Repository: torquem-ch/silkworm Branch: master Commit: aeb2302151d9 Files: 1817 Total size: 62.5 MB Directory structure: gitextract_1pxu9kf7/ ├── .circleci/ │ └── config.yml ├── .clang-format ├── .clang-tidy ├── .dockerignore ├── .editorconfig ├── .git-blame-ignore-revs ├── .github/ │ ├── actions/ │ │ ├── fuzzer-common-steps/ │ │ │ └── action.yml │ │ └── perf-common-steps/ │ │ └── action.yml │ └── workflows/ │ ├── execution-test.yml │ ├── macOS.yml │ ├── rpc-fuzzer-tests.yml │ ├── rpc-integration-tests.yml │ ├── rpc-performance-tests-light.yml │ ├── rpc-performance-tests.yml │ ├── run_integration_tests.sh │ ├── snapshot-test.yml │ ├── start_integration_rpcdaemon.sh │ ├── stop_integration_rpcdaemon.sh │ └── windows.yml ├── .gitignore ├── .gitmodules ├── AUTHORS ├── CMakeLists.txt ├── CMakeSettings.json ├── LICENSE ├── Makefile ├── README.md ├── cmake/ │ ├── cmake_format.cmake │ ├── cmake_format.yaml │ ├── common/ │ │ ├── get_all_targets.cmake │ │ └── targets.cmake │ ├── compiler_settings.cmake │ ├── compiler_settings_sanitize.cmake │ ├── compiler_warnings.cmake │ ├── conan.cmake │ ├── conan_quiet.cmake │ ├── conan_quiet.sh │ ├── copyright.cmake │ ├── format.cmake │ ├── parallel_jobs_count.sh │ ├── profiles/ │ │ ├── experimental/ │ │ │ ├── linux_arm64_gcc_12_debug │ │ │ ├── linux_arm64_gcc_12_release │ │ │ ├── linux_x64_gcc_12_debug │ │ │ ├── linux_x64_gcc_12_release │ │ │ ├── macos_arm64_clang_14_debug │ │ │ ├── macos_arm64_clang_14_release │ │ │ ├── macos_x64_clang_14_debug │ │ │ ├── macos_x64_clang_14_release │ │ │ └── readme.txt │ │ ├── linux_x64_clang_16_debug │ │ ├── linux_x64_clang_16_release │ │ ├── linux_x64_gcc_11_debug │ │ ├── linux_x64_gcc_11_release │ │ ├── macos_arm64_clang_13_debug │ │ ├── macos_arm64_clang_13_release │ │ ├── macos_x64_clang_13_debug │ │ ├── macos_x64_clang_13_release │ │ ├── wasi_release │ │ ├── windows_msvc_193_debug │ │ └── windows_msvc_193_release │ ├── run_smoke_tests.cmake │ ├── run_smoke_tests.sh │ ├── run_unit_tests.cmake │ ├── run_unit_tests.sh │ ├── setup/ │ │ └── compiler_install.sh │ └── toolchain/ │ ├── clang_libcxx.cmake │ ├── cxx20.cmake │ └── wasi.cmake ├── cmd/ │ ├── CMakeLists.txt │ ├── benchmark/ │ │ ├── CMakeLists.txt │ │ └── benchmark_test.cpp │ ├── rpcdaemon.cpp │ ├── sentry.cpp │ ├── silkworm.cpp │ └── test/ │ ├── CMakeLists.txt │ ├── address_sanitizer_fix.hpp │ ├── backend_kv_test.cpp │ ├── ethereum.cpp │ ├── fuzzer_diagnostics.cpp │ ├── fuzzer_test.cpp │ └── sentry_client_test.cpp ├── codecov.yml ├── conanfile.py ├── docs/ │ ├── CONTRIBUTING.md │ ├── JSON-RPC-API.md │ ├── code_style.md │ ├── conan.md │ ├── db_toolbox.md │ ├── dev_tools.md │ └── fuzzer.md ├── examples/ │ ├── CMakeLists.txt │ └── get_latest_block.cpp ├── silkworm/ │ ├── CMakeLists.txt │ ├── capi/ │ │ ├── CMakeLists.txt │ │ ├── cli/ │ │ │ ├── CMakeLists.txt │ │ │ ├── execute.cpp │ │ │ ├── main.c │ │ │ └── sample-go-client/ │ │ │ ├── README.md │ │ │ └── main.go │ │ ├── common/ │ │ │ ├── CMakeLists.txt │ │ │ ├── common_component.hpp │ │ │ ├── errors.h │ │ │ ├── instance.hpp │ │ │ ├── parse_path.cpp │ │ │ ├── parse_path.hpp │ │ │ └── preamble.h │ │ ├── init.cpp │ │ ├── init.h │ │ ├── instance.cpp │ │ ├── instance.hpp │ │ ├── log_level.h │ │ ├── make_log_settings.cpp │ │ ├── make_log_settings.hpp │ │ ├── silkworm.cpp │ │ ├── silkworm.h │ │ └── silkworm_test.cpp │ ├── core/ │ │ ├── CMakeLists.txt │ │ ├── chain/ │ │ │ ├── config.cpp │ │ │ ├── config.hpp │ │ │ ├── config_test.cpp │ │ │ ├── dao.cpp │ │ │ ├── dao.hpp │ │ │ ├── genesis.cpp │ │ │ ├── genesis.hpp │ │ │ ├── genesis_amoy.cpp │ │ │ ├── genesis_amoy.hpp │ │ │ ├── genesis_amoy.json │ │ │ ├── genesis_bor_mainnet.cpp │ │ │ ├── genesis_bor_mainnet.hpp │ │ │ ├── genesis_bor_mainnet.json │ │ │ ├── genesis_holesky.cpp │ │ │ ├── genesis_holesky.hpp │ │ │ ├── genesis_holesky.json │ │ │ ├── genesis_mainnet.cpp │ │ │ ├── genesis_mainnet.hpp │ │ │ ├── genesis_mainnet.json │ │ │ ├── genesis_sepolia.cpp │ │ │ ├── genesis_sepolia.hpp │ │ │ ├── genesis_sepolia.json │ │ │ └── genesis_test.cpp │ │ ├── common/ │ │ │ ├── assert.cpp │ │ │ ├── assert.hpp │ │ │ ├── base.hpp │ │ │ ├── block_cache.hpp │ │ │ ├── block_cache_test.cpp │ │ │ ├── bytes.hpp │ │ │ ├── bytes_test.cpp │ │ │ ├── bytes_to_string.hpp │ │ │ ├── decoding_result.hpp │ │ │ ├── empty_hashes.hpp │ │ │ ├── empty_hashes_test.cpp │ │ │ ├── endian.cpp │ │ │ ├── endian.hpp │ │ │ ├── endian_test.cpp │ │ │ ├── hash_maps.hpp │ │ │ ├── lru_cache.hpp │ │ │ ├── lru_cache_test.cpp │ │ │ ├── math.hpp │ │ │ ├── math_test.cpp │ │ │ ├── object_pool.hpp │ │ │ ├── overloaded.hpp │ │ │ ├── random_number.hpp │ │ │ ├── random_number_test.cpp │ │ │ ├── small_map.hpp │ │ │ ├── small_map_test.cpp │ │ │ ├── test_util.cpp │ │ │ ├── test_util.hpp │ │ │ ├── util.cpp │ │ │ ├── util.hpp │ │ │ └── util_test.cpp │ │ ├── concurrency/ │ │ │ └── resettable_once_flag.hpp │ │ ├── crypto/ │ │ │ ├── ecdsa.c │ │ │ ├── ecdsa.h │ │ │ ├── secp256k1n.cpp │ │ │ ├── secp256k1n.hpp │ │ │ └── secp256k1n_test.cpp │ │ ├── execution/ │ │ │ ├── call_tracer.cpp │ │ │ ├── call_tracer.hpp │ │ │ ├── evm.cpp │ │ │ ├── evm.hpp │ │ │ ├── evm_test.cpp │ │ │ ├── execution.hpp │ │ │ ├── execution_test.cpp │ │ │ ├── precompile.cpp │ │ │ ├── precompile.hpp │ │ │ ├── precompile_benchmark.cpp │ │ │ ├── precompile_test.cpp │ │ │ ├── processor.cpp │ │ │ ├── processor.hpp │ │ │ └── processor_test.cpp │ │ ├── protocol/ │ │ │ ├── blockchain.cpp │ │ │ ├── blockchain.hpp │ │ │ ├── bor/ │ │ │ │ ├── config.cpp │ │ │ │ ├── config.hpp │ │ │ │ ├── config_test.cpp │ │ │ │ ├── span.cpp │ │ │ │ ├── span.hpp │ │ │ │ └── span_test.cpp │ │ │ ├── bor_rule_set.cpp │ │ │ ├── bor_rule_set.hpp │ │ │ ├── ethash_config.cpp │ │ │ ├── ethash_config.hpp │ │ │ ├── ethash_rule_set.cpp │ │ │ ├── ethash_rule_set.hpp │ │ │ ├── ethash_rule_set_test.cpp │ │ │ ├── intrinsic_gas.cpp │ │ │ ├── intrinsic_gas.hpp │ │ │ ├── intrinsic_gas_test.cpp │ │ │ ├── merge_rule_set.cpp │ │ │ ├── merge_rule_set.hpp │ │ │ ├── merge_rule_set_test.cpp │ │ │ ├── param.hpp │ │ │ ├── rule_set.cpp │ │ │ ├── rule_set.hpp │ │ │ ├── rule_set_test.cpp │ │ │ ├── validation.cpp │ │ │ ├── validation.hpp │ │ │ └── validation_test.cpp │ │ ├── rlp/ │ │ │ ├── decode.cpp │ │ │ ├── decode.hpp │ │ │ ├── decode_test.cpp │ │ │ ├── decode_vector.hpp │ │ │ ├── encode.cpp │ │ │ ├── encode.hpp │ │ │ ├── encode_test.cpp │ │ │ └── encode_vector.hpp │ │ ├── state/ │ │ │ ├── block_state.hpp │ │ │ ├── delta.cpp │ │ │ ├── delta.hpp │ │ │ ├── in_memory_state.cpp │ │ │ ├── in_memory_state.hpp │ │ │ ├── intra_block_state.cpp │ │ │ ├── intra_block_state.hpp │ │ │ ├── intra_block_state_test.cpp │ │ │ ├── object.hpp │ │ │ └── state.hpp │ │ ├── test_util/ │ │ │ ├── null_stream.hpp │ │ │ └── sample_blocks.hpp │ │ ├── trie/ │ │ │ ├── hash_builder.cpp │ │ │ ├── hash_builder.hpp │ │ │ ├── hash_builder_test.cpp │ │ │ ├── nibbles.cpp │ │ │ ├── nibbles.hpp │ │ │ ├── nibbles_test.cpp │ │ │ ├── node.cpp │ │ │ ├── node.hpp │ │ │ ├── node_test.cpp │ │ │ ├── prefix_set.cpp │ │ │ ├── prefix_set.hpp │ │ │ ├── prefix_set_test.cpp │ │ │ ├── vector_root.hpp │ │ │ └── vector_root_test.cpp │ │ └── types/ │ │ ├── account.cpp │ │ ├── account.hpp │ │ ├── address.cpp │ │ ├── address.hpp │ │ ├── address_test.cpp │ │ ├── block.cpp │ │ ├── block.hpp │ │ ├── block_body_for_storage.hpp │ │ ├── block_body_for_storage_test.cpp │ │ ├── block_id.hpp │ │ ├── block_test.cpp │ │ ├── bloom.cpp │ │ ├── bloom.hpp │ │ ├── bloom_test.cpp │ │ ├── call_traces.hpp │ │ ├── chain_head.hpp │ │ ├── eip_7685_requests.cpp │ │ ├── eip_7685_requests.hpp │ │ ├── eip_7685_requests_test.cpp │ │ ├── evmc_bytes32.cpp │ │ ├── evmc_bytes32.hpp │ │ ├── hash.hpp │ │ ├── hash_test.cpp │ │ ├── log.cpp │ │ ├── log.hpp │ │ ├── log_test.cpp │ │ ├── receipt.cpp │ │ ├── receipt.hpp │ │ ├── transaction.cpp │ │ ├── transaction.hpp │ │ ├── transaction_test.cpp │ │ ├── withdrawal.cpp │ │ ├── withdrawal.hpp │ │ ├── withdrawal_test.cpp │ │ ├── y_parity_and_chain_id.cpp │ │ ├── y_parity_and_chain_id.hpp │ │ └── y_parity_and_chain_id_test.cpp │ ├── db/ │ │ ├── CMakeLists.txt │ │ ├── access_layer.cpp │ │ ├── access_layer.hpp │ │ ├── access_layer_test.cpp │ │ ├── bitmap_test.cpp │ │ ├── blocks/ │ │ │ ├── blocks_index_builders_factory.cpp │ │ │ ├── blocks_index_builders_factory.hpp │ │ │ ├── bodies/ │ │ │ │ ├── body_index.cpp │ │ │ │ ├── body_index.hpp │ │ │ │ ├── body_queries.hpp │ │ │ │ ├── body_segment.cpp │ │ │ │ ├── body_segment.hpp │ │ │ │ ├── body_segment_collation.cpp │ │ │ │ ├── body_segment_collation.hpp │ │ │ │ ├── body_txs_amount_query.cpp │ │ │ │ ├── body_txs_amount_query.hpp │ │ │ │ └── body_txs_amount_query_test.cpp │ │ │ ├── headers/ │ │ │ │ ├── header_index.cpp │ │ │ │ ├── header_index.hpp │ │ │ │ ├── header_queries.hpp │ │ │ │ ├── header_segment.cpp │ │ │ │ ├── header_segment.hpp │ │ │ │ ├── header_segment_collation.cpp │ │ │ │ └── header_segment_collation.hpp │ │ │ ├── schema_config.cpp │ │ │ ├── schema_config.hpp │ │ │ ├── step_block_num_converter.hpp │ │ │ └── transactions/ │ │ │ ├── txn_index.cpp │ │ │ ├── txn_index.hpp │ │ │ ├── txn_queries.hpp │ │ │ ├── txn_segment.hpp │ │ │ ├── txn_segment_collation.cpp │ │ │ ├── txn_segment_collation.hpp │ │ │ ├── txn_segment_word_codec.cpp │ │ │ ├── txn_segment_word_codec.hpp │ │ │ ├── txn_to_block_index.cpp │ │ │ ├── txn_to_block_index.hpp │ │ │ ├── txs_and_bodies_query.cpp │ │ │ └── txs_and_bodies_query.hpp │ │ ├── buffer.cpp │ │ ├── buffer.hpp │ │ ├── buffer_test.cpp │ │ ├── capi/ │ │ │ ├── component.hpp │ │ │ ├── db.cpp │ │ │ └── db.h │ │ ├── chain/ │ │ │ ├── chain_storage.hpp │ │ │ ├── local_chain_storage.cpp │ │ │ ├── local_chain_storage.hpp │ │ │ ├── providers.hpp │ │ │ ├── remote_chain_storage.cpp │ │ │ ├── remote_chain_storage.hpp │ │ │ └── remote_chain_storage_test.cpp │ │ ├── chain_data_init.cpp │ │ ├── chain_data_init.hpp │ │ ├── chain_head.cpp │ │ ├── chain_head.hpp │ │ ├── cli/ │ │ │ ├── CMakeLists.txt │ │ │ ├── check_blockhashes.cpp │ │ │ ├── check_changes.cpp │ │ │ ├── check_hashstate.cpp │ │ │ ├── check_log_indices.cpp │ │ │ ├── check_senders.cpp │ │ │ ├── check_tx_lookup.cpp │ │ │ ├── db_max_readers_option.cpp │ │ │ ├── db_max_readers_option.hpp │ │ │ ├── db_toolbox.cpp │ │ │ ├── scan_txs.cpp │ │ │ ├── snapshot_options.cpp │ │ │ ├── snapshot_options.hpp │ │ │ └── snapshots.cpp │ │ ├── data_store.cpp │ │ ├── data_store.hpp │ │ ├── datastore/ │ │ │ ├── CMakeLists.txt │ │ │ ├── common/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── dummy.cpp │ │ │ │ ├── entity_name.cpp │ │ │ │ ├── entity_name.hpp │ │ │ │ ├── pair_get.hpp │ │ │ │ ├── ranges/ │ │ │ │ │ ├── caching_view.hpp │ │ │ │ │ ├── concat_view.hpp │ │ │ │ │ ├── concat_view_test.cpp │ │ │ │ │ ├── if_view.hpp │ │ │ │ │ ├── lazy_view.hpp │ │ │ │ │ ├── merge_compare_func.hpp │ │ │ │ │ ├── merge_many_view.hpp │ │ │ │ │ ├── merge_many_view_test.cpp │ │ │ │ │ ├── merge_unique_view.hpp │ │ │ │ │ ├── merge_unique_view_test.cpp │ │ │ │ │ ├── merge_view.hpp │ │ │ │ │ ├── merge_view_test.cpp │ │ │ │ │ ├── owning_view.hpp │ │ │ │ │ ├── unique_view.hpp │ │ │ │ │ └── vector_from_range.hpp │ │ │ │ ├── step.hpp │ │ │ │ ├── step_test.cpp │ │ │ │ ├── step_timestamp_converter.cpp │ │ │ │ ├── step_timestamp_converter.hpp │ │ │ │ ├── step_timestamp_converter_test.cpp │ │ │ │ └── timestamp.hpp │ │ │ ├── data_migration.cpp │ │ │ ├── data_migration.hpp │ │ │ ├── data_migration_command.hpp │ │ │ ├── data_store.hpp │ │ │ ├── domain_get_as_of_query.hpp │ │ │ ├── domain_get_latest_query.hpp │ │ │ ├── domain_range_as_of_query.hpp │ │ │ ├── domain_range_latest_query.hpp │ │ │ ├── etl/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── buffer.hpp │ │ │ │ ├── collector.cpp │ │ │ │ ├── collector.hpp │ │ │ │ ├── collector_settings.hpp │ │ │ │ ├── file_provider.cpp │ │ │ │ ├── file_provider.hpp │ │ │ │ ├── in_memory_collector.hpp │ │ │ │ ├── util.hpp │ │ │ │ └── util_test.cpp │ │ │ ├── history_get_query.hpp │ │ │ ├── history_range_by_keys_query.hpp │ │ │ ├── history_range_in_period_query.hpp │ │ │ ├── inverted_index_range_by_key_query.hpp │ │ │ ├── kvdb/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── big_endian_codec.cpp │ │ │ │ ├── big_endian_codec.hpp │ │ │ │ ├── bitmap.cpp │ │ │ │ ├── bitmap.hpp │ │ │ │ ├── codec.hpp │ │ │ │ ├── cursor_iterator.cpp │ │ │ │ ├── cursor_iterator.hpp │ │ │ │ ├── database.cpp │ │ │ │ ├── database.hpp │ │ │ │ ├── domain.hpp │ │ │ │ ├── domain_codecs.hpp │ │ │ │ ├── domain_delete_query.hpp │ │ │ │ ├── domain_get_latest_query.hpp │ │ │ │ ├── domain_get_latest_query_test.cpp │ │ │ │ ├── domain_put_latest_query.hpp │ │ │ │ ├── domain_put_query.hpp │ │ │ │ ├── domain_queries.hpp │ │ │ │ ├── domain_range_latest_query.hpp │ │ │ │ ├── domain_range_latest_query_test.cpp │ │ │ │ ├── etl_mdbx_collector.hpp │ │ │ │ ├── history.hpp │ │ │ │ ├── history_codecs.hpp │ │ │ │ ├── history_delete_query.hpp │ │ │ │ ├── history_get_query.hpp │ │ │ │ ├── history_get_query_test.cpp │ │ │ │ ├── history_put_query.hpp │ │ │ │ ├── history_queries.hpp │ │ │ │ ├── history_range_by_keys_query.hpp │ │ │ │ ├── history_range_by_keys_query_test.cpp │ │ │ │ ├── history_range_in_period_query.hpp │ │ │ │ ├── history_range_in_period_query_test.cpp │ │ │ │ ├── inverted_index.hpp │ │ │ │ ├── inverted_index_put_query.hpp │ │ │ │ ├── inverted_index_queries.hpp │ │ │ │ ├── inverted_index_range_by_key_query.hpp │ │ │ │ ├── inverted_index_range_by_key_query_test.cpp │ │ │ │ ├── kvts_codec.hpp │ │ │ │ ├── mdbx.cpp │ │ │ │ ├── mdbx.hpp │ │ │ │ ├── mdbx_test.cpp │ │ │ │ ├── mdbx_version.cpp │ │ │ │ ├── mdbx_version.hpp │ │ │ │ ├── memory_mutation.cpp │ │ │ │ ├── memory_mutation.hpp │ │ │ │ ├── memory_mutation_cursor.cpp │ │ │ │ ├── memory_mutation_cursor.hpp │ │ │ │ ├── memory_mutation_test.cpp │ │ │ │ ├── query_test.hpp │ │ │ │ ├── raw_codec.hpp │ │ │ │ ├── schema.cpp │ │ │ │ ├── schema.hpp │ │ │ │ └── timestamp_codec.hpp │ │ │ ├── schema.hpp │ │ │ ├── segment_collation.hpp │ │ │ ├── snapshot_merger.cpp │ │ │ ├── snapshot_merger.hpp │ │ │ ├── snapshots/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── basic_queries.hpp │ │ │ │ ├── bittorrent/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── client.cpp │ │ │ │ │ ├── client.hpp │ │ │ │ │ ├── client_test.cpp │ │ │ │ │ ├── root_certificates.hpp │ │ │ │ │ ├── root_certificates_test.cpp │ │ │ │ │ ├── settings.hpp │ │ │ │ │ ├── torrent_file.cpp │ │ │ │ │ ├── torrent_file.hpp │ │ │ │ │ ├── torrent_file_test.cpp │ │ │ │ │ ├── trackers.cpp │ │ │ │ │ ├── trackers.hpp │ │ │ │ │ ├── web_seed_client.cpp │ │ │ │ │ ├── web_seed_client.hpp │ │ │ │ │ ├── web_seed_client_test.cpp │ │ │ │ │ ├── web_session.cpp │ │ │ │ │ ├── web_session.hpp │ │ │ │ │ └── web_session_test.cpp │ │ │ │ ├── bloom_filter/ │ │ │ │ │ ├── bloom_filter.cpp │ │ │ │ │ ├── bloom_filter.hpp │ │ │ │ │ └── bloom_filter_test.cpp │ │ │ │ ├── btree/ │ │ │ │ │ ├── btree.cpp │ │ │ │ │ ├── btree.hpp │ │ │ │ │ ├── btree_index.cpp │ │ │ │ │ ├── btree_index.hpp │ │ │ │ │ └── btree_index_test.cpp │ │ │ │ ├── common/ │ │ │ │ │ ├── codec.hpp │ │ │ │ │ ├── encoding/ │ │ │ │ │ │ ├── murmur_hash3.cpp │ │ │ │ │ │ ├── murmur_hash3.hpp │ │ │ │ │ │ ├── murmur_hash3_test.cpp │ │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ │ ├── sequence_test.cpp │ │ │ │ │ │ └── util.hpp │ │ │ │ │ ├── key_hasher.cpp │ │ │ │ │ ├── key_hasher.hpp │ │ │ │ │ ├── key_hasher_test.cpp │ │ │ │ │ ├── raw_codec.hpp │ │ │ │ │ ├── snapshot_path.cpp │ │ │ │ │ ├── snapshot_path.hpp │ │ │ │ │ ├── snapshot_path_test.cpp │ │ │ │ │ └── util/ │ │ │ │ │ ├── bitmask_operators.hpp │ │ │ │ │ └── iterator/ │ │ │ │ │ ├── index_range.hpp │ │ │ │ │ ├── iterator_read_into_vector.hpp │ │ │ │ │ ├── list_iterator.hpp │ │ │ │ │ └── map_values_view.hpp │ │ │ │ ├── config/ │ │ │ │ │ ├── chains/ │ │ │ │ │ │ ├── amoy.hpp │ │ │ │ │ │ ├── bor_mainnet.hpp │ │ │ │ │ │ ├── holesky.hpp │ │ │ │ │ │ ├── mainnet.hpp │ │ │ │ │ │ └── sepolia.hpp │ │ │ │ │ ├── config.cpp │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── config_test.cpp │ │ │ │ │ └── entry.hpp │ │ │ │ ├── domain.hpp │ │ │ │ ├── domain_get_latest_query.hpp │ │ │ │ ├── domain_queries.hpp │ │ │ │ ├── domain_range_latest_query.hpp │ │ │ │ ├── elias_fano/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── double_elias_fano_list.cpp │ │ │ │ │ ├── double_elias_fano_list.hpp │ │ │ │ │ ├── double_elias_fano_list_test.cpp │ │ │ │ │ ├── elias_fano_common.hpp │ │ │ │ │ ├── elias_fano_list.cpp │ │ │ │ │ ├── elias_fano_list.hpp │ │ │ │ │ ├── elias_fano_list_test.cpp │ │ │ │ │ └── list_iterator.hpp │ │ │ │ ├── history.hpp │ │ │ │ ├── history_accessor_index.hpp │ │ │ │ ├── history_get_query.hpp │ │ │ │ ├── history_queries.hpp │ │ │ │ ├── history_range_by_keys_query.hpp │ │ │ │ ├── history_range_in_period_query.hpp │ │ │ │ ├── index_builder.cpp │ │ │ │ ├── index_builder.hpp │ │ │ │ ├── index_builders_factory.cpp │ │ │ │ ├── index_builders_factory.hpp │ │ │ │ ├── index_salt_file.cpp │ │ │ │ ├── index_salt_file.hpp │ │ │ │ ├── inverted_index.hpp │ │ │ │ ├── inverted_index_find_by_key_segment_query.hpp │ │ │ │ ├── inverted_index_lower_bound_key_offset_segment_query.cpp │ │ │ │ ├── inverted_index_lower_bound_key_offset_segment_query.hpp │ │ │ │ ├── inverted_index_queries.hpp │ │ │ │ ├── inverted_index_range_by_key_query.hpp │ │ │ │ ├── inverted_index_seek_query.hpp │ │ │ │ ├── inverted_index_ts_list.cpp │ │ │ │ ├── inverted_index_ts_list.hpp │ │ │ │ ├── inverted_index_ts_list_codec.cpp │ │ │ │ ├── inverted_index_ts_list_codec.hpp │ │ │ │ ├── query_cache.hpp │ │ │ │ ├── query_caches.cpp │ │ │ │ ├── query_caches.hpp │ │ │ │ ├── query_caches_schema.hpp │ │ │ │ ├── rec_split/ │ │ │ │ │ ├── accessor_index.hpp │ │ │ │ │ ├── golomb_rice.hpp │ │ │ │ │ ├── golomb_rice_test.cpp │ │ │ │ │ ├── rec_split.cpp │ │ │ │ │ ├── rec_split.hpp │ │ │ │ │ ├── rec_split_par.hpp │ │ │ │ │ ├── rec_split_par_test.cpp │ │ │ │ │ ├── rec_split_seq.hpp │ │ │ │ │ ├── rec_split_seq_test.cpp │ │ │ │ │ └── test_util/ │ │ │ │ │ └── xoroshiro128pp.hpp │ │ │ │ ├── schema.cpp │ │ │ │ ├── schema.hpp │ │ │ │ ├── segment/ │ │ │ │ │ ├── kv_segment_reader.cpp │ │ │ │ │ ├── kv_segment_reader.hpp │ │ │ │ │ ├── kv_segment_test.cpp │ │ │ │ │ ├── kv_segment_writer.cpp │ │ │ │ │ ├── kv_segment_writer.hpp │ │ │ │ │ ├── seg/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── common/ │ │ │ │ │ │ │ ├── varint.cpp │ │ │ │ │ │ │ ├── varint.hpp │ │ │ │ │ │ │ └── varint_test.cpp │ │ │ │ │ │ ├── compression_kind.hpp │ │ │ │ │ │ ├── compressor/ │ │ │ │ │ │ │ ├── bit_stream.cpp │ │ │ │ │ │ │ ├── bit_stream.hpp │ │ │ │ │ │ │ ├── bit_stream_test.cpp │ │ │ │ │ │ │ ├── huffman_code.cpp │ │ │ │ │ │ │ ├── huffman_code.hpp │ │ │ │ │ │ │ ├── huffman_code_test.cpp │ │ │ │ │ │ │ ├── intermediate_compressed_stream.cpp │ │ │ │ │ │ │ ├── intermediate_compressed_stream.hpp │ │ │ │ │ │ │ ├── intermediate_compressed_stream_test.cpp │ │ │ │ │ │ │ ├── lcp_kasai.cpp │ │ │ │ │ │ │ ├── lcp_kasai.hpp │ │ │ │ │ │ │ ├── output_file_transaction.cpp │ │ │ │ │ │ │ ├── output_file_transaction.hpp │ │ │ │ │ │ │ ├── patricia_tree.cpp │ │ │ │ │ │ │ ├── patricia_tree.hpp │ │ │ │ │ │ │ ├── patricia_tree_test.cpp │ │ │ │ │ │ │ ├── pattern_aggregator.cpp │ │ │ │ │ │ │ ├── pattern_aggregator.hpp │ │ │ │ │ │ │ ├── pattern_aggregator_test.cpp │ │ │ │ │ │ │ ├── pattern_covering.cpp │ │ │ │ │ │ │ ├── pattern_covering.hpp │ │ │ │ │ │ │ ├── pattern_covering_test.cpp │ │ │ │ │ │ │ ├── pattern_extractor.cpp │ │ │ │ │ │ │ ├── pattern_extractor.hpp │ │ │ │ │ │ │ ├── pattern_extractor_test.cpp │ │ │ │ │ │ │ ├── positions_map.cpp │ │ │ │ │ │ │ ├── positions_map.hpp │ │ │ │ │ │ │ ├── raw_words_stream.cpp │ │ │ │ │ │ │ ├── raw_words_stream.hpp │ │ │ │ │ │ │ ├── raw_words_stream_test.cpp │ │ │ │ │ │ │ ├── seg_stream.cpp │ │ │ │ │ │ │ └── seg_stream.hpp │ │ │ │ │ │ ├── compressor.cpp │ │ │ │ │ │ ├── compressor.hpp │ │ │ │ │ │ ├── decompressor.cpp │ │ │ │ │ │ ├── decompressor.hpp │ │ │ │ │ │ ├── seg_zip.cpp │ │ │ │ │ │ └── seg_zip.hpp │ │ │ │ │ ├── segment_reader.cpp │ │ │ │ │ ├── segment_reader.hpp │ │ │ │ │ ├── segment_test.cpp │ │ │ │ │ ├── segment_writer.cpp │ │ │ │ │ └── segment_writer.hpp │ │ │ │ ├── segment_and_accessor_index.hpp │ │ │ │ ├── snapshot_bundle.cpp │ │ │ │ ├── snapshot_bundle.hpp │ │ │ │ ├── snapshot_repository.cpp │ │ │ │ ├── snapshot_repository.hpp │ │ │ │ ├── snapshot_repository_ro_access.hpp │ │ │ │ ├── snapshot_settings.hpp │ │ │ │ ├── snapshot_size.hpp │ │ │ │ └── test_util/ │ │ │ │ ├── sample_bloom_filter_data.hpp │ │ │ │ └── string_codec.hpp │ │ │ └── stage_scheduler.hpp │ │ ├── db_utils.cpp │ │ ├── db_utils.hpp │ │ ├── db_utils_test.cpp │ │ ├── etl_collector_test.cpp │ │ ├── etl_in_memory_collector_test.cpp │ │ ├── freezer.cpp │ │ ├── freezer.hpp │ │ ├── genesis.cpp │ │ ├── genesis.hpp │ │ ├── genesis_test.cpp │ │ ├── kv/ │ │ │ ├── api/ │ │ │ │ ├── as_datastore_ts_range.cpp │ │ │ │ ├── as_datastore_ts_range.hpp │ │ │ │ ├── as_datastore_ts_range_test.cpp │ │ │ │ ├── base_transaction.cpp │ │ │ │ ├── base_transaction.hpp │ │ │ │ ├── client.hpp │ │ │ │ ├── cursor.hpp │ │ │ │ ├── direct_client.cpp │ │ │ │ ├── direct_client.hpp │ │ │ │ ├── direct_service.cpp │ │ │ │ ├── direct_service.hpp │ │ │ │ ├── direct_service_test.cpp │ │ │ │ ├── endpoint/ │ │ │ │ │ ├── common.hpp │ │ │ │ │ ├── key_value.hpp │ │ │ │ │ ├── paginated_sequence.hpp │ │ │ │ │ ├── paginated_sequence_benchmark.cpp │ │ │ │ │ ├── paginated_sequence_test.cpp │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ ├── state_change.hpp │ │ │ │ │ ├── state_changes_call.hpp │ │ │ │ │ ├── state_changes_call_test.cpp │ │ │ │ │ ├── temporal_point.hpp │ │ │ │ │ ├── temporal_range.hpp │ │ │ │ │ └── version.hpp │ │ │ │ ├── local_cursor.cpp │ │ │ │ ├── local_cursor.hpp │ │ │ │ ├── local_cursor_test.cpp │ │ │ │ ├── local_transaction.cpp │ │ │ │ ├── local_transaction.hpp │ │ │ │ ├── service.hpp │ │ │ │ ├── service_router.cpp │ │ │ │ ├── service_router.hpp │ │ │ │ ├── state_cache.cpp │ │ │ │ ├── state_cache.hpp │ │ │ │ ├── state_cache_test.cpp │ │ │ │ └── transaction.hpp │ │ │ ├── grpc/ │ │ │ │ ├── client/ │ │ │ │ │ ├── endpoint/ │ │ │ │ │ │ ├── state_change.cpp │ │ │ │ │ │ ├── state_change.hpp │ │ │ │ │ │ ├── temporal_point.cpp │ │ │ │ │ │ ├── temporal_point.hpp │ │ │ │ │ │ ├── temporal_point_test.cpp │ │ │ │ │ │ ├── temporal_range.cpp │ │ │ │ │ │ ├── temporal_range.hpp │ │ │ │ │ │ └── temporal_range_test.cpp │ │ │ │ │ ├── remote_client.cpp │ │ │ │ │ ├── remote_client.hpp │ │ │ │ │ ├── remote_client_test.cpp │ │ │ │ │ ├── remote_cursor.cpp │ │ │ │ │ ├── remote_cursor.hpp │ │ │ │ │ ├── remote_cursor_test.cpp │ │ │ │ │ ├── remote_transaction.cpp │ │ │ │ │ ├── remote_transaction.hpp │ │ │ │ │ ├── remote_transaction_test.cpp │ │ │ │ │ └── rpc.hpp │ │ │ │ ├── server/ │ │ │ │ │ ├── kv_calls.cpp │ │ │ │ │ ├── kv_calls.hpp │ │ │ │ │ ├── kv_calls_test.cpp │ │ │ │ │ ├── kv_server.cpp │ │ │ │ │ ├── kv_server.hpp │ │ │ │ │ ├── kv_server_test.cpp │ │ │ │ │ ├── state_change_collection.cpp │ │ │ │ │ ├── state_change_collection.hpp │ │ │ │ │ └── state_change_collection_test.cpp │ │ │ │ └── test_util/ │ │ │ │ └── sample_protos.hpp │ │ │ ├── state_changes_stream.cpp │ │ │ ├── state_changes_stream.hpp │ │ │ ├── state_changes_stream_test.cpp │ │ │ ├── state_reader.cpp │ │ │ ├── state_reader.hpp │ │ │ ├── state_reader_test.cpp │ │ │ ├── txn_num.cpp │ │ │ ├── txn_num.hpp │ │ │ └── txn_num_test.cpp │ │ ├── log_cbor.cpp │ │ ├── log_cbor.hpp │ │ ├── log_cbor_test.cpp │ │ ├── mdbx_test.cpp │ │ ├── memory_mutation_cursor_test.cpp │ │ ├── prune_mode.cpp │ │ ├── prune_mode.hpp │ │ ├── receipt_cbor.cpp │ │ ├── receipt_cbor.hpp │ │ ├── receipt_cbor_test.cpp │ │ ├── snapshot_benchmark.cpp │ │ ├── snapshot_decompressor_test.cpp │ │ ├── snapshot_index_builder_test.cpp │ │ ├── snapshot_recompress.cpp │ │ ├── snapshot_recompress.hpp │ │ ├── snapshot_repository_test.cpp │ │ ├── snapshot_sync.cpp │ │ ├── snapshot_sync.hpp │ │ ├── snapshot_sync_test.cpp │ │ ├── snapshot_test.cpp │ │ ├── stage.cpp │ │ ├── stage.hpp │ │ ├── stages.cpp │ │ ├── stages.hpp │ │ ├── state/ │ │ │ ├── account_codec.cpp │ │ │ ├── account_codec.hpp │ │ │ ├── account_codec_test.cpp │ │ │ ├── account_codecs.hpp │ │ │ ├── account_codecs_test.cpp │ │ │ ├── accounts_domain.hpp │ │ │ ├── address_codecs.hpp │ │ │ ├── address_codecs_test.cpp │ │ │ ├── code_domain.hpp │ │ │ ├── commitment_domain.hpp │ │ │ ├── hash_decoder.hpp │ │ │ ├── hash_decoder_test.cpp │ │ │ ├── log_address_inverted_index.hpp │ │ │ ├── log_topics_inverted_index.hpp │ │ │ ├── receipts_domain.hpp │ │ │ ├── receipts_domain_test.cpp │ │ │ ├── schema_config.cpp │ │ │ ├── schema_config.hpp │ │ │ ├── state_index_builders_factory.cpp │ │ │ ├── state_index_builders_factory.hpp │ │ │ ├── step_txn_id_converter.hpp │ │ │ ├── storage_codecs.cpp │ │ │ ├── storage_codecs.hpp │ │ │ ├── storage_codecs_benchmark.cpp │ │ │ ├── storage_domain.hpp │ │ │ ├── storage_domain_test.cpp │ │ │ ├── traces_from_inverted_index.hpp │ │ │ └── traces_to_inverted_index.hpp │ │ ├── tables.cpp │ │ ├── tables.hpp │ │ ├── test_util/ │ │ │ ├── CMakeLists.txt │ │ │ ├── kv_test_base.hpp │ │ │ ├── mock_chain_storage.hpp │ │ │ ├── mock_cursor.hpp │ │ │ ├── mock_ro_cursor.hpp │ │ │ ├── mock_state_cache.hpp │ │ │ ├── mock_transaction.hpp │ │ │ ├── mock_txn.hpp │ │ │ ├── temp_chain_data.cpp │ │ │ ├── temp_chain_data.hpp │ │ │ ├── temp_snapshots.hpp │ │ │ ├── test_database_context.cpp │ │ │ └── test_database_context.hpp │ │ ├── util.cpp │ │ ├── util.hpp │ │ └── util_test.cpp │ ├── dev/ │ │ ├── CMakeLists.txt │ │ ├── cli/ │ │ │ ├── CMakeLists.txt │ │ │ ├── embed_json.cpp │ │ │ ├── embed_toml.cpp │ │ │ ├── kzg_g2_uncompress.cpp │ │ │ ├── runner.cpp │ │ │ ├── state_transition_sample1.json │ │ │ ├── state_transition_sample2.json │ │ │ ├── state_transition_sample3.json │ │ │ └── state_transition_sample4.json │ │ ├── expected_state.cpp │ │ ├── expected_state.hpp │ │ ├── state_transition.cpp │ │ └── state_transition.hpp │ ├── execution/ │ │ ├── CMakeLists.txt │ │ ├── api/ │ │ │ ├── active_direct_service.cpp │ │ │ ├── active_direct_service.hpp │ │ │ ├── client.hpp │ │ │ ├── direct_client.cpp │ │ │ ├── direct_client.hpp │ │ │ ├── direct_service.cpp │ │ │ ├── direct_service.hpp │ │ │ ├── endpoint/ │ │ │ │ ├── assembly.hpp │ │ │ │ ├── block.hpp │ │ │ │ ├── checkers.hpp │ │ │ │ ├── getters.hpp │ │ │ │ ├── insertion.hpp │ │ │ │ ├── range.hpp │ │ │ │ ├── status.hpp │ │ │ │ └── validation.hpp │ │ │ ├── execution_engine.hpp │ │ │ └── service.hpp │ │ ├── block_executor.cpp │ │ ├── block_executor.hpp │ │ ├── domain_state.cpp │ │ ├── domain_state.hpp │ │ ├── domain_state_test.cpp │ │ ├── grpc/ │ │ │ ├── client/ │ │ │ │ ├── endpoint/ │ │ │ │ │ ├── assembly.cpp │ │ │ │ │ ├── assembly.hpp │ │ │ │ │ ├── checkers.cpp │ │ │ │ │ ├── checkers.hpp │ │ │ │ │ ├── checkers_test.cpp │ │ │ │ │ ├── getters.cpp │ │ │ │ │ ├── getters.hpp │ │ │ │ │ ├── getters_test.cpp │ │ │ │ │ ├── insertion.cpp │ │ │ │ │ ├── insertion.hpp │ │ │ │ │ ├── insertion_test.cpp │ │ │ │ │ ├── range.cpp │ │ │ │ │ ├── range.hpp │ │ │ │ │ ├── status.cpp │ │ │ │ │ ├── status.hpp │ │ │ │ │ ├── validation.cpp │ │ │ │ │ └── validation.hpp │ │ │ │ ├── remote_client.cpp │ │ │ │ └── remote_client.hpp │ │ │ ├── common/ │ │ │ │ ├── block.cpp │ │ │ │ ├── block.hpp │ │ │ │ └── block_test.cpp │ │ │ ├── server/ │ │ │ │ ├── endpoint/ │ │ │ │ │ ├── assembly.cpp │ │ │ │ │ ├── assembly.hpp │ │ │ │ │ ├── checkers.cpp │ │ │ │ │ ├── checkers.hpp │ │ │ │ │ ├── checkers_test.cpp │ │ │ │ │ ├── getters.cpp │ │ │ │ │ ├── getters.hpp │ │ │ │ │ ├── getters_test.cpp │ │ │ │ │ ├── insertion.cpp │ │ │ │ │ ├── insertion.hpp │ │ │ │ │ ├── insertion_test.cpp │ │ │ │ │ ├── range.cpp │ │ │ │ │ ├── range.hpp │ │ │ │ │ ├── status.cpp │ │ │ │ │ ├── status.hpp │ │ │ │ │ ├── validation.cpp │ │ │ │ │ └── validation.hpp │ │ │ │ ├── server.cpp │ │ │ │ ├── server.hpp │ │ │ │ ├── server_calls.cpp │ │ │ │ └── server_calls.hpp │ │ │ └── test_util/ │ │ │ └── sample_protos.hpp │ │ ├── local_state.cpp │ │ ├── local_state.hpp │ │ ├── remote_state.cpp │ │ ├── remote_state.hpp │ │ ├── remote_state_test.cpp │ │ ├── state_factory.cpp │ │ └── state_factory.hpp │ ├── infra/ │ │ ├── CMakeLists.txt │ │ ├── cli/ │ │ │ ├── CMakeLists.txt │ │ │ ├── common.cpp │ │ │ ├── common.hpp │ │ │ ├── human_size_option.cpp │ │ │ ├── human_size_option.hpp │ │ │ ├── ip_endpoint_option.cpp │ │ │ ├── ip_endpoint_option.hpp │ │ │ ├── shutdown_signal.cpp │ │ │ └── shutdown_signal.hpp │ │ ├── common/ │ │ │ ├── application_info.cpp │ │ │ ├── application_info.hpp │ │ │ ├── async_binary_search.cpp │ │ │ ├── async_binary_search.hpp │ │ │ ├── async_binary_search_test.cpp │ │ │ ├── binary_search.cpp │ │ │ ├── binary_search.hpp │ │ │ ├── binary_search_test.cpp │ │ │ ├── bounded_buffer.hpp │ │ │ ├── bounded_buffer_test.cpp │ │ │ ├── clock_time.cpp │ │ │ ├── clock_time.hpp │ │ │ ├── clock_time_test.cpp │ │ │ ├── decoding_exception.cpp │ │ │ ├── decoding_exception.hpp │ │ │ ├── directories.cpp │ │ │ ├── directories.hpp │ │ │ ├── directories_test.cpp │ │ │ ├── ensure.hpp │ │ │ ├── ensure_test.cpp │ │ │ ├── environment.cpp │ │ │ ├── environment.hpp │ │ │ ├── environment_test.cpp │ │ │ ├── filesystem.cpp │ │ │ ├── filesystem.hpp │ │ │ ├── log.cpp │ │ │ ├── log.hpp │ │ │ ├── log_test.cpp │ │ │ ├── measure.hpp │ │ │ ├── mem_usage.cpp │ │ │ ├── mem_usage.hpp │ │ │ ├── memory_mapped_file.cpp │ │ │ ├── memory_mapped_file.hpp │ │ │ ├── memory_mapped_file_benchmark.cpp │ │ │ ├── memory_mapped_file_test.cpp │ │ │ ├── os.cpp │ │ │ ├── os.hpp │ │ │ ├── os_test.cpp │ │ │ ├── safe_strerror.cpp │ │ │ ├── safe_strerror.hpp │ │ │ ├── secp256k1_context.cpp │ │ │ ├── secp256k1_context.hpp │ │ │ ├── stopwatch.cpp │ │ │ ├── stopwatch.hpp │ │ │ ├── stopwatch_test.cpp │ │ │ ├── terminal.cpp │ │ │ ├── terminal.hpp │ │ │ ├── timer.cpp │ │ │ ├── timer.hpp │ │ │ ├── timer_test.cpp │ │ │ ├── unix_timestamp.cpp │ │ │ └── unix_timestamp.hpp │ │ ├── concurrency/ │ │ │ ├── active_component.hpp │ │ │ ├── async_thread.cpp │ │ │ ├── async_thread.hpp │ │ │ ├── awaitable_condition_variable.cpp │ │ │ ├── awaitable_condition_variable.hpp │ │ │ ├── awaitable_condition_variable_test.cpp │ │ │ ├── awaitable_future.hpp │ │ │ ├── awaitable_future_test.cpp │ │ │ ├── awaitable_wait_for_all.hpp │ │ │ ├── awaitable_wait_for_one.hpp │ │ │ ├── base_service.hpp │ │ │ ├── cancellation_token.hpp │ │ │ ├── channel.hpp │ │ │ ├── channel_test.cpp │ │ │ ├── containers.hpp │ │ │ ├── context_pool.cpp │ │ │ ├── context_pool.hpp │ │ │ ├── context_pool_settings.hpp │ │ │ ├── context_pool_test.cpp │ │ │ ├── coroutine.hpp │ │ │ ├── coroutine_test.cpp │ │ │ ├── event_notifier.hpp │ │ │ ├── executor_pool.hpp │ │ │ ├── parallel_group_test.cpp │ │ │ ├── parallel_group_utils.cpp │ │ │ ├── parallel_group_utils.hpp │ │ │ ├── private_service.hpp │ │ │ ├── private_service_test.cpp │ │ │ ├── shared_service.hpp │ │ │ ├── shared_service_test.cpp │ │ │ ├── signal_handler.cpp │ │ │ ├── signal_handler.hpp │ │ │ ├── signal_handler_test.cpp │ │ │ ├── sleep.cpp │ │ │ ├── sleep.hpp │ │ │ ├── spawn.hpp │ │ │ ├── spawn_test.cpp │ │ │ ├── stoppable.hpp │ │ │ ├── stoppable_test.cpp │ │ │ ├── task.hpp │ │ │ ├── task_group.cpp │ │ │ ├── task_group.hpp │ │ │ ├── task_group_test.cpp │ │ │ ├── thread_pool.hpp │ │ │ ├── thread_safe_queue.hpp │ │ │ ├── timeout.cpp │ │ │ ├── timeout.hpp │ │ │ └── timeout_test.cpp │ │ ├── grpc/ │ │ │ ├── client/ │ │ │ │ ├── call.hpp │ │ │ │ ├── call_test.cpp │ │ │ │ ├── client_context_pool.cpp │ │ │ │ ├── client_context_pool.hpp │ │ │ │ ├── client_context_pool_test.cpp │ │ │ │ ├── dispatcher.hpp │ │ │ │ ├── error.cpp │ │ │ │ ├── error.hpp │ │ │ │ ├── error_test.cpp │ │ │ │ ├── reconnect.cpp │ │ │ │ └── reconnect.hpp │ │ │ ├── common/ │ │ │ │ ├── bytes.hpp │ │ │ │ ├── completion_tag.hpp │ │ │ │ ├── conversion.cpp │ │ │ │ ├── conversion.hpp │ │ │ │ ├── conversion_test.cpp │ │ │ │ ├── errors.cpp │ │ │ │ ├── errors.hpp │ │ │ │ ├── grpc_context_pool.hpp │ │ │ │ ├── util.hpp │ │ │ │ ├── util_test.cpp │ │ │ │ ├── version.cpp │ │ │ │ ├── version.hpp │ │ │ │ └── version_test.cpp │ │ │ ├── server/ │ │ │ │ ├── call.hpp │ │ │ │ ├── call_test.cpp │ │ │ │ ├── server.hpp │ │ │ │ ├── server_callbacks.hpp │ │ │ │ ├── server_context_pool.cpp │ │ │ │ ├── server_context_pool.hpp │ │ │ │ ├── server_context_pool_test.cpp │ │ │ │ ├── server_settings.hpp │ │ │ │ ├── server_settings_test.cpp │ │ │ │ └── server_test.cpp │ │ │ └── test_util/ │ │ │ ├── grpc_actions.hpp │ │ │ ├── grpc_matcher.hpp │ │ │ ├── grpc_responder.hpp │ │ │ ├── interfaces/ │ │ │ │ ├── ethbackend_mock_fix24351.grpc.pb.h │ │ │ │ ├── kv_mock_fix24351.grpc.pb.h │ │ │ │ ├── mining_mock_fix24351.grpc.pb.h │ │ │ │ └── txpool_mock_fix24351.grpc.pb.h │ │ │ └── test_runner.hpp │ │ └── test_util/ │ │ ├── CMakeLists.txt │ │ ├── context_test_base.cpp │ │ ├── context_test_base.hpp │ │ ├── fixture.hpp │ │ ├── hex.cpp │ │ ├── hex.hpp │ │ ├── log.hpp │ │ ├── task_runner.hpp │ │ └── temporary_file.hpp │ ├── interfaces/ │ │ ├── .gitignore │ │ ├── 27.0/ │ │ │ ├── execution/ │ │ │ │ ├── execution.grpc.pb.cc │ │ │ │ ├── execution.grpc.pb.h │ │ │ │ ├── execution.pb.cc │ │ │ │ ├── execution.pb.h │ │ │ │ └── execution_mock.grpc.pb.h │ │ │ ├── p2psentry/ │ │ │ │ ├── sentry.grpc.pb.cc │ │ │ │ ├── sentry.grpc.pb.h │ │ │ │ ├── sentry.pb.cc │ │ │ │ ├── sentry.pb.h │ │ │ │ └── sentry_mock.grpc.pb.h │ │ │ ├── remote/ │ │ │ │ ├── bor.grpc.pb.cc │ │ │ │ ├── bor.grpc.pb.h │ │ │ │ ├── bor.pb.cc │ │ │ │ ├── bor.pb.h │ │ │ │ ├── bor_mock.grpc.pb.h │ │ │ │ ├── ethbackend.grpc.pb.cc │ │ │ │ ├── ethbackend.grpc.pb.h │ │ │ │ ├── ethbackend.pb.cc │ │ │ │ ├── ethbackend.pb.h │ │ │ │ ├── ethbackend_mock.grpc.pb.h │ │ │ │ ├── kv.grpc.pb.cc │ │ │ │ ├── kv.grpc.pb.h │ │ │ │ ├── kv.pb.cc │ │ │ │ ├── kv.pb.h │ │ │ │ └── kv_mock.grpc.pb.h │ │ │ ├── txpool/ │ │ │ │ ├── mining.grpc.pb.cc │ │ │ │ ├── mining.grpc.pb.h │ │ │ │ ├── mining.pb.cc │ │ │ │ ├── mining.pb.h │ │ │ │ ├── mining_mock.grpc.pb.h │ │ │ │ ├── txpool.grpc.pb.cc │ │ │ │ ├── txpool.grpc.pb.h │ │ │ │ ├── txpool.pb.cc │ │ │ │ ├── txpool.pb.h │ │ │ │ └── txpool_mock.grpc.pb.h │ │ │ └── types/ │ │ │ ├── types.pb.cc │ │ │ └── types.pb.h │ │ ├── CMakeLists.txt │ │ └── generate_grpc.cmake │ ├── node/ │ │ ├── CMakeLists.txt │ │ ├── backend/ │ │ │ ├── ethereum_backend.cpp │ │ │ ├── ethereum_backend.hpp │ │ │ └── ethereum_backend_test.cpp │ │ ├── backend_kv_server.cpp │ │ ├── backend_kv_server.hpp │ │ ├── cli/ │ │ │ ├── CMakeLists.txt │ │ │ ├── backend_kv_server.cpp │ │ │ ├── node_options.cpp │ │ │ ├── node_options.hpp │ │ │ └── staged_pipeline.cpp │ │ ├── common/ │ │ │ └── node_settings.hpp │ │ ├── execution/ │ │ │ ├── active_direct_service_test.cpp │ │ │ ├── direct_service_test.cpp │ │ │ └── header_chain_plus_exec_test.cpp │ │ ├── node.cpp │ │ ├── node.hpp │ │ ├── remote/ │ │ │ └── ethbackend/ │ │ │ └── grpc/ │ │ │ └── server/ │ │ │ ├── backend_calls.cpp │ │ │ ├── backend_calls.hpp │ │ │ ├── backend_server.cpp │ │ │ ├── backend_server.hpp │ │ │ └── backend_server_test.cpp │ │ ├── resource_usage.cpp │ │ ├── resource_usage.hpp │ │ ├── settings.hpp │ │ ├── stagedsync/ │ │ │ ├── execution_engine.cpp │ │ │ ├── execution_engine.hpp │ │ │ ├── execution_engine_test.cpp │ │ │ ├── execution_pipeline.cpp │ │ │ ├── execution_pipeline.hpp │ │ │ ├── forks/ │ │ │ │ ├── canonical_chain.cpp │ │ │ │ ├── canonical_chain.hpp │ │ │ │ ├── extending_fork.cpp │ │ │ │ ├── extending_fork.hpp │ │ │ │ ├── fork.cpp │ │ │ │ ├── fork.hpp │ │ │ │ ├── fork_test.cpp │ │ │ │ ├── main_chain.cpp │ │ │ │ ├── main_chain.hpp │ │ │ │ └── main_chain_test.cpp │ │ │ ├── stages/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── stage_blockhashes.cpp │ │ │ │ ├── stage_blockhashes.hpp │ │ │ │ ├── stage_bodies.cpp │ │ │ │ ├── stage_bodies.hpp │ │ │ │ ├── stage_bodies_factory.hpp │ │ │ │ ├── stage_bodies_test.cpp │ │ │ │ ├── stage_call_trace_index.cpp │ │ │ │ ├── stage_call_trace_index.hpp │ │ │ │ ├── stage_execution.cpp │ │ │ │ ├── stage_execution.hpp │ │ │ │ ├── stage_finish.cpp │ │ │ │ ├── stage_finish.hpp │ │ │ │ ├── stage_hashstate.cpp │ │ │ │ ├── stage_hashstate.hpp │ │ │ │ ├── stage_headers.cpp │ │ │ │ ├── stage_headers.hpp │ │ │ │ ├── stage_headers_test.cpp │ │ │ │ ├── stage_history_index.cpp │ │ │ │ ├── stage_history_index.hpp │ │ │ │ ├── stage_history_index_test.cpp │ │ │ │ ├── stage_interhashes/ │ │ │ │ │ ├── _test.cpp │ │ │ │ │ ├── trie_cursor.cpp │ │ │ │ │ ├── trie_cursor.hpp │ │ │ │ │ ├── trie_loader.cpp │ │ │ │ │ └── trie_loader.hpp │ │ │ │ ├── stage_interhashes.cpp │ │ │ │ ├── stage_interhashes.hpp │ │ │ │ ├── stage_log_index.cpp │ │ │ │ ├── stage_log_index.hpp │ │ │ │ ├── stage_senders.cpp │ │ │ │ ├── stage_senders.hpp │ │ │ │ ├── stage_triggers.cpp │ │ │ │ ├── stage_triggers.hpp │ │ │ │ ├── stage_triggers_test.cpp │ │ │ │ ├── stage_tx_lookup.cpp │ │ │ │ ├── stage_tx_lookup.hpp │ │ │ │ └── stage_tx_lookup_test.cpp │ │ │ ├── stages_factory_impl.cpp │ │ │ ├── stages_factory_impl.hpp │ │ │ ├── stages_test.cpp │ │ │ ├── timer_factory.hpp │ │ │ └── types.hpp │ │ └── test_util/ │ │ ├── CMakeLists.txt │ │ ├── dummy.cpp │ │ ├── make_stages_factory.cpp │ │ ├── make_stages_factory.hpp │ │ ├── mock_execution_engine.hpp │ │ └── temp_chain_data_node_settings.hpp │ ├── rpc/ │ │ ├── CMakeLists.txt │ │ ├── capi/ │ │ │ ├── rpcdaemon.cpp │ │ │ └── rpcdaemon.h │ │ ├── cli/ │ │ │ ├── CMakeLists.txt │ │ │ ├── grpc_toolbox.cpp │ │ │ ├── rpcdaemon_options.cpp │ │ │ └── rpcdaemon_options.hpp │ │ ├── commands/ │ │ │ ├── admin_api.cpp │ │ │ ├── admin_api.hpp │ │ │ ├── debug_api.cpp │ │ │ ├── debug_api.hpp │ │ │ ├── debug_api_test.cpp │ │ │ ├── engine_api.cpp │ │ │ ├── engine_api.hpp │ │ │ ├── engine_api_test.cpp │ │ │ ├── erigon_api.cpp │ │ │ ├── erigon_api.hpp │ │ │ ├── erigon_api_test.cpp │ │ │ ├── eth_api.cpp │ │ │ ├── eth_api.hpp │ │ │ ├── eth_api_test.cpp │ │ │ ├── net_api.cpp │ │ │ ├── net_api.hpp │ │ │ ├── net_api_test.cpp │ │ │ ├── ots_api.cpp │ │ │ ├── ots_api.hpp │ │ │ ├── parity_api.cpp │ │ │ ├── parity_api.hpp │ │ │ ├── parity_api_test.cpp │ │ │ ├── rpc_api.hpp │ │ │ ├── rpc_api_table.cpp │ │ │ ├── rpc_api_table.hpp │ │ │ ├── rpc_api_table_test.cpp │ │ │ ├── rpc_api_test.cpp │ │ │ ├── trace_api.cpp │ │ │ ├── trace_api.hpp │ │ │ ├── trace_api_test.cpp │ │ │ ├── txpool_api.cpp │ │ │ ├── txpool_api.hpp │ │ │ ├── web3_api.cpp │ │ │ ├── web3_api.hpp │ │ │ └── web3_api_test.cpp │ │ ├── common/ │ │ │ ├── async_task.hpp │ │ │ ├── async_task_benchmark.cpp │ │ │ ├── async_task_test.cpp │ │ │ ├── compatibility.cpp │ │ │ ├── compatibility.hpp │ │ │ ├── constants.hpp │ │ │ ├── interface_log.cpp │ │ │ ├── interface_log.hpp │ │ │ ├── interface_log_test.cpp │ │ │ ├── tee.hpp │ │ │ ├── util.cpp │ │ │ ├── util.hpp │ │ │ ├── util_test.cpp │ │ │ └── worker_pool.hpp │ │ ├── core/ │ │ │ ├── account_dumper.cpp │ │ │ ├── account_dumper.hpp │ │ │ ├── account_dumper_test.cpp │ │ │ ├── block_reader.cpp │ │ │ ├── block_reader.hpp │ │ │ ├── block_reader_test.cpp │ │ │ ├── call_many.cpp │ │ │ ├── call_many.hpp │ │ │ ├── estimate_gas_oracle.cpp │ │ │ ├── estimate_gas_oracle.hpp │ │ │ ├── estimate_gas_oracle_test.cpp │ │ │ ├── evm_access_list_tracer.cpp │ │ │ ├── evm_access_list_tracer.hpp │ │ │ ├── evm_debug.cpp │ │ │ ├── evm_debug.hpp │ │ │ ├── evm_debug_test.cpp │ │ │ ├── evm_executor.cpp │ │ │ ├── evm_executor.hpp │ │ │ ├── evm_executor_test.cpp │ │ │ ├── evm_trace.cpp │ │ │ ├── evm_trace.hpp │ │ │ ├── evm_trace_test.cpp │ │ │ ├── fee_history_oracle.cpp │ │ │ ├── fee_history_oracle.hpp │ │ │ ├── fee_history_oracle_test.cpp │ │ │ ├── filter_storage.cpp │ │ │ ├── filter_storage.hpp │ │ │ ├── filter_storage_test.cpp │ │ │ ├── gas_price_oracle.cpp │ │ │ ├── gas_price_oracle.hpp │ │ │ ├── gas_price_oracle_test.cpp │ │ │ ├── logs_walker.cpp │ │ │ ├── logs_walker.hpp │ │ │ ├── override_state.cpp │ │ │ ├── override_state.hpp │ │ │ ├── receipts.cpp │ │ │ ├── receipts.hpp │ │ │ ├── receipts_cache.hpp │ │ │ ├── receipts_test.cpp │ │ │ ├── storage_walker.cpp │ │ │ ├── storage_walker.hpp │ │ │ └── storage_walker_test.cpp │ │ ├── daemon.cpp │ │ ├── daemon.hpp │ │ ├── daemon_test.cpp │ │ ├── engine/ │ │ │ ├── conversion.cpp │ │ │ ├── conversion.hpp │ │ │ ├── execution_engine.hpp │ │ │ ├── remote_execution_engine.cpp │ │ │ ├── remote_execution_engine.hpp │ │ │ ├── validation.cpp │ │ │ └── validation.hpp │ │ ├── ethbackend/ │ │ │ ├── backend.hpp │ │ │ ├── remote_backend.cpp │ │ │ ├── remote_backend.hpp │ │ │ └── remote_backend_test.cpp │ │ ├── ethdb/ │ │ │ ├── bitmap.cpp │ │ │ ├── bitmap.hpp │ │ │ ├── cbor.cpp │ │ │ ├── cbor.hpp │ │ │ ├── cbor_test.cpp │ │ │ ├── kv/ │ │ │ │ └── backend_providers.hpp │ │ │ ├── split_cursor.cpp │ │ │ ├── split_cursor.hpp │ │ │ ├── split_cursor_test.cpp │ │ │ ├── walk.cpp │ │ │ └── walk.hpp │ │ ├── http/ │ │ │ ├── chunker.hpp │ │ │ ├── connection.cpp │ │ │ ├── connection.hpp │ │ │ ├── connection_test.cpp │ │ │ ├── deflater.hpp │ │ │ ├── jwt.cpp │ │ │ ├── jwt.hpp │ │ │ ├── jwt_test.cpp │ │ │ ├── server.cpp │ │ │ ├── server.hpp │ │ │ └── zlib_compressor.hpp │ │ ├── json/ │ │ │ ├── access_list_entry.cpp │ │ │ ├── access_list_entry.hpp │ │ │ ├── authorization.cpp │ │ │ ├── authorization.hpp │ │ │ ├── block.cpp │ │ │ ├── block.hpp │ │ │ ├── block_test.cpp │ │ │ ├── cache_validation_result.cpp │ │ │ ├── cache_validation_result.hpp │ │ │ ├── call.cpp │ │ │ ├── call.hpp │ │ │ ├── call_bundle.cpp │ │ │ ├── call_bundle.hpp │ │ │ ├── call_bundle_test.cpp │ │ │ ├── call_test.cpp │ │ │ ├── client_version.cpp │ │ │ ├── client_version.hpp │ │ │ ├── execution_payload.cpp │ │ │ ├── execution_payload.hpp │ │ │ ├── execution_payload_test.cpp │ │ │ ├── filter.cpp │ │ │ ├── filter.hpp │ │ │ ├── filter_test.cpp │ │ │ ├── fork_choice.cpp │ │ │ ├── fork_choice.hpp │ │ │ ├── fork_choice_test.cpp │ │ │ ├── glaze.cpp │ │ │ ├── glaze.hpp │ │ │ ├── glaze_test.cpp │ │ │ ├── log.cpp │ │ │ ├── log.hpp │ │ │ ├── log_test.cpp │ │ │ ├── node_info.cpp │ │ │ ├── node_info.hpp │ │ │ ├── node_info_test.cpp │ │ │ ├── payload_attributes.cpp │ │ │ ├── payload_attributes.hpp │ │ │ ├── payload_attributes_test.cpp │ │ │ ├── receipt.cpp │ │ │ ├── receipt.hpp │ │ │ ├── receipt_test.cpp │ │ │ ├── stream.cpp │ │ │ ├── stream.hpp │ │ │ ├── stream_test.cpp │ │ │ ├── transaction.cpp │ │ │ ├── transaction.hpp │ │ │ ├── transaction_test.cpp │ │ │ ├── transition_configuration.cpp │ │ │ ├── transition_configuration.hpp │ │ │ ├── transition_configuration_test.cpp │ │ │ ├── types.cpp │ │ │ ├── types.hpp │ │ │ ├── types_test.cpp │ │ │ ├── withdrawal.cpp │ │ │ ├── withdrawal.hpp │ │ │ └── withdrawal_test.cpp │ │ ├── json_rpc/ │ │ │ ├── methods.hpp │ │ │ ├── request_handler.cpp │ │ │ ├── request_handler.hpp │ │ │ ├── request_handler_test.cpp │ │ │ ├── specification.cpp │ │ │ ├── specification.hpp │ │ │ ├── specification.json │ │ │ ├── validator.cpp │ │ │ ├── validator.hpp │ │ │ ├── validator_benchmark.cpp │ │ │ └── validator_test.cpp │ │ ├── protocol/ │ │ │ ├── errors.cpp │ │ │ └── errors.hpp │ │ ├── settings.hpp │ │ ├── stagedsync/ │ │ │ ├── stages.cpp │ │ │ ├── stages.hpp │ │ │ └── stages_test.cpp │ │ ├── test_util/ │ │ │ ├── CMakeLists.txt │ │ │ ├── api_test_base.hpp │ │ │ ├── api_test_database.hpp │ │ │ ├── dummy_client.hpp │ │ │ ├── dummy_transaction.hpp │ │ │ ├── mock_back_end.hpp │ │ │ ├── mock_block_cache.hpp │ │ │ ├── mock_estimate_gas_oracle.hpp │ │ │ ├── mock_execution_engine.hpp │ │ │ ├── mock_state_cache.hpp │ │ │ ├── service_context_test_base.cpp │ │ │ └── service_context_test_base.hpp │ │ ├── transport/ │ │ │ ├── request_handler.hpp │ │ │ ├── stream_writer.hpp │ │ │ └── stream_writer_test.cpp │ │ ├── txpool/ │ │ │ ├── miner.cpp │ │ │ ├── miner.hpp │ │ │ ├── miner_test.cpp │ │ │ ├── transaction_pool.cpp │ │ │ ├── transaction_pool.hpp │ │ │ └── transaction_pool_test.cpp │ │ ├── types/ │ │ │ ├── block.cpp │ │ │ ├── block.hpp │ │ │ ├── block_test.cpp │ │ │ ├── cache_validation_result.hpp │ │ │ ├── call.cpp │ │ │ ├── call.hpp │ │ │ ├── call_bundle.hpp │ │ │ ├── call_test.cpp │ │ │ ├── chain_config.cpp │ │ │ ├── chain_config.hpp │ │ │ ├── chain_config_test.cpp │ │ │ ├── chain_traffic.hpp │ │ │ ├── dump_account.cpp │ │ │ ├── dump_account.hpp │ │ │ ├── dump_account_test.cpp │ │ │ ├── error.cpp │ │ │ ├── error.hpp │ │ │ ├── error_test.cpp │ │ │ ├── execution_payload.cpp │ │ │ ├── execution_payload.hpp │ │ │ ├── execution_payload_test.cpp │ │ │ ├── filter.cpp │ │ │ ├── filter.hpp │ │ │ ├── filter_test.cpp │ │ │ ├── issuance.cpp │ │ │ ├── issuance.hpp │ │ │ ├── issuance_test.cpp │ │ │ ├── log.cpp │ │ │ ├── log.hpp │ │ │ ├── log_test.cpp │ │ │ ├── node_info.hpp │ │ │ ├── peer_info.hpp │ │ │ ├── receipt.cpp │ │ │ ├── receipt.hpp │ │ │ ├── receipt_test.cpp │ │ │ ├── syncing_data.hpp │ │ │ ├── transaction.cpp │ │ │ ├── transaction.hpp │ │ │ └── transaction_test.cpp │ │ └── ws/ │ │ ├── connection.cpp │ │ └── connection.hpp │ ├── sentry/ │ │ ├── CMakeLists.txt │ │ ├── api/ │ │ │ ├── common/ │ │ │ │ ├── message_from_peer.hpp │ │ │ │ ├── message_id_set.hpp │ │ │ │ ├── node_info.hpp │ │ │ │ ├── peer_event.hpp │ │ │ │ ├── peer_filter.hpp │ │ │ │ ├── peer_info.hpp │ │ │ │ ├── sentry_client.hpp │ │ │ │ └── service.hpp │ │ │ └── router/ │ │ │ ├── direct_service.cpp │ │ │ ├── direct_service.hpp │ │ │ ├── messages_call.hpp │ │ │ ├── peer_call.hpp │ │ │ ├── peer_events_call.hpp │ │ │ ├── send_message_call.hpp │ │ │ └── service_router.hpp │ │ ├── capi/ │ │ │ ├── component.hpp │ │ │ ├── sentry.cpp │ │ │ └── sentry.h │ │ ├── cli/ │ │ │ ├── CMakeLists.txt │ │ │ ├── sentry_options.cpp │ │ │ └── sentry_options.hpp │ │ ├── common/ │ │ │ ├── CMakeLists.txt │ │ │ ├── atomic_value.hpp │ │ │ ├── crypto/ │ │ │ │ ├── ecdsa_signature.cpp │ │ │ │ ├── ecdsa_signature.hpp │ │ │ │ ├── xor.cpp │ │ │ │ └── xor.hpp │ │ │ ├── ecc_key_pair.cpp │ │ │ ├── ecc_key_pair.hpp │ │ │ ├── ecc_key_pair_test.cpp │ │ │ ├── ecc_public_key.cpp │ │ │ ├── ecc_public_key.hpp │ │ │ ├── enode_url.cpp │ │ │ ├── enode_url.hpp │ │ │ ├── enode_url_test.cpp │ │ │ ├── error.hpp │ │ │ ├── message.hpp │ │ │ ├── random.cpp │ │ │ ├── random.hpp │ │ │ ├── socket_stream.cpp │ │ │ └── socket_stream.hpp │ │ ├── discovery/ │ │ │ ├── bootnodes.cpp │ │ │ ├── bootnodes.hpp │ │ │ ├── common/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── node_address.cpp │ │ │ │ └── node_address.hpp │ │ │ ├── disc_v4/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── common/ │ │ │ │ │ ├── ip_classify.cpp │ │ │ │ │ ├── ip_classify.hpp │ │ │ │ │ ├── ip_classify_test.cpp │ │ │ │ │ ├── ipv6_unsupported_error.hpp │ │ │ │ │ ├── message_expiration.cpp │ │ │ │ │ ├── message_expiration.hpp │ │ │ │ │ ├── node_distance.cpp │ │ │ │ │ ├── node_distance.hpp │ │ │ │ │ ├── node_distance_test.cpp │ │ │ │ │ └── packet_type.hpp │ │ │ │ ├── discovery.cpp │ │ │ │ ├── discovery.hpp │ │ │ │ ├── enr/ │ │ │ │ │ ├── enr_request_handler.cpp │ │ │ │ │ ├── enr_request_handler.hpp │ │ │ │ │ ├── enr_request_message.cpp │ │ │ │ │ ├── enr_request_message.hpp │ │ │ │ │ ├── enr_response_message.cpp │ │ │ │ │ ├── enr_response_message.hpp │ │ │ │ │ ├── enr_response_message_test.cpp │ │ │ │ │ ├── fetch_enr_record.cpp │ │ │ │ │ ├── fetch_enr_record.hpp │ │ │ │ │ ├── message_handler.hpp │ │ │ │ │ └── message_sender.hpp │ │ │ │ ├── find/ │ │ │ │ │ ├── find_neighbors.cpp │ │ │ │ │ ├── find_neighbors.hpp │ │ │ │ │ ├── find_node_handler.cpp │ │ │ │ │ ├── find_node_handler.hpp │ │ │ │ │ ├── find_node_message.cpp │ │ │ │ │ ├── find_node_message.hpp │ │ │ │ │ ├── lookup.cpp │ │ │ │ │ ├── lookup.hpp │ │ │ │ │ ├── message_handler.hpp │ │ │ │ │ ├── message_sender.hpp │ │ │ │ │ ├── neighbors_message.cpp │ │ │ │ │ └── neighbors_message.hpp │ │ │ │ ├── message_codec.cpp │ │ │ │ ├── message_codec.hpp │ │ │ │ ├── message_codec_test.cpp │ │ │ │ ├── message_handler.hpp │ │ │ │ ├── message_sender.hpp │ │ │ │ ├── ping/ │ │ │ │ │ ├── message_handler.hpp │ │ │ │ │ ├── message_sender.hpp │ │ │ │ │ ├── ping_check.cpp │ │ │ │ │ ├── ping_check.hpp │ │ │ │ │ ├── ping_handler.cpp │ │ │ │ │ ├── ping_handler.hpp │ │ │ │ │ ├── ping_message.cpp │ │ │ │ │ ├── ping_message.hpp │ │ │ │ │ ├── pong_message.cpp │ │ │ │ │ └── pong_message.hpp │ │ │ │ ├── server.cpp │ │ │ │ └── server.hpp │ │ │ ├── discovery.cpp │ │ │ ├── discovery.hpp │ │ │ ├── enr/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── enr_codec.cpp │ │ │ │ ├── enr_codec.hpp │ │ │ │ ├── enr_record.hpp │ │ │ │ ├── enr_url.cpp │ │ │ │ ├── enr_url.hpp │ │ │ │ └── enr_url_test.cpp │ │ │ └── node_db/ │ │ │ ├── CMakeLists.txt │ │ │ ├── node_db.hpp │ │ │ ├── node_db_sqlite.cpp │ │ │ ├── node_db_sqlite.hpp │ │ │ ├── node_db_sqlite_test.cpp │ │ │ ├── serial_node_db.cpp │ │ │ └── serial_node_db.hpp │ │ ├── eth/ │ │ │ ├── fork_id.cpp │ │ │ ├── fork_id.hpp │ │ │ ├── fork_id_test.cpp │ │ │ ├── message_id.cpp │ │ │ ├── message_id.hpp │ │ │ ├── protocol.cpp │ │ │ ├── protocol.hpp │ │ │ ├── status_data.hpp │ │ │ ├── status_data_provider.cpp │ │ │ ├── status_data_provider.hpp │ │ │ ├── status_message.cpp │ │ │ └── status_message.hpp │ │ ├── grpc/ │ │ │ ├── client/ │ │ │ │ ├── sentry_client.cpp │ │ │ │ └── sentry_client.hpp │ │ │ ├── interfaces/ │ │ │ │ ├── eth_version.cpp │ │ │ │ ├── eth_version.hpp │ │ │ │ ├── message.cpp │ │ │ │ ├── message.hpp │ │ │ │ ├── node_info.cpp │ │ │ │ ├── node_info.hpp │ │ │ │ ├── peer_event.cpp │ │ │ │ ├── peer_event.hpp │ │ │ │ ├── peer_id.cpp │ │ │ │ ├── peer_id.hpp │ │ │ │ ├── peer_info.cpp │ │ │ │ ├── peer_info.hpp │ │ │ │ ├── sent_peer_ids.cpp │ │ │ │ ├── sent_peer_ids.hpp │ │ │ │ ├── status_data.cpp │ │ │ │ └── status_data.hpp │ │ │ └── server/ │ │ │ ├── server.cpp │ │ │ ├── server.hpp │ │ │ └── server_calls.hpp │ │ ├── grpc_requests.http │ │ ├── message_receiver.cpp │ │ ├── message_receiver.hpp │ │ ├── message_sender.cpp │ │ ├── message_sender.hpp │ │ ├── multi_sentry_client.cpp │ │ ├── multi_sentry_client.hpp │ │ ├── nat/ │ │ │ ├── address_util.cpp │ │ │ ├── address_util.hpp │ │ │ ├── address_util_test.cpp │ │ │ ├── ip_resolver.cpp │ │ │ ├── ip_resolver.hpp │ │ │ ├── local_ip_resolver.cpp │ │ │ ├── local_ip_resolver.hpp │ │ │ ├── nat_option.cpp │ │ │ ├── nat_option.hpp │ │ │ ├── stun_ip_resolver.cpp │ │ │ └── stun_ip_resolver.hpp │ │ ├── node_key_config.cpp │ │ ├── node_key_config.hpp │ │ ├── node_key_config_test.cpp │ │ ├── peer_discovery_feedback.cpp │ │ ├── peer_discovery_feedback.hpp │ │ ├── peer_manager.cpp │ │ ├── peer_manager.hpp │ │ ├── peer_manager_api.cpp │ │ ├── peer_manager_api.hpp │ │ ├── peer_manager_observer.hpp │ │ ├── rlpx/ │ │ │ ├── auth/ │ │ │ │ ├── auth_ack_message.cpp │ │ │ │ ├── auth_ack_message.hpp │ │ │ │ ├── auth_initiator.cpp │ │ │ │ ├── auth_initiator.hpp │ │ │ │ ├── auth_keys.hpp │ │ │ │ ├── auth_message.cpp │ │ │ │ ├── auth_message.hpp │ │ │ │ ├── auth_message_error.hpp │ │ │ │ ├── auth_recipient.cpp │ │ │ │ ├── auth_recipient.hpp │ │ │ │ ├── ecies_cipher.cpp │ │ │ │ ├── ecies_cipher.hpp │ │ │ │ ├── ecies_cipher_error.hpp │ │ │ │ ├── ecies_cipher_test.cpp │ │ │ │ ├── handshake.cpp │ │ │ │ ├── handshake.hpp │ │ │ │ ├── hello_message.cpp │ │ │ │ └── hello_message.hpp │ │ │ ├── client.cpp │ │ │ ├── client.hpp │ │ │ ├── common/ │ │ │ │ ├── disconnect_message.cpp │ │ │ │ ├── disconnect_message.hpp │ │ │ │ ├── disconnect_message_test.cpp │ │ │ │ └── disconnect_reason.hpp │ │ │ ├── crypto/ │ │ │ │ ├── aes.cpp │ │ │ │ ├── aes.hpp │ │ │ │ ├── hmac.cpp │ │ │ │ ├── hmac.hpp │ │ │ │ ├── sha256.cpp │ │ │ │ ├── sha256.hpp │ │ │ │ ├── sha3_hasher.cpp │ │ │ │ ├── sha3_hasher.hpp │ │ │ │ └── sha3_hasher_test.cpp │ │ │ ├── framing/ │ │ │ │ ├── framing_cipher.cpp │ │ │ │ ├── framing_cipher.hpp │ │ │ │ ├── message_frame_codec.cpp │ │ │ │ ├── message_frame_codec.hpp │ │ │ │ ├── message_stream.cpp │ │ │ │ └── message_stream.hpp │ │ │ ├── peer.cpp │ │ │ ├── peer.hpp │ │ │ ├── ping_message.cpp │ │ │ ├── ping_message.hpp │ │ │ ├── protocol.hpp │ │ │ ├── server.cpp │ │ │ └── server.hpp │ │ ├── sentry.cpp │ │ ├── sentry.hpp │ │ ├── sentry_client_factory.cpp │ │ ├── sentry_client_factory.hpp │ │ ├── session_sentry_client.cpp │ │ ├── session_sentry_client.hpp │ │ ├── settings.hpp │ │ ├── status_manager.cpp │ │ └── status_manager.hpp │ ├── sync/ │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── block_exchange.cpp │ │ ├── block_exchange.hpp │ │ ├── chain_sync.cpp │ │ ├── chain_sync.hpp │ │ ├── internals/ │ │ │ ├── algorithm.hpp │ │ │ ├── algorithm_test.cpp │ │ │ ├── body_retrieval.cpp │ │ │ ├── body_retrieval.hpp │ │ │ ├── body_sequence.cpp │ │ │ ├── body_sequence.hpp │ │ │ ├── body_sequence_test.cpp │ │ │ ├── chain_elements.hpp │ │ │ ├── chain_elements_test.cpp │ │ │ ├── chain_fork_view.cpp │ │ │ ├── chain_fork_view.hpp │ │ │ ├── header_chain.cpp │ │ │ ├── header_chain.hpp │ │ │ ├── header_chain_test.cpp │ │ │ ├── header_only_state.cpp │ │ │ ├── header_only_state.hpp │ │ │ ├── header_retrieval.cpp │ │ │ ├── header_retrieval.hpp │ │ │ ├── header_retrieval_test.cpp │ │ │ ├── preverified_hashes/ │ │ │ │ ├── preverified_hashes.cpp │ │ │ │ ├── preverified_hashes.hpp │ │ │ │ └── preverified_hashes_mainnet.cpp │ │ │ ├── priority_queue.hpp │ │ │ ├── priority_queue_test.cpp │ │ │ ├── random_number.hpp │ │ │ ├── statistics.cpp │ │ │ ├── statistics.hpp │ │ │ ├── types.cpp │ │ │ └── types.hpp │ │ ├── messages/ │ │ │ ├── inbound_block_bodies.cpp │ │ │ ├── inbound_block_bodies.hpp │ │ │ ├── inbound_block_headers.cpp │ │ │ ├── inbound_block_headers.hpp │ │ │ ├── inbound_get_block_bodies.cpp │ │ │ ├── inbound_get_block_bodies.hpp │ │ │ ├── inbound_get_block_headers.cpp │ │ │ ├── inbound_get_block_headers.hpp │ │ │ ├── inbound_message.cpp │ │ │ ├── inbound_message.hpp │ │ │ ├── inbound_new_block.cpp │ │ │ ├── inbound_new_block.hpp │ │ │ ├── inbound_new_block_hashes.cpp │ │ │ ├── inbound_new_block_hashes.hpp │ │ │ ├── internal_message.hpp │ │ │ ├── internal_message_test.cpp │ │ │ ├── message.hpp │ │ │ ├── outbound_block_bodies.cpp │ │ │ ├── outbound_block_bodies.hpp │ │ │ ├── outbound_block_headers.cpp │ │ │ ├── outbound_block_headers.hpp │ │ │ ├── outbound_get_block_bodies.cpp │ │ │ ├── outbound_get_block_bodies.hpp │ │ │ ├── outbound_get_block_headers.cpp │ │ │ ├── outbound_get_block_headers.hpp │ │ │ ├── outbound_message.cpp │ │ │ ├── outbound_message.hpp │ │ │ ├── outbound_new_block.cpp │ │ │ ├── outbound_new_block.hpp │ │ │ ├── outbound_new_block_hashes.cpp │ │ │ └── outbound_new_block_hashes.hpp │ │ ├── packets/ │ │ │ ├── block_bodies_packet.hpp │ │ │ ├── block_headers_packet.hpp │ │ │ ├── get_block_bodies_packet.hpp │ │ │ ├── get_block_headers_packet.hpp │ │ │ ├── hash_or_number.hpp │ │ │ ├── new_block_hashes_packet.hpp │ │ │ ├── new_block_packet.hpp │ │ │ ├── packet_coding_test.cpp │ │ │ ├── rlp_decoding.cpp │ │ │ ├── rlp_encoding.cpp │ │ │ └── rlp_eth66_packet_coding.hpp │ │ ├── sentry_client.cpp │ │ ├── sentry_client.hpp │ │ ├── settings.hpp │ │ ├── sync.cpp │ │ ├── sync.hpp │ │ ├── sync_pos.cpp │ │ ├── sync_pos.hpp │ │ ├── sync_pos_test.cpp │ │ ├── sync_pow.cpp │ │ ├── sync_pow.hpp │ │ └── test_util/ │ │ ├── mock_block_exchange.hpp │ │ └── mock_execution_client.hpp │ └── wasm/ │ ├── CMakeLists.txt │ ├── exception_handling_stub.cpp │ ├── silkworm_wasm_api.cpp │ └── silkworm_wasm_api.hpp ├── tests/ │ ├── docker/ │ │ ├── Dockerfile │ │ ├── README.md │ │ └── run-docker.sh │ ├── perf/ │ │ ├── run_with_perf.sh │ │ ├── run_with_toplev.sh │ │ ├── vegeta_attack_getLogs_rpcdaemon.sh │ │ └── vegeta_attack_getLogs_silkrpc.sh │ └── unit/ │ ├── README.md │ └── run_unit_test_loop.py ├── third_party/ │ ├── CMakeLists.txt │ ├── asio-grpc/ │ │ └── CMakeLists.txt │ ├── blst/ │ │ └── CMakeLists.txt │ ├── cbor-cpp/ │ │ └── CMakeLists.txt │ ├── clang-format/ │ │ ├── LICENSE.TXT │ │ ├── darwin-x64/ │ │ │ └── clang-format │ │ └── linux-x64/ │ │ └── clang-format │ ├── clang-tidy/ │ │ ├── clang-tidy-diff.py │ │ └── clang-tidy-diff.sh │ ├── cmake-conan/ │ │ ├── LICENSE │ │ ├── conan_provider.cmake │ │ └── readme.txt │ ├── cpp-base64/ │ │ └── CMakeLists.txt │ ├── erigon-mdbx-go/ │ │ └── CMakeLists.txt │ ├── ethash/ │ │ └── CMakeLists.txt │ ├── evmone/ │ │ └── CMakeLists.txt │ ├── glaze/ │ │ └── CMakeLists.txt │ ├── gmp/ │ │ └── CMakeLists.txt │ ├── intx/ │ │ └── CMakeLists.txt │ ├── libff/ │ │ └── CMakeLists.txt │ ├── llvm/ │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── lib_libc++/ │ │ │ └── clang/ │ │ │ └── 16.0.6/ │ │ │ └── lib/ │ │ │ └── x86_64-linux/ │ │ │ ├── libclang_rt.fuzzer.a │ │ │ ├── libclang_rt.fuzzer_interceptors.a │ │ │ └── libclang_rt.fuzzer_no_main.a │ │ └── llvm.sh │ ├── sais-lite/ │ │ ├── CMakeLists.txt │ │ └── sais-lite/ │ │ ├── README.md │ │ ├── sais.c │ │ └── sais.h │ ├── secp256k1/ │ │ └── CMakeLists.txt │ ├── stbrumme-crc32/ │ │ └── CMakeLists.txt │ ├── stbrumme-keccak/ │ │ ├── CMakeLists.txt │ │ └── stbrumme-keccak/ │ │ ├── LICENSE │ │ ├── keccak.cpp │ │ └── keccak.h │ ├── stun-msg/ │ │ └── CMakeLists.txt │ └── wasmer/ │ └── install.sh └── tools/ ├── deps.py ├── lint/ │ ├── ci_format.sh │ ├── clang_tidy_report.sh │ ├── copyright_replace.sh │ └── log_macros_fix.sh └── sanitizer/ └── tsan_suppressions.txt ================================================ FILE CONTENTS ================================================ ================================================ FILE: .circleci/config.yml ================================================ version: 2.1 orbs: codecov: codecov/codecov@3.3.0 commands: checkout_with_submodules: parameters: ethereum_tests: description: Include a heavy Ethereum tests submodule if needed. type: boolean default: true steps: - checkout - run: name: "Update submodules" command: | if [[ <> == false ]] then git config submodule.ethereum-tests.update none fi git submodule sync git -c submodule.LegacyTests.update=none submodule update --init --recursive build: parameters: build_type: type: string default: Release compiler_id: type: string compiler_version: type: integer conan_profile: type: string default: none target: type: string default: all steps: - run: name: "Install compiler" command: cmake/setup/compiler_install.sh <> <> - run: name: "Cmake" working_directory: ~/build command: | if [[ "<>" != "none" ]] then CONAN_CMAKE_ARGS="-DCONAN_PROFILE=<>" fi if [[ "<>" == "clang" ]] then TOOLCHAIN_CMAKE_ARGS="-DCMAKE_TOOLCHAIN_FILE=../project/cmake/toolchain/clang_libcxx.cmake" fi cmake ../project -DCMAKE_BUILD_TYPE=<> $CONAN_CMAKE_ARGS $TOOLCHAIN_CMAKE_ARGS $BUILD_CMAKE_ARGS - run: name: "Build" working_directory: ~/build command: | if [[ "<>" == "all" ]] then cmake --build . -j16 |& tee build.log else cmake --build . -j16 --target <> |& tee build.log fi install_conan: steps: - run: name: "Install Conan" command: | pip3 install --user --no-warn-script-location conan==2.10.2 conan_path="$(python3 -m site --user-base)/bin" echo "export \"PATH=$conan_path:\$PATH\"" >> "$BASH_ENV" "$conan_path/conan" --version build_using_conan: parameters: build_type: type: string default: Release compiler_id: type: string compiler_version: type: integer target: type: string default: all steps: - install_conan - run: name: "Select Conan profile" command: | if [[ "<>" == "clang" ]] then conan_profile=linux_x64_clang_16_release else conan_profile=linux_x64_gcc_11_release fi echo "export CONAN_PROFILE='$conan_profile'" >> "$BASH_ENV" cp "cmake/profiles/$conan_profile" "$HOME/selected_conan_profile" - restore_cache: name: "Restore Conan cache" key: &conan-cache-key conan-machine-{{ .Environment.CIRCLE_JOB }}-<>-<>-{{checksum "../selected_conan_profile"}}-{{checksum "conanfile.py"}}-{{checksum "cmake/conan.cmake"}} - build: build_type: <> compiler_id: <> compiler_version: <> conan_profile: $CONAN_PROFILE target: <> - save_cache: name: "Save Conan cache" key: *conan-cache-key paths: - ~/.conan2 build_fuzzer: steps: - checkout_with_submodules: ethereum_tests: false - run: name: "Ensure pip" command: | sudo apt-get update sudo apt install -y python3-pip - install_conan - run: name: "Install compiler" command: cmake/setup/compiler_install.sh clang <> - run: name: "CMake Fuzzer" working_directory: ~/build command: cmake ../project -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCONAN_PROFILE=linux_x64_clang_16_release -DCMAKE_TOOLCHAIN_FILE=../project/cmake/toolchain/clang_libcxx.cmake -DSILKWORM_FUZZER=ON - run: name: "Build Fuzzer" command: | cmake --build ~/build -j4 --target rpcdaemon_fuzzer_test cmake --build ~/build -j4 --target rpcdaemon_fuzzer_diagnostics test: parameters: sanitizer: type: string default: "" ethereum_tests: type: boolean default: true steps: - run: name: "Smoke tests" command: make "SILKWORM_BUILD_DIR=$HOME/build" run_smoke_tests - run: name: "Unit tests" command: make "SILKWORM_BUILD_DIR=$HOME/build" SILKWORM_CLANG_COVERAGE=OFF SILKWORM_SANITIZE=<> "SILKWORM_PROJECT_DIR=$HOME/project" run_unit_tests - when: condition: <> steps: - run: name: "Ethereum EL tests" working_directory: ~/build no_output_timeout: 30m command: cmd/test/ethereum - run: name: "Execution spec tests" working_directory: ~/build no_output_timeout: 60m command: cmd/test/ethereum --tests $HOME/project/third_party/eest-fixtures fuzz-test: steps: - run: name: "RPCDaemon Fuzz test" working_directory: ~/build command: | mkdir -p ~/corpus mkdir -p ~/crashes mkdir -p ~/artifacts for file in ../project/third_party/execution-apis/tests/*/*.io; do cp --backup=numbered "$file" ~/artifacts; done for file in ~/artifacts/*; do sed -i '2,$d' "$file"; done for file in ~/artifacts/*; do sed -i 's/^>> //' "$file"; done ./cmd/test/rpcdaemon_fuzzer_test ~/corpus ~/crashes ~/artifacts -max_total_time=86400 -detect_leaks=0 jobs: lint: machine: image: ubuntu-2404:2024.05.1 steps: - add_ssh_keys: fingerprints: - "4b:13:8d:15:b9:98:1a:dc:96:c2:b9:ab:fa:c1:d4:e6" - checkout - run: name: "Format" working_directory: ~/project command: ./tools/lint/ci_format.sh - run: name: "Lint" working_directory: ~/project command: make lint linux-gcc-thread-sanitizer: environment: BUILD_CMAKE_ARGS: -DSILKWORM_SANITIZE=thread machine: image: ubuntu-2404:2024.05.1 resource_class: 2xlarge steps: - checkout_with_submodules - run: name: "Sanitizer hack" # https://stackoverflow.com/questions/77850769/fatal-threadsanitizer-unexpected-memory-mapping-when-running-on-linux-kernels command: sudo sysctl vm.mmap_rnd_bits=30 - build_using_conan: compiler_id: gcc compiler_version: <> build_type: Debug - test: sanitizer: thread linux-release: parameters: compiler_id: type: string compiler_version: type: integer ethereum_tests: type: boolean default: true machine: image: ubuntu-2404:2024.05.1 resource_class: 2xlarge steps: - checkout_with_submodules: ethereum_tests: <> - build_using_conan: compiler_id: <> compiler_version: <> - test: ethereum_tests: <> linux-clang-address-sanitizer: environment: BUILD_CMAKE_ARGS: -DSILKWORM_SANITIZE=address,undefined ASAN_OPTIONS: alloc_dealloc_mismatch=0 # https://github.com/llvm/llvm-project/issues/59432 UBSAN_OPTIONS: print_stacktrace=1 machine: image: ubuntu-2404:2024.05.1 resource_class: 2xlarge steps: - checkout_with_submodules - run: name: "Sanitizer hack" # https://github.com/google/sanitizers/issues/856 command: sudo sysctl vm.mmap_rnd_bits=30 - build_using_conan: build_type: Debug compiler_id: clang compiler_version: 17 - test: sanitizer: address,undefined linux-clang-coverage: environment: BUILD_CMAKE_ARGS: -DSILKWORM_CLANG_COVERAGE=ON machine: image: ubuntu-2404:2024.05.1 resource_class: 2xlarge steps: - checkout_with_submodules - build_using_conan: build_type: Debug compiler_id: clang compiler_version: <> - run: name: "Unit tests" command: make "SILKWORM_BUILD_DIR=$HOME/build" SILKWORM_CLANG_COVERAGE=ON run_unit_tests - run: name: "Ethereum EL tests" no_output_timeout: 30m command: LLVM_PROFILE_FILE=ethereum.profraw ~/build/cmd/test/ethereum - run: name: "Execution spec tests" no_output_timeout: 60m command: LLVM_PROFILE_FILE=execution-spec.profraw ~/build/cmd/test/ethereum --tests $HOME/project/third_party/eest-fixtures - run: name: "Coverage" command: | llvm-profdata merge *.profraw -o profdata llvm-cov export -instr-profile profdata ~/build/cmd/silkworm '-ignore-filename-regex=(third_party|silkworm/interfaces|test)' -format=lcov > /tmp/silkworm.lcov llvm-cov report -instr-profile profdata ~/build/cmd/silkworm '-ignore-filename-regex=(third_party|silkworm/interfaces|test)' > /tmp/report.txt - codecov/upload: file: /tmp/silkworm.lcov - store_artifacts: path: /tmp/silkworm.lcov - store_artifacts: path: /tmp/report.txt linux-clang-tidy: environment: # see: https://clang.llvm.org/extra/clang-tidy/ BUILD_CMAKE_ARGS: -DSILKWORM_CLANG_TIDY=ON machine: image: ubuntu-2404:2024.05.1 resource_class: 2xlarge steps: - run: name: "Install clang-tidy" command: | sudo apt-get update sudo apt-get install -y clang-tidy-<> sudo update-alternatives --install /usr/bin/clang-tidy clang-tidy /usr/bin/clang-tidy-<> 100 - checkout_with_submodules: ethereum_tests: false - build_using_conan: build_type: Debug compiler_id: clang compiler_version: <> - run: name: "Report" command: tools/lint/clang_tidy_report.sh "$HOME/build/build.log" linux-clang-tidy-diff: environment: BUILD_CMAKE_ARGS: -DCMAKE_EXPORT_COMPILE_COMMANDS=ON machine: image: ubuntu-2404:2024.05.1 resource_class: 2xlarge steps: - run: name: "Install clang-tidy" command: | sudo apt-get update sudo apt-get install -y clang-tidy-<> sudo update-alternatives --install /usr/bin/clang-tidy clang-tidy /usr/bin/clang-tidy-<> 100 - checkout_with_submodules: ethereum_tests: false - build_using_conan: build_type: Debug compiler_id: clang compiler_version: <> - run: command: ./third_party/clang-tidy/clang-tidy-diff.sh $(git merge-base master HEAD) ~/build linux-clang-fuzzer: parameters: run_tests: description: Run fuzzy tests if required. type: boolean default: false environment: BUILD_CMAKE_ARGS: -DSILKWORM_FUZZER=ON UBSAN_OPTIONS: print_stacktrace=1 machine: image: ubuntu-2404:2024.05.1 resource_class: 2xlarge steps: - build_fuzzer - when: condition: <> steps: - fuzz-test linux-wasm-build: environment: WASI_SDK_VERSION: 20 machine: image: ubuntu-2404:2024.05.1 steps: - checkout_with_submodules: ethereum_tests: false - run: name: "Install WASI SDK" working_directory: ~/tmp1 command: | wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-$WASI_SDK_VERSION/wasi-sdk-$WASI_SDK_VERSION.0-linux.tar.gz tar xvf wasi-sdk-$WASI_SDK_VERSION.0-linux.tar.gz sudo mv wasi-sdk-$WASI_SDK_VERSION.0 /opt/wasi-sdk - run: name: "Install dependencies" command: | sudo apt-get update sudo apt-get install -y texinfo # https://askubuntu.com/questions/1531760/how-to-install-libtinfo5-on-ubuntu24-04 wget https://security.ubuntu.com/ubuntu/pool/universe/n/ncurses/libtinfo5_6.3-2ubuntu0.1_amd64.deb sudo apt-get install ./libtinfo5_6.3-2ubuntu0.1_amd64.deb - install_conan - run: name: "Install Wasmer" working_directory: ~/tmp2 command: $HOME/project/third_party/wasmer/install.sh v3.2.1 - run: name: "Build GMP" working_directory: ~/tmp3 command: | git clone https://github.com/erigontech/gmp-wasm cd gmp-wasm git checkout 87e9087 ./configure --prefix $HOME/opt-wasm CC=/opt/wasi-sdk/bin/clang --host=none AR=llvm-ar RANLIB=llvm-ranlib --enable-cxx CXX=/opt/wasi-sdk/bin/clang++ ABI=longlong make -j make install - run: name: "Cmake" working_directory: ~/build command: | cmake ../project -DCMAKE_TOOLCHAIN_FILE=$HOME/project/cmake/toolchain/wasi.cmake -DSILKWORM_CORE_ONLY=ON -DSILKWORM_CORE_USE_ABSEIL=OFF -DSILKWORM_WASM_API=ON -DGMP_INCLUDE_DIR=$HOME/opt-wasm/include -DGMP_LIBRARY=$HOME/opt-wasm/lib/libgmp.a -DCMAKE_BUILD_TYPE=Release - run: name: "Build" command: cmake --build ~/build -j - run: name: "Core unit tests" working_directory: ~/build command: wasmer silkworm/core/silkworm_core_test --stack-size 16777216 parameters: clang_version_min: type: integer default: 16 clang_version_latest: type: integer default: 18 gcc_version_min: type: integer default: 11 gcc_version_latest: type: integer default: 14 workflows: light: when: not: equal: [ master, <> ] jobs: - lint - linux-clang-tidy-diff - linux-release: name: linux-gcc-<>-release compiler_id: gcc compiler_version: <> ethereum_tests: false requires: - lint - linux-release: name: linux-clang-<>-release compiler_id: clang compiler_version: <> ethereum_tests: false requires: - lint integration: when: or: - equal: [ master, <> ] - matches: { pattern: "^ci\\/.+$", value: <> } jobs: - linux-release: name: linux-gcc-12-release compiler_id: gcc compiler_version: 12 - linux-gcc-thread-sanitizer - linux-clang-coverage - linux-clang-address-sanitizer - linux-clang-fuzzer: name: linux-clang-fuzzer - linux-clang-tidy - linux-wasm-build ================================================ FILE: .clang-format ================================================ BasedOnStyle: Google ColumnLimit: 0 IndentWidth: 4 AccessModifierOffset: -2 NamespaceIndentation: Inner AllowShortEnumsOnASingleLine: false DerivePointerAlignment: false PointerAlignment: Left IncludeCategories: # coroutine.hpp has to go before the boost headers, # otherwise boost::asio fails to compile on GCC 12 - Regex: '' Priority: 30 # coroutine.hpp has to go before the boost headers, # otherwise boost::asio fails to compile on GCC 12 - Regex: '' Priority: 30 # coroutine.hpp has to go before the boost headers, # otherwise boost::asio fails to compile on GCC 12 - Regex: '"task\.hpp"' Priority: 30 # Silkworm headers - Regex: '' Priority: 10 # C++ standard library - Regex: '<[[:alnum:]_]+>' Priority: 20 # Third-party libraries - Regex: '<.*' Priority: 40 ================================================ FILE: .clang-tidy ================================================ FormatStyle: file HeaderFilterRegex: 'silkworm/(capi|core|db|execution|infra|node|rpc|sentry|sync|wasm)/.+\.hpp$' WarningsAsErrors: 'bugprone-use-after-move' Checks: > abseil-*, boost-*, bugprone-*, -bugprone-easily-swappable-parameters, -bugprone-empty-catch, -bugprone-exception-escape, -bugprone-implicit-widening-of-multiplication-result, -bugprone-suspicious-stringview-data-usage, -bugprone-unchecked-optional-access, -bugprone-unused-raii, -bugprone-unused-return-value, cert-*, -cert-dcl21-cpp, -cert-dcl58-cpp, -cert-err33-c, -cert-err58-cpp, -cert-int09-c, -clang-analyzer-*, clang-diagnostic-*, concurrency-*, cppcoreguidelines-*, -cppcoreguidelines-avoid-c-arrays, -cppcoreguidelines-avoid-capturing-lambda-coroutines, -cppcoreguidelines-avoid-const-or-ref-data-members, -cppcoreguidelines-avoid-do-while, -cppcoreguidelines-avoid-magic-numbers, -cppcoreguidelines-avoid-non-const-global-variables, -cppcoreguidelines-avoid-reference-coroutine-parameters, -cppcoreguidelines-macro-usage, -cppcoreguidelines-missing-std-forward, -cppcoreguidelines-non-private-member-variables-in-classes, -cppcoreguidelines-owning-memory, -cppcoreguidelines-pro-bounds-array-to-pointer-decay, -cppcoreguidelines-pro-bounds-constant-array-index, -cppcoreguidelines-pro-bounds-pointer-arithmetic, -cppcoreguidelines-pro-type-reinterpret-cast, -cppcoreguidelines-pro-type-union-access, -cppcoreguidelines-pro-type-vararg, -cppcoreguidelines-special-member-functions, google-*, -google-build-using-namespace, -google-readability-braces-around-statements, -google-readability-todo, hicpp-*, -hicpp-avoid-c-arrays, -hicpp-braces-around-statements, -hicpp-named-parameter, -hicpp-no-array-decay, -hicpp-signed-bitwise, -hicpp-uppercase-literal-suffix, -hicpp-vararg, -hicpp-special-member-functions, misc-*, -misc-const-correctness, -misc-no-recursion, -misc-non-private-member-variables-in-classes, -misc-use-anonymous-namespace, -misc-use-internal-linkage, -misc-include-cleaner, modernize-*, -modernize-avoid-c-arrays, -modernize-use-designated-initializers, -modernize-use-nodiscard, -modernize-use-trailing-return-type, performance-*, -performance-avoid-endl, -performance-enum-size, portability-*, readability-*, -readability-braces-around-statements, -readability-container-data-pointer, -readability-convert-member-functions-to-static, -readability-function-cognitive-complexity, -readability-identifier-length, -readability-implicit-bool-conversion, -readability-isolate-declaration, -readability-magic-numbers, -readability-math-missing-parentheses, -readability-named-parameter, -readability-qualified-auto, -readability-redundant-member-init, -readability-suspicious-call-argument, -readability-uppercase-literal-suffix CheckOptions: performance-move-const-arg.CheckTriviallyCopyableMove: false hicpp-move-const-arg.CheckTriviallyCopyableMove: false performance-unnecessary-value-param.AllowedTypes: std::exception_ptr readability-identifier-naming.ClassCase: CamelCase readability-identifier-naming.ClassIgnoredRegexp: buildinfo|glaze readability-identifier-naming.ClassMethodCase: lower_case readability-identifier-naming.ConstexprVariableCase: CamelCase readability-identifier-naming.ConstexprVariablePrefix: k readability-identifier-naming.EnumCase: CamelCase readability-identifier-naming.EnumConstantCase: CamelCase readability-identifier-naming.EnumConstantPrefix: k readability-identifier-naming.FunctionCase: lower_case readability-identifier-naming.GlobalConstantCase: CamelCase readability-identifier-naming.GlobalConstantPrefix: k readability-identifier-naming.LocalVariableCase: lower_case readability-identifier-naming.MacroDefinitionCase: UPPER_CASE readability-identifier-naming.NamespaceCase: lower_case readability-identifier-naming.ParameterCase: lower_case readability-identifier-naming.PrivateMemberCase: lower_case readability-identifier-naming.PrivateMemberSuffix: _ readability-identifier-naming.ProtectedMemberCase: lower_case readability-identifier-naming.ProtectedMemberSuffix: _ readability-identifier-naming.PublicMemberCase: lower_case readability-identifier-naming.PublicMemberSuffix: '' readability-identifier-naming.StaticConstantCase: CamelCase readability-identifier-naming.StaticConstantPrefix: k readability-identifier-naming.StaticVariableCase: lower_case readability-simplify-boolean-expr.SimplifyDeMorgan: false ================================================ FILE: .dockerignore ================================================ # Include any files or directories that you don't want to be copied to your # container here (e.g., local build artifacts, temporary files, etc.). # # For more help, visit the .dockerignore file reference guide at # https://docs.docker.com/engine/reference/builder/#dockerignore-file **/.DS_Store **/__pycache__ **/.venv **/.classpath **/.dockerignore **/.env **/.git **/.gitignore **/.project **/.settings **/.toolstarget **/.vs **/.vscode **/*.*proj.user **/*.dbmdl **/*.jfm **/bin **/build **/charts **/docker-compose* **/compose* **/Dockerfile* **/node_modules **/npm-debug.log **/obj **/secrets.dev.yaml **/values.dev.yaml LICENSE README.md ================================================ FILE: .editorconfig ================================================ # EditorConfig helps developers define and maintain consistent # coding styles between different editors and IDEs # http://editorconfig.org root = true [*] end_of_line = lf charset = utf-8 trim_trailing_whitespace = true insert_final_newline = true [*.{cpp,c,hpp,h}] indent_style = space indent_size = 4 ================================================ FILE: .git-blame-ignore-revs ================================================ # Reformat everything with Clang format 9ba211a89d6d2f5b0820b6ee806cf5b15e556900 ================================================ FILE: .github/actions/fuzzer-common-steps/action.yml ================================================ name: QA - RPC Fuzzer Common Steps description: Common steps for running Silkworm fuzzer tests inputs: fuzzer_sanitizers: description: 'List of enabled fuzzer sanitizers' default: 'OFF' runs: using: "composite" steps: - name: Install Compiler shell: bash run: cmake/setup/compiler_install.sh clang 16 - name: Clean Build Directory shell: bash run: rm -rf ${{runner.workspace}}/silkworm/build - name: Create Build Environment shell: bash run: cmake -E make_directory ${{runner.workspace}}/silkworm/build - name: Temporary step - conan cache cleanup - to be executed only once per runner shell: bash run: /opt/conan2/bin/conan remove --confirm "*" - name: Configure CMake shell: bash working-directory: ${{runner.workspace}}/silkworm/build run: CC=clang-16 CXX=clang++-16 cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCONAN_PROFILE=linux_x64_clang_16_release -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchain/clang_libcxx.cmake -DSILKWORM_FUZZER=ON -DSILKWORM_FUZZER_SANITIZERS=${{inputs.fuzzer_sanitizers}} - name: Build Silkworm Fuzzer Test shell: bash working-directory: ${{runner.workspace}}/silkworm/build run: CC=clang-16 CXX=clang++-16 cmake --build . --target rpcdaemon_fuzzer_test -j 8 - name: Prepare Corpus Directories shell: bash working-directory: ${{runner.workspace}}/silkworm/build/cmd/test run: | echo "Ensure persistent directories for fuzzing corpus are created" mkdir -p $RPC_PAST_TEST_DIR/silkworm-fuzzer/corpus mkdir -p $RPC_PAST_TEST_DIR/silkworm-fuzzer/crashes echo "Create corpus artifacts from execution-api specification" mkdir -p artifacts for file in ../../../third_party/execution-apis/tests/*/*.io; do cp --backup=numbered "$file" artifacts; done for file in artifacts/*; do sed -i '2,$d' "$file"; done for file in artifacts/*; do sed -i 's/^>> //' "$file"; done mkdir -p local-corpus - name: Pause the Erigon instance dedicated to db maintenance shell: bash run: | python3 $ERIGON_QA_PATH/test_system/db-producer/pause_production.py || true - name: Execute Silkworm Fuzzer Test shell: bash working-directory: ${{runner.workspace}}/silkworm/build/cmd/test run: | # Create minimal corpus ./rpcdaemon_fuzzer_test -merge=1 -max_total_time=60 local-corpus $RPC_PAST_TEST_DIR/silkworm-fuzzer/corpus artifacts # Single thread execution ./rpcdaemon_fuzzer_test -max_total_time=25200 -rss_limit_mb=10922 local-corpus - name: Save Fuzzer Test Results shell: bash if: always() working-directory: ${{runner.workspace}}/silkworm/build/cmd/test run: | # Save failed results to the crash directory (ignore errors) cp crash-* $RPC_PAST_TEST_DIR/silkworm-fuzzer/crashes/ 2>/dev/null || : cp leak-* $RPC_PAST_TEST_DIR/silkworm-fuzzer/crashes/ 2>/dev/null || : # Save corpus to the persistent corpus directory rm -rf $RPC_PAST_TEST_DIR/silkworm-fuzzer/corpus/* cp -r local-corpus/* $RPC_PAST_TEST_DIR/silkworm-fuzzer/corpus/ - name: Tear Down Build Environment shell: bash if: always() run: | # Reset compiler paths sudo update-alternatives --remove cc /usr/bin/clang sudo update-alternatives --remove c++ /usr/bin/clang++ sudo rm -f /usr/bin/clang sudo rm -f /usr/bin/clang++ # Resume the Erigon instance dedicated to db maintenance python3 $ERIGON_QA_PATH/test_system/db-producer/resume_production.py || true ================================================ FILE: .github/actions/perf-common-steps/action.yml ================================================ name: QA - RPC Performance Common Steps description: Common steps for running Silkworm performance tests inputs: activation_mode: description: 'Activation mode for performance tests (full/light)' required: true measure_erigon: description: 'Flag indicating if Erigon RPCDaemon must be measured or not (true/false)' required: true runs: using: "composite" steps: - name: Checkout RPC Tests Repository & Install Requirements shell: bash run: | rm -rf ${{runner.workspace}}/rpc-tests git -c advice.detachedHead=false clone --depth 1 --branch v1.57.0 https://github.com/erigontech/rpc-tests ${{runner.workspace}}/rpc-tests cd ${{runner.workspace}}/rpc-tests pip3 install -r requirements.txt --break-system-packages - name: Clean Build Directory shell: bash run: rm -rf ${{runner.workspace}}/silkworm/build - name: Create Build Environment shell: bash run: cmake -E make_directory ${{runner.workspace}}/silkworm/build - name: Configure CMake shell: bash working-directory: ${{runner.workspace}}/silkworm/build run: | cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=Release - name: Build Silkworm RpcDaemon shell: bash working-directory: ${{runner.workspace}}/silkworm/build run: cmake --build . --config Release --target rpcdaemon -j 8 - name: Pause the Erigon instance dedicated to db maintenance shell: bash run: | python3 $ERIGON_QA_PATH/test_system/db-producer/pause_production.py || true - name: Run Silkworm RpcDaemon shell: bash working-directory: ${{runner.workspace}}/silkworm/build/cmd run: | ./rpcdaemon --datadir $ERIGON_DATA_DIR --api admin,debug,eth,parity,erigon,trace,web3,txpool,ots,net --log.verbosity 1 --erigon_compatibility --jwt ./jwt.hex --skip_protocol_check --http.compression --eth.addr 127.0.0.1:51515 & SILKWORM_RPC_DAEMON_PID=$! echo "SILKWORM_RPC_DAEMON_PID=$SILKWORM_RPC_DAEMON_PID" >> $GITHUB_ENV - name: Run Erigon RpcDaemon if: ${{ inputs.measure_erigon == 'true' }} shell: bash run: | $ERIGON_DIR/rpcdaemon --datadir $ERIGON_DATA_DIR --http.api admin,debug,eth,parity,erigon,trace,web3,txpool,ots,net --verbosity 1 & ERIGON_RPC_DAEMON_PID=$! echo "ERIGON_RPC_DAEMON_PID=$ERIGON_RPC_DAEMON_PID" >> $GITHUB_ENV - name: Run RPC Performance Tests id: test_step shell: bash run: | set +e # Disable exit on error failed_test=0 commit=$(git -C ${{runner.workspace}}/silkworm rev-parse --short HEAD) # use ${{ github.sha }} or GITHUB_SHA past_test_dir=$RPC_PAST_TEST_DIR/mainnet_$(date +%Y%m%d_%H%M%S)_perf_$commit echo "past_test_dir=$past_test_dir" >> $GITHUB_ENV # Prepare historical test results directory mkdir -p $past_test_dir rm -rf $RPC_PAST_TEST_DIR/mainnet_bin # we want only the latest binary files mkdir -p $RPC_PAST_TEST_DIR/mainnet_bin run_perf () { servers=("silkworm") if [[ "${{ inputs.measure_erigon }}" == "true" ]]; then servers+=("erigon") fi num_servers=${#servers[@]} for (( i=1; i<=num_servers; i++ )) do network=$1 method=$2 repetitions=$3 pattern=$4 sequence=$5 # clean temporary area cd ${{runner.workspace}}/rpc-tests/perf rm -rf ./reports/ python3 ./run_perf_tests.py --blockchain "$network" \ --test-type "$method" \ --pattern-file pattern/"$network"/"$pattern".tar \ --test-sequence "$sequence" \ --repetitions $repetitions \ --silk-dir ${{runner.workspace}}/silkworm \ --erigon-dir $ERIGON_DATA_DIR \ --test-mode $i \ --test-report \ --json-report ./reports/mainnet/result.json \ --testing-daemon ${servers[i-1]} # Capture test runner script exit status perf_exit_status=$? # Preserve test results mv ${{runner.workspace}}/rpc-tests/perf/reports/mainnet/result.json ${{runner.workspace}}/rpc-tests/perf/reports/mainnet/${servers[i-1]}-$method-result.json # Detect the pre-built db version db_version=$(python3 $ERIGON_QA_PATH/test_system/qa-tests/uploads/prod_info.py $ERIGON_DIR/production.ini production erigon_repo_commit) # Check test runner script exit status if [ $perf_exit_status -eq 0 ]; then # save all vegeta binary report echo "Save current vegeta binary files" cp -r ${{runner.workspace}}/rpc-tests/perf/reports/bin $RPC_PAST_TEST_DIR/mainnet_bin echo "Save test result on DB" cd ${{runner.workspace}}/silkworm python3 $ERIGON_QA_PATH/test_system/qa-tests/uploads/upload_test_results.py \ --repo silkworm \ --branch ${{ github.ref_name }} \ --commit $(git rev-parse HEAD) \ --test_name rpc-performance-test-${servers[i-1]}-$method \ --chain mainnet \ --runner ${{ runner.name }} \ --db_version $db_version \ --outcome success \ --result_file ${{runner.workspace}}/rpc-tests/perf/reports/mainnet/${servers[i-1]}-$method-result.json if [ $? -ne 0 ]; then failed_test=1 echo "Failure saving test results on DB" fi echo "Execute Latency Percentile HDR Analysis" cd ${{runner.workspace}}/rpc-tests/perf/reports/mainnet/ python3 $ERIGON_QA_PATH/test_system/qa-tests/rpc-tests/perf_hdr_analysis.py \ --test_name ${servers[i-1]}-$method \ --input_file ./${servers[i-1]}-$method-result.json \ --output_file ./${servers[i-1]}-${method}-latency_hdr_analysis.pdf else failed_test=1 cd ${{runner.workspace}}/silkworm python3 $ERIGON_QA_PATH/test_system/qa-tests/uploads/upload_test_results.py \ --repo silkworm \ --branch ${{ github.ref_name }} \ --commit $(git rev-parse HEAD) \ --test_name rpc-performance-test-${servers[i-1]}-$method \ --chain mainnet \ --runner ${{ runner.name }} \ --db_version $db_version \ --outcome failure fi # Save test results to a directory with timestamp and commit hash cp -r ${{runner.workspace}}/rpc-tests/perf/reports/mainnet $past_test_dir done } # Launch the RPC performance test runner failed_test=0 if [[ "${{ inputs.activation_mode }}" == "light" ]]; then # Lightweight mode: narrower API coverage, less repetitions, shorter sequences run_perf mainnet eth_call 3 stress_test_eth_call_20M 100:30,1000:20 run_perf mainnet eth_getLogs 3 stress_test_eth_getLogs_15M 100:30,1000:20 run_perf mainnet eth_getBlockByHash 3 stress_test_eth_getBlockByHash_14M 100:30,1000:20 else # Full mode: wider API coverage, more repetitions, longer sequences run_perf mainnet eth_call 5 stress_test_eth_call_20M 1:1,100:30,1000:20,10000:20,20000:20 run_perf mainnet eth_getLogs 5 stress_test_eth_getLogs_15M 1:1,100:30,1000:20,10000:20,20000:20 run_perf mainnet eth_getBalance 5 stress_test_eth_getBalance_15M 1:1,100:30,1000:20,10000:20,20000:20 run_perf mainnet eth_getBlockByHash 5 stress_test_eth_getBlockByHash_14M 1:1,100:30,1000:20,10000:20 run_perf mainnet eth_getBlockByNumber 5 stress_test_eth_getBlockByNumber_13M 1:1,100:30,1000:20,5000:20 run_perf mainnet eth_getTransactionByHash 5 stress_test_eth_getTransactionByHash_13M 1:1,100:30,1000:20,10000:20 run_perf mainnet eth_getTransactionReceipt 5 stress_test_eth_getTransactionReceipt_14M 1:1,100:30,1000:20,5000:20,10000:20,20000:20 run_perf mainnet eth_createAccessList 5 stress_test_eth_createAccessList_16M 1:1,100:30,1000:20,10000:20,20000:20 run_perf mainnet debug_traceTransaction 5 stress_test_debug_trace_transaction_21M 1:1,100:30,1000:20,2000:20 fi if [ $failed_test -eq 0 ]; then echo "TEST_RESULT=success" >> "$GITHUB_OUTPUT" echo "Tests completed successfully" else echo "TEST_RESULT=failure" >> "$GITHUB_OUTPUT" echo "Error detected during tests" fi - name: Stop Silkworm RpcDaemon shell: bash working-directory: ${{runner.workspace}}/silkworm/build/cmd run: | # Clean up process if it's still running if kill -0 $SILKWORM_RPC_DAEMON_PID 2> /dev/null; then echo "Terminating Silkworm RpcDaemon" kill $SILKWORM_RPC_DAEMON_PID else echo "Silkworm RpcDaemon has already terminated" fi - name: Stop Erigon RpcDaemon shell: bash run: | # Clean up process if it's still running if kill -0 $ERIGON_RPC_DAEMON_PID 2> /dev/null; then echo "Terminating Erigon RpcDaemon" kill $ERIGON_RPC_DAEMON_PID else echo "Erigon RpcDaemon has already terminated" fi - name: Resume the Erigon instance dedicated to db maintenance shell: bash run: | python3 $ERIGON_QA_PATH/test_system/db-producer/resume_production.py || true - name: Run change point analysis if: steps.test_step.outputs.TEST_RESULT == 'success' shell: bash working-directory: ${{runner.workspace}}/rpc-tests/perf/reports/mainnet run: | set +e # Disable exit on error open_change_points=0 python3 $ERIGON_QA_PATH/test_system/qa-tests/change-points/change_point_analysis.py --repo silkworm open_change_points=$? cp change_point_analysis.pdf $past_test_dir if [ $open_change_points -ne 0 ]; then echo "Change point analysis found points that need to be investigated" #echo "TEST_RESULT=failure" >> "$GITHUB_OUTPUT" -- enable in the future fi - name: Upload test results if: always() uses: actions/upload-artifact@v4 with: name: test-results path: ${{ env.past_test_dir }} - name: Action for Success if: steps.test_step.outputs.TEST_RESULT == 'success' shell: bash run: echo "::notice::Tests completed successfully" - name: Action for Not Success if: steps.test_step.outputs.TEST_RESULT != 'success' shell: bash run: | echo "::error::Error detected during tests" exit 1 ================================================ FILE: .github/workflows/execution-test.yml ================================================ name: QA - Execution Test on: workflow_dispatch: inputs: stop_at_block: description: 'Block number to stop at; none for all' required: false stop_at_stage: description: 'Stage to stop at; none for all; sample values: "Execution", "IntermediateHashes", "HashState", "HistoryIndex"' required: false type: string clean_datadir: description: 'Remove datadir before running the test' type: boolean default: true jobs: execution-test-suite: runs-on: [ self-hosted, Erigon2 ] # must run on E2 not to steal E3 runner, which is used for PR approval timeout-minutes: 7200 # 5 days env: ERIGON_QA_PATH: /opt/erigon-qa CHAIN: mainnet STOP_AT_BLOCK: ${{github.event.inputs.stop_at_block}} STOP_AT_STAGE: ${{github.event.inputs.stop_at_stage}} TRACKING_TIME_SECONDS: 431400 # 5 days minus 10 minutes TOTAL_TIME_SECONDS: 431400 steps: - name: Checkout Silkworm Repository uses: actions/checkout@v4 with: submodules: recursive fetch-depth: "0" - name: Clean Build Directory run: rm -rf ${{runner.workspace}}/silkworm/build - name: Clean Database Directory if: ${{github.event.inputs.clean_datadir}} run: rm -rf ${{runner.workspace}}/silkworm_datadir - name: Create Build Environment run: cmake -E make_directory ${{runner.workspace}}/silkworm/build - name: Configure CMake working-directory: ${{runner.workspace}}/silkworm/build run: | cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=Release - name: Build Silkworm working-directory: ${{runner.workspace}}/silkworm/build run: cmake --build . --config Release --target silkworm -j 8 - name: Pause the Erigon instance dedicated to db maintenance run: | python3 $ERIGON_QA_PATH/test_system/db-producer/pause_production.py || true - name: Run Execution Test id: test_step working-directory: ${{runner.workspace}}/silkworm/build/cmd run: | set +e # Disable exit on error # Run Silkworm, wait until the end of historical execution and check the result python3 $ERIGON_QA_PATH/test_system/qa-tests/silkworm-execution/run_and_check_execution.py \ ${{runner.workspace}}/silkworm/build/cmd ${{runner.workspace}}/silkworm_datadir $TRACKING_TIME_SECONDS $TOTAL_TIME_SECONDS $CHAIN # Capture monitoring script exit status test_exit_status=$? # Save the subsection reached status echo "::set-output name=test_executed::true" # Check test runner exit status if [ $test_exit_status -eq 0 ]; then echo "tests completed successfully" echo "TEST_RESULT=success" >> "$GITHUB_OUTPUT" else echo "error detected during tests" echo "TEST_RESULT=failure" >> "$GITHUB_OUTPUT" fi - name: Resume the Erigon instance dedicated to db maintenance run: | python3 $ERIGON_QA_PATH/test_system/db-producer/resume_production.py || true - name: Upload test results if: always() uses: actions/upload-artifact@v4 with: name: test-results path: ${{runner.workspace}}/result-${{ env.CHAIN }}.json - name: Upload Silkworm full log if: always() uses: actions/upload-artifact@v4 with: name: silkworm-log path: ${{runner.workspace}}/silkworm/build/cmd/silkworm.log - name: Action for Success if: steps.test_step.outputs.TEST_RESULT == 'success' run: echo "::notice::Tests completed successfully" - name: Action for Failure if: steps.test_step.outputs.TEST_RESULT != 'success' run: | echo "::error::Error detected during tests" exit 1 ================================================ FILE: .github/workflows/macOS.yml ================================================ name: macOS on: push: branches: - master - 'ci/**' concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: osx: runs-on: macos-latest # Disable on external PRs if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository strategy: matrix: config: - {build_type: "Release"} fail-fast: false # This makes it so that if 1 of the tests in the matrix fail, they don't all fail steps: - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: "0" - name: Install Prerequisites run: | pip3 install --user --break-system-packages --no-warn-script-location conan==2.10.2 chardet conan_path="$(python3 -m site --user-base)/bin" echo "$conan_path" >> $GITHUB_PATH "$conan_path/conan" --version - name: Create Build Environment # Some projects don't allow in-source building, so create a separate build directory # We'll use this as our working directory for all subsequent commands run: cmake -E make_directory ${{runner.workspace}}/build - name: ccache uses: hendrikmuhs/ccache-action@v1.2 with: key: ${{ github.job }}-${{ matrix.os }}-${{ matrix.config.cc }}-${{ matrix.config.build_type }} # Eg. "linux_x64-ubuntu-latest-clang-12-Debug" - name: Configure CMake working-directory: ${{runner.workspace}}/build env: CC: ${{ matrix.config.cc}} CXX: ${{ matrix.config.cxx}} run: | export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH" cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} - name: Build working-directory: ${{runner.workspace}}/build # Execute the build. You can specify a specific target with "--target " run: cmake --build . --config ${{ matrix.config.build_type }} -j 2 - name: Smoke tests run: make "SILKWORM_BUILD_DIR=${{runner.workspace}}/build" run_smoke_tests - name: Unit tests run: make "SILKWORM_BUILD_DIR=${{runner.workspace}}/build" run_unit_tests - name: Ethereum EL tests working-directory: ${{runner.workspace}}/build run: | cmd/test/ethereum --threads 4 ================================================ FILE: .github/workflows/rpc-fuzzer-tests.yml ================================================ name: QA - RPC Fuzzer Tests on: workflow_dispatch: schedule: - cron: '0 0 * * 0' # Runs every Sunday at 00:00 AM UTC jobs: fuzzer-test-address-sanitizer: runs-on: [ self-hosted, Erigon2 ] # must run on E2 not to steal E3 runner, which is used for PR approval timeout-minutes: 1440 env: RPC_PAST_TEST_DIR: /opt/rpc-past-tests ERIGON_QA_PATH: /opt/erigon-qa steps: - name: Checkout Silkworm Repository uses: actions/checkout@v4 with: submodules: recursive fetch-depth: "1" # Fetch only the last commit, not the entire history - uses: ./.github/actions/fuzzer-common-steps timeout-minutes: 1440 with: fuzzer_sanitizers: address,leak fuzzer-test-no-sanitizer: needs: fuzzer-test-thread-sanitizer runs-on: [ self-hosted, Erigon2 ] # must run on E2 not to steal E3 runner, which is used for PR approval timeout-minutes: 1440 env: RPC_PAST_TEST_DIR: /opt/rpc-past-tests ERIGON_QA_PATH: /opt/erigon-qa steps: - name: Checkout Silkworm Repository uses: actions/checkout@v4 with: submodules: recursive fetch-depth: "1" # Fetch only the last commit, not the entire history - uses: ./.github/actions/fuzzer-common-steps timeout-minutes: 1440 fuzzer-test-memory-sanitizer: needs: fuzzer-test-no-sanitizer runs-on: [ self-hosted, Erigon2 ] # must run on E2 not to steal E3 runner, which is used for PR approval timeout-minutes: 1440 env: RPC_PAST_TEST_DIR: /opt/rpc-past-tests ERIGON_QA_PATH: /opt/erigon-qa steps: - name: Checkout Silkworm Repository uses: actions/checkout@v4 with: submodules: recursive fetch-depth: "1" # Fetch only the last commit, not the entire history - uses: ./.github/actions/fuzzer-common-steps timeout-minutes: 1440 with: fuzzer_sanitizers: memory fuzzer-test-thread-sanitizer: needs: fuzzer-test-address-sanitizer runs-on: [ self-hosted, Erigon2 ] # must run on E2 not to steal E3 runner, which is used for PR approval timeout-minutes: 1440 env: RPC_PAST_TEST_DIR: /opt/rpc-past-tests ERIGON_QA_PATH: /opt/erigon-qa steps: - name: Checkout Silkworm Repository uses: actions/checkout@v4 with: submodules: recursive fetch-depth: "1" # Fetch only the last commit, not the entire history - uses: ./.github/actions/fuzzer-common-steps timeout-minutes: 1440 with: fuzzer_sanitizers: thread,undefined ================================================ FILE: .github/workflows/rpc-integration-tests.yml ================================================ name: QA - RPC Integration Tests on: pull_request: branches: - master types: - opened - ready_for_review - synchronize jobs: integration-test-suite: strategy: fail-fast: false matrix: backend: [ Erigon3 ] runs-on: [ self-hosted, "${{ matrix.backend }}" ] concurrency: group: ${{ github.workflow }}-${{ matrix.backend }} env: ERIGON_DATA_DIR: /opt/erigon-versions/reference-version/datadir RPC_PAST_TEST_DIR: /opt/rpc-past-tests ERIGON_QA_PATH: /opt/erigon-qa steps: - name: Checkout Silkworm Repository uses: actions/checkout@v4 with: submodules: recursive fetch-depth: "0" - name: Checkout RPC Tests Repository & Install Requirements run: | rm -rf ${{runner.workspace}}/rpc-tests git -c advice.detachedHead=false clone --depth 1 --branch v1.57.0 https://github.com/erigontech/rpc-tests ${{runner.workspace}}/rpc-tests cd ${{runner.workspace}}/rpc-tests pip3 install -r requirements.txt --break-system-packages - name: Clean Build Directory run: rm -rf ${{runner.workspace}}/silkworm/build - name: Create Build Environment run: cmake -E make_directory ${{runner.workspace}}/silkworm/build - name: Configure CMake working-directory: ${{runner.workspace}}/silkworm/build run: | cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=Release - name: Build Silkworm RpcDaemon working-directory: ${{runner.workspace}}/silkworm/build run: cmake --build . --config Release --target rpcdaemon -j 8 - name: Resume the Erigon instance dedicated to db maintenance, if needed run: | python3 $ERIGON_QA_PATH/test_system/db-producer/resume_production.py || true - name: Start Silkworm RpcDaemon working-directory: ${{runner.workspace}}/silkworm/build/cmd run: | ${{runner.workspace}}/silkworm/.github/workflows/start_integration_rpcdaemon.sh $ERIGON_DATA_DIR ./jwt.hex & RPC_DAEMON_PID=$! echo "RPC_DAEMON_PID=$RPC_DAEMON_PID" >> $GITHUB_ENV - name: Wait for port 51515 to be opened run: | api_port=51515 for i in {1..30}; do if nc -z localhost $api_port; then echo "Port $api_port is open" break fi echo "Waiting for port $api_port to open..." sleep 10 done if ! nc -z localhost $api_port; then echo "Port $api_port did not open in time" exit 1 fi - name: Run RPC Integration Tests id: test_step run: | set +e # Disable exit on error # Run RPC integration test runner via http ${{runner.workspace}}/silkworm/.github/workflows/run_integration_tests.sh ${{runner.workspace}}/rpc-tests/integration ${{runner.workspace}}/silkworm/build/cmd/jwt.hex $RPC_PAST_TEST_DIR/mainnet_$(date +%Y%m%d_%H%M%S)_integration_$(git -C ${{runner.workspace}}/silkworm rev-parse --short HEAD)_http/ # Capture test runner script exit status test_exit_status=$? # Check test runner exit status if [ $test_exit_status -eq 0 ]; then echo "TEST_RESULT=success" >> "$GITHUB_OUTPUT" else echo "TEST_RESULT=failure" >> "$GITHUB_OUTPUT" fi - name: Stop Silkworm RpcDaemon working-directory: ${{runner.workspace}}/silkworm/build/cmd run: | ${{runner.workspace}}/silkworm/.github/workflows/stop_integration_rpcdaemon.sh $RPC_DAEMON_PID - name: Resume the Erigon instance dedicated to db maintenance, if crashed or paused run: | python3 $ERIGON_QA_PATH/test_system/db-producer/resume_production.py || true - name: Upload test results if: steps.test_step.outputs.TEST_RESULT != 'success' uses: actions/upload-artifact@v4 with: name: test-results path: ${{runner.workspace}}/rpc-tests/integration/mainnet/results/ - name: Action for Success if: steps.test_step.outputs.TEST_RESULT == 'success' run: echo "::notice::Tests completed successfully" - name: Action for Failure if: steps.test_step.outputs.TEST_RESULT != 'success' run: | echo "::error::Error detected during tests" exit 1 ================================================ FILE: .github/workflows/rpc-performance-tests-light.yml ================================================ name: QA - RPC Performance Tests Light on: workflow_dispatch: inputs: measure_erigon: description: 'Measure Erigon RPCDaemon' type: boolean default: false pull_request: branches: - master types: - ready_for_review jobs: performance-test-suite-light: strategy: matrix: backend: [ Erigon3 ] runs-on: [ self-hosted, "${{ matrix.backend }}" ] env: ERIGON_DIR: /opt/erigon-versions/reference-version ERIGON_DATA_DIR: /opt/erigon-versions/reference-version/datadir RPC_PAST_TEST_DIR: /opt/rpc-past-tests ERIGON_QA_PATH: /opt/erigon-qa steps: - name: Checkout Silkworm repository uses: actions/checkout@v3 with: submodules: recursive fetch-depth: "0" - uses: ./.github/actions/perf-common-steps with: activation_mode: light measure_erigon: ${{github.event.inputs.measure_erigon}} ================================================ FILE: .github/workflows/rpc-performance-tests.yml ================================================ name: QA - RPC Performance Tests on: workflow_dispatch: schedule: - cron: '0 0 * * 1-6' # Runs every day from Monday to Saturday at 00:00 AM UTC jobs: performance-test-suite: strategy: matrix: backend: [ Erigon3 ] runs-on: [ self-hosted, "${{ matrix.backend }}" ] env: ERIGON_DIR: /opt/erigon-versions/reference-version ERIGON_DATA_DIR: /opt/erigon-versions/reference-version/datadir RPC_PAST_TEST_DIR: /opt/rpc-past-tests ERIGON_QA_PATH: /opt/erigon-qa steps: - name: Checkout Silkworm repository uses: actions/checkout@v3 with: submodules: recursive fetch-depth: "0" - uses: ./.github/actions/perf-common-steps with: activation_mode: full measure_erigon: true ================================================ FILE: .github/workflows/run_integration_tests.sh ================================================ #!/bin/bash if [ "$#" -ne 3 ]; then echo "Usage: $0 " exit 1 fi # TODO: why is this disabled? set +e # Disable exit on error set -o pipefail cd "$1" || exit 1 rm -rf ./mainnet/results/ # eth_getLogs: waiting erigon fix on wrong FirstLogIndex in ReceiptsDomain # debug_traceBlockByNumber[24-28]: response different wrt erigon python3 ./run_tests.py --continue --blockchain mainnet --jwt "$2" --display-only-fail --json-diff --port 51515 --transport_type http -x \ debug_traceBlockByNumber/test_24,\ debug_traceBlockByNumber/test_25,\ debug_traceBlockByNumber/test_26,\ debug_traceBlockByNumber/test_27,\ debug_traceBlockByNumber/test_28,\ debug_traceCall/test_21,\ debug_traceCall/test_22,\ debug_traceTransaction/test_25,\ debug_traceTransaction/test_36,\ debug_traceTransaction/test_62,\ debug_traceTransaction/test_74,\ debug_traceTransaction/test_75,\ debug_traceTransaction/test_77,\ engine_,\ eth_getLogs/test_16,\ eth_getLogs/test_17,\ eth_getLogs/test_18,\ eth_getLogs/test_19,\ eth_getLogs/test_20,\ eth_getTransactionByHash/test_02,\ parity_listStorageKeys/test_07,\ trace_replayBlockTransactions/test_29,\ trace_transaction/test_44,\ trace_transaction/test_47 failed_test=$? # Check test runner exit status if [ $failed_test -eq 0 ]; then echo "tests completed successfully" else echo "error detected during tests" # Save failed results to a directory with timestamp and commit hash cp -r "$1"/mainnet/results/ "$3" fi exit $failed_test ================================================ FILE: .github/workflows/snapshot-test.yml ================================================ name: QA - Snapshot Test on: workflow_dispatch: jobs: execution-test-suite: runs-on: [ self-hosted, Erigon2 ] # must run on E2 not to steal E3 runner, which is used for PR approval timeout-minutes: 7200 # 5 days env: ERIGON_QA_PATH: /opt/erigon-qa ERIGON_DATA_DIR: /opt/erigon-versions/reference-version/datadir ERIGON_SNAPSHOT_TEST_DIR: /opt/erigon-snapshot CHAIN: mainnet steps: - name: Checkout Silkworm Repository uses: actions/checkout@v4 with: submodules: recursive fetch-depth: "0" - name: Clean Build Directory run: rm -rf ${{runner.workspace}}/silkworm/build - name: Create Build Environment run: cmake -E make_directory ${{runner.workspace}}/silkworm/build - name: Configure CMake working-directory: ${{runner.workspace}}/silkworm/build run: | cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=Release - name: Build Target Snapshots working-directory: ${{runner.workspace}}/silkworm/build run: cmake --build . --config Release --target snapshots -j 8 - name: Pause the Erigon instance dedicated to db maintenance run: | python3 $ERIGON_QA_PATH/test_system/db-producer/pause_production.py || true - name: Sync the snapshot directory run: | rsync -a --delete $ERIGON_DATA_DIR/snapshots/ $ERIGON_SNAPSHOT_TEST_DIR/ - name: Run Execution Test id: test_step working-directory: ${{runner.workspace}}/silkworm/build/cmd/dev run: | set +e # Disable exit on error # Initialize the variables to collect failed test names and the overall test exit status failed_tests="" test_exit_status=0 # Run the first count_headers script ./snapshots --snapshot_dir "$ERIGON_SNAPSHOT_TEST_DIR" count_headers exit_status=$? if [ $exit_status -ne 0 ]; then failed_tests="$failed_tests count_headers" test_exit_status=1 fi # Run the second count_bodies script ./snapshots --snapshot_dir "$ERIGON_SNAPSHOT_TEST_DIR" count_bodies exit_status=$? if [ $exit_status -ne 0 ]; then failed_tests="$failed_tests count_bodies" test_exit_status=1 fi # Check test runner exit status if [ "$test_exit_status" -eq 0 ]; then echo "Tests completed successfully." echo "TEST_RESULT=success" >> "$GITHUB_OUTPUT" else # Output the list of failed tests without commas echo "Error detected during tests:$failed_tests" echo "TEST_RESULT=failure" >> "$GITHUB_OUTPUT" fi - name: Resume the Erigon instance dedicated to db maintenance run: | python3 $ERIGON_QA_PATH/test_system/db-producer/resume_production.py || true - name: Action for Success if: steps.test_step.outputs.TEST_RESULT == 'success' run: echo "::notice::Tests completed successfully" - name: Action for Failure if: steps.test_step.outputs.TEST_RESULT != 'success' run: | echo "::error::Error detected during tests" exit 1 ================================================ FILE: .github/workflows/start_integration_rpcdaemon.sh ================================================ #!/bin/bash set -e set -o pipefail trap : SIGTERM SIGINT if [ "$#" -ne 2 ]; then echo "Usage: $0 " exit 1 fi echo "Silkworm RpcDaemon starting..." ./rpcdaemon \ --eth.addr 127.0.0.1:51515 \ --engine.addr 127.0.0.1:51516 \ --api admin,debug,eth,parity,erigon,trace,web3,txpool,ots,net \ --log.verbosity info \ --erigon_compatibility \ --datadir "$1" \ --jwt "$2" \ --skip_protocol_check \ --ws & PID=$! wait $PID if [[ $? -gt 128 ]] then kill $PID fi exit 0 ================================================ FILE: .github/workflows/stop_integration_rpcdaemon.sh ================================================ #!/bin/bash set -e set -o pipefail if [ "$#" -ne 1 ]; then echo "Usage: $0 " exit 1 fi # Clean up rpcdaemon process if it's still running if kill -0 "$RPC_DAEMON_PID" 2> /dev/null; then echo "Silkworm RpcDaemon stopping..." kill "$RPC_DAEMON_PID" echo "Silkworm RpcDaemon stopped" else echo "Silkworm RpcDaemon has already terminated" fi ================================================ FILE: .github/workflows/windows.yml ================================================ name: Windows on: push: branches: - master - 'ci/**' concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: windows: runs-on: windows-latest # Disable on external PRs if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository strategy: matrix: config: - {build_type: "Release"} fail-fast: false # This makes it so that if 1 of the tests in the matrix fail, they don't all fail steps: - uses: actions/checkout@v3 with: submodules: recursive fetch-depth: "0" - name: Install Conan id: conan uses: turtlebrowser/get-conan@main with: version: 2.10.2 - name: Create Build Environment # Some projects don't allow in-source building, so create a separate build directory # We'll use this as our working directory for all subsequent commands run: cmake -E make_directory C:\build - name: Configure CMake working-directory: C:\build run: cmake ${{runner.workspace}}\silkworm -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} - name: Build unit tests working-directory: C:\build run: cmake --build . --config ${{ matrix.config.build_type }} --target all_unit_tests -j 1 - name: Build Ethereum EL tests working-directory: C:\build run: cmake --build . --config ${{ matrix.config.build_type }} --target ethereum -j 2 - name: Smoke tests run: cmake -DSILKWORM_BUILD_DIR=C:\build -P cmake\run_smoke_tests.cmake # Disabled after https://github.com/erigontech/silkworm/issues/2083 - name: Unit tests if: false run: cmake -DSILKWORM_BUILD_DIR=C:\build -P cmake\run_unit_tests.cmake # Disabled after https://github.com/erigontech/silkworm/issues/2083 - name: Ethereum EL tests if: false working-directory: C:\build run: | cmd/test/${{ matrix.config.build_type }}/ethereum --threads 4 ================================================ FILE: .gitignore ================================================ build* venv xcode *.code-workspace .DS_Store .idea .vscode .vs CMakeFiles cmake-build-* ================================================ FILE: .gitmodules ================================================ [submodule "asio-grpc"] path = third_party/asio-grpc/asio-grpc url = https://github.com/Tradias/asio-grpc.git [submodule "evmone"] path = third_party/evmone/evmone url = https://github.com/erigontech/evmone.git branch = remove_tracers [submodule "ethereum-tests"] path = third_party/ethereum-tests url = https://github.com/ethereum/tests.git [submodule "cbor-cpp"] path = third_party/cbor-cpp/cbor-cpp url = https://github.com/erigontech/cbor-cpp.git [submodule "interfaces"] path = third_party/erigon-interfaces url = https://github.com/erigontech/interfaces.git [submodule "stbrumme-crc32"] path = third_party/stbrumme-crc32/stbrumme-crc32 url = https://github.com/battlmonstr/stbrumme-crc32.git [submodule "erigon-mdbx-go"] path = third_party/erigon-mdbx-go/mdbx-go url = https://github.com/erigontech/mdbx-go.git [submodule "erigon-snapshot"] path = third_party/erigon-snapshot url = https://github.com/erigontech/erigon-snapshot [submodule "secp256k1"] path = third_party/secp256k1/secp256k1 url = https://github.com/bitcoin-core/secp256k1.git [submodule "libff"] path = third_party/libff/libff url = https://github.com/erigontech/libff.git branch = win [submodule "glaze"] path = third_party/glaze/glaze url = https://github.com/stephenberry/glaze [submodule "cpp-base64"] path = third_party/cpp-base64/cpp-base64 url = https://github.com/ReneNyffenegger/cpp-base64.git [submodule "intx"] path = third_party/intx/intx url = https://github.com/chfast/intx.git [submodule "ethash"] path = third_party/ethash/ethash url = https://github.com/chfast/ethash.git [submodule "stun-msg"] path = third_party/stun-msg/stun-msg url = https://github.com/battlmonstr/stun-msg.git [submodule "execution-apis"] path = third_party/execution-apis url = https://github.com/ethereum/execution-apis.git branch = main [submodule "BlockchainTests"] path = third_party/eest-fixtures/BlockchainTests url = https://github.com/erigontech/eest-fixtures ================================================ FILE: AUTHORS ================================================ # This is the official list of Silkworm authors for copyright purposes. https://github.com/erigontech/silkworm/graphs/contributors ================================================ FILE: CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 cmake_minimum_required(VERSION 3.24.0) if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/evmone/evmone/evmc/.git) message(FATAL_ERROR "Git submodules not initialized, execute:\n git submodule update --init --recursive") endif() get_directory_property(SILKWORM_HAS_PARENT PARENT_DIRECTORY) if(NOT SILKWORM_HAS_PARENT) # reduce the log verbosity of evmone/cmake/cable if(NOT CMAKE_MESSAGE_LOG_LEVEL) set(CMAKE_MESSAGE_LOG_LEVEL_EMPTY YES) set(CMAKE_MESSAGE_LOG_LEVEL NOTICE) endif() include(third_party/evmone/evmone/cmake/cable/bootstrap.cmake) include(CableBuildType) cable_set_build_type(DEFAULT Release CONFIGURATION_TYPES Release Debug) # restore the log verbosity if(CMAKE_MESSAGE_LOG_LEVEL_EMPTY) unset(CMAKE_MESSAGE_LOG_LEVEL) endif() if(NOT CMAKE_TOOLCHAIN_FILE) set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/toolchain/cxx20.cmake CACHE FILEPATH "" FORCE ) include("${CMAKE_TOOLCHAIN_FILE}") endif() include(cmake/conan.cmake) endif() project(silkworm) set(PROJECT_VERSION 0.1.0-dev) include(CableBuildInfo) string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" _ ${PROJECT_VERSION}) set(PROJECT_VERSION_MAJOR ${CMAKE_MATCH_1}) set(PROJECT_VERSION_MINOR ${CMAKE_MATCH_2}) set(PROJECT_VERSION_PATCH ${CMAKE_MATCH_3}) if(CMAKE_BUILD_TYPE STREQUAL "Debug") set(CABLE_GIT_DESCRIBE "c0deadded1111111111111111111111111111111") set(CABLE_GIT_BRANCH "dev") endif() cable_add_buildinfo_library( PROJECT_NAME "${PROJECT_NAME}" GIT_DESCRIBE "${CABLE_GIT_DESCRIBE}" GIT_BRANCH "${CABLE_GIT_BRANCH}" ) option(SILKWORM_WASM_API "Build WebAssembly API" OFF) option(SILKWORM_CORE_ONLY "Only build Silkworm Core" OFF) option(SILKWORM_CORE_USE_ABSEIL "Allow use of Abseil in Silkworm Core" ON) option(SILKWORM_CLANG_COVERAGE "Clang instrumentation for code coverage reports" OFF) option(SILKWORM_CLANG_TIDY "Clang-Tidy linter" OFF) option(SILKWORM_SANITIZE "Build instrumentation for sanitizers" OFF) option(SILKWORM_FUZZER "Build instrumentation for fuzzers" OFF) option(SILKWORM_FUZZER_SANITIZERS "CLang sanitizer options for fuzzers" OFF) option(SILKWORM_USE_MIMALLOC "Enable using mimalloc for dynamic memory management" ON) option(SILKWORM_ALLOW_UNUSED_VAR_WARNINGS "Turn unused variable errors into warnings" OFF) set_property( DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS conanfile.py ) get_filename_component(SILKWORM_MAIN_DIR . ABSOLUTE) set(SILKWORM_MAIN_SRC_DIR "${SILKWORM_MAIN_DIR}/silkworm") include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/compiler_settings.cmake) if(NOT SILKWORM_CORE_ONLY) # Silence CMake policy warnings in submodules set(CMAKE_POLICY_DEFAULT_CMP0048 NEW) # project() command manages VERSION variables set(CMAKE_POLICY_DEFAULT_CMP0063 NEW) # Honor visibility properties for all target types find_package(Boost REQUIRED COMPONENTS headers) # Define Boost::headers target if missing because libtorrent needs it if(NOT TARGET Boost::headers) add_library(Boost::headers INTERFACE IMPORTED) target_include_directories(Boost::headers INTERFACE ${Boost_INCLUDE_DIRS}) endif() endif() add_subdirectory(third_party) include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/compiler_warnings.cmake) if(SILKWORM_CLANG_TIDY) find_program(CLANG_TIDY clang-tidy PATHS "${CMAKE_BINARY_DIR}/tidy/bin" NO_CACHE REQUIRED) set(CMAKE_C_CLANG_TIDY "${CLANG_TIDY}") set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY}") endif() # Silkworm itself add_subdirectory(silkworm) if(NOT SILKWORM_HAS_PARENT) add_subdirectory(cmd) add_subdirectory(examples) endif() # All unit tests target include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/common/get_all_targets.cmake) get_all_targets(UNIT_TEST_TARGETS) list(FILTER UNIT_TEST_TARGETS INCLUDE REGEX "_test$") list(REMOVE_ITEM UNIT_TEST_TARGETS backend_kv_test benchmark_test sentry_client_test) if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") # avoid fatal error C1002: compiler is out of heap space list(REMOVE_ITEM UNIT_TEST_TARGETS silkworm_rpcdaemon_test) endif() message(VERBOSE "UNIT_TEST_TARGETS: ${UNIT_TEST_TARGETS}") add_custom_target(all_unit_tests DEPENDS ${UNIT_TEST_TARGETS}) ================================================ FILE: CMakeSettings.json ================================================ { "configurations": [ { "name": "x64-Debug", "generator": "Visual Studio 17 2022 Win64", "configurationType": "Debug", "inheritEnvironments": [ "msvc_x64_x64" ], "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\silkworm\\build\\${name}", "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\silkworm\\install\\${name}", "cmakeCommandArgs": "-Wno-dev -DSILKWORM_CORE_ONLY:BOOL=OFF", "buildCommandArgs": "", "ctestCommandArgs": "", "addressSanitizerEnabled": false }, { "name": "x64-Release", "generator": "Visual Studio 17 2022 Win64", "configurationType": "Release", "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\silkworm\\build\\${name}", "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\silkworm\\install\\${name}", "cmakeCommandArgs": "-Wno-dev", "buildCommandArgs": "", "ctestCommandArgs": "", "inheritEnvironments": [ "msvc_x64_x64" ], "addressSanitizerEnabled": false } ] } ================================================ FILE: LICENSE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS ================================================ FILE: Makefile ================================================ .PHONY: default help fmt lint_copyright lint build run_smoke_tests run_unit_tests test SILKWORM_BUILD_DIR = build default: build help: @echo "Targets:" @echo "make fmt - reformat the code" @echo "make lint - run code checks" @echo "make build - build all targets" @echo "make test - run built unit and smoke tests" fmt: @cmake -P cmake/cmake_format.cmake @cmake -P cmake/format.cmake lint_copyright: @cmake -P cmake/copyright.cmake lint: lint_copyright build: @cmake --build $(SILKWORM_BUILD_DIR) --parallel $$(cmake/parallel_jobs_count.sh) run_smoke_tests: @cmake/run_smoke_tests.sh $(SILKWORM_BUILD_DIR) run_unit_tests: @cmake/run_unit_tests.sh $(SILKWORM_BUILD_DIR) $(SILKWORM_CLANG_COVERAGE) $(SILKWORM_SANITIZE) $(SILKWORM_PROJECT_DIR) test: run_smoke_tests run_unit_tests ================================================ FILE: README.md ================================================ # Silkworm - C++ Ethereum Execution Client C++ implementation of the [Ethereum] Execution Layer (EL) protocol based on the [Erigon architecture]. [![Linux](https://img.shields.io/circleci/build/gh/erigontech/silkworm?label=Linux)](https://circleci.com/gh/erigontech/silkworm) [![macOS](https://github.com/erigontech/silkworm/actions/workflows/macOS.yml/badge.svg)](https://github.com/erigontech/silkworm/actions/workflows/macOS.yml) [![Windows](https://github.com/erigontech/silkworm/actions/workflows/windows.yml/badge.svg)](https://github.com/erigontech/silkworm/actions/workflows/windows.yml) [![codecov](https://codecov.io/gh/erigontech/silkworm/graph/badge.svg?token=89IPVJGR4Q)](https://codecov.io/gh/erigontech/silkworm) [![JSON RPC Integration Tests](https://github.com/erigontech/silkworm/actions/workflows/rpc-integration-tests.yml/badge.svg)](https://github.com/erigontech/silkworm/actions/workflows/rpc-integration-tests.yml) [![JSON RPC Performance Tests](https://github.com/erigontech/silkworm/actions/workflows/rpc-performance-tests.yml/badge.svg)](https://github.com/erigontech/silkworm/actions/workflows/rpc-performance-tests.yml) ## Table of Contents - [About Silkworm](#about) - [About Silkworm for Erigon, aka Erigon++](#erigon++) - [Obtaining Source Code](#source-code) - [Building on Linux & macOS](#build-on-unix) - [Building on Windows](#build-on-windows) - [Testing Silkworm](#testing) - [Contributing](#contributing) - [License](#license) ## About Silkworm Silkworm is a greenfield C++ implementation of the Ethereum protocol based on the [Erigon architecture]. It aims to be the fastest Ethereum client while maintaining the high quality and readability of its source code. Silkworm uses [libmdbx] as the database engine. Silkworm was conceived as an evolution of the [Erigon] project, as outlined in its [release commentary](https://ledgerwatch.github.io/turbo_geth_release.html#Licence-and-language-migration-plan-out-of-scope-for-the-release). Silkworm is under active development and hasn't reached the alpha phase yet. Hence, there have been no releases so far. ## About Silkworm for Erigon a.k.a. Erigon++ At the very beginning, one of the main goals of Silkworm was implementing high-performance C++ libraries to be used directly within Erigon itself. Recently we focused again on this initial target, making it our highest priority and delivering the first release of [Erigon++] starting from Erigon 2.59.0. Erigon++ is supported on platforms: * Linux x86_64 with glibc 34+, glibcpp 30+ (such as Debian 12+, Ubuntu 22+, etc.) * macOS 15+ arm64 It is not supported on any arm64 Linux, Alpine Linux. Test compatibility by running [silkworm_compat_check.sh](https://github.com/erigontech/erigon/blob/main/turbo/silkworm/silkworm_compat_check.sh) Please note that Erigon++ is just a fancy name for identifying such usage of Silkworm libraries within Erigon, which can be selectively enabled by specifying optional flags in Erigon command-line. There are two possible usages of Erigon++: * as a user, you may want to test Erigon++ features out of the box: in this case, no Silkworm build is required, you just build Erigon as usual and then enable any of the command-line flags: ``` --silkworm.exec [enables historical block execution powered by Silkworm] --silkworm.rpc [enables Ethereum JSON-RPC API powered by Silkworm] --silkworm.sentry [enables Execution Layer p2p networking powered by Silkworm] ``` * as a developer, you may want to experiment how you can build Erigon with Silkworm bindings and how you can play with them together through [Cgo]. If you are interested, we have some documentation about the development process of our [C API for Erigon](https://github.com/erigontech/silkworm/blob/master/docs/CONTRIBUTING.md#c-api-for-erigon). ## Obtaining Source Code To obtain Silkworm source code for the first time: ``` git clone --recurse-submodules https://github.com/erigontech/silkworm.git cd silkworm ``` Silkworm uses a few git submodules (some of which have their own submodules). So after you've updated to the latest code with ``` git pull ``` update the submodules as well by running ``` git submodule update --init --recursive ``` ## Building on Linux & macOS Building Silkworm requires: * C++20 compiler: [GCC](https://www.gnu.org/software/gcc/) >= 11.2 or [Clang](https://clang.llvm.org/) >= 16 or AppleClang ([Xcode](https://developer.apple.com/xcode/) >= 16) * [CMake](https://cmake.org) * [Conan](https://conan.io) Conan requires Python, and can be installed using: pip3 install --user conan==2.10.2 chardet On Linux the conan binary gets installed into `$HOME/.local/bin` which is typically in PATH already. On macOS need to add the binary to PATH manually: export "PATH=$HOME/Library/Python/3.9/bin:$PATH" Once the prerequisites are installed, bootstrap cmake by running ``` mkdir build cd build cmake .. ``` (In the future you don't have to run `cmake ..` again.) A custom Conan "profile" can be passed via a cmake argument, for example: cmake .. -DCONAN_PROFILE=macos_arm64_clang_13_debug will use "debug" configuration builds of dependencies. See available profiles in [cmake/profiles](cmake/profiles). During the cmake configuration step `conan_provider.cmake` runs a [conan install](https://docs.conan.io/2/reference/commands/install.html) command that downloads packages and builds some of them from source if needed. The exact arguments to this command are printed in the build log. Then run the build itself ``` make -j ``` _Note about parallel builds using `-j`: if not specified the exact number of parallel tasks, the compiler will spawn as many as the cores available. That may cause OOM errors if the build is executed on a host with a large number of cores but a relatively small amount of RAM. To work around this, either specify `-jn` where `n` is the number of parallel tasks you want to allow or remove `-j` completely. Typically, for Silkworm each compiler job requires 4GB of RAM. So, if your total RAM is 16GB, for example, then `-j4` should be OK, while `-j8` is probably not. It also means that you need a machine with at least 4GB RAM to compile Silkworm._ Now you can run the unit tests ``` make test ``` or the [Ethereum EL Tests] ``` cmd/test/ethereum ``` ## Building on Windows **Note! Windows builds are maintained for compatibility/portability reasons. However, due to the lack of 128-bit integers support by MSVC, execution performance is inferior when compared to Linux builds.** * Install [Visual Studio] 2019. Community edition is fine. * Make sure your setup includes CMake support and Windows 10 SDK. * Install [Conan](https://conan.io) and add it to PATH. * Open Visual Studio and select File -> CMake... * Browse the folder where you have cloned this repository and select the file CMakeLists.txt * Let CMake cache generation complete (it may take several minutes) * Solution explorer shows the project tree. * To build simply `CTRL+Shift+B` * Binaries are written to `%USERPROFILE%\CMakeBuilds\silkworm\build` If you want to change this path simply edit `CMakeSettings.json` file. **Note ! Memory compression on Windows 10/11** Windows 10/11 provide a _memory compression_ feature which makes available more RAM than what physically mounted at cost of extra CPU cycles to compress/decompress while accessing data. As MDBX is a memory mapped file this feature may impact overall performances. Is advisable to have memory compression off. Use the following steps to detect/enable/disable memory compression: * Open a PowerShell prompt with Admin privileges * Run `Get-MMAgent` (check whether memory compression is enabled) * To disable memory compression : `Disable-MMAgent -mc` and reboot * To enable memory compression : `Enable-MMAgent -mc` and reboot ## Testing Silkworm **Note: at current state of development Silkworm can't actually sync the chain like Erigon does.** You can try to run Silkworm to test just the sync on the *pre-Merge* Ethereum chain. In order to do that you need to: - run an instance of `Erigon Sentry` component from branch `release/2.60` - set the environment variable `STOP_AT_BLOCK` to a value < 15'537'351 (e.g. STOP_AT_BLOCK=15000000) ### Linux and macOS #### Erigon Sentry ``` git clone --recurse-submodules https://github.com/erigontech/erigon.git cd erigon git checkout release/2.60 make sentry ./build/bin/sentry ``` #### Silkworm ``` export STOP_AT_BLOCK=15000000 ./cmd/silkworm ``` ### Windows #### Erigon Sentry ``` git clone --recurse-submodules https://github.com/erigontech/erigon.git cd erigon git checkout release/2.60 make sentry ./build/bin/sentry.exe ``` #### Silkworm ``` $env:STOP_AT_BLOCK=15000000 ./cmd/silkworm.exe ``` ## Contributing If you want to contribute, you can read our [contribution guidelines](docs/CONTRIBUTING.md). ## License Silkworm is licensed under the terms of the Apache license. See [LICENSE](LICENSE) for more information. Some files in [elias_fano](silkworm/db/datastore/snapshots/elias_fano) and [rec_split](silkworm/db/datastore/snapshots/rec_split) folders are licensed under the LGPL license. [Ethereum]: https://ethereum.org [Ethereum EL Tests]: https://github.com/ethereum/tests [Erigon]: https://github.com/erigontech/erigon [Erigon architecture]: https://github.com/erigontech/interfaces/blob/master/_docs/README.md [Erigon++]: https://erigon.tech/erigonpp [Cgo]: https://go.dev/blog/cgo [GMP]: http://gmplib.org [libmdbx]: https://github.com/erthink/libmdbx [staged sync]: https://github.com/erigontech/erigon/blob/main/eth/stagedsync/README.md [Visual Studio]: https://www.visualstudio.com/downloads [Yellow Paper]: https://ethereum.github.io/yellowpaper/paper.pdf ================================================ FILE: cmake/cmake_format.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_program(CMAKE_FORMAT cmake-format) if(NOT EXISTS "${CMAKE_FORMAT}") message(FATAL_ERROR "'cmake-format' command not found in PATH. Please install it using:\n\t" "pip3 install --user cmake-format==0.6.13" ) endif() cmake_policy(SET CMP0009 NEW) file( GLOB_RECURSE SRC LIST_DIRECTORIES false "cmake/*.cmake" "cmake/CMakeLists.txt" "cmd/*.cmake" "cmd/CMakeLists.txt" "examples/*.cmake" "examples/CMakeLists.txt" "silkworm/*.cmake" "silkworm/CMakeLists.txt" "third_party/CMakeLists.txt" ) list(PREPEND SRC "${CMAKE_CURRENT_LIST_DIR}/../CMakeLists.txt") list(FILTER SRC EXCLUDE REGEX "third_party/.+/(.+/)+CMakeLists.txt$") execute_process( COMMAND "${CMAKE_FORMAT}" --in-place "--config-file=${CMAKE_CURRENT_LIST_DIR}/cmake_format.yaml" ${SRC} COMMAND_ERROR_IS_FATAL ANY ) ================================================ FILE: cmake/cmake_format.yaml ================================================ parse: additional_commands: conan_cmake_install: kwargs: PATH_OR_REFERENCE: '*' INSTALL_FOLDER: '*' BUILD: '*' OPTIONS: '*' PROFILE: '*' CONF: '*' silkworm_library: flags: - NO_TEST kwargs: PUBLIC: '*' PRIVATE: '*' TYPE: '*' execute_process: flags: - OUTPUT_STRIP_TRAILING_WHITESPACE kwargs: COMMAND_ERROR_IS_FATAL: '*' RESULT_VARIABLE: '*' OUTPUT_VARIABLE: '*' format: line_width: 120 tab_size: 2 max_subgroups_hwrap: 2 max_pargs_hwrap: 5 dangle_parens: true markup: first_comment_is_literal: true ================================================ FILE: cmake/common/get_all_targets.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 # https://stackoverflow.com/a/62311397/1009546 function(get_all_targets var) set(targets) get_all_targets_recursive(targets ${CMAKE_CURRENT_SOURCE_DIR}) set(${var} ${targets} PARENT_SCOPE ) endfunction() macro(get_all_targets_recursive targets dir) get_property( subdirectories DIRECTORY ${dir} PROPERTY SUBDIRECTORIES ) foreach(subdir ${subdirectories}) get_all_targets_recursive(${targets} ${subdir}) endforeach() get_property( current_targets DIRECTORY ${dir} PROPERTY BUILDSYSTEM_TARGETS ) list(APPEND ${targets} ${current_targets}) endmacro() ================================================ FILE: cmake/common/targets.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(Catch2 REQUIRED) macro(list_filter_dirs VAR DIRS) foreach(DIR IN LISTS ${DIRS}) list(FILTER ${VAR} EXCLUDE REGEX "^${DIR}/") endforeach() endmacro() function(silkworm_library TARGET) cmake_parse_arguments( PARSE_ARGV 1 "ARG" "NO_TEST" "TYPE" "PUBLIC;PRIVATE" ) file( GLOB_RECURSE SRC CONFIGURE_DEPENDS "*.cpp" "*.hpp" "*.c" "*.h" ) # remove subdirectories with CMakeLists.txt get_directory_property(SUB_LIBS SUBDIRECTORIES) list_filter_dirs(SRC SUB_LIBS) # cli subdirectories with CMakeLists.txt belong only to silkworm_*_cli libraries if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" MATCHES "/cli$") list(FILTER SRC EXCLUDE REGEX "\/cli\/") endif() set(TEST_REGEX "_test\\.cpp$") # test_util subdirectories without CMakeLists.txt belong to TEST_SRC if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" MATCHES "/test_util$") set(TEST_REGEX "(${TEST_REGEX}|\/test_util\/)") endif() set(TEST_SRC ${SRC}) list(FILTER TEST_SRC INCLUDE REGEX "${TEST_REGEX}") list(FILTER SRC EXCLUDE REGEX "${TEST_REGEX}") list(FILTER SRC EXCLUDE REGEX "_benchmark\\.cpp$") add_library(${TARGET} ${ARG_TYPE} ${SRC}) target_include_directories(${TARGET} PUBLIC "${SILKWORM_MAIN_DIR}") target_link_libraries( ${TARGET} PUBLIC "${ARG_PUBLIC}" PRIVATE "${ARG_PRIVATE}" ) # unit tests if(TEST_SRC AND NOT ${ARG_NO_TEST}) set(TEST_TARGET ${TARGET}_test) add_executable(${TEST_TARGET} ${TEST_SRC}) target_link_libraries(${TEST_TARGET} PRIVATE Catch2::Catch2WithMain ${TARGET}) endif() endfunction() ================================================ FILE: cmake/compiler_settings.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include(${CMAKE_CURRENT_LIST_DIR}/compiler_settings_sanitize.cmake) if(MSVC) message("MSVC_VERSION = ${MSVC_VERSION}") message("MSVC_CXX_ARCHITECTURE_ID = ${MSVC_CXX_ARCHITECTURE_ID}") # cmake-format: off add_compile_definitions(_WIN32_WINNT=0x0602) # Min Windows 8 add_compile_definitions(VC_EXTRALEAN) # Process windows headers faster ... add_compile_definitions(WIN32_LEAN_AND_MEAN) # ... and prevent winsock mismatch with Boost's add_compile_definitions(NOMINMAX) # Prevent MSVC to tamper with std::min/std::max add_compile_definitions(PSAPI_VERSION=2) # For process info # LINK : fatal error LNK1104: cannot open file 'libboost_date_time-vc142-mt-x64-1_72.lib # is solved by this (issue only for MVC) add_compile_definitions(BOOST_DATE_TIME_NO_LIB) add_compile_options(/MP) # Enable parallel compilation add_compile_options(/EHa) # Enable standard C++ unwinding add_compile_options(/await:strict) # Enable coroutine support in std namespace #[[ There is an issue on CLion IDE when toolchain is MSVC. Basically it wrongly parses file(line,column) which are meant to point to an error or a warning. Adding the following compile option works around the problem but still has to be considered a temporary solution. https://youtrack.jetbrains.com/issue/CPP-20259?_ga=2.92522975.312527487.1632161219-1027977455.1629393843&_gac=1.251211380.1631446966.CjwKCAjwyvaJBhBpEiwA8d38vIMQB8b0QfoFeQR5Mf4LHU50RFx3CWeeNzVeCrDOr1QcnfCpUPbFTBoCLEYQAvD_BwE ]] add_compile_options(/diagnostics:classic) add_compile_options(/bigobj) # Increase .obj sections, needed for hard coded pre-verified hashes # Required for proper detection of __cplusplus # see https://docs.microsoft.com/en-us/cpp/build/reference/zc-cplusplus?view=msvc-160 add_compile_options(/Zc:__cplusplus) if(CMAKE_BUILD_TYPE MATCHES "Release") add_compile_options(/GL) # Enable LTCG for faster builds set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /LTCG") # Enable LTCG for faster builds set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LTCG") # Enable LTCG for faster builds set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /OPT:REF /OPT:ICF") # Enable unused references removal set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /RELEASE") # Enable RELEASE so that the executable file has its checksum set endif() if(CMAKE_BUILD_TYPE MATCHES "Debug") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /VERBOSE /TIME") # Debug linker endif() # cmake-format: on elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") # coroutines support if(NOT SILKWORM_WASM_API) add_compile_options($<$:-fcoroutines>) endif() elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang$") if(SILKWORM_CLANG_COVERAGE) add_compile_options(-fprofile-instr-generate -fcoverage-mapping) add_link_options(-fprofile-instr-generate -fcoverage-mapping) endif() # configure libc++ if(NOT SILKWORM_WASM_API) add_compile_options($<$:-stdlib=libc++>) # std::views::join is experimental on clang < 18 and Apple clang < 16 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18) add_compile_options(-fexperimental-library) endif() if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16) add_compile_options(-fexperimental-library) endif() link_libraries(c++) link_libraries(c++abi) endif() else() message(WARNING "${CMAKE_CXX_COMPILER_ID} is not a supported compiler. Use at your own risk.") endif() if(SILKWORM_SANITIZE_COMPILER_OPTIONS) add_compile_options(${SILKWORM_SANITIZE_COMPILER_OPTIONS}) add_link_options(${SILKWORM_SANITIZE_COMPILER_OPTIONS}) add_compile_definitions(SILKWORM_SANITIZE) # asio is using atomic_thread_fence in asio::detail::std_fenced_block, unsupported on GCC with thread sanitizer. See: # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97868 # https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wtsan if("${SILKWORM_SANITIZE}" STREQUAL "thread" AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") add_compile_options(-Wno-error=tsan) endif() # MDBX triggers unaligned access errors in sanitizer builds add_compile_definitions(MDBX_UNALIGNED_OK=0) endif() # Position independent code set(CMAKE_POSITION_INDEPENDENT_CODE TRUE) # Stack set(SILKWORM_STACK_SIZE 0x1000000) if(MSVC) add_link_options(/STACK:${SILKWORM_STACK_SIZE}) elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") add_link_options(-Wl,-stack_size -Wl,${SILKWORM_STACK_SIZE}) else() add_link_options(-Wl,-z,stack-size=${SILKWORM_STACK_SIZE}) # https://clang.llvm.org/docs/SafeStack.html if("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang$" AND NOT SILKWORM_WASM_API AND NOT SILKWORM_SANITIZE AND NOT SILKWORM_FUZZER ) add_compile_options(-fsanitize=safe-stack) add_link_options(-fsanitize=safe-stack) endif() endif() add_compile_definitions(SILKWORM_CAPI_COMPONENT) ================================================ FILE: cmake/compiler_settings_sanitize.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 if(SILKWORM_SANITIZE) # cmake-format: off set(SILKWORM_SANITIZE_COMPILER_OPTIONS -fno-omit-frame-pointer -fno-sanitize-recover=all -fsanitize=${SILKWORM_SANITIZE} ) # cmake-format: on endif() ================================================ FILE: cmake/compiler_warnings.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 if(MSVC) add_compile_options(/wd4127) # Silence warnings about "conditional expression is constant" (abseil mainly) add_compile_options(/wd5030) # Silence warnings about GNU attributes add_compile_options(/wd4324) # Silence warning C4324: 'xxx': structure was padded due to alignment specifier add_compile_options(/wd4068) # Silence warning C4068: unknown pragma add_compile_options(/wd5030) # Silence warning C5030: unknown gnu/clang attribute add_compile_options(/W4) # Display all other un-silenced warnings add_link_options(/ignore:4099) elseif((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang$")) add_compile_options(-Werror -Wall -Wextra -pedantic) add_compile_options(-Wshadow -Wimplicit-fallthrough -Wunused) add_compile_options(-Wsign-compare -Wsign-conversion -Wdouble-promotion) add_compile_options($<$:-Wold-style-cast>) add_compile_options($<$:-Wnon-virtual-dtor>) add_compile_options($<$:-Woverloaded-virtual>) add_compile_options(-Wtype-limits -Wformat=2) add_compile_options(-Wno-missing-field-initializers) if(SILKWORM_ALLOW_UNUSED_VAR_WARNINGS) add_compile_options(-Wno-error=unused-parameter) add_compile_options(-Wno-error=unused-variable) endif() if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") add_compile_options(-Wduplicated-cond -Wduplicated-branches -Wlogical-op) add_compile_options(-Wno-attributes) if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12) # gcc 12 apparently has regressions in uninitialized diagnostics add_compile_options(-Wno-error=maybe-uninitialized) endif() add_compile_options(-Wno-error=mismatched-new-delete) elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang$") add_compile_options(-Wconversion) # too much noise in gcc if(CMAKE_SYSTEM_NAME MATCHES "Darwin") add_compile_definitions(_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS) add_compile_options(-Wthread-safety) endif() if((CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 15)) # https://stackoverflow.com/questions/77164140/ add_link_options(-Wl,-no_warn_duplicate_libraries) endif() endif() else() message(WARNING "${CMAKE_CXX_COMPILER_ID} is not a supported compiler. Use at your own risk.") endif() ================================================ FILE: cmake/conan.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include(${CMAKE_CURRENT_LIST_DIR}/compiler_settings_sanitize.cmake) include(${CMAKE_CURRENT_LIST_DIR}/conan_quiet.cmake) function(guess_conan_profile) if("${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "" AND CMAKE_HOST_UNIX) execute_process( COMMAND uname -m OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ERROR_IS_FATAL ANY ) endif() if("${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "") set(ARCH_NAME "") elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL x86_64) set(ARCH_NAME x64) elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL IA64) set(ARCH_NAME x64) elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL AMD64) set(ARCH_NAME x64) elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL arm64) set(ARCH_NAME arm64) elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL AArch64) set(ARCH_NAME arm64) endif() if(SILKWORM_WASM_API) set(PROFILE wasi_release) elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND ARCH_NAME) set(PROFILE linux_${ARCH_NAME}_gcc_11_release) elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin" AND ARCH_NAME) set(PROFILE macos_${ARCH_NAME}_clang_13_release) elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") set(PROFILE windows_msvc_193_release) else() message(FATAL_ERROR "CONAN_PROFILE is not defined for ${CMAKE_HOST_SYSTEM_NAME} on ${CMAKE_HOST_SYSTEM_PROCESSOR}") endif() set(CONAN_PROFILE ${PROFILE} PARENT_SCOPE ) endfunction() function(get_conan_build_type profile_path var) file(READ "${profile_path}" CONTENTS) string(REGEX MATCH "build_type=[A-Za-z0-9]+" VALUE "${CONTENTS}") string(SUBSTRING "${VALUE}" 11 -1 VALUE) set(${var} "${VALUE}" PARENT_SCOPE ) endfunction() macro(format_list_as_json_array list_var var) list(JOIN ${list_var} "\",\"" ${var}) set(${var} "[\"${${var}}\"]") endmacro() # unset(CONAN_COMMAND CACHE) find_program( CONAN_COMMAND "conan" PATHS /opt/conan2/bin /opt/homebrew/opt/conan@2/bin NO_DEFAULT_PATH ) if(NOT CONAN_COMMAND) find_program(CONAN_COMMAND "conan" PATHS ~/.local/bin REQUIRED) endif() # use "verbose" for more detailed conan install logs set(CONAN_VERBOSITY "error") set(CONAN_BINARY_DIR "${CMAKE_BINARY_DIR}/conan2") if(NOT DEFINED CONAN_PROFILE) guess_conan_profile() endif() message(VERBOSE "CONAN_PROFILE: ${CONAN_PROFILE}") set(CONAN_PROFILE_PATH "${CMAKE_SOURCE_DIR}/cmake/profiles/${CONAN_PROFILE}") set(CONAN_HOST_PROFILE "${CONAN_PROFILE_PATH}") set(CONAN_BUILD_PROFILE "${CONAN_PROFILE_PATH}") get_conan_build_type("${CONAN_PROFILE_PATH}" CONAN_BUILD_TYPE) set(CONAN_BUILD "missing") set(CONAN_SETTINGS "") set(CONAN_OPTIONS "") set(CONAN_CONF "") if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin") set(OS_VERSION_MIN_CXXFLAG "-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}") endif() if(OS_VERSION_MIN_CXXFLAG AND NOT SILKWORM_SANITIZE_COMPILER_OPTIONS) list(APPEND CONAN_CONF "tools.build:cxxflags=[\"${OS_VERSION_MIN_CXXFLAG}\"]") list(APPEND CONAN_CONF "tools.build:cflags=[\"${OS_VERSION_MIN_CXXFLAG}\"]") endif() if(SILKWORM_SANITIZE_COMPILER_OPTIONS) set(CONAN_CXXFLAGS ${SILKWORM_SANITIZE_COMPILER_OPTIONS}) if(OS_VERSION_MIN_CXXFLAG) list(APPEND CONAN_CXXFLAGS ${OS_VERSION_MIN_CXXFLAG}) list(APPEND CONAN_CONF "tools.build:cflags=[\"${OS_VERSION_MIN_CXXFLAG}\"]") endif() format_list_as_json_array(CONAN_CXXFLAGS CONAN_CXXFLAGS_STR) list(APPEND CONAN_CONF "tools.build:cxxflags=${CONAN_CXXFLAGS_STR}") list(APPEND CONAN_OPTIONS "boost/*:zlib=False") list(APPEND CONAN_OPTIONS "grpc/*:with_libsystemd=False") # libraries that must be rebuilt with sanitizer flags # cmake-format: off set(CONAN_BUILD "abseil/*" "boost/*" "grpc/*" "libtorrent/*" "protobuf/*" ) list(APPEND CONAN_BUILD "missing") # cmake-format: on endif() if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") set(CONAN_VERBOSITY "verbose") # make sure to not rebuild anything from source unless required set(CONAN_BUILD "missing:libtorrent/*") list(APPEND CONAN_BUILD "missing:protobuf/*") # HACK: MSVC is "multi config" and conan_provider.cmake runs 2 conan install commands for both Release and Debug # despite CMAKE_BUILD_TYPE. This adds an extra build_type setting to both commands to override and force the desired # build type. It still runs 2 commands, but the 2nd one has no effect. list(APPEND CONAN_SETTINGS "build_type=${CMAKE_BUILD_TYPE}") # most Windows packages on ConanCenter are built for cppstd=14, but some packages require at least cppstd=17 # (otherwise report "Invalid" status) list(APPEND CONAN_SETTINGS "magic_enum/*:compiler.cppstd=17") list(APPEND CONAN_SETTINGS "tomlplusplus/*:compiler.cppstd=17") endif() if(SILKWORM_USE_MIMALLOC) # mimalloc override option causes a crash on macOS at startup in rpcdaemon, so we enable it just on Linux. mimalloc # should not be used in sanitizer builds or at least its override option must be disabled # (https://github.com/microsoft/mimalloc/issues/317#issuecomment-708506405) if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND NOT SILKWORM_SANITIZE) list(APPEND CONAN_OPTIONS "mimalloc/*:override=True") endif() endif() if(SILKWORM_CORE_ONLY) list(APPEND CONAN_CONF "catch2/*:tools.build:cxxflags=[\"-fno-exceptions\"]") endif() # cmake-format: off set(CONAN_INSTALL_ARGS -v ${CONAN_VERBOSITY} --output-folder "${CONAN_BINARY_DIR}" # https://github.com/conan-io/cmake-conan/issues/607 --settings:all "&:build_type=${CMAKE_BUILD_TYPE}" ) # cmake-format: on foreach(VALUE IN LISTS CONAN_BUILD) list(APPEND CONAN_INSTALL_ARGS --build=${VALUE}) endforeach() foreach(VALUE IN LISTS CONAN_SETTINGS) list(APPEND CONAN_INSTALL_ARGS --settings:all=${VALUE}) endforeach() foreach(VALUE IN LISTS CONAN_OPTIONS) list(APPEND CONAN_INSTALL_ARGS --options:all=${VALUE}) endforeach() foreach(VALUE IN LISTS CONAN_CONF) list(APPEND CONAN_INSTALL_ARGS --conf:all=${VALUE}) endforeach() set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES "${CMAKE_SOURCE_DIR}/third_party/cmake-conan/conan_provider.cmake") ================================================ FILE: cmake/conan_quiet.cmake ================================================ # Reduce verbosity of CMakeDeps conan generator # do not edit, regenerate with conan_quiet.sh set(ZLIB_FIND_QUIETLY YES) set(Catch2_FIND_QUIETLY YES) set(jwt-cpp_FIND_QUIETLY YES) set(GTest_FIND_QUIETLY YES) set(LibtorrentRasterbar_FIND_QUIETLY YES) set(Snappy_FIND_QUIETLY YES) set(Microsoft.GSL_FIND_QUIETLY YES) set(OpenSSL_FIND_QUIETLY YES) set(fmt_FIND_QUIETLY YES) set(roaring_FIND_QUIETLY YES) set(BZip2_FIND_QUIETLY YES) set(c-ares_FIND_QUIETLY YES) set(magic_enum_FIND_QUIETLY YES) set(absl_FIND_QUIETLY YES) set(OpenSSL_FIND_QUIETLY YES) set(tomlplusplus_FIND_QUIETLY YES) set(spdlog_FIND_QUIETLY YES) set(SQLite3_FIND_QUIETLY YES) set(CLI11_FIND_QUIETLY YES) set(tl-expected_FIND_QUIETLY YES) set(asio-grpc_FIND_QUIETLY YES) set(benchmark_FIND_QUIETLY YES) set(gmp_FIND_QUIETLY YES) set(Boost_FIND_QUIETLY YES) set(SQLite3_FIND_QUIETLY YES) set(mimalloc_FIND_QUIETLY YES) set(re2_FIND_QUIETLY YES) set(gRPC_FIND_QUIETLY YES) set(protobuf_FIND_QUIETLY YES) set(ZLIB_FIND_QUIETLY YES) set(Protobuf_FIND_QUIETLY YES) set(BZip2_FIND_QUIETLY YES) set(SQLiteCpp_FIND_QUIETLY YES) set(GTest_FIND_QUIETLY YES) set(nlohmann_json_FIND_QUIETLY YES) set(libdeflate_FIND_QUIETLY YES) ================================================ FILE: cmake/conan_quiet.sh ================================================ #!/bin/bash script_dir=$(dirname "${BASH_SOURCE[0]}") project_dir="$script_dir/.." build_dir="$1" if [[ -z "$build_dir" ]] then build_dir="$project_dir/build" fi cat << EOF > "$script_dir/conan_quiet.cmake" # Reduce verbosity of CMakeDeps conan generator # do not edit, regenerate with conan_quiet.sh EOF grep -R FIND_QUIETLY "$build_dir/conan2" | sed -E 's/.+\((.+)\)/set(\1 YES)/' >> "$script_dir/conan_quiet.cmake" ================================================ FILE: cmake/copyright.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 set(COPYRIGHT_HEADER_TEMPLATE_C "// Copyright YYYY The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 " ) set(COPYRIGHT_HEADER_TEMPLATE_SH "# Copyright YYYY The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 " ) set(SILKWORM_COPYRIGHT_YEARS "2025") function(check file_path template) string(LENGTH "${template}" header_len) file(READ "${file_path}" header LIMIT ${header_len}) foreach(Y IN LISTS SILKWORM_COPYRIGHT_YEARS) string(REPLACE "YYYY" "${Y}" COPYRIGHT_HEADER "${template}") if(header STREQUAL COPYRIGHT_HEADER) return() endif() endforeach() message(SEND_ERROR "${file_path}: the copyright header differs from the other files") endfunction() cmake_policy(SET CMP0009 NEW) file( GLOB_RECURSE SRC LIST_DIRECTORIES false "cmd/*.?pp" "examples/*.?pp" "silkworm/*.?pp" ) list(FILTER SRC EXCLUDE REGEX [[silkworm/core/chain/genesis_[a-z_]+\.cpp$]]) list(FILTER SRC EXCLUDE REGEX [[silkworm/core/common/lru_cache(_test)?\..pp$]]) list(FILTER SRC EXCLUDE REGEX [[silkworm/core/crypto/kzg\.cpp$]]) list(FILTER SRC EXCLUDE REGEX [[silkworm/infra/concurrency/thread_pool\.hpp$]]) list(FILTER SRC EXCLUDE REGEX [[silkworm/interfaces/]]) list(FILTER SRC EXCLUDE REGEX [[silkworm/db/datastore/snapshots/config/chains/[a-z_]+\.hpp$]]) list(FILTER SRC EXCLUDE REGEX [[silkworm/rpc/json_rpc/specification\.cpp$]]) list(FILTER SRC EXCLUDE REGEX [[silkworm/sync/internals/preverified_hashes/preverified_hashes_[a-z]+\.cpp$]]) foreach(F IN LISTS SRC) check("${F}" "${COPYRIGHT_HEADER_TEMPLATE_C}") endforeach() file( GLOB_RECURSE SRC_CMAKE LIST_DIRECTORIES false "cmake/*.cmake" "cmake/*CMakeLists.txt" "cmd/*CMakeLists.txt" "examples/*CMakeLists.txt" "silkworm/*CMakeLists.txt" ) list(FILTER SRC_CMAKE EXCLUDE REGEX [[cmake/conan_quiet.cmake$]]) foreach(F IN LISTS SRC_CMAKE) check("${F}" "${COPYRIGHT_HEADER_TEMPLATE_SH}") endforeach() ================================================ FILE: cmake/format.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} OS_NAME) set(ARCH_NAME x64) find_program( CLANG_FORMAT clang-format PATHS "third_party/clang-format/${OS_NAME}-${ARCH_NAME}" NO_SYSTEM_ENVIRONMENT_PATH ) cmake_policy(SET CMP0009 NEW) file( GLOB_RECURSE SRC LIST_DIRECTORIES false "cmd/*.?pp" "silkworm/*.?pp" ) list(FILTER SRC EXCLUDE REGEX "silkworm/interfaces/") list(FILTER SRC EXCLUDE REGEX "silkworm/core/chain/genesis_[a-z_]+.cpp\$") list(FILTER SRC EXCLUDE REGEX "silkworm/core/chain/dao.hpp$") list(FILTER SRC EXCLUDE REGEX "silkworm/rpc/json_rpc/specification.cpp\$") list(FILTER SRC EXCLUDE REGEX "silkworm/sync/internals/preverified_hashes/preverified_hashes_[a-z]+.cpp\$") execute_process(COMMAND ${CLANG_FORMAT} -style=file -i ${SRC} COMMAND_ERROR_IS_FATAL ANY) ================================================ FILE: cmake/parallel_jobs_count.sh ================================================ #!/bin/bash set -e set -o pipefail case $(uname -s) in Linux) nproc ;; Darwin) perf_cores=$(sysctl -n hw.perflevel0.physicalcpu) effi_cores=$(sysctl -n hw.perflevel1.physicalcpu) echo $(( $perf_cores + $effi_cores / 2 )) ;; *) echo "unsupported OS" exit 1 ;; esac ================================================ FILE: cmake/profiles/experimental/linux_arm64_gcc_12_debug ================================================ [settings] os=Linux arch=armv8 compiler=gcc compiler.version=12 compiler.libcxx=libstdc++11 compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/experimental/linux_arm64_gcc_12_release ================================================ [settings] os=Linux arch=armv8 compiler=gcc compiler.version=12 compiler.libcxx=libstdc++11 compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/experimental/linux_x64_gcc_12_debug ================================================ [settings] os=Linux arch=x86_64 compiler=gcc compiler.version=12 compiler.libcxx=libstdc++11 compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/experimental/linux_x64_gcc_12_release ================================================ [settings] os=Linux arch=x86_64 compiler=gcc compiler.version=12 compiler.libcxx=libstdc++11 compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/experimental/macos_arm64_clang_14_debug ================================================ [settings] os=Macos arch=armv8 compiler=apple-clang compiler.version=14 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/experimental/macos_arm64_clang_14_release ================================================ [settings] os=Macos arch=armv8 compiler=apple-clang compiler.version=14 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/experimental/macos_x64_clang_14_debug ================================================ [settings] os=Macos arch=x86_64 compiler=apple-clang compiler.version=14 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/experimental/macos_x64_clang_14_release ================================================ [settings] os=Macos arch=x86_64 compiler=apple-clang compiler.version=14 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/experimental/readme.txt ================================================ There are very few binary packages for gcc 12+ and clang 14+ on ConanCenter. The supported platforms are listed here: https://github.com/conan-io/conan-center-index/issues/25691#issuecomment-2429167255 This command shows which packages are "Missing" and need to be built from sources: conan graph explain --profile:all cmake/profiles/experimental/linux_x64_gcc_12_release . This command shows if binaries are missing for a particular package: conan graph explain --profile:all cmake/profiles/experimental/linux_x64_gcc_12_release --requires=grpc/x.y.z ================================================ FILE: cmake/profiles/linux_x64_clang_16_debug ================================================ [settings] os=Linux arch=x86_64 compiler=clang compiler.version=16 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/linux_x64_clang_16_release ================================================ [settings] os=Linux arch=x86_64 compiler=clang compiler.version=16 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/linux_x64_gcc_11_debug ================================================ [settings] os=Linux arch=x86_64 compiler=gcc compiler.version=11 compiler.libcxx=libstdc++11 compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/linux_x64_gcc_11_release ================================================ [settings] os=Linux arch=x86_64 compiler=gcc compiler.version=11 compiler.libcxx=libstdc++11 compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/macos_arm64_clang_13_debug ================================================ [settings] os=Macos arch=armv8 compiler=apple-clang compiler.version=13 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/macos_arm64_clang_13_release ================================================ [settings] os=Macos arch=armv8 compiler=apple-clang compiler.version=13 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/macos_x64_clang_13_debug ================================================ [settings] os=Macos arch=x86_64 compiler=apple-clang compiler.version=13 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Debug ================================================ FILE: cmake/profiles/macos_x64_clang_13_release ================================================ [settings] os=Macos arch=x86_64 compiler=apple-clang compiler.version=13 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Release ================================================ FILE: cmake/profiles/wasi_release ================================================ [settings] os=Emscripten arch=wasm compiler=clang compiler.version=14 compiler.libcxx=libc++ compiler.cppstd=17 build_type=Release [conf] tools.build:compiler_executables={'c': '/opt/wasi-sdk/bin/clang', 'cpp': '/opt/wasi-sdk/bin/clang++'} ================================================ FILE: cmake/profiles/windows_msvc_193_debug ================================================ [settings] os=Windows arch=x86_64 compiler=msvc compiler.version=193 compiler.runtime=dynamic compiler.runtime_type=Release compiler.cppstd=14 build_type=Debug ================================================ FILE: cmake/profiles/windows_msvc_193_release ================================================ [settings] os=Windows arch=x86_64 compiler=msvc compiler.version=193 compiler.runtime=dynamic compiler.runtime_type=Release compiler.cppstd=14 build_type=Release ================================================ FILE: cmake/run_smoke_tests.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 if(NOT SILKWORM_BUILD_DIR) set(SILKWORM_BUILD_DIR "${CMAKE_CURRENT_LIST_DIR}/../build") endif() file(REAL_PATH "${SILKWORM_BUILD_DIR}" SILKWORM_BUILD_DIR) if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") set(CMAKE_EXECUTABLE_SUFFIX ".exe") endif() file( GLOB_RECURSE COMMANDS LIST_DIRECTORIES false "${SILKWORM_BUILD_DIR}/*${CMAKE_EXECUTABLE_SUFFIX}" ) list(FILTER COMMANDS INCLUDE REGEX "(cli|cmd)/") if(NOT CMAKE_EXECUTABLE_SUFFIX) list(FILTER COMMANDS EXCLUDE REGEX "\\.") endif() list(FILTER COMMANDS EXCLUDE REGEX "Makefile") # TODO: fix check_log_indices --help list(FILTER COMMANDS EXCLUDE REGEX "check_log_indices") # Skip smoke test for execute in ASAN build due to odr-violation if(NOT SILKWORM_SANITIZE) # TODO: fix execute ASAN odr-violation list(FILTER COMMANDS EXCLUDE REGEX "execute") endif() # TODO: fix grpc_toolbox --help list(FILTER COMMANDS EXCLUDE REGEX "grpc_toolbox") # TODO: fix sentry_client_test --help list(FILTER COMMANDS EXCLUDE REGEX "sentry_client_test") message("") message("===================") message("Running smoke tests") message("===================") message("") foreach(COMMAND IN LISTS COMMANDS) file(RELATIVE_PATH COMMAND_REL_PATH "${SILKWORM_BUILD_DIR}" "${COMMAND}") message("Running ${COMMAND_REL_PATH} --help ...") execute_process(COMMAND "${COMMAND}" "--help" OUTPUT_QUIET COMMAND_ERROR_IS_FATAL ANY) endforeach() ================================================ FILE: cmake/run_smoke_tests.sh ================================================ #!/bin/bash set -e set -o pipefail if test `uname -s` = Linux then ulimit -s unlimited fi script_dir=`dirname "$0"` cmake "-DSILKWORM_BUILD_DIR=$1" -P "$script_dir/run_smoke_tests.cmake" ================================================ FILE: cmake/run_unit_tests.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 if(NOT SILKWORM_BUILD_DIR) set(SILKWORM_BUILD_DIR "${CMAKE_CURRENT_LIST_DIR}/../build") endif() file(REAL_PATH "${SILKWORM_BUILD_DIR}" SILKWORM_BUILD_DIR) if(NOT SILKWORM_PROJECT_DIR) set(SILKWORM_PROJECT_DIR "${CMAKE_CURRENT_LIST_DIR}/..") endif() file(REAL_PATH "${SILKWORM_PROJECT_DIR}" SILKWORM_PROJECT_DIR) if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") set(CMAKE_EXECUTABLE_SUFFIX ".exe") endif() file( GLOB_RECURSE TEST_COMMANDS LIST_DIRECTORIES false "${SILKWORM_BUILD_DIR}/*_test${CMAKE_EXECUTABLE_SUFFIX}" ) list(FILTER TEST_COMMANDS EXCLUDE REGEX "backend_kv_test${CMAKE_EXECUTABLE_SUFFIX}\$") list(FILTER TEST_COMMANDS EXCLUDE REGEX "benchmark_test${CMAKE_EXECUTABLE_SUFFIX}\$") list(FILTER TEST_COMMANDS EXCLUDE REGEX "sentry_client_test${CMAKE_EXECUTABLE_SUFFIX}\$") message("") message("==================") message("Running unit tests") message("==================") message("") string(TIMESTAMP TIME "%s") message("For all tests --rng-seed=${TIME}") message("") if("${SILKWORM_SANITIZE}" STREQUAL "thread") set(ENV{TSAN_OPTIONS} "suppressions=${SILKWORM_PROJECT_DIR}/tools/sanitizer/tsan_suppressions.txt") endif() foreach(TEST_COMMAND IN LISTS TEST_COMMANDS) file(RELATIVE_PATH TEST_COMMAND_REL_PATH "${SILKWORM_BUILD_DIR}" "${TEST_COMMAND}") message("Running ${TEST_COMMAND_REL_PATH}...") if(SILKWORM_CLANG_COVERAGE) get_filename_component(TEST_COMMAND_NAME "${TEST_COMMAND}" NAME) set(ENV{LLVM_PROFILE_FILE} "${TEST_COMMAND_NAME}.profraw") endif() execute_process(COMMAND "${TEST_COMMAND}" "--rng-seed=${TIME}" "--min-duration=2" RESULT_VARIABLE EXIT_CODE) if(NOT (EXIT_CODE EQUAL 0)) message(FATAL_ERROR "${TEST_COMMAND_REL_PATH} has failed: ${EXIT_CODE}") endif() endforeach() ================================================ FILE: cmake/run_unit_tests.sh ================================================ #!/bin/bash set -e set -o pipefail if test "$(uname -s)" = Linux then ulimit -s unlimited fi script_dir=$(dirname "$0") cmake "-DSILKWORM_BUILD_DIR=$1" "-DSILKWORM_CLANG_COVERAGE=$2" "-DSILKWORM_SANITIZE=$3" "-SILKWORM_PROJECT_DIR=$4" -P "$script_dir/run_unit_tests.cmake" \ | grep -Ev '^(Randomness|RNG seed|============================)' ================================================ FILE: cmake/setup/compiler_install.sh ================================================ #!/bin/bash # $1 - compiler ID: gcc or clang # $2 - compiler version set -e set -o pipefail script_dir=$(dirname "${BASH_SOURCE[0]}") project_dir="$script_dir/../.." function install_gcc { GCC_VERSION="$1" echo "Installing GCC $GCC_VERSION..." sudo apt-get update sudo apt-get install -y g++-$GCC_VERSION sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-$GCC_VERSION 100 \ --slave /usr/bin/g++ g++ /usr/bin/g++-$GCC_VERSION sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc 100 sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++ 100 sudo update-alternatives --set gcc /usr/bin/gcc-$GCC_VERSION sudo update-alternatives --set cc /usr/bin/gcc sudo update-alternatives --set c++ /usr/bin/g++ } # libc++ is an alternative standard library needed for coroutines support on Clang # https://libcxx.llvm.org function install_clang { CLANG_VERSION="$1" echo "Installing clang $CLANG_VERSION..." sudo apt-get update if apt-cache show clang-$CLANG_VERSION > /dev/null 2>&1 then echo "Installing from the default apt repositories" sudo apt-get install -y clang-$CLANG_VERSION \ libc++-$CLANG_VERSION-dev libc++abi-$CLANG_VERSION-dev \ lld-$CLANG_VERSION else echo "Installing from apt.llvm.org using llvm.sh script" sudo "$project_dir/third_party/llvm/llvm.sh" $CLANG_VERSION fi sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-$CLANG_VERSION 100 \ --slave /usr/bin/clang++ clang++ /usr/bin/clang++-$CLANG_VERSION \ --slave /usr/bin/llvm-cov llvm-cov /usr/bin/llvm-cov-$CLANG_VERSION \ --slave /usr/bin/llvm-profdata llvm-profdata /usr/bin/llvm-profdata-$CLANG_VERSION sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang 100 sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 100 sudo update-alternatives --set clang /usr/bin/clang-$CLANG_VERSION sudo update-alternatives --set cc /usr/bin/clang sudo update-alternatives --set c++ /usr/bin/clang++ # alias gcc to clang # this is useful for scripts having gcc hardcoded (such as GMP autotools build) sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/clang 10 \ --slave /usr/bin/g++ g++ /usr/bin/clang++ sudo update-alternatives --set gcc /usr/bin/clang } if [[ -n "$1" ]] then compiler_id="$1" else echo "Pass a required compiler ID parameter: gcc or clang" exit 1 fi if [[ -n "$2" ]] then version="$2" else echo "Pass a required compiler version parameter" exit 1 fi case "$compiler_id" in gcc) install_gcc "$version" ;; clang) install_clang "$version" ;; esac update-alternatives --display cc update-alternatives --display c++ update-alternatives --display gcc ================================================ FILE: cmake/toolchain/clang_libcxx.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include(${CMAKE_CURRENT_LIST_DIR}/cxx20.cmake) # coroutines support set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++" CACHE STRING "" FORCE ) ================================================ FILE: cmake/toolchain/cxx20.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 set(CMAKE_CXX_STANDARD_REQUIRED YES) set(CMAKE_CXX_STANDARD 20) set(CMAKE_CXX_EXTENSIONS NO) set(CMAKE_C_VISIBILITY_PRESET hidden) set(CMAKE_CXX_VISIBILITY_PRESET hidden) set(CMAKE_VISIBILITY_INLINES_HIDDEN YES) cmake_policy(SET CMP0063 NEW) cmake_policy(SET CMP0074 NEW) set(CMAKE_OSX_DEPLOYMENT_TARGET "15.0" CACHE STRING "" ) ================================================ FILE: cmake/toolchain/wasi.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 set(CMAKE_C_COMPILER /opt/wasi-sdk/bin/clang) set(CMAKE_CXX_COMPILER /opt/wasi-sdk/bin/clang++) add_compile_definitions(CATCH_CONFIG_NO_POSIX_SIGNALS JSON_HAS_FILESYSTEM=0) include(${CMAKE_CURRENT_LIST_DIR}/cxx20.cmake) ================================================ FILE: cmd/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 # Tests add_subdirectory(test) if(NOT SILKWORM_CORE_ONLY) # Benchmarks add_subdirectory(benchmark) if(SILKWORM_USE_MIMALLOC) find_package(mimalloc REQUIRED) endif() # [=] "all-in-one" Silkworm component # cmake-format: off set(SILKWORM_LIBRARIES silkworm_node silkworm_db_cli silkworm_node_cli silkworm_rpcdaemon_cli silkworm_sentry_cli $<$:Kernel32.lib> ) # cmake-format: on add_executable(silkworm silkworm.cpp) target_link_libraries(silkworm PRIVATE ${SILKWORM_LIBRARIES}) # [=] standalone RpcDaemon component set(RPCDAEMON_LIBRARIES silkworm_rpcdaemon silkworm_rpcdaemon_cli) if(SILKWORM_USE_MIMALLOC) list(APPEND RPCDAEMON_LIBRARIES mimalloc-static) endif() add_executable(rpcdaemon rpcdaemon.cpp) target_include_directories(rpcdaemon PUBLIC ${CMAKE_SOURCE_DIR}) target_link_libraries(rpcdaemon PRIVATE ${RPCDAEMON_LIBRARIES}) # [=] standalone Sentry component add_executable(sentry sentry.cpp) target_link_libraries(sentry PRIVATE silkworm_sentry silkworm_sentry_cli) endif() ================================================ FILE: cmd/benchmark/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(benchmark REQUIRED) file(GLOB_RECURSE SILKWORM_BENCHMARK_TESTS CONFIGURE_DEPENDS "${SILKWORM_MAIN_SRC_DIR}/*_benchmark.cpp") add_executable(benchmark_test benchmark_test.cpp ${SILKWORM_BENCHMARK_TESTS}) target_link_libraries( benchmark_test silkworm_infra silkworm_infra_test_util silkworm_node silkworm_rpcdaemon silkworm_rpcdaemon_test_util benchmark::benchmark ) ================================================ FILE: cmd/benchmark/benchmark_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include BENCHMARK_MAIN(); ================================================ FILE: cmd/rpcdaemon.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include using namespace silkworm; using namespace silkworm::cmd::common; using namespace silkworm::rpc; int main(int argc, char* argv[]) { CLI::App cli{"Silkrpc - C++ implementation of Ethereum JSON RPC API service"}; DaemonSettings settings; try { // Parse and validate program arguments add_logging_options(cli, settings.log_settings); add_option_data_dir(cli, settings.datadir); add_context_pool_options(cli, settings.context_pool_settings); add_rpcdaemon_options(cli, settings); cli.parse(argc, argv); // Extract versioning information from Cable build information settings.build_info = make_application_info(silkworm_get_buildinfo()); return Daemon::run(settings); } catch (const CLI::ParseError& pe) { return cli.exit(pe); } } ================================================ FILE: cmd/sentry.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::cmd::common; using namespace silkworm::sentry; Settings sentry_parse_cli_settings(int argc, char* argv[]) { CLI::App cli{"Sentry - P2P proxy"}; Settings settings; settings.client_id = make_client_id_from_build_info(*silkworm_get_buildinfo()); add_logging_options(cli, settings.log_settings); add_option_data_dir(cli, settings.data_dir_path); add_option_chain(cli, settings.network_id); add_context_pool_options(cli, settings.context_pool_settings); add_sentry_options(cli, settings); try { cli.parse(argc, argv); } catch (const CLI::ParseError& pe) { cli.exit(pe); throw; } return settings; } void sentry_main(Settings settings) { using namespace concurrency::awaitable_wait_for_one; log::init(settings.log_settings); log::set_thread_name("main"); silkworm::rpc::ClientContextPool context_pool{ settings.context_pool_settings, }; Sentry sentry{std::move(settings), context_pool.as_executor_pool()}; auto run_future = boost::asio::co_spawn( context_pool.any_executor(), sentry.run() || ShutdownSignal::wait(), boost::asio::use_future); context_pool.start(); const auto pid = boost::this_process::get_id(); const auto tid = std::this_thread::get_id(); SILK_INFO << "Sentry is now running [pid=" << pid << ", main thread=" << tid << "]"; // wait until either: // - shutdown_signal, then the sentry.run() is cancelled gracefully // - sentry.run() exception, then it is rethrown here run_future.get(); context_pool.stop(); context_pool.join(); SILK_INFO << "Sentry exiting [pid=" << pid << ", main thread=" << tid << "]"; } int main(int argc, char* argv[]) { try { sentry_main(sentry_parse_cli_settings(argc, argv)); } catch (const CLI::ParseError& pe) { return pe.get_exit_code(); } catch (const std::exception& e) { SILK_CRIT << "Sentry exiting due to exception: " << e.what(); return -2; } catch (...) { SILK_CRIT << "Sentry exiting due to unexpected exception"; return -3; } } ================================================ FILE: cmd/silkworm.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #ifndef WIN32 #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using silkworm::BlockNum; using silkworm::DataDirectory; using silkworm::human_size; using silkworm::cmd::common::ShutdownSignal; const char* current_exception_name() { #ifdef WIN32 return ""; #else int status{0}; return abi::__cxa_demangle(abi::__cxa_current_exception_type()->name(), nullptr, nullptr, &status); #endif } struct PruneModeValidator : public CLI::Validator { explicit PruneModeValidator() { func_ = [](const std::string& value) -> std::string { if (value.find_first_not_of("hrtc") != std::string::npos) { return "Value " + value + " contains other characters other than h r t c"; } return {}; }; } }; void add_rpc_server_settings(CLI::App& cli, rpc::ServerSettings& server_settings) { using namespace silkworm::cmd::common; add_option_private_api_address(cli, server_settings.address_uri); add_context_pool_options(cli, server_settings.context_pool_settings); } void parse_silkworm_command_line(CLI::App& cli, int argc, char* argv[], node::Settings& settings) { using namespace silkworm::cmd; using namespace silkworm::cmd::common; std::filesystem::path data_dir_path; add_option_data_dir(cli, data_dir_path); // Node settings add_node_options(cli, settings.node_settings); // Sentry settings add_sentry_options(cli, settings.sentry_settings); add_rpc_server_settings(cli, settings.server_settings); // Snapshot&Bittorrent options add_snapshot_options(cli, settings.snapshot_settings); // Prune options std::string prune_mode; auto& prune_opts = *cli.add_option_group("Prune", "Prune options to delete ancient data from DB"); prune_opts .add_option("--prune", prune_mode, "Delete data older than 90K blocks (see \"--prune.*.older\" to set a different block number)\n" "h - prune history (ChangeSets, HistoryIndices - used by historical state access)\n" "r - prune receipts (Receipts, Logs, LogTopicIndex, LogAddressIndex - used by eth_getLogs and " "similar RPC methods)\n" "s - prune senders recovered\n" "t - prune transaction by it's hash index\n" "c - prune call traces (used by trace_* methods)\n" "If item is NOT in the list - means NO pruning for this data.\n" "Example: --prune=hrtc (default: none)") ->capture_default_str() ->check(PruneModeValidator()); prune_opts.add_option("--prune.h.older", "Override default 90k blocks of history to prune") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.r.older", "Override default 90k blocks of receipts to prune") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.s.older", "Override default 90k blocks of senders to prune") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.t.older", "Override default 90k blocks of transactions to prune") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.c.older", "Override default 90k blocks of call traces to prune") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.h.before", "Prune history data before this block") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.r.before", "Prune receipts data before this block") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.s.before", "Prune senders data before this block") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.t.before", "Prune transactions data before this block") ->check(CLI::Range(0u, UINT32_MAX)); prune_opts.add_option("--prune.c.before", "Prune call traces data before this block") ->check(CLI::Range(0u, UINT32_MAX)); // Logging options add_logging_options(cli, settings.log_settings); // RpcDaemon settings add_rpcdaemon_options(cli, settings.rpcdaemon_settings); cli.parse(argc, argv); // Validate and assign settings // node::NodeSettings auto& node_settings = settings.node_settings; const auto build_info = silkworm_get_buildinfo(); node_settings.build_info = make_application_info(build_info); const size_t chaindata_page_size = node_settings.chaindata_env_config.page_size; if ((chaindata_page_size & (chaindata_page_size - 1)) != 0) { throw std::invalid_argument("--chaindata.pagesize is not a power of 2"); } const size_t mdbx_max_size_hard_limit = chaindata_page_size * datastore::kvdb::kMdbxMaxPages; if (node_settings.chaindata_env_config.max_size > mdbx_max_size_hard_limit) { throw std::invalid_argument("--chaindata.maxsize exceeds max allowed size by page size i.e" + human_size(mdbx_max_size_hard_limit)); } if (node_settings.chaindata_env_config.growth_size > (mdbx_max_size_hard_limit / /* two increments ?*/ 2u)) { throw std::invalid_argument("--chaindata.growthsize must be <=" + human_size(mdbx_max_size_hard_limit / 2)); } node_settings.data_directory = std::make_unique(data_dir_path, /*create=*/true); node_settings.chaindata_env_config.path = node_settings.data_directory->chaindata().path().string(); // Parse prune mode db::PruneDistance older_history, older_receipts, older_senders, older_tx_index, older_call_traces; if (cli["--prune.h.older"]->count()) older_history.emplace(cli["--prune.h.older"]->as()); if (cli["--prune.r.older"]->count()) older_receipts.emplace(cli["--prune.r.older"]->as()); if (cli["--prune.s.older"]->count()) older_senders.emplace(cli["--prune.s.older"]->as()); if (cli["--prune.t.older"]->count()) older_tx_index.emplace(cli["--prune.t.older"]->as()); if (cli["--prune.c.older"]->count()) older_call_traces.emplace(cli["--prune.c.older"]->as()); db::PruneThreshold before_history, before_receipts, before_senders, before_tx_index, before_call_traces; if (cli["--prune.h.before"]->count()) before_history.emplace(cli["--prune.h.before"]->as()); if (cli["--prune.r.before"]->count()) before_receipts.emplace(cli["--prune.r.before"]->as()); if (cli["--prune.s.before"]->count()) before_senders.emplace(cli["--prune.s.before"]->as()); if (cli["--prune.t.before"]->count()) before_tx_index.emplace(cli["--prune.t.before"]->as()); if (cli["--prune.c.before"]->count()) before_call_traces.emplace(cli["--prune.c.before"]->as()); node_settings.prune_mode = db::parse_prune_mode( prune_mode, older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces); // snapshots::SnapshotSettings auto& snapshot_settings = settings.snapshot_settings; snapshot_settings.repository_path = node_settings.data_directory->snapshots().path(); snapshot_settings.bittorrent_settings.repository_path = snapshot_settings.repository_path; // sentry::Settings settings.sentry_settings.client_id = node_settings.build_info.client_id; settings.sentry_settings.data_dir_path = node_settings.data_directory->path(); settings.sentry_settings.network_id = node_settings.network_id; } // main int main(int argc, char* argv[]) { using namespace std::chrono; using namespace silkworm::concurrency::awaitable_wait_for_one; using namespace silkworm::concurrency::awaitable_wait_for_all; std::set_terminate([]() { try { auto exc = std::current_exception(); if (exc) { std::rethrow_exception(exc); } } catch (const std::exception& e) { SILK_CRIT << "Silkworm terminating due to exception: " << e.what(); } catch (...) { SILK_CRIT << "Silkworm terminating due to unexpected exception: " << current_exception_name(); } std::abort(); }); CLI::App cli("Silkworm node"); cli.get_formatter()->column_width(50); try { node::Settings settings; parse_silkworm_command_line(cli, argc, argv, settings); // Initialize logging with cli settings log::init(settings.log_settings); log::set_thread_name("main-thread"); log::Info("Silkworm", build_info_as_log_args(silkworm_get_buildinfo())); silkworm::rpc::ClientContextPool context_pool{ settings.server_settings.context_pool_settings, }; silkworm::node::Node execution_node{ context_pool, settings, }; // Go! auto run_future = boost::asio::co_spawn( context_pool.any_executor(), execution_node.run() || ShutdownSignal::wait(), boost::asio::use_future); context_pool.start(); SILK_INFO << "Silkworm is now running"; // Wait for shutdown signal or an exception from tasks run_future.get(); // Graceful exit after user shutdown signal SILK_INFO << "Exiting Silkworm"; return 0; } catch (const CLI::ParseError& ex) { // Let CLI11 handle any error occurred parsing command-line args return cli.exit(ex); } catch (const std::exception& ex) { // Any exception during run leads to termination SILK_CRIT << "Unrecoverable failure: " << ex.what(); return -1; } catch (...) { // Any unknown exception during run leads to termination SILK_CRIT << "Unrecoverable failure: unexpected exception"; return -2; } } ================================================ FILE: cmd/test/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(magic_enum REQUIRED) if(NOT SILKWORM_CORE_ONLY) # Enable fuzzing tests for Clang builds only if("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang$" AND SILKWORM_FUZZER) # Silkworm RpcDaemon Fuzzer Tests add_executable(rpcdaemon_fuzzer_test fuzzer_test.cpp) target_link_libraries( rpcdaemon_fuzzer_test PRIVATE silkworm_rpcdaemon silkworm_infra_test_util silkworm_rpcdaemon_test_util ) target_compile_options(rpcdaemon_fuzzer_test PRIVATE -fsanitize=fuzzer) if(SILKWORM_FUZZER_LIBFUZZER_PATH) target_link_libraries(rpcdaemon_fuzzer_test PRIVATE ${SILKWORM_FUZZER_LIBFUZZER_PATH}) else() target_link_libraries(rpcdaemon_fuzzer_test PRIVATE -fsanitize=fuzzer) endif() # Silkworm RpcDaemon Fuzzer Diagnostic add_executable(rpcdaemon_fuzzer_diagnostics fuzzer_diagnostics.cpp) target_link_libraries( rpcdaemon_fuzzer_diagnostics PRIVATE silkworm_rpcdaemon silkworm_infra_test_util silkworm_rpcdaemon_test_util CLI11::CLI11 ) if(SILKWORM_FUZZER_SANITIZERS) target_compile_options(rpcdaemon_fuzzer_test PRIVATE -fsanitize=${SILKWORM_FUZZER_SANITIZERS}) target_compile_options(rpcdaemon_fuzzer_diagnostics PRIVATE -fsanitize=${SILKWORM_FUZZER_SANITIZERS}) target_link_libraries(rpcdaemon_fuzzer_test PRIVATE -fsanitize=${SILKWORM_FUZZER_SANITIZERS}) target_link_libraries(rpcdaemon_fuzzer_diagnostics PRIVATE -fsanitize=${SILKWORM_FUZZER_SANITIZERS}) endif() endif() # Ethereum EL Tests (https://github.com/ethereum/tests) find_package(CLI11 REQUIRED) add_executable(ethereum ethereum.cpp) target_compile_definitions( ethereum PRIVATE SILKWORM_ETHEREUM_TESTS_DIR="${SILKWORM_MAIN_DIR}/third_party/ethereum-tests" ) target_link_libraries(ethereum PRIVATE silkworm_infra evmc::loader CLI11::CLI11 magic_enum::magic_enum) # BE&KV Tests add_executable(backend_kv_test backend_kv_test.cpp) target_link_libraries(backend_kv_test PRIVATE silkworm_infra_cli silkworm_node CLI11::CLI11 magic_enum::magic_enum) add_executable(sentry_client_test sentry_client_test.cpp) target_link_libraries(sentry_client_test PRIVATE silkworm_sentry) endif() ================================================ FILE: cmd/test/address_sanitizer_fix.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // There is a bug in LLVM's address sanitizer that causes it to report false // positives when std::logic_error is thrown. This is a workaround // that disables the check for alloc_dealloc_mismatch. // // See also: // https://github.com/llvm/llvm-project/issues/59432 // https://github.com/google/googletest/issues/4097 // https://github.com/llvm/llvm-project/issues/52771 // https://lists.llvm.org/pipermail/llvm-bugs/2016-August/049095.html #ifndef __has_feature // GCC does not have __has_feature, adding it to avoid compilation errors #define __has_feature(feature) 0 #endif #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) #ifdef __cplusplus extern "C" #endif const char* __asan_default_options() { return "alloc_dealloc_mismatch=0"; } #endif ================================================ FILE: cmd/test/backend_kv_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std::literals; //! The callback to activate reading each event from the gRPC completion queue. using TagProcessor = std::function; struct UnaryStats { uint64_t started_count{0}; uint64_t completed_count{0}; uint64_t ok_count{0}; uint64_t ko_count{0}; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const UnaryStats& stats) { out << stats.to_string(); return out; } std::string UnaryStats::to_string() const { const UnaryStats& stats = *this; std::stringstream out; out << "started=" << stats.started_count << " completed=" << stats.completed_count << " [OK=" << stats.ok_count << " KO=" << stats.ko_count << "]"; return out.str(); } class AsyncCall { public: explicit AsyncCall(grpc::CompletionQueue* queue) : queue_(queue) {} virtual ~AsyncCall() = default; std::string peer() const { return client_context_.peer(); } std::chrono::steady_clock::duration latency() const { return end_time_ - start_time_; } grpc::Status status() const { return status_; } protected: grpc::ClientContext client_context_; grpc::CompletionQueue* queue_; std::chrono::steady_clock::time_point start_time_; std::chrono::steady_clock::time_point end_time_; grpc::Status status_; }; template using AsyncResponseReaderPtr = std::unique_ptr>; template < typename Request, typename Reply, typename StubInterface, AsyncResponseReaderPtr (StubInterface::*PrepareAsyncUnary)(grpc::ClientContext*, const Request&, grpc::CompletionQueue*)> class AsyncUnaryCall : public AsyncCall { public: using CompletionFunc = std::function*)>; static UnaryStats stats() { return unary_stats_; } explicit AsyncUnaryCall(grpc::CompletionQueue* queue, StubInterface* stub, CompletionFunc completion_handler = {}) : AsyncCall(queue), stub_(stub), finish_processor_([&](bool ok) { process_finish(ok); }), completion_handler_(std::move(completion_handler)) { } void start(const Request& request) { SILK_TRACE << "AsyncUnaryCall::start START"; auto response_reader = (stub_->*PrepareAsyncUnary)(&client_context_, request, queue_); response_reader->StartCall(); response_reader->Finish(&reply_, &status_, &finish_processor_); start_time_ = std::chrono::steady_clock::now(); ++unary_stats_.started_count; SILK_TRACE << "AsyncUnaryCall::start END"; } Reply reply() const { return reply_; } protected: void process_finish(bool ok) { end_time_ = std::chrono::steady_clock::now(); ++unary_stats_.completed_count; if (ok && status_.ok()) { ++unary_stats_.ok_count; } else { ++unary_stats_.ko_count; } handle_finish(ok); if (completion_handler_) { completion_handler_(this); } } virtual void handle_finish(bool /*ok*/) {} static inline UnaryStats unary_stats_; StubInterface* stub_; Reply reply_; TagProcessor finish_processor_; CompletionFunc completion_handler_; }; struct ServerStreamingStats { uint64_t started_count{0}; uint64_t received_count{0}; uint64_t completed_count{0}; uint64_t cancelled_count{0}; uint64_t ok_count{0}; uint64_t ko_count{0}; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const ServerStreamingStats& stats) { out << stats.to_string(); return out; } std::string ServerStreamingStats::to_string() const { const auto& stats = *this; std::stringstream out; out << "started=" << stats.started_count << " received=" << stats.received_count << " completed=" << stats.completed_count << " cancelled=" << stats.cancelled_count << " [OK=" << stats.ok_count << " KO=" << stats.ko_count << "]"; return out.str(); } template using AsyncReaderPtr = std::unique_ptr>; template < typename Request, typename Reply, typename StubInterface, AsyncReaderPtr (StubInterface::*PrepareAsyncServerStreaming)(grpc::ClientContext*, const Request&, grpc::CompletionQueue*)> class AsyncServerStreamingCall : public AsyncCall { public: static ServerStreamingStats stats() { return server_streaming_stats_; } explicit AsyncServerStreamingCall(grpc::CompletionQueue* queue, StubInterface* stub) : AsyncCall(queue), start_processor_([&](bool ok) { process_start(ok); }), read_processor_([&](bool ok) { process_read(ok); }), finish_processor_([&](bool ok) { process_finish(ok); }), stub_(stub) { } void start(const Request& request) { SILK_TRACE << "AsyncServerStreamingCall::start START"; reader_ = (stub_->*PrepareAsyncServerStreaming)(&client_context_, request, queue_); reader_->StartCall(&start_processor_); start_time_ = std::chrono::steady_clock::now(); ++server_streaming_stats_.started_count; SILK_TRACE << "AsyncServerStreamingCall::start END"; } void cancel() { SILK_TRACE << "AsyncServerStreamingCall::cancel START"; client_context_.TryCancel(); ++server_streaming_stats_.cancelled_count; SILK_TRACE << "AsyncServerStreamingCall::cancel END"; } protected: virtual void read() { SILK_TRACE << "AsyncServerStreamingCall::read START"; reader_->Read(&reply_, &read_processor_); SILK_TRACE << "AsyncServerStreamingCall::read END"; } virtual void finish() { SILK_TRACE << "AsyncServerStreamingCall::finish START"; reader_->Finish(&status_, &finish_processor_); SILK_TRACE << "AsyncServerStreamingCall::finish END"; } void process_start(bool ok) { SILK_DEBUG << "AsyncServerStreamingCall::process_start ok: " << ok; if (ok) { started_ = true; SILK_DEBUG << "AsyncServerStreamingCall call started"; // Schedule next async READ event. read(); SILK_DEBUG << "AsyncServerStreamingCall read scheduled"; } else { SILK_DEBUG << "AsyncServerStreamingCall interrupted started: " << started_; done_ = true; finish(); } } void process_read(bool ok) { SILK_DEBUG << "AsyncServerStreamingCall::process_read ok: " << ok; if (ok) { handle_read(); ++server_streaming_stats_.received_count; SILK_DEBUG << "AsyncServerStreamingCall new message received: " << server_streaming_stats_.received_count; // Schedule next async READ event. read(); SILK_DEBUG << "AsyncServerStreamingCall read scheduled"; } else { SILK_DEBUG << "AsyncServerStreamingCall interrupted started: " << started_; done_ = true; finish(); } } void process_finish(bool ok) { SILK_DEBUG << "AsyncServerStreamingCall::process_finish ok: " << ok; if (ok) { end_time_ = std::chrono::steady_clock::now(); ++server_streaming_stats_.completed_count; if (status_.ok()) { ++server_streaming_stats_.ok_count; } else { ++server_streaming_stats_.ko_count; } } else { SILK_DEBUG << "AsyncServerStreamingCall finished done: " << done_; SILKWORM_ASSERT(done_); } handle_finish(); } virtual void handle_read() = 0; virtual void handle_finish() = 0; static inline ServerStreamingStats server_streaming_stats_; TagProcessor start_processor_; TagProcessor read_processor_; TagProcessor finish_processor_; StubInterface* stub_; AsyncReaderPtr reader_; grpc::Status status_; Reply reply_; bool started_{false}; bool done_{false}; }; struct BidirectionalStreamingStats { uint64_t started_count{0}; uint64_t received_count{0}; uint64_t sent_count{0}; uint64_t completed_count{0}; uint64_t ok_count{0}; uint64_t ko_count{0}; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const BidirectionalStreamingStats& stats) { out << stats.to_string(); return out; } std::string BidirectionalStreamingStats::to_string() const { const auto& stats = *this; std::stringstream out; out << "started=" << stats.started_count << " sent=" << stats.sent_count << " received=" << stats.received_count << " completed=" << stats.completed_count << " [OK=" << stats.ok_count << " KO=" << stats.ko_count << "]"; return out.str(); } template using AsyncReaderWriterPtr = std::unique_ptr>; template (StubInterface::*PrepareAsyncBidirectionalStreaming)( grpc::ClientContext*, grpc::CompletionQueue*)> class AsyncBidirectionalStreamingCall : public AsyncCall { public: static BidirectionalStreamingStats stats() { return bidi_streaming_stats_; } explicit AsyncBidirectionalStreamingCall(grpc::CompletionQueue* queue, StubInterface* stub) : AsyncCall(queue), start_processor_([&](bool ok) { process_start(ok); }), read_processor_([&](bool ok) { process_read(ok); }), write_processor_([&](bool ok) { process_write(ok); }), writes_done_processor_([&](bool ok) { process_writes_done(ok); }), finish_processor_([&](bool ok) { process_finish(ok); }), stub_(stub) { } void start() { SILK_TRACE << "AsyncBidirectionalStreamingCall::start START"; stream_ = (stub_->*PrepareAsyncBidirectionalStreaming)(&client_context_, queue_); state_ = State::kStarted; stream_->StartCall(&start_processor_); start_time_ = std::chrono::steady_clock::now(); ++bidi_streaming_stats_.started_count; SILK_TRACE << "AsyncBidirectionalStreamingCall::start END"; } protected: void read() { SILK_TRACE << "AsyncBidirectionalStreamingCall::read START"; stream_->Read(&reply_, &read_processor_); SILK_TRACE << "AsyncBidirectionalStreamingCall::read END"; } void write() { SILK_TRACE << "AsyncBidirectionalStreamingCall::write START"; stream_->Write(request_, &write_processor_); SILK_TRACE << "AsyncBidirectionalStreamingCall::write END"; } void writes_done() { SILK_TRACE << "AsyncBidirectionalStreamingCall::writes_done START"; stream_->WritesDone(&writes_done_processor_); SILK_TRACE << "AsyncBidirectionalStreamingCall::writes_done END"; } void finish() { SILK_TRACE << "AsyncBidirectionalStreamingCall::finish START"; stream_->Finish(&status_, &finish_processor_); SILK_TRACE << "AsyncBidirectionalStreamingCall::finish END"; } void process_start(bool ok) { SILK_DEBUG << "AsyncBidirectionalStreamingCall::process_start ok: " << ok; SILKWORM_ASSERT(state_ == State::kStarted); if (ok) { const bool request_read = handle_start(); if (request_read) { // Schedule first async READ event. state_ = State::kReading; read(); SILK_DEBUG << "AsyncBidirectionalStreamingCall schedule read state: " << magic_enum::enum_name(state_); } else { // Schedule first async WRITE event. state_ = State::kWriting; write(); SILK_DEBUG << "AsyncBidirectionalStreamingCall schedule write state: " << magic_enum::enum_name(state_); } } else { SILK_DEBUG << "AsyncBidirectionalStreamingCall closed by peer state: " << magic_enum::enum_name(state_); state_ = State::kDone; finish(); } } void process_read(bool ok) { SILK_DEBUG << "AsyncBidirectionalStreamingCall::process_read ok: " << ok; SILKWORM_ASSERT(state_ == State::kReading); if (ok) { ++bidi_streaming_stats_.received_count; SILK_DEBUG << "AsyncBidirectionalStreamingCall new response received: " << bidi_streaming_stats_.received_count; const bool done = handle_read(); if (done) { state_ = State::kClosed; SILK_DEBUG << "AsyncBidirectionalStreamingCall closed by us state: " << magic_enum::enum_name(state_); writes_done(); } else { // Schedule next async WRITE event. state_ = State::kWriting; write(); SILK_DEBUG << "AsyncBidirectionalStreamingCall schedule write state: " << magic_enum::enum_name(state_); } } else { SILK_DEBUG << "AsyncBidirectionalStreamingCall closed by peer in state " << magic_enum::enum_name(state_); state_ = State::kDone; finish(); } } void process_write(bool ok) { SILK_DEBUG << "AsyncBidirectionalStreamingCall::process_write ok: " << ok; SILKWORM_ASSERT(state_ == State::kWriting); if (ok) { ++bidi_streaming_stats_.sent_count; SILK_DEBUG << "AsyncBidirectionalStreamingCall new request sent: " << bidi_streaming_stats_.sent_count; const bool done = handle_write(); if (done) { state_ = State::kClosed; SILK_DEBUG << "AsyncBidirectionalStreamingCall closed by us state: " << magic_enum::enum_name(state_); writes_done(); } else { // Schedule next async READ event. state_ = State::kReading; read(); SILK_DEBUG << "AsyncBidirectionalStreamingCall schedule read state: " << magic_enum::enum_name(state_); } } else { SILK_DEBUG << "AsyncBidirectionalStreamingCall closed by peer state: " << magic_enum::enum_name(state_); state_ = State::kDone; finish(); } } void process_writes_done(bool ok) { SILK_DEBUG << "AsyncBidirectionalStreamingCall::process_writes_done ok: " << ok; SILKWORM_ASSERT(state_ == State::kClosed); if (ok) { SILK_DEBUG << "AsyncBidirectionalStreamingCall closed state: " << magic_enum::enum_name(state_); state_ = State::kDone; SILK_DEBUG << "AsyncBidirectionalStreamingCall finishing state: " << magic_enum::enum_name(state_); finish(); } else { state_ = State::kDone; SILK_DEBUG << "AsyncBidirectionalStreamingCall closed by peer state: " << magic_enum::enum_name(state_); finish(); } } void process_finish(bool ok) { SILK_DEBUG << "AsyncBidirectionalStreamingCall::process_finish ok: " << ok; SILKWORM_ASSERT(state_ == State::kDone); if (ok) { SILK_DEBUG << "AsyncBidirectionalStreamingCall finished state: " << magic_enum::enum_name(state_); ++bidi_streaming_stats_.completed_count; if (status_.ok()) { ++bidi_streaming_stats_.ok_count; } else { ++bidi_streaming_stats_.ko_count; } } else { SILK_ERROR << "AsyncBidirectionalStreamingCall cannot finish state: " << magic_enum::enum_name(state_); } handle_finish(); } virtual bool handle_start() = 0; virtual bool handle_read() = 0; virtual bool handle_write() = 0; virtual void handle_finish() = 0; static inline BidirectionalStreamingStats bidi_streaming_stats_; enum class State { kIdle, kStarted, kWriting, kReading, kClosed, kDone, }; TagProcessor start_processor_; TagProcessor read_processor_; TagProcessor write_processor_; TagProcessor writes_done_processor_; TagProcessor finish_processor_; StubInterface* stub_; AsyncReaderWriterPtr stream_; grpc::Status status_; Request request_; Reply reply_; State state_{State::kIdle}; }; class AsyncEtherbaseCall : public AsyncUnaryCall< remote::EtherbaseRequest, remote::EtherbaseReply, remote::ETHBACKEND::StubInterface, &remote::ETHBACKEND::StubInterface::PrepareAsyncEtherbase> { public: explicit AsyncEtherbaseCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncUnaryCall(queue, stub, [](auto* call) { delete call; }) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncEtherbaseCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { if (reply_.has_address()) { const auto h160_address = reply_.address(); const auto address = silkworm::rpc::address_from_h160(h160_address); SILK_INFO << "Etherbase reply: " << address << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_INFO << "Etherbase reply: no address"; } } else { SILK_ERROR << "Etherbase failed: " << status_; } } }; class AsyncNetVersionCall : public AsyncUnaryCall< remote::NetVersionRequest, remote::NetVersionReply, remote::ETHBACKEND::StubInterface, &remote::ETHBACKEND::StubInterface::PrepareAsyncNetVersion> { public: explicit AsyncNetVersionCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncUnaryCall(queue, stub, [](auto* call) { delete call; }) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncNetVersionCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { SILK_INFO << "NetVersion reply: id=" << reply_.id() << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_ERROR << "NetVersion failed: " << status_; } } }; class AsyncNetPeerCountCall : public AsyncUnaryCall< remote::NetPeerCountRequest, remote::NetPeerCountReply, remote::ETHBACKEND::StubInterface, &remote::ETHBACKEND::StubInterface::PrepareAsyncNetPeerCount> { public: explicit AsyncNetPeerCountCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncUnaryCall(queue, stub, [](auto* call) { delete call; }) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncNetPeerCountCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { SILK_INFO << "NetPeerCount reply: count=" << reply_.count() << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_ERROR << "NetPeerCount failed: " << status_; } } }; class AsyncBackEndVersionCall : public AsyncUnaryCall< google::protobuf::Empty, types::VersionReply, remote::ETHBACKEND::StubInterface, &remote::ETHBACKEND::StubInterface::PrepareAsyncVersion> { public: explicit AsyncBackEndVersionCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncUnaryCall(queue, stub, [](auto* call) { delete call; }) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncBackEndVersionCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { const auto major = reply_.major(); const auto minor = reply_.minor(); const auto patch = reply_.patch(); SILK_INFO << "BackEnd Version reply: " << major << "." << minor << "." << patch << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_ERROR << "BackEnd Version failed: " << status_; } } }; class AsyncProtocolVersionCall : public AsyncUnaryCall< remote::ProtocolVersionRequest, remote::ProtocolVersionReply, remote::ETHBACKEND::StubInterface, &remote::ETHBACKEND::StubInterface::PrepareAsyncProtocolVersion> { public: explicit AsyncProtocolVersionCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncUnaryCall(queue, stub, [](auto* call) { delete call; }) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncProtocolVersionCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { SILK_INFO << "ProtocolVersion reply: id=" << reply_.id() << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_ERROR << "ProtocolVersion failed: " << status_; } } }; class AsyncClientVersionCall : public AsyncUnaryCall< remote::ClientVersionRequest, remote::ClientVersionReply, remote::ETHBACKEND::StubInterface, &remote::ETHBACKEND::StubInterface::PrepareAsyncClientVersion> { public: explicit AsyncClientVersionCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncUnaryCall(queue, stub, [](auto* call) { delete call; }) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncClientVersionCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { SILK_INFO << "ClientVersion reply: node name=" << reply_.node_name() << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_ERROR << "ClientVersion failed: " << status_; } } }; class AsyncSubscribeCall : public AsyncServerStreamingCall { public: explicit AsyncSubscribeCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncServerStreamingCall(queue, stub) {} void handle_read() override { SILK_INFO << "Subscribe reply: type=" << reply_.type() << " data=" << reply_.data(); } void handle_finish() override { if (status_.ok()) { SILK_INFO << "Subscribe completed status: " << status_; } else { SILK_ERROR << "Subscribe failed: " << status_; } delete this; } }; class AsyncNodeInfoCall : public AsyncUnaryCall< remote::NodesInfoRequest, remote::NodesInfoReply, remote::ETHBACKEND::StubInterface, &remote::ETHBACKEND::StubInterface::PrepareAsyncNodeInfo> { public: explicit AsyncNodeInfoCall(grpc::CompletionQueue* queue, remote::ETHBACKEND::StubInterface* stub) : AsyncUnaryCall(queue, stub) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncNodeInfoCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { SILK_INFO << "NodeInfo reply: nodes info size=" << reply_.nodes_info_size() << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_ERROR << "NodeInfo failed: " << status_; } } }; class AsyncKvVersionCall : public AsyncUnaryCall< google::protobuf::Empty, types::VersionReply, remote::KV::StubInterface, &remote::KV::StubInterface::PrepareAsyncVersion> { public: explicit AsyncKvVersionCall(grpc::CompletionQueue* queue, remote::KV::StubInterface* stub) : AsyncUnaryCall(queue, stub) {} void handle_finish(bool ok) override { SILK_DEBUG << "AsyncKvVersionCall::handle_finish ok: " << ok << " status: " << status_; if (ok && status_.ok()) { const auto major = reply_.major(); const auto minor = reply_.minor(); const auto patch = reply_.patch(); SILK_INFO << "KV Version reply: " << major << "." << minor << "." << patch << " [latency=" << latency() / 1ns << " ns]"; } else { SILK_ERROR << "KV Version failed: " << status_; } } }; namespace remote { std::string pair_to_string(const Pair& kv_pair) { std::stringstream out; out << "k=" << silkworm::to_hex(silkworm::Bytes(kv_pair.k().begin(), kv_pair.k().end())) << " v= " << silkworm::to_hex(silkworm::Bytes(kv_pair.v().begin(), kv_pair.v().end())); return out.str(); } std::ostream& operator<<(std::ostream& out, const Pair& kv_pair) { out << pair_to_string(kv_pair); return out; } } // namespace remote class AsyncTxCall : public AsyncBidirectionalStreamingCall { public: explicit AsyncTxCall(grpc::CompletionQueue* queue, remote::KV::StubInterface* stub) : AsyncBidirectionalStreamingCall(queue, stub) {} bool handle_start() override { SILK_INFO << "Tx started: reading database view"; return true; } bool handle_read() override { if (view_id_ == kInvalidViewId) { SILK_INFO << "Tx database view: tx_id=" << reply_.tx_id(); view_id_ = gsl::narrow(reply_.tx_id()); SILK_INFO << "Tx announced: opening cursor"; request_.set_op(remote::Op::OPEN); request_.set_bucket_name(table_name_); return false; } if (query_count_ == 0) { if (cursor_id_ == kInvalidCursorId) { SILK_DEBUG << "Tx cursor closed, closing tx"; return true; // reads done, close tx } SILK_INFO << "Tx queried: " << reply_ << ", queries done closing cursor"; request_.set_op(remote::Op::CLOSE); request_.set_cursor(cursor_id_); cursor_id_ = kInvalidCursorId; return false; } if (cursor_id_ == kInvalidCursorId) { SILK_INFO << "Tx opened: cursor=" << reply_.cursor_id(); cursor_id_ = reply_.cursor_id(); SILK_DEBUG << "Tx: prepare request FIRST cursor=" << cursor_id_; request_.set_op(remote::Op::FIRST); request_.set_cursor(cursor_id_); } else { SILK_INFO << "Tx queried: " << reply_; --query_count_; SILK_DEBUG << "Tx: prepare request NEXT cursor=" << cursor_id_; request_.set_op(remote::Op::NEXT); request_.set_cursor(cursor_id_); } return false; } bool handle_write() override { SILK_DEBUG << "Tx request: cursor op=" << remote::Op_Name(request_.op()); return false; } void handle_finish() override { if (status_.ok()) { SILK_INFO << "Tx completed: status: " << status_; } else { SILK_ERROR << "Tx failed: " << status_; } delete this; } private: static constexpr uint32_t kInvalidViewId{0}; static constexpr uint32_t kInvalidCursorId{0}; uint32_t view_id_{kInvalidViewId}; std::string table_name_{silkworm::db::table::kCanonicalHashes.name}; uint32_t query_count_{5}; uint32_t cursor_id_{kInvalidCursorId}; }; class AsyncStateChangesCall : public AsyncServerStreamingCall { public: static size_t num_pending_calls() { return pending_calls_.size(); } static void add_pending_call(AsyncStateChangesCall* call) { pending_calls_.push_back(call); } static void remove_pending_call(AsyncStateChangesCall* call) { pending_calls_.erase(std::find(pending_calls_.begin(), pending_calls_.end(), call)); std::unique_ptr call_ptr{call}; } static void cancel_pending_calls() { for (AsyncStateChangesCall* call : pending_calls_) { std::unique_ptr call_ptr{call}; call_ptr->cancel(); } pending_calls_.clear(); } explicit AsyncStateChangesCall(grpc::CompletionQueue* queue, remote::KV::StubInterface* stub) : AsyncServerStreamingCall(queue, stub) {} void handle_read() override { SILK_INFO << "StateChanges batch: change batch size=" << reply_.change_batch_size() << " state version id=" << reply_.state_version_id() << " pending block base fee=" << reply_.pending_block_base_fee() << " block gas limit=" << reply_.block_gas_limit(); } void handle_finish() override { if (status_.ok()) { SILK_INFO << "StateChanges completed status: " << status_; } else { SILK_ERROR << "StateChanges failed: " << status_; } remove_pending_call(this); } private: static inline std::vector pending_calls_; }; enum class Rpc { kEtherbase = 0, kNetVersion = 1, kNetPeerCount = 2, kBackendVersion = 3, kProtocolVersion = 4, kClientVersion = 5, kSubscribe = 6, kNodeInfo = 7, kKvVersion = 8, kTx = 9, kStateChanges = 10 }; struct BatchOptions { int batch_size{1}; std::vector configured_calls; int64_t interval_between_calls{100}; bool is_configured(Rpc call) const { return configured_calls.empty() || contains_call(call); } private: bool contains_call(Rpc call) const { return std::find(configured_calls.begin(), configured_calls.end(), call) != configured_calls.end(); } }; class AsyncCallFactory { public: AsyncCallFactory(const std::shared_ptr& channel, grpc::CompletionQueue* queue) : queue_(queue), ethbackend_stub_{remote::ETHBACKEND::NewStub(channel, grpc::StubOptions{})}, kv_stub_{remote::KV::NewStub(channel, grpc::StubOptions{})} {} void start_batch(std::atomic_bool& stop, const BatchOptions& batch_options) { for (auto i{0}; i < batch_options.batch_size && !stop; ++i) { if (batch_options.is_configured(Rpc::kEtherbase)) { auto* etherbase = new AsyncEtherbaseCall(queue_, ethbackend_stub_.get()); etherbase->start(remote::EtherbaseRequest{}); SILK_DEBUG << "New Etherbase async call started: " << etherbase; } if (batch_options.is_configured(Rpc::kNetVersion)) { auto* net_version = new AsyncNetVersionCall(queue_, ethbackend_stub_.get()); net_version->start(remote::NetVersionRequest{}); SILK_DEBUG << "New NetVersion async call started: " << net_version; } if (batch_options.is_configured(Rpc::kNetPeerCount)) { auto* net_peer_count = new AsyncNetPeerCountCall(queue_, ethbackend_stub_.get()); net_peer_count->start(remote::NetPeerCountRequest{}); SILK_DEBUG << "New NetPeerCount async call started: " << net_peer_count; } if (batch_options.is_configured(Rpc::kBackendVersion)) { auto* backend_version = new AsyncBackEndVersionCall(queue_, ethbackend_stub_.get()); backend_version->start(google::protobuf::Empty{}); SILK_DEBUG << "New ETHBACKEND Version async call started: " << backend_version; } if (batch_options.is_configured(Rpc::kProtocolVersion)) { auto* protocol_version = new AsyncProtocolVersionCall(queue_, ethbackend_stub_.get()); protocol_version->start(remote::ProtocolVersionRequest{}); SILK_DEBUG << "New ProtocolVersion async call started: " << protocol_version; } if (batch_options.is_configured(Rpc::kClientVersion)) { auto* client_version = new AsyncClientVersionCall(queue_, ethbackend_stub_.get()); client_version->start(remote::ClientVersionRequest{}); SILK_DEBUG << "New ClientVersion async call started: " << client_version; } if (batch_options.is_configured(Rpc::kSubscribe)) { auto* subscribe = new AsyncSubscribeCall(queue_, ethbackend_stub_.get()); subscribe->start(remote::SubscribeRequest{}); SILK_DEBUG << "New Subscribe async call started: " << subscribe; } if (batch_options.is_configured(Rpc::kNodeInfo)) { auto* node_info = new AsyncNodeInfoCall(queue_, ethbackend_stub_.get()); node_info->start(remote::NodesInfoRequest{}); SILK_DEBUG << "New NodeInfo async call started: " << node_info; } if (batch_options.is_configured(Rpc::kKvVersion)) { auto* kv_version = new AsyncKvVersionCall(queue_, kv_stub_.get()); kv_version->start(google::protobuf::Empty{}); SILK_DEBUG << "New KV Version async call started: " << kv_version; } if (batch_options.is_configured(Rpc::kTx)) { auto* tx = new AsyncTxCall(queue_, kv_stub_.get()); tx->start(); SILK_DEBUG << "New Tx async call started: " << tx; } if (batch_options.is_configured(Rpc::kStateChanges) && AsyncStateChangesCall::num_pending_calls() < 10000) { auto* state_changes = new AsyncStateChangesCall(queue_, kv_stub_.get()); state_changes->start(remote::StateChangeRequest{}); SILK_DEBUG << "New StateChanges async call started: " << state_changes; AsyncStateChangesCall::add_pending_call(state_changes); } } } private: grpc::CompletionQueue* queue_; std::unique_ptr ethbackend_stub_; std::unique_ptr kv_stub_; }; void print_stats(const BatchOptions& batch_options) { if (batch_options.is_configured(Rpc::kEtherbase)) { SILK_LOG << "Unary stats Etherbase: " << AsyncEtherbaseCall::stats(); } if (batch_options.is_configured(Rpc::kNetVersion)) { SILK_LOG << "Unary stats NetVersion: " << AsyncNetVersionCall::stats(); } if (batch_options.is_configured(Rpc::kNetPeerCount)) { SILK_LOG << "Unary stats NetPeerCount: " << AsyncNetPeerCountCall::stats(); } if (batch_options.is_configured(Rpc::kBackendVersion)) { SILK_LOG << "Unary stats ETHBACKEND Version: " << AsyncBackEndVersionCall::stats(); } if (batch_options.is_configured(Rpc::kProtocolVersion)) { SILK_LOG << "Unary stats ProtocolVersion: " << AsyncProtocolVersionCall::stats(); } if (batch_options.is_configured(Rpc::kClientVersion)) { SILK_LOG << "Unary stats ClientVersion: " << AsyncClientVersionCall::stats(); } if (batch_options.is_configured(Rpc::kNodeInfo)) { SILK_LOG << "Unary stats NodeInfo: " << AsyncNodeInfoCall::stats(); } if (batch_options.is_configured(Rpc::kKvVersion)) { SILK_LOG << "Unary stats KV Version: " << AsyncKvVersionCall::stats(); } if (batch_options.is_configured(Rpc::kSubscribe)) { SILK_LOG << "Server streaming stats Subscribe: " << AsyncSubscribeCall::stats(); } if (batch_options.is_configured(Rpc::kStateChanges)) { SILK_LOG << "Server streaming stats StateChanges: " << AsyncStateChangesCall::stats(); } if (batch_options.is_configured(Rpc::kTx)) { SILK_LOG << "Bidirectional streaming stats Tx: " << AsyncTxCall::stats(); } } int main(int argc, char* argv[]) { const auto pid = boost::this_process::get_id(); const auto tid = std::this_thread::get_id(); CLI::App app{"ETHBACKEND & KV interface test"}; std::string target_uri{"localhost:9090"}; int num_channels{1}; BatchOptions batch_options; silkworm::log::Level log_level{silkworm::log::Level::kCritical}; app.add_option("--target", target_uri, "The address to connect to the ETHBACKEND & KV services") ->capture_default_str(); app.add_option("--channels", num_channels, "The number of gRPC channels to use as integer") ->required() ->check(CLI::PositiveNumber) ->capture_default_str(); app.add_option("--interval", batch_options.interval_between_calls, "The interval to wait between successive call batches as milliseconds") ->capture_default_str(); app.add_option("--batch", batch_options.batch_size, "The number of async calls for each RPC in each batch as integer") ->capture_default_str(); app.add_option("--calls", batch_options.configured_calls, "The list of RPC call types to use as integers") ->capture_default_str(); app.add_option("--logLevel", log_level, "The log level identifier as string") ->capture_default_str() ->check(CLI::Range(static_cast(silkworm::log::Level::kCritical), static_cast(silkworm::log::Level::kTrace))) ->default_val(std::to_string(static_cast(log_level))); CLI11_PARSE(app, argc, argv) silkworm::log::Settings log_settings{}; log_settings.log_threads = true; log_settings.log_verbosity = log_level; silkworm::log::init(log_settings); try { std::vector> channels; for (int i{0}; i < num_channels; ++i) { grpc::ChannelArguments channel_args; channel_args.SetInt(GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL, 1); channels.push_back(grpc::CreateCustomChannel(target_uri, grpc::InsecureChannelCredentials(), channel_args)); } grpc::CompletionQueue queue; std::mutex mutex; std::condition_variable shutdown_requested; std::atomic_bool pump_stop{false}; std::thread pump_thread{[&]() { SILK_TRACE << "Pump thread: " << pump_thread.get_id() << " start"; size_t channel_index{0}; while (!pump_stop) { AsyncCallFactory call_factory{channels[channel_index], &queue}; call_factory.start_batch(pump_stop, batch_options); SILK_DEBUG << "Pump thread going to wait for " << batch_options.interval_between_calls << "ms..."; std::unique_lock lock{mutex}; const auto now = std::chrono::system_clock::now(); shutdown_requested.wait_until(lock, now + std::chrono::milliseconds{batch_options.interval_between_calls}); channel_index = (channel_index + 1) % channels.size(); } AsyncStateChangesCall::cancel_pending_calls(); SILK_TRACE << "Pump thread: " << pump_thread.get_id() << " end"; }}; std::atomic_bool completion_stop{false}; std::thread completion_thread{[&]() { SILK_TRACE << "Completion thread: " << completion_thread.get_id() << " start"; while (!completion_stop) { SILK_DEBUG << "Reading next tag from queue..."; void* tag{nullptr}; bool ok{false}; const auto got_event = queue.Next(&tag, &ok); if (got_event && !completion_stop) { auto* processor = reinterpret_cast(tag); SILK_DEBUG << "Completion thread post operation: " << processor; (*processor)(ok); } else { SILK_DEBUG << "Got shutdown"; SILKWORM_ASSERT(completion_stop); } } SILK_TRACE << "Completion thread: " << completion_thread.get_id() << " end"; }}; boost::asio::io_context shutdown_signal_ioc; silkworm::cmd::common::ShutdownSignal shutdown_signal{shutdown_signal_ioc.get_executor()}; shutdown_signal.on_signal([&](silkworm::cmd::common::ShutdownSignal::SignalNumber /*num*/) { pump_stop = true; completion_stop = true; shutdown_requested.notify_one(); shutdown_signal_ioc.stop(); }); SILK_LOG << "ETHBACKEND & KV interface test running [pid=" << pid << ", main thread=" << tid << "]"; shutdown_signal_ioc.run(); // Order matters here: 1) wait for pump thread exit 2) shutdown gRPC CQ 3) wait for completion thread exit if (pump_thread.joinable()) { const auto pump_thread_id = pump_thread.get_id(); SILK_DEBUG << "Joining pump thread: " << pump_thread_id; pump_thread.join(); SILK_DEBUG << "Pump thread: " << pump_thread_id << " terminated"; } queue.Shutdown(); if (completion_thread.joinable()) { const auto completion_thread_id = completion_thread.get_id(); SILK_DEBUG << "Joining completion thread: " << completion_thread_id; completion_thread.join(); SILK_DEBUG << "Completion thread: " << completion_thread_id << " terminated"; } print_stats(batch_options); SILK_LOG << "ETHBACKEND & KV interface test exiting [pid=" << pid << ", main thread=" << tid << "]"; return 0; } catch (const std::exception& e) { SILK_CRIT << "ETHBACKEND & KV interface test exiting due to exception: " << e.what(); return -1; } catch (...) { SILK_CRIT << "ETHBACKEND & KV interface test exiting due to unexpected exception"; return -2; } } ================================================ FILE: cmd/test/ethereum.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // See EEST: https://github.com/erigontech/eest-fixtures. // See legacy tests: https://ethereum-tests.readthedocs.io. using namespace silkworm; using namespace silkworm::protocol; namespace fs = std::filesystem; static const fs::path kDifficultyDir{"DifficultyTests"}; static const fs::path kBlockchainDir{"BlockchainTests"}; static const fs::path kTransactionDir{"TransactionTests"}; static const std::array kSlowTests{ kBlockchainDir / "GeneralStateTests" / "stTimeConsuming", kBlockchainDir / "GeneralStateTests" / "VMTests" / "vmPerformance", }; static const std::array kFailingTests{ // Tests related to create address collision. Silkworm and evmone implement this scenario // differently: // Silkworm follows the older EIP-684 and clears the created account storage if not empty, // evmone tries to follow the newer EIP-7610 to revert the creation, however Silkworm // is not able to provide enough information to evmone to identify non-empty storage, // in the result the non-empty storage remains unchanged. // This scenarion don't happen in real networks. The desired behavior for implementations // is still being discussed. kBlockchainDir / "GeneralStateTests" / "stCreate2" / "create2collisionStorage.json", kBlockchainDir / "GeneralStateTests" / "stCreate2" / "create2collisionStorageParis.json", kBlockchainDir / "GeneralStateTests" / "stCreate2" / "RevertInCreateInInitCreate2.json", kBlockchainDir / "GeneralStateTests" / "stCreate2" / "RevertInCreateInInitCreate2Paris.json", kBlockchainDir / "GeneralStateTests" / "stRevertTest" / "RevertInCreateInInit.json", kBlockchainDir / "GeneralStateTests" / "stRevertTest" / "RevertInCreateInInit_Paris.json", kBlockchainDir / "GeneralStateTests" / "stSStoreTest" / "InitCollision.json", kBlockchainDir / "GeneralStateTests" / "stSStoreTest" / "InitCollisionParis.json", }; static constexpr size_t kColumnWidth{80}; /// External EVMC VM. /// It is used in potential multiple test execution threads /// so usage may be broken if the VM is not thread-safe. evmc_vm* exo_evm{nullptr}; enum class Status { kPassed, kFailed, kSkipped }; Status run_block(const nlohmann::json& json_block, Blockchain& blockchain) { bool invalid{json_block.contains("expectException")}; std::optional rlp{from_hex(json_block["rlp"].get())}; if (!rlp) { if (invalid) { return Status::kPassed; } std::cout << "Failure to read hex" << std::endl; return Status::kFailed; } Block block; ByteView view{*rlp}; if (!rlp::decode(view, block)) { if (invalid) { return Status::kPassed; } std::cout << "Failure to decode RLP" << std::endl; return Status::kFailed; } const bool check_state_root{true}; if (ValidationResult err{blockchain.insert_block(block, check_state_root)}; err != ValidationResult::kOk) { if (invalid) { return Status::kPassed; } std::cout << "Validation error " << magic_enum::enum_name(err) << std::endl; return Status::kFailed; } if (invalid) { std::cout << "Invalid block executed successfully\n"; std::cout << "Expected: " << json_block["expectException"] << std::endl; return Status::kFailed; } return Status::kPassed; } bool post_check(const InMemoryState& state, const nlohmann::json& expected) { if (state.accounts().size() != expected.size()) { std::cout << "Account number mismatch: " << state.accounts().size() << " != " << expected.size() << std::endl; // Find and report accounts missing from the expected set. for (const auto& [addr, _] : state.accounts()) { if (const auto addr_hex = "0x" + hex(addr); !expected.contains(addr_hex)) { std::cout << "Unexpected account: " << addr_hex << std::endl; } } return false; } for (const auto& entry : expected.items()) { const evmc::address address{hex_to_address(entry.key())}; const nlohmann::json& j{entry.value()}; std::optional account{state.read_account(address)}; if (!account) { std::cout << "Missing account " << entry.key() << std::endl; return false; } const auto expected_balance{intx::from_string(j["balance"].get())}; if (account->balance != expected_balance) { std::cout << "Balance mismatch for " << entry.key() << ":\n" << to_string(account->balance, 16) << " != " << j["balance"] << std::endl; return false; } const auto expected_nonce{intx::from_string(j["nonce"].get())}; if (account->nonce != expected_nonce) { std::cout << "Nonce mismatch for " << entry.key() << ":\n" << account->nonce << " != " << j["nonce"] << std::endl; return false; } auto expected_code{j["code"].get()}; Bytes actual_code{state.read_code(address, account->code_hash)}; if (actual_code != from_hex(expected_code)) { std::cout << "Code mismatch for " << entry.key() << ":\n" << to_hex(actual_code) << " != " << expected_code << std::endl; return false; } size_t storage_size{state.storage_size(address, account->incarnation)}; if (storage_size != j["storage"].size()) { std::cout << "Storage size mismatch for " << entry.key() << ":\n" << storage_size << " != " << j["storage"].size() << std::endl; return false; } for (const auto& storage : j["storage"].items()) { Bytes key{from_hex(storage.key()).value()}; Bytes expected_value{from_hex(storage.value().get()).value()}; evmc::bytes32 actual_value{state.read_storage(address, account->incarnation, to_bytes32(key))}; if (actual_value != to_bytes32(expected_value)) { std::cout << "Storage mismatch for " << entry.key() << " at " << storage.key() << ":\n" << to_hex(actual_value) << " != " << to_hex(expected_value) << std::endl; return false; } } } return true; } struct [[nodiscard]] RunResults { size_t passed{0}; size_t failed{0}; size_t skipped{0}; constexpr RunResults() = default; // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) constexpr RunResults(Status status) { switch (status) { case Status::kPassed: passed = 1; return; case Status::kFailed: failed = 1; return; case Status::kSkipped: skipped = 1; return; } } RunResults& operator+=(const RunResults& rhs) { passed += rhs.passed; failed += rhs.failed; skipped += rhs.skipped; return *this; } }; // https://ethereum-tests.readthedocs.io/en/latest/test_types/blockchain_tests.html RunResults blockchain_test(const nlohmann::json& json_test) { const auto network{json_test["network"].get()}; const auto config_it{test::kNetworkConfig.find(network)}; if (config_it == test::kNetworkConfig.end()) { std::cout << "unknown network " << network << std::endl; return Status::kSkipped; } Bytes genesis_rlp{from_hex(json_test["genesisRLP"].get()).value()}; ByteView genesis_view{genesis_rlp}; Block genesis_block; if (!rlp::decode(genesis_view, genesis_block)) { std::cout << "Failure to decode genesisRLP" << std::endl; return Status::kFailed; } InMemoryState state{read_genesis_allocation(json_test["pre"])}; Blockchain blockchain{state, config_it->second, genesis_block}; blockchain.exo_evm = exo_evm; for (const auto& json_block : json_test["blocks"]) { Status status{run_block(json_block, blockchain)}; if (status != Status::kPassed) { return status; } } if (json_test.contains("postStateHash")) { evmc::bytes32 state_root{state.state_root_hash()}; std::string expected_hex{json_test["postStateHash"].get()}; if (state_root != to_bytes32(from_hex(expected_hex).value())) { std::cout << "postStateHash mismatch:\n" << to_hex(state_root) << " != " << expected_hex << std::endl; return Status::kFailed; } return Status::kPassed; } if (post_check(state, json_test["postState"])) { return Status::kPassed; } return Status::kFailed; } static void print_test_status(std::string_view key, const RunResults& res) { std::cout << key << " "; for (size_t i{key.size() + 1}; i < kColumnWidth; ++i) { std::cout << '.'; } if (res.failed) { std::cout << kColorMaroonHigh << " Failed" << kColorReset << std::endl; } else if (res.skipped) { std::cout << " Skipped" << std::endl; } else { std::cout << kColorGreen << " Passed" << kColorReset << std::endl; } } std::atomic total_passed{0}; std::atomic total_failed{0}; std::atomic total_skipped{0}; using RunnerFunc = RunResults (*)(const nlohmann::json&); void run_test_file(const fs::path& file_path, RunnerFunc runner, std::string_view filter) { std::ifstream in{file_path.string()}; nlohmann::json json; try { in >> json; } catch (nlohmann::detail::parse_error& e) { std::cerr << e.what() << "\n"; print_test_status(file_path.string(), Status::kSkipped); ++total_skipped; return; } RunResults total; for (const auto& test : json.items()) { if (!filter.empty() && test.key().find(filter) == std::string::npos) { continue; } const RunResults r = runner(test.value()); total += r; if (r.failed || r.skipped) { print_test_status(test.key(), r); } } total_passed += total.passed; total_failed += total.failed; total_skipped += total.skipped; } // https://ethereum-tests.readthedocs.io/en/latest/test_types/transaction_tests.html RunResults transaction_test(const nlohmann::json& j) { Transaction txn; bool decoded{false}; std::optional rlp{from_hex(j["txbytes"].get())}; if (rlp) { ByteView view{*rlp}; if (rlp::decode_transaction(view, txn, rlp::Eip2718Wrapping::kNone)) { decoded = view.empty(); } } for (const auto& entry : j["result"].items()) { const auto& test{entry.value()}; const bool should_be_valid{!test.contains("exception")}; if (!decoded) { if (should_be_valid) { std::cout << "Failed to decode valid transaction" << std::endl; return Status::kFailed; } continue; } const ChainConfig& config{test::kNetworkConfig.at(entry.key())}; const evmc_revision rev{config.revision(/*block_num=*/0, /*block_time=*/0)}; if (ValidationResult err{ pre_validate_transaction(txn, rev, config.chain_id, /*base_fee_per_gas=*/std::nullopt, /*blob_gas_price=*/std::nullopt)}; err != ValidationResult::kOk) { if (should_be_valid) { std::cout << "Validation error " << magic_enum::enum_name(err) << std::endl; return Status::kFailed; } continue; } if (should_be_valid && !txn.sender()) { std::cout << "Failed to recover sender" << std::endl; return Status::kFailed; } if (!should_be_valid && txn.sender()) { std::cout << entry.key() << "\n" << "Sender recovered for invalid transaction" << std::endl; return Status::kFailed; } if (!should_be_valid) { continue; } const std::string expected_sender{test["sender"].get()}; if (txn.sender() != hex_to_address(expected_sender)) { std::cout << "Sender mismatch for " << entry.key() << ":\n" << *txn.sender() << " != " << expected_sender << std::endl; return Status::kFailed; } const auto expected_intrinsic_gas{intx::from_string(test["intrinsicGas"].get())}; const auto calculated_intrinsic_gas{intrinsic_gas(txn, rev)}; if (calculated_intrinsic_gas != expected_intrinsic_gas) { std::cout << "Intrinsic gas mismatch for " << entry.key() << ":\n" << intx::to_string(calculated_intrinsic_gas, /*base=*/16) << " != " << intx::to_string(expected_intrinsic_gas, /*base=*/16) << std::endl; return Status::kFailed; } } return Status::kPassed; } // https://ethereum-tests.readthedocs.io/en/latest/test_types/difficulty_tests.html Status individual_difficulty_test(const nlohmann::json& j, const ChainConfig& config) { auto parent_timestamp{std::stoull(j["parentTimestamp"].get(), nullptr, 0)}; auto parent_difficulty{intx::from_string(j["parentDifficulty"].get())}; auto current_timestamp{std::stoull(j["currentTimestamp"].get(), nullptr, 0)}; auto block_num{std::stoull(j["currentBlockNumber"].get(), nullptr, 0)}; auto current_difficulty{intx::from_string(j["currentDifficulty"].get())}; bool parent_has_uncles{false}; if (j.contains("parentUncles")) { auto parent_uncles{j["parentUncles"].get()}; if (parent_uncles == "0x00") { parent_has_uncles = false; } else if (parent_uncles == "0x01") { parent_has_uncles = true; } else { std::cout << "Invalid parentUncles " << parent_uncles << std::endl; return Status::kFailed; } } intx::uint256 calculated_difficulty{EthashRuleSet::difficulty(block_num, current_timestamp, parent_difficulty, parent_timestamp, parent_has_uncles, config)}; if (calculated_difficulty == current_difficulty) { return Status::kPassed; } std::cout << "Difficulty mismatch for block " << block_num << "\n" << hex(calculated_difficulty) << " != " << hex(current_difficulty) << std::endl; return Status::kFailed; } RunResults difficulty_tests(const nlohmann::json& outer) { RunResults res; for (const auto& network : outer.items()) { if (network.key() == "_info") { continue; } const ChainConfig& config{test::kNetworkConfig.at(network.key())}; for (const auto& test : network.value().items()) { const Status status{individual_difficulty_test(test.value(), config)}; res += status; } } return res; } bool exclude_test(const fs::path& p, const fs::path& root_dir, bool include_slow_tests) { const auto path_fits = [&p, &root_dir](const fs::path& e) { return root_dir / e == p; }; return std::ranges::any_of(kFailingTests, path_fits) || (!include_slow_tests && std::ranges::any_of(kSlowTests, path_fits)); } int main(int argc, char* argv[]) { StopWatch sw; sw.start(); CLI::App app{"Run Ethereum EL tests"}; std::string evm_path; app.add_option("--evm", evm_path, "Path to EVMC-compliant VM"); std::string tests_path{SILKWORM_ETHEREUM_TESTS_DIR}; app.add_option("--tests", tests_path, "Path to Ethereum EL tests") ->capture_default_str() ->check(CLI::ExistingDirectory); std::string test_name_filter; app.add_option("--filter", test_name_filter, "Inclusion filter matching the test names to be executed") ->capture_default_str(); unsigned num_threads{std::thread::hardware_concurrency()}; app.add_option("--threads", num_threads, "Number of parallel threads")->capture_default_str(); bool include_slow_tests{false}; app.add_flag("--slow", include_slow_tests, "Run slow tests"); CLI11_PARSE(app, argc, argv) init_terminal(); if (!evm_path.empty()) { evmc_loader_error_code err{EVMC_LOADER_UNSPECIFIED_ERROR}; exo_evm = evmc_load_and_configure(evm_path.c_str(), &err); if (err) { std::cerr << "Failed to load EVM: " << evmc_last_error_msg() << std::endl; return -1; } } size_t stack_size{50 * kMebi}; #ifdef NDEBUG stack_size = 16 * kMebi; #endif ThreadPool thread_pool{num_threads, stack_size}; const fs::path root_dir{tests_path}; static const std::map kTestTypes{ {kDifficultyDir, difficulty_tests}, {kBlockchainDir, blockchain_test}, {kTransactionDir, transaction_test}, }; for (const auto& entry : kTestTypes) { const fs::path& dir{root_dir / entry.first}; const RunnerFunc runner{entry.second}; if (!fs::exists(dir)) { continue; } for (auto i = fs::recursive_directory_iterator(dir); i != fs::recursive_directory_iterator{}; ++i) { if (exclude_test(*i, root_dir, include_slow_tests)) { ++total_skipped; i.disable_recursion_pending(); } else if (fs::is_regular_file(i->path()) && i->path().extension() == ".json") { const fs::path path{*i}; thread_pool.push_task([=]() { run_test_file(path, runner, test_name_filter); }); } } } thread_pool.wait_for_tasks(); std::cout << kColorGreen << total_passed << " tests passed" << kColorReset << ", "; if (total_failed != 0) { std::cout << kColorMaroonHigh; } std::cout << total_failed << " failed"; if (total_failed != 0) { std::cout << kColorReset; } std::cout << ", " << total_skipped << " skipped"; const auto [_, duration] = sw.lap(); std::cout << " in " << StopWatch::format(duration) << std::endl; return total_failed != 0; } ================================================ FILE: cmd/test/fuzzer_diagnostics.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include "address_sanitizer_fix.hpp" void print_stack_trace() { void* trace[16]; int trace_size = backtrace(trace, 16); char** messages = backtrace_symbols(trace, trace_size); // NOLINTNEXTLINE(cppcoreguidelines-no-malloc) [[maybe_unused]] auto _ = gsl::finally([&messages] { free(reinterpret_cast(messages)); }); std::cout << "Stack Trace:\n"; for (int i = 0; i < trace_size; ++i) { std::cout << messages[i] << "\n"; // extract the address from the message char* address = strchr(messages[i], '['); if (address) { ++address; char* end = strchr(address, ']'); if (end) { *end = '\0'; // use addr2line to get the file name and line number std::string command = "addr2line -e ./rpcdaemon_fuzzer_diagnostics " + std::string(address); auto command_result = system(command.c_str()); // NOLINT(cert-*,concurrency-*) if (command_result != 0) { std::cout << "addr2line failed\n"; } } } } } using namespace silkworm::rpc::json_rpc; using namespace silkworm::rpc::test_util; int main(int argc, char* argv[]) { CLI::App app{"Debug or rerun a single fuzzer test"}; std::string input_str; std::string input_file; app.add_option("input", input_str, "Input string") ->description(R"(Wrap JSON in '' to avoid shell escaping, e.g. '{"jsonrpc":"2.0","id":1}')") ->required(false); app.add_option("-f", input_file, "Path to the JSON request file") ->check(CLI::ExistingFile) ->required(false); CLI11_PARSE(app, argc, argv) if (input_str.empty() && input_file.empty()) { std::cerr << "Either input string or input file must be provided\n"; return -1; } if (!input_file.empty()) { std::ifstream input_file_stream(input_file); input_str = std::string(std::istreambuf_iterator(input_file_stream), std::istreambuf_iterator()); } if (!nlohmann::json::accept(input_str)) { std::cout << "Not valid json: " << input_str << "\n"; } else { auto request_json = nlohmann::json::parse(input_str); std::cout << "Request: " << request_json.dump(4) << "\n"; } std::string reply; try { RpcApiE2ETest api_e2e_test; api_e2e_test.run<&RequestHandlerForTest::handle_request>(input_str, reply); } catch (...) { std::exception_ptr eptr = std::current_exception(); try { if (eptr) { std::rethrow_exception(eptr); } } catch (const std::exception& e) { std::cout << "Caught exception: " << e.what() << "\n"; print_stack_trace(); } } if (nlohmann::json::accept(reply)) { std::cout << "Reply Content: " << nlohmann::json::parse(reply).dump(4) << "\n"; } else { std::cout << "Reply Content (non JSON): " << reply << "\n"; } return 0; } ================================================ FILE: cmd/test/fuzzer_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include "address_sanitizer_fix.hpp" using namespace silkworm::rpc::json_rpc; using namespace silkworm::rpc::test_util; extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) { const auto request = std::string(reinterpret_cast(Data), Size); if (!nlohmann::json::accept(request)) { return -1; } const auto request_json = nlohmann::json::parse(request); RpcApiE2ETest api_e2e_test; std::string reply; api_e2e_test.run<&RequestHandlerForTest::handle_request>(request, reply); if (!nlohmann::json::accept(reply)) { return -1; } const auto reply_json = nlohmann::json::parse(reply); return 0; } ================================================ FILE: cmd/test/sentry_client_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include using namespace silkworm::sentry::grpc::client; using namespace silkworm; Task run(sentry::api::SentryClient& client) { auto service = co_await client.service(); try { auto eth_version = co_await service->handshake(); SILK_INFO << "handshake success!"; SILK_INFO << "protocol: eth/" << int{eth_version}; auto node_infos = co_await service->node_infos(); const auto& node_info = node_infos[0]; SILK_INFO << "client_id: " << node_info.client_id; auto peer_count = co_await service->peer_count(); SILK_INFO << "peer_count: " << peer_count; } catch (const rpc::GrpcStatusError& ex) { SILK_ERROR << ex.what(); } } int main() { log::Settings log_settings; log_settings.log_verbosity = log::Level::kDebug; log::init(log_settings); log::set_thread_name("main"); sentry::Settings sentry_settings; silkworm::rpc::ClientContextPool context_pool{ sentry_settings.context_pool_settings, }; SentryClient client{ sentry_settings.api_address, context_pool.any_grpc_context(), }; auto run_future = boost::asio::co_spawn( context_pool.any_executor(), run(client), boost::asio::use_future); context_pool.start(); run_future.get(); context_pool.stop(); context_pool.join(); return 0; } ================================================ FILE: codecov.yml ================================================ coverage: status: project: default: informational: true ignore: - "**/*_test.cpp" - "cmd" - "silkworm/interfaces" ================================================ FILE: conanfile.py ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 from conan import ConanFile class SilkwormRecipe(ConanFile): settings = 'os', 'compiler', 'build_type', 'arch' generators = 'CMakeDeps' def requirements(self): self.requires('catch2/3.6.0') self.requires('magic_enum/0.8.2') self.requires('ms-gsl/4.0.0') self.requires('nlohmann_json/3.11.3') self.requires('tl-expected/1.1.0') self.requires('zlib/1.3.1') if self.settings.arch == 'wasm': return self.requires('abseil/20240116.2', override=True) self.requires('benchmark/1.6.1') self.requires('boost/1.83.0', override=True) self.requires('cli11/2.2.0') self.requires('gmp/6.2.1') # fix to an older recipe revision due to missing binary packages for the latest revision # see https://github.com/conan-io/conan-center-index/issues/26959 self.requires('grpc/1.67.1#c214ddb4e04e8d9a44d3a100defc9706') self.requires('gtest/1.12.1') self.requires('jwt-cpp/0.6.0') self.requires('libtorrent/2.0.10') self.requires('mimalloc/2.1.2') self.requires('openssl/3.4.1', override=True) self.requires('protobuf/5.27.0', override=True) self.requires('roaring/1.1.2') self.requires('snappy/1.1.7') self.requires('spdlog/1.12.0') self.requires('sqlitecpp/3.3.0') self.requires('tomlplusplus/3.3.0') self.requires('libdeflate/1.23') def configure(self): if (self.settings.os == 'Linux') and (self.settings.compiler == 'clang'): self.options['grpc'].with_libsystemd = False # Disable Catch2 version 3.x.x signal handling on WASM if self.settings.arch == 'wasm': self.options['catch2'].no_posix_signals = True self.configure_boost() def configure_boost(self): # on Windows rebuilding boost from sources increases the build time a lot, so we skip configuration # hoping it doesn't break with asio_no_deprecated = False if self.settings.os == 'Windows': return self.options['boost'].asio_no_deprecated = True if self.settings.os == 'Macos': cmake_osx_deployment_target = '15.0' os_version_min_flag = f'-mmacosx-version-min={cmake_osx_deployment_target}' self.options['boost'].extra_b2_flags = f'cxxflags="{os_version_min_flag}" linkflags="{os_version_min_flag}"' # Disable building unused boost components # note: changing default options above forces a boost rebuild anyway for component in self.boost_components_unused(): setattr(self.options['boost'], 'without_' + component, True) @staticmethod def boost_components_unused() -> set[str]: components_all = [ 'atomic', 'chrono', 'container', 'context', 'contract', 'coroutine', 'date_time', 'exception', 'fiber', 'filesystem', 'graph', 'graph_parallel', 'iostreams', 'json', 'locale', 'log', 'math', 'mpi', 'nowide', 'program_options', 'python', 'random', 'regex', 'serialization', 'stacktrace', 'system', 'test', 'thread', 'timer', 'type_erasure', 'wave', ] components_used = [ # asio-grpc requires: 'container', # silkworm requires: 'iostreams', 'system', 'thread', 'url', # Boost::iostreams requires 'random', 'regex', # Boost::thread requires: 'atomic', 'chrono', 'date_time', 'exception', ] return set(components_all) - set(components_used) ================================================ FILE: docs/CONTRIBUTING.md ================================================ # Contributing Guide We use the [ISO Standard C++][cpp-standard-iso] programming language, specifically C++20. If you contribute to this project, your contributions will be made under [our license][silkworm-license]. The contributions must follow [Silkworm code style](code_style.md). Use `make fmt lint` to format the code and perform basic checks locally before submitting a PR. ## Code Structure Apart from the submodules and some auxiliary directories, Silkworm contains the following components: * [`cmd`][silkworm-cmd]
The source code of Silkworm executable binaries. * [`silkworm/capi`][silkworm-capi]
This module contains the C API exposed by Silkworm for inclusion into [Erigon][erigon] Golang Cgo. This module depends on the `core`, `infra`, `node`, `rpc` and `sentry` modules. * [`silkworm/core`][silkworm-core]
This module contains the heart of the Ethereum protocol logic as described by the [Yellow Paper][ethereum-yellow-paper]. Source code within `core` is compatible with WebAssembly and cannot use C++ exceptions. * [`silkworm/infra`][silkworm-infra]
This module contains common abstractions and facilities useful for networking, concurrency and system programming. This module depends on the `core` and `interfaces` modules. * [`silkworm/interfaces`][silkworm-interfaces]
This module contains the definition of our internal [gRPC][grpc] interfaces based on [Erigon architecture][erigon-interfaces] and their generated stubs and skeletons. * [`silkworm/node`][silkworm-node]
This module contains the database, the staged sync and other logic necessary to function as an Ethereum node. This module depends on the `core` module. * [`silkworm/rpc`][silkworm-rpc]
This module implements the networking and protocol stacks for the `RpcDaemon` component for an Ethereum node based on [Erigon architecture][erigon-interfaces], exposing the vast majority of the [Ethereum JSON RPC Execution API][ethereum-execution-api]. This module depends on the `core`, `infra` and `node` modules. * [`silkworm/sentry`][silkworm-sentry]
This module implements the networking and protocol stacks for the `Sentry` component for an Ethereum node based on [Erigon architecture][erigon-interfaces]. This module depends on the `core`, `infra` and `node` modules. * [`silkworm/sync`][silkworm-sync]
This module implements the networking and protocol stacks for the `Consensus` component for an Ethereum node based on [Erigon architecture][erigon-interfaces], exposing the portion of the [Ethereum JSON RPC Execution API][ethereum-execution-api] necessary to interact with any Consensus Layer client. This module depends on the `core`, `infra`, `node` and `rpc` modules. * [`silkworm/wasm`][silkworm-wasm]
This module allows the `core` the run on WebAssembly. This module depends on both the `core` and `node` modules. ## Dependency Management Silkworm uses [Conan 1.x][conan] as package manager, but also relies on Git submodules for some libraries. ### Conan If you need to add/remove/update any library managed in Conan, just edit the Silkworm [Conan recipe][silkworm-conan]. ### Submodules Silkworm uses also some 3rd-party libraries kept as Git submodules in [third-party][silkworm-third_party] folder. #### Add If you need to add library `lib` to Silkworm submodules, the following procedure must be applied: 1. mkdir third_party/ 2. git submodule add third_party// 3. add third_party//CMakeLists.txt with library-specific build instructions (e.g. build options) 4. update third_party/CMakeLists.txt #### Remove If you need to permanently remove library `lib` from Silkworm submodules, the following procedure must be applied: 1. git submodule deinit -f third_party// 2. git rm -rf third_party/ 3. update third_party/CMakeLists.txt 4. rm -rf .git/modules/third_party/ #### Update If you need to update library `lib` in Silkworm submodules to `commit_hash`, the following procedure must be applied: 1. cd third_party// 2. git checkout ## Updating Internal gRPC Interfaces If you need to update gRPC protocol definitions (i.e. `.proto` files) and related stubs/skeletons for internal [Erigon interfaces][erigon-interfaces], the following procedure must be applied: 1. determine the current version used in Erigon as `commit_hash` from [here][erigon-interfaces-version] 2. cd third_party/erigon-interfaces 3. git pull 4. git checkout ## Updating Snapshots If you need to update the list of builtin snapshots in Silkworm, the following procedure must be applied: * update `erigon-snapshot` submodule to the new commit * generate the embedded C++ code bindings for predefined snapshots by executing from project home folder: ``` /silkworm/dev/cli/embed_toml -i third_party/erigon-snapshot -o silkworm/db/datastore/snapshots/config/chains ``` ## Adding Network Genesis Definitions We use configuration files in JSON format to specify the formal genesis definition for any supported networks. You can find all the currently supported configurations looking at `genesis_.json` files in `silkworm/core/chain` folder. If you need to expand or modify the network configurations used by Silkworm, the following procedure must be applied: 1. add new or edit existing JSON genesis files in `silkworm/core/chain` following the naming convention `genesis_.json` 2. generate the C++ code bindings for JSON genesis files by executing from project home folder: ``` /silkworm/dev/cli/embed_json -i silkworm/core/chain -o silkworm/core/chain -w ``` ## Updating Ethereum JSON-RPC Specification We use the specification in [Ethereum JSON RPC Execution API][ethereum-execution-api] in order to formally validate the incoming requests in our RPC daemon. ### Update Specification from Official Source If you need to update the official specification imported by Silkworm, the following procedure must be applied: 1. update `execution-apis` submodule to the new commit 2. generate the all-in-one JSON specification file following the build instructions in [Ethereum JSON RPC Execution API][ethereum-execution-api] 3. copy and rename the generated JSON specification file into `silkworm/rpc/json_rpc/specification.json`, resolving the conflicts that may arise 4. generate the C++ code bindings for JSON specification by executing from project home folder: ``` /silkworm/dev/cli/embed_json -i silkworm/rpc/json_rpc -o silkworm/rpc/json_rpc -p specification -n silkworm::rpc::json_rpc -w ``` ### Patch Local Specification If you need to patch the local copy of the specification used by Silkworm, the following procedure must be applied: 1. edit the generated JSON specification file in `silkworm/rpc/json_rpc/specification.json` 2. generate the C++ code bindings for JSON specification as specified at step 4. in previous section above ## C API for Erigon One of the main goals of Silkworm is providing fast C++ libraries directly usable within [Erigon][erigon]. In order to achieve this goal, Silkworm defines its [C API][silkworm-capi-header] and provides *silkworm_capi* library built by a dedicated build target. Such library is then integrated within Erigon using the Golang Cgo facility by means of the [Silkworm Go bindings][silkworm-go]. ### Development and Testing Developing and testing Silkworm as a library within Erigon requires the following steps: 1. clone **silkworm**, **silkworm-go** and **erigon** repositories into the same parent directory 2. build *silkworm_capi* target into silkworm/build 3. cd erigon && ./turbo/silkworm/silkworm_go_devenv.sh $PWD/../silkworm $PWD/../silkworm/build $PWD/../silkworm-go 4. Edit silkworm, silkworm-go and erigon sources, rebuild and run them as usual The linkage between silkworm and erigon happens through the silkworm-go repository (see `cat go.work` in the parent directory). If you are sure in advance that no change to silkworm-go will be necessary (i.e. you are going to change neither the C API declarations nor the Go bindings), then you can omit the last argument to the silkworm_go_devenv.sh script: in such case, silkworm-go checkout is automatically put in a temporary directory. ### Cutting C-API Release (maintainers only) Updating the version of Silkworm included in Erigon requires the following steps: 1. cut a new release of silkworm_capi library in silkworm by issuing a new tag named ``capi-`` 2. go to Actions -> Release -> Run workflow for a new version of silkworm-go to be built and tagged as ``v`` 3. wait about 20 min for this CI job to finish: https://app.circleci.com/pipelines/github/erigontech/silkworm-go 4. update your existing PR or open a new one on erigon to upgrade the silkworm-go module by running the command `go get github.com/erigontech/silkworm-go@v`[^1] and then `go mod tidy` [silkworm-license]: https://github.com/erigontech/silkworm/tree/master/LICENSE [silkworm-cmd]: https://github.com/erigontech/silkworm/tree/master/cmd [silkworm-capi]: https://github.com/erigontech/silkworm/tree/master/silkworm/capi [silkworm-core]: https://github.com/erigontech/silkworm/tree/master/silkworm/core [silkworm-infra]: https://github.com/erigontech/silkworm/tree/master/silkworm/infra [silkworm-interfaces]: https://github.com/erigontech/silkworm/tree/master/silkworm/interfaces [silkworm-node]: https://github.com/erigontech/silkworm/tree/master/silkworm/node [silkworm-sentry]: https://github.com/erigontech/silkworm/tree/master/silkworm/sentry [silkworm-rpc]: https://github.com/erigontech/silkworm/tree/master/silkworm/rpc [silkworm-sync]: https://github.com/erigontech/silkworm/tree/master/silkworm/sync [silkworm-wasm]: https://github.com/erigontech/silkworm/tree/master/silkworm/wasm [silkworm-conan]: https://github.com/erigontech/silkworm/tree/master/conanfile.py [silkworm-third_party]: https://github.com/erigontech/silkworm/tree/master/third_party [silkworm-capi-header]: https://github.com/erigontech/silkworm/tree/master/silkworm/capi/silkworm.h [silkworm-go]: https://github.com/erigontech/silkworm-go [cpp-standard-iso]: https://isocpp.org [ethereum-yellow-paper]: https://ethereum.github.io/yellowpaper/paper.pdf [conan]: https://conan.io [grpc]: https://grpc.io [erigon]: https://github.com/erigontech/erigon [erigon-interfaces]: https://github.com/erigontech/interfaces [erigon-interfaces-version]: https://github.com/erigontech/erigon/blob/main/erigon-lib/go.mod [ethereum-execution-api]: https://github.com/ethereum/execution-apis [^1]: You may need to use `GOPRIVATE=github.com/erigontech/silkworm-go go get github.com/erigontech/silkworm-go@v` to avoid any early failure until the tag is publicly available. ================================================ FILE: docs/JSON-RPC-API.md ================================================ ## RPC API Implementation Status The following table shows the current [JSON RPC API](https://eth.wiki/json-rpc/API) implementation status in `Silkworm RPCDaemon`. | Command | Availability | Notes | Integration | Performance | |:-------------------------------------------|:------------:|:-----------------------------------------:|:-----------:|------------:| | admin_nodeInfo | Yes | | Yes | | | admin_peers | Yes | | Yes | | | | | | | | | web3_clientVersion | Yes | | Yes | | | web3_sha3 | Yes | | Yes | | | | | | | | | net_listening | Yes | | Yes | | | net_peerCount | Yes | | Yes | | | net_version | Yes | | Yes | | | | | | | | | eth_blockNumber | Yes | | Yes | | | eth_chainId | Yes | | Yes | | | eth_protocolVersion | Yes | | Yes | | | eth_syncing | Yes | | Yes | | | eth_gasPrice | Yes | | Yes | | | eth_maxPriorityFeePerGas | Yes | | Yes | | | eth_feeHistory | Yes | | Yes | | | eth_baseFee | Yes | | Yes | | | eth_blobBaseFee | Yes | | Yes | | | | | | | | | eth_getBlockByHash | Yes | | Yes | Yes | | eth_getBlockByNumber | Yes | | Yes | Yes | | eth_getBlockTransactionCountByHash | Yes | | Yes | | | eth_getBlockTransactionCountByNumber | Yes | | Yes | | | eth_getUncleByBlockHashAndIndex | Yes | | Yes | | | eth_getUncleByBlockNumberAndIndex | Yes | | Yes | | | eth_getUncleCountByBlockHash | Yes | | Yes | | | eth_getUncleCountByBlockNumber | Yes | | Yes | | | | | | | | | eth_getTransactionByHash | Yes | | Yes | Yes | | eth_getRawTransactionByHash | Yes | | Yes | | | eth_getTransactionByBlockHashAndIndex | Yes | | Yes | | | eth_getRawTransactionByBlockHashAndIndex | Yes | | Yes | | | eth_getTransactionByBlockNumberAndIndex | Yes | | Yes | | | eth_getRawTransactionByBlockNumberAndIndex | Yes | | Yes | | | eth_getTransactionReceipt | Yes | partial: retrieve receipts by exec txn | Yes | Yes | | eth_getBlockReceipts | Yes | | Yes | | | eth_getTransactionReceiptsByBlock | Yes | same as eth_getBlockReceipts | | | | | | | | | | eth_estimateGas | Yes | | Yes | | | eth_getBalance | Yes | | Yes | Yes | | eth_getCode | Yes | | Yes | | | eth_getTransactionCount | Yes | | Yes | | | eth_getStorageAt | Yes | | Yes | | | eth_call | Yes | | Yes | Yes | | eth_callMany | Yes | partial: timeout param handling missing | Yes | | | eth_callBundle | Yes | | Yes | | | eth_createAccessList | Yes | | Yes | Yes | | | | | | | | eth_newFilter | Yes | | | | | eth_newBlockFilter | - | not yet implemented | | | | eth_newPendingTransactionFilter | - | not yet implemented | | | | eth_getFilterChanges | Yes | | | | | eth_getFilterLogs | Yes | | | | | eth_uninstallFilter | Yes | | | | | eth_getLogs | Yes | | Yes | Yes | | | | | | | | eth_accounts | No | deprecated | | | | eth_sendRawTransaction | Yes | remote only | Yes | | | eth_sendTransaction | - | not yet implemented | | | | eth_sign | No | deprecated | | | | eth_signTransaction | - | deprecated | | | | eth_signTypedData | - | ???? | | | | | | | | | | eth_getProof | - | not yet implemented | | | | | | | | | | eth_mining | Yes | | Yes | | | eth_coinbase | Yes | | Yes | | | eth_hashrate | Yes | | | | | eth_submitHashrate | Yes | | Yes | | | eth_getWork | Yes | | Yes | | | eth_submitWork | Yes | | Yes | | | | | | | | | eth_subscribe | - | not yet implemented (WebSockets only) | | | | eth_unsubscribe | - | not yet implemented (WebSockets only) | | | | | | | | | | engine_newPayloadV1 | Yes | | Yes | | | engine_newPayloadV2 | Yes | | Yes | | | engine_forkchoiceUpdatedV1 | Yes | | Yes | | | engine_forkchoiceUpdatedV2 | Yes | | Yes | | | engine_getPayloadV1 | Yes | | Yes | | | engine_getPayloadV2 | Yes | | Yes | | | engine_exchangeCapabilities | Yes | | Yes | | | engine_exchangeTransitionConfigurationV1 | Yes | | Yes | | | engine_getPayloadBodiesByHashV1 | Yes | | Yes | | | engine_getPayloadBodiesByRangeV1 | Yes | | Yes | | | | | | | | | debug_accountRange | Yes | | Yes | | | debug_accountAt | Yes | | Yes | | | debug_getModifiedAccountsByHash | Yes | | Yes | | | debug_getModifiedAccountsByNumber | Yes | | Yes | | | debug_getBadBlocks | No | data not available | | | | debug_getRawBlock | Yes | can be optimized to avoid re-encoding | | | | debug_getRawHeader | Yes | | | | | debug_getRawReceipts | Yes | | | | | debug_getRawTransaction | Yes | | | | | debug_storageRangeAt | Yes | | Yes | | | debug_traceBlockByHash | Yes | uses JSON streaming | Yes | | | debug_traceBlockByNumber | Yes | uses JSON streaming | Yes | | | debug_traceTransaction | Yes | uses JSON streaming | Yes | | | debug_traceCall | Yes | uses JSON streaming | Yes | | | debug_traceCallMany | Yes | uses JSON streaming | Yes | | | | | | | | | trace_call | Yes | | Yes | | | trace_callMany | Yes | | Yes | | | trace_rawTransaction | Yes | | Yes | | | trace_replayBlockTransactions | Yes | | Yes | | | trace_replayTransaction | Yes | | Yes | | | trace_block | Yes | | Yes | | | trace_filter | Yes | uses JSON streaming | Yes | | | trace_get | Yes | | Yes | | | trace_transaction | Yes | | Yes | | | | | | | | | txpool_content | Yes | | Yes | | | txpool_status | Yes | | Yes | | | | | | | | | eth_getCompilers | No | deprecated | | | | eth_compileLLL | No | deprecated | | | | eth_compileSolidity | No | deprecated | | | | eth_compileSerpent | No | deprecated | | | | | | | | | | db_putString | No | deprecated | | | | db_getString | No | deprecated | | | | db_putHex | No | deprecated | | | | db_getHex | No | deprecated | | | | | | | | | | shh_post | No | deprecated | | | | shh_version | No | deprecated | | | | shh_newIdentity | No | deprecated | | | | shh_hasIdentity | No | deprecated | | | | shh_newGroup | No | deprecated | | | | shh_addToGroup | No | deprecated | | | | shh_newFilter | No | deprecated | | | | shh_uninstallFilter | No | deprecated | | | | shh_getFilterChanges | No | deprecated | | | | shh_getMessages | No | deprecated | | | | | | | | | | erigon_cumulativeChainTraffic | Yes | | Yes | | | erigon_getHeaderByHash | Yes | | Yes | | | erigon_getHeaderByNumber | Yes | | Yes | | | erigon_getBalanceChangesInBlock | Yes | | Yes | | | erigon_getBlockByTimestamp | Yes | | Yes | | | erigon_getBlockReceiptsByBlockHash | Yes | | Yes | | | erigon_getLogsByHash | Yes | | Yes | | | erigon_forks | Yes | | Yes | | | erigon_watchTheBurn | Yes | | Yes | | | erigon_nodeInfo | Yes | | Yes | | | erigon_blockNumber | Yes | | Yes | | | erigon_cacheCheck | Yes | | Yes | | | erigon_getLatestLogs | Yes | | Yes | | | | | | | | | bor_getSnapshot | - | not yet implemented | | | | bor_getAuthor | - | not yet implemented | | | | bor_getSnapshotAtHash | - | not yet implemented | | | | bor_getSigners | - | not yet implemented | | | | bor_getSignersAtHash | - | not yet implemented | | | | bor_getCurrentProposer | - | not yet implemented | | | | bor_getCurrentValidators | - | not yet implemented | | | | bor_getRootHash | - | not yet implemented | | | | | | | | | | parity_listStorageKeys | Yes | | Yes | | | | | | | | | ots_getApiLevel | Yes | | Yes | | | ots_getInternalOperations | Yes | | Yes | | | ots_searchTransactionsBefore | Yes | | Yes | | | ots_searchTransactionsAfter | Yes | | Yes | | | ots_getBlockDetails | Yes | | Yes | | | ots_getBlockDetailsByHash | Yes | | Yes | | | ots_getBlockTransactions | Yes | | Yes | | | ots_hasCode | Yes | | Yes | | | ots_traceTransaction | Yes | | Yes | | | ots_getTransactionError | Yes | | Yes | | | ots_getTransactionBySenderAndNonce | Yes | | Yes | | | ots_getContractCreator | Yes | | Yes | | This table is constantly updated. Please visit again. ================================================ FILE: docs/code_style.md ================================================ # Silkworm code style The codebase respects: 1. [C++ Core Guidelines][cpp-core-guidelines] 1. [Google's C++ Style Guide][cpp-google-style-guide] with amendments (see below) 1. [clang-format](https://clang.llvm.org/docs/ClangFormat.html) rules according to our .clang-format config 1. [clang-tidy](https://clang.llvm.org/extra/clang-tidy/) checks according to our .clang-tidy config This is enforced by tools and code reviews. clang-format runs on CI for each PR as a part of "lint" job. It can be run locally using `make fmt`. clang-tidy runs on CI when a PR is merged to `master` as a part of integration workflow. The report is attached to the "ARTIFACTS" section of the linux-clang-tidy job that can be found [here](https://app.circleci.com/pipelines/github/erigontech/silkworm?branch=master). ## Extra guidelines This is a list of project-specific guidelines that take precedence over the rules defined elsewhere. ### Basic rules 1. .cpp & .hpp file extensions for C++; .c & .h are reserved for C. 1. Maximum line length is 120, indentation is 4 spaces. Use `make fmt` to reformat according to the code style. 1. Every code file starts with the Apache license boilerplate. Use `make lint` to check this. 1. Use `#pragma once` in the headers instead of the classic `#ifndef` guards. 1. Use `snake_case()` for function names. 1. Exceptions are allowed outside of the `core` library. 1. `using namespace foo` is allowed inside .cpp files, but not inside headers. 1. User-defined literals are allowed. 1. `template ` syntax is allowed. 1. Use `size_t` without `std::` prefix. ### Libraries 1. `` is allowed. 1. Usage of coroutines is allowed via [task.hpp](../silkworm/infra/concurrency/task.hpp) inclusion. 1. In addition to the [Boost libraries permitted in the style guide](https://google.github.io/styleguide/cppguide.html#Boost), we allow: * Algorithm * Asio * Circular Buffer * DLL * Process * Signals2 * System * Thread * Url ### P1a init syntax convention for variables Use modern init syntax only for custom construction of objects. Use a more conventional assignment operator primitive values and references. Good: BlockNum expected_blocknum = previous_progress + 1; ChainConfig& config = kMainnetConfig; ExecutionProcessor processor{block, *rule_set, buffer, *chain_config}; Bad: BlockNum expected_blocknum{previous_progress + 1}; ChainConfig& config{kMainnetConfig}; ExecutionProcessor processor{block, *rule_set, buffer, *chain_config}; Copy initialization can use either style: auto index_path{snapshot_path->index_file()}; auto index_path = snapshot_path->index_file(); Exception: Bytes transaction_key(8, 0); // has to use parentheses to create 8 zeros instead of [8, 0] list ### P1b init syntax convention for data members (fields) Member initializer list must use the modern init syntax: DebugExecutor(...) : database_reader_{database_reader}, block_cache_{block_cache}, workers_{workers}, tx_{tx}, config_{config} {} as well as inline initialization of data members: struct PayloadAttributes { uint64_t timestamp{0}; }; ### P2 io_context var naming Use `ioc` name when having a single variable of type `asio::io_context` (unless having a more specific name brings much more expressiveness). Good: io_context ioc; Bad: io_context io_context; io_context context; io_context ctx; io_context io; ### P3 BlockNum var naming Use `BlockNum block_num` name when having a single variable of type `BlockNum` (unless having a more specific name brings expressiveness, e.g.: `start`, `end`, `last`). Do not use `height`. Good: BlockNum block_num; Bad: BlockNum height BlockNum block_number BlockNum number BlockNum num BlockNum bn BlockNum b ### P4 RAII lock type usage Use `std::scoped_lock` for a common case where a single mutex needs to be locked immediately and unlocked at the end of the scope. Do not use `std::lock_guard`. Use `std::unique_lock` where a manual `unlock()` is required, for working with `std::condition_variable` or if other unique_lock features are needed (e.g. deferred locking, adoption). ### P5 SILKWORM_ASSERT Use `SILKWORM_ASSERT` instead of `assert(x)`. ### P6 SILK_DEBUG logging macros Use `SILK_DEBUG` logging macros instead of `log::Debug()` syntax. ### P7 explicit keyword Add explicit keyword, but only for single argument constructors, as per [CppCoreGuidelines C.46](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-explicit) ### P8 nodiscard Do not habitually use `[[nodiscard]]` by default. Use it sparingly as needed. We've had a "modernize-use-nodiscard" clang-tidy policy, which led to the proliferation of `[[nodiscard]]` throughout the codebase. The policy was disabled, but a lot of usages were redundant. For example, usage on Task is redundant, because the type itself is already marked with `[[nodiscard]]` within the library. An example where it is useful: if a function has a side effect, and returns no result or an error (e.g. `bool ok = f()`). ### P9 move-only reference parameters Default to move by value. Use `T&&` parameters with caution. Legitimate uses are move-constructors. In some other cases it could be seen as a premature optimization. When copy-prevention is required, consider making a type move-only. If T is an aggregate type (e.g. a basic struct), deleting the copy member functions defeats the aggregate semantics and forces to provide a custom constructor. In this case, if copy-prevention is critical for performance, it might be easier to use `T&&` than providing a custom constructor. ### P10 constants definition keywords In all cases the order of keywords is: [static] [inline] const[expr] **Case 1:** For class-member constants: Use `static constexpr` if possible: static constexpr uint64_t kMinDifficulty{0x20000}; (`inline` is implicit in this case), otherwise use `static inline const`: static inline const std::filesystem::path kDefaultTorrentRepoPath{".torrent"}; **Case 2:** For private constants in .cpp files: Use `static constexpr` if possible, otherwise use `static const`. `inline` is unnecessary in this case. **Case 3:** For global constants in .hpp files: Use `inline constexpr` if possible, otherwise use `inline const` if possible, otherwise use `extern const`. `static` is misleading in this case. See also: [Constants: Safe Idioms](https://abseil.io/tips/140) ### P11 CLion code inspections CLion has some extra code inspections in addition to clang-tidy. These inspections are not enforced. It is up to each developer to decide if they are useful or not (and enable/disable them locally). ### P12 string formatting Use `<<` (and `std::stringstream`) or `+` syntax as you feel for logs and error messages. `std::format` is not supported, but [planned eventually](https://github.com/erigontech/silkworm/issues/2384). ### P13 include paths and quotes Use double quotes and paths relative to the current file within a CMake library, allow referring ancestor directories within the library: #include "types.hpp" #include "../../../api/endpoint/range.hpp" Otherwise use `<` and paths relative to the silkworm root source directory: #include // outside core ### P14 io_context vs any_io_executor Most of the async code needs to dispatch operations (or create sub objects that need to dispatch), and doesn't need to run or stop the io_context. In this case the executor interface is enough. `any_io_executor` is a lightweight copyable and movable type-erased wrapper that can be used to dispatch async work without binding to a concrete executor type (such as `io_context::executor`). Prefer using `any_io_executor` if possible instead of `io_context`. `any_io_executor` can be passed by value, but clang-tidy usually wants to pass it by a const reference: const boost::asio::any_io_executor& executor ### P15 getters in .hpp or .cpp Put simple single line getters in .hpp: int id() const { return id_; } ### P16 i++ vs ++i Prefer ++i by default. Only use i++ where a previous result value is needed. Good: for (size_t i = 0; i < items.size(); ++i) Bad: for (size_t i = 0; i < items.size(); i++) See [this guideline](https://google.github.io/styleguide/cppguide.html#Preincrement_and_Predecrement) ### P17 auto for constants Use an explicit type specification instead of `auto` in constants: Good: static constexpr size_t kThreadNameFixedSize = 11; Bad: static constexpr auto kThreadNameFixedSize = 11; ### P18a optional for an empty std::function Sometimes we use `std::function` as a factory or a callback object. If it is optional prefer using `optional>` and `nullopt` where null is expected instead of using an empty `std::function` (with a `nullptr` inside). ### P18b optional smart pointers Sometimes we use `std::unique_ptr/smart_ptr` to delay initialization or for optional subobjects. In this case a null value should be expected. In other cases we `make_unique` in the constructor and the pointer is never null. Use a default-constructed `std::unique_ptr/smart_ptr` where null is expected. ### P19 name prefix for factory functions Use `make` name/prefix for factory functions instead of `build` or `create`: SentryPtrPair make_sentry(...) std::shared_ptr make(...) std::string make_thread_name(...) `build` prefix can be used for a “builder” pattern, where it might have no parameters, and potential side effects, for example `RecSplit::build()`. ### P20 to_string method naming Use `to_string()` by default to convert an object to std::string (e.g. for logging purposes). Only provide `operator<<` if needed (implemented on top of `to_string()`). If a global function is required, `xxx_to_string()` name should be used. ### P21 multiline parameters indentation Default to 1 parameter per line. Accepted styles: ValidationResult execute_block( const Block& block, State& state, const ChainConfig& chain_config); ValidationResult execute_block(const Block& block, State& state, const ChainConfig& chain_config); The first style is more friendly to Git. The 2nd style in .cpp files clearly splits the function body from parameters. Bad: void start_new_batch(BlockNum block_height, const evmc::bytes32& block_hash, const std::vector&& tx_rlps, bool unwind); ### P22 trailing comments Trailing comments are banned. Good: class StateChangeCollection { //! The database transaction ID associated with the state changes. uint64_t tx_id_{0}; }; // Download the torrent files via web seeding from settings.url_seed auto web_seed_torrents = download_web_seed(settings); Bad: struct AppOptions { std::string datadir{}; // Provided database path }; block1.ommers.push_back(BlockHeader{}); // generate error InvalidOmmerHeader ### P23 string constants When defining a string constant prefer `string_view`. Good: constexpr std::string_view kDbDataFileName{"mdbx.dat"}; constexpr std::string_view kDbDataFileName = "mdbx.dat"; Bad: constexpr const char* kPruneModeHistoryKey{"pruneHistory"}; constexpr const char* kSafeBlockHash = "safeBlockHash"; static const std::string kHeadBlockHash = "headBlockHash"; constexpr std::string_view kTorrentExtension{".torrent"sv}; Exception: `sv` suffix must be used for embedding zero bytes (`'\0'`) within the string_view. ### P24 tmp vs temp naming convention The word "temporary" should be abbreviated as `tmp`, not `temp`. Good: TemporaryDirectory tmp_dir; Bad: TempChainData temp_chaindata; ### P25 license boilerplate Use SPDX short form like in evmone: // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 ### P26 filename vs file name Use `filename` (and `Filename`) everywhere. Good: fs::path entry_filename = entry.path().stem(); FilenameFormat format; Bad: std::string get_file_name(); const char* kSessionFileName{".session"}; ### P27 member init list vs constructor body code Prefer constructors based on member init list. Use constructor body code if the member init list approach leads to cluttered dense code. It is possible to unclutter the member init list using static helper functions, but constructor body code benefit is that it keeps the init sequence in one place. ### P28 Bytes size() vs length() Prefer `size()` instead of `length()`. The methods are aliases of each other. ### P29 friend vs member comparison operators Prefer "friend" version of the comparison operators as it is more versatile, and in some cases mandatory (e.g. for using as a key of std::map). Good: friend bool operator==(const Config& lhs, const Config& rhs) = default; Bad: bool operator==(const Config& other) const = default; ### P30 tx vs txn naming Use "txn", "txns" abbreviations for Ethereum transactions. Use "tx", "txs" abbreviations for database transactions. Good: Stage::Result TxnLookup::forward(RWTx& tx) Bad: Stage::Result TxLookup::forward(RWTxn& txn) [cpp-core-guidelines]: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines [cpp-google-style-guide]: https://google.github.io/styleguide/cppguide.html ================================================ FILE: docs/conan.md ================================================ # Conan package manager Conan is a Python-based meta-build system package management tool. Silkworm uses it for third party packages that are available and well-maintained within the official ["conancenter" repository](https://conan.io/center). The conancenter repository also contains prebuilt binary packages for common platforms to speed up compilation. Other third party packages are included as git submodules or vendored in [third_party](../third_party) directory. ## Concepts * conanfile - a config file that defines the list of required libraries and their build options * recipe - same as conanfile * recipe version - a semver version of a library * recipe revision - a checksum identifying a conanfile version for a particular version of a library (a conanfile might have many revision updates for a given recipe version) * package - a binary artifact from conancenter (or built locally) * package revision - a checksum identifying a package built from to a particular recipe revision; each recipe revision triggers a build of a new package revision on conancenter CI/CD * settings - general platform configuration parameters like OS and compiler; can be set as `--settings` from command line, `[settings]` in a profile * options - library-specific configuration parameters including custom ones; can be set as `--options` from command line, `[options]` in a profile, `self.options` in conanfile * conf - low-level configuration parameters like `cxxflags`; can be set as `--conf` from command line, `[conf]` in a profile * profile - a static config file that defines common settings, options and conf, can be extended using command line parameters ## Debugging In [conan.cmake](../cmake/conan.cmake): set(CONAN_VERBOSITY "verbose") ## Integration The default way to integrate conan is to have a custom script that runs [conan install](https://docs.conan.io/2/reference/commands/install.html) command. Running this command uses [conanfile.py](../conanfile.py) and one of the [profiles](../cmake/profiles) as inputs and produces a bunch of cmake scripts that will make the declared required libraries available to use in CMakeLists.txt and then in the code. Silkworm integration is not calling `conan install` directly. It is integrated using [cmake-conan](../third_party/cmake-conan) "cmake provider". When the first `find_package(X)` call is encountered in a `CMakeLists.txt` file, cmake consults with the cmake-conan provider, and it will re-run `conan install` command if needed. The parameters to this command are configured in [conan.cmake](../cmake/conan.cmake). The full `conan install` command is printed in the build log. As a part of `conan install` process it will download header files, source code, prebuilt binary packages, and potentially build the required libraries. That build of conan libraries is happening in a separate cmake process that does not interact with the main one, and its outputs are produced in `$HOME/.conan2`. The only way to pass configuration parameters for this build is via one of the following inputs: Inputs: * a profile config from [profiles](../cmake/profiles) with settings is guessed or passed via cmake CONAN_PROFILE parameter * [conanfile.py](../conanfile.py) with predefined requirements and options * [conan.cmake](../cmake/conan.cmake) with more fine tuning of options, settings and conf Outputs: * downloaded header files and source code for all requirements in `$HOME/.conan2` * downloaded prebuilt binary packages in `$HOME/.conan2` (if a matching configuration is found on conancenter) * local builds of packages in `$HOME/.conan2` (if a matching configuration is not found on conancenter) * cmake integration script for all requirements in `$CMAKE_BINARY_DIR/conan2` Thus, for example, defining a compilation option in [cmake toolchain](../cmake/toolchain) or CMakeLists.txt has no effect on conan libraries. Their options have to be passed via one of the inputs above. ## Prebuilt binary packages Silkworm aims to reuse prebuilt binary packages from conancenter as much as possible. The heaviest of prebuilt requirements are: * gmp * grpc * libtorrent * openssl * protobuf If a library binary packages are not reused from conancenter for any reason, the build time will increase and it needs to be investigated. The library binary is not reused if there's a mismatch between local options/settings (collected from conanfile, profile and command line parameters) and options/settings that were used when building the library on the conancenter CI/CD. For example, a binary built on conancenter with `options.X=False` is not compatible with a local build defining `options.X=True`. This policy is applied for all options and most settings. Another common reason for a binary package to not be reused is if there's a requirement with `override=True` in conanfile and its version and options are not matching the version and options of a transitive requirement that the conancenter binary package was built with. For example, libtorrent/2.0.10 binary package can't be reused, because it depends on boost/1.81.0 with default options, but conanfile requires boost/1.83.0 with modified options. To get a list of available binary binary packages on conancenter run: conan list 'grpc/1.67.1:*' -r=conancenter -f=compact the above command only lists binary packages for the latest recipe revision, but sometimes some revisions don't have binary packages available. In this case, list all recipe revisions with dates: conan list 'grpc/1.67.1#*' -r=conancenter List all binary packages for a given revision: conan list 'grpc/1.67.1#c214ddb4e04e8d9a44d3a100defc9706:*' -r=conancenter -f=compact To list binary packages for all recipe revisions use: conan list 'grpc/1.67.1#*:*' -r=conancenter -f=compact ## Updating compilers The Silkworm compiler version and settings can be freely updated as long as they maintain binary compatibility with the prebuilt binary packages from conancenter. For example, a package built on Linux gcc 11 is binary compatible with Silkworm built on Linux with gcc 12 (all else being equal), so compiling on gcc 12 requires no changes to the conan configuration. Updating any compiler setting in conan profiles makes it incompatible with available conancenter binary packages. Therefore the profile settings are dictated and fixed by what's available on conancenter. The available conancenter platforms by Oct 2024 are: * Linux gcc 11, no clang * macOS Apple clang 13, both x86 and arm * Windows VS 2019 and 2022 ## Build cache Some libraries have special options or overriden requirements and are locally built into `$HOME/.conan2`. Some compiler options in [compiler_settings.cmake](../cmake/compiler_settings.cmake) might break binary compatibility without conan realizing this. For example, SILKWORM_SANITIZE cmake option breaks binary compatibility. In this case the build cache must be cleared using: conan remove --confirm "*" or simply: rm -rf $HOME/.conan2 Silkworm [CI config](../.circleci/config.yml) reuses the conan cache directory between jobs, but makes sure that the cache is binary compatible using a conservative `conan-cache-key`. If any conan configuration is changed then the cache is not reused. ## Updating grpc Silkworm directly depends on a several grpc transitive requirements: * abseil * openssl * protobuf * zlib When updating to a new grpc version, those requirements must be updated to the same versions as grpc requires. Otherwise the configuration will be incompatible and grpc will be rebuilt from source instead of using the binary package from conancenter. The required versions can be seen in ["Dependencies" tab on conan.io](https://conan.io/center/recipes/grpc). ================================================ FILE: docs/db_toolbox.md ================================================ # db_toolbox Silkworm keeps recent chain data in MDBX database for faster access. The `db_toolbox` tool is a collection of utilities to perform operations on Silkworm MDBX database. Simple usage is `db_toolbox [OPTIONS] [SUBCOMMAND] [SUBCOMMANDOPTIONS]` ## Examples Dump the database table layout and stats ``` db_toolbox --datadir ~/Library/Silkworm/ tables ``` Dump the progress of sync stages (i.e. content of SyncStage table) ``` db_toolbox --datadir ~/Library/Silkworm/ stages ``` Clear content (i.e. delete all the rows) in LogAddressIndex and LogTopicIndex tables ``` db_toolbox --datadir ~/Library/Silkworm/ --exclusive clear --names LogAddressIndex LogTopicIndex ``` Reset the LogIndex stage progress to zero ``` db_toolbox --datadir ~/Library/Silkworm/ --exclusive stage-set --name LogIndex --block 0 ``` ## OPTIONS Common options always specify the base data file to open : - `--datadir` which indicates the **directory** path where `data.mdb` is located - `--lmdb.mapSize` which indicates the **LMDB map size** of data.mdb ### Caveat LMDB's mapSize value basically indicates the width of the segment of virtual memory that has been assigned a direct byte-for-byte correlation with with the data file on disk. This exhibits a very different behavior amongst Linux OS and Windows OS: while in the first case mapSize value behaves as a "limit" for the data file growth, on Windows there is a 1:1 relation amongst mapSize value and the effective size on disk. Put in other words : if, on Linux, we open a **new** LMDB data file specifying 10GB mapSize, we will have a data file with an effective size of few bytes until we begin to insert new data and eventually the growth of file size is limited by mapSize value (i.e. the file won't grow beyond 10GB and any attempt to insert new data will return an `MDB_MAPFULL` error). On Windows instead, the opening of a **new** LMDB data file with 10GB mapSize will result in the immediate allocation on disk of a file sized 10GB. ### Hint Omitting the specification of --lmdb.mapSize is allowed as long as the data file already exists on disk. In such case the value is automatically adjusted to the size of data.mdb. This is like specifying an `lmdb.mapSize == 0`. **Warning** : although db_toolbox protects against errors is highly discouraged to provide a value for --lmdb.mapSize lower than actual file size cause, as observed behavior, the result is a truncation of data file to a size matching --lmdb.mapSize thus causing the invalidation of all mappings for existing data. # Subcommand : tables Usage `db_toolbox --datadir tables` This subcommand requires no additional arguments and provides a detailed list of tables stored into data.mdb. Here is a sample output: ``` Database tables : 40 Database page size : 4096 Dbi Table name Records D Branch Leaf Overflow Size --- ------------------------ ---------- -- ---------- ---------- ---------- ------------ 0 [FREE_DBI] 1298 2 1 38 2662 11063296 1 [MAIN_DBI] 38 1 0 1 0 4096 2 ACS 0 0 0 0 0 0 3 B 0 0 0 0 0 0 4 CODE 332167 4 551 36369 471560 2082734080 5 CST2 480725185 5 42626 2983648 0 12395618304 6 DBINFO 4 1 0 1 0 4096 7 DatabaseVersion 1 1 0 1 0 4096 8 H 11093179 4 2888 183237 0 762368000 9 LastBlock 1 1 0 1 0 4096 10 LastFast 1 1 0 1 0 4096 11 LastHeader 1 1 0 1 0 4096 12 PLAIN-ACS 11093083 4 2206 636977 13858850 59383943168 13 PLAIN-CST2 480725185 5 23356 2423015 0 10020335616 14 PLAIN-SCS 8060176 4 1199 345971 19021260 79333089280 15 PLAIN-contractCode 28925348 5 10217 727455 0 3021504512 16 SCS 0 0 0 0 0 0 17 SNINFO 0 0 0 0 0 0 18 SSP2 13 1 0 1 0 4096 19 SSU2 12 1 0 1 0 4096 20 TrieSync 0 0 0 0 0 0 21 b 11093154 5 7247 579534 44431570 184395165696 22 call_from_index 0 0 0 0 0 0 23 call_to_index 0 0 0 0 0 0 24 clique- 0 0 0 0 0 0 25 contractCode 20079491 5 13292 647684 0 2707357696 26 ethereum-config- 1 1 0 1 0 4096 27 h 33279441 5 24581 2054802 0 8517152768 28 hAT 139283444 5 70658 3774220 657381 18441252864 29 hST 468672601 6 190311 10240434 472990 44661698560 30 iB 0 0 0 0 0 0 31 iTh2 161166225 4 4472 585499 0 2416521216 32 incarnationMap 10390653 4 1487 140197 0 580337664 33 l 874122311 5 210798 10736097 0 44838481920 34 log_address_index 2922721 4 870 91062 157358 1021091840 35 log_topic_index 102732305 5 54006 3118356 259925 14058647552 36 migrations 10 1 0 1 0 4096 37 r 11093083 4 5655 452366 42411330 175592861696 38 secure-key- 0 0 0 0 0 0 39 txSenders 9553003 5 17663 1412848 4982030 26265767936 Database map size : 773094113280 Size of file on disk : 773094113280 Data pages count : 168580819 Data pages size : 690507034624 Reclaimable pages : 1335698 Reclaimable size : 5471019008 Free space available : 88058097664 ``` Each table reports: - the id it was opened with - the name - the number of records stored - the maximum depth of the Btree - The **number of pages** for Branch, Leaf and Overflow - The overall size of data stored which is `(Branch + Leaf + Overflow) * Database page size` The bottom part of the report depicts the storage status of the data file. # Subcommand : freelist Usage `db_toolbox --datadir freelist [--detail]` This produces as output the sum of reclaimable space held in FREE_DBI. Sample : ``` Total free pages : 1335698 Total free size : 5471019008 ``` When the `--detail` CLI flag is also provided, the output records the free reclaimable datapages for each transaction which have freed some. Sample : ``` TxId Pages Size --------- --------- ------------ 33133 263 1077248 33134 509 2084864 33135 509 2084864 33136 509 2084864 33137 509 2084864 33138 509 2084864 33139 509 2084864 33140 509 2084864 33141 509 2084864 33142 509 2084864 33143 509 2084864 33144 509 2084864 33145 509 2084864 33146 509 2084864 33147 509 2084864 33148 509 2084864 33149 509 2084864 33150 509 2084864 33151 509 2084864 33152 509 2084864 33153 509 2084864 33154 509 2084864 33155 509 2084864 33156 509 2084864 33157 509 2084864 [ ... ] 34419 288 1179648 34420 6 24576 34421 12157 49795072 34422 6 24576 34423 15 61440 34424 6 24576 34425 12 49152 34426 6 24576 34427 6 24576 34428 59 241664 34429 6 24576 34430 9569 39194624 Total free pages : 1335698 Total free size : 5471019008 ``` # Subcommand : clear Usage `db_toolbox --datadir clear --names [--drop]` This command provides a handy way to empty a table from all records or drop it. Example : `db_toolbox --datadir clear --names h b` will delete all records from tables `h` and `b` but the table (meant as a container) will remain into database. Example : `db_toolbox --datadir clear --names h b --drop` will delete tables `h` and `b` from database just like a SQL `drop` statement. ## Caveat Like all operations on LMDB the deletion of records (or of an entire table) lives within a writable transaction and by consequence requires database file to have enough space available to record all data pages which will be freed by the transaction. This implies the size of database file may grow. # Subcommand : compact Usage `db_toolbox --datadir compact --workdir [--replace] [--nobak]` The purpose of this subcommand is to obtain a _compacted_ data file. The compaction process renumbers all data pages while reclaiming those previously freed by preceding transactions. This command is the implementation of `mdb_env_copy2` LMDB API call with `MDB_CP_COMPACT` flag. Running this command reports no progress and, ad indicative figure, took more than 6 hours to compact an 730GB data file on Windows with NMVe storage support. Additional flag `--replace` will replace origin data file with compacted one by renaming original data file with `.bak` suffix. Eventually flag `--nobak` will prevent the creation of the bak copy and directly overwrites the origin file. This is a sample output of `tables` command **before** a compact action ``` Database tables : 40 Database page size : 4096 Dbi Table name Records D Branch Leaf Overflow Size --- ------------------------ ---------- -- ---------- ---------- ---------- ------------ 0 [FREE_DBI] 1298 2 1 38 2662 11063296 1 [MAIN_DBI] 38 1 0 1 0 4096 2 ACS 0 0 0 0 0 0 3 B 0 0 0 0 0 0 4 CODE 332167 4 551 36369 471560 2082734080 5 CST2 480725185 5 42626 2983648 0 12395618304 6 DBINFO 4 1 0 1 0 4096 7 DatabaseVersion 1 1 0 1 0 4096 8 H 11093179 4 2888 183237 0 762368000 9 LastBlock 1 1 0 1 0 4096 10 LastFast 1 1 0 1 0 4096 11 LastHeader 1 1 0 1 0 4096 12 PLAIN-ACS 11093083 4 2206 636977 13858850 59383943168 13 PLAIN-CST2 480725185 5 23356 2423015 0 10020335616 14 PLAIN-SCS 8060176 4 1199 345971 19021260 79333089280 15 PLAIN-contractCode 28925348 5 10217 727455 0 3021504512 16 SCS 0 0 0 0 0 0 17 SNINFO 0 0 0 0 0 0 18 SSP2 13 1 0 1 0 4096 19 SSU2 12 1 0 1 0 4096 20 TrieSync 0 0 0 0 0 0 21 b 11093154 5 7247 579534 44431570 184395165696 22 call_from_index 0 0 0 0 0 0 23 call_to_index 0 0 0 0 0 0 24 clique- 0 0 0 0 0 0 25 contractCode 20079491 5 13292 647684 0 2707357696 26 ethereum-config- 1 1 0 1 0 4096 27 h 33279441 5 24581 2054802 0 8517152768 28 hAT 139283444 5 70658 3774220 657381 18441252864 29 hST 468672601 6 190311 10240434 472990 44661698560 30 iB 0 0 0 0 0 0 31 iTh2 161166225 4 4472 585499 0 2416521216 32 incarnationMap 10390653 4 1487 140197 0 580337664 33 l 874122311 5 210798 10736097 0 44838481920 34 log_address_index 2922721 4 870 91062 157358 1021091840 35 log_topic_index 102732305 5 54006 3118356 259925 14058647552 36 migrations 10 1 0 1 0 4096 37 r 11093083 4 5655 452366 42411330 175592861696 38 secure-key- 0 0 0 0 0 0 39 txSenders 9553003 5 17663 1412848 4982030 26265767936 Database map size : 773094113280 Size of file on disk : 773094113280 Data pages count : 168580819 Data pages size : 690507034624 Reclaimable pages : 1335698 Reclaimable size : 5471019008 Free space available : 88058097664 ``` And this is the same database **after** a compaction (6 hours and 10 minutes later) ``` Database tables : 40 Database page size : 4096 Dbi Table name Records D Branch Leaf Overflow Size --- ------------------------ ---------- -- ---------- ---------- ---------- ------------ 0 [FREE_DBI] 0 0 0 0 0 0 1 [MAIN_DBI] 38 1 0 1 0 4096 2 ACS 0 0 0 0 0 0 3 B 0 0 0 0 0 0 4 CODE 332167 4 551 36369 471560 2082734080 5 CST2 480725185 5 42626 2983648 0 12395618304 6 DBINFO 4 1 0 1 0 4096 7 DatabaseVersion 1 1 0 1 0 4096 8 H 11093179 4 2888 183237 0 762368000 9 LastBlock 1 1 0 1 0 4096 10 LastFast 1 1 0 1 0 4096 11 LastHeader 1 1 0 1 0 4096 12 PLAIN-ACS 11093083 4 2206 636977 13858850 59383943168 13 PLAIN-CST2 480725185 5 23356 2423015 0 10020335616 14 PLAIN-SCS 8060176 4 1199 345971 19021260 79333089280 15 PLAIN-contractCode 28925348 5 10217 727455 0 3021504512 16 SCS 0 0 0 0 0 0 17 SNINFO 0 0 0 0 0 0 18 SSP2 13 1 0 1 0 4096 19 SSU2 12 1 0 1 0 4096 20 TrieSync 0 0 0 0 0 0 21 b 11093154 5 7247 579534 44431570 184395165696 22 call_from_index 0 0 0 0 0 0 23 call_to_index 0 0 0 0 0 0 24 clique- 0 0 0 0 0 0 25 contractCode 20079491 5 13292 647684 0 2707357696 26 ethereum-config- 1 1 0 1 0 4096 27 h 33279441 5 24581 2054802 0 8517152768 28 hAT 139283444 5 70658 3774220 657381 18441252864 29 hST 468672601 6 190311 10240434 472990 44661698560 30 iB 0 0 0 0 0 0 31 iTh2 161166225 4 4472 585499 0 2416521216 32 incarnationMap 10390653 4 1487 140197 0 580337664 33 l 874122311 5 210798 10736097 0 44838481920 34 log_address_index 2922721 4 870 91062 157358 1021091840 35 log_topic_index 102732305 5 54006 3118356 259925 14058647552 36 migrations 10 1 0 1 0 4096 37 r 11093083 4 5655 452366 42411330 175592861696 38 secure-key- 0 0 0 0 0 0 39 txSenders 9553003 5 17663 1412848 4982030 26265767936 Database map size : 750808727552 Size of file on disk : 750808682496 Data pages count : 168578118 Data pages size : 690495971328 Reclaimable pages : 0 Reclaimable size : 0 Free space available : 60312756224 ``` ## Caveat To run the compact action you need free storage space available at least equal to size of origin data file. Please note that this tool does reclaim free space **but does not defragment** tables segments. # Subcommand : copy This tools gives the user the ability to copy individual table(s) from one database to another instead of keeping copies of entire databases. Usage ``` db_toolbox --datadir copy --targetdir \ [--create --new.mapSize ] [--tables ] \ [--noempty] [--upsert] [--commit] ``` where - `--targetdir` specifies the target directory holding the target data.mdb (directory must exist) - if target data.mdb does not exist (i.e. target directory is empty) must specify `--create` and `--new.mapSize` with the initial map size for the data file being created - `--tables` specifies a list of table names to copy. If omitted all **known** tables (see below) from origin data file will be copied - `--noempty` flag specifies origin empty tables must not be copied (i.e. they're not created on target) - `--upsert` flag forces the tool to copy origin data into target using Upserts instead of Appends. This is necessary when target db already exists and already contains populated tables with identical name - `--commit` specifies the weight of each commit. By default the copy action commits every 5GB. **Limitation to known tables** : due to the nature of copy action the tool **must know** in advance the _definition_ of origin and target table (for example if is DUPSORTed) and by consequence all tables which do not have a definition in Turbo-Geth (and in Silkworm) code will be skipped. This tool automatically enlarges data file on behalf of the amount of data being copied. When `--upsert` CLI flag is active free_dbi pages are reused if possible. When, instead, default append mode data is stored, according to LMDB documentation, at the end of database. A useful progress is provided like in this sample: ``` db_toolbox --datadir e:\tg\tg\chaindata copy --targetdir e:\tg\compact-temp --tables hAT hST Table Progress ------------------------ -------------------------------------------------- [FREE_DBI] Skipped (SYSTEM TABLE) [MAIN_DBI] Skipped (SYSTEM TABLE) ACS Skipped (no match --tables) B Skipped (no match --tables) CODE Skipped (no match --tables) CST2 Skipped (no match --tables) DBINFO Skipped (no match --tables) DatabaseVersion Skipped (no match --tables) H Skipped (unknown table) LastBlock Skipped (no match --tables) LastFast Skipped (no match --tables) LastHeader Skipped (no match --tables) PLAIN-ACS Skipped (no match --tables) PLAIN-CST2 Skipped (no match --tables) PLAIN-SCS Skipped (no match --tables) PLAIN-contractCode Skipped (no match --tables) SCS Skipped (no match --tables) SNINFO Skipped (unknown table) SSP2 Skipped (no match --tables) SSU2 Skipped (no match --tables) TrieSync Skipped (no match --tables) b Skipped (no match --tables) call_from_index Skipped (unknown table) call_to_index Skipped (unknown table) clique- Skipped (no match --tables) contractCode Skipped (no match --tables) ethereum-config- Skipped (no match --tables) h Skipped (no match --tables) hAT ............................W..................... hST .W......W......W.......W......W.......W......W.... iB Skipped (no match --tables) iTh2 Skipped (no match --tables) incarnationMap Skipped (no match --tables) l Skipped (no match --tables) log_address_index Skipped (no match --tables) log_topic_index Skipped (no match --tables) migrations Skipped (no match --tables) r Skipped (no match --tables) secure-key- Skipped (no match --tables) txSenders Skipped (no match --tables) All done! ``` When a table is effectively being copied each dot `.` represent 2% of overall records. An `W` instead of `.` means in the last 2% there has been a commit (according to `--commit` value) ================================================ FILE: docs/dev_tools.md ================================================ # Silkworm development tools ## Check Log Indices ### Overview Silkworm maintains transaction log address/topic indices in MDBX database. Such indices are generated at runtime by processing transaction logs. ### The `check_log_indices` tool The `check_log_indices` tool is a command-line utility to check the consistency and integrity of transaction log indices. #### Synopsis #### Examples Check only log address index from block 0 up to block 2'000'000 ``` check_log_indices --to 2000000 --index address ``` Check only log topic index for block 2'000'000 ``` check_log_indices --from 2000000 --to 2000000 --index topic ``` Check both log address and topic indices for block 17'500'000 ``` check_log_indices --from 17500000 --to 17500000 ``` Check both log address and topic indices from block 17'000'000 up to the tip (beware: long-running) ``` check_log_indices --from 17000000 ``` ## Snapshots ### Overview Silkworm stores historical chain data in `snapshots` (immutable .seg files) which maintain binary compatibility with Erigon ones and can be seeded/downloaded by [BitTorrent](https://en.wikipedia.org/wiki/BitTorrent) protocol. Each `snapshot` contains just one type of data (e.g. block headers, block bodies, block transactions) encoded with specific format. A `torrent` is a file format for data transfer (similar to other archive file formats, e.g. zip). Inside a .torrent file there is a set of information that helps your BitTorrent client find and download data. This information is a group of files that includes names, sizes, and folder structure. Along with information about files, a .torrent file also contains a list of trackers. A `magnet link` is a simple text link that includes all the necessary information to download a torrent file. ### The `snapshots` tool The `snapshots` tool is a collection of small utilities and benchmark tests for working with Silkworm snapshot files. #### Synopsis ``` Snapshots toolbox Usage: snapshots [OPTIONS] Options: -h,--help Print this help message and exit --tool ENUM:{count_headers->0,decode_segment->1,download->2}:ENUM in [0 - 2] [2] The snapshot tool to use --repetitions INT:INT in [1 - 100] [1] The test repetitions --file TEXT [v1-000000-000500-bodies.seg] The path to snapshot file --page INT:INT in [1 - 1024] [4096] The page size in kB --torrent_dir TEXT [.torrent] The path to torrent file repository --magnet TEXT The magnet link to download --magnet_file TEXT [.magnet_links] The file containing magnet links to download --download_rate_limit INT:INT in [4194304 - 134217728] [67108864] The download rate limit in bytes per second --upload_rate_limit INT:INT in [1048576 - 33554432] [4194304] The upload rate limit in bytes per second --active_downloads INT:INT in [3 - 20] [6] The max number of downloads active simultaneously [Option Group: Log] Logging options Options: --log.verbosity ENUM:{critical->1,debug->5,error->2,info->4,trace->6,warning->3}:ENUM in [1 - 6] [4] Sets log verbosity --log.stdout Outputs to std::out instead of std::err --log.nocolor Disable colors on log lines --log.utc Prints log timings in UTC --log.threads Prints thread ids --log.file TEXT Tee all log lines to given file name ``` Currently available tools are: - `count_bodies` - `count_headers` - `create_index` - `open_index` - `decode_segment` - `download` - `lookup_header` - `lookup_body` - `lookup_txn` - `sync` #### Examples Download one snapshot from its magnet link and put it in torrent folder: ``` snapshots --tool download --magnet "magnet:?xt=urn:btih:83112dec4bec180cff67e01d6345c88c3134fd26&dn=v1-014500-015000-transactions.seg&tr=udp%3a%2f%2ftracker.opentrackr.org%3a1337%2fannounce&tr=udp%3a%2f%2f9.rarbg.com%3a2810%2fannounce&tr=udp%3a%2f%2ftracker.openbittorrent.com%3a6969%2fannounce&tr=http%3a%2f%2ftracker.openbittorrent.com%3a80%2fannounce&tr=https%3a%2f%2fopentracker.i2p.rocks%3a443%2fannounce&tr=udp%3a%2f%2fopen.stealth.si%3a80%2fannounce&tr=udp%3a%2f%2ftracker.torrent.eu.org%3a451%2fannounce&tr=udp%3a%2f%2ftracker.tiny-vps.com%3a6969%2fannounce&tr=udp%3a%2f%2ftracker.pomf.se%3a80%2fannounce&tr=udp%3a%2f%2ftracker.dler.org%3a6969%2fannounce&tr=udp%3a%2f%2fopen.demonii.com%3a1337%2fannounce&tr=udp%3a%2f%2fexplodie.org%3a6969%2fannounce&tr=udp%3a%2f%2fexodus.desync.com%3a6969%2fannounce&tr=https%3a%2f%2ftracker.nanoha.org%3a443%2fannounce&tr=https%3a%2f%2ftracker.lilithraws.org%3a443%2fannounce&tr=https%3a%2f%2ftr.burnabyhighstar.com%3a443%2fannounce&tr=http%3a%2f%2ftracker.mywaifu.best%3a6969%2fannounce&tr=http%3a%2f%2fbt.okmp3.ru%3a2710%2fannounce&tr=udp%3a%2f%2fzecircle.xyz%3a6969%2fannounce&tr=udp%3a%2f%2fyahor.ftp.sh%3a6969%2fannounce" ``` Download all snapshots from the magnet links contained in magnet file and put them in torrent folder: ``` snapshots --tool download --magnet_file .magnet_links --log.verbosity debug --active_downloads 3 ``` Count how many block headers are present in header snapshots under torrent folder: ``` snapshots --tool count_headers --repetitions 1 --log.verbosity info ``` Create indexes for target snapshot under torrent folder: ``` snapshots --tool create_index --file v1-000000-000500-headers.seg --log.verbosity info ``` Search block header by number in one snapshot ``` snapshots --tool lookup_header --snapshot_file v1-001500-002000-headers.seg --number 1500013 ``` Search block body by number in all snapshots ``` snapshots --tool lookup_body --number 1500012 ``` Search block body by number in one snapshot ``` snapshots --tool lookup_body --snapshot_file v1-001500-002000-bodies.seg --number 1500012 ``` Search transaction by hash in all snapshots ``` snapshots --tool lookup_txn --hash 0x3ba9a1f95b96d0a43093b1ade1174133ea88ca395e60fe9fd8144098ff7a441f ``` Search transaction by hash or by progressive identifier in one snapshot ``` snapshots --tool lookup_txn --snapshot_file v1-001500-002000-transactions.seg --hash 0x3ba9a1f95b96d0a43093b1ade1174133ea88ca395e60fe9fd8144098ff7a441f snapshots --tool lookup_txn --snapshot_file v1-001500-002000-transactions.seg --number 7341272 ``` ## gRPC Toolbox ### Overview Silkworm RPCDaemon may run in standalone mode using gRPC interfaces to communicate to other components. ### The `grpc_toolbox` tool The `db_toolbox` tool is a collection of utilities to query the KV/ETHBACKEND gRPC interface of Erigon/Silkworm. #### Synopsis #### Examples Print the number of timestamps in which the specified account has changed state ``` grpc_toolbox kv_index_range --table AccountsHistoryIdx --key 0x616a3E55a20dD54CC9fBb63D8333D89c275c9D90 ``` Print the first 10 changes in account state history using verbose mode (i.e. print keys and values) ``` grpc_toolbox kv_history_range --table AccountsHistory --limit 10 --verbose ``` Print the first 10 changes in account state for the specified key range using verbose mode (i.e. print keys and values) ``` grpc_toolbox kv_domain_range --table accounts --from_key 0x616a3E55a20dD54CC9fBb63D8333D89c275c9D90 \ --to_key 0x716a3E55a20dD54CC9fBb63D8333D89c275c9D90 --timestamp 100000000 --limit 10 --verbose ``` ================================================ FILE: docs/fuzzer.md ================================================ # Fuzz Tests in Silkworm SIlkworm uses [libFuzzer](https://llvm.org/docs/LibFuzzer.html) to execute its fuzzy tests. This battle tested library has helped many other projects to uncover bugs. Although the library is currently in the maintenance mode (bug fixing only) it is still sufficient for our needs. ## Execute tests To build the fuzzer use the following: ```bash mkdir build cd build cmake ../project -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCONAN_PROFILE=linux_x64_clang_16_release -DCMAKE_TOOLCHAIN_FILE=../project/cmake/toolchain/clang_libcxx.cmake -DSILKWORM_FUZZER=ON cmake --build --target rpcdaemon_fuzzer_test cmake –-build --target rpcdaemon_fuzzer_diagnostics ``` Then simply run: ```bash ./cmd/test/rpcdaemon_fuzzer_test -detect_leaks=0 ``` Note: we disable leaks detection to ignore known issues with GRPC library. The command above will start fuzzying without any prior knowledge about the request structure. It can be hours before it forms a valid request. To help the fuzzer, we can provide it with a collection of valid requests which it can use as a starting point, called corpus. Fortunately API test collection has a number of request we can use. ```bash mkdir -p corpus for file in ../third_party/execution-apis/tests/*/*.io; do cp --backup=numbered "$file" corpus; done for file in corpus/*; do sed -i '2,$d' "$file"; done for file in corpus/*; do sed -i 's/^>> //' "$file"; done ./cmd/test/rpcdaemon_fuzzer_test corpus -max_total_time=86400 -detect_leaks=0 ``` ## Diagnostics The fuzzer will stop the execution on a first error. Address, Lean or Undefined sanitizers will try to help us identifying the issue. The fault request is then written to `crash-*` file. To help with analysing a single request you can run the diagnostic tool: ```bash ./cmd/test/rpcdaemon_fuzzer_diagnostics '{"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["0x1A","0x2",[95,99]]}' #or ./cmd/test/rpcdaemon_fuzzer_diagnostics -f crash-file ``` ## Trophies 1. Various validation errors which led to the introduction of `rpc::json_rpc::Validator` 2. BlockNum accepting ill-formatted numbers, e.g. `5x5` 3. `{"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["0x1A","0x2",[95,99]]}` - triggers ASAN error ## Future development Recently some progress has been made on [using AI](https://security.googleblog.com/2024/01/scaling-security-with-ai-from-detection.html) in fuzzy tests. This is a very promising technology which could be adapted in our case: 1. Switch fuzzer library to [OSS-Fuzz](https://github.com/google/oss-fuzz) in libFuzzer mode 2. Use [oss-fuzz-gen](https://github.com/google/oss-fuzz-gen) for target generation ================================================ FILE: examples/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 if(NOT SILKWORM_CORE_ONLY) find_package(absl REQUIRED) find_package(gRPC REQUIRED) find_package(Protobuf REQUIRED) add_executable(get_latest_block get_latest_block.cpp) target_include_directories(get_latest_block PRIVATE ${CMAKE_SOURCE_DIR}) target_link_libraries( get_latest_block absl::flags_parse gRPC::grpc++_unsecure protobuf::libprotobuf silkworm_rpcdaemon ) endif() ================================================ FILE: examples/get_latest_block.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::db; using namespace silkworm::rpc; ABSL_FLAG(std::string, target, std::string{kDefaultPrivateApiAddr}, "server location as string
:"); // ABSL_FLAG(LogLevel, log_verbosity, LogLevel::Critical, "logging level"); Task> latest_block(db::kv::api::Service& service) { std::optional block_num; const auto db_transaction = co_await service.begin_transaction(); try { const auto chain_storage{db_transaction->make_storage()}; db::kv::api::CoherentStateCache state_cache; const BlockReader block_reader{*chain_storage, *db_transaction}; block_num = co_await block_reader.get_latest_block_num(); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what(); } catch (...) { SILK_ERROR << "unexpected exception"; } co_await db_transaction->close(); co_return block_num; } std::optional get_latest_block(boost::asio::io_context& ioc, db::kv::api::Service& service) { auto result = boost::asio::co_spawn( ioc, [&]() -> Task> { const auto block_num = co_await latest_block(service); ioc.stop(); co_return block_num; }, boost::asio::use_future); return result.get(); } int main(int argc, char* argv[]) { absl::SetProgramUsageMessage("Get latest block in Silkworm/Erigon"); absl::ParseCommandLine(argc, argv); log::set_verbosity(log::Level::kCritical); try { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Silkworm/Erigon running instance\n"; return -1; } // TODO(canepat): handle also secure channel for remote ChannelFactory create_channel = [&]() { return grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); }; // TODO(canepat): handle also local (shared-memory) database ClientContextPool context_pool{1}; auto& context = context_pool.next_context(); auto* ioc = context.ioc(); auto& grpc_context = *context.grpc_context(); kv::api::CoherentStateCache state_cache; auto channel = ::grpc::CreateChannel(target, ::grpc::InsecureChannelCredentials()); auto backend = std::make_unique(channel, grpc_context); auto database = std::make_unique( create_channel, grpc_context, &state_cache, ethdb::kv::make_backend_providers(backend.get())); auto context_pool_thread = std::thread([&]() { context_pool.run(); }); const auto latest_block_num = get_latest_block(*ioc, *database->service()); if (latest_block_num) { std::cout << "latest_block_num: " << latest_block_num.value() << "\n"; } if (context_pool_thread.joinable()) { context_pool_thread.join(); } } catch (const std::exception& e) { std::cerr << "Exception: " << e.what() << "\n"; } catch (...) { std::cerr << "Unexpected exception\n"; } return 0; } ================================================ FILE: silkworm/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 # Silkworm itself add_subdirectory(core) if(NOT SILKWORM_CORE_ONLY) add_subdirectory(interfaces) add_subdirectory(infra) add_subdirectory(db) add_subdirectory(dev) add_subdirectory(execution) add_subdirectory(rpc) add_subdirectory(sentry) add_subdirectory(sync) add_subdirectory(node) add_subdirectory(capi) endif() if(SILKWORM_WASM_API) add_subdirectory(wasm) endif() ================================================ FILE: silkworm/capi/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") add_subdirectory(common) set(TARGET silkworm_capi) find_package(Microsoft.GSL REQUIRED) set(PUBLIC_LIBS "") set(PRIVATE_LIBS glaze::glaze Microsoft.GSL::GSL silkworm_capi_common silkworm_core silkworm_db silkworm_execution silkworm_sentry silkworm_rpcdaemon ) # cmake-format: off silkworm_library( ${TARGET} PUBLIC ${PUBLIC_LIBS} PRIVATE ${PRIVATE_LIBS} TYPE SHARED NO_TEST ) # cmake-format: on # cmake-format: off # unit tests and cmd will use a static library version # to avoid ODR violations when identical symbols are mixed into both .dll and .exe silkworm_library( ${TARGET}_static PUBLIC ${PUBLIC_LIBS} PRIVATE ${PRIVATE_LIBS} TYPE STATIC ) # cmake-format: on # Remove custom stack_size linker option for this target get_target_property(LINK_OPTIONS ${TARGET} LINK_OPTIONS) list(REMOVE_ITEM LINK_OPTIONS "-Wl,-stack_size") list(REMOVE_ITEM LINK_OPTIONS "-Wl,${SILKWORM_STACK_SIZE}") set_target_properties(${TARGET} PROPERTIES LINK_OPTIONS "${LINK_OPTIONS}") add_subdirectory(cli) target_link_libraries(silkworm_capi_static_test PRIVATE silkworm_db_test_util) # collect all public C headers into the same directory set(HEADERS_INSTALL_PATH "${CMAKE_CURRENT_BINARY_DIR}/include") file(GLOB_RECURSE HEADERS "../capi/*.h" "../*/capi/*.h") add_custom_command( TARGET ${TARGET} POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${HEADERS_INSTALL_PATH}" COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${HEADERS} "${HEADERS_INSTALL_PATH}" ) ================================================ FILE: silkworm/capi/cli/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(Boost REQUIRED COMPONENTS headers) # Target 'execute' is used to exercise the Silkworm C API library even if using C++ main add_executable(execute execute.cpp) set(PRIVATE_LIBS Boost::headers silkworm_infra silkworm_db silkworm_rpcdaemon silkworm_capi_static silkworm_infra_cli ) target_link_libraries(execute PRIVATE ${PRIVATE_LIBS}) # Target 'capi_main' is used to check that Silkworm C API header passes pure C compilation (avoid this target in # sanitizer build due to linking errors w/ libFuzzingEngine dependencies) if(NOT SILKWORM_SANITIZE) add_executable(capi_main main.c) target_link_libraries(capi_main PRIVATE silkworm_capi) endif() ================================================ FILE: silkworm/capi/cli/execute.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wimplicit-fallthrough" #pragma GCC diagnostic ignored "-Wold-style-cast" #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::snapshots; using namespace silkworm::cmd::common; struct ExecuteBlocksSettings { BlockNum start_block{1}; BlockNum max_block{1}; uint64_t batch_size{1}; bool write_change_sets{true}; bool write_receipts{true}; bool write_call_traces{true}; bool use_internal_txn{false}; }; struct BuildIndexesSettings { std::vector segment_file_names; }; struct Settings { log::Settings log_settings; std::string data_folder; std::optional execute_blocks_settings; std::optional build_indexes_settings; std::optional rpcdaemon_settings; }; void parse_command_line(int argc, char* argv[], CLI::App& app, Settings& settings) { app.require_subcommand(1); // At least 1 subcommand is required // logging add_logging_options(app, settings.log_settings); // repository app.add_option("--datadir", settings.data_folder, "Path to data directory"); // execute sub-command auto cmd_execute = app.add_subcommand("execute", "Execute blocks"); ExecuteBlocksSettings exec_blocks_settings; cmd_execute->add_option("--from", exec_blocks_settings.start_block, "The start block number to execute") ->capture_default_str() ->check(CLI::Range(uint64_t{1}, std::numeric_limits::max())); cmd_execute->add_option("--to", exec_blocks_settings.max_block, "The maximum block number to execute") ->capture_default_str() ->check(CLI::Range(uint64_t{1}, std::numeric_limits::max())); cmd_execute->add_option("--batch_size", exec_blocks_settings.batch_size, "The block batch size to use") ->capture_default_str() ->check(CLI::Range(uint64_t{1}, std::numeric_limits::max())); cmd_execute->add_flag("--write_change_sets", exec_blocks_settings.write_change_sets) ->description("Flag indicating if state changes must be written or not") ->capture_default_str(); cmd_execute->add_flag("--write_receipts", exec_blocks_settings.write_receipts) ->description("Flag indicating if transaction receipts must be written or not") ->capture_default_str(); cmd_execute->add_flag("--write_call_traces", exec_blocks_settings.write_call_traces) ->description("Flag indicating if execution call traces must be written or not") ->capture_default_str(); cmd_execute->add_flag("--use_internal_txn", exec_blocks_settings.use_internal_txn) ->description( "Flag indicating if internal MDBX transaction must be used. " "Please be aware that when this option is chosen the block execution result *will* be saved to the db") ->capture_default_str(); // build indexes sub-command auto cmd_build_indexes = app.add_subcommand("build_indexes", "Build indexes"); BuildIndexesSettings build_indexes_settings; cmd_build_indexes->add_option("--filenames", build_indexes_settings.segment_file_names, "Segment file names to index")->delimiter(',')->required(); // rpcdaemon sub-command auto cmd_rpcdaemon = app.add_subcommand("rpcdaemon", "Start RPC Daemon"); rpc::DaemonSettings rpcdaemon_settings{ .datadir = settings.data_folder}; // parse command line app.parse(argc, argv); // Force logging options to have consistent format with Silkworm API library (matching Erigon in turns) settings.log_settings.log_utc = false; settings.log_settings.log_timezone = false; settings.log_settings.log_trim = true; // check subcommand presence if (app.got_subcommand(cmd_execute)) { settings.execute_blocks_settings = exec_blocks_settings; } else if (app.got_subcommand(cmd_build_indexes)) { settings.build_indexes_settings = std::move(build_indexes_settings); } else if (app.got_subcommand(cmd_rpcdaemon)) { settings.rpcdaemon_settings = std::move(rpcdaemon_settings); } } const char* make_path(const snapshots::SnapshotPath& p) { const auto path_string{p.path().string()}; char* path = new char[path_string.size() + 1]; std::strcpy(path, path_string.c_str()); return path; } std::vector collect_all_snapshot_bundles(const SnapshotRepository& repository) { std::vector headers_snapshot_sequence; std::vector bodies_snapshot_sequence; std::vector transactions_snapshot_sequence; for (const auto& bundle_ptr : repository.view_bundles()) { db::blocks::BundleDataRef bundle{**bundle_ptr}; { { SilkwormHeadersSnapshot raw_headers_snapshot{ .segment{ .file_path = make_path(bundle.header_segment().path()), .memory_address = bundle.header_segment().memory_file_region().data(), .memory_length = bundle.header_segment().memory_file_region().size(), }, .header_hash_index{ .file_path = make_path(bundle.idx_header_hash().path()), .memory_address = bundle.idx_header_hash().memory_file_region().data(), .memory_length = bundle.idx_header_hash().memory_file_region().size(), }, }; headers_snapshot_sequence.push_back(raw_headers_snapshot); } { SilkwormBodiesSnapshot raw_bodies_snapshot{ .segment{ .file_path = make_path(bundle.body_segment().path()), .memory_address = bundle.body_segment().memory_file_region().data(), .memory_length = bundle.body_segment().memory_file_region().size(), }, .block_num_index{ .file_path = make_path(bundle.idx_body_number().path()), .memory_address = bundle.idx_body_number().memory_file_region().data(), .memory_length = bundle.idx_body_number().memory_file_region().size(), }, }; bodies_snapshot_sequence.push_back(raw_bodies_snapshot); } { SilkwormTransactionsSnapshot raw_transactions_snapshot{ .segment{ .file_path = make_path(bundle.txn_segment().path()), .memory_address = bundle.txn_segment().memory_file_region().data(), .memory_length = bundle.txn_segment().memory_file_region().size(), }, .tx_hash_index{ .file_path = make_path(bundle.idx_txn_hash().path()), .memory_address = bundle.idx_txn_hash().memory_file_region().data(), .memory_length = bundle.idx_txn_hash().memory_file_region().size(), }, .tx_hash_2_block_index{ .file_path = make_path(bundle.idx_txn_hash_2_block().path()), .memory_address = bundle.idx_txn_hash_2_block().memory_file_region().data(), .memory_length = bundle.idx_txn_hash_2_block().memory_file_region().size(), }, }; transactions_snapshot_sequence.push_back(raw_transactions_snapshot); } } } ensure(headers_snapshot_sequence.size() == repository.bundles_count(), "invalid header snapshot count"); ensure(bodies_snapshot_sequence.size() == repository.bundles_count(), "invalid body snapshot count"); ensure(transactions_snapshot_sequence.size() == repository.bundles_count(), "invalid tx snapshot count"); std::vector snapshot_sequence; snapshot_sequence.reserve(headers_snapshot_sequence.size()); for (size_t i{0}; i < headers_snapshot_sequence.size(); ++i) { SilkwormBlocksSnapshotBundle bundle{ headers_snapshot_sequence[i], bodies_snapshot_sequence[i], transactions_snapshot_sequence[i], }; snapshot_sequence.push_back(bundle); } return snapshot_sequence; } int execute_with_internal_txn(SilkwormHandle handle, ExecuteBlocksSettings settings, datastore::kvdb::RWAccess chaindata) { datastore::kvdb::ROTxnManaged ro_txn = chaindata.start_ro_tx(); const auto chain_config{db::read_chain_config(ro_txn)}; ensure(chain_config.has_value(), "no chain configuration in database"); const auto chain_id{chain_config->chain_id}; ro_txn.abort(); BlockNum last_executed_block{0}; int mdbx_error_code{0}; const uint64_t count{settings.max_block - settings.start_block + 1}; SILK_DEBUG << "Execute blocks start_block=" << settings.start_block << " end_block=" << settings.max_block << " count=" << count << " batch_size=" << settings.batch_size << " start"; const int status_code = silkworm_execute_blocks_perpetual( handle, *chaindata, chain_id, settings.start_block, settings.max_block, settings.batch_size, settings.write_change_sets, settings.write_receipts, settings.write_call_traces, &last_executed_block, &mdbx_error_code); SILK_DEBUG << "Execute blocks start_block=" << settings.start_block << " end_block=" << settings.max_block << " count=" << count << " batch_size=" << settings.batch_size << " done"; if (status_code != SILKWORM_OK) { SILK_ERROR << "execute_with_internal_txn failed [code=" << std::to_string(status_code) << (status_code == SILKWORM_MDBX_ERROR ? " mdbx_error_code=" + std::to_string(mdbx_error_code) : "") << "]"; return status_code; } SILK_INFO << "Last executed block: " << last_executed_block; return status_code; } int execute_with_external_txn(SilkwormHandle handle, ExecuteBlocksSettings settings, datastore::kvdb::RWTxnManaged rw_txn) { const auto chain_config{db::read_chain_config(rw_txn)}; ensure(chain_config.has_value(), "no chain configuration in database"); const auto chain_id{chain_config->chain_id}; auto start_block{settings.start_block}; const auto max_block{settings.max_block}; while (start_block <= max_block) { BlockNum last_executed_block{0}; int mdbx_error_code{0}; const int status_code = silkworm_execute_blocks_ephemeral( handle, *rw_txn, chain_id, settings.start_block, settings.max_block, settings.batch_size, settings.write_change_sets, settings.write_receipts, settings.write_call_traces, &last_executed_block, &mdbx_error_code); if (status_code != SILKWORM_OK) { SILK_ERROR << "execute_with_external_txn failed [code=" << std::to_string(status_code) << (status_code == SILKWORM_MDBX_ERROR ? " mdbx_error_code=" + std::to_string(mdbx_error_code) : "") << "] last executed block: " << last_executed_block; return status_code; } start_block = last_executed_block + 1; } SILK_INFO << "Last executed block: " << max_block; return SILKWORM_OK; } int execute_blocks(SilkwormHandle handle, ExecuteBlocksSettings settings, const DataDirectory& data_dir) { // Open chain database silkworm::datastore::kvdb::EnvConfig config{ .path = data_dir.chaindata().path().string(), .readonly = false, .exclusive = true}; db::DataStore data_store{ config, data_dir.snapshots().path(), }; // Collect all snapshots auto snapshot_bundles = collect_all_snapshot_bundles(data_store.ref().blocks_repository); [[maybe_unused]] auto _ = gsl::finally([&]() { for (auto& bundle : snapshot_bundles) { delete[] bundle.headers.segment.file_path; delete[] bundle.headers.header_hash_index.file_path; delete[] bundle.bodies.segment.file_path; delete[] bundle.bodies.block_num_index.file_path; delete[] bundle.transactions.segment.file_path; delete[] bundle.transactions.tx_hash_index.file_path; delete[] bundle.transactions.tx_hash_2_block_index.file_path; } }); for (auto& bundle : snapshot_bundles) { const int add_snapshot_status_code{silkworm_add_blocks_snapshot_bundle(handle, &bundle)}; if (add_snapshot_status_code != SILKWORM_OK) { SILK_ERROR << "silkworm_add_blocks_snapshot_bundle failed [code=" << std::to_string(add_snapshot_status_code) << "]"; return add_snapshot_status_code; } } // Execute blocks if (settings.use_internal_txn) { return execute_with_internal_txn(handle, settings, data_store.chaindata().access_rw()); } return execute_with_external_txn(handle, settings, data_store.chaindata().access_rw().start_rw_tx()); } int build_indexes(SilkwormHandle handle, const BuildIndexesSettings& settings, const DataDirectory& data_dir) { SILK_INFO << "Building indexes for segments: " << settings.segment_file_names; std::vector segments; std::vector segment_mmap_files; // Parse snapshot paths and create memory mapped files for (auto& file_name : settings.segment_file_names) { auto raw_snapshot_path = data_dir.snapshots().path() / file_name; auto snapshot_path = SnapshotPath::parse(raw_snapshot_path); if (!snapshot_path.has_value()) throw std::runtime_error("Invalid snapshot path"); segment::SegmentFileReader& segment = segments.emplace_back(*snapshot_path, db::blocks::kStepToBlockNumConverter); auto mmf = new SilkwormMemoryMappedFile{ .file_path = make_path(*snapshot_path), .memory_address = segment.memory_file_region().data(), .memory_length = segment.memory_file_region().size(), }; segment_mmap_files.push_back(mmf); } // Call api to build indexes const auto start_time{std::chrono::high_resolution_clock::now()}; const int status_code = silkworm_build_recsplit_indexes(handle, segment_mmap_files.data(), segment_mmap_files.size()); if (status_code != SILKWORM_OK) return status_code; auto elapsed = std::chrono::high_resolution_clock::now() - start_time; SILK_INFO << "Building indexes for snapshots done in " << std::chrono::duration_cast(elapsed).count() << "ms"; // Free memory mapped files for (auto mmap_file : segment_mmap_files) { delete[] mmap_file->file_path; delete mmap_file; } return SILKWORM_OK; } int start_rpcdaemon(SilkwormHandle handle, const rpc::DaemonSettings& /*settings*/, const DataDirectory& data_dir) { // Start execution context dedicated to handling termination signals boost::asio::io_context shutdown_signal_ioc; cmd::common::ShutdownSignal shutdown_signal{shutdown_signal_ioc.get_executor()}; SILK_DEBUG << "Signals registered on signal_context " << &shutdown_signal_ioc; shutdown_signal.on_signal([&](cmd::common::ShutdownSignal::SignalNumber signal_number) { SILK_INFO << "Signal number: " << signal_number << " caught"; const int status_code{silkworm_stop_rpcdaemon(handle)}; if (status_code != SILKWORM_OK) { SILK_ERROR << "silkworm_stop_rpcdaemon failed [code=" << std::to_string(status_code) << "]"; } }); // Open chain database silkworm::datastore::kvdb::EnvConfig config{ .path = data_dir.chaindata().path().string(), .readonly = false, .exclusive = true}; ::mdbx::env_managed env{silkworm::datastore::kvdb::open_env(config)}; SilkwormRpcSettings settings{}; const int status_code{silkworm_start_rpcdaemon(handle, &*env, &settings)}; if (status_code != SILKWORM_OK) { SILK_ERROR << "silkworm_start_rpcdaemon failed [code=" << std::to_string(status_code) << "]"; } shutdown_signal_ioc.run(); return SILKWORM_OK; } int main(int argc, char* argv[]) { CLI::App app{"Execute"}; try { log::Settings log_settings; Settings settings; parse_command_line(argc, argv, app, settings); log::init(settings.log_settings); const auto pid = boost::this_process::get_id(); SILK_INFO << "Execute starting [pid=" << std::to_string(pid) << "]"; DataDirectory data_dir{ settings.data_folder.empty() ? DataDirectory::get_default_storage_path() : std::filesystem::path(settings.data_folder)}; // Initialize Silkworm API library SilkwormHandle handle{nullptr}; SilkwormSettings silkworm_settings{}; std::string data_dir_path = data_dir.path().string(); if (data_dir_path.size() >= SILKWORM_PATH_SIZE) { SILK_ERROR << "datadir path too long [data_dir_path=" << data_dir_path << "]"; return -1; } strncpy(silkworm_settings.data_dir_path, data_dir_path.c_str(), SILKWORM_PATH_SIZE - 1); SILK_INFO << "libmdbx version: " << silkworm_libmdbx_version(); strncpy(silkworm_settings.libmdbx_version, ::mdbx::get_version().git.describe, sizeof(silkworm_settings.libmdbx_version) - 1); const int init_status_code = silkworm_init(&handle, &silkworm_settings); if (init_status_code != SILKWORM_OK) { SILK_ERROR << "silkworm_init failed [code=" << std::to_string(init_status_code) << "]"; return init_status_code; } int status_code = -1; if (settings.execute_blocks_settings) { // Execute specified block range using Silkworm API library status_code = execute_blocks(handle, *settings.execute_blocks_settings, data_dir); } else if (settings.build_indexes_settings) { // Build index for a specific snapshot using Silkworm API library status_code = build_indexes(handle, *settings.build_indexes_settings, data_dir); } else if (settings.rpcdaemon_settings) { // Start RPC Daemon using Silkworm API library status_code = start_rpcdaemon(handle, *settings.rpcdaemon_settings, data_dir); } // Finalize Silkworm API library const int fini_status_code = silkworm_fini(handle); if (fini_status_code != SILKWORM_OK) { SILK_ERROR << "silkworm_fini failed [code=" << std::to_string(fini_status_code) << "]"; return fini_status_code; } SILK_INFO << "Exiting [pid=" << std::to_string(pid) << "]"; return status_code; } catch (const CLI::ParseError& pe) { return app.exit(pe); } catch (const std::exception& e) { SILK_CRIT << "Exiting due to exception: " << e.what(); return -2; } catch (...) { SILK_CRIT << "Exiting due to unexpected exception"; return -3; } } ================================================ FILE: silkworm/capi/cli/main.c ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include int main(int argc, char* argv[]) { (void)argc, (void)argv; #if defined(_MSC_VER) printf("MSVC version: %d\n", _MSC_FULL_VER); #elif defined(__GNUC__) && !defined(__clang__) printf("gcc version: %d.%d.%d\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__); #else printf("AppleClang version: %d.%d.%d\n", __clang_major__, __clang_minor__, __clang_patchlevel__); #endif printf("C API silkworm_libmdbx_version: %s\n", silkworm_libmdbx_version()); return 0; } ================================================ FILE: silkworm/capi/cli/sample-go-client/README.md ================================================ # A sample go application that loads Silkworm API library ## Prerequisites - C compiler toolchain (required to compile cgo code) ## Build & Run 1. build the silkworm_capi library 2. go to the sample-go-client directory and run: ```bash go run main.go ``` on macOS: ```bash CGO_LDFLAGS=-mmacosx-version-min=15.0 go run main.go ``` ================================================ FILE: silkworm/capi/cli/sample-go-client/main.go ================================================ package main // #cgo LDFLAGS: -lsilkworm_capi // #cgo LDFLAGS: -L${SRCDIR}/../../../../build/silkworm/capi // #cgo LDFLAGS: -Wl,-rpath ${SRCDIR}/../../../../build/silkworm/capi // #cgo CFLAGS: -I${SRCDIR}/../../../../build/silkworm/capi/include /* #include "silkworm.h" #include #include static bool go_string_copy(_GoString_ s, char *dest, size_t size) { size_t len = _GoStringLen(s); if (len >= size) return false; const char *src = _GoStringPtr(s); strncpy(dest, src, len); dest[len] = '\0'; return true; } */ import "C" import "fmt" import "os" func main() { dataDirPath := os.Getenv("HOME") libMdbxVersion := C.GoString(C.silkworm_libmdbx_version()) var handle C.SilkwormHandle settings := &C.struct_SilkwormSettings{} if !C.go_string_copy(dataDirPath, &settings.data_dir_path[0], C.SILKWORM_PATH_SIZE) { fmt.Fprintln(os.Stderr, "silkworm.New failed to copy dataDirPath") os.Exit(1) } if !C.go_string_copy(libMdbxVersion, &settings.libmdbx_version[0], C.SILKWORM_GIT_VERSION_SIZE) { fmt.Fprintln(os.Stderr, "silkworm.New failed to copy libMdbxVersion") os.Exit(2) } initResult := C.silkworm_init(&handle, settings) if initResult != C.SILKWORM_OK { fmt.Fprintln(os.Stderr, "silkworm_init failed:", initResult) os.Exit(int(initResult)) } finiResult := C.silkworm_fini(handle) if finiResult != C.SILKWORM_OK { fmt.Fprintln(os.Stderr, "silkworm_fini failed:", finiResult) os.Exit(int(finiResult)) } os.Exit(0) } ================================================ FILE: silkworm/capi/common/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") silkworm_library(silkworm_capi_common) ================================================ FILE: silkworm/capi/common/common_component.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::capi { struct CommonComponent { silkworm::log::Settings log_settings; silkworm::concurrency::ContextPoolSettings context_pool_settings; std::filesystem::path data_dir_path; }; } // namespace silkworm::capi ================================================ FILE: silkworm/capi/common/errors.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_CAPI_ERRORS_H_ #define SILKWORM_CAPI_ERRORS_H_ // Silkworm library error codes (SILKWORM_OK indicates no error, i.e. success) #define SILKWORM_OK 0 #define SILKWORM_INTERNAL_ERROR 1 #define SILKWORM_UNKNOWN_ERROR 2 #define SILKWORM_INVALID_HANDLE 3 #define SILKWORM_INVALID_PATH 4 #define SILKWORM_INVALID_SNAPSHOT 5 #define SILKWORM_INVALID_MDBX_ENV 6 #define SILKWORM_INVALID_BLOCK_RANGE 7 #define SILKWORM_BLOCK_NOT_FOUND 8 #define SILKWORM_UNKNOWN_CHAIN_ID 9 #define SILKWORM_MDBX_ERROR 10 #define SILKWORM_INVALID_BLOCK 11 #define SILKWORM_DECODING_ERROR 12 #define SILKWORM_TOO_MANY_INSTANCES 13 #define SILKWORM_INVALID_SETTINGS 14 #define SILKWORM_TERMINATION_SIGNAL 15 #define SILKWORM_SERVICE_ALREADY_STARTED 16 #define SILKWORM_INCOMPATIBLE_LIBMDBX 17 #define SILKWORM_INVALID_MDBX_TXN 18 #endif // SILKWORM_CAPI_ERRORS_H_ ================================================ FILE: silkworm/capi/common/instance.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "common_component.hpp" namespace silkworm::db::capi { struct Component; } namespace silkworm::rpc { class Daemon; } namespace silkworm::sentry::capi { struct Component; } namespace capi_todo { struct SilkwormInstance { silkworm::capi::CommonComponent common; std::unique_ptr db; std::unique_ptr rpcdaemon; std::unique_ptr sentry; SilkwormInstance(); ~SilkwormInstance(); }; } // namespace capi_todo ================================================ FILE: silkworm/capi/common/parse_path.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "parse_path.hpp" #include namespace silkworm::capi { std::filesystem::path parse_path(const char data_dir_path[SILKWORM_PATH_SIZE]) { // Treat as char8_t so that filesystem::path assumes UTF-8 encoding of the input path auto begin = reinterpret_cast(data_dir_path); size_t len = strnlen(data_dir_path, SILKWORM_PATH_SIZE); return std::filesystem::path{begin, begin + len}; } } // namespace silkworm::capi ================================================ FILE: silkworm/capi/common/parse_path.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "preamble.h" namespace silkworm::capi { //! Build a file system path from its C null-terminated upper-bounded representation std::filesystem::path parse_path(const char path[SILKWORM_PATH_SIZE]); } // namespace silkworm::capi ================================================ FILE: silkworm/capi/common/preamble.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_CAPI_PREAMBLE_H_ #define SILKWORM_CAPI_PREAMBLE_H_ #include // NOLINT(*-deprecated-headers) #include // NOLINT(*-deprecated-headers) #include // NOLINT(*-deprecated-headers) #if defined _MSC_VER #define SILKWORM_EXPORT __declspec(dllexport) #else #define SILKWORM_EXPORT __attribute__((visibility("default"))) #endif #if __cplusplus #define SILKWORM_NOEXCEPT noexcept #else #define SILKWORM_NOEXCEPT #endif #if __cplusplus extern "C" { #endif struct SilkwormInstance; typedef struct SilkwormInstance* SilkwormHandle; #if __cplusplus } #endif #include "errors.h" #define SILKWORM_PATH_SIZE 260 #endif // SILKWORM_CAPI_PREAMBLE_H_ ================================================ FILE: silkworm/capi/init.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "init.h" #include #include #include #include #include #include "common/instance.hpp" #include "common/parse_path.hpp" #include "instance.hpp" #include "make_log_settings.hpp" using namespace silkworm; using namespace silkworm::capi; static bool is_initialized{false}; //! Generate log arguments for Silkworm library version static log::Args log_args_for_version() { const auto build_info{silkworm_get_buildinfo()}; return { "git_branch", std::string(build_info->git_branch), "git_tag", std::string(build_info->project_version), "git_commit", std::string(build_info->git_commit_hash)}; } SILKWORM_EXPORT int silkworm_init(SilkwormHandle* handle, const struct SilkwormSettings* settings) SILKWORM_NOEXCEPT { using namespace datastore::kvdb; if (!handle) { return SILKWORM_INVALID_HANDLE; } if (!settings) { return SILKWORM_INVALID_SETTINGS; } if (std::strlen(settings->data_dir_path) == 0) { return SILKWORM_INVALID_PATH; } if (!is_compatible_mdbx_version(settings->libmdbx_version, silkworm_libmdbx_version(), MdbxVersionCheck::kExact)) { return SILKWORM_INCOMPATIBLE_LIBMDBX; } if (is_initialized) { return SILKWORM_TOO_MANY_INSTANCES; } is_initialized = true; log::Settings log_settings{make_log_settings(settings->log_verbosity)}; log::init(log_settings); auto data_dir_path = parse_path(settings->data_dir_path); silkworm::capi::CommonComponent common{ .log_settings = std::move(log_settings), .context_pool_settings = { .num_contexts = settings->num_contexts > 0 ? settings->num_contexts : silkworm::concurrency::kDefaultNumContexts, }, .data_dir_path = data_dir_path, }; auto snapshots_dir_path = DataDirectory{data_dir_path}.snapshots().path(); auto blocks_repository = db::blocks::make_blocks_repository( snapshots_dir_path, /* open = */ false, settings->blocks_repo_index_salt); auto state_repository_latest = db::state::make_state_repository_latest( snapshots_dir_path, /* open = */ false, settings->state_repo_index_salt); auto state_repository_historical = db::state::make_state_repository_historical( snapshots_dir_path, /* open = */ false, settings->state_repo_index_salt); db::capi::Component db{ .blocks_repository = std::move(blocks_repository), .state_repository_latest = std::move(state_repository_latest), .state_repository_historical = std::move(state_repository_historical), .chaindata = {}, .query_caches = snapshots::QueryCaches{db::state::make_query_caches_schema(), snapshots_dir_path, settings->state_repo_index_salt}, }; // NOLINTNEXTLINE(bugprone-unhandled-exception-at-new) *handle = new ::SilkwormInstance{}; (*handle)->common = std::move(common); (*handle)->db = std::make_unique(std::move(db)); log::Info{"Silkworm build info", log_args_for_version()}; // NOLINT(*-unused-raii) log::Debug{"[1/12] Silkworm initialized", // NOLINT(*-unused-raii) {"data_dir", data_dir_path.string(), "snapshots_dir", snapshots_dir_path.string(), "blocks_repo_index_salt", std::to_string(settings->blocks_repo_index_salt), "state_repo_index_salt", std::to_string(settings->state_repo_index_salt)}}; return SILKWORM_OK; } SILKWORM_EXPORT int silkworm_fini(SilkwormHandle handle) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } delete handle; is_initialized = false; return SILKWORM_OK; } ================================================ FILE: silkworm/capi/init.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_CAPI_INIT_H_ #define SILKWORM_CAPI_INIT_H_ #ifdef SILKWORM_CAPI_COMPONENT #include "common/preamble.h" #else #include "preamble.h" #endif #include "log_level.h" #if __cplusplus extern "C" { #endif #define SILKWORM_GIT_VERSION_SIZE 32 //! Silkworm library general configuration options struct SilkwormSettings { //! Log verbosity level SilkwormLogLevel log_verbosity; //! Number of I/O contexts to use in concurrency mode uint32_t num_contexts; //! Data directory path in UTF-8. char data_dir_path[SILKWORM_PATH_SIZE]; //! libmdbx version string in git describe format. char libmdbx_version[SILKWORM_GIT_VERSION_SIZE]; //! Index salt for block snapshots uint32_t blocks_repo_index_salt; //! Index salt for state snapshots uint32_t state_repo_index_salt; }; /** * \brief Initialize the Silkworm C API library. * \param[in,out] handle Silkworm instance handle returned on successful initialization. * \param[in] settings General Silkworm settings. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_init(SilkwormHandle* handle, const struct SilkwormSettings* settings) SILKWORM_NOEXCEPT; /** * \brief Finalize the Silkworm C API library. * \param[in] handle A valid Silkworm instance handle got with silkworm_init. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_fini(SilkwormHandle handle) SILKWORM_NOEXCEPT; #if __cplusplus } #endif #endif // SILKWORM_CAPI_INIT_H_ ================================================ FILE: silkworm/capi/instance.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "common/instance.hpp" #include #include #include namespace capi_todo { SilkwormInstance::SilkwormInstance() { static_assert(true); } SilkwormInstance::~SilkwormInstance() { static_assert(true); } } // namespace capi_todo ================================================ FILE: silkworm/capi/instance.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "common/instance.hpp" struct SilkwormInstance : public capi_todo::SilkwormInstance { std::optional chain_config; // TODO: This has to be changed and encapsulated by a proper block caching state struct ExecutionResult { silkworm::TxnId txn_id = 0; uint64_t blob_gas_used = 0; silkworm::Receipt receipt; uint64_t log_index = 0; }; // Keeps all the transactions and receipts created in the current block std::vector executions_in_block; }; ================================================ FILE: silkworm/capi/log_level.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_CAPI_LOG_LEVEL_H_ #define SILKWORM_CAPI_LOG_LEVEL_H_ #if __cplusplus extern "C" { #endif //! Silkworm library logging level //! \note using anonymous C99 enum is the most portable way to pass enum in Cgo typedef enum { // NOLINT(performance-enum-size) SILKWORM_LOG_NONE, SILKWORM_LOG_CRITICAL, SILKWORM_LOG_ERROR, SILKWORM_LOG_WARNING, SILKWORM_LOG_INFO, SILKWORM_LOG_DEBUG, SILKWORM_LOG_TRACE } SilkwormLogLevel; #if __cplusplus } #endif #endif // SILKWORM_CAPI_LOG_LEVEL_H_ ================================================ FILE: silkworm/capi/make_log_settings.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "make_log_settings.hpp" #include //! Build Silkworm log level from its C representation static silkworm::log::Level make_log_level(const SilkwormLogLevel c_log_level) { silkworm::log::Level verbosity{}; switch (c_log_level) { case SilkwormLogLevel::SILKWORM_LOG_NONE: verbosity = silkworm::log::Level::kNone; break; case SilkwormLogLevel::SILKWORM_LOG_CRITICAL: verbosity = silkworm::log::Level::kCritical; break; case SilkwormLogLevel::SILKWORM_LOG_ERROR: verbosity = silkworm::log::Level::kError; break; case SilkwormLogLevel::SILKWORM_LOG_WARNING: verbosity = silkworm::log::Level::kWarning; break; case SilkwormLogLevel::SILKWORM_LOG_INFO: verbosity = silkworm::log::Level::kInfo; break; case SilkwormLogLevel::SILKWORM_LOG_DEBUG: verbosity = silkworm::log::Level::kDebug; break; case SilkwormLogLevel::SILKWORM_LOG_TRACE: verbosity = silkworm::log::Level::kTrace; break; } return verbosity; } silkworm::log::Settings make_log_settings(const SilkwormLogLevel c_log_level) { return { .log_utc = false, // display local time .log_timezone = false, // no timezone ID .log_trim = true, // compact rendering (i.e. no whitespaces) .log_verbosity = make_log_level(c_log_level), }; } ================================================ FILE: silkworm/capi/make_log_settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "log_level.h" //! Build log configuration matching Erigon log format w/ custom verbosity level silkworm::log::Settings make_log_settings(SilkwormLogLevel c_log_level); ================================================ FILE: silkworm/capi/silkworm.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "silkworm.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "common/parse_path.hpp" #include "instance.hpp" using namespace std::chrono_literals; using namespace silkworm; using namespace silkworm::capi; static constexpr size_t kMaxBlockBufferSize{100}; static constexpr size_t kMaxPrefetchedBlocks{10'240}; using SteadyTimePoint = std::chrono::time_point; //! The progress reached by the block execution process struct ExecutionProgress { SteadyTimePoint start_time; SteadyTimePoint next_log_time; SteadyTimePoint end_time; size_t processed_blocks{0}; size_t processed_transactions{0}; size_t processed_gas{0}; float batch_progress_perc{0.0}; }; //! Generate log arguments for execution flush at specified block static log::Args log_args_for_exec_flush(const db::Buffer& state_buffer, uint64_t max_batch_size, uint64_t current_block) { return { "batch", std::to_string(state_buffer.current_batch_state_size()), "max_batch", std::to_string(max_batch_size), "block", std::to_string(current_block)}; } //! Generate log arguments for execution commit at specified block static log::Args log_args_for_exec_commit(StopWatch::Duration elapsed, const std::filesystem::path& env_path) { return { "in", StopWatch::format(elapsed), "chaindata", std::to_string(Directory{env_path}.size())}; } //! Generate log arguments for execution progress at specified block static log::Args log_args_for_exec_progress(ExecutionProgress& progress, uint64_t current_block) { static auto float_to_string = [](float f) -> std::string { const auto size = std::snprintf(nullptr, 0, "%.1f", static_cast(f)); std::string s(static_cast(size + 1), '\0'); // +1 for null terminator std::ignore = std::snprintf(s.data(), s.size(), "%.1f", static_cast(f)); // certain to fit return s.substr(0, s.size() - 1); // remove null terminator }; const auto elapsed{progress.end_time - progress.start_time}; progress.start_time = progress.end_time; const auto duration_seconds{std::chrono::duration_cast(elapsed)}; const auto elapsed_seconds = duration_seconds.count() != 0 ? static_cast(duration_seconds.count()) : 1.0f; if (progress.processed_blocks == 0) { return {"number", std::to_string(current_block), "db", "waiting..."}; } const auto speed_blocks = static_cast(progress.processed_blocks) / elapsed_seconds; const auto speed_transactions = static_cast(progress.processed_transactions) / elapsed_seconds; const auto speed_mgas = static_cast(progress.processed_gas) / elapsed_seconds / 1'000'000; progress.processed_blocks = 0; progress.processed_transactions = 0; progress.processed_gas = 0; std::stringstream batch_progress_perc; batch_progress_perc << std::fixed << std::setprecision(2) << progress.batch_progress_perc * 100 << "%"; return { "number", std::to_string(current_block), "blk/s", float_to_string(speed_blocks), "tx/s", float_to_string(speed_transactions), "Mgas/s", float_to_string(speed_mgas), "batchProgress", batch_progress_perc.str()}; } static void update_execution_progress(ExecutionProgress& progress, const Block& block, const db::Buffer& state_buffer, size_t max_batch_size) { ++progress.processed_blocks; progress.processed_transactions += block.transactions.size(); progress.processed_gas += block.header.gas_used; const auto now{std::chrono::steady_clock::now()}; if (progress.next_log_time <= now) { progress.batch_progress_perc = static_cast(state_buffer.current_batch_state_size()) / static_cast(max_batch_size); progress.end_time = now; log::Info{"[4/12 Execution] Executed blocks", // NOLINT(*-unused-raii) log_args_for_exec_progress(progress, block.header.number)}; progress.next_log_time = now + 20s; } } //! A signal handler guard using RAII pattern to acquire/release signal handling class SignalHandlerGuard { public: SignalHandlerGuard() { SignalHandler::init(/*custom_handler=*/{}, /*silent=*/true); } ~SignalHandlerGuard() { SignalHandler::reset(); } }; class BlockProvider { static constexpr size_t kTxnRefreshThreshold{100}; public: BlockProvider(BoundedBuffer>* block_buffer, datastore::kvdb::ROAccess db_access, db::DataModelFactory data_model_factory, BlockNum start_block, BlockNum max_block) : block_buffer_{block_buffer}, db_access_{std::move(db_access)}, data_model_factory_{std::move(data_model_factory)}, start_block_{start_block}, max_block_{max_block} {} void operator()() { auto txn = db_access_.start_ro_tx(); db::DataModel access_layer = data_model_factory_(txn); BlockNum current_block{start_block_}; size_t refresh_counter{kTxnRefreshThreshold}; try { Block block; while (current_block <= max_block_ && !block_buffer_->is_stopped()) { const bool success{access_layer.read_block(current_block, /*read_senders=*/true, block)}; if (!success) { block_buffer_->push_front(std::nullopt); return; } block_buffer_->push_front(std::move(block)); ++current_block; if (--refresh_counter == 0) { txn.abort(); txn = db_access_.start_ro_tx(); refresh_counter = kTxnRefreshThreshold; } } } catch (const boost::thread_interrupted&) { SILK_TRACE << "thread_interrupted in block provider thread"; } catch (const std::exception& ex) { SILK_WARN << "unexpected exception in block provider thread: what=" << ex.what(); } catch (...) { SILK_ERROR << "unknown exception in block provider thread"; } } private: BoundedBuffer>* block_buffer_; datastore::kvdb::ROAccess db_access_; db::DataModelFactory data_model_factory_; BlockNum start_block_; BlockNum max_block_; }; inline bool signal_check(SteadyTimePoint& signal_check_time) { const auto now{std::chrono::steady_clock::now()}; if (signal_check_time <= now) { if (SignalHandler::signalled()) { return true; } signal_check_time += 5s; } return false; } SILKWORM_EXPORT int silkworm_execute_blocks_ephemeral(SilkwormHandle handle, MDBX_txn* mdbx_txn, uint64_t chain_id, uint64_t start_block, uint64_t max_block, uint64_t batch_size, bool write_change_sets, bool write_receipts, bool write_call_traces, uint64_t* last_executed_block, int* mdbx_error_code) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } if (!mdbx_txn) { return SILKWORM_INVALID_MDBX_TXN; } if (start_block > max_block) { return SILKWORM_INVALID_BLOCK_RANGE; } const auto chain_info = kKnownChainConfigs.find(chain_id); if (!chain_info) { return SILKWORM_UNKNOWN_CHAIN_ID; } SignalHandlerGuard signal_guard; try { auto txn = datastore::kvdb::RWTxnUnmanaged{mdbx_txn}; db::DataModel da_layer{txn, handle->db->blocks_repository}; db::Buffer state_buffer{txn, std::make_unique(da_layer)}; state_buffer.set_memory_limit(batch_size); const size_t max_batch_size{batch_size}; auto signal_check_time{std::chrono::steady_clock::now()}; BlockNum block_num{start_block}; BlockNum batch_start_block_num{start_block}; BlockNum last_block_num = 0; AnalysisCache analysis_cache{execution::block::BlockExecutor::kDefaultAnalysisCacheSize}; execution::block::BlockExecutor block_executor{*chain_info, write_receipts, write_call_traces, write_change_sets}; const auto now = std::chrono::steady_clock::now(); ExecutionProgress execution_progress{.start_time = now, .next_log_time = now + 20s}; ValidationResult last_exec_result = ValidationResult::kOk; boost::circular_buffer prefetched_blocks{/*buffer_capacity=*/kMaxPrefetchedBlocks}; while (block_num <= max_block) { while (block_num <= max_block) { if (prefetched_blocks.empty()) { const auto num_blocks{std::min(size_t{max_block - block_num + 1}, kMaxPrefetchedBlocks)}; SILK_TRACE << "Prefetching " << num_blocks << " blocks start"; for (BlockNum n{block_num}; n < block_num + num_blocks; ++n) { prefetched_blocks.push_back(); const bool success{da_layer.read_block(n, /*read_senders=*/true, prefetched_blocks.back())}; if (!success) { return SILKWORM_BLOCK_NOT_FOUND; } } SILK_TRACE << "Prefetching " << num_blocks << " blocks done"; } const Block& block{prefetched_blocks.front()}; try { last_exec_result = block_executor.execute_single(block, state_buffer, analysis_cache); update_execution_progress(execution_progress, block, state_buffer, max_batch_size); } catch (const db::Buffer::MemoryLimitError&) { // infinite loop detection, buffer memory limit reached but no progress if (batch_start_block_num == block_num) { SILK_ERROR << "Buffer memory limit too small to execute a single block (block_num=" << block_num << ")"; return SILKWORM_INTERNAL_ERROR; } // batch done batch_start_block_num = block_num; break; } if (last_exec_result != ValidationResult::kOk) { // firstly, persist the work done so far, then return SILKWORM_INVALID_BLOCK break; } if (signal_check(signal_check_time)) { return SILKWORM_TERMINATION_SIGNAL; } last_block_num = block_num; ++block_num; prefetched_blocks.pop_front(); } log::Info{"[4/12 Execution] Flushing state", // NOLINT(*-unused-raii) log_args_for_exec_flush(state_buffer, max_batch_size, last_block_num)}; state_buffer.write_state_to_db(); // Always save the Execution stage progress when state batch is flushed db::stages::write_stage_progress(txn, db::stages::kExecutionKey, last_block_num); if (last_executed_block) { *last_executed_block = last_block_num; } if (last_exec_result != ValidationResult::kOk) { return SILKWORM_INVALID_BLOCK; } } return SILKWORM_OK; } catch (const mdbx::exception& e) { if (mdbx_error_code) { *mdbx_error_code = e.error().code(); } return SILKWORM_MDBX_ERROR; } catch (const DecodingError&) { return SILKWORM_DECODING_ERROR; } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what(); return SILKWORM_INTERNAL_ERROR; } catch (...) { SILK_ERROR << "unknown exception"; return SILKWORM_UNKNOWN_ERROR; } } SILKWORM_EXPORT int silkworm_execute_blocks_perpetual(SilkwormHandle handle, MDBX_env* mdbx_env, uint64_t chain_id, uint64_t start_block, uint64_t max_block, uint64_t batch_size, bool write_change_sets, bool write_receipts, bool write_call_traces, uint64_t* last_executed_block, int* mdbx_error_code) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } if (!mdbx_env) { return SILKWORM_INVALID_MDBX_ENV; } if (start_block > max_block) { return SILKWORM_INVALID_BLOCK_RANGE; } const auto chain_info = kKnownChainConfigs.find(chain_id); if (!chain_info) { return SILKWORM_UNKNOWN_CHAIN_ID; } SignalHandlerGuard signal_guard; try { // Wrap MDBX env into an internal *unmanaged* env, i.e. MDBX env is only used but its lifecycle is untouched if (!handle->db->chaindata) { handle->db->chaindata = std::make_unique( db::DataStore::make_chaindata_database(datastore::kvdb::EnvUnmanaged{mdbx_env})); } auto& chaindata = *handle->db->chaindata; db::DataModelFactory data_model_factory = handle->db->data_model_factory(); datastore::kvdb::RWAccess rw_access = chaindata.access_rw(); auto txn = rw_access.start_rw_tx(); db::Buffer state_buffer{txn, std::make_unique(data_model_factory(txn))}; state_buffer.set_memory_limit(batch_size); BoundedBuffer> block_buffer{kMaxBlockBufferSize}; [[maybe_unused]] auto _ = gsl::finally([&block_buffer] { block_buffer.terminate_and_release_all(); }); BlockProvider block_provider{ &block_buffer, chaindata.access_ro(), std::move(data_model_factory), start_block, max_block, }; boost::strict_scoped_thread block_provider_thread(block_provider); const size_t max_batch_size{batch_size}; auto signal_check_time{std::chrono::steady_clock::now()}; std::optional block; BlockNum block_num{start_block}; BlockNum batch_start_block_num{start_block}; BlockNum last_block_num = 0; AnalysisCache analysis_cache{execution::block::BlockExecutor::kDefaultAnalysisCacheSize}; execution::block::BlockExecutor block_executor{*chain_info, write_receipts, write_call_traces, write_change_sets}; const auto now = std::chrono::steady_clock::now(); ExecutionProgress execution_progress{.start_time = now, .next_log_time = now + 20s}; ValidationResult last_exec_result = ValidationResult::kOk; while (block_num <= max_block) { while (block_num <= max_block) { block_buffer.peek_back(&block); if (!block) { return SILKWORM_BLOCK_NOT_FOUND; } SILKWORM_ASSERT(block->header.number == block_num); try { last_exec_result = block_executor.execute_single(*block, state_buffer, analysis_cache); update_execution_progress(execution_progress, *block, state_buffer, max_batch_size); } catch (const db::Buffer::MemoryLimitError&) { // infinite loop detection, buffer memory limit reached but no progress if (batch_start_block_num == block_num) { SILK_ERROR << "Buffer memory limit too small to execute a single block (block_num=" << block_num << ")"; return SILKWORM_INTERNAL_ERROR; } // batch done batch_start_block_num = block_num; break; } if (last_exec_result != ValidationResult::kOk) { // firstly, persist the work done so far, then return SILKWORM_INVALID_BLOCK break; } if (signal_check(signal_check_time)) { return SILKWORM_TERMINATION_SIGNAL; } last_block_num = block_num; ++block_num; block_buffer.pop_back(&block); } StopWatch sw{/*auto_start=*/true}; log::Info{"[4/12 Execution] Flushing state", // NOLINT(*-unused-raii) log_args_for_exec_flush(state_buffer, max_batch_size, last_block_num)}; state_buffer.write_state_to_db(); // Always save the Execution stage progress when state batch is flushed db::stages::write_stage_progress(txn, db::stages::kExecutionKey, last_block_num); // Commit and renew only in case of internally managed transaction txn.commit_and_renew(); const auto elapsed_time_and_duration = sw.stop(); log::Info("[4/12 Execution] Commit state+history", // NOLINT(*-unused-raii) log_args_for_exec_commit(elapsed_time_and_duration.second, (*rw_access).get_path())); if (last_executed_block) { *last_executed_block = last_block_num; } if (last_exec_result != ValidationResult::kOk) { return SILKWORM_INVALID_BLOCK; } } return SILKWORM_OK; } catch (const mdbx::exception& e) { if (mdbx_error_code) { *mdbx_error_code = e.error().code(); } return SILKWORM_MDBX_ERROR; } catch (const DecodingError&) { return SILKWORM_DECODING_ERROR; } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what(); return SILKWORM_INTERNAL_ERROR; } catch (...) { SILK_ERROR << "unknown exception"; return SILKWORM_UNKNOWN_ERROR; } } SILKWORM_EXPORT int silkworm_execute_txn(SilkwormHandle handle, MDBX_txn* mdbx_tx, uint64_t block_num, struct SilkwormBytes32 block_hash, uint64_t txn_index, uint64_t txn_num, uint64_t* gas_used, uint64_t* blob_gas_used) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } if (!mdbx_tx) { return SILKWORM_INVALID_MDBX_TXN; } if (gas_used) { *gas_used = 0; } if (blob_gas_used) { *blob_gas_used = 0; } if (!handle->db) { SILK_ERROR << "Database component not initialized"; return SILKWORM_INVALID_HANDLE; } SILK_DEBUG << "silkworm_execute_txn block_num: " << std::to_string(block_num) << " txn_index: " << std::to_string(txn_index) << " txn_num: " << std::to_string(txn_num); silkworm::Hash block_header_hash{}; memcpy(block_header_hash.bytes, block_hash.bytes, sizeof(block_hash.bytes)); BlockNum block_number{block_num}; TxnId txn_id{txn_num}; auto unmanaged_tx = datastore::kvdb::RWTxnUnmanaged{mdbx_tx}; auto unmanaged_env = silkworm::datastore::kvdb::EnvUnmanaged{::mdbx_txn_env(mdbx_tx)}; auto chain_db = db::DataStore::make_chaindata_database(std::move(unmanaged_env)); auto db_ref = chain_db.ref(); silkworm::execution::DomainState state{ txn_id, unmanaged_tx, db_ref, handle->db->blocks_repository, handle->db->state_repository_latest, handle->db->query_caches, }; if (!handle->chain_config) { handle->chain_config = db::read_chain_config(unmanaged_tx); if (!handle->chain_config) { SILK_ERROR << "Chain config not found"; return SILKWORM_INVALID_SETTINGS; } } // TODO: cache block, also consider preloading silkworm::Block block{}; auto block_read_ok = state.read_body(block_number, block_header_hash, block); if (!block_read_ok) { SILK_ERROR << "Block not found" << " block_number: " << block_number << " block_hash: " << block_header_hash; return SILKWORM_INVALID_BLOCK; } auto header = state.read_header(block_number, block_header_hash); if (!header) { SILK_ERROR << "Header not found" << " block_number: " << block_number << " block_hash: " << block_header_hash; return SILKWORM_INVALID_BLOCK; } block.header = header.value(); if (txn_index >= block.transactions.size()) { SILK_ERROR << "Transaction not found" << " txn_num: " << std::to_string(txn_num) << " txn_index: " << std::to_string(txn_index) << " transactions in block: " << std::to_string(block.transactions.size()); return SILKWORM_INVALID_BLOCK; } auto& transaction = block.transactions[txn_index]; SILK_DEBUG << "silkworm_execute_txn BlockNum " << std::to_string(block_num) << " BlockHash " << silkworm::to_hex(block_hash.bytes, true) << " TxIndex " << std::to_string(txn_index) << " TxNum " << std::to_string(txn_num) << " TxnHash " << silkworm::to_hex(transaction.hash().bytes, true) << " Sender " << silkworm::to_hex(transaction.sender().value_or(evmc::address{}).bytes, true); auto protocol_rule_set{protocol::rule_set_factory(*handle->chain_config)}; if (!protocol_rule_set) { SILK_ERROR << "Protocol rule set not created"; return SILKWORM_INTERNAL_ERROR; } ExecutionProcessor processor{block, *protocol_rule_set, state, *handle->chain_config, false}; // TODO: add analysis cache, check block exec for more silkworm::Receipt receipt{}; const ValidationResult err{protocol::validate_transaction(transaction, processor.intra_block_state(), processor.available_gas())}; if (err != ValidationResult::kOk) { SILK_ERROR << "Transaction validation failed" << " err: " << static_cast(err); return SILKWORM_INVALID_BLOCK; } processor.execute_transaction(transaction, receipt); try { processor.flush_state(); SilkwormInstance::ExecutionResult exec_result{ .txn_id = txn_id, .blob_gas_used = transaction.total_blob_gas(), .receipt = receipt, .log_index = 0}; if (!handle->executions_in_block.empty()) { const auto& prev = handle->executions_in_block.back(); exec_result.blob_gas_used += prev.blob_gas_used; exec_result.receipt.cumulative_gas_used += prev.receipt.cumulative_gas_used; exec_result.log_index += std::size(prev.receipt.logs); } handle->executions_in_block.emplace_back(std::move(exec_result)); } catch (const std::exception& ex) { SILK_ERROR << "transaction post-processing failed: " << ex.what(); return SILKWORM_INTERNAL_ERROR; } SILK_DEBUG << "Gas used " << receipt.cumulative_gas_used << " Blob gas used " << transaction.total_blob_gas(); if (gas_used) { *gas_used = receipt.cumulative_gas_used; } if (blob_gas_used) { *blob_gas_used = transaction.total_blob_gas(); } return SILKWORM_OK; } SILKWORM_EXPORT int silkworm_block_exec_start(SilkwormHandle handle, MDBX_txn* mdbx_tx, [[maybe_unused]] uint64_t block_num, [[maybe_unused]] struct SilkwormBytes32 block_hash) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } if (!mdbx_tx) { return SILKWORM_INVALID_MDBX_TXN; } // TODO: cache block here for future reuse with transactions within same (block_exec_start, block_exec_end) range // Clear any transactoins and receipts created in previous blocks handle->executions_in_block.clear(); return SILKWORM_OK; } SILKWORM_EXPORT int silkworm_block_exec_end(SilkwormHandle handle, MDBX_txn* mdbx_tx, MDBX_txn* mdbx_in_mem_temp_tx) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } if (!mdbx_tx || !mdbx_in_mem_temp_tx) { return SILKWORM_INVALID_MDBX_TXN; } // Temporary db used for silkworm->erigon communication auto unmanaged_in_mem_tx = datastore::kvdb::RWTxnUnmanaged{mdbx_in_mem_temp_tx}; auto rw_in_mem_cursor = unmanaged_in_mem_tx.rw_cursor(db::table::kBlockReceipts); // Persistent db used for shared domains auto unmanaged_tx = datastore::kvdb::RWTxnUnmanaged{mdbx_tx}; auto unmanaged_env = silkworm::datastore::kvdb::EnvUnmanaged{::mdbx_txn_env(mdbx_tx)}; auto chain_db = db::DataStore::make_chaindata_database(std::move(unmanaged_env)); auto db_ref = chain_db.ref(); for (uint64_t index = 0; index < std::size(handle->executions_in_block); ++index) { const auto& receipt = handle->executions_in_block[index].receipt; Bytes rlp_encoded; rlp::encode(rlp_encoded, receipt); Bytes key(sizeof(int64_t), '\0'); endian::store_big_u64(key.data(), index); rw_in_mem_cursor->insert(datastore::kvdb::Slice(key), datastore::kvdb::Slice(rlp_encoded)); const auto& txn_id = handle->executions_in_block[index].txn_id; execution::DomainState state{ txn_id, unmanaged_tx, db_ref, handle->db->blocks_repository, handle->db->state_repository_latest, handle->db->query_caches, }; const auto log_index = handle->executions_in_block[index].log_index; const auto blob_gas_used = handle->executions_in_block[index].blob_gas_used; state.insert_receipt(receipt, log_index, blob_gas_used); } return SILKWORM_OK; } ================================================ FILE: silkworm/capi/silkworm.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_H_ #define SILKWORM_H_ // C API exported by Silkworm to be used in Erigon. #ifdef SILKWORM_CAPI_COMPONENT #include "common/preamble.h" #include #include #include #else #include "preamble.h" #include "db.h" #include "rpcdaemon.h" #include "sentry.h" #endif #include "init.h" #if __cplusplus extern "C" { #endif typedef struct MDBX_env MDBX_env; typedef struct MDBX_txn MDBX_txn; struct SilkwormBytes32 { uint8_t bytes[32]; }; /** * \brief Execute a batch of blocks and push changes to the given database transaction. No data is commited. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] txn A valid external read-write MDBX transaction or zero if an internal one must be used. * This function does not commit nor abort the transaction. * \param[in] chain_id EIP-155 chain ID. SILKWORM_UNKNOWN_CHAIN_ID is returned in case of an unknown or unsupported chain. * \param[in] start_block The block number to start the execution from. * \param[in] max_block Do not execute after this block. * max_block may be executed, or the execution may stop earlier if the batch is full. * \param[in] batch_size The size of DB changes to accumulate before returning from this method. * Pass 0 if you want to execute just 1 block. * \param[in] write_change_sets Whether to write state changes into the DB. * \param[in] write_receipts Whether to write CBOR-encoded receipts into the DB. * \param[in] write_call_traces Whether to write call traces into the DB. * \param[out] last_executed_block The block number of the last successfully executed block. * Not written to if no blocks were executed, otherwise *last_executed_block ≤ max_block. * \param[out] mdbx_error_code If an MDBX error occurs (this function returns kSilkwormMdbxError) * and mdbx_error_code isn't NULL, it's populated with the relevant MDBX error code. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. * SILKWORM_BLOCK_NOT_FOUND is probably OK: it simply means that the execution reached the end of the chain * (blocks up to and incl. last_executed_block were still executed). */ SILKWORM_EXPORT int silkworm_execute_blocks_ephemeral( SilkwormHandle handle, MDBX_txn* txn, uint64_t chain_id, uint64_t start_block, uint64_t max_block, uint64_t batch_size, bool write_change_sets, bool write_receipts, bool write_call_traces, uint64_t* last_executed_block, int* mdbx_error_code) SILKWORM_NOEXCEPT; /** * \brief Execute a batch of blocks and write resulting changes into the database. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] mdbx_env A valid MDBX environment. Must not be zero. * \param[in] chain_id EIP-155 chain ID. SILKWORM_UNKNOWN_CHAIN_ID is returned in case of an unknown or unsupported chain. * \param[in] start_block The block number to start the execution from. * \param[in] max_block Do not execute after this block. * max_block may be executed, or the execution may stop earlier if the batch is full. * \param[in] batch_size The size of DB changes to accumulate before returning from this method. * Pass 0 if you want to execute just 1 block. * \param[in] write_change_sets Whether to write state changes into the DB. * \param[in] write_receipts Whether to write CBOR-encoded receipts into the DB. * \param[in] write_call_traces Whether to write call traces into the DB. * \param[out] last_executed_block The block number of the last successfully executed block. * Not written to if no blocks were executed, otherwise *last_executed_block ≤ max_block. * \param[out] mdbx_error_code If an MDBX error occurs (this function returns kSilkwormMdbxError) * and mdbx_error_code isn't NULL, it's populated with the relevant MDBX error code. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. * SILKWORM_BLOCK_NOT_FOUND is probably OK: it simply means that the execution reached the end of the chain * (blocks up to and incl. last_executed_block were still executed). */ SILKWORM_EXPORT int silkworm_execute_blocks_perpetual(SilkwormHandle handle, MDBX_env* mdbx_env, uint64_t chain_id, uint64_t start_block, uint64_t max_block, uint64_t batch_size, bool write_change_sets, bool write_receipts, bool write_call_traces, uint64_t* last_executed_block, int* mdbx_error_code) SILKWORM_NOEXCEPT; /** * \brief Execute a transaction in a block. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] mdbx_tx A valid external read-write MDBX transaction. * \param[in] block_num The number of the block containing the transaction. * \param[in] block_hash The hash of the block. * \param[in] txn_index The transaction number in the block. * \param[in] txn_num The canonical transaction ID. * \param[out] gas_used The gas used by the transaction. * \param[out] blob_gas_used The blob gas used by the transaction. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_execute_txn(SilkwormHandle handle, MDBX_txn* mdbx_tx, uint64_t block_num, struct SilkwormBytes32 block_hash, uint64_t txn_index, uint64_t txn_num, uint64_t* gas_used, uint64_t* blob_gas_used) SILKWORM_NOEXCEPT; /** * \brief Signals starting block execution * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] mdbx_tx A valid external read-write MDBX transaction. * \param[in] block_num The number of the block containing the transaction. * \param[in] block_hash The hash of the block. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_block_exec_start(SilkwormHandle handle, MDBX_txn* mdbx_tx, uint64_t block_num, struct SilkwormBytes32 block_hash) SILKWORM_NOEXCEPT; /** * \brief Signals completing block execution * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] mdbx_tx A valid external read-write MDBX transaction. * \param[in] mdbx_in_mem_temp_tx A valid in memory MDBX transaction for silkworm->erigon communication * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_block_exec_end(SilkwormHandle handle, MDBX_txn* mdbx_tx, MDBX_txn* mdbx_in_mem_temp_tx) SILKWORM_NOEXCEPT; #if __cplusplus } #endif #endif // SILKWORM_H_ ================================================ FILE: silkworm/capi/silkworm_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "silkworm.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "instance.hpp" namespace silkworm { namespace snapshot_test = snapshots::test_util; using namespace silkworm::db; using namespace silkworm::datastore::kvdb; struct CApiTest { TemporaryDirectory tmp_dir; db::test_util::TestDatabaseContext database{tmp_dir}; SilkwormSettings settings{.log_verbosity = SilkwormLogLevel::SILKWORM_LOG_NONE}; mdbx::env env{*database.chaindata_rw()}; const std::filesystem::path& env_path() const { return database.chaindata_dir_path(); } }; //! Utility to copy `src` C-string to `dst` fixed-size char array template static void c_string_copy(char dst[N], const char* src) { std::strncpy(dst, src, N - 1); dst[N - 1] = '\0'; } //! Utility to copy `src` C-string in 'git describe' format to `dst` static void copy_git_version(char dst[SILKWORM_GIT_VERSION_SIZE], const char* src) { c_string_copy(dst, src); } //! Utility to copy `src` C-string fixed-size path to `dst` static void copy_path(char dst[SILKWORM_PATH_SIZE], const char* src) { c_string_copy(dst, src); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_libmdbx_version: OK", "[capi]") { CHECK(std::strcmp(silkworm_libmdbx_version(), ::mdbx::get_version().git.describe) == 0); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_init: empty settings", "[capi]") { SilkwormHandle handle{nullptr}; CHECK(silkworm_init(&handle, &settings) == SILKWORM_INVALID_PATH); CHECK(!handle); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_init: empty data folder path", "[capi]") { copy_path(settings.data_dir_path, ""); copy_git_version(settings.libmdbx_version, silkworm_libmdbx_version()); SilkwormHandle handle{nullptr}; CHECK(silkworm_init(&handle, &settings) == SILKWORM_INVALID_PATH); CHECK(!handle); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_init: empty MDBX version", "[capi]") { copy_path(settings.data_dir_path, env_path().string().c_str()); copy_git_version(settings.libmdbx_version, ""); SilkwormHandle handle{nullptr}; CHECK(silkworm_init(&handle, &settings) == SILKWORM_INCOMPATIBLE_LIBMDBX); CHECK(!handle); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_init: incompatible MDBX version", "[capi]") { copy_path(settings.data_dir_path, env_path().string().c_str()); copy_git_version(settings.libmdbx_version, "v0.1.0"); SilkwormHandle handle{nullptr}; CHECK(silkworm_init(&handle, &settings) == SILKWORM_INCOMPATIBLE_LIBMDBX); CHECK(!handle); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_init: OK", "[capi]") { copy_path(settings.data_dir_path, env_path().string().c_str()); copy_git_version(settings.libmdbx_version, silkworm_libmdbx_version()); SilkwormHandle handle{nullptr}; CHECK(silkworm_init(&handle, &settings) == SILKWORM_OK); CHECK(handle); CHECK(silkworm_fini(handle) == SILKWORM_OK); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_fini: not initialized", "[capi]") { SilkwormHandle handle{nullptr}; CHECK(silkworm_fini(handle) == SILKWORM_INVALID_HANDLE); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_fini: OK", "[capi]") { copy_path(settings.data_dir_path, env_path().string().c_str()); copy_git_version(settings.libmdbx_version, silkworm_libmdbx_version()); SilkwormHandle handle{nullptr}; REQUIRE(silkworm_init(&handle, &settings) == SILKWORM_OK); CHECK(silkworm_fini(handle) == SILKWORM_OK); } //! \brief Utility class using RAII pattern to wrap the Silkworm C API. //! \note This is useful for tests that do *not* specifically play with silkworm_init/silkworm_fini or invalid handles struct SilkwormLibrary { explicit SilkwormLibrary(const std::filesystem::path& env_path) { SilkwormSettings settings{.log_verbosity = SilkwormLogLevel::SILKWORM_LOG_NONE}; copy_path(settings.data_dir_path, env_path.string().c_str()); copy_git_version(settings.libmdbx_version, silkworm_libmdbx_version()); silkworm_init(&handle_, &settings); } ~SilkwormLibrary() { silkworm_fini(handle_); } struct ExecutionResult { int execute_block_result{0}; BlockNum last_executed_block{0}; int mdbx_error_code{0}; }; ExecutionResult execute_blocks(MDBX_txn* txn, uint64_t chain_id, uint64_t start_block, uint64_t max_block, uint64_t batch_size, bool write_change_sets, bool write_receipts, bool write_call_traces) const { ExecutionResult result; result.execute_block_result = silkworm_execute_blocks_ephemeral(handle_, txn, chain_id, start_block, max_block, batch_size, write_change_sets, write_receipts, write_call_traces, &result.last_executed_block, &result.mdbx_error_code); return result; } ExecutionResult execute_blocks_perpetual(MDBX_env* env, uint64_t chain_id, uint64_t start_block, uint64_t max_block, uint64_t batch_size, bool write_change_sets, bool write_receipts, bool write_call_traces) const { ExecutionResult result; result.execute_block_result = silkworm_execute_blocks_perpetual(handle_, env, chain_id, start_block, max_block, batch_size, write_change_sets, write_receipts, write_call_traces, &result.last_executed_block, &result.mdbx_error_code); return result; } int execute_txn(MDBX_txn* tx, uint64_t block_num, silkworm::Hash head_hash, uint64_t txn_index, uint64_t txn_id) const { SilkwormBytes32 head_hash_bytes{}; std::memcpy(head_hash_bytes.bytes, head_hash.bytes, 32); return silkworm_execute_txn(handle_, tx, block_num, head_hash_bytes, txn_index, txn_id, nullptr, nullptr); } int add_blocks_snapshot_bundle(SilkwormBlocksSnapshotBundle* bundle) const { return silkworm_add_blocks_snapshot_bundle(handle_, bundle); } int add_state_snapshot_bundle_latest(SilkwormStateSnapshotBundleLatest* bundle) const { return silkworm_add_state_snapshot_bundle_latest(handle_, bundle); } int add_state_snapshot_bundle_historical(SilkwormStateSnapshotBundleHistorical* bundle) const { return silkworm_add_state_snapshot_bundle_historical(handle_, bundle); } int start_rpcdaemon(MDBX_env* env, const SilkwormRpcSettings* settings) const { return silkworm_start_rpcdaemon(handle_, env, settings); } int stop_rpcdaemon() const { return silkworm_stop_rpcdaemon(handle_); } private: SilkwormHandle handle_{nullptr}; }; TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_ephemeral: block not found", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{256 * kMebi}; BlockNum start_block{10}; // This does not exist, TestDatabaseContext db contains up to block 9 BlockNum end_block{100}; RWTxnManaged external_txn{env}; const auto result0{ silkworm_lib.execute_blocks(*external_txn, chain_id, start_block, end_block, batch_size, true, true, true)}; CHECK_NOTHROW(external_txn.commit_and_stop()); CHECK(result0.execute_block_result == SILKWORM_BLOCK_NOT_FOUND); CHECK(result0.last_executed_block == 0); CHECK(result0.mdbx_error_code == 0); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_perpetual: block not found", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{256 * kMebi}; BlockNum start_block{10}; // This does not exist, TestDatabaseContext db contains up to block 9 BlockNum end_block{100}; const auto result0{ silkworm_lib.execute_blocks_perpetual(env, chain_id, start_block, end_block, batch_size, true, true, true)}; CHECK(result0.execute_block_result == SILKWORM_BLOCK_NOT_FOUND); CHECK(result0.last_executed_block == 0); CHECK(result0.mdbx_error_code == 0); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_ephemeral: chain id not found", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const uint64_t chain_id{1000000}; const uint64_t batch_size{256 * kMebi}; BlockNum start_block{1}; BlockNum end_block{2}; RWTxnManaged external_txn{env}; const auto result0{ silkworm_lib.execute_blocks(*external_txn, chain_id, start_block, end_block, batch_size, true, true, true)}; CHECK_NOTHROW(external_txn.commit_and_stop()); CHECK(result0.execute_block_result == SILKWORM_UNKNOWN_CHAIN_ID); CHECK(result0.last_executed_block == 0); CHECK(result0.mdbx_error_code == 0); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_perpetual: chain id not found", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const uint64_t chain_id{1000000}; const uint64_t batch_size{256 * kMebi}; BlockNum start_block{1}; BlockNum end_block{2}; const auto result0{ silkworm_lib.execute_blocks_perpetual(env, chain_id, start_block, end_block, batch_size, true, true, true)}; CHECK(result0.execute_block_result == SILKWORM_UNKNOWN_CHAIN_ID); CHECK(result0.last_executed_block == 0); CHECK(result0.mdbx_error_code == 0); } static void insert_block(mdbx::env& env, Block& block) { auto block_hash = block.header.hash(); RWTxnManaged rw_txn{env}; write_senders(rw_txn, block_hash, block.header.number, block); intx::uint256 max_priority_fee_per_gas = block.transactions.empty() ? block.header.base_fee_per_gas.value_or(0) : block.transactions[0].max_priority_fee_per_gas; intx::uint256 max_fee_per_gas = block.transactions.empty() ? block.header.base_fee_per_gas.value_or(0) : block.transactions[0].max_fee_per_gas; silkworm::Transaction system_transaction; system_transaction.max_priority_fee_per_gas = max_priority_fee_per_gas; system_transaction.max_fee_per_gas = max_fee_per_gas; block.transactions.emplace(block.transactions.begin(), system_transaction); block.transactions.emplace_back(system_transaction); write_header(rw_txn, block.header, true); write_raw_body(rw_txn, block, block_hash, block.header.number); write_canonical_header_hash(rw_txn, block_hash.bytes, block.header.number); rw_txn.commit_and_stop(); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_ephemeral single block: OK", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{256 * kMebi}; const bool write_change_sets{false}; // We CANNOT write changesets here, TestDatabaseContext db already has them const bool write_receipts{false}; // We CANNOT write receipts here, TestDatabaseContext db already has them const bool write_call_traces{false}; // For coherence but don't care auto execute_blocks = [&](auto tx, auto start_block, auto end_block) { return silkworm_lib.execute_blocks(tx, chain_id, start_block, end_block, batch_size, write_change_sets, write_receipts, write_call_traces); }; /* TestDatabaseContext db contains a test chain made up of 9 blocks */ // Prepare and insert block 10 (just 1 tx w/ value transfer) evmc::address from{0x658bdf435d810c91414ec09147daa6db62406379_address}; // funded in genesis evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; // untouched address intx::uint256 value{1 * kEther}; Block block{}; block.header.number = 10; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].to = to; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].value = value; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(from); insert_block(env, block); // Execute block 11 using an *external* txn, then commit RWTxnManaged external_txn0{env}; BlockNum start_block{10}, end_block{10}; const auto result0{execute_blocks(*external_txn0, start_block, end_block)}; CHECK_NOTHROW(external_txn0.commit_and_stop()); CHECK(result0.execute_block_result == SILKWORM_OK); CHECK(result0.last_executed_block == end_block); CHECK(result0.mdbx_error_code == 0); ROTxnManaged ro_txn{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == value); ro_txn.abort(); // Prepare and insert block 11 (same as block 10) block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); block.header.number = 11; ++block.transactions[0].nonce; insert_block(env, block); // Execute block 11 using an *external* txn, then commit RWTxnManaged external_txn1{env}; start_block = 11, end_block = 11; const auto result1{execute_blocks(*external_txn1, start_block, end_block)}; CHECK_NOTHROW(external_txn1.commit_and_stop()); CHECK(result1.execute_block_result == SILKWORM_OK); CHECK(result1.last_executed_block == end_block); CHECK(result1.mdbx_error_code == 0); ro_txn = ROTxnManaged{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == 2 * value); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_perpetual single block: OK", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{256 * kMebi}; const bool write_change_sets{false}; // We CANNOT write changesets here, TestDatabaseContext db already has them const bool write_receipts{false}; // We CANNOT write receipts here, TestDatabaseContext db already has them const bool write_call_traces{false}; // For coherence but don't care auto execute_blocks = [&](auto start_block, auto end_block) { return silkworm_lib.execute_blocks_perpetual(env, chain_id, start_block, end_block, batch_size, write_change_sets, write_receipts, write_call_traces); }; /* TestDatabaseContext db contains a test chain made up of 9 blocks */ // Prepare and insert block 10 (just 1 tx w/ value transfer) evmc::address from{0x658bdf435d810c91414ec09147daa6db62406379_address}; // funded in genesis evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; // untouched address intx::uint256 value{1 * kEther}; Block block{}; block.header.number = 10; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].to = to; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].value = value; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(from); insert_block(env, block); // Execute block 10 using an *internal* txn BlockNum start_block{10}, end_block{10}; const auto result0{execute_blocks(start_block, end_block)}; CHECK(result0.execute_block_result == SILKWORM_OK); CHECK(result0.last_executed_block == end_block); CHECK(result0.mdbx_error_code == 0); ROTxnManaged ro_txn{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == value); ro_txn.abort(); // Prepare and insert block 11 (same as block 10) block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); block.header.number = 11; ++block.transactions[0].nonce; insert_block(env, block); // Execute block 11 using an *internal* txn start_block = 11, end_block = 11; const auto result1{execute_blocks(start_block, end_block)}; CHECK(result1.execute_block_result == SILKWORM_OK); CHECK(result1.last_executed_block == end_block); CHECK(result1.mdbx_error_code == 0); ro_txn = ROTxnManaged{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == 2 * value); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_ephemeral multiple blocks: OK", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{3000}; // Small batch size to force multiple iterations const bool write_change_sets{false}; // We CANNOT write changesets here, TestDatabaseContext db already has them const bool write_receipts{false}; // We CANNOT write receipts here, TestDatabaseContext db already has them const bool write_call_traces{false}; // For coherence but don't care auto execute_blocks = [&](auto tx, auto start_block, auto end_block) { return silkworm_lib.execute_blocks(tx, chain_id, start_block, end_block, batch_size, write_change_sets, write_receipts, write_call_traces); }; /* TestDatabaseContext db contains a test chain made up of 9 blocks */ // Prepare block template (just 1 tx w/ value transfer) evmc::address from{0x658bdf435d810c91414ec09147daa6db62406379_address}; // funded in genesis evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; // untouched address intx::uint256 value{1}; Block block{}; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].to = to; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].value = value; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(from); constexpr size_t kBlocks{130}; // Insert N blocks for (size_t i{10}; i < 10 + kBlocks; ++i) { block.header.number = i; insert_block(env, block); block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); ++block.transactions[0].nonce; } // Execute N blocks using an *external* txn, then commit RWTxnManaged external_txn0{env}; BlockNum start_block{10}, end_block{10 + kBlocks - 1}; const auto result0{execute_blocks(*external_txn0, start_block, end_block)}; CHECK_NOTHROW(external_txn0.commit_and_stop()); CHECK(result0.execute_block_result == SILKWORM_OK); CHECK(result0.last_executed_block == end_block); CHECK(result0.mdbx_error_code == 0); ROTxnManaged ro_txn{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == kBlocks * value); ro_txn.abort(); // Insert N blocks again for (size_t i{10 + kBlocks}; i < (10 + 2 * kBlocks); ++i) { block.header.number = i; insert_block(env, block); block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); ++block.transactions[0].nonce; } // Execute N blocks using an *external* txn, then commit RWTxnManaged external_txn1{env}; start_block = 10 + kBlocks, end_block = 10 + 2 * kBlocks - 1; const auto result1{execute_blocks(*external_txn1, start_block, end_block)}; CHECK_NOTHROW(external_txn1.commit_and_stop()); CHECK(result1.execute_block_result == SILKWORM_OK); CHECK(result1.last_executed_block == end_block); CHECK(result1.mdbx_error_code == 0); ro_txn = ROTxnManaged{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == 2 * kBlocks * value); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_perpetual multiple blocks: OK", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{3000}; // Small batch size to force multiple iterations const bool write_change_sets{false}; // We CANNOT write changesets here, TestDatabaseContext db already has them const bool write_receipts{false}; // We CANNOT write receipts here, TestDatabaseContext db already has them const bool write_call_traces{false}; // For coherence but don't care auto execute_blocks = [&](auto start_block, auto end_block) { return silkworm_lib.execute_blocks_perpetual(env, chain_id, start_block, end_block, batch_size, write_change_sets, write_receipts, write_call_traces); }; /* TestDatabaseContext db contains a test chain made up of 9 blocks */ // Prepare block template (just 1 tx w/ value transfer) evmc::address from{0x658bdf435d810c91414ec09147daa6db62406379_address}; // funded in genesis evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb500_address}; // untouched address(es) intx::uint256 value{1}; Block block{}; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].to = to; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].value = value; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(from); constexpr size_t kBlocks{130}; // Insert N blocks for (size_t i{10}; i < 10 + kBlocks; ++i) { block.header.number = i; insert_block(env, block); block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); ++block.transactions[0].nonce; ++block.transactions[0].to->bytes[19]; // change recipient address to force batch size growth } // Execute N blocks using an *internal* txn BlockNum start_block{10}, end_block{10 + kBlocks - 1}; const auto result0{execute_blocks(start_block, end_block)}; CHECK(result0.execute_block_result == SILKWORM_OK); CHECK(result0.last_executed_block == end_block); CHECK(result0.mdbx_error_code == 0); ROTxnManaged ro_txn{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == value); ro_txn.abort(); // Insert N blocks again block.transactions[0].to = to; for (size_t i{10 + kBlocks}; i < (10 + 2 * kBlocks); ++i) { block.header.number = i; insert_block(env, block); block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); ++block.transactions[0].nonce; ++block.transactions[0].to->bytes[19]; // change recipient address to force batch size growth } // Execute N blocks using an *internal* txn, then commit start_block = 10 + kBlocks, end_block = 10 + 2 * kBlocks - 1; const auto result1{execute_blocks(start_block, end_block)}; CHECK(result1.execute_block_result == SILKWORM_OK); CHECK(result1.last_executed_block == end_block); CHECK(result1.mdbx_error_code == 0); ro_txn = ROTxnManaged{env}; REQUIRE(read_account(ro_txn, to)); CHECK(read_account(ro_txn, to)->balance == 2 * value); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_ephemeral multiple blocks: insufficient buffer", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{170}; // Small batch size to force multiple iterations const bool write_change_sets{false}; // We CANNOT write changesets here, TestDatabaseContext db already has them const bool write_receipts{false}; // We CANNOT write receipts here, TestDatabaseContext db already has them const bool write_call_traces{false}; // For coherence but don't care auto execute_blocks = [&](auto tx, auto start_block, auto end_block) { return silkworm_lib.execute_blocks(tx, chain_id, start_block, end_block, batch_size, write_change_sets, write_receipts, write_call_traces); }; /* TestDatabaseContext db contains a test chain made up of 9 blocks */ // Prepare block template (just 1 tx w/ value transfer) evmc::address from{0x658bdf435d810c91414ec09147daa6db62406379_address}; // funded in genesis evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; // untouched address intx::uint256 value{1}; Block block{}; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].to = to; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].value = value; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(from); constexpr size_t kBlocks{130}; // Insert N blocks for (size_t i{10}; i < 10 + kBlocks; ++i) { block.header.number = i; insert_block(env, block); block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); ++block.transactions[0].nonce; } // Execute N blocks using an *external* txn, then commit RWTxnManaged external_txn0{env}; BlockNum start_block{10}, end_block{10 + kBlocks - 1}; const auto result0{execute_blocks(*external_txn0, start_block, end_block)}; CHECK_NOTHROW(external_txn0.commit_and_stop()); CHECK(result0.execute_block_result == SILKWORM_INTERNAL_ERROR); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_execute_blocks_perpetual multiple blocks: insufficient buffer", "[capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; const int chain_id{1}; const uint64_t batch_size{170}; // Batch size not enough to process a single block const bool write_change_sets{false}; // We CANNOT write changesets here, TestDatabaseContext db already has them const bool write_receipts{false}; // We CANNOT write receipts here, TestDatabaseContext db already has them const bool write_call_traces{false}; // For coherence but don't care auto execute_blocks = [&](auto start_block, auto end_block) { return silkworm_lib.execute_blocks_perpetual(env, chain_id, start_block, end_block, batch_size, write_change_sets, write_receipts, write_call_traces); }; /* TestDatabaseContext db contains a test chain made up of 9 blocks */ // Prepare block template (just 1 tx w/ value transfer) evmc::address from{0x658bdf435d810c91414ec09147daa6db62406379_address}; // funded in genesis evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb500_address}; // untouched address(es) intx::uint256 value{1}; Block block{}; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].to = to; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].value = value; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(from); constexpr size_t kBlocks{130}; // Insert N blocks for (size_t i{10}; i < 10 + kBlocks; ++i) { block.header.number = i; insert_block(env, block); block.transactions.erase(block.transactions.cbegin()); block.transactions.pop_back(); ++block.transactions[0].nonce; ++block.transactions[0].to->bytes[19]; // change recipient address to force batch size growth } // Execute N blocks using an *internal* txn BlockNum start_block{10}, end_block{10 + kBlocks - 1}; const auto result0{execute_blocks(start_block, end_block)}; CHECK(result0.execute_block_result == SILKWORM_INTERNAL_ERROR); } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_add_blocks_snapshot_bundle", "[capi]") { static constexpr datastore::StepToTimestampConverter kStepConverter = db::blocks::kStepToBlockNumConverter; snapshot_test::SampleHeaderSnapshotFile header_segment_file{tmp_dir.path()}; auto& header_segment_path = header_segment_file.path(); snapshot_test::SampleBodySnapshotFile body_segment_file{tmp_dir.path()}; auto& body_segment_path = body_segment_file.path(); snapshot_test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; auto& txn_segment_path = txn_segment_file.path(); auto header_index_builder = snapshots::HeaderIndex::make(header_segment_path); header_index_builder.set_base_data_id(header_segment_file.block_num_range().start); REQUIRE_NOTHROW(header_index_builder.build()); snapshots::segment::SegmentFileReader header_segment{header_segment_path, kStepConverter}; snapshots::rec_split::AccessorIndex idx_header_hash{header_segment_path.related_path_ext(db::blocks::kIdxExtension)}; auto body_index_builder = snapshots::BodyIndex::make(body_segment_path); body_index_builder.set_base_data_id(body_segment_file.block_num_range().start); REQUIRE_NOTHROW(body_index_builder.build()); snapshots::segment::SegmentFileReader body_segment{body_segment_path, kStepConverter}; snapshots::rec_split::AccessorIndex idx_body_number{body_segment_path.related_path_ext(db::blocks::kIdxExtension)}; auto tx_index_builder = snapshots::TransactionIndex::make(body_segment_path, txn_segment_path); tx_index_builder.build(); auto tx_index_hash_to_block_builder = snapshots::TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start); tx_index_hash_to_block_builder.build(); snapshots::segment::SegmentFileReader txn_segment{txn_segment_path, kStepConverter}; snapshots::rec_split::AccessorIndex idx_txn_hash{txn_segment_path.related_path_ext(db::blocks::kIdxExtension)}; snapshots::rec_split::AccessorIndex idx_txn_hash_2_block{tx_index_hash_to_block_builder.path()}; const auto header_segment_path_string{header_segment_path.path().string()}; const auto header_index_path_string{idx_header_hash.path().path().string()}; const auto body_segment_path_string{body_segment_path.path().string()}; const auto body_index_path_string{idx_body_number.path().path().string()}; const auto txn_segment_path_string{txn_segment_path.path().string()}; const auto tx_hash_index_path_string{idx_txn_hash.path().path().string()}; const auto tx_hash2block_index_path_string{idx_txn_hash_2_block.path().path().string()}; // Prepare templates for valid header/body/transaction C data structures SilkwormHeadersSnapshot valid_shs{ .segment = SilkwormMemoryMappedFile{ .file_path = header_segment_path_string.c_str(), .memory_address = header_segment.memory_file_region().data(), .memory_length = header_segment.memory_file_region().size(), }, .header_hash_index = SilkwormMemoryMappedFile{ .file_path = header_index_path_string.c_str(), .memory_address = idx_header_hash.memory_file_region().data(), .memory_length = idx_header_hash.memory_file_region().size(), }, }; SilkwormBodiesSnapshot valid_sbs{ .segment = SilkwormMemoryMappedFile{ .file_path = body_segment_path_string.c_str(), .memory_address = body_segment.memory_file_region().data(), .memory_length = body_segment.memory_file_region().size(), }, .block_num_index = SilkwormMemoryMappedFile{ .file_path = body_index_path_string.c_str(), .memory_address = idx_body_number.memory_file_region().data(), .memory_length = idx_body_number.memory_file_region().size(), }, }; SilkwormTransactionsSnapshot valid_sts{ .segment = SilkwormMemoryMappedFile{ .file_path = txn_segment_path_string.c_str(), .memory_address = txn_segment.memory_file_region().data(), .memory_length = txn_segment.memory_file_region().size(), }, .tx_hash_index = SilkwormMemoryMappedFile{ .file_path = tx_hash_index_path_string.c_str(), .memory_address = idx_txn_hash.memory_file_region().data(), .memory_length = idx_txn_hash.memory_file_region().size(), }, .tx_hash_2_block_index = SilkwormMemoryMappedFile{ .file_path = tx_hash2block_index_path_string.c_str(), .memory_address = idx_txn_hash_2_block.memory_file_region().data(), .memory_length = idx_txn_hash_2_block.memory_file_region().size(), }, }; SECTION("invalid handle") { // We purposely do not call silkworm_init to provide a null handle SilkwormHandle handle{nullptr}; SilkwormBlocksSnapshotBundle bundle{valid_shs, valid_sbs, valid_sts}; CHECK(silkworm_add_blocks_snapshot_bundle(handle, &bundle) == SILKWORM_INVALID_HANDLE); } // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; SECTION("invalid header segment path") { SilkwormHeadersSnapshot invalid_shs{valid_shs}; invalid_shs.segment.file_path = nullptr; // as if left unassigned, i.e. empty SilkwormBlocksSnapshotBundle bundle{invalid_shs, valid_sbs, valid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid header index path") { SilkwormHeadersSnapshot invalid_shs{valid_shs}; invalid_shs.header_hash_index.file_path = nullptr; // as if left unassigned, i.e. empty SilkwormBlocksSnapshotBundle bundle{invalid_shs, valid_sbs, valid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid body segment path") { SilkwormBodiesSnapshot invalid_sbs{valid_sbs}; invalid_sbs.segment.file_path = nullptr; // as if left unassigned, i.e. empty SilkwormBlocksSnapshotBundle bundle{valid_shs, invalid_sbs, valid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid body index path") { SilkwormBodiesSnapshot invalid_sbs{valid_sbs}; invalid_sbs.block_num_index.file_path = nullptr; // as if left unassigned, i.e. empty SilkwormBlocksSnapshotBundle bundle{valid_shs, invalid_sbs, valid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid transaction segment path") { SilkwormTransactionsSnapshot invalid_sts{valid_sts}; invalid_sts.segment.file_path = nullptr; // as if left unassigned, i.e. empty SilkwormBlocksSnapshotBundle bundle{valid_shs, valid_sbs, invalid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid transaction hash index path") { SilkwormTransactionsSnapshot invalid_sts{valid_sts}; invalid_sts.tx_hash_index.file_path = nullptr; // as if left unassigned, i.e. empty SilkwormBlocksSnapshotBundle bundle{valid_shs, valid_sbs, invalid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid transaction hash2block index path") { SilkwormTransactionsSnapshot invalid_sts{valid_sts}; invalid_sts.tx_hash_2_block_index.file_path = nullptr; // as if left unassigned, i.e. empty SilkwormBlocksSnapshotBundle bundle{valid_shs, valid_sbs, invalid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid empty chain snapshot") { SilkwormBlocksSnapshotBundle bundle{}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("valid") { SilkwormBlocksSnapshotBundle bundle{valid_shs, valid_sbs, valid_sts}; const int result{silkworm_lib.add_blocks_snapshot_bundle(&bundle)}; CHECK(result == SILKWORM_OK); } } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_add_state_snapshot", "[capi]") { using snapshots::Schema; using namespace snapshots; constexpr uint32_t kZeroSalt{0}; const snapshot_test::SampleAccountsDomainSegmentFile kv_segment_file{tmp_dir.path()}; segment::KVSegmentFileReader kv_segment{kv_segment_file.path(), db::state::kStepToTxnIdConverter, seg::CompressionKind::kAll}; const auto kv_segment_path_string{kv_segment_file.path().path().string()}; const snapshot_test::SampleAccountsDomainExistenceIndexFile existence_index_file{tmp_dir.path()}; bloom_filter::BloomFilter existence_index{existence_index_file.path().path(), KeyHasher{kZeroSalt}}; const auto existence_index_path_string{existence_index_file.path().path().string()}; const snapshot_test::SampleAccountsDomainBTreeIndexFile btree_index_file{tmp_dir.path()}; btree::BTreeIndex btree_index{btree_index_file.path().path()}; const auto btree_index_path_string{btree_index_file.path().path().string()}; [[maybe_unused]] snapshots::Domain domain{ .kv_segment = kv_segment, .existence_index = existence_index, .btree_index = btree_index, }; // Prepare templates for C data structures of valid state (D/H/II) snapshots SilkwormDomainSnapshot sample_domain_snapshot{ .segment = SilkwormMemoryMappedFile{ .file_path = kv_segment_path_string.c_str(), .memory_address = kv_segment.memory_file_region().data(), .memory_length = kv_segment.memory_file_region().size(), }, .existence_index = SilkwormMemoryMappedFile{ .file_path = existence_index_path_string.c_str(), .memory_address = nullptr, // bloom filter is fully kept in memory, no mmap .memory_length = 0, }, .btree_index = SilkwormMemoryMappedFile{ .file_path = btree_index_path_string.c_str(), .memory_address = btree_index.memory_file_region().data(), .memory_length = btree_index.memory_file_region().size(), }, .has_accessor_index = false, }; SilkwormDomainSnapshot valid_accounts_ds{sample_domain_snapshot}; SilkwormDomainSnapshot valid_storage_ds{sample_domain_snapshot}; SilkwormDomainSnapshot valid_code_ds{sample_domain_snapshot}; SilkwormDomainSnapshot valid_commitment_ds{sample_domain_snapshot}; SilkwormDomainSnapshot valid_receipts_ds{sample_domain_snapshot}; SilkwormStateSnapshotBundleLatest valid_bundle_latest{ .accounts = valid_accounts_ds, .storage = valid_storage_ds, .code = valid_code_ds, .commitment = valid_commitment_ds, .receipts = valid_receipts_ds, }; SECTION("invalid handle") { // We purposely do not call silkworm_init to provide a null handle SilkwormHandle handle{nullptr}; CHECK(silkworm_add_state_snapshot_bundle_latest(handle, &valid_bundle_latest) == SILKWORM_INVALID_HANDLE); } // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; SECTION("invalid accounts segment path") { SilkwormStateSnapshotBundleLatest invalid_bundle{valid_bundle_latest}; invalid_bundle.accounts.segment.file_path = nullptr; // as if left unassigned, i.e. empty const int result = silkworm_lib.add_state_snapshot_bundle_latest(&invalid_bundle); CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid storage segment path") { SilkwormStateSnapshotBundleLatest invalid_bundle{valid_bundle_latest}; invalid_bundle.storage.segment.file_path = nullptr; // as if left unassigned, i.e. empty const int result = silkworm_lib.add_state_snapshot_bundle_latest(&invalid_bundle); CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid code segment path") { SilkwormStateSnapshotBundleLatest invalid_bundle{valid_bundle_latest}; invalid_bundle.code.segment.file_path = nullptr; // as if left unassigned, i.e. empty const int result = silkworm_lib.add_state_snapshot_bundle_latest(&invalid_bundle); CHECK(result == SILKWORM_INVALID_PATH); } // TODO(canepat): enable after fixing .kvi configuration with IndexList-like implementation /*SECTION("invalid commitment segment path") { SilkwormStateSnapshotBundleLatest invalid_bundle{valid_bundle_latest}; invalid_bundle.commitment.segment.file_path = nullptr; // as if left unassigned, i.e. empty const int result = silkworm_lib.add_state_snapshot_bundle_latest(&invalid_bundle); CHECK(result == SILKWORM_INVALID_PATH); }*/ SECTION("invalid receipts segment path") { SilkwormStateSnapshotBundleLatest invalid_bundle{valid_bundle_latest}; invalid_bundle.receipts.segment.file_path = nullptr; // as if left unassigned, i.e. empty const int result = silkworm_lib.add_state_snapshot_bundle_latest(&invalid_bundle); CHECK(result == SILKWORM_INVALID_PATH); } SECTION("invalid empty state snapshot") { SilkwormStateSnapshotBundleLatest invalid_bundle{}; const int result{silkworm_lib.add_state_snapshot_bundle_latest(&invalid_bundle)}; CHECK(result == SILKWORM_INVALID_PATH); } SECTION("valid latest") { const int result = silkworm_lib.add_state_snapshot_bundle_latest(&valid_bundle_latest); CHECK(result == SILKWORM_OK); } } static SilkwormRpcSettings make_rpc_settings_for_test(uint16_t api_listening_port) { SilkwormRpcSettings settings{ .eth_if_log_settings = { .enabled = false, .max_file_size_mb = 1, .max_files = 1, .dump_response = false, }, .eth_api_port = api_listening_port, .num_workers = 0, .erigon_json_rpc_compatibility = false, .ws_enabled = false, .ws_compression = false, .http_compression = false, // We must skip internal protocol check here (would block because gRPC server not present) .skip_internal_protocol_check = true, }; (void)std::snprintf(settings.eth_if_log_settings.container_folder, SILKWORM_PATH_SIZE, "logs"); (void)std::snprintf(settings.eth_api_host, SILKWORM_RPC_SETTINGS_HOST_SIZE, "localhost"); (void)std::snprintf(settings.eth_api_spec, SILKWORM_RPC_SETTINGS_API_NAMESPACE_SPEC_SIZE, "eth,ots"); for (auto& domain : settings.cors_domains) { domain[0] = '\0'; } (void)std::snprintf(settings.cors_domains[0], SILKWORM_RPC_SETTINGS_CORS_DOMAIN_SIZE, "*"); settings.jwt_file_path[0] = '\0'; return settings; } static const SilkwormRpcSettings kInvalidRpcSettings{make_rpc_settings_for_test(10)}; static const SilkwormRpcSettings kValidRpcSettings{make_rpc_settings_for_test(8545)}; TEST_CASE_METHOD(CApiTest, "CAPI silkworm_start_rpcdaemon", "[capi]") { SECTION("invalid handle") { // We purposely do not call silkworm_init to provide a null handle SilkwormHandle handle{nullptr}; CHECK(silkworm_start_rpcdaemon(handle, env, &kValidRpcSettings) == SILKWORM_INVALID_HANDLE); } // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; SECTION("invalid settings") { CHECK(silkworm_lib.start_rpcdaemon(env, nullptr) == SILKWORM_INVALID_SETTINGS); } // The following test fails on Windows with silkworm_start_rpcdaemon returning SILKWORM_OK #ifndef _WIN32 SECTION("test settings: invalid port") { CHECK(silkworm_lib.start_rpcdaemon(env, &kInvalidRpcSettings) == SILKWORM_INTERNAL_ERROR); } #endif // _WIN32 SECTION("test settings: valid port") { CHECK(silkworm_lib.start_rpcdaemon(env, &kValidRpcSettings) == SILKWORM_OK); REQUIRE(silkworm_lib.stop_rpcdaemon() == SILKWORM_OK); } } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_stop_rpcdaemon", "[capi]") { SECTION("invalid handle") { // We purposely do not call silkworm_init to provide a null handle SilkwormHandle handle{nullptr}; CHECK(silkworm_stop_rpcdaemon(handle) == SILKWORM_INVALID_HANDLE); } // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; SECTION("not yet started") { CHECK(silkworm_lib.stop_rpcdaemon() == SILKWORM_OK); } SECTION("already started") { REQUIRE(silkworm_lib.start_rpcdaemon(env, &kValidRpcSettings) == SILKWORM_OK); CHECK(silkworm_lib.stop_rpcdaemon() == SILKWORM_OK); } } TEST_CASE_METHOD(CApiTest, "CAPI silkworm_txn: single", "[silkworm][capi]") { // Use Silkworm as a library with silkworm_init/silkworm_fini automated by RAII SilkwormLibrary silkworm_lib{env_path()}; // Prepare and insert block 10 (just 1 tx w/ value transfer) evmc::address from{0x658bdf435d810c91414ec09147daa6db62406379_address}; // funded in genesis evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; // untouched address intx::uint256 value{1 * kEther}; Block block{}; block.header.number = 10; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].to = to; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].value = value; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(from); insert_block(env, block); RWTxnManaged external_txn{env}; auto result = silkworm_lib.execute_txn(*external_txn, 10, block.header.hash(), 0, 9); CHECK(result == SILKWORM_INVALID_BLOCK); CHECK_NOTHROW(external_txn.abort()); } /* The following test is disabled because it requires a database with a chain of blocks to be executed. It is not possible to create such a database in a test environment, still it is very usefull to run tests locally. TODO: Remove the test after CAPI silkworm_txn is fully tested */ // TEST_CASE("CAPI silkworm_txn: single", "[silkworm][capi]") { // auto data_dir = DataDirectory{"/path/to/data"}; // SilkwormLibrary silkworm_lib{data_dir.path()}; // silkworm::datastore::kvdb::EnvConfig env_config{ // .path = data_dir.chaindata().path().string(), // .create = false, // .exclusive = true, // .in_memory = false, // .shared = false, // }; // auto env = open_env(env_config); // silkworm::datastore::kvdb::RWAccess rwa{env}; // auto tx = rwa.start_rw_tx(); // silkworm_lib.execute_txn(*tx, 7763755, silkworm::Hash{0xa96a1cdc01a6b9f502d0005a60d0c99eaa3b552699f1a71c0112d3f057b874d7_bytes32}, 112, 439062500); // silkworm_lib.execute_txn(*tx, 7763755, silkworm::Hash{0xa96a1cdc01a6b9f502d0005a60d0c99eaa3b552699f1a71c0112d3f057b874d7_bytes32}, 113, 439062501); // tx.abort(); // } } // namespace silkworm ================================================ FILE: silkworm/core/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(Catch2 REQUIRED) find_package(magic_enum REQUIRED) find_package(Microsoft.GSL REQUIRED) find_package(nlohmann_json REQUIRED) find_package(tl-expected REQUIRED) if(SILKWORM_CORE_ONLY) if(MSVC) add_compile_options(/EHsc) else() add_compile_options(-fno-exceptions) endif() endif() set(SILKWORM_CORE_PUBLIC_LIBS ethash::ethash evmc evmone intx::intx magic_enum::magic_enum Microsoft.GSL::GSL nlohmann_json::nlohmann_json secp256k1 tl::expected ) set(SILKWORM_CORE_PRIVATE_LIBS ff blst::blst) if(SILKWORM_CORE_USE_ABSEIL) find_package(absl REQUIRED) list(APPEND SILKWORM_CORE_PUBLIC_LIBS absl::flat_hash_map absl::flat_hash_set) endif() silkworm_library( silkworm_core PUBLIC ${SILKWORM_CORE_PUBLIC_LIBS} PRIVATE ${SILKWORM_CORE_PRIVATE_LIBS} ) if(SILKWORM_CORE_USE_ABSEIL) target_compile_definitions(silkworm_core PUBLIC SILKWORM_CORE_USE_ABSEIL) endif() # unit tests set(TEST_TARGET silkworm_core_test) if(SILKWORM_WASM_API) # Stub clang exception handlers on WASM after Catch2 3.x due to https://github.com/WebAssembly/wasi-sdk/issues/329 target_sources(${TEST_TARGET} PRIVATE "${SILKWORM_MAIN_SRC_DIR}/wasm/exception_handling_stub.cpp") # Skip generation of RPATH linker option for wasm-ld present by default after building Catch2 v3.6.0 from sources set_target_properties(${TEST_TARGET} PROPERTIES SKIP_BUILD_RPATH TRUE) endif() if(SILKWORM_CORE_ONLY) if(MSVC) target_compile_options(${TEST_TARGET} PRIVATE /EHa- /EHsc) else() target_compile_options(${TEST_TARGET} PRIVATE -fno-exceptions) endif() endif() ================================================ FILE: silkworm/core/chain/config.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "config.hpp" #include #include #include #include #include #include #include namespace silkworm { static constexpr std::string_view kTerminalTotalDifficulty{"terminalTotalDifficulty"}; static void member_to_json(nlohmann::json& json, const std::string& key, const std::optional& source) { if (source) { json[key] = source.value(); } } static void read_json_config_member( const nlohmann::json& json, const std::string& key, std::optional& target) { if (json.contains(key)) { target = json[key].get(); } } nlohmann::json ChainConfig::to_json() const noexcept { nlohmann::json ret; ret["chainId"] = chain_id; nlohmann::json empty_object(nlohmann::json::value_t::object); std::visit( Overloaded{ [&](const protocol::NoPreMergeConfig&) {}, [&](const protocol::EthashConfig& x) { ret.emplace("ethash", x.to_json()); }, [&](const protocol::bor::Config& x) { ret.emplace("bor", x.to_json()); }, }, rule_set_config); member_to_json(ret, "homesteadBlock", homestead_block); member_to_json(ret, "daoForkBlock", dao_block); member_to_json(ret, "eip150Block", tangerine_whistle_block); member_to_json(ret, "eip155Block", spurious_dragon_block); member_to_json(ret, "byzantiumBlock", byzantium_block); member_to_json(ret, "constantinopleBlock", constantinople_block); member_to_json(ret, "petersburgBlock", petersburg_block); member_to_json(ret, "istanbulBlock", istanbul_block); member_to_json(ret, "muirGlacierBlock", muir_glacier_block); member_to_json(ret, "berlinBlock", berlin_block); member_to_json(ret, "londonBlock", london_block); if (!burnt_contract.empty()) { nlohmann::json burnt_contract_json = nlohmann::json::object(); for (const auto& [from, contract] : burnt_contract) { burnt_contract_json[std::to_string(from)] = address_to_hex(contract); } ret["burntContract"] = burnt_contract_json; } member_to_json(ret, "arrowGlacierBlock", arrow_glacier_block); member_to_json(ret, "grayGlacierBlock", gray_glacier_block); if (terminal_total_difficulty) { // TODO(yperbasis): geth probably treats terminalTotalDifficulty as a JSON number ret[kTerminalTotalDifficulty] = to_string(*terminal_total_difficulty); } member_to_json(ret, "mergeNetsplitBlock", merge_netsplit_block); member_to_json(ret, "shanghaiTime", shanghai_time); member_to_json(ret, "cancunTime", cancun_time); member_to_json(ret, "pragueTime", prague_time); if (genesis_hash.has_value()) { ret["genesisBlockHash"] = to_hex(*genesis_hash, /*with_prefix=*/true); } return ret; } bool ChainConfig::valid_pre_merge_config() const noexcept { const bool has_pre_merge_config{!std::holds_alternative(rule_set_config)}; const bool has_merge_at_genesis{!terminal_total_difficulty || terminal_total_difficulty == 0}; return has_pre_merge_config || has_merge_at_genesis; } std::optional ChainConfig::from_json(const nlohmann::json& json) noexcept { if (json.is_discarded() || !json.contains("chainId") || !json["chainId"].is_number()) { return std::nullopt; } ChainConfig config{}; config.chain_id = json["chainId"].get(); if (json.contains("ethash")) { std::optional ethash_config{protocol::EthashConfig::from_json(json["ethash"])}; if (!ethash_config) { return std::nullopt; } config.rule_set_config = *ethash_config; } else if (json.contains("bor")) { std::optional bor_config{protocol::bor::Config::from_json(json["bor"])}; if (!bor_config) { return std::nullopt; } config.rule_set_config = *bor_config; } else { config.rule_set_config = protocol::NoPreMergeConfig{}; } read_json_config_member(json, "homesteadBlock", config.homestead_block); read_json_config_member(json, "daoForkBlock", config.dao_block); read_json_config_member(json, "eip150Block", config.tangerine_whistle_block); read_json_config_member(json, "eip155Block", config.spurious_dragon_block); read_json_config_member(json, "byzantiumBlock", config.byzantium_block); read_json_config_member(json, "constantinopleBlock", config.constantinople_block); read_json_config_member(json, "petersburgBlock", config.petersburg_block); read_json_config_member(json, "istanbulBlock", config.istanbul_block); read_json_config_member(json, "muirGlacierBlock", config.muir_glacier_block); read_json_config_member(json, "berlinBlock", config.berlin_block); read_json_config_member(json, "londonBlock", config.london_block); if (json.contains("burntContract")) { std::vector> burnt_contract; for (const auto& item : json["burntContract"].items()) { const BlockNum from{std::stoull(item.key(), nullptr, 0)}; const evmc::address contract{hex_to_address(item.value().get())}; burnt_contract.emplace_back(from, contract); } config.burnt_contract = SmallMap(burnt_contract.begin(), burnt_contract.end()); } read_json_config_member(json, "arrowGlacierBlock", config.arrow_glacier_block); read_json_config_member(json, "grayGlacierBlock", config.gray_glacier_block); if (json.contains(kTerminalTotalDifficulty)) { // We handle terminalTotalDifficulty serialized both as JSON string *and* as JSON number if (json[kTerminalTotalDifficulty].is_string()) { /* This is still present to maintain compatibility with previous Silkworm format */ config.terminal_total_difficulty = intx::from_string(json[kTerminalTotalDifficulty].get()); } else if (json[kTerminalTotalDifficulty].is_number()) { /* This is for compatibility with Erigon that uses a JSON number */ // nlohmann::json treats JSON numbers that overflow 64-bit unsigned integer as floating-point numbers and // intx::uint256 cannot currently be constructed from a floating-point number or string in scientific notation config.terminal_total_difficulty = from_string_sci(json[kTerminalTotalDifficulty].dump().c_str()); } } read_json_config_member(json, "mergeNetsplitBlock", config.merge_netsplit_block); read_json_config_member(json, "shanghaiTime", config.shanghai_time); read_json_config_member(json, "cancunTime", config.cancun_time); read_json_config_member(json, "pragueTime", config.prague_time); /* Note ! genesis_hash is purposely omitted. It must be loaded from db after the * effective genesis block has been persisted */ if (!config.valid_pre_merge_config()) { return std::nullopt; } return config; } bool ChainConfig::withdrawals_activated(BlockTime block_time) const noexcept { return shanghai_time && block_time >= shanghai_time; } bool ChainConfig::is_london(BlockNum block_num) const noexcept { return (london_block && block_num >= london_block); } bool ChainConfig::is_prague(BlockNum block_num, BlockTime block_time) const noexcept { return revision(block_num, block_time) >= EVMC_PRAGUE; } evmc_revision ChainConfig::revision(uint64_t block_num, uint64_t block_time) const noexcept { if (prague_time && block_time >= prague_time) return EVMC_PRAGUE; if (cancun_time && block_time >= cancun_time) return EVMC_CANCUN; if (shanghai_time && block_time >= shanghai_time) return EVMC_SHANGHAI; const auto* bor{std::get_if(&rule_set_config)}; if (bor && block_num >= bor->agra_block) return EVMC_SHANGHAI; if (london_block && block_num >= london_block) return EVMC_LONDON; if (berlin_block && block_num >= berlin_block) return EVMC_BERLIN; if (istanbul_block && block_num >= istanbul_block) return EVMC_ISTANBUL; if (petersburg_block && block_num >= petersburg_block) return EVMC_PETERSBURG; if (constantinople_block && block_num >= constantinople_block) return EVMC_CONSTANTINOPLE; if (byzantium_block && block_num >= byzantium_block) return EVMC_BYZANTIUM; if (spurious_dragon_block && block_num >= spurious_dragon_block) return EVMC_SPURIOUS_DRAGON; if (tangerine_whistle_block && block_num >= tangerine_whistle_block) return EVMC_TANGERINE_WHISTLE; if (homestead_block && block_num >= homestead_block) return EVMC_HOMESTEAD; return EVMC_FRONTIER; } std::vector ChainConfig::distinct_fork_block_nums() const { std::set ret; // Add forks identified by *block number* in ascending order ret.insert(homestead_block.value_or(0)); ret.insert(dao_block.value_or(0)); ret.insert(tangerine_whistle_block.value_or(0)); ret.insert(spurious_dragon_block.value_or(0)); ret.insert(byzantium_block.value_or(0)); ret.insert(constantinople_block.value_or(0)); ret.insert(petersburg_block.value_or(0)); ret.insert(istanbul_block.value_or(0)); ret.insert(muir_glacier_block.value_or(0)); ret.insert(berlin_block.value_or(0)); ret.insert(london_block.value_or(0)); ret.insert(arrow_glacier_block.value_or(0)); ret.insert(gray_glacier_block.value_or(0)); ret.insert(merge_netsplit_block.value_or(0)); if (const auto* bor{std::get_if(&rule_set_config)}; bor) { ret.insert(bor->agra_block); } ret.erase(0); // Block 0 is not a fork number return {ret.cbegin(), ret.cend()}; } std::vector ChainConfig::distinct_fork_times() const { std::set ret; // Add forks identified by *block timestamp* in ascending order ret.insert(shanghai_time.value_or(0)); ret.insert(cancun_time.value_or(0)); ret.insert(prague_time.value_or(0)); ret.erase(0); // Block 0 is not a fork timestamp return {ret.cbegin(), ret.cend()}; } std::vector ChainConfig::distinct_fork_points() const { auto block_nums{distinct_fork_block_nums()}; auto times{distinct_fork_times()}; std::vector points; points.resize(block_nums.size() + times.size()); std::ranges::move(block_nums, points.begin()); std::ranges::move(times, points.begin() + (block_nums.end() - block_nums.begin())); return points; } std::ostream& operator<<(std::ostream& out, const ChainConfig& obj) { return out << obj.to_json(); } constinit const ChainConfig kMainnetConfig{ .chain_id = 1, .homestead_block = 1'150'000, .dao_block = 1'920'000, .tangerine_whistle_block = 2'463'000, .spurious_dragon_block = 2'675'000, .byzantium_block = 4'370'000, .constantinople_block = 7'280'000, .petersburg_block = 7'280'000, .istanbul_block = 9'069'000, .muir_glacier_block = 9'200'000, .berlin_block = 12'244'000, .london_block = 12'965'000, .arrow_glacier_block = 13'773'000, .gray_glacier_block = 15'050'000, .terminal_total_difficulty = intx::from_string("58750000000000000000000"), .shanghai_time = 1681338455, .cancun_time = 1710338135, .rule_set_config = protocol::EthashConfig{}, }; constinit const ChainConfig kHoleskyConfig{ .chain_id = 17000, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 1696000704, .cancun_time = 1707305664, .prague_time = 1740434112, .rule_set_config = protocol::NoPreMergeConfig{}, }; constinit const ChainConfig kSepoliaConfig{ .chain_id = 11155111, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .muir_glacier_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 17000000000000000, .merge_netsplit_block = 1'735'371, .shanghai_time = 1677557088, .cancun_time = 1706655072, .prague_time = 1741159776, .rule_set_config = protocol::EthashConfig{}, }; /* The code literals below were obtained with the following Python script: def to_str_literal(hex): print('"', end='') for i in range(len(hex)//2): print(f'\\x{hex[2*i:2*i+2]}', end ='') print('"') n = 24 while len(code) > 2*n: to_str_literal(code[0:2*n]) code = code[2*n:] to_str_literal(code) */ constinit const ChainConfig kBorMainnetConfig{ .chain_id = 137, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 3'395'000, .muir_glacier_block = 3'395'000, .berlin_block = 14'750'000, .london_block = 23'850'000, .burnt_contract = { {23'850'000, 0x70bca57f4579f58670ab2d18ef16e02c17553c38_address}, {50'523'000, 0x7A8ed27F4C30512326878652d20fC85727401854_address}, }, .rule_set_config = protocol::bor::Config{ .period = {{0, 2}}, .sprint = { {0, 64}, {38'189'056, 16}, }, .validator_contract = 0x0000000000000000000000000000000000001000_address, .rewrite_code = { { 22'156'660, {{ 0x0000000000000000000000000000000000001010_address, "\x60\x80\x60\x40\x52\x60\x04\x36\x10\x61\x01\x9c\x57\x60\x00\x35\x60\xe0\x1c\x80\x63\x77\xd3\x2e" "\x94\x11\x61\x00\xec\x57\x80\x63\xac\xd0\x6c\xb3\x11\x61\x00\x8a\x57\x80\x63\xe3\x06\xf7\x79\x11" "\x61\x00\x64\x57\x80\x63\xe3\x06\xf7\x79\x14\x61\x0a\x7b\x57\x80\x63\xe6\x14\xd0\xd6\x14\x61\x0a" "\xa6\x57\x80\x63\xf2\xfd\xe3\x8b\x14\x61\x0a\xd1\x57\x80\x63\xfc\x0c\x54\x6a\x14\x61\x0b\x22\x57" "\x61\x01\x9c\x56\x5b\x80\x63\xac\xd0\x6c\xb3\x14\x61\x09\x7a\x57\x80\x63\xb7\x89\x54\x3c\x14\x61" "\x09\xcd\x57\x80\x63\xcc\x79\xf9\x7b\x14\x61\x0a\x50\x57\x61\x01\x9c\x56\x5b\x80\x63\x90\x25\xe6" "\x4c\x11\x61\x00\xc6\x57\x80\x63\x90\x25\xe6\x4c\x14\x61\x07\xc9\x57\x80\x63\x95\xd8\x9b\x41\x14" "\x61\x08\x59\x57\x80\x63\xa9\x05\x9c\xbb\x14\x61\x08\xe9\x57\x80\x63\xab\xce\xeb\xa2\x14\x61\x09" "\x4f\x57\x61\x01\x9c\x56\x5b\x80\x63\x77\xd3\x2e\x94\x14\x61\x06\x31\x57\x80\x63\x8d\xa5\xcb\x5b" "\x14\x61\x07\x43\x57\x80\x63\x8f\x32\xd5\x9b\x14\x61\x07\x9a\x57\x61\x01\x9c\x56\x5b\x80\x63\x47" "\xe7\xef\x24\x11\x61\x01\x59\x57\x80\x63\x70\x19\xd4\x1a\x11\x61\x01\x33\x57\x80\x63\x70\x19\xd4" "\x1a\x14\x61\x05\x33\x57\x80\x63\x70\xa0\x82\x31\x14\x61\x05\x8a\x57\x80\x63\x71\x50\x18\xa6\x14" "\x61\x05\xef\x57\x80\x63\x77\x12\x82\xf6\x14\x61\x06\x06\x57\x61\x01\x9c\x56\x5b\x80\x63\x47\xe7" "\xef\x24\x14\x61\x04\x10\x57\x80\x63\x48\x5c\xc9\x55\x14\x61\x04\x6b\x57\x80\x63\x60\xf9\x6a\x8f" "\x14\x61\x04\xdc\x57\x61\x01\x9c\x56\x5b\x80\x63\x06\xfd\xde\x03\x14\x61\x01\xa1\x57\x80\x63\x14" "\x99\xc5\x92\x14\x61\x02\x31\x57\x80\x63\x18\x16\x0d\xdd\x14\x61\x02\x82\x57\x80\x63\x19\xd2\x7d" "\x9c\x14\x61\x02\xad\x57\x80\x63\x2e\x1a\x7d\x4d\x14\x61\x03\xb1\x57\x80\x63\x31\x3c\xe5\x67\x14" "\x61\x03\xdf\x57\x5b\x60\x00\x80\xfd\x5b\x34\x80\x15\x61\x01\xad\x57\x60\x00\x80\xfd\x5b\x50\x61" "\x01\xb6\x61\x0b\x79\x56\x5b\x60\x40\x51\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x83\x81\x81\x51" "\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20\x01\x90\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15" "\x61\x01\xf6\x57\x80\x82\x01\x51\x81\x84\x01\x52\x60\x20\x81\x01\x90\x50\x61\x01\xdb\x56\x5b\x50" "\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x02\x23\x57\x80\x82\x03\x80\x51\x60" "\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b\x50\x92\x50\x50" "\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x02\x3d\x57\x60\x00\x80\xfd\x5b\x50\x61" "\x02\x80\x60\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61\x02\x54\x57\x60\x00\x80\xfd\x5b\x81\x01\x90" "\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\x16\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0b\xb6\x56\x5b\x00\x5b\x34\x80\x15\x61\x02" "\x8e\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x97\x61\x0c\x24\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60" "\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x02\xb9\x57\x60\x00\x80" "\xfd\x5b\x50\x61\x03\x6f\x60\x04\x80\x36\x03\x60\xa0\x81\x10\x15\x61\x02\xd0\x57\x60\x00\x80\xfd" "\x5b\x81\x01\x90\x80\x80\x35\x90\x60\x20\x01\x90\x64\x01\x00\x00\x00\x00\x81\x11\x15\x61\x02\xed" "\x57\x60\x00\x80\xfd\x5b\x82\x01\x83\x60\x20\x82\x01\x11\x15\x61\x02\xff\x57\x60\x00\x80\xfd\x5b" "\x80\x35\x90\x60\x20\x01\x91\x84\x60\x01\x83\x02\x84\x01\x11\x64\x01\x00\x00\x00\x00\x83\x11\x17" "\x15\x61\x03\x21\x57\x60\x00\x80\xfd\x5b\x90\x91\x92\x93\x91\x92\x93\x90\x80\x35\x90\x60\x20\x01" "\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90" "\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16" "\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0c\x3a\x56\x5b\x60\x40\x51\x80\x82\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x91\x50" "\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x61\x03\xdd\x60\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61" "\x03\xc7\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50" "\x50\x61\x0c\xaa\x56\x5b\x00\x5b\x34\x80\x15\x61\x03\xeb\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\xf4" "\x61\x0d\xfc\x56\x5b\x60\x40\x51\x80\x82\x60\xff\x16\x60\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50" "\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x04\x1c\x57\x60\x00\x80\xfd\x5b\x50\x61\x04" "\x69\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61\x04\x33\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80" "\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16" "\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0e\x05" "\x56\x5b\x00\x5b\x34\x80\x15\x61\x04\x77\x57\x60\x00\x80\xfd\x5b\x50\x61\x04\xda\x60\x04\x80\x36" "\x03\x60\x40\x81\x10\x15\x61\x04\x8e\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x35\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90" "\x92\x91\x90\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0f\xc1\x56\x5b\x00\x5b\x34\x80\x15" "\x61\x04\xe8\x57\x60\x00\x80\xfd\x5b\x50\x61\x04\xf1\x61\x10\x90\x56\x5b\x60\x40\x51\x80\x82\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01" "\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x05\x3f\x57\x60\x00\x80\xfd\x5b" "\x50\x61\x05\x48\x61\x10\xb6\x56\x5b\x60\x40\x51\x80\x82\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03" "\x90\xf3\x5b\x34\x80\x15\x61\x05\x96\x57\x60\x00\x80\xfd\x5b\x50\x61\x05\xd9\x60\x04\x80\x36\x03" "\x60\x20\x81\x10\x15\x61\x05\xad\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x35\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90\x92" "\x91\x90\x50\x50\x50\x61\x10\xdc\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60" "\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x05\xfb\x57\x60\x00\x80\xfd\x5b\x50\x61\x06\x04" "\x61\x10\xfd\x56\x5b\x00\x5b\x34\x80\x15\x61\x06\x12\x57\x60\x00\x80\xfd\x5b\x50\x61\x06\x1b\x61" "\x11\xcd\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90" "\xf3\x5b\x34\x80\x15\x61\x06\x3d\x57\x60\x00\x80\xfd\x5b\x50\x61\x07\x01\x60\x04\x80\x36\x03\x60" "\x40\x81\x10\x15\x61\x06\x54\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x35\x90\x60\x20\x01\x90" "\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x64\x01\x00\x00\x00\x00\x81\x11\x15\x61\x06\x7b\x57\x60" "\x00\x80\xfd\x5b\x82\x01\x83\x60\x20\x82\x01\x11\x15\x61\x06\x8d\x57\x60\x00\x80\xfd\x5b\x80\x35" "\x90\x60\x20\x01\x91\x84\x60\x01\x83\x02\x84\x01\x11\x64\x01\x00\x00\x00\x00\x83\x11\x17\x15\x61" "\x06\xaf\x57\x60\x00\x80\xfd\x5b\x91\x90\x80\x80\x60\x1f\x01\x60\x20\x80\x91\x04\x02\x60\x20\x01" "\x60\x40\x51\x90\x81\x01\x60\x40\x52\x80\x93\x92\x91\x90\x81\x81\x52\x60\x20\x01\x83\x83\x80\x82" "\x84\x37\x60\x00\x81\x84\x01\x52\x60\x1f\x19\x60\x1f\x82\x01\x16\x90\x50\x80\x83\x01\x92\x50\x50" "\x50\x50\x50\x50\x50\x91\x92\x91\x92\x90\x50\x50\x50\x61\x11\xd3\x56\x5b\x60\x40\x51\x80\x82\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01" "\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x07\x4f\x57\x60\x00\x80\xfd\x5b" "\x50\x61\x07\x58\x61\x13\x58\x56\x5b\x60\x40\x51\x80\x82\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03" "\x90\xf3\x5b\x34\x80\x15\x61\x07\xa6\x57\x60\x00\x80\xfd\x5b\x50\x61\x07\xaf\x61\x13\x81\x56\x5b" "\x60\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90" "\xf3\x5b\x34\x80\x15\x61\x07\xd5\x57\x60\x00\x80\xfd\x5b\x50\x61\x07\xde\x61\x13\xd8\x56\x5b\x60" "\x40\x51\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80" "\x51\x90\x60\x20\x01\x90\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x08\x1e\x57\x80\x82\x01\x51" "\x81\x84\x01\x52\x60\x20\x81\x01\x90\x50\x61\x08\x03\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01" "\x90\x60\x1f\x16\x80\x15\x61\x08\x4b\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00" "\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b\x50\x92\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90" "\xf3\x5b\x34\x80\x15\x61\x08\x65\x57\x60\x00\x80\xfd\x5b\x50\x61\x08\x6e\x61\x14\x11\x56\x5b\x60" "\x40\x51\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80" "\x51\x90\x60\x20\x01\x90\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x08\xae\x57\x80\x82\x01\x51" "\x81\x84\x01\x52\x60\x20\x81\x01\x90\x50\x61\x08\x93\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01" "\x90\x60\x1f\x16\x80\x15\x61\x08\xdb\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00" "\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b\x50\x92\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90" "\xf3\x5b\x61\x09\x35\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61\x08\xff\x57\x60\x00\x80\xfd\x5b" "\x81\x01\x90\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50" "\x50\x61\x14\x4e\x56\x5b\x60\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60" "\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x09\x5b\x57\x60\x00\x80\xfd\x5b\x50\x61\x09\x64" "\x61\x14\x74\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03" "\x90\xf3\x5b\x34\x80\x15\x61\x09\x86\x57\x60\x00\x80\xfd\x5b\x50\x61\x09\xb3\x60\x04\x80\x36\x03" "\x60\x20\x81\x10\x15\x61\x09\x9d\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x35\x90\x60\x20\x01" "\x90\x92\x91\x90\x50\x50\x50\x61\x15\x01\x56\x5b\x60\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52\x60" "\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x09\xd9\x57\x60\x00\x80" "\xfd\x5b\x50\x61\x0a\x3a\x60\x04\x80\x36\x03\x60\x80\x81\x10\x15\x61\x09\xf0\x57\x60\x00\x80\xfd" "\x5b\x81\x01\x90\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x80" "\x35\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x15" "\x21\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3" "\x5b\x34\x80\x15\x61\x0a\x5c\x57\x60\x00\x80\xfd\x5b\x50\x61\x0a\x65\x61\x15\x41\x56\x5b\x60\x40" "\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61" "\x0a\x87\x57\x60\x00\x80\xfd\x5b\x50\x61\x0a\x90\x61\x15\x46\x56\x5b\x60\x40\x51\x80\x82\x81\x52" "\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x0a\xb2\x57\x60\x00" "\x80\xfd\x5b\x50\x61\x0a\xbb\x61\x15\x4c\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50" "\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x0a\xdd\x57\x60\x00\x80\xfd\x5b\x50\x61" "\x0b\x20\x60\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61\x0a\xf4\x57\x60\x00\x80\xfd\x5b\x81\x01\x90" "\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\x16\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x15\xd9\x56\x5b\x00\x5b\x34\x80\x15\x61\x0b" "\x2e\x57\x60\x00\x80\xfd\x5b\x50\x61\x0b\x37\x61\x15\xf6\x56\x5b\x60\x40\x51\x80\x82\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x91\x50" "\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x60\x60\x60\x40\x51\x80\x60\x40\x01\x60\x40\x52\x80\x60" "\x0b\x81\x52\x60\x20\x01\x7f\x4d\x61\x74\x69\x63\x20\x54\x6f\x6b\x65\x6e\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x52\x50\x90\x50\x90\x56\x5b\x60" "\x40\x51\x7f\x08\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03" "\x82\x52\x60\x10\x81\x52\x60\x20\x01\x80\x7f\x44\x69\x73\x61\x62\x6c\x65\x64\x20\x66\x65\x61\x74" "\x75\x72\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x52\x50\x60\x20" "\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x00\x60\x12\x60\xff\x16\x60\x0a\x0a\x64" "\x02\x54\x0b\xe4\x00\x02\x90\x50\x90\x56\x5b\x60\x00\x60\x40\x51\x7f\x08\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x60\x10\x81\x52\x60\x20\x01\x80" "\x7f\x44\x69\x73\x61\x62\x6c\x65\x64\x20\x66\x65\x61\x74\x75\x72\x65\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x52\x50\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03" "\x90\xfd\x5b\x60\x00\x33\x90\x50\x60\x00\x61\x0c\xba\x82\x61\x10\xdc\x56\x5b\x90\x50\x61\x0c\xd1" "\x83\x60\x06\x54\x61\x16\x1c\x90\x91\x90\x63\xff\xff\xff\xff\x16\x56\x5b\x60\x06\x81\x90\x55\x50" "\x60\x00\x83\x11\x80\x15\x61\x0c\xe6\x57\x50\x82\x34\x14\x5b\x61\x0d\x58\x57\x60\x40\x51\x7f\x08" "\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x60\x13" "\x81\x52\x60\x20\x01\x80\x7f\x49\x6e\x73\x75\x66\x66\x69\x63\x69\x65\x6e\x74\x20\x61\x6d\x6f\x75" "\x6e\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x52\x50\x60\x20\x01\x91\x50\x50" "\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x81\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\x16\x60\x02\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\xeb\xff\x26\x02\xb3\xf4" "\x68\x25\x9e\x1e\x99\xf6\x13\xfe\xd6\x69\x1f\x3a\x65\x26\xef\xfe\x6e\xf3\xe7\x68\xba\x7a\xe7\xa3" "\x6c\x4f\x85\x84\x61\x0d\xd4\x87\x61\x10\xdc\x56\x5b\x60\x40\x51\x80\x84\x81\x52\x60\x20\x01\x83" "\x81\x52\x60\x20\x01\x82\x81\x52\x60\x20\x01\x93\x50\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa3" "\x50\x50\x50\x56\x5b\x60\x00\x60\x12\x90\x50\x90\x56\x5b\x61\x0e\x0d\x61\x13\x81\x56\x5b\x61\x0e" "\x16\x57\x60\x00\x80\xfd\x5b\x60\x00\x81\x11\x80\x15\x61\x0e\x53\x57\x50\x60\x00\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x82\x73\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x14\x15\x5b\x61\x0e\xa8\x57" "\x60\x40\x51\x7f\x08\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81" "\x03\x82\x52\x60\x23\x81\x52\x60\x20\x01\x80\x61\x1d\xa7\x60\x23\x91\x39\x60\x40\x01\x91\x50\x50" "\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x00\x61\x0e\xb3\x83\x61\x10\xdc\x56\x5b\x90\x50\x60\x00" "\x83\x90\x50\x80\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\x16\x61\x08\xfc\x84\x90\x81\x15\x02\x90\x60\x40\x51\x60\x00\x60\x40\x51\x80\x83\x03\x81\x85" "\x88\x88\xf1\x93\x50\x50\x50\x50\x15\x80\x15\x61\x0f\x00\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd" "\x5b\x50\x61\x0f\x16\x83\x60\x06\x54\x61\x16\x3c\x90\x91\x90\x63\xff\xff\xff\xff\x16\x56\x5b\x60" "\x06\x81\x90\x55\x50\x83\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x60\x02\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\x4e\x2c\xa0\x51\x5e\xd1\xae\xf1\x39\x5f" "\x66\xb5\x30\x3b\xb5\xd6\xf1\xbf\x9d\x61\xa3\x53\xfa\x53\xf7\x3f\x8a\xc9\x97\x3f\xa9\xf6\x85\x85" "\x61\x0f\x98\x89\x61\x10\xdc\x56\x5b\x60\x40\x51\x80\x84\x81\x52\x60\x20\x01\x83\x81\x52\x60\x20" "\x01\x82\x81\x52\x60\x20\x01\x93\x50\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa3\x50\x50\x50\x50" "\x56\x5b\x60\x07\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x60\xff\x16\x15\x61\x10\x27\x57\x60" "\x40\x51\x7f\x08\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03" "\x82\x52\x60\x23\x81\x52\x60\x20\x01\x80\x61\x1d\x84\x60\x23\x91\x39\x60\x40\x01\x91\x50\x50\x60" "\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x01\x60\x07\x60\x00\x61\x01\x00\x0a\x81\x54\x81\x60\xff\x02" "\x19\x16\x90\x83\x15\x15\x02\x17\x90\x55\x50\x80\x60\x02\x60\x00\x61\x01\x00\x0a\x81\x54\x81\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x19\x16\x90" "\x83\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x02" "\x17\x90\x55\x50\x61\x10\x8c\x82\x61\x16\x5b\x56\x5b\x50\x50\x56\x5b\x60\x03\x60\x00\x90\x54\x90" "\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x81\x56\x5b\x60\x04\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x56\x5b\x60\x00\x81" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x31\x90" "\x50\x91\x90\x50\x56\x5b\x61\x11\x05\x61\x13\x81\x56\x5b\x61\x11\x0e\x57\x60\x00\x80\xfd\x5b\x60" "\x00\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x60" "\x00\x80\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\x16\x7f\x8b\xe0\x07\x9c\x53\x16\x59\x14\x13\x44\xcd\x1f\xd0\xa4\xf2\x84" "\x19\x49\x7f\x97\x22\xa3\xda\xaf\xe3\xb4\x18\x6f\x6b\x64\x57\xe0\x60\x40\x51\x60\x40\x51\x80\x91" "\x03\x90\xa3\x60\x00\x80\x60\x00\x61\x01\x00\x0a\x81\x54\x81\x73\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x19\x16\x90\x83\x73\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x02\x17\x90\x55\x50\x56\x5b\x60\x06" "\x54\x81\x56\x5b\x60\x00\x80\x60\x00\x80\x60\x41\x85\x51\x14\x61\x11\xee\x57\x60\x00\x93\x50\x50" "\x50\x50\x61\x13\x52\x56\x5b\x60\x20\x85\x01\x51\x92\x50\x60\x40\x85\x01\x51\x91\x50\x60\xff\x60" "\x41\x86\x01\x51\x16\x90\x50\x60\x1b\x81\x60\xff\x16\x10\x15\x61\x12\x19\x57\x60\x1b\x81\x01\x90" "\x50\x5b\x60\x1b\x81\x60\xff\x16\x14\x15\x80\x15\x61\x12\x31\x57\x50\x60\x1c\x81\x60\xff\x16\x14" "\x15\x5b\x15\x61\x12\x42\x57\x60\x00\x93\x50\x50\x50\x50\x61\x13\x52\x56\x5b\x60\x01\x86\x82\x85" "\x85\x60\x40\x51\x60\x00\x81\x52\x60\x20\x01\x60\x40\x52\x60\x40\x51\x80\x85\x81\x52\x60\x20\x01" "\x84\x60\xff\x16\x60\xff\x16\x81\x52\x60\x20\x01\x83\x81\x52\x60\x20\x01\x82\x81\x52\x60\x20\x01" "\x94\x50\x50\x50\x50\x50\x60\x20\x60\x40\x51\x60\x20\x81\x03\x90\x80\x84\x03\x90\x85\x5a\xfa\x15" "\x80\x15\x61\x12\x9f\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50\x60\x20\x60\x40\x51" "\x03\x51\x93\x50\x60\x00\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x84\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x14\x15\x61\x13\x4e\x57\x60\x40\x51\x7f\x08\xc3\x79\xa0\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\x81\x52\x60" "\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x60\x12\x81\x52\x60\x20\x01\x80\x7f\x45\x72\x72" "\x6f\x72\x20\x69\x6e\x20\x65\x63\x72\x65\x63\x6f\x76\x65\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x81\x52\x50\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x50" "\x50\x50\x5b\x92\x91\x50\x50\x56\x5b\x60\x00\x80\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x50\x90" "\x56\x5b\x60\x00\x80\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x14\x90\x50\x90\x56\x5b\x60\x40\x51\x80\x60\x40\x01" "\x60\x40\x52\x80\x60\x01\x81\x52\x60\x20\x01\x7f\x89\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\x81\x52\x50\x81" "\x56\x5b\x60\x60\x60\x40\x51\x80\x60\x40\x01\x60\x40\x52\x80\x60\x05\x81\x52\x60\x20\x01\x7f\x4d" "\x41\x54\x49\x43\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\x81\x52\x50\x90\x50\x90\x56\x5b\x60\x00\x81\x34\x14\x61\x14\x60\x57" "\x60\x00\x90\x50\x61\x14\x6e\x56\x5b\x61\x14\x6b\x33\x84\x84\x61\x17\x53\x56\x5b\x90\x50\x5b\x92" "\x91\x50\x50\x56\x5b\x60\x40\x51\x80\x60\x80\x01\x60\x40\x52\x80\x60\x5b\x81\x52\x60\x20\x01\x61" "\x1e\x1c\x60\x5b\x91\x39\x60\x40\x51\x60\x20\x01\x80\x82\x80\x51\x90\x60\x20\x01\x90\x80\x83\x83" "\x5b\x60\x20\x83\x10\x61\x14\xc3\x57\x80\x51\x82\x52\x60\x20\x82\x01\x91\x50\x60\x20\x81\x01\x90" "\x50\x60\x20\x83\x03\x92\x50\x61\x14\xa0\x56\x5b\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x80" "\x19\x82\x51\x16\x81\x84\x51\x16\x80\x82\x17\x85\x52\x50\x50\x50\x50\x50\x50\x90\x50\x01\x91\x50" "\x50\x60\x40\x51\x60\x20\x81\x83\x03\x03\x81\x52\x90\x60\x40\x52\x80\x51\x90\x60\x20\x01\x20\x81" "\x56\x5b\x60\x05\x60\x20\x52\x80\x60\x00\x52\x60\x40\x60\x00\x20\x60\x00\x91\x50\x54\x90\x61\x01" "\x00\x0a\x90\x04\x60\xff\x16\x81\x56\x5b\x60\x00\x61\x15\x37\x61\x15\x32\x86\x86\x86\x86\x61\x1b" "\x10\x56\x5b\x61\x1b\xe6\x56\x5b\x90\x50\x94\x93\x50\x50\x50\x50\x56\x5b\x60\x89\x81\x56\x5b\x60" "\x01\x54\x81\x56\x5b\x60\x40\x51\x80\x60\x80\x01\x60\x40\x52\x80\x60\x52\x81\x52\x60\x20\x01\x61" "\x1d\xca\x60\x52\x91\x39\x60\x40\x51\x60\x20\x01\x80\x82\x80\x51\x90\x60\x20\x01\x90\x80\x83\x83" "\x5b\x60\x20\x83\x10\x61\x15\x9b\x57\x80\x51\x82\x52\x60\x20\x82\x01\x91\x50\x60\x20\x81\x01\x90" "\x50\x60\x20\x83\x03\x92\x50\x61\x15\x78\x56\x5b\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x80" "\x19\x82\x51\x16\x81\x84\x51\x16\x80\x82\x17\x85\x52\x50\x50\x50\x50\x50\x50\x90\x50\x01\x91\x50" "\x50\x60\x40\x51\x60\x20\x81\x83\x03\x03\x81\x52\x90\x60\x40\x52\x80\x51\x90\x60\x20\x01\x20\x81" "\x56\x5b\x61\x15\xe1\x61\x13\x81\x56\x5b\x61\x15\xea\x57\x60\x00\x80\xfd\x5b\x61\x15\xf3\x81\x61" "\x16\x5b\x56\x5b\x50\x56\x5b\x60\x02\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x56\x5b\x60\x00\x82" "\x82\x11\x15\x61\x16\x2b\x57\x60\x00\x80\xfd\x5b\x60\x00\x82\x84\x03\x90\x50\x80\x91\x50\x50\x92" "\x91\x50\x50\x56\x5b\x60\x00\x80\x82\x84\x01\x90\x50\x83\x81\x10\x15\x61\x16\x51\x57\x60\x00\x80" "\xfd\x5b\x80\x91\x50\x50\x92\x91\x50\x50\x56\x5b\x60\x00\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x14\x15\x61\x16\x95\x57\x60\x00\x80\xfd\x5b\x80\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x60\x00\x80" "\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\x16\x7f\x8b\xe0\x07\x9c\x53\x16\x59\x14\x13\x44\xcd\x1f\xd0\xa4\xf2\x84\x19\x49" "\x7f\x97\x22\xa3\xda\xaf\xe3\xb4\x18\x6f\x6b\x64\x57\xe0\x60\x40\x51\x60\x40\x51\x80\x91\x03\x90" "\xa3\x80\x60\x00\x80\x61\x01\x00\x0a\x81\x54\x81\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x19\x16\x90\x83\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x02\x17\x90\x55\x50\x50\x56\x5b\x60\x00\x80\x30" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x63\x70" "\xa0\x82\x31\x86\x60\x40\x51\x82\x63\xff\xff\xff\xff\x16\x60\xe0\x1b\x81\x52\x60\x04\x01\x80\x82" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20" "\x01\x91\x50\x50\x60\x20\x60\x40\x51\x80\x83\x03\x81\x86\x80\x3b\x15\x80\x15\x61\x17\xd3\x57\x60" "\x00\x80\xfd\x5b\x50\x5a\xfa\x15\x80\x15\x61\x17\xe7\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b" "\x50\x50\x50\x50\x60\x40\x51\x3d\x60\x20\x81\x10\x15\x61\x17\xfd\x57\x60\x00\x80\xfd\x5b\x81\x01" "\x90\x80\x80\x51\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x90\x50\x60\x00\x30\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x63\x70\xa0\x82\x31\x86" "\x60\x40\x51\x82\x63\xff\xff\xff\xff\x16\x60\xe0\x1b\x81\x52\x60\x04\x01\x80\x82\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50" "\x60\x20\x60\x40\x51\x80\x83\x03\x81\x86\x80\x3b\x15\x80\x15\x61\x18\x8f\x57\x60\x00\x80\xfd\x5b" "\x50\x5a\xfa\x15\x80\x15\x61\x18\xa3\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50\x50" "\x60\x40\x51\x3d\x60\x20\x81\x10\x15\x61\x18\xb9\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x51" "\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x90\x50\x61\x18\xd7\x86\x86\x86\x61\x1c\x30\x56\x5b" "\x84\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x86" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x60\x02" "\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\x16\x7f\xe6\x49\x7e\x3e\xe5\x48\xa3\x37\x21\x36\xaf\x2f\xcb\x06\x96\xdb" "\x31\xfc\x6c\xf2\x02\x60\x70\x76\x45\x06\x8b\xd3\xfe\x97\xf3\xc4\x87\x86\x86\x30\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x63\x70\xa0\x82\x31\x8e" "\x60\x40\x51\x82\x63\xff\xff\xff\xff\x16\x60\xe0\x1b\x81\x52\x60\x04\x01\x80\x82\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50" "\x60\x20\x60\x40\x51\x80\x83\x03\x81\x86\x80\x3b\x15\x80\x15\x61\x19\xdf\x57\x60\x00\x80\xfd\x5b" "\x50\x5a\xfa\x15\x80\x15\x61\x19\xf3\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50\x50" "\x60\x40\x51\x3d\x60\x20\x81\x10\x15\x61\x1a\x09\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x51" "\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x30\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x63\x70\xa0\x82\x31\x8e\x60\x40\x51\x82\x63\xff\xff\xff" "\xff\x16\x60\xe0\x1b\x81\x52\x60\x04\x01\x80\x82\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50\x60\x20\x60\x40\x51\x80\x83\x03" "\x81\x86\x80\x3b\x15\x80\x15\x61\x1a\x97\x57\x60\x00\x80\xfd\x5b\x50\x5a\xfa\x15\x80\x15\x61\x1a" "\xab\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50\x50\x60\x40\x51\x3d\x60\x20\x81\x10" "\x15\x61\x1a\xc1\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x80\x80\x51\x90\x60\x20\x01\x90\x92\x91\x90" "\x50\x50\x50\x60\x40\x51\x80\x86\x81\x52\x60\x20\x01\x85\x81\x52\x60\x20\x01\x84\x81\x52\x60\x20" "\x01\x83\x81\x52\x60\x20\x01\x82\x81\x52\x60\x20\x01\x95\x50\x50\x50\x50\x50\x50\x60\x40\x51\x80" "\x91\x03\x90\xa4\x60\x01\x92\x50\x50\x50\x93\x92\x50\x50\x50\x56\x5b\x60\x00\x80\x60\x40\x51\x80" "\x60\x80\x01\x60\x40\x52\x80\x60\x5b\x81\x52\x60\x20\x01\x61\x1e\x1c\x60\x5b\x91\x39\x60\x40\x51" "\x60\x20\x01\x80\x82\x80\x51\x90\x60\x20\x01\x90\x80\x83\x83\x5b\x60\x20\x83\x10\x61\x1b\x62\x57" "\x80\x51\x82\x52\x60\x20\x82\x01\x91\x50\x60\x20\x81\x01\x90\x50\x60\x20\x83\x03\x92\x50\x61\x1b" "\x3f\x56\x5b\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x80\x19\x82\x51\x16\x81\x84\x51\x16\x80" "\x82\x17\x85\x52\x50\x50\x50\x50\x50\x50\x90\x50\x01\x91\x50\x50\x60\x40\x51\x60\x20\x81\x83\x03" "\x03\x81\x52\x90\x60\x40\x52\x80\x51\x90\x60\x20\x01\x20\x90\x50\x60\x40\x51\x81\x81\x52\x73\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x16\x60\x20\x82" "\x01\x52\x85\x60\x40\x82\x01\x52\x84\x60\x60\x82\x01\x52\x83\x60\x80\x82\x01\x52\x60\xa0\x81\x20" "\x92\x50\x50\x81\x91\x50\x50\x94\x93\x50\x50\x50\x50\x56\x5b\x60\x00\x80\x60\x01\x54\x90\x50\x60" "\x40\x51\x7f\x19\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x52\x81\x60\x02\x82\x01\x52\x83\x60\x22\x82\x01" "\x52\x60\x42\x81\x20\x92\x50\x50\x81\x91\x50\x50\x91\x90\x50\x56\x5b\x30\x73\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x82\x73\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x14\x15\x61\x1c\xd2\x57\x60\x40\x51" "\x7f\x08\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52" "\x60\x13\x81\x52\x60\x20\x01\x80\x7f\x63\x61\x6e\x27\x74\x20\x73\x65\x6e\x64\x20\x74\x6f\x20\x4d" "\x52\x43\x32\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x52\x50\x60\x20\x01\x91" "\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x81\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x61\x08\xfc\x82\x90\x81\x15\x02\x90\x60\x40\x51\x60\x00" "\x60\x40\x51\x80\x83\x03\x81\x85\x88\x88\xf1\x93\x50\x50\x50\x50\x15\x80\x15\x61\x1d\x18\x57\x3d" "\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x81\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\x16\x83\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\x16\x7f\xdd\xf2\x52\xad\x1b\xe2\xc8\x9b\x69\xc2\xb0\x68\xfc\x37\x8d" "\xaa\x95\x2b\xa7\xf1\x63\xc4\xa1\x16\x28\xf5\x5a\x4d\xf5\x23\xb3\xef\x83\x60\x40\x51\x80\x82\x81" "\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa3\x50\x50\x50\x56\xfe\x54\x68\x65\x20" "\x63\x6f\x6e\x74\x72\x61\x63\x74\x20\x69\x73\x20\x61\x6c\x72\x65\x61\x64\x79\x20\x69\x6e\x69\x74" "\x69\x61\x6c\x69\x7a\x65\x64\x49\x6e\x73\x75\x66\x66\x69\x63\x69\x65\x6e\x74\x20\x61\x6d\x6f\x75" "\x6e\x74\x20\x6f\x72\x20\x69\x6e\x76\x61\x6c\x69\x64\x20\x75\x73\x65\x72\x45\x49\x50\x37\x31\x32" "\x44\x6f\x6d\x61\x69\x6e\x28\x73\x74\x72\x69\x6e\x67\x20\x6e\x61\x6d\x65\x2c\x73\x74\x72\x69\x6e" "\x67\x20\x76\x65\x72\x73\x69\x6f\x6e\x2c\x75\x69\x6e\x74\x32\x35\x36\x20\x63\x68\x61\x69\x6e\x49" "\x64\x2c\x61\x64\x64\x72\x65\x73\x73\x20\x76\x65\x72\x69\x66\x79\x69\x6e\x67\x43\x6f\x6e\x74\x72" "\x61\x63\x74\x29\x54\x6f\x6b\x65\x6e\x54\x72\x61\x6e\x73\x66\x65\x72\x4f\x72\x64\x65\x72\x28\x61" "\x64\x64\x72\x65\x73\x73\x20\x73\x70\x65\x6e\x64\x65\x72\x2c\x75\x69\x6e\x74\x32\x35\x36\x20\x74" "\x6f\x6b\x65\x6e\x49\x64\x4f\x72\x41\x6d\x6f\x75\x6e\x74\x2c\x62\x79\x74\x65\x73\x33\x32\x20\x64" "\x61\x74\x61\x2c\x75\x69\x6e\x74\x32\x35\x36\x20\x65\x78\x70\x69\x72\x61\x74\x69\x6f\x6e\x29\xa2" "\x65\x62\x7a\x7a\x72\x31\x58\x20\xa4\xa6\xf7\x1a\x98\xac\x3f\xc6\x13\xc3\xa8\xf1\xe2\xe1\x1b\x9e" "\xb9\xb6\xb3\x9f\x12\x5f\x7d\x95\x08\x91\x6c\x2b\x8f\xb0\x2c\x71\x64\x73\x6f\x6c\x63\x43\x00\x05" "\x10\x00\x32"sv, }}, }, { 50'523'000, {{ 0x0000000000000000000000000000000000001001_address, "\x60\x80\x60\x40\x52\x34\x80\x15\x61\x00\x10\x57\x60\x00\x80\xfd\x5b\x50\x60\x04\x36\x10\x61\x00" "\x5e\x57\x60\x00\x35\x7c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x04\x80\x63\x19\x49\x4a\x17\x14\x61\x00\x63\x57" "\x80\x63\x34\x34\x73\x5f\x14\x61\x00\xfe\x57\x80\x63\x54\x07\xca\x67\x14\x61\x01\x48\x57\x5b\x60" "\x00\x80\xfd\x5b\x61\x00\xe4\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61\x00\x79\x57\x60\x00\x80" "\xfd\x5b\x81\x01\x90\x80\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x64" "\x01\x00\x00\x00\x00\x81\x11\x15\x61\x00\xa0\x57\x60\x00\x80\xfd\x5b\x82\x01\x83\x60\x20\x82\x01" "\x11\x15\x61\x00\xb2\x57\x60\x00\x80\xfd\x5b\x80\x35\x90\x60\x20\x01\x91\x84\x60\x01\x83\x02\x84" "\x01\x11\x64\x01\x00\x00\x00\x00\x83\x11\x17\x15\x61\x00\xd4\x57\x60\x00\x80\xfd\x5b\x90\x91\x92" "\x93\x91\x92\x93\x90\x50\x50\x50\x61\x01\x66\x56\x5b\x60\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52" "\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x61\x01\x06\x61\x04\xd3\x56\x5b\x60" "\x40\x51\x80\x82\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16" "\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x61\x01\x50\x61\x04\xeb\x56" "\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x60" "\x00\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\x73\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x33\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x14\x61\x02\x1d\x57" "\x60\x40\x51\x7f\x08\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81" "\x03\x82\x52\x60\x12\x81\x52\x60\x20\x01\x80\x7f\x4e\x6f\x74\x20\x53\x79\x73\x74\x65\x6d\x20\x41" "\x64\x64\x65\x73\x73\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x52\x50\x60" "\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x60\x61\x02\x74\x61\x02\x6f\x85\x85" "\x80\x80\x60\x1f\x01\x60\x20\x80\x91\x04\x02\x60\x20\x01\x60\x40\x51\x90\x81\x01\x60\x40\x52\x80" "\x93\x92\x91\x90\x81\x81\x52\x60\x20\x01\x83\x83\x80\x82\x84\x37\x60\x00\x81\x84\x01\x52\x60\x1f" "\x19\x60\x1f\x82\x01\x16\x90\x50\x80\x83\x01\x92\x50\x50\x50\x50\x50\x50\x50\x61\x04\xf1\x56\x5b" "\x61\x05\x1f\x56\x5b\x90\x50\x60\x00\x61\x02\x95\x82\x60\x00\x81\x51\x81\x10\x61\x02\x88\x57\xfe" "\x5b\x60\x20\x02\x60\x20\x01\x01\x51\x61\x05\xfc\x56\x5b\x90\x50\x80\x60\x01\x60\x00\x54\x01\x14" "\x61\x03\x11\x57\x60\x40\x51\x7f\x08\xc3\x79\xa0\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\x81\x52\x60\x04\x01\x80\x80\x60" "\x20\x01\x82\x81\x03\x82\x52\x60\x1b\x81\x52\x60\x20\x01\x80\x7f\x53\x74\x61\x74\x65\x49\x64\x73" "\x20\x61\x72\x65\x20\x6e\x6f\x74\x20\x73\x65\x71\x75\x65\x6e\x74\x69\x61\x6c\x00\x00\x00\x00\x00" "\x81\x52\x50\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x00\x80\x81\x54\x80" "\x92\x91\x90\x60\x01\x01\x91\x90\x50\x55\x50\x60\x00\x61\x03\x41\x83\x60\x01\x81\x51\x81\x10\x61" "\x03\x34\x57\xfe\x5b\x60\x20\x02\x60\x20\x01\x01\x51\x61\x06\x6d\x56\x5b\x90\x50\x60\x60\x61\x03" "\x62\x84\x60\x02\x81\x51\x81\x10\x61\x03\x55\x57\xfe\x5b\x60\x20\x02\x60\x20\x01\x01\x51\x61\x06" "\x90\x56\x5b\x90\x50\x61\x03\x6d\x82\x61\x07\x1c\x56\x5b\x15\x61\x04\xc8\x57\x60\x00\x62\x4c\x4b" "\x40\x90\x50\x60\x60\x84\x83\x60\x40\x51\x60\x24\x01\x80\x83\x81\x52\x60\x20\x01\x80\x60\x20\x01" "\x82\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20\x01\x90\x80" "\x83\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x03\xc7\x57\x80\x82\x01\x51\x81\x84\x01\x52\x60\x20\x81" "\x01\x90\x50\x61\x03\xac\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61" "\x03\xf4\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60" "\x20\x01\x91\x50\x5b\x50\x93\x50\x50\x50\x50\x60\x40\x51\x60\x20\x81\x83\x03\x03\x81\x52\x90\x60" "\x40\x52\x7f\x26\xc5\x3b\xea\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\x7b\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\x19\x16\x60\x20\x82\x01\x80\x51" "\x7b\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\x83\x81\x83\x16\x17\x83\x52\x50\x50\x50\x50\x90\x50\x60\x00\x80\x82\x51\x60" "\x20\x84\x01\x60\x00\x88\x87\xf1\x96\x50\x84\x7f\x5a\x22\x72\x55\x90\xb0\xa5\x1c\x92\x39\x40\x22" "\x3f\x74\x58\x51\x21\x64\xb1\x11\x33\x59\xa7\x35\xe8\x6e\x7f\x27\xf4\x47\x91\xee\x88\x60\x40\x51" "\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa2\x50\x50" "\x5b\x50\x50\x50\x50\x93\x92\x50\x50\x50\x56\x5b\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xfe\x81\x56\x5b\x60\x00\x54\x81\x56\x5b\x61\x04\xf9\x61\x09\x9c" "\x56\x5b\x60\x00\x60\x20\x83\x01\x90\x50\x60\x40\x51\x80\x60\x40\x01\x60\x40\x52\x80\x84\x51\x81" "\x52\x60\x20\x01\x82\x81\x52\x50\x91\x50\x50\x91\x90\x50\x56\x5b\x60\x60\x61\x05\x2a\x82\x61\x07" "\x35\x56\x5b\x61\x05\x33\x57\x60\x00\x80\xfd\x5b\x60\x00\x61\x05\x3e\x83\x61\x07\x83\x56\x5b\x90" "\x50\x60\x60\x81\x60\x40\x51\x90\x80\x82\x52\x80\x60\x20\x02\x60\x20\x01\x82\x01\x60\x40\x52\x80" "\x15\x61\x05\x7c\x57\x81\x60\x20\x01\x5b\x61\x05\x69\x61\x09\xb6\x56\x5b\x81\x52\x60\x20\x01\x90" "\x60\x01\x90\x03\x90\x81\x61\x05\x61\x57\x90\x50\x5b\x50\x90\x50\x60\x00\x61\x05\x8e\x85\x60\x20" "\x01\x51\x61\x07\xf4\x56\x5b\x85\x60\x20\x01\x51\x01\x90\x50\x60\x00\x80\x60\x00\x90\x50\x5b\x84" "\x81\x10\x15\x61\x05\xef\x57\x61\x05\xaf\x83\x61\x08\x7d\x56\x5b\x91\x50\x60\x40\x51\x80\x60\x40" "\x01\x60\x40\x52\x80\x83\x81\x52\x60\x20\x01\x84\x81\x52\x50\x84\x82\x81\x51\x81\x10\x61\x05\xd2" "\x57\xfe\x5b\x60\x20\x02\x60\x20\x01\x01\x81\x90\x52\x50\x81\x83\x01\x92\x50\x80\x80\x60\x01\x01" "\x91\x50\x50\x61\x05\x9e\x56\x5b\x50\x82\x94\x50\x50\x50\x50\x50\x91\x90\x50\x56\x5b\x60\x00\x80" "\x82\x60\x00\x01\x51\x11\x80\x15\x61\x06\x16\x57\x50\x60\x21\x82\x60\x00\x01\x51\x11\x15\x5b\x61" "\x06\x1f\x57\x60\x00\x80\xfd\x5b\x60\x00\x61\x06\x2e\x83\x60\x20\x01\x51\x61\x07\xf4\x56\x5b\x90" "\x50\x60\x00\x81\x84\x60\x00\x01\x51\x03\x90\x50\x60\x00\x80\x83\x86\x60\x20\x01\x51\x01\x90\x50" "\x80\x51\x91\x50\x60\x20\x83\x10\x15\x61\x06\x61\x57\x82\x60\x20\x03\x61\x01\x00\x0a\x82\x04\x91" "\x50\x5b\x81\x94\x50\x50\x50\x50\x50\x91\x90\x50\x56\x5b\x60\x00\x60\x15\x82\x60\x00\x01\x51\x14" "\x61\x06\x80\x57\x60\x00\x80\xfd\x5b\x61\x06\x89\x82\x61\x05\xfc\x56\x5b\x90\x50\x91\x90\x50\x56" "\x5b\x60\x60\x60\x00\x82\x60\x00\x01\x51\x11\x61\x06\xa3\x57\x60\x00\x80\xfd\x5b\x60\x00\x61\x06" "\xb2\x83\x60\x20\x01\x51\x61\x07\xf4\x56\x5b\x90\x50\x60\x00\x81\x84\x60\x00\x01\x51\x03\x90\x50" "\x60\x60\x81\x60\x40\x51\x90\x80\x82\x52\x80\x60\x1f\x01\x60\x1f\x19\x16\x60\x20\x01\x82\x01\x60" "\x40\x52\x80\x15\x61\x06\xf4\x57\x81\x60\x20\x01\x60\x01\x82\x02\x80\x38\x83\x39\x80\x82\x01\x91" "\x50\x50\x90\x50\x5b\x50\x90\x50\x60\x00\x81\x60\x20\x01\x90\x50\x61\x07\x10\x84\x87\x60\x20\x01" "\x51\x01\x82\x85\x61\x09\x35\x56\x5b\x81\x94\x50\x50\x50\x50\x50\x91\x90\x50\x56\x5b\x60\x00\x80" "\x82\x3b\x90\x50\x60\x00\x81\x63\xff\xff\xff\xff\x16\x11\x91\x50\x50\x91\x90\x50\x56\x5b\x60\x00" "\x80\x82\x60\x00\x01\x51\x14\x15\x61\x07\x4c\x57\x60\x00\x90\x50\x61\x07\x7e\x56\x5b\x60\x00\x80" "\x83\x60\x20\x01\x51\x90\x50\x80\x51\x60\x00\x1a\x91\x50\x60\xc0\x60\xff\x16\x82\x60\xff\x16\x10" "\x15\x61\x07\x77\x57\x60\x00\x92\x50\x50\x50\x61\x07\x7e\x56\x5b\x60\x01\x92\x50\x50\x50\x5b\x91" "\x90\x50\x56\x5b\x60\x00\x80\x82\x60\x00\x01\x51\x14\x15\x61\x07\x9a\x57\x60\x00\x90\x50\x61\x07" "\xef\x56\x5b\x60\x00\x80\x90\x50\x60\x00\x61\x07\xae\x84\x60\x20\x01\x51\x61\x07\xf4\x56\x5b\x84" "\x60\x20\x01\x51\x01\x90\x50\x60\x00\x84\x60\x00\x01\x51\x85\x60\x20\x01\x51\x01\x90\x50\x5b\x80" "\x82\x10\x15\x61\x07\xe8\x57\x61\x07\xd7\x82\x61\x08\x7d\x56\x5b\x82\x01\x91\x50\x82\x80\x60\x01" "\x01\x93\x50\x50\x61\x07\xc6\x56\x5b\x82\x93\x50\x50\x50\x50\x5b\x91\x90\x50\x56\x5b\x60\x00\x80" "\x82\x51\x60\x00\x1a\x90\x50\x60\x80\x60\xff\x16\x81\x10\x15\x61\x08\x14\x57\x60\x00\x91\x50\x50" "\x61\x08\x78\x56\x5b\x60\xb8\x60\xff\x16\x81\x10\x80\x61\x08\x39\x57\x50\x60\xc0\x60\xff\x16\x81" "\x10\x15\x80\x15\x61\x08\x38\x57\x50\x60\xf8\x60\xff\x16\x81\x10\x5b\x5b\x15\x61\x08\x48\x57\x60" "\x01\x91\x50\x50\x61\x08\x78\x56\x5b\x60\xc0\x60\xff\x16\x81\x10\x15\x61\x08\x68\x57\x60\x01\x80" "\x60\xb8\x03\x60\xff\x16\x82\x03\x01\x91\x50\x50\x61\x08\x78\x56\x5b\x60\x01\x80\x60\xf8\x03\x60" "\xff\x16\x82\x03\x01\x91\x50\x50\x5b\x91\x90\x50\x56\x5b\x60\x00\x80\x60\x00\x83\x51\x60\x00\x1a" "\x90\x50\x60\x80\x60\xff\x16\x81\x10\x15\x61\x08\x9e\x57\x60\x01\x91\x50\x61\x09\x2b\x56\x5b\x60" "\xb8\x60\xff\x16\x81\x10\x15\x61\x08\xbb\x57\x60\x01\x60\x80\x60\xff\x16\x82\x03\x01\x91\x50\x61" "\x09\x2a\x56\x5b\x60\xc0\x60\xff\x16\x81\x10\x15\x61\x08\xeb\x57\x60\xb7\x81\x03\x60\x01\x85\x01" "\x94\x50\x80\x60\x20\x03\x61\x01\x00\x0a\x85\x51\x04\x60\x01\x82\x01\x81\x01\x93\x50\x50\x50\x61" "\x09\x29\x56\x5b\x60\xf8\x60\xff\x16\x81\x10\x15\x61\x09\x08\x57\x60\x01\x60\xc0\x60\xff\x16\x82" "\x03\x01\x91\x50\x61\x09\x28\x56\x5b\x60\xf7\x81\x03\x60\x01\x85\x01\x94\x50\x80\x60\x20\x03\x61" "\x01\x00\x0a\x85\x51\x04\x60\x01\x82\x01\x81\x01\x93\x50\x50\x50\x5b\x5b\x5b\x5b\x81\x92\x50\x50" "\x50\x91\x90\x50\x56\x5b\x60\x00\x81\x14\x15\x61\x09\x43\x57\x61\x09\x97\x56\x5b\x5b\x60\x20\x60" "\xff\x16\x81\x10\x61\x09\x73\x57\x82\x51\x82\x52\x60\x20\x60\xff\x16\x83\x01\x92\x50\x60\x20\x60" "\xff\x16\x82\x01\x91\x50\x60\x20\x60\xff\x16\x81\x03\x90\x50\x61\x09\x44\x56\x5b\x60\x00\x60\x01" "\x82\x60\x20\x60\xff\x16\x03\x61\x01\x00\x0a\x03\x90\x50\x80\x19\x84\x51\x16\x81\x84\x51\x16\x81" "\x81\x17\x85\x52\x50\x50\x50\x5b\x50\x50\x50\x56\x5b\x60\x40\x51\x80\x60\x40\x01\x60\x40\x52\x80" "\x60\x00\x81\x52\x60\x20\x01\x60\x00\x81\x52\x50\x90\x56\x5b\x60\x40\x51\x80\x60\x40\x01\x60\x40" "\x52\x80\x60\x00\x81\x52\x60\x20\x01\x60\x00\x81\x52\x50\x90\x56\xfe\xa2\x65\x62\x7a\x7a\x72\x31" "\x58\x20\x8f\x1e\xa6\xfc\xf6\x3d\x69\x11\xac\x5d\xbf\xe3\x40\xbe\x10\x29\x61\x45\x81\x80\x2c\x6a" "\x75\x0e\x7d\x63\x54\xb3\x2c\xe6\x64\x7c\x64\x73\x6f\x6c\x63\x43\x00\x05\x11\x00\x32"sv, }}, }, }, .jaipur_block = 23'850'000, .agra_block = 50'523'000, }, }; constinit const ChainConfig kAmoyConfig{ .chain_id = 80002, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .muir_glacier_block = 0, .berlin_block = 0, .london_block = 73100, .burnt_contract = { {0, 0x000000000000000000000000000000000000dead_address}, {73100, 0xeCDD77cE6f146cCf5dab707941d318Bd50eeD2C9_address}, }, .rule_set_config = protocol::bor::Config{ .period = { {0, 2}, }, .sprint = { {0, 16}, }, .validator_contract = 0x0000000000000000000000000000000000001000_address, .rewrite_code = { { 11865856, {{ 0x0000000000000000000000000000000000001001_address, "\x60\x80\x60\x40\x52\x34\x80\x15\x61\x00\x10\x57\x60\x00\x80\xfd\x5b\x50\x60\x04\x36\x10\x61\x00" "\xcf\x57\x60\x00\x35\x60\xe0\x1c\x80\x63\x54\x07\xca\x67\x11\x61\x00\x8c\x57\x80\x63\xab\xca\x22" "\x04\x11\x61\x00\x66\x57\x80\x63\xab\xca\x22\x04\x14\x61\x02\xfa\x57\x80\x63\xd7\x2a\x0b\x67\x14" "\x61\x03\x02\x57\x80\x63\xee\x3a\x87\xf2\x14\x61\x03\x1f\x57\x80\x63\xf1\x65\x05\x36\x14\x61\x03" "\x42\x57\x61\x00\xcf\x56\x5b\x80\x63\x54\x07\xca\x67\x14\x61\x02\x58\x57\x80\x63\x67\x57\xe5\xd9" "\x14\x61\x02\x60\x57\x80\x63\x94\x2a\xf1\x79\x14\x61\x02\xf2\x57\x61\x00\xcf\x56\x5b\x80\x63\x03" "\x11\x2a\x17\x14\x61\x00\xd4\x57\x80\x63\x19\x49\x4a\x17\x14\x61\x00\xf3\x57\x80\x63\x30\xe6\x9f" "\xc3\x14\x61\x01\x7e\x57\x80\x63\x31\x89\x26\xf7\x14\x61\x01\x98\x57\x80\x63\x34\x34\x73\x5f\x14" "\x61\x01\xbc\x57\x80\x63\x51\x95\x0c\xd9\x14\x61\x01\xc4\x57\x5b\x60\x00\x80\xfd\x5b\x61\x00\xf1" "\x60\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61\x00\xea\x57\x60\x00\x80\xfd\x5b\x50\x35\x61\x03\x4a" "\x56\x5b\x00\x5b\x61\x01\x6a\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61\x01\x09\x57\x60\x00\x80" "\xfd\x5b\x81\x35\x91\x90\x81\x01\x90\x60\x40\x81\x01\x60\x20\x82\x01\x35\x64\x01\x00\x00\x00\x00" "\x81\x11\x15\x61\x01\x2b\x57\x60\x00\x80\xfd\x5b\x82\x01\x83\x60\x20\x82\x01\x11\x15\x61\x01\x3d" "\x57\x60\x00\x80\xfd\x5b\x80\x35\x90\x60\x20\x01\x91\x84\x60\x01\x83\x02\x84\x01\x11\x64\x01\x00" "\x00\x00\x00\x83\x11\x17\x15\x61\x01\x5f\x57\x60\x00\x80\xfd\x5b\x50\x90\x92\x50\x90\x50\x61\x06" "\x0d\x56\x5b\x60\x40\x80\x51\x91\x15\x15\x82\x52\x51\x90\x81\x90\x03\x60\x20\x01\x90\xf3\x5b\x61" "\x01\x86\x61\x09\x3e\x56\x5b\x60\x40\x80\x51\x91\x82\x52\x51\x90\x81\x90\x03\x60\x20\x01\x90\xf3" "\x5b\x61\x01\xa0\x61\x09\x44\x56\x5b\x60\x40\x80\x51\x60\x01\x60\x01\x60\xa0\x1b\x03\x90\x92\x16" "\x82\x52\x51\x90\x81\x90\x03\x60\x20\x01\x90\xf3\x5b\x61\x01\xa0\x61\x09\x68\x56\x5b\x61\x00\xf1" "\x60\x04\x80\x36\x03\x61\x02\x80\x81\x10\x15\x61\x01\xdb\x57\x60\x00\x80\xfd\x5b\x61\x02\x00\x82" "\x01\x35\x90\x61\x02\x20\x83\x01\x35\x90\x60\x01\x60\x01\x60\xa0\x1b\x03\x61\x02\x40\x85\x01\x35" "\x16\x90\x84\x01\x84\x61\x02\x80\x81\x01\x61\x02\x60\x82\x01\x35\x64\x01\x00\x00\x00\x00\x81\x11" "\x15\x61\x02\x19\x57\x60\x00\x80\xfd\x5b\x82\x01\x83\x60\x20\x82\x01\x11\x15\x61\x02\x2b\x57\x60" "\x00\x80\xfd\x5b\x80\x35\x90\x60\x20\x01\x91\x84\x60\x01\x83\x02\x84\x01\x11\x64\x01\x00\x00\x00" "\x00\x83\x11\x17\x15\x61\x02\x4d\x57\x60\x00\x80\xfd\x5b\x50\x90\x92\x50\x90\x50\x61\x09\x73\x56" "\x5b\x61\x01\x86\x61\x0c\x78\x56\x5b\x61\x02\x7d\x60\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61\x02" "\x76\x57\x60\x00\x80\xfd\x5b\x50\x35\x61\x0c\x7e\x56\x5b\x60\x40\x80\x51\x60\x20\x80\x82\x52\x83" "\x51\x81\x83\x01\x52\x83\x51\x91\x92\x83\x92\x90\x83\x01\x91\x85\x01\x90\x80\x83\x83\x60\x00\x5b" "\x83\x81\x10\x15\x61\x02\xb7\x57\x81\x81\x01\x51\x83\x82\x01\x52\x60\x20\x01\x61\x02\x9f\x56\x5b" "\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x02\xe4\x57\x80\x82\x03\x80\x51" "\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b\x50\x92\x50" "\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x61\x01\x86\x61\x0d\x19\x56\x5b\x61\x01\x86\x61\x0d" "\x1f\x56\x5b\x61\x01\x6a\x60\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61\x03\x18\x57\x60\x00\x80\xfd" "\x5b\x50\x35\x61\x0d\x25\x56\x5b\x61\x00\xf1\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61\x03\x35" "\x57\x60\x00\x80\xfd\x5b\x50\x80\x35\x90\x60\x20\x01\x35\x61\x0d\x3a\x56\x5b\x61\x01\x86\x61\x0d" "\xb0\x56\x5b\x60\x00\x81\x81\x52\x60\x03\x60\x20\x90\x81\x52\x60\x40\x91\x82\x90\x20\x80\x54\x83" "\x51\x60\x1f\x60\x02\x60\x00\x19\x61\x01\x00\x60\x01\x86\x16\x15\x02\x01\x90\x93\x16\x92\x90\x92" "\x04\x91\x82\x01\x84\x90\x04\x84\x02\x81\x01\x84\x01\x90\x94\x52\x80\x84\x52\x60\x60\x93\x92\x83" "\x01\x82\x82\x80\x15\x61\x03\xdf\x57\x80\x60\x1f\x10\x61\x03\xb4\x57\x61\x01\x00\x80\x83\x54\x04" "\x02\x83\x52\x91\x60\x20\x01\x91\x61\x03\xdf\x56\x5b\x82\x01\x91\x90\x60\x00\x52\x60\x20\x60\x00" "\x20\x90\x5b\x81\x54\x81\x52\x90\x60\x01\x01\x90\x60\x20\x01\x80\x83\x11\x61\x03\xc2\x57\x82\x90" "\x03\x60\x1f\x16\x82\x01\x91\x5b\x50\x50\x50\x50\x50\x90\x50\x80\x51\x60\x00\x14\x15\x61\x04\x26" "\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60\x06\x60" "\x24\x82\x01\x52\x65\x08\x59\x9b\xdd\x5b\x99\x60\xd2\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90" "\x03\x60\x64\x01\x90\xfd\x5b\x60\x00\x82\x81\x52\x60\x03\x60\x20\x52\x60\x40\x81\x20\x61\x04\x3d" "\x91\x61\x12\xbb\x56\x5b\x60\x00\x60\x60\x82\x80\x60\x20\x01\x90\x51\x60\x40\x81\x10\x15\x61\x04" "\x56\x57\x60\x00\x80\xfd\x5b\x81\x51\x60\x20\x83\x01\x80\x51\x60\x40\x51\x92\x94\x92\x93\x83\x01" "\x92\x91\x90\x84\x64\x01\x00\x00\x00\x00\x82\x11\x15\x61\x04\x7d\x57\x60\x00\x80\xfd\x5b\x90\x83" "\x01\x90\x60\x20\x82\x01\x85\x81\x11\x15\x61\x04\x92\x57\x60\x00\x80\xfd\x5b\x82\x51\x64\x01\x00" "\x00\x00\x00\x81\x11\x82\x82\x01\x88\x10\x17\x15\x61\x04\xac\x57\x60\x00\x80\xfd\x5b\x82\x52\x50" "\x81\x51\x60\x20\x91\x82\x01\x92\x90\x91\x01\x90\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x04" "\xd9\x57\x81\x81\x01\x51\x83\x82\x01\x52\x60\x20\x01\x61\x04\xc1\x56\x5b\x50\x50\x50\x50\x90\x50" "\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x05\x06\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03" "\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b\x50\x60\x40\x52\x50\x50\x50\x91\x50" "\x91\x50\x83\x7f\x87\x97\x14\x49\x48\x78\x2a\xdc\xed\xe8\xe0\x4b\xfa\x0b\xd8\xfd\x56\x94\x1e\x0d" "\xf7\x50\x8b\xd0\x2a\x62\x9b\x47\x7f\x7b\x07\x3a\x60\x40\x51\x60\x40\x51\x80\x91\x03\x90\xa2\x60" "\x40\x80\x51\x63\x13\x62\x9d\xf5\x60\xe1\x1b\x81\x52\x60\x04\x81\x01\x86\x81\x52\x60\x24\x82\x01" "\x92\x83\x52\x83\x51\x60\x44\x83\x01\x52\x83\x51\x60\x01\x60\x01\x60\xa0\x1b\x03\x86\x16\x93\x63" "\x26\xc5\x3b\xea\x93\x89\x93\x87\x93\x90\x92\x91\x60\x64\x01\x90\x60\x20\x85\x01\x90\x80\x83\x83" "\x60\x00\x5b\x83\x81\x10\x15\x61\x05\xa2\x57\x81\x81\x01\x51\x83\x82\x01\x52\x60\x20\x01\x61\x05" "\x8a\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x05\xcf\x57\x80\x82" "\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b" "\x50\x93\x50\x50\x50\x50\x60\x00\x60\x40\x51\x80\x83\x03\x81\x60\x00\x87\x80\x3b\x15\x80\x15\x61" "\x05\xef\x57\x60\x00\x80\xfd\x5b\x50\x5a\xf1\x15\x80\x15\x61\x06\x03\x57\x3d\x60\x00\x80\x3e\x3d" "\x60\x00\xfd\x5b\x50\x50\x50\x50\x50\x50\x50\x50\x56\x5b\x60\x00\x33\x60\x02\x60\x01\x60\xa0\x1b" "\x03\x14\x61\x06\x5f\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82" "\x01\x52\x60\x12\x60\x24\x82\x01\x52\x71\x4e\x6f\x74\x20\x53\x79\x73\x74\x65\x6d\x20\x41\x64\x64" "\x65\x73\x73\x21\x60\x70\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b" "\x60\x60\x61\x06\xa8\x61\x06\xa3\x85\x85\x80\x80\x60\x1f\x01\x60\x20\x80\x91\x04\x02\x60\x20\x01" "\x60\x40\x51\x90\x81\x01\x60\x40\x52\x80\x93\x92\x91\x90\x81\x81\x52\x60\x20\x01\x83\x83\x80\x82" "\x84\x37\x60\x00\x92\x01\x91\x90\x91\x52\x50\x61\x0d\xb5\x92\x50\x50\x50\x56\x5b\x61\x0d\xdb\x56" "\x5b\x90\x50\x60\x00\x61\x06\xc9\x82\x60\x00\x81\x51\x81\x10\x61\x06\xbc\x57\xfe\x5b\x60\x20\x02" "\x60\x20\x01\x01\x51\x61\x0f\x14\x56\x5b\x90\x50\x80\x60\x00\x54\x60\x01\x01\x14\x61\x07\x24\x57" "\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60\x1b\x60\x24" "\x82\x01\x52\x7f\x53\x74\x61\x74\x65\x49\x64\x73\x20\x61\x72\x65\x20\x6e\x6f\x74\x20\x73\x65\x71" "\x75\x65\x6e\x74\x69\x61\x6c\x00\x00\x00\x00\x00\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60" "\x64\x01\x90\xfd\x5b\x60\x00\x80\x54\x60\x01\x90\x81\x01\x82\x55\x83\x51\x61\x07\x4c\x91\x85\x91" "\x81\x10\x61\x07\x3f\x57\xfe\x5b\x60\x20\x02\x60\x20\x01\x01\x51\x61\x0f\x62\x56\x5b\x90\x50\x60" "\x60\x61\x07\x6d\x84\x60\x02\x81\x51\x81\x10\x61\x07\x60\x57\xfe\x5b\x60\x20\x02\x60\x20\x01\x01" "\x51\x61\x0f\x82\x56\x5b\x90\x50\x61\x07\x78\x82\x61\x0f\xff\x56\x5b\x15\x61\x09\x33\x57\x60\x00" "\x62\x4c\x4b\x40\x90\x50\x60\x60\x84\x83\x60\x40\x51\x60\x24\x01\x80\x83\x81\x52\x60\x20\x01\x80" "\x60\x20\x01\x82\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20" "\x01\x90\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x07\xcf\x57\x81\x81\x01\x51\x83\x82\x01\x52" "\x60\x20\x01\x61\x07\xb7\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61" "\x07\xfc\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60" "\x20\x01\x91\x50\x5b\x50\x60\x40\x80\x51\x60\x1f\x19\x81\x84\x03\x01\x81\x52\x91\x90\x52\x60\x20" "\x81\x01\x80\x51\x60\x01\x60\x01\x60\xe0\x1b\x03\x16\x63\x13\x62\x9d\xf5\x60\xe1\x1b\x17\x81\x52" "\x81\x51\x91\x96\x50\x60\x00\x95\x50\x85\x94\x50\x90\x92\x50\x90\x50\x82\x88\x87\xf1\x60\x40\x80" "\x51\x82\x15\x15\x81\x52\x90\x51\x91\x98\x50\x86\x91\x7f\x5a\x22\x72\x55\x90\xb0\xa5\x1c\x92\x39" "\x40\x22\x3f\x74\x58\x51\x21\x64\xb1\x11\x33\x59\xa7\x35\xe8\x6e\x7f\x27\xf4\x47\x91\xee\x91\x81" "\x90\x03\x60\x20\x01\x90\xa2\x86\x61\x09\x30\x57\x83\x83\x60\x40\x51\x60\x20\x01\x80\x83\x60\x01" "\x60\x01\x60\xa0\x1b\x03\x16\x81\x52\x60\x20\x01\x80\x60\x20\x01\x82\x81\x03\x82\x52\x83\x81\x81" "\x51\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20\x01\x90\x80\x83\x83\x60\x00\x5b\x83\x81\x10" "\x15\x61\x08\xcc\x57\x81\x81\x01\x51\x83\x82\x01\x52\x60\x20\x01\x61\x08\xb4\x56\x5b\x50\x50\x50" "\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x08\xf9\x57\x80\x82\x03\x80\x51\x60\x01\x83" "\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b\x50\x60\x40\x80\x51\x60" "\x1f\x19\x81\x84\x03\x01\x81\x52\x91\x81\x52\x60\x00\x8b\x81\x52\x60\x03\x60\x20\x90\x81\x52\x91" "\x90\x20\x82\x51\x61\x09\x2e\x97\x50\x90\x95\x50\x91\x01\x92\x50\x90\x50\x61\x13\x02\x56\x5b\x50" "\x5b\x50\x50\x5b\x50\x50\x50\x50\x93\x92\x50\x50\x50\x56\x5b\x60\x04\x54\x81\x56\x5b\x7f\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x97\x1f\xef\x2b\xb6\x0f\x70\x9e\x1d\xaf\x3e\x55\xd0" "\x09\x14\xe2\x30\xcd\x94\x81\x56\x5b\x60\x02\x60\x01\x60\xa0\x1b\x03\x81\x56\x5b\x62\x01\x00\x00" "\x85\x10\x61\x09\xbe\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82" "\x01\x52\x60\x11\x60\x24\x82\x01\x52\x70\x0d\x2d\xce\xcc\x2d\x8d\x2c\x84\x0d\x8c\xac\x2c\xc9\x2d" "\xcc\x8c\xaf\x60\x7b\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x60" "\x04\x54\x60\x05\x80\x54\x60\x01\x01\x90\x81\x90\x55\x11\x15\x61\x0a\x05\x57\x60\x40\x80\x51\x62" "\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60\x03\x60\x24\x82\x01\x52\x62\x19" "\x5b\x99\x60\xea\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x60\x01" "\x54\x80\x61\x0a\x42\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82" "\x01\x52\x60\x05\x60\x24\x82\x01\x52\x64\x08\x5c\x9b\xdb\xdd\x60\xda\x1b\x60\x44\x82\x01\x52\x90" "\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x60\x00\x85\x85\x85\x85\x60\x40\x51\x60\x20\x01\x80" "\x85\x81\x52\x60\x20\x01\x84\x60\x01\x60\x01\x60\xa0\x1b\x03\x16\x81\x52\x60\x20\x01\x80\x60\x20" "\x01\x82\x81\x03\x82\x52\x84\x84\x82\x81\x81\x52\x60\x20\x01\x92\x50\x80\x82\x84\x37\x60\x00\x81" "\x84\x01\x52\x60\x40\x80\x51\x60\x1f\x19\x60\x1f\x90\x93\x01\x83\x16\x90\x94\x01\x84\x81\x03\x90" "\x92\x01\x84\x52\x52\x50\x80\x51\x60\x20\x90\x91\x01\x20\x96\x50\x7f\x28\xcf\x91\xac\x06\x4e\x17" "\x9f\x8a\x42\xe4\xb7\xa2\x0b\xa0\x80\x18\x77\x81\xda\x55\xfd\x4f\x3f\x18\x87\x0b\x7a\x25\xba\xcb" "\x55\x95\x50\x50\x50\x50\x82\x84\x14\x80\x15\x92\x50\x90\x50\x61\x0a\xef\x57\x50\x60\x00\x82\x81" "\x52\x60\x02\x60\x20\x52\x60\x40\x90\x20\x54\x60\xff\x16\x15\x5b\x61\x0b\x29\x57\x60\x40\x80\x51" "\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x80\x83\x01\x91\x90\x91\x52\x60\x24\x82\x01" "\x52\x63\x1d\x5c\xd9\x59\x60\xe2\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90" "\xfd\x5b\x60\x00\x82\x81\x52\x60\x02\x60\x20\x52\x60\x40\x90\x81\x90\x20\x80\x54\x60\xff\x19\x16" "\x60\x01\x17\x90\x55\x80\x51\x61\x02\x00\x81\x81\x01\x90\x92\x52\x61\x0b\x74\x91\x8b\x90\x60\x10" "\x90\x83\x90\x83\x90\x80\x82\x84\x37\x60\x00\x92\x01\x91\x90\x91\x52\x50\x8b\x91\x50\x85\x90\x50" "\x61\x10\x0b\x56\x5b\x83\x14\x61\x0b\xb0\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52" "\x60\x20\x60\x04\x82\x01\x52\x60\x06\x60\x24\x82\x01\x52\x65\x10\xb8\x39\x37\xb7\xb3\x60\xd1\x1b" "\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x60\x40\x51\x87\x90\x7f\x87" "\x97\x14\x49\x48\x78\x2a\xdc\xed\xe8\xe0\x4b\xfa\x0b\xd8\xfd\x56\x94\x1e\x0d\xf7\x50\x8b\xd0\x2a" "\x62\x9b\x47\x7f\x7b\x07\x3a\x90\x60\x00\x90\xa2\x60\x40\x80\x51\x63\x13\x62\x9d\xf5\x60\xe1\x1b" "\x81\x52\x60\x04\x81\x01\x89\x81\x52\x60\x24\x82\x01\x92\x83\x52\x60\x44\x82\x01\x87\x90\x52\x60" "\x01\x60\x01\x60\xa0\x1b\x03\x89\x16\x92\x63\x26\xc5\x3b\xea\x92\x8b\x92\x8a\x92\x8a\x92\x60\x64" "\x01\x84\x84\x80\x82\x84\x37\x60\x00\x81\x84\x01\x52\x60\x1f\x19\x60\x1f\x82\x01\x16\x90\x50\x80" "\x83\x01\x92\x50\x50\x50\x94\x50\x50\x50\x50\x50\x60\x00\x60\x40\x51\x80\x83\x03\x81\x60\x00\x87" "\x80\x3b\x15\x80\x15\x61\x0c\x55\x57\x60\x00\x80\xfd\x5b\x50\x5a\xf1\x15\x80\x15\x61\x0c\x69\x57" "\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50\x50\x50\x50\x50\x50\x50\x50\x50\x50\x50\x56" "\x5b\x60\x00\x54\x81\x56\x5b\x60\x03\x60\x20\x90\x81\x52\x60\x00\x91\x82\x52\x60\x40\x91\x82\x90" "\x20\x80\x54\x83\x51\x60\x1f\x60\x02\x60\x00\x19\x61\x01\x00\x60\x01\x86\x16\x15\x02\x01\x90\x93" "\x16\x92\x90\x92\x04\x91\x82\x01\x84\x90\x04\x84\x02\x81\x01\x84\x01\x90\x94\x52\x80\x84\x52\x90" "\x91\x83\x01\x82\x82\x80\x15\x61\x0d\x11\x57\x80\x60\x1f\x10\x61\x0c\xe6\x57\x61\x01\x00\x80\x83" "\x54\x04\x02\x83\x52\x91\x60\x20\x01\x91\x61\x0d\x11\x56\x5b\x82\x01\x91\x90\x60\x00\x52\x60\x20" "\x60\x00\x20\x90\x5b\x81\x54\x81\x52\x90\x60\x01\x01\x90\x60\x20\x01\x80\x83\x11\x61\x0c\xf4\x57" "\x82\x90\x03\x60\x1f\x16\x82\x01\x91\x5b\x50\x50\x50\x50\x50\x81\x56\x5b\x60\x05\x54\x81\x56\x5b" "\x60\x01\x54\x81\x56\x5b\x60\x02\x60\x20\x52\x60\x00\x90\x81\x52\x60\x40\x90\x20\x54\x60\xff\x16" "\x81\x56\x5b\x33\x60\x01\x60\x01\x60\xa0\x1b\x03\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\xbe\x97\x1f\xef\x2b\xb6\x0f\x70\x9e\x1d\xaf\x3e\x55\xd0\x09\x14\xe2\x30\xcd\x94\x16\x14\x61" "\x0d\xa5\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60" "\x0b\x60\x24\x82\x01\x52\x6a\x10\xb9\x37\xb7\xba\x29\xb2\xba\x3a\x32\xb9\x60\xa9\x1b\x60\x44\x82" "\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x60\x01\x91\x90\x91\x55\x60\x04\x55\x56" "\x5b\x60\x10\x81\x56\x5b\x61\x0d\xbd\x61\x13\x80\x56\x5b\x50\x60\x40\x80\x51\x80\x82\x01\x90\x91" "\x52\x81\x51\x81\x52\x60\x20\x82\x81\x01\x90\x82\x01\x52\x5b\x91\x90\x50\x56\x5b\x60\x60\x61\x0d" "\xe6\x82\x61\x10\xb6\x56\x5b\x61\x0d\xef\x57\x60\x00\x80\xfd\x5b\x60\x00\x61\x0d\xfa\x83\x61\x10" "\xf0\x56\x5b\x90\x50\x60\x60\x81\x67\xff\xff\xff\xff\xff\xff\xff\xff\x81\x11\x80\x15\x61\x0e\x15" "\x57\x60\x00\x80\xfd\x5b\x50\x60\x40\x51\x90\x80\x82\x52\x80\x60\x20\x02\x60\x20\x01\x82\x01\x60" "\x40\x52\x80\x15\x61\x0e\x4f\x57\x81\x60\x20\x01\x5b\x61\x0e\x3c\x61\x13\x80\x56\x5b\x81\x52\x60" "\x20\x01\x90\x60\x01\x90\x03\x90\x81\x61\x0e\x34\x57\x90\x50\x5b\x50\x90\x50\x60\x00\x61\x0e\x61" "\x85\x60\x20\x01\x51\x61\x11\x48\x56\x5b\x60\x20\x86\x01\x51\x01\x90\x50\x60\x00\x80\x5b\x84\x81" "\x10\x15\x61\x0e\xb8\x57\x61\x0e\x7e\x83\x61\x11\xab\x56\x5b\x91\x50\x60\x40\x51\x80\x60\x40\x01" "\x60\x40\x52\x80\x83\x81\x52\x60\x20\x01\x84\x81\x52\x50\x84\x82\x81\x51\x81\x10\x61\x0e\xa1\x57" "\xfe\x5b\x60\x20\x90\x81\x02\x91\x90\x91\x01\x01\x52\x91\x81\x01\x91\x60\x01\x01\x61\x0e\x6d\x56" "\x5b\x50\x85\x51\x60\x20\x87\x01\x51\x83\x03\x14\x61\x0f\x0a\x57\x60\x40\x80\x51\x62\x46\x1b\xcd" "\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60\x13\x60\x24\x82\x01\x52\x72\x2b\xb9\x37\xb7" "\x33\x90\x3a\x37\xba\x30\xb6\x10\x36\x32\xb7\x33\xba\x34\x17\x60\x69\x1b\x60\x44\x82\x01\x52\x90" "\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x50\x90\x94\x93\x50\x50\x50\x50\x56\x5b\x80\x51\x60" "\x00\x90\x15\x80\x15\x90\x61\x0f\x29\x57\x50\x81\x51\x60\x21\x10\x15\x5b\x61\x0f\x32\x57\x60\x00" "\x80\xfd\x5b\x60\x00\x80\x61\x0f\x3e\x84\x61\x12\x44\x56\x5b\x81\x51\x91\x93\x50\x91\x50\x60\x20" "\x82\x10\x15\x61\x0f\x5a\x57\x60\x20\x82\x90\x03\x61\x01\x00\x0a\x90\x04\x5b\x94\x93\x50\x50\x50" "\x50\x56\x5b\x80\x51\x60\x00\x90\x60\x15\x14\x61\x0f\x73\x57\x60\x00\x80\xfd\x5b\x61\x0f\x7c\x82" "\x61\x0f\x14\x56\x5b\x92\x91\x50\x50\x56\x5b\x80\x51\x60\x60\x90\x61\x0f\x90\x57\x60\x00\x80\xfd" "\x5b\x60\x00\x80\x61\x0f\x9c\x84\x61\x12\x44\x56\x5b\x91\x50\x91\x50\x60\x60\x81\x67\xff\xff\xff" "\xff\xff\xff\xff\xff\x81\x11\x80\x15\x61\x0f\xb9\x57\x60\x00\x80\xfd\x5b\x50\x60\x40\x51\x90\x80" "\x82\x52\x80\x60\x1f\x01\x60\x1f\x19\x16\x60\x20\x01\x82\x01\x60\x40\x52\x80\x15\x61\x0f\xe4\x57" "\x60\x20\x82\x01\x81\x80\x36\x83\x37\x01\x90\x50\x5b\x50\x90\x50\x60\x20\x81\x01\x61\x0f\xf6\x84" "\x82\x85\x61\x12\x6a\x56\x5b\x50\x94\x93\x50\x50\x50\x50\x56\x5b\x3b\x63\xff\xff\xff\xff\x16\x15" "\x15\x90\x56\x5b\x60\x00\x81\x81\x5b\x60\x10\x81\x10\x15\x61\x0f\xf6\x57\x60\x01\x85\x82\x1c\x81" "\x16\x14\x15\x61\x10\x6c\x57\x85\x81\x60\x10\x81\x10\x61\x10\x32\x57\xfe\x5b\x60\x20\x02\x01\x51" "\x82\x60\x40\x51\x60\x20\x01\x80\x83\x81\x52\x60\x20\x01\x82\x81\x52\x60\x20\x01\x92\x50\x50\x50" "\x60\x40\x51\x60\x20\x81\x83\x03\x03\x81\x52\x90\x60\x40\x52\x80\x51\x90\x60\x20\x01\x20\x91\x50" "\x61\x10\xae\x56\x5b\x81\x86\x82\x60\x10\x81\x10\x61\x10\x79\x57\xfe\x5b\x60\x20\x02\x01\x51\x60" "\x40\x51\x60\x20\x01\x80\x83\x81\x52\x60\x20\x01\x82\x81\x52\x60\x20\x01\x92\x50\x50\x50\x60\x40" "\x51\x60\x20\x81\x83\x03\x03\x81\x52\x90\x60\x40\x52\x80\x51\x90\x60\x20\x01\x20\x91\x50\x5b\x60" "\x01\x01\x61\x10\x10\x56\x5b\x80\x51\x60\x00\x90\x61\x10\xc7\x57\x50\x60\x00\x61\x0d\xd6\x56\x5b" "\x60\x20\x82\x01\x51\x80\x51\x60\x00\x1a\x90\x60\xc0\x82\x10\x15\x61\x10\xe6\x57\x60\x00\x92\x50" "\x50\x50\x61\x0d\xd6\x56\x5b\x50\x60\x01\x93\x92\x50\x50\x50\x56\x5b\x80\x51\x60\x00\x90\x61\x11" "\x01\x57\x50\x60\x00\x61\x0d\xd6\x56\x5b\x60\x00\x80\x61\x11\x11\x84\x60\x20\x01\x51\x61\x11\x48" "\x56\x5b\x60\x20\x85\x01\x51\x85\x51\x91\x81\x01\x92\x50\x01\x5b\x80\x82\x10\x15\x61\x11\x3f\x57" "\x61\x11\x30\x82\x61\x11\xab\x56\x5b\x60\x01\x90\x93\x01\x92\x90\x91\x01\x90\x61\x11\x1f\x56\x5b" "\x50\x90\x93\x92\x50\x50\x50\x56\x5b\x80\x51\x60\x00\x90\x81\x1a\x60\x80\x81\x10\x15\x61\x11\x62" "\x57\x60\x00\x91\x50\x50\x61\x0d\xd6\x56\x5b\x60\xb8\x81\x10\x80\x61\x11\x7d\x57\x50\x60\xc0\x81" "\x10\x80\x15\x90\x61\x11\x7d\x57\x50\x60\xf8\x81\x10\x5b\x15\x61\x11\x8c\x57\x60\x01\x91\x50\x50" "\x61\x0d\xd6\x56\x5b\x60\xc0\x81\x10\x15\x61\x11\xa0\x57\x60\xb5\x19\x01\x90\x50\x61\x0d\xd6\x56" "\x5b\x60\xf5\x19\x01\x90\x50\x61\x0d\xd6\x56\x5b\x80\x51\x60\x00\x90\x81\x90\x81\x1a\x60\x80\x81" "\x10\x15\x61\x11\xc6\x57\x60\x01\x91\x50\x61\x12\x3d\x56\x5b\x60\xb8\x81\x10\x15\x61\x11\xdb\x57" "\x60\x7e\x19\x81\x01\x91\x50\x61\x12\x3d\x56\x5b\x60\xc0\x81\x10\x15\x61\x12\x08\x57\x60\xb7\x81" "\x03\x60\x01\x85\x01\x94\x50\x80\x60\x20\x03\x61\x01\x00\x0a\x85\x51\x04\x60\x01\x82\x01\x81\x01" "\x93\x50\x50\x50\x61\x12\x3d\x56\x5b\x60\xf8\x81\x10\x15\x61\x12\x1d\x57\x60\xbe\x19\x81\x01\x91" "\x50\x61\x12\x3d\x56\x5b\x60\xf7\x81\x03\x60\x01\x85\x01\x94\x50\x80\x60\x20\x03\x61\x01\x00\x0a" "\x85\x51\x04\x60\x01\x82\x01\x81\x01\x93\x50\x50\x50\x5b\x50\x92\x91\x50\x50\x56\x5b\x60\x00\x80" "\x60\x00\x61\x12\x56\x84\x60\x20\x01\x51\x61\x11\x48\x56\x5b\x60\x20\x85\x01\x51\x94\x51\x94\x81" "\x01\x95\x94\x03\x93\x92\x50\x50\x50\x56\x5b\x80\x61\x12\x74\x57\x61\x12\xb6\x56\x5b\x5b\x60\x20" "\x81\x10\x61\x12\x94\x57\x82\x51\x82\x52\x60\x20\x92\x83\x01\x92\x90\x91\x01\x90\x60\x1f\x19\x01" "\x61\x12\x75\x56\x5b\x80\x15\x61\x12\xb6\x57\x82\x51\x82\x51\x60\x20\x83\x90\x03\x61\x01\x00\x0a" "\x60\x00\x19\x01\x80\x19\x90\x92\x16\x91\x16\x17\x82\x52\x5b\x50\x50\x50\x56\x5b\x50\x80\x54\x60" "\x01\x81\x60\x01\x16\x15\x61\x01\x00\x02\x03\x16\x60\x02\x90\x04\x60\x00\x82\x55\x80\x60\x1f\x10" "\x61\x12\xe1\x57\x50\x61\x12\xff\x56\x5b\x60\x1f\x01\x60\x20\x90\x04\x90\x60\x00\x52\x60\x20\x60" "\x00\x20\x90\x81\x01\x90\x61\x12\xff\x91\x90\x61\x13\x9a\x56\x5b\x50\x56\x5b\x82\x80\x54\x60\x01" "\x81\x60\x01\x16\x15\x61\x01\x00\x02\x03\x16\x60\x02\x90\x04\x90\x60\x00\x52\x60\x20\x60\x00\x20" "\x90\x60\x1f\x01\x60\x20\x90\x04\x81\x01\x92\x82\x60\x1f\x10\x61\x13\x43\x57\x80\x51\x60\xff\x19" "\x16\x83\x80\x01\x17\x85\x55\x61\x13\x70\x56\x5b\x82\x80\x01\x60\x01\x01\x85\x55\x82\x15\x61\x13" "\x70\x57\x91\x82\x01\x5b\x82\x81\x11\x15\x61\x13\x70\x57\x82\x51\x82\x55\x91\x60\x20\x01\x91\x90" "\x60\x01\x01\x90\x61\x13\x55\x56\x5b\x50\x61\x13\x7c\x92\x91\x50\x61\x13\x9a\x56\x5b\x50\x90\x56" "\x5b\x60\x40\x51\x80\x60\x40\x01\x60\x40\x52\x80\x60\x00\x81\x52\x60\x20\x01\x60\x00\x81\x52\x50" "\x90\x56\x5b\x5b\x80\x82\x11\x15\x61\x13\x7c\x57\x60\x00\x81\x55\x60\x01\x01\x61\x13\x9b\x56\xfe" "\xa1\x64\x73\x6f\x6c\x63\x43\x00\x06\x0c\x00\x0a"sv, }, { 0x0000000000000000000000000000000000001010_address, "\x60\x80\x60\x40\x52\x60\x04\x36\x10\x61\x01\xb7\x57\x60\x00\x35\x60\xe0\x1c\x80\x63\x8d\xa5\xcb" "\x5b\x11\x61\x00\xec\x57\x80\x63\xb7\x89\x54\x3c\x11\x61\x00\x8a\x57\x80\x63\xe6\x14\xd0\xd6\x11" "\x61\x00\x64\x57\x80\x63\xe6\x14\xd0\xd6\x14\x61\x06\x95\x57\x80\x63\xed\x9e\xf5\x24\x14\x61\x06" "\xaa\x57\x80\x63\xf2\xfd\xe3\x8b\x14\x61\x06\xdd\x57\x80\x63\xfc\x0c\x54\x6a\x14\x61\x07\x10\x57" "\x61\x01\xb7\x56\x5b\x80\x63\xb7\x89\x54\x3c\x14\x61\x06\x26\x57\x80\x63\xcc\x79\xf9\x7b\x14\x61" "\x06\x6b\x57\x80\x63\xe3\x06\xf7\x79\x14\x61\x06\x80\x57\x61\x01\xb7\x56\x5b\x80\x63\x95\xd8\x9b" "\x41\x11\x61\x00\xc6\x57\x80\x63\x95\xd8\x9b\x41\x14\x61\x05\xa6\x57\x80\x63\xa9\x05\x9c\xbb\x14" "\x61\x05\xbb\x57\x80\x63\xab\xce\xeb\xa2\x14\x61\x05\xe7\x57\x80\x63\xac\xd0\x6c\xb3\x14\x61\x05" "\xfc\x57\x61\x01\xb7\x56\x5b\x80\x63\x8d\xa5\xcb\x5b\x14\x61\x05\x53\x57\x80\x63\x8f\x32\xd5\x9b" "\x14\x61\x05\x68\x57\x80\x63\x90\x25\xe6\x4c\x14\x61\x05\x91\x57\x61\x01\xb7\x56\x5b\x80\x63\x47" "\xe7\xef\x24\x11\x61\x01\x59\x57\x80\x63\x70\xa0\x82\x31\x11\x61\x01\x33\x57\x80\x63\x70\xa0\x82" "\x31\x14\x61\x04\x3c\x57\x80\x63\x71\x50\x18\xa6\x14\x61\x04\x6f\x57\x80\x63\x77\x12\x82\xf6\x14" "\x61\x04\x84\x57\x80\x63\x77\xd3\x2e\x94\x14\x61\x04\x99\x57\x61\x01\xb7\x56\x5b\x80\x63\x47\xe7" "\xef\x24\x14\x61\x03\xb3\x57\x80\x63\x48\x5c\xc9\x55\x14\x61\x03\xec\x57\x80\x63\x60\xf9\x6a\x8f" "\x14\x61\x04\x27\x57\x61\x01\xb7\x56\x5b\x80\x63\x19\xd2\x7d\x9c\x11\x61\x01\x95\x57\x80\x63\x19" "\xd2\x7d\x9c\x14\x61\x02\xa2\x57\x80\x63\x2e\x1a\x7d\x4d\x14\x61\x03\x56\x57\x80\x63\x31\x3c\xe5" "\x67\x14\x61\x03\x73\x57\x80\x63\x42\xfc\x47\xfb\x14\x61\x03\x9e\x57\x61\x01\xb7\x56\x5b\x80\x63" "\x06\xfd\xde\x03\x14\x61\x01\xbc\x57\x80\x63\x14\x99\xc5\x92\x14\x61\x02\x46\x57\x80\x63\x18\x16" "\x0d\xdd\x14\x61\x02\x7b\x57\x5b\x60\x00\x80\xfd\x5b\x34\x80\x15\x61\x01\xc8\x57\x60\x00\x80\xfd" "\x5b\x50\x61\x01\xd1\x61\x07\x25\x56\x5b\x60\x40\x80\x51\x60\x20\x80\x82\x52\x83\x51\x81\x83\x01" "\x52\x83\x51\x91\x92\x83\x92\x90\x83\x01\x91\x85\x01\x90\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15" "\x61\x02\x0b\x57\x81\x81\x01\x51\x83\x82\x01\x52\x60\x20\x01\x61\x01\xf3\x56\x5b\x50\x50\x50\x50" "\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x02\x38\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60" "\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20\x01\x91\x50\x5b\x50\x92\x50\x50\x50\x60\x40" "\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x02\x52\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x79\x60" "\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61\x02\x69\x57\x60\x00\x80\xfd\x5b\x50\x35\x60\x01\x60\x01" "\x60\xa0\x1b\x03\x16\x61\x07\x5c\x56\x5b\x00\x5b\x34\x80\x15\x61\x02\x87\x57\x60\x00\x80\xfd\x5b" "\x50\x61\x02\x90\x61\x07\x9c\x56\x5b\x60\x40\x80\x51\x91\x82\x52\x51\x90\x81\x90\x03\x60\x20\x01" "\x90\xf3\x5b\x34\x80\x15\x61\x02\xae\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\x3a\x60\x04\x80\x36\x03" "\x60\xa0\x81\x10\x15\x61\x02\xc5\x57\x60\x00\x80\xfd\x5b\x81\x01\x90\x60\x20\x81\x01\x81\x35\x64" "\x01\x00\x00\x00\x00\x81\x11\x15\x61\x02\xe0\x57\x60\x00\x80\xfd\x5b\x82\x01\x83\x60\x20\x82\x01" "\x11\x15\x61\x02\xf2\x57\x60\x00\x80\xfd\x5b\x80\x35\x90\x60\x20\x01\x91\x84\x60\x01\x83\x02\x84" "\x01\x11\x64\x01\x00\x00\x00\x00\x83\x11\x17\x15\x61\x03\x14\x57\x60\x00\x80\xfd\x5b\x91\x93\x50" "\x91\x50\x80\x35\x90\x60\x20\x81\x01\x35\x90\x60\x40\x81\x01\x35\x90\x60\x60\x01\x35\x60\x01\x60" "\x01\x60\xa0\x1b\x03\x16\x61\x07\xac\x56\x5b\x60\x40\x80\x51\x60\x01\x60\x01\x60\xa0\x1b\x03\x90" "\x92\x16\x82\x52\x51\x90\x81\x90\x03\x60\x20\x01\x90\xf3\x5b\x61\x02\x79\x60\x04\x80\x36\x03\x60" "\x20\x81\x10\x15\x61\x03\x6c\x57\x60\x00\x80\xfd\x5b\x50\x35\x61\x07\xee\x56\x5b\x34\x80\x15\x61" "\x03\x7f\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\x88\x61\x08\xc6\x56\x5b\x60\x40\x80\x51\x60\xff\x90" "\x92\x16\x82\x52\x51\x90\x81\x90\x03\x60\x20\x01\x90\xf3\x5b\x34\x80\x15\x61\x03\xaa\x57\x60\x00" "\x80\xfd\x5b\x50\x61\x03\x3a\x61\x08\xcb\x56\x5b\x34\x80\x15\x61\x03\xbf\x57\x60\x00\x80\xfd\x5b" "\x50\x61\x02\x79\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61\x03\xd6\x57\x60\x00\x80\xfd\x5b\x50" "\x60\x01\x60\x01\x60\xa0\x1b\x03\x81\x35\x16\x90\x60\x20\x01\x35\x61\x08\xda\x56\x5b\x34\x80\x15" "\x61\x03\xf8\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x79\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61" "\x04\x0f\x57\x60\x00\x80\xfd\x5b\x50\x60\x01\x60\x01\x60\xa0\x1b\x03\x81\x35\x81\x16\x91\x60\x20" "\x01\x35\x16\x61\x09\xa8\x56\x5b\x34\x80\x15\x61\x04\x33\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\x3a" "\x61\x0a\x21\x56\x5b\x34\x80\x15\x61\x04\x48\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x90\x60\x04\x80" "\x36\x03\x60\x20\x81\x10\x15\x61\x04\x5f\x57\x60\x00\x80\xfd\x5b\x50\x35\x60\x01\x60\x01\x60\xa0" "\x1b\x03\x16\x61\x0a\x30\x56\x5b\x34\x80\x15\x61\x04\x7b\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x79" "\x61\x0a\x3d\x56\x5b\x34\x80\x15\x61\x04\x90\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x90\x61\x0a\x98" "\x56\x5b\x34\x80\x15\x61\x04\xa5\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\x3a\x60\x04\x80\x36\x03\x60" "\x40\x81\x10\x15\x61\x04\xbc\x57\x60\x00\x80\xfd\x5b\x81\x35\x91\x90\x81\x01\x90\x60\x40\x81\x01" "\x60\x20\x82\x01\x35\x64\x01\x00\x00\x00\x00\x81\x11\x15\x61\x04\xde\x57\x60\x00\x80\xfd\x5b\x82" "\x01\x83\x60\x20\x82\x01\x11\x15\x61\x04\xf0\x57\x60\x00\x80\xfd\x5b\x80\x35\x90\x60\x20\x01\x91" "\x84\x60\x01\x83\x02\x84\x01\x11\x64\x01\x00\x00\x00\x00\x83\x11\x17\x15\x61\x05\x12\x57\x60\x00" "\x80\xfd\x5b\x91\x90\x80\x80\x60\x1f\x01\x60\x20\x80\x91\x04\x02\x60\x20\x01\x60\x40\x51\x90\x81" "\x01\x60\x40\x52\x80\x93\x92\x91\x90\x81\x81\x52\x60\x20\x01\x83\x83\x80\x82\x84\x37\x60\x00\x92" "\x01\x91\x90\x91\x52\x50\x92\x95\x50\x61\x0a\x9e\x94\x50\x50\x50\x50\x50\x56\x5b\x34\x80\x15\x61" "\x05\x5f\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\x3a\x61\x0b\xc2\x56\x5b\x34\x80\x15\x61\x05\x74\x57" "\x60\x00\x80\xfd\x5b\x50\x61\x05\x7d\x61\x0b\xd1\x56\x5b\x60\x40\x80\x51\x91\x15\x15\x82\x52\x51" "\x90\x81\x90\x03\x60\x20\x01\x90\xf3\x5b\x34\x80\x15\x61\x05\x9d\x57\x60\x00\x80\xfd\x5b\x50\x61" "\x01\xd1\x61\x0b\xe2\x56\x5b\x34\x80\x15\x61\x05\xb2\x57\x60\x00\x80\xfd\x5b\x50\x61\x01\xd1\x61" "\x0c\x00\x56\x5b\x61\x05\x7d\x60\x04\x80\x36\x03\x60\x40\x81\x10\x15\x61\x05\xd1\x57\x60\x00\x80" "\xfd\x5b\x50\x60\x01\x60\x01\x60\xa0\x1b\x03\x81\x35\x16\x90\x60\x20\x01\x35\x61\x0c\x1d\x56\x5b" "\x34\x80\x15\x61\x05\xf3\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x90\x61\x0c\x40\x56\x5b\x34\x80\x15" "\x61\x06\x08\x57\x60\x00\x80\xfd\x5b\x50\x61\x05\x7d\x60\x04\x80\x36\x03\x60\x20\x81\x10\x15\x61" "\x06\x1f\x57\x60\x00\x80\xfd\x5b\x50\x35\x61\x0c\xc9\x56\x5b\x34\x80\x15\x61\x06\x32\x57\x60\x00" "\x80\xfd\x5b\x50\x61\x02\x90\x60\x04\x80\x36\x03\x60\x80\x81\x10\x15\x61\x06\x49\x57\x60\x00\x80" "\xfd\x5b\x50\x60\x01\x60\x01\x60\xa0\x1b\x03\x81\x35\x16\x90\x60\x20\x81\x01\x35\x90\x60\x40\x81" "\x01\x35\x90\x60\x60\x01\x35\x61\x0c\xde\x56\x5b\x34\x80\x15\x61\x06\x77\x57\x60\x00\x80\xfd\x5b" "\x50\x61\x02\x90\x61\x0c\xfd\x56\x5b\x34\x80\x15\x61\x06\x8c\x57\x60\x00\x80\xfd\x5b\x50\x61\x02" "\x90\x61\x0d\x03\x56\x5b\x34\x80\x15\x61\x06\xa1\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x90\x61\x0d" "\x09\x56\x5b\x34\x80\x15\x61\x06\xb6\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x79\x60\x04\x80\x36\x03" "\x60\x20\x81\x10\x15\x61\x06\xcd\x57\x60\x00\x80\xfd\x5b\x50\x35\x60\x01\x60\x01\x60\xa0\x1b\x03" "\x16\x61\x0d\x53\x56\x5b\x34\x80\x15\x61\x06\xe9\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x79\x60\x04" "\x80\x36\x03\x60\x20\x81\x10\x15\x61\x07\x00\x57\x60\x00\x80\xfd\x5b\x50\x35\x60\x01\x60\x01\x60" "\xa0\x1b\x03\x16\x61\x0e\x05\x56\x5b\x34\x80\x15\x61\x07\x1c\x57\x60\x00\x80\xfd\x5b\x50\x61\x03" "\x3a\x61\x0e\x22\x56\x5b\x60\x40\x80\x51\x80\x82\x01\x90\x91\x52\x60\x17\x81\x52\x7f\x50\x6f\x6c" "\x79\x67\x6f\x6e\x20\x45\x63\x6f\x73\x79\x73\x74\x65\x6d\x20\x54\x6f\x6b\x65\x6e\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x60\x20\x82\x01\x52\x90\x56\x5b\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b" "\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60\x10\x60\x24\x82\x01\x52\x6f\x44\x69\x73\x61\x62\x6c\x65" "\x64\x20\x66\x65\x61\x74\x75\x72\x65\x60\x80\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60" "\x64\x01\x90\xfd\x5b\x6b\x20\x4f\xce\x5e\x3e\x25\x02\x61\x10\x00\x00\x00\x90\x56\x5b\x60\x40\x80" "\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60\x10\x60\x24\x82\x01\x52" "\x6f\x44\x69\x73\x61\x62\x6c\x65\x64\x20\x66\x65\x61\x74\x75\x72\x65\x60\x80\x1b\x60\x44\x82\x01" "\x52\x90\x51\x60\x00\x91\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x33\x60\x00\x61\x07\xfa\x82\x61\x0a" "\x30\x56\x5b\x60\x06\x54\x90\x91\x50\x61\x08\x10\x90\x84\x63\xff\xff\xff\xff\x61\x0e\x31\x16\x56" "\x5b\x60\x06\x55\x82\x15\x80\x15\x90\x61\x08\x21\x57\x50\x82\x34\x14\x5b\x61\x08\x68\x57\x60\x40" "\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60\x13\x60\x24\x82\x01" "\x52\x72\x12\x5b\x9c\xdd\x59\x99\x9a\x58\xda\x59\x5b\x9d\x08\x18\x5b\x5b\xdd\x5b\x9d\x60\x6a\x1b" "\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x60\x02\x54\x60\x01\x60\x01" "\x60\xa0\x1b\x03\x80\x84\x16\x91\x16\x7f\xeb\xff\x26\x02\xb3\xf4\x68\x25\x9e\x1e\x99\xf6\x13\xfe" "\xd6\x69\x1f\x3a\x65\x26\xef\xfe\x6e\xf3\xe7\x68\xba\x7a\xe7\xa3\x6c\x4f\x85\x84\x61\x08\xa4\x87" "\x61\x0a\x30\x56\x5b\x60\x40\x80\x51\x93\x84\x52\x60\x20\x84\x01\x92\x90\x92\x52\x82\x82\x01\x52" "\x51\x90\x81\x90\x03\x60\x60\x01\x90\xa3\x50\x50\x50\x56\x5b\x60\x12\x90\x56\x5b\x60\x03\x54\x60" "\x01\x60\x01\x60\xa0\x1b\x03\x16\x81\x56\x5b\x61\x08\xe2\x61\x0b\xd1\x56\x5b\x61\x08\xeb\x57\x60" "\x00\x80\xfd\x5b\x60\x00\x81\x11\x80\x15\x61\x09\x03\x57\x50\x60\x01\x60\x01\x60\xa0\x1b\x03\x82" "\x16\x15\x15\x5b\x61\x09\x3e\x57\x60\x40\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x04\x01\x80" "\x80\x60\x20\x01\x82\x81\x03\x82\x52\x60\x23\x81\x52\x60\x20\x01\x80\x61\x13\x8d\x60\x23\x91\x39" "\x60\x40\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x00\x61\x09\x49\x83\x61\x0a\x30" "\x56\x5b\x60\x06\x54\x90\x91\x50\x61\x09\x5f\x90\x83\x63\xff\xff\xff\xff\x61\x0e\x46\x16\x56\x5b" "\x60\x06\x55\x61\x09\x6c\x83\x83\x61\x0e\x58\x56\x5b\x60\x02\x54\x60\x01\x60\x01\x60\xa0\x1b\x03" "\x80\x85\x16\x91\x16\x7f\x4e\x2c\xa0\x51\x5e\xd1\xae\xf1\x39\x5f\x66\xb5\x30\x3b\xb5\xd6\xf1\xbf" "\x9d\x61\xa3\x53\xfa\x53\xf7\x3f\x8a\xc9\x97\x3f\xa9\xf6\x84\x84\x61\x08\xa4\x88\x61\x0a\x30\x56" "\x5b\x60\x07\x54\x60\xff\x16\x15\x61\x09\xea\x57\x60\x40\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52" "\x60\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x60\x23\x81\x52\x60\x20\x01\x80\x61\x13\x6a" "\x60\x23\x91\x39\x60\x40\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x07\x80\x54\x60" "\xff\x19\x16\x60\x01\x17\x90\x55\x60\x02\x80\x54\x60\x01\x60\x01\x60\xa0\x1b\x03\x83\x16\x60\x01" "\x60\x01\x60\xa0\x1b\x03\x19\x90\x91\x16\x17\x90\x55\x61\x0a\x1d\x82\x61\x0f\x17\x56\x5b\x50\x50" "\x56\x5b\x60\x04\x54\x60\x01\x60\x01\x60\xa0\x1b\x03\x16\x81\x56\x5b\x60\x01\x60\x01\x60\xa0\x1b" "\x03\x16\x31\x90\x56\x5b\x61\x0a\x45\x61\x0b\xd1\x56\x5b\x61\x0a\x4e\x57\x60\x00\x80\xfd\x5b\x60" "\x00\x80\x54\x60\x40\x51\x60\x01\x60\x01\x60\xa0\x1b\x03\x90\x91\x16\x90\x7f\x8b\xe0\x07\x9c\x53" "\x16\x59\x14\x13\x44\xcd\x1f\xd0\xa4\xf2\x84\x19\x49\x7f\x97\x22\xa3\xda\xaf\xe3\xb4\x18\x6f\x6b" "\x64\x57\xe0\x90\x83\x90\xa3\x60\x00\x80\x54\x60\x01\x60\x01\x60\xa0\x1b\x03\x19\x16\x90\x55\x56" "\x5b\x60\x06\x54\x81\x56\x5b\x60\x00\x80\x60\x00\x80\x84\x51\x60\x41\x14\x61\x0a\xb9\x57\x60\x00" "\x93\x50\x50\x50\x50\x61\x0b\xbc\x56\x5b\x50\x50\x50\x60\x20\x82\x01\x51\x60\x40\x83\x01\x51\x60" "\x41\x84\x01\x51\x60\xff\x16\x60\x1b\x81\x10\x15\x61\x0a\xdb\x57\x60\x1b\x01\x5b\x80\x60\xff\x16" "\x60\x1b\x14\x15\x80\x15\x61\x0a\xf3\x57\x50\x80\x60\xff\x16\x60\x1c\x14\x15\x5b\x15\x61\x0b\x04" "\x57\x60\x00\x93\x50\x50\x50\x50\x61\x0b\xbc\x56\x5b\x60\x40\x80\x51\x60\x00\x81\x52\x60\x20\x80" "\x82\x01\x80\x84\x52\x89\x90\x52\x60\xff\x84\x16\x82\x84\x01\x52\x60\x60\x82\x01\x86\x90\x52\x60" "\x80\x82\x01\x85\x90\x52\x91\x51\x60\x01\x92\x60\xa0\x80\x84\x01\x93\x91\x92\x60\x1f\x19\x81\x01" "\x92\x81\x90\x03\x90\x91\x01\x90\x85\x5a\xfa\x15\x80\x15\x61\x0b\x5b\x57\x3d\x60\x00\x80\x3e\x3d" "\x60\x00\xfd\x5b\x50\x50\x60\x40\x51\x60\x1f\x19\x01\x51\x94\x50\x50\x60\x01\x60\x01\x60\xa0\x1b" "\x03\x84\x16\x61\x0b\xb8\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04" "\x82\x01\x52\x60\x12\x60\x24\x82\x01\x52\x71\x22\xb9\x39\x37\xb9\x10\x34\xb7\x10\x32\xb1\xb9\x32" "\xb1\xb7\xbb\x32\xb9\x60\x71\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd" "\x5b\x50\x50\x50\x5b\x92\x91\x50\x50\x56\x5b\x60\x00\x54\x60\x01\x60\x01\x60\xa0\x1b\x03\x16\x90" "\x56\x5b\x60\x00\x54\x60\x01\x60\x01\x60\xa0\x1b\x03\x16\x33\x14\x90\x56\x5b\x60\x40\x51\x80\x60" "\x40\x01\x60\x40\x52\x80\x60\x02\x81\x52\x60\x20\x01\x61\x3a\x99\x60\xf0\x1b\x81\x52\x50\x81\x56" "\x5b\x60\x40\x80\x51\x80\x82\x01\x90\x91\x52\x60\x03\x81\x52\x62\x14\x13\xd3\x60\xea\x1b\x60\x20" "\x82\x01\x52\x90\x56\x5b\x60\x00\x81\x34\x14\x61\x0c\x2e\x57\x50\x60\x00\x61\x0b\xbc\x56\x5b\x61" "\x0c\x39\x33\x84\x84\x61\x0f\x85\x56\x5b\x93\x92\x50\x50\x50\x56\x5b\x60\x40\x51\x80\x60\x80\x01" "\x60\x40\x52\x80\x60\x5b\x81\x52\x60\x20\x01\x61\x14\x34\x60\x5b\x91\x39\x60\x40\x51\x60\x20\x01" "\x80\x82\x80\x51\x90\x60\x20\x01\x90\x80\x83\x83\x5b\x60\x20\x83\x10\x61\x0c\x8b\x57\x80\x51\x82" "\x52\x60\x1f\x19\x90\x92\x01\x91\x60\x20\x91\x82\x01\x91\x01\x61\x0c\x6c\x56\x5b\x60\x01\x83\x60" "\x20\x03\x61\x01\x00\x0a\x03\x80\x19\x82\x51\x16\x81\x84\x51\x16\x80\x82\x17\x85\x52\x50\x50\x50" "\x50\x50\x50\x90\x50\x01\x91\x50\x50\x60\x40\x51\x60\x20\x81\x83\x03\x03\x81\x52\x90\x60\x40\x52" "\x80\x51\x90\x60\x20\x01\x20\x81\x56\x5b\x60\x05\x60\x20\x52\x60\x00\x90\x81\x52\x60\x40\x90\x20" "\x54\x60\xff\x16\x81\x56\x5b\x60\x00\x61\x0c\xf4\x61\x0c\xef\x86\x86\x86\x86\x61\x11\xd2\x56\x5b" "\x61\x12\x8b\x56\x5b\x95\x94\x50\x50\x50\x50\x50\x56\x5b\x61\x3a\x99\x81\x56\x5b\x60\x01\x54\x81" "\x56\x5b\x60\x40\x51\x80\x60\x80\x01\x60\x40\x52\x80\x60\x52\x81\x52\x60\x20\x01\x61\x13\xb0\x60" "\x52\x91\x39\x60\x40\x51\x60\x20\x01\x80\x82\x80\x51\x90\x60\x20\x01\x90\x80\x83\x83\x60\x20\x83" "\x10\x61\x0c\x8b\x57\x80\x51\x82\x52\x60\x1f\x19\x90\x92\x01\x91\x60\x20\x91\x82\x01\x91\x01\x61" "\x0c\x6c\x56\x5b\x61\x0d\x5b\x61\x0b\xd1\x56\x5b\x61\x0d\x64\x57\x60\x00\x80\xfd\x5b\x60\x01\x60" "\x01\x60\xa0\x1b\x03\x81\x16\x61\x0d\xa9\x57\x60\x40\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60" "\x04\x01\x80\x80\x60\x20\x01\x82\x81\x03\x82\x52\x60\x32\x81\x52\x60\x20\x01\x80\x61\x14\x02\x60" "\x32\x91\x39\x60\x40\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xfd\x5b\x60\x03\x54\x60\x40\x51" "\x60\x01\x60\x01\x60\xa0\x1b\x03\x80\x84\x16\x92\x16\x90\x7f\x1f\x9f\x35\x56\xdd\x33\x60\x16\xcd" "\xf2\x0a\xda\xea\xd7\xd5\xc7\x36\x65\xdb\xa6\x64\xb6\x0e\x8c\x17\xe9\xa4\xeb\x91\xce\x1d\x39\x90" "\x60\x00\x90\xa3\x60\x03\x80\x54\x60\x01\x60\x01\x60\xa0\x1b\x03\x19\x16\x60\x01\x60\x01\x60\xa0" "\x1b\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90\x55\x56\x5b\x61\x0e\x0d\x61\x0b\xd1\x56\x5b\x61\x0e" "\x16\x57\x60\x00\x80\xfd\x5b\x61\x0e\x1f\x81\x61\x0f\x17\x56\x5b\x50\x56\x5b\x60\x02\x54\x60\x01" "\x60\x01\x60\xa0\x1b\x03\x16\x81\x56\x5b\x60\x00\x82\x82\x11\x15\x61\x0e\x40\x57\x60\x00\x80\xfd" "\x5b\x50\x90\x03\x90\x56\x5b\x60\x00\x82\x82\x01\x83\x81\x10\x15\x61\x0c\x39\x57\x60\x00\x80\xfd" "\x5b\x60\x08\x54\x15\x61\x0e\x9a\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20" "\x60\x04\x82\x01\x52\x60\x0a\x60\x24\x82\x01\x52\x69\x72\x65\x65\x6e\x74\x72\x61\x6e\x63\x79\x60" "\xb0\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x60\x01\x60\x08\x55" "\x60\x40\x51\x61\x13\x88\x90\x60\x00\x90\x60\x60\x90\x60\x01\x60\x01\x60\xa0\x1b\x03\x86\x16\x90" "\x84\x90\x86\x90\x85\x81\x81\x81\x85\x88\x88\xf1\x93\x50\x50\x50\x50\x3d\x80\x60\x00\x81\x14\x61" "\x0e\xf4\x57\x60\x40\x51\x91\x50\x60\x1f\x19\x60\x3f\x3d\x01\x16\x82\x01\x60\x40\x52\x3d\x82\x52" "\x3d\x60\x00\x60\x20\x84\x01\x3e\x61\x0e\xf9\x56\x5b\x60\x60\x91\x50\x5b\x50\x91\x50\x91\x50\x81" "\x61\x0f\x0b\x57\x80\x51\x60\x20\x82\x01\xfd\x5b\x50\x50\x60\x00\x60\x08\x55\x50\x50\x50\x56\x5b" "\x60\x01\x60\x01\x60\xa0\x1b\x03\x81\x16\x61\x0f\x2a\x57\x60\x00\x80\xfd\x5b\x60\x00\x80\x54\x60" "\x40\x51\x60\x01\x60\x01\x60\xa0\x1b\x03\x80\x85\x16\x93\x92\x16\x91\x7f\x8b\xe0\x07\x9c\x53\x16" "\x59\x14\x13\x44\xcd\x1f\xd0\xa4\xf2\x84\x19\x49\x7f\x97\x22\xa3\xda\xaf\xe3\xb4\x18\x6f\x6b\x64" "\x57\xe0\x91\xa3\x60\x00\x80\x54\x60\x01\x60\x01\x60\xa0\x1b\x03\x19\x16\x60\x01\x60\x01\x60\xa0" "\x1b\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90\x55\x56\x5b\x60\x40\x80\x51\x63\x70\xa0\x82\x31\x60" "\xe0\x1b\x81\x52\x60\x01\x60\x01\x60\xa0\x1b\x03\x85\x16\x60\x04\x82\x01\x52\x90\x51\x60\x00\x91" "\x82\x91\x30\x91\x63\x70\xa0\x82\x31\x91\x60\x24\x80\x83\x01\x92\x60\x20\x92\x91\x90\x82\x90\x03" "\x01\x81\x86\x80\x3b\x15\x80\x15\x61\x0f\xd0\x57\x60\x00\x80\xfd\x5b\x50\x5a\xfa\x15\x80\x15\x61" "\x0f\xe4\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50\x50\x60\x40\x51\x3d\x60\x20\x81" "\x10\x15\x61\x0f\xfa\x57\x60\x00\x80\xfd\x5b\x50\x51\x60\x40\x80\x51\x63\x70\xa0\x82\x31\x60\xe0" "\x1b\x81\x52\x60\x01\x60\x01\x60\xa0\x1b\x03\x87\x16\x60\x04\x82\x01\x52\x90\x51\x91\x92\x50\x60" "\x00\x91\x30\x91\x63\x70\xa0\x82\x31\x91\x60\x24\x80\x83\x01\x92\x60\x20\x92\x91\x90\x82\x90\x03" "\x01\x81\x86\x80\x3b\x15\x80\x15\x61\x10\x48\x57\x60\x00\x80\xfd\x5b\x50\x5a\xfa\x15\x80\x15\x61" "\x10\x5c\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50\x50\x60\x40\x51\x3d\x60\x20\x81" "\x10\x15\x61\x10\x72\x57\x60\x00\x80\xfd\x5b\x50\x51\x90\x50\x61\x10\x81\x86\x86\x86\x61\x12\x99" "\x56\x5b\x60\x02\x54\x60\x40\x80\x51\x63\x70\xa0\x82\x31\x60\xe0\x1b\x81\x52\x60\x01\x60\x01\x60" "\xa0\x1b\x03\x89\x81\x16\x60\x04\x83\x01\x81\x90\x52\x92\x51\x81\x8a\x16\x94\x90\x91\x16\x91\x7f" "\xe6\x49\x7e\x3e\xe5\x48\xa3\x37\x21\x36\xaf\x2f\xcb\x06\x96\xdb\x31\xfc\x6c\xf2\x02\x60\x70\x76" "\x45\x06\x8b\xd3\xfe\x97\xf3\xc4\x91\x89\x91\x88\x91\x88\x91\x30\x91\x63\x70\xa0\x82\x31\x91\x60" "\x24\x80\x82\x01\x92\x60\x20\x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80\x3b\x15\x80\x15\x61\x10" "\xfe\x57\x60\x00\x80\xfd\x5b\x50\x5a\xfa\x15\x80\x15\x61\x11\x12\x57\x3d\x60\x00\x80\x3e\x3d\x60" "\x00\xfd\x5b\x50\x50\x50\x50\x60\x40\x51\x3d\x60\x20\x81\x10\x15\x61\x11\x28\x57\x60\x00\x80\xfd" "\x5b\x50\x51\x60\x40\x80\x51\x63\x70\xa0\x82\x31\x60\xe0\x1b\x81\x52\x60\x01\x60\x01\x60\xa0\x1b" "\x03\x8f\x16\x60\x04\x82\x01\x52\x90\x51\x30\x91\x63\x70\xa0\x82\x31\x91\x60\x24\x80\x83\x01\x92" "\x60\x20\x92\x91\x90\x82\x90\x03\x01\x81\x86\x80\x3b\x15\x80\x15\x61\x11\x70\x57\x60\x00\x80\xfd" "\x5b\x50\x5a\xfa\x15\x80\x15\x61\x11\x84\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x50\x50" "\x50\x60\x40\x51\x3d\x60\x20\x81\x10\x15\x61\x11\x9a\x57\x60\x00\x80\xfd\x5b\x50\x51\x60\x40\x80" "\x51\x95\x86\x52\x60\x20\x86\x01\x94\x90\x94\x52\x84\x84\x01\x92\x90\x92\x52\x60\x60\x84\x01\x52" "\x60\x80\x83\x01\x52\x51\x90\x81\x90\x03\x60\xa0\x01\x90\xa4\x50\x60\x01\x95\x94\x50\x50\x50\x50" "\x50\x56\x5b\x60\x00\x80\x60\x40\x51\x80\x60\x80\x01\x60\x40\x52\x80\x60\x5b\x81\x52\x60\x20\x01" "\x61\x14\x34\x60\x5b\x91\x39\x60\x40\x51\x60\x20\x01\x80\x82\x80\x51\x90\x60\x20\x01\x90\x80\x83" "\x83\x5b\x60\x20\x83\x10\x61\x12\x20\x57\x80\x51\x82\x52\x60\x1f\x19\x90\x92\x01\x91\x60\x20\x91" "\x82\x01\x91\x01\x61\x12\x01\x56\x5b\x51\x81\x51\x60\x20\x93\x84\x03\x61\x01\x00\x0a\x60\x00\x19" "\x01\x80\x19\x90\x92\x16\x91\x16\x17\x90\x52\x60\x40\x80\x51\x92\x90\x94\x01\x82\x81\x03\x60\x1f" "\x19\x01\x83\x52\x80\x85\x52\x82\x51\x92\x82\x01\x92\x90\x92\x20\x82\x52\x60\x01\x60\x01\x60\xa0" "\x1b\x03\x9b\x90\x9b\x16\x9a\x81\x01\x9a\x90\x9a\x52\x50\x88\x01\x96\x90\x96\x52\x50\x50\x50\x60" "\x60\x84\x01\x91\x90\x91\x52\x60\x80\x83\x01\x52\x50\x60\xa0\x90\x20\x90\x56\x5b\x60\x00\x61\x0b" "\xbc\x82\x60\x01\x54\x61\x13\x47\x56\x5b\x60\x01\x60\x01\x60\xa0\x1b\x03\x82\x16\x30\x14\x15\x61" "\x12\xed\x57\x60\x40\x80\x51\x62\x46\x1b\xcd\x60\xe5\x1b\x81\x52\x60\x20\x60\x04\x82\x01\x52\x60" "\x13\x60\x24\x82\x01\x52\x72\x06\x36\x16\xe2\x77\x42\x07\x36\x56\xe6\x42\x07\x46\xf2\x04\xd5\x24" "\x33\x23\x60\x6c\x1b\x60\x44\x82\x01\x52\x90\x51\x90\x81\x90\x03\x60\x64\x01\x90\xfd\x5b\x61\x12" "\xf7\x82\x82\x61\x0e\x58\x56\x5b\x81\x60\x01\x60\x01\x60\xa0\x1b\x03\x16\x83\x60\x01\x60\x01\x60" "\xa0\x1b\x03\x16\x7f\xdd\xf2\x52\xad\x1b\xe2\xc8\x9b\x69\xc2\xb0\x68\xfc\x37\x8d\xaa\x95\x2b\xa7" "\xf1\x63\xc4\xa1\x16\x28\xf5\x5a\x4d\xf5\x23\xb3\xef\x83\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01" "\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa3\x50\x50\x50\x56\x5b\x60\x40\x51\x61\x19\x01\x60\xf0" "\x1b\x81\x52\x60\x02\x81\x01\x91\x90\x91\x52\x60\x22\x81\x01\x91\x90\x91\x52\x60\x42\x90\x20\x90" "\x56\xfe\x54\x68\x65\x20\x63\x6f\x6e\x74\x72\x61\x63\x74\x20\x69\x73\x20\x61\x6c\x72\x65\x61\x64" "\x79\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x64\x49\x6e\x73\x75\x66\x66\x69\x63\x69\x65\x6e" "\x74\x20\x61\x6d\x6f\x75\x6e\x74\x20\x6f\x72\x20\x69\x6e\x76\x61\x6c\x69\x64\x20\x75\x73\x65\x72" "\x45\x49\x50\x37\x31\x32\x44\x6f\x6d\x61\x69\x6e\x28\x73\x74\x72\x69\x6e\x67\x20\x6e\x61\x6d\x65" "\x2c\x73\x74\x72\x69\x6e\x67\x20\x76\x65\x72\x73\x69\x6f\x6e\x2c\x75\x69\x6e\x74\x32\x35\x36\x20" "\x63\x68\x61\x69\x6e\x49\x64\x2c\x61\x64\x64\x72\x65\x73\x73\x20\x76\x65\x72\x69\x66\x79\x69\x6e" "\x67\x43\x6f\x6e\x74\x72\x61\x63\x74\x29\x43\x68\x69\x6c\x64\x20\x74\x6f\x6b\x65\x6e\x3a\x20\x6e" "\x65\x77\x20\x63\x68\x69\x6c\x64\x20\x61\x64\x64\x72\x65\x73\x73\x20\x69\x73\x20\x74\x68\x65\x20" "\x7a\x65\x72\x6f\x20\x61\x64\x64\x72\x65\x73\x73\x54\x6f\x6b\x65\x6e\x54\x72\x61\x6e\x73\x66\x65" "\x72\x4f\x72\x64\x65\x72\x28\x61\x64\x64\x72\x65\x73\x73\x20\x73\x70\x65\x6e\x64\x65\x72\x2c\x75" "\x69\x6e\x74\x32\x35\x36\x20\x74\x6f\x6b\x65\x6e\x49\x64\x4f\x72\x41\x6d\x6f\x75\x6e\x74\x2c\x62" "\x79\x74\x65\x73\x33\x32\x20\x64\x61\x74\x61\x2c\x75\x69\x6e\x74\x32\x35\x36\x20\x65\x78\x70\x69" "\x72\x61\x74\x69\x6f\x6e\x29\xa2\x65\x62\x7a\x7a\x72\x31\x58\x20\x5f\x23\xbe\x75\x74\xe7\x0c\xfc" "\x01\xd0\xcf\xd6\x80\x3b\x87\x1f\x92\x46\x5e\x9a\xe4\xa1\x0f\xe9\x5e\xd3\x1c\xcb\x81\x0b\xda\x3e" "\x64\x73\x6f\x6c\x63\x43\x00\x05\x11\x00\x32"sv, }, { 0x360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9_address, "\x60\x80\x60\x40\x52\x60\x04\x36\x10\x61\x00\xaf\x57\x60\x00\x35\x7c\x01\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x04" "\x63\xff\xff\xff\xff\x16\x80\x63\x06\xfd\xde\x03\x14\x61\x00\xb9\x57\x80\x63\x09\x5e\xa7\xb3\x14" "\x61\x01\x49\x57\x80\x63\x18\x16\x0d\xdd\x14\x61\x01\xae\x57\x80\x63\x23\xb8\x72\xdd\x14\x61\x01" "\xd9\x57\x80\x63\x2e\x1a\x7d\x4d\x14\x61\x02\x5e\x57\x80\x63\x31\x3c\xe5\x67\x14\x61\x02\x8b\x57" "\x80\x63\x70\xa0\x82\x31\x14\x61\x02\xbc\x57\x80\x63\x95\xd8\x9b\x41\x14\x61\x03\x13\x57\x80\x63" "\xa9\x05\x9c\xbb\x14\x61\x03\xa3\x57\x80\x63\xd0\xe3\x0d\xb0\x14\x61\x04\x08\x57\x80\x63\xdd\x62" "\xed\x3e\x14\x61\x04\x12\x57\x5b\x61\x00\xb7\x61\x04\x89\x56\x5b\x00\x5b\x34\x80\x15\x61\x00\xc5" "\x57\x60\x00\x80\xfd\x5b\x50\x61\x00\xce\x61\x05\x26\x56\x5b\x60\x40\x51\x80\x80\x60\x20\x01\x82" "\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20\x01\x90\x80\x83" "\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x01\x0e\x57\x80\x82\x01\x51\x81\x84\x01\x52\x60\x20\x81\x01" "\x90\x50\x61\x00\xf3\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x01" "\x3b\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20" "\x01\x91\x50\x5b\x50\x92\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x01\x55" "\x57\x60\x00\x80\xfd\x5b\x50\x61\x01\x94\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90" "\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x05\xc4\x56\x5b\x60\x40\x51" "\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34" "\x80\x15\x61\x01\xba\x57\x60\x00\x80\xfd\x5b\x50\x61\x01\xc3\x61\x06\xb6\x56\x5b\x60\x40\x51\x80" "\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x01\xe5" "\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x44\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90" "\x92\x91\x90\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50" "\x61\x06\xd5\x56\x5b\x60\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40" "\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x02\x6a\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x89\x60" "\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0a\x22" "\x56\x5b\x00\x5b\x34\x80\x15\x61\x02\x97\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\xa0\x61\x0b\x55\x56" "\x5b\x60\x40\x51\x80\x82\x60\xff\x16\x60\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80" "\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x02\xc8\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\xfd\x60\x04\x80" "\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0b\x68\x56\x5b\x60\x40" "\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61" "\x03\x1f\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\x28\x61\x0b\x80\x56\x5b\x60\x40\x51\x80\x80\x60\x20" "\x01\x82\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20\x01\x90" "\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x03\x68\x57\x80\x82\x01\x51\x81\x84\x01\x52\x60\x20" "\x81\x01\x90\x50\x61\x03\x4d\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15" "\x61\x03\x95\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52" "\x60\x20\x01\x91\x50\x5b\x50\x92\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61" "\x03\xaf\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\xee\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20" "\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0c\x1e\x56\x5b\x60" "\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3" "\x5b\x61\x04\x10\x61\x04\x89\x56\x5b\x00\x5b\x34\x80\x15\x61\x04\x1e\x57\x60\x00\x80\xfd\x5b\x50" "\x61\x04\x73\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x73\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01" "\x90\x92\x91\x90\x50\x50\x50\x61\x0c\x33\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50" "\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x60\x03\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60" "\x00\x20\x60\x00\x82\x82\x54\x01\x92\x50\x50\x81\x90\x55\x50\x33\x73\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\xe1\xff\xfc\xc4\x92\x3d\x04\xb5\x59" "\xf4\xd2\x9a\x8b\xfc\x6c\xda\x04\xeb\x5b\x0d\x3c\x46\x07\x51\xc2\x40\x2c\x5c\x5c\xc9\x10\x9c\x34" "\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa2\x56\x5b\x60" "\x00\x80\x54\x60\x01\x81\x60\x01\x16\x15\x61\x01\x00\x02\x03\x16\x60\x02\x90\x04\x80\x60\x1f\x01" "\x60\x20\x80\x91\x04\x02\x60\x20\x01\x60\x40\x51\x90\x81\x01\x60\x40\x52\x80\x92\x91\x90\x81\x81" "\x52\x60\x20\x01\x82\x80\x54\x60\x01\x81\x60\x01\x16\x15\x61\x01\x00\x02\x03\x16\x60\x02\x90\x04" "\x80\x15\x61\x05\xbc\x57\x80\x60\x1f\x10\x61\x05\x91\x57\x61\x01\x00\x80\x83\x54\x04\x02\x83\x52" "\x91\x60\x20\x01\x91\x61\x05\xbc\x56\x5b\x82\x01\x91\x90\x60\x00\x52\x60\x20\x60\x00\x20\x90\x5b" "\x81\x54\x81\x52\x90\x60\x01\x01\x90\x60\x20\x01\x80\x83\x11\x61\x05\x9f\x57\x82\x90\x03\x60\x1f" "\x16\x82\x01\x91\x5b\x50\x50\x50\x50\x50\x81\x56\x5b\x60\x00\x81\x60\x04\x60\x00\x33\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81" "\x52\x60\x20\x01\x60\x00\x20\x60\x00\x85\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x81\x90\x55\x50" "\x82\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x33" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\x8c" "\x5b\xe1\xe5\xeb\xec\x7d\x5b\xd1\x4f\x71\x42\x7d\x1e\x84\xf3\xdd\x03\x14\xc0\xf7\xb2\x29\x1e\x5b" "\x20\x0a\xc8\xc7\xc3\xb9\x25\x84\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51" "\x80\x91\x03\x90\xa3\x60\x01\x90\x50\x92\x91\x50\x50\x56\x5b\x60\x00\x30\x73\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x31\x90\x50\x90\x56\x5b\x60\x00" "\x81\x60\x03\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x54\x10\x15\x15\x15\x61\x07\x25" "\x57\x60\x00\x80\xfd\x5b\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\x16\x84\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x14\x15\x80\x15\x61\x07\xfd\x57\x50\x7f\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\x60\x04" "\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81" "\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60" "\x00\x20\x54\x14\x15\x5b\x15\x61\x09\x18\x57\x81\x60\x04\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01" "\x60\x00\x20\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x54\x10\x15\x15\x15\x61\x08\x8d" "\x57\x60\x00\x80\xfd\x5b\x81\x60\x04\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00" "\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60" "\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x82\x82\x54\x03\x92\x50\x50\x81\x90\x55\x50" "\x5b\x81\x60\x03\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x82\x82\x54\x03\x92" "\x50\x50\x81\x90\x55\x50\x81\x60\x03\x60\x00\x85\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00" "\x82\x82\x54\x01\x92\x50\x50\x81\x90\x55\x50\x82\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x84\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\xdd\xf2\x52\xad\x1b\xe2\xc8\x9b\x69\xc2\xb0\x68\xfc\x37" "\x8d\xaa\x95\x2b\xa7\xf1\x63\xc4\xa1\x16\x28\xf5\x5a\x4d\xf5\x23\xb3\xef\x84\x60\x40\x51\x80\x82" "\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa3\x60\x01\x90\x50\x93\x92\x50\x50" "\x50\x56\x5b\x80\x60\x03\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x54\x10\x15\x15\x15" "\x61\x0a\x70\x57\x60\x00\x80\xfd\x5b\x80\x60\x03\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00" "\x20\x60\x00\x82\x82\x54\x03\x92\x50\x50\x81\x90\x55\x50\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x61\x08\xfc\x82\x90\x81\x15\x02\x90\x60\x40" "\x51\x60\x00\x60\x40\x51\x80\x83\x03\x81\x85\x88\x88\xf1\x93\x50\x50\x50\x50\x15\x80\x15\x61\x0b" "\x03\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\x7f\xcf\x53\x2c\x15\xf0\xa6\xdb\x0b\xd6\xd0" "\xe0\x38\xbe\xa7\x1d\x30\xd8\x08\xc7\xd9\x8c\xb3\xbf\x72\x68\xa9\x5b\xf5\x08\x1b\x65\x82\x60\x40" "\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa2\x50\x56\x5b\x60\x02" "\x60\x00\x90\x54\x90\x61\x01\x00\x0a\x90\x04\x60\xff\x16\x81\x56\x5b\x60\x03\x60\x20\x52\x80\x60" "\x00\x52\x60\x40\x60\x00\x20\x60\x00\x91\x50\x90\x50\x54\x81\x56\x5b\x60\x01\x80\x54\x60\x01\x81" "\x60\x01\x16\x15\x61\x01\x00\x02\x03\x16\x60\x02\x90\x04\x80\x60\x1f\x01\x60\x20\x80\x91\x04\x02" "\x60\x20\x01\x60\x40\x51\x90\x81\x01\x60\x40\x52\x80\x92\x91\x90\x81\x81\x52\x60\x20\x01\x82\x80" "\x54\x60\x01\x81\x60\x01\x16\x15\x61\x01\x00\x02\x03\x16\x60\x02\x90\x04\x80\x15\x61\x0c\x16\x57" "\x80\x60\x1f\x10\x61\x0b\xeb\x57\x61\x01\x00\x80\x83\x54\x04\x02\x83\x52\x91\x60\x20\x01\x91\x61" "\x0c\x16\x56\x5b\x82\x01\x91\x90\x60\x00\x52\x60\x20\x60\x00\x20\x90\x5b\x81\x54\x81\x52\x90\x60" "\x01\x01\x90\x60\x20\x01\x80\x83\x11\x61\x0b\xf9\x57\x82\x90\x03\x60\x1f\x16\x82\x01\x91\x5b\x50" "\x50\x50\x50\x50\x81\x56\x5b\x60\x00\x61\x0c\x2b\x33\x84\x84\x61\x06\xd5\x56\x5b\x90\x50\x92\x91" "\x50\x50\x56\x5b\x60\x04\x60\x20\x52\x81\x60\x00\x52\x60\x40\x60\x00\x20\x60\x20\x52\x80\x60\x00" "\x52\x60\x40\x60\x00\x20\x60\x00\x91\x50\x91\x50\x50\x54\x81\x56\x00\xa1\x65\x62\x7a\x7a\x72\x30" "\x58\x20\xea\x7b\x3a\x90\xa8\x99\x69\xeb\x00\xd2\xa5\x6f\x58\xb0\xf8\x04\x81\x94\x44\x75\x90\x8a" "\xcf\x25\x43\x87\x59\xb5\x3b\xe7\x3e\x5b\x00\x29"sv, }}, }, { 12121856, {{ 0x360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9_address, "\x60\x80\x60\x40\x52\x60\x04\x36\x10\x61\x00\xaf\x57\x60\x00\x35\x7c\x01\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x04" "\x63\xff\xff\xff\xff\x16\x80\x63\x06\xfd\xde\x03\x14\x61\x00\xb9\x57\x80\x63\x09\x5e\xa7\xb3\x14" "\x61\x01\x49\x57\x80\x63\x18\x16\x0d\xdd\x14\x61\x01\xae\x57\x80\x63\x23\xb8\x72\xdd\x14\x61\x01" "\xd9\x57\x80\x63\x2e\x1a\x7d\x4d\x14\x61\x02\x5e\x57\x80\x63\x31\x3c\xe5\x67\x14\x61\x02\x8b\x57" "\x80\x63\x70\xa0\x82\x31\x14\x61\x02\xbc\x57\x80\x63\x95\xd8\x9b\x41\x14\x61\x03\x13\x57\x80\x63" "\xa9\x05\x9c\xbb\x14\x61\x03\xa3\x57\x80\x63\xd0\xe3\x0d\xb0\x14\x61\x04\x08\x57\x80\x63\xdd\x62" "\xed\x3e\x14\x61\x04\x12\x57\x5b\x61\x00\xb7\x61\x04\x89\x56\x5b\x00\x5b\x34\x80\x15\x61\x00\xc5" "\x57\x60\x00\x80\xfd\x5b\x50\x61\x00\xce\x61\x05\x26\x56\x5b\x60\x40\x51\x80\x80\x60\x20\x01\x82" "\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20\x01\x90\x80\x83" "\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x01\x0e\x57\x80\x82\x01\x51\x81\x84\x01\x52\x60\x20\x81\x01" "\x90\x50\x61\x00\xf3\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15\x61\x01" "\x3b\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52\x60\x20" "\x01\x91\x50\x5b\x50\x92\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x01\x55" "\x57\x60\x00\x80\xfd\x5b\x50\x61\x01\x94\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90" "\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x05\x63\x56\x5b\x60\x40\x51" "\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34" "\x80\x15\x61\x01\xba\x57\x60\x00\x80\xfd\x5b\x50\x61\x01\xc3\x61\x06\x55\x56\x5b\x60\x40\x51\x80" "\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x01\xe5" "\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x44\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90" "\x92\x91\x90\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50" "\x61\x06\x74\x56\x5b\x60\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40" "\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x02\x6a\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\x89\x60" "\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x09\xc1" "\x56\x5b\x00\x5b\x34\x80\x15\x61\x02\x97\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\xa0\x61\x0a\xf4\x56" "\x5b\x60\x40\x51\x80\x82\x60\xff\x16\x60\xff\x16\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80" "\x91\x03\x90\xf3\x5b\x34\x80\x15\x61\x02\xc8\x57\x60\x00\x80\xfd\x5b\x50\x61\x02\xfd\x60\x04\x80" "\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0a\xfd\x56\x5b\x60\x40" "\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61" "\x03\x1f\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\x28\x61\x0b\x15\x56\x5b\x60\x40\x51\x80\x80\x60\x20" "\x01\x82\x81\x03\x82\x52\x83\x81\x81\x51\x81\x52\x60\x20\x01\x91\x50\x80\x51\x90\x60\x20\x01\x90" "\x80\x83\x83\x60\x00\x5b\x83\x81\x10\x15\x61\x03\x68\x57\x80\x82\x01\x51\x81\x84\x01\x52\x60\x20" "\x81\x01\x90\x50\x61\x03\x4d\x56\x5b\x50\x50\x50\x50\x90\x50\x90\x81\x01\x90\x60\x1f\x16\x80\x15" "\x61\x03\x95\x57\x80\x82\x03\x80\x51\x60\x01\x83\x60\x20\x03\x61\x01\x00\x0a\x03\x19\x16\x81\x52" "\x60\x20\x01\x91\x50\x5b\x50\x92\x50\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x80\x15\x61" "\x03\xaf\x57\x60\x00\x80\xfd\x5b\x50\x61\x03\xee\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20" "\x01\x90\x92\x91\x90\x80\x35\x90\x60\x20\x01\x90\x92\x91\x90\x50\x50\x50\x61\x0b\x52\x56\x5b\x60" "\x40\x51\x80\x82\x15\x15\x15\x15\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xf3" "\x5b\x61\x04\x10\x61\x04\x89\x56\x5b\x00\x5b\x34\x80\x15\x61\x04\x1e\x57\x60\x00\x80\xfd\x5b\x50" "\x61\x04\x73\x60\x04\x80\x36\x03\x81\x01\x90\x80\x80\x35\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01\x90\x92\x91\x90\x80\x35\x73\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x90\x60\x20\x01" "\x90\x92\x91\x90\x50\x50\x50\x61\x0b\x67\x56\x5b\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50" "\x50\x60\x40\x51\x80\x91\x03\x90\xf3\x5b\x34\x60\x03\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60" "\x00\x20\x60\x00\x82\x82\x54\x01\x92\x50\x50\x81\x90\x55\x50\x33\x73\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\xe1\xff\xfc\xc4\x92\x3d\x04\xb5\x59" "\xf4\xd2\x9a\x8b\xfc\x6c\xda\x04\xeb\x5b\x0d\x3c\x46\x07\x51\xc2\x40\x2c\x5c\x5c\xc9\x10\x9c\x34" "\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa2\x56\x5b\x60" "\x60\x60\x40\x80\x51\x90\x81\x01\x60\x40\x52\x80\x60\x1f\x81\x52\x60\x20\x01\x7f\x57\x72\x61\x70" "\x70\x65\x64\x20\x50\x6f\x6c\x79\x67\x6f\x6e\x20\x45\x63\x6f\x73\x79\x73\x74\x65\x6d\x20\x54\x6f" "\x6b\x65\x6e\x00\x81\x52\x50\x90\x50\x90\x56\x5b\x60\x00\x81\x60\x04\x60\x00\x33\x73\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52" "\x60\x20\x01\x60\x00\x20\x60\x00\x85\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x81\x90\x55\x50\x82" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x33\x73" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\x8c\x5b" "\xe1\xe5\xeb\xec\x7d\x5b\xd1\x4f\x71\x42\x7d\x1e\x84\xf3\xdd\x03\x14\xc0\xf7\xb2\x29\x1e\x5b\x20" "\x0a\xc8\xc7\xc3\xb9\x25\x84\x60\x40\x51\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80" "\x91\x03\x90\xa3\x60\x01\x90\x50\x92\x91\x50\x50\x56\x5b\x60\x00\x30\x73\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x31\x90\x50\x90\x56\x5b\x60\x00\x81" "\x60\x03\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x54\x10\x15\x15\x15\x61\x06\xc4\x57" "\x60\x00\x80\xfd\x5b\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x84\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x14\x15\x80\x15\x61\x07\x9c\x57\x50\x7f\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\x60\x04\x60" "\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52" "\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00" "\x20\x54\x14\x15\x5b\x15\x61\x08\xb7\x57\x81\x60\x04\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60" "\x00\x20\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x54\x10\x15\x15\x15\x61\x08\x2c\x57" "\x60\x00\x80\xfd\x5b\x81\x60\x04\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x33" "\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20" "\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x82\x82\x54\x03\x92\x50\x50\x81\x90\x55\x50\x5b" "\x81\x60\x03\x60\x00\x86\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x82\x82\x54\x03\x92\x50" "\x50\x81\x90\x55\x50\x81\x60\x03\x60\x00\x85\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x60\x00\x82" "\x82\x54\x01\x92\x50\x50\x81\x90\x55\x50\x82\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\x16\x84\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\x16\x7f\xdd\xf2\x52\xad\x1b\xe2\xc8\x9b\x69\xc2\xb0\x68\xfc\x37\x8d" "\xaa\x95\x2b\xa7\xf1\x63\xc4\xa1\x16\x28\xf5\x5a\x4d\xf5\x23\xb3\xef\x84\x60\x40\x51\x80\x82\x81" "\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa3\x60\x01\x90\x50\x93\x92\x50\x50\x50" "\x56\x5b\x80\x60\x03\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20\x54\x10\x15\x15\x15\x61" "\x0a\x0f\x57\x60\x00\x80\xfd\x5b\x80\x60\x03\x60\x00\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x81\x52\x60\x20\x01\x90\x81\x52\x60\x20\x01\x60\x00\x20" "\x60\x00\x82\x82\x54\x03\x92\x50\x50\x81\x90\x55\x50\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x61\x08\xfc\x82\x90\x81\x15\x02\x90\x60\x40\x51" "\x60\x00\x60\x40\x51\x80\x83\x03\x81\x85\x88\x88\xf1\x93\x50\x50\x50\x50\x15\x80\x15\x61\x0a\xa2" "\x57\x3d\x60\x00\x80\x3e\x3d\x60\x00\xfd\x5b\x50\x33\x73\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x7f\x7f\xcf\x53\x2c\x15\xf0\xa6\xdb\x0b\xd6\xd0\xe0" "\x38\xbe\xa7\x1d\x30\xd8\x08\xc7\xd9\x8c\xb3\xbf\x72\x68\xa9\x5b\xf5\x08\x1b\x65\x82\x60\x40\x51" "\x80\x82\x81\x52\x60\x20\x01\x91\x50\x50\x60\x40\x51\x80\x91\x03\x90\xa2\x50\x56\x5b\x60\x00\x60" "\x12\x90\x50\x90\x56\x5b\x60\x03\x60\x20\x52\x80\x60\x00\x52\x60\x40\x60\x00\x20\x60\x00\x91\x50" "\x90\x50\x54\x81\x56\x5b\x60\x60\x60\x40\x80\x51\x90\x81\x01\x60\x40\x52\x80\x60\x04\x81\x52\x60" "\x20\x01\x7f\x57\x50\x4f\x4c\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\x81\x52\x50\x90\x50\x90\x56\x5b\x60\x00\x61\x0b\x5f" "\x33\x84\x84\x61\x06\x74\x56\x5b\x90\x50\x92\x91\x50\x50\x56\x5b\x60\x04\x60\x20\x52\x81\x60\x00" "\x52\x60\x40\x60\x00\x20\x60\x20\x52\x80\x60\x00\x52\x60\x40\x60\x00\x20\x60\x00\x91\x50\x91\x50" "\x50\x54\x81\x56\x00\xa1\x65\x62\x7a\x7a\x72\x30\x58\x20\x8d\x70\xd8\xaa\x2d\x75\x25\x33\x10\x5b" "\x5c\xcd\xa8\x20\x6d\xae\x8b\x0c\x1d\xe7\x65\xf8\x9f\xb1\xf0\xc5\x72\x7c\xba\xc1\xb4\x0d\x00\x29"sv, }}, }, }, .jaipur_block = 73100, .agra_block = 73100, }, }; } // namespace silkworm ================================================ FILE: silkworm/core/chain/config.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { namespace protocol { // Already merged at genesis struct NoPreMergeConfig { bool operator==(const NoPreMergeConfig&) const = default; }; //! \see IRuleSet using PreMergeRuleSetConfig = std::variant; } // namespace protocol using ChainId = uint64_t; struct ChainConfig { //! \brief Returns the chain identifier //! \see https://eips.ethereum.org/EIPS/eip-155 ChainId chain_id{0}; //! \brief Holds the hash of genesis block std::optional genesis_hash; // https://github.com/ethereum/execution-specs/tree/master/network-upgrades/mainnet-upgrades std::optional homestead_block{std::nullopt}; std::optional dao_block{std::nullopt}; std::optional tangerine_whistle_block{std::nullopt}; std::optional spurious_dragon_block{std::nullopt}; std::optional byzantium_block{std::nullopt}; std::optional constantinople_block{std::nullopt}; std::optional petersburg_block{std::nullopt}; std::optional istanbul_block{std::nullopt}; std::optional muir_glacier_block{std::nullopt}; std::optional berlin_block{std::nullopt}; std::optional london_block{std::nullopt}; // (Optional) contract where EIP-1559 fees will be sent to that otherwise would be burnt since the London fork SmallMap burnt_contract{}; std::optional arrow_glacier_block{std::nullopt}; std::optional gray_glacier_block{std::nullopt}; //! \brief PoW to PoS switch //! \see EIP-3675: Upgrade consensus to Proof-of-Stake std::optional terminal_total_difficulty{std::nullopt}; std::optional merge_netsplit_block{std::nullopt}; // FORK_NEXT_VALUE in EIP-3675 // Starting from Shanghai, forks are triggered by block time rather than number std::optional shanghai_time{std::nullopt}; std::optional cancun_time{std::nullopt}; std::optional prague_time{std::nullopt}; //! \brief Returns the config of the (pre-Merge) protocol rule set protocol::PreMergeRuleSetConfig rule_set_config{protocol::NoPreMergeConfig{}}; // The Shanghai hard fork has withdrawals, but Agra does not bool withdrawals_activated(BlockTime block_time) const noexcept; bool is_london(BlockNum block_num) const noexcept; bool is_prague(BlockNum block_num, BlockTime block_time) const noexcept; //! \brief Returns the revision level at given block number //! \details In other words, on behalf of Json chain config data //! returns whether specific HF have occurred evmc_revision revision(BlockNum block_num, uint64_t block_time) const noexcept; std::vector distinct_fork_block_nums() const; std::vector distinct_fork_times() const; std::vector distinct_fork_points() const; //! \brief Check invariant on pre-Merge config validity bool valid_pre_merge_config() const noexcept; //! \brief Return the JSON representation of this object nlohmann::json to_json() const noexcept; /*Sample JSON input: { "chainId":1, "homesteadBlock":1150000, "daoForkBlock":1920000, "eip150Block":2463000, "eip155Block":2675000, "byzantiumBlock":4370000, "constantinopleBlock":7280000, "petersburgBlock":7280000, "istanbulBlock":9069000, "muirGlacierBlock":9200000, "berlinBlock":12244000 } */ //! \brief Try parse a JSON object into strongly typed ChainConfig //! \remark Should this return std::nullopt the parsing has failed static std::optional from_json(const nlohmann::json& json) noexcept; friend bool operator==(const ChainConfig&, const ChainConfig&) = default; }; std::ostream& operator<<(std::ostream& out, const ChainConfig& obj); using namespace evmc::literals; inline constexpr evmc::bytes32 kMainnetGenesisHash{0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3_bytes32}; constinit extern const ChainConfig kMainnetConfig; inline constexpr evmc::bytes32 kHoleskyGenesisHash{0xb5f7f912443c940f21fd611f12828d75b534364ed9e95ca4e307729a4661bde4_bytes32}; constinit extern const ChainConfig kHoleskyConfig; inline constexpr evmc::bytes32 kSepoliaGenesisHash{0x25a5cc106eea7138acab33231d7160d69cb777ee0c2c553fcddf5138993e6dd9_bytes32}; constinit extern const ChainConfig kSepoliaConfig; inline constexpr evmc::bytes32 kBorMainnetGenesisHash{0xa9c28ce2141b56c474f1dc504bee9b01eb1bd7d1a507580d5519d4437a97de1b_bytes32}; constinit extern const ChainConfig kBorMainnetConfig; inline constexpr evmc::bytes32 kAmoyGenesisHash{0x7202b2b53c5a0836e773e319d18922cc756dd67432f9a1f65352b61f4406c697_bytes32}; constinit extern const ChainConfig kAmoyConfig; //! \brief Known chain names mapped to their respective chain IDs inline constexpr SmallMap kKnownChainNameToId{ {"amoy", 80002}, {"bor-mainnet", 137}, {"holesky", 17000}, {"mainnet", 1}, {"sepolia", 11155111}, }; //! \brief Known chain IDs mapped to their respective chain configs inline constexpr SmallMap kKnownChainConfigs{ {*kKnownChainNameToId.find("mainnet"), &kMainnetConfig}, {*kKnownChainNameToId.find("amoy"), &kAmoyConfig}, {*kKnownChainNameToId.find("bor-mainnet"), &kBorMainnetConfig}, {*kKnownChainNameToId.find("holesky"), &kHoleskyConfig}, {*kKnownChainNameToId.find("sepolia"), &kSepoliaConfig}, }; } // namespace silkworm ================================================ FILE: silkworm/core/chain/config_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "config.hpp" #include #include #include using namespace evmc::literals; namespace silkworm { TEST_CASE("Known configs") { static_assert(kKnownChainConfigs.size() == kKnownChainNameToId.size()); for (const auto& [_, id] : kKnownChainNameToId) { const auto config{kKnownChainConfigs.find(id)}; REQUIRE(config); CHECK((*config)->chain_id == id); } } TEST_CASE("Config revision") { CHECK(kMainnetConfig.revision(0, 0) == EVMC_FRONTIER); CHECK(kMainnetConfig.revision(1, 1438269988) == EVMC_FRONTIER); CHECK(kMainnetConfig.revision(200'000, 1441661589) == EVMC_FRONTIER); CHECK(kMainnetConfig.revision(1'000'000, 1455404053) == EVMC_FRONTIER); CHECK(kMainnetConfig.revision(1'149'999, 1457981342) == EVMC_FRONTIER); CHECK(kMainnetConfig.revision(1'150'000, 1457981393) == EVMC_HOMESTEAD); CHECK(kMainnetConfig.revision(1'150'001, 1457981402) == EVMC_HOMESTEAD); CHECK(kMainnetConfig.revision(1'920'000, 1469020840) == EVMC_HOMESTEAD); // DAO fork doesn't have an evmc_revision CHECK(kMainnetConfig.revision(2'000'000, 1470173578) == EVMC_HOMESTEAD); CHECK(kMainnetConfig.revision(2'462'999, 1476796747) == EVMC_HOMESTEAD); CHECK(kMainnetConfig.revision(2'463'000, 1476796771) == EVMC_TANGERINE_WHISTLE); CHECK(kMainnetConfig.revision(2'463'001, 1476796812) == EVMC_TANGERINE_WHISTLE); CHECK(kMainnetConfig.revision(2'674'999, 1479831337) == EVMC_TANGERINE_WHISTLE); CHECK(kMainnetConfig.revision(2'675'000, 1479831344) == EVMC_SPURIOUS_DRAGON); CHECK(kMainnetConfig.revision(2'675'001, 1479831347) == EVMC_SPURIOUS_DRAGON); CHECK(kMainnetConfig.revision(3'000'000, 1484475035) == EVMC_SPURIOUS_DRAGON); CHECK(kMainnetConfig.revision(4'000'000, 1499633567) == EVMC_SPURIOUS_DRAGON); CHECK(kMainnetConfig.revision(4'369'999, 1508131303) == EVMC_SPURIOUS_DRAGON); CHECK(kMainnetConfig.revision(4'370'000, 1508131331) == EVMC_BYZANTIUM); CHECK(kMainnetConfig.revision(4'370'001, 1508131362) == EVMC_BYZANTIUM); CHECK(kMainnetConfig.revision(5'000'000, 1517319693) == EVMC_BYZANTIUM); CHECK(kMainnetConfig.revision(6'000'000, 1532118564) == EVMC_BYZANTIUM); CHECK(kMainnetConfig.revision(7'000'000, 1546466952) == EVMC_BYZANTIUM); CHECK(kMainnetConfig.revision(7'279'999, 1551383501) == EVMC_BYZANTIUM); CHECK(kMainnetConfig.revision(7'280'000, 1551383524) == EVMC_PETERSBURG); CHECK(kMainnetConfig.revision(7'280'001, 1551383544) == EVMC_PETERSBURG); CHECK(kMainnetConfig.revision(8'000'000, 1561100149) == EVMC_PETERSBURG); CHECK(kMainnetConfig.revision(9'000'000, 1574706444) == EVMC_PETERSBURG); CHECK(kMainnetConfig.revision(9'068'999, 1575764708) == EVMC_PETERSBURG); CHECK(kMainnetConfig.revision(9'069'000, 1575764709) == EVMC_ISTANBUL); CHECK(kMainnetConfig.revision(9'069'001, 1575764711) == EVMC_ISTANBUL); CHECK(kMainnetConfig.revision(9'200'000, 1577953849) == EVMC_ISTANBUL); // Muir Glacier doesn't have an evmc_revision CHECK(kMainnetConfig.revision(10'000'000, 1588598533) == EVMC_ISTANBUL); CHECK(kMainnetConfig.revision(11'000'000, 1601957824) == EVMC_ISTANBUL); CHECK(kMainnetConfig.revision(12'000'000, 1615234816) == EVMC_ISTANBUL); CHECK(kMainnetConfig.revision(12'243'999, 1618481214) == EVMC_ISTANBUL); CHECK(kMainnetConfig.revision(12'244'000, 1618481223) == EVMC_BERLIN); CHECK(kMainnetConfig.revision(12'244'001, 1618481230) == EVMC_BERLIN); CHECK(kMainnetConfig.revision(12'964'999, 1628166812) == EVMC_BERLIN); CHECK(kMainnetConfig.revision(12'965'000, 1628166822) == EVMC_LONDON); CHECK(kMainnetConfig.revision(12'965'001, 1628166835) == EVMC_LONDON); CHECK(kMainnetConfig.revision(13'000'000, 1628632419) == EVMC_LONDON); CHECK(kMainnetConfig.revision(13'773'000, 1639079723) == EVMC_LONDON); // Arrow Glacier doesn't have an evmc_revision CHECK(kMainnetConfig.revision(14'000'000, 1642114795) == EVMC_LONDON); CHECK(kMainnetConfig.revision(15'000'000, 1655778535) == EVMC_LONDON); CHECK(kMainnetConfig.revision(15'050'000, 1656586444) == EVMC_LONDON); // Gray Glacier doesn't have an evmc_revision CHECK(kMainnetConfig.revision(15'537'393, 1663224162) == EVMC_LONDON); // We still use EVMC_LONDON for The Merge, though formally it should be EVMC_PARIS CHECK(kMainnetConfig.revision(16'000'000, 1668811907) == EVMC_LONDON); CHECK(kMainnetConfig.revision(17'000'000, 1680911891) == EVMC_LONDON); CHECK(kMainnetConfig.revision(17'034'869, 1681338443) == EVMC_LONDON); CHECK(kMainnetConfig.revision(17'034'870, 1681338479) == EVMC_SHANGHAI); CHECK(kMainnetConfig.revision(17'034'871, 1681338503) == EVMC_SHANGHAI); CHECK(kMainnetConfig.revision(19'428'734, 1710338123) == EVMC_SHANGHAI); CHECK(kMainnetConfig.revision(19'428'735, 1710338135) == EVMC_CANCUN); CHECK(kMainnetConfig.revision(20'000'000, 1800000000) == EVMC_CANCUN); CHECK(test::kLondonConfig.revision(0, 0) == EVMC_LONDON); CHECK(test::kShanghaiConfig.revision(0, 0) == EVMC_SHANGHAI); } // For Polygon the Agra hard fork (=Shanghai without withdrawals) is activated based on the block number // rather than timestamp. TEST_CASE("Agra revision") { auto bor_config{std::get(kBorMainnetConfig.rule_set_config)}; CHECK(kBorMainnetConfig.revision(bor_config.agra_block - 1, 0) == EVMC_LONDON); CHECK(kBorMainnetConfig.revision(bor_config.agra_block, 0) == EVMC_SHANGHAI); CHECK(kBorMainnetConfig.revision(bor_config.agra_block + 1, 0) == EVMC_SHANGHAI); } TEST_CASE("distinct_fork_points") { const std::vector expected_mainnet_fork_numbers{ 1'150'000, 1'920'000, 2'463'000, 2'675'000, 4'370'000, 7'280'000, 9'069'000, 9'200'000, 12'244'000, 12'965'000, 13'773'000, 15'050'000, }; const std::vector expected_mainnet_fork_times{ 1681338455, 1710338135, }; std::vector expected_mainnet_fork_points{expected_mainnet_fork_numbers}; expected_mainnet_fork_points.insert(expected_mainnet_fork_points.end(), expected_mainnet_fork_times.cbegin(), expected_mainnet_fork_times.cend()); CHECK(kMainnetConfig.distinct_fork_block_nums() == expected_mainnet_fork_numbers); CHECK(kMainnetConfig.distinct_fork_times() == expected_mainnet_fork_times); CHECK(kMainnetConfig.distinct_fork_points() == expected_mainnet_fork_points); } TEST_CASE("JSON serialization") { const auto unrelated_json = nlohmann::json::parse(R"({ "firstName": "John", "lastName": "Smith", "children": [], "spouse": null })"); CHECK(!ChainConfig::from_json(unrelated_json)); const auto merge_test_json = nlohmann::json::parse(R"({ "chainId":1337302, "homesteadBlock":0, "eip150Block":0, "eip155Block":0, "byzantiumBlock":0, "constantinopleBlock":0, "petersburgBlock":0, "istanbulBlock":0, "berlinBlock":0, "londonBlock":0, "mergeNetsplitBlock":10000, "terminalTotalDifficulty":"0" })"); const std::optional config{ChainConfig::from_json(merge_test_json)}; REQUIRE(config); CHECK(config->terminal_total_difficulty == intx::from_string("0")); CHECK(config->merge_netsplit_block == 10000); CHECK(config->to_json() == merge_test_json); } TEST_CASE("terminalTotalDifficulty as JSON number (Erigon compatibility)") { const auto mainnet_json_ttd_number = nlohmann::json::parse(R"({ "chainId":1, "homesteadBlock":1150000, "daoForkBlock":1920000, "eip150Block":2463000, "eip155Block":2675000, "byzantiumBlock":4370000, "constantinopleBlock":7280000, "petersburgBlock":7280000, "istanbulBlock":9069000, "muirGlacierBlock":9200000, "berlinBlock":12244000, "londonBlock":12965000, "arrowGlacierBlock":13773000, "grayGlacierBlock":15050000, "terminalTotalDifficulty":58750000000000000000000, "shanghaiTime":1681338455, "ethash":{} })"); const std::optional config1{ChainConfig::from_json(mainnet_json_ttd_number)}; REQUIRE(config1); CHECK(config1->to_json() != mainnet_json_ttd_number); // "58750000000000000000000" vs 5.875e+22 CHECK(config1->terminal_total_difficulty == intx::from_string("58750000000000000000000")); const auto sepolia_json_ttd_number = nlohmann::json::parse(R"({ "chainId":11155111, "homesteadBlock":0, "eip150Block":0, "eip155Block":0, "byzantiumBlock":0, "constantinopleBlock":0, "petersburgBlock":0, "istanbulBlock":0, "muirGlacierBlock":0, "berlinBlock":0, "londonBlock":0, "terminalTotalDifficulty":17000000000000000, "mergeNetsplitBlock":1735371, "shanghaiTime":1677557088, "ethash":{} })"); const std::optional config2{ChainConfig::from_json(sepolia_json_ttd_number)}; REQUIRE(config2); CHECK(config2->to_json() != sepolia_json_ttd_number); // "17000000000000000" vs 17000000000000000 CHECK(config2->terminal_total_difficulty == intx::from_string("17000000000000000")); } } // namespace silkworm ================================================ FILE: silkworm/core/chain/dao.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "dao.hpp" #include using namespace evmc::literals; constexpr evmc::address kWithdraw{0xbf4ed7b27f1d666546e30d74d50d173d20bca754_address}; constexpr evmc::address kChildren[]{ 0xd4fe7bc31cedb7bfb8a345f31e668033056b2728_address, 0xb3fb0e5aba0e20e5c49d252dfd30e102b171a425_address, 0x2c19c7f9ae8b751e37aeb2d93a699722395ae18f_address, 0xecd135fa4f61a655311e86238c92adcd779555d2_address, 0x1975bd06d486162d5dc297798dfc41edd5d160a7_address, 0xa3acf3a1e16b1d7c315e23510fdd7847b48234f6_address, 0x319f70bab6845585f412ec7724b744fec6095c85_address, 0x06706dd3f2c9abf0a21ddcc6941d9b86f0596936_address, 0x5c8536898fbb74fc7445814902fd08422eac56d0_address, 0x6966ab0d485353095148a2155858910e0965b6f9_address, 0x779543a0491a837ca36ce8c635d6154e3c4911a6_address, 0x2a5ed960395e2a49b1c758cef4aa15213cfd874c_address, 0x5c6e67ccd5849c0d29219c4f95f1a7a93b3f5dc5_address, 0x9c50426be05db97f5d64fc54bf89eff947f0a321_address, 0x200450f06520bdd6c527622a273333384d870efb_address, 0xbe8539bfe837b67d1282b2b1d61c3f723966f049_address, 0x6b0c4d41ba9ab8d8cfb5d379c69a612f2ced8ecb_address, 0xf1385fb24aad0cd7432824085e42aff90886fef5_address, 0xd1ac8b1ef1b69ff51d1d401a476e7e612414f091_address, 0x8163e7fb499e90f8544ea62bbf80d21cd26d9efd_address, 0x51e0ddd9998364a2eb38588679f0d2c42653e4a6_address, 0x627a0a960c079c21c34f7612d5d230e01b4ad4c7_address, 0xf0b1aa0eb660754448a7937c022e30aa692fe0c5_address, 0x24c4d950dfd4dd1902bbed3508144a54542bba94_address, 0x9f27daea7aca0aa0446220b98d028715e3bc803d_address, 0xa5dc5acd6a7968a4554d89d65e59b7fd3bff0f90_address, 0xd9aef3a1e38a39c16b31d1ace71bca8ef58d315b_address, 0x63ed5a272de2f6d968408b4acb9024f4cc208ebf_address, 0x6f6704e5a10332af6672e50b3d9754dc460dfa4d_address, 0x77ca7b50b6cd7e2f3fa008e24ab793fd56cb15f6_address, 0x492ea3bb0f3315521c31f273e565b868fc090f17_address, 0x0ff30d6de14a8224aa97b78aea5388d1c51c1f00_address, 0x9ea779f907f0b315b364b0cfc39a0fde5b02a416_address, 0xceaeb481747ca6c540a000c1f3641f8cef161fa7_address, 0xcc34673c6c40e791051898567a1222daf90be287_address, 0x579a80d909f346fbfb1189493f521d7f48d52238_address, 0xe308bd1ac5fda103967359b2712dd89deffb7973_address, 0x4cb31628079fb14e4bc3cd5e30c2f7489b00960c_address, 0xac1ecab32727358dba8962a0f3b261731aad9723_address, 0x4fd6ace747f06ece9c49699c7cabc62d02211f75_address, 0x440c59b325d2997a134c2c7c60a8c61611212bad_address, 0x4486a3d68fac6967006d7a517b889fd3f98c102b_address, 0x9c15b54878ba618f494b38f0ae7443db6af648ba_address, 0x27b137a85656544b1ccb5a0f2e561a5703c6a68f_address, 0x21c7fdb9ed8d291d79ffd82eb2c4356ec0d81241_address, 0x23b75c2f6791eef49c69684db4c6c1f93bf49a50_address, 0x1ca6abd14d30affe533b24d7a21bff4c2d5e1f3b_address, 0xb9637156d330c0d605a791f1c31ba5890582fe1c_address, 0x6131c42fa982e56929107413a9d526fd99405560_address, 0x1591fc0f688c81fbeb17f5426a162a7024d430c2_address, 0x542a9515200d14b68e934e9830d91645a980dd7a_address, 0xc4bbd073882dd2add2424cf47d35213405b01324_address, 0x782495b7b3355efb2833d56ecb34dc22ad7dfcc4_address, 0x58b95c9a9d5d26825e70a82b6adb139d3fd829eb_address, 0x3ba4d81db016dc2890c81f3acec2454bff5aada5_address, 0xb52042c8ca3f8aa246fa79c3feaa3d959347c0ab_address, 0xe4ae1efdfc53b73893af49113d8694a057b9c0d1_address, 0x3c02a7bc0391e86d91b7d144e61c2c01a25a79c5_address, 0x0737a6b837f97f46ebade41b9bc3e1c509c85c53_address, 0x97f43a37f595ab5dd318fb46e7a155eae057317a_address, 0x52c5317c848ba20c7504cb2c8052abd1fde29d03_address, 0x4863226780fe7c0356454236d3b1c8792785748d_address, 0x5d2b2e6fcbe3b11d26b525e085ff818dae332479_address, 0x5f9f3392e9f62f63b8eac0beb55541fc8627f42c_address, 0x057b56736d32b86616a10f619859c6cd6f59092a_address, 0x9aa008f65de0b923a2a4f02012ad034a5e2e2192_address, 0x304a554a310c7e546dfe434669c62820b7d83490_address, 0x914d1b8b43e92723e64fd0a06f5bdb8dd9b10c79_address, 0x4deb0033bb26bc534b197e61d19e0733e5679784_address, 0x07f5c1e1bc2c93e0402f23341973a0e043f7bf8a_address, 0x35a051a0010aba705c9008d7a7eff6fb88f6ea7b_address, 0x4fa802324e929786dbda3b8820dc7834e9134a2a_address, 0x9da397b9e80755301a3b32173283a91c0ef6c87e_address, 0x8d9edb3054ce5c5774a420ac37ebae0ac02343c6_address, 0x0101f3be8ebb4bbd39a2e3b9a3639d4259832fd9_address, 0x5dc28b15dffed94048d73806ce4b7a4612a1d48f_address, 0xbcf899e6c7d9d5a215ab1e3444c86806fa854c76_address, 0x12e626b0eebfe86a56d633b9864e389b45dcb260_address, 0xa2f1ccba9395d7fcb155bba8bc92db9bafaeade7_address, 0xec8e57756626fdc07c63ad2eafbd28d08e7b0ca5_address, 0xd164b088bd9108b60d0ca3751da4bceb207b0782_address, 0x6231b6d0d5e77fe001c2a460bd9584fee60d409b_address, 0x1cba23d343a983e9b5cfd19496b9a9701ada385f_address, 0xa82f360a8d3455c5c41366975bde739c37bfeb8a_address, 0x9fcd2deaff372a39cc679d5c5e4de7bafb0b1339_address, 0x005f5cee7a43331d5a3d3eec71305925a62f34b6_address, 0x0e0da70933f4c7849fc0d203f5d1d43b9ae4532d_address, 0xd131637d5275fd1a68a3200f4ad25c71a2a9522e_address, 0xbc07118b9ac290e4622f5e77a0853539789effbe_address, 0x47e7aa56d6bdf3f36be34619660de61275420af8_address, 0xacd87e28b0c9d1254e868b81cba4cc20d9a32225_address, 0xadf80daec7ba8dcf15392f1ac611fff65d94f880_address, 0x5524c55fb03cf21f549444ccbecb664d0acad706_address, 0x40b803a9abce16f50f36a77ba41180eb90023925_address, 0xfe24cdd8648121a43a7c86d289be4dd2951ed49f_address, 0x17802f43a0137c506ba92291391a8a8f207f487d_address, 0x253488078a4edf4d6f42f113d1e62836a942cf1a_address, 0x86af3e9626fce1957c82e88cbf04ddf3a2ed7915_address, 0xb136707642a4ea12fb4bae820f03d2562ebff487_address, 0xdbe9b615a3ae8709af8b93336ce9b477e4ac0940_address, 0xf14c14075d6c4ed84b86798af0956deef67365b5_address, 0xca544e5c4687d109611d0f8f928b53a25af72448_address, 0xaeeb8ff27288bdabc0fa5ebb731b6f409507516c_address, 0xcbb9d3703e651b0d496cdefb8b92c25aeb2171f7_address, 0x6d87578288b6cb5549d5076a207456a1f6a63dc0_address, 0xb2c6f0dfbb716ac562e2d85d6cb2f8d5ee87603e_address, 0xaccc230e8a6e5be9160b8cdf2864dd2a001c28b6_address, 0x2b3455ec7fedf16e646268bf88846bd7a2319bb2_address, 0x4613f3bca5c44ea06337a9e439fbc6d42e501d0a_address, 0xd343b217de44030afaa275f54d31a9317c7f441e_address, 0x84ef4b2357079cd7a7c69fd7a37cd0609a679106_address, 0xda2fef9e4a3230988ff17df2165440f37e8b1708_address, 0xf4c64518ea10f995918a454158c6b61407ea345c_address, 0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97_address, 0xbb9bc244d798123fde783fcc1c72d3bb8c189413_address, 0x807640a13483f8ac783c557fcdf27be11ea4ac7a_address, }; namespace silkworm { void transfer_dao_balances(IntraBlockState& state) { for (const evmc::address& address : kChildren) { state.add_to_balance(kWithdraw, state.get_balance(address)); state.set_balance(address, 0); } } } // namespace silkworm ================================================ FILE: silkworm/core/chain/dao.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { // EIP-779: Hardfork Meta: DAO Fork void transfer_dao_balances(IntraBlockState& state); } // namespace silkworm ================================================ FILE: silkworm/core/chain/genesis.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "genesis.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { std::string_view read_genesis_data(ChainId chain_id) { switch (chain_id) { case *kKnownChainNameToId.find("mainnet"): return kGenesisMainnetJson; case *kKnownChainNameToId.find("holesky"): return kGenesisHoleskyJson; case *kKnownChainNameToId.find("sepolia"): return kGenesisSepoliaJson; case *kKnownChainNameToId.find("bor-mainnet"): return kGenesisBorMainnetJson; case *kKnownChainNameToId.find("amoy"): return kGenesisAmoyJson; default: return "{"; // <- Won't be lately parsed as valid json value } } BlockHeader read_genesis_header(const nlohmann::json& genesis, const evmc::bytes32& state_root) { BlockHeader header; if (genesis.contains("extraData")) { const std::string extra_data_str{genesis["extraData"].get()}; if (has_hex_prefix(extra_data_str)) { const std::optional extra_data_hex{from_hex(extra_data_str)}; SILKWORM_ASSERT(extra_data_hex.has_value()); header.extra_data = *extra_data_hex; } else { header.extra_data = string_view_to_byte_view(extra_data_str); } } if (genesis.contains("mixHash")) { const std::optional mix_hash{from_hex(genesis["mixHash"].get())}; SILKWORM_ASSERT(mix_hash.has_value()); std::memcpy(header.prev_randao.bytes, mix_hash->data(), mix_hash->size()); } if (genesis.contains("nonce")) { const uint64_t nonce{std::stoull(genesis["nonce"].get(), nullptr, 0)}; endian::store_big_u64(header.nonce.data(), nonce); } if (genesis.contains("difficulty")) { const auto difficulty_str{genesis["difficulty"].get()}; header.difficulty = intx::from_string(difficulty_str); } header.ommers_hash = kEmptyListHash; header.state_root = state_root; header.transactions_root = kEmptyRoot; header.receipts_root = kEmptyRoot; header.gas_limit = std::stoull(genesis["gasLimit"].get(), nullptr, 0); header.timestamp = std::stoull(genesis["timestamp"].get(), nullptr, 0); const std::optional chain_config{ChainConfig::from_json(genesis["config"])}; SILKWORM_ASSERT(chain_config.has_value()); if (chain_config->revision(0, header.timestamp) >= EVMC_LONDON) { header.base_fee_per_gas = protocol::kInitialBaseFee; } return header; } InMemoryState read_genesis_allocation(const nlohmann::json& alloc) { InMemoryState state; for (const auto& item : alloc.items()) { const evmc::address address{hex_to_address(item.key())}; const nlohmann::json& account_json{item.value()}; Account account; account.balance = intx::from_string(account_json.at("balance")); if (account_json.contains("nonce")) { account.nonce = std::stoull(account_json["nonce"].get(), nullptr, /*base=*/16); } if (account_json.contains("code")) { const Bytes code{*from_hex(account_json["code"].get())}; if (!code.empty()) { account.incarnation = kDefaultIncarnation; account.code_hash = std::bit_cast(keccak256(code)); state.update_account_code(address, account.incarnation, account.code_hash, code); } } state.update_account(address, /*initial=*/std::nullopt, account); if (account_json.contains("storage")) { for (const auto& storage : account_json["storage"].items()) { const Bytes key{*from_hex(storage.key())}; const Bytes value{*from_hex(storage.value().get())}; state.update_storage(address, account.incarnation, to_bytes32(key), /*initial=*/{}, to_bytes32(value)); } } } return state; } } // namespace silkworm ================================================ FILE: silkworm/core/chain/genesis.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include // See https://arvanaghi.com/blog/explaining-the-genesis-block-in-ethereum/ namespace silkworm { /* * \brief Returns genesis data given a known chain_id. * If id is not recognized returns an invalid json string */ std::string_view read_genesis_data(ChainId chain_id); BlockHeader read_genesis_header(const nlohmann::json& genesis, const evmc::bytes32& state_root); InMemoryState read_genesis_allocation(const nlohmann::json& alloc); } // namespace silkworm ================================================ FILE: silkworm/core/chain/genesis_amoy.cpp ================================================ /* Generated from genesis_amoy.json using silkworm embed_json tool */ #include "genesis_amoy.hpp" constexpr char kGenesisAmoyDataInternal[] = { 0x7b, 0x22, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x63, 0x38, 0x36, 0x31, 0x34, 0x64, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x30, 0x66, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x66, 0x32, 0x36, 0x61, 0x61, 0x39, 0x36, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x61, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x35, 0x62, 0x38, 0x34, 0x34, 0x65, 0x62, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x37, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x35, 0x62, 0x38, 0x34, 0x34, 0x65, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x36, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x63, 0x66, 0x32, 0x37, 0x39, 0x33, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x38, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x62, 0x37, 0x63, 0x39, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x62, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x35, 0x39, 0x63, 0x66, 0x35, 0x36, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x64, 0x34, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x61, 0x66, 0x32, 0x36, 0x61, 0x61, 0x39, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x63, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x31, 0x64, 0x37, 0x61, 0x36, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x65, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x61, 0x62, 0x34, 0x64, 0x62, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x31, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x63, 0x31, 0x62, 0x33, 0x63, 0x39, 0x31, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x33, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x62, 0x61, 0x35, 0x37, 0x30, 0x37, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x64, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x62, 0x61, 0x35, 0x37, 0x30, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x32, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x38, 0x61, 0x62, 0x32, 0x62, 0x36, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x35, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x64, 0x31, 0x31, 0x62, 0x38, 0x30, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x37, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x65, 0x37, 0x35, 0x36, 0x34, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x61, 0x39, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x63, 0x38, 0x36, 0x31, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x39, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x35, 0x62, 0x33, 0x61, 0x31, 0x65, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x32, 0x33, 0x35, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x64, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x38, 0x37, 0x61, 0x39, 0x62, 0x64, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x66, 0x39, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x38, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x34, 0x64, 0x36, 0x35, 0x32, 0x38, 0x66, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x34, 0x64, 0x36, 0x35, 0x32, 0x38, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x65, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x64, 0x62, 0x63, 0x39, 0x35, 0x39, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x31, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x35, 0x36, 0x31, 0x34, 0x66, 0x63, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x33, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x38, 0x32, 0x61, 0x38, 0x64, 0x30, 0x38, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x36, 0x63, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x35, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x35, 0x64, 0x64, 0x66, 0x65, 0x65, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x37, 0x30, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x33, 0x65, 0x65, 0x38, 0x32, 0x31, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x61, 0x30, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x34, 0x63, 0x31, 0x35, 0x63, 0x62, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x62, 0x65, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x66, 0x32, 0x61, 0x37, 0x33, 0x66, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x63, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x66, 0x32, 0x61, 0x37, 0x33, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x61, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x62, 0x63, 0x30, 0x36, 0x35, 0x36, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x64, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x64, 0x65, 0x33, 0x61, 0x31, 0x38, 0x30, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x66, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x64, 0x64, 0x66, 0x33, 0x35, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x32, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x30, 0x34, 0x37, 0x61, 0x36, 0x63, 0x35, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x66, 0x35, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x30, 0x63, 0x33, 0x35, 0x62, 0x31, 0x63, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x32, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x32, 0x37, 0x30, 0x62, 0x35, 0x37, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x35, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x63, 0x32, 0x61, 0x32, 0x62, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x38, 0x38, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x30, 0x66, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x30, 0x61, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x37, 0x30, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x31, 0x65, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x34, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x33, 0x63, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x37, 0x35, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x34, 0x66, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x61, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x37, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x36, 0x64, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x39, 0x33, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x37, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x61, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x39, 0x64, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x61, 0x34, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x61, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x62, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x62, 0x39, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x31, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x63, 0x62, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x64, 0x63, 0x36, 0x31, 0x31, 0x32, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x65, 0x39, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x30, 0x63, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x30, 0x37, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x61, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x31, 0x39, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x33, 0x63, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x33, 0x37, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x33, 0x30, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x34, 0x39, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x35, 0x61, 0x36, 0x31, 0x31, 0x34, 0x33, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x36, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x38, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x38, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x38, 0x35, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x64, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x34, 0x34, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x39, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x61, 0x38, 0x36, 0x31, 0x31, 0x35, 0x31, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x62, 0x35, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x64, 0x38, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x64, 0x33, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x61, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x65, 0x35, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x30, 0x38, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x34, 0x30, 0x33, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x36, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x31, 0x35, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x32, 0x36, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x33, 0x33, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x35, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x34, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x32, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x36, 0x33, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x38, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x34, 0x38, 0x31, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x34, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x39, 0x33, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x61, 0x34, 0x36, 0x31, 0x31, 0x38, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x62, 0x33, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x63, 0x34, 0x36, 0x31, 0x31, 0x38, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x64, 0x32, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x61, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x65, 0x33, 0x36, 0x31, 0x31, 0x39, 0x38, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x66, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x31, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x30, 0x65, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x61, 0x31, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x39, 0x39, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x32, 0x32, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x34, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x34, 0x35, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x34, 0x30, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x32, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x39, 0x66, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x35, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x36, 0x33, 0x36, 0x31, 0x31, 0x61, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x37, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x39, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x38, 0x65, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x61, 0x32, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x61, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x62, 0x31, 0x36, 0x31, 0x31, 0x62, 0x35, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x62, 0x65, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x63, 0x66, 0x36, 0x31, 0x31, 0x62, 0x37, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x64, 0x65, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x30, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x66, 0x63, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x30, 0x65, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x31, 0x66, 0x36, 0x31, 0x31, 0x63, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x32, 0x64, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x61, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x36, 0x34, 0x62, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x63, 0x65, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x35, 0x64, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x36, 0x65, 0x36, 0x31, 0x31, 0x64, 0x30, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x37, 0x62, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x62, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x39, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x36, 0x39, 0x39, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x61, 0x31, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x64, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x61, 0x64, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x34, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x62, 0x65, 0x36, 0x31, 0x31, 0x64, 0x36, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x63, 0x62, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x65, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x36, 0x65, 0x39, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x64, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x66, 0x64, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x37, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x31, 0x39, 0x33, 0x39, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x38, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x37, 0x37, 0x39, 0x35, 0x37, 0x36, 0x31, 0x30, 0x37, 0x37, 0x30, 0x36, 0x31, 0x31, 0x38, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x33, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x37, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x31, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x63, 0x64, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x31, 0x37, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x32, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x38, 0x35, 0x63, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x38, 0x39, 0x61, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x38, 0x66, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x31, 0x30, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x30, 0x63, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x30, 0x39, 0x37, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x38, 0x34, 0x35, 0x37, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x61, 0x34, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x38, 0x62, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x31, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x31, 0x33, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x62, 0x30, 0x61, 0x39, 0x30, 0x36, 0x31, 0x33, 0x31, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x62, 0x31, 0x64, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x33, 0x31, 0x35, 0x37, 0x36, 0x31, 0x30, 0x62, 0x33, 0x30, 0x36, 0x31, 0x31, 0x64, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x36, 0x31, 0x30, 0x62, 0x34, 0x35, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x32, 0x30, 0x63, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x38, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x38, 0x36, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x62, 0x37, 0x64, 0x39, 0x30, 0x36, 0x31, 0x33, 0x31, 0x37, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x36, 0x38, 0x36, 0x31, 0x31, 0x36, 0x31, 0x30, 0x62, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x62, 0x62, 0x66, 0x39, 0x30, 0x36, 0x31, 0x33, 0x31, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x39, 0x38, 0x39, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x36, 0x31, 0x30, 0x62, 0x64, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x63, 0x31, 0x61, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x31, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x31, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x37, 0x33, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x36, 0x61, 0x39, 0x30, 0x36, 0x31, 0x33, 0x31, 0x35, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x63, 0x63, 0x63, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x63, 0x33, 0x39, 0x30, 0x36, 0x31, 0x33, 0x31, 0x39, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x39, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x38, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x37, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x35, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x38, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x35, 0x35, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x33, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x64, 0x36, 0x36, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x64, 0x38, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x66, 0x36, 0x31, 0x30, 0x64, 0x64, 0x61, 0x38, 0x37, 0x38, 0x37, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x30, 0x65, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x31, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x35, 0x31, 0x35, 0x37, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x65, 0x30, 0x65, 0x38, 0x33, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x30, 0x31, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x31, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x63, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x65, 0x33, 0x34, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x31, 0x30, 0x65, 0x35, 0x64, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x35, 0x30, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x31, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x65, 0x37, 0x66, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x37, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x31, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x65, 0x61, 0x31, 0x38, 0x33, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x39, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x32, 0x36, 0x37, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x64, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x64, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x65, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x66, 0x61, 0x39, 0x36, 0x31, 0x30, 0x66, 0x61, 0x34, 0x38, 0x36, 0x38, 0x36, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x30, 0x65, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x31, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x31, 0x64, 0x35, 0x37, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x66, 0x64, 0x38, 0x38, 0x33, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x66, 0x63, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x31, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x64, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x66, 0x66, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x31, 0x31, 0x30, 0x32, 0x38, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x31, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x31, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, 0x61, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x33, 0x64, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x31, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x36, 0x63, 0x38, 0x33, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x35, 0x66, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x32, 0x36, 0x37, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x65, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x61, 0x33, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x66, 0x62, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x66, 0x63, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x31, 0x36, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x37, 0x34, 0x35, 0x37, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x32, 0x33, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x36, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x37, 0x62, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x30, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x34, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x32, 0x61, 0x33, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x66, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x32, 0x62, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x33, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x64, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x66, 0x66, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x64, 0x39, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x33, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x32, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x32, 0x63, 0x35, 0x37, 0x36, 0x31, 0x31, 0x34, 0x31, 0x64, 0x38, 0x33, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x34, 0x30, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x36, 0x31, 0x32, 0x30, 0x63, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x65, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x30, 0x38, 0x37, 0x35, 0x31, 0x38, 0x31, 0x36, 0x31, 0x31, 0x34, 0x36, 0x36, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x34, 0x30, 0x32, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x37, 0x66, 0x35, 0x37, 0x36, 0x31, 0x31, 0x34, 0x37, 0x63, 0x38, 0x37, 0x36, 0x31, 0x31, 0x37, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x38, 0x31, 0x31, 0x31, 0x36, 0x31, 0x31, 0x35, 0x30, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x33, 0x38, 0x38, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x38, 0x30, 0x31, 0x35, 0x31, 0x39, 0x35, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x34, 0x61, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x39, 0x34, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x35, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x66, 0x30, 0x35, 0x37, 0x36, 0x31, 0x31, 0x34, 0x65, 0x39, 0x38, 0x36, 0x38, 0x35, 0x36, 0x31, 0x31, 0x32, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x66, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x34, 0x66, 0x61, 0x38, 0x34, 0x38, 0x37, 0x36, 0x31, 0x31, 0x32, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x37, 0x38, 0x32, 0x31, 0x34, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x35, 0x32, 0x36, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x34, 0x35, 0x31, 0x38, 0x31, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x36, 0x30, 0x63, 0x35, 0x37, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x31, 0x35, 0x36, 0x65, 0x38, 0x36, 0x38, 0x33, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x34, 0x31, 0x36, 0x31, 0x32, 0x32, 0x38, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x35, 0x38, 0x35, 0x38, 0x32, 0x38, 0x39, 0x36, 0x31, 0x32, 0x33, 0x31, 0x36, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x38, 0x66, 0x36, 0x31, 0x32, 0x36, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x39, 0x39, 0x38, 0x61, 0x38, 0x33, 0x36, 0x31, 0x31, 0x36, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x61, 0x35, 0x38, 0x61, 0x38, 0x33, 0x36, 0x31, 0x31, 0x31, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x35, 0x64, 0x63, 0x35, 0x37, 0x35, 0x30, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x31, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x35, 0x66, 0x65, 0x35, 0x37, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x66, 0x62, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x37, 0x36, 0x31, 0x32, 0x30, 0x63, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x35, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x34, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x36, 0x32, 0x31, 0x36, 0x31, 0x32, 0x36, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x36, 0x66, 0x31, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x36, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x37, 0x39, 0x35, 0x37, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x37, 0x32, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x36, 0x63, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x37, 0x35, 0x64, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x37, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x66, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x37, 0x38, 0x63, 0x34, 0x33, 0x36, 0x31, 0x31, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x37, 0x61, 0x34, 0x36, 0x31, 0x31, 0x37, 0x39, 0x65, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x38, 0x33, 0x36, 0x31, 0x31, 0x31, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x37, 0x63, 0x36, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x66, 0x63, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x37, 0x65, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x33, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x66, 0x66, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x38, 0x32, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x38, 0x34, 0x61, 0x36, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x38, 0x33, 0x63, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x30, 0x63, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x64, 0x32, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x37, 0x33, 0x36, 0x61, 0x62, 0x33, 0x64, 0x33, 0x36, 0x63, 0x34, 0x36, 0x65, 0x63, 0x66, 0x62, 0x39, 0x62, 0x39, 0x63, 0x30, 0x62, 0x64, 0x35, 0x31, 0x63, 0x62, 0x31, 0x63, 0x33, 0x64, 0x61, 0x35, 0x61, 0x32, 0x63, 0x38, 0x31, 0x63, 0x65, 0x61, 0x36, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x38, 0x66, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x39, 0x36, 0x33, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x39, 0x37, 0x36, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x66, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x39, 0x61, 0x63, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x61, 0x30, 0x61, 0x36, 0x31, 0x31, 0x61, 0x30, 0x34, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x38, 0x33, 0x36, 0x31, 0x30, 0x39, 0x33, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x61, 0x31, 0x64, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x34, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x66, 0x62, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x61, 0x35, 0x66, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x32, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x62, 0x34, 0x65, 0x35, 0x37, 0x36, 0x31, 0x31, 0x62, 0x33, 0x66, 0x38, 0x33, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x62, 0x32, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x36, 0x31, 0x32, 0x30, 0x63, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x62, 0x30, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x62, 0x36, 0x35, 0x39, 0x30, 0x36, 0x31, 0x33, 0x30, 0x35, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x62, 0x37, 0x65, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x39, 0x31, 0x35, 0x37, 0x36, 0x31, 0x31, 0x62, 0x65, 0x65, 0x36, 0x31, 0x32, 0x36, 0x38, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x30, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x35, 0x66, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x36, 0x66, 0x35, 0x37, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x34, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x38, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x63, 0x63, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x62, 0x64, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x63, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x33, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x30, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x62, 0x35, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x63, 0x63, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x63, 0x64, 0x64, 0x34, 0x33, 0x36, 0x31, 0x30, 0x37, 0x35, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x66, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x64, 0x32, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x34, 0x33, 0x38, 0x31, 0x36, 0x31, 0x31, 0x64, 0x37, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x64, 0x62, 0x36, 0x36, 0x31, 0x31, 0x38, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x39, 0x32, 0x35, 0x30, 0x38, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x66, 0x66, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x35, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x35, 0x35, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x33, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x31, 0x65, 0x35, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x31, 0x65, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x61, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x65, 0x62, 0x34, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x65, 0x64, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x65, 0x65, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x66, 0x32, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x65, 0x38, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x30, 0x63, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x66, 0x64, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x66, 0x66, 0x35, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x30, 0x30, 0x65, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x30, 0x34, 0x64, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x66, 0x61, 0x39, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x30, 0x65, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x30, 0x66, 0x33, 0x36, 0x31, 0x32, 0x36, 0x61, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x34, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x32, 0x31, 0x32, 0x34, 0x38, 0x32, 0x36, 0x31, 0x32, 0x34, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x31, 0x32, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x31, 0x33, 0x38, 0x38, 0x33, 0x36, 0x31, 0x32, 0x34, 0x36, 0x65, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x31, 0x37, 0x36, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x62, 0x36, 0x31, 0x32, 0x31, 0x36, 0x33, 0x36, 0x31, 0x32, 0x36, 0x63, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x38, 0x31, 0x36, 0x31, 0x32, 0x31, 0x35, 0x62, 0x35, 0x37, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x31, 0x38, 0x38, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x34, 0x64, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x34, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x31, 0x65, 0x39, 0x35, 0x37, 0x36, 0x31, 0x32, 0x31, 0x61, 0x39, 0x38, 0x33, 0x36, 0x31, 0x32, 0x35, 0x36, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x34, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x31, 0x63, 0x63, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x31, 0x39, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x32, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x32, 0x31, 0x30, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x32, 0x32, 0x31, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x32, 0x32, 0x38, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x34, 0x64, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x32, 0x35, 0x62, 0x35, 0x37, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x32, 0x30, 0x34, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x35, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x32, 0x32, 0x37, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x32, 0x38, 0x33, 0x38, 0x32, 0x36, 0x31, 0x32, 0x31, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x32, 0x39, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x31, 0x35, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x32, 0x32, 0x62, 0x39, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x31, 0x32, 0x33, 0x30, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x31, 0x66, 0x38, 0x34, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x30, 0x31, 0x38, 0x37, 0x38, 0x33, 0x31, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x38, 0x34, 0x38, 0x62, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x35, 0x62, 0x38, 0x31, 0x38, 0x33, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x32, 0x66, 0x37, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x33, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x32, 0x64, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x36, 0x38, 0x35, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x33, 0x30, 0x31, 0x31, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x31, 0x38, 0x35, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x32, 0x33, 0x33, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x34, 0x31, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x66, 0x66, 0x36, 0x30, 0x34, 0x31, 0x38, 0x36, 0x30, 0x31, 0x35, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x33, 0x35, 0x63, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x33, 0x37, 0x34, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x31, 0x63, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x32, 0x33, 0x38, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x34, 0x31, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x37, 0x38, 0x33, 0x38, 0x36, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x32, 0x33, 0x61, 0x61, 0x39, 0x34, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x31, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x33, 0x63, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x30, 0x33, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x31, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x33, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x34, 0x36, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x36, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x34, 0x36, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x38, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x34, 0x64, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x34, 0x39, 0x39, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x34, 0x64, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x64, 0x33, 0x35, 0x37, 0x36, 0x31, 0x32, 0x34, 0x63, 0x32, 0x38, 0x32, 0x36, 0x31, 0x32, 0x35, 0x36, 0x38, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x34, 0x62, 0x31, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x66, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x35, 0x36, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x38, 0x30, 0x36, 0x31, 0x32, 0x35, 0x32, 0x34, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x32, 0x33, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x35, 0x62, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x33, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x35, 0x36, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x35, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x62, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x35, 0x36, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x66, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x38, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x32, 0x36, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x61, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x32, 0x36, 0x31, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x64, 0x36, 0x35, 0x37, 0x36, 0x30, 0x62, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x36, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x66, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x32, 0x36, 0x31, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x38, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x38, 0x33, 0x35, 0x35, 0x38, 0x31, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x36, 0x34, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x32, 0x36, 0x34, 0x63, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x36, 0x64, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x37, 0x33, 0x31, 0x39, 0x31, 0x39, 0x30, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x32, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x35, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x35, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x31, 0x36, 0x31, 0x32, 0x36, 0x65, 0x34, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x34, 0x33, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x62, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x35, 0x38, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x63, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x36, 0x64, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x63, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x31, 0x66, 0x38, 0x34, 0x30, 0x31, 0x31, 0x32, 0x36, 0x31, 0x32, 0x37, 0x38, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x39, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x32, 0x38, 0x33, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x62, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x31, 0x66, 0x38, 0x33, 0x30, 0x31, 0x31, 0x32, 0x36, 0x31, 0x32, 0x37, 0x63, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x33, 0x35, 0x36, 0x31, 0x32, 0x37, 0x65, 0x31, 0x36, 0x31, 0x32, 0x37, 0x64, 0x63, 0x38, 0x32, 0x36, 0x31, 0x33, 0x33, 0x30, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x64, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x38, 0x33, 0x38, 0x33, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x66, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x38, 0x30, 0x38, 0x38, 0x33, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x33, 0x34, 0x35, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x33, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x38, 0x34, 0x36, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x33, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x36, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x38, 0x36, 0x66, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x38, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x38, 0x39, 0x38, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x35, 0x65, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x38, 0x35, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x62, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x38, 0x63, 0x32, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x38, 0x64, 0x33, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x36, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x66, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x39, 0x30, 0x30, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x39, 0x31, 0x31, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x34, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x39, 0x32, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x39, 0x33, 0x61, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x62, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x39, 0x35, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x39, 0x36, 0x34, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x38, 0x35, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x39, 0x38, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x39, 0x38, 0x65, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x39, 0x39, 0x66, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x33, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x36, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x39, 0x62, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x39, 0x63, 0x63, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x39, 0x64, 0x64, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x34, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x39, 0x66, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x61, 0x30, 0x36, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x62, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x38, 0x35, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x61, 0x32, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x61, 0x33, 0x31, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x61, 0x34, 0x32, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x61, 0x30, 0x38, 0x38, 0x38, 0x61, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x61, 0x36, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x61, 0x37, 0x35, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x37, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x61, 0x38, 0x36, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x36, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x36, 0x31, 0x32, 0x61, 0x39, 0x37, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x38, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x38, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x61, 0x62, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x61, 0x63, 0x30, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x37, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x34, 0x35, 0x30, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x38, 0x38, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x61, 0x64, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x61, 0x65, 0x62, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x37, 0x37, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x35, 0x39, 0x38, 0x39, 0x31, 0x39, 0x34, 0x39, 0x37, 0x35, 0x30, 0x39, 0x32, 0x39, 0x35, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x30, 0x38, 0x38, 0x33, 0x38, 0x33, 0x36, 0x31, 0x32, 0x62, 0x32, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x32, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x31, 0x32, 0x66, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x62, 0x33, 0x35, 0x38, 0x31, 0x36, 0x31, 0x33, 0x33, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x62, 0x34, 0x34, 0x38, 0x31, 0x36, 0x31, 0x33, 0x33, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x35, 0x35, 0x38, 0x32, 0x36, 0x31, 0x33, 0x33, 0x34, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x62, 0x35, 0x66, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x33, 0x38, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x32, 0x62, 0x36, 0x61, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x32, 0x65, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x39, 0x62, 0x35, 0x37, 0x38, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x62, 0x38, 0x32, 0x38, 0x38, 0x38, 0x32, 0x36, 0x31, 0x32, 0x61, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x37, 0x35, 0x30, 0x36, 0x31, 0x32, 0x62, 0x38, 0x64, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x36, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x62, 0x36, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x35, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x62, 0x33, 0x38, 0x32, 0x36, 0x31, 0x33, 0x33, 0x35, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x62, 0x62, 0x64, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x33, 0x39, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x32, 0x62, 0x63, 0x38, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x33, 0x65, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x66, 0x39, 0x35, 0x37, 0x38, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x62, 0x65, 0x30, 0x38, 0x38, 0x38, 0x32, 0x36, 0x31, 0x32, 0x62, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x37, 0x35, 0x30, 0x36, 0x31, 0x32, 0x62, 0x65, 0x62, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x37, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x62, 0x63, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x35, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x63, 0x30, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x33, 0x65, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x63, 0x32, 0x36, 0x36, 0x31, 0x32, 0x63, 0x32, 0x31, 0x38, 0x32, 0x36, 0x31, 0x33, 0x33, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x39, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x63, 0x33, 0x35, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x63, 0x34, 0x63, 0x36, 0x31, 0x32, 0x63, 0x34, 0x37, 0x38, 0x32, 0x36, 0x31, 0x33, 0x34, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x61, 0x39, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x63, 0x35, 0x64, 0x38, 0x32, 0x36, 0x31, 0x33, 0x33, 0x36, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x63, 0x36, 0x37, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x33, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x32, 0x63, 0x37, 0x37, 0x38, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x33, 0x34, 0x36, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x63, 0x39, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x63, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x37, 0x36, 0x36, 0x66, 0x37, 0x34, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x63, 0x64, 0x30, 0x36, 0x30, 0x32, 0x64, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x35, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x32, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x37, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x37, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x37, 0x34, 0x36, 0x38, 0x36, 0x31, 0x36, 0x65, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x32, 0x30, 0x36, 0x33, 0x37, 0x35, 0x37, 0x32, 0x37, 0x32, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x31, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x64, 0x33, 0x36, 0x36, 0x30, 0x30, 0x66, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x31, 0x36, 0x65, 0x32, 0x30, 0x36, 0x39, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x64, 0x37, 0x36, 0x36, 0x30, 0x31, 0x33, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x35, 0x33, 0x37, 0x30, 0x36, 0x31, 0x36, 0x65, 0x32, 0x30, 0x36, 0x31, 0x36, 0x63, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x36, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x36, 0x39, 0x37, 0x33, 0x37, 0x34, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x64, 0x62, 0x36, 0x36, 0x30, 0x34, 0x35, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x34, 0x36, 0x39, 0x36, 0x36, 0x36, 0x36, 0x36, 0x35, 0x37, 0x32, 0x36, 0x35, 0x36, 0x65, 0x36, 0x33, 0x36, 0x35, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x37, 0x36, 0x35, 0x36, 0x35, 0x36, 0x65, 0x32, 0x30, 0x37, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x32, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x37, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x36, 0x63, 0x37, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x63, 0x36, 0x35, 0x37, 0x33, 0x32, 0x30, 0x36, 0x66, 0x36, 0x36, 0x32, 0x30, 0x37, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x37, 0x30, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x65, 0x34, 0x32, 0x36, 0x30, 0x30, 0x35, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x63, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x33, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x35, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x65, 0x38, 0x32, 0x36, 0x30, 0x30, 0x65, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x63, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x36, 0x38, 0x36, 0x35, 0x36, 0x39, 0x36, 0x64, 0x36, 0x34, 0x36, 0x31, 0x36, 0x63, 0x36, 0x63, 0x32, 0x64, 0x33, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x65, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x65, 0x63, 0x32, 0x36, 0x30, 0x32, 0x61, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x35, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x37, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x37, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x37, 0x34, 0x36, 0x38, 0x36, 0x31, 0x36, 0x65, 0x32, 0x30, 0x37, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x37, 0x34, 0x36, 0x31, 0x37, 0x32, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x66, 0x32, 0x38, 0x36, 0x30, 0x31, 0x32, 0x38, 0x33, 0x36, 0x31, 0x33, 0x33, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x35, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x34, 0x31, 0x36, 0x34, 0x36, 0x34, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x66, 0x37, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x32, 0x66, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x66, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x32, 0x66, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x66, 0x39, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x32, 0x62, 0x32, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x66, 0x61, 0x36, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x34, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x66, 0x62, 0x35, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x34, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x66, 0x63, 0x34, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x66, 0x64, 0x36, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x32, 0x63, 0x31, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x32, 0x66, 0x65, 0x36, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x32, 0x63, 0x33, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x30, 0x32, 0x38, 0x32, 0x38, 0x36, 0x36, 0x31, 0x32, 0x63, 0x31, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x33, 0x30, 0x31, 0x32, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x32, 0x63, 0x33, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x33, 0x30, 0x32, 0x32, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x32, 0x63, 0x33, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x33, 0x66, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x32, 0x63, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x35, 0x35, 0x38, 0x32, 0x36, 0x31, 0x32, 0x63, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x36, 0x61, 0x38, 0x32, 0x36, 0x31, 0x32, 0x65, 0x33, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x37, 0x66, 0x38, 0x32, 0x36, 0x31, 0x32, 0x65, 0x37, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x30, 0x39, 0x65, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x62, 0x33, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x30, 0x62, 0x65, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x32, 0x62, 0x34, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x30, 0x64, 0x32, 0x38, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x62, 0x61, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x30, 0x66, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x63, 0x30, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x31, 0x30, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x63, 0x32, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x31, 0x32, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x37, 0x36, 0x31, 0x32, 0x63, 0x32, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x31, 0x33, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x32, 0x66, 0x62, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x31, 0x34, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x36, 0x31, 0x32, 0x63, 0x32, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x31, 0x34, 0x64, 0x36, 0x30, 0x36, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x63, 0x32, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x35, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x31, 0x36, 0x66, 0x38, 0x31, 0x36, 0x31, 0x32, 0x63, 0x63, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x31, 0x38, 0x66, 0x38, 0x31, 0x36, 0x31, 0x32, 0x64, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x31, 0x61, 0x66, 0x38, 0x31, 0x36, 0x31, 0x32, 0x64, 0x36, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x31, 0x63, 0x66, 0x38, 0x31, 0x36, 0x31, 0x32, 0x64, 0x61, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x31, 0x65, 0x66, 0x38, 0x31, 0x36, 0x31, 0x32, 0x65, 0x62, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x32, 0x30, 0x66, 0x38, 0x31, 0x36, 0x31, 0x32, 0x66, 0x31, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x32, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x66, 0x35, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x34, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x66, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x36, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x32, 0x66, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x36, 0x65, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x36, 0x31, 0x32, 0x66, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x37, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x62, 0x33, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x32, 0x66, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x61, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x36, 0x31, 0x32, 0x66, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x62, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x66, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x63, 0x66, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x66, 0x62, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x32, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x33, 0x32, 0x66, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x33, 0x33, 0x31, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x33, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x33, 0x64, 0x64, 0x38, 0x32, 0x36, 0x31, 0x33, 0x34, 0x32, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x35, 0x31, 0x35, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x32, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x66, 0x66, 0x38, 0x32, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x38, 0x31, 0x38, 0x33, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x33, 0x34, 0x38, 0x61, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x34, 0x36, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x33, 0x34, 0x39, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x62, 0x63, 0x38, 0x31, 0x36, 0x31, 0x33, 0x33, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x33, 0x34, 0x63, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x64, 0x33, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x33, 0x34, 0x64, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x65, 0x61, 0x38, 0x31, 0x36, 0x31, 0x33, 0x34, 0x34, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x33, 0x34, 0x66, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x33, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x35, 0x34, 0x61, 0x65, 0x38, 0x36, 0x64, 0x35, 0x33, 0x62, 0x61, 0x35, 0x34, 0x36, 0x34, 0x61, 0x39, 0x64, 0x39, 0x30, 0x39, 0x38, 0x62, 0x61, 0x31, 0x34, 0x38, 0x37, 0x35, 0x34, 0x66, 0x64, 0x62, 0x61, 0x38, 0x31, 0x66, 0x30, 0x38, 0x38, 0x63, 0x61, 0x63, 0x30, 0x38, 0x66, 0x66, 0x32, 0x65, 0x37, 0x63, 0x37, 0x62, 0x66, 0x36, 0x61, 0x34, 0x36, 0x61, 0x61, 0x65, 0x38, 0x61, 0x39, 0x36, 0x63, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, 0x64, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x36, 0x31, 0x36, 0x63, 0x66, 0x35, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x34, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x30, 0x34, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x34, 0x39, 0x34, 0x61, 0x31, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x34, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x65, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x34, 0x30, 0x37, 0x63, 0x61, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x32, 0x62, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x63, 0x37, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x35, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x38, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x39, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x62, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x65, 0x39, 0x36, 0x31, 0x30, 0x34, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x33, 0x33, 0x36, 0x31, 0x30, 0x34, 0x63, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x30, 0x30, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x35, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x34, 0x31, 0x36, 0x34, 0x36, 0x34, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x32, 0x35, 0x32, 0x38, 0x35, 0x38, 0x35, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x64, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x30, 0x32, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x38, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x32, 0x36, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x64, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x66, 0x34, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x35, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x34, 0x39, 0x36, 0x34, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x37, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x37, 0x31, 0x37, 0x35, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x35, 0x34, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x33, 0x32, 0x34, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x33, 0x31, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x33, 0x34, 0x35, 0x38, 0x34, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x38, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x37, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x35, 0x30, 0x38, 0x32, 0x36, 0x31, 0x30, 0x36, 0x66, 0x66, 0x35, 0x36, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x61, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x32, 0x34, 0x63, 0x34, 0x62, 0x34, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x61, 0x61, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x38, 0x66, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x64, 0x37, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x37, 0x66, 0x32, 0x36, 0x63, 0x35, 0x33, 0x62, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x62, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x35, 0x31, 0x37, 0x62, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x33, 0x38, 0x31, 0x38, 0x33, 0x31, 0x36, 0x31, 0x37, 0x38, 0x33, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x34, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x37, 0x66, 0x31, 0x39, 0x36, 0x35, 0x30, 0x38, 0x34, 0x37, 0x66, 0x35, 0x61, 0x32, 0x32, 0x37, 0x32, 0x35, 0x35, 0x39, 0x30, 0x62, 0x30, 0x61, 0x35, 0x31, 0x63, 0x39, 0x32, 0x33, 0x39, 0x34, 0x30, 0x32, 0x32, 0x33, 0x66, 0x37, 0x34, 0x35, 0x38, 0x35, 0x31, 0x32, 0x31, 0x36, 0x34, 0x62, 0x31, 0x31, 0x31, 0x33, 0x33, 0x35, 0x39, 0x61, 0x37, 0x33, 0x35, 0x65, 0x38, 0x36, 0x65, 0x37, 0x66, 0x32, 0x37, 0x66, 0x34, 0x34, 0x37, 0x39, 0x31, 0x65, 0x65, 0x38, 0x38, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x64, 0x63, 0x36, 0x31, 0x30, 0x39, 0x37, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x34, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x35, 0x30, 0x64, 0x38, 0x32, 0x36, 0x31, 0x30, 0x37, 0x31, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x31, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x35, 0x32, 0x31, 0x38, 0x33, 0x36, 0x31, 0x30, 0x37, 0x36, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x35, 0x66, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x34, 0x63, 0x36, 0x31, 0x30, 0x39, 0x39, 0x39, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x35, 0x34, 0x34, 0x35, 0x37, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x35, 0x37, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x64, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x34, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x64, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x35, 0x39, 0x32, 0x38, 0x33, 0x36, 0x31, 0x30, 0x38, 0x36, 0x30, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x34, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x35, 0x62, 0x35, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x32, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x66, 0x39, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x30, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x36, 0x31, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x64, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x34, 0x34, 0x35, 0x37, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x32, 0x30, 0x34, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x35, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x36, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x36, 0x63, 0x38, 0x32, 0x36, 0x31, 0x30, 0x35, 0x64, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x36, 0x31, 0x30, 0x36, 0x38, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x36, 0x39, 0x35, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x64, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x64, 0x37, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x66, 0x33, 0x38, 0x34, 0x38, 0x37, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x30, 0x39, 0x31, 0x38, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x33, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x32, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x36, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x35, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x36, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x37, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x37, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x64, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x63, 0x62, 0x35, 0x37, 0x36, 0x31, 0x30, 0x37, 0x62, 0x61, 0x38, 0x32, 0x36, 0x31, 0x30, 0x38, 0x36, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x61, 0x39, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x66, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x35, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x38, 0x31, 0x63, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x31, 0x62, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x35, 0x62, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x32, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x35, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x34, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x62, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x35, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x66, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x38, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x30, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x39, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x30, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x63, 0x65, 0x35, 0x37, 0x36, 0x30, 0x62, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x30, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x65, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x38, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x32, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x39, 0x37, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x35, 0x36, 0x35, 0x37, 0x38, 0x32, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x32, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x31, 0x39, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x31, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x32, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x62, 0x66, 0x39, 0x39, 0x38, 0x36, 0x32, 0x37, 0x61, 0x62, 0x33, 0x66, 0x30, 0x64, 0x65, 0x63, 0x63, 0x39, 0x64, 0x34, 0x61, 0x65, 0x38, 0x35, 0x38, 0x37, 0x31, 0x39, 0x37, 0x39, 0x62, 0x36, 0x66, 0x31, 0x66, 0x65, 0x63, 0x32, 0x32, 0x32, 0x62, 0x62, 0x61, 0x66, 0x65, 0x62, 0x32, 0x65, 0x30, 0x30, 0x34, 0x35, 0x64, 0x61, 0x66, 0x35, 0x38, 0x62, 0x39, 0x33, 0x66, 0x34, 0x62, 0x38, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x33, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x30, 0x34, 0x66, 0x63, 0x65, 0x32, 0x38, 0x30, 0x38, 0x35, 0x62, 0x35, 0x34, 0x39, 0x62, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x38, 0x64, 0x61, 0x35, 0x63, 0x62, 0x35, 0x62, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x65, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x38, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x36, 0x31, 0x34, 0x64, 0x30, 0x64, 0x36, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x36, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x36, 0x31, 0x34, 0x64, 0x30, 0x64, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x63, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x64, 0x39, 0x65, 0x66, 0x35, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x65, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x32, 0x66, 0x64, 0x65, 0x33, 0x38, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x33, 0x64, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x63, 0x30, 0x63, 0x35, 0x34, 0x36, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x38, 0x65, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x65, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x63, 0x63, 0x37, 0x39, 0x66, 0x39, 0x37, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x36, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x30, 0x36, 0x66, 0x37, 0x37, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x39, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x63, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x38, 0x37, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x63, 0x62, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x30, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x62, 0x63, 0x65, 0x65, 0x62, 0x61, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x36, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x63, 0x64, 0x30, 0x36, 0x63, 0x62, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x39, 0x35, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x38, 0x64, 0x61, 0x35, 0x63, 0x62, 0x35, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x35, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x38, 0x66, 0x33, 0x32, 0x64, 0x35, 0x39, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x62, 0x35, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x30, 0x32, 0x35, 0x65, 0x36, 0x34, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x65, 0x34, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x33, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x61, 0x35, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x31, 0x35, 0x30, 0x31, 0x38, 0x61, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x30, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x31, 0x32, 0x38, 0x32, 0x66, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x32, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x64, 0x33, 0x32, 0x65, 0x39, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x34, 0x63, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x38, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x38, 0x35, 0x63, 0x63, 0x39, 0x35, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x64, 0x64, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x66, 0x39, 0x36, 0x61, 0x38, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x34, 0x65, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x39, 0x35, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x63, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x31, 0x61, 0x37, 0x64, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x63, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x66, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x32, 0x66, 0x63, 0x34, 0x37, 0x66, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x32, 0x62, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x30, 0x36, 0x66, 0x64, 0x64, 0x65, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x34, 0x39, 0x39, 0x63, 0x35, 0x39, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x34, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x38, 0x31, 0x36, 0x30, 0x64, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x39, 0x64, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x64, 0x31, 0x36, 0x31, 0x30, 0x62, 0x65, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x31, 0x31, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x33, 0x65, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x35, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x62, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x36, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x32, 0x32, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x61, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x62, 0x32, 0x36, 0x31, 0x30, 0x63, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x64, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x38, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x61, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x65, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x30, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x31, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x33, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x61, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x66, 0x38, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x65, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x65, 0x37, 0x62, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x30, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x30, 0x66, 0x36, 0x31, 0x30, 0x66, 0x63, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x33, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x34, 0x30, 0x36, 0x31, 0x30, 0x66, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x38, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x64, 0x62, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x61, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x66, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x65, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x34, 0x63, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x30, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x31, 0x62, 0x38, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x35, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x36, 0x33, 0x36, 0x31, 0x31, 0x32, 0x38, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x62, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x66, 0x34, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x61, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x31, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x31, 0x66, 0x36, 0x31, 0x31, 0x32, 0x63, 0x65, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x32, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x33, 0x36, 0x36, 0x31, 0x31, 0x33, 0x39, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x35, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x31, 0x63, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x36, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x39, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x61, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x63, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x61, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x36, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x37, 0x33, 0x36, 0x31, 0x31, 0x35, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x63, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x63, 0x61, 0x36, 0x31, 0x31, 0x35, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x66, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x66, 0x39, 0x36, 0x31, 0x31, 0x35, 0x61, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x33, 0x39, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x31, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x36, 0x36, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x38, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x38, 0x39, 0x36, 0x31, 0x31, 0x35, 0x65, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x63, 0x39, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x61, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x66, 0x36, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x39, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x31, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x37, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x37, 0x66, 0x36, 0x31, 0x31, 0x36, 0x34, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x61, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x63, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x62, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x66, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x35, 0x35, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x30, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x66, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x38, 0x30, 0x36, 0x31, 0x31, 0x37, 0x31, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x61, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x61, 0x62, 0x36, 0x31, 0x31, 0x37, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x63, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x64, 0x36, 0x36, 0x31, 0x31, 0x37, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x66, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x33, 0x62, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x37, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x34, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x38, 0x63, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x36, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x39, 0x30, 0x33, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x39, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x61, 0x33, 0x36, 0x31, 0x31, 0x39, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x34, 0x64, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x33, 0x32, 0x30, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x34, 0x36, 0x39, 0x37, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x63, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x36, 0x36, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x61, 0x30, 0x61, 0x36, 0x34, 0x30, 0x32, 0x35, 0x34, 0x30, 0x62, 0x65, 0x34, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x31, 0x31, 0x36, 0x31, 0x30, 0x63, 0x62, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x34, 0x38, 0x30, 0x36, 0x31, 0x30, 0x63, 0x63, 0x33, 0x35, 0x37, 0x35, 0x30, 0x38, 0x32, 0x34, 0x33, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x64, 0x33, 0x35, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x35, 0x33, 0x36, 0x39, 0x36, 0x37, 0x36, 0x65, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x39, 0x37, 0x32, 0x36, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x64, 0x34, 0x63, 0x36, 0x31, 0x30, 0x64, 0x34, 0x36, 0x33, 0x33, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x36, 0x31, 0x31, 0x39, 0x34, 0x36, 0x35, 0x36, 0x35, 0x62, 0x33, 0x30, 0x36, 0x31, 0x31, 0x61, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x35, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x31, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x64, 0x65, 0x38, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x30, 0x66, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x35, 0x33, 0x36, 0x39, 0x36, 0x37, 0x32, 0x30, 0x36, 0x34, 0x36, 0x35, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x36, 0x39, 0x37, 0x36, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x31, 0x35, 0x31, 0x35, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x31, 0x30, 0x65, 0x36, 0x32, 0x38, 0x31, 0x38, 0x39, 0x38, 0x39, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x61, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x65, 0x36, 0x66, 0x38, 0x32, 0x38, 0x34, 0x38, 0x38, 0x36, 0x31, 0x31, 0x62, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x39, 0x36, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x65, 0x38, 0x62, 0x38, 0x32, 0x36, 0x31, 0x31, 0x32, 0x61, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x65, 0x61, 0x32, 0x38, 0x33, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x36, 0x31, 0x31, 0x66, 0x36, 0x38, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x62, 0x37, 0x35, 0x37, 0x35, 0x30, 0x38, 0x32, 0x33, 0x34, 0x31, 0x34, 0x35, 0x62, 0x36, 0x31, 0x30, 0x66, 0x32, 0x39, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x39, 0x36, 0x65, 0x37, 0x33, 0x37, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x62, 0x66, 0x66, 0x32, 0x36, 0x30, 0x32, 0x62, 0x33, 0x66, 0x34, 0x36, 0x38, 0x32, 0x35, 0x39, 0x65, 0x31, 0x65, 0x39, 0x39, 0x66, 0x36, 0x31, 0x33, 0x66, 0x65, 0x64, 0x36, 0x36, 0x39, 0x31, 0x66, 0x33, 0x61, 0x36, 0x35, 0x32, 0x36, 0x65, 0x66, 0x66, 0x65, 0x36, 0x65, 0x66, 0x33, 0x65, 0x37, 0x36, 0x38, 0x62, 0x61, 0x37, 0x61, 0x65, 0x37, 0x61, 0x33, 0x36, 0x63, 0x34, 0x66, 0x38, 0x35, 0x38, 0x34, 0x36, 0x31, 0x30, 0x66, 0x61, 0x35, 0x38, 0x37, 0x36, 0x31, 0x31, 0x32, 0x61, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x30, 0x30, 0x34, 0x36, 0x31, 0x31, 0x35, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x30, 0x30, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x34, 0x61, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x31, 0x30, 0x39, 0x66, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x32, 0x32, 0x36, 0x63, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x30, 0x61, 0x61, 0x38, 0x33, 0x36, 0x31, 0x31, 0x32, 0x61, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x34, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x66, 0x37, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x31, 0x31, 0x30, 0x64, 0x38, 0x33, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x36, 0x31, 0x31, 0x66, 0x38, 0x38, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x34, 0x65, 0x32, 0x63, 0x61, 0x30, 0x35, 0x31, 0x35, 0x65, 0x64, 0x31, 0x61, 0x65, 0x66, 0x31, 0x33, 0x39, 0x35, 0x66, 0x36, 0x36, 0x62, 0x35, 0x33, 0x30, 0x33, 0x62, 0x62, 0x35, 0x64, 0x36, 0x66, 0x31, 0x62, 0x66, 0x39, 0x64, 0x36, 0x31, 0x61, 0x33, 0x35, 0x33, 0x66, 0x61, 0x35, 0x33, 0x66, 0x37, 0x33, 0x66, 0x38, 0x61, 0x63, 0x39, 0x39, 0x37, 0x33, 0x66, 0x61, 0x39, 0x66, 0x36, 0x38, 0x35, 0x38, 0x35, 0x36, 0x31, 0x31, 0x31, 0x38, 0x66, 0x38, 0x39, 0x36, 0x31, 0x31, 0x32, 0x61, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x31, 0x65, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x32, 0x32, 0x34, 0x39, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x31, 0x35, 0x31, 0x35, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x38, 0x33, 0x38, 0x32, 0x36, 0x31, 0x31, 0x66, 0x61, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x64, 0x36, 0x36, 0x31, 0x31, 0x35, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x64, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x31, 0x38, 0x35, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x31, 0x33, 0x62, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x32, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x66, 0x66, 0x36, 0x30, 0x34, 0x31, 0x38, 0x36, 0x30, 0x31, 0x35, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x65, 0x61, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x30, 0x32, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x31, 0x63, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x31, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x32, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x36, 0x38, 0x32, 0x38, 0x35, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x37, 0x30, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x30, 0x33, 0x35, 0x31, 0x39, 0x33, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x35, 0x31, 0x66, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x35, 0x37, 0x32, 0x37, 0x32, 0x36, 0x66, 0x37, 0x32, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x36, 0x35, 0x36, 0x33, 0x37, 0x32, 0x36, 0x35, 0x36, 0x33, 0x36, 0x66, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x30, 0x31, 0x33, 0x38, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x34, 0x64, 0x34, 0x31, 0x35, 0x34, 0x34, 0x39, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x34, 0x31, 0x34, 0x36, 0x31, 0x31, 0x36, 0x33, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x33, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x36, 0x33, 0x63, 0x33, 0x33, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x31, 0x62, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x32, 0x33, 0x31, 0x33, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x36, 0x39, 0x34, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x37, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x37, 0x30, 0x38, 0x36, 0x31, 0x31, 0x37, 0x30, 0x33, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x31, 0x39, 0x34, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x30, 0x39, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x32, 0x30, 0x31, 0x33, 0x38, 0x38, 0x32, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x32, 0x32, 0x38, 0x66, 0x36, 0x30, 0x35, 0x32, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x37, 0x36, 0x65, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x37, 0x34, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x62, 0x34, 0x36, 0x31, 0x31, 0x35, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x62, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x34, 0x33, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x33, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x32, 0x32, 0x65, 0x31, 0x36, 0x30, 0x33, 0x32, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x31, 0x66, 0x39, 0x66, 0x33, 0x35, 0x35, 0x36, 0x64, 0x64, 0x33, 0x33, 0x36, 0x30, 0x31, 0x36, 0x63, 0x64, 0x66, 0x32, 0x30, 0x61, 0x64, 0x61, 0x65, 0x61, 0x64, 0x37, 0x64, 0x35, 0x63, 0x37, 0x33, 0x36, 0x36, 0x35, 0x64, 0x62, 0x61, 0x36, 0x36, 0x34, 0x62, 0x36, 0x30, 0x65, 0x38, 0x63, 0x31, 0x37, 0x65, 0x39, 0x61, 0x34, 0x65, 0x62, 0x39, 0x31, 0x63, 0x65, 0x31, 0x64, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x39, 0x30, 0x62, 0x36, 0x31, 0x31, 0x35, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x39, 0x31, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x31, 0x39, 0x31, 0x64, 0x38, 0x31, 0x36, 0x31, 0x31, 0x66, 0x61, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x32, 0x33, 0x31, 0x33, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x39, 0x39, 0x38, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x39, 0x37, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x37, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x34, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x61, 0x30, 0x38, 0x31, 0x32, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x32, 0x32, 0x38, 0x66, 0x36, 0x30, 0x35, 0x32, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x61, 0x36, 0x65, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x61, 0x34, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x64, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x34, 0x64, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x33, 0x32, 0x30, 0x34, 0x65, 0x36, 0x35, 0x37, 0x34, 0x37, 0x37, 0x36, 0x66, 0x37, 0x32, 0x36, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x36, 0x32, 0x30, 0x31, 0x33, 0x38, 0x38, 0x32, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x62, 0x61, 0x32, 0x38, 0x34, 0x38, 0x32, 0x36, 0x31, 0x32, 0x30, 0x62, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x32, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x33, 0x66, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x35, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x65, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x66, 0x62, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x64, 0x31, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x64, 0x32, 0x66, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x32, 0x30, 0x66, 0x35, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x36, 0x34, 0x39, 0x37, 0x65, 0x33, 0x65, 0x65, 0x35, 0x34, 0x38, 0x61, 0x33, 0x33, 0x37, 0x32, 0x31, 0x33, 0x36, 0x61, 0x66, 0x32, 0x66, 0x63, 0x62, 0x30, 0x36, 0x39, 0x36, 0x64, 0x62, 0x33, 0x31, 0x66, 0x63, 0x36, 0x63, 0x66, 0x32, 0x30, 0x32, 0x36, 0x30, 0x37, 0x30, 0x37, 0x36, 0x34, 0x35, 0x30, 0x36, 0x38, 0x62, 0x64, 0x33, 0x66, 0x65, 0x39, 0x37, 0x66, 0x33, 0x63, 0x34, 0x38, 0x37, 0x38, 0x36, 0x38, 0x36, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x65, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x65, 0x33, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x65, 0x34, 0x62, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x65, 0x36, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x65, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x65, 0x65, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x30, 0x33, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x31, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x34, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x39, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x65, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x30, 0x61, 0x64, 0x38, 0x32, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x31, 0x32, 0x30, 0x62, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x31, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x38, 0x32, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x36, 0x30, 0x32, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x32, 0x38, 0x31, 0x32, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x32, 0x31, 0x39, 0x37, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x36, 0x33, 0x36, 0x31, 0x36, 0x65, 0x32, 0x37, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x64, 0x35, 0x32, 0x34, 0x33, 0x33, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x32, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x31, 0x64, 0x64, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x66, 0x65, 0x35, 0x34, 0x36, 0x38, 0x36, 0x35, 0x32, 0x30, 0x36, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x36, 0x63, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x36, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x36, 0x39, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x37, 0x61, 0x36, 0x35, 0x36, 0x34, 0x34, 0x39, 0x36, 0x65, 0x37, 0x33, 0x37, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x66, 0x37, 0x32, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x35, 0x37, 0x33, 0x36, 0x35, 0x37, 0x32, 0x34, 0x35, 0x34, 0x39, 0x35, 0x30, 0x33, 0x37, 0x33, 0x31, 0x33, 0x32, 0x34, 0x34, 0x36, 0x66, 0x36, 0x64, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x32, 0x38, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x36, 0x65, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x32, 0x63, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x37, 0x33, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x33, 0x36, 0x38, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x32, 0x63, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, 0x36, 0x37, 0x39, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x39, 0x34, 0x33, 0x36, 0x38, 0x36, 0x39, 0x36, 0x63, 0x36, 0x34, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x33, 0x61, 0x32, 0x30, 0x36, 0x65, 0x36, 0x35, 0x37, 0x37, 0x32, 0x30, 0x36, 0x33, 0x36, 0x38, 0x36, 0x39, 0x36, 0x63, 0x36, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x37, 0x34, 0x36, 0x38, 0x36, 0x35, 0x32, 0x30, 0x37, 0x61, 0x36, 0x35, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x35, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x65, 0x37, 0x33, 0x36, 0x36, 0x36, 0x35, 0x37, 0x32, 0x34, 0x66, 0x37, 0x32, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x38, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x34, 0x66, 0x37, 0x32, 0x34, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x63, 0x36, 0x32, 0x37, 0x39, 0x37, 0x34, 0x36, 0x35, 0x37, 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x30, 0x36, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x31, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x39, 0x37, 0x32, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x39, 0x61, 0x32, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x65, 0x62, 0x37, 0x62, 0x61, 0x62, 0x63, 0x33, 0x66, 0x32, 0x34, 0x64, 0x30, 0x66, 0x36, 0x39, 0x34, 0x38, 0x66, 0x65, 0x64, 0x30, 0x38, 0x30, 0x31, 0x62, 0x39, 0x38, 0x38, 0x33, 0x37, 0x31, 0x62, 0x61, 0x30, 0x65, 0x62, 0x32, 0x36, 0x62, 0x32, 0x36, 0x64, 0x34, 0x39, 0x36, 0x66, 0x65, 0x61, 0x39, 0x32, 0x62, 0x37, 0x62, 0x35, 0x37, 0x61, 0x37, 0x32, 0x31, 0x34, 0x38, 0x65, 0x31, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x33, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x42, 0x33, 0x64, 0x33, 0x36, 0x43, 0x34, 0x36, 0x65, 0x63, 0x46, 0x62, 0x39, 0x42, 0x39, 0x63, 0x30, 0x62, 0x44, 0x35, 0x31, 0x43, 0x42, 0x31, 0x63, 0x33, 0x64, 0x61, 0x35, 0x41, 0x32, 0x43, 0x38, 0x31, 0x63, 0x65, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x6d, 0x6f, 0x79, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x38, 0x30, 0x30, 0x30, 0x32, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x72, 0x22, 0x2c, 0x22, 0x68, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x30, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x35, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x62, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x70, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62, 0x75, 0x72, 0x67, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6d, 0x75, 0x69, 0x72, 0x47, 0x6c, 0x61, 0x63, 0x69, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x62, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x37, 0x33, 0x31, 0x30, 0x30, 0x2c, 0x22, 0x62, 0x75, 0x72, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x37, 0x33, 0x31, 0x30, 0x30, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x65, 0x43, 0x44, 0x44, 0x37, 0x37, 0x63, 0x45, 0x36, 0x66, 0x31, 0x34, 0x36, 0x63, 0x43, 0x66, 0x35, 0x64, 0x61, 0x62, 0x37, 0x30, 0x37, 0x39, 0x34, 0x31, 0x64, 0x33, 0x31, 0x38, 0x42, 0x64, 0x35, 0x30, 0x65, 0x65, 0x44, 0x32, 0x43, 0x39, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x20, 0x32, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x20, 0x34, 0x7d, 0x2c, 0x22, 0x73, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x20, 0x31, 0x36, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x20, 0x32, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x20, 0x31, 0x32, 0x38, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x22, 0x2c, 0x22, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x22, 0x6a, 0x61, 0x69, 0x70, 0x75, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x37, 0x33, 0x31, 0x30, 0x30, 0x2c, 0x22, 0x64, 0x65, 0x6c, 0x68, 0x69, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x37, 0x33, 0x31, 0x30, 0x30, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x6f, 0x72, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x37, 0x33, 0x31, 0x30, 0x30, 0x2c, 0x22, 0x61, 0x67, 0x72, 0x61, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x37, 0x33, 0x31, 0x30, 0x30, 0x2c, 0x22, 0x6e, 0x61, 0x70, 0x6f, 0x6c, 0x69, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x35, 0x34, 0x32, 0x33, 0x36, 0x30, 0x30, 0x2c, 0x22, 0x61, 0x68, 0x6d, 0x65, 0x64, 0x61, 0x62, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x31, 0x38, 0x36, 0x35, 0x38, 0x35, 0x36, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x31, 0x31, 0x38, 0x36, 0x35, 0x38, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x30, 0x63, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x35, 0x34, 0x30, 0x37, 0x63, 0x61, 0x36, 0x37, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x38, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x62, 0x63, 0x61, 0x32, 0x32, 0x30, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x36, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x62, 0x63, 0x61, 0x32, 0x32, 0x30, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x66, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x37, 0x32, 0x61, 0x30, 0x62, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x30, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x65, 0x33, 0x61, 0x38, 0x37, 0x66, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x31, 0x66, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x31, 0x36, 0x35, 0x30, 0x35, 0x33, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x34, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x30, 0x63, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x35, 0x34, 0x30, 0x37, 0x63, 0x61, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x35, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x37, 0x35, 0x37, 0x65, 0x35, 0x64, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x36, 0x30, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x34, 0x32, 0x61, 0x66, 0x31, 0x37, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x66, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x30, 0x63, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x30, 0x33, 0x31, 0x31, 0x32, 0x61, 0x31, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x64, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x34, 0x39, 0x34, 0x61, 0x31, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x66, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x30, 0x65, 0x36, 0x39, 0x66, 0x63, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x37, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x31, 0x38, 0x39, 0x32, 0x36, 0x66, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x39, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x31, 0x39, 0x35, 0x30, 0x63, 0x64, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x63, 0x34, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x66, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x65, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x31, 0x30, 0x33, 0x34, 0x61, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x36, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x33, 0x35, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x33, 0x35, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x32, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x33, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x35, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x30, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x31, 0x35, 0x31, 0x35, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x30, 0x39, 0x33, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x61, 0x30, 0x36, 0x31, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x61, 0x30, 0x36, 0x31, 0x30, 0x39, 0x36, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x66, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x64, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x33, 0x35, 0x39, 0x30, 0x36, 0x31, 0x30, 0x32, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x33, 0x35, 0x31, 0x36, 0x39, 0x30, 0x38, 0x34, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x30, 0x32, 0x38, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x32, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x33, 0x35, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x31, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x32, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x34, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x37, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x30, 0x63, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x37, 0x64, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x37, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x31, 0x30, 0x63, 0x37, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x39, 0x31, 0x39, 0x32, 0x38, 0x33, 0x39, 0x32, 0x39, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x62, 0x37, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x32, 0x39, 0x66, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x65, 0x34, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x30, 0x64, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x30, 0x64, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x36, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x31, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x31, 0x30, 0x64, 0x32, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x66, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x33, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x33, 0x35, 0x36, 0x31, 0x30, 0x64, 0x33, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x30, 0x64, 0x62, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x39, 0x31, 0x38, 0x32, 0x39, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x31, 0x39, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x36, 0x31, 0x36, 0x31, 0x35, 0x30, 0x32, 0x30, 0x31, 0x39, 0x30, 0x39, 0x33, 0x31, 0x36, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x30, 0x34, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x34, 0x39, 0x30, 0x30, 0x34, 0x38, 0x34, 0x30, 0x32, 0x38, 0x31, 0x30, 0x31, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x39, 0x34, 0x35, 0x32, 0x38, 0x30, 0x38, 0x34, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x39, 0x33, 0x39, 0x32, 0x38, 0x33, 0x30, 0x31, 0x38, 0x32, 0x38, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x64, 0x66, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x30, 0x36, 0x31, 0x30, 0x33, 0x62, 0x34, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x35, 0x34, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x35, 0x32, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x36, 0x31, 0x30, 0x33, 0x64, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x33, 0x63, 0x32, 0x35, 0x37, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x32, 0x36, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x36, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x35, 0x30, 0x38, 0x35, 0x39, 0x39, 0x62, 0x64, 0x64, 0x35, 0x62, 0x39, 0x39, 0x36, 0x30, 0x64, 0x32, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x32, 0x30, 0x36, 0x31, 0x30, 0x34, 0x33, 0x64, 0x39, 0x31, 0x36, 0x31, 0x31, 0x32, 0x62, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x35, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x32, 0x39, 0x34, 0x39, 0x32, 0x39, 0x33, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x34, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x37, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x39, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x35, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x38, 0x32, 0x38, 0x32, 0x30, 0x31, 0x38, 0x38, 0x31, 0x30, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x61, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x64, 0x39, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x34, 0x63, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x30, 0x36, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x38, 0x33, 0x37, 0x66, 0x38, 0x37, 0x39, 0x37, 0x31, 0x34, 0x34, 0x39, 0x34, 0x38, 0x37, 0x38, 0x32, 0x61, 0x64, 0x63, 0x65, 0x64, 0x65, 0x38, 0x65, 0x30, 0x34, 0x62, 0x66, 0x61, 0x30, 0x62, 0x64, 0x38, 0x66, 0x64, 0x35, 0x36, 0x39, 0x34, 0x31, 0x65, 0x30, 0x64, 0x66, 0x37, 0x35, 0x30, 0x38, 0x62, 0x64, 0x30, 0x32, 0x61, 0x36, 0x32, 0x39, 0x62, 0x34, 0x37, 0x37, 0x66, 0x37, 0x62, 0x30, 0x37, 0x33, 0x61, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x33, 0x31, 0x33, 0x36, 0x32, 0x39, 0x64, 0x66, 0x35, 0x36, 0x30, 0x65, 0x31, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x31, 0x30, 0x31, 0x38, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x39, 0x32, 0x38, 0x33, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x34, 0x34, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x36, 0x31, 0x36, 0x39, 0x33, 0x36, 0x33, 0x32, 0x36, 0x63, 0x35, 0x33, 0x62, 0x65, 0x61, 0x39, 0x33, 0x38, 0x39, 0x39, 0x33, 0x38, 0x37, 0x39, 0x33, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x61, 0x32, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x35, 0x38, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x63, 0x66, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x37, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x65, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x31, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x30, 0x33, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x35, 0x66, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x37, 0x31, 0x34, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x35, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x34, 0x31, 0x36, 0x34, 0x36, 0x34, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x31, 0x36, 0x30, 0x37, 0x30, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x36, 0x61, 0x38, 0x36, 0x31, 0x30, 0x36, 0x61, 0x33, 0x38, 0x35, 0x38, 0x35, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x62, 0x35, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x64, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x36, 0x63, 0x39, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x36, 0x62, 0x63, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x66, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x32, 0x34, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x62, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x35, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x34, 0x39, 0x36, 0x34, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x37, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x37, 0x31, 0x37, 0x35, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x38, 0x32, 0x35, 0x35, 0x38, 0x33, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x34, 0x63, 0x39, 0x31, 0x38, 0x35, 0x39, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x37, 0x33, 0x66, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x66, 0x36, 0x32, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x37, 0x36, 0x64, 0x38, 0x34, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x37, 0x36, 0x30, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x66, 0x38, 0x32, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x37, 0x38, 0x38, 0x32, 0x36, 0x31, 0x30, 0x66, 0x66, 0x66, 0x35, 0x36, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x33, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x32, 0x34, 0x63, 0x34, 0x62, 0x34, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x63, 0x66, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x37, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x66, 0x63, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x38, 0x31, 0x38, 0x34, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x36, 0x33, 0x31, 0x33, 0x36, 0x32, 0x39, 0x64, 0x66, 0x35, 0x36, 0x30, 0x65, 0x31, 0x31, 0x62, 0x31, 0x37, 0x38, 0x31, 0x35, 0x32, 0x38, 0x31, 0x35, 0x31, 0x39, 0x31, 0x39, 0x36, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x35, 0x35, 0x30, 0x38, 0x35, 0x39, 0x34, 0x35, 0x30, 0x39, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x38, 0x32, 0x38, 0x38, 0x38, 0x37, 0x66, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x38, 0x35, 0x30, 0x38, 0x36, 0x39, 0x31, 0x37, 0x66, 0x35, 0x61, 0x32, 0x32, 0x37, 0x32, 0x35, 0x35, 0x39, 0x30, 0x62, 0x30, 0x61, 0x35, 0x31, 0x63, 0x39, 0x32, 0x33, 0x39, 0x34, 0x30, 0x32, 0x32, 0x33, 0x66, 0x37, 0x34, 0x35, 0x38, 0x35, 0x31, 0x32, 0x31, 0x36, 0x34, 0x62, 0x31, 0x31, 0x31, 0x33, 0x33, 0x35, 0x39, 0x61, 0x37, 0x33, 0x35, 0x65, 0x38, 0x36, 0x65, 0x37, 0x66, 0x32, 0x37, 0x66, 0x34, 0x34, 0x37, 0x39, 0x31, 0x65, 0x65, 0x39, 0x31, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x61, 0x32, 0x38, 0x36, 0x36, 0x31, 0x30, 0x39, 0x33, 0x30, 0x35, 0x37, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x63, 0x63, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x38, 0x62, 0x34, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x66, 0x39, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x38, 0x31, 0x38, 0x34, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x39, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x39, 0x31, 0x39, 0x30, 0x32, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x31, 0x30, 0x39, 0x32, 0x65, 0x39, 0x37, 0x35, 0x30, 0x39, 0x30, 0x39, 0x35, 0x35, 0x30, 0x39, 0x31, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x30, 0x32, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x37, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x65, 0x39, 0x37, 0x31, 0x66, 0x65, 0x66, 0x32, 0x62, 0x62, 0x36, 0x30, 0x66, 0x37, 0x30, 0x39, 0x65, 0x31, 0x64, 0x61, 0x66, 0x33, 0x65, 0x35, 0x35, 0x64, 0x30, 0x30, 0x39, 0x31, 0x34, 0x65, 0x32, 0x33, 0x30, 0x63, 0x64, 0x39, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x62, 0x65, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x31, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x37, 0x30, 0x30, 0x64, 0x32, 0x64, 0x63, 0x65, 0x63, 0x63, 0x32, 0x64, 0x38, 0x64, 0x32, 0x63, 0x38, 0x34, 0x30, 0x64, 0x38, 0x63, 0x61, 0x63, 0x32, 0x63, 0x63, 0x39, 0x32, 0x64, 0x63, 0x63, 0x38, 0x63, 0x61, 0x66, 0x36, 0x30, 0x37, 0x62, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x35, 0x34, 0x36, 0x30, 0x30, 0x35, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x30, 0x35, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x32, 0x31, 0x39, 0x35, 0x62, 0x39, 0x39, 0x36, 0x30, 0x65, 0x61, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x30, 0x36, 0x31, 0x30, 0x61, 0x34, 0x32, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x34, 0x30, 0x38, 0x35, 0x63, 0x39, 0x62, 0x64, 0x62, 0x64, 0x64, 0x36, 0x30, 0x64, 0x61, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x35, 0x38, 0x35, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x34, 0x38, 0x34, 0x38, 0x32, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x38, 0x33, 0x31, 0x36, 0x39, 0x30, 0x39, 0x34, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x38, 0x34, 0x35, 0x32, 0x35, 0x32, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x32, 0x30, 0x39, 0x36, 0x35, 0x30, 0x37, 0x66, 0x32, 0x38, 0x63, 0x66, 0x39, 0x31, 0x61, 0x63, 0x30, 0x36, 0x34, 0x65, 0x31, 0x37, 0x39, 0x66, 0x38, 0x61, 0x34, 0x32, 0x65, 0x34, 0x62, 0x37, 0x61, 0x32, 0x30, 0x62, 0x61, 0x30, 0x38, 0x30, 0x31, 0x38, 0x37, 0x37, 0x38, 0x31, 0x64, 0x61, 0x35, 0x35, 0x66, 0x64, 0x34, 0x66, 0x33, 0x66, 0x31, 0x38, 0x38, 0x37, 0x30, 0x62, 0x37, 0x61, 0x32, 0x35, 0x62, 0x61, 0x63, 0x62, 0x35, 0x35, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x32, 0x38, 0x34, 0x31, 0x34, 0x38, 0x30, 0x31, 0x35, 0x39, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x65, 0x66, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x39, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x62, 0x32, 0x39, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x33, 0x31, 0x64, 0x35, 0x63, 0x64, 0x39, 0x35, 0x39, 0x36, 0x30, 0x65, 0x32, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x30, 0x31, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x38, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x30, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x35, 0x32, 0x36, 0x31, 0x30, 0x62, 0x37, 0x34, 0x39, 0x31, 0x38, 0x62, 0x39, 0x30, 0x36, 0x30, 0x31, 0x30, 0x39, 0x30, 0x38, 0x33, 0x39, 0x30, 0x38, 0x33, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x38, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x62, 0x30, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x36, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x35, 0x31, 0x30, 0x62, 0x38, 0x33, 0x39, 0x33, 0x37, 0x62, 0x37, 0x62, 0x33, 0x36, 0x30, 0x64, 0x31, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x37, 0x39, 0x30, 0x37, 0x66, 0x38, 0x37, 0x39, 0x37, 0x31, 0x34, 0x34, 0x39, 0x34, 0x38, 0x37, 0x38, 0x32, 0x61, 0x64, 0x63, 0x65, 0x64, 0x65, 0x38, 0x65, 0x30, 0x34, 0x62, 0x66, 0x61, 0x30, 0x62, 0x64, 0x38, 0x66, 0x64, 0x35, 0x36, 0x39, 0x34, 0x31, 0x65, 0x30, 0x64, 0x66, 0x37, 0x35, 0x30, 0x38, 0x62, 0x64, 0x30, 0x32, 0x61, 0x36, 0x32, 0x39, 0x62, 0x34, 0x37, 0x37, 0x66, 0x37, 0x62, 0x30, 0x37, 0x33, 0x61, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x61, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x33, 0x31, 0x33, 0x36, 0x32, 0x39, 0x64, 0x66, 0x35, 0x36, 0x30, 0x65, 0x31, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x31, 0x30, 0x31, 0x38, 0x39, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x39, 0x32, 0x38, 0x33, 0x35, 0x32, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x38, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x39, 0x31, 0x36, 0x39, 0x32, 0x36, 0x33, 0x32, 0x36, 0x63, 0x35, 0x33, 0x62, 0x65, 0x61, 0x39, 0x32, 0x38, 0x62, 0x39, 0x32, 0x38, 0x61, 0x39, 0x32, 0x38, 0x61, 0x39, 0x32, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x38, 0x34, 0x38, 0x34, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x37, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x35, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x31, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x36, 0x39, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x39, 0x31, 0x38, 0x32, 0x39, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x31, 0x39, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x36, 0x31, 0x36, 0x31, 0x35, 0x30, 0x32, 0x30, 0x31, 0x39, 0x30, 0x39, 0x33, 0x31, 0x36, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x30, 0x34, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x34, 0x39, 0x30, 0x30, 0x34, 0x38, 0x34, 0x30, 0x32, 0x38, 0x31, 0x30, 0x31, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x39, 0x34, 0x35, 0x32, 0x38, 0x30, 0x38, 0x34, 0x35, 0x32, 0x39, 0x30, 0x39, 0x31, 0x38, 0x33, 0x30, 0x31, 0x38, 0x32, 0x38, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x64, 0x31, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x30, 0x36, 0x31, 0x30, 0x63, 0x65, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x35, 0x34, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x35, 0x32, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x36, 0x31, 0x30, 0x64, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x63, 0x66, 0x34, 0x35, 0x37, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x35, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x39, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x33, 0x33, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x37, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x65, 0x39, 0x37, 0x31, 0x66, 0x65, 0x66, 0x32, 0x62, 0x62, 0x36, 0x30, 0x66, 0x37, 0x30, 0x39, 0x65, 0x31, 0x64, 0x61, 0x66, 0x33, 0x65, 0x35, 0x35, 0x64, 0x30, 0x30, 0x39, 0x31, 0x34, 0x65, 0x32, 0x33, 0x30, 0x63, 0x64, 0x39, 0x34, 0x31, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x64, 0x61, 0x35, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x62, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x61, 0x31, 0x30, 0x62, 0x39, 0x33, 0x37, 0x62, 0x37, 0x62, 0x61, 0x32, 0x39, 0x62, 0x32, 0x62, 0x61, 0x33, 0x61, 0x33, 0x32, 0x62, 0x39, 0x36, 0x30, 0x61, 0x39, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x35, 0x36, 0x30, 0x30, 0x34, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x64, 0x62, 0x64, 0x36, 0x31, 0x31, 0x33, 0x38, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x64, 0x65, 0x36, 0x38, 0x32, 0x36, 0x31, 0x31, 0x30, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x64, 0x65, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x64, 0x66, 0x61, 0x38, 0x33, 0x36, 0x31, 0x31, 0x30, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x31, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x34, 0x66, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x33, 0x63, 0x36, 0x31, 0x31, 0x33, 0x38, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x65, 0x33, 0x34, 0x35, 0x37, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x65, 0x36, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x31, 0x31, 0x34, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x36, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x62, 0x38, 0x34, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x62, 0x38, 0x35, 0x37, 0x36, 0x31, 0x30, 0x65, 0x37, 0x65, 0x38, 0x33, 0x36, 0x31, 0x31, 0x31, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x34, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x61, 0x31, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x32, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x30, 0x31, 0x35, 0x32, 0x39, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x65, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x35, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x37, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x66, 0x30, 0x61, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x37, 0x32, 0x32, 0x62, 0x62, 0x39, 0x33, 0x37, 0x62, 0x37, 0x33, 0x33, 0x39, 0x30, 0x33, 0x61, 0x33, 0x37, 0x62, 0x61, 0x33, 0x30, 0x62, 0x36, 0x31, 0x30, 0x33, 0x36, 0x33, 0x32, 0x62, 0x37, 0x33, 0x33, 0x62, 0x61, 0x33, 0x34, 0x31, 0x37, 0x36, 0x30, 0x36, 0x39, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x39, 0x30, 0x36, 0x31, 0x30, 0x66, 0x32, 0x39, 0x35, 0x37, 0x35, 0x30, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x31, 0x31, 0x30, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x66, 0x33, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x66, 0x33, 0x65, 0x38, 0x34, 0x36, 0x31, 0x31, 0x32, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x39, 0x31, 0x39, 0x33, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x35, 0x61, 0x35, 0x37, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x35, 0x62, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x31, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x66, 0x37, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x66, 0x37, 0x63, 0x38, 0x32, 0x36, 0x31, 0x30, 0x66, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x36, 0x30, 0x39, 0x30, 0x36, 0x31, 0x30, 0x66, 0x39, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x66, 0x39, 0x63, 0x38, 0x34, 0x36, 0x31, 0x31, 0x32, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x62, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x65, 0x34, 0x35, 0x37, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x38, 0x30, 0x33, 0x36, 0x38, 0x33, 0x33, 0x37, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x66, 0x66, 0x36, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x31, 0x32, 0x36, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x33, 0x62, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x31, 0x35, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x62, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x66, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x32, 0x31, 0x63, 0x38, 0x31, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x36, 0x63, 0x35, 0x37, 0x38, 0x35, 0x38, 0x31, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x33, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x31, 0x30, 0x61, 0x65, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x38, 0x36, 0x38, 0x32, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x37, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x31, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x36, 0x31, 0x31, 0x30, 0x63, 0x37, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x36, 0x30, 0x63, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x65, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x36, 0x31, 0x31, 0x31, 0x30, 0x31, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x31, 0x31, 0x31, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x31, 0x31, 0x34, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x38, 0x35, 0x35, 0x31, 0x39, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x30, 0x31, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x33, 0x66, 0x35, 0x37, 0x36, 0x31, 0x31, 0x31, 0x33, 0x30, 0x38, 0x32, 0x36, 0x31, 0x31, 0x31, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x31, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x31, 0x31, 0x61, 0x36, 0x30, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x36, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x38, 0x31, 0x31, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x31, 0x37, 0x64, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x38, 0x31, 0x31, 0x30, 0x38, 0x30, 0x31, 0x35, 0x39, 0x30, 0x36, 0x31, 0x31, 0x31, 0x37, 0x64, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x66, 0x38, 0x38, 0x31, 0x31, 0x30, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x38, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x61, 0x30, 0x35, 0x37, 0x36, 0x30, 0x62, 0x35, 0x31, 0x39, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x35, 0x31, 0x39, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x38, 0x31, 0x31, 0x61, 0x36, 0x30, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x63, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x64, 0x62, 0x35, 0x37, 0x36, 0x30, 0x37, 0x65, 0x31, 0x39, 0x38, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x30, 0x38, 0x35, 0x37, 0x36, 0x30, 0x62, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x38, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x31, 0x64, 0x35, 0x37, 0x36, 0x30, 0x62, 0x65, 0x31, 0x39, 0x38, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x32, 0x35, 0x36, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x31, 0x31, 0x34, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x34, 0x35, 0x31, 0x39, 0x34, 0x38, 0x31, 0x30, 0x31, 0x39, 0x35, 0x39, 0x34, 0x30, 0x33, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x31, 0x31, 0x32, 0x37, 0x34, 0x35, 0x37, 0x36, 0x31, 0x31, 0x32, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x32, 0x39, 0x34, 0x35, 0x37, 0x38, 0x32, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x39, 0x32, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x30, 0x31, 0x36, 0x31, 0x31, 0x32, 0x37, 0x35, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x62, 0x36, 0x35, 0x37, 0x38, 0x32, 0x35, 0x31, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x39, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x36, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x38, 0x32, 0x35, 0x32, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x30, 0x36, 0x31, 0x31, 0x32, 0x65, 0x31, 0x35, 0x37, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x66, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x30, 0x30, 0x34, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x32, 0x66, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x33, 0x39, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x34, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x30, 0x30, 0x34, 0x38, 0x31, 0x30, 0x31, 0x39, 0x32, 0x38, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x30, 0x36, 0x31, 0x31, 0x33, 0x34, 0x33, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x38, 0x33, 0x38, 0x30, 0x30, 0x31, 0x31, 0x37, 0x38, 0x35, 0x35, 0x35, 0x36, 0x31, 0x31, 0x33, 0x37, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x35, 0x35, 0x35, 0x38, 0x32, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x37, 0x30, 0x35, 0x37, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x62, 0x38, 0x32, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x37, 0x30, 0x35, 0x37, 0x38, 0x32, 0x35, 0x31, 0x38, 0x32, 0x35, 0x35, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x33, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x37, 0x63, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x39, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x37, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x35, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x33, 0x39, 0x62, 0x35, 0x36, 0x66, 0x65, 0x61, 0x31, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x61, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x38, 0x64, 0x61, 0x35, 0x63, 0x62, 0x35, 0x62, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x65, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x38, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x36, 0x31, 0x34, 0x64, 0x30, 0x64, 0x36, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x36, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x36, 0x31, 0x34, 0x64, 0x30, 0x64, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x39, 0x35, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x64, 0x39, 0x65, 0x66, 0x35, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x61, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x32, 0x66, 0x64, 0x65, 0x33, 0x38, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x64, 0x64, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x63, 0x30, 0x63, 0x35, 0x34, 0x36, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x31, 0x30, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x32, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x63, 0x63, 0x37, 0x39, 0x66, 0x39, 0x37, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x36, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x30, 0x36, 0x66, 0x37, 0x37, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x38, 0x30, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x63, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x61, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x63, 0x62, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x62, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x62, 0x63, 0x65, 0x65, 0x62, 0x61, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x65, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x63, 0x64, 0x30, 0x36, 0x63, 0x62, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x66, 0x63, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x38, 0x64, 0x61, 0x35, 0x63, 0x62, 0x35, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x35, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x38, 0x66, 0x33, 0x32, 0x64, 0x35, 0x39, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x36, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x30, 0x32, 0x35, 0x65, 0x36, 0x34, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x39, 0x31, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x33, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x33, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x31, 0x35, 0x30, 0x31, 0x38, 0x61, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x36, 0x66, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x31, 0x32, 0x38, 0x32, 0x66, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x38, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x64, 0x33, 0x32, 0x65, 0x39, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x39, 0x39, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x62, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x38, 0x35, 0x63, 0x63, 0x39, 0x35, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x65, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x66, 0x39, 0x36, 0x61, 0x38, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x32, 0x37, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x39, 0x35, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x61, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x31, 0x61, 0x37, 0x64, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x35, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x37, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x32, 0x66, 0x63, 0x34, 0x37, 0x66, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x39, 0x65, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x30, 0x36, 0x66, 0x64, 0x64, 0x65, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x34, 0x39, 0x39, 0x63, 0x35, 0x39, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x34, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x38, 0x31, 0x36, 0x30, 0x64, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x37, 0x62, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x64, 0x31, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x39, 0x31, 0x39, 0x32, 0x38, 0x33, 0x39, 0x32, 0x39, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x30, 0x62, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x31, 0x66, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x33, 0x38, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x35, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x36, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x36, 0x31, 0x30, 0x37, 0x35, 0x63, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x38, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x31, 0x30, 0x37, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x61, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x61, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x63, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x38, 0x31, 0x33, 0x35, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x65, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x66, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x31, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x33, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x30, 0x31, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x33, 0x35, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x36, 0x31, 0x30, 0x37, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x37, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x36, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x31, 0x30, 0x37, 0x65, 0x65, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x37, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x38, 0x38, 0x36, 0x31, 0x30, 0x38, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x66, 0x66, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x61, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x61, 0x36, 0x31, 0x30, 0x38, 0x63, 0x62, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x62, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x64, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x31, 0x33, 0x35, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x33, 0x35, 0x36, 0x31, 0x30, 0x38, 0x64, 0x61, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x66, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x31, 0x33, 0x35, 0x38, 0x31, 0x31, 0x36, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x33, 0x35, 0x31, 0x36, 0x36, 0x31, 0x30, 0x39, 0x61, 0x38, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x33, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x61, 0x36, 0x31, 0x30, 0x61, 0x32, 0x31, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x34, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x35, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x36, 0x31, 0x30, 0x61, 0x33, 0x30, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x37, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x39, 0x36, 0x31, 0x30, 0x61, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x39, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x31, 0x30, 0x61, 0x39, 0x38, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x61, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x62, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x33, 0x35, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x33, 0x35, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x64, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x66, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x31, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x35, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x39, 0x65, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x35, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x61, 0x36, 0x31, 0x30, 0x62, 0x63, 0x32, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x37, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x37, 0x64, 0x36, 0x31, 0x30, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x31, 0x35, 0x31, 0x35, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x39, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x64, 0x31, 0x36, 0x31, 0x30, 0x62, 0x65, 0x32, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x62, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x64, 0x31, 0x36, 0x31, 0x30, 0x63, 0x30, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x37, 0x64, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x64, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x31, 0x33, 0x35, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x33, 0x35, 0x36, 0x31, 0x30, 0x63, 0x31, 0x64, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x66, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x31, 0x30, 0x63, 0x34, 0x30, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x30, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x37, 0x64, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x31, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x31, 0x30, 0x63, 0x63, 0x39, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x33, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x34, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x31, 0x33, 0x35, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x30, 0x31, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x33, 0x35, 0x36, 0x31, 0x30, 0x63, 0x64, 0x65, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x31, 0x30, 0x63, 0x66, 0x64, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x38, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x31, 0x30, 0x64, 0x30, 0x33, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x61, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x30, 0x36, 0x31, 0x30, 0x64, 0x30, 0x39, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x62, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x63, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x36, 0x31, 0x30, 0x64, 0x35, 0x33, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x65, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x30, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x36, 0x31, 0x30, 0x65, 0x30, 0x35, 0x35, 0x36, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x31, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x61, 0x36, 0x31, 0x30, 0x65, 0x32, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x37, 0x38, 0x31, 0x35, 0x32, 0x37, 0x66, 0x35, 0x30, 0x36, 0x66, 0x36, 0x63, 0x37, 0x39, 0x36, 0x37, 0x36, 0x66, 0x36, 0x65, 0x32, 0x30, 0x34, 0x35, 0x36, 0x33, 0x36, 0x66, 0x37, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x30, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x66, 0x34, 0x34, 0x36, 0x39, 0x37, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x63, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x36, 0x36, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x36, 0x30, 0x38, 0x30, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x62, 0x32, 0x30, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x33, 0x65, 0x32, 0x35, 0x30, 0x32, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x30, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x66, 0x34, 0x34, 0x36, 0x39, 0x37, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x63, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x36, 0x36, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x36, 0x30, 0x38, 0x30, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x33, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x37, 0x66, 0x61, 0x38, 0x32, 0x36, 0x31, 0x30, 0x61, 0x33, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x39, 0x30, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x31, 0x30, 0x39, 0x30, 0x38, 0x34, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x36, 0x31, 0x30, 0x65, 0x33, 0x31, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x35, 0x38, 0x32, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x39, 0x30, 0x36, 0x31, 0x30, 0x38, 0x32, 0x31, 0x35, 0x37, 0x35, 0x30, 0x38, 0x32, 0x33, 0x34, 0x31, 0x34, 0x35, 0x62, 0x36, 0x31, 0x30, 0x38, 0x36, 0x38, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x37, 0x32, 0x31, 0x32, 0x35, 0x62, 0x39, 0x63, 0x64, 0x64, 0x35, 0x39, 0x39, 0x39, 0x39, 0x61, 0x35, 0x38, 0x64, 0x61, 0x35, 0x39, 0x35, 0x62, 0x39, 0x64, 0x30, 0x38, 0x31, 0x38, 0x35, 0x62, 0x35, 0x62, 0x64, 0x64, 0x35, 0x62, 0x39, 0x64, 0x36, 0x30, 0x36, 0x61, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x30, 0x38, 0x34, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x37, 0x66, 0x65, 0x62, 0x66, 0x66, 0x32, 0x36, 0x30, 0x32, 0x62, 0x33, 0x66, 0x34, 0x36, 0x38, 0x32, 0x35, 0x39, 0x65, 0x31, 0x65, 0x39, 0x39, 0x66, 0x36, 0x31, 0x33, 0x66, 0x65, 0x64, 0x36, 0x36, 0x39, 0x31, 0x66, 0x33, 0x61, 0x36, 0x35, 0x32, 0x36, 0x65, 0x66, 0x66, 0x65, 0x36, 0x65, 0x66, 0x33, 0x65, 0x37, 0x36, 0x38, 0x62, 0x61, 0x37, 0x61, 0x65, 0x37, 0x61, 0x33, 0x36, 0x63, 0x34, 0x66, 0x38, 0x35, 0x38, 0x34, 0x36, 0x31, 0x30, 0x38, 0x61, 0x34, 0x38, 0x37, 0x36, 0x31, 0x30, 0x61, 0x33, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x33, 0x38, 0x34, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x34, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x35, 0x32, 0x38, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x31, 0x32, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x38, 0x65, 0x32, 0x36, 0x31, 0x30, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x38, 0x65, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x30, 0x33, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x32, 0x31, 0x36, 0x31, 0x35, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x39, 0x33, 0x65, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x33, 0x38, 0x64, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x39, 0x34, 0x39, 0x38, 0x33, 0x36, 0x31, 0x30, 0x61, 0x33, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x39, 0x30, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x35, 0x66, 0x39, 0x30, 0x38, 0x33, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x36, 0x31, 0x30, 0x65, 0x34, 0x36, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x35, 0x36, 0x31, 0x30, 0x39, 0x36, 0x63, 0x38, 0x33, 0x38, 0x33, 0x36, 0x31, 0x30, 0x65, 0x35, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x30, 0x38, 0x35, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x37, 0x66, 0x34, 0x65, 0x32, 0x63, 0x61, 0x30, 0x35, 0x31, 0x35, 0x65, 0x64, 0x31, 0x61, 0x65, 0x66, 0x31, 0x33, 0x39, 0x35, 0x66, 0x36, 0x36, 0x62, 0x35, 0x33, 0x30, 0x33, 0x62, 0x62, 0x35, 0x64, 0x36, 0x66, 0x31, 0x62, 0x66, 0x39, 0x64, 0x36, 0x31, 0x61, 0x33, 0x35, 0x33, 0x66, 0x61, 0x35, 0x33, 0x66, 0x37, 0x33, 0x66, 0x38, 0x61, 0x63, 0x39, 0x39, 0x37, 0x33, 0x66, 0x61, 0x39, 0x66, 0x36, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x30, 0x38, 0x61, 0x34, 0x38, 0x38, 0x36, 0x31, 0x30, 0x61, 0x33, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x37, 0x35, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x65, 0x61, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x33, 0x36, 0x61, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x37, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x30, 0x31, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x36, 0x30, 0x30, 0x32, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x33, 0x31, 0x36, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x39, 0x39, 0x30, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x36, 0x31, 0x30, 0x61, 0x31, 0x64, 0x38, 0x32, 0x36, 0x31, 0x30, 0x66, 0x31, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x33, 0x31, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x61, 0x34, 0x35, 0x36, 0x31, 0x30, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x61, 0x34, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x39, 0x30, 0x39, 0x31, 0x31, 0x36, 0x39, 0x30, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x39, 0x30, 0x38, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x35, 0x31, 0x36, 0x30, 0x34, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x62, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x62, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x64, 0x62, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x30, 0x31, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x31, 0x62, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x66, 0x33, 0x35, 0x37, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x31, 0x63, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x30, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x62, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x38, 0x34, 0x35, 0x32, 0x38, 0x39, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x66, 0x66, 0x38, 0x34, 0x31, 0x36, 0x38, 0x32, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x36, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x35, 0x39, 0x30, 0x35, 0x32, 0x39, 0x31, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x36, 0x30, 0x61, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x39, 0x33, 0x39, 0x31, 0x39, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x38, 0x31, 0x30, 0x31, 0x39, 0x32, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x35, 0x62, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x30, 0x31, 0x35, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x34, 0x31, 0x36, 0x36, 0x31, 0x30, 0x62, 0x62, 0x38, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x37, 0x31, 0x32, 0x32, 0x62, 0x39, 0x33, 0x39, 0x33, 0x37, 0x62, 0x39, 0x31, 0x30, 0x33, 0x34, 0x62, 0x37, 0x31, 0x30, 0x33, 0x32, 0x62, 0x31, 0x62, 0x39, 0x33, 0x32, 0x62, 0x31, 0x62, 0x37, 0x62, 0x62, 0x33, 0x32, 0x62, 0x39, 0x36, 0x30, 0x37, 0x31, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x33, 0x33, 0x31, 0x34, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x33, 0x61, 0x39, 0x39, 0x36, 0x30, 0x66, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x32, 0x31, 0x34, 0x31, 0x33, 0x64, 0x33, 0x36, 0x30, 0x65, 0x61, 0x31, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x63, 0x32, 0x65, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x62, 0x62, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x63, 0x33, 0x39, 0x33, 0x33, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x30, 0x66, 0x38, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x34, 0x33, 0x34, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x63, 0x38, 0x62, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x36, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x39, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x63, 0x66, 0x34, 0x36, 0x31, 0x30, 0x63, 0x65, 0x66, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x31, 0x31, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x38, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x35, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x61, 0x39, 0x39, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x33, 0x62, 0x30, 0x36, 0x30, 0x35, 0x32, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x63, 0x38, 0x62, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x36, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x64, 0x36, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x31, 0x31, 0x36, 0x36, 0x31, 0x30, 0x64, 0x61, 0x39, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x33, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x34, 0x30, 0x32, 0x36, 0x30, 0x33, 0x32, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x35, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x30, 0x38, 0x34, 0x31, 0x36, 0x39, 0x32, 0x31, 0x36, 0x39, 0x30, 0x37, 0x66, 0x31, 0x66, 0x39, 0x66, 0x33, 0x35, 0x35, 0x36, 0x64, 0x64, 0x33, 0x33, 0x36, 0x30, 0x31, 0x36, 0x63, 0x64, 0x66, 0x32, 0x30, 0x61, 0x64, 0x61, 0x65, 0x61, 0x64, 0x37, 0x64, 0x35, 0x63, 0x37, 0x33, 0x36, 0x36, 0x35, 0x64, 0x62, 0x61, 0x36, 0x36, 0x34, 0x62, 0x36, 0x30, 0x65, 0x38, 0x63, 0x31, 0x37, 0x65, 0x39, 0x61, 0x34, 0x65, 0x62, 0x39, 0x31, 0x63, 0x65, 0x31, 0x64, 0x33, 0x39, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x33, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x30, 0x64, 0x36, 0x31, 0x30, 0x62, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x31, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x31, 0x66, 0x38, 0x31, 0x36, 0x31, 0x30, 0x66, 0x31, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x34, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x33, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x38, 0x35, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x39, 0x61, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x61, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x39, 0x37, 0x32, 0x36, 0x35, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x65, 0x36, 0x33, 0x37, 0x39, 0x36, 0x30, 0x62, 0x30, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x38, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x33, 0x38, 0x38, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x36, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x36, 0x31, 0x36, 0x39, 0x30, 0x38, 0x34, 0x39, 0x30, 0x38, 0x36, 0x39, 0x30, 0x38, 0x35, 0x38, 0x31, 0x38, 0x31, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x33, 0x64, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x65, 0x66, 0x34, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x33, 0x66, 0x33, 0x64, 0x30, 0x31, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x64, 0x38, 0x32, 0x35, 0x32, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x34, 0x30, 0x31, 0x33, 0x65, 0x36, 0x31, 0x30, 0x65, 0x66, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x66, 0x30, 0x62, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x38, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x31, 0x31, 0x36, 0x36, 0x31, 0x30, 0x66, 0x32, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x30, 0x38, 0x35, 0x31, 0x36, 0x39, 0x33, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x39, 0x31, 0x61, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x35, 0x31, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x38, 0x32, 0x39, 0x31, 0x33, 0x30, 0x39, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x34, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x36, 0x30, 0x32, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x64, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x65, 0x34, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x66, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x37, 0x31, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x33, 0x30, 0x39, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x34, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x36, 0x30, 0x32, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x34, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x35, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x37, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x30, 0x38, 0x31, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x31, 0x32, 0x39, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x35, 0x34, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x39, 0x38, 0x31, 0x31, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x33, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x39, 0x32, 0x35, 0x31, 0x38, 0x31, 0x38, 0x61, 0x31, 0x36, 0x39, 0x34, 0x39, 0x30, 0x39, 0x31, 0x31, 0x36, 0x39, 0x31, 0x37, 0x66, 0x65, 0x36, 0x34, 0x39, 0x37, 0x65, 0x33, 0x65, 0x65, 0x35, 0x34, 0x38, 0x61, 0x33, 0x33, 0x37, 0x32, 0x31, 0x33, 0x36, 0x61, 0x66, 0x32, 0x66, 0x63, 0x62, 0x30, 0x36, 0x39, 0x36, 0x64, 0x62, 0x33, 0x31, 0x66, 0x63, 0x36, 0x63, 0x66, 0x32, 0x30, 0x32, 0x36, 0x30, 0x37, 0x30, 0x37, 0x36, 0x34, 0x35, 0x30, 0x36, 0x38, 0x62, 0x64, 0x33, 0x66, 0x65, 0x39, 0x37, 0x66, 0x33, 0x63, 0x34, 0x39, 0x31, 0x38, 0x39, 0x39, 0x31, 0x38, 0x38, 0x39, 0x31, 0x38, 0x38, 0x39, 0x31, 0x33, 0x30, 0x39, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x34, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x32, 0x36, 0x30, 0x32, 0x30, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x66, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x31, 0x32, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x32, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x33, 0x30, 0x39, 0x31, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x34, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x36, 0x30, 0x32, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x37, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x38, 0x34, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x39, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x35, 0x38, 0x36, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x36, 0x30, 0x31, 0x39, 0x34, 0x39, 0x30, 0x39, 0x34, 0x35, 0x32, 0x38, 0x34, 0x38, 0x34, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x61, 0x30, 0x30, 0x31, 0x39, 0x30, 0x61, 0x34, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x35, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x34, 0x33, 0x34, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x32, 0x32, 0x30, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x32, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x36, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x34, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x30, 0x31, 0x38, 0x33, 0x35, 0x32, 0x38, 0x30, 0x38, 0x35, 0x35, 0x32, 0x38, 0x32, 0x35, 0x31, 0x39, 0x32, 0x38, 0x32, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x32, 0x30, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x39, 0x62, 0x39, 0x30, 0x39, 0x62, 0x31, 0x36, 0x39, 0x61, 0x38, 0x31, 0x30, 0x31, 0x39, 0x61, 0x39, 0x30, 0x39, 0x61, 0x35, 0x32, 0x35, 0x30, 0x38, 0x38, 0x30, 0x31, 0x39, 0x36, 0x39, 0x30, 0x39, 0x36, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x36, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x61, 0x30, 0x39, 0x30, 0x32, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x62, 0x62, 0x63, 0x38, 0x32, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x31, 0x31, 0x33, 0x34, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x38, 0x32, 0x31, 0x36, 0x33, 0x30, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x65, 0x64, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x32, 0x34, 0x36, 0x31, 0x62, 0x63, 0x64, 0x36, 0x30, 0x65, 0x35, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x36, 0x30, 0x32, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x37, 0x32, 0x30, 0x36, 0x33, 0x36, 0x31, 0x36, 0x65, 0x32, 0x37, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x64, 0x35, 0x32, 0x34, 0x33, 0x33, 0x32, 0x33, 0x36, 0x30, 0x36, 0x63, 0x31, 0x62, 0x36, 0x30, 0x34, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x39, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x36, 0x34, 0x30, 0x31, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x66, 0x37, 0x38, 0x32, 0x38, 0x32, 0x36, 0x31, 0x30, 0x65, 0x35, 0x38, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x61, 0x30, 0x31, 0x62, 0x30, 0x33, 0x31, 0x36, 0x37, 0x66, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x39, 0x30, 0x31, 0x36, 0x30, 0x66, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x32, 0x38, 0x31, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x32, 0x39, 0x30, 0x32, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x35, 0x34, 0x36, 0x38, 0x36, 0x35, 0x32, 0x30, 0x36, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x36, 0x63, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x36, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x36, 0x39, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x37, 0x61, 0x36, 0x35, 0x36, 0x34, 0x34, 0x39, 0x36, 0x65, 0x37, 0x33, 0x37, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x66, 0x37, 0x32, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x35, 0x37, 0x33, 0x36, 0x35, 0x37, 0x32, 0x34, 0x35, 0x34, 0x39, 0x35, 0x30, 0x33, 0x37, 0x33, 0x31, 0x33, 0x32, 0x34, 0x34, 0x36, 0x66, 0x36, 0x64, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x32, 0x38, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x36, 0x65, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x32, 0x63, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x37, 0x33, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x33, 0x36, 0x38, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x32, 0x63, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, 0x36, 0x37, 0x39, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x39, 0x34, 0x33, 0x36, 0x38, 0x36, 0x39, 0x36, 0x63, 0x36, 0x34, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x33, 0x61, 0x32, 0x30, 0x36, 0x65, 0x36, 0x35, 0x37, 0x37, 0x32, 0x30, 0x36, 0x33, 0x36, 0x38, 0x36, 0x39, 0x36, 0x63, 0x36, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x37, 0x34, 0x36, 0x38, 0x36, 0x35, 0x32, 0x30, 0x37, 0x61, 0x36, 0x35, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x35, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x65, 0x37, 0x33, 0x36, 0x36, 0x36, 0x35, 0x37, 0x32, 0x34, 0x66, 0x37, 0x32, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x38, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x34, 0x66, 0x37, 0x32, 0x34, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x63, 0x36, 0x32, 0x37, 0x39, 0x37, 0x34, 0x36, 0x35, 0x37, 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x30, 0x36, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x31, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x39, 0x37, 0x32, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x39, 0x61, 0x32, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x35, 0x66, 0x32, 0x33, 0x62, 0x65, 0x37, 0x35, 0x37, 0x34, 0x65, 0x37, 0x30, 0x63, 0x66, 0x63, 0x30, 0x31, 0x64, 0x30, 0x63, 0x66, 0x64, 0x36, 0x38, 0x30, 0x33, 0x62, 0x38, 0x37, 0x31, 0x66, 0x39, 0x32, 0x34, 0x36, 0x35, 0x65, 0x39, 0x61, 0x65, 0x34, 0x61, 0x31, 0x30, 0x66, 0x65, 0x39, 0x35, 0x65, 0x64, 0x33, 0x31, 0x63, 0x63, 0x62, 0x38, 0x31, 0x30, 0x62, 0x64, 0x61, 0x33, 0x65, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x33, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x30, 0x61, 0x64, 0x34, 0x66, 0x39, 0x61, 0x39, 0x41, 0x38, 0x45, 0x46, 0x65, 0x39, 0x41, 0x38, 0x44, 0x43, 0x42, 0x35, 0x66, 0x34, 0x36, 0x31, 0x63, 0x34, 0x43, 0x63, 0x31, 0x30, 0x34, 0x37, 0x45, 0x31, 0x44, 0x63, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x30, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x37, 0x63, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x34, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x30, 0x36, 0x33, 0x30, 0x36, 0x66, 0x64, 0x64, 0x65, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x62, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x30, 0x39, 0x35, 0x65, 0x61, 0x37, 0x62, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x34, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x38, 0x31, 0x36, 0x30, 0x64, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x61, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x62, 0x38, 0x37, 0x32, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x64, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x31, 0x61, 0x37, 0x64, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x35, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x38, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x31, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x63, 0x62, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x61, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x30, 0x65, 0x33, 0x30, 0x64, 0x62, 0x30, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x30, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x64, 0x36, 0x32, 0x65, 0x64, 0x33, 0x65, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x31, 0x32, 0x35, 0x37, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x62, 0x37, 0x36, 0x31, 0x30, 0x34, 0x38, 0x39, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x63, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x30, 0x63, 0x65, 0x36, 0x31, 0x30, 0x35, 0x32, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x65, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x30, 0x66, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x33, 0x62, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x35, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x39, 0x34, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x63, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x62, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x63, 0x33, 0x36, 0x31, 0x30, 0x36, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x65, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x34, 0x34, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x64, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x36, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x38, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x32, 0x32, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x39, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x61, 0x30, 0x36, 0x31, 0x30, 0x62, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x66, 0x64, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x36, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x31, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x32, 0x38, 0x36, 0x31, 0x30, 0x62, 0x38, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x36, 0x38, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x34, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x39, 0x35, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x65, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x31, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x31, 0x30, 0x36, 0x31, 0x30, 0x34, 0x38, 0x39, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x31, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x37, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x33, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x31, 0x66, 0x66, 0x66, 0x63, 0x63, 0x34, 0x39, 0x32, 0x33, 0x64, 0x30, 0x34, 0x62, 0x35, 0x35, 0x39, 0x66, 0x34, 0x64, 0x32, 0x39, 0x61, 0x38, 0x62, 0x66, 0x63, 0x36, 0x63, 0x64, 0x61, 0x30, 0x34, 0x65, 0x62, 0x35, 0x62, 0x30, 0x64, 0x33, 0x63, 0x34, 0x36, 0x30, 0x37, 0x35, 0x31, 0x63, 0x32, 0x34, 0x30, 0x32, 0x63, 0x35, 0x63, 0x35, 0x63, 0x63, 0x39, 0x31, 0x30, 0x39, 0x63, 0x33, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x34, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x30, 0x36, 0x31, 0x30, 0x35, 0x39, 0x31, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x35, 0x34, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x35, 0x32, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x36, 0x31, 0x30, 0x35, 0x62, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x35, 0x39, 0x66, 0x35, 0x37, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x63, 0x35, 0x62, 0x65, 0x31, 0x65, 0x35, 0x65, 0x62, 0x65, 0x63, 0x37, 0x64, 0x35, 0x62, 0x64, 0x31, 0x34, 0x66, 0x37, 0x31, 0x34, 0x32, 0x37, 0x64, 0x31, 0x65, 0x38, 0x34, 0x66, 0x33, 0x64, 0x64, 0x30, 0x33, 0x31, 0x34, 0x63, 0x30, 0x66, 0x37, 0x62, 0x32, 0x32, 0x39, 0x31, 0x65, 0x35, 0x62, 0x32, 0x30, 0x30, 0x61, 0x63, 0x38, 0x63, 0x37, 0x63, 0x33, 0x62, 0x39, 0x32, 0x35, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x66, 0x64, 0x35, 0x37, 0x35, 0x30, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x31, 0x38, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x38, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x37, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x32, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x30, 0x33, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x37, 0x66, 0x63, 0x66, 0x35, 0x33, 0x32, 0x63, 0x31, 0x35, 0x66, 0x30, 0x61, 0x36, 0x64, 0x62, 0x30, 0x62, 0x64, 0x36, 0x64, 0x30, 0x65, 0x30, 0x33, 0x38, 0x62, 0x65, 0x61, 0x37, 0x31, 0x64, 0x33, 0x30, 0x64, 0x38, 0x30, 0x38, 0x63, 0x37, 0x64, 0x39, 0x38, 0x63, 0x62, 0x33, 0x62, 0x66, 0x37, 0x32, 0x36, 0x38, 0x61, 0x39, 0x35, 0x62, 0x66, 0x35, 0x30, 0x38, 0x31, 0x62, 0x36, 0x35, 0x38, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x32, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x34, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x31, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x30, 0x36, 0x31, 0x30, 0x62, 0x65, 0x62, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x35, 0x34, 0x30, 0x34, 0x30, 0x32, 0x38, 0x33, 0x35, 0x32, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x36, 0x31, 0x30, 0x63, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x62, 0x66, 0x39, 0x35, 0x37, 0x38, 0x32, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x63, 0x32, 0x62, 0x33, 0x33, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x30, 0x36, 0x64, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x30, 0x30, 0x61, 0x31, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x30, 0x35, 0x38, 0x32, 0x30, 0x65, 0x61, 0x37, 0x62, 0x33, 0x61, 0x39, 0x30, 0x61, 0x38, 0x39, 0x39, 0x36, 0x39, 0x65, 0x62, 0x30, 0x30, 0x64, 0x32, 0x61, 0x35, 0x36, 0x66, 0x35, 0x38, 0x62, 0x30, 0x66, 0x38, 0x30, 0x34, 0x38, 0x31, 0x39, 0x34, 0x34, 0x34, 0x37, 0x35, 0x39, 0x30, 0x38, 0x61, 0x63, 0x66, 0x32, 0x35, 0x34, 0x33, 0x38, 0x37, 0x35, 0x39, 0x62, 0x35, 0x33, 0x62, 0x65, 0x37, 0x33, 0x65, 0x35, 0x62, 0x30, 0x30, 0x32, 0x39, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x31, 0x32, 0x31, 0x38, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x33, 0x36, 0x30, 0x61, 0x64, 0x34, 0x66, 0x39, 0x61, 0x39, 0x41, 0x38, 0x45, 0x46, 0x65, 0x39, 0x41, 0x38, 0x44, 0x43, 0x42, 0x35, 0x66, 0x34, 0x36, 0x31, 0x63, 0x34, 0x43, 0x63, 0x31, 0x30, 0x34, 0x37, 0x45, 0x31, 0x44, 0x63, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x30, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x37, 0x63, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x34, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x30, 0x36, 0x33, 0x30, 0x36, 0x66, 0x64, 0x64, 0x65, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x62, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x30, 0x39, 0x35, 0x65, 0x61, 0x37, 0x62, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x34, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x38, 0x31, 0x36, 0x30, 0x64, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x61, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x62, 0x38, 0x37, 0x32, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x64, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x31, 0x61, 0x37, 0x64, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x35, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x38, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x31, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x63, 0x62, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x61, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x30, 0x65, 0x33, 0x30, 0x64, 0x62, 0x30, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x30, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x64, 0x36, 0x32, 0x65, 0x64, 0x33, 0x65, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x31, 0x32, 0x35, 0x37, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x62, 0x37, 0x36, 0x31, 0x30, 0x34, 0x38, 0x39, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x63, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x30, 0x63, 0x65, 0x36, 0x31, 0x30, 0x35, 0x32, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x65, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x30, 0x66, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x33, 0x62, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x35, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x39, 0x34, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x36, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x62, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x63, 0x33, 0x36, 0x31, 0x30, 0x36, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x65, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x34, 0x34, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x36, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x38, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x63, 0x31, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x39, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x61, 0x30, 0x36, 0x31, 0x30, 0x61, 0x66, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x66, 0x64, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x66, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x31, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x32, 0x38, 0x36, 0x31, 0x30, 0x62, 0x31, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x36, 0x38, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x34, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x39, 0x35, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x65, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x31, 0x30, 0x36, 0x31, 0x30, 0x34, 0x38, 0x39, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x31, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x37, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x36, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x31, 0x66, 0x66, 0x66, 0x63, 0x63, 0x34, 0x39, 0x32, 0x33, 0x64, 0x30, 0x34, 0x62, 0x35, 0x35, 0x39, 0x66, 0x34, 0x64, 0x32, 0x39, 0x61, 0x38, 0x62, 0x66, 0x63, 0x36, 0x63, 0x64, 0x61, 0x30, 0x34, 0x65, 0x62, 0x35, 0x62, 0x30, 0x64, 0x33, 0x63, 0x34, 0x36, 0x30, 0x37, 0x35, 0x31, 0x63, 0x32, 0x34, 0x30, 0x32, 0x63, 0x35, 0x63, 0x35, 0x63, 0x63, 0x39, 0x31, 0x30, 0x39, 0x63, 0x33, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x35, 0x37, 0x37, 0x32, 0x36, 0x31, 0x37, 0x30, 0x37, 0x30, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x35, 0x30, 0x36, 0x66, 0x36, 0x63, 0x37, 0x39, 0x36, 0x37, 0x36, 0x66, 0x36, 0x65, 0x32, 0x30, 0x34, 0x35, 0x36, 0x33, 0x36, 0x66, 0x37, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x63, 0x35, 0x62, 0x65, 0x31, 0x65, 0x35, 0x65, 0x62, 0x65, 0x63, 0x37, 0x64, 0x35, 0x62, 0x64, 0x31, 0x34, 0x66, 0x37, 0x31, 0x34, 0x32, 0x37, 0x64, 0x31, 0x65, 0x38, 0x34, 0x66, 0x33, 0x64, 0x64, 0x30, 0x33, 0x31, 0x34, 0x63, 0x30, 0x66, 0x37, 0x62, 0x32, 0x32, 0x39, 0x31, 0x65, 0x35, 0x62, 0x32, 0x30, 0x30, 0x61, 0x63, 0x38, 0x63, 0x37, 0x63, 0x33, 0x62, 0x39, 0x32, 0x35, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x63, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x39, 0x63, 0x35, 0x37, 0x35, 0x30, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x62, 0x37, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x32, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x35, 0x34, 0x31, 0x30, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x34, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x32, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x61, 0x32, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x37, 0x66, 0x63, 0x66, 0x35, 0x33, 0x32, 0x63, 0x31, 0x35, 0x66, 0x30, 0x61, 0x36, 0x64, 0x62, 0x30, 0x62, 0x64, 0x36, 0x64, 0x30, 0x65, 0x30, 0x33, 0x38, 0x62, 0x65, 0x61, 0x37, 0x31, 0x64, 0x33, 0x30, 0x64, 0x38, 0x30, 0x38, 0x63, 0x37, 0x64, 0x39, 0x38, 0x63, 0x62, 0x33, 0x62, 0x66, 0x37, 0x32, 0x36, 0x38, 0x61, 0x39, 0x35, 0x62, 0x66, 0x35, 0x30, 0x38, 0x31, 0x62, 0x36, 0x35, 0x38, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x32, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x35, 0x37, 0x35, 0x30, 0x34, 0x66, 0x34, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x62, 0x35, 0x66, 0x33, 0x33, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x30, 0x36, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x30, 0x30, 0x61, 0x31, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x30, 0x35, 0x38, 0x32, 0x30, 0x38, 0x64, 0x37, 0x30, 0x64, 0x38, 0x61, 0x61, 0x32, 0x64, 0x37, 0x35, 0x32, 0x35, 0x33, 0x33, 0x31, 0x30, 0x35, 0x62, 0x35, 0x63, 0x63, 0x64, 0x61, 0x38, 0x32, 0x30, 0x36, 0x64, 0x61, 0x65, 0x38, 0x62, 0x30, 0x63, 0x31, 0x64, 0x65, 0x37, 0x36, 0x35, 0x66, 0x38, 0x39, 0x66, 0x62, 0x31, 0x66, 0x30, 0x63, 0x35, 0x37, 0x32, 0x37, 0x63, 0x62, 0x61, 0x63, 0x31, 0x62, 0x34, 0x30, 0x64, 0x30, 0x30, 0x32, 0x39, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x31, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x39, 0x36, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x35, 0x35, 0x37, 0x36, 0x30, 0x32, 0x39, 0x22, 0x7d }; namespace silkworm { constinit const std::string_view kGenesisAmoyJson{&kGenesisAmoyDataInternal[0], sizeof(kGenesisAmoyDataInternal)}; } ================================================ FILE: silkworm/core/chain/genesis_amoy.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { constinit extern const std::string_view kGenesisAmoyJson; } ================================================ FILE: silkworm/core/chain/genesis_amoy.json ================================================ { "alloc": { "0000000000000000000000000000000000001000": { "balance": "0x0", "code": "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" }, "0000000000000000000000000000000000001001": { "balance": "0x0", "code": "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" }, "0000000000000000000000000000000000001010": { "balance": "0x204fce28085b549b31600000", "code": "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" }, "6aB3d36C46ecFb9B9c0bD51CB1c3da5A2C81cea6": { "balance": "0x3635c9adc5dea00000" } }, "config": { "chainName": "amoy", "chainId": 80002, "consensus": "bor", "homesteadBlock": 0, "eip150Block": 0, "eip155Block": 0, "byzantiumBlock": 0, "constantinopleBlock": 0, "petersburgBlock": 0, "istanbulBlock": 0, "muirGlacierBlock": 0, "berlinBlock": 0, "londonBlock": 73100, "burntContract": { "0": "0x000000000000000000000000000000000000dead", "73100": "0xeCDD77cE6f146cCf5dab707941d318Bd50eeD2C9" }, "bor": { "period": { "0": 2 }, "producerDelay": { "0": 4 }, "sprint": { "0": 16 }, "backupMultiplier": { "0": 2 }, "stateSyncConfirmationDelay": { "0": 128 }, "validatorContract": "0x0000000000000000000000000000000000001000", "stateReceiverContract": "0x0000000000000000000000000000000000001001", "overrideStateSyncRecords": null, "jaipurBlock": 73100, "delhiBlock": 73100, "indoreBlock": 73100, "agraBlock": 73100, "napoliBlock": 5423600, "ahmedabadBlock": 11865856, "blockAlloc": { "11865856": { "0000000000000000000000000000000000001001": { "balance": "0x0", "code": "0x608060405234801561001057600080fd5b50600436106100cf5760003560e01c80635407ca671161008c578063abca220411610066578063abca2204146102fa578063d72a0b6714610302578063ee3a87f21461031f578063f165053614610342576100cf565b80635407ca67146102585780636757e5d914610260578063942af179146102f2576100cf565b806303112a17146100d457806319494a17146100f357806330e69fc31461017e578063318926f7146101985780633434735f146101bc57806351950cd9146101c4575b600080fd5b6100f1600480360360208110156100ea57600080fd5b503561034a565b005b61016a6004803603604081101561010957600080fd5b8135919081019060408101602082013564010000000081111561012b57600080fd5b82018360208201111561013d57600080fd5b8035906020019184600183028401116401000000008311171561015f57600080fd5b50909250905061060d565b604080519115158252519081900360200190f35b61018661093e565b60408051918252519081900360200190f35b6101a0610944565b604080516001600160a01b039092168252519081900360200190f35b6101a0610968565b6100f160048036036102808110156101db57600080fd5b61020082013590610220830135906001600160a01b036102408501351690840184610280810161026082013564010000000081111561021957600080fd5b82018360208201111561022b57600080fd5b8035906020019184600183028401116401000000008311171561024d57600080fd5b509092509050610973565b610186610c78565b61027d6004803603602081101561027657600080fd5b5035610c7e565b6040805160208082528351818301528351919283929083019185019080838360005b838110156102b757818101518382015260200161029f565b50505050905090810190601f1680156102e45780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b610186610d19565b610186610d1f565b61016a6004803603602081101561031857600080fd5b5035610d25565b6100f16004803603604081101561033557600080fd5b5080359060200135610d3a565b610186610db0565b60008181526003602090815260409182902080548351601f60026000196101006001861615020190931692909204918201849004840281018401909452808452606093928301828280156103df5780601f106103b4576101008083540402835291602001916103df565b820191906000526020600020905b8154815290600101906020018083116103c257829003601f168201915b50505050509050805160001415610426576040805162461bcd60e51b815260206004820152600660248201526508599bdd5b9960d21b604482015290519081900360640190fd5b600082815260036020526040812061043d916112bb565b6000606082806020019051604081101561045657600080fd5b81516020830180516040519294929383019291908464010000000082111561047d57600080fd5b90830190602082018581111561049257600080fd5b82516401000000008111828201881017156104ac57600080fd5b82525081516020918201929091019080838360005b838110156104d95781810151838201526020016104c1565b50505050905090810190601f1680156105065780820380516001836020036101000a031916815260200191505b5060405250505091509150837f8797144948782adcede8e04bfa0bd8fd56941e0df7508bd02a629b477f7b073a60405160405180910390a2604080516313629df560e11b815260048101868152602482019283528351604483015283516001600160a01b038616936326c53bea938993879390929160640190602085019080838360005b838110156105a257818101518382015260200161058a565b50505050905090810190601f1680156105cf5780820380516001836020036101000a031916815260200191505b509350505050600060405180830381600087803b1580156105ef57600080fd5b505af1158015610603573d6000803e3d6000fd5b5050505050505050565b6000336002600160a01b031461065f576040805162461bcd60e51b81526020600482015260126024820152714e6f742053797374656d204164646573732160701b604482015290519081900360640190fd5b60606106a86106a385858080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250610db592505050565b610ddb565b905060006106c9826000815181106106bc57fe5b6020026020010151610f14565b90508060005460010114610724576040805162461bcd60e51b815260206004820152601b60248201527f537461746549647320617265206e6f742073657175656e7469616c0000000000604482015290519081900360640190fd5b6000805460019081018255835161074c918591811061073f57fe5b6020026020010151610f62565b9050606061076d8460028151811061076057fe5b6020026020010151610f82565b905061077882610fff565b15610933576000624c4b409050606084836040516024018083815260200180602001828103825283818151815260200191508051906020019080838360005b838110156107cf5781810151838201526020016107b7565b50505050905090810190601f1680156107fc5780820380516001836020036101000a031916815260200191505b5060408051601f198184030181529190526020810180516001600160e01b03166313629df560e11b1781528151919650600095508594509092509050828887f1604080518215158152905191985086917f5a22725590b0a51c923940223f7458512164b1113359a735e86e7f27f44791ee9181900360200190a28661093057838360405160200180836001600160a01b0316815260200180602001828103825283818151815260200191508051906020019080838360005b838110156108cc5781810151838201526020016108b4565b50505050905090810190601f1680156108f95780820380516001836020036101000a031916815260200191505b5060408051601f1981840301815291815260008b815260036020908152919020825161092e9750909550910192509050611302565b505b50505b505050509392505050565b60045481565b7f000000000000000000000000be971fef2bb60f709e1daf3e55d00914e230cd9481565b6002600160a01b0381565b6201000085106109be576040805162461bcd60e51b81526020600482015260116024820152700d2dcecc2d8d2c840d8cac2cc92dcc8caf607b1b604482015290519081900360640190fd5b60045460058054600101908190551115610a05576040805162461bcd60e51b8152602060048201526003602482015262195b9960ea1b604482015290519081900360640190fd5b60015480610a42576040805162461bcd60e51b8152602060048201526005602482015264085c9bdbdd60da1b604482015290519081900360640190fd5b60008585858560405160200180858152602001846001600160a01b0316815260200180602001828103825284848281815260200192508082843760008184015260408051601f19601f909301831690940184810390920184525250805160209091012096507f28cf91ac064e179f8a42e4b7a20ba080187781da55fd4f3f18870b7a25bacb559550505050828414801592509050610aef575060008281526002602052604090205460ff16155b610b29576040805162461bcd60e51b815260206004808301919091526024820152631d5cd95960e21b604482015290519081900360640190fd5b60008281526002602052604090819020805460ff191660011790558051610200818101909252610b74918b9060109083908390808284376000920191909152508b915085905061100b565b8314610bb0576040805162461bcd60e51b815260206004820152600660248201526510b83937b7b360d11b604482015290519081900360640190fd5b60405187907f8797144948782adcede8e04bfa0bd8fd56941e0df7508bd02a629b477f7b073a90600090a2604080516313629df560e11b81526004810189815260248201928352604482018790526001600160a01b038916926326c53bea928b928a928a92606401848480828437600081840152601f19601f820116905080830192505050945050505050600060405180830381600087803b158015610c5557600080fd5b505af1158015610c69573d6000803e3d6000fd5b50505050505050505050505050565b60005481565b60036020908152600091825260409182902080548351601f600260001961010060018616150201909316929092049182018490048402810184019094528084529091830182828015610d115780601f10610ce657610100808354040283529160200191610d11565b820191906000526020600020905b815481529060010190602001808311610cf457829003601f168201915b505050505081565b60055481565b60015481565b60026020526000908152604090205460ff1681565b336001600160a01b037f000000000000000000000000be971fef2bb60f709e1daf3e55d00914e230cd941614610da5576040805162461bcd60e51b815260206004820152600b60248201526a10b937b7ba29b2ba3a32b960a91b604482015290519081900360640190fd5b600191909155600455565b601081565b610dbd611380565b5060408051808201909152815181526020828101908201525b919050565b6060610de6826110b6565b610def57600080fd5b6000610dfa836110f0565b905060608167ffffffffffffffff81118015610e1557600080fd5b50604051908082528060200260200182016040528015610e4f57816020015b610e3c611380565b815260200190600190039081610e345790505b5090506000610e618560200151611148565b60208601510190506000805b84811015610eb857610e7e836111ab565b9150604051806040016040528083815260200184815250848281518110610ea157fe5b602090810291909101015291810191600101610e6d565b5085516020870151830314610f0a576040805162461bcd60e51b81526020600482015260136024820152722bb937b733903a37ba30b6103632b733ba341760691b604482015290519081900360640190fd5b5090949350505050565b805160009015801590610f2957508151602110155b610f3257600080fd5b600080610f3e84611244565b815191935091506020821015610f5a5760208290036101000a90045b949350505050565b8051600090601514610f7357600080fd5b610f7c82610f14565b92915050565b8051606090610f9057600080fd5b600080610f9c84611244565b9150915060608167ffffffffffffffff81118015610fb957600080fd5b506040519080825280601f01601f191660200182016040528015610fe4576020820181803683370190505b50905060208101610ff684828561126a565b50949350505050565b3b63ffffffff16151590565b600081815b6010811015610ff657600185821c8116141561106c5785816010811061103257fe5b60200201518260405160200180838152602001828152602001925050506040516020818303038152906040528051906020012091506110ae565b8186826010811061107957fe5b602002015160405160200180838152602001828152602001925050506040516020818303038152906040528051906020012091505b600101611010565b80516000906110c757506000610dd6565b6020820151805160001a9060c08210156110e657600092505050610dd6565b5060019392505050565b805160009061110157506000610dd6565b6000806111118460200151611148565b602085015185519181019250015b8082101561113f57611130826111ab565b6001909301929091019061111f565b50909392505050565b8051600090811a6080811015611162576000915050610dd6565b60b881108061117d575060c0811080159061117d575060f881105b1561118c576001915050610dd6565b60c08110156111a05760b519019050610dd6565b60f519019050610dd6565b80516000908190811a60808110156111c6576001915061123d565b60b88110156111db57607e198101915061123d565b60c08110156112085760b78103600185019450806020036101000a8551046001820181019350505061123d565b60f881101561121d5760be198101915061123d565b60f78103600185019450806020036101000a855104600182018101935050505b5092915050565b60008060006112568460200151611148565b602085015194519481019594039392505050565b80611274576112b6565b5b60208110611294578251825260209283019290910190601f1901611275565b80156112b6578251825160208390036101000a60001901801990921691161782525b505050565b50805460018160011615610100020316600290046000825580601f106112e157506112ff565b601f0160209004906000526020600020908101906112ff919061139a565b50565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061134357805160ff1916838001178555611370565b82800160010185558215611370579182015b82811115611370578251825591602001919060010190611355565b5061137c92915061139a565b5090565b604051806040016040528060008152602001600081525090565b5b8082111561137c576000815560010161139b56fea164736f6c634300060c000a" }, "0000000000000000000000000000000000001010": { "balance": "0x0", "code": "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" }, "360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9": { "balance": "0x0", "code": "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" } }, "12121856": { "360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9": { "balance": "0x0", "code": "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" } } } } }, "difficulty": "0x01", "gasLimit": "0x989680", "timestamp": "0x65576029" } ================================================ FILE: silkworm/core/chain/genesis_bor_mainnet.cpp ================================================ /* Generated from genesis_bor_mainnet.json using silkworm embed_json tool */ #include "genesis_bor_mainnet.hpp" constexpr char kGenesisBorMainnetDataInternal[] = { 0x7b, 0x22, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x63, 0x38, 0x36, 0x31, 0x34, 0x64, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x30, 0x66, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x66, 0x32, 0x36, 0x61, 0x61, 0x39, 0x36, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x61, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x35, 0x62, 0x38, 0x34, 0x34, 0x65, 0x62, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x37, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x35, 0x62, 0x38, 0x34, 0x34, 0x65, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x36, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x64, 0x63, 0x66, 0x32, 0x37, 0x39, 0x33, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x38, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x62, 0x37, 0x63, 0x39, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x62, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x35, 0x39, 0x63, 0x66, 0x35, 0x36, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x64, 0x34, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x61, 0x66, 0x32, 0x36, 0x61, 0x61, 0x39, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x63, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x31, 0x64, 0x37, 0x61, 0x36, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x65, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x61, 0x62, 0x34, 0x64, 0x62, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x31, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x63, 0x31, 0x62, 0x33, 0x63, 0x39, 0x31, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x33, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x62, 0x61, 0x35, 0x37, 0x30, 0x37, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x64, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x62, 0x61, 0x35, 0x37, 0x30, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x32, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x38, 0x61, 0x62, 0x32, 0x62, 0x36, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x35, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x64, 0x31, 0x31, 0x62, 0x38, 0x30, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x37, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x65, 0x37, 0x35, 0x36, 0x34, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x61, 0x39, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x63, 0x38, 0x36, 0x31, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x39, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x35, 0x62, 0x33, 0x61, 0x31, 0x65, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x62, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x32, 0x33, 0x35, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x64, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x38, 0x37, 0x61, 0x39, 0x62, 0x64, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x66, 0x39, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x38, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x34, 0x64, 0x36, 0x35, 0x32, 0x38, 0x66, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x34, 0x64, 0x36, 0x35, 0x32, 0x38, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x65, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x64, 0x62, 0x63, 0x39, 0x35, 0x39, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x31, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x35, 0x36, 0x31, 0x34, 0x66, 0x63, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x33, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x38, 0x32, 0x61, 0x38, 0x64, 0x30, 0x38, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x36, 0x63, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x35, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x35, 0x64, 0x64, 0x66, 0x65, 0x65, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x37, 0x30, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x33, 0x65, 0x65, 0x38, 0x32, 0x31, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x61, 0x30, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x34, 0x63, 0x31, 0x35, 0x63, 0x62, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x62, 0x65, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x66, 0x32, 0x61, 0x37, 0x33, 0x66, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x63, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x66, 0x32, 0x61, 0x37, 0x33, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x61, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x62, 0x63, 0x30, 0x36, 0x35, 0x36, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x64, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x64, 0x65, 0x33, 0x61, 0x31, 0x38, 0x30, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x66, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x64, 0x64, 0x66, 0x33, 0x35, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x32, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x30, 0x34, 0x37, 0x61, 0x36, 0x63, 0x35, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x66, 0x35, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x30, 0x63, 0x33, 0x35, 0x62, 0x31, 0x63, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x32, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x32, 0x37, 0x30, 0x62, 0x35, 0x37, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x35, 0x38, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x33, 0x63, 0x32, 0x61, 0x32, 0x62, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x38, 0x38, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x30, 0x66, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x30, 0x61, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x37, 0x30, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x31, 0x65, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x35, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x34, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x33, 0x63, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x37, 0x35, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x34, 0x66, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x37, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x36, 0x64, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x39, 0x33, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x37, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x61, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x39, 0x64, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x64, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x61, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x62, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x32, 0x62, 0x39, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x31, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x63, 0x62, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x32, 0x64, 0x63, 0x36, 0x31, 0x31, 0x32, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x32, 0x65, 0x39, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x30, 0x63, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x30, 0x37, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x62, 0x37, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x31, 0x39, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x33, 0x63, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x33, 0x37, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x33, 0x30, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x34, 0x39, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x35, 0x61, 0x36, 0x31, 0x31, 0x34, 0x33, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x36, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x35, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x38, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x38, 0x35, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x62, 0x61, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x34, 0x34, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x39, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x61, 0x38, 0x36, 0x31, 0x31, 0x35, 0x31, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x62, 0x35, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x64, 0x38, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x33, 0x64, 0x33, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x33, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x33, 0x65, 0x35, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x30, 0x38, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x34, 0x30, 0x33, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x36, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x31, 0x35, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x34, 0x65, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x32, 0x36, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x33, 0x33, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x35, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x34, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x61, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x36, 0x33, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x38, 0x36, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x34, 0x38, 0x31, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x62, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x39, 0x33, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x61, 0x34, 0x36, 0x31, 0x31, 0x38, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x62, 0x33, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x35, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x63, 0x34, 0x36, 0x31, 0x31, 0x38, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x64, 0x32, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x65, 0x33, 0x36, 0x31, 0x31, 0x63, 0x35, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x34, 0x66, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x31, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x30, 0x65, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x65, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x63, 0x36, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x32, 0x32, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x34, 0x35, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x34, 0x30, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x61, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x63, 0x63, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x35, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x36, 0x33, 0x36, 0x31, 0x31, 0x63, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x37, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x39, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x38, 0x65, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x63, 0x66, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x61, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x62, 0x31, 0x36, 0x31, 0x31, 0x65, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x62, 0x65, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x63, 0x66, 0x36, 0x31, 0x31, 0x65, 0x34, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x64, 0x65, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x35, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x30, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x35, 0x66, 0x63, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x65, 0x61, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x30, 0x65, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x31, 0x66, 0x36, 0x31, 0x31, 0x66, 0x61, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x32, 0x64, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x36, 0x34, 0x62, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x66, 0x62, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x35, 0x64, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x36, 0x65, 0x36, 0x31, 0x31, 0x66, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x37, 0x62, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x38, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x39, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x36, 0x39, 0x39, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x65, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x66, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x61, 0x64, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x62, 0x65, 0x36, 0x31, 0x32, 0x30, 0x33, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x63, 0x62, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x65, 0x65, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x36, 0x65, 0x39, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x63, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x30, 0x35, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x66, 0x64, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x35, 0x35, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x37, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x31, 0x39, 0x33, 0x39, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x38, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x37, 0x37, 0x39, 0x35, 0x37, 0x36, 0x31, 0x30, 0x37, 0x37, 0x30, 0x36, 0x31, 0x31, 0x38, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x33, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x37, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x31, 0x65, 0x61, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x63, 0x64, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x31, 0x37, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x32, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x38, 0x35, 0x63, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x38, 0x39, 0x61, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x38, 0x66, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x31, 0x30, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x30, 0x63, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x30, 0x39, 0x37, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x38, 0x34, 0x35, 0x37, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x61, 0x34, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x38, 0x62, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x31, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x31, 0x33, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x62, 0x30, 0x61, 0x39, 0x30, 0x36, 0x31, 0x33, 0x34, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x62, 0x31, 0x64, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x33, 0x31, 0x35, 0x37, 0x36, 0x31, 0x30, 0x62, 0x33, 0x30, 0x36, 0x31, 0x32, 0x30, 0x37, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x36, 0x31, 0x30, 0x62, 0x34, 0x35, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x32, 0x33, 0x39, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x38, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x38, 0x36, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x62, 0x37, 0x64, 0x39, 0x30, 0x36, 0x31, 0x33, 0x34, 0x34, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x36, 0x38, 0x36, 0x31, 0x31, 0x36, 0x31, 0x30, 0x62, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x62, 0x62, 0x66, 0x39, 0x30, 0x36, 0x31, 0x33, 0x34, 0x61, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x39, 0x38, 0x39, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x36, 0x31, 0x30, 0x62, 0x64, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x63, 0x31, 0x61, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x31, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x34, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x37, 0x33, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x36, 0x61, 0x39, 0x30, 0x36, 0x31, 0x33, 0x34, 0x32, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x63, 0x63, 0x63, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x63, 0x33, 0x39, 0x30, 0x36, 0x31, 0x33, 0x34, 0x36, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x39, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x38, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x37, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x35, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x38, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x35, 0x35, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x33, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x64, 0x36, 0x36, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x61, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x64, 0x38, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x66, 0x36, 0x31, 0x30, 0x64, 0x64, 0x61, 0x38, 0x37, 0x38, 0x37, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x33, 0x62, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x33, 0x65, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x35, 0x31, 0x35, 0x37, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x65, 0x30, 0x65, 0x38, 0x33, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x30, 0x31, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x33, 0x65, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x63, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x65, 0x33, 0x34, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x31, 0x30, 0x65, 0x35, 0x64, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x35, 0x30, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x34, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x65, 0x37, 0x66, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x37, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x34, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x65, 0x61, 0x31, 0x38, 0x33, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x39, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x35, 0x33, 0x37, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x64, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x64, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x65, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x66, 0x61, 0x39, 0x36, 0x31, 0x30, 0x66, 0x61, 0x34, 0x38, 0x36, 0x38, 0x36, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x33, 0x62, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x33, 0x65, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x31, 0x64, 0x35, 0x37, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x66, 0x64, 0x38, 0x38, 0x33, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x66, 0x63, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x33, 0x65, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x64, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x66, 0x66, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x31, 0x31, 0x30, 0x32, 0x38, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x31, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x34, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x34, 0x61, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x33, 0x64, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x34, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x36, 0x63, 0x38, 0x33, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x35, 0x66, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x35, 0x33, 0x37, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x65, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x61, 0x33, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x66, 0x62, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x66, 0x63, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x31, 0x36, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x37, 0x34, 0x35, 0x37, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x32, 0x33, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x36, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x37, 0x62, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x30, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x34, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x32, 0x61, 0x33, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x32, 0x62, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x30, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x64, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x66, 0x66, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x62, 0x34, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x64, 0x39, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x33, 0x33, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x32, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x32, 0x63, 0x35, 0x37, 0x36, 0x31, 0x31, 0x34, 0x31, 0x64, 0x38, 0x33, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x34, 0x30, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x36, 0x31, 0x32, 0x33, 0x39, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x65, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x30, 0x38, 0x37, 0x35, 0x31, 0x38, 0x31, 0x36, 0x31, 0x31, 0x34, 0x36, 0x36, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x34, 0x30, 0x32, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x37, 0x66, 0x35, 0x37, 0x36, 0x31, 0x31, 0x34, 0x37, 0x63, 0x38, 0x37, 0x36, 0x31, 0x31, 0x37, 0x61, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x38, 0x31, 0x31, 0x31, 0x36, 0x31, 0x31, 0x35, 0x30, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x33, 0x38, 0x38, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x38, 0x30, 0x31, 0x35, 0x31, 0x39, 0x35, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x34, 0x61, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x39, 0x34, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x35, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x66, 0x30, 0x35, 0x37, 0x36, 0x31, 0x31, 0x34, 0x65, 0x39, 0x38, 0x36, 0x38, 0x35, 0x36, 0x31, 0x31, 0x32, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x66, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x34, 0x66, 0x61, 0x38, 0x34, 0x38, 0x37, 0x36, 0x31, 0x31, 0x32, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x37, 0x38, 0x32, 0x31, 0x34, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x35, 0x32, 0x36, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x34, 0x35, 0x31, 0x38, 0x31, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x36, 0x30, 0x63, 0x35, 0x37, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x31, 0x35, 0x36, 0x65, 0x38, 0x36, 0x38, 0x33, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x34, 0x31, 0x36, 0x31, 0x32, 0x35, 0x35, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x35, 0x38, 0x35, 0x38, 0x32, 0x38, 0x39, 0x36, 0x31, 0x32, 0x35, 0x65, 0x36, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x38, 0x66, 0x36, 0x31, 0x32, 0x39, 0x32, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x39, 0x39, 0x38, 0x61, 0x38, 0x33, 0x36, 0x31, 0x31, 0x36, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x61, 0x35, 0x38, 0x61, 0x38, 0x33, 0x36, 0x31, 0x31, 0x31, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x35, 0x64, 0x63, 0x35, 0x37, 0x35, 0x30, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x31, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x35, 0x66, 0x65, 0x35, 0x37, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x66, 0x62, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x37, 0x36, 0x31, 0x32, 0x33, 0x39, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x35, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x34, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x36, 0x32, 0x31, 0x36, 0x31, 0x32, 0x39, 0x32, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x36, 0x66, 0x31, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x36, 0x35, 0x35, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x37, 0x39, 0x35, 0x37, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x37, 0x32, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x36, 0x63, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x37, 0x35, 0x64, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x37, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x66, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x37, 0x38, 0x63, 0x34, 0x33, 0x36, 0x31, 0x31, 0x65, 0x61, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x37, 0x61, 0x34, 0x36, 0x31, 0x31, 0x37, 0x39, 0x65, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x38, 0x33, 0x36, 0x31, 0x31, 0x31, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x37, 0x63, 0x36, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x32, 0x39, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x37, 0x65, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x30, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x66, 0x66, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x38, 0x32, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x62, 0x34, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x38, 0x34, 0x61, 0x36, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x38, 0x33, 0x63, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x33, 0x39, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x64, 0x32, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x37, 0x33, 0x35, 0x39, 0x37, 0x33, 0x39, 0x31, 0x38, 0x32, 0x37, 0x35, 0x63, 0x30, 0x31, 0x66, 0x35, 0x30, 0x35, 0x35, 0x35, 0x64, 0x34, 0x34, 0x65, 0x39, 0x32, 0x63, 0x39, 0x64, 0x39, 0x62, 0x33, 0x35, 0x33, 0x63, 0x61, 0x64, 0x61, 0x64, 0x35, 0x34, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x38, 0x66, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x37, 0x33, 0x62, 0x38, 0x62, 0x62, 0x31, 0x35, 0x38, 0x62, 0x39, 0x33, 0x63, 0x39, 0x34, 0x65, 0x64, 0x33, 0x35, 0x63, 0x31, 0x39, 0x37, 0x30, 0x64, 0x36, 0x31, 0x30, 0x64, 0x31, 0x65, 0x32, 0x62, 0x33, 0x34, 0x65, 0x32, 0x36, 0x36, 0x35, 0x32, 0x63, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x39, 0x35, 0x33, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x37, 0x33, 0x66, 0x38, 0x34, 0x63, 0x37, 0x34, 0x64, 0x65, 0x61, 0x39, 0x36, 0x64, 0x66, 0x30, 0x65, 0x63, 0x32, 0x32, 0x65, 0x31, 0x31, 0x65, 0x37, 0x63, 0x33, 0x33, 0x39, 0x39, 0x36, 0x63, 0x37, 0x33, 0x66, 0x63, 0x63, 0x32, 0x64, 0x38, 0x32, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x39, 0x61, 0x66, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x37, 0x33, 0x62, 0x37, 0x30, 0x32, 0x66, 0x31, 0x63, 0x39, 0x31, 0x35, 0x34, 0x61, 0x63, 0x39, 0x63, 0x30, 0x38, 0x64, 0x61, 0x32, 0x34, 0x37, 0x61, 0x38, 0x65, 0x33, 0x30, 0x65, 0x65, 0x36, 0x66, 0x32, 0x66, 0x33, 0x33, 0x37, 0x33, 0x66, 0x34, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x61, 0x30, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x37, 0x33, 0x37, 0x66, 0x63, 0x64, 0x35, 0x38, 0x63, 0x32, 0x64, 0x35, 0x33, 0x64, 0x39, 0x38, 0x30, 0x62, 0x32, 0x34, 0x37, 0x66, 0x31, 0x36, 0x31, 0x32, 0x66, 0x64, 0x62, 0x61, 0x39, 0x33, 0x65, 0x39, 0x61, 0x37, 0x36, 0x31, 0x39, 0x33, 0x65, 0x36, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x61, 0x36, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x37, 0x33, 0x30, 0x33, 0x37, 0x35, 0x62, 0x32, 0x66, 0x63, 0x37, 0x31, 0x34, 0x30, 0x39, 0x37, 0x37, 0x63, 0x39, 0x63, 0x37, 0x36, 0x64, 0x34, 0x35, 0x34, 0x32, 0x31, 0x35, 0x36, 0x34, 0x65, 0x33, 0x35, 0x34, 0x65, 0x64, 0x34, 0x32, 0x32, 0x37, 0x37, 0x38, 0x31, 0x36, 0x30, 0x30, 0x35, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x61, 0x63, 0x33, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x37, 0x33, 0x34, 0x32, 0x65, 0x65, 0x66, 0x63, 0x64, 0x61, 0x30, 0x36, 0x65, 0x61, 0x64, 0x34, 0x37, 0x35, 0x63, 0x64, 0x65, 0x33, 0x37, 0x33, 0x31, 0x62, 0x38, 0x65, 0x62, 0x31, 0x33, 0x38, 0x65, 0x38, 0x38, 0x63, 0x64, 0x30, 0x62, 0x61, 0x63, 0x33, 0x38, 0x31, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x62, 0x31, 0x66, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x62, 0x38, 0x62, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x62, 0x39, 0x65, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x62, 0x62, 0x61, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x62, 0x64, 0x36, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x62, 0x66, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x30, 0x65, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x35, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x32, 0x61, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x31, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x34, 0x36, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x66, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x37, 0x63, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x63, 0x64, 0x61, 0x36, 0x31, 0x31, 0x63, 0x64, 0x34, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x38, 0x33, 0x36, 0x31, 0x30, 0x39, 0x33, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x63, 0x65, 0x64, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x31, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x62, 0x38, 0x32, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x64, 0x63, 0x62, 0x35, 0x37, 0x38, 0x33, 0x38, 0x32, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x31, 0x31, 0x64, 0x32, 0x66, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x32, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x65, 0x31, 0x65, 0x35, 0x37, 0x36, 0x31, 0x31, 0x65, 0x30, 0x66, 0x38, 0x33, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x64, 0x66, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x36, 0x31, 0x32, 0x33, 0x39, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x64, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x31, 0x65, 0x33, 0x35, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x32, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x65, 0x34, 0x65, 0x36, 0x31, 0x31, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x36, 0x31, 0x35, 0x37, 0x36, 0x31, 0x31, 0x65, 0x62, 0x65, 0x36, 0x31, 0x32, 0x39, 0x35, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x65, 0x64, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x32, 0x66, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x33, 0x66, 0x35, 0x37, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x34, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x35, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x66, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x65, 0x61, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x66, 0x39, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x33, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x30, 0x33, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x66, 0x38, 0x35, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x66, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x31, 0x31, 0x66, 0x61, 0x64, 0x34, 0x33, 0x36, 0x31, 0x30, 0x37, 0x35, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x39, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x66, 0x63, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x66, 0x66, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x34, 0x33, 0x38, 0x31, 0x36, 0x31, 0x32, 0x30, 0x34, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x31, 0x32, 0x30, 0x38, 0x36, 0x36, 0x31, 0x31, 0x38, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x39, 0x32, 0x35, 0x30, 0x38, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x66, 0x66, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x35, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x39, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x35, 0x35, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x33, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x32, 0x31, 0x32, 0x66, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x31, 0x36, 0x31, 0x32, 0x31, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x32, 0x37, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x32, 0x31, 0x38, 0x34, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x31, 0x61, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x31, 0x62, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x31, 0x66, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x31, 0x35, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x33, 0x39, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x38, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x32, 0x32, 0x61, 0x37, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x38, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x32, 0x63, 0x35, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x32, 0x64, 0x65, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x33, 0x31, 0x64, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x32, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x33, 0x62, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x33, 0x63, 0x33, 0x36, 0x31, 0x32, 0x39, 0x37, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x34, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x32, 0x33, 0x66, 0x34, 0x38, 0x32, 0x36, 0x31, 0x32, 0x36, 0x66, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x33, 0x66, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x34, 0x30, 0x38, 0x38, 0x33, 0x36, 0x31, 0x32, 0x37, 0x33, 0x65, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x34, 0x36, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x62, 0x36, 0x31, 0x32, 0x34, 0x33, 0x33, 0x36, 0x31, 0x32, 0x39, 0x39, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x38, 0x31, 0x36, 0x31, 0x32, 0x34, 0x32, 0x62, 0x35, 0x37, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x34, 0x35, 0x38, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x37, 0x61, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x34, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x62, 0x39, 0x35, 0x37, 0x36, 0x31, 0x32, 0x34, 0x37, 0x39, 0x38, 0x33, 0x36, 0x31, 0x32, 0x38, 0x33, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x34, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x32, 0x34, 0x39, 0x63, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x34, 0x36, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x32, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x34, 0x65, 0x30, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x32, 0x34, 0x65, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x34, 0x66, 0x38, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x37, 0x61, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x32, 0x62, 0x35, 0x37, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x32, 0x30, 0x34, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x35, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x32, 0x35, 0x34, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x35, 0x35, 0x33, 0x38, 0x32, 0x36, 0x31, 0x32, 0x34, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x36, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x31, 0x35, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x32, 0x35, 0x38, 0x39, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x31, 0x32, 0x35, 0x64, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x31, 0x66, 0x38, 0x34, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x30, 0x31, 0x38, 0x37, 0x38, 0x33, 0x31, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x38, 0x34, 0x38, 0x62, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x35, 0x62, 0x38, 0x31, 0x38, 0x33, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x35, 0x63, 0x37, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x33, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x35, 0x61, 0x61, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x36, 0x38, 0x35, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x33, 0x30, 0x31, 0x31, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x31, 0x38, 0x35, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x32, 0x36, 0x30, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x36, 0x65, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x66, 0x66, 0x36, 0x30, 0x34, 0x31, 0x38, 0x36, 0x30, 0x31, 0x35, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x36, 0x32, 0x63, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x36, 0x34, 0x34, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x31, 0x63, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x32, 0x36, 0x35, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x36, 0x65, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x37, 0x38, 0x33, 0x38, 0x36, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x31, 0x32, 0x36, 0x37, 0x61, 0x39, 0x34, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x33, 0x33, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x36, 0x39, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x30, 0x33, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x32, 0x36, 0x65, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x30, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x33, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x33, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x33, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x35, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x61, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x37, 0x36, 0x39, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x37, 0x61, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x61, 0x33, 0x35, 0x37, 0x36, 0x31, 0x32, 0x37, 0x39, 0x32, 0x38, 0x32, 0x36, 0x31, 0x32, 0x38, 0x33, 0x38, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x37, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x63, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x33, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x38, 0x30, 0x36, 0x31, 0x32, 0x37, 0x66, 0x34, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x37, 0x66, 0x33, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x35, 0x62, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x30, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x33, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x32, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x62, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x33, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x66, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x35, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x65, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x37, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x65, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x61, 0x36, 0x35, 0x37, 0x36, 0x30, 0x62, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x65, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x38, 0x63, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x32, 0x38, 0x65, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x38, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x38, 0x33, 0x35, 0x35, 0x38, 0x31, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x39, 0x31, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x33, 0x30, 0x32, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x32, 0x39, 0x31, 0x63, 0x39, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x39, 0x61, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x61, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x39, 0x66, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x35, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x35, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x39, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x33, 0x30, 0x31, 0x36, 0x31, 0x32, 0x39, 0x62, 0x34, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x61, 0x31, 0x33, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x61, 0x32, 0x38, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x39, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x61, 0x33, 0x64, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x39, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x31, 0x66, 0x38, 0x34, 0x30, 0x31, 0x31, 0x32, 0x36, 0x31, 0x32, 0x61, 0x35, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x61, 0x36, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x32, 0x38, 0x33, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x61, 0x38, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x31, 0x66, 0x38, 0x33, 0x30, 0x31, 0x31, 0x32, 0x36, 0x31, 0x32, 0x61, 0x39, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x33, 0x35, 0x36, 0x31, 0x32, 0x61, 0x62, 0x31, 0x36, 0x31, 0x32, 0x61, 0x61, 0x63, 0x38, 0x32, 0x36, 0x31, 0x33, 0x35, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x35, 0x61, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x38, 0x33, 0x38, 0x33, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x61, 0x63, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x61, 0x64, 0x38, 0x38, 0x33, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x33, 0x37, 0x32, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x35, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x61, 0x66, 0x30, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x62, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x30, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x31, 0x36, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x30, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x33, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x33, 0x66, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x35, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x36, 0x38, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x32, 0x65, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x38, 0x35, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x38, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x39, 0x32, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x62, 0x61, 0x33, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x36, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x63, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x62, 0x64, 0x30, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x62, 0x65, 0x31, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x34, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x62, 0x66, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x63, 0x30, 0x61, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x38, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x63, 0x32, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x63, 0x33, 0x34, 0x38, 0x34, 0x38, 0x32, 0x38, 0x35, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x38, 0x35, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x63, 0x35, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x63, 0x35, 0x65, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x63, 0x36, 0x66, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x30, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x36, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x63, 0x38, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x63, 0x39, 0x63, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x63, 0x61, 0x64, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x31, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x34, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x63, 0x63, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x63, 0x64, 0x36, 0x38, 0x36, 0x38, 0x32, 0x38, 0x37, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x38, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x38, 0x35, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x63, 0x66, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x64, 0x30, 0x31, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x64, 0x31, 0x32, 0x38, 0x35, 0x38, 0x32, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x61, 0x30, 0x38, 0x38, 0x38, 0x61, 0x30, 0x33, 0x31, 0x32, 0x31, 0x35, 0x36, 0x31, 0x32, 0x64, 0x33, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x64, 0x34, 0x35, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x37, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x31, 0x32, 0x64, 0x35, 0x36, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x36, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x36, 0x31, 0x32, 0x64, 0x36, 0x37, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x65, 0x31, 0x35, 0x36, 0x35, 0x62, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x38, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x64, 0x38, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x64, 0x39, 0x30, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x34, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x34, 0x35, 0x30, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x38, 0x38, 0x30, 0x31, 0x33, 0x35, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x32, 0x64, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x32, 0x64, 0x62, 0x62, 0x38, 0x61, 0x38, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x32, 0x61, 0x34, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x35, 0x39, 0x38, 0x39, 0x31, 0x39, 0x34, 0x39, 0x37, 0x35, 0x30, 0x39, 0x32, 0x39, 0x35, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x64, 0x64, 0x38, 0x38, 0x33, 0x38, 0x33, 0x36, 0x31, 0x32, 0x64, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x64, 0x66, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x31, 0x33, 0x32, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x65, 0x30, 0x35, 0x38, 0x31, 0x36, 0x31, 0x33, 0x36, 0x61, 0x32, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x65, 0x31, 0x34, 0x38, 0x31, 0x36, 0x31, 0x33, 0x36, 0x61, 0x32, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x65, 0x32, 0x35, 0x38, 0x32, 0x36, 0x31, 0x33, 0x36, 0x31, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x65, 0x32, 0x66, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x36, 0x35, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x32, 0x65, 0x33, 0x61, 0x38, 0x33, 0x36, 0x31, 0x33, 0x35, 0x66, 0x65, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x65, 0x36, 0x62, 0x35, 0x37, 0x38, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x65, 0x35, 0x32, 0x38, 0x38, 0x38, 0x32, 0x36, 0x31, 0x32, 0x64, 0x63, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x37, 0x35, 0x30, 0x36, 0x31, 0x32, 0x65, 0x35, 0x64, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x33, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x65, 0x33, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x35, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x65, 0x38, 0x33, 0x38, 0x32, 0x36, 0x31, 0x33, 0x36, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x65, 0x38, 0x64, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x36, 0x36, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x32, 0x65, 0x39, 0x38, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x30, 0x65, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x32, 0x65, 0x63, 0x39, 0x35, 0x37, 0x38, 0x31, 0x35, 0x31, 0x36, 0x31, 0x32, 0x65, 0x62, 0x30, 0x38, 0x38, 0x38, 0x32, 0x36, 0x31, 0x32, 0x64, 0x65, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x37, 0x35, 0x30, 0x36, 0x31, 0x32, 0x65, 0x62, 0x62, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x34, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x32, 0x65, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x35, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x65, 0x64, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x36, 0x62, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x65, 0x66, 0x36, 0x36, 0x31, 0x32, 0x65, 0x66, 0x31, 0x38, 0x32, 0x36, 0x31, 0x33, 0x36, 0x63, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x36, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x66, 0x30, 0x35, 0x38, 0x31, 0x36, 0x31, 0x33, 0x36, 0x65, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x66, 0x31, 0x63, 0x36, 0x31, 0x32, 0x66, 0x31, 0x37, 0x38, 0x32, 0x36, 0x31, 0x33, 0x36, 0x65, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x66, 0x32, 0x64, 0x38, 0x32, 0x36, 0x31, 0x33, 0x36, 0x33, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x32, 0x66, 0x33, 0x37, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x36, 0x37, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x33, 0x35, 0x30, 0x36, 0x31, 0x32, 0x66, 0x34, 0x37, 0x38, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x36, 0x30, 0x31, 0x36, 0x31, 0x33, 0x37, 0x33, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x66, 0x36, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x39, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x37, 0x36, 0x36, 0x66, 0x37, 0x34, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x32, 0x66, 0x61, 0x30, 0x36, 0x30, 0x32, 0x64, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x35, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x32, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x37, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x37, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x37, 0x34, 0x36, 0x38, 0x36, 0x31, 0x36, 0x65, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x32, 0x30, 0x36, 0x33, 0x37, 0x35, 0x37, 0x32, 0x37, 0x32, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x31, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x33, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x39, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x33, 0x31, 0x33, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x33, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x34, 0x36, 0x36, 0x30, 0x30, 0x66, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x31, 0x36, 0x65, 0x32, 0x30, 0x36, 0x39, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x38, 0x36, 0x36, 0x30, 0x31, 0x33, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x35, 0x33, 0x37, 0x30, 0x36, 0x31, 0x36, 0x65, 0x32, 0x30, 0x36, 0x31, 0x36, 0x63, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x36, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x36, 0x39, 0x37, 0x33, 0x37, 0x34, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x30, 0x63, 0x36, 0x36, 0x30, 0x34, 0x35, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x34, 0x36, 0x39, 0x36, 0x36, 0x36, 0x36, 0x36, 0x35, 0x37, 0x32, 0x36, 0x35, 0x36, 0x65, 0x36, 0x33, 0x36, 0x35, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x37, 0x36, 0x35, 0x36, 0x35, 0x36, 0x65, 0x32, 0x30, 0x37, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x32, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x37, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x36, 0x63, 0x37, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x63, 0x36, 0x35, 0x37, 0x33, 0x32, 0x30, 0x36, 0x66, 0x36, 0x36, 0x32, 0x30, 0x37, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x37, 0x30, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x63, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x39, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x36, 0x38, 0x36, 0x35, 0x36, 0x39, 0x36, 0x64, 0x36, 0x34, 0x36, 0x31, 0x36, 0x63, 0x36, 0x63, 0x32, 0x64, 0x33, 0x31, 0x33, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x63, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x31, 0x39, 0x32, 0x36, 0x30, 0x32, 0x61, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x35, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x37, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x37, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x37, 0x34, 0x36, 0x38, 0x36, 0x31, 0x36, 0x65, 0x32, 0x30, 0x37, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x37, 0x66, 0x37, 0x34, 0x36, 0x31, 0x37, 0x32, 0x37, 0x34, 0x32, 0x30, 0x36, 0x32, 0x36, 0x63, 0x36, 0x66, 0x36, 0x33, 0x36, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x31, 0x66, 0x38, 0x36, 0x30, 0x31, 0x32, 0x38, 0x33, 0x36, 0x31, 0x33, 0x36, 0x38, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x37, 0x66, 0x34, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x35, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x34, 0x31, 0x36, 0x34, 0x36, 0x34, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x33, 0x32, 0x34, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x33, 0x32, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x33, 0x32, 0x35, 0x34, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x33, 0x32, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x33, 0x32, 0x36, 0x37, 0x36, 0x30, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x38, 0x32, 0x36, 0x31, 0x32, 0x64, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x37, 0x36, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x38, 0x35, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x32, 0x39, 0x34, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x32, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x32, 0x61, 0x36, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x32, 0x65, 0x65, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x62, 0x36, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x32, 0x66, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x32, 0x64, 0x32, 0x38, 0x32, 0x38, 0x36, 0x36, 0x31, 0x32, 0x65, 0x65, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x65, 0x32, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x32, 0x66, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x33, 0x32, 0x66, 0x32, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x32, 0x66, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x33, 0x30, 0x66, 0x38, 0x32, 0x38, 0x34, 0x36, 0x31, 0x32, 0x66, 0x32, 0x32, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x33, 0x32, 0x35, 0x38, 0x32, 0x36, 0x31, 0x32, 0x66, 0x35, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x33, 0x33, 0x61, 0x38, 0x32, 0x36, 0x31, 0x32, 0x66, 0x66, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x33, 0x34, 0x66, 0x38, 0x32, 0x36, 0x31, 0x33, 0x31, 0x34, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x33, 0x36, 0x65, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x65, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x33, 0x38, 0x65, 0x38, 0x31, 0x38, 0x35, 0x36, 0x31, 0x32, 0x65, 0x31, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x33, 0x61, 0x32, 0x38, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x65, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x33, 0x63, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x65, 0x64, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x33, 0x64, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x65, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x33, 0x66, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x37, 0x36, 0x31, 0x32, 0x65, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x33, 0x32, 0x38, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x31, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x36, 0x31, 0x32, 0x65, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x34, 0x31, 0x64, 0x36, 0x30, 0x36, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x65, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x35, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x34, 0x33, 0x66, 0x38, 0x31, 0x36, 0x31, 0x32, 0x66, 0x39, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x34, 0x35, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x30, 0x33, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x34, 0x37, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x30, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x34, 0x39, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x30, 0x62, 0x39, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x34, 0x62, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x31, 0x38, 0x35, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x36, 0x31, 0x33, 0x34, 0x64, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x31, 0x65, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x34, 0x66, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x33, 0x32, 0x32, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x35, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x33, 0x32, 0x37, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x35, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x33, 0x32, 0x37, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x35, 0x33, 0x65, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x32, 0x37, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x35, 0x34, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x32, 0x65, 0x30, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x35, 0x36, 0x38, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x36, 0x31, 0x33, 0x32, 0x37, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x35, 0x37, 0x35, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x35, 0x36, 0x31, 0x33, 0x32, 0x37, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x35, 0x38, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x33, 0x32, 0x37, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x35, 0x39, 0x66, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x34, 0x36, 0x31, 0x33, 0x32, 0x38, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x38, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x32, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x33, 0x35, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x33, 0x35, 0x65, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x33, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x33, 0x36, 0x61, 0x64, 0x38, 0x32, 0x36, 0x31, 0x33, 0x36, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x35, 0x31, 0x35, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x32, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x66, 0x66, 0x38, 0x32, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x38, 0x31, 0x38, 0x33, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x33, 0x37, 0x35, 0x61, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x33, 0x37, 0x33, 0x66, 0x35, 0x36, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x33, 0x37, 0x36, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x38, 0x63, 0x38, 0x31, 0x36, 0x31, 0x33, 0x36, 0x61, 0x32, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x33, 0x37, 0x39, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x61, 0x33, 0x38, 0x31, 0x36, 0x31, 0x33, 0x36, 0x65, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x33, 0x37, 0x61, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x62, 0x61, 0x38, 0x31, 0x36, 0x31, 0x33, 0x37, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x33, 0x37, 0x63, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x33, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x36, 0x33, 0x38, 0x63, 0x37, 0x34, 0x62, 0x37, 0x33, 0x61, 0x61, 0x64, 0x64, 0x65, 0x62, 0x32, 0x66, 0x32, 0x66, 0x62, 0x39, 0x32, 0x36, 0x37, 0x30, 0x32, 0x38, 0x65, 0x30, 0x39, 0x37, 0x33, 0x37, 0x32, 0x39, 0x31, 0x34, 0x35, 0x38, 0x66, 0x36, 0x64, 0x61, 0x39, 0x33, 0x62, 0x36, 0x36, 0x31, 0x39, 0x64, 0x33, 0x30, 0x63, 0x38, 0x36, 0x34, 0x33, 0x32, 0x37, 0x30, 0x31, 0x64, 0x39, 0x36, 0x63, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, 0x64, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x36, 0x31, 0x36, 0x63, 0x66, 0x35, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x34, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x30, 0x34, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x34, 0x39, 0x34, 0x61, 0x31, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x34, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x65, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x34, 0x30, 0x37, 0x63, 0x61, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x32, 0x62, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x63, 0x37, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x35, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x38, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x39, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x62, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x34, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x65, 0x39, 0x36, 0x31, 0x30, 0x34, 0x37, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x33, 0x33, 0x36, 0x31, 0x30, 0x34, 0x39, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x30, 0x30, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x35, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x34, 0x31, 0x36, 0x34, 0x36, 0x34, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x32, 0x35, 0x32, 0x38, 0x35, 0x38, 0x35, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x39, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x38, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x32, 0x36, 0x62, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x61, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x66, 0x34, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x35, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x34, 0x39, 0x36, 0x34, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x37, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x37, 0x31, 0x37, 0x35, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x35, 0x34, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x33, 0x32, 0x34, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x33, 0x31, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x31, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x33, 0x34, 0x35, 0x38, 0x34, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x38, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x33, 0x37, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x35, 0x30, 0x38, 0x32, 0x36, 0x31, 0x30, 0x36, 0x63, 0x33, 0x35, 0x36, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x36, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x32, 0x34, 0x63, 0x34, 0x62, 0x34, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x61, 0x61, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x38, 0x66, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x64, 0x37, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x37, 0x66, 0x32, 0x36, 0x63, 0x35, 0x33, 0x62, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x62, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x35, 0x31, 0x37, 0x62, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x33, 0x38, 0x31, 0x38, 0x33, 0x31, 0x36, 0x31, 0x37, 0x38, 0x33, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x34, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x37, 0x66, 0x31, 0x39, 0x36, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x61, 0x30, 0x36, 0x31, 0x30, 0x39, 0x34, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x34, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x34, 0x64, 0x31, 0x38, 0x32, 0x36, 0x31, 0x30, 0x36, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x64, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x34, 0x65, 0x35, 0x38, 0x33, 0x36, 0x31, 0x30, 0x37, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x32, 0x33, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x35, 0x64, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x35, 0x30, 0x38, 0x35, 0x37, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x35, 0x33, 0x35, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x39, 0x62, 0x35, 0x36, 0x35, 0x62, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x34, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x39, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x35, 0x35, 0x36, 0x38, 0x33, 0x36, 0x31, 0x30, 0x38, 0x32, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x34, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x35, 0x37, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x34, 0x35, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x32, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x62, 0x64, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x63, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x35, 0x64, 0x35, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x39, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x30, 0x38, 0x35, 0x37, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x32, 0x30, 0x34, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x35, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x32, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x33, 0x30, 0x38, 0x32, 0x36, 0x31, 0x30, 0x35, 0x61, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x36, 0x31, 0x30, 0x36, 0x34, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x36, 0x35, 0x39, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x39, 0x62, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x39, 0x62, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x62, 0x37, 0x38, 0x34, 0x38, 0x37, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x30, 0x38, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x33, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x66, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x31, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x34, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x39, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x37, 0x35, 0x35, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x39, 0x62, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x38, 0x66, 0x35, 0x37, 0x36, 0x31, 0x30, 0x37, 0x37, 0x65, 0x38, 0x32, 0x36, 0x31, 0x30, 0x38, 0x32, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x62, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x37, 0x65, 0x30, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x64, 0x66, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x35, 0x62, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x65, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x62, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x66, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x34, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x64, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x36, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x39, 0x32, 0x35, 0x37, 0x36, 0x30, 0x62, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x64, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x63, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x38, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x65, 0x61, 0x35, 0x37, 0x36, 0x31, 0x30, 0x39, 0x33, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x31, 0x61, 0x35, 0x37, 0x38, 0x32, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x65, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x31, 0x39, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x31, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x32, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x38, 0x33, 0x66, 0x62, 0x64, 0x61, 0x63, 0x62, 0x37, 0x36, 0x66, 0x33, 0x32, 0x62, 0x34, 0x31, 0x31, 0x32, 0x64, 0x30, 0x66, 0x37, 0x64, 0x62, 0x39, 0x61, 0x35, 0x39, 0x36, 0x39, 0x33, 0x37, 0x39, 0x32, 0x35, 0x38, 0x32, 0x34, 0x37, 0x39, 0x38, 0x61, 0x30, 0x30, 0x32, 0x36, 0x62, 0x61, 0x30, 0x32, 0x33, 0x32, 0x33, 0x32, 0x32, 0x33, 0x39, 0x30, 0x62, 0x35, 0x32, 0x36, 0x33, 0x37, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x33, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x30, 0x34, 0x66, 0x63, 0x63, 0x65, 0x32, 0x63, 0x35, 0x61, 0x31, 0x34, 0x31, 0x66, 0x37, 0x66, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x64, 0x33, 0x32, 0x65, 0x39, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x65, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x63, 0x64, 0x30, 0x36, 0x63, 0x62, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x38, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x30, 0x36, 0x66, 0x37, 0x37, 0x39, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x36, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x30, 0x36, 0x66, 0x37, 0x37, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x37, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x36, 0x31, 0x34, 0x64, 0x30, 0x64, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x61, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x32, 0x66, 0x64, 0x65, 0x33, 0x38, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x64, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x63, 0x30, 0x63, 0x35, 0x34, 0x36, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x32, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x61, 0x63, 0x64, 0x30, 0x36, 0x63, 0x62, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x37, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x63, 0x64, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x63, 0x63, 0x37, 0x39, 0x66, 0x39, 0x37, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x35, 0x30, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x39, 0x30, 0x32, 0x35, 0x65, 0x36, 0x34, 0x63, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x63, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x30, 0x32, 0x35, 0x65, 0x36, 0x34, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x63, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x38, 0x35, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x63, 0x62, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x38, 0x65, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x62, 0x63, 0x65, 0x65, 0x62, 0x61, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x34, 0x66, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x64, 0x33, 0x32, 0x65, 0x39, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x33, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x38, 0x64, 0x61, 0x35, 0x63, 0x62, 0x35, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x34, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x38, 0x66, 0x33, 0x32, 0x64, 0x35, 0x39, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x39, 0x61, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x31, 0x39, 0x64, 0x34, 0x31, 0x61, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x33, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x31, 0x39, 0x64, 0x34, 0x31, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x33, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x38, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x31, 0x35, 0x30, 0x31, 0x38, 0x61, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x65, 0x66, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x31, 0x32, 0x38, 0x32, 0x66, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x30, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x31, 0x30, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x38, 0x35, 0x63, 0x63, 0x39, 0x35, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x36, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x66, 0x39, 0x36, 0x61, 0x38, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x64, 0x63, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x30, 0x36, 0x66, 0x64, 0x64, 0x65, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x61, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x34, 0x39, 0x39, 0x63, 0x35, 0x39, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x33, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x38, 0x31, 0x36, 0x30, 0x64, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x38, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x61, 0x64, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x31, 0x61, 0x37, 0x64, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x62, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x64, 0x66, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x61, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x62, 0x36, 0x36, 0x31, 0x30, 0x62, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x66, 0x36, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x32, 0x33, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x33, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x35, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x38, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x37, 0x36, 0x31, 0x30, 0x63, 0x32, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x62, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x36, 0x66, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x61, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x64, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x65, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x66, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x32, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x33, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x64, 0x64, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x63, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x65, 0x30, 0x36, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x65, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x66, 0x34, 0x36, 0x31, 0x30, 0x66, 0x35, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x31, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x36, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x33, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x66, 0x36, 0x31, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x64, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x38, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x31, 0x31, 0x64, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x65, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x66, 0x31, 0x36, 0x31, 0x31, 0x31, 0x65, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x33, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x34, 0x38, 0x36, 0x31, 0x31, 0x32, 0x31, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x39, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x64, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x61, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x33, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x66, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x30, 0x34, 0x36, 0x31, 0x31, 0x32, 0x35, 0x39, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x31, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x31, 0x62, 0x36, 0x31, 0x31, 0x33, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x33, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x30, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x35, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x37, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x38, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x32, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x34, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x35, 0x38, 0x36, 0x31, 0x31, 0x34, 0x62, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x61, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x61, 0x66, 0x36, 0x31, 0x31, 0x34, 0x64, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x64, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x64, 0x65, 0x36, 0x31, 0x31, 0x35, 0x33, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x31, 0x65, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x30, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x34, 0x62, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x36, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x36, 0x65, 0x36, 0x31, 0x31, 0x35, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x61, 0x65, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x39, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x64, 0x62, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x39, 0x33, 0x35, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x66, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x61, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x35, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x36, 0x34, 0x36, 0x31, 0x31, 0x35, 0x64, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x38, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x62, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x39, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x35, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x64, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x33, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x66, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x37, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x35, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x36, 0x35, 0x36, 0x31, 0x31, 0x36, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x38, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x39, 0x30, 0x36, 0x31, 0x31, 0x36, 0x61, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x62, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x62, 0x62, 0x36, 0x31, 0x31, 0x36, 0x61, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x64, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x66, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x37, 0x33, 0x35, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x32, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x33, 0x37, 0x36, 0x31, 0x31, 0x37, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x34, 0x64, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x33, 0x32, 0x30, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x34, 0x36, 0x39, 0x37, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x63, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x36, 0x36, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x61, 0x30, 0x61, 0x36, 0x34, 0x30, 0x32, 0x35, 0x34, 0x30, 0x62, 0x65, 0x34, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x31, 0x31, 0x36, 0x31, 0x30, 0x63, 0x34, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x34, 0x38, 0x30, 0x36, 0x31, 0x30, 0x63, 0x35, 0x37, 0x35, 0x37, 0x35, 0x30, 0x38, 0x32, 0x34, 0x33, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x63, 0x63, 0x39, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x35, 0x33, 0x36, 0x39, 0x36, 0x37, 0x36, 0x65, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x39, 0x37, 0x32, 0x36, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x63, 0x64, 0x37, 0x33, 0x33, 0x38, 0x37, 0x38, 0x37, 0x38, 0x37, 0x36, 0x31, 0x31, 0x36, 0x37, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x35, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x31, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x64, 0x37, 0x33, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x30, 0x66, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x35, 0x33, 0x36, 0x39, 0x36, 0x37, 0x32, 0x30, 0x36, 0x34, 0x36, 0x35, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x36, 0x39, 0x37, 0x36, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x31, 0x35, 0x31, 0x35, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x65, 0x64, 0x38, 0x31, 0x38, 0x39, 0x38, 0x39, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x32, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x64, 0x66, 0x61, 0x38, 0x32, 0x38, 0x34, 0x38, 0x38, 0x36, 0x31, 0x31, 0x37, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x39, 0x36, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x65, 0x31, 0x36, 0x38, 0x32, 0x36, 0x31, 0x31, 0x32, 0x33, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x65, 0x32, 0x64, 0x38, 0x33, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x36, 0x31, 0x31, 0x62, 0x33, 0x35, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x34, 0x32, 0x35, 0x37, 0x35, 0x30, 0x38, 0x32, 0x33, 0x34, 0x31, 0x34, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x62, 0x34, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x39, 0x36, 0x65, 0x37, 0x33, 0x37, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x62, 0x66, 0x66, 0x32, 0x36, 0x30, 0x32, 0x62, 0x33, 0x66, 0x34, 0x36, 0x38, 0x32, 0x35, 0x39, 0x65, 0x31, 0x65, 0x39, 0x39, 0x66, 0x36, 0x31, 0x33, 0x66, 0x65, 0x64, 0x36, 0x36, 0x39, 0x31, 0x66, 0x33, 0x61, 0x36, 0x35, 0x32, 0x36, 0x65, 0x66, 0x66, 0x65, 0x36, 0x65, 0x66, 0x33, 0x65, 0x37, 0x36, 0x38, 0x62, 0x61, 0x37, 0x61, 0x65, 0x37, 0x61, 0x33, 0x36, 0x63, 0x34, 0x66, 0x38, 0x35, 0x38, 0x34, 0x36, 0x31, 0x30, 0x66, 0x33, 0x30, 0x38, 0x37, 0x36, 0x31, 0x31, 0x32, 0x33, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x66, 0x36, 0x39, 0x36, 0x31, 0x31, 0x34, 0x64, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x66, 0x37, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x61, 0x66, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x31, 0x30, 0x30, 0x34, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x66, 0x30, 0x33, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x66, 0x38, 0x33, 0x36, 0x31, 0x31, 0x32, 0x33, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x34, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x35, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x31, 0x30, 0x37, 0x32, 0x38, 0x33, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x36, 0x31, 0x31, 0x62, 0x35, 0x35, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x34, 0x65, 0x32, 0x63, 0x61, 0x30, 0x35, 0x31, 0x35, 0x65, 0x64, 0x31, 0x61, 0x65, 0x66, 0x31, 0x33, 0x39, 0x35, 0x66, 0x36, 0x36, 0x62, 0x35, 0x33, 0x30, 0x33, 0x62, 0x62, 0x35, 0x64, 0x36, 0x66, 0x31, 0x62, 0x66, 0x39, 0x64, 0x36, 0x31, 0x61, 0x33, 0x35, 0x33, 0x66, 0x61, 0x35, 0x33, 0x66, 0x37, 0x33, 0x66, 0x38, 0x61, 0x63, 0x39, 0x39, 0x37, 0x33, 0x66, 0x61, 0x39, 0x66, 0x36, 0x38, 0x35, 0x38, 0x35, 0x36, 0x31, 0x31, 0x30, 0x66, 0x34, 0x38, 0x39, 0x36, 0x31, 0x31, 0x32, 0x33, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x38, 0x33, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x65, 0x65, 0x30, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x31, 0x35, 0x31, 0x35, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x31, 0x31, 0x31, 0x65, 0x38, 0x38, 0x32, 0x36, 0x31, 0x31, 0x62, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x36, 0x31, 0x36, 0x31, 0x31, 0x34, 0x64, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x32, 0x36, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x31, 0x38, 0x35, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x31, 0x33, 0x34, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x61, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x66, 0x66, 0x36, 0x30, 0x34, 0x31, 0x38, 0x36, 0x30, 0x31, 0x35, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x37, 0x35, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x38, 0x64, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x31, 0x63, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x39, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x61, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x36, 0x38, 0x32, 0x38, 0x35, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x66, 0x62, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x30, 0x33, 0x35, 0x31, 0x39, 0x33, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x61, 0x61, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x35, 0x37, 0x32, 0x37, 0x32, 0x36, 0x66, 0x37, 0x32, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x36, 0x35, 0x36, 0x33, 0x37, 0x32, 0x36, 0x35, 0x36, 0x33, 0x36, 0x66, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x34, 0x64, 0x34, 0x31, 0x35, 0x34, 0x34, 0x39, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x34, 0x31, 0x34, 0x36, 0x31, 0x31, 0x35, 0x62, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x63, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x63, 0x37, 0x33, 0x33, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x31, 0x37, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x66, 0x37, 0x38, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x36, 0x31, 0x66, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x36, 0x39, 0x33, 0x36, 0x31, 0x31, 0x36, 0x38, 0x65, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x31, 0x63, 0x36, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x64, 0x34, 0x32, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x38, 0x39, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x66, 0x32, 0x36, 0x36, 0x30, 0x35, 0x32, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x36, 0x66, 0x37, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x36, 0x64, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x33, 0x64, 0x36, 0x31, 0x31, 0x34, 0x64, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x34, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x31, 0x37, 0x34, 0x66, 0x38, 0x31, 0x36, 0x31, 0x31, 0x62, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x66, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x30, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x32, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x62, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x63, 0x38, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x64, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x38, 0x66, 0x63, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x31, 0x64, 0x38, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x36, 0x34, 0x39, 0x37, 0x65, 0x33, 0x65, 0x65, 0x35, 0x34, 0x38, 0x61, 0x33, 0x33, 0x37, 0x32, 0x31, 0x33, 0x36, 0x61, 0x66, 0x32, 0x66, 0x63, 0x62, 0x30, 0x36, 0x39, 0x36, 0x64, 0x62, 0x33, 0x31, 0x66, 0x63, 0x36, 0x63, 0x66, 0x32, 0x30, 0x32, 0x36, 0x30, 0x37, 0x30, 0x37, 0x36, 0x34, 0x35, 0x30, 0x36, 0x38, 0x62, 0x64, 0x33, 0x66, 0x65, 0x39, 0x37, 0x66, 0x33, 0x63, 0x34, 0x38, 0x37, 0x38, 0x36, 0x38, 0x36, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x65, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x30, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x31, 0x38, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x32, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x65, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x62, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x64, 0x30, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x65, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x34, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x62, 0x34, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x62, 0x36, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x62, 0x61, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x66, 0x37, 0x38, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x63, 0x62, 0x65, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x63, 0x39, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x37, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x34, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x61, 0x30, 0x38, 0x31, 0x32, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x31, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x36, 0x30, 0x32, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x32, 0x38, 0x31, 0x32, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x65, 0x32, 0x65, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x36, 0x33, 0x36, 0x31, 0x36, 0x65, 0x32, 0x37, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x64, 0x35, 0x32, 0x34, 0x33, 0x33, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x32, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x65, 0x37, 0x34, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x66, 0x65, 0x35, 0x34, 0x36, 0x38, 0x36, 0x35, 0x32, 0x30, 0x36, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x36, 0x63, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x36, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x36, 0x39, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x37, 0x61, 0x36, 0x35, 0x36, 0x34, 0x34, 0x39, 0x36, 0x65, 0x37, 0x33, 0x37, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x66, 0x37, 0x32, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x35, 0x37, 0x33, 0x36, 0x35, 0x37, 0x32, 0x34, 0x35, 0x34, 0x39, 0x35, 0x30, 0x33, 0x37, 0x33, 0x31, 0x33, 0x32, 0x34, 0x34, 0x36, 0x66, 0x36, 0x64, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x32, 0x38, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x36, 0x65, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x32, 0x63, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x37, 0x33, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x33, 0x36, 0x38, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x32, 0x63, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, 0x36, 0x37, 0x39, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x39, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x35, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x65, 0x37, 0x33, 0x36, 0x36, 0x36, 0x35, 0x37, 0x32, 0x34, 0x66, 0x37, 0x32, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x38, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x34, 0x66, 0x37, 0x32, 0x34, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x63, 0x36, 0x32, 0x37, 0x39, 0x37, 0x34, 0x36, 0x35, 0x37, 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x30, 0x36, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x31, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x39, 0x37, 0x32, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x39, 0x61, 0x32, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x39, 0x38, 0x32, 0x34, 0x37, 0x65, 0x63, 0x33, 0x63, 0x38, 0x64, 0x31, 0x32, 0x37, 0x65, 0x62, 0x66, 0x39, 0x36, 0x39, 0x63, 0x38, 0x66, 0x33, 0x31, 0x37, 0x65, 0x33, 0x34, 0x30, 0x62, 0x31, 0x63, 0x64, 0x36, 0x63, 0x34, 0x38, 0x31, 0x61, 0x66, 0x30, 0x37, 0x37, 0x32, 0x33, 0x34, 0x63, 0x33, 0x38, 0x65, 0x30, 0x63, 0x37, 0x64, 0x39, 0x32, 0x61, 0x62, 0x61, 0x34, 0x64, 0x36, 0x33, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x33, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x37, 0x33, 0x39, 0x31, 0x38, 0x32, 0x37, 0x35, 0x43, 0x30, 0x31, 0x46, 0x35, 0x30, 0x35, 0x35, 0x35, 0x64, 0x34, 0x34, 0x65, 0x39, 0x32, 0x63, 0x39, 0x64, 0x39, 0x62, 0x33, 0x35, 0x33, 0x43, 0x61, 0x44, 0x41, 0x44, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x62, 0x42, 0x31, 0x35, 0x38, 0x42, 0x39, 0x33, 0x63, 0x39, 0x34, 0x65, 0x64, 0x33, 0x35, 0x63, 0x31, 0x39, 0x37, 0x30, 0x44, 0x36, 0x31, 0x30, 0x64, 0x31, 0x45, 0x32, 0x42, 0x33, 0x34, 0x45, 0x32, 0x36, 0x36, 0x35, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x46, 0x38, 0x34, 0x43, 0x37, 0x34, 0x64, 0x45, 0x61, 0x39, 0x36, 0x44, 0x46, 0x30, 0x45, 0x43, 0x32, 0x32, 0x65, 0x31, 0x31, 0x65, 0x37, 0x43, 0x33, 0x33, 0x39, 0x39, 0x36, 0x43, 0x37, 0x33, 0x46, 0x43, 0x43, 0x32, 0x44, 0x38, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x30, 0x32, 0x66, 0x31, 0x43, 0x39, 0x31, 0x35, 0x34, 0x61, 0x63, 0x39, 0x63, 0x30, 0x38, 0x44, 0x61, 0x32, 0x34, 0x37, 0x61, 0x38, 0x65, 0x33, 0x30, 0x65, 0x65, 0x36, 0x46, 0x32, 0x46, 0x33, 0x33, 0x37, 0x33, 0x66, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x43, 0x44, 0x35, 0x38, 0x43, 0x32, 0x44, 0x35, 0x33, 0x44, 0x39, 0x38, 0x30, 0x62, 0x32, 0x34, 0x37, 0x46, 0x31, 0x36, 0x31, 0x32, 0x46, 0x64, 0x62, 0x41, 0x39, 0x33, 0x45, 0x39, 0x61, 0x37, 0x36, 0x31, 0x39, 0x33, 0x45, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x37, 0x35, 0x62, 0x32, 0x66, 0x63, 0x37, 0x31, 0x34, 0x30, 0x39, 0x37, 0x37, 0x63, 0x39, 0x63, 0x37, 0x36, 0x44, 0x34, 0x35, 0x34, 0x32, 0x31, 0x35, 0x36, 0x34, 0x65, 0x33, 0x35, 0x34, 0x45, 0x44, 0x34, 0x32, 0x32, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x45, 0x45, 0x66, 0x63, 0x64, 0x61, 0x30, 0x36, 0x65, 0x61, 0x44, 0x34, 0x37, 0x35, 0x63, 0x64, 0x45, 0x33, 0x37, 0x33, 0x31, 0x42, 0x38, 0x65, 0x62, 0x31, 0x33, 0x38, 0x65, 0x38, 0x38, 0x43, 0x44, 0x30, 0x62, 0x41, 0x43, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x36, 0x33, 0x35, 0x63, 0x39, 0x61, 0x64, 0x63, 0x35, 0x64, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x31, 0x33, 0x37, 0x2c, 0x22, 0x68, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x30, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x35, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x62, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x70, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62, 0x75, 0x72, 0x67, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x33, 0x33, 0x39, 0x35, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x6d, 0x75, 0x69, 0x72, 0x47, 0x6c, 0x61, 0x63, 0x69, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x33, 0x33, 0x39, 0x35, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x62, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x6c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x32, 0x33, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x62, 0x75, 0x72, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x32, 0x33, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x30, 0x62, 0x63, 0x61, 0x35, 0x37, 0x66, 0x34, 0x35, 0x37, 0x39, 0x66, 0x35, 0x38, 0x36, 0x37, 0x30, 0x61, 0x62, 0x32, 0x64, 0x31, 0x38, 0x65, 0x66, 0x31, 0x36, 0x65, 0x30, 0x32, 0x63, 0x31, 0x37, 0x35, 0x35, 0x33, 0x63, 0x33, 0x38, 0x22, 0x2c, 0x22, 0x35, 0x30, 0x35, 0x32, 0x33, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x41, 0x38, 0x65, 0x64, 0x32, 0x37, 0x46, 0x34, 0x43, 0x33, 0x30, 0x35, 0x31, 0x32, 0x33, 0x32, 0x36, 0x38, 0x37, 0x38, 0x36, 0x35, 0x32, 0x64, 0x32, 0x30, 0x66, 0x43, 0x38, 0x35, 0x37, 0x32, 0x37, 0x34, 0x30, 0x31, 0x38, 0x35, 0x34, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x20, 0x32, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x36, 0x2c, 0x22, 0x33, 0x38, 0x31, 0x38, 0x39, 0x30, 0x35, 0x36, 0x22, 0x3a, 0x20, 0x34, 0x7d, 0x2c, 0x22, 0x73, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x36, 0x34, 0x2c, 0x22, 0x33, 0x38, 0x31, 0x38, 0x39, 0x30, 0x35, 0x36, 0x22, 0x3a, 0x20, 0x31, 0x36, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x22, 0x3a, 0x20, 0x32, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x34, 0x34, 0x39, 0x33, 0x34, 0x36, 0x35, 0x36, 0x22, 0x3a, 0x20, 0x31, 0x32, 0x38, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x22, 0x2c, 0x22, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x31, 0x34, 0x39, 0x34, 0x39, 0x31, 0x32, 0x30, 0x22, 0x3a, 0x38, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x34, 0x39, 0x31, 0x38, 0x34, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x35, 0x33, 0x34, 0x37, 0x32, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x35, 0x33, 0x35, 0x33, 0x36, 0x22, 0x3a, 0x35, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x35, 0x33, 0x36, 0x30, 0x30, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x35, 0x33, 0x36, 0x36, 0x34, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x35, 0x33, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x35, 0x33, 0x37, 0x39, 0x32, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x35, 0x33, 0x38, 0x35, 0x36, 0x22, 0x3a, 0x20, 0x30, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x32, 0x32, 0x31, 0x35, 0x36, 0x36, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x64, 0x33, 0x32, 0x65, 0x39, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x65, 0x63, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x63, 0x64, 0x30, 0x36, 0x63, 0x62, 0x33, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x38, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x30, 0x36, 0x66, 0x37, 0x37, 0x39, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x36, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x33, 0x30, 0x36, 0x66, 0x37, 0x37, 0x39, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x37, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x65, 0x36, 0x31, 0x34, 0x64, 0x30, 0x64, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x61, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x32, 0x66, 0x64, 0x65, 0x33, 0x38, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x64, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x66, 0x63, 0x30, 0x63, 0x35, 0x34, 0x36, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x62, 0x32, 0x32, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x61, 0x63, 0x64, 0x30, 0x36, 0x63, 0x62, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x37, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x63, 0x64, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x63, 0x63, 0x37, 0x39, 0x66, 0x39, 0x37, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x61, 0x35, 0x30, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x39, 0x30, 0x32, 0x35, 0x65, 0x36, 0x34, 0x63, 0x31, 0x31, 0x36, 0x31, 0x30, 0x30, 0x63, 0x36, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x30, 0x32, 0x35, 0x65, 0x36, 0x34, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x63, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x64, 0x38, 0x39, 0x62, 0x34, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x38, 0x35, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x63, 0x62, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x38, 0x65, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x61, 0x62, 0x63, 0x65, 0x65, 0x62, 0x61, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x39, 0x34, 0x66, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x64, 0x33, 0x32, 0x65, 0x39, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x33, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x38, 0x64, 0x61, 0x35, 0x63, 0x62, 0x35, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x34, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x38, 0x66, 0x33, 0x32, 0x64, 0x35, 0x39, 0x62, 0x31, 0x34, 0x36, 0x31, 0x30, 0x37, 0x39, 0x61, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x39, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x31, 0x39, 0x64, 0x34, 0x31, 0x61, 0x31, 0x31, 0x36, 0x31, 0x30, 0x31, 0x33, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x31, 0x39, 0x64, 0x34, 0x31, 0x61, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x33, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x38, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x31, 0x35, 0x30, 0x31, 0x38, 0x61, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x35, 0x65, 0x66, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x37, 0x37, 0x31, 0x32, 0x38, 0x32, 0x66, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x30, 0x36, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x31, 0x30, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x38, 0x35, 0x63, 0x63, 0x39, 0x35, 0x35, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x36, 0x62, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x66, 0x39, 0x36, 0x61, 0x38, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x64, 0x63, 0x35, 0x37, 0x36, 0x31, 0x30, 0x31, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x38, 0x30, 0x36, 0x33, 0x30, 0x36, 0x66, 0x64, 0x64, 0x65, 0x30, 0x33, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x61, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x34, 0x39, 0x39, 0x63, 0x35, 0x39, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x33, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x38, 0x31, 0x36, 0x30, 0x64, 0x64, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x38, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x61, 0x64, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x65, 0x31, 0x61, 0x37, 0x64, 0x34, 0x64, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x62, 0x31, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x64, 0x66, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x61, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x62, 0x36, 0x36, 0x31, 0x30, 0x62, 0x37, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x66, 0x36, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x64, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x32, 0x33, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x33, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x35, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x38, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x37, 0x36, 0x31, 0x30, 0x63, 0x32, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x62, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x36, 0x66, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x61, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x64, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x65, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x66, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x32, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x33, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x33, 0x64, 0x64, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x63, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x61, 0x61, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x65, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x66, 0x34, 0x36, 0x31, 0x30, 0x64, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x31, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x36, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x33, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x65, 0x30, 0x35, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x64, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x38, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x66, 0x63, 0x31, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x65, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x66, 0x31, 0x36, 0x31, 0x31, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x33, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x34, 0x38, 0x36, 0x31, 0x31, 0x30, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x39, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x64, 0x39, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x61, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x30, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x66, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x30, 0x34, 0x36, 0x31, 0x31, 0x30, 0x66, 0x64, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x31, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x36, 0x31, 0x62, 0x36, 0x31, 0x31, 0x31, 0x63, 0x64, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x33, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x30, 0x31, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x35, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x37, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x38, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x61, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x31, 0x64, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x34, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x35, 0x38, 0x36, 0x31, 0x31, 0x33, 0x35, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x61, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x61, 0x66, 0x36, 0x31, 0x31, 0x33, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x64, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x64, 0x65, 0x36, 0x31, 0x31, 0x33, 0x64, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x31, 0x65, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x30, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x34, 0x62, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x36, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x36, 0x65, 0x36, 0x31, 0x31, 0x34, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x61, 0x65, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x39, 0x33, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x64, 0x62, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x39, 0x33, 0x35, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x66, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x34, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x35, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x36, 0x34, 0x36, 0x31, 0x31, 0x34, 0x37, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x38, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x62, 0x33, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x39, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x30, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x64, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x33, 0x61, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x66, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x32, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x35, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x36, 0x35, 0x36, 0x31, 0x31, 0x35, 0x34, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x38, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x39, 0x30, 0x36, 0x31, 0x31, 0x35, 0x34, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x62, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x61, 0x62, 0x62, 0x36, 0x31, 0x31, 0x35, 0x34, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x64, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x32, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x66, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x64, 0x39, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x32, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x62, 0x33, 0x37, 0x36, 0x31, 0x31, 0x35, 0x66, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x34, 0x64, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x33, 0x32, 0x30, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x34, 0x36, 0x39, 0x37, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x63, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x36, 0x36, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x61, 0x30, 0x61, 0x36, 0x34, 0x30, 0x32, 0x35, 0x34, 0x30, 0x62, 0x65, 0x34, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x34, 0x36, 0x39, 0x37, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x63, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x36, 0x36, 0x36, 0x35, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x33, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x63, 0x62, 0x61, 0x38, 0x32, 0x36, 0x31, 0x31, 0x30, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x63, 0x64, 0x31, 0x38, 0x33, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x36, 0x31, 0x31, 0x36, 0x31, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x65, 0x36, 0x35, 0x37, 0x35, 0x30, 0x38, 0x32, 0x33, 0x34, 0x31, 0x34, 0x35, 0x62, 0x36, 0x31, 0x30, 0x64, 0x35, 0x38, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x39, 0x36, 0x65, 0x37, 0x33, 0x37, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x62, 0x66, 0x66, 0x32, 0x36, 0x30, 0x32, 0x62, 0x33, 0x66, 0x34, 0x36, 0x38, 0x32, 0x35, 0x39, 0x65, 0x31, 0x65, 0x39, 0x39, 0x66, 0x36, 0x31, 0x33, 0x66, 0x65, 0x64, 0x36, 0x36, 0x39, 0x31, 0x66, 0x33, 0x61, 0x36, 0x35, 0x32, 0x36, 0x65, 0x66, 0x66, 0x65, 0x36, 0x65, 0x66, 0x33, 0x65, 0x37, 0x36, 0x38, 0x62, 0x61, 0x37, 0x61, 0x65, 0x37, 0x61, 0x33, 0x36, 0x63, 0x34, 0x66, 0x38, 0x35, 0x38, 0x34, 0x36, 0x31, 0x30, 0x64, 0x64, 0x34, 0x38, 0x37, 0x36, 0x31, 0x31, 0x30, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x30, 0x64, 0x36, 0x31, 0x31, 0x33, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x31, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x35, 0x33, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x65, 0x61, 0x38, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x64, 0x61, 0x37, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x65, 0x62, 0x33, 0x38, 0x33, 0x36, 0x31, 0x31, 0x30, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x34, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x30, 0x30, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x66, 0x31, 0x36, 0x38, 0x33, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x36, 0x31, 0x31, 0x36, 0x33, 0x63, 0x39, 0x30, 0x39, 0x31, 0x39, 0x30, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x34, 0x65, 0x32, 0x63, 0x61, 0x30, 0x35, 0x31, 0x35, 0x65, 0x64, 0x31, 0x61, 0x65, 0x66, 0x31, 0x33, 0x39, 0x35, 0x66, 0x36, 0x36, 0x62, 0x35, 0x33, 0x30, 0x33, 0x62, 0x62, 0x35, 0x64, 0x36, 0x66, 0x31, 0x62, 0x66, 0x39, 0x64, 0x36, 0x31, 0x61, 0x33, 0x35, 0x33, 0x66, 0x61, 0x35, 0x33, 0x66, 0x37, 0x33, 0x66, 0x38, 0x61, 0x63, 0x39, 0x39, 0x37, 0x33, 0x66, 0x61, 0x39, 0x66, 0x36, 0x38, 0x35, 0x38, 0x35, 0x36, 0x31, 0x30, 0x66, 0x39, 0x38, 0x38, 0x39, 0x36, 0x31, 0x31, 0x30, 0x64, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x32, 0x37, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x64, 0x38, 0x34, 0x36, 0x30, 0x32, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x31, 0x35, 0x31, 0x35, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x31, 0x31, 0x30, 0x38, 0x63, 0x38, 0x32, 0x36, 0x31, 0x31, 0x36, 0x35, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x31, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x31, 0x30, 0x35, 0x36, 0x31, 0x31, 0x33, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x31, 0x30, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x31, 0x38, 0x35, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x31, 0x31, 0x65, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x35, 0x30, 0x31, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x66, 0x66, 0x36, 0x30, 0x34, 0x31, 0x38, 0x36, 0x30, 0x31, 0x35, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x31, 0x39, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x33, 0x31, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x31, 0x63, 0x38, 0x31, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x34, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x33, 0x35, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x36, 0x38, 0x32, 0x38, 0x35, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x39, 0x66, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x30, 0x33, 0x35, 0x31, 0x39, 0x33, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x33, 0x34, 0x65, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x35, 0x37, 0x32, 0x37, 0x32, 0x36, 0x66, 0x37, 0x32, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x36, 0x35, 0x36, 0x33, 0x37, 0x32, 0x36, 0x35, 0x36, 0x33, 0x36, 0x66, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x37, 0x66, 0x34, 0x64, 0x34, 0x31, 0x35, 0x34, 0x34, 0x39, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x34, 0x31, 0x34, 0x36, 0x31, 0x31, 0x34, 0x36, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x36, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x34, 0x36, 0x62, 0x33, 0x33, 0x38, 0x34, 0x38, 0x34, 0x36, 0x31, 0x31, 0x37, 0x35, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x65, 0x31, 0x63, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x34, 0x63, 0x33, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x34, 0x61, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x35, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x35, 0x33, 0x37, 0x36, 0x31, 0x31, 0x35, 0x33, 0x32, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x31, 0x62, 0x31, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x62, 0x65, 0x36, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x38, 0x39, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x64, 0x63, 0x61, 0x36, 0x30, 0x35, 0x32, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x35, 0x39, 0x62, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x35, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x65, 0x31, 0x36, 0x31, 0x31, 0x33, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x65, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x31, 0x35, 0x66, 0x33, 0x38, 0x31, 0x36, 0x31, 0x31, 0x36, 0x35, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x36, 0x32, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x36, 0x35, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x36, 0x39, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x30, 0x37, 0x39, 0x63, 0x35, 0x33, 0x31, 0x36, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x34, 0x34, 0x63, 0x64, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x66, 0x32, 0x38, 0x34, 0x31, 0x39, 0x34, 0x39, 0x37, 0x66, 0x39, 0x37, 0x32, 0x32, 0x61, 0x33, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x36, 0x66, 0x36, 0x62, 0x36, 0x34, 0x35, 0x37, 0x65, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x32, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x64, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x65, 0x37, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x66, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x36, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x38, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x61, 0x33, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x38, 0x62, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x31, 0x38, 0x64, 0x37, 0x38, 0x36, 0x38, 0x36, 0x38, 0x36, 0x36, 0x31, 0x31, 0x63, 0x33, 0x30, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x34, 0x39, 0x30, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x39, 0x30, 0x30, 0x34, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x65, 0x36, 0x34, 0x39, 0x37, 0x65, 0x33, 0x65, 0x65, 0x35, 0x34, 0x38, 0x61, 0x33, 0x33, 0x37, 0x32, 0x31, 0x33, 0x36, 0x61, 0x66, 0x32, 0x66, 0x63, 0x62, 0x30, 0x36, 0x39, 0x36, 0x64, 0x62, 0x33, 0x31, 0x66, 0x63, 0x36, 0x63, 0x66, 0x32, 0x30, 0x32, 0x36, 0x30, 0x37, 0x30, 0x37, 0x36, 0x34, 0x35, 0x30, 0x36, 0x38, 0x62, 0x64, 0x33, 0x66, 0x65, 0x39, 0x37, 0x66, 0x33, 0x63, 0x34, 0x38, 0x37, 0x38, 0x36, 0x38, 0x36, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x65, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x39, 0x64, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x39, 0x66, 0x33, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x30, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x33, 0x37, 0x30, 0x61, 0x30, 0x38, 0x32, 0x33, 0x31, 0x38, 0x65, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x30, 0x65, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x33, 0x62, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x39, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x61, 0x62, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x61, 0x63, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x34, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x65, 0x31, 0x63, 0x36, 0x30, 0x35, 0x62, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x62, 0x36, 0x32, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x62, 0x33, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x32, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x37, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x34, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x61, 0x30, 0x38, 0x31, 0x32, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x34, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x31, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x38, 0x31, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x36, 0x30, 0x32, 0x32, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x32, 0x38, 0x31, 0x32, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x33, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x63, 0x64, 0x32, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x36, 0x33, 0x36, 0x31, 0x36, 0x65, 0x32, 0x37, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x64, 0x35, 0x32, 0x34, 0x33, 0x33, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x36, 0x31, 0x30, 0x38, 0x66, 0x63, 0x38, 0x32, 0x39, 0x30, 0x38, 0x31, 0x31, 0x35, 0x30, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x38, 0x38, 0x38, 0x38, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x64, 0x31, 0x38, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x38, 0x31, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x66, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x66, 0x65, 0x35, 0x34, 0x36, 0x38, 0x36, 0x35, 0x32, 0x30, 0x36, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x36, 0x63, 0x37, 0x32, 0x36, 0x35, 0x36, 0x31, 0x36, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x36, 0x39, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x37, 0x61, 0x36, 0x35, 0x36, 0x34, 0x34, 0x39, 0x36, 0x65, 0x37, 0x33, 0x37, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x30, 0x36, 0x66, 0x37, 0x32, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x35, 0x37, 0x33, 0x36, 0x35, 0x37, 0x32, 0x34, 0x35, 0x34, 0x39, 0x35, 0x30, 0x33, 0x37, 0x33, 0x31, 0x33, 0x32, 0x34, 0x34, 0x36, 0x66, 0x36, 0x64, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x32, 0x38, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x36, 0x65, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x32, 0x63, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x37, 0x33, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x33, 0x36, 0x38, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x32, 0x63, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x36, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, 0x36, 0x37, 0x39, 0x36, 0x39, 0x36, 0x65, 0x36, 0x37, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x39, 0x35, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x35, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x65, 0x37, 0x33, 0x36, 0x36, 0x36, 0x35, 0x37, 0x32, 0x34, 0x66, 0x37, 0x32, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x38, 0x36, 0x31, 0x36, 0x34, 0x36, 0x34, 0x37, 0x32, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x37, 0x33, 0x37, 0x30, 0x36, 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x62, 0x36, 0x35, 0x36, 0x65, 0x34, 0x39, 0x36, 0x34, 0x34, 0x66, 0x37, 0x32, 0x34, 0x31, 0x36, 0x64, 0x36, 0x66, 0x37, 0x35, 0x36, 0x65, 0x37, 0x34, 0x32, 0x63, 0x36, 0x32, 0x37, 0x39, 0x37, 0x34, 0x36, 0x35, 0x37, 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x30, 0x36, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x31, 0x32, 0x63, 0x37, 0x35, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x32, 0x30, 0x36, 0x35, 0x37, 0x38, 0x37, 0x30, 0x36, 0x39, 0x37, 0x32, 0x36, 0x31, 0x37, 0x34, 0x36, 0x39, 0x36, 0x66, 0x36, 0x65, 0x32, 0x39, 0x61, 0x32, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x61, 0x34, 0x61, 0x36, 0x66, 0x37, 0x31, 0x61, 0x39, 0x38, 0x61, 0x63, 0x33, 0x66, 0x63, 0x36, 0x31, 0x33, 0x63, 0x33, 0x61, 0x38, 0x66, 0x31, 0x65, 0x32, 0x65, 0x31, 0x31, 0x62, 0x39, 0x65, 0x62, 0x39, 0x62, 0x36, 0x62, 0x33, 0x39, 0x66, 0x31, 0x32, 0x35, 0x66, 0x37, 0x64, 0x39, 0x35, 0x30, 0x38, 0x39, 0x31, 0x36, 0x63, 0x32, 0x62, 0x38, 0x66, 0x62, 0x30, 0x32, 0x63, 0x37, 0x31, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x33, 0x32, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x35, 0x32, 0x33, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x30, 0x35, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x37, 0x63, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x34, 0x38, 0x30, 0x36, 0x33, 0x31, 0x39, 0x34, 0x39, 0x34, 0x61, 0x31, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x36, 0x33, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x33, 0x34, 0x33, 0x34, 0x37, 0x33, 0x35, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x66, 0x65, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x35, 0x34, 0x30, 0x37, 0x63, 0x61, 0x36, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x34, 0x38, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x30, 0x65, 0x34, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x37, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x61, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x62, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x64, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x36, 0x36, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x30, 0x36, 0x36, 0x31, 0x30, 0x34, 0x64, 0x33, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x65, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x31, 0x64, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x34, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x35, 0x33, 0x37, 0x39, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x64, 0x32, 0x30, 0x34, 0x31, 0x36, 0x34, 0x36, 0x34, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x32, 0x37, 0x34, 0x36, 0x31, 0x30, 0x32, 0x36, 0x66, 0x38, 0x35, 0x38, 0x35, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x39, 0x33, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x36, 0x30, 0x31, 0x66, 0x38, 0x32, 0x30, 0x31, 0x31, 0x36, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x34, 0x66, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x31, 0x66, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x32, 0x39, 0x35, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x32, 0x38, 0x38, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x35, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x31, 0x31, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x31, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x37, 0x66, 0x35, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x35, 0x34, 0x39, 0x36, 0x34, 0x37, 0x33, 0x32, 0x30, 0x36, 0x31, 0x37, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x35, 0x37, 0x31, 0x37, 0x35, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x31, 0x35, 0x34, 0x38, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x35, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x33, 0x34, 0x31, 0x38, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x33, 0x33, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x36, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x33, 0x36, 0x32, 0x38, 0x34, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x33, 0x35, 0x35, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x36, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x36, 0x64, 0x38, 0x32, 0x36, 0x31, 0x30, 0x37, 0x31, 0x63, 0x35, 0x36, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x63, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x32, 0x34, 0x63, 0x34, 0x62, 0x34, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x34, 0x38, 0x33, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x63, 0x37, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x35, 0x31, 0x38, 0x31, 0x38, 0x34, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x33, 0x61, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x33, 0x66, 0x34, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x37, 0x66, 0x32, 0x36, 0x63, 0x35, 0x33, 0x62, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x62, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x30, 0x35, 0x31, 0x37, 0x62, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x33, 0x38, 0x31, 0x38, 0x33, 0x31, 0x36, 0x31, 0x37, 0x38, 0x33, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x34, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x37, 0x66, 0x31, 0x39, 0x36, 0x35, 0x30, 0x38, 0x34, 0x37, 0x66, 0x35, 0x61, 0x32, 0x32, 0x37, 0x32, 0x35, 0x35, 0x39, 0x30, 0x62, 0x30, 0x61, 0x35, 0x31, 0x63, 0x39, 0x32, 0x33, 0x39, 0x34, 0x30, 0x32, 0x32, 0x33, 0x66, 0x37, 0x34, 0x35, 0x38, 0x35, 0x31, 0x32, 0x31, 0x36, 0x34, 0x62, 0x31, 0x31, 0x31, 0x33, 0x33, 0x35, 0x39, 0x61, 0x37, 0x33, 0x35, 0x65, 0x38, 0x36, 0x65, 0x37, 0x66, 0x32, 0x37, 0x66, 0x34, 0x34, 0x37, 0x39, 0x31, 0x65, 0x65, 0x38, 0x38, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x31, 0x35, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x37, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x34, 0x66, 0x39, 0x36, 0x31, 0x30, 0x39, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x34, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x35, 0x32, 0x61, 0x38, 0x32, 0x36, 0x31, 0x30, 0x37, 0x33, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x33, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x35, 0x33, 0x65, 0x38, 0x33, 0x36, 0x31, 0x30, 0x37, 0x38, 0x33, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x37, 0x63, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x62, 0x36, 0x31, 0x30, 0x35, 0x36, 0x39, 0x36, 0x31, 0x30, 0x39, 0x62, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x39, 0x30, 0x38, 0x31, 0x36, 0x31, 0x30, 0x35, 0x36, 0x31, 0x35, 0x37, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x35, 0x38, 0x65, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x66, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x34, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x65, 0x66, 0x35, 0x37, 0x36, 0x31, 0x30, 0x35, 0x61, 0x66, 0x38, 0x33, 0x36, 0x31, 0x30, 0x38, 0x37, 0x64, 0x35, 0x36, 0x35, 0x62, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x38, 0x34, 0x38, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x35, 0x64, 0x32, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x35, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x35, 0x39, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x38, 0x32, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x31, 0x36, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x32, 0x31, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x31, 0x35, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x31, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x36, 0x32, 0x65, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x66, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x36, 0x31, 0x35, 0x37, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x32, 0x30, 0x34, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x35, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x36, 0x38, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x31, 0x30, 0x36, 0x38, 0x39, 0x38, 0x32, 0x36, 0x31, 0x30, 0x35, 0x66, 0x63, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x31, 0x36, 0x31, 0x30, 0x36, 0x61, 0x33, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x36, 0x62, 0x32, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x66, 0x34, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x36, 0x30, 0x31, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x66, 0x34, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x32, 0x38, 0x30, 0x33, 0x38, 0x38, 0x33, 0x33, 0x39, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x31, 0x30, 0x38, 0x34, 0x38, 0x37, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x38, 0x32, 0x38, 0x35, 0x36, 0x31, 0x30, 0x39, 0x33, 0x35, 0x35, 0x36, 0x35, 0x62, 0x38, 0x31, 0x39, 0x34, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x33, 0x62, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x36, 0x31, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x34, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x37, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x37, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x37, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x39, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x65, 0x66, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x37, 0x61, 0x65, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x36, 0x31, 0x30, 0x37, 0x66, 0x34, 0x35, 0x36, 0x35, 0x62, 0x38, 0x34, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x38, 0x35, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x62, 0x38, 0x30, 0x38, 0x32, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x65, 0x38, 0x35, 0x37, 0x36, 0x31, 0x30, 0x37, 0x64, 0x37, 0x38, 0x32, 0x36, 0x31, 0x30, 0x38, 0x37, 0x64, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x37, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x38, 0x32, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x31, 0x34, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x38, 0x30, 0x36, 0x31, 0x30, 0x38, 0x33, 0x39, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x33, 0x38, 0x35, 0x37, 0x35, 0x30, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x35, 0x62, 0x35, 0x62, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x34, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x36, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x62, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x38, 0x37, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x30, 0x66, 0x38, 0x30, 0x33, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x39, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x32, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x62, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x62, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x32, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x65, 0x62, 0x35, 0x37, 0x36, 0x30, 0x62, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x32, 0x39, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x30, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x31, 0x36, 0x30, 0x63, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x33, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x32, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x66, 0x37, 0x38, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x38, 0x35, 0x35, 0x31, 0x30, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x35, 0x62, 0x38, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x34, 0x33, 0x35, 0x37, 0x36, 0x31, 0x30, 0x39, 0x39, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x37, 0x33, 0x35, 0x37, 0x38, 0x32, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x38, 0x31, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x36, 0x31, 0x30, 0x39, 0x34, 0x34, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x31, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x36, 0x30, 0x66, 0x66, 0x31, 0x36, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x30, 0x31, 0x39, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x31, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x32, 0x36, 0x35, 0x36, 0x32, 0x37, 0x61, 0x37, 0x61, 0x37, 0x32, 0x33, 0x31, 0x35, 0x38, 0x32, 0x30, 0x38, 0x66, 0x31, 0x65, 0x61, 0x36, 0x66, 0x63, 0x66, 0x36, 0x33, 0x64, 0x36, 0x39, 0x31, 0x31, 0x61, 0x63, 0x35, 0x64, 0x62, 0x66, 0x65, 0x33, 0x34, 0x30, 0x62, 0x65, 0x31, 0x30, 0x32, 0x39, 0x36, 0x31, 0x34, 0x35, 0x38, 0x31, 0x38, 0x30, 0x32, 0x63, 0x36, 0x61, 0x37, 0x35, 0x30, 0x65, 0x37, 0x64, 0x36, 0x33, 0x35, 0x34, 0x62, 0x33, 0x32, 0x63, 0x65, 0x36, 0x36, 0x34, 0x37, 0x63, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x33, 0x32, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x6a, 0x61, 0x69, 0x70, 0x75, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x32, 0x33, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x64, 0x65, 0x6c, 0x68, 0x69, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x33, 0x38, 0x31, 0x38, 0x39, 0x30, 0x35, 0x36, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x6f, 0x72, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x34, 0x34, 0x39, 0x33, 0x34, 0x36, 0x35, 0x36, 0x2c, 0x22, 0x61, 0x67, 0x72, 0x61, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x20, 0x35, 0x30, 0x35, 0x32, 0x33, 0x30, 0x30, 0x30, 0x7d, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x31, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x39, 0x36, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x45, 0x44, 0x32, 0x30, 0x46, 0x38, 0x34, 0x22, 0x7d }; namespace silkworm { constinit const std::string_view kGenesisBorMainnetJson{&kGenesisBorMainnetDataInternal[0], sizeof(kGenesisBorMainnetDataInternal)}; } ================================================ FILE: silkworm/core/chain/genesis_bor_mainnet.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { constinit extern const std::string_view kGenesisBorMainnetJson; } ================================================ FILE: silkworm/core/chain/genesis_bor_mainnet.json ================================================ { "alloc": { "0000000000000000000000000000000000001000": { "balance": "0x0", "code": "0x608060405234801561001057600080fd5b50600436106101f05760003560e01c806360c8614d1161010f578063af26aa96116100a2578063d5b844eb11610071578063d5b844eb14610666578063dcf2793a14610684578063e3b7c924146106b6578063f59cf565146106d4576101f0565b8063af26aa96146105c7578063b71d7a69146105e7578063b7ab4db514610617578063c1b3c91914610636576101f0565b806370ba5707116100de57806370ba57071461052b57806398ab2b621461055b5780639d11b80714610579578063ae756451146105a9576101f0565b806360c8614d1461049c57806365b3a1e2146104bc57806366332354146104db578063687a9bd6146104f9576101f0565b80633434735f1161018757806344d6528f1161015657806344d6528f146103ee5780634dbc959f1461041e57806355614fcc1461043c578063582a8d081461046c576101f0565b80633434735f1461035257806335ddfeea1461037057806343ee8213146103a057806344c15cb1146103be576101f0565b806323f2a73f116101c357806323f2a73f146102a45780632bc06564146102d45780632de3a180146102f25780632eddf35214610322576101f0565b8063047a6c5b146101f55780630c35b1cb146102275780631270b5741461025857806323c2a2b414610288575b600080fd5b61020f600480360361020a9190810190612c14565b610706565b60405161021e93929190613553565b60405180910390f35b610241600480360361023c9190810190612c14565b61075d565b60405161024f929190613374565b60405180910390f35b610272600480360361026d9190810190612c3d565b610939565b60405161027f91906133ab565b60405180910390f35b6102a2600480360361029d9190810190612d1c565b610a91565b005b6102be60048036036102b99190810190612c3d565b61112a565b6040516102cb91906133ab565b60405180910390f35b6102dc611281565b6040516102e99190613501565b60405180910390f35b61030c60048036036103079190810190612b71565b611286565b60405161031991906133c6565b60405180910390f35b61033c60048036036103379190810190612c14565b611307565b6040516103499190613501565b60405180910390f35b61035a611437565b6040516103679190613359565b60405180910390f35b61038a60048036036103859190810190612bad565b61144f565b60405161039791906133ab565b60405180910390f35b6103a861151a565b6040516103b591906133c6565b60405180910390f35b6103d860048036036103d39190810190612c79565b611531565b6040516103e59190613501565b60405180910390f35b61040860048036036104039190810190612c3d565b611619565b60405161041591906134e6565b60405180910390f35b610426611781565b6040516104339190613501565b60405180910390f35b61045660048036036104519190810190612af6565b611791565b60405161046391906133ab565b60405180910390f35b61048660048036036104819190810190612b1f565b6117ab565b60405161049391906133c6565b60405180910390f35b6104a4611829565b6040516104b393929190613553565b60405180910390f35b6104c461189d565b6040516104d2929190613374565b60405180910390f35b6104e3611c5e565b6040516104f09190613501565b60405180910390f35b610513600480360361050e9190810190612ce0565b611c63565b6040516105229392919061351c565b60405180910390f35b61054560048036036105409190810190612af6565b611cc7565b60405161055291906133ab565b60405180910390f35b610563611ce1565b60405161057091906133c6565b60405180910390f35b610593600480360361058e9190810190612c14565b611cf8565b6040516105a09190613501565b60405180910390f35b6105b1611e29565b6040516105be91906133c6565b60405180910390f35b6105cf611e40565b6040516105de93929190613553565b60405180910390f35b61060160048036036105fc9190810190612c14565b611ea1565b60405161060e9190613501565b60405180910390f35b61061f611fa1565b60405161062d929190613374565b60405180910390f35b610650600480360361064b9190810190612c14565b611fb5565b60405161065d9190613501565b60405180910390f35b61066e611fd6565b60405161067b919061358a565b60405180910390f35b61069e60048036036106999190810190612ce0565b611fdb565b6040516106ad9392919061351c565b60405180910390f35b6106be61203f565b6040516106cb9190613501565b60405180910390f35b6106ee60048036036106e99190810190612c14565b612051565b6040516106fd93929190613553565b60405180910390f35b60008060006002600085815260200190815260200160002060000154600260008681526020019081526020016000206001015460026000878152602001908152602001600020600201549250925092509193909250565b60608060ff83116107795761077061189d565b91509150610934565b600061078484611ea1565b9050606060016000838152602001908152602001600020805490506040519080825280602002602001820160405280156107cd5781602001602082028038833980820191505090505b509050606060016000848152602001908152602001600020805490506040519080825280602002602001820160405280156108175781602001602082028038833980820191505090505b50905060008090505b60016000858152602001908152602001600020805490508110156109295760016000858152602001908152602001600020818154811061085c57fe5b906000526020600020906003020160020160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1683828151811061089a57fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff16815250506001600085815260200190815260200160002081815481106108f257fe5b90600052602060002090600302016001015482828151811061091057fe5b6020026020010181815250508080600101915050610820565b508181945094505050505b915091565b6000606060016000858152602001908152602001600020805480602002602001604051908101604052809291908181526020016000905b82821015610a0c578382906000526020600020906003020160405180606001604052908160008201548152602001600182015481526020016002820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152505081526020019060010190610970565b50505050905060008090505b8151811015610a84578373ffffffffffffffffffffffffffffffffffffffff16828281518110610a4457fe5b60200260200101516040015173ffffffffffffffffffffffffffffffffffffffff161415610a7757600192505050610a8b565b8080600101915050610a18565b5060009150505b92915050565b73fffffffffffffffffffffffffffffffffffffffe73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610b13576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b0a906134c6565b60405180910390fd5b6000610b1d611781565b90506000811415610b3157610b3061207b565b5b610b4560018261239c90919063ffffffff16565b8814610b86576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b7d90613446565b60405180910390fd5b868611610bc8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bbf906134a6565b60405180910390fd5b6000604060018989030181610bd957fe5b0614610c1a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c1190613486565b60405180910390fd5b8660026000838152602001908152602001600020600101541115610c73576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c6a90613426565b60405180910390fd5b6000600260008a81526020019081526020016000206000015414610ccc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cc390613466565b60405180910390fd5b604051806060016040528089815260200188815260200187815250600260008a8152602001908152602001600020600082015181600001556020820151816001015560408201518160020155905050600388908060018154018082558091505090600182039060005260206000200160009091929091909150555060008060008a815260200190815260200160002081610d6691906128f0565b506000600160008a815260200190815260200160002081610d8791906128f0565b506060610ddf610dda87878080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050506123bb565b6123e9565b905060008090505b8151811015610f51576060610e0e838381518110610e0157fe5b60200260200101516123e9565b90506000808c81526020019081526020016000208054809190600101610e3491906128f0565b506040518060600160405280610e5d83600081518110610e5057fe5b60200260200101516124c6565b8152602001610e7f83600181518110610e7257fe5b60200260200101516124c6565b8152602001610ea183600281518110610e9457fe5b6020026020010151612537565b73ffffffffffffffffffffffffffffffffffffffff168152506000808d81526020019081526020016000208381548110610ed757fe5b9060005260206000209060030201600082015181600001556020820151816001015560408201518160020160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550905050508080600101915050610de7565b506060610fa9610fa486868080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050506123bb565b6123e9565b905060008090505b815181101561111d576060610fd8838381518110610fcb57fe5b60200260200101516123e9565b9050600160008d81526020019081526020016000208054809190600101610fff91906128f0565b5060405180606001604052806110288360008151811061101b57fe5b60200260200101516124c6565b815260200161104a8360018151811061103d57fe5b60200260200101516124c6565b815260200161106c8360028151811061105f57fe5b6020026020010151612537565b73ffffffffffffffffffffffffffffffffffffffff16815250600160008e815260200190815260200160002083815481106110a357fe5b9060005260206000209060030201600082015181600001556020820151816001015560408201518160020160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550905050508080600101915050610fb1565b5050505050505050505050565b60006060600080858152602001908152602001600020805480602002602001604051908101604052809291908181526020016000905b828210156111fc578382906000526020600020906003020160405180606001604052908160008201548152602001600182015481526020016002820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152505081526020019060010190611160565b50505050905060008090505b8151811015611274578373ffffffffffffffffffffffffffffffffffffffff1682828151811061123457fe5b60200260200101516040015173ffffffffffffffffffffffffffffffffffffffff1614156112675760019250505061127b565b8080600101915050611208565b5060009150505b92915050565b604081565b60006002600160f81b84846040516020016112a3939291906132c6565b6040516020818303038152906040526040516112bf9190613303565b602060405180830381855afa1580156112dc573d6000803e3d6000fd5b5050506040513d601f19601f820116820180604052506112ff9190810190612b48565b905092915050565b60006060600080848152602001908152602001600020805480602002602001604051908101604052809291908181526020016000905b828210156113d9578382906000526020600020906003020160405180606001604052908160008201548152602001600182015481526020016002820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815250508152602001906001019061133d565b505050509050600080905060008090505b825181101561142c5761141d83828151811061140257fe5b6020026020010151602001518361239c90919063ffffffff16565b915080806001019150506113ea565b508092505050919050565b73fffffffffffffffffffffffffffffffffffffffe81565b600080600080859050600060218087518161146657fe5b04029050600081111561147f5761147c876117ab565b91505b6000602190505b818111611509576000600182038801519050818801519550806000602081106114ab57fe5b1a60f81b9450600060f81b857effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614156114f0576114e98685611286565b93506114fd565b6114fa8487611286565b93505b50602181019050611486565b508782149450505050509392505050565b60405161152690613344565b604051809103902081565b60008060009050600080905060008090505b84518167ffffffffffffffff16101561160c57606061156e868367ffffffffffffffff16604161255a565b9050600061158582896125e690919063ffffffff16565b905061158f612922565b6115998a83611619565b90506115a58a8361112a565b80156115dc57508473ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16115b156115fe578194506115fb81602001518761239c90919063ffffffff16565b95505b505050604181019050611543565b5081925050509392505050565b611621612922565b6060600080858152602001908152602001600020805480602002602001604051908101604052809291908181526020016000905b828210156116f1578382906000526020600020906003020160405180606001604052908160008201548152602001600182015481526020016002820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152505081526020019060010190611655565b50505050905060008090505b8151811015611779578373ffffffffffffffffffffffffffffffffffffffff1682828151811061172957fe5b60200260200101516040015173ffffffffffffffffffffffffffffffffffffffff16141561176c5781818151811061175d57fe5b60200260200101519250611779565b80806001019150506116fd565b505092915050565b600061178c43611ea1565b905090565b60006117a461179e611781565b8361112a565b9050919050565b60006002600060f81b836040516020016117c692919061329a565b6040516020818303038152906040526040516117e29190613303565b602060405180830381855afa1580156117ff573d6000803e3d6000fd5b5050506040513d601f19601f820116820180604052506118229190810190612b48565b9050919050565b60008060008061184a600161183c611781565b61239c90919063ffffffff16565b905060026000828152602001908152602001600020600001546002600083815260200190815260200160002060010154600260008481526020019081526020016000206002015493509350935050909192565b606080606060076040519080825280602002602001820160405280156118d25781602001602082028038833980820191505090505b509050735973918275c01f50555d44e92c9d9b353cadad54816000815181106118f757fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505073b8bb158b93c94ed35c1970d610d1e2b34e26652c8160018151811061195357fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505073f84c74dea96df0ec22e11e7c33996c73fcc2d822816002815181106119af57fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505073b702f1c9154ac9c08da247a8e30ee6f2f3373f4181600381518110611a0b57fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff1681525050737fcd58c2d53d980b247f1612fdba93e9a76193e681600481518110611a6757fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff1681525050730375b2fc7140977c9c76d45421564e354ed4227781600581518110611ac357fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff16815250507342eefcda06ead475cde3731b8eb138e88cd0bac381600681518110611b1f57fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505060606007604051908082528060200260200182016040528015611b8b5781602001602082028038833980820191505090505b50905061271081600081518110611b9e57fe5b60200260200101818152505061271081600181518110611bba57fe5b60200260200101818152505061271081600281518110611bd657fe5b60200260200101818152505061271081600381518110611bf257fe5b60200260200101818152505061271081600481518110611c0e57fe5b60200260200101818152505061271081600581518110611c2a57fe5b60200260200101818152505061271081600681518110611c4657fe5b60200260200101818152505081819350935050509091565b60ff81565b60016020528160005260406000208181548110611c7c57fe5b9060005260206000209060030201600091509150508060000154908060010154908060020160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905083565b6000611cda611cd4611781565b83610939565b9050919050565b604051611ced9061331a565b604051809103902081565b6000606060016000848152602001908152602001600020805480602002602001604051908101604052809291908181526020016000905b82821015611dcb578382906000526020600020906003020160405180606001604052908160008201548152602001600182015481526020016002820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152505081526020019060010190611d2f565b505050509050600080905060008090505b8251811015611e1e57611e0f838281518110611df457fe5b6020026020010151602001518361239c90919063ffffffff16565b91508080600101915050611ddc565b508092505050919050565b604051611e359061332f565b604051809103902081565b600080600080611e4e611781565b905060026000828152602001908152602001600020600001546002600083815260200190815260200160002060010154600260008481526020019081526020016000206002015493509350935050909192565b60008060038054905090505b6000811115611f6157611ebe612959565b6002600060036001850381548110611ed257fe5b906000526020600020015481526020019081526020016000206040518060600160405290816000820154815260200160018201548152602001600282015481525050905083816020015111158015611f2f57506000816040015114155b8015611f3f575080604001518411155b15611f5257806000015192505050611f9c565b50808060019003915050611ead565b5060006003805490501115611f9757600360016003805490500381548110611f8557fe5b90600052602060002001549050611f9c565b600090505b919050565b606080611fad4361075d565b915091509091565b60038181548110611fc257fe5b906000526020600020016000915090505481565b600281565b60006020528160005260406000208181548110611ff457fe5b9060005260206000209060030201600091509150508060000154908060010154908060020160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905083565b60006040438161204b57fe5b04905090565b60026020528060005260406000206000915090508060000154908060010154908060020154905083565b60608061208661189d565b8092508193505050600080905060405180606001604052808281526020016000815260200160ff81525060026000838152602001908152602001600020600082015181600001556020820151816001015560408201518160020155905050600381908060018154018082558091505090600182039060005260206000200160009091929091909150555060008060008381526020019081526020016000208161212f91906128f0565b506000600160008381526020019081526020016000208161215091906128f0565b5060008090505b835181101561227257600080838152602001908152602001600020805480919060010161218491906128f0565b5060405180606001604052808281526020018483815181106121a257fe5b602002602001015181526020018583815181106121bb57fe5b602002602001015173ffffffffffffffffffffffffffffffffffffffff1681525060008084815260200190815260200160002082815481106121f957fe5b9060005260206000209060030201600082015181600001556020820151816001015560408201518160020160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055509050508080600101915050612157565b5060008090505b8351811015612396576001600083815260200190815260200160002080548091906001016122a791906128f0565b5060405180606001604052808281526020018483815181106122c557fe5b602002602001015181526020018583815181106122de57fe5b602002602001015173ffffffffffffffffffffffffffffffffffffffff1681525060016000848152602001908152602001600020828154811061231d57fe5b9060005260206000209060030201600082015181600001556020820151816001015560408201518160020160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055509050508080600101915050612279565b50505050565b6000808284019050838110156123b157600080fd5b8091505092915050565b6123c361297a565b600060208301905060405180604001604052808451815260200182815250915050919050565b60606123f4826126f0565b6123fd57600080fd5b60006124088361273e565b905060608160405190808252806020026020018201604052801561244657816020015b612433612994565b81526020019060019003908161242b5790505b509050600061245885602001516127af565b8560200151019050600080600090505b848110156124b95761247983612838565b915060405180604001604052808381526020018481525084828151811061249c57fe5b602002602001018190525081830192508080600101915050612468565b5082945050505050919050565b60008082600001511180156124e057506021826000015111155b6124e957600080fd5b60006124f883602001516127af565b9050600081846000015103905060008083866020015101905080519150602083101561252b57826020036101000a820491505b81945050505050919050565b6000601582600001511461254a57600080fd5b612553826124c6565b9050919050565b60608183018451101561256c57600080fd5b6060821560008114612589576040519150602082016040526125da565b6040519150601f8416801560200281840101858101878315602002848b0101015b818310156125c757805183526020830192506020810190506125aa565b50868552601f19601f8301166040525050505b50809150509392505050565b600080600080604185511461260157600093505050506126ea565b602085015192506040850151915060ff6041860151169050601b8160ff16101561262c57601b810190505b601b8160ff16141580156126445750601c8160ff1614155b1561265557600093505050506126ea565b60006001878386866040516000815260200160405260405161267a94939291906133e1565b6020604051602081039080840390855afa15801561269c573d6000803e3d6000fd5b505050602060405103519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156126e257600080fd5b809450505050505b92915050565b600080826000015114156127075760009050612739565b60008083602001519050805160001a915060c060ff168260ff16101561273257600092505050612739565b6001925050505b919050565b6000808260000151141561275557600090506127aa565b6000809050600061276984602001516127af565b84602001510190506000846000015185602001510190505b808210156127a35761279282612838565b820191508280600101935050612781565b8293505050505b919050565b600080825160001a9050608060ff168110156127cf576000915050612833565b60b860ff168110806127f4575060c060ff1681101580156127f3575060f860ff1681105b5b15612803576001915050612833565b60c060ff168110156128235760018060b80360ff16820301915050612833565b60018060f80360ff168203019150505b919050565b6000806000835160001a9050608060ff1681101561285957600191506128e6565b60b860ff16811015612876576001608060ff1682030191506128e5565b60c060ff168110156128a65760b78103600185019450806020036101000a855104600182018101935050506128e4565b60f860ff168110156128c357600160c060ff1682030191506128e3565b60f78103600185019450806020036101000a855104600182018101935050505b5b5b5b8192505050919050565b81548183558181111561291d5760030281600302836000526020600020918201910161291c91906129ae565b5b505050565b60405180606001604052806000815260200160008152602001600073ffffffffffffffffffffffffffffffffffffffff1681525090565b60405180606001604052806000815260200160008152602001600081525090565b604051806040016040528060008152602001600081525090565b604051806040016040528060008152602001600081525090565b612a0191905b808211156129fd5760008082016000905560018201600090556002820160006101000a81549073ffffffffffffffffffffffffffffffffffffffff0219169055506003016129b4565b5090565b90565b600081359050612a1381613783565b92915050565b600081359050612a288161379a565b92915050565b600081519050612a3d8161379a565b92915050565b60008083601f840112612a5557600080fd5b8235905067ffffffffffffffff811115612a6e57600080fd5b602083019150836001820283011115612a8657600080fd5b9250929050565b600082601f830112612a9e57600080fd5b8135612ab1612aac826135d2565b6135a5565b91508082526020830160208301858383011115612acd57600080fd5b612ad883828461372d565b50505092915050565b600081359050612af0816137b1565b92915050565b600060208284031215612b0857600080fd5b6000612b1684828501612a04565b91505092915050565b600060208284031215612b3157600080fd5b6000612b3f84828501612a19565b91505092915050565b600060208284031215612b5a57600080fd5b6000612b6884828501612a2e565b91505092915050565b60008060408385031215612b8457600080fd5b6000612b9285828601612a19565b9250506020612ba385828601612a19565b9150509250929050565b600080600060608486031215612bc257600080fd5b6000612bd086828701612a19565b9350506020612be186828701612a19565b925050604084013567ffffffffffffffff811115612bfe57600080fd5b612c0a86828701612a8d565b9150509250925092565b600060208284031215612c2657600080fd5b6000612c3484828501612ae1565b91505092915050565b60008060408385031215612c5057600080fd5b6000612c5e85828601612ae1565b9250506020612c6f85828601612a04565b9150509250929050565b600080600060608486031215612c8e57600080fd5b6000612c9c86828701612ae1565b9350506020612cad86828701612a19565b925050604084013567ffffffffffffffff811115612cca57600080fd5b612cd686828701612a8d565b9150509250925092565b60008060408385031215612cf357600080fd5b6000612d0185828601612ae1565b9250506020612d1285828601612ae1565b9150509250929050565b600080600080600080600060a0888a031215612d3757600080fd5b6000612d458a828b01612ae1565b9750506020612d568a828b01612ae1565b9650506040612d678a828b01612ae1565b955050606088013567ffffffffffffffff811115612d8457600080fd5b612d908a828b01612a43565b9450945050608088013567ffffffffffffffff811115612daf57600080fd5b612dbb8a828b01612a43565b925092505092959891949750929550565b6000612dd88383612dfc565b60208301905092915050565b6000612df0838361326d565b60208301905092915050565b612e05816136a2565b82525050565b612e14816136a2565b82525050565b6000612e258261361e565b612e2f8185613659565b9350612e3a836135fe565b8060005b83811015612e6b578151612e528882612dcc565b9750612e5d8361363f565b925050600181019050612e3e565b5085935050505092915050565b6000612e8382613629565b612e8d818561366a565b9350612e988361360e565b8060005b83811015612ec9578151612eb08882612de4565b9750612ebb8361364c565b925050600181019050612e9c565b5085935050505092915050565b612edf816136b4565b82525050565b612ef6612ef1826136c0565b61376f565b82525050565b612f05816136ec565b82525050565b612f1c612f17826136ec565b613779565b82525050565b6000612f2d82613634565b612f37818561367b565b9350612f4781856020860161373c565b80840191505092915050565b6000612f60600483613697565b91507f766f7465000000000000000000000000000000000000000000000000000000006000830152600482019050919050565b6000612fa0602d83613686565b91507f537461727420626c6f636b206d7573742062652067726561746572207468616e60008301527f2063757272656e74207370616e000000000000000000000000000000000000006020830152604082019050919050565b6000613006600383613697565b91507f31333700000000000000000000000000000000000000000000000000000000006000830152600382019050919050565b6000613046600f83613686565b91507f496e76616c6964207370616e20696400000000000000000000000000000000006000830152602082019050919050565b6000613086601383613686565b91507f5370616e20616c726561647920657869737473000000000000000000000000006000830152602082019050919050565b60006130c6604583613686565b91507f446966666572656e6365206265747765656e20737461727420616e6420656e6460008301527f20626c6f636b206d75737420626520696e206d756c7469706c6573206f66207360208301527f7072696e740000000000000000000000000000000000000000000000000000006040830152606082019050919050565b6000613152600c83613697565b91507f6865696d64616c6c2d31333700000000000000000000000000000000000000006000830152600c82019050919050565b6000613192602a83613686565b91507f456e6420626c6f636b206d7573742062652067726561746572207468616e207360008301527f7461727420626c6f636b000000000000000000000000000000000000000000006020830152604082019050919050565b60006131f8601283613686565b91507f4e6f742053797374656d204164646573732100000000000000000000000000006000830152602082019050919050565b606082016000820151613241600085018261326d565b506020820151613254602085018261326d565b5060408201516132676040850182612dfc565b50505050565b61327681613716565b82525050565b61328581613716565b82525050565b61329481613720565b82525050565b60006132a68285612ee5565b6001820191506132b68284612f0b565b6020820191508190509392505050565b60006132d28286612ee5565b6001820191506132e28285612f0b565b6020820191506132f28284612f0b565b602082019150819050949350505050565b600061330f8284612f22565b915081905092915050565b600061332582612f53565b9150819050919050565b600061333a82612ff9565b9150819050919050565b600061334f82613145565b9150819050919050565b600060208201905061336e6000830184612e0b565b92915050565b6000604082019050818103600083015261338e8185612e1a565b905081810360208301526133a28184612e78565b90509392505050565b60006020820190506133c06000830184612ed6565b92915050565b60006020820190506133db6000830184612efc565b92915050565b60006080820190506133f66000830187612efc565b613403602083018661328b565b6134106040830185612efc565b61341d6060830184612efc565b95945050505050565b6000602082019050818103600083015261343f81612f93565b9050919050565b6000602082019050818103600083015261345f81613039565b9050919050565b6000602082019050818103600083015261347f81613079565b9050919050565b6000602082019050818103600083015261349f816130b9565b9050919050565b600060208201905081810360008301526134bf81613185565b9050919050565b600060208201905081810360008301526134df816131eb565b9050919050565b60006060820190506134fb600083018461322b565b92915050565b6000602082019050613516600083018461327c565b92915050565b6000606082019050613531600083018661327c565b61353e602083018561327c565b61354b6040830184612e0b565b949350505050565b6000606082019050613568600083018661327c565b613575602083018561327c565b613582604083018461327c565b949350505050565b600060208201905061359f600083018461328b565b92915050565b6000604051905081810181811067ffffffffffffffff821117156135c857600080fd5b8060405250919050565b600067ffffffffffffffff8211156135e957600080fd5b601f19601f8301169050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600081905092915050565b60006136ad826136f6565b9050919050565b60008115159050919050565b60007fff0000000000000000000000000000000000000000000000000000000000000082169050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b82818337600083830152505050565b60005b8381101561375a57808201518184015260208101905061373f565b83811115613769576000848401525b50505050565b6000819050919050565b6000819050919050565b61378c816136a2565b811461379757600080fd5b50565b6137a3816136ec565b81146137ae57600080fd5b50565b6137ba81613716565b81146137c557600080fd5b5056fea365627a7a72315820638c74b73aaddeb2f2fb9267028e09737291458f6da93b6619d30c86432701d96c6578706572696d656e74616cf564736f6c634300050b0040" }, "0000000000000000000000000000000000001001": { "balance": "0x0", "code": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c806319494a17146100465780633434735f146100e15780635407ca671461012b575b600080fd5b6100c76004803603604081101561005c57600080fd5b81019080803590602001909291908035906020019064010000000081111561008357600080fd5b82018360208201111561009557600080fd5b803590602001918460018302840111640100000000831117156100b757600080fd5b9091929391929390505050610149565b604051808215151515815260200191505060405180910390f35b6100e961047a565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b610133610492565b6040518082815260200191505060405180910390f35b600073fffffffffffffffffffffffffffffffffffffffe73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610200576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260128152602001807f4e6f742053797374656d2041646465737321000000000000000000000000000081525060200191505060405180910390fd5b606061025761025285858080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f82011690508083019250505050505050610498565b6104c6565b905060006102788260008151811061026b57fe5b60200260200101516105a3565b905080600160005401146102f4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f537461746549647320617265206e6f742073657175656e7469616c000000000081525060200191505060405180910390fd5b600080815480929190600101919050555060006103248360018151811061031757fe5b6020026020010151610614565b905060606103458460028151811061033857fe5b6020026020010151610637565b9050610350826106c3565b1561046f576000624c4b409050606084836040516024018083815260200180602001828103825283818151815260200191508051906020019080838360005b838110156103aa57808201518184015260208101905061038f565b50505050905090810190601f1680156103d75780820380516001836020036101000a031916815260200191505b5093505050506040516020818303038152906040527f26c53bea000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050905060008082516020840160008887f1965050505b505050509392505050565b73fffffffffffffffffffffffffffffffffffffffe81565b60005481565b6104a0610943565b600060208301905060405180604001604052808451815260200182815250915050919050565b60606104d1826106dc565b6104da57600080fd5b60006104e58361072a565b905060608160405190808252806020026020018201604052801561052357816020015b61051061095d565b8152602001906001900390816105085790505b5090506000610535856020015161079b565b8560200151019050600080600090505b848110156105965761055683610824565b915060405180604001604052808381526020018481525084828151811061057957fe5b602002602001018190525081830192508080600101915050610545565b5082945050505050919050565b60008082600001511180156105bd57506021826000015111155b6105c657600080fd5b60006105d5836020015161079b565b9050600081846000015103905060008083866020015101905080519150602083101561060857826020036101000a820491505b81945050505050919050565b6000601582600001511461062757600080fd5b610630826105a3565b9050919050565b6060600082600001511161064a57600080fd5b6000610659836020015161079b565b905060008184600001510390506060816040519080825280601f01601f19166020018201604052801561069b5781602001600182028038833980820191505090505b50905060008160200190506106b78487602001510182856108dc565b81945050505050919050565b600080823b905060008163ffffffff1611915050919050565b600080826000015114156106f35760009050610725565b60008083602001519050805160001a915060c060ff168260ff16101561071e57600092505050610725565b6001925050505b919050565b600080826000015114156107415760009050610796565b60008090506000610755846020015161079b565b84602001510190506000846000015185602001510190505b8082101561078f5761077e82610824565b82019150828060010193505061076d565b8293505050505b919050565b600080825160001a9050608060ff168110156107bb57600091505061081f565b60b860ff168110806107e0575060c060ff1681101580156107df575060f860ff1681105b5b156107ef57600191505061081f565b60c060ff1681101561080f5760018060b80360ff1682030191505061081f565b60018060f80360ff168203019150505b919050565b6000806000835160001a9050608060ff1681101561084557600191506108d2565b60b860ff16811015610862576001608060ff1682030191506108d1565b60c060ff168110156108925760b78103600185019450806020036101000a855104600182018101935050506108d0565b60f860ff168110156108af57600160c060ff1682030191506108cf565b60f78103600185019450806020036101000a855104600182018101935050505b5b5b5b8192505050919050565b60008114156108ea5761093e565b5b602060ff16811061091a5782518252602060ff1683019250602060ff1682019150602060ff16810390506108eb565b6000600182602060ff16036101000a03905080198451168184511681811785525050505b505050565b604051806040016040528060008152602001600081525090565b60405180604001604052806000815260200160008152509056fea265627a7a7231582083fbdacb76f32b4112d0f7db9a596937925824798a0026ba0232322390b5263764736f6c634300050b0032" }, "0000000000000000000000000000000000001010": { "balance": "0x204fcce2c5a141f7f9a00000", "code": "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" }, "5973918275C01F50555d44e92c9d9b353CaDAD54": { "balance": "0x3635c9adc5dea00000" }, "b8bB158B93c94ed35c1970D610d1E2B34E26652c": { "balance": "0x3635c9adc5dea00000" }, "F84C74dEa96DF0EC22e11e7C33996C73FCC2D822": { "balance": "0x3635c9adc5dea00000" }, "b702f1C9154ac9c08Da247a8e30ee6F2F3373f41": { "balance": "0x3635c9adc5dea00000" }, "7fCD58C2D53D980b247F1612FdbA93E9a76193E6": { "balance": "0x3635c9adc5dea00000" }, "0375b2fc7140977c9c76D45421564e354ED42277": { "balance": "0x3635c9adc5dea00000" }, "42EEfcda06eaD475cdE3731B8eb138e88CD0bAC3": { "balance": "0x3635c9adc5dea00000" } }, "config": { "chainId": 137, "homesteadBlock": 0, "eip150Block": 0, "eip155Block": 0, "byzantiumBlock": 0, "constantinopleBlock": 0, "petersburgBlock": 0, "istanbulBlock": 3395000, "muirGlacierBlock": 3395000, "berlinBlock": 14750000, "londonBlock": 23850000, "burntContract": { "23850000": "0x70bca57f4579f58670ab2d18ef16e02c17553c38", "50523000": "0x7A8ed27F4C30512326878652d20fC85727401854" }, "bor": { "period": { "0": 2 }, "producerDelay": { "0": 6, "38189056": 4 }, "sprint": { "0": 64, "38189056": 16 }, "backupMultiplier": { "0": 2 }, "stateSyncConfirmationDelay": { "44934656": 128 }, "validatorContract": "0x0000000000000000000000000000000000001000", "stateReceiverContract": "0x0000000000000000000000000000000000001001", "overrideStateSyncRecords": { "14949120": 8, "14949184": 0, "14953472": 0, "14953536": 5, "14953600": 0, "14953664": 0, "14953728": 0, "14953792": 0, "14953856": 0 }, "blockAlloc": { "22156660": { "0000000000000000000000000000000000001010": { "balance": "0x0", "code": "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" } }, "50523000": { "0x0000000000000000000000000000000000001001": { "balance": "0x0", "code": "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" } } }, "jaipurBlock": 23850000, "delhiBlock": 38189056, "indoreBlock": 44934656, "agraBlock": 50523000 } }, "difficulty": "0x01", "gasLimit": "0x989680", "timestamp": "0x5ED20F84" } ================================================ FILE: silkworm/core/chain/genesis_holesky.cpp ================================================ /* Generated from genesis_holesky.json using silkworm embed_json tool */ #include "genesis_holesky.hpp" constexpr char kGenesisHoleskyDataInternal[] = { 0x7b, 0x22, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x31, 0x30, 0x30, 0x33, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x30, 0x31, 0x66, 0x66, 0x63, 0x39, 0x61, 0x37, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x34, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x32, 0x32, 0x38, 0x39, 0x35, 0x31, 0x31, 0x38, 0x31, 0x34, 0x36, 0x31, 0x30, 0x30, 0x61, 0x34, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x36, 0x32, 0x31, 0x66, 0x64, 0x31, 0x33, 0x30, 0x31, 0x34, 0x36, 0x31, 0x30, 0x31, 0x62, 0x61, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x63, 0x35, 0x66, 0x32, 0x38, 0x39, 0x32, 0x66, 0x31, 0x34, 0x36, 0x31, 0x30, 0x32, 0x34, 0x34, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x35, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x36, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x33, 0x35, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x36, 0x31, 0x30, 0x32, 0x36, 0x62, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x31, 0x35, 0x31, 0x35, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x31, 0x30, 0x31, 0x62, 0x38, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x38, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x62, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x38, 0x31, 0x33, 0x35, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x64, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x65, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x30, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x33, 0x39, 0x30, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x33, 0x35, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x32, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x33, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x35, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x33, 0x39, 0x30, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x33, 0x35, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x37, 0x39, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x32, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x38, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x30, 0x32, 0x38, 0x34, 0x30, 0x31, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x31, 0x31, 0x31, 0x37, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x61, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x39, 0x31, 0x39, 0x33, 0x35, 0x30, 0x39, 0x31, 0x35, 0x30, 0x33, 0x35, 0x36, 0x31, 0x30, 0x33, 0x30, 0x34, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x31, 0x63, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x31, 0x63, 0x66, 0x36, 0x31, 0x31, 0x30, 0x62, 0x35, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x35, 0x32, 0x38, 0x33, 0x35, 0x31, 0x39, 0x31, 0x39, 0x32, 0x38, 0x33, 0x39, 0x32, 0x39, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x31, 0x38, 0x35, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x30, 0x39, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x31, 0x66, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x33, 0x36, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x32, 0x35, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x31, 0x30, 0x32, 0x35, 0x39, 0x36, 0x31, 0x31, 0x30, 0x63, 0x37, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x39, 0x31, 0x38, 0x32, 0x35, 0x32, 0x35, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x31, 0x36, 0x37, 0x66, 0x30, 0x31, 0x66, 0x66, 0x63, 0x39, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x38, 0x30, 0x36, 0x31, 0x30, 0x32, 0x66, 0x65, 0x35, 0x37, 0x35, 0x30, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x31, 0x36, 0x37, 0x66, 0x38, 0x35, 0x36, 0x34, 0x30, 0x39, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x35, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x33, 0x30, 0x38, 0x36, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x35, 0x64, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x38, 0x30, 0x35, 0x36, 0x30, 0x32, 0x36, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x34, 0x31, 0x34, 0x36, 0x31, 0x30, 0x33, 0x62, 0x36, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x33, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x37, 0x39, 0x63, 0x36, 0x30, 0x33, 0x36, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x38, 0x32, 0x31, 0x34, 0x36, 0x31, 0x30, 0x34, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x39, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x38, 0x37, 0x38, 0x36, 0x30, 0x32, 0x39, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x37, 0x30, 0x64, 0x65, 0x30, 0x62, 0x36, 0x62, 0x33, 0x61, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x37, 0x30, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x38, 0x35, 0x32, 0x36, 0x30, 0x32, 0x36, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x33, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x33, 0x34, 0x30, 0x36, 0x31, 0x35, 0x36, 0x31, 0x30, 0x34, 0x63, 0x64, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x33, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x37, 0x64, 0x32, 0x36, 0x30, 0x33, 0x33, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x33, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x33, 0x34, 0x30, 0x34, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x31, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x30, 0x35, 0x33, 0x35, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x37, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x38, 0x32, 0x62, 0x36, 0x30, 0x32, 0x37, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x30, 0x35, 0x34, 0x30, 0x38, 0x32, 0x36, 0x31, 0x31, 0x34, 0x62, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x37, 0x66, 0x36, 0x34, 0x39, 0x62, 0x62, 0x63, 0x36, 0x32, 0x64, 0x30, 0x65, 0x33, 0x31, 0x33, 0x34, 0x32, 0x61, 0x66, 0x65, 0x61, 0x34, 0x65, 0x35, 0x63, 0x64, 0x38, 0x32, 0x64, 0x34, 0x30, 0x34, 0x39, 0x65, 0x37, 0x65, 0x31, 0x65, 0x65, 0x39, 0x31, 0x32, 0x66, 0x63, 0x30, 0x38, 0x38, 0x39, 0x61, 0x61, 0x37, 0x39, 0x30, 0x38, 0x30, 0x33, 0x62, 0x65, 0x33, 0x39, 0x30, 0x33, 0x38, 0x63, 0x35, 0x38, 0x39, 0x38, 0x39, 0x38, 0x39, 0x38, 0x39, 0x38, 0x35, 0x38, 0x61, 0x38, 0x61, 0x36, 0x31, 0x30, 0x35, 0x37, 0x35, 0x36, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x31, 0x31, 0x34, 0x62, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x61, 0x30, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x31, 0x30, 0x31, 0x38, 0x39, 0x39, 0x30, 0x35, 0x32, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x30, 0x38, 0x32, 0x30, 0x31, 0x36, 0x30, 0x36, 0x30, 0x38, 0x33, 0x30, 0x31, 0x36, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x36, 0x30, 0x63, 0x30, 0x38, 0x35, 0x30, 0x31, 0x38, 0x65, 0x38, 0x65, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x30, 0x31, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x31, 0x36, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x38, 0x37, 0x38, 0x31, 0x30, 0x33, 0x38, 0x36, 0x35, 0x32, 0x38, 0x63, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x63, 0x38, 0x63, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x31, 0x36, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x38, 0x38, 0x38, 0x31, 0x30, 0x33, 0x38, 0x36, 0x35, 0x32, 0x38, 0x63, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x38, 0x63, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x33, 0x39, 0x31, 0x38, 0x65, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x38, 0x34, 0x39, 0x30, 0x38, 0x34, 0x39, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x34, 0x38, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x36, 0x33, 0x30, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x37, 0x35, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x38, 0x36, 0x38, 0x31, 0x30, 0x33, 0x38, 0x33, 0x35, 0x32, 0x38, 0x38, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x39, 0x38, 0x39, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x31, 0x66, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x31, 0x36, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x38, 0x38, 0x38, 0x31, 0x30, 0x33, 0x38, 0x34, 0x35, 0x32, 0x38, 0x39, 0x35, 0x31, 0x38, 0x31, 0x35, 0x32, 0x38, 0x39, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x33, 0x39, 0x31, 0x38, 0x62, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x38, 0x34, 0x39, 0x30, 0x38, 0x34, 0x39, 0x30, 0x35, 0x62, 0x38, 0x33, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x36, 0x65, 0x66, 0x35, 0x37, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x35, 0x31, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x36, 0x64, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x36, 0x30, 0x31, 0x66, 0x31, 0x36, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x37, 0x31, 0x63, 0x35, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x62, 0x35, 0x30, 0x39, 0x64, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x61, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x38, 0x61, 0x38, 0x61, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x38, 0x30, 0x31, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x34, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x39, 0x34, 0x31, 0x36, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x38, 0x31, 0x38, 0x34, 0x30, 0x33, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x31, 0x39, 0x31, 0x39, 0x35, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x38, 0x33, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x32, 0x30, 0x38, 0x35, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x37, 0x66, 0x63, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x37, 0x62, 0x66, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x35, 0x39, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x38, 0x36, 0x65, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x32, 0x38, 0x30, 0x36, 0x31, 0x30, 0x38, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x38, 0x34, 0x38, 0x61, 0x38, 0x63, 0x36, 0x31, 0x31, 0x36, 0x66, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x38, 0x66, 0x38, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x38, 0x62, 0x62, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x35, 0x35, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x39, 0x36, 0x61, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x32, 0x36, 0x31, 0x30, 0x39, 0x37, 0x62, 0x38, 0x39, 0x36, 0x30, 0x34, 0x30, 0x38, 0x31, 0x38, 0x64, 0x36, 0x31, 0x31, 0x36, 0x66, 0x65, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x34, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x39, 0x31, 0x39, 0x30, 0x39, 0x31, 0x30, 0x31, 0x39, 0x32, 0x38, 0x33, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x39, 0x32, 0x38, 0x33, 0x30, 0x31, 0x39, 0x31, 0x38, 0x32, 0x39, 0x30, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x39, 0x34, 0x35, 0x30, 0x39, 0x30, 0x39, 0x32, 0x35, 0x30, 0x38, 0x32, 0x39, 0x31, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x39, 0x66, 0x34, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x39, 0x62, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x35, 0x31, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x61, 0x36, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x34, 0x39, 0x30, 0x39, 0x34, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x31, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x38, 0x32, 0x39, 0x31, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x61, 0x64, 0x61, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x61, 0x39, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x33, 0x37, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x62, 0x34, 0x63, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x30, 0x31, 0x38, 0x35, 0x38, 0x31, 0x35, 0x32, 0x39, 0x32, 0x39, 0x33, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x39, 0x32, 0x36, 0x30, 0x30, 0x32, 0x39, 0x32, 0x38, 0x33, 0x39, 0x32, 0x38, 0x37, 0x39, 0x32, 0x38, 0x66, 0x39, 0x32, 0x38, 0x66, 0x39, 0x32, 0x30, 0x31, 0x38, 0x33, 0x38, 0x33, 0x38, 0x30, 0x38, 0x32, 0x38, 0x34, 0x33, 0x37, 0x38, 0x30, 0x38, 0x33, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x62, 0x64, 0x39, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x62, 0x39, 0x63, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x33, 0x36, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x63, 0x34, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x36, 0x35, 0x31, 0x36, 0x30, 0x30, 0x32, 0x39, 0x31, 0x38, 0x38, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x39, 0x31, 0x38, 0x38, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x38, 0x32, 0x39, 0x31, 0x39, 0x30, 0x38, 0x36, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x63, 0x61, 0x39, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x63, 0x36, 0x63, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x30, 0x33, 0x38, 0x30, 0x31, 0x39, 0x38, 0x32, 0x35, 0x31, 0x31, 0x36, 0x38, 0x31, 0x38, 0x34, 0x35, 0x31, 0x31, 0x36, 0x38, 0x30, 0x38, 0x32, 0x31, 0x37, 0x38, 0x35, 0x35, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x31, 0x38, 0x33, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x36, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x38, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x33, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x64, 0x34, 0x65, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x64, 0x31, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x64, 0x61, 0x62, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x64, 0x63, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x31, 0x39, 0x34, 0x39, 0x30, 0x39, 0x34, 0x35, 0x32, 0x38, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x35, 0x32, 0x38, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x31, 0x39, 0x31, 0x39, 0x32, 0x39, 0x30, 0x39, 0x31, 0x38, 0x32, 0x39, 0x31, 0x38, 0x34, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x30, 0x65, 0x33, 0x34, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x64, 0x66, 0x37, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x39, 0x31, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x65, 0x61, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x39, 0x30, 0x35, 0x30, 0x38, 0x35, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x30, 0x66, 0x30, 0x32, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x35, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x37, 0x34, 0x38, 0x36, 0x30, 0x35, 0x34, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x33, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x31, 0x36, 0x31, 0x30, 0x66, 0x36, 0x30, 0x35, 0x37, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x63, 0x33, 0x37, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x30, 0x34, 0x30, 0x31, 0x38, 0x30, 0x38, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x30, 0x33, 0x38, 0x32, 0x35, 0x32, 0x36, 0x30, 0x32, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x36, 0x31, 0x31, 0x37, 0x32, 0x37, 0x36, 0x30, 0x32, 0x31, 0x39, 0x31, 0x33, 0x39, 0x36, 0x30, 0x34, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x36, 0x30, 0x30, 0x30, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x61, 0x39, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x36, 0x30, 0x30, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x30, 0x66, 0x61, 0x30, 0x35, 0x37, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x66, 0x39, 0x31, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x31, 0x35, 0x35, 0x35, 0x30, 0x36, 0x31, 0x31, 0x30, 0x61, 0x63, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x30, 0x66, 0x61, 0x66, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x31, 0x35, 0x34, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x32, 0x35, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x66, 0x65, 0x38, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x38, 0x32, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x30, 0x39, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x34, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x30, 0x66, 0x36, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x66, 0x65, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x31, 0x31, 0x30, 0x63, 0x32, 0x36, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x31, 0x31, 0x34, 0x62, 0x61, 0x35, 0x36, 0x35, 0x62, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x38, 0x31, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x66, 0x30, 0x35, 0x37, 0x38, 0x31, 0x36, 0x30, 0x30, 0x31, 0x31, 0x36, 0x36, 0x30, 0x30, 0x31, 0x31, 0x34, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x65, 0x36, 0x35, 0x37, 0x36, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x32, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x30, 0x66, 0x35, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x31, 0x35, 0x34, 0x38, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x31, 0x36, 0x62, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x31, 0x32, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x63, 0x38, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x31, 0x64, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x31, 0x31, 0x32, 0x65, 0x32, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x38, 0x33, 0x36, 0x30, 0x32, 0x31, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x31, 0x66, 0x36, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x30, 0x31, 0x35, 0x34, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x33, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x38, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x31, 0x35, 0x32, 0x39, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x32, 0x36, 0x62, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x32, 0x32, 0x65, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x63, 0x38, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x32, 0x64, 0x64, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x62, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x30, 0x34, 0x39, 0x31, 0x35, 0x30, 0x36, 0x30, 0x30, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x64, 0x31, 0x35, 0x36, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x32, 0x38, 0x32, 0x36, 0x31, 0x31, 0x32, 0x66, 0x66, 0x36, 0x30, 0x32, 0x30, 0x35, 0x34, 0x36, 0x31, 0x31, 0x34, 0x62, 0x61, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x34, 0x30, 0x31, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x30, 0x38, 0x34, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x38, 0x33, 0x38, 0x30, 0x35, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x33, 0x35, 0x61, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x33, 0x31, 0x64, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x39, 0x30, 0x39, 0x35, 0x31, 0x36, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x38, 0x32, 0x35, 0x32, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x30, 0x31, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x31, 0x38, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x32, 0x38, 0x31, 0x35, 0x31, 0x39, 0x31, 0x39, 0x35, 0x35, 0x30, 0x39, 0x33, 0x35, 0x30, 0x38, 0x33, 0x39, 0x32, 0x38, 0x35, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x38, 0x33, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x38, 0x33, 0x31, 0x30, 0x36, 0x31, 0x31, 0x34, 0x33, 0x66, 0x35, 0x37, 0x38, 0x30, 0x35, 0x31, 0x38, 0x32, 0x35, 0x32, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x30, 0x39, 0x30, 0x39, 0x32, 0x30, 0x31, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x31, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x31, 0x31, 0x34, 0x30, 0x32, 0x35, 0x36, 0x35, 0x62, 0x35, 0x31, 0x38, 0x31, 0x35, 0x31, 0x36, 0x30, 0x32, 0x30, 0x39, 0x33, 0x38, 0x34, 0x30, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x61, 0x37, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x30, 0x31, 0x38, 0x30, 0x31, 0x39, 0x39, 0x30, 0x39, 0x32, 0x31, 0x36, 0x39, 0x31, 0x31, 0x36, 0x31, 0x37, 0x39, 0x30, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x39, 0x31, 0x39, 0x30, 0x39, 0x33, 0x30, 0x31, 0x39, 0x34, 0x35, 0x30, 0x39, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x38, 0x31, 0x38, 0x35, 0x35, 0x61, 0x66, 0x61, 0x31, 0x35, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x39, 0x63, 0x35, 0x37, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x65, 0x33, 0x64, 0x36, 0x30, 0x30, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x33, 0x64, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x31, 0x31, 0x34, 0x62, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x31, 0x39, 0x32, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x38, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x38, 0x38, 0x30, 0x38, 0x32, 0x35, 0x32, 0x38, 0x31, 0x38, 0x33, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x35, 0x32, 0x36, 0x30, 0x36, 0x30, 0x39, 0x31, 0x36, 0x30, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x38, 0x31, 0x38, 0x30, 0x33, 0x36, 0x38, 0x33, 0x33, 0x37, 0x30, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x30, 0x36, 0x30, 0x63, 0x30, 0x38, 0x32, 0x39, 0x30, 0x31, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x37, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x34, 0x66, 0x34, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x36, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x31, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x35, 0x33, 0x37, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x35, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x32, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x35, 0x37, 0x61, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x34, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x33, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x35, 0x62, 0x64, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x33, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x34, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x36, 0x30, 0x30, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x32, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x35, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x36, 0x34, 0x33, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x31, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x36, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x36, 0x38, 0x36, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x36, 0x30, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x36, 0x30, 0x30, 0x37, 0x38, 0x31, 0x35, 0x31, 0x38, 0x31, 0x31, 0x30, 0x36, 0x31, 0x31, 0x36, 0x63, 0x39, 0x35, 0x37, 0x66, 0x65, 0x35, 0x62, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x31, 0x39, 0x30, 0x37, 0x65, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x31, 0x36, 0x39, 0x30, 0x38, 0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x61, 0x39, 0x30, 0x35, 0x33, 0x35, 0x30, 0x35, 0x30, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x35, 0x38, 0x35, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x30, 0x64, 0x35, 0x37, 0x38, 0x31, 0x38, 0x32, 0x66, 0x64, 0x35, 0x62, 0x38, 0x33, 0x38, 0x36, 0x31, 0x31, 0x31, 0x35, 0x36, 0x31, 0x31, 0x37, 0x31, 0x39, 0x35, 0x37, 0x38, 0x31, 0x38, 0x32, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x35, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x33, 0x39, 0x31, 0x39, 0x30, 0x39, 0x32, 0x30, 0x33, 0x39, 0x31, 0x35, 0x30, 0x35, 0x36, 0x66, 0x65, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x36, 0x64, 0x36, 0x35, 0x37, 0x32, 0x36, 0x62, 0x36, 0x63, 0x36, 0x35, 0x32, 0x30, 0x37, 0x34, 0x37, 0x32, 0x36, 0x35, 0x36, 0x35, 0x32, 0x30, 0x36, 0x36, 0x37, 0x35, 0x36, 0x63, 0x36, 0x63, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x37, 0x32, 0x36, 0x35, 0x36, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x37, 0x35, 0x36, 0x33, 0x37, 0x34, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x31, 0x32, 0x30, 0x36, 0x34, 0x36, 0x66, 0x36, 0x35, 0x37, 0x33, 0x32, 0x30, 0x36, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x36, 0x64, 0x36, 0x31, 0x37, 0x34, 0x36, 0x33, 0x36, 0x38, 0x32, 0x30, 0x37, 0x33, 0x37, 0x35, 0x37, 0x30, 0x37, 0x30, 0x36, 0x63, 0x36, 0x39, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x36, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x35, 0x66, 0x36, 0x34, 0x36, 0x31, 0x37, 0x34, 0x36, 0x31, 0x35, 0x66, 0x37, 0x32, 0x36, 0x66, 0x36, 0x66, 0x37, 0x34, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x37, 0x36, 0x39, 0x37, 0x34, 0x36, 0x38, 0x36, 0x34, 0x37, 0x32, 0x36, 0x31, 0x37, 0x37, 0x36, 0x31, 0x36, 0x63, 0x35, 0x66, 0x36, 0x33, 0x37, 0x32, 0x36, 0x35, 0x36, 0x34, 0x36, 0x35, 0x36, 0x65, 0x37, 0x34, 0x36, 0x39, 0x36, 0x31, 0x36, 0x63, 0x37, 0x33, 0x32, 0x30, 0x36, 0x63, 0x36, 0x35, 0x36, 0x65, 0x36, 0x37, 0x37, 0x34, 0x36, 0x38, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x36, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x32, 0x30, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x37, 0x35, 0x36, 0x35, 0x32, 0x30, 0x36, 0x65, 0x36, 0x66, 0x37, 0x34, 0x32, 0x30, 0x36, 0x64, 0x37, 0x35, 0x36, 0x63, 0x37, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x63, 0x36, 0x35, 0x32, 0x30, 0x36, 0x66, 0x36, 0x36, 0x32, 0x30, 0x36, 0x37, 0x37, 0x37, 0x36, 0x35, 0x36, 0x39, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x30, 0x37, 0x35, 0x36, 0x32, 0x36, 0x62, 0x36, 0x35, 0x37, 0x39, 0x32, 0x30, 0x36, 0x63, 0x36, 0x35, 0x36, 0x65, 0x36, 0x37, 0x37, 0x34, 0x36, 0x38, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x36, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x32, 0x30, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x37, 0x35, 0x36, 0x35, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x66, 0x32, 0x30, 0x36, 0x38, 0x36, 0x39, 0x36, 0x37, 0x36, 0x38, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x36, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x32, 0x30, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x37, 0x35, 0x36, 0x35, 0x32, 0x30, 0x37, 0x34, 0x36, 0x66, 0x36, 0x66, 0x32, 0x30, 0x36, 0x63, 0x36, 0x66, 0x37, 0x37, 0x34, 0x34, 0x36, 0x35, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x33, 0x61, 0x32, 0x30, 0x36, 0x39, 0x36, 0x65, 0x37, 0x36, 0x36, 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x34, 0x32, 0x30, 0x37, 0x33, 0x36, 0x39, 0x36, 0x37, 0x36, 0x65, 0x36, 0x31, 0x37, 0x34, 0x37, 0x35, 0x37, 0x32, 0x36, 0x35, 0x32, 0x30, 0x36, 0x63, 0x36, 0x35, 0x36, 0x65, 0x36, 0x37, 0x37, 0x34, 0x36, 0x38, 0x61, 0x32, 0x36, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x36, 0x37, 0x33, 0x35, 0x38, 0x32, 0x32, 0x31, 0x32, 0x32, 0x30, 0x31, 0x64, 0x64, 0x32, 0x36, 0x66, 0x33, 0x37, 0x61, 0x36, 0x32, 0x31, 0x37, 0x30, 0x33, 0x30, 0x30, 0x39, 0x61, 0x62, 0x66, 0x31, 0x36, 0x65, 0x37, 0x37, 0x65, 0x36, 0x39, 0x63, 0x39, 0x33, 0x64, 0x63, 0x35, 0x30, 0x63, 0x37, 0x39, 0x64, 0x62, 0x37, 0x66, 0x36, 0x63, 0x63, 0x33, 0x37, 0x35, 0x34, 0x33, 0x65, 0x33, 0x65, 0x30, 0x65, 0x33, 0x64, 0x65, 0x63, 0x64, 0x63, 0x39, 0x37, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x36, 0x30, 0x62, 0x30, 0x30, 0x33, 0x33, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x35, 0x61, 0x35, 0x66, 0x64, 0x34, 0x32, 0x64, 0x31, 0x36, 0x61, 0x32, 0x30, 0x33, 0x30, 0x32, 0x37, 0x39, 0x38, 0x65, 0x66, 0x36, 0x65, 0x64, 0x33, 0x30, 0x39, 0x39, 0x37, 0x39, 0x62, 0x34, 0x33, 0x30, 0x30, 0x33, 0x64, 0x32, 0x33, 0x32, 0x30, 0x64, 0x39, 0x66, 0x30, 0x65, 0x38, 0x65, 0x61, 0x39, 0x38, 0x33, 0x31, 0x61, 0x39, 0x32, 0x37, 0x35, 0x39, 0x66, 0x62, 0x34, 0x62, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x62, 0x35, 0x36, 0x31, 0x31, 0x34, 0x65, 0x30, 0x30, 0x66, 0x64, 0x64, 0x34, 0x63, 0x31, 0x66, 0x38, 0x35, 0x63, 0x38, 0x39, 0x32, 0x62, 0x66, 0x33, 0x35, 0x61, 0x63, 0x39, 0x61, 0x38, 0x39, 0x32, 0x38, 0x39, 0x61, 0x61, 0x65, 0x63, 0x62, 0x31, 0x65, 0x62, 0x64, 0x30, 0x61, 0x39, 0x36, 0x63, 0x64, 0x65, 0x36, 0x30, 0x36, 0x61, 0x37, 0x34, 0x38, 0x62, 0x35, 0x64, 0x37, 0x31, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x37, 0x38, 0x30, 0x30, 0x39, 0x66, 0x64, 0x66, 0x30, 0x37, 0x66, 0x63, 0x35, 0x36, 0x61, 0x31, 0x31, 0x66, 0x31, 0x32, 0x32, 0x33, 0x37, 0x30, 0x36, 0x35, 0x38, 0x61, 0x33, 0x35, 0x33, 0x61, 0x61, 0x61, 0x35, 0x34, 0x32, 0x65, 0x64, 0x36, 0x33, 0x65, 0x34, 0x34, 0x63, 0x34, 0x62, 0x63, 0x31, 0x35, 0x66, 0x66, 0x34, 0x63, 0x64, 0x31, 0x30, 0x35, 0x61, 0x62, 0x33, 0x33, 0x63, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x33, 0x36, 0x64, 0x39, 0x38, 0x38, 0x33, 0x37, 0x66, 0x32, 0x64, 0x64, 0x31, 0x36, 0x35, 0x61, 0x35, 0x35, 0x64, 0x35, 0x65, 0x65, 0x61, 0x65, 0x39, 0x31, 0x34, 0x38, 0x35, 0x39, 0x35, 0x34, 0x34, 0x37, 0x32, 0x64, 0x35, 0x36, 0x66, 0x32, 0x34, 0x36, 0x64, 0x66, 0x32, 0x35, 0x36, 0x62, 0x66, 0x33, 0x63, 0x61, 0x65, 0x31, 0x39, 0x33, 0x35, 0x32, 0x61, 0x31, 0x32, 0x33, 0x63, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x65, 0x66, 0x64, 0x65, 0x30, 0x35, 0x32, 0x61, 0x61, 0x31, 0x35, 0x34, 0x32, 0x39, 0x66, 0x61, 0x65, 0x30, 0x35, 0x62, 0x61, 0x64, 0x34, 0x64, 0x30, 0x62, 0x31, 0x64, 0x37, 0x63, 0x36, 0x34, 0x64, 0x61, 0x36, 0x34, 0x64, 0x30, 0x33, 0x64, 0x37, 0x61, 0x31, 0x38, 0x35, 0x34, 0x61, 0x35, 0x38, 0x38, 0x63, 0x32, 0x63, 0x62, 0x38, 0x34, 0x33, 0x30, 0x63, 0x30, 0x64, 0x33, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x38, 0x38, 0x64, 0x64, 0x66, 0x65, 0x65, 0x64, 0x34, 0x30, 0x30, 0x61, 0x38, 0x37, 0x35, 0x35, 0x35, 0x39, 0x36, 0x62, 0x32, 0x31, 0x39, 0x34, 0x32, 0x63, 0x31, 0x34, 0x39, 0x37, 0x65, 0x31, 0x31, 0x34, 0x63, 0x33, 0x30, 0x32, 0x65, 0x36, 0x31, 0x31, 0x38, 0x32, 0x39, 0x30, 0x66, 0x39, 0x31, 0x65, 0x36, 0x37, 0x37, 0x32, 0x39, 0x37, 0x36, 0x30, 0x34, 0x31, 0x66, 0x61, 0x31, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x37, 0x65, 0x62, 0x30, 0x64, 0x64, 0x62, 0x61, 0x35, 0x37, 0x65, 0x33, 0x35, 0x66, 0x36, 0x64, 0x32, 0x38, 0x36, 0x36, 0x37, 0x33, 0x38, 0x30, 0x32, 0x61, 0x34, 0x61, 0x66, 0x35, 0x39, 0x37, 0x35, 0x65, 0x32, 0x32, 0x35, 0x30, 0x36, 0x63, 0x37, 0x63, 0x66, 0x34, 0x63, 0x36, 0x34, 0x62, 0x62, 0x36, 0x62, 0x65, 0x35, 0x65, 0x65, 0x31, 0x31, 0x35, 0x32, 0x37, 0x66, 0x32, 0x63, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x36, 0x38, 0x34, 0x36, 0x34, 0x37, 0x36, 0x66, 0x64, 0x35, 0x66, 0x63, 0x35, 0x34, 0x61, 0x35, 0x64, 0x34, 0x33, 0x33, 0x38, 0x35, 0x31, 0x36, 0x37, 0x63, 0x39, 0x35, 0x31, 0x34, 0x34, 0x66, 0x32, 0x36, 0x34, 0x33, 0x66, 0x35, 0x33, 0x33, 0x63, 0x63, 0x38, 0x35, 0x62, 0x62, 0x39, 0x64, 0x31, 0x36, 0x62, 0x37, 0x38, 0x32, 0x66, 0x38, 0x64, 0x37, 0x64, 0x62, 0x31, 0x39, 0x33, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x30, 0x36, 0x64, 0x38, 0x36, 0x35, 0x38, 0x32, 0x64, 0x32, 0x35, 0x32, 0x34, 0x30, 0x35, 0x62, 0x38, 0x34, 0x30, 0x30, 0x31, 0x38, 0x37, 0x39, 0x32, 0x63, 0x61, 0x64, 0x32, 0x62, 0x66, 0x31, 0x32, 0x35, 0x39, 0x66, 0x31, 0x65, 0x66, 0x35, 0x61, 0x61, 0x35, 0x66, 0x38, 0x38, 0x37, 0x65, 0x31, 0x33, 0x63, 0x62, 0x32, 0x66, 0x30, 0x30, 0x39, 0x34, 0x66, 0x35, 0x31, 0x65, 0x31, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x62, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x66, 0x66, 0x66, 0x30, 0x61, 0x64, 0x37, 0x65, 0x36, 0x35, 0x39, 0x37, 0x37, 0x32, 0x66, 0x39, 0x35, 0x33, 0x34, 0x63, 0x31, 0x39, 0x35, 0x63, 0x38, 0x31, 0x35, 0x65, 0x66, 0x63, 0x34, 0x30, 0x31, 0x34, 0x65, 0x66, 0x31, 0x65, 0x31, 0x64, 0x61, 0x65, 0x64, 0x34, 0x34, 0x30, 0x34, 0x63, 0x30, 0x36, 0x33, 0x38, 0x35, 0x64, 0x31, 0x31, 0x31, 0x39, 0x32, 0x65, 0x39, 0x32, 0x62, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x63, 0x66, 0x30, 0x34, 0x31, 0x32, 0x37, 0x64, 0x62, 0x30, 0x35, 0x34, 0x34, 0x31, 0x63, 0x64, 0x38, 0x33, 0x33, 0x31, 0x30, 0x37, 0x61, 0x35, 0x32, 0x62, 0x65, 0x38, 0x35, 0x32, 0x38, 0x36, 0x38, 0x38, 0x39, 0x30, 0x65, 0x34, 0x33, 0x31, 0x37, 0x65, 0x36, 0x61, 0x30, 0x32, 0x61, 0x62, 0x34, 0x37, 0x36, 0x38, 0x33, 0x61, 0x61, 0x37, 0x35, 0x39, 0x36, 0x34, 0x32, 0x32, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x37, 0x64, 0x30, 0x35, 0x66, 0x38, 0x37, 0x35, 0x66, 0x31, 0x34, 0x30, 0x30, 0x32, 0x37, 0x65, 0x66, 0x35, 0x31, 0x31, 0x38, 0x61, 0x32, 0x32, 0x34, 0x37, 0x62, 0x62, 0x62, 0x38, 0x34, 0x63, 0x65, 0x38, 0x66, 0x32, 0x66, 0x30, 0x66, 0x31, 0x31, 0x32, 0x33, 0x36, 0x32, 0x33, 0x30, 0x38, 0x35, 0x64, 0x61, 0x66, 0x37, 0x39, 0x36, 0x30, 0x63, 0x33, 0x32, 0x39, 0x66, 0x35, 0x66, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x66, 0x36, 0x61, 0x66, 0x35, 0x66, 0x35, 0x62, 0x62, 0x64, 0x62, 0x36, 0x62, 0x65, 0x39, 0x65, 0x66, 0x38, 0x61, 0x61, 0x36, 0x31, 0x38, 0x65, 0x34, 0x62, 0x66, 0x38, 0x30, 0x37, 0x33, 0x39, 0x36, 0x30, 0x38, 0x36, 0x37, 0x31, 0x37, 0x31, 0x65, 0x32, 0x39, 0x36, 0x37, 0x36, 0x66, 0x38, 0x62, 0x32, 0x38, 0x34, 0x64, 0x65, 0x61, 0x36, 0x61, 0x30, 0x38, 0x61, 0x38, 0x35, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x66, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x35, 0x38, 0x64, 0x39, 0x30, 0x30, 0x66, 0x35, 0x65, 0x31, 0x38, 0x32, 0x65, 0x33, 0x63, 0x35, 0x30, 0x65, 0x66, 0x37, 0x34, 0x39, 0x36, 0x39, 0x65, 0x61, 0x31, 0x36, 0x63, 0x37, 0x37, 0x32, 0x36, 0x63, 0x35, 0x34, 0x39, 0x37, 0x35, 0x37, 0x63, 0x63, 0x32, 0x33, 0x35, 0x32, 0x33, 0x63, 0x33, 0x36, 0x39, 0x35, 0x38, 0x37, 0x64, 0x61, 0x37, 0x32, 0x39, 0x33, 0x37, 0x38, 0x34, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x34, 0x39, 0x61, 0x37, 0x35, 0x30, 0x32, 0x66, 0x66, 0x63, 0x66, 0x62, 0x30, 0x33, 0x34, 0x30, 0x62, 0x31, 0x64, 0x37, 0x38, 0x38, 0x35, 0x36, 0x38, 0x38, 0x35, 0x30, 0x30, 0x63, 0x61, 0x33, 0x30, 0x38, 0x31, 0x36, 0x31, 0x61, 0x37, 0x66, 0x39, 0x36, 0x62, 0x36, 0x32, 0x64, 0x66, 0x39, 0x64, 0x30, 0x38, 0x33, 0x62, 0x37, 0x31, 0x66, 0x63, 0x63, 0x38, 0x66, 0x32, 0x62, 0x62, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x66, 0x65, 0x36, 0x62, 0x31, 0x36, 0x38, 0x39, 0x32, 0x35, 0x36, 0x63, 0x30, 0x64, 0x33, 0x38, 0x35, 0x66, 0x34, 0x32, 0x66, 0x35, 0x62, 0x62, 0x65, 0x32, 0x30, 0x32, 0x37, 0x61, 0x32, 0x32, 0x63, 0x31, 0x39, 0x39, 0x36, 0x65, 0x31, 0x31, 0x30, 0x62, 0x61, 0x39, 0x37, 0x63, 0x31, 0x37, 0x31, 0x64, 0x33, 0x65, 0x35, 0x39, 0x34, 0x38, 0x64, 0x65, 0x39, 0x32, 0x62, 0x65, 0x62, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x64, 0x30, 0x64, 0x36, 0x33, 0x63, 0x33, 0x39, 0x65, 0x62, 0x61, 0x64, 0x65, 0x38, 0x35, 0x30, 0x39, 0x65, 0x30, 0x61, 0x65, 0x33, 0x63, 0x39, 0x63, 0x33, 0x38, 0x37, 0x36, 0x66, 0x62, 0x35, 0x66, 0x61, 0x31, 0x31, 0x32, 0x62, 0x65, 0x31, 0x38, 0x66, 0x39, 0x30, 0x35, 0x65, 0x63, 0x61, 0x63, 0x66, 0x65, 0x63, 0x62, 0x39, 0x32, 0x30, 0x35, 0x37, 0x36, 0x30, 0x33, 0x61, 0x62, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x35, 0x65, 0x65, 0x63, 0x38, 0x62, 0x32, 0x65, 0x35, 0x34, 0x31, 0x63, 0x61, 0x64, 0x34, 0x65, 0x39, 0x31, 0x64, 0x65, 0x33, 0x38, 0x33, 0x38, 0x35, 0x66, 0x32, 0x65, 0x30, 0x34, 0x36, 0x36, 0x31, 0x39, 0x66, 0x35, 0x34, 0x34, 0x39, 0x36, 0x63, 0x32, 0x33, 0x38, 0x32, 0x63, 0x62, 0x36, 0x63, 0x61, 0x63, 0x64, 0x35, 0x62, 0x39, 0x38, 0x63, 0x32, 0x36, 0x66, 0x35, 0x61, 0x34, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x38, 0x39, 0x33, 0x65, 0x39, 0x30, 0x38, 0x39, 0x31, 0x37, 0x37, 0x37, 0x35, 0x62, 0x36, 0x32, 0x62, 0x66, 0x66, 0x32, 0x33, 0x32, 0x39, 0x34, 0x64, 0x62, 0x62, 0x65, 0x33, 0x61, 0x31, 0x63, 0x64, 0x38, 0x65, 0x36, 0x63, 0x63, 0x31, 0x63, 0x33, 0x35, 0x62, 0x34, 0x38, 0x30, 0x31, 0x38, 0x38, 0x37, 0x62, 0x36, 0x34, 0x36, 0x61, 0x36, 0x66, 0x38, 0x31, 0x66, 0x31, 0x37, 0x66, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x64, 0x64, 0x62, 0x61, 0x37, 0x62, 0x35, 0x39, 0x32, 0x65, 0x33, 0x31, 0x33, 0x33, 0x33, 0x39, 0x33, 0x63, 0x31, 0x36, 0x31, 0x39, 0x34, 0x66, 0x61, 0x63, 0x37, 0x34, 0x33, 0x31, 0x61, 0x62, 0x66, 0x32, 0x66, 0x35, 0x34, 0x38, 0x35, 0x65, 0x64, 0x37, 0x31, 0x31, 0x64, 0x62, 0x32, 0x38, 0x32, 0x31, 0x38, 0x33, 0x63, 0x38, 0x31, 0x39, 0x65, 0x30, 0x38, 0x65, 0x62, 0x61, 0x61, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x61, 0x38, 0x64, 0x37, 0x66, 0x65, 0x33, 0x61, 0x66, 0x38, 0x63, 0x61, 0x61, 0x30, 0x38, 0x35, 0x61, 0x37, 0x36, 0x33, 0x39, 0x61, 0x38, 0x33, 0x32, 0x30, 0x30, 0x31, 0x34, 0x35, 0x37, 0x64, 0x66, 0x62, 0x39, 0x31, 0x32, 0x38, 0x61, 0x38, 0x30, 0x36, 0x31, 0x31, 0x34, 0x32, 0x61, 0x64, 0x30, 0x33, 0x33, 0x35, 0x36, 0x32, 0x39, 0x66, 0x66, 0x32, 0x33, 0x66, 0x66, 0x39, 0x63, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x65, 0x62, 0x33, 0x63, 0x33, 0x33, 0x37, 0x64, 0x37, 0x61, 0x35, 0x31, 0x61, 0x36, 0x66, 0x62, 0x66, 0x30, 0x30, 0x62, 0x39, 0x65, 0x33, 0x34, 0x63, 0x35, 0x32, 0x65, 0x31, 0x63, 0x39, 0x31, 0x39, 0x35, 0x63, 0x39, 0x36, 0x39, 0x62, 0x64, 0x34, 0x65, 0x37, 0x61, 0x30, 0x62, 0x66, 0x64, 0x35, 0x31, 0x64, 0x35, 0x63, 0x35, 0x62, 0x65, 0x64, 0x39, 0x63, 0x31, 0x31, 0x36, 0x37, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x65, 0x37, 0x31, 0x66, 0x30, 0x61, 0x61, 0x38, 0x33, 0x63, 0x63, 0x33, 0x32, 0x65, 0x64, 0x66, 0x62, 0x65, 0x66, 0x61, 0x39, 0x66, 0x34, 0x64, 0x33, 0x65, 0x30, 0x31, 0x37, 0x34, 0x63, 0x61, 0x38, 0x35, 0x31, 0x38, 0x32, 0x65, 0x65, 0x63, 0x39, 0x66, 0x33, 0x61, 0x30, 0x39, 0x66, 0x36, 0x61, 0x36, 0x63, 0x30, 0x64, 0x66, 0x36, 0x33, 0x37, 0x37, 0x61, 0x35, 0x31, 0x30, 0x64, 0x37, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x31, 0x32, 0x30, 0x36, 0x66, 0x61, 0x38, 0x30, 0x61, 0x35, 0x30, 0x62, 0x62, 0x36, 0x61, 0x62, 0x65, 0x32, 0x39, 0x30, 0x38, 0x35, 0x30, 0x35, 0x38, 0x66, 0x31, 0x36, 0x32, 0x31, 0x32, 0x32, 0x31, 0x32, 0x61, 0x36, 0x30, 0x65, 0x65, 0x63, 0x38, 0x66, 0x30, 0x34, 0x39, 0x66, 0x65, 0x63, 0x62, 0x39, 0x32, 0x64, 0x38, 0x63, 0x38, 0x65, 0x30, 0x61, 0x38, 0x34, 0x62, 0x63, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x31, 0x33, 0x35, 0x32, 0x62, 0x66, 0x65, 0x63, 0x62, 0x65, 0x64, 0x64, 0x64, 0x65, 0x39, 0x39, 0x33, 0x38, 0x33, 0x39, 0x66, 0x36, 0x31, 0x34, 0x63, 0x33, 0x64, 0x61, 0x63, 0x30, 0x61, 0x33, 0x65, 0x65, 0x33, 0x37, 0x35, 0x34, 0x33, 0x66, 0x39, 0x62, 0x34, 0x31, 0x32, 0x62, 0x31, 0x36, 0x31, 0x39, 0x39, 0x64, 0x63, 0x31, 0x35, 0x38, 0x65, 0x32, 0x33, 0x62, 0x35, 0x34, 0x34, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x31, 0x39, 0x65, 0x33, 0x31, 0x32, 0x37, 0x32, 0x34, 0x62, 0x62, 0x36, 0x64, 0x37, 0x63, 0x33, 0x31, 0x35, 0x33, 0x65, 0x64, 0x39, 0x64, 0x65, 0x37, 0x39, 0x31, 0x64, 0x37, 0x36, 0x34, 0x61, 0x33, 0x36, 0x36, 0x62, 0x33, 0x38, 0x39, 0x61, 0x66, 0x31, 0x33, 0x63, 0x35, 0x38, 0x62, 0x66, 0x38, 0x61, 0x38, 0x64, 0x39, 0x30, 0x34, 0x38, 0x31, 0x61, 0x34, 0x36, 0x37, 0x36, 0x35, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x63, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x63, 0x64, 0x64, 0x32, 0x39, 0x38, 0x36, 0x32, 0x36, 0x38, 0x32, 0x35, 0x30, 0x36, 0x32, 0x38, 0x64, 0x30, 0x63, 0x31, 0x30, 0x65, 0x33, 0x38, 0x35, 0x63, 0x35, 0x38, 0x63, 0x36, 0x31, 0x39, 0x31, 0x65, 0x36, 0x66, 0x62, 0x65, 0x30, 0x35, 0x31, 0x39, 0x31, 0x62, 0x63, 0x63, 0x30, 0x34, 0x66, 0x31, 0x33, 0x33, 0x66, 0x32, 0x63, 0x65, 0x61, 0x37, 0x32, 0x63, 0x31, 0x63, 0x34, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x34, 0x38, 0x39, 0x33, 0x30, 0x62, 0x64, 0x37, 0x62, 0x61, 0x38, 0x63, 0x61, 0x63, 0x35, 0x34, 0x36, 0x36, 0x31, 0x30, 0x37, 0x32, 0x31, 0x31, 0x33, 0x66, 0x62, 0x32, 0x37, 0x38, 0x38, 0x36, 0x39, 0x65, 0x30, 0x37, 0x62, 0x62, 0x38, 0x35, 0x38, 0x37, 0x66, 0x39, 0x31, 0x33, 0x39, 0x32, 0x39, 0x33, 0x33, 0x33, 0x37, 0x34, 0x64, 0x30, 0x31, 0x37, 0x62, 0x63, 0x62, 0x65, 0x31, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x38, 0x36, 0x39, 0x66, 0x66, 0x32, 0x63, 0x32, 0x32, 0x62, 0x32, 0x38, 0x63, 0x63, 0x31, 0x30, 0x35, 0x31, 0x30, 0x64, 0x39, 0x38, 0x35, 0x33, 0x32, 0x39, 0x32, 0x38, 0x30, 0x33, 0x33, 0x32, 0x38, 0x62, 0x65, 0x34, 0x66, 0x62, 0x30, 0x65, 0x38, 0x30, 0x34, 0x39, 0x35, 0x65, 0x38, 0x62, 0x62, 0x38, 0x64, 0x32, 0x37, 0x31, 0x66, 0x35, 0x62, 0x38, 0x38, 0x39, 0x36, 0x33, 0x36, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x66, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x35, 0x66, 0x65, 0x32, 0x38, 0x65, 0x37, 0x39, 0x66, 0x31, 0x62, 0x38, 0x35, 0x30, 0x66, 0x38, 0x36, 0x35, 0x38, 0x32, 0x34, 0x36, 0x63, 0x65, 0x39, 0x62, 0x36, 0x61, 0x31, 0x65, 0x37, 0x62, 0x34, 0x39, 0x66, 0x63, 0x30, 0x36, 0x64, 0x62, 0x37, 0x31, 0x34, 0x33, 0x65, 0x38, 0x66, 0x65, 0x30, 0x62, 0x34, 0x66, 0x32, 0x62, 0x30, 0x63, 0x35, 0x35, 0x32, 0x33, 0x61, 0x35, 0x63, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x35, 0x65, 0x39, 0x32, 0x39, 0x66, 0x37, 0x30, 0x61, 0x66, 0x32, 0x38, 0x64, 0x30, 0x62, 0x64, 0x64, 0x31, 0x61, 0x39, 0x30, 0x61, 0x38, 0x30, 0x38, 0x66, 0x39, 0x37, 0x37, 0x66, 0x35, 0x39, 0x37, 0x63, 0x37, 0x63, 0x37, 0x37, 0x38, 0x63, 0x34, 0x38, 0x39, 0x65, 0x39, 0x38, 0x64, 0x33, 0x62, 0x64, 0x38, 0x39, 0x31, 0x30, 0x64, 0x33, 0x31, 0x61, 0x63, 0x30, 0x66, 0x37, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x31, 0x36, 0x61, 0x38, 0x37, 0x62, 0x38, 0x32, 0x33, 0x33, 0x33, 0x66, 0x34, 0x32, 0x34, 0x35, 0x30, 0x34, 0x36, 0x36, 0x32, 0x33, 0x62, 0x32, 0x33, 0x37, 0x39, 0x34, 0x43, 0x36, 0x35, 0x43, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x62, 0x65, 0x39, 0x34, 0x39, 0x39, 0x32, 0x38, 0x46, 0x66, 0x31, 0x39, 0x39, 0x63, 0x39, 0x45, 0x42, 0x41, 0x39, 0x45, 0x31, 0x31, 0x30, 0x64, 0x62, 0x32, 0x31, 0x30, 0x41, 0x41, 0x35, 0x43, 0x39, 0x34, 0x45, 0x46, 0x41, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x63, 0x31, 0x33, 0x62, 0x63, 0x34, 0x62, 0x32, 0x63, 0x31, 0x33, 0x33, 0x63, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x43, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x37, 0x62, 0x35, 0x65, 0x32, 0x33, 0x61, 0x31, 0x65, 0x41, 0x45, 0x45, 0x36, 0x33, 0x37, 0x66, 0x32, 0x38, 0x63, 0x41, 0x33, 0x32, 0x43, 0x64, 0x35, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x43, 0x33, 0x35, 0x33, 0x31, 0x37, 0x42, 0x37, 0x61, 0x39, 0x36, 0x43, 0x34, 0x35, 0x34, 0x45, 0x32, 0x43, 0x42, 0x33, 0x64, 0x31, 0x41, 0x32, 0x35, 0x35, 0x44, 0x37, 0x37, 0x35, 0x41, 0x62, 0x31, 0x31, 0x32, 0x63, 0x43, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x64, 0x37, 0x33, 0x31, 0x63, 0x66, 0x61, 0x62, 0x43, 0x35, 0x35, 0x37, 0x34, 0x33, 0x32, 0x39, 0x38, 0x32, 0x33, 0x46, 0x32, 0x36, 0x64, 0x34, 0x38, 0x38, 0x34, 0x31, 0x36, 0x34, 0x35, 0x31, 0x64, 0x32, 0x65, 0x61, 0x33, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x65, 0x37, 0x39, 0x30, 0x36, 0x35, 0x42, 0x35, 0x46, 0x31, 0x31, 0x62, 0x35, 0x42, 0x44, 0x31, 0x65, 0x36, 0x32, 0x42, 0x39, 0x33, 0x35, 0x41, 0x36, 0x30, 0x30, 0x39, 0x37, 0x36, 0x66, 0x66, 0x46, 0x33, 0x37, 0x35, 0x34, 0x42, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x30, 0x35, 0x30, 0x38, 0x33, 0x39, 0x32, 0x39, 0x62, 0x46, 0x39, 0x62, 0x62, 0x32, 0x32, 0x43, 0x32, 0x36, 0x63, 0x42, 0x31, 0x37, 0x37, 0x37, 0x45, 0x63, 0x39, 0x32, 0x36, 0x36, 0x31, 0x31, 0x37, 0x30, 0x44, 0x34, 0x32, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x30, 0x46, 0x35, 0x64, 0x34, 0x35, 0x38, 0x35, 0x34, 0x65, 0x30, 0x33, 0x38, 0x30, 0x37, 0x31, 0x34, 0x38, 0x35, 0x41, 0x43, 0x39, 0x65, 0x34, 0x30, 0x32, 0x33, 0x30, 0x38, 0x63, 0x46, 0x38, 0x30, 0x44, 0x32, 0x64, 0x32, 0x66, 0x45, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x32, 0x36, 0x38, 0x41, 0x44, 0x31, 0x38, 0x39, 0x35, 0x32, 0x36, 0x41, 0x43, 0x30, 0x62, 0x33, 0x38, 0x36, 0x66, 0x61, 0x46, 0x30, 0x36, 0x65, 0x46, 0x66, 0x43, 0x34, 0x36, 0x37, 0x37, 0x39, 0x63, 0x33, 0x34, 0x30, 0x65, 0x45, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x32, 0x43, 0x62, 0x61, 0x35, 0x39, 0x66, 0x35, 0x41, 0x37, 0x34, 0x44, 0x42, 0x38, 0x31, 0x61, 0x31, 0x32, 0x66, 0x66, 0x36, 0x33, 0x43, 0x33, 0x34, 0x39, 0x42, 0x64, 0x38, 0x32, 0x43, 0x42, 0x46, 0x36, 0x30, 0x30, 0x37, 0x43, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x34, 0x34, 0x36, 0x44, 0x37, 0x66, 0x36, 0x64, 0x46, 0x30, 0x30, 0x33, 0x38, 0x30, 0x46, 0x32, 0x34, 0x36, 0x64, 0x38, 0x32, 0x31, 0x31, 0x64, 0x45, 0x37, 0x66, 0x30, 0x46, 0x61, 0x42, 0x43, 0x34, 0x46, 0x64, 0x32, 0x34, 0x38, 0x43, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x36, 0x34, 0x65, 0x33, 0x38, 0x61, 0x33, 0x37, 0x35, 0x32, 0x34, 0x37, 0x41, 0x37, 0x38, 0x34, 0x41, 0x38, 0x31, 0x64, 0x34, 0x32, 0x30, 0x32, 0x30, 0x31, 0x41, 0x41, 0x38, 0x66, 0x65, 0x34, 0x45, 0x35, 0x31, 0x33, 0x39, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x42, 0x37, 0x61, 0x41, 0x34, 0x34, 0x30, 0x38, 0x38, 0x61, 0x30, 0x65, 0x41, 0x39, 0x35, 0x62, 0x64, 0x63, 0x36, 0x35, 0x66, 0x65, 0x66, 0x36, 0x45, 0x35, 0x30, 0x37, 0x31, 0x45, 0x39, 0x34, 0x36, 0x42, 0x66, 0x37, 0x64, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x63, 0x46, 0x36, 0x34, 0x61, 0x37, 0x36, 0x41, 0x45, 0x33, 0x64, 0x33, 0x36, 0x38, 0x35, 0x39, 0x39, 0x35, 0x38, 0x63, 0x38, 0x36, 0x34, 0x66, 0x44, 0x41, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x32, 0x66, 0x31, 0x34, 0x35, 0x38, 0x32, 0x39, 0x34, 0x37, 0x45, 0x32, 0x39, 0x32, 0x61, 0x32, 0x65, 0x43, 0x64, 0x32, 0x30, 0x43, 0x34, 0x33, 0x30, 0x42, 0x34, 0x36, 0x66, 0x32, 0x64, 0x32, 0x37, 0x43, 0x46, 0x45, 0x32, 0x31, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x32, 0x66, 0x32, 0x63, 0x37, 0x35, 0x42, 0x35, 0x44, 0x64, 0x35, 0x44, 0x32, 0x34, 0x36, 0x31, 0x39, 0x34, 0x38, 0x31, 0x32, 0x62, 0x30, 0x30, 0x65, 0x45, 0x62, 0x33, 0x42, 0x30, 0x39, 0x63, 0x32, 0x63, 0x36, 0x36, 0x65, 0x32, 0x65, 0x45, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x33, 0x34, 0x31, 0x63, 0x34, 0x30, 0x62, 0x39, 0x34, 0x62, 0x66, 0x32, 0x61, 0x66, 0x62, 0x66, 0x61, 0x34, 0x32, 0x35, 0x37, 0x33, 0x63, 0x62, 0x37, 0x38, 0x66, 0x31, 0x36, 0x65, 0x65, 0x31, 0x35, 0x61, 0x30, 0x35, 0x36, 0x32, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x33, 0x34, 0x66, 0x38, 0x34, 0x35, 0x37, 0x37, 0x33, 0x44, 0x34, 0x33, 0x36, 0x34, 0x39, 0x39, 0x39, 0x66, 0x32, 0x66, 0x62, 0x43, 0x37, 0x41, 0x41, 0x32, 0x36, 0x41, 0x42, 0x44, 0x65, 0x45, 0x39, 0x30, 0x32, 0x63, 0x42, 0x62, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x33, 0x43, 0x37, 0x35, 0x35, 0x39, 0x34, 0x31, 0x38, 0x31, 0x65, 0x30, 0x33, 0x45, 0x38, 0x45, 0x43, 0x44, 0x38, 0x34, 0x36, 0x38, 0x41, 0x30, 0x30, 0x33, 0x37, 0x46, 0x30, 0x35, 0x38, 0x61, 0x39, 0x64, 0x41, 0x66, 0x61, 0x64, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x34, 0x36, 0x32, 0x33, 0x39, 0x36, 0x45, 0x36, 0x39, 0x64, 0x42, 0x66, 0x61, 0x34, 0x35, 0x35, 0x46, 0x34, 0x30, 0x35, 0x66, 0x34, 0x44, 0x44, 0x38, 0x32, 0x46, 0x33, 0x30, 0x31, 0x34, 0x41, 0x66, 0x38, 0x30, 0x30, 0x33, 0x42, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x36, 0x66, 0x61, 0x35, 0x62, 0x39, 0x39, 0x30, 0x31, 0x39, 0x61, 0x35, 0x63, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x34, 0x39, 0x44, 0x66, 0x33, 0x43, 0x43, 0x61, 0x32, 0x36, 0x37, 0x30, 0x65, 0x42, 0x30, 0x44, 0x35, 0x39, 0x31, 0x31, 0x34, 0x36, 0x42, 0x31, 0x36, 0x33, 0x35, 0x39, 0x66, 0x65, 0x33, 0x33, 0x36, 0x65, 0x34, 0x37, 0x36, 0x46, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x34, 0x44, 0x30, 0x62, 0x30, 0x34, 0x62, 0x34, 0x30, 0x35, 0x63, 0x36, 0x62, 0x36, 0x32, 0x43, 0x37, 0x63, 0x46, 0x43, 0x33, 0x61, 0x45, 0x35, 0x34, 0x37, 0x35, 0x39, 0x37, 0x34, 0x37, 0x65, 0x32, 0x43, 0x30, 0x62, 0x34, 0x36, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x34, 0x44, 0x34, 0x39, 0x36, 0x43, 0x63, 0x43, 0x32, 0x38, 0x30, 0x35, 0x38, 0x42, 0x31, 0x44, 0x37, 0x34, 0x42, 0x37, 0x61, 0x31, 0x39, 0x35, 0x34, 0x31, 0x36, 0x36, 0x33, 0x45, 0x32, 0x31, 0x31, 0x35, 0x34, 0x66, 0x39, 0x63, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x35, 0x30, 0x39, 0x61, 0x37, 0x36, 0x36, 0x37, 0x61, 0x43, 0x38, 0x44, 0x30, 0x33, 0x32, 0x30, 0x65, 0x33, 0x36, 0x31, 0x37, 0x32, 0x63, 0x31, 0x39, 0x32, 0x35, 0x30, 0x36, 0x61, 0x36, 0x31, 0x38, 0x38, 0x61, 0x41, 0x38, 0x34, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x63, 0x31, 0x33, 0x62, 0x63, 0x34, 0x62, 0x32, 0x63, 0x31, 0x33, 0x33, 0x63, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x35, 0x31, 0x38, 0x30, 0x64, 0x62, 0x30, 0x32, 0x33, 0x37, 0x32, 0x39, 0x31, 0x41, 0x36, 0x34, 0x34, 0x39, 0x44, 0x64, 0x41, 0x39, 0x65, 0x64, 0x33, 0x33, 0x61, 0x44, 0x39, 0x30, 0x61, 0x33, 0x38, 0x37, 0x38, 0x37, 0x36, 0x32, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x35, 0x32, 0x37, 0x33, 0x30, 0x66, 0x33, 0x34, 0x37, 0x64, 0x45, 0x66, 0x36, 0x42, 0x41, 0x30, 0x39, 0x61, 0x64, 0x66, 0x46, 0x36, 0x32, 0x45, 0x61, 0x43, 0x36, 0x30, 0x44, 0x35, 0x66, 0x45, 0x65, 0x38, 0x32, 0x30, 0x35, 0x42, 0x43, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x35, 0x45, 0x41, 0x43, 0x30, 0x66, 0x42, 0x64, 0x33, 0x64, 0x66, 0x65, 0x66, 0x38, 0x61, 0x45, 0x33, 0x65, 0x66, 0x61, 0x33, 0x63, 0x35, 0x64, 0x63, 0x31, 0x61, 0x61, 0x31, 0x39, 0x33, 0x62, 0x63, 0x36, 0x30, 0x33, 0x33, 0x64, 0x46, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x36, 0x61, 0x37, 0x61, 0x41, 0x39, 0x62, 0x38, 0x38, 0x32, 0x64, 0x35, 0x30, 0x42, 0x62, 0x37, 0x62, 0x63, 0x35, 0x44, 0x61, 0x31, 0x61, 0x32, 0x34, 0x34, 0x37, 0x31, 0x39, 0x43, 0x39, 0x39, 0x66, 0x31, 0x32, 0x46, 0x30, 0x36, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x36, 0x43, 0x63, 0x39, 0x33, 0x39, 0x37, 0x63, 0x33, 0x42, 0x33, 0x38, 0x37, 0x33, 0x39, 0x64, 0x61, 0x43, 0x62, 0x66, 0x61, 0x41, 0x36, 0x38, 0x45, 0x61, 0x44, 0x35, 0x46, 0x35, 0x44, 0x37, 0x37, 0x42, 0x61, 0x35, 0x46, 0x34, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x37, 0x36, 0x32, 0x63, 0x41, 0x36, 0x32, 0x63, 0x61, 0x32, 0x35, 0x34, 0x39, 0x61, 0x64, 0x38, 0x30, 0x36, 0x37, 0x36, 0x33, 0x42, 0x33, 0x41, 0x61, 0x31, 0x65, 0x41, 0x33, 0x31, 0x37, 0x63, 0x34, 0x32, 0x39, 0x62, 0x44, 0x42, 0x44, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x37, 0x37, 0x38, 0x46, 0x35, 0x46, 0x31, 0x33, 0x43, 0x34, 0x42, 0x65, 0x37, 0x38, 0x41, 0x33, 0x61, 0x34, 0x64, 0x37, 0x31, 0x34, 0x31, 0x42, 0x43, 0x42, 0x32, 0x36, 0x39, 0x39, 0x39, 0x37, 0x30, 0x32, 0x66, 0x34, 0x30, 0x37, 0x43, 0x46, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x38, 0x37, 0x35, 0x44, 0x32, 0x35, 0x45, 0x65, 0x34, 0x62, 0x43, 0x36, 0x30, 0x34, 0x43, 0x37, 0x31, 0x42, 0x61, 0x46, 0x36, 0x32, 0x33, 0x36, 0x61, 0x38, 0x34, 0x38, 0x38, 0x46, 0x32, 0x32, 0x33, 0x39, 0x39, 0x42, 0x45, 0x44, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x38, 0x64, 0x46, 0x37, 0x38, 0x37, 0x38, 0x64, 0x33, 0x35, 0x37, 0x31, 0x42, 0x45, 0x46, 0x35, 0x65, 0x35, 0x61, 0x37, 0x34, 0x34, 0x46, 0x39, 0x36, 0x32, 0x38, 0x37, 0x43, 0x38, 0x44, 0x32, 0x30, 0x33, 0x38, 0x36, 0x64, 0x37, 0x35, 0x41, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x39, 0x45, 0x34, 0x31, 0x35, 0x41, 0x30, 0x39, 0x36, 0x66, 0x46, 0x37, 0x37, 0x36, 0x35, 0x30, 0x64, 0x63, 0x39, 0x32, 0x35, 0x64, 0x45, 0x41, 0x35, 0x34, 0x36, 0x35, 0x38, 0x35, 0x42, 0x34, 0x61, 0x64, 0x42, 0x33, 0x32, 0x32, 0x42, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x41, 0x30, 0x37, 0x36, 0x36, 0x42, 0x36, 0x35, 0x41, 0x34, 0x66, 0x37, 0x42, 0x31, 0x64, 0x61, 0x37, 0x39, 0x61, 0x31, 0x41, 0x46, 0x37, 0x39, 0x61, 0x43, 0x36, 0x39, 0x35, 0x34, 0x35, 0x36, 0x65, 0x46, 0x61, 0x32, 0x38, 0x36, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x41, 0x32, 0x39, 0x42, 0x31, 0x34, 0x34, 0x41, 0x34, 0x34, 0x39, 0x45, 0x34, 0x31, 0x34, 0x41, 0x34, 0x37, 0x32, 0x63, 0x36, 0x30, 0x43, 0x37, 0x41, 0x41, 0x66, 0x31, 0x61, 0x61, 0x46, 0x66, 0x45, 0x33, 0x32, 0x39, 0x30, 0x32, 0x31, 0x44, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x61, 0x35, 0x35, 0x33, 0x39, 0x35, 0x35, 0x36, 0x36, 0x62, 0x30, 0x62, 0x35, 0x34, 0x33, 0x39, 0x35, 0x42, 0x33, 0x32, 0x34, 0x36, 0x66, 0x39, 0x36, 0x41, 0x30, 0x62, 0x44, 0x63, 0x34, 0x62, 0x38, 0x61, 0x34, 0x38, 0x33, 0x64, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x41, 0x43, 0x39, 0x62, 0x61, 0x37, 0x32, 0x66, 0x62, 0x36, 0x31, 0x61, 0x41, 0x37, 0x63, 0x33, 0x31, 0x41, 0x39, 0x35, 0x64, 0x66, 0x30, 0x41, 0x38, 0x62, 0x36, 0x65, 0x62, 0x41, 0x36, 0x66, 0x34, 0x31, 0x45, 0x46, 0x38, 0x37, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x42, 0x30, 0x34, 0x39, 0x38, 0x43, 0x31, 0x35, 0x38, 0x37, 0x39, 0x64, 0x62, 0x32, 0x65, 0x45, 0x35, 0x34, 0x37, 0x31, 0x64, 0x34, 0x39, 0x32, 0x36, 0x63, 0x35, 0x66, 0x41, 0x41, 0x32, 0x35, 0x43, 0x39, 0x61, 0x30, 0x39, 0x36, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x42, 0x31, 0x39, 0x46, 0x62, 0x34, 0x63, 0x31, 0x66, 0x32, 0x38, 0x30, 0x33, 0x32, 0x37, 0x65, 0x36, 0x30, 0x45, 0x64, 0x33, 0x37, 0x62, 0x31, 0x44, 0x63, 0x36, 0x45, 0x45, 0x37, 0x37, 0x35, 0x33, 0x33, 0x35, 0x33, 0x39, 0x33, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x43, 0x32, 0x31, 0x63, 0x42, 0x39, 0x43, 0x39, 0x39, 0x43, 0x33, 0x31, 0x36, 0x64, 0x31, 0x38, 0x36, 0x33, 0x31, 0x34, 0x32, 0x46, 0x37, 0x64, 0x44, 0x38, 0x36, 0x64, 0x64, 0x35, 0x34, 0x39, 0x36, 0x44, 0x38, 0x31, 0x41, 0x38, 0x44, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x63, 0x34, 0x37, 0x33, 0x64, 0x34, 0x31, 0x32, 0x64, 0x63, 0x35, 0x32, 0x65, 0x33, 0x34, 0x39, 0x38, 0x36, 0x32, 0x32, 0x30, 0x39, 0x39, 0x32, 0x34, 0x63, 0x38, 0x39, 0x38, 0x31, 0x62, 0x32, 0x65, 0x65, 0x34, 0x32, 0x30, 0x37, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x43, 0x34, 0x38, 0x45, 0x32, 0x33, 0x43, 0x35, 0x46, 0x36, 0x65, 0x31, 0x65, 0x41, 0x30, 0x42, 0x61, 0x45, 0x66, 0x36, 0x35, 0x33, 0x30, 0x37, 0x33, 0x34, 0x65, 0x64, 0x43, 0x33, 0x39, 0x36, 0x38, 0x66, 0x37, 0x39, 0x41, 0x66, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x63, 0x36, 0x65, 0x32, 0x34, 0x35, 0x39, 0x39, 0x39, 0x31, 0x42, 0x66, 0x45, 0x32, 0x37, 0x63, 0x63, 0x61, 0x36, 0x64, 0x38, 0x36, 0x37, 0x32, 0x32, 0x46, 0x33, 0x35, 0x64, 0x61, 0x32, 0x33, 0x41, 0x31, 0x45, 0x34, 0x43, 0x62, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x44, 0x33, 0x39, 0x39, 0x34, 0x65, 0x34, 0x64, 0x33, 0x32, 0x30, 0x32, 0x64, 0x44, 0x32, 0x33, 0x63, 0x38, 0x34, 0x39, 0x37, 0x64, 0x37, 0x46, 0x37, 0x35, 0x62, 0x46, 0x31, 0x36, 0x34, 0x37, 0x64, 0x31, 0x44, 0x41, 0x31, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x39, 0x44, 0x39, 0x37, 0x31, 0x45, 0x34, 0x46, 0x45, 0x38, 0x34, 0x30, 0x31, 0x45, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x44, 0x43, 0x41, 0x36, 0x65, 0x39, 0x42, 0x34, 0x38, 0x45, 0x61, 0x38, 0x36, 0x41, 0x65, 0x42, 0x46, 0x44, 0x66, 0x39, 0x39, 0x32, 0x39, 0x39, 0x34, 0x39, 0x31, 0x32, 0x34, 0x30, 0x34, 0x32, 0x32, 0x39, 0x36, 0x62, 0x36, 0x65, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x65, 0x30, 0x61, 0x32, 0x42, 0x64, 0x34, 0x32, 0x35, 0x38, 0x44, 0x32, 0x37, 0x36, 0x38, 0x38, 0x33, 0x37, 0x42, 0x41, 0x61, 0x32, 0x36, 0x41, 0x32, 0x38, 0x66, 0x45, 0x37, 0x31, 0x44, 0x63, 0x30, 0x37, 0x39, 0x66, 0x38, 0x34, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x45, 0x41, 0x32, 0x38, 0x64, 0x30, 0x30, 0x32, 0x30, 0x34, 0x32, 0x66, 0x64, 0x39, 0x38, 0x39, 0x38, 0x44, 0x30, 0x44, 0x62, 0x30, 0x31, 0x36, 0x62, 0x65, 0x39, 0x37, 0x35, 0x38, 0x65, 0x65, 0x41, 0x46, 0x45, 0x33, 0x35, 0x43, 0x31, 0x45, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x45, 0x66, 0x41, 0x37, 0x34, 0x35, 0x34, 0x66, 0x31, 0x31, 0x31, 0x36, 0x38, 0x30, 0x37, 0x39, 0x37, 0x35, 0x41, 0x34, 0x37, 0x35, 0x30, 0x42, 0x34, 0x36, 0x36, 0x39, 0x35, 0x45, 0x39, 0x36, 0x37, 0x38, 0x35, 0x30, 0x64, 0x65, 0x35, 0x44, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x46, 0x42, 0x46, 0x64, 0x36, 0x46, 0x61, 0x39, 0x46, 0x37, 0x33, 0x41, 0x63, 0x36, 0x41, 0x30, 0x35, 0x38, 0x45, 0x30, 0x31, 0x32, 0x35, 0x39, 0x30, 0x33, 0x34, 0x43, 0x32, 0x38, 0x30, 0x30, 0x31, 0x42, 0x45, 0x66, 0x38, 0x32, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x65, 0x30, 0x39, 0x39, 0x31, 0x45, 0x38, 0x34, 0x34, 0x30, 0x34, 0x31, 0x62, 0x45, 0x36, 0x46, 0x31, 0x31, 0x42, 0x39, 0x39, 0x64, 0x61, 0x35, 0x62, 0x31, 0x31, 0x34, 0x62, 0x36, 0x62, 0x43, 0x66, 0x38, 0x34, 0x45, 0x42, 0x64, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x35, 0x45, 0x37, 0x31, 0x39, 0x62, 0x36, 0x41, 0x63, 0x41, 0x66, 0x31, 0x45, 0x34, 0x34, 0x31, 0x31, 0x42, 0x66, 0x30, 0x66, 0x39, 0x35, 0x37, 0x36, 0x43, 0x42, 0x31, 0x44, 0x30, 0x64, 0x42, 0x31, 0x36, 0x31, 0x44, 0x64, 0x46, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x33, 0x34, 0x36, 0x44, 0x38, 0x32, 0x37, 0x61, 0x37, 0x35, 0x46, 0x39, 0x38, 0x46, 0x30, 0x41, 0x37, 0x61, 0x33, 0x32, 0x34, 0x46, 0x66, 0x38, 0x30, 0x62, 0x37, 0x43, 0x33, 0x46, 0x39, 0x30, 0x32, 0x35, 0x32, 0x45, 0x38, 0x62, 0x61, 0x43, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x37, 0x33, 0x62, 0x32, 0x65, 0x30, 0x45, 0x35, 0x34, 0x35, 0x31, 0x30, 0x32, 0x33, 0x39, 0x45, 0x32, 0x32, 0x63, 0x43, 0x39, 0x33, 0x36, 0x46, 0x30, 0x62, 0x34, 0x61, 0x36, 0x64, 0x45, 0x31, 0x61, 0x63, 0x66, 0x30, 0x41, 0x62, 0x64, 0x45, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x62, 0x37, 0x64, 0x32, 0x64, 0x63, 0x63, 0x38, 0x30, 0x63, 0x64, 0x32, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x42, 0x62, 0x39, 0x37, 0x37, 0x42, 0x32, 0x45, 0x45, 0x38, 0x61, 0x31, 0x31, 0x31, 0x44, 0x37, 0x38, 0x38, 0x42, 0x33, 0x34, 0x37, 0x37, 0x44, 0x32, 0x34, 0x32, 0x30, 0x37, 0x38, 0x64, 0x30, 0x42, 0x38, 0x33, 0x37, 0x45, 0x37, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x38, 0x33, 0x34, 0x44, 0x62, 0x66, 0x35, 0x41, 0x30, 0x33, 0x65, 0x32, 0x39, 0x63, 0x32, 0x35, 0x62, 0x63, 0x35, 0x35, 0x34, 0x35, 0x39, 0x63, 0x43, 0x65, 0x39, 0x63, 0x30, 0x32, 0x31, 0x45, 0x65, 0x42, 0x45, 0x36, 0x37, 0x36, 0x41, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x44, 0x31, 0x46, 0x37, 0x37, 0x45, 0x34, 0x43, 0x31, 0x43, 0x34, 0x35, 0x31, 0x38, 0x36, 0x65, 0x38, 0x36, 0x35, 0x33, 0x43, 0x34, 0x38, 0x39, 0x46, 0x39, 0x30, 0x65, 0x30, 0x30, 0x38, 0x61, 0x37, 0x33, 0x35, 0x39, 0x37, 0x32, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x62, 0x30, 0x34, 0x61, 0x65, 0x46, 0x32, 0x61, 0x33, 0x64, 0x32, 0x44, 0x38, 0x36, 0x42, 0x30, 0x31, 0x30, 0x30, 0x36, 0x63, 0x43, 0x44, 0x34, 0x33, 0x33, 0x39, 0x41, 0x32, 0x65, 0x39, 0x34, 0x33, 0x64, 0x39, 0x63, 0x36, 0x34, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x43, 0x39, 0x43, 0x41, 0x32, 0x62, 0x41, 0x39, 0x41, 0x32, 0x37, 0x44, 0x65, 0x31, 0x44, 0x62, 0x35, 0x38, 0x39, 0x64, 0x38, 0x63, 0x33, 0x33, 0x41, 0x62, 0x38, 0x45, 0x44, 0x46, 0x61, 0x32, 0x31, 0x31, 0x31, 0x62, 0x33, 0x31, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x33, 0x63, 0x32, 0x31, 0x62, 0x63, 0x65, 0x63, 0x63, 0x65, 0x64, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x34, 0x42, 0x43, 0x36, 0x35, 0x36, 0x42, 0x33, 0x34, 0x44, 0x65, 0x32, 0x33, 0x38, 0x39, 0x36, 0x66, 0x61, 0x36, 0x30, 0x36, 0x39, 0x43, 0x39, 0x38, 0x36, 0x32, 0x46, 0x33, 0x35, 0x35, 0x62, 0x37, 0x34, 0x30, 0x34, 0x30, 0x31, 0x61, 0x46, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x38, 0x34, 0x35, 0x39, 0x35, 0x31, 0x36, 0x31, 0x34, 0x30, 0x31, 0x34, 0x38, 0x34, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x31, 0x37, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x68, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x30, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x35, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x62, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x70, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62, 0x75, 0x72, 0x67, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x62, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x50, 0x61, 0x73, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x31, 0x36, 0x39, 0x36, 0x30, 0x30, 0x30, 0x37, 0x30, 0x34, 0x2c, 0x22, 0x70, 0x72, 0x61, 0x67, 0x75, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x31, 0x37, 0x34, 0x30, 0x34, 0x33, 0x34, 0x31, 0x31, 0x32, 0x2c, 0x22, 0x63, 0x61, 0x6e, 0x63, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x20, 0x31, 0x37, 0x30, 0x37, 0x33, 0x30, 0x35, 0x36, 0x36, 0x34, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x31, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x31, 0x37, 0x44, 0x37, 0x38, 0x34, 0x30, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x32, 0x33, 0x34, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x35, 0x31, 0x35, 0x36, 0x39, 0x39, 0x34, 0x22, 0x7d }; namespace silkworm { constinit const std::string_view kGenesisHoleskyJson{&kGenesisHoleskyDataInternal[0], sizeof(kGenesisHoleskyDataInternal)}; } ================================================ FILE: silkworm/core/chain/genesis_holesky.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { constinit extern const std::string_view kGenesisHoleskyJson; } ================================================ FILE: silkworm/core/chain/genesis_holesky.json ================================================ { "alloc": { "0x0000000000000000000000000000000000000000": { "balance": "0x1" }, "0x0000000000000000000000000000000000000001": { "balance": "0x1" }, "0x0000000000000000000000000000000000000002": { "balance": "0x1" }, "0x0000000000000000000000000000000000000003": { "balance": "0x1" }, "0x0000000000000000000000000000000000000004": { "balance": "0x1" }, "0x0000000000000000000000000000000000000005": { "balance": "0x1" }, "0x0000000000000000000000000000000000000006": { "balance": "0x1" }, "0x0000000000000000000000000000000000000007": { "balance": "0x1" }, "0x0000000000000000000000000000000000000008": { "balance": "0x1" }, "0x0000000000000000000000000000000000000009": { "balance": "0x1" }, "0x000000000000000000000000000000000000000a": { "balance": "0x1" }, "0x000000000000000000000000000000000000000b": { "balance": "0x1" }, "0x000000000000000000000000000000000000000c": { "balance": "0x1" }, "0x000000000000000000000000000000000000000d": { "balance": "0x1" }, "0x000000000000000000000000000000000000000e": { "balance": "0x1" }, "0x000000000000000000000000000000000000000f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000010": { "balance": "0x1" }, "0x0000000000000000000000000000000000000011": { "balance": "0x1" }, "0x0000000000000000000000000000000000000012": { "balance": "0x1" }, "0x0000000000000000000000000000000000000013": { "balance": "0x1" }, "0x0000000000000000000000000000000000000014": { "balance": "0x1" }, "0x0000000000000000000000000000000000000015": { "balance": "0x1" }, "0x0000000000000000000000000000000000000016": { "balance": "0x1" }, "0x0000000000000000000000000000000000000017": { "balance": "0x1" }, "0x0000000000000000000000000000000000000018": { "balance": "0x1" }, "0x0000000000000000000000000000000000000019": { "balance": "0x1" }, "0x000000000000000000000000000000000000001a": { "balance": "0x1" }, "0x000000000000000000000000000000000000001b": { "balance": "0x1" }, "0x000000000000000000000000000000000000001c": { "balance": "0x1" }, "0x000000000000000000000000000000000000001d": { "balance": "0x1" }, "0x000000000000000000000000000000000000001e": { "balance": "0x1" }, "0x000000000000000000000000000000000000001f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000020": { "balance": "0x1" }, "0x0000000000000000000000000000000000000021": { "balance": "0x1" }, "0x0000000000000000000000000000000000000022": { "balance": "0x1" }, "0x0000000000000000000000000000000000000023": { "balance": "0x1" }, "0x0000000000000000000000000000000000000024": { "balance": "0x1" }, "0x0000000000000000000000000000000000000025": { "balance": "0x1" }, "0x0000000000000000000000000000000000000026": { "balance": "0x1" }, "0x0000000000000000000000000000000000000027": { "balance": "0x1" }, "0x0000000000000000000000000000000000000028": { "balance": "0x1" }, "0x0000000000000000000000000000000000000029": { "balance": "0x1" }, "0x000000000000000000000000000000000000002a": { "balance": "0x1" }, "0x000000000000000000000000000000000000002b": { "balance": "0x1" }, "0x000000000000000000000000000000000000002c": { "balance": "0x1" }, "0x000000000000000000000000000000000000002d": { "balance": "0x1" }, "0x000000000000000000000000000000000000002e": { "balance": "0x1" }, "0x000000000000000000000000000000000000002f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000030": { "balance": "0x1" }, "0x0000000000000000000000000000000000000031": { "balance": "0x1" }, "0x0000000000000000000000000000000000000032": { "balance": "0x1" }, "0x0000000000000000000000000000000000000033": { "balance": "0x1" }, "0x0000000000000000000000000000000000000034": { "balance": "0x1" }, "0x0000000000000000000000000000000000000035": { "balance": "0x1" }, "0x0000000000000000000000000000000000000036": { "balance": "0x1" }, "0x0000000000000000000000000000000000000037": { "balance": "0x1" }, "0x0000000000000000000000000000000000000038": { "balance": "0x1" }, "0x0000000000000000000000000000000000000039": { "balance": "0x1" }, "0x000000000000000000000000000000000000003a": { "balance": "0x1" }, "0x000000000000000000000000000000000000003b": { "balance": "0x1" }, "0x000000000000000000000000000000000000003c": { "balance": "0x1" }, "0x000000000000000000000000000000000000003d": { "balance": "0x1" }, "0x000000000000000000000000000000000000003e": { "balance": "0x1" }, "0x000000000000000000000000000000000000003f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000040": { "balance": "0x1" }, "0x0000000000000000000000000000000000000041": { "balance": "0x1" }, "0x0000000000000000000000000000000000000042": { "balance": "0x1" }, "0x0000000000000000000000000000000000000043": { "balance": "0x1" }, "0x0000000000000000000000000000000000000044": { "balance": "0x1" }, "0x0000000000000000000000000000000000000045": { "balance": "0x1" }, "0x0000000000000000000000000000000000000046": { "balance": "0x1" }, "0x0000000000000000000000000000000000000047": { "balance": "0x1" }, "0x0000000000000000000000000000000000000048": { "balance": "0x1" }, "0x0000000000000000000000000000000000000049": { "balance": "0x1" }, "0x000000000000000000000000000000000000004a": { "balance": "0x1" }, "0x000000000000000000000000000000000000004b": { "balance": "0x1" }, "0x000000000000000000000000000000000000004c": { "balance": "0x1" }, "0x000000000000000000000000000000000000004d": { "balance": "0x1" }, "0x000000000000000000000000000000000000004e": { "balance": "0x1" }, "0x000000000000000000000000000000000000004f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000050": { "balance": "0x1" }, "0x0000000000000000000000000000000000000051": { "balance": "0x1" }, "0x0000000000000000000000000000000000000052": { "balance": "0x1" }, "0x0000000000000000000000000000000000000053": { "balance": "0x1" }, "0x0000000000000000000000000000000000000054": { "balance": "0x1" }, "0x0000000000000000000000000000000000000055": { "balance": "0x1" }, "0x0000000000000000000000000000000000000056": { "balance": "0x1" }, "0x0000000000000000000000000000000000000057": { "balance": "0x1" }, "0x0000000000000000000000000000000000000058": { "balance": "0x1" }, "0x0000000000000000000000000000000000000059": { "balance": "0x1" }, "0x000000000000000000000000000000000000005a": { "balance": "0x1" }, "0x000000000000000000000000000000000000005b": { "balance": "0x1" }, "0x000000000000000000000000000000000000005c": { "balance": "0x1" }, "0x000000000000000000000000000000000000005d": { "balance": "0x1" }, "0x000000000000000000000000000000000000005e": { "balance": "0x1" }, "0x000000000000000000000000000000000000005f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000060": { "balance": "0x1" }, "0x0000000000000000000000000000000000000061": { "balance": "0x1" }, "0x0000000000000000000000000000000000000062": { "balance": "0x1" }, "0x0000000000000000000000000000000000000063": { "balance": "0x1" }, "0x0000000000000000000000000000000000000064": { "balance": "0x1" }, "0x0000000000000000000000000000000000000065": { "balance": "0x1" }, "0x0000000000000000000000000000000000000066": { "balance": "0x1" }, "0x0000000000000000000000000000000000000067": { "balance": "0x1" }, "0x0000000000000000000000000000000000000068": { "balance": "0x1" }, "0x0000000000000000000000000000000000000069": { "balance": "0x1" }, "0x000000000000000000000000000000000000006a": { "balance": "0x1" }, "0x000000000000000000000000000000000000006b": { "balance": "0x1" }, "0x000000000000000000000000000000000000006c": { "balance": "0x1" }, "0x000000000000000000000000000000000000006d": { "balance": "0x1" }, "0x000000000000000000000000000000000000006e": { "balance": "0x1" }, "0x000000000000000000000000000000000000006f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000070": { "balance": "0x1" }, "0x0000000000000000000000000000000000000071": { "balance": "0x1" }, "0x0000000000000000000000000000000000000072": { "balance": "0x1" }, "0x0000000000000000000000000000000000000073": { "balance": "0x1" }, "0x0000000000000000000000000000000000000074": { "balance": "0x1" }, "0x0000000000000000000000000000000000000075": { "balance": "0x1" }, "0x0000000000000000000000000000000000000076": { "balance": "0x1" }, "0x0000000000000000000000000000000000000077": { "balance": "0x1" }, "0x0000000000000000000000000000000000000078": { "balance": "0x1" }, "0x0000000000000000000000000000000000000079": { "balance": "0x1" }, "0x000000000000000000000000000000000000007a": { "balance": "0x1" }, "0x000000000000000000000000000000000000007b": { "balance": "0x1" }, "0x000000000000000000000000000000000000007c": { "balance": "0x1" }, "0x000000000000000000000000000000000000007d": { "balance": "0x1" }, "0x000000000000000000000000000000000000007e": { "balance": "0x1" }, "0x000000000000000000000000000000000000007f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000080": { "balance": "0x1" }, "0x0000000000000000000000000000000000000081": { "balance": "0x1" }, "0x0000000000000000000000000000000000000082": { "balance": "0x1" }, "0x0000000000000000000000000000000000000083": { "balance": "0x1" }, "0x0000000000000000000000000000000000000084": { "balance": "0x1" }, "0x0000000000000000000000000000000000000085": { "balance": "0x1" }, "0x0000000000000000000000000000000000000086": { "balance": "0x1" }, "0x0000000000000000000000000000000000000087": { "balance": "0x1" }, "0x0000000000000000000000000000000000000088": { "balance": "0x1" }, "0x0000000000000000000000000000000000000089": { "balance": "0x1" }, "0x000000000000000000000000000000000000008a": { "balance": "0x1" }, "0x000000000000000000000000000000000000008b": { "balance": "0x1" }, "0x000000000000000000000000000000000000008c": { "balance": "0x1" }, "0x000000000000000000000000000000000000008d": { "balance": "0x1" }, "0x000000000000000000000000000000000000008e": { "balance": "0x1" }, "0x000000000000000000000000000000000000008f": { "balance": "0x1" }, "0x0000000000000000000000000000000000000090": { "balance": "0x1" }, "0x0000000000000000000000000000000000000091": { "balance": "0x1" }, "0x0000000000000000000000000000000000000092": { "balance": "0x1" }, "0x0000000000000000000000000000000000000093": { "balance": "0x1" }, "0x0000000000000000000000000000000000000094": { "balance": "0x1" }, "0x0000000000000000000000000000000000000095": { "balance": "0x1" }, "0x0000000000000000000000000000000000000096": { "balance": "0x1" }, "0x0000000000000000000000000000000000000097": { "balance": "0x1" }, "0x0000000000000000000000000000000000000098": { "balance": "0x1" }, "0x0000000000000000000000000000000000000099": { "balance": "0x1" }, "0x000000000000000000000000000000000000009a": { "balance": "0x1" }, "0x000000000000000000000000000000000000009b": { "balance": "0x1" }, "0x000000000000000000000000000000000000009c": { "balance": "0x1" }, "0x000000000000000000000000000000000000009d": { "balance": "0x1" }, "0x000000000000000000000000000000000000009e": { "balance": "0x1" }, "0x000000000000000000000000000000000000009f": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a0": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a1": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a2": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a3": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a4": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a5": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a6": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a7": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a8": { "balance": "0x1" }, "0x00000000000000000000000000000000000000a9": { "balance": "0x1" }, "0x00000000000000000000000000000000000000aa": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ab": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ac": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ad": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ae": { "balance": "0x1" }, "0x00000000000000000000000000000000000000af": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b0": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b1": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b2": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b3": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b4": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b5": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b6": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b7": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b8": { "balance": "0x1" }, "0x00000000000000000000000000000000000000b9": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ba": { "balance": "0x1" }, "0x00000000000000000000000000000000000000bb": { "balance": "0x1" }, "0x00000000000000000000000000000000000000bc": { "balance": "0x1" }, "0x00000000000000000000000000000000000000bd": { "balance": "0x1" }, "0x00000000000000000000000000000000000000be": { "balance": "0x1" }, "0x00000000000000000000000000000000000000bf": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c0": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c1": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c2": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c3": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c4": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c5": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c6": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c7": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c8": { "balance": "0x1" }, "0x00000000000000000000000000000000000000c9": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ca": { "balance": "0x1" }, "0x00000000000000000000000000000000000000cb": { "balance": "0x1" }, "0x00000000000000000000000000000000000000cc": { "balance": "0x1" }, "0x00000000000000000000000000000000000000cd": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ce": { "balance": "0x1" }, "0x00000000000000000000000000000000000000cf": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d0": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d1": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d2": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d3": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d4": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d5": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d6": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d7": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d8": { "balance": "0x1" }, "0x00000000000000000000000000000000000000d9": { "balance": "0x1" }, "0x00000000000000000000000000000000000000da": { "balance": "0x1" }, "0x00000000000000000000000000000000000000db": { "balance": "0x1" }, "0x00000000000000000000000000000000000000dc": { "balance": "0x1" }, "0x00000000000000000000000000000000000000dd": { "balance": "0x1" }, "0x00000000000000000000000000000000000000de": { "balance": "0x1" }, "0x00000000000000000000000000000000000000df": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e0": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e1": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e2": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e3": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e4": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e5": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e6": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e7": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e8": { "balance": "0x1" }, "0x00000000000000000000000000000000000000e9": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ea": { "balance": "0x1" }, "0x00000000000000000000000000000000000000eb": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ec": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ed": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ee": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ef": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f0": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f1": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f2": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f3": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f4": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f5": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f6": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f7": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f8": { "balance": "0x1" }, "0x00000000000000000000000000000000000000f9": { "balance": "0x1" }, "0x00000000000000000000000000000000000000fa": { "balance": "0x1" }, "0x00000000000000000000000000000000000000fb": { "balance": "0x1" }, "0x00000000000000000000000000000000000000fc": { "balance": "0x1" }, "0x00000000000000000000000000000000000000fd": { "balance": "0x1" }, "0x00000000000000000000000000000000000000fe": { "balance": "0x1" }, "0x00000000000000000000000000000000000000ff": { "balance": "0x1" }, "0x4242424242424242424242424242424242424242": { "balance": "0x0", "code": "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", "storage": { "0x0000000000000000000000000000000000000000000000000000000000000022": "0xf5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b", "0x0000000000000000000000000000000000000000000000000000000000000023": "0xdb56114e00fdd4c1f85c892bf35ac9a89289aaecb1ebd0a96cde606a748b5d71", "0x0000000000000000000000000000000000000000000000000000000000000024": "0xc78009fdf07fc56a11f122370658a353aaa542ed63e44c4bc15ff4cd105ab33c", "0x0000000000000000000000000000000000000000000000000000000000000025": "0x536d98837f2dd165a55d5eeae91485954472d56f246df256bf3cae19352a123c", "0x0000000000000000000000000000000000000000000000000000000000000026": "0x9efde052aa15429fae05bad4d0b1d7c64da64d03d7a1854a588c2cb8430c0d30", "0x0000000000000000000000000000000000000000000000000000000000000027": "0xd88ddfeed400a8755596b21942c1497e114c302e6118290f91e6772976041fa1", "0x0000000000000000000000000000000000000000000000000000000000000028": "0x87eb0ddba57e35f6d286673802a4af5975e22506c7cf4c64bb6be5ee11527f2c", "0x0000000000000000000000000000000000000000000000000000000000000029": "0x26846476fd5fc54a5d43385167c95144f2643f533cc85bb9d16b782f8d7db193", "0x000000000000000000000000000000000000000000000000000000000000002a": "0x506d86582d252405b840018792cad2bf1259f1ef5aa5f887e13cb2f0094f51e1", "0x000000000000000000000000000000000000000000000000000000000000002b": "0xffff0ad7e659772f9534c195c815efc4014ef1e1daed4404c06385d11192e92b", "0x000000000000000000000000000000000000000000000000000000000000002c": "0x6cf04127db05441cd833107a52be852868890e4317e6a02ab47683aa75964220", "0x000000000000000000000000000000000000000000000000000000000000002d": "0xb7d05f875f140027ef5118a2247bbb84ce8f2f0f1123623085daf7960c329f5f", "0x000000000000000000000000000000000000000000000000000000000000002e": "0xdf6af5f5bbdb6be9ef8aa618e4bf8073960867171e29676f8b284dea6a08a85e", "0x000000000000000000000000000000000000000000000000000000000000002f": "0xb58d900f5e182e3c50ef74969ea16c7726c549757cc23523c369587da7293784", "0x0000000000000000000000000000000000000000000000000000000000000030": "0xd49a7502ffcfb0340b1d7885688500ca308161a7f96b62df9d083b71fcc8f2bb", "0x0000000000000000000000000000000000000000000000000000000000000031": "0x8fe6b1689256c0d385f42f5bbe2027a22c1996e110ba97c171d3e5948de92beb", "0x0000000000000000000000000000000000000000000000000000000000000032": "0x8d0d63c39ebade8509e0ae3c9c3876fb5fa112be18f905ecacfecb92057603ab", "0x0000000000000000000000000000000000000000000000000000000000000033": "0x95eec8b2e541cad4e91de38385f2e046619f54496c2382cb6cacd5b98c26f5a4", "0x0000000000000000000000000000000000000000000000000000000000000034": "0xf893e908917775b62bff23294dbbe3a1cd8e6cc1c35b4801887b646a6f81f17f", "0x0000000000000000000000000000000000000000000000000000000000000035": "0xcddba7b592e3133393c16194fac7431abf2f5485ed711db282183c819e08ebaa", "0x0000000000000000000000000000000000000000000000000000000000000036": "0x8a8d7fe3af8caa085a7639a832001457dfb9128a8061142ad0335629ff23ff9c", "0x0000000000000000000000000000000000000000000000000000000000000037": "0xfeb3c337d7a51a6fbf00b9e34c52e1c9195c969bd4e7a0bfd51d5c5bed9c1167", "0x0000000000000000000000000000000000000000000000000000000000000038": "0xe71f0aa83cc32edfbefa9f4d3e0174ca85182eec9f3a09f6a6c0df6377a510d7", "0x0000000000000000000000000000000000000000000000000000000000000039": "0x31206fa80a50bb6abe29085058f16212212a60eec8f049fecb92d8c8e0a84bc0", "0x000000000000000000000000000000000000000000000000000000000000003a": "0x21352bfecbeddde993839f614c3dac0a3ee37543f9b412b16199dc158e23b544", "0x000000000000000000000000000000000000000000000000000000000000003b": "0x619e312724bb6d7c3153ed9de791d764a366b389af13c58bf8a8d90481a46765", "0x000000000000000000000000000000000000000000000000000000000000003c": "0x7cdd2986268250628d0c10e385c58c6191e6fbe05191bcc04f133f2cea72c1c4", "0x000000000000000000000000000000000000000000000000000000000000003d": "0x848930bd7ba8cac54661072113fb278869e07bb8587f91392933374d017bcbe1", "0x000000000000000000000000000000000000000000000000000000000000003e": "0x8869ff2c22b28cc10510d9853292803328be4fb0e80495e8bb8d271f5b889636", "0x000000000000000000000000000000000000000000000000000000000000003f": "0xb5fe28e79f1b850f8658246ce9b6a1e7b49fc06db7143e8fe0b4f2b0c5523a5c", "0x0000000000000000000000000000000000000000000000000000000000000040": "0x985e929f70af28d0bdd1a90a808f977f597c7c778c489e98d3bd8910d31ac0f7" } }, "0x0000006916a87b82333f4245046623b23794C65C": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x0be949928Ff199c9EBA9E110db210AA5C94EFAd0": { "balance": "0x7c13bc4b2c133c56000000" }, "0x0C100000006d7b5e23a1eAEE637f28cA32Cd5b31": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x0C35317B7a96C454E2CB3d1A255D775Ab112cCc8": { "balance": "0xd3c21bcecceda1000000" }, "0x0d731cfabC5574329823F26d488416451d2ea376": { "balance": "0xd3c21bcecceda1000000" }, "0x0e79065B5F11b5BD1e62B935A600976ffF3754B9": { "balance": "0xd3c21bcecceda1000000" }, "0x105083929bF9bb22C26cB1777Ec92661170D4285": { "balance": "0xd3c21bcecceda1000000" }, "0x10F5d45854e038071485AC9e402308cF80D2d2fE": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x1268AD189526AC0b386faF06eFfC46779c340eE6": { "balance": "0xd3c21bcecceda1000000" }, "0x12Cba59f5A74DB81a12ff63C349Bd82CBF6007C2": { "balance": "0xd3c21bcecceda1000000" }, "0x1446D7f6dF00380F246d8211dE7f0FaBC4Fd248C": { "balance": "0xd3c21bcecceda1000000" }, "0x164e38a375247A784A81d420201AA8fe4E513921": { "balance": "0xd3c21bcecceda1000000" }, "0x1B7aA44088a0eA95bdc65fef6E5071E946Bf7d8f": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x222222222222cF64a76AE3d36859958c864fDA2c": { "balance": "0xd3c21bcecceda1000000" }, "0x2f14582947E292a2eCd20C430B46f2d27CFE213c": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x2f2c75B5Dd5D246194812b00eEb3B09c2c66e2eE": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x341c40b94bf2afbfa42573cb78f16ee15a056238": { "balance": "0xd3c21bcecceda1000000" }, "0x34f845773D4364999f2fbC7AA26ABDeE902cBb46": { "balance": "0xd3c21bcecceda1000000" }, "0x3C75594181e03E8ECD8468A0037F058a9dAfad79": { "balance": "0xd3c21bcecceda1000000" }, "0x462396E69dBfa455F405f4DD82F3014Af8003B72": { "balance": "0xa56fa5b99019a5c8000000" }, "0x49Df3CCa2670eB0D591146B16359fe336e476F29": { "balance": "0xd3c21bcecceda1000000" }, "0x4D0b04b405c6b62C7cFC3aE54759747e2C0b4662": { "balance": "0xd3c21bcecceda1000000" }, "0x4D496CcC28058B1D74B7a19541663E21154f9c84": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x509a7667aC8D0320e36172c192506a6188aA84f6": { "balance": "0x7c13bc4b2c133c56000000" }, "0x5180db0237291A6449DdA9ed33aD90a38787621c": { "balance": "0xd3c21bcecceda1000000" }, "0x52730f347dEf6BA09adfF62EaC60D5fEe8205BC4": { "balance": "0xd3c21bcecceda1000000" }, "0x5EAC0fBd3dfef8aE3efa3c5dc1aa193bc6033dFd": { "balance": "0xd3c21bcecceda1000000" }, "0x6a7aA9b882d50Bb7bc5Da1a244719C99f12F06a3": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x6Cc9397c3B38739daCbfaA68EaD5F5D77Ba5F455": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x762cA62ca2549ad806763B3Aa1eA317c429bDBDa": { "balance": "0xd3c21bcecceda1000000" }, "0x778F5F13C4Be78A3a4d7141BCB26999702f407CF": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x875D25Ee4bC604C71BaF6236a8488F22399BED4b": { "balance": "0xd3c21bcecceda1000000" }, "0x8dF7878d3571BEF5e5a744F96287C8D20386d75A": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0x9E415A096fF77650dc925dEA546585B4adB322B6": { "balance": "0xd3c21bcecceda1000000" }, "0xA0766B65A4f7B1da79a1AF79aC695456eFa28644": { "balance": "0xd3c21bcecceda1000000" }, "0xA29B144A449E414A472c60C7AAf1aaFfE329021D": { "balance": "0xd3c21bcecceda1000000" }, "0xa55395566b0b54395B3246f96A0bDc4b8a483df9": { "balance": "0xd3c21bcecceda1000000" }, "0xAC9ba72fb61aA7c31A95df0A8b6ebA6f41EF875e": { "balance": "0xd3c21bcecceda1000000" }, "0xB0498C15879db2eE5471d4926c5fAA25C9a09683": { "balance": "0xd3c21bcecceda1000000" }, "0xB19Fb4c1f280327e60Ed37b1Dc6EE77533539314": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0xC21cB9C99C316d1863142F7dD86dd5496D81A8D6": { "balance": "0xd3c21bcecceda1000000" }, "0xc473d412dc52e349862209924c8981b2ee420768": { "balance": "0xd3c21bcecceda1000000" }, "0xC48E23C5F6e1eA0BaEf6530734edC3968f79Af2e": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0xc6e2459991BfE27cca6d86722F35da23A1E4Cb97": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0xD3994e4d3202dD23c8497d7F75bF1647d1DA1bb1": { "balance": "0x19D971E4FE8401E74000000" }, "0xDCA6e9B48Ea86AeBFDf9929949124042296b6e34": { "balance": "0xd3c21bcecceda1000000" }, "0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0xEA28d002042fd9898D0Db016be9758eeAFE35C1E": { "balance": "0xd3c21bcecceda1000000" }, "0xEfA7454f1116807975A4750B46695E967850de5D": { "balance": "0xd3c21bcecceda1000000" }, "0xFBFd6Fa9F73Ac6A058E01259034C28001BEf8247": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0xe0991E844041bE6F11B99da5b114b6bCf84EBd57": { "balance": "0xd3c21bcecceda1000000" }, "0x15E719b6AcAf1E4411Bf0f9576CB1D0dB161DdFc": { "balance": "0xd3c21bcecceda1000000" }, "0x346D827a75F98F0A7a324Ff80b7C3F90252E8baC": { "balance": "0xd3c21bcecceda1000000" }, "0x73b2e0E54510239E22cC936F0b4a6dE1acf0AbdE": { "balance": "0x52b7d2dcc80cd2e4000000" }, "0xBb977B2EE8a111D788B3477D242078d0B837E72b": { "balance": "0xd3c21bcecceda1000000" }, "0x834Dbf5A03e29c25bc55459cCe9c021EeBE676Ad": { "balance": "0xd3c21bcecceda1000000" }, "0xD1F77E4C1C45186e8653C489F90e008a73597296": { "balance": "0xd3c21bcecceda1000000" }, "0xb04aeF2a3d2D86B01006cCD4339A2e943d9c6480": { "balance": "0xd3c21bcecceda1000000" }, "0xC9CA2bA9A27De1Db589d8c33Ab8EDFa2111b31fb": { "balance": "0xd3c21bcecceda1000000" }, "0x4BC656B34De23896fa6069C9862F355b740401aF": { "balance": "0x084595161401484a000000" } }, "config": { "chainId": 17000, "homesteadBlock": 0, "eip150Block": 0, "eip155Block": 0, "byzantiumBlock": 0, "constantinopleBlock": 0, "petersburgBlock": 0, "istanbulBlock": 0, "berlinBlock": 0, "londonBlock": 0, "terminalTotalDifficulty": 0, "terminalTotalDifficultyPassed": true, "shanghaiTime": 1696000704, "pragueTime": 1740434112, "cancunTime": 1707305664 }, "difficulty": "0x01", "gasLimit": "0x017D7840", "nonce": "0x1234", "timestamp": "0x65156994" } ================================================ FILE: silkworm/core/chain/genesis_mainnet.cpp ================================================ /* Generated from genesis_mainnet.json using silkworm embed_json tool */ #include "genesis_mainnet.hpp" constexpr char kGenesisMainnetDataInternal[] = { 0x7b, 0x22, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x33, 0x32, 0x38, 0x32, 0x37, 0x39, 0x31, 0x64, 0x36, 0x66, 0x64, 0x37, 0x31, 0x33, 0x66, 0x31, 0x65, 0x39, 0x34, 0x66, 0x34, 0x62, 0x66, 0x64, 0x35, 0x36, 0x35, 0x65, 0x61, 0x61, 0x37, 0x38, 0x62, 0x33, 0x61, 0x30, 0x35, 0x39, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x39, 0x36, 0x31, 0x64, 0x36, 0x33, 0x33, 0x62, 0x63, 0x66, 0x32, 0x30, 0x61, 0x37, 0x62, 0x30, 0x32, 0x39, 0x61, 0x37, 0x64, 0x39, 0x34, 0x62, 0x37, 0x64, 0x66, 0x34, 0x64, 0x61, 0x32, 0x65, 0x63, 0x35, 0x34, 0x32, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x39, 0x34, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x33, 0x61, 0x36, 0x37, 0x66, 0x65, 0x32, 0x33, 0x64, 0x65, 0x63, 0x63, 0x36, 0x33, 0x62, 0x31, 0x30, 0x64, 0x64, 0x61, 0x37, 0x35, 0x66, 0x33, 0x32, 0x38, 0x37, 0x36, 0x39, 0x35, 0x61, 0x38, 0x31, 0x62, 0x64, 0x35, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x66, 0x62, 0x38, 0x65, 0x63, 0x31, 0x32, 0x34, 0x32, 0x35, 0x61, 0x30, 0x34, 0x66, 0x38, 0x31, 0x33, 0x65, 0x34, 0x36, 0x63, 0x35, 0x34, 0x63, 0x30, 0x35, 0x37, 0x34, 0x38, 0x63, 0x61, 0x36, 0x62, 0x32, 0x39, 0x61, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x61, 0x30, 0x33, 0x30, 0x61, 0x63, 0x38, 0x39, 0x35, 0x32, 0x33, 0x32, 0x35, 0x66, 0x39, 0x65, 0x31, 0x64, 0x62, 0x33, 0x37, 0x38, 0x61, 0x37, 0x31, 0x34, 0x38, 0x35, 0x61, 0x32, 0x34, 0x65, 0x31, 0x62, 0x30, 0x37, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x61, 0x33, 0x34, 0x39, 0x30, 0x37, 0x66, 0x33, 0x30, 0x35, 0x61, 0x35, 0x34, 0x63, 0x38, 0x35, 0x64, 0x62, 0x30, 0x39, 0x63, 0x33, 0x36, 0x33, 0x66, 0x64, 0x65, 0x33, 0x63, 0x34, 0x37, 0x65, 0x36, 0x61, 0x65, 0x32, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x31, 0x61, 0x37, 0x37, 0x34, 0x30, 0x35, 0x63, 0x30, 0x39, 0x61, 0x37, 0x32, 0x62, 0x35, 0x65, 0x38, 0x34, 0x33, 0x36, 0x32, 0x33, 0x37, 0x61, 0x61, 0x61, 0x66, 0x39, 0x35, 0x64, 0x36, 0x38, 0x64, 0x61, 0x31, 0x37, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x61, 0x61, 0x64, 0x61, 0x32, 0x35, 0x65, 0x61, 0x32, 0x32, 0x38, 0x36, 0x37, 0x30, 0x39, 0x61, 0x62, 0x62, 0x34, 0x32, 0x32, 0x64, 0x34, 0x31, 0x39, 0x32, 0x33, 0x66, 0x64, 0x33, 0x38, 0x30, 0x63, 0x64, 0x30, 0x34, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x34, 0x36, 0x61, 0x32, 0x61, 0x35, 0x35, 0x35, 0x63, 0x37, 0x34, 0x64, 0x65, 0x64, 0x34, 0x61, 0x32, 0x62, 0x64, 0x30, 0x39, 0x34, 0x65, 0x38, 0x32, 0x31, 0x62, 0x39, 0x37, 0x38, 0x34, 0x33, 0x62, 0x34, 0x30, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x30, 0x37, 0x66, 0x62, 0x35, 0x62, 0x37, 0x61, 0x34, 0x36, 0x34, 0x65, 0x33, 0x62, 0x61, 0x37, 0x66, 0x62, 0x65, 0x30, 0x39, 0x65, 0x39, 0x61, 0x63, 0x62, 0x32, 0x37, 0x31, 0x61, 0x66, 0x35, 0x33, 0x33, 0x38, 0x63, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x36, 0x39, 0x36, 0x62, 0x65, 0x39, 0x39, 0x66, 0x33, 0x61, 0x36, 0x39, 0x30, 0x34, 0x34, 0x30, 0x63, 0x33, 0x34, 0x33, 0x36, 0x61, 0x35, 0x39, 0x61, 0x37, 0x64, 0x37, 0x65, 0x39, 0x33, 0x37, 0x64, 0x36, 0x62, 0x61, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x33, 0x33, 0x35, 0x35, 0x33, 0x32, 0x38, 0x35, 0x61, 0x39, 0x37, 0x33, 0x37, 0x31, 0x39, 0x61, 0x30, 0x64, 0x35, 0x66, 0x39, 0x35, 0x36, 0x66, 0x66, 0x38, 0x36, 0x31, 0x62, 0x32, 0x64, 0x38, 0x39, 0x65, 0x64, 0x33, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x63, 0x66, 0x64, 0x61, 0x36, 0x65, 0x37, 0x30, 0x62, 0x66, 0x37, 0x36, 0x35, 0x37, 0x64, 0x33, 0x39, 0x30, 0x35, 0x39, 0x62, 0x35, 0x39, 0x37, 0x39, 0x30, 0x65, 0x35, 0x31, 0x34, 0x35, 0x61, 0x66, 0x64, 0x62, 0x65, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x32, 0x31, 0x30, 0x39, 0x31, 0x64, 0x33, 0x30, 0x31, 0x38, 0x30, 0x36, 0x34, 0x32, 0x37, 0x39, 0x64, 0x62, 0x33, 0x39, 0x39, 0x64, 0x32, 0x62, 0x32, 0x61, 0x38, 0x38, 0x61, 0x36, 0x66, 0x34, 0x34, 0x30, 0x61, 0x65, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x33, 0x66, 0x61, 0x31, 0x61, 0x63, 0x30, 0x38, 0x61, 0x62, 0x61, 0x39, 0x63, 0x63, 0x33, 0x62, 0x66, 0x30, 0x66, 0x65, 0x39, 0x64, 0x34, 0x38, 0x33, 0x38, 0x32, 0x30, 0x36, 0x38, 0x38, 0x66, 0x36, 0x35, 0x62, 0x34, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x31, 0x35, 0x63, 0x31, 0x34, 0x30, 0x33, 0x35, 0x66, 0x62, 0x35, 0x37, 0x62, 0x62, 0x33, 0x64, 0x36, 0x36, 0x37, 0x66, 0x37, 0x62, 0x37, 0x30, 0x37, 0x34, 0x39, 0x38, 0x63, 0x34, 0x31, 0x30, 0x37, 0x34, 0x62, 0x38, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x33, 0x34, 0x34, 0x66, 0x37, 0x64, 0x35, 0x63, 0x61, 0x64, 0x36, 0x35, 0x64, 0x31, 0x37, 0x65, 0x35, 0x63, 0x32, 0x64, 0x30, 0x65, 0x37, 0x33, 0x32, 0x33, 0x39, 0x34, 0x33, 0x64, 0x36, 0x66, 0x36, 0x32, 0x66, 0x65, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x32, 0x39, 0x34, 0x36, 0x32, 0x36, 0x65, 0x63, 0x32, 0x39, 0x38, 0x34, 0x63, 0x34, 0x33, 0x62, 0x34, 0x33, 0x64, 0x61, 0x34, 0x64, 0x35, 0x64, 0x38, 0x65, 0x34, 0x36, 0x36, 0x39, 0x62, 0x31, 0x31, 0x64, 0x34, 0x62, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x36, 0x30, 0x31, 0x38, 0x35, 0x38, 0x34, 0x31, 0x33, 0x30, 0x64, 0x62, 0x38, 0x33, 0x61, 0x62, 0x30, 0x35, 0x39, 0x31, 0x61, 0x38, 0x31, 0x32, 0x38, 0x64, 0x39, 0x33, 0x38, 0x31, 0x36, 0x36, 0x36, 0x61, 0x38, 0x64, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x61, 0x30, 0x31, 0x30, 0x63, 0x65, 0x30, 0x63, 0x37, 0x33, 0x31, 0x64, 0x33, 0x62, 0x36, 0x32, 0x38, 0x65, 0x33, 0x36, 0x62, 0x39, 0x31, 0x66, 0x35, 0x37, 0x31, 0x33, 0x30, 0x30, 0x65, 0x34, 0x39, 0x64, 0x62, 0x65, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x39, 0x38, 0x62, 0x36, 0x35, 0x64, 0x62, 0x39, 0x33, 0x65, 0x63, 0x61, 0x63, 0x61, 0x66, 0x37, 0x33, 0x35, 0x33, 0x63, 0x34, 0x38, 0x38, 0x30, 0x38, 0x33, 0x39, 0x30, 0x61, 0x32, 0x32, 0x33, 0x64, 0x35, 0x37, 0x36, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x39, 0x39, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x36, 0x33, 0x35, 0x62, 0x66, 0x37, 0x33, 0x38, 0x33, 0x31, 0x31, 0x31, 0x39, 0x64, 0x32, 0x64, 0x32, 0x39, 0x63, 0x30, 0x64, 0x30, 0x34, 0x66, 0x66, 0x38, 0x66, 0x38, 0x64, 0x38, 0x64, 0x30, 0x61, 0x35, 0x37, 0x61, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x37, 0x35, 0x31, 0x35, 0x66, 0x66, 0x30, 0x65, 0x38, 0x30, 0x38, 0x66, 0x36, 0x39, 0x35, 0x65, 0x30, 0x63, 0x32, 0x30, 0x34, 0x38, 0x35, 0x66, 0x66, 0x39, 0x36, 0x65, 0x64, 0x32, 0x66, 0x37, 0x62, 0x37, 0x39, 0x33, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x33, 0x30, 0x63, 0x30, 0x34, 0x30, 0x39, 0x38, 0x64, 0x37, 0x61, 0x37, 0x65, 0x36, 0x34, 0x32, 0x30, 0x63, 0x33, 0x35, 0x37, 0x65, 0x61, 0x37, 0x62, 0x66, 0x61, 0x34, 0x39, 0x62, 0x61, 0x63, 0x39, 0x61, 0x38, 0x61, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x64, 0x62, 0x61, 0x32, 0x64, 0x36, 0x36, 0x31, 0x35, 0x62, 0x38, 0x62, 0x64, 0x37, 0x35, 0x37, 0x31, 0x38, 0x33, 0x36, 0x64, 0x63, 0x37, 0x35, 0x62, 0x63, 0x37, 0x39, 0x64, 0x33, 0x31, 0x34, 0x66, 0x35, 0x65, 0x63, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x39, 0x31, 0x32, 0x64, 0x34, 0x63, 0x66, 0x34, 0x35, 0x36, 0x32, 0x63, 0x35, 0x37, 0x33, 0x64, 0x64, 0x63, 0x35, 0x62, 0x37, 0x31, 0x65, 0x33, 0x37, 0x33, 0x31, 0x30, 0x65, 0x33, 0x37, 0x38, 0x65, 0x66, 0x38, 0x36, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x64, 0x61, 0x33, 0x34, 0x34, 0x35, 0x30, 0x64, 0x32, 0x32, 0x65, 0x63, 0x30, 0x66, 0x66, 0x63, 0x65, 0x64, 0x65, 0x30, 0x30, 0x30, 0x34, 0x62, 0x30, 0x32, 0x66, 0x37, 0x38, 0x37, 0x32, 0x65, 0x65, 0x30, 0x62, 0x37, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x33, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x34, 0x33, 0x37, 0x64, 0x31, 0x34, 0x36, 0x35, 0x36, 0x34, 0x30, 0x62, 0x31, 0x33, 0x36, 0x63, 0x62, 0x35, 0x38, 0x34, 0x31, 0x63, 0x33, 0x66, 0x39, 0x33, 0x34, 0x66, 0x39, 0x62, 0x61, 0x30, 0x62, 0x37, 0x30, 0x39, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x35, 0x32, 0x38, 0x37, 0x31, 0x64, 0x31, 0x39, 0x32, 0x34, 0x32, 0x32, 0x63, 0x36, 0x62, 0x63, 0x32, 0x33, 0x35, 0x66, 0x61, 0x30, 0x36, 0x33, 0x62, 0x34, 0x34, 0x61, 0x37, 0x65, 0x31, 0x64, 0x34, 0x33, 0x65, 0x33, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x61, 0x37, 0x30, 0x38, 0x65, 0x38, 0x34, 0x66, 0x38, 0x32, 0x64, 0x62, 0x38, 0x36, 0x61, 0x33, 0x35, 0x35, 0x30, 0x32, 0x31, 0x39, 0x33, 0x62, 0x34, 0x63, 0x36, 0x65, 0x65, 0x39, 0x61, 0x37, 0x36, 0x65, 0x62, 0x65, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x33, 0x66, 0x35, 0x36, 0x37, 0x66, 0x61, 0x66, 0x66, 0x37, 0x62, 0x61, 0x64, 0x31, 0x62, 0x35, 0x31, 0x32, 0x30, 0x30, 0x32, 0x32, 0x65, 0x38, 0x63, 0x62, 0x63, 0x61, 0x61, 0x38, 0x32, 0x62, 0x34, 0x39, 0x31, 0x37, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x63, 0x31, 0x64, 0x30, 0x65, 0x65, 0x32, 0x62, 0x61, 0x62, 0x35, 0x33, 0x31, 0x31, 0x34, 0x30, 0x64, 0x65, 0x31, 0x33, 0x37, 0x37, 0x32, 0x32, 0x63, 0x64, 0x33, 0x36, 0x62, 0x64, 0x62, 0x34, 0x65, 0x34, 0x37, 0x31, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x39, 0x64, 0x61, 0x62, 0x31, 0x62, 0x66, 0x38, 0x64, 0x66, 0x31, 0x31, 0x33, 0x32, 0x37, 0x65, 0x36, 0x31, 0x66, 0x39, 0x62, 0x37, 0x61, 0x31, 0x34, 0x62, 0x35, 0x36, 0x33, 0x61, 0x39, 0x36, 0x65, 0x63, 0x33, 0x35, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x36, 0x66, 0x38, 0x64, 0x37, 0x34, 0x36, 0x36, 0x38, 0x32, 0x62, 0x32, 0x32, 0x34, 0x36, 0x37, 0x39, 0x33, 0x34, 0x39, 0x30, 0x36, 0x34, 0x64, 0x31, 0x62, 0x33, 0x36, 0x38, 0x63, 0x37, 0x63, 0x30, 0x35, 0x62, 0x31, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x31, 0x33, 0x31, 0x35, 0x34, 0x36, 0x33, 0x31, 0x34, 0x36, 0x36, 0x64, 0x63, 0x62, 0x31, 0x33, 0x35, 0x33, 0x63, 0x38, 0x39, 0x30, 0x39, 0x33, 0x32, 0x61, 0x37, 0x63, 0x39, 0x37, 0x65, 0x30, 0x38, 0x37, 0x38, 0x65, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x62, 0x31, 0x36, 0x32, 0x36, 0x65, 0x32, 0x34, 0x66, 0x33, 0x30, 0x62, 0x63, 0x61, 0x64, 0x39, 0x32, 0x37, 0x33, 0x63, 0x35, 0x32, 0x37, 0x66, 0x63, 0x63, 0x37, 0x31, 0x34, 0x62, 0x35, 0x64, 0x30, 0x30, 0x37, 0x62, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x64, 0x62, 0x30, 0x62, 0x39, 0x62, 0x32, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x33, 0x33, 0x63, 0x37, 0x35, 0x37, 0x66, 0x36, 0x61, 0x64, 0x39, 0x62, 0x63, 0x62, 0x35, 0x35, 0x35, 0x63, 0x30, 0x32, 0x64, 0x61, 0x39, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x39, 0x39, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x66, 0x63, 0x37, 0x65, 0x35, 0x33, 0x63, 0x35, 0x65, 0x62, 0x64, 0x32, 0x37, 0x61, 0x32, 0x61, 0x62, 0x64, 0x61, 0x63, 0x34, 0x35, 0x32, 0x36, 0x31, 0x66, 0x38, 0x34, 0x61, 0x62, 0x33, 0x62, 0x35, 0x31, 0x61, 0x65, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x38, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x36, 0x33, 0x36, 0x62, 0x37, 0x61, 0x34, 0x39, 0x36, 0x66, 0x30, 0x34, 0x34, 0x64, 0x37, 0x33, 0x35, 0x39, 0x35, 0x39, 0x36, 0x65, 0x33, 0x35, 0x33, 0x61, 0x31, 0x30, 0x34, 0x36, 0x31, 0x36, 0x34, 0x33, 0x36, 0x66, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x62, 0x63, 0x65, 0x39, 0x65, 0x63, 0x33, 0x38, 0x33, 0x36, 0x32, 0x64, 0x36, 0x63, 0x39, 0x34, 0x63, 0x63, 0x61, 0x63, 0x32, 0x36, 0x64, 0x35, 0x63, 0x30, 0x65, 0x31, 0x33, 0x61, 0x38, 0x62, 0x33, 0x62, 0x31, 0x64, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x33, 0x34, 0x36, 0x38, 0x32, 0x31, 0x38, 0x30, 0x62, 0x39, 0x38, 0x32, 0x64, 0x31, 0x36, 0x36, 0x62, 0x61, 0x64, 0x62, 0x39, 0x64, 0x39, 0x64, 0x31, 0x64, 0x39, 0x62, 0x62, 0x66, 0x30, 0x31, 0x36, 0x64, 0x38, 0x37, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x36, 0x65, 0x30, 0x31, 0x35, 0x33, 0x66, 0x63, 0x31, 0x36, 0x31, 0x62, 0x63, 0x30, 0x35, 0x65, 0x36, 0x35, 0x36, 0x62, 0x62, 0x62, 0x31, 0x34, 0x34, 0x63, 0x37, 0x31, 0x38, 0x37, 0x62, 0x66, 0x34, 0x66, 0x65, 0x38, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x39, 0x63, 0x30, 0x63, 0x63, 0x66, 0x66, 0x36, 0x35, 0x34, 0x64, 0x61, 0x30, 0x33, 0x61, 0x65, 0x62, 0x31, 0x31, 0x61, 0x66, 0x37, 0x30, 0x31, 0x30, 0x35, 0x34, 0x35, 0x36, 0x31, 0x64, 0x36, 0x32, 0x39, 0x37, 0x65, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x61, 0x31, 0x65, 0x32, 0x35, 0x34, 0x34, 0x30, 0x39, 0x66, 0x62, 0x31, 0x62, 0x35, 0x35, 0x61, 0x37, 0x63, 0x62, 0x34, 0x64, 0x64, 0x38, 0x65, 0x62, 0x61, 0x33, 0x62, 0x33, 0x30, 0x63, 0x38, 0x62, 0x61, 0x64, 0x39, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x66, 0x31, 0x38, 0x39, 0x36, 0x62, 0x30, 0x30, 0x37, 0x63, 0x33, 0x32, 0x61, 0x31, 0x35, 0x31, 0x31, 0x34, 0x66, 0x62, 0x38, 0x39, 0x64, 0x37, 0x33, 0x64, 0x62, 0x64, 0x34, 0x37, 0x66, 0x39, 0x31, 0x32, 0x32, 0x62, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x33, 0x32, 0x30, 0x64, 0x64, 0x39, 0x30, 0x66, 0x32, 0x62, 0x61, 0x61, 0x31, 0x31, 0x30, 0x64, 0x64, 0x33, 0x33, 0x34, 0x38, 0x37, 0x32, 0x61, 0x39, 0x39, 0x38, 0x66, 0x31, 0x34, 0x38, 0x34, 0x32, 0x36, 0x34, 0x35, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x32, 0x65, 0x31, 0x64, 0x33, 0x33, 0x35, 0x63, 0x63, 0x32, 0x39, 0x61, 0x39, 0x36, 0x62, 0x39, 0x62, 0x31, 0x63, 0x30, 0x32, 0x66, 0x30, 0x30, 0x33, 0x61, 0x31, 0x36, 0x64, 0x39, 0x37, 0x31, 0x65, 0x39, 0x30, 0x62, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x32, 0x31, 0x36, 0x30, 0x35, 0x66, 0x39, 0x39, 0x31, 0x36, 0x34, 0x65, 0x33, 0x62, 0x63, 0x63, 0x32, 0x38, 0x66, 0x33, 0x31, 0x63, 0x61, 0x65, 0x63, 0x65, 0x37, 0x38, 0x39, 0x37, 0x33, 0x31, 0x38, 0x32, 0x35, 0x36, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x33, 0x37, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x30, 0x30, 0x61, 0x34, 0x32, 0x30, 0x61, 0x33, 0x36, 0x31, 0x30, 0x37, 0x64, 0x66, 0x64, 0x35, 0x66, 0x34, 0x39, 0x35, 0x31, 0x32, 0x38, 0x61, 0x35, 0x66, 0x65, 0x35, 0x61, 0x62, 0x62, 0x32, 0x64, 0x62, 0x30, 0x66, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x63, 0x62, 0x64, 0x66, 0x30, 0x39, 0x34, 0x35, 0x34, 0x65, 0x31, 0x61, 0x35, 0x65, 0x34, 0x61, 0x34, 0x30, 0x64, 0x33, 0x65, 0x65, 0x66, 0x37, 0x63, 0x35, 0x63, 0x66, 0x31, 0x63, 0x64, 0x33, 0x64, 0x65, 0x39, 0x34, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x36, 0x65, 0x30, 0x34, 0x33, 0x64, 0x30, 0x35, 0x39, 0x37, 0x61, 0x36, 0x36, 0x34, 0x39, 0x34, 0x38, 0x66, 0x62, 0x62, 0x30, 0x64, 0x63, 0x31, 0x35, 0x34, 0x37, 0x35, 0x61, 0x33, 0x61, 0x34, 0x66, 0x33, 0x61, 0x36, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x61, 0x65, 0x62, 0x33, 0x34, 0x35, 0x36, 0x36, 0x62, 0x39, 0x37, 0x34, 0x63, 0x33, 0x35, 0x61, 0x35, 0x38, 0x38, 0x31, 0x64, 0x65, 0x63, 0x30, 0x32, 0x30, 0x39, 0x32, 0x37, 0x64, 0x61, 0x37, 0x64, 0x66, 0x35, 0x64, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x61, 0x64, 0x63, 0x36, 0x31, 0x65, 0x64, 0x35, 0x66, 0x30, 0x34, 0x36, 0x30, 0x61, 0x37, 0x66, 0x31, 0x38, 0x65, 0x35, 0x31, 0x62, 0x32, 0x66, 0x62, 0x32, 0x36, 0x31, 0x34, 0x64, 0x39, 0x32, 0x36, 0x34, 0x61, 0x30, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x62, 0x39, 0x31, 0x65, 0x66, 0x65, 0x37, 0x33, 0x35, 0x30, 0x63, 0x32, 0x64, 0x35, 0x37, 0x65, 0x37, 0x65, 0x34, 0x30, 0x36, 0x62, 0x61, 0x62, 0x31, 0x38, 0x66, 0x33, 0x36, 0x31, 0x37, 0x62, 0x63, 0x64, 0x65, 0x31, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x39, 0x38, 0x65, 0x30, 0x37, 0x65, 0x62, 0x63, 0x62, 0x34, 0x66, 0x37, 0x35, 0x66, 0x66, 0x32, 0x31, 0x31, 0x36, 0x64, 0x65, 0x37, 0x37, 0x63, 0x31, 0x63, 0x32, 0x61, 0x39, 0x39, 0x66, 0x33, 0x30, 0x33, 0x61, 0x34, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x32, 0x37, 0x39, 0x36, 0x32, 0x39, 0x35, 0x31, 0x30, 0x31, 0x36, 0x37, 0x34, 0x32, 0x38, 0x38, 0x63, 0x31, 0x64, 0x39, 0x33, 0x34, 0x36, 0x37, 0x30, 0x35, 0x33, 0x64, 0x30, 0x34, 0x32, 0x32, 0x31, 0x39, 0x62, 0x37, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x65, 0x64, 0x38, 0x34, 0x38, 0x65, 0x63, 0x39, 0x36, 0x31, 0x37, 0x33, 0x39, 0x63, 0x32, 0x63, 0x37, 0x65, 0x33, 0x35, 0x32, 0x66, 0x34, 0x33, 0x35, 0x62, 0x61, 0x37, 0x30, 0x61, 0x37, 0x63, 0x64, 0x35, 0x64, 0x62, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x34, 0x38, 0x35, 0x37, 0x32, 0x38, 0x64, 0x30, 0x65, 0x32, 0x38, 0x31, 0x35, 0x36, 0x33, 0x37, 0x35, 0x38, 0x63, 0x37, 0x35, 0x61, 0x62, 0x32, 0x37, 0x65, 0x64, 0x39, 0x65, 0x38, 0x38, 0x32, 0x61, 0x30, 0x30, 0x30, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x37, 0x65, 0x63, 0x36, 0x36, 0x38, 0x61, 0x63, 0x39, 0x34, 0x30, 0x34, 0x65, 0x38, 0x39, 0x35, 0x63, 0x63, 0x38, 0x36, 0x31, 0x35, 0x31, 0x31, 0x64, 0x31, 0x36, 0x32, 0x30, 0x61, 0x34, 0x39, 0x31, 0x32, 0x62, 0x65, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x62, 0x63, 0x31, 0x39, 0x39, 0x65, 0x35, 0x38, 0x36, 0x37, 0x39, 0x30, 0x62, 0x65, 0x38, 0x37, 0x61, 0x66, 0x65, 0x64, 0x63, 0x38, 0x34, 0x39, 0x63, 0x30, 0x34, 0x37, 0x32, 0x36, 0x37, 0x34, 0x35, 0x63, 0x35, 0x64, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x64, 0x39, 0x34, 0x35, 0x33, 0x33, 0x34, 0x65, 0x63, 0x64, 0x65, 0x34, 0x37, 0x62, 0x65, 0x62, 0x39, 0x63, 0x61, 0x33, 0x38, 0x31, 0x36, 0x63, 0x31, 0x37, 0x33, 0x64, 0x66, 0x62, 0x62, 0x64, 0x30, 0x62, 0x35, 0x33, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x63, 0x65, 0x62, 0x63, 0x62, 0x37, 0x36, 0x35, 0x36, 0x64, 0x66, 0x35, 0x64, 0x63, 0x61, 0x61, 0x33, 0x33, 0x36, 0x38, 0x61, 0x30, 0x35, 0x35, 0x64, 0x32, 0x32, 0x66, 0x39, 0x65, 0x64, 0x36, 0x63, 0x64, 0x64, 0x39, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x63, 0x31, 0x66, 0x38, 0x64, 0x37, 0x62, 0x66, 0x37, 0x32, 0x31, 0x66, 0x33, 0x63, 0x66, 0x65, 0x37, 0x34, 0x64, 0x32, 0x30, 0x66, 0x65, 0x61, 0x39, 0x62, 0x38, 0x37, 0x61, 0x32, 0x38, 0x61, 0x61, 0x61, 0x39, 0x38, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x34, 0x37, 0x61, 0x64, 0x39, 0x30, 0x35, 0x39, 0x61, 0x32, 0x34, 0x39, 0x66, 0x63, 0x39, 0x33, 0x36, 0x62, 0x32, 0x36, 0x36, 0x32, 0x33, 0x35, 0x33, 0x64, 0x61, 0x36, 0x39, 0x30, 0x35, 0x66, 0x37, 0x35, 0x63, 0x32, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x38, 0x34, 0x39, 0x38, 0x39, 0x33, 0x34, 0x65, 0x33, 0x37, 0x65, 0x39, 0x30, 0x35, 0x66, 0x31, 0x64, 0x30, 0x65, 0x37, 0x37, 0x62, 0x34, 0x34, 0x62, 0x35, 0x37, 0x34, 0x62, 0x63, 0x66, 0x33, 0x65, 0x63, 0x34, 0x61, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x36, 0x62, 0x36, 0x62, 0x39, 0x63, 0x37, 0x63, 0x62, 0x35, 0x35, 0x32, 0x38, 0x32, 0x39, 0x63, 0x31, 0x64, 0x33, 0x64, 0x66, 0x64, 0x38, 0x66, 0x66, 0x62, 0x31, 0x31, 0x61, 0x61, 0x62, 0x61, 0x65, 0x37, 0x38, 0x32, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x65, 0x61, 0x32, 0x35, 0x64, 0x34, 0x32, 0x62, 0x32, 0x36, 0x31, 0x32, 0x32, 0x38, 0x36, 0x65, 0x39, 0x39, 0x63, 0x35, 0x33, 0x36, 0x39, 0x37, 0x63, 0x36, 0x62, 0x63, 0x34, 0x31, 0x30, 0x30, 0x65, 0x32, 0x64, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x33, 0x36, 0x31, 0x35, 0x63, 0x37, 0x38, 0x39, 0x64, 0x30, 0x62, 0x31, 0x31, 0x35, 0x32, 0x61, 0x64, 0x34, 0x64, 0x62, 0x32, 0x35, 0x66, 0x65, 0x35, 0x64, 0x63, 0x66, 0x32, 0x32, 0x32, 0x38, 0x30, 0x34, 0x63, 0x66, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x65, 0x36, 0x35, 0x38, 0x31, 0x65, 0x31, 0x64, 0x61, 0x31, 0x66, 0x39, 0x62, 0x38, 0x34, 0x36, 0x65, 0x30, 0x39, 0x33, 0x34, 0x37, 0x33, 0x33, 0x33, 0x64, 0x63, 0x38, 0x31, 0x38, 0x65, 0x32, 0x64, 0x32, 0x61, 0x63, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x30, 0x33, 0x30, 0x35, 0x37, 0x32, 0x37, 0x33, 0x31, 0x33, 0x64, 0x30, 0x31, 0x65, 0x37, 0x33, 0x35, 0x34, 0x32, 0x63, 0x37, 0x37, 0x35, 0x66, 0x66, 0x35, 0x39, 0x64, 0x31, 0x31, 0x63, 0x64, 0x33, 0x35, 0x66, 0x38, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x33, 0x31, 0x32, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x35, 0x63, 0x66, 0x64, 0x61, 0x38, 0x34, 0x36, 0x35, 0x62, 0x61, 0x39, 0x63, 0x32, 0x36, 0x36, 0x31, 0x62, 0x32, 0x34, 0x39, 0x66, 0x63, 0x33, 0x61, 0x62, 0x36, 0x36, 0x31, 0x62, 0x64, 0x66, 0x61, 0x33, 0x35, 0x66, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x38, 0x39, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x30, 0x64, 0x30, 0x37, 0x36, 0x38, 0x31, 0x37, 0x65, 0x38, 0x64, 0x36, 0x38, 0x65, 0x65, 0x32, 0x64, 0x66, 0x34, 0x65, 0x31, 0x64, 0x61, 0x31, 0x63, 0x31, 0x31, 0x34, 0x32, 0x64, 0x31, 0x39, 0x38, 0x63, 0x34, 0x34, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x63, 0x32, 0x65, 0x36, 0x34, 0x65, 0x35, 0x64, 0x65, 0x35, 0x35, 0x38, 0x39, 0x65, 0x64, 0x32, 0x35, 0x30, 0x30, 0x36, 0x65, 0x38, 0x34, 0x33, 0x31, 0x39, 0x36, 0x65, 0x65, 0x39, 0x62, 0x31, 0x63, 0x66, 0x30, 0x62, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x32, 0x65, 0x35, 0x30, 0x34, 0x61, 0x32, 0x64, 0x31, 0x31, 0x32, 0x32, 0x62, 0x35, 0x61, 0x39, 0x66, 0x65, 0x65, 0x65, 0x35, 0x63, 0x62, 0x31, 0x34, 0x35, 0x31, 0x62, 0x66, 0x34, 0x63, 0x32, 0x61, 0x63, 0x65, 0x38, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x62, 0x39, 0x36, 0x61, 0x62, 0x32, 0x63, 0x61, 0x64, 0x35, 0x35, 0x64, 0x62, 0x31, 0x30, 0x30, 0x62, 0x35, 0x33, 0x30, 0x30, 0x31, 0x66, 0x39, 0x65, 0x34, 0x64, 0x62, 0x33, 0x37, 0x38, 0x31, 0x30, 0x34, 0x63, 0x38, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x32, 0x37, 0x64, 0x34, 0x38, 0x62, 0x62, 0x36, 0x63, 0x62, 0x38, 0x31, 0x34, 0x62, 0x63, 0x36, 0x30, 0x39, 0x63, 0x62, 0x63, 0x61, 0x61, 0x39, 0x31, 0x35, 0x31, 0x66, 0x35, 0x64, 0x34, 0x35, 0x39, 0x61, 0x32, 0x37, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x62, 0x64, 0x38, 0x64, 0x61, 0x66, 0x32, 0x37, 0x64, 0x64, 0x66, 0x37, 0x30, 0x34, 0x63, 0x64, 0x64, 0x30, 0x64, 0x39, 0x30, 0x39, 0x61, 0x37, 0x38, 0x39, 0x62, 0x61, 0x33, 0x36, 0x65, 0x64, 0x34, 0x66, 0x33, 0x37, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x64, 0x62, 0x64, 0x33, 0x62, 0x63, 0x37, 0x62, 0x30, 0x61, 0x66, 0x63, 0x30, 0x35, 0x64, 0x31, 0x64, 0x32, 0x65, 0x64, 0x61, 0x34, 0x39, 0x66, 0x66, 0x38, 0x36, 0x33, 0x39, 0x33, 0x39, 0x63, 0x34, 0x38, 0x64, 0x62, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x37, 0x65, 0x30, 0x33, 0x37, 0x30, 0x32, 0x37, 0x32, 0x33, 0x63, 0x62, 0x31, 0x36, 0x65, 0x65, 0x32, 0x37, 0x65, 0x32, 0x32, 0x64, 0x64, 0x30, 0x62, 0x38, 0x31, 0x35, 0x64, 0x63, 0x32, 0x64, 0x35, 0x63, 0x61, 0x65, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x32, 0x31, 0x30, 0x65, 0x37, 0x30, 0x34, 0x37, 0x38, 0x38, 0x36, 0x64, 0x61, 0x61, 0x35, 0x32, 0x61, 0x61, 0x66, 0x37, 0x30, 0x66, 0x34, 0x62, 0x39, 0x39, 0x31, 0x64, 0x61, 0x63, 0x36, 0x38, 0x65, 0x33, 0x30, 0x32, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x38, 0x30, 0x34, 0x38, 0x36, 0x38, 0x37, 0x66, 0x32, 0x62, 0x66, 0x63, 0x63, 0x39, 0x62, 0x64, 0x39, 0x30, 0x65, 0x64, 0x31, 0x38, 0x37, 0x33, 0x36, 0x63, 0x35, 0x37, 0x65, 0x64, 0x64, 0x33, 0x35, 0x32, 0x62, 0x36, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x63, 0x31, 0x38, 0x63, 0x32, 0x61, 0x32, 0x33, 0x38, 0x64, 0x64, 0x63, 0x34, 0x63, 0x62, 0x61, 0x32, 0x33, 0x30, 0x61, 0x30, 0x37, 0x32, 0x64, 0x64, 0x37, 0x64, 0x63, 0x31, 0x30, 0x31, 0x65, 0x36, 0x32, 0x30, 0x32, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x33, 0x64, 0x37, 0x36, 0x36, 0x63, 0x39, 0x38, 0x33, 0x66, 0x31, 0x39, 0x32, 0x62, 0x63, 0x65, 0x63, 0x61, 0x63, 0x37, 0x30, 0x66, 0x34, 0x65, 0x65, 0x30, 0x33, 0x64, 0x64, 0x39, 0x66, 0x66, 0x37, 0x31, 0x34, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x61, 0x36, 0x33, 0x64, 0x31, 0x38, 0x34, 0x32, 0x34, 0x35, 0x38, 0x37, 0x62, 0x39, 0x62, 0x33, 0x30, 0x37, 0x62, 0x66, 0x63, 0x33, 0x63, 0x33, 0x36, 0x34, 0x61, 0x65, 0x31, 0x30, 0x63, 0x64, 0x30, 0x34, 0x63, 0x37, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x62, 0x32, 0x64, 0x33, 0x34, 0x66, 0x30, 0x34, 0x38, 0x33, 0x34, 0x66, 0x62, 0x66, 0x37, 0x34, 0x37, 0x39, 0x36, 0x34, 0x39, 0x63, 0x61, 0x62, 0x39, 0x32, 0x33, 0x64, 0x32, 0x63, 0x34, 0x37, 0x32, 0x35, 0x63, 0x35, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x33, 0x34, 0x61, 0x63, 0x66, 0x33, 0x30, 0x31, 0x35, 0x33, 0x32, 0x32, 0x63, 0x35, 0x38, 0x33, 0x38, 0x32, 0x65, 0x65, 0x62, 0x32, 0x62, 0x37, 0x39, 0x36, 0x33, 0x38, 0x39, 0x30, 0x36, 0x65, 0x38, 0x38, 0x62, 0x36, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x35, 0x35, 0x31, 0x33, 0x39, 0x37, 0x66, 0x37, 0x39, 0x61, 0x32, 0x39, 0x38, 0x38, 0x62, 0x30, 0x36, 0x34, 0x61, 0x66, 0x64, 0x30, 0x65, 0x66, 0x65, 0x62, 0x65, 0x65, 0x38, 0x30, 0x32, 0x63, 0x37, 0x37, 0x32, 0x31, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x33, 0x37, 0x64, 0x33, 0x36, 0x61, 0x37, 0x30, 0x65, 0x65, 0x62, 0x38, 0x64, 0x33, 0x65, 0x35, 0x63, 0x38, 0x30, 0x64, 0x65, 0x38, 0x31, 0x35, 0x32, 0x32, 0x35, 0x63, 0x31, 0x31, 0x35, 0x38, 0x63, 0x62, 0x39, 0x32, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x35, 0x63, 0x65, 0x35, 0x31, 0x32, 0x39, 0x37, 0x61, 0x30, 0x37, 0x39, 0x33, 0x62, 0x38, 0x31, 0x32, 0x30, 0x36, 0x37, 0x66, 0x30, 0x31, 0x37, 0x62, 0x33, 0x65, 0x37, 0x62, 0x32, 0x64, 0x66, 0x39, 0x62, 0x62, 0x31, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x35, 0x62, 0x61, 0x36, 0x35, 0x66, 0x65, 0x62, 0x65, 0x32, 0x33, 0x65, 0x65, 0x66, 0x63, 0x32, 0x63, 0x38, 0x30, 0x32, 0x36, 0x36, 0x36, 0x61, 0x62, 0x31, 0x32, 0x36, 0x32, 0x33, 0x38, 0x32, 0x63, 0x66, 0x63, 0x34, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x63, 0x30, 0x64, 0x30, 0x38, 0x62, 0x33, 0x36, 0x65, 0x31, 0x38, 0x34, 0x66, 0x39, 0x39, 0x35, 0x32, 0x61, 0x34, 0x30, 0x33, 0x37, 0x65, 0x33, 0x65, 0x35, 0x33, 0x61, 0x36, 0x36, 0x37, 0x64, 0x30, 0x37, 0x30, 0x61, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x66, 0x65, 0x35, 0x61, 0x31, 0x62, 0x33, 0x32, 0x38, 0x62, 0x61, 0x65, 0x34, 0x34, 0x30, 0x37, 0x31, 0x31, 0x62, 0x65, 0x61, 0x66, 0x36, 0x61, 0x61, 0x64, 0x36, 0x30, 0x32, 0x36, 0x65, 0x64, 0x61, 0x36, 0x64, 0x32, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x64, 0x36, 0x37, 0x39, 0x65, 0x35, 0x66, 0x62, 0x30, 0x64, 0x61, 0x32, 0x61, 0x35, 0x64, 0x31, 0x31, 0x36, 0x31, 0x39, 0x34, 0x64, 0x63, 0x62, 0x35, 0x30, 0x38, 0x33, 0x31, 0x38, 0x65, 0x64, 0x63, 0x35, 0x38, 0x30, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x61, 0x64, 0x33, 0x36, 0x39, 0x66, 0x37, 0x35, 0x38, 0x66, 0x65, 0x66, 0x33, 0x38, 0x61, 0x31, 0x39, 0x61, 0x61, 0x33, 0x31, 0x34, 0x39, 0x33, 0x37, 0x39, 0x38, 0x33, 0x32, 0x63, 0x38, 0x31, 0x38, 0x65, 0x66, 0x32, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x38, 0x34, 0x36, 0x64, 0x63, 0x31, 0x32, 0x36, 0x35, 0x37, 0x65, 0x39, 0x31, 0x61, 0x66, 0x32, 0x35, 0x30, 0x30, 0x38, 0x35, 0x31, 0x39, 0x63, 0x33, 0x65, 0x38, 0x35, 0x37, 0x66, 0x35, 0x31, 0x37, 0x30, 0x37, 0x64, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x32, 0x64, 0x36, 0x65, 0x61, 0x64, 0x65, 0x61, 0x63, 0x66, 0x31, 0x62, 0x37, 0x38, 0x62, 0x33, 0x63, 0x61, 0x38, 0x35, 0x30, 0x33, 0x35, 0x63, 0x36, 0x33, 0x37, 0x62, 0x62, 0x31, 0x63, 0x65, 0x30, 0x31, 0x66, 0x34, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x36, 0x65, 0x62, 0x37, 0x63, 0x64, 0x37, 0x33, 0x31, 0x39, 0x62, 0x38, 0x32, 0x64, 0x64, 0x30, 0x37, 0x61, 0x31, 0x66, 0x33, 0x62, 0x34, 0x30, 0x39, 0x30, 0x37, 0x31, 0x64, 0x39, 0x36, 0x65, 0x33, 0x39, 0x36, 0x37, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x63, 0x39, 0x39, 0x30, 0x35, 0x61, 0x34, 0x63, 0x62, 0x36, 0x61, 0x62, 0x31, 0x63, 0x66, 0x64, 0x36, 0x32, 0x35, 0x34, 0x36, 0x65, 0x65, 0x35, 0x39, 0x31, 0x37, 0x33, 0x30, 0x30, 0x62, 0x38, 0x37, 0x63, 0x34, 0x66, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x36, 0x65, 0x35, 0x32, 0x65, 0x36, 0x62, 0x37, 0x37, 0x34, 0x38, 0x30, 0x62, 0x31, 0x38, 0x36, 0x37, 0x65, 0x66, 0x65, 0x63, 0x36, 0x34, 0x34, 0x36, 0x64, 0x39, 0x66, 0x63, 0x33, 0x63, 0x63, 0x33, 0x35, 0x37, 0x37, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x37, 0x36, 0x62, 0x32, 0x62, 0x62, 0x37, 0x35, 0x31, 0x63, 0x65, 0x37, 0x34, 0x38, 0x65, 0x31, 0x61, 0x34, 0x63, 0x34, 0x66, 0x66, 0x37, 0x62, 0x32, 0x33, 0x30, 0x62, 0x65, 0x30, 0x63, 0x31, 0x35, 0x64, 0x32, 0x32, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x35, 0x30, 0x35, 0x65, 0x36, 0x32, 0x61, 0x37, 0x34, 0x65, 0x38, 0x37, 0x65, 0x35, 0x37, 0x37, 0x34, 0x37, 0x33, 0x65, 0x34, 0x66, 0x33, 0x61, 0x66, 0x61, 0x31, 0x36, 0x62, 0x65, 0x64, 0x64, 0x33, 0x63, 0x66, 0x61, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x64, 0x30, 0x32, 0x37, 0x30, 0x35, 0x66, 0x33, 0x66, 0x36, 0x34, 0x39, 0x30, 0x35, 0x64, 0x38, 0x30, 0x65, 0x64, 0x39, 0x31, 0x34, 0x37, 0x39, 0x31, 0x33, 0x65, 0x61, 0x38, 0x63, 0x37, 0x33, 0x30, 0x37, 0x64, 0x36, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x31, 0x64, 0x61, 0x66, 0x31, 0x34, 0x38, 0x39, 0x31, 0x62, 0x38, 0x61, 0x31, 0x65, 0x31, 0x62, 0x64, 0x34, 0x32, 0x39, 0x64, 0x38, 0x62, 0x33, 0x36, 0x62, 0x39, 0x61, 0x34, 0x61, 0x61, 0x31, 0x64, 0x39, 0x61, 0x66, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x33, 0x38, 0x65, 0x66, 0x37, 0x30, 0x65, 0x61, 0x63, 0x39, 0x64, 0x64, 0x39, 0x61, 0x66, 0x35, 0x61, 0x30, 0x35, 0x30, 0x33, 0x62, 0x35, 0x65, 0x66, 0x61, 0x64, 0x31, 0x30, 0x33, 0x39, 0x65, 0x36, 0x37, 0x65, 0x37, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x63, 0x61, 0x38, 0x36, 0x62, 0x35, 0x65, 0x62, 0x31, 0x64, 0x30, 0x31, 0x38, 0x37, 0x34, 0x64, 0x66, 0x38, 0x65, 0x35, 0x66, 0x33, 0x34, 0x39, 0x34, 0x35, 0x64, 0x34, 0x39, 0x63, 0x36, 0x63, 0x31, 0x61, 0x62, 0x38, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x63, 0x63, 0x38, 0x62, 0x63, 0x62, 0x35, 0x35, 0x39, 0x34, 0x36, 0x35, 0x66, 0x38, 0x31, 0x62, 0x66, 0x65, 0x35, 0x38, 0x33, 0x62, 0x64, 0x37, 0x61, 0x62, 0x30, 0x61, 0x32, 0x33, 0x30, 0x36, 0x34, 0x35, 0x33, 0x62, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x33, 0x32, 0x33, 0x34, 0x35, 0x37, 0x65, 0x31, 0x38, 0x37, 0x37, 0x36, 0x31, 0x61, 0x38, 0x32, 0x37, 0x36, 0x65, 0x33, 0x35, 0x39, 0x62, 0x37, 0x62, 0x37, 0x61, 0x66, 0x33, 0x66, 0x33, 0x62, 0x36, 0x65, 0x33, 0x64, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x38, 0x32, 0x64, 0x37, 0x37, 0x30, 0x30, 0x63, 0x31, 0x32, 0x33, 0x62, 0x62, 0x39, 0x31, 0x39, 0x34, 0x31, 0x39, 0x62, 0x62, 0x61, 0x66, 0x30, 0x34, 0x36, 0x37, 0x39, 0x39, 0x63, 0x36, 0x62, 0x30, 0x65, 0x32, 0x63, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x36, 0x36, 0x61, 0x62, 0x62, 0x63, 0x32, 0x64, 0x33, 0x30, 0x63, 0x65, 0x32, 0x31, 0x61, 0x38, 0x33, 0x33, 0x62, 0x30, 0x64, 0x62, 0x38, 0x65, 0x35, 0x36, 0x31, 0x64, 0x35, 0x31, 0x30, 0x35, 0x65, 0x30, 0x61, 0x37, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x39, 0x39, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x65, 0x35, 0x33, 0x38, 0x36, 0x36, 0x66, 0x63, 0x32, 0x64, 0x31, 0x34, 0x64, 0x35, 0x37, 0x32, 0x61, 0x62, 0x37, 0x33, 0x62, 0x34, 0x61, 0x30, 0x36, 0x35, 0x61, 0x31, 0x31, 0x38, 0x38, 0x32, 0x36, 0x37, 0x66, 0x35, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x66, 0x35, 0x63, 0x39, 0x38, 0x39, 0x34, 0x63, 0x33, 0x33, 0x65, 0x34, 0x32, 0x63, 0x32, 0x63, 0x35, 0x31, 0x38, 0x65, 0x33, 0x61, 0x63, 0x36, 0x37, 0x30, 0x65, 0x61, 0x39, 0x35, 0x30, 0x35, 0x64, 0x31, 0x62, 0x35, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x61, 0x32, 0x35, 0x63, 0x37, 0x61, 0x35, 0x30, 0x33, 0x63, 0x63, 0x38, 0x65, 0x30, 0x64, 0x30, 0x34, 0x39, 0x37, 0x31, 0x63, 0x61, 0x30, 0x35, 0x63, 0x37, 0x36, 0x32, 0x66, 0x39, 0x62, 0x37, 0x36, 0x32, 0x62, 0x34, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x61, 0x33, 0x30, 0x34, 0x32, 0x38, 0x31, 0x39, 0x61, 0x66, 0x33, 0x65, 0x36, 0x36, 0x32, 0x39, 0x30, 0x30, 0x65, 0x31, 0x62, 0x39, 0x32, 0x62, 0x34, 0x33, 0x35, 0x38, 0x65, 0x64, 0x61, 0x36, 0x65, 0x39, 0x32, 0x35, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x64, 0x37, 0x63, 0x33, 0x38, 0x61, 0x34, 0x32, 0x31, 0x30, 0x33, 0x30, 0x34, 0x61, 0x34, 0x64, 0x36, 0x35, 0x33, 0x65, 0x64, 0x65, 0x66, 0x66, 0x31, 0x62, 0x33, 0x63, 0x65, 0x34, 0x35, 0x66, 0x63, 0x65, 0x37, 0x38, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x63, 0x32, 0x32, 0x66, 0x62, 0x39, 0x32, 0x63, 0x36, 0x33, 0x38, 0x65, 0x31, 0x65, 0x32, 0x31, 0x66, 0x66, 0x35, 0x63, 0x66, 0x30, 0x33, 0x39, 0x64, 0x61, 0x61, 0x36, 0x65, 0x37, 0x33, 0x34, 0x64, 0x61, 0x66, 0x62, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x66, 0x31, 0x39, 0x33, 0x61, 0x30, 0x35, 0x39, 0x32, 0x66, 0x31, 0x66, 0x65, 0x62, 0x39, 0x66, 0x64, 0x66, 0x63, 0x39, 0x30, 0x61, 0x61, 0x38, 0x31, 0x33, 0x37, 0x38, 0x34, 0x65, 0x62, 0x38, 0x30, 0x34, 0x37, 0x31, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x37, 0x66, 0x64, 0x65, 0x30, 0x62, 0x36, 0x37, 0x37, 0x31, 0x36, 0x33, 0x32, 0x35, 0x63, 0x66, 0x30, 0x65, 0x63, 0x63, 0x65, 0x38, 0x61, 0x31, 0x39, 0x31, 0x61, 0x33, 0x37, 0x36, 0x31, 0x62, 0x32, 0x63, 0x37, 0x39, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x30, 0x32, 0x33, 0x37, 0x63, 0x66, 0x39, 0x31, 0x31, 0x37, 0x65, 0x37, 0x36, 0x37, 0x39, 0x32, 0x32, 0x66, 0x63, 0x34, 0x61, 0x31, 0x62, 0x37, 0x38, 0x64, 0x37, 0x39, 0x36, 0x34, 0x64, 0x61, 0x38, 0x32, 0x64, 0x66, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x32, 0x66, 0x39, 0x35, 0x37, 0x36, 0x36, 0x64, 0x35, 0x37, 0x62, 0x35, 0x63, 0x64, 0x34, 0x62, 0x31, 0x37, 0x33, 0x32, 0x38, 0x39, 0x64, 0x36, 0x38, 0x37, 0x36, 0x66, 0x39, 0x65, 0x36, 0x34, 0x35, 0x35, 0x38, 0x31, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x64, 0x35, 0x39, 0x63, 0x38, 0x39, 0x32, 0x33, 0x37, 0x35, 0x39, 0x30, 0x37, 0x33, 0x64, 0x36, 0x66, 0x34, 0x31, 0x35, 0x61, 0x61, 0x66, 0x38, 0x65, 0x62, 0x30, 0x36, 0x35, 0x66, 0x66, 0x32, 0x66, 0x33, 0x62, 0x36, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x33, 0x64, 0x37, 0x39, 0x66, 0x37, 0x63, 0x62, 0x39, 0x62, 0x37, 0x30, 0x39, 0x35, 0x32, 0x66, 0x64, 0x33, 0x30, 0x66, 0x63, 0x65, 0x35, 0x38, 0x64, 0x35, 0x34, 0x62, 0x39, 0x66, 0x30, 0x62, 0x35, 0x39, 0x66, 0x36, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x38, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x62, 0x32, 0x38, 0x31, 0x63, 0x33, 0x32, 0x37, 0x31, 0x39, 0x63, 0x34, 0x30, 0x66, 0x64, 0x62, 0x33, 0x65, 0x32, 0x31, 0x36, 0x64, 0x62, 0x30, 0x66, 0x33, 0x37, 0x66, 0x62, 0x63, 0x37, 0x33, 0x61, 0x30, 0x32, 0x36, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x36, 0x35, 0x31, 0x31, 0x66, 0x64, 0x37, 0x61, 0x33, 0x38, 0x30, 0x30, 0x62, 0x32, 0x36, 0x38, 0x35, 0x34, 0x63, 0x37, 0x65, 0x63, 0x33, 0x39, 0x63, 0x30, 0x64, 0x63, 0x62, 0x35, 0x66, 0x34, 0x63, 0x34, 0x65, 0x38, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x62, 0x61, 0x38, 0x37, 0x63, 0x37, 0x37, 0x65, 0x39, 0x62, 0x35, 0x39, 0x36, 0x64, 0x65, 0x37, 0x62, 0x61, 0x30, 0x65, 0x33, 0x32, 0x36, 0x66, 0x64, 0x64, 0x66, 0x65, 0x65, 0x63, 0x32, 0x31, 0x36, 0x33, 0x65, 0x66, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x31, 0x31, 0x32, 0x31, 0x38, 0x32, 0x39, 0x63, 0x39, 0x61, 0x30, 0x38, 0x32, 0x38, 0x34, 0x30, 0x38, 0x37, 0x61, 0x34, 0x33, 0x66, 0x62, 0x64, 0x32, 0x66, 0x63, 0x31, 0x31, 0x34, 0x32, 0x61, 0x33, 0x32, 0x33, 0x33, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x61, 0x32, 0x35, 0x38, 0x31, 0x32, 0x61, 0x62, 0x35, 0x36, 0x64, 0x63, 0x63, 0x34, 0x32, 0x33, 0x31, 0x37, 0x35, 0x65, 0x64, 0x31, 0x64, 0x38, 0x61, 0x64, 0x61, 0x63, 0x63, 0x65, 0x33, 0x33, 0x63, 0x64, 0x31, 0x38, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x38, 0x63, 0x65, 0x66, 0x32, 0x37, 0x62, 0x31, 0x30, 0x35, 0x38, 0x32, 0x62, 0x36, 0x64, 0x31, 0x34, 0x66, 0x36, 0x39, 0x34, 0x38, 0x33, 0x64, 0x64, 0x61, 0x61, 0x30, 0x64, 0x64, 0x33, 0x63, 0x38, 0x37, 0x62, 0x62, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x31, 0x36, 0x31, 0x37, 0x34, 0x39, 0x66, 0x65, 0x64, 0x63, 0x66, 0x31, 0x63, 0x37, 0x32, 0x31, 0x66, 0x32, 0x32, 0x30, 0x32, 0x64, 0x31, 0x33, 0x61, 0x64, 0x65, 0x32, 0x61, 0x62, 0x63, 0x66, 0x34, 0x36, 0x30, 0x62, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x33, 0x36, 0x63, 0x31, 0x37, 0x32, 0x35, 0x33, 0x63, 0x31, 0x31, 0x63, 0x66, 0x33, 0x38, 0x39, 0x37, 0x34, 0x65, 0x64, 0x30, 0x64, 0x62, 0x31, 0x62, 0x37, 0x35, 0x39, 0x31, 0x36, 0x30, 0x64, 0x61, 0x36, 0x33, 0x37, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x66, 0x61, 0x37, 0x36, 0x64, 0x62, 0x30, 0x34, 0x63, 0x65, 0x33, 0x38, 0x66, 0x62, 0x32, 0x30, 0x35, 0x64, 0x33, 0x37, 0x62, 0x38, 0x64, 0x33, 0x37, 0x37, 0x63, 0x66, 0x31, 0x33, 0x38, 0x30, 0x64, 0x61, 0x30, 0x33, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x65, 0x38, 0x33, 0x37, 0x37, 0x32, 0x62, 0x63, 0x32, 0x30, 0x30, 0x66, 0x39, 0x30, 0x30, 0x36, 0x61, 0x61, 0x32, 0x61, 0x32, 0x36, 0x30, 0x64, 0x62, 0x61, 0x61, 0x38, 0x34, 0x38, 0x33, 0x64, 0x63, 0x35, 0x32, 0x62, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x37, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x37, 0x65, 0x61, 0x63, 0x36, 0x64, 0x36, 0x30, 0x32, 0x62, 0x34, 0x31, 0x30, 0x39, 0x63, 0x39, 0x36, 0x37, 0x31, 0x62, 0x66, 0x35, 0x37, 0x62, 0x39, 0x35, 0x30, 0x63, 0x32, 0x63, 0x66, 0x64, 0x62, 0x39, 0x39, 0x64, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x30, 0x36, 0x61, 0x64, 0x38, 0x34, 0x31, 0x64, 0x66, 0x66, 0x62, 0x65, 0x34, 0x63, 0x63, 0x66, 0x34, 0x36, 0x66, 0x31, 0x30, 0x33, 0x39, 0x66, 0x63, 0x33, 0x38, 0x36, 0x66, 0x33, 0x63, 0x33, 0x32, 0x31, 0x34, 0x34, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x66, 0x39, 0x30, 0x33, 0x63, 0x31, 0x65, 0x34, 0x38, 0x61, 0x63, 0x34, 0x32, 0x31, 0x61, 0x62, 0x34, 0x38, 0x35, 0x32, 0x38, 0x66, 0x33, 0x64, 0x34, 0x61, 0x32, 0x36, 0x34, 0x38, 0x30, 0x38, 0x30, 0x66, 0x65, 0x30, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x38, 0x37, 0x32, 0x62, 0x31, 0x32, 0x32, 0x65, 0x39, 0x39, 0x34, 0x65, 0x66, 0x32, 0x37, 0x63, 0x37, 0x31, 0x64, 0x37, 0x64, 0x65, 0x62, 0x34, 0x35, 0x37, 0x62, 0x66, 0x36, 0x35, 0x34, 0x32, 0x39, 0x65, 0x63, 0x61, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x39, 0x39, 0x39, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x34, 0x30, 0x38, 0x33, 0x65, 0x63, 0x65, 0x61, 0x33, 0x38, 0x35, 0x30, 0x31, 0x37, 0x61, 0x61, 0x34, 0x30, 0x62, 0x64, 0x64, 0x33, 0x35, 0x65, 0x66, 0x37, 0x65, 0x66, 0x66, 0x62, 0x34, 0x63, 0x65, 0x37, 0x37, 0x36, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x33, 0x37, 0x30, 0x39, 0x33, 0x39, 0x31, 0x66, 0x33, 0x66, 0x62, 0x65, 0x62, 0x61, 0x33, 0x35, 0x39, 0x32, 0x64, 0x31, 0x37, 0x35, 0x63, 0x37, 0x34, 0x30, 0x65, 0x38, 0x37, 0x61, 0x30, 0x39, 0x35, 0x34, 0x31, 0x64, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x38, 0x65, 0x39, 0x34, 0x39, 0x31, 0x37, 0x30, 0x38, 0x33, 0x64, 0x31, 0x35, 0x32, 0x32, 0x30, 0x32, 0x62, 0x35, 0x33, 0x31, 0x36, 0x33, 0x39, 0x33, 0x39, 0x38, 0x36, 0x39, 0x64, 0x32, 0x37, 0x31, 0x31, 0x37, 0x35, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x64, 0x34, 0x63, 0x38, 0x66, 0x30, 0x30, 0x36, 0x61, 0x32, 0x37, 0x63, 0x31, 0x65, 0x35, 0x66, 0x37, 0x63, 0x65, 0x32, 0x30, 0x35, 0x64, 0x65, 0x37, 0x35, 0x66, 0x35, 0x31, 0x36, 0x62, 0x66, 0x62, 0x39, 0x66, 0x37, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x61, 0x36, 0x62, 0x64, 0x34, 0x31, 0x66, 0x39, 0x64, 0x39, 0x63, 0x33, 0x32, 0x30, 0x31, 0x65, 0x30, 0x35, 0x30, 0x62, 0x38, 0x37, 0x31, 0x39, 0x38, 0x66, 0x62, 0x64, 0x61, 0x33, 0x39, 0x39, 0x33, 0x34, 0x32, 0x32, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x32, 0x32, 0x36, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x30, 0x61, 0x61, 0x64, 0x61, 0x65, 0x31, 0x32, 0x32, 0x31, 0x62, 0x30, 0x37, 0x61, 0x66, 0x65, 0x61, 0x33, 0x39, 0x66, 0x62, 0x61, 0x32, 0x65, 0x64, 0x36, 0x32, 0x65, 0x30, 0x35, 0x65, 0x35, 0x62, 0x37, 0x62, 0x35, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x65, 0x64, 0x63, 0x34, 0x32, 0x36, 0x37, 0x63, 0x63, 0x62, 0x38, 0x39, 0x62, 0x33, 0x31, 0x62, 0x62, 0x37, 0x36, 0x34, 0x64, 0x37, 0x32, 0x31, 0x31, 0x31, 0x37, 0x31, 0x30, 0x30, 0x38, 0x64, 0x39, 0x34, 0x64, 0x34, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x32, 0x39, 0x64, 0x63, 0x63, 0x32, 0x30, 0x33, 0x62, 0x31, 0x65, 0x64, 0x63, 0x63, 0x66, 0x64, 0x66, 0x30, 0x36, 0x65, 0x38, 0x37, 0x39, 0x31, 0x30, 0x63, 0x34, 0x35, 0x32, 0x61, 0x31, 0x66, 0x34, 0x64, 0x37, 0x61, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x62, 0x65, 0x33, 0x61, 0x65, 0x35, 0x34, 0x66, 0x36, 0x32, 0x64, 0x36, 0x36, 0x33, 0x62, 0x30, 0x64, 0x34, 0x63, 0x63, 0x39, 0x65, 0x31, 0x65, 0x61, 0x38, 0x66, 0x65, 0x39, 0x35, 0x35, 0x36, 0x65, 0x61, 0x39, 0x65, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x30, 0x63, 0x39, 0x64, 0x30, 0x30, 0x35, 0x65, 0x61, 0x30, 0x31, 0x36, 0x63, 0x32, 0x39, 0x35, 0x63, 0x64, 0x37, 0x39, 0x35, 0x63, 0x63, 0x39, 0x32, 0x31, 0x33, 0x65, 0x38, 0x37, 0x66, 0x65, 0x62, 0x63, 0x33, 0x33, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x64, 0x30, 0x35, 0x37, 0x62, 0x63, 0x63, 0x30, 0x34, 0x62, 0x64, 0x30, 0x66, 0x34, 0x61, 0x66, 0x39, 0x36, 0x34, 0x32, 0x35, 0x31, 0x33, 0x61, 0x61, 0x35, 0x30, 0x39, 0x30, 0x62, 0x62, 0x33, 0x66, 0x66, 0x39, 0x33, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x36, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x39, 0x65, 0x30, 0x33, 0x30, 0x63, 0x61, 0x37, 0x35, 0x63, 0x62, 0x31, 0x64, 0x32, 0x39, 0x65, 0x61, 0x30, 0x31, 0x64, 0x30, 0x64, 0x34, 0x63, 0x64, 0x66, 0x64, 0x63, 0x63, 0x64, 0x33, 0x38, 0x34, 0x34, 0x62, 0x36, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x63, 0x34, 0x63, 0x65, 0x30, 0x36, 0x64, 0x39, 0x61, 0x63, 0x31, 0x38, 0x35, 0x62, 0x62, 0x31, 0x34, 0x38, 0x64, 0x39, 0x36, 0x66, 0x37, 0x62, 0x37, 0x61, 0x62, 0x65, 0x37, 0x33, 0x66, 0x34, 0x34, 0x31, 0x30, 0x30, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x30, 0x34, 0x31, 0x31, 0x35, 0x63, 0x33, 0x65, 0x35, 0x32, 0x39, 0x36, 0x31, 0x62, 0x30, 0x64, 0x63, 0x30, 0x62, 0x30, 0x62, 0x66, 0x33, 0x31, 0x66, 0x62, 0x61, 0x34, 0x35, 0x34, 0x36, 0x66, 0x35, 0x39, 0x36, 0x36, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x35, 0x39, 0x64, 0x63, 0x65, 0x30, 0x32, 0x65, 0x39, 0x31, 0x64, 0x39, 0x64, 0x62, 0x30, 0x32, 0x62, 0x31, 0x62, 0x64, 0x38, 0x62, 0x37, 0x64, 0x31, 0x37, 0x61, 0x39, 0x63, 0x34, 0x31, 0x61, 0x39, 0x37, 0x61, 0x66, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x31, 0x35, 0x34, 0x37, 0x62, 0x61, 0x34, 0x32, 0x66, 0x63, 0x61, 0x66, 0x61, 0x66, 0x39, 0x33, 0x39, 0x33, 0x38, 0x62, 0x65, 0x63, 0x66, 0x37, 0x36, 0x39, 0x39, 0x66, 0x37, 0x34, 0x32, 0x39, 0x30, 0x61, 0x66, 0x37, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x39, 0x33, 0x64, 0x36, 0x65, 0x33, 0x37, 0x64, 0x31, 0x34, 0x62, 0x35, 0x36, 0x36, 0x36, 0x34, 0x33, 0x61, 0x63, 0x34, 0x31, 0x33, 0x35, 0x66, 0x32, 0x34, 0x33, 0x63, 0x61, 0x61, 0x30, 0x37, 0x38, 0x37, 0x63, 0x31, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x30, 0x65, 0x65, 0x31, 0x33, 0x34, 0x64, 0x38, 0x62, 0x33, 0x36, 0x31, 0x34, 0x35, 0x62, 0x34, 0x37, 0x62, 0x65, 0x65, 0x65, 0x37, 0x61, 0x66, 0x38, 0x64, 0x32, 0x37, 0x33, 0x38, 0x64, 0x62, 0x64, 0x61, 0x30, 0x38, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x66, 0x35, 0x34, 0x61, 0x63, 0x37, 0x32, 0x36, 0x34, 0x64, 0x32, 0x32, 0x35, 0x34, 0x61, 0x62, 0x62, 0x62, 0x35, 0x66, 0x38, 0x62, 0x34, 0x31, 0x61, 0x64, 0x64, 0x65, 0x38, 0x37, 0x35, 0x31, 0x35, 0x37, 0x64, 0x62, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x34, 0x39, 0x36, 0x33, 0x34, 0x64, 0x63, 0x32, 0x61, 0x39, 0x65, 0x38, 0x30, 0x63, 0x33, 0x66, 0x37, 0x37, 0x32, 0x31, 0x65, 0x65, 0x32, 0x62, 0x35, 0x30, 0x34, 0x36, 0x61, 0x65, 0x61, 0x61, 0x65, 0x64, 0x66, 0x62, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x33, 0x65, 0x34, 0x39, 0x31, 0x33, 0x35, 0x63, 0x33, 0x33, 0x39, 0x31, 0x39, 0x39, 0x31, 0x30, 0x36, 0x30, 0x32, 0x39, 0x30, 0x61, 0x61, 0x37, 0x66, 0x36, 0x63, 0x63, 0x62, 0x38, 0x66, 0x38, 0x35, 0x61, 0x37, 0x38, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x32, 0x33, 0x36, 0x64, 0x34, 0x63, 0x39, 0x30, 0x64, 0x30, 0x36, 0x35, 0x66, 0x39, 0x65, 0x33, 0x39, 0x33, 0x38, 0x33, 0x35, 0x38, 0x61, 0x61, 0x66, 0x66, 0x64, 0x37, 0x37, 0x37, 0x62, 0x38, 0x36, 0x61, 0x65, 0x63, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x61, 0x62, 0x64, 0x38, 0x34, 0x61, 0x31, 0x38, 0x31, 0x30, 0x39, 0x33, 0x65, 0x35, 0x65, 0x32, 0x32, 0x39, 0x31, 0x33, 0x36, 0x66, 0x34, 0x32, 0x64, 0x38, 0x33, 0x35, 0x65, 0x38, 0x32, 0x33, 0x35, 0x64, 0x65, 0x31, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x36, 0x61, 0x37, 0x38, 0x30, 0x30, 0x32, 0x38, 0x30, 0x33, 0x39, 0x63, 0x38, 0x31, 0x63, 0x61, 0x66, 0x33, 0x37, 0x62, 0x36, 0x37, 0x37, 0x35, 0x63, 0x36, 0x32, 0x30, 0x65, 0x37, 0x38, 0x36, 0x39, 0x35, 0x34, 0x37, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x64, 0x66, 0x37, 0x33, 0x62, 0x64, 0x33, 0x37, 0x37, 0x66, 0x32, 0x63, 0x30, 0x39, 0x64, 0x65, 0x36, 0x33, 0x63, 0x34, 0x35, 0x64, 0x36, 0x37, 0x66, 0x32, 0x38, 0x33, 0x65, 0x61, 0x65, 0x66, 0x61, 0x30, 0x66, 0x34, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x37, 0x30, 0x62, 0x30, 0x32, 0x66, 0x32, 0x63, 0x33, 0x63, 0x66, 0x38, 0x66, 0x64, 0x34, 0x66, 0x34, 0x37, 0x33, 0x30, 0x66, 0x33, 0x33, 0x38, 0x31, 0x61, 0x37, 0x31, 0x65, 0x61, 0x34, 0x33, 0x31, 0x63, 0x33, 0x33, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x61, 0x61, 0x31, 0x31, 0x35, 0x31, 0x62, 0x62, 0x37, 0x36, 0x35, 0x66, 0x61, 0x33, 0x61, 0x38, 0x39, 0x63, 0x61, 0x35, 0x30, 0x65, 0x62, 0x36, 0x65, 0x31, 0x62, 0x31, 0x63, 0x37, 0x30, 0x36, 0x34, 0x31, 0x37, 0x66, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x32, 0x32, 0x37, 0x64, 0x36, 0x35, 0x33, 0x33, 0x34, 0x65, 0x36, 0x39, 0x31, 0x63, 0x66, 0x32, 0x33, 0x31, 0x62, 0x34, 0x61, 0x34, 0x65, 0x31, 0x64, 0x33, 0x33, 0x39, 0x62, 0x39, 0x35, 0x64, 0x35, 0x39, 0x38, 0x61, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x35, 0x35, 0x35, 0x30, 0x36, 0x35, 0x36, 0x63, 0x62, 0x66, 0x39, 0x30, 0x62, 0x37, 0x35, 0x64, 0x39, 0x32, 0x61, 0x64, 0x39, 0x31, 0x32, 0x32, 0x64, 0x39, 0x30, 0x64, 0x32, 0x33, 0x63, 0x61, 0x36, 0x38, 0x63, 0x61, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x38, 0x31, 0x37, 0x33, 0x33, 0x34, 0x37, 0x33, 0x65, 0x30, 0x30, 0x64, 0x38, 0x37, 0x66, 0x31, 0x31, 0x65, 0x39, 0x39, 0x35, 0x35, 0x65, 0x35, 0x38, 0x39, 0x62, 0x35, 0x39, 0x66, 0x34, 0x61, 0x63, 0x32, 0x38, 0x65, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x61, 0x39, 0x36, 0x62, 0x66, 0x32, 0x32, 0x34, 0x32, 0x65, 0x61, 0x31, 0x62, 0x33, 0x39, 0x65, 0x63, 0x65, 0x36, 0x66, 0x63, 0x63, 0x30, 0x64, 0x31, 0x38, 0x61, 0x65, 0x64, 0x30, 0x30, 0x63, 0x30, 0x31, 0x37, 0x39, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x63, 0x66, 0x39, 0x34, 0x66, 0x38, 0x30, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x35, 0x35, 0x66, 0x30, 0x31, 0x30, 0x61, 0x62, 0x34, 0x62, 0x61, 0x63, 0x36, 0x39, 0x36, 0x65, 0x30, 0x63, 0x61, 0x30, 0x66, 0x36, 0x37, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x39, 0x31, 0x62, 0x34, 0x64, 0x31, 0x37, 0x36, 0x64, 0x34, 0x37, 0x36, 0x63, 0x65, 0x61, 0x31, 0x36, 0x34, 0x65, 0x35, 0x66, 0x62, 0x35, 0x33, 0x35, 0x63, 0x36, 0x39, 0x37, 0x30, 0x30, 0x63, 0x62, 0x32, 0x35, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x32, 0x66, 0x32, 0x62, 0x64, 0x32, 0x32, 0x39, 0x64, 0x64, 0x66, 0x33, 0x63, 0x62, 0x30, 0x66, 0x64, 0x61, 0x66, 0x34, 0x35, 0x35, 0x63, 0x31, 0x38, 0x33, 0x32, 0x30, 0x39, 0x63, 0x30, 0x65, 0x31, 0x65, 0x33, 0x39, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x66, 0x63, 0x39, 0x39, 0x64, 0x35, 0x65, 0x62, 0x62, 0x34, 0x61, 0x38, 0x34, 0x66, 0x65, 0x37, 0x37, 0x38, 0x38, 0x64, 0x39, 0x37, 0x64, 0x63, 0x65, 0x32, 0x37, 0x34, 0x62, 0x30, 0x33, 0x38, 0x32, 0x34, 0x30, 0x34, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x64, 0x66, 0x38, 0x66, 0x34, 0x38, 0x65, 0x65, 0x30, 0x30, 0x39, 0x32, 0x35, 0x36, 0x65, 0x61, 0x37, 0x39, 0x37, 0x65, 0x31, 0x66, 0x61, 0x33, 0x36, 0x39, 0x62, 0x65, 0x65, 0x62, 0x63, 0x66, 0x36, 0x62, 0x63, 0x36, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x32, 0x36, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x37, 0x32, 0x64, 0x36, 0x33, 0x35, 0x61, 0x61, 0x64, 0x65, 0x65, 0x65, 0x34, 0x33, 0x38, 0x32, 0x33, 0x34, 0x39, 0x64, 0x62, 0x39, 0x38, 0x61, 0x31, 0x38, 0x31, 0x33, 0x61, 0x34, 0x63, 0x66, 0x65, 0x62, 0x33, 0x64, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x32, 0x36, 0x66, 0x39, 0x61, 0x35, 0x33, 0x30, 0x35, 0x66, 0x38, 0x33, 0x38, 0x31, 0x30, 0x39, 0x34, 0x33, 0x35, 0x34, 0x64, 0x62, 0x66, 0x63, 0x39, 0x32, 0x36, 0x36, 0x34, 0x65, 0x38, 0x34, 0x66, 0x39, 0x30, 0x32, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x38, 0x33, 0x62, 0x38, 0x65, 0x64, 0x62, 0x31, 0x30, 0x61, 0x32, 0x35, 0x35, 0x32, 0x38, 0x61, 0x34, 0x34, 0x30, 0x34, 0x64, 0x65, 0x31, 0x63, 0x36, 0x35, 0x65, 0x37, 0x34, 0x31, 0x30, 0x64, 0x62, 0x63, 0x61, 0x61, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x38, 0x35, 0x39, 0x66, 0x63, 0x30, 0x37, 0x66, 0x37, 0x35, 0x36, 0x65, 0x61, 0x37, 0x64, 0x63, 0x65, 0x62, 0x62, 0x63, 0x63, 0x64, 0x34, 0x32, 0x66, 0x30, 0x35, 0x38, 0x31, 0x37, 0x35, 0x38, 0x32, 0x64, 0x39, 0x37, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x38, 0x31, 0x38, 0x31, 0x61, 0x34, 0x35, 0x38, 0x61, 0x34, 0x34, 0x30, 0x66, 0x31, 0x63, 0x36, 0x62, 0x62, 0x31, 0x64, 0x65, 0x38, 0x34, 0x30, 0x30, 0x32, 0x38, 0x31, 0x61, 0x33, 0x31, 0x34, 0x38, 0x66, 0x34, 0x63, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x62, 0x31, 0x36, 0x39, 0x34, 0x65, 0x61, 0x66, 0x61, 0x31, 0x36, 0x35, 0x65, 0x62, 0x64, 0x37, 0x63, 0x63, 0x37, 0x62, 0x63, 0x39, 0x39, 0x65, 0x37, 0x34, 0x38, 0x31, 0x34, 0x61, 0x39, 0x35, 0x31, 0x34, 0x31, 0x39, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x63, 0x63, 0x38, 0x61, 0x62, 0x32, 0x33, 0x63, 0x30, 0x30, 0x64, 0x31, 0x62, 0x38, 0x32, 0x61, 0x63, 0x64, 0x37, 0x64, 0x37, 0x33, 0x66, 0x33, 0x38, 0x63, 0x39, 0x39, 0x65, 0x30, 0x64, 0x30, 0x35, 0x61, 0x34, 0x66, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x36, 0x30, 0x38, 0x32, 0x63, 0x62, 0x37, 0x65, 0x65, 0x64, 0x34, 0x62, 0x31, 0x39, 0x39, 0x33, 0x61, 0x64, 0x32, 0x34, 0x35, 0x61, 0x34, 0x37, 0x37, 0x32, 0x36, 0x37, 0x65, 0x31, 0x63, 0x33, 0x33, 0x63, 0x64, 0x35, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x34, 0x37, 0x66, 0x63, 0x33, 0x65, 0x31, 0x37, 0x37, 0x66, 0x35, 0x36, 0x37, 0x61, 0x31, 0x65, 0x33, 0x38, 0x39, 0x33, 0x65, 0x30, 0x30, 0x30, 0x65, 0x33, 0x36, 0x62, 0x62, 0x61, 0x32, 0x33, 0x35, 0x32, 0x30, 0x61, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x34, 0x61, 0x37, 0x36, 0x66, 0x30, 0x36, 0x39, 0x33, 0x35, 0x33, 0x38, 0x38, 0x64, 0x64, 0x65, 0x35, 0x65, 0x32, 0x33, 0x34, 0x36, 0x39, 0x36, 0x61, 0x30, 0x36, 0x36, 0x38, 0x62, 0x63, 0x32, 0x30, 0x64, 0x32, 0x64, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x31, 0x66, 0x61, 0x30, 0x62, 0x61, 0x64, 0x61, 0x64, 0x64, 0x62, 0x39, 0x61, 0x39, 0x37, 0x65, 0x38, 0x38, 0x64, 0x33, 0x66, 0x34, 0x64, 0x62, 0x37, 0x63, 0x35, 0x35, 0x64, 0x36, 0x62, 0x62, 0x37, 0x34, 0x33, 0x30, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x34, 0x64, 0x65, 0x31, 0x62, 0x33, 0x66, 0x33, 0x38, 0x64, 0x39, 0x31, 0x35, 0x38, 0x34, 0x36, 0x61, 0x65, 0x33, 0x37, 0x31, 0x38, 0x35, 0x36, 0x34, 0x61, 0x35, 0x61, 0x64, 0x61, 0x32, 0x30, 0x63, 0x32, 0x66, 0x33, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x31, 0x36, 0x63, 0x32, 0x36, 0x38, 0x37, 0x37, 0x37, 0x37, 0x62, 0x36, 0x64, 0x37, 0x64, 0x32, 0x61, 0x32, 0x34, 0x33, 0x32, 0x64, 0x35, 0x39, 0x61, 0x34, 0x31, 0x66, 0x61, 0x30, 0x35, 0x39, 0x65, 0x33, 0x61, 0x34, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x30, 0x39, 0x35, 0x35, 0x61, 0x61, 0x36, 0x65, 0x33, 0x34, 0x31, 0x35, 0x37, 0x31, 0x39, 0x38, 0x36, 0x36, 0x30, 0x38, 0x62, 0x64, 0x63, 0x38, 0x39, 0x31, 0x63, 0x32, 0x31, 0x33, 0x39, 0x66, 0x35, 0x34, 0x30, 0x63, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x34, 0x34, 0x39, 0x37, 0x34, 0x61, 0x33, 0x31, 0x64, 0x31, 0x38, 0x37, 0x65, 0x64, 0x61, 0x31, 0x36, 0x64, 0x64, 0x64, 0x34, 0x37, 0x62, 0x39, 0x63, 0x37, 0x65, 0x63, 0x35, 0x30, 0x30, 0x32, 0x64, 0x36, 0x31, 0x66, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x61, 0x62, 0x65, 0x63, 0x35, 0x61, 0x61, 0x33, 0x36, 0x65, 0x35, 0x63, 0x39, 0x64, 0x30, 0x39, 0x38, 0x66, 0x31, 0x62, 0x39, 0x34, 0x32, 0x38, 0x38, 0x31, 0x62, 0x64, 0x35, 0x61, 0x63, 0x61, 0x63, 0x36, 0x39, 0x36, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x34, 0x66, 0x34, 0x39, 0x34, 0x62, 0x33, 0x66, 0x32, 0x65, 0x31, 0x34, 0x33, 0x63, 0x32, 0x66, 0x66, 0x63, 0x39, 0x37, 0x33, 0x38, 0x63, 0x62, 0x66, 0x64, 0x39, 0x35, 0x30, 0x31, 0x38, 0x35, 0x30, 0x62, 0x38, 0x37, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x61, 0x33, 0x66, 0x66, 0x64, 0x34, 0x36, 0x38, 0x33, 0x66, 0x62, 0x61, 0x30, 0x61, 0x64, 0x33, 0x62, 0x62, 0x63, 0x39, 0x30, 0x37, 0x33, 0x34, 0x62, 0x36, 0x31, 0x31, 0x64, 0x61, 0x39, 0x63, 0x66, 0x62, 0x34, 0x35, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x39, 0x32, 0x36, 0x32, 0x34, 0x63, 0x35, 0x34, 0x63, 0x64, 0x65, 0x63, 0x36, 0x30, 0x61, 0x35, 0x61, 0x65, 0x39, 0x33, 0x38, 0x30, 0x33, 0x33, 0x61, 0x66, 0x38, 0x62, 0x65, 0x30, 0x63, 0x35, 0x30, 0x63, 0x62, 0x62, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x32, 0x31, 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x36, 0x30, 0x39, 0x34, 0x31, 0x33, 0x32, 0x38, 0x66, 0x66, 0x35, 0x38, 0x37, 0x63, 0x62, 0x63, 0x35, 0x36, 0x63, 0x33, 0x38, 0x63, 0x37, 0x38, 0x32, 0x33, 0x38, 0x61, 0x37, 0x62, 0x62, 0x35, 0x66, 0x34, 0x34, 0x32, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x62, 0x37, 0x65, 0x30, 0x32, 0x32, 0x38, 0x62, 0x61, 0x65, 0x64, 0x36, 0x35, 0x39, 0x35, 0x37, 0x61, 0x65, 0x62, 0x62, 0x34, 0x64, 0x39, 0x31, 0x36, 0x64, 0x33, 0x33, 0x33, 0x61, 0x61, 0x65, 0x31, 0x36, 0x34, 0x66, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x31, 0x36, 0x66, 0x63, 0x61, 0x66, 0x37, 0x37, 0x63, 0x38, 0x39, 0x33, 0x39, 0x37, 0x30, 0x66, 0x63, 0x64, 0x31, 0x61, 0x39, 0x35, 0x38, 0x62, 0x61, 0x39, 0x61, 0x30, 0x30, 0x65, 0x34, 0x39, 0x30, 0x34, 0x34, 0x30, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x32, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x39, 0x32, 0x61, 0x39, 0x36, 0x37, 0x33, 0x30, 0x38, 0x63, 0x30, 0x32, 0x62, 0x39, 0x38, 0x61, 0x66, 0x39, 0x31, 0x65, 0x65, 0x37, 0x36, 0x30, 0x66, 0x64, 0x33, 0x62, 0x36, 0x62, 0x34, 0x38, 0x32, 0x34, 0x61, 0x62, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x62, 0x62, 0x34, 0x33, 0x35, 0x37, 0x63, 0x64, 0x36, 0x39, 0x31, 0x30, 0x63, 0x38, 0x36, 0x64, 0x32, 0x32, 0x33, 0x38, 0x62, 0x66, 0x37, 0x32, 0x37, 0x63, 0x62, 0x65, 0x38, 0x31, 0x35, 0x36, 0x36, 0x38, 0x30, 0x65, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x63, 0x63, 0x30, 0x66, 0x30, 0x36, 0x30, 0x61, 0x61, 0x64, 0x39, 0x32, 0x64, 0x34, 0x65, 0x62, 0x38, 0x62, 0x33, 0x36, 0x62, 0x33, 0x62, 0x39, 0x35, 0x63, 0x65, 0x39, 0x65, 0x39, 0x30, 0x65, 0x62, 0x33, 0x38, 0x33, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x64, 0x34, 0x65, 0x62, 0x66, 0x34, 0x31, 0x65, 0x33, 0x64, 0x33, 0x63, 0x34, 0x35, 0x31, 0x65, 0x39, 0x34, 0x33, 0x62, 0x64, 0x64, 0x37, 0x65, 0x31, 0x66, 0x31, 0x37, 0x35, 0x66, 0x61, 0x65, 0x39, 0x33, 0x32, 0x61, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x38, 0x33, 0x64, 0x34, 0x32, 0x34, 0x61, 0x33, 0x63, 0x66, 0x32, 0x34, 0x64, 0x35, 0x31, 0x66, 0x30, 0x31, 0x39, 0x32, 0x33, 0x64, 0x64, 0x35, 0x34, 0x61, 0x31, 0x38, 0x64, 0x36, 0x62, 0x36, 0x66, 0x65, 0x64, 0x65, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x66, 0x63, 0x39, 0x30, 0x37, 0x36, 0x36, 0x61, 0x30, 0x30, 0x62, 0x63, 0x35, 0x32, 0x33, 0x37, 0x32, 0x63, 0x61, 0x63, 0x39, 0x37, 0x66, 0x61, 0x62, 0x64, 0x38, 0x61, 0x33, 0x63, 0x38, 0x33, 0x31, 0x66, 0x38, 0x65, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x32, 0x62, 0x39, 0x36, 0x30, 0x33, 0x38, 0x38, 0x34, 0x61, 0x34, 0x66, 0x32, 0x65, 0x34, 0x36, 0x34, 0x65, 0x63, 0x65, 0x62, 0x39, 0x37, 0x64, 0x31, 0x37, 0x39, 0x33, 0x38, 0x64, 0x38, 0x32, 0x38, 0x62, 0x63, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x32, 0x35, 0x30, 0x61, 0x65, 0x34, 0x66, 0x31, 0x31, 0x30, 0x64, 0x37, 0x31, 0x63, 0x61, 0x66, 0x63, 0x37, 0x62, 0x30, 0x61, 0x64, 0x62, 0x35, 0x32, 0x65, 0x38, 0x64, 0x39, 0x61, 0x63, 0x62, 0x36, 0x36, 0x37, 0x39, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x62, 0x33, 0x64, 0x66, 0x32, 0x65, 0x39, 0x65, 0x39, 0x66, 0x64, 0x39, 0x36, 0x38, 0x31, 0x33, 0x31, 0x66, 0x31, 0x65, 0x38, 0x38, 0x66, 0x30, 0x61, 0x30, 0x65, 0x62, 0x35, 0x62, 0x64, 0x37, 0x36, 0x35, 0x34, 0x36, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x65, 0x31, 0x33, 0x62, 0x64, 0x38, 0x38, 0x32, 0x66, 0x32, 0x35, 0x37, 0x36, 0x35, 0x37, 0x35, 0x39, 0x32, 0x31, 0x61, 0x39, 0x34, 0x39, 0x37, 0x34, 0x63, 0x62, 0x65, 0x61, 0x38, 0x36, 0x31, 0x62, 0x61, 0x30, 0x64, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x30, 0x39, 0x36, 0x38, 0x38, 0x64, 0x39, 0x33, 0x61, 0x64, 0x30, 0x37, 0x66, 0x33, 0x61, 0x62, 0x65, 0x36, 0x38, 0x63, 0x37, 0x32, 0x32, 0x37, 0x32, 0x33, 0x63, 0x64, 0x36, 0x38, 0x30, 0x39, 0x39, 0x30, 0x34, 0x33, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x39, 0x39, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x35, 0x38, 0x65, 0x32, 0x35, 0x35, 0x66, 0x63, 0x31, 0x39, 0x38, 0x37, 0x30, 0x61, 0x30, 0x34, 0x33, 0x30, 0x35, 0x66, 0x66, 0x32, 0x61, 0x30, 0x34, 0x36, 0x33, 0x31, 0x66, 0x32, 0x66, 0x66, 0x32, 0x39, 0x34, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x61, 0x65, 0x64, 0x30, 0x61, 0x63, 0x62, 0x36, 0x61, 0x37, 0x36, 0x66, 0x31, 0x31, 0x33, 0x66, 0x37, 0x63, 0x36, 0x31, 0x33, 0x35, 0x35, 0x35, 0x61, 0x32, 0x63, 0x33, 0x62, 0x30, 0x66, 0x35, 0x62, 0x66, 0x33, 0x34, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x39, 0x61, 0x64, 0x63, 0x65, 0x32, 0x37, 0x61, 0x61, 0x31, 0x30, 0x62, 0x34, 0x37, 0x32, 0x33, 0x36, 0x34, 0x32, 0x39, 0x61, 0x33, 0x34, 0x61, 0x35, 0x61, 0x63, 0x34, 0x32, 0x63, 0x61, 0x64, 0x35, 0x62, 0x36, 0x34, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x38, 0x36, 0x37, 0x39, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x33, 0x34, 0x63, 0x36, 0x34, 0x33, 0x31, 0x38, 0x32, 0x30, 0x35, 0x63, 0x61, 0x37, 0x64, 0x64, 0x34, 0x61, 0x32, 0x31, 0x61, 0x62, 0x63, 0x62, 0x30, 0x38, 0x32, 0x36, 0x36, 0x63, 0x62, 0x32, 0x31, 0x66, 0x66, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x36, 0x61, 0x38, 0x34, 0x37, 0x31, 0x38, 0x64, 0x64, 0x38, 0x36, 0x65, 0x36, 0x33, 0x33, 0x33, 0x38, 0x34, 0x32, 0x39, 0x61, 0x63, 0x38, 0x31, 0x31, 0x64, 0x37, 0x63, 0x38, 0x61, 0x38, 0x36, 0x30, 0x66, 0x32, 0x31, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x31, 0x38, 0x63, 0x31, 0x31, 0x36, 0x61, 0x62, 0x30, 0x63, 0x64, 0x66, 0x36, 0x66, 0x64, 0x31, 0x31, 0x64, 0x35, 0x34, 0x61, 0x34, 0x33, 0x30, 0x39, 0x33, 0x30, 0x37, 0x62, 0x34, 0x37, 0x37, 0x63, 0x33, 0x66, 0x63, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x61, 0x39, 0x30, 0x31, 0x61, 0x36, 0x39, 0x66, 0x30, 0x33, 0x36, 0x62, 0x63, 0x66, 0x39, 0x66, 0x37, 0x38, 0x34, 0x33, 0x63, 0x30, 0x62, 0x61, 0x30, 0x31, 0x62, 0x34, 0x32, 0x36, 0x65, 0x38, 0x63, 0x33, 0x64, 0x63, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x64, 0x34, 0x34, 0x66, 0x65, 0x33, 0x32, 0x63, 0x37, 0x66, 0x38, 0x63, 0x64, 0x35, 0x66, 0x31, 0x61, 0x39, 0x37, 0x34, 0x32, 0x37, 0x62, 0x36, 0x63, 0x64, 0x33, 0x61, 0x66, 0x63, 0x39, 0x65, 0x34, 0x35, 0x30, 0x32, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x30, 0x34, 0x35, 0x62, 0x33, 0x63, 0x33, 0x35, 0x30, 0x62, 0x34, 0x63, 0x65, 0x39, 0x63, 0x61, 0x30, 0x63, 0x36, 0x62, 0x37, 0x35, 0x34, 0x66, 0x62, 0x34, 0x31, 0x61, 0x36, 0x39, 0x62, 0x39, 0x37, 0x65, 0x39, 0x39, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x35, 0x61, 0x36, 0x66, 0x39, 0x64, 0x66, 0x37, 0x35, 0x35, 0x37, 0x39, 0x63, 0x36, 0x34, 0x34, 0x66, 0x37, 0x39, 0x34, 0x37, 0x31, 0x31, 0x32, 0x31, 0x35, 0x62, 0x33, 0x30, 0x64, 0x37, 0x37, 0x61, 0x30, 0x63, 0x65, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x39, 0x30, 0x34, 0x62, 0x31, 0x61, 0x65, 0x66, 0x61, 0x30, 0x35, 0x36, 0x33, 0x39, 0x38, 0x62, 0x36, 0x32, 0x33, 0x34, 0x63, 0x62, 0x33, 0x35, 0x38, 0x31, 0x31, 0x32, 0x38, 0x38, 0x64, 0x37, 0x33, 0x36, 0x64, 0x62, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x30, 0x31, 0x62, 0x64, 0x37, 0x39, 0x39, 0x65, 0x34, 0x31, 0x31, 0x63, 0x64, 0x65, 0x31, 0x34, 0x62, 0x64, 0x66, 0x61, 0x63, 0x32, 0x35, 0x62, 0x30, 0x36, 0x37, 0x61, 0x63, 0x38, 0x39, 0x30, 0x65, 0x61, 0x62, 0x38, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x34, 0x35, 0x66, 0x62, 0x33, 0x61, 0x35, 0x35, 0x35, 0x62, 0x61, 0x64, 0x38, 0x30, 0x37, 0x62, 0x33, 0x38, 0x38, 0x61, 0x30, 0x33, 0x35, 0x37, 0x63, 0x38, 0x35, 0x35, 0x32, 0x30, 0x35, 0x66, 0x37, 0x63, 0x37, 0x35, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x30, 0x63, 0x33, 0x63, 0x37, 0x37, 0x39, 0x38, 0x65, 0x38, 0x37, 0x33, 0x33, 0x64, 0x64, 0x32, 0x36, 0x36, 0x38, 0x31, 0x35, 0x32, 0x38, 0x39, 0x31, 0x62, 0x61, 0x62, 0x38, 0x30, 0x61, 0x38, 0x62, 0x65, 0x39, 0x35, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x33, 0x36, 0x34, 0x35, 0x33, 0x33, 0x32, 0x32, 0x63, 0x31, 0x34, 0x36, 0x36, 0x63, 0x62, 0x39, 0x30, 0x35, 0x61, 0x66, 0x35, 0x63, 0x33, 0x33, 0x35, 0x63, 0x61, 0x38, 0x64, 0x62, 0x37, 0x34, 0x62, 0x66, 0x66, 0x31, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x63, 0x61, 0x63, 0x38, 0x39, 0x35, 0x32, 0x36, 0x34, 0x31, 0x64, 0x38, 0x66, 0x63, 0x35, 0x32, 0x36, 0x65, 0x63, 0x31, 0x61, 0x62, 0x34, 0x66, 0x32, 0x64, 0x66, 0x38, 0x32, 0x36, 0x61, 0x35, 0x65, 0x37, 0x37, 0x31, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x38, 0x61, 0x61, 0x62, 0x38, 0x66, 0x37, 0x34, 0x65, 0x61, 0x38, 0x36, 0x32, 0x63, 0x64, 0x66, 0x37, 0x36, 0x36, 0x38, 0x30, 0x35, 0x30, 0x30, 0x39, 0x64, 0x33, 0x66, 0x33, 0x65, 0x34, 0x32, 0x64, 0x38, 0x64, 0x30, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x30, 0x38, 0x37, 0x36, 0x30, 0x63, 0x64, 0x33, 0x39, 0x62, 0x39, 0x63, 0x31, 0x65, 0x38, 0x31, 0x38, 0x34, 0x65, 0x36, 0x61, 0x37, 0x35, 0x32, 0x65, 0x65, 0x38, 0x38, 0x38, 0x65, 0x33, 0x66, 0x30, 0x62, 0x37, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x35, 0x36, 0x33, 0x36, 0x30, 0x62, 0x62, 0x64, 0x33, 0x37, 0x30, 0x39, 0x36, 0x31, 0x63, 0x65, 0x63, 0x61, 0x36, 0x62, 0x36, 0x36, 0x39, 0x31, 0x64, 0x37, 0x35, 0x30, 0x30, 0x36, 0x61, 0x64, 0x32, 0x30, 0x34, 0x63, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x30, 0x34, 0x35, 0x38, 0x38, 0x66, 0x30, 0x64, 0x38, 0x35, 0x30, 0x63, 0x64, 0x38, 0x64, 0x33, 0x38, 0x66, 0x37, 0x36, 0x65, 0x39, 0x65, 0x38, 0x33, 0x63, 0x31, 0x62, 0x66, 0x36, 0x33, 0x65, 0x33, 0x33, 0x33, 0x65, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x63, 0x36, 0x33, 0x62, 0x61, 0x32, 0x64, 0x63, 0x62, 0x31, 0x64, 0x64, 0x34, 0x64, 0x66, 0x33, 0x33, 0x64, 0x64, 0x61, 0x62, 0x31, 0x31, 0x63, 0x34, 0x66, 0x30, 0x30, 0x30, 0x37, 0x66, 0x61, 0x39, 0x36, 0x61, 0x36, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x30, 0x39, 0x62, 0x66, 0x30, 0x37, 0x36, 0x66, 0x31, 0x62, 0x61, 0x33, 0x66, 0x61, 0x35, 0x37, 0x64, 0x32, 0x61, 0x37, 0x32, 0x31, 0x37, 0x32, 0x31, 0x38, 0x62, 0x65, 0x64, 0x35, 0x35, 0x36, 0x35, 0x61, 0x37, 0x61, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x38, 0x39, 0x30, 0x36, 0x30, 0x66, 0x39, 0x38, 0x37, 0x63, 0x35, 0x31, 0x38, 0x66, 0x61, 0x30, 0x37, 0x39, 0x65, 0x63, 0x32, 0x63, 0x30, 0x61, 0x35, 0x65, 0x62, 0x66, 0x61, 0x33, 0x30, 0x66, 0x35, 0x64, 0x32, 0x30, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x39, 0x35, 0x65, 0x62, 0x37, 0x32, 0x36, 0x32, 0x32, 0x36, 0x65, 0x64, 0x63, 0x33, 0x66, 0x37, 0x38, 0x63, 0x63, 0x36, 0x61, 0x35, 0x31, 0x35, 0x30, 0x37, 0x37, 0x62, 0x33, 0x32, 0x39, 0x36, 0x66, 0x64, 0x62, 0x39, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x31, 0x39, 0x65, 0x37, 0x36, 0x32, 0x37, 0x66, 0x39, 0x62, 0x37, 0x64, 0x35, 0x34, 0x65, 0x61, 0x33, 0x62, 0x31, 0x34, 0x62, 0x62, 0x34, 0x64, 0x64, 0x34, 0x36, 0x34, 0x39, 0x66, 0x34, 0x66, 0x33, 0x39, 0x64, 0x65, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x63, 0x36, 0x35, 0x62, 0x38, 0x34, 0x35, 0x61, 0x62, 0x61, 0x36, 0x63, 0x64, 0x38, 0x31, 0x36, 0x66, 0x62, 0x61, 0x61, 0x65, 0x39, 0x38, 0x33, 0x65, 0x30, 0x65, 0x34, 0x36, 0x63, 0x38, 0x32, 0x61, 0x61, 0x38, 0x36, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x66, 0x35, 0x31, 0x64, 0x37, 0x32, 0x61, 0x64, 0x66, 0x61, 0x65, 0x31, 0x34, 0x33, 0x65, 0x64, 0x66, 0x33, 0x61, 0x34, 0x32, 0x62, 0x31, 0x61, 0x65, 0x63, 0x35, 0x35, 0x61, 0x32, 0x63, 0x63, 0x64, 0x64, 0x30, 0x62, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x62, 0x62, 0x36, 0x34, 0x61, 0x39, 0x31, 0x36, 0x62, 0x65, 0x36, 0x36, 0x66, 0x34, 0x36, 0x30, 0x66, 0x35, 0x65, 0x33, 0x62, 0x36, 0x34, 0x33, 0x33, 0x32, 0x31, 0x31, 0x30, 0x64, 0x32, 0x30, 0x39, 0x65, 0x31, 0x39, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x62, 0x31, 0x31, 0x37, 0x65, 0x63, 0x31, 0x31, 0x36, 0x65, 0x62, 0x38, 0x34, 0x36, 0x34, 0x31, 0x38, 0x39, 0x36, 0x31, 0x65, 0x62, 0x37, 0x65, 0x64, 0x62, 0x36, 0x32, 0x39, 0x63, 0x64, 0x30, 0x64, 0x64, 0x36, 0x39, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x65, 0x39, 0x37, 0x62, 0x30, 0x39, 0x34, 0x39, 0x32, 0x63, 0x64, 0x36, 0x38, 0x66, 0x36, 0x33, 0x62, 0x31, 0x32, 0x62, 0x38, 0x39, 0x32, 0x65, 0x64, 0x31, 0x64, 0x31, 0x31, 0x64, 0x31, 0x35, 0x32, 0x63, 0x30, 0x65, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x63, 0x63, 0x37, 0x38, 0x37, 0x38, 0x64, 0x61, 0x36, 0x30, 0x35, 0x66, 0x64, 0x62, 0x30, 0x31, 0x39, 0x66, 0x61, 0x62, 0x39, 0x62, 0x34, 0x63, 0x63, 0x66, 0x63, 0x31, 0x35, 0x37, 0x37, 0x30, 0x39, 0x63, 0x64, 0x64, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x36, 0x39, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x63, 0x61, 0x63, 0x36, 0x34, 0x39, 0x34, 0x66, 0x31, 0x31, 0x65, 0x66, 0x32, 0x37, 0x39, 0x38, 0x37, 0x34, 0x38, 0x63, 0x62, 0x35, 0x33, 0x32, 0x38, 0x35, 0x62, 0x64, 0x38, 0x65, 0x32, 0x32, 0x66, 0x39, 0x37, 0x63, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x35, 0x61, 0x38, 0x63, 0x39, 0x34, 0x62, 0x64, 0x38, 0x62, 0x65, 0x36, 0x34, 0x37, 0x30, 0x36, 0x34, 0x34, 0x66, 0x37, 0x30, 0x63, 0x38, 0x66, 0x38, 0x61, 0x33, 0x33, 0x61, 0x38, 0x61, 0x35, 0x35, 0x63, 0x36, 0x33, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x31, 0x39, 0x65, 0x37, 0x39, 0x61, 0x61, 0x39, 0x62, 0x39, 0x31, 0x36, 0x35, 0x32, 0x36, 0x35, 0x38, 0x31, 0x63, 0x62, 0x66, 0x35, 0x32, 0x31, 0x65, 0x66, 0x34, 0x37, 0x34, 0x61, 0x65, 0x38, 0x34, 0x64, 0x63, 0x66, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x66, 0x31, 0x30, 0x34, 0x35, 0x61, 0x64, 0x66, 0x32, 0x37, 0x61, 0x31, 0x61, 0x61, 0x33, 0x32, 0x39, 0x34, 0x36, 0x31, 0x62, 0x32, 0x34, 0x64, 0x65, 0x31, 0x62, 0x61, 0x65, 0x39, 0x39, 0x34, 0x38, 0x61, 0x36, 0x39, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x39, 0x38, 0x36, 0x32, 0x38, 0x65, 0x61, 0x36, 0x36, 0x33, 0x32, 0x64, 0x33, 0x39, 0x33, 0x65, 0x39, 0x32, 0x39, 0x63, 0x62, 0x64, 0x39, 0x32, 0x38, 0x34, 0x36, 0x34, 0x63, 0x35, 0x36, 0x38, 0x61, 0x61, 0x34, 0x61, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x36, 0x36, 0x38, 0x66, 0x37, 0x63, 0x31, 0x61, 0x34, 0x66, 0x66, 0x39, 0x65, 0x33, 0x31, 0x66, 0x39, 0x39, 0x37, 0x37, 0x61, 0x65, 0x33, 0x32, 0x32, 0x34, 0x62, 0x63, 0x62, 0x38, 0x38, 0x37, 0x61, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x30, 0x65, 0x38, 0x37, 0x34, 0x35, 0x63, 0x33, 0x61, 0x35, 0x34, 0x39, 0x34, 0x34, 0x35, 0x63, 0x32, 0x62, 0x65, 0x39, 0x30, 0x30, 0x66, 0x35, 0x32, 0x33, 0x30, 0x30, 0x38, 0x30, 0x34, 0x61, 0x62, 0x35, 0x36, 0x32, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x31, 0x30, 0x34, 0x36, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x62, 0x61, 0x62, 0x34, 0x66, 0x30, 0x61, 0x66, 0x64, 0x38, 0x61, 0x39, 0x64, 0x31, 0x61, 0x33, 0x38, 0x31, 0x62, 0x34, 0x35, 0x37, 0x36, 0x31, 0x61, 0x61, 0x31, 0x38, 0x66, 0x33, 0x64, 0x33, 0x63, 0x63, 0x65, 0x31, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x36, 0x30, 0x30, 0x33, 0x37, 0x65, 0x39, 0x30, 0x37, 0x31, 0x34, 0x61, 0x34, 0x62, 0x39, 0x31, 0x37, 0x65, 0x36, 0x31, 0x66, 0x31, 0x39, 0x33, 0x64, 0x38, 0x33, 0x34, 0x39, 0x30, 0x36, 0x37, 0x30, 0x33, 0x62, 0x31, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x64, 0x34, 0x32, 0x38, 0x34, 0x63, 0x30, 0x66, 0x34, 0x37, 0x34, 0x34, 0x39, 0x63, 0x31, 0x35, 0x62, 0x38, 0x64, 0x39, 0x62, 0x33, 0x32, 0x34, 0x35, 0x64, 0x65, 0x38, 0x62, 0x65, 0x62, 0x36, 0x63, 0x65, 0x38, 0x30, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x33, 0x61, 0x64, 0x31, 0x35, 0x39, 0x36, 0x34, 0x30, 0x31, 0x65, 0x30, 0x35, 0x61, 0x65, 0x61, 0x32, 0x64, 0x33, 0x36, 0x63, 0x61, 0x34, 0x37, 0x33, 0x31, 0x38, 0x65, 0x66, 0x34, 0x63, 0x64, 0x32, 0x63, 0x62, 0x33, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x64, 0x62, 0x35, 0x35, 0x39, 0x66, 0x32, 0x63, 0x33, 0x63, 0x31, 0x34, 0x37, 0x35, 0x61, 0x32, 0x65, 0x36, 0x66, 0x66, 0x65, 0x38, 0x33, 0x61, 0x35, 0x39, 0x37, 0x39, 0x35, 0x39, 0x39, 0x31, 0x39, 0x36, 0x61, 0x37, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x66, 0x34, 0x34, 0x39, 0x66, 0x31, 0x30, 0x38, 0x63, 0x36, 0x66, 0x62, 0x34, 0x66, 0x35, 0x61, 0x32, 0x62, 0x30, 0x38, 0x31, 0x65, 0x65, 0x64, 0x37, 0x65, 0x34, 0x35, 0x65, 0x36, 0x39, 0x31, 0x39, 0x65, 0x34, 0x64, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x65, 0x31, 0x62, 0x63, 0x62, 0x39, 0x30, 0x33, 0x34, 0x33, 0x66, 0x61, 0x65, 0x35, 0x33, 0x30, 0x33, 0x31, 0x37, 0x33, 0x66, 0x34, 0x36, 0x31, 0x62, 0x64, 0x39, 0x31, 0x34, 0x61, 0x34, 0x38, 0x33, 0x39, 0x30, 0x35, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x38, 0x31, 0x61, 0x64, 0x35, 0x65, 0x36, 0x62, 0x37, 0x37, 0x39, 0x33, 0x61, 0x32, 0x33, 0x66, 0x63, 0x36, 0x63, 0x31, 0x65, 0x38, 0x36, 0x39, 0x32, 0x65, 0x62, 0x32, 0x39, 0x36, 0x35, 0x64, 0x31, 0x38, 0x64, 0x30, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x35, 0x64, 0x32, 0x32, 0x35, 0x39, 0x33, 0x30, 0x36, 0x61, 0x65, 0x63, 0x37, 0x64, 0x66, 0x30, 0x32, 0x32, 0x37, 0x36, 0x38, 0x63, 0x36, 0x39, 0x38, 0x39, 0x39, 0x61, 0x36, 0x35, 0x32, 0x31, 0x38, 0x35, 0x64, 0x62, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x32, 0x65, 0x39, 0x62, 0x65, 0x36, 0x64, 0x34, 0x61, 0x62, 0x34, 0x35, 0x30, 0x66, 0x64, 0x31, 0x32, 0x35, 0x33, 0x31, 0x66, 0x33, 0x33, 0x66, 0x30, 0x32, 0x38, 0x63, 0x36, 0x31, 0x34, 0x36, 0x37, 0x34, 0x66, 0x31, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x63, 0x63, 0x37, 0x65, 0x36, 0x34, 0x66, 0x63, 0x61, 0x66, 0x63, 0x62, 0x63, 0x32, 0x64, 0x63, 0x36, 0x63, 0x30, 0x65, 0x35, 0x65, 0x36, 0x36, 0x32, 0x63, 0x62, 0x33, 0x34, 0x37, 0x62, 0x66, 0x66, 0x63, 0x64, 0x37, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x62, 0x64, 0x62, 0x33, 0x35, 0x63, 0x31, 0x35, 0x31, 0x34, 0x39, 0x38, 0x34, 0x61, 0x30, 0x33, 0x39, 0x32, 0x31, 0x33, 0x37, 0x39, 0x33, 0x66, 0x33, 0x33, 0x34, 0x35, 0x61, 0x31, 0x36, 0x38, 0x65, 0x38, 0x31, 0x66, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x39, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x31, 0x35, 0x64, 0x65, 0x65, 0x61, 0x31, 0x64, 0x38, 0x63, 0x31, 0x32, 0x37, 0x31, 0x66, 0x39, 0x64, 0x31, 0x33, 0x31, 0x31, 0x32, 0x36, 0x33, 0x61, 0x62, 0x34, 0x37, 0x63, 0x30, 0x30, 0x37, 0x61, 0x66, 0x62, 0x36, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x61, 0x66, 0x39, 0x30, 0x62, 0x37, 0x36, 0x65, 0x63, 0x66, 0x62, 0x39, 0x36, 0x33, 0x31, 0x62, 0x66, 0x39, 0x30, 0x32, 0x32, 0x31, 0x37, 0x36, 0x30, 0x33, 0x32, 0x64, 0x38, 0x62, 0x32, 0x63, 0x32, 0x30, 0x37, 0x30, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x37, 0x61, 0x39, 0x36, 0x36, 0x62, 0x35, 0x64, 0x63, 0x33, 0x35, 0x37, 0x66, 0x66, 0x62, 0x30, 0x37, 0x65, 0x39, 0x66, 0x65, 0x30, 0x36, 0x37, 0x63, 0x34, 0x35, 0x37, 0x39, 0x31, 0x66, 0x64, 0x38, 0x65, 0x33, 0x30, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x36, 0x34, 0x61, 0x38, 0x64, 0x37, 0x31, 0x31, 0x31, 0x31, 0x61, 0x32, 0x32, 0x66, 0x34, 0x63, 0x35, 0x64, 0x65, 0x31, 0x65, 0x30, 0x33, 0x39, 0x62, 0x33, 0x33, 0x36, 0x66, 0x36, 0x38, 0x64, 0x33, 0x39, 0x38, 0x61, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x31, 0x66, 0x62, 0x62, 0x61, 0x38, 0x35, 0x32, 0x61, 0x37, 0x66, 0x35, 0x30, 0x31, 0x37, 0x38, 0x62, 0x31, 0x63, 0x37, 0x66, 0x30, 0x33, 0x65, 0x64, 0x39, 0x65, 0x35, 0x38, 0x64, 0x35, 0x34, 0x31, 0x36, 0x32, 0x39, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x37, 0x33, 0x33, 0x30, 0x30, 0x39, 0x36, 0x66, 0x37, 0x39, 0x65, 0x64, 0x32, 0x36, 0x34, 0x65, 0x65, 0x30, 0x31, 0x32, 0x37, 0x66, 0x35, 0x64, 0x33, 0x30, 0x64, 0x32, 0x66, 0x37, 0x33, 0x63, 0x35, 0x32, 0x62, 0x33, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x61, 0x38, 0x64, 0x62, 0x64, 0x64, 0x31, 0x61, 0x38, 0x35, 0x64, 0x31, 0x62, 0x65, 0x65, 0x65, 0x32, 0x35, 0x36, 0x39, 0x65, 0x39, 0x31, 0x63, 0x63, 0x63, 0x34, 0x64, 0x30, 0x39, 0x61, 0x65, 0x37, 0x66, 0x36, 0x65, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x39, 0x63, 0x33, 0x32, 0x36, 0x38, 0x34, 0x35, 0x38, 0x64, 0x61, 0x33, 0x30, 0x31, 0x61, 0x32, 0x62, 0x65, 0x35, 0x61, 0x62, 0x30, 0x38, 0x32, 0x35, 0x37, 0x66, 0x37, 0x37, 0x62, 0x62, 0x35, 0x61, 0x39, 0x38, 0x61, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x33, 0x37, 0x32, 0x66, 0x66, 0x36, 0x39, 0x32, 0x37, 0x63, 0x62, 0x33, 0x39, 0x36, 0x64, 0x39, 0x63, 0x66, 0x32, 0x39, 0x38, 0x30, 0x33, 0x35, 0x30, 0x30, 0x31, 0x31, 0x30, 0x64, 0x61, 0x36, 0x33, 0x32, 0x62, 0x63, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x61, 0x35, 0x35, 0x34, 0x61, 0x62, 0x39, 0x35, 0x35, 0x63, 0x32, 0x34, 0x39, 0x32, 0x31, 0x37, 0x33, 0x38, 0x36, 0x61, 0x34, 0x64, 0x33, 0x32, 0x36, 0x33, 0x62, 0x62, 0x66, 0x37, 0x32, 0x38, 0x39, 0x35, 0x34, 0x33, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x35, 0x39, 0x65, 0x34, 0x37, 0x65, 0x61, 0x35, 0x64, 0x38, 0x66, 0x30, 0x65, 0x37, 0x63, 0x30, 0x32, 0x38, 0x61, 0x33, 0x65, 0x38, 0x65, 0x30, 0x39, 0x33, 0x61, 0x34, 0x39, 0x63, 0x31, 0x62, 0x35, 0x30, 0x62, 0x39, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x33, 0x32, 0x63, 0x37, 0x32, 0x31, 0x39, 0x31, 0x62, 0x38, 0x33, 0x39, 0x32, 0x63, 0x35, 0x35, 0x66, 0x35, 0x31, 0x30, 0x64, 0x38, 0x65, 0x33, 0x33, 0x32, 0x36, 0x65, 0x33, 0x61, 0x36, 0x30, 0x35, 0x30, 0x31, 0x64, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x66, 0x61, 0x65, 0x65, 0x30, 0x37, 0x37, 0x32, 0x31, 0x32, 0x66, 0x31, 0x62, 0x65, 0x61, 0x66, 0x30, 0x65, 0x36, 0x66, 0x32, 0x66, 0x31, 0x38, 0x34, 0x30, 0x35, 0x33, 0x37, 0x61, 0x65, 0x31, 0x35, 0x34, 0x61, 0x64, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x61, 0x62, 0x61, 0x30, 0x33, 0x35, 0x65, 0x32, 0x61, 0x66, 0x33, 0x37, 0x39, 0x33, 0x66, 0x64, 0x37, 0x34, 0x36, 0x37, 0x34, 0x62, 0x31, 0x30, 0x32, 0x35, 0x34, 0x30, 0x63, 0x66, 0x31, 0x39, 0x30, 0x61, 0x64, 0x64, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x32, 0x65, 0x64, 0x62, 0x39, 0x36, 0x66, 0x63, 0x65, 0x32, 0x39, 0x36, 0x39, 0x61, 0x61, 0x66, 0x36, 0x63, 0x35, 0x34, 0x35, 0x65, 0x39, 0x36, 0x37, 0x63, 0x66, 0x31, 0x63, 0x30, 0x62, 0x63, 0x38, 0x30, 0x35, 0x32, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x37, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x30, 0x64, 0x63, 0x36, 0x38, 0x64, 0x66, 0x30, 0x31, 0x39, 0x62, 0x36, 0x62, 0x30, 0x63, 0x63, 0x62, 0x66, 0x66, 0x62, 0x37, 0x38, 0x34, 0x62, 0x35, 0x61, 0x35, 0x61, 0x62, 0x34, 0x62, 0x31, 0x35, 0x64, 0x34, 0x30, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x62, 0x62, 0x38, 0x32, 0x39, 0x36, 0x35, 0x32, 0x64, 0x38, 0x62, 0x66, 0x62, 0x35, 0x38, 0x62, 0x38, 0x35, 0x32, 0x37, 0x66, 0x30, 0x65, 0x63, 0x62, 0x36, 0x32, 0x31, 0x63, 0x32, 0x39, 0x65, 0x32, 0x31, 0x32, 0x65, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x62, 0x31, 0x32, 0x30, 0x65, 0x62, 0x38, 0x38, 0x30, 0x36, 0x37, 0x33, 0x32, 0x33, 0x32, 0x31, 0x32, 0x38, 0x38, 0x66, 0x36, 0x37, 0x35, 0x61, 0x32, 0x37, 0x61, 0x39, 0x32, 0x32, 0x35, 0x66, 0x31, 0x63, 0x64, 0x32, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x30, 0x61, 0x66, 0x31, 0x65, 0x65, 0x66, 0x64, 0x33, 0x33, 0x36, 0x35, 0x64, 0x37, 0x38, 0x62, 0x61, 0x37, 0x62, 0x31, 0x32, 0x63, 0x62, 0x31, 0x61, 0x36, 0x37, 0x33, 0x65, 0x30, 0x36, 0x61, 0x30, 0x37, 0x37, 0x32, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x30, 0x34, 0x32, 0x63, 0x39, 0x63, 0x32, 0x66, 0x62, 0x31, 0x38, 0x37, 0x36, 0x36, 0x66, 0x38, 0x33, 0x36, 0x62, 0x62, 0x35, 0x39, 0x66, 0x37, 0x33, 0x35, 0x66, 0x32, 0x37, 0x64, 0x63, 0x33, 0x32, 0x39, 0x66, 0x65, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x64, 0x61, 0x35, 0x66, 0x37, 0x38, 0x38, 0x61, 0x36, 0x63, 0x36, 0x38, 0x38, 0x64, 0x64, 0x66, 0x39, 0x32, 0x31, 0x66, 0x61, 0x33, 0x38, 0x35, 0x32, 0x65, 0x62, 0x36, 0x64, 0x36, 0x63, 0x36, 0x63, 0x36, 0x32, 0x39, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x61, 0x64, 0x35, 0x37, 0x39, 0x62, 0x62, 0x66, 0x61, 0x38, 0x64, 0x62, 0x38, 0x65, 0x62, 0x65, 0x63, 0x39, 0x64, 0x32, 0x38, 0x36, 0x61, 0x37, 0x32, 0x65, 0x34, 0x36, 0x36, 0x31, 0x65, 0x65, 0x64, 0x38, 0x65, 0x33, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x37, 0x30, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x32, 0x30, 0x37, 0x33, 0x62, 0x61, 0x34, 0x34, 0x64, 0x33, 0x64, 0x64, 0x62, 0x64, 0x62, 0x36, 0x33, 0x39, 0x63, 0x30, 0x34, 0x65, 0x31, 0x39, 0x31, 0x30, 0x33, 0x39, 0x61, 0x37, 0x31, 0x37, 0x31, 0x36, 0x32, 0x33, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x33, 0x35, 0x32, 0x30, 0x34, 0x35, 0x33, 0x35, 0x38, 0x32, 0x63, 0x37, 0x31, 0x38, 0x61, 0x32, 0x31, 0x63, 0x34, 0x32, 0x33, 0x37, 0x35, 0x62, 0x63, 0x35, 0x30, 0x37, 0x37, 0x33, 0x32, 0x35, 0x35, 0x32, 0x35, 0x33, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x63, 0x61, 0x61, 0x65, 0x39, 0x66, 0x66, 0x36, 0x34, 0x64, 0x32, 0x63, 0x64, 0x39, 0x35, 0x62, 0x35, 0x32, 0x34, 0x39, 0x64, 0x63, 0x66, 0x66, 0x65, 0x37, 0x66, 0x61, 0x61, 0x30, 0x61, 0x30, 0x63, 0x30, 0x65, 0x34, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x33, 0x64, 0x65, 0x31, 0x35, 0x35, 0x64, 0x35, 0x65, 0x63, 0x64, 0x38, 0x65, 0x38, 0x31, 0x63, 0x31, 0x66, 0x66, 0x39, 0x62, 0x62, 0x66, 0x30, 0x33, 0x37, 0x38, 0x33, 0x30, 0x31, 0x66, 0x38, 0x64, 0x34, 0x63, 0x36, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x66, 0x30, 0x37, 0x61, 0x63, 0x30, 0x39, 0x65, 0x37, 0x62, 0x32, 0x63, 0x33, 0x63, 0x30, 0x61, 0x33, 0x64, 0x31, 0x65, 0x39, 0x34, 0x31, 0x33, 0x61, 0x35, 0x34, 0x34, 0x63, 0x37, 0x33, 0x61, 0x34, 0x31, 0x62, 0x65, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x36, 0x33, 0x31, 0x63, 0x37, 0x36, 0x39, 0x38, 0x62, 0x36, 0x63, 0x35, 0x31, 0x31, 0x31, 0x39, 0x38, 0x39, 0x62, 0x66, 0x34, 0x35, 0x32, 0x37, 0x32, 0x37, 0x62, 0x33, 0x66, 0x39, 0x33, 0x39, 0x35, 0x61, 0x36, 0x64, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x63, 0x32, 0x32, 0x63, 0x39, 0x62, 0x63, 0x39, 0x61, 0x64, 0x30, 0x35, 0x64, 0x38, 0x37, 0x35, 0x61, 0x33, 0x39, 0x37, 0x64, 0x62, 0x65, 0x38, 0x34, 0x37, 0x65, 0x64, 0x32, 0x32, 0x31, 0x63, 0x39, 0x32, 0x30, 0x63, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x39, 0x38, 0x37, 0x65, 0x33, 0x66, 0x38, 0x33, 0x64, 0x65, 0x37, 0x35, 0x61, 0x34, 0x32, 0x66, 0x31, 0x62, 0x64, 0x65, 0x37, 0x63, 0x39, 0x39, 0x37, 0x63, 0x31, 0x39, 0x32, 0x31, 0x37, 0x62, 0x34, 0x61, 0x35, 0x66, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x32, 0x62, 0x36, 0x34, 0x65, 0x39, 0x63, 0x30, 0x35, 0x38, 0x65, 0x33, 0x38, 0x32, 0x61, 0x38, 0x62, 0x32, 0x39, 0x39, 0x32, 0x32, 0x34, 0x65, 0x65, 0x63, 0x61, 0x61, 0x31, 0x36, 0x65, 0x30, 0x39, 0x63, 0x38, 0x64, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x63, 0x61, 0x61, 0x66, 0x61, 0x63, 0x66, 0x33, 0x32, 0x61, 0x61, 0x30, 0x33, 0x31, 0x37, 0x63, 0x30, 0x33, 0x32, 0x61, 0x63, 0x33, 0x36, 0x62, 0x61, 0x62, 0x65, 0x64, 0x39, 0x37, 0x34, 0x37, 0x39, 0x31, 0x64, 0x63, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x64, 0x31, 0x66, 0x30, 0x61, 0x33, 0x31, 0x34, 0x63, 0x62, 0x62, 0x32, 0x30, 0x30, 0x64, 0x65, 0x30, 0x61, 0x30, 0x63, 0x62, 0x31, 0x65, 0x66, 0x39, 0x37, 0x65, 0x39, 0x32, 0x30, 0x37, 0x30, 0x39, 0x64, 0x39, 0x37, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x39, 0x38, 0x30, 0x66, 0x34, 0x62, 0x35, 0x36, 0x36, 0x62, 0x62, 0x30, 0x34, 0x35, 0x35, 0x31, 0x37, 0x65, 0x34, 0x63, 0x31, 0x34, 0x63, 0x38, 0x37, 0x37, 0x35, 0x30, 0x64, 0x65, 0x39, 0x33, 0x34, 0x36, 0x37, 0x34, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x35, 0x66, 0x32, 0x39, 0x63, 0x63, 0x32, 0x66, 0x61, 0x61, 0x32, 0x36, 0x32, 0x63, 0x64, 0x65, 0x66, 0x33, 0x30, 0x65, 0x66, 0x35, 0x35, 0x34, 0x66, 0x35, 0x30, 0x65, 0x62, 0x34, 0x38, 0x38, 0x31, 0x34, 0x36, 0x65, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x31, 0x38, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x35, 0x33, 0x61, 0x30, 0x63, 0x33, 0x63, 0x38, 0x39, 0x31, 0x32, 0x38, 0x38, 0x31, 0x62, 0x66, 0x31, 0x63, 0x33, 0x35, 0x30, 0x31, 0x62, 0x66, 0x36, 0x34, 0x62, 0x34, 0x35, 0x36, 0x34, 0x39, 0x65, 0x34, 0x38, 0x32, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x31, 0x61, 0x37, 0x33, 0x34, 0x31, 0x65, 0x62, 0x38, 0x34, 0x66, 0x64, 0x31, 0x35, 0x31, 0x30, 0x35, 0x34, 0x65, 0x35, 0x65, 0x33, 0x38, 0x37, 0x62, 0x62, 0x32, 0x35, 0x64, 0x33, 0x36, 0x65, 0x34, 0x39, 0x39, 0x63, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x36, 0x30, 0x65, 0x38, 0x61, 0x63, 0x36, 0x37, 0x31, 0x38, 0x61, 0x36, 0x61, 0x31, 0x63, 0x64, 0x63, 0x66, 0x66, 0x31, 0x38, 0x39, 0x64, 0x36, 0x30, 0x33, 0x63, 0x39, 0x30, 0x36, 0x33, 0x65, 0x34, 0x31, 0x33, 0x64, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x39, 0x62, 0x61, 0x30, 0x63, 0x64, 0x39, 0x36, 0x38, 0x31, 0x36, 0x63, 0x34, 0x36, 0x30, 0x37, 0x37, 0x37, 0x33, 0x63, 0x66, 0x38, 0x61, 0x35, 0x39, 0x37, 0x30, 0x62, 0x62, 0x35, 0x62, 0x63, 0x31, 0x36, 0x61, 0x31, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x61, 0x63, 0x31, 0x31, 0x37, 0x64, 0x39, 0x66, 0x30, 0x64, 0x62, 0x61, 0x38, 0x30, 0x39, 0x30, 0x31, 0x34, 0x34, 0x35, 0x38, 0x32, 0x33, 0x63, 0x34, 0x63, 0x39, 0x64, 0x34, 0x66, 0x61, 0x33, 0x66, 0x65, 0x64, 0x63, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x37, 0x35, 0x39, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x36, 0x37, 0x66, 0x64, 0x33, 0x65, 0x31, 0x32, 0x37, 0x66, 0x64, 0x39, 0x64, 0x63, 0x33, 0x36, 0x65, 0x62, 0x33, 0x66, 0x63, 0x64, 0x36, 0x61, 0x38, 0x30, 0x63, 0x37, 0x62, 0x65, 0x34, 0x66, 0x37, 0x35, 0x33, 0x32, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x33, 0x63, 0x32, 0x37, 0x66, 0x37, 0x61, 0x30, 0x61, 0x31, 0x32, 0x32, 0x30, 0x38, 0x34, 0x62, 0x39, 0x38, 0x66, 0x34, 0x38, 0x33, 0x39, 0x32, 0x32, 0x35, 0x34, 0x31, 0x63, 0x38, 0x38, 0x33, 0x36, 0x63, 0x65, 0x65, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x39, 0x32, 0x37, 0x39, 0x39, 0x36, 0x32, 0x30, 0x32, 0x39, 0x61, 0x38, 0x62, 0x64, 0x34, 0x35, 0x36, 0x33, 0x39, 0x37, 0x33, 0x37, 0x65, 0x39, 0x38, 0x62, 0x35, 0x31, 0x31, 0x65, 0x66, 0x66, 0x30, 0x37, 0x34, 0x63, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x36, 0x37, 0x34, 0x34, 0x31, 0x65, 0x37, 0x66, 0x32, 0x39, 0x37, 0x39, 0x39, 0x61, 0x62, 0x61, 0x36, 0x31, 0x36, 0x34, 0x35, 0x31, 0x64, 0x35, 0x33, 0x62, 0x33, 0x66, 0x34, 0x38, 0x39, 0x66, 0x39, 0x65, 0x30, 0x66, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x35, 0x38, 0x37, 0x35, 0x66, 0x66, 0x34, 0x66, 0x62, 0x62, 0x30, 0x63, 0x66, 0x33, 0x61, 0x34, 0x33, 0x30, 0x32, 0x31, 0x33, 0x31, 0x32, 0x37, 0x34, 0x38, 0x37, 0x66, 0x37, 0x36, 0x30, 0x38, 0x64, 0x30, 0x34, 0x63, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x39, 0x35, 0x33, 0x62, 0x35, 0x62, 0x63, 0x63, 0x37, 0x30, 0x39, 0x33, 0x37, 0x39, 0x66, 0x63, 0x62, 0x35, 0x35, 0x39, 0x64, 0x37, 0x62, 0x39, 0x31, 0x36, 0x61, 0x66, 0x64, 0x61, 0x61, 0x35, 0x30, 0x63, 0x61, 0x64, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x61, 0x37, 0x39, 0x31, 0x65, 0x62, 0x61, 0x62, 0x30, 0x34, 0x34, 0x35, 0x61, 0x30, 0x30, 0x65, 0x66, 0x64, 0x66, 0x63, 0x34, 0x65, 0x34, 0x61, 0x38, 0x65, 0x39, 0x61, 0x37, 0x65, 0x37, 0x35, 0x36, 0x35, 0x31, 0x33, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x66, 0x65, 0x35, 0x63, 0x66, 0x38, 0x32, 0x63, 0x63, 0x39, 0x65, 0x61, 0x35, 0x65, 0x33, 0x36, 0x63, 0x61, 0x64, 0x37, 0x63, 0x32, 0x39, 0x37, 0x34, 0x63, 0x65, 0x37, 0x32, 0x34, 0x39, 0x66, 0x33, 0x37, 0x34, 0x39, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x62, 0x34, 0x65, 0x63, 0x63, 0x36, 0x33, 0x35, 0x32, 0x35, 0x66, 0x37, 0x34, 0x33, 0x32, 0x63, 0x33, 0x64, 0x38, 0x33, 0x34, 0x66, 0x66, 0x65, 0x32, 0x62, 0x39, 0x37, 0x30, 0x66, 0x62, 0x65, 0x62, 0x38, 0x37, 0x32, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x37, 0x32, 0x61, 0x38, 0x66, 0x30, 0x36, 0x31, 0x63, 0x66, 0x65, 0x36, 0x39, 0x39, 0x36, 0x61, 0x64, 0x34, 0x34, 0x37, 0x64, 0x33, 0x63, 0x37, 0x32, 0x63, 0x32, 0x38, 0x63, 0x30, 0x63, 0x30, 0x38, 0x61, 0x62, 0x33, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x37, 0x31, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x61, 0x33, 0x63, 0x36, 0x38, 0x30, 0x30, 0x34, 0x32, 0x34, 0x38, 0x65, 0x34, 0x38, 0x39, 0x35, 0x37, 0x33, 0x61, 0x62, 0x62, 0x32, 0x37, 0x34, 0x33, 0x36, 0x37, 0x37, 0x30, 0x36, 0x36, 0x62, 0x32, 0x34, 0x63, 0x38, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x63, 0x30, 0x64, 0x30, 0x63, 0x63, 0x30, 0x62, 0x34, 0x64, 0x33, 0x34, 0x32, 0x64, 0x34, 0x30, 0x36, 0x32, 0x62, 0x61, 0x63, 0x36, 0x32, 0x34, 0x63, 0x63, 0x63, 0x33, 0x63, 0x37, 0x30, 0x63, 0x63, 0x36, 0x64, 0x61, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x39, 0x38, 0x63, 0x36, 0x36, 0x34, 0x63, 0x33, 0x65, 0x34, 0x34, 0x37, 0x61, 0x39, 0x35, 0x65, 0x36, 0x39, 0x62, 0x64, 0x35, 0x38, 0x32, 0x31, 0x37, 0x31, 0x62, 0x37, 0x31, 0x37, 0x36, 0x65, 0x61, 0x32, 0x61, 0x36, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x37, 0x31, 0x30, 0x38, 0x36, 0x64, 0x34, 0x63, 0x36, 0x30, 0x32, 0x35, 0x35, 0x34, 0x62, 0x38, 0x32, 0x64, 0x63, 0x62, 0x66, 0x63, 0x65, 0x38, 0x38, 0x64, 0x32, 0x30, 0x36, 0x33, 0x34, 0x64, 0x35, 0x33, 0x63, 0x63, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x36, 0x30, 0x31, 0x39, 0x39, 0x33, 0x37, 0x38, 0x39, 0x32, 0x30, 0x37, 0x66, 0x39, 0x36, 0x35, 0x62, 0x62, 0x38, 0x36, 0x35, 0x63, 0x62, 0x62, 0x34, 0x63, 0x64, 0x36, 0x35, 0x37, 0x63, 0x63, 0x65, 0x37, 0x36, 0x66, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x32, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x36, 0x62, 0x35, 0x35, 0x39, 0x39, 0x30, 0x38, 0x39, 0x61, 0x33, 0x66, 0x62, 0x36, 0x66, 0x32, 0x39, 0x63, 0x36, 0x63, 0x37, 0x32, 0x65, 0x34, 0x39, 0x62, 0x32, 0x65, 0x34, 0x37, 0x34, 0x30, 0x65, 0x61, 0x38, 0x30, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x33, 0x39, 0x39, 0x39, 0x38, 0x62, 0x32, 0x34, 0x37, 0x63, 0x62, 0x34, 0x62, 0x66, 0x38, 0x62, 0x63, 0x38, 0x30, 0x61, 0x36, 0x64, 0x32, 0x62, 0x33, 0x35, 0x32, 0x37, 0x66, 0x31, 0x64, 0x66, 0x65, 0x39, 0x61, 0x36, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x66, 0x37, 0x64, 0x32, 0x65, 0x32, 0x65, 0x32, 0x32, 0x30, 0x38, 0x34, 0x63, 0x34, 0x34, 0x66, 0x37, 0x30, 0x66, 0x65, 0x61, 0x61, 0x62, 0x36, 0x63, 0x33, 0x32, 0x31, 0x30, 0x35, 0x66, 0x33, 0x64, 0x61, 0x33, 0x37, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x65, 0x62, 0x61, 0x35, 0x36, 0x38, 0x34, 0x61, 0x61, 0x31, 0x62, 0x32, 0x34, 0x63, 0x62, 0x61, 0x36, 0x33, 0x31, 0x35, 0x30, 0x32, 0x36, 0x33, 0x62, 0x37, 0x61, 0x39, 0x31, 0x33, 0x31, 0x61, 0x65, 0x65, 0x63, 0x32, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x61, 0x64, 0x34, 0x62, 0x61, 0x64, 0x38, 0x32, 0x34, 0x62, 0x64, 0x30, 0x65, 0x62, 0x39, 0x65, 0x61, 0x34, 0x39, 0x63, 0x35, 0x38, 0x63, 0x65, 0x62, 0x63, 0x63, 0x30, 0x66, 0x66, 0x35, 0x65, 0x30, 0x38, 0x33, 0x34, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x64, 0x38, 0x37, 0x37, 0x33, 0x37, 0x38, 0x34, 0x30, 0x37, 0x62, 0x39, 0x34, 0x65, 0x37, 0x38, 0x31, 0x63, 0x34, 0x65, 0x66, 0x34, 0x61, 0x66, 0x37, 0x63, 0x66, 0x63, 0x35, 0x62, 0x63, 0x32, 0x32, 0x30, 0x62, 0x35, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x39, 0x63, 0x39, 0x65, 0x65, 0x34, 0x37, 0x31, 0x39, 0x35, 0x35, 0x31, 0x31, 0x66, 0x33, 0x35, 0x66, 0x38, 0x36, 0x32, 0x63, 0x61, 0x34, 0x63, 0x32, 0x32, 0x66, 0x64, 0x33, 0x35, 0x61, 0x65, 0x38, 0x66, 0x66, 0x62, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x61, 0x38, 0x39, 0x61, 0x31, 0x39, 0x32, 0x37, 0x63, 0x63, 0x34, 0x65, 0x32, 0x64, 0x34, 0x33, 0x66, 0x62, 0x63, 0x64, 0x61, 0x31, 0x65, 0x34, 0x31, 0x34, 0x64, 0x33, 0x32, 0x34, 0x61, 0x37, 0x64, 0x39, 0x65, 0x30, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x39, 0x33, 0x36, 0x39, 0x36, 0x66, 0x61, 0x32, 0x34, 0x38, 0x35, 0x39, 0x66, 0x35, 0x64, 0x32, 0x39, 0x33, 0x39, 0x61, 0x65, 0x62, 0x66, 0x61, 0x35, 0x34, 0x62, 0x34, 0x62, 0x35, 0x31, 0x61, 0x65, 0x31, 0x64, 0x63, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x66, 0x36, 0x35, 0x66, 0x31, 0x34, 0x37, 0x38, 0x34, 0x65, 0x35, 0x35, 0x61, 0x36, 0x66, 0x39, 0x35, 0x36, 0x36, 0x37, 0x66, 0x64, 0x37, 0x33, 0x32, 0x35, 0x32, 0x61, 0x31, 0x63, 0x39, 0x34, 0x30, 0x37, 0x32, 0x64, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x32, 0x39, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x37, 0x30, 0x63, 0x34, 0x39, 0x63, 0x63, 0x39, 0x38, 0x62, 0x33, 0x64, 0x66, 0x33, 0x66, 0x62, 0x65, 0x32, 0x62, 0x31, 0x35, 0x39, 0x37, 0x66, 0x35, 0x63, 0x31, 0x62, 0x36, 0x33, 0x34, 0x37, 0x61, 0x33, 0x38, 0x38, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x36, 0x66, 0x37, 0x38, 0x66, 0x37, 0x30, 0x64, 0x62, 0x32, 0x35, 0x39, 0x61, 0x63, 0x38, 0x35, 0x33, 0x34, 0x31, 0x34, 0x35, 0x62, 0x32, 0x39, 0x33, 0x34, 0x66, 0x34, 0x65, 0x66, 0x31, 0x30, 0x39, 0x38, 0x62, 0x35, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x62, 0x38, 0x61, 0x65, 0x38, 0x66, 0x36, 0x33, 0x65, 0x66, 0x33, 0x35, 0x65, 0x64, 0x30, 0x37, 0x36, 0x32, 0x66, 0x30, 0x62, 0x36, 0x32, 0x33, 0x33, 0x64, 0x34, 0x61, 0x63, 0x31, 0x34, 0x65, 0x36, 0x34, 0x62, 0x36, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x61, 0x65, 0x32, 0x39, 0x34, 0x33, 0x35, 0x35, 0x39, 0x38, 0x62, 0x61, 0x38, 0x66, 0x31, 0x63, 0x39, 0x33, 0x34, 0x32, 0x38, 0x63, 0x64, 0x62, 0x33, 0x65, 0x32, 0x62, 0x34, 0x64, 0x33, 0x31, 0x30, 0x37, 0x38, 0x65, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x66, 0x64, 0x39, 0x62, 0x35, 0x35, 0x31, 0x61, 0x39, 0x38, 0x63, 0x62, 0x36, 0x31, 0x63, 0x32, 0x65, 0x30, 0x37, 0x66, 0x62, 0x66, 0x34, 0x31, 0x64, 0x33, 0x65, 0x38, 0x63, 0x39, 0x61, 0x35, 0x33, 0x30, 0x63, 0x62, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x39, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x33, 0x65, 0x37, 0x38, 0x32, 0x39, 0x34, 0x62, 0x61, 0x38, 0x38, 0x36, 0x61, 0x30, 0x63, 0x66, 0x64, 0x35, 0x64, 0x33, 0x34, 0x38, 0x37, 0x66, 0x62, 0x33, 0x61, 0x33, 0x30, 0x37, 0x38, 0x64, 0x33, 0x33, 0x38, 0x64, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x66, 0x36, 0x65, 0x36, 0x38, 0x63, 0x30, 0x63, 0x64, 0x37, 0x35, 0x38, 0x34, 0x30, 0x38, 0x30, 0x65, 0x38, 0x34, 0x37, 0x64, 0x37, 0x32, 0x63, 0x62, 0x62, 0x32, 0x33, 0x61, 0x61, 0x64, 0x34, 0x36, 0x61, 0x65, 0x62, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x38, 0x39, 0x33, 0x34, 0x36, 0x37, 0x37, 0x32, 0x39, 0x39, 0x35, 0x65, 0x63, 0x31, 0x39, 0x30, 0x36, 0x66, 0x61, 0x66, 0x66, 0x65, 0x62, 0x61, 0x32, 0x61, 0x37, 0x66, 0x65, 0x37, 0x64, 0x65, 0x39, 0x63, 0x36, 0x62, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x35, 0x66, 0x35, 0x61, 0x64, 0x36, 0x36, 0x33, 0x61, 0x36, 0x66, 0x32, 0x36, 0x33, 0x33, 0x32, 0x37, 0x64, 0x36, 0x34, 0x63, 0x61, 0x63, 0x39, 0x63, 0x62, 0x31, 0x33, 0x33, 0x64, 0x32, 0x63, 0x39, 0x36, 0x30, 0x35, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x66, 0x65, 0x31, 0x33, 0x35, 0x37, 0x32, 0x31, 0x38, 0x64, 0x30, 0x39, 0x35, 0x38, 0x34, 0x39, 0x63, 0x64, 0x35, 0x37, 0x39, 0x38, 0x34, 0x32, 0x63, 0x34, 0x61, 0x61, 0x30, 0x32, 0x66, 0x66, 0x38, 0x38, 0x38, 0x64, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x39, 0x63, 0x36, 0x38, 0x65, 0x36, 0x31, 0x39, 0x39, 0x38, 0x64, 0x39, 0x63, 0x38, 0x31, 0x62, 0x31, 0x34, 0x65, 0x34, 0x65, 0x65, 0x38, 0x30, 0x32, 0x62, 0x61, 0x37, 0x61, 0x64, 0x66, 0x36, 0x64, 0x37, 0x34, 0x63, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x30, 0x66, 0x65, 0x31, 0x31, 0x66, 0x33, 0x63, 0x32, 0x34, 0x64, 0x62, 0x38, 0x37, 0x33, 0x32, 0x64, 0x36, 0x63, 0x32, 0x65, 0x37, 0x37, 0x32, 0x65, 0x32, 0x32, 0x39, 0x37, 0x63, 0x37, 0x65, 0x36, 0x35, 0x66, 0x31, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x36, 0x39, 0x32, 0x39, 0x38, 0x39, 0x30, 0x61, 0x37, 0x62, 0x34, 0x37, 0x66, 0x62, 0x38, 0x35, 0x39, 0x31, 0x39, 0x36, 0x30, 0x31, 0x36, 0x63, 0x36, 0x66, 0x64, 0x64, 0x38, 0x32, 0x38, 0x39, 0x63, 0x65, 0x62, 0x37, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x63, 0x37, 0x39, 0x64, 0x36, 0x65, 0x37, 0x66, 0x35, 0x35, 0x62, 0x63, 0x65, 0x32, 0x65, 0x32, 0x64, 0x30, 0x63, 0x30, 0x32, 0x61, 0x64, 0x30, 0x37, 0x63, 0x65, 0x63, 0x61, 0x38, 0x62, 0x62, 0x35, 0x32, 0x39, 0x33, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x36, 0x38, 0x37, 0x64, 0x61, 0x61, 0x33, 0x39, 0x63, 0x33, 0x36, 0x38, 0x31, 0x33, 0x39, 0x62, 0x36, 0x65, 0x37, 0x62, 0x65, 0x36, 0x30, 0x64, 0x63, 0x31, 0x37, 0x35, 0x33, 0x61, 0x39, 0x66, 0x30, 0x63, 0x62, 0x65, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x39, 0x62, 0x65, 0x34, 0x34, 0x30, 0x31, 0x33, 0x34, 0x64, 0x36, 0x32, 0x38, 0x30, 0x39, 0x38, 0x30, 0x31, 0x34, 0x34, 0x61, 0x39, 0x66, 0x36, 0x34, 0x64, 0x38, 0x34, 0x37, 0x34, 0x38, 0x61, 0x33, 0x37, 0x66, 0x33, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x38, 0x64, 0x30, 0x37, 0x32, 0x33, 0x37, 0x32, 0x31, 0x65, 0x37, 0x33, 0x61, 0x36, 0x63, 0x30, 0x64, 0x38, 0x36, 0x30, 0x61, 0x61, 0x30, 0x35, 0x35, 0x37, 0x61, 0x62, 0x64, 0x31, 0x34, 0x63, 0x31, 0x65, 0x65, 0x33, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x32, 0x34, 0x31, 0x66, 0x30, 0x33, 0x37, 0x33, 0x33, 0x37, 0x65, 0x62, 0x34, 0x61, 0x63, 0x63, 0x36, 0x31, 0x38, 0x34, 0x39, 0x62, 0x64, 0x32, 0x37, 0x32, 0x61, 0x63, 0x31, 0x33, 0x33, 0x66, 0x37, 0x63, 0x64, 0x66, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x62, 0x39, 0x35, 0x65, 0x62, 0x65, 0x66, 0x37, 0x39, 0x35, 0x30, 0x30, 0x62, 0x61, 0x61, 0x30, 0x65, 0x64, 0x61, 0x37, 0x32, 0x65, 0x37, 0x37, 0x66, 0x38, 0x37, 0x37, 0x34, 0x31, 0x35, 0x64, 0x66, 0x37, 0x35, 0x63, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x36, 0x65, 0x64, 0x35, 0x63, 0x37, 0x31, 0x39, 0x62, 0x35, 0x32, 0x36, 0x31, 0x34, 0x37, 0x37, 0x38, 0x39, 0x30, 0x34, 0x32, 0x35, 0x61, 0x65, 0x37, 0x35, 0x35, 0x31, 0x64, 0x63, 0x35, 0x39, 0x62, 0x64, 0x32, 0x35, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x39, 0x37, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x32, 0x65, 0x32, 0x66, 0x31, 0x36, 0x31, 0x38, 0x35, 0x35, 0x32, 0x65, 0x61, 0x62, 0x30, 0x64, 0x62, 0x39, 0x38, 0x61, 0x64, 0x64, 0x35, 0x35, 0x36, 0x33, 0x37, 0x63, 0x32, 0x39, 0x35, 0x31, 0x66, 0x31, 0x66, 0x62, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x33, 0x31, 0x34, 0x35, 0x63, 0x62, 0x34, 0x61, 0x65, 0x37, 0x34, 0x38, 0x39, 0x66, 0x63, 0x63, 0x39, 0x30, 0x63, 0x64, 0x39, 0x38, 0x35, 0x63, 0x36, 0x64, 0x63, 0x37, 0x38, 0x32, 0x62, 0x33, 0x63, 0x63, 0x34, 0x65, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x62, 0x65, 0x32, 0x34, 0x66, 0x32, 0x38, 0x39, 0x34, 0x34, 0x33, 0x65, 0x65, 0x34, 0x37, 0x33, 0x62, 0x63, 0x37, 0x36, 0x38, 0x32, 0x32, 0x66, 0x35, 0x35, 0x30, 0x39, 0x38, 0x64, 0x38, 0x39, 0x62, 0x39, 0x31, 0x63, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x62, 0x63, 0x33, 0x37, 0x62, 0x31, 0x64, 0x32, 0x61, 0x33, 0x37, 0x38, 0x38, 0x64, 0x35, 0x38, 0x39, 0x62, 0x36, 0x64, 0x65, 0x32, 0x31, 0x32, 0x64, 0x63, 0x31, 0x37, 0x31, 0x33, 0x62, 0x32, 0x66, 0x36, 0x65, 0x37, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x66, 0x63, 0x35, 0x32, 0x37, 0x64, 0x63, 0x65, 0x31, 0x37, 0x38, 0x35, 0x66, 0x30, 0x66, 0x62, 0x38, 0x62, 0x63, 0x37, 0x65, 0x35, 0x31, 0x38, 0x62, 0x31, 0x63, 0x36, 0x36, 0x39, 0x66, 0x37, 0x65, 0x63, 0x64, 0x66, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x38, 0x30, 0x62, 0x31, 0x62, 0x63, 0x39, 0x34, 0x33, 0x39, 0x30, 0x66, 0x30, 0x34, 0x62, 0x33, 0x39, 0x37, 0x62, 0x64, 0x37, 0x33, 0x65, 0x39, 0x35, 0x64, 0x39, 0x36, 0x65, 0x66, 0x31, 0x31, 0x65, 0x61, 0x66, 0x33, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x62, 0x66, 0x34, 0x61, 0x66, 0x33, 0x38, 0x31, 0x30, 0x62, 0x38, 0x34, 0x32, 0x33, 0x38, 0x37, 0x64, 0x62, 0x37, 0x30, 0x63, 0x31, 0x34, 0x64, 0x34, 0x36, 0x30, 0x39, 0x39, 0x36, 0x32, 0x36, 0x30, 0x30, 0x33, 0x64, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x39, 0x39, 0x33, 0x64, 0x33, 0x31, 0x32, 0x61, 0x61, 0x31, 0x31, 0x30, 0x36, 0x39, 0x35, 0x37, 0x38, 0x36, 0x38, 0x66, 0x36, 0x61, 0x35, 0x35, 0x61, 0x35, 0x65, 0x38, 0x66, 0x31, 0x32, 0x66, 0x37, 0x37, 0x63, 0x38, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x32, 0x39, 0x62, 0x34, 0x62, 0x34, 0x37, 0x63, 0x30, 0x39, 0x65, 0x62, 0x31, 0x36, 0x31, 0x35, 0x38, 0x34, 0x36, 0x34, 0x63, 0x38, 0x61, 0x61, 0x37, 0x66, 0x64, 0x39, 0x36, 0x39, 0x30, 0x62, 0x34, 0x33, 0x38, 0x38, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x37, 0x30, 0x65, 0x36, 0x39, 0x64, 0x32, 0x63, 0x34, 0x61, 0x30, 0x61, 0x66, 0x38, 0x31, 0x38, 0x38, 0x30, 0x37, 0x62, 0x31, 0x61, 0x32, 0x37, 0x30, 0x35, 0x66, 0x37, 0x39, 0x66, 0x64, 0x30, 0x62, 0x35, 0x64, 0x62, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x62, 0x35, 0x30, 0x31, 0x34, 0x36, 0x65, 0x37, 0x31, 0x39, 0x31, 0x36, 0x61, 0x35, 0x34, 0x34, 0x38, 0x64, 0x65, 0x31, 0x32, 0x61, 0x34, 0x64, 0x37, 0x34, 0x32, 0x31, 0x33, 0x35, 0x64, 0x63, 0x66, 0x33, 0x39, 0x38, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x34, 0x33, 0x39, 0x61, 0x61, 0x61, 0x32, 0x34, 0x65, 0x33, 0x36, 0x33, 0x36, 0x66, 0x33, 0x61, 0x31, 0x38, 0x65, 0x30, 0x32, 0x30, 0x65, 0x61, 0x31, 0x64, 0x61, 0x37, 0x65, 0x31, 0x34, 0x35, 0x31, 0x36, 0x30, 0x64, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x62, 0x34, 0x34, 0x32, 0x39, 0x62, 0x31, 0x38, 0x32, 0x66, 0x30, 0x33, 0x37, 0x37, 0x62, 0x65, 0x37, 0x65, 0x36, 0x32, 0x36, 0x39, 0x33, 0x39, 0x63, 0x35, 0x64, 0x62, 0x36, 0x34, 0x34, 0x30, 0x66, 0x37, 0x35, 0x64, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x37, 0x39, 0x37, 0x32, 0x36, 0x66, 0x35, 0x63, 0x37, 0x31, 0x61, 0x65, 0x31, 0x62, 0x36, 0x64, 0x31, 0x36, 0x61, 0x36, 0x38, 0x34, 0x32, 0x38, 0x31, 0x37, 0x34, 0x65, 0x36, 0x62, 0x33, 0x34, 0x62, 0x32, 0x33, 0x36, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x35, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x65, 0x65, 0x39, 0x31, 0x64, 0x33, 0x65, 0x66, 0x35, 0x38, 0x63, 0x39, 0x64, 0x31, 0x61, 0x35, 0x38, 0x39, 0x38, 0x34, 0x34, 0x65, 0x61, 0x31, 0x61, 0x65, 0x33, 0x31, 0x32, 0x35, 0x64, 0x36, 0x63, 0x35, 0x62, 0x61, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x32, 0x33, 0x30, 0x34, 0x31, 0x31, 0x38, 0x62, 0x38, 0x30, 0x34, 0x37, 0x33, 0x64, 0x39, 0x65, 0x39, 0x66, 0x65, 0x33, 0x65, 0x65, 0x34, 0x35, 0x38, 0x66, 0x62, 0x65, 0x36, 0x31, 0x30, 0x66, 0x66, 0x64, 0x61, 0x32, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x30, 0x38, 0x62, 0x30, 0x33, 0x34, 0x36, 0x36, 0x63, 0x32, 0x37, 0x61, 0x31, 0x37, 0x64, 0x66, 0x65, 0x31, 0x61, 0x61, 0x66, 0x63, 0x65, 0x62, 0x38, 0x31, 0x65, 0x31, 0x36, 0x64, 0x32, 0x39, 0x33, 0x34, 0x35, 0x36, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x33, 0x34, 0x36, 0x34, 0x31, 0x34, 0x62, 0x65, 0x63, 0x36, 0x64, 0x33, 0x64, 0x63, 0x63, 0x34, 0x34, 0x65, 0x35, 0x30, 0x65, 0x35, 0x34, 0x64, 0x35, 0x34, 0x63, 0x32, 0x62, 0x38, 0x63, 0x33, 0x37, 0x33, 0x34, 0x65, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x65, 0x65, 0x35, 0x30, 0x63, 0x35, 0x66, 0x39, 0x38, 0x38, 0x32, 0x30, 0x36, 0x62, 0x30, 0x39, 0x61, 0x35, 0x37, 0x33, 0x34, 0x36, 0x39, 0x66, 0x62, 0x31, 0x64, 0x30, 0x62, 0x34, 0x32, 0x65, 0x62, 0x62, 0x36, 0x64, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x63, 0x65, 0x31, 0x34, 0x30, 0x30, 0x38, 0x30, 0x30, 0x39, 0x33, 0x36, 0x63, 0x37, 0x63, 0x36, 0x34, 0x38, 0x35, 0x66, 0x63, 0x64, 0x64, 0x33, 0x36, 0x32, 0x36, 0x30, 0x31, 0x37, 0x64, 0x30, 0x39, 0x61, 0x66, 0x62, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x66, 0x33, 0x61, 0x64, 0x37, 0x36, 0x33, 0x35, 0x33, 0x38, 0x31, 0x30, 0x62, 0x65, 0x36, 0x61, 0x38, 0x39, 0x64, 0x37, 0x33, 0x31, 0x62, 0x37, 0x38, 0x37, 0x66, 0x36, 0x66, 0x31, 0x37, 0x31, 0x38, 0x38, 0x36, 0x31, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x34, 0x30, 0x32, 0x33, 0x30, 0x30, 0x65, 0x38, 0x31, 0x64, 0x31, 0x34, 0x36, 0x63, 0x32, 0x65, 0x36, 0x34, 0x34, 0x65, 0x32, 0x62, 0x62, 0x64, 0x61, 0x31, 0x64, 0x61, 0x31, 0x36, 0x33, 0x63, 0x61, 0x33, 0x66, 0x62, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x34, 0x62, 0x34, 0x61, 0x34, 0x62, 0x35, 0x34, 0x38, 0x30, 0x37, 0x30, 0x66, 0x66, 0x34, 0x31, 0x34, 0x33, 0x32, 0x63, 0x39, 0x65, 0x30, 0x38, 0x61, 0x30, 0x63, 0x61, 0x36, 0x66, 0x61, 0x37, 0x62, 0x63, 0x39, 0x66, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x64, 0x64, 0x35, 0x38, 0x39, 0x30, 0x33, 0x38, 0x38, 0x36, 0x33, 0x30, 0x33, 0x62, 0x39, 0x32, 0x38, 0x36, 0x32, 0x35, 0x32, 0x35, 0x37, 0x61, 0x65, 0x31, 0x61, 0x30, 0x31, 0x33, 0x64, 0x37, 0x31, 0x61, 0x65, 0x32, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x36, 0x63, 0x38, 0x31, 0x38, 0x62, 0x65, 0x66, 0x64, 0x32, 0x35, 0x31, 0x33, 0x36, 0x31, 0x65, 0x30, 0x32, 0x37, 0x34, 0x34, 0x30, 0x36, 0x38, 0x62, 0x65, 0x39, 0x39, 0x64, 0x38, 0x61, 0x61, 0x36, 0x30, 0x62, 0x38, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x64, 0x32, 0x64, 0x64, 0x63, 0x36, 0x36, 0x66, 0x33, 0x30, 0x38, 0x63, 0x30, 0x31, 0x35, 0x38, 0x61, 0x65, 0x33, 0x63, 0x63, 0x62, 0x37, 0x62, 0x38, 0x36, 0x39, 0x66, 0x37, 0x64, 0x31, 0x39, 0x39, 0x64, 0x37, 0x62, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x34, 0x38, 0x36, 0x61, 0x30, 0x34, 0x34, 0x32, 0x64, 0x31, 0x37, 0x31, 0x63, 0x38, 0x36, 0x30, 0x35, 0x62, 0x65, 0x33, 0x34, 0x38, 0x66, 0x65, 0x65, 0x35, 0x37, 0x65, 0x62, 0x35, 0x30, 0x38, 0x35, 0x65, 0x66, 0x66, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x30, 0x37, 0x31, 0x30, 0x34, 0x66, 0x32, 0x37, 0x30, 0x33, 0x64, 0x36, 0x37, 0x39, 0x66, 0x38, 0x64, 0x65, 0x61, 0x66, 0x63, 0x34, 0x34, 0x32, 0x62, 0x65, 0x66, 0x65, 0x38, 0x34, 0x39, 0x65, 0x34, 0x32, 0x39, 0x35, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x36, 0x31, 0x61, 0x30, 0x34, 0x62, 0x66, 0x66, 0x64, 0x35, 0x37, 0x63, 0x31, 0x30, 0x34, 0x37, 0x30, 0x64, 0x34, 0x35, 0x63, 0x33, 0x39, 0x31, 0x30, 0x33, 0x66, 0x36, 0x34, 0x36, 0x35, 0x30, 0x33, 0x34, 0x37, 0x36, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x63, 0x34, 0x35, 0x39, 0x35, 0x34, 0x61, 0x36, 0x32, 0x62, 0x39, 0x31, 0x31, 0x61, 0x64, 0x37, 0x30, 0x31, 0x66, 0x66, 0x32, 0x65, 0x39, 0x30, 0x31, 0x33, 0x31, 0x65, 0x38, 0x63, 0x65, 0x62, 0x38, 0x39, 0x63, 0x39, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x36, 0x35, 0x34, 0x35, 0x38, 0x62, 0x65, 0x39, 0x36, 0x34, 0x61, 0x65, 0x34, 0x34, 0x39, 0x66, 0x37, 0x31, 0x37, 0x37, 0x33, 0x37, 0x30, 0x34, 0x39, 0x37, 0x39, 0x37, 0x36, 0x36, 0x66, 0x38, 0x38, 0x39, 0x38, 0x37, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x62, 0x33, 0x37, 0x38, 0x32, 0x35, 0x66, 0x30, 0x33, 0x30, 0x37, 0x33, 0x64, 0x33, 0x31, 0x65, 0x32, 0x34, 0x39, 0x33, 0x37, 0x38, 0x63, 0x33, 0x30, 0x63, 0x37, 0x39, 0x35, 0x63, 0x33, 0x33, 0x66, 0x38, 0x33, 0x61, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x30, 0x39, 0x39, 0x37, 0x34, 0x63, 0x65, 0x33, 0x39, 0x64, 0x36, 0x30, 0x61, 0x61, 0x64, 0x66, 0x32, 0x65, 0x36, 0x39, 0x36, 0x37, 0x33, 0x32, 0x35, 0x31, 0x62, 0x66, 0x30, 0x65, 0x30, 0x34, 0x37, 0x36, 0x30, 0x61, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x34, 0x31, 0x61, 0x63, 0x31, 0x38, 0x37, 0x61, 0x64, 0x37, 0x65, 0x30, 0x39, 0x30, 0x35, 0x32, 0x32, 0x64, 0x65, 0x36, 0x64, 0x61, 0x33, 0x32, 0x31, 0x33, 0x65, 0x39, 0x61, 0x37, 0x66, 0x34, 0x34, 0x33, 0x39, 0x36, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x33, 0x65, 0x66, 0x63, 0x36, 0x33, 0x39, 0x37, 0x61, 0x61, 0x36, 0x35, 0x66, 0x62, 0x35, 0x33, 0x61, 0x38, 0x66, 0x30, 0x37, 0x61, 0x30, 0x66, 0x38, 0x39, 0x33, 0x61, 0x61, 0x65, 0x33, 0x30, 0x65, 0x38, 0x62, 0x63, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x34, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x66, 0x31, 0x39, 0x39, 0x38, 0x65, 0x31, 0x63, 0x62, 0x31, 0x35, 0x38, 0x30, 0x63, 0x65, 0x63, 0x34, 0x66, 0x36, 0x63, 0x30, 0x34, 0x37, 0x64, 0x63, 0x64, 0x33, 0x64, 0x63, 0x65, 0x63, 0x35, 0x34, 0x63, 0x66, 0x37, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x64, 0x37, 0x36, 0x63, 0x32, 0x63, 0x33, 0x62, 0x35, 0x64, 0x35, 0x30, 0x66, 0x66, 0x38, 0x66, 0x62, 0x35, 0x30, 0x62, 0x33, 0x65, 0x65, 0x61, 0x63, 0x64, 0x36, 0x38, 0x31, 0x35, 0x39, 0x30, 0x62, 0x65, 0x31, 0x63, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x37, 0x64, 0x36, 0x37, 0x64, 0x38, 0x37, 0x66, 0x35, 0x38, 0x36, 0x66, 0x30, 0x61, 0x35, 0x61, 0x34, 0x37, 0x39, 0x65, 0x32, 0x30, 0x65, 0x65, 0x31, 0x33, 0x65, 0x61, 0x33, 0x31, 0x30, 0x61, 0x31, 0x30, 0x62, 0x36, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x35, 0x65, 0x65, 0x35, 0x33, 0x33, 0x61, 0x63, 0x62, 0x66, 0x62, 0x33, 0x61, 0x32, 0x64, 0x37, 0x36, 0x64, 0x35, 0x62, 0x36, 0x38, 0x35, 0x32, 0x37, 0x37, 0x62, 0x37, 0x39, 0x36, 0x63, 0x35, 0x36, 0x61, 0x30, 0x35, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x33, 0x66, 0x63, 0x61, 0x35, 0x65, 0x64, 0x37, 0x37, 0x66, 0x36, 0x39, 0x39, 0x66, 0x39, 0x64, 0x39, 0x39, 0x33, 0x30, 0x66, 0x35, 0x63, 0x65, 0x65, 0x66, 0x66, 0x38, 0x65, 0x35, 0x36, 0x66, 0x35, 0x39, 0x66, 0x30, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x66, 0x65, 0x32, 0x63, 0x65, 0x39, 0x37, 0x66, 0x30, 0x65, 0x38, 0x63, 0x33, 0x38, 0x35, 0x36, 0x62, 0x65, 0x30, 0x64, 0x65, 0x35, 0x66, 0x34, 0x64, 0x63, 0x62, 0x32, 0x63, 0x65, 0x35, 0x64, 0x33, 0x38, 0x39, 0x61, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x38, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x32, 0x35, 0x38, 0x32, 0x35, 0x35, 0x62, 0x33, 0x37, 0x63, 0x37, 0x66, 0x35, 0x38, 0x66, 0x34, 0x62, 0x31, 0x30, 0x36, 0x37, 0x33, 0x61, 0x39, 0x33, 0x32, 0x64, 0x64, 0x33, 0x61, 0x66, 0x64, 0x39, 0x30, 0x66, 0x34, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x30, 0x66, 0x65, 0x39, 0x63, 0x36, 0x63, 0x61, 0x64, 0x35, 0x30, 0x63, 0x31, 0x38, 0x66, 0x31, 0x31, 0x61, 0x39, 0x65, 0x64, 0x39, 0x63, 0x34, 0x35, 0x37, 0x34, 0x30, 0x61, 0x36, 0x31, 0x38, 0x30, 0x36, 0x31, 0x32, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x33, 0x31, 0x31, 0x36, 0x37, 0x66, 0x39, 0x63, 0x63, 0x39, 0x33, 0x62, 0x33, 0x63, 0x36, 0x34, 0x36, 0x35, 0x36, 0x30, 0x39, 0x64, 0x37, 0x39, 0x64, 0x62, 0x30, 0x63, 0x64, 0x65, 0x39, 0x30, 0x65, 0x38, 0x34, 0x38, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x62, 0x62, 0x35, 0x65, 0x36, 0x39, 0x35, 0x37, 0x61, 0x61, 0x38, 0x32, 0x31, 0x65, 0x66, 0x36, 0x35, 0x39, 0x62, 0x36, 0x30, 0x31, 0x38, 0x61, 0x33, 0x39, 0x33, 0x61, 0x35, 0x30, 0x34, 0x63, 0x61, 0x65, 0x34, 0x34, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x33, 0x30, 0x35, 0x61, 0x37, 0x39, 0x36, 0x65, 0x33, 0x33, 0x62, 0x62, 0x66, 0x37, 0x66, 0x39, 0x61, 0x65, 0x61, 0x65, 0x36, 0x35, 0x31, 0x32, 0x39, 0x35, 0x39, 0x30, 0x36, 0x36, 0x65, 0x66, 0x64, 0x61, 0x31, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x37, 0x66, 0x39, 0x64, 0x34, 0x64, 0x33, 0x31, 0x65, 0x66, 0x37, 0x30, 0x38, 0x33, 0x39, 0x64, 0x38, 0x34, 0x62, 0x30, 0x64, 0x39, 0x63, 0x64, 0x62, 0x37, 0x32, 0x62, 0x39, 0x61, 0x66, 0x65, 0x64, 0x62, 0x64, 0x66, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x39, 0x65, 0x31, 0x31, 0x39, 0x37, 0x64, 0x37, 0x39, 0x37, 0x34, 0x61, 0x37, 0x36, 0x34, 0x38, 0x64, 0x63, 0x63, 0x37, 0x61, 0x30, 0x33, 0x31, 0x31, 0x32, 0x61, 0x38, 0x38, 0x65, 0x64, 0x62, 0x63, 0x39, 0x30, 0x34, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x66, 0x37, 0x37, 0x66, 0x39, 0x39, 0x38, 0x62, 0x32, 0x30, 0x65, 0x30, 0x62, 0x63, 0x64, 0x63, 0x64, 0x39, 0x66, 0x63, 0x38, 0x33, 0x38, 0x36, 0x34, 0x31, 0x35, 0x32, 0x36, 0x63, 0x66, 0x32, 0x35, 0x39, 0x31, 0x38, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x66, 0x66, 0x63, 0x31, 0x35, 0x37, 0x61, 0x64, 0x36, 0x62, 0x66, 0x38, 0x64, 0x35, 0x36, 0x64, 0x39, 0x61, 0x31, 0x61, 0x37, 0x66, 0x64, 0x64, 0x62, 0x63, 0x30, 0x66, 0x65, 0x61, 0x30, 0x31, 0x30, 0x61, 0x61, 0x62, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x66, 0x65, 0x39, 0x31, 0x34, 0x31, 0x66, 0x34, 0x37, 0x30, 0x34, 0x35, 0x39, 0x39, 0x31, 0x35, 0x39, 0x64, 0x37, 0x62, 0x32, 0x32, 0x33, 0x64, 0x65, 0x34, 0x32, 0x62, 0x66, 0x66, 0x64, 0x38, 0x30, 0x34, 0x39, 0x36, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x31, 0x62, 0x66, 0x35, 0x33, 0x61, 0x39, 0x63, 0x62, 0x65, 0x38, 0x33, 0x61, 0x37, 0x64, 0x65, 0x61, 0x34, 0x33, 0x34, 0x35, 0x37, 0x39, 0x66, 0x65, 0x37, 0x32, 0x61, 0x61, 0x63, 0x38, 0x64, 0x32, 0x61, 0x30, 0x63, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x63, 0x63, 0x63, 0x33, 0x63, 0x36, 0x61, 0x63, 0x64, 0x38, 0x35, 0x63, 0x32, 0x65, 0x34, 0x36, 0x30, 0x63, 0x34, 0x66, 0x66, 0x64, 0x64, 0x38, 0x32, 0x62, 0x63, 0x37, 0x35, 0x64, 0x63, 0x38, 0x34, 0x39, 0x65, 0x61, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x38, 0x36, 0x61, 0x30, 0x36, 0x36, 0x65, 0x64, 0x62, 0x36, 0x31, 0x66, 0x63, 0x62, 0x35, 0x38, 0x35, 0x36, 0x64, 0x65, 0x39, 0x33, 0x62, 0x37, 0x35, 0x63, 0x38, 0x63, 0x37, 0x39, 0x31, 0x38, 0x36, 0x34, 0x62, 0x39, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x31, 0x62, 0x38, 0x61, 0x38, 0x62, 0x35, 0x31, 0x64, 0x65, 0x61, 0x31, 0x39, 0x38, 0x39, 0x61, 0x35, 0x39, 0x32, 0x31, 0x66, 0x31, 0x33, 0x65, 0x63, 0x31, 0x61, 0x39, 0x35, 0x35, 0x61, 0x35, 0x31, 0x35, 0x61, 0x64, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x66, 0x63, 0x64, 0x39, 0x63, 0x37, 0x39, 0x66, 0x62, 0x34, 0x33, 0x33, 0x34, 0x63, 0x61, 0x36, 0x32, 0x34, 0x37, 0x62, 0x30, 0x61, 0x33, 0x33, 0x62, 0x64, 0x39, 0x63, 0x63, 0x33, 0x33, 0x32, 0x30, 0x38, 0x65, 0x32, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x61, 0x63, 0x31, 0x64, 0x33, 0x65, 0x64, 0x37, 0x34, 0x36, 0x34, 0x66, 0x61, 0x33, 0x64, 0x62, 0x31, 0x34, 0x65, 0x37, 0x37, 0x32, 0x39, 0x32, 0x31, 0x33, 0x63, 0x65, 0x61, 0x61, 0x33, 0x37, 0x38, 0x63, 0x30, 0x39, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x39, 0x64, 0x36, 0x36, 0x33, 0x63, 0x38, 0x64, 0x36, 0x30, 0x39, 0x30, 0x38, 0x33, 0x39, 0x31, 0x63, 0x38, 0x64, 0x32, 0x33, 0x36, 0x31, 0x39, 0x31, 0x35, 0x33, 0x33, 0x66, 0x64, 0x66, 0x37, 0x37, 0x37, 0x35, 0x36, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x65, 0x64, 0x35, 0x66, 0x66, 0x64, 0x64, 0x31, 0x61, 0x64, 0x64, 0x38, 0x35, 0x35, 0x61, 0x32, 0x36, 0x39, 0x32, 0x66, 0x65, 0x30, 0x36, 0x32, 0x62, 0x35, 0x64, 0x36, 0x31, 0x38, 0x37, 0x34, 0x32, 0x33, 0x36, 0x30, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x34, 0x66, 0x30, 0x31, 0x34, 0x31, 0x64, 0x37, 0x32, 0x31, 0x64, 0x33, 0x33, 0x63, 0x62, 0x64, 0x63, 0x34, 0x31, 0x30, 0x31, 0x38, 0x62, 0x64, 0x30, 0x31, 0x31, 0x31, 0x39, 0x61, 0x61, 0x34, 0x37, 0x38, 0x34, 0x38, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x38, 0x36, 0x38, 0x37, 0x65, 0x33, 0x34, 0x31, 0x37, 0x37, 0x31, 0x30, 0x62, 0x62, 0x38, 0x61, 0x39, 0x33, 0x35, 0x35, 0x39, 0x30, 0x32, 0x31, 0x61, 0x31, 0x34, 0x36, 0x39, 0x65, 0x36, 0x61, 0x38, 0x36, 0x62, 0x63, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x32, 0x36, 0x36, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x35, 0x62, 0x31, 0x39, 0x38, 0x61, 0x30, 0x30, 0x63, 0x66, 0x62, 0x35, 0x35, 0x61, 0x39, 0x37, 0x62, 0x35, 0x64, 0x35, 0x33, 0x36, 0x34, 0x34, 0x63, 0x66, 0x66, 0x61, 0x38, 0x61, 0x30, 0x34, 0x64, 0x32, 0x61, 0x62, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x35, 0x39, 0x66, 0x33, 0x64, 0x64, 0x65, 0x37, 0x37, 0x65, 0x30, 0x39, 0x39, 0x34, 0x30, 0x62, 0x65, 0x66, 0x62, 0x36, 0x65, 0x65, 0x35, 0x38, 0x30, 0x33, 0x31, 0x39, 0x36, 0x35, 0x63, 0x61, 0x65, 0x37, 0x61, 0x33, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x65, 0x62, 0x65, 0x63, 0x31, 0x61, 0x36, 0x32, 0x63, 0x30, 0x38, 0x62, 0x30, 0x35, 0x61, 0x37, 0x64, 0x31, 0x64, 0x35, 0x39, 0x31, 0x38, 0x30, 0x61, 0x66, 0x39, 0x66, 0x66, 0x30, 0x64, 0x31, 0x38, 0x65, 0x33, 0x66, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x61, 0x39, 0x37, 0x31, 0x61, 0x37, 0x33, 0x39, 0x37, 0x39, 0x39, 0x66, 0x38, 0x63, 0x62, 0x34, 0x38, 0x65, 0x61, 0x38, 0x34, 0x37, 0x35, 0x64, 0x37, 0x32, 0x62, 0x32, 0x64, 0x32, 0x34, 0x37, 0x34, 0x31, 0x37, 0x32, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x64, 0x34, 0x36, 0x34, 0x39, 0x64, 0x66, 0x36, 0x34, 0x36, 0x65, 0x32, 0x38, 0x31, 0x39, 0x32, 0x32, 0x39, 0x30, 0x33, 0x32, 0x64, 0x38, 0x38, 0x36, 0x38, 0x35, 0x35, 0x36, 0x66, 0x65, 0x31, 0x65, 0x30, 0x35, 0x33, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x30, 0x66, 0x65, 0x34, 0x31, 0x35, 0x61, 0x36, 0x34, 0x31, 0x62, 0x30, 0x38, 0x35, 0x36, 0x63, 0x34, 0x65, 0x37, 0x35, 0x62, 0x66, 0x39, 0x36, 0x30, 0x35, 0x31, 0x35, 0x34, 0x34, 0x31, 0x61, 0x66, 0x61, 0x33, 0x35, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x66, 0x35, 0x31, 0x36, 0x31, 0x34, 0x36, 0x63, 0x64, 0x61, 0x32, 0x30, 0x32, 0x38, 0x31, 0x37, 0x31, 0x39, 0x39, 0x37, 0x38, 0x30, 0x36, 0x30, 0x63, 0x36, 0x62, 0x65, 0x34, 0x31, 0x34, 0x39, 0x30, 0x36, 0x37, 0x63, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x61, 0x31, 0x33, 0x37, 0x30, 0x31, 0x31, 0x36, 0x66, 0x65, 0x32, 0x32, 0x30, 0x39, 0x39, 0x65, 0x30, 0x31, 0x35, 0x64, 0x30, 0x37, 0x63, 0x64, 0x32, 0x36, 0x36, 0x39, 0x64, 0x64, 0x32, 0x39, 0x31, 0x63, 0x63, 0x39, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x63, 0x30, 0x34, 0x65, 0x66, 0x64, 0x33, 0x31, 0x30, 0x66, 0x34, 0x34, 0x30, 0x34, 0x38, 0x33, 0x63, 0x37, 0x33, 0x66, 0x37, 0x34, 0x34, 0x62, 0x35, 0x62, 0x39, 0x65, 0x36, 0x34, 0x35, 0x39, 0x39, 0x63, 0x65, 0x33, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x39, 0x31, 0x34, 0x63, 0x39, 0x35, 0x62, 0x35, 0x36, 0x30, 0x65, 0x63, 0x31, 0x33, 0x66, 0x31, 0x34, 0x30, 0x35, 0x37, 0x37, 0x33, 0x33, 0x38, 0x63, 0x33, 0x32, 0x62, 0x63, 0x62, 0x62, 0x37, 0x37, 0x64, 0x33, 0x61, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x63, 0x38, 0x31, 0x32, 0x37, 0x33, 0x37, 0x61, 0x63, 0x36, 0x30, 0x36, 0x62, 0x61, 0x66, 0x37, 0x35, 0x32, 0x32, 0x61, 0x64, 0x38, 0x31, 0x37, 0x34, 0x32, 0x38, 0x61, 0x33, 0x36, 0x30, 0x35, 0x30, 0x65, 0x37, 0x61, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x31, 0x34, 0x35, 0x36, 0x66, 0x66, 0x66, 0x30, 0x31, 0x30, 0x34, 0x65, 0x65, 0x38, 0x34, 0x34, 0x61, 0x33, 0x33, 0x31, 0x34, 0x37, 0x33, 0x37, 0x38, 0x34, 0x33, 0x33, 0x33, 0x38, 0x64, 0x32, 0x34, 0x63, 0x64, 0x36, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x36, 0x65, 0x63, 0x65, 0x39, 0x39, 0x31, 0x31, 0x31, 0x63, 0x61, 0x64, 0x31, 0x39, 0x36, 0x31, 0x63, 0x37, 0x34, 0x38, 0x65, 0x64, 0x33, 0x64, 0x66, 0x35, 0x31, 0x65, 0x64, 0x64, 0x36, 0x39, 0x64, 0x32, 0x61, 0x33, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x39, 0x64, 0x37, 0x30, 0x39, 0x35, 0x37, 0x39, 0x66, 0x66, 0x34, 0x62, 0x63, 0x30, 0x39, 0x66, 0x64, 0x63, 0x64, 0x64, 0x65, 0x34, 0x33, 0x31, 0x64, 0x63, 0x31, 0x34, 0x34, 0x37, 0x64, 0x32, 0x63, 0x32, 0x36, 0x30, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x66, 0x66, 0x38, 0x34, 0x62, 0x62, 0x65, 0x66, 0x34, 0x32, 0x33, 0x30, 0x37, 0x31, 0x65, 0x36, 0x30, 0x34, 0x63, 0x33, 0x36, 0x31, 0x62, 0x62, 0x61, 0x36, 0x37, 0x37, 0x66, 0x35, 0x35, 0x39, 0x33, 0x64, 0x65, 0x66, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x30, 0x63, 0x35, 0x34, 0x30, 0x30, 0x38, 0x38, 0x31, 0x31, 0x33, 0x66, 0x61, 0x36, 0x65, 0x63, 0x30, 0x30, 0x62, 0x34, 0x62, 0x32, 0x63, 0x38, 0x38, 0x32, 0x34, 0x66, 0x38, 0x37, 0x39, 0x36, 0x65, 0x39, 0x36, 0x65, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x33, 0x32, 0x32, 0x30, 0x63, 0x36, 0x39, 0x37, 0x62, 0x63, 0x64, 0x32, 0x38, 0x66, 0x32, 0x36, 0x65, 0x66, 0x30, 0x62, 0x37, 0x34, 0x34, 0x30, 0x34, 0x61, 0x38, 0x62, 0x65, 0x62, 0x30, 0x36, 0x62, 0x32, 0x62, 0x61, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x39, 0x61, 0x36, 0x63, 0x64, 0x62, 0x33, 0x61, 0x38, 0x61, 0x37, 0x64, 0x62, 0x38, 0x65, 0x31, 0x66, 0x33, 0x30, 0x63, 0x38, 0x62, 0x38, 0x34, 0x63, 0x64, 0x37, 0x33, 0x62, 0x61, 0x65, 0x30, 0x32, 0x62, 0x63, 0x30, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x31, 0x35, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x66, 0x62, 0x33, 0x31, 0x61, 0x35, 0x63, 0x61, 0x65, 0x65, 0x36, 0x61, 0x39, 0x36, 0x64, 0x65, 0x33, 0x39, 0x33, 0x62, 0x64, 0x62, 0x66, 0x38, 0x39, 0x66, 0x62, 0x65, 0x36, 0x35, 0x66, 0x65, 0x31, 0x32, 0x35, 0x62, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x30, 0x66, 0x62, 0x33, 0x34, 0x30, 0x31, 0x66, 0x37, 0x32, 0x62, 0x64, 0x33, 0x34, 0x31, 0x38, 0x62, 0x37, 0x64, 0x31, 0x64, 0x61, 0x37, 0x35, 0x62, 0x66, 0x38, 0x63, 0x35, 0x31, 0x39, 0x64, 0x64, 0x37, 0x30, 0x37, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x37, 0x35, 0x31, 0x65, 0x37, 0x66, 0x32, 0x34, 0x64, 0x66, 0x39, 0x64, 0x39, 0x34, 0x61, 0x36, 0x33, 0x37, 0x61, 0x35, 0x64, 0x65, 0x64, 0x65, 0x66, 0x66, 0x63, 0x35, 0x38, 0x32, 0x37, 0x37, 0x62, 0x35, 0x64, 0x62, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x65, 0x64, 0x37, 0x65, 0x30, 0x37, 0x64, 0x30, 0x37, 0x31, 0x31, 0x65, 0x36, 0x38, 0x34, 0x64, 0x65, 0x36, 0x35, 0x61, 0x63, 0x38, 0x62, 0x32, 0x61, 0x62, 0x35, 0x37, 0x63, 0x35, 0x35, 0x63, 0x31, 0x61, 0x38, 0x36, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x37, 0x66, 0x66, 0x34, 0x34, 0x31, 0x62, 0x61, 0x36, 0x66, 0x66, 0x65, 0x33, 0x36, 0x37, 0x31, 0x66, 0x33, 0x63, 0x30, 0x64, 0x61, 0x62, 0x62, 0x66, 0x66, 0x31, 0x38, 0x32, 0x33, 0x61, 0x35, 0x30, 0x34, 0x33, 0x33, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x35, 0x34, 0x37, 0x34, 0x62, 0x61, 0x35, 0x38, 0x66, 0x30, 0x66, 0x32, 0x66, 0x34, 0x30, 0x65, 0x36, 0x63, 0x62, 0x61, 0x62, 0x65, 0x64, 0x34, 0x65, 0x61, 0x31, 0x37, 0x36, 0x65, 0x30, 0x31, 0x31, 0x66, 0x63, 0x61, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x32, 0x34, 0x32, 0x37, 0x61, 0x64, 0x37, 0x35, 0x37, 0x38, 0x62, 0x34, 0x62, 0x66, 0x65, 0x32, 0x30, 0x61, 0x39, 0x66, 0x36, 0x33, 0x61, 0x37, 0x63, 0x35, 0x35, 0x30, 0x36, 0x64, 0x35, 0x63, 0x61, 0x31, 0x32, 0x64, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x61, 0x38, 0x62, 0x61, 0x61, 0x65, 0x64, 0x30, 0x31, 0x32, 0x65, 0x61, 0x32, 0x65, 0x36, 0x33, 0x38, 0x30, 0x33, 0x62, 0x35, 0x39, 0x33, 0x64, 0x30, 0x64, 0x30, 0x63, 0x32, 0x61, 0x61, 0x62, 0x34, 0x63, 0x35, 0x62, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x37, 0x65, 0x30, 0x37, 0x32, 0x31, 0x34, 0x34, 0x34, 0x39, 0x39, 0x66, 0x65, 0x35, 0x65, 0x62, 0x62, 0x64, 0x33, 0x35, 0x34, 0x61, 0x63, 0x63, 0x37, 0x65, 0x37, 0x65, 0x66, 0x62, 0x35, 0x38, 0x39, 0x38, 0x35, 0x64, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x63, 0x32, 0x66, 0x66, 0x61, 0x31, 0x62, 0x65, 0x66, 0x35, 0x34, 0x39, 0x31, 0x39, 0x64, 0x32, 0x30, 0x39, 0x37, 0x66, 0x37, 0x61, 0x31, 0x34, 0x32, 0x64, 0x32, 0x65, 0x31, 0x34, 0x66, 0x39, 0x62, 0x30, 0x34, 0x61, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x33, 0x38, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x66, 0x61, 0x66, 0x31, 0x36, 0x35, 0x62, 0x65, 0x30, 0x33, 0x31, 0x65, 0x63, 0x31, 0x38, 0x33, 0x33, 0x30, 0x64, 0x39, 0x66, 0x63, 0x65, 0x35, 0x62, 0x64, 0x31, 0x32, 0x38, 0x31, 0x61, 0x31, 0x61, 0x66, 0x30, 0x38, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x35, 0x61, 0x62, 0x36, 0x35, 0x38, 0x63, 0x36, 0x66, 0x30, 0x65, 0x64, 0x34, 0x66, 0x38, 0x37, 0x35, 0x65, 0x64, 0x36, 0x37, 0x34, 0x32, 0x65, 0x34, 0x62, 0x63, 0x37, 0x32, 0x39, 0x32, 0x64, 0x31, 0x61, 0x62, 0x62, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x31, 0x38, 0x65, 0x63, 0x37, 0x36, 0x37, 0x65, 0x33, 0x32, 0x30, 0x35, 0x30, 0x38, 0x31, 0x39, 0x35, 0x66, 0x31, 0x33, 0x37, 0x34, 0x35, 0x30, 0x30, 0x65, 0x33, 0x66, 0x32, 0x65, 0x31, 0x32, 0x35, 0x36, 0x38, 0x39, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x66, 0x63, 0x35, 0x33, 0x37, 0x62, 0x32, 0x31, 0x30, 0x36, 0x35, 0x38, 0x36, 0x36, 0x30, 0x61, 0x38, 0x33, 0x62, 0x61, 0x61, 0x39, 0x61, 0x63, 0x34, 0x61, 0x38, 0x34, 0x30, 0x32, 0x66, 0x36, 0x35, 0x37, 0x34, 0x36, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x36, 0x36, 0x34, 0x64, 0x32, 0x32, 0x30, 0x66, 0x61, 0x37, 0x66, 0x33, 0x37, 0x39, 0x35, 0x38, 0x30, 0x32, 0x34, 0x61, 0x33, 0x33, 0x33, 0x32, 0x64, 0x36, 0x38, 0x34, 0x62, 0x63, 0x63, 0x36, 0x64, 0x34, 0x63, 0x38, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x61, 0x63, 0x62, 0x36, 0x31, 0x35, 0x36, 0x38, 0x65, 0x63, 0x34, 0x61, 0x66, 0x37, 0x65, 0x61, 0x32, 0x38, 0x31, 0x39, 0x33, 0x38, 0x36, 0x31, 0x38, 0x31, 0x62, 0x31, 0x31, 0x36, 0x61, 0x36, 0x63, 0x35, 0x65, 0x65, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x64, 0x39, 0x38, 0x66, 0x33, 0x38, 0x61, 0x33, 0x62, 0x61, 0x33, 0x64, 0x62, 0x63, 0x30, 0x31, 0x66, 0x61, 0x35, 0x63, 0x32, 0x63, 0x31, 0x34, 0x32, 0x37, 0x64, 0x38, 0x36, 0x32, 0x38, 0x33, 0x32, 0x66, 0x32, 0x66, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x65, 0x31, 0x31, 0x35, 0x32, 0x36, 0x38, 0x32, 0x62, 0x37, 0x35, 0x39, 0x38, 0x66, 0x65, 0x32, 0x64, 0x31, 0x65, 0x32, 0x31, 0x65, 0x63, 0x31, 0x35, 0x35, 0x33, 0x33, 0x38, 0x38, 0x35, 0x34, 0x33, 0x35, 0x61, 0x63, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x31, 0x38, 0x64, 0x39, 0x62, 0x31, 0x30, 0x34, 0x34, 0x31, 0x31, 0x34, 0x38, 0x30, 0x61, 0x38, 0x36, 0x33, 0x65, 0x36, 0x32, 0x33, 0x66, 0x63, 0x35, 0x35, 0x32, 0x33, 0x32, 0x64, 0x31, 0x61, 0x34, 0x66, 0x34, 0x38, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x35, 0x37, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x64, 0x65, 0x62, 0x61, 0x65, 0x63, 0x62, 0x35, 0x66, 0x33, 0x33, 0x39, 0x62, 0x65, 0x65, 0x61, 0x34, 0x38, 0x39, 0x34, 0x65, 0x35, 0x32, 0x30, 0x34, 0x62, 0x66, 0x61, 0x33, 0x34, 0x30, 0x64, 0x30, 0x36, 0x37, 0x66, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x37, 0x33, 0x31, 0x62, 0x35, 0x35, 0x63, 0x65, 0x64, 0x34, 0x35, 0x32, 0x62, 0x62, 0x33, 0x66, 0x33, 0x66, 0x65, 0x38, 0x37, 0x31, 0x64, 0x64, 0x63, 0x33, 0x65, 0x64, 0x37, 0x65, 0x65, 0x36, 0x35, 0x31, 0x30, 0x61, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x64, 0x66, 0x32, 0x34, 0x32, 0x64, 0x32, 0x34, 0x30, 0x64, 0x64, 0x34, 0x62, 0x38, 0x30, 0x37, 0x31, 0x64, 0x37, 0x32, 0x66, 0x38, 0x66, 0x63, 0x66, 0x33, 0x35, 0x62, 0x62, 0x33, 0x38, 0x30, 0x39, 0x64, 0x37, 0x31, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x63, 0x66, 0x39, 0x33, 0x30, 0x65, 0x35, 0x64, 0x31, 0x31, 0x36, 0x61, 0x62, 0x38, 0x64, 0x31, 0x33, 0x62, 0x39, 0x66, 0x39, 0x61, 0x37, 0x65, 0x63, 0x34, 0x61, 0x62, 0x35, 0x30, 0x30, 0x33, 0x61, 0x36, 0x61, 0x62, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x61, 0x32, 0x35, 0x61, 0x35, 0x66, 0x35, 0x61, 0x66, 0x30, 0x31, 0x36, 0x39, 0x62, 0x33, 0x30, 0x38, 0x36, 0x34, 0x63, 0x33, 0x62, 0x65, 0x34, 0x64, 0x37, 0x35, 0x36, 0x33, 0x63, 0x63, 0x64, 0x34, 0x34, 0x66, 0x30, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x36, 0x65, 0x66, 0x62, 0x36, 0x66, 0x34, 0x33, 0x31, 0x38, 0x38, 0x37, 0x36, 0x64, 0x32, 0x65, 0x65, 0x36, 0x32, 0x34, 0x65, 0x32, 0x37, 0x35, 0x39, 0x35, 0x66, 0x34, 0x34, 0x34, 0x34, 0x36, 0x66, 0x36, 0x38, 0x65, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x32, 0x34, 0x39, 0x66, 0x65, 0x37, 0x30, 0x66, 0x36, 0x31, 0x63, 0x36, 0x62, 0x31, 0x36, 0x66, 0x31, 0x39, 0x61, 0x33, 0x32, 0x34, 0x38, 0x34, 0x30, 0x66, 0x64, 0x63, 0x30, 0x32, 0x30, 0x32, 0x33, 0x31, 0x62, 0x62, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x30, 0x34, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x35, 0x32, 0x33, 0x37, 0x63, 0x34, 0x62, 0x65, 0x31, 0x34, 0x36, 0x66, 0x62, 0x61, 0x39, 0x39, 0x34, 0x37, 0x38, 0x66, 0x33, 0x61, 0x37, 0x64, 0x61, 0x64, 0x31, 0x37, 0x62, 0x30, 0x39, 0x31, 0x33, 0x38, 0x64, 0x61, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x31, 0x66, 0x62, 0x35, 0x61, 0x38, 0x39, 0x61, 0x38, 0x39, 0x61, 0x37, 0x32, 0x31, 0x62, 0x38, 0x37, 0x39, 0x37, 0x30, 0x36, 0x38, 0x66, 0x62, 0x63, 0x34, 0x37, 0x66, 0x33, 0x65, 0x39, 0x64, 0x35, 0x32, 0x65, 0x31, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x37, 0x66, 0x62, 0x61, 0x65, 0x64, 0x39, 0x39, 0x66, 0x63, 0x32, 0x30, 0x39, 0x39, 0x36, 0x32, 0x36, 0x30, 0x34, 0x65, 0x62, 0x64, 0x32, 0x30, 0x65, 0x32, 0x34, 0x30, 0x66, 0x37, 0x34, 0x66, 0x34, 0x35, 0x39, 0x31, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x34, 0x63, 0x33, 0x61, 0x62, 0x36, 0x32, 0x31, 0x38, 0x31, 0x65, 0x39, 0x61, 0x31, 0x35, 0x62, 0x37, 0x38, 0x63, 0x34, 0x36, 0x32, 0x31, 0x65, 0x34, 0x63, 0x37, 0x63, 0x35, 0x38, 0x38, 0x31, 0x32, 0x37, 0x62, 0x65, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x32, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x63, 0x64, 0x37, 0x34, 0x33, 0x32, 0x64, 0x35, 0x31, 0x36, 0x31, 0x62, 0x65, 0x37, 0x39, 0x37, 0x36, 0x38, 0x61, 0x64, 0x34, 0x35, 0x64, 0x65, 0x33, 0x65, 0x34, 0x34, 0x37, 0x61, 0x30, 0x37, 0x39, 0x38, 0x32, 0x30, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x61, 0x37, 0x30, 0x36, 0x39, 0x31, 0x32, 0x35, 0x35, 0x63, 0x39, 0x66, 0x63, 0x39, 0x37, 0x39, 0x31, 0x61, 0x34, 0x66, 0x37, 0x35, 0x63, 0x38, 0x62, 0x38, 0x31, 0x66, 0x33, 0x38, 0x38, 0x65, 0x30, 0x61, 0x32, 0x35, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x32, 0x66, 0x31, 0x36, 0x64, 0x37, 0x39, 0x61, 0x62, 0x66, 0x63, 0x65, 0x63, 0x33, 0x39, 0x34, 0x33, 0x65, 0x33, 0x34, 0x62, 0x32, 0x30, 0x66, 0x30, 0x35, 0x66, 0x39, 0x37, 0x62, 0x64, 0x66, 0x63, 0x64, 0x61, 0x36, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x63, 0x36, 0x36, 0x39, 0x36, 0x35, 0x65, 0x34, 0x32, 0x36, 0x66, 0x66, 0x31, 0x61, 0x63, 0x38, 0x37, 0x61, 0x64, 0x36, 0x65, 0x62, 0x37, 0x38, 0x63, 0x31, 0x64, 0x39, 0x35, 0x32, 0x37, 0x31, 0x31, 0x35, 0x38, 0x66, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x38, 0x37, 0x38, 0x36, 0x33, 0x65, 0x63, 0x34, 0x33, 0x61, 0x34, 0x38, 0x31, 0x64, 0x66, 0x30, 0x34, 0x64, 0x30, 0x31, 0x37, 0x37, 0x36, 0x32, 0x65, 0x64, 0x63, 0x62, 0x35, 0x63, 0x61, 0x61, 0x36, 0x32, 0x39, 0x62, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x37, 0x64, 0x36, 0x38, 0x34, 0x39, 0x62, 0x31, 0x36, 0x38, 0x66, 0x36, 0x63, 0x33, 0x33, 0x33, 0x32, 0x62, 0x37, 0x61, 0x62, 0x61, 0x65, 0x37, 0x65, 0x62, 0x36, 0x63, 0x34, 0x32, 0x63, 0x33, 0x37, 0x66, 0x34, 0x38, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x31, 0x31, 0x35, 0x38, 0x62, 0x65, 0x35, 0x37, 0x36, 0x32, 0x62, 0x31, 0x31, 0x39, 0x63, 0x63, 0x39, 0x62, 0x32, 0x30, 0x33, 0x35, 0x65, 0x38, 0x38, 0x65, 0x65, 0x34, 0x65, 0x65, 0x37, 0x38, 0x66, 0x32, 0x39, 0x62, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x62, 0x39, 0x31, 0x65, 0x32, 0x65, 0x32, 0x39, 0x30, 0x32, 0x64, 0x30, 0x35, 0x65, 0x32, 0x62, 0x35, 0x39, 0x31, 0x62, 0x34, 0x31, 0x30, 0x38, 0x33, 0x62, 0x64, 0x37, 0x62, 0x65, 0x62, 0x32, 0x64, 0x35, 0x32, 0x63, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x34, 0x38, 0x36, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x32, 0x63, 0x65, 0x63, 0x62, 0x31, 0x30, 0x63, 0x66, 0x63, 0x66, 0x33, 0x38, 0x65, 0x63, 0x39, 0x38, 0x36, 0x62, 0x34, 0x33, 0x62, 0x38, 0x37, 0x37, 0x30, 0x61, 0x64, 0x65, 0x63, 0x65, 0x39, 0x32, 0x30, 0x30, 0x32, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x34, 0x65, 0x33, 0x62, 0x61, 0x31, 0x33, 0x32, 0x32, 0x65, 0x64, 0x30, 0x35, 0x37, 0x31, 0x31, 0x38, 0x33, 0x61, 0x32, 0x34, 0x66, 0x39, 0x34, 0x32, 0x30, 0x34, 0x65, 0x65, 0x34, 0x39, 0x63, 0x31, 0x38, 0x36, 0x36, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x37, 0x38, 0x62, 0x62, 0x38, 0x34, 0x39, 0x31, 0x33, 0x39, 0x61, 0x36, 0x62, 0x61, 0x33, 0x38, 0x61, 0x65, 0x39, 0x32, 0x61, 0x30, 0x39, 0x61, 0x36, 0x39, 0x36, 0x30, 0x31, 0x63, 0x63, 0x34, 0x63, 0x62, 0x36, 0x32, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x65, 0x30, 0x62, 0x36, 0x38, 0x36, 0x32, 0x63, 0x63, 0x65, 0x39, 0x31, 0x36, 0x32, 0x65, 0x38, 0x37, 0x65, 0x30, 0x38, 0x34, 0x39, 0x65, 0x33, 0x38, 0x37, 0x63, 0x62, 0x35, 0x64, 0x66, 0x34, 0x66, 0x39, 0x31, 0x31, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x32, 0x63, 0x30, 0x61, 0x37, 0x38, 0x37, 0x37, 0x33, 0x34, 0x35, 0x66, 0x65, 0x30, 0x63, 0x32, 0x33, 0x33, 0x62, 0x62, 0x30, 0x66, 0x30, 0x34, 0x66, 0x64, 0x36, 0x61, 0x62, 0x31, 0x38, 0x62, 0x36, 0x66, 0x31, 0x34, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x31, 0x36, 0x64, 0x63, 0x31, 0x33, 0x38, 0x65, 0x32, 0x35, 0x38, 0x31, 0x35, 0x62, 0x39, 0x30, 0x62, 0x65, 0x33, 0x66, 0x65, 0x39, 0x65, 0x65, 0x65, 0x38, 0x66, 0x66, 0x62, 0x32, 0x65, 0x31, 0x30, 0x35, 0x36, 0x32, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x38, 0x39, 0x64, 0x30, 0x31, 0x64, 0x62, 0x31, 0x32, 0x63, 0x38, 0x31, 0x36, 0x61, 0x63, 0x32, 0x36, 0x38, 0x65, 0x39, 0x61, 0x66, 0x31, 0x39, 0x64, 0x63, 0x30, 0x64, 0x64, 0x36, 0x64, 0x39, 0x39, 0x66, 0x31, 0x35, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x62, 0x37, 0x37, 0x64, 0x62, 0x39, 0x62, 0x38, 0x31, 0x62, 0x62, 0x65, 0x39, 0x30, 0x34, 0x32, 0x37, 0x62, 0x36, 0x32, 0x66, 0x37, 0x30, 0x32, 0x62, 0x32, 0x30, 0x31, 0x66, 0x66, 0x63, 0x32, 0x39, 0x66, 0x66, 0x36, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x66, 0x66, 0x38, 0x31, 0x31, 0x64, 0x61, 0x64, 0x38, 0x31, 0x39, 0x65, 0x63, 0x65, 0x33, 0x62, 0x61, 0x36, 0x30, 0x32, 0x63, 0x33, 0x38, 0x33, 0x66, 0x62, 0x35, 0x64, 0x63, 0x36, 0x34, 0x63, 0x30, 0x61, 0x33, 0x61, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x33, 0x30, 0x38, 0x37, 0x65, 0x36, 0x32, 0x65, 0x30, 0x34, 0x62, 0x66, 0x39, 0x30, 0x30, 0x64, 0x35, 0x61, 0x35, 0x34, 0x64, 0x63, 0x33, 0x65, 0x39, 0x34, 0x36, 0x32, 0x37, 0x34, 0x64, 0x61, 0x39, 0x32, 0x34, 0x32, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x31, 0x30, 0x32, 0x33, 0x66, 0x64, 0x65, 0x31, 0x35, 0x37, 0x34, 0x64, 0x62, 0x38, 0x62, 0x62, 0x35, 0x34, 0x66, 0x31, 0x37, 0x33, 0x39, 0x36, 0x37, 0x30, 0x31, 0x35, 0x37, 0x63, 0x61, 0x34, 0x37, 0x64, 0x61, 0x36, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x36, 0x39, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x33, 0x62, 0x30, 0x31, 0x30, 0x62, 0x31, 0x38, 0x65, 0x36, 0x65, 0x32, 0x62, 0x65, 0x31, 0x31, 0x33, 0x35, 0x38, 0x37, 0x31, 0x30, 0x32, 0x36, 0x62, 0x37, 0x62, 0x61, 0x31, 0x35, 0x65, 0x61, 0x30, 0x66, 0x64, 0x65, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x62, 0x64, 0x61, 0x66, 0x33, 0x35, 0x34, 0x66, 0x34, 0x37, 0x32, 0x30, 0x61, 0x34, 0x36, 0x36, 0x61, 0x37, 0x36, 0x34, 0x61, 0x35, 0x32, 0x38, 0x64, 0x36, 0x30, 0x65, 0x33, 0x61, 0x34, 0x38, 0x32, 0x61, 0x33, 0x39, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x62, 0x62, 0x63, 0x36, 0x37, 0x64, 0x31, 0x33, 0x66, 0x38, 0x39, 0x65, 0x62, 0x63, 0x61, 0x35, 0x39, 0x34, 0x62, 0x65, 0x39, 0x34, 0x62, 0x63, 0x35, 0x31, 0x37, 0x30, 0x39, 0x32, 0x30, 0x63, 0x33, 0x30, 0x64, 0x39, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x37, 0x35, 0x34, 0x39, 0x36, 0x66, 0x64, 0x34, 0x64, 0x64, 0x38, 0x39, 0x33, 0x31, 0x66, 0x64, 0x36, 0x39, 0x66, 0x62, 0x30, 0x61, 0x30, 0x62, 0x30, 0x34, 0x63, 0x34, 0x64, 0x31, 0x66, 0x66, 0x38, 0x37, 0x39, 0x65, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x31, 0x32, 0x35, 0x30, 0x61, 0x32, 0x39, 0x31, 0x32, 0x31, 0x32, 0x37, 0x30, 0x61, 0x34, 0x65, 0x65, 0x35, 0x64, 0x37, 0x38, 0x64, 0x32, 0x34, 0x66, 0x65, 0x61, 0x66, 0x65, 0x38, 0x32, 0x63, 0x37, 0x30, 0x62, 0x61, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x30, 0x63, 0x63, 0x62, 0x35, 0x39, 0x31, 0x31, 0x63, 0x66, 0x37, 0x38, 0x66, 0x36, 0x66, 0x36, 0x32, 0x32, 0x66, 0x35, 0x33, 0x35, 0x63, 0x34, 0x37, 0x34, 0x33, 0x37, 0x35, 0x66, 0x34, 0x61, 0x31, 0x32, 0x63, 0x66, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x32, 0x65, 0x38, 0x30, 0x39, 0x36, 0x62, 0x61, 0x66, 0x62, 0x38, 0x38, 0x31, 0x36, 0x32, 0x36, 0x30, 0x36, 0x30, 0x30, 0x32, 0x65, 0x38, 0x63, 0x38, 0x61, 0x33, 0x65, 0x64, 0x31, 0x39, 0x38, 0x31, 0x34, 0x61, 0x65, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x35, 0x34, 0x32, 0x36, 0x63, 0x66, 0x66, 0x33, 0x37, 0x38, 0x65, 0x64, 0x32, 0x33, 0x32, 0x35, 0x33, 0x35, 0x31, 0x33, 0x62, 0x31, 0x39, 0x66, 0x34, 0x39, 0x36, 0x64, 0x65, 0x34, 0x35, 0x66, 0x61, 0x37, 0x65, 0x31, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x61, 0x36, 0x39, 0x33, 0x62, 0x31, 0x32, 0x32, 0x66, 0x33, 0x31, 0x34, 0x34, 0x38, 0x32, 0x61, 0x34, 0x37, 0x62, 0x31, 0x31, 0x63, 0x63, 0x37, 0x37, 0x63, 0x36, 0x38, 0x61, 0x34, 0x39, 0x37, 0x38, 0x37, 0x36, 0x31, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x62, 0x37, 0x38, 0x33, 0x64, 0x33, 0x31, 0x64, 0x33, 0x32, 0x61, 0x64, 0x63, 0x35, 0x30, 0x66, 0x61, 0x33, 0x65, 0x61, 0x63, 0x61, 0x61, 0x31, 0x35, 0x64, 0x39, 0x32, 0x62, 0x35, 0x36, 0x38, 0x65, 0x61, 0x65, 0x62, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x38, 0x65, 0x36, 0x35, 0x35, 0x37, 0x36, 0x36, 0x62, 0x39, 0x34, 0x34, 0x66, 0x62, 0x32, 0x36, 0x33, 0x36, 0x31, 0x39, 0x36, 0x35, 0x38, 0x37, 0x34, 0x30, 0x62, 0x38, 0x35, 0x30, 0x63, 0x39, 0x34, 0x61, 0x66, 0x61, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x32, 0x33, 0x63, 0x35, 0x65, 0x34, 0x62, 0x37, 0x38, 0x32, 0x62, 0x30, 0x30, 0x61, 0x35, 0x66, 0x61, 0x64, 0x66, 0x31, 0x61, 0x65, 0x61, 0x64, 0x38, 0x37, 0x64, 0x61, 0x63, 0x66, 0x35, 0x62, 0x30, 0x33, 0x36, 0x37, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x31, 0x37, 0x66, 0x33, 0x39, 0x37, 0x66, 0x38, 0x66, 0x34, 0x36, 0x66, 0x31, 0x62, 0x61, 0x65, 0x34, 0x35, 0x64, 0x31, 0x38, 0x37, 0x31, 0x34, 0x38, 0x63, 0x30, 0x36, 0x65, 0x65, 0x62, 0x39, 0x35, 0x39, 0x66, 0x61, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x37, 0x38, 0x65, 0x31, 0x30, 0x32, 0x31, 0x32, 0x63, 0x61, 0x31, 0x34, 0x66, 0x66, 0x30, 0x37, 0x33, 0x32, 0x61, 0x38, 0x32, 0x34, 0x31, 0x65, 0x33, 0x37, 0x34, 0x36, 0x37, 0x64, 0x62, 0x38, 0x35, 0x36, 0x33, 0x32, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x62, 0x35, 0x34, 0x39, 0x35, 0x61, 0x35, 0x30, 0x35, 0x33, 0x33, 0x36, 0x63, 0x32, 0x34, 0x36, 0x35, 0x34, 0x31, 0x30, 0x64, 0x31, 0x63, 0x61, 0x65, 0x30, 0x39, 0x35, 0x62, 0x38, 0x65, 0x31, 0x62, 0x61, 0x35, 0x63, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x35, 0x62, 0x30, 0x66, 0x35, 0x32, 0x34, 0x32, 0x37, 0x35, 0x33, 0x37, 0x30, 0x31, 0x62, 0x32, 0x36, 0x34, 0x61, 0x36, 0x37, 0x30, 0x37, 0x31, 0x61, 0x32, 0x64, 0x63, 0x38, 0x38, 0x30, 0x38, 0x33, 0x36, 0x62, 0x38, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x65, 0x64, 0x64, 0x65, 0x33, 0x37, 0x66, 0x39, 0x61, 0x38, 0x63, 0x33, 0x39, 0x64, 0x64, 0x65, 0x61, 0x32, 0x34, 0x64, 0x37, 0x39, 0x66, 0x34, 0x30, 0x31, 0x35, 0x37, 0x35, 0x37, 0x64, 0x30, 0x36, 0x62, 0x66, 0x37, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x30, 0x66, 0x33, 0x31, 0x62, 0x39, 0x38, 0x39, 0x33, 0x31, 0x31, 0x65, 0x34, 0x31, 0x32, 0x34, 0x63, 0x36, 0x61, 0x37, 0x34, 0x36, 0x35, 0x66, 0x35, 0x61, 0x34, 0x34, 0x30, 0x39, 0x34, 0x64, 0x33, 0x36, 0x66, 0x39, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x31, 0x35, 0x37, 0x36, 0x31, 0x32, 0x37, 0x36, 0x34, 0x65, 0x30, 0x66, 0x64, 0x36, 0x39, 0x36, 0x63, 0x38, 0x63, 0x62, 0x35, 0x66, 0x62, 0x61, 0x38, 0x35, 0x64, 0x66, 0x34, 0x63, 0x30, 0x64, 0x64, 0x63, 0x33, 0x63, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x35, 0x32, 0x31, 0x64, 0x65, 0x62, 0x33, 0x62, 0x36, 0x65, 0x66, 0x31, 0x34, 0x31, 0x36, 0x65, 0x61, 0x34, 0x63, 0x37, 0x38, 0x31, 0x61, 0x32, 0x65, 0x35, 0x64, 0x37, 0x62, 0x33, 0x36, 0x65, 0x65, 0x38, 0x31, 0x63, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x66, 0x64, 0x39, 0x30, 0x62, 0x35, 0x33, 0x35, 0x65, 0x30, 0x30, 0x62, 0x62, 0x64, 0x38, 0x38, 0x39, 0x66, 0x64, 0x61, 0x37, 0x65, 0x39, 0x63, 0x33, 0x31, 0x38, 0x34, 0x66, 0x38, 0x37, 0x39, 0x61, 0x31, 0x35, 0x31, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x33, 0x35, 0x61, 0x34, 0x62, 0x63, 0x37, 0x31, 0x66, 0x62, 0x32, 0x38, 0x66, 0x64, 0x64, 0x35, 0x64, 0x32, 0x63, 0x33, 0x32, 0x32, 0x39, 0x38, 0x33, 0x61, 0x35, 0x36, 0x63, 0x32, 0x38, 0x34, 0x34, 0x32, 0x36, 0x65, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x37, 0x63, 0x39, 0x65, 0x34, 0x33, 0x32, 0x33, 0x30, 0x36, 0x39, 0x35, 0x31, 0x38, 0x31, 0x38, 0x39, 0x64, 0x35, 0x32, 0x30, 0x37, 0x61, 0x30, 0x37, 0x32, 0x38, 0x64, 0x63, 0x62, 0x39, 0x32, 0x33, 0x30, 0x36, 0x61, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x66, 0x39, 0x34, 0x30, 0x66, 0x36, 0x33, 0x65, 0x63, 0x39, 0x62, 0x38, 0x64, 0x38, 0x37, 0x36, 0x32, 0x37, 0x32, 0x61, 0x63, 0x61, 0x39, 0x36, 0x66, 0x65, 0x66, 0x36, 0x35, 0x63, 0x64, 0x61, 0x63, 0x65, 0x63, 0x64, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x39, 0x33, 0x35, 0x38, 0x37, 0x30, 0x39, 0x33, 0x33, 0x32, 0x63, 0x38, 0x32, 0x62, 0x38, 0x38, 0x37, 0x65, 0x32, 0x30, 0x62, 0x63, 0x64, 0x64, 0x64, 0x30, 0x32, 0x32, 0x30, 0x66, 0x38, 0x65, 0x64, 0x62, 0x61, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x35, 0x37, 0x61, 0x64, 0x35, 0x39, 0x34, 0x62, 0x64, 0x38, 0x38, 0x33, 0x32, 0x38, 0x61, 0x37, 0x64, 0x39, 0x30, 0x66, 0x63, 0x30, 0x61, 0x39, 0x30, 0x37, 0x64, 0x66, 0x39, 0x35, 0x65, 0x65, 0x63, 0x61, 0x65, 0x33, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x30, 0x35, 0x31, 0x36, 0x36, 0x36, 0x63, 0x62, 0x34, 0x66, 0x37, 0x62, 0x64, 0x32, 0x62, 0x31, 0x39, 0x30, 0x37, 0x32, 0x32, 0x31, 0x62, 0x38, 0x32, 0x39, 0x62, 0x35, 0x35, 0x35, 0x64, 0x37, 0x61, 0x33, 0x64, 0x62, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x62, 0x66, 0x63, 0x35, 0x62, 0x32, 0x30, 0x37, 0x65, 0x62, 0x32, 0x30, 0x31, 0x33, 0x65, 0x32, 0x65, 0x36, 0x30, 0x66, 0x37, 0x37, 0x35, 0x66, 0x65, 0x63, 0x64, 0x37, 0x31, 0x38, 0x31, 0x30, 0x63, 0x35, 0x39, 0x39, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x62, 0x39, 0x30, 0x38, 0x31, 0x65, 0x37, 0x37, 0x31, 0x30, 0x33, 0x34, 0x35, 0x65, 0x33, 0x38, 0x65, 0x30, 0x32, 0x65, 0x31, 0x36, 0x34, 0x34, 0x39, 0x61, 0x63, 0x65, 0x31, 0x62, 0x38, 0x35, 0x62, 0x63, 0x66, 0x63, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x37, 0x33, 0x66, 0x37, 0x62, 0x31, 0x63, 0x61, 0x33, 0x62, 0x37, 0x37, 0x33, 0x62, 0x33, 0x34, 0x32, 0x34, 0x39, 0x61, 0x64, 0x61, 0x32, 0x65, 0x32, 0x63, 0x38, 0x61, 0x39, 0x32, 0x37, 0x34, 0x63, 0x63, 0x31, 0x37, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x64, 0x61, 0x66, 0x34, 0x61, 0x62, 0x66, 0x61, 0x38, 0x36, 0x37, 0x64, 0x62, 0x31, 0x37, 0x66, 0x39, 0x39, 0x61, 0x66, 0x36, 0x61, 0x62, 0x65, 0x62, 0x66, 0x37, 0x30, 0x37, 0x61, 0x33, 0x63, 0x66, 0x35, 0x35, 0x64, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x36, 0x32, 0x39, 0x63, 0x32, 0x30, 0x36, 0x30, 0x38, 0x31, 0x33, 0x35, 0x34, 0x39, 0x31, 0x62, 0x35, 0x30, 0x31, 0x33, 0x66, 0x31, 0x30, 0x30, 0x32, 0x35, 0x38, 0x36, 0x61, 0x30, 0x33, 0x38, 0x33, 0x31, 0x33, 0x30, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x65, 0x34, 0x36, 0x64, 0x65, 0x34, 0x34, 0x35, 0x33, 0x63, 0x33, 0x38, 0x65, 0x39, 0x34, 0x31, 0x65, 0x37, 0x39, 0x33, 0x30, 0x66, 0x34, 0x33, 0x33, 0x30, 0x34, 0x66, 0x39, 0x34, 0x62, 0x62, 0x37, 0x62, 0x32, 0x62, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x38, 0x35, 0x66, 0x36, 0x32, 0x31, 0x32, 0x35, 0x36, 0x34, 0x33, 0x33, 0x62, 0x39, 0x38, 0x61, 0x34, 0x32, 0x30, 0x30, 0x64, 0x61, 0x64, 0x38, 0x35, 0x37, 0x65, 0x66, 0x65, 0x35, 0x35, 0x39, 0x33, 0x37, 0x65, 0x63, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x35, 0x63, 0x31, 0x30, 0x63, 0x39, 0x33, 0x65, 0x30, 0x64, 0x62, 0x37, 0x32, 0x30, 0x35, 0x62, 0x32, 0x36, 0x34, 0x33, 0x34, 0x35, 0x38, 0x32, 0x33, 0x33, 0x63, 0x36, 0x34, 0x66, 0x63, 0x33, 0x33, 0x66, 0x64, 0x37, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x34, 0x34, 0x30, 0x31, 0x61, 0x65, 0x39, 0x38, 0x66, 0x31, 0x32, 0x65, 0x66, 0x36, 0x64, 0x65, 0x33, 0x39, 0x61, 0x65, 0x32, 0x34, 0x63, 0x66, 0x39, 0x66, 0x63, 0x35, 0x31, 0x66, 0x38, 0x30, 0x65, 0x62, 0x61, 0x31, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x62, 0x38, 0x30, 0x37, 0x61, 0x66, 0x61, 0x33, 0x64, 0x64, 0x64, 0x36, 0x34, 0x37, 0x65, 0x37, 0x32, 0x33, 0x35, 0x34, 0x32, 0x65, 0x37, 0x62, 0x35, 0x32, 0x66, 0x65, 0x65, 0x33, 0x39, 0x35, 0x32, 0x37, 0x66, 0x33, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x62, 0x33, 0x36, 0x36, 0x65, 0x36, 0x65, 0x37, 0x64, 0x35, 0x61, 0x62, 0x62, 0x63, 0x65, 0x36, 0x62, 0x34, 0x34, 0x61, 0x34, 0x33, 0x38, 0x64, 0x36, 0x39, 0x61, 0x31, 0x63, 0x61, 0x62, 0x62, 0x39, 0x30, 0x64, 0x31, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x34, 0x66, 0x66, 0x65, 0x37, 0x38, 0x62, 0x62, 0x66, 0x35, 0x64, 0x32, 0x30, 0x64, 0x64, 0x31, 0x38, 0x61, 0x31, 0x66, 0x30, 0x31, 0x64, 0x61, 0x35, 0x35, 0x32, 0x65, 0x30, 0x30, 0x62, 0x37, 0x62, 0x31, 0x31, 0x64, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x35, 0x64, 0x34, 0x37, 0x61, 0x62, 0x30, 0x63, 0x39, 0x61, 0x61, 0x39, 0x38, 0x61, 0x35, 0x62, 0x64, 0x36, 0x32, 0x64, 0x31, 0x36, 0x32, 0x32, 0x33, 0x65, 0x61, 0x32, 0x34, 0x37, 0x31, 0x62, 0x31, 0x32, 0x31, 0x63, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x38, 0x37, 0x63, 0x33, 0x63, 0x34, 0x62, 0x65, 0x38, 0x36, 0x61, 0x32, 0x37, 0x32, 0x33, 0x64, 0x39, 0x31, 0x37, 0x63, 0x30, 0x36, 0x62, 0x34, 0x35, 0x38, 0x35, 0x35, 0x30, 0x31, 0x37, 0x30, 0x63, 0x33, 0x65, 0x64, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x34, 0x64, 0x30, 0x38, 0x61, 0x61, 0x32, 0x65, 0x34, 0x37, 0x34, 0x39, 0x36, 0x64, 0x63, 0x61, 0x38, 0x37, 0x32, 0x32, 0x35, 0x64, 0x65, 0x33, 0x33, 0x66, 0x32, 0x62, 0x34, 0x30, 0x61, 0x38, 0x61, 0x35, 0x62, 0x33, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x61, 0x38, 0x64, 0x65, 0x66, 0x65, 0x31, 0x31, 0x65, 0x33, 0x36, 0x31, 0x33, 0x66, 0x31, 0x31, 0x30, 0x36, 0x37, 0x66, 0x62, 0x39, 0x38, 0x33, 0x36, 0x32, 0x35, 0x61, 0x30, 0x38, 0x39, 0x39, 0x35, 0x61, 0x38, 0x64, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x62, 0x62, 0x36, 0x37, 0x63, 0x38, 0x62, 0x38, 0x64, 0x38, 0x62, 0x64, 0x30, 0x66, 0x36, 0x33, 0x63, 0x34, 0x37, 0x36, 0x30, 0x39, 0x30, 0x34, 0x66, 0x32, 0x64, 0x33, 0x33, 0x33, 0x66, 0x34, 0x30, 0x30, 0x61, 0x61, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x32, 0x37, 0x65, 0x31, 0x30, 0x61, 0x34, 0x64, 0x62, 0x66, 0x39, 0x63, 0x61, 0x63, 0x61, 0x33, 0x31, 0x62, 0x31, 0x37, 0x38, 0x30, 0x32, 0x33, 0x39, 0x66, 0x35, 0x35, 0x37, 0x36, 0x31, 0x35, 0x66, 0x63, 0x33, 0x35, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x61, 0x38, 0x39, 0x38, 0x39, 0x65, 0x33, 0x32, 0x33, 0x30, 0x38, 0x31, 0x32, 0x31, 0x66, 0x37, 0x32, 0x34, 0x36, 0x36, 0x39, 0x37, 0x38, 0x64, 0x62, 0x33, 0x39, 0x35, 0x64, 0x31, 0x66, 0x37, 0x36, 0x63, 0x33, 0x61, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x33, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x35, 0x36, 0x39, 0x61, 0x32, 0x31, 0x64, 0x32, 0x38, 0x66, 0x62, 0x61, 0x34, 0x62, 0x64, 0x61, 0x33, 0x37, 0x37, 0x35, 0x33, 0x34, 0x30, 0x35, 0x61, 0x30, 0x38, 0x31, 0x66, 0x32, 0x30, 0x36, 0x33, 0x64, 0x61, 0x31, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x37, 0x35, 0x36, 0x62, 0x63, 0x64, 0x63, 0x63, 0x37, 0x65, 0x65, 0x63, 0x37, 0x34, 0x65, 0x64, 0x38, 0x39, 0x36, 0x61, 0x64, 0x66, 0x63, 0x33, 0x33, 0x35, 0x32, 0x37, 0x35, 0x39, 0x33, 0x30, 0x32, 0x36, 0x36, 0x65, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x33, 0x61, 0x36, 0x31, 0x66, 0x30, 0x34, 0x36, 0x31, 0x62, 0x30, 0x30, 0x39, 0x33, 0x35, 0x65, 0x38, 0x35, 0x66, 0x61, 0x31, 0x65, 0x61, 0x64, 0x38, 0x32, 0x63, 0x34, 0x35, 0x65, 0x35, 0x61, 0x36, 0x34, 0x64, 0x34, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x32, 0x66, 0x33, 0x39, 0x36, 0x61, 0x32, 0x62, 0x35, 0x65, 0x62, 0x38, 0x33, 0x35, 0x35, 0x39, 0x62, 0x61, 0x63, 0x35, 0x31, 0x35, 0x65, 0x35, 0x32, 0x31, 0x30, 0x64, 0x66, 0x32, 0x63, 0x38, 0x63, 0x33, 0x36, 0x32, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x62, 0x63, 0x37, 0x64, 0x39, 0x61, 0x34, 0x61, 0x62, 0x64, 0x34, 0x34, 0x63, 0x38, 0x62, 0x62, 0x62, 0x38, 0x66, 0x65, 0x38, 0x62, 0x61, 0x38, 0x30, 0x34, 0x63, 0x36, 0x31, 0x61, 0x64, 0x38, 0x64, 0x36, 0x35, 0x37, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x39, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x30, 0x62, 0x62, 0x39, 0x66, 0x33, 0x39, 0x36, 0x36, 0x34, 0x31, 0x39, 0x65, 0x31, 0x34, 0x62, 0x62, 0x62, 0x61, 0x61, 0x61, 0x61, 0x36, 0x37, 0x38, 0x39, 0x65, 0x39, 0x32, 0x34, 0x39, 0x36, 0x63, 0x66, 0x61, 0x34, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x35, 0x31, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x65, 0x66, 0x34, 0x34, 0x32, 0x64, 0x32, 0x39, 0x31, 0x61, 0x34, 0x34, 0x37, 0x64, 0x37, 0x34, 0x63, 0x35, 0x64, 0x32, 0x35, 0x33, 0x63, 0x34, 0x39, 0x65, 0x66, 0x33, 0x32, 0x34, 0x65, 0x61, 0x63, 0x31, 0x64, 0x38, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x36, 0x63, 0x32, 0x61, 0x37, 0x33, 0x64, 0x61, 0x63, 0x37, 0x34, 0x32, 0x34, 0x61, 0x62, 0x30, 0x64, 0x30, 0x33, 0x31, 0x62, 0x36, 0x36, 0x37, 0x36, 0x31, 0x31, 0x32, 0x32, 0x35, 0x36, 0x36, 0x63, 0x30, 0x31, 0x30, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x34, 0x64, 0x32, 0x34, 0x33, 0x63, 0x32, 0x39, 0x37, 0x38, 0x65, 0x34, 0x36, 0x63, 0x32, 0x63, 0x38, 0x36, 0x61, 0x64, 0x62, 0x65, 0x63, 0x64, 0x32, 0x34, 0x36, 0x65, 0x33, 0x62, 0x32, 0x39, 0x35, 0x66, 0x66, 0x36, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x66, 0x66, 0x36, 0x37, 0x32, 0x30, 0x31, 0x36, 0x66, 0x36, 0x33, 0x62, 0x32, 0x66, 0x38, 0x35, 0x33, 0x39, 0x38, 0x66, 0x34, 0x61, 0x36, 0x66, 0x65, 0x64, 0x62, 0x62, 0x36, 0x30, 0x61, 0x35, 0x30, 0x64, 0x33, 0x63, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x30, 0x35, 0x31, 0x63, 0x62, 0x33, 0x63, 0x62, 0x36, 0x37, 0x30, 0x34, 0x66, 0x30, 0x35, 0x34, 0x38, 0x63, 0x63, 0x38, 0x39, 0x30, 0x61, 0x62, 0x30, 0x61, 0x31, 0x39, 0x64, 0x62, 0x33, 0x34, 0x31, 0x35, 0x62, 0x34, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x31, 0x31, 0x65, 0x35, 0x64, 0x62, 0x66, 0x34, 0x35, 0x65, 0x36, 0x66, 0x39, 0x30, 0x36, 0x64, 0x36, 0x32, 0x38, 0x36, 0x36, 0x66, 0x31, 0x37, 0x30, 0x38, 0x31, 0x30, 0x31, 0x37, 0x38, 0x38, 0x64, 0x64, 0x64, 0x35, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x36, 0x38, 0x36, 0x62, 0x66, 0x32, 0x32, 0x30, 0x62, 0x35, 0x39, 0x33, 0x64, 0x65, 0x62, 0x39, 0x62, 0x37, 0x33, 0x32, 0x34, 0x36, 0x31, 0x35, 0x66, 0x62, 0x39, 0x31, 0x34, 0x34, 0x64, 0x65, 0x64, 0x33, 0x66, 0x33, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x31, 0x66, 0x65, 0x65, 0x61, 0x36, 0x31, 0x66, 0x65, 0x30, 0x65, 0x64, 0x35, 0x30, 0x63, 0x35, 0x62, 0x39, 0x65, 0x35, 0x61, 0x30, 0x64, 0x36, 0x36, 0x30, 0x37, 0x31, 0x33, 0x39, 0x39, 0x64, 0x32, 0x38, 0x62, 0x64, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x38, 0x31, 0x64, 0x65, 0x66, 0x61, 0x65, 0x31, 0x63, 0x30, 0x37, 0x62, 0x33, 0x63, 0x65, 0x30, 0x34, 0x63, 0x37, 0x38, 0x61, 0x62, 0x65, 0x32, 0x36, 0x62, 0x30, 0x63, 0x64, 0x63, 0x38, 0x64, 0x37, 0x33, 0x66, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x39, 0x34, 0x66, 0x33, 0x32, 0x38, 0x30, 0x38, 0x61, 0x32, 0x65, 0x66, 0x38, 0x61, 0x39, 0x62, 0x66, 0x30, 0x38, 0x36, 0x31, 0x64, 0x31, 0x64, 0x32, 0x34, 0x30, 0x34, 0x66, 0x37, 0x62, 0x37, 0x62, 0x65, 0x32, 0x35, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x65, 0x66, 0x36, 0x62, 0x31, 0x34, 0x31, 0x37, 0x64, 0x37, 0x62, 0x31, 0x30, 0x65, 0x63, 0x66, 0x63, 0x31, 0x39, 0x62, 0x31, 0x32, 0x33, 0x61, 0x38, 0x61, 0x38, 0x39, 0x65, 0x37, 0x33, 0x65, 0x35, 0x32, 0x36, 0x63, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x38, 0x61, 0x66, 0x39, 0x65, 0x37, 0x37, 0x36, 0x35, 0x32, 0x32, 0x33, 0x66, 0x34, 0x34, 0x34, 0x36, 0x66, 0x34, 0x34, 0x64, 0x33, 0x64, 0x35, 0x30, 0x39, 0x38, 0x31, 0x39, 0x61, 0x33, 0x64, 0x33, 0x64, 0x62, 0x34, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x66, 0x63, 0x34, 0x63, 0x36, 0x34, 0x37, 0x64, 0x61, 0x63, 0x36, 0x61, 0x63, 0x61, 0x63, 0x33, 0x35, 0x35, 0x37, 0x37, 0x61, 0x64, 0x32, 0x32, 0x31, 0x37, 0x35, 0x38, 0x66, 0x65, 0x66, 0x36, 0x36, 0x31, 0x36, 0x66, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x34, 0x37, 0x62, 0x39, 0x62, 0x66, 0x37, 0x61, 0x64, 0x36, 0x36, 0x32, 0x37, 0x34, 0x66, 0x33, 0x34, 0x31, 0x33, 0x38, 0x32, 0x37, 0x32, 0x33, 0x31, 0x62, 0x61, 0x34, 0x30, 0x35, 0x65, 0x65, 0x38, 0x63, 0x38, 0x38, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x30, 0x61, 0x34, 0x30, 0x63, 0x65, 0x66, 0x33, 0x32, 0x30, 0x32, 0x33, 0x39, 0x37, 0x66, 0x32, 0x34, 0x30, 0x34, 0x36, 0x39, 0x35, 0x34, 0x38, 0x62, 0x65, 0x62, 0x35, 0x36, 0x32, 0x36, 0x61, 0x66, 0x34, 0x66, 0x32, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x37, 0x35, 0x62, 0x65, 0x33, 0x31, 0x39, 0x34, 0x65, 0x36, 0x36, 0x39, 0x34, 0x32, 0x32, 0x64, 0x31, 0x35, 0x66, 0x65, 0x65, 0x38, 0x31, 0x65, 0x62, 0x39, 0x66, 0x32, 0x63, 0x35, 0x36, 0x63, 0x36, 0x37, 0x64, 0x39, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x65, 0x30, 0x32, 0x36, 0x30, 0x38, 0x30, 0x36, 0x36, 0x38, 0x32, 0x38, 0x38, 0x34, 0x38, 0x61, 0x65, 0x62, 0x32, 0x38, 0x63, 0x37, 0x33, 0x36, 0x37, 0x32, 0x61, 0x31, 0x32, 0x39, 0x32, 0x35, 0x31, 0x38, 0x31, 0x66, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x32, 0x39, 0x63, 0x65, 0x62, 0x39, 0x66, 0x30, 0x64, 0x37, 0x30, 0x38, 0x33, 0x39, 0x34, 0x39, 0x38, 0x64, 0x34, 0x34, 0x65, 0x36, 0x61, 0x62, 0x65, 0x64, 0x39, 0x33, 0x63, 0x35, 0x63, 0x61, 0x30, 0x35, 0x39, 0x66, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x66, 0x31, 0x39, 0x38, 0x33, 0x33, 0x31, 0x65, 0x34, 0x62, 0x32, 0x31, 0x63, 0x31, 0x62, 0x37, 0x36, 0x30, 0x61, 0x33, 0x31, 0x35, 0x35, 0x66, 0x34, 0x61, 0x62, 0x32, 0x66, 0x65, 0x30, 0x30, 0x61, 0x37, 0x34, 0x36, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x66, 0x63, 0x62, 0x38, 0x37, 0x30, 0x64, 0x34, 0x30, 0x32, 0x33, 0x64, 0x32, 0x35, 0x35, 0x64, 0x35, 0x31, 0x36, 0x37, 0x64, 0x38, 0x61, 0x35, 0x30, 0x37, 0x63, 0x65, 0x66, 0x63, 0x33, 0x36, 0x36, 0x62, 0x36, 0x38, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x64, 0x61, 0x65, 0x32, 0x37, 0x62, 0x33, 0x35, 0x30, 0x62, 0x61, 0x65, 0x32, 0x30, 0x63, 0x35, 0x36, 0x35, 0x32, 0x31, 0x32, 0x34, 0x61, 0x66, 0x35, 0x64, 0x38, 0x62, 0x35, 0x63, 0x62, 0x61, 0x30, 0x30, 0x31, 0x65, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x35, 0x35, 0x30, 0x30, 0x38, 0x32, 0x35, 0x31, 0x30, 0x35, 0x63, 0x66, 0x37, 0x31, 0x32, 0x61, 0x33, 0x31, 0x38, 0x61, 0x35, 0x65, 0x39, 0x63, 0x33, 0x62, 0x66, 0x63, 0x36, 0x39, 0x63, 0x38, 0x39, 0x64, 0x30, 0x63, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x64, 0x38, 0x62, 0x62, 0x33, 0x66, 0x30, 0x36, 0x37, 0x37, 0x38, 0x62, 0x30, 0x33, 0x39, 0x65, 0x39, 0x39, 0x36, 0x31, 0x64, 0x38, 0x31, 0x63, 0x62, 0x37, 0x31, 0x61, 0x37, 0x33, 0x65, 0x36, 0x37, 0x38, 0x37, 0x63, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x30, 0x66, 0x66, 0x61, 0x63, 0x33, 0x62, 0x63, 0x33, 0x34, 0x31, 0x32, 0x65, 0x32, 0x65, 0x63, 0x30, 0x65, 0x61, 0x34, 0x37, 0x62, 0x37, 0x39, 0x38, 0x31, 0x63, 0x37, 0x37, 0x30, 0x66, 0x35, 0x62, 0x62, 0x32, 0x66, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x33, 0x34, 0x34, 0x62, 0x30, 0x31, 0x63, 0x37, 0x31, 0x39, 0x31, 0x61, 0x33, 0x32, 0x64, 0x30, 0x37, 0x36, 0x32, 0x61, 0x63, 0x31, 0x38, 0x38, 0x66, 0x30, 0x65, 0x63, 0x32, 0x64, 0x64, 0x34, 0x36, 0x30, 0x39, 0x31, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x66, 0x61, 0x39, 0x38, 0x37, 0x37, 0x66, 0x37, 0x31, 0x39, 0x63, 0x37, 0x39, 0x64, 0x39, 0x65, 0x34, 0x39, 0x34, 0x61, 0x30, 0x38, 0x64, 0x31, 0x65, 0x34, 0x31, 0x63, 0x66, 0x31, 0x30, 0x33, 0x66, 0x63, 0x38, 0x37, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x65, 0x61, 0x61, 0x63, 0x37, 0x30, 0x33, 0x32, 0x64, 0x34, 0x39, 0x32, 0x65, 0x66, 0x31, 0x37, 0x66, 0x64, 0x36, 0x30, 0x39, 0x35, 0x61, 0x66, 0x63, 0x31, 0x31, 0x64, 0x36, 0x33, 0x34, 0x66, 0x35, 0x36, 0x62, 0x33, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x32, 0x63, 0x30, 0x64, 0x65, 0x63, 0x38, 0x61, 0x33, 0x64, 0x34, 0x36, 0x34, 0x62, 0x66, 0x33, 0x39, 0x62, 0x31, 0x32, 0x31, 0x35, 0x65, 0x61, 0x66, 0x64, 0x32, 0x36, 0x34, 0x38, 0x30, 0x61, 0x65, 0x34, 0x39, 0x30, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x31, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x32, 0x61, 0x38, 0x62, 0x66, 0x64, 0x37, 0x64, 0x39, 0x64, 0x63, 0x35, 0x64, 0x64, 0x33, 0x61, 0x64, 0x37, 0x38, 0x31, 0x36, 0x31, 0x62, 0x36, 0x62, 0x62, 0x35, 0x36, 0x30, 0x38, 0x32, 0x34, 0x33, 0x37, 0x33, 0x36, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x34, 0x38, 0x32, 0x34, 0x66, 0x66, 0x39, 0x66, 0x62, 0x32, 0x61, 0x62, 0x64, 0x61, 0x35, 0x35, 0x34, 0x64, 0x65, 0x65, 0x34, 0x66, 0x62, 0x38, 0x63, 0x66, 0x35, 0x34, 0x39, 0x31, 0x36, 0x35, 0x35, 0x37, 0x30, 0x36, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x33, 0x62, 0x39, 0x30, 0x30, 0x35, 0x66, 0x34, 0x36, 0x66, 0x64, 0x32, 0x63, 0x61, 0x33, 0x62, 0x33, 0x30, 0x31, 0x36, 0x32, 0x35, 0x39, 0x39, 0x39, 0x32, 0x38, 0x63, 0x37, 0x37, 0x64, 0x39, 0x66, 0x36, 0x62, 0x36, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x64, 0x63, 0x32, 0x35, 0x31, 0x31, 0x39, 0x36, 0x66, 0x62, 0x63, 0x62, 0x62, 0x37, 0x37, 0x63, 0x39, 0x34, 0x37, 0x64, 0x37, 0x63, 0x31, 0x39, 0x34, 0x36, 0x62, 0x30, 0x66, 0x66, 0x36, 0x35, 0x30, 0x32, 0x31, 0x63, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x31, 0x31, 0x34, 0x38, 0x65, 0x66, 0x36, 0x63, 0x38, 0x65, 0x31, 0x30, 0x33, 0x64, 0x37, 0x35, 0x33, 0x30, 0x65, 0x66, 0x63, 0x39, 0x31, 0x36, 0x37, 0x39, 0x63, 0x39, 0x61, 0x63, 0x32, 0x37, 0x30, 0x30, 0x30, 0x39, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x62, 0x32, 0x36, 0x35, 0x30, 0x65, 0x61, 0x30, 0x31, 0x61, 0x63, 0x61, 0x37, 0x35, 0x35, 0x62, 0x63, 0x30, 0x63, 0x30, 0x31, 0x37, 0x62, 0x36, 0x34, 0x62, 0x31, 0x61, 0x62, 0x35, 0x61, 0x36, 0x36, 0x64, 0x38, 0x32, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x64, 0x61, 0x31, 0x32, 0x62, 0x66, 0x37, 0x32, 0x64, 0x34, 0x36, 0x31, 0x62, 0x62, 0x63, 0x34, 0x37, 0x39, 0x65, 0x62, 0x39, 0x32, 0x65, 0x36, 0x34, 0x39, 0x31, 0x64, 0x30, 0x35, 0x37, 0x65, 0x36, 0x62, 0x35, 0x61, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x35, 0x62, 0x37, 0x37, 0x66, 0x39, 0x30, 0x36, 0x36, 0x31, 0x35, 0x39, 0x65, 0x36, 0x31, 0x35, 0x39, 0x33, 0x33, 0x66, 0x32, 0x64, 0x64, 0x61, 0x37, 0x34, 0x37, 0x37, 0x66, 0x61, 0x34, 0x65, 0x34, 0x37, 0x64, 0x36, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x31, 0x31, 0x36, 0x31, 0x62, 0x30, 0x65, 0x34, 0x33, 0x63, 0x33, 0x30, 0x32, 0x30, 0x36, 0x36, 0x65, 0x38, 0x61, 0x36, 0x38, 0x64, 0x32, 0x63, 0x65, 0x37, 0x65, 0x31, 0x39, 0x39, 0x65, 0x63, 0x64, 0x62, 0x31, 0x64, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x65, 0x33, 0x33, 0x30, 0x63, 0x64, 0x30, 0x63, 0x38, 0x39, 0x30, 0x61, 0x63, 0x39, 0x39, 0x66, 0x65, 0x37, 0x37, 0x31, 0x66, 0x63, 0x63, 0x37, 0x65, 0x37, 0x62, 0x30, 0x30, 0x39, 0x62, 0x37, 0x34, 0x31, 0x33, 0x64, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x62, 0x33, 0x38, 0x61, 0x35, 0x66, 0x64, 0x62, 0x36, 0x33, 0x65, 0x30, 0x31, 0x37, 0x31, 0x34, 0x65, 0x39, 0x38, 0x30, 0x31, 0x64, 0x62, 0x34, 0x37, 0x62, 0x63, 0x39, 0x39, 0x30, 0x62, 0x64, 0x35, 0x30, 0x39, 0x31, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x30, 0x66, 0x39, 0x38, 0x35, 0x39, 0x38, 0x66, 0x38, 0x38, 0x30, 0x35, 0x36, 0x61, 0x32, 0x36, 0x33, 0x33, 0x39, 0x36, 0x32, 0x30, 0x39, 0x32, 0x33, 0x62, 0x38, 0x66, 0x31, 0x65, 0x62, 0x30, 0x37, 0x34, 0x61, 0x39, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x63, 0x35, 0x39, 0x65, 0x64, 0x38, 0x38, 0x39, 0x37, 0x33, 0x64, 0x65, 0x61, 0x64, 0x33, 0x31, 0x30, 0x38, 0x38, 0x34, 0x32, 0x32, 0x33, 0x61, 0x66, 0x34, 0x39, 0x37, 0x36, 0x33, 0x63, 0x30, 0x35, 0x30, 0x33, 0x30, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x38, 0x35, 0x65, 0x34, 0x32, 0x62, 0x31, 0x64, 0x66, 0x33, 0x32, 0x31, 0x61, 0x34, 0x62, 0x33, 0x65, 0x38, 0x33, 0x35, 0x62, 0x35, 0x30, 0x63, 0x30, 0x30, 0x62, 0x30, 0x36, 0x31, 0x37, 0x33, 0x39, 0x36, 0x38, 0x34, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x37, 0x38, 0x38, 0x65, 0x66, 0x32, 0x38, 0x36, 0x35, 0x38, 0x61, 0x61, 0x30, 0x36, 0x63, 0x63, 0x35, 0x33, 0x65, 0x31, 0x66, 0x33, 0x66, 0x30, 0x64, 0x65, 0x35, 0x38, 0x65, 0x35, 0x63, 0x33, 0x37, 0x31, 0x62, 0x65, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x64, 0x32, 0x37, 0x36, 0x61, 0x66, 0x36, 0x34, 0x63, 0x37, 0x39, 0x64, 0x31, 0x62, 0x64, 0x39, 0x61, 0x39, 0x32, 0x62, 0x38, 0x36, 0x62, 0x35, 0x65, 0x38, 0x38, 0x64, 0x39, 0x61, 0x39, 0x35, 0x65, 0x62, 0x38, 0x38, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x63, 0x39, 0x65, 0x31, 0x61, 0x65, 0x65, 0x32, 0x64, 0x33, 0x33, 0x36, 0x35, 0x64, 0x35, 0x33, 0x62, 0x63, 0x66, 0x64, 0x63, 0x64, 0x39, 0x36, 0x63, 0x37, 0x63, 0x35, 0x33, 0x38, 0x62, 0x30, 0x66, 0x64, 0x37, 0x65, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x33, 0x39, 0x65, 0x66, 0x39, 0x65, 0x61, 0x36, 0x62, 0x64, 0x66, 0x66, 0x66, 0x31, 0x35, 0x64, 0x31, 0x31, 0x66, 0x65, 0x39, 0x31, 0x66, 0x35, 0x36, 0x31, 0x61, 0x36, 0x66, 0x39, 0x65, 0x33, 0x31, 0x66, 0x35, 0x64, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x38, 0x37, 0x38, 0x66, 0x39, 0x64, 0x36, 0x65, 0x30, 0x61, 0x37, 0x65, 0x64, 0x39, 0x61, 0x65, 0x63, 0x37, 0x38, 0x32, 0x39, 0x37, 0x62, 0x37, 0x33, 0x38, 0x37, 0x39, 0x61, 0x38, 0x30, 0x31, 0x39, 0x35, 0x61, 0x66, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x39, 0x34, 0x63, 0x39, 0x31, 0x38, 0x62, 0x31, 0x61, 0x65, 0x66, 0x62, 0x34, 0x64, 0x32, 0x35, 0x39, 0x32, 0x37, 0x65, 0x66, 0x39, 0x64, 0x37, 0x39, 0x39, 0x65, 0x37, 0x31, 0x66, 0x39, 0x33, 0x61, 0x32, 0x38, 0x65, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x33, 0x66, 0x37, 0x30, 0x64, 0x61, 0x37, 0x32, 0x37, 0x35, 0x65, 0x66, 0x30, 0x35, 0x37, 0x31, 0x30, 0x34, 0x64, 0x66, 0x61, 0x37, 0x64, 0x62, 0x36, 0x34, 0x66, 0x34, 0x37, 0x32, 0x65, 0x39, 0x66, 0x35, 0x64, 0x35, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x35, 0x62, 0x64, 0x64, 0x36, 0x34, 0x37, 0x34, 0x63, 0x63, 0x38, 0x32, 0x36, 0x32, 0x66, 0x32, 0x36, 0x61, 0x32, 0x32, 0x63, 0x33, 0x38, 0x66, 0x34, 0x35, 0x39, 0x34, 0x30, 0x65, 0x31, 0x63, 0x65, 0x65, 0x61, 0x36, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x66, 0x38, 0x62, 0x35, 0x30, 0x39, 0x66, 0x65, 0x65, 0x31, 0x61, 0x38, 0x37, 0x34, 0x61, 0x62, 0x36, 0x66, 0x39, 0x64, 0x38, 0x37, 0x33, 0x36, 0x37, 0x66, 0x62, 0x65, 0x61, 0x66, 0x31, 0x35, 0x61, 0x63, 0x31, 0x33, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x37, 0x32, 0x38, 0x61, 0x33, 0x65, 0x38, 0x63, 0x32, 0x61, 0x61, 0x61, 0x63, 0x39, 0x38, 0x33, 0x64, 0x30, 0x35, 0x64, 0x63, 0x36, 0x38, 0x37, 0x37, 0x33, 0x37, 0x34, 0x61, 0x38, 0x66, 0x34, 0x34, 0x36, 0x65, 0x65, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x30, 0x32, 0x30, 0x36, 0x63, 0x62, 0x32, 0x33, 0x33, 0x31, 0x35, 0x31, 0x32, 0x38, 0x66, 0x38, 0x63, 0x61, 0x66, 0x66, 0x32, 0x36, 0x66, 0x36, 0x61, 0x33, 0x30, 0x62, 0x39, 0x38, 0x35, 0x34, 0x36, 0x37, 0x64, 0x30, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x63, 0x66, 0x33, 0x36, 0x61, 0x64, 0x30, 0x33, 0x63, 0x39, 0x65, 0x61, 0x65, 0x39, 0x30, 0x35, 0x33, 0x61, 0x62, 0x62, 0x35, 0x32, 0x34, 0x32, 0x64, 0x65, 0x39, 0x31, 0x31, 0x37, 0x62, 0x62, 0x30, 0x66, 0x32, 0x61, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x32, 0x39, 0x63, 0x38, 0x62, 0x64, 0x37, 0x31, 0x64, 0x62, 0x30, 0x63, 0x33, 0x30, 0x38, 0x64, 0x61, 0x63, 0x30, 0x36, 0x30, 0x38, 0x30, 0x61, 0x31, 0x37, 0x34, 0x37, 0x66, 0x32, 0x31, 0x62, 0x31, 0x34, 0x36, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x61, 0x36, 0x65, 0x30, 0x37, 0x35, 0x39, 0x38, 0x39, 0x63, 0x37, 0x34, 0x31, 0x39, 0x30, 0x39, 0x34, 0x63, 0x63, 0x39, 0x66, 0x36, 0x64, 0x32, 0x65, 0x34, 0x39, 0x33, 0x39, 0x33, 0x62, 0x62, 0x31, 0x39, 0x39, 0x36, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x33, 0x65, 0x65, 0x63, 0x65, 0x30, 0x62, 0x30, 0x38, 0x61, 0x63, 0x38, 0x39, 0x65, 0x33, 0x32, 0x62, 0x66, 0x61, 0x34, 0x62, 0x65, 0x63, 0x65, 0x37, 0x36, 0x39, 0x35, 0x31, 0x34, 0x64, 0x38, 0x63, 0x62, 0x35, 0x62, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x66, 0x33, 0x32, 0x37, 0x37, 0x63, 0x61, 0x38, 0x35, 0x39, 0x33, 0x36, 0x63, 0x37, 0x61, 0x30, 0x64, 0x32, 0x63, 0x30, 0x37, 0x39, 0x35, 0x36, 0x30, 0x35, 0x61, 0x64, 0x32, 0x35, 0x30, 0x39, 0x35, 0x65, 0x37, 0x31, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x36, 0x33, 0x37, 0x35, 0x38, 0x63, 0x62, 0x62, 0x36, 0x63, 0x34, 0x63, 0x35, 0x32, 0x35, 0x65, 0x30, 0x34, 0x31, 0x34, 0x61, 0x34, 0x30, 0x61, 0x30, 0x34, 0x39, 0x64, 0x63, 0x63, 0x63, 0x63, 0x65, 0x39, 0x31, 0x39, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x63, 0x64, 0x64, 0x64, 0x62, 0x63, 0x38, 0x62, 0x30, 0x39, 0x65, 0x36, 0x36, 0x37, 0x35, 0x61, 0x39, 0x65, 0x39, 0x65, 0x30, 0x35, 0x30, 0x39, 0x31, 0x63, 0x62, 0x39, 0x32, 0x32, 0x33, 0x38, 0x63, 0x33, 0x39, 0x65, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x62, 0x37, 0x66, 0x34, 0x39, 0x33, 0x62, 0x34, 0x34, 0x61, 0x32, 0x63, 0x38, 0x64, 0x38, 0x30, 0x65, 0x63, 0x37, 0x38, 0x62, 0x31, 0x63, 0x64, 0x63, 0x37, 0x35, 0x61, 0x36, 0x35, 0x32, 0x62, 0x37, 0x33, 0x62, 0x30, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x39, 0x62, 0x38, 0x35, 0x35, 0x35, 0x33, 0x39, 0x63, 0x65, 0x31, 0x62, 0x30, 0x34, 0x37, 0x31, 0x34, 0x37, 0x32, 0x38, 0x65, 0x65, 0x63, 0x32, 0x35, 0x61, 0x33, 0x37, 0x66, 0x33, 0x36, 0x37, 0x39, 0x35, 0x31, 0x64, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x32, 0x65, 0x61, 0x62, 0x31, 0x66, 0x36, 0x31, 0x62, 0x36, 0x64, 0x34, 0x35, 0x35, 0x31, 0x37, 0x32, 0x38, 0x33, 0x66, 0x34, 0x31, 0x64, 0x31, 0x34, 0x34, 0x31, 0x38, 0x32, 0x34, 0x38, 0x37, 0x38, 0x37, 0x34, 0x39, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x35, 0x36, 0x35, 0x31, 0x64, 0x36, 0x64, 0x62, 0x34, 0x66, 0x61, 0x66, 0x39, 0x65, 0x63, 0x64, 0x31, 0x30, 0x33, 0x61, 0x39, 0x32, 0x31, 0x62, 0x62, 0x62, 0x62, 0x65, 0x36, 0x61, 0x65, 0x39, 0x37, 0x30, 0x66, 0x64, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x61, 0x66, 0x66, 0x39, 0x31, 0x39, 0x32, 0x39, 0x37, 0x39, 0x37, 0x34, 0x38, 0x39, 0x35, 0x35, 0x35, 0x61, 0x32, 0x66, 0x66, 0x31, 0x64, 0x31, 0x34, 0x64, 0x35, 0x63, 0x36, 0x39, 0x35, 0x61, 0x31, 0x30, 0x38, 0x33, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x63, 0x61, 0x37, 0x66, 0x64, 0x63, 0x66, 0x65, 0x62, 0x65, 0x34, 0x35, 0x38, 0x38, 0x65, 0x66, 0x66, 0x35, 0x34, 0x32, 0x31, 0x64, 0x31, 0x35, 0x32, 0x32, 0x62, 0x36, 0x31, 0x33, 0x32, 0x38, 0x64, 0x66, 0x37, 0x62, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x31, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x66, 0x62, 0x61, 0x31, 0x32, 0x64, 0x66, 0x63, 0x39, 0x39, 0x36, 0x37, 0x34, 0x32, 0x64, 0x62, 0x37, 0x39, 0x30, 0x34, 0x36, 0x34, 0x63, 0x61, 0x37, 0x64, 0x32, 0x37, 0x33, 0x62, 0x65, 0x36, 0x65, 0x38, 0x31, 0x62, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x61, 0x61, 0x32, 0x31, 0x36, 0x64, 0x65, 0x39, 0x63, 0x63, 0x35, 0x61, 0x34, 0x33, 0x30, 0x33, 0x31, 0x37, 0x30, 0x37, 0x64, 0x33, 0x36, 0x66, 0x65, 0x36, 0x64, 0x35, 0x62, 0x65, 0x64, 0x63, 0x30, 0x35, 0x62, 0x64, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x39, 0x31, 0x39, 0x34, 0x33, 0x30, 0x34, 0x66, 0x31, 0x34, 0x62, 0x31, 0x62, 0x39, 0x33, 0x61, 0x66, 0x65, 0x34, 0x34, 0x34, 0x66, 0x30, 0x36, 0x32, 0x34, 0x65, 0x30, 0x35, 0x33, 0x63, 0x32, 0x33, 0x61, 0x30, 0x30, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x63, 0x63, 0x31, 0x39, 0x39, 0x34, 0x38, 0x64, 0x64, 0x39, 0x63, 0x64, 0x38, 0x37, 0x62, 0x34, 0x63, 0x37, 0x32, 0x30, 0x31, 0x61, 0x62, 0x34, 0x38, 0x65, 0x37, 0x35, 0x38, 0x66, 0x32, 0x38, 0x65, 0x37, 0x63, 0x63, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x32, 0x34, 0x65, 0x62, 0x39, 0x30, 0x30, 0x62, 0x33, 0x37, 0x62, 0x34, 0x34, 0x39, 0x30, 0x65, 0x65, 0x65, 0x36, 0x61, 0x30, 0x62, 0x36, 0x34, 0x32, 0x30, 0x64, 0x38, 0x35, 0x63, 0x39, 0x34, 0x37, 0x64, 0x38, 0x37, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x38, 0x31, 0x30, 0x62, 0x61, 0x66, 0x63, 0x33, 0x37, 0x65, 0x38, 0x34, 0x33, 0x30, 0x36, 0x33, 0x33, 0x32, 0x61, 0x61, 0x63, 0x62, 0x33, 0x35, 0x65, 0x39, 0x32, 0x61, 0x64, 0x39, 0x31, 0x31, 0x64, 0x32, 0x33, 0x64, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x36, 0x37, 0x64, 0x32, 0x65, 0x32, 0x66, 0x38, 0x32, 0x64, 0x61, 0x38, 0x38, 0x36, 0x31, 0x33, 0x34, 0x31, 0x62, 0x63, 0x39, 0x36, 0x61, 0x32, 0x63, 0x30, 0x37, 0x39, 0x31, 0x66, 0x64, 0x64, 0x66, 0x33, 0x39, 0x65, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x36, 0x34, 0x39, 0x35, 0x38, 0x39, 0x31, 0x32, 0x34, 0x30, 0x65, 0x36, 0x34, 0x65, 0x35, 0x39, 0x34, 0x34, 0x39, 0x33, 0x63, 0x32, 0x36, 0x36, 0x32, 0x31, 0x37, 0x31, 0x64, 0x62, 0x35, 0x65, 0x33, 0x30, 0x63, 0x65, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x62, 0x64, 0x64, 0x34, 0x30, 0x31, 0x33, 0x61, 0x61, 0x33, 0x31, 0x63, 0x30, 0x34, 0x36, 0x31, 0x36, 0x63, 0x32, 0x62, 0x63, 0x39, 0x37, 0x38, 0x35, 0x66, 0x32, 0x37, 0x38, 0x38, 0x66, 0x39, 0x31, 0x35, 0x36, 0x37, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x61, 0x65, 0x32, 0x38, 0x37, 0x64, 0x64, 0x62, 0x65, 0x31, 0x31, 0x34, 0x39, 0x62, 0x61, 0x31, 0x36, 0x64, 0x64, 0x63, 0x63, 0x61, 0x34, 0x66, 0x65, 0x30, 0x36, 0x61, 0x61, 0x32, 0x65, 0x61, 0x61, 0x39, 0x38, 0x38, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x63, 0x39, 0x66, 0x31, 0x32, 0x62, 0x30, 0x33, 0x38, 0x65, 0x37, 0x33, 0x34, 0x33, 0x36, 0x64, 0x31, 0x37, 0x65, 0x31, 0x63, 0x31, 0x32, 0x66, 0x66, 0x65, 0x31, 0x61, 0x65, 0x63, 0x63, 0x64, 0x62, 0x33, 0x66, 0x35, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x62, 0x35, 0x30, 0x30, 0x30, 0x31, 0x31, 0x63, 0x66, 0x62, 0x61, 0x39, 0x35, 0x64, 0x37, 0x63, 0x64, 0x36, 0x33, 0x36, 0x65, 0x39, 0x35, 0x65, 0x36, 0x63, 0x62, 0x66, 0x36, 0x31, 0x36, 0x37, 0x34, 0x36, 0x34, 0x62, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x65, 0x30, 0x64, 0x62, 0x34, 0x64, 0x36, 0x30, 0x35, 0x36, 0x38, 0x63, 0x38, 0x30, 0x30, 0x62, 0x38, 0x63, 0x35, 0x35, 0x30, 0x30, 0x30, 0x32, 0x36, 0x63, 0x32, 0x35, 0x39, 0x34, 0x66, 0x35, 0x37, 0x36, 0x38, 0x39, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x65, 0x33, 0x63, 0x32, 0x38, 0x33, 0x66, 0x37, 0x65, 0x32, 0x34, 0x64, 0x65, 0x30, 0x34, 0x31, 0x30, 0x63, 0x31, 0x32, 0x31, 0x62, 0x65, 0x65, 0x36, 0x30, 0x61, 0x35, 0x36, 0x30, 0x37, 0x66, 0x33, 0x65, 0x32, 0x39, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x37, 0x64, 0x33, 0x32, 0x39, 0x30, 0x38, 0x35, 0x31, 0x62, 0x65, 0x35, 0x63, 0x36, 0x62, 0x34, 0x62, 0x34, 0x33, 0x66, 0x37, 0x64, 0x34, 0x35, 0x37, 0x34, 0x33, 0x32, 0x39, 0x66, 0x36, 0x31, 0x61, 0x37, 0x39, 0x32, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x33, 0x65, 0x63, 0x65, 0x39, 0x33, 0x35, 0x61, 0x38, 0x66, 0x34, 0x65, 0x66, 0x39, 0x33, 0x38, 0x65, 0x61, 0x37, 0x65, 0x31, 0x62, 0x61, 0x63, 0x38, 0x37, 0x63, 0x62, 0x39, 0x32, 0x35, 0x64, 0x38, 0x34, 0x39, 0x30, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x31, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x62, 0x64, 0x64, 0x66, 0x30, 0x37, 0x38, 0x38, 0x33, 0x34, 0x30, 0x30, 0x39, 0x63, 0x38, 0x39, 0x64, 0x38, 0x38, 0x65, 0x36, 0x32, 0x38, 0x32, 0x37, 0x35, 0x39, 0x64, 0x63, 0x34, 0x35, 0x33, 0x33, 0x35, 0x62, 0x34, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x61, 0x64, 0x31, 0x38, 0x37, 0x61, 0x62, 0x32, 0x31, 0x31, 0x36, 0x37, 0x63, 0x32, 0x62, 0x36, 0x65, 0x37, 0x38, 0x62, 0x65, 0x30, 0x31, 0x35, 0x33, 0x66, 0x34, 0x34, 0x35, 0x30, 0x34, 0x61, 0x30, 0x37, 0x39, 0x34, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x64, 0x32, 0x34, 0x61, 0x61, 0x63, 0x33, 0x36, 0x31, 0x32, 0x62, 0x32, 0x30, 0x63, 0x36, 0x30, 0x39, 0x65, 0x62, 0x34, 0x36, 0x37, 0x37, 0x39, 0x62, 0x66, 0x39, 0x35, 0x36, 0x39, 0x38, 0x34, 0x30, 0x37, 0x63, 0x35, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x35, 0x32, 0x36, 0x63, 0x39, 0x65, 0x64, 0x66, 0x39, 0x34, 0x33, 0x65, 0x66, 0x61, 0x34, 0x66, 0x36, 0x64, 0x30, 0x66, 0x30, 0x62, 0x61, 0x65, 0x38, 0x31, 0x65, 0x31, 0x38, 0x62, 0x33, 0x31, 0x63, 0x35, 0x34, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x36, 0x61, 0x39, 0x64, 0x63, 0x32, 0x63, 0x61, 0x62, 0x31, 0x30, 0x61, 0x62, 0x62, 0x32, 0x65, 0x37, 0x63, 0x31, 0x33, 0x37, 0x30, 0x30, 0x36, 0x66, 0x30, 0x38, 0x66, 0x65, 0x63, 0x62, 0x35, 0x62, 0x37, 0x37, 0x39, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x63, 0x39, 0x66, 0x37, 0x39, 0x34, 0x30, 0x61, 0x37, 0x62, 0x38, 0x62, 0x37, 0x61, 0x34, 0x31, 0x30, 0x62, 0x66, 0x38, 0x33, 0x64, 0x63, 0x39, 0x63, 0x32, 0x32, 0x33, 0x33, 0x33, 0x64, 0x34, 0x32, 0x37, 0x35, 0x64, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x66, 0x64, 0x33, 0x38, 0x33, 0x33, 0x65, 0x38, 0x38, 0x65, 0x37, 0x63, 0x66, 0x31, 0x66, 0x61, 0x39, 0x38, 0x37, 0x39, 0x62, 0x64, 0x66, 0x35, 0x35, 0x61, 0x66, 0x34, 0x62, 0x39, 0x39, 0x63, 0x64, 0x35, 0x63, 0x65, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x32, 0x36, 0x38, 0x66, 0x31, 0x33, 0x31, 0x64, 0x64, 0x66, 0x36, 0x38, 0x37, 0x63, 0x63, 0x33, 0x32, 0x35, 0x63, 0x34, 0x31, 0x32, 0x66, 0x37, 0x38, 0x62, 0x61, 0x39, 0x36, 0x31, 0x32, 0x30, 0x35, 0x65, 0x39, 0x31, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x30, 0x34, 0x37, 0x38, 0x61, 0x36, 0x35, 0x35, 0x64, 0x37, 0x38, 0x64, 0x30, 0x66, 0x33, 0x62, 0x30, 0x63, 0x34, 0x66, 0x32, 0x30, 0x32, 0x62, 0x36, 0x31, 0x34, 0x38, 0x35, 0x62, 0x63, 0x34, 0x30, 0x30, 0x32, 0x66, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x34, 0x30, 0x31, 0x34, 0x35, 0x33, 0x38, 0x63, 0x65, 0x65, 0x36, 0x36, 0x34, 0x61, 0x32, 0x66, 0x62, 0x63, 0x62, 0x36, 0x64, 0x63, 0x36, 0x36, 0x39, 0x66, 0x37, 0x61, 0x62, 0x31, 0x36, 0x64, 0x30, 0x62, 0x61, 0x35, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x33, 0x61, 0x35, 0x37, 0x39, 0x62, 0x63, 0x33, 0x65, 0x61, 0x63, 0x32, 0x61, 0x39, 0x34, 0x39, 0x30, 0x34, 0x31, 0x30, 0x31, 0x32, 0x38, 0x64, 0x62, 0x63, 0x65, 0x62, 0x65, 0x36, 0x64, 0x39, 0x64, 0x65, 0x38, 0x32, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x38, 0x32, 0x32, 0x64, 0x39, 0x62, 0x33, 0x65, 0x66, 0x34, 0x62, 0x35, 0x30, 0x32, 0x36, 0x32, 0x37, 0x34, 0x30, 0x37, 0x64, 0x61, 0x32, 0x37, 0x32, 0x66, 0x36, 0x37, 0x38, 0x31, 0x34, 0x61, 0x36, 0x62, 0x65, 0x63, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x35, 0x32, 0x61, 0x62, 0x31, 0x30, 0x35, 0x35, 0x33, 0x34, 0x39, 0x32, 0x33, 0x32, 0x39, 0x63, 0x31, 0x63, 0x35, 0x34, 0x38, 0x33, 0x33, 0x61, 0x65, 0x36, 0x31, 0x30, 0x66, 0x33, 0x39, 0x38, 0x61, 0x36, 0x35, 0x62, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x33, 0x34, 0x30, 0x61, 0x35, 0x37, 0x37, 0x31, 0x36, 0x62, 0x66, 0x61, 0x36, 0x33, 0x65, 0x62, 0x36, 0x63, 0x64, 0x31, 0x33, 0x33, 0x37, 0x32, 0x31, 0x32, 0x30, 0x32, 0x35, 0x37, 0x35, 0x62, 0x66, 0x37, 0x39, 0x36, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x39, 0x39, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x33, 0x62, 0x66, 0x33, 0x33, 0x66, 0x38, 0x32, 0x39, 0x39, 0x37, 0x30, 0x32, 0x62, 0x33, 0x61, 0x39, 0x30, 0x32, 0x36, 0x34, 0x32, 0x63, 0x33, 0x33, 0x65, 0x30, 0x62, 0x66, 0x61, 0x65, 0x61, 0x35, 0x63, 0x31, 0x63, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x62, 0x63, 0x34, 0x39, 0x65, 0x66, 0x32, 0x38, 0x38, 0x63, 0x64, 0x31, 0x36, 0x35, 0x65, 0x35, 0x32, 0x35, 0x63, 0x36, 0x36, 0x31, 0x61, 0x38, 0x31, 0x32, 0x63, 0x66, 0x38, 0x34, 0x66, 0x62, 0x65, 0x63, 0x38, 0x66, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x38, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x32, 0x33, 0x31, 0x62, 0x61, 0x35, 0x61, 0x34, 0x31, 0x31, 0x61, 0x31, 0x33, 0x65, 0x32, 0x32, 0x32, 0x62, 0x32, 0x39, 0x62, 0x66, 0x63, 0x31, 0x30, 0x38, 0x33, 0x66, 0x37, 0x36, 0x33, 0x31, 0x35, 0x38, 0x66, 0x32, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x31, 0x35, 0x65, 0x63, 0x33, 0x35, 0x32, 0x30, 0x62, 0x66, 0x38, 0x65, 0x62, 0x62, 0x63, 0x38, 0x32, 0x30, 0x62, 0x64, 0x30, 0x66, 0x66, 0x31, 0x39, 0x37, 0x37, 0x38, 0x33, 0x37, 0x35, 0x34, 0x39, 0x34, 0x63, 0x66, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x63, 0x65, 0x64, 0x38, 0x61, 0x39, 0x35, 0x36, 0x33, 0x62, 0x31, 0x62, 0x63, 0x33, 0x31, 0x31, 0x64, 0x62, 0x64, 0x66, 0x66, 0x63, 0x31, 0x61, 0x65, 0x37, 0x66, 0x35, 0x37, 0x35, 0x31, 0x39, 0x63, 0x34, 0x34, 0x34, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x30, 0x66, 0x33, 0x30, 0x30, 0x39, 0x64, 0x62, 0x34, 0x33, 0x37, 0x65, 0x34, 0x65, 0x31, 0x31, 0x63, 0x37, 0x38, 0x30, 0x62, 0x65, 0x63, 0x38, 0x38, 0x39, 0x36, 0x66, 0x37, 0x33, 0x38, 0x64, 0x36, 0x35, 0x65, 0x66, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x30, 0x33, 0x32, 0x34, 0x31, 0x65, 0x62, 0x38, 0x66, 0x30, 0x38, 0x66, 0x37, 0x32, 0x31, 0x65, 0x33, 0x34, 0x38, 0x63, 0x39, 0x64, 0x39, 0x61, 0x64, 0x39, 0x32, 0x66, 0x34, 0x38, 0x65, 0x33, 0x39, 0x30, 0x61, 0x61, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x63, 0x65, 0x63, 0x36, 0x63, 0x38, 0x38, 0x30, 0x39, 0x32, 0x66, 0x37, 0x35, 0x36, 0x65, 0x66, 0x65, 0x35, 0x36, 0x66, 0x37, 0x64, 0x62, 0x31, 0x31, 0x32, 0x32, 0x38, 0x61, 0x32, 0x64, 0x62, 0x34, 0x35, 0x62, 0x31, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x34, 0x63, 0x65, 0x62, 0x62, 0x34, 0x39, 0x32, 0x39, 0x38, 0x38, 0x32, 0x62, 0x66, 0x33, 0x62, 0x34, 0x62, 0x66, 0x39, 0x38, 0x36, 0x34, 0x63, 0x32, 0x62, 0x31, 0x62, 0x30, 0x66, 0x36, 0x32, 0x63, 0x32, 0x38, 0x33, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x65, 0x38, 0x36, 0x32, 0x38, 0x61, 0x38, 0x31, 0x35, 0x34, 0x38, 0x37, 0x34, 0x65, 0x30, 0x34, 0x38, 0x64, 0x38, 0x30, 0x63, 0x31, 0x34, 0x32, 0x31, 0x38, 0x31, 0x30, 0x32, 0x32, 0x62, 0x31, 0x38, 0x30, 0x62, 0x63, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x64, 0x39, 0x37, 0x33, 0x61, 0x66, 0x33, 0x36, 0x36, 0x61, 0x61, 0x35, 0x31, 0x35, 0x37, 0x63, 0x35, 0x34, 0x36, 0x35, 0x39, 0x62, 0x63, 0x66, 0x62, 0x32, 0x37, 0x63, 0x62, 0x66, 0x61, 0x35, 0x61, 0x63, 0x31, 0x35, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x33, 0x31, 0x33, 0x39, 0x62, 0x63, 0x35, 0x39, 0x36, 0x34, 0x30, 0x33, 0x64, 0x35, 0x64, 0x33, 0x39, 0x33, 0x31, 0x66, 0x37, 0x37, 0x34, 0x63, 0x36, 0x36, 0x63, 0x34, 0x62, 0x61, 0x34, 0x36, 0x37, 0x34, 0x35, 0x34, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x39, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x35, 0x38, 0x34, 0x61, 0x33, 0x66, 0x36, 0x31, 0x33, 0x62, 0x64, 0x34, 0x66, 0x61, 0x63, 0x37, 0x34, 0x63, 0x31, 0x65, 0x37, 0x38, 0x30, 0x62, 0x38, 0x36, 0x64, 0x36, 0x63, 0x61, 0x65, 0x62, 0x38, 0x39, 0x30, 0x63, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x66, 0x34, 0x65, 0x33, 0x62, 0x64, 0x66, 0x30, 0x35, 0x36, 0x38, 0x38, 0x33, 0x63, 0x63, 0x38, 0x37, 0x32, 0x38, 0x30, 0x64, 0x62, 0x65, 0x36, 0x34, 0x30, 0x61, 0x31, 0x38, 0x61, 0x30, 0x64, 0x30, 0x32, 0x61, 0x32, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x65, 0x33, 0x66, 0x65, 0x33, 0x34, 0x61, 0x36, 0x66, 0x62, 0x66, 0x36, 0x33, 0x34, 0x63, 0x30, 0x35, 0x31, 0x39, 0x39, 0x37, 0x66, 0x34, 0x37, 0x63, 0x63, 0x37, 0x66, 0x34, 0x38, 0x37, 0x39, 0x31, 0x66, 0x35, 0x38, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x35, 0x61, 0x31, 0x63, 0x61, 0x31, 0x30, 0x33, 0x36, 0x62, 0x39, 0x35, 0x30, 0x30, 0x34, 0x31, 0x38, 0x37, 0x63, 0x64, 0x61, 0x63, 0x34, 0x34, 0x61, 0x33, 0x36, 0x65, 0x33, 0x33, 0x61, 0x39, 0x34, 0x61, 0x62, 0x35, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x64, 0x33, 0x33, 0x65, 0x62, 0x33, 0x39, 0x63, 0x64, 0x61, 0x36, 0x34, 0x35, 0x33, 0x62, 0x31, 0x39, 0x65, 0x36, 0x31, 0x63, 0x31, 0x66, 0x65, 0x34, 0x64, 0x62, 0x39, 0x33, 0x31, 0x37, 0x30, 0x65, 0x66, 0x39, 0x64, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x35, 0x36, 0x31, 0x36, 0x62, 0x65, 0x39, 0x63, 0x38, 0x62, 0x37, 0x39, 0x37, 0x65, 0x37, 0x34, 0x31, 0x35, 0x32, 0x32, 0x37, 0x63, 0x39, 0x31, 0x33, 0x38, 0x66, 0x61, 0x61, 0x30, 0x38, 0x39, 0x31, 0x37, 0x34, 0x32, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x37, 0x38, 0x31, 0x32, 0x66, 0x36, 0x36, 0x63, 0x35, 0x65, 0x36, 0x35, 0x39, 0x34, 0x31, 0x65, 0x31, 0x38, 0x36, 0x63, 0x34, 0x36, 0x39, 0x32, 0x32, 0x62, 0x36, 0x65, 0x37, 0x62, 0x32, 0x66, 0x30, 0x65, 0x65, 0x62, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x37, 0x66, 0x35, 0x30, 0x64, 0x66, 0x38, 0x39, 0x61, 0x31, 0x63, 0x66, 0x66, 0x39, 0x36, 0x35, 0x31, 0x33, 0x62, 0x65, 0x66, 0x31, 0x62, 0x32, 0x61, 0x65, 0x33, 0x61, 0x32, 0x39, 0x37, 0x31, 0x61, 0x63, 0x63, 0x66, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x64, 0x31, 0x35, 0x32, 0x38, 0x62, 0x34, 0x34, 0x37, 0x65, 0x64, 0x34, 0x32, 0x39, 0x37, 0x39, 0x30, 0x32, 0x66, 0x36, 0x33, 0x39, 0x63, 0x35, 0x31, 0x34, 0x64, 0x30, 0x39, 0x34, 0x34, 0x61, 0x38, 0x38, 0x66, 0x38, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x66, 0x62, 0x31, 0x34, 0x34, 0x30, 0x39, 0x61, 0x36, 0x37, 0x62, 0x34, 0x35, 0x36, 0x38, 0x38, 0x61, 0x38, 0x35, 0x39, 0x33, 0x65, 0x35, 0x63, 0x63, 0x32, 0x63, 0x66, 0x35, 0x39, 0x36, 0x63, 0x65, 0x64, 0x36, 0x66, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x35, 0x64, 0x39, 0x61, 0x65, 0x66, 0x32, 0x63, 0x33, 0x39, 0x63, 0x36, 0x32, 0x33, 0x30, 0x64, 0x30, 0x39, 0x63, 0x39, 0x39, 0x65, 0x66, 0x36, 0x34, 0x39, 0x34, 0x39, 0x38, 0x39, 0x61, 0x62, 0x65, 0x36, 0x38, 0x37, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x38, 0x63, 0x34, 0x33, 0x64, 0x31, 0x31, 0x61, 0x66, 0x65, 0x33, 0x62, 0x35, 0x38, 0x36, 0x66, 0x66, 0x33, 0x37, 0x34, 0x31, 0x39, 0x32, 0x64, 0x39, 0x36, 0x61, 0x37, 0x66, 0x32, 0x33, 0x64, 0x32, 0x62, 0x39, 0x62, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x37, 0x37, 0x31, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x65, 0x63, 0x65, 0x31, 0x66, 0x36, 0x33, 0x32, 0x37, 0x31, 0x31, 0x64, 0x31, 0x33, 0x62, 0x66, 0x66, 0x66, 0x61, 0x31, 0x66, 0x38, 0x66, 0x36, 0x38, 0x34, 0x30, 0x38, 0x37, 0x31, 0x65, 0x65, 0x35, 0x38, 0x66, 0x62, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x62, 0x33, 0x33, 0x35, 0x38, 0x63, 0x35, 0x30, 0x63, 0x66, 0x39, 0x66, 0x37, 0x35, 0x66, 0x66, 0x63, 0x37, 0x36, 0x64, 0x34, 0x34, 0x33, 0x63, 0x32, 0x63, 0x37, 0x66, 0x35, 0x35, 0x30, 0x37, 0x35, 0x61, 0x30, 0x35, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x35, 0x36, 0x64, 0x63, 0x30, 0x62, 0x32, 0x61, 0x39, 0x38, 0x31, 0x65, 0x35, 0x62, 0x35, 0x35, 0x64, 0x33, 0x66, 0x32, 0x66, 0x30, 0x33, 0x62, 0x38, 0x31, 0x33, 0x34, 0x65, 0x33, 0x33, 0x31, 0x64, 0x62, 0x61, 0x64, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x39, 0x63, 0x63, 0x39, 0x66, 0x65, 0x30, 0x38, 0x36, 0x39, 0x64, 0x32, 0x64, 0x61, 0x62, 0x35, 0x32, 0x63, 0x63, 0x37, 0x61, 0x61, 0x65, 0x38, 0x66, 0x64, 0x35, 0x37, 0x61, 0x64, 0x62, 0x33, 0x35, 0x66, 0x39, 0x66, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x36, 0x37, 0x63, 0x36, 0x61, 0x35, 0x63, 0x36, 0x39, 0x36, 0x65, 0x64, 0x65, 0x39, 0x61, 0x31, 0x65, 0x35, 0x34, 0x32, 0x62, 0x66, 0x31, 0x61, 0x64, 0x30, 0x36, 0x62, 0x63, 0x63, 0x34, 0x62, 0x30, 0x36, 0x61, 0x63, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x37, 0x35, 0x62, 0x34, 0x61, 0x34, 0x37, 0x35, 0x31, 0x33, 0x31, 0x32, 0x30, 0x62, 0x61, 0x35, 0x66, 0x38, 0x36, 0x30, 0x33, 0x39, 0x38, 0x31, 0x34, 0x66, 0x31, 0x39, 0x39, 0x38, 0x65, 0x33, 0x38, 0x31, 0x37, 0x61, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x38, 0x37, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x33, 0x64, 0x30, 0x36, 0x39, 0x32, 0x63, 0x65, 0x65, 0x65, 0x66, 0x38, 0x30, 0x61, 0x61, 0x34, 0x39, 0x36, 0x35, 0x63, 0x65, 0x65, 0x64, 0x32, 0x36, 0x32, 0x66, 0x66, 0x63, 0x37, 0x66, 0x30, 0x36, 0x39, 0x66, 0x32, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x35, 0x30, 0x32, 0x39, 0x61, 0x63, 0x65, 0x62, 0x30, 0x37, 0x37, 0x38, 0x36, 0x37, 0x35, 0x62, 0x65, 0x66, 0x31, 0x37, 0x34, 0x31, 0x61, 0x62, 0x32, 0x63, 0x64, 0x32, 0x39, 0x33, 0x31, 0x65, 0x66, 0x37, 0x63, 0x38, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x64, 0x33, 0x62, 0x37, 0x33, 0x31, 0x61, 0x33, 0x32, 0x36, 0x65, 0x37, 0x36, 0x38, 0x35, 0x38, 0x62, 0x61, 0x61, 0x35, 0x66, 0x34, 0x62, 0x64, 0x38, 0x39, 0x62, 0x35, 0x37, 0x62, 0x33, 0x36, 0x39, 0x33, 0x32, 0x33, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x34, 0x36, 0x63, 0x62, 0x31, 0x66, 0x62, 0x63, 0x65, 0x32, 0x61, 0x62, 0x32, 0x38, 0x35, 0x64, 0x38, 0x65, 0x35, 0x34, 0x30, 0x31, 0x66, 0x34, 0x32, 0x64, 0x64, 0x37, 0x32, 0x33, 0x34, 0x64, 0x33, 0x37, 0x65, 0x38, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x66, 0x34, 0x66, 0x63, 0x36, 0x30, 0x66, 0x30, 0x38, 0x65, 0x61, 0x63, 0x61, 0x31, 0x30, 0x35, 0x39, 0x38, 0x66, 0x30, 0x33, 0x33, 0x36, 0x33, 0x32, 0x39, 0x38, 0x30, 0x31, 0x65, 0x33, 0x63, 0x39, 0x32, 0x63, 0x62, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x34, 0x61, 0x36, 0x61, 0x33, 0x37, 0x39, 0x37, 0x30, 0x38, 0x62, 0x39, 0x34, 0x32, 0x38, 0x64, 0x37, 0x32, 0x32, 0x61, 0x61, 0x32, 0x62, 0x30, 0x36, 0x62, 0x37, 0x37, 0x65, 0x38, 0x38, 0x39, 0x33, 0x35, 0x63, 0x66, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x32, 0x38, 0x33, 0x32, 0x63, 0x64, 0x35, 0x39, 0x37, 0x37, 0x65, 0x30, 0x30, 0x61, 0x34, 0x63, 0x33, 0x30, 0x64, 0x30, 0x31, 0x36, 0x33, 0x66, 0x32, 0x65, 0x32, 0x34, 0x66, 0x30, 0x38, 0x38, 0x61, 0x36, 0x63, 0x62, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x61, 0x63, 0x30, 0x64, 0x33, 0x61, 0x35, 0x38, 0x36, 0x30, 0x35, 0x65, 0x31, 0x64, 0x30, 0x66, 0x30, 0x65, 0x62, 0x33, 0x64, 0x65, 0x32, 0x35, 0x62, 0x32, 0x63, 0x61, 0x64, 0x31, 0x32, 0x39, 0x65, 0x64, 0x36, 0x30, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x35, 0x36, 0x35, 0x35, 0x31, 0x62, 0x62, 0x37, 0x37, 0x64, 0x34, 0x66, 0x34, 0x35, 0x61, 0x36, 0x64, 0x37, 0x65, 0x30, 0x39, 0x66, 0x30, 0x61, 0x30, 0x38, 0x39, 0x65, 0x37, 0x39, 0x63, 0x63, 0x61, 0x32, 0x34, 0x39, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x30, 0x63, 0x39, 0x66, 0x35, 0x37, 0x38, 0x39, 0x61, 0x65, 0x34, 0x34, 0x65, 0x32, 0x64, 0x63, 0x65, 0x30, 0x31, 0x37, 0x63, 0x37, 0x31, 0x34, 0x63, 0x61, 0x66, 0x30, 0x30, 0x63, 0x38, 0x33, 0x30, 0x30, 0x38, 0x34, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x66, 0x64, 0x36, 0x63, 0x35, 0x64, 0x39, 0x37, 0x66, 0x39, 0x63, 0x36, 0x30, 0x30, 0x62, 0x37, 0x36, 0x38, 0x32, 0x31, 0x64, 0x64, 0x64, 0x34, 0x65, 0x37, 0x37, 0x36, 0x33, 0x35, 0x30, 0x66, 0x63, 0x65, 0x32, 0x62, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x64, 0x35, 0x63, 0x33, 0x31, 0x63, 0x63, 0x62, 0x36, 0x63, 0x62, 0x65, 0x33, 0x30, 0x63, 0x37, 0x63, 0x39, 0x65, 0x61, 0x31, 0x39, 0x66, 0x32, 0x36, 0x38, 0x64, 0x31, 0x35, 0x39, 0x38, 0x35, 0x31, 0x66, 0x38, 0x63, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x37, 0x30, 0x39, 0x31, 0x39, 0x33, 0x32, 0x65, 0x34, 0x62, 0x63, 0x33, 0x39, 0x64, 0x62, 0x62, 0x35, 0x35, 0x32, 0x33, 0x38, 0x30, 0x63, 0x61, 0x39, 0x33, 0x34, 0x66, 0x64, 0x37, 0x31, 0x36, 0x36, 0x64, 0x31, 0x65, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x64, 0x38, 0x64, 0x64, 0x39, 0x31, 0x66, 0x37, 0x31, 0x34, 0x37, 0x36, 0x34, 0x63, 0x34, 0x35, 0x36, 0x37, 0x37, 0x63, 0x36, 0x33, 0x64, 0x38, 0x35, 0x32, 0x65, 0x35, 0x36, 0x65, 0x62, 0x39, 0x65, 0x65, 0x63, 0x65, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x64, 0x30, 0x33, 0x32, 0x61, 0x34, 0x33, 0x64, 0x31, 0x36, 0x34, 0x65, 0x37, 0x31, 0x61, 0x61, 0x32, 0x65, 0x66, 0x33, 0x66, 0x66, 0x64, 0x38, 0x34, 0x39, 0x31, 0x62, 0x30, 0x61, 0x34, 0x65, 0x66, 0x31, 0x65, 0x61, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x66, 0x34, 0x36, 0x61, 0x32, 0x35, 0x61, 0x63, 0x30, 0x39, 0x63, 0x62, 0x37, 0x33, 0x36, 0x31, 0x36, 0x62, 0x35, 0x33, 0x62, 0x31, 0x34, 0x66, 0x62, 0x34, 0x32, 0x66, 0x66, 0x30, 0x61, 0x35, 0x31, 0x63, 0x64, 0x64, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x61, 0x36, 0x62, 0x66, 0x32, 0x66, 0x31, 0x35, 0x61, 0x65, 0x39, 0x63, 0x31, 0x64, 0x62, 0x63, 0x36, 0x34, 0x64, 0x61, 0x61, 0x37, 0x66, 0x38, 0x65, 0x61, 0x34, 0x64, 0x30, 0x64, 0x38, 0x31, 0x61, 0x61, 0x64, 0x33, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x33, 0x33, 0x37, 0x30, 0x31, 0x32, 0x61, 0x65, 0x31, 0x64, 0x37, 0x66, 0x66, 0x33, 0x65, 0x65, 0x37, 0x66, 0x36, 0x39, 0x37, 0x63, 0x34, 0x30, 0x33, 0x65, 0x37, 0x37, 0x38, 0x30, 0x31, 0x38, 0x38, 0x62, 0x66, 0x30, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x65, 0x62, 0x36, 0x34, 0x62, 0x65, 0x31, 0x62, 0x35, 0x64, 0x65, 0x64, 0x65, 0x34, 0x30, 0x38, 0x63, 0x36, 0x62, 0x64, 0x65, 0x66, 0x62, 0x65, 0x36, 0x65, 0x34, 0x30, 0x35, 0x63, 0x31, 0x36, 0x62, 0x37, 0x65, 0x64, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x65, 0x32, 0x34, 0x38, 0x38, 0x65, 0x32, 0x64, 0x61, 0x32, 0x36, 0x61, 0x34, 0x39, 0x61, 0x65, 0x38, 0x34, 0x63, 0x30, 0x31, 0x62, 0x64, 0x35, 0x34, 0x62, 0x32, 0x31, 0x66, 0x32, 0x39, 0x34, 0x37, 0x38, 0x39, 0x31, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x39, 0x38, 0x61, 0x37, 0x37, 0x66, 0x64, 0x34, 0x31, 0x30, 0x39, 0x37, 0x62, 0x33, 0x34, 0x66, 0x35, 0x39, 0x64, 0x37, 0x35, 0x38, 0x39, 0x62, 0x61, 0x61, 0x64, 0x30, 0x32, 0x31, 0x36, 0x35, 0x39, 0x66, 0x66, 0x37, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x34, 0x65, 0x64, 0x32, 0x61, 0x35, 0x38, 0x61, 0x38, 0x64, 0x64, 0x32, 0x30, 0x61, 0x37, 0x33, 0x32, 0x37, 0x35, 0x33, 0x34, 0x37, 0x62, 0x35, 0x38, 0x30, 0x64, 0x37, 0x31, 0x62, 0x39, 0x35, 0x62, 0x66, 0x39, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x31, 0x31, 0x31, 0x30, 0x64, 0x39, 0x36, 0x61, 0x61, 0x66, 0x66, 0x31, 0x31, 0x35, 0x32, 0x33, 0x63, 0x63, 0x35, 0x34, 0x36, 0x62, 0x66, 0x39, 0x39, 0x34, 0x30, 0x65, 0x65, 0x64, 0x66, 0x66, 0x62, 0x32, 0x66, 0x61, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x37, 0x31, 0x37, 0x39, 0x39, 0x63, 0x38, 0x64, 0x66, 0x33, 0x62, 0x63, 0x63, 0x62, 0x37, 0x65, 0x65, 0x34, 0x34, 0x36, 0x64, 0x66, 0x35, 0x30, 0x62, 0x38, 0x33, 0x31, 0x32, 0x62, 0x63, 0x34, 0x65, 0x62, 0x37, 0x31, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x31, 0x37, 0x39, 0x61, 0x34, 0x36, 0x30, 0x64, 0x62, 0x36, 0x36, 0x33, 0x32, 0x36, 0x37, 0x34, 0x33, 0x64, 0x32, 0x34, 0x65, 0x36, 0x37, 0x35, 0x32, 0x33, 0x61, 0x35, 0x37, 0x62, 0x32, 0x34, 0x36, 0x64, 0x61, 0x66, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x32, 0x32, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x38, 0x62, 0x66, 0x63, 0x66, 0x31, 0x62, 0x30, 0x37, 0x61, 0x65, 0x33, 0x30, 0x38, 0x66, 0x61, 0x32, 0x63, 0x30, 0x32, 0x30, 0x36, 0x39, 0x61, 0x63, 0x39, 0x64, 0x61, 0x66, 0x65, 0x37, 0x31, 0x33, 0x35, 0x66, 0x62, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x36, 0x32, 0x61, 0x31, 0x37, 0x36, 0x35, 0x65, 0x65, 0x39, 0x32, 0x31, 0x38, 0x34, 0x32, 0x64, 0x64, 0x63, 0x38, 0x38, 0x38, 0x39, 0x38, 0x64, 0x31, 0x64, 0x63, 0x38, 0x36, 0x32, 0x37, 0x35, 0x39, 0x37, 0x62, 0x64, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x33, 0x65, 0x65, 0x63, 0x38, 0x61, 0x61, 0x35, 0x64, 0x61, 0x63, 0x37, 0x37, 0x62, 0x32, 0x65, 0x36, 0x36, 0x32, 0x33, 0x65, 0x64, 0x35, 0x31, 0x39, 0x38, 0x61, 0x34, 0x33, 0x31, 0x61, 0x62, 0x62, 0x61, 0x65, 0x65, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x36, 0x36, 0x34, 0x33, 0x63, 0x30, 0x65, 0x38, 0x38, 0x38, 0x34, 0x62, 0x32, 0x64, 0x33, 0x32, 0x31, 0x31, 0x38, 0x35, 0x33, 0x37, 0x38, 0x35, 0x61, 0x30, 0x38, 0x62, 0x66, 0x38, 0x66, 0x33, 0x33, 0x65, 0x64, 0x32, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x63, 0x37, 0x64, 0x33, 0x30, 0x36, 0x36, 0x64, 0x34, 0x35, 0x64, 0x32, 0x37, 0x36, 0x32, 0x31, 0x66, 0x37, 0x38, 0x62, 0x62, 0x34, 0x62, 0x33, 0x33, 0x39, 0x34, 0x37, 0x33, 0x65, 0x34, 0x34, 0x32, 0x61, 0x38, 0x36, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x65, 0x66, 0x38, 0x62, 0x65, 0x34, 0x35, 0x30, 0x37, 0x37, 0x63, 0x37, 0x64, 0x34, 0x63, 0x35, 0x36, 0x35, 0x32, 0x37, 0x34, 0x30, 0x64, 0x65, 0x39, 0x34, 0x36, 0x61, 0x36, 0x32, 0x36, 0x32, 0x34, 0x66, 0x37, 0x31, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x38, 0x35, 0x33, 0x38, 0x31, 0x37, 0x61, 0x66, 0x64, 0x33, 0x62, 0x38, 0x66, 0x33, 0x62, 0x38, 0x36, 0x65, 0x39, 0x66, 0x36, 0x30, 0x65, 0x65, 0x37, 0x37, 0x62, 0x35, 0x64, 0x39, 0x37, 0x37, 0x37, 0x33, 0x63, 0x30, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x31, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x30, 0x62, 0x38, 0x65, 0x64, 0x38, 0x36, 0x65, 0x64, 0x36, 0x36, 0x39, 0x65, 0x31, 0x32, 0x37, 0x32, 0x33, 0x61, 0x66, 0x37, 0x35, 0x37, 0x32, 0x66, 0x62, 0x61, 0x63, 0x66, 0x65, 0x38, 0x32, 0x39, 0x62, 0x31, 0x65, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x36, 0x38, 0x65, 0x30, 0x63, 0x62, 0x33, 0x65, 0x64, 0x66, 0x35, 0x31, 0x66, 0x30, 0x61, 0x36, 0x66, 0x32, 0x31, 0x31, 0x63, 0x39, 0x62, 0x32, 0x63, 0x62, 0x35, 0x65, 0x30, 0x37, 0x33, 0x63, 0x39, 0x62, 0x66, 0x66, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x32, 0x33, 0x34, 0x66, 0x35, 0x30, 0x35, 0x63, 0x61, 0x38, 0x64, 0x63, 0x63, 0x37, 0x37, 0x64, 0x39, 0x62, 0x37, 0x65, 0x30, 0x31, 0x64, 0x32, 0x35, 0x37, 0x63, 0x33, 0x31, 0x38, 0x63, 0x63, 0x31, 0x39, 0x33, 0x39, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x66, 0x32, 0x34, 0x66, 0x63, 0x32, 0x39, 0x65, 0x32, 0x30, 0x34, 0x30, 0x33, 0x66, 0x63, 0x30, 0x65, 0x38, 0x66, 0x35, 0x65, 0x62, 0x62, 0x62, 0x35, 0x35, 0x33, 0x34, 0x32, 0x36, 0x66, 0x37, 0x38, 0x32, 0x37, 0x30, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x35, 0x34, 0x36, 0x62, 0x37, 0x39, 0x65, 0x63, 0x66, 0x36, 0x39, 0x66, 0x39, 0x33, 0x36, 0x62, 0x35, 0x61, 0x35, 0x36, 0x31, 0x35, 0x30, 0x38, 0x62, 0x30, 0x64, 0x37, 0x65, 0x35, 0x30, 0x63, 0x63, 0x35, 0x39, 0x39, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x35, 0x34, 0x34, 0x33, 0x62, 0x38, 0x31, 0x64, 0x66, 0x64, 0x62, 0x39, 0x62, 0x64, 0x38, 0x63, 0x36, 0x37, 0x38, 0x37, 0x62, 0x63, 0x32, 0x35, 0x31, 0x38, 0x65, 0x32, 0x64, 0x34, 0x37, 0x65, 0x35, 0x37, 0x63, 0x31, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x30, 0x36, 0x65, 0x33, 0x62, 0x62, 0x31, 0x65, 0x64, 0x63, 0x66, 0x64, 0x30, 0x63, 0x34, 0x34, 0x63, 0x33, 0x30, 0x37, 0x34, 0x64, 0x65, 0x30, 0x62, 0x62, 0x36, 0x30, 0x36, 0x62, 0x30, 0x34, 0x39, 0x38, 0x39, 0x34, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x33, 0x31, 0x30, 0x38, 0x63, 0x31, 0x65, 0x36, 0x38, 0x30, 0x61, 0x33, 0x33, 0x62, 0x33, 0x33, 0x36, 0x63, 0x32, 0x31, 0x31, 0x33, 0x31, 0x33, 0x33, 0x34, 0x34, 0x30, 0x39, 0x64, 0x39, 0x37, 0x65, 0x35, 0x61, 0x64, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x61, 0x66, 0x36, 0x62, 0x66, 0x34, 0x65, 0x63, 0x37, 0x64, 0x35, 0x61, 0x31, 0x39, 0x63, 0x35, 0x65, 0x30, 0x38, 0x39, 0x37, 0x61, 0x35, 0x65, 0x65, 0x62, 0x30, 0x31, 0x31, 0x64, 0x63, 0x65, 0x63, 0x65, 0x34, 0x32, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x39, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x34, 0x66, 0x38, 0x35, 0x35, 0x31, 0x61, 0x63, 0x65, 0x39, 0x33, 0x33, 0x37, 0x32, 0x30, 0x37, 0x31, 0x32, 0x63, 0x35, 0x63, 0x34, 0x39, 0x31, 0x63, 0x64, 0x62, 0x36, 0x66, 0x32, 0x66, 0x39, 0x35, 0x31, 0x37, 0x33, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x63, 0x31, 0x66, 0x39, 0x35, 0x35, 0x30, 0x37, 0x62, 0x31, 0x30, 0x31, 0x38, 0x36, 0x34, 0x32, 0x65, 0x34, 0x35, 0x63, 0x64, 0x39, 0x63, 0x30, 0x65, 0x32, 0x32, 0x37, 0x33, 0x33, 0x62, 0x39, 0x62, 0x31, 0x61, 0x33, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x63, 0x61, 0x35, 0x36, 0x64, 0x65, 0x37, 0x37, 0x37, 0x66, 0x64, 0x34, 0x35, 0x33, 0x31, 0x37, 0x37, 0x66, 0x35, 0x65, 0x30, 0x36, 0x39, 0x34, 0x63, 0x34, 0x37, 0x38, 0x65, 0x36, 0x36, 0x61, 0x66, 0x66, 0x38, 0x61, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x64, 0x64, 0x31, 0x62, 0x37, 0x38, 0x36, 0x31, 0x36, 0x32, 0x62, 0x38, 0x33, 0x31, 0x37, 0x65, 0x32, 0x30, 0x66, 0x30, 0x65, 0x39, 0x37, 0x39, 0x66, 0x34, 0x62, 0x32, 0x63, 0x65, 0x34, 0x38, 0x36, 0x64, 0x37, 0x36, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x38, 0x30, 0x35, 0x66, 0x61, 0x30, 0x66, 0x37, 0x33, 0x38, 0x37, 0x66, 0x37, 0x33, 0x30, 0x35, 0x35, 0x62, 0x37, 0x38, 0x35, 0x38, 0x63, 0x61, 0x38, 0x35, 0x31, 0x39, 0x65, 0x64, 0x64, 0x39, 0x33, 0x64, 0x36, 0x33, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x33, 0x36, 0x32, 0x32, 0x34, 0x63, 0x37, 0x33, 0x35, 0x36, 0x65, 0x37, 0x35, 0x31, 0x66, 0x30, 0x63, 0x30, 0x36, 0x36, 0x63, 0x33, 0x35, 0x65, 0x33, 0x62, 0x34, 0x34, 0x38, 0x36, 0x30, 0x33, 0x36, 0x34, 0x62, 0x66, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x38, 0x39, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x65, 0x63, 0x62, 0x65, 0x61, 0x30, 0x37, 0x63, 0x32, 0x37, 0x30, 0x30, 0x32, 0x66, 0x36, 0x35, 0x66, 0x65, 0x35, 0x33, 0x34, 0x62, 0x62, 0x38, 0x38, 0x34, 0x32, 0x64, 0x30, 0x39, 0x32, 0x35, 0x63, 0x37, 0x38, 0x34, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x32, 0x39, 0x38, 0x32, 0x61, 0x63, 0x31, 0x66, 0x31, 0x63, 0x36, 0x64, 0x31, 0x37, 0x32, 0x31, 0x66, 0x65, 0x65, 0x63, 0x64, 0x39, 0x62, 0x39, 0x63, 0x39, 0x36, 0x63, 0x64, 0x39, 0x34, 0x39, 0x38, 0x30, 0x35, 0x30, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x38, 0x38, 0x30, 0x66, 0x63, 0x37, 0x35, 0x36, 0x37, 0x64, 0x35, 0x35, 0x39, 0x35, 0x63, 0x61, 0x63, 0x63, 0x65, 0x31, 0x35, 0x63, 0x33, 0x66, 0x63, 0x31, 0x34, 0x63, 0x38, 0x37, 0x34, 0x32, 0x63, 0x32, 0x36, 0x63, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x31, 0x63, 0x37, 0x38, 0x37, 0x38, 0x36, 0x61, 0x62, 0x34, 0x64, 0x32, 0x62, 0x33, 0x62, 0x32, 0x37, 0x37, 0x31, 0x33, 0x35, 0x62, 0x35, 0x62, 0x61, 0x31, 0x32, 0x33, 0x65, 0x30, 0x34, 0x30, 0x30, 0x34, 0x38, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x66, 0x32, 0x37, 0x65, 0x37, 0x34, 0x34, 0x62, 0x64, 0x32, 0x39, 0x64, 0x65, 0x32, 0x62, 0x30, 0x35, 0x39, 0x38, 0x66, 0x30, 0x32, 0x61, 0x30, 0x62, 0x62, 0x39, 0x66, 0x39, 0x38, 0x65, 0x36, 0x38, 0x31, 0x65, 0x61, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x61, 0x30, 0x32, 0x35, 0x33, 0x31, 0x36, 0x66, 0x39, 0x36, 0x37, 0x66, 0x61, 0x38, 0x62, 0x39, 0x61, 0x31, 0x64, 0x36, 0x30, 0x37, 0x30, 0x30, 0x30, 0x36, 0x33, 0x66, 0x35, 0x61, 0x36, 0x38, 0x30, 0x30, 0x31, 0x63, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x31, 0x66, 0x32, 0x30, 0x31, 0x37, 0x36, 0x64, 0x31, 0x32, 0x33, 0x36, 0x30, 0x64, 0x37, 0x32, 0x34, 0x64, 0x35, 0x31, 0x34, 0x37, 0x30, 0x61, 0x39, 0x30, 0x37, 0x30, 0x33, 0x36, 0x37, 0x35, 0x35, 0x39, 0x34, 0x61, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x34, 0x64, 0x38, 0x34, 0x30, 0x33, 0x32, 0x31, 0x36, 0x66, 0x64, 0x35, 0x37, 0x31, 0x35, 0x37, 0x32, 0x62, 0x66, 0x31, 0x62, 0x64, 0x62, 0x30, 0x31, 0x64, 0x30, 0x30, 0x35, 0x37, 0x38, 0x39, 0x37, 0x38, 0x64, 0x36, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x30, 0x66, 0x30, 0x62, 0x38, 0x65, 0x33, 0x35, 0x62, 0x36, 0x36, 0x38, 0x66, 0x38, 0x31, 0x65, 0x66, 0x32, 0x35, 0x32, 0x62, 0x31, 0x33, 0x38, 0x35, 0x35, 0x61, 0x61, 0x35, 0x30, 0x30, 0x37, 0x64, 0x30, 0x31, 0x32, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x35, 0x62, 0x39, 0x35, 0x61, 0x32, 0x61, 0x33, 0x37, 0x33, 0x37, 0x63, 0x62, 0x38, 0x66, 0x30, 0x66, 0x35, 0x39, 0x36, 0x62, 0x33, 0x34, 0x35, 0x32, 0x34, 0x38, 0x37, 0x32, 0x62, 0x64, 0x33, 0x30, 0x64, 0x61, 0x32, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x32, 0x61, 0x36, 0x38, 0x66, 0x36, 0x63, 0x36, 0x34, 0x35, 0x35, 0x35, 0x39, 0x63, 0x63, 0x39, 0x37, 0x37, 0x66, 0x63, 0x34, 0x39, 0x36, 0x34, 0x30, 0x34, 0x37, 0x61, 0x32, 0x30, 0x31, 0x64, 0x31, 0x62, 0x62, 0x30, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x64, 0x61, 0x64, 0x31, 0x62, 0x36, 0x64, 0x30, 0x38, 0x64, 0x34, 0x35, 0x38, 0x31, 0x63, 0x63, 0x61, 0x65, 0x36, 0x35, 0x61, 0x38, 0x37, 0x33, 0x32, 0x64, 0x62, 0x36, 0x61, 0x63, 0x36, 0x39, 0x66, 0x30, 0x63, 0x36, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x38, 0x35, 0x35, 0x65, 0x63, 0x36, 0x34, 0x31, 0x61, 0x62, 0x39, 0x65, 0x30, 0x38, 0x31, 0x65, 0x64, 0x30, 0x63, 0x32, 0x61, 0x36, 0x64, 0x63, 0x64, 0x38, 0x31, 0x33, 0x35, 0x34, 0x64, 0x30, 0x32, 0x34, 0x34, 0x61, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x31, 0x38, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x30, 0x31, 0x35, 0x64, 0x37, 0x32, 0x30, 0x33, 0x63, 0x35, 0x65, 0x30, 0x32, 0x32, 0x34, 0x61, 0x65, 0x64, 0x61, 0x32, 0x38, 0x36, 0x65, 0x64, 0x31, 0x32, 0x66, 0x31, 0x61, 0x35, 0x31, 0x62, 0x37, 0x38, 0x39, 0x33, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x31, 0x63, 0x31, 0x32, 0x37, 0x32, 0x32, 0x63, 0x36, 0x38, 0x37, 0x39, 0x32, 0x32, 0x37, 0x39, 0x39, 0x32, 0x61, 0x33, 0x30, 0x34, 0x65, 0x62, 0x33, 0x35, 0x37, 0x36, 0x63, 0x64, 0x31, 0x38, 0x34, 0x33, 0x34, 0x65, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x36, 0x66, 0x30, 0x30, 0x33, 0x30, 0x33, 0x34, 0x39, 0x37, 0x35, 0x32, 0x30, 0x36, 0x31, 0x63, 0x39, 0x36, 0x30, 0x37, 0x32, 0x62, 0x63, 0x33, 0x64, 0x36, 0x65, 0x62, 0x33, 0x35, 0x34, 0x39, 0x32, 0x30, 0x38, 0x64, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x38, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x31, 0x35, 0x33, 0x30, 0x36, 0x33, 0x61, 0x31, 0x61, 0x65, 0x37, 0x66, 0x30, 0x32, 0x66, 0x31, 0x61, 0x38, 0x38, 0x31, 0x33, 0x36, 0x64, 0x34, 0x64, 0x36, 0x39, 0x63, 0x37, 0x63, 0x35, 0x65, 0x33, 0x65, 0x34, 0x33, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x33, 0x35, 0x35, 0x64, 0x66, 0x30, 0x61, 0x32, 0x33, 0x30, 0x66, 0x38, 0x33, 0x64, 0x30, 0x33, 0x32, 0x63, 0x37, 0x30, 0x33, 0x31, 0x35, 0x34, 0x34, 0x31, 0x34, 0x64, 0x65, 0x33, 0x65, 0x65, 0x64, 0x61, 0x62, 0x35, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x62, 0x35, 0x36, 0x63, 0x64, 0x32, 0x33, 0x34, 0x32, 0x36, 0x37, 0x63, 0x32, 0x38, 0x65, 0x38, 0x39, 0x63, 0x36, 0x66, 0x36, 0x62, 0x32, 0x32, 0x36, 0x36, 0x62, 0x30, 0x38, 0x36, 0x61, 0x31, 0x32, 0x66, 0x39, 0x37, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x33, 0x63, 0x64, 0x33, 0x62, 0x65, 0x63, 0x30, 0x36, 0x35, 0x39, 0x31, 0x64, 0x36, 0x33, 0x34, 0x36, 0x66, 0x32, 0x35, 0x34, 0x62, 0x36, 0x32, 0x31, 0x65, 0x62, 0x34, 0x31, 0x63, 0x38, 0x39, 0x30, 0x30, 0x38, 0x64, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x38, 0x65, 0x61, 0x31, 0x64, 0x63, 0x38, 0x65, 0x64, 0x63, 0x31, 0x39, 0x62, 0x61, 0x65, 0x38, 0x32, 0x36, 0x33, 0x38, 0x30, 0x32, 0x39, 0x65, 0x61, 0x38, 0x37, 0x35, 0x32, 0x63, 0x65, 0x39, 0x38, 0x62, 0x63, 0x66, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x36, 0x33, 0x32, 0x30, 0x34, 0x36, 0x64, 0x63, 0x62, 0x32, 0x35, 0x61, 0x35, 0x34, 0x39, 0x33, 0x36, 0x39, 0x32, 0x38, 0x61, 0x39, 0x36, 0x66, 0x34, 0x32, 0x33, 0x66, 0x33, 0x33, 0x32, 0x30, 0x63, 0x62, 0x65, 0x64, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x62, 0x65, 0x65, 0x36, 0x66, 0x30, 0x39, 0x34, 0x65, 0x61, 0x65, 0x36, 0x33, 0x34, 0x32, 0x30, 0x62, 0x30, 0x30, 0x33, 0x66, 0x62, 0x34, 0x37, 0x35, 0x37, 0x31, 0x34, 0x32, 0x61, 0x65, 0x61, 0x36, 0x63, 0x64, 0x30, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x35, 0x35, 0x64, 0x30, 0x30, 0x66, 0x39, 0x31, 0x39, 0x30, 0x63, 0x63, 0x33, 0x36, 0x37, 0x37, 0x61, 0x65, 0x66, 0x33, 0x31, 0x34, 0x61, 0x63, 0x64, 0x37, 0x33, 0x66, 0x64, 0x63, 0x33, 0x39, 0x33, 0x39, 0x39, 0x32, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x33, 0x30, 0x66, 0x65, 0x31, 0x62, 0x66, 0x66, 0x30, 0x33, 0x31, 0x38, 0x36, 0x64, 0x30, 0x32, 0x31, 0x39, 0x66, 0x31, 0x35, 0x64, 0x34, 0x63, 0x34, 0x38, 0x31, 0x62, 0x37, 0x64, 0x35, 0x39, 0x62, 0x65, 0x32, 0x38, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x34, 0x65, 0x39, 0x32, 0x36, 0x35, 0x32, 0x32, 0x33, 0x63, 0x39, 0x37, 0x33, 0x38, 0x33, 0x32, 0x34, 0x63, 0x66, 0x32, 0x30, 0x62, 0x64, 0x30, 0x36, 0x30, 0x30, 0x36, 0x64, 0x30, 0x30, 0x37, 0x33, 0x65, 0x64, 0x62, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x35, 0x30, 0x66, 0x66, 0x37, 0x66, 0x39, 0x39, 0x65, 0x61, 0x61, 0x39, 0x31, 0x31, 0x36, 0x32, 0x37, 0x35, 0x64, 0x65, 0x61, 0x63, 0x36, 0x38, 0x65, 0x34, 0x32, 0x38, 0x64, 0x66, 0x35, 0x62, 0x62, 0x63, 0x64, 0x38, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x31, 0x66, 0x36, 0x39, 0x30, 0x34, 0x33, 0x64, 0x65, 0x38, 0x38, 0x63, 0x34, 0x39, 0x31, 0x37, 0x63, 0x61, 0x31, 0x30, 0x66, 0x31, 0x38, 0x34, 0x32, 0x38, 0x39, 0x37, 0x65, 0x65, 0x63, 0x30, 0x35, 0x38, 0x39, 0x63, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x38, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x31, 0x37, 0x38, 0x37, 0x38, 0x34, 0x33, 0x35, 0x30, 0x35, 0x66, 0x38, 0x65, 0x34, 0x65, 0x66, 0x66, 0x34, 0x36, 0x35, 0x36, 0x36, 0x63, 0x63, 0x65, 0x36, 0x61, 0x35, 0x39, 0x66, 0x34, 0x64, 0x31, 0x63, 0x35, 0x66, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x64, 0x33, 0x37, 0x62, 0x32, 0x35, 0x36, 0x35, 0x36, 0x33, 0x65, 0x33, 0x30, 0x63, 0x36, 0x66, 0x39, 0x32, 0x38, 0x39, 0x61, 0x38, 0x65, 0x32, 0x37, 0x30, 0x32, 0x66, 0x30, 0x38, 0x35, 0x32, 0x38, 0x38, 0x30, 0x38, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x34, 0x31, 0x65, 0x31, 0x61, 0x32, 0x38, 0x66, 0x35, 0x63, 0x61, 0x61, 0x38, 0x34, 0x33, 0x38, 0x38, 0x30, 0x65, 0x66, 0x34, 0x65, 0x38, 0x62, 0x30, 0x38, 0x62, 0x64, 0x36, 0x63, 0x33, 0x33, 0x31, 0x34, 0x31, 0x65, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x30, 0x31, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x32, 0x33, 0x38, 0x65, 0x30, 0x33, 0x36, 0x35, 0x39, 0x36, 0x39, 0x38, 0x37, 0x36, 0x34, 0x33, 0x64, 0x37, 0x33, 0x31, 0x37, 0x33, 0x63, 0x33, 0x37, 0x62, 0x30, 0x61, 0x64, 0x30, 0x36, 0x30, 0x35, 0x35, 0x62, 0x39, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x38, 0x39, 0x37, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x38, 0x65, 0x35, 0x32, 0x34, 0x65, 0x66, 0x32, 0x61, 0x33, 0x38, 0x31, 0x64, 0x37, 0x30, 0x63, 0x38, 0x32, 0x35, 0x38, 0x38, 0x61, 0x39, 0x33, 0x63, 0x61, 0x37, 0x61, 0x35, 0x66, 0x61, 0x39, 0x64, 0x35, 0x31, 0x63, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x31, 0x39, 0x61, 0x63, 0x36, 0x31, 0x38, 0x64, 0x35, 0x64, 0x65, 0x61, 0x37, 0x63, 0x64, 0x63, 0x36, 0x30, 0x37, 0x37, 0x32, 0x30, 0x36, 0x66, 0x62, 0x30, 0x37, 0x64, 0x62, 0x64, 0x64, 0x37, 0x31, 0x63, 0x31, 0x37, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x32, 0x35, 0x66, 0x66, 0x33, 0x34, 0x39, 0x33, 0x34, 0x63, 0x31, 0x39, 0x34, 0x32, 0x65, 0x32, 0x32, 0x61, 0x34, 0x65, 0x37, 0x62, 0x64, 0x35, 0x36, 0x66, 0x31, 0x34, 0x30, 0x32, 0x31, 0x61, 0x31, 0x61, 0x66, 0x30, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x35, 0x32, 0x66, 0x34, 0x62, 0x33, 0x65, 0x64, 0x33, 0x65, 0x31, 0x64, 0x61, 0x37, 0x39, 0x61, 0x32, 0x66, 0x37, 0x38, 0x62, 0x62, 0x31, 0x33, 0x65, 0x38, 0x61, 0x65, 0x35, 0x61, 0x36, 0x38, 0x61, 0x39, 0x64, 0x66, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x35, 0x34, 0x32, 0x32, 0x31, 0x65, 0x36, 0x32, 0x64, 0x63, 0x30, 0x39, 0x65, 0x36, 0x34, 0x30, 0x36, 0x34, 0x33, 0x36, 0x31, 0x36, 0x33, 0x61, 0x31, 0x38, 0x35, 0x65, 0x66, 0x30, 0x36, 0x64, 0x31, 0x31, 0x34, 0x61, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x30, 0x34, 0x33, 0x32, 0x63, 0x62, 0x31, 0x35, 0x37, 0x62, 0x35, 0x31, 0x37, 0x39, 0x66, 0x30, 0x32, 0x65, 0x62, 0x62, 0x61, 0x35, 0x63, 0x39, 0x64, 0x31, 0x62, 0x35, 0x34, 0x66, 0x65, 0x63, 0x34, 0x64, 0x38, 0x38, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x37, 0x38, 0x30, 0x61, 0x62, 0x38, 0x37, 0x61, 0x39, 0x31, 0x34, 0x35, 0x66, 0x65, 0x31, 0x30, 0x65, 0x64, 0x36, 0x30, 0x66, 0x61, 0x34, 0x37, 0x36, 0x61, 0x37, 0x34, 0x30, 0x61, 0x66, 0x34, 0x63, 0x61, 0x62, 0x31, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x66, 0x36, 0x37, 0x36, 0x65, 0x32, 0x37, 0x66, 0x36, 0x38, 0x31, 0x61, 0x39, 0x38, 0x32, 0x64, 0x38, 0x66, 0x64, 0x39, 0x64, 0x32, 0x30, 0x65, 0x36, 0x34, 0x38, 0x62, 0x33, 0x64, 0x63, 0x65, 0x30, 0x35, 0x65, 0x39, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x36, 0x33, 0x66, 0x63, 0x38, 0x35, 0x30, 0x32, 0x39, 0x61, 0x32, 0x36, 0x35, 0x34, 0x64, 0x37, 0x39, 0x62, 0x32, 0x62, 0x65, 0x61, 0x34, 0x64, 0x65, 0x33, 0x34, 0x39, 0x65, 0x34, 0x35, 0x32, 0x34, 0x35, 0x37, 0x37, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x63, 0x30, 0x38, 0x39, 0x63, 0x33, 0x62, 0x63, 0x34, 0x64, 0x38, 0x32, 0x66, 0x30, 0x36, 0x61, 0x32, 0x30, 0x30, 0x35, 0x31, 0x61, 0x39, 0x64, 0x37, 0x33, 0x32, 0x64, 0x63, 0x30, 0x65, 0x37, 0x33, 0x34, 0x63, 0x62, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x66, 0x34, 0x34, 0x37, 0x39, 0x37, 0x39, 0x39, 0x65, 0x66, 0x38, 0x32, 0x65, 0x65, 0x61, 0x32, 0x30, 0x39, 0x34, 0x33, 0x33, 0x37, 0x34, 0x66, 0x35, 0x36, 0x61, 0x31, 0x62, 0x66, 0x35, 0x34, 0x30, 0x30, 0x31, 0x65, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x34, 0x31, 0x31, 0x36, 0x35, 0x32, 0x63, 0x38, 0x37, 0x31, 0x37, 0x31, 0x33, 0x36, 0x30, 0x39, 0x61, 0x66, 0x30, 0x30, 0x36, 0x32, 0x61, 0x38, 0x61, 0x31, 0x32, 0x38, 0x31, 0x62, 0x66, 0x31, 0x62, 0x62, 0x63, 0x66, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x62, 0x66, 0x61, 0x61, 0x35, 0x61, 0x34, 0x35, 0x63, 0x35, 0x30, 0x34, 0x34, 0x32, 0x38, 0x39, 0x32, 0x33, 0x63, 0x34, 0x61, 0x36, 0x31, 0x31, 0x39, 0x32, 0x61, 0x35, 0x35, 0x62, 0x31, 0x34, 0x30, 0x30, 0x62, 0x34, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x31, 0x66, 0x62, 0x64, 0x34, 0x65, 0x35, 0x38, 0x65, 0x32, 0x33, 0x31, 0x32, 0x62, 0x33, 0x63, 0x37, 0x38, 0x64, 0x37, 0x61, 0x61, 0x61, 0x61, 0x66, 0x61, 0x31, 0x30, 0x62, 0x66, 0x39, 0x63, 0x33, 0x31, 0x38, 0x39, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x32, 0x37, 0x63, 0x36, 0x61, 0x37, 0x66, 0x39, 0x31, 0x30, 0x37, 0x35, 0x34, 0x37, 0x35, 0x61, 0x62, 0x32, 0x32, 0x39, 0x36, 0x31, 0x39, 0x30, 0x34, 0x30, 0x66, 0x38, 0x30, 0x34, 0x63, 0x38, 0x65, 0x63, 0x37, 0x61, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x38, 0x64, 0x33, 0x31, 0x66, 0x61, 0x61, 0x38, 0x36, 0x34, 0x65, 0x32, 0x32, 0x31, 0x35, 0x39, 0x63, 0x64, 0x36, 0x66, 0x35, 0x31, 0x37, 0x35, 0x63, 0x63, 0x65, 0x63, 0x63, 0x35, 0x33, 0x66, 0x61, 0x35, 0x34, 0x64, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x64, 0x38, 0x65, 0x65, 0x65, 0x66, 0x38, 0x37, 0x31, 0x39, 0x34, 0x61, 0x62, 0x63, 0x32, 0x63, 0x65, 0x37, 0x35, 0x38, 0x35, 0x64, 0x61, 0x31, 0x65, 0x33, 0x35, 0x62, 0x37, 0x63, 0x65, 0x61, 0x37, 0x38, 0x30, 0x63, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x31, 0x38, 0x30, 0x31, 0x65, 0x37, 0x30, 0x62, 0x36, 0x32, 0x36, 0x32, 0x38, 0x36, 0x31, 0x62, 0x31, 0x31, 0x33, 0x34, 0x63, 0x63, 0x62, 0x63, 0x33, 0x39, 0x31, 0x66, 0x35, 0x36, 0x38, 0x61, 0x66, 0x63, 0x39, 0x32, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x30, 0x34, 0x32, 0x62, 0x38, 0x30, 0x66, 0x64, 0x36, 0x30, 0x39, 0x35, 0x64, 0x31, 0x62, 0x38, 0x37, 0x62, 0x65, 0x32, 0x66, 0x30, 0x30, 0x66, 0x31, 0x30, 0x39, 0x66, 0x61, 0x62, 0x61, 0x66, 0x64, 0x31, 0x35, 0x37, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x35, 0x35, 0x31, 0x38, 0x37, 0x31, 0x34, 0x63, 0x65, 0x66, 0x63, 0x33, 0x36, 0x64, 0x30, 0x34, 0x38, 0x36, 0x35, 0x64, 0x65, 0x35, 0x39, 0x31, 0x35, 0x65, 0x66, 0x30, 0x66, 0x66, 0x34, 0x37, 0x64, 0x66, 0x65, 0x37, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x61, 0x64, 0x64, 0x31, 0x65, 0x37, 0x38, 0x30, 0x39, 0x66, 0x37, 0x64, 0x30, 0x33, 0x30, 0x36, 0x39, 0x62, 0x66, 0x65, 0x38, 0x38, 0x33, 0x62, 0x30, 0x61, 0x39, 0x33, 0x32, 0x32, 0x31, 0x30, 0x62, 0x65, 0x38, 0x37, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x65, 0x32, 0x64, 0x34, 0x39, 0x38, 0x66, 0x37, 0x30, 0x64, 0x63, 0x64, 0x30, 0x38, 0x35, 0x39, 0x65, 0x35, 0x30, 0x62, 0x30, 0x32, 0x33, 0x61, 0x37, 0x31, 0x30, 0x61, 0x36, 0x64, 0x34, 0x62, 0x32, 0x31, 0x33, 0x33, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x37, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x64, 0x30, 0x34, 0x37, 0x66, 0x61, 0x65, 0x36, 0x37, 0x65, 0x66, 0x31, 0x36, 0x32, 0x66, 0x65, 0x36, 0x38, 0x66, 0x65, 0x64, 0x62, 0x63, 0x32, 0x37, 0x64, 0x33, 0x62, 0x36, 0x35, 0x63, 0x61, 0x66, 0x31, 0x30, 0x63, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x63, 0x62, 0x33, 0x65, 0x32, 0x31, 0x35, 0x33, 0x39, 0x39, 0x38, 0x64, 0x38, 0x36, 0x65, 0x35, 0x65, 0x65, 0x32, 0x30, 0x63, 0x31, 0x66, 0x63, 0x64, 0x31, 0x61, 0x36, 0x62, 0x61, 0x65, 0x65, 0x62, 0x32, 0x38, 0x36, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x33, 0x36, 0x33, 0x33, 0x30, 0x31, 0x30, 0x61, 0x38, 0x38, 0x36, 0x38, 0x36, 0x62, 0x65, 0x61, 0x35, 0x61, 0x39, 0x38, 0x65, 0x61, 0x35, 0x33, 0x65, 0x38, 0x37, 0x39, 0x39, 0x37, 0x63, 0x62, 0x66, 0x37, 0x33, 0x65, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x62, 0x31, 0x31, 0x65, 0x63, 0x62, 0x33, 0x32, 0x64, 0x33, 0x63, 0x65, 0x38, 0x32, 0x39, 0x36, 0x30, 0x31, 0x33, 0x31, 0x30, 0x36, 0x33, 0x36, 0x66, 0x35, 0x61, 0x31, 0x30, 0x63, 0x66, 0x37, 0x63, 0x66, 0x39, 0x62, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x36, 0x38, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x31, 0x33, 0x34, 0x35, 0x36, 0x39, 0x39, 0x36, 0x34, 0x30, 0x38, 0x61, 0x66, 0x31, 0x63, 0x32, 0x65, 0x39, 0x33, 0x65, 0x31, 0x37, 0x37, 0x37, 0x38, 0x38, 0x61, 0x62, 0x35, 0x35, 0x38, 0x39, 0x35, 0x65, 0x32, 0x62, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x30, 0x38, 0x65, 0x64, 0x30, 0x61, 0x66, 0x37, 0x66, 0x38, 0x61, 0x33, 0x63, 0x31, 0x37, 0x35, 0x31, 0x66, 0x61, 0x66, 0x63, 0x38, 0x37, 0x37, 0x62, 0x35, 0x61, 0x34, 0x32, 0x61, 0x66, 0x37, 0x64, 0x33, 0x35, 0x38, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x65, 0x64, 0x66, 0x38, 0x31, 0x32, 0x33, 0x66, 0x32, 0x34, 0x30, 0x33, 0x63, 0x65, 0x31, 0x61, 0x30, 0x32, 0x39, 0x39, 0x62, 0x65, 0x63, 0x66, 0x37, 0x61, 0x61, 0x63, 0x37, 0x34, 0x34, 0x64, 0x30, 0x37, 0x35, 0x66, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x36, 0x36, 0x35, 0x31, 0x35, 0x35, 0x63, 0x63, 0x34, 0x39, 0x63, 0x62, 0x66, 0x36, 0x61, 0x61, 0x62, 0x64, 0x64, 0x35, 0x61, 0x65, 0x39, 0x32, 0x63, 0x62, 0x66, 0x61, 0x61, 0x64, 0x38, 0x32, 0x62, 0x38, 0x63, 0x30, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x62, 0x32, 0x37, 0x37, 0x62, 0x30, 0x39, 0x39, 0x61, 0x38, 0x65, 0x38, 0x36, 0x36, 0x63, 0x61, 0x30, 0x65, 0x63, 0x36, 0x35, 0x62, 0x63, 0x62, 0x38, 0x37, 0x32, 0x38, 0x34, 0x66, 0x64, 0x31, 0x34, 0x32, 0x61, 0x35, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x39, 0x65, 0x30, 0x36, 0x38, 0x66, 0x63, 0x34, 0x36, 0x38, 0x30, 0x39, 0x37, 0x36, 0x65, 0x36, 0x31, 0x35, 0x30, 0x34, 0x39, 0x31, 0x32, 0x39, 0x38, 0x35, 0x66, 0x64, 0x35, 0x63, 0x65, 0x39, 0x34, 0x62, 0x61, 0x62, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x31, 0x33, 0x34, 0x65, 0x37, 0x66, 0x36, 0x62, 0x30, 0x31, 0x37, 0x62, 0x66, 0x34, 0x38, 0x65, 0x38, 0x35, 0x35, 0x61, 0x33, 0x39, 0x39, 0x63, 0x61, 0x35, 0x38, 0x65, 0x32, 0x65, 0x38, 0x39, 0x32, 0x66, 0x61, 0x35, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x66, 0x63, 0x65, 0x61, 0x35, 0x34, 0x32, 0x31, 0x65, 0x63, 0x31, 0x35, 0x39, 0x30, 0x30, 0x63, 0x36, 0x65, 0x63, 0x66, 0x63, 0x37, 0x37, 0x37, 0x31, 0x38, 0x34, 0x65, 0x31, 0x34, 0x30, 0x65, 0x32, 0x30, 0x39, 0x65, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x33, 0x32, 0x63, 0x30, 0x35, 0x31, 0x36, 0x61, 0x32, 0x65, 0x31, 0x37, 0x31, 0x37, 0x34, 0x61, 0x63, 0x35, 0x34, 0x37, 0x63, 0x34, 0x33, 0x62, 0x37, 0x62, 0x30, 0x30, 0x32, 0x30, 0x64, 0x31, 0x65, 0x62, 0x34, 0x63, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x39, 0x61, 0x35, 0x64, 0x61, 0x34, 0x36, 0x30, 0x33, 0x39, 0x32, 0x62, 0x39, 0x34, 0x30, 0x62, 0x33, 0x63, 0x36, 0x39, 0x62, 0x63, 0x30, 0x33, 0x37, 0x35, 0x37, 0x62, 0x66, 0x33, 0x66, 0x32, 0x65, 0x38, 0x32, 0x34, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x63, 0x38, 0x33, 0x33, 0x31, 0x65, 0x66, 0x65, 0x37, 0x31, 0x39, 0x38, 0x65, 0x39, 0x38, 0x62, 0x32, 0x64, 0x33, 0x32, 0x62, 0x39, 0x33, 0x38, 0x36, 0x38, 0x38, 0x65, 0x33, 0x32, 0x34, 0x31, 0x64, 0x30, 0x65, 0x32, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x63, 0x61, 0x32, 0x61, 0x30, 0x66, 0x66, 0x33, 0x34, 0x35, 0x38, 0x38, 0x61, 0x66, 0x36, 0x32, 0x35, 0x66, 0x61, 0x38, 0x65, 0x32, 0x38, 0x66, 0x63, 0x33, 0x30, 0x31, 0x35, 0x61, 0x62, 0x35, 0x61, 0x33, 0x61, 0x61, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x33, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x66, 0x63, 0x33, 0x34, 0x32, 0x64, 0x66, 0x66, 0x63, 0x66, 0x34, 0x35, 0x64, 0x66, 0x65, 0x65, 0x37, 0x34, 0x66, 0x38, 0x34, 0x63, 0x30, 0x39, 0x39, 0x35, 0x33, 0x39, 0x37, 0x62, 0x64, 0x31, 0x61, 0x36, 0x33, 0x31, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x30, 0x32, 0x35, 0x34, 0x37, 0x32, 0x34, 0x32, 0x38, 0x30, 0x36, 0x66, 0x36, 0x65, 0x37, 0x30, 0x65, 0x37, 0x34, 0x30, 0x35, 0x38, 0x64, 0x36, 0x65, 0x35, 0x32, 0x39, 0x32, 0x64, 0x65, 0x66, 0x63, 0x38, 0x63, 0x38, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x62, 0x63, 0x31, 0x33, 0x64, 0x30, 0x34, 0x61, 0x63, 0x63, 0x63, 0x30, 0x37, 0x30, 0x37, 0x61, 0x65, 0x62, 0x64, 0x63, 0x61, 0x65, 0x66, 0x30, 0x38, 0x37, 0x64, 0x30, 0x62, 0x38, 0x37, 0x65, 0x30, 0x62, 0x35, 0x65, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x35, 0x63, 0x62, 0x61, 0x38, 0x64, 0x33, 0x37, 0x34, 0x32, 0x37, 0x39, 0x38, 0x36, 0x65, 0x38, 0x63, 0x61, 0x32, 0x36, 0x30, 0x30, 0x65, 0x38, 0x35, 0x38, 0x62, 0x62, 0x30, 0x33, 0x63, 0x33, 0x35, 0x39, 0x35, 0x32, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x37, 0x34, 0x66, 0x61, 0x31, 0x62, 0x63, 0x31, 0x32, 0x61, 0x33, 0x62, 0x37, 0x31, 0x38, 0x33, 0x63, 0x62, 0x61, 0x62, 0x62, 0x37, 0x37, 0x61, 0x30, 0x62, 0x35, 0x39, 0x35, 0x35, 0x37, 0x62, 0x61, 0x35, 0x66, 0x31, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x62, 0x33, 0x61, 0x37, 0x63, 0x62, 0x35, 0x65, 0x36, 0x37, 0x32, 0x36, 0x34, 0x32, 0x37, 0x61, 0x33, 0x61, 0x33, 0x36, 0x31, 0x63, 0x66, 0x61, 0x38, 0x64, 0x36, 0x31, 0x36, 0x34, 0x64, 0x62, 0x64, 0x30, 0x62, 0x61, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x65, 0x36, 0x36, 0x31, 0x63, 0x39, 0x33, 0x39, 0x38, 0x36, 0x33, 0x61, 0x63, 0x63, 0x30, 0x34, 0x34, 0x65, 0x36, 0x66, 0x31, 0x37, 0x62, 0x35, 0x36, 0x39, 0x38, 0x63, 0x63, 0x65, 0x33, 0x37, 0x39, 0x65, 0x63, 0x33, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x62, 0x64, 0x35, 0x39, 0x30, 0x34, 0x30, 0x35, 0x39, 0x30, 0x39, 0x31, 0x64, 0x32, 0x66, 0x39, 0x65, 0x31, 0x32, 0x64, 0x36, 0x61, 0x32, 0x36, 0x61, 0x30, 0x31, 0x30, 0x63, 0x61, 0x32, 0x32, 0x61, 0x62, 0x31, 0x34, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x36, 0x36, 0x32, 0x36, 0x37, 0x32, 0x38, 0x61, 0x61, 0x61, 0x34, 0x63, 0x34, 0x66, 0x62, 0x33, 0x64, 0x33, 0x31, 0x63, 0x32, 0x36, 0x64, 0x66, 0x33, 0x61, 0x66, 0x33, 0x31, 0x30, 0x30, 0x38, 0x31, 0x37, 0x31, 0x30, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x62, 0x35, 0x64, 0x32, 0x63, 0x36, 0x37, 0x33, 0x62, 0x66, 0x62, 0x31, 0x64, 0x64, 0x63, 0x61, 0x31, 0x34, 0x31, 0x62, 0x39, 0x38, 0x39, 0x34, 0x66, 0x64, 0x36, 0x64, 0x33, 0x66, 0x30, 0x35, 0x64, 0x61, 0x36, 0x37, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x65, 0x33, 0x31, 0x61, 0x66, 0x64, 0x31, 0x38, 0x39, 0x61, 0x31, 0x33, 0x61, 0x37, 0x36, 0x66, 0x66, 0x36, 0x66, 0x65, 0x37, 0x33, 0x65, 0x61, 0x64, 0x39, 0x66, 0x37, 0x34, 0x62, 0x62, 0x35, 0x63, 0x34, 0x61, 0x36, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x30, 0x39, 0x31, 0x32, 0x36, 0x63, 0x38, 0x39, 0x31, 0x63, 0x34, 0x61, 0x38, 0x33, 0x30, 0x36, 0x38, 0x30, 0x35, 0x39, 0x66, 0x65, 0x30, 0x65, 0x31, 0x35, 0x37, 0x39, 0x36, 0x63, 0x34, 0x36, 0x36, 0x31, 0x61, 0x39, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x36, 0x66, 0x35, 0x38, 0x34, 0x33, 0x66, 0x36, 0x64, 0x32, 0x34, 0x63, 0x64, 0x39, 0x38, 0x64, 0x32, 0x35, 0x35, 0x65, 0x34, 0x63, 0x32, 0x33, 0x64, 0x31, 0x65, 0x31, 0x66, 0x30, 0x32, 0x33, 0x32, 0x32, 0x37, 0x35, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x35, 0x34, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x30, 0x63, 0x66, 0x32, 0x33, 0x64, 0x64, 0x39, 0x35, 0x63, 0x34, 0x64, 0x35, 0x35, 0x38, 0x61, 0x32, 0x37, 0x39, 0x64, 0x37, 0x37, 0x38, 0x64, 0x32, 0x62, 0x33, 0x37, 0x33, 0x35, 0x62, 0x33, 0x31, 0x36, 0x34, 0x31, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x35, 0x65, 0x63, 0x31, 0x38, 0x65, 0x38, 0x33, 0x31, 0x33, 0x38, 0x38, 0x37, 0x64, 0x66, 0x34, 0x36, 0x31, 0x64, 0x32, 0x39, 0x30, 0x32, 0x65, 0x38, 0x31, 0x65, 0x36, 0x37, 0x61, 0x38, 0x66, 0x31, 0x31, 0x33, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x61, 0x37, 0x66, 0x37, 0x37, 0x63, 0x33, 0x34, 0x38, 0x66, 0x39, 0x32, 0x61, 0x39, 0x66, 0x31, 0x31, 0x30, 0x30, 0x63, 0x36, 0x62, 0x64, 0x38, 0x32, 0x39, 0x61, 0x38, 0x61, 0x63, 0x36, 0x64, 0x37, 0x66, 0x63, 0x66, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x39, 0x30, 0x31, 0x32, 0x36, 0x38, 0x37, 0x30, 0x65, 0x30, 0x62, 0x64, 0x65, 0x38, 0x61, 0x36, 0x36, 0x33, 0x61, 0x62, 0x30, 0x34, 0x30, 0x61, 0x37, 0x32, 0x61, 0x35, 0x35, 0x37, 0x33, 0x64, 0x38, 0x64, 0x34, 0x31, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x30, 0x66, 0x61, 0x39, 0x33, 0x36, 0x37, 0x62, 0x64, 0x61, 0x35, 0x37, 0x64, 0x30, 0x64, 0x33, 0x32, 0x35, 0x33, 0x61, 0x30, 0x61, 0x38, 0x66, 0x66, 0x37, 0x36, 0x63, 0x65, 0x30, 0x62, 0x38, 0x65, 0x31, 0x39, 0x61, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x35, 0x62, 0x61, 0x39, 0x65, 0x33, 0x34, 0x63, 0x64, 0x35, 0x38, 0x64, 0x61, 0x35, 0x34, 0x63, 0x39, 0x61, 0x32, 0x37, 0x31, 0x32, 0x36, 0x36, 0x33, 0x61, 0x33, 0x62, 0x65, 0x32, 0x37, 0x34, 0x63, 0x38, 0x65, 0x34, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x38, 0x36, 0x34, 0x31, 0x64, 0x34, 0x33, 0x63, 0x34, 0x32, 0x30, 0x30, 0x33, 0x66, 0x30, 0x61, 0x33, 0x33, 0x63, 0x39, 0x32, 0x39, 0x66, 0x37, 0x31, 0x31, 0x30, 0x37, 0x39, 0x64, 0x65, 0x62, 0x32, 0x62, 0x39, 0x65, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x64, 0x39, 0x37, 0x36, 0x36, 0x34, 0x63, 0x63, 0x34, 0x65, 0x65, 0x63, 0x39, 0x65, 0x64, 0x62, 0x65, 0x37, 0x66, 0x61, 0x30, 0x39, 0x66, 0x34, 0x37, 0x35, 0x30, 0x61, 0x36, 0x36, 0x33, 0x62, 0x35, 0x30, 0x37, 0x64, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x35, 0x34, 0x30, 0x65, 0x39, 0x34, 0x63, 0x66, 0x66, 0x33, 0x34, 0x36, 0x35, 0x63, 0x63, 0x33, 0x64, 0x31, 0x38, 0x37, 0x65, 0x37, 0x63, 0x38, 0x65, 0x33, 0x62, 0x64, 0x61, 0x66, 0x39, 0x38, 0x34, 0x36, 0x35, 0x39, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x38, 0x39, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x36, 0x38, 0x38, 0x33, 0x35, 0x38, 0x32, 0x34, 0x35, 0x39, 0x39, 0x30, 0x38, 0x63, 0x38, 0x32, 0x37, 0x36, 0x32, 0x37, 0x65, 0x38, 0x36, 0x66, 0x32, 0x38, 0x65, 0x36, 0x34, 0x36, 0x66, 0x39, 0x63, 0x37, 0x66, 0x63, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x66, 0x65, 0x65, 0x64, 0x39, 0x39, 0x65, 0x38, 0x39, 0x31, 0x37, 0x63, 0x35, 0x63, 0x35, 0x34, 0x35, 0x38, 0x36, 0x33, 0x35, 0x66, 0x33, 0x36, 0x30, 0x33, 0x65, 0x63, 0x62, 0x37, 0x65, 0x38, 0x31, 0x37, 0x61, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x62, 0x31, 0x36, 0x30, 0x33, 0x65, 0x63, 0x36, 0x32, 0x62, 0x32, 0x30, 0x30, 0x32, 0x32, 0x30, 0x33, 0x33, 0x65, 0x65, 0x63, 0x34, 0x64, 0x36, 0x64, 0x36, 0x36, 0x35, 0x35, 0x61, 0x63, 0x32, 0x34, 0x61, 0x30, 0x31, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x38, 0x65, 0x31, 0x64, 0x63, 0x62, 0x33, 0x31, 0x34, 0x63, 0x39, 0x35, 0x30, 0x64, 0x33, 0x36, 0x38, 0x37, 0x34, 0x33, 0x34, 0x64, 0x33, 0x30, 0x39, 0x38, 0x35, 0x38, 0x65, 0x31, 0x61, 0x38, 0x37, 0x33, 0x39, 0x63, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x39, 0x32, 0x30, 0x36, 0x62, 0x61, 0x36, 0x62, 0x35, 0x34, 0x39, 0x61, 0x31, 0x61, 0x37, 0x66, 0x39, 0x36, 0x39, 0x65, 0x31, 0x64, 0x35, 0x64, 0x62, 0x61, 0x38, 0x36, 0x37, 0x35, 0x33, 0x39, 0x64, 0x31, 0x66, 0x61, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x31, 0x30, 0x31, 0x30, 0x64, 0x61, 0x34, 0x39, 0x32, 0x66, 0x34, 0x30, 0x31, 0x38, 0x38, 0x33, 0x33, 0x62, 0x30, 0x38, 0x38, 0x64, 0x39, 0x38, 0x37, 0x32, 0x39, 0x30, 0x31, 0x65, 0x30, 0x36, 0x31, 0x32, 0x39, 0x31, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x34, 0x33, 0x31, 0x38, 0x34, 0x63, 0x38, 0x30, 0x31, 0x65, 0x35, 0x64, 0x37, 0x39, 0x64, 0x32, 0x30, 0x36, 0x33, 0x66, 0x33, 0x35, 0x37, 0x38, 0x64, 0x62, 0x61, 0x65, 0x38, 0x31, 0x65, 0x37, 0x62, 0x33, 0x61, 0x39, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x61, 0x64, 0x61, 0x38, 0x63, 0x39, 0x32, 0x66, 0x35, 0x36, 0x30, 0x36, 0x37, 0x65, 0x31, 0x62, 0x62, 0x37, 0x33, 0x63, 0x65, 0x33, 0x37, 0x38, 0x64, 0x61, 0x35, 0x36, 0x64, 0x63, 0x32, 0x63, 0x64, 0x66, 0x64, 0x33, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x65, 0x61, 0x36, 0x62, 0x37, 0x38, 0x35, 0x35, 0x65, 0x30, 0x35, 0x62, 0x30, 0x37, 0x61, 0x62, 0x38, 0x30, 0x64, 0x61, 0x62, 0x31, 0x65, 0x31, 0x34, 0x64, 0x65, 0x39, 0x62, 0x36, 0x34, 0x39, 0x65, 0x39, 0x39, 0x62, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x30, 0x37, 0x31, 0x31, 0x65, 0x33, 0x31, 0x31, 0x62, 0x62, 0x39, 0x34, 0x37, 0x33, 0x35, 0x35, 0x66, 0x37, 0x35, 0x35, 0x62, 0x35, 0x37, 0x39, 0x32, 0x35, 0x30, 0x63, 0x61, 0x37, 0x66, 0x64, 0x37, 0x36, 0x35, 0x61, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x66, 0x62, 0x32, 0x36, 0x63, 0x33, 0x31, 0x65, 0x34, 0x38, 0x36, 0x34, 0x34, 0x64, 0x36, 0x39, 0x33, 0x31, 0x33, 0x34, 0x32, 0x30, 0x35, 0x63, 0x61, 0x65, 0x34, 0x33, 0x62, 0x32, 0x31, 0x66, 0x31, 0x38, 0x36, 0x31, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x31, 0x64, 0x31, 0x34, 0x38, 0x30, 0x34, 0x62, 0x33, 0x39, 0x39, 0x63, 0x36, 0x65, 0x66, 0x38, 0x30, 0x65, 0x36, 0x34, 0x35, 0x37, 0x36, 0x66, 0x36, 0x35, 0x37, 0x36, 0x36, 0x30, 0x38, 0x30, 0x34, 0x66, 0x65, 0x63, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x36, 0x34, 0x32, 0x30, 0x38, 0x36, 0x62, 0x31, 0x66, 0x62, 0x61, 0x65, 0x36, 0x31, 0x61, 0x36, 0x38, 0x30, 0x34, 0x64, 0x62, 0x65, 0x35, 0x66, 0x62, 0x31, 0x35, 0x65, 0x63, 0x32, 0x64, 0x32, 0x62, 0x35, 0x33, 0x37, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x31, 0x39, 0x64, 0x64, 0x35, 0x65, 0x35, 0x64, 0x66, 0x62, 0x31, 0x61, 0x66, 0x61, 0x34, 0x30, 0x34, 0x37, 0x30, 0x33, 0x62, 0x39, 0x66, 0x61, 0x65, 0x61, 0x38, 0x63, 0x65, 0x65, 0x33, 0x35, 0x64, 0x30, 0x30, 0x64, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x63, 0x34, 0x64, 0x61, 0x35, 0x31, 0x64, 0x32, 0x37, 0x38, 0x32, 0x32, 0x64, 0x31, 0x65, 0x32, 0x30, 0x38, 0x63, 0x39, 0x36, 0x65, 0x61, 0x36, 0x34, 0x61, 0x31, 0x65, 0x35, 0x62, 0x35, 0x35, 0x32, 0x39, 0x39, 0x37, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x64, 0x38, 0x65, 0x62, 0x61, 0x61, 0x37, 0x36, 0x37, 0x34, 0x62, 0x62, 0x31, 0x38, 0x65, 0x31, 0x39, 0x31, 0x39, 0x38, 0x64, 0x62, 0x32, 0x34, 0x34, 0x66, 0x35, 0x37, 0x30, 0x33, 0x31, 0x33, 0x30, 0x37, 0x35, 0x66, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x34, 0x65, 0x66, 0x30, 0x31, 0x32, 0x36, 0x35, 0x38, 0x64, 0x35, 0x34, 0x66, 0x38, 0x65, 0x38, 0x36, 0x30, 0x39, 0x63, 0x34, 0x65, 0x39, 0x30, 0x32, 0x33, 0x63, 0x30, 0x39, 0x66, 0x65, 0x38, 0x36, 0x35, 0x63, 0x38, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x62, 0x30, 0x37, 0x39, 0x62, 0x61, 0x66, 0x30, 0x37, 0x32, 0x37, 0x39, 0x39, 0x39, 0x65, 0x36, 0x36, 0x62, 0x66, 0x37, 0x34, 0x33, 0x64, 0x35, 0x62, 0x63, 0x62, 0x66, 0x37, 0x37, 0x36, 0x63, 0x33, 0x62, 0x30, 0x39, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x61, 0x63, 0x32, 0x36, 0x61, 0x64, 0x39, 0x32, 0x63, 0x62, 0x38, 0x35, 0x39, 0x62, 0x64, 0x35, 0x39, 0x30, 0x35, 0x64, 0x64, 0x63, 0x65, 0x34, 0x32, 0x36, 0x36, 0x61, 0x61, 0x30, 0x65, 0x63, 0x35, 0x30, 0x61, 0x39, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x63, 0x31, 0x64, 0x39, 0x66, 0x34, 0x30, 0x63, 0x36, 0x61, 0x62, 0x37, 0x66, 0x38, 0x61, 0x39, 0x32, 0x66, 0x63, 0x65, 0x32, 0x66, 0x64, 0x63, 0x65, 0x34, 0x37, 0x61, 0x35, 0x34, 0x61, 0x35, 0x38, 0x36, 0x63, 0x35, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x65, 0x39, 0x33, 0x30, 0x38, 0x32, 0x65, 0x34, 0x35, 0x31, 0x38, 0x37, 0x63, 0x32, 0x36, 0x31, 0x36, 0x30, 0x65, 0x36, 0x36, 0x37, 0x39, 0x32, 0x66, 0x35, 0x37, 0x66, 0x61, 0x64, 0x33, 0x35, 0x35, 0x31, 0x63, 0x37, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x61, 0x37, 0x36, 0x31, 0x33, 0x34, 0x34, 0x35, 0x61, 0x32, 0x31, 0x32, 0x39, 0x39, 0x61, 0x61, 0x37, 0x34, 0x66, 0x30, 0x61, 0x64, 0x37, 0x31, 0x34, 0x33, 0x31, 0x65, 0x63, 0x34, 0x33, 0x66, 0x62, 0x62, 0x31, 0x62, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x39, 0x61, 0x32, 0x36, 0x66, 0x64, 0x30, 0x61, 0x38, 0x62, 0x61, 0x31, 0x30, 0x66, 0x39, 0x37, 0x37, 0x64, 0x61, 0x34, 0x66, 0x37, 0x37, 0x63, 0x33, 0x31, 0x39, 0x30, 0x38, 0x64, 0x61, 0x62, 0x34, 0x61, 0x38, 0x30, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x32, 0x63, 0x32, 0x66, 0x39, 0x36, 0x61, 0x61, 0x30, 0x30, 0x63, 0x66, 0x38, 0x61, 0x32, 0x66, 0x32, 0x30, 0x35, 0x61, 0x62, 0x63, 0x66, 0x38, 0x39, 0x33, 0x37, 0x63, 0x30, 0x63, 0x37, 0x35, 0x66, 0x35, 0x64, 0x38, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x30, 0x34, 0x36, 0x63, 0x62, 0x33, 0x64, 0x63, 0x31, 0x64, 0x65, 0x64, 0x62, 0x64, 0x33, 0x36, 0x34, 0x35, 0x31, 0x34, 0x61, 0x32, 0x38, 0x34, 0x38, 0x65, 0x34, 0x34, 0x63, 0x31, 0x64, 0x65, 0x34, 0x65, 0x64, 0x31, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x63, 0x32, 0x65, 0x65, 0x39, 0x31, 0x61, 0x35, 0x30, 0x37, 0x35, 0x36, 0x64, 0x38, 0x63, 0x65, 0x39, 0x61, 0x62, 0x65, 0x65, 0x62, 0x37, 0x35, 0x38, 0x39, 0x64, 0x32, 0x32, 0x63, 0x36, 0x66, 0x65, 0x65, 0x35, 0x64, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x63, 0x31, 0x61, 0x61, 0x32, 0x32, 0x34, 0x34, 0x62, 0x39, 0x63, 0x38, 0x61, 0x39, 0x35, 0x37, 0x63, 0x61, 0x38, 0x66, 0x61, 0x63, 0x34, 0x33, 0x31, 0x62, 0x30, 0x35, 0x39, 0x35, 0x61, 0x33, 0x62, 0x38, 0x36, 0x38, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x66, 0x64, 0x30, 0x62, 0x61, 0x64, 0x65, 0x35, 0x66, 0x34, 0x65, 0x66, 0x37, 0x34, 0x37, 0x34, 0x64, 0x30, 0x35, 0x38, 0x62, 0x37, 0x66, 0x33, 0x64, 0x38, 0x35, 0x34, 0x63, 0x62, 0x31, 0x33, 0x30, 0x30, 0x35, 0x32, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x36, 0x34, 0x61, 0x33, 0x63, 0x37, 0x62, 0x34, 0x38, 0x31, 0x35, 0x35, 0x34, 0x34, 0x38, 0x63, 0x35, 0x34, 0x63, 0x38, 0x38, 0x63, 0x37, 0x30, 0x38, 0x66, 0x31, 0x36, 0x36, 0x37, 0x30, 0x39, 0x37, 0x33, 0x36, 0x64, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x64, 0x35, 0x33, 0x61, 0x65, 0x38, 0x39, 0x37, 0x35, 0x32, 0x36, 0x62, 0x31, 0x36, 0x37, 0x64, 0x33, 0x39, 0x66, 0x31, 0x37, 0x34, 0x34, 0x65, 0x66, 0x37, 0x63, 0x33, 0x64, 0x61, 0x35, 0x62, 0x33, 0x37, 0x61, 0x32, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x65, 0x31, 0x31, 0x31, 0x36, 0x37, 0x30, 0x62, 0x35, 0x36, 0x33, 0x63, 0x63, 0x64, 0x62, 0x65, 0x62, 0x63, 0x61, 0x35, 0x32, 0x33, 0x38, 0x34, 0x32, 0x39, 0x30, 0x65, 0x63, 0x64, 0x36, 0x38, 0x66, 0x65, 0x35, 0x63, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x64, 0x36, 0x37, 0x31, 0x64, 0x39, 0x39, 0x63, 0x62, 0x65, 0x61, 0x31, 0x61, 0x62, 0x35, 0x37, 0x39, 0x30, 0x36, 0x33, 0x37, 0x35, 0x62, 0x36, 0x33, 0x66, 0x66, 0x34, 0x32, 0x62, 0x35, 0x30, 0x34, 0x35, 0x31, 0x64, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x31, 0x37, 0x63, 0x63, 0x39, 0x33, 0x30, 0x31, 0x35, 0x31, 0x31, 0x64, 0x34, 0x61, 0x38, 0x31, 0x62, 0x39, 0x66, 0x35, 0x38, 0x33, 0x31, 0x34, 0x38, 0x62, 0x65, 0x65, 0x64, 0x33, 0x64, 0x33, 0x63, 0x63, 0x38, 0x33, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x39, 0x32, 0x38, 0x34, 0x34, 0x66, 0x32, 0x38, 0x32, 0x61, 0x39, 0x32, 0x39, 0x39, 0x39, 0x65, 0x65, 0x35, 0x62, 0x34, 0x61, 0x38, 0x64, 0x37, 0x37, 0x33, 0x64, 0x30, 0x36, 0x62, 0x36, 0x39, 0x34, 0x64, 0x62, 0x64, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x61, 0x36, 0x30, 0x36, 0x66, 0x34, 0x64, 0x64, 0x63, 0x62, 0x62, 0x39, 0x34, 0x37, 0x31, 0x65, 0x63, 0x36, 0x37, 0x66, 0x36, 0x35, 0x38, 0x63, 0x61, 0x66, 0x32, 0x62, 0x30, 0x30, 0x65, 0x65, 0x37, 0x33, 0x30, 0x32, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x62, 0x36, 0x30, 0x62, 0x38, 0x32, 0x33, 0x61, 0x31, 0x31, 0x37, 0x33, 0x64, 0x34, 0x35, 0x61, 0x30, 0x37, 0x39, 0x32, 0x32, 0x34, 0x35, 0x66, 0x62, 0x34, 0x39, 0x36, 0x66, 0x31, 0x66, 0x64, 0x33, 0x33, 0x30, 0x31, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x32, 0x36, 0x31, 0x35, 0x66, 0x38, 0x62, 0x36, 0x63, 0x61, 0x35, 0x30, 0x31, 0x32, 0x62, 0x36, 0x36, 0x33, 0x62, 0x64, 0x64, 0x30, 0x39, 0x34, 0x62, 0x30, 0x63, 0x35, 0x31, 0x33, 0x37, 0x63, 0x37, 0x37, 0x38, 0x64, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x66, 0x66, 0x37, 0x31, 0x36, 0x66, 0x64, 0x66, 0x30, 0x33, 0x33, 0x65, 0x63, 0x37, 0x65, 0x39, 0x34, 0x32, 0x63, 0x39, 0x30, 0x39, 0x64, 0x39, 0x38, 0x33, 0x31, 0x38, 0x36, 0x37, 0x62, 0x38, 0x62, 0x36, 0x65, 0x32, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x63, 0x31, 0x34, 0x37, 0x36, 0x35, 0x31, 0x32, 0x37, 0x63, 0x64, 0x65, 0x31, 0x31, 0x66, 0x61, 0x62, 0x34, 0x36, 0x63, 0x35, 0x64, 0x32, 0x63, 0x66, 0x34, 0x64, 0x34, 0x62, 0x32, 0x38, 0x39, 0x30, 0x30, 0x32, 0x33, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x32, 0x63, 0x62, 0x33, 0x30, 0x31, 0x32, 0x35, 0x38, 0x65, 0x39, 0x31, 0x62, 0x63, 0x30, 0x38, 0x39, 0x39, 0x38, 0x61, 0x38, 0x30, 0x35, 0x64, 0x64, 0x31, 0x39, 0x32, 0x66, 0x32, 0x35, 0x63, 0x32, 0x66, 0x39, 0x61, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x37, 0x33, 0x32, 0x63, 0x39, 0x37, 0x36, 0x35, 0x39, 0x33, 0x65, 0x65, 0x63, 0x34, 0x37, 0x38, 0x33, 0x62, 0x34, 0x65, 0x32, 0x65, 0x63, 0x64, 0x37, 0x39, 0x33, 0x39, 0x37, 0x39, 0x37, 0x38, 0x30, 0x62, 0x66, 0x65, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x66, 0x36, 0x32, 0x30, 0x33, 0x36, 0x66, 0x30, 0x33, 0x62, 0x37, 0x36, 0x33, 0x35, 0x62, 0x38, 0x35, 0x38, 0x66, 0x31, 0x31, 0x30, 0x33, 0x66, 0x38, 0x61, 0x31, 0x64, 0x39, 0x30, 0x31, 0x39, 0x61, 0x38, 0x39, 0x32, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x30, 0x36, 0x66, 0x61, 0x64, 0x37, 0x64, 0x63, 0x64, 0x37, 0x61, 0x34, 0x39, 0x32, 0x63, 0x62, 0x63, 0x30, 0x35, 0x33, 0x65, 0x65, 0x61, 0x62, 0x64, 0x65, 0x36, 0x39, 0x33, 0x34, 0x62, 0x33, 0x39, 0x64, 0x38, 0x36, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x66, 0x32, 0x62, 0x62, 0x37, 0x38, 0x62, 0x38, 0x64, 0x33, 0x65, 0x31, 0x31, 0x66, 0x37, 0x63, 0x34, 0x35, 0x38, 0x61, 0x31, 0x30, 0x62, 0x35, 0x63, 0x38, 0x65, 0x30, 0x61, 0x31, 0x64, 0x33, 0x37, 0x34, 0x34, 0x36, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x35, 0x63, 0x64, 0x62, 0x31, 0x65, 0x34, 0x32, 0x38, 0x63, 0x39, 0x31, 0x64, 0x64, 0x37, 0x63, 0x62, 0x35, 0x34, 0x61, 0x36, 0x61, 0x65, 0x64, 0x34, 0x35, 0x37, 0x31, 0x64, 0x61, 0x30, 0x35, 0x34, 0x62, 0x66, 0x65, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x35, 0x35, 0x37, 0x64, 0x33, 0x39, 0x62, 0x35, 0x34, 0x31, 0x31, 0x62, 0x38, 0x34, 0x34, 0x34, 0x35, 0x66, 0x35, 0x66, 0x35, 0x34, 0x66, 0x33, 0x38, 0x66, 0x36, 0x32, 0x64, 0x32, 0x37, 0x31, 0x34, 0x64, 0x30, 0x30, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x30, 0x65, 0x30, 0x35, 0x35, 0x62, 0x32, 0x38, 0x63, 0x62, 0x64, 0x30, 0x33, 0x64, 0x63, 0x35, 0x66, 0x66, 0x34, 0x34, 0x61, 0x61, 0x36, 0x34, 0x66, 0x33, 0x64, 0x63, 0x65, 0x30, 0x34, 0x66, 0x35, 0x65, 0x36, 0x33, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x32, 0x62, 0x65, 0x37, 0x66, 0x35, 0x36, 0x37, 0x35, 0x34, 0x66, 0x35, 0x30, 0x35, 0x65, 0x33, 0x34, 0x34, 0x31, 0x61, 0x31, 0x30, 0x66, 0x37, 0x66, 0x30, 0x65, 0x32, 0x30, 0x66, 0x64, 0x33, 0x64, 0x64, 0x66, 0x38, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x39, 0x33, 0x66, 0x63, 0x61, 0x34, 0x61, 0x34, 0x66, 0x30, 0x39, 0x63, 0x61, 0x63, 0x32, 0x30, 0x64, 0x62, 0x36, 0x30, 0x65, 0x30, 0x36, 0x35, 0x65, 0x64, 0x63, 0x63, 0x63, 0x63, 0x31, 0x31, 0x65, 0x30, 0x61, 0x35, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x63, 0x38, 0x35, 0x64, 0x36, 0x63, 0x37, 0x33, 0x35, 0x62, 0x39, 0x63, 0x64, 0x61, 0x34, 0x62, 0x62, 0x61, 0x35, 0x66, 0x34, 0x38, 0x62, 0x32, 0x34, 0x62, 0x31, 0x33, 0x65, 0x37, 0x30, 0x36, 0x33, 0x30, 0x33, 0x30, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x31, 0x30, 0x32, 0x33, 0x35, 0x34, 0x61, 0x36, 0x61, 0x63, 0x61, 0x39, 0x35, 0x64, 0x38, 0x61, 0x32, 0x65, 0x38, 0x36, 0x64, 0x35, 0x64, 0x65, 0x62, 0x64, 0x61, 0x36, 0x64, 0x65, 0x36, 0x39, 0x33, 0x34, 0x36, 0x30, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x61, 0x34, 0x35, 0x33, 0x30, 0x66, 0x34, 0x62, 0x39, 0x62, 0x63, 0x35, 0x30, 0x39, 0x30, 0x35, 0x62, 0x37, 0x39, 0x64, 0x31, 0x37, 0x63, 0x32, 0x38, 0x66, 0x63, 0x34, 0x36, 0x66, 0x39, 0x35, 0x33, 0x34, 0x39, 0x62, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x35, 0x34, 0x35, 0x62, 0x62, 0x62, 0x36, 0x36, 0x66, 0x62, 0x64, 0x30, 0x30, 0x65, 0x62, 0x35, 0x65, 0x36, 0x33, 0x37, 0x33, 0x66, 0x66, 0x34, 0x65, 0x33, 0x32, 0x36, 0x66, 0x35, 0x66, 0x65, 0x62, 0x35, 0x66, 0x65, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x33, 0x30, 0x61, 0x39, 0x32, 0x35, 0x37, 0x30, 0x36, 0x62, 0x32, 0x63, 0x31, 0x30, 0x31, 0x63, 0x38, 0x63, 0x35, 0x63, 0x62, 0x39, 0x62, 0x64, 0x30, 0x35, 0x66, 0x62, 0x62, 0x34, 0x66, 0x36, 0x37, 0x35, 0x39, 0x62, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x31, 0x65, 0x30, 0x31, 0x63, 0x37, 0x61, 0x39, 0x64, 0x31, 0x32, 0x34, 0x39, 0x39, 0x30, 0x30, 0x35, 0x66, 0x34, 0x64, 0x61, 0x65, 0x37, 0x37, 0x31, 0x36, 0x30, 0x39, 0x35, 0x61, 0x33, 0x34, 0x31, 0x37, 0x36, 0x32, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x38, 0x32, 0x36, 0x62, 0x36, 0x63, 0x33, 0x38, 0x38, 0x32, 0x66, 0x61, 0x64, 0x30, 0x65, 0x64, 0x35, 0x63, 0x38, 0x66, 0x62, 0x62, 0x32, 0x35, 0x63, 0x63, 0x34, 0x30, 0x63, 0x63, 0x34, 0x66, 0x33, 0x33, 0x37, 0x35, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x35, 0x31, 0x30, 0x65, 0x36, 0x65, 0x66, 0x66, 0x31, 0x66, 0x63, 0x38, 0x32, 0x39, 0x62, 0x36, 0x35, 0x37, 0x36, 0x66, 0x34, 0x33, 0x32, 0x38, 0x62, 0x63, 0x33, 0x39, 0x33, 0x38, 0x65, 0x63, 0x37, 0x61, 0x36, 0x35, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x65, 0x35, 0x33, 0x36, 0x33, 0x62, 0x31, 0x33, 0x65, 0x38, 0x32, 0x33, 0x38, 0x61, 0x61, 0x34, 0x64, 0x64, 0x31, 0x35, 0x61, 0x63, 0x64, 0x30, 0x62, 0x32, 0x65, 0x38, 0x61, 0x66, 0x65, 0x30, 0x38, 0x37, 0x33, 0x32, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x37, 0x62, 0x63, 0x38, 0x34, 0x61, 0x62, 0x64, 0x34, 0x37, 0x63, 0x30, 0x35, 0x62, 0x62, 0x66, 0x34, 0x35, 0x37, 0x62, 0x32, 0x65, 0x66, 0x36, 0x35, 0x39, 0x64, 0x36, 0x31, 0x63, 0x61, 0x35, 0x65, 0x35, 0x65, 0x34, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x37, 0x31, 0x39, 0x30, 0x36, 0x31, 0x66, 0x35, 0x32, 0x38, 0x35, 0x34, 0x39, 0x35, 0x62, 0x33, 0x37, 0x62, 0x39, 0x64, 0x37, 0x65, 0x66, 0x38, 0x61, 0x35, 0x31, 0x62, 0x30, 0x37, 0x64, 0x36, 0x65, 0x36, 0x61, 0x63, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x37, 0x31, 0x34, 0x35, 0x32, 0x32, 0x66, 0x61, 0x32, 0x38, 0x33, 0x39, 0x36, 0x32, 0x30, 0x34, 0x37, 0x30, 0x65, 0x64, 0x63, 0x66, 0x30, 0x63, 0x34, 0x34, 0x30, 0x31, 0x62, 0x37, 0x31, 0x33, 0x36, 0x36, 0x33, 0x64, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x64, 0x65, 0x63, 0x66, 0x38, 0x32, 0x39, 0x36, 0x39, 0x38, 0x31, 0x39, 0x62, 0x61, 0x30, 0x32, 0x64, 0x65, 0x32, 0x39, 0x62, 0x39, 0x62, 0x35, 0x39, 0x33, 0x66, 0x32, 0x31, 0x62, 0x36, 0x34, 0x65, 0x65, 0x64, 0x61, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x37, 0x64, 0x33, 0x61, 0x65, 0x33, 0x64, 0x38, 0x38, 0x37, 0x30, 0x34, 0x64, 0x39, 0x61, 0x62, 0x30, 0x30, 0x30, 0x39, 0x64, 0x63, 0x63, 0x31, 0x61, 0x30, 0x30, 0x36, 0x37, 0x31, 0x33, 0x31, 0x66, 0x38, 0x62, 0x61, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x63, 0x62, 0x33, 0x37, 0x30, 0x65, 0x64, 0x36, 0x38, 0x61, 0x61, 0x39, 0x32, 0x32, 0x32, 0x38, 0x33, 0x30, 0x34, 0x33, 0x65, 0x66, 0x37, 0x63, 0x61, 0x64, 0x31, 0x62, 0x39, 0x64, 0x34, 0x30, 0x33, 0x66, 0x63, 0x33, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x35, 0x33, 0x32, 0x64, 0x66, 0x34, 0x63, 0x36, 0x33, 0x39, 0x31, 0x31, 0x64, 0x31, 0x63, 0x65, 0x39, 0x31, 0x66, 0x36, 0x64, 0x31, 0x66, 0x63, 0x62, 0x66, 0x66, 0x37, 0x39, 0x36, 0x30, 0x66, 0x37, 0x38, 0x61, 0x38, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x36, 0x39, 0x38, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x63, 0x66, 0x64, 0x31, 0x64, 0x35, 0x37, 0x66, 0x38, 0x37, 0x32, 0x32, 0x39, 0x30, 0x35, 0x36, 0x30, 0x63, 0x62, 0x36, 0x32, 0x64, 0x36, 0x30, 0x30, 0x65, 0x31, 0x64, 0x65, 0x66, 0x62, 0x65, 0x66, 0x63, 0x63, 0x63, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x65, 0x32, 0x37, 0x65, 0x62, 0x30, 0x37, 0x64, 0x66, 0x63, 0x37, 0x31, 0x61, 0x37, 0x30, 0x36, 0x30, 0x36, 0x30, 0x63, 0x37, 0x66, 0x30, 0x37, 0x39, 0x32, 0x33, 0x38, 0x63, 0x61, 0x39, 0x33, 0x65, 0x38, 0x38, 0x35, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x37, 0x37, 0x33, 0x32, 0x66, 0x30, 0x32, 0x66, 0x32, 0x65, 0x32, 0x37, 0x32, 0x65, 0x61, 0x66, 0x32, 0x38, 0x64, 0x66, 0x39, 0x37, 0x32, 0x65, 0x63, 0x63, 0x30, 0x64, 0x64, 0x65, 0x65, 0x64, 0x39, 0x63, 0x66, 0x34, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x35, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x30, 0x39, 0x64, 0x37, 0x37, 0x30, 0x34, 0x38, 0x65, 0x32, 0x37, 0x30, 0x62, 0x36, 0x36, 0x32, 0x33, 0x33, 0x30, 0x65, 0x39, 0x34, 0x38, 0x36, 0x62, 0x33, 0x38, 0x62, 0x34, 0x33, 0x63, 0x64, 0x37, 0x38, 0x31, 0x34, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x39, 0x66, 0x31, 0x37, 0x31, 0x34, 0x34, 0x35, 0x64, 0x34, 0x32, 0x62, 0x30, 0x32, 0x65, 0x32, 0x65, 0x30, 0x37, 0x30, 0x30, 0x34, 0x61, 0x64, 0x38, 0x61, 0x66, 0x65, 0x36, 0x39, 0x34, 0x66, 0x61, 0x35, 0x33, 0x64, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x64, 0x64, 0x30, 0x33, 0x62, 0x65, 0x62, 0x62, 0x65, 0x65, 0x32, 0x37, 0x33, 0x62, 0x36, 0x63, 0x61, 0x31, 0x30, 0x35, 0x39, 0x62, 0x33, 0x34, 0x39, 0x39, 0x39, 0x61, 0x35, 0x62, 0x62, 0x64, 0x36, 0x31, 0x62, 0x62, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x61, 0x31, 0x64, 0x33, 0x35, 0x39, 0x62, 0x61, 0x36, 0x63, 0x62, 0x34, 0x62, 0x63, 0x63, 0x35, 0x37, 0x64, 0x37, 0x61, 0x34, 0x33, 0x37, 0x37, 0x32, 0x30, 0x64, 0x35, 0x35, 0x64, 0x62, 0x32, 0x66, 0x30, 0x31, 0x63, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x39, 0x33, 0x35, 0x37, 0x39, 0x33, 0x66, 0x34, 0x35, 0x62, 0x37, 0x30, 0x64, 0x38, 0x30, 0x34, 0x35, 0x64, 0x32, 0x36, 0x35, 0x34, 0x64, 0x38, 0x64, 0x64, 0x33, 0x61, 0x64, 0x32, 0x34, 0x62, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x37, 0x31, 0x37, 0x39, 0x33, 0x65, 0x33, 0x61, 0x63, 0x66, 0x31, 0x32, 0x61, 0x37, 0x32, 0x37, 0x34, 0x66, 0x35, 0x36, 0x33, 0x39, 0x36, 0x31, 0x66, 0x35, 0x33, 0x37, 0x35, 0x32, 0x39, 0x64, 0x38, 0x39, 0x63, 0x37, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x66, 0x30, 0x35, 0x64, 0x31, 0x39, 0x30, 0x36, 0x33, 0x65, 0x39, 0x33, 0x36, 0x39, 0x63, 0x36, 0x30, 0x30, 0x34, 0x65, 0x62, 0x33, 0x66, 0x31, 0x32, 0x33, 0x39, 0x34, 0x33, 0x61, 0x37, 0x63, 0x66, 0x66, 0x34, 0x65, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x62, 0x31, 0x30, 0x66, 0x39, 0x63, 0x32, 0x38, 0x30, 0x30, 0x39, 0x38, 0x31, 0x37, 0x39, 0x61, 0x32, 0x62, 0x37, 0x36, 0x65, 0x39, 0x63, 0x65, 0x39, 0x30, 0x62, 0x65, 0x36, 0x31, 0x66, 0x63, 0x38, 0x34, 0x34, 0x64, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x33, 0x63, 0x38, 0x34, 0x64, 0x31, 0x32, 0x34, 0x32, 0x30, 0x35, 0x37, 0x30, 0x63, 0x63, 0x34, 0x65, 0x66, 0x33, 0x62, 0x61, 0x62, 0x61, 0x31, 0x63, 0x39, 0x35, 0x39, 0x63, 0x32, 0x38, 0x33, 0x32, 0x34, 0x39, 0x35, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x63, 0x38, 0x35, 0x61, 0x63, 0x64, 0x35, 0x39, 0x32, 0x38, 0x37, 0x32, 0x32, 0x65, 0x66, 0x35, 0x30, 0x39, 0x35, 0x33, 0x33, 0x31, 0x65, 0x65, 0x38, 0x38, 0x66, 0x34, 0x38, 0x34, 0x62, 0x38, 0x63, 0x66, 0x38, 0x33, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x36, 0x31, 0x61, 0x31, 0x33, 0x38, 0x64, 0x63, 0x66, 0x38, 0x33, 0x62, 0x64, 0x38, 0x31, 0x33, 0x65, 0x30, 0x65, 0x37, 0x66, 0x31, 0x30, 0x38, 0x36, 0x34, 0x32, 0x62, 0x65, 0x33, 0x64, 0x65, 0x33, 0x64, 0x36, 0x66, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x30, 0x33, 0x35, 0x30, 0x65, 0x34, 0x30, 0x62, 0x33, 0x33, 0x38, 0x64, 0x64, 0x61, 0x37, 0x33, 0x36, 0x36, 0x36, 0x31, 0x38, 0x37, 0x32, 0x62, 0x65, 0x33, 0x33, 0x66, 0x31, 0x66, 0x39, 0x37, 0x35, 0x32, 0x64, 0x37, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x64, 0x63, 0x39, 0x33, 0x34, 0x39, 0x63, 0x62, 0x35, 0x32, 0x65, 0x31, 0x36, 0x31, 0x31, 0x39, 0x36, 0x31, 0x32, 0x32, 0x63, 0x66, 0x38, 0x37, 0x61, 0x33, 0x38, 0x39, 0x33, 0x36, 0x65, 0x32, 0x63, 0x35, 0x37, 0x66, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x61, 0x38, 0x63, 0x30, 0x65, 0x66, 0x62, 0x38, 0x62, 0x63, 0x64, 0x31, 0x35, 0x63, 0x35, 0x34, 0x33, 0x65, 0x32, 0x61, 0x36, 0x61, 0x34, 0x66, 0x38, 0x30, 0x37, 0x35, 0x39, 0x37, 0x36, 0x33, 0x31, 0x61, 0x64, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x31, 0x33, 0x64, 0x30, 0x63, 0x66, 0x37, 0x38, 0x63, 0x30, 0x30, 0x31, 0x38, 0x39, 0x38, 0x61, 0x33, 0x37, 0x38, 0x62, 0x39, 0x31, 0x38, 0x63, 0x64, 0x36, 0x65, 0x34, 0x39, 0x38, 0x65, 0x61, 0x37, 0x37, 0x33, 0x63, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x30, 0x38, 0x65, 0x35, 0x39, 0x64, 0x65, 0x36, 0x62, 0x34, 0x30, 0x35, 0x35, 0x30, 0x38, 0x38, 0x37, 0x38, 0x32, 0x39, 0x30, 0x32, 0x65, 0x30, 0x35, 0x37, 0x39, 0x63, 0x37, 0x32, 0x30, 0x31, 0x61, 0x38, 0x62, 0x66, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x39, 0x66, 0x63, 0x36, 0x64, 0x36, 0x38, 0x61, 0x34, 0x37, 0x37, 0x35, 0x35, 0x37, 0x33, 0x63, 0x31, 0x64, 0x63, 0x64, 0x61, 0x65, 0x63, 0x38, 0x33, 0x30, 0x66, 0x65, 0x66, 0x64, 0x35, 0x30, 0x33, 0x39, 0x37, 0x63, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x39, 0x61, 0x37, 0x66, 0x37, 0x35, 0x35, 0x61, 0x38, 0x31, 0x61, 0x31, 0x37, 0x65, 0x64, 0x62, 0x37, 0x64, 0x61, 0x61, 0x61, 0x32, 0x38, 0x61, 0x66, 0x63, 0x36, 0x36, 0x35, 0x64, 0x66, 0x61, 0x36, 0x62, 0x65, 0x36, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x30, 0x61, 0x32, 0x33, 0x30, 0x65, 0x34, 0x34, 0x36, 0x35, 0x30, 0x37, 0x37, 0x65, 0x30, 0x62, 0x31, 0x34, 0x65, 0x65, 0x34, 0x34, 0x34, 0x32, 0x61, 0x34, 0x38, 0x32, 0x64, 0x35, 0x62, 0x30, 0x63, 0x39, 0x31, 0x34, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x37, 0x39, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x61, 0x61, 0x30, 0x31, 0x63, 0x65, 0x62, 0x37, 0x30, 0x65, 0x61, 0x66, 0x39, 0x35, 0x39, 0x31, 0x66, 0x61, 0x35, 0x32, 0x31, 0x62, 0x61, 0x34, 0x61, 0x32, 0x37, 0x65, 0x61, 0x39, 0x66, 0x62, 0x38, 0x65, 0x64, 0x65, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x33, 0x61, 0x31, 0x65, 0x34, 0x35, 0x66, 0x36, 0x37, 0x65, 0x39, 0x32, 0x63, 0x38, 0x38, 0x30, 0x65, 0x35, 0x37, 0x33, 0x62, 0x34, 0x33, 0x33, 0x37, 0x39, 0x64, 0x37, 0x31, 0x65, 0x65, 0x30, 0x38, 0x39, 0x64, 0x62, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x36, 0x34, 0x33, 0x62, 0x61, 0x62, 0x65, 0x61, 0x36, 0x30, 0x31, 0x31, 0x33, 0x31, 0x36, 0x63, 0x63, 0x37, 0x39, 0x37, 0x64, 0x39, 0x62, 0x30, 0x39, 0x33, 0x63, 0x38, 0x39, 0x37, 0x61, 0x31, 0x37, 0x62, 0x64, 0x61, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x36, 0x37, 0x35, 0x65, 0x39, 0x31, 0x37, 0x37, 0x37, 0x32, 0x36, 0x64, 0x34, 0x35, 0x65, 0x61, 0x61, 0x34, 0x36, 0x62, 0x33, 0x39, 0x39, 0x32, 0x61, 0x33, 0x34, 0x30, 0x62, 0x61, 0x37, 0x66, 0x37, 0x31, 0x30, 0x63, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x38, 0x33, 0x34, 0x36, 0x31, 0x62, 0x61, 0x32, 0x32, 0x34, 0x62, 0x62, 0x31, 0x65, 0x38, 0x66, 0x64, 0x64, 0x39, 0x64, 0x61, 0x65, 0x35, 0x33, 0x35, 0x31, 0x37, 0x32, 0x62, 0x37, 0x33, 0x35, 0x61, 0x63, 0x62, 0x34, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x61, 0x61, 0x33, 0x62, 0x31, 0x65, 0x62, 0x65, 0x38, 0x63, 0x34, 0x64, 0x62, 0x63, 0x62, 0x36, 0x61, 0x37, 0x30, 0x38, 0x62, 0x31, 0x64, 0x37, 0x34, 0x38, 0x33, 0x31, 0x65, 0x36, 0x30, 0x65, 0x34, 0x39, 0x37, 0x36, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x32, 0x63, 0x66, 0x37, 0x64, 0x64, 0x65, 0x32, 0x30, 0x63, 0x33, 0x64, 0x64, 0x35, 0x36, 0x37, 0x39, 0x66, 0x66, 0x35, 0x65, 0x33, 0x32, 0x35, 0x38, 0x34, 0x35, 0x63, 0x37, 0x30, 0x63, 0x35, 0x39, 0x36, 0x32, 0x36, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x30, 0x37, 0x66, 0x30, 0x62, 0x64, 0x62, 0x36, 0x65, 0x37, 0x30, 0x30, 0x39, 0x32, 0x30, 0x32, 0x62, 0x37, 0x61, 0x66, 0x33, 0x65, 0x61, 0x39, 0x30, 0x39, 0x30, 0x32, 0x36, 0x39, 0x37, 0x63, 0x37, 0x32, 0x31, 0x34, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x39, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x63, 0x36, 0x34, 0x30, 0x30, 0x34, 0x61, 0x39, 0x61, 0x38, 0x32, 0x36, 0x65, 0x39, 0x34, 0x65, 0x35, 0x65, 0x34, 0x65, 0x65, 0x32, 0x36, 0x37, 0x66, 0x61, 0x32, 0x61, 0x37, 0x36, 0x33, 0x32, 0x64, 0x64, 0x34, 0x65, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x39, 0x31, 0x39, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x32, 0x32, 0x65, 0x35, 0x38, 0x34, 0x61, 0x36, 0x36, 0x32, 0x33, 0x65, 0x61, 0x61, 0x66, 0x39, 0x39, 0x66, 0x32, 0x62, 0x65, 0x34, 0x39, 0x65, 0x35, 0x33, 0x38, 0x30, 0x63, 0x35, 0x63, 0x62, 0x63, 0x66, 0x35, 0x63, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x63, 0x31, 0x30, 0x66, 0x61, 0x33, 0x38, 0x66, 0x39, 0x66, 0x62, 0x30, 0x36, 0x38, 0x31, 0x30, 0x65, 0x31, 0x31, 0x66, 0x36, 0x30, 0x31, 0x37, 0x33, 0x65, 0x63, 0x33, 0x64, 0x32, 0x66, 0x64, 0x36, 0x61, 0x37, 0x35, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x33, 0x63, 0x33, 0x31, 0x30, 0x37, 0x66, 0x34, 0x62, 0x61, 0x63, 0x65, 0x34, 0x31, 0x34, 0x65, 0x34, 0x39, 0x39, 0x63, 0x36, 0x34, 0x33, 0x39, 0x30, 0x61, 0x35, 0x31, 0x66, 0x37, 0x34, 0x36, 0x31, 0x35, 0x63, 0x61, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x34, 0x33, 0x38, 0x65, 0x35, 0x32, 0x30, 0x33, 0x62, 0x36, 0x33, 0x34, 0x36, 0x66, 0x66, 0x38, 0x38, 0x36, 0x64, 0x37, 0x63, 0x33, 0x36, 0x32, 0x38, 0x38, 0x61, 0x61, 0x63, 0x63, 0x63, 0x63, 0x37, 0x38, 0x63, 0x65, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x66, 0x30, 0x37, 0x64, 0x39, 0x37, 0x63, 0x33, 0x34, 0x38, 0x31, 0x66, 0x39, 0x64, 0x36, 0x61, 0x65, 0x65, 0x31, 0x63, 0x39, 0x38, 0x66, 0x39, 0x64, 0x39, 0x31, 0x61, 0x31, 0x38, 0x30, 0x61, 0x33, 0x32, 0x34, 0x34, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x61, 0x61, 0x35, 0x64, 0x33, 0x31, 0x33, 0x65, 0x62, 0x62, 0x30, 0x38, 0x34, 0x64, 0x61, 0x30, 0x65, 0x37, 0x38, 0x30, 0x31, 0x30, 0x39, 0x31, 0x65, 0x32, 0x39, 0x65, 0x39, 0x32, 0x63, 0x35, 0x64, 0x65, 0x63, 0x33, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x63, 0x34, 0x33, 0x33, 0x64, 0x36, 0x30, 0x31, 0x66, 0x61, 0x64, 0x37, 0x31, 0x34, 0x64, 0x61, 0x36, 0x33, 0x36, 0x39, 0x33, 0x30, 0x38, 0x66, 0x64, 0x32, 0x36, 0x63, 0x31, 0x64, 0x63, 0x39, 0x39, 0x34, 0x32, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x31, 0x30, 0x36, 0x61, 0x62, 0x36, 0x37, 0x35, 0x35, 0x64, 0x66, 0x38, 0x36, 0x64, 0x36, 0x62, 0x36, 0x33, 0x61, 0x31, 0x38, 0x37, 0x37, 0x30, 0x33, 0x62, 0x30, 0x63, 0x66, 0x65, 0x61, 0x30, 0x65, 0x35, 0x39, 0x34, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x34, 0x32, 0x35, 0x36, 0x65, 0x39, 0x39, 0x62, 0x30, 0x66, 0x39, 0x63, 0x64, 0x36, 0x65, 0x35, 0x65, 0x62, 0x63, 0x61, 0x33, 0x38, 0x39, 0x39, 0x38, 0x36, 0x33, 0x32, 0x35, 0x32, 0x39, 0x30, 0x30, 0x31, 0x36, 0x35, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x34, 0x61, 0x63, 0x65, 0x34, 0x63, 0x31, 0x63, 0x63, 0x31, 0x33, 0x33, 0x39, 0x31, 0x65, 0x30, 0x31, 0x66, 0x30, 0x30, 0x62, 0x31, 0x39, 0x38, 0x65, 0x31, 0x66, 0x32, 0x30, 0x62, 0x35, 0x66, 0x39, 0x31, 0x63, 0x62, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x35, 0x63, 0x65, 0x63, 0x64, 0x39, 0x35, 0x35, 0x65, 0x35, 0x37, 0x39, 0x38, 0x33, 0x37, 0x30, 0x37, 0x36, 0x39, 0x32, 0x33, 0x30, 0x31, 0x35, 0x39, 0x33, 0x30, 0x33, 0x64, 0x39, 0x62, 0x31, 0x38, 0x33, 0x39, 0x66, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x64, 0x38, 0x31, 0x65, 0x63, 0x33, 0x35, 0x33, 0x33, 0x66, 0x66, 0x31, 0x62, 0x66, 0x65, 0x62, 0x66, 0x33, 0x65, 0x33, 0x38, 0x34, 0x33, 0x65, 0x65, 0x37, 0x34, 0x30, 0x61, 0x64, 0x31, 0x31, 0x37, 0x35, 0x38, 0x64, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x38, 0x65, 0x62, 0x33, 0x38, 0x35, 0x33, 0x62, 0x62, 0x63, 0x63, 0x35, 0x30, 0x65, 0x63, 0x66, 0x65, 0x65, 0x30, 0x66, 0x61, 0x38, 0x37, 0x66, 0x30, 0x61, 0x62, 0x36, 0x39, 0x33, 0x63, 0x61, 0x62, 0x64, 0x65, 0x66, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x35, 0x39, 0x32, 0x34, 0x30, 0x38, 0x31, 0x33, 0x61, 0x37, 0x33, 0x30, 0x39, 0x35, 0x61, 0x37, 0x65, 0x62, 0x66, 0x37, 0x63, 0x33, 0x62, 0x33, 0x37, 0x34, 0x33, 0x65, 0x38, 0x30, 0x32, 0x38, 0x61, 0x65, 0x35, 0x66, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x64, 0x31, 0x35, 0x37, 0x39, 0x63, 0x64, 0x34, 0x32, 0x36, 0x38, 0x32, 0x62, 0x37, 0x36, 0x34, 0x34, 0x65, 0x31, 0x64, 0x34, 0x66, 0x37, 0x31, 0x32, 0x38, 0x34, 0x34, 0x31, 0x65, 0x65, 0x66, 0x66, 0x65, 0x33, 0x33, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x32, 0x34, 0x33, 0x61, 0x30, 0x61, 0x39, 0x66, 0x65, 0x61, 0x34, 0x39, 0x62, 0x38, 0x33, 0x39, 0x35, 0x34, 0x37, 0x37, 0x34, 0x35, 0x66, 0x66, 0x32, 0x64, 0x31, 0x31, 0x61, 0x66, 0x33, 0x66, 0x34, 0x62, 0x30, 0x35, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x61, 0x34, 0x31, 0x61, 0x35, 0x61, 0x32, 0x37, 0x31, 0x39, 0x39, 0x32, 0x32, 0x36, 0x65, 0x34, 0x63, 0x37, 0x65, 0x62, 0x31, 0x39, 0x38, 0x62, 0x30, 0x33, 0x31, 0x62, 0x35, 0x39, 0x31, 0x39, 0x36, 0x66, 0x39, 0x38, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x31, 0x34, 0x61, 0x64, 0x62, 0x64, 0x63, 0x36, 0x33, 0x66, 0x34, 0x38, 0x33, 0x66, 0x33, 0x30, 0x34, 0x64, 0x38, 0x65, 0x39, 0x34, 0x62, 0x36, 0x37, 0x66, 0x66, 0x33, 0x33, 0x30, 0x39, 0x66, 0x31, 0x38, 0x30, 0x62, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x32, 0x39, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x61, 0x65, 0x65, 0x63, 0x39, 0x31, 0x35, 0x64, 0x65, 0x30, 0x31, 0x63, 0x63, 0x36, 0x39, 0x62, 0x32, 0x63, 0x62, 0x35, 0x61, 0x36, 0x33, 0x35, 0x36, 0x66, 0x65, 0x65, 0x61, 0x31, 0x34, 0x36, 0x35, 0x38, 0x63, 0x36, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x66, 0x39, 0x61, 0x64, 0x33, 0x64, 0x39, 0x62, 0x62, 0x64, 0x30, 0x34, 0x61, 0x65, 0x30, 0x35, 0x35, 0x63, 0x31, 0x34, 0x37, 0x37, 0x63, 0x30, 0x63, 0x33, 0x35, 0x65, 0x37, 0x35, 0x39, 0x32, 0x63, 0x62, 0x32, 0x61, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x61, 0x37, 0x62, 0x36, 0x38, 0x61, 0x64, 0x61, 0x62, 0x34, 0x65, 0x33, 0x65, 0x61, 0x64, 0x66, 0x66, 0x31, 0x39, 0x66, 0x66, 0x61, 0x35, 0x38, 0x65, 0x33, 0x34, 0x61, 0x33, 0x66, 0x63, 0x65, 0x63, 0x30, 0x64, 0x39, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x64, 0x65, 0x32, 0x32, 0x61, 0x31, 0x35, 0x30, 0x37, 0x34, 0x33, 0x32, 0x61, 0x34, 0x37, 0x62, 0x30, 0x31, 0x63, 0x63, 0x36, 0x38, 0x63, 0x35, 0x32, 0x61, 0x30, 0x62, 0x66, 0x38, 0x61, 0x32, 0x65, 0x30, 0x64, 0x30, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x62, 0x33, 0x33, 0x64, 0x37, 0x38, 0x65, 0x37, 0x35, 0x34, 0x37, 0x61, 0x39, 0x64, 0x61, 0x32, 0x65, 0x38, 0x37, 0x64, 0x35, 0x31, 0x61, 0x65, 0x63, 0x35, 0x66, 0x33, 0x34, 0x34, 0x31, 0x63, 0x38, 0x37, 0x39, 0x32, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x32, 0x38, 0x30, 0x39, 0x61, 0x32, 0x33, 0x39, 0x30, 0x66, 0x30, 0x37, 0x63, 0x36, 0x36, 0x35, 0x39, 0x32, 0x31, 0x66, 0x66, 0x33, 0x37, 0x64, 0x35, 0x34, 0x37, 0x64, 0x31, 0x32, 0x66, 0x31, 0x63, 0x39, 0x39, 0x36, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x65, 0x36, 0x35, 0x36, 0x61, 0x31, 0x62, 0x39, 0x31, 0x36, 0x66, 0x39, 0x62, 0x66, 0x34, 0x35, 0x61, 0x66, 0x62, 0x30, 0x37, 0x64, 0x64, 0x38, 0x61, 0x66, 0x61, 0x66, 0x37, 0x33, 0x62, 0x34, 0x63, 0x35, 0x36, 0x66, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x34, 0x31, 0x30, 0x62, 0x62, 0x37, 0x35, 0x35, 0x37, 0x63, 0x66, 0x39, 0x31, 0x64, 0x37, 0x39, 0x66, 0x61, 0x36, 0x39, 0x64, 0x30, 0x64, 0x66, 0x65, 0x61, 0x30, 0x61, 0x61, 0x30, 0x37, 0x35, 0x34, 0x30, 0x32, 0x36, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x65, 0x39, 0x34, 0x32, 0x64, 0x35, 0x63, 0x61, 0x66, 0x35, 0x66, 0x61, 0x63, 0x31, 0x31, 0x34, 0x32, 0x31, 0x64, 0x38, 0x36, 0x62, 0x30, 0x31, 0x30, 0x62, 0x34, 0x35, 0x38, 0x65, 0x35, 0x63, 0x33, 0x39, 0x32, 0x39, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x38, 0x66, 0x31, 0x30, 0x39, 0x38, 0x33, 0x35, 0x66, 0x35, 0x65, 0x61, 0x63, 0x64, 0x30, 0x35, 0x34, 0x33, 0x36, 0x34, 0x37, 0x63, 0x33, 0x34, 0x61, 0x36, 0x62, 0x32, 0x36, 0x39, 0x65, 0x33, 0x38, 0x30, 0x32, 0x66, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x32, 0x62, 0x39, 0x63, 0x30, 0x34, 0x64, 0x34, 0x30, 0x64, 0x32, 0x61, 0x63, 0x38, 0x33, 0x30, 0x38, 0x33, 0x64, 0x39, 0x34, 0x32, 0x39, 0x38, 0x31, 0x36, 0x39, 0x64, 0x61, 0x65, 0x38, 0x31, 0x61, 0x62, 0x32, 0x65, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x31, 0x30, 0x66, 0x32, 0x37, 0x36, 0x34, 0x32, 0x39, 0x30, 0x66, 0x38, 0x37, 0x35, 0x34, 0x33, 0x34, 0x33, 0x37, 0x32, 0x66, 0x37, 0x39, 0x64, 0x62, 0x66, 0x37, 0x31, 0x33, 0x38, 0x30, 0x31, 0x63, 0x61, 0x61, 0x63, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x63, 0x37, 0x65, 0x61, 0x66, 0x66, 0x64, 0x63, 0x32, 0x63, 0x39, 0x64, 0x39, 0x33, 0x37, 0x33, 0x34, 0x35, 0x32, 0x30, 0x36, 0x63, 0x39, 0x30, 0x39, 0x61, 0x35, 0x32, 0x64, 0x66, 0x62, 0x31, 0x34, 0x63, 0x34, 0x37, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x36, 0x37, 0x65, 0x30, 0x64, 0x37, 0x62, 0x36, 0x32, 0x65, 0x32, 0x61, 0x30, 0x38, 0x35, 0x30, 0x36, 0x39, 0x34, 0x35, 0x61, 0x35, 0x64, 0x66, 0x65, 0x33, 0x38, 0x32, 0x36, 0x33, 0x33, 0x33, 0x39, 0x66, 0x31, 0x66, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x63, 0x33, 0x37, 0x31, 0x34, 0x66, 0x64, 0x64, 0x64, 0x62, 0x36, 0x33, 0x34, 0x36, 0x35, 0x39, 0x65, 0x34, 0x61, 0x32, 0x62, 0x31, 0x65, 0x61, 0x34, 0x32, 0x63, 0x34, 0x37, 0x32, 0x38, 0x63, 0x63, 0x37, 0x62, 0x38, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x62, 0x34, 0x64, 0x34, 0x39, 0x39, 0x64, 0x65, 0x33, 0x66, 0x33, 0x38, 0x62, 0x66, 0x33, 0x35, 0x61, 0x61, 0x66, 0x37, 0x36, 0x39, 0x61, 0x36, 0x65, 0x33, 0x31, 0x38, 0x62, 0x63, 0x36, 0x64, 0x31, 0x32, 0x33, 0x36, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x32, 0x32, 0x64, 0x65, 0x61, 0x33, 0x63, 0x32, 0x35, 0x66, 0x31, 0x62, 0x35, 0x39, 0x63, 0x37, 0x62, 0x64, 0x32, 0x37, 0x62, 0x62, 0x39, 0x31, 0x64, 0x33, 0x61, 0x33, 0x65, 0x61, 0x65, 0x63, 0x65, 0x66, 0x33, 0x39, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x33, 0x62, 0x61, 0x64, 0x62, 0x31, 0x62, 0x36, 0x65, 0x31, 0x33, 0x38, 0x30, 0x65, 0x32, 0x37, 0x30, 0x33, 0x39, 0x63, 0x35, 0x37, 0x36, 0x61, 0x65, 0x36, 0x32, 0x32, 0x32, 0x65, 0x39, 0x36, 0x33, 0x61, 0x35, 0x62, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x64, 0x34, 0x64, 0x36, 0x63, 0x31, 0x36, 0x36, 0x36, 0x33, 0x35, 0x38, 0x63, 0x30, 0x34, 0x30, 0x36, 0x66, 0x64, 0x66, 0x33, 0x61, 0x66, 0x32, 0x34, 0x38, 0x66, 0x37, 0x38, 0x65, 0x63, 0x65, 0x38, 0x33, 0x30, 0x31, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x39, 0x32, 0x35, 0x61, 0x64, 0x35, 0x65, 0x62, 0x33, 0x35, 0x32, 0x63, 0x38, 0x65, 0x66, 0x37, 0x36, 0x64, 0x30, 0x63, 0x32, 0x32, 0x32, 0x64, 0x31, 0x31, 0x35, 0x62, 0x30, 0x37, 0x39, 0x31, 0x62, 0x39, 0x36, 0x32, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x39, 0x31, 0x38, 0x36, 0x63, 0x33, 0x34, 0x61, 0x35, 0x32, 0x35, 0x31, 0x34, 0x61, 0x62, 0x62, 0x39, 0x31, 0x30, 0x37, 0x38, 0x36, 0x30, 0x66, 0x36, 0x37, 0x34, 0x66, 0x39, 0x37, 0x62, 0x38, 0x32, 0x31, 0x62, 0x64, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x66, 0x36, 0x37, 0x33, 0x31, 0x34, 0x63, 0x62, 0x38, 0x33, 0x32, 0x65, 0x33, 0x32, 0x65, 0x36, 0x33, 0x62, 0x31, 0x35, 0x61, 0x34, 0x30, 0x63, 0x65, 0x30, 0x64, 0x37, 0x66, 0x66, 0x62, 0x64, 0x62, 0x32, 0x36, 0x39, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x30, 0x38, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x33, 0x30, 0x64, 0x33, 0x62, 0x63, 0x39, 0x66, 0x36, 0x30, 0x32, 0x32, 0x33, 0x32, 0x62, 0x63, 0x37, 0x32, 0x34, 0x32, 0x38, 0x38, 0x63, 0x61, 0x34, 0x36, 0x63, 0x64, 0x30, 0x62, 0x30, 0x37, 0x38, 0x38, 0x66, 0x37, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x30, 0x61, 0x62, 0x64, 0x35, 0x33, 0x61, 0x35, 0x34, 0x66, 0x63, 0x61, 0x34, 0x61, 0x36, 0x34, 0x32, 0x39, 0x32, 0x30, 0x37, 0x63, 0x31, 0x38, 0x32, 0x64, 0x34, 0x64, 0x35, 0x37, 0x62, 0x62, 0x33, 0x39, 0x64, 0x34, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x64, 0x38, 0x35, 0x64, 0x63, 0x33, 0x36, 0x38, 0x33, 0x31, 0x35, 0x36, 0x65, 0x36, 0x33, 0x62, 0x66, 0x38, 0x38, 0x30, 0x61, 0x39, 0x66, 0x61, 0x62, 0x37, 0x37, 0x38, 0x38, 0x63, 0x66, 0x38, 0x31, 0x34, 0x33, 0x61, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x33, 0x36, 0x31, 0x32, 0x33, 0x30, 0x34, 0x36, 0x62, 0x32, 0x38, 0x34, 0x65, 0x35, 0x65, 0x66, 0x31, 0x30, 0x32, 0x62, 0x66, 0x64, 0x32, 0x32, 0x62, 0x31, 0x37, 0x36, 0x35, 0x65, 0x35, 0x30, 0x38, 0x31, 0x31, 0x36, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x30, 0x36, 0x64, 0x35, 0x65, 0x61, 0x37, 0x37, 0x37, 0x61, 0x34, 0x65, 0x62, 0x31, 0x34, 0x37, 0x35, 0x65, 0x36, 0x30, 0x35, 0x64, 0x62, 0x63, 0x62, 0x66, 0x34, 0x33, 0x34, 0x34, 0x34, 0x65, 0x38, 0x30, 0x33, 0x37, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x66, 0x31, 0x31, 0x33, 0x39, 0x39, 0x35, 0x31, 0x31, 0x63, 0x32, 0x31, 0x33, 0x31, 0x38, 0x31, 0x62, 0x66, 0x64, 0x61, 0x33, 0x61, 0x38, 0x62, 0x32, 0x36, 0x34, 0x63, 0x30, 0x35, 0x66, 0x63, 0x38, 0x31, 0x62, 0x33, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x31, 0x39, 0x31, 0x32, 0x31, 0x35, 0x39, 0x38, 0x33, 0x66, 0x33, 0x33, 0x66, 0x64, 0x33, 0x33, 0x65, 0x32, 0x32, 0x63, 0x64, 0x34, 0x61, 0x32, 0x34, 0x39, 0x30, 0x30, 0x35, 0x34, 0x64, 0x61, 0x35, 0x33, 0x66, 0x64, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x65, 0x62, 0x66, 0x35, 0x39, 0x34, 0x33, 0x32, 0x62, 0x35, 0x32, 0x38, 0x39, 0x32, 0x66, 0x39, 0x33, 0x38, 0x30, 0x62, 0x64, 0x31, 0x34, 0x30, 0x61, 0x61, 0x39, 0x39, 0x64, 0x63, 0x66, 0x38, 0x61, 0x64, 0x30, 0x63, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x30, 0x38, 0x37, 0x66, 0x39, 0x33, 0x39, 0x30, 0x66, 0x62, 0x39, 0x65, 0x39, 0x37, 0x36, 0x61, 0x63, 0x32, 0x33, 0x61, 0x62, 0x36, 0x38, 0x39, 0x35, 0x34, 0x34, 0x61, 0x30, 0x39, 0x34, 0x32, 0x65, 0x63, 0x32, 0x30, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x34, 0x62, 0x39, 0x38, 0x39, 0x35, 0x35, 0x38, 0x61, 0x65, 0x31, 0x31, 0x62, 0x65, 0x30, 0x63, 0x33, 0x62, 0x33, 0x36, 0x65, 0x32, 0x64, 0x36, 0x66, 0x32, 0x61, 0x35, 0x34, 0x61, 0x39, 0x33, 0x34, 0x33, 0x63, 0x61, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x30, 0x63, 0x32, 0x66, 0x62, 0x32, 0x63, 0x34, 0x61, 0x38, 0x31, 0x37, 0x35, 0x33, 0x61, 0x63, 0x30, 0x31, 0x38, 0x32, 0x65, 0x61, 0x34, 0x36, 0x30, 0x65, 0x63, 0x30, 0x39, 0x63, 0x39, 0x30, 0x61, 0x35, 0x31, 0x36, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x38, 0x64, 0x62, 0x66, 0x63, 0x36, 0x34, 0x39, 0x39, 0x38, 0x39, 0x34, 0x66, 0x37, 0x33, 0x61, 0x37, 0x31, 0x66, 0x61, 0x61, 0x30, 0x30, 0x61, 0x62, 0x65, 0x30, 0x66, 0x34, 0x62, 0x63, 0x39, 0x64, 0x31, 0x39, 0x66, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x63, 0x65, 0x66, 0x38, 0x65, 0x38, 0x66, 0x62, 0x38, 0x39, 0x38, 0x34, 0x61, 0x36, 0x30, 0x31, 0x39, 0x66, 0x30, 0x31, 0x63, 0x36, 0x37, 0x39, 0x66, 0x32, 0x37, 0x32, 0x62, 0x62, 0x65, 0x36, 0x38, 0x66, 0x35, 0x63, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x30, 0x30, 0x66, 0x39, 0x33, 0x64, 0x35, 0x66, 0x35, 0x63, 0x37, 0x65, 0x33, 0x66, 0x63, 0x33, 0x30, 0x33, 0x31, 0x32, 0x39, 0x61, 0x63, 0x38, 0x66, 0x62, 0x30, 0x63, 0x32, 0x66, 0x37, 0x38, 0x36, 0x34, 0x30, 0x37, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x31, 0x33, 0x33, 0x34, 0x33, 0x31, 0x64, 0x31, 0x64, 0x39, 0x61, 0x33, 0x37, 0x62, 0x61, 0x32, 0x66, 0x30, 0x37, 0x36, 0x32, 0x62, 0x63, 0x34, 0x30, 0x63, 0x35, 0x61, 0x63, 0x63, 0x38, 0x61, 0x61, 0x36, 0x39, 0x37, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x30, 0x33, 0x64, 0x32, 0x37, 0x30, 0x38, 0x39, 0x31, 0x62, 0x61, 0x32, 0x64, 0x66, 0x36, 0x34, 0x33, 0x64, 0x61, 0x38, 0x33, 0x34, 0x31, 0x35, 0x38, 0x33, 0x31, 0x39, 0x33, 0x35, 0x34, 0x35, 0x65, 0x33, 0x65, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x33, 0x38, 0x64, 0x31, 0x62, 0x34, 0x64, 0x61, 0x65, 0x65, 0x35, 0x35, 0x61, 0x35, 0x34, 0x64, 0x37, 0x33, 0x38, 0x63, 0x66, 0x31, 0x37, 0x65, 0x34, 0x34, 0x37, 0x37, 0x66, 0x36, 0x37, 0x39, 0x34, 0x65, 0x34, 0x36, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x65, 0x36, 0x66, 0x35, 0x34, 0x37, 0x64, 0x62, 0x38, 0x38, 0x65, 0x37, 0x35, 0x66, 0x31, 0x66, 0x39, 0x63, 0x38, 0x61, 0x63, 0x32, 0x63, 0x35, 0x63, 0x66, 0x31, 0x36, 0x32, 0x37, 0x62, 0x61, 0x35, 0x38, 0x30, 0x62, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x39, 0x66, 0x64, 0x62, 0x66, 0x34, 0x34, 0x65, 0x31, 0x66, 0x34, 0x61, 0x36, 0x33, 0x36, 0x32, 0x62, 0x37, 0x36, 0x39, 0x63, 0x33, 0x39, 0x61, 0x34, 0x37, 0x35, 0x66, 0x39, 0x35, 0x61, 0x39, 0x36, 0x63, 0x32, 0x62, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x66, 0x39, 0x35, 0x39, 0x37, 0x38, 0x31, 0x31, 0x62, 0x30, 0x62, 0x39, 0x39, 0x32, 0x62, 0x62, 0x37, 0x64, 0x33, 0x37, 0x35, 0x37, 0x61, 0x61, 0x32, 0x35, 0x62, 0x34, 0x63, 0x32, 0x35, 0x36, 0x31, 0x64, 0x33, 0x32, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x64, 0x31, 0x30, 0x63, 0x35, 0x35, 0x62, 0x62, 0x38, 0x35, 0x34, 0x66, 0x37, 0x35, 0x34, 0x34, 0x33, 0x34, 0x66, 0x31, 0x32, 0x31, 0x39, 0x63, 0x32, 0x63, 0x39, 0x61, 0x39, 0x38, 0x61, 0x63, 0x65, 0x37, 0x39, 0x66, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x30, 0x34, 0x38, 0x66, 0x33, 0x61, 0x31, 0x32, 0x61, 0x34, 0x64, 0x64, 0x31, 0x66, 0x36, 0x32, 0x36, 0x63, 0x36, 0x34, 0x32, 0x36, 0x34, 0x63, 0x62, 0x31, 0x64, 0x37, 0x39, 0x37, 0x31, 0x64, 0x65, 0x32, 0x63, 0x61, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x33, 0x63, 0x66, 0x38, 0x32, 0x62, 0x66, 0x31, 0x34, 0x63, 0x35, 0x39, 0x32, 0x36, 0x34, 0x30, 0x61, 0x30, 0x38, 0x36, 0x30, 0x38, 0x39, 0x31, 0x34, 0x63, 0x32, 0x33, 0x37, 0x30, 0x37, 0x39, 0x64, 0x35, 0x62, 0x65, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x62, 0x30, 0x36, 0x38, 0x39, 0x38, 0x39, 0x64, 0x66, 0x32, 0x39, 0x63, 0x32, 0x35, 0x33, 0x35, 0x37, 0x37, 0x64, 0x30, 0x34, 0x30, 0x35, 0x61, 0x64, 0x65, 0x36, 0x65, 0x30, 0x65, 0x37, 0x35, 0x32, 0x38, 0x66, 0x38, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x61, 0x38, 0x65, 0x63, 0x61, 0x31, 0x31, 0x61, 0x32, 0x33, 0x64, 0x36, 0x34, 0x36, 0x38, 0x39, 0x61, 0x32, 0x61, 0x61, 0x33, 0x65, 0x34, 0x31, 0x37, 0x64, 0x62, 0x62, 0x33, 0x64, 0x33, 0x33, 0x36, 0x62, 0x62, 0x35, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x32, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x34, 0x31, 0x33, 0x37, 0x30, 0x34, 0x62, 0x31, 0x61, 0x33, 0x32, 0x65, 0x37, 0x30, 0x66, 0x33, 0x62, 0x63, 0x30, 0x64, 0x36, 0x39, 0x64, 0x64, 0x38, 0x38, 0x31, 0x63, 0x33, 0x38, 0x35, 0x36, 0x36, 0x62, 0x35, 0x34, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x33, 0x38, 0x32, 0x37, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x30, 0x38, 0x35, 0x65, 0x32, 0x35, 0x62, 0x36, 0x34, 0x38, 0x36, 0x32, 0x66, 0x35, 0x65, 0x36, 0x38, 0x64, 0x37, 0x36, 0x38, 0x65, 0x32, 0x62, 0x30, 0x66, 0x37, 0x61, 0x38, 0x35, 0x32, 0x39, 0x38, 0x35, 0x38, 0x65, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x33, 0x36, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x33, 0x64, 0x33, 0x66, 0x61, 0x65, 0x35, 0x34, 0x32, 0x61, 0x64, 0x35, 0x66, 0x38, 0x62, 0x35, 0x30, 0x63, 0x65, 0x31, 0x39, 0x62, 0x64, 0x65, 0x32, 0x62, 0x65, 0x63, 0x35, 0x37, 0x39, 0x31, 0x38, 0x30, 0x63, 0x38, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x34, 0x38, 0x33, 0x64, 0x36, 0x65, 0x38, 0x38, 0x61, 0x63, 0x31, 0x66, 0x34, 0x61, 0x65, 0x37, 0x33, 0x63, 0x63, 0x34, 0x34, 0x30, 0x38, 0x64, 0x36, 0x63, 0x30, 0x33, 0x61, 0x62, 0x65, 0x30, 0x65, 0x34, 0x39, 0x64, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x65, 0x33, 0x39, 0x35, 0x62, 0x63, 0x30, 0x62, 0x36, 0x64, 0x35, 0x63, 0x62, 0x62, 0x34, 0x63, 0x31, 0x64, 0x38, 0x66, 0x65, 0x61, 0x33, 0x65, 0x30, 0x62, 0x34, 0x62, 0x66, 0x66, 0x36, 0x33, 0x35, 0x65, 0x39, 0x64, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x64, 0x61, 0x63, 0x64, 0x39, 0x34, 0x65, 0x63, 0x38, 0x39, 0x61, 0x32, 0x65, 0x66, 0x39, 0x36, 0x38, 0x66, 0x63, 0x66, 0x39, 0x37, 0x37, 0x61, 0x30, 0x38, 0x66, 0x31, 0x66, 0x61, 0x65, 0x32, 0x37, 0x35, 0x37, 0x38, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x32, 0x39, 0x31, 0x31, 0x39, 0x37, 0x34, 0x35, 0x64, 0x32, 0x33, 0x33, 0x37, 0x33, 0x32, 0x30, 0x64, 0x61, 0x35, 0x31, 0x65, 0x31, 0x39, 0x31, 0x30, 0x30, 0x63, 0x39, 0x34, 0x38, 0x64, 0x39, 0x38, 0x30, 0x62, 0x39, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x30, 0x62, 0x66, 0x38, 0x37, 0x34, 0x31, 0x35, 0x65, 0x30, 0x63, 0x66, 0x34, 0x30, 0x37, 0x33, 0x30, 0x31, 0x65, 0x35, 0x35, 0x39, 0x39, 0x61, 0x36, 0x38, 0x33, 0x36, 0x36, 0x64, 0x61, 0x30, 0x39, 0x62, 0x62, 0x61, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x33, 0x32, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x63, 0x63, 0x37, 0x64, 0x62, 0x62, 0x38, 0x33, 0x35, 0x36, 0x64, 0x38, 0x34, 0x32, 0x64, 0x34, 0x33, 0x61, 0x65, 0x37, 0x65, 0x32, 0x33, 0x63, 0x38, 0x34, 0x32, 0x32, 0x62, 0x30, 0x32, 0x32, 0x61, 0x33, 0x30, 0x38, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x32, 0x30, 0x65, 0x37, 0x31, 0x31, 0x37, 0x33, 0x65, 0x31, 0x62, 0x61, 0x31, 0x39, 0x62, 0x61, 0x38, 0x66, 0x39, 0x66, 0x34, 0x66, 0x64, 0x62, 0x64, 0x63, 0x61, 0x61, 0x33, 0x34, 0x65, 0x31, 0x64, 0x36, 0x62, 0x62, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x38, 0x37, 0x30, 0x37, 0x63, 0x36, 0x32, 0x31, 0x66, 0x64, 0x62, 0x64, 0x31, 0x64, 0x39, 0x30, 0x66, 0x62, 0x38, 0x30, 0x65, 0x62, 0x37, 0x38, 0x37, 0x66, 0x64, 0x32, 0x36, 0x66, 0x37, 0x33, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x33, 0x65, 0x35, 0x37, 0x64, 0x61, 0x63, 0x62, 0x65, 0x30, 0x31, 0x34, 0x39, 0x66, 0x38, 0x32, 0x66, 0x65, 0x36, 0x35, 0x61, 0x32, 0x36, 0x36, 0x34, 0x38, 0x39, 0x38, 0x38, 0x36, 0x36, 0x66, 0x66, 0x35, 0x62, 0x34, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x35, 0x64, 0x62, 0x37, 0x34, 0x33, 0x39, 0x66, 0x61, 0x31, 0x64, 0x35, 0x62, 0x34, 0x32, 0x33, 0x61, 0x66, 0x61, 0x37, 0x64, 0x64, 0x37, 0x31, 0x39, 0x38, 0x63, 0x31, 0x63, 0x66, 0x37, 0x34, 0x63, 0x39, 0x31, 0x38, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x62, 0x34, 0x36, 0x36, 0x38, 0x36, 0x39, 0x36, 0x66, 0x38, 0x36, 0x61, 0x30, 0x38, 0x30, 0x66, 0x38, 0x62, 0x65, 0x62, 0x62, 0x39, 0x31, 0x64, 0x62, 0x38, 0x65, 0x36, 0x66, 0x38, 0x37, 0x30, 0x31, 0x35, 0x39, 0x31, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x33, 0x31, 0x39, 0x39, 0x36, 0x64, 0x63, 0x61, 0x63, 0x30, 0x31, 0x35, 0x66, 0x39, 0x62, 0x65, 0x39, 0x38, 0x35, 0x62, 0x36, 0x31, 0x31, 0x66, 0x34, 0x36, 0x38, 0x37, 0x33, 0x30, 0x65, 0x66, 0x32, 0x34, 0x34, 0x64, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x31, 0x37, 0x39, 0x35, 0x38, 0x39, 0x65, 0x31, 0x39, 0x64, 0x62, 0x39, 0x64, 0x34, 0x31, 0x35, 0x35, 0x37, 0x62, 0x62, 0x65, 0x63, 0x31, 0x63, 0x62, 0x32, 0x34, 0x63, 0x63, 0x63, 0x32, 0x64, 0x65, 0x63, 0x31, 0x63, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x31, 0x39, 0x33, 0x37, 0x64, 0x35, 0x65, 0x37, 0x39, 0x33, 0x62, 0x38, 0x39, 0x62, 0x36, 0x33, 0x66, 0x62, 0x38, 0x65, 0x62, 0x35, 0x66, 0x31, 0x62, 0x31, 0x63, 0x39, 0x63, 0x61, 0x36, 0x62, 0x61, 0x30, 0x66, 0x61, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x31, 0x32, 0x37, 0x62, 0x37, 0x66, 0x36, 0x36, 0x32, 0x39, 0x65, 0x65, 0x31, 0x33, 0x66, 0x63, 0x33, 0x66, 0x36, 0x30, 0x62, 0x63, 0x32, 0x66, 0x34, 0x34, 0x36, 0x37, 0x61, 0x32, 0x30, 0x37, 0x34, 0x35, 0x61, 0x37, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x36, 0x35, 0x36, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x30, 0x36, 0x64, 0x65, 0x30, 0x65, 0x32, 0x38, 0x38, 0x62, 0x35, 0x36, 0x63, 0x66, 0x64, 0x66, 0x39, 0x38, 0x37, 0x65, 0x66, 0x30, 0x64, 0x33, 0x63, 0x63, 0x32, 0x39, 0x36, 0x36, 0x30, 0x37, 0x39, 0x33, 0x66, 0x36, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x61, 0x31, 0x39, 0x32, 0x37, 0x37, 0x37, 0x63, 0x61, 0x35, 0x62, 0x39, 0x37, 0x38, 0x62, 0x36, 0x62, 0x32, 0x63, 0x32, 0x66, 0x66, 0x38, 0x30, 0x30, 0x61, 0x63, 0x31, 0x38, 0x36, 0x30, 0x66, 0x37, 0x35, 0x33, 0x66, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x64, 0x61, 0x39, 0x64, 0x63, 0x64, 0x63, 0x61, 0x36, 0x31, 0x63, 0x62, 0x66, 0x65, 0x31, 0x66, 0x31, 0x33, 0x33, 0x63, 0x37, 0x62, 0x63, 0x65, 0x66, 0x63, 0x38, 0x36, 0x37, 0x62, 0x39, 0x63, 0x38, 0x31, 0x32, 0x32, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x64, 0x39, 0x65, 0x66, 0x61, 0x63, 0x34, 0x64, 0x36, 0x64, 0x36, 0x30, 0x62, 0x64, 0x37, 0x31, 0x64, 0x39, 0x35, 0x35, 0x38, 0x35, 0x64, 0x63, 0x65, 0x35, 0x64, 0x35, 0x39, 0x37, 0x30, 0x35, 0x63, 0x31, 0x33, 0x35, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x38, 0x65, 0x34, 0x38, 0x61, 0x33, 0x37, 0x37, 0x36, 0x39, 0x35, 0x64, 0x65, 0x30, 0x31, 0x34, 0x33, 0x36, 0x33, 0x61, 0x35, 0x32, 0x33, 0x61, 0x32, 0x38, 0x62, 0x31, 0x61, 0x34, 0x30, 0x63, 0x37, 0x38, 0x66, 0x32, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x32, 0x62, 0x36, 0x35, 0x35, 0x35, 0x61, 0x66, 0x64, 0x63, 0x38, 0x30, 0x66, 0x32, 0x64, 0x39, 0x36, 0x64, 0x39, 0x37, 0x32, 0x64, 0x31, 0x37, 0x64, 0x62, 0x38, 0x34, 0x65, 0x61, 0x35, 0x61, 0x64, 0x35, 0x32, 0x31, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x61, 0x62, 0x37, 0x31, 0x63, 0x64, 0x32, 0x36, 0x65, 0x61, 0x36, 0x64, 0x36, 0x65, 0x35, 0x39, 0x61, 0x37, 0x61, 0x30, 0x66, 0x36, 0x32, 0x37, 0x65, 0x65, 0x30, 0x37, 0x39, 0x63, 0x38, 0x38, 0x35, 0x65, 0x62, 0x62, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x30, 0x62, 0x31, 0x33, 0x34, 0x66, 0x65, 0x61, 0x32, 0x32, 0x63, 0x36, 0x62, 0x32, 0x39, 0x63, 0x38, 0x34, 0x35, 0x37, 0x66, 0x34, 0x39, 0x66, 0x30, 0x30, 0x30, 0x66, 0x39, 0x63, 0x64, 0x61, 0x37, 0x38, 0x39, 0x61, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x61, 0x32, 0x66, 0x36, 0x65, 0x61, 0x39, 0x34, 0x64, 0x30, 0x35, 0x65, 0x38, 0x63, 0x31, 0x64, 0x39, 0x61, 0x65, 0x32, 0x66, 0x34, 0x39, 0x31, 0x30, 0x33, 0x33, 0x38, 0x61, 0x33, 0x35, 0x38, 0x65, 0x39, 0x38, 0x64, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x31, 0x33, 0x61, 0x30, 0x38, 0x35, 0x31, 0x31, 0x31, 0x31, 0x30, 0x66, 0x33, 0x32, 0x65, 0x35, 0x33, 0x62, 0x65, 0x34, 0x31, 0x32, 0x37, 0x38, 0x34, 0x35, 0x63, 0x38, 0x34, 0x33, 0x61, 0x31, 0x61, 0x35, 0x37, 0x63, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x64, 0x62, 0x31, 0x62, 0x61, 0x35, 0x38, 0x35, 0x63, 0x65, 0x33, 0x34, 0x35, 0x33, 0x31, 0x65, 0x64, 0x65, 0x63, 0x35, 0x34, 0x39, 0x34, 0x38, 0x34, 0x39, 0x33, 0x39, 0x31, 0x33, 0x38, 0x31, 0x65, 0x36, 0x63, 0x63, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x35, 0x35, 0x38, 0x39, 0x61, 0x37, 0x61, 0x38, 0x39, 0x62, 0x39, 0x61, 0x64, 0x31, 0x35, 0x62, 0x30, 0x32, 0x37, 0x35, 0x31, 0x39, 0x33, 0x30, 0x34, 0x31, 0x35, 0x39, 0x34, 0x38, 0x61, 0x38, 0x37, 0x35, 0x66, 0x62, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x30, 0x35, 0x34, 0x34, 0x33, 0x30, 0x64, 0x63, 0x64, 0x63, 0x32, 0x38, 0x61, 0x63, 0x31, 0x35, 0x66, 0x61, 0x36, 0x33, 0x35, 0x65, 0x66, 0x38, 0x37, 0x63, 0x31, 0x30, 0x35, 0x65, 0x36, 0x30, 0x32, 0x62, 0x66, 0x37, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x38, 0x38, 0x32, 0x63, 0x32, 0x37, 0x37, 0x33, 0x32, 0x63, 0x65, 0x66, 0x35, 0x63, 0x37, 0x63, 0x31, 0x33, 0x61, 0x36, 0x38, 0x36, 0x66, 0x30, 0x61, 0x32, 0x65, 0x61, 0x37, 0x37, 0x35, 0x35, 0x35, 0x61, 0x63, 0x32, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x33, 0x37, 0x34, 0x32, 0x39, 0x39, 0x63, 0x31, 0x64, 0x30, 0x37, 0x64, 0x37, 0x39, 0x35, 0x33, 0x37, 0x33, 0x38, 0x35, 0x31, 0x39, 0x30, 0x66, 0x34, 0x34, 0x32, 0x65, 0x66, 0x39, 0x63, 0x61, 0x32, 0x34, 0x30, 0x36, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x34, 0x36, 0x61, 0x30, 0x62, 0x39, 0x32, 0x35, 0x35, 0x35, 0x33, 0x63, 0x66, 0x30, 0x36, 0x66, 0x63, 0x61, 0x66, 0x35, 0x34, 0x61, 0x31, 0x62, 0x34, 0x64, 0x66, 0x65, 0x61, 0x36, 0x32, 0x31, 0x32, 0x39, 0x30, 0x37, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x61, 0x65, 0x34, 0x39, 0x65, 0x33, 0x37, 0x66, 0x31, 0x32, 0x31, 0x64, 0x66, 0x35, 0x64, 0x63, 0x31, 0x35, 0x38, 0x63, 0x66, 0x64, 0x65, 0x38, 0x30, 0x36, 0x66, 0x31, 0x37, 0x33, 0x61, 0x30, 0x36, 0x62, 0x30, 0x63, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x35, 0x38, 0x38, 0x39, 0x36, 0x66, 0x31, 0x62, 0x61, 0x61, 0x38, 0x36, 0x34, 0x66, 0x31, 0x37, 0x65, 0x62, 0x65, 0x64, 0x31, 0x36, 0x64, 0x39, 0x35, 0x33, 0x38, 0x38, 0x36, 0x66, 0x65, 0x65, 0x36, 0x38, 0x61, 0x61, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x37, 0x33, 0x30, 0x34, 0x36, 0x36, 0x62, 0x38, 0x65, 0x62, 0x36, 0x64, 0x63, 0x39, 0x30, 0x64, 0x35, 0x34, 0x39, 0x36, 0x61, 0x61, 0x37, 0x36, 0x61, 0x33, 0x34, 0x37, 0x32, 0x64, 0x37, 0x64, 0x62, 0x65, 0x30, 0x62, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x30, 0x32, 0x37, 0x33, 0x34, 0x30, 0x33, 0x33, 0x65, 0x35, 0x37, 0x66, 0x37, 0x30, 0x35, 0x31, 0x37, 0x65, 0x30, 0x61, 0x66, 0x63, 0x37, 0x65, 0x65, 0x36, 0x32, 0x34, 0x36, 0x31, 0x66, 0x30, 0x36, 0x66, 0x61, 0x64, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x62, 0x32, 0x64, 0x32, 0x65, 0x30, 0x34, 0x39, 0x34, 0x65, 0x61, 0x62, 0x31, 0x38, 0x65, 0x30, 0x37, 0x64, 0x33, 0x37, 0x62, 0x62, 0x62, 0x38, 0x35, 0x36, 0x64, 0x38, 0x30, 0x65, 0x38, 0x30, 0x66, 0x38, 0x34, 0x63, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x32, 0x37, 0x38, 0x62, 0x30, 0x38, 0x64, 0x65, 0x65, 0x37, 0x63, 0x30, 0x66, 0x32, 0x63, 0x38, 0x63, 0x30, 0x66, 0x37, 0x32, 0x32, 0x66, 0x39, 0x66, 0x63, 0x62, 0x62, 0x62, 0x39, 0x61, 0x35, 0x32, 0x34, 0x31, 0x66, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x38, 0x36, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x62, 0x36, 0x62, 0x63, 0x64, 0x62, 0x38, 0x33, 0x63, 0x66, 0x32, 0x34, 0x61, 0x30, 0x61, 0x65, 0x31, 0x63, 0x62, 0x32, 0x31, 0x62, 0x33, 0x62, 0x35, 0x62, 0x38, 0x33, 0x63, 0x32, 0x66, 0x33, 0x38, 0x32, 0x34, 0x39, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x34, 0x33, 0x39, 0x63, 0x61, 0x39, 0x63, 0x63, 0x31, 0x36, 0x39, 0x61, 0x37, 0x39, 0x64, 0x34, 0x61, 0x30, 0x39, 0x63, 0x61, 0x65, 0x35, 0x65, 0x36, 0x37, 0x37, 0x36, 0x34, 0x61, 0x36, 0x66, 0x38, 0x37, 0x31, 0x61, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x36, 0x63, 0x32, 0x39, 0x61, 0x38, 0x31, 0x35, 0x31, 0x37, 0x65, 0x30, 0x64, 0x34, 0x38, 0x37, 0x62, 0x36, 0x37, 0x66, 0x62, 0x30, 0x62, 0x36, 0x61, 0x61, 0x62, 0x63, 0x34, 0x66, 0x35, 0x37, 0x33, 0x36, 0x38, 0x33, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x38, 0x65, 0x33, 0x63, 0x63, 0x39, 0x39, 0x65, 0x39, 0x34, 0x37, 0x38, 0x34, 0x34, 0x61, 0x31, 0x38, 0x65, 0x36, 0x61, 0x34, 0x32, 0x39, 0x31, 0x38, 0x66, 0x65, 0x66, 0x37, 0x65, 0x37, 0x66, 0x35, 0x66, 0x35, 0x65, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x39, 0x38, 0x30, 0x34, 0x31, 0x33, 0x37, 0x38, 0x30, 0x33, 0x62, 0x61, 0x36, 0x38, 0x36, 0x38, 0x64, 0x39, 0x33, 0x61, 0x35, 0x35, 0x66, 0x39, 0x39, 0x38, 0x35, 0x66, 0x63, 0x64, 0x35, 0x34, 0x30, 0x34, 0x35, 0x31, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x36, 0x33, 0x30, 0x30, 0x32, 0x34, 0x62, 0x64, 0x32, 0x63, 0x35, 0x38, 0x64, 0x32, 0x34, 0x38, 0x65, 0x64, 0x64, 0x38, 0x34, 0x36, 0x35, 0x36, 0x31, 0x37, 0x62, 0x32, 0x62, 0x66, 0x31, 0x36, 0x34, 0x37, 0x64, 0x61, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x32, 0x32, 0x34, 0x61, 0x64, 0x31, 0x63, 0x30, 0x66, 0x61, 0x63, 0x65, 0x34, 0x36, 0x66, 0x39, 0x66, 0x35, 0x35, 0x36, 0x65, 0x34, 0x37, 0x37, 0x34, 0x61, 0x33, 0x30, 0x32, 0x35, 0x61, 0x64, 0x30, 0x36, 0x62, 0x64, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x32, 0x38, 0x31, 0x30, 0x64, 0x65, 0x65, 0x34, 0x34, 0x61, 0x65, 0x34, 0x64, 0x66, 0x66, 0x33, 0x64, 0x38, 0x36, 0x33, 0x34, 0x32, 0x61, 0x62, 0x31, 0x32, 0x36, 0x36, 0x35, 0x37, 0x64, 0x36, 0x35, 0x33, 0x63, 0x33, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x61, 0x33, 0x30, 0x64, 0x65, 0x31, 0x63, 0x39, 0x31, 0x39, 0x64, 0x33, 0x66, 0x64, 0x33, 0x31, 0x38, 0x30, 0x65, 0x39, 0x37, 0x64, 0x35, 0x66, 0x32, 0x62, 0x32, 0x61, 0x39, 0x64, 0x62, 0x64, 0x39, 0x36, 0x34, 0x64, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x61, 0x33, 0x30, 0x62, 0x38, 0x61, 0x38, 0x30, 0x38, 0x39, 0x33, 0x31, 0x32, 0x31, 0x37, 0x34, 0x34, 0x35, 0x63, 0x33, 0x66, 0x35, 0x61, 0x39, 0x33, 0x65, 0x38, 0x38, 0x32, 0x63, 0x30, 0x33, 0x34, 0x35, 0x62, 0x34, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x35, 0x33, 0x39, 0x36, 0x61, 0x34, 0x62, 0x62, 0x64, 0x39, 0x62, 0x61, 0x65, 0x38, 0x61, 0x66, 0x39, 0x66, 0x62, 0x37, 0x63, 0x34, 0x64, 0x36, 0x34, 0x64, 0x34, 0x37, 0x31, 0x64, 0x62, 0x39, 0x63, 0x32, 0x34, 0x35, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x66, 0x64, 0x61, 0x32, 0x64, 0x35, 0x64, 0x62, 0x39, 0x38, 0x66, 0x39, 0x33, 0x38, 0x30, 0x37, 0x31, 0x34, 0x36, 0x36, 0x34, 0x64, 0x35, 0x34, 0x62, 0x34, 0x65, 0x65, 0x39, 0x37, 0x31, 0x61, 0x31, 0x63, 0x61, 0x65, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x65, 0x61, 0x64, 0x63, 0x64, 0x32, 0x64, 0x31, 0x62, 0x38, 0x36, 0x35, 0x37, 0x61, 0x31, 0x32, 0x31, 0x66, 0x33, 0x33, 0x63, 0x34, 0x35, 0x38, 0x61, 0x38, 0x62, 0x31, 0x33, 0x65, 0x37, 0x36, 0x62, 0x36, 0x35, 0x35, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x39, 0x38, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x65, 0x37, 0x30, 0x37, 0x30, 0x66, 0x34, 0x64, 0x30, 0x33, 0x33, 0x66, 0x65, 0x36, 0x39, 0x31, 0x30, 0x63, 0x39, 0x65, 0x66, 0x65, 0x35, 0x61, 0x32, 0x37, 0x38, 0x65, 0x31, 0x66, 0x63, 0x36, 0x32, 0x33, 0x34, 0x64, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x33, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x35, 0x35, 0x30, 0x38, 0x61, 0x64, 0x62, 0x62, 0x62, 0x65, 0x39, 0x62, 0x65, 0x38, 0x31, 0x62, 0x38, 0x30, 0x66, 0x39, 0x37, 0x61, 0x36, 0x65, 0x61, 0x38, 0x39, 0x61, 0x64, 0x64, 0x36, 0x38, 0x64, 0x61, 0x36, 0x37, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x39, 0x32, 0x35, 0x64, 0x65, 0x33, 0x65, 0x34, 0x33, 0x66, 0x34, 0x62, 0x34, 0x31, 0x62, 0x66, 0x39, 0x64, 0x61, 0x64, 0x64, 0x65, 0x32, 0x37, 0x64, 0x35, 0x34, 0x38, 0x38, 0x65, 0x66, 0x35, 0x36, 0x39, 0x65, 0x61, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x63, 0x30, 0x37, 0x37, 0x39, 0x34, 0x36, 0x36, 0x37, 0x34, 0x62, 0x61, 0x39, 0x33, 0x34, 0x31, 0x66, 0x62, 0x34, 0x63, 0x37, 0x34, 0x37, 0x61, 0x35, 0x64, 0x35, 0x30, 0x66, 0x35, 0x64, 0x32, 0x64, 0x61, 0x36, 0x34, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x32, 0x64, 0x31, 0x61, 0x30, 0x63, 0x37, 0x33, 0x63, 0x32, 0x61, 0x31, 0x62, 0x65, 0x38, 0x34, 0x39, 0x31, 0x35, 0x31, 0x38, 0x35, 0x66, 0x38, 0x62, 0x33, 0x34, 0x66, 0x61, 0x61, 0x30, 0x61, 0x64, 0x66, 0x31, 0x64, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x62, 0x38, 0x61, 0x61, 0x64, 0x38, 0x37, 0x39, 0x64, 0x64, 0x33, 0x30, 0x35, 0x36, 0x37, 0x65, 0x38, 0x37, 0x37, 0x38, 0x64, 0x32, 0x64, 0x32, 0x33, 0x31, 0x63, 0x38, 0x66, 0x33, 0x37, 0x61, 0x62, 0x38, 0x37, 0x33, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x61, 0x65, 0x34, 0x38, 0x37, 0x32, 0x66, 0x64, 0x39, 0x30, 0x39, 0x33, 0x63, 0x62, 0x63, 0x61, 0x64, 0x31, 0x34, 0x30, 0x36, 0x66, 0x31, 0x65, 0x38, 0x30, 0x37, 0x38, 0x62, 0x61, 0x62, 0x35, 0x30, 0x33, 0x35, 0x39, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x65, 0x39, 0x64, 0x37, 0x36, 0x62, 0x66, 0x35, 0x30, 0x66, 0x63, 0x33, 0x36, 0x62, 0x66, 0x37, 0x64, 0x33, 0x39, 0x34, 0x34, 0x62, 0x36, 0x33, 0x65, 0x39, 0x63, 0x61, 0x38, 0x38, 0x39, 0x62, 0x36, 0x39, 0x39, 0x39, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x35, 0x66, 0x35, 0x39, 0x36, 0x62, 0x39, 0x34, 0x62, 0x39, 0x34, 0x37, 0x33, 0x34, 0x34, 0x63, 0x30, 0x33, 0x33, 0x63, 0x65, 0x32, 0x64, 0x63, 0x62, 0x66, 0x66, 0x31, 0x32, 0x65, 0x32, 0x35, 0x62, 0x37, 0x39, 0x37, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x32, 0x63, 0x62, 0x31, 0x63, 0x64, 0x34, 0x39, 0x39, 0x39, 0x33, 0x63, 0x31, 0x34, 0x34, 0x61, 0x33, 0x66, 0x38, 0x38, 0x62, 0x33, 0x36, 0x31, 0x31, 0x65, 0x32, 0x33, 0x33, 0x35, 0x36, 0x39, 0x61, 0x38, 0x36, 0x62, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x32, 0x33, 0x32, 0x63, 0x30, 0x38, 0x63, 0x31, 0x34, 0x64, 0x63, 0x31, 0x61, 0x36, 0x65, 0x64, 0x30, 0x62, 0x38, 0x61, 0x33, 0x62, 0x32, 0x38, 0x36, 0x38, 0x39, 0x37, 0x37, 0x62, 0x61, 0x35, 0x63, 0x31, 0x37, 0x64, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x32, 0x37, 0x30, 0x63, 0x63, 0x34, 0x32, 0x31, 0x34, 0x31, 0x64, 0x64, 0x39, 0x39, 0x38, 0x61, 0x64, 0x32, 0x38, 0x36, 0x32, 0x64, 0x62, 0x64, 0x31, 0x66, 0x65, 0x39, 0x62, 0x34, 0x34, 0x65, 0x37, 0x65, 0x36, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x64, 0x39, 0x39, 0x34, 0x36, 0x38, 0x35, 0x30, 0x37, 0x61, 0x61, 0x30, 0x34, 0x31, 0x33, 0x66, 0x62, 0x36, 0x30, 0x64, 0x63, 0x61, 0x32, 0x61, 0x64, 0x63, 0x37, 0x66, 0x35, 0x36, 0x39, 0x63, 0x62, 0x33, 0x36, 0x62, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x38, 0x35, 0x32, 0x37, 0x33, 0x32, 0x62, 0x34, 0x63, 0x36, 0x35, 0x32, 0x66, 0x36, 0x63, 0x32, 0x65, 0x35, 0x38, 0x65, 0x62, 0x33, 0x36, 0x35, 0x38, 0x37, 0x65, 0x36, 0x30, 0x61, 0x36, 0x32, 0x64, 0x61, 0x31, 0x34, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x66, 0x32, 0x34, 0x63, 0x64, 0x64, 0x37, 0x63, 0x32, 0x32, 0x39, 0x32, 0x38, 0x63, 0x34, 0x34, 0x31, 0x65, 0x36, 0x39, 0x34, 0x64, 0x65, 0x34, 0x61, 0x61, 0x33, 0x31, 0x62, 0x30, 0x66, 0x61, 0x62, 0x35, 0x39, 0x37, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x32, 0x62, 0x39, 0x31, 0x62, 0x62, 0x66, 0x61, 0x61, 0x39, 0x65, 0x35, 0x38, 0x31, 0x65, 0x66, 0x36, 0x38, 0x33, 0x66, 0x63, 0x39, 0x30, 0x64, 0x39, 0x64, 0x62, 0x32, 0x32, 0x61, 0x38, 0x66, 0x34, 0x39, 0x66, 0x34, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x38, 0x35, 0x37, 0x37, 0x61, 0x30, 0x37, 0x33, 0x66, 0x62, 0x61, 0x66, 0x33, 0x33, 0x63, 0x34, 0x63, 0x64, 0x32, 0x30, 0x32, 0x65, 0x30, 0x30, 0x65, 0x61, 0x37, 0x30, 0x65, 0x66, 0x37, 0x31, 0x31, 0x62, 0x34, 0x30, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x61, 0x63, 0x63, 0x36, 0x66, 0x30, 0x38, 0x32, 0x61, 0x34, 0x34, 0x32, 0x38, 0x32, 0x38, 0x37, 0x36, 0x34, 0x64, 0x31, 0x31, 0x66, 0x35, 0x38, 0x64, 0x36, 0x38, 0x39, 0x34, 0x61, 0x65, 0x34, 0x30, 0x38, 0x66, 0x30, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x35, 0x35, 0x62, 0x63, 0x61, 0x63, 0x62, 0x64, 0x32, 0x31, 0x34, 0x34, 0x31, 0x65, 0x39, 0x35, 0x61, 0x64, 0x65, 0x65, 0x64, 0x63, 0x33, 0x30, 0x63, 0x31, 0x37, 0x32, 0x31, 0x38, 0x63, 0x38, 0x61, 0x34, 0x30, 0x38, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x37, 0x33, 0x63, 0x66, 0x32, 0x33, 0x37, 0x39, 0x66, 0x31, 0x32, 0x34, 0x38, 0x36, 0x30, 0x66, 0x37, 0x33, 0x64, 0x36, 0x64, 0x39, 0x31, 0x62, 0x66, 0x35, 0x39, 0x61, 0x63, 0x63, 0x35, 0x63, 0x66, 0x63, 0x38, 0x34, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x37, 0x34, 0x32, 0x62, 0x38, 0x39, 0x31, 0x30, 0x39, 0x34, 0x31, 0x65, 0x30, 0x39, 0x33, 0x32, 0x38, 0x33, 0x30, 0x61, 0x31, 0x64, 0x39, 0x36, 0x39, 0x32, 0x63, 0x66, 0x64, 0x32, 0x38, 0x34, 0x39, 0x34, 0x63, 0x66, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x61, 0x38, 0x63, 0x32, 0x38, 0x33, 0x30, 0x30, 0x38, 0x31, 0x62, 0x31, 0x30, 0x32, 0x64, 0x66, 0x36, 0x65, 0x30, 0x31, 0x33, 0x31, 0x36, 0x35, 0x37, 0x63, 0x30, 0x37, 0x61, 0x62, 0x36, 0x33, 0x35, 0x62, 0x35, 0x34, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x33, 0x30, 0x36, 0x34, 0x62, 0x64, 0x33, 0x33, 0x35, 0x35, 0x65, 0x36, 0x65, 0x30, 0x37, 0x65, 0x32, 0x64, 0x33, 0x37, 0x37, 0x30, 0x32, 0x34, 0x31, 0x32, 0x35, 0x61, 0x33, 0x33, 0x37, 0x37, 0x36, 0x63, 0x34, 0x61, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x32, 0x35, 0x65, 0x31, 0x63, 0x35, 0x62, 0x63, 0x37, 0x65, 0x35, 0x66, 0x35, 0x30, 0x65, 0x63, 0x31, 0x36, 0x66, 0x38, 0x38, 0x38, 0x35, 0x66, 0x32, 0x31, 0x30, 0x65, 0x61, 0x31, 0x62, 0x39, 0x33, 0x38, 0x38, 0x30, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x62, 0x35, 0x39, 0x62, 0x38, 0x36, 0x39, 0x38, 0x61, 0x37, 0x66, 0x62, 0x64, 0x33, 0x64, 0x32, 0x66, 0x38, 0x63, 0x37, 0x33, 0x61, 0x30, 0x30, 0x38, 0x39, 0x38, 0x38, 0x64, 0x65, 0x33, 0x65, 0x34, 0x30, 0x36, 0x62, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x35, 0x35, 0x62, 0x39, 0x33, 0x31, 0x35, 0x36, 0x66, 0x30, 0x39, 0x31, 0x30, 0x31, 0x32, 0x33, 0x33, 0x63, 0x36, 0x66, 0x37, 0x63, 0x66, 0x36, 0x65, 0x62, 0x33, 0x63, 0x34, 0x66, 0x31, 0x39, 0x36, 0x64, 0x33, 0x33, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x66, 0x33, 0x32, 0x63, 0x30, 0x61, 0x31, 0x66, 0x32, 0x64, 0x61, 0x61, 0x62, 0x36, 0x37, 0x36, 0x66, 0x65, 0x36, 0x39, 0x61, 0x62, 0x64, 0x39, 0x65, 0x30, 0x31, 0x38, 0x33, 0x35, 0x32, 0x64, 0x34, 0x63, 0x63, 0x64, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x35, 0x36, 0x62, 0x32, 0x38, 0x65, 0x63, 0x37, 0x38, 0x39, 0x30, 0x62, 0x37, 0x36, 0x66, 0x63, 0x30, 0x36, 0x31, 0x61, 0x31, 0x66, 0x65, 0x62, 0x35, 0x32, 0x64, 0x38, 0x32, 0x61, 0x65, 0x38, 0x31, 0x66, 0x62, 0x36, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x33, 0x39, 0x32, 0x35, 0x39, 0x65, 0x37, 0x66, 0x38, 0x35, 0x66, 0x32, 0x36, 0x35, 0x39, 0x62, 0x65, 0x66, 0x35, 0x66, 0x36, 0x30, 0x39, 0x65, 0x64, 0x38, 0x36, 0x62, 0x33, 0x64, 0x35, 0x39, 0x36, 0x63, 0x32, 0x30, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x65, 0x39, 0x32, 0x63, 0x31, 0x33, 0x37, 0x30, 0x65, 0x39, 0x65, 0x31, 0x38, 0x35, 0x39, 0x61, 0x35, 0x64, 0x66, 0x38, 0x33, 0x62, 0x35, 0x36, 0x64, 0x30, 0x66, 0x35, 0x38, 0x36, 0x61, 0x61, 0x33, 0x62, 0x34, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x61, 0x37, 0x62, 0x65, 0x63, 0x33, 0x33, 0x32, 0x61, 0x64, 0x64, 0x65, 0x31, 0x38, 0x62, 0x33, 0x31, 0x30, 0x34, 0x62, 0x35, 0x37, 0x39, 0x32, 0x35, 0x34, 0x36, 0x61, 0x61, 0x35, 0x39, 0x62, 0x38, 0x37, 0x39, 0x62, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x38, 0x38, 0x64, 0x66, 0x64, 0x30, 0x31, 0x30, 0x39, 0x31, 0x61, 0x34, 0x35, 0x61, 0x39, 0x65, 0x32, 0x36, 0x37, 0x36, 0x30, 0x32, 0x31, 0x65, 0x36, 0x34, 0x32, 0x38, 0x36, 0x63, 0x64, 0x33, 0x36, 0x62, 0x38, 0x64, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x32, 0x63, 0x34, 0x37, 0x37, 0x64, 0x36, 0x39, 0x61, 0x61, 0x64, 0x62, 0x61, 0x39, 0x61, 0x30, 0x62, 0x30, 0x66, 0x36, 0x32, 0x62, 0x37, 0x34, 0x35, 0x39, 0x65, 0x31, 0x37, 0x66, 0x62, 0x62, 0x31, 0x63, 0x31, 0x35, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x32, 0x37, 0x32, 0x64, 0x35, 0x65, 0x37, 0x35, 0x37, 0x34, 0x33, 0x31, 0x35, 0x64, 0x63, 0x61, 0x65, 0x39, 0x61, 0x62, 0x62, 0x64, 0x33, 0x31, 0x37, 0x62, 0x61, 0x63, 0x39, 0x30, 0x32, 0x38, 0x39, 0x64, 0x34, 0x37, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x36, 0x31, 0x35, 0x64, 0x39, 0x37, 0x35, 0x63, 0x30, 0x38, 0x38, 0x37, 0x65, 0x30, 0x63, 0x39, 0x31, 0x31, 0x33, 0x65, 0x63, 0x37, 0x32, 0x39, 0x38, 0x34, 0x32, 0x30, 0x61, 0x37, 0x39, 0x33, 0x61, 0x66, 0x38, 0x62, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x37, 0x61, 0x64, 0x66, 0x37, 0x64, 0x37, 0x30, 0x61, 0x36, 0x37, 0x34, 0x30, 0x66, 0x38, 0x64, 0x35, 0x31, 0x63, 0x62, 0x64, 0x64, 0x36, 0x38, 0x62, 0x62, 0x33, 0x66, 0x39, 0x31, 0x63, 0x34, 0x61, 0x35, 0x63, 0x65, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x35, 0x64, 0x39, 0x39, 0x39, 0x33, 0x31, 0x30, 0x34, 0x65, 0x34, 0x63, 0x62, 0x35, 0x34, 0x35, 0x65, 0x31, 0x37, 0x39, 0x61, 0x32, 0x61, 0x33, 0x66, 0x39, 0x37, 0x31, 0x66, 0x37, 0x34, 0x34, 0x66, 0x39, 0x38, 0x34, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x32, 0x39, 0x38, 0x33, 0x30, 0x61, 0x36, 0x31, 0x63, 0x31, 0x66, 0x31, 0x33, 0x63, 0x31, 0x39, 0x37, 0x65, 0x35, 0x35, 0x30, 0x62, 0x65, 0x64, 0x64, 0x66, 0x64, 0x36, 0x62, 0x64, 0x31, 0x39, 0x35, 0x63, 0x39, 0x64, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x32, 0x38, 0x32, 0x61, 0x62, 0x62, 0x62, 0x36, 0x64, 0x34, 0x61, 0x33, 0x63, 0x33, 0x63, 0x64, 0x33, 0x62, 0x35, 0x63, 0x61, 0x38, 0x31, 0x32, 0x66, 0x37, 0x36, 0x34, 0x33, 0x65, 0x38, 0x30, 0x33, 0x30, 0x35, 0x66, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x35, 0x32, 0x35, 0x38, 0x36, 0x64, 0x30, 0x32, 0x31, 0x61, 0x64, 0x30, 0x63, 0x66, 0x37, 0x37, 0x65, 0x30, 0x65, 0x39, 0x32, 0x38, 0x34, 0x30, 0x34, 0x61, 0x35, 0x39, 0x66, 0x33, 0x37, 0x34, 0x66, 0x66, 0x34, 0x35, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x66, 0x37, 0x62, 0x39, 0x32, 0x30, 0x30, 0x38, 0x38, 0x31, 0x33, 0x61, 0x65, 0x30, 0x61, 0x36, 0x37, 0x36, 0x65, 0x62, 0x32, 0x31, 0x32, 0x38, 0x31, 0x34, 0x61, 0x66, 0x61, 0x62, 0x33, 0x35, 0x32, 0x32, 0x31, 0x30, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x36, 0x36, 0x38, 0x36, 0x30, 0x37, 0x38, 0x66, 0x62, 0x36, 0x62, 0x63, 0x66, 0x39, 0x62, 0x61, 0x30, 0x61, 0x38, 0x61, 0x38, 0x64, 0x63, 0x36, 0x33, 0x61, 0x39, 0x30, 0x36, 0x66, 0x35, 0x66, 0x65, 0x61, 0x63, 0x30, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x36, 0x33, 0x33, 0x37, 0x39, 0x61, 0x37, 0x62, 0x66, 0x32, 0x63, 0x62, 0x39, 0x32, 0x33, 0x61, 0x38, 0x34, 0x63, 0x35, 0x30, 0x39, 0x33, 0x65, 0x36, 0x38, 0x64, 0x61, 0x63, 0x37, 0x66, 0x37, 0x35, 0x34, 0x38, 0x31, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x30, 0x32, 0x36, 0x34, 0x61, 0x30, 0x39, 0x66, 0x38, 0x63, 0x36, 0x38, 0x65, 0x33, 0x65, 0x36, 0x36, 0x32, 0x39, 0x37, 0x39, 0x35, 0x32, 0x38, 0x30, 0x66, 0x35, 0x36, 0x32, 0x35, 0x34, 0x66, 0x38, 0x36, 0x34, 0x30, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x38, 0x39, 0x31, 0x31, 0x35, 0x35, 0x66, 0x35, 0x30, 0x65, 0x34, 0x32, 0x30, 0x37, 0x34, 0x33, 0x37, 0x34, 0x63, 0x37, 0x33, 0x39, 0x62, 0x61, 0x61, 0x64, 0x66, 0x37, 0x64, 0x66, 0x32, 0x36, 0x35, 0x31, 0x31, 0x35, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x30, 0x32, 0x32, 0x61, 0x31, 0x32, 0x30, 0x37, 0x65, 0x39, 0x31, 0x30, 0x39, 0x31, 0x31, 0x66, 0x63, 0x39, 0x32, 0x38, 0x34, 0x39, 0x62, 0x30, 0x36, 0x39, 0x61, 0x62, 0x30, 0x63, 0x64, 0x61, 0x64, 0x30, 0x34, 0x33, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x38, 0x31, 0x65, 0x63, 0x37, 0x33, 0x32, 0x64, 0x34, 0x30, 0x31, 0x32, 0x30, 0x32, 0x62, 0x62, 0x39, 0x62, 0x64, 0x31, 0x33, 0x38, 0x36, 0x30, 0x39, 0x31, 0x30, 0x64, 0x64, 0x36, 0x63, 0x32, 0x39, 0x61, 0x63, 0x30, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x32, 0x66, 0x31, 0x61, 0x66, 0x65, 0x66, 0x37, 0x63, 0x35, 0x38, 0x36, 0x38, 0x63, 0x34, 0x34, 0x38, 0x33, 0x32, 0x66, 0x63, 0x37, 0x37, 0x63, 0x62, 0x30, 0x33, 0x62, 0x35, 0x35, 0x66, 0x38, 0x39, 0x65, 0x36, 0x64, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x66, 0x66, 0x35, 0x38, 0x32, 0x39, 0x35, 0x32, 0x66, 0x66, 0x32, 0x34, 0x34, 0x35, 0x38, 0x66, 0x37, 0x62, 0x31, 0x33, 0x64, 0x35, 0x31, 0x66, 0x30, 0x62, 0x34, 0x66, 0x39, 0x38, 0x37, 0x30, 0x32, 0x32, 0x63, 0x31, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x39, 0x31, 0x34, 0x62, 0x32, 0x32, 0x66, 0x63, 0x32, 0x66, 0x31, 0x33, 0x31, 0x35, 0x38, 0x34, 0x32, 0x34, 0x37, 0x64, 0x38, 0x32, 0x62, 0x65, 0x34, 0x66, 0x65, 0x63, 0x62, 0x66, 0x39, 0x37, 0x38, 0x61, 0x64, 0x34, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x32, 0x62, 0x65, 0x39, 0x35, 0x61, 0x62, 0x61, 0x31, 0x37, 0x63, 0x35, 0x33, 0x37, 0x31, 0x66, 0x65, 0x32, 0x62, 0x61, 0x38, 0x32, 0x38, 0x37, 0x39, 0x39, 0x62, 0x31, 0x66, 0x35, 0x35, 0x64, 0x32, 0x31, 0x37, 0x37, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x38, 0x66, 0x35, 0x62, 0x64, 0x32, 0x61, 0x32, 0x61, 0x65, 0x38, 0x39, 0x30, 0x32, 0x64, 0x62, 0x33, 0x37, 0x38, 0x34, 0x37, 0x64, 0x31, 0x63, 0x62, 0x30, 0x64, 0x62, 0x39, 0x33, 0x39, 0x30, 0x62, 0x30, 0x36, 0x32, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x39, 0x39, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x39, 0x37, 0x35, 0x38, 0x37, 0x34, 0x33, 0x62, 0x36, 0x30, 0x33, 0x65, 0x65, 0x61, 0x33, 0x61, 0x61, 0x30, 0x35, 0x32, 0x34, 0x62, 0x34, 0x32, 0x38, 0x38, 0x39, 0x37, 0x32, 0x33, 0x63, 0x34, 0x31, 0x35, 0x33, 0x39, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x38, 0x35, 0x63, 0x35, 0x39, 0x61, 0x34, 0x34, 0x39, 0x64, 0x66, 0x63, 0x35, 0x64, 0x61, 0x37, 0x38, 0x37, 0x64, 0x38, 0x32, 0x34, 0x34, 0x65, 0x37, 0x34, 0x36, 0x63, 0x36, 0x64, 0x37, 0x30, 0x63, 0x61, 0x61, 0x35, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x65, 0x65, 0x31, 0x39, 0x37, 0x66, 0x34, 0x62, 0x62, 0x66, 0x39, 0x66, 0x31, 0x62, 0x30, 0x36, 0x36, 0x32, 0x65, 0x34, 0x31, 0x63, 0x32, 0x62, 0x62, 0x64, 0x39, 0x61, 0x61, 0x31, 0x66, 0x37, 0x39, 0x39, 0x65, 0x38, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x37, 0x63, 0x32, 0x34, 0x32, 0x65, 0x64, 0x66, 0x66, 0x65, 0x61, 0x30, 0x39, 0x31, 0x62, 0x63, 0x35, 0x34, 0x64, 0x35, 0x37, 0x64, 0x66, 0x35, 0x64, 0x31, 0x66, 0x64, 0x62, 0x39, 0x33, 0x31, 0x30, 0x31, 0x34, 0x37, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x38, 0x32, 0x65, 0x37, 0x66, 0x36, 0x38, 0x65, 0x34, 0x31, 0x66, 0x32, 0x33, 0x38, 0x66, 0x65, 0x35, 0x31, 0x37, 0x38, 0x32, 0x39, 0x64, 0x65, 0x31, 0x35, 0x34, 0x37, 0x37, 0x66, 0x65, 0x30, 0x66, 0x36, 0x64, 0x64, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x62, 0x66, 0x34, 0x66, 0x63, 0x66, 0x65, 0x37, 0x37, 0x32, 0x65, 0x34, 0x35, 0x62, 0x38, 0x32, 0x36, 0x34, 0x34, 0x33, 0x38, 0x35, 0x32, 0x65, 0x36, 0x63, 0x33, 0x35, 0x31, 0x33, 0x35, 0x30, 0x63, 0x65, 0x37, 0x32, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x30, 0x34, 0x36, 0x32, 0x65, 0x35, 0x38, 0x66, 0x63, 0x63, 0x30, 0x37, 0x66, 0x33, 0x39, 0x35, 0x38, 0x34, 0x61, 0x31, 0x38, 0x37, 0x36, 0x33, 0x39, 0x34, 0x35, 0x31, 0x31, 0x36, 0x37, 0x65, 0x38, 0x35, 0x39, 0x32, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x61, 0x32, 0x37, 0x36, 0x39, 0x39, 0x63, 0x61, 0x64, 0x61, 0x38, 0x64, 0x63, 0x33, 0x61, 0x37, 0x36, 0x66, 0x37, 0x39, 0x33, 0x33, 0x61, 0x61, 0x36, 0x36, 0x63, 0x37, 0x31, 0x39, 0x31, 0x39, 0x30, 0x34, 0x30, 0x65, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x30, 0x34, 0x36, 0x62, 0x39, 0x31, 0x64, 0x61, 0x39, 0x62, 0x36, 0x31, 0x62, 0x36, 0x32, 0x39, 0x63, 0x62, 0x38, 0x62, 0x38, 0x65, 0x63, 0x30, 0x63, 0x33, 0x35, 0x31, 0x61, 0x30, 0x37, 0x65, 0x30, 0x37, 0x30, 0x33, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x30, 0x33, 0x33, 0x63, 0x31, 0x62, 0x36, 0x64, 0x30, 0x35, 0x65, 0x31, 0x63, 0x61, 0x38, 0x39, 0x62, 0x30, 0x39, 0x34, 0x38, 0x66, 0x63, 0x36, 0x34, 0x34, 0x35, 0x33, 0x66, 0x62, 0x65, 0x38, 0x37, 0x61, 0x62, 0x32, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x39, 0x38, 0x32, 0x32, 0x66, 0x35, 0x35, 0x37, 0x38, 0x62, 0x34, 0x30, 0x64, 0x64, 0x31, 0x66, 0x34, 0x34, 0x37, 0x31, 0x37, 0x30, 0x36, 0x62, 0x32, 0x32, 0x63, 0x64, 0x39, 0x37, 0x31, 0x33, 0x35, 0x32, 0x64, 0x61, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x34, 0x65, 0x38, 0x35, 0x33, 0x31, 0x34, 0x34, 0x65, 0x33, 0x33, 0x36, 0x34, 0x34, 0x39, 0x35, 0x65, 0x37, 0x61, 0x36, 0x39, 0x66, 0x61, 0x31, 0x64, 0x34, 0x36, 0x61, 0x62, 0x65, 0x61, 0x33, 0x61, 0x63, 0x30, 0x39, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x66, 0x37, 0x32, 0x38, 0x63, 0x66, 0x39, 0x33, 0x31, 0x32, 0x66, 0x32, 0x32, 0x31, 0x32, 0x38, 0x30, 0x32, 0x34, 0x65, 0x37, 0x30, 0x34, 0x36, 0x63, 0x32, 0x35, 0x31, 0x66, 0x35, 0x64, 0x63, 0x35, 0x39, 0x30, 0x31, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x38, 0x31, 0x66, 0x37, 0x66, 0x63, 0x30, 0x39, 0x31, 0x38, 0x34, 0x36, 0x31, 0x31, 0x35, 0x36, 0x38, 0x35, 0x37, 0x30, 0x62, 0x34, 0x39, 0x38, 0x36, 0x65, 0x32, 0x63, 0x37, 0x32, 0x38, 0x37, 0x32, 0x62, 0x37, 0x65, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x62, 0x34, 0x61, 0x36, 0x36, 0x31, 0x61, 0x33, 0x33, 0x61, 0x37, 0x31, 0x64, 0x34, 0x32, 0x34, 0x64, 0x34, 0x39, 0x62, 0x62, 0x35, 0x64, 0x66, 0x32, 0x38, 0x36, 0x32, 0x32, 0x65, 0x64, 0x34, 0x64, 0x66, 0x66, 0x63, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x66, 0x33, 0x62, 0x33, 0x64, 0x65, 0x61, 0x64, 0x31, 0x61, 0x36, 0x39, 0x32, 0x36, 0x64, 0x34, 0x39, 0x61, 0x61, 0x33, 0x32, 0x62, 0x31, 0x32, 0x63, 0x32, 0x32, 0x61, 0x66, 0x35, 0x34, 0x64, 0x39, 0x66, 0x66, 0x39, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x34, 0x31, 0x30, 0x39, 0x37, 0x31, 0x61, 0x64, 0x32, 0x32, 0x39, 0x63, 0x33, 0x30, 0x33, 0x36, 0x66, 0x34, 0x31, 0x61, 0x63, 0x66, 0x38, 0x35, 0x32, 0x66, 0x32, 0x61, 0x63, 0x39, 0x39, 0x39, 0x32, 0x38, 0x31, 0x39, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x31, 0x37, 0x36, 0x62, 0x35, 0x32, 0x38, 0x34, 0x62, 0x63, 0x65, 0x65, 0x33, 0x61, 0x38, 0x33, 0x38, 0x62, 0x61, 0x32, 0x34, 0x66, 0x36, 0x37, 0x66, 0x63, 0x37, 0x63, 0x62, 0x66, 0x36, 0x37, 0x64, 0x37, 0x38, 0x65, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x31, 0x32, 0x30, 0x30, 0x34, 0x36, 0x66, 0x36, 0x38, 0x33, 0x32, 0x31, 0x30, 0x32, 0x61, 0x37, 0x35, 0x32, 0x61, 0x37, 0x36, 0x36, 0x35, 0x36, 0x36, 0x39, 0x31, 0x63, 0x38, 0x36, 0x33, 0x65, 0x31, 0x37, 0x65, 0x35, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x66, 0x34, 0x37, 0x32, 0x66, 0x65, 0x34, 0x66, 0x32, 0x32, 0x62, 0x37, 0x37, 0x64, 0x62, 0x34, 0x38, 0x39, 0x32, 0x31, 0x39, 0x65, 0x61, 0x34, 0x30, 0x32, 0x33, 0x64, 0x31, 0x31, 0x35, 0x38, 0x32, 0x61, 0x39, 0x33, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x64, 0x36, 0x34, 0x63, 0x66, 0x39, 0x64, 0x66, 0x30, 0x39, 0x37, 0x34, 0x31, 0x31, 0x33, 0x33, 0x64, 0x31, 0x37, 0x30, 0x34, 0x38, 0x35, 0x66, 0x64, 0x32, 0x34, 0x62, 0x30, 0x30, 0x35, 0x30, 0x31, 0x31, 0x64, 0x35, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x38, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x35, 0x30, 0x35, 0x65, 0x32, 0x38, 0x37, 0x31, 0x66, 0x37, 0x64, 0x65, 0x62, 0x37, 0x61, 0x36, 0x33, 0x38, 0x39, 0x35, 0x32, 0x30, 0x38, 0x65, 0x38, 0x32, 0x32, 0x37, 0x64, 0x63, 0x61, 0x61, 0x31, 0x62, 0x66, 0x66, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x32, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x31, 0x65, 0x33, 0x61, 0x39, 0x31, 0x62, 0x66, 0x64, 0x63, 0x32, 0x66, 0x31, 0x63, 0x38, 0x34, 0x32, 0x38, 0x61, 0x30, 0x31, 0x31, 0x39, 0x64, 0x30, 0x33, 0x61, 0x34, 0x31, 0x36, 0x30, 0x31, 0x34, 0x31, 0x37, 0x65, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x36, 0x39, 0x61, 0x30, 0x64, 0x32, 0x61, 0x33, 0x31, 0x63, 0x33, 0x64, 0x62, 0x66, 0x37, 0x61, 0x39, 0x31, 0x32, 0x32, 0x31, 0x31, 0x36, 0x39, 0x30, 0x31, 0x62, 0x32, 0x62, 0x64, 0x66, 0x65, 0x39, 0x38, 0x30, 0x32, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x61, 0x38, 0x31, 0x36, 0x38, 0x30, 0x65, 0x34, 0x36, 0x35, 0x66, 0x38, 0x38, 0x37, 0x39, 0x30, 0x66, 0x30, 0x30, 0x37, 0x34, 0x66, 0x36, 0x30, 0x62, 0x34, 0x66, 0x33, 0x35, 0x66, 0x35, 0x64, 0x31, 0x65, 0x36, 0x61, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x37, 0x39, 0x38, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x34, 0x61, 0x36, 0x62, 0x62, 0x33, 0x30, 0x32, 0x62, 0x38, 0x61, 0x62, 0x61, 0x37, 0x61, 0x35, 0x62, 0x35, 0x37, 0x39, 0x64, 0x66, 0x39, 0x33, 0x65, 0x30, 0x64, 0x66, 0x31, 0x35, 0x37, 0x34, 0x39, 0x36, 0x37, 0x36, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x34, 0x63, 0x63, 0x38, 0x30, 0x38, 0x36, 0x61, 0x38, 0x37, 0x31, 0x30, 0x66, 0x39, 0x31, 0x62, 0x32, 0x31, 0x37, 0x32, 0x30, 0x39, 0x30, 0x35, 0x39, 0x31, 0x32, 0x63, 0x64, 0x37, 0x39, 0x36, 0x34, 0x61, 0x65, 0x38, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x61, 0x63, 0x61, 0x30, 0x38, 0x64, 0x35, 0x62, 0x65, 0x38, 0x35, 0x65, 0x62, 0x62, 0x39, 0x66, 0x33, 0x31, 0x33, 0x32, 0x64, 0x66, 0x63, 0x31, 0x62, 0x36, 0x32, 0x30, 0x38, 0x32, 0x34, 0x65, 0x64, 0x66, 0x65, 0x64, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x35, 0x31, 0x61, 0x30, 0x36, 0x33, 0x63, 0x63, 0x64, 0x62, 0x33, 0x30, 0x35, 0x34, 0x39, 0x30, 0x37, 0x37, 0x66, 0x31, 0x64, 0x31, 0x33, 0x39, 0x65, 0x37, 0x32, 0x64, 0x65, 0x37, 0x39, 0x37, 0x31, 0x31, 0x39, 0x37, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x34, 0x61, 0x34, 0x61, 0x63, 0x38, 0x64, 0x35, 0x34, 0x30, 0x61, 0x39, 0x32, 0x38, 0x39, 0x63, 0x36, 0x38, 0x64, 0x39, 0x36, 0x30, 0x64, 0x35, 0x66, 0x62, 0x37, 0x63, 0x63, 0x34, 0x35, 0x61, 0x37, 0x37, 0x38, 0x33, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x64, 0x62, 0x35, 0x36, 0x35, 0x37, 0x62, 0x62, 0x37, 0x32, 0x66, 0x31, 0x30, 0x64, 0x35, 0x38, 0x66, 0x32, 0x33, 0x31, 0x66, 0x64, 0x64, 0x66, 0x31, 0x31, 0x39, 0x38, 0x30, 0x61, 0x66, 0x66, 0x36, 0x37, 0x38, 0x36, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x36, 0x61, 0x63, 0x65, 0x38, 0x36, 0x35, 0x65, 0x32, 0x63, 0x35, 0x30, 0x65, 0x61, 0x34, 0x36, 0x39, 0x38, 0x64, 0x32, 0x31, 0x36, 0x61, 0x62, 0x34, 0x35, 0x35, 0x64, 0x66, 0x66, 0x35, 0x61, 0x31, 0x31, 0x63, 0x64, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x61, 0x65, 0x61, 0x31, 0x33, 0x63, 0x37, 0x33, 0x33, 0x34, 0x31, 0x32, 0x64, 0x63, 0x34, 0x62, 0x34, 0x39, 0x30, 0x34, 0x30, 0x32, 0x62, 0x66, 0x65, 0x66, 0x32, 0x37, 0x61, 0x30, 0x33, 0x39, 0x37, 0x61, 0x39, 0x62, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x30, 0x35, 0x39, 0x34, 0x63, 0x34, 0x66, 0x33, 0x36, 0x36, 0x34, 0x65, 0x66, 0x38, 0x34, 0x39, 0x63, 0x63, 0x61, 0x36, 0x32, 0x32, 0x37, 0x62, 0x38, 0x61, 0x32, 0x35, 0x61, 0x61, 0x36, 0x39, 0x30, 0x39, 0x32, 0x35, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x32, 0x66, 0x61, 0x30, 0x61, 0x30, 0x31, 0x39, 0x30, 0x38, 0x38, 0x64, 0x62, 0x33, 0x31, 0x36, 0x36, 0x66, 0x36, 0x31, 0x31, 0x39, 0x34, 0x33, 0x38, 0x64, 0x30, 0x37, 0x61, 0x39, 0x39, 0x66, 0x38, 0x62, 0x61, 0x32, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x66, 0x66, 0x61, 0x64, 0x30, 0x37, 0x64, 0x62, 0x39, 0x36, 0x31, 0x33, 0x38, 0x63, 0x34, 0x62, 0x32, 0x61, 0x35, 0x33, 0x30, 0x65, 0x63, 0x31, 0x63, 0x37, 0x64, 0x65, 0x32, 0x39, 0x62, 0x38, 0x61, 0x30, 0x35, 0x39, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x61, 0x66, 0x32, 0x35, 0x64, 0x33, 0x66, 0x36, 0x66, 0x38, 0x65, 0x65, 0x61, 0x31, 0x35, 0x33, 0x31, 0x33, 0x64, 0x35, 0x66, 0x65, 0x34, 0x35, 0x35, 0x37, 0x65, 0x38, 0x31, 0x30, 0x63, 0x35, 0x32, 0x34, 0x63, 0x30, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x61, 0x32, 0x32, 0x65, 0x35, 0x39, 0x38, 0x64, 0x61, 0x62, 0x64, 0x33, 0x38, 0x65, 0x61, 0x36, 0x65, 0x39, 0x35, 0x38, 0x62, 0x64, 0x37, 0x39, 0x64, 0x34, 0x38, 0x64, 0x64, 0x64, 0x39, 0x36, 0x30, 0x34, 0x66, 0x34, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x61, 0x34, 0x33, 0x35, 0x64, 0x65, 0x34, 0x34, 0x61, 0x30, 0x31, 0x62, 0x64, 0x30, 0x65, 0x63, 0x62, 0x32, 0x39, 0x65, 0x34, 0x34, 0x65, 0x34, 0x37, 0x36, 0x34, 0x34, 0x65, 0x34, 0x36, 0x61, 0x30, 0x63, 0x64, 0x66, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x31, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x39, 0x62, 0x34, 0x37, 0x36, 0x34, 0x39, 0x63, 0x66, 0x61, 0x64, 0x39, 0x39, 0x33, 0x65, 0x34, 0x30, 0x36, 0x34, 0x64, 0x32, 0x36, 0x33, 0x36, 0x61, 0x34, 0x62, 0x61, 0x61, 0x30, 0x36, 0x32, 0x33, 0x33, 0x30, 0x35, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x32, 0x31, 0x62, 0x36, 0x30, 0x35, 0x30, 0x32, 0x36, 0x66, 0x34, 0x66, 0x66, 0x62, 0x32, 0x39, 0x36, 0x61, 0x33, 0x65, 0x30, 0x65, 0x64, 0x63, 0x62, 0x33, 0x39, 0x30, 0x63, 0x39, 0x63, 0x38, 0x35, 0x36, 0x30, 0x38, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x62, 0x66, 0x32, 0x34, 0x63, 0x62, 0x38, 0x33, 0x36, 0x38, 0x36, 0x62, 0x63, 0x34, 0x36, 0x39, 0x38, 0x36, 0x39, 0x66, 0x65, 0x66, 0x62, 0x30, 0x34, 0x34, 0x62, 0x39, 0x30, 0x39, 0x37, 0x31, 0x36, 0x39, 0x39, 0x33, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x64, 0x39, 0x31, 0x61, 0x39, 0x32, 0x64, 0x37, 0x34, 0x66, 0x63, 0x38, 0x36, 0x31, 0x61, 0x37, 0x32, 0x39, 0x36, 0x34, 0x36, 0x64, 0x62, 0x31, 0x39, 0x32, 0x61, 0x31, 0x32, 0x35, 0x62, 0x37, 0x39, 0x66, 0x35, 0x33, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x30, 0x36, 0x36, 0x32, 0x62, 0x34, 0x31, 0x30, 0x32, 0x39, 0x38, 0x63, 0x39, 0x39, 0x66, 0x33, 0x31, 0x31, 0x64, 0x33, 0x61, 0x31, 0x34, 0x35, 0x34, 0x61, 0x31, 0x65, 0x65, 0x64, 0x62, 0x61, 0x32, 0x66, 0x65, 0x61, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x39, 0x30, 0x38, 0x61, 0x61, 0x37, 0x34, 0x37, 0x38, 0x61, 0x36, 0x64, 0x31, 0x63, 0x39, 0x62, 0x39, 0x62, 0x30, 0x32, 0x38, 0x31, 0x31, 0x34, 0x38, 0x66, 0x38, 0x66, 0x39, 0x66, 0x32, 0x34, 0x32, 0x62, 0x39, 0x66, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x34, 0x33, 0x38, 0x63, 0x39, 0x39, 0x64, 0x64, 0x35, 0x31, 0x65, 0x66, 0x31, 0x63, 0x61, 0x38, 0x33, 0x38, 0x36, 0x61, 0x66, 0x30, 0x61, 0x33, 0x31, 0x37, 0x65, 0x39, 0x62, 0x30, 0x34, 0x31, 0x34, 0x35, 0x37, 0x38, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x35, 0x62, 0x62, 0x30, 0x37, 0x30, 0x65, 0x37, 0x38, 0x31, 0x31, 0x37, 0x32, 0x65, 0x62, 0x31, 0x36, 0x30, 0x38, 0x61, 0x66, 0x37, 0x66, 0x63, 0x32, 0x38, 0x39, 0x35, 0x64, 0x36, 0x63, 0x62, 0x38, 0x37, 0x31, 0x39, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x31, 0x64, 0x32, 0x36, 0x65, 0x66, 0x36, 0x37, 0x35, 0x39, 0x62, 0x61, 0x35, 0x62, 0x39, 0x66, 0x32, 0x30, 0x66, 0x64, 0x63, 0x64, 0x36, 0x36, 0x66, 0x31, 0x36, 0x31, 0x33, 0x32, 0x63, 0x33, 0x35, 0x32, 0x34, 0x31, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x66, 0x33, 0x37, 0x30, 0x64, 0x34, 0x62, 0x65, 0x64, 0x39, 0x64, 0x35, 0x37, 0x63, 0x36, 0x66, 0x34, 0x39, 0x63, 0x39, 0x39, 0x39, 0x64, 0x65, 0x37, 0x32, 0x39, 0x65, 0x65, 0x35, 0x36, 0x39, 0x64, 0x33, 0x66, 0x34, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x65, 0x33, 0x35, 0x61, 0x61, 0x62, 0x62, 0x32, 0x64, 0x65, 0x65, 0x66, 0x34, 0x30, 0x38, 0x62, 0x62, 0x39, 0x62, 0x35, 0x61, 0x63, 0x65, 0x66, 0x37, 0x31, 0x34, 0x34, 0x35, 0x37, 0x64, 0x66, 0x64, 0x65, 0x36, 0x32, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x63, 0x66, 0x63, 0x34, 0x30, 0x36, 0x35, 0x30, 0x30, 0x38, 0x63, 0x66, 0x64, 0x33, 0x32, 0x33, 0x33, 0x30, 0x35, 0x66, 0x36, 0x32, 0x38, 0x36, 0x62, 0x35, 0x37, 0x61, 0x34, 0x64, 0x64, 0x37, 0x65, 0x65, 0x65, 0x32, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x37, 0x32, 0x35, 0x64, 0x37, 0x30, 0x62, 0x65, 0x39, 0x37, 0x65, 0x36, 0x37, 0x37, 0x65, 0x33, 0x63, 0x38, 0x65, 0x38, 0x35, 0x63, 0x30, 0x62, 0x32, 0x36, 0x65, 0x66, 0x33, 0x31, 0x65, 0x39, 0x39, 0x35, 0x35, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x66, 0x36, 0x62, 0x36, 0x35, 0x37, 0x32, 0x36, 0x36, 0x65, 0x39, 0x31, 0x61, 0x34, 0x64, 0x61, 0x65, 0x36, 0x30, 0x33, 0x33, 0x64, 0x64, 0x61, 0x63, 0x31, 0x35, 0x33, 0x33, 0x32, 0x64, 0x64, 0x38, 0x64, 0x32, 0x62, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x66, 0x30, 0x30, 0x36, 0x66, 0x33, 0x34, 0x39, 0x34, 0x65, 0x64, 0x36, 0x63, 0x31, 0x36, 0x65, 0x62, 0x39, 0x32, 0x61, 0x61, 0x66, 0x39, 0x30, 0x34, 0x34, 0x66, 0x61, 0x38, 0x61, 0x62, 0x62, 0x35, 0x66, 0x64, 0x35, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x65, 0x61, 0x33, 0x38, 0x36, 0x66, 0x39, 0x64, 0x30, 0x66, 0x64, 0x38, 0x30, 0x34, 0x64, 0x30, 0x32, 0x38, 0x31, 0x38, 0x66, 0x32, 0x33, 0x37, 0x62, 0x37, 0x64, 0x39, 0x66, 0x61, 0x37, 0x36, 0x34, 0x36, 0x64, 0x33, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x31, 0x32, 0x31, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x35, 0x62, 0x33, 0x33, 0x34, 0x31, 0x65, 0x38, 0x66, 0x31, 0x35, 0x63, 0x38, 0x30, 0x33, 0x32, 0x39, 0x33, 0x32, 0x30, 0x63, 0x33, 0x39, 0x37, 0x37, 0x65, 0x33, 0x62, 0x39, 0x30, 0x65, 0x37, 0x38, 0x32, 0x36, 0x61, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x36, 0x34, 0x39, 0x64, 0x61, 0x33, 0x62, 0x39, 0x36, 0x61, 0x31, 0x30, 0x32, 0x63, 0x64, 0x63, 0x36, 0x64, 0x62, 0x36, 0x35, 0x32, 0x61, 0x30, 0x63, 0x30, 0x37, 0x64, 0x36, 0x35, 0x62, 0x31, 0x65, 0x34, 0x34, 0x33, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x35, 0x38, 0x66, 0x64, 0x64, 0x64, 0x37, 0x31, 0x38, 0x39, 0x38, 0x64, 0x65, 0x37, 0x37, 0x33, 0x61, 0x37, 0x34, 0x66, 0x64, 0x61, 0x65, 0x34, 0x35, 0x65, 0x37, 0x62, 0x64, 0x38, 0x34, 0x65, 0x66, 0x34, 0x33, 0x36, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x35, 0x36, 0x31, 0x34, 0x39, 0x66, 0x35, 0x62, 0x35, 0x30, 0x36, 0x33, 0x62, 0x65, 0x61, 0x31, 0x34, 0x65, 0x31, 0x35, 0x36, 0x36, 0x31, 0x66, 0x66, 0x62, 0x35, 0x38, 0x66, 0x39, 0x62, 0x34, 0x35, 0x39, 0x61, 0x39, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x33, 0x38, 0x65, 0x38, 0x38, 0x30, 0x63, 0x62, 0x32, 0x37, 0x36, 0x36, 0x62, 0x30, 0x63, 0x31, 0x63, 0x65, 0x61, 0x65, 0x63, 0x39, 0x64, 0x32, 0x34, 0x31, 0x38, 0x66, 0x63, 0x65, 0x62, 0x39, 0x35, 0x32, 0x61, 0x30, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x64, 0x38, 0x30, 0x65, 0x64, 0x61, 0x37, 0x66, 0x35, 0x35, 0x30, 0x35, 0x34, 0x64, 0x62, 0x39, 0x66, 0x62, 0x35, 0x32, 0x38, 0x32, 0x34, 0x35, 0x31, 0x36, 0x38, 0x38, 0x66, 0x32, 0x36, 0x62, 0x62, 0x33, 0x37, 0x34, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x61, 0x62, 0x39, 0x34, 0x38, 0x61, 0x65, 0x38, 0x31, 0x64, 0x61, 0x33, 0x30, 0x31, 0x64, 0x39, 0x37, 0x32, 0x65, 0x33, 0x66, 0x36, 0x31, 0x37, 0x61, 0x39, 0x31, 0x32, 0x65, 0x35, 0x61, 0x37, 0x35, 0x33, 0x37, 0x31, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x35, 0x64, 0x38, 0x63, 0x38, 0x65, 0x65, 0x64, 0x36, 0x63, 0x38, 0x35, 0x61, 0x63, 0x32, 0x31, 0x35, 0x36, 0x36, 0x31, 0x64, 0x65, 0x30, 0x32, 0x36, 0x36, 0x37, 0x36, 0x38, 0x32, 0x33, 0x66, 0x61, 0x61, 0x30, 0x61, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x32, 0x32, 0x61, 0x33, 0x36, 0x61, 0x30, 0x31, 0x65, 0x38, 0x34, 0x31, 0x64, 0x30, 0x33, 0x66, 0x37, 0x38, 0x30, 0x39, 0x33, 0x35, 0x65, 0x39, 0x31, 0x37, 0x64, 0x38, 0x35, 0x64, 0x35, 0x61, 0x36, 0x37, 0x61, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x62, 0x38, 0x62, 0x64, 0x66, 0x33, 0x64, 0x66, 0x39, 0x61, 0x35, 0x31, 0x62, 0x30, 0x62, 0x39, 0x31, 0x64, 0x31, 0x36, 0x61, 0x62, 0x62, 0x65, 0x61, 0x30, 0x35, 0x62, 0x62, 0x34, 0x37, 0x38, 0x33, 0x63, 0x38, 0x36, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x66, 0x36, 0x62, 0x38, 0x65, 0x36, 0x32, 0x31, 0x33, 0x64, 0x62, 0x63, 0x39, 0x61, 0x35, 0x35, 0x38, 0x31, 0x66, 0x34, 0x63, 0x63, 0x65, 0x36, 0x36, 0x35, 0x35, 0x66, 0x39, 0x35, 0x32, 0x35, 0x32, 0x62, 0x64, 0x62, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x39, 0x39, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x39, 0x39, 0x34, 0x39, 0x33, 0x63, 0x65, 0x36, 0x35, 0x37, 0x37, 0x32, 0x63, 0x66, 0x39, 0x33, 0x65, 0x39, 0x38, 0x61, 0x66, 0x31, 0x31, 0x39, 0x35, 0x65, 0x63, 0x30, 0x39, 0x35, 0x35, 0x64, 0x63, 0x39, 0x38, 0x30, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x61, 0x62, 0x35, 0x61, 0x62, 0x61, 0x35, 0x62, 0x38, 0x32, 0x38, 0x64, 0x65, 0x31, 0x37, 0x30, 0x35, 0x33, 0x38, 0x31, 0x66, 0x33, 0x38, 0x62, 0x63, 0x37, 0x34, 0x34, 0x62, 0x33, 0x32, 0x62, 0x61, 0x31, 0x62, 0x34, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x38, 0x32, 0x38, 0x32, 0x36, 0x64, 0x33, 0x63, 0x32, 0x39, 0x34, 0x38, 0x31, 0x64, 0x63, 0x63, 0x32, 0x62, 0x64, 0x32, 0x39, 0x35, 0x30, 0x30, 0x34, 0x37, 0x65, 0x38, 0x62, 0x36, 0x30, 0x34, 0x38, 0x36, 0x63, 0x33, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x34, 0x37, 0x34, 0x62, 0x63, 0x36, 0x36, 0x61, 0x35, 0x34, 0x37, 0x38, 0x30, 0x30, 0x36, 0x36, 0x61, 0x61, 0x34, 0x66, 0x35, 0x31, 0x32, 0x65, 0x65, 0x66, 0x61, 0x37, 0x37, 0x33, 0x61, 0x62, 0x66, 0x39, 0x31, 0x39, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x39, 0x30, 0x33, 0x65, 0x39, 0x39, 0x37, 0x38, 0x65, 0x65, 0x32, 0x30, 0x61, 0x33, 0x38, 0x63, 0x33, 0x66, 0x34, 0x39, 0x38, 0x64, 0x36, 0x33, 0x64, 0x35, 0x37, 0x66, 0x33, 0x31, 0x61, 0x33, 0x39, 0x66, 0x36, 0x61, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x31, 0x34, 0x38, 0x30, 0x63, 0x63, 0x38, 0x63, 0x62, 0x34, 0x37, 0x36, 0x66, 0x38, 0x64, 0x30, 0x31, 0x66, 0x66, 0x33, 0x30, 0x38, 0x31, 0x32, 0x65, 0x37, 0x63, 0x37, 0x30, 0x65, 0x30, 0x35, 0x61, 0x66, 0x61, 0x66, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x37, 0x37, 0x31, 0x30, 0x33, 0x39, 0x33, 0x34, 0x35, 0x61, 0x33, 0x34, 0x33, 0x30, 0x30, 0x31, 0x62, 0x63, 0x30, 0x66, 0x38, 0x61, 0x35, 0x39, 0x32, 0x33, 0x62, 0x31, 0x32, 0x36, 0x62, 0x36, 0x30, 0x64, 0x35, 0x30, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x61, 0x34, 0x36, 0x37, 0x39, 0x36, 0x38, 0x35, 0x66, 0x61, 0x31, 0x34, 0x31, 0x39, 0x36, 0x63, 0x32, 0x65, 0x39, 0x32, 0x33, 0x30, 0x63, 0x38, 0x63, 0x34, 0x65, 0x33, 0x33, 0x62, 0x66, 0x66, 0x62, 0x63, 0x31, 0x30, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x34, 0x30, 0x30, 0x64, 0x66, 0x66, 0x38, 0x35, 0x39, 0x34, 0x64, 0x65, 0x37, 0x32, 0x32, 0x38, 0x62, 0x34, 0x66, 0x64, 0x31, 0x35, 0x63, 0x33, 0x32, 0x33, 0x32, 0x32, 0x62, 0x37, 0x35, 0x62, 0x62, 0x38, 0x37, 0x64, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x33, 0x33, 0x36, 0x64, 0x66, 0x62, 0x39, 0x36, 0x62, 0x36, 0x62, 0x63, 0x62, 0x65, 0x34, 0x62, 0x33, 0x65, 0x64, 0x66, 0x33, 0x32, 0x30, 0x35, 0x62, 0x65, 0x35, 0x37, 0x32, 0x33, 0x63, 0x39, 0x30, 0x66, 0x61, 0x64, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x62, 0x31, 0x66, 0x31, 0x66, 0x63, 0x61, 0x33, 0x66, 0x61, 0x34, 0x37, 0x32, 0x36, 0x39, 0x66, 0x32, 0x31, 0x62, 0x30, 0x36, 0x31, 0x63, 0x33, 0x35, 0x33, 0x62, 0x37, 0x66, 0x35, 0x65, 0x39, 0x36, 0x64, 0x39, 0x30, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x65, 0x34, 0x31, 0x34, 0x39, 0x34, 0x30, 0x34, 0x38, 0x37, 0x66, 0x64, 0x32, 0x34, 0x65, 0x33, 0x39, 0x30, 0x33, 0x37, 0x38, 0x32, 0x38, 0x35, 0x63, 0x35, 0x64, 0x37, 0x62, 0x39, 0x33, 0x33, 0x34, 0x64, 0x38, 0x62, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x62, 0x35, 0x62, 0x34, 0x63, 0x34, 0x31, 0x63, 0x64, 0x64, 0x62, 0x38, 0x32, 0x39, 0x36, 0x39, 0x30, 0x63, 0x32, 0x66, 0x64, 0x61, 0x37, 0x66, 0x32, 0x30, 0x63, 0x38, 0x35, 0x65, 0x36, 0x32, 0x39, 0x64, 0x64, 0x35, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x36, 0x33, 0x30, 0x34, 0x32, 0x66, 0x32, 0x35, 0x65, 0x64, 0x33, 0x32, 0x38, 0x38, 0x34, 0x61, 0x64, 0x32, 0x36, 0x65, 0x33, 0x61, 0x64, 0x39, 0x35, 0x39, 0x65, 0x62, 0x39, 0x34, 0x65, 0x61, 0x33, 0x36, 0x62, 0x66, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x62, 0x33, 0x66, 0x32, 0x34, 0x34, 0x62, 0x63, 0x61, 0x37, 0x62, 0x37, 0x64, 0x65, 0x35, 0x62, 0x34, 0x38, 0x61, 0x35, 0x33, 0x65, 0x64, 0x62, 0x39, 0x63, 0x62, 0x65, 0x61, 0x62, 0x30, 0x62, 0x36, 0x64, 0x38, 0x38, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x31, 0x61, 0x35, 0x63, 0x34, 0x33, 0x63, 0x35, 0x37, 0x34, 0x64, 0x34, 0x65, 0x39, 0x33, 0x34, 0x32, 0x39, 0x39, 0x62, 0x32, 0x34, 0x66, 0x31, 0x34, 0x37, 0x32, 0x63, 0x64, 0x63, 0x39, 0x66, 0x64, 0x36, 0x66, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x64, 0x39, 0x61, 0x62, 0x39, 0x36, 0x36, 0x34, 0x62, 0x63, 0x66, 0x36, 0x64, 0x66, 0x32, 0x30, 0x33, 0x63, 0x33, 0x34, 0x36, 0x66, 0x63, 0x36, 0x39, 0x32, 0x66, 0x64, 0x39, 0x63, 0x62, 0x61, 0x62, 0x39, 0x32, 0x30, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x65, 0x38, 0x63, 0x32, 0x63, 0x62, 0x38, 0x37, 0x36, 0x66, 0x62, 0x65, 0x38, 0x61, 0x34, 0x63, 0x63, 0x61, 0x38, 0x32, 0x39, 0x30, 0x33, 0x36, 0x31, 0x61, 0x37, 0x65, 0x61, 0x30, 0x31, 0x61, 0x36, 0x39, 0x66, 0x64, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x31, 0x33, 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x37, 0x63, 0x32, 0x35, 0x32, 0x30, 0x34, 0x32, 0x65, 0x37, 0x34, 0x36, 0x38, 0x61, 0x33, 0x66, 0x66, 0x37, 0x37, 0x33, 0x64, 0x36, 0x34, 0x35, 0x30, 0x62, 0x62, 0x61, 0x38, 0x35, 0x65, 0x66, 0x61, 0x32, 0x36, 0x33, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x30, 0x36, 0x65, 0x36, 0x39, 0x32, 0x33, 0x65, 0x64, 0x64, 0x35, 0x33, 0x63, 0x61, 0x38, 0x65, 0x64, 0x36, 0x35, 0x30, 0x39, 0x36, 0x38, 0x61, 0x39, 0x31, 0x30, 0x38, 0x64, 0x36, 0x63, 0x63, 0x66, 0x64, 0x39, 0x36, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x39, 0x39, 0x39, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x31, 0x65, 0x32, 0x35, 0x64, 0x62, 0x35, 0x31, 0x36, 0x62, 0x30, 0x66, 0x30, 0x39, 0x39, 0x66, 0x61, 0x65, 0x62, 0x66, 0x64, 0x39, 0x34, 0x66, 0x38, 0x39, 0x30, 0x63, 0x66, 0x39, 0x36, 0x36, 0x36, 0x30, 0x38, 0x33, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x64, 0x62, 0x63, 0x33, 0x61, 0x38, 0x34, 0x34, 0x65, 0x34, 0x30, 0x64, 0x39, 0x36, 0x62, 0x32, 0x66, 0x33, 0x61, 0x36, 0x33, 0x35, 0x33, 0x32, 0x32, 0x65, 0x36, 0x30, 0x36, 0x35, 0x66, 0x34, 0x63, 0x61, 0x30, 0x65, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x34, 0x37, 0x61, 0x36, 0x31, 0x62, 0x37, 0x32, 0x35, 0x33, 0x35, 0x31, 0x39, 0x33, 0x63, 0x35, 0x36, 0x31, 0x63, 0x63, 0x63, 0x63, 0x37, 0x35, 0x63, 0x33, 0x66, 0x33, 0x63, 0x65, 0x30, 0x38, 0x30, 0x34, 0x61, 0x32, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x33, 0x31, 0x33, 0x30, 0x35, 0x63, 0x33, 0x31, 0x39, 0x66, 0x39, 0x32, 0x37, 0x33, 0x64, 0x33, 0x39, 0x33, 0x36, 0x64, 0x38, 0x66, 0x35, 0x62, 0x32, 0x66, 0x37, 0x31, 0x65, 0x39, 0x62, 0x31, 0x62, 0x32, 0x32, 0x39, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x62, 0x32, 0x64, 0x35, 0x37, 0x33, 0x32, 0x39, 0x37, 0x33, 0x36, 0x30, 0x31, 0x30, 0x32, 0x63, 0x30, 0x37, 0x61, 0x31, 0x38, 0x66, 0x63, 0x32, 0x31, 0x64, 0x66, 0x32, 0x65, 0x37, 0x34, 0x39, 0x39, 0x66, 0x66, 0x34, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x38, 0x34, 0x36, 0x34, 0x62, 0x66, 0x36, 0x34, 0x66, 0x32, 0x34, 0x31, 0x31, 0x33, 0x35, 0x36, 0x65, 0x34, 0x64, 0x33, 0x32, 0x35, 0x30, 0x65, 0x66, 0x65, 0x66, 0x65, 0x35, 0x63, 0x35, 0x30, 0x61, 0x35, 0x66, 0x36, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x37, 0x63, 0x63, 0x32, 0x62, 0x66, 0x64, 0x61, 0x30, 0x65, 0x30, 0x38, 0x38, 0x64, 0x30, 0x32, 0x65, 0x66, 0x66, 0x37, 0x30, 0x62, 0x33, 0x38, 0x62, 0x30, 0x38, 0x61, 0x61, 0x35, 0x33, 0x63, 0x63, 0x33, 0x30, 0x39, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x63, 0x62, 0x39, 0x38, 0x39, 0x36, 0x34, 0x34, 0x35, 0x66, 0x37, 0x30, 0x61, 0x31, 0x30, 0x61, 0x31, 0x34, 0x32, 0x31, 0x35, 0x32, 0x39, 0x36, 0x64, 0x61, 0x66, 0x36, 0x31, 0x34, 0x65, 0x33, 0x32, 0x63, 0x66, 0x34, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x64, 0x37, 0x30, 0x32, 0x34, 0x33, 0x64, 0x38, 0x38, 0x62, 0x66, 0x30, 0x34, 0x30, 0x30, 0x66, 0x35, 0x37, 0x63, 0x38, 0x63, 0x31, 0x66, 0x64, 0x35, 0x37, 0x38, 0x31, 0x31, 0x38, 0x34, 0x38, 0x61, 0x66, 0x31, 0x36, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x62, 0x39, 0x37, 0x35, 0x34, 0x64, 0x37, 0x35, 0x64, 0x31, 0x32, 0x64, 0x33, 0x38, 0x34, 0x30, 0x33, 0x39, 0x65, 0x63, 0x36, 0x39, 0x30, 0x36, 0x33, 0x63, 0x30, 0x62, 0x65, 0x32, 0x31, 0x30, 0x64, 0x35, 0x65, 0x30, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x39, 0x34, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x31, 0x37, 0x39, 0x39, 0x61, 0x61, 0x64, 0x37, 0x36, 0x30, 0x32, 0x62, 0x34, 0x35, 0x34, 0x30, 0x63, 0x64, 0x38, 0x33, 0x32, 0x66, 0x39, 0x64, 0x62, 0x35, 0x66, 0x31, 0x31, 0x31, 0x35, 0x30, 0x66, 0x31, 0x36, 0x38, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x62, 0x36, 0x35, 0x62, 0x61, 0x33, 0x31, 0x37, 0x31, 0x61, 0x33, 0x66, 0x37, 0x37, 0x61, 0x36, 0x33, 0x35, 0x30, 0x62, 0x39, 0x64, 0x61, 0x66, 0x31, 0x66, 0x38, 0x64, 0x35, 0x35, 0x62, 0x34, 0x64, 0x32, 0x30, 0x31, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x30, 0x61, 0x34, 0x61, 0x65, 0x34, 0x37, 0x38, 0x65, 0x39, 0x36, 0x33, 0x36, 0x65, 0x38, 0x38, 0x63, 0x36, 0x30, 0x34, 0x66, 0x32, 0x34, 0x32, 0x63, 0x66, 0x35, 0x34, 0x33, 0x39, 0x63, 0x36, 0x64, 0x34, 0x35, 0x36, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x64, 0x30, 0x62, 0x30, 0x61, 0x36, 0x34, 0x33, 0x36, 0x33, 0x36, 0x32, 0x35, 0x39, 0x35, 0x63, 0x65, 0x61, 0x64, 0x65, 0x30, 0x35, 0x32, 0x65, 0x62, 0x63, 0x39, 0x62, 0x39, 0x32, 0x39, 0x66, 0x62, 0x36, 0x63, 0x36, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x64, 0x34, 0x61, 0x66, 0x33, 0x38, 0x65, 0x39, 0x62, 0x61, 0x37, 0x39, 0x39, 0x30, 0x34, 0x30, 0x38, 0x39, 0x34, 0x38, 0x34, 0x39, 0x62, 0x38, 0x61, 0x38, 0x32, 0x31, 0x39, 0x33, 0x37, 0x35, 0x66, 0x31, 0x61, 0x63, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x64, 0x64, 0x65, 0x65, 0x39, 0x30, 0x32, 0x65, 0x31, 0x64, 0x30, 0x63, 0x39, 0x39, 0x64, 0x31, 0x62, 0x31, 0x31, 0x61, 0x66, 0x33, 0x63, 0x63, 0x38, 0x61, 0x39, 0x36, 0x66, 0x37, 0x38, 0x65, 0x34, 0x64, 0x63, 0x66, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x38, 0x34, 0x32, 0x32, 0x31, 0x30, 0x66, 0x34, 0x34, 0x64, 0x31, 0x34, 0x63, 0x34, 0x61, 0x34, 0x64, 0x62, 0x39, 0x31, 0x66, 0x63, 0x39, 0x64, 0x33, 0x62, 0x33, 0x62, 0x35, 0x30, 0x30, 0x31, 0x34, 0x66, 0x37, 0x62, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x61, 0x31, 0x63, 0x34, 0x32, 0x64, 0x63, 0x31, 0x62, 0x61, 0x37, 0x34, 0x36, 0x39, 0x38, 0x36, 0x62, 0x39, 0x38, 0x35, 0x61, 0x35, 0x32, 0x32, 0x61, 0x37, 0x33, 0x63, 0x39, 0x33, 0x65, 0x61, 0x65, 0x36, 0x34, 0x63, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x30, 0x33, 0x62, 0x63, 0x30, 0x39, 0x39, 0x33, 0x33, 0x65, 0x39, 0x39, 0x32, 0x31, 0x66, 0x64, 0x35, 0x33, 0x64, 0x63, 0x35, 0x33, 0x36, 0x66, 0x31, 0x31, 0x66, 0x30, 0x35, 0x64, 0x30, 0x64, 0x34, 0x37, 0x31, 0x30, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x38, 0x65, 0x65, 0x63, 0x35, 0x34, 0x64, 0x33, 0x30, 0x35, 0x63, 0x39, 0x32, 0x38, 0x63, 0x63, 0x32, 0x38, 0x34, 0x38, 0x63, 0x32, 0x66, 0x65, 0x65, 0x32, 0x33, 0x35, 0x33, 0x31, 0x61, 0x63, 0x62, 0x39, 0x36, 0x64, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x32, 0x63, 0x65, 0x34, 0x33, 0x62, 0x35, 0x64, 0x38, 0x39, 0x64, 0x36, 0x39, 0x33, 0x36, 0x62, 0x38, 0x65, 0x38, 0x63, 0x33, 0x35, 0x34, 0x37, 0x39, 0x31, 0x62, 0x38, 0x61, 0x66, 0x66, 0x66, 0x39, 0x36, 0x32, 0x34, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x32, 0x30, 0x32, 0x30, 0x65, 0x33, 0x65, 0x64, 0x37, 0x39, 0x32, 0x64, 0x32, 0x66, 0x31, 0x38, 0x33, 0x35, 0x66, 0x65, 0x35, 0x66, 0x35, 0x35, 0x34, 0x31, 0x37, 0x64, 0x35, 0x31, 0x31, 0x31, 0x34, 0x36, 0x30, 0x63, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x31, 0x36, 0x63, 0x65, 0x33, 0x39, 0x66, 0x65, 0x65, 0x66, 0x33, 0x62, 0x64, 0x37, 0x66, 0x35, 0x64, 0x31, 0x36, 0x32, 0x30, 0x34, 0x35, 0x65, 0x30, 0x66, 0x36, 0x37, 0x63, 0x30, 0x66, 0x30, 0x30, 0x30, 0x34, 0x36, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x39, 0x34, 0x38, 0x61, 0x34, 0x61, 0x65, 0x33, 0x37, 0x39, 0x35, 0x63, 0x62, 0x63, 0x61, 0x31, 0x33, 0x31, 0x32, 0x36, 0x65, 0x31, 0x39, 0x32, 0x35, 0x33, 0x62, 0x64, 0x63, 0x32, 0x31, 0x64, 0x33, 0x61, 0x38, 0x35, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x32, 0x62, 0x37, 0x66, 0x34, 0x30, 0x64, 0x66, 0x39, 0x61, 0x32, 0x66, 0x37, 0x62, 0x66, 0x39, 0x38, 0x33, 0x36, 0x36, 0x31, 0x34, 0x32, 0x32, 0x61, 0x62, 0x38, 0x34, 0x63, 0x39, 0x63, 0x31, 0x66, 0x35, 0x30, 0x38, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x65, 0x36, 0x62, 0x32, 0x66, 0x35, 0x65, 0x62, 0x39, 0x34, 0x66, 0x61, 0x37, 0x61, 0x34, 0x33, 0x38, 0x33, 0x31, 0x66, 0x63, 0x38, 0x37, 0x65, 0x32, 0x35, 0x34, 0x61, 0x33, 0x66, 0x65, 0x33, 0x62, 0x66, 0x38, 0x66, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x33, 0x62, 0x63, 0x61, 0x34, 0x37, 0x61, 0x62, 0x63, 0x30, 0x30, 0x63, 0x37, 0x30, 0x35, 0x37, 0x65, 0x33, 0x61, 0x64, 0x33, 0x34, 0x66, 0x63, 0x61, 0x36, 0x33, 0x65, 0x33, 0x37, 0x35, 0x66, 0x62, 0x64, 0x38, 0x62, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x66, 0x33, 0x32, 0x36, 0x63, 0x64, 0x36, 0x30, 0x66, 0x64, 0x31, 0x33, 0x36, 0x62, 0x32, 0x34, 0x35, 0x65, 0x32, 0x39, 0x65, 0x39, 0x30, 0x38, 0x37, 0x61, 0x36, 0x61, 0x64, 0x33, 0x61, 0x36, 0x35, 0x32, 0x37, 0x66, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x66, 0x66, 0x62, 0x34, 0x61, 0x63, 0x31, 0x33, 0x38, 0x31, 0x32, 0x61, 0x30, 0x62, 0x37, 0x38, 0x63, 0x34, 0x61, 0x33, 0x37, 0x62, 0x38, 0x32, 0x37, 0x35, 0x32, 0x32, 0x33, 0x65, 0x31, 0x37, 0x36, 0x62, 0x66, 0x64, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x35, 0x37, 0x66, 0x63, 0x38, 0x37, 0x32, 0x30, 0x64, 0x33, 0x63, 0x34, 0x66, 0x61, 0x35, 0x32, 0x37, 0x37, 0x30, 0x37, 0x35, 0x65, 0x36, 0x30, 0x62, 0x64, 0x35, 0x63, 0x34, 0x31, 0x31, 0x61, 0x65, 0x62, 0x64, 0x39, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x64, 0x62, 0x63, 0x35, 0x34, 0x63, 0x63, 0x38, 0x62, 0x64, 0x62, 0x62, 0x62, 0x34, 0x30, 0x32, 0x61, 0x30, 0x38, 0x39, 0x31, 0x31, 0x65, 0x32, 0x32, 0x33, 0x32, 0x61, 0x35, 0x34, 0x36, 0x30, 0x63, 0x65, 0x38, 0x36, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x65, 0x39, 0x37, 0x36, 0x30, 0x63, 0x63, 0x32, 0x37, 0x33, 0x64, 0x34, 0x37, 0x30, 0x36, 0x61, 0x61, 0x30, 0x38, 0x33, 0x37, 0x35, 0x63, 0x33, 0x65, 0x34, 0x36, 0x66, 0x61, 0x32, 0x33, 0x30, 0x61, 0x66, 0x66, 0x33, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x33, 0x61, 0x32, 0x34, 0x64, 0x37, 0x66, 0x39, 0x34, 0x36, 0x38, 0x33, 0x34, 0x33, 0x63, 0x31, 0x34, 0x33, 0x61, 0x34, 0x31, 0x64, 0x37, 0x33, 0x62, 0x38, 0x38, 0x66, 0x37, 0x63, 0x62, 0x65, 0x36, 0x33, 0x62, 0x65, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x64, 0x38, 0x30, 0x36, 0x33, 0x31, 0x32, 0x38, 0x34, 0x32, 0x30, 0x33, 0x66, 0x36, 0x32, 0x38, 0x38, 0x65, 0x63, 0x64, 0x34, 0x65, 0x35, 0x37, 0x35, 0x38, 0x62, 0x62, 0x39, 0x64, 0x34, 0x31, 0x64, 0x30, 0x35, 0x64, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x34, 0x63, 0x64, 0x31, 0x33, 0x39, 0x39, 0x66, 0x38, 0x61, 0x33, 0x34, 0x65, 0x64, 0x64, 0x62, 0x39, 0x61, 0x31, 0x37, 0x61, 0x34, 0x37, 0x31, 0x66, 0x63, 0x39, 0x32, 0x32, 0x62, 0x35, 0x38, 0x37, 0x30, 0x61, 0x61, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x63, 0x35, 0x34, 0x65, 0x61, 0x61, 0x38, 0x61, 0x63, 0x39, 0x34, 0x30, 0x66, 0x39, 0x65, 0x38, 0x30, 0x66, 0x31, 0x65, 0x37, 0x34, 0x65, 0x38, 0x32, 0x66, 0x63, 0x31, 0x34, 0x66, 0x31, 0x36, 0x37, 0x36, 0x38, 0x35, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x63, 0x32, 0x37, 0x66, 0x66, 0x35, 0x64, 0x37, 0x66, 0x39, 0x64, 0x64, 0x64, 0x61, 0x39, 0x31, 0x31, 0x38, 0x33, 0x66, 0x34, 0x36, 0x66, 0x39, 0x64, 0x35, 0x32, 0x35, 0x34, 0x33, 0x62, 0x36, 0x63, 0x64, 0x32, 0x62, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x33, 0x63, 0x36, 0x32, 0x38, 0x33, 0x66, 0x32, 0x30, 0x64, 0x66, 0x37, 0x62, 0x63, 0x38, 0x36, 0x35, 0x34, 0x32, 0x66, 0x64, 0x66, 0x62, 0x34, 0x65, 0x37, 0x36, 0x33, 0x65, 0x63, 0x64, 0x62, 0x62, 0x62, 0x65, 0x65, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x61, 0x66, 0x33, 0x34, 0x37, 0x39, 0x31, 0x38, 0x65, 0x66, 0x62, 0x32, 0x64, 0x36, 0x33, 0x64, 0x64, 0x65, 0x30, 0x33, 0x65, 0x33, 0x39, 0x32, 0x37, 0x35, 0x62, 0x62, 0x65, 0x39, 0x37, 0x64, 0x32, 0x36, 0x64, 0x66, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x34, 0x64, 0x30, 0x35, 0x34, 0x31, 0x61, 0x62, 0x34, 0x61, 0x34, 0x37, 0x65, 0x63, 0x37, 0x66, 0x37, 0x35, 0x33, 0x36, 0x39, 0x63, 0x30, 0x30, 0x36, 0x39, 0x62, 0x36, 0x34, 0x61, 0x31, 0x62, 0x38, 0x31, 0x37, 0x37, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x61, 0x35, 0x34, 0x37, 0x38, 0x35, 0x63, 0x39, 0x62, 0x64, 0x33, 0x30, 0x35, 0x37, 0x35, 0x63, 0x38, 0x39, 0x64, 0x65, 0x62, 0x35, 0x39, 0x64, 0x32, 0x30, 0x34, 0x31, 0x64, 0x32, 0x30, 0x61, 0x33, 0x39, 0x65, 0x31, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x37, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x62, 0x34, 0x36, 0x33, 0x61, 0x30, 0x33, 0x38, 0x39, 0x39, 0x38, 0x33, 0x64, 0x66, 0x37, 0x64, 0x35, 0x39, 0x33, 0x66, 0x37, 0x62, 0x64, 0x64, 0x36, 0x64, 0x37, 0x38, 0x34, 0x39, 0x37, 0x66, 0x65, 0x64, 0x38, 0x38, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x31, 0x65, 0x61, 0x34, 0x62, 0x31, 0x38, 0x33, 0x65, 0x32, 0x35, 0x32, 0x63, 0x39, 0x62, 0x62, 0x37, 0x37, 0x36, 0x37, 0x61, 0x30, 0x30, 0x36, 0x64, 0x34, 0x62, 0x34, 0x33, 0x36, 0x39, 0x36, 0x63, 0x62, 0x38, 0x61, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x32, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x61, 0x61, 0x37, 0x34, 0x38, 0x34, 0x37, 0x65, 0x38, 0x36, 0x65, 0x64, 0x66, 0x64, 0x64, 0x33, 0x66, 0x33, 0x64, 0x62, 0x32, 0x32, 0x66, 0x38, 0x61, 0x32, 0x31, 0x35, 0x32, 0x66, 0x65, 0x65, 0x65, 0x35, 0x62, 0x37, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x38, 0x38, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x33, 0x62, 0x39, 0x64, 0x38, 0x32, 0x61, 0x39, 0x39, 0x62, 0x33, 0x63, 0x39, 0x62, 0x62, 0x61, 0x35, 0x61, 0x65, 0x37, 0x32, 0x65, 0x66, 0x32, 0x31, 0x39, 0x39, 0x65, 0x64, 0x63, 0x37, 0x64, 0x33, 0x62, 0x62, 0x33, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x33, 0x35, 0x66, 0x62, 0x38, 0x37, 0x35, 0x37, 0x36, 0x30, 0x30, 0x63, 0x66, 0x34, 0x37, 0x34, 0x35, 0x34, 0x36, 0x32, 0x35, 0x32, 0x66, 0x37, 0x34, 0x64, 0x63, 0x30, 0x37, 0x34, 0x36, 0x64, 0x30, 0x36, 0x32, 0x36, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x65, 0x37, 0x65, 0x63, 0x38, 0x34, 0x36, 0x33, 0x35, 0x38, 0x64, 0x37, 0x64, 0x30, 0x66, 0x39, 0x33, 0x37, 0x61, 0x64, 0x31, 0x63, 0x33, 0x35, 0x30, 0x62, 0x61, 0x30, 0x36, 0x39, 0x64, 0x37, 0x62, 0x66, 0x37, 0x32, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x65, 0x64, 0x33, 0x65, 0x37, 0x37, 0x32, 0x35, 0x34, 0x61, 0x63, 0x62, 0x38, 0x33, 0x32, 0x33, 0x31, 0x64, 0x63, 0x30, 0x38, 0x36, 0x30, 0x65, 0x31, 0x61, 0x31, 0x31, 0x32, 0x34, 0x32, 0x62, 0x61, 0x36, 0x32, 0x37, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x61, 0x30, 0x32, 0x61, 0x62, 0x39, 0x34, 0x65, 0x62, 0x65, 0x35, 0x36, 0x64, 0x30, 0x34, 0x35, 0x62, 0x34, 0x31, 0x62, 0x36, 0x32, 0x39, 0x62, 0x39, 0x38, 0x34, 0x36, 0x32, 0x65, 0x33, 0x61, 0x30, 0x32, 0x34, 0x61, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x31, 0x35, 0x34, 0x39, 0x62, 0x64, 0x64, 0x31, 0x34, 0x38, 0x37, 0x39, 0x31, 0x32, 0x66, 0x39, 0x30, 0x30, 0x61, 0x37, 0x35, 0x32, 0x33, 0x64, 0x62, 0x35, 0x66, 0x37, 0x36, 0x32, 0x36, 0x31, 0x32, 0x31, 0x62, 0x62, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x36, 0x64, 0x30, 0x61, 0x39, 0x65, 0x31, 0x37, 0x63, 0x39, 0x63, 0x30, 0x39, 0x35, 0x61, 0x66, 0x32, 0x65, 0x61, 0x32, 0x33, 0x35, 0x38, 0x62, 0x38, 0x39, 0x65, 0x63, 0x37, 0x30, 0x35, 0x32, 0x31, 0x32, 0x65, 0x65, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x31, 0x62, 0x32, 0x39, 0x63, 0x65, 0x66, 0x63, 0x37, 0x39, 0x61, 0x65, 0x39, 0x37, 0x36, 0x37, 0x34, 0x34, 0x66, 0x64, 0x65, 0x62, 0x63, 0x65, 0x62, 0x64, 0x33, 0x63, 0x62, 0x62, 0x33, 0x32, 0x63, 0x35, 0x31, 0x33, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x63, 0x32, 0x37, 0x30, 0x33, 0x64, 0x38, 0x63, 0x33, 0x66, 0x32, 0x66, 0x34, 0x34, 0x63, 0x35, 0x38, 0x34, 0x62, 0x63, 0x31, 0x30, 0x65, 0x37, 0x63, 0x30, 0x61, 0x36, 0x62, 0x36, 0x34, 0x63, 0x31, 0x63, 0x30, 0x39, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x33, 0x30, 0x61, 0x64, 0x64, 0x64, 0x38, 0x39, 0x35, 0x62, 0x38, 0x32, 0x65, 0x65, 0x33, 0x31, 0x39, 0x65, 0x35, 0x34, 0x66, 0x62, 0x30, 0x34, 0x63, 0x62, 0x32, 0x62, 0x62, 0x30, 0x33, 0x39, 0x37, 0x31, 0x66, 0x33, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x31, 0x62, 0x36, 0x32, 0x66, 0x34, 0x62, 0x34, 0x34, 0x38, 0x63, 0x30, 0x32, 0x62, 0x31, 0x32, 0x30, 0x31, 0x63, 0x62, 0x35, 0x65, 0x33, 0x39, 0x34, 0x61, 0x65, 0x36, 0x32, 0x37, 0x62, 0x30, 0x61, 0x35, 0x36, 0x30, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x33, 0x33, 0x34, 0x65, 0x39, 0x39, 0x38, 0x33, 0x37, 0x39, 0x64, 0x66, 0x65, 0x39, 0x38, 0x33, 0x31, 0x37, 0x37, 0x30, 0x36, 0x32, 0x37, 0x39, 0x31, 0x62, 0x39, 0x30, 0x66, 0x38, 0x30, 0x65, 0x65, 0x32, 0x32, 0x64, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x36, 0x33, 0x33, 0x30, 0x39, 0x37, 0x61, 0x38, 0x35, 0x32, 0x32, 0x35, 0x61, 0x31, 0x66, 0x66, 0x34, 0x33, 0x32, 0x31, 0x62, 0x31, 0x32, 0x39, 0x38, 0x38, 0x66, 0x64, 0x64, 0x35, 0x35, 0x63, 0x32, 0x62, 0x33, 0x38, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x64, 0x38, 0x64, 0x34, 0x63, 0x34, 0x65, 0x39, 0x34, 0x33, 0x66, 0x36, 0x63, 0x38, 0x30, 0x37, 0x33, 0x39, 0x32, 0x31, 0x64, 0x63, 0x31, 0x37, 0x65, 0x33, 0x65, 0x38, 0x64, 0x37, 0x61, 0x30, 0x37, 0x36, 0x31, 0x36, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x33, 0x33, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x64, 0x39, 0x36, 0x65, 0x36, 0x39, 0x37, 0x64, 0x34, 0x36, 0x33, 0x35, 0x38, 0x64, 0x31, 0x31, 0x39, 0x61, 0x66, 0x37, 0x38, 0x31, 0x39, 0x64, 0x63, 0x37, 0x30, 0x38, 0x37, 0x66, 0x36, 0x61, 0x65, 0x34, 0x37, 0x66, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x35, 0x31, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x38, 0x30, 0x39, 0x34, 0x39, 0x38, 0x63, 0x35, 0x34, 0x38, 0x30, 0x34, 0x37, 0x61, 0x31, 0x65, 0x32, 0x61, 0x32, 0x61, 0x61, 0x36, 0x61, 0x32, 0x39, 0x63, 0x64, 0x36, 0x31, 0x61, 0x30, 0x65, 0x65, 0x32, 0x36, 0x38, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x64, 0x36, 0x62, 0x37, 0x35, 0x39, 0x33, 0x63, 0x62, 0x65, 0x65, 0x37, 0x37, 0x38, 0x33, 0x30, 0x61, 0x38, 0x62, 0x31, 0x39, 0x64, 0x30, 0x38, 0x30, 0x31, 0x39, 0x35, 0x38, 0x66, 0x63, 0x64, 0x34, 0x62, 0x63, 0x35, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x64, 0x34, 0x64, 0x32, 0x65, 0x65, 0x66, 0x62, 0x37, 0x36, 0x61, 0x62, 0x61, 0x65, 0x35, 0x35, 0x33, 0x33, 0x39, 0x36, 0x31, 0x65, 0x64, 0x64, 0x31, 0x31, 0x34, 0x30, 0x30, 0x34, 0x30, 0x36, 0x62, 0x32, 0x39, 0x38, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x33, 0x31, 0x30, 0x32, 0x38, 0x63, 0x62, 0x62, 0x35, 0x61, 0x32, 0x31, 0x34, 0x38, 0x35, 0x62, 0x63, 0x35, 0x31, 0x62, 0x35, 0x36, 0x35, 0x31, 0x34, 0x32, 0x39, 0x39, 0x33, 0x62, 0x64, 0x62, 0x32, 0x35, 0x38, 0x32, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x33, 0x62, 0x61, 0x64, 0x34, 0x61, 0x31, 0x32, 0x32, 0x62, 0x34, 0x35, 0x37, 0x64, 0x36, 0x34, 0x65, 0x38, 0x31, 0x35, 0x30, 0x61, 0x34, 0x31, 0x33, 0x65, 0x61, 0x65, 0x34, 0x64, 0x30, 0x37, 0x30, 0x32, 0x33, 0x65, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x32, 0x32, 0x65, 0x32, 0x30, 0x66, 0x62, 0x66, 0x30, 0x34, 0x65, 0x64, 0x37, 0x66, 0x36, 0x62, 0x30, 0x35, 0x61, 0x33, 0x37, 0x62, 0x34, 0x37, 0x31, 0x38, 0x64, 0x36, 0x66, 0x63, 0x65, 0x30, 0x31, 0x34, 0x32, 0x65, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x39, 0x62, 0x61, 0x64, 0x36, 0x66, 0x31, 0x65, 0x65, 0x30, 0x32, 0x61, 0x37, 0x30, 0x66, 0x31, 0x66, 0x31, 0x33, 0x64, 0x65, 0x66, 0x35, 0x63, 0x63, 0x63, 0x62, 0x32, 0x37, 0x61, 0x39, 0x61, 0x32, 0x37, 0x34, 0x30, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x64, 0x30, 0x64, 0x36, 0x33, 0x33, 0x38, 0x35, 0x35, 0x39, 0x65, 0x66, 0x34, 0x34, 0x64, 0x63, 0x37, 0x61, 0x36, 0x31, 0x65, 0x64, 0x65, 0x62, 0x38, 0x39, 0x33, 0x66, 0x61, 0x35, 0x64, 0x38, 0x33, 0x66, 0x61, 0x31, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x38, 0x63, 0x31, 0x64, 0x37, 0x62, 0x36, 0x61, 0x61, 0x63, 0x63, 0x64, 0x34, 0x32, 0x39, 0x64, 0x62, 0x33, 0x61, 0x39, 0x31, 0x65, 0x65, 0x34, 0x63, 0x39, 0x65, 0x62, 0x31, 0x63, 0x61, 0x34, 0x66, 0x36, 0x66, 0x37, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x39, 0x36, 0x61, 0x64, 0x37, 0x34, 0x33, 0x35, 0x37, 0x39, 0x64, 0x33, 0x38, 0x65, 0x32, 0x33, 0x30, 0x32, 0x34, 0x35, 0x34, 0x64, 0x31, 0x66, 0x62, 0x36, 0x65, 0x32, 0x61, 0x62, 0x36, 0x39, 0x65, 0x30, 0x31, 0x62, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x33, 0x63, 0x63, 0x66, 0x34, 0x33, 0x36, 0x37, 0x32, 0x35, 0x63, 0x31, 0x35, 0x31, 0x65, 0x32, 0x35, 0x35, 0x63, 0x63, 0x66, 0x35, 0x32, 0x31, 0x30, 0x63, 0x66, 0x63, 0x65, 0x35, 0x61, 0x34, 0x33, 0x66, 0x31, 0x33, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x38, 0x33, 0x64, 0x39, 0x38, 0x66, 0x31, 0x34, 0x61, 0x33, 0x33, 0x66, 0x64, 0x63, 0x31, 0x31, 0x38, 0x64, 0x34, 0x30, 0x33, 0x39, 0x35, 0x35, 0x63, 0x32, 0x39, 0x39, 0x33, 0x35, 0x65, 0x64, 0x66, 0x63, 0x35, 0x66, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x66, 0x63, 0x66, 0x37, 0x35, 0x31, 0x37, 0x66, 0x30, 0x63, 0x30, 0x38, 0x34, 0x35, 0x39, 0x37, 0x32, 0x30, 0x39, 0x34, 0x32, 0x62, 0x36, 0x34, 0x37, 0x61, 0x64, 0x31, 0x39, 0x32, 0x61, 0x61, 0x39, 0x63, 0x38, 0x38, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x33, 0x37, 0x38, 0x66, 0x30, 0x65, 0x64, 0x63, 0x30, 0x62, 0x62, 0x30, 0x66, 0x30, 0x36, 0x38, 0x36, 0x64, 0x36, 0x61, 0x32, 0x30, 0x62, 0x65, 0x36, 0x61, 0x37, 0x36, 0x39, 0x32, 0x63, 0x34, 0x66, 0x61, 0x32, 0x34, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x66, 0x36, 0x38, 0x64, 0x65, 0x33, 0x64, 0x37, 0x33, 0x39, 0x64, 0x62, 0x34, 0x31, 0x31, 0x32, 0x31, 0x65, 0x61, 0x63, 0x66, 0x37, 0x37, 0x39, 0x61, 0x61, 0x64, 0x61, 0x33, 0x64, 0x65, 0x38, 0x37, 0x36, 0x32, 0x31, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x30, 0x39, 0x36, 0x35, 0x30, 0x64, 0x64, 0x35, 0x62, 0x31, 0x33, 0x39, 0x37, 0x62, 0x38, 0x62, 0x38, 0x62, 0x30, 0x65, 0x62, 0x36, 0x39, 0x34, 0x39, 0x39, 0x62, 0x32, 0x39, 0x31, 0x62, 0x30, 0x61, 0x64, 0x31, 0x32, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x36, 0x36, 0x37, 0x35, 0x31, 0x34, 0x32, 0x65, 0x33, 0x31, 0x31, 0x31, 0x61, 0x31, 0x63, 0x32, 0x65, 0x61, 0x31, 0x65, 0x62, 0x32, 0x34, 0x31, 0x39, 0x63, 0x66, 0x61, 0x34, 0x32, 0x61, 0x61, 0x66, 0x37, 0x61, 0x32, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x33, 0x36, 0x66, 0x37, 0x65, 0x66, 0x36, 0x62, 0x63, 0x37, 0x62, 0x64, 0x30, 0x66, 0x66, 0x33, 0x61, 0x63, 0x61, 0x66, 0x34, 0x34, 0x39, 0x63, 0x38, 0x34, 0x64, 0x64, 0x36, 0x62, 0x31, 0x65, 0x32, 0x63, 0x39, 0x33, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x34, 0x32, 0x32, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x64, 0x65, 0x64, 0x62, 0x65, 0x34, 0x38, 0x39, 0x32, 0x33, 0x66, 0x62, 0x66, 0x39, 0x65, 0x35, 0x33, 0x36, 0x62, 0x66, 0x39, 0x66, 0x66, 0x62, 0x30, 0x37, 0x34, 0x37, 0x63, 0x39, 0x63, 0x64, 0x64, 0x33, 0x39, 0x65, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x37, 0x64, 0x36, 0x31, 0x30, 0x62, 0x33, 0x39, 0x39, 0x32, 0x35, 0x30, 0x66, 0x37, 0x30, 0x65, 0x63, 0x66, 0x31, 0x33, 0x38, 0x39, 0x62, 0x61, 0x62, 0x36, 0x32, 0x39, 0x32, 0x63, 0x39, 0x31, 0x32, 0x36, 0x34, 0x66, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x61, 0x36, 0x64, 0x36, 0x32, 0x37, 0x66, 0x36, 0x36, 0x61, 0x38, 0x39, 0x32, 0x33, 0x64, 0x38, 0x38, 0x64, 0x36, 0x30, 0x39, 0x34, 0x63, 0x34, 0x37, 0x31, 0x35, 0x33, 0x38, 0x30, 0x64, 0x33, 0x30, 0x35, 0x37, 0x63, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x35, 0x32, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x30, 0x63, 0x63, 0x39, 0x31, 0x37, 0x63, 0x62, 0x65, 0x65, 0x37, 0x64, 0x37, 0x63, 0x30, 0x39, 0x39, 0x37, 0x36, 0x33, 0x66, 0x31, 0x34, 0x65, 0x36, 0x34, 0x64, 0x66, 0x37, 0x64, 0x33, 0x34, 0x65, 0x32, 0x62, 0x66, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x61, 0x61, 0x65, 0x36, 0x38, 0x62, 0x33, 0x32, 0x31, 0x34, 0x30, 0x32, 0x63, 0x38, 0x65, 0x62, 0x63, 0x31, 0x33, 0x34, 0x36, 0x38, 0x66, 0x33, 0x34, 0x31, 0x63, 0x36, 0x33, 0x63, 0x30, 0x63, 0x66, 0x30, 0x33, 0x66, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x39, 0x63, 0x64, 0x61, 0x61, 0x35, 0x33, 0x30, 0x33, 0x36, 0x37, 0x38, 0x65, 0x66, 0x37, 0x63, 0x65, 0x63, 0x35, 0x39, 0x64, 0x34, 0x38, 0x63, 0x38, 0x32, 0x31, 0x36, 0x33, 0x61, 0x63, 0x63, 0x36, 0x30, 0x62, 0x39, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x32, 0x33, 0x34, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x37, 0x31, 0x31, 0x39, 0x32, 0x39, 0x36, 0x36, 0x65, 0x62, 0x36, 0x39, 0x63, 0x33, 0x35, 0x32, 0x30, 0x66, 0x63, 0x61, 0x33, 0x61, 0x61, 0x34, 0x64, 0x64, 0x30, 0x34, 0x32, 0x39, 0x37, 0x65, 0x61, 0x30, 0x34, 0x62, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x33, 0x34, 0x32, 0x35, 0x64, 0x38, 0x64, 0x66, 0x31, 0x66, 0x31, 0x31, 0x63, 0x33, 0x34, 0x31, 0x66, 0x66, 0x35, 0x38, 0x61, 0x65, 0x35, 0x66, 0x31, 0x34, 0x33, 0x38, 0x61, 0x62, 0x66, 0x31, 0x63, 0x61, 0x35, 0x33, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x66, 0x65, 0x33, 0x32, 0x32, 0x39, 0x39, 0x37, 0x62, 0x38, 0x65, 0x34, 0x30, 0x34, 0x34, 0x32, 0x32, 0x64, 0x31, 0x39, 0x63, 0x35, 0x34, 0x61, 0x61, 0x64, 0x62, 0x31, 0x38, 0x66, 0x35, 0x62, 0x63, 0x38, 0x65, 0x39, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x35, 0x66, 0x37, 0x38, 0x64, 0x36, 0x31, 0x38, 0x62, 0x39, 0x39, 0x30, 0x62, 0x34, 0x32, 0x39, 0x35, 0x62, 0x61, 0x63, 0x38, 0x61, 0x32, 0x64, 0x66, 0x61, 0x32, 0x36, 0x32, 0x38, 0x38, 0x34, 0x66, 0x38, 0x30, 0x34, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x34, 0x64, 0x36, 0x39, 0x31, 0x37, 0x30, 0x66, 0x65, 0x37, 0x31, 0x34, 0x31, 0x34, 0x30, 0x31, 0x38, 0x38, 0x32, 0x62, 0x38, 0x38, 0x36, 0x61, 0x63, 0x34, 0x36, 0x31, 0x38, 0x63, 0x36, 0x61, 0x65, 0x34, 0x30, 0x65, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x63, 0x39, 0x34, 0x65, 0x30, 0x37, 0x63, 0x34, 0x61, 0x39, 0x62, 0x65, 0x33, 0x33, 0x38, 0x34, 0x64, 0x39, 0x35, 0x64, 0x66, 0x61, 0x33, 0x63, 0x62, 0x39, 0x32, 0x39, 0x30, 0x30, 0x35, 0x31, 0x38, 0x37, 0x33, 0x62, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x39, 0x63, 0x36, 0x30, 0x30, 0x63, 0x66, 0x31, 0x33, 0x64, 0x31, 0x64, 0x30, 0x32, 0x37, 0x33, 0x64, 0x35, 0x64, 0x31, 0x64, 0x61, 0x33, 0x63, 0x64, 0x37, 0x38, 0x39, 0x65, 0x34, 0x39, 0x35, 0x38, 0x39, 0x39, 0x66, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x36, 0x63, 0x65, 0x62, 0x62, 0x62, 0x66, 0x37, 0x66, 0x35, 0x31, 0x34, 0x39, 0x61, 0x36, 0x36, 0x66, 0x37, 0x65, 0x62, 0x39, 0x37, 0x36, 0x62, 0x33, 0x65, 0x34, 0x37, 0x64, 0x35, 0x36, 0x35, 0x31, 0x36, 0x64, 0x61, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x62, 0x62, 0x63, 0x34, 0x37, 0x32, 0x31, 0x32, 0x64, 0x38, 0x32, 0x66, 0x63, 0x62, 0x35, 0x65, 0x65, 0x30, 0x38, 0x66, 0x35, 0x32, 0x32, 0x35, 0x65, 0x63, 0x63, 0x32, 0x30, 0x34, 0x31, 0x61, 0x64, 0x32, 0x64, 0x61, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x65, 0x37, 0x39, 0x39, 0x37, 0x65, 0x64, 0x64, 0x39, 0x30, 0x34, 0x35, 0x30, 0x33, 0x64, 0x37, 0x37, 0x64, 0x61, 0x36, 0x30, 0x33, 0x38, 0x61, 0x62, 0x30, 0x61, 0x34, 0x63, 0x38, 0x33, 0x34, 0x62, 0x62, 0x64, 0x35, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x33, 0x33, 0x36, 0x32, 0x37, 0x34, 0x34, 0x35, 0x66, 0x32, 0x64, 0x37, 0x38, 0x37, 0x39, 0x30, 0x31, 0x65, 0x66, 0x33, 0x33, 0x62, 0x62, 0x32, 0x61, 0x38, 0x61, 0x33, 0x36, 0x37, 0x35, 0x65, 0x32, 0x37, 0x66, 0x66, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x61, 0x35, 0x38, 0x65, 0x39, 0x38, 0x35, 0x64, 0x63, 0x63, 0x64, 0x37, 0x30, 0x37, 0x61, 0x35, 0x39, 0x34, 0x64, 0x31, 0x39, 0x33, 0x65, 0x37, 0x63, 0x63, 0x61, 0x37, 0x38, 0x62, 0x35, 0x64, 0x30, 0x32, 0x37, 0x38, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x61, 0x65, 0x38, 0x35, 0x37, 0x62, 0x36, 0x37, 0x61, 0x34, 0x61, 0x32, 0x38, 0x39, 0x33, 0x61, 0x33, 0x66, 0x62, 0x65, 0x37, 0x63, 0x37, 0x61, 0x38, 0x37, 0x66, 0x66, 0x31, 0x63, 0x30, 0x31, 0x63, 0x36, 0x61, 0x36, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x31, 0x35, 0x36, 0x31, 0x64, 0x62, 0x38, 0x62, 0x36, 0x66, 0x61, 0x66, 0x62, 0x39, 0x30, 0x30, 0x37, 0x65, 0x36, 0x32, 0x64, 0x30, 0x35, 0x30, 0x63, 0x32, 0x38, 0x32, 0x65, 0x39, 0x32, 0x63, 0x34, 0x62, 0x36, 0x62, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x64, 0x66, 0x31, 0x65, 0x63, 0x32, 0x34, 0x62, 0x34, 0x65, 0x34, 0x62, 0x66, 0x65, 0x37, 0x39, 0x62, 0x30, 0x63, 0x30, 0x39, 0x35, 0x63, 0x65, 0x62, 0x61, 0x65, 0x31, 0x39, 0x38, 0x66, 0x32, 0x39, 0x31, 0x66, 0x62, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x30, 0x38, 0x38, 0x31, 0x32, 0x61, 0x36, 0x38, 0x34, 0x30, 0x39, 0x38, 0x66, 0x33, 0x64, 0x61, 0x34, 0x65, 0x66, 0x65, 0x36, 0x61, 0x62, 0x61, 0x32, 0x35, 0x36, 0x32, 0x35, 0x36, 0x61, 0x64, 0x66, 0x65, 0x33, 0x66, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x65, 0x63, 0x38, 0x65, 0x39, 0x37, 0x61, 0x32, 0x30, 0x61, 0x61, 0x35, 0x66, 0x38, 0x64, 0x64, 0x32, 0x30, 0x36, 0x66, 0x35, 0x35, 0x32, 0x30, 0x37, 0x65, 0x30, 0x36, 0x62, 0x38, 0x31, 0x33, 0x64, 0x66, 0x32, 0x63, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x65, 0x62, 0x37, 0x65, 0x65, 0x66, 0x64, 0x61, 0x65, 0x39, 0x66, 0x65, 0x62, 0x34, 0x34, 0x39, 0x63, 0x36, 0x33, 0x66, 0x66, 0x35, 0x66, 0x32, 0x37, 0x39, 0x64, 0x36, 0x37, 0x35, 0x31, 0x30, 0x65, 0x62, 0x31, 0x34, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x36, 0x37, 0x38, 0x37, 0x30, 0x36, 0x64, 0x30, 0x33, 0x37, 0x31, 0x38, 0x37, 0x66, 0x33, 0x65, 0x32, 0x32, 0x65, 0x36, 0x66, 0x36, 0x39, 0x62, 0x39, 0x39, 0x61, 0x35, 0x39, 0x32, 0x64, 0x31, 0x31, 0x65, 0x62, 0x63, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x36, 0x64, 0x33, 0x36, 0x33, 0x31, 0x30, 0x36, 0x63, 0x63, 0x36, 0x32, 0x33, 0x38, 0x64, 0x32, 0x66, 0x30, 0x39, 0x32, 0x66, 0x30, 0x66, 0x30, 0x33, 0x37, 0x32, 0x31, 0x33, 0x36, 0x64, 0x31, 0x63, 0x64, 0x35, 0x30, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x37, 0x31, 0x30, 0x64, 0x37, 0x65, 0x38, 0x62, 0x35, 0x61, 0x33, 0x62, 0x64, 0x36, 0x39, 0x61, 0x34, 0x32, 0x66, 0x65, 0x30, 0x66, 0x61, 0x38, 0x62, 0x38, 0x37, 0x63, 0x33, 0x35, 0x37, 0x66, 0x64, 0x64, 0x63, 0x64, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x36, 0x37, 0x66, 0x34, 0x64, 0x34, 0x31, 0x32, 0x39, 0x32, 0x66, 0x33, 0x37, 0x30, 0x38, 0x36, 0x33, 0x63, 0x39, 0x30, 0x64, 0x37, 0x39, 0x33, 0x32, 0x39, 0x36, 0x39, 0x30, 0x33, 0x38, 0x34, 0x33, 0x36, 0x32, 0x35, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x64, 0x61, 0x34, 0x31, 0x64, 0x64, 0x35, 0x33, 0x33, 0x39, 0x39, 0x31, 0x32, 0x39, 0x30, 0x37, 0x39, 0x34, 0x65, 0x32, 0x32, 0x61, 0x65, 0x33, 0x32, 0x34, 0x31, 0x34, 0x33, 0x65, 0x33, 0x30, 0x39, 0x62, 0x33, 0x64, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x61, 0x35, 0x30, 0x63, 0x65, 0x65, 0x32, 0x65, 0x36, 0x38, 0x38, 0x63, 0x65, 0x65, 0x65, 0x33, 0x61, 0x63, 0x61, 0x34, 0x64, 0x34, 0x61, 0x32, 0x39, 0x37, 0x32, 0x35, 0x64, 0x34, 0x30, 0x37, 0x32, 0x63, 0x63, 0x34, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x64, 0x33, 0x62, 0x62, 0x63, 0x30, 0x35, 0x32, 0x34, 0x30, 0x65, 0x30, 0x64, 0x33, 0x39, 0x39, 0x65, 0x62, 0x36, 0x64, 0x64, 0x66, 0x65, 0x36, 0x30, 0x66, 0x36, 0x32, 0x64, 0x65, 0x34, 0x64, 0x39, 0x35, 0x30, 0x39, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x39, 0x39, 0x39, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x65, 0x66, 0x62, 0x35, 0x34, 0x37, 0x30, 0x37, 0x66, 0x36, 0x31, 0x62, 0x32, 0x63, 0x39, 0x66, 0x62, 0x30, 0x34, 0x37, 0x31, 0x35, 0x61, 0x62, 0x30, 0x32, 0x36, 0x65, 0x31, 0x62, 0x62, 0x37, 0x32, 0x30, 0x34, 0x32, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x62, 0x39, 0x61, 0x33, 0x30, 0x31, 0x65, 0x36, 0x62, 0x64, 0x34, 0x36, 0x65, 0x39, 0x34, 0x30, 0x33, 0x35, 0x35, 0x30, 0x32, 0x38, 0x65, 0x63, 0x63, 0x64, 0x34, 0x30, 0x63, 0x65, 0x34, 0x64, 0x35, 0x61, 0x31, 0x61, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x36, 0x37, 0x32, 0x64, 0x61, 0x33, 0x61, 0x62, 0x30, 0x35, 0x32, 0x38, 0x32, 0x31, 0x61, 0x30, 0x32, 0x34, 0x33, 0x64, 0x31, 0x63, 0x65, 0x34, 0x62, 0x36, 0x65, 0x30, 0x61, 0x33, 0x36, 0x35, 0x31, 0x37, 0x62, 0x38, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x63, 0x30, 0x38, 0x32, 0x37, 0x65, 0x66, 0x66, 0x30, 0x63, 0x36, 0x65, 0x33, 0x66, 0x66, 0x32, 0x38, 0x61, 0x37, 0x64, 0x34, 0x61, 0x35, 0x34, 0x66, 0x36, 0x35, 0x63, 0x62, 0x37, 0x36, 0x38, 0x39, 0x64, 0x37, 0x62, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x35, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x62, 0x36, 0x63, 0x64, 0x63, 0x66, 0x63, 0x62, 0x32, 0x34, 0x32, 0x33, 0x30, 0x62, 0x33, 0x33, 0x37, 0x64, 0x37, 0x37, 0x30, 0x64, 0x66, 0x36, 0x30, 0x33, 0x34, 0x64, 0x66, 0x62, 0x64, 0x34, 0x65, 0x31, 0x35, 0x30, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x65, 0x32, 0x66, 0x37, 0x36, 0x38, 0x30, 0x63, 0x38, 0x30, 0x32, 0x64, 0x61, 0x36, 0x31, 0x35, 0x34, 0x63, 0x39, 0x32, 0x63, 0x30, 0x31, 0x39, 0x34, 0x61, 0x65, 0x37, 0x33, 0x32, 0x35, 0x31, 0x37, 0x61, 0x37, 0x31, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x39, 0x66, 0x31, 0x61, 0x61, 0x33, 0x30, 0x65, 0x34, 0x34, 0x35, 0x35, 0x62, 0x65, 0x62, 0x31, 0x38, 0x32, 0x32, 0x30, 0x39, 0x31, 0x64, 0x65, 0x35, 0x63, 0x61, 0x64, 0x65, 0x63, 0x37, 0x39, 0x61, 0x38, 0x66, 0x39, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x36, 0x38, 0x31, 0x65, 0x37, 0x33, 0x62, 0x62, 0x30, 0x65, 0x33, 0x32, 0x66, 0x36, 0x62, 0x37, 0x32, 0x36, 0x32, 0x30, 0x34, 0x38, 0x33, 0x31, 0x66, 0x66, 0x36, 0x39, 0x62, 0x61, 0x61, 0x34, 0x38, 0x37, 0x37, 0x65, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x32, 0x63, 0x64, 0x32, 0x32, 0x61, 0x38, 0x65, 0x64, 0x66, 0x31, 0x65, 0x34, 0x66, 0x34, 0x65, 0x35, 0x35, 0x62, 0x34, 0x62, 0x31, 0x35, 0x64, 0x64, 0x62, 0x66, 0x62, 0x35, 0x64, 0x39, 0x64, 0x35, 0x34, 0x31, 0x39, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x31, 0x64, 0x66, 0x38, 0x64, 0x33, 0x33, 0x30, 0x65, 0x62, 0x37, 0x63, 0x63, 0x37, 0x31, 0x34, 0x37, 0x64, 0x30, 0x61, 0x35, 0x35, 0x35, 0x37, 0x36, 0x66, 0x30, 0x35, 0x64, 0x65, 0x38, 0x64, 0x32, 0x36, 0x61, 0x38, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x66, 0x39, 0x39, 0x66, 0x32, 0x63, 0x30, 0x62, 0x34, 0x36, 0x63, 0x65, 0x38, 0x39, 0x30, 0x36, 0x38, 0x37, 0x35, 0x64, 0x63, 0x39, 0x66, 0x39, 0x30, 0x61, 0x65, 0x31, 0x30, 0x34, 0x64, 0x61, 0x65, 0x33, 0x35, 0x35, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x62, 0x62, 0x33, 0x66, 0x37, 0x39, 0x30, 0x32, 0x32, 0x62, 0x66, 0x33, 0x63, 0x34, 0x35, 0x33, 0x66, 0x34, 0x66, 0x66, 0x32, 0x35, 0x36, 0x65, 0x32, 0x36, 0x39, 0x62, 0x31, 0x35, 0x63, 0x66, 0x32, 0x63, 0x39, 0x63, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x30, 0x31, 0x64, 0x63, 0x34, 0x63, 0x66, 0x32, 0x36, 0x64, 0x37, 0x31, 0x38, 0x36, 0x66, 0x32, 0x61, 0x31, 0x31, 0x62, 0x66, 0x38, 0x62, 0x30, 0x38, 0x62, 0x66, 0x32, 0x32, 0x39, 0x34, 0x36, 0x33, 0x66, 0x36, 0x34, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x62, 0x63, 0x61, 0x38, 0x38, 0x66, 0x63, 0x61, 0x36, 0x61, 0x30, 0x30, 0x36, 0x30, 0x62, 0x39, 0x36, 0x30, 0x39, 0x38, 0x35, 0x63, 0x39, 0x61, 0x61, 0x31, 0x62, 0x30, 0x32, 0x35, 0x33, 0x34, 0x64, 0x63, 0x32, 0x32, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x63, 0x31, 0x61, 0x62, 0x64, 0x32, 0x39, 0x64, 0x63, 0x35, 0x37, 0x62, 0x34, 0x31, 0x64, 0x63, 0x31, 0x39, 0x32, 0x64, 0x30, 0x65, 0x33, 0x38, 0x34, 0x64, 0x30, 0x32, 0x31, 0x64, 0x66, 0x30, 0x62, 0x34, 0x66, 0x36, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x33, 0x32, 0x66, 0x36, 0x66, 0x38, 0x36, 0x65, 0x37, 0x38, 0x37, 0x66, 0x66, 0x37, 0x38, 0x65, 0x36, 0x33, 0x64, 0x37, 0x38, 0x62, 0x30, 0x65, 0x66, 0x39, 0x35, 0x66, 0x65, 0x36, 0x30, 0x37, 0x31, 0x38, 0x35, 0x32, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x37, 0x38, 0x63, 0x35, 0x66, 0x32, 0x61, 0x35, 0x32, 0x32, 0x33, 0x39, 0x33, 0x32, 0x32, 0x35, 0x31, 0x39, 0x36, 0x33, 0x36, 0x31, 0x38, 0x39, 0x34, 0x66, 0x35, 0x33, 0x63, 0x63, 0x37, 0x35, 0x32, 0x66, 0x65, 0x32, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x66, 0x30, 0x34, 0x63, 0x62, 0x31, 0x34, 0x33, 0x38, 0x30, 0x30, 0x35, 0x39, 0x65, 0x66, 0x64, 0x33, 0x66, 0x32, 0x33, 0x38, 0x62, 0x36, 0x35, 0x64, 0x35, 0x62, 0x65, 0x62, 0x38, 0x36, 0x61, 0x66, 0x61, 0x31, 0x34, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x65, 0x31, 0x37, 0x33, 0x31, 0x33, 0x35, 0x30, 0x66, 0x39, 0x38, 0x33, 0x63, 0x63, 0x32, 0x63, 0x34, 0x31, 0x38, 0x39, 0x38, 0x34, 0x32, 0x66, 0x64, 0x65, 0x30, 0x36, 0x31, 0x33, 0x66, 0x61, 0x64, 0x35, 0x30, 0x63, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x62, 0x31, 0x31, 0x64, 0x36, 0x66, 0x32, 0x62, 0x63, 0x65, 0x39, 0x34, 0x35, 0x65, 0x30, 0x63, 0x36, 0x61, 0x35, 0x30, 0x32, 0x30, 0x63, 0x33, 0x62, 0x35, 0x32, 0x37, 0x35, 0x33, 0x66, 0x38, 0x30, 0x33, 0x66, 0x39, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x39, 0x62, 0x64, 0x37, 0x35, 0x30, 0x38, 0x35, 0x38, 0x32, 0x31, 0x63, 0x31, 0x64, 0x65, 0x37, 0x30, 0x63, 0x64, 0x63, 0x33, 0x62, 0x31, 0x31, 0x66, 0x66, 0x63, 0x33, 0x64, 0x39, 0x32, 0x33, 0x63, 0x37, 0x34, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x62, 0x37, 0x31, 0x36, 0x30, 0x61, 0x62, 0x61, 0x32, 0x39, 0x33, 0x37, 0x36, 0x32, 0x66, 0x38, 0x37, 0x33, 0x34, 0x66, 0x33, 0x65, 0x30, 0x33, 0x32, 0x36, 0x66, 0x66, 0x63, 0x39, 0x61, 0x34, 0x63, 0x61, 0x63, 0x31, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x61, 0x64, 0x34, 0x64, 0x62, 0x63, 0x64, 0x33, 0x61, 0x63, 0x66, 0x39, 0x39, 0x37, 0x64, 0x66, 0x39, 0x33, 0x35, 0x38, 0x36, 0x39, 0x35, 0x36, 0x66, 0x37, 0x32, 0x62, 0x36, 0x34, 0x64, 0x38, 0x61, 0x64, 0x39, 0x34, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x65, 0x63, 0x39, 0x38, 0x33, 0x32, 0x39, 0x64, 0x31, 0x66, 0x39, 0x36, 0x63, 0x33, 0x61, 0x35, 0x39, 0x63, 0x61, 0x61, 0x37, 0x39, 0x38, 0x31, 0x37, 0x35, 0x35, 0x34, 0x35, 0x32, 0x64, 0x34, 0x64, 0x61, 0x34, 0x39, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x38, 0x61, 0x62, 0x34, 0x36, 0x37, 0x66, 0x65, 0x62, 0x35, 0x61, 0x30, 0x61, 0x61, 0x64, 0x66, 0x66, 0x66, 0x39, 0x31, 0x32, 0x33, 0x30, 0x66, 0x66, 0x30, 0x35, 0x36, 0x34, 0x36, 0x34, 0x64, 0x37, 0x38, 0x64, 0x38, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x30, 0x63, 0x33, 0x37, 0x36, 0x35, 0x31, 0x35, 0x36, 0x62, 0x63, 0x61, 0x38, 0x65, 0x34, 0x38, 0x39, 0x37, 0x61, 0x62, 0x38, 0x30, 0x32, 0x34, 0x31, 0x39, 0x31, 0x35, 0x33, 0x63, 0x62, 0x65, 0x35, 0x32, 0x32, 0x35, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x63, 0x38, 0x66, 0x33, 0x63, 0x63, 0x37, 0x61, 0x33, 0x35, 0x34, 0x66, 0x65, 0x61, 0x63, 0x39, 0x39, 0x61, 0x35, 0x65, 0x37, 0x62, 0x66, 0x65, 0x37, 0x63, 0x64, 0x66, 0x61, 0x33, 0x35, 0x31, 0x63, 0x66, 0x65, 0x33, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x66, 0x63, 0x34, 0x64, 0x33, 0x39, 0x62, 0x63, 0x30, 0x63, 0x32, 0x63, 0x34, 0x30, 0x36, 0x38, 0x61, 0x33, 0x36, 0x64, 0x65, 0x35, 0x30, 0x65, 0x34, 0x61, 0x62, 0x34, 0x64, 0x34, 0x64, 0x62, 0x37, 0x65, 0x33, 0x34, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x30, 0x61, 0x62, 0x62, 0x64, 0x34, 0x61, 0x61, 0x34, 0x35, 0x64, 0x33, 0x65, 0x62, 0x38, 0x38, 0x35, 0x31, 0x35, 0x34, 0x36, 0x35, 0x61, 0x38, 0x62, 0x61, 0x30, 0x62, 0x33, 0x31, 0x30, 0x66, 0x64, 0x39, 0x62, 0x35, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x32, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x32, 0x34, 0x30, 0x30, 0x38, 0x64, 0x35, 0x36, 0x66, 0x37, 0x36, 0x39, 0x38, 0x31, 0x32, 0x35, 0x36, 0x34, 0x32, 0x30, 0x63, 0x39, 0x34, 0x36, 0x61, 0x36, 0x66, 0x66, 0x34, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x62, 0x61, 0x36, 0x61, 0x34, 0x36, 0x64, 0x35, 0x35, 0x31, 0x34, 0x30, 0x63, 0x34, 0x33, 0x39, 0x63, 0x62, 0x63, 0x66, 0x30, 0x37, 0x36, 0x63, 0x63, 0x36, 0x35, 0x37, 0x31, 0x33, 0x36, 0x32, 0x36, 0x32, 0x66, 0x34, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x37, 0x61, 0x64, 0x66, 0x36, 0x36, 0x30, 0x62, 0x38, 0x64, 0x39, 0x39, 0x63, 0x65, 0x31, 0x35, 0x39, 0x33, 0x33, 0x64, 0x37, 0x63, 0x35, 0x66, 0x30, 0x37, 0x32, 0x66, 0x33, 0x63, 0x62, 0x65, 0x62, 0x39, 0x39, 0x64, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x35, 0x30, 0x33, 0x33, 0x33, 0x34, 0x36, 0x33, 0x30, 0x64, 0x37, 0x37, 0x66, 0x37, 0x34, 0x31, 0x34, 0x37, 0x66, 0x36, 0x38, 0x62, 0x32, 0x65, 0x30, 0x38, 0x36, 0x36, 0x31, 0x33, 0x63, 0x38, 0x66, 0x31, 0x61, 0x64, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x65, 0x64, 0x38, 0x35, 0x38, 0x37, 0x38, 0x38, 0x62, 0x64, 0x61, 0x34, 0x64, 0x35, 0x32, 0x37, 0x30, 0x39, 0x39, 0x32, 0x32, 0x32, 0x31, 0x63, 0x63, 0x30, 0x34, 0x32, 0x30, 0x36, 0x65, 0x63, 0x36, 0x32, 0x36, 0x31, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x62, 0x63, 0x61, 0x34, 0x31, 0x38, 0x64, 0x33, 0x35, 0x32, 0x39, 0x63, 0x62, 0x33, 0x39, 0x33, 0x30, 0x38, 0x31, 0x30, 0x36, 0x32, 0x30, 0x33, 0x32, 0x61, 0x36, 0x65, 0x31, 0x31, 0x38, 0x33, 0x63, 0x36, 0x62, 0x32, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x36, 0x33, 0x65, 0x63, 0x65, 0x35, 0x64, 0x37, 0x30, 0x39, 0x65, 0x30, 0x64, 0x37, 0x61, 0x65, 0x37, 0x31, 0x63, 0x63, 0x61, 0x38, 0x36, 0x38, 0x65, 0x64, 0x33, 0x37, 0x63, 0x64, 0x32, 0x66, 0x65, 0x66, 0x38, 0x30, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x62, 0x61, 0x33, 0x38, 0x36, 0x34, 0x64, 0x61, 0x35, 0x38, 0x33, 0x64, 0x61, 0x62, 0x35, 0x36, 0x66, 0x34, 0x32, 0x30, 0x38, 0x37, 0x33, 0x63, 0x33, 0x37, 0x36, 0x37, 0x39, 0x36, 0x39, 0x30, 0x65, 0x30, 0x32, 0x66, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x64, 0x63, 0x62, 0x33, 0x61, 0x31, 0x64, 0x36, 0x38, 0x34, 0x33, 0x66, 0x62, 0x36, 0x62, 0x65, 0x66, 0x36, 0x34, 0x33, 0x36, 0x31, 0x37, 0x64, 0x65, 0x61, 0x66, 0x33, 0x38, 0x66, 0x38, 0x65, 0x39, 0x38, 0x64, 0x64, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x61, 0x63, 0x37, 0x34, 0x38, 0x66, 0x37, 0x38, 0x34, 0x61, 0x30, 0x66, 0x65, 0x64, 0x36, 0x38, 0x64, 0x62, 0x61, 0x34, 0x33, 0x33, 0x31, 0x39, 0x62, 0x34, 0x32, 0x61, 0x37, 0x35, 0x62, 0x34, 0x36, 0x34, 0x39, 0x63, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x62, 0x38, 0x62, 0x63, 0x66, 0x39, 0x38, 0x33, 0x32, 0x31, 0x64, 0x61, 0x36, 0x31, 0x66, 0x62, 0x34, 0x65, 0x33, 0x65, 0x61, 0x63, 0x63, 0x31, 0x65, 0x63, 0x35, 0x34, 0x31, 0x37, 0x32, 0x37, 0x32, 0x64, 0x63, 0x32, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x36, 0x39, 0x34, 0x33, 0x66, 0x66, 0x62, 0x32, 0x65, 0x66, 0x35, 0x63, 0x64, 0x64, 0x33, 0x35, 0x62, 0x38, 0x33, 0x63, 0x32, 0x38, 0x62, 0x63, 0x30, 0x34, 0x36, 0x62, 0x64, 0x34, 0x66, 0x34, 0x36, 0x37, 0x37, 0x30, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x38, 0x31, 0x31, 0x33, 0x66, 0x39, 0x34, 0x64, 0x39, 0x31, 0x37, 0x33, 0x65, 0x65, 0x66, 0x64, 0x35, 0x61, 0x33, 0x30, 0x37, 0x33, 0x66, 0x35, 0x31, 0x36, 0x38, 0x30, 0x33, 0x61, 0x31, 0x30, 0x62, 0x32, 0x38, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x38, 0x33, 0x34, 0x39, 0x62, 0x36, 0x37, 0x66, 0x35, 0x37, 0x34, 0x35, 0x34, 0x34, 0x39, 0x66, 0x36, 0x35, 0x39, 0x33, 0x36, 0x37, 0x64, 0x39, 0x61, 0x64, 0x34, 0x37, 0x31, 0x32, 0x64, 0x62, 0x35, 0x62, 0x38, 0x39, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x63, 0x66, 0x61, 0x39, 0x37, 0x38, 0x30, 0x61, 0x65, 0x36, 0x64, 0x38, 0x37, 0x62, 0x32, 0x63, 0x33, 0x31, 0x38, 0x38, 0x33, 0x66, 0x30, 0x39, 0x32, 0x37, 0x36, 0x39, 0x38, 0x36, 0x63, 0x38, 0x39, 0x61, 0x36, 0x37, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x30, 0x36, 0x66, 0x65, 0x34, 0x63, 0x32, 0x32, 0x31, 0x37, 0x33, 0x39, 0x38, 0x30, 0x66, 0x30, 0x30, 0x63, 0x37, 0x34, 0x33, 0x34, 0x32, 0x62, 0x33, 0x39, 0x63, 0x64, 0x32, 0x33, 0x31, 0x63, 0x36, 0x35, 0x33, 0x31, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x38, 0x34, 0x38, 0x62, 0x34, 0x36, 0x65, 0x61, 0x37, 0x35, 0x62, 0x65, 0x62, 0x37, 0x65, 0x61, 0x61, 0x38, 0x35, 0x66, 0x35, 0x39, 0x64, 0x38, 0x36, 0x36, 0x64, 0x37, 0x37, 0x66, 0x64, 0x32, 0x34, 0x63, 0x66, 0x32, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x34, 0x61, 0x32, 0x64, 0x35, 0x30, 0x66, 0x38, 0x38, 0x35, 0x38, 0x35, 0x33, 0x37, 0x31, 0x38, 0x38, 0x61, 0x32, 0x34, 0x65, 0x30, 0x66, 0x35, 0x30, 0x64, 0x66, 0x31, 0x36, 0x38, 0x31, 0x61, 0x62, 0x30, 0x37, 0x65, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x39, 0x63, 0x65, 0x32, 0x61, 0x66, 0x39, 0x62, 0x38, 0x63, 0x35, 0x65, 0x34, 0x32, 0x63, 0x36, 0x38, 0x30, 0x38, 0x61, 0x33, 0x38, 0x37, 0x30, 0x65, 0x63, 0x35, 0x37, 0x36, 0x66, 0x33, 0x31, 0x33, 0x35, 0x34, 0x35, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x36, 0x34, 0x64, 0x30, 0x32, 0x37, 0x32, 0x32, 0x30, 0x30, 0x30, 0x39, 0x39, 0x36, 0x65, 0x63, 0x64, 0x34, 0x37, 0x35, 0x62, 0x34, 0x33, 0x33, 0x32, 0x39, 0x38, 0x65, 0x39, 0x66, 0x35, 0x34, 0x30, 0x62, 0x30, 0x35, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x37, 0x63, 0x37, 0x37, 0x64, 0x62, 0x65, 0x39, 0x35, 0x64, 0x63, 0x32, 0x36, 0x30, 0x32, 0x63, 0x65, 0x33, 0x32, 0x36, 0x39, 0x61, 0x39, 0x35, 0x34, 0x35, 0x64, 0x30, 0x34, 0x39, 0x36, 0x35, 0x66, 0x65, 0x66, 0x64, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x64, 0x63, 0x62, 0x62, 0x30, 0x35, 0x36, 0x66, 0x34, 0x64, 0x62, 0x37, 0x64, 0x39, 0x64, 0x61, 0x33, 0x39, 0x39, 0x33, 0x36, 0x32, 0x30, 0x32, 0x63, 0x35, 0x62, 0x64, 0x38, 0x32, 0x33, 0x30, 0x62, 0x33, 0x62, 0x34, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x63, 0x62, 0x61, 0x62, 0x62, 0x30, 0x62, 0x32, 0x32, 0x37, 0x38, 0x32, 0x62, 0x33, 0x37, 0x35, 0x34, 0x34, 0x32, 0x39, 0x65, 0x31, 0x37, 0x35, 0x37, 0x61, 0x61, 0x62, 0x61, 0x30, 0x34, 0x62, 0x38, 0x31, 0x31, 0x38, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x33, 0x37, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x31, 0x63, 0x34, 0x34, 0x62, 0x33, 0x30, 0x38, 0x34, 0x30, 0x34, 0x37, 0x31, 0x38, 0x34, 0x62, 0x32, 0x61, 0x64, 0x32, 0x31, 0x38, 0x36, 0x38, 0x30, 0x36, 0x34, 0x30, 0x39, 0x30, 0x33, 0x37, 0x35, 0x30, 0x63, 0x34, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x38, 0x65, 0x62, 0x30, 0x37, 0x64, 0x65, 0x33, 0x64, 0x34, 0x39, 0x64, 0x39, 0x64, 0x35, 0x32, 0x62, 0x62, 0x65, 0x38, 0x65, 0x35, 0x62, 0x32, 0x36, 0x64, 0x62, 0x65, 0x31, 0x64, 0x31, 0x36, 0x30, 0x66, 0x61, 0x38, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x63, 0x66, 0x33, 0x61, 0x61, 0x32, 0x31, 0x61, 0x62, 0x37, 0x34, 0x32, 0x35, 0x37, 0x36, 0x61, 0x64, 0x38, 0x63, 0x34, 0x32, 0x32, 0x66, 0x37, 0x31, 0x62, 0x62, 0x31, 0x38, 0x38, 0x35, 0x39, 0x31, 0x64, 0x65, 0x61, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x63, 0x33, 0x31, 0x32, 0x61, 0x39, 0x36, 0x35, 0x35, 0x34, 0x32, 0x36, 0x61, 0x39, 0x63, 0x30, 0x63, 0x39, 0x65, 0x66, 0x61, 0x33, 0x66, 0x64, 0x38, 0x32, 0x35, 0x35, 0x39, 0x65, 0x66, 0x34, 0x35, 0x30, 0x35, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x33, 0x65, 0x32, 0x62, 0x31, 0x62, 0x66, 0x33, 0x34, 0x36, 0x64, 0x64, 0x30, 0x37, 0x30, 0x62, 0x30, 0x32, 0x37, 0x33, 0x35, 0x37, 0x66, 0x65, 0x61, 0x63, 0x34, 0x34, 0x61, 0x34, 0x62, 0x32, 0x63, 0x39, 0x37, 0x64, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x64, 0x33, 0x39, 0x64, 0x35, 0x31, 0x30, 0x38, 0x38, 0x39, 0x65, 0x35, 0x35, 0x32, 0x61, 0x33, 0x39, 0x36, 0x31, 0x33, 0x35, 0x62, 0x66, 0x63, 0x64, 0x62, 0x30, 0x36, 0x65, 0x33, 0x37, 0x65, 0x33, 0x38, 0x37, 0x36, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x61, 0x33, 0x31, 0x34, 0x38, 0x38, 0x33, 0x33, 0x64, 0x39, 0x36, 0x34, 0x34, 0x39, 0x38, 0x34, 0x66, 0x37, 0x63, 0x34, 0x37, 0x35, 0x61, 0x37, 0x38, 0x35, 0x30, 0x37, 0x31, 0x36, 0x65, 0x66, 0x62, 0x34, 0x38, 0x30, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x62, 0x34, 0x61, 0x39, 0x32, 0x32, 0x36, 0x65, 0x36, 0x31, 0x36, 0x38, 0x33, 0x63, 0x37, 0x32, 0x63, 0x31, 0x38, 0x33, 0x32, 0x35, 0x34, 0x36, 0x39, 0x30, 0x64, 0x61, 0x66, 0x35, 0x31, 0x31, 0x62, 0x34, 0x31, 0x31, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x37, 0x36, 0x33, 0x61, 0x64, 0x64, 0x38, 0x36, 0x38, 0x66, 0x64, 0x37, 0x33, 0x36, 0x31, 0x31, 0x37, 0x38, 0x33, 0x34, 0x32, 0x66, 0x63, 0x30, 0x35, 0x35, 0x65, 0x61, 0x61, 0x32, 0x62, 0x39, 0x35, 0x66, 0x36, 0x38, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x38, 0x39, 0x38, 0x65, 0x61, 0x62, 0x38, 0x63, 0x30, 0x35, 0x63, 0x30, 0x32, 0x32, 0x32, 0x38, 0x38, 0x33, 0x63, 0x64, 0x34, 0x64, 0x62, 0x32, 0x33, 0x62, 0x37, 0x37, 0x39, 0x35, 0x65, 0x31, 0x61, 0x32, 0x34, 0x61, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x36, 0x36, 0x34, 0x37, 0x63, 0x66, 0x63, 0x38, 0x35, 0x64, 0x32, 0x33, 0x64, 0x33, 0x37, 0x36, 0x30, 0x35, 0x35, 0x37, 0x33, 0x64, 0x32, 0x30, 0x38, 0x63, 0x61, 0x31, 0x35, 0x34, 0x62, 0x32, 0x34, 0x34, 0x64, 0x37, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x66, 0x39, 0x65, 0x65, 0x34, 0x62, 0x38, 0x38, 0x36, 0x63, 0x36, 0x64, 0x31, 0x65, 0x39, 0x35, 0x34, 0x39, 0x36, 0x66, 0x64, 0x32, 0x37, 0x34, 0x32, 0x33, 0x35, 0x62, 0x66, 0x34, 0x65, 0x63, 0x66, 0x63, 0x62, 0x30, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x38, 0x36, 0x30, 0x61, 0x39, 0x33, 0x35, 0x32, 0x35, 0x39, 0x35, 0x35, 0x66, 0x66, 0x36, 0x32, 0x34, 0x39, 0x34, 0x30, 0x66, 0x61, 0x64, 0x63, 0x66, 0x66, 0x62, 0x38, 0x65, 0x31, 0x34, 0x39, 0x66, 0x64, 0x35, 0x39, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x31, 0x63, 0x32, 0x64, 0x33, 0x34, 0x36, 0x63, 0x30, 0x61, 0x64, 0x66, 0x34, 0x63, 0x63, 0x35, 0x36, 0x37, 0x30, 0x38, 0x66, 0x36, 0x33, 0x39, 0x34, 0x62, 0x61, 0x36, 0x63, 0x38, 0x63, 0x38, 0x61, 0x36, 0x34, 0x61, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x61, 0x38, 0x65, 0x32, 0x33, 0x36, 0x61, 0x33, 0x30, 0x65, 0x36, 0x64, 0x36, 0x33, 0x63, 0x31, 0x66, 0x66, 0x36, 0x34, 0x34, 0x64, 0x31, 0x33, 0x32, 0x61, 0x61, 0x32, 0x35, 0x63, 0x38, 0x39, 0x35, 0x33, 0x37, 0x65, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x36, 0x37, 0x39, 0x65, 0x33, 0x37, 0x38, 0x66, 0x64, 0x63, 0x65, 0x36, 0x62, 0x66, 0x64, 0x39, 0x37, 0x66, 0x65, 0x36, 0x32, 0x66, 0x30, 0x34, 0x33, 0x63, 0x36, 0x66, 0x36, 0x34, 0x30, 0x35, 0x64, 0x37, 0x39, 0x65, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x33, 0x34, 0x33, 0x36, 0x63, 0x38, 0x34, 0x37, 0x32, 0x36, 0x35, 0x35, 0x66, 0x36, 0x34, 0x63, 0x33, 0x61, 0x66, 0x61, 0x61, 0x66, 0x37, 0x63, 0x34, 0x63, 0x36, 0x32, 0x31, 0x63, 0x38, 0x33, 0x61, 0x36, 0x32, 0x62, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x65, 0x30, 0x37, 0x63, 0x65, 0x64, 0x36, 0x61, 0x63, 0x35, 0x64, 0x64, 0x66, 0x39, 0x39, 0x31, 0x65, 0x66, 0x66, 0x36, 0x63, 0x33, 0x64, 0x61, 0x32, 0x32, 0x36, 0x61, 0x37, 0x34, 0x31, 0x62, 0x64, 0x32, 0x34, 0x33, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x35, 0x36, 0x61, 0x34, 0x30, 0x34, 0x37, 0x32, 0x33, 0x63, 0x66, 0x66, 0x32, 0x30, 0x64, 0x30, 0x36, 0x38, 0x35, 0x34, 0x38, 0x38, 0x62, 0x30, 0x35, 0x61, 0x30, 0x32, 0x63, 0x64, 0x63, 0x33, 0x35, 0x61, 0x61, 0x63, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x35, 0x35, 0x31, 0x65, 0x63, 0x31, 0x61, 0x32, 0x31, 0x33, 0x33, 0x63, 0x39, 0x38, 0x31, 0x64, 0x35, 0x66, 0x63, 0x36, 0x61, 0x38, 0x63, 0x38, 0x31, 0x37, 0x33, 0x66, 0x39, 0x65, 0x37, 0x63, 0x34, 0x66, 0x34, 0x37, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x33, 0x37, 0x36, 0x65, 0x63, 0x61, 0x62, 0x66, 0x37, 0x34, 0x36, 0x63, 0x65, 0x35, 0x33, 0x33, 0x32, 0x31, 0x63, 0x66, 0x34, 0x32, 0x63, 0x38, 0x36, 0x36, 0x34, 0x39, 0x62, 0x39, 0x32, 0x62, 0x36, 0x37, 0x62, 0x32, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x34, 0x62, 0x61, 0x36, 0x63, 0x36, 0x31, 0x30, 0x38, 0x32, 0x65, 0x39, 0x38, 0x39, 0x31, 0x30, 0x39, 0x66, 0x35, 0x63, 0x31, 0x31, 0x64, 0x34, 0x62, 0x34, 0x30, 0x65, 0x39, 0x39, 0x31, 0x36, 0x36, 0x30, 0x64, 0x34, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x30, 0x64, 0x35, 0x39, 0x31, 0x31, 0x65, 0x64, 0x38, 0x64, 0x64, 0x39, 0x65, 0x65, 0x63, 0x34, 0x35, 0x63, 0x30, 0x36, 0x30, 0x63, 0x32, 0x32, 0x33, 0x66, 0x38, 0x39, 0x61, 0x37, 0x66, 0x36, 0x32, 0x30, 0x62, 0x62, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x31, 0x62, 0x62, 0x36, 0x66, 0x31, 0x64, 0x61, 0x35, 0x65, 0x62, 0x31, 0x30, 0x64, 0x34, 0x38, 0x39, 0x39, 0x66, 0x37, 0x65, 0x36, 0x31, 0x64, 0x30, 0x36, 0x63, 0x31, 0x62, 0x30, 0x30, 0x66, 0x64, 0x66, 0x62, 0x35, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x33, 0x61, 0x33, 0x30, 0x61, 0x63, 0x34, 0x32, 0x38, 0x36, 0x61, 0x65, 0x31, 0x37, 0x63, 0x66, 0x34, 0x38, 0x33, 0x64, 0x61, 0x64, 0x37, 0x62, 0x38, 0x37, 0x30, 0x63, 0x36, 0x62, 0x64, 0x36, 0x34, 0x64, 0x37, 0x62, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x30, 0x62, 0x33, 0x31, 0x66, 0x66, 0x36, 0x65, 0x32, 0x34, 0x37, 0x34, 0x35, 0x65, 0x61, 0x64, 0x38, 0x65, 0x64, 0x39, 0x62, 0x62, 0x38, 0x35, 0x66, 0x63, 0x30, 0x62, 0x66, 0x32, 0x66, 0x65, 0x31, 0x64, 0x35, 0x35, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x34, 0x36, 0x39, 0x31, 0x63, 0x65, 0x37, 0x31, 0x34, 0x66, 0x33, 0x32, 0x35, 0x63, 0x65, 0x64, 0x35, 0x35, 0x63, 0x65, 0x35, 0x39, 0x32, 0x38, 0x63, 0x65, 0x39, 0x62, 0x61, 0x31, 0x32, 0x66, 0x61, 0x63, 0x64, 0x31, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x33, 0x63, 0x66, 0x65, 0x38, 0x32, 0x36, 0x64, 0x36, 0x64, 0x31, 0x38, 0x34, 0x31, 0x64, 0x63, 0x61, 0x65, 0x34, 0x34, 0x33, 0x62, 0x65, 0x38, 0x63, 0x33, 0x38, 0x37, 0x35, 0x31, 0x38, 0x31, 0x33, 0x36, 0x62, 0x35, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x63, 0x64, 0x38, 0x34, 0x35, 0x34, 0x36, 0x38, 0x39, 0x36, 0x64, 0x64, 0x30, 0x38, 0x31, 0x64, 0x62, 0x31, 0x61, 0x33, 0x32, 0x30, 0x62, 0x64, 0x34, 0x64, 0x38, 0x63, 0x31, 0x64, 0x64, 0x31, 0x35, 0x32, 0x38, 0x63, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x62, 0x35, 0x66, 0x65, 0x36, 0x61, 0x36, 0x38, 0x62, 0x64, 0x33, 0x36, 0x31, 0x32, 0x61, 0x63, 0x31, 0x35, 0x61, 0x39, 0x39, 0x61, 0x36, 0x31, 0x65, 0x35, 0x35, 0x35, 0x39, 0x32, 0x38, 0x65, 0x65, 0x63, 0x65, 0x61, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x37, 0x39, 0x65, 0x33, 0x30, 0x66, 0x66, 0x30, 0x35, 0x37, 0x66, 0x37, 0x30, 0x61, 0x33, 0x64, 0x30, 0x31, 0x39, 0x31, 0x66, 0x37, 0x66, 0x35, 0x33, 0x66, 0x37, 0x36, 0x31, 0x35, 0x33, 0x37, 0x61, 0x66, 0x37, 0x64, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x33, 0x66, 0x61, 0x64, 0x34, 0x39, 0x63, 0x39, 0x65, 0x35, 0x64, 0x32, 0x37, 0x35, 0x39, 0x63, 0x38, 0x65, 0x38, 0x65, 0x35, 0x61, 0x37, 0x61, 0x34, 0x64, 0x36, 0x30, 0x61, 0x30, 0x64, 0x64, 0x31, 0x33, 0x35, 0x36, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x61, 0x38, 0x33, 0x30, 0x37, 0x32, 0x34, 0x33, 0x30, 0x32, 0x62, 0x63, 0x30, 0x66, 0x36, 0x65, 0x62, 0x64, 0x61, 0x61, 0x31, 0x65, 0x62, 0x65, 0x65, 0x65, 0x62, 0x34, 0x36, 0x65, 0x36, 0x63, 0x65, 0x30, 0x30, 0x62, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x62, 0x36, 0x61, 0x65, 0x32, 0x32, 0x63, 0x37, 0x37, 0x33, 0x35, 0x66, 0x35, 0x62, 0x38, 0x39, 0x66, 0x33, 0x34, 0x64, 0x64, 0x37, 0x37, 0x61, 0x64, 0x30, 0x39, 0x37, 0x35, 0x66, 0x30, 0x61, 0x63, 0x63, 0x39, 0x31, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x32, 0x64, 0x64, 0x35, 0x35, 0x64, 0x62, 0x37, 0x65, 0x61, 0x62, 0x30, 0x65, 0x62, 0x65, 0x65, 0x36, 0x35, 0x62, 0x33, 0x33, 0x65, 0x64, 0x38, 0x32, 0x30, 0x32, 0x63, 0x31, 0x65, 0x39, 0x39, 0x32, 0x65, 0x39, 0x35, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x35, 0x64, 0x36, 0x64, 0x32, 0x35, 0x35, 0x35, 0x32, 0x30, 0x61, 0x38, 0x64, 0x62, 0x32, 0x39, 0x61, 0x62, 0x63, 0x34, 0x37, 0x64, 0x38, 0x33, 0x61, 0x35, 0x64, 0x62, 0x38, 0x61, 0x31, 0x61, 0x37, 0x64, 0x66, 0x30, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x63, 0x39, 0x30, 0x38, 0x37, 0x36, 0x30, 0x30, 0x34, 0x31, 0x30, 0x39, 0x63, 0x64, 0x37, 0x39, 0x61, 0x33, 0x64, 0x65, 0x61, 0x38, 0x36, 0x36, 0x63, 0x62, 0x38, 0x34, 0x30, 0x61, 0x63, 0x33, 0x36, 0x34, 0x62, 0x61, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x33, 0x65, 0x39, 0x64, 0x36, 0x61, 0x35, 0x38, 0x32, 0x35, 0x33, 0x62, 0x65, 0x65, 0x62, 0x65, 0x62, 0x37, 0x39, 0x33, 0x65, 0x36, 0x66, 0x32, 0x38, 0x62, 0x30, 0x35, 0x34, 0x61, 0x35, 0x38, 0x34, 0x39, 0x31, 0x62, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x31, 0x64, 0x39, 0x39, 0x62, 0x36, 0x39, 0x39, 0x65, 0x35, 0x63, 0x36, 0x39, 0x31, 0x31, 0x35, 0x31, 0x39, 0x63, 0x62, 0x32, 0x30, 0x37, 0x36, 0x62, 0x34, 0x63, 0x37, 0x36, 0x33, 0x33, 0x30, 0x63, 0x35, 0x34, 0x64, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x39, 0x31, 0x33, 0x32, 0x62, 0x37, 0x30, 0x39, 0x33, 0x64, 0x33, 0x65, 0x63, 0x34, 0x32, 0x65, 0x31, 0x65, 0x34, 0x66, 0x62, 0x38, 0x63, 0x62, 0x33, 0x31, 0x65, 0x63, 0x64, 0x64, 0x34, 0x33, 0x61, 0x65, 0x37, 0x37, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x31, 0x65, 0x61, 0x66, 0x35, 0x64, 0x35, 0x31, 0x61, 0x35, 0x62, 0x61, 0x31, 0x62, 0x61, 0x33, 0x39, 0x62, 0x62, 0x34, 0x31, 0x38, 0x64, 0x62, 0x62, 0x35, 0x34, 0x66, 0x61, 0x62, 0x37, 0x35, 0x30, 0x65, 0x66, 0x62, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x34, 0x39, 0x33, 0x64, 0x33, 0x66, 0x34, 0x66, 0x62, 0x38, 0x36, 0x36, 0x34, 0x39, 0x31, 0x63, 0x66, 0x38, 0x66, 0x38, 0x30, 0x30, 0x65, 0x66, 0x62, 0x37, 0x65, 0x32, 0x33, 0x32, 0x34, 0x65, 0x64, 0x37, 0x63, 0x66, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x39, 0x39, 0x38, 0x32, 0x66, 0x35, 0x36, 0x32, 0x33, 0x37, 0x65, 0x65, 0x34, 0x35, 0x38, 0x39, 0x35, 0x31, 0x30, 0x34, 0x37, 0x65, 0x30, 0x61, 0x32, 0x32, 0x33, 0x30, 0x66, 0x38, 0x30, 0x34, 0x65, 0x32, 0x65, 0x38, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x36, 0x65, 0x39, 0x32, 0x61, 0x39, 0x31, 0x62, 0x62, 0x64, 0x61, 0x36, 0x38, 0x62, 0x39, 0x65, 0x32, 0x66, 0x39, 0x38, 0x62, 0x33, 0x63, 0x30, 0x34, 0x38, 0x39, 0x33, 0x34, 0x65, 0x33, 0x63, 0x63, 0x30, 0x62, 0x34, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x34, 0x33, 0x30, 0x65, 0x31, 0x66, 0x36, 0x34, 0x37, 0x66, 0x33, 0x32, 0x31, 0x65, 0x64, 0x33, 0x34, 0x37, 0x33, 0x39, 0x35, 0x36, 0x32, 0x33, 0x32, 0x33, 0x63, 0x37, 0x64, 0x36, 0x32, 0x33, 0x34, 0x31, 0x30, 0x62, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x61, 0x34, 0x33, 0x62, 0x62, 0x63, 0x32, 0x33, 0x61, 0x30, 0x64, 0x33, 0x32, 0x31, 0x62, 0x61, 0x39, 0x65, 0x34, 0x36, 0x62, 0x39, 0x32, 0x39, 0x37, 0x33, 0x35, 0x63, 0x65, 0x37, 0x64, 0x38, 0x65, 0x66, 0x30, 0x63, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x34, 0x35, 0x63, 0x62, 0x33, 0x34, 0x63, 0x39, 0x32, 0x38, 0x33, 0x36, 0x34, 0x64, 0x39, 0x63, 0x63, 0x39, 0x64, 0x38, 0x62, 0x62, 0x30, 0x30, 0x33, 0x37, 0x33, 0x34, 0x37, 0x34, 0x36, 0x31, 0x38, 0x66, 0x30, 0x36, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x39, 0x39, 0x39, 0x35, 0x39, 0x31, 0x66, 0x64, 0x37, 0x32, 0x65, 0x66, 0x37, 0x31, 0x31, 0x31, 0x65, 0x66, 0x63, 0x61, 0x37, 0x61, 0x39, 0x65, 0x39, 0x37, 0x61, 0x32, 0x33, 0x35, 0x36, 0x62, 0x33, 0x62, 0x30, 0x30, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x37, 0x39, 0x64, 0x61, 0x64, 0x66, 0x31, 0x61, 0x33, 0x39, 0x35, 0x61, 0x33, 0x34, 0x37, 0x31, 0x65, 0x32, 0x30, 0x62, 0x36, 0x66, 0x37, 0x36, 0x33, 0x64, 0x39, 0x61, 0x30, 0x66, 0x66, 0x31, 0x39, 0x61, 0x33, 0x66, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x64, 0x34, 0x65, 0x31, 0x35, 0x39, 0x39, 0x64, 0x30, 0x33, 0x62, 0x37, 0x39, 0x38, 0x30, 0x39, 0x65, 0x30, 0x31, 0x33, 0x30, 0x61, 0x38, 0x64, 0x63, 0x33, 0x38, 0x34, 0x30, 0x38, 0x66, 0x30, 0x35, 0x65, 0x38, 0x63, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x62, 0x63, 0x65, 0x31, 0x38, 0x30, 0x38, 0x39, 0x34, 0x30, 0x63, 0x64, 0x34, 0x65, 0x66, 0x35, 0x62, 0x35, 0x65, 0x30, 0x35, 0x32, 0x38, 0x35, 0x66, 0x38, 0x32, 0x64, 0x66, 0x37, 0x61, 0x39, 0x61, 0x62, 0x35, 0x65, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x62, 0x30, 0x63, 0x31, 0x32, 0x36, 0x38, 0x32, 0x61, 0x32, 0x66, 0x31, 0x35, 0x63, 0x39, 0x62, 0x35, 0x37, 0x34, 0x31, 0x62, 0x32, 0x33, 0x38, 0x35, 0x63, 0x62, 0x65, 0x34, 0x31, 0x66, 0x30, 0x33, 0x34, 0x30, 0x36, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x62, 0x37, 0x62, 0x64, 0x63, 0x66, 0x39, 0x34, 0x34, 0x64, 0x35, 0x35, 0x37, 0x30, 0x38, 0x33, 0x38, 0x62, 0x65, 0x37, 0x30, 0x34, 0x36, 0x30, 0x32, 0x34, 0x33, 0x61, 0x38, 0x36, 0x39, 0x34, 0x34, 0x38, 0x35, 0x38, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x35, 0x32, 0x65, 0x30, 0x65, 0x34, 0x62, 0x33, 0x64, 0x36, 0x61, 0x65, 0x30, 0x36, 0x62, 0x38, 0x33, 0x36, 0x66, 0x30, 0x33, 0x32, 0x63, 0x61, 0x30, 0x39, 0x64, 0x62, 0x34, 0x30, 0x39, 0x64, 0x64, 0x66, 0x65, 0x30, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x64, 0x34, 0x66, 0x32, 0x34, 0x36, 0x38, 0x66, 0x39, 0x36, 0x33, 0x66, 0x64, 0x37, 0x39, 0x61, 0x30, 0x30, 0x36, 0x31, 0x39, 0x38, 0x62, 0x62, 0x36, 0x37, 0x38, 0x39, 0x35, 0x64, 0x32, 0x64, 0x35, 0x61, 0x61, 0x34, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x65, 0x37, 0x32, 0x32, 0x32, 0x66, 0x61, 0x61, 0x66, 0x30, 0x66, 0x34, 0x64, 0x61, 0x34, 0x30, 0x63, 0x31, 0x63, 0x34, 0x61, 0x34, 0x30, 0x36, 0x33, 0x30, 0x33, 0x37, 0x33, 0x61, 0x30, 0x39, 0x62, 0x65, 0x64, 0x37, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x35, 0x39, 0x61, 0x65, 0x65, 0x32, 0x38, 0x31, 0x66, 0x61, 0x34, 0x33, 0x66, 0x65, 0x39, 0x37, 0x31, 0x39, 0x34, 0x33, 0x35, 0x31, 0x61, 0x39, 0x38, 0x35, 0x37, 0x65, 0x30, 0x31, 0x61, 0x33, 0x62, 0x38, 0x39, 0x37, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x30, 0x64, 0x34, 0x62, 0x37, 0x65, 0x66, 0x39, 0x31, 0x66, 0x62, 0x35, 0x35, 0x61, 0x64, 0x32, 0x36, 0x35, 0x66, 0x32, 0x35, 0x31, 0x31, 0x34, 0x32, 0x30, 0x36, 0x37, 0x66, 0x31, 0x30, 0x33, 0x37, 0x36, 0x63, 0x65, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x36, 0x66, 0x35, 0x63, 0x31, 0x32, 0x34, 0x63, 0x63, 0x37, 0x38, 0x39, 0x66, 0x38, 0x62, 0x62, 0x33, 0x39, 0x38, 0x65, 0x33, 0x66, 0x38, 0x38, 0x39, 0x37, 0x35, 0x31, 0x62, 0x63, 0x34, 0x62, 0x36, 0x30, 0x32, 0x64, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x39, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x35, 0x65, 0x66, 0x32, 0x37, 0x64, 0x38, 0x32, 0x30, 0x34, 0x30, 0x33, 0x38, 0x30, 0x35, 0x66, 0x63, 0x39, 0x65, 0x64, 0x32, 0x35, 0x39, 0x66, 0x66, 0x66, 0x36, 0x34, 0x61, 0x63, 0x62, 0x38, 0x64, 0x36, 0x33, 0x34, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x61, 0x38, 0x33, 0x30, 0x38, 0x66, 0x34, 0x32, 0x39, 0x31, 0x30, 0x65, 0x35, 0x61, 0x64, 0x65, 0x30, 0x39, 0x63, 0x31, 0x61, 0x35, 0x65, 0x32, 0x38, 0x32, 0x64, 0x36, 0x64, 0x39, 0x31, 0x37, 0x31, 0x30, 0x62, 0x64, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x34, 0x63, 0x65, 0x63, 0x33, 0x35, 0x33, 0x61, 0x63, 0x33, 0x65, 0x33, 0x38, 0x31, 0x38, 0x33, 0x35, 0x65, 0x33, 0x63, 0x30, 0x39, 0x39, 0x31, 0x66, 0x38, 0x66, 0x61, 0x61, 0x35, 0x62, 0x37, 0x64, 0x30, 0x61, 0x38, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x37, 0x63, 0x66, 0x33, 0x34, 0x31, 0x65, 0x38, 0x35, 0x31, 0x36, 0x63, 0x38, 0x31, 0x35, 0x38, 0x31, 0x34, 0x65, 0x62, 0x63, 0x64, 0x37, 0x33, 0x65, 0x36, 0x35, 0x36, 0x39, 0x61, 0x66, 0x31, 0x34, 0x63, 0x66, 0x37, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x39, 0x64, 0x61, 0x36, 0x36, 0x32, 0x65, 0x62, 0x34, 0x61, 0x30, 0x61, 0x32, 0x61, 0x30, 0x36, 0x39, 0x64, 0x32, 0x62, 0x63, 0x32, 0x34, 0x62, 0x30, 0x35, 0x62, 0x34, 0x65, 0x65, 0x32, 0x65, 0x39, 0x32, 0x63, 0x34, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x36, 0x33, 0x34, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x39, 0x38, 0x64, 0x38, 0x32, 0x37, 0x33, 0x31, 0x31, 0x35, 0x62, 0x35, 0x36, 0x61, 0x66, 0x34, 0x33, 0x63, 0x35, 0x30, 0x35, 0x65, 0x30, 0x38, 0x37, 0x61, 0x66, 0x66, 0x30, 0x36, 0x37, 0x36, 0x65, 0x64, 0x33, 0x36, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x39, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x34, 0x64, 0x31, 0x33, 0x63, 0x35, 0x35, 0x61, 0x38, 0x34, 0x65, 0x34, 0x36, 0x65, 0x64, 0x37, 0x65, 0x39, 0x63, 0x62, 0x39, 0x30, 0x66, 0x64, 0x33, 0x35, 0x35, 0x65, 0x38, 0x61, 0x64, 0x39, 0x39, 0x31, 0x65, 0x33, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x63, 0x30, 0x36, 0x38, 0x62, 0x34, 0x39, 0x37, 0x39, 0x62, 0x30, 0x65, 0x61, 0x36, 0x34, 0x61, 0x36, 0x32, 0x64, 0x33, 0x62, 0x37, 0x61, 0x61, 0x38, 0x39, 0x37, 0x64, 0x37, 0x33, 0x38, 0x31, 0x30, 0x64, 0x63, 0x35, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x66, 0x64, 0x66, 0x35, 0x34, 0x36, 0x36, 0x37, 0x34, 0x37, 0x33, 0x38, 0x63, 0x39, 0x38, 0x34, 0x64, 0x38, 0x66, 0x61, 0x62, 0x38, 0x35, 0x37, 0x38, 0x38, 0x30, 0x62, 0x33, 0x65, 0x34, 0x32, 0x38, 0x30, 0x63, 0x30, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x66, 0x31, 0x36, 0x31, 0x37, 0x34, 0x30, 0x61, 0x36, 0x64, 0x39, 0x30, 0x39, 0x66, 0x65, 0x39, 0x39, 0x63, 0x35, 0x39, 0x61, 0x39, 0x62, 0x37, 0x37, 0x39, 0x34, 0x35, 0x63, 0x39, 0x31, 0x63, 0x63, 0x39, 0x31, 0x34, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x61, 0x64, 0x31, 0x62, 0x33, 0x64, 0x37, 0x35, 0x66, 0x62, 0x61, 0x36, 0x37, 0x64, 0x35, 0x34, 0x36, 0x36, 0x33, 0x64, 0x61, 0x39, 0x66, 0x63, 0x38, 0x34, 0x38, 0x61, 0x38, 0x61, 0x64, 0x65, 0x31, 0x30, 0x66, 0x61, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x39, 0x65, 0x62, 0x34, 0x39, 0x39, 0x30, 0x62, 0x35, 0x61, 0x62, 0x61, 0x35, 0x35, 0x34, 0x37, 0x30, 0x39, 0x33, 0x64, 0x61, 0x31, 0x32, 0x62, 0x36, 0x62, 0x33, 0x63, 0x31, 0x30, 0x39, 0x33, 0x64, 0x66, 0x36, 0x64, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x33, 0x64, 0x39, 0x61, 0x65, 0x65, 0x64, 0x34, 0x62, 0x31, 0x38, 0x30, 0x39, 0x34, 0x37, 0x65, 0x64, 0x32, 0x62, 0x39, 0x32, 0x30, 0x37, 0x63, 0x63, 0x65, 0x34, 0x63, 0x33, 0x64, 0x64, 0x63, 0x35, 0x35, 0x65, 0x31, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x33, 0x65, 0x36, 0x32, 0x65, 0x37, 0x37, 0x61, 0x38, 0x62, 0x32, 0x32, 0x35, 0x65, 0x34, 0x31, 0x31, 0x35, 0x39, 0x32, 0x62, 0x31, 0x61, 0x66, 0x33, 0x30, 0x30, 0x37, 0x35, 0x32, 0x66, 0x65, 0x34, 0x31, 0x32, 0x34, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x30, 0x62, 0x34, 0x32, 0x35, 0x35, 0x35, 0x35, 0x65, 0x34, 0x65, 0x34, 0x63, 0x35, 0x31, 0x37, 0x31, 0x38, 0x31, 0x34, 0x36, 0x38, 0x33, 0x36, 0x61, 0x32, 0x63, 0x31, 0x65, 0x65, 0x37, 0x37, 0x61, 0x35, 0x62, 0x34, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x38, 0x65, 0x34, 0x36, 0x64, 0x36, 0x39, 0x64, 0x32, 0x65, 0x32, 0x33, 0x34, 0x33, 0x64, 0x38, 0x36, 0x63, 0x36, 0x30, 0x64, 0x38, 0x32, 0x63, 0x66, 0x34, 0x32, 0x63, 0x32, 0x30, 0x34, 0x31, 0x61, 0x30, 0x63, 0x31, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x35, 0x37, 0x30, 0x65, 0x39, 0x32, 0x34, 0x63, 0x39, 0x35, 0x64, 0x65, 0x62, 0x62, 0x37, 0x30, 0x36, 0x31, 0x33, 0x36, 0x39, 0x37, 0x39, 0x32, 0x63, 0x66, 0x32, 0x65, 0x66, 0x65, 0x63, 0x32, 0x61, 0x38, 0x32, 0x64, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x63, 0x34, 0x62, 0x66, 0x35, 0x65, 0x37, 0x35, 0x38, 0x39, 0x63, 0x34, 0x37, 0x62, 0x32, 0x38, 0x33, 0x37, 0x38, 0x64, 0x37, 0x35, 0x30, 0x33, 0x63, 0x66, 0x39, 0x36, 0x34, 0x38, 0x38, 0x30, 0x36, 0x31, 0x64, 0x62, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x37, 0x65, 0x61, 0x35, 0x62, 0x66, 0x30, 0x33, 0x35, 0x32, 0x38, 0x31, 0x30, 0x30, 0x65, 0x64, 0x38, 0x61, 0x66, 0x38, 0x61, 0x65, 0x64, 0x32, 0x36, 0x35, 0x33, 0x65, 0x39, 0x32, 0x31, 0x62, 0x36, 0x65, 0x36, 0x37, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x32, 0x62, 0x64, 0x65, 0x36, 0x34, 0x36, 0x31, 0x36, 0x38, 0x36, 0x65, 0x31, 0x39, 0x61, 0x63, 0x36, 0x35, 0x30, 0x63, 0x39, 0x37, 0x30, 0x64, 0x30, 0x36, 0x37, 0x32, 0x65, 0x37, 0x36, 0x64, 0x63, 0x62, 0x34, 0x66, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x65, 0x37, 0x36, 0x30, 0x62, 0x62, 0x30, 0x37, 0x63, 0x30, 0x38, 0x31, 0x37, 0x37, 0x37, 0x33, 0x34, 0x35, 0x65, 0x30, 0x35, 0x37, 0x38, 0x65, 0x38, 0x62, 0x63, 0x38, 0x39, 0x38, 0x32, 0x32, 0x36, 0x64, 0x34, 0x65, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x39, 0x63, 0x62, 0x66, 0x32, 0x31, 0x64, 0x66, 0x65, 0x63, 0x38, 0x61, 0x63, 0x65, 0x33, 0x66, 0x31, 0x63, 0x31, 0x39, 0x36, 0x64, 0x38, 0x32, 0x64, 0x66, 0x39, 0x36, 0x32, 0x35, 0x33, 0x34, 0x64, 0x66, 0x33, 0x39, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x33, 0x32, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x38, 0x32, 0x34, 0x35, 0x63, 0x33, 0x61, 0x62, 0x37, 0x64, 0x31, 0x37, 0x33, 0x31, 0x36, 0x34, 0x38, 0x36, 0x31, 0x63, 0x64, 0x33, 0x39, 0x39, 0x31, 0x62, 0x39, 0x34, 0x66, 0x31, 0x62, 0x61, 0x34, 0x30, 0x61, 0x39, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x35, 0x63, 0x66, 0x38, 0x32, 0x36, 0x35, 0x35, 0x30, 0x63, 0x38, 0x65, 0x61, 0x66, 0x31, 0x30, 0x61, 0x66, 0x32, 0x32, 0x33, 0x34, 0x66, 0x65, 0x66, 0x39, 0x30, 0x34, 0x64, 0x64, 0x62, 0x39, 0x35, 0x32, 0x31, 0x33, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x37, 0x62, 0x66, 0x61, 0x66, 0x37, 0x36, 0x32, 0x34, 0x33, 0x63, 0x64, 0x62, 0x39, 0x34, 0x30, 0x33, 0x63, 0x36, 0x37, 0x64, 0x32, 0x63, 0x65, 0x65, 0x66, 0x64, 0x65, 0x65, 0x39, 0x30, 0x61, 0x33, 0x66, 0x65, 0x62, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x35, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x32, 0x31, 0x31, 0x33, 0x35, 0x30, 0x34, 0x35, 0x33, 0x34, 0x36, 0x34, 0x32, 0x61, 0x31, 0x64, 0x61, 0x66, 0x31, 0x30, 0x32, 0x65, 0x65, 0x65, 0x31, 0x30, 0x62, 0x39, 0x65, 0x62, 0x64, 0x65, 0x37, 0x36, 0x65, 0x32, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x33, 0x33, 0x33, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x62, 0x63, 0x34, 0x61, 0x35, 0x65, 0x32, 0x30, 0x34, 0x35, 0x66, 0x34, 0x66, 0x66, 0x38, 0x64, 0x62, 0x31, 0x38, 0x34, 0x63, 0x66, 0x33, 0x61, 0x39, 0x62, 0x30, 0x63, 0x30, 0x36, 0x35, 0x61, 0x64, 0x38, 0x30, 0x37, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x64, 0x61, 0x34, 0x30, 0x37, 0x33, 0x36, 0x66, 0x39, 0x39, 0x64, 0x35, 0x64, 0x66, 0x33, 0x62, 0x30, 0x36, 0x38, 0x61, 0x35, 0x64, 0x37, 0x34, 0x35, 0x66, 0x61, 0x66, 0x63, 0x36, 0x34, 0x36, 0x33, 0x66, 0x63, 0x39, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x31, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x61, 0x36, 0x63, 0x37, 0x62, 0x30, 0x39, 0x37, 0x33, 0x64, 0x30, 0x62, 0x61, 0x65, 0x32, 0x39, 0x34, 0x30, 0x35, 0x34, 0x30, 0x65, 0x32, 0x34, 0x37, 0x64, 0x33, 0x36, 0x32, 0x37, 0x65, 0x33, 0x37, 0x63, 0x61, 0x33, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x62, 0x30, 0x35, 0x39, 0x36, 0x32, 0x66, 0x62, 0x32, 0x61, 0x64, 0x35, 0x38, 0x39, 0x64, 0x36, 0x35, 0x61, 0x64, 0x31, 0x36, 0x61, 0x32, 0x32, 0x35, 0x35, 0x39, 0x65, 0x62, 0x61, 0x31, 0x34, 0x35, 0x38, 0x66, 0x33, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x65, 0x61, 0x65, 0x33, 0x37, 0x33, 0x33, 0x64, 0x38, 0x66, 0x61, 0x34, 0x33, 0x64, 0x36, 0x63, 0x64, 0x38, 0x30, 0x63, 0x31, 0x61, 0x39, 0x36, 0x65, 0x38, 0x65, 0x62, 0x39, 0x33, 0x31, 0x30, 0x39, 0x63, 0x38, 0x33, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x65, 0x61, 0x65, 0x61, 0x37, 0x38, 0x63, 0x64, 0x34, 0x64, 0x39, 0x35, 0x66, 0x61, 0x65, 0x63, 0x66, 0x62, 0x36, 0x38, 0x38, 0x33, 0x36, 0x65, 0x61, 0x66, 0x65, 0x38, 0x33, 0x35, 0x32, 0x30, 0x66, 0x33, 0x62, 0x62, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x39, 0x66, 0x36, 0x66, 0x39, 0x62, 0x61, 0x61, 0x62, 0x63, 0x30, 0x31, 0x38, 0x63, 0x38, 0x66, 0x38, 0x65, 0x31, 0x31, 0x39, 0x65, 0x30, 0x31, 0x31, 0x35, 0x66, 0x34, 0x39, 0x31, 0x66, 0x63, 0x39, 0x32, 0x61, 0x38, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x33, 0x33, 0x31, 0x36, 0x39, 0x38, 0x35, 0x64, 0x34, 0x37, 0x37, 0x34, 0x32, 0x62, 0x66, 0x65, 0x64, 0x34, 0x31, 0x30, 0x36, 0x30, 0x34, 0x61, 0x39, 0x31, 0x39, 0x35, 0x33, 0x63, 0x30, 0x35, 0x66, 0x62, 0x31, 0x32, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x64, 0x37, 0x35, 0x30, 0x31, 0x36, 0x65, 0x33, 0x61, 0x30, 0x38, 0x31, 0x35, 0x30, 0x37, 0x32, 0x62, 0x36, 0x62, 0x31, 0x30, 0x38, 0x62, 0x63, 0x63, 0x31, 0x62, 0x37, 0x39, 0x39, 0x61, 0x63, 0x66, 0x30, 0x33, 0x38, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x33, 0x32, 0x34, 0x30, 0x33, 0x35, 0x38, 0x37, 0x39, 0x34, 0x37, 0x62, 0x39, 0x66, 0x31, 0x35, 0x36, 0x32, 0x32, 0x61, 0x36, 0x38, 0x64, 0x31, 0x30, 0x34, 0x64, 0x35, 0x34, 0x64, 0x33, 0x33, 0x64, 0x62, 0x64, 0x31, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x36, 0x34, 0x62, 0x39, 0x63, 0x31, 0x32, 0x34, 0x36, 0x64, 0x38, 0x35, 0x37, 0x38, 0x33, 0x31, 0x36, 0x34, 0x33, 0x31, 0x30, 0x37, 0x64, 0x33, 0x35, 0x35, 0x62, 0x35, 0x63, 0x37, 0x35, 0x66, 0x65, 0x66, 0x35, 0x64, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x64, 0x63, 0x61, 0x66, 0x63, 0x63, 0x32, 0x62, 0x61, 0x63, 0x65, 0x37, 0x62, 0x35, 0x35, 0x62, 0x35, 0x34, 0x63, 0x30, 0x31, 0x61, 0x31, 0x63, 0x35, 0x31, 0x34, 0x36, 0x32, 0x36, 0x62, 0x66, 0x36, 0x31, 0x65, 0x62, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x38, 0x36, 0x61, 0x64, 0x61, 0x37, 0x62, 0x62, 0x62, 0x30, 0x36, 0x31, 0x37, 0x62, 0x64, 0x61, 0x38, 0x34, 0x32, 0x31, 0x39, 0x31, 0x63, 0x36, 0x38, 0x63, 0x39, 0x32, 0x32, 0x65, 0x61, 0x33, 0x61, 0x38, 0x61, 0x63, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x33, 0x36, 0x64, 0x63, 0x39, 0x36, 0x37, 0x36, 0x30, 0x30, 0x31, 0x32, 0x33, 0x38, 0x38, 0x66, 0x65, 0x38, 0x38, 0x62, 0x36, 0x36, 0x63, 0x30, 0x36, 0x65, 0x66, 0x65, 0x35, 0x37, 0x65, 0x30, 0x64, 0x37, 0x63, 0x66, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x32, 0x38, 0x38, 0x61, 0x35, 0x61, 0x38, 0x62, 0x37, 0x35, 0x66, 0x33, 0x64, 0x63, 0x34, 0x31, 0x39, 0x31, 0x65, 0x62, 0x30, 0x34, 0x35, 0x37, 0x65, 0x31, 0x63, 0x38, 0x33, 0x64, 0x62, 0x64, 0x32, 0x30, 0x34, 0x64, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x62, 0x36, 0x63, 0x32, 0x33, 0x64, 0x64, 0x32, 0x65, 0x63, 0x39, 0x30, 0x62, 0x34, 0x37, 0x32, 0x38, 0x66, 0x33, 0x62, 0x62, 0x32, 0x65, 0x37, 0x36, 0x34, 0x63, 0x33, 0x63, 0x35, 0x30, 0x63, 0x38, 0x35, 0x66, 0x31, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x31, 0x30, 0x62, 0x30, 0x32, 0x30, 0x66, 0x64, 0x39, 0x38, 0x30, 0x34, 0x34, 0x39, 0x35, 0x37, 0x39, 0x39, 0x35, 0x30, 0x39, 0x32, 0x30, 0x39, 0x30, 0x66, 0x31, 0x37, 0x66, 0x30, 0x34, 0x65, 0x35, 0x32, 0x63, 0x64, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x62, 0x61, 0x65, 0x62, 0x33, 0x30, 0x65, 0x33, 0x31, 0x33, 0x37, 0x37, 0x36, 0x63, 0x34, 0x63, 0x36, 0x64, 0x32, 0x34, 0x37, 0x34, 0x30, 0x32, 0x62, 0x61, 0x34, 0x31, 0x36, 0x37, 0x61, 0x66, 0x63, 0x64, 0x61, 0x31, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x34, 0x31, 0x66, 0x37, 0x64, 0x32, 0x36, 0x61, 0x38, 0x36, 0x63, 0x64, 0x64, 0x62, 0x32, 0x62, 0x65, 0x31, 0x33, 0x30, 0x38, 0x31, 0x38, 0x31, 0x30, 0x65, 0x30, 0x31, 0x63, 0x39, 0x63, 0x38, 0x33, 0x63, 0x34, 0x62, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x61, 0x38, 0x64, 0x61, 0x64, 0x65, 0x63, 0x31, 0x34, 0x32, 0x35, 0x37, 0x31, 0x61, 0x37, 0x64, 0x35, 0x33, 0x61, 0x34, 0x32, 0x39, 0x37, 0x30, 0x35, 0x31, 0x37, 0x38, 0x36, 0x64, 0x30, 0x37, 0x32, 0x63, 0x62, 0x61, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x37, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x37, 0x33, 0x64, 0x64, 0x33, 0x35, 0x36, 0x62, 0x34, 0x39, 0x37, 0x39, 0x62, 0x35, 0x37, 0x39, 0x62, 0x34, 0x30, 0x31, 0x64, 0x34, 0x63, 0x63, 0x37, 0x61, 0x33, 0x31, 0x61, 0x32, 0x36, 0x38, 0x64, 0x64, 0x63, 0x65, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x66, 0x31, 0x61, 0x63, 0x66, 0x65, 0x39, 0x39, 0x62, 0x63, 0x38, 0x63, 0x31, 0x34, 0x62, 0x33, 0x30, 0x34, 0x63, 0x38, 0x64, 0x39, 0x30, 0x35, 0x62, 0x61, 0x32, 0x37, 0x36, 0x35, 0x37, 0x62, 0x38, 0x61, 0x37, 0x62, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x64, 0x61, 0x62, 0x62, 0x35, 0x62, 0x36, 0x65, 0x65, 0x64, 0x39, 0x65, 0x39, 0x39, 0x62, 0x65, 0x39, 0x31, 0x35, 0x38, 0x38, 0x38, 0x66, 0x36, 0x35, 0x36, 0x38, 0x30, 0x35, 0x36, 0x33, 0x38, 0x31, 0x36, 0x30, 0x38, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x38, 0x34, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x65, 0x32, 0x30, 0x61, 0x65, 0x37, 0x36, 0x61, 0x61, 0x30, 0x38, 0x32, 0x36, 0x33, 0x62, 0x32, 0x30, 0x35, 0x64, 0x35, 0x31, 0x34, 0x32, 0x34, 0x36, 0x31, 0x39, 0x36, 0x31, 0x65, 0x32, 0x34, 0x30, 0x38, 0x64, 0x32, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x34, 0x66, 0x66, 0x39, 0x38, 0x39, 0x62, 0x37, 0x62, 0x65, 0x64, 0x39, 0x61, 0x62, 0x31, 0x30, 0x39, 0x64, 0x31, 0x30, 0x63, 0x38, 0x63, 0x37, 0x65, 0x35, 0x35, 0x66, 0x30, 0x32, 0x64, 0x37, 0x36, 0x37, 0x33, 0x34, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x38, 0x64, 0x64, 0x32, 0x33, 0x32, 0x33, 0x38, 0x65, 0x65, 0x36, 0x65, 0x61, 0x37, 0x63, 0x32, 0x31, 0x33, 0x38, 0x64, 0x33, 0x38, 0x35, 0x64, 0x66, 0x35, 0x30, 0x30, 0x63, 0x33, 0x32, 0x35, 0x66, 0x33, 0x37, 0x36, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x64, 0x36, 0x64, 0x64, 0x30, 0x63, 0x66, 0x66, 0x32, 0x33, 0x34, 0x30, 0x30, 0x65, 0x31, 0x37, 0x33, 0x30, 0x62, 0x61, 0x37, 0x62, 0x38, 0x39, 0x34, 0x35, 0x30, 0x34, 0x35, 0x37, 0x37, 0x64, 0x31, 0x34, 0x65, 0x37, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x31, 0x34, 0x37, 0x34, 0x33, 0x30, 0x63, 0x33, 0x31, 0x30, 0x36, 0x35, 0x30, 0x30, 0x65, 0x37, 0x39, 0x66, 0x61, 0x32, 0x66, 0x35, 0x30, 0x32, 0x34, 0x36, 0x32, 0x65, 0x39, 0x34, 0x37, 0x30, 0x33, 0x63, 0x32, 0x33, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x61, 0x65, 0x31, 0x34, 0x64, 0x37, 0x32, 0x34, 0x38, 0x33, 0x32, 0x65, 0x32, 0x66, 0x63, 0x65, 0x32, 0x37, 0x37, 0x38, 0x64, 0x65, 0x37, 0x66, 0x37, 0x62, 0x38, 0x64, 0x61, 0x66, 0x37, 0x62, 0x31, 0x32, 0x61, 0x39, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x37, 0x34, 0x31, 0x33, 0x30, 0x36, 0x30, 0x61, 0x66, 0x33, 0x66, 0x31, 0x34, 0x65, 0x62, 0x34, 0x37, 0x39, 0x30, 0x36, 0x35, 0x66, 0x31, 0x65, 0x39, 0x64, 0x31, 0x39, 0x62, 0x33, 0x37, 0x35, 0x37, 0x61, 0x65, 0x38, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x30, 0x34, 0x64, 0x32, 0x65, 0x64, 0x63, 0x30, 0x35, 0x38, 0x61, 0x31, 0x61, 0x66, 0x63, 0x37, 0x36, 0x31, 0x64, 0x39, 0x63, 0x39, 0x39, 0x61, 0x65, 0x34, 0x66, 0x63, 0x35, 0x63, 0x38, 0x35, 0x64, 0x34, 0x63, 0x38, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x34, 0x38, 0x30, 0x37, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x39, 0x34, 0x64, 0x36, 0x33, 0x36, 0x65, 0x36, 0x38, 0x34, 0x65, 0x62, 0x31, 0x35, 0x35, 0x38, 0x39, 0x35, 0x63, 0x65, 0x36, 0x64, 0x62, 0x34, 0x61, 0x32, 0x35, 0x38, 0x38, 0x66, 0x62, 0x61, 0x31, 0x64, 0x30, 0x30, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x32, 0x31, 0x62, 0x32, 0x61, 0x37, 0x61, 0x61, 0x34, 0x34, 0x63, 0x32, 0x31, 0x32, 0x39, 0x38, 0x65, 0x38, 0x35, 0x30, 0x33, 0x39, 0x64, 0x30, 0x30, 0x65, 0x32, 0x65, 0x34, 0x36, 0x30, 0x65, 0x36, 0x37, 0x30, 0x62, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x38, 0x39, 0x61, 0x38, 0x30, 0x30, 0x36, 0x61, 0x34, 0x66, 0x31, 0x33, 0x37, 0x61, 0x32, 0x30, 0x64, 0x63, 0x32, 0x62, 0x65, 0x63, 0x34, 0x36, 0x66, 0x65, 0x32, 0x65, 0x62, 0x33, 0x31, 0x32, 0x65, 0x61, 0x39, 0x36, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x36, 0x61, 0x66, 0x62, 0x61, 0x37, 0x31, 0x64, 0x38, 0x34, 0x39, 0x65, 0x38, 0x30, 0x63, 0x30, 0x65, 0x64, 0x35, 0x39, 0x63, 0x61, 0x63, 0x35, 0x31, 0x39, 0x62, 0x32, 0x37, 0x38, 0x65, 0x37, 0x66, 0x37, 0x61, 0x62, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x66, 0x32, 0x63, 0x64, 0x64, 0x31, 0x62, 0x30, 0x34, 0x36, 0x65, 0x32, 0x64, 0x61, 0x32, 0x66, 0x62, 0x62, 0x35, 0x61, 0x32, 0x36, 0x37, 0x32, 0x33, 0x34, 0x32, 0x32, 0x62, 0x38, 0x33, 0x32, 0x35, 0x65, 0x32, 0x35, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x39, 0x66, 0x61, 0x37, 0x32, 0x63, 0x39, 0x35, 0x66, 0x33, 0x37, 0x64, 0x30, 0x38, 0x65, 0x39, 0x61, 0x33, 0x36, 0x30, 0x30, 0x39, 0x65, 0x37, 0x61, 0x34, 0x62, 0x30, 0x37, 0x66, 0x32, 0x39, 0x62, 0x61, 0x64, 0x34, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x38, 0x66, 0x62, 0x64, 0x32, 0x39, 0x64, 0x36, 0x37, 0x63, 0x66, 0x34, 0x61, 0x30, 0x31, 0x33, 0x63, 0x62, 0x30, 0x32, 0x61, 0x34, 0x62, 0x31, 0x37, 0x36, 0x65, 0x66, 0x32, 0x34, 0x34, 0x65, 0x39, 0x65, 0x65, 0x36, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x31, 0x39, 0x30, 0x63, 0x61, 0x38, 0x38, 0x35, 0x64, 0x61, 0x34, 0x32, 0x33, 0x31, 0x38, 0x37, 0x34, 0x63, 0x31, 0x63, 0x66, 0x62, 0x34, 0x32, 0x62, 0x31, 0x35, 0x38, 0x30, 0x61, 0x32, 0x31, 0x37, 0x33, 0x37, 0x66, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x64, 0x66, 0x34, 0x35, 0x38, 0x62, 0x66, 0x66, 0x33, 0x35, 0x39, 0x39, 0x65, 0x65, 0x65, 0x31, 0x61, 0x32, 0x36, 0x33, 0x39, 0x38, 0x38, 0x35, 0x33, 0x63, 0x35, 0x37, 0x35, 0x62, 0x63, 0x33, 0x38, 0x63, 0x36, 0x33, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x32, 0x32, 0x32, 0x30, 0x61, 0x64, 0x65, 0x33, 0x36, 0x34, 0x64, 0x30, 0x33, 0x36, 0x39, 0x66, 0x32, 0x64, 0x32, 0x64, 0x61, 0x37, 0x38, 0x33, 0x63, 0x61, 0x34, 0x37, 0x34, 0x64, 0x37, 0x62, 0x39, 0x62, 0x33, 0x34, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x65, 0x32, 0x61, 0x66, 0x37, 0x33, 0x33, 0x39, 0x33, 0x65, 0x61, 0x39, 0x38, 0x61, 0x31, 0x64, 0x39, 0x39, 0x33, 0x61, 0x37, 0x34, 0x64, 0x66, 0x35, 0x63, 0x64, 0x37, 0x35, 0x34, 0x62, 0x39, 0x38, 0x64, 0x35, 0x32, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x33, 0x38, 0x64, 0x39, 0x30, 0x66, 0x38, 0x33, 0x66, 0x34, 0x35, 0x31, 0x35, 0x63, 0x30, 0x33, 0x63, 0x63, 0x37, 0x38, 0x33, 0x32, 0x36, 0x61, 0x31, 0x35, 0x34, 0x64, 0x33, 0x35, 0x38, 0x62, 0x64, 0x38, 0x38, 0x32, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x38, 0x65, 0x62, 0x30, 0x38, 0x32, 0x33, 0x62, 0x30, 0x37, 0x62, 0x30, 0x65, 0x36, 0x64, 0x32, 0x30, 0x61, 0x61, 0x64, 0x64, 0x61, 0x30, 0x65, 0x39, 0x35, 0x63, 0x66, 0x33, 0x38, 0x33, 0x35, 0x62, 0x65, 0x31, 0x39, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x38, 0x36, 0x33, 0x39, 0x64, 0x61, 0x62, 0x62, 0x65, 0x33, 0x61, 0x65, 0x61, 0x63, 0x38, 0x38, 0x37, 0x62, 0x35, 0x64, 0x63, 0x30, 0x65, 0x34, 0x33, 0x65, 0x31, 0x33, 0x62, 0x63, 0x64, 0x32, 0x38, 0x37, 0x64, 0x37, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x33, 0x61, 0x30, 0x63, 0x34, 0x62, 0x39, 0x30, 0x33, 0x66, 0x36, 0x65, 0x61, 0x35, 0x32, 0x65, 0x61, 0x37, 0x61, 0x62, 0x37, 0x62, 0x38, 0x38, 0x36, 0x33, 0x62, 0x36, 0x61, 0x36, 0x31, 0x36, 0x61, 0x64, 0x36, 0x36, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x36, 0x62, 0x66, 0x33, 0x32, 0x32, 0x37, 0x37, 0x34, 0x65, 0x31, 0x38, 0x32, 0x38, 0x38, 0x37, 0x36, 0x39, 0x64, 0x36, 0x37, 0x65, 0x33, 0x31, 0x30, 0x37, 0x64, 0x65, 0x62, 0x37, 0x34, 0x34, 0x37, 0x37, 0x30, 0x37, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x36, 0x31, 0x61, 0x34, 0x66, 0x32, 0x66, 0x63, 0x37, 0x37, 0x62, 0x32, 0x39, 0x36, 0x64, 0x31, 0x39, 0x61, 0x64, 0x61, 0x32, 0x33, 0x38, 0x65, 0x34, 0x39, 0x61, 0x35, 0x63, 0x62, 0x38, 0x65, 0x63, 0x62, 0x66, 0x61, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x32, 0x30, 0x38, 0x33, 0x34, 0x38, 0x33, 0x36, 0x64, 0x31, 0x64, 0x62, 0x66, 0x64, 0x61, 0x39, 0x65, 0x37, 0x61, 0x33, 0x31, 0x38, 0x34, 0x64, 0x31, 0x61, 0x64, 0x31, 0x66, 0x64, 0x34, 0x33, 0x32, 0x30, 0x63, 0x63, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x64, 0x33, 0x62, 0x62, 0x33, 0x61, 0x34, 0x65, 0x62, 0x35, 0x35, 0x34, 0x63, 0x66, 0x63, 0x61, 0x39, 0x37, 0x39, 0x34, 0x37, 0x64, 0x35, 0x37, 0x35, 0x35, 0x30, 0x37, 0x63, 0x64, 0x66, 0x64, 0x36, 0x64, 0x32, 0x31, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x37, 0x38, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x66, 0x61, 0x30, 0x65, 0x38, 0x36, 0x63, 0x64, 0x30, 0x38, 0x37, 0x64, 0x64, 0x36, 0x38, 0x64, 0x36, 0x39, 0x33, 0x31, 0x39, 0x30, 0x66, 0x33, 0x32, 0x64, 0x39, 0x33, 0x33, 0x31, 0x30, 0x39, 0x30, 0x39, 0x65, 0x64, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x37, 0x35, 0x39, 0x66, 0x61, 0x31, 0x31, 0x30, 0x61, 0x33, 0x31, 0x63, 0x38, 0x38, 0x34, 0x36, 0x39, 0x66, 0x35, 0x34, 0x64, 0x34, 0x34, 0x62, 0x61, 0x33, 0x30, 0x33, 0x64, 0x35, 0x37, 0x64, 0x64, 0x33, 0x65, 0x31, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x38, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x36, 0x66, 0x34, 0x39, 0x30, 0x37, 0x63, 0x61, 0x62, 0x34, 0x31, 0x65, 0x32, 0x37, 0x30, 0x38, 0x34, 0x62, 0x39, 0x38, 0x34, 0x35, 0x30, 0x36, 0x39, 0x66, 0x66, 0x32, 0x66, 0x64, 0x30, 0x63, 0x39, 0x61, 0x64, 0x65, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x38, 0x39, 0x65, 0x35, 0x30, 0x35, 0x63, 0x62, 0x34, 0x36, 0x65, 0x32, 0x31, 0x31, 0x61, 0x35, 0x33, 0x66, 0x33, 0x32, 0x66, 0x31, 0x36, 0x37, 0x61, 0x38, 0x37, 0x37, 0x62, 0x65, 0x63, 0x38, 0x37, 0x66, 0x34, 0x62, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x61, 0x38, 0x35, 0x32, 0x66, 0x64, 0x62, 0x39, 0x62, 0x31, 0x34, 0x30, 0x35, 0x62, 0x66, 0x35, 0x33, 0x63, 0x63, 0x66, 0x39, 0x35, 0x30, 0x38, 0x66, 0x38, 0x33, 0x32, 0x39, 0x39, 0x64, 0x33, 0x32, 0x30, 0x36, 0x63, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x37, 0x61, 0x62, 0x63, 0x39, 0x36, 0x34, 0x39, 0x30, 0x35, 0x36, 0x64, 0x33, 0x39, 0x32, 0x36, 0x30, 0x34, 0x34, 0x64, 0x32, 0x38, 0x63, 0x33, 0x61, 0x64, 0x30, 0x39, 0x65, 0x64, 0x31, 0x37, 0x62, 0x36, 0x37, 0x64, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x32, 0x39, 0x66, 0x39, 0x65, 0x39, 0x61, 0x35, 0x32, 0x33, 0x63, 0x31, 0x66, 0x38, 0x36, 0x36, 0x39, 0x34, 0x34, 0x38, 0x62, 0x35, 0x35, 0x63, 0x34, 0x38, 0x63, 0x62, 0x64, 0x34, 0x37, 0x63, 0x32, 0x35, 0x65, 0x36, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x34, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x61, 0x39, 0x64, 0x61, 0x37, 0x32, 0x35, 0x37, 0x34, 0x63, 0x35, 0x31, 0x65, 0x37, 0x65, 0x65, 0x30, 0x39, 0x30, 0x34, 0x62, 0x61, 0x31, 0x66, 0x37, 0x33, 0x61, 0x36, 0x62, 0x37, 0x62, 0x38, 0x33, 0x62, 0x39, 0x62, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x30, 0x65, 0x32, 0x62, 0x39, 0x32, 0x63, 0x30, 0x66, 0x36, 0x63, 0x39, 0x30, 0x32, 0x62, 0x35, 0x31, 0x33, 0x64, 0x39, 0x66, 0x31, 0x65, 0x36, 0x66, 0x61, 0x62, 0x36, 0x61, 0x38, 0x62, 0x30, 0x64, 0x65, 0x66, 0x33, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x66, 0x37, 0x63, 0x30, 0x37, 0x32, 0x62, 0x32, 0x63, 0x35, 0x61, 0x63, 0x64, 0x37, 0x31, 0x63, 0x37, 0x36, 0x61, 0x64, 0x64, 0x63, 0x63, 0x65, 0x35, 0x33, 0x35, 0x63, 0x66, 0x37, 0x66, 0x38, 0x66, 0x39, 0x33, 0x35, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x35, 0x35, 0x36, 0x64, 0x62, 0x32, 0x37, 0x33, 0x34, 0x39, 0x61, 0x62, 0x38, 0x62, 0x32, 0x37, 0x30, 0x30, 0x34, 0x39, 0x34, 0x34, 0x65, 0x64, 0x35, 0x30, 0x61, 0x34, 0x36, 0x65, 0x39, 0x34, 0x31, 0x61, 0x30, 0x66, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x37, 0x36, 0x31, 0x38, 0x63, 0x38, 0x35, 0x36, 0x35, 0x36, 0x32, 0x30, 0x37, 0x63, 0x37, 0x62, 0x61, 0x63, 0x31, 0x35, 0x30, 0x37, 0x63, 0x30, 0x66, 0x66, 0x65, 0x66, 0x61, 0x32, 0x66, 0x62, 0x36, 0x34, 0x62, 0x30, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x34, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x66, 0x33, 0x37, 0x32, 0x33, 0x34, 0x37, 0x63, 0x39, 0x36, 0x62, 0x35, 0x35, 0x66, 0x37, 0x64, 0x34, 0x33, 0x30, 0x36, 0x30, 0x33, 0x34, 0x62, 0x65, 0x62, 0x38, 0x33, 0x32, 0x36, 0x36, 0x66, 0x64, 0x39, 0x30, 0x39, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x37, 0x38, 0x34, 0x63, 0x31, 0x30, 0x35, 0x31, 0x31, 0x37, 0x63, 0x31, 0x66, 0x36, 0x38, 0x39, 0x33, 0x35, 0x37, 0x39, 0x37, 0x66, 0x65, 0x31, 0x35, 0x39, 0x61, 0x62, 0x63, 0x37, 0x34, 0x65, 0x34, 0x33, 0x64, 0x31, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x38, 0x34, 0x66, 0x39, 0x36, 0x64, 0x64, 0x62, 0x34, 0x37, 0x62, 0x35, 0x31, 0x38, 0x36, 0x65, 0x65, 0x35, 0x35, 0x38, 0x61, 0x61, 0x33, 0x31, 0x33, 0x32, 0x34, 0x64, 0x66, 0x35, 0x33, 0x36, 0x31, 0x63, 0x30, 0x66, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x30, 0x63, 0x31, 0x32, 0x30, 0x39, 0x37, 0x35, 0x34, 0x66, 0x35, 0x64, 0x38, 0x37, 0x62, 0x31, 0x38, 0x31, 0x64, 0x61, 0x34, 0x66, 0x30, 0x38, 0x31, 0x37, 0x61, 0x38, 0x31, 0x38, 0x35, 0x39, 0x65, 0x66, 0x39, 0x66, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x66, 0x64, 0x61, 0x39, 0x34, 0x30, 0x35, 0x63, 0x38, 0x65, 0x39, 0x37, 0x33, 0x36, 0x35, 0x31, 0x34, 0x35, 0x37, 0x34, 0x64, 0x61, 0x39, 0x32, 0x38, 0x64, 0x65, 0x36, 0x37, 0x34, 0x35, 0x36, 0x30, 0x31, 0x30, 0x39, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x37, 0x38, 0x36, 0x39, 0x36, 0x64, 0x35, 0x31, 0x35, 0x30, 0x61, 0x39, 0x61, 0x32, 0x36, 0x33, 0x35, 0x31, 0x33, 0x66, 0x38, 0x66, 0x37, 0x34, 0x63, 0x36, 0x39, 0x36, 0x66, 0x38, 0x62, 0x31, 0x33, 0x39, 0x37, 0x63, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x61, 0x64, 0x31, 0x39, 0x32, 0x36, 0x62, 0x63, 0x36, 0x36, 0x62, 0x64, 0x62, 0x33, 0x33, 0x31, 0x35, 0x38, 0x38, 0x65, 0x61, 0x38, 0x31, 0x39, 0x33, 0x37, 0x38, 0x38, 0x35, 0x33, 0x34, 0x64, 0x39, 0x38, 0x32, 0x63, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x66, 0x38, 0x30, 0x62, 0x34, 0x30, 0x66, 0x62, 0x38, 0x33, 0x66, 0x62, 0x39, 0x37, 0x62, 0x62, 0x30, 0x64, 0x35, 0x32, 0x33, 0x30, 0x61, 0x66, 0x34, 0x66, 0x36, 0x65, 0x64, 0x35, 0x39, 0x62, 0x31, 0x63, 0x37, 0x63, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x30, 0x37, 0x35, 0x37, 0x38, 0x65, 0x31, 0x66, 0x34, 0x64, 0x64, 0x62, 0x38, 0x66, 0x66, 0x36, 0x64, 0x35, 0x38, 0x36, 0x37, 0x62, 0x33, 0x39, 0x35, 0x38, 0x32, 0x64, 0x37, 0x31, 0x62, 0x39, 0x38, 0x31, 0x32, 0x61, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x38, 0x38, 0x33, 0x64, 0x35, 0x34, 0x63, 0x64, 0x33, 0x39, 0x31, 0x35, 0x65, 0x35, 0x34, 0x39, 0x30, 0x39, 0x35, 0x35, 0x33, 0x30, 0x66, 0x39, 0x61, 0x62, 0x31, 0x38, 0x30, 0x35, 0x65, 0x38, 0x63, 0x35, 0x34, 0x33, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x37, 0x34, 0x63, 0x38, 0x61, 0x34, 0x31, 0x34, 0x63, 0x65, 0x61, 0x65, 0x66, 0x64, 0x33, 0x63, 0x32, 0x65, 0x34, 0x64, 0x66, 0x64, 0x62, 0x65, 0x66, 0x34, 0x33, 0x30, 0x35, 0x36, 0x38, 0x64, 0x39, 0x61, 0x39, 0x36, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x32, 0x64, 0x33, 0x32, 0x62, 0x30, 0x30, 0x66, 0x33, 0x30, 0x35, 0x62, 0x63, 0x63, 0x32, 0x34, 0x64, 0x63, 0x65, 0x66, 0x35, 0x36, 0x38, 0x31, 0x37, 0x64, 0x36, 0x32, 0x32, 0x66, 0x33, 0x34, 0x66, 0x62, 0x32, 0x63, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x31, 0x66, 0x38, 0x61, 0x33, 0x61, 0x32, 0x61, 0x66, 0x30, 0x61, 0x38, 0x62, 0x64, 0x62, 0x65, 0x31, 0x64, 0x61, 0x30, 0x30, 0x39, 0x33, 0x32, 0x31, 0x66, 0x62, 0x32, 0x39, 0x37, 0x36, 0x34, 0x65, 0x62, 0x36, 0x32, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x37, 0x62, 0x30, 0x34, 0x65, 0x30, 0x33, 0x34, 0x33, 0x61, 0x33, 0x32, 0x31, 0x33, 0x31, 0x66, 0x64, 0x36, 0x61, 0x62, 0x62, 0x33, 0x39, 0x62, 0x31, 0x62, 0x36, 0x31, 0x35, 0x36, 0x62, 0x62, 0x61, 0x33, 0x64, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x36, 0x39, 0x37, 0x38, 0x31, 0x66, 0x33, 0x32, 0x66, 0x66, 0x63, 0x65, 0x33, 0x33, 0x33, 0x34, 0x36, 0x66, 0x32, 0x63, 0x39, 0x61, 0x65, 0x33, 0x66, 0x30, 0x38, 0x34, 0x39, 0x33, 0x66, 0x33, 0x65, 0x38, 0x32, 0x66, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x62, 0x33, 0x64, 0x32, 0x63, 0x39, 0x62, 0x66, 0x35, 0x37, 0x30, 0x62, 0x65, 0x36, 0x61, 0x32, 0x66, 0x37, 0x32, 0x61, 0x64, 0x63, 0x61, 0x31, 0x38, 0x36, 0x32, 0x63, 0x33, 0x31, 0x30, 0x39, 0x33, 0x36, 0x61, 0x34, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x39, 0x63, 0x61, 0x66, 0x33, 0x39, 0x62, 0x62, 0x33, 0x37, 0x37, 0x66, 0x64, 0x66, 0x32, 0x63, 0x66, 0x31, 0x39, 0x62, 0x64, 0x34, 0x66, 0x62, 0x35, 0x32, 0x35, 0x39, 0x31, 0x63, 0x32, 0x36, 0x33, 0x31, 0x61, 0x36, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x36, 0x38, 0x33, 0x32, 0x34, 0x62, 0x63, 0x62, 0x37, 0x37, 0x36, 0x64, 0x33, 0x66, 0x66, 0x64, 0x30, 0x62, 0x66, 0x39, 0x66, 0x65, 0x61, 0x39, 0x31, 0x64, 0x39, 0x66, 0x30, 0x33, 0x37, 0x66, 0x64, 0x36, 0x61, 0x62, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x39, 0x39, 0x66, 0x65, 0x39, 0x62, 0x62, 0x36, 0x63, 0x36, 0x64, 0x31, 0x30, 0x36, 0x36, 0x64, 0x39, 0x31, 0x32, 0x30, 0x39, 0x39, 0x35, 0x34, 0x37, 0x66, 0x64, 0x31, 0x66, 0x34, 0x38, 0x30, 0x39, 0x65, 0x61, 0x63, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x66, 0x65, 0x30, 0x61, 0x38, 0x33, 0x30, 0x63, 0x61, 0x63, 0x65, 0x38, 0x37, 0x62, 0x37, 0x32, 0x39, 0x33, 0x39, 0x39, 0x33, 0x61, 0x37, 0x65, 0x39, 0x34, 0x39, 0x36, 0x63, 0x65, 0x36, 0x34, 0x66, 0x38, 0x65, 0x33, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x63, 0x30, 0x30, 0x35, 0x34, 0x62, 0x37, 0x30, 0x30, 0x64, 0x33, 0x61, 0x37, 0x63, 0x32, 0x64, 0x63, 0x62, 0x65, 0x32, 0x37, 0x35, 0x36, 0x38, 0x39, 0x64, 0x34, 0x66, 0x34, 0x63, 0x61, 0x64, 0x31, 0x36, 0x61, 0x33, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x37, 0x65, 0x37, 0x63, 0x36, 0x31, 0x37, 0x37, 0x39, 0x61, 0x64, 0x62, 0x37, 0x37, 0x30, 0x36, 0x63, 0x39, 0x34, 0x64, 0x33, 0x32, 0x34, 0x30, 0x39, 0x61, 0x32, 0x62, 0x62, 0x34, 0x65, 0x39, 0x39, 0x34, 0x62, 0x66, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x39, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x33, 0x37, 0x64, 0x32, 0x31, 0x35, 0x64, 0x31, 0x31, 0x64, 0x31, 0x64, 0x66, 0x33, 0x64, 0x35, 0x34, 0x66, 0x62, 0x64, 0x33, 0x32, 0x31, 0x63, 0x64, 0x32, 0x39, 0x35, 0x63, 0x35, 0x34, 0x36, 0x35, 0x65, 0x32, 0x37, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x31, 0x36, 0x36, 0x66, 0x30, 0x32, 0x33, 0x31, 0x33, 0x66, 0x65, 0x61, 0x65, 0x31, 0x38, 0x62, 0x62, 0x30, 0x34, 0x34, 0x65, 0x37, 0x38, 0x37, 0x37, 0x63, 0x38, 0x30, 0x38, 0x62, 0x35, 0x35, 0x62, 0x35, 0x62, 0x66, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x31, 0x62, 0x31, 0x35, 0x30, 0x31, 0x36, 0x34, 0x37, 0x61, 0x32, 0x65, 0x30, 0x36, 0x63, 0x30, 0x65, 0x64, 0x34, 0x33, 0x66, 0x66, 0x31, 0x39, 0x37, 0x66, 0x63, 0x63, 0x65, 0x63, 0x33, 0x35, 0x65, 0x31, 0x37, 0x30, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x33, 0x31, 0x36, 0x61, 0x64, 0x66, 0x32, 0x35, 0x33, 0x37, 0x38, 0x63, 0x31, 0x30, 0x66, 0x35, 0x37, 0x36, 0x64, 0x35, 0x62, 0x34, 0x31, 0x61, 0x36, 0x66, 0x34, 0x37, 0x66, 0x61, 0x39, 0x38, 0x66, 0x63, 0x65, 0x33, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x36, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x65, 0x32, 0x66, 0x64, 0x63, 0x36, 0x37, 0x39, 0x65, 0x36, 0x62, 0x65, 0x65, 0x30, 0x31, 0x65, 0x39, 0x33, 0x65, 0x66, 0x34, 0x61, 0x33, 0x61, 0x62, 0x31, 0x62, 0x63, 0x63, 0x65, 0x30, 0x31, 0x32, 0x61, 0x62, 0x63, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x30, 0x32, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x38, 0x65, 0x61, 0x66, 0x36, 0x62, 0x38, 0x35, 0x35, 0x34, 0x63, 0x34, 0x35, 0x64, 0x66, 0x64, 0x65, 0x31, 0x36, 0x62, 0x37, 0x38, 0x63, 0x65, 0x30, 0x63, 0x31, 0x35, 0x37, 0x66, 0x32, 0x65, 0x65, 0x33, 0x31, 0x33, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x39, 0x32, 0x33, 0x61, 0x35, 0x64, 0x38, 0x66, 0x62, 0x63, 0x33, 0x64, 0x30, 0x31, 0x61, 0x61, 0x30, 0x37, 0x39, 0x64, 0x31, 0x63, 0x66, 0x65, 0x34, 0x62, 0x34, 0x33, 0x63, 0x65, 0x30, 0x37, 0x31, 0x62, 0x31, 0x36, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x32, 0x38, 0x38, 0x34, 0x37, 0x65, 0x34, 0x66, 0x30, 0x39, 0x64, 0x66, 0x63, 0x65, 0x35, 0x66, 0x39, 0x62, 0x32, 0x35, 0x61, 0x66, 0x37, 0x63, 0x34, 0x65, 0x35, 0x33, 0x30, 0x66, 0x35, 0x39, 0x63, 0x38, 0x38, 0x30, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x63, 0x65, 0x38, 0x38, 0x32, 0x37, 0x35, 0x39, 0x35, 0x36, 0x64, 0x65, 0x66, 0x35, 0x66, 0x39, 0x34, 0x35, 0x38, 0x65, 0x33, 0x62, 0x39, 0x35, 0x64, 0x65, 0x63, 0x61, 0x63, 0x64, 0x34, 0x38, 0x34, 0x30, 0x32, 0x31, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x34, 0x32, 0x31, 0x33, 0x33, 0x33, 0x39, 0x61, 0x30, 0x31, 0x35, 0x35, 0x31, 0x38, 0x36, 0x31, 0x37, 0x36, 0x34, 0x63, 0x38, 0x37, 0x61, 0x39, 0x33, 0x63, 0x65, 0x38, 0x66, 0x38, 0x35, 0x66, 0x38, 0x37, 0x39, 0x35, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x35, 0x39, 0x62, 0x35, 0x66, 0x64, 0x33, 0x33, 0x37, 0x62, 0x39, 0x63, 0x35, 0x35, 0x37, 0x32, 0x61, 0x39, 0x62, 0x66, 0x39, 0x65, 0x30, 0x66, 0x32, 0x35, 0x32, 0x31, 0x66, 0x37, 0x64, 0x34, 0x34, 0x36, 0x64, 0x62, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x62, 0x30, 0x33, 0x62, 0x66, 0x61, 0x36, 0x63, 0x31, 0x31, 0x33, 0x31, 0x32, 0x33, 0x34, 0x65, 0x35, 0x36, 0x62, 0x37, 0x65, 0x61, 0x37, 0x63, 0x34, 0x66, 0x37, 0x32, 0x31, 0x34, 0x38, 0x37, 0x35, 0x34, 0x36, 0x62, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x36, 0x66, 0x66, 0x37, 0x31, 0x62, 0x33, 0x64, 0x62, 0x30, 0x39, 0x32, 0x38, 0x66, 0x38, 0x33, 0x39, 0x65, 0x30, 0x35, 0x61, 0x37, 0x33, 0x32, 0x33, 0x62, 0x66, 0x62, 0x35, 0x37, 0x64, 0x32, 0x39, 0x63, 0x38, 0x37, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x37, 0x63, 0x32, 0x30, 0x32, 0x62, 0x34, 0x36, 0x32, 0x62, 0x37, 0x63, 0x63, 0x35, 0x38, 0x35, 0x35, 0x64, 0x37, 0x34, 0x38, 0x34, 0x37, 0x35, 0x35, 0x66, 0x36, 0x65, 0x32, 0x36, 0x65, 0x66, 0x34, 0x33, 0x61, 0x31, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x33, 0x34, 0x38, 0x36, 0x63, 0x61, 0x36, 0x34, 0x62, 0x33, 0x37, 0x35, 0x34, 0x37, 0x34, 0x66, 0x62, 0x32, 0x62, 0x37, 0x35, 0x39, 0x61, 0x39, 0x65, 0x37, 0x61, 0x31, 0x33, 0x35, 0x38, 0x35, 0x39, 0x62, 0x64, 0x39, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x31, 0x64, 0x66, 0x38, 0x61, 0x37, 0x36, 0x66, 0x34, 0x38, 0x66, 0x36, 0x62, 0x35, 0x34, 0x62, 0x63, 0x66, 0x39, 0x63, 0x61, 0x66, 0x35, 0x36, 0x66, 0x30, 0x65, 0x65, 0x31, 0x63, 0x66, 0x35, 0x37, 0x61, 0x62, 0x33, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x64, 0x38, 0x37, 0x38, 0x36, 0x36, 0x35, 0x36, 0x38, 0x64, 0x64, 0x38, 0x31, 0x61, 0x64, 0x34, 0x37, 0x64, 0x39, 0x64, 0x33, 0x61, 0x64, 0x30, 0x38, 0x34, 0x36, 0x65, 0x35, 0x61, 0x36, 0x35, 0x35, 0x30, 0x37, 0x33, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x36, 0x36, 0x36, 0x31, 0x30, 0x39, 0x30, 0x31, 0x61, 0x61, 0x63, 0x65, 0x33, 0x38, 0x62, 0x38, 0x33, 0x32, 0x34, 0x34, 0x66, 0x33, 0x61, 0x39, 0x63, 0x38, 0x33, 0x31, 0x33, 0x30, 0x36, 0x61, 0x36, 0x37, 0x62, 0x39, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x32, 0x35, 0x37, 0x61, 0x64, 0x34, 0x61, 0x35, 0x35, 0x31, 0x30, 0x35, 0x65, 0x61, 0x33, 0x62, 0x35, 0x38, 0x65, 0x64, 0x33, 0x37, 0x34, 0x62, 0x31, 0x39, 0x38, 0x64, 0x61, 0x32, 0x36, 0x36, 0x63, 0x38, 0x35, 0x66, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x34, 0x66, 0x31, 0x31, 0x33, 0x38, 0x66, 0x31, 0x62, 0x64, 0x36, 0x62, 0x66, 0x35, 0x62, 0x36, 0x64, 0x34, 0x38, 0x35, 0x63, 0x63, 0x65, 0x34, 0x63, 0x31, 0x30, 0x31, 0x37, 0x66, 0x63, 0x62, 0x38, 0x35, 0x66, 0x30, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x33, 0x34, 0x62, 0x65, 0x63, 0x61, 0x66, 0x37, 0x31, 0x66, 0x32, 0x32, 0x35, 0x66, 0x38, 0x62, 0x34, 0x61, 0x34, 0x62, 0x66, 0x37, 0x62, 0x31, 0x39, 0x37, 0x66, 0x34, 0x61, 0x63, 0x39, 0x36, 0x33, 0x30, 0x33, 0x34, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x32, 0x62, 0x66, 0x34, 0x62, 0x61, 0x38, 0x65, 0x35, 0x65, 0x66, 0x31, 0x38, 0x64, 0x33, 0x37, 0x64, 0x65, 0x36, 0x64, 0x36, 0x61, 0x64, 0x36, 0x33, 0x36, 0x63, 0x34, 0x63, 0x61, 0x65, 0x34, 0x38, 0x39, 0x64, 0x30, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x37, 0x38, 0x61, 0x39, 0x37, 0x35, 0x62, 0x37, 0x64, 0x62, 0x35, 0x65, 0x34, 0x64, 0x38, 0x65, 0x32, 0x38, 0x38, 0x34, 0x35, 0x63, 0x66, 0x62, 0x65, 0x37, 0x65, 0x33, 0x31, 0x34, 0x30, 0x31, 0x62, 0x65, 0x30, 0x64, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x61, 0x61, 0x35, 0x32, 0x63, 0x62, 0x30, 0x62, 0x35, 0x35, 0x34, 0x37, 0x32, 0x33, 0x65, 0x37, 0x30, 0x36, 0x30, 0x66, 0x32, 0x31, 0x66, 0x33, 0x32, 0x37, 0x62, 0x30, 0x61, 0x36, 0x38, 0x33, 0x31, 0x35, 0x66, 0x65, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x65, 0x32, 0x38, 0x39, 0x37, 0x33, 0x62, 0x38, 0x36, 0x30, 0x63, 0x35, 0x36, 0x37, 0x34, 0x30, 0x32, 0x38, 0x30, 0x30, 0x66, 0x62, 0x62, 0x36, 0x33, 0x63, 0x65, 0x33, 0x39, 0x61, 0x30, 0x34, 0x38, 0x61, 0x33, 0x64, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x63, 0x35, 0x61, 0x63, 0x61, 0x64, 0x30, 0x30, 0x30, 0x62, 0x38, 0x38, 0x37, 0x37, 0x32, 0x31, 0x34, 0x63, 0x62, 0x31, 0x61, 0x65, 0x30, 0x30, 0x65, 0x61, 0x63, 0x39, 0x61, 0x33, 0x37, 0x64, 0x35, 0x39, 0x61, 0x30, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x32, 0x32, 0x36, 0x65, 0x30, 0x61, 0x64, 0x38, 0x64, 0x36, 0x32, 0x32, 0x37, 0x37, 0x62, 0x31, 0x36, 0x32, 0x36, 0x32, 0x31, 0x63, 0x36, 0x32, 0x63, 0x39, 0x32, 0x38, 0x65, 0x39, 0x36, 0x65, 0x30, 0x62, 0x39, 0x61, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x39, 0x61, 0x62, 0x66, 0x32, 0x64, 0x61, 0x34, 0x64, 0x35, 0x38, 0x37, 0x31, 0x36, 0x66, 0x64, 0x39, 0x37, 0x33, 0x61, 0x30, 0x64, 0x31, 0x33, 0x61, 0x37, 0x35, 0x66, 0x35, 0x33, 0x30, 0x31, 0x35, 0x30, 0x32, 0x36, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x64, 0x38, 0x31, 0x64, 0x35, 0x32, 0x36, 0x63, 0x31, 0x39, 0x35, 0x65, 0x33, 0x66, 0x31, 0x30, 0x62, 0x35, 0x63, 0x36, 0x64, 0x62, 0x35, 0x32, 0x62, 0x35, 0x65, 0x35, 0x39, 0x61, 0x66, 0x62, 0x65, 0x30, 0x61, 0x39, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x39, 0x30, 0x38, 0x37, 0x61, 0x63, 0x30, 0x66, 0x35, 0x61, 0x39, 0x37, 0x63, 0x36, 0x66, 0x61, 0x64, 0x30, 0x32, 0x31, 0x35, 0x33, 0x38, 0x62, 0x66, 0x31, 0x64, 0x36, 0x63, 0x64, 0x61, 0x31, 0x38, 0x65, 0x30, 0x64, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x36, 0x35, 0x61, 0x66, 0x38, 0x33, 0x37, 0x65, 0x66, 0x33, 0x62, 0x30, 0x62, 0x64, 0x34, 0x65, 0x32, 0x62, 0x32, 0x33, 0x35, 0x36, 0x38, 0x64, 0x35, 0x30, 0x32, 0x33, 0x63, 0x64, 0x33, 0x34, 0x62, 0x31, 0x36, 0x34, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x33, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x37, 0x64, 0x36, 0x35, 0x39, 0x32, 0x61, 0x33, 0x31, 0x35, 0x38, 0x39, 0x61, 0x63, 0x63, 0x33, 0x31, 0x62, 0x39, 0x39, 0x30, 0x31, 0x66, 0x62, 0x65, 0x62, 0x33, 0x63, 0x63, 0x33, 0x64, 0x36, 0x35, 0x62, 0x33, 0x32, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x32, 0x30, 0x37, 0x35, 0x31, 0x37, 0x34, 0x32, 0x32, 0x63, 0x63, 0x30, 0x64, 0x36, 0x30, 0x64, 0x65, 0x37, 0x63, 0x32, 0x33, 0x37, 0x30, 0x39, 0x37, 0x61, 0x34, 0x64, 0x34, 0x66, 0x63, 0x65, 0x32, 0x30, 0x39, 0x34, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x62, 0x38, 0x62, 0x34, 0x34, 0x36, 0x64, 0x65, 0x62, 0x64, 0x31, 0x39, 0x34, 0x37, 0x39, 0x35, 0x35, 0x64, 0x64, 0x30, 0x38, 0x34, 0x66, 0x32, 0x63, 0x35, 0x34, 0x34, 0x39, 0x33, 0x33, 0x33, 0x34, 0x36, 0x64, 0x33, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x34, 0x31, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x37, 0x61, 0x30, 0x33, 0x63, 0x66, 0x30, 0x38, 0x34, 0x32, 0x64, 0x62, 0x64, 0x65, 0x62, 0x30, 0x36, 0x31, 0x38, 0x66, 0x62, 0x35, 0x38, 0x37, 0x63, 0x61, 0x36, 0x39, 0x31, 0x38, 0x39, 0x65, 0x63, 0x39, 0x32, 0x66, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x36, 0x30, 0x33, 0x61, 0x65, 0x63, 0x31, 0x37, 0x35, 0x39, 0x65, 0x61, 0x35, 0x66, 0x30, 0x37, 0x63, 0x37, 0x66, 0x38, 0x64, 0x34, 0x31, 0x61, 0x31, 0x34, 0x32, 0x38, 0x66, 0x62, 0x62, 0x61, 0x66, 0x39, 0x65, 0x37, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x61, 0x32, 0x34, 0x34, 0x36, 0x37, 0x32, 0x38, 0x39, 0x35, 0x34, 0x38, 0x30, 0x66, 0x34, 0x61, 0x32, 0x62, 0x31, 0x63, 0x64, 0x66, 0x37, 0x64, 0x61, 0x35, 0x65, 0x35, 0x61, 0x32, 0x34, 0x32, 0x65, 0x63, 0x34, 0x64, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x62, 0x34, 0x63, 0x37, 0x64, 0x35, 0x62, 0x37, 0x39, 0x37, 0x65, 0x39, 0x32, 0x39, 0x36, 0x65, 0x36, 0x33, 0x38, 0x32, 0x66, 0x32, 0x30, 0x33, 0x36, 0x39, 0x33, 0x64, 0x62, 0x34, 0x30, 0x39, 0x34, 0x34, 0x39, 0x64, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x65, 0x38, 0x32, 0x64, 0x61, 0x62, 0x39, 0x32, 0x61, 0x36, 0x36, 0x33, 0x38, 0x39, 0x65, 0x65, 0x61, 0x31, 0x61, 0x62, 0x62, 0x39, 0x30, 0x31, 0x64, 0x31, 0x64, 0x35, 0x37, 0x66, 0x35, 0x61, 0x37, 0x63, 0x63, 0x61, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x62, 0x63, 0x34, 0x30, 0x32, 0x31, 0x35, 0x61, 0x62, 0x62, 0x64, 0x39, 0x61, 0x65, 0x35, 0x64, 0x32, 0x38, 0x30, 0x62, 0x39, 0x35, 0x62, 0x38, 0x30, 0x31, 0x30, 0x62, 0x34, 0x35, 0x31, 0x34, 0x66, 0x66, 0x31, 0x32, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x61, 0x34, 0x66, 0x61, 0x63, 0x33, 0x63, 0x34, 0x32, 0x30, 0x33, 0x39, 0x64, 0x38, 0x32, 0x38, 0x65, 0x37, 0x34, 0x32, 0x63, 0x64, 0x65, 0x30, 0x65, 0x66, 0x66, 0x66, 0x65, 0x37, 0x37, 0x34, 0x39, 0x34, 0x31, 0x62, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x31, 0x63, 0x61, 0x34, 0x32, 0x37, 0x65, 0x36, 0x31, 0x36, 0x35, 0x61, 0x36, 0x34, 0x34, 0x62, 0x61, 0x65, 0x33, 0x32, 0x36, 0x62, 0x64, 0x30, 0x39, 0x37, 0x35, 0x30, 0x61, 0x31, 0x37, 0x38, 0x63, 0x36, 0x35, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x66, 0x33, 0x33, 0x39, 0x36, 0x35, 0x35, 0x33, 0x31, 0x33, 0x38, 0x30, 0x31, 0x36, 0x33, 0x31, 0x36, 0x38, 0x66, 0x63, 0x31, 0x31, 0x66, 0x36, 0x37, 0x65, 0x38, 0x39, 0x63, 0x36, 0x66, 0x31, 0x62, 0x63, 0x31, 0x37, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x38, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x66, 0x64, 0x30, 0x32, 0x64, 0x37, 0x30, 0x34, 0x61, 0x31, 0x32, 0x61, 0x34, 0x64, 0x61, 0x63, 0x65, 0x39, 0x34, 0x37, 0x31, 0x62, 0x30, 0x36, 0x34, 0x35, 0x66, 0x39, 0x36, 0x32, 0x61, 0x38, 0x39, 0x36, 0x37, 0x31, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x35, 0x64, 0x31, 0x37, 0x31, 0x39, 0x62, 0x66, 0x30, 0x33, 0x65, 0x33, 0x66, 0x38, 0x36, 0x36, 0x33, 0x31, 0x32, 0x34, 0x37, 0x39, 0x66, 0x65, 0x33, 0x33, 0x38, 0x31, 0x31, 0x38, 0x63, 0x64, 0x33, 0x38, 0x37, 0x65, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x31, 0x35, 0x39, 0x38, 0x36, 0x36, 0x63, 0x32, 0x62, 0x63, 0x38, 0x36, 0x62, 0x62, 0x61, 0x34, 0x30, 0x66, 0x39, 0x64, 0x37, 0x33, 0x62, 0x62, 0x39, 0x39, 0x66, 0x31, 0x65, 0x65, 0x65, 0x35, 0x37, 0x62, 0x62, 0x39, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x61, 0x34, 0x36, 0x32, 0x31, 0x62, 0x36, 0x36, 0x30, 0x30, 0x34, 0x35, 0x38, 0x38, 0x65, 0x33, 0x31, 0x32, 0x30, 0x36, 0x66, 0x37, 0x31, 0x38, 0x63, 0x62, 0x30, 0x30, 0x61, 0x33, 0x31, 0x39, 0x38, 0x38, 0x39, 0x63, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x63, 0x64, 0x62, 0x63, 0x38, 0x66, 0x31, 0x64, 0x64, 0x31, 0x33, 0x61, 0x66, 0x35, 0x37, 0x38, 0x64, 0x34, 0x61, 0x34, 0x37, 0x37, 0x34, 0x61, 0x36, 0x32, 0x31, 0x38, 0x32, 0x62, 0x65, 0x64, 0x66, 0x39, 0x66, 0x39, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x62, 0x65, 0x30, 0x36, 0x36, 0x64, 0x65, 0x35, 0x37, 0x32, 0x33, 0x36, 0x64, 0x63, 0x38, 0x33, 0x30, 0x37, 0x32, 0x35, 0x64, 0x33, 0x32, 0x61, 0x30, 0x32, 0x61, 0x65, 0x66, 0x39, 0x32, 0x34, 0x36, 0x63, 0x36, 0x63, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x63, 0x66, 0x61, 0x64, 0x37, 0x36, 0x30, 0x39, 0x31, 0x33, 0x64, 0x33, 0x63, 0x33, 0x32, 0x32, 0x66, 0x63, 0x63, 0x37, 0x37, 0x62, 0x34, 0x39, 0x63, 0x32, 0x61, 0x65, 0x33, 0x39, 0x30, 0x37, 0x65, 0x37, 0x34, 0x66, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x62, 0x35, 0x39, 0x64, 0x33, 0x39, 0x30, 0x37, 0x30, 0x32, 0x63, 0x39, 0x63, 0x30, 0x35, 0x39, 0x64, 0x62, 0x31, 0x34, 0x38, 0x65, 0x62, 0x34, 0x66, 0x33, 0x66, 0x63, 0x66, 0x61, 0x37, 0x64, 0x30, 0x34, 0x63, 0x37, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x32, 0x64, 0x62, 0x32, 0x38, 0x63, 0x33, 0x33, 0x30, 0x39, 0x33, 0x37, 0x35, 0x65, 0x65, 0x61, 0x33, 0x63, 0x36, 0x64, 0x37, 0x32, 0x63, 0x64, 0x36, 0x64, 0x30, 0x65, 0x65, 0x63, 0x31, 0x34, 0x35, 0x61, 0x66, 0x63, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x33, 0x30, 0x36, 0x64, 0x65, 0x35, 0x31, 0x39, 0x38, 0x31, 0x65, 0x37, 0x61, 0x63, 0x61, 0x31, 0x38, 0x35, 0x36, 0x38, 0x35, 0x39, 0x62, 0x37, 0x63, 0x37, 0x37, 0x38, 0x36, 0x39, 0x36, 0x61, 0x36, 0x62, 0x36, 0x39, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x31, 0x34, 0x37, 0x39, 0x39, 0x66, 0x36, 0x64, 0x64, 0x66, 0x34, 0x64, 0x63, 0x62, 0x32, 0x39, 0x63, 0x37, 0x65, 0x65, 0x38, 0x37, 0x30, 0x65, 0x37, 0x35, 0x66, 0x39, 0x63, 0x63, 0x32, 0x64, 0x33, 0x35, 0x33, 0x32, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x38, 0x36, 0x37, 0x64, 0x32, 0x30, 0x39, 0x31, 0x36, 0x62, 0x64, 0x32, 0x65, 0x39, 0x63, 0x39, 0x65, 0x63, 0x65, 0x30, 0x38, 0x61, 0x61, 0x30, 0x34, 0x33, 0x38, 0x35, 0x64, 0x62, 0x36, 0x36, 0x37, 0x63, 0x39, 0x31, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x61, 0x38, 0x36, 0x66, 0x30, 0x31, 0x63, 0x65, 0x33, 0x66, 0x37, 0x63, 0x66, 0x64, 0x34, 0x34, 0x34, 0x31, 0x33, 0x33, 0x30, 0x65, 0x31, 0x63, 0x39, 0x62, 0x31, 0x39, 0x65, 0x31, 0x62, 0x31, 0x30, 0x36, 0x30, 0x36, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x37, 0x35, 0x39, 0x38, 0x31, 0x33, 0x61, 0x64, 0x31, 0x33, 0x38, 0x36, 0x62, 0x65, 0x64, 0x32, 0x37, 0x66, 0x66, 0x61, 0x65, 0x39, 0x65, 0x34, 0x38, 0x31, 0x35, 0x65, 0x33, 0x36, 0x33, 0x30, 0x63, 0x63, 0x61, 0x33, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x32, 0x32, 0x36, 0x30, 0x39, 0x36, 0x63, 0x31, 0x38, 0x34, 0x65, 0x62, 0x62, 0x34, 0x30, 0x31, 0x30, 0x35, 0x65, 0x30, 0x38, 0x64, 0x61, 0x63, 0x34, 0x64, 0x32, 0x32, 0x65, 0x31, 0x63, 0x32, 0x64, 0x35, 0x34, 0x64, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x36, 0x35, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x61, 0x63, 0x61, 0x64, 0x61, 0x38, 0x39, 0x38, 0x30, 0x61, 0x66, 0x66, 0x63, 0x37, 0x35, 0x30, 0x34, 0x39, 0x32, 0x31, 0x62, 0x65, 0x38, 0x34, 0x65, 0x62, 0x34, 0x39, 0x34, 0x34, 0x63, 0x38, 0x66, 0x62, 0x62, 0x32, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x32, 0x64, 0x63, 0x66, 0x64, 0x38, 0x31, 0x61, 0x64, 0x64, 0x62, 0x39, 0x37, 0x64, 0x31, 0x61, 0x30, 0x65, 0x34, 0x39, 0x32, 0x35, 0x63, 0x34, 0x62, 0x35, 0x34, 0x39, 0x38, 0x30, 0x36, 0x65, 0x39, 0x66, 0x33, 0x62, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x31, 0x34, 0x39, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x32, 0x66, 0x35, 0x32, 0x35, 0x64, 0x35, 0x35, 0x38, 0x35, 0x39, 0x62, 0x37, 0x64, 0x34, 0x65, 0x36, 0x30, 0x38, 0x64, 0x32, 0x30, 0x34, 0x38, 0x37, 0x66, 0x61, 0x61, 0x64, 0x62, 0x30, 0x30, 0x32, 0x39, 0x33, 0x31, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x37, 0x61, 0x63, 0x36, 0x38, 0x31, 0x64, 0x34, 0x35, 0x65, 0x34, 0x31, 0x38, 0x66, 0x63, 0x65, 0x38, 0x62, 0x33, 0x61, 0x31, 0x64, 0x62, 0x35, 0x62, 0x63, 0x33, 0x62, 0x65, 0x36, 0x66, 0x30, 0x36, 0x63, 0x39, 0x38, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x38, 0x36, 0x39, 0x32, 0x65, 0x65, 0x66, 0x66, 0x32, 0x61, 0x35, 0x33, 0x64, 0x36, 0x64, 0x31, 0x36, 0x38, 0x38, 0x65, 0x64, 0x35, 0x36, 0x61, 0x39, 0x64, 0x64, 0x62, 0x62, 0x64, 0x36, 0x38, 0x64, 0x61, 0x62, 0x62, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x36, 0x33, 0x33, 0x37, 0x38, 0x33, 0x33, 0x66, 0x38, 0x66, 0x36, 0x61, 0x36, 0x62, 0x66, 0x31, 0x30, 0x63, 0x61, 0x37, 0x65, 0x63, 0x32, 0x31, 0x61, 0x61, 0x38, 0x31, 0x30, 0x65, 0x64, 0x34, 0x34, 0x34, 0x66, 0x34, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x39, 0x33, 0x37, 0x37, 0x62, 0x36, 0x61, 0x64, 0x33, 0x66, 0x65, 0x31, 0x30, 0x31, 0x63, 0x39, 0x36, 0x38, 0x35, 0x62, 0x33, 0x35, 0x37, 0x36, 0x35, 0x34, 0x35, 0x63, 0x36, 0x62, 0x31, 0x36, 0x38, 0x34, 0x65, 0x37, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x30, 0x66, 0x63, 0x30, 0x38, 0x64, 0x30, 0x37, 0x39, 0x66, 0x30, 0x34, 0x37, 0x65, 0x64, 0x38, 0x64, 0x37, 0x64, 0x66, 0x37, 0x35, 0x35, 0x35, 0x31, 0x61, 0x61, 0x35, 0x33, 0x35, 0x30, 0x31, 0x66, 0x35, 0x37, 0x30, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x37, 0x38, 0x66, 0x33, 0x35, 0x31, 0x34, 0x35, 0x37, 0x64, 0x30, 0x31, 0x36, 0x66, 0x34, 0x61, 0x64, 0x32, 0x37, 0x35, 0x35, 0x65, 0x63, 0x37, 0x34, 0x32, 0x34, 0x65, 0x35, 0x63, 0x32, 0x31, 0x62, 0x61, 0x36, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x65, 0x31, 0x31, 0x61, 0x39, 0x32, 0x66, 0x61, 0x64, 0x30, 0x32, 0x34, 0x66, 0x66, 0x32, 0x62, 0x33, 0x65, 0x38, 0x37, 0x65, 0x33, 0x62, 0x35, 0x34, 0x32, 0x65, 0x36, 0x63, 0x36, 0x30, 0x64, 0x63, 0x62, 0x64, 0x39, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x62, 0x38, 0x33, 0x39, 0x61, 0x65, 0x61, 0x66, 0x32, 0x61, 0x64, 0x33, 0x37, 0x63, 0x62, 0x37, 0x38, 0x62, 0x61, 0x63, 0x62, 0x62, 0x62, 0x36, 0x33, 0x33, 0x62, 0x63, 0x63, 0x35, 0x63, 0x30, 0x39, 0x39, 0x64, 0x63, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x33, 0x31, 0x34, 0x34, 0x66, 0x30, 0x65, 0x63, 0x31, 0x34, 0x32, 0x65, 0x37, 0x37, 0x30, 0x66, 0x34, 0x38, 0x33, 0x34, 0x66, 0x65, 0x65, 0x30, 0x65, 0x65, 0x33, 0x31, 0x31, 0x38, 0x33, 0x32, 0x66, 0x33, 0x30, 0x38, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x38, 0x61, 0x36, 0x33, 0x66, 0x33, 0x66, 0x34, 0x30, 0x64, 0x65, 0x34, 0x61, 0x38, 0x38, 0x33, 0x38, 0x38, 0x62, 0x63, 0x35, 0x30, 0x32, 0x31, 0x32, 0x66, 0x65, 0x61, 0x38, 0x65, 0x30, 0x36, 0x34, 0x66, 0x62, 0x62, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x38, 0x39, 0x39, 0x62, 0x30, 0x32, 0x63, 0x62, 0x63, 0x62, 0x33, 0x39, 0x33, 0x39, 0x63, 0x64, 0x36, 0x31, 0x64, 0x65, 0x31, 0x33, 0x34, 0x32, 0x64, 0x35, 0x30, 0x34, 0x38, 0x32, 0x61, 0x62, 0x62, 0x36, 0x38, 0x35, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x64, 0x39, 0x65, 0x65, 0x64, 0x62, 0x63, 0x39, 0x30, 0x31, 0x39, 0x32, 0x36, 0x33, 0x64, 0x39, 0x64, 0x31, 0x36, 0x63, 0x63, 0x35, 0x61, 0x65, 0x30, 0x37, 0x32, 0x64, 0x31, 0x64, 0x33, 0x64, 0x64, 0x39, 0x64, 0x62, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x35, 0x63, 0x30, 0x63, 0x33, 0x39, 0x66, 0x35, 0x64, 0x35, 0x37, 0x30, 0x30, 0x62, 0x34, 0x31, 0x64, 0x33, 0x37, 0x35, 0x62, 0x33, 0x66, 0x31, 0x37, 0x38, 0x35, 0x31, 0x64, 0x63, 0x64, 0x35, 0x32, 0x34, 0x30, 0x31, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x37, 0x39, 0x63, 0x38, 0x30, 0x39, 0x37, 0x30, 0x31, 0x38, 0x32, 0x63, 0x63, 0x35, 0x62, 0x37, 0x64, 0x38, 0x32, 0x61, 0x34, 0x64, 0x66, 0x30, 0x36, 0x65, 0x61, 0x39, 0x34, 0x64, 0x62, 0x36, 0x33, 0x61, 0x32, 0x35, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x37, 0x34, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x38, 0x38, 0x62, 0x35, 0x64, 0x66, 0x65, 0x63, 0x64, 0x32, 0x63, 0x35, 0x65, 0x34, 0x62, 0x35, 0x39, 0x36, 0x35, 0x37, 0x37, 0x63, 0x36, 0x34, 0x32, 0x35, 0x35, 0x36, 0x64, 0x62, 0x66, 0x65, 0x32, 0x37, 0x37, 0x38, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x65, 0x32, 0x38, 0x33, 0x33, 0x37, 0x65, 0x36, 0x33, 0x35, 0x37, 0x31, 0x39, 0x33, 0x64, 0x39, 0x65, 0x32, 0x63, 0x62, 0x32, 0x33, 0x36, 0x62, 0x30, 0x31, 0x62, 0x65, 0x34, 0x34, 0x62, 0x38, 0x31, 0x34, 0x32, 0x37, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x62, 0x61, 0x34, 0x62, 0x62, 0x38, 0x37, 0x31, 0x34, 0x30, 0x30, 0x32, 0x32, 0x63, 0x32, 0x31, 0x34, 0x61, 0x36, 0x66, 0x61, 0x63, 0x34, 0x32, 0x64, 0x62, 0x35, 0x61, 0x31, 0x36, 0x64, 0x64, 0x39, 0x35, 0x34, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x63, 0x39, 0x32, 0x36, 0x30, 0x39, 0x33, 0x65, 0x39, 0x62, 0x38, 0x39, 0x32, 0x37, 0x39, 0x33, 0x33, 0x38, 0x31, 0x30, 0x64, 0x39, 0x38, 0x32, 0x32, 0x32, 0x64, 0x36, 0x32, 0x65, 0x32, 0x62, 0x38, 0x32, 0x30, 0x36, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x37, 0x33, 0x34, 0x36, 0x37, 0x36, 0x36, 0x65, 0x31, 0x61, 0x36, 0x37, 0x36, 0x64, 0x30, 0x64, 0x30, 0x36, 0x65, 0x63, 0x38, 0x32, 0x31, 0x38, 0x36, 0x37, 0x61, 0x32, 0x37, 0x36, 0x61, 0x30, 0x38, 0x33, 0x62, 0x66, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x32, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x35, 0x35, 0x38, 0x32, 0x32, 0x36, 0x62, 0x33, 0x38, 0x34, 0x36, 0x32, 0x36, 0x63, 0x61, 0x64, 0x34, 0x38, 0x65, 0x30, 0x39, 0x64, 0x39, 0x36, 0x36, 0x62, 0x66, 0x31, 0x33, 0x39, 0x35, 0x65, 0x65, 0x37, 0x65, 0x61, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x66, 0x36, 0x39, 0x33, 0x66, 0x38, 0x33, 0x33, 0x63, 0x33, 0x66, 0x65, 0x34, 0x37, 0x31, 0x37, 0x35, 0x33, 0x31, 0x38, 0x34, 0x37, 0x38, 0x38, 0x65, 0x62, 0x34, 0x62, 0x66, 0x65, 0x34, 0x61, 0x64, 0x63, 0x33, 0x66, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x37, 0x34, 0x32, 0x39, 0x39, 0x64, 0x30, 0x65, 0x65, 0x30, 0x39, 0x30, 0x64, 0x63, 0x39, 0x30, 0x37, 0x38, 0x39, 0x61, 0x31, 0x34, 0x38, 0x36, 0x34, 0x38, 0x39, 0x63, 0x33, 0x64, 0x30, 0x64, 0x36, 0x34, 0x35, 0x65, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x31, 0x37, 0x38, 0x61, 0x64, 0x34, 0x37, 0x33, 0x38, 0x33, 0x63, 0x33, 0x31, 0x63, 0x38, 0x31, 0x33, 0x34, 0x61, 0x31, 0x39, 0x34, 0x31, 0x63, 0x62, 0x63, 0x64, 0x34, 0x37, 0x34, 0x64, 0x30, 0x36, 0x32, 0x34, 0x34, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x39, 0x64, 0x36, 0x38, 0x31, 0x63, 0x36, 0x31, 0x37, 0x64, 0x61, 0x31, 0x36, 0x66, 0x32, 0x31, 0x62, 0x63, 0x61, 0x63, 0x61, 0x31, 0x30, 0x31, 0x65, 0x64, 0x31, 0x36, 0x65, 0x64, 0x30, 0x31, 0x35, 0x61, 0x62, 0x36, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x32, 0x30, 0x63, 0x30, 0x38, 0x30, 0x36, 0x30, 0x36, 0x61, 0x37, 0x39, 0x63, 0x37, 0x33, 0x62, 0x64, 0x38, 0x65, 0x37, 0x35, 0x62, 0x31, 0x31, 0x37, 0x31, 0x37, 0x61, 0x34, 0x65, 0x38, 0x64, 0x62, 0x33, 0x66, 0x31, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x35, 0x32, 0x31, 0x38, 0x66, 0x33, 0x34, 0x32, 0x66, 0x38, 0x30, 0x31, 0x32, 0x65, 0x64, 0x61, 0x39, 0x66, 0x32, 0x37, 0x34, 0x65, 0x36, 0x33, 0x63, 0x65, 0x32, 0x31, 0x35, 0x32, 0x62, 0x32, 0x64, 0x63, 0x66, 0x64, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x30, 0x62, 0x36, 0x31, 0x65, 0x34, 0x32, 0x66, 0x33, 0x39, 0x34, 0x32, 0x36, 0x64, 0x32, 0x34, 0x30, 0x38, 0x64, 0x34, 0x30, 0x38, 0x35, 0x32, 0x62, 0x39, 0x65, 0x33, 0x34, 0x61, 0x62, 0x35, 0x65, 0x62, 0x65, 0x62, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x61, 0x66, 0x63, 0x32, 0x32, 0x35, 0x66, 0x34, 0x66, 0x61, 0x33, 0x30, 0x37, 0x64, 0x65, 0x34, 0x38, 0x34, 0x35, 0x35, 0x32, 0x62, 0x62, 0x65, 0x31, 0x64, 0x39, 0x64, 0x33, 0x66, 0x31, 0x35, 0x30, 0x37, 0x34, 0x63, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x37, 0x38, 0x33, 0x65, 0x35, 0x32, 0x32, 0x61, 0x62, 0x37, 0x64, 0x66, 0x30, 0x61, 0x63, 0x61, 0x61, 0x63, 0x39, 0x65, 0x65, 0x65, 0x64, 0x33, 0x35, 0x39, 0x33, 0x30, 0x33, 0x39, 0x65, 0x35, 0x61, 0x63, 0x37, 0x35, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x33, 0x34, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x37, 0x62, 0x66, 0x36, 0x33, 0x37, 0x33, 0x66, 0x37, 0x37, 0x31, 0x61, 0x34, 0x36, 0x30, 0x31, 0x37, 0x36, 0x32, 0x63, 0x34, 0x64, 0x61, 0x65, 0x35, 0x66, 0x62, 0x62, 0x66, 0x34, 0x66, 0x65, 0x64, 0x64, 0x39, 0x63, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x38, 0x37, 0x39, 0x37, 0x36, 0x39, 0x30, 0x61, 0x62, 0x37, 0x37, 0x62, 0x35, 0x34, 0x37, 0x30, 0x62, 0x66, 0x37, 0x63, 0x30, 0x63, 0x31, 0x62, 0x62, 0x61, 0x36, 0x31, 0x32, 0x35, 0x30, 0x38, 0x65, 0x31, 0x61, 0x63, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x32, 0x61, 0x62, 0x36, 0x62, 0x37, 0x34, 0x63, 0x37, 0x61, 0x66, 0x31, 0x64, 0x39, 0x34, 0x37, 0x36, 0x62, 0x62, 0x35, 0x62, 0x63, 0x62, 0x34, 0x35, 0x32, 0x34, 0x37, 0x39, 0x37, 0x62, 0x65, 0x64, 0x63, 0x33, 0x35, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x33, 0x65, 0x31, 0x34, 0x30, 0x64, 0x63, 0x38, 0x31, 0x31, 0x62, 0x31, 0x38, 0x36, 0x64, 0x65, 0x65, 0x35, 0x64, 0x36, 0x63, 0x38, 0x38, 0x62, 0x66, 0x36, 0x38, 0x65, 0x39, 0x30, 0x62, 0x38, 0x65, 0x30, 0x39, 0x36, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x38, 0x31, 0x36, 0x38, 0x66, 0x62, 0x66, 0x32, 0x32, 0x35, 0x65, 0x37, 0x38, 0x36, 0x34, 0x35, 0x39, 0x63, 0x61, 0x36, 0x62, 0x62, 0x31, 0x38, 0x64, 0x39, 0x36, 0x33, 0x64, 0x32, 0x36, 0x62, 0x35, 0x30, 0x35, 0x33, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x66, 0x66, 0x33, 0x65, 0x64, 0x65, 0x38, 0x63, 0x61, 0x64, 0x62, 0x35, 0x63, 0x33, 0x37, 0x62, 0x34, 0x38, 0x63, 0x62, 0x31, 0x34, 0x35, 0x38, 0x30, 0x66, 0x62, 0x36, 0x35, 0x65, 0x32, 0x33, 0x30, 0x39, 0x30, 0x61, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x38, 0x32, 0x64, 0x32, 0x35, 0x35, 0x65, 0x64, 0x65, 0x35, 0x36, 0x62, 0x30, 0x34, 0x63, 0x33, 0x65, 0x38, 0x64, 0x66, 0x31, 0x35, 0x31, 0x66, 0x35, 0x36, 0x65, 0x39, 0x63, 0x61, 0x36, 0x32, 0x61, 0x61, 0x61, 0x38, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x30, 0x38, 0x38, 0x30, 0x61, 0x33, 0x34, 0x35, 0x39, 0x36, 0x32, 0x33, 0x30, 0x37, 0x32, 0x30, 0x66, 0x30, 0x35, 0x61, 0x63, 0x38, 0x66, 0x30, 0x36, 0x35, 0x61, 0x66, 0x38, 0x36, 0x38, 0x31, 0x64, 0x63, 0x62, 0x36, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x37, 0x34, 0x66, 0x32, 0x38, 0x63, 0x38, 0x61, 0x66, 0x64, 0x30, 0x37, 0x33, 0x66, 0x38, 0x62, 0x37, 0x39, 0x39, 0x36, 0x39, 0x31, 0x62, 0x32, 0x66, 0x30, 0x35, 0x38, 0x34, 0x64, 0x66, 0x39, 0x34, 0x32, 0x65, 0x38, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x34, 0x36, 0x64, 0x66, 0x39, 0x38, 0x62, 0x34, 0x39, 0x34, 0x34, 0x32, 0x37, 0x34, 0x36, 0x62, 0x36, 0x31, 0x35, 0x32, 0x35, 0x63, 0x38, 0x31, 0x61, 0x33, 0x62, 0x30, 0x34, 0x62, 0x61, 0x33, 0x31, 0x30, 0x36, 0x32, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x35, 0x63, 0x31, 0x63, 0x38, 0x64, 0x66, 0x62, 0x65, 0x31, 0x65, 0x30, 0x32, 0x63, 0x61, 0x63, 0x62, 0x63, 0x61, 0x36, 0x30, 0x66, 0x64, 0x62, 0x64, 0x64, 0x34, 0x30, 0x35, 0x62, 0x30, 0x39, 0x66, 0x30, 0x62, 0x37, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x65, 0x62, 0x61, 0x65, 0x64, 0x32, 0x37, 0x65, 0x64, 0x62, 0x39, 0x64, 0x63, 0x63, 0x31, 0x39, 0x35, 0x37, 0x61, 0x65, 0x65, 0x35, 0x66, 0x34, 0x35, 0x32, 0x61, 0x63, 0x32, 0x31, 0x30, 0x35, 0x61, 0x36, 0x35, 0x63, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x35, 0x33, 0x31, 0x39, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x37, 0x39, 0x65, 0x31, 0x62, 0x31, 0x32, 0x36, 0x35, 0x66, 0x35, 0x30, 0x65, 0x38, 0x63, 0x38, 0x61, 0x39, 0x38, 0x65, 0x63, 0x30, 0x63, 0x37, 0x38, 0x31, 0x35, 0x65, 0x62, 0x33, 0x61, 0x65, 0x61, 0x63, 0x39, 0x65, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x37, 0x65, 0x62, 0x61, 0x35, 0x36, 0x37, 0x34, 0x38, 0x61, 0x35, 0x39, 0x30, 0x34, 0x33, 0x35, 0x30, 0x64, 0x32, 0x63, 0x61, 0x32, 0x61, 0x35, 0x63, 0x65, 0x39, 0x63, 0x61, 0x30, 0x30, 0x62, 0x36, 0x37, 0x30, 0x61, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x65, 0x65, 0x30, 0x63, 0x63, 0x61, 0x33, 0x62, 0x63, 0x62, 0x31, 0x30, 0x63, 0x64, 0x33, 0x65, 0x39, 0x38, 0x33, 0x37, 0x32, 0x32, 0x63, 0x65, 0x64, 0x38, 0x34, 0x39, 0x33, 0x64, 0x39, 0x32, 0x36, 0x63, 0x30, 0x38, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x64, 0x35, 0x34, 0x31, 0x63, 0x38, 0x34, 0x30, 0x63, 0x65, 0x34, 0x33, 0x63, 0x65, 0x66, 0x62, 0x61, 0x66, 0x36, 0x64, 0x31, 0x39, 0x61, 0x66, 0x36, 0x62, 0x39, 0x38, 0x35, 0x39, 0x62, 0x35, 0x37, 0x33, 0x63, 0x31, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x35, 0x31, 0x62, 0x30, 0x31, 0x30, 0x66, 0x36, 0x33, 0x33, 0x63, 0x34, 0x30, 0x61, 0x66, 0x31, 0x61, 0x38, 0x66, 0x30, 0x36, 0x61, 0x37, 0x33, 0x65, 0x62, 0x62, 0x61, 0x61, 0x62, 0x36, 0x35, 0x30, 0x37, 0x37, 0x61, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x61, 0x61, 0x36, 0x39, 0x33, 0x36, 0x35, 0x35, 0x35, 0x35, 0x62, 0x37, 0x33, 0x66, 0x32, 0x38, 0x32, 0x33, 0x33, 0x33, 0x64, 0x31, 0x65, 0x33, 0x30, 0x63, 0x31, 0x62, 0x62, 0x64, 0x30, 0x37, 0x32, 0x38, 0x35, 0x34, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x62, 0x31, 0x63, 0x38, 0x33, 0x65, 0x36, 0x33, 0x32, 0x30, 0x33, 0x66, 0x39, 0x35, 0x34, 0x37, 0x32, 0x36, 0x33, 0x65, 0x66, 0x36, 0x32, 0x38, 0x32, 0x65, 0x37, 0x64, 0x61, 0x33, 0x33, 0x62, 0x36, 0x65, 0x64, 0x36, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x30, 0x36, 0x66, 0x35, 0x66, 0x61, 0x36, 0x64, 0x31, 0x32, 0x31, 0x34, 0x65, 0x63, 0x34, 0x33, 0x39, 0x36, 0x37, 0x64, 0x31, 0x62, 0x64, 0x34, 0x64, 0x64, 0x65, 0x37, 0x34, 0x61, 0x62, 0x38, 0x31, 0x34, 0x61, 0x39, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x31, 0x31, 0x37, 0x33, 0x36, 0x30, 0x31, 0x39, 0x34, 0x37, 0x63, 0x32, 0x30, 0x38, 0x34, 0x61, 0x36, 0x32, 0x64, 0x36, 0x33, 0x39, 0x35, 0x32, 0x37, 0x65, 0x39, 0x36, 0x31, 0x35, 0x31, 0x32, 0x35, 0x37, 0x39, 0x61, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x33, 0x38, 0x31, 0x31, 0x32, 0x32, 0x62, 0x61, 0x64, 0x61, 0x37, 0x39, 0x31, 0x61, 0x37, 0x61, 0x62, 0x31, 0x66, 0x36, 0x30, 0x33, 0x37, 0x64, 0x61, 0x63, 0x38, 0x30, 0x34, 0x33, 0x32, 0x37, 0x35, 0x33, 0x62, 0x61, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x36, 0x36, 0x66, 0x33, 0x34, 0x66, 0x66, 0x31, 0x36, 0x66, 0x33, 0x63, 0x66, 0x63, 0x63, 0x39, 0x37, 0x33, 0x32, 0x31, 0x37, 0x32, 0x31, 0x66, 0x34, 0x33, 0x64, 0x64, 0x66, 0x35, 0x61, 0x33, 0x38, 0x62, 0x30, 0x63, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x38, 0x35, 0x61, 0x38, 0x66, 0x31, 0x38, 0x63, 0x33, 0x38, 0x62, 0x39, 0x62, 0x63, 0x34, 0x66, 0x66, 0x62, 0x39, 0x62, 0x38, 0x66, 0x61, 0x38, 0x63, 0x37, 0x37, 0x32, 0x37, 0x62, 0x64, 0x36, 0x34, 0x32, 0x65, 0x65, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x62, 0x64, 0x34, 0x66, 0x32, 0x30, 0x35, 0x64, 0x65, 0x37, 0x39, 0x39, 0x62, 0x36, 0x34, 0x62, 0x33, 0x35, 0x36, 0x34, 0x62, 0x32, 0x35, 0x36, 0x64, 0x34, 0x32, 0x61, 0x37, 0x31, 0x31, 0x64, 0x33, 0x37, 0x65, 0x66, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x37, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x66, 0x61, 0x31, 0x37, 0x63, 0x30, 0x66, 0x62, 0x35, 0x30, 0x36, 0x63, 0x65, 0x34, 0x39, 0x34, 0x30, 0x30, 0x38, 0x62, 0x39, 0x35, 0x35, 0x37, 0x38, 0x34, 0x31, 0x63, 0x33, 0x66, 0x36, 0x34, 0x31, 0x62, 0x38, 0x63, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x61, 0x63, 0x61, 0x37, 0x34, 0x38, 0x66, 0x39, 0x64, 0x33, 0x31, 0x32, 0x65, 0x63, 0x37, 0x34, 0x37, 0x66, 0x38, 0x62, 0x36, 0x35, 0x37, 0x38, 0x31, 0x34, 0x32, 0x36, 0x39, 0x34, 0x63, 0x37, 0x65, 0x39, 0x66, 0x33, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x30, 0x63, 0x36, 0x38, 0x61, 0x34, 0x30, 0x39, 0x38, 0x38, 0x31, 0x35, 0x34, 0x64, 0x32, 0x33, 0x39, 0x33, 0x66, 0x66, 0x66, 0x38, 0x64, 0x61, 0x37, 0x63, 0x63, 0x64, 0x61, 0x39, 0x39, 0x36, 0x31, 0x34, 0x66, 0x37, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x39, 0x37, 0x39, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x35, 0x64, 0x31, 0x35, 0x65, 0x32, 0x64, 0x33, 0x33, 0x64, 0x38, 0x62, 0x34, 0x66, 0x61, 0x37, 0x64, 0x62, 0x61, 0x38, 0x62, 0x39, 0x65, 0x36, 0x30, 0x37, 0x66, 0x30, 0x34, 0x61, 0x32, 0x36, 0x31, 0x65, 0x33, 0x34, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x31, 0x36, 0x64, 0x34, 0x34, 0x38, 0x39, 0x38, 0x35, 0x66, 0x35, 0x64, 0x33, 0x32, 0x61, 0x65, 0x66, 0x61, 0x38, 0x62, 0x39, 0x33, 0x61, 0x39, 0x39, 0x33, 0x65, 0x30, 0x39, 0x34, 0x62, 0x64, 0x38, 0x35, 0x34, 0x39, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x62, 0x39, 0x36, 0x35, 0x35, 0x63, 0x66, 0x62, 0x32, 0x61, 0x33, 0x36, 0x65, 0x61, 0x37, 0x63, 0x36, 0x33, 0x37, 0x61, 0x37, 0x62, 0x38, 0x35, 0x39, 0x62, 0x34, 0x61, 0x33, 0x31, 0x35, 0x34, 0x65, 0x32, 0x36, 0x65, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x39, 0x34, 0x39, 0x64, 0x62, 0x61, 0x35, 0x35, 0x39, 0x61, 0x36, 0x33, 0x62, 0x66, 0x63, 0x38, 0x34, 0x35, 0x64, 0x65, 0x64, 0x30, 0x36, 0x65, 0x39, 0x66, 0x32, 0x64, 0x39, 0x62, 0x37, 0x66, 0x31, 0x31, 0x65, 0x66, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x37, 0x35, 0x36, 0x33, 0x64, 0x38, 0x61, 0x38, 0x30, 0x66, 0x64, 0x35, 0x61, 0x35, 0x33, 0x37, 0x62, 0x30, 0x65, 0x36, 0x36, 0x64, 0x32, 0x30, 0x61, 0x30, 0x32, 0x35, 0x32, 0x35, 0x64, 0x35, 0x64, 0x38, 0x38, 0x36, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x38, 0x33, 0x65, 0x62, 0x65, 0x65, 0x34, 0x66, 0x63, 0x62, 0x34, 0x32, 0x63, 0x32, 0x32, 0x30, 0x65, 0x34, 0x37, 0x37, 0x37, 0x34, 0x66, 0x35, 0x39, 0x64, 0x36, 0x63, 0x35, 0x34, 0x64, 0x35, 0x65, 0x33, 0x32, 0x61, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x34, 0x32, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x65, 0x35, 0x64, 0x37, 0x37, 0x33, 0x32, 0x30, 0x33, 0x30, 0x34, 0x63, 0x32, 0x30, 0x31, 0x63, 0x31, 0x65, 0x35, 0x33, 0x62, 0x32, 0x36, 0x31, 0x61, 0x31, 0x32, 0x33, 0x64, 0x30, 0x61, 0x31, 0x30, 0x36, 0x33, 0x65, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x31, 0x34, 0x62, 0x35, 0x36, 0x36, 0x32, 0x33, 0x34, 0x61, 0x62, 0x65, 0x65, 0x37, 0x33, 0x30, 0x34, 0x32, 0x63, 0x33, 0x31, 0x64, 0x32, 0x31, 0x37, 0x31, 0x37, 0x31, 0x38, 0x32, 0x63, 0x62, 0x61, 0x31, 0x34, 0x61, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x61, 0x36, 0x31, 0x37, 0x36, 0x39, 0x35, 0x30, 0x30, 0x39, 0x63, 0x63, 0x35, 0x37, 0x64, 0x32, 0x36, 0x61, 0x64, 0x34, 0x39, 0x30, 0x62, 0x33, 0x32, 0x61, 0x35, 0x64, 0x66, 0x62, 0x65, 0x62, 0x39, 0x33, 0x34, 0x65, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x32, 0x36, 0x62, 0x38, 0x38, 0x64, 0x65, 0x38, 0x30, 0x36, 0x31, 0x38, 0x34, 0x34, 0x35, 0x34, 0x63, 0x34, 0x30, 0x62, 0x32, 0x37, 0x66, 0x33, 0x30, 0x39, 0x64, 0x39, 0x64, 0x64, 0x36, 0x64, 0x63, 0x66, 0x62, 0x39, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x65, 0x36, 0x61, 0x35, 0x34, 0x62, 0x32, 0x64, 0x35, 0x66, 0x36, 0x37, 0x61, 0x32, 0x34, 0x61, 0x34, 0x38, 0x37, 0x35, 0x61, 0x66, 0x37, 0x35, 0x31, 0x30, 0x37, 0x63, 0x61, 0x37, 0x65, 0x61, 0x39, 0x66, 0x64, 0x32, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x62, 0x35, 0x38, 0x65, 0x34, 0x30, 0x36, 0x65, 0x32, 0x30, 0x32, 0x64, 0x66, 0x39, 0x62, 0x63, 0x37, 0x30, 0x33, 0x63, 0x34, 0x38, 0x30, 0x62, 0x64, 0x38, 0x65, 0x64, 0x32, 0x34, 0x38, 0x64, 0x35, 0x32, 0x61, 0x30, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x37, 0x37, 0x33, 0x36, 0x31, 0x61, 0x33, 0x64, 0x64, 0x38, 0x61, 0x62, 0x36, 0x32, 0x65, 0x35, 0x66, 0x31, 0x62, 0x39, 0x62, 0x30, 0x34, 0x37, 0x35, 0x36, 0x38, 0x63, 0x63, 0x30, 0x62, 0x35, 0x35, 0x35, 0x37, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x61, 0x39, 0x33, 0x62, 0x35, 0x62, 0x61, 0x34, 0x31, 0x62, 0x66, 0x38, 0x38, 0x37, 0x32, 0x30, 0x65, 0x34, 0x31, 0x35, 0x37, 0x39, 0x30, 0x63, 0x64, 0x63, 0x30, 0x62, 0x36, 0x37, 0x62, 0x34, 0x61, 0x66, 0x33, 0x34, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x31, 0x63, 0x63, 0x35, 0x61, 0x63, 0x31, 0x31, 0x31, 0x63, 0x34, 0x39, 0x62, 0x66, 0x63, 0x66, 0x64, 0x38, 0x34, 0x38, 0x66, 0x33, 0x37, 0x64, 0x64, 0x37, 0x36, 0x38, 0x61, 0x61, 0x36, 0x35, 0x63, 0x38, 0x38, 0x38, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x32, 0x31, 0x34, 0x33, 0x37, 0x38, 0x62, 0x35, 0x34, 0x30, 0x30, 0x34, 0x30, 0x35, 0x36, 0x61, 0x37, 0x63, 0x63, 0x30, 0x38, 0x63, 0x38, 0x39, 0x31, 0x33, 0x32, 0x37, 0x37, 0x39, 0x38, 0x61, 0x63, 0x36, 0x62, 0x32, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x38, 0x30, 0x64, 0x38, 0x36, 0x35, 0x62, 0x38, 0x35, 0x63, 0x33, 0x34, 0x64, 0x32, 0x65, 0x36, 0x34, 0x39, 0x34, 0x62, 0x32, 0x65, 0x37, 0x61, 0x65, 0x66, 0x65, 0x61, 0x36, 0x62, 0x39, 0x61, 0x66, 0x31, 0x38, 0x34, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x64, 0x36, 0x32, 0x34, 0x30, 0x36, 0x32, 0x30, 0x66, 0x34, 0x32, 0x63, 0x35, 0x65, 0x64, 0x62, 0x62, 0x32, 0x65, 0x64, 0x65, 0x36, 0x61, 0x65, 0x63, 0x34, 0x33, 0x64, 0x61, 0x34, 0x65, 0x64, 0x39, 0x62, 0x35, 0x37, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x65, 0x33, 0x35, 0x65, 0x30, 0x34, 0x37, 0x36, 0x34, 0x36, 0x65, 0x37, 0x35, 0x39, 0x66, 0x34, 0x35, 0x31, 0x37, 0x30, 0x39, 0x33, 0x64, 0x36, 0x34, 0x30, 0x38, 0x36, 0x34, 0x32, 0x35, 0x31, 0x37, 0x66, 0x30, 0x38, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x33, 0x39, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x34, 0x30, 0x33, 0x34, 0x35, 0x63, 0x61, 0x36, 0x61, 0x33, 0x65, 0x61, 0x62, 0x64, 0x62, 0x37, 0x37, 0x33, 0x36, 0x33, 0x66, 0x32, 0x35, 0x38, 0x36, 0x30, 0x34, 0x33, 0x66, 0x32, 0x39, 0x34, 0x33, 0x38, 0x63, 0x65, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x30, 0x39, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x34, 0x30, 0x63, 0x63, 0x66, 0x30, 0x35, 0x33, 0x35, 0x35, 0x35, 0x63, 0x31, 0x33, 0x30, 0x61, 0x65, 0x32, 0x62, 0x36, 0x35, 0x36, 0x36, 0x34, 0x37, 0x65, 0x61, 0x36, 0x65, 0x33, 0x31, 0x36, 0x33, 0x37, 0x62, 0x39, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x34, 0x64, 0x38, 0x36, 0x66, 0x33, 0x34, 0x36, 0x36, 0x61, 0x65, 0x36, 0x36, 0x38, 0x33, 0x62, 0x31, 0x39, 0x37, 0x32, 0x39, 0x39, 0x38, 0x32, 0x65, 0x37, 0x61, 0x37, 0x65, 0x31, 0x61, 0x34, 0x38, 0x33, 0x34, 0x37, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x65, 0x63, 0x30, 0x36, 0x66, 0x32, 0x34, 0x37, 0x30, 0x30, 0x66, 0x65, 0x34, 0x32, 0x34, 0x31, 0x34, 0x63, 0x62, 0x39, 0x38, 0x39, 0x37, 0x63, 0x31, 0x35, 0x34, 0x63, 0x38, 0x38, 0x64, 0x65, 0x32, 0x66, 0x36, 0x31, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x65, 0x35, 0x65, 0x32, 0x33, 0x34, 0x61, 0x39, 0x66, 0x34, 0x34, 0x32, 0x36, 0x36, 0x61, 0x34, 0x61, 0x36, 0x32, 0x34, 0x31, 0x61, 0x38, 0x34, 0x64, 0x37, 0x61, 0x31, 0x61, 0x35, 0x35, 0x61, 0x64, 0x35, 0x61, 0x37, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x61, 0x39, 0x61, 0x34, 0x31, 0x37, 0x34, 0x30, 0x66, 0x34, 0x34, 0x66, 0x35, 0x34, 0x63, 0x33, 0x36, 0x38, 0x38, 0x62, 0x35, 0x33, 0x65, 0x31, 0x64, 0x64, 0x64, 0x34, 0x32, 0x65, 0x34, 0x33, 0x63, 0x39, 0x66, 0x65, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x33, 0x61, 0x35, 0x31, 0x64, 0x62, 0x37, 0x34, 0x33, 0x64, 0x33, 0x33, 0x34, 0x64, 0x32, 0x66, 0x65, 0x38, 0x38, 0x32, 0x32, 0x34, 0x62, 0x35, 0x66, 0x65, 0x37, 0x63, 0x30, 0x30, 0x38, 0x65, 0x38, 0x30, 0x65, 0x36, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x39, 0x34, 0x64, 0x66, 0x35, 0x33, 0x31, 0x33, 0x66, 0x61, 0x35, 0x32, 0x30, 0x35, 0x37, 0x30, 0x65, 0x66, 0x32, 0x33, 0x32, 0x62, 0x63, 0x33, 0x33, 0x31, 0x31, 0x64, 0x35, 0x66, 0x36, 0x32, 0x32, 0x66, 0x66, 0x31, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x35, 0x37, 0x37, 0x32, 0x37, 0x65, 0x37, 0x32, 0x63, 0x66, 0x36, 0x32, 0x39, 0x30, 0x32, 0x30, 0x66, 0x34, 0x65, 0x30, 0x35, 0x65, 0x64, 0x66, 0x37, 0x39, 0x39, 0x61, 0x61, 0x37, 0x34, 0x35, 0x38, 0x30, 0x36, 0x32, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x35, 0x65, 0x30, 0x65, 0x61, 0x63, 0x64, 0x31, 0x62, 0x33, 0x39, 0x64, 0x30, 0x36, 0x35, 0x35, 0x66, 0x32, 0x66, 0x37, 0x37, 0x35, 0x33, 0x35, 0x65, 0x66, 0x36, 0x36, 0x30, 0x38, 0x65, 0x62, 0x39, 0x35, 0x30, 0x62, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x61, 0x61, 0x61, 0x33, 0x61, 0x36, 0x31, 0x36, 0x33, 0x65, 0x33, 0x37, 0x30, 0x36, 0x35, 0x37, 0x37, 0x62, 0x34, 0x39, 0x63, 0x30, 0x37, 0x36, 0x37, 0x65, 0x39, 0x34, 0x38, 0x61, 0x36, 0x38, 0x31, 0x65, 0x31, 0x36, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x66, 0x31, 0x66, 0x65, 0x34, 0x63, 0x38, 0x30, 0x38, 0x33, 0x65, 0x35, 0x39, 0x36, 0x32, 0x31, 0x32, 0x61, 0x31, 0x38, 0x37, 0x37, 0x32, 0x38, 0x64, 0x64, 0x35, 0x63, 0x66, 0x38, 0x30, 0x61, 0x33, 0x31, 0x62, 0x65, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x64, 0x35, 0x66, 0x64, 0x30, 0x65, 0x33, 0x64, 0x33, 0x30, 0x34, 0x39, 0x33, 0x33, 0x30, 0x66, 0x66, 0x63, 0x64, 0x63, 0x64, 0x30, 0x32, 0x30, 0x34, 0x35, 0x36, 0x39, 0x31, 0x37, 0x36, 0x35, 0x37, 0x62, 0x61, 0x32, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x62, 0x64, 0x62, 0x63, 0x37, 0x62, 0x61, 0x35, 0x61, 0x62, 0x65, 0x62, 0x62, 0x36, 0x33, 0x38, 0x39, 0x65, 0x39, 0x31, 0x61, 0x33, 0x32, 0x38, 0x35, 0x32, 0x32, 0x30, 0x64, 0x33, 0x34, 0x35, 0x31, 0x62, 0x64, 0x32, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x31, 0x32, 0x36, 0x62, 0x33, 0x38, 0x32, 0x63, 0x66, 0x32, 0x35, 0x37, 0x66, 0x61, 0x64, 0x37, 0x66, 0x30, 0x62, 0x63, 0x37, 0x64, 0x31, 0x36, 0x32, 0x39, 0x37, 0x65, 0x35, 0x34, 0x63, 0x63, 0x37, 0x32, 0x36, 0x37, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x66, 0x38, 0x36, 0x31, 0x36, 0x64, 0x39, 0x37, 0x37, 0x32, 0x34, 0x61, 0x66, 0x33, 0x64, 0x65, 0x66, 0x31, 0x36, 0x35, 0x64, 0x30, 0x65, 0x32, 0x38, 0x63, 0x64, 0x61, 0x38, 0x39, 0x62, 0x38, 0x30, 0x30, 0x30, 0x30, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x30, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x62, 0x39, 0x34, 0x38, 0x62, 0x31, 0x62, 0x36, 0x66, 0x65, 0x66, 0x65, 0x32, 0x30, 0x37, 0x64, 0x65, 0x36, 0x35, 0x65, 0x39, 0x62, 0x62, 0x63, 0x32, 0x64, 0x65, 0x39, 0x38, 0x65, 0x36, 0x30, 0x35, 0x64, 0x30, 0x62, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x32, 0x31, 0x37, 0x64, 0x62, 0x33, 0x38, 0x62, 0x63, 0x33, 0x35, 0x66, 0x32, 0x31, 0x35, 0x66, 0x64, 0x39, 0x32, 0x39, 0x30, 0x36, 0x62, 0x65, 0x34, 0x32, 0x34, 0x33, 0x36, 0x66, 0x65, 0x37, 0x65, 0x36, 0x65, 0x64, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x38, 0x62, 0x30, 0x36, 0x32, 0x32, 0x35, 0x39, 0x65, 0x39, 0x36, 0x65, 0x65, 0x62, 0x33, 0x63, 0x38, 0x64, 0x34, 0x31, 0x30, 0x34, 0x39, 0x34, 0x33, 0x66, 0x39, 0x65, 0x62, 0x33, 0x32, 0x35, 0x38, 0x39, 0x33, 0x63, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x36, 0x62, 0x31, 0x38, 0x61, 0x34, 0x35, 0x61, 0x37, 0x36, 0x34, 0x36, 0x37, 0x65, 0x32, 0x65, 0x35, 0x64, 0x35, 0x61, 0x32, 0x65, 0x66, 0x39, 0x31, 0x31, 0x63, 0x33, 0x65, 0x31, 0x32, 0x39, 0x32, 0x39, 0x38, 0x35, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x36, 0x38, 0x61, 0x65, 0x35, 0x61, 0x62, 0x65, 0x30, 0x32, 0x64, 0x63, 0x66, 0x38, 0x63, 0x62, 0x63, 0x35, 0x61, 0x61, 0x37, 0x31, 0x39, 0x63, 0x32, 0x35, 0x38, 0x31, 0x34, 0x36, 0x35, 0x31, 0x61, 0x66, 0x38, 0x62, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x37, 0x65, 0x32, 0x65, 0x32, 0x62, 0x37, 0x37, 0x61, 0x64, 0x30, 0x63, 0x64, 0x36, 0x66, 0x34, 0x34, 0x61, 0x63, 0x62, 0x32, 0x38, 0x36, 0x31, 0x66, 0x30, 0x66, 0x62, 0x38, 0x62, 0x32, 0x38, 0x37, 0x35, 0x30, 0x65, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x62, 0x61, 0x31, 0x35, 0x36, 0x39, 0x36, 0x35, 0x30, 0x65, 0x35, 0x62, 0x62, 0x62, 0x62, 0x32, 0x31, 0x64, 0x33, 0x35, 0x64, 0x33, 0x65, 0x31, 0x37, 0x35, 0x63, 0x30, 0x64, 0x36, 0x62, 0x30, 0x63, 0x36, 0x35, 0x31, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x62, 0x34, 0x62, 0x66, 0x37, 0x33, 0x31, 0x35, 0x36, 0x61, 0x38, 0x32, 0x61, 0x30, 0x61, 0x36, 0x38, 0x32, 0x32, 0x30, 0x38, 0x30, 0x63, 0x36, 0x65, 0x64, 0x66, 0x34, 0x39, 0x63, 0x34, 0x36, 0x39, 0x61, 0x66, 0x38, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x30, 0x33, 0x32, 0x39, 0x39, 0x36, 0x37, 0x31, 0x64, 0x34, 0x36, 0x37, 0x36, 0x33, 0x39, 0x37, 0x38, 0x66, 0x61, 0x34, 0x61, 0x61, 0x31, 0x39, 0x65, 0x65, 0x33, 0x34, 0x62, 0x31, 0x66, 0x63, 0x39, 0x35, 0x32, 0x37, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x32, 0x31, 0x62, 0x62, 0x34, 0x61, 0x39, 0x34, 0x36, 0x61, 0x64, 0x61, 0x66, 0x64, 0x61, 0x64, 0x65, 0x34, 0x35, 0x37, 0x31, 0x66, 0x62, 0x31, 0x35, 0x63, 0x30, 0x30, 0x34, 0x33, 0x64, 0x33, 0x39, 0x65, 0x65, 0x33, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x37, 0x35, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x33, 0x36, 0x30, 0x38, 0x37, 0x35, 0x31, 0x64, 0x36, 0x38, 0x64, 0x30, 0x34, 0x36, 0x65, 0x38, 0x35, 0x38, 0x30, 0x32, 0x39, 0x32, 0x36, 0x36, 0x37, 0x33, 0x63, 0x64, 0x66, 0x32, 0x66, 0x35, 0x37, 0x66, 0x37, 0x63, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x66, 0x65, 0x65, 0x30, 0x38, 0x62, 0x30, 0x30, 0x63, 0x36, 0x63, 0x32, 0x63, 0x30, 0x34, 0x61, 0x33, 0x63, 0x36, 0x32, 0x35, 0x63, 0x31, 0x66, 0x66, 0x37, 0x37, 0x63, 0x61, 0x66, 0x31, 0x63, 0x33, 0x32, 0x64, 0x66, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x30, 0x66, 0x65, 0x61, 0x31, 0x31, 0x37, 0x36, 0x64, 0x35, 0x32, 0x31, 0x35, 0x39, 0x33, 0x33, 0x33, 0x61, 0x31, 0x34, 0x33, 0x63, 0x32, 0x39, 0x34, 0x39, 0x34, 0x33, 0x64, 0x61, 0x33, 0x36, 0x62, 0x62, 0x64, 0x64, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x33, 0x31, 0x63, 0x38, 0x32, 0x33, 0x38, 0x32, 0x35, 0x61, 0x39, 0x65, 0x35, 0x32, 0x36, 0x33, 0x64, 0x30, 0x35, 0x32, 0x64, 0x38, 0x39, 0x31, 0x35, 0x64, 0x34, 0x64, 0x63, 0x64, 0x65, 0x30, 0x37, 0x61, 0x35, 0x63, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x35, 0x34, 0x33, 0x32, 0x61, 0x36, 0x66, 0x32, 0x61, 0x63, 0x39, 0x64, 0x35, 0x36, 0x35, 0x37, 0x37, 0x62, 0x39, 0x33, 0x38, 0x61, 0x33, 0x37, 0x66, 0x61, 0x62, 0x61, 0x63, 0x38, 0x63, 0x63, 0x37, 0x63, 0x34, 0x36, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x34, 0x66, 0x63, 0x34, 0x36, 0x64, 0x34, 0x32, 0x38, 0x62, 0x36, 0x64, 0x62, 0x63, 0x32, 0x32, 0x38, 0x61, 0x30, 0x66, 0x35, 0x66, 0x35, 0x35, 0x63, 0x39, 0x35, 0x30, 0x38, 0x63, 0x37, 0x37, 0x32, 0x65, 0x61, 0x62, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x39, 0x35, 0x61, 0x38, 0x61, 0x38, 0x30, 0x38, 0x32, 0x65, 0x34, 0x36, 0x35, 0x32, 0x65, 0x34, 0x31, 0x37, 0x30, 0x64, 0x66, 0x39, 0x32, 0x37, 0x31, 0x63, 0x62, 0x34, 0x62, 0x62, 0x34, 0x33, 0x30, 0x35, 0x66, 0x30, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x63, 0x39, 0x66, 0x31, 0x62, 0x66, 0x62, 0x36, 0x38, 0x39, 0x66, 0x64, 0x66, 0x38, 0x30, 0x34, 0x64, 0x37, 0x36, 0x39, 0x66, 0x38, 0x32, 0x31, 0x32, 0x33, 0x33, 0x36, 0x30, 0x32, 0x31, 0x35, 0x61, 0x66, 0x66, 0x39, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x37, 0x32, 0x63, 0x64, 0x66, 0x61, 0x62, 0x37, 0x32, 0x61, 0x30, 0x31, 0x63, 0x65, 0x39, 0x36, 0x38, 0x65, 0x37, 0x38, 0x66, 0x35, 0x62, 0x35, 0x34, 0x34, 0x38, 0x64, 0x61, 0x32, 0x39, 0x38, 0x35, 0x33, 0x66, 0x62, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x36, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x39, 0x63, 0x37, 0x31, 0x36, 0x36, 0x38, 0x34, 0x39, 0x62, 0x63, 0x32, 0x34, 0x61, 0x30, 0x32, 0x64, 0x36, 0x35, 0x33, 0x35, 0x65, 0x32, 0x64, 0x65, 0x66, 0x31, 0x33, 0x64, 0x61, 0x65, 0x65, 0x66, 0x38, 0x61, 0x61, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x61, 0x32, 0x35, 0x34, 0x61, 0x63, 0x30, 0x39, 0x62, 0x39, 0x37, 0x32, 0x35, 0x62, 0x65, 0x62, 0x63, 0x38, 0x65, 0x34, 0x36, 0x30, 0x34, 0x33, 0x31, 0x64, 0x64, 0x30, 0x37, 0x33, 0x32, 0x65, 0x62, 0x63, 0x61, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x32, 0x35, 0x63, 0x31, 0x63, 0x61, 0x35, 0x66, 0x32, 0x61, 0x39, 0x63, 0x38, 0x38, 0x31, 0x35, 0x36, 0x62, 0x62, 0x37, 0x64, 0x39, 0x63, 0x64, 0x63, 0x34, 0x34, 0x61, 0x33, 0x32, 0x36, 0x36, 0x35, 0x33, 0x63, 0x32, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x36, 0x38, 0x36, 0x63, 0x37, 0x62, 0x61, 0x64, 0x37, 0x36, 0x32, 0x63, 0x35, 0x34, 0x62, 0x36, 0x36, 0x37, 0x64, 0x35, 0x39, 0x66, 0x39, 0x30, 0x39, 0x34, 0x33, 0x63, 0x64, 0x31, 0x34, 0x64, 0x31, 0x31, 0x37, 0x61, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x35, 0x61, 0x38, 0x62, 0x32, 0x62, 0x38, 0x30, 0x62, 0x65, 0x38, 0x62, 0x33, 0x35, 0x64, 0x38, 0x65, 0x63, 0x66, 0x37, 0x38, 0x39, 0x62, 0x35, 0x65, 0x64, 0x37, 0x61, 0x30, 0x37, 0x37, 0x35, 0x63, 0x35, 0x30, 0x37, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x63, 0x66, 0x38, 0x30, 0x65, 0x32, 0x31, 0x38, 0x39, 0x38, 0x31, 0x32, 0x35, 0x65, 0x62, 0x34, 0x65, 0x38, 0x30, 0x37, 0x63, 0x64, 0x38, 0x32, 0x65, 0x30, 0x39, 0x62, 0x39, 0x64, 0x32, 0x38, 0x35, 0x39, 0x32, 0x66, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x65, 0x39, 0x36, 0x39, 0x61, 0x65, 0x66, 0x33, 0x34, 0x65, 0x61, 0x38, 0x37, 0x61, 0x63, 0x32, 0x39, 0x39, 0x62, 0x37, 0x35, 0x39, 0x37, 0x65, 0x32, 0x39, 0x32, 0x62, 0x34, 0x61, 0x30, 0x31, 0x35, 0x35, 0x63, 0x63, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x38, 0x38, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x65, 0x39, 0x34, 0x65, 0x36, 0x32, 0x30, 0x30, 0x35, 0x30, 0x61, 0x61, 0x64, 0x37, 0x36, 0x36, 0x62, 0x39, 0x65, 0x31, 0x62, 0x61, 0x64, 0x39, 0x33, 0x31, 0x32, 0x33, 0x38, 0x33, 0x31, 0x32, 0x64, 0x34, 0x62, 0x66, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x39, 0x66, 0x35, 0x37, 0x66, 0x64, 0x65, 0x64, 0x36, 0x61, 0x65, 0x33, 0x37, 0x39, 0x31, 0x33, 0x64, 0x39, 0x30, 0x30, 0x62, 0x38, 0x31, 0x65, 0x35, 0x66, 0x34, 0x38, 0x61, 0x37, 0x39, 0x33, 0x32, 0x32, 0x63, 0x36, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x35, 0x35, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x62, 0x30, 0x61, 0x33, 0x32, 0x31, 0x39, 0x61, 0x33, 0x32, 0x38, 0x38, 0x64, 0x39, 0x62, 0x33, 0x35, 0x62, 0x30, 0x39, 0x31, 0x62, 0x31, 0x34, 0x36, 0x35, 0x30, 0x62, 0x38, 0x66, 0x65, 0x32, 0x33, 0x64, 0x63, 0x65, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x37, 0x35, 0x63, 0x37, 0x37, 0x30, 0x36, 0x36, 0x38, 0x61, 0x39, 0x64, 0x31, 0x37, 0x39, 0x66, 0x31, 0x65, 0x66, 0x37, 0x36, 0x38, 0x63, 0x32, 0x39, 0x33, 0x66, 0x38, 0x30, 0x31, 0x36, 0x36, 0x65, 0x32, 0x61, 0x61, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x66, 0x30, 0x35, 0x62, 0x32, 0x36, 0x32, 0x35, 0x36, 0x30, 0x35, 0x30, 0x33, 0x63, 0x61, 0x37, 0x36, 0x31, 0x63, 0x36, 0x31, 0x38, 0x39, 0x30, 0x61, 0x34, 0x30, 0x33, 0x35, 0x66, 0x34, 0x63, 0x37, 0x33, 0x37, 0x32, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x38, 0x36, 0x64, 0x31, 0x62, 0x63, 0x36, 0x35, 0x37, 0x61, 0x33, 0x31, 0x32, 0x63, 0x38, 0x38, 0x34, 0x37, 0x64, 0x39, 0x33, 0x63, 0x62, 0x33, 0x63, 0x62, 0x37, 0x39, 0x35, 0x30, 0x66, 0x32, 0x62, 0x30, 0x63, 0x36, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x39, 0x65, 0x36, 0x61, 0x61, 0x66, 0x38, 0x30, 0x31, 0x39, 0x61, 0x30, 0x35, 0x66, 0x32, 0x33, 0x30, 0x65, 0x35, 0x64, 0x65, 0x66, 0x30, 0x35, 0x61, 0x66, 0x35, 0x64, 0x38, 0x38, 0x39, 0x62, 0x64, 0x34, 0x64, 0x30, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x37, 0x35, 0x62, 0x34, 0x62, 0x63, 0x32, 0x34, 0x61, 0x32, 0x34, 0x65, 0x31, 0x66, 0x37, 0x39, 0x37, 0x35, 0x39, 0x33, 0x63, 0x63, 0x33, 0x30, 0x32, 0x62, 0x32, 0x66, 0x33, 0x33, 0x31, 0x30, 0x36, 0x33, 0x66, 0x61, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x38, 0x62, 0x61, 0x37, 0x63, 0x32, 0x38, 0x39, 0x35, 0x63, 0x35, 0x30, 0x65, 0x30, 0x37, 0x32, 0x64, 0x63, 0x36, 0x66, 0x39, 0x36, 0x34, 0x39, 0x33, 0x32, 0x64, 0x35, 0x30, 0x63, 0x32, 0x38, 0x32, 0x64, 0x33, 0x30, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x62, 0x33, 0x34, 0x61, 0x32, 0x36, 0x33, 0x66, 0x31, 0x30, 0x63, 0x33, 0x64, 0x32, 0x65, 0x63, 0x65, 0x62, 0x30, 0x61, 0x63, 0x63, 0x35, 0x35, 0x39, 0x61, 0x37, 0x62, 0x32, 0x61, 0x62, 0x38, 0x35, 0x63, 0x65, 0x35, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x64, 0x32, 0x62, 0x34, 0x32, 0x39, 0x66, 0x31, 0x61, 0x64, 0x35, 0x33, 0x34, 0x39, 0x65, 0x33, 0x31, 0x37, 0x30, 0x34, 0x39, 0x36, 0x39, 0x65, 0x64, 0x63, 0x35, 0x66, 0x32, 0x35, 0x65, 0x65, 0x38, 0x61, 0x63, 0x61, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x34, 0x61, 0x64, 0x62, 0x32, 0x31, 0x64, 0x66, 0x34, 0x63, 0x39, 0x38, 0x63, 0x37, 0x61, 0x33, 0x34, 0x37, 0x61, 0x63, 0x34, 0x63, 0x33, 0x63, 0x32, 0x34, 0x32, 0x36, 0x36, 0x37, 0x35, 0x37, 0x64, 0x64, 0x37, 0x30, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x35, 0x36, 0x35, 0x62, 0x61, 0x39, 0x64, 0x61, 0x32, 0x63, 0x30, 0x33, 0x65, 0x37, 0x37, 0x38, 0x63, 0x65, 0x31, 0x32, 0x32, 0x39, 0x34, 0x66, 0x30, 0x38, 0x31, 0x64, 0x66, 0x65, 0x38, 0x31, 0x30, 0x36, 0x34, 0x64, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x64, 0x64, 0x61, 0x37, 0x35, 0x38, 0x36, 0x62, 0x32, 0x32, 0x33, 0x37, 0x62, 0x30, 0x35, 0x33, 0x61, 0x37, 0x66, 0x33, 0x32, 0x38, 0x39, 0x63, 0x66, 0x34, 0x36, 0x30, 0x64, 0x63, 0x35, 0x37, 0x64, 0x33, 0x37, 0x61, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x34, 0x66, 0x61, 0x61, 0x63, 0x30, 0x30, 0x62, 0x65, 0x36, 0x36, 0x32, 0x38, 0x66, 0x39, 0x32, 0x65, 0x66, 0x36, 0x62, 0x38, 0x63, 0x62, 0x31, 0x62, 0x31, 0x65, 0x37, 0x36, 0x61, 0x61, 0x63, 0x38, 0x31, 0x66, 0x61, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x35, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x39, 0x39, 0x64, 0x63, 0x38, 0x65, 0x34, 0x39, 0x65, 0x36, 0x31, 0x64, 0x35, 0x37, 0x64, 0x61, 0x65, 0x66, 0x36, 0x30, 0x36, 0x61, 0x63, 0x64, 0x64, 0x39, 0x31, 0x62, 0x34, 0x64, 0x37, 0x30, 0x30, 0x37, 0x33, 0x32, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x61, 0x39, 0x37, 0x39, 0x33, 0x35, 0x32, 0x37, 0x35, 0x39, 0x62, 0x61, 0x30, 0x39, 0x65, 0x33, 0x35, 0x61, 0x61, 0x35, 0x39, 0x33, 0x35, 0x64, 0x66, 0x31, 0x37, 0x35, 0x62, 0x66, 0x66, 0x36, 0x37, 0x38, 0x61, 0x31, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x66, 0x66, 0x66, 0x32, 0x32, 0x30, 0x65, 0x35, 0x39, 0x33, 0x30, 0x35, 0x63, 0x30, 0x39, 0x66, 0x34, 0x38, 0x33, 0x38, 0x36, 0x30, 0x64, 0x36, 0x66, 0x39, 0x34, 0x65, 0x39, 0x36, 0x66, 0x62, 0x65, 0x33, 0x32, 0x66, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x65, 0x38, 0x62, 0x30, 0x38, 0x34, 0x35, 0x33, 0x37, 0x35, 0x35, 0x37, 0x65, 0x37, 0x30, 0x39, 0x65, 0x61, 0x65, 0x32, 0x65, 0x31, 0x65, 0x31, 0x61, 0x35, 0x61, 0x36, 0x62, 0x63, 0x65, 0x31, 0x65, 0x66, 0x38, 0x33, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x34, 0x66, 0x66, 0x37, 0x64, 0x65, 0x34, 0x39, 0x31, 0x63, 0x36, 0x38, 0x37, 0x64, 0x66, 0x34, 0x35, 0x37, 0x34, 0x64, 0x64, 0x31, 0x62, 0x31, 0x37, 0x66, 0x66, 0x38, 0x66, 0x32, 0x34, 0x36, 0x62, 0x61, 0x33, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x33, 0x38, 0x35, 0x33, 0x32, 0x39, 0x33, 0x36, 0x38, 0x31, 0x33, 0x63, 0x39, 0x31, 0x65, 0x36, 0x35, 0x33, 0x32, 0x38, 0x34, 0x66, 0x30, 0x31, 0x37, 0x63, 0x38, 0x30, 0x63, 0x33, 0x62, 0x38, 0x66, 0x38, 0x61, 0x33, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x38, 0x32, 0x66, 0x39, 0x36, 0x63, 0x64, 0x34, 0x62, 0x37, 0x65, 0x32, 0x64, 0x39, 0x33, 0x64, 0x31, 0x30, 0x66, 0x33, 0x31, 0x38, 0x35, 0x64, 0x63, 0x38, 0x66, 0x34, 0x33, 0x64, 0x34, 0x62, 0x37, 0x35, 0x61, 0x61, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x37, 0x34, 0x30, 0x61, 0x34, 0x36, 0x36, 0x34, 0x38, 0x65, 0x38, 0x34, 0x35, 0x61, 0x35, 0x64, 0x39, 0x36, 0x34, 0x36, 0x31, 0x62, 0x31, 0x38, 0x30, 0x39, 0x31, 0x66, 0x66, 0x35, 0x37, 0x62, 0x65, 0x38, 0x61, 0x31, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x33, 0x66, 0x36, 0x33, 0x65, 0x31, 0x33, 0x31, 0x32, 0x39, 0x61, 0x32, 0x32, 0x31, 0x62, 0x61, 0x31, 0x61, 0x62, 0x30, 0x36, 0x33, 0x32, 0x36, 0x33, 0x34, 0x32, 0x63, 0x64, 0x39, 0x38, 0x62, 0x35, 0x31, 0x32, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x37, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x35, 0x66, 0x33, 0x62, 0x33, 0x34, 0x62, 0x64, 0x31, 0x33, 0x34, 0x62, 0x32, 0x37, 0x38, 0x31, 0x61, 0x66, 0x65, 0x35, 0x61, 0x30, 0x34, 0x32, 0x34, 0x61, 0x63, 0x35, 0x38, 0x34, 0x36, 0x63, 0x64, 0x65, 0x66, 0x64, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x39, 0x33, 0x36, 0x63, 0x32, 0x37, 0x31, 0x39, 0x34, 0x35, 0x30, 0x62, 0x39, 0x34, 0x32, 0x30, 0x63, 0x63, 0x32, 0x35, 0x32, 0x32, 0x63, 0x66, 0x39, 0x31, 0x64, 0x62, 0x30, 0x31, 0x66, 0x32, 0x32, 0x37, 0x63, 0x31, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x37, 0x30, 0x37, 0x36, 0x61, 0x38, 0x37, 0x37, 0x62, 0x31, 0x38, 0x65, 0x63, 0x31, 0x35, 0x61, 0x34, 0x31, 0x35, 0x62, 0x62, 0x31, 0x31, 0x36, 0x66, 0x30, 0x36, 0x65, 0x66, 0x33, 0x32, 0x36, 0x34, 0x35, 0x64, 0x62, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x32, 0x39, 0x30, 0x38, 0x65, 0x37, 0x66, 0x65, 0x35, 0x33, 0x39, 0x38, 0x30, 0x61, 0x39, 0x61, 0x62, 0x66, 0x34, 0x30, 0x34, 0x34, 0x65, 0x39, 0x35, 0x37, 0x61, 0x35, 0x34, 0x62, 0x37, 0x30, 0x65, 0x39, 0x39, 0x63, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x62, 0x33, 0x37, 0x31, 0x63, 0x34, 0x30, 0x37, 0x34, 0x30, 0x36, 0x63, 0x34, 0x32, 0x37, 0x62, 0x33, 0x62, 0x37, 0x64, 0x65, 0x32, 0x37, 0x31, 0x61, 0x64, 0x33, 0x63, 0x31, 0x65, 0x30, 0x34, 0x32, 0x36, 0x39, 0x35, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x37, 0x30, 0x32, 0x32, 0x33, 0x61, 0x65, 0x33, 0x63, 0x61, 0x61, 0x38, 0x35, 0x31, 0x34, 0x31, 0x38, 0x61, 0x39, 0x38, 0x34, 0x33, 0x61, 0x31, 0x61, 0x63, 0x35, 0x35, 0x64, 0x62, 0x34, 0x38, 0x32, 0x34, 0x66, 0x34, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x34, 0x36, 0x39, 0x32, 0x63, 0x63, 0x63, 0x62, 0x33, 0x33, 0x34, 0x30, 0x35, 0x64, 0x64, 0x30, 0x61, 0x62, 0x30, 0x63, 0x33, 0x33, 0x37, 0x39, 0x62, 0x34, 0x39, 0x63, 0x61, 0x66, 0x38, 0x65, 0x36, 0x32, 0x32, 0x31, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x36, 0x35, 0x39, 0x31, 0x38, 0x62, 0x66, 0x65, 0x33, 0x66, 0x32, 0x36, 0x32, 0x37, 0x62, 0x39, 0x66, 0x33, 0x61, 0x38, 0x36, 0x37, 0x37, 0x35, 0x64, 0x38, 0x37, 0x35, 0x36, 0x65, 0x30, 0x66, 0x64, 0x38, 0x61, 0x39, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x39, 0x65, 0x64, 0x30, 0x61, 0x62, 0x37, 0x61, 0x61, 0x37, 0x37, 0x64, 0x65, 0x35, 0x37, 0x31, 0x66, 0x31, 0x36, 0x31, 0x30, 0x36, 0x30, 0x35, 0x31, 0x64, 0x39, 0x32, 0x61, 0x66, 0x65, 0x31, 0x39, 0x35, 0x66, 0x32, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x34, 0x33, 0x32, 0x61, 0x33, 0x39, 0x31, 0x36, 0x32, 0x34, 0x39, 0x62, 0x34, 0x37, 0x32, 0x34, 0x32, 0x39, 0x33, 0x61, 0x66, 0x39, 0x31, 0x34, 0x36, 0x65, 0x34, 0x39, 0x62, 0x38, 0x32, 0x38, 0x30, 0x61, 0x37, 0x66, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x63, 0x39, 0x64, 0x63, 0x65, 0x38, 0x62, 0x32, 0x39, 0x38, 0x31, 0x63, 0x62, 0x34, 0x30, 0x65, 0x39, 0x38, 0x62, 0x30, 0x34, 0x30, 0x32, 0x62, 0x63, 0x33, 0x65, 0x62, 0x32, 0x38, 0x33, 0x34, 0x38, 0x66, 0x30, 0x33, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x31, 0x66, 0x63, 0x63, 0x33, 0x63, 0x35, 0x31, 0x65, 0x32, 0x35, 0x32, 0x62, 0x36, 0x39, 0x33, 0x62, 0x63, 0x35, 0x62, 0x30, 0x65, 0x63, 0x33, 0x66, 0x36, 0x33, 0x35, 0x32, 0x39, 0x66, 0x65, 0x36, 0x39, 0x32, 0x38, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x66, 0x64, 0x30, 0x38, 0x64, 0x31, 0x38, 0x30, 0x36, 0x34, 0x62, 0x64, 0x32, 0x30, 0x32, 0x63, 0x30, 0x65, 0x63, 0x33, 0x64, 0x32, 0x63, 0x63, 0x65, 0x30, 0x63, 0x65, 0x30, 0x62, 0x39, 0x64, 0x31, 0x36, 0x39, 0x63, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x33, 0x61, 0x37, 0x63, 0x38, 0x39, 0x39, 0x65, 0x65, 0x31, 0x38, 0x62, 0x63, 0x32, 0x31, 0x34, 0x39, 0x36, 0x39, 0x38, 0x37, 0x30, 0x62, 0x63, 0x37, 0x34, 0x38, 0x32, 0x66, 0x36, 0x64, 0x38, 0x66, 0x33, 0x35, 0x37, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x34, 0x63, 0x63, 0x38, 0x64, 0x65, 0x33, 0x33, 0x64, 0x36, 0x33, 0x33, 0x38, 0x32, 0x33, 0x36, 0x35, 0x33, 0x39, 0x61, 0x34, 0x38, 0x39, 0x30, 0x32, 0x30, 0x63, 0x65, 0x34, 0x36, 0x35, 0x35, 0x61, 0x33, 0x32, 0x62, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x38, 0x62, 0x66, 0x34, 0x31, 0x30, 0x61, 0x64, 0x39, 0x62, 0x62, 0x63, 0x32, 0x66, 0x65, 0x63, 0x63, 0x34, 0x35, 0x30, 0x38, 0x64, 0x38, 0x37, 0x61, 0x37, 0x66, 0x63, 0x32, 0x65, 0x34, 0x62, 0x38, 0x35, 0x36, 0x31, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x66, 0x37, 0x64, 0x63, 0x38, 0x64, 0x31, 0x62, 0x39, 0x34, 0x36, 0x32, 0x63, 0x65, 0x66, 0x36, 0x66, 0x65, 0x62, 0x31, 0x33, 0x33, 0x36, 0x38, 0x61, 0x37, 0x65, 0x33, 0x39, 0x37, 0x34, 0x62, 0x30, 0x39, 0x37, 0x66, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x39, 0x66, 0x38, 0x39, 0x61, 0x33, 0x39, 0x31, 0x30, 0x66, 0x36, 0x61, 0x32, 0x61, 0x65, 0x38, 0x61, 0x39, 0x31, 0x30, 0x34, 0x37, 0x61, 0x31, 0x37, 0x61, 0x62, 0x37, 0x38, 0x38, 0x62, 0x64, 0x64, 0x65, 0x63, 0x31, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x65, 0x35, 0x39, 0x38, 0x61, 0x62, 0x61, 0x33, 0x34, 0x34, 0x33, 0x37, 0x38, 0x63, 0x61, 0x62, 0x34, 0x34, 0x33, 0x31, 0x35, 0x35, 0x35, 0x62, 0x34, 0x66, 0x37, 0x39, 0x39, 0x39, 0x32, 0x64, 0x63, 0x32, 0x39, 0x30, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x65, 0x36, 0x30, 0x33, 0x34, 0x65, 0x63, 0x66, 0x32, 0x33, 0x66, 0x38, 0x62, 0x35, 0x36, 0x33, 0x39, 0x64, 0x35, 0x66, 0x30, 0x65, 0x61, 0x37, 0x30, 0x61, 0x32, 0x32, 0x35, 0x33, 0x38, 0x61, 0x39, 0x32, 0x30, 0x34, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x32, 0x37, 0x33, 0x39, 0x32, 0x32, 0x30, 0x36, 0x62, 0x39, 0x35, 0x38, 0x63, 0x64, 0x33, 0x37, 0x35, 0x64, 0x37, 0x65, 0x66, 0x38, 0x61, 0x66, 0x32, 0x63, 0x66, 0x38, 0x65, 0x66, 0x30, 0x35, 0x39, 0x38, 0x63, 0x30, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x31, 0x33, 0x36, 0x66, 0x65, 0x36, 0x65, 0x32, 0x38, 0x62, 0x37, 0x34, 0x35, 0x33, 0x66, 0x63, 0x62, 0x31, 0x36, 0x62, 0x36, 0x62, 0x62, 0x62, 0x65, 0x39, 0x61, 0x61, 0x61, 0x63, 0x62, 0x61, 0x38, 0x33, 0x33, 0x37, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x38, 0x32, 0x66, 0x65, 0x38, 0x61, 0x38, 0x36, 0x37, 0x65, 0x39, 0x33, 0x65, 0x62, 0x34, 0x61, 0x30, 0x62, 0x64, 0x30, 0x35, 0x31, 0x35, 0x38, 0x39, 0x33, 0x39, 0x39, 0x66, 0x32, 0x65, 0x63, 0x39, 0x61, 0x35, 0x32, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x64, 0x31, 0x30, 0x35, 0x32, 0x61, 0x36, 0x30, 0x35, 0x30, 0x36, 0x62, 0x64, 0x31, 0x61, 0x39, 0x65, 0x66, 0x30, 0x30, 0x33, 0x61, 0x66, 0x64, 0x39, 0x64, 0x30, 0x33, 0x33, 0x63, 0x32, 0x36, 0x37, 0x64, 0x38, 0x65, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x38, 0x66, 0x61, 0x32, 0x63, 0x34, 0x63, 0x63, 0x31, 0x34, 0x37, 0x61, 0x64, 0x30, 0x36, 0x61, 0x64, 0x35, 0x61, 0x32, 0x66, 0x37, 0x35, 0x35, 0x37, 0x39, 0x32, 0x38, 0x31, 0x66, 0x32, 0x32, 0x61, 0x37, 0x63, 0x63, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x37, 0x39, 0x34, 0x64, 0x62, 0x64, 0x66, 0x36, 0x32, 0x33, 0x64, 0x61, 0x61, 0x36, 0x65, 0x30, 0x64, 0x30, 0x30, 0x37, 0x37, 0x34, 0x61, 0x64, 0x36, 0x39, 0x36, 0x32, 0x37, 0x33, 0x37, 0x63, 0x39, 0x32, 0x31, 0x65, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x36, 0x62, 0x31, 0x38, 0x34, 0x65, 0x31, 0x66, 0x30, 0x66, 0x35, 0x34, 0x39, 0x32, 0x34, 0x61, 0x63, 0x38, 0x37, 0x34, 0x66, 0x36, 0x30, 0x62, 0x62, 0x66, 0x34, 0x34, 0x37, 0x30, 0x37, 0x34, 0x34, 0x36, 0x62, 0x37, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x62, 0x61, 0x32, 0x39, 0x39, 0x31, 0x37, 0x63, 0x37, 0x38, 0x61, 0x31, 0x64, 0x39, 0x65, 0x35, 0x63, 0x35, 0x63, 0x37, 0x31, 0x33, 0x36, 0x36, 0x36, 0x63, 0x31, 0x65, 0x34, 0x31, 0x31, 0x64, 0x37, 0x66, 0x36, 0x39, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x64, 0x36, 0x31, 0x39, 0x66, 0x66, 0x35, 0x37, 0x32, 0x36, 0x66, 0x32, 0x34, 0x30, 0x35, 0x66, 0x31, 0x32, 0x39, 0x30, 0x34, 0x63, 0x37, 0x32, 0x65, 0x62, 0x31, 0x65, 0x32, 0x34, 0x61, 0x30, 0x61, 0x61, 0x65, 0x65, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x32, 0x66, 0x61, 0x32, 0x39, 0x33, 0x38, 0x37, 0x65, 0x63, 0x31, 0x32, 0x65, 0x33, 0x37, 0x66, 0x36, 0x39, 0x32, 0x32, 0x61, 0x63, 0x34, 0x63, 0x65, 0x39, 0x38, 0x63, 0x35, 0x62, 0x30, 0x39, 0x65, 0x30, 0x62, 0x30, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x32, 0x33, 0x30, 0x64, 0x31, 0x64, 0x31, 0x66, 0x66, 0x32, 0x61, 0x63, 0x61, 0x33, 0x36, 0x36, 0x39, 0x36, 0x33, 0x39, 0x31, 0x34, 0x61, 0x37, 0x39, 0x64, 0x66, 0x39, 0x66, 0x37, 0x63, 0x35, 0x65, 0x61, 0x32, 0x63, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x34, 0x30, 0x30, 0x37, 0x63, 0x34, 0x35, 0x65, 0x35, 0x61, 0x35, 0x37, 0x33, 0x66, 0x64, 0x62, 0x62, 0x36, 0x66, 0x38, 0x62, 0x64, 0x37, 0x34, 0x36, 0x62, 0x66, 0x39, 0x34, 0x61, 0x64, 0x30, 0x34, 0x61, 0x33, 0x63, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x32, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x39, 0x61, 0x30, 0x63, 0x37, 0x30, 0x64, 0x32, 0x32, 0x36, 0x32, 0x30, 0x34, 0x32, 0x64, 0x66, 0x31, 0x30, 0x31, 0x37, 0x64, 0x36, 0x63, 0x33, 0x30, 0x33, 0x31, 0x33, 0x32, 0x30, 0x32, 0x34, 0x37, 0x37, 0x32, 0x37, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x33, 0x61, 0x61, 0x64, 0x34, 0x31, 0x64, 0x66, 0x34, 0x62, 0x36, 0x66, 0x63, 0x38, 0x66, 0x65, 0x63, 0x65, 0x38, 0x63, 0x39, 0x33, 0x39, 0x35, 0x38, 0x61, 0x61, 0x39, 0x30, 0x31, 0x66, 0x61, 0x36, 0x38, 0x30, 0x38, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x30, 0x34, 0x66, 0x61, 0x64, 0x39, 0x63, 0x34, 0x39, 0x66, 0x39, 0x65, 0x38, 0x38, 0x30, 0x62, 0x65, 0x62, 0x38, 0x66, 0x63, 0x66, 0x31, 0x64, 0x33, 0x61, 0x33, 0x38, 0x39, 0x30, 0x65, 0x34, 0x62, 0x33, 0x38, 0x34, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x32, 0x34, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x38, 0x32, 0x34, 0x36, 0x36, 0x36, 0x64, 0x32, 0x37, 0x38, 0x64, 0x37, 0x30, 0x34, 0x32, 0x33, 0x66, 0x30, 0x33, 0x64, 0x66, 0x65, 0x31, 0x64, 0x63, 0x37, 0x61, 0x33, 0x66, 0x30, 0x32, 0x66, 0x34, 0x33, 0x65, 0x32, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x34, 0x39, 0x32, 0x30, 0x64, 0x63, 0x36, 0x65, 0x63, 0x63, 0x31, 0x64, 0x36, 0x65, 0x63, 0x63, 0x30, 0x38, 0x34, 0x66, 0x38, 0x38, 0x61, 0x61, 0x30, 0x61, 0x66, 0x35, 0x64, 0x62, 0x39, 0x37, 0x62, 0x66, 0x38, 0x39, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x63, 0x31, 0x62, 0x31, 0x37, 0x37, 0x61, 0x32, 0x32, 0x30, 0x65, 0x34, 0x31, 0x66, 0x37, 0x63, 0x37, 0x34, 0x64, 0x30, 0x37, 0x63, 0x64, 0x65, 0x38, 0x35, 0x36, 0x39, 0x63, 0x32, 0x31, 0x63, 0x37, 0x35, 0x63, 0x32, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x36, 0x34, 0x64, 0x63, 0x39, 0x39, 0x39, 0x66, 0x65, 0x34, 0x66, 0x38, 0x65, 0x30, 0x30, 0x33, 0x63, 0x30, 0x66, 0x34, 0x33, 0x64, 0x65, 0x63, 0x63, 0x33, 0x39, 0x61, 0x61, 0x65, 0x31, 0x35, 0x32, 0x32, 0x64, 0x63, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x35, 0x63, 0x33, 0x37, 0x63, 0x65, 0x32, 0x64, 0x61, 0x30, 0x36, 0x62, 0x62, 0x63, 0x34, 0x30, 0x30, 0x38, 0x31, 0x31, 0x35, 0x39, 0x63, 0x36, 0x62, 0x61, 0x30, 0x66, 0x39, 0x37, 0x36, 0x65, 0x33, 0x39, 0x39, 0x33, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x37, 0x38, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x39, 0x61, 0x38, 0x32, 0x35, 0x65, 0x30, 0x66, 0x31, 0x66, 0x36, 0x65, 0x39, 0x38, 0x35, 0x33, 0x30, 0x39, 0x36, 0x36, 0x38, 0x34, 0x36, 0x35, 0x63, 0x66, 0x66, 0x65, 0x64, 0x34, 0x33, 0x36, 0x66, 0x36, 0x61, 0x65, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x36, 0x62, 0x36, 0x39, 0x39, 0x64, 0x39, 0x65, 0x61, 0x64, 0x33, 0x34, 0x39, 0x66, 0x30, 0x36, 0x37, 0x66, 0x34, 0x35, 0x37, 0x31, 0x31, 0x61, 0x30, 0x37, 0x34, 0x61, 0x36, 0x34, 0x31, 0x64, 0x62, 0x36, 0x61, 0x38, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x38, 0x63, 0x65, 0x38, 0x62, 0x64, 0x36, 0x65, 0x39, 0x30, 0x32, 0x61, 0x34, 0x35, 0x63, 0x62, 0x38, 0x33, 0x62, 0x35, 0x31, 0x35, 0x34, 0x31, 0x62, 0x34, 0x30, 0x66, 0x33, 0x39, 0x63, 0x34, 0x34, 0x36, 0x39, 0x37, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x37, 0x61, 0x63, 0x36, 0x39, 0x30, 0x37, 0x39, 0x31, 0x63, 0x32, 0x65, 0x32, 0x33, 0x34, 0x35, 0x31, 0x30, 0x38, 0x39, 0x66, 0x65, 0x36, 0x63, 0x37, 0x30, 0x38, 0x33, 0x66, 0x65, 0x35, 0x35, 0x64, 0x65, 0x62, 0x36, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x34, 0x66, 0x30, 0x34, 0x62, 0x38, 0x64, 0x62, 0x36, 0x35, 0x62, 0x62, 0x61, 0x39, 0x63, 0x32, 0x36, 0x65, 0x66, 0x63, 0x34, 0x63, 0x65, 0x36, 0x65, 0x66, 0x63, 0x35, 0x30, 0x34, 0x38, 0x31, 0x66, 0x33, 0x64, 0x36, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x61, 0x65, 0x66, 0x34, 0x38, 0x64, 0x65, 0x38, 0x63, 0x39, 0x66, 0x62, 0x61, 0x64, 0x34, 0x62, 0x39, 0x65, 0x34, 0x63, 0x61, 0x39, 0x37, 0x30, 0x37, 0x39, 0x37, 0x61, 0x35, 0x35, 0x33, 0x33, 0x65, 0x62, 0x37, 0x32, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x30, 0x65, 0x63, 0x64, 0x61, 0x36, 0x36, 0x33, 0x36, 0x66, 0x37, 0x37, 0x31, 0x36, 0x65, 0x66, 0x31, 0x39, 0x37, 0x33, 0x36, 0x31, 0x34, 0x36, 0x38, 0x37, 0x66, 0x64, 0x38, 0x39, 0x61, 0x38, 0x32, 0x30, 0x61, 0x37, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x32, 0x38, 0x32, 0x35, 0x64, 0x35, 0x66, 0x33, 0x64, 0x62, 0x32, 0x34, 0x39, 0x65, 0x66, 0x34, 0x65, 0x38, 0x35, 0x63, 0x63, 0x34, 0x66, 0x33, 0x33, 0x31, 0x35, 0x33, 0x39, 0x35, 0x38, 0x39, 0x37, 0x36, 0x65, 0x38, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x33, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x66, 0x31, 0x36, 0x66, 0x64, 0x38, 0x64, 0x31, 0x35, 0x62, 0x33, 0x37, 0x38, 0x61, 0x30, 0x66, 0x62, 0x61, 0x33, 0x30, 0x36, 0x62, 0x38, 0x64, 0x30, 0x33, 0x64, 0x64, 0x39, 0x38, 0x66, 0x63, 0x39, 0x32, 0x36, 0x31, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x38, 0x62, 0x35, 0x32, 0x38, 0x36, 0x35, 0x65, 0x61, 0x35, 0x35, 0x64, 0x38, 0x30, 0x33, 0x36, 0x66, 0x32, 0x66, 0x61, 0x62, 0x32, 0x36, 0x30, 0x39, 0x38, 0x62, 0x33, 0x35, 0x32, 0x63, 0x61, 0x38, 0x33, 0x37, 0x65, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x36, 0x35, 0x38, 0x66, 0x62, 0x33, 0x36, 0x31, 0x65, 0x30, 0x34, 0x36, 0x64, 0x34, 0x66, 0x63, 0x61, 0x61, 0x38, 0x61, 0x65, 0x66, 0x36, 0x64, 0x30, 0x32, 0x61, 0x39, 0x39, 0x31, 0x31, 0x31, 0x32, 0x32, 0x33, 0x36, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x61, 0x34, 0x39, 0x38, 0x66, 0x30, 0x33, 0x62, 0x64, 0x37, 0x31, 0x37, 0x38, 0x62, 0x64, 0x38, 0x61, 0x37, 0x38, 0x39, 0x61, 0x30, 0x30, 0x66, 0x35, 0x32, 0x33, 0x37, 0x61, 0x66, 0x37, 0x39, 0x61, 0x33, 0x65, 0x33, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x34, 0x38, 0x66, 0x65, 0x38, 0x32, 0x36, 0x35, 0x64, 0x39, 0x61, 0x66, 0x35, 0x35, 0x65, 0x62, 0x37, 0x30, 0x30, 0x36, 0x62, 0x63, 0x33, 0x33, 0x35, 0x36, 0x34, 0x35, 0x62, 0x30, 0x61, 0x33, 0x61, 0x31, 0x38, 0x33, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x66, 0x39, 0x61, 0x31, 0x64, 0x34, 0x36, 0x35, 0x65, 0x37, 0x38, 0x62, 0x37, 0x30, 0x33, 0x39, 0x65, 0x33, 0x36, 0x39, 0x34, 0x34, 0x37, 0x38, 0x65, 0x32, 0x36, 0x32, 0x37, 0x62, 0x33, 0x36, 0x66, 0x63, 0x64, 0x31, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x62, 0x38, 0x34, 0x34, 0x30, 0x30, 0x35, 0x37, 0x30, 0x30, 0x36, 0x39, 0x61, 0x39, 0x35, 0x37, 0x33, 0x63, 0x61, 0x62, 0x30, 0x34, 0x62, 0x34, 0x65, 0x36, 0x62, 0x36, 0x39, 0x35, 0x33, 0x35, 0x65, 0x32, 0x30, 0x32, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x34, 0x63, 0x38, 0x39, 0x63, 0x35, 0x62, 0x64, 0x38, 0x65, 0x37, 0x64, 0x32, 0x32, 0x62, 0x63, 0x35, 0x37, 0x34, 0x62, 0x62, 0x33, 0x35, 0x65, 0x34, 0x38, 0x39, 0x35, 0x30, 0x32, 0x31, 0x31, 0x63, 0x36, 0x66, 0x37, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x39, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x33, 0x39, 0x36, 0x66, 0x34, 0x61, 0x32, 0x36, 0x63, 0x32, 0x62, 0x34, 0x36, 0x30, 0x34, 0x34, 0x39, 0x36, 0x33, 0x30, 0x36, 0x63, 0x35, 0x34, 0x34, 0x32, 0x65, 0x37, 0x66, 0x63, 0x62, 0x61, 0x32, 0x37, 0x32, 0x65, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x30, 0x39, 0x39, 0x34, 0x64, 0x62, 0x65, 0x35, 0x36, 0x61, 0x33, 0x61, 0x39, 0x35, 0x39, 0x32, 0x39, 0x37, 0x37, 0x34, 0x65, 0x32, 0x30, 0x65, 0x31, 0x66, 0x65, 0x35, 0x32, 0x35, 0x63, 0x66, 0x33, 0x37, 0x30, 0x34, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x37, 0x31, 0x63, 0x66, 0x37, 0x61, 0x64, 0x33, 0x30, 0x34, 0x65, 0x63, 0x61, 0x65, 0x65, 0x35, 0x39, 0x35, 0x37, 0x39, 0x32, 0x66, 0x34, 0x62, 0x62, 0x66, 0x61, 0x34, 0x38, 0x34, 0x34, 0x31, 0x38, 0x35, 0x34, 0x39, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x32, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x34, 0x32, 0x63, 0x36, 0x34, 0x34, 0x62, 0x61, 0x65, 0x32, 0x62, 0x39, 0x36, 0x66, 0x32, 0x35, 0x66, 0x39, 0x34, 0x64, 0x33, 0x31, 0x66, 0x36, 0x37, 0x38, 0x63, 0x39, 0x30, 0x64, 0x63, 0x39, 0x36, 0x36, 0x39, 0x30, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x32, 0x34, 0x62, 0x35, 0x39, 0x37, 0x38, 0x37, 0x33, 0x62, 0x62, 0x31, 0x34, 0x31, 0x62, 0x64, 0x62, 0x32, 0x33, 0x37, 0x65, 0x61, 0x38, 0x61, 0x35, 0x61, 0x62, 0x37, 0x34, 0x37, 0x37, 0x39, 0x39, 0x61, 0x66, 0x30, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x63, 0x38, 0x30, 0x32, 0x66, 0x38, 0x37, 0x37, 0x35, 0x38, 0x33, 0x34, 0x39, 0x66, 0x61, 0x30, 0x33, 0x65, 0x36, 0x62, 0x63, 0x32, 0x65, 0x32, 0x66, 0x64, 0x30, 0x37, 0x39, 0x31, 0x31, 0x39, 0x37, 0x65, 0x65, 0x61, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x37, 0x61, 0x38, 0x38, 0x39, 0x32, 0x31, 0x62, 0x35, 0x66, 0x63, 0x61, 0x31, 0x30, 0x65, 0x35, 0x62, 0x62, 0x39, 0x64, 0x65, 0x64, 0x36, 0x30, 0x30, 0x32, 0x35, 0x34, 0x33, 0x37, 0x61, 0x65, 0x32, 0x32, 0x31, 0x36, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x65, 0x34, 0x39, 0x64, 0x36, 0x38, 0x61, 0x64, 0x65, 0x64, 0x62, 0x30, 0x38, 0x31, 0x66, 0x64, 0x34, 0x33, 0x37, 0x30, 0x35, 0x61, 0x35, 0x66, 0x37, 0x38, 0x63, 0x37, 0x37, 0x38, 0x66, 0x62, 0x39, 0x30, 0x64, 0x65, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x65, 0x65, 0x39, 0x30, 0x31, 0x62, 0x34, 0x61, 0x63, 0x38, 0x62, 0x31, 0x35, 0x36, 0x63, 0x35, 0x65, 0x32, 0x66, 0x38, 0x61, 0x36, 0x66, 0x31, 0x62, 0x65, 0x66, 0x35, 0x37, 0x32, 0x61, 0x37, 0x64, 0x63, 0x65, 0x62, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x61, 0x66, 0x33, 0x31, 0x65, 0x36, 0x32, 0x32, 0x63, 0x30, 0x33, 0x64, 0x39, 0x65, 0x31, 0x38, 0x61, 0x30, 0x64, 0x64, 0x62, 0x38, 0x62, 0x65, 0x36, 0x30, 0x66, 0x62, 0x65, 0x33, 0x65, 0x36, 0x36, 0x31, 0x62, 0x65, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x61, 0x61, 0x35, 0x33, 0x38, 0x31, 0x62, 0x32, 0x31, 0x33, 0x38, 0x65, 0x62, 0x65, 0x66, 0x66, 0x63, 0x31, 0x39, 0x31, 0x64, 0x35, 0x64, 0x38, 0x63, 0x33, 0x39, 0x31, 0x37, 0x35, 0x33, 0x62, 0x37, 0x30, 0x39, 0x38, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x30, 0x30, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x34, 0x63, 0x30, 0x63, 0x36, 0x30, 0x66, 0x31, 0x30, 0x65, 0x64, 0x32, 0x38, 0x39, 0x34, 0x62, 0x64, 0x62, 0x34, 0x32, 0x64, 0x39, 0x64, 0x64, 0x31, 0x64, 0x32, 0x31, 0x30, 0x35, 0x38, 0x37, 0x38, 0x31, 0x30, 0x61, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x34, 0x66, 0x34, 0x61, 0x62, 0x35, 0x62, 0x63, 0x36, 0x30, 0x33, 0x39, 0x37, 0x63, 0x37, 0x33, 0x37, 0x65, 0x62, 0x30, 0x36, 0x38, 0x33, 0x33, 0x39, 0x31, 0x62, 0x36, 0x33, 0x33, 0x66, 0x38, 0x33, 0x63, 0x34, 0x38, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x62, 0x65, 0x66, 0x32, 0x37, 0x35, 0x36, 0x32, 0x34, 0x38, 0x66, 0x39, 0x61, 0x37, 0x61, 0x33, 0x38, 0x30, 0x66, 0x39, 0x31, 0x62, 0x30, 0x35, 0x31, 0x62, 0x61, 0x33, 0x62, 0x65, 0x32, 0x38, 0x61, 0x36, 0x34, 0x39, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x64, 0x39, 0x30, 0x39, 0x61, 0x63, 0x30, 0x64, 0x34, 0x61, 0x31, 0x31, 0x30, 0x32, 0x65, 0x63, 0x39, 0x38, 0x64, 0x63, 0x66, 0x32, 0x63, 0x63, 0x61, 0x39, 0x36, 0x61, 0x30, 0x61, 0x64, 0x63, 0x64, 0x37, 0x61, 0x39, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x63, 0x30, 0x33, 0x65, 0x30, 0x32, 0x65, 0x35, 0x38, 0x37, 0x62, 0x37, 0x37, 0x36, 0x39, 0x64, 0x65, 0x66, 0x35, 0x33, 0x38, 0x34, 0x31, 0x33, 0x65, 0x39, 0x37, 0x66, 0x37, 0x65, 0x35, 0x35, 0x62, 0x65, 0x37, 0x31, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x37, 0x34, 0x38, 0x30, 0x33, 0x66, 0x65, 0x31, 0x66, 0x33, 0x61, 0x30, 0x33, 0x36, 0x35, 0x65, 0x37, 0x39, 0x32, 0x32, 0x62, 0x31, 0x34, 0x32, 0x37, 0x30, 0x65, 0x61, 0x65, 0x62, 0x30, 0x33, 0x32, 0x63, 0x63, 0x31, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x32, 0x33, 0x31, 0x30, 0x31, 0x39, 0x31, 0x65, 0x61, 0x64, 0x38, 0x64, 0x33, 0x62, 0x63, 0x36, 0x34, 0x38, 0x39, 0x38, 0x37, 0x33, 0x61, 0x35, 0x66, 0x30, 0x63, 0x32, 0x65, 0x63, 0x36, 0x62, 0x38, 0x37, 0x65, 0x31, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x36, 0x37, 0x38, 0x61, 0x33, 0x63, 0x35, 0x37, 0x31, 0x35, 0x31, 0x61, 0x65, 0x62, 0x36, 0x38, 0x65, 0x66, 0x64, 0x63, 0x34, 0x33, 0x65, 0x66, 0x34, 0x64, 0x33, 0x36, 0x63, 0x62, 0x35, 0x39, 0x61, 0x30, 0x30, 0x39, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x38, 0x33, 0x66, 0x36, 0x30, 0x37, 0x61, 0x32, 0x31, 0x66, 0x63, 0x63, 0x32, 0x38, 0x31, 0x30, 0x30, 0x61, 0x30, 0x31, 0x38, 0x63, 0x35, 0x36, 0x38, 0x66, 0x66, 0x62, 0x65, 0x31, 0x34, 0x30, 0x33, 0x38, 0x30, 0x34, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x39, 0x31, 0x61, 0x39, 0x66, 0x65, 0x64, 0x34, 0x31, 0x62, 0x37, 0x64, 0x30, 0x65, 0x35, 0x63, 0x64, 0x32, 0x64, 0x38, 0x33, 0x31, 0x35, 0x38, 0x64, 0x33, 0x65, 0x38, 0x61, 0x34, 0x31, 0x61, 0x39, 0x61, 0x32, 0x64, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x30, 0x65, 0x35, 0x35, 0x39, 0x65, 0x32, 0x37, 0x34, 0x61, 0x61, 0x65, 0x66, 0x30, 0x63, 0x32, 0x35, 0x38, 0x39, 0x39, 0x38, 0x63, 0x39, 0x37, 0x39, 0x66, 0x36, 0x37, 0x31, 0x64, 0x31, 0x31, 0x37, 0x33, 0x62, 0x38, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x38, 0x61, 0x32, 0x62, 0x37, 0x63, 0x33, 0x33, 0x36, 0x66, 0x37, 0x38, 0x34, 0x37, 0x37, 0x39, 0x64, 0x38, 0x62, 0x35, 0x34, 0x64, 0x30, 0x32, 0x61, 0x38, 0x64, 0x33, 0x31, 0x64, 0x39, 0x61, 0x31, 0x33, 0x39, 0x63, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x39, 0x38, 0x66, 0x64, 0x66, 0x31, 0x66, 0x64, 0x63, 0x64, 0x38, 0x62, 0x61, 0x38, 0x66, 0x34, 0x63, 0x35, 0x62, 0x30, 0x34, 0x63, 0x33, 0x61, 0x65, 0x38, 0x35, 0x38, 0x37, 0x65, 0x66, 0x64, 0x66, 0x30, 0x66, 0x36, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x34, 0x66, 0x66, 0x34, 0x34, 0x61, 0x65, 0x66, 0x63, 0x31, 0x37, 0x62, 0x64, 0x32, 0x30, 0x65, 0x66, 0x64, 0x37, 0x61, 0x32, 0x30, 0x34, 0x63, 0x34, 0x37, 0x64, 0x31, 0x36, 0x32, 0x30, 0x63, 0x38, 0x36, 0x64, 0x62, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x38, 0x31, 0x31, 0x36, 0x62, 0x64, 0x30, 0x61, 0x66, 0x35, 0x35, 0x37, 0x30, 0x65, 0x61, 0x66, 0x30, 0x63, 0x35, 0x36, 0x63, 0x34, 0x39, 0x63, 0x37, 0x61, 0x62, 0x35, 0x65, 0x33, 0x37, 0x61, 0x35, 0x38, 0x30, 0x34, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x39, 0x38, 0x33, 0x35, 0x65, 0x34, 0x30, 0x34, 0x66, 0x62, 0x38, 0x36, 0x62, 0x66, 0x38, 0x34, 0x35, 0x66, 0x62, 0x61, 0x30, 0x39, 0x30, 0x64, 0x36, 0x62, 0x61, 0x32, 0x35, 0x65, 0x30, 0x63, 0x38, 0x38, 0x36, 0x36, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x65, 0x37, 0x32, 0x30, 0x31, 0x66, 0x66, 0x36, 0x31, 0x39, 0x66, 0x61, 0x66, 0x66, 0x63, 0x33, 0x33, 0x32, 0x65, 0x36, 0x61, 0x64, 0x33, 0x37, 0x65, 0x64, 0x34, 0x31, 0x65, 0x33, 0x30, 0x31, 0x62, 0x66, 0x30, 0x31, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x36, 0x39, 0x30, 0x36, 0x62, 0x36, 0x62, 0x64, 0x34, 0x39, 0x37, 0x32, 0x65, 0x33, 0x63, 0x37, 0x31, 0x36, 0x35, 0x35, 0x65, 0x30, 0x34, 0x62, 0x61, 0x66, 0x33, 0x36, 0x32, 0x36, 0x30, 0x63, 0x37, 0x63, 0x62, 0x31, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x34, 0x62, 0x63, 0x38, 0x33, 0x62, 0x30, 0x65, 0x36, 0x62, 0x61, 0x61, 0x64, 0x62, 0x31, 0x31, 0x35, 0x36, 0x63, 0x35, 0x63, 0x66, 0x30, 0x36, 0x65, 0x30, 0x66, 0x37, 0x32, 0x31, 0x38, 0x30, 0x38, 0x63, 0x35, 0x32, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x35, 0x38, 0x31, 0x34, 0x38, 0x61, 0x32, 0x65, 0x30, 0x66, 0x33, 0x65, 0x39, 0x32, 0x64, 0x63, 0x32, 0x63, 0x65, 0x33, 0x38, 0x66, 0x65, 0x62, 0x63, 0x32, 0x30, 0x31, 0x30, 0x37, 0x65, 0x33, 0x32, 0x35, 0x33, 0x63, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x36, 0x61, 0x33, 0x32, 0x32, 0x61, 0x36, 0x64, 0x34, 0x36, 0x39, 0x39, 0x38, 0x31, 0x34, 0x32, 0x36, 0x61, 0x65, 0x38, 0x34, 0x34, 0x38, 0x36, 0x35, 0x64, 0x37, 0x65, 0x65, 0x30, 0x62, 0x62, 0x31, 0x35, 0x63, 0x37, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x66, 0x32, 0x39, 0x65, 0x38, 0x37, 0x32, 0x37, 0x61, 0x37, 0x34, 0x63, 0x36, 0x62, 0x34, 0x33, 0x30, 0x31, 0x65, 0x33, 0x66, 0x66, 0x66, 0x66, 0x30, 0x36, 0x38, 0x37, 0x63, 0x31, 0x62, 0x38, 0x37, 0x30, 0x64, 0x61, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x39, 0x31, 0x38, 0x61, 0x61, 0x30, 0x39, 0x65, 0x37, 0x64, 0x34, 0x39, 0x34, 0x65, 0x39, 0x38, 0x66, 0x66, 0x61, 0x35, 0x64, 0x62, 0x35, 0x30, 0x33, 0x35, 0x30, 0x38, 0x39, 0x32, 0x66, 0x37, 0x31, 0x35, 0x36, 0x61, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x35, 0x66, 0x38, 0x35, 0x30, 0x38, 0x64, 0x61, 0x30, 0x65, 0x62, 0x65, 0x62, 0x62, 0x39, 0x30, 0x62, 0x65, 0x39, 0x30, 0x33, 0x33, 0x62, 0x64, 0x34, 0x64, 0x39, 0x65, 0x32, 0x37, 0x34, 0x31, 0x30, 0x35, 0x61, 0x65, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x63, 0x32, 0x35, 0x65, 0x37, 0x65, 0x30, 0x30, 0x63, 0x61, 0x34, 0x66, 0x36, 0x30, 0x61, 0x39, 0x66, 0x65, 0x36, 0x66, 0x32, 0x38, 0x64, 0x31, 0x66, 0x64, 0x65, 0x33, 0x35, 0x34, 0x32, 0x65, 0x32, 0x64, 0x31, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x30, 0x39, 0x34, 0x66, 0x33, 0x39, 0x35, 0x31, 0x66, 0x66, 0x63, 0x39, 0x37, 0x37, 0x31, 0x64, 0x63, 0x65, 0x64, 0x32, 0x33, 0x61, 0x64, 0x61, 0x30, 0x38, 0x30, 0x62, 0x63, 0x61, 0x66, 0x39, 0x63, 0x37, 0x63, 0x63, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x66, 0x37, 0x65, 0x38, 0x36, 0x65, 0x33, 0x38, 0x31, 0x65, 0x63, 0x35, 0x31, 0x65, 0x63, 0x34, 0x39, 0x30, 0x36, 0x64, 0x31, 0x34, 0x37, 0x36, 0x63, 0x62, 0x61, 0x39, 0x37, 0x61, 0x33, 0x64, 0x62, 0x35, 0x38, 0x34, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x36, 0x39, 0x36, 0x62, 0x37, 0x33, 0x39, 0x31, 0x36, 0x62, 0x64, 0x33, 0x30, 0x33, 0x33, 0x65, 0x30, 0x35, 0x35, 0x32, 0x31, 0x65, 0x33, 0x32, 0x31, 0x31, 0x64, 0x66, 0x65, 0x63, 0x30, 0x32, 0x36, 0x65, 0x39, 0x38, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x37, 0x66, 0x37, 0x30, 0x33, 0x37, 0x38, 0x37, 0x37, 0x35, 0x35, 0x38, 0x39, 0x66, 0x63, 0x36, 0x36, 0x61, 0x38, 0x31, 0x64, 0x33, 0x66, 0x36, 0x35, 0x33, 0x65, 0x39, 0x35, 0x34, 0x66, 0x35, 0x35, 0x35, 0x36, 0x30, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x35, 0x36, 0x31, 0x33, 0x32, 0x33, 0x36, 0x66, 0x33, 0x35, 0x38, 0x34, 0x32, 0x31, 0x36, 0x61, 0x64, 0x37, 0x35, 0x63, 0x35, 0x64, 0x33, 0x65, 0x30, 0x37, 0x65, 0x33, 0x66, 0x61, 0x36, 0x38, 0x36, 0x33, 0x61, 0x37, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x62, 0x31, 0x34, 0x35, 0x34, 0x62, 0x35, 0x37, 0x33, 0x38, 0x30, 0x35, 0x63, 0x38, 0x61, 0x63, 0x61, 0x33, 0x37, 0x65, 0x64, 0x65, 0x63, 0x37, 0x31, 0x34, 0x39, 0x61, 0x34, 0x31, 0x66, 0x36, 0x31, 0x32, 0x30, 0x32, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x39, 0x39, 0x39, 0x39, 0x61, 0x32, 0x34, 0x39, 0x30, 0x64, 0x39, 0x34, 0x39, 0x34, 0x61, 0x35, 0x33, 0x30, 0x63, 0x61, 0x65, 0x34, 0x64, 0x61, 0x66, 0x33, 0x38, 0x35, 0x35, 0x34, 0x66, 0x34, 0x64, 0x64, 0x36, 0x33, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x30, 0x34, 0x63, 0x65, 0x66, 0x63, 0x66, 0x62, 0x31, 0x33, 0x33, 0x31, 0x65, 0x63, 0x37, 0x61, 0x37, 0x38, 0x33, 0x38, 0x38, 0x62, 0x32, 0x39, 0x33, 0x39, 0x33, 0x65, 0x38, 0x35, 0x63, 0x31, 0x61, 0x66, 0x37, 0x39, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x34, 0x61, 0x63, 0x66, 0x63, 0x33, 0x36, 0x65, 0x64, 0x36, 0x30, 0x39, 0x34, 0x61, 0x32, 0x37, 0x65, 0x31, 0x31, 0x38, 0x65, 0x63, 0x63, 0x39, 0x31, 0x31, 0x63, 0x64, 0x34, 0x37, 0x33, 0x65, 0x38, 0x66, 0x62, 0x39, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x37, 0x35, 0x62, 0x30, 0x37, 0x37, 0x66, 0x63, 0x62, 0x34, 0x63, 0x63, 0x38, 0x65, 0x66, 0x63, 0x62, 0x66, 0x38, 0x33, 0x38, 0x34, 0x35, 0x39, 0x62, 0x36, 0x66, 0x61, 0x32, 0x34, 0x33, 0x61, 0x34, 0x31, 0x35, 0x39, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x34, 0x30, 0x35, 0x63, 0x66, 0x36, 0x39, 0x37, 0x39, 0x35, 0x36, 0x31, 0x33, 0x38, 0x30, 0x36, 0x35, 0x65, 0x31, 0x31, 0x63, 0x35, 0x66, 0x37, 0x35, 0x35, 0x39, 0x65, 0x36, 0x37, 0x32, 0x34, 0x35, 0x62, 0x64, 0x31, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x66, 0x64, 0x65, 0x38, 0x35, 0x35, 0x38, 0x36, 0x34, 0x63, 0x32, 0x35, 0x39, 0x38, 0x64, 0x61, 0x33, 0x63, 0x61, 0x66, 0x63, 0x30, 0x35, 0x61, 0x64, 0x39, 0x38, 0x64, 0x66, 0x32, 0x38, 0x39, 0x38, 0x65, 0x38, 0x30, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x31, 0x37, 0x39, 0x32, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x66, 0x37, 0x31, 0x31, 0x65, 0x34, 0x33, 0x61, 0x31, 0x33, 0x39, 0x31, 0x38, 0x66, 0x31, 0x33, 0x30, 0x33, 0x65, 0x38, 0x31, 0x64, 0x30, 0x65, 0x61, 0x37, 0x38, 0x63, 0x39, 0x65, 0x65, 0x66, 0x64, 0x36, 0x37, 0x65, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x31, 0x34, 0x38, 0x39, 0x31, 0x39, 0x39, 0x39, 0x61, 0x36, 0x35, 0x63, 0x39, 0x65, 0x66, 0x37, 0x33, 0x33, 0x30, 0x38, 0x65, 0x66, 0x65, 0x33, 0x31, 0x30, 0x30, 0x63, 0x61, 0x31, 0x62, 0x32, 0x30, 0x65, 0x38, 0x31, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x63, 0x66, 0x39, 0x63, 0x64, 0x61, 0x66, 0x39, 0x32, 0x66, 0x63, 0x39, 0x39, 0x39, 0x63, 0x63, 0x35, 0x65, 0x66, 0x62, 0x62, 0x37, 0x32, 0x30, 0x33, 0x63, 0x36, 0x31, 0x65, 0x34, 0x66, 0x31, 0x63, 0x64, 0x64, 0x34, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x62, 0x61, 0x38, 0x61, 0x33, 0x66, 0x30, 0x33, 0x66, 0x30, 0x38, 0x62, 0x38, 0x39, 0x35, 0x30, 0x39, 0x35, 0x39, 0x39, 0x34, 0x64, 0x64, 0x61, 0x36, 0x31, 0x39, 0x65, 0x64, 0x61, 0x61, 0x63, 0x65, 0x65, 0x33, 0x65, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x62, 0x36, 0x64, 0x36, 0x35, 0x63, 0x62, 0x30, 0x30, 0x62, 0x37, 0x62, 0x33, 0x36, 0x65, 0x31, 0x66, 0x62, 0x35, 0x65, 0x64, 0x33, 0x36, 0x33, 0x32, 0x63, 0x34, 0x63, 0x62, 0x32, 0x30, 0x61, 0x38, 0x39, 0x34, 0x31, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x39, 0x61, 0x65, 0x65, 0x34, 0x34, 0x34, 0x62, 0x35, 0x37, 0x38, 0x33, 0x63, 0x30, 0x39, 0x33, 0x63, 0x66, 0x66, 0x66, 0x64, 0x31, 0x63, 0x34, 0x36, 0x33, 0x32, 0x63, 0x66, 0x39, 0x33, 0x63, 0x36, 0x66, 0x30, 0x35, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x34, 0x31, 0x33, 0x31, 0x34, 0x61, 0x30, 0x62, 0x34, 0x30, 0x38, 0x65, 0x39, 0x35, 0x61, 0x36, 0x39, 0x34, 0x34, 0x34, 0x34, 0x39, 0x37, 0x37, 0x37, 0x31, 0x32, 0x61, 0x35, 0x30, 0x37, 0x31, 0x33, 0x35, 0x39, 0x31, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x33, 0x34, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x39, 0x36, 0x64, 0x63, 0x61, 0x33, 0x34, 0x31, 0x30, 0x38, 0x30, 0x38, 0x35, 0x62, 0x63, 0x66, 0x30, 0x34, 0x61, 0x65, 0x37, 0x32, 0x62, 0x39, 0x34, 0x35, 0x37, 0x34, 0x61, 0x31, 0x33, 0x65, 0x31, 0x61, 0x33, 0x65, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x64, 0x66, 0x30, 0x35, 0x62, 0x61, 0x64, 0x34, 0x36, 0x63, 0x33, 0x66, 0x30, 0x30, 0x61, 0x65, 0x34, 0x37, 0x36, 0x65, 0x63, 0x66, 0x30, 0x31, 0x37, 0x62, 0x62, 0x38, 0x63, 0x38, 0x37, 0x37, 0x33, 0x38, 0x33, 0x66, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x32, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x35, 0x39, 0x62, 0x32, 0x31, 0x63, 0x64, 0x30, 0x65, 0x32, 0x37, 0x34, 0x38, 0x38, 0x30, 0x34, 0x64, 0x39, 0x61, 0x62, 0x65, 0x30, 0x36, 0x34, 0x65, 0x61, 0x63, 0x32, 0x62, 0x65, 0x66, 0x30, 0x63, 0x39, 0x35, 0x66, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x39, 0x66, 0x35, 0x62, 0x37, 0x63, 0x31, 0x39, 0x33, 0x30, 0x64, 0x39, 0x66, 0x39, 0x37, 0x61, 0x31, 0x31, 0x35, 0x65, 0x30, 0x36, 0x37, 0x30, 0x36, 0x36, 0x66, 0x30, 0x62, 0x35, 0x34, 0x64, 0x62, 0x34, 0x34, 0x62, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x38, 0x63, 0x31, 0x36, 0x31, 0x34, 0x34, 0x39, 0x33, 0x33, 0x31, 0x39, 0x37, 0x63, 0x61, 0x63, 0x32, 0x36, 0x35, 0x30, 0x34, 0x64, 0x64, 0x37, 0x36, 0x65, 0x30, 0x36, 0x66, 0x64, 0x36, 0x36, 0x30, 0x30, 0x63, 0x37, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x65, 0x33, 0x63, 0x35, 0x32, 0x61, 0x39, 0x32, 0x63, 0x33, 0x30, 0x33, 0x39, 0x36, 0x61, 0x34, 0x65, 0x33, 0x33, 0x61, 0x35, 0x30, 0x31, 0x37, 0x30, 0x64, 0x63, 0x39, 0x30, 0x30, 0x66, 0x63, 0x66, 0x38, 0x63, 0x39, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x36, 0x66, 0x36, 0x39, 0x63, 0x65, 0x65, 0x34, 0x66, 0x61, 0x61, 0x30, 0x61, 0x36, 0x33, 0x62, 0x33, 0x30, 0x61, 0x65, 0x31, 0x65, 0x37, 0x38, 0x38, 0x31, 0x66, 0x34, 0x66, 0x37, 0x31, 0x35, 0x36, 0x35, 0x37, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x30, 0x30, 0x30, 0x37, 0x62, 0x30, 0x39, 0x36, 0x30, 0x64, 0x30, 0x30, 0x39, 0x30, 0x38, 0x61, 0x39, 0x34, 0x34, 0x33, 0x32, 0x61, 0x37, 0x33, 0x37, 0x35, 0x35, 0x37, 0x38, 0x37, 0x36, 0x61, 0x61, 0x63, 0x37, 0x63, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x66, 0x63, 0x31, 0x35, 0x65, 0x34, 0x38, 0x37, 0x62, 0x31, 0x62, 0x65, 0x64, 0x61, 0x30, 0x61, 0x38, 0x64, 0x31, 0x33, 0x32, 0x35, 0x62, 0x64, 0x62, 0x34, 0x31, 0x37, 0x32, 0x32, 0x34, 0x30, 0x64, 0x63, 0x35, 0x34, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x61, 0x62, 0x30, 0x61, 0x33, 0x65, 0x38, 0x33, 0x64, 0x30, 0x63, 0x38, 0x61, 0x63, 0x39, 0x33, 0x36, 0x36, 0x39, 0x31, 0x30, 0x35, 0x32, 0x30, 0x65, 0x61, 0x62, 0x31, 0x37, 0x37, 0x32, 0x62, 0x61, 0x63, 0x33, 0x62, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x39, 0x35, 0x61, 0x30, 0x65, 0x62, 0x34, 0x61, 0x34, 0x33, 0x37, 0x32, 0x37, 0x32, 0x32, 0x66, 0x63, 0x62, 0x63, 0x35, 0x61, 0x66, 0x65, 0x36, 0x39, 0x33, 0x36, 0x66, 0x32, 0x38, 0x39, 0x63, 0x38, 0x38, 0x61, 0x34, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x65, 0x66, 0x65, 0x32, 0x39, 0x36, 0x61, 0x65, 0x37, 0x36, 0x63, 0x38, 0x36, 0x30, 0x64, 0x31, 0x63, 0x35, 0x66, 0x62, 0x64, 0x33, 0x33, 0x64, 0x34, 0x37, 0x65, 0x38, 0x63, 0x65, 0x39, 0x39, 0x39, 0x36, 0x64, 0x31, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x64, 0x64, 0x33, 0x35, 0x35, 0x65, 0x36, 0x33, 0x34, 0x65, 0x65, 0x39, 0x39, 0x32, 0x37, 0x65, 0x34, 0x62, 0x37, 0x66, 0x36, 0x63, 0x39, 0x37, 0x65, 0x37, 0x62, 0x66, 0x33, 0x61, 0x32, 0x66, 0x31, 0x65, 0x36, 0x38, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x62, 0x34, 0x61, 0x62, 0x32, 0x63, 0x39, 0x34, 0x32, 0x37, 0x61, 0x39, 0x30, 0x31, 0x35, 0x65, 0x66, 0x36, 0x65, 0x65, 0x66, 0x66, 0x66, 0x35, 0x65, 0x64, 0x62, 0x36, 0x30, 0x31, 0x33, 0x39, 0x62, 0x37, 0x31, 0x39, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x35, 0x62, 0x65, 0x32, 0x65, 0x31, 0x32, 0x66, 0x36, 0x32, 0x39, 0x65, 0x36, 0x33, 0x34, 0x39, 0x62, 0x39, 0x37, 0x64, 0x32, 0x31, 0x62, 0x36, 0x32, 0x61, 0x31, 0x37, 0x62, 0x37, 0x63, 0x38, 0x33, 0x30, 0x65, 0x64, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x36, 0x31, 0x63, 0x39, 0x63, 0x31, 0x62, 0x37, 0x61, 0x33, 0x64, 0x38, 0x62, 0x35, 0x33, 0x62, 0x62, 0x61, 0x32, 0x30, 0x62, 0x33, 0x34, 0x34, 0x36, 0x36, 0x35, 0x34, 0x34, 0x62, 0x37, 0x62, 0x32, 0x31, 0x36, 0x36, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x61, 0x30, 0x38, 0x66, 0x64, 0x36, 0x66, 0x64, 0x31, 0x61, 0x63, 0x31, 0x37, 0x63, 0x65, 0x31, 0x35, 0x65, 0x64, 0x35, 0x37, 0x65, 0x65, 0x66, 0x62, 0x31, 0x32, 0x61, 0x32, 0x62, 0x65, 0x32, 0x38, 0x31, 0x38, 0x38, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x30, 0x34, 0x39, 0x33, 0x31, 0x31, 0x31, 0x30, 0x31, 0x64, 0x38, 0x31, 0x37, 0x65, 0x66, 0x62, 0x31, 0x64, 0x36, 0x35, 0x39, 0x31, 0x30, 0x66, 0x36, 0x36, 0x33, 0x36, 0x36, 0x32, 0x61, 0x36, 0x39, 0x39, 0x63, 0x39, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x35, 0x31, 0x31, 0x38, 0x33, 0x32, 0x39, 0x31, 0x38, 0x64, 0x38, 0x30, 0x33, 0x34, 0x61, 0x37, 0x62, 0x65, 0x65, 0x37, 0x32, 0x65, 0x66, 0x32, 0x62, 0x66, 0x65, 0x65, 0x34, 0x34, 0x30, 0x65, 0x63, 0x62, 0x62, 0x63, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x37, 0x63, 0x32, 0x33, 0x34, 0x66, 0x66, 0x37, 0x61, 0x63, 0x63, 0x61, 0x63, 0x65, 0x33, 0x64, 0x39, 0x39, 0x36, 0x37, 0x30, 0x38, 0x66, 0x38, 0x66, 0x39, 0x62, 0x30, 0x34, 0x39, 0x37, 0x30, 0x66, 0x39, 0x37, 0x64, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x36, 0x31, 0x31, 0x37, 0x31, 0x66, 0x35, 0x33, 0x34, 0x32, 0x62, 0x31, 0x37, 0x33, 0x64, 0x64, 0x37, 0x30, 0x65, 0x37, 0x62, 0x66, 0x65, 0x35, 0x62, 0x35, 0x63, 0x61, 0x32, 0x33, 0x38, 0x62, 0x31, 0x33, 0x62, 0x63, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x39, 0x37, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x62, 0x66, 0x36, 0x31, 0x62, 0x32, 0x64, 0x38, 0x37, 0x37, 0x66, 0x65, 0x31, 0x30, 0x36, 0x33, 0x35, 0x31, 0x32, 0x36, 0x33, 0x32, 0x36, 0x66, 0x61, 0x31, 0x38, 0x39, 0x65, 0x34, 0x62, 0x30, 0x62, 0x31, 0x63, 0x33, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x37, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x62, 0x36, 0x64, 0x38, 0x36, 0x62, 0x38, 0x33, 0x31, 0x34, 0x63, 0x32, 0x32, 0x64, 0x38, 0x64, 0x33, 0x37, 0x65, 0x61, 0x35, 0x31, 0x36, 0x64, 0x30, 0x30, 0x31, 0x39, 0x66, 0x31, 0x35, 0x36, 0x61, 0x61, 0x65, 0x31, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x33, 0x36, 0x33, 0x65, 0x30, 0x61, 0x62, 0x37, 0x34, 0x37, 0x65, 0x30, 0x32, 0x64, 0x31, 0x62, 0x33, 0x62, 0x36, 0x36, 0x61, 0x62, 0x62, 0x36, 0x39, 0x65, 0x61, 0x35, 0x33, 0x63, 0x37, 0x62, 0x61, 0x66, 0x35, 0x32, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x33, 0x65, 0x31, 0x31, 0x32, 0x30, 0x33, 0x37, 0x34, 0x39, 0x62, 0x31, 0x66, 0x61, 0x34, 0x66, 0x33, 0x32, 0x66, 0x65, 0x62, 0x62, 0x37, 0x31, 0x65, 0x34, 0x39, 0x64, 0x31, 0x33, 0x35, 0x39, 0x31, 0x39, 0x33, 0x38, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x35, 0x39, 0x39, 0x39, 0x61, 0x38, 0x39, 0x64, 0x32, 0x64, 0x64, 0x32, 0x38, 0x36, 0x64, 0x35, 0x61, 0x38, 0x30, 0x63, 0x36, 0x64, 0x65, 0x65, 0x37, 0x65, 0x38, 0x36, 0x61, 0x61, 0x64, 0x34, 0x30, 0x66, 0x39, 0x65, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x36, 0x64, 0x64, 0x33, 0x36, 0x35, 0x30, 0x65, 0x65, 0x34, 0x32, 0x38, 0x64, 0x63, 0x62, 0x37, 0x37, 0x35, 0x39, 0x35, 0x35, 0x33, 0x62, 0x30, 0x31, 0x37, 0x61, 0x39, 0x36, 0x61, 0x39, 0x34, 0x32, 0x38, 0x36, 0x61, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x66, 0x63, 0x31, 0x64, 0x36, 0x38, 0x38, 0x31, 0x61, 0x62, 0x66, 0x63, 0x62, 0x38, 0x62, 0x65, 0x63, 0x63, 0x30, 0x62, 0x62, 0x30, 0x32, 0x31, 0x62, 0x38, 0x62, 0x37, 0x33, 0x62, 0x37, 0x32, 0x33, 0x33, 0x64, 0x64, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x38, 0x33, 0x32, 0x61, 0x36, 0x62, 0x62, 0x32, 0x35, 0x35, 0x30, 0x33, 0x65, 0x65, 0x63, 0x61, 0x34, 0x33, 0x35, 0x62, 0x65, 0x33, 0x31, 0x62, 0x30, 0x62, 0x66, 0x39, 0x30, 0x35, 0x63, 0x61, 0x31, 0x66, 0x63, 0x66, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x37, 0x66, 0x64, 0x61, 0x37, 0x30, 0x37, 0x30, 0x62, 0x66, 0x33, 0x65, 0x65, 0x39, 0x62, 0x62, 0x64, 0x39, 0x61, 0x34, 0x31, 0x66, 0x35, 0x35, 0x63, 0x61, 0x64, 0x34, 0x38, 0x35, 0x34, 0x61, 0x65, 0x36, 0x63, 0x32, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x32, 0x37, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x30, 0x62, 0x64, 0x38, 0x61, 0x63, 0x66, 0x63, 0x62, 0x63, 0x35, 0x33, 0x61, 0x36, 0x30, 0x31, 0x30, 0x62, 0x34, 0x30, 0x64, 0x34, 0x64, 0x30, 0x38, 0x64, 0x64, 0x64, 0x32, 0x64, 0x39, 0x64, 0x36, 0x39, 0x36, 0x32, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x62, 0x36, 0x36, 0x38, 0x62, 0x33, 0x66, 0x31, 0x34, 0x64, 0x39, 0x32, 0x30, 0x65, 0x62, 0x63, 0x33, 0x37, 0x39, 0x30, 0x39, 0x32, 0x64, 0x62, 0x39, 0x38, 0x30, 0x33, 0x31, 0x62, 0x36, 0x37, 0x62, 0x32, 0x31, 0x39, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x31, 0x64, 0x38, 0x38, 0x39, 0x31, 0x36, 0x34, 0x34, 0x37, 0x39, 0x63, 0x65, 0x34, 0x33, 0x36, 0x65, 0x63, 0x65, 0x35, 0x31, 0x37, 0x36, 0x33, 0x65, 0x32, 0x32, 0x63, 0x64, 0x61, 0x31, 0x39, 0x62, 0x32, 0x32, 0x64, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x65, 0x32, 0x38, 0x64, 0x62, 0x35, 0x33, 0x63, 0x39, 0x30, 0x34, 0x34, 0x62, 0x34, 0x65, 0x63, 0x64, 0x34, 0x30, 0x35, 0x33, 0x66, 0x64, 0x31, 0x62, 0x34, 0x62, 0x31, 0x30, 0x64, 0x37, 0x30, 0x35, 0x36, 0x63, 0x36, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x37, 0x62, 0x30, 0x31, 0x61, 0x36, 0x65, 0x39, 0x31, 0x31, 0x66, 0x61, 0x39, 0x38, 0x38, 0x64, 0x30, 0x31, 0x61, 0x33, 0x61, 0x62, 0x33, 0x33, 0x36, 0x34, 0x36, 0x62, 0x65, 0x65, 0x66, 0x39, 0x63, 0x31, 0x33, 0x38, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x30, 0x36, 0x34, 0x66, 0x31, 0x64, 0x39, 0x34, 0x37, 0x34, 0x61, 0x62, 0x39, 0x31, 0x35, 0x64, 0x35, 0x36, 0x39, 0x30, 0x36, 0x63, 0x39, 0x66, 0x62, 0x33, 0x32, 0x30, 0x61, 0x32, 0x63, 0x37, 0x30, 0x39, 0x38, 0x63, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x33, 0x65, 0x64, 0x61, 0x64, 0x34, 0x38, 0x36, 0x34, 0x64, 0x61, 0x62, 0x36, 0x34, 0x63, 0x61, 0x65, 0x34, 0x63, 0x35, 0x34, 0x31, 0x37, 0x61, 0x37, 0x36, 0x37, 0x37, 0x34, 0x30, 0x35, 0x33, 0x64, 0x63, 0x36, 0x34, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x30, 0x39, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x64, 0x32, 0x63, 0x63, 0x36, 0x64, 0x30, 0x32, 0x35, 0x37, 0x38, 0x63, 0x36, 0x35, 0x66, 0x37, 0x33, 0x63, 0x35, 0x37, 0x35, 0x65, 0x37, 0x36, 0x63, 0x65, 0x38, 0x66, 0x62, 0x63, 0x66, 0x61, 0x64, 0x63, 0x66, 0x33, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x37, 0x31, 0x64, 0x66, 0x36, 0x30, 0x66, 0x30, 0x61, 0x65, 0x36, 0x36, 0x64, 0x63, 0x65, 0x39, 0x65, 0x38, 0x63, 0x38, 0x34, 0x65, 0x31, 0x37, 0x31, 0x34, 0x39, 0x66, 0x30, 0x39, 0x66, 0x39, 0x63, 0x35, 0x32, 0x66, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x65, 0x36, 0x36, 0x31, 0x64, 0x30, 0x62, 0x61, 0x37, 0x33, 0x64, 0x36, 0x63, 0x66, 0x32, 0x34, 0x30, 0x39, 0x39, 0x61, 0x35, 0x35, 0x36, 0x32, 0x62, 0x38, 0x30, 0x38, 0x66, 0x37, 0x62, 0x33, 0x36, 0x37, 0x33, 0x62, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x62, 0x30, 0x65, 0x65, 0x36, 0x62, 0x62, 0x38, 0x33, 0x37, 0x64, 0x33, 0x61, 0x34, 0x63, 0x34, 0x63, 0x35, 0x30, 0x31, 0x31, 0x63, 0x33, 0x61, 0x32, 0x32, 0x38, 0x63, 0x30, 0x65, 0x64, 0x61, 0x62, 0x34, 0x36, 0x33, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x33, 0x37, 0x35, 0x61, 0x66, 0x62, 0x66, 0x35, 0x39, 0x62, 0x33, 0x61, 0x31, 0x64, 0x36, 0x31, 0x61, 0x31, 0x62, 0x65, 0x33, 0x32, 0x64, 0x30, 0x37, 0x35, 0x65, 0x30, 0x65, 0x31, 0x35, 0x61, 0x34, 0x66, 0x62, 0x63, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x65, 0x39, 0x34, 0x37, 0x36, 0x62, 0x66, 0x65, 0x63, 0x64, 0x33, 0x35, 0x39, 0x31, 0x39, 0x36, 0x34, 0x64, 0x64, 0x33, 0x32, 0x35, 0x63, 0x66, 0x38, 0x63, 0x32, 0x61, 0x32, 0x34, 0x66, 0x61, 0x65, 0x64, 0x38, 0x32, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x34, 0x63, 0x38, 0x39, 0x30, 0x37, 0x62, 0x36, 0x30, 0x30, 0x32, 0x34, 0x38, 0x30, 0x35, 0x37, 0x62, 0x31, 0x65, 0x34, 0x36, 0x33, 0x35, 0x34, 0x62, 0x31, 0x39, 0x62, 0x64, 0x63, 0x38, 0x35, 0x39, 0x63, 0x39, 0x39, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x30, 0x34, 0x35, 0x36, 0x34, 0x39, 0x63, 0x64, 0x35, 0x33, 0x64, 0x63, 0x32, 0x33, 0x35, 0x34, 0x31, 0x66, 0x38, 0x65, 0x64, 0x34, 0x64, 0x33, 0x34, 0x31, 0x38, 0x31, 0x32, 0x38, 0x30, 0x38, 0x64, 0x35, 0x64, 0x64, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x65, 0x34, 0x38, 0x38, 0x63, 0x66, 0x32, 0x62, 0x35, 0x36, 0x37, 0x37, 0x39, 0x33, 0x33, 0x39, 0x37, 0x31, 0x66, 0x36, 0x34, 0x63, 0x62, 0x38, 0x32, 0x30, 0x32, 0x64, 0x64, 0x30, 0x35, 0x37, 0x35, 0x32, 0x61, 0x32, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x32, 0x35, 0x34, 0x38, 0x31, 0x66, 0x63, 0x64, 0x39, 0x63, 0x32, 0x32, 0x31, 0x66, 0x31, 0x61, 0x63, 0x37, 0x65, 0x35, 0x66, 0x64, 0x31, 0x65, 0x63, 0x64, 0x39, 0x33, 0x30, 0x37, 0x61, 0x31, 0x36, 0x32, 0x31, 0x35, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x31, 0x38, 0x38, 0x37, 0x38, 0x31, 0x38, 0x66, 0x39, 0x31, 0x34, 0x61, 0x32, 0x30, 0x65, 0x33, 0x31, 0x30, 0x37, 0x37, 0x32, 0x39, 0x30, 0x62, 0x38, 0x33, 0x37, 0x31, 0x35, 0x61, 0x36, 0x62, 0x32, 0x64, 0x36, 0x65, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x39, 0x34, 0x33, 0x37, 0x65, 0x61, 0x63, 0x66, 0x34, 0x33, 0x37, 0x38, 0x37, 0x38, 0x64, 0x63, 0x32, 0x39, 0x33, 0x64, 0x34, 0x38, 0x61, 0x33, 0x39, 0x63, 0x38, 0x37, 0x62, 0x37, 0x34, 0x32, 0x31, 0x61, 0x32, 0x31, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x31, 0x61, 0x31, 0x63, 0x32, 0x36, 0x63, 0x63, 0x36, 0x39, 0x39, 0x34, 0x63, 0x64, 0x64, 0x33, 0x63, 0x31, 0x34, 0x62, 0x65, 0x63, 0x65, 0x32, 0x37, 0x36, 0x66, 0x66, 0x66, 0x66, 0x34, 0x62, 0x39, 0x64, 0x66, 0x37, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x62, 0x39, 0x35, 0x36, 0x39, 0x36, 0x65, 0x38, 0x65, 0x63, 0x34, 0x35, 0x31, 0x30, 0x64, 0x35, 0x36, 0x38, 0x36, 0x38, 0x61, 0x37, 0x63, 0x31, 0x61, 0x37, 0x33, 0x35, 0x63, 0x36, 0x38, 0x62, 0x32, 0x34, 0x34, 0x38, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x37, 0x66, 0x33, 0x65, 0x65, 0x31, 0x39, 0x65, 0x39, 0x33, 0x38, 0x38, 0x62, 0x62, 0x62, 0x62, 0x32, 0x32, 0x31, 0x35, 0x63, 0x36, 0x32, 0x33, 0x39, 0x37, 0x62, 0x39, 0x36, 0x35, 0x36, 0x30, 0x31, 0x33, 0x32, 0x33, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x37, 0x61, 0x66, 0x63, 0x38, 0x34, 0x37, 0x37, 0x34, 0x31, 0x32, 0x32, 0x37, 0x34, 0x66, 0x63, 0x32, 0x36, 0x35, 0x64, 0x66, 0x31, 0x33, 0x63, 0x30, 0x35, 0x34, 0x34, 0x37, 0x33, 0x34, 0x32, 0x37, 0x64, 0x34, 0x33, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x30, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x30, 0x35, 0x30, 0x61, 0x35, 0x63, 0x66, 0x66, 0x61, 0x64, 0x65, 0x64, 0x62, 0x34, 0x62, 0x62, 0x36, 0x65, 0x61, 0x61, 0x66, 0x62, 0x63, 0x39, 0x65, 0x35, 0x30, 0x31, 0x33, 0x34, 0x32, 0x38, 0x65, 0x39, 0x36, 0x63, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x35, 0x38, 0x36, 0x65, 0x63, 0x35, 0x34, 0x35, 0x31, 0x37, 0x33, 0x35, 0x65, 0x65, 0x61, 0x61, 0x65, 0x62, 0x34, 0x37, 0x30, 0x64, 0x63, 0x38, 0x37, 0x33, 0x36, 0x61, 0x61, 0x65, 0x37, 0x35, 0x32, 0x66, 0x38, 0x32, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x30, 0x33, 0x39, 0x33, 0x37, 0x37, 0x65, 0x65, 0x64, 0x30, 0x63, 0x35, 0x37, 0x33, 0x66, 0x39, 0x38, 0x36, 0x63, 0x35, 0x65, 0x38, 0x61, 0x39, 0x35, 0x66, 0x62, 0x39, 0x39, 0x61, 0x35, 0x39, 0x65, 0x39, 0x33, 0x33, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x62, 0x31, 0x36, 0x31, 0x66, 0x65, 0x38, 0x37, 0x35, 0x66, 0x30, 0x39, 0x32, 0x39, 0x30, 0x61, 0x34, 0x62, 0x32, 0x36, 0x32, 0x62, 0x63, 0x36, 0x30, 0x31, 0x31, 0x30, 0x38, 0x34, 0x38, 0x66, 0x30, 0x64, 0x32, 0x32, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x35, 0x32, 0x61, 0x32, 0x63, 0x63, 0x30, 0x38, 0x36, 0x39, 0x64, 0x63, 0x39, 0x65, 0x39, 0x66, 0x38, 0x34, 0x32, 0x62, 0x64, 0x30, 0x39, 0x35, 0x37, 0x63, 0x34, 0x37, 0x61, 0x38, 0x65, 0x39, 0x62, 0x30, 0x63, 0x39, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x64, 0x32, 0x33, 0x35, 0x64, 0x35, 0x30, 0x38, 0x35, 0x64, 0x63, 0x37, 0x62, 0x30, 0x36, 0x38, 0x61, 0x36, 0x37, 0x63, 0x34, 0x31, 0x32, 0x36, 0x37, 0x37, 0x62, 0x30, 0x33, 0x65, 0x31, 0x38, 0x33, 0x36, 0x38, 0x38, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x35, 0x65, 0x61, 0x63, 0x34, 0x66, 0x31, 0x61, 0x64, 0x33, 0x66, 0x35, 0x38, 0x66, 0x30, 0x62, 0x64, 0x30, 0x32, 0x34, 0x64, 0x36, 0x38, 0x65, 0x61, 0x36, 0x30, 0x64, 0x62, 0x65, 0x30, 0x31, 0x63, 0x36, 0x61, 0x66, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x35, 0x38, 0x38, 0x30, 0x38, 0x38, 0x31, 0x36, 0x66, 0x64, 0x61, 0x61, 0x33, 0x61, 0x35, 0x66, 0x63, 0x39, 0x38, 0x65, 0x64, 0x34, 0x37, 0x63, 0x66, 0x61, 0x65, 0x36, 0x63, 0x31, 0x38, 0x33, 0x31, 0x35, 0x34, 0x32, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x34, 0x30, 0x63, 0x37, 0x62, 0x64, 0x37, 0x61, 0x38, 0x34, 0x34, 0x32, 0x64, 0x35, 0x62, 0x65, 0x65, 0x32, 0x31, 0x61, 0x32, 0x31, 0x38, 0x30, 0x61, 0x31, 0x63, 0x34, 0x65, 0x64, 0x66, 0x66, 0x31, 0x36, 0x34, 0x39, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x33, 0x39, 0x32, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x65, 0x64, 0x62, 0x62, 0x64, 0x32, 0x63, 0x61, 0x30, 0x33, 0x35, 0x37, 0x36, 0x35, 0x34, 0x61, 0x64, 0x30, 0x65, 0x61, 0x34, 0x37, 0x39, 0x33, 0x66, 0x38, 0x63, 0x35, 0x63, 0x65, 0x63, 0x64, 0x33, 0x30, 0x65, 0x32, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x39, 0x30, 0x36, 0x62, 0x30, 0x61, 0x65, 0x39, 0x61, 0x32, 0x38, 0x31, 0x35, 0x38, 0x65, 0x38, 0x61, 0x63, 0x35, 0x35, 0x30, 0x65, 0x33, 0x39, 0x64, 0x61, 0x30, 0x38, 0x36, 0x65, 0x65, 0x33, 0x31, 0x35, 0x37, 0x36, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x38, 0x30, 0x31, 0x30, 0x39, 0x33, 0x63, 0x31, 0x39, 0x63, 0x61, 0x39, 0x62, 0x38, 0x66, 0x33, 0x34, 0x32, 0x65, 0x33, 0x33, 0x63, 0x63, 0x39, 0x63, 0x37, 0x37, 0x62, 0x62, 0x64, 0x34, 0x63, 0x38, 0x33, 0x31, 0x32, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x35, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x36, 0x34, 0x38, 0x32, 0x65, 0x65, 0x36, 0x66, 0x31, 0x33, 0x38, 0x61, 0x37, 0x37, 0x38, 0x66, 0x65, 0x31, 0x61, 0x64, 0x36, 0x32, 0x62, 0x31, 0x38, 0x30, 0x63, 0x65, 0x38, 0x35, 0x36, 0x66, 0x62, 0x62, 0x32, 0x33, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x65, 0x64, 0x30, 0x64, 0x34, 0x61, 0x64, 0x31, 0x30, 0x64, 0x65, 0x30, 0x33, 0x34, 0x33, 0x35, 0x62, 0x31, 0x35, 0x33, 0x61, 0x30, 0x66, 0x63, 0x32, 0x35, 0x64, 0x65, 0x33, 0x62, 0x39, 0x33, 0x66, 0x34, 0x35, 0x32, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x65, 0x36, 0x37, 0x39, 0x39, 0x30, 0x65, 0x31, 0x62, 0x36, 0x64, 0x35, 0x32, 0x65, 0x31, 0x30, 0x35, 0x35, 0x66, 0x66, 0x65, 0x30, 0x34, 0x39, 0x63, 0x35, 0x33, 0x31, 0x39, 0x35, 0x61, 0x38, 0x31, 0x35, 0x34, 0x32, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x64, 0x32, 0x32, 0x32, 0x30, 0x39, 0x66, 0x66, 0x64, 0x30, 0x62, 0x38, 0x37, 0x35, 0x30, 0x39, 0x61, 0x64, 0x65, 0x33, 0x61, 0x38, 0x65, 0x32, 0x65, 0x66, 0x34, 0x32, 0x39, 0x38, 0x37, 0x39, 0x63, 0x62, 0x38, 0x39, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x36, 0x34, 0x34, 0x64, 0x34, 0x30, 0x65, 0x39, 0x30, 0x62, 0x63, 0x39, 0x37, 0x66, 0x65, 0x37, 0x64, 0x66, 0x65, 0x37, 0x63, 0x61, 0x62, 0x64, 0x33, 0x32, 0x36, 0x39, 0x66, 0x64, 0x35, 0x37, 0x39, 0x62, 0x61, 0x34, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x65, 0x31, 0x32, 0x39, 0x30, 0x38, 0x37, 0x37, 0x62, 0x35, 0x38, 0x33, 0x65, 0x33, 0x36, 0x31, 0x61, 0x32, 0x64, 0x34, 0x31, 0x62, 0x30, 0x30, 0x39, 0x33, 0x34, 0x36, 0x65, 0x36, 0x32, 0x37, 0x34, 0x65, 0x32, 0x35, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x33, 0x38, 0x36, 0x31, 0x32, 0x32, 0x36, 0x66, 0x66, 0x65, 0x63, 0x31, 0x32, 0x38, 0x39, 0x31, 0x38, 0x37, 0x66, 0x62, 0x38, 0x34, 0x61, 0x30, 0x38, 0x65, 0x63, 0x33, 0x65, 0x64, 0x30, 0x34, 0x33, 0x32, 0x36, 0x34, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x65, 0x30, 0x62, 0x64, 0x64, 0x30, 0x61, 0x32, 0x35, 0x39, 0x62, 0x62, 0x39, 0x63, 0x62, 0x30, 0x39, 0x64, 0x33, 0x66, 0x33, 0x37, 0x65, 0x35, 0x63, 0x64, 0x38, 0x62, 0x39, 0x64, 0x61, 0x63, 0x65, 0x61, 0x62, 0x66, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x62, 0x37, 0x37, 0x35, 0x38, 0x35, 0x63, 0x62, 0x33, 0x64, 0x35, 0x35, 0x61, 0x31, 0x39, 0x39, 0x61, 0x62, 0x32, 0x39, 0x31, 0x64, 0x33, 0x61, 0x31, 0x38, 0x63, 0x36, 0x38, 0x66, 0x65, 0x38, 0x39, 0x61, 0x38, 0x34, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x31, 0x32, 0x38, 0x31, 0x37, 0x33, 0x34, 0x38, 0x39, 0x35, 0x32, 0x38, 0x30, 0x31, 0x32, 0x65, 0x37, 0x36, 0x62, 0x34, 0x31, 0x61, 0x35, 0x65, 0x32, 0x38, 0x63, 0x36, 0x38, 0x62, 0x61, 0x34, 0x65, 0x33, 0x61, 0x39, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x38, 0x34, 0x39, 0x32, 0x34, 0x38, 0x38, 0x62, 0x61, 0x31, 0x61, 0x32, 0x39, 0x32, 0x33, 0x34, 0x32, 0x32, 0x34, 0x37, 0x62, 0x33, 0x31, 0x38, 0x35, 0x35, 0x61, 0x35, 0x35, 0x39, 0x30, 0x35, 0x66, 0x65, 0x66, 0x32, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x62, 0x35, 0x34, 0x63, 0x37, 0x32, 0x66, 0x64, 0x36, 0x36, 0x31, 0x30, 0x62, 0x66, 0x61, 0x34, 0x33, 0x36, 0x33, 0x33, 0x39, 0x37, 0x65, 0x30, 0x32, 0x30, 0x33, 0x38, 0x34, 0x62, 0x30, 0x32, 0x32, 0x62, 0x30, 0x63, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x30, 0x66, 0x36, 0x36, 0x61, 0x30, 0x65, 0x32, 0x36, 0x35, 0x37, 0x66, 0x66, 0x30, 0x61, 0x63, 0x34, 0x31, 0x39, 0x35, 0x66, 0x32, 0x66, 0x30, 0x36, 0x34, 0x63, 0x66, 0x32, 0x66, 0x61, 0x34, 0x62, 0x32, 0x34, 0x32, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x34, 0x33, 0x32, 0x65, 0x64, 0x32, 0x63, 0x36, 0x62, 0x37, 0x37, 0x37, 0x37, 0x61, 0x38, 0x38, 0x65, 0x38, 0x64, 0x34, 0x36, 0x64, 0x33, 0x38, 0x38, 0x65, 0x37, 0x30, 0x34, 0x37, 0x37, 0x66, 0x32, 0x30, 0x38, 0x63, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x39, 0x39, 0x35, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x62, 0x61, 0x31, 0x30, 0x66, 0x30, 0x64, 0x61, 0x32, 0x37, 0x32, 0x35, 0x64, 0x63, 0x37, 0x30, 0x34, 0x37, 0x33, 0x33, 0x65, 0x38, 0x37, 0x66, 0x35, 0x61, 0x35, 0x32, 0x34, 0x63, 0x61, 0x38, 0x38, 0x35, 0x31, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x38, 0x37, 0x66, 0x37, 0x66, 0x38, 0x64, 0x38, 0x63, 0x33, 0x38, 0x37, 0x32, 0x63, 0x31, 0x62, 0x35, 0x38, 0x36, 0x62, 0x63, 0x64, 0x37, 0x64, 0x30, 0x61, 0x65, 0x64, 0x62, 0x66, 0x37, 0x65, 0x37, 0x33, 0x32, 0x37, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x36, 0x62, 0x62, 0x64, 0x65, 0x66, 0x37, 0x36, 0x64, 0x34, 0x63, 0x61, 0x36, 0x30, 0x64, 0x33, 0x31, 0x36, 0x63, 0x30, 0x37, 0x66, 0x35, 0x64, 0x31, 0x61, 0x37, 0x38, 0x30, 0x65, 0x33, 0x62, 0x31, 0x36, 0x35, 0x66, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x61, 0x35, 0x38, 0x39, 0x64, 0x64, 0x39, 0x66, 0x34, 0x30, 0x37, 0x31, 0x64, 0x62, 0x62, 0x36, 0x66, 0x62, 0x61, 0x38, 0x39, 0x62, 0x33, 0x66, 0x35, 0x64, 0x35, 0x64, 0x61, 0x65, 0x37, 0x64, 0x39, 0x36, 0x63, 0x31, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x31, 0x38, 0x65, 0x66, 0x62, 0x34, 0x64, 0x62, 0x39, 0x38, 0x31, 0x63, 0x64, 0x64, 0x36, 0x61, 0x37, 0x39, 0x37, 0x66, 0x34, 0x62, 0x64, 0x34, 0x38, 0x63, 0x37, 0x63, 0x32, 0x36, 0x32, 0x39, 0x33, 0x63, 0x65, 0x62, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x38, 0x37, 0x64, 0x32, 0x33, 0x37, 0x31, 0x65, 0x66, 0x33, 0x37, 0x38, 0x39, 0x35, 0x37, 0x66, 0x62, 0x64, 0x30, 0x35, 0x62, 0x61, 0x32, 0x66, 0x31, 0x64, 0x36, 0x36, 0x39, 0x33, 0x31, 0x62, 0x30, 0x31, 0x65, 0x32, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x65, 0x66, 0x36, 0x34, 0x32, 0x36, 0x32, 0x31, 0x31, 0x39, 0x34, 0x39, 0x63, 0x63, 0x33, 0x37, 0x66, 0x34, 0x63, 0x37, 0x35, 0x65, 0x37, 0x38, 0x35, 0x30, 0x33, 0x36, 0x39, 0x64, 0x30, 0x63, 0x66, 0x35, 0x66, 0x34, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x39, 0x39, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x33, 0x61, 0x30, 0x62, 0x30, 0x64, 0x36, 0x62, 0x36, 0x61, 0x37, 0x31, 0x38, 0x66, 0x36, 0x66, 0x63, 0x30, 0x32, 0x39, 0x32, 0x61, 0x38, 0x32, 0x35, 0x64, 0x63, 0x39, 0x32, 0x34, 0x37, 0x61, 0x39, 0x30, 0x61, 0x35, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x31, 0x36, 0x64, 0x64, 0x35, 0x63, 0x33, 0x64, 0x31, 0x61, 0x32, 0x37, 0x31, 0x34, 0x33, 0x35, 0x38, 0x66, 0x65, 0x33, 0x37, 0x35, 0x32, 0x63, 0x61, 0x65, 0x35, 0x33, 0x64, 0x62, 0x61, 0x62, 0x32, 0x62, 0x65, 0x39, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x62, 0x37, 0x38, 0x33, 0x34, 0x65, 0x31, 0x37, 0x31, 0x64, 0x34, 0x31, 0x65, 0x30, 0x36, 0x39, 0x61, 0x37, 0x37, 0x39, 0x34, 0x37, 0x66, 0x63, 0x61, 0x38, 0x37, 0x36, 0x32, 0x32, 0x66, 0x30, 0x62, 0x61, 0x34, 0x65, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x64, 0x39, 0x31, 0x62, 0x30, 0x39, 0x35, 0x34, 0x63, 0x65, 0x64, 0x65, 0x32, 0x32, 0x31, 0x64, 0x36, 0x66, 0x32, 0x34, 0x63, 0x37, 0x39, 0x38, 0x35, 0x66, 0x63, 0x35, 0x39, 0x39, 0x36, 0x35, 0x66, 0x62, 0x39, 0x38, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x64, 0x30, 0x64, 0x38, 0x38, 0x37, 0x35, 0x34, 0x61, 0x63, 0x38, 0x34, 0x62, 0x38, 0x62, 0x32, 0x31, 0x62, 0x61, 0x39, 0x33, 0x64, 0x64, 0x32, 0x62, 0x66, 0x65, 0x63, 0x37, 0x32, 0x36, 0x32, 0x36, 0x66, 0x61, 0x62, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x35, 0x62, 0x34, 0x63, 0x63, 0x65, 0x30, 0x38, 0x35, 0x38, 0x35, 0x36, 0x64, 0x39, 0x65, 0x31, 0x66, 0x39, 0x66, 0x66, 0x33, 0x65, 0x37, 0x39, 0x39, 0x34, 0x32, 0x30, 0x32, 0x33, 0x33, 0x35, 0x39, 0x65, 0x35, 0x66, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x35, 0x36, 0x64, 0x31, 0x38, 0x30, 0x32, 0x39, 0x33, 0x35, 0x30, 0x65, 0x34, 0x37, 0x30, 0x34, 0x30, 0x38, 0x66, 0x31, 0x35, 0x66, 0x31, 0x61, 0x61, 0x33, 0x62, 0x65, 0x39, 0x66, 0x30, 0x34, 0x30, 0x61, 0x36, 0x37, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x64, 0x36, 0x34, 0x62, 0x34, 0x66, 0x33, 0x62, 0x62, 0x37, 0x38, 0x35, 0x30, 0x37, 0x32, 0x32, 0x62, 0x35, 0x38, 0x62, 0x34, 0x37, 0x38, 0x62, 0x61, 0x36, 0x39, 0x31, 0x33, 0x37, 0x35, 0x65, 0x32, 0x32, 0x34, 0x65, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x65, 0x34, 0x61, 0x30, 0x65, 0x35, 0x32, 0x62, 0x61, 0x63, 0x33, 0x65, 0x65, 0x34, 0x34, 0x65, 0x66, 0x65, 0x30, 0x39, 0x35, 0x34, 0x65, 0x37, 0x35, 0x33, 0x64, 0x34, 0x62, 0x38, 0x35, 0x64, 0x36, 0x34, 0x34, 0x65, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x61, 0x37, 0x39, 0x63, 0x38, 0x34, 0x39, 0x34, 0x35, 0x65, 0x34, 0x37, 0x61, 0x39, 0x63, 0x33, 0x34, 0x33, 0x38, 0x36, 0x38, 0x33, 0x64, 0x36, 0x62, 0x35, 0x38, 0x34, 0x32, 0x63, 0x66, 0x66, 0x37, 0x36, 0x38, 0x34, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x61, 0x63, 0x32, 0x65, 0x31, 0x62, 0x66, 0x33, 0x33, 0x32, 0x30, 0x35, 0x62, 0x30, 0x35, 0x35, 0x33, 0x33, 0x36, 0x39, 0x31, 0x61, 0x30, 0x32, 0x32, 0x36, 0x37, 0x65, 0x65, 0x31, 0x39, 0x63, 0x64, 0x38, 0x31, 0x38, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x39, 0x39, 0x32, 0x35, 0x32, 0x31, 0x65, 0x63, 0x38, 0x35, 0x32, 0x33, 0x37, 0x30, 0x38, 0x34, 0x38, 0x61, 0x64, 0x36, 0x39, 0x37, 0x63, 0x63, 0x32, 0x64, 0x66, 0x36, 0x34, 0x65, 0x36, 0x33, 0x63, 0x63, 0x30, 0x36, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x61, 0x66, 0x30, 0x65, 0x65, 0x31, 0x31, 0x38, 0x34, 0x34, 0x33, 0x63, 0x39, 0x62, 0x33, 0x37, 0x64, 0x32, 0x66, 0x65, 0x61, 0x64, 0x37, 0x37, 0x66, 0x35, 0x65, 0x35, 0x32, 0x31, 0x64, 0x65, 0x62, 0x65, 0x31, 0x35, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x64, 0x62, 0x64, 0x62, 0x39, 0x65, 0x66, 0x64, 0x35, 0x65, 0x63, 0x31, 0x62, 0x33, 0x37, 0x38, 0x36, 0x65, 0x30, 0x36, 0x37, 0x31, 0x65, 0x62, 0x32, 0x32, 0x37, 0x39, 0x62, 0x32, 0x35, 0x33, 0x66, 0x32, 0x31, 0x35, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x39, 0x63, 0x30, 0x61, 0x37, 0x32, 0x63, 0x37, 0x36, 0x37, 0x61, 0x33, 0x61, 0x36, 0x35, 0x63, 0x65, 0x64, 0x30, 0x65, 0x31, 0x63, 0x61, 0x38, 0x38, 0x35, 0x61, 0x34, 0x63, 0x35, 0x31, 0x66, 0x64, 0x39, 0x62, 0x37, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x31, 0x32, 0x37, 0x36, 0x35, 0x31, 0x33, 0x62, 0x36, 0x66, 0x63, 0x36, 0x38, 0x36, 0x32, 0x38, 0x61, 0x37, 0x34, 0x31, 0x38, 0x35, 0x63, 0x32, 0x65, 0x32, 0x30, 0x63, 0x62, 0x62, 0x63, 0x61, 0x37, 0x38, 0x31, 0x37, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x64, 0x31, 0x32, 0x63, 0x35, 0x65, 0x64, 0x34, 0x66, 0x61, 0x38, 0x32, 0x37, 0x65, 0x32, 0x31, 0x35, 0x30, 0x63, 0x66, 0x61, 0x30, 0x64, 0x36, 0x38, 0x63, 0x30, 0x61, 0x61, 0x33, 0x37, 0x62, 0x31, 0x37, 0x36, 0x39, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x63, 0x30, 0x66, 0x65, 0x66, 0x36, 0x39, 0x38, 0x36, 0x63, 0x66, 0x62, 0x32, 0x65, 0x34, 0x30, 0x34, 0x31, 0x66, 0x39, 0x39, 0x37, 0x39, 0x64, 0x39, 0x39, 0x34, 0x30, 0x62, 0x36, 0x39, 0x64, 0x66, 0x66, 0x33, 0x64, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x39, 0x38, 0x63, 0x37, 0x39, 0x38, 0x38, 0x65, 0x66, 0x61, 0x30, 0x38, 0x65, 0x39, 0x32, 0x35, 0x65, 0x66, 0x39, 0x63, 0x39, 0x39, 0x34, 0x35, 0x35, 0x32, 0x30, 0x33, 0x32, 0x36, 0x65, 0x39, 0x66, 0x34, 0x33, 0x62, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x38, 0x66, 0x31, 0x66, 0x64, 0x63, 0x61, 0x62, 0x37, 0x66, 0x62, 0x65, 0x63, 0x39, 0x61, 0x36, 0x61, 0x33, 0x66, 0x63, 0x63, 0x35, 0x30, 0x37, 0x36, 0x31, 0x39, 0x36, 0x30, 0x30, 0x35, 0x30, 0x35, 0x63, 0x33, 0x36, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x32, 0x30, 0x61, 0x61, 0x33, 0x35, 0x34, 0x36, 0x35, 0x62, 0x65, 0x36, 0x31, 0x37, 0x61, 0x64, 0x32, 0x34, 0x39, 0x38, 0x66, 0x33, 0x37, 0x30, 0x64, 0x65, 0x30, 0x61, 0x33, 0x63, 0x63, 0x34, 0x64, 0x32, 0x33, 0x30, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x33, 0x32, 0x64, 0x31, 0x66, 0x39, 0x37, 0x34, 0x32, 0x65, 0x64, 0x66, 0x38, 0x64, 0x64, 0x39, 0x32, 0x37, 0x64, 0x61, 0x33, 0x35, 0x33, 0x62, 0x32, 0x61, 0x65, 0x37, 0x62, 0x34, 0x63, 0x62, 0x63, 0x65, 0x37, 0x35, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x61, 0x35, 0x66, 0x35, 0x38, 0x37, 0x39, 0x32, 0x62, 0x38, 0x63, 0x36, 0x32, 0x64, 0x32, 0x61, 0x66, 0x35, 0x35, 0x36, 0x37, 0x31, 0x37, 0x65, 0x65, 0x33, 0x65, 0x65, 0x33, 0x30, 0x32, 0x38, 0x62, 0x65, 0x34, 0x64, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x66, 0x38, 0x36, 0x66, 0x31, 0x65, 0x32, 0x66, 0x32, 0x62, 0x38, 0x30, 0x33, 0x32, 0x61, 0x39, 0x35, 0x63, 0x34, 0x64, 0x37, 0x37, 0x33, 0x38, 0x61, 0x31, 0x30, 0x39, 0x64, 0x33, 0x64, 0x30, 0x65, 0x64, 0x38, 0x31, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x63, 0x32, 0x66, 0x30, 0x66, 0x66, 0x31, 0x36, 0x31, 0x32, 0x65, 0x34, 0x61, 0x31, 0x63, 0x33, 0x34, 0x36, 0x64, 0x35, 0x33, 0x33, 0x38, 0x32, 0x61, 0x62, 0x66, 0x36, 0x64, 0x38, 0x61, 0x32, 0x35, 0x62, 0x61, 0x61, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x61, 0x31, 0x62, 0x64, 0x37, 0x61, 0x39, 0x31, 0x34, 0x38, 0x66, 0x62, 0x38, 0x36, 0x35, 0x63, 0x64, 0x36, 0x31, 0x32, 0x64, 0x64, 0x33, 0x35, 0x66, 0x31, 0x36, 0x32, 0x38, 0x36, 0x31, 0x64, 0x30, 0x66, 0x33, 0x62, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x36, 0x36, 0x32, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x36, 0x39, 0x63, 0x36, 0x30, 0x61, 0x65, 0x65, 0x34, 0x63, 0x65, 0x65, 0x64, 0x31, 0x38, 0x34, 0x39, 0x61, 0x62, 0x33, 0x36, 0x64, 0x36, 0x36, 0x34, 0x63, 0x66, 0x66, 0x39, 0x37, 0x30, 0x36, 0x31, 0x65, 0x38, 0x65, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x35, 0x65, 0x33, 0x61, 0x34, 0x30, 0x64, 0x32, 0x63, 0x64, 0x30, 0x33, 0x32, 0x35, 0x37, 0x36, 0x36, 0x64, 0x65, 0x37, 0x33, 0x61, 0x33, 0x64, 0x36, 0x37, 0x31, 0x38, 0x39, 0x36, 0x62, 0x33, 0x36, 0x32, 0x63, 0x37, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x33, 0x33, 0x38, 0x32, 0x62, 0x36, 0x65, 0x31, 0x35, 0x32, 0x36, 0x37, 0x39, 0x37, 0x34, 0x61, 0x38, 0x35, 0x35, 0x30, 0x62, 0x39, 0x38, 0x66, 0x37, 0x31, 0x37, 0x36, 0x63, 0x31, 0x61, 0x33, 0x35, 0x33, 0x66, 0x39, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x34, 0x31, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x30, 0x63, 0x31, 0x34, 0x39, 0x61, 0x31, 0x39, 0x30, 0x36, 0x66, 0x61, 0x64, 0x32, 0x37, 0x38, 0x36, 0x66, 0x66, 0x62, 0x31, 0x33, 0x35, 0x61, 0x61, 0x62, 0x35, 0x30, 0x31, 0x37, 0x33, 0x37, 0x65, 0x39, 0x65, 0x35, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x37, 0x37, 0x35, 0x39, 0x36, 0x35, 0x62, 0x37, 0x31, 0x36, 0x34, 0x37, 0x36, 0x36, 0x37, 0x35, 0x61, 0x38, 0x64, 0x35, 0x31, 0x33, 0x65, 0x62, 0x31, 0x34, 0x62, 0x62, 0x66, 0x37, 0x62, 0x30, 0x37, 0x63, 0x64, 0x31, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x37, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x36, 0x36, 0x32, 0x30, 0x30, 0x36, 0x30, 0x31, 0x35, 0x63, 0x31, 0x66, 0x38, 0x65, 0x33, 0x63, 0x63, 0x66, 0x63, 0x61, 0x65, 0x62, 0x63, 0x38, 0x65, 0x65, 0x36, 0x38, 0x30, 0x37, 0x65, 0x65, 0x31, 0x39, 0x36, 0x33, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x37, 0x34, 0x36, 0x61, 0x39, 0x35, 0x38, 0x64, 0x63, 0x65, 0x64, 0x34, 0x63, 0x37, 0x36, 0x34, 0x66, 0x38, 0x37, 0x36, 0x35, 0x30, 0x38, 0x63, 0x34, 0x31, 0x34, 0x61, 0x36, 0x38, 0x33, 0x34, 0x32, 0x63, 0x65, 0x63, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x38, 0x32, 0x65, 0x36, 0x66, 0x32, 0x38, 0x63, 0x35, 0x34, 0x38, 0x66, 0x35, 0x66, 0x39, 0x36, 0x66, 0x34, 0x35, 0x65, 0x36, 0x33, 0x66, 0x37, 0x61, 0x62, 0x37, 0x30, 0x38, 0x37, 0x32, 0x34, 0x66, 0x35, 0x33, 0x66, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x36, 0x32, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x30, 0x62, 0x66, 0x64, 0x35, 0x32, 0x65, 0x30, 0x31, 0x36, 0x36, 0x37, 0x61, 0x33, 0x34, 0x31, 0x39, 0x62, 0x30, 0x32, 0x39, 0x61, 0x31, 0x62, 0x38, 0x65, 0x34, 0x35, 0x35, 0x37, 0x36, 0x61, 0x38, 0x36, 0x61, 0x32, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x64, 0x32, 0x35, 0x32, 0x65, 0x30, 0x64, 0x37, 0x33, 0x32, 0x66, 0x66, 0x31, 0x64, 0x37, 0x63, 0x37, 0x38, 0x66, 0x30, 0x61, 0x30, 0x32, 0x65, 0x36, 0x63, 0x62, 0x32, 0x35, 0x34, 0x32, 0x33, 0x63, 0x66, 0x31, 0x62, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x32, 0x64, 0x37, 0x65, 0x61, 0x36, 0x36, 0x62, 0x39, 0x66, 0x34, 0x37, 0x64, 0x38, 0x63, 0x63, 0x35, 0x32, 0x63, 0x30, 0x31, 0x63, 0x35, 0x32, 0x62, 0x36, 0x65, 0x31, 0x39, 0x31, 0x62, 0x63, 0x37, 0x64, 0x34, 0x37, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x33, 0x31, 0x36, 0x31, 0x66, 0x31, 0x65, 0x61, 0x32, 0x66, 0x62, 0x66, 0x31, 0x32, 0x36, 0x65, 0x37, 0x39, 0x64, 0x61, 0x31, 0x38, 0x30, 0x31, 0x64, 0x61, 0x39, 0x35, 0x31, 0x32, 0x62, 0x33, 0x37, 0x39, 0x38, 0x38, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x32, 0x62, 0x61, 0x38, 0x36, 0x64, 0x61, 0x35, 0x32, 0x65, 0x37, 0x38, 0x35, 0x64, 0x38, 0x36, 0x32, 0x35, 0x33, 0x33, 0x34, 0x66, 0x33, 0x33, 0x39, 0x37, 0x62, 0x61, 0x31, 0x63, 0x34, 0x62, 0x66, 0x32, 0x65, 0x38, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x30, 0x38, 0x66, 0x34, 0x33, 0x37, 0x62, 0x33, 0x31, 0x66, 0x31, 0x38, 0x62, 0x63, 0x30, 0x62, 0x36, 0x34, 0x64, 0x33, 0x38, 0x31, 0x61, 0x65, 0x38, 0x36, 0x66, 0x64, 0x39, 0x37, 0x38, 0x65, 0x64, 0x37, 0x62, 0x33, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x61, 0x35, 0x61, 0x34, 0x34, 0x64, 0x33, 0x38, 0x61, 0x32, 0x66, 0x34, 0x34, 0x63, 0x36, 0x61, 0x39, 0x64, 0x62, 0x39, 0x63, 0x64, 0x62, 0x63, 0x36, 0x62, 0x31, 0x65, 0x32, 0x65, 0x39, 0x37, 0x61, 0x62, 0x62, 0x35, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x35, 0x61, 0x64, 0x33, 0x61, 0x62, 0x63, 0x36, 0x65, 0x65, 0x65, 0x62, 0x32, 0x34, 0x37, 0x31, 0x36, 0x38, 0x39, 0x62, 0x35, 0x33, 0x39, 0x65, 0x37, 0x38, 0x39, 0x63, 0x65, 0x32, 0x62, 0x38, 0x32, 0x36, 0x38, 0x33, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x39, 0x39, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x65, 0x34, 0x33, 0x37, 0x64, 0x34, 0x34, 0x38, 0x38, 0x36, 0x31, 0x32, 0x32, 0x38, 0x61, 0x32, 0x33, 0x32, 0x62, 0x36, 0x32, 0x65, 0x65, 0x38, 0x64, 0x33, 0x37, 0x39, 0x36, 0x35, 0x61, 0x39, 0x30, 0x34, 0x65, 0x64, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x37, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x35, 0x33, 0x33, 0x32, 0x32, 0x66, 0x34, 0x33, 0x66, 0x62, 0x62, 0x35, 0x38, 0x34, 0x39, 0x34, 0x64, 0x37, 0x63, 0x63, 0x65, 0x31, 0x39, 0x64, 0x64, 0x61, 0x32, 0x37, 0x32, 0x62, 0x32, 0x34, 0x35, 0x30, 0x65, 0x38, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x36, 0x36, 0x66, 0x63, 0x30, 0x38, 0x63, 0x61, 0x38, 0x35, 0x66, 0x37, 0x36, 0x36, 0x66, 0x64, 0x65, 0x38, 0x33, 0x31, 0x34, 0x36, 0x30, 0x65, 0x39, 0x64, 0x63, 0x39, 0x33, 0x63, 0x30, 0x65, 0x32, 0x31, 0x61, 0x61, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x63, 0x30, 0x31, 0x37, 0x34, 0x63, 0x66, 0x38, 0x34, 0x65, 0x30, 0x37, 0x38, 0x33, 0x63, 0x32, 0x32, 0x30, 0x62, 0x34, 0x65, 0x62, 0x36, 0x61, 0x65, 0x31, 0x38, 0x66, 0x65, 0x37, 0x30, 0x33, 0x38, 0x35, 0x34, 0x61, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x37, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x66, 0x34, 0x38, 0x34, 0x35, 0x32, 0x34, 0x66, 0x62, 0x64, 0x66, 0x61, 0x64, 0x61, 0x65, 0x32, 0x36, 0x64, 0x63, 0x31, 0x38, 0x35, 0x65, 0x33, 0x32, 0x62, 0x32, 0x62, 0x36, 0x33, 0x30, 0x66, 0x64, 0x32, 0x65, 0x37, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x38, 0x37, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x63, 0x64, 0x35, 0x64, 0x38, 0x30, 0x62, 0x31, 0x30, 0x35, 0x38, 0x39, 0x37, 0x61, 0x35, 0x37, 0x61, 0x62, 0x63, 0x34, 0x37, 0x38, 0x36, 0x35, 0x37, 0x36, 0x38, 0x62, 0x32, 0x39, 0x30, 0x30, 0x35, 0x32, 0x34, 0x32, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x32, 0x66, 0x34, 0x30, 0x37, 0x38, 0x66, 0x65, 0x62, 0x62, 0x62, 0x61, 0x61, 0x38, 0x62, 0x30, 0x65, 0x37, 0x38, 0x65, 0x36, 0x34, 0x32, 0x63, 0x38, 0x61, 0x34, 0x32, 0x66, 0x33, 0x35, 0x64, 0x34, 0x33, 0x33, 0x39, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x63, 0x37, 0x36, 0x38, 0x62, 0x66, 0x31, 0x34, 0x62, 0x38, 0x66, 0x39, 0x34, 0x33, 0x32, 0x65, 0x36, 0x39, 0x65, 0x61, 0x61, 0x38, 0x32, 0x61, 0x39, 0x39, 0x66, 0x62, 0x65, 0x62, 0x39, 0x34, 0x63, 0x64, 0x30, 0x63, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x33, 0x39, 0x65, 0x65, 0x65, 0x39, 0x38, 0x37, 0x33, 0x63, 0x65, 0x65, 0x63, 0x32, 0x36, 0x66, 0x63, 0x63, 0x39, 0x34, 0x35, 0x34, 0x62, 0x35, 0x34, 0x38, 0x62, 0x39, 0x65, 0x37, 0x63, 0x35, 0x34, 0x61, 0x61, 0x36, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x63, 0x33, 0x63, 0x32, 0x35, 0x31, 0x30, 0x64, 0x36, 0x37, 0x38, 0x30, 0x32, 0x30, 0x34, 0x38, 0x35, 0x61, 0x36, 0x33, 0x37, 0x33, 0x35, 0x64, 0x31, 0x33, 0x30, 0x37, 0x65, 0x63, 0x34, 0x63, 0x61, 0x36, 0x33, 0x30, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x33, 0x64, 0x36, 0x61, 0x37, 0x37, 0x35, 0x35, 0x39, 0x63, 0x38, 0x36, 0x63, 0x66, 0x36, 0x35, 0x37, 0x34, 0x32, 0x34, 0x32, 0x39, 0x30, 0x33, 0x33, 0x39, 0x34, 0x62, 0x61, 0x63, 0x66, 0x39, 0x36, 0x65, 0x33, 0x35, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x65, 0x32, 0x65, 0x37, 0x63, 0x65, 0x61, 0x61, 0x61, 0x31, 0x38, 0x61, 0x66, 0x30, 0x66, 0x38, 0x61, 0x61, 0x66, 0x61, 0x37, 0x66, 0x62, 0x61, 0x64, 0x37, 0x34, 0x63, 0x63, 0x38, 0x39, 0x65, 0x33, 0x63, 0x64, 0x34, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x33, 0x37, 0x37, 0x63, 0x30, 0x65, 0x35, 0x35, 0x36, 0x62, 0x36, 0x34, 0x30, 0x31, 0x30, 0x33, 0x32, 0x38, 0x39, 0x61, 0x36, 0x31, 0x38, 0x39, 0x65, 0x31, 0x61, 0x65, 0x61, 0x65, 0x36, 0x33, 0x34, 0x39, 0x33, 0x34, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x62, 0x30, 0x61, 0x35, 0x61, 0x39, 0x61, 0x65, 0x39, 0x36, 0x64, 0x32, 0x32, 0x63, 0x66, 0x30, 0x31, 0x64, 0x38, 0x66, 0x64, 0x36, 0x34, 0x38, 0x33, 0x62, 0x39, 0x66, 0x33, 0x38, 0x66, 0x30, 0x38, 0x63, 0x32, 0x63, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x38, 0x32, 0x31, 0x35, 0x61, 0x30, 0x61, 0x36, 0x39, 0x39, 0x31, 0x33, 0x66, 0x36, 0x32, 0x61, 0x34, 0x33, 0x62, 0x66, 0x31, 0x63, 0x38, 0x35, 0x39, 0x30, 0x62, 0x39, 0x64, 0x64, 0x63, 0x64, 0x30, 0x64, 0x38, 0x64, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x38, 0x33, 0x35, 0x63, 0x32, 0x35, 0x38, 0x32, 0x34, 0x63, 0x34, 0x37, 0x65, 0x63, 0x62, 0x66, 0x63, 0x37, 0x39, 0x34, 0x33, 0x39, 0x62, 0x66, 0x33, 0x66, 0x35, 0x63, 0x33, 0x34, 0x38, 0x31, 0x61, 0x61, 0x37, 0x35, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x34, 0x39, 0x33, 0x65, 0x66, 0x31, 0x37, 0x33, 0x37, 0x32, 0x34, 0x34, 0x34, 0x35, 0x63, 0x66, 0x33, 0x34, 0x35, 0x63, 0x30, 0x33, 0x35, 0x64, 0x32, 0x37, 0x39, 0x62, 0x61, 0x37, 0x35, 0x39, 0x66, 0x32, 0x38, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x65, 0x39, 0x30, 0x63, 0x31, 0x31, 0x39, 0x32, 0x62, 0x33, 0x64, 0x35, 0x64, 0x33, 0x65, 0x33, 0x61, 0x62, 0x30, 0x37, 0x30, 0x30, 0x66, 0x31, 0x62, 0x66, 0x36, 0x35, 0x35, 0x66, 0x35, 0x64, 0x64, 0x34, 0x33, 0x34, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x39, 0x62, 0x64, 0x65, 0x37, 0x33, 0x31, 0x36, 0x63, 0x63, 0x31, 0x65, 0x64, 0x32, 0x39, 0x35, 0x63, 0x38, 0x38, 0x35, 0x61, 0x63, 0x65, 0x33, 0x34, 0x32, 0x63, 0x37, 0x39, 0x62, 0x66, 0x37, 0x65, 0x65, 0x33, 0x33, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x36, 0x32, 0x35, 0x35, 0x30, 0x31, 0x66, 0x35, 0x32, 0x62, 0x37, 0x61, 0x66, 0x35, 0x32, 0x62, 0x31, 0x39, 0x65, 0x64, 0x36, 0x31, 0x32, 0x65, 0x39, 0x64, 0x35, 0x34, 0x66, 0x64, 0x64, 0x30, 0x30, 0x36, 0x62, 0x34, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x64, 0x35, 0x39, 0x39, 0x34, 0x35, 0x36, 0x62, 0x32, 0x35, 0x34, 0x33, 0x65, 0x36, 0x64, 0x62, 0x38, 0x30, 0x65, 0x61, 0x39, 0x62, 0x32, 0x31, 0x30, 0x65, 0x39, 0x30, 0x38, 0x30, 0x32, 0x36, 0x65, 0x32, 0x31, 0x34, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x30, 0x36, 0x64, 0x64, 0x39, 0x32, 0x32, 0x62, 0x36, 0x31, 0x35, 0x31, 0x34, 0x61, 0x61, 0x66, 0x65, 0x64, 0x64, 0x38, 0x34, 0x34, 0x38, 0x38, 0x63, 0x30, 0x63, 0x32, 0x38, 0x65, 0x36, 0x64, 0x63, 0x66, 0x30, 0x65, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x62, 0x35, 0x65, 0x64, 0x65, 0x36, 0x66, 0x64, 0x66, 0x31, 0x64, 0x36, 0x65, 0x39, 0x61, 0x33, 0x34, 0x37, 0x32, 0x31, 0x33, 0x37, 0x39, 0x61, 0x65, 0x61, 0x61, 0x31, 0x37, 0x63, 0x37, 0x31, 0x33, 0x64, 0x64, 0x38, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x39, 0x33, 0x30, 0x61, 0x33, 0x39, 0x63, 0x37, 0x37, 0x33, 0x35, 0x37, 0x63, 0x33, 0x30, 0x61, 0x64, 0x33, 0x61, 0x30, 0x36, 0x30, 0x66, 0x30, 0x30, 0x62, 0x30, 0x36, 0x30, 0x34, 0x36, 0x33, 0x33, 0x31, 0x66, 0x64, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x61, 0x32, 0x63, 0x32, 0x31, 0x31, 0x31, 0x36, 0x31, 0x32, 0x66, 0x62, 0x38, 0x62, 0x62, 0x62, 0x38, 0x65, 0x37, 0x64, 0x64, 0x39, 0x33, 0x37, 0x38, 0x64, 0x36, 0x37, 0x66, 0x31, 0x61, 0x33, 0x38, 0x34, 0x66, 0x30, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x31, 0x37, 0x34, 0x66, 0x34, 0x30, 0x61, 0x30, 0x34, 0x34, 0x37, 0x32, 0x33, 0x34, 0x65, 0x36, 0x36, 0x36, 0x35, 0x33, 0x39, 0x31, 0x34, 0x64, 0x37, 0x35, 0x62, 0x63, 0x30, 0x30, 0x33, 0x65, 0x35, 0x36, 0x39, 0x30, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x36, 0x63, 0x62, 0x36, 0x32, 0x39, 0x34, 0x37, 0x30, 0x34, 0x65, 0x65, 0x61, 0x37, 0x34, 0x33, 0x37, 0x63, 0x32, 0x66, 0x63, 0x33, 0x64, 0x33, 0x30, 0x37, 0x37, 0x33, 0x62, 0x37, 0x62, 0x66, 0x33, 0x38, 0x38, 0x38, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x30, 0x36, 0x66, 0x38, 0x63, 0x31, 0x62, 0x35, 0x63, 0x64, 0x62, 0x64, 0x32, 0x38, 0x65, 0x32, 0x64, 0x39, 0x36, 0x62, 0x36, 0x33, 0x34, 0x36, 0x63, 0x33, 0x65, 0x38, 0x35, 0x61, 0x30, 0x34, 0x38, 0x33, 0x62, 0x61, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x31, 0x36, 0x65, 0x66, 0x31, 0x64, 0x66, 0x32, 0x66, 0x66, 0x34, 0x64, 0x36, 0x63, 0x31, 0x38, 0x30, 0x38, 0x64, 0x62, 0x61, 0x36, 0x36, 0x33, 0x65, 0x63, 0x38, 0x30, 0x39, 0x33, 0x36, 0x39, 0x37, 0x39, 0x36, 0x38, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x36, 0x39, 0x31, 0x35, 0x65, 0x62, 0x64, 0x39, 0x61, 0x31, 0x39, 0x63, 0x38, 0x31, 0x62, 0x36, 0x39, 0x32, 0x61, 0x64, 0x39, 0x39, 0x62, 0x31, 0x32, 0x31, 0x38, 0x61, 0x35, 0x39, 0x32, 0x63, 0x31, 0x61, 0x63, 0x37, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x35, 0x34, 0x39, 0x33, 0x62, 0x64, 0x61, 0x33, 0x36, 0x61, 0x30, 0x34, 0x33, 0x32, 0x39, 0x37, 0x36, 0x35, 0x34, 0x36, 0x63, 0x31, 0x64, 0x64, 0x63, 0x65, 0x37, 0x31, 0x63, 0x33, 0x66, 0x34, 0x35, 0x37, 0x30, 0x30, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x62, 0x30, 0x34, 0x30, 0x37, 0x63, 0x64, 0x61, 0x64, 0x34, 0x63, 0x65, 0x35, 0x32, 0x36, 0x30, 0x30, 0x36, 0x32, 0x33, 0x62, 0x64, 0x35, 0x65, 0x31, 0x66, 0x36, 0x61, 0x38, 0x31, 0x61, 0x62, 0x36, 0x31, 0x66, 0x30, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x39, 0x34, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x37, 0x64, 0x39, 0x66, 0x30, 0x63, 0x30, 0x37, 0x66, 0x38, 0x65, 0x62, 0x37, 0x34, 0x66, 0x61, 0x61, 0x61, 0x64, 0x31, 0x35, 0x65, 0x62, 0x63, 0x37, 0x62, 0x38, 0x30, 0x34, 0x34, 0x37, 0x34, 0x31, 0x37, 0x66, 0x37, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x36, 0x63, 0x63, 0x66, 0x38, 0x30, 0x36, 0x37, 0x33, 0x38, 0x30, 0x39, 0x31, 0x30, 0x34, 0x32, 0x61, 0x64, 0x39, 0x37, 0x61, 0x36, 0x65, 0x30, 0x39, 0x35, 0x66, 0x65, 0x38, 0x63, 0x33, 0x36, 0x61, 0x61, 0x37, 0x39, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x34, 0x33, 0x37, 0x66, 0x65, 0x63, 0x66, 0x33, 0x34, 0x61, 0x62, 0x39, 0x64, 0x34, 0x33, 0x35, 0x66, 0x34, 0x64, 0x65, 0x62, 0x38, 0x63, 0x61, 0x31, 0x38, 0x31, 0x35, 0x31, 0x39, 0x65, 0x32, 0x35, 0x39, 0x32, 0x30, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x31, 0x66, 0x61, 0x61, 0x33, 0x34, 0x37, 0x62, 0x30, 0x66, 0x63, 0x63, 0x38, 0x30, 0x34, 0x63, 0x32, 0x64, 0x61, 0x38, 0x36, 0x63, 0x33, 0x36, 0x64, 0x35, 0x66, 0x31, 0x64, 0x31, 0x38, 0x62, 0x37, 0x30, 0x38, 0x37, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x30, 0x63, 0x66, 0x36, 0x37, 0x64, 0x62, 0x30, 0x36, 0x30, 0x63, 0x63, 0x65, 0x31, 0x37, 0x35, 0x36, 0x38, 0x64, 0x35, 0x66, 0x32, 0x61, 0x34, 0x32, 0x33, 0x36, 0x38, 0x37, 0x63, 0x34, 0x39, 0x36, 0x34, 0x37, 0x36, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x64, 0x39, 0x35, 0x65, 0x66, 0x39, 0x36, 0x32, 0x34, 0x36, 0x32, 0x62, 0x36, 0x65, 0x64, 0x66, 0x61, 0x31, 0x30, 0x66, 0x64, 0x61, 0x38, 0x37, 0x64, 0x37, 0x32, 0x32, 0x34, 0x32, 0x66, 0x65, 0x33, 0x65, 0x64, 0x62, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x35, 0x65, 0x38, 0x62, 0x33, 0x63, 0x37, 0x37, 0x66, 0x37, 0x39, 0x32, 0x64, 0x65, 0x63, 0x62, 0x37, 0x61, 0x38, 0x39, 0x38, 0x35, 0x64, 0x66, 0x39, 0x31, 0x36, 0x65, 0x66, 0x62, 0x34, 0x39, 0x30, 0x61, 0x61, 0x63, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x33, 0x62, 0x30, 0x38, 0x33, 0x30, 0x39, 0x33, 0x62, 0x61, 0x35, 0x36, 0x34, 0x65, 0x32, 0x64, 0x63, 0x36, 0x33, 0x31, 0x35, 0x36, 0x38, 0x63, 0x66, 0x37, 0x35, 0x34, 0x30, 0x64, 0x39, 0x61, 0x30, 0x65, 0x63, 0x37, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x33, 0x63, 0x35, 0x34, 0x37, 0x65, 0x30, 0x63, 0x62, 0x35, 0x63, 0x65, 0x36, 0x33, 0x32, 0x65, 0x31, 0x63, 0x35, 0x61, 0x64, 0x36, 0x36, 0x31, 0x35, 0x35, 0x37, 0x32, 0x30, 0x63, 0x30, 0x31, 0x63, 0x34, 0x30, 0x39, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x39, 0x31, 0x35, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x31, 0x33, 0x34, 0x36, 0x31, 0x32, 0x30, 0x38, 0x34, 0x35, 0x35, 0x34, 0x35, 0x35, 0x34, 0x36, 0x35, 0x34, 0x34, 0x35, 0x61, 0x34, 0x35, 0x39, 0x62, 0x30, 0x36, 0x63, 0x33, 0x37, 0x37, 0x33, 0x62, 0x30, 0x65, 0x62, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x31, 0x66, 0x33, 0x37, 0x65, 0x38, 0x61, 0x30, 0x32, 0x39, 0x66, 0x64, 0x30, 0x32, 0x34, 0x38, 0x32, 0x66, 0x32, 0x38, 0x39, 0x63, 0x34, 0x39, 0x62, 0x35, 0x64, 0x30, 0x36, 0x64, 0x30, 0x30, 0x65, 0x34, 0x30, 0x38, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x30, 0x64, 0x34, 0x63, 0x34, 0x33, 0x61, 0x64, 0x63, 0x66, 0x35, 0x35, 0x62, 0x32, 0x63, 0x62, 0x35, 0x33, 0x64, 0x36, 0x38, 0x33, 0x32, 0x33, 0x32, 0x36, 0x34, 0x31, 0x33, 0x34, 0x34, 0x39, 0x38, 0x64, 0x38, 0x39, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x34, 0x38, 0x65, 0x61, 0x38, 0x39, 0x63, 0x32, 0x37, 0x35, 0x32, 0x35, 0x37, 0x31, 0x30, 0x31, 0x37, 0x32, 0x39, 0x34, 0x34, 0x65, 0x37, 0x39, 0x65, 0x64, 0x66, 0x66, 0x38, 0x34, 0x37, 0x38, 0x30, 0x33, 0x62, 0x37, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x37, 0x66, 0x38, 0x36, 0x39, 0x66, 0x38, 0x65, 0x39, 0x30, 0x64, 0x35, 0x33, 0x66, 0x64, 0x63, 0x30, 0x33, 0x65, 0x38, 0x62, 0x32, 0x38, 0x31, 0x39, 0x62, 0x30, 0x31, 0x36, 0x62, 0x39, 0x64, 0x31, 0x38, 0x65, 0x62, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x31, 0x66, 0x39, 0x32, 0x61, 0x33, 0x61, 0x35, 0x34, 0x61, 0x37, 0x62, 0x38, 0x63, 0x32, 0x66, 0x35, 0x65, 0x61, 0x34, 0x34, 0x33, 0x30, 0x35, 0x66, 0x63, 0x63, 0x62, 0x38, 0x34, 0x65, 0x65, 0x65, 0x32, 0x33, 0x31, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x38, 0x38, 0x39, 0x30, 0x31, 0x33, 0x33, 0x31, 0x65, 0x33, 0x38, 0x37, 0x66, 0x37, 0x31, 0x33, 0x66, 0x61, 0x63, 0x65, 0x62, 0x39, 0x30, 0x30, 0x35, 0x63, 0x62, 0x39, 0x62, 0x36, 0x35, 0x31, 0x33, 0x36, 0x65, 0x62, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x61, 0x33, 0x39, 0x61, 0x38, 0x62, 0x61, 0x63, 0x30, 0x66, 0x30, 0x31, 0x63, 0x33, 0x34, 0x39, 0x63, 0x36, 0x34, 0x63, 0x65, 0x64, 0x62, 0x36, 0x39, 0x38, 0x39, 0x37, 0x66, 0x36, 0x33, 0x33, 0x32, 0x33, 0x34, 0x65, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x32, 0x61, 0x35, 0x63, 0x30, 0x30, 0x66, 0x39, 0x32, 0x33, 0x61, 0x61, 0x66, 0x32, 0x31, 0x61, 0x62, 0x39, 0x66, 0x33, 0x66, 0x62, 0x30, 0x36, 0x36, 0x65, 0x66, 0x61, 0x30, 0x61, 0x30, 0x33, 0x64, 0x65, 0x32, 0x66, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x35, 0x32, 0x35, 0x39, 0x61, 0x35, 0x63, 0x39, 0x33, 0x39, 0x63, 0x64, 0x32, 0x35, 0x39, 0x36, 0x36, 0x63, 0x39, 0x62, 0x36, 0x33, 0x30, 0x33, 0x64, 0x33, 0x37, 0x33, 0x31, 0x63, 0x35, 0x33, 0x64, 0x64, 0x62, 0x63, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x36, 0x38, 0x32, 0x63, 0x32, 0x31, 0x35, 0x39, 0x30, 0x31, 0x38, 0x64, 0x63, 0x33, 0x64, 0x30, 0x37, 0x66, 0x30, 0x38, 0x32, 0x34, 0x30, 0x61, 0x38, 0x63, 0x36, 0x30, 0x36, 0x64, 0x61, 0x66, 0x36, 0x35, 0x66, 0x38, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x39, 0x39, 0x39, 0x31, 0x63, 0x65, 0x62, 0x64, 0x39, 0x38, 0x64, 0x39, 0x63, 0x38, 0x33, 0x38, 0x63, 0x32, 0x35, 0x66, 0x37, 0x61, 0x37, 0x34, 0x31, 0x36, 0x64, 0x39, 0x65, 0x32, 0x34, 0x34, 0x63, 0x61, 0x32, 0x35, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x32, 0x38, 0x35, 0x37, 0x35, 0x35, 0x33, 0x39, 0x31, 0x65, 0x39, 0x31, 0x34, 0x65, 0x35, 0x38, 0x30, 0x32, 0x35, 0x66, 0x61, 0x61, 0x34, 0x38, 0x63, 0x63, 0x36, 0x38, 0x35, 0x66, 0x34, 0x66, 0x64, 0x34, 0x66, 0x35, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x32, 0x34, 0x62, 0x37, 0x61, 0x63, 0x34, 0x37, 0x64, 0x32, 0x66, 0x32, 0x37, 0x64, 0x65, 0x39, 0x30, 0x39, 0x37, 0x34, 0x62, 0x61, 0x33, 0x64, 0x65, 0x35, 0x65, 0x61, 0x64, 0x32, 0x30, 0x33, 0x35, 0x34, 0x34, 0x62, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x62, 0x31, 0x38, 0x32, 0x66, 0x32, 0x64, 0x61, 0x32, 0x62, 0x33, 0x38, 0x34, 0x34, 0x39, 0x33, 0x63, 0x66, 0x35, 0x66, 0x33, 0x35, 0x66, 0x38, 0x33, 0x64, 0x39, 0x64, 0x31, 0x65, 0x65, 0x31, 0x34, 0x66, 0x32, 0x61, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x61, 0x62, 0x30, 0x38, 0x38, 0x39, 0x36, 0x36, 0x65, 0x63, 0x63, 0x37, 0x32, 0x32, 0x39, 0x32, 0x35, 0x38, 0x66, 0x36, 0x30, 0x39, 0x38, 0x66, 0x63, 0x65, 0x36, 0x38, 0x63, 0x66, 0x33, 0x39, 0x62, 0x33, 0x38, 0x34, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x37, 0x37, 0x61, 0x37, 0x39, 0x33, 0x39, 0x64, 0x30, 0x39, 0x33, 0x39, 0x36, 0x38, 0x39, 0x34, 0x35, 0x35, 0x63, 0x65, 0x32, 0x36, 0x33, 0x39, 0x64, 0x30, 0x65, 0x65, 0x35, 0x61, 0x34, 0x63, 0x64, 0x39, 0x31, 0x30, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x61, 0x66, 0x39, 0x33, 0x38, 0x63, 0x31, 0x32, 0x33, 0x37, 0x61, 0x32, 0x37, 0x63, 0x39, 0x30, 0x33, 0x30, 0x30, 0x39, 0x34, 0x64, 0x63, 0x66, 0x32, 0x34, 0x30, 0x37, 0x35, 0x30, 0x32, 0x34, 0x36, 0x65, 0x33, 0x64, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x32, 0x62, 0x66, 0x61, 0x34, 0x61, 0x34, 0x36, 0x36, 0x66, 0x38, 0x32, 0x36, 0x37, 0x31, 0x62, 0x38, 0x30, 0x30, 0x65, 0x65, 0x65, 0x34, 0x32, 0x36, 0x61, 0x64, 0x30, 0x30, 0x63, 0x30, 0x37, 0x31, 0x62, 0x61, 0x31, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x37, 0x33, 0x37, 0x39, 0x64, 0x34, 0x63, 0x34, 0x36, 0x37, 0x34, 0x36, 0x34, 0x66, 0x32, 0x33, 0x35, 0x62, 0x63, 0x31, 0x38, 0x65, 0x35, 0x35, 0x39, 0x33, 0x38, 0x61, 0x61, 0x64, 0x33, 0x65, 0x36, 0x38, 0x38, 0x61, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x62, 0x32, 0x39, 0x62, 0x38, 0x32, 0x31, 0x39, 0x35, 0x63, 0x38, 0x38, 0x32, 0x64, 0x61, 0x62, 0x37, 0x38, 0x39, 0x37, 0x63, 0x32, 0x61, 0x65, 0x39, 0x35, 0x65, 0x37, 0x37, 0x37, 0x31, 0x30, 0x66, 0x35, 0x37, 0x38, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x35, 0x38, 0x36, 0x33, 0x39, 0x31, 0x30, 0x34, 0x30, 0x63, 0x35, 0x37, 0x65, 0x65, 0x63, 0x36, 0x66, 0x35, 0x61, 0x66, 0x66, 0x64, 0x38, 0x63, 0x64, 0x34, 0x61, 0x62, 0x64, 0x65, 0x31, 0x30, 0x62, 0x35, 0x30, 0x61, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x36, 0x30, 0x38, 0x65, 0x32, 0x62, 0x61, 0x63, 0x39, 0x64, 0x64, 0x32, 0x30, 0x37, 0x32, 0x38, 0x64, 0x32, 0x39, 0x34, 0x37, 0x65, 0x66, 0x66, 0x62, 0x62, 0x62, 0x66, 0x39, 0x30, 0x30, 0x61, 0x39, 0x63, 0x65, 0x39, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x35, 0x34, 0x38, 0x62, 0x34, 0x62, 0x61, 0x36, 0x32, 0x62, 0x63, 0x62, 0x32, 0x66, 0x30, 0x64, 0x33, 0x34, 0x61, 0x38, 0x38, 0x64, 0x63, 0x36, 0x39, 0x61, 0x36, 0x38, 0x30, 0x65, 0x35, 0x33, 0x39, 0x63, 0x66, 0x30, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x36, 0x35, 0x61, 0x62, 0x31, 0x37, 0x33, 0x39, 0x64, 0x37, 0x31, 0x31, 0x31, 0x39, 0x65, 0x65, 0x36, 0x31, 0x33, 0x32, 0x61, 0x62, 0x62, 0x64, 0x39, 0x32, 0x36, 0x61, 0x32, 0x37, 0x39, 0x66, 0x65, 0x36, 0x37, 0x39, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x34, 0x34, 0x39, 0x33, 0x65, 0x38, 0x35, 0x32, 0x31, 0x63, 0x61, 0x38, 0x39, 0x64, 0x39, 0x35, 0x66, 0x35, 0x32, 0x36, 0x37, 0x63, 0x31, 0x61, 0x62, 0x36, 0x33, 0x66, 0x39, 0x66, 0x34, 0x35, 0x34, 0x31, 0x31, 0x65, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x36, 0x39, 0x32, 0x35, 0x63, 0x30, 0x30, 0x37, 0x35, 0x31, 0x30, 0x30, 0x38, 0x34, 0x34, 0x30, 0x61, 0x36, 0x37, 0x33, 0x39, 0x61, 0x30, 0x32, 0x62, 0x66, 0x32, 0x62, 0x36, 0x63, 0x64, 0x61, 0x61, 0x62, 0x35, 0x65, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x65, 0x34, 0x30, 0x66, 0x62, 0x64, 0x39, 0x31, 0x39, 0x61, 0x61, 0x64, 0x32, 0x38, 0x31, 0x38, 0x64, 0x66, 0x30, 0x31, 0x65, 0x65, 0x34, 0x64, 0x66, 0x34, 0x36, 0x63, 0x34, 0x36, 0x38, 0x34, 0x32, 0x61, 0x63, 0x35, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x35, 0x62, 0x39, 0x32, 0x39, 0x36, 0x39, 0x32, 0x31, 0x61, 0x37, 0x34, 0x64, 0x31, 0x66, 0x63, 0x34, 0x31, 0x36, 0x31, 0x37, 0x66, 0x34, 0x33, 0x62, 0x38, 0x33, 0x30, 0x33, 0x65, 0x36, 0x66, 0x33, 0x65, 0x64, 0x37, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x38, 0x36, 0x62, 0x34, 0x62, 0x64, 0x65, 0x33, 0x65, 0x33, 0x35, 0x64, 0x34, 0x61, 0x65, 0x62, 0x32, 0x34, 0x62, 0x38, 0x32, 0x35, 0x66, 0x31, 0x61, 0x32, 0x31, 0x35, 0x66, 0x39, 0x39, 0x64, 0x38, 0x35, 0x66, 0x37, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x65, 0x65, 0x34, 0x39, 0x31, 0x39, 0x66, 0x62, 0x33, 0x37, 0x66, 0x32, 0x62, 0x62, 0x39, 0x37, 0x30, 0x63, 0x33, 0x66, 0x66, 0x66, 0x35, 0x34, 0x61, 0x61, 0x66, 0x31, 0x66, 0x33, 0x64, 0x64, 0x61, 0x36, 0x63, 0x30, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x34, 0x38, 0x39, 0x61, 0x35, 0x30, 0x65, 0x61, 0x64, 0x35, 0x64, 0x35, 0x34, 0x34, 0x35, 0x61, 0x37, 0x62, 0x65, 0x65, 0x34, 0x64, 0x32, 0x64, 0x35, 0x35, 0x33, 0x36, 0x63, 0x32, 0x61, 0x37, 0x36, 0x63, 0x34, 0x31, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x35, 0x65, 0x34, 0x66, 0x37, 0x63, 0x32, 0x37, 0x35, 0x35, 0x38, 0x38, 0x63, 0x35, 0x33, 0x33, 0x61, 0x32, 0x30, 0x65, 0x62, 0x64, 0x32, 0x61, 0x63, 0x31, 0x33, 0x62, 0x34, 0x30, 0x39, 0x62, 0x62, 0x64, 0x65, 0x61, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x62, 0x35, 0x33, 0x35, 0x39, 0x38, 0x63, 0x63, 0x32, 0x30, 0x65, 0x32, 0x30, 0x35, 0x35, 0x64, 0x63, 0x35, 0x35, 0x33, 0x62, 0x30, 0x34, 0x39, 0x34, 0x30, 0x34, 0x61, 0x63, 0x39, 0x62, 0x37, 0x64, 0x64, 0x31, 0x65, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x63, 0x64, 0x32, 0x30, 0x34, 0x30, 0x33, 0x62, 0x61, 0x37, 0x65, 0x64, 0x61, 0x36, 0x62, 0x63, 0x33, 0x30, 0x37, 0x61, 0x33, 0x64, 0x36, 0x33, 0x62, 0x35, 0x39, 0x31, 0x31, 0x62, 0x38, 0x31, 0x37, 0x63, 0x31, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x31, 0x31, 0x64, 0x61, 0x30, 0x33, 0x63, 0x63, 0x30, 0x65, 0x33, 0x31, 0x65, 0x63, 0x63, 0x65, 0x35, 0x33, 0x30, 0x39, 0x39, 0x39, 0x38, 0x37, 0x31, 0x38, 0x35, 0x31, 0x35, 0x35, 0x32, 0x38, 0x61, 0x30, 0x39, 0x30, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x62, 0x34, 0x32, 0x32, 0x64, 0x63, 0x34, 0x64, 0x64, 0x32, 0x61, 0x61, 0x65, 0x39, 0x34, 0x61, 0x62, 0x61, 0x65, 0x39, 0x35, 0x65, 0x61, 0x34, 0x35, 0x64, 0x64, 0x31, 0x37, 0x33, 0x31, 0x62, 0x62, 0x36, 0x62, 0x30, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x64, 0x65, 0x39, 0x37, 0x33, 0x34, 0x62, 0x38, 0x65, 0x36, 0x61, 0x61, 0x35, 0x33, 0x38, 0x63, 0x32, 0x39, 0x31, 0x64, 0x36, 0x64, 0x37, 0x66, 0x61, 0x63, 0x65, 0x64, 0x62, 0x30, 0x66, 0x33, 0x33, 0x38, 0x66, 0x38, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x31, 0x63, 0x61, 0x30, 0x32, 0x61, 0x38, 0x62, 0x36, 0x64, 0x36, 0x32, 0x62, 0x66, 0x34, 0x63, 0x61, 0x34, 0x37, 0x65, 0x39, 0x30, 0x36, 0x39, 0x31, 0x34, 0x30, 0x37, 0x39, 0x38, 0x36, 0x31, 0x39, 0x37, 0x32, 0x63, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x30, 0x64, 0x30, 0x30, 0x35, 0x35, 0x66, 0x64, 0x39, 0x61, 0x33, 0x38, 0x34, 0x38, 0x38, 0x61, 0x66, 0x66, 0x39, 0x32, 0x33, 0x66, 0x64, 0x30, 0x33, 0x64, 0x33, 0x35, 0x65, 0x63, 0x34, 0x36, 0x64, 0x37, 0x31, 0x31, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x38, 0x37, 0x31, 0x39, 0x32, 0x63, 0x37, 0x66, 0x37, 0x30, 0x35, 0x30, 0x30, 0x36, 0x62, 0x36, 0x33, 0x30, 0x30, 0x39, 0x31, 0x32, 0x37, 0x36, 0x62, 0x33, 0x39, 0x61, 0x63, 0x36, 0x38, 0x30, 0x34, 0x34, 0x38, 0x64, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x33, 0x63, 0x38, 0x65, 0x36, 0x31, 0x65, 0x35, 0x36, 0x30, 0x34, 0x63, 0x65, 0x66, 0x30, 0x36, 0x30, 0x35, 0x64, 0x34, 0x33, 0x36, 0x64, 0x64, 0x32, 0x32, 0x61, 0x63, 0x63, 0x64, 0x38, 0x36, 0x32, 0x32, 0x31, 0x37, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x35, 0x38, 0x66, 0x64, 0x36, 0x36, 0x32, 0x66, 0x63, 0x34, 0x63, 0x65, 0x33, 0x32, 0x39, 0x35, 0x66, 0x30, 0x64, 0x34, 0x65, 0x64, 0x38, 0x66, 0x37, 0x62, 0x62, 0x31, 0x34, 0x34, 0x39, 0x36, 0x30, 0x30, 0x61, 0x30, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x37, 0x31, 0x64, 0x65, 0x36, 0x37, 0x32, 0x62, 0x39, 0x39, 0x30, 0x34, 0x62, 0x61, 0x64, 0x38, 0x37, 0x34, 0x33, 0x36, 0x39, 0x32, 0x63, 0x32, 0x31, 0x63, 0x34, 0x66, 0x64, 0x63, 0x65, 0x61, 0x34, 0x63, 0x32, 0x65, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x65, 0x30, 0x34, 0x35, 0x35, 0x31, 0x32, 0x61, 0x30, 0x32, 0x36, 0x65, 0x33, 0x66, 0x31, 0x63, 0x65, 0x62, 0x66, 0x64, 0x35, 0x61, 0x37, 0x65, 0x63, 0x30, 0x63, 0x66, 0x63, 0x33, 0x36, 0x66, 0x32, 0x64, 0x63, 0x31, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x33, 0x30, 0x30, 0x62, 0x33, 0x32, 0x31, 0x35, 0x62, 0x31, 0x31, 0x64, 0x65, 0x37, 0x36, 0x32, 0x65, 0x63, 0x64, 0x65, 0x34, 0x62, 0x37, 0x30, 0x62, 0x37, 0x39, 0x32, 0x37, 0x64, 0x30, 0x31, 0x32, 0x39, 0x31, 0x35, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x65, 0x33, 0x37, 0x34, 0x34, 0x37, 0x34, 0x30, 0x36, 0x63, 0x34, 0x31, 0x32, 0x31, 0x39, 0x37, 0x62, 0x32, 0x65, 0x32, 0x61, 0x65, 0x62, 0x63, 0x30, 0x30, 0x31, 0x64, 0x36, 0x65, 0x33, 0x30, 0x63, 0x39, 0x38, 0x63, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x34, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x30, 0x34, 0x37, 0x66, 0x66, 0x31, 0x65, 0x36, 0x39, 0x63, 0x63, 0x36, 0x62, 0x32, 0x39, 0x61, 0x64, 0x32, 0x36, 0x34, 0x39, 0x37, 0x61, 0x39, 0x61, 0x36, 0x66, 0x32, 0x37, 0x61, 0x39, 0x30, 0x33, 0x66, 0x63, 0x34, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x66, 0x61, 0x37, 0x65, 0x62, 0x35, 0x31, 0x61, 0x34, 0x38, 0x32, 0x32, 0x39, 0x35, 0x39, 0x38, 0x66, 0x39, 0x37, 0x65, 0x37, 0x36, 0x32, 0x62, 0x65, 0x30, 0x38, 0x36, 0x39, 0x36, 0x35, 0x32, 0x64, 0x66, 0x66, 0x63, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x37, 0x39, 0x61, 0x65, 0x65, 0x63, 0x64, 0x38, 0x37, 0x61, 0x35, 0x37, 0x61, 0x37, 0x33, 0x66, 0x33, 0x33, 0x35, 0x36, 0x38, 0x31, 0x31, 0x64, 0x32, 0x63, 0x66, 0x34, 0x39, 0x64, 0x30, 0x63, 0x34, 0x64, 0x39, 0x36, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x63, 0x35, 0x35, 0x61, 0x65, 0x62, 0x35, 0x37, 0x33, 0x39, 0x38, 0x37, 0x36, 0x66, 0x30, 0x61, 0x63, 0x38, 0x64, 0x37, 0x65, 0x62, 0x65, 0x61, 0x31, 0x33, 0x62, 0x65, 0x37, 0x32, 0x39, 0x36, 0x38, 0x35, 0x66, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x37, 0x62, 0x36, 0x35, 0x38, 0x37, 0x36, 0x64, 0x62, 0x66, 0x32, 0x39, 0x62, 0x66, 0x39, 0x31, 0x31, 0x64, 0x34, 0x66, 0x30, 0x36, 0x39, 0x32, 0x61, 0x32, 0x63, 0x39, 0x62, 0x65, 0x62, 0x31, 0x31, 0x33, 0x39, 0x38, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x32, 0x34, 0x32, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x66, 0x63, 0x33, 0x36, 0x62, 0x30, 0x31, 0x33, 0x31, 0x65, 0x63, 0x31, 0x32, 0x30, 0x61, 0x63, 0x39, 0x65, 0x38, 0x35, 0x61, 0x66, 0x63, 0x31, 0x30, 0x63, 0x65, 0x37, 0x30, 0x62, 0x35, 0x36, 0x64, 0x38, 0x62, 0x36, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x38, 0x39, 0x38, 0x39, 0x39, 0x63, 0x62, 0x65, 0x62, 0x64, 0x62, 0x62, 0x36, 0x34, 0x62, 0x62, 0x32, 0x36, 0x61, 0x31, 0x39, 0x35, 0x61, 0x36, 0x33, 0x63, 0x30, 0x38, 0x34, 0x39, 0x31, 0x66, 0x63, 0x64, 0x39, 0x65, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x64, 0x66, 0x37, 0x66, 0x35, 0x32, 0x38, 0x33, 0x37, 0x32, 0x35, 0x63, 0x39, 0x35, 0x33, 0x65, 0x65, 0x36, 0x34, 0x33, 0x31, 0x37, 0x66, 0x36, 0x36, 0x31, 0x38, 0x38, 0x61, 0x66, 0x31, 0x31, 0x38, 0x34, 0x62, 0x30, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x37, 0x33, 0x38, 0x35, 0x65, 0x38, 0x38, 0x36, 0x33, 0x34, 0x34, 0x36, 0x35, 0x36, 0x38, 0x35, 0x63, 0x32, 0x33, 0x31, 0x61, 0x33, 0x31, 0x34, 0x61, 0x30, 0x64, 0x35, 0x64, 0x63, 0x64, 0x31, 0x34, 0x36, 0x61, 0x66, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x38, 0x66, 0x32, 0x30, 0x61, 0x32, 0x37, 0x62, 0x32, 0x37, 0x65, 0x63, 0x34, 0x34, 0x31, 0x61, 0x66, 0x37, 0x32, 0x33, 0x66, 0x64, 0x39, 0x30, 0x39, 0x39, 0x66, 0x32, 0x63, 0x62, 0x62, 0x37, 0x39, 0x64, 0x36, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x61, 0x34, 0x32, 0x32, 0x37, 0x66, 0x36, 0x63, 0x66, 0x39, 0x38, 0x38, 0x32, 0x35, 0x63, 0x30, 0x64, 0x35, 0x62, 0x61, 0x66, 0x66, 0x35, 0x33, 0x31, 0x35, 0x37, 0x35, 0x32, 0x63, 0x63, 0x63, 0x31, 0x61, 0x31, 0x33, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x35, 0x31, 0x37, 0x30, 0x38, 0x33, 0x65, 0x33, 0x30, 0x33, 0x64, 0x34, 0x66, 0x62, 0x62, 0x36, 0x63, 0x32, 0x31, 0x31, 0x34, 0x35, 0x31, 0x34, 0x32, 0x31, 0x35, 0x64, 0x36, 0x39, 0x62, 0x63, 0x34, 0x36, 0x61, 0x32, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x61, 0x62, 0x31, 0x37, 0x32, 0x65, 0x66, 0x66, 0x61, 0x36, 0x66, 0x62, 0x65, 0x65, 0x35, 0x33, 0x34, 0x63, 0x39, 0x34, 0x62, 0x31, 0x37, 0x65, 0x37, 0x39, 0x34, 0x65, 0x64, 0x61, 0x63, 0x35, 0x34, 0x66, 0x35, 0x35, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x65, 0x65, 0x33, 0x35, 0x39, 0x33, 0x34, 0x32, 0x32, 0x39, 0x36, 0x39, 0x33, 0x35, 0x32, 0x39, 0x64, 0x63, 0x34, 0x31, 0x64, 0x39, 0x62, 0x62, 0x37, 0x31, 0x61, 0x32, 0x34, 0x39, 0x36, 0x36, 0x35, 0x38, 0x62, 0x38, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x65, 0x65, 0x31, 0x64, 0x66, 0x35, 0x64, 0x34, 0x34, 0x62, 0x31, 0x32, 0x38, 0x34, 0x36, 0x39, 0x65, 0x39, 0x31, 0x33, 0x35, 0x36, 0x39, 0x65, 0x66, 0x36, 0x61, 0x63, 0x38, 0x31, 0x65, 0x65, 0x64, 0x61, 0x34, 0x66, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x62, 0x64, 0x32, 0x34, 0x36, 0x38, 0x36, 0x35, 0x66, 0x61, 0x62, 0x34, 0x39, 0x30, 0x61, 0x63, 0x30, 0x38, 0x37, 0x61, 0x63, 0x31, 0x66, 0x31, 0x64, 0x34, 0x66, 0x32, 0x63, 0x31, 0x30, 0x64, 0x30, 0x63, 0x64, 0x61, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x66, 0x38, 0x62, 0x66, 0x31, 0x64, 0x33, 0x35, 0x61, 0x32, 0x33, 0x31, 0x33, 0x31, 0x35, 0x37, 0x36, 0x34, 0x66, 0x63, 0x38, 0x30, 0x30, 0x31, 0x38, 0x30, 0x39, 0x61, 0x39, 0x34, 0x39, 0x32, 0x39, 0x34, 0x66, 0x63, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x30, 0x66, 0x61, 0x34, 0x35, 0x35, 0x37, 0x36, 0x62, 0x66, 0x39, 0x63, 0x38, 0x36, 0x35, 0x66, 0x39, 0x38, 0x33, 0x38, 0x39, 0x33, 0x30, 0x30, 0x32, 0x63, 0x34, 0x31, 0x34, 0x39, 0x32, 0x36, 0x66, 0x36, 0x31, 0x30, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x65, 0x61, 0x61, 0x63, 0x32, 0x61, 0x63, 0x66, 0x31, 0x64, 0x31, 0x33, 0x38, 0x65, 0x31, 0x39, 0x66, 0x32, 0x66, 0x63, 0x33, 0x66, 0x39, 0x66, 0x62, 0x37, 0x34, 0x35, 0x39, 0x32, 0x65, 0x33, 0x65, 0x64, 0x38, 0x31, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x62, 0x66, 0x62, 0x63, 0x62, 0x36, 0x35, 0x36, 0x63, 0x32, 0x39, 0x39, 0x32, 0x62, 0x65, 0x38, 0x66, 0x63, 0x64, 0x65, 0x38, 0x32, 0x31, 0x39, 0x66, 0x62, 0x63, 0x35, 0x34, 0x61, 0x61, 0x64, 0x64, 0x35, 0x39, 0x66, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x32, 0x32, 0x63, 0x34, 0x63, 0x62, 0x65, 0x37, 0x30, 0x61, 0x39, 0x34, 0x62, 0x36, 0x35, 0x35, 0x39, 0x64, 0x34, 0x32, 0x35, 0x30, 0x38, 0x34, 0x63, 0x61, 0x65, 0x65, 0x64, 0x34, 0x64, 0x36, 0x65, 0x36, 0x36, 0x65, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x65, 0x36, 0x38, 0x31, 0x62, 0x63, 0x32, 0x64, 0x31, 0x30, 0x64, 0x62, 0x36, 0x32, 0x64, 0x65, 0x38, 0x35, 0x38, 0x34, 0x38, 0x33, 0x32, 0x34, 0x34, 0x39, 0x32, 0x32, 0x35, 0x30, 0x33, 0x34, 0x38, 0x65, 0x39, 0x30, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x33, 0x30, 0x38, 0x62, 0x61, 0x63, 0x34, 0x38, 0x35, 0x37, 0x64, 0x33, 0x33, 0x62, 0x61, 0x65, 0x61, 0x30, 0x37, 0x34, 0x66, 0x33, 0x39, 0x35, 0x36, 0x64, 0x33, 0x36, 0x32, 0x31, 0x64, 0x39, 0x66, 0x61, 0x32, 0x38, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x63, 0x30, 0x38, 0x34, 0x39, 0x30, 0x63, 0x38, 0x39, 0x62, 0x66, 0x30, 0x64, 0x36, 0x62, 0x36, 0x66, 0x33, 0x32, 0x30, 0x62, 0x31, 0x61, 0x63, 0x61, 0x39, 0x35, 0x63, 0x38, 0x33, 0x31, 0x32, 0x63, 0x30, 0x30, 0x36, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x31, 0x38, 0x38, 0x34, 0x64, 0x64, 0x62, 0x62, 0x62, 0x38, 0x65, 0x31, 0x30, 0x65, 0x34, 0x64, 0x62, 0x61, 0x36, 0x65, 0x34, 0x34, 0x66, 0x65, 0x65, 0x65, 0x63, 0x32, 0x61, 0x37, 0x65, 0x35, 0x66, 0x39, 0x32, 0x66, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x37, 0x34, 0x31, 0x37, 0x62, 0x64, 0x31, 0x36, 0x62, 0x31, 0x62, 0x33, 0x64, 0x32, 0x32, 0x64, 0x62, 0x62, 0x39, 0x30, 0x32, 0x64, 0x38, 0x66, 0x39, 0x36, 0x35, 0x37, 0x30, 0x31, 0x36, 0x66, 0x32, 0x34, 0x61, 0x36, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x66, 0x39, 0x33, 0x64, 0x65, 0x36, 0x65, 0x65, 0x30, 0x35, 0x34, 0x63, 0x61, 0x64, 0x34, 0x35, 0x39, 0x62, 0x32, 0x64, 0x35, 0x65, 0x62, 0x30, 0x66, 0x36, 0x38, 0x37, 0x30, 0x33, 0x38, 0x39, 0x64, 0x66, 0x63, 0x62, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x39, 0x34, 0x36, 0x62, 0x37, 0x31, 0x31, 0x37, 0x66, 0x63, 0x39, 0x31, 0x35, 0x65, 0x64, 0x31, 0x30, 0x37, 0x33, 0x38, 0x35, 0x66, 0x34, 0x32, 0x64, 0x39, 0x39, 0x64, 0x64, 0x61, 0x63, 0x36, 0x33, 0x32, 0x34, 0x39, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x65, 0x63, 0x30, 0x30, 0x66, 0x38, 0x34, 0x39, 0x62, 0x36, 0x33, 0x31, 0x39, 0x63, 0x66, 0x35, 0x31, 0x61, 0x61, 0x38, 0x64, 0x64, 0x38, 0x66, 0x36, 0x36, 0x62, 0x33, 0x35, 0x35, 0x32, 0x39, 0x63, 0x30, 0x62, 0x65, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x30, 0x66, 0x64, 0x36, 0x65, 0x65, 0x34, 0x65, 0x65, 0x62, 0x61, 0x62, 0x31, 0x30, 0x61, 0x38, 0x63, 0x35, 0x35, 0x64, 0x30, 0x62, 0x34, 0x62, 0x64, 0x32, 0x65, 0x37, 0x64, 0x36, 0x65, 0x66, 0x38, 0x31, 0x37, 0x31, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x32, 0x32, 0x65, 0x34, 0x62, 0x66, 0x30, 0x62, 0x66, 0x37, 0x34, 0x31, 0x34, 0x37, 0x63, 0x63, 0x38, 0x39, 0x35, 0x62, 0x65, 0x64, 0x38, 0x66, 0x31, 0x36, 0x64, 0x33, 0x63, 0x65, 0x66, 0x33, 0x34, 0x32, 0x36, 0x31, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x39, 0x32, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x35, 0x61, 0x65, 0x63, 0x62, 0x61, 0x66, 0x39, 0x62, 0x62, 0x33, 0x39, 0x62, 0x37, 0x34, 0x61, 0x36, 0x37, 0x65, 0x61, 0x31, 0x63, 0x65, 0x36, 0x32, 0x33, 0x64, 0x65, 0x33, 0x36, 0x38, 0x34, 0x38, 0x31, 0x62, 0x61, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x34, 0x39, 0x36, 0x63, 0x62, 0x32, 0x30, 0x36, 0x39, 0x35, 0x36, 0x33, 0x31, 0x34, 0x34, 0x64, 0x30, 0x38, 0x31, 0x31, 0x36, 0x37, 0x37, 0x62, 0x61, 0x30, 0x65, 0x34, 0x37, 0x31, 0x33, 0x61, 0x30, 0x61, 0x34, 0x31, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x30, 0x30, 0x62, 0x37, 0x32, 0x30, 0x37, 0x33, 0x34, 0x65, 0x64, 0x32, 0x32, 0x39, 0x33, 0x38, 0x64, 0x37, 0x38, 0x63, 0x35, 0x65, 0x34, 0x38, 0x62, 0x32, 0x62, 0x61, 0x39, 0x33, 0x36, 0x37, 0x61, 0x35, 0x37, 0x35, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x30, 0x37, 0x32, 0x65, 0x36, 0x65, 0x31, 0x38, 0x33, 0x33, 0x31, 0x33, 0x37, 0x39, 0x39, 0x35, 0x31, 0x39, 0x36, 0x64, 0x37, 0x62, 0x62, 0x31, 0x37, 0x32, 0x35, 0x66, 0x65, 0x66, 0x38, 0x37, 0x36, 0x31, 0x66, 0x36, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x36, 0x34, 0x34, 0x61, 0x64, 0x31, 0x31, 0x36, 0x61, 0x34, 0x31, 0x63, 0x65, 0x32, 0x63, 0x61, 0x37, 0x66, 0x62, 0x65, 0x63, 0x36, 0x30, 0x39, 0x62, 0x64, 0x65, 0x66, 0x37, 0x33, 0x38, 0x61, 0x32, 0x61, 0x63, 0x37, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x64, 0x39, 0x34, 0x32, 0x64, 0x38, 0x32, 0x66, 0x31, 0x37, 0x35, 0x65, 0x63, 0x62, 0x31, 0x63, 0x31, 0x36, 0x61, 0x34, 0x30, 0x35, 0x62, 0x31, 0x30, 0x31, 0x34, 0x33, 0x62, 0x33, 0x66, 0x34, 0x36, 0x62, 0x39, 0x36, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x33, 0x64, 0x64, 0x39, 0x63, 0x31, 0x34, 0x32, 0x62, 0x37, 0x31, 0x62, 0x63, 0x65, 0x31, 0x31, 0x64, 0x30, 0x36, 0x65, 0x33, 0x30, 0x65, 0x37, 0x65, 0x37, 0x64, 0x30, 0x33, 0x32, 0x66, 0x32, 0x65, 0x63, 0x39, 0x63, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x32, 0x37, 0x64, 0x37, 0x35, 0x39, 0x64, 0x35, 0x36, 0x65, 0x30, 0x61, 0x62, 0x38, 0x37, 0x61, 0x66, 0x33, 0x37, 0x65, 0x63, 0x66, 0x36, 0x33, 0x66, 0x65, 0x30, 0x31, 0x66, 0x33, 0x31, 0x30, 0x62, 0x65, 0x31, 0x30, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x66, 0x61, 0x32, 0x35, 0x38, 0x30, 0x66, 0x39, 0x65, 0x62, 0x65, 0x34, 0x32, 0x30, 0x66, 0x33, 0x65, 0x35, 0x65, 0x65, 0x66, 0x64, 0x64, 0x33, 0x37, 0x31, 0x36, 0x33, 0x38, 0x65, 0x33, 0x62, 0x37, 0x61, 0x66, 0x34, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x34, 0x62, 0x64, 0x64, 0x32, 0x63, 0x37, 0x62, 0x66, 0x64, 0x35, 0x30, 0x30, 0x65, 0x65, 0x37, 0x34, 0x30, 0x34, 0x66, 0x37, 0x66, 0x62, 0x33, 0x65, 0x39, 0x66, 0x62, 0x33, 0x31, 0x64, 0x64, 0x32, 0x30, 0x66, 0x62, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x62, 0x31, 0x34, 0x62, 0x66, 0x34, 0x35, 0x34, 0x35, 0x35, 0x64, 0x30, 0x61, 0x62, 0x30, 0x38, 0x30, 0x33, 0x33, 0x35, 0x38, 0x62, 0x37, 0x35, 0x32, 0x34, 0x61, 0x37, 0x32, 0x62, 0x65, 0x31, 0x61, 0x32, 0x30, 0x34, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x65, 0x32, 0x64, 0x64, 0x39, 0x35, 0x65, 0x33, 0x39, 0x61, 0x65, 0x39, 0x37, 0x37, 0x35, 0x63, 0x35, 0x35, 0x61, 0x65, 0x62, 0x31, 0x33, 0x66, 0x31, 0x32, 0x63, 0x32, 0x66, 0x61, 0x32, 0x33, 0x33, 0x30, 0x35, 0x33, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x62, 0x30, 0x33, 0x65, 0x61, 0x34, 0x32, 0x34, 0x35, 0x37, 0x33, 0x36, 0x66, 0x35, 0x37, 0x62, 0x38, 0x35, 0x64, 0x32, 0x65, 0x62, 0x37, 0x39, 0x36, 0x32, 0x38, 0x66, 0x30, 0x33, 0x36, 0x64, 0x64, 0x63, 0x64, 0x37, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x32, 0x65, 0x66, 0x33, 0x64, 0x33, 0x38, 0x66, 0x65, 0x36, 0x35, 0x32, 0x34, 0x30, 0x33, 0x63, 0x64, 0x34, 0x63, 0x39, 0x64, 0x38, 0x35, 0x65, 0x64, 0x37, 0x66, 0x30, 0x36, 0x38, 0x32, 0x63, 0x64, 0x37, 0x63, 0x32, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x37, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x30, 0x35, 0x39, 0x34, 0x64, 0x33, 0x30, 0x36, 0x36, 0x31, 0x33, 0x63, 0x64, 0x33, 0x65, 0x32, 0x66, 0x64, 0x32, 0x34, 0x62, 0x63, 0x61, 0x39, 0x39, 0x39, 0x34, 0x61, 0x64, 0x39, 0x38, 0x61, 0x33, 0x64, 0x37, 0x33, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x39, 0x37, 0x61, 0x31, 0x62, 0x63, 0x34, 0x37, 0x61, 0x63, 0x64, 0x36, 0x34, 0x37, 0x34, 0x31, 0x38, 0x31, 0x35, 0x39, 0x62, 0x39, 0x39, 0x63, 0x65, 0x61, 0x35, 0x37, 0x65, 0x31, 0x65, 0x36, 0x35, 0x33, 0x32, 0x64, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x36, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x34, 0x38, 0x31, 0x35, 0x61, 0x30, 0x66, 0x32, 0x38, 0x65, 0x35, 0x36, 0x39, 0x64, 0x30, 0x65, 0x39, 0x32, 0x31, 0x61, 0x34, 0x61, 0x64, 0x65, 0x38, 0x66, 0x62, 0x32, 0x36, 0x34, 0x32, 0x35, 0x32, 0x36, 0x34, 0x39, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x34, 0x31, 0x30, 0x39, 0x62, 0x65, 0x32, 0x66, 0x35, 0x31, 0x33, 0x64, 0x38, 0x37, 0x34, 0x39, 0x38, 0x65, 0x39, 0x32, 0x36, 0x61, 0x32, 0x38, 0x36, 0x34, 0x39, 0x39, 0x37, 0x35, 0x34, 0x66, 0x39, 0x65, 0x64, 0x34, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x61, 0x63, 0x32, 0x39, 0x62, 0x64, 0x61, 0x39, 0x33, 0x66, 0x34, 0x39, 0x37, 0x62, 0x63, 0x34, 0x61, 0x65, 0x61, 0x61, 0x62, 0x39, 0x33, 0x35, 0x34, 0x35, 0x32, 0x63, 0x34, 0x33, 0x31, 0x35, 0x31, 0x30, 0x33, 0x34, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x38, 0x31, 0x61, 0x62, 0x65, 0x34, 0x39, 0x38, 0x34, 0x63, 0x37, 0x63, 0x36, 0x62, 0x65, 0x66, 0x36, 0x33, 0x64, 0x36, 0x39, 0x38, 0x32, 0x30, 0x65, 0x35, 0x35, 0x37, 0x34, 0x33, 0x63, 0x36, 0x31, 0x66, 0x32, 0x30, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x31, 0x31, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x64, 0x63, 0x63, 0x35, 0x66, 0x62, 0x34, 0x65, 0x65, 0x37, 0x66, 0x65, 0x65, 0x30, 0x34, 0x36, 0x65, 0x31, 0x34, 0x31, 0x38, 0x31, 0x39, 0x61, 0x61, 0x39, 0x36, 0x38, 0x37, 0x39, 0x39, 0x64, 0x36, 0x34, 0x34, 0x34, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x66, 0x66, 0x33, 0x38, 0x37, 0x34, 0x33, 0x65, 0x64, 0x30, 0x63, 0x64, 0x34, 0x33, 0x33, 0x30, 0x38, 0x63, 0x30, 0x36, 0x36, 0x35, 0x30, 0x39, 0x63, 0x63, 0x38, 0x65, 0x37, 0x65, 0x37, 0x32, 0x63, 0x38, 0x36, 0x32, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x66, 0x32, 0x30, 0x30, 0x30, 0x35, 0x62, 0x36, 0x31, 0x33, 0x35, 0x32, 0x66, 0x66, 0x61, 0x37, 0x36, 0x39, 0x39, 0x61, 0x31, 0x62, 0x35, 0x32, 0x66, 0x30, 0x31, 0x66, 0x35, 0x61, 0x62, 0x33, 0x39, 0x31, 0x36, 0x37, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x64, 0x61, 0x34, 0x31, 0x31, 0x62, 0x64, 0x35, 0x31, 0x36, 0x33, 0x62, 0x61, 0x65, 0x63, 0x61, 0x31, 0x65, 0x35, 0x35, 0x38, 0x35, 0x36, 0x33, 0x36, 0x30, 0x31, 0x63, 0x65, 0x37, 0x32, 0x30, 0x65, 0x32, 0x34, 0x65, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x32, 0x34, 0x35, 0x66, 0x35, 0x39, 0x36, 0x36, 0x39, 0x31, 0x30, 0x39, 0x33, 0x65, 0x63, 0x65, 0x33, 0x66, 0x33, 0x64, 0x33, 0x63, 0x61, 0x32, 0x32, 0x36, 0x33, 0x65, 0x61, 0x63, 0x65, 0x38, 0x31, 0x39, 0x34, 0x31, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x32, 0x61, 0x35, 0x38, 0x38, 0x32, 0x65, 0x38, 0x39, 0x32, 0x37, 0x64, 0x39, 0x34, 0x34, 0x62, 0x33, 0x35, 0x39, 0x62, 0x32, 0x36, 0x33, 0x36, 0x36, 0x62, 0x61, 0x32, 0x62, 0x39, 0x63, 0x61, 0x63, 0x66, 0x62, 0x61, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x38, 0x63, 0x31, 0x38, 0x62, 0x32, 0x64, 0x63, 0x65, 0x31, 0x37, 0x30, 0x65, 0x38, 0x66, 0x34, 0x34, 0x35, 0x37, 0x35, 0x33, 0x62, 0x61, 0x35, 0x64, 0x37, 0x35, 0x31, 0x33, 0x63, 0x62, 0x37, 0x36, 0x33, 0x36, 0x64, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x36, 0x38, 0x62, 0x33, 0x62, 0x62, 0x38, 0x63, 0x31, 0x36, 0x37, 0x33, 0x32, 0x31, 0x64, 0x39, 0x62, 0x64, 0x62, 0x30, 0x32, 0x33, 0x61, 0x36, 0x65, 0x39, 0x66, 0x64, 0x31, 0x31, 0x61, 0x66, 0x63, 0x39, 0x61, 0x66, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x31, 0x30, 0x33, 0x62, 0x62, 0x36, 0x62, 0x36, 0x37, 0x61, 0x35, 0x35, 0x61, 0x37, 0x66, 0x65, 0x63, 0x65, 0x32, 0x64, 0x31, 0x61, 0x66, 0x36, 0x32, 0x64, 0x34, 0x35, 0x37, 0x63, 0x32, 0x31, 0x37, 0x38, 0x39, 0x34, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x39, 0x66, 0x64, 0x61, 0x37, 0x64, 0x39, 0x38, 0x31, 0x66, 0x65, 0x39, 0x64, 0x36, 0x34, 0x32, 0x38, 0x37, 0x66, 0x38, 0x35, 0x63, 0x39, 0x34, 0x64, 0x38, 0x33, 0x66, 0x39, 0x30, 0x37, 0x34, 0x38, 0x34, 0x39, 0x66, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x32, 0x31, 0x31, 0x37, 0x31, 0x32, 0x37, 0x31, 0x39, 0x66, 0x32, 0x62, 0x30, 0x38, 0x34, 0x64, 0x33, 0x62, 0x33, 0x38, 0x37, 0x35, 0x61, 0x38, 0x35, 0x30, 0x36, 0x39, 0x66, 0x34, 0x36, 0x36, 0x33, 0x36, 0x33, 0x31, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x36, 0x33, 0x38, 0x34, 0x39, 0x37, 0x33, 0x39, 0x32, 0x36, 0x35, 0x61, 0x36, 0x33, 0x62, 0x30, 0x61, 0x32, 0x62, 0x66, 0x32, 0x33, 0x36, 0x61, 0x35, 0x39, 0x31, 0x33, 0x65, 0x36, 0x66, 0x39, 0x35, 0x39, 0x63, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x64, 0x31, 0x37, 0x37, 0x38, 0x65, 0x66, 0x36, 0x65, 0x65, 0x35, 0x66, 0x65, 0x34, 0x38, 0x38, 0x63, 0x31, 0x34, 0x35, 0x66, 0x33, 0x35, 0x38, 0x36, 0x62, 0x36, 0x65, 0x62, 0x62, 0x65, 0x33, 0x66, 0x62, 0x62, 0x34, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x37, 0x37, 0x61, 0x34, 0x64, 0x38, 0x38, 0x63, 0x30, 0x64, 0x35, 0x36, 0x61, 0x33, 0x64, 0x62, 0x65, 0x33, 0x62, 0x61, 0x65, 0x30, 0x34, 0x61, 0x30, 0x35, 0x66, 0x34, 0x66, 0x63, 0x64, 0x31, 0x62, 0x37, 0x35, 0x37, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x39, 0x63, 0x30, 0x66, 0x66, 0x66, 0x65, 0x66, 0x62, 0x38, 0x30, 0x33, 0x30, 0x38, 0x31, 0x32, 0x35, 0x36, 0x63, 0x30, 0x63, 0x66, 0x34, 0x64, 0x36, 0x36, 0x35, 0x39, 0x65, 0x36, 0x64, 0x33, 0x33, 0x65, 0x62, 0x34, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x33, 0x30, 0x31, 0x37, 0x66, 0x66, 0x31, 0x61, 0x64, 0x61, 0x64, 0x34, 0x39, 0x39, 0x61, 0x61, 0x30, 0x36, 0x35, 0x34, 0x30, 0x31, 0x62, 0x34, 0x32, 0x33, 0x36, 0x63, 0x65, 0x36, 0x65, 0x39, 0x32, 0x62, 0x36, 0x32, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x33, 0x63, 0x36, 0x37, 0x65, 0x30, 0x39, 0x62, 0x35, 0x63, 0x37, 0x31, 0x33, 0x63, 0x35, 0x32, 0x32, 0x31, 0x63, 0x38, 0x61, 0x30, 0x63, 0x37, 0x66, 0x33, 0x66, 0x37, 0x34, 0x34, 0x36, 0x36, 0x63, 0x33, 0x34, 0x37, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x65, 0x33, 0x30, 0x33, 0x34, 0x31, 0x31, 0x61, 0x66, 0x61, 0x66, 0x36, 0x63, 0x31, 0x30, 0x37, 0x61, 0x34, 0x34, 0x31, 0x30, 0x31, 0x63, 0x39, 0x61, 0x63, 0x35, 0x62, 0x33, 0x36, 0x65, 0x39, 0x64, 0x36, 0x35, 0x33, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x63, 0x35, 0x30, 0x61, 0x61, 0x38, 0x32, 0x33, 0x66, 0x34, 0x36, 0x35, 0x62, 0x39, 0x34, 0x36, 0x34, 0x62, 0x30, 0x62, 0x63, 0x30, 0x63, 0x34, 0x61, 0x35, 0x37, 0x37, 0x32, 0x34, 0x61, 0x35, 0x35, 0x35, 0x66, 0x35, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x65, 0x33, 0x61, 0x36, 0x65, 0x61, 0x35, 0x30, 0x39, 0x35, 0x37, 0x33, 0x65, 0x32, 0x31, 0x62, 0x64, 0x30, 0x32, 0x33, 0x39, 0x65, 0x63, 0x65, 0x30, 0x35, 0x32, 0x33, 0x61, 0x37, 0x62, 0x37, 0x64, 0x38, 0x39, 0x62, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x36, 0x39, 0x65, 0x66, 0x30, 0x65, 0x62, 0x33, 0x34, 0x32, 0x39, 0x39, 0x61, 0x62, 0x64, 0x32, 0x65, 0x33, 0x32, 0x64, 0x61, 0x62, 0x63, 0x34, 0x37, 0x39, 0x34, 0x34, 0x62, 0x32, 0x37, 0x32, 0x33, 0x33, 0x34, 0x38, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x61, 0x33, 0x64, 0x61, 0x30, 0x39, 0x61, 0x38, 0x31, 0x39, 0x34, 0x38, 0x31, 0x39, 0x61, 0x65, 0x31, 0x39, 0x39, 0x66, 0x32, 0x65, 0x36, 0x64, 0x39, 0x64, 0x31, 0x33, 0x30, 0x34, 0x38, 0x31, 0x37, 0x65, 0x32, 0x38, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x34, 0x39, 0x35, 0x62, 0x61, 0x35, 0x38, 0x34, 0x32, 0x37, 0x32, 0x38, 0x63, 0x30, 0x65, 0x64, 0x39, 0x37, 0x62, 0x65, 0x33, 0x37, 0x64, 0x30, 0x65, 0x34, 0x32, 0x32, 0x62, 0x39, 0x38, 0x64, 0x36, 0x39, 0x32, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x61, 0x39, 0x37, 0x36, 0x66, 0x31, 0x61, 0x31, 0x32, 0x31, 0x35, 0x66, 0x37, 0x35, 0x31, 0x32, 0x38, 0x37, 0x31, 0x38, 0x39, 0x32, 0x64, 0x34, 0x35, 0x66, 0x37, 0x30, 0x34, 0x38, 0x61, 0x63, 0x64, 0x33, 0x35, 0x36, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x37, 0x63, 0x61, 0x63, 0x34, 0x31, 0x63, 0x64, 0x37, 0x30, 0x36, 0x66, 0x33, 0x33, 0x34, 0x35, 0x66, 0x32, 0x64, 0x33, 0x34, 0x61, 0x63, 0x33, 0x34, 0x65, 0x30, 0x31, 0x37, 0x35, 0x32, 0x61, 0x36, 0x65, 0x35, 0x39, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x35, 0x33, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x65, 0x30, 0x62, 0x32, 0x65, 0x32, 0x39, 0x64, 0x64, 0x65, 0x37, 0x33, 0x61, 0x66, 0x37, 0x35, 0x39, 0x38, 0x37, 0x65, 0x65, 0x34, 0x34, 0x34, 0x36, 0x63, 0x38, 0x32, 0x39, 0x61, 0x31, 0x38, 0x39, 0x63, 0x39, 0x35, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x35, 0x66, 0x61, 0x65, 0x33, 0x62, 0x30, 0x33, 0x37, 0x32, 0x63, 0x32, 0x33, 0x30, 0x63, 0x31, 0x32, 0x35, 0x64, 0x36, 0x64, 0x34, 0x37, 0x30, 0x31, 0x34, 0x30, 0x33, 0x33, 0x37, 0x61, 0x62, 0x39, 0x31, 0x35, 0x36, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x35, 0x31, 0x37, 0x37, 0x65, 0x62, 0x37, 0x34, 0x61, 0x64, 0x30, 0x61, 0x39, 0x64, 0x39, 0x61, 0x35, 0x37, 0x35, 0x32, 0x32, 0x32, 0x38, 0x31, 0x34, 0x37, 0x65, 0x65, 0x36, 0x64, 0x36, 0x33, 0x35, 0x36, 0x61, 0x36, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x62, 0x37, 0x62, 0x62, 0x61, 0x31, 0x66, 0x39, 0x35, 0x37, 0x33, 0x66, 0x32, 0x34, 0x31, 0x31, 0x35, 0x64, 0x38, 0x63, 0x38, 0x63, 0x36, 0x32, 0x65, 0x39, 0x63, 0x65, 0x38, 0x38, 0x39, 0x35, 0x30, 0x36, 0x38, 0x65, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x36, 0x61, 0x33, 0x37, 0x66, 0x30, 0x31, 0x38, 0x65, 0x39, 0x37, 0x39, 0x36, 0x37, 0x39, 0x33, 0x37, 0x66, 0x63, 0x35, 0x65, 0x38, 0x36, 0x31, 0x37, 0x62, 0x61, 0x31, 0x64, 0x37, 0x38, 0x36, 0x64, 0x64, 0x35, 0x66, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x65, 0x33, 0x61, 0x39, 0x33, 0x65, 0x37, 0x32, 0x31, 0x34, 0x34, 0x61, 0x64, 0x61, 0x38, 0x36, 0x30, 0x63, 0x62, 0x63, 0x35, 0x36, 0x66, 0x66, 0x38, 0x35, 0x31, 0x34, 0x35, 0x61, 0x64, 0x61, 0x33, 0x38, 0x63, 0x36, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x64, 0x61, 0x39, 0x32, 0x32, 0x65, 0x66, 0x66, 0x61, 0x34, 0x37, 0x32, 0x61, 0x36, 0x62, 0x31, 0x32, 0x34, 0x65, 0x38, 0x34, 0x65, 0x61, 0x38, 0x66, 0x38, 0x36, 0x62, 0x32, 0x34, 0x65, 0x30, 0x66, 0x35, 0x31, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x39, 0x62, 0x64, 0x34, 0x35, 0x38, 0x39, 0x35, 0x33, 0x35, 0x64, 0x62, 0x32, 0x37, 0x66, 0x61, 0x32, 0x62, 0x63, 0x39, 0x30, 0x33, 0x63, 0x61, 0x31, 0x37, 0x64, 0x36, 0x37, 0x39, 0x64, 0x64, 0x36, 0x35, 0x34, 0x38, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x61, 0x39, 0x65, 0x39, 0x62, 0x37, 0x33, 0x61, 0x65, 0x39, 0x38, 0x62, 0x38, 0x36, 0x34, 0x64, 0x31, 0x37, 0x32, 0x38, 0x37, 0x39, 0x38, 0x62, 0x38, 0x37, 0x36, 0x36, 0x64, 0x62, 0x63, 0x36, 0x65, 0x61, 0x38, 0x64, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x37, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x35, 0x38, 0x30, 0x61, 0x62, 0x35, 0x65, 0x64, 0x34, 0x63, 0x37, 0x64, 0x66, 0x61, 0x35, 0x30, 0x36, 0x66, 0x61, 0x36, 0x66, 0x65, 0x36, 0x34, 0x61, 0x64, 0x35, 0x63, 0x65, 0x31, 0x32, 0x39, 0x37, 0x30, 0x37, 0x37, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x34, 0x61, 0x37, 0x39, 0x38, 0x35, 0x65, 0x33, 0x63, 0x63, 0x37, 0x65, 0x62, 0x35, 0x63, 0x39, 0x33, 0x36, 0x39, 0x31, 0x66, 0x36, 0x66, 0x38, 0x63, 0x63, 0x37, 0x62, 0x38, 0x66, 0x32, 0x34, 0x35, 0x64, 0x30, 0x31, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x34, 0x36, 0x62, 0x36, 0x63, 0x36, 0x36, 0x39, 0x39, 0x63, 0x38, 0x66, 0x33, 0x34, 0x63, 0x61, 0x32, 0x37, 0x36, 0x38, 0x61, 0x38, 0x32, 0x30, 0x66, 0x31, 0x66, 0x66, 0x61, 0x34, 0x63, 0x32, 0x30, 0x37, 0x66, 0x65, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x61, 0x34, 0x39, 0x31, 0x66, 0x62, 0x35, 0x39, 0x32, 0x30, 0x61, 0x36, 0x35, 0x37, 0x34, 0x65, 0x62, 0x64, 0x32, 0x38, 0x39, 0x66, 0x33, 0x39, 0x63, 0x31, 0x62, 0x32, 0x34, 0x33, 0x30, 0x64, 0x32, 0x64, 0x39, 0x61, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x65, 0x37, 0x36, 0x37, 0x31, 0x39, 0x64, 0x39, 0x37, 0x65, 0x61, 0x63, 0x34, 0x31, 0x38, 0x37, 0x30, 0x34, 0x32, 0x38, 0x65, 0x39, 0x34, 0x30, 0x32, 0x37, 0x39, 0x64, 0x39, 0x37, 0x64, 0x64, 0x35, 0x37, 0x62, 0x32, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x62, 0x32, 0x64, 0x62, 0x64, 0x37, 0x39, 0x64, 0x64, 0x61, 0x39, 0x62, 0x38, 0x36, 0x34, 0x66, 0x36, 0x61, 0x37, 0x30, 0x33, 0x30, 0x32, 0x37, 0x35, 0x34, 0x31, 0x39, 0x63, 0x33, 0x39, 0x64, 0x33, 0x65, 0x66, 0x64, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x38, 0x32, 0x35, 0x34, 0x31, 0x32, 0x31, 0x61, 0x36, 0x65, 0x39, 0x34, 0x32, 0x66, 0x63, 0x39, 0x30, 0x38, 0x32, 0x38, 0x66, 0x32, 0x34, 0x33, 0x31, 0x66, 0x35, 0x31, 0x31, 0x64, 0x61, 0x64, 0x37, 0x66, 0x33, 0x32, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x66, 0x61, 0x63, 0x31, 0x65, 0x36, 0x62, 0x63, 0x31, 0x32, 0x32, 0x65, 0x39, 0x33, 0x36, 0x64, 0x66, 0x62, 0x38, 0x34, 0x64, 0x65, 0x30, 0x63, 0x34, 0x62, 0x65, 0x66, 0x36, 0x65, 0x30, 0x64, 0x36, 0x30, 0x63, 0x32, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x31, 0x30, 0x38, 0x38, 0x38, 0x62, 0x37, 0x65, 0x31, 0x34, 0x39, 0x63, 0x61, 0x65, 0x32, 0x37, 0x32, 0x63, 0x30, 0x31, 0x33, 0x30, 0x32, 0x63, 0x33, 0x32, 0x37, 0x64, 0x30, 0x61, 0x66, 0x30, 0x31, 0x61, 0x30, 0x62, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x31, 0x33, 0x35, 0x34, 0x61, 0x32, 0x39, 0x37, 0x39, 0x35, 0x32, 0x66, 0x61, 0x39, 0x37, 0x32, 0x61, 0x64, 0x33, 0x38, 0x33, 0x63, 0x61, 0x30, 0x37, 0x61, 0x30, 0x61, 0x32, 0x38, 0x31, 0x31, 0x64, 0x37, 0x34, 0x61, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x38, 0x36, 0x35, 0x64, 0x62, 0x31, 0x34, 0x38, 0x38, 0x38, 0x31, 0x39, 0x35, 0x31, 0x66, 0x35, 0x31, 0x32, 0x35, 0x31, 0x37, 0x31, 0x30, 0x65, 0x38, 0x32, 0x62, 0x39, 0x62, 0x65, 0x30, 0x64, 0x37, 0x65, 0x61, 0x64, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x62, 0x64, 0x36, 0x65, 0x63, 0x62, 0x62, 0x35, 0x37, 0x35, 0x32, 0x38, 0x39, 0x31, 0x62, 0x34, 0x63, 0x65, 0x62, 0x33, 0x63, 0x63, 0x65, 0x37, 0x33, 0x61, 0x38, 0x66, 0x34, 0x37, 0x37, 0x30, 0x35, 0x39, 0x33, 0x37, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x32, 0x33, 0x36, 0x31, 0x30, 0x38, 0x65, 0x65, 0x63, 0x37, 0x32, 0x32, 0x38, 0x39, 0x62, 0x61, 0x63, 0x33, 0x61, 0x36, 0x35, 0x63, 0x64, 0x32, 0x38, 0x33, 0x66, 0x39, 0x35, 0x65, 0x30, 0x34, 0x31, 0x64, 0x31, 0x34, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x38, 0x33, 0x62, 0x36, 0x66, 0x64, 0x30, 0x64, 0x35, 0x31, 0x32, 0x31, 0x33, 0x31, 0x32, 0x30, 0x34, 0x37, 0x30, 0x37, 0x65, 0x61, 0x66, 0x37, 0x32, 0x65, 0x61, 0x30, 0x63, 0x38, 0x63, 0x39, 0x62, 0x65, 0x66, 0x39, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x36, 0x65, 0x65, 0x66, 0x66, 0x35, 0x62, 0x61, 0x39, 0x30, 0x61, 0x36, 0x38, 0x37, 0x39, 0x61, 0x31, 0x34, 0x64, 0x66, 0x66, 0x34, 0x63, 0x35, 0x30, 0x34, 0x33, 0x62, 0x31, 0x38, 0x63, 0x61, 0x30, 0x34, 0x36, 0x30, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x63, 0x35, 0x63, 0x61, 0x39, 0x34, 0x37, 0x35, 0x38, 0x30, 0x37, 0x38, 0x66, 0x62, 0x66, 0x63, 0x63, 0x64, 0x31, 0x39, 0x64, 0x62, 0x33, 0x35, 0x35, 0x38, 0x64, 0x61, 0x37, 0x65, 0x65, 0x38, 0x61, 0x30, 0x61, 0x37, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x64, 0x36, 0x32, 0x63, 0x34, 0x37, 0x65, 0x61, 0x36, 0x30, 0x66, 0x62, 0x39, 0x30, 0x61, 0x33, 0x36, 0x33, 0x39, 0x32, 0x30, 0x39, 0x62, 0x62, 0x66, 0x64, 0x64, 0x34, 0x64, 0x39, 0x33, 0x33, 0x39, 0x39, 0x31, 0x63, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x31, 0x63, 0x62, 0x38, 0x32, 0x33, 0x38, 0x63, 0x38, 0x38, 0x65, 0x39, 0x33, 0x61, 0x31, 0x62, 0x63, 0x66, 0x36, 0x31, 0x64, 0x62, 0x34, 0x39, 0x62, 0x64, 0x38, 0x32, 0x62, 0x34, 0x37, 0x61, 0x37, 0x66, 0x34, 0x66, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x35, 0x33, 0x30, 0x30, 0x33, 0x33, 0x34, 0x36, 0x64, 0x36, 0x35, 0x63, 0x35, 0x65, 0x37, 0x61, 0x36, 0x34, 0x36, 0x62, 0x63, 0x30, 0x33, 0x34, 0x66, 0x32, 0x62, 0x37, 0x64, 0x33, 0x32, 0x66, 0x63, 0x62, 0x65, 0x35, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x38, 0x39, 0x63, 0x35, 0x31, 0x65, 0x61, 0x36, 0x64, 0x65, 0x31, 0x33, 0x65, 0x30, 0x36, 0x63, 0x64, 0x63, 0x37, 0x34, 0x38, 0x62, 0x36, 0x37, 0x63, 0x34, 0x34, 0x31, 0x30, 0x66, 0x65, 0x39, 0x62, 0x63, 0x61, 0x62, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x31, 0x63, 0x64, 0x62, 0x61, 0x64, 0x66, 0x30, 0x34, 0x62, 0x31, 0x65, 0x35, 0x34, 0x63, 0x38, 0x38, 0x33, 0x64, 0x65, 0x36, 0x30, 0x30, 0x35, 0x66, 0x63, 0x64, 0x66, 0x31, 0x36, 0x62, 0x65, 0x62, 0x38, 0x65, 0x62, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x39, 0x35, 0x31, 0x64, 0x65, 0x35, 0x61, 0x65, 0x66, 0x61, 0x66, 0x30, 0x34, 0x35, 0x38, 0x37, 0x36, 0x38, 0x64, 0x37, 0x37, 0x34, 0x63, 0x32, 0x35, 0x34, 0x66, 0x37, 0x31, 0x35, 0x37, 0x37, 0x33, 0x35, 0x65, 0x35, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x37, 0x33, 0x32, 0x63, 0x66, 0x32, 0x63, 0x31, 0x33, 0x62, 0x38, 0x62, 0x62, 0x38, 0x65, 0x37, 0x34, 0x39, 0x32, 0x61, 0x39, 0x38, 0x38, 0x66, 0x35, 0x66, 0x38, 0x39, 0x65, 0x33, 0x38, 0x32, 0x37, 0x33, 0x64, 0x64, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x35, 0x32, 0x32, 0x31, 0x38, 0x65, 0x35, 0x34, 0x64, 0x65, 0x34, 0x32, 0x33, 0x66, 0x38, 0x36, 0x63, 0x30, 0x35, 0x30, 0x31, 0x39, 0x33, 0x33, 0x39, 0x31, 0x37, 0x61, 0x65, 0x61, 0x30, 0x38, 0x63, 0x38, 0x66, 0x65, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x32, 0x66, 0x34, 0x65, 0x38, 0x36, 0x30, 0x65, 0x66, 0x33, 0x65, 0x65, 0x38, 0x30, 0x36, 0x61, 0x35, 0x30, 0x32, 0x37, 0x37, 0x37, 0x61, 0x31, 0x62, 0x38, 0x64, 0x62, 0x63, 0x39, 0x31, 0x61, 0x39, 0x30, 0x37, 0x36, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x62, 0x39, 0x36, 0x66, 0x33, 0x30, 0x63, 0x32, 0x33, 0x62, 0x38, 0x36, 0x36, 0x34, 0x65, 0x37, 0x34, 0x39, 0x30, 0x36, 0x35, 0x31, 0x30, 0x36, 0x36, 0x62, 0x30, 0x30, 0x63, 0x34, 0x33, 0x39, 0x31, 0x66, 0x62, 0x66, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x30, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x39, 0x33, 0x65, 0x39, 0x62, 0x38, 0x62, 0x65, 0x39, 0x34, 0x34, 0x32, 0x35, 0x65, 0x65, 0x66, 0x37, 0x39, 0x36, 0x39, 0x62, 0x63, 0x36, 0x39, 0x66, 0x39, 0x64, 0x34, 0x32, 0x66, 0x37, 0x63, 0x61, 0x64, 0x36, 0x37, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x31, 0x35, 0x35, 0x37, 0x64, 0x66, 0x64, 0x66, 0x62, 0x31, 0x61, 0x31, 0x62, 0x64, 0x63, 0x65, 0x66, 0x65, 0x66, 0x65, 0x32, 0x65, 0x62, 0x61, 0x31, 0x65, 0x32, 0x31, 0x66, 0x65, 0x30, 0x61, 0x34, 0x61, 0x39, 0x39, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x34, 0x35, 0x38, 0x65, 0x30, 0x36, 0x38, 0x35, 0x35, 0x37, 0x33, 0x63, 0x62, 0x34, 0x64, 0x32, 0x38, 0x66, 0x35, 0x33, 0x30, 0x39, 0x38, 0x38, 0x32, 0x39, 0x39, 0x30, 0x34, 0x35, 0x37, 0x30, 0x31, 0x37, 0x39, 0x32, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x65, 0x34, 0x64, 0x39, 0x36, 0x39, 0x36, 0x64, 0x63, 0x62, 0x33, 0x66, 0x34, 0x64, 0x37, 0x62, 0x33, 0x66, 0x37, 0x30, 0x64, 0x63, 0x61, 0x61, 0x34, 0x65, 0x65, 0x63, 0x62, 0x37, 0x31, 0x37, 0x38, 0x32, 0x66, 0x66, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x63, 0x61, 0x30, 0x65, 0x34, 0x34, 0x39, 0x61, 0x62, 0x36, 0x34, 0x36, 0x64, 0x62, 0x64, 0x66, 0x64, 0x33, 0x39, 0x33, 0x61, 0x39, 0x36, 0x36, 0x36, 0x32, 0x39, 0x36, 0x30, 0x62, 0x63, 0x61, 0x62, 0x35, 0x61, 0x65, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x64, 0x37, 0x61, 0x63, 0x30, 0x36, 0x35, 0x33, 0x63, 0x63, 0x63, 0x36, 0x37, 0x61, 0x61, 0x39, 0x63, 0x33, 0x34, 0x36, 0x39, 0x65, 0x65, 0x66, 0x34, 0x33, 0x35, 0x32, 0x31, 0x39, 0x33, 0x66, 0x37, 0x64, 0x62, 0x62, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x39, 0x66, 0x35, 0x63, 0x33, 0x66, 0x62, 0x62, 0x65, 0x30, 0x63, 0x39, 0x62, 0x63, 0x62, 0x66, 0x31, 0x61, 0x66, 0x38, 0x66, 0x66, 0x37, 0x34, 0x65, 0x61, 0x32, 0x38, 0x30, 0x62, 0x33, 0x61, 0x35, 0x64, 0x38, 0x62, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x35, 0x31, 0x66, 0x33, 0x36, 0x33, 0x61, 0x30, 0x61, 0x37, 0x66, 0x64, 0x30, 0x35, 0x33, 0x33, 0x31, 0x39, 0x30, 0x38, 0x30, 0x39, 0x64, 0x64, 0x61, 0x66, 0x39, 0x33, 0x34, 0x30, 0x64, 0x38, 0x64, 0x31, 0x31, 0x32, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x38, 0x61, 0x32, 0x61, 0x66, 0x34, 0x32, 0x35, 0x63, 0x65, 0x62, 0x30, 0x31, 0x65, 0x38, 0x37, 0x66, 0x66, 0x63, 0x31, 0x62, 0x65, 0x35, 0x34, 0x63, 0x30, 0x66, 0x35, 0x33, 0x32, 0x62, 0x32, 0x30, 0x65, 0x61, 0x63, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x31, 0x32, 0x32, 0x61, 0x30, 0x33, 0x63, 0x64, 0x30, 0x35, 0x38, 0x63, 0x31, 0x32, 0x32, 0x65, 0x35, 0x66, 0x65, 0x31, 0x37, 0x62, 0x38, 0x37, 0x32, 0x66, 0x34, 0x38, 0x37, 0x37, 0x66, 0x39, 0x64, 0x66, 0x39, 0x35, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x61, 0x34, 0x63, 0x61, 0x38, 0x38, 0x39, 0x33, 0x35, 0x63, 0x32, 0x37, 0x66, 0x35, 0x35, 0x63, 0x33, 0x31, 0x31, 0x30, 0x34, 0x38, 0x38, 0x34, 0x30, 0x65, 0x35, 0x38, 0x39, 0x65, 0x30, 0x34, 0x61, 0x38, 0x61, 0x30, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x37, 0x63, 0x32, 0x63, 0x31, 0x36, 0x36, 0x35, 0x63, 0x38, 0x38, 0x33, 0x33, 0x38, 0x36, 0x38, 0x38, 0x31, 0x38, 0x37, 0x36, 0x32, 0x39, 0x66, 0x34, 0x39, 0x65, 0x39, 0x39, 0x62, 0x36, 0x30, 0x62, 0x32, 0x64, 0x33, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x63, 0x38, 0x32, 0x33, 0x37, 0x33, 0x61, 0x64, 0x65, 0x38, 0x65, 0x62, 0x63, 0x66, 0x32, 0x61, 0x63, 0x62, 0x36, 0x66, 0x38, 0x62, 0x63, 0x32, 0x34, 0x31, 0x34, 0x64, 0x64, 0x37, 0x61, 0x62, 0x62, 0x37, 0x30, 0x64, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x63, 0x32, 0x34, 0x37, 0x66, 0x35, 0x33, 0x62, 0x39, 0x66, 0x62, 0x65, 0x62, 0x31, 0x37, 0x62, 0x62, 0x61, 0x30, 0x37, 0x30, 0x33, 0x61, 0x30, 0x30, 0x63, 0x30, 0x30, 0x39, 0x66, 0x64, 0x62, 0x30, 0x66, 0x36, 0x65, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x35, 0x32, 0x32, 0x65, 0x35, 0x32, 0x63, 0x31, 0x39, 0x35, 0x62, 0x66, 0x62, 0x37, 0x63, 0x66, 0x35, 0x66, 0x66, 0x61, 0x61, 0x65, 0x64, 0x62, 0x39, 0x31, 0x61, 0x33, 0x62, 0x61, 0x37, 0x34, 0x36, 0x38, 0x31, 0x36, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x35, 0x39, 0x65, 0x39, 0x30, 0x63, 0x34, 0x38, 0x61, 0x39, 0x31, 0x35, 0x39, 0x30, 0x34, 0x61, 0x64, 0x66, 0x65, 0x32, 0x39, 0x32, 0x62, 0x32, 0x32, 0x66, 0x61, 0x35, 0x66, 0x64, 0x35, 0x65, 0x37, 0x32, 0x37, 0x39, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x66, 0x64, 0x64, 0x66, 0x64, 0x35, 0x39, 0x62, 0x38, 0x64, 0x32, 0x63, 0x31, 0x35, 0x34, 0x65, 0x65, 0x63, 0x66, 0x35, 0x63, 0x37, 0x63, 0x31, 0x36, 0x37, 0x62, 0x66, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x64, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x35, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x31, 0x64, 0x36, 0x38, 0x61, 0x30, 0x33, 0x38, 0x66, 0x64, 0x32, 0x35, 0x38, 0x36, 0x30, 0x36, 0x37, 0x65, 0x66, 0x36, 0x64, 0x31, 0x33, 0x35, 0x64, 0x39, 0x36, 0x32, 0x38, 0x65, 0x37, 0x39, 0x63, 0x32, 0x63, 0x39, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x38, 0x36, 0x31, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x38, 0x65, 0x34, 0x35, 0x65, 0x61, 0x64, 0x64, 0x33, 0x64, 0x38, 0x38, 0x62, 0x38, 0x37, 0x66, 0x65, 0x34, 0x64, 0x61, 0x62, 0x30, 0x36, 0x36, 0x36, 0x38, 0x30, 0x35, 0x32, 0x32, 0x66, 0x30, 0x64, 0x66, 0x63, 0x38, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x36, 0x31, 0x65, 0x63, 0x30, 0x66, 0x33, 0x37, 0x39, 0x32, 0x31, 0x38, 0x66, 0x65, 0x35, 0x65, 0x64, 0x34, 0x65, 0x30, 0x32, 0x38, 0x61, 0x33, 0x66, 0x37, 0x34, 0x34, 0x61, 0x61, 0x34, 0x31, 0x37, 0x35, 0x34, 0x63, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x35, 0x33, 0x39, 0x36, 0x64, 0x61, 0x61, 0x61, 0x34, 0x39, 0x30, 0x64, 0x66, 0x32, 0x35, 0x36, 0x39, 0x33, 0x32, 0x34, 0x66, 0x63, 0x63, 0x36, 0x36, 0x32, 0x33, 0x62, 0x65, 0x30, 0x35, 0x32, 0x66, 0x31, 0x33, 0x32, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x37, 0x36, 0x61, 0x64, 0x61, 0x39, 0x30, 0x33, 0x33, 0x33, 0x62, 0x31, 0x64, 0x31, 0x38, 0x31, 0x30, 0x38, 0x34, 0x63, 0x39, 0x37, 0x65, 0x36, 0x34, 0x35, 0x65, 0x38, 0x31, 0x30, 0x61, 0x61, 0x35, 0x62, 0x37, 0x36, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x38, 0x30, 0x30, 0x64, 0x32, 0x66, 0x38, 0x30, 0x36, 0x38, 0x65, 0x34, 0x34, 0x38, 0x63, 0x37, 0x39, 0x61, 0x34, 0x66, 0x36, 0x39, 0x62, 0x31, 0x66, 0x31, 0x35, 0x65, 0x66, 0x36, 0x38, 0x32, 0x61, 0x61, 0x65, 0x35, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x65, 0x62, 0x32, 0x30, 0x34, 0x61, 0x61, 0x30, 0x63, 0x33, 0x38, 0x65, 0x31, 0x37, 0x39, 0x65, 0x38, 0x31, 0x61, 0x39, 0x34, 0x65, 0x64, 0x38, 0x62, 0x33, 0x65, 0x37, 0x64, 0x35, 0x33, 0x30, 0x34, 0x37, 0x63, 0x32, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x63, 0x31, 0x30, 0x30, 0x62, 0x31, 0x30, 0x37, 0x30, 0x31, 0x31, 0x63, 0x37, 0x66, 0x63, 0x30, 0x61, 0x31, 0x33, 0x33, 0x39, 0x36, 0x31, 0x32, 0x61, 0x31, 0x36, 0x63, 0x63, 0x65, 0x63, 0x33, 0x32, 0x38, 0x35, 0x32, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x62, 0x31, 0x33, 0x34, 0x30, 0x62, 0x39, 0x39, 0x36, 0x66, 0x36, 0x66, 0x30, 0x62, 0x66, 0x30, 0x64, 0x39, 0x35, 0x36, 0x31, 0x63, 0x38, 0x34, 0x39, 0x63, 0x61, 0x66, 0x37, 0x66, 0x34, 0x34, 0x33, 0x30, 0x62, 0x65, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x34, 0x34, 0x33, 0x64, 0x62, 0x64, 0x39, 0x35, 0x63, 0x63, 0x34, 0x31, 0x32, 0x33, 0x37, 0x66, 0x36, 0x31, 0x33, 0x61, 0x34, 0x38, 0x34, 0x35, 0x36, 0x39, 0x38, 0x38, 0x61, 0x30, 0x34, 0x66, 0x36, 0x38, 0x33, 0x32, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x63, 0x36, 0x66, 0x31, 0x65, 0x30, 0x66, 0x35, 0x30, 0x65, 0x63, 0x33, 0x64, 0x32, 0x61, 0x36, 0x37, 0x65, 0x36, 0x62, 0x63, 0x64, 0x31, 0x39, 0x33, 0x65, 0x63, 0x37, 0x61, 0x65, 0x33, 0x38, 0x66, 0x31, 0x36, 0x35, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x31, 0x38, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x38, 0x38, 0x39, 0x39, 0x65, 0x37, 0x36, 0x31, 0x30, 0x64, 0x34, 0x63, 0x39, 0x33, 0x61, 0x32, 0x33, 0x35, 0x33, 0x35, 0x62, 0x63, 0x63, 0x34, 0x34, 0x38, 0x39, 0x34, 0x35, 0x62, 0x61, 0x31, 0x36, 0x36, 0x36, 0x66, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x32, 0x35, 0x33, 0x37, 0x36, 0x33, 0x63, 0x66, 0x34, 0x61, 0x37, 0x35, 0x64, 0x66, 0x39, 0x32, 0x63, 0x61, 0x31, 0x65, 0x37, 0x36, 0x36, 0x64, 0x63, 0x34, 0x65, 0x65, 0x38, 0x61, 0x32, 0x37, 0x34, 0x35, 0x31, 0x34, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x64, 0x36, 0x37, 0x63, 0x65, 0x31, 0x34, 0x65, 0x38, 0x64, 0x32, 0x39, 0x65, 0x38, 0x63, 0x32, 0x66, 0x66, 0x65, 0x33, 0x38, 0x31, 0x39, 0x31, 0x37, 0x62, 0x39, 0x33, 0x30, 0x62, 0x31, 0x61, 0x66, 0x66, 0x31, 0x61, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x33, 0x64, 0x34, 0x38, 0x62, 0x64, 0x61, 0x30, 0x31, 0x35, 0x61, 0x39, 0x62, 0x66, 0x63, 0x66, 0x31, 0x36, 0x30, 0x33, 0x39, 0x33, 0x36, 0x65, 0x61, 0x62, 0x36, 0x38, 0x30, 0x32, 0x34, 0x63, 0x65, 0x35, 0x35, 0x31, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x64, 0x64, 0x35, 0x37, 0x31, 0x36, 0x35, 0x63, 0x38, 0x37, 0x61, 0x32, 0x37, 0x30, 0x37, 0x66, 0x30, 0x32, 0x35, 0x64, 0x63, 0x66, 0x63, 0x32, 0x35, 0x30, 0x38, 0x63, 0x30, 0x39, 0x38, 0x33, 0x34, 0x37, 0x35, 0x39, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x66, 0x37, 0x66, 0x38, 0x39, 0x61, 0x34, 0x64, 0x34, 0x32, 0x31, 0x39, 0x61, 0x33, 0x38, 0x32, 0x39, 0x35, 0x32, 0x35, 0x31, 0x33, 0x33, 0x31, 0x35, 0x36, 0x38, 0x32, 0x31, 0x30, 0x66, 0x66, 0x63, 0x31, 0x63, 0x31, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x38, 0x64, 0x33, 0x30, 0x65, 0x35, 0x33, 0x66, 0x61, 0x36, 0x38, 0x31, 0x30, 0x39, 0x32, 0x62, 0x35, 0x32, 0x65, 0x39, 0x62, 0x61, 0x65, 0x31, 0x35, 0x61, 0x30, 0x64, 0x63, 0x62, 0x34, 0x31, 0x61, 0x38, 0x63, 0x39, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x62, 0x37, 0x34, 0x33, 0x64, 0x31, 0x64, 0x39, 0x65, 0x66, 0x66, 0x39, 0x30, 0x64, 0x39, 0x61, 0x31, 0x39, 0x33, 0x34, 0x62, 0x34, 0x64, 0x62, 0x32, 0x31, 0x64, 0x35, 0x31, 0x39, 0x64, 0x38, 0x39, 0x62, 0x34, 0x61, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x64, 0x30, 0x62, 0x30, 0x33, 0x63, 0x66, 0x66, 0x62, 0x62, 0x32, 0x36, 0x39, 0x66, 0x37, 0x39, 0x36, 0x61, 0x63, 0x32, 0x39, 0x64, 0x38, 0x30, 0x62, 0x66, 0x62, 0x30, 0x37, 0x64, 0x63, 0x37, 0x63, 0x36, 0x61, 0x64, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x36, 0x64, 0x39, 0x37, 0x37, 0x32, 0x63, 0x66, 0x31, 0x31, 0x33, 0x39, 0x39, 0x31, 0x31, 0x36, 0x63, 0x63, 0x31, 0x65, 0x37, 0x32, 0x63, 0x32, 0x36, 0x63, 0x36, 0x37, 0x37, 0x34, 0x63, 0x39, 0x65, 0x64, 0x64, 0x37, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x38, 0x30, 0x65, 0x32, 0x61, 0x38, 0x62, 0x66, 0x38, 0x38, 0x61, 0x31, 0x61, 0x38, 0x32, 0x36, 0x34, 0x38, 0x62, 0x34, 0x30, 0x31, 0x33, 0x63, 0x34, 0x39, 0x63, 0x34, 0x35, 0x39, 0x34, 0x63, 0x34, 0x33, 0x33, 0x63, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x34, 0x34, 0x61, 0x37, 0x32, 0x31, 0x38, 0x66, 0x65, 0x34, 0x34, 0x64, 0x36, 0x35, 0x61, 0x31, 0x62, 0x34, 0x62, 0x37, 0x61, 0x37, 0x64, 0x39, 0x62, 0x31, 0x63, 0x32, 0x63, 0x35, 0x32, 0x63, 0x38, 0x63, 0x33, 0x65, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x32, 0x32, 0x31, 0x33, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x38, 0x36, 0x65, 0x64, 0x62, 0x63, 0x38, 0x62, 0x62, 0x62, 0x31, 0x66, 0x39, 0x31, 0x33, 0x31, 0x30, 0x32, 0x32, 0x62, 0x65, 0x36, 0x34, 0x39, 0x35, 0x36, 0x35, 0x65, 0x62, 0x64, 0x62, 0x30, 0x39, 0x65, 0x33, 0x32, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x31, 0x35, 0x65, 0x61, 0x62, 0x35, 0x61, 0x62, 0x32, 0x65, 0x35, 0x39, 0x37, 0x37, 0x64, 0x30, 0x37, 0x35, 0x64, 0x65, 0x63, 0x34, 0x37, 0x64, 0x39, 0x36, 0x62, 0x36, 0x38, 0x62, 0x34, 0x62, 0x35, 0x63, 0x66, 0x35, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x36, 0x35, 0x63, 0x61, 0x62, 0x30, 0x65, 0x61, 0x66, 0x62, 0x35, 0x61, 0x33, 0x32, 0x38, 0x66, 0x63, 0x34, 0x31, 0x61, 0x63, 0x36, 0x34, 0x64, 0x61, 0x65, 0x37, 0x31, 0x35, 0x62, 0x32, 0x65, 0x65, 0x66, 0x32, 0x63, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x36, 0x63, 0x38, 0x36, 0x62, 0x37, 0x32, 0x30, 0x38, 0x33, 0x64, 0x31, 0x66, 0x38, 0x39, 0x30, 0x37, 0x64, 0x38, 0x34, 0x65, 0x66, 0x64, 0x32, 0x64, 0x32, 0x64, 0x37, 0x38, 0x33, 0x64, 0x66, 0x66, 0x61, 0x33, 0x65, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x32, 0x34, 0x30, 0x38, 0x36, 0x64, 0x34, 0x36, 0x63, 0x38, 0x31, 0x31, 0x32, 0x62, 0x31, 0x32, 0x38, 0x62, 0x32, 0x66, 0x61, 0x66, 0x36, 0x66, 0x37, 0x63, 0x37, 0x64, 0x38, 0x31, 0x36, 0x30, 0x61, 0x38, 0x33, 0x38, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x32, 0x64, 0x37, 0x34, 0x61, 0x31, 0x35, 0x37, 0x66, 0x37, 0x64, 0x32, 0x62, 0x39, 0x61, 0x33, 0x33, 0x37, 0x38, 0x62, 0x31, 0x66, 0x35, 0x36, 0x37, 0x30, 0x33, 0x37, 0x33, 0x30, 0x65, 0x30, 0x33, 0x61, 0x31, 0x37, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x65, 0x66, 0x32, 0x38, 0x36, 0x39, 0x63, 0x62, 0x65, 0x36, 0x30, 0x38, 0x38, 0x35, 0x36, 0x30, 0x34, 0x35, 0x64, 0x38, 0x63, 0x32, 0x30, 0x34, 0x31, 0x31, 0x31, 0x38, 0x35, 0x37, 0x39, 0x66, 0x32, 0x32, 0x33, 0x36, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x37, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x39, 0x39, 0x32, 0x64, 0x64, 0x36, 0x36, 0x39, 0x63, 0x30, 0x38, 0x38, 0x33, 0x65, 0x35, 0x35, 0x31, 0x35, 0x64, 0x33, 0x66, 0x33, 0x31, 0x31, 0x32, 0x61, 0x31, 0x33, 0x66, 0x36, 0x31, 0x37, 0x61, 0x34, 0x63, 0x33, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x36, 0x61, 0x32, 0x34, 0x38, 0x66, 0x63, 0x39, 0x37, 0x64, 0x37, 0x30, 0x35, 0x64, 0x65, 0x66, 0x34, 0x39, 0x35, 0x63, 0x61, 0x32, 0x30, 0x37, 0x35, 0x39, 0x31, 0x36, 0x39, 0x65, 0x66, 0x30, 0x64, 0x33, 0x36, 0x34, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x34, 0x64, 0x32, 0x66, 0x31, 0x37, 0x38, 0x39, 0x35, 0x66, 0x32, 0x39, 0x30, 0x32, 0x30, 0x34, 0x39, 0x64, 0x65, 0x61, 0x61, 0x65, 0x63, 0x66, 0x30, 0x39, 0x63, 0x33, 0x30, 0x34, 0x36, 0x35, 0x30, 0x37, 0x34, 0x30, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x33, 0x39, 0x62, 0x34, 0x66, 0x32, 0x31, 0x66, 0x38, 0x65, 0x30, 0x35, 0x63, 0x64, 0x30, 0x31, 0x35, 0x31, 0x32, 0x62, 0x32, 0x62, 0x65, 0x37, 0x61, 0x30, 0x65, 0x31, 0x38, 0x61, 0x36, 0x64, 0x39, 0x37, 0x34, 0x36, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x37, 0x61, 0x36, 0x37, 0x33, 0x33, 0x63, 0x64, 0x35, 0x66, 0x65, 0x39, 0x39, 0x38, 0x36, 0x34, 0x62, 0x33, 0x62, 0x33, 0x33, 0x34, 0x36, 0x30, 0x64, 0x31, 0x36, 0x37, 0x32, 0x34, 0x33, 0x34, 0x64, 0x35, 0x63, 0x61, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x35, 0x38, 0x61, 0x32, 0x62, 0x32, 0x64, 0x64, 0x32, 0x36, 0x64, 0x64, 0x39, 0x35, 0x39, 0x33, 0x61, 0x61, 0x65, 0x30, 0x34, 0x35, 0x33, 0x31, 0x66, 0x64, 0x33, 0x63, 0x33, 0x63, 0x63, 0x33, 0x38, 0x35, 0x34, 0x62, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x37, 0x37, 0x62, 0x36, 0x62, 0x65, 0x66, 0x61, 0x30, 0x35, 0x34, 0x65, 0x39, 0x63, 0x30, 0x34, 0x30, 0x34, 0x36, 0x31, 0x38, 0x35, 0x35, 0x30, 0x39, 0x34, 0x62, 0x30, 0x30, 0x32, 0x64, 0x37, 0x66, 0x35, 0x37, 0x62, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x62, 0x66, 0x65, 0x37, 0x37, 0x31, 0x30, 0x66, 0x33, 0x31, 0x63, 0x61, 0x62, 0x39, 0x34, 0x39, 0x62, 0x37, 0x61, 0x32, 0x36, 0x30, 0x34, 0x66, 0x62, 0x66, 0x35, 0x32, 0x33, 0x39, 0x63, 0x65, 0x65, 0x37, 0x39, 0x30, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x31, 0x37, 0x66, 0x32, 0x64, 0x38, 0x66, 0x31, 0x38, 0x66, 0x66, 0x63, 0x63, 0x30, 0x65, 0x35, 0x66, 0x65, 0x32, 0x34, 0x37, 0x64, 0x33, 0x61, 0x34, 0x32, 0x31, 0x39, 0x30, 0x33, 0x37, 0x63, 0x33, 0x61, 0x36, 0x34, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x37, 0x30, 0x37, 0x65, 0x34, 0x32, 0x35, 0x64, 0x32, 0x61, 0x31, 0x31, 0x64, 0x32, 0x63, 0x38, 0x39, 0x66, 0x33, 0x39, 0x31, 0x62, 0x32, 0x62, 0x38, 0x30, 0x39, 0x66, 0x35, 0x35, 0x36, 0x63, 0x35, 0x39, 0x32, 0x34, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x36, 0x37, 0x30, 0x38, 0x64, 0x64, 0x62, 0x38, 0x39, 0x30, 0x33, 0x63, 0x32, 0x38, 0x39, 0x66, 0x38, 0x33, 0x66, 0x65, 0x38, 0x38, 0x39, 0x63, 0x31, 0x65, 0x64, 0x63, 0x64, 0x36, 0x31, 0x66, 0x38, 0x35, 0x34, 0x34, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x32, 0x37, 0x63, 0x63, 0x34, 0x39, 0x64, 0x30, 0x30, 0x62, 0x36, 0x63, 0x39, 0x38, 0x37, 0x33, 0x33, 0x36, 0x61, 0x38, 0x37, 0x35, 0x61, 0x65, 0x33, 0x39, 0x64, 0x61, 0x35, 0x38, 0x66, 0x62, 0x30, 0x34, 0x31, 0x62, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x38, 0x38, 0x65, 0x37, 0x38, 0x35, 0x63, 0x39, 0x38, 0x66, 0x30, 0x30, 0x66, 0x38, 0x34, 0x62, 0x33, 0x61, 0x61, 0x31, 0x35, 0x33, 0x33, 0x33, 0x35, 0x35, 0x63, 0x37, 0x61, 0x32, 0x35, 0x38, 0x65, 0x38, 0x37, 0x39, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x37, 0x63, 0x62, 0x37, 0x64, 0x63, 0x31, 0x38, 0x37, 0x30, 0x33, 0x36, 0x62, 0x35, 0x34, 0x32, 0x37, 0x62, 0x63, 0x37, 0x65, 0x32, 0x30, 0x30, 0x63, 0x35, 0x65, 0x63, 0x34, 0x35, 0x30, 0x63, 0x31, 0x64, 0x32, 0x37, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x62, 0x66, 0x61, 0x61, 0x35, 0x38, 0x62, 0x35, 0x31, 0x39, 0x36, 0x63, 0x35, 0x63, 0x62, 0x37, 0x66, 0x38, 0x39, 0x64, 0x65, 0x31, 0x35, 0x66, 0x34, 0x37, 0x39, 0x64, 0x31, 0x38, 0x33, 0x38, 0x64, 0x65, 0x37, 0x31, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x38, 0x30, 0x64, 0x65, 0x39, 0x65, 0x38, 0x36, 0x66, 0x35, 0x37, 0x62, 0x61, 0x66, 0x61, 0x63, 0x64, 0x37, 0x39, 0x30, 0x34, 0x66, 0x39, 0x38, 0x32, 0x36, 0x62, 0x36, 0x62, 0x34, 0x62, 0x32, 0x36, 0x33, 0x33, 0x37, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x32, 0x30, 0x34, 0x64, 0x61, 0x64, 0x35, 0x66, 0x35, 0x36, 0x30, 0x37, 0x32, 0x38, 0x61, 0x33, 0x35, 0x63, 0x30, 0x64, 0x38, 0x66, 0x63, 0x37, 0x39, 0x34, 0x38, 0x31, 0x30, 0x35, 0x37, 0x62, 0x66, 0x37, 0x37, 0x33, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x30, 0x64, 0x61, 0x32, 0x35, 0x61, 0x66, 0x32, 0x36, 0x37, 0x64, 0x37, 0x38, 0x33, 0x36, 0x63, 0x32, 0x32, 0x36, 0x62, 0x63, 0x61, 0x65, 0x38, 0x64, 0x38, 0x37, 0x32, 0x64, 0x32, 0x63, 0x65, 0x35, 0x32, 0x63, 0x39, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x31, 0x37, 0x34, 0x34, 0x38, 0x64, 0x61, 0x64, 0x61, 0x37, 0x36, 0x31, 0x63, 0x63, 0x35, 0x62, 0x61, 0x34, 0x30, 0x33, 0x33, 0x65, 0x65, 0x38, 0x38, 0x31, 0x63, 0x38, 0x33, 0x30, 0x33, 0x37, 0x30, 0x33, 0x36, 0x34, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x64, 0x30, 0x61, 0x35, 0x61, 0x38, 0x34, 0x37, 0x62, 0x65, 0x66, 0x39, 0x61, 0x39, 0x64, 0x61, 0x37, 0x63, 0x62, 0x61, 0x31, 0x64, 0x36, 0x34, 0x31, 0x31, 0x66, 0x35, 0x63, 0x33, 0x31, 0x36, 0x33, 0x31, 0x32, 0x36, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x35, 0x64, 0x35, 0x31, 0x37, 0x30, 0x32, 0x39, 0x33, 0x32, 0x31, 0x35, 0x36, 0x32, 0x31, 0x31, 0x31, 0x62, 0x34, 0x33, 0x30, 0x38, 0x36, 0x64, 0x30, 0x62, 0x30, 0x34, 0x33, 0x35, 0x39, 0x31, 0x31, 0x30, 0x39, 0x61, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x66, 0x63, 0x31, 0x61, 0x37, 0x62, 0x61, 0x64, 0x34, 0x30, 0x34, 0x37, 0x32, 0x33, 0x37, 0x63, 0x65, 0x31, 0x31, 0x36, 0x31, 0x34, 0x36, 0x32, 0x39, 0x36, 0x32, 0x33, 0x38, 0x65, 0x30, 0x37, 0x38, 0x66, 0x39, 0x33, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x35, 0x34, 0x32, 0x32, 0x66, 0x62, 0x34, 0x62, 0x31, 0x34, 0x65, 0x36, 0x64, 0x39, 0x38, 0x62, 0x36, 0x30, 0x39, 0x31, 0x66, 0x64, 0x65, 0x63, 0x37, 0x31, 0x66, 0x31, 0x66, 0x30, 0x38, 0x36, 0x34, 0x30, 0x34, 0x31, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x38, 0x66, 0x65, 0x38, 0x65, 0x65, 0x32, 0x61, 0x31, 0x33, 0x64, 0x61, 0x34, 0x38, 0x37, 0x62, 0x32, 0x32, 0x63, 0x36, 0x61, 0x62, 0x36, 0x64, 0x35, 0x38, 0x32, 0x65, 0x61, 0x37, 0x31, 0x30, 0x36, 0x34, 0x64, 0x39, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x64, 0x33, 0x65, 0x34, 0x34, 0x64, 0x33, 0x63, 0x30, 0x30, 0x31, 0x66, 0x61, 0x32, 0x39, 0x30, 0x62, 0x33, 0x39, 0x33, 0x36, 0x31, 0x37, 0x30, 0x33, 0x30, 0x35, 0x34, 0x34, 0x31, 0x30, 0x38, 0x61, 0x63, 0x36, 0x65, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x61, 0x65, 0x65, 0x36, 0x38, 0x64, 0x30, 0x39, 0x61, 0x66, 0x62, 0x37, 0x31, 0x64, 0x38, 0x38, 0x31, 0x37, 0x66, 0x33, 0x66, 0x31, 0x38, 0x34, 0x65, 0x63, 0x35, 0x36, 0x32, 0x66, 0x37, 0x38, 0x39, 0x37, 0x62, 0x37, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x33, 0x34, 0x30, 0x61, 0x34, 0x63, 0x61, 0x39, 0x34, 0x63, 0x39, 0x36, 0x37, 0x38, 0x62, 0x37, 0x34, 0x39, 0x34, 0x63, 0x33, 0x63, 0x38, 0x35, 0x32, 0x35, 0x32, 0x38, 0x65, 0x64, 0x65, 0x35, 0x65, 0x65, 0x35, 0x32, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x36, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x39, 0x30, 0x31, 0x65, 0x30, 0x64, 0x30, 0x65, 0x30, 0x38, 0x61, 0x63, 0x33, 0x64, 0x35, 0x65, 0x39, 0x35, 0x62, 0x38, 0x65, 0x63, 0x39, 0x64, 0x35, 0x65, 0x30, 0x66, 0x66, 0x35, 0x66, 0x31, 0x32, 0x65, 0x30, 0x33, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x37, 0x35, 0x61, 0x36, 0x31, 0x30, 0x63, 0x35, 0x30, 0x32, 0x62, 0x39, 0x66, 0x31, 0x65, 0x36, 0x61, 0x64, 0x34, 0x63, 0x64, 0x61, 0x64, 0x62, 0x38, 0x63, 0x65, 0x32, 0x39, 0x62, 0x66, 0x66, 0x37, 0x35, 0x66, 0x36, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x32, 0x38, 0x39, 0x37, 0x62, 0x63, 0x34, 0x66, 0x38, 0x65, 0x38, 0x39, 0x30, 0x32, 0x39, 0x31, 0x32, 0x30, 0x66, 0x63, 0x66, 0x66, 0x62, 0x37, 0x38, 0x37, 0x63, 0x30, 0x31, 0x61, 0x39, 0x33, 0x65, 0x36, 0x34, 0x31, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x61, 0x63, 0x66, 0x66, 0x39, 0x33, 0x34, 0x62, 0x38, 0x34, 0x64, 0x61, 0x30, 0x39, 0x36, 0x39, 0x64, 0x63, 0x33, 0x37, 0x61, 0x38, 0x66, 0x63, 0x66, 0x36, 0x34, 0x33, 0x62, 0x37, 0x64, 0x37, 0x66, 0x62, 0x65, 0x64, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x35, 0x66, 0x63, 0x64, 0x34, 0x63, 0x30, 0x64, 0x37, 0x33, 0x61, 0x61, 0x31, 0x36, 0x37, 0x65, 0x35, 0x35, 0x35, 0x33, 0x63, 0x38, 0x63, 0x30, 0x64, 0x36, 0x64, 0x34, 0x66, 0x32, 0x66, 0x61, 0x61, 0x33, 0x39, 0x37, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x38, 0x31, 0x64, 0x33, 0x31, 0x32, 0x64, 0x32, 0x38, 0x37, 0x64, 0x35, 0x35, 0x38, 0x38, 0x37, 0x31, 0x65, 0x64, 0x64, 0x39, 0x37, 0x33, 0x61, 0x62, 0x62, 0x37, 0x36, 0x62, 0x39, 0x37, 0x39, 0x65, 0x35, 0x63, 0x33, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x61, 0x36, 0x31, 0x63, 0x63, 0x64, 0x36, 0x32, 0x62, 0x66, 0x38, 0x36, 0x30, 0x36, 0x35, 0x36, 0x65, 0x30, 0x33, 0x32, 0x35, 0x64, 0x37, 0x31, 0x35, 0x37, 0x65, 0x32, 0x66, 0x31, 0x36, 0x30, 0x64, 0x39, 0x33, 0x62, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x38, 0x34, 0x61, 0x35, 0x30, 0x33, 0x38, 0x32, 0x66, 0x38, 0x33, 0x61, 0x36, 0x31, 0x36, 0x64, 0x33, 0x39, 0x62, 0x38, 0x61, 0x39, 0x63, 0x30, 0x66, 0x33, 0x39, 0x36, 0x65, 0x30, 0x65, 0x62, 0x62, 0x66, 0x61, 0x39, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x63, 0x66, 0x35, 0x63, 0x31, 0x62, 0x63, 0x66, 0x39, 0x64, 0x61, 0x36, 0x36, 0x32, 0x62, 0x63, 0x65, 0x61, 0x32, 0x32, 0x35, 0x35, 0x39, 0x30, 0x35, 0x30, 0x39, 0x39, 0x66, 0x39, 0x64, 0x36, 0x65, 0x38, 0x34, 0x64, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x34, 0x39, 0x33, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x31, 0x62, 0x32, 0x61, 0x33, 0x64, 0x37, 0x31, 0x33, 0x35, 0x64, 0x32, 0x61, 0x38, 0x35, 0x66, 0x62, 0x35, 0x61, 0x35, 0x37, 0x31, 0x64, 0x63, 0x62, 0x65, 0x36, 0x39, 0x35, 0x65, 0x31, 0x33, 0x66, 0x63, 0x34, 0x33, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x32, 0x64, 0x61, 0x64, 0x64, 0x37, 0x65, 0x31, 0x65, 0x30, 0x35, 0x32, 0x33, 0x32, 0x61, 0x39, 0x33, 0x32, 0x33, 0x37, 0x62, 0x61, 0x65, 0x64, 0x39, 0x38, 0x65, 0x30, 0x64, 0x66, 0x39, 0x32, 0x62, 0x31, 0x38, 0x36, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x39, 0x66, 0x65, 0x36, 0x64, 0x34, 0x33, 0x34, 0x39, 0x62, 0x39, 0x39, 0x62, 0x63, 0x33, 0x37, 0x39, 0x33, 0x38, 0x30, 0x35, 0x34, 0x30, 0x32, 0x32, 0x64, 0x35, 0x34, 0x66, 0x63, 0x61, 0x33, 0x36, 0x36, 0x66, 0x37, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x37, 0x65, 0x34, 0x37, 0x35, 0x31, 0x63, 0x33, 0x62, 0x61, 0x62, 0x65, 0x37, 0x38, 0x63, 0x66, 0x66, 0x38, 0x38, 0x33, 0x30, 0x38, 0x38, 0x36, 0x66, 0x65, 0x62, 0x63, 0x31, 0x30, 0x66, 0x39, 0x39, 0x30, 0x38, 0x64, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x62, 0x33, 0x35, 0x38, 0x63, 0x62, 0x33, 0x64, 0x62, 0x65, 0x66, 0x61, 0x33, 0x37, 0x66, 0x34, 0x37, 0x64, 0x66, 0x32, 0x64, 0x37, 0x33, 0x36, 0x35, 0x38, 0x34, 0x30, 0x64, 0x61, 0x38, 0x65, 0x33, 0x62, 0x63, 0x39, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x64, 0x35, 0x62, 0x63, 0x61, 0x32, 0x30, 0x30, 0x35, 0x33, 0x39, 0x35, 0x62, 0x36, 0x37, 0x35, 0x66, 0x64, 0x65, 0x35, 0x30, 0x33, 0x35, 0x36, 0x35, 0x39, 0x62, 0x32, 0x36, 0x62, 0x66, 0x65, 0x66, 0x63, 0x34, 0x39, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x31, 0x38, 0x36, 0x39, 0x33, 0x31, 0x31, 0x38, 0x34, 0x31, 0x33, 0x37, 0x64, 0x31, 0x31, 0x39, 0x32, 0x61, 0x63, 0x38, 0x38, 0x63, 0x64, 0x33, 0x65, 0x31, 0x65, 0x35, 0x64, 0x30, 0x66, 0x64, 0x62, 0x38, 0x36, 0x61, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x32, 0x31, 0x32, 0x32, 0x39, 0x33, 0x66, 0x38, 0x66, 0x31, 0x64, 0x32, 0x33, 0x31, 0x66, 0x61, 0x31, 0x30, 0x65, 0x36, 0x30, 0x39, 0x34, 0x37, 0x30, 0x64, 0x35, 0x31, 0x32, 0x63, 0x62, 0x38, 0x66, 0x66, 0x63, 0x35, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x33, 0x37, 0x63, 0x35, 0x63, 0x35, 0x31, 0x35, 0x30, 0x35, 0x37, 0x35, 0x35, 0x33, 0x63, 0x63, 0x62, 0x64, 0x34, 0x36, 0x64, 0x35, 0x38, 0x36, 0x36, 0x34, 0x35, 0x35, 0x63, 0x65, 0x36, 0x36, 0x32, 0x39, 0x30, 0x32, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x32, 0x37, 0x37, 0x37, 0x32, 0x36, 0x31, 0x65, 0x33, 0x62, 0x64, 0x38, 0x35, 0x32, 0x63, 0x34, 0x38, 0x65, 0x63, 0x61, 0x39, 0x35, 0x62, 0x33, 0x61, 0x34, 0x34, 0x63, 0x35, 0x62, 0x37, 0x66, 0x32, 0x64, 0x34, 0x32, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x66, 0x38, 0x34, 0x32, 0x39, 0x32, 0x64, 0x39, 0x35, 0x34, 0x61, 0x63, 0x64, 0x39, 0x65, 0x34, 0x30, 0x37, 0x32, 0x66, 0x62, 0x38, 0x36, 0x30, 0x62, 0x31, 0x35, 0x30, 0x34, 0x31, 0x30, 0x36, 0x65, 0x30, 0x37, 0x37, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x34, 0x31, 0x30, 0x30, 0x65, 0x33, 0x30, 0x61, 0x37, 0x33, 0x62, 0x30, 0x63, 0x37, 0x33, 0x34, 0x62, 0x31, 0x38, 0x66, 0x66, 0x61, 0x38, 0x34, 0x32, 0x36, 0x64, 0x31, 0x39, 0x62, 0x31, 0x39, 0x33, 0x31, 0x32, 0x66, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x33, 0x61, 0x33, 0x64, 0x63, 0x37, 0x63, 0x35, 0x33, 0x33, 0x64, 0x31, 0x37, 0x34, 0x34, 0x32, 0x39, 0x35, 0x62, 0x65, 0x39, 0x35, 0x35, 0x64, 0x36, 0x31, 0x61, 0x66, 0x33, 0x66, 0x35, 0x32, 0x62, 0x35, 0x31, 0x61, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x61, 0x31, 0x34, 0x38, 0x63, 0x32, 0x63, 0x33, 0x33, 0x34, 0x30, 0x31, 0x65, 0x36, 0x36, 0x61, 0x32, 0x62, 0x35, 0x38, 0x36, 0x65, 0x36, 0x35, 0x37, 0x37, 0x63, 0x34, 0x62, 0x32, 0x39, 0x32, 0x64, 0x33, 0x66, 0x32, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x38, 0x35, 0x30, 0x65, 0x33, 0x62, 0x65, 0x31, 0x65, 0x62, 0x36, 0x61, 0x34, 0x64, 0x37, 0x32, 0x36, 0x63, 0x30, 0x38, 0x66, 0x61, 0x37, 0x33, 0x61, 0x61, 0x64, 0x33, 0x35, 0x38, 0x66, 0x33, 0x39, 0x37, 0x30, 0x36, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x33, 0x36, 0x35, 0x31, 0x62, 0x35, 0x35, 0x65, 0x66, 0x38, 0x34, 0x32, 0x39, 0x64, 0x66, 0x35, 0x30, 0x63, 0x66, 0x38, 0x31, 0x39, 0x33, 0x38, 0x63, 0x32, 0x35, 0x30, 0x38, 0x64, 0x65, 0x35, 0x63, 0x38, 0x38, 0x37, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x30, 0x30, 0x65, 0x33, 0x30, 0x32, 0x37, 0x34, 0x32, 0x34, 0x64, 0x39, 0x33, 0x39, 0x64, 0x62, 0x64, 0x65, 0x35, 0x64, 0x34, 0x32, 0x66, 0x62, 0x37, 0x38, 0x66, 0x36, 0x63, 0x34, 0x64, 0x62, 0x65, 0x63, 0x31, 0x61, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x63, 0x62, 0x64, 0x32, 0x65, 0x32, 0x33, 0x33, 0x32, 0x61, 0x35, 0x32, 0x34, 0x63, 0x66, 0x32, 0x31, 0x39, 0x62, 0x31, 0x30, 0x64, 0x38, 0x37, 0x31, 0x63, 0x63, 0x63, 0x32, 0x30, 0x61, 0x66, 0x31, 0x66, 0x62, 0x30, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x35, 0x62, 0x39, 0x66, 0x37, 0x36, 0x62, 0x38, 0x61, 0x64, 0x30, 0x32, 0x33, 0x66, 0x30, 0x35, 0x37, 0x65, 0x62, 0x31, 0x31, 0x61, 0x64, 0x39, 0x34, 0x32, 0x35, 0x37, 0x61, 0x30, 0x38, 0x36, 0x32, 0x65, 0x34, 0x65, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x39, 0x65, 0x38, 0x39, 0x31, 0x66, 0x62, 0x63, 0x63, 0x30, 0x61, 0x33, 0x33, 0x65, 0x31, 0x39, 0x63, 0x31, 0x32, 0x64, 0x63, 0x30, 0x66, 0x30, 0x32, 0x30, 0x33, 0x39, 0x63, 0x61, 0x30, 0x35, 0x62, 0x38, 0x30, 0x31, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x38, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x36, 0x33, 0x36, 0x62, 0x32, 0x35, 0x38, 0x31, 0x31, 0x62, 0x31, 0x37, 0x36, 0x61, 0x62, 0x66, 0x63, 0x66, 0x65, 0x65, 0x63, 0x61, 0x36, 0x34, 0x62, 0x63, 0x38, 0x37, 0x34, 0x35, 0x32, 0x66, 0x31, 0x66, 0x64, 0x66, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x31, 0x30, 0x33, 0x30, 0x61, 0x35, 0x62, 0x32, 0x37, 0x62, 0x30, 0x37, 0x32, 0x38, 0x38, 0x61, 0x34, 0x35, 0x36, 0x39, 0x36, 0x66, 0x31, 0x38, 0x39, 0x65, 0x31, 0x31, 0x31, 0x34, 0x66, 0x31, 0x32, 0x61, 0x38, 0x31, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x63, 0x38, 0x34, 0x35, 0x39, 0x37, 0x62, 0x39, 0x31, 0x65, 0x37, 0x33, 0x64, 0x35, 0x63, 0x35, 0x62, 0x34, 0x64, 0x36, 0x39, 0x63, 0x38, 0x30, 0x65, 0x63, 0x66, 0x31, 0x34, 0x36, 0x38, 0x36, 0x30, 0x66, 0x37, 0x37, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x65, 0x30, 0x31, 0x37, 0x34, 0x38, 0x32, 0x39, 0x66, 0x33, 0x34, 0x63, 0x33, 0x37, 0x38, 0x31, 0x62, 0x65, 0x31, 0x61, 0x35, 0x65, 0x33, 0x38, 0x64, 0x31, 0x35, 0x34, 0x31, 0x65, 0x61, 0x34, 0x33, 0x39, 0x62, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x37, 0x65, 0x30, 0x35, 0x65, 0x32, 0x39, 0x65, 0x64, 0x64, 0x61, 0x37, 0x65, 0x34, 0x61, 0x65, 0x32, 0x35, 0x63, 0x35, 0x31, 0x37, 0x33, 0x35, 0x34, 0x33, 0x65, 0x66, 0x64, 0x37, 0x31, 0x66, 0x36, 0x64, 0x33, 0x64, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x62, 0x36, 0x61, 0x63, 0x34, 0x38, 0x34, 0x30, 0x32, 0x37, 0x30, 0x34, 0x31, 0x36, 0x34, 0x32, 0x62, 0x62, 0x66, 0x64, 0x38, 0x64, 0x38, 0x30, 0x66, 0x39, 0x64, 0x30, 0x63, 0x31, 0x63, 0x66, 0x33, 0x33, 0x63, 0x31, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x33, 0x63, 0x30, 0x38, 0x61, 0x61, 0x38, 0x62, 0x39, 0x36, 0x61, 0x36, 0x31, 0x31, 0x65, 0x66, 0x36, 0x33, 0x63, 0x30, 0x32, 0x35, 0x33, 0x65, 0x32, 0x61, 0x34, 0x33, 0x33, 0x34, 0x38, 0x32, 0x39, 0x65, 0x35, 0x37, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x66, 0x34, 0x62, 0x66, 0x66, 0x30, 0x63, 0x61, 0x61, 0x35, 0x30, 0x32, 0x37, 0x63, 0x30, 0x61, 0x36, 0x61, 0x32, 0x64, 0x63, 0x66, 0x63, 0x39, 0x35, 0x32, 0x38, 0x32, 0x34, 0x64, 0x65, 0x32, 0x39, 0x34, 0x30, 0x39, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x66, 0x38, 0x36, 0x39, 0x66, 0x30, 0x33, 0x35, 0x30, 0x62, 0x35, 0x37, 0x64, 0x35, 0x33, 0x34, 0x37, 0x38, 0x64, 0x37, 0x30, 0x31, 0x65, 0x33, 0x66, 0x65, 0x65, 0x35, 0x32, 0x39, 0x62, 0x63, 0x39, 0x31, 0x31, 0x63, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x61, 0x62, 0x33, 0x34, 0x62, 0x63, 0x31, 0x37, 0x62, 0x36, 0x36, 0x66, 0x39, 0x63, 0x33, 0x62, 0x36, 0x33, 0x66, 0x31, 0x35, 0x31, 0x32, 0x37, 0x34, 0x66, 0x32, 0x61, 0x37, 0x32, 0x37, 0x63, 0x35, 0x33, 0x39, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x30, 0x31, 0x32, 0x35, 0x39, 0x63, 0x61, 0x66, 0x37, 0x33, 0x34, 0x61, 0x64, 0x37, 0x35, 0x38, 0x31, 0x63, 0x35, 0x36, 0x31, 0x30, 0x35, 0x31, 0x62, 0x61, 0x30, 0x62, 0x63, 0x61, 0x37, 0x66, 0x64, 0x36, 0x39, 0x34, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x65, 0x39, 0x63, 0x66, 0x38, 0x31, 0x36, 0x36, 0x63, 0x33, 0x36, 0x61, 0x62, 0x66, 0x61, 0x34, 0x39, 0x30, 0x35, 0x33, 0x62, 0x37, 0x61, 0x31, 0x61, 0x64, 0x34, 0x30, 0x33, 0x36, 0x32, 0x30, 0x32, 0x36, 0x38, 0x31, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x62, 0x63, 0x35, 0x36, 0x32, 0x39, 0x66, 0x39, 0x61, 0x36, 0x61, 0x36, 0x36, 0x62, 0x32, 0x63, 0x66, 0x33, 0x33, 0x36, 0x33, 0x61, 0x63, 0x34, 0x38, 0x39, 0x35, 0x63, 0x30, 0x33, 0x34, 0x38, 0x65, 0x38, 0x62, 0x66, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x30, 0x62, 0x34, 0x36, 0x34, 0x61, 0x63, 0x39, 0x64, 0x65, 0x33, 0x35, 0x61, 0x35, 0x36, 0x31, 0x38, 0x62, 0x37, 0x63, 0x62, 0x66, 0x32, 0x35, 0x34, 0x36, 0x37, 0x34, 0x31, 0x38, 0x32, 0x62, 0x38, 0x31, 0x62, 0x39, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x62, 0x64, 0x66, 0x31, 0x61, 0x36, 0x33, 0x37, 0x65, 0x66, 0x36, 0x63, 0x34, 0x32, 0x61, 0x37, 0x65, 0x32, 0x66, 0x65, 0x32, 0x31, 0x37, 0x37, 0x37, 0x33, 0x64, 0x36, 0x37, 0x37, 0x65, 0x38, 0x30, 0x34, 0x65, 0x62, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x30, 0x61, 0x37, 0x38, 0x61, 0x39, 0x63, 0x63, 0x33, 0x39, 0x33, 0x66, 0x39, 0x31, 0x63, 0x33, 0x64, 0x39, 0x65, 0x33, 0x39, 0x61, 0x36, 0x62, 0x38, 0x63, 0x30, 0x36, 0x39, 0x66, 0x30, 0x37, 0x35, 0x65, 0x36, 0x62, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x39, 0x63, 0x35, 0x66, 0x65, 0x63, 0x64, 0x32, 0x62, 0x34, 0x34, 0x66, 0x62, 0x62, 0x36, 0x61, 0x31, 0x65, 0x63, 0x37, 0x33, 0x32, 0x65, 0x61, 0x30, 0x35, 0x39, 0x66, 0x34, 0x66, 0x31, 0x66, 0x39, 0x64, 0x32, 0x62, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x30, 0x36, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x37, 0x31, 0x32, 0x63, 0x37, 0x61, 0x66, 0x31, 0x31, 0x36, 0x37, 0x36, 0x30, 0x30, 0x36, 0x61, 0x36, 0x36, 0x64, 0x32, 0x66, 0x63, 0x35, 0x63, 0x31, 0x61, 0x62, 0x34, 0x63, 0x34, 0x37, 0x39, 0x63, 0x65, 0x36, 0x30, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x36, 0x36, 0x66, 0x36, 0x37, 0x65, 0x33, 0x39, 0x36, 0x33, 0x36, 0x63, 0x30, 0x31, 0x66, 0x34, 0x33, 0x62, 0x33, 0x61, 0x32, 0x31, 0x61, 0x30, 0x65, 0x38, 0x35, 0x32, 0x39, 0x33, 0x32, 0x35, 0x63, 0x30, 0x38, 0x36, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x32, 0x38, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x64, 0x35, 0x30, 0x32, 0x61, 0x37, 0x34, 0x65, 0x38, 0x31, 0x33, 0x62, 0x63, 0x66, 0x61, 0x33, 0x35, 0x35, 0x63, 0x65, 0x64, 0x61, 0x33, 0x63, 0x31, 0x37, 0x36, 0x66, 0x36, 0x61, 0x36, 0x38, 0x37, 0x31, 0x61, 0x66, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x34, 0x37, 0x35, 0x34, 0x31, 0x39, 0x63, 0x30, 0x36, 0x64, 0x35, 0x66, 0x31, 0x34, 0x37, 0x61, 0x61, 0x35, 0x39, 0x37, 0x32, 0x34, 0x38, 0x65, 0x62, 0x34, 0x36, 0x63, 0x66, 0x37, 0x62, 0x65, 0x66, 0x61, 0x36, 0x34, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x34, 0x33, 0x64, 0x37, 0x37, 0x36, 0x32, 0x64, 0x37, 0x37, 0x32, 0x38, 0x37, 0x62, 0x31, 0x32, 0x36, 0x33, 0x38, 0x36, 0x38, 0x38, 0x62, 0x39, 0x38, 0x35, 0x34, 0x65, 0x38, 0x38, 0x61, 0x37, 0x36, 0x39, 0x62, 0x32, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x33, 0x64, 0x38, 0x62, 0x61, 0x61, 0x32, 0x35, 0x35, 0x31, 0x64, 0x32, 0x61, 0x64, 0x64, 0x63, 0x34, 0x33, 0x63, 0x32, 0x31, 0x62, 0x34, 0x35, 0x65, 0x38, 0x61, 0x66, 0x34, 0x63, 0x61, 0x32, 0x62, 0x66, 0x62, 0x32, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x66, 0x62, 0x62, 0x36, 0x64, 0x38, 0x38, 0x37, 0x66, 0x38, 0x62, 0x38, 0x63, 0x63, 0x33, 0x61, 0x38, 0x36, 0x39, 0x61, 0x62, 0x61, 0x38, 0x34, 0x37, 0x66, 0x33, 0x64, 0x31, 0x66, 0x36, 0x34, 0x33, 0x63, 0x35, 0x33, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x64, 0x62, 0x33, 0x39, 0x34, 0x34, 0x36, 0x35, 0x30, 0x36, 0x31, 0x36, 0x65, 0x34, 0x37, 0x63, 0x62, 0x31, 0x38, 0x32, 0x65, 0x30, 0x36, 0x30, 0x33, 0x32, 0x32, 0x66, 0x61, 0x31, 0x34, 0x38, 0x37, 0x39, 0x37, 0x38, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x64, 0x32, 0x31, 0x36, 0x36, 0x33, 0x64, 0x38, 0x62, 0x30, 0x31, 0x37, 0x36, 0x65, 0x30, 0x35, 0x66, 0x64, 0x65, 0x31, 0x62, 0x39, 0x30, 0x65, 0x66, 0x33, 0x31, 0x66, 0x38, 0x35, 0x33, 0x30, 0x66, 0x64, 0x61, 0x39, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x63, 0x63, 0x30, 0x32, 0x66, 0x36, 0x32, 0x33, 0x61, 0x39, 0x63, 0x66, 0x39, 0x38, 0x35, 0x33, 0x30, 0x39, 0x39, 0x37, 0x65, 0x61, 0x36, 0x37, 0x64, 0x39, 0x35, 0x63, 0x33, 0x62, 0x34, 0x39, 0x31, 0x38, 0x35, 0x39, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x62, 0x35, 0x61, 0x34, 0x35, 0x34, 0x61, 0x63, 0x33, 0x34, 0x30, 0x35, 0x62, 0x62, 0x34, 0x31, 0x37, 0x39, 0x32, 0x30, 0x38, 0x63, 0x36, 0x63, 0x38, 0x34, 0x64, 0x65, 0x30, 0x30, 0x36, 0x62, 0x63, 0x62, 0x39, 0x62, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x39, 0x32, 0x30, 0x66, 0x64, 0x30, 0x65, 0x32, 0x63, 0x37, 0x33, 0x35, 0x63, 0x32, 0x35, 0x36, 0x34, 0x36, 0x33, 0x63, 0x61, 0x61, 0x32, 0x34, 0x30, 0x66, 0x62, 0x37, 0x61, 0x63, 0x38, 0x36, 0x61, 0x39, 0x33, 0x64, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x31, 0x66, 0x31, 0x65, 0x31, 0x31, 0x35, 0x61, 0x30, 0x64, 0x36, 0x30, 0x63, 0x65, 0x30, 0x32, 0x66, 0x62, 0x32, 0x35, 0x64, 0x66, 0x30, 0x31, 0x34, 0x64, 0x32, 0x38, 0x39, 0x65, 0x33, 0x61, 0x30, 0x63, 0x62, 0x65, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x65, 0x32, 0x63, 0x36, 0x61, 0x38, 0x62, 0x65, 0x38, 0x65, 0x30, 0x61, 0x63, 0x66, 0x61, 0x35, 0x63, 0x34, 0x64, 0x66, 0x35, 0x65, 0x33, 0x36, 0x30, 0x35, 0x38, 0x62, 0x62, 0x37, 0x63, 0x62, 0x61, 0x63, 0x35, 0x61, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x62, 0x65, 0x30, 0x66, 0x61, 0x66, 0x34, 0x64, 0x37, 0x39, 0x32, 0x33, 0x66, 0x63, 0x34, 0x34, 0x34, 0x36, 0x32, 0x32, 0x64, 0x31, 0x39, 0x38, 0x30, 0x63, 0x66, 0x32, 0x64, 0x39, 0x39, 0x30, 0x61, 0x61, 0x62, 0x33, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x32, 0x39, 0x64, 0x30, 0x66, 0x37, 0x62, 0x62, 0x37, 0x63, 0x34, 0x34, 0x36, 0x63, 0x66, 0x62, 0x62, 0x30, 0x64, 0x65, 0x61, 0x64, 0x62, 0x32, 0x33, 0x39, 0x34, 0x64, 0x39, 0x64, 0x62, 0x37, 0x32, 0x34, 0x39, 0x61, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x63, 0x61, 0x63, 0x35, 0x30, 0x34, 0x62, 0x32, 0x33, 0x33, 0x38, 0x36, 0x36, 0x65, 0x62, 0x35, 0x61, 0x34, 0x61, 0x39, 0x39, 0x65, 0x37, 0x62, 0x64, 0x32, 0x39, 0x30, 0x31, 0x33, 0x35, 0x39, 0x65, 0x34, 0x33, 0x62, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x64, 0x36, 0x63, 0x62, 0x33, 0x30, 0x38, 0x34, 0x38, 0x31, 0x63, 0x33, 0x33, 0x36, 0x61, 0x36, 0x65, 0x31, 0x61, 0x32, 0x32, 0x35, 0x61, 0x39, 0x31, 0x32, 0x66, 0x36, 0x65, 0x36, 0x33, 0x35, 0x35, 0x39, 0x34, 0x30, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x38, 0x37, 0x39, 0x66, 0x64, 0x31, 0x32, 0x62, 0x31, 0x66, 0x33, 0x61, 0x32, 0x37, 0x66, 0x37, 0x65, 0x31, 0x30, 0x39, 0x37, 0x36, 0x31, 0x62, 0x32, 0x33, 0x63, 0x61, 0x33, 0x34, 0x33, 0x63, 0x34, 0x38, 0x65, 0x33, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x37, 0x66, 0x31, 0x30, 0x30, 0x62, 0x31, 0x61, 0x35, 0x39, 0x33, 0x30, 0x32, 0x32, 0x35, 0x65, 0x66, 0x63, 0x37, 0x65, 0x39, 0x30, 0x32, 0x30, 0x64, 0x37, 0x38, 0x33, 0x32, 0x37, 0x62, 0x34, 0x31, 0x63, 0x30, 0x32, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x61, 0x34, 0x32, 0x63, 0x32, 0x31, 0x62, 0x39, 0x62, 0x33, 0x31, 0x63, 0x33, 0x65, 0x32, 0x37, 0x63, 0x63, 0x64, 0x31, 0x37, 0x65, 0x30, 0x39, 0x39, 0x61, 0x66, 0x36, 0x37, 0x39, 0x63, 0x64, 0x66, 0x35, 0x36, 0x39, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x34, 0x64, 0x35, 0x32, 0x31, 0x32, 0x32, 0x36, 0x33, 0x61, 0x66, 0x66, 0x34, 0x61, 0x32, 0x61, 0x31, 0x34, 0x66, 0x30, 0x33, 0x31, 0x66, 0x30, 0x34, 0x65, 0x63, 0x37, 0x34, 0x39, 0x64, 0x63, 0x38, 0x38, 0x33, 0x65, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x33, 0x61, 0x32, 0x64, 0x61, 0x34, 0x31, 0x65, 0x38, 0x36, 0x38, 0x65, 0x64, 0x33, 0x66, 0x65, 0x66, 0x35, 0x37, 0x34, 0x35, 0x62, 0x39, 0x36, 0x66, 0x35, 0x65, 0x63, 0x61, 0x34, 0x36, 0x32, 0x66, 0x66, 0x36, 0x66, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x32, 0x36, 0x36, 0x39, 0x30, 0x63, 0x39, 0x39, 0x32, 0x62, 0x37, 0x61, 0x33, 0x31, 0x32, 0x61, 0x62, 0x31, 0x32, 0x65, 0x31, 0x33, 0x38, 0x35, 0x64, 0x39, 0x34, 0x61, 0x63, 0x64, 0x35, 0x38, 0x32, 0x38, 0x38, 0x65, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x31, 0x32, 0x32, 0x31, 0x36, 0x32, 0x63, 0x39, 0x31, 0x33, 0x65, 0x37, 0x31, 0x34, 0x36, 0x63, 0x61, 0x64, 0x30, 0x62, 0x37, 0x65, 0x64, 0x33, 0x37, 0x61, 0x66, 0x66, 0x63, 0x39, 0x32, 0x61, 0x30, 0x62, 0x66, 0x32, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x36, 0x37, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x37, 0x33, 0x35, 0x32, 0x64, 0x62, 0x61, 0x35, 0x38, 0x32, 0x65, 0x65, 0x32, 0x30, 0x36, 0x36, 0x62, 0x39, 0x63, 0x30, 0x30, 0x32, 0x61, 0x39, 0x36, 0x32, 0x65, 0x30, 0x30, 0x33, 0x31, 0x33, 0x34, 0x66, 0x37, 0x38, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x34, 0x61, 0x63, 0x39, 0x63, 0x39, 0x65, 0x37, 0x65, 0x32, 0x34, 0x63, 0x62, 0x32, 0x34, 0x34, 0x34, 0x61, 0x30, 0x34, 0x35, 0x34, 0x66, 0x61, 0x35, 0x62, 0x39, 0x61, 0x64, 0x39, 0x64, 0x39, 0x32, 0x64, 0x33, 0x38, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x66, 0x36, 0x32, 0x61, 0x36, 0x36, 0x33, 0x66, 0x31, 0x33, 0x35, 0x33, 0x62, 0x61, 0x32, 0x65, 0x66, 0x38, 0x65, 0x36, 0x35, 0x32, 0x31, 0x64, 0x63, 0x31, 0x65, 0x63, 0x62, 0x36, 0x37, 0x33, 0x65, 0x63, 0x38, 0x65, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x37, 0x66, 0x35, 0x65, 0x36, 0x35, 0x65, 0x30, 0x64, 0x61, 0x33, 0x33, 0x39, 0x39, 0x38, 0x32, 0x31, 0x39, 0x61, 0x64, 0x34, 0x65, 0x39, 0x39, 0x35, 0x37, 0x30, 0x35, 0x34, 0x35, 0x62, 0x32, 0x61, 0x39, 0x64, 0x35, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x66, 0x30, 0x30, 0x37, 0x37, 0x62, 0x33, 0x35, 0x31, 0x66, 0x36, 0x63, 0x35, 0x30, 0x35, 0x63, 0x64, 0x35, 0x31, 0x35, 0x64, 0x66, 0x61, 0x36, 0x64, 0x32, 0x66, 0x61, 0x37, 0x66, 0x35, 0x63, 0x34, 0x63, 0x64, 0x32, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x63, 0x36, 0x30, 0x30, 0x32, 0x66, 0x38, 0x34, 0x35, 0x32, 0x63, 0x61, 0x31, 0x35, 0x37, 0x66, 0x31, 0x33, 0x31, 0x37, 0x65, 0x38, 0x30, 0x61, 0x32, 0x66, 0x61, 0x66, 0x32, 0x34, 0x34, 0x37, 0x35, 0x35, 0x35, 0x39, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x61, 0x30, 0x37, 0x61, 0x33, 0x34, 0x61, 0x31, 0x61, 0x66, 0x63, 0x38, 0x39, 0x36, 0x37, 0x64, 0x33, 0x64, 0x31, 0x33, 0x38, 0x33, 0x62, 0x39, 0x36, 0x62, 0x36, 0x32, 0x63, 0x66, 0x39, 0x36, 0x64, 0x35, 0x66, 0x61, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x33, 0x38, 0x39, 0x63, 0x31, 0x32, 0x66, 0x33, 0x63, 0x36, 0x31, 0x36, 0x34, 0x66, 0x36, 0x34, 0x34, 0x36, 0x35, 0x36, 0x36, 0x63, 0x37, 0x37, 0x36, 0x36, 0x39, 0x35, 0x30, 0x33, 0x63, 0x32, 0x37, 0x39, 0x32, 0x35, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x34, 0x63, 0x63, 0x32, 0x35, 0x36, 0x61, 0x65, 0x37, 0x34, 0x64, 0x36, 0x32, 0x34, 0x61, 0x63, 0x65, 0x38, 0x30, 0x64, 0x62, 0x30, 0x37, 0x38, 0x62, 0x32, 0x32, 0x30, 0x37, 0x66, 0x35, 0x37, 0x31, 0x39, 0x38, 0x66, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x33, 0x62, 0x61, 0x37, 0x36, 0x34, 0x37, 0x32, 0x33, 0x38, 0x64, 0x31, 0x31, 0x33, 0x62, 0x63, 0x65, 0x39, 0x39, 0x36, 0x34, 0x61, 0x34, 0x33, 0x64, 0x30, 0x61, 0x30, 0x39, 0x38, 0x31, 0x31, 0x38, 0x62, 0x66, 0x65, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x61, 0x37, 0x36, 0x37, 0x36, 0x61, 0x64, 0x31, 0x34, 0x38, 0x61, 0x65, 0x39, 0x63, 0x31, 0x65, 0x66, 0x38, 0x62, 0x36, 0x66, 0x35, 0x65, 0x35, 0x61, 0x30, 0x63, 0x32, 0x63, 0x34, 0x37, 0x33, 0x62, 0x65, 0x38, 0x35, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x33, 0x34, 0x38, 0x30, 0x33, 0x35, 0x36, 0x39, 0x65, 0x30, 0x30, 0x62, 0x64, 0x36, 0x62, 0x35, 0x39, 0x66, 0x66, 0x66, 0x30, 0x38, 0x31, 0x64, 0x66, 0x61, 0x35, 0x63, 0x30, 0x61, 0x62, 0x34, 0x31, 0x39, 0x37, 0x61, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x31, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x31, 0x65, 0x61, 0x34, 0x38, 0x37, 0x37, 0x63, 0x64, 0x30, 0x38, 0x39, 0x34, 0x34, 0x65, 0x62, 0x36, 0x34, 0x63, 0x32, 0x39, 0x36, 0x36, 0x65, 0x39, 0x64, 0x62, 0x38, 0x64, 0x65, 0x64, 0x63, 0x66, 0x65, 0x63, 0x30, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x33, 0x37, 0x63, 0x32, 0x32, 0x65, 0x36, 0x30, 0x33, 0x61, 0x65, 0x64, 0x62, 0x36, 0x30, 0x61, 0x36, 0x32, 0x37, 0x32, 0x35, 0x33, 0x63, 0x34, 0x37, 0x64, 0x38, 0x62, 0x61, 0x38, 0x36, 0x36, 0x66, 0x36, 0x64, 0x39, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x39, 0x61, 0x61, 0x30, 0x30, 0x32, 0x63, 0x36, 0x39, 0x36, 0x32, 0x61, 0x33, 0x61, 0x38, 0x35, 0x34, 0x35, 0x30, 0x32, 0x37, 0x66, 0x64, 0x38, 0x62, 0x30, 0x35, 0x66, 0x32, 0x32, 0x62, 0x35, 0x62, 0x66, 0x39, 0x35, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x38, 0x39, 0x61, 0x38, 0x38, 0x32, 0x36, 0x37, 0x30, 0x39, 0x30, 0x39, 0x63, 0x66, 0x33, 0x37, 0x37, 0x65, 0x39, 0x65, 0x37, 0x38, 0x32, 0x38, 0x36, 0x65, 0x65, 0x39, 0x37, 0x62, 0x61, 0x37, 0x38, 0x64, 0x34, 0x36, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x63, 0x38, 0x35, 0x33, 0x39, 0x37, 0x37, 0x39, 0x32, 0x61, 0x36, 0x39, 0x64, 0x37, 0x38, 0x66, 0x32, 0x38, 0x36, 0x62, 0x38, 0x36, 0x34, 0x33, 0x32, 0x61, 0x30, 0x37, 0x61, 0x65, 0x63, 0x65, 0x62, 0x36, 0x30, 0x65, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x31, 0x30, 0x35, 0x39, 0x32, 0x32, 0x30, 0x32, 0x63, 0x32, 0x38, 0x32, 0x61, 0x62, 0x39, 0x62, 0x64, 0x38, 0x61, 0x38, 0x38, 0x34, 0x35, 0x31, 0x38, 0x62, 0x33, 0x65, 0x30, 0x62, 0x64, 0x34, 0x37, 0x35, 0x38, 0x31, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x39, 0x33, 0x32, 0x37, 0x30, 0x39, 0x61, 0x39, 0x37, 0x66, 0x30, 0x32, 0x63, 0x39, 0x38, 0x65, 0x35, 0x31, 0x62, 0x30, 0x39, 0x31, 0x33, 0x31, 0x32, 0x38, 0x36, 0x35, 0x31, 0x32, 0x32, 0x33, 0x38, 0x35, 0x61, 0x65, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x66, 0x38, 0x63, 0x39, 0x36, 0x31, 0x38, 0x36, 0x62, 0x33, 0x37, 0x39, 0x38, 0x34, 0x63, 0x62, 0x66, 0x65, 0x30, 0x34, 0x63, 0x35, 0x39, 0x38, 0x34, 0x30, 0x36, 0x65, 0x33, 0x62, 0x30, 0x61, 0x63, 0x33, 0x31, 0x37, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x66, 0x37, 0x38, 0x64, 0x61, 0x34, 0x66, 0x34, 0x64, 0x30, 0x34, 0x31, 0x62, 0x33, 0x62, 0x63, 0x31, 0x34, 0x62, 0x63, 0x35, 0x62, 0x61, 0x35, 0x31, 0x39, 0x61, 0x35, 0x62, 0x61, 0x30, 0x63, 0x33, 0x32, 0x66, 0x31, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x33, 0x32, 0x36, 0x32, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x30, 0x65, 0x64, 0x64, 0x32, 0x33, 0x62, 0x63, 0x64, 0x38, 0x35, 0x66, 0x36, 0x30, 0x31, 0x35, 0x66, 0x39, 0x32, 0x38, 0x39, 0x63, 0x32, 0x38, 0x38, 0x34, 0x31, 0x66, 0x65, 0x30, 0x34, 0x63, 0x38, 0x33, 0x65, 0x66, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x61, 0x34, 0x33, 0x63, 0x30, 0x30, 0x39, 0x31, 0x30, 0x30, 0x36, 0x31, 0x36, 0x63, 0x62, 0x34, 0x61, 0x65, 0x34, 0x65, 0x30, 0x33, 0x33, 0x66, 0x31, 0x66, 0x63, 0x35, 0x64, 0x37, 0x65, 0x30, 0x62, 0x36, 0x66, 0x31, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x33, 0x39, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x38, 0x31, 0x66, 0x61, 0x36, 0x62, 0x61, 0x61, 0x64, 0x36, 0x63, 0x66, 0x62, 0x37, 0x66, 0x35, 0x31, 0x62, 0x32, 0x63, 0x63, 0x61, 0x31, 0x36, 0x66, 0x62, 0x38, 0x39, 0x37, 0x30, 0x39, 0x39, 0x31, 0x61, 0x36, 0x34, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x33, 0x39, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x65, 0x37, 0x33, 0x38, 0x36, 0x64, 0x64, 0x65, 0x34, 0x30, 0x31, 0x63, 0x65, 0x34, 0x63, 0x36, 0x37, 0x62, 0x37, 0x31, 0x62, 0x36, 0x35, 0x35, 0x33, 0x66, 0x38, 0x61, 0x61, 0x33, 0x34, 0x65, 0x61, 0x35, 0x61, 0x31, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x65, 0x63, 0x37, 0x33, 0x30, 0x30, 0x62, 0x38, 0x31, 0x61, 0x63, 0x38, 0x34, 0x33, 0x33, 0x33, 0x65, 0x64, 0x31, 0x62, 0x30, 0x33, 0x33, 0x63, 0x64, 0x35, 0x64, 0x37, 0x61, 0x33, 0x33, 0x39, 0x37, 0x32, 0x65, 0x32, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x61, 0x38, 0x30, 0x65, 0x30, 0x31, 0x39, 0x30, 0x37, 0x32, 0x31, 0x66, 0x39, 0x34, 0x33, 0x39, 0x30, 0x64, 0x36, 0x38, 0x30, 0x32, 0x37, 0x32, 0x39, 0x64, 0x64, 0x31, 0x32, 0x63, 0x33, 0x31, 0x61, 0x38, 0x39, 0x35, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x34, 0x32, 0x39, 0x37, 0x64, 0x61, 0x33, 0x63, 0x35, 0x35, 0x35, 0x65, 0x34, 0x36, 0x63, 0x30, 0x37, 0x33, 0x36, 0x36, 0x39, 0x64, 0x30, 0x34, 0x37, 0x38, 0x66, 0x63, 0x65, 0x37, 0x35, 0x66, 0x32, 0x66, 0x37, 0x39, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x65, 0x30, 0x35, 0x38, 0x34, 0x61, 0x37, 0x31, 0x33, 0x34, 0x38, 0x63, 0x63, 0x33, 0x31, 0x34, 0x62, 0x37, 0x33, 0x62, 0x32, 0x30, 0x32, 0x39, 0x62, 0x36, 0x32, 0x33, 0x30, 0x62, 0x39, 0x32, 0x64, 0x62, 0x62, 0x31, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x32, 0x61, 0x64, 0x65, 0x39, 0x35, 0x62, 0x32, 0x65, 0x38, 0x63, 0x36, 0x36, 0x64, 0x38, 0x61, 0x65, 0x36, 0x66, 0x30, 0x62, 0x61, 0x36, 0x34, 0x63, 0x61, 0x35, 0x37, 0x64, 0x37, 0x38, 0x33, 0x62, 0x65, 0x36, 0x64, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x34, 0x62, 0x35, 0x62, 0x33, 0x35, 0x31, 0x64, 0x31, 0x62, 0x63, 0x38, 0x32, 0x65, 0x39, 0x32, 0x39, 0x37, 0x34, 0x33, 0x39, 0x39, 0x34, 0x38, 0x63, 0x66, 0x34, 0x38, 0x36, 0x31, 0x64, 0x61, 0x63, 0x39, 0x61, 0x65, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x65, 0x36, 0x32, 0x62, 0x64, 0x32, 0x37, 0x31, 0x61, 0x37, 0x36, 0x30, 0x36, 0x33, 0x37, 0x66, 0x61, 0x64, 0x37, 0x39, 0x63, 0x33, 0x31, 0x63, 0x39, 0x34, 0x66, 0x66, 0x36, 0x32, 0x62, 0x34, 0x63, 0x64, 0x31, 0x32, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x38, 0x30, 0x32, 0x33, 0x39, 0x32, 0x39, 0x64, 0x39, 0x31, 0x37, 0x32, 0x33, 0x34, 0x61, 0x65, 0x34, 0x30, 0x35, 0x31, 0x32, 0x62, 0x31, 0x61, 0x61, 0x62, 0x62, 0x35, 0x65, 0x38, 0x61, 0x34, 0x35, 0x31, 0x32, 0x37, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x35, 0x38, 0x61, 0x63, 0x61, 0x63, 0x61, 0x66, 0x32, 0x31, 0x65, 0x61, 0x38, 0x31, 0x63, 0x61, 0x62, 0x37, 0x35, 0x39, 0x38, 0x66, 0x64, 0x62, 0x64, 0x38, 0x36, 0x62, 0x34, 0x35, 0x32, 0x65, 0x39, 0x65, 0x38, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x33, 0x33, 0x62, 0x31, 0x33, 0x32, 0x35, 0x61, 0x30, 0x61, 0x66, 0x34, 0x35, 0x34, 0x37, 0x32, 0x63, 0x32, 0x35, 0x35, 0x32, 0x37, 0x38, 0x35, 0x33, 0x62, 0x31, 0x66, 0x31, 0x63, 0x32, 0x31, 0x66, 0x61, 0x33, 0x35, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x66, 0x38, 0x35, 0x61, 0x61, 0x61, 0x61, 0x36, 0x38, 0x33, 0x37, 0x33, 0x38, 0x66, 0x30, 0x37, 0x33, 0x62, 0x61, 0x65, 0x66, 0x34, 0x34, 0x61, 0x63, 0x39, 0x64, 0x63, 0x33, 0x34, 0x63, 0x34, 0x63, 0x37, 0x37, 0x39, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x65, 0x35, 0x37, 0x66, 0x32, 0x37, 0x39, 0x31, 0x37, 0x63, 0x35, 0x36, 0x32, 0x61, 0x31, 0x33, 0x32, 0x61, 0x34, 0x64, 0x31, 0x62, 0x66, 0x37, 0x65, 0x63, 0x30, 0x61, 0x63, 0x37, 0x38, 0x35, 0x38, 0x33, 0x32, 0x39, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x65, 0x36, 0x66, 0x39, 0x62, 0x32, 0x34, 0x37, 0x66, 0x39, 0x38, 0x38, 0x66, 0x36, 0x63, 0x30, 0x66, 0x63, 0x31, 0x34, 0x63, 0x35, 0x36, 0x66, 0x31, 0x64, 0x65, 0x35, 0x33, 0x65, 0x63, 0x36, 0x39, 0x64, 0x34, 0x33, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x32, 0x63, 0x32, 0x61, 0x30, 0x31, 0x31, 0x63, 0x30, 0x64, 0x66, 0x35, 0x30, 0x66, 0x62, 0x62, 0x36, 0x65, 0x32, 0x38, 0x62, 0x32, 0x30, 0x61, 0x65, 0x31, 0x61, 0x61, 0x64, 0x32, 0x31, 0x37, 0x38, 0x38, 0x36, 0x37, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x31, 0x63, 0x61, 0x66, 0x35, 0x61, 0x39, 0x37, 0x32, 0x61, 0x63, 0x65, 0x38, 0x33, 0x37, 0x39, 0x61, 0x36, 0x64, 0x30, 0x61, 0x30, 0x34, 0x61, 0x65, 0x36, 0x65, 0x31, 0x36, 0x33, 0x66, 0x65, 0x32, 0x31, 0x64, 0x66, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x36, 0x33, 0x35, 0x39, 0x30, 0x65, 0x66, 0x65, 0x39, 0x39, 0x38, 0x36, 0x63, 0x33, 0x66, 0x65, 0x65, 0x30, 0x39, 0x62, 0x30, 0x61, 0x30, 0x61, 0x33, 0x33, 0x38, 0x62, 0x31, 0x35, 0x62, 0x65, 0x64, 0x39, 0x31, 0x66, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x65, 0x31, 0x63, 0x38, 0x65, 0x63, 0x39, 0x38, 0x34, 0x31, 0x35, 0x62, 0x65, 0x66, 0x34, 0x34, 0x32, 0x36, 0x31, 0x38, 0x37, 0x30, 0x38, 0x37, 0x39, 0x39, 0x34, 0x33, 0x37, 0x62, 0x38, 0x36, 0x65, 0x36, 0x63, 0x32, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x66, 0x34, 0x61, 0x36, 0x34, 0x37, 0x31, 0x65, 0x62, 0x31, 0x62, 0x63, 0x61, 0x36, 0x61, 0x39, 0x66, 0x38, 0x35, 0x62, 0x33, 0x62, 0x34, 0x38, 0x37, 0x32, 0x65, 0x31, 0x30, 0x37, 0x35, 0x35, 0x63, 0x38, 0x32, 0x62, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x34, 0x39, 0x64, 0x65, 0x66, 0x66, 0x34, 0x37, 0x30, 0x38, 0x35, 0x66, 0x63, 0x30, 0x39, 0x37, 0x30, 0x34, 0x63, 0x61, 0x61, 0x32, 0x64, 0x63, 0x61, 0x38, 0x63, 0x32, 0x38, 0x37, 0x61, 0x39, 0x61, 0x31, 0x33, 0x37, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x31, 0x37, 0x33, 0x61, 0x32, 0x34, 0x37, 0x64, 0x32, 0x39, 0x64, 0x38, 0x32, 0x33, 0x38, 0x64, 0x66, 0x30, 0x39, 0x32, 0x32, 0x66, 0x34, 0x64, 0x66, 0x32, 0x35, 0x61, 0x30, 0x35, 0x66, 0x32, 0x61, 0x66, 0x37, 0x37, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x37, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x38, 0x39, 0x31, 0x62, 0x32, 0x63, 0x63, 0x64, 0x64, 0x32, 0x66, 0x35, 0x61, 0x34, 0x34, 0x62, 0x32, 0x61, 0x38, 0x62, 0x63, 0x34, 0x39, 0x61, 0x35, 0x64, 0x39, 0x62, 0x63, 0x61, 0x36, 0x34, 0x37, 0x37, 0x32, 0x35, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x61, 0x66, 0x33, 0x33, 0x35, 0x30, 0x62, 0x37, 0x63, 0x65, 0x31, 0x34, 0x34, 0x64, 0x30, 0x36, 0x38, 0x62, 0x31, 0x38, 0x36, 0x30, 0x31, 0x30, 0x38, 0x35, 0x32, 0x63, 0x38, 0x34, 0x64, 0x64, 0x30, 0x63, 0x65, 0x30, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x33, 0x39, 0x33, 0x64, 0x33, 0x37, 0x62, 0x34, 0x35, 0x31, 0x65, 0x66, 0x66, 0x62, 0x39, 0x65, 0x31, 0x66, 0x66, 0x33, 0x62, 0x38, 0x35, 0x35, 0x32, 0x37, 0x31, 0x32, 0x65, 0x32, 0x61, 0x39, 0x37, 0x30, 0x64, 0x38, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x62, 0x63, 0x36, 0x30, 0x62, 0x63, 0x63, 0x38, 0x30, 0x65, 0x35, 0x63, 0x64, 0x63, 0x33, 0x35, 0x63, 0x35, 0x34, 0x31, 0x36, 0x61, 0x31, 0x66, 0x30, 0x61, 0x34, 0x30, 0x61, 0x38, 0x33, 0x64, 0x61, 0x65, 0x38, 0x36, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x61, 0x62, 0x33, 0x39, 0x38, 0x30, 0x35, 0x62, 0x64, 0x38, 0x32, 0x31, 0x31, 0x38, 0x34, 0x66, 0x36, 0x63, 0x62, 0x64, 0x33, 0x64, 0x32, 0x34, 0x37, 0x33, 0x33, 0x34, 0x37, 0x62, 0x31, 0x32, 0x62, 0x66, 0x31, 0x37, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x35, 0x61, 0x36, 0x62, 0x34, 0x37, 0x36, 0x31, 0x66, 0x64, 0x31, 0x31, 0x65, 0x38, 0x63, 0x38, 0x35, 0x66, 0x31, 0x35, 0x31, 0x37, 0x34, 0x64, 0x37, 0x34, 0x37, 0x36, 0x37, 0x63, 0x64, 0x38, 0x62, 0x64, 0x39, 0x61, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x64, 0x31, 0x62, 0x35, 0x38, 0x35, 0x39, 0x36, 0x35, 0x66, 0x34, 0x30, 0x36, 0x61, 0x34, 0x32, 0x61, 0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x37, 0x30, 0x66, 0x37, 0x36, 0x39, 0x65, 0x37, 0x36, 0x35, 0x61, 0x33, 0x66, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x62, 0x39, 0x38, 0x38, 0x62, 0x35, 0x30, 0x35, 0x63, 0x66, 0x65, 0x65, 0x31, 0x64, 0x62, 0x65, 0x39, 0x63, 0x64, 0x31, 0x38, 0x65, 0x39, 0x62, 0x35, 0x34, 0x37, 0x33, 0x62, 0x39, 0x61, 0x32, 0x64, 0x34, 0x66, 0x35, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x65, 0x66, 0x38, 0x63, 0x33, 0x38, 0x37, 0x37, 0x39, 0x66, 0x62, 0x33, 0x30, 0x37, 0x65, 0x63, 0x36, 0x66, 0x30, 0x34, 0x34, 0x62, 0x65, 0x62, 0x65, 0x34, 0x37, 0x66, 0x33, 0x63, 0x66, 0x61, 0x65, 0x37, 0x39, 0x36, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x38, 0x35, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x32, 0x64, 0x36, 0x66, 0x39, 0x61, 0x31, 0x34, 0x30, 0x64, 0x32, 0x31, 0x33, 0x66, 0x34, 0x63, 0x38, 0x30, 0x63, 0x64, 0x30, 0x35, 0x31, 0x61, 0x66, 0x65, 0x32, 0x35, 0x63, 0x36, 0x32, 0x30, 0x62, 0x66, 0x34, 0x63, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x64, 0x39, 0x61, 0x30, 0x36, 0x64, 0x31, 0x62, 0x64, 0x33, 0x36, 0x63, 0x34, 0x65, 0x64, 0x64, 0x32, 0x37, 0x66, 0x63, 0x30, 0x64, 0x31, 0x66, 0x35, 0x62, 0x30, 0x38, 0x38, 0x64, 0x64, 0x61, 0x65, 0x33, 0x63, 0x37, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x63, 0x64, 0x62, 0x36, 0x62, 0x38, 0x37, 0x61, 0x35, 0x30, 0x33, 0x63, 0x36, 0x64, 0x38, 0x61, 0x33, 0x63, 0x36, 0x35, 0x63, 0x32, 0x63, 0x66, 0x39, 0x61, 0x39, 0x61, 0x61, 0x38, 0x38, 0x33, 0x34, 0x37, 0x39, 0x61, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x38, 0x34, 0x63, 0x32, 0x66, 0x64, 0x31, 0x38, 0x64, 0x38, 0x30, 0x39, 0x35, 0x37, 0x31, 0x34, 0x61, 0x39, 0x36, 0x38, 0x31, 0x37, 0x31, 0x38, 0x39, 0x63, 0x61, 0x32, 0x31, 0x63, 0x63, 0x61, 0x36, 0x32, 0x62, 0x61, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x39, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x62, 0x61, 0x64, 0x38, 0x36, 0x35, 0x30, 0x39, 0x66, 0x62, 0x65, 0x30, 0x65, 0x30, 0x65, 0x33, 0x63, 0x30, 0x65, 0x39, 0x33, 0x66, 0x36, 0x64, 0x33, 0x38, 0x31, 0x66, 0x31, 0x61, 0x66, 0x36, 0x65, 0x39, 0x64, 0x34, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x35, 0x34, 0x62, 0x64, 0x66, 0x65, 0x30, 0x62, 0x66, 0x35, 0x38, 0x37, 0x63, 0x36, 0x39, 0x35, 0x61, 0x33, 0x30, 0x35, 0x64, 0x39, 0x32, 0x34, 0x34, 0x63, 0x33, 0x64, 0x35, 0x62, 0x64, 0x64, 0x64, 0x61, 0x63, 0x39, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x38, 0x37, 0x34, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x66, 0x30, 0x65, 0x35, 0x61, 0x37, 0x35, 0x32, 0x66, 0x37, 0x39, 0x66, 0x36, 0x37, 0x31, 0x32, 0x34, 0x65, 0x65, 0x64, 0x36, 0x33, 0x33, 0x61, 0x64, 0x33, 0x66, 0x64, 0x32, 0x37, 0x30, 0x35, 0x61, 0x33, 0x39, 0x37, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x66, 0x64, 0x37, 0x31, 0x38, 0x66, 0x30, 0x62, 0x39, 0x31, 0x62, 0x35, 0x63, 0x65, 0x63, 0x38, 0x38, 0x61, 0x35, 0x64, 0x63, 0x31, 0x35, 0x65, 0x65, 0x63, 0x66, 0x30, 0x65, 0x63, 0x65, 0x66, 0x61, 0x34, 0x65, 0x66, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x30, 0x32, 0x37, 0x64, 0x31, 0x39, 0x35, 0x35, 0x38, 0x65, 0x64, 0x37, 0x33, 0x33, 0x39, 0x61, 0x30, 0x38, 0x61, 0x65, 0x65, 0x38, 0x64, 0x65, 0x33, 0x35, 0x35, 0x39, 0x62, 0x65, 0x30, 0x36, 0x33, 0x65, 0x63, 0x32, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x66, 0x30, 0x34, 0x36, 0x32, 0x61, 0x65, 0x36, 0x66, 0x38, 0x62, 0x39, 0x36, 0x30, 0x38, 0x38, 0x66, 0x37, 0x65, 0x39, 0x63, 0x36, 0x38, 0x63, 0x37, 0x34, 0x62, 0x39, 0x64, 0x38, 0x61, 0x64, 0x33, 0x34, 0x62, 0x33, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x66, 0x33, 0x39, 0x31, 0x63, 0x61, 0x39, 0x32, 0x38, 0x30, 0x38, 0x38, 0x31, 0x37, 0x62, 0x37, 0x35, 0x35, 0x61, 0x38, 0x62, 0x38, 0x66, 0x34, 0x65, 0x32, 0x63, 0x61, 0x30, 0x38, 0x64, 0x31, 0x66, 0x64, 0x31, 0x31, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x63, 0x66, 0x35, 0x62, 0x61, 0x36, 0x36, 0x36, 0x36, 0x66, 0x39, 0x36, 0x36, 0x63, 0x35, 0x34, 0x34, 0x38, 0x63, 0x31, 0x37, 0x62, 0x66, 0x31, 0x63, 0x62, 0x30, 0x62, 0x62, 0x63, 0x64, 0x38, 0x30, 0x31, 0x39, 0x62, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x62, 0x39, 0x61, 0x32, 0x37, 0x34, 0x37, 0x35, 0x31, 0x30, 0x65, 0x33, 0x31, 0x30, 0x32, 0x34, 0x31, 0x64, 0x32, 0x65, 0x63, 0x65, 0x39, 0x38, 0x66, 0x35, 0x36, 0x62, 0x33, 0x33, 0x30, 0x31, 0x64, 0x37, 0x35, 0x37, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x30, 0x30, 0x33, 0x38, 0x31, 0x64, 0x36, 0x30, 0x61, 0x35, 0x62, 0x35, 0x34, 0x61, 0x64, 0x63, 0x30, 0x39, 0x64, 0x31, 0x39, 0x36, 0x38, 0x33, 0x61, 0x38, 0x66, 0x36, 0x64, 0x35, 0x62, 0x62, 0x34, 0x62, 0x66, 0x62, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x39, 0x35, 0x61, 0x65, 0x37, 0x38, 0x63, 0x30, 0x64, 0x39, 0x30, 0x32, 0x36, 0x31, 0x65, 0x32, 0x31, 0x34, 0x30, 0x65, 0x66, 0x32, 0x30, 0x36, 0x33, 0x31, 0x30, 0x34, 0x37, 0x33, 0x31, 0x61, 0x36, 0x30, 0x64, 0x31, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x39, 0x31, 0x31, 0x63, 0x66, 0x37, 0x64, 0x63, 0x35, 0x64, 0x64, 0x30, 0x38, 0x31, 0x33, 0x36, 0x35, 0x36, 0x36, 0x37, 0x30, 0x35, 0x32, 0x38, 0x65, 0x39, 0x33, 0x33, 0x38, 0x65, 0x36, 0x37, 0x30, 0x33, 0x34, 0x37, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x32, 0x61, 0x65, 0x64, 0x34, 0x62, 0x63, 0x30, 0x66, 0x34, 0x61, 0x34, 0x62, 0x32, 0x63, 0x36, 0x66, 0x62, 0x33, 0x35, 0x37, 0x39, 0x33, 0x65, 0x38, 0x33, 0x35, 0x61, 0x34, 0x39, 0x31, 0x38, 0x39, 0x63, 0x64, 0x66, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x65, 0x39, 0x33, 0x66, 0x33, 0x33, 0x39, 0x65, 0x36, 0x37, 0x32, 0x36, 0x65, 0x63, 0x36, 0x35, 0x65, 0x65, 0x61, 0x34, 0x34, 0x66, 0x38, 0x61, 0x34, 0x62, 0x66, 0x65, 0x31, 0x30, 0x64, 0x61, 0x33, 0x64, 0x33, 0x32, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x61, 0x35, 0x37, 0x62, 0x30, 0x37, 0x31, 0x36, 0x31, 0x33, 0x32, 0x38, 0x30, 0x34, 0x64, 0x36, 0x30, 0x61, 0x61, 0x63, 0x32, 0x38, 0x31, 0x31, 0x39, 0x37, 0x66, 0x66, 0x32, 0x62, 0x33, 0x64, 0x32, 0x33, 0x37, 0x62, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x39, 0x39, 0x65, 0x33, 0x34, 0x65, 0x38, 0x38, 0x66, 0x66, 0x38, 0x38, 0x62, 0x65, 0x37, 0x64, 0x65, 0x32, 0x38, 0x65, 0x31, 0x35, 0x65, 0x34, 0x66, 0x32, 0x61, 0x36, 0x33, 0x64, 0x30, 0x62, 0x33, 0x33, 0x63, 0x34, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x35, 0x30, 0x36, 0x63, 0x31, 0x30, 0x31, 0x39, 0x31, 0x32, 0x31, 0x66, 0x66, 0x30, 0x38, 0x61, 0x32, 0x63, 0x38, 0x63, 0x31, 0x35, 0x39, 0x31, 0x61, 0x36, 0x35, 0x65, 0x62, 0x34, 0x62, 0x64, 0x66, 0x62, 0x34, 0x61, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x35, 0x65, 0x62, 0x63, 0x32, 0x36, 0x32, 0x36, 0x66, 0x63, 0x33, 0x39, 0x62, 0x30, 0x63, 0x38, 0x36, 0x32, 0x39, 0x34, 0x65, 0x30, 0x65, 0x38, 0x33, 0x37, 0x64, 0x63, 0x66, 0x35, 0x32, 0x33, 0x35, 0x35, 0x33, 0x30, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x31, 0x61, 0x63, 0x61, 0x38, 0x32, 0x36, 0x33, 0x31, 0x33, 0x32, 0x34, 0x61, 0x63, 0x62, 0x66, 0x61, 0x32, 0x34, 0x36, 0x38, 0x62, 0x64, 0x61, 0x33, 0x32, 0x35, 0x62, 0x62, 0x64, 0x37, 0x38, 0x34, 0x37, 0x37, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x32, 0x37, 0x31, 0x64, 0x32, 0x38, 0x35, 0x35, 0x30, 0x30, 0x64, 0x37, 0x33, 0x38, 0x34, 0x36, 0x62, 0x31, 0x38, 0x66, 0x37, 0x33, 0x33, 0x65, 0x32, 0x35, 0x64, 0x64, 0x38, 0x62, 0x34, 0x66, 0x35, 0x64, 0x34, 0x61, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x37, 0x38, 0x39, 0x32, 0x65, 0x32, 0x32, 0x37, 0x33, 0x62, 0x32, 0x33, 0x35, 0x64, 0x37, 0x36, 0x38, 0x39, 0x65, 0x34, 0x33, 0x30, 0x65, 0x37, 0x61, 0x65, 0x65, 0x64, 0x39, 0x63, 0x62, 0x63, 0x65, 0x38, 0x61, 0x31, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x38, 0x39, 0x37, 0x32, 0x38, 0x33, 0x38, 0x66, 0x37, 0x30, 0x63, 0x39, 0x30, 0x33, 0x63, 0x39, 0x62, 0x36, 0x63, 0x36, 0x63, 0x34, 0x36, 0x31, 0x36, 0x32, 0x65, 0x39, 0x39, 0x64, 0x36, 0x32, 0x31, 0x36, 0x64, 0x34, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x38, 0x35, 0x65, 0x64, 0x33, 0x36, 0x32, 0x66, 0x32, 0x34, 0x66, 0x36, 0x62, 0x39, 0x66, 0x30, 0x34, 0x63, 0x64, 0x66, 0x63, 0x63, 0x64, 0x30, 0x32, 0x32, 0x61, 0x65, 0x35, 0x33, 0x35, 0x31, 0x34, 0x37, 0x63, 0x62, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x30, 0x37, 0x65, 0x66, 0x66, 0x34, 0x33, 0x61, 0x61, 0x39, 0x37, 0x63, 0x37, 0x36, 0x39, 0x31, 0x30, 0x61, 0x31, 0x39, 0x37, 0x35, 0x32, 0x64, 0x64, 0x37, 0x31, 0x35, 0x65, 0x65, 0x30, 0x31, 0x38, 0x32, 0x64, 0x39, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x39, 0x65, 0x35, 0x34, 0x34, 0x31, 0x64, 0x34, 0x34, 0x62, 0x32, 0x34, 0x33, 0x62, 0x65, 0x35, 0x35, 0x62, 0x37, 0x35, 0x30, 0x32, 0x37, 0x61, 0x31, 0x63, 0x65, 0x62, 0x39, 0x65, 0x61, 0x63, 0x66, 0x35, 0x30, 0x64, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x65, 0x61, 0x65, 0x34, 0x33, 0x33, 0x32, 0x37, 0x39, 0x31, 0x33, 0x66, 0x36, 0x32, 0x38, 0x30, 0x38, 0x66, 0x61, 0x61, 0x31, 0x62, 0x36, 0x32, 0x37, 0x36, 0x61, 0x32, 0x62, 0x64, 0x36, 0x33, 0x36, 0x38, 0x65, 0x61, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x37, 0x30, 0x34, 0x35, 0x36, 0x38, 0x38, 0x35, 0x33, 0x34, 0x32, 0x62, 0x36, 0x34, 0x30, 0x62, 0x34, 0x63, 0x66, 0x63, 0x31, 0x62, 0x35, 0x32, 0x30, 0x65, 0x31, 0x61, 0x35, 0x34, 0x34, 0x65, 0x65, 0x30, 0x64, 0x35, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x37, 0x39, 0x38, 0x66, 0x32, 0x30, 0x31, 0x32, 0x35, 0x37, 0x62, 0x39, 0x63, 0x33, 0x35, 0x32, 0x30, 0x34, 0x39, 0x35, 0x37, 0x30, 0x35, 0x37, 0x62, 0x35, 0x34, 0x36, 0x37, 0x34, 0x61, 0x65, 0x66, 0x61, 0x35, 0x31, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x35, 0x66, 0x39, 0x65, 0x62, 0x33, 0x66, 0x62, 0x36, 0x66, 0x66, 0x33, 0x65, 0x39, 0x65, 0x33, 0x63, 0x38, 0x34, 0x34, 0x37, 0x65, 0x31, 0x34, 0x61, 0x36, 0x36, 0x65, 0x38, 0x64, 0x34, 0x66, 0x33, 0x37, 0x37, 0x39, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x64, 0x66, 0x32, 0x36, 0x38, 0x31, 0x64, 0x36, 0x64, 0x36, 0x30, 0x32, 0x65, 0x32, 0x32, 0x31, 0x34, 0x32, 0x64, 0x35, 0x34, 0x31, 0x31, 0x36, 0x64, 0x65, 0x61, 0x31, 0x35, 0x64, 0x34, 0x35, 0x34, 0x39, 0x35, 0x37, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x33, 0x33, 0x39, 0x36, 0x63, 0x65, 0x33, 0x63, 0x61, 0x63, 0x33, 0x39, 0x38, 0x62, 0x63, 0x62, 0x65, 0x37, 0x32, 0x32, 0x37, 0x66, 0x33, 0x32, 0x33, 0x65, 0x37, 0x38, 0x66, 0x66, 0x39, 0x36, 0x64, 0x30, 0x38, 0x37, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x37, 0x66, 0x66, 0x37, 0x39, 0x34, 0x33, 0x62, 0x37, 0x31, 0x64, 0x63, 0x34, 0x64, 0x63, 0x64, 0x62, 0x31, 0x36, 0x36, 0x38, 0x30, 0x37, 0x38, 0x66, 0x38, 0x33, 0x64, 0x64, 0x37, 0x63, 0x63, 0x34, 0x35, 0x32, 0x30, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x65, 0x64, 0x31, 0x31, 0x62, 0x30, 0x37, 0x32, 0x64, 0x38, 0x39, 0x66, 0x62, 0x31, 0x33, 0x36, 0x37, 0x35, 0x39, 0x66, 0x63, 0x36, 0x39, 0x62, 0x34, 0x32, 0x38, 0x63, 0x34, 0x38, 0x61, 0x61, 0x35, 0x64, 0x34, 0x63, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x30, 0x34, 0x33, 0x63, 0x34, 0x33, 0x38, 0x38, 0x64, 0x33, 0x34, 0x35, 0x66, 0x38, 0x38, 0x34, 0x63, 0x36, 0x38, 0x35, 0x35, 0x65, 0x37, 0x31, 0x31, 0x34, 0x32, 0x61, 0x39, 0x66, 0x34, 0x31, 0x66, 0x64, 0x36, 0x39, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x31, 0x34, 0x64, 0x32, 0x32, 0x31, 0x65, 0x33, 0x33, 0x64, 0x35, 0x34, 0x34, 0x36, 0x32, 0x39, 0x31, 0x39, 0x38, 0x63, 0x64, 0x30, 0x39, 0x36, 0x65, 0x64, 0x36, 0x33, 0x64, 0x66, 0x61, 0x32, 0x38, 0x64, 0x39, 0x66, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x31, 0x65, 0x36, 0x38, 0x33, 0x38, 0x66, 0x37, 0x63, 0x65, 0x63, 0x35, 0x62, 0x33, 0x38, 0x33, 0x63, 0x31, 0x64, 0x39, 0x30, 0x31, 0x34, 0x36, 0x33, 0x34, 0x31, 0x32, 0x37, 0x34, 0x64, 0x61, 0x66, 0x38, 0x65, 0x35, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x61, 0x30, 0x65, 0x36, 0x31, 0x65, 0x31, 0x62, 0x65, 0x34, 0x37, 0x66, 0x61, 0x38, 0x37, 0x65, 0x33, 0x30, 0x64, 0x33, 0x32, 0x38, 0x38, 0x38, 0x65, 0x65, 0x30, 0x33, 0x33, 0x30, 0x39, 0x30, 0x31, 0x63, 0x61, 0x39, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x66, 0x63, 0x39, 0x38, 0x65, 0x35, 0x63, 0x38, 0x32, 0x62, 0x36, 0x61, 0x64, 0x62, 0x31, 0x38, 0x30, 0x61, 0x33, 0x66, 0x63, 0x62, 0x31, 0x32, 0x30, 0x62, 0x39, 0x61, 0x37, 0x36, 0x39, 0x30, 0x63, 0x38, 0x36, 0x61, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x61, 0x36, 0x64, 0x32, 0x66, 0x63, 0x35, 0x32, 0x62, 0x65, 0x37, 0x33, 0x30, 0x38, 0x34, 0x30, 0x32, 0x33, 0x63, 0x39, 0x31, 0x38, 0x30, 0x32, 0x66, 0x30, 0x35, 0x62, 0x63, 0x32, 0x34, 0x61, 0x34, 0x62, 0x65, 0x30, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x35, 0x39, 0x31, 0x61, 0x34, 0x32, 0x31, 0x37, 0x39, 0x66, 0x33, 0x34, 0x65, 0x36, 0x34, 0x64, 0x39, 0x64, 0x66, 0x37, 0x35, 0x64, 0x63, 0x64, 0x34, 0x36, 0x33, 0x62, 0x32, 0x38, 0x36, 0x38, 0x36, 0x66, 0x35, 0x35, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x31, 0x32, 0x33, 0x30, 0x30, 0x34, 0x37, 0x63, 0x32, 0x31, 0x31, 0x64, 0x32, 0x64, 0x35, 0x62, 0x30, 0x30, 0x64, 0x38, 0x64, 0x65, 0x34, 0x63, 0x35, 0x31, 0x33, 0x39, 0x64, 0x65, 0x35, 0x65, 0x33, 0x32, 0x32, 0x37, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x62, 0x31, 0x66, 0x66, 0x37, 0x31, 0x37, 0x39, 0x38, 0x66, 0x32, 0x38, 0x64, 0x36, 0x65, 0x39, 0x38, 0x39, 0x66, 0x61, 0x31, 0x65, 0x61, 0x30, 0x35, 0x38, 0x38, 0x65, 0x32, 0x37, 0x62, 0x61, 0x38, 0x36, 0x63, 0x62, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x31, 0x66, 0x64, 0x31, 0x39, 0x30, 0x36, 0x61, 0x39, 0x30, 0x38, 0x35, 0x30, 0x36, 0x64, 0x65, 0x64, 0x61, 0x65, 0x31, 0x65, 0x32, 0x30, 0x38, 0x31, 0x32, 0x38, 0x38, 0x37, 0x32, 0x62, 0x35, 0x36, 0x65, 0x65, 0x37, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x30, 0x35, 0x65, 0x61, 0x36, 0x61, 0x36, 0x61, 0x63, 0x38, 0x61, 0x66, 0x37, 0x63, 0x62, 0x36, 0x61, 0x38, 0x62, 0x39, 0x31, 0x31, 0x61, 0x38, 0x63, 0x63, 0x65, 0x38, 0x66, 0x65, 0x31, 0x61, 0x32, 0x61, 0x63, 0x66, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x64, 0x64, 0x39, 0x33, 0x32, 0x31, 0x39, 0x33, 0x63, 0x64, 0x33, 0x38, 0x34, 0x39, 0x34, 0x61, 0x61, 0x33, 0x66, 0x30, 0x33, 0x61, 0x65, 0x63, 0x63, 0x63, 0x34, 0x62, 0x37, 0x61, 0x62, 0x37, 0x66, 0x61, 0x62, 0x63, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x61, 0x61, 0x33, 0x35, 0x32, 0x37, 0x34, 0x64, 0x37, 0x34, 0x32, 0x35, 0x34, 0x36, 0x36, 0x37, 0x30, 0x62, 0x37, 0x34, 0x32, 0x36, 0x32, 0x36, 0x34, 0x35, 0x32, 0x31, 0x30, 0x33, 0x32, 0x61, 0x66, 0x34, 0x66, 0x34, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x62, 0x38, 0x61, 0x36, 0x65, 0x39, 0x30, 0x66, 0x64, 0x66, 0x30, 0x61, 0x31, 0x63, 0x61, 0x63, 0x34, 0x34, 0x31, 0x37, 0x39, 0x33, 0x33, 0x30, 0x31, 0x65, 0x38, 0x37, 0x35, 0x30, 0x61, 0x39, 0x66, 0x61, 0x37, 0x39, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x35, 0x62, 0x65, 0x30, 0x64, 0x38, 0x63, 0x36, 0x37, 0x32, 0x37, 0x36, 0x62, 0x61, 0x61, 0x62, 0x64, 0x38, 0x65, 0x64, 0x62, 0x33, 0x30, 0x64, 0x34, 0x38, 0x65, 0x61, 0x37, 0x35, 0x36, 0x34, 0x30, 0x62, 0x38, 0x62, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x34, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x64, 0x37, 0x65, 0x35, 0x38, 0x36, 0x36, 0x66, 0x31, 0x64, 0x38, 0x35, 0x66, 0x64, 0x31, 0x63, 0x65, 0x62, 0x33, 0x32, 0x62, 0x66, 0x62, 0x65, 0x31, 0x64, 0x66, 0x63, 0x33, 0x36, 0x64, 0x62, 0x34, 0x33, 0x34, 0x35, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x65, 0x33, 0x65, 0x39, 0x30, 0x62, 0x32, 0x38, 0x66, 0x63, 0x63, 0x61, 0x65, 0x65, 0x38, 0x32, 0x38, 0x37, 0x37, 0x39, 0x62, 0x38, 0x64, 0x34, 0x30, 0x61, 0x35, 0x35, 0x36, 0x38, 0x63, 0x34, 0x31, 0x31, 0x36, 0x65, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x64, 0x35, 0x37, 0x38, 0x66, 0x37, 0x34, 0x30, 0x37, 0x64, 0x66, 0x62, 0x64, 0x35, 0x34, 0x38, 0x64, 0x30, 0x35, 0x65, 0x39, 0x35, 0x63, 0x63, 0x63, 0x33, 0x39, 0x63, 0x34, 0x38, 0x35, 0x34, 0x32, 0x39, 0x36, 0x32, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x61, 0x36, 0x39, 0x38, 0x39, 0x37, 0x34, 0x36, 0x62, 0x30, 0x36, 0x65, 0x33, 0x32, 0x65, 0x32, 0x34, 0x38, 0x37, 0x34, 0x36, 0x31, 0x62, 0x31, 0x63, 0x65, 0x39, 0x39, 0x36, 0x61, 0x32, 0x37, 0x33, 0x61, 0x63, 0x66, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x66, 0x39, 0x33, 0x33, 0x30, 0x37, 0x66, 0x38, 0x62, 0x63, 0x65, 0x30, 0x33, 0x31, 0x39, 0x35, 0x66, 0x65, 0x63, 0x65, 0x38, 0x37, 0x32, 0x30, 0x34, 0x33, 0x65, 0x38, 0x61, 0x30, 0x33, 0x66, 0x37, 0x62, 0x64, 0x31, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x62, 0x64, 0x35, 0x32, 0x66, 0x39, 0x37, 0x64, 0x61, 0x35, 0x66, 0x64, 0x33, 0x61, 0x36, 0x37, 0x33, 0x61, 0x34, 0x36, 0x63, 0x62, 0x66, 0x33, 0x33, 0x30, 0x34, 0x34, 0x37, 0x62, 0x37, 0x65, 0x38, 0x61, 0x61, 0x64, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x62, 0x64, 0x64, 0x39, 0x61, 0x66, 0x35, 0x39, 0x37, 0x38, 0x38, 0x35, 0x30, 0x62, 0x63, 0x32, 0x34, 0x31, 0x31, 0x30, 0x37, 0x31, 0x38, 0x62, 0x33, 0x37, 0x32, 0x33, 0x37, 0x35, 0x39, 0x62, 0x34, 0x33, 0x37, 0x65, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x30, 0x37, 0x33, 0x62, 0x36, 0x36, 0x64, 0x31, 0x62, 0x38, 0x63, 0x36, 0x36, 0x37, 0x34, 0x34, 0x64, 0x38, 0x38, 0x30, 0x39, 0x36, 0x61, 0x38, 0x64, 0x64, 0x39, 0x39, 0x65, 0x63, 0x37, 0x65, 0x30, 0x32, 0x32, 0x38, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x39, 0x64, 0x36, 0x36, 0x31, 0x61, 0x36, 0x33, 0x37, 0x36, 0x66, 0x36, 0x36, 0x64, 0x30, 0x62, 0x37, 0x34, 0x65, 0x32, 0x66, 0x65, 0x39, 0x64, 0x38, 0x66, 0x32, 0x36, 0x63, 0x30, 0x32, 0x34, 0x37, 0x65, 0x63, 0x38, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x33, 0x34, 0x66, 0x66, 0x35, 0x39, 0x61, 0x65, 0x38, 0x34, 0x30, 0x61, 0x37, 0x34, 0x31, 0x33, 0x63, 0x36, 0x62, 0x61, 0x34, 0x63, 0x35, 0x62, 0x62, 0x32, 0x62, 0x61, 0x32, 0x63, 0x37, 0x35, 0x65, 0x61, 0x62, 0x30, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x63, 0x61, 0x36, 0x61, 0x33, 0x63, 0x35, 0x64, 0x39, 0x66, 0x34, 0x34, 0x39, 0x64, 0x30, 0x39, 0x35, 0x36, 0x62, 0x64, 0x34, 0x33, 0x66, 0x61, 0x37, 0x62, 0x34, 0x64, 0x37, 0x62, 0x65, 0x38, 0x34, 0x33, 0x35, 0x39, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x39, 0x66, 0x39, 0x66, 0x30, 0x32, 0x62, 0x62, 0x63, 0x39, 0x38, 0x65, 0x66, 0x65, 0x30, 0x39, 0x37, 0x65, 0x61, 0x62, 0x62, 0x37, 0x38, 0x32, 0x31, 0x30, 0x39, 0x37, 0x39, 0x30, 0x32, 0x31, 0x38, 0x39, 0x38, 0x62, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x65, 0x33, 0x30, 0x30, 0x61, 0x63, 0x37, 0x31, 0x34, 0x35, 0x31, 0x65, 0x34, 0x30, 0x31, 0x66, 0x38, 0x38, 0x37, 0x66, 0x36, 0x65, 0x37, 0x37, 0x32, 0x38, 0x38, 0x35, 0x31, 0x36, 0x34, 0x37, 0x61, 0x38, 0x30, 0x65, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x61, 0x65, 0x37, 0x66, 0x64, 0x34, 0x62, 0x62, 0x63, 0x63, 0x38, 0x30, 0x63, 0x61, 0x31, 0x31, 0x61, 0x39, 0x30, 0x61, 0x31, 0x65, 0x63, 0x37, 0x61, 0x33, 0x30, 0x31, 0x66, 0x37, 0x63, 0x63, 0x63, 0x63, 0x38, 0x33, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x34, 0x31, 0x30, 0x32, 0x35, 0x33, 0x34, 0x64, 0x65, 0x38, 0x66, 0x32, 0x33, 0x65, 0x66, 0x66, 0x62, 0x30, 0x39, 0x33, 0x62, 0x33, 0x31, 0x32, 0x34, 0x32, 0x61, 0x64, 0x33, 0x62, 0x32, 0x33, 0x33, 0x66, 0x61, 0x63, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x32, 0x37, 0x61, 0x61, 0x62, 0x35, 0x39, 0x30, 0x36, 0x35, 0x61, 0x32, 0x38, 0x36, 0x34, 0x34, 0x61, 0x35, 0x36, 0x62, 0x61, 0x33, 0x66, 0x31, 0x35, 0x65, 0x32, 0x65, 0x61, 0x63, 0x31, 0x33, 0x64, 0x61, 0x32, 0x39, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x36, 0x30, 0x63, 0x34, 0x61, 0x62, 0x36, 0x65, 0x35, 0x34, 0x30, 0x32, 0x30, 0x36, 0x33, 0x31, 0x37, 0x65, 0x33, 0x35, 0x39, 0x34, 0x37, 0x61, 0x36, 0x33, 0x61, 0x39, 0x63, 0x61, 0x36, 0x62, 0x30, 0x33, 0x65, 0x32, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x32, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x35, 0x35, 0x62, 0x30, 0x33, 0x63, 0x63, 0x62, 0x30, 0x32, 0x39, 0x61, 0x37, 0x37, 0x34, 0x37, 0x62, 0x31, 0x66, 0x30, 0x37, 0x33, 0x30, 0x33, 0x65, 0x30, 0x61, 0x36, 0x36, 0x34, 0x37, 0x39, 0x33, 0x35, 0x33, 0x39, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x37, 0x38, 0x35, 0x30, 0x31, 0x66, 0x66, 0x39, 0x34, 0x61, 0x64, 0x64, 0x31, 0x63, 0x35, 0x38, 0x38, 0x31, 0x66, 0x65, 0x38, 0x38, 0x36, 0x31, 0x33, 0x36, 0x66, 0x36, 0x64, 0x66, 0x64, 0x62, 0x65, 0x36, 0x31, 0x61, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x34, 0x37, 0x31, 0x30, 0x38, 0x62, 0x39, 0x38, 0x64, 0x66, 0x36, 0x34, 0x62, 0x35, 0x37, 0x65, 0x38, 0x37, 0x31, 0x30, 0x33, 0x33, 0x38, 0x38, 0x35, 0x63, 0x31, 0x61, 0x64, 0x37, 0x31, 0x64, 0x62, 0x31, 0x61, 0x33, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x31, 0x36, 0x37, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x65, 0x65, 0x32, 0x36, 0x38, 0x39, 0x66, 0x61, 0x39, 0x30, 0x30, 0x36, 0x62, 0x35, 0x39, 0x63, 0x66, 0x32, 0x38, 0x35, 0x32, 0x33, 0x37, 0x64, 0x65, 0x35, 0x33, 0x62, 0x33, 0x61, 0x37, 0x66, 0x64, 0x30, 0x31, 0x34, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x30, 0x31, 0x64, 0x63, 0x37, 0x63, 0x33, 0x37, 0x34, 0x37, 0x63, 0x61, 0x36, 0x30, 0x38, 0x66, 0x39, 0x38, 0x33, 0x64, 0x66, 0x63, 0x38, 0x63, 0x39, 0x62, 0x33, 0x39, 0x65, 0x37, 0x35, 0x35, 0x61, 0x33, 0x62, 0x39, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x64, 0x65, 0x61, 0x63, 0x34, 0x63, 0x30, 0x32, 0x36, 0x62, 0x39, 0x33, 0x30, 0x35, 0x34, 0x64, 0x63, 0x35, 0x62, 0x31, 0x64, 0x36, 0x36, 0x31, 0x30, 0x63, 0x36, 0x66, 0x33, 0x39, 0x36, 0x30, 0x66, 0x32, 0x61, 0x64, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x63, 0x66, 0x66, 0x65, 0x32, 0x33, 0x39, 0x63, 0x36, 0x34, 0x65, 0x37, 0x65, 0x32, 0x30, 0x33, 0x38, 0x38, 0x65, 0x36, 0x32, 0x32, 0x31, 0x31, 0x37, 0x33, 0x39, 0x31, 0x33, 0x30, 0x31, 0x62, 0x32, 0x39, 0x38, 0x36, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x62, 0x62, 0x34, 0x66, 0x32, 0x63, 0x33, 0x64, 0x61, 0x38, 0x62, 0x65, 0x33, 0x65, 0x62, 0x36, 0x32, 0x64, 0x31, 0x66, 0x66, 0x62, 0x31, 0x66, 0x39, 0x35, 0x30, 0x32, 0x36, 0x31, 0x63, 0x66, 0x39, 0x38, 0x65, 0x63, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x63, 0x31, 0x30, 0x62, 0x39, 0x30, 0x63, 0x38, 0x35, 0x39, 0x63, 0x62, 0x62, 0x37, 0x38, 0x31, 0x35, 0x36, 0x39, 0x32, 0x66, 0x39, 0x39, 0x64, 0x61, 0x65, 0x35, 0x32, 0x30, 0x61, 0x62, 0x35, 0x66, 0x65, 0x62, 0x66, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x66, 0x39, 0x65, 0x63, 0x66, 0x33, 0x65, 0x35, 0x64, 0x64, 0x64, 0x63, 0x61, 0x33, 0x38, 0x38, 0x31, 0x35, 0x64, 0x33, 0x65, 0x35, 0x39, 0x65, 0x64, 0x33, 0x34, 0x62, 0x35, 0x62, 0x39, 0x30, 0x62, 0x34, 0x61, 0x33, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x66, 0x61, 0x35, 0x66, 0x66, 0x62, 0x36, 0x30, 0x34, 0x38, 0x66, 0x39, 0x36, 0x66, 0x62, 0x31, 0x61, 0x62, 0x61, 0x30, 0x39, 0x65, 0x66, 0x38, 0x37, 0x62, 0x31, 0x63, 0x31, 0x31, 0x64, 0x64, 0x37, 0x30, 0x30, 0x35, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x61, 0x34, 0x32, 0x65, 0x65, 0x37, 0x61, 0x30, 0x62, 0x38, 0x39, 0x38, 0x66, 0x36, 0x61, 0x35, 0x63, 0x63, 0x36, 0x30, 0x62, 0x35, 0x61, 0x35, 0x64, 0x37, 0x62, 0x31, 0x62, 0x66, 0x61, 0x33, 0x63, 0x33, 0x33, 0x32, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x39, 0x35, 0x37, 0x37, 0x39, 0x32, 0x30, 0x30, 0x35, 0x33, 0x62, 0x31, 0x61, 0x30, 0x30, 0x31, 0x38, 0x39, 0x33, 0x30, 0x34, 0x64, 0x38, 0x38, 0x38, 0x30, 0x31, 0x30, 0x64, 0x39, 0x65, 0x66, 0x32, 0x63, 0x62, 0x34, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x64, 0x30, 0x62, 0x34, 0x38, 0x32, 0x37, 0x63, 0x64, 0x32, 0x30, 0x38, 0x66, 0x66, 0x62, 0x66, 0x35, 0x65, 0x37, 0x35, 0x39, 0x64, 0x62, 0x61, 0x38, 0x63, 0x33, 0x63, 0x63, 0x36, 0x31, 0x64, 0x38, 0x63, 0x32, 0x63, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x66, 0x66, 0x31, 0x65, 0x62, 0x31, 0x64, 0x65, 0x61, 0x64, 0x35, 0x30, 0x61, 0x37, 0x66, 0x32, 0x66, 0x39, 0x36, 0x33, 0x38, 0x66, 0x64, 0x65, 0x65, 0x36, 0x65, 0x63, 0x63, 0x66, 0x33, 0x61, 0x37, 0x62, 0x32, 0x61, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x64, 0x65, 0x31, 0x34, 0x37, 0x62, 0x32, 0x61, 0x66, 0x37, 0x38, 0x39, 0x65, 0x61, 0x61, 0x35, 0x38, 0x36, 0x35, 0x34, 0x37, 0x65, 0x36, 0x36, 0x63, 0x34, 0x66, 0x61, 0x32, 0x36, 0x36, 0x34, 0x64, 0x33, 0x32, 0x38, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x37, 0x35, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x30, 0x34, 0x32, 0x62, 0x61, 0x36, 0x38, 0x62, 0x31, 0x32, 0x64, 0x34, 0x63, 0x31, 0x35, 0x31, 0x36, 0x35, 0x31, 0x63, 0x61, 0x32, 0x38, 0x31, 0x33, 0x62, 0x37, 0x33, 0x35, 0x32, 0x62, 0x64, 0x35, 0x36, 0x66, 0x30, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x63, 0x63, 0x61, 0x34, 0x32, 0x30, 0x34, 0x35, 0x65, 0x63, 0x33, 0x65, 0x31, 0x36, 0x35, 0x30, 0x38, 0x62, 0x36, 0x30, 0x33, 0x66, 0x64, 0x39, 0x33, 0x36, 0x65, 0x37, 0x66, 0x64, 0x37, 0x64, 0x65, 0x35, 0x66, 0x33, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x37, 0x61, 0x38, 0x39, 0x62, 0x64, 0x34, 0x35, 0x64, 0x63, 0x30, 0x34, 0x65, 0x65, 0x62, 0x34, 0x65, 0x34, 0x31, 0x64, 0x37, 0x62, 0x35, 0x39, 0x36, 0x62, 0x37, 0x30, 0x37, 0x65, 0x36, 0x65, 0x35, 0x31, 0x65, 0x37, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x37, 0x63, 0x37, 0x62, 0x38, 0x34, 0x35, 0x31, 0x34, 0x39, 0x65, 0x66, 0x62, 0x61, 0x31, 0x39, 0x65, 0x32, 0x36, 0x31, 0x62, 0x63, 0x37, 0x63, 0x37, 0x35, 0x31, 0x35, 0x37, 0x39, 0x30, 0x38, 0x61, 0x66, 0x61, 0x39, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x35, 0x32, 0x30, 0x31, 0x66, 0x65, 0x31, 0x33, 0x34, 0x32, 0x61, 0x66, 0x31, 0x31, 0x33, 0x30, 0x37, 0x62, 0x39, 0x31, 0x34, 0x32, 0x61, 0x30, 0x34, 0x31, 0x32, 0x34, 0x33, 0x63, 0x61, 0x39, 0x32, 0x65, 0x32, 0x66, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x64, 0x66, 0x34, 0x39, 0x35, 0x65, 0x63, 0x66, 0x33, 0x66, 0x38, 0x62, 0x34, 0x63, 0x65, 0x66, 0x32, 0x61, 0x36, 0x63, 0x31, 0x38, 0x39, 0x39, 0x35, 0x37, 0x32, 0x34, 0x38, 0x66, 0x65, 0x38, 0x38, 0x34, 0x62, 0x63, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x37, 0x39, 0x61, 0x38, 0x35, 0x33, 0x64, 0x37, 0x31, 0x62, 0x65, 0x30, 0x36, 0x32, 0x31, 0x62, 0x34, 0x34, 0x65, 0x32, 0x39, 0x37, 0x35, 0x39, 0x36, 0x35, 0x36, 0x63, 0x61, 0x30, 0x37, 0x35, 0x66, 0x64, 0x66, 0x34, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x65, 0x30, 0x32, 0x66, 0x32, 0x64, 0x64, 0x36, 0x37, 0x65, 0x66, 0x64, 0x62, 0x37, 0x33, 0x39, 0x33, 0x34, 0x30, 0x32, 0x66, 0x61, 0x39, 0x65, 0x61, 0x61, 0x63, 0x62, 0x63, 0x66, 0x35, 0x38, 0x39, 0x64, 0x32, 0x65, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x39, 0x61, 0x61, 0x64, 0x34, 0x36, 0x32, 0x37, 0x37, 0x34, 0x34, 0x65, 0x35, 0x33, 0x66, 0x35, 0x64, 0x36, 0x36, 0x33, 0x30, 0x39, 0x61, 0x61, 0x37, 0x34, 0x34, 0x34, 0x38, 0x62, 0x33, 0x61, 0x63, 0x64, 0x66, 0x34, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x34, 0x33, 0x31, 0x38, 0x66, 0x35, 0x65, 0x31, 0x33, 0x65, 0x38, 0x32, 0x34, 0x61, 0x35, 0x34, 0x65, 0x64, 0x66, 0x65, 0x33, 0x30, 0x61, 0x37, 0x65, 0x64, 0x34, 0x66, 0x32, 0x36, 0x63, 0x64, 0x33, 0x64, 0x61, 0x35, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x61, 0x32, 0x38, 0x36, 0x65, 0x30, 0x36, 0x35, 0x63, 0x38, 0x35, 0x66, 0x33, 0x61, 0x66, 0x37, 0x34, 0x38, 0x31, 0x32, 0x65, 0x64, 0x38, 0x62, 0x64, 0x33, 0x61, 0x38, 0x63, 0x65, 0x35, 0x64, 0x32, 0x35, 0x65, 0x32, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x36, 0x38, 0x36, 0x64, 0x65, 0x35, 0x33, 0x66, 0x61, 0x39, 0x37, 0x66, 0x39, 0x39, 0x36, 0x33, 0x39, 0x65, 0x32, 0x35, 0x36, 0x38, 0x35, 0x34, 0x39, 0x37, 0x32, 0x30, 0x62, 0x63, 0x35, 0x38, 0x38, 0x63, 0x39, 0x65, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x62, 0x30, 0x66, 0x66, 0x38, 0x33, 0x34, 0x30, 0x37, 0x33, 0x63, 0x63, 0x65, 0x31, 0x63, 0x62, 0x63, 0x39, 0x65, 0x61, 0x35, 0x35, 0x37, 0x65, 0x61, 0x38, 0x37, 0x62, 0x36, 0x30, 0x35, 0x39, 0x36, 0x33, 0x65, 0x38, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x62, 0x35, 0x36, 0x33, 0x33, 0x66, 0x65, 0x34, 0x37, 0x37, 0x66, 0x65, 0x35, 0x34, 0x32, 0x65, 0x37, 0x34, 0x32, 0x66, 0x61, 0x63, 0x66, 0x64, 0x36, 0x39, 0x30, 0x63, 0x31, 0x33, 0x37, 0x38, 0x35, 0x34, 0x66, 0x32, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x66, 0x33, 0x37, 0x33, 0x64, 0x30, 0x37, 0x36, 0x38, 0x31, 0x34, 0x63, 0x62, 0x63, 0x35, 0x37, 0x65, 0x31, 0x63, 0x36, 0x64, 0x31, 0x36, 0x61, 0x38, 0x32, 0x63, 0x35, 0x62, 0x65, 0x31, 0x33, 0x63, 0x37, 0x33, 0x64, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x32, 0x36, 0x34, 0x65, 0x36, 0x39, 0x32, 0x35, 0x31, 0x33, 0x30, 0x39, 0x30, 0x36, 0x63, 0x34, 0x64, 0x37, 0x63, 0x31, 0x38, 0x35, 0x39, 0x31, 0x61, 0x61, 0x34, 0x31, 0x62, 0x32, 0x61, 0x36, 0x37, 0x66, 0x36, 0x66, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x61, 0x32, 0x61, 0x32, 0x31, 0x30, 0x33, 0x31, 0x32, 0x62, 0x33, 0x65, 0x38, 0x36, 0x37, 0x65, 0x65, 0x30, 0x64, 0x31, 0x63, 0x63, 0x36, 0x38, 0x32, 0x63, 0x65, 0x31, 0x64, 0x36, 0x36, 0x36, 0x66, 0x31, 0x38, 0x65, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x32, 0x61, 0x66, 0x65, 0x63, 0x66, 0x38, 0x65, 0x32, 0x65, 0x63, 0x32, 0x62, 0x36, 0x32, 0x61, 0x63, 0x38, 0x61, 0x64, 0x32, 0x30, 0x34, 0x31, 0x36, 0x31, 0x66, 0x64, 0x31, 0x66, 0x61, 0x65, 0x37, 0x37, 0x31, 0x64, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x62, 0x32, 0x30, 0x66, 0x39, 0x38, 0x30, 0x61, 0x64, 0x38, 0x35, 0x33, 0x61, 0x64, 0x30, 0x34, 0x63, 0x62, 0x66, 0x63, 0x38, 0x38, 0x37, 0x63, 0x65, 0x36, 0x36, 0x30, 0x31, 0x63, 0x36, 0x62, 0x65, 0x30, 0x62, 0x32, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x38, 0x30, 0x61, 0x35, 0x38, 0x66, 0x38, 0x62, 0x62, 0x31, 0x30, 0x62, 0x39, 0x34, 0x34, 0x30, 0x64, 0x65, 0x39, 0x34, 0x66, 0x34, 0x32, 0x62, 0x34, 0x66, 0x35, 0x39, 0x32, 0x31, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x31, 0x34, 0x63, 0x64, 0x62, 0x35, 0x37, 0x31, 0x62, 0x66, 0x64, 0x39, 0x33, 0x64, 0x36, 0x34, 0x64, 0x61, 0x36, 0x36, 0x61, 0x34, 0x65, 0x31, 0x30, 0x38, 0x65, 0x61, 0x31, 0x33, 0x34, 0x65, 0x35, 0x30, 0x64, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x38, 0x36, 0x34, 0x32, 0x33, 0x36, 0x39, 0x33, 0x30, 0x64, 0x30, 0x34, 0x64, 0x38, 0x34, 0x30, 0x32, 0x62, 0x35, 0x64, 0x63, 0x62, 0x65, 0x62, 0x38, 0x30, 0x37, 0x66, 0x33, 0x63, 0x61, 0x66, 0x36, 0x31, 0x31, 0x65, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x64, 0x64, 0x32, 0x33, 0x39, 0x30, 0x30, 0x38, 0x31, 0x38, 0x32, 0x66, 0x62, 0x35, 0x31, 0x39, 0x66, 0x62, 0x33, 0x30, 0x65, 0x65, 0x64, 0x64, 0x32, 0x30, 0x39, 0x33, 0x66, 0x65, 0x64, 0x31, 0x36, 0x33, 0x39, 0x62, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x65, 0x35, 0x33, 0x32, 0x34, 0x33, 0x39, 0x38, 0x31, 0x61, 0x61, 0x62, 0x63, 0x38, 0x37, 0x36, 0x37, 0x64, 0x61, 0x31, 0x30, 0x63, 0x37, 0x33, 0x34, 0x34, 0x39, 0x66, 0x31, 0x33, 0x39, 0x31, 0x35, 0x36, 0x30, 0x65, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x61, 0x39, 0x32, 0x32, 0x36, 0x61, 0x65, 0x32, 0x37, 0x35, 0x64, 0x66, 0x32, 0x63, 0x61, 0x62, 0x33, 0x31, 0x32, 0x62, 0x39, 0x31, 0x31, 0x30, 0x34, 0x30, 0x36, 0x33, 0x34, 0x61, 0x39, 0x63, 0x39, 0x63, 0x39, 0x65, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x63, 0x63, 0x31, 0x39, 0x65, 0x61, 0x39, 0x66, 0x34, 0x63, 0x35, 0x37, 0x64, 0x63, 0x62, 0x63, 0x65, 0x38, 0x39, 0x33, 0x31, 0x39, 0x33, 0x63, 0x66, 0x62, 0x31, 0x36, 0x36, 0x61, 0x61, 0x39, 0x31, 0x34, 0x65, 0x64, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x31, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x65, 0x31, 0x34, 0x30, 0x39, 0x63, 0x61, 0x35, 0x32, 0x63, 0x32, 0x35, 0x34, 0x33, 0x35, 0x31, 0x33, 0x34, 0x64, 0x30, 0x30, 0x36, 0x63, 0x32, 0x61, 0x36, 0x61, 0x38, 0x35, 0x34, 0x32, 0x64, 0x66, 0x62, 0x37, 0x32, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x31, 0x64, 0x64, 0x66, 0x30, 0x34, 0x30, 0x34, 0x65, 0x34, 0x64, 0x32, 0x32, 0x64, 0x64, 0x61, 0x35, 0x35, 0x36, 0x61, 0x30, 0x37, 0x32, 0x36, 0x66, 0x30, 0x30, 0x62, 0x32, 0x64, 0x39, 0x38, 0x61, 0x62, 0x39, 0x35, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x62, 0x63, 0x63, 0x38, 0x38, 0x63, 0x33, 0x62, 0x32, 0x35, 0x36, 0x66, 0x36, 0x65, 0x64, 0x35, 0x66, 0x65, 0x35, 0x35, 0x30, 0x65, 0x34, 0x61, 0x31, 0x38, 0x31, 0x39, 0x38, 0x62, 0x39, 0x34, 0x33, 0x33, 0x35, 0x36, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x61, 0x31, 0x37, 0x66, 0x30, 0x36, 0x34, 0x62, 0x33, 0x34, 0x34, 0x65, 0x38, 0x34, 0x64, 0x62, 0x36, 0x33, 0x36, 0x35, 0x64, 0x61, 0x39, 0x35, 0x39, 0x31, 0x66, 0x66, 0x31, 0x36, 0x32, 0x38, 0x32, 0x35, 0x37, 0x36, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x32, 0x30, 0x66, 0x39, 0x63, 0x61, 0x34, 0x32, 0x36, 0x65, 0x66, 0x32, 0x66, 0x32, 0x63, 0x62, 0x64, 0x32, 0x66, 0x65, 0x63, 0x64, 0x33, 0x39, 0x39, 0x32, 0x30, 0x63, 0x34, 0x66, 0x31, 0x61, 0x38, 0x39, 0x65, 0x31, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x30, 0x34, 0x61, 0x35, 0x65, 0x62, 0x66, 0x62, 0x35, 0x64, 0x62, 0x34, 0x30, 0x39, 0x64, 0x62, 0x30, 0x36, 0x31, 0x37, 0x63, 0x39, 0x66, 0x61, 0x35, 0x36, 0x33, 0x31, 0x63, 0x31, 0x39, 0x32, 0x38, 0x36, 0x31, 0x66, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x38, 0x62, 0x31, 0x34, 0x63, 0x62, 0x66, 0x36, 0x36, 0x39, 0x34, 0x33, 0x33, 0x36, 0x64, 0x30, 0x66, 0x65, 0x31, 0x32, 0x61, 0x63, 0x31, 0x66, 0x32, 0x35, 0x64, 0x66, 0x32, 0x64, 0x61, 0x30, 0x63, 0x30, 0x35, 0x64, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x61, 0x63, 0x32, 0x30, 0x64, 0x36, 0x33, 0x62, 0x64, 0x38, 0x30, 0x33, 0x35, 0x39, 0x35, 0x63, 0x65, 0x63, 0x30, 0x33, 0x36, 0x64, 0x61, 0x37, 0x65, 0x64, 0x31, 0x64, 0x63, 0x36, 0x36, 0x65, 0x30, 0x61, 0x39, 0x65, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x39, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x63, 0x39, 0x34, 0x63, 0x32, 0x38, 0x32, 0x30, 0x64, 0x66, 0x63, 0x66, 0x37, 0x31, 0x35, 0x36, 0x65, 0x36, 0x66, 0x31, 0x33, 0x30, 0x38, 0x38, 0x65, 0x63, 0x65, 0x37, 0x39, 0x35, 0x38, 0x62, 0x33, 0x36, 0x37, 0x36, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x38, 0x64, 0x65, 0x61, 0x36, 0x30, 0x64, 0x66, 0x33, 0x65, 0x30, 0x39, 0x61, 0x65, 0x33, 0x63, 0x38, 0x64, 0x33, 0x35, 0x30, 0x35, 0x65, 0x39, 0x63, 0x30, 0x38, 0x30, 0x34, 0x35, 0x34, 0x62, 0x65, 0x30, 0x65, 0x38, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x36, 0x38, 0x64, 0x36, 0x32, 0x36, 0x34, 0x36, 0x35, 0x36, 0x33, 0x36, 0x31, 0x31, 0x64, 0x63, 0x33, 0x62, 0x38, 0x33, 0x32, 0x61, 0x33, 0x30, 0x61, 0x61, 0x32, 0x33, 0x39, 0x34, 0x63, 0x36, 0x34, 0x36, 0x31, 0x33, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x31, 0x39, 0x32, 0x62, 0x39, 0x36, 0x34, 0x61, 0x66, 0x64, 0x38, 0x30, 0x37, 0x37, 0x33, 0x65, 0x35, 0x66, 0x35, 0x65, 0x64, 0x61, 0x36, 0x61, 0x35, 0x36, 0x66, 0x31, 0x34, 0x65, 0x32, 0x35, 0x65, 0x30, 0x63, 0x36, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x38, 0x64, 0x34, 0x38, 0x62, 0x31, 0x65, 0x62, 0x30, 0x37, 0x62, 0x33, 0x63, 0x32, 0x31, 0x37, 0x37, 0x39, 0x30, 0x65, 0x36, 0x63, 0x32, 0x64, 0x66, 0x30, 0x34, 0x64, 0x63, 0x33, 0x31, 0x39, 0x65, 0x37, 0x65, 0x38, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x36, 0x31, 0x66, 0x61, 0x36, 0x63, 0x66, 0x35, 0x66, 0x38, 0x39, 0x38, 0x62, 0x34, 0x34, 0x30, 0x64, 0x61, 0x63, 0x35, 0x61, 0x62, 0x64, 0x38, 0x36, 0x30, 0x30, 0x64, 0x36, 0x64, 0x36, 0x39, 0x31, 0x66, 0x64, 0x65, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x39, 0x64, 0x33, 0x36, 0x38, 0x65, 0x62, 0x34, 0x36, 0x61, 0x32, 0x64, 0x31, 0x66, 0x62, 0x64, 0x63, 0x38, 0x66, 0x66, 0x61, 0x30, 0x36, 0x30, 0x37, 0x65, 0x64, 0x65, 0x34, 0x62, 0x61, 0x38, 0x38, 0x66, 0x35, 0x39, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x38, 0x32, 0x61, 0x35, 0x38, 0x39, 0x30, 0x66, 0x66, 0x62, 0x35, 0x34, 0x30, 0x36, 0x64, 0x33, 0x61, 0x63, 0x61, 0x38, 0x64, 0x32, 0x62, 0x66, 0x63, 0x31, 0x64, 0x64, 0x37, 0x30, 0x61, 0x61, 0x61, 0x38, 0x30, 0x61, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x32, 0x61, 0x65, 0x61, 0x35, 0x61, 0x31, 0x64, 0x63, 0x66, 0x36, 0x65, 0x64, 0x33, 0x62, 0x35, 0x65, 0x38, 0x33, 0x32, 0x33, 0x39, 0x34, 0x34, 0x65, 0x39, 0x38, 0x33, 0x66, 0x65, 0x64, 0x66, 0x64, 0x31, 0x61, 0x63, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x61, 0x61, 0x35, 0x30, 0x31, 0x38, 0x37, 0x30, 0x36, 0x37, 0x37, 0x65, 0x37, 0x66, 0x30, 0x61, 0x35, 0x30, 0x34, 0x38, 0x37, 0x36, 0x62, 0x34, 0x65, 0x38, 0x38, 0x30, 0x31, 0x61, 0x30, 0x61, 0x64, 0x30, 0x31, 0x63, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x34, 0x37, 0x33, 0x64, 0x30, 0x61, 0x62, 0x38, 0x37, 0x36, 0x64, 0x64, 0x61, 0x61, 0x31, 0x35, 0x36, 0x30, 0x38, 0x36, 0x32, 0x31, 0x64, 0x37, 0x30, 0x31, 0x33, 0x65, 0x36, 0x66, 0x66, 0x37, 0x31, 0x34, 0x62, 0x36, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x32, 0x39, 0x30, 0x66, 0x62, 0x35, 0x66, 0x39, 0x61, 0x35, 0x31, 0x37, 0x66, 0x38, 0x32, 0x38, 0x34, 0x35, 0x61, 0x63, 0x64, 0x65, 0x63, 0x61, 0x30, 0x66, 0x63, 0x38, 0x34, 0x36, 0x30, 0x33, 0x39, 0x62, 0x65, 0x32, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x35, 0x38, 0x33, 0x31, 0x32, 0x38, 0x32, 0x63, 0x65, 0x31, 0x34, 0x61, 0x36, 0x35, 0x37, 0x61, 0x37, 0x33, 0x30, 0x64, 0x63, 0x31, 0x38, 0x38, 0x32, 0x36, 0x66, 0x37, 0x66, 0x39, 0x62, 0x39, 0x39, 0x64, 0x62, 0x39, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x33, 0x30, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x32, 0x38, 0x35, 0x31, 0x30, 0x63, 0x30, 0x39, 0x64, 0x62, 0x63, 0x64, 0x38, 0x35, 0x31, 0x39, 0x34, 0x61, 0x39, 0x38, 0x64, 0x36, 0x37, 0x63, 0x33, 0x33, 0x61, 0x63, 0x34, 0x39, 0x66, 0x32, 0x66, 0x39, 0x34, 0x64, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x38, 0x38, 0x33, 0x61, 0x32, 0x30, 0x33, 0x32, 0x39, 0x36, 0x36, 0x37, 0x65, 0x61, 0x32, 0x32, 0x36, 0x61, 0x31, 0x65, 0x33, 0x63, 0x37, 0x36, 0x35, 0x64, 0x62, 0x62, 0x36, 0x62, 0x61, 0x62, 0x33, 0x32, 0x32, 0x31, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x33, 0x38, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x31, 0x35, 0x31, 0x30, 0x30, 0x65, 0x61, 0x37, 0x65, 0x32, 0x35, 0x62, 0x62, 0x61, 0x39, 0x62, 0x63, 0x61, 0x37, 0x34, 0x36, 0x30, 0x35, 0x38, 0x61, 0x66, 0x62, 0x62, 0x62, 0x34, 0x66, 0x66, 0x62, 0x65, 0x34, 0x32, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x31, 0x35, 0x65, 0x65, 0x33, 0x61, 0x62, 0x37, 0x36, 0x34, 0x31, 0x65, 0x31, 0x61, 0x61, 0x36, 0x64, 0x30, 0x30, 0x30, 0x65, 0x34, 0x31, 0x62, 0x66, 0x63, 0x31, 0x65, 0x63, 0x37, 0x32, 0x31, 0x30, 0x63, 0x32, 0x66, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x66, 0x61, 0x38, 0x64, 0x35, 0x36, 0x38, 0x35, 0x37, 0x35, 0x36, 0x35, 0x38, 0x63, 0x61, 0x34, 0x63, 0x31, 0x61, 0x35, 0x39, 0x33, 0x61, 0x63, 0x34, 0x63, 0x35, 0x64, 0x30, 0x65, 0x34, 0x34, 0x63, 0x36, 0x30, 0x37, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x63, 0x32, 0x34, 0x64, 0x34, 0x62, 0x33, 0x61, 0x35, 0x65, 0x30, 0x66, 0x66, 0x38, 0x61, 0x34, 0x36, 0x32, 0x32, 0x64, 0x35, 0x31, 0x38, 0x65, 0x64, 0x64, 0x37, 0x33, 0x66, 0x31, 0x36, 0x61, 0x62, 0x32, 0x38, 0x36, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x33, 0x39, 0x61, 0x63, 0x64, 0x39, 0x36, 0x62, 0x33, 0x31, 0x62, 0x61, 0x35, 0x33, 0x62, 0x30, 0x64, 0x30, 0x38, 0x37, 0x36, 0x33, 0x32, 0x32, 0x39, 0x65, 0x31, 0x66, 0x30, 0x36, 0x66, 0x64, 0x31, 0x30, 0x35, 0x65, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x61, 0x34, 0x61, 0x66, 0x66, 0x31, 0x61, 0x33, 0x37, 0x66, 0x39, 0x38, 0x34, 0x62, 0x30, 0x61, 0x36, 0x37, 0x32, 0x37, 0x32, 0x31, 0x34, 0x39, 0x32, 0x37, 0x33, 0x61, 0x65, 0x39, 0x62, 0x64, 0x34, 0x31, 0x65, 0x33, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x36, 0x38, 0x34, 0x64, 0x66, 0x62, 0x38, 0x33, 0x30, 0x34, 0x37, 0x32, 0x39, 0x33, 0x35, 0x35, 0x62, 0x35, 0x38, 0x33, 0x31, 0x35, 0x65, 0x38, 0x30, 0x31, 0x39, 0x62, 0x31, 0x61, 0x61, 0x32, 0x61, 0x64, 0x31, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x39, 0x37, 0x62, 0x36, 0x30, 0x66, 0x64, 0x32, 0x38, 0x39, 0x34, 0x61, 0x62, 0x33, 0x63, 0x32, 0x66, 0x34, 0x61, 0x65, 0x64, 0x65, 0x38, 0x36, 0x64, 0x61, 0x66, 0x32, 0x65, 0x37, 0x38, 0x38, 0x64, 0x37, 0x34, 0x35, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x61, 0x30, 0x64, 0x65, 0x34, 0x32, 0x31, 0x61, 0x65, 0x35, 0x34, 0x66, 0x36, 0x64, 0x31, 0x37, 0x32, 0x38, 0x31, 0x33, 0x30, 0x38, 0x66, 0x35, 0x36, 0x34, 0x36, 0x64, 0x32, 0x66, 0x33, 0x39, 0x66, 0x37, 0x37, 0x37, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x35, 0x30, 0x34, 0x66, 0x30, 0x35, 0x36, 0x34, 0x33, 0x66, 0x61, 0x62, 0x35, 0x39, 0x31, 0x39, 0x66, 0x35, 0x65, 0x65, 0x61, 0x35, 0x35, 0x39, 0x32, 0x35, 0x64, 0x37, 0x61, 0x33, 0x65, 0x64, 0x37, 0x64, 0x38, 0x30, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x37, 0x30, 0x36, 0x38, 0x65, 0x31, 0x63, 0x33, 0x33, 0x37, 0x35, 0x63, 0x30, 0x65, 0x35, 0x39, 0x39, 0x64, 0x62, 0x31, 0x66, 0x62, 0x65, 0x36, 0x62, 0x32, 0x65, 0x61, 0x32, 0x33, 0x62, 0x38, 0x66, 0x34, 0x30, 0x37, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x37, 0x38, 0x64, 0x37, 0x66, 0x36, 0x31, 0x62, 0x30, 0x65, 0x35, 0x36, 0x63, 0x37, 0x34, 0x65, 0x65, 0x36, 0x36, 0x33, 0x35, 0x62, 0x32, 0x65, 0x31, 0x38, 0x31, 0x39, 0x65, 0x66, 0x31, 0x65, 0x33, 0x64, 0x38, 0x37, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x31, 0x32, 0x62, 0x35, 0x31, 0x65, 0x32, 0x32, 0x35, 0x62, 0x34, 0x61, 0x34, 0x33, 0x37, 0x32, 0x65, 0x35, 0x39, 0x61, 0x64, 0x37, 0x61, 0x32, 0x61, 0x31, 0x61, 0x31, 0x33, 0x65, 0x61, 0x33, 0x64, 0x33, 0x61, 0x31, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x31, 0x37, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x32, 0x65, 0x38, 0x36, 0x34, 0x36, 0x39, 0x61, 0x35, 0x62, 0x66, 0x33, 0x37, 0x63, 0x65, 0x65, 0x38, 0x32, 0x65, 0x38, 0x38, 0x62, 0x34, 0x63, 0x33, 0x38, 0x36, 0x33, 0x38, 0x39, 0x35, 0x64, 0x32, 0x38, 0x66, 0x63, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x37, 0x36, 0x37, 0x32, 0x66, 0x64, 0x33, 0x39, 0x64, 0x36, 0x66, 0x32, 0x34, 0x36, 0x63, 0x65, 0x36, 0x36, 0x61, 0x37, 0x39, 0x30, 0x64, 0x31, 0x33, 0x61, 0x61, 0x39, 0x32, 0x32, 0x64, 0x37, 0x30, 0x65, 0x61, 0x31, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x30, 0x39, 0x61, 0x37, 0x63, 0x62, 0x64, 0x31, 0x39, 0x32, 0x62, 0x33, 0x61, 0x65, 0x64, 0x34, 0x61, 0x64, 0x62, 0x39, 0x38, 0x33, 0x64, 0x35, 0x32, 0x38, 0x34, 0x35, 0x35, 0x32, 0x63, 0x31, 0x36, 0x63, 0x37, 0x34, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x63, 0x33, 0x63, 0x34, 0x38, 0x61, 0x31, 0x61, 0x63, 0x30, 0x61, 0x33, 0x34, 0x37, 0x39, 0x39, 0x66, 0x30, 0x34, 0x64, 0x62, 0x38, 0x36, 0x65, 0x63, 0x37, 0x61, 0x39, 0x37, 0x35, 0x66, 0x65, 0x37, 0x37, 0x36, 0x38, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x62, 0x65, 0x37, 0x35, 0x65, 0x39, 0x38, 0x61, 0x39, 0x39, 0x35, 0x61, 0x33, 0x39, 0x35, 0x32, 0x32, 0x32, 0x64, 0x30, 0x30, 0x62, 0x64, 0x37, 0x39, 0x66, 0x66, 0x34, 0x62, 0x36, 0x65, 0x36, 0x33, 0x38, 0x65, 0x31, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x30, 0x35, 0x65, 0x33, 0x34, 0x65, 0x35, 0x65, 0x66, 0x32, 0x66, 0x34, 0x32, 0x65, 0x64, 0x30, 0x39, 0x64, 0x65, 0x66, 0x66, 0x31, 0x30, 0x32, 0x36, 0x63, 0x64, 0x36, 0x36, 0x62, 0x63, 0x62, 0x36, 0x39, 0x36, 0x30, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x36, 0x61, 0x65, 0x38, 0x63, 0x62, 0x64, 0x36, 0x62, 0x33, 0x33, 0x39, 0x33, 0x63, 0x32, 0x32, 0x64, 0x31, 0x36, 0x32, 0x35, 0x34, 0x31, 0x30, 0x30, 0x64, 0x30, 0x32, 0x33, 0x38, 0x65, 0x38, 0x30, 0x38, 0x31, 0x34, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x39, 0x39, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x33, 0x37, 0x36, 0x65, 0x31, 0x62, 0x32, 0x64, 0x32, 0x66, 0x35, 0x39, 0x30, 0x37, 0x36, 0x39, 0x62, 0x62, 0x38, 0x35, 0x38, 0x64, 0x34, 0x35, 0x37, 0x35, 0x33, 0x32, 0x30, 0x64, 0x34, 0x65, 0x31, 0x34, 0x39, 0x39, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x65, 0x61, 0x64, 0x36, 0x37, 0x64, 0x62, 0x66, 0x35, 0x62, 0x37, 0x65, 0x62, 0x31, 0x33, 0x33, 0x35, 0x38, 0x65, 0x31, 0x30, 0x66, 0x33, 0x36, 0x31, 0x38, 0x39, 0x64, 0x35, 0x33, 0x65, 0x36, 0x34, 0x33, 0x63, 0x66, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x64, 0x35, 0x39, 0x38, 0x38, 0x32, 0x34, 0x39, 0x61, 0x36, 0x38, 0x36, 0x31, 0x34, 0x37, 0x31, 0x36, 0x36, 0x35, 0x39, 0x38, 0x34, 0x30, 0x65, 0x64, 0x30, 0x61, 0x65, 0x36, 0x66, 0x36, 0x66, 0x34, 0x35, 0x37, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x39, 0x36, 0x30, 0x65, 0x31, 0x30, 0x63, 0x35, 0x32, 0x33, 0x39, 0x31, 0x63, 0x35, 0x34, 0x65, 0x31, 0x35, 0x33, 0x38, 0x37, 0x63, 0x63, 0x36, 0x37, 0x61, 0x66, 0x38, 0x32, 0x37, 0x62, 0x35, 0x33, 0x31, 0x36, 0x64, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x33, 0x62, 0x61, 0x39, 0x39, 0x30, 0x33, 0x34, 0x65, 0x39, 0x30, 0x30, 0x65, 0x33, 0x61, 0x65, 0x64, 0x66, 0x36, 0x31, 0x34, 0x39, 0x39, 0x64, 0x33, 0x62, 0x32, 0x62, 0x63, 0x65, 0x33, 0x39, 0x62, 0x65, 0x62, 0x37, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x66, 0x32, 0x33, 0x65, 0x39, 0x63, 0x30, 0x61, 0x61, 0x66, 0x63, 0x37, 0x38, 0x62, 0x39, 0x63, 0x34, 0x30, 0x34, 0x64, 0x63, 0x64, 0x36, 0x30, 0x33, 0x33, 0x39, 0x61, 0x39, 0x32, 0x35, 0x62, 0x66, 0x66, 0x61, 0x32, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x35, 0x61, 0x34, 0x34, 0x37, 0x63, 0x39, 0x31, 0x31, 0x64, 0x62, 0x62, 0x32, 0x37, 0x35, 0x62, 0x66, 0x62, 0x32, 0x65, 0x35, 0x61, 0x33, 0x37, 0x65, 0x35, 0x61, 0x37, 0x30, 0x33, 0x61, 0x35, 0x36, 0x66, 0x39, 0x39, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x62, 0x37, 0x31, 0x65, 0x63, 0x34, 0x31, 0x62, 0x64, 0x61, 0x37, 0x64, 0x63, 0x65, 0x38, 0x36, 0x65, 0x37, 0x36, 0x36, 0x65, 0x36, 0x65, 0x38, 0x63, 0x33, 0x65, 0x39, 0x39, 0x30, 0x37, 0x37, 0x32, 0x33, 0x61, 0x36, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x36, 0x61, 0x33, 0x65, 0x61, 0x38, 0x30, 0x37, 0x31, 0x66, 0x37, 0x30, 0x39, 0x35, 0x63, 0x37, 0x64, 0x62, 0x38, 0x61, 0x30, 0x35, 0x61, 0x65, 0x35, 0x30, 0x37, 0x61, 0x38, 0x39, 0x32, 0x39, 0x64, 0x62, 0x62, 0x38, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x33, 0x62, 0x33, 0x63, 0x66, 0x65, 0x33, 0x65, 0x65, 0x36, 0x32, 0x62, 0x62, 0x64, 0x65, 0x32, 0x61, 0x32, 0x36, 0x31, 0x65, 0x35, 0x33, 0x63, 0x62, 0x33, 0x65, 0x63, 0x63, 0x30, 0x35, 0x38, 0x31, 0x30, 0x66, 0x32, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x36, 0x66, 0x33, 0x38, 0x31, 0x33, 0x66, 0x35, 0x66, 0x36, 0x61, 0x31, 0x33, 0x62, 0x38, 0x65, 0x34, 0x66, 0x66, 0x65, 0x63, 0x38, 0x33, 0x66, 0x65, 0x37, 0x66, 0x38, 0x32, 0x36, 0x31, 0x38, 0x36, 0x61, 0x37, 0x31, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x62, 0x37, 0x32, 0x62, 0x66, 0x64, 0x34, 0x33, 0x66, 0x65, 0x66, 0x34, 0x36, 0x35, 0x63, 0x61, 0x35, 0x36, 0x33, 0x32, 0x62, 0x34, 0x35, 0x61, 0x61, 0x62, 0x37, 0x32, 0x36, 0x31, 0x34, 0x30, 0x34, 0x65, 0x31, 0x33, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x62, 0x37, 0x36, 0x32, 0x30, 0x34, 0x31, 0x38, 0x36, 0x61, 0x66, 0x32, 0x66, 0x36, 0x33, 0x62, 0x65, 0x37, 0x39, 0x31, 0x36, 0x38, 0x36, 0x30, 0x31, 0x36, 0x38, 0x37, 0x66, 0x63, 0x39, 0x62, 0x61, 0x64, 0x36, 0x36, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x61, 0x62, 0x31, 0x36, 0x35, 0x66, 0x66, 0x62, 0x36, 0x39, 0x65, 0x64, 0x61, 0x30, 0x63, 0x35, 0x34, 0x39, 0x61, 0x65, 0x33, 0x38, 0x65, 0x39, 0x38, 0x32, 0x36, 0x66, 0x35, 0x66, 0x37, 0x66, 0x39, 0x32, 0x66, 0x38, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x39, 0x36, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x33, 0x65, 0x32, 0x31, 0x31, 0x32, 0x32, 0x38, 0x32, 0x32, 0x31, 0x35, 0x64, 0x63, 0x30, 0x37, 0x36, 0x32, 0x66, 0x33, 0x32, 0x62, 0x37, 0x65, 0x38, 0x30, 0x37, 0x64, 0x63, 0x64, 0x31, 0x61, 0x37, 0x61, 0x61, 0x65, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x30, 0x38, 0x36, 0x65, 0x34, 0x32, 0x36, 0x36, 0x31, 0x65, 0x61, 0x39, 0x32, 0x39, 0x64, 0x32, 0x64, 0x64, 0x61, 0x31, 0x61, 0x62, 0x36, 0x63, 0x37, 0x34, 0x38, 0x63, 0x65, 0x33, 0x30, 0x35, 0x35, 0x64, 0x31, 0x31, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x62, 0x32, 0x31, 0x32, 0x38, 0x34, 0x62, 0x63, 0x64, 0x34, 0x66, 0x37, 0x38, 0x37, 0x61, 0x37, 0x35, 0x35, 0x36, 0x35, 0x30, 0x30, 0x64, 0x36, 0x64, 0x37, 0x64, 0x38, 0x66, 0x33, 0x36, 0x36, 0x32, 0x33, 0x63, 0x66, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x39, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x38, 0x36, 0x35, 0x31, 0x63, 0x31, 0x64, 0x39, 0x63, 0x31, 0x36, 0x62, 0x66, 0x66, 0x34, 0x63, 0x39, 0x35, 0x35, 0x34, 0x38, 0x38, 0x36, 0x63, 0x33, 0x66, 0x33, 0x66, 0x32, 0x36, 0x34, 0x33, 0x31, 0x66, 0x36, 0x66, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x64, 0x62, 0x64, 0x63, 0x39, 0x62, 0x39, 0x37, 0x33, 0x34, 0x33, 0x31, 0x64, 0x31, 0x33, 0x63, 0x38, 0x39, 0x61, 0x33, 0x66, 0x39, 0x37, 0x35, 0x37, 0x65, 0x39, 0x62, 0x33, 0x62, 0x36, 0x32, 0x37, 0x35, 0x62, 0x66, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x30, 0x64, 0x61, 0x33, 0x37, 0x65, 0x39, 0x35, 0x36, 0x64, 0x38, 0x36, 0x32, 0x66, 0x38, 0x31, 0x61, 0x37, 0x35, 0x66, 0x64, 0x35, 0x38, 0x30, 0x61, 0x37, 0x31, 0x33, 0x35, 0x63, 0x31, 0x62, 0x32, 0x34, 0x36, 0x33, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x36, 0x30, 0x61, 0x33, 0x65, 0x32, 0x35, 0x33, 0x62, 0x66, 0x33, 0x38, 0x63, 0x38, 0x64, 0x35, 0x36, 0x36, 0x32, 0x30, 0x31, 0x30, 0x62, 0x62, 0x39, 0x33, 0x61, 0x34, 0x37, 0x33, 0x63, 0x39, 0x36, 0x35, 0x63, 0x33, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x65, 0x30, 0x32, 0x61, 0x62, 0x62, 0x30, 0x31, 0x36, 0x63, 0x63, 0x32, 0x33, 0x61, 0x32, 0x39, 0x33, 0x34, 0x66, 0x36, 0x62, 0x63, 0x64, 0x64, 0x62, 0x36, 0x38, 0x31, 0x39, 0x30, 0x35, 0x30, 0x32, 0x31, 0x64, 0x35, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x32, 0x63, 0x38, 0x65, 0x30, 0x39, 0x64, 0x30, 0x36, 0x34, 0x39, 0x33, 0x61, 0x36, 0x33, 0x38, 0x35, 0x38, 0x34, 0x33, 0x37, 0x62, 0x64, 0x32, 0x30, 0x62, 0x65, 0x30, 0x31, 0x39, 0x36, 0x32, 0x34, 0x35, 0x30, 0x33, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x66, 0x39, 0x62, 0x33, 0x62, 0x32, 0x66, 0x32, 0x33, 0x63, 0x66, 0x34, 0x36, 0x31, 0x65, 0x62, 0x35, 0x39, 0x31, 0x66, 0x32, 0x38, 0x33, 0x34, 0x30, 0x62, 0x63, 0x37, 0x31, 0x39, 0x39, 0x33, 0x31, 0x63, 0x38, 0x33, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x35, 0x63, 0x33, 0x39, 0x66, 0x37, 0x65, 0x30, 0x61, 0x63, 0x31, 0x36, 0x38, 0x63, 0x38, 0x65, 0x64, 0x30, 0x65, 0x64, 0x33, 0x34, 0x30, 0x34, 0x37, 0x37, 0x31, 0x31, 0x37, 0x64, 0x31, 0x62, 0x36, 0x38, 0x32, 0x65, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x35, 0x62, 0x62, 0x33, 0x39, 0x63, 0x37, 0x39, 0x39, 0x37, 0x37, 0x39, 0x65, 0x62, 0x63, 0x30, 0x34, 0x61, 0x33, 0x33, 0x36, 0x64, 0x32, 0x36, 0x30, 0x64, 0x61, 0x36, 0x33, 0x31, 0x34, 0x36, 0x65, 0x64, 0x39, 0x38, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x39, 0x36, 0x36, 0x63, 0x34, 0x38, 0x39, 0x66, 0x34, 0x63, 0x37, 0x34, 0x38, 0x61, 0x37, 0x61, 0x65, 0x39, 0x38, 0x30, 0x61, 0x61, 0x32, 0x37, 0x61, 0x35, 0x37, 0x34, 0x32, 0x35, 0x31, 0x37, 0x36, 0x37, 0x63, 0x61, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x35, 0x33, 0x63, 0x39, 0x35, 0x34, 0x66, 0x34, 0x65, 0x64, 0x39, 0x37, 0x66, 0x64, 0x34, 0x38, 0x31, 0x30, 0x31, 0x31, 0x31, 0x62, 0x64, 0x61, 0x62, 0x36, 0x39, 0x65, 0x66, 0x39, 0x38, 0x31, 0x65, 0x66, 0x32, 0x35, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x61, 0x32, 0x36, 0x63, 0x66, 0x63, 0x34, 0x63, 0x31, 0x38, 0x33, 0x31, 0x36, 0x66, 0x37, 0x30, 0x64, 0x35, 0x39, 0x65, 0x39, 0x65, 0x31, 0x61, 0x37, 0x39, 0x65, 0x65, 0x33, 0x65, 0x38, 0x62, 0x39, 0x36, 0x32, 0x66, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x36, 0x33, 0x63, 0x65, 0x33, 0x62, 0x32, 0x34, 0x63, 0x61, 0x32, 0x38, 0x36, 0x35, 0x62, 0x34, 0x63, 0x35, 0x61, 0x36, 0x38, 0x37, 0x62, 0x37, 0x61, 0x65, 0x61, 0x33, 0x35, 0x39, 0x37, 0x65, 0x66, 0x36, 0x65, 0x35, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x30, 0x63, 0x39, 0x30, 0x32, 0x39, 0x35, 0x38, 0x66, 0x36, 0x34, 0x32, 0x31, 0x35, 0x39, 0x34, 0x64, 0x31, 0x62, 0x36, 0x64, 0x65, 0x64, 0x37, 0x31, 0x32, 0x34, 0x39, 0x30, 0x64, 0x35, 0x32, 0x65, 0x64, 0x36, 0x63, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x34, 0x34, 0x63, 0x61, 0x30, 0x39, 0x66, 0x30, 0x63, 0x36, 0x61, 0x38, 0x32, 0x39, 0x34, 0x63, 0x62, 0x64, 0x35, 0x31, 0x39, 0x63, 0x64, 0x63, 0x35, 0x39, 0x34, 0x61, 0x64, 0x34, 0x32, 0x63, 0x36, 0x37, 0x35, 0x37, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x31, 0x36, 0x66, 0x62, 0x34, 0x36, 0x63, 0x38, 0x31, 0x35, 0x37, 0x38, 0x63, 0x39, 0x63, 0x38, 0x65, 0x62, 0x34, 0x64, 0x33, 0x62, 0x66, 0x38, 0x38, 0x30, 0x34, 0x35, 0x31, 0x61, 0x38, 0x38, 0x33, 0x37, 0x39, 0x64, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x62, 0x63, 0x32, 0x30, 0x65, 0x32, 0x64, 0x36, 0x32, 0x62, 0x33, 0x64, 0x31, 0x39, 0x36, 0x36, 0x33, 0x63, 0x64, 0x62, 0x34, 0x63, 0x33, 0x30, 0x39, 0x64, 0x35, 0x62, 0x34, 0x66, 0x32, 0x66, 0x63, 0x32, 0x64, 0x62, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x65, 0x62, 0x66, 0x30, 0x39, 0x38, 0x35, 0x64, 0x37, 0x66, 0x36, 0x38, 0x30, 0x61, 0x61, 0x61, 0x39, 0x31, 0x35, 0x63, 0x34, 0x34, 0x63, 0x63, 0x36, 0x32, 0x65, 0x64, 0x62, 0x34, 0x39, 0x65, 0x61, 0x62, 0x32, 0x36, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x63, 0x62, 0x66, 0x36, 0x30, 0x33, 0x32, 0x66, 0x61, 0x33, 0x39, 0x65, 0x37, 0x63, 0x34, 0x36, 0x66, 0x66, 0x37, 0x37, 0x38, 0x61, 0x39, 0x34, 0x66, 0x37, 0x64, 0x34, 0x34, 0x35, 0x66, 0x65, 0x32, 0x32, 0x63, 0x66, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x38, 0x62, 0x39, 0x63, 0x63, 0x36, 0x31, 0x64, 0x65, 0x64, 0x62, 0x62, 0x39, 0x38, 0x63, 0x33, 0x33, 0x66, 0x32, 0x32, 0x34, 0x64, 0x32, 0x37, 0x31, 0x66, 0x30, 0x65, 0x32, 0x32, 0x38, 0x62, 0x35, 0x38, 0x33, 0x34, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x63, 0x36, 0x64, 0x66, 0x61, 0x65, 0x39, 0x37, 0x66, 0x37, 0x30, 0x39, 0x39, 0x66, 0x63, 0x35, 0x66, 0x34, 0x65, 0x39, 0x34, 0x62, 0x37, 0x38, 0x34, 0x64, 0x62, 0x38, 0x30, 0x32, 0x39, 0x32, 0x33, 0x61, 0x31, 0x34, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x61, 0x63, 0x64, 0x33, 0x64, 0x34, 0x30, 0x66, 0x33, 0x62, 0x38, 0x32, 0x61, 0x63, 0x39, 0x31, 0x61, 0x32, 0x36, 0x34, 0x64, 0x39, 0x64, 0x38, 0x38, 0x64, 0x39, 0x30, 0x38, 0x65, 0x61, 0x63, 0x38, 0x36, 0x36, 0x34, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x64, 0x38, 0x30, 0x30, 0x34, 0x38, 0x38, 0x37, 0x37, 0x35, 0x39, 0x36, 0x65, 0x30, 0x63, 0x32, 0x38, 0x34, 0x38, 0x39, 0x65, 0x36, 0x35, 0x30, 0x63, 0x64, 0x34, 0x61, 0x63, 0x31, 0x38, 0x30, 0x30, 0x39, 0x36, 0x61, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x61, 0x36, 0x66, 0x36, 0x64, 0x64, 0x36, 0x66, 0x37, 0x30, 0x61, 0x34, 0x35, 0x36, 0x66, 0x34, 0x65, 0x63, 0x31, 0x35, 0x65, 0x66, 0x37, 0x61, 0x64, 0x35, 0x65, 0x35, 0x64, 0x62, 0x62, 0x36, 0x38, 0x62, 0x64, 0x37, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x31, 0x38, 0x38, 0x37, 0x30, 0x62, 0x63, 0x32, 0x65, 0x34, 0x66, 0x61, 0x37, 0x62, 0x38, 0x61, 0x36, 0x31, 0x32, 0x31, 0x61, 0x65, 0x30, 0x38, 0x37, 0x32, 0x64, 0x35, 0x35, 0x32, 0x34, 0x37, 0x62, 0x36, 0x32, 0x35, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x66, 0x39, 0x33, 0x38, 0x33, 0x64, 0x35, 0x38, 0x31, 0x30, 0x65, 0x61, 0x37, 0x62, 0x34, 0x33, 0x31, 0x38, 0x32, 0x62, 0x38, 0x37, 0x30, 0x34, 0x62, 0x36, 0x32, 0x62, 0x32, 0x37, 0x66, 0x35, 0x39, 0x32, 0x35, 0x64, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x35, 0x65, 0x34, 0x37, 0x33, 0x61, 0x62, 0x63, 0x65, 0x38, 0x66, 0x39, 0x37, 0x61, 0x36, 0x39, 0x33, 0x32, 0x66, 0x37, 0x37, 0x63, 0x32, 0x66, 0x61, 0x63, 0x61, 0x66, 0x39, 0x63, 0x63, 0x30, 0x61, 0x30, 0x30, 0x35, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x37, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x66, 0x31, 0x63, 0x61, 0x35, 0x35, 0x66, 0x64, 0x39, 0x63, 0x65, 0x63, 0x31, 0x62, 0x31, 0x66, 0x65, 0x39, 0x66, 0x30, 0x61, 0x39, 0x61, 0x62, 0x62, 0x37, 0x34, 0x63, 0x35, 0x31, 0x33, 0x63, 0x31, 0x65, 0x32, 0x61, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x39, 0x39, 0x62, 0x31, 0x38, 0x39, 0x62, 0x62, 0x64, 0x39, 0x61, 0x34, 0x38, 0x66, 0x63, 0x32, 0x65, 0x31, 0x36, 0x65, 0x38, 0x66, 0x63, 0x64, 0x61, 0x33, 0x33, 0x62, 0x62, 0x39, 0x39, 0x61, 0x33, 0x31, 0x37, 0x62, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x39, 0x36, 0x66, 0x61, 0x65, 0x64, 0x61, 0x33, 0x30, 0x35, 0x34, 0x33, 0x30, 0x32, 0x63, 0x34, 0x35, 0x66, 0x35, 0x38, 0x66, 0x31, 0x36, 0x31, 0x33, 0x32, 0x34, 0x63, 0x39, 0x39, 0x61, 0x33, 0x65, 0x65, 0x62, 0x62, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x39, 0x33, 0x38, 0x31, 0x38, 0x66, 0x36, 0x38, 0x34, 0x64, 0x62, 0x30, 0x63, 0x33, 0x36, 0x37, 0x35, 0x65, 0x63, 0x38, 0x31, 0x33, 0x33, 0x32, 0x62, 0x33, 0x31, 0x38, 0x33, 0x65, 0x63, 0x63, 0x32, 0x38, 0x61, 0x34, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x35, 0x39, 0x66, 0x61, 0x63, 0x62, 0x31, 0x65, 0x38, 0x33, 0x34, 0x33, 0x36, 0x35, 0x35, 0x33, 0x62, 0x35, 0x62, 0x34, 0x32, 0x39, 0x38, 0x39, 0x61, 0x64, 0x62, 0x38, 0x30, 0x37, 0x35, 0x66, 0x39, 0x39, 0x35, 0x33, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x33, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x66, 0x66, 0x61, 0x64, 0x61, 0x61, 0x66, 0x32, 0x38, 0x32, 0x33, 0x66, 0x62, 0x65, 0x61, 0x37, 0x62, 0x66, 0x66, 0x37, 0x30, 0x32, 0x30, 0x32, 0x31, 0x62, 0x66, 0x66, 0x63, 0x34, 0x38, 0x35, 0x33, 0x65, 0x62, 0x35, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x32, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x38, 0x36, 0x34, 0x63, 0x31, 0x61, 0x66, 0x63, 0x38, 0x65, 0x61, 0x61, 0x64, 0x33, 0x37, 0x66, 0x33, 0x62, 0x61, 0x35, 0x36, 0x66, 0x63, 0x62, 0x37, 0x34, 0x37, 0x37, 0x63, 0x63, 0x36, 0x32, 0x32, 0x30, 0x30, 0x39, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x65, 0x66, 0x36, 0x64, 0x38, 0x62, 0x36, 0x61, 0x37, 0x63, 0x62, 0x66, 0x39, 0x62, 0x35, 0x63, 0x38, 0x63, 0x39, 0x37, 0x66, 0x36, 0x37, 0x65, 0x65, 0x32, 0x61, 0x64, 0x63, 0x32, 0x61, 0x37, 0x33, 0x62, 0x33, 0x66, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x34, 0x33, 0x66, 0x32, 0x34, 0x35, 0x32, 0x64, 0x63, 0x62, 0x39, 0x36, 0x30, 0x32, 0x65, 0x66, 0x36, 0x32, 0x62, 0x64, 0x33, 0x36, 0x30, 0x65, 0x30, 0x33, 0x33, 0x64, 0x64, 0x32, 0x33, 0x39, 0x37, 0x31, 0x66, 0x65, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x64, 0x64, 0x36, 0x35, 0x34, 0x30, 0x32, 0x33, 0x39, 0x35, 0x64, 0x66, 0x39, 0x62, 0x64, 0x31, 0x39, 0x66, 0x65, 0x65, 0x34, 0x35, 0x30, 0x37, 0x65, 0x66, 0x35, 0x33, 0x34, 0x35, 0x66, 0x37, 0x34, 0x35, 0x31, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x39, 0x63, 0x34, 0x33, 0x31, 0x33, 0x64, 0x32, 0x32, 0x38, 0x30, 0x65, 0x64, 0x66, 0x35, 0x65, 0x30, 0x37, 0x31, 0x62, 0x63, 0x65, 0x64, 0x38, 0x34, 0x36, 0x30, 0x36, 0x33, 0x66, 0x30, 0x61, 0x39, 0x37, 0x35, 0x64, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x38, 0x32, 0x34, 0x35, 0x30, 0x33, 0x37, 0x63, 0x62, 0x31, 0x39, 0x32, 0x66, 0x37, 0x35, 0x37, 0x38, 0x35, 0x63, 0x62, 0x38, 0x36, 0x63, 0x62, 0x66, 0x65, 0x37, 0x63, 0x39, 0x33, 0x30, 0x64, 0x61, 0x32, 0x35, 0x38, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x30, 0x63, 0x62, 0x31, 0x37, 0x33, 0x38, 0x62, 0x61, 0x63, 0x30, 0x38, 0x64, 0x34, 0x66, 0x39, 0x63, 0x30, 0x38, 0x62, 0x34, 0x64, 0x65, 0x66, 0x66, 0x35, 0x31, 0x35, 0x35, 0x34, 0x35, 0x66, 0x61, 0x38, 0x35, 0x38, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x39, 0x37, 0x31, 0x62, 0x66, 0x32, 0x36, 0x33, 0x34, 0x63, 0x65, 0x65, 0x30, 0x62, 0x65, 0x33, 0x63, 0x39, 0x38, 0x39, 0x30, 0x66, 0x35, 0x31, 0x61, 0x35, 0x36, 0x30, 0x39, 0x39, 0x64, 0x62, 0x62, 0x39, 0x35, 0x31, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x65, 0x66, 0x65, 0x39, 0x36, 0x35, 0x36, 0x30, 0x63, 0x39, 0x64, 0x39, 0x37, 0x62, 0x37, 0x32, 0x62, 0x64, 0x33, 0x36, 0x34, 0x34, 0x37, 0x38, 0x34, 0x33, 0x38, 0x38, 0x35, 0x63, 0x31, 0x64, 0x39, 0x30, 0x63, 0x32, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x33, 0x39, 0x30, 0x66, 0x34, 0x34, 0x30, 0x35, 0x33, 0x64, 0x64, 0x66, 0x63, 0x65, 0x66, 0x30, 0x64, 0x36, 0x30, 0x38, 0x62, 0x33, 0x35, 0x65, 0x34, 0x64, 0x39, 0x63, 0x32, 0x63, 0x62, 0x65, 0x39, 0x38, 0x37, 0x31, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x64, 0x31, 0x30, 0x31, 0x61, 0x30, 0x33, 0x33, 0x65, 0x65, 0x30, 0x65, 0x32, 0x65, 0x62, 0x62, 0x33, 0x31, 0x30, 0x30, 0x65, 0x64, 0x65, 0x37, 0x36, 0x36, 0x64, 0x66, 0x31, 0x61, 0x64, 0x30, 0x32, 0x34, 0x34, 0x39, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x38, 0x35, 0x35, 0x31, 0x33, 0x63, 0x66, 0x37, 0x33, 0x32, 0x65, 0x34, 0x37, 0x65, 0x38, 0x37, 0x36, 0x37, 0x30, 0x37, 0x37, 0x30, 0x62, 0x35, 0x34, 0x31, 0x39, 0x62, 0x65, 0x31, 0x30, 0x63, 0x64, 0x31, 0x66, 0x63, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x37, 0x36, 0x39, 0x39, 0x66, 0x34, 0x38, 0x61, 0x37, 0x38, 0x63, 0x36, 0x31, 0x35, 0x35, 0x31, 0x32, 0x35, 0x31, 0x35, 0x37, 0x33, 0x39, 0x39, 0x35, 0x38, 0x39, 0x39, 0x33, 0x33, 0x31, 0x32, 0x35, 0x37, 0x34, 0x66, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x65, 0x63, 0x37, 0x39, 0x64, 0x35, 0x62, 0x65, 0x37, 0x31, 0x35, 0x35, 0x37, 0x31, 0x36, 0x63, 0x34, 0x30, 0x39, 0x34, 0x31, 0x63, 0x37, 0x39, 0x64, 0x37, 0x38, 0x64, 0x31, 0x37, 0x64, 0x65, 0x39, 0x65, 0x66, 0x38, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x65, 0x38, 0x62, 0x61, 0x36, 0x36, 0x31, 0x62, 0x34, 0x38, 0x31, 0x35, 0x34, 0x63, 0x66, 0x38, 0x34, 0x33, 0x64, 0x34, 0x63, 0x32, 0x61, 0x35, 0x63, 0x30, 0x66, 0x37, 0x39, 0x32, 0x64, 0x35, 0x32, 0x38, 0x65, 0x65, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x32, 0x30, 0x31, 0x62, 0x34, 0x33, 0x32, 0x37, 0x63, 0x65, 0x61, 0x37, 0x66, 0x33, 0x39, 0x39, 0x30, 0x34, 0x36, 0x32, 0x34, 0x36, 0x61, 0x33, 0x63, 0x38, 0x37, 0x65, 0x36, 0x65, 0x30, 0x33, 0x61, 0x33, 0x63, 0x64, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x30, 0x66, 0x36, 0x32, 0x64, 0x37, 0x33, 0x39, 0x33, 0x37, 0x39, 0x35, 0x33, 0x66, 0x65, 0x66, 0x33, 0x35, 0x31, 0x36, 0x39, 0x65, 0x31, 0x31, 0x64, 0x38, 0x37, 0x32, 0x64, 0x32, 0x65, 0x61, 0x33, 0x31, 0x37, 0x65, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x63, 0x30, 0x34, 0x64, 0x30, 0x31, 0x30, 0x36, 0x38, 0x31, 0x30, 0x65, 0x33, 0x65, 0x63, 0x30, 0x65, 0x35, 0x34, 0x61, 0x31, 0x39, 0x66, 0x32, 0x61, 0x62, 0x38, 0x35, 0x39, 0x37, 0x65, 0x36, 0x39, 0x61, 0x35, 0x37, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x34, 0x37, 0x63, 0x66, 0x30, 0x37, 0x33, 0x65, 0x33, 0x36, 0x66, 0x32, 0x37, 0x31, 0x64, 0x35, 0x32, 0x32, 0x64, 0x37, 0x66, 0x61, 0x34, 0x65, 0x37, 0x31, 0x32, 0x30, 0x61, 0x64, 0x35, 0x30, 0x30, 0x37, 0x61, 0x30, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x34, 0x66, 0x65, 0x38, 0x30, 0x30, 0x64, 0x39, 0x36, 0x66, 0x63, 0x61, 0x64, 0x37, 0x33, 0x62, 0x37, 0x31, 0x37, 0x30, 0x64, 0x30, 0x66, 0x36, 0x31, 0x30, 0x63, 0x62, 0x38, 0x63, 0x30, 0x36, 0x38, 0x32, 0x64, 0x36, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x30, 0x66, 0x34, 0x61, 0x39, 0x38, 0x64, 0x66, 0x61, 0x31, 0x64, 0x39, 0x37, 0x39, 0x39, 0x62, 0x66, 0x35, 0x63, 0x37, 0x39, 0x36, 0x66, 0x62, 0x35, 0x35, 0x30, 0x65, 0x66, 0x62, 0x65, 0x37, 0x65, 0x63, 0x64, 0x38, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x33, 0x33, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x38, 0x66, 0x61, 0x31, 0x31, 0x66, 0x65, 0x33, 0x33, 0x64, 0x38, 0x35, 0x61, 0x64, 0x31, 0x62, 0x65, 0x66, 0x63, 0x62, 0x61, 0x65, 0x33, 0x38, 0x31, 0x38, 0x61, 0x63, 0x62, 0x37, 0x31, 0x66, 0x36, 0x61, 0x37, 0x64, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x38, 0x63, 0x34, 0x65, 0x35, 0x33, 0x37, 0x62, 0x35, 0x64, 0x66, 0x39, 0x33, 0x30, 0x64, 0x36, 0x35, 0x61, 0x37, 0x34, 0x64, 0x30, 0x34, 0x33, 0x38, 0x33, 0x31, 0x64, 0x36, 0x62, 0x34, 0x38, 0x35, 0x62, 0x62, 0x64, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x30, 0x61, 0x36, 0x39, 0x34, 0x33, 0x30, 0x37, 0x37, 0x36, 0x66, 0x36, 0x33, 0x34, 0x37, 0x37, 0x30, 0x33, 0x66, 0x39, 0x35, 0x32, 0x39, 0x37, 0x38, 0x33, 0x39, 0x35, 0x35, 0x61, 0x36, 0x31, 0x39, 0x37, 0x62, 0x36, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x33, 0x35, 0x61, 0x39, 0x64, 0x66, 0x36, 0x32, 0x37, 0x35, 0x37, 0x66, 0x37, 0x66, 0x66, 0x61, 0x64, 0x31, 0x30, 0x34, 0x39, 0x61, 0x66, 0x62, 0x30, 0x36, 0x63, 0x61, 0x34, 0x61, 0x66, 0x63, 0x34, 0x36, 0x34, 0x63, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x66, 0x66, 0x31, 0x34, 0x36, 0x36, 0x63, 0x32, 0x36, 0x32, 0x33, 0x36, 0x37, 0x35, 0x65, 0x33, 0x63, 0x62, 0x30, 0x65, 0x37, 0x35, 0x65, 0x34, 0x32, 0x33, 0x64, 0x33, 0x37, 0x61, 0x32, 0x35, 0x65, 0x34, 0x34, 0x32, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x31, 0x35, 0x63, 0x62, 0x39, 0x39, 0x61, 0x38, 0x64, 0x31, 0x30, 0x33, 0x30, 0x62, 0x31, 0x32, 0x37, 0x37, 0x30, 0x61, 0x64, 0x64, 0x30, 0x33, 0x33, 0x61, 0x37, 0x39, 0x65, 0x65, 0x30, 0x64, 0x30, 0x63, 0x39, 0x30, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x38, 0x34, 0x64, 0x63, 0x63, 0x38, 0x37, 0x33, 0x61, 0x61, 0x38, 0x63, 0x31, 0x35, 0x31, 0x33, 0x65, 0x63, 0x32, 0x36, 0x66, 0x66, 0x33, 0x36, 0x62, 0x63, 0x39, 0x32, 0x65, 0x61, 0x63, 0x36, 0x64, 0x34, 0x63, 0x39, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x63, 0x33, 0x32, 0x38, 0x66, 0x62, 0x39, 0x38, 0x66, 0x32, 0x66, 0x31, 0x39, 0x61, 0x62, 0x36, 0x36, 0x34, 0x36, 0x66, 0x30, 0x61, 0x37, 0x63, 0x38, 0x63, 0x35, 0x36, 0x36, 0x66, 0x64, 0x61, 0x35, 0x61, 0x38, 0x35, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x37, 0x61, 0x30, 0x61, 0x31, 0x31, 0x63, 0x35, 0x37, 0x66, 0x30, 0x33, 0x38, 0x33, 0x62, 0x39, 0x34, 0x39, 0x64, 0x65, 0x35, 0x34, 0x30, 0x62, 0x36, 0x36, 0x64, 0x65, 0x65, 0x36, 0x38, 0x36, 0x30, 0x34, 0x62, 0x30, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x66, 0x36, 0x30, 0x33, 0x34, 0x33, 0x33, 0x36, 0x30, 0x65, 0x30, 0x62, 0x32, 0x64, 0x37, 0x35, 0x32, 0x35, 0x35, 0x32, 0x31, 0x30, 0x33, 0x37, 0x35, 0x37, 0x32, 0x30, 0x64, 0x66, 0x32, 0x31, 0x64, 0x62, 0x35, 0x63, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x39, 0x34, 0x62, 0x66, 0x34, 0x37, 0x64, 0x35, 0x34, 0x35, 0x34, 0x30, 0x65, 0x63, 0x65, 0x35, 0x63, 0x37, 0x32, 0x32, 0x33, 0x37, 0x61, 0x31, 0x66, 0x66, 0x62, 0x35, 0x31, 0x31, 0x64, 0x64, 0x62, 0x37, 0x34, 0x37, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x36, 0x64, 0x39, 0x34, 0x35, 0x61, 0x61, 0x38, 0x39, 0x64, 0x66, 0x31, 0x65, 0x34, 0x35, 0x37, 0x61, 0x61, 0x33, 0x34, 0x32, 0x62, 0x33, 0x31, 0x30, 0x32, 0x38, 0x61, 0x35, 0x65, 0x39, 0x31, 0x33, 0x30, 0x62, 0x32, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x30, 0x65, 0x30, 0x61, 0x63, 0x62, 0x35, 0x33, 0x34, 0x63, 0x39, 0x62, 0x33, 0x30, 0x38, 0x34, 0x65, 0x38, 0x35, 0x30, 0x31, 0x64, 0x61, 0x30, 0x39, 0x30, 0x62, 0x34, 0x65, 0x62, 0x31, 0x36, 0x61, 0x32, 0x63, 0x30, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x39, 0x39, 0x64, 0x31, 0x32, 0x66, 0x36, 0x65, 0x63, 0x36, 0x35, 0x36, 0x38, 0x39, 0x39, 0x62, 0x30, 0x34, 0x39, 0x61, 0x37, 0x36, 0x35, 0x37, 0x30, 0x36, 0x35, 0x64, 0x36, 0x32, 0x39, 0x39, 0x36, 0x38, 0x39, 0x32, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x65, 0x37, 0x66, 0x32, 0x34, 0x35, 0x36, 0x39, 0x37, 0x31, 0x38, 0x38, 0x33, 0x62, 0x39, 0x61, 0x38, 0x64, 0x62, 0x65, 0x34, 0x63, 0x39, 0x31, 0x64, 0x65, 0x63, 0x30, 0x38, 0x61, 0x63, 0x33, 0x34, 0x65, 0x38, 0x38, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x37, 0x34, 0x36, 0x61, 0x65, 0x65, 0x61, 0x31, 0x34, 0x66, 0x32, 0x37, 0x62, 0x65, 0x66, 0x66, 0x30, 0x63, 0x30, 0x64, 0x61, 0x36, 0x34, 0x32, 0x35, 0x33, 0x66, 0x31, 0x65, 0x37, 0x39, 0x37, 0x31, 0x38, 0x39, 0x30, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x36, 0x62, 0x34, 0x34, 0x35, 0x30, 0x33, 0x64, 0x64, 0x32, 0x66, 0x36, 0x64, 0x64, 0x35, 0x34, 0x36, 0x39, 0x66, 0x66, 0x34, 0x63, 0x35, 0x62, 0x32, 0x64, 0x62, 0x38, 0x65, 0x61, 0x34, 0x66, 0x65, 0x63, 0x36, 0x35, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x33, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x32, 0x65, 0x64, 0x66, 0x66, 0x36, 0x33, 0x36, 0x35, 0x36, 0x33, 0x61, 0x36, 0x31, 0x30, 0x36, 0x65, 0x35, 0x32, 0x65, 0x39, 0x61, 0x32, 0x35, 0x39, 0x38, 0x66, 0x37, 0x65, 0x36, 0x64, 0x30, 0x65, 0x66, 0x32, 0x37, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x63, 0x36, 0x34, 0x37, 0x61, 0x39, 0x66, 0x39, 0x32, 0x39, 0x62, 0x30, 0x37, 0x38, 0x31, 0x66, 0x65, 0x39, 0x61, 0x65, 0x30, 0x31, 0x63, 0x61, 0x61, 0x33, 0x65, 0x31, 0x38, 0x33, 0x65, 0x38, 0x37, 0x36, 0x37, 0x37, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x36, 0x31, 0x32, 0x65, 0x37, 0x38, 0x36, 0x32, 0x63, 0x32, 0x37, 0x62, 0x35, 0x38, 0x37, 0x63, 0x66, 0x62, 0x36, 0x64, 0x61, 0x66, 0x39, 0x39, 0x31, 0x32, 0x63, 0x62, 0x30, 0x35, 0x31, 0x66, 0x30, 0x33, 0x30, 0x61, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x34, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x36, 0x62, 0x61, 0x65, 0x36, 0x31, 0x62, 0x30, 0x32, 0x37, 0x65, 0x35, 0x62, 0x62, 0x34, 0x32, 0x32, 0x65, 0x38, 0x33, 0x61, 0x33, 0x66, 0x39, 0x63, 0x39, 0x33, 0x66, 0x33, 0x63, 0x38, 0x66, 0x63, 0x37, 0x37, 0x64, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x32, 0x33, 0x62, 0x61, 0x31, 0x66, 0x33, 0x37, 0x61, 0x39, 0x36, 0x63, 0x34, 0x35, 0x62, 0x63, 0x34, 0x39, 0x30, 0x32, 0x35, 0x39, 0x35, 0x33, 0x38, 0x61, 0x35, 0x34, 0x63, 0x32, 0x38, 0x62, 0x61, 0x33, 0x62, 0x30, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x31, 0x64, 0x37, 0x66, 0x62, 0x34, 0x39, 0x66, 0x65, 0x37, 0x30, 0x31, 0x62, 0x61, 0x61, 0x63, 0x32, 0x35, 0x37, 0x31, 0x37, 0x30, 0x34, 0x32, 0x36, 0x63, 0x63, 0x39, 0x62, 0x33, 0x38, 0x63, 0x61, 0x33, 0x61, 0x39, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x62, 0x61, 0x63, 0x62, 0x37, 0x38, 0x34, 0x34, 0x66, 0x64, 0x63, 0x33, 0x32, 0x32, 0x66, 0x38, 0x30, 0x35, 0x39, 0x30, 0x34, 0x66, 0x62, 0x66, 0x31, 0x39, 0x36, 0x32, 0x38, 0x30, 0x32, 0x64, 0x62, 0x31, 0x35, 0x33, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x38, 0x30, 0x62, 0x63, 0x31, 0x38, 0x65, 0x39, 0x66, 0x38, 0x64, 0x34, 0x39, 0x36, 0x38, 0x62, 0x31, 0x38, 0x35, 0x64, 0x61, 0x38, 0x63, 0x37, 0x39, 0x66, 0x61, 0x36, 0x65, 0x31, 0x31, 0x66, 0x66, 0x63, 0x33, 0x65, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x63, 0x61, 0x30, 0x61, 0x35, 0x32, 0x33, 0x38, 0x35, 0x36, 0x34, 0x64, 0x66, 0x63, 0x39, 0x31, 0x65, 0x38, 0x62, 0x66, 0x32, 0x32, 0x62, 0x61, 0x64, 0x65, 0x32, 0x39, 0x30, 0x31, 0x36, 0x31, 0x39, 0x61, 0x31, 0x63, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x64, 0x37, 0x32, 0x64, 0x32, 0x30, 0x61, 0x37, 0x36, 0x65, 0x37, 0x66, 0x63, 0x63, 0x36, 0x62, 0x37, 0x36, 0x34, 0x30, 0x35, 0x38, 0x66, 0x34, 0x38, 0x64, 0x34, 0x31, 0x37, 0x64, 0x34, 0x39, 0x36, 0x66, 0x61, 0x36, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x62, 0x63, 0x37, 0x33, 0x30, 0x39, 0x33, 0x37, 0x66, 0x61, 0x37, 0x35, 0x64, 0x38, 0x34, 0x35, 0x32, 0x36, 0x31, 0x36, 0x61, 0x64, 0x31, 0x65, 0x66, 0x31, 0x66, 0x65, 0x37, 0x66, 0x66, 0x66, 0x65, 0x30, 0x64, 0x30, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x33, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x63, 0x31, 0x34, 0x38, 0x32, 0x38, 0x32, 0x36, 0x61, 0x63, 0x62, 0x36, 0x31, 0x31, 0x31, 0x65, 0x31, 0x39, 0x64, 0x33, 0x34, 0x30, 0x61, 0x34, 0x35, 0x66, 0x62, 0x38, 0x35, 0x31, 0x35, 0x37, 0x36, 0x62, 0x65, 0x64, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x31, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x65, 0x34, 0x30, 0x35, 0x32, 0x31, 0x31, 0x32, 0x32, 0x35, 0x33, 0x30, 0x64, 0x39, 0x61, 0x63, 0x39, 0x31, 0x31, 0x31, 0x33, 0x63, 0x30, 0x36, 0x61, 0x30, 0x31, 0x39, 0x30, 0x62, 0x36, 0x64, 0x36, 0x33, 0x38, 0x35, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x32, 0x30, 0x65, 0x35, 0x66, 0x64, 0x33, 0x36, 0x31, 0x65, 0x61, 0x62, 0x63, 0x66, 0x36, 0x33, 0x38, 0x39, 0x31, 0x66, 0x35, 0x62, 0x38, 0x37, 0x62, 0x30, 0x39, 0x32, 0x36, 0x38, 0x62, 0x38, 0x65, 0x62, 0x33, 0x37, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x66, 0x66, 0x34, 0x32, 0x39, 0x30, 0x37, 0x34, 0x63, 0x62, 0x39, 0x62, 0x36, 0x63, 0x36, 0x33, 0x62, 0x63, 0x39, 0x31, 0x34, 0x32, 0x38, 0x34, 0x62, 0x63, 0x65, 0x35, 0x66, 0x30, 0x63, 0x38, 0x66, 0x62, 0x66, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x33, 0x32, 0x36, 0x35, 0x64, 0x33, 0x65, 0x37, 0x62, 0x64, 0x62, 0x39, 0x33, 0x64, 0x35, 0x65, 0x38, 0x65, 0x38, 0x62, 0x31, 0x63, 0x61, 0x34, 0x37, 0x66, 0x32, 0x31, 0x30, 0x61, 0x37, 0x39, 0x33, 0x65, 0x63, 0x63, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x34, 0x65, 0x61, 0x31, 0x36, 0x64, 0x62, 0x36, 0x38, 0x30, 0x39, 0x62, 0x30, 0x33, 0x35, 0x32, 0x64, 0x34, 0x62, 0x36, 0x65, 0x38, 0x31, 0x63, 0x33, 0x39, 0x31, 0x33, 0x66, 0x37, 0x36, 0x61, 0x35, 0x31, 0x62, 0x62, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x66, 0x65, 0x30, 0x38, 0x38, 0x66, 0x66, 0x66, 0x63, 0x65, 0x39, 0x34, 0x38, 0x66, 0x35, 0x31, 0x33, 0x37, 0x65, 0x65, 0x32, 0x33, 0x62, 0x30, 0x31, 0x64, 0x39, 0x35, 0x39, 0x65, 0x38, 0x34, 0x61, 0x63, 0x34, 0x32, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x37, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x34, 0x65, 0x39, 0x34, 0x30, 0x39, 0x37, 0x30, 0x34, 0x31, 0x32, 0x31, 0x64, 0x31, 0x64, 0x37, 0x37, 0x39, 0x39, 0x37, 0x30, 0x32, 0x36, 0x66, 0x66, 0x30, 0x36, 0x65, 0x61, 0x39, 0x62, 0x31, 0x39, 0x61, 0x38, 0x62, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x62, 0x34, 0x33, 0x34, 0x66, 0x65, 0x30, 0x36, 0x35, 0x37, 0x65, 0x34, 0x32, 0x61, 0x63, 0x63, 0x38, 0x32, 0x31, 0x32, 0x62, 0x36, 0x38, 0x36, 0x35, 0x31, 0x33, 0x39, 0x64, 0x65, 0x64, 0x65, 0x31, 0x35, 0x39, 0x37, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x66, 0x30, 0x30, 0x34, 0x64, 0x66, 0x38, 0x64, 0x65, 0x39, 0x65, 0x36, 0x65, 0x62, 0x66, 0x35, 0x32, 0x33, 0x63, 0x63, 0x61, 0x63, 0x65, 0x34, 0x35, 0x37, 0x61, 0x63, 0x63, 0x62, 0x32, 0x36, 0x66, 0x39, 0x37, 0x32, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x66, 0x39, 0x32, 0x34, 0x30, 0x63, 0x35, 0x35, 0x63, 0x66, 0x66, 0x30, 0x33, 0x35, 0x35, 0x32, 0x33, 0x63, 0x36, 0x64, 0x35, 0x62, 0x64, 0x33, 0x30, 0x30, 0x64, 0x33, 0x37, 0x30, 0x64, 0x63, 0x38, 0x66, 0x30, 0x63, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x39, 0x65, 0x35, 0x37, 0x66, 0x64, 0x65, 0x33, 0x30, 0x65, 0x35, 0x30, 0x36, 0x38, 0x63, 0x30, 0x33, 0x65, 0x34, 0x39, 0x38, 0x34, 0x38, 0x65, 0x64, 0x63, 0x65, 0x33, 0x34, 0x33, 0x62, 0x37, 0x30, 0x32, 0x38, 0x33, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x37, 0x63, 0x66, 0x34, 0x61, 0x32, 0x33, 0x63, 0x62, 0x31, 0x39, 0x31, 0x63, 0x64, 0x63, 0x35, 0x36, 0x33, 0x31, 0x32, 0x63, 0x32, 0x39, 0x64, 0x31, 0x35, 0x65, 0x32, 0x31, 0x30, 0x62, 0x33, 0x62, 0x39, 0x62, 0x37, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x66, 0x30, 0x38, 0x65, 0x30, 0x31, 0x63, 0x65, 0x30, 0x39, 0x38, 0x38, 0x65, 0x36, 0x33, 0x63, 0x37, 0x66, 0x38, 0x66, 0x32, 0x39, 0x30, 0x38, 0x66, 0x61, 0x64, 0x65, 0x34, 0x33, 0x63, 0x37, 0x66, 0x39, 0x66, 0x35, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x65, 0x35, 0x66, 0x35, 0x62, 0x63, 0x37, 0x63, 0x39, 0x32, 0x33, 0x66, 0x64, 0x31, 0x65, 0x33, 0x31, 0x37, 0x33, 0x35, 0x65, 0x37, 0x32, 0x65, 0x66, 0x39, 0x36, 0x38, 0x66, 0x64, 0x36, 0x37, 0x31, 0x31, 0x30, 0x63, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x63, 0x34, 0x65, 0x63, 0x34, 0x62, 0x37, 0x37, 0x62, 0x66, 0x31, 0x39, 0x64, 0x30, 0x39, 0x31, 0x61, 0x38, 0x36, 0x38, 0x65, 0x36, 0x66, 0x34, 0x39, 0x31, 0x35, 0x34, 0x31, 0x38, 0x30, 0x35, 0x34, 0x31, 0x66, 0x39, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x33, 0x37, 0x64, 0x61, 0x65, 0x36, 0x37, 0x31, 0x38, 0x32, 0x33, 0x61, 0x38, 0x64, 0x35, 0x39, 0x31, 0x37, 0x65, 0x30, 0x31, 0x35, 0x37, 0x61, 0x63, 0x65, 0x39, 0x63, 0x34, 0x33, 0x34, 0x36, 0x38, 0x64, 0x39, 0x34, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x39, 0x38, 0x63, 0x61, 0x33, 0x34, 0x31, 0x31, 0x37, 0x33, 0x30, 0x61, 0x36, 0x63, 0x64, 0x31, 0x30, 0x65, 0x37, 0x34, 0x35, 0x35, 0x62, 0x30, 0x34, 0x31, 0x30, 0x66, 0x62, 0x30, 0x66, 0x36, 0x64, 0x33, 0x66, 0x66, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x32, 0x65, 0x61, 0x62, 0x38, 0x35, 0x64, 0x63, 0x38, 0x39, 0x66, 0x65, 0x32, 0x39, 0x64, 0x63, 0x30, 0x61, 0x61, 0x31, 0x38, 0x35, 0x33, 0x32, 0x34, 0x37, 0x64, 0x61, 0x62, 0x34, 0x33, 0x61, 0x35, 0x32, 0x33, 0x64, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x63, 0x30, 0x38, 0x33, 0x62, 0x65, 0x61, 0x64, 0x62, 0x64, 0x63, 0x32, 0x32, 0x37, 0x63, 0x35, 0x66, 0x62, 0x34, 0x33, 0x38, 0x38, 0x31, 0x35, 0x39, 0x37, 0x65, 0x33, 0x32, 0x65, 0x38, 0x33, 0x63, 0x32, 0x36, 0x30, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x30, 0x32, 0x65, 0x34, 0x34, 0x61, 0x66, 0x37, 0x36, 0x39, 0x61, 0x38, 0x37, 0x32, 0x34, 0x36, 0x61, 0x32, 0x31, 0x65, 0x30, 0x37, 0x39, 0x63, 0x30, 0x38, 0x62, 0x66, 0x33, 0x36, 0x62, 0x30, 0x36, 0x65, 0x66, 0x65, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x32, 0x64, 0x30, 0x34, 0x66, 0x30, 0x61, 0x34, 0x30, 0x31, 0x37, 0x31, 0x38, 0x39, 0x62, 0x33, 0x34, 0x30, 0x63, 0x61, 0x37, 0x37, 0x31, 0x39, 0x38, 0x36, 0x34, 0x31, 0x64, 0x63, 0x66, 0x36, 0x34, 0x35, 0x36, 0x62, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x65, 0x34, 0x63, 0x37, 0x33, 0x66, 0x39, 0x36, 0x39, 0x62, 0x38, 0x39, 0x65, 0x39, 0x63, 0x65, 0x61, 0x65, 0x36, 0x36, 0x61, 0x32, 0x62, 0x35, 0x31, 0x38, 0x34, 0x34, 0x34, 0x38, 0x30, 0x65, 0x30, 0x33, 0x38, 0x65, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x66, 0x66, 0x30, 0x64, 0x31, 0x64, 0x30, 0x62, 0x39, 0x37, 0x34, 0x37, 0x31, 0x65, 0x37, 0x36, 0x64, 0x37, 0x38, 0x39, 0x64, 0x32, 0x65, 0x34, 0x39, 0x63, 0x38, 0x61, 0x37, 0x34, 0x66, 0x39, 0x62, 0x64, 0x35, 0x34, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x37, 0x63, 0x64, 0x62, 0x38, 0x63, 0x38, 0x30, 0x63, 0x36, 0x37, 0x39, 0x35, 0x30, 0x62, 0x31, 0x38, 0x64, 0x36, 0x35, 0x34, 0x32, 0x32, 0x39, 0x36, 0x31, 0x30, 0x65, 0x39, 0x33, 0x62, 0x66, 0x61, 0x36, 0x65, 0x65, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x37, 0x32, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x65, 0x30, 0x35, 0x31, 0x66, 0x62, 0x37, 0x34, 0x34, 0x61, 0x61, 0x33, 0x34, 0x31, 0x30, 0x63, 0x33, 0x62, 0x38, 0x38, 0x66, 0x38, 0x39, 0x39, 0x66, 0x35, 0x64, 0x35, 0x37, 0x66, 0x31, 0x36, 0x38, 0x64, 0x66, 0x31, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x30, 0x64, 0x62, 0x32, 0x35, 0x36, 0x37, 0x35, 0x66, 0x34, 0x35, 0x65, 0x61, 0x34, 0x63, 0x37, 0x66, 0x33, 0x31, 0x37, 0x37, 0x66, 0x33, 0x37, 0x63, 0x65, 0x32, 0x39, 0x65, 0x32, 0x32, 0x64, 0x36, 0x37, 0x39, 0x39, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x31, 0x33, 0x65, 0x63, 0x35, 0x31, 0x31, 0x34, 0x32, 0x63, 0x65, 0x62, 0x62, 0x37, 0x61, 0x32, 0x36, 0x30, 0x38, 0x33, 0x34, 0x31, 0x32, 0x63, 0x33, 0x63, 0x65, 0x33, 0x35, 0x31, 0x34, 0x34, 0x62, 0x61, 0x35, 0x36, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x62, 0x64, 0x66, 0x61, 0x33, 0x65, 0x65, 0x32, 0x36, 0x66, 0x33, 0x38, 0x34, 0x39, 0x36, 0x31, 0x37, 0x62, 0x32, 0x33, 0x30, 0x30, 0x36, 0x32, 0x35, 0x38, 0x38, 0x61, 0x39, 0x37, 0x65, 0x33, 0x63, 0x61, 0x65, 0x37, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x35, 0x33, 0x38, 0x63, 0x37, 0x33, 0x63, 0x35, 0x62, 0x33, 0x38, 0x64, 0x38, 0x64, 0x35, 0x38, 0x34, 0x64, 0x37, 0x65, 0x62, 0x64, 0x61, 0x64, 0x65, 0x66, 0x62, 0x31, 0x35, 0x63, 0x61, 0x62, 0x65, 0x34, 0x38, 0x33, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x65, 0x63, 0x63, 0x65, 0x32, 0x63, 0x34, 0x39, 0x66, 0x37, 0x32, 0x61, 0x30, 0x39, 0x39, 0x35, 0x61, 0x30, 0x62, 0x64, 0x61, 0x35, 0x37, 0x61, 0x61, 0x63, 0x66, 0x31, 0x65, 0x39, 0x66, 0x30, 0x30, 0x31, 0x65, 0x32, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x32, 0x34, 0x66, 0x62, 0x64, 0x61, 0x64, 0x32, 0x39, 0x30, 0x31, 0x37, 0x35, 0x65, 0x62, 0x32, 0x64, 0x66, 0x36, 0x64, 0x31, 0x38, 0x30, 0x61, 0x31, 0x39, 0x62, 0x39, 0x61, 0x39, 0x66, 0x34, 0x31, 0x33, 0x37, 0x30, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x63, 0x63, 0x34, 0x33, 0x62, 0x63, 0x34, 0x66, 0x38, 0x61, 0x63, 0x66, 0x33, 0x39, 0x62, 0x66, 0x66, 0x30, 0x34, 0x65, 0x62, 0x66, 0x62, 0x66, 0x34, 0x32, 0x61, 0x61, 0x63, 0x30, 0x36, 0x61, 0x33, 0x32, 0x38, 0x34, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x37, 0x37, 0x39, 0x37, 0x37, 0x31, 0x66, 0x30, 0x35, 0x33, 0x36, 0x64, 0x37, 0x39, 0x61, 0x38, 0x37, 0x30, 0x38, 0x66, 0x36, 0x39, 0x33, 0x31, 0x61, 0x62, 0x63, 0x34, 0x34, 0x62, 0x33, 0x30, 0x33, 0x35, 0x65, 0x39, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x32, 0x37, 0x62, 0x61, 0x37, 0x38, 0x63, 0x38, 0x65, 0x35, 0x65, 0x33, 0x64, 0x61, 0x65, 0x66, 0x33, 0x31, 0x61, 0x64, 0x30, 0x35, 0x61, 0x65, 0x66, 0x30, 0x66, 0x66, 0x30, 0x33, 0x32, 0x35, 0x37, 0x32, 0x31, 0x65, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x33, 0x63, 0x62, 0x38, 0x38, 0x30, 0x33, 0x63, 0x31, 0x64, 0x33, 0x32, 0x61, 0x32, 0x35, 0x62, 0x32, 0x37, 0x62, 0x36, 0x34, 0x31, 0x31, 0x34, 0x38, 0x35, 0x32, 0x62, 0x64, 0x30, 0x34, 0x64, 0x39, 0x63, 0x32, 0x30, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x64, 0x34, 0x32, 0x36, 0x37, 0x66, 0x65, 0x62, 0x31, 0x35, 0x64, 0x61, 0x39, 0x37, 0x30, 0x30, 0x66, 0x37, 0x63, 0x63, 0x63, 0x33, 0x63, 0x38, 0x34, 0x61, 0x38, 0x39, 0x31, 0x38, 0x62, 0x66, 0x31, 0x37, 0x63, 0x66, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x37, 0x37, 0x38, 0x63, 0x31, 0x33, 0x66, 0x62, 0x64, 0x39, 0x36, 0x38, 0x62, 0x63, 0x30, 0x38, 0x33, 0x63, 0x62, 0x37, 0x64, 0x31, 0x30, 0x32, 0x34, 0x66, 0x66, 0x65, 0x31, 0x66, 0x34, 0x39, 0x64, 0x30, 0x32, 0x63, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x39, 0x36, 0x62, 0x63, 0x63, 0x39, 0x37, 0x62, 0x38, 0x61, 0x62, 0x63, 0x37, 0x31, 0x37, 0x66, 0x34, 0x62, 0x34, 0x61, 0x37, 0x63, 0x36, 0x62, 0x31, 0x30, 0x33, 0x36, 0x65, 0x61, 0x32, 0x31, 0x38, 0x32, 0x36, 0x33, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x35, 0x32, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x65, 0x63, 0x64, 0x36, 0x61, 0x66, 0x39, 0x30, 0x30, 0x63, 0x38, 0x62, 0x30, 0x36, 0x34, 0x61, 0x66, 0x63, 0x63, 0x36, 0x30, 0x37, 0x33, 0x66, 0x32, 0x64, 0x38, 0x35, 0x64, 0x35, 0x39, 0x61, 0x66, 0x31, 0x31, 0x39, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x35, 0x65, 0x64, 0x37, 0x66, 0x36, 0x64, 0x39, 0x65, 0x65, 0x39, 0x66, 0x32, 0x35, 0x32, 0x65, 0x30, 0x37, 0x33, 0x32, 0x36, 0x38, 0x64, 0x62, 0x30, 0x32, 0x32, 0x63, 0x36, 0x33, 0x32, 0x36, 0x61, 0x64, 0x66, 0x63, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x38, 0x61, 0x33, 0x37, 0x63, 0x32, 0x37, 0x66, 0x37, 0x38, 0x61, 0x36, 0x31, 0x37, 0x64, 0x35, 0x63, 0x30, 0x39, 0x31, 0x62, 0x37, 0x64, 0x35, 0x62, 0x37, 0x33, 0x61, 0x33, 0x37, 0x36, 0x31, 0x65, 0x36, 0x35, 0x66, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x66, 0x62, 0x34, 0x39, 0x63, 0x32, 0x39, 0x64, 0x32, 0x33, 0x61, 0x31, 0x38, 0x39, 0x35, 0x30, 0x63, 0x34, 0x62, 0x32, 0x64, 0x63, 0x30, 0x64, 0x64, 0x66, 0x34, 0x31, 0x30, 0x66, 0x35, 0x33, 0x32, 0x64, 0x36, 0x66, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x63, 0x61, 0x65, 0x66, 0x61, 0x36, 0x66, 0x63, 0x33, 0x65, 0x65, 0x35, 0x33, 0x34, 0x36, 0x32, 0x36, 0x64, 0x62, 0x30, 0x32, 0x63, 0x36, 0x66, 0x38, 0x35, 0x61, 0x30, 0x63, 0x33, 0x39, 0x35, 0x35, 0x37, 0x31, 0x65, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x38, 0x31, 0x31, 0x63, 0x35, 0x35, 0x39, 0x37, 0x36, 0x39, 0x38, 0x30, 0x66, 0x30, 0x38, 0x33, 0x39, 0x30, 0x31, 0x64, 0x38, 0x61, 0x30, 0x64, 0x62, 0x32, 0x36, 0x39, 0x32, 0x32, 0x32, 0x64, 0x66, 0x62, 0x35, 0x63, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x38, 0x35, 0x35, 0x63, 0x37, 0x64, 0x66, 0x62, 0x65, 0x65, 0x33, 0x33, 0x35, 0x33, 0x34, 0x34, 0x39, 0x30, 0x34, 0x61, 0x31, 0x32, 0x63, 0x34, 0x30, 0x63, 0x37, 0x33, 0x31, 0x37, 0x39, 0x35, 0x62, 0x31, 0x33, 0x61, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x61, 0x38, 0x39, 0x38, 0x64, 0x34, 0x36, 0x66, 0x31, 0x39, 0x37, 0x31, 0x39, 0x63, 0x33, 0x38, 0x31, 0x32, 0x36, 0x61, 0x38, 0x61, 0x33, 0x63, 0x32, 0x37, 0x38, 0x36, 0x37, 0x61, 0x65, 0x32, 0x63, 0x65, 0x65, 0x35, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x34, 0x32, 0x38, 0x38, 0x36, 0x33, 0x61, 0x35, 0x63, 0x61, 0x33, 0x30, 0x33, 0x36, 0x39, 0x38, 0x39, 0x32, 0x64, 0x36, 0x31, 0x32, 0x31, 0x38, 0x33, 0x65, 0x66, 0x39, 0x66, 0x62, 0x31, 0x61, 0x30, 0x34, 0x62, 0x63, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x37, 0x34, 0x32, 0x37, 0x65, 0x33, 0x64, 0x62, 0x66, 0x30, 0x66, 0x65, 0x61, 0x65, 0x37, 0x61, 0x32, 0x35, 0x30, 0x36, 0x66, 0x31, 0x32, 0x64, 0x66, 0x31, 0x64, 0x63, 0x34, 0x30, 0x33, 0x32, 0x36, 0x65, 0x38, 0x35, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x35, 0x37, 0x34, 0x66, 0x63, 0x66, 0x30, 0x30, 0x66, 0x61, 0x65, 0x31, 0x64, 0x39, 0x38, 0x63, 0x63, 0x38, 0x62, 0x66, 0x39, 0x64, 0x64, 0x66, 0x61, 0x31, 0x62, 0x33, 0x39, 0x35, 0x33, 0x62, 0x39, 0x37, 0x34, 0x31, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x38, 0x31, 0x38, 0x65, 0x31, 0x38, 0x62, 0x36, 0x31, 0x30, 0x30, 0x30, 0x31, 0x33, 0x32, 0x31, 0x62, 0x33, 0x31, 0x64, 0x66, 0x36, 0x66, 0x65, 0x37, 0x64, 0x32, 0x38, 0x31, 0x35, 0x63, 0x64, 0x61, 0x64, 0x63, 0x39, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x33, 0x65, 0x31, 0x65, 0x36, 0x37, 0x33, 0x39, 0x62, 0x30, 0x63, 0x36, 0x32, 0x32, 0x30, 0x30, 0x65, 0x30, 0x30, 0x61, 0x30, 0x30, 0x33, 0x36, 0x39, 0x31, 0x64, 0x39, 0x65, 0x66, 0x62, 0x32, 0x33, 0x38, 0x64, 0x38, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x64, 0x33, 0x37, 0x30, 0x66, 0x65, 0x63, 0x36, 0x33, 0x35, 0x37, 0x36, 0x61, 0x62, 0x31, 0x35, 0x62, 0x33, 0x31, 0x38, 0x62, 0x66, 0x39, 0x65, 0x35, 0x38, 0x33, 0x36, 0x34, 0x64, 0x63, 0x32, 0x61, 0x33, 0x35, 0x35, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x32, 0x33, 0x62, 0x66, 0x31, 0x66, 0x62, 0x66, 0x38, 0x30, 0x34, 0x38, 0x35, 0x63, 0x61, 0x32, 0x62, 0x35, 0x35, 0x36, 0x37, 0x64, 0x39, 0x38, 0x64, 0x62, 0x37, 0x62, 0x63, 0x33, 0x35, 0x33, 0x34, 0x64, 0x64, 0x36, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x32, 0x37, 0x64, 0x30, 0x64, 0x31, 0x66, 0x33, 0x64, 0x64, 0x33, 0x63, 0x31, 0x34, 0x30, 0x32, 0x39, 0x34, 0x64, 0x30, 0x34, 0x38, 0x38, 0x62, 0x37, 0x38, 0x33, 0x65, 0x62, 0x66, 0x34, 0x30, 0x31, 0x35, 0x32, 0x37, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x33, 0x30, 0x63, 0x32, 0x64, 0x39, 0x63, 0x62, 0x66, 0x61, 0x38, 0x37, 0x66, 0x35, 0x31, 0x30, 0x66, 0x38, 0x66, 0x39, 0x38, 0x37, 0x37, 0x37, 0x66, 0x66, 0x38, 0x61, 0x38, 0x34, 0x34, 0x38, 0x63, 0x61, 0x35, 0x36, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x30, 0x63, 0x31, 0x39, 0x32, 0x39, 0x31, 0x31, 0x39, 0x36, 0x35, 0x30, 0x35, 0x62, 0x36, 0x35, 0x30, 0x35, 0x39, 0x64, 0x39, 0x39, 0x31, 0x34, 0x62, 0x37, 0x30, 0x39, 0x30, 0x62, 0x65, 0x31, 0x64, 0x62, 0x38, 0x37, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x34, 0x35, 0x65, 0x65, 0x38, 0x34, 0x65, 0x61, 0x34, 0x38, 0x65, 0x35, 0x36, 0x34, 0x31, 0x36, 0x31, 0x65, 0x39, 0x34, 0x38, 0x32, 0x64, 0x35, 0x39, 0x62, 0x63, 0x66, 0x34, 0x30, 0x36, 0x61, 0x36, 0x30, 0x32, 0x63, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x34, 0x63, 0x66, 0x34, 0x31, 0x37, 0x38, 0x35, 0x31, 0x36, 0x31, 0x66, 0x35, 0x37, 0x31, 0x64, 0x30, 0x63, 0x61, 0x36, 0x39, 0x63, 0x39, 0x34, 0x66, 0x38, 0x30, 0x32, 0x31, 0x66, 0x34, 0x31, 0x32, 0x39, 0x34, 0x65, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x34, 0x66, 0x39, 0x62, 0x38, 0x35, 0x30, 0x36, 0x39, 0x30, 0x63, 0x37, 0x63, 0x39, 0x34, 0x36, 0x30, 0x30, 0x64, 0x62, 0x65, 0x65, 0x30, 0x63, 0x61, 0x34, 0x62, 0x30, 0x61, 0x34, 0x31, 0x31, 0x65, 0x39, 0x63, 0x32, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x62, 0x36, 0x62, 0x35, 0x31, 0x61, 0x39, 0x30, 0x33, 0x30, 0x62, 0x34, 0x30, 0x66, 0x62, 0x39, 0x35, 0x63, 0x66, 0x30, 0x62, 0x37, 0x34, 0x38, 0x61, 0x30, 0x35, 0x39, 0x63, 0x32, 0x34, 0x31, 0x37, 0x62, 0x65, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x35, 0x65, 0x66, 0x32, 0x64, 0x61, 0x36, 0x32, 0x30, 0x66, 0x64, 0x33, 0x33, 0x30, 0x64, 0x31, 0x32, 0x65, 0x65, 0x35, 0x35, 0x64, 0x65, 0x35, 0x66, 0x33, 0x32, 0x39, 0x61, 0x36, 0x39, 0x36, 0x65, 0x30, 0x61, 0x39, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x62, 0x31, 0x63, 0x34, 0x33, 0x61, 0x30, 0x66, 0x38, 0x33, 0x34, 0x64, 0x37, 0x64, 0x30, 0x34, 0x37, 0x38, 0x62, 0x38, 0x39, 0x36, 0x30, 0x37, 0x36, 0x37, 0x65, 0x63, 0x31, 0x61, 0x63, 0x34, 0x34, 0x63, 0x39, 0x61, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x32, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x65, 0x66, 0x38, 0x31, 0x34, 0x37, 0x38, 0x61, 0x34, 0x62, 0x32, 0x65, 0x38, 0x30, 0x39, 0x38, 0x64, 0x62, 0x35, 0x66, 0x66, 0x33, 0x38, 0x37, 0x62, 0x61, 0x32, 0x31, 0x35, 0x33, 0x66, 0x34, 0x65, 0x32, 0x32, 0x62, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x36, 0x61, 0x61, 0x30, 0x64, 0x33, 0x30, 0x62, 0x36, 0x34, 0x37, 0x32, 0x31, 0x39, 0x39, 0x30, 0x62, 0x39, 0x35, 0x30, 0x34, 0x61, 0x38, 0x36, 0x33, 0x66, 0x61, 0x30, 0x62, 0x66, 0x62, 0x35, 0x65, 0x35, 0x37, 0x64, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x33, 0x38, 0x30, 0x63, 0x36, 0x66, 0x66, 0x66, 0x35, 0x61, 0x63, 0x64, 0x32, 0x36, 0x35, 0x31, 0x33, 0x30, 0x39, 0x36, 0x32, 0x39, 0x64, 0x62, 0x39, 0x61, 0x37, 0x31, 0x62, 0x66, 0x33, 0x66, 0x32, 0x30, 0x63, 0x35, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x65, 0x62, 0x66, 0x31, 0x32, 0x30, 0x35, 0x64, 0x30, 0x63, 0x63, 0x32, 0x30, 0x63, 0x65, 0x65, 0x36, 0x63, 0x37, 0x66, 0x38, 0x66, 0x66, 0x33, 0x31, 0x31, 0x35, 0x66, 0x35, 0x36, 0x64, 0x34, 0x38, 0x66, 0x62, 0x61, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x63, 0x63, 0x39, 0x64, 0x32, 0x64, 0x32, 0x31, 0x66, 0x38, 0x36, 0x62, 0x38, 0x34, 0x61, 0x63, 0x38, 0x63, 0x65, 0x61, 0x66, 0x39, 0x37, 0x31, 0x64, 0x62, 0x61, 0x37, 0x38, 0x61, 0x39, 0x30, 0x65, 0x36, 0x32, 0x35, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x38, 0x66, 0x39, 0x61, 0x62, 0x30, 0x38, 0x30, 0x31, 0x35, 0x37, 0x64, 0x62, 0x33, 0x30, 0x37, 0x33, 0x31, 0x35, 0x36, 0x64, 0x62, 0x63, 0x61, 0x31, 0x61, 0x31, 0x36, 0x39, 0x65, 0x66, 0x33, 0x31, 0x37, 0x39, 0x34, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x64, 0x31, 0x31, 0x62, 0x37, 0x37, 0x62, 0x63, 0x31, 0x37, 0x65, 0x35, 0x65, 0x36, 0x36, 0x39, 0x34, 0x63, 0x38, 0x62, 0x63, 0x35, 0x62, 0x36, 0x65, 0x34, 0x37, 0x39, 0x38, 0x66, 0x36, 0x38, 0x64, 0x39, 0x63, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x37, 0x33, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x31, 0x37, 0x62, 0x39, 0x36, 0x37, 0x62, 0x39, 0x62, 0x64, 0x34, 0x38, 0x35, 0x66, 0x37, 0x36, 0x39, 0x35, 0x64, 0x32, 0x65, 0x66, 0x35, 0x31, 0x66, 0x62, 0x37, 0x37, 0x39, 0x32, 0x64, 0x38, 0x39, 0x38, 0x66, 0x35, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x63, 0x62, 0x61, 0x64, 0x33, 0x63, 0x63, 0x64, 0x66, 0x36, 0x35, 0x34, 0x64, 0x61, 0x32, 0x32, 0x63, 0x62, 0x63, 0x66, 0x35, 0x63, 0x37, 0x38, 0x36, 0x35, 0x39, 0x37, 0x63, 0x61, 0x31, 0x39, 0x35, 0x35, 0x63, 0x31, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x35, 0x32, 0x32, 0x64, 0x64, 0x66, 0x39, 0x34, 0x34, 0x65, 0x63, 0x35, 0x32, 0x65, 0x32, 0x37, 0x64, 0x37, 0x32, 0x34, 0x65, 0x64, 0x34, 0x63, 0x39, 0x33, 0x65, 0x31, 0x66, 0x37, 0x62, 0x65, 0x36, 0x30, 0x38, 0x33, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x39, 0x30, 0x63, 0x63, 0x62, 0x31, 0x33, 0x32, 0x35, 0x38, 0x61, 0x63, 0x61, 0x61, 0x39, 0x66, 0x34, 0x66, 0x65, 0x62, 0x63, 0x30, 0x61, 0x33, 0x34, 0x32, 0x39, 0x32, 0x66, 0x39, 0x35, 0x39, 0x39, 0x31, 0x65, 0x32, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x32, 0x30, 0x37, 0x33, 0x30, 0x38, 0x63, 0x65, 0x64, 0x32, 0x33, 0x38, 0x61, 0x36, 0x63, 0x30, 0x31, 0x61, 0x64, 0x30, 0x32, 0x31, 0x33, 0x63, 0x61, 0x39, 0x65, 0x62, 0x34, 0x34, 0x36, 0x35, 0x64, 0x34, 0x32, 0x35, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x66, 0x32, 0x39, 0x34, 0x39, 0x63, 0x66, 0x37, 0x38, 0x62, 0x63, 0x32, 0x31, 0x39, 0x62, 0x62, 0x34, 0x66, 0x30, 0x31, 0x39, 0x30, 0x37, 0x63, 0x66, 0x33, 0x62, 0x34, 0x62, 0x33, 0x64, 0x33, 0x38, 0x36, 0x35, 0x34, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x66, 0x35, 0x32, 0x35, 0x39, 0x32, 0x31, 0x64, 0x63, 0x31, 0x31, 0x63, 0x33, 0x32, 0x39, 0x62, 0x37, 0x35, 0x34, 0x66, 0x62, 0x66, 0x33, 0x65, 0x35, 0x32, 0x39, 0x66, 0x63, 0x37, 0x32, 0x33, 0x63, 0x38, 0x33, 0x34, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x31, 0x33, 0x39, 0x62, 0x66, 0x64, 0x63, 0x63, 0x61, 0x36, 0x35, 0x36, 0x63, 0x34, 0x33, 0x30, 0x32, 0x30, 0x33, 0x66, 0x37, 0x32, 0x39, 0x35, 0x38, 0x63, 0x35, 0x34, 0x33, 0x62, 0x36, 0x35, 0x38, 0x30, 0x64, 0x34, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x35, 0x31, 0x31, 0x35, 0x34, 0x33, 0x62, 0x33, 0x64, 0x39, 0x64, 0x63, 0x36, 0x30, 0x64, 0x34, 0x37, 0x66, 0x30, 0x39, 0x64, 0x34, 0x39, 0x64, 0x30, 0x31, 0x62, 0x36, 0x63, 0x34, 0x39, 0x38, 0x64, 0x38, 0x32, 0x30, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x34, 0x64, 0x31, 0x30, 0x33, 0x32, 0x35, 0x34, 0x37, 0x35, 0x39, 0x62, 0x33, 0x34, 0x33, 0x63, 0x62, 0x32, 0x62, 0x39, 0x63, 0x32, 0x64, 0x38, 0x66, 0x66, 0x39, 0x65, 0x31, 0x61, 0x63, 0x35, 0x66, 0x31, 0x34, 0x35, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x32, 0x33, 0x64, 0x63, 0x62, 0x66, 0x32, 0x65, 0x64, 0x64, 0x63, 0x35, 0x33, 0x38, 0x32, 0x65, 0x65, 0x34, 0x62, 0x62, 0x62, 0x62, 0x32, 0x30, 0x31, 0x63, 0x61, 0x33, 0x39, 0x33, 0x31, 0x62, 0x65, 0x38, 0x62, 0x34, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x39, 0x64, 0x32, 0x63, 0x39, 0x31, 0x38, 0x66, 0x64, 0x30, 0x39, 0x65, 0x32, 0x38, 0x30, 0x37, 0x33, 0x31, 0x38, 0x65, 0x36, 0x36, 0x63, 0x65, 0x34, 0x33, 0x32, 0x39, 0x30, 0x39, 0x31, 0x37, 0x36, 0x62, 0x64, 0x35, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x33, 0x35, 0x66, 0x38, 0x64, 0x62, 0x38, 0x37, 0x39, 0x66, 0x63, 0x36, 0x37, 0x66, 0x65, 0x63, 0x35, 0x38, 0x38, 0x32, 0x34, 0x61, 0x35, 0x63, 0x62, 0x65, 0x36, 0x65, 0x35, 0x34, 0x39, 0x38, 0x61, 0x62, 0x61, 0x36, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x34, 0x30, 0x37, 0x34, 0x33, 0x31, 0x32, 0x38, 0x30, 0x36, 0x64, 0x61, 0x34, 0x37, 0x34, 0x38, 0x34, 0x33, 0x34, 0x32, 0x36, 0x36, 0x65, 0x65, 0x30, 0x30, 0x32, 0x31, 0x34, 0x30, 0x65, 0x33, 0x38, 0x31, 0x39, 0x61, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x65, 0x66, 0x31, 0x30, 0x30, 0x64, 0x37, 0x63, 0x65, 0x30, 0x38, 0x39, 0x35, 0x38, 0x33, 0x32, 0x66, 0x32, 0x36, 0x37, 0x38, 0x64, 0x66, 0x37, 0x32, 0x64, 0x34, 0x61, 0x63, 0x66, 0x38, 0x63, 0x32, 0x38, 0x62, 0x38, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x61, 0x66, 0x31, 0x62, 0x31, 0x35, 0x37, 0x33, 0x34, 0x32, 0x64, 0x35, 0x34, 0x33, 0x36, 0x38, 0x32, 0x36, 0x30, 0x64, 0x31, 0x37, 0x38, 0x37, 0x36, 0x32, 0x33, 0x30, 0x61, 0x35, 0x33, 0x34, 0x62, 0x35, 0x34, 0x62, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x39, 0x61, 0x37, 0x31, 0x61, 0x33, 0x36, 0x63, 0x31, 0x31, 0x64, 0x31, 0x30, 0x35, 0x65, 0x30, 0x66, 0x32, 0x61, 0x65, 0x66, 0x35, 0x61, 0x33, 0x65, 0x35, 0x39, 0x38, 0x30, 0x37, 0x38, 0x65, 0x38, 0x35, 0x63, 0x38, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x61, 0x66, 0x30, 0x39, 0x32, 0x66, 0x39, 0x34, 0x62, 0x61, 0x36, 0x61, 0x37, 0x39, 0x39, 0x31, 0x38, 0x62, 0x30, 0x63, 0x66, 0x39, 0x33, 0x39, 0x65, 0x61, 0x62, 0x33, 0x66, 0x30, 0x31, 0x62, 0x33, 0x66, 0x35, 0x31, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x61, 0x35, 0x34, 0x39, 0x65, 0x38, 0x66, 0x64, 0x36, 0x63, 0x33, 0x36, 0x38, 0x64, 0x36, 0x64, 0x63, 0x63, 0x61, 0x36, 0x64, 0x32, 0x65, 0x37, 0x64, 0x31, 0x38, 0x65, 0x34, 0x64, 0x62, 0x39, 0x35, 0x66, 0x35, 0x32, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x65, 0x32, 0x36, 0x34, 0x39, 0x63, 0x37, 0x65, 0x36, 0x61, 0x33, 0x66, 0x32, 0x63, 0x35, 0x64, 0x66, 0x65, 0x33, 0x33, 0x62, 0x62, 0x66, 0x62, 0x64, 0x39, 0x32, 0x37, 0x63, 0x61, 0x33, 0x63, 0x33, 0x35, 0x30, 0x61, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x62, 0x37, 0x35, 0x39, 0x63, 0x63, 0x38, 0x61, 0x31, 0x63, 0x37, 0x35, 0x66, 0x38, 0x30, 0x38, 0x34, 0x39, 0x65, 0x62, 0x62, 0x63, 0x64, 0x61, 0x38, 0x37, 0x38, 0x64, 0x63, 0x38, 0x66, 0x30, 0x64, 0x36, 0x36, 0x64, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x38, 0x34, 0x36, 0x66, 0x32, 0x66, 0x64, 0x66, 0x35, 0x61, 0x34, 0x31, 0x65, 0x64, 0x38, 0x64, 0x66, 0x33, 0x36, 0x65, 0x35, 0x65, 0x64, 0x38, 0x35, 0x34, 0x34, 0x64, 0x66, 0x37, 0x35, 0x39, 0x38, 0x38, 0x65, 0x63, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x39, 0x66, 0x66, 0x38, 0x30, 0x62, 0x66, 0x35, 0x37, 0x30, 0x38, 0x30, 0x30, 0x39, 0x61, 0x39, 0x66, 0x37, 0x33, 0x39, 0x65, 0x30, 0x66, 0x38, 0x62, 0x35, 0x36, 0x30, 0x39, 0x31, 0x34, 0x30, 0x31, 0x36, 0x64, 0x35, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x35, 0x30, 0x35, 0x35, 0x33, 0x37, 0x35, 0x33, 0x37, 0x66, 0x66, 0x62, 0x33, 0x33, 0x63, 0x34, 0x31, 0x35, 0x66, 0x65, 0x63, 0x36, 0x34, 0x65, 0x36, 0x39, 0x62, 0x61, 0x65, 0x30, 0x39, 0x30, 0x63, 0x35, 0x66, 0x36, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x31, 0x64, 0x39, 0x65, 0x39, 0x31, 0x36, 0x63, 0x64, 0x34, 0x30, 0x64, 0x31, 0x39, 0x33, 0x64, 0x62, 0x36, 0x30, 0x65, 0x37, 0x39, 0x32, 0x30, 0x32, 0x37, 0x37, 0x38, 0x61, 0x30, 0x30, 0x38, 0x37, 0x37, 0x31, 0x36, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x36, 0x38, 0x32, 0x33, 0x61, 0x31, 0x62, 0x64, 0x38, 0x31, 0x39, 0x66, 0x31, 0x33, 0x35, 0x31, 0x35, 0x35, 0x33, 0x38, 0x32, 0x36, 0x34, 0x61, 0x32, 0x64, 0x65, 0x30, 0x35, 0x32, 0x62, 0x34, 0x34, 0x34, 0x32, 0x32, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x39, 0x33, 0x39, 0x33, 0x64, 0x36, 0x33, 0x61, 0x30, 0x36, 0x33, 0x65, 0x66, 0x33, 0x37, 0x32, 0x31, 0x65, 0x31, 0x36, 0x62, 0x64, 0x39, 0x66, 0x64, 0x65, 0x34, 0x35, 0x65, 0x65, 0x39, 0x64, 0x62, 0x64, 0x37, 0x37, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x38, 0x38, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x66, 0x36, 0x32, 0x64, 0x30, 0x32, 0x34, 0x33, 0x65, 0x64, 0x65, 0x36, 0x31, 0x64, 0x61, 0x64, 0x39, 0x61, 0x33, 0x31, 0x36, 0x35, 0x66, 0x35, 0x33, 0x39, 0x30, 0x35, 0x32, 0x37, 0x30, 0x64, 0x35, 0x34, 0x65, 0x32, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x62, 0x62, 0x32, 0x39, 0x61, 0x38, 0x36, 0x31, 0x65, 0x61, 0x31, 0x64, 0x34, 0x32, 0x34, 0x64, 0x34, 0x35, 0x61, 0x63, 0x64, 0x34, 0x62, 0x66, 0x63, 0x34, 0x39, 0x32, 0x66, 0x62, 0x38, 0x65, 0x64, 0x38, 0x30, 0x39, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x37, 0x34, 0x65, 0x64, 0x38, 0x30, 0x65, 0x39, 0x36, 0x35, 0x35, 0x37, 0x38, 0x38, 0x65, 0x31, 0x62, 0x62, 0x32, 0x36, 0x39, 0x37, 0x35, 0x32, 0x33, 0x31, 0x39, 0x36, 0x36, 0x37, 0x66, 0x65, 0x37, 0x35, 0x34, 0x65, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x37, 0x36, 0x62, 0x30, 0x35, 0x38, 0x63, 0x62, 0x39, 0x38, 0x64, 0x38, 0x38, 0x62, 0x65, 0x65, 0x64, 0x62, 0x36, 0x37, 0x65, 0x35, 0x34, 0x33, 0x35, 0x30, 0x36, 0x63, 0x39, 0x61, 0x30, 0x64, 0x39, 0x34, 0x37, 0x30, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x36, 0x38, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x65, 0x39, 0x65, 0x66, 0x38, 0x63, 0x38, 0x61, 0x38, 0x61, 0x64, 0x66, 0x61, 0x36, 0x61, 0x62, 0x37, 0x39, 0x38, 0x61, 0x62, 0x32, 0x63, 0x64, 0x63, 0x34, 0x30, 0x35, 0x30, 0x38, 0x32, 0x61, 0x31, 0x62, 0x62, 0x62, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x31, 0x30, 0x32, 0x63, 0x33, 0x62, 0x37, 0x31, 0x31, 0x62, 0x38, 0x31, 0x30, 0x33, 0x34, 0x34, 0x31, 0x39, 0x37, 0x34, 0x31, 0x39, 0x62, 0x31, 0x63, 0x64, 0x38, 0x61, 0x37, 0x30, 0x35, 0x39, 0x66, 0x31, 0x33, 0x65, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x32, 0x30, 0x33, 0x38, 0x63, 0x61, 0x35, 0x32, 0x61, 0x65, 0x65, 0x31, 0x39, 0x37, 0x34, 0x35, 0x62, 0x65, 0x35, 0x63, 0x33, 0x31, 0x66, 0x63, 0x64, 0x63, 0x35, 0x34, 0x31, 0x34, 0x38, 0x62, 0x62, 0x32, 0x63, 0x34, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x65, 0x33, 0x32, 0x31, 0x37, 0x32, 0x38, 0x63, 0x39, 0x63, 0x35, 0x37, 0x36, 0x32, 0x38, 0x30, 0x35, 0x38, 0x65, 0x39, 0x33, 0x66, 0x63, 0x38, 0x36, 0x36, 0x61, 0x30, 0x33, 0x32, 0x64, 0x64, 0x30, 0x62, 0x64, 0x61, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x34, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x62, 0x61, 0x65, 0x34, 0x61, 0x32, 0x33, 0x33, 0x63, 0x32, 0x64, 0x38, 0x35, 0x37, 0x32, 0x34, 0x66, 0x30, 0x64, 0x61, 0x62, 0x65, 0x62, 0x64, 0x61, 0x30, 0x32, 0x34, 0x39, 0x64, 0x38, 0x33, 0x33, 0x65, 0x33, 0x37, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x64, 0x33, 0x32, 0x34, 0x31, 0x36, 0x37, 0x32, 0x32, 0x63, 0x61, 0x34, 0x65, 0x36, 0x34, 0x38, 0x36, 0x33, 0x30, 0x35, 0x34, 0x38, 0x65, 0x61, 0x64, 0x39, 0x31, 0x65, 0x64, 0x64, 0x37, 0x39, 0x63, 0x30, 0x36, 0x61, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x66, 0x30, 0x37, 0x35, 0x35, 0x32, 0x62, 0x35, 0x63, 0x36, 0x39, 0x33, 0x63, 0x32, 0x30, 0x30, 0x36, 0x37, 0x62, 0x33, 0x37, 0x38, 0x62, 0x38, 0x30, 0x39, 0x63, 0x65, 0x65, 0x38, 0x35, 0x33, 0x62, 0x38, 0x66, 0x31, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x36, 0x38, 0x61, 0x66, 0x38, 0x36, 0x38, 0x61, 0x31, 0x65, 0x39, 0x38, 0x38, 0x38, 0x35, 0x66, 0x39, 0x33, 0x37, 0x66, 0x32, 0x36, 0x31, 0x35, 0x64, 0x65, 0x64, 0x36, 0x37, 0x35, 0x31, 0x38, 0x30, 0x34, 0x65, 0x62, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x39, 0x64, 0x33, 0x35, 0x33, 0x31, 0x63, 0x39, 0x39, 0x32, 0x32, 0x61, 0x64, 0x35, 0x36, 0x32, 0x36, 0x39, 0x66, 0x36, 0x33, 0x30, 0x39, 0x61, 0x61, 0x37, 0x38, 0x39, 0x66, 0x62, 0x32, 0x34, 0x38, 0x35, 0x66, 0x39, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x32, 0x39, 0x63, 0x37, 0x61, 0x61, 0x62, 0x34, 0x32, 0x62, 0x32, 0x30, 0x34, 0x38, 0x64, 0x32, 0x62, 0x32, 0x35, 0x32, 0x32, 0x35, 0x64, 0x34, 0x39, 0x38, 0x64, 0x62, 0x61, 0x36, 0x37, 0x61, 0x30, 0x33, 0x66, 0x62, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x35, 0x30, 0x37, 0x35, 0x63, 0x61, 0x36, 0x31, 0x66, 0x65, 0x35, 0x39, 0x64, 0x31, 0x32, 0x33, 0x39, 0x36, 0x39, 0x63, 0x33, 0x36, 0x61, 0x38, 0x32, 0x64, 0x31, 0x61, 0x62, 0x32, 0x64, 0x39, 0x31, 0x38, 0x61, 0x61, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x66, 0x63, 0x30, 0x34, 0x34, 0x36, 0x63, 0x36, 0x61, 0x38, 0x64, 0x34, 0x30, 0x61, 0x65, 0x33, 0x35, 0x35, 0x31, 0x64, 0x62, 0x37, 0x65, 0x37, 0x30, 0x31, 0x64, 0x31, 0x66, 0x61, 0x38, 0x37, 0x36, 0x65, 0x34, 0x61, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x63, 0x64, 0x30, 0x64, 0x31, 0x65, 0x63, 0x65, 0x65, 0x32, 0x37, 0x61, 0x64, 0x64, 0x65, 0x61, 0x39, 0x35, 0x66, 0x36, 0x38, 0x35, 0x37, 0x61, 0x65, 0x65, 0x63, 0x38, 0x63, 0x37, 0x61, 0x30, 0x34, 0x62, 0x32, 0x38, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x32, 0x63, 0x66, 0x62, 0x37, 0x62, 0x33, 0x64, 0x66, 0x37, 0x30, 0x66, 0x63, 0x65, 0x63, 0x61, 0x30, 0x65, 0x64, 0x65, 0x32, 0x36, 0x33, 0x35, 0x30, 0x30, 0x65, 0x32, 0x37, 0x38, 0x37, 0x33, 0x66, 0x38, 0x65, 0x64, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x64, 0x62, 0x34, 0x35, 0x36, 0x31, 0x37, 0x38, 0x32, 0x30, 0x36, 0x66, 0x35, 0x63, 0x34, 0x34, 0x33, 0x30, 0x66, 0x65, 0x30, 0x30, 0x35, 0x30, 0x36, 0x33, 0x39, 0x30, 0x33, 0x63, 0x33, 0x64, 0x37, 0x61, 0x34, 0x39, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x36, 0x32, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x63, 0x66, 0x38, 0x30, 0x61, 0x65, 0x39, 0x36, 0x38, 0x38, 0x65, 0x31, 0x35, 0x38, 0x30, 0x65, 0x36, 0x38, 0x65, 0x37, 0x38, 0x32, 0x63, 0x64, 0x30, 0x38, 0x31, 0x31, 0x66, 0x37, 0x61, 0x61, 0x34, 0x39, 0x34, 0x64, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x30, 0x36, 0x35, 0x31, 0x65, 0x33, 0x39, 0x33, 0x37, 0x38, 0x33, 0x34, 0x32, 0x33, 0x65, 0x35, 0x63, 0x63, 0x31, 0x62, 0x63, 0x35, 0x66, 0x38, 0x38, 0x39, 0x65, 0x34, 0x34, 0x65, 0x66, 0x37, 0x65, 0x61, 0x32, 0x34, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x38, 0x61, 0x38, 0x39, 0x37, 0x30, 0x65, 0x61, 0x34, 0x31, 0x34, 0x35, 0x63, 0x36, 0x34, 0x64, 0x35, 0x35, 0x31, 0x37, 0x62, 0x38, 0x64, 0x65, 0x35, 0x62, 0x34, 0x36, 0x64, 0x30, 0x35, 0x39, 0x35, 0x61, 0x61, 0x64, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x39, 0x62, 0x34, 0x38, 0x35, 0x61, 0x33, 0x62, 0x31, 0x63, 0x64, 0x33, 0x33, 0x61, 0x36, 0x61, 0x39, 0x63, 0x36, 0x32, 0x66, 0x31, 0x65, 0x35, 0x62, 0x65, 0x65, 0x39, 0x32, 0x37, 0x30, 0x31, 0x38, 0x35, 0x36, 0x64, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x35, 0x30, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x32, 0x38, 0x37, 0x63, 0x37, 0x65, 0x37, 0x33, 0x34, 0x32, 0x39, 0x39, 0x65, 0x37, 0x32, 0x37, 0x36, 0x32, 0x36, 0x66, 0x39, 0x33, 0x66, 0x62, 0x31, 0x31, 0x38, 0x37, 0x61, 0x36, 0x30, 0x64, 0x35, 0x30, 0x35, 0x37, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x35, 0x63, 0x30, 0x30, 0x66, 0x64, 0x66, 0x30, 0x33, 0x35, 0x62, 0x63, 0x61, 0x31, 0x35, 0x66, 0x61, 0x33, 0x36, 0x31, 0x30, 0x64, 0x66, 0x33, 0x33, 0x38, 0x34, 0x65, 0x30, 0x66, 0x62, 0x37, 0x39, 0x30, 0x36, 0x38, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x30, 0x61, 0x39, 0x31, 0x33, 0x61, 0x39, 0x30, 0x33, 0x31, 0x63, 0x39, 0x34, 0x39, 0x32, 0x61, 0x62, 0x64, 0x34, 0x63, 0x34, 0x31, 0x64, 0x62, 0x62, 0x31, 0x35, 0x30, 0x35, 0x34, 0x63, 0x66, 0x65, 0x63, 0x34, 0x34, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x33, 0x36, 0x31, 0x34, 0x64, 0x63, 0x62, 0x36, 0x38, 0x61, 0x33, 0x36, 0x65, 0x34, 0x35, 0x61, 0x34, 0x65, 0x39, 0x31, 0x31, 0x65, 0x36, 0x32, 0x37, 0x39, 0x36, 0x32, 0x34, 0x37, 0x32, 0x32, 0x32, 0x64, 0x35, 0x39, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x35, 0x65, 0x32, 0x32, 0x30, 0x32, 0x35, 0x62, 0x37, 0x61, 0x37, 0x37, 0x63, 0x33, 0x61, 0x30, 0x37, 0x34, 0x63, 0x37, 0x38, 0x62, 0x38, 0x65, 0x33, 0x64, 0x66, 0x65, 0x30, 0x37, 0x31, 0x33, 0x34, 0x31, 0x39, 0x34, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x37, 0x38, 0x37, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x65, 0x31, 0x64, 0x66, 0x61, 0x34, 0x32, 0x61, 0x64, 0x65, 0x61, 0x63, 0x32, 0x66, 0x31, 0x37, 0x66, 0x36, 0x66, 0x64, 0x66, 0x35, 0x38, 0x34, 0x63, 0x39, 0x34, 0x38, 0x36, 0x32, 0x66, 0x64, 0x35, 0x36, 0x33, 0x33, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x39, 0x65, 0x37, 0x30, 0x32, 0x66, 0x33, 0x38, 0x35, 0x64, 0x63, 0x64, 0x31, 0x30, 0x35, 0x65, 0x38, 0x62, 0x39, 0x66, 0x61, 0x34, 0x32, 0x38, 0x65, 0x65, 0x61, 0x32, 0x31, 0x63, 0x35, 0x37, 0x66, 0x66, 0x35, 0x32, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x65, 0x34, 0x39, 0x34, 0x39, 0x64, 0x38, 0x61, 0x31, 0x36, 0x35, 0x34, 0x32, 0x64, 0x34, 0x32, 0x33, 0x63, 0x31, 0x37, 0x39, 0x38, 0x34, 0x65, 0x36, 0x37, 0x33, 0x39, 0x66, 0x61, 0x37, 0x32, 0x63, 0x65, 0x62, 0x31, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x39, 0x39, 0x39, 0x39, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x32, 0x39, 0x63, 0x39, 0x64, 0x65, 0x37, 0x36, 0x35, 0x64, 0x64, 0x65, 0x32, 0x35, 0x38, 0x35, 0x32, 0x61, 0x66, 0x30, 0x37, 0x64, 0x33, 0x33, 0x66, 0x32, 0x63, 0x65, 0x34, 0x36, 0x38, 0x66, 0x64, 0x32, 0x30, 0x39, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x66, 0x35, 0x66, 0x30, 0x36, 0x31, 0x61, 0x30, 0x66, 0x34, 0x38, 0x65, 0x35, 0x65, 0x36, 0x39, 0x36, 0x31, 0x38, 0x37, 0x33, 0x39, 0x61, 0x37, 0x37, 0x64, 0x32, 0x65, 0x63, 0x31, 0x39, 0x37, 0x36, 0x38, 0x64, 0x32, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x34, 0x37, 0x63, 0x66, 0x39, 0x63, 0x37, 0x32, 0x65, 0x63, 0x34, 0x38, 0x32, 0x61, 0x66, 0x33, 0x65, 0x61, 0x61, 0x37, 0x35, 0x39, 0x36, 0x35, 0x38, 0x66, 0x37, 0x39, 0x33, 0x64, 0x36, 0x37, 0x30, 0x61, 0x35, 0x37, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x66, 0x34, 0x31, 0x34, 0x37, 0x63, 0x63, 0x63, 0x36, 0x62, 0x63, 0x62, 0x38, 0x30, 0x63, 0x63, 0x38, 0x34, 0x32, 0x65, 0x36, 0x39, 0x66, 0x36, 0x64, 0x30, 0x30, 0x65, 0x33, 0x30, 0x66, 0x61, 0x34, 0x31, 0x33, 0x33, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x36, 0x64, 0x33, 0x31, 0x62, 0x39, 0x61, 0x32, 0x36, 0x31, 0x64, 0x36, 0x34, 0x30, 0x62, 0x35, 0x64, 0x65, 0x61, 0x35, 0x31, 0x65, 0x66, 0x32, 0x31, 0x36, 0x32, 0x63, 0x33, 0x31, 0x30, 0x39, 0x66, 0x31, 0x65, 0x62, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x35, 0x62, 0x61, 0x38, 0x64, 0x37, 0x62, 0x36, 0x38, 0x35, 0x33, 0x39, 0x64, 0x39, 0x33, 0x33, 0x33, 0x30, 0x30, 0x62, 0x63, 0x39, 0x32, 0x38, 0x39, 0x63, 0x33, 0x64, 0x39, 0x34, 0x37, 0x34, 0x64, 0x30, 0x34, 0x31, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x32, 0x65, 0x39, 0x36, 0x32, 0x37, 0x36, 0x66, 0x35, 0x31, 0x38, 0x64, 0x33, 0x31, 0x64, 0x37, 0x65, 0x35, 0x36, 0x65, 0x33, 0x30, 0x64, 0x66, 0x62, 0x30, 0x30, 0x39, 0x63, 0x31, 0x32, 0x31, 0x38, 0x32, 0x30, 0x31, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x32, 0x37, 0x32, 0x32, 0x30, 0x34, 0x39, 0x32, 0x31, 0x39, 0x34, 0x62, 0x32, 0x65, 0x64, 0x61, 0x39, 0x66, 0x63, 0x34, 0x62, 0x62, 0x65, 0x33, 0x38, 0x66, 0x32, 0x35, 0x64, 0x36, 0x38, 0x31, 0x64, 0x66, 0x64, 0x33, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x63, 0x33, 0x33, 0x61, 0x66, 0x63, 0x38, 0x63, 0x62, 0x34, 0x37, 0x30, 0x34, 0x65, 0x32, 0x33, 0x31, 0x35, 0x33, 0x64, 0x65, 0x32, 0x30, 0x34, 0x39, 0x64, 0x33, 0x35, 0x61, 0x65, 0x37, 0x31, 0x33, 0x33, 0x32, 0x34, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x63, 0x37, 0x33, 0x36, 0x64, 0x33, 0x36, 0x35, 0x61, 0x61, 0x33, 0x37, 0x62, 0x35, 0x63, 0x30, 0x62, 0x65, 0x39, 0x63, 0x31, 0x32, 0x63, 0x38, 0x61, 0x64, 0x35, 0x63, 0x64, 0x39, 0x30, 0x33, 0x63, 0x33, 0x32, 0x63, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x65, 0x65, 0x66, 0x34, 0x63, 0x66, 0x34, 0x62, 0x65, 0x62, 0x30, 0x31, 0x65, 0x65, 0x32, 0x30, 0x64, 0x31, 0x31, 0x31, 0x37, 0x34, 0x38, 0x62, 0x36, 0x31, 0x63, 0x62, 0x34, 0x64, 0x33, 0x66, 0x36, 0x34, 0x31, 0x61, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x63, 0x31, 0x62, 0x66, 0x35, 0x62, 0x37, 0x64, 0x63, 0x39, 0x63, 0x38, 0x33, 0x63, 0x31, 0x37, 0x39, 0x65, 0x66, 0x61, 0x63, 0x62, 0x63, 0x66, 0x32, 0x65, 0x62, 0x31, 0x37, 0x34, 0x65, 0x33, 0x35, 0x36, 0x31, 0x63, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x39, 0x64, 0x62, 0x35, 0x61, 0x62, 0x34, 0x33, 0x36, 0x32, 0x31, 0x61, 0x37, 0x61, 0x33, 0x64, 0x61, 0x37, 0x39, 0x35, 0x65, 0x35, 0x38, 0x39, 0x32, 0x39, 0x66, 0x33, 0x64, 0x64, 0x32, 0x35, 0x61, 0x66, 0x36, 0x37, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x65, 0x66, 0x61, 0x65, 0x36, 0x33, 0x35, 0x36, 0x35, 0x30, 0x39, 0x65, 0x64, 0x66, 0x61, 0x63, 0x65, 0x38, 0x39, 0x66, 0x63, 0x36, 0x31, 0x61, 0x37, 0x66, 0x64, 0x63, 0x64, 0x62, 0x33, 0x39, 0x65, 0x65, 0x61, 0x38, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x35, 0x30, 0x30, 0x35, 0x61, 0x36, 0x63, 0x33, 0x37, 0x65, 0x38, 0x63, 0x61, 0x37, 0x65, 0x35, 0x34, 0x33, 0x63, 0x65, 0x32, 0x35, 0x39, 0x39, 0x37, 0x33, 0x61, 0x33, 0x63, 0x61, 0x63, 0x65, 0x39, 0x36, 0x31, 0x61, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x33, 0x64, 0x38, 0x36, 0x62, 0x63, 0x38, 0x32, 0x39, 0x32, 0x37, 0x65, 0x30, 0x63, 0x64, 0x34, 0x32, 0x31, 0x64, 0x31, 0x34, 0x36, 0x65, 0x30, 0x37, 0x66, 0x39, 0x31, 0x39, 0x33, 0x32, 0x37, 0x63, 0x64, 0x66, 0x36, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x34, 0x65, 0x64, 0x32, 0x36, 0x36, 0x36, 0x30, 0x30, 0x31, 0x63, 0x31, 0x36, 0x33, 0x33, 0x33, 0x63, 0x66, 0x37, 0x61, 0x66, 0x35, 0x39, 0x65, 0x34, 0x61, 0x33, 0x64, 0x34, 0x38, 0x36, 0x30, 0x33, 0x36, 0x33, 0x62, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x39, 0x39, 0x66, 0x36, 0x39, 0x66, 0x36, 0x35, 0x33, 0x62, 0x30, 0x35, 0x61, 0x35, 0x61, 0x36, 0x65, 0x38, 0x31, 0x66, 0x34, 0x38, 0x30, 0x37, 0x31, 0x31, 0x64, 0x30, 0x39, 0x62, 0x62, 0x66, 0x39, 0x37, 0x35, 0x38, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x66, 0x63, 0x38, 0x35, 0x61, 0x34, 0x39, 0x63, 0x66, 0x66, 0x39, 0x30, 0x64, 0x62, 0x63, 0x66, 0x64, 0x61, 0x64, 0x63, 0x39, 0x64, 0x64, 0x64, 0x34, 0x30, 0x64, 0x36, 0x62, 0x39, 0x61, 0x32, 0x32, 0x31, 0x30, 0x61, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x31, 0x65, 0x64, 0x32, 0x36, 0x33, 0x66, 0x62, 0x66, 0x36, 0x66, 0x36, 0x66, 0x37, 0x62, 0x34, 0x38, 0x61, 0x65, 0x66, 0x38, 0x66, 0x37, 0x33, 0x33, 0x64, 0x33, 0x32, 0x39, 0x64, 0x34, 0x33, 0x38, 0x32, 0x63, 0x37, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x37, 0x66, 0x65, 0x36, 0x66, 0x35, 0x33, 0x66, 0x32, 0x61, 0x35, 0x38, 0x66, 0x36, 0x64, 0x37, 0x36, 0x64, 0x37, 0x35, 0x32, 0x61, 0x64, 0x66, 0x37, 0x34, 0x61, 0x38, 0x61, 0x32, 0x63, 0x31, 0x38, 0x65, 0x39, 0x30, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x64, 0x61, 0x32, 0x66, 0x64, 0x64, 0x61, 0x32, 0x39, 0x61, 0x39, 0x65, 0x32, 0x37, 0x66, 0x39, 0x65, 0x31, 0x31, 0x35, 0x39, 0x37, 0x35, 0x65, 0x36, 0x39, 0x61, 0x65, 0x39, 0x63, 0x66, 0x62, 0x66, 0x33, 0x66, 0x32, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x31, 0x34, 0x36, 0x65, 0x61, 0x33, 0x38, 0x38, 0x35, 0x31, 0x37, 0x36, 0x66, 0x30, 0x37, 0x37, 0x38, 0x32, 0x65, 0x31, 0x66, 0x65, 0x33, 0x30, 0x64, 0x63, 0x65, 0x33, 0x63, 0x65, 0x32, 0x34, 0x63, 0x34, 0x39, 0x65, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x33, 0x66, 0x66, 0x34, 0x32, 0x35, 0x35, 0x65, 0x35, 0x63, 0x36, 0x35, 0x38, 0x66, 0x32, 0x65, 0x37, 0x66, 0x31, 0x30, 0x65, 0x63, 0x62, 0x64, 0x32, 0x39, 0x32, 0x35, 0x37, 0x32, 0x36, 0x37, 0x31, 0x62, 0x63, 0x32, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x39, 0x30, 0x63, 0x61, 0x31, 0x32, 0x32, 0x62, 0x38, 0x35, 0x30, 0x31, 0x65, 0x65, 0x33, 0x65, 0x35, 0x65, 0x30, 0x37, 0x61, 0x38, 0x63, 0x61, 0x34, 0x62, 0x34, 0x31, 0x39, 0x66, 0x37, 0x65, 0x34, 0x64, 0x61, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x39, 0x31, 0x39, 0x33, 0x39, 0x39, 0x36, 0x62, 0x31, 0x39, 0x34, 0x36, 0x31, 0x37, 0x32, 0x31, 0x31, 0x31, 0x30, 0x36, 0x64, 0x31, 0x36, 0x33, 0x35, 0x65, 0x62, 0x32, 0x36, 0x63, 0x63, 0x34, 0x62, 0x36, 0x36, 0x63, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x39, 0x63, 0x34, 0x39, 0x63, 0x31, 0x37, 0x34, 0x63, 0x61, 0x31, 0x33, 0x62, 0x63, 0x38, 0x33, 0x36, 0x63, 0x31, 0x65, 0x30, 0x61, 0x39, 0x32, 0x62, 0x66, 0x66, 0x34, 0x38, 0x62, 0x32, 0x37, 0x31, 0x35, 0x34, 0x33, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x32, 0x31, 0x63, 0x65, 0x35, 0x62, 0x65, 0x33, 0x38, 0x31, 0x37, 0x33, 0x38, 0x64, 0x64, 0x63, 0x38, 0x33, 0x66, 0x30, 0x32, 0x36, 0x32, 0x31, 0x39, 0x37, 0x34, 0x66, 0x66, 0x30, 0x36, 0x38, 0x36, 0x63, 0x37, 0x39, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x65, 0x39, 0x30, 0x33, 0x30, 0x65, 0x65, 0x36, 0x65, 0x32, 0x66, 0x62, 0x63, 0x34, 0x39, 0x31, 0x61, 0x63, 0x61, 0x33, 0x64, 0x65, 0x34, 0x30, 0x32, 0x32, 0x64, 0x33, 0x30, 0x31, 0x37, 0x37, 0x32, 0x62, 0x37, 0x62, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x62, 0x64, 0x37, 0x35, 0x61, 0x62, 0x64, 0x38, 0x36, 0x35, 0x65, 0x30, 0x63, 0x33, 0x66, 0x30, 0x34, 0x61, 0x30, 0x62, 0x34, 0x66, 0x64, 0x62, 0x63, 0x62, 0x37, 0x34, 0x64, 0x33, 0x34, 0x30, 0x38, 0x32, 0x66, 0x62, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x63, 0x31, 0x66, 0x66, 0x38, 0x37, 0x31, 0x34, 0x38, 0x32, 0x38, 0x62, 0x66, 0x32, 0x38, 0x36, 0x66, 0x66, 0x37, 0x65, 0x38, 0x61, 0x37, 0x37, 0x30, 0x39, 0x31, 0x30, 0x36, 0x35, 0x34, 0x38, 0x65, 0x64, 0x31, 0x62, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x61, 0x61, 0x64, 0x62, 0x64, 0x39, 0x35, 0x30, 0x39, 0x37, 0x32, 0x32, 0x37, 0x30, 0x35, 0x66, 0x36, 0x64, 0x32, 0x33, 0x35, 0x38, 0x61, 0x35, 0x63, 0x37, 0x39, 0x66, 0x33, 0x37, 0x39, 0x37, 0x30, 0x66, 0x30, 0x30, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x38, 0x38, 0x31, 0x34, 0x33, 0x33, 0x66, 0x30, 0x34, 0x61, 0x37, 0x64, 0x30, 0x64, 0x32, 0x37, 0x66, 0x38, 0x34, 0x39, 0x34, 0x34, 0x65, 0x30, 0x38, 0x61, 0x35, 0x31, 0x32, 0x64, 0x61, 0x33, 0x35, 0x35, 0x35, 0x32, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x31, 0x64, 0x36, 0x65, 0x61, 0x64, 0x30, 0x31, 0x61, 0x61, 0x64, 0x61, 0x33, 0x65, 0x38, 0x64, 0x63, 0x37, 0x62, 0x39, 0x35, 0x64, 0x63, 0x61, 0x32, 0x35, 0x64, 0x66, 0x32, 0x36, 0x65, 0x65, 0x66, 0x61, 0x36, 0x33, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x31, 0x30, 0x36, 0x62, 0x61, 0x39, 0x34, 0x65, 0x38, 0x35, 0x36, 0x33, 0x64, 0x34, 0x62, 0x33, 0x63, 0x62, 0x33, 0x63, 0x35, 0x63, 0x36, 0x39, 0x32, 0x63, 0x31, 0x30, 0x65, 0x36, 0x30, 0x34, 0x62, 0x37, 0x63, 0x65, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x38, 0x36, 0x39, 0x37, 0x61, 0x66, 0x30, 0x66, 0x62, 0x66, 0x32, 0x63, 0x61, 0x33, 0x36, 0x65, 0x38, 0x37, 0x36, 0x38, 0x66, 0x34, 0x61, 0x66, 0x32, 0x32, 0x31, 0x33, 0x33, 0x35, 0x37, 0x30, 0x36, 0x38, 0x35, 0x61, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x66, 0x63, 0x63, 0x35, 0x38, 0x35, 0x38, 0x39, 0x36, 0x63, 0x64, 0x30, 0x65, 0x64, 0x65, 0x31, 0x32, 0x39, 0x65, 0x65, 0x32, 0x64, 0x65, 0x35, 0x63, 0x31, 0x39, 0x65, 0x61, 0x38, 0x31, 0x31, 0x35, 0x34, 0x30, 0x62, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x33, 0x31, 0x32, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x32, 0x31, 0x35, 0x36, 0x33, 0x31, 0x62, 0x31, 0x34, 0x32, 0x34, 0x38, 0x64, 0x34, 0x35, 0x61, 0x32, 0x35, 0x35, 0x32, 0x39, 0x36, 0x62, 0x65, 0x64, 0x31, 0x66, 0x62, 0x66, 0x61, 0x30, 0x33, 0x33, 0x30, 0x66, 0x66, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x38, 0x37, 0x38, 0x66, 0x39, 0x31, 0x63, 0x61, 0x38, 0x36, 0x30, 0x35, 0x33, 0x66, 0x63, 0x65, 0x64, 0x35, 0x34, 0x34, 0x34, 0x36, 0x38, 0x36, 0x61, 0x33, 0x33, 0x30, 0x65, 0x30, 0x39, 0x63, 0x63, 0x33, 0x38, 0x38, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x35, 0x64, 0x66, 0x31, 0x39, 0x33, 0x39, 0x30, 0x63, 0x31, 0x36, 0x64, 0x30, 0x31, 0x32, 0x39, 0x38, 0x37, 0x37, 0x32, 0x62, 0x61, 0x65, 0x38, 0x62, 0x63, 0x33, 0x61, 0x31, 0x31, 0x35, 0x32, 0x31, 0x39, 0x39, 0x63, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x33, 0x64, 0x61, 0x65, 0x35, 0x39, 0x65, 0x64, 0x30, 0x66, 0x65, 0x31, 0x38, 0x62, 0x35, 0x38, 0x35, 0x31, 0x31, 0x65, 0x36, 0x66, 0x65, 0x32, 0x66, 0x62, 0x36, 0x39, 0x62, 0x32, 0x31, 0x39, 0x36, 0x38, 0x39, 0x34, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x36, 0x34, 0x38, 0x63, 0x61, 0x61, 0x63, 0x37, 0x34, 0x38, 0x64, 0x64, 0x31, 0x33, 0x35, 0x63, 0x64, 0x39, 0x31, 0x65, 0x61, 0x31, 0x34, 0x63, 0x32, 0x38, 0x65, 0x31, 0x62, 0x64, 0x34, 0x64, 0x37, 0x66, 0x66, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x32, 0x65, 0x32, 0x61, 0x64, 0x36, 0x33, 0x35, 0x65, 0x39, 0x38, 0x36, 0x31, 0x61, 0x65, 0x39, 0x35, 0x63, 0x62, 0x39, 0x62, 0x61, 0x66, 0x63, 0x63, 0x61, 0x30, 0x33, 0x36, 0x62, 0x35, 0x32, 0x38, 0x31, 0x66, 0x35, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x65, 0x65, 0x63, 0x30, 0x39, 0x62, 0x66, 0x30, 0x33, 0x65, 0x33, 0x35, 0x32, 0x62, 0x64, 0x36, 0x66, 0x66, 0x31, 0x62, 0x31, 0x65, 0x38, 0x37, 0x36, 0x62, 0x65, 0x36, 0x36, 0x34, 0x63, 0x65, 0x66, 0x66, 0x64, 0x30, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x36, 0x65, 0x35, 0x61, 0x62, 0x33, 0x66, 0x36, 0x34, 0x63, 0x39, 0x61, 0x62, 0x35, 0x36, 0x62, 0x30, 0x30, 0x39, 0x33, 0x39, 0x33, 0x62, 0x30, 0x31, 0x36, 0x36, 0x34, 0x66, 0x63, 0x30, 0x33, 0x32, 0x34, 0x30, 0x35, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x32, 0x62, 0x39, 0x31, 0x34, 0x39, 0x64, 0x37, 0x30, 0x31, 0x37, 0x38, 0x61, 0x37, 0x33, 0x33, 0x33, 0x36, 0x33, 0x34, 0x32, 0x37, 0x35, 0x65, 0x38, 0x32, 0x64, 0x35, 0x39, 0x35, 0x33, 0x66, 0x32, 0x37, 0x39, 0x36, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x33, 0x39, 0x31, 0x39, 0x30, 0x61, 0x34, 0x66, 0x64, 0x65, 0x38, 0x33, 0x64, 0x66, 0x62, 0x33, 0x64, 0x64, 0x63, 0x62, 0x34, 0x63, 0x35, 0x66, 0x62, 0x62, 0x38, 0x33, 0x61, 0x63, 0x36, 0x63, 0x34, 0x39, 0x37, 0x35, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x39, 0x65, 0x66, 0x37, 0x36, 0x31, 0x31, 0x39, 0x35, 0x66, 0x33, 0x61, 0x33, 0x37, 0x33, 0x65, 0x32, 0x34, 0x65, 0x63, 0x65, 0x36, 0x63, 0x64, 0x32, 0x32, 0x35, 0x32, 0x30, 0x66, 0x65, 0x30, 0x62, 0x39, 0x65, 0x38, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x39, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x61, 0x66, 0x61, 0x37, 0x38, 0x37, 0x66, 0x63, 0x39, 0x66, 0x39, 0x34, 0x62, 0x64, 0x66, 0x66, 0x36, 0x39, 0x37, 0x36, 0x62, 0x31, 0x61, 0x34, 0x32, 0x66, 0x34, 0x33, 0x30, 0x61, 0x38, 0x62, 0x66, 0x36, 0x66, 0x62, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x30, 0x62, 0x33, 0x31, 0x61, 0x66, 0x66, 0x66, 0x34, 0x62, 0x36, 0x64, 0x66, 0x33, 0x36, 0x35, 0x33, 0x61, 0x39, 0x34, 0x64, 0x37, 0x63, 0x38, 0x37, 0x39, 0x37, 0x38, 0x61, 0x65, 0x33, 0x35, 0x66, 0x33, 0x34, 0x61, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x64, 0x38, 0x32, 0x66, 0x32, 0x65, 0x36, 0x39, 0x39, 0x34, 0x33, 0x66, 0x37, 0x64, 0x65, 0x30, 0x66, 0x35, 0x66, 0x37, 0x37, 0x34, 0x33, 0x38, 0x37, 0x39, 0x34, 0x30, 0x36, 0x66, 0x61, 0x63, 0x32, 0x65, 0x39, 0x63, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x64, 0x36, 0x63, 0x65, 0x66, 0x64, 0x37, 0x35, 0x62, 0x30, 0x63, 0x34, 0x62, 0x33, 0x66, 0x38, 0x66, 0x31, 0x64, 0x36, 0x38, 0x37, 0x61, 0x35, 0x32, 0x32, 0x63, 0x39, 0x36, 0x31, 0x32, 0x33, 0x66, 0x31, 0x66, 0x35, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x35, 0x37, 0x37, 0x61, 0x66, 0x64, 0x34, 0x65, 0x35, 0x30, 0x38, 0x39, 0x30, 0x32, 0x34, 0x37, 0x63, 0x39, 0x62, 0x31, 0x30, 0x64, 0x34, 0x34, 0x61, 0x66, 0x37, 0x33, 0x32, 0x32, 0x39, 0x61, 0x65, 0x63, 0x38, 0x38, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x35, 0x36, 0x30, 0x36, 0x64, 0x35, 0x31, 0x32, 0x32, 0x30, 0x65, 0x65, 0x37, 0x66, 0x32, 0x31, 0x34, 0x36, 0x64, 0x34, 0x31, 0x31, 0x35, 0x38, 0x32, 0x65, 0x65, 0x34, 0x65, 0x65, 0x34, 0x61, 0x34, 0x35, 0x35, 0x39, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x32, 0x65, 0x37, 0x37, 0x63, 0x38, 0x36, 0x31, 0x36, 0x39, 0x36, 0x65, 0x66, 0x39, 0x36, 0x61, 0x64, 0x35, 0x34, 0x39, 0x33, 0x34, 0x66, 0x38, 0x39, 0x34, 0x61, 0x61, 0x38, 0x65, 0x61, 0x33, 0x35, 0x31, 0x35, 0x31, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x37, 0x66, 0x35, 0x33, 0x37, 0x36, 0x63, 0x32, 0x64, 0x65, 0x30, 0x62, 0x36, 0x63, 0x63, 0x33, 0x63, 0x31, 0x37, 0x39, 0x63, 0x30, 0x36, 0x30, 0x38, 0x37, 0x61, 0x61, 0x34, 0x37, 0x33, 0x64, 0x36, 0x62, 0x34, 0x36, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x34, 0x39, 0x61, 0x66, 0x63, 0x64, 0x37, 0x35, 0x34, 0x34, 0x37, 0x38, 0x33, 0x38, 0x66, 0x36, 0x65, 0x37, 0x63, 0x65, 0x64, 0x61, 0x38, 0x64, 0x32, 0x31, 0x37, 0x37, 0x37, 0x64, 0x34, 0x66, 0x63, 0x31, 0x63, 0x33, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x38, 0x34, 0x61, 0x64, 0x64, 0x38, 0x38, 0x64, 0x38, 0x33, 0x64, 0x63, 0x35, 0x36, 0x34, 0x61, 0x62, 0x38, 0x65, 0x30, 0x65, 0x30, 0x32, 0x63, 0x62, 0x64, 0x62, 0x36, 0x33, 0x39, 0x31, 0x39, 0x61, 0x65, 0x61, 0x38, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x33, 0x31, 0x32, 0x61, 0x35, 0x36, 0x63, 0x37, 0x38, 0x34, 0x62, 0x31, 0x32, 0x32, 0x30, 0x39, 0x39, 0x62, 0x37, 0x36, 0x34, 0x64, 0x30, 0x35, 0x39, 0x63, 0x32, 0x31, 0x65, 0x63, 0x65, 0x39, 0x35, 0x65, 0x38, 0x34, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x39, 0x37, 0x62, 0x61, 0x61, 0x66, 0x39, 0x63, 0x63, 0x62, 0x36, 0x30, 0x33, 0x66, 0x64, 0x33, 0x30, 0x34, 0x33, 0x30, 0x36, 0x38, 0x39, 0x64, 0x34, 0x33, 0x35, 0x34, 0x34, 0x35, 0x65, 0x39, 0x63, 0x39, 0x38, 0x62, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x32, 0x35, 0x66, 0x38, 0x63, 0x39, 0x38, 0x64, 0x32, 0x37, 0x61, 0x30, 0x39, 0x61, 0x31, 0x62, 0x63, 0x61, 0x62, 0x64, 0x35, 0x31, 0x32, 0x38, 0x62, 0x31, 0x63, 0x32, 0x61, 0x39, 0x34, 0x38, 0x35, 0x36, 0x61, 0x66, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x66, 0x35, 0x63, 0x61, 0x66, 0x34, 0x63, 0x34, 0x30, 0x65, 0x36, 0x39, 0x30, 0x38, 0x38, 0x31, 0x33, 0x63, 0x30, 0x37, 0x34, 0x35, 0x62, 0x30, 0x61, 0x65, 0x61, 0x39, 0x35, 0x38, 0x36, 0x64, 0x39, 0x64, 0x64, 0x39, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x35, 0x39, 0x36, 0x61, 0x38, 0x31, 0x62, 0x33, 0x35, 0x37, 0x63, 0x36, 0x66, 0x32, 0x34, 0x39, 0x37, 0x30, 0x63, 0x63, 0x33, 0x31, 0x33, 0x64, 0x66, 0x36, 0x64, 0x62, 0x64, 0x61, 0x61, 0x62, 0x64, 0x30, 0x64, 0x30, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x36, 0x33, 0x31, 0x32, 0x32, 0x38, 0x65, 0x66, 0x62, 0x66, 0x32, 0x61, 0x32, 0x65, 0x33, 0x61, 0x34, 0x30, 0x39, 0x32, 0x65, 0x65, 0x38, 0x39, 0x30, 0x30, 0x63, 0x36, 0x33, 0x39, 0x65, 0x64, 0x33, 0x34, 0x66, 0x62, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x36, 0x63, 0x66, 0x32, 0x30, 0x36, 0x34, 0x39, 0x61, 0x39, 0x65, 0x39, 0x37, 0x33, 0x31, 0x37, 0x37, 0x61, 0x63, 0x36, 0x37, 0x64, 0x62, 0x61, 0x64, 0x65, 0x65, 0x34, 0x65, 0x62, 0x65, 0x35, 0x63, 0x37, 0x62, 0x64, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x61, 0x37, 0x62, 0x66, 0x65, 0x30, 0x34, 0x33, 0x38, 0x38, 0x36, 0x31, 0x32, 0x37, 0x64, 0x34, 0x30, 0x31, 0x31, 0x64, 0x38, 0x33, 0x35, 0x36, 0x61, 0x34, 0x37, 0x65, 0x39, 0x34, 0x37, 0x39, 0x36, 0x33, 0x61, 0x63, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x66, 0x38, 0x65, 0x35, 0x35, 0x39, 0x36, 0x39, 0x36, 0x38, 0x32, 0x63, 0x37, 0x31, 0x35, 0x66, 0x34, 0x38, 0x61, 0x64, 0x34, 0x66, 0x63, 0x30, 0x66, 0x62, 0x62, 0x36, 0x37, 0x65, 0x62, 0x35, 0x39, 0x37, 0x39, 0x35, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x32, 0x66, 0x35, 0x36, 0x31, 0x32, 0x32, 0x35, 0x34, 0x39, 0x64, 0x31, 0x36, 0x38, 0x61, 0x35, 0x63, 0x35, 0x65, 0x32, 0x36, 0x37, 0x66, 0x35, 0x32, 0x36, 0x36, 0x32, 0x65, 0x35, 0x63, 0x35, 0x63, 0x63, 0x65, 0x35, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x31, 0x33, 0x61, 0x62, 0x38, 0x30, 0x33, 0x37, 0x34, 0x31, 0x31, 0x63, 0x30, 0x39, 0x62, 0x61, 0x36, 0x38, 0x37, 0x66, 0x36, 0x66, 0x39, 0x33, 0x36, 0x34, 0x66, 0x30, 0x64, 0x33, 0x32, 0x33, 0x39, 0x66, 0x61, 0x63, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x63, 0x63, 0x63, 0x36, 0x31, 0x36, 0x62, 0x33, 0x31, 0x31, 0x38, 0x32, 0x36, 0x38, 0x65, 0x37, 0x35, 0x64, 0x39, 0x61, 0x62, 0x38, 0x39, 0x39, 0x36, 0x63, 0x38, 0x38, 0x35, 0x38, 0x65, 0x62, 0x64, 0x37, 0x66, 0x33, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x63, 0x38, 0x38, 0x66, 0x39, 0x31, 0x37, 0x65, 0x34, 0x64, 0x36, 0x61, 0x64, 0x34, 0x37, 0x33, 0x66, 0x61, 0x31, 0x32, 0x65, 0x39, 0x38, 0x65, 0x61, 0x33, 0x63, 0x34, 0x34, 0x37, 0x32, 0x61, 0x35, 0x65, 0x64, 0x36, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x39, 0x36, 0x66, 0x64, 0x34, 0x65, 0x38, 0x33, 0x39, 0x62, 0x34, 0x63, 0x39, 0x35, 0x64, 0x37, 0x35, 0x31, 0x30, 0x66, 0x62, 0x37, 0x63, 0x35, 0x63, 0x37, 0x32, 0x62, 0x38, 0x33, 0x63, 0x36, 0x63, 0x33, 0x65, 0x33, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x32, 0x38, 0x35, 0x35, 0x33, 0x39, 0x38, 0x36, 0x39, 0x64, 0x38, 0x38, 0x66, 0x38, 0x61, 0x39, 0x36, 0x31, 0x35, 0x33, 0x33, 0x37, 0x35, 0x35, 0x37, 0x31, 0x37, 0x64, 0x37, 0x65, 0x62, 0x36, 0x35, 0x35, 0x37, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x32, 0x39, 0x63, 0x36, 0x35, 0x64, 0x36, 0x39, 0x64, 0x35, 0x62, 0x62, 0x61, 0x65, 0x61, 0x35, 0x39, 0x37, 0x36, 0x32, 0x36, 0x36, 0x32, 0x65, 0x66, 0x34, 0x31, 0x38, 0x62, 0x63, 0x32, 0x31, 0x61, 0x64, 0x39, 0x32, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x34, 0x31, 0x38, 0x61, 0x61, 0x30, 0x65, 0x37, 0x31, 0x33, 0x64, 0x32, 0x34, 0x38, 0x32, 0x32, 0x38, 0x37, 0x37, 0x36, 0x62, 0x32, 0x65, 0x37, 0x34, 0x33, 0x34, 0x32, 0x32, 0x32, 0x61, 0x65, 0x37, 0x35, 0x65, 0x33, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x30, 0x62, 0x39, 0x30, 0x61, 0x31, 0x66, 0x64, 0x64, 0x34, 0x38, 0x66, 0x32, 0x37, 0x62, 0x32, 0x36, 0x38, 0x66, 0x65, 0x62, 0x33, 0x38, 0x33, 0x38, 0x32, 0x65, 0x35, 0x35, 0x64, 0x64, 0x62, 0x35, 0x30, 0x65, 0x66, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x61, 0x30, 0x34, 0x33, 0x31, 0x66, 0x66, 0x66, 0x35, 0x65, 0x61, 0x64, 0x39, 0x32, 0x37, 0x66, 0x33, 0x63, 0x36, 0x39, 0x36, 0x34, 0x39, 0x36, 0x31, 0x36, 0x64, 0x63, 0x36, 0x65, 0x39, 0x37, 0x39, 0x34, 0x35, 0x66, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x33, 0x63, 0x62, 0x38, 0x31, 0x65, 0x35, 0x31, 0x30, 0x31, 0x31, 0x62, 0x35, 0x34, 0x39, 0x64, 0x37, 0x38, 0x62, 0x66, 0x37, 0x32, 0x30, 0x62, 0x30, 0x64, 0x39, 0x32, 0x34, 0x61, 0x63, 0x37, 0x36, 0x33, 0x61, 0x37, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x35, 0x62, 0x33, 0x37, 0x37, 0x39, 0x62, 0x62, 0x36, 0x64, 0x35, 0x36, 0x33, 0x34, 0x32, 0x65, 0x32, 0x66, 0x64, 0x61, 0x38, 0x31, 0x37, 0x62, 0x35, 0x62, 0x32, 0x64, 0x38, 0x31, 0x63, 0x37, 0x66, 0x34, 0x31, 0x33, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x64, 0x34, 0x38, 0x36, 0x66, 0x63, 0x31, 0x39, 0x36, 0x37, 0x39, 0x31, 0x62, 0x39, 0x32, 0x63, 0x66, 0x36, 0x31, 0x32, 0x64, 0x33, 0x34, 0x38, 0x36, 0x31, 0x34, 0x66, 0x39, 0x31, 0x35, 0x36, 0x34, 0x38, 0x38, 0x62, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x61, 0x38, 0x63, 0x62, 0x62, 0x66, 0x64, 0x66, 0x66, 0x30, 0x32, 0x62, 0x32, 0x65, 0x33, 0x38, 0x61, 0x65, 0x34, 0x62, 0x62, 0x66, 0x63, 0x61, 0x31, 0x35, 0x66, 0x31, 0x66, 0x30, 0x65, 0x38, 0x33, 0x62, 0x31, 0x61, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x62, 0x30, 0x63, 0x31, 0x65, 0x33, 0x37, 0x66, 0x35, 0x61, 0x35, 0x65, 0x63, 0x34, 0x62, 0x62, 0x66, 0x35, 0x30, 0x38, 0x34, 0x30, 0x35, 0x34, 0x38, 0x66, 0x39, 0x64, 0x33, 0x61, 0x63, 0x30, 0x32, 0x38, 0x38, 0x38, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x64, 0x34, 0x39, 0x66, 0x38, 0x36, 0x63, 0x32, 0x32, 0x38, 0x66, 0x34, 0x37, 0x33, 0x36, 0x37, 0x61, 0x33, 0x35, 0x65, 0x38, 0x38, 0x36, 0x63, 0x61, 0x61, 0x63, 0x62, 0x32, 0x37, 0x31, 0x65, 0x35, 0x33, 0x39, 0x34, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x32, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x34, 0x61, 0x36, 0x65, 0x62, 0x34, 0x31, 0x62, 0x61, 0x33, 0x34, 0x66, 0x31, 0x33, 0x61, 0x64, 0x64, 0x64, 0x65, 0x37, 0x64, 0x32, 0x64, 0x62, 0x37, 0x64, 0x66, 0x30, 0x34, 0x39, 0x31, 0x35, 0x63, 0x37, 0x61, 0x32, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x35, 0x63, 0x63, 0x66, 0x32, 0x64, 0x38, 0x31, 0x39, 0x65, 0x64, 0x62, 0x62, 0x64, 0x64, 0x65, 0x61, 0x38, 0x31, 0x31, 0x37, 0x62, 0x35, 0x63, 0x34, 0x39, 0x65, 0x64, 0x33, 0x63, 0x32, 0x61, 0x30, 0x36, 0x36, 0x65, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x33, 0x62, 0x37, 0x38, 0x33, 0x36, 0x61, 0x32, 0x62, 0x39, 0x64, 0x38, 0x39, 0x39, 0x37, 0x32, 0x31, 0x61, 0x34, 0x64, 0x32, 0x33, 0x37, 0x62, 0x35, 0x32, 0x32, 0x33, 0x38, 0x35, 0x64, 0x63, 0x65, 0x38, 0x64, 0x66, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x36, 0x61, 0x61, 0x32, 0x33, 0x63, 0x38, 0x32, 0x64, 0x37, 0x32, 0x31, 0x35, 0x62, 0x65, 0x63, 0x38, 0x64, 0x35, 0x37, 0x66, 0x36, 0x30, 0x61, 0x64, 0x37, 0x35, 0x65, 0x66, 0x31, 0x34, 0x66, 0x61, 0x33, 0x35, 0x66, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x37, 0x39, 0x30, 0x35, 0x37, 0x64, 0x61, 0x62, 0x65, 0x66, 0x35, 0x65, 0x36, 0x34, 0x65, 0x37, 0x62, 0x34, 0x34, 0x66, 0x37, 0x66, 0x31, 0x38, 0x36, 0x34, 0x38, 0x65, 0x37, 0x65, 0x35, 0x33, 0x33, 0x37, 0x31, 0x38, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x66, 0x30, 0x35, 0x37, 0x63, 0x64, 0x30, 0x33, 0x61, 0x34, 0x65, 0x32, 0x37, 0x65, 0x38, 0x65, 0x30, 0x33, 0x32, 0x66, 0x38, 0x35, 0x37, 0x39, 0x38, 0x35, 0x66, 0x64, 0x37, 0x66, 0x30, 0x31, 0x61, 0x64, 0x63, 0x38, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x32, 0x66, 0x30, 0x37, 0x64, 0x32, 0x64, 0x36, 0x39, 0x37, 0x65, 0x38, 0x63, 0x35, 0x36, 0x37, 0x66, 0x63, 0x66, 0x64, 0x66, 0x65, 0x30, 0x32, 0x30, 0x66, 0x34, 0x39, 0x66, 0x33, 0x36, 0x30, 0x62, 0x65, 0x32, 0x31, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x66, 0x62, 0x64, 0x66, 0x65, 0x35, 0x33, 0x38, 0x39, 0x39, 0x39, 0x39, 0x36, 0x33, 0x33, 0x63, 0x32, 0x36, 0x36, 0x30, 0x35, 0x61, 0x35, 0x62, 0x66, 0x63, 0x32, 0x63, 0x31, 0x62, 0x62, 0x35, 0x39, 0x35, 0x39, 0x33, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x37, 0x65, 0x38, 0x37, 0x63, 0x38, 0x66, 0x37, 0x64, 0x31, 0x66, 0x63, 0x65, 0x33, 0x62, 0x30, 0x31, 0x33, 0x35, 0x33, 0x61, 0x38, 0x35, 0x38, 0x36, 0x32, 0x61, 0x39, 0x34, 0x38, 0x61, 0x63, 0x30, 0x34, 0x39, 0x66, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x35, 0x33, 0x38, 0x33, 0x64, 0x36, 0x38, 0x62, 0x35, 0x32, 0x64, 0x30, 0x33, 0x34, 0x31, 0x36, 0x31, 0x62, 0x66, 0x61, 0x62, 0x30, 0x31, 0x61, 0x65, 0x31, 0x62, 0x30, 0x34, 0x37, 0x39, 0x34, 0x32, 0x66, 0x62, 0x63, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x30, 0x66, 0x66, 0x33, 0x33, 0x35, 0x34, 0x65, 0x30, 0x66, 0x64, 0x65, 0x39, 0x33, 0x38, 0x64, 0x30, 0x66, 0x62, 0x35, 0x62, 0x38, 0x32, 0x63, 0x65, 0x66, 0x35, 0x62, 0x61, 0x31, 0x35, 0x63, 0x33, 0x64, 0x32, 0x39, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x34, 0x36, 0x64, 0x35, 0x33, 0x37, 0x63, 0x66, 0x32, 0x65, 0x64, 0x64, 0x34, 0x30, 0x33, 0x35, 0x36, 0x35, 0x62, 0x64, 0x65, 0x37, 0x33, 0x33, 0x62, 0x32, 0x65, 0x33, 0x34, 0x62, 0x32, 0x31, 0x35, 0x30, 0x30, 0x31, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x35, 0x38, 0x66, 0x62, 0x33, 0x64, 0x62, 0x32, 0x39, 0x30, 0x37, 0x30, 0x64, 0x30, 0x31, 0x33, 0x30, 0x31, 0x38, 0x38, 0x63, 0x65, 0x34, 0x37, 0x32, 0x62, 0x65, 0x30, 0x61, 0x31, 0x37, 0x32, 0x62, 0x38, 0x39, 0x30, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x61, 0x62, 0x65, 0x35, 0x32, 0x37, 0x30, 0x66, 0x33, 0x61, 0x37, 0x38, 0x63, 0x65, 0x30, 0x30, 0x37, 0x63, 0x66, 0x33, 0x37, 0x66, 0x38, 0x66, 0x62, 0x63, 0x30, 0x34, 0x35, 0x64, 0x34, 0x38, 0x39, 0x62, 0x37, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x63, 0x36, 0x63, 0x31, 0x31, 0x34, 0x32, 0x36, 0x62, 0x34, 0x61, 0x31, 0x65, 0x61, 0x65, 0x37, 0x65, 0x35, 0x31, 0x64, 0x64, 0x35, 0x31, 0x32, 0x61, 0x64, 0x31, 0x30, 0x39, 0x30, 0x63, 0x36, 0x66, 0x31, 0x61, 0x38, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x63, 0x66, 0x66, 0x66, 0x64, 0x30, 0x35, 0x32, 0x31, 0x35, 0x32, 0x62, 0x62, 0x33, 0x66, 0x39, 0x35, 0x37, 0x62, 0x34, 0x37, 0x38, 0x64, 0x35, 0x66, 0x39, 0x38, 0x62, 0x32, 0x33, 0x33, 0x61, 0x37, 0x63, 0x32, 0x62, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x34, 0x61, 0x30, 0x31, 0x31, 0x39, 0x39, 0x35, 0x63, 0x36, 0x38, 0x31, 0x62, 0x63, 0x39, 0x39, 0x39, 0x66, 0x64, 0x64, 0x37, 0x39, 0x37, 0x35, 0x34, 0x65, 0x39, 0x61, 0x33, 0x32, 0x34, 0x61, 0x65, 0x33, 0x62, 0x33, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x33, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x61, 0x36, 0x30, 0x64, 0x66, 0x38, 0x31, 0x38, 0x61, 0x35, 0x34, 0x34, 0x36, 0x34, 0x31, 0x38, 0x62, 0x31, 0x62, 0x62, 0x64, 0x36, 0x32, 0x38, 0x32, 0x36, 0x65, 0x30, 0x62, 0x39, 0x38, 0x32, 0x35, 0x65, 0x31, 0x33, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x64, 0x35, 0x35, 0x61, 0x64, 0x39, 0x39, 0x62, 0x39, 0x31, 0x33, 0x37, 0x66, 0x64, 0x31, 0x62, 0x32, 0x30, 0x63, 0x63, 0x32, 0x62, 0x34, 0x66, 0x30, 0x33, 0x64, 0x34, 0x32, 0x63, 0x62, 0x61, 0x64, 0x64, 0x66, 0x33, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x39, 0x62, 0x39, 0x61, 0x31, 0x30, 0x39, 0x39, 0x33, 0x30, 0x35, 0x31, 0x37, 0x65, 0x38, 0x39, 0x39, 0x39, 0x30, 0x39, 0x39, 0x63, 0x63, 0x66, 0x32, 0x61, 0x39, 0x31, 0x34, 0x63, 0x34, 0x63, 0x38, 0x64, 0x64, 0x39, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x38, 0x33, 0x35, 0x34, 0x34, 0x66, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x32, 0x35, 0x37, 0x32, 0x63, 0x37, 0x38, 0x32, 0x62, 0x65, 0x65, 0x35, 0x64, 0x32, 0x31, 0x38, 0x66, 0x31, 0x65, 0x66, 0x30, 0x36, 0x34, 0x61, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x38, 0x62, 0x31, 0x34, 0x36, 0x34, 0x38, 0x66, 0x30, 0x31, 0x38, 0x33, 0x33, 0x33, 0x36, 0x38, 0x37, 0x63, 0x64, 0x32, 0x31, 0x33, 0x66, 0x61, 0x36, 0x34, 0x30, 0x61, 0x65, 0x63, 0x30, 0x34, 0x63, 0x65, 0x36, 0x33, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x37, 0x62, 0x34, 0x36, 0x32, 0x61, 0x62, 0x38, 0x34, 0x65, 0x35, 0x30, 0x39, 0x31, 0x66, 0x34, 0x38, 0x61, 0x34, 0x36, 0x65, 0x62, 0x30, 0x63, 0x64, 0x63, 0x39, 0x32, 0x64, 0x64, 0x63, 0x62, 0x32, 0x36, 0x65, 0x30, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x38, 0x35, 0x31, 0x30, 0x37, 0x39, 0x33, 0x65, 0x65, 0x65, 0x38, 0x31, 0x31, 0x63, 0x32, 0x64, 0x61, 0x62, 0x31, 0x63, 0x39, 0x33, 0x63, 0x36, 0x66, 0x34, 0x34, 0x37, 0x33, 0x66, 0x33, 0x30, 0x66, 0x62, 0x65, 0x66, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x32, 0x66, 0x62, 0x63, 0x62, 0x31, 0x30, 0x36, 0x36, 0x32, 0x33, 0x37, 0x30, 0x61, 0x30, 0x36, 0x38, 0x66, 0x63, 0x32, 0x36, 0x35, 0x32, 0x36, 0x30, 0x32, 0x61, 0x32, 0x35, 0x37, 0x37, 0x39, 0x33, 0x37, 0x63, 0x63, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x38, 0x33, 0x62, 0x32, 0x31, 0x62, 0x64, 0x32, 0x37, 0x31, 0x32, 0x33, 0x36, 0x30, 0x34, 0x33, 0x36, 0x62, 0x36, 0x37, 0x61, 0x35, 0x39, 0x37, 0x65, 0x65, 0x33, 0x33, 0x37, 0x38, 0x64, 0x62, 0x33, 0x65, 0x37, 0x61, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x37, 0x37, 0x34, 0x34, 0x31, 0x63, 0x38, 0x33, 0x65, 0x30, 0x33, 0x66, 0x30, 0x62, 0x65, 0x38, 0x64, 0x64, 0x33, 0x34, 0x30, 0x62, 0x64, 0x65, 0x36, 0x33, 0x36, 0x38, 0x35, 0x30, 0x38, 0x34, 0x37, 0x63, 0x36, 0x32, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x34, 0x61, 0x35, 0x38, 0x35, 0x32, 0x30, 0x33, 0x64, 0x61, 0x37, 0x62, 0x62, 0x61, 0x66, 0x64, 0x39, 0x33, 0x65, 0x31, 0x35, 0x38, 0x38, 0x34, 0x65, 0x36, 0x36, 0x30, 0x64, 0x34, 0x62, 0x31, 0x65, 0x61, 0x64, 0x38, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x61, 0x30, 0x38, 0x30, 0x38, 0x31, 0x37, 0x39, 0x39, 0x31, 0x37, 0x33, 0x65, 0x30, 0x30, 0x31, 0x63, 0x63, 0x35, 0x62, 0x64, 0x34, 0x36, 0x61, 0x30, 0x32, 0x34, 0x30, 0x36, 0x64, 0x63, 0x39, 0x35, 0x64, 0x31, 0x37, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x64, 0x31, 0x33, 0x66, 0x30, 0x63, 0x34, 0x30, 0x32, 0x34, 0x65, 0x39, 0x36, 0x37, 0x64, 0x39, 0x34, 0x37, 0x30, 0x37, 0x39, 0x31, 0x62, 0x35, 0x30, 0x66, 0x32, 0x32, 0x64, 0x65, 0x33, 0x61, 0x66, 0x65, 0x63, 0x66, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x35, 0x32, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x66, 0x64, 0x36, 0x31, 0x33, 0x34, 0x63, 0x30, 0x34, 0x61, 0x38, 0x61, 0x62, 0x37, 0x65, 0x62, 0x31, 0x36, 0x66, 0x30, 0x30, 0x36, 0x34, 0x33, 0x66, 0x38, 0x66, 0x65, 0x64, 0x37, 0x64, 0x61, 0x61, 0x61, 0x65, 0x63, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x38, 0x31, 0x32, 0x62, 0x63, 0x36, 0x39, 0x66, 0x62, 0x31, 0x37, 0x30, 0x65, 0x66, 0x35, 0x37, 0x65, 0x32, 0x33, 0x32, 0x37, 0x65, 0x38, 0x30, 0x61, 0x66, 0x66, 0x64, 0x31, 0x34, 0x66, 0x38, 0x65, 0x34, 0x62, 0x36, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x34, 0x38, 0x61, 0x65, 0x66, 0x33, 0x33, 0x32, 0x36, 0x31, 0x64, 0x38, 0x30, 0x33, 0x31, 0x66, 0x61, 0x63, 0x33, 0x66, 0x37, 0x31, 0x38, 0x32, 0x66, 0x66, 0x33, 0x35, 0x39, 0x32, 0x38, 0x64, 0x61, 0x66, 0x35, 0x34, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x30, 0x36, 0x33, 0x39, 0x30, 0x66, 0x32, 0x34, 0x33, 0x37, 0x62, 0x32, 0x30, 0x65, 0x63, 0x34, 0x61, 0x33, 0x64, 0x33, 0x34, 0x33, 0x31, 0x62, 0x33, 0x32, 0x37, 0x39, 0x63, 0x36, 0x35, 0x38, 0x33, 0x65, 0x35, 0x65, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x30, 0x39, 0x62, 0x33, 0x31, 0x39, 0x39, 0x38, 0x65, 0x61, 0x64, 0x34, 0x31, 0x34, 0x62, 0x38, 0x66, 0x62, 0x30, 0x65, 0x38, 0x34, 0x36, 0x62, 0x64, 0x35, 0x63, 0x62, 0x64, 0x65, 0x33, 0x39, 0x33, 0x39, 0x33, 0x35, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x30, 0x64, 0x62, 0x61, 0x39, 0x33, 0x39, 0x31, 0x36, 0x38, 0x32, 0x62, 0x34, 0x61, 0x33, 0x36, 0x34, 0x65, 0x37, 0x37, 0x66, 0x65, 0x39, 0x39, 0x32, 0x35, 0x36, 0x33, 0x30, 0x31, 0x61, 0x36, 0x63, 0x30, 0x62, 0x66, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x38, 0x33, 0x62, 0x61, 0x65, 0x37, 0x62, 0x35, 0x36, 0x35, 0x32, 0x34, 0x34, 0x35, 0x35, 0x38, 0x35, 0x35, 0x35, 0x62, 0x63, 0x66, 0x34, 0x62, 0x61, 0x38, 0x64, 0x61, 0x32, 0x30, 0x31, 0x31, 0x38, 0x39, 0x31, 0x63, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x61, 0x30, 0x33, 0x35, 0x34, 0x39, 0x61, 0x61, 0x36, 0x31, 0x36, 0x38, 0x65, 0x39, 0x37, 0x65, 0x38, 0x38, 0x61, 0x35, 0x30, 0x38, 0x33, 0x33, 0x30, 0x61, 0x35, 0x61, 0x30, 0x62, 0x65, 0x61, 0x37, 0x34, 0x37, 0x31, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x63, 0x39, 0x61, 0x30, 0x65, 0x33, 0x34, 0x31, 0x34, 0x35, 0x66, 0x62, 0x66, 0x64, 0x64, 0x32, 0x63, 0x39, 0x64, 0x32, 0x61, 0x34, 0x39, 0x39, 0x62, 0x36, 0x31, 0x37, 0x64, 0x37, 0x61, 0x30, 0x32, 0x39, 0x36, 0x39, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x64, 0x66, 0x34, 0x30, 0x39, 0x30, 0x35, 0x37, 0x36, 0x39, 0x62, 0x63, 0x63, 0x34, 0x32, 0x36, 0x63, 0x62, 0x32, 0x63, 0x32, 0x39, 0x33, 0x38, 0x66, 0x66, 0x65, 0x30, 0x37, 0x37, 0x65, 0x31, 0x65, 0x38, 0x39, 0x64, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x34, 0x62, 0x35, 0x31, 0x63, 0x33, 0x39, 0x65, 0x35, 0x33, 0x64, 0x39, 0x65, 0x37, 0x36, 0x32, 0x62, 0x30, 0x36, 0x31, 0x33, 0x62, 0x38, 0x32, 0x39, 0x61, 0x34, 0x34, 0x62, 0x34, 0x37, 0x32, 0x66, 0x34, 0x66, 0x66, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x37, 0x39, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x36, 0x32, 0x35, 0x38, 0x38, 0x31, 0x37, 0x31, 0x63, 0x66, 0x39, 0x39, 0x62, 0x62, 0x65, 0x62, 0x35, 0x38, 0x66, 0x31, 0x32, 0x36, 0x62, 0x38, 0x37, 0x30, 0x66, 0x39, 0x61, 0x33, 0x37, 0x32, 0x38, 0x64, 0x36, 0x31, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x62, 0x31, 0x38, 0x35, 0x66, 0x65, 0x31, 0x62, 0x37, 0x30, 0x61, 0x39, 0x34, 0x61, 0x36, 0x61, 0x30, 0x38, 0x30, 0x65, 0x37, 0x65, 0x32, 0x33, 0x61, 0x38, 0x62, 0x65, 0x64, 0x63, 0x34, 0x61, 0x63, 0x62, 0x66, 0x33, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x33, 0x62, 0x66, 0x65, 0x61, 0x64, 0x61, 0x36, 0x66, 0x30, 0x66, 0x64, 0x30, 0x31, 0x36, 0x66, 0x62, 0x63, 0x38, 0x34, 0x33, 0x65, 0x62, 0x63, 0x66, 0x36, 0x65, 0x33, 0x37, 0x30, 0x61, 0x36, 0x35, 0x62, 0x65, 0x37, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x65, 0x64, 0x31, 0x30, 0x63, 0x66, 0x31, 0x66, 0x36, 0x64, 0x62, 0x34, 0x38, 0x32, 0x30, 0x36, 0x62, 0x35, 0x30, 0x39, 0x31, 0x39, 0x62, 0x39, 0x62, 0x36, 0x39, 0x37, 0x30, 0x38, 0x31, 0x66, 0x62, 0x64, 0x61, 0x61, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x36, 0x62, 0x30, 0x35, 0x32, 0x31, 0x62, 0x30, 0x65, 0x36, 0x38, 0x62, 0x32, 0x37, 0x37, 0x64, 0x66, 0x30, 0x62, 0x62, 0x33, 0x32, 0x66, 0x33, 0x66, 0x64, 0x34, 0x38, 0x33, 0x32, 0x36, 0x33, 0x35, 0x30, 0x62, 0x66, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x34, 0x33, 0x39, 0x33, 0x34, 0x38, 0x64, 0x66, 0x38, 0x61, 0x34, 0x32, 0x37, 0x37, 0x62, 0x32, 0x32, 0x61, 0x37, 0x36, 0x38, 0x34, 0x35, 0x37, 0x64, 0x31, 0x31, 0x35, 0x38, 0x65, 0x39, 0x37, 0x63, 0x34, 0x30, 0x39, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x32, 0x35, 0x33, 0x32, 0x37, 0x66, 0x38, 0x64, 0x63, 0x62, 0x62, 0x32, 0x66, 0x34, 0x35, 0x65, 0x35, 0x36, 0x31, 0x65, 0x38, 0x36, 0x65, 0x33, 0x35, 0x64, 0x38, 0x38, 0x35, 0x30, 0x65, 0x35, 0x33, 0x61, 0x62, 0x30, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x64, 0x37, 0x33, 0x38, 0x39, 0x36, 0x63, 0x66, 0x36, 0x35, 0x39, 0x33, 0x61, 0x36, 0x39, 0x31, 0x39, 0x37, 0x32, 0x61, 0x31, 0x33, 0x61, 0x36, 0x65, 0x34, 0x38, 0x37, 0x31, 0x66, 0x66, 0x32, 0x63, 0x34, 0x32, 0x62, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x30, 0x66, 0x64, 0x32, 0x61, 0x36, 0x34, 0x37, 0x31, 0x30, 0x32, 0x66, 0x38, 0x38, 0x31, 0x66, 0x37, 0x34, 0x63, 0x39, 0x66, 0x62, 0x63, 0x33, 0x37, 0x64, 0x61, 0x36, 0x33, 0x32, 0x39, 0x34, 0x39, 0x66, 0x32, 0x33, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x35, 0x66, 0x38, 0x32, 0x33, 0x36, 0x35, 0x63, 0x35, 0x31, 0x30, 0x31, 0x66, 0x30, 0x37, 0x31, 0x65, 0x37, 0x64, 0x32, 0x63, 0x62, 0x36, 0x61, 0x66, 0x31, 0x34, 0x66, 0x37, 0x61, 0x61, 0x64, 0x32, 0x63, 0x31, 0x36, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x61, 0x61, 0x38, 0x66, 0x39, 0x32, 0x65, 0x62, 0x66, 0x66, 0x66, 0x39, 0x39, 0x31, 0x66, 0x63, 0x30, 0x35, 0x35, 0x65, 0x39, 0x30, 0x36, 0x65, 0x36, 0x35, 0x31, 0x61, 0x63, 0x37, 0x36, 0x38, 0x64, 0x33, 0x32, 0x62, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x62, 0x66, 0x38, 0x37, 0x37, 0x30, 0x66, 0x30, 0x64, 0x31, 0x30, 0x38, 0x32, 0x65, 0x35, 0x63, 0x32, 0x30, 0x63, 0x35, 0x61, 0x65, 0x61, 0x64, 0x33, 0x34, 0x65, 0x35, 0x66, 0x63, 0x61, 0x39, 0x61, 0x65, 0x37, 0x61, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x63, 0x39, 0x63, 0x63, 0x33, 0x30, 0x39, 0x34, 0x62, 0x30, 0x34, 0x31, 0x61, 0x64, 0x30, 0x65, 0x30, 0x37, 0x36, 0x66, 0x39, 0x36, 0x38, 0x61, 0x30, 0x64, 0x65, 0x33, 0x62, 0x31, 0x36, 0x37, 0x32, 0x35, 0x35, 0x38, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x35, 0x33, 0x31, 0x65, 0x38, 0x62, 0x31, 0x62, 0x64, 0x65, 0x30, 0x39, 0x37, 0x66, 0x64, 0x66, 0x38, 0x34, 0x39, 0x64, 0x36, 0x64, 0x31, 0x31, 0x39, 0x38, 0x38, 0x35, 0x36, 0x30, 0x38, 0x61, 0x30, 0x30, 0x38, 0x64, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x63, 0x64, 0x32, 0x35, 0x39, 0x38, 0x61, 0x32, 0x30, 0x65, 0x31, 0x34, 0x39, 0x65, 0x61, 0x64, 0x32, 0x61, 0x64, 0x36, 0x39, 0x33, 0x37, 0x39, 0x35, 0x37, 0x36, 0x65, 0x63, 0x65, 0x64, 0x62, 0x36, 0x30, 0x65, 0x33, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x63, 0x61, 0x38, 0x62, 0x63, 0x36, 0x64, 0x61, 0x32, 0x38, 0x30, 0x33, 0x64, 0x30, 0x37, 0x32, 0x35, 0x66, 0x35, 0x65, 0x31, 0x61, 0x34, 0x35, 0x36, 0x63, 0x38, 0x39, 0x66, 0x39, 0x62, 0x63, 0x37, 0x37, 0x34, 0x65, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x37, 0x32, 0x35, 0x65, 0x63, 0x32, 0x62, 0x64, 0x63, 0x33, 0x33, 0x61, 0x31, 0x64, 0x38, 0x32, 0x36, 0x30, 0x37, 0x31, 0x64, 0x65, 0x61, 0x32, 0x39, 0x64, 0x36, 0x32, 0x64, 0x34, 0x33, 0x38, 0x35, 0x61, 0x38, 0x63, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x34, 0x37, 0x36, 0x35, 0x37, 0x39, 0x30, 0x33, 0x35, 0x32, 0x36, 0x35, 0x36, 0x62, 0x63, 0x36, 0x35, 0x36, 0x36, 0x38, 0x32, 0x63, 0x32, 0x34, 0x66, 0x63, 0x35, 0x65, 0x66, 0x33, 0x65, 0x37, 0x36, 0x61, 0x32, 0x33, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x66, 0x39, 0x65, 0x34, 0x36, 0x35, 0x37, 0x31, 0x36, 0x61, 0x63, 0x61, 0x63, 0x66, 0x62, 0x38, 0x63, 0x38, 0x32, 0x35, 0x32, 0x66, 0x61, 0x38, 0x65, 0x37, 0x62, 0x63, 0x37, 0x39, 0x36, 0x39, 0x65, 0x62, 0x66, 0x36, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x63, 0x35, 0x33, 0x30, 0x38, 0x62, 0x33, 0x31, 0x32, 0x38, 0x32, 0x65, 0x32, 0x31, 0x38, 0x66, 0x63, 0x39, 0x65, 0x37, 0x35, 0x39, 0x64, 0x34, 0x66, 0x65, 0x63, 0x35, 0x64, 0x62, 0x33, 0x37, 0x30, 0x38, 0x63, 0x65, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x37, 0x37, 0x30, 0x31, 0x66, 0x63, 0x36, 0x32, 0x32, 0x35, 0x64, 0x35, 0x61, 0x31, 0x37, 0x38, 0x31, 0x35, 0x34, 0x33, 0x38, 0x61, 0x38, 0x39, 0x34, 0x31, 0x64, 0x32, 0x31, 0x65, 0x62, 0x63, 0x35, 0x64, 0x30, 0x35, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x38, 0x39, 0x63, 0x38, 0x33, 0x66, 0x66, 0x62, 0x62, 0x30, 0x32, 0x35, 0x32, 0x61, 0x63, 0x30, 0x64, 0x62, 0x65, 0x33, 0x35, 0x32, 0x31, 0x32, 0x31, 0x37, 0x36, 0x33, 0x30, 0x65, 0x30, 0x66, 0x34, 0x39, 0x31, 0x66, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x62, 0x35, 0x31, 0x37, 0x37, 0x34, 0x61, 0x66, 0x32, 0x30, 0x36, 0x62, 0x39, 0x36, 0x36, 0x62, 0x38, 0x39, 0x30, 0x39, 0x63, 0x34, 0x35, 0x61, 0x61, 0x36, 0x37, 0x32, 0x32, 0x37, 0x34, 0x38, 0x38, 0x30, 0x32, 0x63, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x39, 0x32, 0x32, 0x36, 0x64, 0x34, 0x36, 0x66, 0x65, 0x37, 0x35, 0x31, 0x39, 0x34, 0x30, 0x62, 0x63, 0x34, 0x31, 0x36, 0x61, 0x37, 0x39, 0x38, 0x62, 0x36, 0x39, 0x63, 0x63, 0x66, 0x30, 0x64, 0x66, 0x61, 0x62, 0x36, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x36, 0x36, 0x30, 0x66, 0x38, 0x62, 0x32, 0x65, 0x34, 0x63, 0x37, 0x63, 0x63, 0x32, 0x62, 0x34, 0x61, 0x63, 0x39, 0x63, 0x34, 0x37, 0x65, 0x64, 0x32, 0x38, 0x35, 0x30, 0x38, 0x64, 0x35, 0x66, 0x38, 0x66, 0x38, 0x36, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x31, 0x39, 0x66, 0x61, 0x63, 0x38, 0x61, 0x33, 0x32, 0x34, 0x33, 0x37, 0x64, 0x38, 0x30, 0x61, 0x63, 0x36, 0x38, 0x33, 0x37, 0x61, 0x30, 0x62, 0x62, 0x37, 0x38, 0x34, 0x31, 0x37, 0x32, 0x39, 0x66, 0x34, 0x39, 0x37, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x31, 0x38, 0x36, 0x34, 0x61, 0x38, 0x66, 0x37, 0x38, 0x34, 0x63, 0x32, 0x32, 0x37, 0x37, 0x62, 0x30, 0x62, 0x37, 0x63, 0x39, 0x65, 0x65, 0x37, 0x33, 0x34, 0x66, 0x37, 0x62, 0x33, 0x37, 0x37, 0x65, 0x61, 0x62, 0x36, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x31, 0x30, 0x31, 0x63, 0x39, 0x36, 0x31, 0x65, 0x38, 0x65, 0x31, 0x63, 0x31, 0x35, 0x37, 0x39, 0x38, 0x66, 0x66, 0x63, 0x64, 0x30, 0x65, 0x33, 0x32, 0x30, 0x31, 0x64, 0x37, 0x37, 0x38, 0x36, 0x65, 0x63, 0x33, 0x37, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x66, 0x66, 0x34, 0x36, 0x32, 0x30, 0x33, 0x65, 0x66, 0x61, 0x32, 0x33, 0x30, 0x36, 0x34, 0x62, 0x31, 0x63, 0x61, 0x66, 0x30, 0x30, 0x35, 0x31, 0x36, 0x65, 0x32, 0x38, 0x37, 0x30, 0x34, 0x61, 0x38, 0x32, 0x61, 0x34, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x31, 0x33, 0x36, 0x62, 0x34, 0x37, 0x39, 0x36, 0x32, 0x62, 0x62, 0x38, 0x62, 0x34, 0x66, 0x62, 0x35, 0x34, 0x30, 0x64, 0x62, 0x34, 0x63, 0x63, 0x66, 0x35, 0x66, 0x64, 0x64, 0x30, 0x34, 0x32, 0x66, 0x66, 0x62, 0x38, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x34, 0x61, 0x65, 0x32, 0x31, 0x64, 0x37, 0x36, 0x32, 0x64, 0x36, 0x65, 0x31, 0x64, 0x64, 0x65, 0x32, 0x38, 0x63, 0x32, 0x33, 0x35, 0x64, 0x31, 0x33, 0x31, 0x30, 0x34, 0x35, 0x39, 0x37, 0x32, 0x33, 0x36, 0x64, 0x62, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x37, 0x61, 0x39, 0x32, 0x65, 0x30, 0x33, 0x36, 0x31, 0x64, 0x62, 0x61, 0x63, 0x65, 0x63, 0x64, 0x63, 0x35, 0x64, 0x65, 0x30, 0x64, 0x31, 0x38, 0x39, 0x34, 0x39, 0x35, 0x35, 0x61, 0x66, 0x36, 0x61, 0x39, 0x62, 0x36, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x34, 0x38, 0x65, 0x31, 0x39, 0x64, 0x33, 0x39, 0x64, 0x64, 0x33, 0x35, 0x62, 0x36, 0x36, 0x65, 0x36, 0x65, 0x31, 0x62, 0x62, 0x36, 0x62, 0x39, 0x63, 0x36, 0x35, 0x37, 0x63, 0x62, 0x32, 0x63, 0x66, 0x35, 0x39, 0x64, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x38, 0x34, 0x34, 0x31, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x64, 0x34, 0x37, 0x66, 0x64, 0x63, 0x66, 0x39, 0x63, 0x64, 0x39, 0x34, 0x32, 0x64, 0x32, 0x38, 0x65, 0x66, 0x66, 0x64, 0x35, 0x62, 0x38, 0x34, 0x31, 0x31, 0x35, 0x62, 0x33, 0x31, 0x61, 0x36, 0x35, 0x38, 0x61, 0x31, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x30, 0x64, 0x30, 0x38, 0x36, 0x31, 0x37, 0x62, 0x64, 0x32, 0x35, 0x32, 0x61, 0x39, 0x31, 0x31, 0x64, 0x66, 0x38, 0x62, 0x64, 0x34, 0x31, 0x61, 0x33, 0x39, 0x62, 0x38, 0x33, 0x64, 0x64, 0x66, 0x38, 0x30, 0x39, 0x36, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x36, 0x36, 0x36, 0x62, 0x38, 0x36, 0x66, 0x31, 0x63, 0x35, 0x65, 0x65, 0x38, 0x63, 0x61, 0x34, 0x31, 0x32, 0x38, 0x35, 0x66, 0x35, 0x62, 0x64, 0x65, 0x34, 0x66, 0x37, 0x39, 0x30, 0x35, 0x32, 0x30, 0x38, 0x31, 0x34, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x64, 0x65, 0x63, 0x35, 0x62, 0x64, 0x33, 0x66, 0x34, 0x65, 0x62, 0x61, 0x32, 0x64, 0x31, 0x38, 0x62, 0x38, 0x61, 0x61, 0x63, 0x65, 0x66, 0x61, 0x37, 0x62, 0x37, 0x32, 0x31, 0x35, 0x34, 0x38, 0x63, 0x33, 0x31, 0x39, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x39, 0x66, 0x65, 0x30, 0x63, 0x39, 0x35, 0x66, 0x31, 0x30, 0x66, 0x65, 0x65, 0x38, 0x37, 0x61, 0x66, 0x31, 0x61, 0x66, 0x32, 0x30, 0x37, 0x32, 0x33, 0x36, 0x63, 0x38, 0x66, 0x33, 0x36, 0x31, 0x34, 0x65, 0x66, 0x30, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x64, 0x30, 0x64, 0x33, 0x31, 0x30, 0x61, 0x63, 0x65, 0x61, 0x31, 0x38, 0x34, 0x30, 0x36, 0x31, 0x33, 0x38, 0x62, 0x61, 0x61, 0x61, 0x62, 0x62, 0x66, 0x65, 0x30, 0x35, 0x37, 0x31, 0x65, 0x38, 0x30, 0x64, 0x65, 0x38, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x36, 0x39, 0x63, 0x36, 0x33, 0x61, 0x39, 0x32, 0x38, 0x34, 0x61, 0x38, 0x30, 0x35, 0x36, 0x32, 0x36, 0x64, 0x62, 0x33, 0x61, 0x33, 0x32, 0x65, 0x39, 0x64, 0x32, 0x33, 0x36, 0x33, 0x39, 0x33, 0x34, 0x37, 0x36, 0x31, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x35, 0x63, 0x32, 0x63, 0x31, 0x30, 0x39, 0x39, 0x62, 0x62, 0x65, 0x65, 0x66, 0x62, 0x32, 0x36, 0x37, 0x65, 0x37, 0x34, 0x62, 0x35, 0x38, 0x38, 0x38, 0x30, 0x62, 0x34, 0x34, 0x34, 0x64, 0x39, 0x34, 0x34, 0x34, 0x39, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x33, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x36, 0x61, 0x65, 0x37, 0x61, 0x30, 0x35, 0x61, 0x31, 0x64, 0x65, 0x35, 0x37, 0x35, 0x38, 0x32, 0x61, 0x65, 0x32, 0x37, 0x36, 0x38, 0x32, 0x30, 0x34, 0x32, 0x37, 0x36, 0x63, 0x30, 0x66, 0x66, 0x34, 0x37, 0x65, 0x64, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x32, 0x64, 0x38, 0x38, 0x34, 0x62, 0x64, 0x36, 0x39, 0x64, 0x62, 0x31, 0x61, 0x63, 0x63, 0x30, 0x64, 0x38, 0x39, 0x63, 0x36, 0x34, 0x61, 0x64, 0x65, 0x34, 0x63, 0x62, 0x34, 0x66, 0x63, 0x33, 0x61, 0x38, 0x38, 0x62, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x32, 0x63, 0x62, 0x63, 0x61, 0x38, 0x34, 0x34, 0x30, 0x61, 0x38, 0x35, 0x37, 0x37, 0x30, 0x39, 0x37, 0x62, 0x31, 0x39, 0x61, 0x66, 0x66, 0x35, 0x39, 0x33, 0x61, 0x32, 0x61, 0x64, 0x39, 0x64, 0x32, 0x38, 0x61, 0x37, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x64, 0x66, 0x39, 0x34, 0x34, 0x35, 0x61, 0x38, 0x31, 0x63, 0x31, 0x62, 0x33, 0x64, 0x38, 0x30, 0x34, 0x61, 0x65, 0x61, 0x65, 0x62, 0x36, 0x66, 0x36, 0x65, 0x32, 0x30, 0x34, 0x65, 0x34, 0x32, 0x33, 0x36, 0x36, 0x36, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x33, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x62, 0x35, 0x66, 0x33, 0x33, 0x62, 0x34, 0x64, 0x34, 0x38, 0x38, 0x39, 0x33, 0x36, 0x64, 0x31, 0x33, 0x65, 0x33, 0x31, 0x36, 0x31, 0x64, 0x61, 0x33, 0x33, 0x61, 0x31, 0x64, 0x61, 0x37, 0x64, 0x66, 0x37, 0x30, 0x64, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x36, 0x30, 0x66, 0x31, 0x38, 0x63, 0x38, 0x31, 0x32, 0x61, 0x31, 0x31, 0x65, 0x64, 0x34, 0x65, 0x32, 0x37, 0x37, 0x36, 0x65, 0x37, 0x61, 0x38, 0x30, 0x65, 0x63, 0x66, 0x35, 0x65, 0x35, 0x33, 0x30, 0x35, 0x62, 0x33, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x39, 0x61, 0x39, 0x63, 0x64, 0x36, 0x63, 0x39, 0x63, 0x31, 0x62, 0x65, 0x33, 0x35, 0x33, 0x34, 0x65, 0x65, 0x63, 0x64, 0x39, 0x32, 0x65, 0x63, 0x63, 0x32, 0x32, 0x66, 0x35, 0x63, 0x33, 0x38, 0x65, 0x39, 0x35, 0x31, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x32, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x63, 0x34, 0x30, 0x66, 0x65, 0x32, 0x30, 0x39, 0x35, 0x34, 0x32, 0x33, 0x35, 0x30, 0x39, 0x62, 0x39, 0x66, 0x64, 0x39, 0x62, 0x37, 0x35, 0x34, 0x33, 0x32, 0x33, 0x31, 0x35, 0x38, 0x61, 0x66, 0x32, 0x33, 0x31, 0x30, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x34, 0x61, 0x35, 0x66, 0x35, 0x35, 0x37, 0x66, 0x33, 0x62, 0x61, 0x62, 0x33, 0x39, 0x30, 0x61, 0x39, 0x32, 0x66, 0x34, 0x39, 0x62, 0x39, 0x62, 0x39, 0x30, 0x30, 0x61, 0x66, 0x33, 0x30, 0x63, 0x34, 0x36, 0x61, 0x65, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x36, 0x64, 0x66, 0x30, 0x32, 0x66, 0x62, 0x64, 0x38, 0x39, 0x36, 0x30, 0x37, 0x33, 0x34, 0x37, 0x61, 0x66, 0x63, 0x65, 0x32, 0x39, 0x36, 0x39, 0x62, 0x39, 0x63, 0x34, 0x32, 0x33, 0x36, 0x61, 0x35, 0x38, 0x61, 0x35, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x34, 0x39, 0x64, 0x66, 0x38, 0x33, 0x63, 0x36, 0x66, 0x36, 0x35, 0x65, 0x65, 0x63, 0x30, 0x66, 0x31, 0x64, 0x63, 0x39, 0x61, 0x30, 0x39, 0x33, 0x34, 0x61, 0x35, 0x63, 0x35, 0x66, 0x33, 0x61, 0x35, 0x30, 0x66, 0x64, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x36, 0x36, 0x32, 0x65, 0x39, 0x35, 0x32, 0x37, 0x34, 0x31, 0x32, 0x31, 0x66, 0x31, 0x37, 0x37, 0x35, 0x36, 0x36, 0x65, 0x36, 0x33, 0x36, 0x64, 0x32, 0x33, 0x39, 0x36, 0x34, 0x63, 0x66, 0x31, 0x66, 0x64, 0x36, 0x38, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x32, 0x36, 0x37, 0x33, 0x33, 0x31, 0x66, 0x61, 0x63, 0x62, 0x32, 0x36, 0x32, 0x64, 0x61, 0x61, 0x65, 0x63, 0x64, 0x39, 0x64, 0x64, 0x36, 0x33, 0x61, 0x39, 0x37, 0x30, 0x30, 0x63, 0x35, 0x66, 0x35, 0x32, 0x35, 0x39, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x37, 0x64, 0x39, 0x61, 0x61, 0x33, 0x63, 0x34, 0x64, 0x31, 0x33, 0x62, 0x65, 0x65, 0x31, 0x32, 0x63, 0x37, 0x35, 0x30, 0x30, 0x66, 0x30, 0x39, 0x66, 0x35, 0x64, 0x64, 0x31, 0x63, 0x36, 0x36, 0x63, 0x34, 0x36, 0x35, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x34, 0x64, 0x30, 0x37, 0x61, 0x63, 0x64, 0x33, 0x38, 0x31, 0x38, 0x33, 0x61, 0x36, 0x31, 0x62, 0x62, 0x32, 0x37, 0x38, 0x33, 0x64, 0x32, 0x62, 0x37, 0x62, 0x31, 0x37, 0x38, 0x64, 0x64, 0x35, 0x30, 0x32, 0x61, 0x63, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x30, 0x63, 0x33, 0x64, 0x65, 0x66, 0x61, 0x63, 0x39, 0x63, 0x65, 0x61, 0x37, 0x61, 0x63, 0x63, 0x33, 0x31, 0x39, 0x61, 0x39, 0x36, 0x63, 0x33, 0x30, 0x62, 0x38, 0x65, 0x31, 0x66, 0x65, 0x64, 0x61, 0x62, 0x34, 0x35, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x64, 0x63, 0x32, 0x32, 0x65, 0x64, 0x35, 0x39, 0x35, 0x62, 0x66, 0x30, 0x61, 0x33, 0x33, 0x37, 0x63, 0x30, 0x31, 0x65, 0x30, 0x33, 0x63, 0x63, 0x36, 0x62, 0x65, 0x37, 0x34, 0x34, 0x32, 0x35, 0x35, 0x66, 0x63, 0x39, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x30, 0x36, 0x37, 0x63, 0x37, 0x63, 0x31, 0x62, 0x62, 0x64, 0x35, 0x37, 0x37, 0x38, 0x30, 0x62, 0x37, 0x62, 0x39, 0x65, 0x65, 0x62, 0x39, 0x65, 0x63, 0x30, 0x30, 0x33, 0x32, 0x66, 0x39, 0x30, 0x64, 0x30, 0x64, 0x63, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x65, 0x32, 0x34, 0x34, 0x30, 0x61, 0x65, 0x31, 0x34, 0x32, 0x63, 0x38, 0x38, 0x30, 0x33, 0x36, 0x36, 0x61, 0x31, 0x32, 0x63, 0x36, 0x64, 0x34, 0x31, 0x30, 0x32, 0x66, 0x34, 0x62, 0x38, 0x34, 0x33, 0x34, 0x62, 0x36, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x65, 0x63, 0x65, 0x30, 0x32, 0x32, 0x62, 0x63, 0x63, 0x64, 0x32, 0x63, 0x39, 0x32, 0x33, 0x34, 0x36, 0x39, 0x31, 0x31, 0x65, 0x37, 0x39, 0x64, 0x64, 0x35, 0x30, 0x33, 0x30, 0x33, 0x63, 0x30, 0x31, 0x65, 0x30, 0x31, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x30, 0x33, 0x32, 0x38, 0x65, 0x66, 0x39, 0x37, 0x36, 0x32, 0x35, 0x66, 0x65, 0x37, 0x34, 0x35, 0x66, 0x61, 0x61, 0x34, 0x39, 0x65, 0x65, 0x30, 0x66, 0x39, 0x64, 0x34, 0x61, 0x61, 0x33, 0x62, 0x30, 0x64, 0x66, 0x62, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x61, 0x61, 0x63, 0x62, 0x38, 0x63, 0x62, 0x33, 0x30, 0x62, 0x61, 0x62, 0x32, 0x61, 0x65, 0x34, 0x61, 0x32, 0x34, 0x32, 0x34, 0x36, 0x32, 0x36, 0x65, 0x36, 0x65, 0x31, 0x32, 0x62, 0x30, 0x32, 0x64, 0x30, 0x34, 0x36, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x34, 0x34, 0x35, 0x39, 0x66, 0x61, 0x32, 0x66, 0x32, 0x31, 0x33, 0x31, 0x38, 0x65, 0x33, 0x34, 0x33, 0x34, 0x34, 0x34, 0x39, 0x37, 0x38, 0x39, 0x64, 0x38, 0x32, 0x36, 0x63, 0x64, 0x63, 0x31, 0x35, 0x37, 0x30, 0x63, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x34, 0x61, 0x34, 0x34, 0x63, 0x30, 0x36, 0x39, 0x33, 0x33, 0x39, 0x64, 0x30, 0x38, 0x65, 0x31, 0x39, 0x61, 0x37, 0x35, 0x36, 0x36, 0x38, 0x62, 0x64, 0x62, 0x61, 0x33, 0x30, 0x33, 0x62, 0x65, 0x38, 0x35, 0x35, 0x33, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x65, 0x35, 0x30, 0x31, 0x61, 0x61, 0x35, 0x37, 0x65, 0x61, 0x64, 0x37, 0x39, 0x32, 0x37, 0x38, 0x39, 0x33, 0x37, 0x63, 0x64, 0x36, 0x33, 0x30, 0x38, 0x63, 0x35, 0x63, 0x66, 0x61, 0x37, 0x61, 0x35, 0x36, 0x32, 0x39, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x34, 0x35, 0x62, 0x64, 0x35, 0x35, 0x64, 0x62, 0x39, 0x30, 0x36, 0x30, 0x65, 0x63, 0x65, 0x64, 0x39, 0x32, 0x33, 0x62, 0x62, 0x39, 0x63, 0x62, 0x37, 0x33, 0x33, 0x63, 0x62, 0x33, 0x35, 0x37, 0x33, 0x66, 0x62, 0x35, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x39, 0x66, 0x33, 0x62, 0x38, 0x61, 0x38, 0x31, 0x31, 0x62, 0x32, 0x31, 0x66, 0x33, 0x66, 0x66, 0x33, 0x66, 0x65, 0x32, 0x30, 0x66, 0x65, 0x39, 0x37, 0x30, 0x30, 0x35, 0x31, 0x63, 0x65, 0x36, 0x36, 0x61, 0x38, 0x32, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x35, 0x37, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x39, 0x61, 0x65, 0x63, 0x65, 0x39, 0x30, 0x35, 0x34, 0x31, 0x63, 0x61, 0x65, 0x32, 0x32, 0x34, 0x62, 0x38, 0x37, 0x64, 0x61, 0x36, 0x37, 0x33, 0x39, 0x36, 0x35, 0x65, 0x30, 0x61, 0x65, 0x62, 0x32, 0x39, 0x36, 0x61, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x36, 0x64, 0x63, 0x65, 0x31, 0x33, 0x33, 0x30, 0x63, 0x35, 0x39, 0x65, 0x66, 0x39, 0x32, 0x31, 0x36, 0x30, 0x32, 0x31, 0x35, 0x34, 0x35, 0x37, 0x32, 0x64, 0x34, 0x64, 0x34, 0x62, 0x61, 0x63, 0x62, 0x64, 0x30, 0x34, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x36, 0x33, 0x35, 0x33, 0x62, 0x39, 0x37, 0x31, 0x35, 0x38, 0x39, 0x66, 0x31, 0x38, 0x66, 0x32, 0x39, 0x35, 0x35, 0x63, 0x62, 0x61, 0x32, 0x38, 0x61, 0x62, 0x65, 0x38, 0x61, 0x63, 0x63, 0x65, 0x36, 0x61, 0x35, 0x37, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x63, 0x31, 0x30, 0x65, 0x62, 0x66, 0x32, 0x63, 0x34, 0x66, 0x39, 0x37, 0x63, 0x62, 0x61, 0x35, 0x61, 0x31, 0x61, 0x62, 0x33, 0x66, 0x32, 0x61, 0x61, 0x66, 0x65, 0x31, 0x63, 0x61, 0x63, 0x34, 0x32, 0x33, 0x66, 0x38, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x37, 0x37, 0x63, 0x33, 0x65, 0x34, 0x63, 0x34, 0x34, 0x35, 0x35, 0x38, 0x36, 0x65, 0x30, 0x39, 0x34, 0x63, 0x65, 0x31, 0x30, 0x32, 0x39, 0x33, 0x37, 0x66, 0x61, 0x30, 0x35, 0x62, 0x37, 0x33, 0x37, 0x62, 0x35, 0x36, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x33, 0x37, 0x31, 0x66, 0x39, 0x32, 0x61, 0x35, 0x36, 0x65, 0x61, 0x38, 0x33, 0x38, 0x31, 0x65, 0x34, 0x33, 0x30, 0x35, 0x39, 0x61, 0x39, 0x35, 0x31, 0x32, 0x38, 0x62, 0x64, 0x63, 0x34, 0x64, 0x34, 0x33, 0x63, 0x35, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x61, 0x36, 0x38, 0x38, 0x35, 0x30, 0x38, 0x33, 0x63, 0x38, 0x39, 0x39, 0x64, 0x61, 0x62, 0x62, 0x66, 0x35, 0x33, 0x30, 0x65, 0x64, 0x36, 0x63, 0x31, 0x32, 0x66, 0x34, 0x64, 0x64, 0x33, 0x61, 0x32, 0x30, 0x34, 0x63, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x62, 0x32, 0x63, 0x38, 0x35, 0x65, 0x33, 0x61, 0x65, 0x65, 0x65, 0x62, 0x62, 0x37, 0x30, 0x64, 0x36, 0x33, 0x63, 0x34, 0x61, 0x34, 0x37, 0x33, 0x30, 0x63, 0x65, 0x32, 0x65, 0x38, 0x65, 0x38, 0x38, 0x61, 0x33, 0x36, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x65, 0x34, 0x34, 0x30, 0x36, 0x38, 0x62, 0x38, 0x66, 0x34, 0x61, 0x33, 0x66, 0x65, 0x37, 0x39, 0x39, 0x65, 0x36, 0x61, 0x38, 0x33, 0x31, 0x31, 0x64, 0x62, 0x66, 0x64, 0x65, 0x64, 0x61, 0x32, 0x39, 0x64, 0x65, 0x65, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x61, 0x36, 0x33, 0x38, 0x38, 0x64, 0x34, 0x30, 0x32, 0x62, 0x33, 0x30, 0x61, 0x66, 0x65, 0x35, 0x39, 0x39, 0x33, 0x34, 0x63, 0x33, 0x62, 0x39, 0x65, 0x31, 0x33, 0x64, 0x31, 0x31, 0x38, 0x36, 0x34, 0x37, 0x36, 0x30, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x35, 0x31, 0x33, 0x35, 0x38, 0x63, 0x61, 0x34, 0x65, 0x30, 0x36, 0x30, 0x64, 0x64, 0x62, 0x35, 0x35, 0x39, 0x63, 0x61, 0x35, 0x38, 0x62, 0x63, 0x30, 0x62, 0x64, 0x64, 0x62, 0x65, 0x62, 0x34, 0x30, 0x37, 0x30, 0x32, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x65, 0x38, 0x36, 0x66, 0x33, 0x62, 0x35, 0x62, 0x33, 0x30, 0x63, 0x30, 0x62, 0x61, 0x35, 0x39, 0x66, 0x32, 0x62, 0x32, 0x65, 0x38, 0x35, 0x38, 0x34, 0x32, 0x35, 0x62, 0x61, 0x38, 0x39, 0x66, 0x30, 0x61, 0x31, 0x30, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x38, 0x65, 0x63, 0x37, 0x36, 0x62, 0x34, 0x34, 0x30, 0x64, 0x38, 0x38, 0x30, 0x37, 0x62, 0x33, 0x66, 0x37, 0x38, 0x62, 0x35, 0x66, 0x39, 0x30, 0x39, 0x37, 0x39, 0x62, 0x65, 0x65, 0x34, 0x32, 0x65, 0x64, 0x34, 0x33, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x34, 0x62, 0x30, 0x36, 0x35, 0x64, 0x62, 0x63, 0x62, 0x32, 0x33, 0x30, 0x34, 0x37, 0x32, 0x30, 0x33, 0x32, 0x36, 0x32, 0x66, 0x62, 0x34, 0x38, 0x63, 0x31, 0x31, 0x38, 0x38, 0x33, 0x36, 0x34, 0x39, 0x37, 0x37, 0x34, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x65, 0x32, 0x61, 0x64, 0x65, 0x62, 0x35, 0x34, 0x35, 0x65, 0x34, 0x39, 0x39, 0x64, 0x39, 0x38, 0x32, 0x63, 0x30, 0x63, 0x31, 0x31, 0x37, 0x33, 0x36, 0x33, 0x63, 0x65, 0x62, 0x34, 0x38, 0x39, 0x63, 0x35, 0x62, 0x31, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x32, 0x38, 0x66, 0x66, 0x37, 0x31, 0x35, 0x61, 0x66, 0x63, 0x33, 0x61, 0x32, 0x62, 0x36, 0x30, 0x66, 0x38, 0x65, 0x62, 0x34, 0x63, 0x63, 0x34, 0x62, 0x61, 0x34, 0x65, 0x65, 0x38, 0x64, 0x61, 0x62, 0x36, 0x65, 0x35, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x36, 0x31, 0x33, 0x30, 0x63, 0x37, 0x33, 0x63, 0x62, 0x39, 0x32, 0x31, 0x30, 0x32, 0x33, 0x38, 0x30, 0x32, 0x35, 0x63, 0x39, 0x64, 0x66, 0x39, 0x35, 0x64, 0x30, 0x62, 0x65, 0x35, 0x34, 0x61, 0x63, 0x36, 0x37, 0x66, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x64, 0x30, 0x33, 0x64, 0x34, 0x64, 0x66, 0x61, 0x62, 0x33, 0x35, 0x30, 0x30, 0x63, 0x66, 0x38, 0x39, 0x62, 0x38, 0x36, 0x38, 0x36, 0x36, 0x66, 0x31, 0x35, 0x64, 0x34, 0x35, 0x32, 0x38, 0x65, 0x31, 0x34, 0x61, 0x31, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x39, 0x33, 0x65, 0x35, 0x38, 0x33, 0x64, 0x36, 0x30, 0x37, 0x30, 0x35, 0x36, 0x33, 0x65, 0x37, 0x62, 0x38, 0x36, 0x32, 0x62, 0x39, 0x36, 0x31, 0x34, 0x61, 0x34, 0x37, 0x65, 0x39, 0x39, 0x34, 0x38, 0x39, 0x66, 0x33, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x66, 0x31, 0x34, 0x30, 0x62, 0x61, 0x37, 0x39, 0x36, 0x35, 0x38, 0x35, 0x64, 0x64, 0x35, 0x34, 0x38, 0x39, 0x33, 0x31, 0x35, 0x62, 0x63, 0x61, 0x34, 0x62, 0x62, 0x61, 0x36, 0x38, 0x30, 0x61, 0x64, 0x62, 0x62, 0x38, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x39, 0x65, 0x65, 0x66, 0x30, 0x61, 0x30, 0x38, 0x38, 0x36, 0x30, 0x35, 0x36, 0x65, 0x33, 0x66, 0x36, 0x39, 0x32, 0x31, 0x31, 0x38, 0x35, 0x33, 0x62, 0x39, 0x62, 0x37, 0x34, 0x35, 0x37, 0x66, 0x33, 0x37, 0x38, 0x32, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x32, 0x35, 0x35, 0x62, 0x37, 0x30, 0x30, 0x61, 0x65, 0x37, 0x31, 0x33, 0x38, 0x61, 0x34, 0x62, 0x61, 0x63, 0x66, 0x32, 0x32, 0x38, 0x38, 0x38, 0x61, 0x39, 0x65, 0x32, 0x63, 0x30, 0x30, 0x61, 0x32, 0x38, 0x35, 0x65, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x34, 0x37, 0x61, 0x34, 0x66, 0x66, 0x63, 0x39, 0x37, 0x39, 0x33, 0x36, 0x33, 0x32, 0x33, 0x32, 0x63, 0x39, 0x39, 0x62, 0x39, 0x39, 0x66, 0x61, 0x64, 0x61, 0x30, 0x66, 0x32, 0x37, 0x33, 0x34, 0x62, 0x30, 0x61, 0x65, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x31, 0x32, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x30, 0x36, 0x39, 0x31, 0x39, 0x37, 0x64, 0x31, 0x64, 0x65, 0x35, 0x30, 0x30, 0x34, 0x35, 0x61, 0x31, 0x38, 0x36, 0x66, 0x35, 0x65, 0x63, 0x37, 0x34, 0x34, 0x61, 0x63, 0x34, 0x30, 0x65, 0x38, 0x61, 0x66, 0x39, 0x31, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x31, 0x34, 0x38, 0x38, 0x32, 0x63, 0x39, 0x37, 0x39, 0x62, 0x62, 0x36, 0x34, 0x32, 0x61, 0x38, 0x30, 0x64, 0x64, 0x33, 0x38, 0x37, 0x35, 0x34, 0x64, 0x35, 0x62, 0x38, 0x63, 0x38, 0x32, 0x39, 0x36, 0x64, 0x39, 0x61, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x63, 0x30, 0x34, 0x37, 0x38, 0x36, 0x35, 0x37, 0x65, 0x31, 0x64, 0x33, 0x64, 0x31, 0x37, 0x61, 0x61, 0x61, 0x33, 0x33, 0x31, 0x64, 0x64, 0x34, 0x32, 0x39, 0x63, 0x65, 0x63, 0x66, 0x39, 0x31, 0x66, 0x38, 0x61, 0x65, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x39, 0x36, 0x31, 0x36, 0x63, 0x34, 0x37, 0x62, 0x34, 0x61, 0x36, 0x37, 0x66, 0x34, 0x30, 0x36, 0x62, 0x39, 0x35, 0x61, 0x31, 0x34, 0x66, 0x65, 0x36, 0x66, 0x63, 0x32, 0x36, 0x38, 0x33, 0x39, 0x36, 0x66, 0x31, 0x37, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x30, 0x61, 0x39, 0x39, 0x38, 0x61, 0x37, 0x31, 0x37, 0x62, 0x33, 0x33, 0x38, 0x64, 0x31, 0x64, 0x64, 0x39, 0x39, 0x38, 0x35, 0x34, 0x34, 0x30, 0x39, 0x62, 0x31, 0x61, 0x33, 0x33, 0x38, 0x64, 0x65, 0x65, 0x61, 0x34, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x65, 0x65, 0x39, 0x30, 0x35, 0x39, 0x35, 0x37, 0x66, 0x65, 0x37, 0x63, 0x63, 0x37, 0x30, 0x65, 0x63, 0x38, 0x66, 0x32, 0x38, 0x36, 0x38, 0x62, 0x34, 0x33, 0x66, 0x65, 0x34, 0x37, 0x62, 0x31, 0x33, 0x66, 0x65, 0x62, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x30, 0x31, 0x38, 0x61, 0x36, 0x39, 0x30, 0x61, 0x64, 0x36, 0x37, 0x34, 0x36, 0x64, 0x62, 0x65, 0x33, 0x61, 0x63, 0x66, 0x39, 0x37, 0x31, 0x32, 0x64, 0x64, 0x63, 0x61, 0x35, 0x32, 0x62, 0x36, 0x32, 0x35, 0x30, 0x30, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x31, 0x38, 0x35, 0x35, 0x37, 0x64, 0x36, 0x30, 0x30, 0x64, 0x30, 0x35, 0x63, 0x32, 0x66, 0x63, 0x62, 0x66, 0x33, 0x38, 0x30, 0x36, 0x66, 0x66, 0x62, 0x64, 0x39, 0x33, 0x64, 0x30, 0x32, 0x30, 0x32, 0x35, 0x64, 0x37, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x66, 0x35, 0x63, 0x39, 0x63, 0x37, 0x33, 0x36, 0x35, 0x30, 0x63, 0x66, 0x62, 0x62, 0x64, 0x65, 0x35, 0x63, 0x38, 0x38, 0x35, 0x35, 0x33, 0x31, 0x64, 0x34, 0x32, 0x37, 0x63, 0x37, 0x63, 0x33, 0x66, 0x65, 0x35, 0x35, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x61, 0x33, 0x39, 0x36, 0x64, 0x63, 0x64, 0x61, 0x62, 0x32, 0x63, 0x37, 0x34, 0x39, 0x34, 0x31, 0x33, 0x30, 0x62, 0x33, 0x66, 0x64, 0x33, 0x30, 0x37, 0x38, 0x32, 0x30, 0x33, 0x34, 0x30, 0x64, 0x66, 0x64, 0x38, 0x63, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x38, 0x65, 0x30, 0x36, 0x31, 0x38, 0x39, 0x32, 0x61, 0x35, 0x64, 0x63, 0x63, 0x65, 0x32, 0x31, 0x39, 0x36, 0x36, 0x61, 0x65, 0x31, 0x62, 0x62, 0x30, 0x37, 0x38, 0x38, 0x66, 0x64, 0x33, 0x65, 0x38, 0x62, 0x61, 0x30, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x33, 0x34, 0x62, 0x32, 0x34, 0x35, 0x33, 0x34, 0x37, 0x31, 0x66, 0x33, 0x32, 0x34, 0x66, 0x62, 0x32, 0x36, 0x62, 0x65, 0x35, 0x62, 0x32, 0x35, 0x31, 0x36, 0x36, 0x62, 0x35, 0x62, 0x35, 0x37, 0x32, 0x36, 0x30, 0x32, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x66, 0x32, 0x32, 0x31, 0x31, 0x35, 0x39, 0x35, 0x31, 0x38, 0x37, 0x38, 0x33, 0x62, 0x63, 0x34, 0x61, 0x37, 0x30, 0x36, 0x36, 0x37, 0x36, 0x66, 0x63, 0x34, 0x66, 0x33, 0x63, 0x35, 0x65, 0x65, 0x34, 0x30, 0x35, 0x38, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x35, 0x36, 0x64, 0x34, 0x62, 0x64, 0x36, 0x62, 0x66, 0x33, 0x63, 0x62, 0x61, 0x63, 0x61, 0x63, 0x36, 0x35, 0x66, 0x38, 0x66, 0x35, 0x61, 0x30, 0x65, 0x33, 0x39, 0x38, 0x30, 0x62, 0x38, 0x35, 0x32, 0x37, 0x34, 0x30, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x30, 0x35, 0x33, 0x36, 0x37, 0x39, 0x34, 0x61, 0x39, 0x65, 0x32, 0x62, 0x30, 0x30, 0x34, 0x39, 0x64, 0x31, 0x30, 0x32, 0x33, 0x33, 0x63, 0x34, 0x31, 0x61, 0x64, 0x63, 0x35, 0x66, 0x34, 0x31, 0x38, 0x61, 0x32, 0x36, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x39, 0x65, 0x30, 0x65, 0x63, 0x36, 0x37, 0x38, 0x38, 0x66, 0x37, 0x64, 0x66, 0x34, 0x63, 0x37, 0x66, 0x63, 0x32, 0x31, 0x30, 0x61, 0x61, 0x63, 0x64, 0x32, 0x32, 0x30, 0x63, 0x32, 0x37, 0x65, 0x34, 0x35, 0x63, 0x39, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x62, 0x63, 0x62, 0x38, 0x65, 0x37, 0x66, 0x37, 0x33, 0x63, 0x64, 0x61, 0x33, 0x64, 0x37, 0x33, 0x66, 0x34, 0x64, 0x33, 0x38, 0x62, 0x32, 0x64, 0x30, 0x38, 0x34, 0x37, 0x65, 0x36, 0x30, 0x30, 0x62, 0x61, 0x30, 0x64, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x36, 0x31, 0x64, 0x34, 0x38, 0x34, 0x36, 0x66, 0x61, 0x66, 0x62, 0x33, 0x37, 0x37, 0x62, 0x36, 0x63, 0x30, 0x65, 0x65, 0x34, 0x39, 0x61, 0x35, 0x39, 0x36, 0x61, 0x37, 0x38, 0x64, 0x64, 0x66, 0x33, 0x35, 0x31, 0x36, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x63, 0x33, 0x63, 0x32, 0x33, 0x36, 0x37, 0x35, 0x33, 0x34, 0x64, 0x31, 0x33, 0x62, 0x61, 0x32, 0x62, 0x33, 0x33, 0x66, 0x31, 0x38, 0x35, 0x63, 0x64, 0x62, 0x65, 0x36, 0x61, 0x63, 0x34, 0x33, 0x63, 0x32, 0x66, 0x61, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x63, 0x36, 0x66, 0x34, 0x35, 0x66, 0x65, 0x66, 0x32, 0x36, 0x62, 0x30, 0x36, 0x65, 0x33, 0x33, 0x30, 0x32, 0x33, 0x31, 0x33, 0x66, 0x38, 0x38, 0x34, 0x64, 0x61, 0x66, 0x34, 0x38, 0x65, 0x32, 0x37, 0x34, 0x36, 0x66, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x34, 0x31, 0x34, 0x64, 0x32, 0x39, 0x63, 0x62, 0x37, 0x65, 0x65, 0x39, 0x37, 0x33, 0x66, 0x65, 0x63, 0x35, 0x34, 0x65, 0x32, 0x32, 0x61, 0x33, 0x38, 0x38, 0x34, 0x39, 0x31, 0x37, 0x38, 0x36, 0x63, 0x66, 0x35, 0x34, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x32, 0x64, 0x63, 0x33, 0x63, 0x34, 0x66, 0x66, 0x32, 0x64, 0x37, 0x64, 0x39, 0x32, 0x35, 0x65, 0x65, 0x32, 0x38, 0x35, 0x39, 0x66, 0x34, 0x61, 0x30, 0x36, 0x64, 0x37, 0x62, 0x61, 0x36, 0x30, 0x66, 0x31, 0x33, 0x30, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x65, 0x64, 0x32, 0x63, 0x65, 0x35, 0x33, 0x31, 0x63, 0x30, 0x35, 0x36, 0x62, 0x30, 0x30, 0x39, 0x37, 0x65, 0x66, 0x63, 0x33, 0x63, 0x36, 0x64, 0x65, 0x31, 0x30, 0x63, 0x34, 0x37, 0x36, 0x32, 0x30, 0x30, 0x34, 0x65, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x37, 0x38, 0x32, 0x66, 0x66, 0x65, 0x30, 0x36, 0x61, 0x63, 0x37, 0x38, 0x38, 0x32, 0x32, 0x61, 0x33, 0x63, 0x33, 0x61, 0x38, 0x61, 0x66, 0x65, 0x33, 0x30, 0x35, 0x65, 0x35, 0x30, 0x61, 0x35, 0x36, 0x31, 0x38, 0x38, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x37, 0x33, 0x38, 0x33, 0x33, 0x64, 0x65, 0x34, 0x62, 0x38, 0x31, 0x30, 0x62, 0x62, 0x30, 0x32, 0x37, 0x38, 0x31, 0x30, 0x66, 0x63, 0x38, 0x66, 0x36, 0x39, 0x66, 0x35, 0x34, 0x34, 0x65, 0x38, 0x33, 0x63, 0x31, 0x32, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x35, 0x31, 0x61, 0x34, 0x63, 0x63, 0x36, 0x32, 0x30, 0x31, 0x31, 0x33, 0x32, 0x32, 0x63, 0x36, 0x39, 0x36, 0x66, 0x64, 0x37, 0x32, 0x35, 0x62, 0x39, 0x66, 0x62, 0x38, 0x66, 0x35, 0x33, 0x66, 0x65, 0x61, 0x61, 0x61, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x32, 0x39, 0x38, 0x63, 0x63, 0x62, 0x64, 0x66, 0x66, 0x36, 0x38, 0x39, 0x66, 0x38, 0x37, 0x66, 0x65, 0x34, 0x31, 0x61, 0x61, 0x36, 0x65, 0x39, 0x38, 0x66, 0x64, 0x66, 0x62, 0x35, 0x33, 0x64, 0x65, 0x61, 0x66, 0x33, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x37, 0x35, 0x33, 0x31, 0x61, 0x36, 0x63, 0x35, 0x38, 0x31, 0x37, 0x61, 0x65, 0x33, 0x35, 0x66, 0x38, 0x32, 0x62, 0x30, 0x30, 0x62, 0x39, 0x37, 0x35, 0x34, 0x66, 0x63, 0x66, 0x37, 0x34, 0x63, 0x35, 0x35, 0x65, 0x32, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x35, 0x38, 0x31, 0x61, 0x36, 0x30, 0x62, 0x36, 0x31, 0x30, 0x32, 0x38, 0x64, 0x39, 0x33, 0x34, 0x31, 0x36, 0x37, 0x39, 0x32, 0x39, 0x62, 0x32, 0x32, 0x64, 0x37, 0x30, 0x62, 0x33, 0x31, 0x33, 0x63, 0x33, 0x34, 0x66, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x30, 0x37, 0x37, 0x64, 0x62, 0x31, 0x33, 0x66, 0x66, 0x65, 0x62, 0x30, 0x39, 0x34, 0x38, 0x34, 0x63, 0x32, 0x31, 0x37, 0x37, 0x30, 0x39, 0x64, 0x35, 0x38, 0x38, 0x36, 0x62, 0x38, 0x62, 0x66, 0x39, 0x63, 0x35, 0x61, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x62, 0x37, 0x61, 0x35, 0x37, 0x30, 0x33, 0x33, 0x66, 0x38, 0x66, 0x31, 0x31, 0x33, 0x33, 0x30, 0x65, 0x34, 0x36, 0x36, 0x35, 0x65, 0x31, 0x38, 0x35, 0x64, 0x32, 0x33, 0x34, 0x65, 0x38, 0x33, 0x65, 0x63, 0x31, 0x34, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x36, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x66, 0x35, 0x32, 0x33, 0x66, 0x31, 0x31, 0x37, 0x62, 0x63, 0x39, 0x66, 0x65, 0x39, 0x37, 0x38, 0x61, 0x61, 0x34, 0x38, 0x31, 0x65, 0x62, 0x34, 0x66, 0x35, 0x35, 0x36, 0x31, 0x37, 0x31, 0x31, 0x33, 0x37, 0x31, 0x62, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x34, 0x32, 0x66, 0x63, 0x64, 0x32, 0x34, 0x63, 0x65, 0x34, 0x32, 0x33, 0x39, 0x33, 0x38, 0x33, 0x33, 0x30, 0x34, 0x33, 0x36, 0x37, 0x35, 0x39, 0x35, 0x66, 0x30, 0x36, 0x38, 0x66, 0x30, 0x63, 0x36, 0x31, 0x30, 0x37, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x34, 0x36, 0x64, 0x33, 0x35, 0x33, 0x37, 0x37, 0x37, 0x31, 0x37, 0x36, 0x66, 0x66, 0x38, 0x65, 0x38, 0x33, 0x66, 0x66, 0x61, 0x38, 0x30, 0x30, 0x31, 0x66, 0x34, 0x66, 0x37, 0x30, 0x66, 0x39, 0x37, 0x33, 0x33, 0x61, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x65, 0x34, 0x33, 0x39, 0x32, 0x38, 0x31, 0x36, 0x65, 0x35, 0x66, 0x32, 0x65, 0x66, 0x35, 0x66, 0x62, 0x36, 0x35, 0x38, 0x33, 0x37, 0x63, 0x65, 0x63, 0x32, 0x63, 0x32, 0x33, 0x32, 0x35, 0x63, 0x63, 0x36, 0x34, 0x39, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x33, 0x64, 0x61, 0x36, 0x35, 0x30, 0x32, 0x33, 0x61, 0x31, 0x33, 0x30, 0x32, 0x30, 0x64, 0x32, 0x32, 0x31, 0x34, 0x35, 0x63, 0x66, 0x63, 0x31, 0x38, 0x62, 0x61, 0x62, 0x31, 0x30, 0x62, 0x64, 0x31, 0x39, 0x63, 0x65, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x36, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x30, 0x38, 0x35, 0x64, 0x34, 0x33, 0x65, 0x63, 0x39, 0x32, 0x34, 0x31, 0x34, 0x65, 0x61, 0x32, 0x37, 0x62, 0x39, 0x31, 0x34, 0x66, 0x65, 0x37, 0x36, 0x37, 0x62, 0x36, 0x64, 0x34, 0x36, 0x62, 0x31, 0x65, 0x65, 0x66, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x32, 0x33, 0x36, 0x37, 0x66, 0x38, 0x34, 0x39, 0x34, 0x62, 0x35, 0x66, 0x65, 0x31, 0x38, 0x64, 0x36, 0x38, 0x33, 0x63, 0x30, 0x35, 0x35, 0x64, 0x38, 0x39, 0x39, 0x39, 0x39, 0x63, 0x39, 0x66, 0x33, 0x64, 0x31, 0x62, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x32, 0x34, 0x34, 0x66, 0x63, 0x39, 0x35, 0x61, 0x36, 0x39, 0x35, 0x37, 0x65, 0x64, 0x37, 0x63, 0x31, 0x35, 0x30, 0x34, 0x65, 0x34, 0x39, 0x66, 0x33, 0x30, 0x62, 0x38, 0x63, 0x33, 0x35, 0x65, 0x63, 0x61, 0x34, 0x62, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x30, 0x33, 0x31, 0x62, 0x30, 0x61, 0x37, 0x32, 0x34, 0x34, 0x37, 0x31, 0x64, 0x34, 0x37, 0x36, 0x66, 0x33, 0x62, 0x63, 0x64, 0x32, 0x65, 0x62, 0x30, 0x37, 0x38, 0x33, 0x33, 0x38, 0x62, 0x66, 0x36, 0x37, 0x66, 0x62, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x65, 0x35, 0x63, 0x63, 0x36, 0x31, 0x32, 0x37, 0x63, 0x34, 0x66, 0x38, 0x38, 0x35, 0x62, 0x65, 0x30, 0x32, 0x66, 0x34, 0x34, 0x62, 0x34, 0x32, 0x64, 0x31, 0x63, 0x38, 0x62, 0x30, 0x61, 0x63, 0x39, 0x31, 0x65, 0x34, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x31, 0x63, 0x65, 0x61, 0x37, 0x62, 0x34, 0x35, 0x64, 0x31, 0x62, 0x64, 0x34, 0x64, 0x30, 0x65, 0x32, 0x61, 0x30, 0x30, 0x37, 0x62, 0x64, 0x33, 0x62, 0x66, 0x62, 0x33, 0x35, 0x34, 0x37, 0x35, 0x39, 0x65, 0x32, 0x63, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x66, 0x65, 0x61, 0x66, 0x31, 0x32, 0x34, 0x35, 0x37, 0x39, 0x35, 0x32, 0x33, 0x39, 0x35, 0x34, 0x36, 0x34, 0x35, 0x62, 0x37, 0x66, 0x61, 0x66, 0x66, 0x66, 0x30, 0x33, 0x37, 0x38, 0x64, 0x31, 0x63, 0x38, 0x32, 0x34, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x30, 0x37, 0x64, 0x34, 0x32, 0x64, 0x38, 0x33, 0x31, 0x63, 0x32, 0x64, 0x37, 0x63, 0x38, 0x33, 0x38, 0x61, 0x61, 0x31, 0x38, 0x37, 0x32, 0x62, 0x33, 0x61, 0x64, 0x35, 0x64, 0x32, 0x37, 0x37, 0x31, 0x37, 0x36, 0x38, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x33, 0x37, 0x64, 0x63, 0x31, 0x32, 0x37, 0x32, 0x33, 0x64, 0x39, 0x63, 0x37, 0x38, 0x35, 0x38, 0x38, 0x35, 0x34, 0x32, 0x65, 0x61, 0x62, 0x30, 0x38, 0x32, 0x36, 0x36, 0x34, 0x66, 0x33, 0x66, 0x30, 0x33, 0x38, 0x64, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x34, 0x62, 0x35, 0x35, 0x62, 0x35, 0x32, 0x35, 0x66, 0x31, 0x30, 0x33, 0x39, 0x65, 0x37, 0x34, 0x34, 0x62, 0x39, 0x31, 0x38, 0x63, 0x62, 0x33, 0x33, 0x33, 0x32, 0x34, 0x39, 0x32, 0x65, 0x34, 0x35, 0x65, 0x63, 0x61, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x64, 0x36, 0x62, 0x30, 0x31, 0x62, 0x39, 0x34, 0x64, 0x38, 0x35, 0x34, 0x66, 0x65, 0x38, 0x62, 0x33, 0x37, 0x34, 0x61, 0x61, 0x36, 0x35, 0x65, 0x38, 0x39, 0x35, 0x63, 0x66, 0x32, 0x32, 0x61, 0x61, 0x32, 0x35, 0x36, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x36, 0x31, 0x64, 0x39, 0x34, 0x30, 0x63, 0x33, 0x37, 0x36, 0x30, 0x31, 0x30, 0x30, 0x62, 0x39, 0x30, 0x38, 0x30, 0x35, 0x32, 0x39, 0x66, 0x38, 0x61, 0x36, 0x30, 0x33, 0x32, 0x35, 0x30, 0x33, 0x30, 0x66, 0x36, 0x65, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x30, 0x65, 0x65, 0x39, 0x61, 0x31, 0x32, 0x62, 0x34, 0x64, 0x36, 0x38, 0x61, 0x62, 0x61, 0x63, 0x65, 0x36, 0x62, 0x61, 0x63, 0x61, 0x39, 0x61, 0x64, 0x37, 0x62, 0x66, 0x35, 0x63, 0x64, 0x31, 0x66, 0x61, 0x66, 0x39, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x39, 0x39, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x37, 0x39, 0x34, 0x39, 0x65, 0x31, 0x63, 0x61, 0x30, 0x35, 0x37, 0x30, 0x34, 0x36, 0x39, 0x65, 0x34, 0x63, 0x65, 0x33, 0x63, 0x36, 0x39, 0x30, 0x61, 0x65, 0x36, 0x31, 0x33, 0x61, 0x36, 0x62, 0x30, 0x31, 0x63, 0x35, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x66, 0x38, 0x65, 0x32, 0x36, 0x66, 0x34, 0x63, 0x32, 0x37, 0x39, 0x30, 0x64, 0x61, 0x36, 0x35, 0x33, 0x33, 0x61, 0x32, 0x61, 0x63, 0x39, 0x61, 0x62, 0x61, 0x63, 0x33, 0x63, 0x36, 0x39, 0x61, 0x31, 0x39, 0x39, 0x34, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x66, 0x65, 0x63, 0x36, 0x32, 0x63, 0x32, 0x63, 0x34, 0x32, 0x35, 0x65, 0x32, 0x31, 0x39, 0x62, 0x31, 0x38, 0x34, 0x34, 0x38, 0x61, 0x64, 0x37, 0x35, 0x37, 0x30, 0x30, 0x39, 0x64, 0x38, 0x63, 0x35, 0x34, 0x30, 0x32, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x62, 0x66, 0x65, 0x39, 0x33, 0x63, 0x63, 0x64, 0x61, 0x37, 0x35, 0x30, 0x38, 0x34, 0x37, 0x65, 0x34, 0x31, 0x61, 0x31, 0x61, 0x66, 0x66, 0x65, 0x65, 0x36, 0x62, 0x32, 0x64, 0x61, 0x39, 0x36, 0x65, 0x37, 0x32, 0x31, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x34, 0x38, 0x34, 0x31, 0x34, 0x64, 0x32, 0x61, 0x63, 0x34, 0x64, 0x34, 0x32, 0x61, 0x35, 0x39, 0x36, 0x32, 0x66, 0x32, 0x39, 0x65, 0x65, 0x65, 0x34, 0x34, 0x39, 0x37, 0x30, 0x39, 0x32, 0x66, 0x34, 0x33, 0x31, 0x33, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x62, 0x64, 0x64, 0x64, 0x31, 0x62, 0x62, 0x64, 0x33, 0x38, 0x66, 0x66, 0x61, 0x64, 0x65, 0x30, 0x33, 0x30, 0x35, 0x64, 0x33, 0x30, 0x66, 0x30, 0x32, 0x30, 0x32, 0x38, 0x64, 0x39, 0x32, 0x65, 0x39, 0x66, 0x33, 0x61, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x63, 0x30, 0x31, 0x31, 0x34, 0x32, 0x39, 0x30, 0x37, 0x61, 0x63, 0x62, 0x31, 0x35, 0x36, 0x35, 0x66, 0x37, 0x30, 0x34, 0x33, 0x38, 0x62, 0x39, 0x39, 0x38, 0x30, 0x61, 0x65, 0x37, 0x33, 0x31, 0x38, 0x31, 0x38, 0x37, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x66, 0x63, 0x34, 0x39, 0x63, 0x31, 0x37, 0x38, 0x37, 0x65, 0x65, 0x62, 0x62, 0x32, 0x62, 0x35, 0x36, 0x63, 0x61, 0x62, 0x65, 0x39, 0x32, 0x34, 0x30, 0x34, 0x62, 0x36, 0x33, 0x36, 0x31, 0x34, 0x37, 0x64, 0x34, 0x35, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x37, 0x39, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x39, 0x65, 0x65, 0x65, 0x63, 0x65, 0x33, 0x39, 0x66, 0x61, 0x37, 0x65, 0x66, 0x35, 0x30, 0x37, 0x36, 0x64, 0x38, 0x35, 0x35, 0x30, 0x36, 0x31, 0x33, 0x38, 0x34, 0x30, 0x30, 0x39, 0x37, 0x39, 0x32, 0x63, 0x66, 0x32, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x62, 0x36, 0x61, 0x37, 0x39, 0x30, 0x30, 0x30, 0x39, 0x62, 0x63, 0x31, 0x36, 0x36, 0x34, 0x32, 0x63, 0x38, 0x64, 0x38, 0x32, 0x30, 0x62, 0x37, 0x63, 0x64, 0x65, 0x30, 0x65, 0x39, 0x66, 0x64, 0x31, 0x36, 0x64, 0x38, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x62, 0x34, 0x31, 0x62, 0x35, 0x31, 0x66, 0x34, 0x31, 0x64, 0x66, 0x32, 0x30, 0x64, 0x64, 0x32, 0x37, 0x39, 0x62, 0x61, 0x65, 0x31, 0x38, 0x63, 0x31, 0x32, 0x37, 0x37, 0x35, 0x66, 0x37, 0x37, 0x61, 0x64, 0x37, 0x37, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x37, 0x64, 0x33, 0x31, 0x33, 0x66, 0x64, 0x33, 0x36, 0x62, 0x30, 0x35, 0x33, 0x65, 0x65, 0x65, 0x61, 0x65, 0x64, 0x62, 0x63, 0x65, 0x37, 0x34, 0x62, 0x39, 0x66, 0x62, 0x30, 0x36, 0x37, 0x38, 0x33, 0x33, 0x33, 0x32, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x64, 0x32, 0x39, 0x37, 0x30, 0x66, 0x34, 0x39, 0x64, 0x63, 0x63, 0x38, 0x31, 0x65, 0x61, 0x39, 0x65, 0x65, 0x37, 0x30, 0x37, 0x65, 0x39, 0x63, 0x38, 0x61, 0x30, 0x61, 0x62, 0x32, 0x61, 0x38, 0x62, 0x62, 0x37, 0x34, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x30, 0x61, 0x63, 0x61, 0x35, 0x30, 0x38, 0x62, 0x33, 0x63, 0x61, 0x66, 0x35, 0x65, 0x65, 0x30, 0x32, 0x38, 0x62, 0x63, 0x37, 0x30, 0x37, 0x64, 0x64, 0x31, 0x65, 0x38, 0x30, 0x30, 0x62, 0x38, 0x33, 0x38, 0x66, 0x34, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x34, 0x36, 0x33, 0x32, 0x65, 0x66, 0x62, 0x64, 0x36, 0x34, 0x32, 0x63, 0x30, 0x34, 0x64, 0x65, 0x36, 0x63, 0x61, 0x33, 0x34, 0x32, 0x33, 0x31, 0x35, 0x64, 0x34, 0x30, 0x64, 0x64, 0x39, 0x30, 0x61, 0x32, 0x64, 0x62, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x38, 0x31, 0x30, 0x66, 0x66, 0x39, 0x64, 0x32, 0x31, 0x33, 0x61, 0x32, 0x37, 0x31, 0x65, 0x64, 0x61, 0x32, 0x62, 0x38, 0x61, 0x61, 0x37, 0x39, 0x38, 0x62, 0x65, 0x36, 0x35, 0x34, 0x66, 0x61, 0x34, 0x62, 0x62, 0x65, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x30, 0x38, 0x38, 0x30, 0x30, 0x36, 0x63, 0x36, 0x34, 0x62, 0x33, 0x30, 0x63, 0x34, 0x64, 0x64, 0x61, 0x66, 0x62, 0x63, 0x33, 0x36, 0x63, 0x62, 0x35, 0x66, 0x30, 0x35, 0x34, 0x36, 0x39, 0x65, 0x62, 0x36, 0x32, 0x38, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x38, 0x64, 0x66, 0x33, 0x31, 0x38, 0x35, 0x36, 0x36, 0x39, 0x39, 0x62, 0x62, 0x35, 0x61, 0x63, 0x66, 0x63, 0x31, 0x66, 0x65, 0x31, 0x64, 0x36, 0x38, 0x30, 0x64, 0x66, 0x39, 0x39, 0x36, 0x30, 0x63, 0x61, 0x34, 0x33, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x38, 0x65, 0x33, 0x66, 0x39, 0x33, 0x35, 0x37, 0x65, 0x33, 0x30, 0x33, 0x35, 0x31, 0x33, 0x38, 0x34, 0x31, 0x62, 0x33, 0x66, 0x38, 0x34, 0x62, 0x64, 0x61, 0x38, 0x33, 0x66, 0x63, 0x38, 0x39, 0x37, 0x32, 0x37, 0x35, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x33, 0x65, 0x66, 0x36, 0x35, 0x32, 0x65, 0x37, 0x62, 0x37, 0x36, 0x39, 0x66, 0x35, 0x33, 0x64, 0x36, 0x65, 0x37, 0x38, 0x36, 0x61, 0x35, 0x38, 0x39, 0x35, 0x32, 0x66, 0x61, 0x39, 0x33, 0x65, 0x65, 0x36, 0x61, 0x62, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x36, 0x30, 0x61, 0x30, 0x35, 0x66, 0x37, 0x61, 0x34, 0x61, 0x35, 0x66, 0x38, 0x63, 0x66, 0x32, 0x37, 0x38, 0x34, 0x33, 0x39, 0x31, 0x33, 0x36, 0x32, 0x65, 0x37, 0x35, 0x35, 0x61, 0x38, 0x33, 0x34, 0x31, 0x65, 0x66, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x39, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x36, 0x62, 0x32, 0x36, 0x66, 0x34, 0x33, 0x38, 0x64, 0x39, 0x61, 0x33, 0x35, 0x32, 0x34, 0x34, 0x39, 0x31, 0x35, 0x35, 0x62, 0x38, 0x38, 0x37, 0x36, 0x63, 0x62, 0x64, 0x31, 0x37, 0x63, 0x39, 0x64, 0x39, 0x39, 0x62, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x66, 0x37, 0x31, 0x39, 0x61, 0x65, 0x33, 0x34, 0x32, 0x62, 0x64, 0x37, 0x66, 0x65, 0x66, 0x31, 0x38, 0x61, 0x30, 0x35, 0x63, 0x62, 0x62, 0x30, 0x32, 0x66, 0x37, 0x30, 0x35, 0x61, 0x64, 0x33, 0x38, 0x65, 0x64, 0x35, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x63, 0x61, 0x38, 0x64, 0x39, 0x35, 0x36, 0x36, 0x30, 0x38, 0x66, 0x39, 0x65, 0x30, 0x30, 0x61, 0x32, 0x66, 0x39, 0x39, 0x37, 0x34, 0x30, 0x32, 0x38, 0x36, 0x34, 0x30, 0x38, 0x38, 0x38, 0x34, 0x36, 0x35, 0x36, 0x36, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x61, 0x66, 0x33, 0x31, 0x36, 0x62, 0x38, 0x37, 0x36, 0x31, 0x35, 0x64, 0x38, 0x38, 0x66, 0x37, 0x61, 0x64, 0x63, 0x37, 0x37, 0x63, 0x35, 0x38, 0x65, 0x37, 0x31, 0x32, 0x65, 0x64, 0x34, 0x64, 0x37, 0x37, 0x39, 0x36, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x31, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x30, 0x34, 0x31, 0x32, 0x62, 0x66, 0x65, 0x64, 0x63, 0x64, 0x39, 0x36, 0x34, 0x65, 0x38, 0x33, 0x37, 0x64, 0x30, 0x39, 0x32, 0x63, 0x37, 0x31, 0x61, 0x35, 0x66, 0x63, 0x62, 0x61, 0x66, 0x33, 0x30, 0x31, 0x32, 0x36, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x37, 0x31, 0x66, 0x37, 0x32, 0x65, 0x65, 0x62, 0x33, 0x30, 0x30, 0x36, 0x32, 0x34, 0x65, 0x62, 0x32, 0x38, 0x32, 0x65, 0x61, 0x62, 0x34, 0x64, 0x30, 0x33, 0x37, 0x32, 0x33, 0x63, 0x36, 0x34, 0x39, 0x62, 0x31, 0x62, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x66, 0x37, 0x31, 0x66, 0x37, 0x66, 0x62, 0x35, 0x33, 0x37, 0x61, 0x63, 0x35, 0x34, 0x66, 0x34, 0x65, 0x35, 0x31, 0x34, 0x39, 0x34, 0x37, 0x66, 0x61, 0x37, 0x66, 0x66, 0x36, 0x37, 0x32, 0x38, 0x66, 0x31, 0x36, 0x64, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x39, 0x38, 0x63, 0x37, 0x37, 0x34, 0x63, 0x32, 0x30, 0x63, 0x61, 0x31, 0x64, 0x61, 0x61, 0x63, 0x35, 0x64, 0x64, 0x62, 0x36, 0x32, 0x30, 0x33, 0x36, 0x35, 0x33, 0x31, 0x36, 0x64, 0x33, 0x35, 0x33, 0x66, 0x31, 0x30, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x64, 0x38, 0x64, 0x37, 0x61, 0x31, 0x61, 0x33, 0x34, 0x66, 0x61, 0x31, 0x66, 0x38, 0x65, 0x37, 0x33, 0x63, 0x63, 0x62, 0x30, 0x30, 0x35, 0x66, 0x63, 0x32, 0x61, 0x30, 0x33, 0x61, 0x31, 0x35, 0x62, 0x38, 0x32, 0x32, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x35, 0x31, 0x66, 0x61, 0x35, 0x64, 0x31, 0x37, 0x61, 0x32, 0x64, 0x63, 0x65, 0x32, 0x64, 0x37, 0x66, 0x31, 0x65, 0x62, 0x33, 0x39, 0x65, 0x66, 0x37, 0x66, 0x65, 0x32, 0x61, 0x64, 0x32, 0x31, 0x33, 0x64, 0x35, 0x64, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x36, 0x36, 0x32, 0x38, 0x33, 0x35, 0x32, 0x65, 0x64, 0x33, 0x33, 0x39, 0x30, 0x62, 0x61, 0x66, 0x61, 0x38, 0x36, 0x64, 0x39, 0x32, 0x33, 0x65, 0x35, 0x36, 0x30, 0x31, 0x34, 0x63, 0x66, 0x63, 0x62, 0x33, 0x36, 0x30, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x61, 0x66, 0x32, 0x34, 0x35, 0x39, 0x61, 0x39, 0x33, 0x64, 0x30, 0x62, 0x33, 0x66, 0x34, 0x64, 0x30, 0x36, 0x32, 0x36, 0x33, 0x36, 0x32, 0x33, 0x36, 0x63, 0x64, 0x34, 0x62, 0x32, 0x39, 0x65, 0x33, 0x62, 0x63, 0x65, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x65, 0x32, 0x61, 0x62, 0x62, 0x36, 0x33, 0x62, 0x30, 0x36, 0x30, 0x34, 0x34, 0x30, 0x39, 0x66, 0x62, 0x64, 0x65, 0x33, 0x65, 0x37, 0x31, 0x36, 0x64, 0x32, 0x38, 0x37, 0x36, 0x64, 0x34, 0x34, 0x65, 0x38, 0x65, 0x35, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x31, 0x30, 0x64, 0x63, 0x64, 0x30, 0x39, 0x62, 0x38, 0x31, 0x30, 0x31, 0x66, 0x39, 0x34, 0x33, 0x37, 0x62, 0x64, 0x39, 0x37, 0x64, 0x62, 0x39, 0x30, 0x61, 0x37, 0x33, 0x65, 0x66, 0x39, 0x39, 0x33, 0x64, 0x30, 0x62, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x33, 0x65, 0x65, 0x34, 0x33, 0x38, 0x64, 0x38, 0x33, 0x64, 0x65, 0x39, 0x61, 0x33, 0x37, 0x35, 0x36, 0x32, 0x62, 0x62, 0x34, 0x65, 0x32, 0x38, 0x36, 0x63, 0x62, 0x31, 0x62, 0x64, 0x31, 0x39, 0x66, 0x34, 0x39, 0x36, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x33, 0x37, 0x37, 0x39, 0x64, 0x31, 0x34, 0x61, 0x31, 0x33, 0x66, 0x36, 0x63, 0x37, 0x38, 0x35, 0x36, 0x36, 0x62, 0x63, 0x64, 0x65, 0x34, 0x30, 0x33, 0x35, 0x39, 0x31, 0x34, 0x31, 0x33, 0x61, 0x36, 0x32, 0x33, 0x39, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x30, 0x34, 0x66, 0x31, 0x36, 0x39, 0x65, 0x30, 0x64, 0x30, 0x62, 0x33, 0x36, 0x62, 0x35, 0x37, 0x62, 0x62, 0x63, 0x33, 0x39, 0x66, 0x33, 0x63, 0x34, 0x35, 0x34, 0x33, 0x37, 0x62, 0x35, 0x65, 0x65, 0x33, 0x64, 0x32, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x38, 0x34, 0x34, 0x32, 0x33, 0x30, 0x35, 0x30, 0x65, 0x33, 0x63, 0x32, 0x30, 0x35, 0x31, 0x66, 0x30, 0x62, 0x62, 0x64, 0x38, 0x66, 0x34, 0x34, 0x62, 0x64, 0x36, 0x64, 0x62, 0x63, 0x32, 0x37, 0x65, 0x63, 0x62, 0x36, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x33, 0x31, 0x35, 0x64, 0x39, 0x30, 0x31, 0x36, 0x65, 0x38, 0x65, 0x65, 0x35, 0x66, 0x35, 0x33, 0x36, 0x36, 0x38, 0x31, 0x32, 0x30, 0x32, 0x66, 0x39, 0x30, 0x38, 0x34, 0x62, 0x30, 0x33, 0x32, 0x35, 0x34, 0x34, 0x64, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x62, 0x36, 0x33, 0x32, 0x30, 0x31, 0x66, 0x61, 0x65, 0x31, 0x66, 0x31, 0x32, 0x39, 0x66, 0x39, 0x35, 0x63, 0x37, 0x61, 0x31, 0x31, 0x36, 0x62, 0x64, 0x39, 0x64, 0x64, 0x65, 0x35, 0x31, 0x35, 0x39, 0x63, 0x36, 0x63, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x38, 0x33, 0x37, 0x34, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x62, 0x65, 0x36, 0x32, 0x65, 0x61, 0x63, 0x38, 0x30, 0x63, 0x61, 0x37, 0x66, 0x34, 0x64, 0x36, 0x66, 0x64, 0x65, 0x65, 0x37, 0x65, 0x37, 0x64, 0x38, 0x65, 0x32, 0x38, 0x62, 0x36, 0x33, 0x61, 0x63, 0x66, 0x37, 0x37, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x64, 0x61, 0x31, 0x62, 0x61, 0x32, 0x64, 0x65, 0x39, 0x65, 0x32, 0x63, 0x39, 0x35, 0x34, 0x62, 0x30, 0x39, 0x32, 0x64, 0x64, 0x39, 0x64, 0x38, 0x31, 0x32, 0x30, 0x34, 0x66, 0x64, 0x30, 0x31, 0x36, 0x62, 0x61, 0x30, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x38, 0x36, 0x65, 0x34, 0x61, 0x35, 0x31, 0x63, 0x30, 0x31, 0x33, 0x62, 0x31, 0x66, 0x62, 0x34, 0x63, 0x37, 0x36, 0x62, 0x63, 0x66, 0x33, 0x30, 0x36, 0x36, 0x37, 0x63, 0x37, 0x38, 0x64, 0x35, 0x32, 0x65, 0x65, 0x64, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x37, 0x31, 0x37, 0x65, 0x63, 0x31, 0x35, 0x35, 0x32, 0x66, 0x34, 0x63, 0x34, 0x34, 0x30, 0x30, 0x38, 0x34, 0x66, 0x62, 0x61, 0x31, 0x31, 0x35, 0x34, 0x61, 0x38, 0x31, 0x64, 0x63, 0x30, 0x30, 0x33, 0x65, 0x62, 0x64, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x36, 0x30, 0x39, 0x37, 0x31, 0x62, 0x62, 0x63, 0x31, 0x38, 0x31, 0x63, 0x36, 0x61, 0x37, 0x63, 0x66, 0x37, 0x37, 0x34, 0x34, 0x31, 0x66, 0x32, 0x34, 0x32, 0x34, 0x37, 0x64, 0x31, 0x39, 0x63, 0x65, 0x39, 0x62, 0x34, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x31, 0x35, 0x30, 0x61, 0x66, 0x62, 0x31, 0x61, 0x37, 0x37, 0x63, 0x32, 0x62, 0x34, 0x35, 0x39, 0x32, 0x38, 0x63, 0x32, 0x36, 0x38, 0x63, 0x31, 0x65, 0x39, 0x62, 0x64, 0x62, 0x34, 0x36, 0x34, 0x31, 0x64, 0x34, 0x37, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x61, 0x33, 0x33, 0x34, 0x62, 0x35, 0x37, 0x35, 0x30, 0x38, 0x30, 0x37, 0x65, 0x61, 0x37, 0x34, 0x61, 0x61, 0x63, 0x35, 0x61, 0x62, 0x38, 0x36, 0x39, 0x34, 0x65, 0x63, 0x35, 0x66, 0x32, 0x38, 0x61, 0x61, 0x37, 0x37, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x66, 0x62, 0x30, 0x35, 0x38, 0x63, 0x33, 0x64, 0x33, 0x31, 0x30, 0x33, 0x32, 0x62, 0x33, 0x35, 0x33, 0x62, 0x66, 0x32, 0x34, 0x66, 0x30, 0x39, 0x61, 0x65, 0x32, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x35, 0x37, 0x64, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x65, 0x66, 0x30, 0x32, 0x37, 0x62, 0x31, 0x61, 0x62, 0x35, 0x30, 0x34, 0x63, 0x37, 0x33, 0x66, 0x34, 0x31, 0x66, 0x32, 0x61, 0x31, 0x30, 0x39, 0x37, 0x39, 0x62, 0x34, 0x37, 0x34, 0x66, 0x39, 0x37, 0x65, 0x33, 0x30, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x64, 0x31, 0x31, 0x32, 0x66, 0x33, 0x36, 0x38, 0x63, 0x30, 0x65, 0x36, 0x63, 0x65, 0x66, 0x66, 0x37, 0x37, 0x61, 0x39, 0x64, 0x66, 0x30, 0x32, 0x61, 0x35, 0x34, 0x38, 0x31, 0x36, 0x35, 0x31, 0x61, 0x30, 0x32, 0x66, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x39, 0x33, 0x65, 0x35, 0x35, 0x30, 0x34, 0x30, 0x33, 0x65, 0x32, 0x61, 0x30, 0x36, 0x31, 0x31, 0x33, 0x65, 0x64, 0x34, 0x63, 0x33, 0x66, 0x62, 0x61, 0x31, 0x61, 0x38, 0x39, 0x31, 0x33, 0x62, 0x31, 0x39, 0x34, 0x30, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x30, 0x63, 0x31, 0x36, 0x33, 0x35, 0x32, 0x65, 0x39, 0x30, 0x31, 0x64, 0x34, 0x38, 0x62, 0x61, 0x38, 0x64, 0x30, 0x34, 0x65, 0x32, 0x63, 0x37, 0x36, 0x37, 0x31, 0x32, 0x31, 0x37, 0x37, 0x32, 0x37, 0x39, 0x30, 0x62, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x32, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x61, 0x38, 0x30, 0x33, 0x32, 0x37, 0x63, 0x62, 0x65, 0x35, 0x35, 0x63, 0x34, 0x63, 0x37, 0x62, 0x64, 0x35, 0x31, 0x66, 0x66, 0x39, 0x64, 0x64, 0x65, 0x34, 0x63, 0x61, 0x36, 0x34, 0x38, 0x66, 0x39, 0x65, 0x62, 0x33, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x35, 0x63, 0x63, 0x66, 0x65, 0x30, 0x65, 0x37, 0x37, 0x64, 0x35, 0x35, 0x37, 0x62, 0x39, 0x37, 0x31, 0x62, 0x65, 0x31, 0x61, 0x35, 0x35, 0x38, 0x62, 0x63, 0x30, 0x32, 0x64, 0x66, 0x39, 0x65, 0x65, 0x65, 0x30, 0x35, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x35, 0x39, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x65, 0x64, 0x30, 0x65, 0x36, 0x63, 0x66, 0x65, 0x39, 0x35, 0x66, 0x39, 0x64, 0x36, 0x38, 0x30, 0x63, 0x37, 0x36, 0x34, 0x37, 0x32, 0x61, 0x38, 0x31, 0x61, 0x32, 0x62, 0x36, 0x38, 0x30, 0x61, 0x37, 0x66, 0x39, 0x33, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x36, 0x34, 0x34, 0x32, 0x66, 0x36, 0x30, 0x65, 0x32, 0x31, 0x36, 0x39, 0x31, 0x33, 0x39, 0x35, 0x64, 0x30, 0x62, 0x66, 0x66, 0x61, 0x61, 0x39, 0x31, 0x39, 0x34, 0x64, 0x63, 0x61, 0x66, 0x66, 0x31, 0x32, 0x65, 0x32, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x62, 0x39, 0x65, 0x61, 0x63, 0x63, 0x35, 0x32, 0x65, 0x34, 0x32, 0x39, 0x64, 0x63, 0x38, 0x33, 0x62, 0x34, 0x36, 0x31, 0x63, 0x35, 0x66, 0x34, 0x64, 0x38, 0x36, 0x30, 0x31, 0x30, 0x65, 0x35, 0x33, 0x38, 0x33, 0x61, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x39, 0x38, 0x34, 0x65, 0x66, 0x32, 0x36, 0x63, 0x35, 0x37, 0x36, 0x65, 0x38, 0x31, 0x35, 0x61, 0x32, 0x65, 0x61, 0x65, 0x64, 0x32, 0x66, 0x35, 0x31, 0x37, 0x37, 0x66, 0x30, 0x37, 0x64, 0x62, 0x62, 0x31, 0x63, 0x34, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x34, 0x36, 0x36, 0x34, 0x38, 0x38, 0x33, 0x36, 0x61, 0x33, 0x30, 0x37, 0x61, 0x30, 0x35, 0x37, 0x31, 0x38, 0x34, 0x66, 0x64, 0x35, 0x31, 0x66, 0x36, 0x32, 0x38, 0x61, 0x35, 0x66, 0x38, 0x63, 0x31, 0x32, 0x34, 0x32, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x66, 0x30, 0x64, 0x62, 0x30, 0x37, 0x37, 0x62, 0x62, 0x39, 0x62, 0x61, 0x35, 0x65, 0x34, 0x34, 0x33, 0x65, 0x32, 0x31, 0x65, 0x31, 0x34, 0x38, 0x65, 0x35, 0x39, 0x66, 0x33, 0x37, 0x39, 0x31, 0x30, 0x35, 0x63, 0x35, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x36, 0x65, 0x32, 0x64, 0x33, 0x38, 0x31, 0x33, 0x65, 0x66, 0x64, 0x31, 0x31, 0x36, 0x35, 0x66, 0x31, 0x32, 0x66, 0x36, 0x30, 0x32, 0x66, 0x39, 0x37, 0x66, 0x34, 0x61, 0x36, 0x32, 0x39, 0x30, 0x39, 0x64, 0x33, 0x63, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x37, 0x38, 0x39, 0x62, 0x33, 0x64, 0x32, 0x34, 0x36, 0x35, 0x65, 0x39, 0x34, 0x36, 0x65, 0x36, 0x32, 0x31, 0x30, 0x66, 0x61, 0x35, 0x62, 0x33, 0x35, 0x64, 0x65, 0x34, 0x65, 0x38, 0x63, 0x39, 0x33, 0x30, 0x38, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x66, 0x39, 0x39, 0x62, 0x36, 0x62, 0x61, 0x33, 0x31, 0x33, 0x34, 0x36, 0x63, 0x64, 0x39, 0x38, 0x61, 0x39, 0x66, 0x65, 0x34, 0x63, 0x33, 0x30, 0x38, 0x66, 0x38, 0x37, 0x63, 0x35, 0x61, 0x35, 0x38, 0x63, 0x35, 0x31, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x35, 0x65, 0x32, 0x33, 0x64, 0x37, 0x38, 0x38, 0x61, 0x32, 0x64, 0x34, 0x62, 0x62, 0x38, 0x35, 0x61, 0x31, 0x35, 0x64, 0x66, 0x37, 0x31, 0x33, 0x36, 0x64, 0x32, 0x36, 0x34, 0x61, 0x36, 0x33, 0x35, 0x35, 0x31, 0x31, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x36, 0x31, 0x65, 0x66, 0x61, 0x35, 0x38, 0x31, 0x39, 0x64, 0x37, 0x30, 0x35, 0x66, 0x32, 0x62, 0x31, 0x65, 0x34, 0x65, 0x65, 0x37, 0x35, 0x34, 0x61, 0x65, 0x62, 0x38, 0x61, 0x38, 0x31, 0x39, 0x35, 0x30, 0x36, 0x61, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x35, 0x34, 0x39, 0x34, 0x37, 0x62, 0x37, 0x62, 0x39, 0x34, 0x37, 0x62, 0x30, 0x30, 0x34, 0x30, 0x64, 0x61, 0x35, 0x32, 0x63, 0x61, 0x31, 0x38, 0x30, 0x39, 0x32, 0x35, 0x63, 0x36, 0x64, 0x33, 0x62, 0x38, 0x38, 0x66, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x65, 0x66, 0x66, 0x61, 0x64, 0x62, 0x33, 0x38, 0x37, 0x61, 0x31, 0x35, 0x34, 0x37, 0x66, 0x62, 0x32, 0x38, 0x34, 0x64, 0x61, 0x39, 0x62, 0x38, 0x31, 0x34, 0x37, 0x66, 0x33, 0x65, 0x37, 0x63, 0x36, 0x64, 0x63, 0x36, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x38, 0x39, 0x33, 0x39, 0x62, 0x62, 0x66, 0x30, 0x30, 0x63, 0x39, 0x64, 0x65, 0x39, 0x61, 0x66, 0x35, 0x33, 0x33, 0x38, 0x66, 0x35, 0x64, 0x37, 0x31, 0x34, 0x61, 0x62, 0x66, 0x36, 0x64, 0x30, 0x63, 0x31, 0x63, 0x36, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x33, 0x33, 0x33, 0x36, 0x39, 0x36, 0x65, 0x30, 0x34, 0x63, 0x63, 0x61, 0x31, 0x36, 0x39, 0x32, 0x65, 0x37, 0x31, 0x39, 0x38, 0x36, 0x35, 0x37, 0x39, 0x63, 0x39, 0x32, 0x30, 0x64, 0x36, 0x62, 0x32, 0x39, 0x31, 0x36, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x38, 0x31, 0x34, 0x34, 0x38, 0x35, 0x30, 0x33, 0x63, 0x30, 0x63, 0x37, 0x30, 0x32, 0x35, 0x34, 0x32, 0x62, 0x31, 0x64, 0x65, 0x37, 0x63, 0x63, 0x35, 0x66, 0x62, 0x35, 0x66, 0x36, 0x61, 0x62, 0x31, 0x63, 0x66, 0x36, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x38, 0x31, 0x66, 0x36, 0x34, 0x34, 0x39, 0x61, 0x30, 0x33, 0x33, 0x37, 0x34, 0x31, 0x39, 0x31, 0x66, 0x33, 0x62, 0x37, 0x63, 0x62, 0x30, 0x35, 0x64, 0x39, 0x33, 0x38, 0x62, 0x37, 0x32, 0x65, 0x30, 0x39, 0x30, 0x64, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x66, 0x31, 0x63, 0x32, 0x31, 0x34, 0x36, 0x33, 0x33, 0x61, 0x64, 0x39, 0x63, 0x30, 0x37, 0x30, 0x33, 0x62, 0x34, 0x65, 0x32, 0x33, 0x37, 0x34, 0x61, 0x32, 0x65, 0x33, 0x33, 0x65, 0x33, 0x65, 0x34, 0x32, 0x39, 0x32, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x64, 0x38, 0x34, 0x37, 0x36, 0x64, 0x31, 0x30, 0x64, 0x35, 0x38, 0x34, 0x62, 0x33, 0x38, 0x62, 0x66, 0x61, 0x36, 0x37, 0x33, 0x37, 0x36, 0x30, 0x30, 0x65, 0x66, 0x31, 0x39, 0x64, 0x33, 0x35, 0x63, 0x34, 0x31, 0x65, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x39, 0x35, 0x63, 0x39, 0x62, 0x37, 0x35, 0x34, 0x36, 0x62, 0x35, 0x64, 0x31, 0x37, 0x38, 0x36, 0x63, 0x33, 0x38, 0x35, 0x38, 0x66, 0x62, 0x31, 0x32, 0x33, 0x36, 0x34, 0x34, 0x36, 0x62, 0x63, 0x30, 0x63, 0x61, 0x34, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x30, 0x37, 0x64, 0x62, 0x35, 0x61, 0x33, 0x35, 0x37, 0x66, 0x35, 0x61, 0x66, 0x32, 0x34, 0x38, 0x34, 0x63, 0x62, 0x63, 0x39, 0x64, 0x37, 0x37, 0x64, 0x37, 0x33, 0x62, 0x31, 0x66, 0x64, 0x30, 0x35, 0x31, 0x39, 0x66, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x36, 0x38, 0x61, 0x32, 0x34, 0x63, 0x37, 0x65, 0x62, 0x34, 0x31, 0x31, 0x37, 0x36, 0x36, 0x37, 0x37, 0x33, 0x37, 0x62, 0x33, 0x33, 0x33, 0x39, 0x33, 0x66, 0x62, 0x33, 0x63, 0x32, 0x31, 0x34, 0x38, 0x61, 0x35, 0x33, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x66, 0x36, 0x36, 0x35, 0x66, 0x64, 0x38, 0x63, 0x64, 0x35, 0x63, 0x32, 0x62, 0x63, 0x63, 0x36, 0x64, 0x64, 0x63, 0x30, 0x61, 0x38, 0x61, 0x65, 0x35, 0x32, 0x31, 0x65, 0x34, 0x64, 0x63, 0x36, 0x61, 0x61, 0x36, 0x30, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x36, 0x61, 0x63, 0x63, 0x30, 0x64, 0x31, 0x31, 0x62, 0x36, 0x38, 0x39, 0x63, 0x65, 0x61, 0x36, 0x64, 0x39, 0x65, 0x61, 0x35, 0x66, 0x66, 0x34, 0x30, 0x31, 0x34, 0x63, 0x32, 0x32, 0x34, 0x61, 0x35, 0x64, 0x63, 0x37, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x37, 0x32, 0x62, 0x32, 0x61, 0x31, 0x31, 0x38, 0x36, 0x61, 0x38, 0x65, 0x32, 0x39, 0x31, 0x36, 0x35, 0x34, 0x33, 0x62, 0x31, 0x63, 0x62, 0x33, 0x36, 0x61, 0x36, 0x38, 0x38, 0x37, 0x30, 0x65, 0x61, 0x35, 0x64, 0x31, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x30, 0x32, 0x61, 0x34, 0x61, 0x34, 0x32, 0x30, 0x37, 0x37, 0x65, 0x31, 0x31, 0x63, 0x35, 0x38, 0x64, 0x66, 0x34, 0x37, 0x37, 0x33, 0x65, 0x33, 0x61, 0x63, 0x39, 0x34, 0x34, 0x36, 0x32, 0x33, 0x61, 0x36, 0x36, 0x64, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x34, 0x38, 0x30, 0x62, 0x65, 0x64, 0x65, 0x38, 0x31, 0x61, 0x64, 0x39, 0x36, 0x34, 0x32, 0x33, 0x66, 0x32, 0x32, 0x32, 0x38, 0x62, 0x35, 0x63, 0x36, 0x31, 0x62, 0x65, 0x34, 0x34, 0x66, 0x62, 0x35, 0x32, 0x33, 0x31, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x37, 0x36, 0x64, 0x62, 0x33, 0x30, 0x61, 0x62, 0x34, 0x38, 0x36, 0x66, 0x37, 0x39, 0x31, 0x39, 0x34, 0x65, 0x62, 0x62, 0x63, 0x34, 0x35, 0x64, 0x38, 0x66, 0x61, 0x62, 0x39, 0x61, 0x39, 0x32, 0x34, 0x32, 0x66, 0x36, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x65, 0x65, 0x61, 0x31, 0x35, 0x65, 0x65, 0x63, 0x33, 0x62, 0x64, 0x61, 0x64, 0x38, 0x30, 0x32, 0x33, 0x66, 0x39, 0x38, 0x65, 0x63, 0x66, 0x32, 0x35, 0x62, 0x32, 0x62, 0x38, 0x66, 0x65, 0x66, 0x32, 0x37, 0x64, 0x62, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x36, 0x35, 0x32, 0x33, 0x36, 0x30, 0x64, 0x36, 0x37, 0x31, 0x36, 0x64, 0x63, 0x35, 0x35, 0x63, 0x66, 0x39, 0x61, 0x61, 0x62, 0x32, 0x31, 0x66, 0x33, 0x34, 0x38, 0x32, 0x66, 0x38, 0x31, 0x36, 0x63, 0x63, 0x32, 0x63, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x65, 0x30, 0x32, 0x66, 0x62, 0x34, 0x34, 0x38, 0x64, 0x36, 0x63, 0x38, 0x34, 0x61, 0x65, 0x31, 0x37, 0x64, 0x62, 0x33, 0x31, 0x30, 0x61, 0x64, 0x32, 0x38, 0x36, 0x64, 0x30, 0x35, 0x36, 0x31, 0x36, 0x30, 0x64, 0x61, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x35, 0x39, 0x38, 0x62, 0x31, 0x33, 0x38, 0x36, 0x65, 0x39, 0x33, 0x63, 0x35, 0x63, 0x63, 0x62, 0x39, 0x36, 0x30, 0x32, 0x66, 0x66, 0x34, 0x62, 0x62, 0x62, 0x65, 0x63, 0x64, 0x62, 0x64, 0x33, 0x37, 0x30, 0x31, 0x64, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x34, 0x30, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x65, 0x61, 0x34, 0x37, 0x32, 0x63, 0x62, 0x39, 0x34, 0x36, 0x36, 0x30, 0x31, 0x38, 0x31, 0x31, 0x30, 0x61, 0x66, 0x30, 0x30, 0x63, 0x33, 0x37, 0x34, 0x39, 0x35, 0x62, 0x35, 0x63, 0x32, 0x63, 0x37, 0x31, 0x33, 0x31, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x37, 0x35, 0x63, 0x62, 0x35, 0x30, 0x35, 0x31, 0x61, 0x30, 0x62, 0x30, 0x39, 0x34, 0x34, 0x62, 0x34, 0x36, 0x37, 0x33, 0x63, 0x61, 0x37, 0x35, 0x32, 0x61, 0x39, 0x37, 0x30, 0x33, 0x37, 0x66, 0x37, 0x63, 0x38, 0x63, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x66, 0x36, 0x32, 0x36, 0x61, 0x35, 0x66, 0x33, 0x32, 0x37, 0x64, 0x37, 0x35, 0x30, 0x36, 0x35, 0x38, 0x39, 0x65, 0x65, 0x62, 0x37, 0x30, 0x31, 0x30, 0x66, 0x66, 0x39, 0x63, 0x39, 0x34, 0x34, 0x36, 0x30, 0x32, 0x30, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x38, 0x63, 0x37, 0x36, 0x65, 0x63, 0x66, 0x64, 0x38, 0x61, 0x66, 0x36, 0x38, 0x64, 0x37, 0x30, 0x35, 0x35, 0x35, 0x33, 0x35, 0x32, 0x65, 0x31, 0x66, 0x36, 0x30, 0x31, 0x65, 0x33, 0x35, 0x39, 0x38, 0x38, 0x30, 0x34, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x33, 0x64, 0x31, 0x39, 0x34, 0x34, 0x31, 0x64, 0x31, 0x39, 0x36, 0x63, 0x62, 0x34, 0x34, 0x33, 0x36, 0x36, 0x32, 0x30, 0x32, 0x30, 0x66, 0x63, 0x61, 0x64, 0x37, 0x66, 0x62, 0x62, 0x37, 0x39, 0x62, 0x32, 0x39, 0x65, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x31, 0x30, 0x31, 0x61, 0x30, 0x66, 0x35, 0x36, 0x64, 0x33, 0x39, 0x61, 0x38, 0x38, 0x63, 0x35, 0x61, 0x38, 0x34, 0x66, 0x39, 0x62, 0x33, 0x32, 0x34, 0x63, 0x64, 0x64, 0x65, 0x33, 0x33, 0x65, 0x35, 0x63, 0x62, 0x36, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x32, 0x39, 0x65, 0x37, 0x34, 0x36, 0x61, 0x38, 0x33, 0x66, 0x32, 0x63, 0x65, 0x32, 0x35, 0x33, 0x62, 0x30, 0x62, 0x30, 0x33, 0x65, 0x62, 0x31, 0x34, 0x37, 0x32, 0x34, 0x31, 0x31, 0x62, 0x35, 0x37, 0x65, 0x35, 0x37, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x34, 0x63, 0x64, 0x66, 0x31, 0x38, 0x36, 0x32, 0x38, 0x64, 0x62, 0x66, 0x61, 0x38, 0x33, 0x32, 0x39, 0x31, 0x39, 0x34, 0x64, 0x34, 0x37, 0x38, 0x64, 0x64, 0x35, 0x32, 0x30, 0x31, 0x65, 0x65, 0x63, 0x63, 0x34, 0x62, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x37, 0x34, 0x37, 0x33, 0x37, 0x37, 0x34, 0x66, 0x36, 0x33, 0x61, 0x63, 0x33, 0x64, 0x36, 0x32, 0x37, 0x39, 0x66, 0x64, 0x30, 0x37, 0x34, 0x33, 0x64, 0x35, 0x37, 0x39, 0x30, 0x63, 0x34, 0x66, 0x31, 0x36, 0x31, 0x35, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x64, 0x65, 0x66, 0x65, 0x66, 0x64, 0x33, 0x35, 0x61, 0x62, 0x38, 0x66, 0x36, 0x35, 0x38, 0x62, 0x32, 0x34, 0x37, 0x31, 0x65, 0x35, 0x34, 0x37, 0x39, 0x30, 0x62, 0x63, 0x31, 0x37, 0x61, 0x66, 0x39, 0x38, 0x64, 0x65, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x33, 0x39, 0x30, 0x30, 0x32, 0x39, 0x38, 0x64, 0x64, 0x31, 0x34, 0x64, 0x37, 0x63, 0x63, 0x39, 0x36, 0x64, 0x34, 0x61, 0x62, 0x62, 0x34, 0x32, 0x38, 0x64, 0x61, 0x31, 0x62, 0x61, 0x65, 0x32, 0x31, 0x33, 0x66, 0x66, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x37, 0x33, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x34, 0x66, 0x30, 0x37, 0x62, 0x39, 0x36, 0x66, 0x39, 0x30, 0x63, 0x35, 0x66, 0x30, 0x64, 0x37, 0x63, 0x30, 0x63, 0x35, 0x38, 0x30, 0x35, 0x33, 0x33, 0x31, 0x34, 0x39, 0x66, 0x33, 0x66, 0x35, 0x38, 0x35, 0x61, 0x30, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x32, 0x63, 0x36, 0x64, 0x30, 0x33, 0x62, 0x35, 0x62, 0x36, 0x65, 0x36, 0x37, 0x31, 0x31, 0x65, 0x66, 0x66, 0x66, 0x31, 0x39, 0x30, 0x65, 0x34, 0x39, 0x63, 0x32, 0x38, 0x65, 0x65, 0x66, 0x33, 0x36, 0x63, 0x38, 0x32, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x37, 0x63, 0x37, 0x37, 0x65, 0x33, 0x63, 0x32, 0x34, 0x61, 0x64, 0x65, 0x63, 0x64, 0x63, 0x64, 0x31, 0x30, 0x33, 0x38, 0x61, 0x33, 0x38, 0x62, 0x35, 0x36, 0x65, 0x31, 0x38, 0x64, 0x65, 0x61, 0x64, 0x33, 0x62, 0x37, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x62, 0x36, 0x65, 0x35, 0x66, 0x30, 0x39, 0x63, 0x63, 0x31, 0x62, 0x39, 0x30, 0x64, 0x66, 0x30, 0x37, 0x38, 0x30, 0x33, 0x63, 0x65, 0x33, 0x64, 0x34, 0x64, 0x31, 0x33, 0x37, 0x36, 0x36, 0x61, 0x39, 0x63, 0x34, 0x36, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x34, 0x33, 0x33, 0x34, 0x62, 0x34, 0x65, 0x32, 0x33, 0x61, 0x31, 0x36, 0x39, 0x61, 0x30, 0x63, 0x31, 0x36, 0x62, 0x64, 0x32, 0x31, 0x65, 0x38, 0x36, 0x36, 0x62, 0x62, 0x61, 0x35, 0x32, 0x64, 0x39, 0x37, 0x30, 0x35, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x35, 0x37, 0x61, 0x34, 0x62, 0x39, 0x63, 0x63, 0x33, 0x64, 0x30, 0x32, 0x34, 0x37, 0x63, 0x63, 0x61, 0x61, 0x65, 0x62, 0x39, 0x39, 0x30, 0x39, 0x61, 0x30, 0x65, 0x35, 0x36, 0x65, 0x31, 0x64, 0x64, 0x36, 0x64, 0x63, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x36, 0x39, 0x34, 0x30, 0x38, 0x31, 0x63, 0x37, 0x36, 0x64, 0x31, 0x38, 0x63, 0x36, 0x34, 0x63, 0x61, 0x37, 0x31, 0x33, 0x38, 0x32, 0x62, 0x65, 0x35, 0x63, 0x64, 0x36, 0x33, 0x62, 0x33, 0x63, 0x62, 0x34, 0x37, 0x36, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x33, 0x65, 0x34, 0x66, 0x31, 0x35, 0x65, 0x31, 0x65, 0x33, 0x39, 0x63, 0x35, 0x33, 0x34, 0x33, 0x35, 0x39, 0x33, 0x30, 0x61, 0x61, 0x65, 0x64, 0x66, 0x33, 0x65, 0x30, 0x66, 0x65, 0x35, 0x36, 0x66, 0x64, 0x65, 0x38, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x36, 0x37, 0x66, 0x62, 0x31, 0x30, 0x64, 0x66, 0x62, 0x32, 0x39, 0x33, 0x65, 0x39, 0x39, 0x38, 0x61, 0x62, 0x65, 0x35, 0x36, 0x34, 0x63, 0x30, 0x35, 0x35, 0x65, 0x33, 0x33, 0x34, 0x38, 0x66, 0x39, 0x66, 0x62, 0x66, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x34, 0x34, 0x39, 0x63, 0x30, 0x31, 0x62, 0x33, 0x32, 0x61, 0x37, 0x66, 0x61, 0x35, 0x35, 0x61, 0x66, 0x38, 0x31, 0x30, 0x34, 0x66, 0x34, 0x32, 0x63, 0x64, 0x64, 0x38, 0x34, 0x34, 0x61, 0x61, 0x38, 0x63, 0x62, 0x63, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x35, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x32, 0x30, 0x39, 0x34, 0x61, 0x63, 0x31, 0x36, 0x35, 0x34, 0x61, 0x34, 0x36, 0x62, 0x61, 0x31, 0x63, 0x34, 0x64, 0x33, 0x61, 0x34, 0x30, 0x62, 0x62, 0x38, 0x63, 0x31, 0x37, 0x64, 0x61, 0x37, 0x66, 0x33, 0x39, 0x36, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x38, 0x63, 0x61, 0x39, 0x34, 0x64, 0x62, 0x37, 0x63, 0x65, 0x38, 0x62, 0x65, 0x31, 0x63, 0x33, 0x30, 0x35, 0x36, 0x63, 0x64, 0x36, 0x39, 0x38, 0x38, 0x65, 0x62, 0x33, 0x37, 0x36, 0x33, 0x35, 0x39, 0x66, 0x33, 0x33, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x66, 0x62, 0x31, 0x37, 0x32, 0x33, 0x33, 0x35, 0x62, 0x31, 0x36, 0x63, 0x38, 0x37, 0x64, 0x35, 0x31, 0x39, 0x63, 0x64, 0x31, 0x34, 0x37, 0x35, 0x35, 0x33, 0x30, 0x64, 0x32, 0x30, 0x35, 0x37, 0x37, 0x66, 0x35, 0x65, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x62, 0x35, 0x36, 0x31, 0x63, 0x65, 0x38, 0x36, 0x34, 0x32, 0x34, 0x62, 0x33, 0x35, 0x39, 0x38, 0x39, 0x31, 0x65, 0x33, 0x36, 0x34, 0x65, 0x63, 0x39, 0x32, 0x35, 0x66, 0x66, 0x65, 0x66, 0x66, 0x32, 0x37, 0x37, 0x64, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x39, 0x38, 0x31, 0x30, 0x33, 0x39, 0x66, 0x63, 0x66, 0x35, 0x30, 0x32, 0x32, 0x35, 0x65, 0x32, 0x61, 0x64, 0x66, 0x37, 0x36, 0x32, 0x37, 0x35, 0x32, 0x31, 0x31, 0x32, 0x64, 0x31, 0x63, 0x63, 0x32, 0x36, 0x62, 0x36, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x33, 0x36, 0x35, 0x37, 0x61, 0x35, 0x30, 0x65, 0x65, 0x63, 0x62, 0x63, 0x33, 0x30, 0x37, 0x37, 0x65, 0x30, 0x30, 0x35, 0x64, 0x38, 0x66, 0x38, 0x64, 0x39, 0x34, 0x66, 0x33, 0x37, 0x37, 0x38, 0x37, 0x36, 0x62, 0x61, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x37, 0x65, 0x35, 0x31, 0x31, 0x38, 0x36, 0x34, 0x62, 0x31, 0x63, 0x66, 0x39, 0x39, 0x36, 0x39, 0x65, 0x33, 0x35, 0x36, 0x30, 0x36, 0x30, 0x32, 0x38, 0x32, 0x39, 0x65, 0x33, 0x32, 0x66, 0x63, 0x34, 0x65, 0x37, 0x31, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x33, 0x30, 0x36, 0x63, 0x37, 0x64, 0x35, 0x37, 0x35, 0x38, 0x38, 0x36, 0x33, 0x37, 0x37, 0x38, 0x30, 0x66, 0x63, 0x39, 0x66, 0x64, 0x65, 0x38, 0x65, 0x39, 0x38, 0x65, 0x63, 0x62, 0x30, 0x30, 0x38, 0x66, 0x30, 0x31, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x63, 0x61, 0x39, 0x38, 0x36, 0x32, 0x30, 0x30, 0x33, 0x62, 0x34, 0x65, 0x34, 0x30, 0x61, 0x33, 0x31, 0x37, 0x31, 0x66, 0x62, 0x35, 0x63, 0x61, 0x66, 0x61, 0x39, 0x30, 0x32, 0x38, 0x63, 0x61, 0x63, 0x38, 0x64, 0x65, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x31, 0x64, 0x39, 0x34, 0x31, 0x35, 0x35, 0x64, 0x62, 0x63, 0x66, 0x65, 0x32, 0x61, 0x39, 0x33, 0x61, 0x33, 0x31, 0x39, 0x62, 0x36, 0x31, 0x37, 0x31, 0x66, 0x36, 0x33, 0x62, 0x32, 0x30, 0x62, 0x64, 0x32, 0x62, 0x36, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x31, 0x39, 0x39, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x35, 0x33, 0x33, 0x65, 0x32, 0x37, 0x30, 0x63, 0x63, 0x36, 0x31, 0x66, 0x61, 0x31, 0x36, 0x34, 0x61, 0x63, 0x31, 0x35, 0x35, 0x33, 0x34, 0x35, 0x35, 0x63, 0x31, 0x30, 0x35, 0x64, 0x30, 0x34, 0x38, 0x38, 0x37, 0x65, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x30, 0x64, 0x35, 0x64, 0x33, 0x36, 0x34, 0x63, 0x62, 0x37, 0x62, 0x62, 0x66, 0x38, 0x32, 0x32, 0x66, 0x63, 0x32, 0x63, 0x61, 0x39, 0x31, 0x61, 0x33, 0x35, 0x62, 0x64, 0x64, 0x34, 0x34, 0x31, 0x62, 0x32, 0x31, 0x35, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x37, 0x35, 0x34, 0x37, 0x37, 0x66, 0x61, 0x35, 0x36, 0x33, 0x39, 0x30, 0x64, 0x33, 0x33, 0x30, 0x31, 0x37, 0x35, 0x31, 0x38, 0x64, 0x36, 0x37, 0x31, 0x31, 0x30, 0x32, 0x37, 0x66, 0x30, 0x35, 0x66, 0x32, 0x38, 0x64, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x61, 0x33, 0x34, 0x61, 0x34, 0x64, 0x64, 0x39, 0x33, 0x64, 0x64, 0x39, 0x61, 0x65, 0x66, 0x64, 0x33, 0x39, 0x39, 0x30, 0x30, 0x32, 0x61, 0x39, 0x37, 0x64, 0x39, 0x39, 0x37, 0x61, 0x31, 0x62, 0x34, 0x62, 0x38, 0x39, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x30, 0x62, 0x65, 0x63, 0x64, 0x66, 0x35, 0x32, 0x62, 0x37, 0x31, 0x66, 0x33, 0x64, 0x38, 0x38, 0x32, 0x37, 0x64, 0x39, 0x32, 0x37, 0x36, 0x31, 0x30, 0x66, 0x31, 0x61, 0x39, 0x38, 0x30, 0x66, 0x33, 0x33, 0x37, 0x31, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x39, 0x34, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x33, 0x32, 0x61, 0x64, 0x66, 0x66, 0x34, 0x39, 0x30, 0x64, 0x61, 0x34, 0x62, 0x37, 0x32, 0x64, 0x31, 0x32, 0x33, 0x36, 0x64, 0x30, 0x34, 0x62, 0x35, 0x31, 0x30, 0x66, 0x37, 0x34, 0x64, 0x32, 0x66, 0x61, 0x61, 0x33, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x64, 0x64, 0x39, 0x62, 0x37, 0x39, 0x64, 0x66, 0x38, 0x64, 0x66, 0x35, 0x33, 0x30, 0x61, 0x64, 0x36, 0x33, 0x63, 0x32, 0x30, 0x65, 0x36, 0x32, 0x61, 0x66, 0x34, 0x33, 0x31, 0x61, 0x65, 0x39, 0x39, 0x32, 0x31, 0x36, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x35, 0x32, 0x30, 0x31, 0x61, 0x30, 0x61, 0x31, 0x64, 0x37, 0x33, 0x34, 0x32, 0x32, 0x38, 0x30, 0x31, 0x66, 0x35, 0x35, 0x64, 0x65, 0x64, 0x34, 0x64, 0x66, 0x61, 0x65, 0x65, 0x34, 0x66, 0x62, 0x61, 0x61, 0x36, 0x65, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x36, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x39, 0x64, 0x35, 0x61, 0x39, 0x36, 0x32, 0x65, 0x64, 0x65, 0x65, 0x65, 0x62, 0x65, 0x61, 0x31, 0x37, 0x38, 0x30, 0x31, 0x38, 0x63, 0x30, 0x66, 0x33, 0x38, 0x62, 0x39, 0x63, 0x64, 0x62, 0x32, 0x31, 0x33, 0x66, 0x32, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x39, 0x31, 0x31, 0x66, 0x33, 0x36, 0x38, 0x32, 0x66, 0x33, 0x32, 0x66, 0x65, 0x30, 0x37, 0x39, 0x32, 0x65, 0x39, 0x66, 0x62, 0x36, 0x66, 0x66, 0x33, 0x63, 0x66, 0x63, 0x34, 0x37, 0x66, 0x35, 0x38, 0x39, 0x66, 0x63, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x37, 0x61, 0x30, 0x33, 0x39, 0x32, 0x66, 0x38, 0x35, 0x37, 0x37, 0x33, 0x32, 0x65, 0x33, 0x30, 0x30, 0x34, 0x61, 0x33, 0x37, 0x35, 0x65, 0x36, 0x62, 0x31, 0x30, 0x36, 0x38, 0x64, 0x34, 0x39, 0x64, 0x38, 0x33, 0x30, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x30, 0x34, 0x66, 0x35, 0x64, 0x35, 0x33, 0x66, 0x63, 0x30, 0x66, 0x35, 0x31, 0x35, 0x62, 0x65, 0x39, 0x34, 0x32, 0x62, 0x38, 0x66, 0x31, 0x32, 0x61, 0x39, 0x63, 0x62, 0x37, 0x61, 0x62, 0x30, 0x66, 0x33, 0x39, 0x37, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x34, 0x37, 0x38, 0x65, 0x38, 0x65, 0x33, 0x64, 0x64, 0x65, 0x36, 0x62, 0x64, 0x34, 0x30, 0x33, 0x62, 0x62, 0x32, 0x64, 0x31, 0x63, 0x36, 0x35, 0x37, 0x63, 0x34, 0x33, 0x31, 0x30, 0x65, 0x65, 0x31, 0x39, 0x32, 0x37, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x37, 0x36, 0x32, 0x32, 0x64, 0x38, 0x34, 0x61, 0x32, 0x33, 0x34, 0x62, 0x62, 0x38, 0x62, 0x30, 0x37, 0x38, 0x32, 0x33, 0x30, 0x66, 0x63, 0x66, 0x38, 0x34, 0x62, 0x36, 0x37, 0x61, 0x65, 0x39, 0x61, 0x38, 0x61, 0x63, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x37, 0x35, 0x63, 0x35, 0x31, 0x30, 0x65, 0x63, 0x39, 0x61, 0x32, 0x36, 0x39, 0x37, 0x39, 0x32, 0x34, 0x37, 0x37, 0x34, 0x34, 0x63, 0x33, 0x64, 0x38, 0x63, 0x33, 0x62, 0x30, 0x65, 0x30, 0x62, 0x35, 0x66, 0x34, 0x34, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x34, 0x37, 0x61, 0x38, 0x65, 0x66, 0x39, 0x35, 0x66, 0x32, 0x66, 0x34, 0x39, 0x66, 0x38, 0x65, 0x36, 0x66, 0x35, 0x38, 0x31, 0x38, 0x34, 0x31, 0x35, 0x34, 0x31, 0x34, 0x35, 0x64, 0x31, 0x31, 0x66, 0x37, 0x32, 0x37, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x63, 0x65, 0x33, 0x33, 0x32, 0x64, 0x66, 0x66, 0x36, 0x35, 0x61, 0x36, 0x61, 0x62, 0x39, 0x33, 0x33, 0x38, 0x39, 0x37, 0x35, 0x38, 0x38, 0x61, 0x61, 0x32, 0x33, 0x65, 0x30, 0x30, 0x30, 0x39, 0x38, 0x30, 0x66, 0x61, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x34, 0x62, 0x62, 0x63, 0x64, 0x35, 0x66, 0x31, 0x36, 0x34, 0x34, 0x61, 0x36, 0x66, 0x30, 0x37, 0x35, 0x38, 0x32, 0x34, 0x64, 0x64, 0x66, 0x65, 0x38, 0x35, 0x63, 0x35, 0x37, 0x31, 0x64, 0x36, 0x61, 0x62, 0x66, 0x36, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x32, 0x62, 0x32, 0x30, 0x62, 0x64, 0x30, 0x33, 0x31, 0x31, 0x36, 0x30, 0x38, 0x62, 0x36, 0x36, 0x66, 0x38, 0x61, 0x36, 0x64, 0x31, 0x35, 0x62, 0x32, 0x61, 0x39, 0x35, 0x65, 0x36, 0x64, 0x65, 0x32, 0x37, 0x63, 0x35, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x64, 0x64, 0x35, 0x39, 0x61, 0x62, 0x35, 0x65, 0x35, 0x31, 0x37, 0x64, 0x33, 0x39, 0x38, 0x65, 0x34, 0x39, 0x66, 0x61, 0x35, 0x33, 0x37, 0x66, 0x38, 0x39, 0x39, 0x66, 0x65, 0x64, 0x34, 0x63, 0x31, 0x35, 0x65, 0x39, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x38, 0x61, 0x35, 0x63, 0x65, 0x34, 0x31, 0x34, 0x64, 0x65, 0x39, 0x63, 0x64, 0x31, 0x37, 0x32, 0x39, 0x33, 0x37, 0x65, 0x33, 0x37, 0x66, 0x32, 0x64, 0x35, 0x39, 0x63, 0x66, 0x66, 0x37, 0x31, 0x63, 0x65, 0x35, 0x37, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x63, 0x35, 0x36, 0x34, 0x36, 0x36, 0x34, 0x31, 0x36, 0x36, 0x61, 0x31, 0x65, 0x64, 0x66, 0x33, 0x39, 0x31, 0x33, 0x65, 0x30, 0x31, 0x36, 0x39, 0x66, 0x31, 0x63, 0x64, 0x34, 0x35, 0x31, 0x66, 0x64, 0x62, 0x35, 0x64, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x61, 0x65, 0x32, 0x64, 0x64, 0x63, 0x35, 0x66, 0x34, 0x63, 0x38, 0x61, 0x64, 0x61, 0x39, 0x37, 0x65, 0x30, 0x36, 0x63, 0x30, 0x30, 0x38, 0x36, 0x31, 0x37, 0x31, 0x37, 0x36, 0x37, 0x63, 0x34, 0x32, 0x33, 0x66, 0x35, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x37, 0x39, 0x61, 0x62, 0x64, 0x62, 0x39, 0x32, 0x35, 0x63, 0x35, 0x35, 0x62, 0x39, 0x66, 0x39, 0x38, 0x65, 0x66, 0x65, 0x65, 0x66, 0x36, 0x34, 0x63, 0x66, 0x63, 0x39, 0x65, 0x62, 0x36, 0x31, 0x66, 0x35, 0x31, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x61, 0x34, 0x32, 0x66, 0x35, 0x39, 0x66, 0x65, 0x65, 0x30, 0x37, 0x34, 0x65, 0x34, 0x66, 0x62, 0x31, 0x33, 0x65, 0x61, 0x39, 0x65, 0x35, 0x37, 0x65, 0x63, 0x66, 0x31, 0x63, 0x63, 0x34, 0x38, 0x32, 0x38, 0x32, 0x32, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x65, 0x32, 0x62, 0x34, 0x63, 0x64, 0x65, 0x65, 0x64, 0x39, 0x64, 0x30, 0x38, 0x37, 0x62, 0x31, 0x32, 0x65, 0x35, 0x35, 0x36, 0x64, 0x39, 0x65, 0x37, 0x37, 0x30, 0x63, 0x31, 0x33, 0x63, 0x30, 0x39, 0x39, 0x36, 0x31, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x34, 0x37, 0x33, 0x62, 0x37, 0x61, 0x37, 0x64, 0x39, 0x36, 0x35, 0x39, 0x30, 0x34, 0x62, 0x65, 0x64, 0x62, 0x61, 0x35, 0x35, 0x36, 0x64, 0x66, 0x62, 0x63, 0x31, 0x37, 0x31, 0x33, 0x36, 0x63, 0x64, 0x35, 0x64, 0x34, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x35, 0x63, 0x33, 0x61, 0x35, 0x34, 0x63, 0x64, 0x61, 0x37, 0x63, 0x32, 0x66, 0x31, 0x31, 0x38, 0x65, 0x64, 0x62, 0x61, 0x34, 0x33, 0x34, 0x65, 0x64, 0x38, 0x31, 0x65, 0x36, 0x65, 0x62, 0x62, 0x31, 0x31, 0x64, 0x64, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x63, 0x31, 0x31, 0x37, 0x64, 0x31, 0x64, 0x32, 0x62, 0x33, 0x61, 0x39, 0x37, 0x61, 0x62, 0x31, 0x31, 0x61, 0x34, 0x36, 0x37, 0x39, 0x63, 0x39, 0x39, 0x61, 0x37, 0x37, 0x34, 0x61, 0x39, 0x65, 0x61, 0x64, 0x65, 0x38, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x38, 0x63, 0x35, 0x65, 0x33, 0x33, 0x66, 0x61, 0x39, 0x37, 0x31, 0x33, 0x39, 0x64, 0x66, 0x35, 0x62, 0x32, 0x65, 0x36, 0x33, 0x38, 0x38, 0x36, 0x63, 0x65, 0x33, 0x34, 0x65, 0x62, 0x66, 0x33, 0x65, 0x34, 0x39, 0x37, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x37, 0x34, 0x31, 0x39, 0x64, 0x63, 0x32, 0x61, 0x30, 0x39, 0x30, 0x61, 0x34, 0x36, 0x65, 0x32, 0x38, 0x37, 0x33, 0x64, 0x37, 0x64, 0x65, 0x36, 0x65, 0x61, 0x61, 0x61, 0x64, 0x35, 0x39, 0x65, 0x31, 0x39, 0x63, 0x34, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x30, 0x61, 0x31, 0x64, 0x64, 0x66, 0x62, 0x30, 0x33, 0x31, 0x65, 0x35, 0x63, 0x38, 0x63, 0x63, 0x31, 0x64, 0x34, 0x36, 0x63, 0x66, 0x30, 0x35, 0x38, 0x34, 0x32, 0x64, 0x35, 0x30, 0x66, 0x64, 0x64, 0x63, 0x37, 0x31, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x33, 0x61, 0x36, 0x38, 0x64, 0x62, 0x36, 0x62, 0x30, 0x63, 0x61, 0x65, 0x38, 0x61, 0x37, 0x63, 0x37, 0x61, 0x34, 0x37, 0x36, 0x62, 0x64, 0x66, 0x63, 0x66, 0x62, 0x64, 0x36, 0x32, 0x30, 0x35, 0x65, 0x31, 0x30, 0x36, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x36, 0x64, 0x31, 0x35, 0x66, 0x34, 0x30, 0x37, 0x61, 0x30, 0x31, 0x31, 0x33, 0x35, 0x62, 0x31, 0x33, 0x61, 0x36, 0x62, 0x37, 0x32, 0x66, 0x38, 0x66, 0x32, 0x35, 0x32, 0x30, 0x62, 0x33, 0x35, 0x33, 0x31, 0x65, 0x33, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x39, 0x34, 0x62, 0x39, 0x30, 0x66, 0x61, 0x64, 0x62, 0x38, 0x36, 0x30, 0x34, 0x66, 0x38, 0x36, 0x66, 0x34, 0x33, 0x66, 0x63, 0x31, 0x65, 0x33, 0x35, 0x64, 0x33, 0x31, 0x32, 0x34, 0x62, 0x33, 0x32, 0x61, 0x35, 0x39, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x31, 0x32, 0x63, 0x39, 0x62, 0x63, 0x33, 0x30, 0x62, 0x34, 0x64, 0x66, 0x34, 0x33, 0x39, 0x66, 0x30, 0x32, 0x33, 0x31, 0x30, 0x30, 0x65, 0x36, 0x33, 0x39, 0x32, 0x34, 0x30, 0x36, 0x36, 0x61, 0x66, 0x64, 0x35, 0x33, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x65, 0x37, 0x62, 0x33, 0x32, 0x30, 0x35, 0x32, 0x33, 0x30, 0x61, 0x35, 0x36, 0x36, 0x61, 0x31, 0x66, 0x30, 0x36, 0x31, 0x64, 0x39, 0x32, 0x32, 0x38, 0x31, 0x39, 0x62, 0x62, 0x34, 0x64, 0x34, 0x64, 0x32, 0x61, 0x30, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x34, 0x66, 0x63, 0x36, 0x36, 0x30, 0x36, 0x39, 0x30, 0x34, 0x36, 0x63, 0x35, 0x32, 0x35, 0x36, 0x35, 0x38, 0x63, 0x33, 0x33, 0x37, 0x61, 0x39, 0x31, 0x37, 0x66, 0x32, 0x64, 0x34, 0x62, 0x38, 0x33, 0x32, 0x62, 0x34, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x30, 0x36, 0x31, 0x65, 0x65, 0x32, 0x65, 0x35, 0x65, 0x65, 0x32, 0x36, 0x62, 0x38, 0x31, 0x35, 0x35, 0x30, 0x33, 0x36, 0x37, 0x37, 0x31, 0x33, 0x30, 0x65, 0x31, 0x64, 0x65, 0x30, 0x37, 0x61, 0x35, 0x32, 0x64, 0x62, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x37, 0x39, 0x33, 0x34, 0x36, 0x33, 0x65, 0x31, 0x36, 0x38, 0x31, 0x30, 0x38, 0x33, 0x64, 0x36, 0x61, 0x62, 0x64, 0x36, 0x65, 0x37, 0x32, 0x35, 0x64, 0x35, 0x62, 0x62, 0x61, 0x37, 0x34, 0x35, 0x64, 0x63, 0x63, 0x64, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x35, 0x39, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x35, 0x35, 0x31, 0x66, 0x35, 0x36, 0x39, 0x37, 0x35, 0x66, 0x65, 0x39, 0x32, 0x62, 0x33, 0x31, 0x66, 0x61, 0x34, 0x36, 0x39, 0x63, 0x34, 0x39, 0x65, 0x61, 0x36, 0x36, 0x65, 0x65, 0x36, 0x36, 0x36, 0x32, 0x66, 0x34, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x64, 0x39, 0x36, 0x61, 0x62, 0x36, 0x61, 0x63, 0x37, 0x36, 0x38, 0x61, 0x64, 0x35, 0x30, 0x39, 0x39, 0x34, 0x35, 0x32, 0x61, 0x63, 0x34, 0x37, 0x37, 0x37, 0x62, 0x64, 0x31, 0x61, 0x34, 0x37, 0x65, 0x64, 0x63, 0x34, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x37, 0x34, 0x36, 0x63, 0x64, 0x34, 0x34, 0x30, 0x32, 0x37, 0x61, 0x66, 0x33, 0x65, 0x62, 0x64, 0x33, 0x37, 0x63, 0x33, 0x37, 0x38, 0x63, 0x38, 0x35, 0x65, 0x66, 0x37, 0x66, 0x37, 0x35, 0x34, 0x61, 0x62, 0x35, 0x66, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x64, 0x33, 0x38, 0x39, 0x65, 0x36, 0x32, 0x34, 0x61, 0x33, 0x61, 0x37, 0x61, 0x65, 0x62, 0x63, 0x65, 0x34, 0x64, 0x33, 0x65, 0x35, 0x64, 0x62, 0x64, 0x66, 0x36, 0x63, 0x64, 0x63, 0x32, 0x39, 0x39, 0x33, 0x32, 0x61, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x37, 0x36, 0x31, 0x66, 0x65, 0x62, 0x37, 0x66, 0x63, 0x66, 0x61, 0x37, 0x64, 0x65, 0x64, 0x31, 0x66, 0x30, 0x65, 0x62, 0x30, 0x35, 0x38, 0x66, 0x34, 0x61, 0x36, 0x30, 0x30, 0x62, 0x66, 0x33, 0x61, 0x37, 0x30, 0x38, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x35, 0x63, 0x36, 0x63, 0x31, 0x37, 0x39, 0x33, 0x33, 0x31, 0x37, 0x64, 0x33, 0x32, 0x63, 0x65, 0x31, 0x33, 0x62, 0x62, 0x61, 0x34, 0x63, 0x34, 0x66, 0x66, 0x65, 0x62, 0x39, 0x37, 0x33, 0x62, 0x37, 0x38, 0x61, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x30, 0x34, 0x65, 0x65, 0x65, 0x37, 0x34, 0x65, 0x30, 0x62, 0x66, 0x33, 0x30, 0x63, 0x33, 0x66, 0x38, 0x64, 0x36, 0x63, 0x32, 0x63, 0x37, 0x66, 0x35, 0x32, 0x65, 0x30, 0x35, 0x31, 0x39, 0x32, 0x31, 0x30, 0x64, 0x66, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x33, 0x31, 0x61, 0x62, 0x33, 0x37, 0x34, 0x37, 0x64, 0x33, 0x35, 0x37, 0x32, 0x30, 0x61, 0x39, 0x64, 0x38, 0x63, 0x61, 0x32, 0x35, 0x31, 0x36, 0x35, 0x63, 0x64, 0x32, 0x38, 0x35, 0x61, 0x63, 0x64, 0x34, 0x62, 0x64, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x34, 0x63, 0x38, 0x62, 0x39, 0x66, 0x64, 0x33, 0x33, 0x65, 0x63, 0x65, 0x30, 0x30, 0x61, 0x66, 0x39, 0x31, 0x39, 0x39, 0x66, 0x33, 0x63, 0x66, 0x35, 0x66, 0x65, 0x30, 0x63, 0x63, 0x65, 0x32, 0x38, 0x63, 0x64, 0x31, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x33, 0x66, 0x37, 0x38, 0x33, 0x62, 0x35, 0x63, 0x64, 0x62, 0x38, 0x36, 0x32, 0x32, 0x31, 0x62, 0x66, 0x30, 0x32, 0x39, 0x34, 0x66, 0x62, 0x37, 0x31, 0x34, 0x39, 0x35, 0x39, 0x63, 0x37, 0x62, 0x34, 0x35, 0x38, 0x39, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x39, 0x65, 0x63, 0x34, 0x64, 0x32, 0x36, 0x35, 0x66, 0x33, 0x61, 0x62, 0x35, 0x33, 0x36, 0x62, 0x37, 0x63, 0x37, 0x30, 0x66, 0x61, 0x39, 0x37, 0x61, 0x63, 0x61, 0x31, 0x34, 0x32, 0x36, 0x39, 0x32, 0x63, 0x31, 0x33, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x32, 0x66, 0x37, 0x66, 0x30, 0x62, 0x30, 0x34, 0x62, 0x61, 0x34, 0x62, 0x65, 0x31, 0x36, 0x31, 0x65, 0x31, 0x39, 0x63, 0x62, 0x36, 0x66, 0x31, 0x31, 0x32, 0x63, 0x65, 0x37, 0x61, 0x35, 0x65, 0x37, 0x64, 0x37, 0x66, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x34, 0x62, 0x61, 0x32, 0x64, 0x38, 0x35, 0x36, 0x38, 0x31, 0x64, 0x63, 0x31, 0x33, 0x30, 0x65, 0x35, 0x62, 0x39, 0x62, 0x30, 0x32, 0x63, 0x34, 0x65, 0x38, 0x63, 0x38, 0x35, 0x31, 0x33, 0x39, 0x31, 0x66, 0x64, 0x39, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x64, 0x38, 0x61, 0x66, 0x36, 0x30, 0x64, 0x65, 0x36, 0x35, 0x66, 0x32, 0x34, 0x64, 0x63, 0x33, 0x63, 0x65, 0x35, 0x37, 0x33, 0x30, 0x62, 0x61, 0x39, 0x32, 0x36, 0x35, 0x33, 0x30, 0x32, 0x32, 0x64, 0x63, 0x35, 0x39, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x34, 0x32, 0x61, 0x36, 0x36, 0x64, 0x39, 0x37, 0x39, 0x66, 0x35, 0x38, 0x32, 0x38, 0x33, 0x34, 0x37, 0x34, 0x37, 0x61, 0x38, 0x62, 0x36, 0x30, 0x34, 0x32, 0x38, 0x65, 0x39, 0x62, 0x34, 0x65, 0x65, 0x63, 0x63, 0x64, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x31, 0x39, 0x65, 0x62, 0x30, 0x63, 0x33, 0x35, 0x34, 0x62, 0x63, 0x31, 0x33, 0x39, 0x33, 0x39, 0x36, 0x30, 0x65, 0x62, 0x30, 0x36, 0x30, 0x36, 0x33, 0x62, 0x38, 0x33, 0x39, 0x32, 0x36, 0x66, 0x30, 0x64, 0x36, 0x37, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x66, 0x33, 0x35, 0x34, 0x36, 0x66, 0x64, 0x31, 0x63, 0x64, 0x61, 0x33, 0x33, 0x64, 0x35, 0x38, 0x38, 0x34, 0x35, 0x66, 0x63, 0x38, 0x66, 0x63, 0x66, 0x65, 0x63, 0x61, 0x62, 0x63, 0x61, 0x37, 0x63, 0x35, 0x36, 0x34, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x34, 0x30, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x33, 0x36, 0x31, 0x32, 0x62, 0x63, 0x33, 0x62, 0x61, 0x30, 0x65, 0x65, 0x34, 0x38, 0x39, 0x38, 0x62, 0x34, 0x39, 0x64, 0x64, 0x32, 0x30, 0x32, 0x33, 0x33, 0x39, 0x30, 0x35, 0x66, 0x32, 0x66, 0x34, 0x35, 0x38, 0x66, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x32, 0x61, 0x66, 0x63, 0x30, 0x61, 0x65, 0x64, 0x31, 0x31, 0x62, 0x66, 0x63, 0x37, 0x31, 0x65, 0x37, 0x37, 0x61, 0x39, 0x30, 0x37, 0x36, 0x35, 0x37, 0x62, 0x33, 0x36, 0x65, 0x61, 0x37, 0x36, 0x65, 0x33, 0x66, 0x62, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x37, 0x31, 0x34, 0x62, 0x34, 0x31, 0x64, 0x32, 0x61, 0x36, 0x66, 0x37, 0x35, 0x31, 0x30, 0x30, 0x38, 0x65, 0x66, 0x38, 0x64, 0x64, 0x34, 0x64, 0x32, 0x62, 0x32, 0x39, 0x61, 0x65, 0x63, 0x61, 0x62, 0x38, 0x66, 0x33, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x37, 0x32, 0x31, 0x63, 0x38, 0x37, 0x62, 0x30, 0x64, 0x63, 0x32, 0x31, 0x33, 0x37, 0x37, 0x63, 0x37, 0x32, 0x30, 0x30, 0x65, 0x35, 0x32, 0x34, 0x62, 0x31, 0x34, 0x61, 0x32, 0x32, 0x66, 0x30, 0x61, 0x66, 0x36, 0x39, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x35, 0x38, 0x35, 0x38, 0x66, 0x37, 0x34, 0x39, 0x66, 0x31, 0x36, 0x39, 0x63, 0x61, 0x62, 0x63, 0x66, 0x65, 0x35, 0x32, 0x62, 0x37, 0x39, 0x36, 0x65, 0x33, 0x63, 0x31, 0x31, 0x65, 0x63, 0x34, 0x37, 0x65, 0x61, 0x33, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x66, 0x62, 0x34, 0x36, 0x61, 0x63, 0x35, 0x64, 0x30, 0x30, 0x63, 0x33, 0x35, 0x31, 0x38, 0x62, 0x32, 0x63, 0x33, 0x61, 0x31, 0x63, 0x31, 0x37, 0x37, 0x64, 0x34, 0x34, 0x32, 0x66, 0x38, 0x31, 0x36, 0x35, 0x35, 0x35, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x38, 0x63, 0x38, 0x39, 0x63, 0x30, 0x31, 0x34, 0x35, 0x30, 0x39, 0x64, 0x35, 0x36, 0x64, 0x37, 0x62, 0x36, 0x38, 0x31, 0x33, 0x30, 0x36, 0x36, 0x38, 0x66, 0x66, 0x36, 0x61, 0x33, 0x65, 0x63, 0x65, 0x63, 0x37, 0x33, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x35, 0x64, 0x32, 0x66, 0x37, 0x33, 0x39, 0x34, 0x39, 0x64, 0x61, 0x64, 0x64, 0x61, 0x30, 0x38, 0x35, 0x36, 0x62, 0x32, 0x30, 0x36, 0x39, 0x38, 0x39, 0x64, 0x66, 0x30, 0x30, 0x37, 0x38, 0x64, 0x35, 0x31, 0x61, 0x31, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x35, 0x33, 0x38, 0x32, 0x34, 0x36, 0x64, 0x64, 0x34, 0x65, 0x36, 0x66, 0x30, 0x63, 0x32, 0x30, 0x62, 0x66, 0x35, 0x61, 0x64, 0x31, 0x33, 0x37, 0x33, 0x63, 0x33, 0x62, 0x34, 0x36, 0x33, 0x61, 0x31, 0x33, 0x31, 0x65, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x36, 0x38, 0x30, 0x61, 0x31, 0x35, 0x66, 0x38, 0x63, 0x63, 0x62, 0x38, 0x62, 0x64, 0x63, 0x30, 0x32, 0x66, 0x37, 0x33, 0x36, 0x30, 0x63, 0x32, 0x35, 0x61, 0x64, 0x38, 0x63, 0x66, 0x62, 0x35, 0x37, 0x62, 0x38, 0x63, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x30, 0x63, 0x61, 0x33, 0x37, 0x33, 0x37, 0x33, 0x33, 0x37, 0x31, 0x37, 0x38, 0x61, 0x30, 0x63, 0x61, 0x61, 0x63, 0x33, 0x30, 0x39, 0x39, 0x63, 0x35, 0x38, 0x34, 0x62, 0x30, 0x35, 0x36, 0x63, 0x35, 0x36, 0x33, 0x30, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x33, 0x34, 0x31, 0x66, 0x61, 0x35, 0x61, 0x33, 0x61, 0x31, 0x62, 0x64, 0x30, 0x35, 0x31, 0x66, 0x37, 0x64, 0x62, 0x38, 0x30, 0x37, 0x62, 0x36, 0x64, 0x62, 0x32, 0x66, 0x63, 0x37, 0x62, 0x61, 0x34, 0x66, 0x39, 0x62, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x36, 0x33, 0x66, 0x37, 0x31, 0x35, 0x64, 0x35, 0x39, 0x34, 0x61, 0x31, 0x61, 0x34, 0x61, 0x63, 0x65, 0x34, 0x62, 0x62, 0x39, 0x63, 0x33, 0x62, 0x32, 0x38, 0x38, 0x61, 0x37, 0x34, 0x64, 0x65, 0x63, 0x66, 0x32, 0x39, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x30, 0x64, 0x31, 0x35, 0x33, 0x62, 0x31, 0x30, 0x33, 0x36, 0x39, 0x31, 0x34, 0x33, 0x66, 0x39, 0x37, 0x66, 0x35, 0x34, 0x62, 0x38, 0x64, 0x34, 0x63, 0x61, 0x32, 0x32, 0x39, 0x65, 0x62, 0x33, 0x65, 0x38, 0x66, 0x33, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x30, 0x62, 0x39, 0x65, 0x61, 0x35, 0x33, 0x66, 0x64, 0x32, 0x36, 0x33, 0x34, 0x31, 0x35, 0x65, 0x61, 0x63, 0x31, 0x31, 0x33, 0x39, 0x31, 0x66, 0x37, 0x63, 0x65, 0x39, 0x31, 0x32, 0x33, 0x63, 0x34, 0x34, 0x37, 0x30, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x63, 0x62, 0x36, 0x37, 0x35, 0x65, 0x30, 0x39, 0x39, 0x36, 0x32, 0x33, 0x35, 0x34, 0x30, 0x34, 0x65, 0x66, 0x61, 0x66, 0x62, 0x62, 0x32, 0x65, 0x63, 0x62, 0x38, 0x31, 0x35, 0x32, 0x32, 0x37, 0x31, 0x62, 0x35, 0x35, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x31, 0x35, 0x65, 0x39, 0x34, 0x30, 0x31, 0x34, 0x33, 0x65, 0x62, 0x35, 0x37, 0x66, 0x38, 0x37, 0x35, 0x38, 0x39, 0x33, 0x62, 0x63, 0x39, 0x38, 0x61, 0x36, 0x31, 0x62, 0x33, 0x64, 0x36, 0x31, 0x38, 0x63, 0x31, 0x65, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x36, 0x66, 0x31, 0x37, 0x37, 0x31, 0x32, 0x31, 0x66, 0x37, 0x38, 0x35, 0x35, 0x63, 0x32, 0x31, 0x61, 0x35, 0x30, 0x36, 0x32, 0x33, 0x33, 0x30, 0x63, 0x38, 0x37, 0x36, 0x32, 0x32, 0x36, 0x34, 0x61, 0x39, 0x37, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x39, 0x32, 0x35, 0x35, 0x30, 0x39, 0x63, 0x38, 0x64, 0x30, 0x62, 0x32, 0x61, 0x36, 0x37, 0x33, 0x38, 0x63, 0x35, 0x66, 0x36, 0x61, 0x37, 0x32, 0x66, 0x33, 0x35, 0x33, 0x31, 0x34, 0x34, 0x39, 0x31, 0x32, 0x34, 0x38, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x32, 0x39, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x30, 0x38, 0x64, 0x39, 0x61, 0x64, 0x38, 0x39, 0x34, 0x66, 0x38, 0x31, 0x33, 0x65, 0x38, 0x65, 0x32, 0x31, 0x34, 0x38, 0x63, 0x31, 0x36, 0x30, 0x64, 0x32, 0x34, 0x62, 0x33, 0x35, 0x33, 0x61, 0x38, 0x65, 0x37, 0x34, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x66, 0x34, 0x66, 0x34, 0x63, 0x30, 0x36, 0x63, 0x37, 0x33, 0x32, 0x63, 0x64, 0x33, 0x35, 0x62, 0x31, 0x31, 0x39, 0x62, 0x38, 0x39, 0x33, 0x62, 0x31, 0x32, 0x37, 0x65, 0x37, 0x64, 0x39, 0x64, 0x30, 0x37, 0x37, 0x31, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x30, 0x36, 0x38, 0x35, 0x34, 0x64, 0x31, 0x34, 0x39, 0x65, 0x30, 0x38, 0x31, 0x61, 0x63, 0x30, 0x39, 0x63, 0x62, 0x34, 0x63, 0x61, 0x35, 0x36, 0x30, 0x64, 0x61, 0x34, 0x36, 0x33, 0x66, 0x33, 0x31, 0x32, 0x33, 0x30, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x66, 0x30, 0x35, 0x64, 0x30, 0x37, 0x65, 0x61, 0x30, 0x32, 0x36, 0x65, 0x37, 0x65, 0x62, 0x66, 0x34, 0x39, 0x34, 0x31, 0x30, 0x30, 0x32, 0x33, 0x33, 0x35, 0x62, 0x61, 0x66, 0x32, 0x66, 0x65, 0x64, 0x30, 0x66, 0x30, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x39, 0x39, 0x30, 0x62, 0x38, 0x61, 0x65, 0x62, 0x35, 0x38, 0x38, 0x64, 0x37, 0x65, 0x65, 0x37, 0x65, 0x63, 0x32, 0x65, 0x64, 0x38, 0x63, 0x32, 0x65, 0x36, 0x34, 0x66, 0x37, 0x33, 0x38, 0x32, 0x61, 0x39, 0x66, 0x65, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x35, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x65, 0x30, 0x36, 0x38, 0x33, 0x61, 0x38, 0x30, 0x35, 0x64, 0x65, 0x36, 0x61, 0x30, 0x35, 0x65, 0x64, 0x62, 0x32, 0x66, 0x66, 0x62, 0x62, 0x35, 0x65, 0x39, 0x36, 0x66, 0x30, 0x35, 0x37, 0x30, 0x62, 0x36, 0x33, 0x37, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x61, 0x35, 0x34, 0x38, 0x36, 0x64, 0x35, 0x33, 0x63, 0x36, 0x65, 0x32, 0x34, 0x30, 0x34, 0x39, 0x34, 0x32, 0x34, 0x31, 0x61, 0x62, 0x66, 0x38, 0x37, 0x65, 0x34, 0x33, 0x63, 0x37, 0x36, 0x30, 0x30, 0x64, 0x34, 0x31, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x37, 0x35, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x31, 0x62, 0x64, 0x35, 0x34, 0x62, 0x61, 0x32, 0x63, 0x34, 0x34, 0x61, 0x36, 0x66, 0x36, 0x62, 0x65, 0x62, 0x31, 0x35, 0x36, 0x31, 0x64, 0x36, 0x38, 0x62, 0x38, 0x30, 0x62, 0x35, 0x34, 0x34, 0x34, 0x65, 0x36, 0x64, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x33, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x39, 0x38, 0x61, 0x62, 0x31, 0x38, 0x32, 0x61, 0x31, 0x39, 0x33, 0x35, 0x39, 0x66, 0x66, 0x63, 0x65, 0x63, 0x61, 0x66, 0x64, 0x37, 0x64, 0x31, 0x62, 0x35, 0x66, 0x61, 0x32, 0x31, 0x32, 0x64, 0x65, 0x64, 0x65, 0x36, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x61, 0x63, 0x62, 0x35, 0x61, 0x64, 0x63, 0x31, 0x31, 0x38, 0x33, 0x39, 0x37, 0x33, 0x32, 0x35, 0x38, 0x64, 0x36, 0x62, 0x38, 0x35, 0x32, 0x34, 0x66, 0x66, 0x61, 0x32, 0x38, 0x66, 0x66, 0x65, 0x62, 0x32, 0x33, 0x64, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x37, 0x61, 0x61, 0x36, 0x37, 0x65, 0x31, 0x32, 0x31, 0x38, 0x33, 0x65, 0x66, 0x39, 0x64, 0x37, 0x34, 0x36, 0x38, 0x65, 0x61, 0x32, 0x38, 0x61, 0x64, 0x32, 0x33, 0x39, 0x63, 0x32, 0x65, 0x65, 0x66, 0x37, 0x31, 0x62, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x39, 0x61, 0x32, 0x30, 0x62, 0x63, 0x34, 0x38, 0x65, 0x37, 0x32, 0x62, 0x65, 0x31, 0x63, 0x64, 0x61, 0x66, 0x39, 0x35, 0x36, 0x39, 0x63, 0x37, 0x31, 0x31, 0x65, 0x38, 0x36, 0x34, 0x38, 0x64, 0x39, 0x35, 0x37, 0x33, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x39, 0x66, 0x38, 0x34, 0x66, 0x30, 0x62, 0x31, 0x64, 0x37, 0x63, 0x34, 0x61, 0x37, 0x63, 0x66, 0x34, 0x39, 0x65, 0x65, 0x37, 0x66, 0x38, 0x62, 0x32, 0x63, 0x34, 0x61, 0x31, 0x33, 0x34, 0x64, 0x65, 0x33, 0x32, 0x38, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x62, 0x61, 0x63, 0x39, 0x35, 0x32, 0x37, 0x62, 0x35, 0x34, 0x64, 0x36, 0x64, 0x66, 0x37, 0x61, 0x65, 0x32, 0x65, 0x30, 0x30, 0x30, 0x63, 0x63, 0x61, 0x33, 0x36, 0x31, 0x33, 0x62, 0x61, 0x30, 0x31, 0x35, 0x63, 0x61, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x39, 0x37, 0x62, 0x37, 0x30, 0x34, 0x37, 0x37, 0x63, 0x61, 0x62, 0x34, 0x32, 0x65, 0x32, 0x62, 0x38, 0x62, 0x32, 0x36, 0x36, 0x36, 0x38, 0x31, 0x66, 0x34, 0x61, 0x65, 0x37, 0x33, 0x37, 0x35, 0x62, 0x62, 0x32, 0x35, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x37, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x63, 0x39, 0x33, 0x34, 0x65, 0x33, 0x38, 0x65, 0x35, 0x33, 0x62, 0x65, 0x33, 0x62, 0x33, 0x33, 0x66, 0x32, 0x37, 0x34, 0x64, 0x30, 0x35, 0x33, 0x39, 0x63, 0x66, 0x63, 0x61, 0x31, 0x35, 0x39, 0x61, 0x34, 0x64, 0x30, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x37, 0x37, 0x65, 0x65, 0x61, 0x65, 0x61, 0x62, 0x37, 0x38, 0x64, 0x35, 0x63, 0x30, 0x30, 0x65, 0x38, 0x33, 0x63, 0x33, 0x32, 0x62, 0x32, 0x64, 0x39, 0x38, 0x66, 0x61, 0x37, 0x39, 0x61, 0x64, 0x35, 0x31, 0x34, 0x38, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x31, 0x31, 0x65, 0x63, 0x66, 0x36, 0x39, 0x64, 0x35, 0x35, 0x31, 0x64, 0x37, 0x66, 0x34, 0x66, 0x38, 0x34, 0x64, 0x66, 0x31, 0x32, 0x38, 0x30, 0x34, 0x36, 0x62, 0x33, 0x61, 0x31, 0x33, 0x32, 0x34, 0x30, 0x61, 0x33, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x66, 0x66, 0x38, 0x38, 0x35, 0x33, 0x65, 0x39, 0x38, 0x65, 0x64, 0x38, 0x34, 0x30, 0x36, 0x62, 0x39, 0x35, 0x30, 0x30, 0x30, 0x61, 0x64, 0x61, 0x38, 0x34, 0x38, 0x33, 0x36, 0x32, 0x64, 0x36, 0x61, 0x30, 0x33, 0x39, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x31, 0x63, 0x66, 0x35, 0x64, 0x33, 0x36, 0x33, 0x37, 0x34, 0x36, 0x66, 0x65, 0x65, 0x36, 0x38, 0x36, 0x34, 0x64, 0x33, 0x63, 0x61, 0x33, 0x33, 0x36, 0x64, 0x64, 0x38, 0x30, 0x36, 0x37, 0x39, 0x62, 0x62, 0x38, 0x37, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x32, 0x32, 0x33, 0x63, 0x31, 0x65, 0x32, 0x32, 0x65, 0x61, 0x63, 0x31, 0x32, 0x36, 0x39, 0x62, 0x33, 0x32, 0x65, 0x65, 0x31, 0x35, 0x36, 0x61, 0x35, 0x33, 0x38, 0x35, 0x39, 0x32, 0x32, 0x65, 0x64, 0x33, 0x36, 0x66, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x36, 0x36, 0x30, 0x30, 0x38, 0x30, 0x36, 0x32, 0x38, 0x39, 0x34, 0x35, 0x34, 0x61, 0x63, 0x64, 0x61, 0x33, 0x33, 0x30, 0x61, 0x32, 0x61, 0x33, 0x35, 0x35, 0x36, 0x30, 0x31, 0x30, 0x64, 0x66, 0x61, 0x63, 0x61, 0x64, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x65, 0x32, 0x63, 0x61, 0x61, 0x66, 0x33, 0x63, 0x65, 0x63, 0x39, 0x37, 0x30, 0x36, 0x31, 0x64, 0x30, 0x39, 0x33, 0x39, 0x37, 0x34, 0x38, 0x37, 0x33, 0x39, 0x62, 0x66, 0x66, 0x65, 0x36, 0x38, 0x34, 0x61, 0x65, 0x39, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x65, 0x62, 0x35, 0x32, 0x62, 0x36, 0x30, 0x34, 0x65, 0x35, 0x66, 0x37, 0x37, 0x66, 0x61, 0x61, 0x61, 0x63, 0x38, 0x38, 0x32, 0x37, 0x35, 0x62, 0x38, 0x64, 0x36, 0x62, 0x34, 0x39, 0x65, 0x39, 0x66, 0x39, 0x66, 0x39, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x38, 0x39, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x33, 0x63, 0x35, 0x36, 0x37, 0x66, 0x30, 0x63, 0x33, 0x66, 0x66, 0x32, 0x65, 0x30, 0x38, 0x62, 0x37, 0x64, 0x35, 0x39, 0x65, 0x32, 0x62, 0x35, 0x63, 0x37, 0x33, 0x34, 0x38, 0x35, 0x34, 0x33, 0x37, 0x66, 0x63, 0x35, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x66, 0x37, 0x35, 0x39, 0x33, 0x33, 0x65, 0x30, 0x31, 0x62, 0x37, 0x35, 0x62, 0x31, 0x35, 0x34, 0x65, 0x66, 0x30, 0x36, 0x36, 0x39, 0x30, 0x37, 0x36, 0x62, 0x65, 0x38, 0x37, 0x66, 0x36, 0x32, 0x64, 0x66, 0x66, 0x61, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x66, 0x64, 0x32, 0x39, 0x36, 0x32, 0x62, 0x35, 0x37, 0x35, 0x62, 0x63, 0x62, 0x65, 0x65, 0x65, 0x39, 0x37, 0x66, 0x34, 0x39, 0x31, 0x34, 0x32, 0x64, 0x36, 0x33, 0x63, 0x33, 0x30, 0x61, 0x62, 0x30, 0x30, 0x39, 0x66, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x36, 0x34, 0x38, 0x35, 0x63, 0x34, 0x32, 0x39, 0x37, 0x61, 0x63, 0x31, 0x35, 0x32, 0x62, 0x32, 0x38, 0x39, 0x62, 0x31, 0x39, 0x64, 0x64, 0x65, 0x33, 0x32, 0x63, 0x37, 0x37, 0x65, 0x63, 0x34, 0x31, 0x37, 0x66, 0x34, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x62, 0x39, 0x37, 0x34, 0x36, 0x37, 0x33, 0x33, 0x36, 0x37, 0x66, 0x35, 0x63, 0x30, 0x37, 0x62, 0x65, 0x35, 0x66, 0x64, 0x32, 0x37, 0x30, 0x64, 0x63, 0x34, 0x62, 0x37, 0x31, 0x33, 0x38, 0x62, 0x30, 0x37, 0x34, 0x64, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x37, 0x30, 0x34, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x64, 0x37, 0x61, 0x66, 0x32, 0x30, 0x34, 0x63, 0x35, 0x36, 0x66, 0x33, 0x31, 0x66, 0x64, 0x39, 0x34, 0x33, 0x39, 0x38, 0x65, 0x34, 0x30, 0x64, 0x66, 0x31, 0x39, 0x36, 0x34, 0x62, 0x64, 0x38, 0x62, 0x66, 0x31, 0x32, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x30, 0x36, 0x66, 0x65, 0x31, 0x39, 0x66, 0x61, 0x34, 0x62, 0x30, 0x30, 0x36, 0x62, 0x61, 0x61, 0x33, 0x39, 0x38, 0x34, 0x35, 0x32, 0x39, 0x64, 0x38, 0x35, 0x31, 0x36, 0x64, 0x62, 0x32, 0x62, 0x32, 0x62, 0x35, 0x30, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x64, 0x63, 0x37, 0x62, 0x61, 0x38, 0x35, 0x34, 0x38, 0x30, 0x62, 0x62, 0x62, 0x33, 0x66, 0x35, 0x33, 0x35, 0x63, 0x30, 0x39, 0x35, 0x36, 0x38, 0x61, 0x61, 0x61, 0x33, 0x61, 0x66, 0x36, 0x66, 0x33, 0x37, 0x32, 0x31, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x31, 0x34, 0x39, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x37, 0x31, 0x63, 0x33, 0x66, 0x32, 0x32, 0x35, 0x38, 0x61, 0x65, 0x66, 0x33, 0x35, 0x65, 0x35, 0x39, 0x39, 0x63, 0x37, 0x64, 0x61, 0x31, 0x61, 0x61, 0x30, 0x37, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x64, 0x61, 0x39, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x35, 0x38, 0x31, 0x63, 0x65, 0x65, 0x32, 0x33, 0x33, 0x30, 0x38, 0x38, 0x63, 0x30, 0x38, 0x36, 0x30, 0x64, 0x39, 0x34, 0x34, 0x65, 0x30, 0x63, 0x66, 0x31, 0x63, 0x65, 0x61, 0x62, 0x62, 0x38, 0x32, 0x36, 0x31, 0x63, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x32, 0x65, 0x33, 0x36, 0x30, 0x37, 0x65, 0x31, 0x32, 0x37, 0x63, 0x61, 0x63, 0x61, 0x30, 0x66, 0x62, 0x64, 0x35, 0x63, 0x35, 0x39, 0x34, 0x38, 0x61, 0x64, 0x61, 0x64, 0x37, 0x64, 0x64, 0x38, 0x33, 0x30, 0x62, 0x32, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x37, 0x65, 0x64, 0x65, 0x38, 0x66, 0x35, 0x32, 0x34, 0x30, 0x61, 0x30, 0x36, 0x35, 0x34, 0x31, 0x65, 0x62, 0x36, 0x39, 0x39, 0x64, 0x37, 0x38, 0x32, 0x63, 0x32, 0x66, 0x39, 0x61, 0x66, 0x62, 0x32, 0x31, 0x37, 0x30, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x38, 0x63, 0x35, 0x34, 0x31, 0x34, 0x62, 0x35, 0x36, 0x62, 0x38, 0x34, 0x35, 0x35, 0x31, 0x37, 0x31, 0x66, 0x62, 0x66, 0x30, 0x37, 0x36, 0x32, 0x32, 0x30, 0x63, 0x31, 0x63, 0x62, 0x61, 0x34, 0x62, 0x35, 0x63, 0x61, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x37, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x38, 0x37, 0x34, 0x35, 0x62, 0x61, 0x33, 0x32, 0x32, 0x66, 0x35, 0x66, 0x64, 0x36, 0x63, 0x62, 0x35, 0x30, 0x31, 0x32, 0x34, 0x65, 0x63, 0x34, 0x36, 0x36, 0x38, 0x38, 0x63, 0x37, 0x61, 0x36, 0x39, 0x61, 0x37, 0x66, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x35, 0x30, 0x36, 0x65, 0x62, 0x34, 0x61, 0x37, 0x38, 0x30, 0x63, 0x39, 0x35, 0x31, 0x63, 0x37, 0x34, 0x61, 0x30, 0x36, 0x62, 0x30, 0x33, 0x64, 0x33, 0x62, 0x38, 0x33, 0x36, 0x32, 0x66, 0x30, 0x39, 0x39, 0x39, 0x64, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x64, 0x36, 0x32, 0x64, 0x66, 0x64, 0x34, 0x36, 0x30, 0x38, 0x37, 0x66, 0x36, 0x32, 0x34, 0x30, 0x39, 0x64, 0x39, 0x33, 0x64, 0x64, 0x36, 0x30, 0x36, 0x31, 0x38, 0x38, 0x65, 0x37, 0x30, 0x65, 0x33, 0x38, 0x31, 0x32, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x65, 0x61, 0x64, 0x61, 0x39, 0x33, 0x63, 0x34, 0x37, 0x35, 0x64, 0x65, 0x64, 0x32, 0x66, 0x37, 0x65, 0x31, 0x35, 0x65, 0x37, 0x37, 0x38, 0x37, 0x64, 0x34, 0x30, 0x30, 0x34, 0x37, 0x30, 0x66, 0x61, 0x35, 0x32, 0x30, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x62, 0x61, 0x62, 0x66, 0x34, 0x32, 0x62, 0x32, 0x36, 0x37, 0x66, 0x64, 0x63, 0x66, 0x33, 0x38, 0x36, 0x31, 0x66, 0x64, 0x64, 0x34, 0x32, 0x33, 0x36, 0x61, 0x35, 0x65, 0x34, 0x37, 0x34, 0x38, 0x34, 0x38, 0x62, 0x33, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x32, 0x36, 0x65, 0x65, 0x63, 0x65, 0x31, 0x61, 0x36, 0x62, 0x64, 0x63, 0x33, 0x65, 0x65, 0x37, 0x62, 0x34, 0x30, 0x30, 0x66, 0x65, 0x39, 0x33, 0x35, 0x62, 0x34, 0x38, 0x34, 0x36, 0x33, 0x66, 0x33, 0x31, 0x62, 0x65, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x62, 0x36, 0x32, 0x38, 0x31, 0x36, 0x65, 0x31, 0x65, 0x33, 0x62, 0x38, 0x64, 0x31, 0x39, 0x62, 0x37, 0x39, 0x64, 0x31, 0x35, 0x31, 0x33, 0x64, 0x35, 0x64, 0x66, 0x61, 0x38, 0x35, 0x35, 0x62, 0x30, 0x63, 0x33, 0x61, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x65, 0x33, 0x63, 0x34, 0x33, 0x39, 0x30, 0x36, 0x39, 0x38, 0x38, 0x30, 0x31, 0x35, 0x36, 0x36, 0x30, 0x30, 0x63, 0x32, 0x38, 0x39, 0x32, 0x65, 0x34, 0x34, 0x38, 0x64, 0x34, 0x31, 0x33, 0x36, 0x63, 0x39, 0x32, 0x64, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x34, 0x61, 0x64, 0x39, 0x33, 0x35, 0x35, 0x33, 0x39, 0x30, 0x65, 0x34, 0x38, 0x38, 0x39, 0x65, 0x66, 0x34, 0x32, 0x61, 0x63, 0x64, 0x31, 0x33, 0x38, 0x62, 0x32, 0x61, 0x32, 0x37, 0x65, 0x37, 0x38, 0x63, 0x30, 0x30, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x62, 0x39, 0x64, 0x36, 0x38, 0x33, 0x63, 0x65, 0x61, 0x31, 0x32, 0x62, 0x61, 0x36, 0x30, 0x30, 0x62, 0x61, 0x61, 0x63, 0x65, 0x32, 0x31, 0x39, 0x62, 0x30, 0x62, 0x33, 0x63, 0x39, 0x37, 0x65, 0x38, 0x63, 0x30, 0x30, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x33, 0x37, 0x66, 0x65, 0x36, 0x65, 0x63, 0x31, 0x30, 0x33, 0x63, 0x61, 0x38, 0x64, 0x31, 0x35, 0x38, 0x66, 0x36, 0x33, 0x62, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x65, 0x63, 0x63, 0x61, 0x63, 0x35, 0x62, 0x33, 0x65, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x34, 0x38, 0x64, 0x38, 0x37, 0x37, 0x62, 0x36, 0x33, 0x61, 0x38, 0x66, 0x38, 0x66, 0x39, 0x33, 0x38, 0x33, 0x65, 0x39, 0x64, 0x30, 0x31, 0x65, 0x35, 0x33, 0x65, 0x38, 0x30, 0x63, 0x35, 0x32, 0x38, 0x65, 0x39, 0x35, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x36, 0x35, 0x64, 0x61, 0x61, 0x33, 0x34, 0x30, 0x33, 0x39, 0x66, 0x37, 0x66, 0x30, 0x64, 0x66, 0x36, 0x32, 0x33, 0x37, 0x35, 0x61, 0x33, 0x37, 0x65, 0x35, 0x61, 0x62, 0x38, 0x61, 0x37, 0x32, 0x62, 0x33, 0x30, 0x31, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x63, 0x64, 0x30, 0x34, 0x38, 0x61, 0x31, 0x31, 0x30, 0x35, 0x37, 0x34, 0x34, 0x38, 0x32, 0x39, 0x38, 0x33, 0x34, 0x39, 0x32, 0x64, 0x66, 0x62, 0x31, 0x62, 0x64, 0x32, 0x37, 0x39, 0x34, 0x32, 0x61, 0x36, 0x39, 0x36, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x31, 0x31, 0x63, 0x65, 0x35, 0x39, 0x61, 0x39, 0x38, 0x62, 0x30, 0x37, 0x32, 0x61, 0x65, 0x39, 0x35, 0x39, 0x64, 0x63, 0x34, 0x39, 0x61, 0x64, 0x35, 0x31, 0x31, 0x64, 0x61, 0x61, 0x61, 0x61, 0x61, 0x31, 0x39, 0x64, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x39, 0x32, 0x35, 0x38, 0x32, 0x66, 0x64, 0x62, 0x61, 0x30, 0x35, 0x65, 0x61, 0x62, 0x63, 0x33, 0x65, 0x35, 0x31, 0x35, 0x33, 0x38, 0x63, 0x35, 0x36, 0x64, 0x62, 0x38, 0x38, 0x31, 0x33, 0x37, 0x38, 0x35, 0x62, 0x33, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x37, 0x65, 0x39, 0x62, 0x62, 0x66, 0x62, 0x62, 0x62, 0x37, 0x31, 0x63, 0x31, 0x61, 0x37, 0x34, 0x30, 0x63, 0x37, 0x34, 0x63, 0x37, 0x32, 0x33, 0x34, 0x32, 0x36, 0x64, 0x66, 0x35, 0x35, 0x64, 0x30, 0x36, 0x33, 0x64, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x39, 0x39, 0x61, 0x31, 0x64, 0x61, 0x39, 0x31, 0x64, 0x35, 0x39, 0x32, 0x30, 0x62, 0x63, 0x31, 0x34, 0x65, 0x30, 0x63, 0x62, 0x39, 0x31, 0x34, 0x66, 0x64, 0x66, 0x36, 0x32, 0x62, 0x39, 0x34, 0x63, 0x62, 0x38, 0x33, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x38, 0x65, 0x36, 0x65, 0x33, 0x36, 0x36, 0x35, 0x35, 0x37, 0x30, 0x64, 0x66, 0x66, 0x37, 0x61, 0x31, 0x62, 0x64, 0x61, 0x36, 0x39, 0x37, 0x61, 0x61, 0x35, 0x38, 0x39, 0x63, 0x30, 0x62, 0x34, 0x65, 0x39, 0x30, 0x32, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x31, 0x34, 0x36, 0x31, 0x61, 0x32, 0x62, 0x30, 0x63, 0x61, 0x39, 0x30, 0x62, 0x61, 0x64, 0x61, 0x63, 0x30, 0x36, 0x61, 0x39, 0x65, 0x61, 0x31, 0x36, 0x65, 0x37, 0x38, 0x37, 0x62, 0x33, 0x33, 0x62, 0x31, 0x39, 0x36, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x31, 0x31, 0x62, 0x32, 0x31, 0x66, 0x31, 0x62, 0x31, 0x32, 0x62, 0x35, 0x30, 0x39, 0x36, 0x31, 0x38, 0x31, 0x35, 0x39, 0x30, 0x64, 0x65, 0x30, 0x37, 0x65, 0x66, 0x38, 0x31, 0x61, 0x38, 0x39, 0x35, 0x33, 0x37, 0x65, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x31, 0x35, 0x35, 0x30, 0x35, 0x37, 0x30, 0x30, 0x32, 0x66, 0x36, 0x62, 0x30, 0x64, 0x31, 0x38, 0x61, 0x63, 0x62, 0x39, 0x33, 0x38, 0x38, 0x64, 0x33, 0x62, 0x63, 0x38, 0x31, 0x32, 0x39, 0x66, 0x38, 0x66, 0x37, 0x61, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x65, 0x32, 0x32, 0x66, 0x39, 0x66, 0x61, 0x33, 0x37, 0x32, 0x34, 0x34, 0x39, 0x61, 0x34, 0x32, 0x30, 0x36, 0x31, 0x30, 0x62, 0x34, 0x37, 0x61, 0x65, 0x30, 0x63, 0x38, 0x64, 0x35, 0x36, 0x35, 0x34, 0x38, 0x31, 0x32, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x32, 0x62, 0x37, 0x34, 0x61, 0x34, 0x37, 0x36, 0x32, 0x38, 0x62, 0x65, 0x33, 0x31, 0x35, 0x62, 0x31, 0x66, 0x37, 0x36, 0x62, 0x33, 0x31, 0x35, 0x30, 0x35, 0x34, 0x61, 0x64, 0x34, 0x34, 0x61, 0x65, 0x39, 0x37, 0x31, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x61, 0x37, 0x63, 0x35, 0x61, 0x36, 0x34, 0x33, 0x36, 0x32, 0x65, 0x39, 0x66, 0x38, 0x34, 0x32, 0x61, 0x32, 0x33, 0x64, 0x65, 0x63, 0x61, 0x32, 0x31, 0x30, 0x33, 0x35, 0x38, 0x35, 0x37, 0x66, 0x38, 0x38, 0x39, 0x38, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x31, 0x33, 0x66, 0x34, 0x35, 0x39, 0x65, 0x30, 0x37, 0x38, 0x61, 0x64, 0x33, 0x61, 0x62, 0x39, 0x35, 0x61, 0x30, 0x39, 0x32, 0x30, 0x32, 0x33, 0x39, 0x66, 0x63, 0x66, 0x31, 0x36, 0x33, 0x33, 0x64, 0x63, 0x30, 0x34, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x39, 0x39, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x39, 0x35, 0x37, 0x62, 0x61, 0x39, 0x34, 0x63, 0x31, 0x62, 0x32, 0x39, 0x65, 0x35, 0x32, 0x37, 0x37, 0x65, 0x63, 0x33, 0x36, 0x36, 0x32, 0x32, 0x37, 0x30, 0x34, 0x39, 0x30, 0x34, 0x63, 0x36, 0x33, 0x64, 0x63, 0x30, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x63, 0x34, 0x30, 0x66, 0x35, 0x33, 0x32, 0x64, 0x66, 0x65, 0x65, 0x35, 0x31, 0x31, 0x38, 0x31, 0x31, 0x37, 0x64, 0x32, 0x61, 0x64, 0x33, 0x35, 0x32, 0x64, 0x61, 0x37, 0x37, 0x64, 0x34, 0x66, 0x36, 0x64, 0x61, 0x32, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x31, 0x65, 0x66, 0x62, 0x33, 0x63, 0x65, 0x37, 0x38, 0x39, 0x62, 0x65, 0x64, 0x65, 0x63, 0x33, 0x64, 0x36, 0x37, 0x63, 0x33, 0x65, 0x31, 0x62, 0x33, 0x62, 0x63, 0x30, 0x65, 0x39, 0x61, 0x61, 0x32, 0x32, 0x37, 0x66, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x31, 0x65, 0x33, 0x38, 0x39, 0x62, 0x32, 0x38, 0x61, 0x33, 0x31, 0x64, 0x38, 0x65, 0x34, 0x39, 0x39, 0x35, 0x62, 0x64, 0x64, 0x37, 0x64, 0x37, 0x63, 0x38, 0x31, 0x62, 0x65, 0x65, 0x61, 0x62, 0x31, 0x65, 0x34, 0x31, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x39, 0x37, 0x61, 0x61, 0x38, 0x61, 0x63, 0x36, 0x39, 0x65, 0x64, 0x66, 0x37, 0x61, 0x39, 0x38, 0x37, 0x64, 0x36, 0x64, 0x37, 0x30, 0x39, 0x37, 0x39, 0x66, 0x38, 0x65, 0x63, 0x31, 0x66, 0x62, 0x63, 0x61, 0x37, 0x61, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x61, 0x64, 0x30, 0x35, 0x35, 0x30, 0x37, 0x63, 0x64, 0x63, 0x38, 0x66, 0x32, 0x34, 0x62, 0x32, 0x62, 0x65, 0x34, 0x63, 0x62, 0x37, 0x66, 0x61, 0x35, 0x64, 0x39, 0x32, 0x37, 0x64, 0x64, 0x62, 0x39, 0x31, 0x31, 0x62, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x34, 0x34, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x65, 0x38, 0x61, 0x66, 0x64, 0x39, 0x33, 0x64, 0x66, 0x61, 0x39, 0x61, 0x66, 0x32, 0x37, 0x66, 0x33, 0x39, 0x62, 0x34, 0x64, 0x66, 0x30, 0x36, 0x30, 0x37, 0x36, 0x37, 0x31, 0x30, 0x62, 0x65, 0x65, 0x33, 0x64, 0x66, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x30, 0x62, 0x32, 0x35, 0x35, 0x65, 0x66, 0x62, 0x35, 0x37, 0x65, 0x31, 0x30, 0x66, 0x37, 0x30, 0x30, 0x38, 0x61, 0x61, 0x32, 0x32, 0x64, 0x34, 0x30, 0x65, 0x39, 0x37, 0x35, 0x32, 0x64, 0x66, 0x63, 0x66, 0x30, 0x33, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x66, 0x35, 0x62, 0x31, 0x32, 0x32, 0x35, 0x38, 0x61, 0x31, 0x38, 0x64, 0x65, 0x63, 0x30, 0x37, 0x64, 0x35, 0x65, 0x63, 0x32, 0x65, 0x33, 0x31, 0x36, 0x35, 0x37, 0x34, 0x39, 0x31, 0x39, 0x64, 0x37, 0x39, 0x64, 0x36, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x36, 0x36, 0x36, 0x37, 0x35, 0x35, 0x62, 0x64, 0x34, 0x31, 0x62, 0x35, 0x39, 0x38, 0x36, 0x39, 0x39, 0x37, 0x37, 0x38, 0x33, 0x63, 0x31, 0x33, 0x30, 0x34, 0x33, 0x30, 0x30, 0x38, 0x32, 0x34, 0x32, 0x62, 0x33, 0x63, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x31, 0x66, 0x35, 0x32, 0x36, 0x31, 0x66, 0x34, 0x66, 0x36, 0x31, 0x32, 0x37, 0x36, 0x30, 0x37, 0x30, 0x36, 0x38, 0x39, 0x32, 0x36, 0x32, 0x35, 0x63, 0x37, 0x35, 0x65, 0x37, 0x62, 0x63, 0x65, 0x39, 0x36, 0x62, 0x37, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x65, 0x31, 0x65, 0x33, 0x33, 0x37, 0x37, 0x38, 0x38, 0x35, 0x63, 0x34, 0x32, 0x64, 0x37, 0x64, 0x66, 0x32, 0x31, 0x38, 0x35, 0x32, 0x32, 0x65, 0x65, 0x37, 0x37, 0x36, 0x36, 0x38, 0x38, 0x37, 0x63, 0x30, 0x35, 0x65, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x34, 0x31, 0x36, 0x33, 0x62, 0x65, 0x39, 0x66, 0x62, 0x62, 0x65, 0x31, 0x63, 0x35, 0x36, 0x39, 0x36, 0x65, 0x65, 0x32, 0x35, 0x35, 0x65, 0x39, 0x30, 0x62, 0x31, 0x33, 0x32, 0x35, 0x34, 0x33, 0x39, 0x35, 0x63, 0x33, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x30, 0x66, 0x31, 0x35, 0x65, 0x35, 0x64, 0x66, 0x38, 0x62, 0x30, 0x65, 0x61, 0x62, 0x64, 0x30, 0x32, 0x35, 0x36, 0x39, 0x35, 0x33, 0x37, 0x61, 0x38, 0x65, 0x66, 0x39, 0x33, 0x62, 0x35, 0x36, 0x37, 0x38, 0x35, 0x63, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x65, 0x65, 0x63, 0x31, 0x65, 0x32, 0x38, 0x38, 0x61, 0x63, 0x33, 0x31, 0x62, 0x36, 0x65, 0x61, 0x62, 0x61, 0x37, 0x65, 0x31, 0x66, 0x62, 0x64, 0x34, 0x66, 0x30, 0x34, 0x61, 0x64, 0x35, 0x37, 0x39, 0x61, 0x36, 0x62, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x32, 0x36, 0x39, 0x34, 0x65, 0x63, 0x30, 0x37, 0x63, 0x66, 0x35, 0x65, 0x34, 0x64, 0x36, 0x38, 0x62, 0x61, 0x34, 0x30, 0x66, 0x33, 0x65, 0x37, 0x61, 0x31, 0x34, 0x63, 0x35, 0x33, 0x66, 0x33, 0x30, 0x33, 0x38, 0x63, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x39, 0x62, 0x34, 0x63, 0x65, 0x66, 0x37, 0x33, 0x33, 0x39, 0x30, 0x63, 0x38, 0x33, 0x61, 0x38, 0x66, 0x64, 0x37, 0x31, 0x64, 0x37, 0x62, 0x35, 0x34, 0x30, 0x61, 0x37, 0x66, 0x39, 0x63, 0x66, 0x38, 0x62, 0x38, 0x63, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x64, 0x65, 0x37, 0x61, 0x35, 0x36, 0x34, 0x63, 0x37, 0x66, 0x34, 0x30, 0x31, 0x32, 0x61, 0x36, 0x66, 0x36, 0x64, 0x31, 0x30, 0x66, 0x64, 0x30, 0x38, 0x66, 0x34, 0x37, 0x38, 0x39, 0x30, 0x66, 0x62, 0x66, 0x30, 0x37, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x33, 0x34, 0x35, 0x62, 0x33, 0x33, 0x66, 0x34, 0x39, 0x63, 0x65, 0x32, 0x37, 0x66, 0x65, 0x38, 0x32, 0x63, 0x66, 0x37, 0x63, 0x38, 0x34, 0x64, 0x31, 0x34, 0x31, 0x63, 0x36, 0x38, 0x66, 0x35, 0x39, 0x30, 0x63, 0x65, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x35, 0x33, 0x62, 0x39, 0x34, 0x39, 0x38, 0x39, 0x64, 0x38, 0x39, 0x39, 0x36, 0x34, 0x64, 0x61, 0x32, 0x30, 0x36, 0x31, 0x35, 0x33, 0x39, 0x35, 0x32, 0x36, 0x62, 0x62, 0x65, 0x39, 0x37, 0x39, 0x64, 0x64, 0x32, 0x65, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x34, 0x31, 0x30, 0x66, 0x62, 0x33, 0x31, 0x30, 0x37, 0x31, 0x31, 0x62, 0x65, 0x30, 0x37, 0x34, 0x61, 0x38, 0x30, 0x38, 0x38, 0x33, 0x63, 0x36, 0x33, 0x35, 0x64, 0x30, 0x65, 0x66, 0x36, 0x61, 0x66, 0x62, 0x32, 0x35, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x33, 0x34, 0x34, 0x65, 0x39, 0x36, 0x32, 0x35, 0x36, 0x37, 0x63, 0x62, 0x32, 0x37, 0x65, 0x34, 0x34, 0x64, 0x62, 0x39, 0x66, 0x32, 0x66, 0x61, 0x63, 0x37, 0x62, 0x36, 0x38, 0x64, 0x66, 0x31, 0x63, 0x31, 0x65, 0x36, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x30, 0x31, 0x36, 0x65, 0x63, 0x31, 0x37, 0x65, 0x63, 0x35, 0x66, 0x31, 0x30, 0x65, 0x33, 0x62, 0x62, 0x39, 0x38, 0x66, 0x66, 0x34, 0x61, 0x31, 0x65, 0x64, 0x61, 0x30, 0x34, 0x35, 0x31, 0x35, 0x37, 0x36, 0x38, 0x32, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x35, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x39, 0x64, 0x61, 0x39, 0x36, 0x65, 0x30, 0x36, 0x62, 0x65, 0x61, 0x66, 0x36, 0x62, 0x64, 0x38, 0x38, 0x30, 0x62, 0x33, 0x37, 0x38, 0x66, 0x30, 0x36, 0x38, 0x30, 0x63, 0x34, 0x33, 0x66, 0x64, 0x32, 0x65, 0x39, 0x64, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x65, 0x65, 0x38, 0x31, 0x61, 0x63, 0x33, 0x33, 0x31, 0x65, 0x66, 0x64, 0x38, 0x66, 0x38, 0x31, 0x31, 0x36, 0x31, 0x63, 0x35, 0x37, 0x33, 0x38, 0x32, 0x62, 0x62, 0x34, 0x35, 0x30, 0x37, 0x62, 0x62, 0x39, 0x65, 0x62, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x63, 0x66, 0x39, 0x30, 0x65, 0x66, 0x35, 0x62, 0x37, 0x36, 0x38, 0x63, 0x35, 0x64, 0x61, 0x35, 0x38, 0x35, 0x30, 0x30, 0x32, 0x63, 0x63, 0x62, 0x65, 0x36, 0x36, 0x31, 0x37, 0x36, 0x35, 0x30, 0x64, 0x38, 0x65, 0x38, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x36, 0x66, 0x61, 0x31, 0x35, 0x30, 0x63, 0x63, 0x38, 0x37, 0x62, 0x35, 0x30, 0x35, 0x36, 0x61, 0x30, 0x37, 0x64, 0x30, 0x30, 0x34, 0x65, 0x66, 0x63, 0x38, 0x34, 0x35, 0x32, 0x34, 0x37, 0x33, 0x39, 0x65, 0x36, 0x32, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x39, 0x62, 0x32, 0x64, 0x63, 0x32, 0x39, 0x36, 0x30, 0x65, 0x34, 0x63, 0x62, 0x39, 0x34, 0x30, 0x38, 0x66, 0x37, 0x34, 0x30, 0x35, 0x38, 0x32, 0x37, 0x63, 0x39, 0x62, 0x35, 0x39, 0x30, 0x37, 0x31, 0x36, 0x31, 0x32, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x66, 0x64, 0x31, 0x37, 0x38, 0x39, 0x65, 0x62, 0x31, 0x32, 0x34, 0x34, 0x61, 0x33, 0x64, 0x65, 0x64, 0x65, 0x30, 0x66, 0x35, 0x64, 0x65, 0x35, 0x38, 0x32, 0x64, 0x38, 0x39, 0x36, 0x33, 0x63, 0x62, 0x31, 0x66, 0x33, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x39, 0x63, 0x35, 0x64, 0x34, 0x62, 0x63, 0x36, 0x66, 0x32, 0x35, 0x64, 0x34, 0x65, 0x34, 0x35, 0x36, 0x63, 0x36, 0x39, 0x37, 0x62, 0x35, 0x32, 0x61, 0x30, 0x37, 0x38, 0x31, 0x31, 0x63, 0x63, 0x64, 0x31, 0x39, 0x66, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x62, 0x37, 0x62, 0x31, 0x64, 0x36, 0x62, 0x33, 0x34, 0x63, 0x65, 0x30, 0x35, 0x33, 0x61, 0x34, 0x30, 0x65, 0x62, 0x36, 0x35, 0x63, 0x64, 0x34, 0x61, 0x34, 0x66, 0x37, 0x64, 0x64, 0x64, 0x64, 0x30, 0x65, 0x39, 0x66, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x38, 0x32, 0x37, 0x36, 0x38, 0x36, 0x63, 0x30, 0x31, 0x36, 0x39, 0x34, 0x38, 0x35, 0x65, 0x63, 0x31, 0x35, 0x62, 0x33, 0x61, 0x37, 0x63, 0x38, 0x63, 0x30, 0x31, 0x35, 0x31, 0x37, 0x61, 0x32, 0x38, 0x37, 0x34, 0x64, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x65, 0x35, 0x63, 0x39, 0x36, 0x37, 0x35, 0x65, 0x66, 0x34, 0x64, 0x65, 0x65, 0x64, 0x32, 0x36, 0x36, 0x62, 0x38, 0x36, 0x39, 0x35, 0x36, 0x66, 0x63, 0x34, 0x35, 0x39, 0x30, 0x65, 0x61, 0x37, 0x64, 0x34, 0x61, 0x32, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x66, 0x38, 0x38, 0x33, 0x65, 0x35, 0x36, 0x37, 0x62, 0x34, 0x33, 0x36, 0x61, 0x32, 0x37, 0x62, 0x62, 0x35, 0x61, 0x33, 0x31, 0x32, 0x34, 0x64, 0x62, 0x63, 0x38, 0x34, 0x64, 0x65, 0x63, 0x37, 0x37, 0x35, 0x61, 0x38, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x34, 0x30, 0x37, 0x36, 0x66, 0x38, 0x34, 0x62, 0x64, 0x39, 0x31, 0x37, 0x66, 0x32, 0x30, 0x66, 0x38, 0x33, 0x34, 0x32, 0x63, 0x39, 0x38, 0x62, 0x61, 0x37, 0x39, 0x65, 0x36, 0x66, 0x62, 0x30, 0x38, 0x65, 0x63, 0x64, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x63, 0x65, 0x36, 0x64, 0x35, 0x62, 0x39, 0x30, 0x31, 0x38, 0x63, 0x65, 0x63, 0x30, 0x34, 0x61, 0x64, 0x36, 0x39, 0x36, 0x37, 0x39, 0x34, 0x34, 0x62, 0x65, 0x61, 0x33, 0x39, 0x65, 0x38, 0x30, 0x33, 0x30, 0x62, 0x36, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x39, 0x36, 0x61, 0x32, 0x37, 0x64, 0x63, 0x33, 0x65, 0x65, 0x31, 0x31, 0x35, 0x66, 0x63, 0x65, 0x32, 0x66, 0x39, 0x34, 0x62, 0x34, 0x38, 0x31, 0x62, 0x63, 0x32, 0x30, 0x37, 0x61, 0x39, 0x65, 0x32, 0x36, 0x31, 0x35, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x37, 0x63, 0x66, 0x39, 0x62, 0x65, 0x61, 0x62, 0x33, 0x36, 0x33, 0x38, 0x33, 0x30, 0x38, 0x64, 0x65, 0x64, 0x37, 0x65, 0x31, 0x39, 0x35, 0x65, 0x30, 0x63, 0x38, 0x36, 0x31, 0x33, 0x32, 0x64, 0x31, 0x36, 0x33, 0x66, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x39, 0x37, 0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x63, 0x65, 0x35, 0x35, 0x64, 0x31, 0x62, 0x36, 0x32, 0x66, 0x35, 0x39, 0x34, 0x33, 0x33, 0x63, 0x32, 0x31, 0x32, 0x36, 0x62, 0x63, 0x65, 0x63, 0x30, 0x39, 0x62, 0x61, 0x66, 0x63, 0x39, 0x64, 0x66, 0x61, 0x61, 0x35, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x64, 0x34, 0x36, 0x64, 0x61, 0x36, 0x37, 0x37, 0x65, 0x31, 0x36, 0x31, 0x38, 0x32, 0x35, 0x65, 0x31, 0x32, 0x65, 0x38, 0x30, 0x64, 0x63, 0x34, 0x34, 0x36, 0x66, 0x35, 0x38, 0x32, 0x37, 0x36, 0x65, 0x31, 0x31, 0x32, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x63, 0x35, 0x34, 0x39, 0x34, 0x61, 0x30, 0x33, 0x61, 0x63, 0x39, 0x31, 0x61, 0x37, 0x36, 0x38, 0x64, 0x66, 0x66, 0x63, 0x30, 0x65, 0x61, 0x31, 0x64, 0x64, 0x65, 0x30, 0x61, 0x63, 0x62, 0x66, 0x38, 0x38, 0x39, 0x30, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x37, 0x66, 0x66, 0x32, 0x63, 0x63, 0x38, 0x30, 0x33, 0x65, 0x33, 0x31, 0x63, 0x39, 0x30, 0x38, 0x32, 0x32, 0x33, 0x33, 0x62, 0x38, 0x32, 0x35, 0x64, 0x30, 0x32, 0x35, 0x62, 0x65, 0x33, 0x66, 0x37, 0x62, 0x31, 0x30, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x39, 0x31, 0x31, 0x37, 0x36, 0x62, 0x65, 0x31, 0x39, 0x62, 0x39, 0x39, 0x36, 0x34, 0x61, 0x38, 0x66, 0x37, 0x32, 0x65, 0x30, 0x65, 0x63, 0x65, 0x36, 0x62, 0x66, 0x38, 0x65, 0x33, 0x63, 0x66, 0x61, 0x64, 0x36, 0x65, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x61, 0x35, 0x36, 0x65, 0x31, 0x31, 0x31, 0x32, 0x36, 0x34, 0x31, 0x63, 0x30, 0x33, 0x38, 0x64, 0x30, 0x35, 0x36, 0x35, 0x61, 0x39, 0x63, 0x32, 0x39, 0x36, 0x63, 0x34, 0x36, 0x33, 0x61, 0x66, 0x65, 0x66, 0x63, 0x31, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x30, 0x33, 0x31, 0x36, 0x37, 0x66, 0x33, 0x64, 0x34, 0x39, 0x36, 0x30, 0x66, 0x65, 0x38, 0x38, 0x31, 0x62, 0x33, 0x32, 0x38, 0x30, 0x30, 0x61, 0x32, 0x62, 0x34, 0x61, 0x65, 0x66, 0x66, 0x31, 0x62, 0x30, 0x38, 0x38, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x33, 0x31, 0x34, 0x31, 0x31, 0x32, 0x37, 0x64, 0x38, 0x63, 0x66, 0x33, 0x31, 0x38, 0x61, 0x65, 0x62, 0x66, 0x38, 0x38, 0x33, 0x36, 0x35, 0x61, 0x64, 0x64, 0x33, 0x64, 0x35, 0x35, 0x32, 0x37, 0x64, 0x38, 0x35, 0x62, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x31, 0x36, 0x62, 0x31, 0x61, 0x30, 0x31, 0x63, 0x64, 0x63, 0x34, 0x65, 0x35, 0x36, 0x65, 0x37, 0x36, 0x35, 0x37, 0x37, 0x31, 0x35, 0x65, 0x61, 0x33, 0x37, 0x65, 0x32, 0x61, 0x30, 0x66, 0x30, 0x38, 0x37, 0x64, 0x31, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x36, 0x30, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x61, 0x34, 0x33, 0x30, 0x61, 0x32, 0x64, 0x34, 0x61, 0x38, 0x39, 0x34, 0x61, 0x30, 0x64, 0x38, 0x61, 0x61, 0x33, 0x66, 0x65, 0x61, 0x63, 0x36, 0x31, 0x35, 0x33, 0x36, 0x31, 0x34, 0x31, 0x35, 0x63, 0x33, 0x66, 0x38, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x61, 0x33, 0x30, 0x31, 0x30, 0x66, 0x30, 0x32, 0x30, 0x31, 0x62, 0x63, 0x39, 0x34, 0x66, 0x66, 0x36, 0x37, 0x61, 0x32, 0x66, 0x36, 0x39, 0x39, 0x64, 0x66, 0x63, 0x32, 0x30, 0x36, 0x66, 0x39, 0x65, 0x37, 0x36, 0x37, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x39, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x61, 0x64, 0x30, 0x39, 0x63, 0x36, 0x64, 0x33, 0x32, 0x36, 0x35, 0x37, 0x36, 0x38, 0x35, 0x33, 0x35, 0x35, 0x62, 0x35, 0x63, 0x36, 0x65, 0x63, 0x38, 0x65, 0x39, 0x66, 0x35, 0x37, 0x62, 0x34, 0x65, 0x62, 0x62, 0x39, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x65, 0x38, 0x30, 0x61, 0x38, 0x32, 0x63, 0x32, 0x30, 0x63, 0x62, 0x65, 0x33, 0x64, 0x32, 0x30, 0x36, 0x30, 0x32, 0x34, 0x32, 0x63, 0x62, 0x39, 0x32, 0x64, 0x37, 0x33, 0x35, 0x38, 0x31, 0x30, 0x64, 0x30, 0x33, 0x34, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x35, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x33, 0x39, 0x30, 0x31, 0x36, 0x32, 0x35, 0x33, 0x35, 0x65, 0x33, 0x39, 0x38, 0x38, 0x37, 0x37, 0x65, 0x34, 0x31, 0x36, 0x37, 0x38, 0x37, 0x64, 0x36, 0x32, 0x33, 0x39, 0x65, 0x30, 0x37, 0x35, 0x34, 0x65, 0x39, 0x33, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x35, 0x66, 0x64, 0x65, 0x61, 0x66, 0x32, 0x61, 0x36, 0x31, 0x66, 0x39, 0x35, 0x64, 0x62, 0x39, 0x30, 0x32, 0x66, 0x39, 0x62, 0x35, 0x61, 0x35, 0x33, 0x63, 0x39, 0x62, 0x38, 0x66, 0x39, 0x32, 0x36, 0x36, 0x63, 0x33, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x65, 0x32, 0x30, 0x63, 0x39, 0x36, 0x64, 0x66, 0x38, 0x64, 0x34, 0x65, 0x33, 0x38, 0x66, 0x35, 0x30, 0x62, 0x32, 0x36, 0x35, 0x61, 0x39, 0x38, 0x61, 0x39, 0x30, 0x36, 0x64, 0x36, 0x31, 0x62, 0x63, 0x35, 0x31, 0x61, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x34, 0x39, 0x66, 0x64, 0x31, 0x64, 0x65, 0x66, 0x35, 0x63, 0x37, 0x36, 0x61, 0x32, 0x38, 0x36, 0x62, 0x33, 0x38, 0x37, 0x32, 0x34, 0x32, 0x34, 0x38, 0x30, 0x39, 0x61, 0x30, 0x37, 0x64, 0x62, 0x33, 0x39, 0x36, 0x36, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x33, 0x36, 0x30, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x63, 0x64, 0x62, 0x37, 0x65, 0x35, 0x31, 0x61, 0x63, 0x34, 0x34, 0x37, 0x37, 0x32, 0x62, 0x65, 0x33, 0x36, 0x39, 0x30, 0x66, 0x36, 0x31, 0x64, 0x30, 0x65, 0x35, 0x39, 0x37, 0x36, 0x36, 0x65, 0x38, 0x62, 0x66, 0x63, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x39, 0x61, 0x34, 0x61, 0x37, 0x36, 0x38, 0x62, 0x35, 0x66, 0x32, 0x33, 0x37, 0x32, 0x34, 0x38, 0x39, 0x33, 0x38, 0x61, 0x31, 0x32, 0x63, 0x36, 0x32, 0x33, 0x38, 0x34, 0x37, 0x62, 0x64, 0x34, 0x65, 0x36, 0x38, 0x38, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x32, 0x34, 0x61, 0x30, 0x30, 0x30, 0x32, 0x33, 0x34, 0x65, 0x62, 0x61, 0x61, 0x66, 0x30, 0x37, 0x38, 0x39, 0x61, 0x31, 0x33, 0x34, 0x61, 0x32, 0x61, 0x34, 0x31, 0x37, 0x33, 0x38, 0x33, 0x63, 0x65, 0x35, 0x32, 0x38, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x34, 0x33, 0x63, 0x37, 0x65, 0x65, 0x61, 0x38, 0x64, 0x36, 0x32, 0x33, 0x35, 0x35, 0x62, 0x30, 0x61, 0x38, 0x61, 0x38, 0x31, 0x64, 0x61, 0x30, 0x38, 0x31, 0x63, 0x36, 0x34, 0x34, 0x36, 0x62, 0x33, 0x33, 0x65, 0x39, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x62, 0x31, 0x38, 0x39, 0x65, 0x66, 0x32, 0x63, 0x32, 0x64, 0x35, 0x37, 0x36, 0x32, 0x61, 0x39, 0x36, 0x33, 0x64, 0x36, 0x62, 0x37, 0x62, 0x64, 0x66, 0x39, 0x36, 0x39, 0x38, 0x65, 0x61, 0x38, 0x65, 0x37, 0x62, 0x34, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x37, 0x66, 0x64, 0x37, 0x37, 0x39, 0x37, 0x64, 0x35, 0x31, 0x36, 0x39, 0x61, 0x30, 0x35, 0x66, 0x37, 0x33, 0x36, 0x34, 0x33, 0x32, 0x31, 0x63, 0x31, 0x39, 0x38, 0x34, 0x33, 0x61, 0x38, 0x63, 0x33, 0x34, 0x38, 0x65, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x32, 0x36, 0x33, 0x39, 0x35, 0x38, 0x38, 0x62, 0x35, 0x35, 0x63, 0x33, 0x34, 0x34, 0x62, 0x30, 0x32, 0x33, 0x65, 0x38, 0x64, 0x65, 0x35, 0x66, 0x64, 0x34, 0x30, 0x38, 0x37, 0x62, 0x31, 0x66, 0x30, 0x34, 0x30, 0x33, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x33, 0x33, 0x64, 0x31, 0x63, 0x32, 0x66, 0x62, 0x35, 0x65, 0x30, 0x38, 0x34, 0x66, 0x32, 0x66, 0x31, 0x64, 0x35, 0x34, 0x62, 0x63, 0x35, 0x32, 0x36, 0x37, 0x37, 0x32, 0x37, 0x66, 0x65, 0x63, 0x33, 0x66, 0x39, 0x38, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x62, 0x31, 0x30, 0x36, 0x36, 0x34, 0x39, 0x61, 0x61, 0x38, 0x63, 0x34, 0x32, 0x31, 0x64, 0x64, 0x63, 0x64, 0x31, 0x62, 0x38, 0x63, 0x33, 0x32, 0x63, 0x64, 0x30, 0x34, 0x31, 0x38, 0x63, 0x66, 0x33, 0x30, 0x64, 0x61, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x35, 0x61, 0x32, 0x34, 0x31, 0x34, 0x35, 0x39, 0x63, 0x36, 0x61, 0x62, 0x62, 0x66, 0x36, 0x33, 0x30, 0x32, 0x33, 0x39, 0x63, 0x39, 0x38, 0x61, 0x33, 0x30, 0x64, 0x32, 0x30, 0x62, 0x38, 0x62, 0x33, 0x61, 0x63, 0x35, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x34, 0x66, 0x39, 0x34, 0x62, 0x39, 0x31, 0x39, 0x31, 0x62, 0x62, 0x37, 0x62, 0x62, 0x35, 0x35, 0x36, 0x61, 0x61, 0x61, 0x64, 0x37, 0x63, 0x37, 0x34, 0x64, 0x64, 0x62, 0x32, 0x38, 0x38, 0x34, 0x31, 0x37, 0x61, 0x35, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x66, 0x34, 0x61, 0x37, 0x64, 0x30, 0x34, 0x65, 0x38, 0x66, 0x61, 0x66, 0x32, 0x30, 0x65, 0x38, 0x63, 0x36, 0x65, 0x62, 0x38, 0x35, 0x39, 0x63, 0x66, 0x37, 0x66, 0x37, 0x38, 0x64, 0x64, 0x32, 0x33, 0x64, 0x37, 0x61, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x37, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x61, 0x64, 0x66, 0x35, 0x39, 0x32, 0x39, 0x61, 0x35, 0x65, 0x32, 0x39, 0x38, 0x31, 0x36, 0x38, 0x34, 0x65, 0x61, 0x32, 0x34, 0x33, 0x62, 0x61, 0x61, 0x30, 0x31, 0x66, 0x37, 0x64, 0x31, 0x66, 0x35, 0x65, 0x31, 0x34, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x35, 0x38, 0x64, 0x38, 0x33, 0x34, 0x38, 0x66, 0x63, 0x31, 0x64, 0x63, 0x34, 0x65, 0x30, 0x64, 0x64, 0x38, 0x33, 0x34, 0x33, 0x62, 0x36, 0x35, 0x34, 0x33, 0x63, 0x38, 0x35, 0x37, 0x30, 0x34, 0x35, 0x65, 0x65, 0x39, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x65, 0x33, 0x62, 0x61, 0x61, 0x33, 0x38, 0x65, 0x31, 0x30, 0x34, 0x61, 0x31, 0x65, 0x32, 0x37, 0x61, 0x34, 0x64, 0x38, 0x32, 0x38, 0x36, 0x39, 0x61, 0x66, 0x62, 0x31, 0x63, 0x30, 0x61, 0x65, 0x36, 0x65, 0x66, 0x66, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x33, 0x35, 0x30, 0x62, 0x35, 0x33, 0x33, 0x31, 0x39, 0x32, 0x36, 0x66, 0x35, 0x65, 0x32, 0x38, 0x66, 0x33, 0x63, 0x31, 0x65, 0x39, 0x38, 0x36, 0x66, 0x39, 0x36, 0x34, 0x34, 0x33, 0x38, 0x30, 0x39, 0x63, 0x38, 0x62, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x35, 0x64, 0x36, 0x36, 0x62, 0x31, 0x33, 0x63, 0x38, 0x37, 0x62, 0x33, 0x39, 0x32, 0x65, 0x39, 0x34, 0x64, 0x39, 0x31, 0x64, 0x35, 0x66, 0x37, 0x36, 0x63, 0x30, 0x64, 0x34, 0x35, 0x30, 0x61, 0x35, 0x35, 0x32, 0x38, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x32, 0x61, 0x38, 0x64, 0x63, 0x62, 0x62, 0x65, 0x65, 0x65, 0x66, 0x37, 0x62, 0x33, 0x36, 0x30, 0x36, 0x38, 0x35, 0x64, 0x32, 0x37, 0x33, 0x30, 0x33, 0x62, 0x64, 0x36, 0x39, 0x65, 0x30, 0x39, 0x34, 0x61, 0x63, 0x63, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x64, 0x39, 0x39, 0x33, 0x34, 0x64, 0x37, 0x62, 0x32, 0x39, 0x32, 0x62, 0x63, 0x66, 0x36, 0x30, 0x33, 0x62, 0x32, 0x38, 0x38, 0x30, 0x37, 0x34, 0x31, 0x65, 0x62, 0x37, 0x36, 0x30, 0x32, 0x38, 0x38, 0x33, 0x38, 0x33, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x63, 0x35, 0x33, 0x36, 0x36, 0x32, 0x33, 0x37, 0x31, 0x64, 0x63, 0x61, 0x35, 0x38, 0x37, 0x62, 0x35, 0x39, 0x38, 0x35, 0x30, 0x64, 0x65, 0x37, 0x38, 0x36, 0x30, 0x36, 0x65, 0x32, 0x33, 0x35, 0x39, 0x64, 0x66, 0x33, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x36, 0x39, 0x63, 0x30, 0x31, 0x37, 0x33, 0x33, 0x35, 0x32, 0x62, 0x31, 0x30, 0x62, 0x66, 0x36, 0x38, 0x33, 0x34, 0x37, 0x31, 0x39, 0x64, 0x62, 0x35, 0x62, 0x65, 0x64, 0x30, 0x31, 0x61, 0x64, 0x66, 0x39, 0x37, 0x62, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x61, 0x39, 0x33, 0x34, 0x35, 0x37, 0x34, 0x39, 0x36, 0x66, 0x31, 0x31, 0x30, 0x38, 0x63, 0x64, 0x39, 0x38, 0x65, 0x31, 0x34, 0x30, 0x61, 0x31, 0x65, 0x63, 0x64, 0x62, 0x61, 0x65, 0x35, 0x65, 0x36, 0x64, 0x65, 0x31, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x66, 0x66, 0x38, 0x39, 0x30, 0x31, 0x62, 0x35, 0x34, 0x31, 0x37, 0x36, 0x33, 0x66, 0x38, 0x31, 0x37, 0x63, 0x35, 0x66, 0x32, 0x39, 0x39, 0x38, 0x66, 0x30, 0x32, 0x64, 0x63, 0x66, 0x63, 0x31, 0x64, 0x66, 0x32, 0x39, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x63, 0x32, 0x37, 0x64, 0x36, 0x33, 0x66, 0x64, 0x65, 0x32, 0x34, 0x62, 0x39, 0x32, 0x65, 0x65, 0x38, 0x61, 0x31, 0x65, 0x37, 0x65, 0x64, 0x35, 0x64, 0x32, 0x36, 0x64, 0x38, 0x64, 0x63, 0x35, 0x63, 0x38, 0x33, 0x62, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x66, 0x38, 0x31, 0x62, 0x31, 0x62, 0x32, 0x36, 0x66, 0x63, 0x38, 0x34, 0x64, 0x36, 0x64, 0x65, 0x39, 0x37, 0x65, 0x66, 0x38, 0x62, 0x39, 0x66, 0x62, 0x64, 0x37, 0x32, 0x61, 0x33, 0x33, 0x31, 0x33, 0x30, 0x63, 0x63, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x32, 0x30, 0x65, 0x66, 0x39, 0x37, 0x30, 0x34, 0x36, 0x37, 0x30, 0x61, 0x35, 0x30, 0x30, 0x62, 0x62, 0x32, 0x36, 0x39, 0x62, 0x35, 0x38, 0x33, 0x32, 0x65, 0x38, 0x35, 0x39, 0x38, 0x30, 0x32, 0x30, 0x34, 0x39, 0x66, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x36, 0x61, 0x66, 0x64, 0x63, 0x30, 0x38, 0x35, 0x66, 0x32, 0x61, 0x33, 0x64, 0x63, 0x65, 0x34, 0x36, 0x31, 0x35, 0x65, 0x64, 0x66, 0x66, 0x62, 0x61, 0x64, 0x66, 0x37, 0x31, 0x61, 0x31, 0x31, 0x37, 0x38, 0x30, 0x66, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x66, 0x30, 0x63, 0x36, 0x33, 0x66, 0x37, 0x30, 0x32, 0x34, 0x31, 0x62, 0x65, 0x63, 0x65, 0x31, 0x39, 0x62, 0x37, 0x33, 0x37, 0x65, 0x35, 0x33, 0x34, 0x31, 0x62, 0x31, 0x32, 0x62, 0x31, 0x30, 0x39, 0x30, 0x33, 0x31, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x34, 0x31, 0x37, 0x34, 0x61, 0x61, 0x36, 0x61, 0x66, 0x32, 0x38, 0x34, 0x37, 0x36, 0x65, 0x32, 0x32, 0x39, 0x64, 0x61, 0x64, 0x62, 0x34, 0x36, 0x31, 0x38, 0x30, 0x38, 0x30, 0x38, 0x63, 0x36, 0x37, 0x35, 0x30, 0x35, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x31, 0x39, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x65, 0x63, 0x34, 0x39, 0x63, 0x36, 0x36, 0x35, 0x65, 0x36, 0x34, 0x65, 0x65, 0x38, 0x39, 0x64, 0x64, 0x34, 0x34, 0x31, 0x65, 0x65, 0x37, 0x34, 0x30, 0x35, 0x36, 0x65, 0x31, 0x66, 0x30, 0x31, 0x65, 0x39, 0x32, 0x38, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x64, 0x32, 0x32, 0x38, 0x64, 0x63, 0x37, 0x31, 0x32, 0x31, 0x36, 0x39, 0x33, 0x30, 0x37, 0x66, 0x65, 0x32, 0x37, 0x63, 0x65, 0x62, 0x37, 0x34, 0x37, 0x37, 0x62, 0x34, 0x38, 0x63, 0x66, 0x63, 0x38, 0x32, 0x37, 0x32, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x39, 0x31, 0x38, 0x35, 0x33, 0x36, 0x61, 0x38, 0x65, 0x66, 0x61, 0x36, 0x66, 0x36, 0x63, 0x65, 0x66, 0x65, 0x31, 0x66, 0x61, 0x31, 0x31, 0x35, 0x33, 0x39, 0x39, 0x35, 0x66, 0x65, 0x66, 0x35, 0x65, 0x33, 0x33, 0x64, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x62, 0x62, 0x35, 0x30, 0x34, 0x61, 0x35, 0x64, 0x63, 0x35, 0x32, 0x37, 0x64, 0x33, 0x65, 0x33, 0x65, 0x62, 0x30, 0x30, 0x38, 0x35, 0x65, 0x32, 0x66, 0x63, 0x33, 0x63, 0x37, 0x64, 0x64, 0x35, 0x33, 0x38, 0x63, 0x62, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x39, 0x39, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x62, 0x33, 0x32, 0x33, 0x61, 0x65, 0x35, 0x30, 0x35, 0x36, 0x65, 0x64, 0x30, 0x61, 0x34, 0x35, 0x33, 0x30, 0x37, 0x32, 0x63, 0x35, 0x61, 0x62, 0x65, 0x32, 0x65, 0x34, 0x32, 0x66, 0x63, 0x66, 0x35, 0x64, 0x37, 0x31, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x64, 0x36, 0x38, 0x32, 0x61, 0x32, 0x38, 0x32, 0x65, 0x66, 0x37, 0x33, 0x66, 0x62, 0x38, 0x64, 0x36, 0x65, 0x39, 0x30, 0x37, 0x31, 0x65, 0x32, 0x36, 0x31, 0x34, 0x66, 0x34, 0x37, 0x61, 0x62, 0x31, 0x64, 0x30, 0x66, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x35, 0x38, 0x63, 0x66, 0x31, 0x31, 0x61, 0x65, 0x61, 0x37, 0x39, 0x66, 0x35, 0x33, 0x39, 0x38, 0x61, 0x64, 0x32, 0x62, 0x62, 0x32, 0x32, 0x32, 0x36, 0x37, 0x62, 0x35, 0x61, 0x33, 0x63, 0x39, 0x35, 0x32, 0x65, 0x61, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x64, 0x36, 0x63, 0x61, 0x63, 0x61, 0x32, 0x32, 0x62, 0x63, 0x63, 0x64, 0x36, 0x61, 0x37, 0x32, 0x66, 0x38, 0x37, 0x65, 0x65, 0x37, 0x64, 0x36, 0x62, 0x35, 0x39, 0x65, 0x30, 0x62, 0x64, 0x65, 0x32, 0x31, 0x64, 0x37, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x61, 0x36, 0x33, 0x63, 0x62, 0x64, 0x61, 0x34, 0x35, 0x64, 0x64, 0x34, 0x38, 0x37, 0x61, 0x33, 0x66, 0x31, 0x63, 0x64, 0x34, 0x61, 0x37, 0x34, 0x36, 0x61, 0x30, 0x31, 0x62, 0x62, 0x35, 0x65, 0x30, 0x36, 0x30, 0x62, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x39, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x30, 0x34, 0x37, 0x36, 0x65, 0x32, 0x65, 0x66, 0x64, 0x66, 0x65, 0x65, 0x34, 0x66, 0x33, 0x38, 0x37, 0x62, 0x30, 0x66, 0x33, 0x32, 0x61, 0x35, 0x30, 0x36, 0x37, 0x38, 0x62, 0x30, 0x65, 0x66, 0x62, 0x35, 0x37, 0x33, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x35, 0x61, 0x61, 0x31, 0x65, 0x36, 0x63, 0x32, 0x62, 0x36, 0x30, 0x66, 0x36, 0x66, 0x64, 0x33, 0x65, 0x66, 0x65, 0x37, 0x32, 0x31, 0x62, 0x62, 0x34, 0x61, 0x37, 0x31, 0x39, 0x63, 0x62, 0x65, 0x33, 0x64, 0x36, 0x66, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x35, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x32, 0x65, 0x37, 0x36, 0x36, 0x64, 0x61, 0x63, 0x33, 0x66, 0x36, 0x34, 0x38, 0x66, 0x36, 0x33, 0x37, 0x61, 0x63, 0x36, 0x37, 0x31, 0x33, 0x66, 0x64, 0x64, 0x62, 0x30, 0x36, 0x38, 0x65, 0x34, 0x61, 0x34, 0x66, 0x30, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x39, 0x31, 0x64, 0x64, 0x63, 0x39, 0x62, 0x36, 0x34, 0x61, 0x38, 0x65, 0x30, 0x38, 0x39, 0x30, 0x62, 0x34, 0x33, 0x32, 0x33, 0x37, 0x30, 0x39, 0x64, 0x37, 0x61, 0x30, 0x37, 0x63, 0x34, 0x38, 0x62, 0x39, 0x32, 0x61, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x34, 0x66, 0x30, 0x66, 0x66, 0x32, 0x61, 0x65, 0x62, 0x36, 0x37, 0x64, 0x35, 0x34, 0x63, 0x65, 0x33, 0x62, 0x63, 0x38, 0x63, 0x36, 0x35, 0x31, 0x30, 0x62, 0x39, 0x61, 0x65, 0x38, 0x33, 0x65, 0x39, 0x64, 0x33, 0x32, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x32, 0x33, 0x66, 0x36, 0x32, 0x64, 0x66, 0x66, 0x30, 0x64, 0x36, 0x34, 0x36, 0x30, 0x30, 0x33, 0x36, 0x63, 0x36, 0x32, 0x65, 0x38, 0x34, 0x30, 0x61, 0x65, 0x63, 0x35, 0x35, 0x37, 0x37, 0x65, 0x30, 0x62, 0x65, 0x66, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x64, 0x63, 0x32, 0x36, 0x65, 0x63, 0x36, 0x37, 0x30, 0x61, 0x33, 0x31, 0x65, 0x30, 0x32, 0x32, 0x31, 0x64, 0x32, 0x61, 0x37, 0x35, 0x62, 0x63, 0x35, 0x64, 0x63, 0x39, 0x66, 0x39, 0x30, 0x63, 0x31, 0x66, 0x36, 0x66, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x38, 0x63, 0x39, 0x39, 0x34, 0x61, 0x37, 0x39, 0x30, 0x30, 0x33, 0x66, 0x65, 0x37, 0x62, 0x37, 0x63, 0x32, 0x36, 0x63, 0x63, 0x36, 0x33, 0x32, 0x31, 0x32, 0x65, 0x31, 0x66, 0x63, 0x32, 0x66, 0x39, 0x63, 0x31, 0x39, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x63, 0x32, 0x38, 0x34, 0x62, 0x61, 0x31, 0x30, 0x61, 0x32, 0x30, 0x38, 0x33, 0x30, 0x66, 0x63, 0x33, 0x64, 0x36, 0x39, 0x39, 0x65, 0x63, 0x39, 0x37, 0x64, 0x32, 0x64, 0x66, 0x61, 0x32, 0x37, 0x65, 0x31, 0x62, 0x39, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x61, 0x33, 0x66, 0x33, 0x32, 0x65, 0x66, 0x34, 0x30, 0x38, 0x36, 0x34, 0x34, 0x38, 0x62, 0x33, 0x34, 0x34, 0x64, 0x35, 0x66, 0x30, 0x61, 0x39, 0x38, 0x39, 0x30, 0x64, 0x31, 0x63, 0x65, 0x34, 0x64, 0x36, 0x31, 0x37, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x35, 0x61, 0x62, 0x63, 0x38, 0x64, 0x30, 0x38, 0x61, 0x30, 0x39, 0x36, 0x61, 0x38, 0x38, 0x66, 0x33, 0x64, 0x36, 0x61, 0x62, 0x35, 0x35, 0x66, 0x62, 0x63, 0x37, 0x33, 0x35, 0x32, 0x62, 0x64, 0x64, 0x63, 0x62, 0x39, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x36, 0x30, 0x65, 0x35, 0x31, 0x66, 0x30, 0x62, 0x65, 0x32, 0x32, 0x38, 0x65, 0x34, 0x64, 0x35, 0x36, 0x66, 0x64, 0x64, 0x32, 0x39, 0x39, 0x32, 0x63, 0x38, 0x31, 0x34, 0x64, 0x61, 0x37, 0x37, 0x34, 0x30, 0x63, 0x36, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x33, 0x35, 0x36, 0x63, 0x66, 0x64, 0x62, 0x39, 0x35, 0x66, 0x65, 0x62, 0x62, 0x37, 0x31, 0x34, 0x36, 0x33, 0x33, 0x62, 0x32, 0x38, 0x64, 0x35, 0x63, 0x31, 0x33, 0x32, 0x64, 0x64, 0x38, 0x34, 0x61, 0x39, 0x62, 0x34, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x36, 0x32, 0x65, 0x35, 0x31, 0x33, 0x34, 0x63, 0x36, 0x31, 0x32, 0x66, 0x31, 0x32, 0x36, 0x39, 0x34, 0x64, 0x62, 0x64, 0x30, 0x65, 0x31, 0x33, 0x31, 0x64, 0x34, 0x63, 0x65, 0x31, 0x39, 0x37, 0x64, 0x31, 0x62, 0x36, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x38, 0x36, 0x32, 0x36, 0x31, 0x36, 0x66, 0x63, 0x62, 0x66, 0x62, 0x33, 0x62, 0x65, 0x63, 0x62, 0x37, 0x34, 0x30, 0x36, 0x66, 0x37, 0x33, 0x63, 0x35, 0x63, 0x62, 0x66, 0x66, 0x30, 0x30, 0x63, 0x39, 0x34, 0x30, 0x37, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x63, 0x39, 0x62, 0x32, 0x37, 0x31, 0x66, 0x66, 0x64, 0x35, 0x62, 0x37, 0x37, 0x30, 0x61, 0x35, 0x65, 0x65, 0x65, 0x34, 0x65, 0x64, 0x63, 0x39, 0x37, 0x38, 0x37, 0x62, 0x35, 0x63, 0x64, 0x63, 0x37, 0x30, 0x39, 0x37, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x39, 0x32, 0x35, 0x36, 0x31, 0x39, 0x63, 0x39, 0x62, 0x33, 0x33, 0x31, 0x34, 0x34, 0x34, 0x36, 0x33, 0x66, 0x30, 0x35, 0x33, 0x37, 0x64, 0x38, 0x39, 0x36, 0x33, 0x35, 0x38, 0x37, 0x30, 0x36, 0x63, 0x35, 0x32, 0x30, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x65, 0x32, 0x65, 0x32, 0x38, 0x63, 0x33, 0x66, 0x62, 0x37, 0x34, 0x37, 0x34, 0x39, 0x64, 0x37, 0x65, 0x37, 0x38, 0x30, 0x64, 0x63, 0x38, 0x61, 0x35, 0x64, 0x34, 0x32, 0x32, 0x35, 0x33, 0x38, 0x65, 0x36, 0x65, 0x34, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x33, 0x33, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x31, 0x39, 0x35, 0x61, 0x36, 0x33, 0x35, 0x64, 0x63, 0x63, 0x36, 0x32, 0x66, 0x35, 0x36, 0x61, 0x37, 0x31, 0x38, 0x30, 0x34, 0x39, 0x64, 0x34, 0x37, 0x65, 0x38, 0x66, 0x39, 0x66, 0x39, 0x36, 0x38, 0x33, 0x32, 0x38, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x65, 0x39, 0x61, 0x39, 0x61, 0x38, 0x32, 0x65, 0x64, 0x61, 0x61, 0x38, 0x31, 0x34, 0x63, 0x32, 0x38, 0x34, 0x64, 0x32, 0x33, 0x32, 0x62, 0x36, 0x65, 0x39, 0x62, 0x61, 0x39, 0x30, 0x37, 0x30, 0x31, 0x64, 0x34, 0x39, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x63, 0x34, 0x61, 0x62, 0x39, 0x30, 0x37, 0x32, 0x62, 0x34, 0x65, 0x36, 0x65, 0x33, 0x36, 0x35, 0x34, 0x61, 0x34, 0x39, 0x66, 0x38, 0x61, 0x38, 0x64, 0x62, 0x30, 0x32, 0x36, 0x61, 0x34, 0x62, 0x33, 0x33, 0x38, 0x36, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x39, 0x64, 0x65, 0x65, 0x33, 0x66, 0x37, 0x36, 0x37, 0x39, 0x66, 0x66, 0x31, 0x30, 0x33, 0x30, 0x37, 0x33, 0x33, 0x66, 0x39, 0x33, 0x34, 0x30, 0x63, 0x30, 0x39, 0x36, 0x36, 0x38, 0x36, 0x62, 0x34, 0x39, 0x33, 0x39, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x38, 0x35, 0x35, 0x38, 0x64, 0x30, 0x38, 0x63, 0x66, 0x63, 0x62, 0x31, 0x30, 0x31, 0x31, 0x38, 0x31, 0x64, 0x61, 0x63, 0x31, 0x65, 0x62, 0x36, 0x30, 0x39, 0x34, 0x62, 0x34, 0x65, 0x31, 0x61, 0x38, 0x39, 0x36, 0x66, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x39, 0x30, 0x66, 0x38, 0x31, 0x33, 0x30, 0x65, 0x63, 0x34, 0x34, 0x34, 0x36, 0x36, 0x61, 0x66, 0x61, 0x64, 0x62, 0x33, 0x36, 0x65, 0x64, 0x33, 0x63, 0x39, 0x32, 0x36, 0x31, 0x33, 0x33, 0x39, 0x36, 0x33, 0x36, 0x37, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x36, 0x34, 0x38, 0x35, 0x30, 0x33, 0x62, 0x31, 0x63, 0x63, 0x63, 0x35, 0x62, 0x38, 0x62, 0x65, 0x30, 0x33, 0x66, 0x61, 0x31, 0x65, 0x63, 0x34, 0x66, 0x33, 0x65, 0x65, 0x32, 0x36, 0x37, 0x65, 0x36, 0x61, 0x64, 0x66, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x62, 0x34, 0x32, 0x66, 0x61, 0x65, 0x63, 0x63, 0x31, 0x65, 0x64, 0x66, 0x62, 0x31, 0x34, 0x32, 0x38, 0x33, 0x63, 0x61, 0x39, 0x37, 0x39, 0x61, 0x66, 0x35, 0x34, 0x35, 0x66, 0x36, 0x33, 0x62, 0x33, 0x30, 0x65, 0x36, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x32, 0x30, 0x66, 0x38, 0x62, 0x63, 0x63, 0x38, 0x31, 0x36, 0x34, 0x61, 0x36, 0x31, 0x35, 0x32, 0x61, 0x39, 0x39, 0x64, 0x36, 0x62, 0x39, 0x39, 0x36, 0x39, 0x33, 0x30, 0x30, 0x35, 0x63, 0x63, 0x66, 0x37, 0x65, 0x30, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x62, 0x34, 0x62, 0x37, 0x34, 0x65, 0x36, 0x36, 0x32, 0x33, 0x62, 0x61, 0x39, 0x64, 0x31, 0x35, 0x38, 0x33, 0x65, 0x30, 0x63, 0x66, 0x62, 0x65, 0x34, 0x39, 0x36, 0x34, 0x33, 0x66, 0x31, 0x36, 0x33, 0x38, 0x34, 0x31, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x33, 0x31, 0x30, 0x61, 0x31, 0x36, 0x63, 0x63, 0x36, 0x61, 0x62, 0x63, 0x34, 0x36, 0x35, 0x30, 0x30, 0x37, 0x36, 0x39, 0x34, 0x62, 0x39, 0x33, 0x30, 0x66, 0x39, 0x37, 0x38, 0x65, 0x63, 0x65, 0x31, 0x39, 0x33, 0x30, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x30, 0x31, 0x39, 0x61, 0x34, 0x64, 0x61, 0x66, 0x61, 0x62, 0x34, 0x33, 0x66, 0x34, 0x64, 0x39, 0x62, 0x66, 0x34, 0x31, 0x36, 0x33, 0x66, 0x61, 0x65, 0x30, 0x38, 0x34, 0x37, 0x64, 0x38, 0x34, 0x38, 0x61, 0x66, 0x63, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x39, 0x32, 0x39, 0x38, 0x61, 0x39, 0x64, 0x65, 0x31, 0x34, 0x37, 0x65, 0x36, 0x33, 0x61, 0x31, 0x63, 0x37, 0x64, 0x36, 0x64, 0x32, 0x66, 0x63, 0x65, 0x30, 0x38, 0x39, 0x63, 0x37, 0x65, 0x36, 0x34, 0x30, 0x38, 0x33, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x30, 0x39, 0x37, 0x33, 0x38, 0x30, 0x37, 0x62, 0x32, 0x66, 0x34, 0x32, 0x36, 0x39, 0x31, 0x34, 0x61, 0x64, 0x30, 0x30, 0x31, 0x38, 0x31, 0x32, 0x37, 0x30, 0x61, 0x63, 0x64, 0x32, 0x37, 0x62, 0x38, 0x66, 0x66, 0x36, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x37, 0x62, 0x63, 0x66, 0x31, 0x63, 0x63, 0x35, 0x64, 0x34, 0x34, 0x36, 0x32, 0x65, 0x35, 0x31, 0x32, 0x34, 0x63, 0x39, 0x36, 0x35, 0x65, 0x63, 0x66, 0x30, 0x64, 0x37, 0x30, 0x64, 0x63, 0x32, 0x37, 0x61, 0x63, 0x61, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x66, 0x37, 0x39, 0x38, 0x65, 0x30, 0x37, 0x37, 0x62, 0x30, 0x37, 0x64, 0x38, 0x36, 0x31, 0x32, 0x34, 0x65, 0x31, 0x34, 0x30, 0x37, 0x64, 0x66, 0x33, 0x32, 0x38, 0x39, 0x30, 0x64, 0x62, 0x62, 0x34, 0x62, 0x36, 0x33, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x62, 0x64, 0x39, 0x32, 0x31, 0x64, 0x62, 0x65, 0x31, 0x32, 0x31, 0x35, 0x36, 0x33, 0x62, 0x39, 0x38, 0x61, 0x36, 0x38, 0x37, 0x31, 0x66, 0x65, 0x63, 0x62, 0x31, 0x34, 0x66, 0x31, 0x63, 0x63, 0x37, 0x65, 0x38, 0x38, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x34, 0x32, 0x32, 0x37, 0x36, 0x64, 0x66, 0x32, 0x39, 0x38, 0x33, 0x66, 0x65, 0x32, 0x62, 0x63, 0x34, 0x37, 0x35, 0x39, 0x64, 0x63, 0x31, 0x39, 0x34, 0x33, 0x65, 0x31, 0x38, 0x66, 0x64, 0x62, 0x63, 0x33, 0x34, 0x66, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x32, 0x62, 0x32, 0x32, 0x38, 0x30, 0x35, 0x32, 0x33, 0x37, 0x36, 0x38, 0x65, 0x61, 0x38, 0x61, 0x63, 0x33, 0x35, 0x63, 0x64, 0x39, 0x65, 0x38, 0x38, 0x38, 0x64, 0x36, 0x30, 0x61, 0x37, 0x31, 0x39, 0x33, 0x30, 0x30, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x34, 0x64, 0x61, 0x37, 0x35, 0x33, 0x34, 0x33, 0x30, 0x66, 0x63, 0x30, 0x39, 0x65, 0x37, 0x33, 0x61, 0x63, 0x62, 0x63, 0x63, 0x64, 0x63, 0x64, 0x65, 0x39, 0x64, 0x61, 0x36, 0x34, 0x37, 0x66, 0x32, 0x62, 0x35, 0x64, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x34, 0x32, 0x32, 0x33, 0x64, 0x32, 0x37, 0x66, 0x66, 0x32, 0x33, 0x65, 0x35, 0x39, 0x30, 0x36, 0x63, 0x61, 0x65, 0x64, 0x32, 0x32, 0x35, 0x39, 0x35, 0x37, 0x30, 0x31, 0x62, 0x62, 0x33, 0x34, 0x38, 0x33, 0x30, 0x63, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x34, 0x33, 0x30, 0x64, 0x37, 0x37, 0x39, 0x36, 0x39, 0x36, 0x61, 0x33, 0x36, 0x35, 0x33, 0x66, 0x63, 0x36, 0x30, 0x65, 0x37, 0x34, 0x66, 0x62, 0x63, 0x62, 0x61, 0x63, 0x66, 0x36, 0x62, 0x39, 0x63, 0x32, 0x62, 0x61, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x32, 0x33, 0x32, 0x31, 0x30, 0x37, 0x39, 0x33, 0x32, 0x62, 0x31, 0x32, 0x65, 0x30, 0x33, 0x31, 0x38, 0x36, 0x35, 0x38, 0x33, 0x35, 0x32, 0x35, 0x63, 0x65, 0x30, 0x32, 0x33, 0x61, 0x37, 0x30, 0x33, 0x65, 0x66, 0x38, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x64, 0x31, 0x34, 0x64, 0x38, 0x31, 0x62, 0x36, 0x30, 0x62, 0x32, 0x33, 0x66, 0x62, 0x32, 0x35, 0x30, 0x35, 0x34, 0x64, 0x38, 0x39, 0x32, 0x35, 0x64, 0x66, 0x61, 0x35, 0x37, 0x33, 0x64, 0x63, 0x61, 0x65, 0x36, 0x31, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x33, 0x33, 0x38, 0x34, 0x31, 0x31, 0x66, 0x32, 0x36, 0x63, 0x63, 0x66, 0x33, 0x37, 0x36, 0x35, 0x38, 0x63, 0x63, 0x37, 0x35, 0x35, 0x32, 0x31, 0x64, 0x37, 0x37, 0x36, 0x32, 0x39, 0x30, 0x39, 0x39, 0x65, 0x34, 0x36, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x37, 0x36, 0x32, 0x32, 0x61, 0x63, 0x39, 0x62, 0x62, 0x64, 0x63, 0x34, 0x64, 0x38, 0x32, 0x62, 0x37, 0x35, 0x30, 0x31, 0x35, 0x64, 0x37, 0x34, 0x35, 0x62, 0x39, 0x66, 0x38, 0x64, 0x65, 0x36, 0x35, 0x61, 0x32, 0x38, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x64, 0x37, 0x37, 0x34, 0x34, 0x31, 0x38, 0x34, 0x34, 0x61, 0x66, 0x65, 0x39, 0x63, 0x63, 0x31, 0x38, 0x66, 0x31, 0x35, 0x64, 0x38, 0x63, 0x37, 0x37, 0x62, 0x63, 0x63, 0x66, 0x62, 0x36, 0x35, 0x35, 0x65, 0x65, 0x30, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x38, 0x34, 0x39, 0x62, 0x65, 0x31, 0x61, 0x66, 0x32, 0x30, 0x31, 0x30, 0x30, 0x65, 0x62, 0x38, 0x61, 0x33, 0x62, 0x61, 0x35, 0x61, 0x35, 0x62, 0x65, 0x34, 0x64, 0x33, 0x61, 0x65, 0x38, 0x64, 0x62, 0x35, 0x61, 0x37, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x35, 0x38, 0x36, 0x64, 0x61, 0x34, 0x65, 0x35, 0x39, 0x35, 0x38, 0x33, 0x63, 0x38, 0x64, 0x38, 0x36, 0x63, 0x63, 0x63, 0x66, 0x37, 0x31, 0x61, 0x38, 0x36, 0x31, 0x39, 0x37, 0x66, 0x31, 0x37, 0x39, 0x39, 0x36, 0x37, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x35, 0x33, 0x61, 0x65, 0x35, 0x39, 0x63, 0x37, 0x38, 0x34, 0x62, 0x36, 0x62, 0x35, 0x63, 0x34, 0x33, 0x36, 0x31, 0x36, 0x62, 0x39, 0x61, 0x30, 0x38, 0x30, 0x39, 0x35, 0x35, 0x38, 0x65, 0x36, 0x38, 0x34, 0x65, 0x31, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x64, 0x34, 0x32, 0x65, 0x62, 0x34, 0x39, 0x35, 0x62, 0x66, 0x34, 0x36, 0x61, 0x36, 0x33, 0x34, 0x39, 0x39, 0x37, 0x62, 0x35, 0x66, 0x32, 0x65, 0x61, 0x33, 0x36, 0x32, 0x38, 0x31, 0x34, 0x39, 0x31, 0x38, 0x65, 0x32, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x31, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x39, 0x66, 0x66, 0x31, 0x37, 0x66, 0x31, 0x64, 0x35, 0x31, 0x62, 0x34, 0x37, 0x33, 0x62, 0x34, 0x34, 0x30, 0x31, 0x30, 0x30, 0x35, 0x32, 0x37, 0x35, 0x35, 0x61, 0x37, 0x66, 0x61, 0x38, 0x63, 0x37, 0x35, 0x62, 0x64, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x32, 0x64, 0x61, 0x61, 0x62, 0x32, 0x35, 0x63, 0x33, 0x31, 0x61, 0x36, 0x31, 0x61, 0x39, 0x32, 0x61, 0x34, 0x63, 0x38, 0x32, 0x63, 0x39, 0x39, 0x32, 0x35, 0x61, 0x31, 0x64, 0x32, 0x65, 0x66, 0x35, 0x38, 0x35, 0x38, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x63, 0x30, 0x63, 0x38, 0x38, 0x62, 0x35, 0x34, 0x61, 0x33, 0x35, 0x34, 0x34, 0x37, 0x30, 0x39, 0x38, 0x32, 0x38, 0x61, 0x62, 0x34, 0x61, 0x62, 0x30, 0x36, 0x38, 0x34, 0x30, 0x35, 0x35, 0x39, 0x66, 0x36, 0x63, 0x35, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x38, 0x36, 0x34, 0x39, 0x65, 0x36, 0x39, 0x30, 0x66, 0x63, 0x38, 0x63, 0x31, 0x62, 0x66, 0x64, 0x61, 0x31, 0x62, 0x35, 0x65, 0x31, 0x38, 0x36, 0x35, 0x38, 0x31, 0x66, 0x36, 0x34, 0x39, 0x62, 0x35, 0x30, 0x66, 0x65, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x63, 0x66, 0x61, 0x39, 0x64, 0x39, 0x34, 0x65, 0x64, 0x61, 0x36, 0x36, 0x32, 0x35, 0x63, 0x39, 0x64, 0x66, 0x61, 0x35, 0x66, 0x39, 0x66, 0x34, 0x66, 0x35, 0x64, 0x31, 0x30, 0x37, 0x63, 0x34, 0x30, 0x33, 0x31, 0x66, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x37, 0x38, 0x66, 0x66, 0x64, 0x63, 0x39, 0x62, 0x39, 0x34, 0x63, 0x35, 0x61, 0x35, 0x39, 0x65, 0x32, 0x32, 0x34, 0x65, 0x62, 0x39, 0x36, 0x35, 0x62, 0x36, 0x64, 0x65, 0x39, 0x30, 0x66, 0x32, 0x32, 0x32, 0x64, 0x31, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x35, 0x61, 0x37, 0x66, 0x34, 0x65, 0x31, 0x30, 0x39, 0x34, 0x39, 0x63, 0x62, 0x36, 0x66, 0x38, 0x39, 0x36, 0x34, 0x32, 0x36, 0x38, 0x66, 0x31, 0x66, 0x61, 0x35, 0x66, 0x35, 0x37, 0x65, 0x37, 0x31, 0x32, 0x62, 0x34, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x33, 0x39, 0x63, 0x63, 0x33, 0x37, 0x63, 0x61, 0x61, 0x61, 0x32, 0x64, 0x64, 0x63, 0x39, 0x62, 0x36, 0x31, 0x30, 0x66, 0x36, 0x31, 0x33, 0x31, 0x65, 0x30, 0x36, 0x31, 0x39, 0x66, 0x61, 0x65, 0x37, 0x37, 0x32, 0x61, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x34, 0x33, 0x37, 0x33, 0x36, 0x35, 0x61, 0x65, 0x33, 0x61, 0x39, 0x61, 0x32, 0x66, 0x66, 0x39, 0x37, 0x63, 0x36, 0x38, 0x65, 0x36, 0x66, 0x39, 0x30, 0x61, 0x37, 0x36, 0x32, 0x30, 0x31, 0x38, 0x38, 0x63, 0x37, 0x64, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x31, 0x30, 0x63, 0x32, 0x63, 0x30, 0x33, 0x63, 0x36, 0x35, 0x39, 0x39, 0x32, 0x62, 0x32, 0x65, 0x37, 0x37, 0x34, 0x62, 0x65, 0x35, 0x32, 0x64, 0x33, 0x61, 0x62, 0x34, 0x61, 0x36, 0x62, 0x61, 0x32, 0x31, 0x37, 0x65, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x36, 0x65, 0x33, 0x33, 0x35, 0x63, 0x61, 0x34, 0x37, 0x61, 0x66, 0x35, 0x37, 0x39, 0x36, 0x32, 0x66, 0x61, 0x30, 0x66, 0x34, 0x64, 0x62, 0x66, 0x33, 0x65, 0x34, 0x35, 0x65, 0x36, 0x38, 0x38, 0x63, 0x62, 0x61, 0x35, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x37, 0x35, 0x34, 0x39, 0x62, 0x66, 0x62, 0x63, 0x39, 0x62, 0x64, 0x64, 0x31, 0x38, 0x66, 0x37, 0x33, 0x36, 0x62, 0x32, 0x32, 0x36, 0x35, 0x30, 0x65, 0x34, 0x38, 0x61, 0x37, 0x33, 0x36, 0x30, 0x31, 0x66, 0x61, 0x36, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x63, 0x61, 0x31, 0x65, 0x37, 0x32, 0x37, 0x65, 0x39, 0x64, 0x31, 0x61, 0x38, 0x37, 0x39, 0x39, 0x31, 0x63, 0x63, 0x32, 0x63, 0x34, 0x31, 0x38, 0x34, 0x30, 0x65, 0x62, 0x62, 0x39, 0x65, 0x64, 0x66, 0x32, 0x31, 0x64, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x34, 0x31, 0x36, 0x36, 0x37, 0x34, 0x36, 0x65, 0x31, 0x64, 0x33, 0x62, 0x63, 0x31, 0x66, 0x38, 0x64, 0x30, 0x37, 0x31, 0x34, 0x62, 0x30, 0x31, 0x66, 0x31, 0x37, 0x65, 0x38, 0x61, 0x36, 0x32, 0x64, 0x66, 0x31, 0x34, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x37, 0x35, 0x63, 0x33, 0x64, 0x34, 0x66, 0x61, 0x36, 0x66, 0x63, 0x63, 0x62, 0x64, 0x35, 0x64, 0x64, 0x35, 0x61, 0x37, 0x30, 0x33, 0x63, 0x31, 0x35, 0x33, 0x37, 0x39, 0x61, 0x31, 0x65, 0x37, 0x38, 0x33, 0x65, 0x39, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x35, 0x38, 0x31, 0x31, 0x62, 0x34, 0x30, 0x62, 0x65, 0x31, 0x65, 0x32, 0x61, 0x31, 0x65, 0x31, 0x64, 0x32, 0x38, 0x63, 0x33, 0x62, 0x30, 0x37, 0x37, 0x34, 0x61, 0x63, 0x64, 0x65, 0x30, 0x61, 0x30, 0x39, 0x36, 0x30, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x33, 0x38, 0x38, 0x36, 0x65, 0x33, 0x33, 0x33, 0x63, 0x35, 0x36, 0x66, 0x65, 0x66, 0x66, 0x38, 0x35, 0x62, 0x65, 0x33, 0x39, 0x35, 0x31, 0x61, 0x62, 0x30, 0x62, 0x38, 0x38, 0x39, 0x63, 0x65, 0x32, 0x36, 0x32, 0x65, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x31, 0x30, 0x31, 0x65, 0x38, 0x32, 0x32, 0x63, 0x64, 0x39, 0x36, 0x32, 0x39, 0x36, 0x32, 0x61, 0x30, 0x36, 0x38, 0x30, 0x30, 0x61, 0x32, 0x63, 0x30, 0x38, 0x64, 0x33, 0x62, 0x31, 0x35, 0x64, 0x38, 0x32, 0x62, 0x37, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x31, 0x65, 0x39, 0x34, 0x37, 0x36, 0x64, 0x66, 0x38, 0x34, 0x34, 0x33, 0x31, 0x38, 0x32, 0x35, 0x63, 0x38, 0x33, 0x36, 0x65, 0x38, 0x38, 0x30, 0x33, 0x61, 0x39, 0x37, 0x65, 0x32, 0x32, 0x66, 0x61, 0x35, 0x61, 0x30, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x34, 0x65, 0x37, 0x64, 0x39, 0x38, 0x33, 0x66, 0x32, 0x65, 0x32, 0x61, 0x36, 0x33, 0x36, 0x62, 0x31, 0x31, 0x30, 0x32, 0x65, 0x63, 0x37, 0x30, 0x33, 0x39, 0x65, 0x66, 0x65, 0x62, 0x63, 0x38, 0x34, 0x32, 0x65, 0x39, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x34, 0x32, 0x37, 0x32, 0x37, 0x32, 0x35, 0x31, 0x36, 0x62, 0x33, 0x65, 0x36, 0x37, 0x64, 0x34, 0x66, 0x63, 0x62, 0x66, 0x38, 0x32, 0x66, 0x35, 0x39, 0x33, 0x39, 0x30, 0x64, 0x30, 0x34, 0x63, 0x38, 0x65, 0x32, 0x38, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x64, 0x32, 0x33, 0x31, 0x65, 0x31, 0x34, 0x34, 0x65, 0x63, 0x39, 0x31, 0x30, 0x37, 0x33, 0x38, 0x36, 0x63, 0x37, 0x63, 0x39, 0x62, 0x30, 0x32, 0x66, 0x31, 0x37, 0x30, 0x32, 0x63, 0x65, 0x61, 0x61, 0x34, 0x66, 0x37, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x30, 0x66, 0x30, 0x35, 0x36, 0x30, 0x36, 0x36, 0x63, 0x32, 0x64, 0x35, 0x36, 0x36, 0x32, 0x38, 0x38, 0x35, 0x30, 0x32, 0x37, 0x33, 0x64, 0x37, 0x65, 0x63, 0x62, 0x37, 0x66, 0x38, 0x65, 0x36, 0x65, 0x39, 0x31, 0x32, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x35, 0x33, 0x38, 0x65, 0x39, 0x61, 0x38, 0x37, 0x65, 0x35, 0x39, 0x63, 0x61, 0x39, 0x65, 0x63, 0x38, 0x65, 0x35, 0x38, 0x32, 0x36, 0x61, 0x35, 0x62, 0x37, 0x39, 0x33, 0x66, 0x39, 0x39, 0x66, 0x39, 0x36, 0x63, 0x34, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x35, 0x62, 0x61, 0x62, 0x31, 0x63, 0x62, 0x33, 0x37, 0x31, 0x30, 0x66, 0x63, 0x30, 0x35, 0x66, 0x61, 0x31, 0x39, 0x66, 0x66, 0x61, 0x63, 0x32, 0x32, 0x65, 0x36, 0x37, 0x35, 0x32, 0x31, 0x61, 0x30, 0x62, 0x61, 0x32, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x63, 0x62, 0x64, 0x62, 0x61, 0x36, 0x62, 0x65, 0x36, 0x63, 0x66, 0x65, 0x36, 0x38, 0x64, 0x62, 0x63, 0x32, 0x33, 0x63, 0x32, 0x62, 0x30, 0x66, 0x66, 0x35, 0x33, 0x30, 0x65, 0x65, 0x30, 0x35, 0x32, 0x32, 0x36, 0x66, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x62, 0x38, 0x37, 0x62, 0x61, 0x38, 0x37, 0x38, 0x38, 0x65, 0x62, 0x61, 0x30, 0x64, 0x66, 0x38, 0x37, 0x65, 0x35, 0x62, 0x39, 0x62, 0x64, 0x35, 0x30, 0x61, 0x38, 0x65, 0x34, 0x35, 0x33, 0x36, 0x38, 0x30, 0x39, 0x31, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x37, 0x39, 0x61, 0x39, 0x65, 0x63, 0x37, 0x34, 0x38, 0x30, 0x62, 0x37, 0x34, 0x62, 0x35, 0x64, 0x62, 0x38, 0x66, 0x63, 0x34, 0x39, 0x39, 0x62, 0x65, 0x33, 0x35, 0x32, 0x64, 0x61, 0x37, 0x66, 0x38, 0x34, 0x65, 0x65, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x31, 0x31, 0x62, 0x63, 0x64, 0x37, 0x61, 0x61, 0x34, 0x65, 0x39, 0x62, 0x34, 0x66, 0x33, 0x38, 0x33, 0x66, 0x66, 0x33, 0x64, 0x30, 0x64, 0x36, 0x62, 0x36, 0x65, 0x30, 0x37, 0x65, 0x32, 0x31, 0x65, 0x33, 0x37, 0x30, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x35, 0x63, 0x31, 0x38, 0x31, 0x36, 0x38, 0x36, 0x38, 0x66, 0x37, 0x37, 0x37, 0x37, 0x63, 0x63, 0x32, 0x62, 0x61, 0x36, 0x63, 0x36, 0x64, 0x32, 0x38, 0x63, 0x39, 0x65, 0x31, 0x65, 0x37, 0x39, 0x36, 0x63, 0x35, 0x32, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x31, 0x30, 0x65, 0x65, 0x39, 0x33, 0x34, 0x66, 0x30, 0x63, 0x62, 0x63, 0x39, 0x30, 0x30, 0x65, 0x31, 0x30, 0x30, 0x37, 0x65, 0x62, 0x33, 0x38, 0x61, 0x32, 0x31, 0x65, 0x32, 0x61, 0x35, 0x31, 0x30, 0x31, 0x62, 0x38, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x65, 0x38, 0x36, 0x34, 0x64, 0x33, 0x35, 0x34, 0x37, 0x34, 0x31, 0x62, 0x34, 0x32, 0x33, 0x65, 0x36, 0x66, 0x34, 0x32, 0x38, 0x35, 0x31, 0x37, 0x32, 0x34, 0x34, 0x36, 0x38, 0x63, 0x37, 0x34, 0x66, 0x35, 0x61, 0x61, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x34, 0x33, 0x61, 0x30, 0x36, 0x36, 0x66, 0x62, 0x33, 0x32, 0x61, 0x38, 0x36, 0x36, 0x38, 0x61, 0x61, 0x30, 0x37, 0x33, 0x36, 0x61, 0x30, 0x63, 0x39, 0x63, 0x64, 0x34, 0x30, 0x64, 0x37, 0x38, 0x30, 0x39, 0x38, 0x37, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x65, 0x62, 0x31, 0x39, 0x34, 0x38, 0x62, 0x39, 0x35, 0x31, 0x65, 0x32, 0x32, 0x64, 0x66, 0x31, 0x36, 0x31, 0x37, 0x38, 0x32, 0x39, 0x62, 0x66, 0x33, 0x62, 0x38, 0x64, 0x38, 0x36, 0x38, 0x30, 0x65, 0x63, 0x36, 0x62, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x62, 0x37, 0x38, 0x32, 0x66, 0x34, 0x64, 0x63, 0x64, 0x37, 0x34, 0x35, 0x61, 0x36, 0x63, 0x30, 0x65, 0x32, 0x65, 0x30, 0x33, 0x30, 0x36, 0x30, 0x30, 0x65, 0x30, 0x34, 0x61, 0x32, 0x34, 0x62, 0x32, 0x35, 0x65, 0x35, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x39, 0x66, 0x34, 0x66, 0x31, 0x61, 0x32, 0x61, 0x34, 0x66, 0x35, 0x34, 0x30, 0x37, 0x37, 0x34, 0x35, 0x30, 0x35, 0x62, 0x34, 0x37, 0x30, 0x37, 0x61, 0x38, 0x31, 0x64, 0x65, 0x34, 0x34, 0x34, 0x31, 0x30, 0x32, 0x35, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x66, 0x38, 0x64, 0x30, 0x36, 0x62, 0x30, 0x30, 0x65, 0x33, 0x66, 0x35, 0x30, 0x63, 0x31, 0x39, 0x31, 0x30, 0x39, 0x39, 0x61, 0x64, 0x35, 0x36, 0x62, 0x61, 0x36, 0x61, 0x65, 0x32, 0x36, 0x35, 0x37, 0x31, 0x63, 0x64, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x30, 0x62, 0x37, 0x64, 0x35, 0x37, 0x37, 0x61, 0x37, 0x65, 0x33, 0x39, 0x61, 0x61, 0x32, 0x33, 0x61, 0x63, 0x66, 0x36, 0x32, 0x61, 0x64, 0x37, 0x66, 0x31, 0x65, 0x66, 0x33, 0x34, 0x32, 0x39, 0x33, 0x34, 0x62, 0x39, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x32, 0x34, 0x33, 0x33, 0x64, 0x32, 0x63, 0x65, 0x38, 0x33, 0x64, 0x33, 0x66, 0x62, 0x34, 0x61, 0x37, 0x36, 0x30, 0x32, 0x63, 0x63, 0x61, 0x33, 0x66, 0x61, 0x63, 0x61, 0x34, 0x65, 0x63, 0x31, 0x34, 0x30, 0x61, 0x34, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x66, 0x34, 0x36, 0x30, 0x34, 0x35, 0x36, 0x38, 0x37, 0x37, 0x32, 0x33, 0x64, 0x63, 0x33, 0x33, 0x65, 0x34, 0x64, 0x30, 0x39, 0x39, 0x61, 0x30, 0x36, 0x39, 0x30, 0x34, 0x66, 0x31, 0x65, 0x62, 0x62, 0x35, 0x38, 0x34, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x61, 0x30, 0x34, 0x32, 0x39, 0x66, 0x38, 0x37, 0x34, 0x66, 0x38, 0x64, 0x63, 0x65, 0x65, 0x32, 0x65, 0x39, 0x63, 0x30, 0x36, 0x32, 0x61, 0x39, 0x30, 0x32, 0x30, 0x61, 0x38, 0x34, 0x32, 0x61, 0x35, 0x38, 0x37, 0x61, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x30, 0x63, 0x65, 0x62, 0x36, 0x66, 0x39, 0x38, 0x30, 0x65, 0x30, 0x34, 0x33, 0x31, 0x35, 0x66, 0x35, 0x33, 0x63, 0x34, 0x66, 0x63, 0x39, 0x38, 0x38, 0x62, 0x32, 0x62, 0x66, 0x36, 0x39, 0x65, 0x32, 0x38, 0x34, 0x64, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x34, 0x30, 0x66, 0x39, 0x62, 0x39, 0x31, 0x63, 0x32, 0x36, 0x37, 0x32, 0x38, 0x63, 0x33, 0x31, 0x64, 0x31, 0x32, 0x31, 0x64, 0x35, 0x64, 0x36, 0x66, 0x63, 0x33, 0x62, 0x62, 0x35, 0x36, 0x64, 0x33, 0x64, 0x38, 0x36, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x61, 0x31, 0x64, 0x35, 0x61, 0x64, 0x33, 0x38, 0x66, 0x65, 0x64, 0x34, 0x34, 0x37, 0x35, 0x39, 0x63, 0x30, 0x35, 0x62, 0x38, 0x39, 0x39, 0x33, 0x63, 0x31, 0x61, 0x61, 0x30, 0x64, 0x61, 0x63, 0x65, 0x31, 0x39, 0x66, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x36, 0x39, 0x62, 0x34, 0x66, 0x37, 0x31, 0x62, 0x62, 0x38, 0x37, 0x35, 0x31, 0x65, 0x64, 0x65, 0x34, 0x33, 0x63, 0x30, 0x31, 0x36, 0x33, 0x36, 0x33, 0x61, 0x37, 0x61, 0x36, 0x31, 0x34, 0x66, 0x37, 0x36, 0x31, 0x31, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x62, 0x36, 0x66, 0x35, 0x37, 0x38, 0x61, 0x64, 0x66, 0x62, 0x65, 0x37, 0x62, 0x32, 0x61, 0x31, 0x31, 0x36, 0x62, 0x33, 0x35, 0x35, 0x34, 0x66, 0x61, 0x63, 0x66, 0x39, 0x39, 0x36, 0x39, 0x38, 0x31, 0x33, 0x63, 0x33, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x33, 0x34, 0x37, 0x36, 0x34, 0x62, 0x37, 0x62, 0x33, 0x39, 0x37, 0x61, 0x34, 0x65, 0x35, 0x37, 0x38, 0x66, 0x35, 0x30, 0x33, 0x36, 0x34, 0x64, 0x36, 0x30, 0x63, 0x65, 0x34, 0x34, 0x38, 0x39, 0x39, 0x62, 0x66, 0x66, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x64, 0x32, 0x31, 0x39, 0x36, 0x36, 0x32, 0x34, 0x61, 0x31, 0x64, 0x64, 0x66, 0x31, 0x34, 0x61, 0x39, 0x64, 0x33, 0x37, 0x35, 0x65, 0x35, 0x66, 0x30, 0x37, 0x31, 0x35, 0x32, 0x62, 0x61, 0x66, 0x32, 0x32, 0x61, 0x66, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x31, 0x31, 0x37, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x34, 0x32, 0x64, 0x61, 0x38, 0x34, 0x35, 0x64, 0x34, 0x32, 0x64, 0x34, 0x62, 0x66, 0x37, 0x37, 0x39, 0x61, 0x30, 0x30, 0x66, 0x32, 0x39, 0x35, 0x62, 0x34, 0x30, 0x37, 0x35, 0x30, 0x66, 0x65, 0x34, 0x39, 0x65, 0x61, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x32, 0x33, 0x34, 0x36, 0x35, 0x37, 0x61, 0x38, 0x30, 0x37, 0x33, 0x38, 0x34, 0x31, 0x32, 0x36, 0x66, 0x38, 0x39, 0x36, 0x38, 0x63, 0x61, 0x31, 0x37, 0x30, 0x38, 0x62, 0x62, 0x30, 0x37, 0x62, 0x61, 0x61, 0x34, 0x39, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x63, 0x30, 0x35, 0x35, 0x65, 0x38, 0x35, 0x38, 0x33, 0x35, 0x37, 0x61, 0x61, 0x61, 0x33, 0x30, 0x63, 0x66, 0x32, 0x30, 0x34, 0x31, 0x66, 0x61, 0x39, 0x30, 0x35, 0x39, 0x63, 0x65, 0x31, 0x36, 0x34, 0x61, 0x31, 0x66, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x63, 0x37, 0x33, 0x63, 0x39, 0x30, 0x35, 0x32, 0x38, 0x61, 0x31, 0x35, 0x37, 0x33, 0x33, 0x36, 0x66, 0x31, 0x65, 0x37, 0x65, 0x61, 0x32, 0x30, 0x36, 0x32, 0x30, 0x61, 0x65, 0x35, 0x33, 0x66, 0x64, 0x32, 0x34, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x36, 0x39, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x65, 0x37, 0x66, 0x33, 0x65, 0x62, 0x37, 0x62, 0x66, 0x36, 0x37, 0x66, 0x33, 0x35, 0x39, 0x39, 0x32, 0x30, 0x39, 0x65, 0x62, 0x65, 0x30, 0x38, 0x62, 0x36, 0x32, 0x61, 0x64, 0x33, 0x33, 0x32, 0x37, 0x66, 0x38, 0x63, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x62, 0x35, 0x31, 0x36, 0x66, 0x64, 0x64, 0x31, 0x39, 0x65, 0x37, 0x66, 0x33, 0x38, 0x36, 0x34, 0x62, 0x36, 0x64, 0x32, 0x63, 0x66, 0x31, 0x62, 0x32, 0x35, 0x32, 0x61, 0x34, 0x31, 0x35, 0x36, 0x66, 0x31, 0x62, 0x30, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x36, 0x34, 0x65, 0x37, 0x38, 0x33, 0x31, 0x34, 0x61, 0x65, 0x31, 0x36, 0x62, 0x32, 0x38, 0x39, 0x32, 0x36, 0x63, 0x63, 0x35, 0x35, 0x33, 0x64, 0x32, 0x63, 0x63, 0x62, 0x31, 0x36, 0x66, 0x33, 0x35, 0x36, 0x32, 0x37, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x38, 0x32, 0x38, 0x38, 0x39, 0x34, 0x37, 0x35, 0x32, 0x66, 0x36, 0x66, 0x32, 0x35, 0x31, 0x37, 0x35, 0x64, 0x61, 0x66, 0x32, 0x31, 0x37, 0x37, 0x30, 0x39, 0x34, 0x34, 0x38, 0x37, 0x39, 0x35, 0x34, 0x62, 0x36, 0x66, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x39, 0x36, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x38, 0x34, 0x61, 0x30, 0x66, 0x31, 0x34, 0x37, 0x61, 0x64, 0x32, 0x36, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x62, 0x38, 0x35, 0x30, 0x32, 0x39, 0x61, 0x34, 0x31, 0x66, 0x63, 0x39, 0x63, 0x65, 0x35, 0x37, 0x66, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x66, 0x65, 0x35, 0x31, 0x66, 0x64, 0x65, 0x33, 0x34, 0x34, 0x31, 0x33, 0x63, 0x37, 0x33, 0x33, 0x31, 0x38, 0x62, 0x39, 0x63, 0x38, 0x35, 0x34, 0x33, 0x37, 0x66, 0x65, 0x37, 0x65, 0x38, 0x32, 0x30, 0x66, 0x35, 0x36, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x63, 0x37, 0x62, 0x33, 0x31, 0x65, 0x38, 0x63, 0x33, 0x37, 0x36, 0x32, 0x38, 0x32, 0x61, 0x63, 0x32, 0x32, 0x37, 0x31, 0x37, 0x32, 0x38, 0x63, 0x33, 0x31, 0x63, 0x39, 0x35, 0x65, 0x33, 0x35, 0x64, 0x39, 0x35, 0x32, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x64, 0x35, 0x63, 0x34, 0x30, 0x63, 0x35, 0x39, 0x63, 0x37, 0x66, 0x35, 0x34, 0x65, 0x61, 0x33, 0x61, 0x35, 0x35, 0x66, 0x63, 0x66, 0x64, 0x31, 0x37, 0x35, 0x34, 0x37, 0x31, 0x65, 0x61, 0x33, 0x35, 0x30, 0x39, 0x39, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x62, 0x62, 0x31, 0x30, 0x66, 0x35, 0x62, 0x64, 0x39, 0x62, 0x63, 0x33, 0x33, 0x62, 0x38, 0x65, 0x63, 0x31, 0x61, 0x38, 0x32, 0x64, 0x36, 0x34, 0x62, 0x35, 0x35, 0x62, 0x36, 0x62, 0x31, 0x38, 0x37, 0x37, 0x37, 0x35, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x62, 0x30, 0x65, 0x61, 0x32, 0x62, 0x32, 0x31, 0x38, 0x64, 0x38, 0x32, 0x65, 0x30, 0x61, 0x65, 0x61, 0x37, 0x63, 0x32, 0x38, 0x38, 0x39, 0x32, 0x33, 0x38, 0x61, 0x33, 0x39, 0x63, 0x39, 0x62, 0x66, 0x39, 0x30, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x35, 0x63, 0x64, 0x62, 0x65, 0x32, 0x35, 0x62, 0x32, 0x61, 0x30, 0x34, 0x34, 0x62, 0x37, 0x62, 0x39, 0x62, 0x65, 0x33, 0x38, 0x33, 0x62, 0x63, 0x61, 0x61, 0x35, 0x38, 0x30, 0x37, 0x62, 0x30, 0x36, 0x64, 0x33, 0x63, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x33, 0x37, 0x34, 0x39, 0x61, 0x33, 0x62, 0x39, 0x37, 0x31, 0x39, 0x35, 0x39, 0x65, 0x34, 0x36, 0x63, 0x38, 0x62, 0x34, 0x38, 0x32, 0x32, 0x64, 0x63, 0x61, 0x66, 0x61, 0x66, 0x37, 0x61, 0x61, 0x66, 0x39, 0x62, 0x64, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x32, 0x37, 0x32, 0x32, 0x31, 0x33, 0x65, 0x38, 0x64, 0x32, 0x66, 0x64, 0x33, 0x65, 0x39, 0x36, 0x62, 0x64, 0x36, 0x32, 0x31, 0x37, 0x62, 0x32, 0x34, 0x62, 0x34, 0x62, 0x61, 0x30, 0x31, 0x62, 0x36, 0x31, 0x37, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x61, 0x63, 0x62, 0x66, 0x62, 0x32, 0x66, 0x32, 0x35, 0x61, 0x35, 0x34, 0x38, 0x35, 0x63, 0x37, 0x33, 0x39, 0x65, 0x66, 0x37, 0x30, 0x61, 0x34, 0x34, 0x65, 0x65, 0x65, 0x65, 0x62, 0x37, 0x63, 0x36, 0x35, 0x61, 0x36, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x66, 0x31, 0x35, 0x34, 0x32, 0x33, 0x33, 0x32, 0x33, 0x63, 0x32, 0x34, 0x66, 0x31, 0x39, 0x61, 0x65, 0x32, 0x61, 0x62, 0x36, 0x37, 0x33, 0x37, 0x31, 0x37, 0x32, 0x32, 0x39, 0x64, 0x33, 0x66, 0x37, 0x34, 0x37, 0x64, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x36, 0x31, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x34, 0x61, 0x62, 0x66, 0x63, 0x32, 0x38, 0x32, 0x61, 0x65, 0x64, 0x37, 0x36, 0x65, 0x35, 0x64, 0x35, 0x37, 0x61, 0x66, 0x66, 0x64, 0x61, 0x35, 0x34, 0x32, 0x63, 0x31, 0x66, 0x33, 0x38, 0x32, 0x66, 0x63, 0x61, 0x63, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x31, 0x33, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x31, 0x62, 0x34, 0x35, 0x33, 0x34, 0x66, 0x32, 0x38, 0x36, 0x65, 0x34, 0x33, 0x30, 0x39, 0x33, 0x62, 0x31, 0x65, 0x31, 0x35, 0x65, 0x66, 0x65, 0x61, 0x37, 0x34, 0x39, 0x65, 0x37, 0x35, 0x39, 0x37, 0x62, 0x38, 0x62, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x34, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x63, 0x64, 0x37, 0x37, 0x35, 0x33, 0x35, 0x61, 0x38, 0x39, 0x33, 0x66, 0x61, 0x37, 0x63, 0x34, 0x64, 0x35, 0x65, 0x62, 0x33, 0x61, 0x32, 0x34, 0x30, 0x65, 0x37, 0x39, 0x64, 0x30, 0x39, 0x39, 0x61, 0x37, 0x32, 0x64, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x33, 0x63, 0x65, 0x37, 0x66, 0x63, 0x33, 0x38, 0x31, 0x63, 0x35, 0x31, 0x64, 0x62, 0x37, 0x64, 0x35, 0x66, 0x62, 0x64, 0x36, 0x39, 0x32, 0x66, 0x38, 0x66, 0x39, 0x65, 0x30, 0x35, 0x38, 0x61, 0x34, 0x63, 0x37, 0x30, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x63, 0x38, 0x63, 0x34, 0x61, 0x39, 0x34, 0x31, 0x62, 0x34, 0x36, 0x32, 0x38, 0x63, 0x30, 0x64, 0x36, 0x63, 0x33, 0x30, 0x66, 0x64, 0x61, 0x35, 0x36, 0x34, 0x35, 0x32, 0x64, 0x39, 0x39, 0x63, 0x37, 0x65, 0x31, 0x62, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x37, 0x36, 0x37, 0x37, 0x61, 0x62, 0x61, 0x31, 0x65, 0x35, 0x32, 0x63, 0x33, 0x62, 0x35, 0x33, 0x62, 0x66, 0x61, 0x32, 0x30, 0x37, 0x31, 0x64, 0x34, 0x65, 0x38, 0x35, 0x39, 0x61, 0x30, 0x61, 0x66, 0x37, 0x65, 0x38, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x66, 0x30, 0x37, 0x35, 0x66, 0x64, 0x34, 0x30, 0x31, 0x33, 0x33, 0x35, 0x35, 0x37, 0x37, 0x62, 0x36, 0x36, 0x38, 0x33, 0x63, 0x32, 0x38, 0x31, 0x65, 0x36, 0x64, 0x31, 0x30, 0x31, 0x34, 0x33, 0x32, 0x64, 0x63, 0x36, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x38, 0x64, 0x62, 0x63, 0x38, 0x65, 0x66, 0x64, 0x35, 0x65, 0x34, 0x31, 0x36, 0x61, 0x37, 0x36, 0x32, 0x65, 0x63, 0x30, 0x65, 0x30, 0x31, 0x38, 0x38, 0x36, 0x34, 0x62, 0x62, 0x39, 0x61, 0x61, 0x38, 0x33, 0x32, 0x38, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x35, 0x33, 0x33, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x37, 0x31, 0x37, 0x63, 0x64, 0x34, 0x33, 0x32, 0x61, 0x33, 0x32, 0x33, 0x61, 0x34, 0x36, 0x35, 0x39, 0x30, 0x33, 0x39, 0x38, 0x34, 0x38, 0x64, 0x33, 0x62, 0x38, 0x37, 0x64, 0x65, 0x32, 0x36, 0x66, 0x63, 0x39, 0x35, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x35, 0x38, 0x65, 0x39, 0x37, 0x63, 0x37, 0x30, 0x62, 0x36, 0x30, 0x35, 0x62, 0x31, 0x64, 0x37, 0x64, 0x37, 0x32, 0x39, 0x64, 0x66, 0x62, 0x36, 0x34, 0x30, 0x62, 0x34, 0x33, 0x63, 0x35, 0x65, 0x61, 0x66, 0x64, 0x31, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x33, 0x63, 0x32, 0x33, 0x30, 0x36, 0x64, 0x66, 0x33, 0x36, 0x30, 0x34, 0x61, 0x65, 0x34, 0x66, 0x64, 0x61, 0x30, 0x64, 0x32, 0x30, 0x37, 0x61, 0x62, 0x61, 0x37, 0x33, 0x36, 0x66, 0x36, 0x37, 0x64, 0x65, 0x30, 0x37, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x64, 0x33, 0x36, 0x36, 0x62, 0x30, 0x37, 0x62, 0x32, 0x66, 0x35, 0x36, 0x34, 0x37, 0x37, 0x64, 0x37, 0x63, 0x37, 0x30, 0x37, 0x37, 0x61, 0x63, 0x36, 0x66, 0x65, 0x34, 0x39, 0x37, 0x65, 0x30, 0x65, 0x62, 0x36, 0x35, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x30, 0x31, 0x34, 0x35, 0x61, 0x66, 0x61, 0x38, 0x62, 0x35, 0x34, 0x35, 0x32, 0x32, 0x62, 0x62, 0x32, 0x31, 0x66, 0x33, 0x35, 0x32, 0x66, 0x30, 0x36, 0x64, 0x61, 0x35, 0x61, 0x37, 0x38, 0x38, 0x66, 0x61, 0x38, 0x66, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x33, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x32, 0x35, 0x36, 0x39, 0x32, 0x31, 0x31, 0x65, 0x38, 0x63, 0x36, 0x33, 0x32, 0x37, 0x62, 0x35, 0x34, 0x31, 0x35, 0x65, 0x33, 0x61, 0x36, 0x37, 0x65, 0x35, 0x37, 0x33, 0x38, 0x62, 0x31, 0x35, 0x62, 0x61, 0x61, 0x66, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x37, 0x34, 0x62, 0x61, 0x36, 0x32, 0x65, 0x37, 0x63, 0x38, 0x31, 0x61, 0x33, 0x34, 0x37, 0x34, 0x65, 0x32, 0x37, 0x64, 0x38, 0x39, 0x34, 0x66, 0x65, 0x64, 0x33, 0x33, 0x64, 0x64, 0x32, 0x34, 0x61, 0x64, 0x39, 0x35, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x36, 0x65, 0x34, 0x64, 0x38, 0x30, 0x32, 0x39, 0x62, 0x37, 0x33, 0x66, 0x35, 0x35, 0x37, 0x39, 0x64, 0x63, 0x61, 0x33, 0x33, 0x65, 0x37, 0x30, 0x62, 0x32, 0x34, 0x65, 0x62, 0x61, 0x38, 0x39, 0x65, 0x31, 0x31, 0x64, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x63, 0x36, 0x65, 0x37, 0x34, 0x66, 0x66, 0x31, 0x64, 0x39, 0x32, 0x38, 0x64, 0x66, 0x39, 0x38, 0x31, 0x33, 0x37, 0x61, 0x66, 0x34, 0x64, 0x66, 0x38, 0x34, 0x33, 0x30, 0x64, 0x66, 0x32, 0x34, 0x66, 0x30, 0x37, 0x63, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x62, 0x33, 0x36, 0x62, 0x30, 0x63, 0x38, 0x37, 0x65, 0x61, 0x36, 0x36, 0x34, 0x65, 0x64, 0x38, 0x30, 0x33, 0x31, 0x38, 0x64, 0x63, 0x37, 0x37, 0x62, 0x36, 0x38, 0x38, 0x64, 0x64, 0x65, 0x38, 0x37, 0x64, 0x39, 0x35, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x38, 0x33, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x63, 0x34, 0x63, 0x61, 0x65, 0x62, 0x34, 0x37, 0x34, 0x64, 0x34, 0x36, 0x32, 0x37, 0x63, 0x62, 0x36, 0x65, 0x62, 0x34, 0x35, 0x36, 0x65, 0x63, 0x62, 0x61, 0x30, 0x65, 0x63, 0x64, 0x30, 0x38, 0x65, 0x64, 0x38, 0x61, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x61, 0x36, 0x35, 0x36, 0x65, 0x37, 0x31, 0x65, 0x63, 0x36, 0x35, 0x31, 0x62, 0x66, 0x61, 0x31, 0x37, 0x63, 0x35, 0x61, 0x35, 0x37, 0x35, 0x39, 0x64, 0x38, 0x36, 0x30, 0x33, 0x31, 0x63, 0x63, 0x33, 0x35, 0x39, 0x39, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x36, 0x32, 0x30, 0x62, 0x64, 0x65, 0x31, 0x37, 0x32, 0x32, 0x38, 0x66, 0x36, 0x63, 0x62, 0x62, 0x61, 0x37, 0x34, 0x64, 0x66, 0x36, 0x62, 0x65, 0x38, 0x37, 0x32, 0x36, 0x34, 0x64, 0x39, 0x38, 0x35, 0x63, 0x63, 0x31, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x61, 0x61, 0x32, 0x66, 0x31, 0x66, 0x38, 0x65, 0x39, 0x33, 0x65, 0x37, 0x39, 0x37, 0x31, 0x33, 0x64, 0x39, 0x32, 0x63, 0x65, 0x61, 0x39, 0x66, 0x66, 0x63, 0x65, 0x39, 0x61, 0x34, 0x30, 0x61, 0x66, 0x39, 0x63, 0x38, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x38, 0x65, 0x66, 0x31, 0x65, 0x63, 0x33, 0x32, 0x35, 0x61, 0x39, 0x36, 0x63, 0x63, 0x33, 0x35, 0x34, 0x63, 0x37, 0x32, 0x36, 0x36, 0x61, 0x30, 0x33, 0x38, 0x62, 0x65, 0x38, 0x62, 0x35, 0x63, 0x35, 0x35, 0x38, 0x66, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x38, 0x33, 0x33, 0x34, 0x37, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x31, 0x33, 0x64, 0x35, 0x65, 0x33, 0x32, 0x63, 0x31, 0x66, 0x64, 0x32, 0x36, 0x64, 0x37, 0x65, 0x39, 0x31, 0x66, 0x66, 0x36, 0x65, 0x30, 0x35, 0x33, 0x31, 0x36, 0x30, 0x61, 0x38, 0x39, 0x62, 0x32, 0x63, 0x38, 0x61, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x35, 0x36, 0x62, 0x66, 0x33, 0x66, 0x66, 0x34, 0x31, 0x63, 0x32, 0x36, 0x32, 0x35, 0x36, 0x66, 0x65, 0x66, 0x35, 0x31, 0x37, 0x31, 0x36, 0x36, 0x31, 0x32, 0x62, 0x39, 0x64, 0x33, 0x39, 0x61, 0x64, 0x65, 0x39, 0x39, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x31, 0x32, 0x38, 0x63, 0x39, 0x35, 0x64, 0x39, 0x35, 0x37, 0x32, 0x31, 0x35, 0x31, 0x30, 0x31, 0x66, 0x30, 0x34, 0x33, 0x64, 0x64, 0x38, 0x66, 0x63, 0x35, 0x38, 0x32, 0x34, 0x35, 0x36, 0x64, 0x34, 0x31, 0x30, 0x31, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x36, 0x30, 0x62, 0x30, 0x39, 0x62, 0x38, 0x39, 0x61, 0x34, 0x61, 0x65, 0x36, 0x38, 0x34, 0x39, 0x65, 0x64, 0x35, 0x61, 0x33, 0x63, 0x39, 0x39, 0x35, 0x38, 0x34, 0x32, 0x36, 0x36, 0x33, 0x31, 0x37, 0x31, 0x34, 0x34, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x64, 0x36, 0x65, 0x39, 0x66, 0x62, 0x38, 0x32, 0x35, 0x34, 0x32, 0x66, 0x64, 0x32, 0x39, 0x65, 0x64, 0x39, 0x65, 0x61, 0x33, 0x36, 0x30, 0x39, 0x38, 0x39, 0x31, 0x65, 0x31, 0x35, 0x31, 0x33, 0x39, 0x36, 0x62, 0x36, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x36, 0x30, 0x37, 0x62, 0x34, 0x32, 0x35, 0x37, 0x33, 0x62, 0x62, 0x36, 0x66, 0x36, 0x62, 0x34, 0x64, 0x34, 0x66, 0x32, 0x33, 0x63, 0x37, 0x65, 0x32, 0x61, 0x32, 0x36, 0x62, 0x33, 0x61, 0x30, 0x66, 0x36, 0x62, 0x36, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x30, 0x33, 0x36, 0x32, 0x63, 0x33, 0x61, 0x64, 0x65, 0x38, 0x37, 0x38, 0x63, 0x61, 0x39, 0x30, 0x64, 0x36, 0x62, 0x32, 0x64, 0x38, 0x38, 0x39, 0x61, 0x34, 0x63, 0x63, 0x35, 0x35, 0x31, 0x30, 0x65, 0x65, 0x64, 0x35, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x34, 0x32, 0x38, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x38, 0x33, 0x30, 0x37, 0x30, 0x34, 0x65, 0x39, 0x39, 0x61, 0x61, 0x61, 0x64, 0x35, 0x63, 0x35, 0x35, 0x65, 0x31, 0x66, 0x35, 0x30, 0x32, 0x62, 0x32, 0x37, 0x62, 0x32, 0x32, 0x63, 0x31, 0x32, 0x63, 0x39, 0x31, 0x39, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x33, 0x30, 0x62, 0x31, 0x31, 0x31, 0x63, 0x36, 0x39, 0x38, 0x33, 0x66, 0x30, 0x34, 0x38, 0x35, 0x64, 0x64, 0x61, 0x63, 0x61, 0x37, 0x36, 0x32, 0x32, 0x34, 0x63, 0x36, 0x31, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x38, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x35, 0x62, 0x37, 0x64, 0x37, 0x62, 0x31, 0x39, 0x35, 0x61, 0x33, 0x37, 0x31, 0x62, 0x66, 0x39, 0x61, 0x62, 0x64, 0x64, 0x62, 0x34, 0x32, 0x66, 0x65, 0x30, 0x34, 0x66, 0x32, 0x66, 0x31, 0x64, 0x39, 0x61, 0x39, 0x39, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x64, 0x34, 0x33, 0x66, 0x61, 0x37, 0x62, 0x34, 0x38, 0x31, 0x64, 0x62, 0x66, 0x33, 0x64, 0x62, 0x35, 0x33, 0x30, 0x63, 0x66, 0x62, 0x66, 0x35, 0x66, 0x64, 0x63, 0x65, 0x64, 0x30, 0x65, 0x36, 0x35, 0x37, 0x31, 0x38, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x39, 0x30, 0x62, 0x34, 0x31, 0x35, 0x61, 0x33, 0x38, 0x65, 0x32, 0x65, 0x31, 0x39, 0x63, 0x64, 0x64, 0x30, 0x32, 0x66, 0x66, 0x33, 0x61, 0x64, 0x38, 0x31, 0x61, 0x39, 0x37, 0x61, 0x66, 0x37, 0x63, 0x62, 0x66, 0x36, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x63, 0x38, 0x32, 0x65, 0x66, 0x30, 0x37, 0x36, 0x39, 0x33, 0x32, 0x33, 0x34, 0x31, 0x32, 0x36, 0x34, 0x66, 0x36, 0x31, 0x37, 0x61, 0x30, 0x63, 0x38, 0x30, 0x64, 0x64, 0x35, 0x37, 0x31, 0x65, 0x36, 0x61, 0x65, 0x39, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x65, 0x35, 0x34, 0x39, 0x66, 0x65, 0x38, 0x34, 0x33, 0x30, 0x65, 0x35, 0x35, 0x32, 0x63, 0x36, 0x64, 0x30, 0x37, 0x63, 0x63, 0x33, 0x62, 0x39, 0x32, 0x63, 0x63, 0x64, 0x34, 0x33, 0x62, 0x31, 0x32, 0x66, 0x62, 0x35, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x38, 0x65, 0x36, 0x38, 0x39, 0x62, 0x30, 0x32, 0x39, 0x31, 0x37, 0x63, 0x64, 0x63, 0x32, 0x39, 0x32, 0x34, 0x35, 0x64, 0x30, 0x63, 0x39, 0x63, 0x36, 0x38, 0x62, 0x30, 0x39, 0x34, 0x62, 0x34, 0x31, 0x61, 0x39, 0x65, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x63, 0x33, 0x61, 0x38, 0x62, 0x62, 0x61, 0x32, 0x36, 0x37, 0x63, 0x38, 0x63, 0x63, 0x61, 0x32, 0x37, 0x62, 0x31, 0x61, 0x39, 0x61, 0x66, 0x61, 0x62, 0x61, 0x64, 0x38, 0x36, 0x66, 0x36, 0x30, 0x37, 0x61, 0x66, 0x37, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x33, 0x63, 0x36, 0x33, 0x39, 0x37, 0x35, 0x32, 0x63, 0x61, 0x65, 0x65, 0x63, 0x66, 0x36, 0x61, 0x39, 0x39, 0x37, 0x64, 0x33, 0x39, 0x37, 0x30, 0x39, 0x66, 0x63, 0x38, 0x66, 0x31, 0x39, 0x38, 0x37, 0x38, 0x63, 0x37, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x36, 0x30, 0x33, 0x64, 0x37, 0x61, 0x33, 0x62, 0x62, 0x32, 0x39, 0x37, 0x63, 0x36, 0x37, 0x63, 0x38, 0x37, 0x37, 0x65, 0x35, 0x64, 0x33, 0x34, 0x66, 0x62, 0x64, 0x35, 0x62, 0x39, 0x31, 0x33, 0x64, 0x34, 0x63, 0x36, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x36, 0x36, 0x66, 0x39, 0x31, 0x31, 0x63, 0x36, 0x34, 0x34, 0x61, 0x63, 0x33, 0x32, 0x31, 0x33, 0x64, 0x32, 0x39, 0x65, 0x30, 0x65, 0x31, 0x61, 0x65, 0x30, 0x31, 0x30, 0x66, 0x37, 0x39, 0x34, 0x64, 0x35, 0x61, 0x64, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x62, 0x33, 0x38, 0x31, 0x39, 0x36, 0x31, 0x37, 0x34, 0x30, 0x34, 0x30, 0x35, 0x38, 0x32, 0x36, 0x38, 0x66, 0x30, 0x63, 0x33, 0x63, 0x66, 0x66, 0x33, 0x35, 0x39, 0x36, 0x62, 0x66, 0x65, 0x39, 0x31, 0x34, 0x38, 0x63, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x36, 0x37, 0x64, 0x64, 0x30, 0x34, 0x33, 0x61, 0x35, 0x30, 0x34, 0x66, 0x63, 0x32, 0x66, 0x32, 0x66, 0x63, 0x37, 0x31, 0x39, 0x34, 0x65, 0x39, 0x62, 0x65, 0x63, 0x66, 0x34, 0x38, 0x34, 0x63, 0x65, 0x63, 0x62, 0x31, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x32, 0x34, 0x65, 0x65, 0x33, 0x33, 0x31, 0x65, 0x34, 0x61, 0x63, 0x33, 0x63, 0x63, 0x35, 0x38, 0x37, 0x36, 0x39, 0x33, 0x33, 0x39, 0x35, 0x62, 0x35, 0x37, 0x65, 0x63, 0x66, 0x36, 0x32, 0x35, 0x61, 0x36, 0x63, 0x30, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x37, 0x39, 0x63, 0x36, 0x30, 0x64, 0x62, 0x64, 0x30, 0x36, 0x38, 0x62, 0x31, 0x35, 0x30, 0x62, 0x30, 0x37, 0x34, 0x64, 0x61, 0x34, 0x62, 0x65, 0x32, 0x33, 0x30, 0x33, 0x33, 0x62, 0x32, 0x30, 0x63, 0x36, 0x38, 0x35, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x61, 0x34, 0x37, 0x39, 0x34, 0x30, 0x34, 0x33, 0x34, 0x37, 0x63, 0x35, 0x35, 0x34, 0x33, 0x61, 0x61, 0x62, 0x32, 0x39, 0x32, 0x61, 0x65, 0x31, 0x62, 0x62, 0x34, 0x61, 0x36, 0x66, 0x31, 0x35, 0x38, 0x33, 0x35, 0x37, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x64, 0x33, 0x32, 0x62, 0x64, 0x37, 0x65, 0x34, 0x65, 0x36, 0x39, 0x35, 0x62, 0x37, 0x62, 0x30, 0x31, 0x61, 0x61, 0x33, 0x64, 0x30, 0x34, 0x31, 0x36, 0x66, 0x38, 0x30, 0x35, 0x35, 0x37, 0x64, 0x62, 0x61, 0x39, 0x39, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x33, 0x34, 0x65, 0x63, 0x30, 0x33, 0x37, 0x32, 0x34, 0x64, 0x64, 0x65, 0x65, 0x35, 0x62, 0x62, 0x35, 0x32, 0x37, 0x39, 0x61, 0x61, 0x31, 0x61, 0x66, 0x63, 0x66, 0x36, 0x31, 0x62, 0x30, 0x63, 0x62, 0x34, 0x34, 0x38, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x33, 0x38, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x34, 0x30, 0x36, 0x39, 0x64, 0x66, 0x62, 0x31, 0x38, 0x62, 0x30, 0x39, 0x36, 0x63, 0x37, 0x38, 0x36, 0x37, 0x66, 0x38, 0x62, 0x65, 0x65, 0x37, 0x37, 0x61, 0x36, 0x64, 0x63, 0x37, 0x34, 0x37, 0x37, 0x61, 0x64, 0x30, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x63, 0x35, 0x33, 0x65, 0x65, 0x37, 0x65, 0x33, 0x33, 0x35, 0x37, 0x66, 0x39, 0x34, 0x63, 0x65, 0x30, 0x64, 0x37, 0x38, 0x36, 0x38, 0x30, 0x30, 0x39, 0x63, 0x32, 0x30, 0x38, 0x62, 0x34, 0x61, 0x31, 0x33, 0x30, 0x31, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x33, 0x32, 0x64, 0x39, 0x63, 0x62, 0x34, 0x64, 0x30, 0x66, 0x64, 0x61, 0x61, 0x30, 0x31, 0x35, 0x30, 0x36, 0x35, 0x36, 0x62, 0x62, 0x36, 0x30, 0x38, 0x64, 0x63, 0x63, 0x34, 0x33, 0x65, 0x64, 0x37, 0x64, 0x39, 0x33, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x33, 0x39, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x64, 0x62, 0x36, 0x30, 0x39, 0x32, 0x37, 0x37, 0x39, 0x64, 0x35, 0x38, 0x34, 0x32, 0x65, 0x61, 0x64, 0x33, 0x37, 0x38, 0x65, 0x32, 0x31, 0x65, 0x38, 0x31, 0x32, 0x30, 0x66, 0x64, 0x34, 0x63, 0x36, 0x62, 0x63, 0x31, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x65, 0x61, 0x30, 0x31, 0x65, 0x33, 0x62, 0x66, 0x32, 0x65, 0x38, 0x33, 0x38, 0x33, 0x36, 0x65, 0x37, 0x31, 0x37, 0x30, 0x34, 0x65, 0x32, 0x32, 0x61, 0x32, 0x37, 0x31, 0x39, 0x33, 0x37, 0x37, 0x65, 0x66, 0x64, 0x39, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x63, 0x31, 0x31, 0x31, 0x30, 0x62, 0x31, 0x38, 0x38, 0x37, 0x30, 0x65, 0x63, 0x38, 0x31, 0x31, 0x37, 0x38, 0x64, 0x39, 0x33, 0x64, 0x32, 0x31, 0x35, 0x38, 0x33, 0x38, 0x63, 0x35, 0x35, 0x31, 0x64, 0x34, 0x38, 0x65, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x32, 0x37, 0x61, 0x66, 0x31, 0x30, 0x31, 0x66, 0x30, 0x61, 0x61, 0x62, 0x61, 0x34, 0x64, 0x32, 0x33, 0x61, 0x31, 0x63, 0x61, 0x66, 0x65, 0x31, 0x37, 0x63, 0x36, 0x65, 0x62, 0x35, 0x64, 0x61, 0x62, 0x31, 0x63, 0x36, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x31, 0x61, 0x30, 0x33, 0x63, 0x34, 0x62, 0x62, 0x32, 0x36, 0x64, 0x32, 0x31, 0x65, 0x66, 0x66, 0x36, 0x37, 0x37, 0x64, 0x35, 0x64, 0x35, 0x35, 0x35, 0x63, 0x38, 0x30, 0x62, 0x32, 0x35, 0x34, 0x35, 0x33, 0x65, 0x65, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x39, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x65, 0x35, 0x64, 0x65, 0x61, 0x33, 0x33, 0x37, 0x30, 0x61, 0x32, 0x63, 0x37, 0x34, 0x36, 0x61, 0x61, 0x65, 0x33, 0x34, 0x61, 0x33, 0x37, 0x63, 0x35, 0x33, 0x31, 0x66, 0x34, 0x31, 0x64, 0x61, 0x32, 0x36, 0x34, 0x65, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x32, 0x35, 0x63, 0x33, 0x35, 0x32, 0x38, 0x30, 0x31, 0x62, 0x61, 0x38, 0x38, 0x33, 0x62, 0x33, 0x32, 0x32, 0x36, 0x63, 0x35, 0x66, 0x65, 0x62, 0x30, 0x64, 0x66, 0x39, 0x65, 0x61, 0x65, 0x32, 0x64, 0x36, 0x65, 0x36, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x35, 0x30, 0x35, 0x35, 0x38, 0x31, 0x34, 0x63, 0x62, 0x38, 0x62, 0x65, 0x30, 0x63, 0x31, 0x31, 0x37, 0x62, 0x62, 0x38, 0x62, 0x31, 0x63, 0x38, 0x64, 0x32, 0x62, 0x36, 0x33, 0x62, 0x34, 0x36, 0x39, 0x38, 0x62, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x62, 0x31, 0x62, 0x63, 0x33, 0x34, 0x64, 0x38, 0x36, 0x64, 0x34, 0x61, 0x34, 0x64, 0x64, 0x65, 0x32, 0x35, 0x38, 0x30, 0x64, 0x38, 0x62, 0x65, 0x61, 0x66, 0x30, 0x37, 0x34, 0x65, 0x62, 0x30, 0x65, 0x31, 0x61, 0x32, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x38, 0x33, 0x36, 0x30, 0x32, 0x30, 0x36, 0x38, 0x38, 0x33, 0x64, 0x64, 0x31, 0x62, 0x36, 0x64, 0x34, 0x61, 0x35, 0x39, 0x36, 0x33, 0x39, 0x65, 0x35, 0x36, 0x32, 0x39, 0x64, 0x30, 0x66, 0x30, 0x63, 0x36, 0x37, 0x35, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x64, 0x36, 0x66, 0x38, 0x37, 0x31, 0x63, 0x61, 0x37, 0x38, 0x31, 0x61, 0x37, 0x35, 0x39, 0x61, 0x32, 0x30, 0x61, 0x63, 0x33, 0x61, 0x64, 0x62, 0x39, 0x37, 0x32, 0x63, 0x66, 0x31, 0x32, 0x38, 0x32, 0x39, 0x61, 0x32, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x61, 0x63, 0x34, 0x65, 0x66, 0x66, 0x36, 0x36, 0x38, 0x30, 0x65, 0x65, 0x31, 0x34, 0x31, 0x36, 0x39, 0x63, 0x64, 0x61, 0x64, 0x62, 0x66, 0x66, 0x64, 0x62, 0x33, 0x30, 0x38, 0x30, 0x34, 0x66, 0x36, 0x64, 0x32, 0x35, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x62, 0x35, 0x38, 0x66, 0x61, 0x66, 0x66, 0x61, 0x38, 0x37, 0x39, 0x34, 0x66, 0x35, 0x30, 0x61, 0x66, 0x38, 0x65, 0x38, 0x38, 0x33, 0x30, 0x39, 0x63, 0x37, 0x61, 0x36, 0x32, 0x36, 0x35, 0x34, 0x35, 0x35, 0x64, 0x35, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x31, 0x61, 0x35, 0x34, 0x64, 0x66, 0x37, 0x38, 0x34, 0x61, 0x34, 0x34, 0x64, 0x37, 0x31, 0x62, 0x37, 0x37, 0x31, 0x62, 0x38, 0x37, 0x33, 0x31, 0x37, 0x35, 0x30, 0x39, 0x32, 0x31, 0x31, 0x33, 0x38, 0x31, 0x66, 0x32, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x61, 0x34, 0x62, 0x36, 0x34, 0x63, 0x32, 0x62, 0x31, 0x35, 0x62, 0x37, 0x39, 0x66, 0x35, 0x66, 0x32, 0x30, 0x34, 0x32, 0x34, 0x36, 0x66, 0x64, 0x37, 0x30, 0x62, 0x63, 0x62, 0x64, 0x38, 0x36, 0x65, 0x34, 0x61, 0x39, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x30, 0x64, 0x38, 0x66, 0x66, 0x36, 0x30, 0x63, 0x61, 0x61, 0x65, 0x33, 0x31, 0x64, 0x30, 0x32, 0x65, 0x30, 0x62, 0x36, 0x36, 0x35, 0x66, 0x61, 0x34, 0x33, 0x35, 0x64, 0x37, 0x36, 0x66, 0x37, 0x37, 0x63, 0x39, 0x34, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x65, 0x37, 0x34, 0x66, 0x34, 0x37, 0x30, 0x63, 0x37, 0x64, 0x33, 0x61, 0x33, 0x66, 0x30, 0x30, 0x33, 0x33, 0x37, 0x38, 0x30, 0x66, 0x37, 0x36, 0x61, 0x38, 0x39, 0x66, 0x33, 0x65, 0x66, 0x36, 0x39, 0x31, 0x65, 0x36, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x32, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x33, 0x30, 0x37, 0x32, 0x38, 0x31, 0x33, 0x31, 0x66, 0x65, 0x38, 0x65, 0x33, 0x61, 0x31, 0x35, 0x34, 0x38, 0x37, 0x61, 0x33, 0x34, 0x35, 0x37, 0x33, 0x63, 0x39, 0x33, 0x34, 0x35, 0x37, 0x65, 0x32, 0x61, 0x66, 0x65, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x66, 0x39, 0x64, 0x62, 0x65, 0x34, 0x37, 0x34, 0x32, 0x32, 0x64, 0x31, 0x37, 0x37, 0x66, 0x39, 0x34, 0x35, 0x62, 0x64, 0x65, 0x61, 0x64, 0x37, 0x65, 0x36, 0x64, 0x38, 0x32, 0x39, 0x33, 0x30, 0x33, 0x35, 0x36, 0x32, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x62, 0x35, 0x62, 0x36, 0x36, 0x32, 0x61, 0x31, 0x63, 0x37, 0x31, 0x38, 0x36, 0x30, 0x38, 0x66, 0x64, 0x35, 0x32, 0x66, 0x30, 0x63, 0x32, 0x35, 0x66, 0x39, 0x33, 0x37, 0x38, 0x38, 0x33, 0x30, 0x31, 0x37, 0x38, 0x35, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x39, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x61, 0x36, 0x38, 0x31, 0x30, 0x65, 0x61, 0x35, 0x61, 0x63, 0x39, 0x38, 0x35, 0x64, 0x36, 0x66, 0x66, 0x62, 0x66, 0x31, 0x63, 0x35, 0x31, 0x31, 0x66, 0x31, 0x63, 0x31, 0x34, 0x32, 0x65, 0x64, 0x63, 0x66, 0x64, 0x64, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x32, 0x63, 0x35, 0x34, 0x31, 0x37, 0x36, 0x62, 0x64, 0x66, 0x34, 0x33, 0x64, 0x32, 0x63, 0x39, 0x62, 0x63, 0x64, 0x37, 0x62, 0x38, 0x30, 0x38, 0x62, 0x38, 0x39, 0x35, 0x35, 0x36, 0x62, 0x38, 0x39, 0x63, 0x62, 0x66, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x34, 0x64, 0x35, 0x64, 0x65, 0x34, 0x38, 0x34, 0x36, 0x64, 0x33, 0x39, 0x62, 0x35, 0x33, 0x63, 0x64, 0x32, 0x31, 0x64, 0x31, 0x63, 0x34, 0x39, 0x66, 0x30, 0x39, 0x36, 0x64, 0x62, 0x35, 0x63, 0x31, 0x39, 0x62, 0x61, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x34, 0x61, 0x38, 0x64, 0x62, 0x30, 0x38, 0x36, 0x66, 0x61, 0x65, 0x64, 0x34, 0x65, 0x66, 0x63, 0x33, 0x37, 0x31, 0x33, 0x31, 0x62, 0x33, 0x61, 0x32, 0x32, 0x62, 0x30, 0x37, 0x38, 0x32, 0x64, 0x61, 0x64, 0x37, 0x30, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x37, 0x66, 0x61, 0x35, 0x63, 0x61, 0x65, 0x38, 0x32, 0x66, 0x65, 0x64, 0x62, 0x36, 0x39, 0x61, 0x62, 0x31, 0x38, 0x39, 0x64, 0x33, 0x66, 0x66, 0x32, 0x37, 0x61, 0x65, 0x32, 0x30, 0x39, 0x32, 0x39, 0x33, 0x66, 0x62, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x36, 0x36, 0x30, 0x64, 0x65, 0x63, 0x38, 0x32, 0x35, 0x35, 0x32, 0x32, 0x61, 0x39, 0x66, 0x36, 0x32, 0x66, 0x63, 0x65, 0x63, 0x33, 0x63, 0x35, 0x62, 0x37, 0x33, 0x31, 0x39, 0x38, 0x30, 0x64, 0x63, 0x32, 0x38, 0x36, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x62, 0x39, 0x62, 0x31, 0x30, 0x37, 0x31, 0x35, 0x37, 0x31, 0x34, 0x63, 0x30, 0x39, 0x63, 0x66, 0x64, 0x36, 0x31, 0x30, 0x63, 0x66, 0x39, 0x63, 0x39, 0x38, 0x34, 0x36, 0x30, 0x35, 0x31, 0x63, 0x62, 0x31, 0x64, 0x35, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x34, 0x36, 0x37, 0x64, 0x38, 0x30, 0x65, 0x37, 0x34, 0x63, 0x33, 0x35, 0x34, 0x30, 0x37, 0x62, 0x37, 0x64, 0x62, 0x35, 0x31, 0x37, 0x38, 0x39, 0x32, 0x33, 0x34, 0x36, 0x31, 0x35, 0x66, 0x65, 0x61, 0x36, 0x36, 0x38, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x39, 0x64, 0x35, 0x61, 0x30, 0x30, 0x38, 0x38, 0x66, 0x31, 0x64, 0x64, 0x62, 0x32, 0x66, 0x64, 0x33, 0x38, 0x30, 0x65, 0x32, 0x61, 0x30, 0x34, 0x39, 0x31, 0x39, 0x32, 0x32, 0x36, 0x36, 0x63, 0x35, 0x31, 0x63, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x64, 0x31, 0x65, 0x39, 0x39, 0x61, 0x66, 0x39, 0x31, 0x32, 0x33, 0x31, 0x38, 0x35, 0x38, 0x65, 0x37, 0x30, 0x36, 0x35, 0x64, 0x64, 0x31, 0x39, 0x31, 0x38, 0x33, 0x33, 0x30, 0x64, 0x63, 0x34, 0x63, 0x37, 0x34, 0x37, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x32, 0x31, 0x33, 0x30, 0x32, 0x63, 0x61, 0x35, 0x30, 0x39, 0x36, 0x62, 0x65, 0x61, 0x37, 0x34, 0x30, 0x32, 0x62, 0x39, 0x31, 0x62, 0x30, 0x66, 0x64, 0x35, 0x30, 0x36, 0x32, 0x35, 0x34, 0x66, 0x39, 0x39, 0x39, 0x61, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x36, 0x38, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x34, 0x62, 0x36, 0x36, 0x34, 0x34, 0x66, 0x34, 0x33, 0x39, 0x63, 0x38, 0x30, 0x35, 0x31, 0x64, 0x66, 0x63, 0x36, 0x34, 0x64, 0x33, 0x38, 0x31, 0x62, 0x38, 0x63, 0x38, 0x36, 0x63, 0x37, 0x35, 0x63, 0x31, 0x37, 0x35, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x32, 0x38, 0x65, 0x62, 0x63, 0x30, 0x38, 0x37, 0x34, 0x38, 0x30, 0x66, 0x64, 0x36, 0x34, 0x35, 0x34, 0x37, 0x63, 0x61, 0x32, 0x38, 0x31, 0x66, 0x35, 0x65, 0x61, 0x63, 0x65, 0x33, 0x30, 0x34, 0x31, 0x34, 0x35, 0x33, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x64, 0x61, 0x33, 0x65, 0x33, 0x35, 0x62, 0x32, 0x33, 0x62, 0x62, 0x31, 0x66, 0x37, 0x32, 0x66, 0x38, 0x65, 0x32, 0x32, 0x35, 0x38, 0x63, 0x66, 0x37, 0x66, 0x35, 0x35, 0x33, 0x33, 0x35, 0x39, 0x64, 0x32, 0x34, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x65, 0x35, 0x35, 0x38, 0x61, 0x33, 0x63, 0x35, 0x36, 0x39, 0x37, 0x65, 0x36, 0x66, 0x62, 0x32, 0x33, 0x61, 0x32, 0x35, 0x39, 0x34, 0x63, 0x38, 0x38, 0x30, 0x62, 0x37, 0x61, 0x31, 0x62, 0x36, 0x38, 0x66, 0x39, 0x38, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x39, 0x35, 0x31, 0x61, 0x34, 0x33, 0x32, 0x37, 0x34, 0x65, 0x65, 0x61, 0x66, 0x63, 0x38, 0x61, 0x30, 0x39, 0x30, 0x33, 0x62, 0x30, 0x61, 0x66, 0x32, 0x65, 0x63, 0x39, 0x32, 0x62, 0x66, 0x31, 0x65, 0x66, 0x63, 0x38, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x31, 0x35, 0x66, 0x36, 0x66, 0x63, 0x62, 0x38, 0x34, 0x64, 0x66, 0x37, 0x62, 0x62, 0x34, 0x31, 0x30, 0x65, 0x38, 0x63, 0x38, 0x66, 0x30, 0x34, 0x38, 0x39, 0x34, 0x61, 0x38, 0x38, 0x31, 0x64, 0x63, 0x61, 0x63, 0x32, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x63, 0x62, 0x30, 0x33, 0x61, 0x63, 0x66, 0x37, 0x66, 0x35, 0x33, 0x63, 0x65, 0x38, 0x37, 0x61, 0x61, 0x64, 0x63, 0x63, 0x32, 0x31, 0x61, 0x39, 0x39, 0x33, 0x32, 0x64, 0x65, 0x39, 0x31, 0x35, 0x66, 0x38, 0x39, 0x38, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x38, 0x63, 0x38, 0x35, 0x61, 0x39, 0x62, 0x39, 0x32, 0x30, 0x37, 0x64, 0x38, 0x31, 0x34, 0x36, 0x30, 0x33, 0x33, 0x66, 0x65, 0x33, 0x38, 0x31, 0x34, 0x33, 0x66, 0x36, 0x64, 0x33, 0x34, 0x62, 0x35, 0x39, 0x35, 0x63, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x39, 0x63, 0x30, 0x36, 0x62, 0x34, 0x38, 0x37, 0x65, 0x38, 0x35, 0x34, 0x36, 0x61, 0x62, 0x64, 0x66, 0x63, 0x39, 0x35, 0x38, 0x61, 0x32, 0x35, 0x61, 0x33, 0x66, 0x30, 0x66, 0x62, 0x61, 0x35, 0x33, 0x66, 0x36, 0x66, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x31, 0x35, 0x30, 0x37, 0x61, 0x65, 0x65, 0x65, 0x36, 0x61, 0x32, 0x35, 0x35, 0x64, 0x63, 0x32, 0x63, 0x64, 0x39, 0x64, 0x66, 0x35, 0x35, 0x31, 0x35, 0x34, 0x30, 0x36, 0x32, 0x64, 0x30, 0x38, 0x39, 0x37, 0x62, 0x32, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x32, 0x62, 0x31, 0x63, 0x38, 0x35, 0x33, 0x61, 0x65, 0x62, 0x32, 0x38, 0x63, 0x34, 0x35, 0x35, 0x33, 0x39, 0x61, 0x66, 0x37, 0x36, 0x61, 0x30, 0x30, 0x61, 0x63, 0x32, 0x64, 0x38, 0x61, 0x38, 0x32, 0x34, 0x32, 0x38, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x64, 0x36, 0x37, 0x61, 0x39, 0x30, 0x34, 0x34, 0x62, 0x34, 0x33, 0x35, 0x62, 0x36, 0x36, 0x65, 0x38, 0x39, 0x37, 0x37, 0x66, 0x66, 0x33, 0x39, 0x61, 0x32, 0x38, 0x64, 0x63, 0x34, 0x62, 0x64, 0x35, 0x33, 0x37, 0x32, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x33, 0x37, 0x35, 0x39, 0x64, 0x64, 0x31, 0x63, 0x34, 0x65, 0x33, 0x36, 0x32, 0x65, 0x62, 0x31, 0x39, 0x33, 0x39, 0x38, 0x39, 0x35, 0x31, 0x66, 0x66, 0x39, 0x66, 0x38, 0x66, 0x61, 0x64, 0x31, 0x64, 0x33, 0x31, 0x30, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x35, 0x38, 0x39, 0x39, 0x30, 0x62, 0x63, 0x64, 0x39, 0x30, 0x63, 0x66, 0x62, 0x66, 0x36, 0x64, 0x38, 0x66, 0x30, 0x39, 0x38, 0x36, 0x66, 0x36, 0x66, 0x61, 0x36, 0x30, 0x30, 0x32, 0x37, 0x36, 0x62, 0x39, 0x34, 0x65, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x66, 0x35, 0x63, 0x38, 0x34, 0x66, 0x37, 0x62, 0x39, 0x30, 0x39, 0x61, 0x61, 0x62, 0x33, 0x65, 0x36, 0x31, 0x66, 0x65, 0x30, 0x65, 0x63, 0x62, 0x31, 0x62, 0x33, 0x62, 0x66, 0x32, 0x36, 0x30, 0x32, 0x32, 0x32, 0x61, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x62, 0x32, 0x34, 0x39, 0x35, 0x64, 0x36, 0x61, 0x63, 0x61, 0x37, 0x62, 0x32, 0x61, 0x36, 0x61, 0x32, 0x64, 0x31, 0x33, 0x38, 0x62, 0x36, 0x65, 0x31, 0x61, 0x34, 0x32, 0x65, 0x32, 0x64, 0x63, 0x33, 0x31, 0x31, 0x66, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x32, 0x30, 0x33, 0x63, 0x63, 0x33, 0x37, 0x35, 0x39, 0x39, 0x62, 0x36, 0x34, 0x38, 0x33, 0x31, 0x32, 0x61, 0x37, 0x63, 0x63, 0x39, 0x65, 0x30, 0x36, 0x64, 0x61, 0x63, 0x62, 0x35, 0x38, 0x39, 0x61, 0x39, 0x61, 0x65, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x38, 0x36, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x39, 0x62, 0x33, 0x34, 0x37, 0x34, 0x36, 0x34, 0x62, 0x32, 0x66, 0x39, 0x39, 0x32, 0x39, 0x64, 0x38, 0x30, 0x37, 0x65, 0x30, 0x33, 0x39, 0x64, 0x61, 0x65, 0x34, 0x38, 0x64, 0x33, 0x64, 0x39, 0x38, 0x64, 0x65, 0x33, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x64, 0x32, 0x34, 0x33, 0x34, 0x62, 0x37, 0x61, 0x37, 0x64, 0x62, 0x62, 0x66, 0x66, 0x30, 0x38, 0x32, 0x32, 0x33, 0x62, 0x36, 0x33, 0x38, 0x37, 0x62, 0x30, 0x35, 0x64, 0x61, 0x32, 0x65, 0x35, 0x30, 0x39, 0x33, 0x31, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x64, 0x37, 0x36, 0x34, 0x34, 0x36, 0x64, 0x35, 0x61, 0x61, 0x64, 0x66, 0x66, 0x38, 0x30, 0x62, 0x36, 0x38, 0x62, 0x39, 0x31, 0x62, 0x30, 0x38, 0x63, 0x64, 0x39, 0x62, 0x63, 0x38, 0x66, 0x35, 0x35, 0x35, 0x31, 0x61, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x33, 0x31, 0x35, 0x38, 0x37, 0x62, 0x35, 0x66, 0x64, 0x35, 0x38, 0x36, 0x39, 0x38, 0x34, 0x35, 0x37, 0x38, 0x38, 0x37, 0x32, 0x35, 0x61, 0x36, 0x36, 0x33, 0x32, 0x39, 0x30, 0x61, 0x34, 0x39, 0x64, 0x33, 0x36, 0x37, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x37, 0x31, 0x35, 0x65, 0x66, 0x39, 0x31, 0x37, 0x36, 0x66, 0x38, 0x35, 0x30, 0x62, 0x32, 0x65, 0x33, 0x30, 0x65, 0x62, 0x38, 0x65, 0x33, 0x38, 0x32, 0x37, 0x30, 0x37, 0x66, 0x37, 0x37, 0x37, 0x61, 0x36, 0x66, 0x62, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x32, 0x31, 0x34, 0x37, 0x39, 0x34, 0x37, 0x61, 0x65, 0x33, 0x33, 0x66, 0x62, 0x30, 0x39, 0x38, 0x62, 0x34, 0x38, 0x39, 0x61, 0x35, 0x63, 0x31, 0x36, 0x62, 0x66, 0x66, 0x66, 0x39, 0x61, 0x62, 0x63, 0x64, 0x34, 0x65, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x63, 0x30, 0x64, 0x30, 0x62, 0x63, 0x39, 0x33, 0x61, 0x36, 0x32, 0x65, 0x32, 0x35, 0x37, 0x31, 0x37, 0x34, 0x37, 0x30, 0x30, 0x65, 0x31, 0x30, 0x66, 0x30, 0x32, 0x34, 0x63, 0x38, 0x62, 0x32, 0x33, 0x66, 0x31, 0x66, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x39, 0x37, 0x38, 0x66, 0x32, 0x65, 0x33, 0x34, 0x34, 0x30, 0x37, 0x66, 0x61, 0x62, 0x31, 0x64, 0x63, 0x32, 0x31, 0x38, 0x33, 0x64, 0x39, 0x35, 0x63, 0x66, 0x64, 0x61, 0x36, 0x32, 0x36, 0x30, 0x62, 0x33, 0x35, 0x39, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x66, 0x39, 0x37, 0x34, 0x64, 0x39, 0x39, 0x30, 0x34, 0x66, 0x34, 0x35, 0x63, 0x65, 0x38, 0x31, 0x61, 0x38, 0x34, 0x35, 0x65, 0x31, 0x31, 0x65, 0x66, 0x34, 0x63, 0x62, 0x63, 0x66, 0x32, 0x37, 0x61, 0x66, 0x37, 0x31, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x37, 0x36, 0x31, 0x65, 0x61, 0x61, 0x30, 0x66, 0x33, 0x34, 0x35, 0x66, 0x37, 0x37, 0x37, 0x62, 0x35, 0x34, 0x34, 0x31, 0x62, 0x37, 0x33, 0x61, 0x30, 0x66, 0x61, 0x35, 0x62, 0x35, 0x36, 0x62, 0x38, 0x35, 0x66, 0x32, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x36, 0x30, 0x34, 0x33, 0x36, 0x39, 0x31, 0x32, 0x64, 0x65, 0x36, 0x62, 0x66, 0x31, 0x38, 0x37, 0x64, 0x33, 0x61, 0x34, 0x37, 0x32, 0x66, 0x66, 0x38, 0x66, 0x35, 0x33, 0x33, 0x33, 0x61, 0x30, 0x66, 0x37, 0x65, 0x64, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x66, 0x38, 0x66, 0x30, 0x35, 0x37, 0x64, 0x62, 0x37, 0x65, 0x36, 0x30, 0x65, 0x36, 0x37, 0x35, 0x61, 0x64, 0x39, 0x34, 0x30, 0x66, 0x31, 0x35, 0x35, 0x38, 0x38, 0x35, 0x64, 0x31, 0x61, 0x34, 0x37, 0x37, 0x33, 0x34, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x33, 0x33, 0x34, 0x39, 0x31, 0x37, 0x36, 0x30, 0x63, 0x38, 0x66, 0x30, 0x62, 0x34, 0x64, 0x66, 0x38, 0x63, 0x61, 0x61, 0x63, 0x37, 0x38, 0x65, 0x64, 0x38, 0x33, 0x35, 0x63, 0x61, 0x65, 0x65, 0x32, 0x31, 0x30, 0x34, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x37, 0x37, 0x35, 0x65, 0x34, 0x61, 0x66, 0x36, 0x61, 0x32, 0x33, 0x61, 0x66, 0x61, 0x32, 0x30, 0x31, 0x66, 0x62, 0x37, 0x38, 0x62, 0x39, 0x31, 0x35, 0x65, 0x35, 0x31, 0x61, 0x35, 0x31, 0x35, 0x62, 0x37, 0x61, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x64, 0x36, 0x34, 0x33, 0x38, 0x34, 0x32, 0x34, 0x39, 0x62, 0x37, 0x37, 0x36, 0x37, 0x39, 0x34, 0x30, 0x36, 0x33, 0x62, 0x35, 0x36, 0x39, 0x38, 0x37, 0x38, 0x64, 0x35, 0x65, 0x33, 0x62, 0x35, 0x33, 0x30, 0x61, 0x34, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x37, 0x35, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x36, 0x33, 0x33, 0x61, 0x33, 0x37, 0x33, 0x37, 0x66, 0x36, 0x38, 0x34, 0x33, 0x39, 0x62, 0x61, 0x63, 0x37, 0x63, 0x39, 0x30, 0x61, 0x35, 0x32, 0x31, 0x34, 0x32, 0x30, 0x35, 0x38, 0x65, 0x65, 0x38, 0x65, 0x38, 0x61, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x62, 0x64, 0x36, 0x32, 0x61, 0x30, 0x35, 0x30, 0x38, 0x34, 0x35, 0x32, 0x36, 0x31, 0x66, 0x61, 0x34, 0x61, 0x39, 0x66, 0x37, 0x63, 0x66, 0x32, 0x34, 0x31, 0x65, 0x61, 0x36, 0x33, 0x30, 0x62, 0x30, 0x35, 0x65, 0x66, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x32, 0x39, 0x38, 0x37, 0x66, 0x30, 0x36, 0x35, 0x31, 0x62, 0x39, 0x31, 0x35, 0x62, 0x32, 0x65, 0x31, 0x65, 0x35, 0x33, 0x32, 0x38, 0x63, 0x31, 0x32, 0x31, 0x39, 0x36, 0x30, 0x64, 0x34, 0x62, 0x64, 0x64, 0x36, 0x61, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x61, 0x66, 0x36, 0x65, 0x63, 0x64, 0x62, 0x39, 0x31, 0x61, 0x63, 0x62, 0x33, 0x36, 0x30, 0x36, 0x61, 0x38, 0x33, 0x35, 0x37, 0x63, 0x30, 0x62, 0x63, 0x34, 0x66, 0x34, 0x35, 0x63, 0x66, 0x64, 0x32, 0x64, 0x37, 0x65, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x35, 0x61, 0x33, 0x31, 0x31, 0x64, 0x39, 0x66, 0x36, 0x39, 0x38, 0x39, 0x38, 0x61, 0x37, 0x63, 0x36, 0x61, 0x39, 0x64, 0x36, 0x33, 0x36, 0x30, 0x36, 0x38, 0x30, 0x34, 0x33, 0x38, 0x65, 0x36, 0x37, 0x61, 0x37, 0x62, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x38, 0x35, 0x39, 0x63, 0x35, 0x62, 0x35, 0x34, 0x38, 0x62, 0x37, 0x30, 0x30, 0x64, 0x39, 0x32, 0x38, 0x34, 0x63, 0x65, 0x65, 0x34, 0x62, 0x36, 0x36, 0x33, 0x33, 0x63, 0x32, 0x66, 0x35, 0x32, 0x65, 0x35, 0x32, 0x39, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x37, 0x32, 0x33, 0x30, 0x39, 0x31, 0x36, 0x39, 0x62, 0x31, 0x34, 0x30, 0x32, 0x65, 0x63, 0x38, 0x31, 0x33, 0x31, 0x61, 0x31, 0x37, 0x61, 0x36, 0x61, 0x61, 0x63, 0x33, 0x32, 0x32, 0x32, 0x66, 0x38, 0x39, 0x65, 0x36, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x36, 0x64, 0x37, 0x34, 0x38, 0x35, 0x63, 0x62, 0x65, 0x39, 0x39, 0x30, 0x61, 0x63, 0x63, 0x31, 0x61, 0x64, 0x30, 0x65, 0x65, 0x39, 0x65, 0x38, 0x63, 0x63, 0x66, 0x33, 0x39, 0x63, 0x30, 0x63, 0x39, 0x33, 0x34, 0x34, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x63, 0x31, 0x31, 0x64, 0x30, 0x32, 0x34, 0x64, 0x31, 0x32, 0x61, 0x65, 0x34, 0x38, 0x36, 0x63, 0x31, 0x30, 0x39, 0x35, 0x62, 0x37, 0x61, 0x37, 0x62, 0x39, 0x63, 0x34, 0x61, 0x66, 0x33, 0x65, 0x38, 0x65, 0x64, 0x65, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x33, 0x34, 0x31, 0x33, 0x38, 0x37, 0x38, 0x61, 0x65, 0x61, 0x33, 0x62, 0x63, 0x31, 0x30, 0x38, 0x36, 0x33, 0x30, 0x39, 0x61, 0x33, 0x66, 0x65, 0x37, 0x36, 0x38, 0x62, 0x36, 0x35, 0x35, 0x35, 0x39, 0x65, 0x38, 0x63, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x30, 0x35, 0x36, 0x39, 0x65, 0x35, 0x35, 0x35, 0x38, 0x66, 0x63, 0x37, 0x64, 0x66, 0x32, 0x37, 0x36, 0x36, 0x66, 0x32, 0x62, 0x61, 0x31, 0x35, 0x64, 0x63, 0x38, 0x61, 0x65, 0x66, 0x66, 0x63, 0x35, 0x62, 0x65, 0x62, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x31, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x31, 0x35, 0x62, 0x30, 0x37, 0x34, 0x33, 0x66, 0x39, 0x34, 0x66, 0x63, 0x38, 0x63, 0x63, 0x38, 0x36, 0x35, 0x34, 0x66, 0x64, 0x39, 0x64, 0x35, 0x39, 0x37, 0x65, 0x64, 0x37, 0x64, 0x38, 0x62, 0x37, 0x37, 0x63, 0x35, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x38, 0x35, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x32, 0x36, 0x34, 0x38, 0x30, 0x61, 0x31, 0x35, 0x30, 0x39, 0x36, 0x31, 0x62, 0x38, 0x65, 0x33, 0x30, 0x37, 0x35, 0x30, 0x37, 0x31, 0x33, 0x61, 0x39, 0x34, 0x65, 0x65, 0x36, 0x66, 0x32, 0x65, 0x34, 0x37, 0x66, 0x63, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x65, 0x35, 0x64, 0x65, 0x37, 0x63, 0x37, 0x66, 0x62, 0x37, 0x65, 0x65, 0x65, 0x30, 0x66, 0x33, 0x36, 0x65, 0x36, 0x34, 0x35, 0x33, 0x30, 0x61, 0x34, 0x31, 0x34, 0x34, 0x30, 0x65, 0x64, 0x66, 0x62, 0x65, 0x66, 0x61, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x33, 0x61, 0x37, 0x63, 0x62, 0x61, 0x62, 0x37, 0x30, 0x64, 0x37, 0x61, 0x36, 0x34, 0x64, 0x30, 0x61, 0x37, 0x65, 0x35, 0x32, 0x39, 0x38, 0x30, 0x66, 0x36, 0x38, 0x31, 0x34, 0x37, 0x32, 0x35, 0x39, 0x33, 0x34, 0x39, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x32, 0x37, 0x30, 0x61, 0x64, 0x35, 0x32, 0x39, 0x66, 0x31, 0x66, 0x30, 0x62, 0x38, 0x64, 0x39, 0x63, 0x62, 0x36, 0x64, 0x32, 0x34, 0x32, 0x37, 0x65, 0x63, 0x31, 0x62, 0x37, 0x65, 0x32, 0x64, 0x63, 0x36, 0x34, 0x61, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x33, 0x62, 0x64, 0x64, 0x35, 0x39, 0x64, 0x63, 0x64, 0x64, 0x61, 0x35, 0x61, 0x39, 0x62, 0x62, 0x32, 0x61, 0x63, 0x31, 0x36, 0x34, 0x31, 0x66, 0x64, 0x30, 0x32, 0x31, 0x38, 0x30, 0x66, 0x35, 0x66, 0x33, 0x36, 0x35, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x65, 0x62, 0x66, 0x35, 0x30, 0x62, 0x63, 0x37, 0x65, 0x35, 0x34, 0x66, 0x38, 0x32, 0x65, 0x39, 0x62, 0x39, 0x62, 0x64, 0x32, 0x34, 0x62, 0x61, 0x65, 0x66, 0x32, 0x39, 0x34, 0x33, 0x38, 0x65, 0x32, 0x35, 0x39, 0x63, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x32, 0x63, 0x38, 0x66, 0x38, 0x31, 0x38, 0x37, 0x32, 0x63, 0x37, 0x39, 0x66, 0x65, 0x64, 0x35, 0x32, 0x31, 0x63, 0x62, 0x35, 0x66, 0x39, 0x35, 0x30, 0x64, 0x38, 0x62, 0x30, 0x33, 0x32, 0x33, 0x32, 0x32, 0x65, 0x61, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x34, 0x31, 0x33, 0x32, 0x36, 0x30, 0x30, 0x66, 0x34, 0x31, 0x35, 0x35, 0x65, 0x30, 0x37, 0x66, 0x34, 0x64, 0x34, 0x35, 0x62, 0x63, 0x33, 0x65, 0x62, 0x38, 0x64, 0x39, 0x66, 0x62, 0x37, 0x32, 0x64, 0x63, 0x64, 0x37, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x65, 0x32, 0x62, 0x39, 0x34, 0x61, 0x64, 0x39, 0x35, 0x30, 0x61, 0x32, 0x61, 0x36, 0x32, 0x36, 0x34, 0x30, 0x63, 0x33, 0x35, 0x62, 0x66, 0x63, 0x63, 0x64, 0x36, 0x63, 0x36, 0x37, 0x64, 0x61, 0x65, 0x34, 0x35, 0x30, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x63, 0x36, 0x61, 0x63, 0x37, 0x34, 0x32, 0x65, 0x37, 0x63, 0x38, 0x35, 0x37, 0x64, 0x34, 0x61, 0x30, 0x35, 0x61, 0x30, 0x34, 0x63, 0x33, 0x33, 0x64, 0x34, 0x64, 0x30, 0x35, 0x63, 0x31, 0x34, 0x36, 0x37, 0x35, 0x37, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x64, 0x64, 0x64, 0x38, 0x35, 0x66, 0x63, 0x39, 0x38, 0x62, 0x65, 0x39, 0x63, 0x34, 0x30, 0x34, 0x35, 0x39, 0x36, 0x31, 0x66, 0x34, 0x30, 0x66, 0x39, 0x33, 0x38, 0x30, 0x35, 0x65, 0x63, 0x63, 0x34, 0x35, 0x34, 0x39, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x34, 0x30, 0x36, 0x35, 0x33, 0x36, 0x31, 0x63, 0x62, 0x38, 0x35, 0x34, 0x66, 0x61, 0x63, 0x34, 0x32, 0x62, 0x66, 0x62, 0x35, 0x63, 0x39, 0x66, 0x63, 0x64, 0x65, 0x30, 0x36, 0x30, 0x34, 0x61, 0x63, 0x39, 0x31, 0x39, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x36, 0x66, 0x66, 0x35, 0x66, 0x36, 0x61, 0x37, 0x61, 0x66, 0x37, 0x62, 0x37, 0x61, 0x65, 0x30, 0x65, 0x64, 0x39, 0x63, 0x32, 0x30, 0x65, 0x63, 0x65, 0x63, 0x35, 0x30, 0x32, 0x33, 0x64, 0x32, 0x38, 0x31, 0x62, 0x37, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x33, 0x61, 0x34, 0x38, 0x35, 0x34, 0x39, 0x31, 0x31, 0x31, 0x34, 0x35, 0x65, 0x61, 0x30, 0x31, 0x63, 0x36, 0x34, 0x34, 0x30, 0x34, 0x34, 0x62, 0x64, 0x62, 0x32, 0x65, 0x35, 0x61, 0x39, 0x36, 0x30, 0x61, 0x39, 0x38, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x34, 0x39, 0x37, 0x65, 0x39, 0x32, 0x63, 0x64, 0x63, 0x30, 0x65, 0x30, 0x62, 0x39, 0x36, 0x33, 0x64, 0x37, 0x35, 0x32, 0x62, 0x32, 0x32, 0x39, 0x36, 0x61, 0x63, 0x62, 0x38, 0x37, 0x64, 0x61, 0x38, 0x32, 0x38, 0x62, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x66, 0x36, 0x37, 0x66, 0x62, 0x38, 0x37, 0x66, 0x36, 0x65, 0x66, 0x62, 0x61, 0x39, 0x32, 0x37, 0x39, 0x39, 0x33, 0x30, 0x63, 0x66, 0x62, 0x64, 0x31, 0x62, 0x37, 0x61, 0x33, 0x34, 0x33, 0x63, 0x37, 0x39, 0x66, 0x61, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x66, 0x32, 0x65, 0x35, 0x63, 0x63, 0x65, 0x63, 0x64, 0x35, 0x32, 0x63, 0x63, 0x34, 0x62, 0x39, 0x35, 0x65, 0x30, 0x35, 0x39, 0x37, 0x64, 0x66, 0x32, 0x37, 0x63, 0x63, 0x30, 0x37, 0x39, 0x37, 0x31, 0x35, 0x36, 0x30, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x64, 0x61, 0x30, 0x38, 0x34, 0x65, 0x37, 0x39, 0x36, 0x35, 0x30, 0x30, 0x62, 0x61, 0x31, 0x34, 0x63, 0x35, 0x31, 0x32, 0x31, 0x63, 0x30, 0x64, 0x39, 0x30, 0x38, 0x34, 0x36, 0x66, 0x36, 0x36, 0x65, 0x34, 0x62, 0x65, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x33, 0x36, 0x62, 0x34, 0x64, 0x33, 0x30, 0x34, 0x37, 0x33, 0x36, 0x34, 0x31, 0x61, 0x62, 0x35, 0x36, 0x61, 0x65, 0x65, 0x65, 0x31, 0x39, 0x32, 0x34, 0x32, 0x37, 0x36, 0x31, 0x64, 0x37, 0x32, 0x37, 0x32, 0x35, 0x31, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x35, 0x35, 0x64, 0x65, 0x30, 0x34, 0x35, 0x38, 0x66, 0x38, 0x35, 0x30, 0x62, 0x33, 0x37, 0x65, 0x34, 0x64, 0x37, 0x38, 0x61, 0x36, 0x34, 0x31, 0x64, 0x64, 0x32, 0x65, 0x62, 0x32, 0x64, 0x64, 0x38, 0x66, 0x33, 0x38, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x30, 0x63, 0x61, 0x32, 0x38, 0x66, 0x66, 0x33, 0x33, 0x62, 0x39, 0x66, 0x36, 0x36, 0x64, 0x37, 0x66, 0x31, 0x66, 0x63, 0x30, 0x30, 0x37, 0x38, 0x66, 0x38, 0x63, 0x31, 0x65, 0x65, 0x66, 0x36, 0x39, 0x61, 0x31, 0x62, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x31, 0x34, 0x32, 0x36, 0x31, 0x66, 0x30, 0x31, 0x30, 0x38, 0x39, 0x66, 0x35, 0x33, 0x37, 0x39, 0x35, 0x36, 0x33, 0x30, 0x62, 0x61, 0x39, 0x64, 0x64, 0x32, 0x34, 0x66, 0x39, 0x61, 0x33, 0x34, 0x63, 0x32, 0x64, 0x39, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x34, 0x31, 0x35, 0x66, 0x61, 0x62, 0x36, 0x31, 0x65, 0x30, 0x64, 0x66, 0x64, 0x34, 0x62, 0x39, 0x30, 0x36, 0x37, 0x36, 0x31, 0x34, 0x31, 0x61, 0x35, 0x35, 0x37, 0x61, 0x38, 0x36, 0x39, 0x62, 0x61, 0x30, 0x62, 0x64, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x33, 0x34, 0x34, 0x39, 0x30, 0x39, 0x36, 0x34, 0x34, 0x63, 0x37, 0x61, 0x64, 0x34, 0x39, 0x33, 0x30, 0x66, 0x64, 0x38, 0x37, 0x33, 0x63, 0x61, 0x31, 0x63, 0x30, 0x64, 0x61, 0x32, 0x64, 0x34, 0x33, 0x34, 0x63, 0x30, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x62, 0x32, 0x31, 0x37, 0x63, 0x63, 0x62, 0x37, 0x38, 0x36, 0x61, 0x32, 0x35, 0x34, 0x63, 0x66, 0x34, 0x64, 0x63, 0x35, 0x37, 0x66, 0x35, 0x64, 0x39, 0x61, 0x63, 0x33, 0x63, 0x34, 0x35, 0x35, 0x61, 0x33, 0x30, 0x34, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x64, 0x62, 0x63, 0x65, 0x63, 0x31, 0x30, 0x31, 0x34, 0x62, 0x39, 0x36, 0x64, 0x61, 0x32, 0x31, 0x35, 0x38, 0x63, 0x61, 0x35, 0x31, 0x33, 0x65, 0x39, 0x63, 0x38, 0x64, 0x33, 0x62, 0x39, 0x61, 0x66, 0x31, 0x63, 0x33, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x61, 0x39, 0x66, 0x37, 0x39, 0x39, 0x37, 0x65, 0x35, 0x33, 0x38, 0x37, 0x62, 0x36, 0x62, 0x32, 0x61, 0x61, 0x30, 0x31, 0x33, 0x35, 0x61, 0x63, 0x32, 0x34, 0x35, 0x32, 0x66, 0x65, 0x33, 0x36, 0x62, 0x34, 0x63, 0x32, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x30, 0x61, 0x64, 0x32, 0x63, 0x34, 0x65, 0x39, 0x65, 0x65, 0x62, 0x66, 0x61, 0x36, 0x33, 0x37, 0x65, 0x66, 0x35, 0x36, 0x62, 0x64, 0x34, 0x38, 0x36, 0x61, 0x64, 0x32, 0x61, 0x31, 0x65, 0x35, 0x62, 0x63, 0x65, 0x30, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x65, 0x32, 0x37, 0x66, 0x32, 0x34, 0x35, 0x65, 0x30, 0x32, 0x64, 0x31, 0x63, 0x33, 0x31, 0x32, 0x63, 0x31, 0x64, 0x35, 0x30, 0x30, 0x37, 0x38, 0x38, 0x63, 0x39, 0x64, 0x65, 0x66, 0x37, 0x36, 0x39, 0x30, 0x34, 0x35, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x33, 0x34, 0x66, 0x34, 0x36, 0x33, 0x64, 0x31, 0x38, 0x34, 0x38, 0x35, 0x35, 0x30, 0x31, 0x66, 0x38, 0x66, 0x38, 0x35, 0x61, 0x63, 0x65, 0x34, 0x39, 0x37, 0x32, 0x63, 0x39, 0x62, 0x36, 0x33, 0x32, 0x64, 0x62, 0x63, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x34, 0x31, 0x35, 0x32, 0x66, 0x63, 0x39, 0x35, 0x64, 0x35, 0x63, 0x31, 0x63, 0x61, 0x38, 0x62, 0x38, 0x38, 0x31, 0x31, 0x33, 0x61, 0x62, 0x62, 0x61, 0x64, 0x34, 0x64, 0x37, 0x31, 0x30, 0x65, 0x34, 0x30, 0x64, 0x65, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x62, 0x39, 0x38, 0x30, 0x64, 0x32, 0x38, 0x65, 0x65, 0x63, 0x65, 0x32, 0x63, 0x30, 0x36, 0x66, 0x63, 0x61, 0x36, 0x63, 0x39, 0x34, 0x37, 0x33, 0x30, 0x36, 0x38, 0x62, 0x33, 0x37, 0x64, 0x34, 0x61, 0x36, 0x64, 0x36, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x34, 0x32, 0x36, 0x39, 0x31, 0x32, 0x64, 0x30, 0x35, 0x39, 0x66, 0x61, 0x64, 0x39, 0x37, 0x34, 0x30, 0x62, 0x32, 0x65, 0x33, 0x39, 0x30, 0x61, 0x32, 0x65, 0x65, 0x61, 0x63, 0x30, 0x35, 0x34, 0x36, 0x66, 0x66, 0x30, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x39, 0x39, 0x39, 0x37, 0x35, 0x30, 0x39, 0x38, 0x38, 0x32, 0x30, 0x32, 0x37, 0x65, 0x61, 0x39, 0x34, 0x37, 0x32, 0x33, 0x31, 0x34, 0x32, 0x34, 0x62, 0x65, 0x64, 0x65, 0x64, 0x65, 0x32, 0x39, 0x36, 0x35, 0x64, 0x30, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x37, 0x63, 0x65, 0x37, 0x64, 0x65, 0x36, 0x35, 0x65, 0x38, 0x34, 0x37, 0x30, 0x38, 0x35, 0x39, 0x35, 0x61, 0x35, 0x32, 0x35, 0x34, 0x39, 0x37, 0x61, 0x33, 0x65, 0x62, 0x35, 0x65, 0x35, 0x61, 0x36, 0x36, 0x35, 0x30, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x33, 0x30, 0x63, 0x30, 0x30, 0x32, 0x34, 0x66, 0x64, 0x62, 0x66, 0x37, 0x33, 0x61, 0x38, 0x32, 0x65, 0x32, 0x31, 0x66, 0x63, 0x63, 0x66, 0x38, 0x63, 0x62, 0x64, 0x30, 0x39, 0x31, 0x33, 0x38, 0x34, 0x32, 0x31, 0x63, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x35, 0x32, 0x39, 0x31, 0x32, 0x62, 0x63, 0x31, 0x30, 0x65, 0x61, 0x33, 0x39, 0x64, 0x35, 0x34, 0x65, 0x32, 0x39, 0x33, 0x66, 0x37, 0x61, 0x65, 0x64, 0x36, 0x62, 0x39, 0x39, 0x61, 0x30, 0x66, 0x34, 0x63, 0x37, 0x33, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x63, 0x66, 0x38, 0x62, 0x30, 0x65, 0x34, 0x36, 0x35, 0x32, 0x31, 0x33, 0x32, 0x31, 0x31, 0x61, 0x35, 0x62, 0x35, 0x33, 0x64, 0x66, 0x62, 0x30, 0x64, 0x64, 0x32, 0x37, 0x31, 0x61, 0x32, 0x38, 0x32, 0x63, 0x31, 0x32, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x39, 0x36, 0x34, 0x65, 0x32, 0x64, 0x31, 0x37, 0x65, 0x39, 0x31, 0x38, 0x39, 0x66, 0x38, 0x38, 0x61, 0x38, 0x32, 0x30, 0x33, 0x39, 0x33, 0x36, 0x62, 0x34, 0x30, 0x61, 0x63, 0x39, 0x36, 0x65, 0x35, 0x33, 0x33, 0x63, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x62, 0x31, 0x61, 0x36, 0x33, 0x64, 0x61, 0x34, 0x64, 0x63, 0x64, 0x39, 0x66, 0x38, 0x31, 0x66, 0x65, 0x35, 0x34, 0x66, 0x35, 0x65, 0x33, 0x66, 0x63, 0x62, 0x34, 0x30, 0x35, 0x35, 0x65, 0x66, 0x37, 0x65, 0x63, 0x35, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x37, 0x37, 0x65, 0x37, 0x66, 0x37, 0x32, 0x62, 0x34, 0x33, 0x37, 0x62, 0x35, 0x37, 0x34, 0x66, 0x30, 0x30, 0x31, 0x32, 0x38, 0x62, 0x32, 0x31, 0x66, 0x32, 0x61, 0x63, 0x32, 0x36, 0x35, 0x31, 0x33, 0x33, 0x35, 0x32, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x66, 0x35, 0x63, 0x37, 0x34, 0x37, 0x38, 0x35, 0x63, 0x35, 0x36, 0x36, 0x38, 0x61, 0x38, 0x33, 0x38, 0x30, 0x37, 0x32, 0x30, 0x34, 0x38, 0x62, 0x66, 0x38, 0x62, 0x34, 0x35, 0x33, 0x35, 0x39, 0x34, 0x64, 0x64, 0x61, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x65, 0x35, 0x35, 0x34, 0x61, 0x66, 0x33, 0x64, 0x38, 0x37, 0x36, 0x32, 0x39, 0x36, 0x32, 0x30, 0x64, 0x61, 0x36, 0x31, 0x64, 0x35, 0x33, 0x38, 0x63, 0x37, 0x66, 0x35, 0x62, 0x34, 0x62, 0x35, 0x34, 0x63, 0x34, 0x61, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x39, 0x37, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x61, 0x31, 0x30, 0x34, 0x35, 0x31, 0x66, 0x33, 0x36, 0x31, 0x36, 0x36, 0x63, 0x66, 0x36, 0x34, 0x33, 0x64, 0x64, 0x32, 0x64, 0x65, 0x36, 0x63, 0x31, 0x63, 0x62, 0x62, 0x61, 0x38, 0x61, 0x30, 0x31, 0x31, 0x63, 0x66, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x39, 0x61, 0x64, 0x31, 0x32, 0x65, 0x66, 0x30, 0x35, 0x64, 0x36, 0x64, 0x39, 0x30, 0x32, 0x36, 0x31, 0x66, 0x39, 0x36, 0x63, 0x38, 0x33, 0x34, 0x30, 0x61, 0x30, 0x33, 0x38, 0x31, 0x39, 0x37, 0x34, 0x64, 0x66, 0x34, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x37, 0x66, 0x37, 0x66, 0x38, 0x31, 0x63, 0x64, 0x37, 0x61, 0x34, 0x30, 0x36, 0x66, 0x63, 0x34, 0x35, 0x39, 0x39, 0x34, 0x34, 0x30, 0x38, 0x62, 0x35, 0x30, 0x34, 0x39, 0x39, 0x31, 0x32, 0x63, 0x35, 0x36, 0x36, 0x34, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x61, 0x33, 0x64, 0x66, 0x35, 0x37, 0x62, 0x37, 0x61, 0x61, 0x65, 0x63, 0x31, 0x36, 0x61, 0x31, 0x36, 0x32, 0x66, 0x64, 0x35, 0x33, 0x31, 0x36, 0x66, 0x33, 0x35, 0x62, 0x65, 0x63, 0x30, 0x38, 0x32, 0x38, 0x32, 0x31, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x65, 0x30, 0x62, 0x39, 0x30, 0x33, 0x30, 0x38, 0x38, 0x65, 0x30, 0x63, 0x36, 0x33, 0x66, 0x35, 0x33, 0x64, 0x64, 0x30, 0x36, 0x39, 0x35, 0x37, 0x35, 0x34, 0x35, 0x32, 0x61, 0x66, 0x66, 0x35, 0x32, 0x34, 0x31, 0x30, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x65, 0x38, 0x38, 0x65, 0x32, 0x65, 0x35, 0x33, 0x39, 0x66, 0x66, 0x62, 0x34, 0x35, 0x30, 0x33, 0x38, 0x36, 0x62, 0x34, 0x65, 0x34, 0x36, 0x37, 0x38, 0x39, 0x62, 0x32, 0x32, 0x33, 0x66, 0x35, 0x34, 0x37, 0x36, 0x63, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x32, 0x37, 0x33, 0x34, 0x31, 0x66, 0x32, 0x36, 0x63, 0x31, 0x32, 0x30, 0x30, 0x31, 0x65, 0x33, 0x37, 0x38, 0x34, 0x30, 0x35, 0x65, 0x65, 0x33, 0x38, 0x62, 0x32, 0x64, 0x38, 0x34, 0x36, 0x34, 0x65, 0x63, 0x37, 0x31, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x36, 0x37, 0x35, 0x31, 0x36, 0x35, 0x36, 0x63, 0x30, 0x61, 0x38, 0x65, 0x66, 0x34, 0x33, 0x35, 0x37, 0x62, 0x37, 0x33, 0x34, 0x34, 0x33, 0x32, 0x32, 0x31, 0x33, 0x34, 0x62, 0x39, 0x38, 0x33, 0x35, 0x30, 0x34, 0x61, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x30, 0x36, 0x30, 0x64, 0x63, 0x36, 0x63, 0x35, 0x66, 0x31, 0x63, 0x62, 0x38, 0x63, 0x63, 0x37, 0x65, 0x31, 0x34, 0x35, 0x32, 0x65, 0x30, 0x32, 0x65, 0x65, 0x31, 0x36, 0x37, 0x35, 0x30, 0x38, 0x62, 0x35, 0x36, 0x35, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x37, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x31, 0x33, 0x36, 0x63, 0x39, 0x64, 0x66, 0x31, 0x36, 0x37, 0x61, 0x61, 0x31, 0x37, 0x62, 0x36, 0x66, 0x31, 0x38, 0x65, 0x32, 0x32, 0x61, 0x37, 0x30, 0x32, 0x63, 0x38, 0x38, 0x66, 0x34, 0x62, 0x63, 0x32, 0x38, 0x32, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x36, 0x31, 0x30, 0x38, 0x63, 0x31, 0x32, 0x30, 0x38, 0x34, 0x36, 0x31, 0x32, 0x65, 0x65, 0x64, 0x61, 0x37, 0x61, 0x39, 0x33, 0x64, 0x64, 0x63, 0x66, 0x38, 0x64, 0x32, 0x36, 0x30, 0x32, 0x65, 0x32, 0x37, 0x39, 0x65, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x62, 0x36, 0x34, 0x33, 0x64, 0x32, 0x31, 0x38, 0x37, 0x62, 0x33, 0x36, 0x34, 0x61, 0x66, 0x63, 0x31, 0x30, 0x61, 0x36, 0x66, 0x64, 0x33, 0x36, 0x38, 0x64, 0x37, 0x64, 0x35, 0x35, 0x66, 0x35, 0x30, 0x64, 0x31, 0x61, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x38, 0x33, 0x65, 0x37, 0x39, 0x38, 0x63, 0x33, 0x39, 0x36, 0x62, 0x37, 0x61, 0x35, 0x35, 0x65, 0x32, 0x61, 0x32, 0x32, 0x32, 0x34, 0x61, 0x62, 0x63, 0x64, 0x38, 0x33, 0x34, 0x62, 0x32, 0x37, 0x65, 0x61, 0x34, 0x35, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x33, 0x66, 0x34, 0x65, 0x33, 0x36, 0x31, 0x66, 0x65, 0x35, 0x64, 0x65, 0x63, 0x64, 0x39, 0x38, 0x39, 0x64, 0x34, 0x63, 0x38, 0x66, 0x37, 0x64, 0x37, 0x63, 0x63, 0x39, 0x37, 0x39, 0x39, 0x30, 0x33, 0x38, 0x35, 0x64, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x66, 0x32, 0x39, 0x65, 0x64, 0x30, 0x30, 0x37, 0x36, 0x36, 0x31, 0x31, 0x62, 0x35, 0x65, 0x35, 0x35, 0x65, 0x31, 0x33, 0x30, 0x35, 0x34, 0x37, 0x65, 0x36, 0x38, 0x61, 0x34, 0x38, 0x65, 0x32, 0x36, 0x64, 0x66, 0x35, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x34, 0x62, 0x35, 0x35, 0x31, 0x66, 0x36, 0x66, 0x64, 0x62, 0x63, 0x64, 0x61, 0x36, 0x63, 0x35, 0x31, 0x31, 0x62, 0x35, 0x62, 0x62, 0x33, 0x37, 0x32, 0x32, 0x35, 0x30, 0x61, 0x36, 0x62, 0x37, 0x38, 0x33, 0x65, 0x35, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x34, 0x62, 0x31, 0x39, 0x66, 0x31, 0x66, 0x36, 0x36, 0x63, 0x62, 0x65, 0x33, 0x31, 0x38, 0x33, 0x34, 0x37, 0x65, 0x34, 0x38, 0x64, 0x38, 0x34, 0x62, 0x31, 0x34, 0x30, 0x33, 0x39, 0x34, 0x36, 0x36, 0x63, 0x35, 0x39, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x31, 0x38, 0x33, 0x36, 0x34, 0x31, 0x65, 0x64, 0x62, 0x38, 0x38, 0x36, 0x63, 0x65, 0x36, 0x30, 0x62, 0x38, 0x31, 0x39, 0x30, 0x32, 0x36, 0x31, 0x65, 0x31, 0x34, 0x66, 0x34, 0x32, 0x64, 0x39, 0x33, 0x63, 0x63, 0x65, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x64, 0x62, 0x38, 0x30, 0x37, 0x38, 0x37, 0x33, 0x38, 0x36, 0x30, 0x61, 0x61, 0x63, 0x33, 0x64, 0x35, 0x61, 0x65, 0x61, 0x31, 0x65, 0x38, 0x38, 0x35, 0x65, 0x35, 0x32, 0x62, 0x66, 0x66, 0x32, 0x38, 0x36, 0x39, 0x39, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x37, 0x34, 0x63, 0x65, 0x65, 0x34, 0x66, 0x61, 0x30, 0x66, 0x36, 0x33, 0x37, 0x30, 0x61, 0x37, 0x38, 0x39, 0x34, 0x66, 0x31, 0x31, 0x36, 0x63, 0x64, 0x30, 0x30, 0x63, 0x31, 0x31, 0x34, 0x37, 0x62, 0x38, 0x33, 0x65, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x33, 0x32, 0x61, 0x34, 0x61, 0x38, 0x61, 0x32, 0x37, 0x66, 0x31, 0x63, 0x63, 0x36, 0x33, 0x39, 0x35, 0x34, 0x61, 0x61, 0x36, 0x33, 0x34, 0x66, 0x37, 0x38, 0x35, 0x37, 0x30, 0x35, 0x37, 0x33, 0x33, 0x34, 0x63, 0x37, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x62, 0x65, 0x62, 0x39, 0x39, 0x39, 0x33, 0x32, 0x65, 0x39, 0x37, 0x65, 0x36, 0x65, 0x30, 0x32, 0x30, 0x35, 0x38, 0x63, 0x66, 0x63, 0x36, 0x32, 0x64, 0x30, 0x62, 0x32, 0x36, 0x62, 0x63, 0x37, 0x63, 0x63, 0x61, 0x35, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x64, 0x65, 0x38, 0x62, 0x37, 0x33, 0x32, 0x65, 0x36, 0x30, 0x32, 0x33, 0x38, 0x37, 0x38, 0x65, 0x62, 0x32, 0x33, 0x65, 0x64, 0x31, 0x36, 0x32, 0x32, 0x39, 0x31, 0x32, 0x34, 0x62, 0x35, 0x66, 0x37, 0x61, 0x66, 0x62, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x63, 0x34, 0x65, 0x63, 0x62, 0x34, 0x65, 0x65, 0x38, 0x39, 0x31, 0x65, 0x61, 0x39, 0x38, 0x34, 0x61, 0x37, 0x63, 0x35, 0x63, 0x65, 0x66, 0x64, 0x38, 0x64, 0x66, 0x62, 0x30, 0x30, 0x33, 0x31, 0x30, 0x62, 0x32, 0x38, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x33, 0x39, 0x33, 0x66, 0x62, 0x30, 0x38, 0x31, 0x33, 0x65, 0x65, 0x31, 0x30, 0x31, 0x64, 0x62, 0x31, 0x65, 0x31, 0x34, 0x65, 0x63, 0x63, 0x37, 0x64, 0x33, 0x32, 0x32, 0x63, 0x37, 0x32, 0x62, 0x38, 0x63, 0x30, 0x34, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x35, 0x35, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x36, 0x36, 0x31, 0x32, 0x36, 0x38, 0x37, 0x39, 0x38, 0x34, 0x34, 0x64, 0x66, 0x61, 0x33, 0x34, 0x66, 0x65, 0x36, 0x35, 0x63, 0x39, 0x66, 0x32, 0x38, 0x38, 0x31, 0x31, 0x37, 0x66, 0x65, 0x66, 0x62, 0x34, 0x34, 0x39, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x32, 0x62, 0x61, 0x35, 0x30, 0x33, 0x32, 0x37, 0x36, 0x32, 0x31, 0x34, 0x62, 0x35, 0x30, 0x39, 0x66, 0x39, 0x37, 0x35, 0x38, 0x36, 0x62, 0x64, 0x38, 0x34, 0x32, 0x31, 0x31, 0x30, 0x64, 0x31, 0x30, 0x33, 0x64, 0x35, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x65, 0x63, 0x65, 0x36, 0x39, 0x39, 0x38, 0x61, 0x65, 0x31, 0x39, 0x30, 0x30, 0x64, 0x64, 0x33, 0x37, 0x37, 0x30, 0x63, 0x66, 0x34, 0x62, 0x39, 0x33, 0x38, 0x31, 0x32, 0x62, 0x61, 0x64, 0x38, 0x34, 0x66, 0x30, 0x33, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x30, 0x39, 0x32, 0x37, 0x62, 0x61, 0x63, 0x37, 0x64, 0x63, 0x33, 0x36, 0x36, 0x36, 0x39, 0x63, 0x32, 0x38, 0x33, 0x35, 0x34, 0x61, 0x62, 0x31, 0x62, 0x65, 0x38, 0x33, 0x64, 0x37, 0x65, 0x65, 0x63, 0x33, 0x30, 0x39, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x37, 0x66, 0x33, 0x65, 0x36, 0x31, 0x32, 0x39, 0x39, 0x63, 0x32, 0x64, 0x62, 0x39, 0x62, 0x39, 0x63, 0x30, 0x34, 0x38, 0x37, 0x63, 0x66, 0x36, 0x32, 0x37, 0x35, 0x31, 0x39, 0x65, 0x64, 0x30, 0x30, 0x61, 0x39, 0x31, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x63, 0x34, 0x36, 0x63, 0x33, 0x39, 0x36, 0x65, 0x36, 0x37, 0x34, 0x38, 0x36, 0x39, 0x61, 0x64, 0x39, 0x34, 0x38, 0x31, 0x36, 0x33, 0x38, 0x66, 0x30, 0x30, 0x31, 0x33, 0x36, 0x33, 0x30, 0x63, 0x38, 0x37, 0x63, 0x61, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x36, 0x38, 0x64, 0x32, 0x38, 0x61, 0x61, 0x66, 0x31, 0x65, 0x65, 0x65, 0x66, 0x65, 0x66, 0x36, 0x34, 0x36, 0x62, 0x36, 0x35, 0x65, 0x38, 0x63, 0x63, 0x38, 0x64, 0x31, 0x39, 0x30, 0x66, 0x36, 0x63, 0x36, 0x64, 0x61, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x39, 0x36, 0x39, 0x37, 0x34, 0x37, 0x66, 0x37, 0x61, 0x35, 0x62, 0x33, 0x30, 0x36, 0x34, 0x35, 0x66, 0x65, 0x30, 0x30, 0x65, 0x34, 0x34, 0x39, 0x30, 0x31, 0x34, 0x33, 0x35, 0x61, 0x63, 0x65, 0x32, 0x34, 0x63, 0x63, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x34, 0x64, 0x65, 0x63, 0x34, 0x64, 0x35, 0x65, 0x65, 0x38, 0x38, 0x61, 0x32, 0x37, 0x37, 0x31, 0x61, 0x38, 0x31, 0x35, 0x66, 0x31, 0x65, 0x65, 0x37, 0x32, 0x36, 0x34, 0x39, 0x34, 0x32, 0x66, 0x62, 0x35, 0x38, 0x62, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x65, 0x61, 0x63, 0x30, 0x33, 0x30, 0x35, 0x65, 0x64, 0x65, 0x33, 0x61, 0x39, 0x31, 0x35, 0x32, 0x39, 0x35, 0x65, 0x63, 0x38, 0x65, 0x36, 0x31, 0x63, 0x37, 0x66, 0x38, 0x38, 0x31, 0x30, 0x30, 0x36, 0x66, 0x34, 0x34, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x39, 0x31, 0x33, 0x39, 0x35, 0x37, 0x36, 0x31, 0x39, 0x34, 0x61, 0x30, 0x38, 0x36, 0x36, 0x31, 0x39, 0x35, 0x31, 0x35, 0x31, 0x66, 0x33, 0x33, 0x66, 0x32, 0x31, 0x34, 0x30, 0x61, 0x64, 0x31, 0x63, 0x63, 0x38, 0x36, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x61, 0x64, 0x31, 0x38, 0x30, 0x33, 0x65, 0x35, 0x65, 0x37, 0x33, 0x37, 0x61, 0x36, 0x38, 0x65, 0x31, 0x38, 0x34, 0x37, 0x32, 0x64, 0x39, 0x61, 0x63, 0x37, 0x31, 0x35, 0x66, 0x30, 0x39, 0x39, 0x34, 0x63, 0x63, 0x32, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x38, 0x61, 0x62, 0x39, 0x61, 0x32, 0x66, 0x33, 0x33, 0x33, 0x38, 0x31, 0x65, 0x30, 0x37, 0x63, 0x30, 0x63, 0x34, 0x37, 0x34, 0x33, 0x33, 0x64, 0x30, 0x64, 0x32, 0x31, 0x64, 0x36, 0x66, 0x33, 0x33, 0x36, 0x62, 0x31, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x65, 0x64, 0x63, 0x37, 0x33, 0x65, 0x36, 0x32, 0x36, 0x66, 0x35, 0x64, 0x33, 0x34, 0x34, 0x31, 0x61, 0x34, 0x35, 0x35, 0x33, 0x39, 0x62, 0x35, 0x66, 0x37, 0x61, 0x33, 0x39, 0x38, 0x63, 0x35, 0x39, 0x33, 0x65, 0x64, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x34, 0x66, 0x35, 0x66, 0x61, 0x32, 0x31, 0x31, 0x31, 0x64, 0x62, 0x36, 0x38, 0x66, 0x36, 0x62, 0x64, 0x65, 0x33, 0x35, 0x38, 0x39, 0x62, 0x36, 0x33, 0x30, 0x32, 0x39, 0x33, 0x39, 0x35, 0x62, 0x36, 0x39, 0x61, 0x39, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x39, 0x33, 0x63, 0x33, 0x63, 0x36, 0x64, 0x62, 0x39, 0x64, 0x33, 0x37, 0x37, 0x31, 0x37, 0x64, 0x65, 0x31, 0x36, 0x35, 0x63, 0x33, 0x61, 0x31, 0x62, 0x34, 0x66, 0x65, 0x35, 0x31, 0x39, 0x35, 0x32, 0x63, 0x30, 0x38, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x37, 0x62, 0x62, 0x30, 0x37, 0x62, 0x32, 0x38, 0x39, 0x64, 0x66, 0x37, 0x33, 0x30, 0x31, 0x65, 0x35, 0x34, 0x63, 0x30, 0x65, 0x66, 0x64, 0x61, 0x36, 0x61, 0x32, 0x63, 0x66, 0x32, 0x39, 0x31, 0x65, 0x38, 0x39, 0x32, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x61, 0x34, 0x35, 0x36, 0x30, 0x63, 0x38, 0x34, 0x62, 0x32, 0x30, 0x65, 0x30, 0x66, 0x62, 0x35, 0x34, 0x63, 0x34, 0x39, 0x36, 0x37, 0x30, 0x63, 0x32, 0x39, 0x30, 0x33, 0x62, 0x30, 0x61, 0x39, 0x36, 0x63, 0x34, 0x32, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x61, 0x35, 0x37, 0x39, 0x37, 0x66, 0x35, 0x32, 0x63, 0x39, 0x64, 0x35, 0x38, 0x66, 0x31, 0x38, 0x39, 0x66, 0x33, 0x36, 0x62, 0x31, 0x64, 0x34, 0x35, 0x64, 0x31, 0x62, 0x66, 0x36, 0x30, 0x34, 0x31, 0x66, 0x32, 0x66, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x35, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x61, 0x33, 0x33, 0x30, 0x32, 0x32, 0x34, 0x30, 0x61, 0x66, 0x30, 0x35, 0x31, 0x31, 0x63, 0x36, 0x66, 0x64, 0x31, 0x38, 0x35, 0x37, 0x65, 0x36, 0x64, 0x64, 0x62, 0x37, 0x33, 0x39, 0x34, 0x66, 0x37, 0x37, 0x61, 0x62, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x32, 0x64, 0x31, 0x35, 0x66, 0x66, 0x33, 0x39, 0x35, 0x36, 0x31, 0x63, 0x31, 0x62, 0x37, 0x32, 0x65, 0x64, 0x61, 0x31, 0x63, 0x63, 0x30, 0x32, 0x37, 0x66, 0x66, 0x65, 0x66, 0x32, 0x33, 0x37, 0x34, 0x33, 0x61, 0x31, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x34, 0x63, 0x32, 0x37, 0x31, 0x35, 0x37, 0x38, 0x30, 0x63, 0x61, 0x34, 0x65, 0x39, 0x39, 0x65, 0x36, 0x30, 0x65, 0x62, 0x66, 0x32, 0x31, 0x39, 0x66, 0x31, 0x35, 0x39, 0x30, 0x63, 0x38, 0x63, 0x61, 0x64, 0x35, 0x30, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x35, 0x65, 0x37, 0x65, 0x65, 0x37, 0x64, 0x35, 0x31, 0x31, 0x34, 0x38, 0x32, 0x31, 0x65, 0x31, 0x35, 0x39, 0x64, 0x63, 0x61, 0x35, 0x65, 0x38, 0x31, 0x66, 0x31, 0x38, 0x66, 0x31, 0x62, 0x66, 0x66, 0x66, 0x62, 0x66, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x36, 0x39, 0x63, 0x31, 0x63, 0x32, 0x31, 0x30, 0x65, 0x61, 0x65, 0x38, 0x34, 0x35, 0x65, 0x35, 0x36, 0x38, 0x34, 0x30, 0x34, 0x31, 0x32, 0x65, 0x31, 0x66, 0x36, 0x35, 0x39, 0x39, 0x33, 0x65, 0x61, 0x39, 0x30, 0x66, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x63, 0x34, 0x35, 0x66, 0x38, 0x34, 0x64, 0x62, 0x37, 0x33, 0x38, 0x32, 0x64, 0x64, 0x65, 0x35, 0x34, 0x63, 0x35, 0x66, 0x37, 0x64, 0x38, 0x39, 0x33, 0x38, 0x63, 0x34, 0x32, 0x66, 0x34, 0x66, 0x33, 0x61, 0x33, 0x62, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x33, 0x38, 0x33, 0x64, 0x34, 0x62, 0x36, 0x64, 0x31, 0x37, 0x62, 0x33, 0x66, 0x39, 0x63, 0x64, 0x34, 0x32, 0x36, 0x65, 0x31, 0x30, 0x66, 0x62, 0x39, 0x34, 0x34, 0x30, 0x31, 0x35, 0x63, 0x30, 0x64, 0x34, 0x34, 0x62, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x39, 0x30, 0x66, 0x65, 0x32, 0x33, 0x64, 0x63, 0x64, 0x38, 0x36, 0x62, 0x33, 0x35, 0x38, 0x63, 0x33, 0x32, 0x65, 0x34, 0x38, 0x64, 0x32, 0x61, 0x66, 0x39, 0x31, 0x30, 0x32, 0x34, 0x32, 0x35, 0x39, 0x66, 0x36, 0x35, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x66, 0x65, 0x64, 0x63, 0x63, 0x33, 0x36, 0x62, 0x37, 0x63, 0x63, 0x33, 0x31, 0x32, 0x61, 0x64, 0x32, 0x61, 0x39, 0x65, 0x64, 0x65, 0x34, 0x33, 0x31, 0x61, 0x35, 0x31, 0x34, 0x66, 0x63, 0x63, 0x62, 0x34, 0x39, 0x62, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x66, 0x65, 0x39, 0x33, 0x65, 0x63, 0x31, 0x61, 0x35, 0x36, 0x33, 0x36, 0x65, 0x39, 0x65, 0x65, 0x33, 0x34, 0x61, 0x66, 0x37, 0x30, 0x64, 0x66, 0x66, 0x35, 0x32, 0x36, 0x38, 0x32, 0x65, 0x36, 0x66, 0x66, 0x37, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x30, 0x31, 0x65, 0x34, 0x61, 0x64, 0x35, 0x36, 0x39, 0x63, 0x39, 0x35, 0x64, 0x30, 0x30, 0x37, 0x61, 0x64, 0x61, 0x33, 0x30, 0x64, 0x35, 0x65, 0x32, 0x64, 0x62, 0x31, 0x32, 0x38, 0x38, 0x38, 0x34, 0x39, 0x32, 0x32, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x64, 0x39, 0x32, 0x63, 0x36, 0x32, 0x62, 0x32, 0x38, 0x30, 0x65, 0x30, 0x30, 0x66, 0x36, 0x32, 0x36, 0x64, 0x38, 0x36, 0x35, 0x37, 0x66, 0x31, 0x62, 0x38, 0x36, 0x31, 0x36, 0x36, 0x63, 0x62, 0x31, 0x66, 0x37, 0x34, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x33, 0x36, 0x36, 0x38, 0x33, 0x30, 0x36, 0x33, 0x62, 0x37, 0x65, 0x39, 0x65, 0x62, 0x39, 0x39, 0x34, 0x36, 0x32, 0x64, 0x61, 0x62, 0x64, 0x35, 0x36, 0x39, 0x62, 0x64, 0x64, 0x63, 0x65, 0x37, 0x31, 0x36, 0x38, 0x36, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x34, 0x38, 0x65, 0x30, 0x61, 0x37, 0x30, 0x39, 0x38, 0x62, 0x30, 0x36, 0x61, 0x39, 0x30, 0x35, 0x38, 0x30, 0x32, 0x62, 0x38, 0x37, 0x35, 0x34, 0x35, 0x37, 0x33, 0x31, 0x31, 0x31, 0x38, 0x65, 0x38, 0x39, 0x66, 0x34, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x39, 0x65, 0x35, 0x36, 0x65, 0x39, 0x30, 0x32, 0x66, 0x34, 0x62, 0x65, 0x31, 0x66, 0x63, 0x38, 0x37, 0x36, 0x38, 0x64, 0x38, 0x30, 0x33, 0x38, 0x62, 0x61, 0x63, 0x36, 0x33, 0x65, 0x32, 0x61, 0x63, 0x62, 0x62, 0x66, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x36, 0x37, 0x66, 0x32, 0x61, 0x62, 0x38, 0x35, 0x39, 0x39, 0x66, 0x65, 0x66, 0x35, 0x66, 0x63, 0x34, 0x31, 0x33, 0x39, 0x39, 0x39, 0x61, 0x61, 0x30, 0x31, 0x66, 0x64, 0x37, 0x66, 0x63, 0x65, 0x37, 0x30, 0x62, 0x34, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x37, 0x34, 0x65, 0x30, 0x64, 0x31, 0x62, 0x37, 0x37, 0x65, 0x62, 0x63, 0x38, 0x32, 0x33, 0x61, 0x63, 0x61, 0x30, 0x33, 0x66, 0x31, 0x31, 0x39, 0x38, 0x35, 0x34, 0x63, 0x62, 0x31, 0x32, 0x30, 0x32, 0x37, 0x66, 0x36, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x35, 0x62, 0x31, 0x39, 0x61, 0x65, 0x31, 0x62, 0x65, 0x39, 0x34, 0x66, 0x66, 0x34, 0x64, 0x65, 0x65, 0x36, 0x33, 0x35, 0x34, 0x39, 0x32, 0x61, 0x31, 0x62, 0x30, 0x31, 0x32, 0x64, 0x31, 0x34, 0x64, 0x62, 0x30, 0x32, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x65, 0x39, 0x65, 0x37, 0x64, 0x35, 0x64, 0x31, 0x62, 0x36, 0x36, 0x37, 0x64, 0x30, 0x39, 0x35, 0x64, 0x64, 0x33, 0x34, 0x30, 0x39, 0x39, 0x63, 0x38, 0x35, 0x62, 0x30, 0x34, 0x32, 0x31, 0x61, 0x30, 0x62, 0x63, 0x36, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x36, 0x65, 0x62, 0x34, 0x65, 0x34, 0x37, 0x64, 0x66, 0x37, 0x31, 0x62, 0x34, 0x32, 0x65, 0x31, 0x36, 0x64, 0x36, 0x66, 0x65, 0x34, 0x36, 0x38, 0x32, 0x35, 0x62, 0x37, 0x33, 0x32, 0x37, 0x62, 0x61, 0x66, 0x33, 0x31, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x32, 0x63, 0x32, 0x39, 0x37, 0x66, 0x30, 0x61, 0x64, 0x31, 0x39, 0x34, 0x34, 0x38, 0x32, 0x65, 0x65, 0x38, 0x63, 0x33, 0x66, 0x30, 0x33, 0x36, 0x62, 0x64, 0x65, 0x62, 0x30, 0x31, 0x63, 0x32, 0x30, 0x31, 0x64, 0x35, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x30, 0x35, 0x32, 0x35, 0x31, 0x39, 0x37, 0x35, 0x36, 0x61, 0x66, 0x34, 0x32, 0x35, 0x39, 0x30, 0x66, 0x31, 0x35, 0x33, 0x39, 0x31, 0x62, 0x37, 0x32, 0x33, 0x61, 0x30, 0x33, 0x66, 0x61, 0x35, 0x36, 0x34, 0x61, 0x39, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x31, 0x35, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x36, 0x38, 0x34, 0x36, 0x61, 0x31, 0x61, 0x61, 0x39, 0x39, 0x39, 0x61, 0x32, 0x32, 0x34, 0x36, 0x61, 0x32, 0x38, 0x37, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x62, 0x61, 0x34, 0x64, 0x63, 0x62, 0x61, 0x38, 0x65, 0x36, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x35, 0x62, 0x30, 0x30, 0x35, 0x66, 0x65, 0x38, 0x64, 0x61, 0x61, 0x65, 0x38, 0x64, 0x31, 0x66, 0x30, 0x35, 0x64, 0x65, 0x33, 0x65, 0x64, 0x61, 0x30, 0x34, 0x32, 0x30, 0x36, 0x36, 0x63, 0x36, 0x63, 0x34, 0x36, 0x39, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x34, 0x63, 0x31, 0x65, 0x63, 0x63, 0x36, 0x33, 0x30, 0x63, 0x32, 0x38, 0x37, 0x37, 0x64, 0x65, 0x38, 0x30, 0x39, 0x35, 0x66, 0x30, 0x61, 0x38, 0x64, 0x62, 0x61, 0x31, 0x65, 0x38, 0x62, 0x66, 0x31, 0x66, 0x35, 0x35, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x66, 0x32, 0x32, 0x36, 0x31, 0x34, 0x32, 0x61, 0x34, 0x32, 0x38, 0x34, 0x33, 0x34, 0x61, 0x62, 0x31, 0x37, 0x61, 0x31, 0x38, 0x36, 0x34, 0x61, 0x32, 0x35, 0x39, 0x37, 0x66, 0x36, 0x34, 0x61, 0x61, 0x62, 0x32, 0x66, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x34, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x63, 0x39, 0x31, 0x30, 0x63, 0x65, 0x34, 0x64, 0x34, 0x39, 0x34, 0x61, 0x39, 0x31, 0x39, 0x63, 0x63, 0x64, 0x61, 0x61, 0x61, 0x31, 0x66, 0x63, 0x33, 0x62, 0x38, 0x32, 0x61, 0x61, 0x37, 0x34, 0x62, 0x61, 0x30, 0x36, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x38, 0x37, 0x62, 0x31, 0x36, 0x61, 0x62, 0x63, 0x38, 0x61, 0x37, 0x34, 0x30, 0x38, 0x31, 0x65, 0x33, 0x36, 0x31, 0x33, 0x65, 0x31, 0x34, 0x33, 0x34, 0x32, 0x63, 0x30, 0x33, 0x33, 0x37, 0x35, 0x62, 0x66, 0x30, 0x38, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x31, 0x37, 0x36, 0x30, 0x36, 0x35, 0x65, 0x38, 0x38, 0x65, 0x33, 0x63, 0x36, 0x66, 0x65, 0x36, 0x32, 0x36, 0x32, 0x36, 0x37, 0x64, 0x31, 0x38, 0x61, 0x30, 0x38, 0x38, 0x61, 0x61, 0x61, 0x34, 0x64, 0x62, 0x38, 0x30, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x64, 0x63, 0x62, 0x63, 0x32, 0x37, 0x62, 0x63, 0x61, 0x64, 0x39, 0x38, 0x34, 0x30, 0x39, 0x33, 0x61, 0x32, 0x31, 0x32, 0x61, 0x39, 0x62, 0x34, 0x31, 0x37, 0x38, 0x65, 0x61, 0x62, 0x65, 0x39, 0x30, 0x31, 0x37, 0x35, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x39, 0x35, 0x33, 0x63, 0x36, 0x65, 0x39, 0x37, 0x35, 0x38, 0x31, 0x34, 0x63, 0x35, 0x37, 0x31, 0x33, 0x31, 0x31, 0x63, 0x33, 0x34, 0x63, 0x30, 0x66, 0x36, 0x61, 0x39, 0x39, 0x63, 0x64, 0x66, 0x34, 0x38, 0x61, 0x62, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x30, 0x61, 0x32, 0x66, 0x33, 0x38, 0x35, 0x66, 0x30, 0x39, 0x64, 0x62, 0x66, 0x63, 0x65, 0x39, 0x36, 0x37, 0x33, 0x32, 0x65, 0x31, 0x32, 0x62, 0x62, 0x34, 0x30, 0x61, 0x63, 0x33, 0x34, 0x39, 0x38, 0x37, 0x31, 0x62, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x31, 0x32, 0x35, 0x34, 0x30, 0x32, 0x36, 0x35, 0x63, 0x62, 0x65, 0x65, 0x63, 0x33, 0x38, 0x34, 0x37, 0x30, 0x32, 0x32, 0x63, 0x35, 0x39, 0x66, 0x31, 0x62, 0x33, 0x31, 0x38, 0x64, 0x34, 0x33, 0x34, 0x30, 0x30, 0x61, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x62, 0x64, 0x63, 0x34, 0x66, 0x32, 0x38, 0x64, 0x65, 0x30, 0x31, 0x38, 0x30, 0x66, 0x34, 0x33, 0x33, 0x63, 0x32, 0x36, 0x39, 0x34, 0x65, 0x62, 0x37, 0x34, 0x66, 0x35, 0x35, 0x30, 0x34, 0x63, 0x65, 0x39, 0x34, 0x33, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x36, 0x36, 0x62, 0x66, 0x62, 0x66, 0x32, 0x32, 0x36, 0x32, 0x65, 0x66, 0x63, 0x63, 0x38, 0x64, 0x32, 0x62, 0x64, 0x30, 0x34, 0x34, 0x34, 0x66, 0x63, 0x35, 0x62, 0x30, 0x36, 0x39, 0x36, 0x32, 0x39, 0x38, 0x66, 0x66, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x36, 0x34, 0x31, 0x31, 0x66, 0x64, 0x37, 0x39, 0x30, 0x30, 0x33, 0x34, 0x38, 0x30, 0x66, 0x36, 0x66, 0x32, 0x62, 0x36, 0x61, 0x61, 0x63, 0x32, 0x36, 0x62, 0x37, 0x62, 0x61, 0x37, 0x39, 0x32, 0x66, 0x30, 0x39, 0x34, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x65, 0x61, 0x36, 0x36, 0x39, 0x65, 0x33, 0x35, 0x36, 0x34, 0x38, 0x31, 0x39, 0x61, 0x38, 0x33, 0x62, 0x30, 0x63, 0x32, 0x36, 0x63, 0x30, 0x30, 0x61, 0x31, 0x36, 0x64, 0x39, 0x65, 0x38, 0x32, 0x36, 0x66, 0x36, 0x63, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x66, 0x66, 0x62, 0x30, 0x32, 0x63, 0x62, 0x37, 0x64, 0x39, 0x65, 0x61, 0x35, 0x32, 0x34, 0x33, 0x37, 0x30, 0x31, 0x36, 0x38, 0x39, 0x61, 0x66, 0x64, 0x35, 0x64, 0x34, 0x31, 0x37, 0x64, 0x37, 0x65, 0x64, 0x32, 0x65, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x65, 0x37, 0x64, 0x62, 0x61, 0x38, 0x66, 0x64, 0x34, 0x66, 0x31, 0x66, 0x38, 0x35, 0x30, 0x64, 0x62, 0x63, 0x32, 0x36, 0x34, 0x39, 0x64, 0x38, 0x65, 0x38, 0x34, 0x66, 0x30, 0x39, 0x35, 0x32, 0x65, 0x33, 0x65, 0x62, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x34, 0x34, 0x63, 0x63, 0x32, 0x38, 0x31, 0x62, 0x65, 0x33, 0x33, 0x32, 0x63, 0x63, 0x63, 0x65, 0x64, 0x33, 0x36, 0x64, 0x61, 0x34, 0x38, 0x33, 0x66, 0x62, 0x32, 0x61, 0x30, 0x37, 0x34, 0x36, 0x64, 0x39, 0x62, 0x61, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x61, 0x39, 0x31, 0x64, 0x61, 0x36, 0x63, 0x66, 0x31, 0x62, 0x39, 0x64, 0x36, 0x35, 0x63, 0x37, 0x34, 0x61, 0x30, 0x32, 0x65, 0x63, 0x31, 0x66, 0x39, 0x36, 0x65, 0x65, 0x63, 0x62, 0x36, 0x64, 0x64, 0x32, 0x34, 0x31, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x33, 0x31, 0x64, 0x63, 0x34, 0x30, 0x64, 0x37, 0x34, 0x65, 0x35, 0x30, 0x39, 0x35, 0x65, 0x33, 0x37, 0x32, 0x39, 0x65, 0x64, 0x64, 0x66, 0x34, 0x39, 0x35, 0x34, 0x34, 0x65, 0x63, 0x64, 0x34, 0x33, 0x39, 0x36, 0x66, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x63, 0x38, 0x39, 0x37, 0x61, 0x38, 0x34, 0x62, 0x36, 0x39, 0x35, 0x65, 0x65, 0x62, 0x65, 0x34, 0x36, 0x36, 0x37, 0x39, 0x66, 0x37, 0x64, 0x61, 0x31, 0x39, 0x64, 0x37, 0x37, 0x36, 0x36, 0x32, 0x31, 0x63, 0x32, 0x36, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x37, 0x33, 0x34, 0x36, 0x30, 0x62, 0x35, 0x39, 0x64, 0x38, 0x65, 0x38, 0x35, 0x30, 0x34, 0x35, 0x64, 0x35, 0x65, 0x37, 0x35, 0x32, 0x65, 0x36, 0x32, 0x35, 0x35, 0x39, 0x38, 0x37, 0x35, 0x65, 0x34, 0x32, 0x35, 0x30, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x64, 0x34, 0x65, 0x36, 0x37, 0x34, 0x62, 0x62, 0x61, 0x64, 0x62, 0x31, 0x62, 0x30, 0x64, 0x63, 0x38, 0x32, 0x34, 0x34, 0x39, 0x38, 0x37, 0x31, 0x33, 0x64, 0x63, 0x65, 0x33, 0x62, 0x35, 0x31, 0x35, 0x36, 0x64, 0x61, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x39, 0x33, 0x33, 0x64, 0x36, 0x31, 0x62, 0x37, 0x37, 0x64, 0x63, 0x64, 0x63, 0x37, 0x31, 0x36, 0x34, 0x30, 0x37, 0x66, 0x38, 0x32, 0x35, 0x30, 0x62, 0x63, 0x39, 0x31, 0x65, 0x34, 0x66, 0x66, 0x61, 0x65, 0x62, 0x30, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x63, 0x39, 0x30, 0x37, 0x35, 0x34, 0x64, 0x32, 0x66, 0x32, 0x30, 0x61, 0x31, 0x63, 0x62, 0x31, 0x64, 0x64, 0x33, 0x33, 0x30, 0x36, 0x32, 0x35, 0x65, 0x30, 0x34, 0x62, 0x34, 0x35, 0x66, 0x61, 0x36, 0x31, 0x39, 0x64, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x35, 0x65, 0x63, 0x35, 0x35, 0x34, 0x35, 0x36, 0x34, 0x34, 0x65, 0x30, 0x62, 0x37, 0x38, 0x33, 0x33, 0x30, 0x66, 0x66, 0x66, 0x61, 0x62, 0x38, 0x64, 0x64, 0x65, 0x61, 0x63, 0x39, 0x65, 0x38, 0x33, 0x33, 0x31, 0x35, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x31, 0x65, 0x32, 0x39, 0x37, 0x32, 0x31, 0x64, 0x36, 0x63, 0x62, 0x39, 0x31, 0x30, 0x35, 0x37, 0x66, 0x36, 0x63, 0x34, 0x30, 0x34, 0x32, 0x64, 0x38, 0x61, 0x30, 0x62, 0x62, 0x63, 0x36, 0x34, 0x34, 0x61, 0x66, 0x65, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x62, 0x39, 0x30, 0x61, 0x34, 0x64, 0x63, 0x30, 0x39, 0x37, 0x32, 0x33, 0x39, 0x34, 0x39, 0x32, 0x63, 0x35, 0x62, 0x39, 0x37, 0x37, 0x37, 0x64, 0x63, 0x64, 0x31, 0x65, 0x35, 0x32, 0x62, 0x61, 0x32, 0x62, 0x65, 0x32, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x32, 0x34, 0x31, 0x61, 0x37, 0x38, 0x34, 0x34, 0x32, 0x39, 0x30, 0x65, 0x30, 0x61, 0x62, 0x38, 0x35, 0x35, 0x66, 0x31, 0x64, 0x34, 0x61, 0x61, 0x37, 0x35, 0x62, 0x35, 0x35, 0x33, 0x34, 0x35, 0x30, 0x33, 0x32, 0x32, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x64, 0x34, 0x65, 0x30, 0x66, 0x33, 0x66, 0x33, 0x32, 0x62, 0x65, 0x65, 0x36, 0x64, 0x33, 0x37, 0x36, 0x37, 0x66, 0x64, 0x62, 0x63, 0x39, 0x64, 0x33, 0x35, 0x33, 0x61, 0x36, 0x64, 0x33, 0x61, 0x61, 0x62, 0x37, 0x38, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x30, 0x33, 0x35, 0x35, 0x39, 0x34, 0x63, 0x37, 0x34, 0x37, 0x34, 0x37, 0x36, 0x64, 0x34, 0x32, 0x64, 0x31, 0x65, 0x65, 0x39, 0x36, 0x36, 0x63, 0x33, 0x36, 0x32, 0x32, 0x34, 0x63, 0x64, 0x64, 0x32, 0x32, 0x34, 0x39, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x35, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x39, 0x37, 0x66, 0x34, 0x33, 0x33, 0x30, 0x37, 0x30, 0x30, 0x62, 0x34, 0x38, 0x63, 0x34, 0x39, 0x36, 0x64, 0x34, 0x33, 0x37, 0x63, 0x39, 0x31, 0x63, 0x61, 0x31, 0x64, 0x65, 0x39, 0x63, 0x34, 0x62, 0x30, 0x31, 0x62, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x36, 0x61, 0x64, 0x33, 0x63, 0x33, 0x33, 0x61, 0x39, 0x62, 0x39, 0x61, 0x30, 0x61, 0x31, 0x38, 0x39, 0x36, 0x37, 0x33, 0x35, 0x37, 0x39, 0x36, 0x39, 0x62, 0x39, 0x34, 0x65, 0x65, 0x37, 0x64, 0x32, 0x61, 0x62, 0x63, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x62, 0x65, 0x30, 0x35, 0x65, 0x38, 0x38, 0x63, 0x39, 0x63, 0x62, 0x62, 0x63, 0x63, 0x30, 0x65, 0x39, 0x32, 0x61, 0x34, 0x30, 0x35, 0x66, 0x61, 0x63, 0x31, 0x64, 0x38, 0x35, 0x64, 0x65, 0x32, 0x34, 0x38, 0x65, 0x65, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x63, 0x34, 0x65, 0x36, 0x66, 0x37, 0x66, 0x38, 0x62, 0x30, 0x31, 0x31, 0x34, 0x31, 0x34, 0x62, 0x66, 0x62, 0x61, 0x34, 0x32, 0x66, 0x32, 0x33, 0x61, 0x64, 0x66, 0x61, 0x61, 0x37, 0x38, 0x64, 0x34, 0x65, 0x63, 0x63, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x33, 0x31, 0x61, 0x63, 0x32, 0x36, 0x36, 0x38, 0x62, 0x61, 0x36, 0x61, 0x38, 0x34, 0x34, 0x38, 0x31, 0x61, 0x62, 0x31, 0x33, 0x39, 0x37, 0x33, 0x35, 0x61, 0x65, 0x63, 0x31, 0x34, 0x62, 0x37, 0x62, 0x66, 0x62, 0x61, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x32, 0x36, 0x33, 0x63, 0x65, 0x38, 0x61, 0x66, 0x36, 0x64, 0x62, 0x33, 0x65, 0x34, 0x36, 0x37, 0x35, 0x38, 0x34, 0x35, 0x30, 0x32, 0x65, 0x64, 0x37, 0x31, 0x30, 0x39, 0x31, 0x32, 0x35, 0x65, 0x61, 0x65, 0x32, 0x32, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x38, 0x32, 0x35, 0x38, 0x63, 0x31, 0x32, 0x34, 0x38, 0x31, 0x62, 0x63, 0x64, 0x64, 0x64, 0x62, 0x62, 0x37, 0x32, 0x61, 0x38, 0x63, 0x61, 0x30, 0x63, 0x30, 0x34, 0x33, 0x30, 0x39, 0x37, 0x32, 0x36, 0x31, 0x63, 0x36, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x39, 0x33, 0x31, 0x32, 0x33, 0x63, 0x30, 0x32, 0x31, 0x65, 0x63, 0x65, 0x33, 0x62, 0x33, 0x33, 0x62, 0x31, 0x61, 0x34, 0x35, 0x32, 0x63, 0x39, 0x32, 0x36, 0x38, 0x64, 0x65, 0x31, 0x34, 0x30, 0x30, 0x37, 0x66, 0x39, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x31, 0x66, 0x32, 0x63, 0x31, 0x39, 0x65, 0x33, 0x31, 0x36, 0x62, 0x30, 0x34, 0x34, 0x61, 0x34, 0x62, 0x33, 0x65, 0x36, 0x31, 0x61, 0x30, 0x63, 0x36, 0x66, 0x66, 0x38, 0x63, 0x31, 0x30, 0x34, 0x61, 0x31, 0x61, 0x31, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x33, 0x65, 0x37, 0x38, 0x37, 0x34, 0x31, 0x34, 0x62, 0x39, 0x30, 0x34, 0x38, 0x34, 0x37, 0x38, 0x61, 0x35, 0x30, 0x37, 0x33, 0x33, 0x33, 0x35, 0x39, 0x65, 0x63, 0x64, 0x64, 0x37, 0x65, 0x33, 0x36, 0x34, 0x37, 0x61, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x37, 0x31, 0x35, 0x39, 0x35, 0x36, 0x66, 0x35, 0x32, 0x66, 0x31, 0x35, 0x33, 0x30, 0x36, 0x65, 0x65, 0x39, 0x35, 0x30, 0x36, 0x62, 0x66, 0x38, 0x32, 0x62, 0x63, 0x63, 0x63, 0x34, 0x30, 0x36, 0x62, 0x33, 0x38, 0x39, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x66, 0x39, 0x31, 0x65, 0x37, 0x61, 0x63, 0x62, 0x35, 0x62, 0x38, 0x31, 0x32, 0x39, 0x61, 0x33, 0x30, 0x36, 0x38, 0x37, 0x37, 0x63, 0x65, 0x33, 0x31, 0x36, 0x38, 0x65, 0x36, 0x66, 0x34, 0x33, 0x38, 0x62, 0x36, 0x36, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x64, 0x62, 0x62, 0x64, 0x34, 0x65, 0x32, 0x36, 0x30, 0x34, 0x65, 0x34, 0x30, 0x65, 0x31, 0x37, 0x31, 0x30, 0x63, 0x63, 0x36, 0x37, 0x33, 0x30, 0x32, 0x38, 0x39, 0x64, 0x63, 0x63, 0x66, 0x61, 0x64, 0x33, 0x38, 0x39, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x35, 0x66, 0x34, 0x62, 0x33, 0x66, 0x31, 0x65, 0x31, 0x31, 0x37, 0x30, 0x37, 0x61, 0x32, 0x32, 0x37, 0x61, 0x61, 0x35, 0x65, 0x36, 0x39, 0x66, 0x61, 0x34, 0x39, 0x64, 0x64, 0x65, 0x64, 0x33, 0x33, 0x66, 0x62, 0x33, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x34, 0x38, 0x38, 0x61, 0x64, 0x33, 0x64, 0x61, 0x36, 0x30, 0x33, 0x63, 0x34, 0x63, 0x64, 0x64, 0x36, 0x63, 0x62, 0x30, 0x62, 0x37, 0x61, 0x31, 0x65, 0x33, 0x30, 0x64, 0x32, 0x61, 0x33, 0x30, 0x63, 0x38, 0x66, 0x63, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x31, 0x31, 0x34, 0x35, 0x62, 0x34, 0x34, 0x38, 0x34, 0x30, 0x63, 0x39, 0x34, 0x36, 0x65, 0x32, 0x31, 0x64, 0x62, 0x63, 0x31, 0x39, 0x30, 0x32, 0x36, 0x34, 0x62, 0x38, 0x65, 0x30, 0x64, 0x35, 0x30, 0x32, 0x39, 0x33, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x30, 0x35, 0x30, 0x37, 0x30, 0x63, 0x32, 0x63, 0x33, 0x34, 0x32, 0x31, 0x39, 0x33, 0x31, 0x31, 0x63, 0x34, 0x35, 0x34, 0x38, 0x62, 0x32, 0x36, 0x31, 0x34, 0x61, 0x34, 0x33, 0x38, 0x38, 0x31, 0x30, 0x64, 0x65, 0x64, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x66, 0x33, 0x38, 0x37, 0x65, 0x31, 0x61, 0x34, 0x65, 0x64, 0x34, 0x61, 0x37, 0x33, 0x31, 0x30, 0x36, 0x65, 0x66, 0x32, 0x62, 0x34, 0x36, 0x32, 0x65, 0x34, 0x37, 0x34, 0x65, 0x32, 0x65, 0x33, 0x31, 0x34, 0x33, 0x61, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x31, 0x36, 0x62, 0x30, 0x62, 0x34, 0x36, 0x38, 0x30, 0x66, 0x35, 0x33, 0x61, 0x62, 0x37, 0x32, 0x63, 0x39, 0x36, 0x38, 0x62, 0x61, 0x38, 0x30, 0x32, 0x65, 0x31, 0x30, 0x61, 0x61, 0x31, 0x62, 0x65, 0x31, 0x31, 0x64, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x61, 0x30, 0x61, 0x66, 0x63, 0x39, 0x33, 0x61, 0x61, 0x65, 0x32, 0x31, 0x30, 0x38, 0x61, 0x33, 0x66, 0x61, 0x63, 0x30, 0x35, 0x39, 0x36, 0x32, 0x33, 0x62, 0x66, 0x38, 0x36, 0x66, 0x61, 0x35, 0x38, 0x32, 0x61, 0x37, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x39, 0x39, 0x37, 0x39, 0x39, 0x32, 0x30, 0x33, 0x36, 0x63, 0x35, 0x62, 0x34, 0x33, 0x33, 0x61, 0x63, 0x33, 0x33, 0x64, 0x32, 0x35, 0x61, 0x38, 0x65, 0x61, 0x31, 0x64, 0x63, 0x33, 0x64, 0x34, 0x65, 0x34, 0x65, 0x36, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x37, 0x65, 0x30, 0x62, 0x38, 0x33, 0x65, 0x64, 0x39, 0x61, 0x34, 0x32, 0x34, 0x63, 0x36, 0x64, 0x31, 0x65, 0x36, 0x61, 0x36, 0x66, 0x38, 0x37, 0x61, 0x34, 0x64, 0x62, 0x66, 0x30, 0x36, 0x34, 0x30, 0x39, 0x63, 0x37, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x31, 0x66, 0x62, 0x31, 0x33, 0x30, 0x66, 0x30, 0x31, 0x35, 0x30, 0x63, 0x35, 0x36, 0x35, 0x32, 0x36, 0x39, 0x65, 0x30, 0x30, 0x65, 0x66, 0x62, 0x34, 0x33, 0x39, 0x30, 0x32, 0x62, 0x35, 0x32, 0x61, 0x34, 0x35, 0x35, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x62, 0x30, 0x31, 0x38, 0x39, 0x33, 0x32, 0x62, 0x63, 0x61, 0x64, 0x33, 0x35, 0x35, 0x62, 0x36, 0x37, 0x39, 0x32, 0x62, 0x32, 0x35, 0x35, 0x64, 0x62, 0x36, 0x37, 0x30, 0x32, 0x64, 0x65, 0x63, 0x38, 0x63, 0x65, 0x35, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x39, 0x30, 0x34, 0x65, 0x39, 0x33, 0x34, 0x62, 0x64, 0x30, 0x63, 0x63, 0x38, 0x62, 0x32, 0x30, 0x37, 0x30, 0x35, 0x66, 0x38, 0x37, 0x39, 0x65, 0x39, 0x30, 0x35, 0x62, 0x39, 0x33, 0x65, 0x61, 0x30, 0x63, 0x63, 0x63, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x32, 0x65, 0x63, 0x34, 0x32, 0x66, 0x61, 0x61, 0x38, 0x63, 0x64, 0x36, 0x39, 0x61, 0x61, 0x61, 0x37, 0x31, 0x62, 0x33, 0x32, 0x63, 0x63, 0x37, 0x62, 0x34, 0x30, 0x34, 0x38, 0x38, 0x31, 0x64, 0x35, 0x32, 0x66, 0x66, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x62, 0x63, 0x32, 0x64, 0x31, 0x39, 0x65, 0x30, 0x36, 0x63, 0x33, 0x62, 0x61, 0x62, 0x62, 0x62, 0x35, 0x62, 0x36, 0x66, 0x30, 0x35, 0x32, 0x62, 0x36, 0x62, 0x66, 0x37, 0x66, 0x63, 0x33, 0x37, 0x65, 0x30, 0x37, 0x32, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x61, 0x38, 0x37, 0x34, 0x33, 0x33, 0x34, 0x31, 0x35, 0x33, 0x33, 0x63, 0x62, 0x32, 0x66, 0x30, 0x62, 0x39, 0x63, 0x36, 0x65, 0x66, 0x62, 0x38, 0x66, 0x64, 0x61, 0x38, 0x30, 0x64, 0x37, 0x37, 0x31, 0x36, 0x32, 0x38, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x36, 0x38, 0x62, 0x37, 0x64, 0x65, 0x37, 0x35, 0x35, 0x36, 0x32, 0x38, 0x61, 0x66, 0x33, 0x35, 0x39, 0x61, 0x38, 0x34, 0x35, 0x34, 0x33, 0x64, 0x65, 0x32, 0x33, 0x35, 0x30, 0x34, 0x65, 0x31, 0x35, 0x65, 0x34, 0x31, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x63, 0x39, 0x36, 0x64, 0x31, 0x33, 0x62, 0x64, 0x62, 0x32, 0x34, 0x64, 0x63, 0x37, 0x61, 0x35, 0x35, 0x37, 0x32, 0x39, 0x33, 0x66, 0x30, 0x32, 0x39, 0x65, 0x30, 0x32, 0x64, 0x64, 0x37, 0x34, 0x62, 0x39, 0x37, 0x61, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x35, 0x63, 0x39, 0x30, 0x66, 0x66, 0x62, 0x65, 0x35, 0x34, 0x38, 0x34, 0x38, 0x36, 0x34, 0x37, 0x38, 0x30, 0x62, 0x38, 0x36, 0x37, 0x34, 0x39, 0x34, 0x61, 0x38, 0x33, 0x63, 0x38, 0x39, 0x32, 0x35, 0x36, 0x64, 0x36, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x65, 0x36, 0x66, 0x38, 0x31, 0x36, 0x33, 0x62, 0x66, 0x37, 0x63, 0x37, 0x62, 0x62, 0x34, 0x61, 0x62, 0x65, 0x38, 0x65, 0x39, 0x38, 0x39, 0x33, 0x62, 0x64, 0x30, 0x63, 0x63, 0x31, 0x31, 0x32, 0x66, 0x65, 0x38, 0x38, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x30, 0x65, 0x62, 0x37, 0x63, 0x36, 0x36, 0x66, 0x38, 0x36, 0x39, 0x64, 0x64, 0x66, 0x34, 0x39, 0x64, 0x61, 0x38, 0x35, 0x66, 0x33, 0x33, 0x39, 0x33, 0x65, 0x39, 0x38, 0x30, 0x63, 0x30, 0x32, 0x39, 0x61, 0x61, 0x34, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x35, 0x63, 0x31, 0x39, 0x31, 0x33, 0x32, 0x63, 0x61, 0x63, 0x31, 0x39, 0x33, 0x35, 0x35, 0x37, 0x36, 0x61, 0x62, 0x66, 0x65, 0x64, 0x36, 0x63, 0x30, 0x34, 0x39, 0x35, 0x66, 0x62, 0x30, 0x37, 0x38, 0x38, 0x31, 0x62, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x35, 0x35, 0x30, 0x63, 0x61, 0x61, 0x66, 0x37, 0x34, 0x33, 0x62, 0x30, 0x33, 0x37, 0x63, 0x35, 0x36, 0x66, 0x64, 0x32, 0x35, 0x35, 0x38, 0x61, 0x31, 0x63, 0x38, 0x65, 0x64, 0x32, 0x33, 0x35, 0x31, 0x33, 0x30, 0x37, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x37, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x30, 0x39, 0x37, 0x39, 0x32, 0x33, 0x62, 0x61, 0x31, 0x35, 0x35, 0x65, 0x31, 0x36, 0x64, 0x38, 0x32, 0x66, 0x33, 0x61, 0x64, 0x33, 0x66, 0x36, 0x62, 0x38, 0x31, 0x35, 0x35, 0x34, 0x30, 0x38, 0x38, 0x34, 0x62, 0x39, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x64, 0x39, 0x65, 0x33, 0x30, 0x66, 0x30, 0x38, 0x34, 0x32, 0x30, 0x31, 0x32, 0x61, 0x37, 0x31, 0x37, 0x36, 0x61, 0x39, 0x31, 0x37, 0x64, 0x39, 0x64, 0x32, 0x30, 0x34, 0x38, 0x63, 0x61, 0x30, 0x37, 0x33, 0x38, 0x37, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x39, 0x61, 0x64, 0x33, 0x36, 0x65, 0x35, 0x63, 0x37, 0x34, 0x63, 0x65, 0x32, 0x65, 0x39, 0x36, 0x33, 0x39, 0x39, 0x66, 0x35, 0x37, 0x38, 0x33, 0x39, 0x34, 0x33, 0x31, 0x64, 0x30, 0x65, 0x37, 0x39, 0x66, 0x39, 0x36, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x62, 0x65, 0x38, 0x66, 0x66, 0x36, 0x35, 0x65, 0x35, 0x37, 0x38, 0x38, 0x61, 0x65, 0x63, 0x36, 0x62, 0x32, 0x61, 0x35, 0x32, 0x64, 0x35, 0x66, 0x61, 0x37, 0x62, 0x31, 0x65, 0x37, 0x61, 0x30, 0x33, 0x62, 0x61, 0x36, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x36, 0x64, 0x34, 0x37, 0x33, 0x37, 0x64, 0x37, 0x61, 0x39, 0x34, 0x30, 0x33, 0x38, 0x32, 0x34, 0x38, 0x37, 0x32, 0x36, 0x34, 0x38, 0x38, 0x36, 0x36, 0x39, 0x37, 0x63, 0x66, 0x37, 0x36, 0x33, 0x37, 0x66, 0x38, 0x30, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x37, 0x62, 0x33, 0x62, 0x62, 0x61, 0x63, 0x31, 0x36, 0x64, 0x61, 0x62, 0x38, 0x33, 0x31, 0x61, 0x34, 0x61, 0x30, 0x66, 0x63, 0x35, 0x33, 0x62, 0x30, 0x63, 0x35, 0x34, 0x39, 0x64, 0x63, 0x33, 0x36, 0x63, 0x33, 0x31, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x34, 0x33, 0x65, 0x65, 0x30, 0x38, 0x36, 0x33, 0x63, 0x65, 0x39, 0x33, 0x33, 0x65, 0x32, 0x32, 0x66, 0x38, 0x39, 0x63, 0x38, 0x30, 0x32, 0x64, 0x33, 0x31, 0x32, 0x38, 0x37, 0x62, 0x39, 0x36, 0x37, 0x31, 0x65, 0x38, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x31, 0x66, 0x33, 0x62, 0x61, 0x39, 0x65, 0x64, 0x39, 0x35, 0x36, 0x62, 0x37, 0x37, 0x30, 0x66, 0x32, 0x35, 0x37, 0x64, 0x33, 0x36, 0x37, 0x32, 0x66, 0x65, 0x31, 0x66, 0x66, 0x39, 0x66, 0x37, 0x62, 0x30, 0x32, 0x34, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x30, 0x61, 0x65, 0x39, 0x66, 0x30, 0x34, 0x33, 0x63, 0x38, 0x33, 0x34, 0x64, 0x34, 0x34, 0x32, 0x37, 0x31, 0x66, 0x31, 0x33, 0x34, 0x30, 0x36, 0x35, 0x39, 0x33, 0x64, 0x66, 0x65, 0x30, 0x39, 0x34, 0x66, 0x33, 0x38, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x31, 0x37, 0x35, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x33, 0x34, 0x37, 0x34, 0x35, 0x65, 0x64, 0x65, 0x38, 0x35, 0x37, 0x36, 0x62, 0x34, 0x39, 0x39, 0x64, 0x62, 0x30, 0x31, 0x62, 0x65, 0x62, 0x37, 0x63, 0x31, 0x65, 0x63, 0x64, 0x61, 0x38, 0x35, 0x63, 0x66, 0x34, 0x61, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x65, 0x38, 0x63, 0x63, 0x62, 0x34, 0x66, 0x31, 0x31, 0x62, 0x36, 0x36, 0x63, 0x61, 0x36, 0x65, 0x31, 0x64, 0x35, 0x37, 0x63, 0x30, 0x62, 0x35, 0x33, 0x39, 0x36, 0x32, 0x32, 0x31, 0x61, 0x33, 0x31, 0x62, 0x61, 0x35, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x38, 0x62, 0x39, 0x30, 0x38, 0x66, 0x65, 0x37, 0x34, 0x33, 0x61, 0x34, 0x33, 0x34, 0x32, 0x30, 0x33, 0x64, 0x65, 0x32, 0x39, 0x34, 0x63, 0x34, 0x34, 0x31, 0x63, 0x37, 0x65, 0x32, 0x30, 0x61, 0x38, 0x36, 0x65, 0x61, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x33, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x32, 0x33, 0x36, 0x62, 0x66, 0x36, 0x61, 0x62, 0x66, 0x34, 0x66, 0x33, 0x32, 0x39, 0x33, 0x37, 0x39, 0x35, 0x62, 0x66, 0x30, 0x63, 0x32, 0x38, 0x37, 0x31, 0x38, 0x66, 0x39, 0x33, 0x65, 0x33, 0x62, 0x31, 0x62, 0x33, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x32, 0x35, 0x34, 0x65, 0x61, 0x31, 0x32, 0x36, 0x62, 0x35, 0x32, 0x64, 0x30, 0x31, 0x34, 0x32, 0x64, 0x61, 0x30, 0x61, 0x37, 0x65, 0x31, 0x38, 0x38, 0x63, 0x65, 0x32, 0x35, 0x35, 0x64, 0x38, 0x63, 0x34, 0x37, 0x31, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x65, 0x64, 0x34, 0x37, 0x63, 0x61, 0x35, 0x62, 0x38, 0x39, 0x39, 0x66, 0x64, 0x31, 0x36, 0x32, 0x33, 0x66, 0x32, 0x31, 0x65, 0x39, 0x62, 0x64, 0x34, 0x64, 0x62, 0x36, 0x35, 0x61, 0x31, 0x30, 0x65, 0x35, 0x62, 0x30, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x61, 0x63, 0x64, 0x38, 0x35, 0x38, 0x38, 0x37, 0x35, 0x66, 0x61, 0x32, 0x34, 0x65, 0x65, 0x66, 0x30, 0x64, 0x35, 0x37, 0x32, 0x66, 0x63, 0x37, 0x64, 0x36, 0x32, 0x61, 0x61, 0x64, 0x30, 0x65, 0x62, 0x64, 0x64, 0x63, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x61, 0x32, 0x38, 0x31, 0x64, 0x66, 0x66, 0x36, 0x34, 0x31, 0x36, 0x37, 0x31, 0x39, 0x37, 0x38, 0x35, 0x35, 0x62, 0x66, 0x36, 0x65, 0x37, 0x30, 0x35, 0x65, 0x62, 0x39, 0x66, 0x32, 0x63, 0x65, 0x66, 0x36, 0x33, 0x32, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x37, 0x64, 0x35, 0x64, 0x62, 0x65, 0x32, 0x32, 0x32, 0x66, 0x32, 0x66, 0x62, 0x35, 0x32, 0x35, 0x33, 0x31, 0x61, 0x63, 0x62, 0x64, 0x30, 0x62, 0x30, 0x31, 0x33, 0x64, 0x63, 0x34, 0x34, 0x36, 0x61, 0x63, 0x37, 0x33, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x66, 0x38, 0x35, 0x32, 0x30, 0x33, 0x63, 0x38, 0x33, 0x37, 0x36, 0x61, 0x35, 0x66, 0x64, 0x65, 0x39, 0x38, 0x31, 0x35, 0x33, 0x38, 0x34, 0x61, 0x33, 0x35, 0x30, 0x63, 0x33, 0x38, 0x37, 0x39, 0x63, 0x34, 0x63, 0x62, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x65, 0x30, 0x34, 0x37, 0x31, 0x63, 0x36, 0x34, 0x66, 0x66, 0x33, 0x35, 0x66, 0x61, 0x35, 0x32, 0x33, 0x32, 0x63, 0x63, 0x33, 0x31, 0x32, 0x31, 0x64, 0x31, 0x64, 0x33, 0x38, 0x64, 0x31, 0x61, 0x30, 0x66, 0x62, 0x37, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x65, 0x63, 0x63, 0x38, 0x32, 0x64, 0x64, 0x66, 0x63, 0x35, 0x36, 0x31, 0x39, 0x32, 0x65, 0x32, 0x36, 0x66, 0x35, 0x36, 0x33, 0x63, 0x33, 0x64, 0x36, 0x38, 0x63, 0x62, 0x35, 0x34, 0x34, 0x61, 0x39, 0x36, 0x62, 0x66, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x31, 0x34, 0x66, 0x34, 0x32, 0x64, 0x35, 0x64, 0x61, 0x38, 0x34, 0x34, 0x33, 0x37, 0x37, 0x35, 0x37, 0x38, 0x65, 0x36, 0x62, 0x34, 0x34, 0x38, 0x64, 0x63, 0x32, 0x34, 0x33, 0x30, 0x35, 0x62, 0x65, 0x66, 0x32, 0x62, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x39, 0x36, 0x62, 0x63, 0x64, 0x35, 0x38, 0x34, 0x35, 0x37, 0x62, 0x62, 0x66, 0x31, 0x64, 0x33, 0x63, 0x32, 0x61, 0x34, 0x36, 0x66, 0x66, 0x61, 0x66, 0x31, 0x36, 0x64, 0x62, 0x66, 0x37, 0x64, 0x38, 0x33, 0x36, 0x38, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x31, 0x33, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x36, 0x36, 0x66, 0x66, 0x65, 0x64, 0x62, 0x35, 0x33, 0x30, 0x65, 0x61, 0x30, 0x62, 0x32, 0x65, 0x38, 0x35, 0x36, 0x64, 0x64, 0x31, 0x32, 0x61, 0x63, 0x32, 0x32, 0x39, 0x36, 0x63, 0x33, 0x31, 0x66, 0x65, 0x32, 0x39, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x38, 0x34, 0x38, 0x37, 0x36, 0x64, 0x62, 0x62, 0x39, 0x35, 0x63, 0x34, 0x30, 0x62, 0x36, 0x36, 0x35, 0x36, 0x65, 0x34, 0x32, 0x62, 0x61, 0x39, 0x61, 0x65, 0x61, 0x30, 0x38, 0x61, 0x39, 0x39, 0x33, 0x62, 0x35, 0x34, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x31, 0x39, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x63, 0x34, 0x66, 0x34, 0x35, 0x61, 0x38, 0x32, 0x65, 0x31, 0x63, 0x34, 0x37, 0x38, 0x64, 0x38, 0x34, 0x35, 0x30, 0x38, 0x32, 0x65, 0x62, 0x31, 0x38, 0x38, 0x37, 0x35, 0x63, 0x34, 0x65, 0x61, 0x36, 0x35, 0x33, 0x39, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x39, 0x36, 0x34, 0x38, 0x34, 0x39, 0x62, 0x31, 0x66, 0x36, 0x39, 0x63, 0x63, 0x37, 0x63, 0x65, 0x61, 0x34, 0x34, 0x34, 0x32, 0x35, 0x33, 0x38, 0x65, 0x64, 0x38, 0x37, 0x66, 0x64, 0x66, 0x31, 0x36, 0x63, 0x66, 0x63, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x62, 0x34, 0x37, 0x31, 0x30, 0x35, 0x66, 0x65, 0x34, 0x32, 0x63, 0x34, 0x37, 0x31, 0x32, 0x64, 0x63, 0x65, 0x36, 0x65, 0x32, 0x61, 0x32, 0x31, 0x63, 0x30, 0x35, 0x62, 0x66, 0x66, 0x64, 0x35, 0x65, 0x61, 0x34, 0x37, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x65, 0x39, 0x63, 0x30, 0x30, 0x66, 0x30, 0x63, 0x32, 0x30, 0x36, 0x61, 0x34, 0x65, 0x34, 0x65, 0x37, 0x65, 0x30, 0x35, 0x32, 0x32, 0x31, 0x37, 0x30, 0x64, 0x63, 0x38, 0x31, 0x65, 0x38, 0x38, 0x66, 0x33, 0x65, 0x62, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x65, 0x37, 0x37, 0x37, 0x30, 0x33, 0x38, 0x30, 0x38, 0x66, 0x38, 0x32, 0x33, 0x65, 0x36, 0x63, 0x33, 0x39, 0x39, 0x33, 0x35, 0x32, 0x31, 0x30, 0x38, 0x62, 0x64, 0x62, 0x32, 0x63, 0x35, 0x32, 0x37, 0x63, 0x62, 0x38, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x37, 0x32, 0x31, 0x38, 0x36, 0x65, 0x66, 0x32, 0x37, 0x64, 0x63, 0x62, 0x65, 0x32, 0x66, 0x35, 0x66, 0x63, 0x33, 0x37, 0x33, 0x30, 0x35, 0x30, 0x66, 0x64, 0x61, 0x65, 0x37, 0x66, 0x32, 0x61, 0x63, 0x65, 0x32, 0x33, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x35, 0x37, 0x36, 0x65, 0x39, 0x64, 0x33, 0x31, 0x34, 0x64, 0x66, 0x34, 0x31, 0x65, 0x63, 0x35, 0x35, 0x30, 0x36, 0x34, 0x39, 0x34, 0x32, 0x39, 0x33, 0x61, 0x66, 0x62, 0x31, 0x62, 0x64, 0x35, 0x64, 0x33, 0x66, 0x36, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x39, 0x66, 0x66, 0x66, 0x36, 0x38, 0x63, 0x36, 0x31, 0x62, 0x30, 0x31, 0x31, 0x65, 0x66, 0x62, 0x65, 0x63, 0x66, 0x30, 0x33, 0x38, 0x65, 0x64, 0x37, 0x32, 0x64, 0x62, 0x39, 0x37, 0x62, 0x62, 0x39, 0x65, 0x37, 0x32, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x39, 0x35, 0x32, 0x39, 0x34, 0x39, 0x32, 0x62, 0x35, 0x63, 0x32, 0x39, 0x65, 0x34, 0x37, 0x35, 0x61, 0x63, 0x62, 0x39, 0x34, 0x31, 0x34, 0x30, 0x32, 0x62, 0x33, 0x64, 0x33, 0x62, 0x61, 0x35, 0x30, 0x36, 0x38, 0x36, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x39, 0x62, 0x33, 0x39, 0x33, 0x38, 0x39, 0x64, 0x34, 0x37, 0x62, 0x31, 0x31, 0x62, 0x38, 0x61, 0x32, 0x63, 0x33, 0x66, 0x31, 0x64, 0x61, 0x39, 0x31, 0x32, 0x34, 0x64, 0x65, 0x63, 0x66, 0x66, 0x62, 0x65, 0x66, 0x61, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x39, 0x35, 0x31, 0x66, 0x36, 0x64, 0x63, 0x35, 0x65, 0x33, 0x35, 0x32, 0x61, 0x66, 0x62, 0x38, 0x64, 0x30, 0x34, 0x32, 0x39, 0x39, 0x64, 0x32, 0x34, 0x37, 0x38, 0x61, 0x34, 0x35, 0x31, 0x32, 0x35, 0x39, 0x62, 0x66, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x62, 0x31, 0x66, 0x62, 0x65, 0x34, 0x65, 0x35, 0x64, 0x33, 0x30, 0x31, 0x39, 0x63, 0x64, 0x37, 0x64, 0x33, 0x30, 0x64, 0x61, 0x65, 0x39, 0x63, 0x30, 0x64, 0x35, 0x62, 0x34, 0x63, 0x37, 0x36, 0x66, 0x62, 0x36, 0x33, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x63, 0x63, 0x38, 0x30, 0x34, 0x64, 0x39, 0x32, 0x32, 0x62, 0x65, 0x39, 0x31, 0x66, 0x35, 0x39, 0x30, 0x39, 0x66, 0x33, 0x34, 0x38, 0x62, 0x30, 0x61, 0x61, 0x61, 0x35, 0x64, 0x32, 0x31, 0x62, 0x36, 0x30, 0x37, 0x38, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x37, 0x62, 0x39, 0x65, 0x63, 0x37, 0x61, 0x32, 0x34, 0x33, 0x38, 0x64, 0x31, 0x65, 0x33, 0x63, 0x37, 0x36, 0x39, 0x38, 0x62, 0x35, 0x34, 0x35, 0x62, 0x39, 0x63, 0x33, 0x66, 0x64, 0x37, 0x37, 0x62, 0x37, 0x63, 0x64, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x36, 0x31, 0x36, 0x30, 0x38, 0x35, 0x31, 0x64, 0x32, 0x62, 0x39, 0x63, 0x33, 0x34, 0x39, 0x62, 0x39, 0x32, 0x65, 0x34, 0x36, 0x66, 0x38, 0x32, 0x39, 0x61, 0x62, 0x66, 0x62, 0x32, 0x31, 0x30, 0x39, 0x34, 0x33, 0x35, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x63, 0x36, 0x62, 0x39, 0x38, 0x38, 0x34, 0x32, 0x35, 0x34, 0x32, 0x65, 0x61, 0x31, 0x30, 0x62, 0x62, 0x37, 0x34, 0x66, 0x32, 0x36, 0x64, 0x37, 0x63, 0x37, 0x34, 0x38, 0x38, 0x66, 0x36, 0x39, 0x38, 0x62, 0x36, 0x34, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x38, 0x32, 0x35, 0x61, 0x65, 0x62, 0x30, 0x39, 0x30, 0x37, 0x36, 0x63, 0x61, 0x61, 0x34, 0x37, 0x37, 0x38, 0x38, 0x37, 0x66, 0x62, 0x63, 0x39, 0x61, 0x65, 0x33, 0x37, 0x65, 0x38, 0x62, 0x32, 0x37, 0x63, 0x63, 0x39, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x35, 0x65, 0x38, 0x61, 0x31, 0x63, 0x30, 0x64, 0x61, 0x63, 0x37, 0x65, 0x30, 0x65, 0x36, 0x36, 0x64, 0x62, 0x61, 0x63, 0x37, 0x33, 0x36, 0x61, 0x35, 0x39, 0x32, 0x61, 0x62, 0x64, 0x34, 0x34, 0x30, 0x31, 0x32, 0x35, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x36, 0x62, 0x38, 0x34, 0x65, 0x62, 0x38, 0x35, 0x66, 0x63, 0x63, 0x31, 0x66, 0x34, 0x66, 0x63, 0x64, 0x63, 0x63, 0x32, 0x62, 0x30, 0x38, 0x64, 0x62, 0x36, 0x61, 0x38, 0x36, 0x65, 0x31, 0x33, 0x35, 0x66, 0x62, 0x63, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x33, 0x62, 0x33, 0x64, 0x32, 0x62, 0x62, 0x66, 0x64, 0x63, 0x62, 0x63, 0x38, 0x37, 0x37, 0x32, 0x61, 0x32, 0x33, 0x33, 0x31, 0x35, 0x37, 0x32, 0x34, 0x63, 0x31, 0x34, 0x32, 0x35, 0x31, 0x36, 0x37, 0x63, 0x35, 0x36, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x32, 0x31, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x32, 0x64, 0x63, 0x62, 0x37, 0x61, 0x36, 0x37, 0x31, 0x37, 0x30, 0x31, 0x64, 0x62, 0x62, 0x38, 0x66, 0x34, 0x39, 0x35, 0x37, 0x32, 0x38, 0x30, 0x38, 0x38, 0x32, 0x36, 0x35, 0x38, 0x37, 0x33, 0x33, 0x35, 0x36, 0x63, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x63, 0x62, 0x34, 0x63, 0x34, 0x66, 0x34, 0x35, 0x31, 0x36, 0x63, 0x34, 0x66, 0x66, 0x37, 0x39, 0x61, 0x31, 0x62, 0x36, 0x32, 0x34, 0x34, 0x66, 0x62, 0x66, 0x35, 0x37, 0x32, 0x65, 0x31, 0x63, 0x37, 0x66, 0x65, 0x61, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x62, 0x61, 0x34, 0x65, 0x39, 0x63, 0x61, 0x37, 0x32, 0x66, 0x64, 0x64, 0x63, 0x32, 0x30, 0x63, 0x36, 0x39, 0x62, 0x34, 0x33, 0x39, 0x36, 0x66, 0x37, 0x36, 0x66, 0x38, 0x31, 0x38, 0x33, 0x66, 0x37, 0x61, 0x32, 0x61, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x30, 0x38, 0x37, 0x37, 0x38, 0x36, 0x62, 0x34, 0x32, 0x64, 0x61, 0x30, 0x34, 0x65, 0x64, 0x36, 0x64, 0x31, 0x65, 0x30, 0x66, 0x65, 0x32, 0x36, 0x66, 0x36, 0x63, 0x30, 0x65, 0x65, 0x66, 0x65, 0x31, 0x65, 0x39, 0x66, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x66, 0x37, 0x66, 0x36, 0x37, 0x32, 0x30, 0x39, 0x62, 0x31, 0x36, 0x61, 0x31, 0x37, 0x35, 0x35, 0x30, 0x63, 0x36, 0x39, 0x34, 0x63, 0x37, 0x32, 0x35, 0x38, 0x33, 0x38, 0x31, 0x39, 0x63, 0x38, 0x30, 0x62, 0x35, 0x34, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x62, 0x62, 0x32, 0x65, 0x39, 0x36, 0x39, 0x33, 0x65, 0x34, 0x65, 0x30, 0x38, 0x35, 0x33, 0x34, 0x34, 0x64, 0x32, 0x66, 0x30, 0x64, 0x62, 0x64, 0x34, 0x36, 0x61, 0x32, 0x38, 0x33, 0x65, 0x33, 0x61, 0x30, 0x38, 0x37, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x37, 0x38, 0x39, 0x36, 0x33, 0x66, 0x62, 0x63, 0x32, 0x36, 0x33, 0x63, 0x30, 0x39, 0x62, 0x64, 0x37, 0x32, 0x65, 0x34, 0x66, 0x38, 0x64, 0x65, 0x66, 0x37, 0x34, 0x61, 0x39, 0x34, 0x37, 0x35, 0x66, 0x37, 0x30, 0x35, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x31, 0x34, 0x34, 0x63, 0x61, 0x39, 0x61, 0x37, 0x37, 0x37, 0x31, 0x61, 0x38, 0x33, 0x36, 0x61, 0x64, 0x35, 0x30, 0x66, 0x38, 0x30, 0x33, 0x66, 0x36, 0x34, 0x64, 0x38, 0x36, 0x39, 0x62, 0x32, 0x61, 0x65, 0x32, 0x62, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x37, 0x35, 0x38, 0x64, 0x30, 0x37, 0x31, 0x64, 0x32, 0x35, 0x61, 0x36, 0x33, 0x32, 0x30, 0x61, 0x66, 0x36, 0x38, 0x63, 0x35, 0x64, 0x63, 0x39, 0x63, 0x34, 0x66, 0x36, 0x39, 0x35, 0x35, 0x62, 0x61, 0x39, 0x34, 0x35, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x34, 0x32, 0x62, 0x34, 0x34, 0x65, 0x62, 0x35, 0x66, 0x64, 0x36, 0x30, 0x62, 0x35, 0x38, 0x33, 0x37, 0x65, 0x34, 0x66, 0x39, 0x65, 0x62, 0x34, 0x37, 0x32, 0x36, 0x37, 0x35, 0x32, 0x33, 0x64, 0x31, 0x61, 0x32, 0x32, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x66, 0x35, 0x62, 0x32, 0x30, 0x37, 0x62, 0x38, 0x38, 0x62, 0x30, 0x64, 0x65, 0x34, 0x61, 0x63, 0x34, 0x30, 0x64, 0x37, 0x34, 0x37, 0x63, 0x65, 0x65, 0x30, 0x36, 0x65, 0x31, 0x37, 0x32, 0x64, 0x66, 0x36, 0x65, 0x37, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x64, 0x33, 0x38, 0x30, 0x35, 0x31, 0x31, 0x64, 0x66, 0x31, 0x39, 0x64, 0x35, 0x65, 0x63, 0x32, 0x38, 0x30, 0x37, 0x62, 0x62, 0x63, 0x62, 0x36, 0x37, 0x36, 0x35, 0x38, 0x31, 0x62, 0x36, 0x37, 0x66, 0x64, 0x33, 0x37, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x31, 0x62, 0x33, 0x37, 0x36, 0x38, 0x63, 0x31, 0x36, 0x64, 0x38, 0x32, 0x31, 0x66, 0x35, 0x38, 0x30, 0x65, 0x37, 0x36, 0x63, 0x38, 0x65, 0x34, 0x63, 0x38, 0x65, 0x38, 0x36, 0x64, 0x37, 0x64, 0x63, 0x37, 0x38, 0x38, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x30, 0x39, 0x38, 0x61, 0x38, 0x31, 0x34, 0x35, 0x32, 0x33, 0x31, 0x37, 0x63, 0x31, 0x39, 0x65, 0x33, 0x65, 0x65, 0x66, 0x30, 0x62, 0x64, 0x31, 0x32, 0x33, 0x62, 0x62, 0x65, 0x31, 0x37, 0x38, 0x65, 0x39, 0x65, 0x39, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x37, 0x31, 0x34, 0x38, 0x66, 0x64, 0x37, 0x32, 0x63, 0x35, 0x34, 0x66, 0x36, 0x32, 0x30, 0x61, 0x35, 0x39, 0x32, 0x66, 0x62, 0x39, 0x32, 0x37, 0x39, 0x39, 0x33, 0x31, 0x39, 0x63, 0x63, 0x34, 0x35, 0x33, 0x32, 0x62, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x63, 0x64, 0x62, 0x64, 0x34, 0x31, 0x66, 0x66, 0x66, 0x32, 0x30, 0x64, 0x66, 0x37, 0x32, 0x37, 0x63, 0x37, 0x30, 0x62, 0x36, 0x32, 0x35, 0x35, 0x63, 0x31, 0x62, 0x61, 0x37, 0x36, 0x30, 0x36, 0x30, 0x35, 0x35, 0x34, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x33, 0x33, 0x66, 0x63, 0x62, 0x62, 0x63, 0x30, 0x30, 0x33, 0x35, 0x31, 0x30, 0x62, 0x65, 0x33, 0x35, 0x37, 0x38, 0x35, 0x62, 0x35, 0x32, 0x61, 0x39, 0x63, 0x35, 0x64, 0x32, 0x31, 0x36, 0x62, 0x63, 0x30, 0x30, 0x35, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x32, 0x37, 0x64, 0x61, 0x66, 0x35, 0x62, 0x39, 0x64, 0x36, 0x38, 0x65, 0x66, 0x63, 0x61, 0x62, 0x34, 0x38, 0x39, 0x66, 0x65, 0x64, 0x65, 0x63, 0x39, 0x36, 0x64, 0x37, 0x66, 0x37, 0x33, 0x32, 0x35, 0x64, 0x64, 0x34, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x30, 0x61, 0x31, 0x36, 0x31, 0x62, 0x63, 0x33, 0x36, 0x37, 0x61, 0x65, 0x30, 0x39, 0x32, 0x37, 0x61, 0x39, 0x32, 0x61, 0x61, 0x63, 0x39, 0x63, 0x66, 0x36, 0x65, 0x35, 0x30, 0x38, 0x36, 0x37, 0x31, 0x34, 0x65, 0x66, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x32, 0x36, 0x36, 0x37, 0x66, 0x31, 0x37, 0x32, 0x31, 0x33, 0x35, 0x62, 0x39, 0x35, 0x30, 0x62, 0x32, 0x63, 0x64, 0x31, 0x64, 0x65, 0x31, 0x30, 0x61, 0x66, 0x64, 0x65, 0x63, 0x65, 0x36, 0x38, 0x35, 0x37, 0x62, 0x38, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x30, 0x31, 0x39, 0x34, 0x63, 0x34, 0x62, 0x31, 0x30, 0x37, 0x34, 0x33, 0x30, 0x35, 0x64, 0x31, 0x39, 0x64, 0x65, 0x34, 0x30, 0x35, 0x62, 0x30, 0x61, 0x63, 0x37, 0x38, 0x32, 0x38, 0x30, 0x65, 0x63, 0x61, 0x66, 0x39, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x66, 0x35, 0x35, 0x65, 0x66, 0x34, 0x37, 0x65, 0x36, 0x34, 0x35, 0x36, 0x61, 0x34, 0x31, 0x38, 0x61, 0x62, 0x33, 0x32, 0x62, 0x39, 0x32, 0x32, 0x31, 0x65, 0x64, 0x32, 0x37, 0x64, 0x62, 0x61, 0x36, 0x36, 0x30, 0x38, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x61, 0x35, 0x33, 0x32, 0x63, 0x39, 0x31, 0x30, 0x65, 0x33, 0x61, 0x63, 0x30, 0x64, 0x66, 0x62, 0x31, 0x34, 0x64, 0x62, 0x36, 0x31, 0x63, 0x64, 0x37, 0x33, 0x39, 0x61, 0x39, 0x33, 0x33, 0x35, 0x33, 0x66, 0x64, 0x30, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x36, 0x38, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x64, 0x66, 0x32, 0x64, 0x63, 0x64, 0x61, 0x66, 0x37, 0x34, 0x62, 0x32, 0x62, 0x66, 0x38, 0x30, 0x33, 0x34, 0x30, 0x34, 0x64, 0x64, 0x34, 0x64, 0x65, 0x36, 0x61, 0x33, 0x35, 0x65, 0x61, 0x62, 0x65, 0x63, 0x31, 0x62, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x65, 0x37, 0x66, 0x62, 0x39, 0x65, 0x34, 0x32, 0x30, 0x61, 0x35, 0x33, 0x34, 0x30, 0x64, 0x35, 0x33, 0x36, 0x66, 0x34, 0x30, 0x34, 0x30, 0x38, 0x33, 0x34, 0x34, 0x66, 0x65, 0x61, 0x65, 0x66, 0x63, 0x30, 0x36, 0x61, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x34, 0x32, 0x61, 0x32, 0x63, 0x66, 0x63, 0x65, 0x38, 0x64, 0x37, 0x39, 0x61, 0x32, 0x63, 0x34, 0x61, 0x35, 0x31, 0x62, 0x37, 0x37, 0x37, 0x34, 0x37, 0x34, 0x39, 0x38, 0x39, 0x31, 0x32, 0x32, 0x34, 0x35, 0x63, 0x64, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x38, 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x36, 0x33, 0x61, 0x32, 0x34, 0x31, 0x61, 0x30, 0x61, 0x38, 0x39, 0x65, 0x37, 0x30, 0x65, 0x31, 0x38, 0x32, 0x63, 0x38, 0x34, 0x35, 0x65, 0x32, 0x31, 0x30, 0x35, 0x63, 0x38, 0x61, 0x64, 0x37, 0x32, 0x36, 0x34, 0x62, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x38, 0x32, 0x35, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x65, 0x31, 0x31, 0x33, 0x64, 0x38, 0x31, 0x37, 0x37, 0x63, 0x36, 0x39, 0x31, 0x61, 0x36, 0x31, 0x62, 0x65, 0x37, 0x38, 0x35, 0x38, 0x35, 0x32, 0x66, 0x61, 0x35, 0x62, 0x62, 0x34, 0x37, 0x61, 0x65, 0x65, 0x62, 0x64, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x65, 0x63, 0x34, 0x64, 0x30, 0x32, 0x63, 0x65, 0x38, 0x35, 0x66, 0x63, 0x34, 0x38, 0x66, 0x65, 0x62, 0x36, 0x32, 0x34, 0x38, 0x39, 0x38, 0x34, 0x31, 0x64, 0x38, 0x35, 0x62, 0x31, 0x37, 0x30, 0x35, 0x38, 0x36, 0x61, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x37, 0x63, 0x66, 0x39, 0x64, 0x30, 0x39, 0x30, 0x32, 0x65, 0x66, 0x38, 0x31, 0x39, 0x61, 0x37, 0x61, 0x35, 0x66, 0x31, 0x34, 0x39, 0x34, 0x34, 0x35, 0x62, 0x66, 0x31, 0x37, 0x37, 0x35, 0x65, 0x65, 0x38, 0x63, 0x34, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x39, 0x36, 0x37, 0x32, 0x38, 0x30, 0x32, 0x31, 0x34, 0x65, 0x32, 0x31, 0x38, 0x61, 0x31, 0x32, 0x30, 0x63, 0x35, 0x64, 0x64, 0x61, 0x33, 0x37, 0x30, 0x34, 0x31, 0x62, 0x31, 0x31, 0x31, 0x65, 0x61, 0x33, 0x36, 0x64, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x62, 0x37, 0x37, 0x31, 0x39, 0x35, 0x31, 0x63, 0x65, 0x31, 0x64, 0x65, 0x65, 0x65, 0x33, 0x36, 0x33, 0x61, 0x65, 0x32, 0x62, 0x37, 0x37, 0x31, 0x62, 0x37, 0x33, 0x65, 0x30, 0x37, 0x63, 0x34, 0x62, 0x35, 0x65, 0x38, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x66, 0x38, 0x66, 0x62, 0x61, 0x34, 0x63, 0x33, 0x30, 0x37, 0x37, 0x32, 0x62, 0x30, 0x35, 0x37, 0x65, 0x64, 0x62, 0x62, 0x65, 0x36, 0x32, 0x61, 0x65, 0x37, 0x34, 0x32, 0x30, 0x63, 0x33, 0x39, 0x30, 0x35, 0x37, 0x32, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x33, 0x34, 0x63, 0x37, 0x65, 0x37, 0x39, 0x39, 0x35, 0x64, 0x62, 0x39, 0x66, 0x31, 0x38, 0x37, 0x63, 0x66, 0x66, 0x31, 0x35, 0x36, 0x39, 0x31, 0x38, 0x63, 0x66, 0x62, 0x36, 0x66, 0x31, 0x33, 0x66, 0x36, 0x65, 0x30, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x36, 0x62, 0x66, 0x37, 0x65, 0x33, 0x63, 0x35, 0x34, 0x35, 0x39, 0x32, 0x31, 0x64, 0x33, 0x32, 0x30, 0x36, 0x64, 0x39, 0x30, 0x30, 0x63, 0x32, 0x34, 0x66, 0x31, 0x34, 0x31, 0x32, 0x37, 0x63, 0x62, 0x64, 0x35, 0x65, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x32, 0x33, 0x35, 0x66, 0x33, 0x34, 0x30, 0x64, 0x32, 0x38, 0x36, 0x33, 0x65, 0x31, 0x38, 0x64, 0x32, 0x66, 0x34, 0x63, 0x35, 0x32, 0x39, 0x39, 0x36, 0x35, 0x31, 0x36, 0x31, 0x33, 0x38, 0x64, 0x32, 0x32, 0x30, 0x32, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x66, 0x65, 0x63, 0x30, 0x63, 0x36, 0x32, 0x35, 0x33, 0x63, 0x61, 0x66, 0x33, 0x39, 0x37, 0x66, 0x37, 0x31, 0x32, 0x38, 0x37, 0x63, 0x31, 0x63, 0x30, 0x37, 0x66, 0x36, 0x63, 0x39, 0x35, 0x38, 0x32, 0x62, 0x35, 0x62, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x32, 0x38, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x32, 0x65, 0x33, 0x31, 0x62, 0x30, 0x38, 0x38, 0x30, 0x33, 0x62, 0x32, 0x63, 0x35, 0x66, 0x31, 0x33, 0x64, 0x33, 0x39, 0x38, 0x65, 0x63, 0x61, 0x64, 0x38, 0x38, 0x35, 0x32, 0x38, 0x32, 0x30, 0x39, 0x66, 0x36, 0x30, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x34, 0x65, 0x61, 0x62, 0x34, 0x62, 0x32, 0x37, 0x36, 0x62, 0x34, 0x63, 0x64, 0x38, 0x39, 0x38, 0x33, 0x65, 0x31, 0x35, 0x63, 0x61, 0x37, 0x32, 0x62, 0x31, 0x30, 0x36, 0x39, 0x30, 0x30, 0x66, 0x65, 0x34, 0x31, 0x66, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x61, 0x31, 0x65, 0x39, 0x37, 0x39, 0x38, 0x38, 0x64, 0x65, 0x37, 0x35, 0x64, 0x38, 0x32, 0x31, 0x63, 0x64, 0x32, 0x38, 0x61, 0x64, 0x36, 0x38, 0x32, 0x32, 0x62, 0x32, 0x32, 0x63, 0x63, 0x65, 0x39, 0x38, 0x38, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x38, 0x63, 0x30, 0x62, 0x64, 0x65, 0x36, 0x33, 0x30, 0x65, 0x63, 0x33, 0x39, 0x33, 0x62, 0x31, 0x65, 0x37, 0x32, 0x36, 0x37, 0x66, 0x63, 0x39, 0x64, 0x37, 0x64, 0x39, 0x37, 0x30, 0x31, 0x39, 0x65, 0x34, 0x31, 0x34, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x65, 0x34, 0x34, 0x36, 0x31, 0x65, 0x62, 0x39, 0x64, 0x38, 0x34, 0x39, 0x66, 0x30, 0x30, 0x34, 0x31, 0x63, 0x31, 0x34, 0x30, 0x34, 0x32, 0x31, 0x39, 0x65, 0x34, 0x32, 0x37, 0x32, 0x63, 0x34, 0x39, 0x30, 0x30, 0x61, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x37, 0x33, 0x33, 0x38, 0x39, 0x32, 0x39, 0x38, 0x30, 0x33, 0x31, 0x62, 0x38, 0x38, 0x31, 0x36, 0x63, 0x63, 0x61, 0x39, 0x34, 0x36, 0x34, 0x32, 0x31, 0x63, 0x31, 0x39, 0x39, 0x65, 0x31, 0x38, 0x62, 0x33, 0x34, 0x33, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x31, 0x32, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x35, 0x61, 0x66, 0x33, 0x31, 0x63, 0x37, 0x65, 0x30, 0x36, 0x33, 0x33, 0x39, 0x61, 0x63, 0x38, 0x62, 0x34, 0x36, 0x32, 0x38, 0x64, 0x37, 0x63, 0x34, 0x64, 0x62, 0x30, 0x63, 0x65, 0x30, 0x66, 0x34, 0x35, 0x63, 0x38, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x39, 0x62, 0x35, 0x31, 0x30, 0x33, 0x65, 0x34, 0x63, 0x65, 0x38, 0x39, 0x61, 0x66, 0x34, 0x66, 0x36, 0x34, 0x39, 0x31, 0x36, 0x31, 0x35, 0x30, 0x62, 0x66, 0x66, 0x39, 0x65, 0x65, 0x63, 0x62, 0x39, 0x66, 0x61, 0x61, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x30, 0x66, 0x36, 0x34, 0x31, 0x36, 0x31, 0x34, 0x37, 0x37, 0x39, 0x64, 0x63, 0x66, 0x61, 0x38, 0x38, 0x65, 0x64, 0x31, 0x64, 0x34, 0x32, 0x35, 0x64, 0x36, 0x30, 0x64, 0x62, 0x34, 0x32, 0x61, 0x30, 0x36, 0x30, 0x63, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x38, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x65, 0x36, 0x32, 0x33, 0x34, 0x35, 0x31, 0x65, 0x37, 0x65, 0x39, 0x34, 0x65, 0x37, 0x65, 0x38, 0x39, 0x62, 0x61, 0x35, 0x65, 0x64, 0x39, 0x35, 0x63, 0x38, 0x61, 0x38, 0x33, 0x61, 0x36, 0x32, 0x66, 0x66, 0x63, 0x34, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x61, 0x35, 0x30, 0x30, 0x65, 0x65, 0x65, 0x63, 0x37, 0x61, 0x36, 0x36, 0x32, 0x61, 0x38, 0x34, 0x31, 0x35, 0x35, 0x32, 0x62, 0x35, 0x31, 0x36, 0x38, 0x62, 0x37, 0x30, 0x37, 0x62, 0x30, 0x64, 0x65, 0x32, 0x31, 0x65, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x35, 0x61, 0x37, 0x66, 0x63, 0x34, 0x61, 0x63, 0x65, 0x33, 0x36, 0x38, 0x64, 0x32, 0x33, 0x33, 0x65, 0x36, 0x32, 0x30, 0x62, 0x32, 0x61, 0x34, 0x35, 0x39, 0x33, 0x35, 0x36, 0x36, 0x31, 0x32, 0x39, 0x32, 0x62, 0x64, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x36, 0x38, 0x66, 0x36, 0x37, 0x34, 0x31, 0x36, 0x61, 0x36, 0x33, 0x62, 0x66, 0x34, 0x34, 0x35, 0x31, 0x61, 0x33, 0x31, 0x31, 0x36, 0x34, 0x63, 0x39, 0x32, 0x66, 0x36, 0x37, 0x32, 0x61, 0x36, 0x38, 0x37, 0x35, 0x39, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x38, 0x62, 0x35, 0x62, 0x64, 0x38, 0x31, 0x61, 0x39, 0x64, 0x62, 0x39, 0x64, 0x32, 0x62, 0x32, 0x31, 0x64, 0x35, 0x65, 0x63, 0x37, 0x63, 0x36, 0x30, 0x35, 0x35, 0x32, 0x63, 0x64, 0x30, 0x32, 0x65, 0x64, 0x35, 0x36, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x63, 0x38, 0x33, 0x30, 0x66, 0x31, 0x36, 0x35, 0x34, 0x37, 0x31, 0x38, 0x66, 0x30, 0x37, 0x35, 0x63, 0x63, 0x61, 0x62, 0x61, 0x33, 0x31, 0x36, 0x66, 0x61, 0x61, 0x63, 0x62, 0x38, 0x35, 0x62, 0x37, 0x64, 0x31, 0x32, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x39, 0x32, 0x65, 0x35, 0x33, 0x37, 0x37, 0x36, 0x37, 0x31, 0x33, 0x35, 0x37, 0x38, 0x30, 0x31, 0x35, 0x62, 0x66, 0x66, 0x34, 0x39, 0x34, 0x30, 0x63, 0x66, 0x34, 0x33, 0x38, 0x34, 0x39, 0x64, 0x37, 0x64, 0x63, 0x62, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x33, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x35, 0x37, 0x34, 0x37, 0x37, 0x64, 0x61, 0x66, 0x61, 0x34, 0x32, 0x66, 0x37, 0x30, 0x35, 0x63, 0x37, 0x66, 0x65, 0x34, 0x30, 0x65, 0x61, 0x65, 0x39, 0x63, 0x38, 0x31, 0x37, 0x35, 0x36, 0x65, 0x30, 0x32, 0x32, 0x35, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x62, 0x63, 0x33, 0x31, 0x37, 0x33, 0x62, 0x63, 0x39, 0x30, 0x37, 0x32, 0x31, 0x33, 0x36, 0x33, 0x35, 0x34, 0x30, 0x30, 0x32, 0x62, 0x37, 0x62, 0x34, 0x66, 0x62, 0x33, 0x62, 0x66, 0x63, 0x35, 0x33, 0x66, 0x32, 0x32, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x38, 0x66, 0x38, 0x34, 0x65, 0x33, 0x38, 0x39, 0x34, 0x34, 0x61, 0x30, 0x65, 0x30, 0x32, 0x35, 0x35, 0x66, 0x61, 0x65, 0x63, 0x65, 0x34, 0x38, 0x62, 0x61, 0x34, 0x39, 0x35, 0x30, 0x64, 0x34, 0x62, 0x64, 0x33, 0x39, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x61, 0x33, 0x62, 0x62, 0x36, 0x31, 0x33, 0x39, 0x62, 0x30, 0x61, 0x64, 0x61, 0x30, 0x30, 0x63, 0x31, 0x66, 0x37, 0x66, 0x31, 0x66, 0x39, 0x66, 0x35, 0x36, 0x64, 0x39, 0x39, 0x34, 0x62, 0x61, 0x34, 0x64, 0x31, 0x66, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x33, 0x66, 0x32, 0x39, 0x36, 0x30, 0x31, 0x61, 0x31, 0x33, 0x33, 0x31, 0x37, 0x34, 0x35, 0x65, 0x30, 0x35, 0x63, 0x34, 0x32, 0x38, 0x33, 0x30, 0x61, 0x31, 0x35, 0x65, 0x37, 0x31, 0x39, 0x33, 0x38, 0x61, 0x36, 0x32, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x63, 0x36, 0x36, 0x34, 0x30, 0x66, 0x34, 0x39, 0x30, 0x39, 0x62, 0x35, 0x38, 0x63, 0x62, 0x66, 0x31, 0x65, 0x38, 0x30, 0x36, 0x33, 0x34, 0x32, 0x39, 0x36, 0x31, 0x64, 0x36, 0x30, 0x37, 0x35, 0x39, 0x35, 0x30, 0x39, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x65, 0x33, 0x63, 0x33, 0x32, 0x39, 0x62, 0x36, 0x32, 0x61, 0x32, 0x38, 0x62, 0x38, 0x62, 0x30, 0x38, 0x38, 0x36, 0x63, 0x62, 0x64, 0x38, 0x62, 0x39, 0x39, 0x66, 0x38, 0x62, 0x63, 0x39, 0x33, 0x30, 0x63, 0x65, 0x33, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x65, 0x62, 0x32, 0x63, 0x30, 0x61, 0x31, 0x33, 0x32, 0x61, 0x35, 0x32, 0x34, 0x66, 0x37, 0x32, 0x63, 0x63, 0x63, 0x30, 0x64, 0x36, 0x30, 0x66, 0x65, 0x65, 0x38, 0x62, 0x34, 0x31, 0x36, 0x38, 0x35, 0x64, 0x33, 0x39, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x62, 0x31, 0x66, 0x33, 0x37, 0x30, 0x66, 0x39, 0x63, 0x31, 0x65, 0x62, 0x30, 0x62, 0x65, 0x30, 0x66, 0x62, 0x38, 0x65, 0x32, 0x62, 0x38, 0x61, 0x64, 0x39, 0x36, 0x61, 0x34, 0x31, 0x36, 0x33, 0x37, 0x31, 0x64, 0x64, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x37, 0x34, 0x32, 0x65, 0x36, 0x38, 0x35, 0x39, 0x63, 0x35, 0x36, 0x39, 0x64, 0x35, 0x66, 0x32, 0x31, 0x30, 0x38, 0x33, 0x35, 0x31, 0x65, 0x30, 0x62, 0x66, 0x34, 0x64, 0x63, 0x61, 0x33, 0x35, 0x32, 0x61, 0x34, 0x38, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x33, 0x34, 0x63, 0x30, 0x30, 0x34, 0x33, 0x39, 0x31, 0x61, 0x62, 0x34, 0x39, 0x39, 0x32, 0x38, 0x37, 0x38, 0x33, 0x33, 0x37, 0x61, 0x35, 0x31, 0x65, 0x63, 0x32, 0x34, 0x32, 0x66, 0x34, 0x32, 0x32, 0x38, 0x35, 0x37, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x37, 0x34, 0x31, 0x36, 0x66, 0x66, 0x33, 0x32, 0x32, 0x35, 0x34, 0x39, 0x35, 0x31, 0x63, 0x62, 0x62, 0x63, 0x36, 0x32, 0x34, 0x65, 0x63, 0x37, 0x66, 0x62, 0x34, 0x35, 0x66, 0x63, 0x37, 0x65, 0x63, 0x61, 0x61, 0x38, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x39, 0x35, 0x66, 0x36, 0x34, 0x33, 0x31, 0x39, 0x66, 0x63, 0x31, 0x37, 0x64, 0x64, 0x30, 0x66, 0x38, 0x32, 0x36, 0x31, 0x66, 0x39, 0x64, 0x32, 0x30, 0x36, 0x66, 0x62, 0x36, 0x36, 0x62, 0x36, 0x34, 0x63, 0x64, 0x30, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x65, 0x30, 0x33, 0x65, 0x66, 0x30, 0x37, 0x30, 0x61, 0x35, 0x34, 0x37, 0x30, 0x33, 0x62, 0x37, 0x31, 0x38, 0x34, 0x65, 0x34, 0x38, 0x32, 0x37, 0x36, 0x63, 0x35, 0x63, 0x30, 0x30, 0x37, 0x37, 0x65, 0x66, 0x34, 0x62, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x33, 0x30, 0x61, 0x31, 0x36, 0x33, 0x38, 0x31, 0x66, 0x38, 0x36, 0x39, 0x66, 0x36, 0x65, 0x61, 0x35, 0x34, 0x32, 0x33, 0x39, 0x31, 0x35, 0x38, 0x35, 0x35, 0x65, 0x38, 0x30, 0x30, 0x38, 0x38, 0x33, 0x35, 0x32, 0x35, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x61, 0x33, 0x36, 0x37, 0x62, 0x31, 0x36, 0x36, 0x64, 0x32, 0x39, 0x39, 0x31, 0x61, 0x32, 0x62, 0x66, 0x64, 0x61, 0x39, 0x66, 0x35, 0x36, 0x34, 0x36, 0x33, 0x61, 0x30, 0x39, 0x66, 0x32, 0x35, 0x32, 0x63, 0x31, 0x62, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x63, 0x34, 0x61, 0x36, 0x39, 0x37, 0x65, 0x36, 0x30, 0x33, 0x64, 0x34, 0x32, 0x62, 0x31, 0x32, 0x30, 0x35, 0x36, 0x63, 0x62, 0x62, 0x61, 0x37, 0x36, 0x31, 0x65, 0x37, 0x66, 0x35, 0x31, 0x64, 0x30, 0x34, 0x34, 0x33, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x33, 0x65, 0x66, 0x35, 0x38, 0x61, 0x31, 0x65, 0x32, 0x65, 0x37, 0x61, 0x33, 0x65, 0x62, 0x36, 0x62, 0x34, 0x35, 0x39, 0x61, 0x38, 0x30, 0x61, 0x62, 0x32, 0x61, 0x35, 0x34, 0x37, 0x63, 0x39, 0x34, 0x31, 0x38, 0x32, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x62, 0x65, 0x38, 0x61, 0x62, 0x66, 0x61, 0x31, 0x37, 0x34, 0x32, 0x38, 0x30, 0x36, 0x32, 0x36, 0x33, 0x39, 0x38, 0x31, 0x33, 0x37, 0x31, 0x62, 0x66, 0x33, 0x64, 0x33, 0x35, 0x35, 0x39, 0x30, 0x38, 0x30, 0x36, 0x62, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x39, 0x39, 0x64, 0x61, 0x65, 0x39, 0x36, 0x34, 0x38, 0x31, 0x65, 0x38, 0x30, 0x37, 0x63, 0x31, 0x66, 0x39, 0x39, 0x66, 0x38, 0x62, 0x37, 0x66, 0x62, 0x64, 0x65, 0x32, 0x39, 0x62, 0x37, 0x35, 0x34, 0x37, 0x63, 0x35, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x62, 0x39, 0x64, 0x32, 0x37, 0x37, 0x64, 0x38, 0x61, 0x61, 0x64, 0x32, 0x30, 0x36, 0x39, 0x37, 0x61, 0x35, 0x31, 0x66, 0x37, 0x36, 0x65, 0x32, 0x30, 0x39, 0x37, 0x38, 0x39, 0x39, 0x36, 0x62, 0x66, 0x66, 0x65, 0x30, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x32, 0x34, 0x31, 0x30, 0x35, 0x61, 0x62, 0x62, 0x64, 0x61, 0x61, 0x30, 0x33, 0x66, 0x61, 0x36, 0x33, 0x30, 0x39, 0x65, 0x66, 0x36, 0x63, 0x31, 0x38, 0x38, 0x65, 0x35, 0x31, 0x66, 0x37, 0x31, 0x34, 0x61, 0x36, 0x65, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x62, 0x36, 0x62, 0x32, 0x64, 0x37, 0x63, 0x66, 0x63, 0x35, 0x35, 0x39, 0x62, 0x37, 0x66, 0x34, 0x31, 0x65, 0x36, 0x66, 0x35, 0x36, 0x61, 0x62, 0x39, 0x35, 0x63, 0x37, 0x63, 0x39, 0x35, 0x38, 0x63, 0x64, 0x30, 0x65, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x37, 0x62, 0x34, 0x32, 0x36, 0x35, 0x34, 0x37, 0x61, 0x31, 0x36, 0x34, 0x32, 0x64, 0x38, 0x30, 0x33, 0x33, 0x33, 0x32, 0x34, 0x38, 0x31, 0x34, 0x66, 0x30, 0x65, 0x64, 0x65, 0x33, 0x31, 0x31, 0x34, 0x66, 0x63, 0x32, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x38, 0x66, 0x31, 0x66, 0x38, 0x62, 0x64, 0x32, 0x32, 0x30, 0x62, 0x30, 0x35, 0x35, 0x38, 0x62, 0x39, 0x35, 0x66, 0x62, 0x33, 0x33, 0x31, 0x30, 0x30, 0x66, 0x66, 0x64, 0x62, 0x62, 0x36, 0x34, 0x30, 0x64, 0x37, 0x63, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x36, 0x64, 0x35, 0x35, 0x64, 0x35, 0x37, 0x39, 0x32, 0x61, 0x35, 0x31, 0x34, 0x65, 0x63, 0x31, 0x30, 0x38, 0x65, 0x30, 0x39, 0x30, 0x35, 0x39, 0x39, 0x66, 0x32, 0x61, 0x30, 0x36, 0x35, 0x65, 0x35, 0x30, 0x31, 0x31, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x64, 0x32, 0x32, 0x34, 0x37, 0x61, 0x32, 0x32, 0x31, 0x65, 0x37, 0x30, 0x63, 0x32, 0x64, 0x36, 0x36, 0x64, 0x31, 0x37, 0x65, 0x65, 0x31, 0x33, 0x38, 0x64, 0x33, 0x38, 0x63, 0x35, 0x35, 0x66, 0x66, 0x62, 0x38, 0x36, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x64, 0x65, 0x37, 0x32, 0x35, 0x65, 0x63, 0x61, 0x35, 0x64, 0x65, 0x66, 0x38, 0x30, 0x35, 0x66, 0x66, 0x37, 0x39, 0x34, 0x31, 0x64, 0x33, 0x31, 0x61, 0x63, 0x31, 0x63, 0x32, 0x65, 0x33, 0x34, 0x32, 0x64, 0x66, 0x65, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x36, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x36, 0x31, 0x63, 0x62, 0x62, 0x63, 0x30, 0x35, 0x35, 0x31, 0x35, 0x64, 0x65, 0x37, 0x33, 0x61, 0x62, 0x38, 0x63, 0x66, 0x39, 0x65, 0x61, 0x65, 0x31, 0x33, 0x35, 0x37, 0x33, 0x34, 0x31, 0x65, 0x37, 0x64, 0x66, 0x64, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x35, 0x35, 0x64, 0x63, 0x65, 0x63, 0x38, 0x61, 0x37, 0x66, 0x63, 0x34, 0x34, 0x36, 0x31, 0x62, 0x66, 0x64, 0x37, 0x66, 0x33, 0x37, 0x34, 0x35, 0x36, 0x66, 0x63, 0x65, 0x33, 0x66, 0x34, 0x63, 0x33, 0x63, 0x61, 0x61, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x36, 0x31, 0x66, 0x64, 0x34, 0x39, 0x65, 0x38, 0x34, 0x37, 0x66, 0x36, 0x37, 0x34, 0x35, 0x35, 0x66, 0x31, 0x63, 0x38, 0x62, 0x62, 0x37, 0x61, 0x62, 0x62, 0x33, 0x36, 0x65, 0x39, 0x38, 0x35, 0x32, 0x36, 0x30, 0x64, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x30, 0x37, 0x33, 0x62, 0x61, 0x64, 0x32, 0x35, 0x65, 0x34, 0x32, 0x32, 0x31, 0x38, 0x36, 0x31, 0x35, 0x66, 0x34, 0x61, 0x30, 0x65, 0x36, 0x62, 0x32, 0x65, 0x61, 0x38, 0x66, 0x38, 0x64, 0x65, 0x32, 0x32, 0x33, 0x30, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x30, 0x38, 0x61, 0x36, 0x64, 0x63, 0x30, 0x31, 0x37, 0x33, 0x63, 0x37, 0x33, 0x34, 0x32, 0x39, 0x35, 0x35, 0x64, 0x31, 0x64, 0x33, 0x66, 0x32, 0x63, 0x30, 0x36, 0x35, 0x64, 0x36, 0x32, 0x66, 0x38, 0x33, 0x61, 0x65, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x63, 0x62, 0x36, 0x64, 0x38, 0x61, 0x36, 0x33, 0x37, 0x39, 0x66, 0x39, 0x34, 0x61, 0x62, 0x61, 0x38, 0x62, 0x38, 0x38, 0x35, 0x36, 0x36, 0x39, 0x35, 0x36, 0x32, 0x63, 0x34, 0x64, 0x34, 0x34, 0x38, 0x65, 0x35, 0x36, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x30, 0x35, 0x34, 0x31, 0x35, 0x65, 0x31, 0x64, 0x37, 0x66, 0x64, 0x65, 0x63, 0x36, 0x64, 0x65, 0x64, 0x66, 0x62, 0x38, 0x39, 0x65, 0x35, 0x32, 0x31, 0x64, 0x31, 0x30, 0x35, 0x39, 0x32, 0x64, 0x37, 0x34, 0x33, 0x63, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x61, 0x63, 0x64, 0x61, 0x66, 0x34, 0x32, 0x32, 0x32, 0x36, 0x64, 0x31, 0x35, 0x63, 0x62, 0x31, 0x63, 0x66, 0x39, 0x38, 0x66, 0x61, 0x31, 0x35, 0x30, 0x34, 0x38, 0x63, 0x37, 0x66, 0x34, 0x63, 0x65, 0x65, 0x66, 0x65, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x33, 0x64, 0x66, 0x34, 0x63, 0x65, 0x38, 0x30, 0x63, 0x63, 0x62, 0x36, 0x32, 0x61, 0x37, 0x36, 0x62, 0x31, 0x32, 0x62, 0x63, 0x64, 0x66, 0x63, 0x65, 0x63, 0x63, 0x34, 0x36, 0x32, 0x38, 0x39, 0x39, 0x37, 0x33, 0x61, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x38, 0x63, 0x64, 0x32, 0x36, 0x65, 0x38, 0x32, 0x65, 0x37, 0x63, 0x36, 0x64, 0x65, 0x66, 0x64, 0x30, 0x32, 0x64, 0x66, 0x61, 0x64, 0x30, 0x37, 0x39, 0x37, 0x39, 0x30, 0x32, 0x31, 0x63, 0x62, 0x66, 0x37, 0x31, 0x35, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x61, 0x31, 0x37, 0x31, 0x32, 0x32, 0x66, 0x61, 0x33, 0x31, 0x62, 0x39, 0x38, 0x66, 0x31, 0x37, 0x31, 0x31, 0x64, 0x33, 0x32, 0x61, 0x39, 0x39, 0x66, 0x30, 0x33, 0x65, 0x63, 0x33, 0x32, 0x36, 0x66, 0x33, 0x33, 0x64, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x37, 0x39, 0x31, 0x64, 0x33, 0x35, 0x39, 0x62, 0x63, 0x33, 0x35, 0x33, 0x36, 0x61, 0x33, 0x31, 0x35, 0x64, 0x36, 0x33, 0x38, 0x32, 0x62, 0x38, 0x38, 0x33, 0x31, 0x31, 0x61, 0x66, 0x38, 0x65, 0x64, 0x36, 0x64, 0x61, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x33, 0x30, 0x65, 0x34, 0x39, 0x65, 0x35, 0x61, 0x62, 0x33, 0x31, 0x33, 0x32, 0x31, 0x34, 0x64, 0x32, 0x66, 0x30, 0x31, 0x64, 0x63, 0x61, 0x62, 0x63, 0x65, 0x38, 0x39, 0x34, 0x30, 0x62, 0x38, 0x31, 0x62, 0x31, 0x63, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x39, 0x62, 0x65, 0x39, 0x62, 0x39, 0x61, 0x62, 0x38, 0x36, 0x63, 0x36, 0x36, 0x62, 0x35, 0x39, 0x39, 0x36, 0x38, 0x65, 0x36, 0x37, 0x62, 0x38, 0x64, 0x34, 0x64, 0x63, 0x66, 0x66, 0x34, 0x36, 0x62, 0x31, 0x38, 0x31, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x64, 0x66, 0x63, 0x38, 0x38, 0x64, 0x37, 0x38, 0x62, 0x66, 0x31, 0x62, 0x32, 0x38, 0x35, 0x61, 0x63, 0x36, 0x34, 0x66, 0x31, 0x61, 0x64, 0x62, 0x33, 0x35, 0x64, 0x63, 0x31, 0x31, 0x66, 0x63, 0x62, 0x30, 0x33, 0x39, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x38, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x31, 0x33, 0x34, 0x63, 0x66, 0x62, 0x62, 0x31, 0x64, 0x66, 0x37, 0x61, 0x32, 0x30, 0x62, 0x30, 0x65, 0x64, 0x37, 0x30, 0x35, 0x37, 0x36, 0x32, 0x32, 0x65, 0x65, 0x65, 0x64, 0x32, 0x38, 0x30, 0x39, 0x34, 0x37, 0x64, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x39, 0x65, 0x63, 0x38, 0x65, 0x66, 0x65, 0x30, 0x38, 0x36, 0x38, 0x36, 0x66, 0x61, 0x35, 0x38, 0x63, 0x31, 0x38, 0x31, 0x33, 0x33, 0x35, 0x38, 0x37, 0x32, 0x62, 0x61, 0x36, 0x39, 0x38, 0x35, 0x36, 0x30, 0x65, 0x63, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x61, 0x38, 0x36, 0x33, 0x35, 0x37, 0x35, 0x37, 0x63, 0x35, 0x65, 0x38, 0x63, 0x31, 0x33, 0x34, 0x64, 0x32, 0x30, 0x64, 0x30, 0x32, 0x38, 0x63, 0x66, 0x37, 0x37, 0x38, 0x63, 0x66, 0x38, 0x36, 0x30, 0x39, 0x65, 0x34, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x39, 0x34, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x36, 0x35, 0x62, 0x32, 0x65, 0x37, 0x37, 0x33, 0x30, 0x66, 0x33, 0x36, 0x62, 0x37, 0x37, 0x36, 0x62, 0x35, 0x32, 0x64, 0x30, 0x63, 0x39, 0x64, 0x30, 0x32, 0x61, 0x64, 0x61, 0x35, 0x35, 0x64, 0x38, 0x65, 0x33, 0x63, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x38, 0x63, 0x65, 0x61, 0x32, 0x64, 0x65, 0x38, 0x34, 0x61, 0x38, 0x64, 0x66, 0x39, 0x39, 0x37, 0x66, 0x64, 0x33, 0x66, 0x38, 0x34, 0x65, 0x33, 0x30, 0x38, 0x33, 0x64, 0x39, 0x33, 0x64, 0x65, 0x35, 0x37, 0x63, 0x64, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x37, 0x65, 0x64, 0x39, 0x37, 0x34, 0x62, 0x36, 0x65, 0x32, 0x33, 0x34, 0x63, 0x65, 0x38, 0x31, 0x32, 0x34, 0x37, 0x34, 0x39, 0x38, 0x34, 0x32, 0x39, 0x61, 0x35, 0x62, 0x64, 0x34, 0x61, 0x30, 0x61, 0x32, 0x64, 0x31, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x61, 0x35, 0x33, 0x64, 0x63, 0x38, 0x63, 0x39, 0x35, 0x65, 0x39, 0x61, 0x34, 0x37, 0x32, 0x66, 0x65, 0x62, 0x61, 0x32, 0x63, 0x34, 0x65, 0x33, 0x32, 0x63, 0x31, 0x64, 0x63, 0x34, 0x64, 0x64, 0x37, 0x62, 0x61, 0x62, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x62, 0x37, 0x34, 0x30, 0x64, 0x66, 0x66, 0x38, 0x63, 0x34, 0x35, 0x37, 0x36, 0x36, 0x38, 0x66, 0x64, 0x66, 0x37, 0x34, 0x66, 0x36, 0x61, 0x32, 0x36, 0x36, 0x62, 0x66, 0x63, 0x31, 0x64, 0x63, 0x62, 0x37, 0x32, 0x33, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x62, 0x63, 0x32, 0x63, 0x63, 0x38, 0x65, 0x65, 0x64, 0x63, 0x30, 0x31, 0x39, 0x37, 0x30, 0x37, 0x30, 0x30, 0x65, 0x66, 0x63, 0x39, 0x63, 0x34, 0x66, 0x62, 0x33, 0x36, 0x37, 0x33, 0x35, 0x65, 0x39, 0x38, 0x63, 0x64, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x31, 0x63, 0x39, 0x36, 0x32, 0x30, 0x36, 0x33, 0x65, 0x30, 0x64, 0x35, 0x32, 0x39, 0x35, 0x39, 0x34, 0x31, 0x66, 0x32, 0x31, 0x30, 0x64, 0x63, 0x61, 0x33, 0x61, 0x62, 0x35, 0x33, 0x31, 0x65, 0x65, 0x63, 0x38, 0x38, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x34, 0x37, 0x35, 0x37, 0x31, 0x64, 0x61, 0x63, 0x62, 0x62, 0x33, 0x65, 0x63, 0x62, 0x62, 0x36, 0x64, 0x31, 0x63, 0x66, 0x30, 0x62, 0x30, 0x63, 0x38, 0x66, 0x33, 0x38, 0x33, 0x38, 0x65, 0x35, 0x32, 0x33, 0x32, 0x34, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x31, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x37, 0x36, 0x34, 0x65, 0x33, 0x36, 0x37, 0x37, 0x65, 0x65, 0x66, 0x36, 0x30, 0x34, 0x63, 0x62, 0x63, 0x35, 0x39, 0x61, 0x65, 0x64, 0x32, 0x34, 0x61, 0x62, 0x64, 0x63, 0x35, 0x36, 0x36, 0x62, 0x30, 0x39, 0x66, 0x63, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x61, 0x61, 0x36, 0x32, 0x32, 0x38, 0x38, 0x31, 0x32, 0x33, 0x36, 0x64, 0x64, 0x30, 0x66, 0x34, 0x39, 0x34, 0x30, 0x63, 0x32, 0x34, 0x63, 0x33, 0x32, 0x34, 0x66, 0x66, 0x38, 0x62, 0x37, 0x62, 0x37, 0x65, 0x32, 0x31, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x61, 0x37, 0x64, 0x33, 0x30, 0x36, 0x66, 0x35, 0x31, 0x30, 0x63, 0x64, 0x35, 0x38, 0x33, 0x35, 0x39, 0x34, 0x32, 0x38, 0x63, 0x30, 0x64, 0x32, 0x66, 0x37, 0x63, 0x33, 0x36, 0x30, 0x39, 0x64, 0x35, 0x36, 0x37, 0x34, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x38, 0x33, 0x63, 0x31, 0x37, 0x30, 0x31, 0x64, 0x62, 0x30, 0x33, 0x38, 0x38, 0x62, 0x36, 0x38, 0x32, 0x31, 0x30, 0x64, 0x30, 0x30, 0x66, 0x35, 0x37, 0x31, 0x37, 0x63, 0x64, 0x39, 0x62, 0x64, 0x33, 0x32, 0x32, 0x63, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x37, 0x64, 0x35, 0x61, 0x32, 0x36, 0x64, 0x37, 0x61, 0x64, 0x38, 0x66, 0x38, 0x65, 0x37, 0x30, 0x36, 0x30, 0x30, 0x66, 0x37, 0x30, 0x61, 0x33, 0x39, 0x38, 0x64, 0x64, 0x61, 0x61, 0x31, 0x63, 0x32, 0x64, 0x62, 0x32, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x37, 0x36, 0x37, 0x62, 0x66, 0x37, 0x66, 0x64, 0x32, 0x61, 0x66, 0x39, 0x35, 0x62, 0x37, 0x32, 0x65, 0x39, 0x33, 0x31, 0x32, 0x64, 0x61, 0x39, 0x34, 0x34, 0x33, 0x63, 0x62, 0x31, 0x36, 0x38, 0x38, 0x65, 0x34, 0x33, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x61, 0x38, 0x35, 0x64, 0x36, 0x64, 0x32, 0x34, 0x33, 0x66, 0x62, 0x31, 0x64, 0x66, 0x62, 0x37, 0x64, 0x31, 0x64, 0x32, 0x64, 0x34, 0x34, 0x66, 0x35, 0x33, 0x36, 0x65, 0x39, 0x34, 0x37, 0x61, 0x34, 0x63, 0x65, 0x65, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x61, 0x39, 0x64, 0x61, 0x64, 0x34, 0x32, 0x65, 0x31, 0x36, 0x33, 0x32, 0x62, 0x61, 0x33, 0x65, 0x34, 0x65, 0x34, 0x39, 0x36, 0x32, 0x33, 0x66, 0x61, 0x62, 0x36, 0x32, 0x61, 0x31, 0x37, 0x65, 0x34, 0x64, 0x33, 0x36, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x65, 0x30, 0x63, 0x62, 0x64, 0x36, 0x37, 0x66, 0x31, 0x38, 0x61, 0x63, 0x64, 0x62, 0x37, 0x61, 0x36, 0x32, 0x39, 0x31, 0x65, 0x31, 0x32, 0x35, 0x34, 0x64, 0x62, 0x33, 0x32, 0x65, 0x30, 0x39, 0x37, 0x32, 0x37, 0x33, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x64, 0x65, 0x35, 0x65, 0x34, 0x33, 0x34, 0x66, 0x64, 0x63, 0x64, 0x64, 0x36, 0x38, 0x38, 0x66, 0x31, 0x63, 0x33, 0x31, 0x62, 0x36, 0x66, 0x62, 0x35, 0x31, 0x32, 0x63, 0x62, 0x31, 0x39, 0x36, 0x37, 0x32, 0x34, 0x37, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x36, 0x33, 0x64, 0x33, 0x38, 0x65, 0x65, 0x38, 0x62, 0x39, 0x30, 0x65, 0x30, 0x65, 0x36, 0x65, 0x64, 0x38, 0x66, 0x31, 0x39, 0x32, 0x65, 0x64, 0x61, 0x30, 0x35, 0x31, 0x62, 0x32, 0x64, 0x36, 0x61, 0x35, 0x38, 0x62, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x37, 0x39, 0x62, 0x62, 0x34, 0x64, 0x39, 0x38, 0x36, 0x36, 0x31, 0x34, 0x33, 0x61, 0x36, 0x64, 0x61, 0x37, 0x32, 0x61, 0x65, 0x37, 0x61, 0x63, 0x30, 0x30, 0x32, 0x32, 0x30, 0x36, 0x32, 0x39, 0x38, 0x31, 0x33, 0x31, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x34, 0x31, 0x33, 0x66, 0x35, 0x61, 0x37, 0x63, 0x32, 0x64, 0x39, 0x61, 0x34, 0x62, 0x38, 0x31, 0x30, 0x38, 0x32, 0x38, 0x39, 0x65, 0x66, 0x36, 0x65, 0x63, 0x64, 0x32, 0x37, 0x31, 0x37, 0x38, 0x31, 0x35, 0x32, 0x34, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x31, 0x61, 0x35, 0x61, 0x37, 0x62, 0x33, 0x34, 0x31, 0x66, 0x39, 0x39, 0x63, 0x35, 0x33, 0x35, 0x31, 0x34, 0x34, 0x65, 0x32, 0x30, 0x62, 0x65, 0x39, 0x63, 0x36, 0x62, 0x33, 0x62, 0x62, 0x34, 0x63, 0x32, 0x38, 0x65, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x33, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x33, 0x66, 0x31, 0x34, 0x36, 0x31, 0x37, 0x38, 0x36, 0x30, 0x35, 0x65, 0x36, 0x36, 0x64, 0x35, 0x31, 0x37, 0x62, 0x65, 0x37, 0x38, 0x32, 0x65, 0x66, 0x30, 0x62, 0x33, 0x63, 0x36, 0x31, 0x61, 0x34, 0x65, 0x31, 0x39, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x31, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x36, 0x63, 0x30, 0x34, 0x37, 0x38, 0x31, 0x63, 0x62, 0x35, 0x65, 0x36, 0x37, 0x64, 0x64, 0x65, 0x33, 0x32, 0x33, 0x35, 0x64, 0x37, 0x66, 0x38, 0x36, 0x32, 0x30, 0x65, 0x31, 0x61, 0x62, 0x36, 0x36, 0x33, 0x61, 0x39, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x66, 0x38, 0x32, 0x61, 0x38, 0x37, 0x65, 0x35, 0x39, 0x61, 0x33, 0x39, 0x64, 0x30, 0x64, 0x32, 0x38, 0x30, 0x38, 0x66, 0x30, 0x37, 0x35, 0x31, 0x65, 0x62, 0x37, 0x32, 0x63, 0x32, 0x33, 0x32, 0x39, 0x63, 0x64, 0x63, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x37, 0x37, 0x65, 0x62, 0x63, 0x65, 0x64, 0x37, 0x65, 0x32, 0x31, 0x35, 0x66, 0x30, 0x39, 0x32, 0x30, 0x65, 0x38, 0x63, 0x32, 0x62, 0x38, 0x37, 0x30, 0x30, 0x32, 0x34, 0x66, 0x36, 0x65, 0x63, 0x62, 0x32, 0x66, 0x66, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x36, 0x39, 0x37, 0x66, 0x66, 0x32, 0x32, 0x63, 0x61, 0x35, 0x34, 0x37, 0x62, 0x66, 0x63, 0x39, 0x35, 0x65, 0x33, 0x33, 0x64, 0x39, 0x36, 0x30, 0x64, 0x61, 0x36, 0x30, 0x35, 0x63, 0x36, 0x37, 0x36, 0x33, 0x66, 0x33, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x30, 0x61, 0x66, 0x35, 0x32, 0x30, 0x37, 0x36, 0x30, 0x30, 0x39, 0x63, 0x61, 0x37, 0x33, 0x37, 0x38, 0x31, 0x62, 0x37, 0x30, 0x65, 0x34, 0x33, 0x62, 0x39, 0x35, 0x39, 0x31, 0x36, 0x61, 0x36, 0x32, 0x32, 0x30, 0x33, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x34, 0x31, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x64, 0x63, 0x30, 0x34, 0x32, 0x34, 0x63, 0x36, 0x39, 0x36, 0x39, 0x64, 0x37, 0x39, 0x38, 0x33, 0x35, 0x38, 0x62, 0x33, 0x39, 0x33, 0x62, 0x31, 0x39, 0x33, 0x33, 0x61, 0x31, 0x66, 0x35, 0x31, 0x62, 0x65, 0x65, 0x30, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x62, 0x61, 0x35, 0x36, 0x66, 0x36, 0x33, 0x61, 0x34, 0x38, 0x62, 0x63, 0x30, 0x38, 0x31, 0x37, 0x64, 0x36, 0x62, 0x39, 0x37, 0x30, 0x33, 0x39, 0x30, 0x33, 0x39, 0x61, 0x37, 0x61, 0x64, 0x36, 0x32, 0x66, 0x61, 0x65, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x64, 0x31, 0x33, 0x39, 0x65, 0x32, 0x65, 0x34, 0x30, 0x63, 0x37, 0x62, 0x39, 0x37, 0x32, 0x33, 0x39, 0x64, 0x32, 0x33, 0x64, 0x66, 0x61, 0x63, 0x61, 0x33, 0x33, 0x38, 0x35, 0x38, 0x66, 0x36, 0x30, 0x32, 0x64, 0x32, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x36, 0x31, 0x37, 0x30, 0x66, 0x66, 0x36, 0x36, 0x39, 0x37, 0x38, 0x65, 0x37, 0x37, 0x33, 0x62, 0x62, 0x36, 0x32, 0x31, 0x62, 0x66, 0x37, 0x32, 0x62, 0x31, 0x62, 0x61, 0x37, 0x62, 0x65, 0x33, 0x61, 0x37, 0x66, 0x38, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x36, 0x38, 0x35, 0x32, 0x33, 0x61, 0x39, 0x30, 0x66, 0x30, 0x32, 0x39, 0x33, 0x64, 0x36, 0x35, 0x63, 0x35, 0x33, 0x38, 0x64, 0x32, 0x64, 0x64, 0x36, 0x63, 0x35, 0x37, 0x36, 0x37, 0x33, 0x37, 0x31, 0x30, 0x31, 0x39, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x62, 0x35, 0x61, 0x30, 0x66, 0x34, 0x38, 0x30, 0x32, 0x63, 0x38, 0x36, 0x34, 0x38, 0x30, 0x30, 0x39, 0x65, 0x38, 0x61, 0x36, 0x39, 0x39, 0x38, 0x61, 0x66, 0x33, 0x35, 0x32, 0x63, 0x64, 0x65, 0x38, 0x37, 0x35, 0x34, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x34, 0x33, 0x38, 0x32, 0x39, 0x61, 0x63, 0x37, 0x38, 0x37, 0x66, 0x66, 0x38, 0x38, 0x61, 0x61, 0x66, 0x31, 0x38, 0x33, 0x62, 0x61, 0x33, 0x35, 0x32, 0x61, 0x61, 0x64, 0x62, 0x66, 0x35, 0x61, 0x31, 0x35, 0x62, 0x31, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x32, 0x32, 0x61, 0x30, 0x62, 0x33, 0x38, 0x38, 0x36, 0x36, 0x38, 0x64, 0x31, 0x61, 0x65, 0x32, 0x36, 0x34, 0x33, 0x65, 0x37, 0x37, 0x31, 0x64, 0x61, 0x63, 0x66, 0x33, 0x38, 0x61, 0x34, 0x33, 0x34, 0x32, 0x32, 0x33, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x32, 0x61, 0x63, 0x62, 0x36, 0x32, 0x34, 0x62, 0x30, 0x38, 0x63, 0x30, 0x35, 0x35, 0x31, 0x30, 0x31, 0x38, 0x39, 0x62, 0x62, 0x62, 0x65, 0x32, 0x31, 0x65, 0x36, 0x35, 0x32, 0x34, 0x64, 0x36, 0x34, 0x34, 0x63, 0x63, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x30, 0x35, 0x33, 0x38, 0x65, 0x64, 0x37, 0x31, 0x64, 0x61, 0x31, 0x31, 0x35, 0x35, 0x65, 0x30, 0x66, 0x33, 0x62, 0x64, 0x65, 0x35, 0x36, 0x36, 0x37, 0x63, 0x65, 0x62, 0x38, 0x34, 0x33, 0x31, 0x38, 0x61, 0x31, 0x61, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x39, 0x39, 0x34, 0x63, 0x64, 0x38, 0x33, 0x61, 0x61, 0x32, 0x36, 0x34, 0x30, 0x61, 0x39, 0x37, 0x62, 0x32, 0x36, 0x30, 0x30, 0x62, 0x34, 0x31, 0x33, 0x33, 0x39, 0x64, 0x31, 0x65, 0x30, 0x64, 0x33, 0x65, 0x64, 0x65, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x34, 0x36, 0x30, 0x63, 0x31, 0x62, 0x33, 0x37, 0x39, 0x64, 0x64, 0x62, 0x31, 0x39, 0x61, 0x38, 0x63, 0x38, 0x35, 0x62, 0x34, 0x63, 0x36, 0x37, 0x34, 0x37, 0x30, 0x35, 0x30, 0x64, 0x64, 0x66, 0x31, 0x37, 0x61, 0x38, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x61, 0x37, 0x36, 0x39, 0x66, 0x61, 0x66, 0x64, 0x65, 0x63, 0x66, 0x34, 0x61, 0x36, 0x33, 0x38, 0x37, 0x36, 0x32, 0x64, 0x35, 0x62, 0x61, 0x33, 0x39, 0x36, 0x39, 0x64, 0x66, 0x36, 0x33, 0x31, 0x32, 0x30, 0x61, 0x34, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x33, 0x37, 0x35, 0x62, 0x38, 0x36, 0x36, 0x30, 0x30, 0x63, 0x34, 0x30, 0x63, 0x63, 0x61, 0x38, 0x62, 0x32, 0x36, 0x37, 0x36, 0x62, 0x37, 0x61, 0x31, 0x61, 0x31, 0x64, 0x31, 0x36, 0x34, 0x34, 0x63, 0x35, 0x66, 0x35, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x65, 0x65, 0x30, 0x66, 0x63, 0x36, 0x33, 0x65, 0x62, 0x66, 0x31, 0x62, 0x31, 0x66, 0x63, 0x34, 0x39, 0x64, 0x37, 0x62, 0x62, 0x33, 0x38, 0x66, 0x38, 0x38, 0x36, 0x33, 0x38, 0x32, 0x33, 0x61, 0x32, 0x65, 0x31, 0x37, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x35, 0x31, 0x37, 0x33, 0x36, 0x66, 0x62, 0x35, 0x39, 0x62, 0x39, 0x31, 0x66, 0x65, 0x65, 0x39, 0x63, 0x39, 0x33, 0x61, 0x61, 0x30, 0x62, 0x64, 0x36, 0x65, 0x61, 0x32, 0x66, 0x37, 0x62, 0x32, 0x35, 0x30, 0x36, 0x31, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x31, 0x64, 0x39, 0x65, 0x64, 0x38, 0x30, 0x62, 0x35, 0x62, 0x64, 0x32, 0x37, 0x63, 0x66, 0x39, 0x66, 0x31, 0x32, 0x32, 0x36, 0x66, 0x32, 0x36, 0x37, 0x35, 0x33, 0x32, 0x35, 0x38, 0x65, 0x65, 0x35, 0x66, 0x39, 0x62, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x62, 0x36, 0x62, 0x36, 0x38, 0x36, 0x31, 0x31, 0x31, 0x36, 0x39, 0x31, 0x65, 0x65, 0x36, 0x61, 0x61, 0x31, 0x39, 0x37, 0x63, 0x37, 0x32, 0x33, 0x31, 0x61, 0x38, 0x38, 0x64, 0x63, 0x36, 0x30, 0x62, 0x64, 0x32, 0x39, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x62, 0x34, 0x61, 0x34, 0x38, 0x35, 0x33, 0x35, 0x37, 0x37, 0x61, 0x39, 0x64, 0x62, 0x63, 0x63, 0x32, 0x65, 0x37, 0x39, 0x35, 0x62, 0x65, 0x30, 0x33, 0x31, 0x30, 0x64, 0x31, 0x62, 0x65, 0x64, 0x32, 0x38, 0x36, 0x34, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x37, 0x35, 0x38, 0x65, 0x30, 0x34, 0x39, 0x63, 0x64, 0x39, 0x38, 0x62, 0x63, 0x65, 0x61, 0x31, 0x32, 0x32, 0x37, 0x37, 0x61, 0x36, 0x37, 0x36, 0x66, 0x39, 0x32, 0x39, 0x37, 0x33, 0x36, 0x32, 0x38, 0x39, 0x30, 0x30, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x62, 0x35, 0x30, 0x38, 0x31, 0x33, 0x31, 0x34, 0x36, 0x61, 0x39, 0x61, 0x64, 0x64, 0x34, 0x32, 0x65, 0x65, 0x32, 0x32, 0x30, 0x33, 0x38, 0x63, 0x39, 0x66, 0x31, 0x66, 0x37, 0x34, 0x36, 0x39, 0x64, 0x34, 0x37, 0x66, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x65, 0x34, 0x62, 0x35, 0x38, 0x31, 0x33, 0x38, 0x35, 0x63, 0x66, 0x37, 0x66, 0x63, 0x39, 0x66, 0x65, 0x38, 0x63, 0x37, 0x37, 0x64, 0x31, 0x33, 0x31, 0x66, 0x65, 0x32, 0x65, 0x65, 0x37, 0x37, 0x32, 0x34, 0x63, 0x37, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x38, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x61, 0x35, 0x61, 0x30, 0x32, 0x34, 0x32, 0x33, 0x30, 0x61, 0x35, 0x37, 0x63, 0x63, 0x63, 0x36, 0x36, 0x36, 0x37, 0x36, 0x30, 0x62, 0x38, 0x39, 0x62, 0x30, 0x65, 0x32, 0x36, 0x63, 0x61, 0x66, 0x64, 0x31, 0x38, 0x39, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x61, 0x66, 0x39, 0x30, 0x38, 0x37, 0x65, 0x30, 0x35, 0x31, 0x36, 0x37, 0x37, 0x31, 0x35, 0x34, 0x39, 0x37, 0x63, 0x39, 0x61, 0x35, 0x61, 0x37, 0x34, 0x39, 0x31, 0x38, 0x39, 0x34, 0x38, 0x39, 0x30, 0x30, 0x34, 0x64, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x64, 0x32, 0x31, 0x63, 0x31, 0x64, 0x65, 0x63, 0x63, 0x66, 0x62, 0x66, 0x31, 0x63, 0x35, 0x63, 0x64, 0x39, 0x36, 0x36, 0x38, 0x38, 0x61, 0x32, 0x34, 0x37, 0x36, 0x62, 0x36, 0x39, 0x62, 0x61, 0x30, 0x37, 0x63, 0x65, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x30, 0x38, 0x34, 0x33, 0x35, 0x32, 0x30, 0x34, 0x37, 0x39, 0x33, 0x37, 0x36, 0x34, 0x66, 0x35, 0x66, 0x63, 0x62, 0x65, 0x36, 0x35, 0x65, 0x62, 0x35, 0x31, 0x30, 0x66, 0x35, 0x61, 0x37, 0x34, 0x34, 0x61, 0x36, 0x35, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x37, 0x36, 0x64, 0x63, 0x65, 0x32, 0x61, 0x66, 0x32, 0x65, 0x63, 0x38, 0x64, 0x63, 0x64, 0x61, 0x37, 0x34, 0x31, 0x62, 0x37, 0x65, 0x37, 0x33, 0x34, 0x35, 0x36, 0x36, 0x34, 0x36, 0x38, 0x31, 0x64, 0x39, 0x33, 0x36, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x62, 0x34, 0x37, 0x63, 0x34, 0x64, 0x30, 0x65, 0x64, 0x36, 0x30, 0x31, 0x38, 0x38, 0x34, 0x32, 0x65, 0x36, 0x63, 0x66, 0x63, 0x38, 0x36, 0x33, 0x30, 0x61, 0x63, 0x33, 0x61, 0x33, 0x31, 0x34, 0x32, 0x65, 0x35, 0x65, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x31, 0x39, 0x38, 0x63, 0x38, 0x63, 0x61, 0x31, 0x62, 0x33, 0x39, 0x39, 0x66, 0x37, 0x35, 0x32, 0x31, 0x35, 0x36, 0x31, 0x66, 0x64, 0x35, 0x33, 0x38, 0x34, 0x61, 0x37, 0x31, 0x33, 0x32, 0x66, 0x62, 0x61, 0x34, 0x38, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x63, 0x31, 0x33, 0x66, 0x65, 0x30, 0x64, 0x36, 0x63, 0x65, 0x38, 0x37, 0x66, 0x64, 0x35, 0x30, 0x65, 0x30, 0x33, 0x64, 0x65, 0x66, 0x39, 0x66, 0x61, 0x36, 0x34, 0x30, 0x30, 0x35, 0x30, 0x39, 0x62, 0x64, 0x37, 0x30, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x31, 0x37, 0x66, 0x31, 0x36, 0x63, 0x32, 0x38, 0x64, 0x31, 0x33, 0x32, 0x62, 0x62, 0x34, 0x30, 0x65, 0x33, 0x62, 0x61, 0x33, 0x36, 0x63, 0x36, 0x61, 0x65, 0x66, 0x31, 0x33, 0x31, 0x63, 0x34, 0x36, 0x32, 0x64, 0x61, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x30, 0x32, 0x33, 0x61, 0x66, 0x35, 0x37, 0x64, 0x35, 0x38, 0x34, 0x64, 0x38, 0x34, 0x35, 0x65, 0x36, 0x39, 0x38, 0x37, 0x33, 0x36, 0x66, 0x31, 0x33, 0x30, 0x64, 0x62, 0x39, 0x64, 0x62, 0x34, 0x30, 0x64, 0x66, 0x61, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x31, 0x38, 0x36, 0x32, 0x37, 0x62, 0x38, 0x38, 0x33, 0x35, 0x31, 0x66, 0x65, 0x64, 0x65, 0x37, 0x39, 0x36, 0x64, 0x33, 0x66, 0x33, 0x30, 0x38, 0x33, 0x33, 0x36, 0x34, 0x66, 0x62, 0x64, 0x34, 0x38, 0x38, 0x37, 0x62, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x62, 0x36, 0x65, 0x39, 0x30, 0x36, 0x31, 0x61, 0x34, 0x65, 0x62, 0x30, 0x39, 0x36, 0x31, 0x36, 0x30, 0x37, 0x37, 0x37, 0x65, 0x32, 0x36, 0x37, 0x36, 0x32, 0x63, 0x66, 0x34, 0x38, 0x62, 0x64, 0x64, 0x38, 0x62, 0x35, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x30, 0x37, 0x33, 0x65, 0x66, 0x63, 0x31, 0x37, 0x64, 0x30, 0x35, 0x63, 0x61, 0x62, 0x33, 0x31, 0x39, 0x35, 0x63, 0x32, 0x64, 0x62, 0x33, 0x33, 0x32, 0x62, 0x36, 0x31, 0x39, 0x38, 0x34, 0x37, 0x37, 0x37, 0x61, 0x36, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x36, 0x61, 0x38, 0x35, 0x34, 0x61, 0x33, 0x63, 0x35, 0x64, 0x63, 0x33, 0x36, 0x64, 0x31, 0x63, 0x34, 0x39, 0x66, 0x34, 0x63, 0x38, 0x37, 0x64, 0x36, 0x64, 0x62, 0x33, 0x33, 0x33, 0x62, 0x35, 0x37, 0x65, 0x34, 0x61, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x32, 0x35, 0x39, 0x38, 0x33, 0x38, 0x36, 0x30, 0x61, 0x31, 0x63, 0x62, 0x34, 0x36, 0x32, 0x33, 0x63, 0x37, 0x32, 0x34, 0x38, 0x30, 0x61, 0x63, 0x31, 0x36, 0x32, 0x37, 0x32, 0x62, 0x30, 0x63, 0x39, 0x35, 0x65, 0x35, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x36, 0x30, 0x64, 0x63, 0x35, 0x31, 0x65, 0x65, 0x30, 0x37, 0x62, 0x64, 0x64, 0x61, 0x61, 0x62, 0x61, 0x62, 0x62, 0x39, 0x65, 0x65, 0x37, 0x34, 0x34, 0x62, 0x33, 0x39, 0x33, 0x63, 0x37, 0x66, 0x34, 0x37, 0x39, 0x33, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x31, 0x32, 0x37, 0x62, 0x62, 0x66, 0x38, 0x65, 0x33, 0x31, 0x31, 0x63, 0x61, 0x65, 0x61, 0x32, 0x62, 0x61, 0x35, 0x30, 0x32, 0x61, 0x33, 0x33, 0x66, 0x65, 0x63, 0x65, 0x64, 0x33, 0x66, 0x37, 0x33, 0x30, 0x62, 0x61, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x64, 0x35, 0x32, 0x31, 0x61, 0x38, 0x64, 0x39, 0x37, 0x37, 0x39, 0x30, 0x32, 0x33, 0x66, 0x37, 0x31, 0x36, 0x34, 0x64, 0x32, 0x33, 0x33, 0x63, 0x33, 0x62, 0x36, 0x34, 0x32, 0x30, 0x66, 0x66, 0x64, 0x32, 0x32, 0x33, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x32, 0x62, 0x37, 0x64, 0x38, 0x62, 0x36, 0x30, 0x38, 0x64, 0x32, 0x38, 0x62, 0x37, 0x37, 0x66, 0x35, 0x63, 0x61, 0x61, 0x39, 0x63, 0x64, 0x36, 0x34, 0x35, 0x32, 0x34, 0x32, 0x61, 0x38, 0x32, 0x33, 0x65, 0x34, 0x63, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x38, 0x36, 0x36, 0x64, 0x30, 0x33, 0x32, 0x64, 0x34, 0x30, 0x35, 0x61, 0x62, 0x64, 0x64, 0x36, 0x35, 0x63, 0x66, 0x36, 0x35, 0x31, 0x34, 0x31, 0x31, 0x64, 0x38, 0x30, 0x33, 0x37, 0x39, 0x36, 0x63, 0x32, 0x32, 0x33, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x35, 0x31, 0x62, 0x32, 0x64, 0x63, 0x39, 0x64, 0x32, 0x34, 0x37, 0x61, 0x31, 0x64, 0x30, 0x65, 0x35, 0x62, 0x63, 0x33, 0x36, 0x63, 0x61, 0x33, 0x31, 0x35, 0x36, 0x66, 0x37, 0x61, 0x66, 0x32, 0x31, 0x66, 0x66, 0x39, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x34, 0x64, 0x39, 0x62, 0x65, 0x61, 0x30, 0x61, 0x37, 0x62, 0x39, 0x66, 0x31, 0x34, 0x30, 0x32, 0x32, 0x30, 0x66, 0x64, 0x38, 0x62, 0x39, 0x30, 0x39, 0x37, 0x63, 0x66, 0x62, 0x66, 0x64, 0x35, 0x65, 0x64, 0x66, 0x35, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x33, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x38, 0x36, 0x65, 0x35, 0x65, 0x38, 0x65, 0x31, 0x35, 0x62, 0x35, 0x33, 0x39, 0x30, 0x39, 0x36, 0x30, 0x30, 0x65, 0x34, 0x31, 0x33, 0x30, 0x38, 0x64, 0x61, 0x62, 0x37, 0x35, 0x66, 0x30, 0x65, 0x32, 0x34, 0x65, 0x34, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x31, 0x36, 0x34, 0x61, 0x61, 0x32, 0x36, 0x31, 0x63, 0x30, 0x39, 0x61, 0x64, 0x39, 0x62, 0x32, 0x62, 0x35, 0x30, 0x36, 0x38, 0x64, 0x34, 0x35, 0x33, 0x65, 0x64, 0x38, 0x65, 0x62, 0x36, 0x61, 0x61, 0x31, 0x33, 0x30, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x61, 0x61, 0x66, 0x38, 0x63, 0x31, 0x61, 0x63, 0x30, 0x31, 0x32, 0x66, 0x38, 0x37, 0x35, 0x32, 0x64, 0x34, 0x63, 0x30, 0x39, 0x62, 0x62, 0x34, 0x36, 0x36, 0x30, 0x37, 0x62, 0x36, 0x36, 0x35, 0x31, 0x64, 0x35, 0x63, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x37, 0x38, 0x36, 0x61, 0x31, 0x30, 0x64, 0x34, 0x34, 0x37, 0x66, 0x34, 0x38, 0x34, 0x64, 0x33, 0x33, 0x32, 0x34, 0x34, 0x63, 0x63, 0x62, 0x37, 0x66, 0x61, 0x63, 0x64, 0x38, 0x62, 0x34, 0x32, 0x37, 0x62, 0x35, 0x62, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x30, 0x63, 0x35, 0x37, 0x62, 0x34, 0x37, 0x31, 0x35, 0x30, 0x66, 0x39, 0x35, 0x61, 0x61, 0x36, 0x61, 0x37, 0x65, 0x31, 0x36, 0x61, 0x62, 0x39, 0x62, 0x31, 0x63, 0x62, 0x66, 0x35, 0x34, 0x33, 0x32, 0x38, 0x39, 0x37, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x37, 0x34, 0x37, 0x32, 0x33, 0x37, 0x38, 0x30, 0x36, 0x66, 0x65, 0x64, 0x33, 0x66, 0x38, 0x32, 0x38, 0x61, 0x36, 0x38, 0x35, 0x32, 0x65, 0x62, 0x30, 0x38, 0x36, 0x37, 0x66, 0x37, 0x39, 0x30, 0x32, 0x37, 0x61, 0x66, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x36, 0x38, 0x64, 0x62, 0x34, 0x64, 0x35, 0x37, 0x65, 0x34, 0x64, 0x36, 0x37, 0x34, 0x36, 0x32, 0x64, 0x37, 0x33, 0x33, 0x63, 0x36, 0x39, 0x61, 0x39, 0x65, 0x30, 0x66, 0x65, 0x32, 0x36, 0x65, 0x32, 0x31, 0x38, 0x33, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x36, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x38, 0x38, 0x66, 0x38, 0x61, 0x31, 0x33, 0x33, 0x38, 0x66, 0x63, 0x37, 0x63, 0x31, 0x30, 0x39, 0x37, 0x36, 0x61, 0x62, 0x63, 0x64, 0x33, 0x66, 0x62, 0x38, 0x64, 0x33, 0x38, 0x35, 0x35, 0x34, 0x62, 0x35, 0x65, 0x63, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x65, 0x61, 0x34, 0x64, 0x37, 0x32, 0x61, 0x36, 0x37, 0x62, 0x35, 0x62, 0x33, 0x65, 0x30, 0x66, 0x33, 0x31, 0x35, 0x35, 0x35, 0x39, 0x66, 0x35, 0x32, 0x62, 0x64, 0x30, 0x36, 0x31, 0x34, 0x64, 0x37, 0x31, 0x33, 0x30, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x61, 0x65, 0x62, 0x39, 0x31, 0x30, 0x36, 0x37, 0x36, 0x31, 0x37, 0x64, 0x63, 0x66, 0x38, 0x62, 0x34, 0x34, 0x31, 0x37, 0x32, 0x62, 0x30, 0x32, 0x61, 0x66, 0x36, 0x31, 0x35, 0x36, 0x37, 0x34, 0x38, 0x33, 0x35, 0x64, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x36, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x31, 0x61, 0x31, 0x33, 0x62, 0x61, 0x38, 0x65, 0x39, 0x35, 0x31, 0x36, 0x37, 0x62, 0x38, 0x30, 0x33, 0x33, 0x31, 0x62, 0x35, 0x32, 0x64, 0x36, 0x39, 0x65, 0x33, 0x37, 0x30, 0x35, 0x34, 0x66, 0x65, 0x37, 0x61, 0x38, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x37, 0x61, 0x38, 0x30, 0x66, 0x31, 0x37, 0x30, 0x31, 0x39, 0x37, 0x64, 0x39, 0x36, 0x63, 0x64, 0x63, 0x63, 0x34, 0x61, 0x62, 0x36, 0x63, 0x62, 0x61, 0x36, 0x32, 0x37, 0x62, 0x34, 0x61, 0x66, 0x61, 0x36, 0x65, 0x31, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x61, 0x66, 0x30, 0x34, 0x30, 0x61, 0x30, 0x63, 0x63, 0x32, 0x33, 0x33, 0x37, 0x61, 0x37, 0x36, 0x61, 0x66, 0x32, 0x38, 0x38, 0x31, 0x35, 0x34, 0x63, 0x37, 0x35, 0x36, 0x31, 0x65, 0x31, 0x61, 0x32, 0x33, 0x33, 0x33, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x36, 0x31, 0x39, 0x30, 0x39, 0x30, 0x34, 0x62, 0x38, 0x64, 0x30, 0x37, 0x39, 0x65, 0x63, 0x30, 0x31, 0x30, 0x65, 0x34, 0x36, 0x32, 0x63, 0x62, 0x66, 0x66, 0x63, 0x39, 0x30, 0x38, 0x33, 0x34, 0x66, 0x66, 0x61, 0x61, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x33, 0x33, 0x30, 0x34, 0x64, 0x64, 0x37, 0x61, 0x35, 0x37, 0x32, 0x30, 0x62, 0x32, 0x39, 0x63, 0x31, 0x61, 0x31, 0x30, 0x66, 0x36, 0x30, 0x33, 0x34, 0x32, 0x32, 0x31, 0x39, 0x66, 0x34, 0x38, 0x30, 0x33, 0x32, 0x66, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x31, 0x33, 0x31, 0x33, 0x35, 0x32, 0x35, 0x32, 0x33, 0x38, 0x61, 0x32, 0x31, 0x63, 0x37, 0x36, 0x37, 0x34, 0x35, 0x37, 0x61, 0x39, 0x31, 0x33, 0x37, 0x34, 0x66, 0x30, 0x32, 0x32, 0x30, 0x30, 0x63, 0x35, 0x35, 0x34, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x34, 0x61, 0x32, 0x66, 0x32, 0x63, 0x66, 0x38, 0x36, 0x63, 0x66, 0x33, 0x65, 0x34, 0x33, 0x33, 0x37, 0x35, 0x66, 0x33, 0x36, 0x30, 0x61, 0x34, 0x37, 0x33, 0x34, 0x36, 0x39, 0x31, 0x31, 0x39, 0x35, 0x66, 0x31, 0x34, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x38, 0x31, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x30, 0x32, 0x30, 0x37, 0x37, 0x39, 0x62, 0x35, 0x64, 0x64, 0x64, 0x33, 0x64, 0x66, 0x32, 0x32, 0x38, 0x61, 0x30, 0x30, 0x63, 0x62, 0x34, 0x38, 0x63, 0x32, 0x66, 0x63, 0x39, 0x37, 0x39, 0x64, 0x61, 0x36, 0x61, 0x65, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x30, 0x36, 0x66, 0x62, 0x37, 0x33, 0x32, 0x34, 0x65, 0x39, 0x64, 0x65, 0x62, 0x37, 0x39, 0x65, 0x31, 0x39, 0x39, 0x30, 0x33, 0x34, 0x39, 0x36, 0x64, 0x36, 0x39, 0x36, 0x31, 0x62, 0x39, 0x62, 0x65, 0x35, 0x36, 0x36, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x65, 0x31, 0x36, 0x30, 0x65, 0x33, 0x63, 0x64, 0x36, 0x30, 0x61, 0x65, 0x33, 0x31, 0x62, 0x39, 0x64, 0x36, 0x37, 0x34, 0x32, 0x64, 0x36, 0x38, 0x65, 0x31, 0x34, 0x65, 0x37, 0x36, 0x62, 0x64, 0x39, 0x36, 0x63, 0x35, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x37, 0x64, 0x38, 0x65, 0x38, 0x36, 0x64, 0x36, 0x65, 0x65, 0x62, 0x30, 0x32, 0x35, 0x34, 0x35, 0x61, 0x61, 0x64, 0x39, 0x30, 0x65, 0x39, 0x31, 0x33, 0x32, 0x37, 0x62, 0x64, 0x33, 0x36, 0x39, 0x64, 0x37, 0x64, 0x32, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x63, 0x37, 0x64, 0x31, 0x37, 0x31, 0x31, 0x62, 0x30, 0x31, 0x31, 0x61, 0x33, 0x33, 0x66, 0x31, 0x36, 0x66, 0x31, 0x66, 0x35, 0x35, 0x62, 0x35, 0x63, 0x39, 0x30, 0x32, 0x63, 0x63, 0x65, 0x39, 0x37, 0x30, 0x62, 0x64, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x37, 0x62, 0x65, 0x37, 0x31, 0x62, 0x33, 0x61, 0x61, 0x38, 0x31, 0x35, 0x66, 0x66, 0x34, 0x35, 0x33, 0x64, 0x35, 0x36, 0x34, 0x32, 0x66, 0x37, 0x33, 0x30, 0x37, 0x34, 0x34, 0x35, 0x30, 0x62, 0x36, 0x34, 0x63, 0x38, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x38, 0x34, 0x61, 0x32, 0x63, 0x30, 0x36, 0x36, 0x62, 0x37, 0x61, 0x34, 0x35, 0x35, 0x64, 0x62, 0x64, 0x36, 0x61, 0x65, 0x32, 0x38, 0x30, 0x37, 0x61, 0x37, 0x33, 0x33, 0x34, 0x65, 0x38, 0x33, 0x63, 0x33, 0x35, 0x66, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x30, 0x35, 0x65, 0x39, 0x64, 0x30, 0x66, 0x30, 0x37, 0x35, 0x38, 0x65, 0x37, 0x39, 0x35, 0x33, 0x30, 0x33, 0x37, 0x31, 0x37, 0x65, 0x33, 0x31, 0x64, 0x61, 0x32, 0x31, 0x33, 0x63, 0x61, 0x31, 0x35, 0x37, 0x65, 0x36, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x31, 0x61, 0x32, 0x64, 0x61, 0x35, 0x34, 0x61, 0x34, 0x63, 0x36, 0x64, 0x61, 0x31, 0x39, 0x64, 0x31, 0x34, 0x32, 0x34, 0x31, 0x32, 0x65, 0x35, 0x36, 0x65, 0x38, 0x31, 0x35, 0x37, 0x34, 0x31, 0x64, 0x62, 0x32, 0x33, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x34, 0x63, 0x61, 0x38, 0x62, 0x38, 0x32, 0x31, 0x31, 0x37, 0x38, 0x39, 0x34, 0x65, 0x34, 0x33, 0x64, 0x62, 0x37, 0x32, 0x62, 0x39, 0x66, 0x61, 0x37, 0x38, 0x66, 0x30, 0x62, 0x39, 0x62, 0x39, 0x33, 0x61, 0x63, 0x65, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x63, 0x39, 0x39, 0x66, 0x38, 0x38, 0x34, 0x39, 0x63, 0x39, 0x38, 0x30, 0x32, 0x62, 0x38, 0x33, 0x63, 0x38, 0x36, 0x31, 0x32, 0x31, 0x37, 0x66, 0x64, 0x30, 0x37, 0x61, 0x39, 0x65, 0x38, 0x34, 0x63, 0x64, 0x62, 0x37, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x63, 0x30, 0x64, 0x31, 0x39, 0x66, 0x30, 0x62, 0x38, 0x65, 0x30, 0x35, 0x34, 0x66, 0x39, 0x65, 0x38, 0x39, 0x33, 0x38, 0x33, 0x36, 0x64, 0x35, 0x65, 0x63, 0x61, 0x65, 0x37, 0x39, 0x30, 0x31, 0x61, 0x66, 0x32, 0x38, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x64, 0x63, 0x30, 0x31, 0x63, 0x62, 0x66, 0x34, 0x34, 0x39, 0x37, 0x38, 0x61, 0x34, 0x32, 0x65, 0x38, 0x64, 0x65, 0x38, 0x65, 0x34, 0x33, 0x36, 0x65, 0x64, 0x66, 0x39, 0x34, 0x32, 0x30, 0x35, 0x63, 0x66, 0x62, 0x36, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x38, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x37, 0x64, 0x65, 0x65, 0x32, 0x32, 0x30, 0x66, 0x30, 0x34, 0x35, 0x37, 0x61, 0x37, 0x31, 0x38, 0x37, 0x64, 0x35, 0x36, 0x63, 0x31, 0x63, 0x34, 0x31, 0x66, 0x32, 0x65, 0x62, 0x30, 0x30, 0x61, 0x63, 0x35, 0x36, 0x30, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x39, 0x39, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x31, 0x32, 0x38, 0x62, 0x64, 0x36, 0x63, 0x64, 0x61, 0x35, 0x66, 0x63, 0x61, 0x32, 0x37, 0x35, 0x37, 0x35, 0x65, 0x34, 0x62, 0x34, 0x33, 0x62, 0x33, 0x32, 0x35, 0x33, 0x63, 0x38, 0x63, 0x34, 0x31, 0x37, 0x32, 0x61, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x36, 0x37, 0x34, 0x36, 0x66, 0x62, 0x39, 0x33, 0x64, 0x31, 0x39, 0x33, 0x35, 0x63, 0x35, 0x61, 0x33, 0x63, 0x36, 0x38, 0x34, 0x65, 0x37, 0x32, 0x35, 0x30, 0x31, 0x30, 0x63, 0x34, 0x66, 0x61, 0x64, 0x30, 0x62, 0x31, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x64, 0x37, 0x38, 0x62, 0x31, 0x37, 0x38, 0x64, 0x37, 0x30, 0x37, 0x65, 0x33, 0x39, 0x36, 0x65, 0x38, 0x37, 0x31, 0x30, 0x39, 0x36, 0x35, 0x63, 0x34, 0x66, 0x34, 0x31, 0x62, 0x31, 0x61, 0x31, 0x64, 0x39, 0x31, 0x37, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x66, 0x37, 0x35, 0x37, 0x33, 0x63, 0x64, 0x34, 0x35, 0x37, 0x65, 0x31, 0x34, 0x63, 0x30, 0x33, 0x66, 0x65, 0x61, 0x34, 0x33, 0x65, 0x33, 0x30, 0x32, 0x64, 0x33, 0x30, 0x33, 0x34, 0x37, 0x63, 0x31, 0x30, 0x37, 0x30, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x33, 0x30, 0x63, 0x62, 0x32, 0x33, 0x37, 0x62, 0x63, 0x30, 0x39, 0x36, 0x66, 0x31, 0x37, 0x30, 0x33, 0x36, 0x66, 0x63, 0x38, 0x30, 0x64, 0x64, 0x32, 0x31, 0x63, 0x61, 0x36, 0x38, 0x39, 0x39, 0x32, 0x63, 0x61, 0x32, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x63, 0x66, 0x63, 0x63, 0x34, 0x61, 0x37, 0x62, 0x30, 0x66, 0x32, 0x36, 0x63, 0x66, 0x32, 0x36, 0x65, 0x39, 0x66, 0x33, 0x33, 0x33, 0x32, 0x31, 0x33, 0x32, 0x65, 0x32, 0x66, 0x63, 0x36, 0x61, 0x32, 0x33, 0x30, 0x37, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x36, 0x36, 0x65, 0x33, 0x37, 0x64, 0x32, 0x65, 0x35, 0x30, 0x31, 0x61, 0x65, 0x37, 0x33, 0x63, 0x38, 0x34, 0x31, 0x34, 0x32, 0x62, 0x35, 0x66, 0x66, 0x62, 0x35, 0x61, 0x61, 0x36, 0x35, 0x35, 0x64, 0x64, 0x35, 0x61, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x66, 0x32, 0x34, 0x66, 0x36, 0x36, 0x38, 0x35, 0x61, 0x36, 0x32, 0x66, 0x37, 0x39, 0x31, 0x62, 0x61, 0x33, 0x33, 0x37, 0x62, 0x66, 0x33, 0x66, 0x66, 0x36, 0x37, 0x65, 0x39, 0x31, 0x66, 0x33, 0x64, 0x34, 0x62, 0x63, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x65, 0x34, 0x33, 0x35, 0x33, 0x34, 0x30, 0x65, 0x39, 0x64, 0x32, 0x35, 0x33, 0x63, 0x30, 0x30, 0x32, 0x35, 0x36, 0x33, 0x38, 0x39, 0x66, 0x35, 0x32, 0x62, 0x30, 0x36, 0x37, 0x64, 0x35, 0x35, 0x39, 0x37, 0x34, 0x65, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x35, 0x33, 0x64, 0x32, 0x36, 0x35, 0x36, 0x34, 0x38, 0x35, 0x39, 0x64, 0x39, 0x65, 0x39, 0x30, 0x62, 0x62, 0x30, 0x65, 0x35, 0x33, 0x62, 0x37, 0x61, 0x62, 0x66, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x36, 0x32, 0x63, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x36, 0x36, 0x35, 0x37, 0x66, 0x30, 0x65, 0x64, 0x32, 0x30, 0x31, 0x65, 0x61, 0x32, 0x33, 0x39, 0x32, 0x63, 0x39, 0x32, 0x32, 0x32, 0x62, 0x38, 0x30, 0x61, 0x37, 0x30, 0x30, 0x33, 0x36, 0x30, 0x38, 0x64, 0x64, 0x66, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x31, 0x37, 0x37, 0x61, 0x30, 0x64, 0x38, 0x35, 0x64, 0x34, 0x38, 0x62, 0x30, 0x65, 0x32, 0x36, 0x34, 0x32, 0x31, 0x31, 0x63, 0x65, 0x32, 0x61, 0x61, 0x32, 0x65, 0x66, 0x64, 0x33, 0x66, 0x31, 0x62, 0x34, 0x37, 0x66, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x39, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x34, 0x37, 0x62, 0x61, 0x35, 0x62, 0x34, 0x63, 0x38, 0x35, 0x30, 0x35, 0x61, 0x64, 0x38, 0x64, 0x61, 0x34, 0x32, 0x39, 0x33, 0x34, 0x32, 0x38, 0x30, 0x62, 0x36, 0x31, 0x61, 0x30, 0x65, 0x31, 0x65, 0x38, 0x62, 0x39, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x63, 0x32, 0x61, 0x33, 0x64, 0x32, 0x33, 0x35, 0x65, 0x35, 0x65, 0x65, 0x61, 0x62, 0x64, 0x30, 0x64, 0x34, 0x61, 0x36, 0x61, 0x66, 0x64, 0x62, 0x38, 0x39, 0x64, 0x39, 0x34, 0x36, 0x32, 0x37, 0x33, 0x39, 0x36, 0x34, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x36, 0x61, 0x38, 0x30, 0x33, 0x39, 0x63, 0x65, 0x63, 0x66, 0x39, 0x64, 0x63, 0x65, 0x34, 0x38, 0x37, 0x39, 0x63, 0x62, 0x63, 0x61, 0x66, 0x33, 0x34, 0x39, 0x33, 0x62, 0x66, 0x35, 0x34, 0x35, 0x61, 0x38, 0x38, 0x36, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x61, 0x33, 0x37, 0x65, 0x64, 0x36, 0x37, 0x38, 0x38, 0x37, 0x37, 0x35, 0x31, 0x61, 0x34, 0x37, 0x31, 0x66, 0x30, 0x65, 0x62, 0x33, 0x30, 0x36, 0x62, 0x65, 0x34, 0x34, 0x65, 0x30, 0x64, 0x62, 0x63, 0x64, 0x36, 0x30, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x64, 0x34, 0x61, 0x31, 0x36, 0x38, 0x39, 0x31, 0x66, 0x35, 0x32, 0x39, 0x32, 0x32, 0x37, 0x38, 0x39, 0x32, 0x31, 0x37, 0x66, 0x63, 0x64, 0x38, 0x38, 0x36, 0x66, 0x37, 0x66, 0x63, 0x65, 0x32, 0x39, 0x36, 0x64, 0x34, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x37, 0x65, 0x31, 0x30, 0x38, 0x35, 0x30, 0x32, 0x62, 0x30, 0x62, 0x31, 0x38, 0x39, 0x65, 0x66, 0x39, 0x63, 0x38, 0x63, 0x36, 0x64, 0x61, 0x34, 0x64, 0x30, 0x64, 0x62, 0x36, 0x32, 0x36, 0x31, 0x65, 0x65, 0x63, 0x36, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x38, 0x34, 0x64, 0x32, 0x36, 0x62, 0x65, 0x63, 0x63, 0x31, 0x65, 0x65, 0x61, 0x38, 0x63, 0x36, 0x33, 0x31, 0x35, 0x65, 0x63, 0x33, 0x65, 0x65, 0x30, 0x61, 0x34, 0x35, 0x30, 0x31, 0x31, 0x37, 0x64, 0x63, 0x38, 0x36, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x39, 0x65, 0x39, 0x37, 0x61, 0x30, 0x34, 0x38, 0x32, 0x66, 0x33, 0x35, 0x33, 0x61, 0x30, 0x35, 0x63, 0x30, 0x66, 0x37, 0x39, 0x32, 0x62, 0x39, 0x37, 0x37, 0x62, 0x36, 0x63, 0x37, 0x65, 0x38, 0x31, 0x31, 0x66, 0x61, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x37, 0x33, 0x62, 0x61, 0x64, 0x37, 0x62, 0x63, 0x34, 0x65, 0x34, 0x38, 0x37, 0x36, 0x32, 0x32, 0x64, 0x31, 0x37, 0x35, 0x65, 0x66, 0x37, 0x61, 0x36, 0x36, 0x39, 0x38, 0x38, 0x62, 0x36, 0x61, 0x39, 0x33, 0x63, 0x34, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x39, 0x33, 0x62, 0x31, 0x36, 0x31, 0x33, 0x36, 0x66, 0x31, 0x31, 0x65, 0x61, 0x66, 0x31, 0x30, 0x39, 0x39, 0x36, 0x63, 0x39, 0x35, 0x39, 0x39, 0x30, 0x64, 0x33, 0x62, 0x32, 0x37, 0x33, 0x39, 0x63, 0x63, 0x65, 0x61, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x66, 0x31, 0x66, 0x61, 0x33, 0x39, 0x31, 0x38, 0x63, 0x61, 0x33, 0x34, 0x65, 0x32, 0x63, 0x66, 0x37, 0x65, 0x38, 0x34, 0x36, 0x37, 0x30, 0x62, 0x31, 0x66, 0x34, 0x64, 0x38, 0x65, 0x63, 0x61, 0x31, 0x36, 0x30, 0x64, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x61, 0x32, 0x31, 0x35, 0x34, 0x34, 0x33, 0x30, 0x63, 0x30, 0x65, 0x34, 0x31, 0x31, 0x34, 0x37, 0x64, 0x33, 0x63, 0x31, 0x66, 0x65, 0x65, 0x33, 0x62, 0x33, 0x62, 0x30, 0x30, 0x36, 0x66, 0x38, 0x35, 0x31, 0x65, 0x64, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x31, 0x38, 0x35, 0x66, 0x33, 0x32, 0x35, 0x61, 0x63, 0x66, 0x32, 0x64, 0x36, 0x34, 0x35, 0x30, 0x30, 0x36, 0x39, 0x38, 0x66, 0x36, 0x35, 0x63, 0x37, 0x36, 0x39, 0x64, 0x64, 0x66, 0x36, 0x38, 0x33, 0x30, 0x31, 0x36, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x63, 0x61, 0x66, 0x65, 0x34, 0x31, 0x61, 0x35, 0x65, 0x38, 0x62, 0x62, 0x64, 0x39, 0x30, 0x62, 0x61, 0x30, 0x32, 0x64, 0x39, 0x65, 0x30, 0x36, 0x35, 0x38, 0x35, 0x62, 0x34, 0x65, 0x62, 0x35, 0x34, 0x36, 0x63, 0x35, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x36, 0x38, 0x31, 0x63, 0x64, 0x61, 0x65, 0x36, 0x39, 0x62, 0x32, 0x30, 0x34, 0x39, 0x63, 0x65, 0x31, 0x30, 0x31, 0x65, 0x33, 0x32, 0x35, 0x63, 0x37, 0x35, 0x39, 0x38, 0x39, 0x32, 0x63, 0x61, 0x63, 0x33, 0x66, 0x38, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x35, 0x30, 0x36, 0x36, 0x66, 0x39, 0x61, 0x64, 0x32, 0x36, 0x36, 0x35, 0x35, 0x31, 0x39, 0x36, 0x64, 0x35, 0x35, 0x33, 0x35, 0x33, 0x32, 0x37, 0x62, 0x62, 0x65, 0x62, 0x39, 0x62, 0x37, 0x39, 0x32, 0x39, 0x63, 0x62, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x38, 0x35, 0x66, 0x64, 0x32, 0x65, 0x32, 0x35, 0x34, 0x34, 0x37, 0x30, 0x32, 0x63, 0x33, 0x36, 0x30, 0x62, 0x38, 0x62, 0x62, 0x39, 0x65, 0x65, 0x37, 0x38, 0x66, 0x31, 0x33, 0x30, 0x64, 0x61, 0x64, 0x31, 0x36, 0x64, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x65, 0x36, 0x38, 0x64, 0x62, 0x39, 0x34, 0x63, 0x37, 0x64, 0x30, 0x61, 0x62, 0x37, 0x61, 0x63, 0x34, 0x31, 0x38, 0x35, 0x37, 0x61, 0x37, 0x31, 0x64, 0x36, 0x37, 0x31, 0x34, 0x37, 0x38, 0x37, 0x30, 0x66, 0x34, 0x65, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x64, 0x39, 0x35, 0x64, 0x31, 0x38, 0x38, 0x64, 0x36, 0x34, 0x36, 0x34, 0x37, 0x30, 0x39, 0x61, 0x64, 0x64, 0x32, 0x35, 0x35, 0x35, 0x66, 0x62, 0x34, 0x64, 0x39, 0x37, 0x66, 0x65, 0x31, 0x65, 0x62, 0x66, 0x33, 0x31, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x62, 0x65, 0x64, 0x64, 0x36, 0x66, 0x64, 0x61, 0x37, 0x62, 0x61, 0x33, 0x32, 0x37, 0x32, 0x31, 0x38, 0x35, 0x30, 0x38, 0x37, 0x62, 0x36, 0x33, 0x35, 0x31, 0x66, 0x63, 0x31, 0x33, 0x33, 0x64, 0x34, 0x38, 0x34, 0x65, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x61, 0x34, 0x37, 0x31, 0x35, 0x35, 0x30, 0x34, 0x63, 0x36, 0x61, 0x66, 0x31, 0x30, 0x37, 0x62, 0x30, 0x31, 0x39, 0x34, 0x66, 0x34, 0x66, 0x37, 0x62, 0x31, 0x63, 0x62, 0x36, 0x66, 0x63, 0x63, 0x63, 0x64, 0x36, 0x66, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x30, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x33, 0x30, 0x36, 0x66, 0x66, 0x65, 0x32, 0x65, 0x34, 0x61, 0x38, 0x66, 0x33, 0x63, 0x61, 0x38, 0x32, 0x36, 0x63, 0x31, 0x61, 0x32, 0x34, 0x39, 0x66, 0x37, 0x32, 0x31, 0x32, 0x64, 0x61, 0x34, 0x33, 0x61, 0x65, 0x66, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x34, 0x35, 0x33, 0x66, 0x35, 0x61, 0x33, 0x61, 0x64, 0x64, 0x64, 0x64, 0x38, 0x61, 0x62, 0x35, 0x36, 0x37, 0x35, 0x30, 0x66, 0x61, 0x64, 0x62, 0x30, 0x66, 0x65, 0x37, 0x66, 0x39, 0x34, 0x64, 0x39, 0x63, 0x38, 0x39, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x30, 0x31, 0x64, 0x31, 0x63, 0x30, 0x36, 0x39, 0x32, 0x30, 0x63, 0x64, 0x33, 0x39, 0x37, 0x61, 0x65, 0x38, 0x61, 0x64, 0x38, 0x36, 0x39, 0x62, 0x63, 0x64, 0x61, 0x36, 0x65, 0x34, 0x37, 0x66, 0x66, 0x62, 0x31, 0x62, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x31, 0x63, 0x62, 0x35, 0x63, 0x64, 0x30, 0x35, 0x63, 0x37, 0x65, 0x66, 0x39, 0x30, 0x39, 0x66, 0x65, 0x31, 0x62, 0x65, 0x36, 0x30, 0x37, 0x33, 0x33, 0x64, 0x38, 0x39, 0x36, 0x33, 0x64, 0x37, 0x36, 0x30, 0x64, 0x63, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x36, 0x65, 0x33, 0x31, 0x39, 0x35, 0x39, 0x32, 0x62, 0x33, 0x34, 0x31, 0x65, 0x61, 0x63, 0x63, 0x64, 0x37, 0x37, 0x38, 0x64, 0x64, 0x61, 0x37, 0x63, 0x38, 0x31, 0x39, 0x36, 0x64, 0x35, 0x34, 0x63, 0x61, 0x63, 0x37, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x36, 0x30, 0x39, 0x65, 0x30, 0x61, 0x34, 0x36, 0x35, 0x62, 0x36, 0x65, 0x39, 0x39, 0x66, 0x63, 0x65, 0x39, 0x30, 0x37, 0x31, 0x36, 0x36, 0x64, 0x35, 0x37, 0x65, 0x39, 0x64, 0x61, 0x30, 0x38, 0x31, 0x34, 0x66, 0x35, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x65, 0x63, 0x36, 0x32, 0x62, 0x38, 0x30, 0x34, 0x62, 0x31, 0x66, 0x36, 0x39, 0x62, 0x31, 0x65, 0x33, 0x30, 0x37, 0x30, 0x62, 0x35, 0x64, 0x33, 0x36, 0x32, 0x63, 0x36, 0x32, 0x66, 0x62, 0x33, 0x30, 0x39, 0x62, 0x30, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x36, 0x38, 0x30, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x62, 0x39, 0x65, 0x66, 0x30, 0x36, 0x64, 0x30, 0x63, 0x32, 0x35, 0x39, 0x30, 0x34, 0x30, 0x33, 0x31, 0x39, 0x39, 0x34, 0x37, 0x65, 0x38, 0x63, 0x37, 0x61, 0x36, 0x38, 0x31, 0x32, 0x61, 0x61, 0x30, 0x32, 0x35, 0x33, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x66, 0x33, 0x37, 0x66, 0x66, 0x38, 0x35, 0x34, 0x61, 0x32, 0x66, 0x31, 0x63, 0x65, 0x35, 0x33, 0x39, 0x33, 0x34, 0x34, 0x39, 0x34, 0x37, 0x37, 0x37, 0x38, 0x39, 0x32, 0x64, 0x33, 0x65, 0x63, 0x36, 0x35, 0x35, 0x37, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x62, 0x31, 0x61, 0x66, 0x37, 0x32, 0x33, 0x33, 0x39, 0x62, 0x32, 0x61, 0x32, 0x32, 0x35, 0x36, 0x33, 0x38, 0x39, 0x66, 0x64, 0x36, 0x34, 0x36, 0x30, 0x37, 0x64, 0x65, 0x32, 0x34, 0x66, 0x30, 0x64, 0x65, 0x36, 0x30, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x62, 0x65, 0x62, 0x39, 0x31, 0x63, 0x32, 0x62, 0x39, 0x39, 0x63, 0x38, 0x39, 0x36, 0x34, 0x61, 0x61, 0x39, 0x35, 0x62, 0x36, 0x62, 0x34, 0x61, 0x31, 0x38, 0x34, 0x62, 0x31, 0x32, 0x36, 0x39, 0x66, 0x63, 0x33, 0x34, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x32, 0x61, 0x32, 0x30, 0x63, 0x37, 0x39, 0x61, 0x31, 0x64, 0x33, 0x61, 0x32, 0x36, 0x64, 0x64, 0x33, 0x38, 0x32, 0x39, 0x36, 0x37, 0x37, 0x62, 0x66, 0x31, 0x64, 0x34, 0x35, 0x63, 0x38, 0x66, 0x36, 0x37, 0x32, 0x62, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x38, 0x34, 0x33, 0x33, 0x39, 0x39, 0x64, 0x31, 0x35, 0x30, 0x30, 0x36, 0x36, 0x62, 0x66, 0x37, 0x39, 0x37, 0x39, 0x63, 0x33, 0x34, 0x62, 0x61, 0x32, 0x39, 0x34, 0x36, 0x32, 0x30, 0x33, 0x36, 0x38, 0x61, 0x64, 0x37, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x64, 0x30, 0x63, 0x64, 0x32, 0x32, 0x65, 0x36, 0x32, 0x30, 0x65, 0x64, 0x61, 0x37, 0x39, 0x63, 0x30, 0x34, 0x36, 0x31, 0x65, 0x38, 0x39, 0x36, 0x63, 0x39, 0x33, 0x63, 0x34, 0x34, 0x38, 0x33, 0x37, 0x65, 0x32, 0x39, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x37, 0x30, 0x64, 0x64, 0x30, 0x36, 0x38, 0x37, 0x62, 0x64, 0x35, 0x35, 0x63, 0x61, 0x38, 0x38, 0x62, 0x38, 0x37, 0x61, 0x64, 0x65, 0x66, 0x35, 0x31, 0x63, 0x66, 0x64, 0x63, 0x35, 0x35, 0x63, 0x34, 0x64, 0x64, 0x34, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x64, 0x33, 0x38, 0x34, 0x65, 0x66, 0x32, 0x64, 0x34, 0x31, 0x64, 0x39, 0x64, 0x32, 0x30, 0x33, 0x39, 0x37, 0x34, 0x65, 0x35, 0x37, 0x63, 0x31, 0x32, 0x33, 0x32, 0x38, 0x65, 0x61, 0x37, 0x36, 0x30, 0x65, 0x30, 0x38, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x32, 0x39, 0x61, 0x35, 0x63, 0x62, 0x37, 0x31, 0x30, 0x35, 0x66, 0x65, 0x38, 0x31, 0x30, 0x62, 0x64, 0x38, 0x39, 0x35, 0x64, 0x63, 0x37, 0x32, 0x30, 0x36, 0x61, 0x39, 0x39, 0x31, 0x61, 0x34, 0x35, 0x34, 0x35, 0x34, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x37, 0x32, 0x66, 0x34, 0x38, 0x64, 0x63, 0x35, 0x65, 0x33, 0x66, 0x38, 0x31, 0x37, 0x62, 0x63, 0x36, 0x62, 0x32, 0x61, 0x64, 0x32, 0x64, 0x30, 0x33, 0x30, 0x66, 0x63, 0x35, 0x65, 0x30, 0x34, 0x37, 0x31, 0x31, 0x39, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x34, 0x62, 0x37, 0x35, 0x31, 0x32, 0x63, 0x39, 0x61, 0x65, 0x35, 0x65, 0x61, 0x36, 0x33, 0x63, 0x62, 0x66, 0x31, 0x31, 0x37, 0x31, 0x35, 0x62, 0x36, 0x33, 0x66, 0x32, 0x31, 0x65, 0x31, 0x38, 0x64, 0x32, 0x39, 0x36, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x62, 0x32, 0x35, 0x36, 0x62, 0x32, 0x30, 0x34, 0x38, 0x30, 0x30, 0x61, 0x66, 0x32, 0x30, 0x31, 0x33, 0x37, 0x66, 0x61, 0x62, 0x63, 0x63, 0x39, 0x31, 0x36, 0x61, 0x32, 0x33, 0x32, 0x35, 0x38, 0x37, 0x35, 0x32, 0x35, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x36, 0x36, 0x66, 0x61, 0x62, 0x61, 0x32, 0x37, 0x37, 0x66, 0x34, 0x62, 0x35, 0x64, 0x65, 0x36, 0x34, 0x61, 0x64, 0x34, 0x35, 0x65, 0x62, 0x31, 0x39, 0x63, 0x33, 0x31, 0x65, 0x30, 0x30, 0x63, 0x65, 0x64, 0x33, 0x65, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x38, 0x32, 0x34, 0x66, 0x38, 0x62, 0x63, 0x65, 0x64, 0x31, 0x37, 0x36, 0x66, 0x64, 0x33, 0x65, 0x61, 0x32, 0x32, 0x65, 0x63, 0x36, 0x61, 0x34, 0x39, 0x33, 0x64, 0x30, 0x63, 0x63, 0x63, 0x33, 0x33, 0x66, 0x63, 0x31, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x33, 0x38, 0x65, 0x38, 0x35, 0x39, 0x66, 0x65, 0x32, 0x65, 0x38, 0x63, 0x31, 0x35, 0x35, 0x35, 0x34, 0x38, 0x34, 0x38, 0x62, 0x37, 0x35, 0x63, 0x61, 0x65, 0x63, 0x64, 0x61, 0x38, 0x37, 0x37, 0x61, 0x30, 0x65, 0x38, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x33, 0x63, 0x36, 0x38, 0x37, 0x39, 0x36, 0x32, 0x31, 0x32, 0x30, 0x33, 0x33, 0x65, 0x34, 0x65, 0x36, 0x66, 0x39, 0x63, 0x66, 0x66, 0x35, 0x36, 0x65, 0x31, 0x39, 0x63, 0x34, 0x36, 0x31, 0x65, 0x62, 0x34, 0x35, 0x34, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x36, 0x31, 0x65, 0x63, 0x63, 0x34, 0x61, 0x36, 0x61, 0x34, 0x35, 0x65, 0x62, 0x31, 0x61, 0x35, 0x62, 0x39, 0x34, 0x37, 0x66, 0x62, 0x38, 0x36, 0x62, 0x38, 0x38, 0x30, 0x36, 0x39, 0x62, 0x39, 0x31, 0x66, 0x63, 0x64, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x34, 0x62, 0x39, 0x39, 0x63, 0x62, 0x33, 0x66, 0x61, 0x39, 0x66, 0x37, 0x62, 0x37, 0x34, 0x63, 0x65, 0x33, 0x61, 0x34, 0x38, 0x33, 0x31, 0x37, 0x62, 0x31, 0x63, 0x64, 0x31, 0x33, 0x30, 0x39, 0x30, 0x61, 0x31, 0x61, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x64, 0x65, 0x32, 0x31, 0x65, 0x34, 0x32, 0x31, 0x63, 0x33, 0x37, 0x66, 0x65, 0x34, 0x62, 0x38, 0x30, 0x32, 0x35, 0x66, 0x39, 0x61, 0x35, 0x31, 0x62, 0x37, 0x62, 0x33, 0x39, 0x30, 0x62, 0x35, 0x64, 0x66, 0x37, 0x38, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x35, 0x61, 0x65, 0x63, 0x64, 0x37, 0x65, 0x62, 0x38, 0x62, 0x64, 0x36, 0x33, 0x34, 0x35, 0x62, 0x30, 0x36, 0x33, 0x62, 0x35, 0x64, 0x62, 0x64, 0x32, 0x37, 0x31, 0x63, 0x37, 0x37, 0x64, 0x33, 0x35, 0x31, 0x34, 0x34, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x62, 0x32, 0x33, 0x64, 0x36, 0x61, 0x31, 0x61, 0x64, 0x63, 0x30, 0x36, 0x63, 0x36, 0x35, 0x32, 0x61, 0x37, 0x37, 0x39, 0x63, 0x36, 0x61, 0x37, 0x66, 0x62, 0x36, 0x62, 0x39, 0x35, 0x62, 0x39, 0x66, 0x65, 0x61, 0x64, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x36, 0x35, 0x38, 0x30, 0x31, 0x34, 0x61, 0x31, 0x39, 0x39, 0x30, 0x36, 0x31, 0x63, 0x66, 0x36, 0x62, 0x33, 0x39, 0x34, 0x33, 0x33, 0x31, 0x34, 0x30, 0x33, 0x30, 0x33, 0x63, 0x32, 0x30, 0x66, 0x66, 0x64, 0x34, 0x65, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x61, 0x63, 0x37, 0x34, 0x30, 0x65, 0x34, 0x66, 0x30, 0x32, 0x63, 0x62, 0x35, 0x36, 0x65, 0x65, 0x66, 0x30, 0x35, 0x32, 0x36, 0x65, 0x35, 0x64, 0x33, 0x30, 0x30, 0x33, 0x32, 0x32, 0x36, 0x30, 0x30, 0x64, 0x30, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x65, 0x61, 0x64, 0x34, 0x30, 0x61, 0x61, 0x64, 0x38, 0x63, 0x37, 0x33, 0x65, 0x66, 0x30, 0x38, 0x66, 0x63, 0x38, 0x34, 0x62, 0x63, 0x30, 0x61, 0x39, 0x32, 0x63, 0x39, 0x30, 0x39, 0x32, 0x66, 0x36, 0x61, 0x33, 0x36, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x66, 0x37, 0x64, 0x30, 0x32, 0x35, 0x64, 0x31, 0x36, 0x66, 0x37, 0x62, 0x65, 0x65, 0x31, 0x30, 0x35, 0x35, 0x38, 0x30, 0x34, 0x38, 0x36, 0x66, 0x39, 0x66, 0x35, 0x36, 0x31, 0x63, 0x37, 0x62, 0x61, 0x65, 0x33, 0x66, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x37, 0x37, 0x62, 0x66, 0x62, 0x61, 0x30, 0x33, 0x38, 0x61, 0x34, 0x34, 0x66, 0x62, 0x34, 0x39, 0x62, 0x30, 0x33, 0x39, 0x37, 0x30, 0x64, 0x38, 0x64, 0x38, 0x63, 0x66, 0x32, 0x63, 0x62, 0x36, 0x31, 0x66, 0x38, 0x62, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x34, 0x62, 0x62, 0x65, 0x66, 0x66, 0x37, 0x30, 0x37, 0x32, 0x30, 0x39, 0x37, 0x35, 0x64, 0x63, 0x36, 0x31, 0x39, 0x31, 0x62, 0x32, 0x61, 0x34, 0x34, 0x66, 0x66, 0x34, 0x39, 0x66, 0x32, 0x36, 0x37, 0x32, 0x38, 0x37, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x38, 0x38, 0x63, 0x33, 0x61, 0x35, 0x64, 0x66, 0x32, 0x32, 0x38, 0x31, 0x38, 0x35, 0x64, 0x39, 0x38, 0x65, 0x65, 0x37, 0x65, 0x36, 0x30, 0x37, 0x34, 0x38, 0x32, 0x35, 0x35, 0x63, 0x64, 0x65, 0x61, 0x36, 0x38, 0x62, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x35, 0x64, 0x33, 0x35, 0x66, 0x61, 0x65, 0x64, 0x62, 0x33, 0x39, 0x31, 0x63, 0x37, 0x62, 0x63, 0x32, 0x64, 0x62, 0x37, 0x66, 0x61, 0x39, 0x30, 0x37, 0x31, 0x31, 0x36, 0x30, 0x34, 0x30, 0x35, 0x39, 0x39, 0x36, 0x64, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x37, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x65, 0x34, 0x35, 0x37, 0x62, 0x64, 0x35, 0x36, 0x65, 0x63, 0x33, 0x36, 0x61, 0x31, 0x32, 0x34, 0x36, 0x62, 0x66, 0x61, 0x33, 0x32, 0x33, 0x30, 0x66, 0x66, 0x66, 0x33, 0x38, 0x65, 0x35, 0x39, 0x32, 0x36, 0x65, 0x66, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x39, 0x63, 0x35, 0x37, 0x66, 0x65, 0x37, 0x62, 0x36, 0x62, 0x31, 0x33, 0x38, 0x61, 0x39, 0x32, 0x30, 0x64, 0x36, 0x37, 0x36, 0x66, 0x33, 0x63, 0x37, 0x36, 0x62, 0x36, 0x63, 0x32, 0x61, 0x30, 0x65, 0x65, 0x66, 0x36, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x64, 0x66, 0x38, 0x66, 0x38, 0x38, 0x33, 0x63, 0x31, 0x32, 0x37, 0x33, 0x65, 0x63, 0x38, 0x61, 0x31, 0x37, 0x31, 0x66, 0x37, 0x61, 0x33, 0x33, 0x63, 0x66, 0x64, 0x36, 0x34, 0x39, 0x62, 0x31, 0x66, 0x65, 0x36, 0x30, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x37, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x34, 0x66, 0x34, 0x36, 0x62, 0x61, 0x62, 0x37, 0x33, 0x66, 0x65, 0x34, 0x35, 0x64, 0x33, 0x31, 0x62, 0x66, 0x38, 0x37, 0x66, 0x30, 0x61, 0x31, 0x65, 0x30, 0x34, 0x36, 0x36, 0x31, 0x39, 0x39, 0x66, 0x32, 0x65, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x65, 0x31, 0x62, 0x38, 0x61, 0x61, 0x39, 0x30, 0x30, 0x65, 0x39, 0x63, 0x31, 0x33, 0x39, 0x62, 0x33, 0x66, 0x61, 0x31, 0x32, 0x32, 0x33, 0x35, 0x34, 0x66, 0x36, 0x31, 0x35, 0x36, 0x64, 0x39, 0x32, 0x61, 0x31, 0x38, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x37, 0x63, 0x64, 0x37, 0x36, 0x30, 0x38, 0x65, 0x35, 0x64, 0x30, 0x64, 0x38, 0x33, 0x61, 0x32, 0x36, 0x62, 0x37, 0x31, 0x37, 0x66, 0x33, 0x36, 0x30, 0x33, 0x64, 0x61, 0x63, 0x32, 0x32, 0x37, 0x37, 0x64, 0x63, 0x33, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x66, 0x37, 0x35, 0x33, 0x39, 0x64, 0x33, 0x30, 0x39, 0x65, 0x39, 0x30, 0x33, 0x39, 0x39, 0x38, 0x39, 0x65, 0x66, 0x65, 0x32, 0x65, 0x38, 0x62, 0x32, 0x64, 0x62, 0x64, 0x38, 0x36, 0x35, 0x61, 0x30, 0x64, 0x66, 0x30, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x37, 0x39, 0x32, 0x65, 0x32, 0x39, 0x36, 0x38, 0x33, 0x65, 0x62, 0x35, 0x38, 0x36, 0x65, 0x33, 0x39, 0x34, 0x62, 0x62, 0x33, 0x33, 0x35, 0x32, 0x36, 0x63, 0x36, 0x30, 0x30, 0x31, 0x62, 0x33, 0x39, 0x37, 0x39, 0x39, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x34, 0x66, 0x39, 0x64, 0x35, 0x36, 0x38, 0x62, 0x66, 0x37, 0x61, 0x66, 0x64, 0x39, 0x34, 0x63, 0x32, 0x61, 0x35, 0x62, 0x38, 0x61, 0x35, 0x66, 0x66, 0x35, 0x35, 0x63, 0x36, 0x36, 0x63, 0x34, 0x30, 0x38, 0x37, 0x39, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x33, 0x31, 0x62, 0x66, 0x34, 0x31, 0x61, 0x62, 0x63, 0x37, 0x35, 0x63, 0x39, 0x61, 0x65, 0x32, 0x63, 0x64, 0x38, 0x66, 0x37, 0x66, 0x33, 0x35, 0x31, 0x36, 0x33, 0x62, 0x36, 0x65, 0x32, 0x62, 0x37, 0x34, 0x35, 0x30, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x35, 0x34, 0x35, 0x33, 0x65, 0x65, 0x66, 0x32, 0x63, 0x63, 0x33, 0x63, 0x37, 0x61, 0x30, 0x34, 0x34, 0x64, 0x30, 0x61, 0x63, 0x31, 0x33, 0x34, 0x62, 0x61, 0x36, 0x31, 0x35, 0x39, 0x30, 0x38, 0x66, 0x61, 0x38, 0x32, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x61, 0x37, 0x39, 0x61, 0x63, 0x30, 0x34, 0x33, 0x31, 0x36, 0x63, 0x63, 0x38, 0x64, 0x30, 0x38, 0x66, 0x32, 0x30, 0x30, 0x36, 0x35, 0x62, 0x61, 0x61, 0x36, 0x64, 0x34, 0x31, 0x34, 0x32, 0x38, 0x39, 0x37, 0x64, 0x35, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x64, 0x63, 0x38, 0x61, 0x63, 0x38, 0x31, 0x30, 0x34, 0x32, 0x63, 0x36, 0x37, 0x61, 0x39, 0x63, 0x33, 0x63, 0x36, 0x37, 0x39, 0x32, 0x62, 0x32, 0x33, 0x30, 0x63, 0x34, 0x36, 0x61, 0x63, 0x30, 0x31, 0x36, 0x63, 0x61, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x62, 0x33, 0x36, 0x36, 0x62, 0x39, 0x65, 0x64, 0x63, 0x62, 0x30, 0x64, 0x61, 0x36, 0x38, 0x30, 0x66, 0x30, 0x65, 0x31, 0x30, 0x62, 0x33, 0x62, 0x36, 0x65, 0x32, 0x38, 0x37, 0x34, 0x38, 0x31, 0x39, 0x30, 0x64, 0x36, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x36, 0x37, 0x37, 0x37, 0x30, 0x62, 0x36, 0x61, 0x65, 0x33, 0x32, 0x30, 0x62, 0x64, 0x64, 0x65, 0x35, 0x30, 0x66, 0x39, 0x30, 0x34, 0x64, 0x36, 0x36, 0x33, 0x65, 0x37, 0x34, 0x36, 0x61, 0x36, 0x31, 0x64, 0x61, 0x63, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x64, 0x34, 0x32, 0x66, 0x64, 0x31, 0x33, 0x65, 0x62, 0x64, 0x34, 0x62, 0x66, 0x36, 0x39, 0x63, 0x61, 0x63, 0x35, 0x65, 0x39, 0x63, 0x37, 0x65, 0x38, 0x32, 0x34, 0x38, 0x33, 0x61, 0x62, 0x34, 0x36, 0x64, 0x64, 0x37, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x38, 0x33, 0x30, 0x63, 0x35, 0x66, 0x36, 0x30, 0x32, 0x33, 0x61, 0x66, 0x61, 0x61, 0x66, 0x37, 0x39, 0x37, 0x34, 0x35, 0x36, 0x37, 0x36, 0x63, 0x32, 0x30, 0x34, 0x61, 0x30, 0x66, 0x61, 0x63, 0x63, 0x64, 0x61, 0x30, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x62, 0x31, 0x37, 0x39, 0x63, 0x62, 0x34, 0x38, 0x30, 0x31, 0x61, 0x39, 0x39, 0x62, 0x39, 0x35, 0x63, 0x33, 0x62, 0x30, 0x63, 0x33, 0x32, 0x34, 0x61, 0x32, 0x62, 0x64, 0x63, 0x31, 0x30, 0x31, 0x61, 0x36, 0x35, 0x33, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x36, 0x65, 0x33, 0x63, 0x65, 0x61, 0x66, 0x33, 0x66, 0x31, 0x61, 0x66, 0x35, 0x31, 0x66, 0x38, 0x63, 0x32, 0x39, 0x61, 0x66, 0x66, 0x35, 0x64, 0x37, 0x66, 0x61, 0x32, 0x31, 0x66, 0x30, 0x33, 0x38, 0x36, 0x64, 0x38, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x32, 0x61, 0x35, 0x65, 0x65, 0x32, 0x33, 0x32, 0x36, 0x31, 0x32, 0x63, 0x64, 0x33, 0x30, 0x30, 0x35, 0x66, 0x62, 0x32, 0x36, 0x65, 0x35, 0x62, 0x35, 0x39, 0x37, 0x64, 0x65, 0x31, 0x39, 0x66, 0x37, 0x37, 0x36, 0x62, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x35, 0x61, 0x61, 0x33, 0x33, 0x66, 0x63, 0x31, 0x34, 0x62, 0x35, 0x31, 0x38, 0x34, 0x31, 0x61, 0x30, 0x36, 0x39, 0x30, 0x36, 0x65, 0x64, 0x62, 0x32, 0x62, 0x62, 0x34, 0x39, 0x63, 0x32, 0x61, 0x31, 0x31, 0x37, 0x32, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x63, 0x61, 0x36, 0x61, 0x62, 0x65, 0x37, 0x39, 0x65, 0x61, 0x32, 0x34, 0x39, 0x37, 0x66, 0x34, 0x36, 0x66, 0x64, 0x62, 0x62, 0x38, 0x33, 0x30, 0x33, 0x34, 0x36, 0x30, 0x31, 0x30, 0x66, 0x65, 0x34, 0x36, 0x39, 0x63, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x65, 0x63, 0x33, 0x31, 0x31, 0x61, 0x64, 0x30, 0x35, 0x30, 0x30, 0x38, 0x62, 0x34, 0x61, 0x66, 0x33, 0x35, 0x33, 0x63, 0x39, 0x35, 0x38, 0x63, 0x34, 0x30, 0x62, 0x64, 0x30, 0x36, 0x37, 0x33, 0x39, 0x61, 0x33, 0x66, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x39, 0x36, 0x39, 0x38, 0x63, 0x66, 0x31, 0x65, 0x30, 0x38, 0x61, 0x39, 0x64, 0x30, 0x34, 0x38, 0x62, 0x64, 0x38, 0x64, 0x38, 0x30, 0x34, 0x38, 0x66, 0x32, 0x38, 0x62, 0x65, 0x37, 0x65, 0x64, 0x39, 0x34, 0x30, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x66, 0x61, 0x35, 0x33, 0x36, 0x62, 0x34, 0x63, 0x36, 0x36, 0x62, 0x63, 0x33, 0x38, 0x64, 0x38, 0x37, 0x35, 0x63, 0x34, 0x62, 0x33, 0x30, 0x30, 0x39, 0x39, 0x64, 0x39, 0x32, 0x36, 0x31, 0x66, 0x64, 0x62, 0x33, 0x38, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x35, 0x39, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x36, 0x33, 0x61, 0x32, 0x64, 0x66, 0x62, 0x32, 0x62, 0x63, 0x64, 0x30, 0x63, 0x61, 0x65, 0x63, 0x30, 0x30, 0x32, 0x32, 0x62, 0x38, 0x38, 0x62, 0x65, 0x33, 0x30, 0x63, 0x31, 0x34, 0x35, 0x31, 0x65, 0x61, 0x35, 0x36, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x39, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x37, 0x62, 0x65, 0x30, 0x66, 0x39, 0x30, 0x39, 0x39, 0x37, 0x63, 0x61, 0x66, 0x39, 0x30, 0x33, 0x63, 0x38, 0x61, 0x63, 0x31, 0x64, 0x35, 0x33, 0x63, 0x64, 0x65, 0x39, 0x30, 0x34, 0x66, 0x62, 0x31, 0x39, 0x30, 0x37, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x33, 0x63, 0x64, 0x64, 0x64, 0x66, 0x35, 0x33, 0x37, 0x37, 0x66, 0x33, 0x63, 0x37, 0x35, 0x31, 0x62, 0x66, 0x32, 0x65, 0x35, 0x34, 0x31, 0x31, 0x32, 0x30, 0x30, 0x34, 0x35, 0x61, 0x34, 0x37, 0x63, 0x62, 0x61, 0x31, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x63, 0x64, 0x63, 0x36, 0x30, 0x31, 0x66, 0x38, 0x39, 0x63, 0x30, 0x34, 0x32, 0x38, 0x62, 0x33, 0x31, 0x33, 0x30, 0x32, 0x64, 0x31, 0x38, 0x37, 0x65, 0x30, 0x64, 0x63, 0x30, 0x38, 0x61, 0x64, 0x37, 0x64, 0x31, 0x63, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x38, 0x61, 0x63, 0x62, 0x31, 0x30, 0x37, 0x36, 0x30, 0x37, 0x33, 0x38, 0x38, 0x34, 0x37, 0x39, 0x66, 0x36, 0x34, 0x62, 0x61, 0x61, 0x61, 0x62, 0x65, 0x61, 0x38, 0x66, 0x66, 0x30, 0x30, 0x37, 0x61, 0x64, 0x61, 0x39, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x32, 0x38, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x62, 0x63, 0x34, 0x33, 0x30, 0x31, 0x32, 0x65, 0x64, 0x62, 0x30, 0x65, 0x61, 0x39, 0x66, 0x30, 0x36, 0x32, 0x61, 0x63, 0x34, 0x33, 0x37, 0x38, 0x34, 0x33, 0x32, 0x35, 0x30, 0x61, 0x33, 0x39, 0x62, 0x37, 0x38, 0x66, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x66, 0x63, 0x33, 0x61, 0x35, 0x30, 0x30, 0x34, 0x64, 0x36, 0x37, 0x38, 0x36, 0x31, 0x33, 0x66, 0x30, 0x62, 0x33, 0x36, 0x61, 0x36, 0x34, 0x32, 0x32, 0x36, 0x39, 0x61, 0x37, 0x66, 0x33, 0x37, 0x31, 0x63, 0x33, 0x66, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x30, 0x39, 0x35, 0x35, 0x37, 0x65, 0x39, 0x30, 0x31, 0x38, 0x33, 0x66, 0x62, 0x66, 0x30, 0x66, 0x30, 0x36, 0x35, 0x31, 0x61, 0x37, 0x38, 0x36, 0x34, 0x38, 0x37, 0x62, 0x63, 0x63, 0x34, 0x32, 0x38, 0x62, 0x61, 0x31, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x64, 0x39, 0x31, 0x35, 0x65, 0x64, 0x61, 0x33, 0x62, 0x38, 0x32, 0x35, 0x64, 0x36, 0x65, 0x65, 0x34, 0x61, 0x66, 0x39, 0x33, 0x32, 0x38, 0x64, 0x33, 0x32, 0x61, 0x63, 0x31, 0x38, 0x61, 0x64, 0x61, 0x33, 0x35, 0x34, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x33, 0x37, 0x65, 0x66, 0x30, 0x35, 0x32, 0x36, 0x31, 0x63, 0x33, 0x34, 0x64, 0x37, 0x39, 0x63, 0x63, 0x32, 0x32, 0x62, 0x38, 0x36, 0x30, 0x64, 0x65, 0x30, 0x66, 0x31, 0x37, 0x66, 0x37, 0x39, 0x33, 0x63, 0x33, 0x38, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x61, 0x32, 0x65, 0x33, 0x31, 0x39, 0x65, 0x37, 0x64, 0x33, 0x61, 0x31, 0x34, 0x34, 0x38, 0x62, 0x35, 0x61, 0x61, 0x32, 0x34, 0x36, 0x38, 0x39, 0x35, 0x33, 0x31, 0x36, 0x30, 0x63, 0x32, 0x64, 0x62, 0x63, 0x62, 0x61, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x33, 0x36, 0x38, 0x65, 0x66, 0x65, 0x34, 0x61, 0x64, 0x37, 0x38, 0x36, 0x65, 0x32, 0x36, 0x33, 0x39, 0x35, 0x65, 0x63, 0x39, 0x66, 0x63, 0x36, 0x61, 0x64, 0x36, 0x39, 0x38, 0x63, 0x61, 0x65, 0x32, 0x39, 0x66, 0x65, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x33, 0x32, 0x34, 0x30, 0x62, 0x30, 0x38, 0x31, 0x30, 0x65, 0x31, 0x63, 0x66, 0x34, 0x30, 0x37, 0x61, 0x35, 0x30, 0x30, 0x38, 0x30, 0x34, 0x37, 0x34, 0x30, 0x63, 0x66, 0x38, 0x64, 0x36, 0x31, 0x36, 0x34, 0x33, 0x32, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x39, 0x31, 0x64, 0x64, 0x32, 0x66, 0x36, 0x37, 0x34, 0x35, 0x66, 0x32, 0x30, 0x65, 0x32, 0x32, 0x64, 0x32, 0x65, 0x31, 0x64, 0x31, 0x62, 0x39, 0x35, 0x35, 0x61, 0x61, 0x32, 0x39, 0x30, 0x33, 0x64, 0x36, 0x35, 0x36, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x39, 0x33, 0x66, 0x66, 0x38, 0x33, 0x32, 0x37, 0x37, 0x34, 0x64, 0x62, 0x35, 0x31, 0x31, 0x34, 0x63, 0x35, 0x35, 0x62, 0x62, 0x34, 0x62, 0x66, 0x34, 0x34, 0x63, 0x63, 0x66, 0x33, 0x62, 0x35, 0x38, 0x66, 0x39, 0x30, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x32, 0x30, 0x32, 0x36, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x31, 0x63, 0x63, 0x36, 0x65, 0x31, 0x38, 0x63, 0x31, 0x35, 0x32, 0x34, 0x38, 0x38, 0x62, 0x61, 0x31, 0x31, 0x63, 0x32, 0x63, 0x63, 0x31, 0x62, 0x63, 0x65, 0x66, 0x61, 0x32, 0x64, 0x66, 0x33, 0x30, 0x36, 0x61, 0x62, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x65, 0x39, 0x37, 0x38, 0x36, 0x61, 0x38, 0x34, 0x65, 0x37, 0x35, 0x62, 0x34, 0x38, 0x66, 0x31, 0x38, 0x65, 0x37, 0x32, 0x36, 0x64, 0x64, 0x37, 0x38, 0x64, 0x37, 0x30, 0x65, 0x34, 0x61, 0x66, 0x33, 0x65, 0x64, 0x38, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x35, 0x35, 0x31, 0x63, 0x65, 0x64, 0x65, 0x33, 0x37, 0x36, 0x66, 0x37, 0x34, 0x37, 0x65, 0x33, 0x37, 0x31, 0x36, 0x63, 0x38, 0x64, 0x37, 0x39, 0x34, 0x30, 0x30, 0x64, 0x37, 0x36, 0x36, 0x64, 0x32, 0x65, 0x30, 0x31, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x66, 0x30, 0x32, 0x38, 0x33, 0x39, 0x35, 0x62, 0x35, 0x61, 0x38, 0x36, 0x63, 0x39, 0x65, 0x30, 0x37, 0x66, 0x37, 0x37, 0x37, 0x38, 0x36, 0x33, 0x30, 0x65, 0x34, 0x63, 0x32, 0x65, 0x33, 0x64, 0x33, 0x37, 0x33, 0x61, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x32, 0x37, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x33, 0x36, 0x39, 0x34, 0x34, 0x32, 0x34, 0x63, 0x37, 0x63, 0x63, 0x36, 0x62, 0x38, 0x62, 0x63, 0x64, 0x39, 0x62, 0x63, 0x63, 0x61, 0x62, 0x61, 0x35, 0x34, 0x30, 0x63, 0x63, 0x31, 0x66, 0x35, 0x64, 0x66, 0x31, 0x38, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x38, 0x65, 0x32, 0x39, 0x62, 0x33, 0x66, 0x31, 0x39, 0x31, 0x63, 0x38, 0x31, 0x32, 0x61, 0x36, 0x33, 0x39, 0x33, 0x39, 0x31, 0x38, 0x66, 0x37, 0x31, 0x61, 0x62, 0x39, 0x33, 0x33, 0x61, 0x65, 0x36, 0x38, 0x34, 0x37, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x36, 0x34, 0x65, 0x36, 0x31, 0x32, 0x39, 0x66, 0x32, 0x32, 0x34, 0x65, 0x33, 0x37, 0x38, 0x63, 0x30, 0x65, 0x36, 0x65, 0x37, 0x33, 0x36, 0x61, 0x37, 0x65, 0x37, 0x61, 0x30, 0x36, 0x63, 0x32, 0x31, 0x31, 0x65, 0x39, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x63, 0x31, 0x35, 0x33, 0x31, 0x38, 0x64, 0x33, 0x37, 0x30, 0x63, 0x37, 0x33, 0x33, 0x31, 0x38, 0x63, 0x63, 0x31, 0x38, 0x62, 0x64, 0x64, 0x34, 0x36, 0x36, 0x64, 0x62, 0x61, 0x61, 0x34, 0x63, 0x36, 0x36, 0x30, 0x33, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x33, 0x35, 0x62, 0x63, 0x66, 0x66, 0x61, 0x65, 0x66, 0x64, 0x65, 0x65, 0x65, 0x61, 0x33, 0x35, 0x38, 0x33, 0x30, 0x63, 0x34, 0x39, 0x37, 0x64, 0x31, 0x34, 0x32, 0x38, 0x39, 0x64, 0x33, 0x36, 0x32, 0x30, 0x32, 0x33, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x39, 0x37, 0x64, 0x66, 0x63, 0x37, 0x39, 0x38, 0x36, 0x61, 0x32, 0x37, 0x30, 0x35, 0x30, 0x38, 0x34, 0x38, 0x66, 0x61, 0x31, 0x63, 0x36, 0x34, 0x64, 0x37, 0x61, 0x37, 0x64, 0x36, 0x65, 0x30, 0x37, 0x61, 0x63, 0x63, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x65, 0x31, 0x33, 0x61, 0x38, 0x64, 0x30, 0x37, 0x38, 0x35, 0x64, 0x65, 0x38, 0x37, 0x35, 0x38, 0x61, 0x35, 0x65, 0x34, 0x31, 0x38, 0x37, 0x36, 0x63, 0x33, 0x36, 0x65, 0x39, 0x31, 0x36, 0x63, 0x66, 0x37, 0x35, 0x30, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x32, 0x34, 0x63, 0x39, 0x61, 0x66, 0x32, 0x62, 0x37, 0x36, 0x33, 0x34, 0x38, 0x30, 0x35, 0x31, 0x35, 0x64, 0x31, 0x62, 0x30, 0x39, 0x35, 0x31, 0x62, 0x62, 0x37, 0x37, 0x61, 0x35, 0x34, 0x30, 0x66, 0x31, 0x65, 0x33, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x32, 0x33, 0x62, 0x33, 0x37, 0x30, 0x66, 0x63, 0x39, 0x39, 0x32, 0x62, 0x62, 0x36, 0x37, 0x63, 0x65, 0x63, 0x30, 0x36, 0x65, 0x32, 0x36, 0x37, 0x31, 0x35, 0x62, 0x36, 0x32, 0x66, 0x30, 0x62, 0x33, 0x61, 0x34, 0x61, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x63, 0x30, 0x37, 0x36, 0x37, 0x33, 0x65, 0x34, 0x32, 0x66, 0x36, 0x34, 0x63, 0x31, 0x61, 0x32, 0x35, 0x65, 0x63, 0x32, 0x66, 0x61, 0x32, 0x64, 0x38, 0x36, 0x65, 0x35, 0x61, 0x61, 0x32, 0x62, 0x33, 0x34, 0x65, 0x30, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x37, 0x64, 0x62, 0x38, 0x33, 0x36, 0x33, 0x37, 0x37, 0x66, 0x65, 0x31, 0x35, 0x34, 0x35, 0x35, 0x65, 0x30, 0x32, 0x63, 0x32, 0x65, 0x62, 0x64, 0x61, 0x34, 0x30, 0x62, 0x31, 0x63, 0x65, 0x62, 0x35, 0x35, 0x31, 0x62, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x31, 0x63, 0x30, 0x34, 0x37, 0x37, 0x66, 0x31, 0x31, 0x38, 0x34, 0x64, 0x36, 0x30, 0x61, 0x63, 0x63, 0x61, 0x62, 0x33, 0x37, 0x34, 0x64, 0x33, 0x37, 0x34, 0x35, 0x35, 0x37, 0x61, 0x30, 0x61, 0x33, 0x65, 0x31, 0x30, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x66, 0x65, 0x30, 0x64, 0x32, 0x30, 0x31, 0x32, 0x32, 0x38, 0x61, 0x37, 0x35, 0x33, 0x31, 0x34, 0x35, 0x36, 0x35, 0x35, 0x64, 0x34, 0x32, 0x38, 0x65, 0x62, 0x39, 0x66, 0x64, 0x39, 0x34, 0x39, 0x38, 0x35, 0x64, 0x33, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x39, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x37, 0x33, 0x31, 0x62, 0x30, 0x34, 0x36, 0x63, 0x38, 0x61, 0x63, 0x36, 0x39, 0x35, 0x61, 0x31, 0x32, 0x37, 0x66, 0x64, 0x37, 0x39, 0x64, 0x30, 0x61, 0x35, 0x64, 0x35, 0x66, 0x61, 0x36, 0x61, 0x65, 0x36, 0x64, 0x31, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x65, 0x33, 0x30, 0x63, 0x33, 0x31, 0x66, 0x33, 0x63, 0x61, 0x36, 0x36, 0x37, 0x32, 0x31, 0x65, 0x63, 0x62, 0x32, 0x31, 0x33, 0x63, 0x38, 0x30, 0x39, 0x61, 0x61, 0x62, 0x35, 0x36, 0x31, 0x64, 0x39, 0x62, 0x35, 0x32, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x64, 0x36, 0x39, 0x63, 0x35, 0x62, 0x39, 0x62, 0x66, 0x35, 0x65, 0x62, 0x35, 0x61, 0x33, 0x39, 0x63, 0x65, 0x65, 0x37, 0x63, 0x33, 0x33, 0x34, 0x31, 0x61, 0x31, 0x32, 0x30, 0x64, 0x39, 0x37, 0x33, 0x66, 0x64, 0x62, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x37, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x36, 0x65, 0x34, 0x31, 0x38, 0x36, 0x34, 0x65, 0x66, 0x39, 0x38, 0x66, 0x30, 0x36, 0x30, 0x64, 0x61, 0x30, 0x38, 0x65, 0x63, 0x61, 0x65, 0x31, 0x39, 0x61, 0x64, 0x31, 0x31, 0x36, 0x36, 0x61, 0x31, 0x37, 0x64, 0x30, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x35, 0x33, 0x64, 0x34, 0x31, 0x61, 0x65, 0x34, 0x61, 0x37, 0x35, 0x32, 0x62, 0x32, 0x31, 0x61, 0x62, 0x65, 0x64, 0x35, 0x33, 0x37, 0x34, 0x36, 0x34, 0x39, 0x39, 0x35, 0x33, 0x61, 0x35, 0x31, 0x33, 0x64, 0x65, 0x35, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x64, 0x64, 0x38, 0x66, 0x63, 0x62, 0x62, 0x34, 0x36, 0x65, 0x61, 0x34, 0x36, 0x66, 0x65, 0x33, 0x38, 0x31, 0x61, 0x36, 0x38, 0x62, 0x38, 0x63, 0x61, 0x30, 0x65, 0x61, 0x35, 0x62, 0x65, 0x32, 0x31, 0x66, 0x65, 0x39, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x37, 0x33, 0x32, 0x62, 0x66, 0x39, 0x37, 0x33, 0x30, 0x35, 0x35, 0x64, 0x62, 0x64, 0x39, 0x31, 0x61, 0x34, 0x35, 0x33, 0x33, 0x61, 0x64, 0x61, 0x61, 0x32, 0x31, 0x34, 0x39, 0x61, 0x39, 0x31, 0x64, 0x33, 0x38, 0x33, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x65, 0x61, 0x31, 0x63, 0x30, 0x39, 0x33, 0x34, 0x65, 0x33, 0x64, 0x30, 0x34, 0x30, 0x32, 0x32, 0x65, 0x64, 0x39, 0x63, 0x39, 0x35, 0x61, 0x30, 0x38, 0x37, 0x61, 0x31, 0x35, 0x30, 0x65, 0x66, 0x37, 0x30, 0x35, 0x65, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x64, 0x65, 0x35, 0x63, 0x36, 0x30, 0x31, 0x65, 0x36, 0x39, 0x36, 0x36, 0x33, 0x35, 0x63, 0x36, 0x39, 0x38, 0x62, 0x37, 0x61, 0x65, 0x39, 0x63, 0x61, 0x34, 0x35, 0x33, 0x39, 0x66, 0x63, 0x37, 0x62, 0x39, 0x34, 0x31, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x65, 0x31, 0x66, 0x35, 0x63, 0x62, 0x39, 0x62, 0x38, 0x61, 0x62, 0x61, 0x63, 0x65, 0x30, 0x33, 0x61, 0x31, 0x61, 0x36, 0x34, 0x32, 0x38, 0x32, 0x35, 0x36, 0x35, 0x35, 0x33, 0x62, 0x36, 0x39, 0x30, 0x63, 0x32, 0x33, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x33, 0x39, 0x62, 0x34, 0x61, 0x34, 0x30, 0x31, 0x62, 0x35, 0x38, 0x34, 0x64, 0x66, 0x65, 0x30, 0x66, 0x33, 0x34, 0x34, 0x62, 0x31, 0x62, 0x34, 0x32, 0x32, 0x63, 0x36, 0x35, 0x35, 0x34, 0x33, 0x31, 0x36, 0x37, 0x65, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x35, 0x38, 0x34, 0x64, 0x39, 0x32, 0x30, 0x36, 0x61, 0x34, 0x36, 0x63, 0x65, 0x31, 0x35, 0x63, 0x33, 0x30, 0x31, 0x31, 0x31, 0x37, 0x65, 0x65, 0x32, 0x38, 0x66, 0x31, 0x35, 0x63, 0x33, 0x30, 0x65, 0x36, 0x30, 0x65, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x36, 0x65, 0x62, 0x32, 0x30, 0x34, 0x32, 0x34, 0x31, 0x61, 0x38, 0x37, 0x38, 0x33, 0x30, 0x66, 0x62, 0x32, 0x32, 0x39, 0x30, 0x33, 0x31, 0x33, 0x34, 0x33, 0x64, 0x63, 0x33, 0x30, 0x38, 0x35, 0x34, 0x66, 0x35, 0x38, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x64, 0x34, 0x36, 0x62, 0x31, 0x63, 0x36, 0x64, 0x33, 0x66, 0x30, 0x35, 0x65, 0x32, 0x39, 0x65, 0x39, 0x63, 0x36, 0x66, 0x30, 0x33, 0x37, 0x65, 0x65, 0x64, 0x39, 0x61, 0x35, 0x39, 0x35, 0x61, 0x66, 0x34, 0x61, 0x39, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x32, 0x35, 0x64, 0x61, 0x34, 0x35, 0x34, 0x39, 0x65, 0x31, 0x35, 0x31, 0x35, 0x35, 0x65, 0x35, 0x37, 0x61, 0x36, 0x32, 0x38, 0x35, 0x32, 0x32, 0x63, 0x65, 0x61, 0x39, 0x64, 0x64, 0x64, 0x66, 0x36, 0x32, 0x37, 0x64, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x39, 0x64, 0x66, 0x33, 0x34, 0x38, 0x35, 0x39, 0x65, 0x64, 0x64, 0x37, 0x63, 0x38, 0x32, 0x30, 0x64, 0x62, 0x38, 0x38, 0x37, 0x37, 0x34, 0x30, 0x64, 0x38, 0x66, 0x66, 0x39, 0x65, 0x31, 0x35, 0x31, 0x35, 0x37, 0x63, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x39, 0x66, 0x34, 0x63, 0x38, 0x39, 0x30, 0x61, 0x33, 0x62, 0x35, 0x31, 0x31, 0x63, 0x65, 0x65, 0x35, 0x31, 0x64, 0x66, 0x65, 0x36, 0x63, 0x66, 0x64, 0x37, 0x66, 0x31, 0x30, 0x39, 0x33, 0x62, 0x37, 0x36, 0x34, 0x31, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x63, 0x37, 0x66, 0x33, 0x34, 0x61, 0x33, 0x38, 0x62, 0x33, 0x31, 0x38, 0x30, 0x31, 0x64, 0x61, 0x34, 0x33, 0x30, 0x36, 0x33, 0x34, 0x37, 0x37, 0x62, 0x31, 0x32, 0x62, 0x32, 0x37, 0x64, 0x30, 0x66, 0x32, 0x30, 0x33, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x34, 0x32, 0x35, 0x30, 0x31, 0x30, 0x30, 0x34, 0x63, 0x39, 0x30, 0x65, 0x61, 0x39, 0x63, 0x39, 0x65, 0x64, 0x31, 0x39, 0x39, 0x38, 0x62, 0x61, 0x31, 0x34, 0x30, 0x61, 0x34, 0x63, 0x64, 0x36, 0x32, 0x63, 0x36, 0x66, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x35, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x38, 0x63, 0x66, 0x31, 0x39, 0x31, 0x31, 0x39, 0x64, 0x62, 0x37, 0x30, 0x61, 0x61, 0x38, 0x36, 0x34, 0x35, 0x34, 0x32, 0x35, 0x33, 0x64, 0x61, 0x37, 0x36, 0x34, 0x61, 0x32, 0x63, 0x62, 0x31, 0x62, 0x32, 0x62, 0x65, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x37, 0x39, 0x37, 0x34, 0x31, 0x31, 0x37, 0x34, 0x61, 0x38, 0x63, 0x31, 0x65, 0x61, 0x30, 0x62, 0x37, 0x66, 0x39, 0x65, 0x64, 0x66, 0x36, 0x35, 0x38, 0x31, 0x37, 0x37, 0x38, 0x35, 0x39, 0x34, 0x31, 0x37, 0x66, 0x35, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x31, 0x32, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x34, 0x66, 0x35, 0x32, 0x34, 0x38, 0x34, 0x37, 0x62, 0x33, 0x61, 0x36, 0x61, 0x63, 0x63, 0x30, 0x64, 0x33, 0x64, 0x35, 0x66, 0x31, 0x66, 0x33, 0x36, 0x32, 0x62, 0x36, 0x30, 0x33, 0x65, 0x64, 0x66, 0x36, 0x35, 0x66, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x66, 0x31, 0x38, 0x66, 0x61, 0x37, 0x63, 0x38, 0x61, 0x37, 0x63, 0x30, 0x61, 0x32, 0x62, 0x33, 0x64, 0x35, 0x65, 0x66, 0x64, 0x31, 0x39, 0x39, 0x30, 0x66, 0x36, 0x34, 0x64, 0x64, 0x63, 0x35, 0x36, 0x39, 0x32, 0x34, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x65, 0x38, 0x32, 0x65, 0x37, 0x30, 0x37, 0x38, 0x64, 0x63, 0x34, 0x66, 0x64, 0x39, 0x65, 0x38, 0x37, 0x39, 0x66, 0x62, 0x38, 0x61, 0x35, 0x30, 0x36, 0x36, 0x37, 0x66, 0x35, 0x33, 0x61, 0x35, 0x63, 0x35, 0x34, 0x35, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x30, 0x37, 0x64, 0x30, 0x35, 0x30, 0x37, 0x35, 0x34, 0x64, 0x63, 0x39, 0x62, 0x61, 0x32, 0x33, 0x30, 0x64, 0x62, 0x30, 0x31, 0x63, 0x33, 0x31, 0x30, 0x61, 0x66, 0x64, 0x62, 0x35, 0x33, 0x39, 0x35, 0x61, 0x61, 0x31, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x37, 0x37, 0x61, 0x31, 0x30, 0x37, 0x61, 0x62, 0x31, 0x32, 0x32, 0x36, 0x62, 0x33, 0x66, 0x39, 0x35, 0x66, 0x31, 0x30, 0x65, 0x65, 0x38, 0x33, 0x61, 0x65, 0x66, 0x63, 0x36, 0x63, 0x35, 0x64, 0x66, 0x66, 0x33, 0x65, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x35, 0x61, 0x36, 0x31, 0x39, 0x33, 0x35, 0x37, 0x32, 0x64, 0x34, 0x61, 0x34, 0x65, 0x35, 0x39, 0x64, 0x37, 0x62, 0x65, 0x30, 0x39, 0x63, 0x62, 0x39, 0x36, 0x30, 0x64, 0x64, 0x64, 0x38, 0x63, 0x35, 0x33, 0x30, 0x65, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x37, 0x33, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x37, 0x30, 0x61, 0x34, 0x66, 0x39, 0x32, 0x65, 0x63, 0x36, 0x62, 0x30, 0x66, 0x63, 0x63, 0x64, 0x30, 0x31, 0x32, 0x33, 0x34, 0x66, 0x61, 0x35, 0x39, 0x30, 0x32, 0x33, 0x65, 0x39, 0x66, 0x66, 0x31, 0x66, 0x33, 0x61, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x62, 0x63, 0x65, 0x66, 0x33, 0x33, 0x38, 0x34, 0x64, 0x34, 0x32, 0x30, 0x65, 0x34, 0x62, 0x66, 0x36, 0x31, 0x61, 0x30, 0x36, 0x36, 0x39, 0x39, 0x39, 0x30, 0x62, 0x63, 0x37, 0x30, 0x35, 0x34, 0x66, 0x31, 0x61, 0x35, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x61, 0x62, 0x66, 0x36, 0x36, 0x34, 0x33, 0x62, 0x65, 0x62, 0x34, 0x62, 0x64, 0x30, 0x31, 0x63, 0x31, 0x32, 0x30, 0x62, 0x64, 0x30, 0x35, 0x39, 0x38, 0x61, 0x30, 0x39, 0x38, 0x37, 0x64, 0x38, 0x32, 0x39, 0x36, 0x37, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x61, 0x32, 0x66, 0x32, 0x65, 0x36, 0x65, 0x63, 0x62, 0x38, 0x36, 0x33, 0x39, 0x34, 0x65, 0x63, 0x30, 0x65, 0x33, 0x33, 0x38, 0x63, 0x30, 0x66, 0x63, 0x39, 0x37, 0x65, 0x39, 0x63, 0x35, 0x35, 0x38, 0x33, 0x64, 0x65, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x39, 0x34, 0x37, 0x33, 0x63, 0x66, 0x37, 0x37, 0x31, 0x32, 0x33, 0x35, 0x30, 0x61, 0x31, 0x66, 0x61, 0x30, 0x33, 0x39, 0x35, 0x32, 0x37, 0x33, 0x66, 0x63, 0x38, 0x30, 0x35, 0x36, 0x30, 0x37, 0x35, 0x32, 0x65, 0x34, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x62, 0x32, 0x31, 0x39, 0x37, 0x31, 0x30, 0x36, 0x31, 0x32, 0x33, 0x33, 0x38, 0x37, 0x61, 0x30, 0x64, 0x34, 0x64, 0x65, 0x33, 0x36, 0x38, 0x34, 0x33, 0x31, 0x61, 0x38, 0x62, 0x61, 0x63, 0x64, 0x64, 0x61, 0x33, 0x30, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x64, 0x35, 0x36, 0x31, 0x31, 0x35, 0x62, 0x64, 0x36, 0x35, 0x30, 0x35, 0x61, 0x38, 0x38, 0x32, 0x37, 0x33, 0x64, 0x66, 0x35, 0x63, 0x35, 0x36, 0x38, 0x33, 0x39, 0x34, 0x37, 0x30, 0x64, 0x32, 0x34, 0x61, 0x32, 0x64, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x33, 0x66, 0x36, 0x64, 0x36, 0x34, 0x36, 0x39, 0x30, 0x66, 0x64, 0x61, 0x63, 0x64, 0x39, 0x34, 0x32, 0x38, 0x35, 0x33, 0x35, 0x39, 0x31, 0x62, 0x62, 0x30, 0x66, 0x66, 0x32, 0x30, 0x64, 0x33, 0x36, 0x35, 0x36, 0x64, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x63, 0x61, 0x66, 0x66, 0x34, 0x62, 0x62, 0x61, 0x30, 0x34, 0x64, 0x32, 0x32, 0x30, 0x63, 0x39, 0x61, 0x35, 0x64, 0x32, 0x30, 0x31, 0x38, 0x36, 0x37, 0x32, 0x65, 0x63, 0x38, 0x35, 0x65, 0x33, 0x31, 0x65, 0x66, 0x38, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x61, 0x66, 0x38, 0x64, 0x38, 0x62, 0x35, 0x62, 0x31, 0x64, 0x31, 0x65, 0x65, 0x64, 0x66, 0x61, 0x37, 0x37, 0x62, 0x63, 0x62, 0x63, 0x39, 0x36, 0x63, 0x31, 0x62, 0x31, 0x33, 0x33, 0x66, 0x38, 0x33, 0x33, 0x30, 0x36, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x35, 0x36, 0x63, 0x35, 0x62, 0x32, 0x63, 0x35, 0x34, 0x33, 0x36, 0x65, 0x33, 0x65, 0x35, 0x37, 0x31, 0x30, 0x30, 0x38, 0x39, 0x33, 0x33, 0x66, 0x31, 0x38, 0x30, 0x35, 0x63, 0x63, 0x66, 0x65, 0x33, 0x34, 0x65, 0x39, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x65, 0x65, 0x62, 0x62, 0x65, 0x34, 0x36, 0x34, 0x64, 0x33, 0x39, 0x31, 0x38, 0x37, 0x62, 0x66, 0x38, 0x30, 0x63, 0x61, 0x39, 0x63, 0x31, 0x33, 0x64, 0x37, 0x32, 0x30, 0x32, 0x37, 0x65, 0x63, 0x35, 0x62, 0x61, 0x38, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x33, 0x35, 0x63, 0x66, 0x64, 0x62, 0x63, 0x62, 0x39, 0x39, 0x33, 0x33, 0x39, 0x35, 0x35, 0x33, 0x37, 0x61, 0x65, 0x63, 0x63, 0x39, 0x66, 0x35, 0x39, 0x30, 0x38, 0x35, 0x61, 0x38, 0x64, 0x35, 0x64, 0x64, 0x62, 0x36, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x65, 0x32, 0x62, 0x36, 0x64, 0x36, 0x30, 0x36, 0x66, 0x64, 0x32, 0x64, 0x36, 0x39, 0x39, 0x31, 0x63, 0x39, 0x64, 0x36, 0x64, 0x34, 0x30, 0x37, 0x37, 0x66, 0x64, 0x66, 0x33, 0x66, 0x64, 0x64, 0x34, 0x35, 0x38, 0x35, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x30, 0x66, 0x35, 0x66, 0x66, 0x63, 0x31, 0x30, 0x64, 0x65, 0x37, 0x36, 0x37, 0x64, 0x65, 0x64, 0x38, 0x30, 0x37, 0x66, 0x37, 0x31, 0x65, 0x38, 0x36, 0x31, 0x64, 0x36, 0x34, 0x37, 0x64, 0x66, 0x64, 0x32, 0x31, 0x39, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x36, 0x34, 0x34, 0x61, 0x35, 0x30, 0x63, 0x62, 0x63, 0x32, 0x61, 0x65, 0x65, 0x38, 0x32, 0x33, 0x62, 0x64, 0x32, 0x62, 0x66, 0x32, 0x34, 0x33, 0x65, 0x38, 0x32, 0x35, 0x62, 0x65, 0x34, 0x64, 0x34, 0x37, 0x64, 0x66, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x34, 0x35, 0x35, 0x62, 0x34, 0x31, 0x31, 0x37, 0x36, 0x35, 0x64, 0x36, 0x39, 0x30, 0x31, 0x65, 0x33, 0x31, 0x31, 0x65, 0x37, 0x32, 0x36, 0x34, 0x30, 0x33, 0x30, 0x39, 0x31, 0x65, 0x34, 0x32, 0x63, 0x35, 0x36, 0x36, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x38, 0x36, 0x65, 0x65, 0x39, 0x34, 0x38, 0x36, 0x32, 0x62, 0x37, 0x34, 0x33, 0x64, 0x64, 0x33, 0x34, 0x66, 0x34, 0x31, 0x30, 0x39, 0x36, 0x39, 0x64, 0x39, 0x34, 0x65, 0x32, 0x63, 0x35, 0x36, 0x35, 0x32, 0x64, 0x34, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x37, 0x33, 0x36, 0x30, 0x66, 0x30, 0x30, 0x32, 0x65, 0x30, 0x64, 0x36, 0x34, 0x64, 0x32, 0x64, 0x37, 0x34, 0x34, 0x35, 0x37, 0x64, 0x38, 0x63, 0x61, 0x34, 0x38, 0x35, 0x37, 0x65, 0x65, 0x30, 0x30, 0x62, 0x63, 0x64, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x35, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x39, 0x62, 0x33, 0x62, 0x64, 0x33, 0x30, 0x30, 0x38, 0x39, 0x33, 0x66, 0x39, 0x37, 0x32, 0x33, 0x33, 0x65, 0x66, 0x39, 0x34, 0x37, 0x63, 0x34, 0x36, 0x66, 0x37, 0x32, 0x31, 0x37, 0x65, 0x33, 0x39, 0x32, 0x66, 0x37, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x33, 0x61, 0x37, 0x34, 0x66, 0x64, 0x35, 0x65, 0x37, 0x65, 0x64, 0x63, 0x63, 0x31, 0x31, 0x36, 0x32, 0x39, 0x39, 0x33, 0x31, 0x37, 0x31, 0x33, 0x38, 0x31, 0x63, 0x62, 0x62, 0x36, 0x33, 0x32, 0x62, 0x37, 0x63, 0x66, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x35, 0x64, 0x35, 0x63, 0x61, 0x61, 0x36, 0x30, 0x39, 0x62, 0x66, 0x37, 0x30, 0x61, 0x31, 0x38, 0x61, 0x63, 0x61, 0x35, 0x38, 0x30, 0x34, 0x36, 0x35, 0x64, 0x38, 0x66, 0x62, 0x37, 0x33, 0x31, 0x30, 0x64, 0x31, 0x62, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x66, 0x36, 0x30, 0x39, 0x63, 0x61, 0x38, 0x37, 0x32, 0x30, 0x61, 0x30, 0x32, 0x33, 0x32, 0x36, 0x32, 0x63, 0x35, 0x35, 0x63, 0x34, 0x36, 0x66, 0x32, 0x64, 0x32, 0x36, 0x66, 0x62, 0x33, 0x39, 0x33, 0x30, 0x61, 0x63, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x61, 0x63, 0x34, 0x61, 0x33, 0x39, 0x62, 0x35, 0x33, 0x63, 0x31, 0x31, 0x33, 0x30, 0x37, 0x38, 0x32, 0x30, 0x39, 0x37, 0x33, 0x62, 0x34, 0x34, 0x31, 0x33, 0x36, 0x35, 0x63, 0x66, 0x66, 0x65, 0x35, 0x39, 0x36, 0x66, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x32, 0x36, 0x33, 0x34, 0x62, 0x34, 0x65, 0x63, 0x33, 0x30, 0x66, 0x66, 0x37, 0x38, 0x36, 0x65, 0x30, 0x32, 0x34, 0x31, 0x35, 0x39, 0x66, 0x37, 0x39, 0x36, 0x61, 0x35, 0x37, 0x39, 0x33, 0x39, 0x65, 0x61, 0x31, 0x34, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x64, 0x32, 0x63, 0x32, 0x38, 0x65, 0x65, 0x39, 0x62, 0x63, 0x35, 0x34, 0x35, 0x65, 0x61, 0x61, 0x66, 0x37, 0x66, 0x64, 0x31, 0x34, 0x63, 0x32, 0x37, 0x63, 0x34, 0x30, 0x37, 0x33, 0x62, 0x34, 0x62, 0x62, 0x35, 0x66, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x34, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x63, 0x63, 0x34, 0x36, 0x61, 0x61, 0x33, 0x37, 0x39, 0x66, 0x38, 0x35, 0x36, 0x61, 0x36, 0x36, 0x34, 0x30, 0x64, 0x63, 0x63, 0x64, 0x35, 0x61, 0x36, 0x34, 0x38, 0x61, 0x37, 0x39, 0x30, 0x32, 0x66, 0x38, 0x34, 0x39, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x36, 0x34, 0x34, 0x30, 0x63, 0x37, 0x39, 0x37, 0x61, 0x35, 0x35, 0x36, 0x65, 0x30, 0x34, 0x63, 0x37, 0x64, 0x39, 0x31, 0x30, 0x34, 0x36, 0x36, 0x30, 0x34, 0x39, 0x31, 0x66, 0x39, 0x36, 0x62, 0x62, 0x30, 0x37, 0x36, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x39, 0x36, 0x38, 0x37, 0x39, 0x37, 0x34, 0x36, 0x38, 0x65, 0x66, 0x37, 0x36, 0x37, 0x31, 0x30, 0x31, 0x62, 0x37, 0x36, 0x31, 0x64, 0x34, 0x33, 0x31, 0x66, 0x63, 0x65, 0x31, 0x34, 0x61, 0x62, 0x66, 0x66, 0x64, 0x62, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x38, 0x39, 0x35, 0x65, 0x66, 0x64, 0x30, 0x35, 0x36, 0x64, 0x39, 0x61, 0x33, 0x61, 0x38, 0x31, 0x63, 0x33, 0x64, 0x61, 0x35, 0x37, 0x38, 0x61, 0x64, 0x61, 0x33, 0x31, 0x31, 0x62, 0x66, 0x62, 0x39, 0x33, 0x35, 0x36, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x38, 0x34, 0x36, 0x66, 0x30, 0x64, 0x65, 0x30, 0x33, 0x62, 0x35, 0x61, 0x37, 0x36, 0x39, 0x37, 0x31, 0x65, 0x61, 0x64, 0x32, 0x39, 0x38, 0x63, 0x64, 0x64, 0x30, 0x38, 0x38, 0x34, 0x33, 0x61, 0x34, 0x62, 0x63, 0x36, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x37, 0x30, 0x38, 0x65, 0x61, 0x66, 0x33, 0x39, 0x64, 0x38, 0x32, 0x33, 0x39, 0x34, 0x36, 0x63, 0x35, 0x31, 0x62, 0x33, 0x61, 0x33, 0x65, 0x39, 0x62, 0x37, 0x62, 0x33, 0x63, 0x30, 0x30, 0x33, 0x65, 0x32, 0x36, 0x33, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x66, 0x37, 0x34, 0x35, 0x30, 0x64, 0x64, 0x62, 0x66, 0x31, 0x38, 0x62, 0x30, 0x32, 0x30, 0x66, 0x65, 0x62, 0x31, 0x61, 0x32, 0x30, 0x33, 0x32, 0x64, 0x39, 0x64, 0x35, 0x34, 0x62, 0x36, 0x33, 0x33, 0x65, 0x64, 0x66, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x65, 0x33, 0x61, 0x32, 0x35, 0x33, 0x62, 0x63, 0x62, 0x32, 0x63, 0x66, 0x34, 0x65, 0x31, 0x33, 0x62, 0x61, 0x38, 0x30, 0x63, 0x32, 0x39, 0x38, 0x61, 0x62, 0x30, 0x34, 0x30, 0x32, 0x64, 0x61, 0x37, 0x63, 0x32, 0x61, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x65, 0x38, 0x38, 0x31, 0x30, 0x36, 0x35, 0x32, 0x65, 0x38, 0x65, 0x36, 0x31, 0x36, 0x31, 0x35, 0x32, 0x35, 0x64, 0x36, 0x33, 0x62, 0x62, 0x37, 0x37, 0x35, 0x31, 0x64, 0x63, 0x32, 0x30, 0x66, 0x36, 0x37, 0x36, 0x30, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x36, 0x32, 0x39, 0x63, 0x39, 0x35, 0x63, 0x64, 0x65, 0x66, 0x34, 0x32, 0x38, 0x61, 0x64, 0x33, 0x37, 0x64, 0x34, 0x35, 0x33, 0x63, 0x61, 0x39, 0x35, 0x33, 0x38, 0x61, 0x39, 0x66, 0x39, 0x30, 0x39, 0x30, 0x30, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x37, 0x39, 0x65, 0x64, 0x64, 0x34, 0x38, 0x34, 0x35, 0x62, 0x30, 0x37, 0x36, 0x65, 0x34, 0x63, 0x64, 0x38, 0x38, 0x64, 0x31, 0x38, 0x38, 0x62, 0x36, 0x65, 0x34, 0x33, 0x32, 0x64, 0x64, 0x39, 0x33, 0x66, 0x33, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x33, 0x32, 0x35, 0x64, 0x34, 0x30, 0x32, 0x39, 0x65, 0x30, 0x64, 0x38, 0x37, 0x32, 0x39, 0x66, 0x36, 0x64, 0x33, 0x39, 0x39, 0x63, 0x34, 0x37, 0x38, 0x32, 0x32, 0x34, 0x61, 0x65, 0x39, 0x65, 0x37, 0x61, 0x65, 0x34, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x63, 0x65, 0x63, 0x66, 0x64, 0x32, 0x39, 0x32, 0x31, 0x30, 0x37, 0x39, 0x63, 0x32, 0x64, 0x37, 0x64, 0x66, 0x33, 0x66, 0x30, 0x38, 0x62, 0x30, 0x37, 0x61, 0x61, 0x33, 0x62, 0x65, 0x65, 0x65, 0x35, 0x65, 0x32, 0x31, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x39, 0x30, 0x32, 0x34, 0x36, 0x62, 0x61, 0x33, 0x63, 0x38, 0x30, 0x36, 0x37, 0x39, 0x65, 0x32, 0x32, 0x65, 0x61, 0x63, 0x34, 0x34, 0x31, 0x32, 0x61, 0x31, 0x61, 0x65, 0x66, 0x63, 0x65, 0x36, 0x64, 0x37, 0x63, 0x64, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x37, 0x61, 0x65, 0x65, 0x65, 0x38, 0x64, 0x34, 0x62, 0x63, 0x30, 0x38, 0x66, 0x63, 0x39, 0x37, 0x61, 0x62, 0x31, 0x35, 0x36, 0x65, 0x64, 0x35, 0x37, 0x66, 0x62, 0x39, 0x37, 0x30, 0x39, 0x32, 0x35, 0x33, 0x36, 0x36, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x33, 0x30, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x30, 0x30, 0x62, 0x66, 0x34, 0x33, 0x39, 0x39, 0x31, 0x31, 0x61, 0x35, 0x35, 0x33, 0x39, 0x38, 0x32, 0x64, 0x62, 0x36, 0x33, 0x38, 0x30, 0x33, 0x39, 0x32, 0x34, 0x35, 0x62, 0x63, 0x66, 0x30, 0x33, 0x32, 0x64, 0x62, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x66, 0x36, 0x32, 0x34, 0x62, 0x32, 0x34, 0x61, 0x31, 0x66, 0x61, 0x35, 0x61, 0x30, 0x35, 0x36, 0x66, 0x65, 0x35, 0x37, 0x31, 0x32, 0x32, 0x39, 0x65, 0x37, 0x33, 0x37, 0x39, 0x64, 0x62, 0x31, 0x34, 0x62, 0x39, 0x61, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x39, 0x39, 0x39, 0x39, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x30, 0x36, 0x64, 0x33, 0x32, 0x38, 0x65, 0x34, 0x37, 0x31, 0x64, 0x30, 0x31, 0x31, 0x37, 0x62, 0x32, 0x34, 0x36, 0x64, 0x32, 0x61, 0x34, 0x36, 0x31, 0x39, 0x38, 0x32, 0x37, 0x37, 0x30, 0x39, 0x65, 0x39, 0x36, 0x64, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x33, 0x66, 0x31, 0x65, 0x64, 0x31, 0x63, 0x39, 0x63, 0x33, 0x65, 0x39, 0x63, 0x35, 0x32, 0x61, 0x39, 0x62, 0x30, 0x32, 0x34, 0x39, 0x61, 0x35, 0x63, 0x31, 0x63, 0x61, 0x61, 0x30, 0x35, 0x37, 0x31, 0x66, 0x64, 0x66, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x36, 0x30, 0x34, 0x38, 0x64, 0x64, 0x32, 0x31, 0x38, 0x31, 0x64, 0x34, 0x61, 0x33, 0x36, 0x66, 0x36, 0x34, 0x66, 0x63, 0x65, 0x63, 0x63, 0x36, 0x32, 0x31, 0x35, 0x34, 0x38, 0x31, 0x65, 0x34, 0x32, 0x61, 0x62, 0x63, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x37, 0x36, 0x61, 0x34, 0x63, 0x64, 0x38, 0x66, 0x65, 0x62, 0x63, 0x62, 0x63, 0x39, 0x62, 0x38, 0x31, 0x38, 0x66, 0x31, 0x37, 0x38, 0x32, 0x38, 0x66, 0x38, 0x64, 0x39, 0x33, 0x34, 0x37, 0x33, 0x66, 0x33, 0x66, 0x33, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x33, 0x31, 0x65, 0x30, 0x65, 0x63, 0x62, 0x35, 0x34, 0x39, 0x38, 0x35, 0x61, 0x65, 0x32, 0x31, 0x61, 0x66, 0x31, 0x37, 0x39, 0x33, 0x39, 0x35, 0x30, 0x64, 0x63, 0x38, 0x31, 0x31, 0x38, 0x38, 0x38, 0x66, 0x64, 0x65, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x30, 0x66, 0x65, 0x65, 0x33, 0x38, 0x36, 0x38, 0x35, 0x61, 0x39, 0x34, 0x61, 0x61, 0x62, 0x63, 0x64, 0x37, 0x63, 0x65, 0x38, 0x35, 0x37, 0x62, 0x36, 0x62, 0x31, 0x34, 0x30, 0x39, 0x38, 0x32, 0x34, 0x66, 0x37, 0x35, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x63, 0x62, 0x65, 0x66, 0x38, 0x34, 0x65, 0x31, 0x36, 0x39, 0x36, 0x33, 0x30, 0x30, 0x39, 0x38, 0x64, 0x34, 0x65, 0x33, 0x30, 0x31, 0x62, 0x32, 0x30, 0x32, 0x30, 0x38, 0x65, 0x66, 0x30, 0x35, 0x38, 0x34, 0x36, 0x61, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x63, 0x61, 0x36, 0x35, 0x62, 0x33, 0x32, 0x36, 0x36, 0x65, 0x61, 0x32, 0x66, 0x62, 0x37, 0x33, 0x61, 0x30, 0x33, 0x66, 0x39, 0x32, 0x31, 0x36, 0x33, 0x35, 0x66, 0x39, 0x31, 0x32, 0x63, 0x37, 0x62, 0x65, 0x64, 0x65, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x65, 0x63, 0x32, 0x65, 0x34, 0x32, 0x36, 0x65, 0x64, 0x36, 0x63, 0x63, 0x30, 0x63, 0x66, 0x33, 0x63, 0x32, 0x34, 0x39, 0x63, 0x31, 0x38, 0x39, 0x37, 0x65, 0x61, 0x63, 0x34, 0x37, 0x61, 0x37, 0x66, 0x61, 0x61, 0x39, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x66, 0x33, 0x30, 0x37, 0x35, 0x38, 0x66, 0x61, 0x61, 0x38, 0x30, 0x38, 0x64, 0x62, 0x63, 0x39, 0x31, 0x39, 0x61, 0x61, 0x37, 0x62, 0x34, 0x32, 0x35, 0x65, 0x63, 0x39, 0x32, 0x32, 0x62, 0x39, 0x33, 0x62, 0x38, 0x31, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x36, 0x64, 0x63, 0x66, 0x30, 0x30, 0x30, 0x31, 0x39, 0x34, 0x65, 0x33, 0x62, 0x66, 0x66, 0x35, 0x30, 0x61, 0x63, 0x35, 0x62, 0x34, 0x32, 0x34, 0x33, 0x61, 0x33, 0x62, 0x61, 0x30, 0x31, 0x34, 0x64, 0x36, 0x36, 0x31, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x34, 0x64, 0x64, 0x62, 0x30, 0x33, 0x38, 0x36, 0x66, 0x62, 0x36, 0x30, 0x36, 0x33, 0x39, 0x38, 0x62, 0x38, 0x63, 0x63, 0x34, 0x37, 0x35, 0x36, 0x35, 0x61, 0x66, 0x61, 0x65, 0x30, 0x30, 0x66, 0x66, 0x31, 0x64, 0x36, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x37, 0x33, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x63, 0x39, 0x35, 0x38, 0x32, 0x32, 0x65, 0x62, 0x38, 0x38, 0x37, 0x62, 0x63, 0x31, 0x31, 0x33, 0x62, 0x34, 0x37, 0x31, 0x32, 0x61, 0x34, 0x64, 0x66, 0x64, 0x37, 0x66, 0x31, 0x33, 0x62, 0x30, 0x39, 0x37, 0x62, 0x35, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x33, 0x36, 0x61, 0x35, 0x61, 0x66, 0x36, 0x63, 0x33, 0x32, 0x39, 0x39, 0x63, 0x36, 0x62, 0x35, 0x66, 0x30, 0x30, 0x35, 0x66, 0x64, 0x61, 0x64, 0x64, 0x62, 0x31, 0x34, 0x38, 0x63, 0x30, 0x37, 0x30, 0x62, 0x32, 0x39, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x33, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x63, 0x62, 0x38, 0x36, 0x38, 0x64, 0x32, 0x63, 0x33, 0x66, 0x39, 0x35, 0x62, 0x32, 0x35, 0x37, 0x36, 0x31, 0x31, 0x65, 0x62, 0x33, 0x34, 0x61, 0x34, 0x31, 0x38, 0x38, 0x64, 0x35, 0x38, 0x62, 0x37, 0x34, 0x39, 0x38, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x37, 0x66, 0x30, 0x39, 0x64, 0x37, 0x65, 0x64, 0x36, 0x36, 0x64, 0x30, 0x63, 0x33, 0x38, 0x62, 0x63, 0x35, 0x61, 0x64, 0x34, 0x65, 0x33, 0x32, 0x62, 0x37, 0x66, 0x32, 0x62, 0x30, 0x38, 0x64, 0x63, 0x31, 0x62, 0x33, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x66, 0x61, 0x38, 0x31, 0x38, 0x34, 0x65, 0x34, 0x33, 0x65, 0x64, 0x33, 0x65, 0x30, 0x62, 0x38, 0x61, 0x62, 0x39, 0x31, 0x32, 0x31, 0x36, 0x34, 0x36, 0x31, 0x62, 0x33, 0x35, 0x32, 0x38, 0x64, 0x38, 0x34, 0x66, 0x64, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x62, 0x66, 0x30, 0x64, 0x62, 0x66, 0x64, 0x37, 0x37, 0x38, 0x39, 0x30, 0x38, 0x30, 0x30, 0x35, 0x33, 0x33, 0x66, 0x30, 0x39, 0x64, 0x65, 0x61, 0x38, 0x33, 0x30, 0x31, 0x62, 0x39, 0x66, 0x30, 0x32, 0x35, 0x64, 0x32, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x35, 0x33, 0x64, 0x32, 0x35, 0x64, 0x36, 0x62, 0x35, 0x34, 0x32, 0x31, 0x65, 0x38, 0x31, 0x63, 0x32, 0x61, 0x64, 0x30, 0x35, 0x65, 0x30, 0x62, 0x38, 0x62, 0x61, 0x37, 0x35, 0x31, 0x66, 0x38, 0x66, 0x30, 0x31, 0x30, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x66, 0x38, 0x62, 0x31, 0x33, 0x39, 0x36, 0x37, 0x66, 0x35, 0x35, 0x31, 0x32, 0x35, 0x32, 0x37, 0x32, 0x64, 0x65, 0x30, 0x35, 0x36, 0x32, 0x35, 0x33, 0x36, 0x63, 0x34, 0x35, 0x30, 0x62, 0x61, 0x35, 0x36, 0x35, 0x35, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x36, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x36, 0x65, 0x38, 0x34, 0x30, 0x61, 0x33, 0x66, 0x32, 0x61, 0x32, 0x34, 0x36, 0x34, 0x37, 0x64, 0x38, 0x65, 0x34, 0x33, 0x65, 0x30, 0x39, 0x64, 0x34, 0x35, 0x63, 0x37, 0x63, 0x33, 0x33, 0x35, 0x64, 0x66, 0x34, 0x32, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x32, 0x66, 0x64, 0x32, 0x39, 0x64, 0x30, 0x33, 0x66, 0x65, 0x65, 0x39, 0x61, 0x30, 0x37, 0x38, 0x39, 0x33, 0x64, 0x66, 0x33, 0x61, 0x32, 0x36, 0x39, 0x66, 0x35, 0x36, 0x62, 0x37, 0x32, 0x66, 0x32, 0x65, 0x31, 0x65, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x35, 0x37, 0x62, 0x32, 0x62, 0x63, 0x38, 0x33, 0x63, 0x63, 0x38, 0x64, 0x34, 0x64, 0x65, 0x33, 0x33, 0x31, 0x32, 0x30, 0x34, 0x65, 0x38, 0x39, 0x33, 0x66, 0x32, 0x66, 0x33, 0x62, 0x31, 0x64, 0x62, 0x31, 0x30, 0x37, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x35, 0x34, 0x31, 0x34, 0x39, 0x31, 0x64, 0x32, 0x61, 0x63, 0x30, 0x30, 0x64, 0x32, 0x36, 0x31, 0x32, 0x66, 0x39, 0x34, 0x61, 0x61, 0x37, 0x66, 0x30, 0x62, 0x63, 0x62, 0x30, 0x31, 0x34, 0x36, 0x35, 0x31, 0x66, 0x62, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x34, 0x61, 0x39, 0x62, 0x65, 0x31, 0x30, 0x63, 0x64, 0x35, 0x64, 0x33, 0x66, 0x62, 0x35, 0x64, 0x65, 0x34, 0x38, 0x63, 0x31, 0x37, 0x62, 0x65, 0x32, 0x39, 0x36, 0x66, 0x38, 0x39, 0x35, 0x36, 0x39, 0x30, 0x36, 0x34, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x64, 0x31, 0x63, 0x39, 0x65, 0x65, 0x64, 0x66, 0x37, 0x63, 0x61, 0x62, 0x34, 0x31, 0x61, 0x37, 0x37, 0x39, 0x30, 0x35, 0x37, 0x62, 0x37, 0x39, 0x33, 0x39, 0x35, 0x66, 0x35, 0x34, 0x32, 0x38, 0x64, 0x38, 0x30, 0x35, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x32, 0x33, 0x33, 0x34, 0x38, 0x31, 0x34, 0x37, 0x32, 0x34, 0x39, 0x33, 0x35, 0x62, 0x37, 0x39, 0x33, 0x31, 0x64, 0x64, 0x63, 0x61, 0x36, 0x31, 0x30, 0x30, 0x65, 0x30, 0x30, 0x64, 0x34, 0x36, 0x37, 0x37, 0x32, 0x37, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x35, 0x32, 0x63, 0x39, 0x38, 0x34, 0x31, 0x30, 0x32, 0x65, 0x65, 0x30, 0x63, 0x64, 0x33, 0x65, 0x33, 0x31, 0x38, 0x32, 0x31, 0x62, 0x38, 0x34, 0x64, 0x34, 0x30, 0x38, 0x39, 0x33, 0x30, 0x65, 0x66, 0x61, 0x31, 0x61, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x30, 0x64, 0x38, 0x33, 0x36, 0x32, 0x30, 0x31, 0x33, 0x31, 0x38, 0x65, 0x63, 0x36, 0x38, 0x39, 0x39, 0x61, 0x36, 0x37, 0x35, 0x34, 0x30, 0x36, 0x39, 0x30, 0x33, 0x38, 0x32, 0x37, 0x38, 0x30, 0x37, 0x34, 0x33, 0x32, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x34, 0x39, 0x38, 0x63, 0x61, 0x30, 0x37, 0x62, 0x30, 0x66, 0x32, 0x66, 0x31, 0x37, 0x65, 0x38, 0x62, 0x62, 0x63, 0x37, 0x65, 0x36, 0x31, 0x61, 0x37, 0x66, 0x34, 0x61, 0x65, 0x37, 0x62, 0x65, 0x36, 0x36, 0x62, 0x37, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x36, 0x30, 0x61, 0x33, 0x64, 0x65, 0x33, 0x38, 0x64, 0x66, 0x33, 0x38, 0x32, 0x61, 0x65, 0x34, 0x61, 0x34, 0x64, 0x63, 0x65, 0x31, 0x38, 0x63, 0x30, 0x63, 0x30, 0x37, 0x62, 0x39, 0x38, 0x62, 0x63, 0x65, 0x33, 0x64, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x38, 0x65, 0x34, 0x64, 0x66, 0x31, 0x38, 0x63, 0x66, 0x30, 0x61, 0x66, 0x37, 0x37, 0x30, 0x39, 0x37, 0x38, 0x61, 0x38, 0x64, 0x66, 0x38, 0x64, 0x61, 0x63, 0x39, 0x30, 0x39, 0x33, 0x31, 0x35, 0x31, 0x30, 0x61, 0x36, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x64, 0x36, 0x38, 0x64, 0x61, 0x64, 0x36, 0x31, 0x64, 0x33, 0x62, 0x62, 0x64, 0x66, 0x62, 0x33, 0x66, 0x37, 0x37, 0x39, 0x32, 0x36, 0x35, 0x63, 0x34, 0x39, 0x34, 0x37, 0x34, 0x61, 0x66, 0x66, 0x33, 0x66, 0x63, 0x64, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x33, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x65, 0x61, 0x66, 0x62, 0x66, 0x32, 0x66, 0x62, 0x36, 0x66, 0x34, 0x64, 0x62, 0x39, 0x61, 0x34, 0x33, 0x36, 0x61, 0x37, 0x34, 0x63, 0x34, 0x35, 0x62, 0x35, 0x36, 0x35, 0x34, 0x34, 0x35, 0x32, 0x65, 0x32, 0x33, 0x38, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x64, 0x37, 0x66, 0x32, 0x63, 0x61, 0x61, 0x34, 0x36, 0x32, 0x61, 0x34, 0x31, 0x62, 0x33, 0x62, 0x33, 0x30, 0x61, 0x33, 0x34, 0x61, 0x65, 0x62, 0x33, 0x62, 0x61, 0x36, 0x31, 0x30, 0x31, 0x30, 0x65, 0x32, 0x36, 0x32, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x37, 0x31, 0x66, 0x35, 0x35, 0x34, 0x31, 0x32, 0x32, 0x34, 0x36, 0x39, 0x65, 0x66, 0x39, 0x37, 0x38, 0x65, 0x32, 0x66, 0x31, 0x66, 0x65, 0x66, 0x64, 0x37, 0x63, 0x62, 0x62, 0x34, 0x31, 0x30, 0x39, 0x38, 0x32, 0x37, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x34, 0x36, 0x36, 0x36, 0x63, 0x65, 0x38, 0x39, 0x33, 0x31, 0x31, 0x37, 0x35, 0x65, 0x31, 0x31, 0x61, 0x35, 0x65, 0x64, 0x31, 0x31, 0x63, 0x31, 0x64, 0x63, 0x61, 0x61, 0x30, 0x36, 0x65, 0x35, 0x37, 0x66, 0x34, 0x65, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x37, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x30, 0x66, 0x30, 0x36, 0x37, 0x32, 0x38, 0x36, 0x63, 0x30, 0x66, 0x62, 0x64, 0x30, 0x38, 0x32, 0x66, 0x39, 0x66, 0x34, 0x61, 0x36, 0x31, 0x30, 0x38, 0x33, 0x65, 0x63, 0x37, 0x36, 0x64, 0x65, 0x62, 0x33, 0x63, 0x65, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x65, 0x34, 0x63, 0x62, 0x32, 0x32, 0x62, 0x65, 0x34, 0x36, 0x32, 0x35, 0x38, 0x61, 0x34, 0x30, 0x65, 0x31, 0x36, 0x64, 0x34, 0x33, 0x33, 0x38, 0x64, 0x38, 0x30, 0x32, 0x66, 0x66, 0x66, 0x64, 0x30, 0x30, 0x63, 0x31, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x39, 0x37, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x31, 0x33, 0x64, 0x33, 0x38, 0x36, 0x33, 0x37, 0x62, 0x39, 0x61, 0x34, 0x37, 0x63, 0x65, 0x37, 0x39, 0x64, 0x33, 0x37, 0x61, 0x38, 0x36, 0x66, 0x35, 0x30, 0x66, 0x62, 0x34, 0x30, 0x39, 0x63, 0x30, 0x36, 0x30, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x30, 0x32, 0x31, 0x32, 0x62, 0x32, 0x30, 0x31, 0x31, 0x62, 0x62, 0x35, 0x36, 0x62, 0x64, 0x62, 0x66, 0x31, 0x62, 0x63, 0x33, 0x35, 0x36, 0x39, 0x30, 0x66, 0x33, 0x61, 0x34, 0x65, 0x30, 0x66, 0x64, 0x39, 0x30, 0x35, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x66, 0x36, 0x39, 0x31, 0x31, 0x36, 0x37, 0x32, 0x36, 0x37, 0x39, 0x62, 0x62, 0x30, 0x65, 0x66, 0x33, 0x35, 0x30, 0x39, 0x30, 0x33, 0x38, 0x63, 0x30, 0x63, 0x32, 0x37, 0x65, 0x33, 0x39, 0x34, 0x66, 0x64, 0x66, 0x65, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x38, 0x66, 0x65, 0x34, 0x31, 0x36, 0x36, 0x65, 0x32, 0x33, 0x64, 0x31, 0x31, 0x39, 0x36, 0x33, 0x63, 0x30, 0x39, 0x33, 0x32, 0x62, 0x38, 0x61, 0x64, 0x65, 0x38, 0x65, 0x30, 0x31, 0x34, 0x35, 0x65, 0x61, 0x30, 0x37, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x30, 0x39, 0x65, 0x65, 0x62, 0x31, 0x33, 0x34, 0x37, 0x65, 0x38, 0x34, 0x32, 0x66, 0x66, 0x62, 0x34, 0x31, 0x33, 0x65, 0x33, 0x37, 0x31, 0x35, 0x35, 0x65, 0x32, 0x63, 0x62, 0x63, 0x37, 0x33, 0x38, 0x32, 0x37, 0x33, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x37, 0x65, 0x39, 0x66, 0x36, 0x66, 0x30, 0x35, 0x66, 0x37, 0x65, 0x33, 0x36, 0x34, 0x37, 0x36, 0x61, 0x31, 0x36, 0x65, 0x33, 0x65, 0x37, 0x31, 0x30, 0x30, 0x63, 0x39, 0x30, 0x33, 0x31, 0x63, 0x66, 0x34, 0x30, 0x34, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x63, 0x38, 0x63, 0x61, 0x66, 0x37, 0x65, 0x65, 0x34, 0x39, 0x34, 0x36, 0x38, 0x66, 0x65, 0x65, 0x35, 0x35, 0x32, 0x65, 0x66, 0x66, 0x33, 0x61, 0x63, 0x35, 0x32, 0x33, 0x34, 0x65, 0x62, 0x39, 0x62, 0x31, 0x37, 0x64, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x38, 0x39, 0x38, 0x62, 0x62, 0x62, 0x34, 0x35, 0x35, 0x33, 0x65, 0x30, 0x30, 0x62, 0x62, 0x66, 0x64, 0x30, 0x63, 0x66, 0x32, 0x36, 0x38, 0x62, 0x32, 0x66, 0x63, 0x34, 0x36, 0x34, 0x64, 0x31, 0x35, 0x34, 0x61, 0x64, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x62, 0x33, 0x31, 0x38, 0x39, 0x65, 0x34, 0x62, 0x64, 0x37, 0x66, 0x34, 0x35, 0x66, 0x31, 0x37, 0x38, 0x62, 0x31, 0x63, 0x33, 0x30, 0x63, 0x37, 0x36, 0x65, 0x32, 0x36, 0x33, 0x31, 0x34, 0x64, 0x34, 0x61, 0x34, 0x62, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x31, 0x63, 0x64, 0x37, 0x66, 0x34, 0x63, 0x34, 0x37, 0x32, 0x30, 0x37, 0x30, 0x39, 0x36, 0x38, 0x66, 0x33, 0x62, 0x64, 0x65, 0x32, 0x36, 0x38, 0x33, 0x36, 0x36, 0x62, 0x32, 0x31, 0x65, 0x65, 0x65, 0x61, 0x38, 0x33, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x36, 0x61, 0x31, 0x38, 0x35, 0x33, 0x36, 0x61, 0x66, 0x34, 0x31, 0x38, 0x37, 0x34, 0x34, 0x32, 0x36, 0x33, 0x30, 0x38, 0x38, 0x37, 0x31, 0x62, 0x63, 0x64, 0x31, 0x35, 0x31, 0x32, 0x61, 0x37, 0x37, 0x35, 0x63, 0x39, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x63, 0x37, 0x35, 0x38, 0x66, 0x38, 0x64, 0x61, 0x34, 0x31, 0x65, 0x33, 0x33, 0x34, 0x36, 0x65, 0x34, 0x33, 0x35, 0x30, 0x65, 0x35, 0x61, 0x63, 0x33, 0x39, 0x37, 0x36, 0x33, 0x34, 0x35, 0x63, 0x36, 0x63, 0x31, 0x30, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x65, 0x63, 0x38, 0x61, 0x35, 0x62, 0x37, 0x34, 0x33, 0x66, 0x33, 0x34, 0x37, 0x39, 0x65, 0x37, 0x30, 0x37, 0x64, 0x61, 0x65, 0x39, 0x65, 0x65, 0x32, 0x30, 0x64, 0x64, 0x61, 0x61, 0x34, 0x66, 0x34, 0x30, 0x66, 0x31, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x30, 0x31, 0x37, 0x36, 0x35, 0x61, 0x66, 0x66, 0x30, 0x38, 0x62, 0x63, 0x32, 0x32, 0x30, 0x35, 0x35, 0x30, 0x61, 0x63, 0x61, 0x35, 0x65, 0x61, 0x32, 0x65, 0x31, 0x63, 0x65, 0x38, 0x65, 0x35, 0x62, 0x30, 0x39, 0x39, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x30, 0x66, 0x33, 0x39, 0x30, 0x32, 0x33, 0x62, 0x64, 0x62, 0x32, 0x39, 0x65, 0x62, 0x31, 0x38, 0x36, 0x32, 0x61, 0x39, 0x66, 0x39, 0x30, 0x35, 0x39, 0x63, 0x61, 0x62, 0x35, 0x64, 0x33, 0x30, 0x36, 0x65, 0x36, 0x36, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x61, 0x66, 0x38, 0x64, 0x36, 0x65, 0x32, 0x32, 0x31, 0x31, 0x37, 0x34, 0x31, 0x32, 0x34, 0x38, 0x32, 0x30, 0x65, 0x65, 0x34, 0x39, 0x32, 0x62, 0x39, 0x34, 0x35, 0x39, 0x65, 0x63, 0x34, 0x66, 0x61, 0x64, 0x61, 0x66, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x35, 0x64, 0x35, 0x63, 0x64, 0x37, 0x34, 0x38, 0x39, 0x36, 0x32, 0x39, 0x65, 0x32, 0x34, 0x31, 0x33, 0x63, 0x32, 0x31, 0x30, 0x35, 0x62, 0x35, 0x61, 0x31, 0x37, 0x32, 0x64, 0x39, 0x33, 0x33, 0x63, 0x32, 0x37, 0x61, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x34, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x64, 0x63, 0x32, 0x61, 0x65, 0x66, 0x39, 0x66, 0x35, 0x39, 0x35, 0x31, 0x61, 0x38, 0x64, 0x37, 0x38, 0x61, 0x36, 0x62, 0x33, 0x35, 0x63, 0x33, 0x64, 0x30, 0x62, 0x33, 0x61, 0x34, 0x65, 0x36, 0x65, 0x32, 0x65, 0x37, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x34, 0x66, 0x36, 0x65, 0x31, 0x64, 0x36, 0x34, 0x30, 0x31, 0x62, 0x35, 0x36, 0x63, 0x30, 0x37, 0x36, 0x62, 0x36, 0x34, 0x61, 0x31, 0x62, 0x30, 0x38, 0x36, 0x37, 0x64, 0x30, 0x62, 0x32, 0x66, 0x33, 0x31, 0x30, 0x64, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x38, 0x35, 0x36, 0x33, 0x38, 0x36, 0x37, 0x39, 0x30, 0x31, 0x32, 0x30, 0x36, 0x66, 0x33, 0x66, 0x32, 0x62, 0x66, 0x30, 0x66, 0x61, 0x33, 0x65, 0x31, 0x63, 0x38, 0x31, 0x30, 0x39, 0x63, 0x61, 0x62, 0x63, 0x63, 0x64, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x37, 0x66, 0x62, 0x65, 0x32, 0x32, 0x64, 0x39, 0x30, 0x34, 0x36, 0x32, 0x65, 0x64, 0x33, 0x37, 0x32, 0x38, 0x30, 0x36, 0x37, 0x30, 0x61, 0x32, 0x65, 0x61, 0x30, 0x62, 0x33, 0x30, 0x38, 0x36, 0x61, 0x30, 0x64, 0x36, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x36, 0x64, 0x37, 0x64, 0x34, 0x63, 0x64, 0x64, 0x31, 0x35, 0x35, 0x35, 0x33, 0x61, 0x34, 0x65, 0x34, 0x64, 0x33, 0x31, 0x36, 0x64, 0x36, 0x64, 0x36, 0x34, 0x38, 0x30, 0x63, 0x61, 0x33, 0x63, 0x65, 0x61, 0x31, 0x65, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x34, 0x64, 0x32, 0x63, 0x39, 0x31, 0x65, 0x66, 0x62, 0x36, 0x65, 0x39, 0x63, 0x34, 0x35, 0x66, 0x66, 0x62, 0x65, 0x37, 0x34, 0x62, 0x34, 0x33, 0x34, 0x63, 0x38, 0x63, 0x35, 0x66, 0x32, 0x62, 0x30, 0x32, 0x38, 0x66, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x31, 0x36, 0x34, 0x64, 0x65, 0x62, 0x31, 0x30, 0x38, 0x31, 0x34, 0x61, 0x65, 0x30, 0x38, 0x33, 0x39, 0x31, 0x66, 0x33, 0x32, 0x63, 0x30, 0x38, 0x36, 0x36, 0x37, 0x62, 0x36, 0x32, 0x34, 0x38, 0x63, 0x32, 0x37, 0x64, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x35, 0x61, 0x65, 0x30, 0x35, 0x61, 0x65, 0x30, 0x66, 0x38, 0x63, 0x62, 0x65, 0x35, 0x64, 0x66, 0x65, 0x37, 0x32, 0x31, 0x66, 0x30, 0x34, 0x34, 0x64, 0x37, 0x61, 0x37, 0x62, 0x65, 0x66, 0x34, 0x63, 0x32, 0x37, 0x39, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x38, 0x32, 0x35, 0x38, 0x36, 0x64, 0x36, 0x33, 0x62, 0x30, 0x64, 0x37, 0x34, 0x63, 0x32, 0x30, 0x31, 0x62, 0x31, 0x61, 0x66, 0x38, 0x34, 0x31, 0x38, 0x33, 0x37, 0x32, 0x65, 0x33, 0x30, 0x63, 0x37, 0x36, 0x31, 0x36, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x63, 0x66, 0x30, 0x39, 0x33, 0x35, 0x62, 0x66, 0x31, 0x39, 0x64, 0x32, 0x63, 0x65, 0x62, 0x62, 0x65, 0x63, 0x64, 0x38, 0x37, 0x38, 0x30, 0x64, 0x32, 0x37, 0x64, 0x32, 0x65, 0x32, 0x62, 0x32, 0x63, 0x33, 0x34, 0x31, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x35, 0x36, 0x36, 0x61, 0x64, 0x37, 0x62, 0x38, 0x38, 0x33, 0x66, 0x30, 0x31, 0x66, 0x64, 0x33, 0x39, 0x39, 0x38, 0x61, 0x39, 0x61, 0x35, 0x38, 0x61, 0x39, 0x64, 0x65, 0x65, 0x34, 0x37, 0x32, 0x34, 0x64, 0x64, 0x63, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x38, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x61, 0x36, 0x30, 0x39, 0x66, 0x61, 0x33, 0x61, 0x37, 0x65, 0x36, 0x63, 0x66, 0x32, 0x63, 0x63, 0x30, 0x65, 0x37, 0x30, 0x63, 0x64, 0x61, 0x62, 0x65, 0x37, 0x38, 0x64, 0x63, 0x34, 0x65, 0x33, 0x38, 0x32, 0x65, 0x31, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x36, 0x39, 0x31, 0x30, 0x30, 0x63, 0x33, 0x39, 0x35, 0x63, 0x65, 0x36, 0x63, 0x35, 0x65, 0x61, 0x61, 0x64, 0x66, 0x39, 0x35, 0x64, 0x30, 0x35, 0x64, 0x38, 0x37, 0x32, 0x38, 0x33, 0x37, 0x65, 0x64, 0x65, 0x64, 0x64, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x39, 0x31, 0x65, 0x63, 0x63, 0x66, 0x32, 0x62, 0x64, 0x35, 0x36, 0x36, 0x61, 0x66, 0x61, 0x31, 0x31, 0x36, 0x39, 0x36, 0x63, 0x35, 0x30, 0x34, 0x39, 0x66, 0x61, 0x38, 0x34, 0x63, 0x36, 0x39, 0x36, 0x33, 0x30, 0x61, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x35, 0x64, 0x30, 0x65, 0x65, 0x38, 0x31, 0x35, 0x35, 0x65, 0x63, 0x30, 0x61, 0x36, 0x66, 0x66, 0x36, 0x38, 0x30, 0x38, 0x35, 0x35, 0x32, 0x63, 0x61, 0x35, 0x66, 0x31, 0x36, 0x62, 0x62, 0x35, 0x62, 0x65, 0x33, 0x32, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x35, 0x63, 0x62, 0x38, 0x39, 0x32, 0x38, 0x63, 0x34, 0x31, 0x37, 0x38, 0x32, 0x35, 0x63, 0x30, 0x33, 0x61, 0x33, 0x62, 0x66, 0x63, 0x63, 0x35, 0x32, 0x31, 0x38, 0x33, 0x65, 0x35, 0x63, 0x39, 0x31, 0x65, 0x34, 0x32, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x36, 0x34, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x31, 0x62, 0x37, 0x37, 0x31, 0x66, 0x30, 0x39, 0x61, 0x66, 0x38, 0x38, 0x32, 0x61, 0x66, 0x30, 0x36, 0x34, 0x33, 0x30, 0x38, 0x33, 0x64, 0x65, 0x32, 0x61, 0x61, 0x37, 0x39, 0x64, 0x63, 0x30, 0x39, 0x37, 0x63, 0x34, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x61, 0x33, 0x38, 0x38, 0x62, 0x30, 0x64, 0x61, 0x32, 0x37, 0x63, 0x38, 0x37, 0x62, 0x31, 0x63, 0x63, 0x30, 0x65, 0x61, 0x63, 0x36, 0x63, 0x35, 0x37, 0x62, 0x32, 0x63, 0x35, 0x61, 0x30, 0x62, 0x34, 0x35, 0x39, 0x63, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x32, 0x39, 0x66, 0x33, 0x37, 0x39, 0x37, 0x62, 0x62, 0x36, 0x61, 0x32, 0x30, 0x66, 0x37, 0x65, 0x61, 0x36, 0x34, 0x39, 0x32, 0x34, 0x31, 0x39, 0x63, 0x38, 0x34, 0x63, 0x38, 0x36, 0x37, 0x36, 0x34, 0x31, 0x64, 0x38, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x32, 0x61, 0x37, 0x64, 0x61, 0x30, 0x61, 0x35, 0x61, 0x64, 0x37, 0x34, 0x30, 0x37, 0x34, 0x36, 0x38, 0x64, 0x33, 0x62, 0x65, 0x38, 0x65, 0x30, 0x37, 0x65, 0x36, 0x39, 0x63, 0x37, 0x64, 0x64, 0x36, 0x34, 0x65, 0x38, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x38, 0x32, 0x63, 0x63, 0x38, 0x64, 0x34, 0x61, 0x31, 0x62, 0x62, 0x31, 0x64, 0x39, 0x34, 0x33, 0x34, 0x33, 0x39, 0x32, 0x39, 0x36, 0x35, 0x62, 0x33, 0x65, 0x38, 0x30, 0x62, 0x61, 0x64, 0x33, 0x63, 0x30, 0x33, 0x64, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x38, 0x32, 0x36, 0x39, 0x34, 0x66, 0x61, 0x32, 0x39, 0x64, 0x39, 0x65, 0x32, 0x31, 0x33, 0x32, 0x30, 0x32, 0x61, 0x31, 0x61, 0x32, 0x30, 0x39, 0x32, 0x38, 0x35, 0x64, 0x66, 0x36, 0x65, 0x37, 0x34, 0x35, 0x63, 0x32, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x35, 0x33, 0x66, 0x66, 0x32, 0x31, 0x30, 0x37, 0x61, 0x38, 0x64, 0x65, 0x62, 0x65, 0x33, 0x33, 0x32, 0x38, 0x34, 0x39, 0x33, 0x61, 0x39, 0x32, 0x61, 0x35, 0x38, 0x36, 0x61, 0x37, 0x65, 0x31, 0x66, 0x34, 0x39, 0x37, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x31, 0x34, 0x33, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x64, 0x64, 0x62, 0x37, 0x38, 0x36, 0x64, 0x33, 0x37, 0x39, 0x34, 0x65, 0x32, 0x37, 0x30, 0x31, 0x38, 0x37, 0x64, 0x30, 0x34, 0x35, 0x31, 0x61, 0x64, 0x36, 0x63, 0x38, 0x62, 0x37, 0x39, 0x65, 0x30, 0x65, 0x38, 0x37, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x62, 0x63, 0x66, 0x39, 0x39, 0x35, 0x37, 0x66, 0x35, 0x66, 0x63, 0x35, 0x65, 0x39, 0x38, 0x35, 0x61, 0x64, 0x64, 0x34, 0x37, 0x35, 0x32, 0x32, 0x33, 0x62, 0x30, 0x34, 0x62, 0x38, 0x63, 0x31, 0x34, 0x61, 0x37, 0x61, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x63, 0x37, 0x35, 0x39, 0x30, 0x62, 0x35, 0x36, 0x32, 0x31, 0x65, 0x63, 0x66, 0x38, 0x33, 0x35, 0x38, 0x35, 0x38, 0x38, 0x64, 0x65, 0x39, 0x62, 0x36, 0x38, 0x39, 0x30, 0x66, 0x32, 0x36, 0x32, 0x36, 0x31, 0x34, 0x33, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x34, 0x66, 0x31, 0x32, 0x32, 0x65, 0x33, 0x35, 0x63, 0x30, 0x62, 0x31, 0x64, 0x31, 0x65, 0x34, 0x30, 0x36, 0x39, 0x32, 0x39, 0x31, 0x34, 0x35, 0x37, 0x63, 0x38, 0x33, 0x63, 0x30, 0x37, 0x66, 0x39, 0x36, 0x35, 0x66, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x38, 0x38, 0x35, 0x61, 0x62, 0x61, 0x62, 0x65, 0x64, 0x66, 0x34, 0x64, 0x39, 0x32, 0x38, 0x65, 0x31, 0x63, 0x33, 0x63, 0x37, 0x31, 0x64, 0x37, 0x63, 0x61, 0x34, 0x30, 0x64, 0x35, 0x36, 0x33, 0x65, 0x64, 0x35, 0x39, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x63, 0x65, 0x33, 0x65, 0x33, 0x64, 0x34, 0x37, 0x34, 0x61, 0x38, 0x61, 0x30, 0x34, 0x37, 0x62, 0x39, 0x32, 0x63, 0x34, 0x31, 0x35, 0x34, 0x32, 0x32, 0x34, 0x32, 0x64, 0x30, 0x61, 0x30, 0x38, 0x63, 0x37, 0x30, 0x66, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x33, 0x34, 0x64, 0x39, 0x34, 0x32, 0x66, 0x30, 0x33, 0x37, 0x66, 0x32, 0x63, 0x63, 0x33, 0x64, 0x34, 0x32, 0x34, 0x61, 0x32, 0x33, 0x30, 0x63, 0x36, 0x30, 0x33, 0x64, 0x36, 0x37, 0x61, 0x62, 0x64, 0x33, 0x65, 0x64, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x36, 0x30, 0x65, 0x38, 0x37, 0x64, 0x66, 0x32, 0x34, 0x63, 0x36, 0x39, 0x65, 0x65, 0x36, 0x64, 0x35, 0x31, 0x63, 0x37, 0x36, 0x65, 0x37, 0x33, 0x37, 0x36, 0x37, 0x66, 0x66, 0x65, 0x31, 0x39, 0x61, 0x32, 0x31, 0x33, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x64, 0x31, 0x63, 0x33, 0x65, 0x33, 0x31, 0x37, 0x37, 0x38, 0x32, 0x37, 0x36, 0x63, 0x62, 0x34, 0x32, 0x65, 0x61, 0x37, 0x34, 0x30, 0x66, 0x35, 0x65, 0x61, 0x65, 0x39, 0x63, 0x36, 0x34, 0x31, 0x64, 0x62, 0x63, 0x37, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x33, 0x39, 0x37, 0x33, 0x34, 0x32, 0x65, 0x63, 0x35, 0x66, 0x33, 0x64, 0x34, 0x63, 0x62, 0x38, 0x37, 0x37, 0x65, 0x35, 0x34, 0x65, 0x66, 0x35, 0x64, 0x36, 0x66, 0x31, 0x64, 0x33, 0x36, 0x36, 0x37, 0x33, 0x31, 0x62, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x34, 0x62, 0x35, 0x63, 0x30, 0x35, 0x64, 0x30, 0x36, 0x61, 0x32, 0x30, 0x39, 0x35, 0x37, 0x65, 0x31, 0x37, 0x34, 0x38, 0x61, 0x62, 0x36, 0x64, 0x66, 0x32, 0x30, 0x36, 0x66, 0x33, 0x34, 0x33, 0x66, 0x39, 0x32, 0x66, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x30, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x31, 0x31, 0x35, 0x62, 0x31, 0x33, 0x66, 0x39, 0x37, 0x39, 0x35, 0x66, 0x37, 0x65, 0x39, 0x35, 0x36, 0x35, 0x30, 0x32, 0x64, 0x35, 0x30, 0x37, 0x34, 0x35, 0x36, 0x37, 0x64, 0x61, 0x62, 0x39, 0x34, 0x35, 0x63, 0x65, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x37, 0x33, 0x30, 0x63, 0x33, 0x35, 0x37, 0x61, 0x39, 0x31, 0x30, 0x32, 0x36, 0x65, 0x34, 0x34, 0x62, 0x31, 0x64, 0x30, 0x65, 0x32, 0x66, 0x63, 0x32, 0x61, 0x35, 0x31, 0x64, 0x30, 0x37, 0x31, 0x64, 0x38, 0x64, 0x37, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x65, 0x38, 0x38, 0x31, 0x39, 0x33, 0x37, 0x30, 0x34, 0x37, 0x38, 0x39, 0x35, 0x61, 0x36, 0x36, 0x30, 0x63, 0x66, 0x32, 0x32, 0x39, 0x37, 0x36, 0x30, 0x66, 0x32, 0x37, 0x65, 0x36, 0x36, 0x38, 0x32, 0x38, 0x64, 0x36, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x33, 0x65, 0x66, 0x36, 0x62, 0x61, 0x31, 0x35, 0x31, 0x63, 0x32, 0x31, 0x62, 0x35, 0x39, 0x39, 0x38, 0x36, 0x61, 0x65, 0x36, 0x34, 0x66, 0x36, 0x65, 0x38, 0x32, 0x32, 0x38, 0x62, 0x63, 0x39, 0x61, 0x32, 0x63, 0x37, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x62, 0x64, 0x34, 0x32, 0x33, 0x32, 0x63, 0x31, 0x37, 0x63, 0x34, 0x30, 0x37, 0x61, 0x39, 0x38, 0x30, 0x64, 0x62, 0x38, 0x37, 0x66, 0x66, 0x62, 0x63, 0x64, 0x61, 0x30, 0x33, 0x36, 0x33, 0x30, 0x65, 0x35, 0x63, 0x34, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x33, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x32, 0x39, 0x61, 0x32, 0x39, 0x66, 0x65, 0x65, 0x31, 0x39, 0x38, 0x34, 0x35, 0x30, 0x36, 0x37, 0x32, 0x63, 0x30, 0x63, 0x31, 0x64, 0x30, 0x37, 0x33, 0x31, 0x36, 0x32, 0x32, 0x35, 0x30, 0x62, 0x65, 0x63, 0x36, 0x34, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x38, 0x66, 0x39, 0x36, 0x63, 0x63, 0x32, 0x39, 0x66, 0x35, 0x37, 0x62, 0x30, 0x39, 0x37, 0x35, 0x31, 0x32, 0x30, 0x63, 0x62, 0x35, 0x39, 0x33, 0x62, 0x37, 0x64, 0x64, 0x38, 0x33, 0x33, 0x64, 0x36, 0x30, 0x36, 0x62, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x64, 0x33, 0x66, 0x31, 0x65, 0x62, 0x65, 0x32, 0x61, 0x65, 0x36, 0x37, 0x35, 0x36, 0x62, 0x35, 0x64, 0x38, 0x64, 0x63, 0x31, 0x39, 0x63, 0x61, 0x64, 0x30, 0x32, 0x63, 0x34, 0x31, 0x39, 0x61, 0x61, 0x35, 0x37, 0x37, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x61, 0x37, 0x37, 0x36, 0x61, 0x36, 0x37, 0x35, 0x34, 0x34, 0x36, 0x39, 0x64, 0x37, 0x62, 0x39, 0x32, 0x36, 0x37, 0x61, 0x38, 0x39, 0x62, 0x38, 0x36, 0x37, 0x32, 0x35, 0x65, 0x37, 0x34, 0x30, 0x64, 0x61, 0x30, 0x66, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x39, 0x65, 0x34, 0x37, 0x39, 0x37, 0x36, 0x34, 0x62, 0x34, 0x39, 0x39, 0x64, 0x36, 0x36, 0x36, 0x32, 0x30, 0x38, 0x63, 0x34, 0x61, 0x38, 0x61, 0x30, 0x34, 0x37, 0x61, 0x39, 0x37, 0x30, 0x34, 0x33, 0x31, 0x36, 0x33, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x64, 0x35, 0x65, 0x34, 0x32, 0x30, 0x37, 0x35, 0x35, 0x36, 0x31, 0x33, 0x38, 0x38, 0x36, 0x66, 0x33, 0x35, 0x61, 0x61, 0x35, 0x36, 0x61, 0x63, 0x34, 0x30, 0x33, 0x65, 0x65, 0x62, 0x64, 0x66, 0x65, 0x34, 0x62, 0x30, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x65, 0x38, 0x30, 0x31, 0x65, 0x36, 0x31, 0x33, 0x33, 0x35, 0x63, 0x35, 0x31, 0x34, 0x30, 0x64, 0x63, 0x37, 0x65, 0x64, 0x61, 0x32, 0x65, 0x66, 0x35, 0x32, 0x30, 0x34, 0x34, 0x36, 0x30, 0x61, 0x35, 0x30, 0x31, 0x32, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x38, 0x61, 0x36, 0x62, 0x36, 0x64, 0x35, 0x30, 0x33, 0x33, 0x62, 0x31, 0x34, 0x39, 0x38, 0x62, 0x31, 0x66, 0x66, 0x65, 0x62, 0x34, 0x31, 0x61, 0x34, 0x31, 0x35, 0x35, 0x30, 0x34, 0x30, 0x35, 0x66, 0x61, 0x30, 0x33, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x63, 0x32, 0x66, 0x66, 0x63, 0x33, 0x30, 0x65, 0x66, 0x64, 0x63, 0x35, 0x32, 0x37, 0x33, 0x65, 0x37, 0x36, 0x31, 0x38, 0x33, 0x61, 0x31, 0x36, 0x63, 0x32, 0x36, 0x39, 0x38, 0x64, 0x36, 0x65, 0x35, 0x33, 0x31, 0x32, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x65, 0x63, 0x33, 0x61, 0x65, 0x63, 0x33, 0x66, 0x38, 0x66, 0x39, 0x32, 0x32, 0x31, 0x66, 0x39, 0x31, 0x34, 0x39, 0x66, 0x65, 0x64, 0x65, 0x30, 0x36, 0x39, 0x30, 0x33, 0x61, 0x30, 0x66, 0x39, 0x61, 0x32, 0x33, 0x32, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x33, 0x35, 0x66, 0x36, 0x64, 0x34, 0x62, 0x31, 0x30, 0x37, 0x35, 0x65, 0x36, 0x61, 0x61, 0x31, 0x33, 0x39, 0x31, 0x35, 0x31, 0x63, 0x39, 0x37, 0x34, 0x62, 0x32, 0x66, 0x34, 0x36, 0x35, 0x38, 0x66, 0x37, 0x30, 0x35, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x61, 0x36, 0x38, 0x65, 0x61, 0x62, 0x39, 0x30, 0x35, 0x61, 0x38, 0x62, 0x33, 0x64, 0x63, 0x65, 0x30, 0x30, 0x65, 0x33, 0x31, 0x37, 0x33, 0x30, 0x38, 0x32, 0x32, 0x35, 0x64, 0x61, 0x62, 0x31, 0x62, 0x39, 0x66, 0x36, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x66, 0x35, 0x62, 0x35, 0x33, 0x64, 0x37, 0x39, 0x62, 0x66, 0x32, 0x65, 0x34, 0x31, 0x31, 0x34, 0x38, 0x39, 0x35, 0x32, 0x36, 0x35, 0x33, 0x30, 0x32, 0x32, 0x33, 0x38, 0x34, 0x35, 0x66, 0x61, 0x63, 0x36, 0x66, 0x36, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x31, 0x31, 0x31, 0x35, 0x32, 0x39, 0x36, 0x61, 0x62, 0x37, 0x64, 0x62, 0x35, 0x32, 0x34, 0x39, 0x32, 0x66, 0x66, 0x37, 0x62, 0x36, 0x34, 0x37, 0x64, 0x36, 0x33, 0x33, 0x32, 0x39, 0x66, 0x62, 0x35, 0x63, 0x62, 0x63, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x39, 0x66, 0x31, 0x39, 0x33, 0x35, 0x30, 0x38, 0x33, 0x39, 0x33, 0x65, 0x34, 0x64, 0x32, 0x61, 0x31, 0x32, 0x37, 0x62, 0x32, 0x30, 0x62, 0x32, 0x30, 0x33, 0x31, 0x66, 0x33, 0x39, 0x63, 0x38, 0x32, 0x35, 0x38, 0x31, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x30, 0x65, 0x33, 0x34, 0x63, 0x64, 0x65, 0x35, 0x62, 0x64, 0x39, 0x65, 0x32, 0x62, 0x37, 0x31, 0x62, 0x62, 0x39, 0x32, 0x64, 0x37, 0x63, 0x66, 0x35, 0x35, 0x65, 0x65, 0x65, 0x31, 0x38, 0x38, 0x64, 0x35, 0x66, 0x61, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x65, 0x61, 0x36, 0x37, 0x61, 0x64, 0x33, 0x66, 0x62, 0x35, 0x36, 0x61, 0x64, 0x35, 0x66, 0x62, 0x39, 0x34, 0x33, 0x38, 0x37, 0x64, 0x64, 0x33, 0x38, 0x65, 0x62, 0x33, 0x38, 0x33, 0x30, 0x30, 0x31, 0x64, 0x37, 0x63, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x39, 0x66, 0x39, 0x62, 0x35, 0x36, 0x65, 0x34, 0x32, 0x38, 0x39, 0x64, 0x66, 0x62, 0x35, 0x38, 0x65, 0x37, 0x30, 0x66, 0x64, 0x35, 0x66, 0x31, 0x32, 0x61, 0x39, 0x37, 0x62, 0x35, 0x36, 0x64, 0x33, 0x35, 0x63, 0x36, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x62, 0x65, 0x36, 0x66, 0x39, 0x35, 0x33, 0x66, 0x32, 0x61, 0x34, 0x64, 0x32, 0x35, 0x62, 0x36, 0x32, 0x35, 0x36, 0x66, 0x66, 0x64, 0x32, 0x34, 0x32, 0x33, 0x61, 0x63, 0x31, 0x34, 0x33, 0x38, 0x32, 0x35, 0x32, 0x65, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x31, 0x64, 0x66, 0x63, 0x39, 0x38, 0x34, 0x62, 0x37, 0x31, 0x61, 0x31, 0x39, 0x39, 0x32, 0x39, 0x61, 0x38, 0x31, 0x64, 0x38, 0x31, 0x66, 0x30, 0x34, 0x61, 0x37, 0x63, 0x62, 0x62, 0x31, 0x34, 0x30, 0x37, 0x33, 0x37, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x63, 0x31, 0x34, 0x61, 0x63, 0x65, 0x32, 0x38, 0x62, 0x31, 0x39, 0x32, 0x63, 0x62, 0x62, 0x30, 0x36, 0x32, 0x31, 0x34, 0x35, 0x66, 0x63, 0x62, 0x62, 0x64, 0x35, 0x38, 0x36, 0x39, 0x63, 0x36, 0x37, 0x32, 0x37, 0x31, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x61, 0x37, 0x36, 0x62, 0x37, 0x63, 0x33, 0x39, 0x62, 0x34, 0x32, 0x30, 0x65, 0x33, 0x38, 0x38, 0x62, 0x61, 0x32, 0x63, 0x31, 0x30, 0x32, 0x30, 0x62, 0x30, 0x38, 0x35, 0x36, 0x62, 0x30, 0x32, 0x37, 0x30, 0x36, 0x34, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x32, 0x62, 0x65, 0x34, 0x62, 0x34, 0x35, 0x34, 0x39, 0x35, 0x66, 0x63, 0x64, 0x39, 0x33, 0x31, 0x34, 0x33, 0x65, 0x66, 0x63, 0x34, 0x31, 0x32, 0x64, 0x36, 0x39, 0x39, 0x64, 0x36, 0x63, 0x64, 0x63, 0x32, 0x33, 0x64, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x66, 0x38, 0x37, 0x33, 0x62, 0x64, 0x39, 0x39, 0x35, 0x36, 0x31, 0x33, 0x35, 0x37, 0x38, 0x39, 0x61, 0x62, 0x30, 0x30, 0x65, 0x62, 0x63, 0x31, 0x39, 0x35, 0x62, 0x39, 0x32, 0x32, 0x65, 0x39, 0x34, 0x62, 0x32, 0x35, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x35, 0x66, 0x33, 0x37, 0x36, 0x34, 0x65, 0x39, 0x37, 0x62, 0x62, 0x63, 0x63, 0x66, 0x37, 0x36, 0x37, 0x63, 0x62, 0x64, 0x33, 0x62, 0x37, 0x39, 0x35, 0x62, 0x61, 0x38, 0x36, 0x64, 0x38, 0x62, 0x61, 0x39, 0x38, 0x34, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x33, 0x39, 0x62, 0x65, 0x34, 0x31, 0x30, 0x39, 0x34, 0x62, 0x31, 0x39, 0x39, 0x37, 0x64, 0x32, 0x31, 0x36, 0x39, 0x65, 0x38, 0x32, 0x36, 0x34, 0x63, 0x32, 0x63, 0x33, 0x62, 0x61, 0x61, 0x36, 0x63, 0x39, 0x39, 0x62, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x66, 0x66, 0x63, 0x31, 0x31, 0x32, 0x38, 0x36, 0x30, 0x35, 0x63, 0x62, 0x30, 0x63, 0x31, 0x33, 0x37, 0x30, 0x39, 0x61, 0x37, 0x32, 0x39, 0x30, 0x35, 0x30, 0x36, 0x66, 0x32, 0x36, 0x39, 0x30, 0x39, 0x37, 0x37, 0x31, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x31, 0x31, 0x36, 0x38, 0x64, 0x65, 0x38, 0x61, 0x62, 0x36, 0x34, 0x62, 0x34, 0x37, 0x35, 0x35, 0x32, 0x66, 0x33, 0x33, 0x38, 0x39, 0x38, 0x30, 0x30, 0x61, 0x39, 0x63, 0x63, 0x30, 0x38, 0x62, 0x34, 0x36, 0x36, 0x36, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x31, 0x61, 0x61, 0x38, 0x66, 0x63, 0x66, 0x63, 0x38, 0x39, 0x61, 0x31, 0x61, 0x35, 0x33, 0x32, 0x38, 0x63, 0x62, 0x64, 0x36, 0x33, 0x34, 0x34, 0x62, 0x37, 0x31, 0x66, 0x32, 0x37, 0x38, 0x61, 0x32, 0x63, 0x61, 0x34, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x35, 0x61, 0x33, 0x33, 0x61, 0x31, 0x38, 0x36, 0x33, 0x34, 0x64, 0x64, 0x34, 0x38, 0x30, 0x30, 0x36, 0x39, 0x33, 0x63, 0x36, 0x37, 0x66, 0x34, 0x38, 0x61, 0x31, 0x64, 0x36, 0x39, 0x33, 0x64, 0x34, 0x38, 0x33, 0x33, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x38, 0x66, 0x63, 0x30, 0x39, 0x61, 0x30, 0x30, 0x33, 0x30, 0x66, 0x64, 0x30, 0x39, 0x32, 0x38, 0x63, 0x64, 0x33, 0x32, 0x31, 0x31, 0x39, 0x38, 0x35, 0x38, 0x30, 0x31, 0x38, 0x32, 0x61, 0x37, 0x36, 0x61, 0x61, 0x65, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x63, 0x64, 0x64, 0x63, 0x61, 0x33, 0x63, 0x64, 0x32, 0x62, 0x34, 0x39, 0x39, 0x30, 0x65, 0x32, 0x35, 0x63, 0x64, 0x36, 0x35, 0x63, 0x32, 0x34, 0x31, 0x34, 0x39, 0x64, 0x30, 0x39, 0x31, 0x32, 0x30, 0x39, 0x39, 0x65, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x37, 0x61, 0x36, 0x65, 0x66, 0x38, 0x37, 0x36, 0x33, 0x61, 0x31, 0x38, 0x66, 0x30, 0x30, 0x66, 0x61, 0x63, 0x32, 0x31, 0x37, 0x65, 0x30, 0x35, 0x35, 0x63, 0x30, 0x64, 0x33, 0x30, 0x39, 0x34, 0x31, 0x30, 0x31, 0x30, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x30, 0x62, 0x64, 0x33, 0x32, 0x34, 0x37, 0x33, 0x63, 0x34, 0x63, 0x35, 0x31, 0x62, 0x66, 0x32, 0x35, 0x36, 0x35, 0x34, 0x64, 0x65, 0x66, 0x36, 0x39, 0x66, 0x37, 0x39, 0x37, 0x63, 0x36, 0x62, 0x32, 0x39, 0x61, 0x32, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x64, 0x38, 0x63, 0x33, 0x35, 0x66, 0x62, 0x37, 0x65, 0x65, 0x61, 0x36, 0x32, 0x32, 0x35, 0x38, 0x32, 0x31, 0x33, 0x35, 0x65, 0x33, 0x61, 0x64, 0x34, 0x37, 0x61, 0x32, 0x32, 0x37, 0x63, 0x39, 0x61, 0x36, 0x36, 0x33, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x36, 0x34, 0x38, 0x38, 0x36, 0x39, 0x38, 0x35, 0x39, 0x30, 0x64, 0x63, 0x33, 0x62, 0x32, 0x63, 0x35, 0x35, 0x35, 0x36, 0x34, 0x32, 0x62, 0x38, 0x37, 0x31, 0x33, 0x34, 0x38, 0x64, 0x66, 0x61, 0x30, 0x36, 0x37, 0x61, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x65, 0x62, 0x65, 0x38, 0x30, 0x63, 0x62, 0x36, 0x66, 0x33, 0x61, 0x65, 0x35, 0x39, 0x30, 0x34, 0x66, 0x36, 0x66, 0x34, 0x62, 0x32, 0x38, 0x64, 0x39, 0x30, 0x37, 0x66, 0x39, 0x30, 0x37, 0x31, 0x38, 0x39, 0x66, 0x63, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x31, 0x61, 0x62, 0x64, 0x38, 0x39, 0x37, 0x64, 0x61, 0x63, 0x64, 0x34, 0x33, 0x31, 0x32, 0x65, 0x31, 0x38, 0x30, 0x38, 0x30, 0x63, 0x38, 0x38, 0x66, 0x62, 0x39, 0x36, 0x34, 0x37, 0x65, 0x61, 0x62, 0x34, 0x34, 0x30, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x37, 0x30, 0x32, 0x39, 0x63, 0x34, 0x36, 0x39, 0x63, 0x34, 0x35, 0x34, 0x38, 0x64, 0x31, 0x36, 0x38, 0x63, 0x65, 0x63, 0x33, 0x65, 0x36, 0x35, 0x38, 0x37, 0x32, 0x65, 0x34, 0x34, 0x32, 0x38, 0x64, 0x34, 0x32, 0x62, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x39, 0x36, 0x61, 0x63, 0x64, 0x65, 0x64, 0x31, 0x65, 0x30, 0x36, 0x33, 0x61, 0x66, 0x33, 0x39, 0x66, 0x65, 0x38, 0x62, 0x61, 0x30, 0x62, 0x34, 0x62, 0x36, 0x33, 0x64, 0x66, 0x37, 0x38, 0x39, 0x66, 0x37, 0x30, 0x35, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x37, 0x36, 0x32, 0x63, 0x36, 0x33, 0x36, 0x37, 0x38, 0x63, 0x31, 0x38, 0x64, 0x31, 0x63, 0x36, 0x33, 0x37, 0x38, 0x63, 0x65, 0x30, 0x36, 0x38, 0x65, 0x36, 0x36, 0x36, 0x33, 0x38, 0x31, 0x33, 0x31, 0x35, 0x31, 0x34, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x63, 0x31, 0x63, 0x38, 0x37, 0x38, 0x66, 0x61, 0x36, 0x63, 0x64, 0x65, 0x38, 0x61, 0x39, 0x61, 0x30, 0x62, 0x38, 0x33, 0x31, 0x31, 0x32, 0x34, 0x37, 0x65, 0x37, 0x34, 0x31, 0x65, 0x34, 0x36, 0x34, 0x32, 0x66, 0x65, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x39, 0x65, 0x64, 0x37, 0x66, 0x34, 0x35, 0x35, 0x33, 0x30, 0x35, 0x38, 0x63, 0x32, 0x36, 0x66, 0x37, 0x38, 0x33, 0x36, 0x61, 0x33, 0x38, 0x30, 0x32, 0x64, 0x33, 0x30, 0x36, 0x34, 0x65, 0x62, 0x31, 0x62, 0x33, 0x36, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x33, 0x32, 0x65, 0x34, 0x62, 0x63, 0x66, 0x37, 0x39, 0x33, 0x32, 0x62, 0x34, 0x39, 0x66, 0x64, 0x62, 0x61, 0x33, 0x37, 0x37, 0x62, 0x36, 0x66, 0x31, 0x34, 0x39, 0x39, 0x36, 0x33, 0x36, 0x35, 0x31, 0x33, 0x63, 0x66, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x32, 0x62, 0x36, 0x37, 0x38, 0x62, 0x35, 0x31, 0x62, 0x35, 0x38, 0x34, 0x66, 0x33, 0x65, 0x64, 0x37, 0x61, 0x64, 0x61, 0x30, 0x37, 0x30, 0x62, 0x35, 0x63, 0x64, 0x39, 0x39, 0x63, 0x30, 0x62, 0x66, 0x37, 0x62, 0x38, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x61, 0x61, 0x34, 0x39, 0x65, 0x33, 0x38, 0x30, 0x39, 0x66, 0x30, 0x38, 0x39, 0x39, 0x66, 0x32, 0x38, 0x61, 0x62, 0x35, 0x37, 0x65, 0x36, 0x37, 0x34, 0x33, 0x37, 0x30, 0x39, 0x64, 0x35, 0x38, 0x34, 0x31, 0x39, 0x30, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x62, 0x31, 0x63, 0x61, 0x65, 0x39, 0x31, 0x61, 0x33, 0x62, 0x39, 0x35, 0x35, 0x39, 0x61, 0x66, 0x62, 0x33, 0x33, 0x63, 0x64, 0x63, 0x36, 0x64, 0x36, 0x38, 0x39, 0x34, 0x34, 0x32, 0x66, 0x64, 0x62, 0x66, 0x65, 0x30, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x30, 0x34, 0x33, 0x30, 0x30, 0x34, 0x65, 0x63, 0x31, 0x39, 0x34, 0x31, 0x61, 0x38, 0x63, 0x66, 0x34, 0x66, 0x32, 0x62, 0x30, 0x30, 0x62, 0x31, 0x35, 0x37, 0x30, 0x30, 0x64, 0x64, 0x61, 0x63, 0x36, 0x66, 0x66, 0x31, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x61, 0x32, 0x63, 0x36, 0x63, 0x33, 0x35, 0x64, 0x66, 0x61, 0x65, 0x63, 0x32, 0x39, 0x36, 0x38, 0x32, 0x36, 0x35, 0x39, 0x31, 0x39, 0x30, 0x34, 0x64, 0x35, 0x34, 0x34, 0x34, 0x36, 0x34, 0x61, 0x65, 0x61, 0x62, 0x64, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x32, 0x34, 0x30, 0x30, 0x66, 0x64, 0x31, 0x33, 0x63, 0x35, 0x35, 0x30, 0x30, 0x39, 0x31, 0x37, 0x63, 0x62, 0x30, 0x33, 0x37, 0x62, 0x32, 0x39, 0x66, 0x65, 0x32, 0x32, 0x65, 0x37, 0x64, 0x35, 0x32, 0x32, 0x38, 0x66, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x39, 0x64, 0x39, 0x32, 0x64, 0x32, 0x63, 0x38, 0x37, 0x30, 0x31, 0x39, 0x38, 0x30, 0x63, 0x63, 0x30, 0x37, 0x33, 0x63, 0x33, 0x37, 0x35, 0x64, 0x37, 0x32, 0x30, 0x61, 0x66, 0x30, 0x36, 0x34, 0x37, 0x34, 0x33, 0x63, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x64, 0x64, 0x36, 0x31, 0x38, 0x35, 0x64, 0x39, 0x61, 0x38, 0x64, 0x37, 0x33, 0x64, 0x64, 0x66, 0x64, 0x61, 0x61, 0x37, 0x31, 0x65, 0x39, 0x62, 0x37, 0x37, 0x37, 0x34, 0x34, 0x33, 0x31, 0x63, 0x34, 0x64, 0x66, 0x65, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x63, 0x62, 0x32, 0x31, 0x65, 0x35, 0x39, 0x30, 0x63, 0x35, 0x61, 0x30, 0x65, 0x30, 0x36, 0x38, 0x30, 0x31, 0x33, 0x36, 0x36, 0x61, 0x66, 0x66, 0x33, 0x34, 0x32, 0x63, 0x37, 0x64, 0x37, 0x64, 0x62, 0x31, 0x36, 0x34, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x36, 0x64, 0x35, 0x35, 0x66, 0x36, 0x37, 0x31, 0x32, 0x39, 0x36, 0x37, 0x34, 0x30, 0x35, 0x63, 0x36, 0x35, 0x39, 0x31, 0x32, 0x39, 0x66, 0x34, 0x62, 0x31, 0x64, 0x65, 0x30, 0x39, 0x61, 0x63, 0x66, 0x32, 0x63, 0x62, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x37, 0x39, 0x39, 0x37, 0x39, 0x39, 0x30, 0x37, 0x66, 0x65, 0x37, 0x66, 0x30, 0x33, 0x37, 0x65, 0x34, 0x63, 0x33, 0x38, 0x30, 0x32, 0x39, 0x64, 0x36, 0x30, 0x62, 0x63, 0x62, 0x61, 0x62, 0x38, 0x33, 0x32, 0x62, 0x33, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x63, 0x34, 0x30, 0x37, 0x31, 0x33, 0x33, 0x62, 0x38, 0x34, 0x62, 0x33, 0x63, 0x61, 0x34, 0x63, 0x33, 0x64, 0x65, 0x64, 0x31, 0x66, 0x34, 0x36, 0x35, 0x38, 0x39, 0x30, 0x30, 0x63, 0x33, 0x38, 0x31, 0x30, 0x31, 0x36, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x32, 0x61, 0x33, 0x36, 0x64, 0x37, 0x35, 0x33, 0x65, 0x39, 0x65, 0x30, 0x65, 0x64, 0x30, 0x31, 0x32, 0x61, 0x35, 0x38, 0x34, 0x64, 0x37, 0x31, 0x36, 0x38, 0x30, 0x37, 0x35, 0x38, 0x37, 0x62, 0x34, 0x31, 0x64, 0x35, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x35, 0x35, 0x66, 0x61, 0x36, 0x63, 0x35, 0x31, 0x65, 0x62, 0x33, 0x31, 0x64, 0x38, 0x30, 0x38, 0x34, 0x31, 0x32, 0x64, 0x37, 0x34, 0x38, 0x61, 0x61, 0x30, 0x38, 0x36, 0x31, 0x30, 0x35, 0x30, 0x31, 0x38, 0x31, 0x32, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x63, 0x63, 0x38, 0x65, 0x31, 0x36, 0x36, 0x38, 0x64, 0x64, 0x65, 0x39, 0x39, 0x35, 0x64, 0x63, 0x35, 0x37, 0x30, 0x66, 0x65, 0x34, 0x31, 0x34, 0x66, 0x34, 0x34, 0x32, 0x31, 0x31, 0x63, 0x35, 0x33, 0x34, 0x61, 0x36, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x33, 0x39, 0x35, 0x64, 0x62, 0x35, 0x61, 0x34, 0x62, 0x62, 0x36, 0x36, 0x65, 0x36, 0x30, 0x66, 0x34, 0x63, 0x66, 0x62, 0x63, 0x64, 0x66, 0x30, 0x30, 0x35, 0x37, 0x62, 0x62, 0x34, 0x64, 0x39, 0x37, 0x38, 0x36, 0x32, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x66, 0x62, 0x33, 0x39, 0x37, 0x38, 0x36, 0x32, 0x35, 0x30, 0x30, 0x38, 0x31, 0x34, 0x32, 0x36, 0x61, 0x33, 0x34, 0x32, 0x63, 0x37, 0x30, 0x64, 0x34, 0x37, 0x65, 0x65, 0x35, 0x32, 0x31, 0x65, 0x35, 0x62, 0x63, 0x35, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x30, 0x65, 0x64, 0x61, 0x35, 0x36, 0x30, 0x31, 0x34, 0x39, 0x39, 0x61, 0x30, 0x64, 0x35, 0x65, 0x31, 0x61, 0x30, 0x30, 0x36, 0x62, 0x66, 0x66, 0x66, 0x64, 0x38, 0x33, 0x33, 0x36, 0x37, 0x32, 0x66, 0x32, 0x65, 0x32, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x63, 0x31, 0x39, 0x64, 0x62, 0x61, 0x38, 0x31, 0x30, 0x62, 0x61, 0x36, 0x31, 0x31, 0x65, 0x36, 0x38, 0x66, 0x32, 0x66, 0x38, 0x33, 0x65, 0x65, 0x31, 0x36, 0x66, 0x36, 0x65, 0x37, 0x37, 0x34, 0x34, 0x66, 0x30, 0x63, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x66, 0x66, 0x32, 0x36, 0x65, 0x62, 0x36, 0x30, 0x61, 0x38, 0x64, 0x31, 0x61, 0x39, 0x35, 0x61, 0x34, 0x38, 0x39, 0x66, 0x61, 0x65, 0x31, 0x33, 0x36, 0x65, 0x65, 0x39, 0x31, 0x64, 0x34, 0x65, 0x35, 0x38, 0x30, 0x38, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x64, 0x39, 0x30, 0x62, 0x65, 0x32, 0x35, 0x32, 0x64, 0x39, 0x63, 0x64, 0x34, 0x36, 0x34, 0x64, 0x39, 0x39, 0x38, 0x31, 0x32, 0x35, 0x66, 0x61, 0x62, 0x36, 0x39, 0x33, 0x30, 0x36, 0x30, 0x62, 0x61, 0x38, 0x65, 0x34, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x38, 0x33, 0x32, 0x33, 0x62, 0x31, 0x38, 0x34, 0x63, 0x66, 0x66, 0x37, 0x61, 0x38, 0x32, 0x61, 0x65, 0x32, 0x65, 0x31, 0x62, 0x64, 0x61, 0x37, 0x37, 0x39, 0x33, 0x66, 0x65, 0x34, 0x33, 0x31, 0x39, 0x63, 0x61, 0x30, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x35, 0x33, 0x30, 0x35, 0x62, 0x34, 0x30, 0x32, 0x30, 0x61, 0x30, 0x36, 0x62, 0x34, 0x39, 0x64, 0x36, 0x35, 0x37, 0x63, 0x37, 0x63, 0x61, 0x33, 0x34, 0x63, 0x33, 0x35, 0x63, 0x39, 0x31, 0x63, 0x35, 0x66, 0x32, 0x63, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x34, 0x35, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x63, 0x38, 0x30, 0x64, 0x63, 0x31, 0x32, 0x65, 0x37, 0x62, 0x61, 0x62, 0x38, 0x36, 0x65, 0x39, 0x34, 0x39, 0x64, 0x30, 0x31, 0x65, 0x34, 0x63, 0x33, 0x65, 0x64, 0x33, 0x35, 0x66, 0x32, 0x62, 0x39, 0x62, 0x62, 0x61, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x65, 0x62, 0x38, 0x31, 0x66, 0x62, 0x32, 0x66, 0x35, 0x65, 0x39, 0x31, 0x35, 0x32, 0x36, 0x62, 0x32, 0x61, 0x63, 0x39, 0x37, 0x39, 0x35, 0x65, 0x37, 0x36, 0x63, 0x36, 0x39, 0x62, 0x63, 0x66, 0x66, 0x30, 0x34, 0x62, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x62, 0x63, 0x39, 0x62, 0x63, 0x61, 0x37, 0x66, 0x37, 0x31, 0x62, 0x34, 0x65, 0x64, 0x31, 0x32, 0x65, 0x36, 0x32, 0x30, 0x34, 0x33, 0x38, 0x64, 0x36, 0x32, 0x30, 0x66, 0x35, 0x33, 0x63, 0x31, 0x31, 0x34, 0x33, 0x34, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x38, 0x38, 0x65, 0x37, 0x63, 0x62, 0x37, 0x62, 0x61, 0x39, 0x66, 0x36, 0x32, 0x30, 0x61, 0x62, 0x30, 0x66, 0x37, 0x34, 0x35, 0x32, 0x65, 0x35, 0x30, 0x38, 0x36, 0x33, 0x33, 0x64, 0x31, 0x63, 0x35, 0x61, 0x61, 0x32, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x65, 0x34, 0x36, 0x30, 0x61, 0x39, 0x38, 0x39, 0x63, 0x62, 0x31, 0x35, 0x35, 0x36, 0x35, 0x66, 0x39, 0x65, 0x63, 0x63, 0x61, 0x37, 0x64, 0x31, 0x32, 0x31, 0x61, 0x31, 0x38, 0x65, 0x34, 0x65, 0x62, 0x34, 0x30, 0x35, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x38, 0x39, 0x63, 0x63, 0x38, 0x61, 0x62, 0x65, 0x37, 0x35, 0x63, 0x64, 0x61, 0x34, 0x65, 0x66, 0x30, 0x64, 0x30, 0x31, 0x63, 0x65, 0x66, 0x32, 0x36, 0x30, 0x35, 0x65, 0x34, 0x37, 0x65, 0x64, 0x61, 0x36, 0x37, 0x61, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x62, 0x34, 0x30, 0x33, 0x66, 0x62, 0x31, 0x66, 0x62, 0x37, 0x63, 0x31, 0x34, 0x35, 0x35, 0x39, 0x61, 0x32, 0x64, 0x36, 0x66, 0x36, 0x35, 0x36, 0x34, 0x61, 0x35, 0x35, 0x35, 0x32, 0x62, 0x63, 0x61, 0x33, 0x39, 0x61, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x35, 0x63, 0x38, 0x30, 0x35, 0x32, 0x30, 0x61, 0x31, 0x62, 0x30, 0x66, 0x37, 0x35, 0x35, 0x62, 0x39, 0x61, 0x32, 0x63, 0x64, 0x33, 0x63, 0x65, 0x32, 0x31, 0x34, 0x66, 0x37, 0x36, 0x32, 0x35, 0x36, 0x35, 0x33, 0x65, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x31, 0x62, 0x37, 0x30, 0x37, 0x30, 0x32, 0x35, 0x39, 0x62, 0x64, 0x62, 0x61, 0x32, 0x37, 0x31, 0x30, 0x30, 0x65, 0x33, 0x36, 0x65, 0x32, 0x33, 0x34, 0x32, 0x38, 0x61, 0x35, 0x33, 0x64, 0x66, 0x65, 0x33, 0x30, 0x34, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x35, 0x63, 0x39, 0x31, 0x34, 0x62, 0x31, 0x32, 0x38, 0x62, 0x66, 0x31, 0x36, 0x39, 0x35, 0x63, 0x30, 0x38, 0x38, 0x39, 0x32, 0x33, 0x66, 0x61, 0x34, 0x36, 0x37, 0x65, 0x37, 0x39, 0x31, 0x31, 0x66, 0x33, 0x35, 0x31, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x64, 0x66, 0x34, 0x39, 0x35, 0x31, 0x38, 0x64, 0x37, 0x33, 0x62, 0x31, 0x32, 0x39, 0x66, 0x30, 0x64, 0x61, 0x33, 0x36, 0x62, 0x31, 0x63, 0x39, 0x62, 0x34, 0x30, 0x63, 0x62, 0x36, 0x36, 0x34, 0x32, 0x30, 0x66, 0x64, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x39, 0x35, 0x30, 0x35, 0x34, 0x33, 0x35, 0x35, 0x34, 0x64, 0x38, 0x61, 0x37, 0x31, 0x33, 0x30, 0x30, 0x33, 0x66, 0x36, 0x36, 0x32, 0x62, 0x62, 0x36, 0x31, 0x32, 0x63, 0x31, 0x30, 0x61, 0x64, 0x34, 0x63, 0x64, 0x66, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x37, 0x36, 0x30, 0x36, 0x34, 0x33, 0x35, 0x62, 0x33, 0x35, 0x36, 0x63, 0x65, 0x65, 0x32, 0x35, 0x37, 0x62, 0x64, 0x32, 0x66, 0x63, 0x64, 0x33, 0x64, 0x39, 0x65, 0x61, 0x63, 0x62, 0x33, 0x63, 0x64, 0x31, 0x63, 0x34, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x62, 0x61, 0x64, 0x39, 0x38, 0x65, 0x65, 0x65, 0x39, 0x36, 0x39, 0x38, 0x64, 0x62, 0x66, 0x36, 0x64, 0x37, 0x36, 0x30, 0x38, 0x35, 0x62, 0x37, 0x39, 0x32, 0x33, 0x64, 0x65, 0x35, 0x37, 0x35, 0x34, 0x65, 0x39, 0x30, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x35, 0x33, 0x63, 0x38, 0x63, 0x64, 0x64, 0x37, 0x34, 0x32, 0x39, 0x36, 0x61, 0x63, 0x61, 0x39, 0x38, 0x37, 0x62, 0x32, 0x62, 0x63, 0x31, 0x39, 0x63, 0x32, 0x62, 0x38, 0x37, 0x35, 0x61, 0x34, 0x38, 0x37, 0x34, 0x39, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x63, 0x35, 0x35, 0x61, 0x62, 0x66, 0x39, 0x37, 0x36, 0x66, 0x64, 0x63, 0x33, 0x64, 0x62, 0x32, 0x61, 0x66, 0x65, 0x39, 0x62, 0x65, 0x39, 0x39, 0x64, 0x34, 0x39, 0x39, 0x34, 0x38, 0x34, 0x64, 0x35, 0x37, 0x36, 0x63, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x38, 0x61, 0x36, 0x62, 0x37, 0x36, 0x33, 0x35, 0x32, 0x35, 0x32, 0x66, 0x35, 0x32, 0x34, 0x34, 0x34, 0x38, 0x36, 0x63, 0x30, 0x61, 0x66, 0x30, 0x61, 0x37, 0x33, 0x61, 0x32, 0x30, 0x37, 0x33, 0x38, 0x35, 0x65, 0x30, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x62, 0x33, 0x38, 0x39, 0x33, 0x38, 0x31, 0x64, 0x34, 0x38, 0x61, 0x38, 0x61, 0x65, 0x34, 0x66, 0x66, 0x63, 0x34, 0x38, 0x33, 0x61, 0x64, 0x30, 0x62, 0x62, 0x35, 0x65, 0x32, 0x30, 0x34, 0x63, 0x66, 0x64, 0x62, 0x31, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x37, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x34, 0x37, 0x36, 0x36, 0x37, 0x30, 0x33, 0x38, 0x66, 0x33, 0x33, 0x62, 0x30, 0x31, 0x63, 0x31, 0x63, 0x63, 0x37, 0x39, 0x35, 0x64, 0x38, 0x64, 0x61, 0x66, 0x35, 0x34, 0x37, 0x35, 0x65, 0x66, 0x66, 0x35, 0x61, 0x30, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x38, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x38, 0x64, 0x32, 0x31, 0x35, 0x62, 0x35, 0x62, 0x36, 0x61, 0x61, 0x63, 0x34, 0x38, 0x36, 0x31, 0x61, 0x32, 0x38, 0x31, 0x61, 0x63, 0x37, 0x65, 0x34, 0x30, 0x30, 0x62, 0x37, 0x38, 0x66, 0x65, 0x66, 0x30, 0x34, 0x63, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x30, 0x64, 0x65, 0x63, 0x35, 0x31, 0x61, 0x36, 0x65, 0x38, 0x37, 0x33, 0x33, 0x30, 0x61, 0x36, 0x61, 0x38, 0x66, 0x61, 0x32, 0x61, 0x30, 0x66, 0x36, 0x35, 0x64, 0x38, 0x38, 0x64, 0x34, 0x61, 0x62, 0x63, 0x64, 0x66, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x38, 0x66, 0x36, 0x34, 0x64, 0x64, 0x63, 0x64, 0x65, 0x39, 0x62, 0x38, 0x62, 0x34, 0x35, 0x31, 0x62, 0x61, 0x66, 0x61, 0x61, 0x32, 0x33, 0x35, 0x61, 0x39, 0x62, 0x66, 0x35, 0x31, 0x31, 0x61, 0x32, 0x35, 0x61, 0x63, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x63, 0x36, 0x62, 0x66, 0x34, 0x62, 0x62, 0x64, 0x64, 0x37, 0x64, 0x35, 0x39, 0x37, 0x64, 0x39, 0x63, 0x36, 0x38, 0x36, 0x64, 0x30, 0x36, 0x39, 0x35, 0x35, 0x39, 0x33, 0x62, 0x65, 0x64, 0x63, 0x63, 0x63, 0x37, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x65, 0x31, 0x35, 0x31, 0x35, 0x38, 0x62, 0x35, 0x65, 0x65, 0x33, 0x65, 0x38, 0x36, 0x65, 0x62, 0x30, 0x33, 0x33, 0x32, 0x65, 0x33, 0x65, 0x36, 0x61, 0x39, 0x61, 0x63, 0x36, 0x63, 0x64, 0x39, 0x62, 0x35, 0x35, 0x65, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x65, 0x61, 0x34, 0x65, 0x38, 0x32, 0x64, 0x32, 0x34, 0x30, 0x30, 0x32, 0x34, 0x38, 0x66, 0x39, 0x39, 0x38, 0x37, 0x31, 0x61, 0x34, 0x31, 0x63, 0x61, 0x32, 0x35, 0x37, 0x30, 0x36, 0x30, 0x64, 0x33, 0x61, 0x32, 0x32, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x31, 0x32, 0x36, 0x66, 0x30, 0x65, 0x63, 0x37, 0x36, 0x39, 0x66, 0x34, 0x39, 0x64, 0x63, 0x65, 0x66, 0x63, 0x61, 0x32, 0x66, 0x32, 0x30, 0x30, 0x32, 0x38, 0x36, 0x34, 0x35, 0x31, 0x35, 0x38, 0x33, 0x30, 0x38, 0x34, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x33, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x38, 0x62, 0x64, 0x36, 0x64, 0x32, 0x65, 0x63, 0x61, 0x32, 0x30, 0x31, 0x38, 0x35, 0x61, 0x37, 0x38, 0x65, 0x37, 0x64, 0x39, 0x38, 0x65, 0x38, 0x65, 0x31, 0x38, 0x35, 0x36, 0x37, 0x38, 0x64, 0x61, 0x63, 0x34, 0x38, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x34, 0x63, 0x64, 0x36, 0x37, 0x64, 0x63, 0x63, 0x63, 0x39, 0x61, 0x63, 0x38, 0x32, 0x32, 0x38, 0x62, 0x34, 0x35, 0x63, 0x35, 0x35, 0x64, 0x62, 0x38, 0x64, 0x37, 0x36, 0x35, 0x35, 0x30, 0x62, 0x36, 0x35, 0x39, 0x63, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x33, 0x66, 0x33, 0x37, 0x64, 0x39, 0x32, 0x34, 0x36, 0x36, 0x35, 0x35, 0x30, 0x65, 0x39, 0x66, 0x64, 0x37, 0x37, 0x35, 0x61, 0x65, 0x37, 0x34, 0x33, 0x36, 0x32, 0x64, 0x66, 0x30, 0x33, 0x30, 0x31, 0x37, 0x39, 0x31, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x30, 0x64, 0x38, 0x37, 0x36, 0x33, 0x63, 0x36, 0x61, 0x34, 0x66, 0x64, 0x38, 0x32, 0x34, 0x61, 0x62, 0x38, 0x62, 0x38, 0x35, 0x39, 0x31, 0x36, 0x31, 0x65, 0x66, 0x37, 0x65, 0x33, 0x61, 0x39, 0x36, 0x61, 0x31, 0x32, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x63, 0x32, 0x63, 0x36, 0x34, 0x62, 0x62, 0x35, 0x34, 0x63, 0x33, 0x65, 0x63, 0x63, 0x64, 0x30, 0x35, 0x35, 0x38, 0x35, 0x65, 0x31, 0x30, 0x65, 0x63, 0x36, 0x66, 0x39, 0x39, 0x61, 0x30, 0x63, 0x64, 0x62, 0x30, 0x31, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x36, 0x32, 0x34, 0x64, 0x39, 0x38, 0x30, 0x62, 0x36, 0x35, 0x33, 0x33, 0x36, 0x66, 0x65, 0x61, 0x63, 0x35, 0x61, 0x36, 0x64, 0x35, 0x34, 0x31, 0x32, 0x35, 0x30, 0x30, 0x35, 0x63, 0x66, 0x63, 0x66, 0x32, 0x61, 0x61, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x37, 0x66, 0x63, 0x39, 0x64, 0x64, 0x66, 0x37, 0x30, 0x35, 0x37, 0x36, 0x66, 0x36, 0x33, 0x33, 0x30, 0x36, 0x36, 0x39, 0x65, 0x61, 0x61, 0x61, 0x37, 0x31, 0x62, 0x36, 0x61, 0x38, 0x33, 0x31, 0x65, 0x39, 0x39, 0x35, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x32, 0x62, 0x62, 0x63, 0x61, 0x31, 0x35, 0x64, 0x33, 0x66, 0x65, 0x33, 0x39, 0x66, 0x38, 0x61, 0x33, 0x32, 0x38, 0x65, 0x39, 0x31, 0x66, 0x39, 0x30, 0x64, 0x61, 0x31, 0x34, 0x66, 0x37, 0x61, 0x63, 0x36, 0x32, 0x35, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x66, 0x65, 0x65, 0x66, 0x35, 0x34, 0x63, 0x31, 0x33, 0x36, 0x38, 0x35, 0x30, 0x38, 0x32, 0x39, 0x62, 0x61, 0x64, 0x63, 0x34, 0x62, 0x34, 0x39, 0x63, 0x33, 0x66, 0x32, 0x61, 0x37, 0x33, 0x63, 0x38, 0x39, 0x66, 0x62, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x30, 0x33, 0x33, 0x35, 0x30, 0x63, 0x34, 0x64, 0x36, 0x66, 0x65, 0x33, 0x33, 0x37, 0x33, 0x34, 0x32, 0x63, 0x64, 0x64, 0x63, 0x36, 0x35, 0x62, 0x66, 0x31, 0x65, 0x32, 0x33, 0x38, 0x36, 0x62, 0x66, 0x33, 0x66, 0x39, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x37, 0x64, 0x31, 0x63, 0x39, 0x34, 0x39, 0x35, 0x31, 0x31, 0x66, 0x38, 0x38, 0x33, 0x30, 0x33, 0x38, 0x30, 0x38, 0x63, 0x36, 0x30, 0x63, 0x35, 0x65, 0x61, 0x30, 0x36, 0x34, 0x30, 0x66, 0x63, 0x63, 0x30, 0x32, 0x36, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x66, 0x61, 0x37, 0x37, 0x39, 0x32, 0x62, 0x61, 0x64, 0x38, 0x62, 0x62, 0x64, 0x37, 0x66, 0x66, 0x36, 0x34, 0x30, 0x35, 0x36, 0x32, 0x31, 0x34, 0x61, 0x33, 0x33, 0x65, 0x62, 0x36, 0x36, 0x30, 0x30, 0x63, 0x31, 0x65, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x34, 0x63, 0x63, 0x32, 0x62, 0x35, 0x32, 0x32, 0x37, 0x65, 0x63, 0x33, 0x63, 0x66, 0x30, 0x34, 0x38, 0x35, 0x31, 0x32, 0x34, 0x36, 0x37, 0x63, 0x34, 0x31, 0x62, 0x37, 0x62, 0x37, 0x62, 0x37, 0x34, 0x38, 0x39, 0x30, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x64, 0x61, 0x33, 0x61, 0x37, 0x61, 0x30, 0x66, 0x34, 0x35, 0x32, 0x31, 0x36, 0x31, 0x63, 0x66, 0x62, 0x63, 0x65, 0x63, 0x33, 0x31, 0x31, 0x62, 0x62, 0x36, 0x38, 0x65, 0x62, 0x66, 0x64, 0x65, 0x65, 0x31, 0x37, 0x65, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x62, 0x34, 0x65, 0x65, 0x31, 0x64, 0x38, 0x32, 0x66, 0x32, 0x65, 0x31, 0x35, 0x36, 0x34, 0x34, 0x32, 0x63, 0x63, 0x39, 0x33, 0x33, 0x33, 0x38, 0x61, 0x32, 0x66, 0x63, 0x32, 0x38, 0x36, 0x66, 0x61, 0x32, 0x38, 0x38, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x32, 0x64, 0x66, 0x63, 0x37, 0x37, 0x30, 0x65, 0x32, 0x34, 0x33, 0x36, 0x38, 0x31, 0x33, 0x31, 0x62, 0x37, 0x38, 0x34, 0x37, 0x37, 0x39, 0x35, 0x66, 0x32, 0x30, 0x33, 0x66, 0x33, 0x64, 0x35, 0x30, 0x64, 0x35, 0x62, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x65, 0x66, 0x34, 0x64, 0x34, 0x33, 0x61, 0x61, 0x34, 0x31, 0x37, 0x66, 0x39, 0x65, 0x66, 0x38, 0x62, 0x37, 0x38, 0x37, 0x66, 0x38, 0x62, 0x39, 0x39, 0x64, 0x35, 0x33, 0x66, 0x31, 0x66, 0x65, 0x61, 0x31, 0x65, 0x65, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x61, 0x33, 0x30, 0x65, 0x66, 0x35, 0x62, 0x62, 0x33, 0x33, 0x32, 0x30, 0x66, 0x34, 0x30, 0x64, 0x63, 0x35, 0x65, 0x39, 0x38, 0x31, 0x32, 0x33, 0x30, 0x64, 0x35, 0x32, 0x61, 0x65, 0x33, 0x61, 0x63, 0x31, 0x39, 0x33, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x37, 0x34, 0x38, 0x34, 0x34, 0x64, 0x38, 0x65, 0x39, 0x63, 0x62, 0x35, 0x35, 0x38, 0x31, 0x63, 0x34, 0x35, 0x30, 0x37, 0x39, 0x61, 0x32, 0x65, 0x39, 0x34, 0x34, 0x36, 0x32, 0x61, 0x36, 0x63, 0x65, 0x65, 0x38, 0x38, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x32, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x31, 0x31, 0x30, 0x62, 0x65, 0x30, 0x31, 0x64, 0x63, 0x39, 0x37, 0x33, 0x34, 0x63, 0x66, 0x63, 0x36, 0x65, 0x31, 0x63, 0x65, 0x30, 0x37, 0x66, 0x38, 0x37, 0x64, 0x37, 0x37, 0x64, 0x31, 0x33, 0x34, 0x35, 0x62, 0x37, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x62, 0x39, 0x31, 0x36, 0x65, 0x62, 0x66, 0x34, 0x39, 0x64, 0x30, 0x66, 0x38, 0x36, 0x63, 0x31, 0x33, 0x66, 0x37, 0x33, 0x33, 0x31, 0x63, 0x65, 0x66, 0x31, 0x39, 0x65, 0x31, 0x32, 0x39, 0x39, 0x33, 0x37, 0x35, 0x31, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x39, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x35, 0x61, 0x62, 0x64, 0x30, 0x39, 0x63, 0x65, 0x35, 0x61, 0x66, 0x37, 0x62, 0x61, 0x38, 0x34, 0x38, 0x37, 0x63, 0x33, 0x35, 0x39, 0x65, 0x30, 0x66, 0x32, 0x61, 0x39, 0x33, 0x61, 0x39, 0x38, 0x36, 0x62, 0x30, 0x62, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x64, 0x36, 0x30, 0x64, 0x37, 0x33, 0x65, 0x66, 0x61, 0x61, 0x64, 0x38, 0x37, 0x33, 0x63, 0x39, 0x62, 0x62, 0x66, 0x62, 0x31, 0x37, 0x38, 0x63, 0x61, 0x31, 0x62, 0x37, 0x31, 0x30, 0x35, 0x61, 0x38, 0x31, 0x61, 0x36, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x65, 0x62, 0x31, 0x32, 0x33, 0x63, 0x39, 0x35, 0x63, 0x38, 0x32, 0x62, 0x66, 0x36, 0x38, 0x35, 0x61, 0x63, 0x65, 0x37, 0x61, 0x37, 0x35, 0x61, 0x31, 0x38, 0x38, 0x31, 0x61, 0x32, 0x38, 0x39, 0x65, 0x66, 0x63, 0x61, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x30, 0x30, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x65, 0x38, 0x36, 0x37, 0x30, 0x65, 0x32, 0x37, 0x35, 0x39, 0x38, 0x65, 0x61, 0x30, 0x39, 0x63, 0x33, 0x38, 0x39, 0x39, 0x61, 0x62, 0x37, 0x37, 0x31, 0x31, 0x64, 0x33, 0x62, 0x39, 0x66, 0x65, 0x39, 0x30, 0x31, 0x63, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x34, 0x34, 0x66, 0x36, 0x62, 0x36, 0x30, 0x66, 0x37, 0x32, 0x64, 0x36, 0x34, 0x61, 0x32, 0x31, 0x65, 0x33, 0x33, 0x30, 0x64, 0x61, 0x64, 0x62, 0x36, 0x32, 0x64, 0x38, 0x39, 0x39, 0x30, 0x61, 0x64, 0x65, 0x32, 0x62, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x38, 0x38, 0x33, 0x65, 0x31, 0x35, 0x32, 0x65, 0x35, 0x36, 0x36, 0x30, 0x66, 0x65, 0x65, 0x35, 0x39, 0x36, 0x32, 0x36, 0x65, 0x37, 0x65, 0x33, 0x62, 0x34, 0x66, 0x30, 0x35, 0x31, 0x31, 0x30, 0x65, 0x36, 0x32, 0x32, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x36, 0x38, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x34, 0x32, 0x34, 0x39, 0x31, 0x32, 0x37, 0x39, 0x35, 0x30, 0x65, 0x32, 0x66, 0x38, 0x39, 0x36, 0x65, 0x63, 0x30, 0x65, 0x37, 0x65, 0x32, 0x65, 0x33, 0x64, 0x30, 0x35, 0x35, 0x61, 0x61, 0x62, 0x31, 0x30, 0x35, 0x35, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x33, 0x64, 0x35, 0x33, 0x63, 0x66, 0x36, 0x32, 0x30, 0x66, 0x30, 0x39, 0x32, 0x32, 0x62, 0x34, 0x31, 0x37, 0x38, 0x34, 0x38, 0x64, 0x65, 0x65, 0x39, 0x36, 0x63, 0x31, 0x39, 0x30, 0x62, 0x35, 0x62, 0x63, 0x38, 0x32, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x63, 0x32, 0x65, 0x36, 0x64, 0x65, 0x33, 0x39, 0x63, 0x30, 0x37, 0x63, 0x32, 0x62, 0x61, 0x65, 0x35, 0x35, 0x36, 0x61, 0x63, 0x66, 0x62, 0x65, 0x65, 0x32, 0x63, 0x34, 0x37, 0x32, 0x38, 0x62, 0x39, 0x39, 0x38, 0x32, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x63, 0x34, 0x37, 0x31, 0x36, 0x64, 0x31, 0x65, 0x65, 0x35, 0x32, 0x37, 0x39, 0x61, 0x38, 0x36, 0x64, 0x30, 0x31, 0x36, 0x33, 0x61, 0x31, 0x34, 0x36, 0x31, 0x38, 0x31, 0x38, 0x31, 0x65, 0x31, 0x36, 0x31, 0x33, 0x36, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x38, 0x65, 0x66, 0x32, 0x38, 0x61, 0x35, 0x65, 0x64, 0x39, 0x38, 0x34, 0x61, 0x37, 0x64, 0x62, 0x32, 0x34, 0x61, 0x31, 0x61, 0x65, 0x37, 0x38, 0x32, 0x64, 0x66, 0x62, 0x38, 0x37, 0x66, 0x33, 0x39, 0x37, 0x64, 0x66, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x66, 0x62, 0x65, 0x35, 0x38, 0x38, 0x35, 0x66, 0x39, 0x66, 0x63, 0x63, 0x65, 0x39, 0x65, 0x61, 0x35, 0x65, 0x64, 0x62, 0x38, 0x32, 0x65, 0x64, 0x34, 0x61, 0x31, 0x31, 0x39, 0x36, 0x64, 0x64, 0x32, 0x35, 0x39, 0x61, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x62, 0x66, 0x31, 0x34, 0x64, 0x37, 0x62, 0x31, 0x66, 0x63, 0x38, 0x34, 0x65, 0x62, 0x66, 0x33, 0x63, 0x39, 0x36, 0x62, 0x65, 0x31, 0x32, 0x66, 0x37, 0x62, 0x63, 0x65, 0x30, 0x31, 0x61, 0x61, 0x36, 0x39, 0x62, 0x30, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x64, 0x35, 0x63, 0x33, 0x32, 0x34, 0x61, 0x38, 0x32, 0x30, 0x39, 0x64, 0x37, 0x63, 0x38, 0x30, 0x34, 0x39, 0x64, 0x30, 0x64, 0x34, 0x61, 0x65, 0x64, 0x65, 0x30, 0x32, 0x62, 0x61, 0x38, 0x30, 0x61, 0x62, 0x35, 0x37, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x38, 0x38, 0x39, 0x33, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x64, 0x35, 0x61, 0x37, 0x31, 0x63, 0x65, 0x38, 0x62, 0x38, 0x66, 0x38, 0x61, 0x65, 0x30, 0x32, 0x62, 0x32, 0x65, 0x61, 0x66, 0x38, 0x65, 0x61, 0x66, 0x32, 0x63, 0x61, 0x32, 0x38, 0x34, 0x30, 0x62, 0x39, 0x33, 0x66, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x61, 0x35, 0x39, 0x63, 0x33, 0x63, 0x63, 0x35, 0x66, 0x66, 0x61, 0x63, 0x62, 0x63, 0x62, 0x36, 0x37, 0x62, 0x65, 0x30, 0x66, 0x63, 0x37, 0x32, 0x35, 0x36, 0x66, 0x36, 0x34, 0x63, 0x39, 0x62, 0x31, 0x32, 0x37, 0x63, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x32, 0x31, 0x61, 0x66, 0x31, 0x62, 0x38, 0x64, 0x62, 0x66, 0x32, 0x37, 0x66, 0x63, 0x66, 0x36, 0x33, 0x66, 0x33, 0x37, 0x65, 0x30, 0x34, 0x37, 0x62, 0x38, 0x37, 0x61, 0x38, 0x32, 0x35, 0x63, 0x62, 0x65, 0x37, 0x63, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x33, 0x35, 0x61, 0x61, 0x62, 0x36, 0x38, 0x38, 0x61, 0x30, 0x63, 0x64, 0x38, 0x65, 0x66, 0x38, 0x32, 0x65, 0x37, 0x36, 0x35, 0x34, 0x31, 0x62, 0x61, 0x37, 0x61, 0x63, 0x33, 0x39, 0x35, 0x32, 0x37, 0x66, 0x37, 0x34, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x61, 0x63, 0x35, 0x63, 0x66, 0x65, 0x36, 0x37, 0x63, 0x35, 0x34, 0x61, 0x61, 0x37, 0x65, 0x62, 0x66, 0x62, 0x61, 0x34, 0x34, 0x38, 0x36, 0x36, 0x36, 0x63, 0x34, 0x36, 0x31, 0x61, 0x33, 0x62, 0x31, 0x66, 0x65, 0x32, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x61, 0x35, 0x33, 0x61, 0x62, 0x35, 0x34, 0x39, 0x65, 0x32, 0x30, 0x31, 0x36, 0x64, 0x66, 0x61, 0x32, 0x32, 0x33, 0x63, 0x39, 0x65, 0x64, 0x35, 0x61, 0x33, 0x38, 0x66, 0x61, 0x64, 0x39, 0x31, 0x32, 0x38, 0x38, 0x64, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x61, 0x34, 0x64, 0x65, 0x31, 0x39, 0x64, 0x65, 0x64, 0x37, 0x39, 0x30, 0x30, 0x38, 0x63, 0x66, 0x64, 0x63, 0x64, 0x34, 0x35, 0x64, 0x30, 0x31, 0x34, 0x64, 0x32, 0x65, 0x35, 0x38, 0x34, 0x62, 0x38, 0x39, 0x31, 0x34, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x64, 0x62, 0x66, 0x34, 0x61, 0x61, 0x65, 0x30, 0x65, 0x33, 0x65, 0x66, 0x34, 0x34, 0x66, 0x37, 0x64, 0x64, 0x34, 0x64, 0x38, 0x39, 0x38, 0x35, 0x63, 0x66, 0x61, 0x66, 0x30, 0x39, 0x36, 0x65, 0x63, 0x34, 0x38, 0x65, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x36, 0x33, 0x33, 0x66, 0x63, 0x64, 0x31, 0x31, 0x32, 0x63, 0x63, 0x65, 0x65, 0x62, 0x37, 0x36, 0x35, 0x66, 0x65, 0x30, 0x34, 0x31, 0x38, 0x31, 0x37, 0x30, 0x37, 0x33, 0x32, 0x61, 0x39, 0x37, 0x30, 0x35, 0x65, 0x37, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x32, 0x66, 0x32, 0x32, 0x38, 0x62, 0x30, 0x61, 0x39, 0x34, 0x37, 0x34, 0x38, 0x63, 0x38, 0x65, 0x65, 0x63, 0x36, 0x31, 0x32, 0x64, 0x32, 0x34, 0x36, 0x66, 0x39, 0x38, 0x39, 0x33, 0x36, 0x33, 0x65, 0x30, 0x38, 0x66, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x33, 0x34, 0x39, 0x37, 0x66, 0x35, 0x65, 0x66, 0x35, 0x66, 0x65, 0x36, 0x33, 0x30, 0x39, 0x35, 0x38, 0x33, 0x36, 0x63, 0x30, 0x30, 0x34, 0x65, 0x62, 0x39, 0x63, 0x65, 0x30, 0x32, 0x65, 0x39, 0x30, 0x31, 0x33, 0x62, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x33, 0x34, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x36, 0x64, 0x66, 0x64, 0x35, 0x35, 0x33, 0x62, 0x32, 0x65, 0x38, 0x37, 0x33, 0x64, 0x32, 0x61, 0x65, 0x63, 0x31, 0x35, 0x62, 0x64, 0x35, 0x66, 0x62, 0x62, 0x33, 0x66, 0x38, 0x34, 0x37, 0x32, 0x64, 0x38, 0x64, 0x33, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x65, 0x62, 0x66, 0x34, 0x34, 0x32, 0x35, 0x36, 0x34, 0x36, 0x65, 0x36, 0x63, 0x66, 0x38, 0x31, 0x62, 0x31, 0x30, 0x39, 0x63, 0x65, 0x37, 0x62, 0x66, 0x34, 0x61, 0x32, 0x61, 0x36, 0x33, 0x64, 0x38, 0x34, 0x38, 0x31, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x65, 0x35, 0x65, 0x33, 0x62, 0x35, 0x66, 0x35, 0x39, 0x31, 0x64, 0x35, 0x65, 0x63, 0x61, 0x33, 0x38, 0x61, 0x62, 0x66, 0x32, 0x32, 0x38, 0x66, 0x32, 0x65, 0x33, 0x63, 0x33, 0x35, 0x31, 0x33, 0x34, 0x62, 0x64, 0x61, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x31, 0x39, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x63, 0x34, 0x31, 0x65, 0x62, 0x61, 0x30, 0x30, 0x38, 0x65, 0x32, 0x30, 0x63, 0x62, 0x65, 0x39, 0x32, 0x37, 0x66, 0x33, 0x34, 0x36, 0x36, 0x30, 0x33, 0x66, 0x63, 0x38, 0x38, 0x36, 0x39, 0x38, 0x31, 0x32, 0x35, 0x39, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x32, 0x62, 0x61, 0x37, 0x36, 0x64, 0x62, 0x34, 0x31, 0x62, 0x37, 0x35, 0x36, 0x30, 0x36, 0x64, 0x64, 0x34, 0x38, 0x61, 0x34, 0x38, 0x66, 0x30, 0x31, 0x33, 0x37, 0x65, 0x39, 0x31, 0x37, 0x34, 0x65, 0x30, 0x33, 0x31, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x32, 0x34, 0x62, 0x64, 0x62, 0x63, 0x31, 0x63, 0x34, 0x37, 0x66, 0x30, 0x65, 0x62, 0x38, 0x33, 0x64, 0x31, 0x32, 0x38, 0x63, 0x61, 0x65, 0x34, 0x38, 0x61, 0x63, 0x33, 0x33, 0x63, 0x34, 0x38, 0x31, 0x37, 0x65, 0x39, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x34, 0x65, 0x35, 0x66, 0x66, 0x62, 0x37, 0x30, 0x34, 0x63, 0x32, 0x63, 0x39, 0x31, 0x33, 0x39, 0x64, 0x37, 0x37, 0x65, 0x66, 0x36, 0x31, 0x64, 0x38, 0x63, 0x64, 0x66, 0x61, 0x33, 0x31, 0x64, 0x37, 0x61, 0x38, 0x38, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x38, 0x33, 0x36, 0x30, 0x65, 0x39, 0x38, 0x35, 0x66, 0x32, 0x30, 0x36, 0x32, 0x65, 0x38, 0x66, 0x38, 0x65, 0x66, 0x65, 0x30, 0x32, 0x61, 0x64, 0x32, 0x63, 0x62, 0x63, 0x39, 0x31, 0x61, 0x64, 0x39, 0x61, 0x35, 0x61, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x35, 0x31, 0x66, 0x39, 0x30, 0x33, 0x61, 0x65, 0x31, 0x38, 0x37, 0x32, 0x37, 0x32, 0x35, 0x39, 0x65, 0x65, 0x65, 0x38, 0x34, 0x31, 0x61, 0x31, 0x38, 0x39, 0x61, 0x31, 0x66, 0x35, 0x36, 0x39, 0x61, 0x35, 0x66, 0x64, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x61, 0x36, 0x62, 0x31, 0x66, 0x30, 0x64, 0x62, 0x36, 0x30, 0x33, 0x35, 0x33, 0x37, 0x38, 0x32, 0x36, 0x38, 0x39, 0x31, 0x62, 0x38, 0x62, 0x34, 0x62, 0x63, 0x31, 0x36, 0x33, 0x39, 0x38, 0x34, 0x62, 0x62, 0x34, 0x30, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x66, 0x66, 0x66, 0x34, 0x32, 0x63, 0x36, 0x37, 0x38, 0x35, 0x35, 0x31, 0x64, 0x31, 0x34, 0x31, 0x65, 0x62, 0x37, 0x35, 0x61, 0x36, 0x65, 0x65, 0x33, 0x39, 0x38, 0x31, 0x31, 0x37, 0x64, 0x66, 0x33, 0x65, 0x34, 0x61, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x32, 0x39, 0x34, 0x61, 0x64, 0x62, 0x62, 0x36, 0x66, 0x30, 0x64, 0x63, 0x63, 0x37, 0x36, 0x65, 0x36, 0x33, 0x32, 0x65, 0x62, 0x65, 0x66, 0x34, 0x38, 0x61, 0x62, 0x34, 0x39, 0x66, 0x31, 0x32, 0x34, 0x64, 0x62, 0x62, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x34, 0x33, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x37, 0x30, 0x30, 0x64, 0x35, 0x33, 0x32, 0x35, 0x34, 0x64, 0x34, 0x33, 0x30, 0x66, 0x32, 0x32, 0x37, 0x38, 0x31, 0x61, 0x34, 0x61, 0x37, 0x36, 0x61, 0x34, 0x36, 0x33, 0x39, 0x33, 0x33, 0x62, 0x35, 0x64, 0x36, 0x62, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x34, 0x61, 0x37, 0x61, 0x61, 0x61, 0x38, 0x66, 0x34, 0x39, 0x66, 0x32, 0x66, 0x62, 0x39, 0x61, 0x38, 0x31, 0x30, 0x32, 0x64, 0x36, 0x62, 0x62, 0x65, 0x34, 0x63, 0x34, 0x38, 0x61, 0x65, 0x37, 0x63, 0x30, 0x36, 0x66, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x64, 0x34, 0x65, 0x36, 0x33, 0x66, 0x35, 0x32, 0x36, 0x35, 0x34, 0x32, 0x64, 0x34, 0x34, 0x66, 0x64, 0x64, 0x64, 0x33, 0x34, 0x64, 0x35, 0x39, 0x63, 0x64, 0x32, 0x35, 0x33, 0x38, 0x38, 0x66, 0x66, 0x64, 0x36, 0x62, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x61, 0x63, 0x39, 0x31, 0x66, 0x62, 0x38, 0x33, 0x61, 0x31, 0x34, 0x37, 0x64, 0x32, 0x66, 0x37, 0x36, 0x63, 0x33, 0x32, 0x36, 0x37, 0x39, 0x38, 0x34, 0x62, 0x39, 0x31, 0x30, 0x61, 0x37, 0x39, 0x39, 0x33, 0x33, 0x33, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x33, 0x32, 0x63, 0x66, 0x34, 0x66, 0x35, 0x31, 0x31, 0x35, 0x66, 0x34, 0x62, 0x33, 0x34, 0x61, 0x30, 0x30, 0x61, 0x36, 0x34, 0x63, 0x36, 0x31, 0x37, 0x64, 0x65, 0x30, 0x36, 0x33, 0x38, 0x37, 0x33, 0x35, 0x34, 0x33, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x62, 0x65, 0x64, 0x64, 0x35, 0x37, 0x36, 0x61, 0x34, 0x62, 0x34, 0x63, 0x32, 0x30, 0x32, 0x37, 0x64, 0x61, 0x37, 0x33, 0x35, 0x61, 0x35, 0x62, 0x63, 0x33, 0x66, 0x35, 0x33, 0x33, 0x32, 0x35, 0x32, 0x61, 0x31, 0x38, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x61, 0x33, 0x62, 0x39, 0x38, 0x65, 0x34, 0x35, 0x39, 0x33, 0x66, 0x65, 0x61, 0x30, 0x62, 0x33, 0x38, 0x63, 0x34, 0x66, 0x34, 0x35, 0x35, 0x61, 0x35, 0x30, 0x36, 0x35, 0x66, 0x30, 0x35, 0x31, 0x61, 0x32, 0x66, 0x38, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x33, 0x30, 0x39, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x66, 0x35, 0x32, 0x33, 0x38, 0x38, 0x35, 0x34, 0x36, 0x65, 0x63, 0x33, 0x35, 0x61, 0x63, 0x61, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x39, 0x33, 0x64, 0x38, 0x64, 0x36, 0x30, 0x39, 0x64, 0x65, 0x33, 0x61, 0x34, 0x62, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x34, 0x32, 0x33, 0x63, 0x37, 0x36, 0x39, 0x33, 0x30, 0x64, 0x30, 0x37, 0x66, 0x39, 0x33, 0x63, 0x34, 0x37, 0x61, 0x35, 0x63, 0x63, 0x34, 0x66, 0x36, 0x31, 0x35, 0x37, 0x34, 0x35, 0x63, 0x34, 0x35, 0x61, 0x39, 0x64, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x35, 0x32, 0x66, 0x32, 0x65, 0x34, 0x61, 0x33, 0x65, 0x33, 0x63, 0x31, 0x32, 0x64, 0x64, 0x31, 0x63, 0x37, 0x31, 0x62, 0x66, 0x37, 0x38, 0x61, 0x34, 0x65, 0x63, 0x33, 0x30, 0x34, 0x33, 0x64, 0x63, 0x38, 0x38, 0x62, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x61, 0x64, 0x65, 0x39, 0x31, 0x64, 0x31, 0x35, 0x34, 0x35, 0x31, 0x37, 0x36, 0x32, 0x30, 0x66, 0x64, 0x34, 0x62, 0x34, 0x33, 0x39, 0x61, 0x63, 0x39, 0x37, 0x31, 0x35, 0x37, 0x61, 0x34, 0x31, 0x30, 0x32, 0x61, 0x39, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x36, 0x39, 0x38, 0x64, 0x36, 0x34, 0x63, 0x36, 0x35, 0x63, 0x37, 0x66, 0x32, 0x62, 0x32, 0x63, 0x37, 0x32, 0x35, 0x33, 0x30, 0x35, 0x39, 0x63, 0x64, 0x33, 0x64, 0x31, 0x38, 0x31, 0x64, 0x38, 0x39, 0x39, 0x62, 0x36, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x64, 0x38, 0x39, 0x35, 0x34, 0x65, 0x38, 0x66, 0x33, 0x66, 0x63, 0x35, 0x33, 0x33, 0x64, 0x32, 0x64, 0x32, 0x33, 0x30, 0x66, 0x66, 0x30, 0x32, 0x35, 0x63, 0x62, 0x34, 0x64, 0x63, 0x65, 0x31, 0x34, 0x66, 0x33, 0x34, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x39, 0x61, 0x38, 0x31, 0x36, 0x62, 0x31, 0x37, 0x61, 0x62, 0x33, 0x64, 0x32, 0x37, 0x62, 0x62, 0x63, 0x30, 0x61, 0x65, 0x30, 0x30, 0x35, 0x31, 0x66, 0x36, 0x61, 0x30, 0x37, 0x30, 0x62, 0x65, 0x31, 0x66, 0x66, 0x32, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x34, 0x64, 0x39, 0x63, 0x38, 0x34, 0x38, 0x34, 0x63, 0x34, 0x33, 0x63, 0x34, 0x32, 0x66, 0x66, 0x32, 0x63, 0x35, 0x61, 0x62, 0x37, 0x35, 0x39, 0x39, 0x39, 0x36, 0x34, 0x39, 0x38, 0x64, 0x33, 0x32, 0x33, 0x39, 0x39, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x39, 0x34, 0x34, 0x66, 0x62, 0x63, 0x61, 0x39, 0x62, 0x35, 0x37, 0x39, 0x36, 0x33, 0x30, 0x38, 0x34, 0x65, 0x62, 0x38, 0x34, 0x64, 0x66, 0x37, 0x63, 0x38, 0x35, 0x66, 0x62, 0x39, 0x62, 0x63, 0x64, 0x66, 0x62, 0x38, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x34, 0x39, 0x38, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x64, 0x39, 0x33, 0x63, 0x39, 0x30, 0x63, 0x32, 0x39, 0x63, 0x30, 0x37, 0x62, 0x63, 0x35, 0x66, 0x62, 0x35, 0x66, 0x63, 0x34, 0x39, 0x61, 0x65, 0x65, 0x61, 0x35, 0x35, 0x61, 0x34, 0x30, 0x65, 0x31, 0x33, 0x34, 0x66, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x61, 0x65, 0x64, 0x62, 0x35, 0x33, 0x31, 0x39, 0x66, 0x65, 0x38, 0x30, 0x36, 0x35, 0x34, 0x33, 0x63, 0x35, 0x36, 0x65, 0x35, 0x30, 0x32, 0x31, 0x64, 0x33, 0x37, 0x32, 0x66, 0x37, 0x31, 0x62, 0x65, 0x39, 0x30, 0x36, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x30, 0x37, 0x39, 0x63, 0x39, 0x32, 0x61, 0x36, 0x32, 0x39, 0x63, 0x61, 0x31, 0x35, 0x63, 0x38, 0x63, 0x61, 0x66, 0x61, 0x32, 0x65, 0x62, 0x32, 0x38, 0x64, 0x35, 0x62, 0x63, 0x31, 0x37, 0x61, 0x66, 0x38, 0x32, 0x38, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x32, 0x61, 0x35, 0x32, 0x61, 0x37, 0x63, 0x66, 0x30, 0x63, 0x38, 0x34, 0x33, 0x36, 0x61, 0x38, 0x65, 0x30, 0x30, 0x37, 0x39, 0x37, 0x36, 0x62, 0x36, 0x63, 0x32, 0x36, 0x62, 0x37, 0x32, 0x32, 0x39, 0x64, 0x31, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x38, 0x39, 0x66, 0x37, 0x34, 0x36, 0x30, 0x62, 0x61, 0x33, 0x64, 0x66, 0x65, 0x38, 0x33, 0x63, 0x35, 0x61, 0x31, 0x64, 0x33, 0x61, 0x30, 0x31, 0x39, 0x65, 0x65, 0x31, 0x32, 0x35, 0x30, 0x66, 0x32, 0x34, 0x32, 0x66, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x31, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x37, 0x62, 0x66, 0x65, 0x36, 0x34, 0x65, 0x33, 0x61, 0x31, 0x65, 0x33, 0x38, 0x30, 0x30, 0x65, 0x39, 0x34, 0x64, 0x62, 0x31, 0x63, 0x36, 0x63, 0x31, 0x38, 0x34, 0x64, 0x38, 0x64, 0x63, 0x38, 0x61, 0x61, 0x66, 0x63, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x66, 0x64, 0x30, 0x32, 0x65, 0x64, 0x33, 0x37, 0x30, 0x63, 0x37, 0x30, 0x36, 0x30, 0x62, 0x32, 0x61, 0x65, 0x35, 0x33, 0x63, 0x30, 0x37, 0x38, 0x63, 0x38, 0x30, 0x31, 0x32, 0x31, 0x39, 0x30, 0x64, 0x66, 0x62, 0x62, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x62, 0x36, 0x32, 0x66, 0x31, 0x33, 0x31, 0x61, 0x35, 0x66, 0x32, 0x39, 0x62, 0x34, 0x35, 0x35, 0x37, 0x31, 0x35, 0x31, 0x33, 0x65, 0x65, 0x37, 0x61, 0x37, 0x34, 0x61, 0x38, 0x66, 0x30, 0x62, 0x32, 0x33, 0x32, 0x32, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x38, 0x32, 0x31, 0x32, 0x62, 0x37, 0x32, 0x32, 0x61, 0x66, 0x64, 0x34, 0x30, 0x38, 0x61, 0x37, 0x61, 0x37, 0x33, 0x65, 0x64, 0x33, 0x65, 0x32, 0x33, 0x39, 0x35, 0x65, 0x65, 0x36, 0x34, 0x35, 0x34, 0x61, 0x30, 0x33, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x35, 0x66, 0x33, 0x30, 0x62, 0x63, 0x39, 0x30, 0x63, 0x64, 0x66, 0x34, 0x35, 0x37, 0x37, 0x65, 0x65, 0x34, 0x37, 0x64, 0x36, 0x35, 0x64, 0x37, 0x38, 0x35, 0x66, 0x62, 0x65, 0x32, 0x65, 0x38, 0x33, 0x37, 0x63, 0x36, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x36, 0x36, 0x31, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x37, 0x33, 0x37, 0x36, 0x66, 0x34, 0x35, 0x64, 0x32, 0x31, 0x65, 0x31, 0x35, 0x65, 0x64, 0x65, 0x33, 0x62, 0x32, 0x36, 0x66, 0x32, 0x36, 0x35, 0x35, 0x66, 0x63, 0x65, 0x65, 0x30, 0x32, 0x63, 0x63, 0x63, 0x30, 0x66, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x61, 0x33, 0x39, 0x63, 0x65, 0x33, 0x65, 0x66, 0x34, 0x61, 0x37, 0x61, 0x33, 0x39, 0x36, 0x36, 0x62, 0x33, 0x32, 0x65, 0x65, 0x37, 0x65, 0x61, 0x34, 0x65, 0x62, 0x63, 0x32, 0x33, 0x33, 0x35, 0x61, 0x38, 0x66, 0x31, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x32, 0x35, 0x39, 0x64, 0x39, 0x37, 0x35, 0x61, 0x32, 0x31, 0x64, 0x38, 0x33, 0x61, 0x65, 0x33, 0x30, 0x65, 0x33, 0x33, 0x66, 0x38, 0x30, 0x30, 0x66, 0x35, 0x33, 0x66, 0x33, 0x37, 0x64, 0x66, 0x61, 0x30, 0x31, 0x39, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x64, 0x31, 0x34, 0x33, 0x37, 0x30, 0x31, 0x66, 0x32, 0x66, 0x37, 0x32, 0x32, 0x38, 0x30, 0x66, 0x64, 0x30, 0x34, 0x61, 0x37, 0x62, 0x34, 0x31, 0x36, 0x34, 0x32, 0x38, 0x31, 0x39, 0x37, 0x39, 0x65, 0x61, 0x38, 0x37, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x63, 0x39, 0x39, 0x61, 0x64, 0x37, 0x38, 0x31, 0x36, 0x61, 0x65, 0x39, 0x30, 0x32, 0x30, 0x66, 0x66, 0x38, 0x61, 0x64, 0x66, 0x37, 0x39, 0x66, 0x61, 0x39, 0x38, 0x36, 0x39, 0x62, 0x37, 0x63, 0x65, 0x61, 0x36, 0x36, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x31, 0x66, 0x64, 0x65, 0x64, 0x38, 0x30, 0x61, 0x63, 0x62, 0x35, 0x30, 0x32, 0x38, 0x39, 0x30, 0x65, 0x38, 0x37, 0x33, 0x36, 0x39, 0x37, 0x34, 0x31, 0x66, 0x33, 0x37, 0x32, 0x32, 0x35, 0x31, 0x34, 0x63, 0x65, 0x66, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x35, 0x37, 0x66, 0x63, 0x62, 0x65, 0x36, 0x38, 0x32, 0x65, 0x62, 0x34, 0x65, 0x38, 0x64, 0x62, 0x31, 0x35, 0x32, 0x65, 0x63, 0x66, 0x38, 0x39, 0x32, 0x34, 0x35, 0x36, 0x30, 0x30, 0x30, 0x62, 0x35, 0x31, 0x33, 0x64, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x63, 0x33, 0x37, 0x63, 0x35, 0x32, 0x62, 0x39, 0x37, 0x66, 0x34, 0x62, 0x30, 0x34, 0x30, 0x62, 0x31, 0x61, 0x61, 0x33, 0x39, 0x31, 0x64, 0x36, 0x64, 0x65, 0x63, 0x31, 0x35, 0x32, 0x38, 0x39, 0x33, 0x63, 0x34, 0x37, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x66, 0x63, 0x38, 0x65, 0x34, 0x64, 0x33, 0x38, 0x36, 0x62, 0x30, 0x64, 0x30, 0x62, 0x62, 0x34, 0x61, 0x37, 0x30, 0x37, 0x65, 0x64, 0x66, 0x33, 0x62, 0x64, 0x35, 0x36, 0x30, 0x64, 0x66, 0x31, 0x61, 0x64, 0x38, 0x66, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x63, 0x30, 0x62, 0x62, 0x37, 0x66, 0x63, 0x38, 0x38, 0x65, 0x61, 0x34, 0x32, 0x32, 0x64, 0x32, 0x65, 0x66, 0x37, 0x65, 0x35, 0x34, 0x30, 0x65, 0x32, 0x64, 0x38, 0x66, 0x32, 0x38, 0x62, 0x31, 0x62, 0x62, 0x38, 0x31, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x66, 0x34, 0x39, 0x33, 0x61, 0x33, 0x64, 0x31, 0x30, 0x38, 0x61, 0x61, 0x61, 0x32, 0x64, 0x31, 0x38, 0x64, 0x39, 0x38, 0x39, 0x32, 0x32, 0x66, 0x38, 0x65, 0x66, 0x65, 0x31, 0x36, 0x36, 0x32, 0x63, 0x66, 0x62, 0x37, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x34, 0x35, 0x38, 0x66, 0x36, 0x38, 0x62, 0x62, 0x32, 0x37, 0x32, 0x63, 0x62, 0x35, 0x36, 0x37, 0x33, 0x61, 0x30, 0x34, 0x66, 0x37, 0x38, 0x31, 0x62, 0x34, 0x30, 0x33, 0x35, 0x35, 0x36, 0x66, 0x64, 0x33, 0x61, 0x33, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x35, 0x32, 0x35, 0x61, 0x33, 0x33, 0x65, 0x61, 0x39, 0x31, 0x36, 0x31, 0x37, 0x37, 0x66, 0x31, 0x37, 0x32, 0x38, 0x33, 0x66, 0x63, 0x61, 0x32, 0x39, 0x65, 0x38, 0x62, 0x33, 0x35, 0x30, 0x62, 0x37, 0x66, 0x35, 0x33, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x65, 0x62, 0x38, 0x34, 0x36, 0x62, 0x65, 0x34, 0x33, 0x30, 0x34, 0x31, 0x66, 0x64, 0x36, 0x62, 0x33, 0x34, 0x32, 0x30, 0x32, 0x38, 0x39, 0x37, 0x39, 0x34, 0x33, 0x65, 0x33, 0x66, 0x32, 0x31, 0x63, 0x62, 0x37, 0x66, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x32, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x61, 0x61, 0x35, 0x33, 0x30, 0x64, 0x63, 0x33, 0x36, 0x39, 0x35, 0x38, 0x62, 0x34, 0x65, 0x64, 0x62, 0x33, 0x38, 0x65, 0x65, 0x65, 0x36, 0x64, 0x64, 0x39, 0x65, 0x33, 0x63, 0x37, 0x37, 0x64, 0x34, 0x63, 0x39, 0x31, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x35, 0x38, 0x64, 0x36, 0x35, 0x35, 0x35, 0x66, 0x66, 0x39, 0x38, 0x61, 0x31, 0x32, 0x39, 0x63, 0x63, 0x65, 0x34, 0x30, 0x33, 0x37, 0x39, 0x35, 0x33, 0x64, 0x30, 0x30, 0x32, 0x30, 0x36, 0x65, 0x66, 0x66, 0x34, 0x32, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x33, 0x35, 0x66, 0x65, 0x34, 0x65, 0x36, 0x62, 0x36, 0x61, 0x66, 0x32, 0x37, 0x61, 0x65, 0x34, 0x39, 0x32, 0x61, 0x35, 0x37, 0x38, 0x35, 0x31, 0x35, 0x65, 0x39, 0x64, 0x33, 0x39, 0x66, 0x61, 0x36, 0x66, 0x61, 0x36, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x36, 0x62, 0x37, 0x31, 0x63, 0x30, 0x30, 0x31, 0x35, 0x38, 0x31, 0x39, 0x63, 0x32, 0x34, 0x32, 0x61, 0x37, 0x38, 0x36, 0x31, 0x65, 0x36, 0x66, 0x66, 0x37, 0x65, 0x64, 0x65, 0x64, 0x38, 0x61, 0x35, 0x66, 0x37, 0x31, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x31, 0x39, 0x35, 0x32, 0x65, 0x65, 0x64, 0x31, 0x63, 0x35, 0x34, 0x38, 0x64, 0x39, 0x65, 0x65, 0x39, 0x62, 0x39, 0x37, 0x64, 0x30, 0x31, 0x36, 0x39, 0x61, 0x30, 0x37, 0x39, 0x33, 0x33, 0x62, 0x65, 0x36, 0x39, 0x66, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x32, 0x31, 0x64, 0x62, 0x62, 0x38, 0x39, 0x62, 0x33, 0x61, 0x30, 0x37, 0x34, 0x31, 0x39, 0x30, 0x38, 0x34, 0x61, 0x64, 0x31, 0x30, 0x63, 0x33, 0x63, 0x31, 0x35, 0x64, 0x66, 0x65, 0x39, 0x62, 0x33, 0x32, 0x64, 0x30, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x34, 0x33, 0x33, 0x36, 0x65, 0x65, 0x34, 0x65, 0x61, 0x31, 0x35, 0x35, 0x66, 0x39, 0x66, 0x32, 0x34, 0x66, 0x38, 0x37, 0x62, 0x63, 0x61, 0x39, 0x63, 0x61, 0x37, 0x32, 0x65, 0x32, 0x35, 0x33, 0x65, 0x31, 0x32, 0x63, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x63, 0x35, 0x66, 0x63, 0x34, 0x62, 0x37, 0x65, 0x38, 0x61, 0x30, 0x32, 0x39, 0x33, 0x66, 0x66, 0x33, 0x39, 0x61, 0x33, 0x61, 0x30, 0x66, 0x37, 0x64, 0x36, 0x30, 0x64, 0x32, 0x36, 0x34, 0x36, 0x64, 0x33, 0x37, 0x61, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x32, 0x63, 0x31, 0x39, 0x37, 0x64, 0x32, 0x36, 0x65, 0x39, 0x38, 0x62, 0x30, 0x64, 0x61, 0x38, 0x33, 0x65, 0x31, 0x62, 0x37, 0x32, 0x63, 0x37, 0x38, 0x37, 0x36, 0x31, 0x38, 0x63, 0x39, 0x37, 0x39, 0x64, 0x33, 0x64, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x61, 0x61, 0x35, 0x37, 0x33, 0x66, 0x65, 0x64, 0x32, 0x66, 0x32, 0x33, 0x33, 0x34, 0x31, 0x30, 0x64, 0x62, 0x61, 0x65, 0x35, 0x31, 0x38, 0x30, 0x31, 0x34, 0x35, 0x62, 0x32, 0x33, 0x63, 0x33, 0x31, 0x61, 0x30, 0x32, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x33, 0x62, 0x32, 0x66, 0x39, 0x32, 0x31, 0x63, 0x65, 0x34, 0x61, 0x33, 0x37, 0x61, 0x32, 0x35, 0x39, 0x65, 0x65, 0x34, 0x61, 0x64, 0x38, 0x62, 0x32, 0x31, 0x35, 0x38, 0x64, 0x31, 0x35, 0x64, 0x36, 0x36, 0x34, 0x66, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x37, 0x34, 0x62, 0x39, 0x64, 0x66, 0x61, 0x65, 0x34, 0x35, 0x36, 0x61, 0x39, 0x32, 0x39, 0x62, 0x61, 0x33, 0x62, 0x31, 0x61, 0x32, 0x37, 0x65, 0x35, 0x37, 0x32, 0x63, 0x39, 0x62, 0x32, 0x63, 0x65, 0x63, 0x64, 0x66, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x38, 0x62, 0x38, 0x30, 0x30, 0x35, 0x64, 0x36, 0x33, 0x36, 0x61, 0x34, 0x39, 0x36, 0x36, 0x34, 0x66, 0x37, 0x34, 0x32, 0x37, 0x35, 0x65, 0x66, 0x34, 0x32, 0x34, 0x33, 0x38, 0x61, 0x63, 0x64, 0x36, 0x35, 0x61, 0x63, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x31, 0x61, 0x35, 0x32, 0x30, 0x30, 0x31, 0x36, 0x36, 0x31, 0x66, 0x61, 0x63, 0x37, 0x31, 0x38, 0x62, 0x32, 0x64, 0x37, 0x62, 0x33, 0x35, 0x31, 0x62, 0x37, 0x63, 0x36, 0x66, 0x62, 0x35, 0x32, 0x31, 0x61, 0x37, 0x61, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x32, 0x61, 0x35, 0x35, 0x63, 0x34, 0x33, 0x63, 0x61, 0x65, 0x64, 0x63, 0x35, 0x39, 0x37, 0x32, 0x31, 0x38, 0x33, 0x37, 0x39, 0x30, 0x30, 0x30, 0x63, 0x65, 0x35, 0x31, 0x30, 0x64, 0x35, 0x34, 0x38, 0x38, 0x33, 0x36, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x39, 0x30, 0x63, 0x38, 0x35, 0x38, 0x37, 0x37, 0x31, 0x39, 0x38, 0x37, 0x35, 0x36, 0x62, 0x30, 0x33, 0x36, 0x36, 0x63, 0x30, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x65, 0x35, 0x32, 0x62, 0x34, 0x34, 0x36, 0x35, 0x30, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x34, 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x33, 0x30, 0x31, 0x37, 0x63, 0x31, 0x35, 0x30, 0x64, 0x64, 0x30, 0x64, 0x63, 0x65, 0x37, 0x66, 0x63, 0x66, 0x38, 0x38, 0x31, 0x62, 0x30, 0x61, 0x34, 0x38, 0x64, 0x30, 0x64, 0x31, 0x63, 0x37, 0x35, 0x36, 0x63, 0x34, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x61, 0x66, 0x37, 0x61, 0x32, 0x61, 0x30, 0x32, 0x61, 0x65, 0x37, 0x38, 0x38, 0x30, 0x31, 0x65, 0x38, 0x39, 0x30, 0x34, 0x61, 0x64, 0x37, 0x61, 0x63, 0x30, 0x35, 0x31, 0x30, 0x38, 0x66, 0x63, 0x35, 0x36, 0x63, 0x66, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x37, 0x64, 0x61, 0x65, 0x37, 0x38, 0x62, 0x63, 0x30, 0x31, 0x31, 0x33, 0x64, 0x38, 0x64, 0x33, 0x39, 0x63, 0x34, 0x34, 0x30, 0x32, 0x66, 0x32, 0x61, 0x36, 0x34, 0x31, 0x61, 0x65, 0x32, 0x61, 0x31, 0x30, 0x35, 0x61, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x31, 0x38, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x62, 0x35, 0x62, 0x35, 0x62, 0x63, 0x35, 0x61, 0x31, 0x31, 0x37, 0x66, 0x61, 0x30, 0x38, 0x62, 0x33, 0x34, 0x65, 0x64, 0x31, 0x64, 0x62, 0x39, 0x34, 0x34, 0x30, 0x36, 0x30, 0x38, 0x35, 0x39, 0x37, 0x61, 0x63, 0x35, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x65, 0x37, 0x33, 0x32, 0x65, 0x64, 0x61, 0x36, 0x35, 0x39, 0x38, 0x38, 0x63, 0x33, 0x61, 0x30, 0x30, 0x63, 0x37, 0x66, 0x34, 0x37, 0x32, 0x66, 0x33, 0x35, 0x31, 0x63, 0x34, 0x36, 0x33, 0x62, 0x31, 0x63, 0x39, 0x36, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x35, 0x33, 0x34, 0x32, 0x39, 0x35, 0x33, 0x63, 0x38, 0x61, 0x32, 0x31, 0x65, 0x38, 0x62, 0x36, 0x33, 0x35, 0x65, 0x65, 0x66, 0x61, 0x63, 0x37, 0x38, 0x31, 0x39, 0x62, 0x65, 0x61, 0x33, 0x30, 0x66, 0x31, 0x37, 0x30, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x36, 0x31, 0x36, 0x62, 0x31, 0x65, 0x65, 0x65, 0x37, 0x37, 0x65, 0x65, 0x66, 0x36, 0x66, 0x31, 0x37, 0x36, 0x65, 0x30, 0x36, 0x39, 0x38, 0x64, 0x62, 0x33, 0x63, 0x30, 0x63, 0x31, 0x34, 0x31, 0x62, 0x32, 0x66, 0x63, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x64, 0x32, 0x30, 0x37, 0x39, 0x30, 0x62, 0x37, 0x64, 0x33, 0x64, 0x62, 0x64, 0x38, 0x38, 0x63, 0x38, 0x31, 0x61, 0x32, 0x37, 0x39, 0x62, 0x38, 0x31, 0x32, 0x30, 0x33, 0x39, 0x65, 0x38, 0x61, 0x36, 0x30, 0x33, 0x62, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x33, 0x34, 0x63, 0x62, 0x31, 0x38, 0x37, 0x34, 0x39, 0x31, 0x65, 0x64, 0x65, 0x37, 0x31, 0x33, 0x61, 0x65, 0x35, 0x62, 0x33, 0x62, 0x32, 0x64, 0x31, 0x32, 0x32, 0x38, 0x34, 0x61, 0x66, 0x34, 0x36, 0x62, 0x38, 0x31, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x39, 0x36, 0x37, 0x63, 0x34, 0x63, 0x35, 0x66, 0x38, 0x61, 0x65, 0x34, 0x37, 0x65, 0x32, 0x36, 0x36, 0x66, 0x62, 0x34, 0x31, 0x36, 0x61, 0x61, 0x64, 0x31, 0x39, 0x36, 0x34, 0x65, 0x65, 0x33, 0x65, 0x37, 0x65, 0x38, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x63, 0x65, 0x66, 0x31, 0x39, 0x63, 0x38, 0x36, 0x38, 0x62, 0x31, 0x35, 0x64, 0x33, 0x34, 0x65, 0x64, 0x61, 0x34, 0x32, 0x36, 0x65, 0x63, 0x37, 0x65, 0x30, 0x34, 0x62, 0x31, 0x38, 0x62, 0x36, 0x30, 0x31, 0x37, 0x30, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x39, 0x64, 0x32, 0x31, 0x63, 0x36, 0x39, 0x32, 0x63, 0x64, 0x33, 0x63, 0x30, 0x31, 0x66, 0x32, 0x30, 0x31, 0x31, 0x66, 0x35, 0x30, 0x35, 0x66, 0x38, 0x37, 0x30, 0x30, 0x33, 0x36, 0x66, 0x61, 0x38, 0x66, 0x36, 0x63, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x34, 0x66, 0x36, 0x61, 0x63, 0x33, 0x39, 0x32, 0x33, 0x62, 0x35, 0x66, 0x64, 0x37, 0x33, 0x31, 0x61, 0x34, 0x63, 0x34, 0x35, 0x39, 0x34, 0x34, 0x65, 0x63, 0x34, 0x66, 0x37, 0x65, 0x63, 0x35, 0x32, 0x61, 0x36, 0x61, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x32, 0x34, 0x64, 0x36, 0x38, 0x64, 0x39, 0x64, 0x30, 0x64, 0x30, 0x30, 0x63, 0x65, 0x63, 0x31, 0x39, 0x33, 0x38, 0x63, 0x38, 0x35, 0x34, 0x65, 0x31, 0x35, 0x66, 0x66, 0x62, 0x38, 0x38, 0x30, 0x62, 0x61, 0x30, 0x31, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x32, 0x31, 0x38, 0x36, 0x64, 0x65, 0x64, 0x32, 0x33, 0x65, 0x30, 0x63, 0x66, 0x39, 0x35, 0x32, 0x31, 0x36, 0x39, 0x34, 0x65, 0x34, 0x65, 0x31, 0x36, 0x34, 0x35, 0x39, 0x33, 0x65, 0x36, 0x39, 0x30, 0x61, 0x39, 0x36, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x34, 0x62, 0x35, 0x65, 0x32, 0x37, 0x38, 0x35, 0x37, 0x38, 0x63, 0x30, 0x34, 0x36, 0x63, 0x63, 0x65, 0x61, 0x66, 0x36, 0x35, 0x37, 0x33, 0x30, 0x61, 0x30, 0x65, 0x30, 0x36, 0x38, 0x33, 0x32, 0x39, 0x65, 0x64, 0x35, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x35, 0x30, 0x61, 0x61, 0x32, 0x61, 0x39, 0x32, 0x31, 0x32, 0x62, 0x63, 0x64, 0x65, 0x35, 0x36, 0x34, 0x31, 0x38, 0x61, 0x65, 0x32, 0x36, 0x31, 0x66, 0x30, 0x62, 0x33, 0x35, 0x65, 0x37, 0x61, 0x39, 0x64, 0x62, 0x62, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x35, 0x33, 0x33, 0x31, 0x33, 0x65, 0x32, 0x61, 0x64, 0x37, 0x34, 0x36, 0x32, 0x33, 0x39, 0x63, 0x62, 0x32, 0x32, 0x37, 0x30, 0x66, 0x34, 0x38, 0x61, 0x66, 0x33, 0x34, 0x64, 0x38, 0x62, 0x62, 0x39, 0x63, 0x34, 0x34, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x35, 0x30, 0x32, 0x35, 0x66, 0x35, 0x39, 0x35, 0x61, 0x63, 0x64, 0x62, 0x66, 0x33, 0x31, 0x31, 0x30, 0x66, 0x37, 0x37, 0x63, 0x35, 0x62, 0x66, 0x32, 0x34, 0x34, 0x37, 0x37, 0x65, 0x36, 0x35, 0x34, 0x38, 0x66, 0x39, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x61, 0x66, 0x33, 0x32, 0x63, 0x32, 0x32, 0x66, 0x65, 0x66, 0x39, 0x39, 0x38, 0x30, 0x33, 0x66, 0x31, 0x37, 0x38, 0x63, 0x66, 0x39, 0x30, 0x62, 0x38, 0x30, 0x32, 0x66, 0x62, 0x35, 0x37, 0x31, 0x63, 0x36, 0x31, 0x63, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x61, 0x38, 0x61, 0x62, 0x64, 0x38, 0x30, 0x61, 0x31, 0x39, 0x39, 0x62, 0x35, 0x34, 0x62, 0x30, 0x38, 0x62, 0x36, 0x35, 0x66, 0x30, 0x31, 0x64, 0x32, 0x30, 0x39, 0x63, 0x32, 0x37, 0x66, 0x65, 0x66, 0x30, 0x31, 0x31, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x32, 0x35, 0x39, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x36, 0x38, 0x33, 0x30, 0x36, 0x62, 0x61, 0x37, 0x66, 0x38, 0x64, 0x61, 0x61, 0x66, 0x37, 0x33, 0x66, 0x34, 0x63, 0x36, 0x34, 0x34, 0x65, 0x66, 0x37, 0x64, 0x32, 0x37, 0x34, 0x33, 0x63, 0x30, 0x66, 0x32, 0x36, 0x38, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x39, 0x32, 0x34, 0x31, 0x39, 0x31, 0x62, 0x37, 0x64, 0x66, 0x36, 0x35, 0x35, 0x62, 0x33, 0x33, 0x31, 0x39, 0x64, 0x63, 0x36, 0x64, 0x36, 0x31, 0x33, 0x37, 0x66, 0x34, 0x38, 0x31, 0x61, 0x37, 0x33, 0x61, 0x30, 0x66, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x61, 0x37, 0x32, 0x30, 0x31, 0x35, 0x66, 0x61, 0x37, 0x38, 0x36, 0x39, 0x36, 0x65, 0x66, 0x64, 0x39, 0x61, 0x38, 0x36, 0x31, 0x37, 0x34, 0x66, 0x37, 0x66, 0x31, 0x66, 0x32, 0x31, 0x30, 0x31, 0x39, 0x32, 0x38, 0x36, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x31, 0x31, 0x39, 0x64, 0x66, 0x39, 0x39, 0x63, 0x36, 0x62, 0x38, 0x64, 0x65, 0x35, 0x38, 0x61, 0x31, 0x65, 0x32, 0x63, 0x33, 0x66, 0x32, 0x39, 0x37, 0x61, 0x36, 0x37, 0x34, 0x34, 0x62, 0x66, 0x35, 0x35, 0x32, 0x32, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x37, 0x33, 0x33, 0x39, 0x34, 0x37, 0x66, 0x61, 0x62, 0x38, 0x32, 0x30, 0x64, 0x62, 0x64, 0x33, 0x35, 0x31, 0x65, 0x66, 0x64, 0x36, 0x37, 0x38, 0x35, 0x35, 0x65, 0x61, 0x30, 0x65, 0x38, 0x38, 0x31, 0x33, 0x37, 0x33, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x65, 0x36, 0x66, 0x38, 0x30, 0x62, 0x37, 0x30, 0x65, 0x31, 0x66, 0x32, 0x33, 0x63, 0x39, 0x31, 0x66, 0x62, 0x64, 0x35, 0x61, 0x39, 0x36, 0x36, 0x62, 0x30, 0x65, 0x34, 0x39, 0x39, 0x64, 0x39, 0x35, 0x64, 0x66, 0x38, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x61, 0x37, 0x64, 0x39, 0x66, 0x61, 0x37, 0x64, 0x30, 0x65, 0x62, 0x31, 0x31, 0x38, 0x35, 0x63, 0x36, 0x37, 0x65, 0x35, 0x34, 0x64, 0x61, 0x38, 0x33, 0x63, 0x32, 0x65, 0x37, 0x35, 0x64, 0x62, 0x36, 0x39, 0x65, 0x33, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x32, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x33, 0x32, 0x65, 0x66, 0x31, 0x63, 0x38, 0x35, 0x62, 0x37, 0x35, 0x61, 0x39, 0x62, 0x32, 0x61, 0x38, 0x30, 0x30, 0x35, 0x37, 0x64, 0x35, 0x30, 0x38, 0x37, 0x33, 0x34, 0x63, 0x35, 0x31, 0x30, 0x38, 0x35, 0x62, 0x65, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x66, 0x63, 0x66, 0x65, 0x38, 0x38, 0x63, 0x38, 0x32, 0x36, 0x63, 0x63, 0x66, 0x31, 0x33, 0x31, 0x64, 0x35, 0x34, 0x65, 0x62, 0x34, 0x65, 0x61, 0x39, 0x65, 0x62, 0x38, 0x30, 0x65, 0x36, 0x31, 0x65, 0x31, 0x65, 0x65, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x31, 0x66, 0x61, 0x36, 0x36, 0x34, 0x33, 0x61, 0x31, 0x66, 0x31, 0x34, 0x63, 0x30, 0x32, 0x39, 0x39, 0x36, 0x61, 0x64, 0x37, 0x31, 0x34, 0x34, 0x62, 0x37, 0x35, 0x39, 0x32, 0x36, 0x65, 0x38, 0x37, 0x65, 0x63, 0x62, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x64, 0x39, 0x65, 0x34, 0x36, 0x61, 0x37, 0x36, 0x30, 0x34, 0x64, 0x37, 0x62, 0x35, 0x61, 0x34, 0x65, 0x61, 0x34, 0x65, 0x65, 0x36, 0x31, 0x61, 0x34, 0x32, 0x62, 0x33, 0x64, 0x32, 0x33, 0x35, 0x30, 0x66, 0x63, 0x33, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x61, 0x66, 0x61, 0x66, 0x35, 0x65, 0x36, 0x32, 0x35, 0x30, 0x35, 0x36, 0x31, 0x35, 0x30, 0x36, 0x38, 0x61, 0x66, 0x38, 0x65, 0x62, 0x32, 0x32, 0x61, 0x31, 0x33, 0x61, 0x64, 0x38, 0x61, 0x39, 0x65, 0x35, 0x35, 0x30, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x66, 0x32, 0x64, 0x63, 0x66, 0x66, 0x35, 0x61, 0x64, 0x37, 0x38, 0x63, 0x33, 0x65, 0x62, 0x36, 0x38, 0x35, 0x30, 0x62, 0x35, 0x63, 0x62, 0x39, 0x35, 0x31, 0x31, 0x32, 0x37, 0x62, 0x36, 0x35, 0x39, 0x35, 0x32, 0x32, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x61, 0x64, 0x31, 0x62, 0x61, 0x61, 0x64, 0x65, 0x35, 0x61, 0x66, 0x30, 0x34, 0x65, 0x32, 0x62, 0x31, 0x37, 0x34, 0x33, 0x39, 0x65, 0x39, 0x33, 0x35, 0x39, 0x38, 0x37, 0x62, 0x66, 0x38, 0x63, 0x32, 0x62, 0x62, 0x34, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x38, 0x38, 0x38, 0x37, 0x62, 0x61, 0x62, 0x35, 0x37, 0x63, 0x35, 0x62, 0x61, 0x34, 0x66, 0x30, 0x36, 0x31, 0x35, 0x32, 0x32, 0x39, 0x64, 0x37, 0x35, 0x32, 0x35, 0x66, 0x61, 0x31, 0x31, 0x33, 0x62, 0x37, 0x65, 0x61, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x33, 0x39, 0x33, 0x33, 0x33, 0x30, 0x34, 0x36, 0x64, 0x65, 0x62, 0x31, 0x65, 0x66, 0x33, 0x63, 0x34, 0x64, 0x61, 0x66, 0x35, 0x30, 0x36, 0x31, 0x39, 0x39, 0x39, 0x33, 0x66, 0x34, 0x34, 0x34, 0x65, 0x31, 0x64, 0x65, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x35, 0x32, 0x64, 0x31, 0x34, 0x66, 0x35, 0x65, 0x31, 0x30, 0x39, 0x33, 0x66, 0x30, 0x37, 0x31, 0x37, 0x31, 0x31, 0x63, 0x31, 0x61, 0x64, 0x62, 0x63, 0x34, 0x65, 0x33, 0x65, 0x62, 0x31, 0x65, 0x35, 0x63, 0x35, 0x37, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x36, 0x34, 0x31, 0x65, 0x30, 0x36, 0x33, 0x36, 0x38, 0x66, 0x62, 0x30, 0x65, 0x66, 0x61, 0x61, 0x31, 0x37, 0x30, 0x33, 0x65, 0x30, 0x31, 0x66, 0x65, 0x34, 0x38, 0x66, 0x34, 0x61, 0x36, 0x38, 0x35, 0x33, 0x30, 0x39, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x65, 0x65, 0x34, 0x64, 0x30, 0x32, 0x63, 0x66, 0x32, 0x34, 0x33, 0x38, 0x32, 0x63, 0x33, 0x30, 0x39, 0x30, 0x64, 0x33, 0x65, 0x39, 0x39, 0x35, 0x36, 0x30, 0x64, 0x65, 0x33, 0x36, 0x37, 0x38, 0x37, 0x33, 0x35, 0x63, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x65, 0x32, 0x35, 0x64, 0x66, 0x38, 0x38, 0x32, 0x32, 0x35, 0x33, 0x38, 0x61, 0x38, 0x35, 0x39, 0x36, 0x62, 0x32, 0x38, 0x63, 0x36, 0x33, 0x37, 0x38, 0x39, 0x36, 0x62, 0x34, 0x64, 0x31, 0x34, 0x33, 0x63, 0x33, 0x35, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x39, 0x37, 0x30, 0x36, 0x63, 0x33, 0x33, 0x32, 0x64, 0x32, 0x30, 0x37, 0x37, 0x39, 0x63, 0x34, 0x35, 0x66, 0x38, 0x61, 0x36, 0x64, 0x30, 0x34, 0x36, 0x61, 0x36, 0x39, 0x39, 0x31, 0x35, 0x39, 0x62, 0x37, 0x34, 0x39, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x30, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x34, 0x64, 0x61, 0x37, 0x38, 0x64, 0x63, 0x65, 0x30, 0x35, 0x61, 0x65, 0x62, 0x38, 0x37, 0x64, 0x65, 0x39, 0x61, 0x65, 0x61, 0x64, 0x39, 0x31, 0x38, 0x35, 0x37, 0x32, 0x36, 0x64, 0x61, 0x31, 0x39, 0x32, 0x36, 0x37, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x34, 0x31, 0x34, 0x34, 0x35, 0x61, 0x33, 0x33, 0x62, 0x61, 0x31, 0x35, 0x38, 0x37, 0x34, 0x31, 0x31, 0x36, 0x30, 0x64, 0x39, 0x63, 0x33, 0x34, 0x34, 0x65, 0x62, 0x38, 0x38, 0x65, 0x35, 0x63, 0x33, 0x30, 0x36, 0x66, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x64, 0x34, 0x33, 0x31, 0x31, 0x63, 0x39, 0x63, 0x31, 0x62, 0x62, 0x61, 0x66, 0x38, 0x37, 0x66, 0x61, 0x62, 0x65, 0x31, 0x61, 0x31, 0x64, 0x30, 0x31, 0x34, 0x36, 0x33, 0x38, 0x32, 0x38, 0x64, 0x35, 0x64, 0x39, 0x38, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x64, 0x33, 0x65, 0x35, 0x39, 0x66, 0x32, 0x33, 0x39, 0x66, 0x61, 0x66, 0x65, 0x34, 0x37, 0x37, 0x36, 0x62, 0x62, 0x39, 0x62, 0x64, 0x64, 0x64, 0x36, 0x62, 0x65, 0x65, 0x38, 0x33, 0x62, 0x61, 0x35, 0x64, 0x39, 0x64, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x65, 0x61, 0x61, 0x65, 0x38, 0x32, 0x37, 0x36, 0x31, 0x37, 0x36, 0x32, 0x66, 0x34, 0x64, 0x32, 0x64, 0x62, 0x35, 0x33, 0x61, 0x39, 0x63, 0x36, 0x38, 0x62, 0x30, 0x66, 0x36, 0x62, 0x30, 0x62, 0x36, 0x64, 0x34, 0x65, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x37, 0x64, 0x33, 0x33, 0x39, 0x33, 0x37, 0x31, 0x65, 0x35, 0x62, 0x65, 0x36, 0x37, 0x32, 0x37, 0x65, 0x36, 0x65, 0x33, 0x33, 0x31, 0x62, 0x35, 0x38, 0x32, 0x31, 0x66, 0x61, 0x32, 0x34, 0x62, 0x64, 0x62, 0x39, 0x64, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x37, 0x37, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x31, 0x34, 0x63, 0x66, 0x61, 0x34, 0x66, 0x34, 0x36, 0x62, 0x64, 0x36, 0x62, 0x64, 0x37, 0x30, 0x37, 0x33, 0x37, 0x64, 0x37, 0x35, 0x38, 0x37, 0x38, 0x31, 0x39, 0x37, 0x65, 0x30, 0x38, 0x66, 0x38, 0x38, 0x65, 0x36, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x37, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x39, 0x32, 0x63, 0x61, 0x30, 0x36, 0x36, 0x65, 0x64, 0x62, 0x37, 0x63, 0x37, 0x31, 0x31, 0x64, 0x66, 0x63, 0x35, 0x62, 0x31, 0x36, 0x36, 0x31, 0x39, 0x32, 0x64, 0x31, 0x65, 0x64, 0x66, 0x38, 0x65, 0x37, 0x37, 0x31, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x37, 0x62, 0x35, 0x36, 0x65, 0x62, 0x64, 0x35, 0x62, 0x37, 0x37, 0x61, 0x62, 0x63, 0x39, 0x66, 0x62, 0x61, 0x63, 0x62, 0x61, 0x62, 0x64, 0x34, 0x39, 0x34, 0x62, 0x39, 0x64, 0x32, 0x63, 0x32, 0x32, 0x31, 0x63, 0x64, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x31, 0x62, 0x65, 0x66, 0x33, 0x31, 0x37, 0x31, 0x64, 0x31, 0x63, 0x35, 0x39, 0x35, 0x37, 0x37, 0x31, 0x37, 0x61, 0x34, 0x65, 0x39, 0x38, 0x64, 0x31, 0x37, 0x65, 0x62, 0x31, 0x34, 0x32, 0x63, 0x32, 0x31, 0x34, 0x65, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x39, 0x62, 0x33, 0x63, 0x32, 0x34, 0x39, 0x66, 0x30, 0x63, 0x34, 0x62, 0x38, 0x31, 0x64, 0x66, 0x37, 0x35, 0x64, 0x32, 0x31, 0x32, 0x30, 0x30, 0x34, 0x64, 0x33, 0x64, 0x36, 0x64, 0x39, 0x35, 0x32, 0x66, 0x64, 0x32, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x31, 0x39, 0x64, 0x32, 0x65, 0x63, 0x65, 0x31, 0x32, 0x32, 0x65, 0x30, 0x32, 0x38, 0x63, 0x38, 0x65, 0x38, 0x61, 0x30, 0x34, 0x61, 0x30, 0x36, 0x34, 0x64, 0x30, 0x32, 0x62, 0x39, 0x30, 0x32, 0x39, 0x62, 0x30, 0x38, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x34, 0x31, 0x36, 0x34, 0x32, 0x64, 0x34, 0x30, 0x64, 0x32, 0x61, 0x66, 0x63, 0x65, 0x32, 0x65, 0x39, 0x31, 0x30, 0x37, 0x63, 0x36, 0x37, 0x30, 0x37, 0x39, 0x61, 0x63, 0x37, 0x61, 0x32, 0x36, 0x36, 0x30, 0x30, 0x38, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x32, 0x39, 0x31, 0x38, 0x38, 0x66, 0x30, 0x38, 0x30, 0x36, 0x35, 0x37, 0x61, 0x62, 0x33, 0x61, 0x32, 0x61, 0x66, 0x61, 0x35, 0x32, 0x32, 0x34, 0x36, 0x37, 0x31, 0x37, 0x38, 0x32, 0x37, 0x39, 0x38, 0x33, 0x32, 0x30, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x33, 0x31, 0x37, 0x38, 0x32, 0x36, 0x64, 0x31, 0x66, 0x37, 0x30, 0x61, 0x61, 0x34, 0x62, 0x64, 0x64, 0x66, 0x61, 0x30, 0x39, 0x62, 0x65, 0x30, 0x63, 0x34, 0x31, 0x30, 0x35, 0x35, 0x35, 0x32, 0x64, 0x32, 0x33, 0x35, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x63, 0x39, 0x64, 0x63, 0x37, 0x61, 0x34, 0x33, 0x36, 0x61, 0x65, 0x39, 0x38, 0x66, 0x64, 0x30, 0x31, 0x63, 0x37, 0x61, 0x39, 0x36, 0x32, 0x31, 0x61, 0x61, 0x38, 0x65, 0x39, 0x64, 0x30, 0x62, 0x38, 0x62, 0x35, 0x33, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x63, 0x38, 0x38, 0x65, 0x32, 0x64, 0x38, 0x38, 0x36, 0x32, 0x31, 0x65, 0x33, 0x30, 0x66, 0x35, 0x38, 0x61, 0x39, 0x35, 0x38, 0x36, 0x62, 0x65, 0x64, 0x34, 0x30, 0x39, 0x38, 0x39, 0x39, 0x39, 0x65, 0x62, 0x36, 0x37, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x31, 0x65, 0x36, 0x36, 0x65, 0x64, 0x35, 0x33, 0x39, 0x64, 0x64, 0x39, 0x32, 0x66, 0x63, 0x34, 0x30, 0x62, 0x62, 0x61, 0x61, 0x31, 0x66, 0x61, 0x31, 0x36, 0x64, 0x65, 0x38, 0x63, 0x30, 0x32, 0x63, 0x31, 0x34, 0x64, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x63, 0x38, 0x31, 0x66, 0x66, 0x63, 0x65, 0x63, 0x62, 0x34, 0x37, 0x65, 0x63, 0x64, 0x63, 0x35, 0x35, 0x63, 0x30, 0x62, 0x37, 0x31, 0x65, 0x34, 0x38, 0x35, 0x35, 0x66, 0x33, 0x65, 0x35, 0x65, 0x39, 0x37, 0x66, 0x63, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x66, 0x38, 0x66, 0x61, 0x34, 0x62, 0x62, 0x39, 0x65, 0x32, 0x36, 0x37, 0x37, 0x63, 0x39, 0x39, 0x30, 0x61, 0x34, 0x65, 0x65, 0x38, 0x63, 0x65, 0x37, 0x30, 0x64, 0x64, 0x31, 0x35, 0x32, 0x33, 0x32, 0x35, 0x31, 0x65, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x36, 0x34, 0x61, 0x38, 0x35, 0x65, 0x38, 0x65, 0x39, 0x61, 0x34, 0x30, 0x34, 0x39, 0x38, 0x63, 0x30, 0x63, 0x37, 0x35, 0x66, 0x63, 0x65, 0x62, 0x30, 0x33, 0x33, 0x37, 0x66, 0x62, 0x34, 0x39, 0x30, 0x38, 0x33, 0x65, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x32, 0x39, 0x34, 0x33, 0x37, 0x63, 0x39, 0x37, 0x62, 0x34, 0x61, 0x38, 0x34, 0x34, 0x62, 0x65, 0x37, 0x31, 0x63, 0x63, 0x61, 0x33, 0x62, 0x36, 0x34, 0x38, 0x64, 0x34, 0x63, 0x61, 0x30, 0x66, 0x64, 0x64, 0x39, 0x62, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x65, 0x65, 0x36, 0x63, 0x62, 0x65, 0x65, 0x34, 0x66, 0x65, 0x39, 0x36, 0x61, 0x64, 0x36, 0x31, 0x35, 0x61, 0x39, 0x63, 0x66, 0x35, 0x38, 0x35, 0x37, 0x61, 0x36, 0x34, 0x37, 0x39, 0x34, 0x30, 0x64, 0x66, 0x38, 0x63, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x66, 0x30, 0x65, 0x64, 0x63, 0x36, 0x30, 0x33, 0x33, 0x38, 0x65, 0x37, 0x31, 0x31, 0x32, 0x30, 0x38, 0x35, 0x61, 0x31, 0x64, 0x31, 0x31, 0x34, 0x64, 0x61, 0x38, 0x63, 0x34, 0x32, 0x63, 0x65, 0x38, 0x66, 0x35, 0x35, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x62, 0x31, 0x63, 0x34, 0x39, 0x31, 0x37, 0x66, 0x62, 0x64, 0x39, 0x33, 0x65, 0x65, 0x33, 0x64, 0x34, 0x38, 0x33, 0x38, 0x39, 0x33, 0x30, 0x36, 0x39, 0x35, 0x37, 0x33, 0x38, 0x34, 0x61, 0x35, 0x34, 0x39, 0x36, 0x63, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x36, 0x37, 0x35, 0x32, 0x35, 0x63, 0x35, 0x66, 0x35, 0x61, 0x32, 0x32, 0x65, 0x64, 0x38, 0x30, 0x65, 0x39, 0x64, 0x34, 0x64, 0x37, 0x37, 0x31, 0x30, 0x66, 0x30, 0x33, 0x36, 0x32, 0x64, 0x32, 0x39, 0x65, 0x66, 0x61, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x36, 0x34, 0x38, 0x39, 0x39, 0x61, 0x39, 0x36, 0x33, 0x63, 0x34, 0x37, 0x37, 0x39, 0x63, 0x62, 0x66, 0x36, 0x31, 0x33, 0x63, 0x64, 0x36, 0x39, 0x38, 0x30, 0x38, 0x34, 0x36, 0x61, 0x66, 0x31, 0x65, 0x36, 0x65, 0x63, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x39, 0x39, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x35, 0x33, 0x31, 0x66, 0x34, 0x64, 0x64, 0x61, 0x38, 0x30, 0x38, 0x66, 0x35, 0x33, 0x32, 0x30, 0x37, 0x36, 0x37, 0x61, 0x30, 0x33, 0x31, 0x31, 0x33, 0x34, 0x32, 0x38, 0x63, 0x61, 0x30, 0x63, 0x65, 0x32, 0x66, 0x33, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x62, 0x39, 0x61, 0x63, 0x39, 0x61, 0x39, 0x65, 0x61, 0x65, 0x65, 0x63, 0x30, 0x61, 0x35, 0x32, 0x33, 0x37, 0x35, 0x37, 0x30, 0x35, 0x30, 0x63, 0x37, 0x31, 0x66, 0x34, 0x37, 0x32, 0x37, 0x38, 0x63, 0x37, 0x32, 0x64, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x39, 0x32, 0x63, 0x36, 0x39, 0x64, 0x30, 0x36, 0x37, 0x62, 0x35, 0x31, 0x62, 0x36, 0x63, 0x63, 0x36, 0x33, 0x39, 0x64, 0x31, 0x31, 0x36, 0x34, 0x64, 0x35, 0x35, 0x37, 0x38, 0x63, 0x36, 0x30, 0x64, 0x32, 0x64, 0x32, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x33, 0x66, 0x62, 0x66, 0x61, 0x31, 0x66, 0x64, 0x33, 0x32, 0x64, 0x37, 0x61, 0x36, 0x65, 0x30, 0x65, 0x36, 0x66, 0x38, 0x65, 0x66, 0x34, 0x65, 0x61, 0x62, 0x35, 0x37, 0x62, 0x65, 0x33, 0x34, 0x30, 0x32, 0x35, 0x63, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x66, 0x65, 0x63, 0x30, 0x35, 0x38, 0x63, 0x63, 0x35, 0x34, 0x36, 0x31, 0x35, 0x37, 0x37, 0x36, 0x36, 0x61, 0x36, 0x33, 0x32, 0x37, 0x37, 0x35, 0x34, 0x30, 0x34, 0x61, 0x33, 0x33, 0x34, 0x61, 0x61, 0x61, 0x64, 0x61, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x66, 0x35, 0x66, 0x30, 0x62, 0x37, 0x62, 0x36, 0x64, 0x35, 0x35, 0x38, 0x66, 0x35, 0x30, 0x39, 0x30, 0x64, 0x39, 0x65, 0x61, 0x31, 0x66, 0x62, 0x32, 0x64, 0x34, 0x32, 0x32, 0x35, 0x39, 0x63, 0x35, 0x38, 0x36, 0x30, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x65, 0x63, 0x66, 0x32, 0x61, 0x62, 0x66, 0x34, 0x30, 0x63, 0x39, 0x65, 0x38, 0x35, 0x37, 0x62, 0x32, 0x35, 0x32, 0x66, 0x65, 0x31, 0x64, 0x62, 0x66, 0x64, 0x33, 0x64, 0x34, 0x63, 0x35, 0x64, 0x38, 0x66, 0x38, 0x31, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x38, 0x61, 0x32, 0x36, 0x36, 0x38, 0x39, 0x66, 0x37, 0x61, 0x32, 0x66, 0x64, 0x65, 0x66, 0x64, 0x30, 0x30, 0x39, 0x63, 0x62, 0x61, 0x61, 0x61, 0x35, 0x33, 0x31, 0x30, 0x32, 0x35, 0x33, 0x34, 0x35, 0x30, 0x64, 0x61, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x39, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x66, 0x34, 0x30, 0x64, 0x33, 0x35, 0x38, 0x66, 0x35, 0x65, 0x33, 0x66, 0x65, 0x37, 0x34, 0x36, 0x33, 0x65, 0x63, 0x37, 0x30, 0x34, 0x38, 0x30, 0x62, 0x64, 0x32, 0x65, 0x64, 0x33, 0x39, 0x38, 0x61, 0x37, 0x30, 0x36, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x31, 0x39, 0x64, 0x36, 0x66, 0x37, 0x61, 0x35, 0x30, 0x66, 0x34, 0x66, 0x30, 0x37, 0x39, 0x38, 0x39, 0x33, 0x64, 0x31, 0x36, 0x37, 0x62, 0x66, 0x31, 0x34, 0x65, 0x32, 0x31, 0x64, 0x30, 0x30, 0x37, 0x33, 0x64, 0x31, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x32, 0x63, 0x61, 0x30, 0x64, 0x32, 0x33, 0x34, 0x62, 0x61, 0x66, 0x36, 0x30, 0x37, 0x61, 0x64, 0x34, 0x36, 0x36, 0x61, 0x31, 0x62, 0x38, 0x35, 0x66, 0x34, 0x61, 0x36, 0x34, 0x38, 0x38, 0x65, 0x66, 0x30, 0x30, 0x61, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x61, 0x34, 0x39, 0x63, 0x61, 0x32, 0x33, 0x39, 0x30, 0x63, 0x31, 0x66, 0x36, 0x64, 0x35, 0x63, 0x30, 0x65, 0x36, 0x32, 0x35, 0x31, 0x33, 0x62, 0x30, 0x37, 0x39, 0x35, 0x37, 0x31, 0x37, 0x34, 0x33, 0x66, 0x37, 0x63, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x33, 0x66, 0x33, 0x62, 0x31, 0x66, 0x37, 0x31, 0x33, 0x30, 0x62, 0x30, 0x62, 0x62, 0x32, 0x31, 0x61, 0x30, 0x66, 0x64, 0x33, 0x32, 0x33, 0x39, 0x36, 0x32, 0x33, 0x39, 0x31, 0x37, 0x39, 0x61, 0x32, 0x35, 0x36, 0x35, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x33, 0x32, 0x63, 0x30, 0x66, 0x33, 0x65, 0x30, 0x35, 0x61, 0x32, 0x37, 0x64, 0x39, 0x31, 0x32, 0x36, 0x66, 0x64, 0x30, 0x62, 0x36, 0x34, 0x31, 0x61, 0x38, 0x63, 0x32, 0x64, 0x34, 0x30, 0x36, 0x30, 0x36, 0x30, 0x38, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x31, 0x30, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x30, 0x34, 0x61, 0x33, 0x32, 0x66, 0x30, 0x35, 0x61, 0x38, 0x33, 0x37, 0x36, 0x32, 0x37, 0x34, 0x34, 0x61, 0x39, 0x35, 0x34, 0x32, 0x39, 0x37, 0x36, 0x66, 0x66, 0x39, 0x62, 0x37, 0x32, 0x33, 0x66, 0x61, 0x33, 0x31, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x37, 0x36, 0x32, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x36, 0x38, 0x66, 0x33, 0x32, 0x31, 0x66, 0x64, 0x36, 0x34, 0x33, 0x33, 0x64, 0x39, 0x36, 0x62, 0x34, 0x66, 0x33, 0x35, 0x34, 0x64, 0x33, 0x63, 0x63, 0x31, 0x36, 0x35, 0x32, 0x63, 0x31, 0x37, 0x33, 0x32, 0x66, 0x35, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x37, 0x61, 0x66, 0x34, 0x36, 0x61, 0x65, 0x39, 0x63, 0x63, 0x64, 0x31, 0x38, 0x62, 0x62, 0x33, 0x35, 0x63, 0x61, 0x30, 0x31, 0x62, 0x33, 0x35, 0x33, 0x62, 0x35, 0x31, 0x39, 0x39, 0x30, 0x65, 0x34, 0x39, 0x64, 0x63, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x65, 0x61, 0x65, 0x36, 0x66, 0x65, 0x66, 0x66, 0x61, 0x39, 0x66, 0x62, 0x66, 0x34, 0x63, 0x64, 0x38, 0x37, 0x34, 0x66, 0x34, 0x37, 0x33, 0x39, 0x61, 0x63, 0x65, 0x35, 0x33, 0x30, 0x63, 0x63, 0x62, 0x65, 0x35, 0x39, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x39, 0x34, 0x66, 0x62, 0x33, 0x32, 0x33, 0x31, 0x64, 0x37, 0x65, 0x34, 0x31, 0x64, 0x34, 0x39, 0x31, 0x61, 0x39, 0x64, 0x36, 0x38, 0x64, 0x31, 0x66, 0x61, 0x34, 0x63, 0x61, 0x65, 0x32, 0x63, 0x63, 0x31, 0x35, 0x39, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x31, 0x32, 0x36, 0x34, 0x34, 0x36, 0x61, 0x62, 0x33, 0x64, 0x38, 0x30, 0x33, 0x32, 0x35, 0x35, 0x37, 0x65, 0x38, 0x65, 0x62, 0x61, 0x36, 0x35, 0x35, 0x39, 0x37, 0x64, 0x37, 0x35, 0x66, 0x61, 0x64, 0x63, 0x38, 0x31, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x64, 0x61, 0x61, 0x61, 0x64, 0x64, 0x66, 0x37, 0x62, 0x30, 0x36, 0x62, 0x62, 0x63, 0x65, 0x61, 0x39, 0x62, 0x38, 0x30, 0x35, 0x39, 0x30, 0x30, 0x38, 0x35, 0x61, 0x38, 0x38, 0x35, 0x36, 0x37, 0x36, 0x38, 0x32, 0x62, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x39, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x30, 0x32, 0x30, 0x66, 0x38, 0x65, 0x64, 0x66, 0x63, 0x66, 0x35, 0x32, 0x34, 0x37, 0x39, 0x38, 0x61, 0x39, 0x62, 0x37, 0x33, 0x61, 0x36, 0x34, 0x30, 0x33, 0x33, 0x34, 0x62, 0x62, 0x66, 0x37, 0x32, 0x66, 0x38, 0x30, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x66, 0x65, 0x62, 0x66, 0x39, 0x65, 0x31, 0x30, 0x30, 0x33, 0x61, 0x66, 0x31, 0x35, 0x62, 0x31, 0x62, 0x64, 0x34, 0x39, 0x30, 0x37, 0x65, 0x63, 0x30, 0x38, 0x39, 0x61, 0x34, 0x61, 0x31, 0x62, 0x39, 0x31, 0x64, 0x32, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x37, 0x39, 0x63, 0x38, 0x36, 0x33, 0x63, 0x33, 0x64, 0x33, 0x37, 0x32, 0x62, 0x33, 0x66, 0x66, 0x30, 0x63, 0x36, 0x66, 0x34, 0x35, 0x32, 0x37, 0x33, 0x34, 0x61, 0x37, 0x66, 0x39, 0x37, 0x30, 0x34, 0x32, 0x64, 0x37, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x32, 0x30, 0x33, 0x65, 0x62, 0x33, 0x61, 0x37, 0x32, 0x33, 0x65, 0x39, 0x39, 0x63, 0x32, 0x32, 0x32, 0x30, 0x31, 0x31, 0x37, 0x63, 0x61, 0x36, 0x61, 0x66, 0x65, 0x62, 0x36, 0x36, 0x66, 0x61, 0x34, 0x32, 0x34, 0x66, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x36, 0x31, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x66, 0x62, 0x30, 0x39, 0x31, 0x38, 0x38, 0x66, 0x32, 0x37, 0x66, 0x31, 0x30, 0x33, 0x38, 0x65, 0x36, 0x35, 0x34, 0x30, 0x33, 0x31, 0x39, 0x32, 0x34, 0x66, 0x36, 0x32, 0x38, 0x61, 0x32, 0x31, 0x30, 0x36, 0x37, 0x30, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x62, 0x61, 0x30, 0x63, 0x36, 0x65, 0x65, 0x35, 0x61, 0x31, 0x31, 0x34, 0x35, 0x63, 0x31, 0x63, 0x35, 0x37, 0x33, 0x39, 0x38, 0x34, 0x39, 0x36, 0x33, 0x61, 0x36, 0x30, 0x35, 0x64, 0x38, 0x38, 0x30, 0x61, 0x37, 0x61, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x65, 0x66, 0x62, 0x65, 0x32, 0x33, 0x39, 0x38, 0x65, 0x34, 0x37, 0x64, 0x35, 0x32, 0x65, 0x37, 0x38, 0x64, 0x62, 0x34, 0x33, 0x33, 0x34, 0x63, 0x38, 0x62, 0x36, 0x39, 0x37, 0x36, 0x37, 0x35, 0x66, 0x31, 0x39, 0x33, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x32, 0x34, 0x37, 0x31, 0x65, 0x33, 0x66, 0x63, 0x32, 0x65, 0x61, 0x30, 0x35, 0x33, 0x32, 0x36, 0x31, 0x35, 0x61, 0x37, 0x35, 0x37, 0x31, 0x64, 0x34, 0x39, 0x33, 0x32, 0x38, 0x39, 0x63, 0x31, 0x33, 0x63, 0x33, 0x36, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x34, 0x36, 0x39, 0x61, 0x61, 0x35, 0x63, 0x33, 0x38, 0x36, 0x62, 0x31, 0x39, 0x32, 0x39, 0x35, 0x64, 0x34, 0x61, 0x31, 0x62, 0x35, 0x34, 0x37, 0x33, 0x62, 0x35, 0x34, 0x30, 0x33, 0x35, 0x33, 0x33, 0x39, 0x30, 0x63, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x31, 0x31, 0x36, 0x37, 0x33, 0x63, 0x63, 0x30, 0x31, 0x39, 0x36, 0x32, 0x36, 0x62, 0x32, 0x39, 0x30, 0x63, 0x62, 0x64, 0x63, 0x65, 0x32, 0x36, 0x30, 0x34, 0x36, 0x66, 0x37, 0x65, 0x36, 0x64, 0x31, 0x34, 0x31, 0x65, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x37, 0x38, 0x34, 0x61, 0x64, 0x65, 0x39, 0x31, 0x63, 0x38, 0x61, 0x38, 0x33, 0x61, 0x38, 0x65, 0x33, 0x39, 0x36, 0x35, 0x38, 0x63, 0x38, 0x64, 0x38, 0x32, 0x37, 0x37, 0x34, 0x31, 0x33, 0x63, 0x63, 0x63, 0x39, 0x39, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x64, 0x33, 0x64, 0x66, 0x38, 0x30, 0x34, 0x66, 0x32, 0x62, 0x65, 0x65, 0x65, 0x36, 0x65, 0x66, 0x35, 0x33, 0x61, 0x62, 0x39, 0x34, 0x63, 0x62, 0x33, 0x65, 0x65, 0x39, 0x63, 0x66, 0x35, 0x32, 0x34, 0x61, 0x31, 0x38, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x33, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x61, 0x65, 0x30, 0x64, 0x33, 0x64, 0x38, 0x35, 0x32, 0x61, 0x37, 0x64, 0x61, 0x33, 0x38, 0x36, 0x30, 0x66, 0x30, 0x36, 0x33, 0x36, 0x31, 0x35, 0x34, 0x63, 0x30, 0x61, 0x36, 0x63, 0x61, 0x33, 0x31, 0x36, 0x32, 0x38, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x65, 0x33, 0x61, 0x31, 0x66, 0x63, 0x36, 0x65, 0x32, 0x34, 0x63, 0x38, 0x66, 0x37, 0x62, 0x33, 0x32, 0x35, 0x30, 0x35, 0x36, 0x30, 0x39, 0x39, 0x31, 0x66, 0x39, 0x33, 0x63, 0x62, 0x61, 0x32, 0x63, 0x66, 0x38, 0x30, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x34, 0x63, 0x65, 0x38, 0x35, 0x38, 0x38, 0x35, 0x37, 0x65, 0x63, 0x35, 0x34, 0x38, 0x31, 0x63, 0x38, 0x36, 0x62, 0x64, 0x39, 0x30, 0x36, 0x65, 0x38, 0x33, 0x61, 0x30, 0x34, 0x38, 0x38, 0x32, 0x65, 0x35, 0x38, 0x32, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x33, 0x37, 0x63, 0x66, 0x36, 0x62, 0x34, 0x66, 0x38, 0x31, 0x61, 0x39, 0x65, 0x32, 0x32, 0x32, 0x66, 0x62, 0x61, 0x32, 0x32, 0x65, 0x39, 0x62, 0x64, 0x32, 0x34, 0x62, 0x35, 0x30, 0x39, 0x38, 0x62, 0x37, 0x33, 0x33, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x32, 0x32, 0x61, 0x38, 0x30, 0x64, 0x35, 0x63, 0x37, 0x62, 0x33, 0x33, 0x37, 0x34, 0x61, 0x30, 0x35, 0x62, 0x34, 0x34, 0x36, 0x30, 0x38, 0x31, 0x66, 0x39, 0x37, 0x64, 0x30, 0x61, 0x33, 0x34, 0x30, 0x37, 0x39, 0x65, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x32, 0x39, 0x61, 0x38, 0x61, 0x34, 0x64, 0x35, 0x66, 0x64, 0x39, 0x35, 0x30, 0x30, 0x37, 0x35, 0x66, 0x66, 0x62, 0x33, 0x34, 0x64, 0x37, 0x37, 0x61, 0x66, 0x65, 0x62, 0x32, 0x64, 0x38, 0x32, 0x33, 0x62, 0x64, 0x36, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x31, 0x61, 0x66, 0x39, 0x31, 0x33, 0x34, 0x66, 0x61, 0x66, 0x35, 0x32, 0x35, 0x37, 0x31, 0x37, 0x34, 0x65, 0x38, 0x62, 0x37, 0x39, 0x31, 0x38, 0x36, 0x66, 0x34, 0x32, 0x65, 0x65, 0x33, 0x35, 0x34, 0x65, 0x36, 0x34, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x31, 0x36, 0x31, 0x39, 0x39, 0x38, 0x38, 0x66, 0x33, 0x37, 0x31, 0x35, 0x65, 0x39, 0x34, 0x66, 0x66, 0x31, 0x64, 0x32, 0x35, 0x33, 0x32, 0x36, 0x32, 0x64, 0x63, 0x35, 0x35, 0x38, 0x31, 0x64, 0x62, 0x33, 0x64, 0x65, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x31, 0x33, 0x37, 0x61, 0x37, 0x31, 0x61, 0x36, 0x66, 0x31, 0x39, 0x37, 0x64, 0x66, 0x32, 0x63, 0x62, 0x62, 0x66, 0x30, 0x31, 0x30, 0x64, 0x63, 0x62, 0x64, 0x33, 0x63, 0x34, 0x34, 0x34, 0x65, 0x66, 0x35, 0x63, 0x39, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x65, 0x66, 0x62, 0x38, 0x61, 0x32, 0x30, 0x34, 0x35, 0x31, 0x31, 0x36, 0x31, 0x62, 0x36, 0x34, 0x34, 0x61, 0x38, 0x63, 0x63, 0x65, 0x62, 0x62, 0x63, 0x31, 0x64, 0x33, 0x34, 0x33, 0x61, 0x33, 0x62, 0x62, 0x63, 0x62, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x35, 0x30, 0x34, 0x65, 0x36, 0x61, 0x32, 0x31, 0x35, 0x61, 0x63, 0x38, 0x33, 0x62, 0x63, 0x63, 0x66, 0x39, 0x35, 0x36, 0x62, 0x65, 0x66, 0x63, 0x38, 0x32, 0x61, 0x62, 0x35, 0x61, 0x36, 0x37, 0x39, 0x33, 0x37, 0x31, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x38, 0x38, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x32, 0x33, 0x66, 0x66, 0x66, 0x39, 0x37, 0x34, 0x39, 0x38, 0x37, 0x31, 0x62, 0x33, 0x35, 0x33, 0x38, 0x38, 0x34, 0x33, 0x38, 0x38, 0x33, 0x37, 0x66, 0x37, 0x65, 0x36, 0x65, 0x30, 0x64, 0x65, 0x61, 0x39, 0x63, 0x62, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x63, 0x36, 0x61, 0x34, 0x39, 0x39, 0x38, 0x61, 0x33, 0x33, 0x66, 0x65, 0x62, 0x37, 0x36, 0x34, 0x34, 0x33, 0x37, 0x61, 0x38, 0x62, 0x65, 0x39, 0x32, 0x39, 0x61, 0x37, 0x33, 0x62, 0x61, 0x33, 0x34, 0x61, 0x30, 0x37, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x64, 0x37, 0x66, 0x37, 0x63, 0x37, 0x63, 0x32, 0x33, 0x35, 0x33, 0x37, 0x38, 0x30, 0x63, 0x64, 0x65, 0x30, 0x38, 0x31, 0x65, 0x65, 0x65, 0x63, 0x34, 0x35, 0x38, 0x32, 0x32, 0x62, 0x32, 0x35, 0x66, 0x32, 0x38, 0x36, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x30, 0x35, 0x30, 0x62, 0x65, 0x66, 0x66, 0x39, 0x64, 0x65, 0x33, 0x33, 0x63, 0x38, 0x30, 0x65, 0x31, 0x66, 0x61, 0x31, 0x35, 0x32, 0x32, 0x35, 0x65, 0x32, 0x38, 0x66, 0x32, 0x63, 0x34, 0x31, 0x33, 0x61, 0x65, 0x33, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x32, 0x36, 0x38, 0x31, 0x37, 0x31, 0x62, 0x38, 0x33, 0x33, 0x65, 0x30, 0x61, 0x61, 0x31, 0x33, 0x63, 0x35, 0x34, 0x62, 0x35, 0x32, 0x63, 0x63, 0x63, 0x30, 0x34, 0x32, 0x32, 0x65, 0x34, 0x66, 0x61, 0x30, 0x33, 0x61, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x36, 0x39, 0x37, 0x32, 0x34, 0x65, 0x65, 0x37, 0x32, 0x32, 0x37, 0x31, 0x63, 0x35, 0x33, 0x34, 0x63, 0x61, 0x64, 0x36, 0x34, 0x32, 0x30, 0x66, 0x62, 0x30, 0x34, 0x65, 0x65, 0x36, 0x34, 0x34, 0x63, 0x62, 0x38, 0x36, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x30, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x36, 0x64, 0x35, 0x62, 0x62, 0x62, 0x62, 0x39, 0x30, 0x35, 0x33, 0x62, 0x38, 0x39, 0x64, 0x37, 0x34, 0x34, 0x61, 0x32, 0x37, 0x33, 0x31, 0x36, 0x63, 0x32, 0x61, 0x37, 0x62, 0x38, 0x63, 0x30, 0x39, 0x62, 0x35, 0x34, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x39, 0x38, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x33, 0x66, 0x34, 0x36, 0x62, 0x37, 0x35, 0x63, 0x61, 0x62, 0x65, 0x33, 0x37, 0x62, 0x66, 0x61, 0x63, 0x63, 0x38, 0x37, 0x36, 0x30, 0x32, 0x38, 0x31, 0x66, 0x34, 0x33, 0x34, 0x31, 0x63, 0x61, 0x37, 0x66, 0x34, 0x36, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x32, 0x37, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x33, 0x33, 0x38, 0x33, 0x34, 0x65, 0x38, 0x35, 0x38, 0x33, 0x37, 0x33, 0x33, 0x65, 0x32, 0x64, 0x35, 0x32, 0x61, 0x65, 0x61, 0x64, 0x35, 0x38, 0x39, 0x62, 0x64, 0x31, 0x61, 0x66, 0x66, 0x62, 0x31, 0x64, 0x64, 0x32, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x34, 0x64, 0x65, 0x64, 0x39, 0x39, 0x64, 0x63, 0x62, 0x35, 0x37, 0x32, 0x62, 0x39, 0x62, 0x62, 0x31, 0x64, 0x63, 0x62, 0x61, 0x33, 0x32, 0x66, 0x36, 0x64, 0x65, 0x65, 0x39, 0x31, 0x65, 0x30, 0x35, 0x37, 0x39, 0x38, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x33, 0x33, 0x36, 0x61, 0x32, 0x33, 0x36, 0x64, 0x65, 0x64, 0x37, 0x35, 0x35, 0x38, 0x37, 0x32, 0x34, 0x31, 0x31, 0x66, 0x32, 0x65, 0x30, 0x34, 0x39, 0x31, 0x64, 0x38, 0x33, 0x65, 0x33, 0x65, 0x30, 0x30, 0x31, 0x35, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x61, 0x63, 0x35, 0x34, 0x35, 0x63, 0x39, 0x39, 0x31, 0x32, 0x34, 0x33, 0x66, 0x61, 0x31, 0x38, 0x61, 0x65, 0x63, 0x34, 0x31, 0x64, 0x34, 0x66, 0x36, 0x66, 0x35, 0x39, 0x38, 0x65, 0x35, 0x35, 0x35, 0x30, 0x31, 0x35, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x65, 0x65, 0x30, 0x35, 0x63, 0x36, 0x39, 0x64, 0x31, 0x66, 0x32, 0x39, 0x65, 0x37, 0x37, 0x31, 0x34, 0x36, 0x38, 0x34, 0x63, 0x38, 0x38, 0x64, 0x65, 0x35, 0x61, 0x31, 0x36, 0x30, 0x39, 0x38, 0x65, 0x39, 0x31, 0x33, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x62, 0x65, 0x36, 0x62, 0x36, 0x34, 0x64, 0x37, 0x63, 0x37, 0x33, 0x33, 0x61, 0x34, 0x33, 0x36, 0x61, 0x64, 0x65, 0x63, 0x35, 0x65, 0x31, 0x34, 0x62, 0x66, 0x39, 0x61, 0x64, 0x37, 0x34, 0x30, 0x32, 0x62, 0x31, 0x62, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x33, 0x62, 0x64, 0x64, 0x64, 0x64, 0x35, 0x64, 0x61, 0x39, 0x34, 0x38, 0x35, 0x32, 0x66, 0x34, 0x61, 0x64, 0x65, 0x38, 0x64, 0x32, 0x31, 0x32, 0x38, 0x38, 0x35, 0x36, 0x38, 0x32, 0x64, 0x39, 0x30, 0x37, 0x36, 0x62, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x32, 0x63, 0x35, 0x37, 0x64, 0x32, 0x66, 0x62, 0x31, 0x39, 0x35, 0x31, 0x30, 0x37, 0x64, 0x34, 0x63, 0x64, 0x35, 0x63, 0x61, 0x33, 0x30, 0x30, 0x37, 0x37, 0x34, 0x31, 0x31, 0x39, 0x64, 0x66, 0x61, 0x64, 0x32, 0x66, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x33, 0x37, 0x62, 0x61, 0x61, 0x34, 0x64, 0x62, 0x63, 0x39, 0x39, 0x32, 0x36, 0x65, 0x33, 0x32, 0x61, 0x33, 0x64, 0x38, 0x35, 0x64, 0x31, 0x32, 0x36, 0x34, 0x34, 0x30, 0x32, 0x64, 0x35, 0x34, 0x64, 0x62, 0x30, 0x31, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x39, 0x31, 0x32, 0x33, 0x37, 0x65, 0x37, 0x34, 0x30, 0x64, 0x32, 0x35, 0x61, 0x39, 0x32, 0x66, 0x37, 0x66, 0x61, 0x31, 0x34, 0x36, 0x66, 0x61, 0x61, 0x31, 0x38, 0x63, 0x65, 0x35, 0x36, 0x64, 0x63, 0x36, 0x65, 0x31, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x33, 0x39, 0x65, 0x39, 0x34, 0x39, 0x32, 0x38, 0x37, 0x30, 0x61, 0x66, 0x65, 0x61, 0x32, 0x35, 0x33, 0x37, 0x66, 0x33, 0x38, 0x39, 0x61, 0x63, 0x32, 0x66, 0x38, 0x33, 0x38, 0x33, 0x30, 0x32, 0x61, 0x33, 0x33, 0x63, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x34, 0x35, 0x35, 0x38, 0x36, 0x65, 0x62, 0x38, 0x30, 0x33, 0x63, 0x61, 0x32, 0x31, 0x39, 0x30, 0x36, 0x35, 0x30, 0x62, 0x66, 0x37, 0x34, 0x38, 0x61, 0x32, 0x62, 0x31, 0x37, 0x34, 0x33, 0x31, 0x32, 0x62, 0x62, 0x35, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x31, 0x34, 0x34, 0x36, 0x62, 0x37, 0x35, 0x34, 0x63, 0x32, 0x34, 0x65, 0x33, 0x62, 0x31, 0x36, 0x34, 0x32, 0x64, 0x39, 0x65, 0x35, 0x31, 0x37, 0x36, 0x35, 0x62, 0x34, 0x64, 0x33, 0x65, 0x34, 0x36, 0x62, 0x33, 0x34, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x32, 0x38, 0x62, 0x35, 0x65, 0x64, 0x65, 0x61, 0x30, 0x35, 0x62, 0x37, 0x36, 0x66, 0x38, 0x63, 0x35, 0x66, 0x39, 0x37, 0x30, 0x38, 0x34, 0x35, 0x34, 0x31, 0x32, 0x37, 0x37, 0x63, 0x39, 0x36, 0x36, 0x39, 0x36, 0x61, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x31, 0x63, 0x39, 0x61, 0x32, 0x36, 0x65, 0x30, 0x65, 0x30, 0x32, 0x34, 0x31, 0x38, 0x61, 0x35, 0x63, 0x66, 0x36, 0x38, 0x37, 0x64, 0x61, 0x37, 0x35, 0x61, 0x32, 0x37, 0x35, 0x63, 0x36, 0x32, 0x32, 0x63, 0x39, 0x34, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x39, 0x33, 0x36, 0x38, 0x36, 0x30, 0x39, 0x30, 0x34, 0x32, 0x61, 0x38, 0x35, 0x38, 0x64, 0x31, 0x65, 0x63, 0x64, 0x66, 0x31, 0x66, 0x63, 0x30, 0x61, 0x64, 0x61, 0x35, 0x65, 0x61, 0x63, 0x65, 0x63, 0x61, 0x32, 0x39, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x66, 0x35, 0x61, 0x35, 0x31, 0x64, 0x30, 0x36, 0x66, 0x36, 0x33, 0x34, 0x30, 0x64, 0x38, 0x30, 0x62, 0x36, 0x64, 0x32, 0x39, 0x65, 0x61, 0x32, 0x65, 0x38, 0x38, 0x31, 0x31, 0x38, 0x61, 0x64, 0x37, 0x33, 0x30, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x31, 0x61, 0x32, 0x63, 0x61, 0x33, 0x34, 0x65, 0x37, 0x31, 0x38, 0x37, 0x63, 0x31, 0x36, 0x33, 0x64, 0x32, 0x38, 0x65, 0x33, 0x36, 0x31, 0x38, 0x64, 0x62, 0x32, 0x38, 0x62, 0x31, 0x33, 0x63, 0x31, 0x39, 0x36, 0x64, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x62, 0x30, 0x65, 0x39, 0x63, 0x39, 0x34, 0x32, 0x61, 0x34, 0x66, 0x30, 0x66, 0x36, 0x66, 0x38, 0x36, 0x64, 0x33, 0x66, 0x39, 0x35, 0x66, 0x66, 0x39, 0x39, 0x38, 0x30, 0x32, 0x32, 0x66, 0x61, 0x36, 0x37, 0x39, 0x36, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x62, 0x33, 0x37, 0x66, 0x30, 0x33, 0x63, 0x62, 0x31, 0x30, 0x37, 0x34, 0x32, 0x34, 0x65, 0x39, 0x63, 0x34, 0x64, 0x64, 0x35, 0x37, 0x35, 0x63, 0x63, 0x64, 0x34, 0x66, 0x34, 0x63, 0x65, 0x65, 0x35, 0x37, 0x65, 0x36, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x39, 0x39, 0x33, 0x64, 0x64, 0x62, 0x37, 0x65, 0x30, 0x32, 0x63, 0x32, 0x38, 0x32, 0x62, 0x38, 0x39, 0x38, 0x66, 0x36, 0x31, 0x35, 0x35, 0x66, 0x36, 0x38, 0x30, 0x65, 0x66, 0x35, 0x62, 0x39, 0x61, 0x66, 0x66, 0x39, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x64, 0x35, 0x38, 0x33, 0x61, 0x37, 0x62, 0x36, 0x35, 0x62, 0x32, 0x33, 0x66, 0x36, 0x30, 0x62, 0x37, 0x39, 0x30, 0x35, 0x66, 0x33, 0x65, 0x34, 0x61, 0x61, 0x36, 0x32, 0x61, 0x61, 0x63, 0x38, 0x37, 0x66, 0x34, 0x32, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x34, 0x36, 0x37, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x36, 0x62, 0x62, 0x35, 0x33, 0x33, 0x62, 0x37, 0x36, 0x65, 0x32, 0x30, 0x63, 0x38, 0x65, 0x65, 0x31, 0x65, 0x62, 0x66, 0x31, 0x32, 0x33, 0x66, 0x31, 0x65, 0x39, 0x66, 0x66, 0x34, 0x31, 0x34, 0x38, 0x65, 0x34, 0x30, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x36, 0x30, 0x62, 0x34, 0x63, 0x30, 0x32, 0x63, 0x61, 0x63, 0x30, 0x61, 0x38, 0x31, 0x64, 0x65, 0x39, 0x31, 0x30, 0x38, 0x64, 0x65, 0x34, 0x33, 0x34, 0x35, 0x39, 0x30, 0x61, 0x38, 0x62, 0x66, 0x65, 0x36, 0x38, 0x37, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x30, 0x30, 0x30, 0x37, 0x33, 0x39, 0x34, 0x62, 0x38, 0x62, 0x37, 0x35, 0x36, 0x35, 0x61, 0x31, 0x36, 0x35, 0x38, 0x61, 0x66, 0x38, 0x38, 0x63, 0x65, 0x34, 0x36, 0x33, 0x34, 0x39, 0x39, 0x31, 0x33, 0x35, 0x64, 0x36, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x34, 0x35, 0x37, 0x66, 0x61, 0x33, 0x33, 0x62, 0x30, 0x38, 0x33, 0x32, 0x35, 0x30, 0x36, 0x63, 0x34, 0x66, 0x37, 0x64, 0x31, 0x31, 0x38, 0x30, 0x64, 0x63, 0x65, 0x34, 0x38, 0x66, 0x34, 0x36, 0x66, 0x33, 0x65, 0x30, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x31, 0x65, 0x35, 0x35, 0x38, 0x65, 0x62, 0x35, 0x35, 0x31, 0x32, 0x66, 0x62, 0x63, 0x66, 0x61, 0x38, 0x31, 0x66, 0x38, 0x64, 0x30, 0x62, 0x64, 0x39, 0x33, 0x38, 0x63, 0x37, 0x39, 0x65, 0x62, 0x62, 0x35, 0x32, 0x34, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x66, 0x31, 0x33, 0x66, 0x39, 0x66, 0x30, 0x38, 0x33, 0x36, 0x61, 0x33, 0x65, 0x65, 0x32, 0x34, 0x33, 0x37, 0x61, 0x38, 0x34, 0x39, 0x32, 0x32, 0x64, 0x32, 0x39, 0x38, 0x34, 0x64, 0x63, 0x30, 0x66, 0x37, 0x64, 0x35, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x64, 0x34, 0x35, 0x37, 0x61, 0x64, 0x65, 0x30, 0x35, 0x31, 0x37, 0x39, 0x35, 0x64, 0x66, 0x33, 0x66, 0x32, 0x34, 0x36, 0x35, 0x63, 0x33, 0x38, 0x33, 0x39, 0x61, 0x65, 0x64, 0x33, 0x63, 0x35, 0x64, 0x65, 0x65, 0x39, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x64, 0x62, 0x63, 0x66, 0x31, 0x33, 0x35, 0x61, 0x63, 0x62, 0x39, 0x64, 0x65, 0x65, 0x31, 0x61, 0x34, 0x38, 0x39, 0x63, 0x35, 0x39, 0x33, 0x63, 0x30, 0x32, 0x34, 0x66, 0x30, 0x33, 0x63, 0x32, 0x62, 0x62, 0x61, 0x65, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x62, 0x39, 0x30, 0x32, 0x63, 0x35, 0x61, 0x36, 0x37, 0x33, 0x38, 0x38, 0x35, 0x38, 0x32, 0x36, 0x38, 0x32, 0x30, 0x64, 0x31, 0x66, 0x65, 0x31, 0x34, 0x35, 0x34, 0x39, 0x65, 0x34, 0x38, 0x36, 0x35, 0x66, 0x62, 0x64, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x37, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x63, 0x63, 0x39, 0x63, 0x31, 0x61, 0x33, 0x32, 0x32, 0x34, 0x30, 0x62, 0x34, 0x64, 0x35, 0x62, 0x32, 0x66, 0x37, 0x37, 0x37, 0x61, 0x32, 0x65, 0x61, 0x30, 0x35, 0x32, 0x62, 0x34, 0x32, 0x66, 0x63, 0x31, 0x32, 0x37, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x64, 0x66, 0x65, 0x66, 0x36, 0x33, 0x39, 0x31, 0x35, 0x35, 0x64, 0x61, 0x61, 0x62, 0x30, 0x61, 0x35, 0x63, 0x62, 0x34, 0x39, 0x35, 0x33, 0x61, 0x61, 0x38, 0x63, 0x35, 0x61, 0x66, 0x61, 0x61, 0x38, 0x38, 0x30, 0x34, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x66, 0x66, 0x36, 0x66, 0x35, 0x30, 0x39, 0x39, 0x36, 0x38, 0x66, 0x33, 0x36, 0x63, 0x62, 0x34, 0x32, 0x63, 0x62, 0x61, 0x34, 0x38, 0x64, 0x62, 0x33, 0x32, 0x66, 0x32, 0x31, 0x66, 0x35, 0x36, 0x37, 0x36, 0x61, 0x62, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x63, 0x38, 0x31, 0x37, 0x30, 0x66, 0x37, 0x62, 0x32, 0x61, 0x62, 0x35, 0x33, 0x36, 0x64, 0x31, 0x64, 0x39, 0x61, 0x32, 0x35, 0x62, 0x64, 0x64, 0x32, 0x30, 0x33, 0x61, 0x65, 0x31, 0x32, 0x38, 0x38, 0x64, 0x63, 0x33, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x64, 0x34, 0x66, 0x38, 0x63, 0x37, 0x31, 0x63, 0x31, 0x65, 0x36, 0x38, 0x61, 0x36, 0x39, 0x61, 0x39, 0x38, 0x66, 0x35, 0x32, 0x66, 0x63, 0x62, 0x34, 0x35, 0x64, 0x61, 0x38, 0x61, 0x66, 0x35, 0x36, 0x65, 0x61, 0x31, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x63, 0x39, 0x39, 0x65, 0x39, 0x37, 0x32, 0x66, 0x63, 0x61, 0x37, 0x31, 0x37, 0x37, 0x35, 0x30, 0x38, 0x63, 0x38, 0x65, 0x31, 0x61, 0x34, 0x37, 0x61, 0x63, 0x32, 0x32, 0x64, 0x37, 0x36, 0x38, 0x61, 0x63, 0x61, 0x62, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x37, 0x61, 0x61, 0x31, 0x36, 0x64, 0x37, 0x34, 0x61, 0x65, 0x65, 0x38, 0x61, 0x39, 0x61, 0x33, 0x32, 0x38, 0x38, 0x64, 0x35, 0x32, 0x64, 0x62, 0x31, 0x35, 0x35, 0x31, 0x64, 0x35, 0x39, 0x33, 0x38, 0x38, 0x33, 0x32, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x31, 0x31, 0x36, 0x39, 0x30, 0x34, 0x31, 0x63, 0x31, 0x37, 0x34, 0x35, 0x65, 0x34, 0x35, 0x62, 0x31, 0x37, 0x32, 0x34, 0x33, 0x35, 0x61, 0x32, 0x66, 0x63, 0x39, 0x39, 0x62, 0x34, 0x39, 0x61, 0x63, 0x65, 0x32, 0x62, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x36, 0x63, 0x62, 0x30, 0x39, 0x63, 0x65, 0x33, 0x61, 0x64, 0x61, 0x33, 0x36, 0x37, 0x32, 0x65, 0x65, 0x63, 0x31, 0x64, 0x65, 0x62, 0x34, 0x36, 0x32, 0x30, 0x35, 0x62, 0x65, 0x38, 0x39, 0x61, 0x34, 0x62, 0x35, 0x36, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x36, 0x39, 0x35, 0x39, 0x64, 0x65, 0x32, 0x62, 0x36, 0x37, 0x39, 0x36, 0x37, 0x62, 0x37, 0x31, 0x39, 0x34, 0x38, 0x63, 0x38, 0x39, 0x31, 0x61, 0x62, 0x30, 0x30, 0x64, 0x38, 0x63, 0x38, 0x66, 0x33, 0x38, 0x63, 0x37, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x37, 0x62, 0x61, 0x33, 0x66, 0x66, 0x35, 0x33, 0x36, 0x63, 0x37, 0x65, 0x35, 0x66, 0x30, 0x65, 0x31, 0x35, 0x33, 0x38, 0x30, 0x30, 0x62, 0x64, 0x33, 0x38, 0x33, 0x64, 0x62, 0x38, 0x33, 0x31, 0x32, 0x39, 0x39, 0x38, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x64, 0x30, 0x36, 0x65, 0x65, 0x35, 0x31, 0x36, 0x36, 0x32, 0x61, 0x38, 0x36, 0x63, 0x36, 0x33, 0x34, 0x35, 0x38, 0x38, 0x66, 0x62, 0x36, 0x32, 0x64, 0x63, 0x34, 0x33, 0x63, 0x38, 0x66, 0x32, 0x37, 0x65, 0x37, 0x63, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x30, 0x34, 0x34, 0x37, 0x66, 0x39, 0x37, 0x63, 0x65, 0x39, 0x62, 0x32, 0x35, 0x66, 0x32, 0x32, 0x62, 0x61, 0x31, 0x61, 0x66, 0x62, 0x33, 0x36, 0x64, 0x66, 0x32, 0x37, 0x66, 0x39, 0x35, 0x38, 0x36, 0x62, 0x65, 0x62, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x35, 0x63, 0x39, 0x62, 0x64, 0x61, 0x64, 0x33, 0x63, 0x35, 0x63, 0x38, 0x61, 0x31, 0x32, 0x32, 0x30, 0x34, 0x34, 0x34, 0x61, 0x65, 0x61, 0x35, 0x63, 0x32, 0x32, 0x39, 0x63, 0x31, 0x38, 0x33, 0x39, 0x66, 0x31, 0x64, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x38, 0x33, 0x30, 0x36, 0x63, 0x62, 0x37, 0x30, 0x62, 0x61, 0x61, 0x38, 0x65, 0x34, 0x39, 0x31, 0x38, 0x36, 0x62, 0x64, 0x36, 0x38, 0x61, 0x61, 0x37, 0x30, 0x61, 0x38, 0x33, 0x64, 0x32, 0x34, 0x32, 0x66, 0x32, 0x39, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x32, 0x31, 0x33, 0x66, 0x63, 0x61, 0x33, 0x31, 0x33, 0x34, 0x30, 0x34, 0x32, 0x30, 0x34, 0x65, 0x63, 0x62, 0x61, 0x38, 0x37, 0x31, 0x39, 0x37, 0x37, 0x34, 0x31, 0x61, 0x61, 0x39, 0x64, 0x66, 0x65, 0x39, 0x36, 0x33, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x65, 0x33, 0x39, 0x30, 0x61, 0x64, 0x32, 0x62, 0x61, 0x33, 0x33, 0x64, 0x38, 0x32, 0x62, 0x33, 0x37, 0x33, 0x38, 0x38, 0x64, 0x30, 0x39, 0x63, 0x34, 0x35, 0x34, 0x34, 0x63, 0x36, 0x62, 0x30, 0x32, 0x32, 0x35, 0x64, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x36, 0x65, 0x38, 0x31, 0x34, 0x66, 0x37, 0x37, 0x30, 0x37, 0x34, 0x38, 0x61, 0x37, 0x63, 0x33, 0x39, 0x39, 0x37, 0x38, 0x30, 0x36, 0x33, 0x34, 0x37, 0x36, 0x30, 0x35, 0x34, 0x38, 0x30, 0x61, 0x33, 0x66, 0x64, 0x35, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x34, 0x35, 0x32, 0x63, 0x33, 0x39, 0x36, 0x39, 0x65, 0x63, 0x65, 0x33, 0x38, 0x30, 0x31, 0x63, 0x35, 0x34, 0x32, 0x30, 0x32, 0x30, 0x66, 0x31, 0x63, 0x64, 0x63, 0x61, 0x61, 0x31, 0x63, 0x37, 0x31, 0x65, 0x64, 0x32, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x34, 0x32, 0x62, 0x31, 0x65, 0x36, 0x30, 0x36, 0x39, 0x61, 0x38, 0x66, 0x66, 0x63, 0x33, 0x63, 0x34, 0x37, 0x36, 0x37, 0x32, 0x33, 0x35, 0x64, 0x65, 0x66, 0x62, 0x30, 0x64, 0x34, 0x39, 0x63, 0x62, 0x65, 0x64, 0x32, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x32, 0x32, 0x35, 0x37, 0x33, 0x38, 0x64, 0x63, 0x66, 0x33, 0x35, 0x37, 0x38, 0x34, 0x33, 0x38, 0x66, 0x38, 0x65, 0x37, 0x63, 0x38, 0x62, 0x33, 0x38, 0x33, 0x37, 0x65, 0x34, 0x32, 0x65, 0x30, 0x34, 0x61, 0x32, 0x36, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x35, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x30, 0x62, 0x30, 0x32, 0x35, 0x37, 0x65, 0x37, 0x38, 0x33, 0x61, 0x33, 0x64, 0x32, 0x63, 0x32, 0x65, 0x33, 0x62, 0x61, 0x39, 0x64, 0x36, 0x65, 0x37, 0x39, 0x62, 0x37, 0x35, 0x65, 0x66, 0x39, 0x38, 0x30, 0x32, 0x34, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x30, 0x65, 0x37, 0x66, 0x65, 0x66, 0x31, 0x38, 0x61, 0x35, 0x64, 0x62, 0x31, 0x35, 0x62, 0x30, 0x31, 0x34, 0x37, 0x33, 0x66, 0x33, 0x61, 0x64, 0x36, 0x62, 0x37, 0x38, 0x62, 0x32, 0x61, 0x32, 0x66, 0x38, 0x61, 0x63, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x31, 0x35, 0x37, 0x35, 0x65, 0x39, 0x63, 0x66, 0x35, 0x39, 0x63, 0x38, 0x32, 0x32, 0x36, 0x66, 0x61, 0x37, 0x61, 0x61, 0x66, 0x39, 0x31, 0x64, 0x65, 0x38, 0x36, 0x66, 0x62, 0x37, 0x30, 0x66, 0x35, 0x61, 0x63, 0x33, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x37, 0x31, 0x31, 0x37, 0x31, 0x66, 0x32, 0x39, 0x34, 0x39, 0x66, 0x61, 0x30, 0x63, 0x33, 0x61, 0x63, 0x32, 0x35, 0x34, 0x32, 0x35, 0x34, 0x62, 0x31, 0x66, 0x30, 0x34, 0x34, 0x30, 0x65, 0x35, 0x65, 0x36, 0x61, 0x30, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x65, 0x61, 0x36, 0x61, 0x63, 0x38, 0x39, 0x61, 0x32, 0x62, 0x61, 0x63, 0x39, 0x35, 0x33, 0x34, 0x37, 0x62, 0x35, 0x31, 0x64, 0x62, 0x61, 0x36, 0x33, 0x64, 0x38, 0x62, 0x64, 0x35, 0x65, 0x62, 0x64, 0x65, 0x64, 0x63, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x65, 0x63, 0x35, 0x63, 0x66, 0x30, 0x63, 0x34, 0x39, 0x62, 0x39, 0x63, 0x33, 0x31, 0x37, 0x65, 0x31, 0x65, 0x37, 0x30, 0x36, 0x33, 0x31, 0x35, 0x65, 0x66, 0x39, 0x65, 0x62, 0x37, 0x63, 0x30, 0x62, 0x66, 0x31, 0x31, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x39, 0x39, 0x62, 0x34, 0x32, 0x65, 0x34, 0x66, 0x34, 0x32, 0x36, 0x31, 0x39, 0x65, 0x65, 0x33, 0x36, 0x62, 0x61, 0x61, 0x37, 0x65, 0x34, 0x61, 0x66, 0x32, 0x64, 0x36, 0x35, 0x65, 0x61, 0x63, 0x66, 0x63, 0x62, 0x61, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x65, 0x34, 0x63, 0x63, 0x30, 0x63, 0x37, 0x32, 0x38, 0x33, 0x66, 0x63, 0x31, 0x63, 0x38, 0x35, 0x62, 0x63, 0x34, 0x38, 0x31, 0x33, 0x65, 0x66, 0x66, 0x61, 0x61, 0x66, 0x37, 0x32, 0x62, 0x34, 0x39, 0x38, 0x32, 0x33, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x36, 0x39, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x63, 0x31, 0x63, 0x65, 0x30, 0x65, 0x34, 0x39, 0x62, 0x31, 0x61, 0x37, 0x30, 0x35, 0x64, 0x32, 0x32, 0x65, 0x32, 0x30, 0x33, 0x37, 0x61, 0x65, 0x63, 0x38, 0x37, 0x38, 0x65, 0x65, 0x30, 0x64, 0x37, 0x35, 0x63, 0x37, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x36, 0x66, 0x34, 0x34, 0x62, 0x64, 0x65, 0x62, 0x36, 0x38, 0x38, 0x30, 0x33, 0x37, 0x30, 0x31, 0x35, 0x65, 0x38, 0x34, 0x66, 0x66, 0x32, 0x31, 0x38, 0x30, 0x34, 0x39, 0x65, 0x33, 0x38, 0x32, 0x33, 0x33, 0x32, 0x61, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x33, 0x61, 0x33, 0x33, 0x30, 0x65, 0x34, 0x66, 0x63, 0x62, 0x36, 0x39, 0x64, 0x62, 0x65, 0x66, 0x35, 0x65, 0x36, 0x39, 0x30, 0x31, 0x37, 0x38, 0x33, 0x62, 0x66, 0x35, 0x30, 0x66, 0x64, 0x31, 0x63, 0x31, 0x35, 0x33, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x61, 0x38, 0x34, 0x66, 0x37, 0x35, 0x36, 0x37, 0x35, 0x63, 0x36, 0x32, 0x64, 0x38, 0x30, 0x63, 0x38, 0x38, 0x37, 0x35, 0x36, 0x63, 0x34, 0x32, 0x38, 0x65, 0x65, 0x65, 0x32, 0x62, 0x63, 0x62, 0x31, 0x38, 0x35, 0x34, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x39, 0x33, 0x62, 0x35, 0x34, 0x36, 0x62, 0x37, 0x36, 0x39, 0x38, 0x37, 0x31, 0x30, 0x61, 0x32, 0x30, 0x35, 0x61, 0x64, 0x34, 0x36, 0x38, 0x62, 0x32, 0x63, 0x31, 0x33, 0x31, 0x35, 0x32, 0x32, 0x31, 0x39, 0x61, 0x33, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x36, 0x32, 0x37, 0x61, 0x37, 0x36, 0x39, 0x65, 0x36, 0x61, 0x39, 0x35, 0x30, 0x65, 0x62, 0x38, 0x37, 0x30, 0x31, 0x37, 0x61, 0x37, 0x63, 0x64, 0x39, 0x63, 0x61, 0x32, 0x30, 0x38, 0x37, 0x31, 0x31, 0x33, 0x36, 0x38, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x64, 0x35, 0x37, 0x36, 0x33, 0x63, 0x65, 0x30, 0x37, 0x33, 0x31, 0x32, 0x37, 0x65, 0x32, 0x63, 0x65, 0x64, 0x64, 0x65, 0x36, 0x66, 0x61, 0x62, 0x61, 0x37, 0x38, 0x36, 0x63, 0x37, 0x33, 0x63, 0x61, 0x39, 0x34, 0x31, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x32, 0x31, 0x31, 0x30, 0x66, 0x32, 0x39, 0x65, 0x61, 0x63, 0x35, 0x66, 0x37, 0x64, 0x30, 0x32, 0x62, 0x35, 0x34, 0x33, 0x64, 0x38, 0x64, 0x63, 0x64, 0x35, 0x62, 0x62, 0x35, 0x39, 0x61, 0x35, 0x65, 0x33, 0x33, 0x62, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x34, 0x37, 0x33, 0x63, 0x64, 0x33, 0x30, 0x30, 0x66, 0x66, 0x66, 0x61, 0x65, 0x32, 0x34, 0x30, 0x66, 0x35, 0x37, 0x38, 0x35, 0x36, 0x32, 0x36, 0x63, 0x36, 0x35, 0x64, 0x66, 0x65, 0x63, 0x37, 0x39, 0x32, 0x62, 0x39, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x63, 0x64, 0x31, 0x31, 0x38, 0x31, 0x35, 0x38, 0x31, 0x38, 0x61, 0x65, 0x32, 0x39, 0x62, 0x38, 0x35, 0x64, 0x30, 0x31, 0x33, 0x36, 0x37, 0x33, 0x34, 0x39, 0x61, 0x38, 0x61, 0x37, 0x66, 0x62, 0x31, 0x32, 0x64, 0x30, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x32, 0x39, 0x66, 0x66, 0x64, 0x63, 0x32, 0x36, 0x38, 0x62, 0x61, 0x62, 0x64, 0x65, 0x38, 0x38, 0x37, 0x34, 0x62, 0x33, 0x36, 0x36, 0x34, 0x30, 0x36, 0x63, 0x38, 0x31, 0x34, 0x34, 0x35, 0x62, 0x39, 0x62, 0x32, 0x64, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x32, 0x34, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x62, 0x34, 0x32, 0x38, 0x31, 0x65, 0x62, 0x62, 0x33, 0x31, 0x38, 0x35, 0x39, 0x30, 0x61, 0x62, 0x62, 0x38, 0x39, 0x61, 0x38, 0x31, 0x64, 0x66, 0x30, 0x37, 0x66, 0x61, 0x33, 0x61, 0x66, 0x39, 0x30, 0x34, 0x32, 0x35, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x35, 0x30, 0x36, 0x31, 0x65, 0x65, 0x31, 0x32, 0x65, 0x38, 0x32, 0x30, 0x30, 0x34, 0x31, 0x61, 0x30, 0x31, 0x39, 0x34, 0x32, 0x63, 0x62, 0x30, 0x65, 0x36, 0x35, 0x62, 0x62, 0x34, 0x32, 0x37, 0x62, 0x30, 0x30, 0x30, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x62, 0x36, 0x39, 0x38, 0x65, 0x38, 0x39, 0x38, 0x64, 0x32, 0x30, 0x64, 0x34, 0x64, 0x34, 0x66, 0x34, 0x30, 0x38, 0x65, 0x34, 0x65, 0x34, 0x64, 0x30, 0x36, 0x31, 0x39, 0x32, 0x32, 0x61, 0x61, 0x38, 0x35, 0x36, 0x33, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x34, 0x39, 0x61, 0x35, 0x66, 0x35, 0x38, 0x61, 0x64, 0x62, 0x65, 0x66, 0x61, 0x65, 0x32, 0x33, 0x65, 0x65, 0x35, 0x39, 0x65, 0x65, 0x61, 0x32, 0x34, 0x31, 0x63, 0x66, 0x30, 0x34, 0x38, 0x32, 0x36, 0x32, 0x32, 0x65, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x36, 0x65, 0x38, 0x35, 0x64, 0x66, 0x37, 0x65, 0x37, 0x33, 0x32, 0x62, 0x34, 0x61, 0x38, 0x66, 0x30, 0x65, 0x64, 0x30, 0x33, 0x36, 0x32, 0x33, 0x66, 0x34, 0x64, 0x62, 0x39, 0x64, 0x62, 0x30, 0x62, 0x38, 0x66, 0x61, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x31, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x37, 0x36, 0x30, 0x63, 0x64, 0x39, 0x65, 0x31, 0x39, 0x35, 0x65, 0x65, 0x34, 0x66, 0x32, 0x64, 0x36, 0x62, 0x63, 0x65, 0x32, 0x35, 0x30, 0x30, 0x66, 0x66, 0x39, 0x36, 0x64, 0x61, 0x37, 0x63, 0x34, 0x33, 0x65, 0x65, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x34, 0x61, 0x30, 0x39, 0x38, 0x61, 0x65, 0x37, 0x30, 0x32, 0x62, 0x65, 0x66, 0x35, 0x34, 0x30, 0x36, 0x63, 0x39, 0x63, 0x32, 0x32, 0x62, 0x37, 0x38, 0x62, 0x64, 0x34, 0x65, 0x62, 0x32, 0x63, 0x63, 0x37, 0x61, 0x32, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x38, 0x31, 0x61, 0x65, 0x61, 0x36, 0x39, 0x61, 0x65, 0x64, 0x36, 0x61, 0x64, 0x30, 0x37, 0x30, 0x38, 0x39, 0x64, 0x36, 0x31, 0x34, 0x34, 0x35, 0x33, 0x34, 0x38, 0x63, 0x31, 0x37, 0x66, 0x33, 0x34, 0x62, 0x66, 0x63, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x61, 0x62, 0x38, 0x37, 0x64, 0x64, 0x35, 0x61, 0x30, 0x35, 0x61, 0x64, 0x38, 0x33, 0x39, 0x61, 0x34, 0x65, 0x32, 0x66, 0x63, 0x38, 0x63, 0x38, 0x35, 0x61, 0x61, 0x36, 0x62, 0x61, 0x30, 0x35, 0x36, 0x34, 0x31, 0x37, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x65, 0x32, 0x66, 0x35, 0x61, 0x66, 0x39, 0x37, 0x39, 0x61, 0x30, 0x33, 0x66, 0x64, 0x37, 0x32, 0x33, 0x61, 0x31, 0x62, 0x36, 0x65, 0x66, 0x61, 0x37, 0x32, 0x38, 0x33, 0x31, 0x38, 0x63, 0x66, 0x39, 0x63, 0x31, 0x38, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x62, 0x36, 0x39, 0x66, 0x65, 0x39, 0x33, 0x65, 0x36, 0x66, 0x62, 0x36, 0x66, 0x62, 0x64, 0x34, 0x35, 0x30, 0x39, 0x36, 0x36, 0x62, 0x39, 0x37, 0x32, 0x33, 0x38, 0x62, 0x31, 0x31, 0x30, 0x61, 0x64, 0x38, 0x32, 0x37, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x32, 0x35, 0x39, 0x66, 0x38, 0x33, 0x34, 0x35, 0x66, 0x37, 0x65, 0x33, 0x61, 0x38, 0x62, 0x37, 0x32, 0x62, 0x30, 0x66, 0x65, 0x63, 0x32, 0x63, 0x66, 0x37, 0x35, 0x65, 0x33, 0x32, 0x31, 0x66, 0x64, 0x61, 0x34, 0x64, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x30, 0x33, 0x30, 0x65, 0x34, 0x62, 0x38, 0x32, 0x36, 0x39, 0x32, 0x64, 0x63, 0x66, 0x38, 0x62, 0x38, 0x64, 0x30, 0x39, 0x31, 0x32, 0x34, 0x39, 0x34, 0x62, 0x39, 0x62, 0x33, 0x37, 0x38, 0x65, 0x63, 0x39, 0x33, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x34, 0x37, 0x30, 0x66, 0x37, 0x62, 0x61, 0x30, 0x33, 0x30, 0x62, 0x63, 0x37, 0x63, 0x66, 0x63, 0x66, 0x33, 0x33, 0x38, 0x64, 0x34, 0x62, 0x66, 0x30, 0x34, 0x33, 0x32, 0x61, 0x39, 0x31, 0x65, 0x32, 0x65, 0x61, 0x35, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x63, 0x39, 0x66, 0x39, 0x33, 0x65, 0x34, 0x35, 0x66, 0x65, 0x33, 0x63, 0x31, 0x34, 0x31, 0x38, 0x63, 0x33, 0x35, 0x33, 0x65, 0x34, 0x63, 0x35, 0x61, 0x63, 0x33, 0x38, 0x39, 0x34, 0x65, 0x65, 0x66, 0x38, 0x31, 0x32, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x61, 0x63, 0x33, 0x64, 0x62, 0x38, 0x37, 0x39, 0x61, 0x36, 0x63, 0x37, 0x31, 0x35, 0x38, 0x65, 0x38, 0x64, 0x65, 0x63, 0x36, 0x30, 0x33, 0x62, 0x34, 0x30, 0x37, 0x34, 0x36, 0x33, 0x62, 0x61, 0x30, 0x64, 0x33, 0x31, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x38, 0x65, 0x38, 0x37, 0x64, 0x64, 0x64, 0x61, 0x35, 0x65, 0x37, 0x38, 0x66, 0x63, 0x62, 0x63, 0x62, 0x39, 0x66, 0x61, 0x37, 0x66, 0x63, 0x33, 0x63, 0x65, 0x30, 0x33, 0x38, 0x66, 0x39, 0x66, 0x37, 0x64, 0x32, 0x65, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x30, 0x35, 0x38, 0x39, 0x62, 0x31, 0x34, 0x33, 0x61, 0x38, 0x65, 0x35, 0x65, 0x31, 0x30, 0x37, 0x63, 0x39, 0x61, 0x63, 0x36, 0x36, 0x61, 0x39, 0x66, 0x39, 0x66, 0x38, 0x35, 0x39, 0x37, 0x61, 0x62, 0x33, 0x65, 0x37, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x31, 0x30, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x64, 0x35, 0x38, 0x31, 0x66, 0x65, 0x30, 0x61, 0x66, 0x31, 0x65, 0x63, 0x33, 0x38, 0x33, 0x66, 0x33, 0x62, 0x33, 0x63, 0x34, 0x31, 0x36, 0x37, 0x38, 0x33, 0x66, 0x33, 0x38, 0x35, 0x31, 0x34, 0x36, 0x61, 0x37, 0x36, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x33, 0x66, 0x63, 0x30, 0x61, 0x32, 0x39, 0x63, 0x30, 0x33, 0x34, 0x64, 0x37, 0x31, 0x30, 0x38, 0x31, 0x32, 0x64, 0x63, 0x63, 0x37, 0x37, 0x35, 0x63, 0x38, 0x63, 0x61, 0x62, 0x39, 0x64, 0x32, 0x38, 0x64, 0x36, 0x39, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x36, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x36, 0x30, 0x33, 0x66, 0x66, 0x30, 0x66, 0x65, 0x39, 0x33, 0x36, 0x31, 0x36, 0x63, 0x34, 0x33, 0x35, 0x37, 0x33, 0x65, 0x66, 0x32, 0x37, 0x39, 0x62, 0x66, 0x65, 0x61, 0x34, 0x30, 0x38, 0x38, 0x38, 0x64, 0x36, 0x61, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x66, 0x32, 0x62, 0x37, 0x62, 0x31, 0x36, 0x34, 0x33, 0x32, 0x65, 0x65, 0x35, 0x30, 0x61, 0x35, 0x66, 0x35, 0x35, 0x62, 0x34, 0x31, 0x32, 0x33, 0x32, 0x66, 0x36, 0x33, 0x33, 0x34, 0x65, 0x64, 0x35, 0x38, 0x62, 0x64, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x33, 0x64, 0x37, 0x32, 0x30, 0x33, 0x63, 0x38, 0x61, 0x34, 0x34, 0x37, 0x66, 0x37, 0x62, 0x66, 0x33, 0x36, 0x64, 0x38, 0x38, 0x61, 0x65, 0x39, 0x62, 0x36, 0x30, 0x36, 0x32, 0x61, 0x35, 0x65, 0x65, 0x65, 0x37, 0x38, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x36, 0x37, 0x65, 0x31, 0x66, 0x31, 0x64, 0x36, 0x38, 0x33, 0x35, 0x35, 0x36, 0x61, 0x34, 0x63, 0x63, 0x34, 0x66, 0x64, 0x30, 0x63, 0x30, 0x33, 0x31, 0x33, 0x32, 0x33, 0x39, 0x66, 0x33, 0x32, 0x63, 0x34, 0x63, 0x66, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x37, 0x33, 0x38, 0x63, 0x39, 0x30, 0x64, 0x38, 0x36, 0x30, 0x65, 0x30, 0x34, 0x63, 0x62, 0x31, 0x32, 0x66, 0x34, 0x39, 0x38, 0x64, 0x39, 0x36, 0x66, 0x64, 0x62, 0x35, 0x62, 0x66, 0x33, 0x36, 0x66, 0x63, 0x33, 0x34, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x37, 0x38, 0x31, 0x62, 0x62, 0x65, 0x37, 0x37, 0x31, 0x34, 0x61, 0x31, 0x63, 0x38, 0x66, 0x37, 0x33, 0x62, 0x31, 0x63, 0x37, 0x34, 0x37, 0x39, 0x32, 0x31, 0x64, 0x66, 0x34, 0x66, 0x38, 0x34, 0x32, 0x37, 0x38, 0x62, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x39, 0x37, 0x65, 0x38, 0x66, 0x63, 0x66, 0x34, 0x36, 0x33, 0x35, 0x65, 0x61, 0x37, 0x66, 0x63, 0x35, 0x65, 0x39, 0x36, 0x65, 0x65, 0x35, 0x31, 0x37, 0x35, 0x32, 0x65, 0x63, 0x33, 0x38, 0x38, 0x37, 0x31, 0x36, 0x62, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x39, 0x33, 0x39, 0x66, 0x66, 0x30, 0x38, 0x39, 0x32, 0x31, 0x62, 0x34, 0x36, 0x37, 0x63, 0x66, 0x32, 0x39, 0x34, 0x36, 0x37, 0x35, 0x31, 0x64, 0x38, 0x35, 0x36, 0x33, 0x37, 0x38, 0x32, 0x39, 0x36, 0x63, 0x36, 0x33, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x38, 0x35, 0x34, 0x37, 0x30, 0x65, 0x36, 0x31, 0x64, 0x62, 0x31, 0x31, 0x30, 0x61, 0x65, 0x62, 0x64, 0x62, 0x61, 0x66, 0x64, 0x35, 0x33, 0x36, 0x37, 0x36, 0x39, 0x65, 0x33, 0x63, 0x35, 0x39, 0x39, 0x63, 0x63, 0x39, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x30, 0x64, 0x31, 0x62, 0x63, 0x62, 0x37, 0x31, 0x32, 0x38, 0x36, 0x64, 0x63, 0x37, 0x31, 0x32, 0x38, 0x61, 0x39, 0x66, 0x63, 0x37, 0x63, 0x36, 0x65, 0x64, 0x37, 0x66, 0x37, 0x33, 0x33, 0x38, 0x39, 0x32, 0x65, 0x65, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x65, 0x65, 0x61, 0x38, 0x39, 0x38, 0x64, 0x34, 0x61, 0x65, 0x32, 0x62, 0x37, 0x31, 0x38, 0x30, 0x32, 0x37, 0x61, 0x31, 0x39, 0x63, 0x65, 0x39, 0x61, 0x35, 0x65, 0x62, 0x37, 0x33, 0x30, 0x30, 0x61, 0x62, 0x65, 0x33, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x34, 0x39, 0x37, 0x34, 0x61, 0x31, 0x66, 0x34, 0x36, 0x62, 0x66, 0x32, 0x30, 0x34, 0x39, 0x34, 0x34, 0x61, 0x38, 0x35, 0x33, 0x31, 0x31, 0x31, 0x65, 0x35, 0x32, 0x66, 0x31, 0x36, 0x30, 0x32, 0x36, 0x31, 0x37, 0x64, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x61, 0x35, 0x37, 0x33, 0x32, 0x66, 0x33, 0x62, 0x38, 0x36, 0x66, 0x62, 0x38, 0x63, 0x38, 0x31, 0x65, 0x66, 0x62, 0x65, 0x36, 0x62, 0x35, 0x62, 0x34, 0x37, 0x62, 0x35, 0x36, 0x33, 0x37, 0x33, 0x30, 0x62, 0x30, 0x36, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x30, 0x37, 0x64, 0x37, 0x31, 0x64, 0x64, 0x36, 0x64, 0x30, 0x65, 0x65, 0x66, 0x62, 0x31, 0x31, 0x64, 0x34, 0x63, 0x39, 0x31, 0x36, 0x34, 0x30, 0x34, 0x63, 0x62, 0x39, 0x38, 0x63, 0x37, 0x35, 0x33, 0x65, 0x31, 0x31, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x37, 0x62, 0x63, 0x64, 0x61, 0x36, 0x35, 0x39, 0x32, 0x34, 0x61, 0x61, 0x61, 0x34, 0x39, 0x62, 0x38, 0x30, 0x39, 0x38, 0x34, 0x61, 0x65, 0x31, 0x37, 0x33, 0x37, 0x35, 0x30, 0x32, 0x35, 0x38, 0x62, 0x39, 0x32, 0x38, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x37, 0x62, 0x35, 0x34, 0x34, 0x37, 0x34, 0x64, 0x30, 0x31, 0x66, 0x65, 0x66, 0x64, 0x33, 0x38, 0x38, 0x64, 0x66, 0x63, 0x64, 0x35, 0x33, 0x62, 0x39, 0x66, 0x36, 0x36, 0x32, 0x36, 0x32, 0x34, 0x34, 0x31, 0x38, 0x61, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x66, 0x63, 0x37, 0x33, 0x64, 0x32, 0x30, 0x37, 0x39, 0x33, 0x30, 0x39, 0x38, 0x65, 0x30, 0x39, 0x64, 0x64, 0x61, 0x62, 0x35, 0x37, 0x39, 0x38, 0x35, 0x30, 0x36, 0x32, 0x32, 0x34, 0x66, 0x61, 0x31, 0x65, 0x31, 0x38, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x38, 0x34, 0x38, 0x38, 0x62, 0x64, 0x32, 0x64, 0x33, 0x63, 0x31, 0x39, 0x37, 0x61, 0x33, 0x64, 0x32, 0x36, 0x31, 0x35, 0x31, 0x38, 0x31, 0x35, 0x62, 0x35, 0x61, 0x37, 0x39, 0x38, 0x64, 0x32, 0x37, 0x31, 0x36, 0x38, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x39, 0x31, 0x33, 0x31, 0x66, 0x32, 0x38, 0x39, 0x34, 0x33, 0x39, 0x32, 0x35, 0x63, 0x66, 0x63, 0x39, 0x37, 0x64, 0x34, 0x31, 0x65, 0x30, 0x63, 0x65, 0x61, 0x30, 0x62, 0x32, 0x36, 0x32, 0x39, 0x37, 0x33, 0x61, 0x37, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x62, 0x38, 0x64, 0x36, 0x62, 0x37, 0x33, 0x62, 0x37, 0x39, 0x35, 0x33, 0x34, 0x66, 0x62, 0x30, 0x38, 0x62, 0x62, 0x38, 0x63, 0x62, 0x63, 0x65, 0x66, 0x61, 0x63, 0x37, 0x66, 0x33, 0x39, 0x33, 0x63, 0x35, 0x37, 0x62, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x61, 0x63, 0x63, 0x32, 0x32, 0x30, 0x62, 0x61, 0x32, 0x65, 0x35, 0x31, 0x64, 0x66, 0x63, 0x66, 0x32, 0x31, 0x64, 0x34, 0x34, 0x33, 0x33, 0x36, 0x31, 0x65, 0x65, 0x61, 0x37, 0x36, 0x35, 0x63, 0x62, 0x64, 0x33, 0x35, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x63, 0x36, 0x63, 0x62, 0x37, 0x32, 0x33, 0x64, 0x64, 0x37, 0x61, 0x66, 0x61, 0x37, 0x65, 0x62, 0x35, 0x33, 0x35, 0x36, 0x31, 0x35, 0x65, 0x35, 0x33, 0x66, 0x33, 0x63, 0x65, 0x66, 0x31, 0x34, 0x66, 0x31, 0x38, 0x31, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x39, 0x61, 0x38, 0x36, 0x32, 0x61, 0x64, 0x31, 0x31, 0x35, 0x64, 0x36, 0x63, 0x38, 0x32, 0x37, 0x34, 0x65, 0x64, 0x30, 0x62, 0x39, 0x34, 0x34, 0x62, 0x64, 0x64, 0x36, 0x61, 0x35, 0x35, 0x30, 0x30, 0x35, 0x31, 0x30, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x37, 0x33, 0x32, 0x63, 0x30, 0x36, 0x35, 0x63, 0x62, 0x64, 0x36, 0x34, 0x31, 0x31, 0x39, 0x39, 0x34, 0x31, 0x61, 0x65, 0x64, 0x34, 0x33, 0x30, 0x61, 0x63, 0x35, 0x39, 0x36, 0x37, 0x30, 0x62, 0x36, 0x63, 0x35, 0x31, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x31, 0x33, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x32, 0x36, 0x65, 0x31, 0x32, 0x65, 0x62, 0x63, 0x31, 0x37, 0x30, 0x33, 0x35, 0x66, 0x33, 0x35, 0x63, 0x30, 0x65, 0x39, 0x64, 0x31, 0x31, 0x64, 0x64, 0x31, 0x34, 0x38, 0x33, 0x39, 0x33, 0x63, 0x34, 0x30, 0x35, 0x64, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x32, 0x30, 0x34, 0x38, 0x63, 0x63, 0x36, 0x30, 0x39, 0x61, 0x65, 0x62, 0x32, 0x34, 0x32, 0x31, 0x36, 0x35, 0x65, 0x61, 0x61, 0x61, 0x38, 0x37, 0x30, 0x35, 0x38, 0x35, 0x30, 0x63, 0x66, 0x33, 0x31, 0x32, 0x35, 0x64, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x65, 0x64, 0x64, 0x31, 0x64, 0x64, 0x64, 0x36, 0x64, 0x38, 0x36, 0x64, 0x63, 0x30, 0x30, 0x35, 0x62, 0x61, 0x65, 0x62, 0x35, 0x34, 0x31, 0x64, 0x32, 0x32, 0x62, 0x36, 0x34, 0x30, 0x64, 0x35, 0x63, 0x37, 0x63, 0x61, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x34, 0x39, 0x62, 0x31, 0x35, 0x39, 0x37, 0x39, 0x32, 0x35, 0x35, 0x66, 0x37, 0x65, 0x36, 0x35, 0x65, 0x39, 0x39, 0x62, 0x30, 0x64, 0x35, 0x36, 0x30, 0x34, 0x64, 0x62, 0x39, 0x38, 0x64, 0x66, 0x63, 0x61, 0x63, 0x38, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x63, 0x37, 0x63, 0x31, 0x39, 0x31, 0x33, 0x37, 0x39, 0x38, 0x39, 0x37, 0x64, 0x64, 0x39, 0x63, 0x39, 0x64, 0x39, 0x61, 0x33, 0x33, 0x38, 0x33, 0x39, 0x63, 0x34, 0x61, 0x35, 0x66, 0x36, 0x32, 0x63, 0x30, 0x38, 0x39, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x36, 0x37, 0x30, 0x30, 0x39, 0x61, 0x62, 0x36, 0x35, 0x38, 0x32, 0x36, 0x33, 0x62, 0x36, 0x32, 0x63, 0x32, 0x33, 0x33, 0x33, 0x61, 0x31, 0x63, 0x39, 0x65, 0x34, 0x31, 0x34, 0x30, 0x34, 0x39, 0x38, 0x65, 0x31, 0x33, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x33, 0x66, 0x35, 0x66, 0x31, 0x36, 0x35, 0x38, 0x64, 0x39, 0x65, 0x35, 0x37, 0x38, 0x66, 0x34, 0x66, 0x33, 0x64, 0x39, 0x35, 0x66, 0x38, 0x30, 0x63, 0x30, 0x62, 0x31, 0x62, 0x64, 0x33, 0x39, 0x33, 0x33, 0x63, 0x62, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x30, 0x39, 0x66, 0x64, 0x63, 0x32, 0x63, 0x37, 0x61, 0x32, 0x30, 0x65, 0x32, 0x33, 0x35, 0x37, 0x34, 0x62, 0x39, 0x37, 0x63, 0x36, 0x39, 0x65, 0x39, 0x33, 0x64, 0x65, 0x62, 0x61, 0x36, 0x37, 0x64, 0x33, 0x37, 0x32, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x38, 0x62, 0x35, 0x30, 0x39, 0x61, 0x65, 0x66, 0x65, 0x61, 0x31, 0x64, 0x62, 0x66, 0x61, 0x66, 0x32, 0x62, 0x62, 0x33, 0x33, 0x35, 0x30, 0x30, 0x64, 0x36, 0x35, 0x37, 0x30, 0x62, 0x36, 0x66, 0x64, 0x39, 0x36, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x66, 0x66, 0x61, 0x63, 0x38, 0x34, 0x30, 0x33, 0x32, 0x39, 0x34, 0x30, 0x66, 0x30, 0x31, 0x32, 0x31, 0x61, 0x30, 0x39, 0x36, 0x36, 0x38, 0x62, 0x38, 0x35, 0x38, 0x61, 0x37, 0x65, 0x37, 0x39, 0x66, 0x66, 0x61, 0x33, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x37, 0x39, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x33, 0x38, 0x34, 0x35, 0x39, 0x66, 0x33, 0x32, 0x61, 0x31, 0x35, 0x39, 0x62, 0x32, 0x33, 0x64, 0x62, 0x33, 0x30, 0x61, 0x63, 0x33, 0x33, 0x35, 0x37, 0x36, 0x39, 0x61, 0x62, 0x32, 0x33, 0x35, 0x31, 0x61, 0x61, 0x36, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x32, 0x32, 0x35, 0x31, 0x34, 0x35, 0x36, 0x64, 0x63, 0x31, 0x33, 0x38, 0x30, 0x66, 0x38, 0x66, 0x35, 0x36, 0x39, 0x32, 0x66, 0x39, 0x36, 0x32, 0x38, 0x32, 0x38, 0x36, 0x34, 0x30, 0x61, 0x62, 0x39, 0x66, 0x32, 0x61, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x37, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x66, 0x34, 0x36, 0x39, 0x36, 0x62, 0x64, 0x34, 0x36, 0x32, 0x62, 0x32, 0x30, 0x64, 0x61, 0x30, 0x39, 0x66, 0x62, 0x38, 0x33, 0x65, 0x64, 0x32, 0x30, 0x33, 0x39, 0x38, 0x31, 0x38, 0x64, 0x37, 0x37, 0x36, 0x32, 0x35, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x64, 0x65, 0x38, 0x62, 0x31, 0x35, 0x62, 0x33, 0x63, 0x63, 0x62, 0x61, 0x61, 0x35, 0x37, 0x38, 0x30, 0x31, 0x31, 0x32, 0x63, 0x33, 0x64, 0x36, 0x37, 0x34, 0x66, 0x33, 0x31, 0x33, 0x62, 0x62, 0x61, 0x36, 0x38, 0x30, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x30, 0x64, 0x36, 0x33, 0x37, 0x61, 0x38, 0x34, 0x35, 0x63, 0x30, 0x36, 0x64, 0x62, 0x36, 0x63, 0x64, 0x63, 0x39, 0x31, 0x65, 0x36, 0x33, 0x37, 0x31, 0x63, 0x65, 0x37, 0x63, 0x34, 0x33, 0x38, 0x38, 0x61, 0x36, 0x32, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x32, 0x39, 0x35, 0x65, 0x38, 0x65, 0x61, 0x35, 0x61, 0x66, 0x64, 0x39, 0x30, 0x39, 0x33, 0x66, 0x63, 0x30, 0x61, 0x34, 0x36, 0x35, 0x64, 0x31, 0x35, 0x37, 0x39, 0x32, 0x32, 0x62, 0x35, 0x64, 0x32, 0x61, 0x65, 0x32, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x34, 0x65, 0x38, 0x62, 0x65, 0x66, 0x33, 0x64, 0x64, 0x32, 0x63, 0x35, 0x39, 0x62, 0x35, 0x39, 0x61, 0x34, 0x31, 0x34, 0x35, 0x36, 0x37, 0x34, 0x34, 0x30, 0x31, 0x30, 0x31, 0x38, 0x33, 0x35, 0x31, 0x38, 0x38, 0x34, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x33, 0x37, 0x64, 0x30, 0x34, 0x32, 0x64, 0x63, 0x36, 0x61, 0x65, 0x37, 0x33, 0x65, 0x63, 0x37, 0x33, 0x61, 0x65, 0x32, 0x35, 0x31, 0x37, 0x61, 0x63, 0x65, 0x61, 0x32, 0x66, 0x64, 0x64, 0x39, 0x36, 0x34, 0x38, 0x37, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x63, 0x36, 0x66, 0x63, 0x36, 0x35, 0x38, 0x35, 0x33, 0x66, 0x39, 0x63, 0x63, 0x65, 0x35, 0x66, 0x38, 0x65, 0x38, 0x34, 0x34, 0x36, 0x37, 0x36, 0x33, 0x36, 0x32, 0x65, 0x31, 0x35, 0x37, 0x39, 0x30, 0x31, 0x35, 0x66, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x34, 0x37, 0x65, 0x32, 0x36, 0x30, 0x39, 0x63, 0x66, 0x61, 0x66, 0x65, 0x33, 0x36, 0x39, 0x64, 0x36, 0x36, 0x64, 0x34, 0x31, 0x35, 0x64, 0x39, 0x33, 0x39, 0x64, 0x65, 0x30, 0x35, 0x30, 0x38, 0x31, 0x61, 0x39, 0x38, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x61, 0x39, 0x32, 0x38, 0x64, 0x35, 0x32, 0x38, 0x65, 0x63, 0x31, 0x62, 0x33, 0x65, 0x32, 0x35, 0x66, 0x66, 0x63, 0x38, 0x33, 0x65, 0x32, 0x31, 0x38, 0x63, 0x31, 0x65, 0x30, 0x61, 0x66, 0x65, 0x38, 0x39, 0x32, 0x38, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x34, 0x34, 0x34, 0x66, 0x64, 0x33, 0x33, 0x37, 0x65, 0x35, 0x64, 0x37, 0x35, 0x32, 0x39, 0x33, 0x61, 0x64, 0x63, 0x66, 0x66, 0x66, 0x37, 0x30, 0x65, 0x31, 0x65, 0x61, 0x30, 0x31, 0x64, 0x62, 0x30, 0x32, 0x33, 0x32, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x38, 0x62, 0x64, 0x65, 0x63, 0x38, 0x31, 0x38, 0x65, 0x61, 0x66, 0x63, 0x36, 0x64, 0x32, 0x39, 0x39, 0x32, 0x65, 0x35, 0x65, 0x66, 0x35, 0x34, 0x61, 0x61, 0x30, 0x65, 0x31, 0x36, 0x30, 0x31, 0x65, 0x33, 0x63, 0x35, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x33, 0x64, 0x62, 0x65, 0x63, 0x34, 0x32, 0x66, 0x39, 0x32, 0x62, 0x35, 0x30, 0x66, 0x39, 0x37, 0x35, 0x31, 0x32, 0x39, 0x62, 0x39, 0x33, 0x63, 0x34, 0x63, 0x39, 0x39, 0x37, 0x33, 0x37, 0x35, 0x66, 0x30, 0x39, 0x30, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x63, 0x63, 0x32, 0x63, 0x37, 0x33, 0x32, 0x62, 0x64, 0x64, 0x39, 0x33, 0x34, 0x61, 0x66, 0x36, 0x63, 0x63, 0x64, 0x31, 0x36, 0x38, 0x34, 0x36, 0x66, 0x62, 0x32, 0x36, 0x65, 0x66, 0x38, 0x39, 0x62, 0x32, 0x61, 0x61, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x32, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x32, 0x35, 0x37, 0x36, 0x64, 0x61, 0x34, 0x64, 0x65, 0x32, 0x38, 0x33, 0x62, 0x62, 0x65, 0x38, 0x65, 0x33, 0x65, 0x65, 0x36, 0x39, 0x64, 0x64, 0x64, 0x36, 0x36, 0x65, 0x35, 0x65, 0x37, 0x31, 0x31, 0x64, 0x62, 0x33, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x33, 0x64, 0x64, 0x31, 0x30, 0x34, 0x63, 0x64, 0x37, 0x65, 0x62, 0x30, 0x34, 0x66, 0x32, 0x31, 0x39, 0x33, 0x32, 0x66, 0x64, 0x34, 0x33, 0x33, 0x65, 0x61, 0x37, 0x61, 0x66, 0x66, 0x64, 0x33, 0x39, 0x33, 0x36, 0x39, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x34, 0x66, 0x34, 0x61, 0x63, 0x35, 0x66, 0x61, 0x64, 0x37, 0x36, 0x62, 0x64, 0x63, 0x31, 0x35, 0x33, 0x37, 0x61, 0x33, 0x62, 0x33, 0x61, 0x66, 0x36, 0x34, 0x37, 0x32, 0x33, 0x31, 0x39, 0x62, 0x34, 0x31, 0x30, 0x64, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x39, 0x64, 0x36, 0x62, 0x65, 0x35, 0x37, 0x66, 0x66, 0x38, 0x33, 0x65, 0x30, 0x36, 0x35, 0x39, 0x38, 0x35, 0x36, 0x36, 0x34, 0x66, 0x31, 0x32, 0x35, 0x36, 0x34, 0x34, 0x38, 0x33, 0x66, 0x32, 0x65, 0x36, 0x30, 0x30, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x66, 0x31, 0x30, 0x34, 0x35, 0x66, 0x31, 0x39, 0x66, 0x32, 0x64, 0x33, 0x31, 0x39, 0x31, 0x38, 0x31, 0x36, 0x62, 0x31, 0x64, 0x66, 0x31, 0x38, 0x62, 0x62, 0x36, 0x65, 0x31, 0x34, 0x33, 0x35, 0x61, 0x64, 0x31, 0x62, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x62, 0x37, 0x35, 0x66, 0x62, 0x32, 0x66, 0x66, 0x39, 0x66, 0x65, 0x63, 0x62, 0x38, 0x38, 0x66, 0x38, 0x39, 0x34, 0x37, 0x36, 0x36, 0x38, 0x38, 0x65, 0x32, 0x62, 0x30, 0x30, 0x65, 0x33, 0x36, 0x37, 0x65, 0x62, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x32, 0x65, 0x38, 0x31, 0x35, 0x35, 0x35, 0x38, 0x34, 0x30, 0x32, 0x64, 0x36, 0x37, 0x66, 0x39, 0x30, 0x64, 0x36, 0x62, 0x66, 0x65, 0x36, 0x64, 0x61, 0x30, 0x62, 0x32, 0x66, 0x66, 0x66, 0x61, 0x39, 0x31, 0x34, 0x35, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x30, 0x32, 0x34, 0x63, 0x66, 0x64, 0x37, 0x34, 0x32, 0x63, 0x31, 0x65, 0x63, 0x31, 0x33, 0x63, 0x30, 0x31, 0x66, 0x65, 0x61, 0x31, 0x38, 0x64, 0x33, 0x30, 0x34, 0x32, 0x65, 0x36, 0x35, 0x66, 0x31, 0x64, 0x35, 0x64, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x37, 0x32, 0x32, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x34, 0x36, 0x62, 0x62, 0x32, 0x35, 0x34, 0x36, 0x30, 0x64, 0x64, 0x37, 0x64, 0x61, 0x65, 0x34, 0x32, 0x31, 0x31, 0x63, 0x61, 0x37, 0x66, 0x31, 0x35, 0x61, 0x64, 0x33, 0x31, 0x32, 0x66, 0x63, 0x37, 0x64, 0x63, 0x37, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x66, 0x31, 0x38, 0x63, 0x64, 0x32, 0x35, 0x32, 0x36, 0x30, 0x34, 0x30, 0x37, 0x36, 0x31, 0x34, 0x38, 0x38, 0x63, 0x35, 0x31, 0x33, 0x31, 0x37, 0x34, 0x64, 0x31, 0x65, 0x37, 0x39, 0x36, 0x33, 0x37, 0x36, 0x38, 0x62, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x31, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x32, 0x66, 0x32, 0x35, 0x62, 0x61, 0x62, 0x66, 0x34, 0x61, 0x36, 0x39, 0x30, 0x36, 0x37, 0x33, 0x65, 0x33, 0x35, 0x31, 0x39, 0x35, 0x65, 0x66, 0x61, 0x38, 0x66, 0x37, 0x39, 0x64, 0x30, 0x35, 0x38, 0x34, 0x38, 0x61, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x62, 0x31, 0x35, 0x31, 0x63, 0x63, 0x35, 0x65, 0x35, 0x37, 0x31, 0x63, 0x31, 0x37, 0x63, 0x37, 0x36, 0x35, 0x33, 0x39, 0x64, 0x62, 0x65, 0x39, 0x39, 0x36, 0x34, 0x63, 0x62, 0x62, 0x36, 0x66, 0x65, 0x35, 0x64, 0x65, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x33, 0x65, 0x65, 0x65, 0x35, 0x37, 0x63, 0x33, 0x34, 0x64, 0x36, 0x64, 0x61, 0x65, 0x39, 0x37, 0x30, 0x64, 0x38, 0x62, 0x33, 0x31, 0x31, 0x31, 0x31, 0x37, 0x63, 0x35, 0x33, 0x35, 0x38, 0x36, 0x63, 0x64, 0x33, 0x35, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x36, 0x66, 0x30, 0x63, 0x37, 0x33, 0x66, 0x64, 0x64, 0x37, 0x37, 0x63, 0x34, 0x38, 0x39, 0x37, 0x32, 0x37, 0x35, 0x31, 0x32, 0x31, 0x37, 0x34, 0x64, 0x39, 0x62, 0x35, 0x30, 0x32, 0x39, 0x36, 0x36, 0x31, 0x31, 0x63, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x31, 0x39, 0x62, 0x30, 0x34, 0x35, 0x38, 0x65, 0x33, 0x31, 0x34, 0x65, 0x32, 0x62, 0x35, 0x33, 0x62, 0x66, 0x65, 0x30, 0x30, 0x63, 0x33, 0x38, 0x34, 0x39, 0x35, 0x66, 0x64, 0x34, 0x62, 0x39, 0x66, 0x64, 0x66, 0x38, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x64, 0x62, 0x61, 0x30, 0x33, 0x31, 0x63, 0x37, 0x38, 0x66, 0x39, 0x63, 0x30, 0x39, 0x36, 0x64, 0x36, 0x32, 0x64, 0x30, 0x35, 0x61, 0x33, 0x36, 0x39, 0x65, 0x65, 0x61, 0x62, 0x30, 0x62, 0x63, 0x63, 0x63, 0x35, 0x35, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x35, 0x65, 0x33, 0x32, 0x38, 0x36, 0x36, 0x36, 0x65, 0x64, 0x35, 0x36, 0x33, 0x37, 0x31, 0x34, 0x32, 0x62, 0x33, 0x33, 0x30, 0x36, 0x62, 0x37, 0x37, 0x63, 0x63, 0x63, 0x35, 0x34, 0x36, 0x30, 0x65, 0x37, 0x32, 0x63, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x38, 0x36, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x66, 0x62, 0x62, 0x36, 0x39, 0x32, 0x35, 0x64, 0x63, 0x37, 0x35, 0x65, 0x35, 0x32, 0x63, 0x66, 0x32, 0x36, 0x38, 0x34, 0x32, 0x32, 0x34, 0x62, 0x62, 0x65, 0x30, 0x35, 0x35, 0x30, 0x66, 0x65, 0x61, 0x36, 0x38, 0x35, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x65, 0x31, 0x36, 0x33, 0x31, 0x33, 0x36, 0x34, 0x33, 0x65, 0x62, 0x63, 0x39, 0x31, 0x66, 0x66, 0x39, 0x62, 0x62, 0x31, 0x61, 0x32, 0x65, 0x31, 0x31, 0x36, 0x62, 0x38, 0x35, 0x34, 0x65, 0x61, 0x39, 0x33, 0x33, 0x61, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x61, 0x63, 0x66, 0x66, 0x64, 0x30, 0x62, 0x66, 0x64, 0x39, 0x39, 0x63, 0x33, 0x38, 0x32, 0x65, 0x37, 0x62, 0x64, 0x35, 0x36, 0x66, 0x66, 0x30, 0x65, 0x36, 0x31, 0x34, 0x34, 0x61, 0x39, 0x65, 0x35, 0x32, 0x62, 0x30, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x36, 0x61, 0x30, 0x30, 0x36, 0x65, 0x33, 0x30, 0x32, 0x38, 0x65, 0x63, 0x64, 0x34, 0x34, 0x63, 0x64, 0x62, 0x36, 0x32, 0x62, 0x61, 0x30, 0x61, 0x37, 0x37, 0x63, 0x65, 0x39, 0x34, 0x65, 0x62, 0x64, 0x39, 0x66, 0x31, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x37, 0x31, 0x31, 0x63, 0x33, 0x64, 0x64, 0x61, 0x33, 0x32, 0x33, 0x31, 0x37, 0x38, 0x38, 0x35, 0x66, 0x30, 0x61, 0x32, 0x66, 0x64, 0x38, 0x61, 0x65, 0x39, 0x32, 0x65, 0x38, 0x32, 0x30, 0x36, 0x39, 0x62, 0x30, 0x64, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x63, 0x62, 0x39, 0x36, 0x35, 0x32, 0x38, 0x31, 0x38, 0x63, 0x36, 0x66, 0x34, 0x64, 0x36, 0x37, 0x39, 0x36, 0x62, 0x30, 0x65, 0x38, 0x39, 0x34, 0x30, 0x39, 0x33, 0x30, 0x36, 0x63, 0x37, 0x39, 0x64, 0x62, 0x36, 0x33, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x30, 0x39, 0x64, 0x64, 0x30, 0x31, 0x31, 0x64, 0x31, 0x35, 0x66, 0x33, 0x31, 0x32, 0x32, 0x64, 0x39, 0x64, 0x33, 0x61, 0x32, 0x37, 0x35, 0x38, 0x38, 0x63, 0x31, 0x30, 0x64, 0x37, 0x37, 0x37, 0x34, 0x34, 0x35, 0x30, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x39, 0x37, 0x64, 0x64, 0x36, 0x36, 0x66, 0x64, 0x31, 0x31, 0x38, 0x30, 0x37, 0x31, 0x61, 0x37, 0x38, 0x63, 0x32, 0x63, 0x62, 0x33, 0x36, 0x65, 0x34, 0x30, 0x62, 0x36, 0x36, 0x35, 0x31, 0x63, 0x63, 0x38, 0x32, 0x35, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x66, 0x36, 0x37, 0x32, 0x64, 0x39, 0x37, 0x39, 0x62, 0x33, 0x36, 0x36, 0x35, 0x32, 0x66, 0x63, 0x35, 0x32, 0x38, 0x32, 0x35, 0x34, 0x37, 0x61, 0x36, 0x61, 0x36, 0x62, 0x63, 0x32, 0x31, 0x32, 0x61, 0x65, 0x34, 0x33, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x65, 0x64, 0x31, 0x36, 0x65, 0x61, 0x66, 0x35, 0x64, 0x61, 0x61, 0x62, 0x35, 0x62, 0x66, 0x30, 0x32, 0x39, 0x35, 0x65, 0x35, 0x65, 0x30, 0x37, 0x37, 0x66, 0x35, 0x39, 0x66, 0x62, 0x38, 0x32, 0x35, 0x35, 0x39, 0x30, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x63, 0x35, 0x38, 0x66, 0x36, 0x66, 0x66, 0x63, 0x34, 0x66, 0x38, 0x31, 0x30, 0x37, 0x61, 0x65, 0x36, 0x65, 0x33, 0x30, 0x33, 0x37, 0x38, 0x65, 0x34, 0x65, 0x39, 0x66, 0x39, 0x39, 0x63, 0x35, 0x37, 0x66, 0x62, 0x62, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x61, 0x35, 0x37, 0x30, 0x64, 0x63, 0x63, 0x32, 0x30, 0x39, 0x30, 0x63, 0x38, 0x36, 0x61, 0x36, 0x62, 0x33, 0x65, 0x61, 0x32, 0x39, 0x61, 0x36, 0x30, 0x38, 0x36, 0x33, 0x64, 0x64, 0x65, 0x34, 0x31, 0x66, 0x31, 0x33, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x33, 0x61, 0x33, 0x62, 0x36, 0x38, 0x65, 0x35, 0x36, 0x62, 0x30, 0x64, 0x66, 0x31, 0x38, 0x36, 0x32, 0x62, 0x39, 0x30, 0x35, 0x38, 0x36, 0x62, 0x62, 0x64, 0x33, 0x39, 0x63, 0x38, 0x34, 0x30, 0x66, 0x66, 0x31, 0x39, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x65, 0x61, 0x66, 0x31, 0x32, 0x39, 0x34, 0x34, 0x30, 0x39, 0x32, 0x64, 0x63, 0x33, 0x35, 0x39, 0x39, 0x62, 0x33, 0x39, 0x35, 0x33, 0x66, 0x61, 0x37, 0x63, 0x62, 0x31, 0x63, 0x39, 0x37, 0x36, 0x31, 0x63, 0x63, 0x32, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x31, 0x31, 0x33, 0x36, 0x32, 0x63, 0x65, 0x63, 0x38, 0x31, 0x30, 0x39, 0x38, 0x35, 0x64, 0x30, 0x65, 0x62, 0x62, 0x64, 0x37, 0x62, 0x37, 0x33, 0x34, 0x35, 0x31, 0x34, 0x34, 0x34, 0x39, 0x38, 0x35, 0x62, 0x33, 0x36, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x65, 0x38, 0x33, 0x66, 0x38, 0x30, 0x62, 0x33, 0x36, 0x37, 0x38, 0x63, 0x37, 0x61, 0x30, 0x61, 0x34, 0x65, 0x33, 0x65, 0x38, 0x63, 0x38, 0x34, 0x64, 0x63, 0x63, 0x64, 0x65, 0x30, 0x36, 0x34, 0x34, 0x32, 0x36, 0x32, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x63, 0x36, 0x37, 0x66, 0x38, 0x32, 0x37, 0x33, 0x65, 0x31, 0x62, 0x61, 0x65, 0x30, 0x38, 0x36, 0x37, 0x66, 0x64, 0x34, 0x32, 0x65, 0x38, 0x62, 0x38, 0x31, 0x39, 0x33, 0x64, 0x37, 0x32, 0x36, 0x37, 0x39, 0x64, 0x62, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x30, 0x64, 0x38, 0x35, 0x36, 0x64, 0x36, 0x32, 0x31, 0x65, 0x63, 0x31, 0x34, 0x35, 0x33, 0x30, 0x33, 0x63, 0x30, 0x61, 0x36, 0x34, 0x30, 0x30, 0x63, 0x64, 0x31, 0x37, 0x62, 0x62, 0x64, 0x36, 0x66, 0x35, 0x65, 0x61, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x36, 0x38, 0x39, 0x30, 0x36, 0x65, 0x37, 0x65, 0x64, 0x66, 0x36, 0x36, 0x34, 0x61, 0x62, 0x30, 0x64, 0x38, 0x62, 0x65, 0x33, 0x64, 0x38, 0x33, 0x65, 0x62, 0x37, 0x61, 0x62, 0x33, 0x66, 0x37, 0x66, 0x66, 0x64, 0x63, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x32, 0x38, 0x36, 0x63, 0x66, 0x62, 0x33, 0x30, 0x31, 0x34, 0x36, 0x65, 0x35, 0x66, 0x64, 0x37, 0x39, 0x30, 0x63, 0x32, 0x63, 0x38, 0x35, 0x34, 0x31, 0x35, 0x35, 0x32, 0x35, 0x37, 0x38, 0x64, 0x65, 0x33, 0x33, 0x34, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x30, 0x31, 0x63, 0x34, 0x32, 0x37, 0x63, 0x63, 0x63, 0x66, 0x66, 0x31, 0x30, 0x64, 0x65, 0x63, 0x62, 0x38, 0x36, 0x34, 0x32, 0x30, 0x32, 0x66, 0x33, 0x36, 0x66, 0x35, 0x38, 0x30, 0x38, 0x33, 0x32, 0x32, 0x61, 0x30, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x32, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x64, 0x30, 0x31, 0x39, 0x66, 0x66, 0x33, 0x36, 0x61, 0x30, 0x39, 0x31, 0x35, 0x35, 0x33, 0x34, 0x36, 0x62, 0x36, 0x39, 0x39, 0x37, 0x34, 0x38, 0x31, 0x35, 0x61, 0x31, 0x63, 0x39, 0x31, 0x32, 0x63, 0x39, 0x30, 0x61, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x66, 0x65, 0x35, 0x39, 0x63, 0x33, 0x64, 0x62, 0x62, 0x33, 0x61, 0x61, 0x37, 0x63, 0x63, 0x38, 0x63, 0x62, 0x36, 0x32, 0x34, 0x38, 0x30, 0x63, 0x36, 0x35, 0x65, 0x35, 0x36, 0x65, 0x36, 0x32, 0x30, 0x34, 0x61, 0x37, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x37, 0x37, 0x37, 0x39, 0x64, 0x38, 0x62, 0x63, 0x31, 0x63, 0x37, 0x62, 0x63, 0x65, 0x30, 0x66, 0x30, 0x31, 0x31, 0x63, 0x63, 0x62, 0x33, 0x39, 0x65, 0x66, 0x36, 0x38, 0x62, 0x38, 0x35, 0x34, 0x66, 0x38, 0x64, 0x65, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x63, 0x36, 0x35, 0x30, 0x63, 0x65, 0x64, 0x34, 0x30, 0x62, 0x62, 0x36, 0x35, 0x36, 0x34, 0x31, 0x62, 0x38, 0x65, 0x38, 0x61, 0x39, 0x32, 0x34, 0x61, 0x30, 0x33, 0x39, 0x64, 0x65, 0x66, 0x34, 0x36, 0x38, 0x35, 0x34, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x66, 0x34, 0x66, 0x34, 0x30, 0x61, 0x64, 0x39, 0x38, 0x34, 0x66, 0x62, 0x62, 0x38, 0x30, 0x39, 0x33, 0x33, 0x61, 0x65, 0x36, 0x32, 0x36, 0x65, 0x30, 0x65, 0x34, 0x32, 0x66, 0x39, 0x33, 0x33, 0x33, 0x66, 0x64, 0x64, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x32, 0x64, 0x35, 0x30, 0x35, 0x35, 0x64, 0x39, 0x36, 0x32, 0x33, 0x31, 0x33, 0x35, 0x39, 0x36, 0x31, 0x65, 0x36, 0x61, 0x62, 0x64, 0x32, 0x37, 0x33, 0x63, 0x39, 0x30, 0x64, 0x65, 0x65, 0x61, 0x31, 0x36, 0x61, 0x33, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x33, 0x35, 0x36, 0x34, 0x66, 0x35, 0x66, 0x31, 0x62, 0x61, 0x30, 0x66, 0x39, 0x34, 0x65, 0x63, 0x37, 0x62, 0x61, 0x63, 0x31, 0x36, 0x34, 0x62, 0x64, 0x64, 0x62, 0x66, 0x33, 0x31, 0x63, 0x36, 0x38, 0x38, 0x38, 0x62, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x32, 0x36, 0x62, 0x34, 0x37, 0x62, 0x64, 0x30, 0x33, 0x34, 0x62, 0x63, 0x35, 0x30, 0x38, 0x65, 0x36, 0x63, 0x34, 0x62, 0x63, 0x66, 0x64, 0x36, 0x63, 0x37, 0x64, 0x33, 0x30, 0x30, 0x33, 0x34, 0x39, 0x32, 0x35, 0x37, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x37, 0x64, 0x62, 0x61, 0x63, 0x36, 0x33, 0x36, 0x61, 0x33, 0x37, 0x37, 0x32, 0x31, 0x64, 0x66, 0x35, 0x34, 0x62, 0x30, 0x38, 0x61, 0x33, 0x32, 0x65, 0x66, 0x34, 0x39, 0x35, 0x39, 0x62, 0x35, 0x65, 0x34, 0x66, 0x66, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x66, 0x38, 0x36, 0x65, 0x64, 0x38, 0x61, 0x33, 0x31, 0x35, 0x33, 0x65, 0x63, 0x39, 0x33, 0x33, 0x37, 0x38, 0x36, 0x61, 0x30, 0x32, 0x61, 0x63, 0x30, 0x39, 0x30, 0x33, 0x30, 0x31, 0x38, 0x35, 0x35, 0x65, 0x35, 0x37, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x64, 0x32, 0x37, 0x32, 0x38, 0x64, 0x66, 0x62, 0x38, 0x62, 0x64, 0x62, 0x66, 0x33, 0x62, 0x66, 0x37, 0x33, 0x35, 0x39, 0x38, 0x61, 0x36, 0x65, 0x31, 0x33, 0x65, 0x61, 0x66, 0x34, 0x33, 0x30, 0x35, 0x32, 0x65, 0x61, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x62, 0x31, 0x36, 0x66, 0x30, 0x62, 0x38, 0x62, 0x33, 0x34, 0x64, 0x66, 0x66, 0x33, 0x38, 0x30, 0x34, 0x66, 0x36, 0x39, 0x65, 0x32, 0x31, 0x36, 0x38, 0x61, 0x34, 0x66, 0x37, 0x62, 0x32, 0x34, 0x64, 0x31, 0x30, 0x34, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x64, 0x62, 0x31, 0x34, 0x35, 0x39, 0x62, 0x62, 0x30, 0x30, 0x38, 0x31, 0x32, 0x65, 0x61, 0x36, 0x37, 0x65, 0x63, 0x62, 0x33, 0x64, 0x63, 0x31, 0x38, 0x39, 0x62, 0x37, 0x32, 0x31, 0x38, 0x37, 0x64, 0x39, 0x63, 0x35, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x38, 0x38, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x33, 0x61, 0x39, 0x65, 0x65, 0x37, 0x31, 0x66, 0x37, 0x32, 0x39, 0x66, 0x32, 0x33, 0x36, 0x63, 0x62, 0x61, 0x33, 0x38, 0x36, 0x37, 0x62, 0x34, 0x64, 0x37, 0x39, 0x64, 0x38, 0x63, 0x65, 0x65, 0x65, 0x32, 0x35, 0x64, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x37, 0x37, 0x63, 0x33, 0x31, 0x66, 0x64, 0x39, 0x63, 0x62, 0x37, 0x32, 0x30, 0x30, 0x37, 0x35, 0x64, 0x63, 0x61, 0x34, 0x39, 0x66, 0x31, 0x61, 0x62, 0x63, 0x63, 0x64, 0x35, 0x39, 0x65, 0x63, 0x33, 0x33, 0x66, 0x37, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x38, 0x39, 0x34, 0x34, 0x38, 0x33, 0x31, 0x36, 0x63, 0x63, 0x66, 0x31, 0x34, 0x65, 0x64, 0x38, 0x36, 0x64, 0x66, 0x38, 0x65, 0x32, 0x66, 0x34, 0x37, 0x38, 0x64, 0x63, 0x36, 0x33, 0x63, 0x34, 0x33, 0x33, 0x38, 0x33, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x37, 0x39, 0x63, 0x37, 0x64, 0x33, 0x35, 0x35, 0x63, 0x32, 0x38, 0x38, 0x30, 0x33, 0x39, 0x32, 0x61, 0x61, 0x64, 0x31, 0x61, 0x61, 0x32, 0x31, 0x65, 0x65, 0x38, 0x36, 0x37, 0x63, 0x33, 0x62, 0x33, 0x35, 0x30, 0x37, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x62, 0x35, 0x65, 0x32, 0x38, 0x39, 0x34, 0x35, 0x62, 0x62, 0x32, 0x39, 0x36, 0x39, 0x66, 0x39, 0x63, 0x36, 0x34, 0x63, 0x36, 0x33, 0x63, 0x63, 0x30, 0x35, 0x62, 0x36, 0x66, 0x31, 0x66, 0x38, 0x64, 0x36, 0x66, 0x34, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x32, 0x32, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x32, 0x33, 0x30, 0x33, 0x33, 0x34, 0x31, 0x65, 0x31, 0x65, 0x31, 0x65, 0x62, 0x35, 0x65, 0x38, 0x31, 0x38, 0x39, 0x62, 0x64, 0x65, 0x30, 0x33, 0x66, 0x37, 0x33, 0x61, 0x36, 0x30, 0x61, 0x32, 0x61, 0x35, 0x34, 0x38, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x64, 0x38, 0x31, 0x30, 0x37, 0x34, 0x64, 0x62, 0x35, 0x61, 0x65, 0x31, 0x39, 0x37, 0x64, 0x32, 0x62, 0x62, 0x31, 0x33, 0x37, 0x33, 0x61, 0x62, 0x38, 0x30, 0x61, 0x38, 0x37, 0x64, 0x31, 0x32, 0x31, 0x63, 0x34, 0x62, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x32, 0x63, 0x39, 0x66, 0x65, 0x62, 0x66, 0x34, 0x32, 0x66, 0x36, 0x36, 0x63, 0x34, 0x37, 0x38, 0x37, 0x62, 0x66, 0x61, 0x37, 0x65, 0x62, 0x31, 0x37, 0x63, 0x66, 0x35, 0x33, 0x33, 0x33, 0x62, 0x62, 0x61, 0x35, 0x30, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x36, 0x34, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x38, 0x31, 0x36, 0x61, 0x61, 0x63, 0x30, 0x65, 0x64, 0x65, 0x30, 0x64, 0x32, 0x64, 0x33, 0x63, 0x64, 0x34, 0x34, 0x32, 0x64, 0x61, 0x37, 0x39, 0x65, 0x30, 0x36, 0x33, 0x38, 0x38, 0x30, 0x66, 0x30, 0x66, 0x31, 0x64, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x61, 0x63, 0x39, 0x31, 0x63, 0x31, 0x65, 0x38, 0x35, 0x39, 0x64, 0x35, 0x65, 0x35, 0x37, 0x65, 0x64, 0x33, 0x30, 0x38, 0x34, 0x62, 0x35, 0x30, 0x32, 0x30, 0x30, 0x66, 0x39, 0x37, 0x36, 0x36, 0x65, 0x32, 0x63, 0x35, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x63, 0x32, 0x66, 0x64, 0x65, 0x32, 0x62, 0x36, 0x61, 0x61, 0x62, 0x62, 0x38, 0x30, 0x65, 0x35, 0x61, 0x65, 0x61, 0x32, 0x62, 0x39, 0x34, 0x39, 0x61, 0x32, 0x31, 0x37, 0x66, 0x33, 0x63, 0x62, 0x30, 0x39, 0x32, 0x32, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x31, 0x34, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x61, 0x62, 0x34, 0x36, 0x61, 0x35, 0x39, 0x30, 0x32, 0x30, 0x38, 0x30, 0x36, 0x34, 0x36, 0x66, 0x62, 0x66, 0x39, 0x35, 0x34, 0x32, 0x30, 0x34, 0x32, 0x30, 0x34, 0x61, 0x65, 0x38, 0x38, 0x34, 0x30, 0x34, 0x38, 0x32, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x34, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x66, 0x34, 0x32, 0x33, 0x34, 0x33, 0x30, 0x31, 0x39, 0x62, 0x30, 0x62, 0x30, 0x63, 0x36, 0x62, 0x66, 0x32, 0x36, 0x30, 0x62, 0x31, 0x37, 0x33, 0x61, 0x66, 0x61, 0x62, 0x37, 0x65, 0x34, 0x35, 0x62, 0x39, 0x64, 0x36, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x31, 0x66, 0x36, 0x30, 0x34, 0x30, 0x62, 0x34, 0x65, 0x33, 0x65, 0x35, 0x30, 0x64, 0x63, 0x66, 0x33, 0x35, 0x35, 0x33, 0x66, 0x31, 0x38, 0x32, 0x63, 0x64, 0x39, 0x37, 0x61, 0x39, 0x30, 0x36, 0x33, 0x30, 0x62, 0x37, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x37, 0x36, 0x32, 0x31, 0x36, 0x36, 0x64, 0x64, 0x31, 0x31, 0x31, 0x38, 0x65, 0x38, 0x34, 0x33, 0x36, 0x39, 0x66, 0x38, 0x30, 0x34, 0x63, 0x37, 0x35, 0x66, 0x39, 0x63, 0x64, 0x36, 0x35, 0x37, 0x62, 0x66, 0x37, 0x33, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x36, 0x64, 0x33, 0x66, 0x31, 0x35, 0x36, 0x32, 0x35, 0x31, 0x62, 0x37, 0x32, 0x63, 0x30, 0x63, 0x63, 0x66, 0x34, 0x62, 0x34, 0x37, 0x61, 0x33, 0x33, 0x39, 0x33, 0x63, 0x62, 0x64, 0x36, 0x66, 0x34, 0x39, 0x61, 0x39, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x65, 0x62, 0x34, 0x32, 0x32, 0x39, 0x35, 0x65, 0x39, 0x63, 0x61, 0x64, 0x65, 0x61, 0x66, 0x32, 0x61, 0x66, 0x31, 0x32, 0x64, 0x65, 0x64, 0x65, 0x38, 0x61, 0x38, 0x64, 0x35, 0x33, 0x63, 0x35, 0x37, 0x39, 0x63, 0x34, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x39, 0x33, 0x37, 0x31, 0x62, 0x33, 0x30, 0x63, 0x34, 0x63, 0x38, 0x34, 0x34, 0x65, 0x35, 0x39, 0x65, 0x30, 0x33, 0x65, 0x39, 0x32, 0x34, 0x62, 0x65, 0x36, 0x30, 0x36, 0x61, 0x39, 0x33, 0x38, 0x64, 0x31, 0x64, 0x33, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x64, 0x33, 0x39, 0x33, 0x33, 0x34, 0x61, 0x63, 0x37, 0x65, 0x61, 0x63, 0x37, 0x39, 0x37, 0x32, 0x35, 0x37, 0x61, 0x62, 0x65, 0x33, 0x37, 0x33, 0x36, 0x31, 0x39, 0x35, 0x66, 0x35, 0x62, 0x34, 0x62, 0x35, 0x63, 0x65, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x34, 0x34, 0x33, 0x35, 0x37, 0x65, 0x30, 0x31, 0x37, 0x65, 0x32, 0x34, 0x34, 0x66, 0x34, 0x37, 0x36, 0x39, 0x33, 0x31, 0x63, 0x37, 0x62, 0x38, 0x31, 0x38, 0x39, 0x65, 0x66, 0x65, 0x65, 0x38, 0x30, 0x61, 0x35, 0x64, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x61, 0x37, 0x62, 0x37, 0x31, 0x37, 0x64, 0x39, 0x62, 0x63, 0x38, 0x37, 0x39, 0x33, 0x62, 0x30, 0x34, 0x65, 0x30, 0x35, 0x31, 0x61, 0x38, 0x64, 0x32, 0x33, 0x65, 0x31, 0x36, 0x34, 0x30, 0x66, 0x35, 0x62, 0x61, 0x35, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x38, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x65, 0x34, 0x61, 0x32, 0x62, 0x36, 0x30, 0x63, 0x66, 0x34, 0x38, 0x65, 0x38, 0x62, 0x61, 0x66, 0x32, 0x62, 0x37, 0x37, 0x37, 0x65, 0x31, 0x37, 0x35, 0x61, 0x35, 0x62, 0x31, 0x65, 0x34, 0x64, 0x30, 0x63, 0x32, 0x64, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x31, 0x64, 0x32, 0x64, 0x32, 0x64, 0x31, 0x64, 0x35, 0x32, 0x30, 0x33, 0x30, 0x34, 0x62, 0x36, 0x32, 0x30, 0x38, 0x38, 0x34, 0x39, 0x35, 0x37, 0x30, 0x34, 0x33, 0x37, 0x65, 0x62, 0x33, 0x30, 0x39, 0x31, 0x62, 0x62, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x30, 0x34, 0x37, 0x64, 0x63, 0x38, 0x61, 0x63, 0x39, 0x30, 0x38, 0x33, 0x64, 0x39, 0x30, 0x36, 0x37, 0x32, 0x65, 0x38, 0x62, 0x33, 0x34, 0x37, 0x33, 0x63, 0x31, 0x30, 0x30, 0x63, 0x63, 0x64, 0x32, 0x37, 0x38, 0x33, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x66, 0x65, 0x31, 0x37, 0x34, 0x63, 0x62, 0x66, 0x35, 0x32, 0x36, 0x36, 0x35, 0x30, 0x65, 0x30, 0x63, 0x64, 0x30, 0x30, 0x39, 0x62, 0x64, 0x36, 0x31, 0x32, 0x36, 0x35, 0x30, 0x32, 0x63, 0x65, 0x38, 0x65, 0x36, 0x38, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x64, 0x66, 0x32, 0x33, 0x66, 0x36, 0x65, 0x61, 0x30, 0x34, 0x62, 0x65, 0x63, 0x66, 0x34, 0x61, 0x62, 0x37, 0x30, 0x31, 0x37, 0x34, 0x38, 0x64, 0x63, 0x30, 0x39, 0x36, 0x33, 0x31, 0x38, 0x34, 0x35, 0x35, 0x35, 0x63, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x31, 0x37, 0x30, 0x64, 0x62, 0x61, 0x61, 0x64, 0x62, 0x33, 0x64, 0x65, 0x65, 0x36, 0x31, 0x39, 0x38, 0x65, 0x61, 0x35, 0x34, 0x34, 0x62, 0x61, 0x65, 0x63, 0x39, 0x33, 0x32, 0x35, 0x31, 0x38, 0x36, 0x30, 0x66, 0x64, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x62, 0x65, 0x61, 0x63, 0x66, 0x63, 0x32, 0x39, 0x63, 0x66, 0x65, 0x39, 0x33, 0x34, 0x30, 0x32, 0x64, 0x62, 0x33, 0x63, 0x34, 0x31, 0x64, 0x39, 0x39, 0x61, 0x62, 0x37, 0x35, 0x39, 0x36, 0x36, 0x32, 0x65, 0x37, 0x33, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x35, 0x33, 0x30, 0x35, 0x62, 0x37, 0x38, 0x37, 0x33, 0x32, 0x32, 0x65, 0x32, 0x35, 0x64, 0x63, 0x36, 0x61, 0x64, 0x30, 0x63, 0x65, 0x66, 0x65, 0x36, 0x63, 0x36, 0x66, 0x33, 0x33, 0x34, 0x36, 0x37, 0x38, 0x64, 0x35, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x34, 0x35, 0x37, 0x66, 0x38, 0x65, 0x66, 0x38, 0x65, 0x32, 0x62, 0x64, 0x63, 0x33, 0x36, 0x32, 0x31, 0x39, 0x36, 0x62, 0x39, 0x61, 0x39, 0x31, 0x32, 0x35, 0x64, 0x61, 0x30, 0x39, 0x63, 0x36, 0x37, 0x65, 0x33, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x32, 0x38, 0x30, 0x32, 0x66, 0x33, 0x36, 0x64, 0x30, 0x30, 0x32, 0x35, 0x30, 0x66, 0x61, 0x62, 0x35, 0x33, 0x61, 0x64, 0x62, 0x63, 0x64, 0x36, 0x39, 0x36, 0x66, 0x30, 0x31, 0x37, 0x36, 0x66, 0x36, 0x33, 0x38, 0x61, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x39, 0x33, 0x33, 0x34, 0x63, 0x32, 0x62, 0x36, 0x39, 0x35, 0x63, 0x38, 0x65, 0x65, 0x30, 0x37, 0x39, 0x34, 0x62, 0x64, 0x38, 0x36, 0x34, 0x32, 0x31, 0x37, 0x66, 0x62, 0x39, 0x66, 0x64, 0x38, 0x66, 0x38, 0x62, 0x31, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x38, 0x63, 0x66, 0x34, 0x65, 0x36, 0x32, 0x37, 0x36, 0x39, 0x38, 0x63, 0x35, 0x64, 0x35, 0x37, 0x38, 0x38, 0x61, 0x62, 0x62, 0x37, 0x38, 0x38, 0x30, 0x34, 0x31, 0x37, 0x65, 0x37, 0x35, 0x30, 0x32, 0x33, 0x31, 0x33, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x34, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x32, 0x39, 0x65, 0x62, 0x33, 0x62, 0x61, 0x66, 0x34, 0x33, 0x34, 0x35, 0x64, 0x36, 0x30, 0x30, 0x63, 0x65, 0x64, 0x34, 0x30, 0x65, 0x36, 0x65, 0x39, 0x39, 0x37, 0x35, 0x36, 0x35, 0x36, 0x66, 0x31, 0x31, 0x33, 0x37, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x64, 0x64, 0x35, 0x34, 0x39, 0x39, 0x64, 0x61, 0x65, 0x62, 0x32, 0x35, 0x30, 0x37, 0x66, 0x62, 0x32, 0x64, 0x65, 0x31, 0x32, 0x32, 0x39, 0x37, 0x37, 0x33, 0x31, 0x64, 0x34, 0x63, 0x37, 0x32, 0x62, 0x31, 0x36, 0x62, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x63, 0x32, 0x35, 0x31, 0x36, 0x61, 0x37, 0x63, 0x64, 0x62, 0x30, 0x39, 0x61, 0x36, 0x32, 0x37, 0x36, 0x64, 0x37, 0x32, 0x39, 0x37, 0x64, 0x33, 0x30, 0x66, 0x35, 0x61, 0x34, 0x64, 0x62, 0x31, 0x65, 0x38, 0x34, 0x62, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x32, 0x63, 0x65, 0x64, 0x38, 0x64, 0x63, 0x30, 0x64, 0x63, 0x39, 0x65, 0x38, 0x39, 0x39, 0x65, 0x65, 0x34, 0x36, 0x66, 0x37, 0x39, 0x36, 0x32, 0x33, 0x33, 0x33, 0x33, 0x31, 0x35, 0x66, 0x33, 0x66, 0x35, 0x35, 0x65, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x38, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x31, 0x65, 0x34, 0x33, 0x61, 0x34, 0x35, 0x31, 0x37, 0x37, 0x61, 0x64, 0x35, 0x31, 0x63, 0x62, 0x65, 0x30, 0x66, 0x37, 0x32, 0x31, 0x38, 0x34, 0x61, 0x35, 0x63, 0x62, 0x35, 0x30, 0x33, 0x39, 0x31, 0x37, 0x32, 0x38, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x62, 0x35, 0x36, 0x36, 0x63, 0x39, 0x34, 0x62, 0x62, 0x62, 0x61, 0x34, 0x65, 0x33, 0x63, 0x62, 0x36, 0x37, 0x63, 0x64, 0x64, 0x61, 0x37, 0x64, 0x35, 0x66, 0x61, 0x64, 0x37, 0x31, 0x33, 0x31, 0x35, 0x33, 0x39, 0x31, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x62, 0x65, 0x35, 0x62, 0x34, 0x36, 0x32, 0x39, 0x61, 0x65, 0x66, 0x62, 0x62, 0x63, 0x61, 0x62, 0x39, 0x64, 0x65, 0x32, 0x36, 0x64, 0x33, 0x39, 0x35, 0x37, 0x36, 0x63, 0x62, 0x37, 0x66, 0x36, 0x39, 0x31, 0x64, 0x37, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x35, 0x33, 0x36, 0x37, 0x39, 0x36, 0x30, 0x33, 0x30, 0x34, 0x62, 0x65, 0x65, 0x65, 0x33, 0x34, 0x35, 0x39, 0x31, 0x31, 0x31, 0x38, 0x65, 0x39, 0x61, 0x63, 0x32, 0x64, 0x31, 0x33, 0x35, 0x38, 0x64, 0x38, 0x30, 0x32, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x64, 0x35, 0x62, 0x38, 0x62, 0x36, 0x32, 0x64, 0x30, 0x30, 0x32, 0x64, 0x65, 0x66, 0x39, 0x32, 0x34, 0x31, 0x33, 0x37, 0x31, 0x30, 0x64, 0x31, 0x33, 0x62, 0x36, 0x66, 0x66, 0x38, 0x64, 0x34, 0x66, 0x63, 0x37, 0x64, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x33, 0x62, 0x37, 0x32, 0x63, 0x35, 0x62, 0x64, 0x37, 0x31, 0x64, 0x34, 0x38, 0x31, 0x34, 0x65, 0x38, 0x38, 0x61, 0x36, 0x32, 0x33, 0x32, 0x31, 0x61, 0x39, 0x33, 0x64, 0x34, 0x30, 0x31, 0x31, 0x65, 0x33, 0x35, 0x37, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x38, 0x38, 0x38, 0x39, 0x35, 0x61, 0x63, 0x39, 0x66, 0x62, 0x61, 0x66, 0x65, 0x63, 0x30, 0x31, 0x32, 0x30, 0x39, 0x32, 0x64, 0x63, 0x30, 0x35, 0x63, 0x30, 0x63, 0x33, 0x30, 0x32, 0x64, 0x39, 0x30, 0x37, 0x34, 0x30, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x32, 0x31, 0x65, 0x38, 0x35, 0x61, 0x38, 0x38, 0x31, 0x34, 0x66, 0x63, 0x65, 0x31, 0x65, 0x38, 0x32, 0x61, 0x34, 0x31, 0x61, 0x62, 0x64, 0x31, 0x64, 0x33, 0x62, 0x32, 0x64, 0x61, 0x64, 0x32, 0x66, 0x61, 0x65, 0x66, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x65, 0x65, 0x39, 0x66, 0x35, 0x34, 0x64, 0x34, 0x64, 0x64, 0x63, 0x38, 0x34, 0x64, 0x36, 0x37, 0x30, 0x65, 0x66, 0x66, 0x31, 0x31, 0x65, 0x35, 0x34, 0x61, 0x36, 0x35, 0x39, 0x66, 0x64, 0x37, 0x32, 0x66, 0x34, 0x34, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x33, 0x63, 0x36, 0x66, 0x37, 0x30, 0x65, 0x66, 0x62, 0x36, 0x62, 0x31, 0x64, 0x30, 0x66, 0x32, 0x62, 0x62, 0x63, 0x35, 0x37, 0x65, 0x65, 0x62, 0x63, 0x64, 0x37, 0x30, 0x36, 0x31, 0x37, 0x63, 0x36, 0x63, 0x65, 0x36, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x33, 0x34, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x63, 0x63, 0x37, 0x63, 0x65, 0x36, 0x61, 0x38, 0x34, 0x38, 0x35, 0x38, 0x39, 0x35, 0x61, 0x33, 0x31, 0x39, 0x39, 0x65, 0x31, 0x36, 0x34, 0x38, 0x31, 0x66, 0x37, 0x32, 0x65, 0x31, 0x66, 0x37, 0x36, 0x32, 0x64, 0x65, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x61, 0x37, 0x32, 0x30, 0x39, 0x62, 0x38, 0x30, 0x63, 0x66, 0x36, 0x30, 0x64, 0x62, 0x36, 0x32, 0x66, 0x35, 0x37, 0x64, 0x30, 0x61, 0x35, 0x64, 0x37, 0x64, 0x35, 0x32, 0x31, 0x61, 0x36, 0x39, 0x36, 0x30, 0x36, 0x36, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x31, 0x34, 0x64, 0x30, 0x30, 0x65, 0x64, 0x64, 0x37, 0x31, 0x30, 0x38, 0x61, 0x36, 0x62, 0x65, 0x38, 0x33, 0x39, 0x61, 0x36, 0x33, 0x38, 0x64, 0x62, 0x32, 0x34, 0x31, 0x35, 0x34, 0x31, 0x38, 0x31, 0x37, 0x34, 0x31, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x36, 0x33, 0x37, 0x37, 0x66, 0x38, 0x36, 0x34, 0x62, 0x30, 0x31, 0x34, 0x33, 0x66, 0x32, 0x38, 0x32, 0x31, 0x37, 0x34, 0x61, 0x38, 0x39, 0x32, 0x61, 0x37, 0x33, 0x64, 0x33, 0x65, 0x63, 0x38, 0x65, 0x63, 0x36, 0x31, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x32, 0x36, 0x35, 0x37, 0x33, 0x64, 0x38, 0x37, 0x62, 0x30, 0x31, 0x37, 0x35, 0x61, 0x35, 0x32, 0x39, 0x35, 0x66, 0x31, 0x64, 0x64, 0x30, 0x37, 0x63, 0x35, 0x37, 0x35, 0x63, 0x66, 0x38, 0x63, 0x66, 0x61, 0x31, 0x35, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x31, 0x32, 0x33, 0x64, 0x37, 0x64, 0x61, 0x36, 0x64, 0x31, 0x65, 0x36, 0x66, 0x61, 0x63, 0x32, 0x64, 0x63, 0x61, 0x64, 0x64, 0x32, 0x37, 0x30, 0x32, 0x39, 0x32, 0x34, 0x30, 0x62, 0x62, 0x33, 0x39, 0x30, 0x35, 0x32, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x35, 0x61, 0x38, 0x64, 0x33, 0x63, 0x36, 0x34, 0x37, 0x38, 0x62, 0x36, 0x39, 0x66, 0x36, 0x35, 0x37, 0x64, 0x62, 0x33, 0x38, 0x33, 0x37, 0x61, 0x32, 0x35, 0x37, 0x35, 0x65, 0x66, 0x38, 0x65, 0x31, 0x64, 0x66, 0x39, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x38, 0x38, 0x32, 0x65, 0x61, 0x63, 0x65, 0x64, 0x64, 0x30, 0x65, 0x66, 0x66, 0x32, 0x36, 0x33, 0x35, 0x31, 0x31, 0x62, 0x33, 0x31, 0x32, 0x61, 0x64, 0x62, 0x62, 0x63, 0x35, 0x39, 0x63, 0x36, 0x62, 0x38, 0x62, 0x32, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x34, 0x33, 0x62, 0x64, 0x32, 0x33, 0x39, 0x31, 0x30, 0x32, 0x35, 0x35, 0x38, 0x31, 0x64, 0x38, 0x39, 0x35, 0x36, 0x63, 0x65, 0x34, 0x32, 0x61, 0x30, 0x37, 0x32, 0x35, 0x37, 0x39, 0x63, 0x62, 0x62, 0x66, 0x63, 0x62, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x66, 0x65, 0x61, 0x30, 0x34, 0x37, 0x33, 0x37, 0x32, 0x32, 0x63, 0x62, 0x37, 0x66, 0x30, 0x65, 0x30, 0x65, 0x38, 0x36, 0x62, 0x39, 0x65, 0x31, 0x31, 0x38, 0x38, 0x33, 0x62, 0x66, 0x34, 0x32, 0x38, 0x64, 0x38, 0x64, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x32, 0x62, 0x31, 0x63, 0x34, 0x37, 0x32, 0x35, 0x61, 0x31, 0x38, 0x37, 0x35, 0x34, 0x34, 0x39, 0x65, 0x39, 0x38, 0x66, 0x39, 0x37, 0x30, 0x65, 0x62, 0x33, 0x65, 0x35, 0x34, 0x30, 0x36, 0x32, 0x64, 0x31, 0x35, 0x38, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x66, 0x34, 0x61, 0x66, 0x33, 0x61, 0x66, 0x30, 0x61, 0x65, 0x64, 0x65, 0x35, 0x66, 0x61, 0x66, 0x64, 0x63, 0x34, 0x32, 0x61, 0x30, 0x38, 0x31, 0x65, 0x63, 0x63, 0x31, 0x66, 0x38, 0x39, 0x65, 0x33, 0x63, 0x63, 0x66, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x34, 0x37, 0x36, 0x38, 0x66, 0x64, 0x37, 0x31, 0x65, 0x32, 0x64, 0x62, 0x32, 0x63, 0x62, 0x65, 0x37, 0x66, 0x61, 0x30, 0x35, 0x30, 0x34, 0x38, 0x33, 0x63, 0x32, 0x37, 0x62, 0x34, 0x65, 0x62, 0x39, 0x33, 0x31, 0x64, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x66, 0x37, 0x63, 0x34, 0x31, 0x65, 0x30, 0x37, 0x37, 0x32, 0x39, 0x64, 0x66, 0x61, 0x36, 0x64, 0x66, 0x63, 0x36, 0x34, 0x63, 0x34, 0x34, 0x32, 0x33, 0x31, 0x36, 0x30, 0x61, 0x32, 0x32, 0x63, 0x36, 0x30, 0x39, 0x66, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x34, 0x34, 0x63, 0x38, 0x61, 0x36, 0x39, 0x66, 0x66, 0x32, 0x63, 0x61, 0x31, 0x32, 0x34, 0x39, 0x36, 0x39, 0x30, 0x63, 0x31, 0x32, 0x32, 0x39, 0x63, 0x37, 0x31, 0x39, 0x32, 0x66, 0x33, 0x36, 0x32, 0x35, 0x31, 0x30, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x65, 0x36, 0x34, 0x65, 0x38, 0x35, 0x33, 0x62, 0x61, 0x30, 0x61, 0x35, 0x31, 0x32, 0x38, 0x32, 0x63, 0x62, 0x38, 0x64, 0x62, 0x35, 0x32, 0x65, 0x34, 0x31, 0x36, 0x31, 0x35, 0x65, 0x37, 0x63, 0x39, 0x66, 0x37, 0x33, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x33, 0x66, 0x39, 0x33, 0x61, 0x66, 0x33, 0x30, 0x65, 0x38, 0x64, 0x37, 0x36, 0x36, 0x37, 0x33, 0x38, 0x31, 0x62, 0x32, 0x62, 0x39, 0x35, 0x62, 0x63, 0x31, 0x61, 0x36, 0x39, 0x39, 0x64, 0x35, 0x65, 0x33, 0x65, 0x31, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x32, 0x30, 0x65, 0x35, 0x62, 0x35, 0x63, 0x65, 0x65, 0x37, 0x63, 0x64, 0x31, 0x66, 0x35, 0x35, 0x31, 0x35, 0x62, 0x61, 0x63, 0x65, 0x33, 0x62, 0x66, 0x34, 0x66, 0x37, 0x37, 0x66, 0x66, 0x64, 0x65, 0x35, 0x63, 0x63, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x34, 0x38, 0x35, 0x39, 0x36, 0x66, 0x39, 0x31, 0x63, 0x30, 0x39, 0x62, 0x61, 0x61, 0x33, 0x30, 0x62, 0x63, 0x39, 0x36, 0x31, 0x30, 0x36, 0x61, 0x32, 0x64, 0x33, 0x37, 0x62, 0x35, 0x37, 0x30, 0x35, 0x65, 0x35, 0x64, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x63, 0x61, 0x32, 0x34, 0x64, 0x38, 0x63, 0x35, 0x36, 0x64, 0x36, 0x65, 0x32, 0x63, 0x30, 0x37, 0x64, 0x62, 0x30, 0x38, 0x36, 0x65, 0x63, 0x30, 0x37, 0x65, 0x35, 0x38, 0x35, 0x62, 0x65, 0x32, 0x36, 0x37, 0x61, 0x63, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x37, 0x62, 0x62, 0x38, 0x65, 0x32, 0x31, 0x31, 0x38, 0x62, 0x62, 0x63, 0x64, 0x35, 0x39, 0x30, 0x32, 0x37, 0x36, 0x36, 0x36, 0x65, 0x65, 0x64, 0x66, 0x36, 0x39, 0x34, 0x33, 0x65, 0x63, 0x39, 0x66, 0x38, 0x38, 0x30, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x65, 0x36, 0x35, 0x39, 0x65, 0x62, 0x33, 0x62, 0x63, 0x34, 0x36, 0x38, 0x35, 0x32, 0x66, 0x61, 0x38, 0x36, 0x66, 0x61, 0x63, 0x34, 0x65, 0x32, 0x31, 0x63, 0x37, 0x36, 0x38, 0x64, 0x35, 0x30, 0x33, 0x38, 0x38, 0x39, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x65, 0x30, 0x65, 0x64, 0x35, 0x34, 0x66, 0x33, 0x62, 0x37, 0x36, 0x61, 0x65, 0x30, 0x36, 0x33, 0x36, 0x31, 0x37, 0x36, 0x65, 0x30, 0x37, 0x34, 0x32, 0x30, 0x38, 0x31, 0x35, 0x61, 0x30, 0x32, 0x31, 0x37, 0x33, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x36, 0x63, 0x64, 0x32, 0x33, 0x37, 0x62, 0x36, 0x33, 0x65, 0x65, 0x61, 0x34, 0x33, 0x38, 0x63, 0x38, 0x65, 0x33, 0x62, 0x36, 0x35, 0x38, 0x35, 0x66, 0x36, 0x37, 0x39, 0x65, 0x34, 0x38, 0x36, 0x30, 0x38, 0x33, 0x32, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x37, 0x36, 0x30, 0x64, 0x34, 0x38, 0x37, 0x37, 0x65, 0x36, 0x61, 0x36, 0x32, 0x37, 0x63, 0x31, 0x63, 0x39, 0x36, 0x37, 0x62, 0x65, 0x65, 0x34, 0x35, 0x31, 0x61, 0x38, 0x35, 0x30, 0x37, 0x64, 0x64, 0x64, 0x64, 0x62, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x33, 0x30, 0x34, 0x34, 0x36, 0x37, 0x30, 0x66, 0x61, 0x65, 0x66, 0x66, 0x30, 0x30, 0x61, 0x35, 0x35, 0x62, 0x35, 0x61, 0x65, 0x30, 0x35, 0x31, 0x65, 0x62, 0x37, 0x62, 0x65, 0x38, 0x37, 0x30, 0x62, 0x31, 0x31, 0x36, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x33, 0x63, 0x30, 0x36, 0x39, 0x32, 0x38, 0x66, 0x31, 0x39, 0x64, 0x30, 0x61, 0x39, 0x35, 0x36, 0x63, 0x63, 0x32, 0x38, 0x38, 0x36, 0x36, 0x62, 0x66, 0x36, 0x63, 0x38, 0x64, 0x38, 0x66, 0x34, 0x31, 0x39, 0x31, 0x61, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x32, 0x64, 0x63, 0x31, 0x33, 0x36, 0x34, 0x63, 0x63, 0x66, 0x36, 0x64, 0x66, 0x38, 0x35, 0x63, 0x34, 0x33, 0x32, 0x36, 0x38, 0x65, 0x65, 0x31, 0x38, 0x32, 0x35, 0x35, 0x34, 0x64, 0x61, 0x65, 0x36, 0x39, 0x32, 0x65, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x33, 0x36, 0x38, 0x62, 0x63, 0x31, 0x34, 0x32, 0x30, 0x62, 0x33, 0x35, 0x65, 0x66, 0x64, 0x61, 0x39, 0x35, 0x66, 0x61, 0x66, 0x62, 0x63, 0x37, 0x33, 0x30, 0x39, 0x30, 0x35, 0x32, 0x31, 0x39, 0x31, 0x36, 0x61, 0x61, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x62, 0x39, 0x32, 0x64, 0x33, 0x30, 0x62, 0x66, 0x30, 0x31, 0x66, 0x66, 0x39, 0x61, 0x31, 0x39, 0x30, 0x31, 0x36, 0x36, 0x36, 0x63, 0x35, 0x35, 0x37, 0x33, 0x35, 0x33, 0x32, 0x62, 0x66, 0x61, 0x30, 0x37, 0x65, 0x65, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x32, 0x35, 0x62, 0x39, 0x61, 0x37, 0x30, 0x33, 0x32, 0x36, 0x37, 0x39, 0x62, 0x31, 0x31, 0x33, 0x35, 0x38, 0x38, 0x65, 0x64, 0x35, 0x32, 0x63, 0x31, 0x33, 0x37, 0x64, 0x31, 0x61, 0x30, 0x35, 0x33, 0x61, 0x31, 0x65, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x31, 0x33, 0x34, 0x63, 0x62, 0x66, 0x66, 0x38, 0x38, 0x62, 0x66, 0x61, 0x64, 0x63, 0x34, 0x36, 0x36, 0x62, 0x35, 0x32, 0x65, 0x63, 0x65, 0x61, 0x61, 0x37, 0x39, 0x38, 0x35, 0x37, 0x38, 0x39, 0x31, 0x64, 0x38, 0x33, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x62, 0x31, 0x61, 0x33, 0x30, 0x36, 0x63, 0x62, 0x34, 0x33, 0x31, 0x32, 0x64, 0x66, 0x36, 0x36, 0x34, 0x38, 0x32, 0x63, 0x32, 0x63, 0x61, 0x65, 0x37, 0x32, 0x64, 0x31, 0x65, 0x30, 0x36, 0x31, 0x34, 0x30, 0x30, 0x66, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x39, 0x31, 0x64, 0x35, 0x38, 0x35, 0x62, 0x38, 0x39, 0x39, 0x33, 0x36, 0x62, 0x32, 0x35, 0x64, 0x32, 0x39, 0x38, 0x66, 0x39, 0x64, 0x33, 0x35, 0x66, 0x39, 0x66, 0x39, 0x65, 0x64, 0x63, 0x32, 0x35, 0x61, 0x32, 0x39, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x36, 0x39, 0x33, 0x33, 0x35, 0x34, 0x33, 0x64, 0x34, 0x66, 0x32, 0x63, 0x63, 0x30, 0x30, 0x62, 0x35, 0x33, 0x35, 0x30, 0x62, 0x64, 0x38, 0x30, 0x36, 0x38, 0x62, 0x61, 0x39, 0x32, 0x34, 0x33, 0x64, 0x36, 0x62, 0x65, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x65, 0x30, 0x64, 0x33, 0x33, 0x65, 0x61, 0x61, 0x33, 0x34, 0x31, 0x35, 0x36, 0x39, 0x66, 0x61, 0x39, 0x66, 0x66, 0x35, 0x39, 0x38, 0x32, 0x36, 0x38, 0x34, 0x38, 0x35, 0x34, 0x61, 0x34, 0x61, 0x33, 0x32, 0x38, 0x61, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x35, 0x63, 0x63, 0x35, 0x65, 0x34, 0x64, 0x35, 0x36, 0x62, 0x32, 0x62, 0x63, 0x63, 0x32, 0x65, 0x65, 0x31, 0x63, 0x37, 0x30, 0x39, 0x66, 0x62, 0x39, 0x65, 0x36, 0x38, 0x66, 0x62, 0x31, 0x37, 0x37, 0x34, 0x34, 0x30, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x39, 0x39, 0x65, 0x39, 0x35, 0x64, 0x65, 0x63, 0x65, 0x34, 0x36, 0x66, 0x66, 0x66, 0x66, 0x62, 0x31, 0x37, 0x35, 0x65, 0x62, 0x36, 0x34, 0x30, 0x30, 0x66, 0x62, 0x65, 0x62, 0x62, 0x30, 0x38, 0x65, 0x65, 0x39, 0x62, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x33, 0x38, 0x61, 0x30, 0x66, 0x66, 0x32, 0x38, 0x32, 0x61, 0x61, 0x61, 0x35, 0x66, 0x34, 0x62, 0x37, 0x35, 0x63, 0x66, 0x62, 0x36, 0x32, 0x63, 0x37, 0x30, 0x30, 0x33, 0x37, 0x65, 0x65, 0x36, 0x37, 0x64, 0x34, 0x66, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x36, 0x37, 0x36, 0x64, 0x31, 0x66, 0x61, 0x32, 0x31, 0x66, 0x63, 0x61, 0x30, 0x35, 0x32, 0x32, 0x39, 0x37, 0x65, 0x32, 0x34, 0x62, 0x66, 0x39, 0x36, 0x33, 0x38, 0x39, 0x63, 0x35, 0x62, 0x31, 0x32, 0x61, 0x37, 0x30, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x33, 0x64, 0x66, 0x62, 0x64, 0x62, 0x34, 0x35, 0x34, 0x62, 0x65, 0x35, 0x32, 0x37, 0x39, 0x61, 0x33, 0x62, 0x38, 0x61, 0x64, 0x64, 0x66, 0x64, 0x30, 0x65, 0x64, 0x31, 0x63, 0x64, 0x33, 0x37, 0x61, 0x39, 0x34, 0x32, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x62, 0x35, 0x39, 0x37, 0x32, 0x39, 0x39, 0x30, 0x33, 0x30, 0x31, 0x38, 0x33, 0x66, 0x36, 0x65, 0x32, 0x64, 0x32, 0x33, 0x38, 0x35, 0x33, 0x33, 0x66, 0x34, 0x36, 0x34, 0x32, 0x61, 0x61, 0x35, 0x38, 0x37, 0x35, 0x34, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x66, 0x32, 0x64, 0x63, 0x62, 0x66, 0x65, 0x30, 0x61, 0x35, 0x30, 0x30, 0x34, 0x31, 0x31, 0x64, 0x39, 0x35, 0x36, 0x65, 0x62, 0x38, 0x63, 0x38, 0x39, 0x33, 0x39, 0x63, 0x33, 0x64, 0x36, 0x63, 0x66, 0x65, 0x36, 0x36, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x32, 0x34, 0x37, 0x63, 0x35, 0x33, 0x64, 0x30, 0x35, 0x39, 0x65, 0x62, 0x37, 0x63, 0x39, 0x33, 0x31, 0x30, 0x66, 0x36, 0x32, 0x38, 0x64, 0x37, 0x66, 0x63, 0x36, 0x63, 0x36, 0x61, 0x30, 0x61, 0x37, 0x37, 0x33, 0x66, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x39, 0x39, 0x63, 0x61, 0x32, 0x31, 0x64, 0x62, 0x63, 0x66, 0x36, 0x39, 0x62, 0x66, 0x61, 0x31, 0x62, 0x33, 0x66, 0x37, 0x32, 0x62, 0x61, 0x63, 0x35, 0x31, 0x62, 0x39, 0x65, 0x33, 0x63, 0x61, 0x35, 0x38, 0x37, 0x63, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x66, 0x39, 0x35, 0x63, 0x31, 0x65, 0x39, 0x39, 0x63, 0x65, 0x32, 0x66, 0x39, 0x66, 0x35, 0x36, 0x39, 0x38, 0x30, 0x35, 0x37, 0x63, 0x31, 0x39, 0x64, 0x35, 0x63, 0x39, 0x34, 0x30, 0x32, 0x37, 0x65, 0x65, 0x34, 0x61, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x35, 0x36, 0x33, 0x62, 0x63, 0x33, 0x36, 0x34, 0x65, 0x64, 0x38, 0x31, 0x61, 0x30, 0x63, 0x36, 0x64, 0x61, 0x33, 0x62, 0x35, 0x36, 0x66, 0x66, 0x34, 0x39, 0x62, 0x62, 0x66, 0x32, 0x36, 0x37, 0x38, 0x32, 0x37, 0x61, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x39, 0x32, 0x36, 0x39, 0x38, 0x30, 0x30, 0x37, 0x63, 0x63, 0x31, 0x31, 0x61, 0x61, 0x36, 0x30, 0x33, 0x64, 0x32, 0x32, 0x31, 0x64, 0x35, 0x66, 0x65, 0x65, 0x61, 0x30, 0x37, 0x36, 0x62, 0x63, 0x66, 0x37, 0x63, 0x33, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x33, 0x34, 0x66, 0x66, 0x33, 0x38, 0x31, 0x35, 0x35, 0x66, 0x61, 0x62, 0x61, 0x65, 0x39, 0x34, 0x66, 0x64, 0x33, 0x35, 0x63, 0x34, 0x66, 0x66, 0x65, 0x31, 0x64, 0x37, 0x39, 0x64, 0x65, 0x37, 0x65, 0x66, 0x39, 0x63, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x39, 0x37, 0x37, 0x33, 0x31, 0x36, 0x39, 0x34, 0x34, 0x65, 0x35, 0x39, 0x34, 0x32, 0x65, 0x37, 0x39, 0x62, 0x30, 0x65, 0x33, 0x61, 0x62, 0x61, 0x64, 0x33, 0x38, 0x64, 0x61, 0x37, 0x34, 0x36, 0x30, 0x38, 0x36, 0x35, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x33, 0x64, 0x33, 0x37, 0x65, 0x64, 0x33, 0x34, 0x37, 0x64, 0x31, 0x63, 0x32, 0x66, 0x34, 0x65, 0x33, 0x35, 0x33, 0x35, 0x30, 0x64, 0x39, 0x61, 0x34, 0x34, 0x34, 0x62, 0x63, 0x35, 0x37, 0x63, 0x61, 0x34, 0x64, 0x62, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x39, 0x61, 0x36, 0x64, 0x37, 0x64, 0x62, 0x33, 0x32, 0x36, 0x36, 0x37, 0x39, 0x62, 0x37, 0x37, 0x63, 0x39, 0x30, 0x33, 0x39, 0x31, 0x61, 0x37, 0x34, 0x37, 0x36, 0x64, 0x32, 0x33, 0x38, 0x66, 0x33, 0x62, 0x61, 0x33, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x37, 0x62, 0x33, 0x62, 0x64, 0x66, 0x38, 0x36, 0x64, 0x37, 0x31, 0x33, 0x64, 0x62, 0x64, 0x30, 0x37, 0x62, 0x35, 0x64, 0x62, 0x66, 0x63, 0x63, 0x30, 0x32, 0x32, 0x62, 0x37, 0x61, 0x37, 0x62, 0x31, 0x39, 0x34, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x65, 0x37, 0x66, 0x65, 0x34, 0x31, 0x39, 0x63, 0x63, 0x36, 0x31, 0x66, 0x39, 0x31, 0x66, 0x34, 0x30, 0x38, 0x64, 0x32, 0x33, 0x34, 0x63, 0x63, 0x38, 0x30, 0x64, 0x35, 0x63, 0x61, 0x33, 0x64, 0x30, 0x35, 0x34, 0x64, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x37, 0x62, 0x62, 0x31, 0x33, 0x34, 0x64, 0x61, 0x33, 0x30, 0x61, 0x38, 0x31, 0x32, 0x64, 0x30, 0x30, 0x33, 0x61, 0x66, 0x38, 0x64, 0x63, 0x63, 0x62, 0x38, 0x38, 0x38, 0x66, 0x34, 0x34, 0x62, 0x62, 0x66, 0x35, 0x37, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x39, 0x32, 0x30, 0x66, 0x37, 0x32, 0x32, 0x36, 0x38, 0x32, 0x61, 0x66, 0x62, 0x35, 0x61, 0x66, 0x34, 0x35, 0x31, 0x62, 0x30, 0x35, 0x34, 0x34, 0x64, 0x34, 0x66, 0x34, 0x31, 0x62, 0x33, 0x62, 0x39, 0x64, 0x35, 0x37, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x39, 0x31, 0x37, 0x66, 0x33, 0x62, 0x35, 0x63, 0x62, 0x30, 0x62, 0x38, 0x38, 0x33, 0x30, 0x34, 0x37, 0x66, 0x64, 0x39, 0x62, 0x36, 0x35, 0x39, 0x33, 0x64, 0x62, 0x63, 0x64, 0x35, 0x35, 0x37, 0x66, 0x34, 0x35, 0x33, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x39, 0x37, 0x38, 0x36, 0x64, 0x33, 0x37, 0x31, 0x32, 0x66, 0x61, 0x32, 0x30, 0x30, 0x65, 0x39, 0x66, 0x36, 0x38, 0x35, 0x33, 0x37, 0x65, 0x65, 0x61, 0x61, 0x31, 0x61, 0x30, 0x36, 0x61, 0x36, 0x66, 0x34, 0x35, 0x61, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x62, 0x39, 0x38, 0x64, 0x36, 0x64, 0x62, 0x62, 0x31, 0x65, 0x61, 0x61, 0x65, 0x31, 0x36, 0x64, 0x34, 0x35, 0x61, 0x30, 0x34, 0x35, 0x36, 0x38, 0x35, 0x34, 0x31, 0x61, 0x64, 0x33, 0x64, 0x38, 0x66, 0x65, 0x30, 0x36, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x32, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x37, 0x62, 0x62, 0x33, 0x34, 0x32, 0x66, 0x30, 0x31, 0x62, 0x63, 0x39, 0x38, 0x38, 0x38, 0x65, 0x36, 0x61, 0x39, 0x61, 0x66, 0x34, 0x61, 0x38, 0x38, 0x37, 0x63, 0x62, 0x66, 0x34, 0x63, 0x32, 0x64, 0x64, 0x32, 0x63, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x30, 0x62, 0x31, 0x35, 0x31, 0x35, 0x64, 0x66, 0x63, 0x65, 0x64, 0x37, 0x61, 0x31, 0x33, 0x65, 0x31, 0x33, 0x65, 0x65, 0x31, 0x32, 0x63, 0x30, 0x66, 0x35, 0x32, 0x33, 0x61, 0x65, 0x35, 0x30, 0x34, 0x66, 0x30, 0x33, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x32, 0x38, 0x38, 0x39, 0x62, 0x35, 0x39, 0x36, 0x36, 0x66, 0x30, 0x63, 0x37, 0x66, 0x39, 0x65, 0x64, 0x62, 0x34, 0x32, 0x38, 0x39, 0x35, 0x63, 0x62, 0x36, 0x39, 0x64, 0x31, 0x63, 0x30, 0x34, 0x66, 0x39, 0x32, 0x33, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x30, 0x38, 0x35, 0x31, 0x33, 0x62, 0x32, 0x37, 0x36, 0x30, 0x34, 0x61, 0x38, 0x39, 0x62, 0x61, 0x31, 0x37, 0x36, 0x33, 0x62, 0x36, 0x66, 0x38, 0x34, 0x63, 0x65, 0x36, 0x38, 0x38, 0x62, 0x33, 0x34, 0x36, 0x39, 0x34, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x62, 0x30, 0x39, 0x64, 0x65, 0x36, 0x65, 0x37, 0x31, 0x33, 0x64, 0x63, 0x36, 0x39, 0x35, 0x34, 0x36, 0x65, 0x37, 0x36, 0x65, 0x66, 0x30, 0x61, 0x63, 0x66, 0x34, 0x30, 0x62, 0x39, 0x34, 0x66, 0x30, 0x32, 0x34, 0x31, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x35, 0x33, 0x66, 0x38, 0x32, 0x38, 0x64, 0x64, 0x30, 0x37, 0x36, 0x64, 0x34, 0x61, 0x37, 0x63, 0x31, 0x63, 0x32, 0x35, 0x37, 0x34, 0x62, 0x62, 0x32, 0x64, 0x65, 0x65, 0x31, 0x61, 0x34, 0x34, 0x61, 0x33, 0x31, 0x38, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x61, 0x64, 0x65, 0x35, 0x64, 0x62, 0x32, 0x32, 0x66, 0x38, 0x62, 0x37, 0x35, 0x38, 0x65, 0x65, 0x31, 0x34, 0x34, 0x33, 0x36, 0x32, 0x36, 0x63, 0x36, 0x34, 0x65, 0x63, 0x32, 0x66, 0x33, 0x32, 0x61, 0x61, 0x30, 0x61, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x30, 0x36, 0x35, 0x30, 0x38, 0x36, 0x31, 0x66, 0x37, 0x38, 0x35, 0x65, 0x64, 0x38, 0x65, 0x34, 0x62, 0x66, 0x31, 0x30, 0x30, 0x35, 0x63, 0x34, 0x35, 0x30, 0x62, 0x62, 0x64, 0x30, 0x36, 0x65, 0x62, 0x34, 0x38, 0x66, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x36, 0x36, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x35, 0x31, 0x34, 0x39, 0x65, 0x31, 0x38, 0x35, 0x66, 0x36, 0x65, 0x33, 0x39, 0x32, 0x37, 0x30, 0x35, 0x37, 0x37, 0x33, 0x39, 0x30, 0x37, 0x33, 0x61, 0x31, 0x38, 0x32, 0x32, 0x61, 0x65, 0x31, 0x63, 0x66, 0x30, 0x64, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x63, 0x62, 0x37, 0x64, 0x61, 0x30, 0x35, 0x30, 0x32, 0x64, 0x66, 0x34, 0x35, 0x63, 0x66, 0x35, 0x36, 0x31, 0x38, 0x31, 0x37, 0x62, 0x62, 0x64, 0x32, 0x33, 0x36, 0x32, 0x66, 0x34, 0x35, 0x31, 0x62, 0x65, 0x30, 0x32, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x31, 0x62, 0x62, 0x35, 0x36, 0x32, 0x65, 0x34, 0x32, 0x62, 0x64, 0x34, 0x36, 0x31, 0x33, 0x30, 0x65, 0x32, 0x64, 0x33, 0x61, 0x65, 0x34, 0x36, 0x35, 0x32, 0x62, 0x36, 0x61, 0x34, 0x65, 0x62, 0x38, 0x36, 0x62, 0x63, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x33, 0x34, 0x30, 0x33, 0x35, 0x66, 0x37, 0x35, 0x34, 0x34, 0x34, 0x36, 0x33, 0x63, 0x65, 0x31, 0x65, 0x32, 0x32, 0x62, 0x63, 0x35, 0x35, 0x33, 0x30, 0x36, 0x34, 0x36, 0x38, 0x34, 0x63, 0x35, 0x31, 0x33, 0x63, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x39, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x65, 0x33, 0x33, 0x38, 0x30, 0x30, 0x61, 0x31, 0x62, 0x32, 0x65, 0x39, 0x36, 0x62, 0x64, 0x65, 0x31, 0x30, 0x33, 0x31, 0x36, 0x33, 0x30, 0x61, 0x39, 0x35, 0x39, 0x61, 0x61, 0x30, 0x30, 0x37, 0x66, 0x32, 0x36, 0x65, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x35, 0x63, 0x65, 0x33, 0x33, 0x35, 0x35, 0x61, 0x37, 0x62, 0x61, 0x39, 0x62, 0x33, 0x33, 0x32, 0x37, 0x36, 0x30, 0x63, 0x30, 0x39, 0x35, 0x30, 0x63, 0x32, 0x62, 0x63, 0x34, 0x35, 0x61, 0x38, 0x35, 0x66, 0x61, 0x39, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x66, 0x35, 0x65, 0x62, 0x36, 0x34, 0x39, 0x61, 0x66, 0x62, 0x39, 0x39, 0x35, 0x39, 0x39, 0x63, 0x34, 0x31, 0x34, 0x62, 0x32, 0x37, 0x61, 0x39, 0x63, 0x39, 0x63, 0x38, 0x35, 0x35, 0x33, 0x35, 0x37, 0x66, 0x61, 0x38, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x31, 0x30, 0x62, 0x65, 0x32, 0x64, 0x66, 0x35, 0x37, 0x62, 0x64, 0x30, 0x61, 0x62, 0x39, 0x61, 0x65, 0x38, 0x31, 0x39, 0x36, 0x63, 0x64, 0x35, 0x30, 0x61, 0x62, 0x30, 0x63, 0x35, 0x32, 0x31, 0x61, 0x62, 0x61, 0x39, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x34, 0x32, 0x38, 0x38, 0x30, 0x31, 0x34, 0x65, 0x64, 0x64, 0x63, 0x35, 0x36, 0x33, 0x32, 0x66, 0x35, 0x66, 0x61, 0x63, 0x62, 0x35, 0x65, 0x33, 0x38, 0x35, 0x31, 0x37, 0x61, 0x38, 0x66, 0x38, 0x62, 0x63, 0x35, 0x64, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x38, 0x34, 0x39, 0x30, 0x33, 0x66, 0x31, 0x64, 0x37, 0x63, 0x31, 0x62, 0x35, 0x63, 0x64, 0x39, 0x30, 0x31, 0x66, 0x38, 0x38, 0x37, 0x35, 0x64, 0x31, 0x34, 0x61, 0x37, 0x39, 0x62, 0x33, 0x63, 0x62, 0x65, 0x32, 0x61, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x64, 0x63, 0x65, 0x38, 0x36, 0x37, 0x66, 0x30, 0x61, 0x33, 0x39, 0x63, 0x35, 0x62, 0x65, 0x66, 0x39, 0x65, 0x65, 0x62, 0x61, 0x36, 0x30, 0x39, 0x32, 0x32, 0x39, 0x65, 0x66, 0x61, 0x30, 0x32, 0x36, 0x37, 0x38, 0x62, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x32, 0x30, 0x65, 0x38, 0x36, 0x33, 0x36, 0x32, 0x62, 0x34, 0x38, 0x37, 0x37, 0x35, 0x32, 0x38, 0x33, 0x36, 0x61, 0x36, 0x64, 0x65, 0x30, 0x62, 0x63, 0x30, 0x32, 0x63, 0x64, 0x38, 0x64, 0x38, 0x39, 0x61, 0x38, 0x62, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x30, 0x38, 0x38, 0x63, 0x30, 0x32, 0x35, 0x66, 0x33, 0x65, 0x38, 0x35, 0x30, 0x31, 0x33, 0x66, 0x35, 0x34, 0x33, 0x39, 0x66, 0x62, 0x33, 0x34, 0x34, 0x30, 0x61, 0x31, 0x37, 0x33, 0x30, 0x31, 0x65, 0x35, 0x34, 0x34, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x66, 0x62, 0x34, 0x34, 0x38, 0x63, 0x30, 0x63, 0x35, 0x66, 0x36, 0x38, 0x33, 0x66, 0x62, 0x36, 0x37, 0x65, 0x65, 0x35, 0x37, 0x30, 0x62, 0x61, 0x66, 0x30, 0x64, 0x62, 0x35, 0x36, 0x38, 0x36, 0x35, 0x39, 0x39, 0x37, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x31, 0x38, 0x37, 0x64, 0x35, 0x61, 0x37, 0x30, 0x34, 0x64, 0x35, 0x61, 0x33, 0x33, 0x38, 0x63, 0x35, 0x62, 0x32, 0x38, 0x37, 0x36, 0x61, 0x30, 0x39, 0x30, 0x64, 0x63, 0x65, 0x39, 0x36, 0x34, 0x32, 0x38, 0x34, 0x65, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x30, 0x65, 0x31, 0x38, 0x61, 0x30, 0x31, 0x64, 0x63, 0x34, 0x64, 0x63, 0x35, 0x64, 0x61, 0x61, 0x65, 0x35, 0x36, 0x37, 0x63, 0x33, 0x66, 0x61, 0x34, 0x63, 0x37, 0x66, 0x38, 0x66, 0x39, 0x62, 0x35, 0x39, 0x30, 0x32, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x37, 0x66, 0x35, 0x38, 0x36, 0x39, 0x64, 0x36, 0x65, 0x34, 0x36, 0x39, 0x35, 0x66, 0x30, 0x65, 0x62, 0x39, 0x65, 0x32, 0x37, 0x33, 0x31, 0x31, 0x63, 0x34, 0x38, 0x37, 0x38, 0x61, 0x66, 0x66, 0x33, 0x33, 0x33, 0x33, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x31, 0x30, 0x30, 0x64, 0x64, 0x30, 0x30, 0x66, 0x65, 0x32, 0x64, 0x64, 0x66, 0x31, 0x38, 0x31, 0x36, 0x33, 0x61, 0x64, 0x39, 0x36, 0x34, 0x64, 0x30, 0x62, 0x36, 0x39, 0x66, 0x31, 0x66, 0x32, 0x65, 0x39, 0x36, 0x35, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x35, 0x39, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x65, 0x66, 0x34, 0x61, 0x63, 0x63, 0x31, 0x62, 0x66, 0x31, 0x34, 0x37, 0x65, 0x33, 0x32, 0x36, 0x37, 0x34, 0x39, 0x64, 0x31, 0x30, 0x65, 0x36, 0x37, 0x37, 0x64, 0x63, 0x66, 0x66, 0x64, 0x37, 0x36, 0x66, 0x39, 0x65, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x30, 0x64, 0x66, 0x63, 0x30, 0x62, 0x37, 0x31, 0x65, 0x33, 0x35, 0x39, 0x62, 0x32, 0x62, 0x34, 0x36, 0x35, 0x34, 0x34, 0x30, 0x61, 0x33, 0x36, 0x61, 0x36, 0x63, 0x64, 0x63, 0x33, 0x35, 0x32, 0x37, 0x37, 0x33, 0x30, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x65, 0x30, 0x36, 0x37, 0x35, 0x64, 0x61, 0x39, 0x38, 0x61, 0x35, 0x64, 0x64, 0x61, 0x37, 0x30, 0x63, 0x64, 0x39, 0x36, 0x31, 0x39, 0x36, 0x62, 0x38, 0x37, 0x66, 0x34, 0x65, 0x37, 0x32, 0x36, 0x62, 0x34, 0x33, 0x33, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x62, 0x64, 0x35, 0x65, 0x38, 0x34, 0x35, 0x35, 0x63, 0x31, 0x33, 0x30, 0x31, 0x36, 0x39, 0x33, 0x35, 0x37, 0x63, 0x34, 0x37, 0x31, 0x65, 0x33, 0x65, 0x36, 0x38, 0x31, 0x62, 0x37, 0x39, 0x39, 0x36, 0x61, 0x37, 0x32, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x37, 0x62, 0x36, 0x64, 0x63, 0x35, 0x31, 0x39, 0x30, 0x66, 0x65, 0x32, 0x39, 0x31, 0x32, 0x39, 0x36, 0x33, 0x66, 0x63, 0x64, 0x35, 0x37, 0x39, 0x36, 0x38, 0x33, 0x65, 0x63, 0x37, 0x33, 0x39, 0x35, 0x31, 0x31, 0x36, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x30, 0x35, 0x64, 0x64, 0x33, 0x64, 0x39, 0x38, 0x37, 0x63, 0x66, 0x66, 0x64, 0x38, 0x31, 0x33, 0x65, 0x39, 0x63, 0x38, 0x35, 0x30, 0x30, 0x61, 0x38, 0x30, 0x61, 0x31, 0x61, 0x64, 0x32, 0x35, 0x37, 0x64, 0x35, 0x36, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x35, 0x32, 0x35, 0x30, 0x62, 0x30, 0x36, 0x65, 0x34, 0x66, 0x61, 0x37, 0x63, 0x62, 0x32, 0x37, 0x34, 0x39, 0x34, 0x32, 0x32, 0x65, 0x62, 0x38, 0x31, 0x37, 0x62, 0x64, 0x64, 0x61, 0x38, 0x62, 0x35, 0x34, 0x64, 0x65, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x36, 0x64, 0x62, 0x33, 0x33, 0x62, 0x37, 0x62, 0x35, 0x61, 0x39, 0x35, 0x30, 0x63, 0x33, 0x65, 0x66, 0x61, 0x32, 0x64, 0x63, 0x33, 0x31, 0x62, 0x31, 0x30, 0x62, 0x61, 0x31, 0x30, 0x61, 0x35, 0x33, 0x32, 0x65, 0x66, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x35, 0x32, 0x39, 0x62, 0x64, 0x62, 0x34, 0x35, 0x39, 0x63, 0x63, 0x31, 0x38, 0x35, 0x62, 0x65, 0x65, 0x35, 0x61, 0x31, 0x63, 0x35, 0x38, 0x62, 0x66, 0x37, 0x65, 0x38, 0x63, 0x63, 0x65, 0x32, 0x35, 0x63, 0x31, 0x35, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x35, 0x35, 0x34, 0x36, 0x65, 0x38, 0x37, 0x36, 0x38, 0x64, 0x35, 0x30, 0x36, 0x38, 0x37, 0x33, 0x38, 0x31, 0x38, 0x61, 0x63, 0x39, 0x37, 0x35, 0x31, 0x63, 0x31, 0x66, 0x31, 0x32, 0x31, 0x31, 0x36, 0x61, 0x33, 0x62, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x64, 0x32, 0x34, 0x62, 0x63, 0x33, 0x37, 0x33, 0x36, 0x66, 0x38, 0x38, 0x64, 0x64, 0x36, 0x33, 0x62, 0x37, 0x32, 0x32, 0x32, 0x30, 0x32, 0x36, 0x38, 0x38, 0x36, 0x36, 0x33, 0x30, 0x62, 0x36, 0x65, 0x62, 0x38, 0x37, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x61, 0x66, 0x32, 0x38, 0x62, 0x30, 0x37, 0x34, 0x36, 0x63, 0x61, 0x63, 0x30, 0x64, 0x61, 0x31, 0x37, 0x30, 0x38, 0x34, 0x62, 0x39, 0x33, 0x39, 0x38, 0x63, 0x35, 0x65, 0x33, 0x36, 0x62, 0x62, 0x33, 0x61, 0x30, 0x64, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x66, 0x38, 0x33, 0x61, 0x63, 0x33, 0x64, 0x61, 0x33, 0x30, 0x66, 0x37, 0x30, 0x39, 0x32, 0x36, 0x32, 0x38, 0x63, 0x37, 0x33, 0x33, 0x39, 0x66, 0x32, 0x30, 0x38, 0x62, 0x66, 0x63, 0x31, 0x34, 0x32, 0x63, 0x62, 0x31, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x34, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x66, 0x34, 0x36, 0x33, 0x65, 0x31, 0x33, 0x37, 0x64, 0x63, 0x66, 0x36, 0x32, 0x35, 0x66, 0x62, 0x66, 0x33, 0x62, 0x63, 0x61, 0x33, 0x39, 0x65, 0x63, 0x61, 0x39, 0x38, 0x64, 0x32, 0x62, 0x39, 0x36, 0x38, 0x63, 0x66, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x38, 0x34, 0x66, 0x63, 0x65, 0x35, 0x30, 0x35, 0x64, 0x39, 0x37, 0x62, 0x65, 0x62, 0x66, 0x31, 0x61, 0x64, 0x38, 0x63, 0x35, 0x66, 0x66, 0x36, 0x38, 0x32, 0x36, 0x66, 0x63, 0x36, 0x34, 0x35, 0x33, 0x37, 0x31, 0x66, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x61, 0x37, 0x31, 0x34, 0x66, 0x39, 0x39, 0x66, 0x61, 0x30, 0x30, 0x66, 0x65, 0x66, 0x37, 0x35, 0x38, 0x65, 0x32, 0x33, 0x61, 0x32, 0x65, 0x37, 0x34, 0x36, 0x33, 0x32, 0x36, 0x64, 0x61, 0x64, 0x32, 0x34, 0x37, 0x63, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x66, 0x30, 0x36, 0x34, 0x34, 0x32, 0x38, 0x66, 0x38, 0x33, 0x36, 0x32, 0x36, 0x37, 0x32, 0x32, 0x61, 0x37, 0x62, 0x35, 0x62, 0x32, 0x36, 0x61, 0x39, 0x61, 0x62, 0x32, 0x30, 0x34, 0x32, 0x31, 0x61, 0x37, 0x37, 0x32, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x36, 0x66, 0x36, 0x38, 0x65, 0x38, 0x33, 0x37, 0x63, 0x66, 0x31, 0x39, 0x36, 0x31, 0x63, 0x62, 0x31, 0x34, 0x61, 0x62, 0x34, 0x37, 0x34, 0x34, 0x36, 0x64, 0x61, 0x31, 0x36, 0x38, 0x61, 0x31, 0x36, 0x64, 0x64, 0x65, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x33, 0x63, 0x37, 0x33, 0x38, 0x38, 0x63, 0x63, 0x37, 0x36, 0x64, 0x61, 0x33, 0x64, 0x36, 0x32, 0x64, 0x34, 0x30, 0x30, 0x36, 0x37, 0x64, 0x61, 0x62, 0x63, 0x63, 0x64, 0x37, 0x65, 0x66, 0x30, 0x34, 0x33, 0x33, 0x64, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x62, 0x39, 0x61, 0x34, 0x39, 0x61, 0x34, 0x33, 0x38, 0x37, 0x33, 0x30, 0x32, 0x30, 0x66, 0x30, 0x37, 0x35, 0x39, 0x31, 0x38, 0x35, 0x65, 0x32, 0x30, 0x62, 0x62, 0x62, 0x34, 0x63, 0x66, 0x33, 0x38, 0x31, 0x62, 0x62, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x31, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x66, 0x39, 0x66, 0x32, 0x32, 0x32, 0x36, 0x65, 0x35, 0x61, 0x65, 0x61, 0x63, 0x66, 0x31, 0x64, 0x38, 0x30, 0x61, 0x65, 0x30, 0x61, 0x35, 0x39, 0x63, 0x36, 0x65, 0x33, 0x38, 0x30, 0x33, 0x38, 0x62, 0x63, 0x38, 0x64, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x30, 0x65, 0x37, 0x64, 0x39, 0x32, 0x66, 0x62, 0x33, 0x30, 0x35, 0x38, 0x35, 0x33, 0x64, 0x37, 0x39, 0x38, 0x32, 0x36, 0x33, 0x62, 0x66, 0x31, 0x35, 0x65, 0x39, 0x37, 0x63, 0x37, 0x32, 0x62, 0x66, 0x39, 0x64, 0x37, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x35, 0x63, 0x36, 0x30, 0x65, 0x38, 0x34, 0x35, 0x33, 0x35, 0x65, 0x65, 0x62, 0x34, 0x64, 0x35, 0x38, 0x30, 0x64, 0x65, 0x31, 0x32, 0x37, 0x61, 0x31, 0x32, 0x65, 0x62, 0x32, 0x36, 0x37, 0x37, 0x63, 0x63, 0x62, 0x33, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x64, 0x36, 0x35, 0x34, 0x32, 0x30, 0x63, 0x31, 0x38, 0x63, 0x32, 0x33, 0x32, 0x37, 0x63, 0x63, 0x35, 0x61, 0x66, 0x39, 0x37, 0x34, 0x32, 0x35, 0x66, 0x38, 0x35, 0x37, 0x65, 0x34, 0x61, 0x39, 0x66, 0x64, 0x35, 0x31, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x63, 0x39, 0x33, 0x39, 0x32, 0x32, 0x34, 0x34, 0x61, 0x32, 0x31, 0x30, 0x38, 0x63, 0x39, 0x38, 0x37, 0x62, 0x63, 0x35, 0x63, 0x64, 0x64, 0x65, 0x30, 0x65, 0x64, 0x39, 0x66, 0x38, 0x33, 0x37, 0x61, 0x38, 0x31, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x36, 0x30, 0x35, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x61, 0x31, 0x64, 0x36, 0x30, 0x64, 0x34, 0x30, 0x66, 0x35, 0x37, 0x66, 0x33, 0x30, 0x38, 0x65, 0x65, 0x62, 0x66, 0x30, 0x38, 0x37, 0x64, 0x65, 0x65, 0x33, 0x62, 0x33, 0x37, 0x66, 0x31, 0x65, 0x37, 0x63, 0x32, 0x63, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x35, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x61, 0x31, 0x63, 0x64, 0x63, 0x33, 0x33, 0x62, 0x66, 0x64, 0x33, 0x37, 0x36, 0x66, 0x31, 0x63, 0x30, 0x64, 0x37, 0x36, 0x66, 0x62, 0x36, 0x63, 0x38, 0x34, 0x62, 0x36, 0x62, 0x34, 0x61, 0x63, 0x32, 0x37, 0x34, 0x64, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x37, 0x66, 0x33, 0x38, 0x38, 0x31, 0x39, 0x35, 0x36, 0x35, 0x34, 0x32, 0x33, 0x61, 0x61, 0x38, 0x35, 0x66, 0x33, 0x65, 0x33, 0x61, 0x62, 0x36, 0x31, 0x62, 0x63, 0x37, 0x36, 0x33, 0x63, 0x62, 0x61, 0x62, 0x38, 0x39, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x64, 0x35, 0x63, 0x63, 0x37, 0x31, 0x31, 0x37, 0x65, 0x31, 0x38, 0x35, 0x30, 0x30, 0x61, 0x63, 0x32, 0x66, 0x39, 0x65, 0x33, 0x63, 0x32, 0x36, 0x63, 0x38, 0x36, 0x62, 0x30, 0x61, 0x39, 0x34, 0x62, 0x30, 0x64, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x37, 0x30, 0x64, 0x33, 0x61, 0x63, 0x66, 0x37, 0x32, 0x62, 0x35, 0x62, 0x31, 0x66, 0x33, 0x32, 0x61, 0x37, 0x30, 0x30, 0x33, 0x63, 0x66, 0x31, 0x30, 0x32, 0x63, 0x36, 0x34, 0x65, 0x65, 0x30, 0x35, 0x34, 0x37, 0x39, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x36, 0x32, 0x38, 0x31, 0x35, 0x30, 0x65, 0x32, 0x39, 0x39, 0x35, 0x62, 0x35, 0x62, 0x32, 0x37, 0x39, 0x66, 0x63, 0x38, 0x33, 0x65, 0x30, 0x64, 0x64, 0x35, 0x66, 0x31, 0x30, 0x32, 0x61, 0x36, 0x37, 0x31, 0x64, 0x64, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x38, 0x66, 0x33, 0x39, 0x38, 0x38, 0x31, 0x62, 0x39, 0x65, 0x64, 0x66, 0x65, 0x39, 0x31, 0x32, 0x32, 0x37, 0x63, 0x33, 0x33, 0x66, 0x61, 0x34, 0x63, 0x64, 0x64, 0x39, 0x31, 0x65, 0x36, 0x37, 0x38, 0x35, 0x34, 0x34, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x30, 0x62, 0x37, 0x63, 0x62, 0x37, 0x31, 0x64, 0x61, 0x39, 0x64, 0x34, 0x63, 0x31, 0x65, 0x61, 0x36, 0x65, 0x63, 0x63, 0x32, 0x38, 0x65, 0x62, 0x64, 0x61, 0x35, 0x30, 0x34, 0x63, 0x36, 0x33, 0x66, 0x38, 0x32, 0x66, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x37, 0x39, 0x35, 0x63, 0x35, 0x66, 0x34, 0x61, 0x35, 0x36, 0x38, 0x39, 0x61, 0x64, 0x36, 0x32, 0x64, 0x61, 0x39, 0x36, 0x31, 0x36, 0x37, 0x31, 0x66, 0x30, 0x32, 0x38, 0x30, 0x36, 0x35, 0x32, 0x38, 0x36, 0x64, 0x35, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x32, 0x33, 0x34, 0x36, 0x61, 0x32, 0x37, 0x66, 0x66, 0x39, 0x62, 0x37, 0x30, 0x32, 0x30, 0x34, 0x34, 0x66, 0x35, 0x30, 0x30, 0x64, 0x65, 0x66, 0x66, 0x32, 0x65, 0x37, 0x66, 0x66, 0x65, 0x36, 0x38, 0x32, 0x34, 0x35, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x62, 0x64, 0x34, 0x31, 0x37, 0x63, 0x33, 0x37, 0x32, 0x62, 0x38, 0x62, 0x30, 0x64, 0x30, 0x31, 0x62, 0x63, 0x64, 0x39, 0x34, 0x34, 0x37, 0x30, 0x36, 0x62, 0x64, 0x33, 0x32, 0x65, 0x36, 0x30, 0x61, 0x65, 0x32, 0x38, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x66, 0x62, 0x66, 0x34, 0x31, 0x34, 0x34, 0x31, 0x36, 0x30, 0x30, 0x37, 0x35, 0x37, 0x66, 0x65, 0x31, 0x35, 0x38, 0x33, 0x30, 0x63, 0x38, 0x63, 0x64, 0x35, 0x66, 0x34, 0x66, 0x66, 0x62, 0x62, 0x62, 0x64, 0x35, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x30, 0x63, 0x64, 0x36, 0x37, 0x62, 0x36, 0x30, 0x65, 0x38, 0x31, 0x64, 0x35, 0x34, 0x65, 0x37, 0x62, 0x35, 0x66, 0x36, 0x30, 0x37, 0x38, 0x66, 0x33, 0x65, 0x30, 0x32, 0x31, 0x62, 0x61, 0x36, 0x35, 0x62, 0x39, 0x61, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x61, 0x34, 0x63, 0x61, 0x63, 0x30, 0x63, 0x62, 0x38, 0x62, 0x35, 0x38, 0x32, 0x64, 0x39, 0x66, 0x65, 0x66, 0x33, 0x38, 0x63, 0x35, 0x63, 0x39, 0x66, 0x66, 0x66, 0x39, 0x62, 0x64, 0x35, 0x33, 0x30, 0x39, 0x33, 0x64, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x37, 0x62, 0x34, 0x66, 0x35, 0x33, 0x63, 0x34, 0x35, 0x36, 0x35, 0x35, 0x66, 0x33, 0x64, 0x63, 0x35, 0x66, 0x30, 0x31, 0x37, 0x65, 0x64, 0x63, 0x32, 0x33, 0x62, 0x31, 0x36, 0x66, 0x39, 0x62, 0x63, 0x35, 0x33, 0x36, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x30, 0x38, 0x64, 0x33, 0x39, 0x63, 0x37, 0x30, 0x39, 0x31, 0x36, 0x66, 0x36, 0x61, 0x62, 0x63, 0x34, 0x63, 0x63, 0x37, 0x66, 0x39, 0x39, 0x39, 0x66, 0x30, 0x31, 0x31, 0x66, 0x30, 0x37, 0x37, 0x31, 0x30, 0x35, 0x38, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x37, 0x64, 0x64, 0x30, 0x35, 0x36, 0x65, 0x37, 0x66, 0x64, 0x62, 0x64, 0x36, 0x34, 0x31, 0x64, 0x62, 0x35, 0x62, 0x36, 0x62, 0x65, 0x61, 0x32, 0x61, 0x38, 0x37, 0x38, 0x30, 0x61, 0x38, 0x33, 0x66, 0x61, 0x65, 0x31, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x30, 0x35, 0x35, 0x37, 0x62, 0x62, 0x34, 0x33, 0x66, 0x34, 0x62, 0x65, 0x33, 0x61, 0x31, 0x62, 0x38, 0x62, 0x38, 0x35, 0x65, 0x37, 0x64, 0x66, 0x37, 0x62, 0x33, 0x63, 0x35, 0x62, 0x63, 0x64, 0x35, 0x34, 0x38, 0x30, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x30, 0x38, 0x39, 0x33, 0x36, 0x31, 0x61, 0x33, 0x66, 0x65, 0x37, 0x34, 0x35, 0x31, 0x66, 0x62, 0x31, 0x66, 0x38, 0x37, 0x66, 0x30, 0x31, 0x61, 0x32, 0x64, 0x38, 0x36, 0x36, 0x36, 0x35, 0x33, 0x64, 0x63, 0x30, 0x62, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x62, 0x65, 0x63, 0x39, 0x36, 0x33, 0x30, 0x38, 0x61, 0x32, 0x30, 0x66, 0x39, 0x30, 0x63, 0x61, 0x62, 0x31, 0x38, 0x33, 0x39, 0x39, 0x63, 0x34, 0x39, 0x33, 0x66, 0x64, 0x33, 0x64, 0x30, 0x36, 0x35, 0x61, 0x62, 0x66, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x61, 0x30, 0x37, 0x62, 0x62, 0x37, 0x39, 0x34, 0x35, 0x37, 0x31, 0x64, 0x34, 0x61, 0x63, 0x66, 0x30, 0x34, 0x31, 0x64, 0x61, 0x64, 0x38, 0x37, 0x66, 0x30, 0x64, 0x31, 0x65, 0x66, 0x33, 0x31, 0x38, 0x35, 0x62, 0x33, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x64, 0x30, 0x65, 0x39, 0x38, 0x36, 0x64, 0x38, 0x31, 0x34, 0x65, 0x61, 0x31, 0x33, 0x63, 0x38, 0x66, 0x34, 0x36, 0x36, 0x61, 0x30, 0x35, 0x33, 0x38, 0x63, 0x35, 0x33, 0x64, 0x63, 0x39, 0x32, 0x32, 0x36, 0x35, 0x31, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x32, 0x63, 0x66, 0x61, 0x30, 0x33, 0x38, 0x66, 0x61, 0x62, 0x33, 0x37, 0x61, 0x30, 0x31, 0x37, 0x34, 0x35, 0x61, 0x33, 0x36, 0x34, 0x65, 0x31, 0x62, 0x39, 0x38, 0x31, 0x32, 0x37, 0x63, 0x35, 0x30, 0x33, 0x37, 0x34, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x33, 0x36, 0x63, 0x33, 0x65, 0x66, 0x36, 0x65, 0x38, 0x62, 0x35, 0x30, 0x65, 0x65, 0x39, 0x30, 0x65, 0x30, 0x33, 0x37, 0x62, 0x31, 0x36, 0x34, 0x62, 0x37, 0x61, 0x38, 0x65, 0x61, 0x35, 0x66, 0x61, 0x61, 0x63, 0x36, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x32, 0x37, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x33, 0x33, 0x33, 0x35, 0x38, 0x66, 0x63, 0x32, 0x31, 0x63, 0x38, 0x35, 0x30, 0x30, 0x36, 0x65, 0x34, 0x30, 0x66, 0x33, 0x32, 0x33, 0x35, 0x37, 0x64, 0x63, 0x38, 0x38, 0x39, 0x35, 0x39, 0x34, 0x30, 0x61, 0x61, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x61, 0x39, 0x61, 0x34, 0x30, 0x34, 0x66, 0x63, 0x39, 0x66, 0x35, 0x62, 0x66, 0x65, 0x65, 0x34, 0x38, 0x65, 0x63, 0x32, 0x36, 0x35, 0x62, 0x31, 0x32, 0x35, 0x32, 0x33, 0x33, 0x33, 0x38, 0x65, 0x32, 0x39, 0x61, 0x38, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x66, 0x32, 0x33, 0x35, 0x64, 0x32, 0x62, 0x62, 0x65, 0x30, 0x35, 0x30, 0x65, 0x36, 0x32, 0x39, 0x31, 0x36, 0x31, 0x35, 0x62, 0x37, 0x31, 0x63, 0x61, 0x35, 0x38, 0x32, 0x39, 0x36, 0x35, 0x38, 0x38, 0x31, 0x30, 0x31, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x35, 0x61, 0x36, 0x33, 0x31, 0x35, 0x37, 0x66, 0x39, 0x31, 0x34, 0x66, 0x64, 0x33, 0x39, 0x38, 0x65, 0x61, 0x62, 0x31, 0x39, 0x63, 0x31, 0x33, 0x37, 0x64, 0x64, 0x39, 0x35, 0x35, 0x30, 0x62, 0x62, 0x37, 0x37, 0x31, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x34, 0x33, 0x31, 0x34, 0x66, 0x62, 0x36, 0x31, 0x63, 0x64, 0x39, 0x33, 0x38, 0x66, 0x63, 0x33, 0x33, 0x65, 0x31, 0x35, 0x65, 0x38, 0x31, 0x36, 0x62, 0x31, 0x31, 0x33, 0x66, 0x32, 0x61, 0x63, 0x38, 0x39, 0x61, 0x37, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x31, 0x36, 0x64, 0x63, 0x35, 0x39, 0x65, 0x32, 0x37, 0x63, 0x33, 0x64, 0x37, 0x32, 0x37, 0x39, 0x66, 0x35, 0x63, 0x64, 0x35, 0x62, 0x62, 0x32, 0x62, 0x65, 0x63, 0x66, 0x62, 0x32, 0x36, 0x30, 0x36, 0x65, 0x31, 0x34, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x61, 0x35, 0x34, 0x35, 0x39, 0x66, 0x63, 0x64, 0x64, 0x35, 0x65, 0x35, 0x62, 0x32, 0x37, 0x33, 0x38, 0x33, 0x30, 0x64, 0x66, 0x38, 0x38, 0x65, 0x65, 0x61, 0x34, 0x63, 0x62, 0x37, 0x37, 0x64, 0x64, 0x61, 0x64, 0x66, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x33, 0x31, 0x30, 0x32, 0x35, 0x66, 0x35, 0x36, 0x34, 0x39, 0x64, 0x32, 0x63, 0x36, 0x65, 0x65, 0x61, 0x34, 0x31, 0x65, 0x64, 0x33, 0x62, 0x64, 0x64, 0x33, 0x34, 0x37, 0x31, 0x61, 0x37, 0x39, 0x30, 0x66, 0x37, 0x35, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x31, 0x66, 0x39, 0x64, 0x31, 0x37, 0x65, 0x35, 0x61, 0x30, 0x65, 0x37, 0x34, 0x32, 0x30, 0x35, 0x39, 0x34, 0x37, 0x61, 0x65, 0x62, 0x39, 0x62, 0x63, 0x36, 0x61, 0x37, 0x39, 0x33, 0x38, 0x39, 0x36, 0x31, 0x30, 0x33, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x64, 0x30, 0x38, 0x36, 0x34, 0x64, 0x63, 0x33, 0x32, 0x66, 0x39, 0x61, 0x63, 0x62, 0x33, 0x36, 0x62, 0x66, 0x34, 0x65, 0x61, 0x34, 0x34, 0x37, 0x65, 0x38, 0x64, 0x64, 0x36, 0x37, 0x32, 0x36, 0x39, 0x30, 0x36, 0x61, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x35, 0x37, 0x35, 0x63, 0x33, 0x31, 0x31, 0x34, 0x37, 0x35, 0x31, 0x65, 0x33, 0x63, 0x36, 0x33, 0x31, 0x39, 0x37, 0x31, 0x64, 0x61, 0x36, 0x61, 0x32, 0x61, 0x30, 0x32, 0x66, 0x64, 0x33, 0x66, 0x66, 0x62, 0x66, 0x63, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x36, 0x30, 0x38, 0x39, 0x35, 0x66, 0x62, 0x65, 0x62, 0x62, 0x62, 0x35, 0x30, 0x31, 0x37, 0x66, 0x63, 0x62, 0x66, 0x66, 0x33, 0x63, 0x64, 0x64, 0x61, 0x33, 0x39, 0x37, 0x32, 0x39, 0x32, 0x62, 0x66, 0x32, 0x35, 0x62, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x39, 0x31, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x66, 0x65, 0x38, 0x61, 0x34, 0x63, 0x36, 0x31, 0x36, 0x34, 0x64, 0x66, 0x38, 0x66, 0x61, 0x36, 0x30, 0x36, 0x39, 0x39, 0x35, 0x64, 0x36, 0x62, 0x61, 0x37, 0x61, 0x64, 0x63, 0x61, 0x66, 0x31, 0x63, 0x38, 0x39, 0x33, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x39, 0x30, 0x38, 0x37, 0x66, 0x36, 0x36, 0x66, 0x66, 0x32, 0x38, 0x34, 0x66, 0x38, 0x62, 0x35, 0x65, 0x66, 0x62, 0x64, 0x32, 0x39, 0x34, 0x39, 0x33, 0x62, 0x37, 0x30, 0x36, 0x37, 0x33, 0x33, 0x61, 0x62, 0x31, 0x34, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x31, 0x36, 0x33, 0x33, 0x30, 0x38, 0x30, 0x64, 0x30, 0x37, 0x61, 0x35, 0x35, 0x37, 0x61, 0x64, 0x64, 0x65, 0x33, 0x31, 0x39, 0x32, 0x36, 0x31, 0x62, 0x30, 0x37, 0x34, 0x39, 0x39, 0x37, 0x66, 0x31, 0x34, 0x36, 0x39, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x61, 0x31, 0x32, 0x64, 0x66, 0x32, 0x65, 0x33, 0x65, 0x66, 0x38, 0x35, 0x37, 0x61, 0x63, 0x65, 0x66, 0x66, 0x39, 0x33, 0x30, 0x36, 0x62, 0x33, 0x30, 0x39, 0x66, 0x36, 0x61, 0x35, 0x30, 0x30, 0x66, 0x37, 0x30, 0x31, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x36, 0x34, 0x61, 0x38, 0x65, 0x38, 0x64, 0x61, 0x63, 0x66, 0x34, 0x61, 0x64, 0x65, 0x33, 0x30, 0x64, 0x31, 0x30, 0x66, 0x34, 0x64, 0x35, 0x39, 0x62, 0x30, 0x61, 0x33, 0x64, 0x35, 0x61, 0x62, 0x66, 0x64, 0x62, 0x66, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x34, 0x36, 0x39, 0x32, 0x38, 0x64, 0x36, 0x38, 0x33, 0x32, 0x38, 0x39, 0x61, 0x32, 0x64, 0x31, 0x31, 0x64, 0x66, 0x38, 0x64, 0x62, 0x37, 0x61, 0x39, 0x34, 0x37, 0x34, 0x39, 0x38, 0x38, 0x65, 0x66, 0x30, 0x31, 0x33, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x66, 0x31, 0x62, 0x32, 0x32, 0x30, 0x64, 0x65, 0x33, 0x64, 0x38, 0x65, 0x39, 0x63, 0x61, 0x34, 0x63, 0x31, 0x62, 0x35, 0x62, 0x65, 0x33, 0x34, 0x61, 0x37, 0x39, 0x39, 0x62, 0x63, 0x64, 0x65, 0x64, 0x34, 0x66, 0x36, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x35, 0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x37, 0x63, 0x31, 0x65, 0x39, 0x61, 0x36, 0x31, 0x61, 0x30, 0x38, 0x61, 0x38, 0x33, 0x39, 0x38, 0x34, 0x38, 0x33, 0x35, 0x63, 0x37, 0x30, 0x65, 0x63, 0x33, 0x31, 0x64, 0x33, 0x34, 0x64, 0x33, 0x65, 0x61, 0x61, 0x38, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x32, 0x31, 0x30, 0x62, 0x38, 0x66, 0x30, 0x34, 0x64, 0x63, 0x36, 0x64, 0x34, 0x66, 0x37, 0x36, 0x32, 0x31, 0x36, 0x61, 0x63, 0x66, 0x63, 0x62, 0x64, 0x35, 0x39, 0x62, 0x61, 0x38, 0x33, 0x62, 0x65, 0x39, 0x62, 0x36, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x38, 0x63, 0x32, 0x39, 0x31, 0x32, 0x66, 0x30, 0x38, 0x34, 0x61, 0x36, 0x64, 0x31, 0x38, 0x34, 0x61, 0x61, 0x37, 0x33, 0x36, 0x33, 0x38, 0x35, 0x31, 0x33, 0x63, 0x63, 0x62, 0x63, 0x33, 0x32, 0x36, 0x65, 0x30, 0x31, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x64, 0x64, 0x37, 0x62, 0x39, 0x65, 0x36, 0x65, 0x61, 0x62, 0x34, 0x30, 0x39, 0x62, 0x39, 0x32, 0x32, 0x36, 0x33, 0x61, 0x63, 0x32, 0x37, 0x32, 0x64, 0x61, 0x38, 0x30, 0x31, 0x62, 0x36, 0x36, 0x34, 0x66, 0x38, 0x61, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x61, 0x35, 0x66, 0x38, 0x32, 0x35, 0x39, 0x65, 0x64, 0x35, 0x62, 0x30, 0x39, 0x65, 0x31, 0x38, 0x38, 0x63, 0x65, 0x33, 0x34, 0x36, 0x65, 0x65, 0x39, 0x32, 0x64, 0x33, 0x34, 0x61, 0x61, 0x35, 0x64, 0x64, 0x39, 0x33, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x31, 0x66, 0x31, 0x39, 0x37, 0x39, 0x36, 0x31, 0x35, 0x66, 0x30, 0x38, 0x32, 0x31, 0x34, 0x30, 0x62, 0x38, 0x62, 0x62, 0x37, 0x38, 0x63, 0x36, 0x37, 0x62, 0x32, 0x37, 0x61, 0x31, 0x39, 0x34, 0x32, 0x37, 0x31, 0x33, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x36, 0x36, 0x65, 0x37, 0x62, 0x38, 0x34, 0x64, 0x63, 0x64, 0x62, 0x66, 0x33, 0x36, 0x65, 0x65, 0x61, 0x33, 0x65, 0x37, 0x35, 0x62, 0x38, 0x35, 0x33, 0x38, 0x32, 0x61, 0x37, 0x35, 0x66, 0x31, 0x61, 0x31, 0x35, 0x64, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x39, 0x31, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x39, 0x65, 0x37, 0x61, 0x34, 0x65, 0x62, 0x63, 0x32, 0x38, 0x34, 0x65, 0x32, 0x63, 0x63, 0x64, 0x34, 0x32, 0x62, 0x31, 0x62, 0x64, 0x64, 0x36, 0x30, 0x62, 0x64, 0x36, 0x35, 0x31, 0x31, 0x63, 0x30, 0x66, 0x37, 0x37, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x62, 0x66, 0x65, 0x31, 0x66, 0x61, 0x33, 0x62, 0x37, 0x62, 0x37, 0x30, 0x63, 0x31, 0x37, 0x32, 0x65, 0x62, 0x30, 0x34, 0x32, 0x66, 0x36, 0x38, 0x31, 0x39, 0x61, 0x38, 0x39, 0x37, 0x32, 0x35, 0x39, 0x35, 0x34, 0x31, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x39, 0x65, 0x66, 0x31, 0x63, 0x65, 0x35, 0x32, 0x66, 0x65, 0x37, 0x39, 0x36, 0x33, 0x66, 0x31, 0x36, 0x36, 0x64, 0x35, 0x61, 0x32, 0x37, 0x35, 0x63, 0x34, 0x62, 0x31, 0x30, 0x36, 0x39, 0x66, 0x65, 0x33, 0x61, 0x38, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x64, 0x66, 0x35, 0x35, 0x64, 0x63, 0x63, 0x33, 0x34, 0x61, 0x30, 0x35, 0x31, 0x30, 0x31, 0x32, 0x62, 0x35, 0x37, 0x35, 0x63, 0x62, 0x39, 0x36, 0x38, 0x62, 0x63, 0x39, 0x63, 0x34, 0x35, 0x38, 0x65, 0x61, 0x30, 0x39, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x38, 0x62, 0x35, 0x30, 0x31, 0x39, 0x62, 0x38, 0x31, 0x38, 0x36, 0x39, 0x31, 0x36, 0x34, 0x34, 0x38, 0x33, 0x35, 0x66, 0x65, 0x36, 0x39, 0x62, 0x66, 0x32, 0x32, 0x39, 0x65, 0x31, 0x37, 0x31, 0x31, 0x32, 0x64, 0x35, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x30, 0x62, 0x64, 0x37, 0x33, 0x35, 0x35, 0x34, 0x33, 0x65, 0x36, 0x62, 0x66, 0x64, 0x32, 0x65, 0x61, 0x36, 0x66, 0x31, 0x31, 0x62, 0x66, 0x66, 0x36, 0x32, 0x37, 0x33, 0x34, 0x30, 0x62, 0x63, 0x30, 0x33, 0x35, 0x61, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x62, 0x62, 0x30, 0x63, 0x37, 0x33, 0x64, 0x66, 0x39, 0x31, 0x62, 0x39, 0x31, 0x37, 0x34, 0x30, 0x62, 0x36, 0x36, 0x39, 0x33, 0x62, 0x37, 0x37, 0x34, 0x61, 0x37, 0x64, 0x30, 0x35, 0x31, 0x37, 0x37, 0x65, 0x38, 0x65, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x66, 0x63, 0x66, 0x35, 0x65, 0x66, 0x34, 0x36, 0x64, 0x39, 0x33, 0x33, 0x61, 0x35, 0x31, 0x39, 0x64, 0x31, 0x64, 0x31, 0x36, 0x63, 0x36, 0x62, 0x61, 0x33, 0x31, 0x38, 0x39, 0x62, 0x32, 0x37, 0x34, 0x39, 0x36, 0x32, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x31, 0x31, 0x64, 0x37, 0x37, 0x61, 0x38, 0x39, 0x37, 0x37, 0x66, 0x61, 0x63, 0x33, 0x30, 0x64, 0x32, 0x36, 0x38, 0x34, 0x34, 0x35, 0x65, 0x35, 0x33, 0x31, 0x31, 0x34, 0x39, 0x62, 0x33, 0x31, 0x35, 0x34, 0x31, 0x61, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x62, 0x31, 0x36, 0x32, 0x36, 0x65, 0x66, 0x34, 0x38, 0x61, 0x31, 0x64, 0x37, 0x64, 0x37, 0x35, 0x35, 0x32, 0x61, 0x35, 0x65, 0x30, 0x32, 0x39, 0x38, 0x66, 0x31, 0x66, 0x63, 0x32, 0x33, 0x61, 0x33, 0x62, 0x34, 0x38, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x31, 0x33, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x39, 0x34, 0x33, 0x62, 0x65, 0x31, 0x32, 0x32, 0x32, 0x63, 0x64, 0x31, 0x34, 0x30, 0x30, 0x61, 0x32, 0x33, 0x39, 0x39, 0x64, 0x64, 0x31, 0x62, 0x34, 0x35, 0x39, 0x34, 0x34, 0x35, 0x63, 0x66, 0x36, 0x64, 0x35, 0x34, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x37, 0x63, 0x32, 0x62, 0x39, 0x66, 0x35, 0x30, 0x36, 0x33, 0x37, 0x62, 0x65, 0x63, 0x65, 0x30, 0x63, 0x61, 0x39, 0x35, 0x39, 0x32, 0x30, 0x38, 0x61, 0x65, 0x66, 0x65, 0x65, 0x36, 0x34, 0x36, 0x33, 0x62, 0x61, 0x37, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x62, 0x39, 0x30, 0x36, 0x65, 0x61, 0x37, 0x32, 0x39, 0x66, 0x34, 0x36, 0x35, 0x35, 0x61, 0x66, 0x65, 0x33, 0x65, 0x35, 0x37, 0x64, 0x33, 0x35, 0x32, 0x37, 0x37, 0x63, 0x39, 0x36, 0x37, 0x64, 0x66, 0x61, 0x31, 0x35, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x39, 0x35, 0x62, 0x64, 0x38, 0x63, 0x65, 0x32, 0x65, 0x30, 0x63, 0x36, 0x37, 0x62, 0x66, 0x31, 0x63, 0x37, 0x61, 0x35, 0x33, 0x31, 0x64, 0x34, 0x37, 0x37, 0x62, 0x63, 0x61, 0x31, 0x62, 0x32, 0x62, 0x39, 0x37, 0x35, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x66, 0x38, 0x32, 0x30, 0x35, 0x30, 0x30, 0x62, 0x37, 0x30, 0x66, 0x34, 0x61, 0x33, 0x65, 0x33, 0x32, 0x33, 0x39, 0x64, 0x36, 0x31, 0x39, 0x63, 0x66, 0x66, 0x38, 0x66, 0x32, 0x32, 0x32, 0x30, 0x37, 0x35, 0x62, 0x31, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x33, 0x35, 0x36, 0x35, 0x64, 0x35, 0x32, 0x62, 0x36, 0x38, 0x38, 0x61, 0x64, 0x64, 0x65, 0x64, 0x30, 0x38, 0x31, 0x36, 0x38, 0x62, 0x32, 0x64, 0x33, 0x38, 0x37, 0x32, 0x64, 0x31, 0x37, 0x64, 0x30, 0x61, 0x32, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x37, 0x63, 0x32, 0x30, 0x35, 0x30, 0x61, 0x32, 0x32, 0x37, 0x62, 0x62, 0x66, 0x64, 0x36, 0x30, 0x39, 0x33, 0x37, 0x65, 0x32, 0x36, 0x38, 0x63, 0x65, 0x61, 0x33, 0x65, 0x36, 0x38, 0x66, 0x65, 0x61, 0x38, 0x64, 0x31, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x35, 0x39, 0x64, 0x63, 0x36, 0x30, 0x62, 0x65, 0x38, 0x62, 0x32, 0x66, 0x63, 0x31, 0x39, 0x61, 0x62, 0x64, 0x30, 0x61, 0x35, 0x37, 0x38, 0x32, 0x63, 0x35, 0x32, 0x63, 0x32, 0x38, 0x34, 0x30, 0x30, 0x62, 0x63, 0x65, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x65, 0x64, 0x35, 0x66, 0x62, 0x61, 0x38, 0x64, 0x32, 0x65, 0x61, 0x62, 0x36, 0x37, 0x33, 0x61, 0x65, 0x63, 0x30, 0x34, 0x32, 0x64, 0x33, 0x30, 0x65, 0x34, 0x65, 0x38, 0x61, 0x36, 0x31, 0x31, 0x64, 0x38, 0x63, 0x35, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x61, 0x30, 0x38, 0x37, 0x62, 0x39, 0x33, 0x35, 0x31, 0x63, 0x61, 0x34, 0x32, 0x66, 0x35, 0x38, 0x66, 0x33, 0x36, 0x65, 0x30, 0x32, 0x31, 0x39, 0x32, 0x37, 0x61, 0x32, 0x32, 0x39, 0x38, 0x38, 0x32, 0x38, 0x34, 0x66, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x65, 0x30, 0x30, 0x32, 0x33, 0x66, 0x35, 0x37, 0x32, 0x32, 0x36, 0x35, 0x30, 0x66, 0x33, 0x61, 0x38, 0x61, 0x63, 0x30, 0x31, 0x30, 0x30, 0x39, 0x31, 0x32, 0x35, 0x65, 0x37, 0x34, 0x65, 0x33, 0x66, 0x38, 0x32, 0x65, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x31, 0x38, 0x30, 0x33, 0x33, 0x37, 0x30, 0x62, 0x64, 0x64, 0x62, 0x31, 0x32, 0x39, 0x64, 0x32, 0x33, 0x39, 0x66, 0x64, 0x31, 0x36, 0x65, 0x61, 0x38, 0x35, 0x32, 0x36, 0x61, 0x36, 0x31, 0x38, 0x38, 0x61, 0x65, 0x35, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x30, 0x35, 0x32, 0x37, 0x64, 0x34, 0x34, 0x34, 0x63, 0x34, 0x39, 0x30, 0x65, 0x39, 0x66, 0x63, 0x33, 0x66, 0x35, 0x63, 0x63, 0x34, 0x34, 0x65, 0x36, 0x36, 0x65, 0x62, 0x34, 0x66, 0x33, 0x30, 0x36, 0x62, 0x33, 0x38, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x32, 0x30, 0x36, 0x65, 0x31, 0x61, 0x31, 0x64, 0x61, 0x37, 0x32, 0x30, 0x37, 0x65, 0x61, 0x35, 0x31, 0x38, 0x62, 0x31, 0x31, 0x32, 0x34, 0x31, 0x38, 0x62, 0x61, 0x61, 0x38, 0x62, 0x30, 0x36, 0x32, 0x36, 0x30, 0x33, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x31, 0x61, 0x30, 0x34, 0x36, 0x63, 0x61, 0x66, 0x35, 0x62, 0x34, 0x61, 0x35, 0x37, 0x66, 0x34, 0x66, 0x64, 0x34, 0x62, 0x63, 0x31, 0x37, 0x33, 0x36, 0x32, 0x32, 0x31, 0x32, 0x36, 0x62, 0x34, 0x65, 0x32, 0x66, 0x64, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x30, 0x30, 0x38, 0x61, 0x37, 0x32, 0x66, 0x38, 0x30, 0x33, 0x36, 0x66, 0x33, 0x66, 0x65, 0x62, 0x61, 0x35, 0x34, 0x32, 0x65, 0x33, 0x35, 0x30, 0x37, 0x38, 0x63, 0x30, 0x35, 0x37, 0x66, 0x33, 0x32, 0x61, 0x38, 0x38, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x36, 0x32, 0x39, 0x31, 0x31, 0x36, 0x35, 0x62, 0x35, 0x39, 0x33, 0x33, 0x32, 0x64, 0x66, 0x35, 0x66, 0x31, 0x38, 0x63, 0x65, 0x35, 0x63, 0x39, 0x38, 0x38, 0x35, 0x36, 0x66, 0x61, 0x65, 0x39, 0x35, 0x38, 0x39, 0x37, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x39, 0x39, 0x64, 0x66, 0x62, 0x65, 0x39, 0x38, 0x39, 0x64, 0x33, 0x62, 0x61, 0x35, 0x32, 0x39, 0x64, 0x31, 0x39, 0x37, 0x35, 0x31, 0x62, 0x37, 0x66, 0x34, 0x33, 0x31, 0x37, 0x66, 0x38, 0x39, 0x35, 0x33, 0x61, 0x33, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x38, 0x63, 0x32, 0x38, 0x35, 0x65, 0x66, 0x31, 0x32, 0x33, 0x33, 0x66, 0x65, 0x34, 0x64, 0x33, 0x31, 0x63, 0x38, 0x66, 0x62, 0x31, 0x33, 0x37, 0x38, 0x33, 0x33, 0x33, 0x37, 0x32, 0x31, 0x63, 0x31, 0x32, 0x65, 0x32, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x64, 0x31, 0x32, 0x65, 0x35, 0x35, 0x36, 0x61, 0x36, 0x30, 0x33, 0x37, 0x33, 0x36, 0x66, 0x65, 0x62, 0x61, 0x34, 0x61, 0x36, 0x66, 0x61, 0x38, 0x62, 0x64, 0x34, 0x61, 0x63, 0x34, 0x35, 0x64, 0x36, 0x36, 0x32, 0x61, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x61, 0x65, 0x37, 0x33, 0x35, 0x64, 0x39, 0x31, 0x35, 0x65, 0x39, 0x34, 0x36, 0x38, 0x36, 0x36, 0x65, 0x31, 0x66, 0x65, 0x61, 0x37, 0x37, 0x65, 0x35, 0x65, 0x61, 0x34, 0x36, 0x36, 0x62, 0x35, 0x63, 0x61, 0x64, 0x64, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x37, 0x36, 0x37, 0x62, 0x63, 0x38, 0x37, 0x39, 0x34, 0x61, 0x65, 0x66, 0x39, 0x61, 0x30, 0x61, 0x33, 0x38, 0x66, 0x65, 0x61, 0x35, 0x63, 0x38, 0x31, 0x66, 0x31, 0x34, 0x36, 0x39, 0x34, 0x66, 0x66, 0x32, 0x31, 0x61, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x32, 0x66, 0x38, 0x65, 0x32, 0x38, 0x61, 0x36, 0x38, 0x31, 0x66, 0x37, 0x37, 0x63, 0x35, 0x38, 0x33, 0x62, 0x64, 0x30, 0x65, 0x63, 0x64, 0x65, 0x31, 0x36, 0x36, 0x33, 0x34, 0x62, 0x64, 0x64, 0x37, 0x65, 0x30, 0x30, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x34, 0x61, 0x36, 0x65, 0x38, 0x64, 0x36, 0x61, 0x61, 0x62, 0x33, 0x34, 0x63, 0x65, 0x38, 0x35, 0x39, 0x37, 0x36, 0x38, 0x31, 0x34, 0x63, 0x31, 0x33, 0x32, 0x37, 0x62, 0x64, 0x36, 0x65, 0x61, 0x30, 0x37, 0x38, 0x34, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x39, 0x62, 0x65, 0x37, 0x61, 0x62, 0x31, 0x32, 0x36, 0x61, 0x35, 0x33, 0x39, 0x38, 0x65, 0x64, 0x64, 0x36, 0x64, 0x61, 0x39, 0x66, 0x31, 0x38, 0x34, 0x34, 0x37, 0x65, 0x37, 0x38, 0x63, 0x36, 0x39, 0x32, 0x61, 0x34, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x34, 0x36, 0x66, 0x63, 0x65, 0x65, 0x36, 0x61, 0x33, 0x62, 0x62, 0x31, 0x34, 0x35, 0x62, 0x35, 0x39, 0x34, 0x61, 0x32, 0x34, 0x33, 0x61, 0x33, 0x39, 0x31, 0x33, 0x66, 0x63, 0x65, 0x35, 0x64, 0x61, 0x64, 0x36, 0x66, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x39, 0x62, 0x31, 0x31, 0x61, 0x38, 0x61, 0x62, 0x31, 0x66, 0x66, 0x35, 0x65, 0x32, 0x32, 0x65, 0x35, 0x61, 0x65, 0x36, 0x35, 0x31, 0x37, 0x32, 0x31, 0x34, 0x66, 0x37, 0x33, 0x63, 0x35, 0x62, 0x39, 0x62, 0x35, 0x35, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x39, 0x61, 0x61, 0x36, 0x34, 0x64, 0x35, 0x62, 0x37, 0x64, 0x31, 0x38, 0x31, 0x64, 0x61, 0x65, 0x39, 0x64, 0x33, 0x63, 0x62, 0x34, 0x34, 0x39, 0x39, 0x35, 0x35, 0x63, 0x38, 0x39, 0x63, 0x31, 0x66, 0x39, 0x36, 0x33, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x30, 0x37, 0x39, 0x66, 0x35, 0x31, 0x38, 0x38, 0x37, 0x37, 0x37, 0x34, 0x64, 0x38, 0x30, 0x32, 0x31, 0x63, 0x62, 0x33, 0x62, 0x35, 0x37, 0x35, 0x66, 0x35, 0x38, 0x66, 0x31, 0x38, 0x65, 0x39, 0x61, 0x63, 0x66, 0x39, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x30, 0x63, 0x33, 0x30, 0x36, 0x66, 0x38, 0x31, 0x65, 0x66, 0x35, 0x64, 0x39, 0x35, 0x38, 0x30, 0x63, 0x30, 0x36, 0x63, 0x62, 0x31, 0x61, 0x62, 0x32, 0x30, 0x31, 0x62, 0x39, 0x35, 0x63, 0x37, 0x34, 0x38, 0x61, 0x36, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x64, 0x63, 0x37, 0x66, 0x31, 0x38, 0x63, 0x65, 0x65, 0x37, 0x65, 0x64, 0x61, 0x62, 0x35, 0x62, 0x37, 0x39, 0x35, 0x33, 0x33, 0x37, 0x62, 0x31, 0x64, 0x66, 0x36, 0x61, 0x39, 0x65, 0x38, 0x62, 0x64, 0x38, 0x61, 0x65, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x31, 0x63, 0x37, 0x37, 0x38, 0x65, 0x66, 0x32, 0x61, 0x30, 0x64, 0x37, 0x66, 0x37, 0x35, 0x31, 0x65, 0x61, 0x38, 0x63, 0x30, 0x37, 0x34, 0x64, 0x31, 0x66, 0x38, 0x31, 0x32, 0x32, 0x34, 0x33, 0x38, 0x36, 0x33, 0x65, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x30, 0x38, 0x35, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x64, 0x34, 0x62, 0x35, 0x34, 0x64, 0x33, 0x37, 0x61, 0x38, 0x63, 0x66, 0x35, 0x39, 0x39, 0x38, 0x32, 0x31, 0x32, 0x33, 0x35, 0x66, 0x30, 0x36, 0x32, 0x66, 0x61, 0x39, 0x64, 0x31, 0x37, 0x30, 0x65, 0x64, 0x65, 0x38, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x33, 0x61, 0x36, 0x63, 0x32, 0x65, 0x62, 0x38, 0x62, 0x34, 0x30, 0x61, 0x62, 0x30, 0x39, 0x36, 0x62, 0x34, 0x66, 0x36, 0x37, 0x65, 0x37, 0x34, 0x61, 0x38, 0x39, 0x37, 0x62, 0x38, 0x34, 0x30, 0x37, 0x34, 0x36, 0x65, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x34, 0x64, 0x38, 0x31, 0x65, 0x31, 0x38, 0x66, 0x34, 0x36, 0x65, 0x32, 0x63, 0x66, 0x62, 0x35, 0x63, 0x31, 0x66, 0x63, 0x66, 0x35, 0x30, 0x34, 0x31, 0x62, 0x63, 0x38, 0x35, 0x36, 0x39, 0x37, 0x36, 0x37, 0x64, 0x31, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x33, 0x38, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x64, 0x65, 0x31, 0x32, 0x30, 0x33, 0x64, 0x33, 0x63, 0x63, 0x32, 0x63, 0x65, 0x61, 0x33, 0x31, 0x63, 0x38, 0x32, 0x65, 0x65, 0x32, 0x64, 0x65, 0x35, 0x39, 0x31, 0x36, 0x38, 0x38, 0x30, 0x37, 0x39, 0x39, 0x65, 0x61, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x30, 0x66, 0x30, 0x34, 0x66, 0x63, 0x66, 0x33, 0x37, 0x61, 0x35, 0x33, 0x61, 0x34, 0x65, 0x32, 0x34, 0x65, 0x64, 0x65, 0x36, 0x65, 0x39, 0x33, 0x31, 0x30, 0x34, 0x65, 0x37, 0x38, 0x62, 0x65, 0x31, 0x64, 0x33, 0x63, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x65, 0x31, 0x64, 0x63, 0x39, 0x37, 0x66, 0x63, 0x64, 0x37, 0x62, 0x37, 0x63, 0x34, 0x64, 0x33, 0x61, 0x31, 0x38, 0x61, 0x34, 0x39, 0x64, 0x36, 0x66, 0x32, 0x61, 0x35, 0x63, 0x31, 0x62, 0x31, 0x61, 0x39, 0x30, 0x36, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x34, 0x65, 0x65, 0x39, 0x64, 0x35, 0x30, 0x32, 0x65, 0x37, 0x64, 0x32, 0x64, 0x32, 0x65, 0x39, 0x39, 0x65, 0x35, 0x39, 0x64, 0x38, 0x63, 0x61, 0x37, 0x64, 0x35, 0x66, 0x30, 0x30, 0x63, 0x39, 0x34, 0x62, 0x34, 0x64, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x34, 0x30, 0x61, 0x33, 0x37, 0x66, 0x38, 0x30, 0x35, 0x32, 0x39, 0x38, 0x31, 0x35, 0x31, 0x35, 0x62, 0x63, 0x65, 0x30, 0x37, 0x38, 0x64, 0x61, 0x39, 0x33, 0x61, 0x66, 0x61, 0x34, 0x37, 0x38, 0x39, 0x62, 0x35, 0x37, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x63, 0x61, 0x63, 0x34, 0x38, 0x38, 0x31, 0x31, 0x31, 0x61, 0x34, 0x66, 0x64, 0x35, 0x39, 0x35, 0x66, 0x35, 0x36, 0x38, 0x61, 0x65, 0x33, 0x61, 0x38, 0x35, 0x38, 0x37, 0x37, 0x30, 0x66, 0x63, 0x39, 0x31, 0x35, 0x64, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x34, 0x61, 0x34, 0x30, 0x38, 0x66, 0x35, 0x30, 0x65, 0x39, 0x65, 0x37, 0x32, 0x31, 0x34, 0x36, 0x61, 0x32, 0x38, 0x63, 0x65, 0x34, 0x66, 0x63, 0x38, 0x64, 0x39, 0x30, 0x32, 0x37, 0x31, 0x66, 0x31, 0x31, 0x36, 0x65, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x39, 0x64, 0x62, 0x32, 0x39, 0x64, 0x62, 0x63, 0x31, 0x39, 0x64, 0x31, 0x32, 0x33, 0x35, 0x64, 0x61, 0x37, 0x32, 0x39, 0x38, 0x61, 0x30, 0x34, 0x30, 0x38, 0x31, 0x63, 0x33, 0x31, 0x35, 0x37, 0x34, 0x32, 0x65, 0x39, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x30, 0x34, 0x35, 0x37, 0x32, 0x38, 0x34, 0x37, 0x64, 0x33, 0x31, 0x65, 0x38, 0x31, 0x66, 0x37, 0x37, 0x36, 0x35, 0x63, 0x61, 0x35, 0x62, 0x66, 0x63, 0x39, 0x64, 0x35, 0x35, 0x37, 0x31, 0x35, 0x39, 0x66, 0x33, 0x36, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x37, 0x37, 0x31, 0x62, 0x30, 0x62, 0x66, 0x33, 0x34, 0x32, 0x37, 0x66, 0x39, 0x61, 0x65, 0x37, 0x61, 0x39, 0x33, 0x65, 0x37, 0x63, 0x32, 0x65, 0x36, 0x31, 0x65, 0x65, 0x36, 0x33, 0x39, 0x34, 0x31, 0x66, 0x64, 0x62, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x63, 0x32, 0x36, 0x61, 0x38, 0x65, 0x39, 0x37, 0x31, 0x62, 0x61, 0x61, 0x31, 0x38, 0x35, 0x35, 0x64, 0x36, 0x33, 0x33, 0x62, 0x61, 0x37, 0x30, 0x33, 0x66, 0x30, 0x32, 0x38, 0x63, 0x63, 0x37, 0x38, 0x37, 0x33, 0x31, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x37, 0x65, 0x33, 0x65, 0x33, 0x61, 0x65, 0x32, 0x30, 0x30, 0x33, 0x33, 0x34, 0x38, 0x34, 0x35, 0x39, 0x33, 0x39, 0x32, 0x66, 0x37, 0x64, 0x66, 0x63, 0x65, 0x34, 0x34, 0x61, 0x66, 0x37, 0x63, 0x32, 0x31, 0x61, 0x64, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x66, 0x31, 0x36, 0x66, 0x31, 0x65, 0x37, 0x35, 0x63, 0x33, 0x63, 0x30, 0x36, 0x61, 0x39, 0x34, 0x37, 0x38, 0x65, 0x38, 0x63, 0x35, 0x39, 0x37, 0x61, 0x34, 0x30, 0x61, 0x33, 0x63, 0x62, 0x30, 0x62, 0x66, 0x30, 0x34, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x36, 0x62, 0x31, 0x35, 0x34, 0x36, 0x38, 0x39, 0x34, 0x66, 0x39, 0x61, 0x38, 0x35, 0x65, 0x32, 0x30, 0x33, 0x66, 0x62, 0x33, 0x33, 0x36, 0x64, 0x62, 0x35, 0x36, 0x39, 0x62, 0x31, 0x36, 0x63, 0x32, 0x35, 0x65, 0x30, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x33, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x36, 0x31, 0x36, 0x65, 0x32, 0x38, 0x39, 0x32, 0x66, 0x61, 0x32, 0x36, 0x39, 0x37, 0x30, 0x35, 0x62, 0x32, 0x30, 0x34, 0x36, 0x62, 0x38, 0x66, 0x65, 0x33, 0x65, 0x37, 0x32, 0x66, 0x61, 0x35, 0x35, 0x38, 0x31, 0x36, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x34, 0x64, 0x31, 0x64, 0x34, 0x31, 0x36, 0x39, 0x33, 0x65, 0x34, 0x36, 0x32, 0x63, 0x66, 0x39, 0x38, 0x32, 0x66, 0x64, 0x38, 0x31, 0x64, 0x30, 0x61, 0x61, 0x37, 0x30, 0x31, 0x64, 0x33, 0x61, 0x35, 0x33, 0x37, 0x34, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x31, 0x38, 0x37, 0x39, 0x39, 0x61, 0x35, 0x39, 0x32, 0x35, 0x35, 0x37, 0x36, 0x32, 0x31, 0x33, 0x65, 0x32, 0x31, 0x38, 0x39, 0x36, 0x65, 0x30, 0x35, 0x33, 0x39, 0x61, 0x62, 0x62, 0x38, 0x35, 0x62, 0x30, 0x35, 0x61, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x33, 0x61, 0x32, 0x38, 0x63, 0x31, 0x64, 0x66, 0x61, 0x66, 0x62, 0x30, 0x35, 0x30, 0x35, 0x62, 0x64, 0x63, 0x65, 0x31, 0x39, 0x66, 0x65, 0x30, 0x32, 0x35, 0x66, 0x35, 0x30, 0x36, 0x61, 0x36, 0x64, 0x30, 0x31, 0x63, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x61, 0x34, 0x37, 0x65, 0x33, 0x39, 0x33, 0x33, 0x32, 0x34, 0x36, 0x63, 0x33, 0x66, 0x64, 0x36, 0x32, 0x39, 0x37, 0x39, 0x61, 0x31, 0x65, 0x61, 0x31, 0x39, 0x66, 0x66, 0x64, 0x66, 0x38, 0x63, 0x37, 0x32, 0x65, 0x66, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x38, 0x32, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x33, 0x31, 0x39, 0x32, 0x39, 0x37, 0x33, 0x35, 0x31, 0x33, 0x32, 0x31, 0x30, 0x32, 0x34, 0x37, 0x31, 0x62, 0x61, 0x35, 0x39, 0x30, 0x30, 0x37, 0x62, 0x36, 0x36, 0x34, 0x34, 0x63, 0x63, 0x30, 0x63, 0x31, 0x64, 0x65, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x35, 0x64, 0x38, 0x64, 0x33, 0x63, 0x65, 0x31, 0x37, 0x39, 0x38, 0x61, 0x63, 0x61, 0x39, 0x30, 0x32, 0x37, 0x35, 0x34, 0x66, 0x31, 0x36, 0x34, 0x62, 0x38, 0x62, 0x65, 0x32, 0x61, 0x30, 0x32, 0x33, 0x32, 0x39, 0x63, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x62, 0x31, 0x61, 0x35, 0x36, 0x31, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x31, 0x63, 0x37, 0x63, 0x37, 0x37, 0x35, 0x64, 0x63, 0x37, 0x35, 0x37, 0x34, 0x38, 0x36, 0x36, 0x39, 0x62, 0x38, 0x62, 0x65, 0x34, 0x64, 0x65, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x65, 0x65, 0x33, 0x36, 0x61, 0x34, 0x39, 0x65, 0x65, 0x35, 0x30, 0x65, 0x63, 0x66, 0x37, 0x31, 0x36, 0x66, 0x31, 0x30, 0x34, 0x37, 0x39, 0x31, 0x35, 0x36, 0x34, 0x36, 0x37, 0x37, 0x39, 0x66, 0x38, 0x62, 0x61, 0x30, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x36, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x64, 0x62, 0x35, 0x65, 0x30, 0x36, 0x62, 0x34, 0x38, 0x31, 0x35, 0x64, 0x33, 0x31, 0x63, 0x62, 0x35, 0x36, 0x61, 0x38, 0x37, 0x31, 0x39, 0x62, 0x61, 0x33, 0x33, 0x61, 0x66, 0x32, 0x64, 0x37, 0x33, 0x65, 0x37, 0x32, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x38, 0x62, 0x62, 0x36, 0x35, 0x61, 0x36, 0x66, 0x62, 0x62, 0x34, 0x39, 0x62, 0x64, 0x34, 0x31, 0x33, 0x33, 0x39, 0x36, 0x61, 0x39, 0x64, 0x37, 0x65, 0x33, 0x31, 0x30, 0x35, 0x33, 0x62, 0x62, 0x62, 0x33, 0x37, 0x61, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x33, 0x38, 0x34, 0x63, 0x36, 0x65, 0x37, 0x31, 0x37, 0x65, 0x62, 0x65, 0x34, 0x62, 0x32, 0x33, 0x30, 0x31, 0x34, 0x65, 0x35, 0x31, 0x66, 0x33, 0x31, 0x63, 0x39, 0x64, 0x66, 0x37, 0x65, 0x34, 0x65, 0x32, 0x35, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x34, 0x31, 0x35, 0x38, 0x61, 0x31, 0x61, 0x39, 0x64, 0x63, 0x36, 0x39, 0x33, 0x63, 0x31, 0x33, 0x33, 0x66, 0x36, 0x35, 0x65, 0x34, 0x37, 0x62, 0x35, 0x63, 0x33, 0x61, 0x65, 0x32, 0x66, 0x37, 0x37, 0x33, 0x61, 0x38, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x33, 0x34, 0x63, 0x30, 0x64, 0x66, 0x37, 0x62, 0x62, 0x63, 0x31, 0x37, 0x32, 0x62, 0x36, 0x63, 0x31, 0x38, 0x36, 0x62, 0x30, 0x62, 0x37, 0x32, 0x35, 0x34, 0x37, 0x61, 0x63, 0x65, 0x38, 0x62, 0x66, 0x37, 0x35, 0x34, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x36, 0x36, 0x30, 0x36, 0x33, 0x61, 0x61, 0x35, 0x64, 0x65, 0x31, 0x64, 0x62, 0x35, 0x63, 0x36, 0x37, 0x31, 0x66, 0x33, 0x64, 0x64, 0x36, 0x39, 0x39, 0x64, 0x35, 0x61, 0x62, 0x65, 0x32, 0x31, 0x33, 0x65, 0x65, 0x39, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x32, 0x35, 0x64, 0x34, 0x36, 0x61, 0x35, 0x61, 0x38, 0x30, 0x39, 0x34, 0x33, 0x39, 0x32, 0x34, 0x61, 0x33, 0x39, 0x65, 0x35, 0x62, 0x38, 0x34, 0x62, 0x39, 0x36, 0x64, 0x61, 0x30, 0x61, 0x63, 0x34, 0x35, 0x30, 0x35, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x31, 0x62, 0x62, 0x63, 0x61, 0x30, 0x39, 0x39, 0x66, 0x66, 0x38, 0x39, 0x39, 0x62, 0x61, 0x62, 0x30, 0x37, 0x65, 0x61, 0x31, 0x63, 0x66, 0x38, 0x36, 0x39, 0x36, 0x35, 0x63, 0x33, 0x30, 0x35, 0x34, 0x63, 0x38, 0x39, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x66, 0x37, 0x36, 0x36, 0x62, 0x30, 0x65, 0x34, 0x36, 0x64, 0x37, 0x33, 0x66, 0x63, 0x64, 0x34, 0x64, 0x35, 0x32, 0x65, 0x37, 0x61, 0x37, 0x32, 0x65, 0x31, 0x62, 0x39, 0x31, 0x39, 0x30, 0x63, 0x63, 0x36, 0x33, 0x32, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x30, 0x64, 0x63, 0x37, 0x64, 0x64, 0x37, 0x61, 0x35, 0x33, 0x64, 0x36, 0x31, 0x32, 0x37, 0x32, 0x38, 0x62, 0x63, 0x62, 0x64, 0x32, 0x62, 0x32, 0x37, 0x63, 0x31, 0x39, 0x64, 0x64, 0x34, 0x64, 0x37, 0x64, 0x36, 0x36, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x35, 0x36, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x64, 0x32, 0x65, 0x39, 0x31, 0x35, 0x34, 0x39, 0x36, 0x34, 0x62, 0x34, 0x31, 0x63, 0x38, 0x64, 0x35, 0x30, 0x61, 0x37, 0x34, 0x38, 0x37, 0x64, 0x33, 0x39, 0x31, 0x65, 0x37, 0x65, 0x65, 0x32, 0x63, 0x33, 0x64, 0x33, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x32, 0x61, 0x37, 0x38, 0x35, 0x66, 0x34, 0x61, 0x39, 0x32, 0x31, 0x36, 0x33, 0x32, 0x35, 0x30, 0x34, 0x63, 0x65, 0x35, 0x64, 0x30, 0x31, 0x35, 0x66, 0x38, 0x33, 0x63, 0x34, 0x39, 0x61, 0x61, 0x38, 0x33, 0x38, 0x64, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x31, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x33, 0x64, 0x65, 0x35, 0x30, 0x30, 0x32, 0x36, 0x63, 0x61, 0x36, 0x37, 0x63, 0x39, 0x34, 0x64, 0x66, 0x35, 0x34, 0x66, 0x30, 0x36, 0x36, 0x32, 0x36, 0x30, 0x65, 0x31, 0x64, 0x31, 0x34, 0x61, 0x63, 0x63, 0x31, 0x31, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x38, 0x38, 0x30, 0x37, 0x38, 0x34, 0x34, 0x34, 0x30, 0x32, 0x37, 0x65, 0x33, 0x38, 0x36, 0x37, 0x39, 0x38, 0x61, 0x38, 0x61, 0x65, 0x36, 0x38, 0x36, 0x39, 0x38, 0x39, 0x31, 0x39, 0x64, 0x35, 0x63, 0x63, 0x32, 0x33, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x36, 0x30, 0x38, 0x31, 0x30, 0x35, 0x63, 0x65, 0x34, 0x62, 0x39, 0x65, 0x31, 0x31, 0x66, 0x38, 0x36, 0x62, 0x66, 0x34, 0x39, 0x37, 0x66, 0x66, 0x63, 0x61, 0x33, 0x62, 0x37, 0x38, 0x39, 0x36, 0x37, 0x62, 0x35, 0x66, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x31, 0x35, 0x39, 0x30, 0x39, 0x39, 0x30, 0x37, 0x35, 0x32, 0x30, 0x37, 0x63, 0x36, 0x38, 0x30, 0x37, 0x36, 0x36, 0x33, 0x62, 0x31, 0x66, 0x30, 0x66, 0x37, 0x65, 0x64, 0x61, 0x35, 0x34, 0x61, 0x63, 0x38, 0x63, 0x63, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x35, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x31, 0x61, 0x35, 0x65, 0x33, 0x39, 0x65, 0x65, 0x32, 0x66, 0x36, 0x38, 0x30, 0x61, 0x36, 0x30, 0x30, 0x66, 0x62, 0x66, 0x36, 0x66, 0x61, 0x32, 0x39, 0x37, 0x64, 0x65, 0x39, 0x30, 0x66, 0x33, 0x32, 0x32, 0x35, 0x63, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x66, 0x66, 0x66, 0x33, 0x37, 0x62, 0x65, 0x30, 0x31, 0x61, 0x33, 0x38, 0x38, 0x38, 0x64, 0x33, 0x62, 0x38, 0x62, 0x38, 0x65, 0x31, 0x38, 0x38, 0x38, 0x30, 0x61, 0x37, 0x64, 0x64, 0x65, 0x66, 0x65, 0x65, 0x65, 0x61, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x31, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x61, 0x36, 0x32, 0x39, 0x61, 0x33, 0x39, 0x36, 0x32, 0x35, 0x35, 0x32, 0x63, 0x62, 0x38, 0x65, 0x64, 0x65, 0x64, 0x38, 0x38, 0x39, 0x36, 0x33, 0x36, 0x61, 0x61, 0x66, 0x62, 0x64, 0x30, 0x63, 0x31, 0x38, 0x63, 0x65, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x62, 0x61, 0x35, 0x33, 0x35, 0x39, 0x66, 0x37, 0x65, 0x63, 0x33, 0x62, 0x63, 0x37, 0x37, 0x30, 0x61, 0x63, 0x34, 0x39, 0x39, 0x37, 0x35, 0x64, 0x38, 0x34, 0x34, 0x65, 0x63, 0x39, 0x37, 0x31, 0x36, 0x32, 0x35, 0x36, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x31, 0x64, 0x66, 0x32, 0x34, 0x61, 0x34, 0x66, 0x37, 0x66, 0x62, 0x32, 0x63, 0x37, 0x62, 0x34, 0x37, 0x32, 0x65, 0x30, 0x62, 0x62, 0x30, 0x30, 0x36, 0x63, 0x62, 0x32, 0x37, 0x64, 0x63, 0x64, 0x31, 0x36, 0x34, 0x31, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x37, 0x64, 0x35, 0x34, 0x63, 0x37, 0x63, 0x36, 0x35, 0x37, 0x30, 0x65, 0x66, 0x63, 0x61, 0x35, 0x62, 0x34, 0x62, 0x38, 0x63, 0x65, 0x37, 0x30, 0x66, 0x35, 0x32, 0x61, 0x35, 0x37, 0x37, 0x33, 0x65, 0x35, 0x64, 0x35, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x31, 0x37, 0x33, 0x61, 0x61, 0x36, 0x65, 0x64, 0x66, 0x34, 0x36, 0x39, 0x64, 0x31, 0x38, 0x35, 0x65, 0x35, 0x39, 0x62, 0x64, 0x32, 0x36, 0x61, 0x65, 0x34, 0x32, 0x33, 0x36, 0x62, 0x39, 0x32, 0x62, 0x34, 0x64, 0x38, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x66, 0x34, 0x61, 0x64, 0x31, 0x34, 0x65, 0x30, 0x62, 0x62, 0x34, 0x34, 0x65, 0x32, 0x63, 0x65, 0x32, 0x63, 0x31, 0x34, 0x33, 0x35, 0x39, 0x63, 0x37, 0x35, 0x62, 0x38, 0x65, 0x37, 0x33, 0x32, 0x64, 0x33, 0x37, 0x30, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x35, 0x66, 0x36, 0x32, 0x37, 0x32, 0x33, 0x31, 0x34, 0x38, 0x30, 0x64, 0x30, 0x64, 0x39, 0x35, 0x33, 0x30, 0x32, 0x65, 0x36, 0x64, 0x38, 0x39, 0x66, 0x63, 0x33, 0x32, 0x63, 0x62, 0x31, 0x64, 0x34, 0x66, 0x65, 0x37, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x37, 0x37, 0x35, 0x64, 0x62, 0x61, 0x32, 0x61, 0x66, 0x34, 0x63, 0x33, 0x30, 0x61, 0x33, 0x61, 0x37, 0x38, 0x33, 0x36, 0x35, 0x39, 0x33, 0x39, 0x63, 0x64, 0x37, 0x31, 0x63, 0x32, 0x66, 0x39, 0x64, 0x65, 0x39, 0x35, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x39, 0x34, 0x32, 0x33, 0x35, 0x66, 0x63, 0x33, 0x62, 0x33, 0x66, 0x34, 0x37, 0x61, 0x32, 0x34, 0x31, 0x33, 0x61, 0x66, 0x33, 0x31, 0x65, 0x38, 0x38, 0x34, 0x39, 0x31, 0x34, 0x39, 0x30, 0x38, 0x65, 0x66, 0x30, 0x63, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x65, 0x64, 0x63, 0x63, 0x36, 0x62, 0x38, 0x62, 0x36, 0x39, 0x36, 0x32, 0x64, 0x35, 0x64, 0x39, 0x32, 0x38, 0x38, 0x63, 0x31, 0x35, 0x36, 0x63, 0x35, 0x37, 0x39, 0x64, 0x34, 0x37, 0x63, 0x30, 0x61, 0x39, 0x66, 0x63, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x63, 0x34, 0x38, 0x64, 0x34, 0x30, 0x63, 0x36, 0x36, 0x34, 0x63, 0x63, 0x39, 0x61, 0x36, 0x64, 0x38, 0x39, 0x66, 0x31, 0x63, 0x35, 0x66, 0x35, 0x63, 0x38, 0x30, 0x61, 0x31, 0x63, 0x37, 0x30, 0x65, 0x37, 0x34, 0x34, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x37, 0x33, 0x31, 0x31, 0x34, 0x63, 0x35, 0x65, 0x34, 0x30, 0x36, 0x66, 0x64, 0x62, 0x62, 0x65, 0x30, 0x39, 0x62, 0x34, 0x66, 0x61, 0x36, 0x32, 0x31, 0x62, 0x64, 0x37, 0x30, 0x65, 0x64, 0x35, 0x34, 0x65, 0x61, 0x31, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x39, 0x30, 0x66, 0x31, 0x61, 0x34, 0x62, 0x32, 0x30, 0x61, 0x62, 0x37, 0x62, 0x61, 0x33, 0x34, 0x36, 0x32, 0x38, 0x36, 0x32, 0x30, 0x64, 0x65, 0x39, 0x63, 0x61, 0x30, 0x34, 0x30, 0x63, 0x34, 0x33, 0x63, 0x31, 0x39, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x64, 0x31, 0x34, 0x66, 0x39, 0x65, 0x62, 0x62, 0x61, 0x37, 0x36, 0x36, 0x38, 0x30, 0x65, 0x62, 0x38, 0x33, 0x36, 0x62, 0x30, 0x37, 0x39, 0x63, 0x37, 0x66, 0x37, 0x62, 0x61, 0x61, 0x66, 0x34, 0x38, 0x31, 0x65, 0x64, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x37, 0x31, 0x34, 0x61, 0x35, 0x38, 0x66, 0x66, 0x66, 0x36, 0x65, 0x39, 0x37, 0x64, 0x31, 0x34, 0x62, 0x38, 0x61, 0x35, 0x65, 0x33, 0x30, 0x35, 0x65, 0x62, 0x32, 0x34, 0x34, 0x30, 0x36, 0x35, 0x36, 0x38, 0x38, 0x62, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x36, 0x31, 0x38, 0x33, 0x35, 0x30, 0x66, 0x61, 0x30, 0x31, 0x36, 0x35, 0x37, 0x61, 0x62, 0x30, 0x65, 0x66, 0x33, 0x65, 0x62, 0x61, 0x63, 0x38, 0x65, 0x33, 0x37, 0x30, 0x31, 0x32, 0x66, 0x38, 0x66, 0x63, 0x32, 0x62, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x34, 0x36, 0x64, 0x35, 0x61, 0x63, 0x63, 0x31, 0x33, 0x34, 0x36, 0x65, 0x62, 0x61, 0x30, 0x61, 0x37, 0x32, 0x37, 0x39, 0x61, 0x30, 0x61, 0x63, 0x31, 0x64, 0x34, 0x36, 0x35, 0x63, 0x39, 0x39, 0x36, 0x64, 0x38, 0x32, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x33, 0x38, 0x35, 0x31, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x36, 0x34, 0x63, 0x61, 0x61, 0x61, 0x38, 0x63, 0x63, 0x35, 0x39, 0x37, 0x37, 0x61, 0x66, 0x65, 0x31, 0x66, 0x61, 0x64, 0x38, 0x61, 0x37, 0x64, 0x36, 0x30, 0x32, 0x38, 0x63, 0x65, 0x32, 0x64, 0x35, 0x37, 0x32, 0x39, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x31, 0x37, 0x65, 0x35, 0x62, 0x64, 0x38, 0x32, 0x61, 0x39, 0x37, 0x39, 0x30, 0x66, 0x64, 0x36, 0x35, 0x30, 0x64, 0x30, 0x34, 0x33, 0x63, 0x64, 0x64, 0x39, 0x33, 0x30, 0x66, 0x37, 0x37, 0x39, 0x39, 0x36, 0x33, 0x33, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x32, 0x61, 0x65, 0x63, 0x63, 0x36, 0x34, 0x39, 0x33, 0x39, 0x33, 0x38, 0x61, 0x32, 0x38, 0x63, 0x61, 0x31, 0x63, 0x33, 0x36, 0x37, 0x62, 0x37, 0x30, 0x31, 0x63, 0x32, 0x31, 0x35, 0x39, 0x38, 0x62, 0x36, 0x61, 0x30, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x62, 0x65, 0x64, 0x33, 0x61, 0x37, 0x32, 0x65, 0x63, 0x63, 0x66, 0x62, 0x61, 0x66, 0x62, 0x39, 0x32, 0x33, 0x34, 0x38, 0x39, 0x32, 0x39, 0x33, 0x65, 0x34, 0x32, 0x39, 0x65, 0x37, 0x30, 0x33, 0x63, 0x37, 0x65, 0x32, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x64, 0x62, 0x30, 0x62, 0x39, 0x30, 0x32, 0x35, 0x35, 0x39, 0x65, 0x30, 0x34, 0x30, 0x38, 0x37, 0x64, 0x64, 0x35, 0x63, 0x34, 0x34, 0x31, 0x62, 0x63, 0x37, 0x36, 0x31, 0x31, 0x39, 0x33, 0x34, 0x31, 0x38, 0x34, 0x62, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x34, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x62, 0x63, 0x32, 0x64, 0x34, 0x64, 0x64, 0x63, 0x64, 0x36, 0x35, 0x38, 0x33, 0x62, 0x65, 0x32, 0x63, 0x37, 0x62, 0x63, 0x30, 0x39, 0x34, 0x62, 0x32, 0x38, 0x66, 0x62, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x61, 0x38, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x66, 0x30, 0x65, 0x37, 0x63, 0x31, 0x65, 0x33, 0x61, 0x66, 0x66, 0x38, 0x30, 0x35, 0x61, 0x36, 0x32, 0x37, 0x61, 0x32, 0x61, 0x61, 0x66, 0x32, 0x63, 0x66, 0x66, 0x36, 0x62, 0x34, 0x63, 0x30, 0x64, 0x62, 0x65, 0x39, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x31, 0x62, 0x39, 0x66, 0x64, 0x36, 0x65, 0x61, 0x65, 0x33, 0x37, 0x32, 0x66, 0x33, 0x35, 0x30, 0x31, 0x66, 0x34, 0x32, 0x65, 0x62, 0x39, 0x36, 0x31, 0x39, 0x65, 0x65, 0x63, 0x38, 0x32, 0x30, 0x62, 0x37, 0x38, 0x61, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x39, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x31, 0x64, 0x62, 0x32, 0x30, 0x61, 0x38, 0x30, 0x63, 0x66, 0x33, 0x62, 0x31, 0x37, 0x66, 0x31, 0x36, 0x32, 0x31, 0x66, 0x31, 0x62, 0x33, 0x66, 0x66, 0x37, 0x39, 0x62, 0x38, 0x38, 0x32, 0x66, 0x35, 0x30, 0x64, 0x65, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x38, 0x61, 0x36, 0x64, 0x36, 0x33, 0x34, 0x38, 0x39, 0x63, 0x63, 0x63, 0x31, 0x30, 0x61, 0x35, 0x37, 0x66, 0x38, 0x38, 0x35, 0x66, 0x39, 0x36, 0x65, 0x62, 0x30, 0x34, 0x65, 0x63, 0x62, 0x62, 0x35, 0x34, 0x36, 0x30, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x33, 0x34, 0x39, 0x66, 0x37, 0x65, 0x66, 0x39, 0x37, 0x34, 0x65, 0x61, 0x35, 0x35, 0x66, 0x65, 0x33, 0x36, 0x61, 0x31, 0x35, 0x38, 0x33, 0x62, 0x33, 0x34, 0x63, 0x65, 0x63, 0x33, 0x63, 0x34, 0x35, 0x30, 0x36, 0x35, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x34, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x32, 0x34, 0x31, 0x64, 0x38, 0x39, 0x30, 0x61, 0x39, 0x32, 0x62, 0x61, 0x66, 0x35, 0x32, 0x39, 0x30, 0x38, 0x64, 0x63, 0x34, 0x61, 0x61, 0x30, 0x34, 0x39, 0x37, 0x32, 0x36, 0x62, 0x65, 0x34, 0x32, 0x36, 0x65, 0x62, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x62, 0x31, 0x31, 0x64, 0x31, 0x30, 0x39, 0x66, 0x36, 0x30, 0x38, 0x66, 0x61, 0x38, 0x65, 0x64, 0x64, 0x33, 0x66, 0x65, 0x61, 0x39, 0x66, 0x38, 0x63, 0x33, 0x31, 0x35, 0x36, 0x34, 0x39, 0x61, 0x65, 0x62, 0x33, 0x64, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x33, 0x32, 0x31, 0x62, 0x33, 0x64, 0x61, 0x61, 0x61, 0x32, 0x39, 0x36, 0x63, 0x61, 0x64, 0x66, 0x32, 0x39, 0x34, 0x33, 0x39, 0x66, 0x39, 0x64, 0x61, 0x62, 0x30, 0x36, 0x32, 0x61, 0x34, 0x62, 0x66, 0x66, 0x65, 0x64, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x31, 0x38, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x61, 0x65, 0x38, 0x36, 0x62, 0x30, 0x63, 0x36, 0x63, 0x37, 0x65, 0x33, 0x39, 0x30, 0x30, 0x66, 0x31, 0x33, 0x36, 0x38, 0x31, 0x30, 0x35, 0x63, 0x35, 0x36, 0x35, 0x33, 0x37, 0x66, 0x61, 0x66, 0x38, 0x64, 0x37, 0x34, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x38, 0x65, 0x63, 0x61, 0x34, 0x31, 0x38, 0x39, 0x66, 0x66, 0x34, 0x61, 0x61, 0x38, 0x66, 0x66, 0x37, 0x65, 0x64, 0x34, 0x62, 0x36, 0x62, 0x37, 0x30, 0x33, 0x39, 0x66, 0x30, 0x39, 0x30, 0x32, 0x32, 0x31, 0x39, 0x62, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x66, 0x61, 0x63, 0x63, 0x35, 0x30, 0x31, 0x39, 0x35, 0x63, 0x30, 0x62, 0x34, 0x39, 0x33, 0x33, 0x63, 0x38, 0x35, 0x38, 0x39, 0x37, 0x66, 0x65, 0x63, 0x63, 0x35, 0x62, 0x62, 0x64, 0x39, 0x39, 0x35, 0x63, 0x33, 0x34, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x37, 0x62, 0x64, 0x30, 0x65, 0x35, 0x63, 0x32, 0x63, 0x65, 0x36, 0x39, 0x63, 0x37, 0x63, 0x34, 0x61, 0x37, 0x32, 0x34, 0x62, 0x64, 0x32, 0x36, 0x62, 0x62, 0x66, 0x61, 0x39, 0x64, 0x32, 0x61, 0x31, 0x37, 0x63, 0x61, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x30, 0x61, 0x62, 0x61, 0x36, 0x64, 0x65, 0x39, 0x38, 0x34, 0x64, 0x39, 0x34, 0x35, 0x31, 0x37, 0x33, 0x37, 0x37, 0x38, 0x30, 0x33, 0x37, 0x30, 0x35, 0x65, 0x61, 0x65, 0x61, 0x37, 0x30, 0x39, 0x35, 0x66, 0x34, 0x61, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x34, 0x61, 0x63, 0x39, 0x38, 0x38, 0x36, 0x37, 0x61, 0x37, 0x63, 0x39, 0x63, 0x37, 0x65, 0x64, 0x37, 0x31, 0x31, 0x63, 0x62, 0x38, 0x32, 0x66, 0x32, 0x38, 0x61, 0x38, 0x37, 0x38, 0x63, 0x61, 0x66, 0x36, 0x39, 0x62, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x33, 0x34, 0x64, 0x61, 0x63, 0x32, 0x35, 0x62, 0x64, 0x31, 0x35, 0x38, 0x32, 0x38, 0x66, 0x61, 0x65, 0x66, 0x61, 0x61, 0x66, 0x32, 0x38, 0x66, 0x37, 0x31, 0x30, 0x37, 0x35, 0x33, 0x62, 0x33, 0x39, 0x65, 0x38, 0x39, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x34, 0x31, 0x38, 0x62, 0x34, 0x32, 0x31, 0x61, 0x39, 0x63, 0x36, 0x64, 0x33, 0x37, 0x33, 0x36, 0x30, 0x32, 0x37, 0x39, 0x30, 0x34, 0x37, 0x35, 0x64, 0x32, 0x33, 0x30, 0x33, 0x65, 0x31, 0x31, 0x61, 0x37, 0x35, 0x39, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x34, 0x37, 0x32, 0x39, 0x36, 0x33, 0x31, 0x39, 0x37, 0x38, 0x38, 0x33, 0x62, 0x62, 0x64, 0x61, 0x35, 0x61, 0x39, 0x62, 0x37, 0x64, 0x66, 0x63, 0x62, 0x32, 0x32, 0x64, 0x62, 0x31, 0x31, 0x34, 0x34, 0x30, 0x61, 0x64, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x31, 0x34, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x37, 0x38, 0x62, 0x64, 0x62, 0x63, 0x33, 0x37, 0x31, 0x62, 0x34, 0x64, 0x32, 0x34, 0x33, 0x38, 0x34, 0x35, 0x33, 0x33, 0x30, 0x35, 0x35, 0x36, 0x66, 0x66, 0x66, 0x32, 0x64, 0x35, 0x65, 0x66, 0x34, 0x64, 0x66, 0x66, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x61, 0x34, 0x37, 0x39, 0x36, 0x64, 0x30, 0x63, 0x65, 0x62, 0x34, 0x64, 0x33, 0x61, 0x38, 0x33, 0x36, 0x62, 0x38, 0x34, 0x63, 0x39, 0x36, 0x66, 0x39, 0x31, 0x30, 0x61, 0x66, 0x63, 0x31, 0x30, 0x33, 0x66, 0x35, 0x62, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x36, 0x66, 0x64, 0x61, 0x36, 0x62, 0x39, 0x62, 0x35, 0x38, 0x63, 0x35, 0x35, 0x33, 0x32, 0x37, 0x35, 0x30, 0x33, 0x30, 0x36, 0x61, 0x31, 0x30, 0x61, 0x32, 0x61, 0x38, 0x63, 0x37, 0x36, 0x38, 0x31, 0x30, 0x33, 0x62, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x37, 0x30, 0x66, 0x31, 0x34, 0x65, 0x66, 0x62, 0x31, 0x36, 0x35, 0x64, 0x64, 0x65, 0x62, 0x61, 0x37, 0x39, 0x63, 0x31, 0x30, 0x62, 0x62, 0x30, 0x61, 0x66, 0x33, 0x31, 0x63, 0x33, 0x31, 0x65, 0x35, 0x39, 0x33, 0x33, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x33, 0x38, 0x32, 0x63, 0x30, 0x32, 0x39, 0x36, 0x36, 0x31, 0x32, 0x65, 0x34, 0x65, 0x39, 0x37, 0x65, 0x34, 0x34, 0x30, 0x65, 0x30, 0x32, 0x64, 0x33, 0x38, 0x37, 0x31, 0x32, 0x37, 0x33, 0x62, 0x35, 0x35, 0x66, 0x35, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x62, 0x37, 0x62, 0x64, 0x33, 0x31, 0x30, 0x64, 0x39, 0x35, 0x66, 0x32, 0x61, 0x36, 0x64, 0x39, 0x62, 0x61, 0x61, 0x66, 0x38, 0x61, 0x38, 0x61, 0x34, 0x33, 0x30, 0x61, 0x39, 0x61, 0x30, 0x34, 0x34, 0x35, 0x33, 0x61, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x61, 0x63, 0x66, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x62, 0x62, 0x35, 0x35, 0x62, 0x62, 0x36, 0x62, 0x66, 0x62, 0x61, 0x62, 0x31, 0x38, 0x31, 0x35, 0x66, 0x66, 0x63, 0x34, 0x65, 0x31, 0x37, 0x65, 0x38, 0x35, 0x61, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x33, 0x64, 0x35, 0x62, 0x63, 0x62, 0x30, 0x36, 0x34, 0x34, 0x62, 0x30, 0x63, 0x63, 0x65, 0x35, 0x66, 0x63, 0x64, 0x64, 0x61, 0x33, 0x34, 0x33, 0x66, 0x35, 0x31, 0x36, 0x38, 0x66, 0x66, 0x61, 0x62, 0x32, 0x38, 0x37, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x39, 0x39, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x30, 0x63, 0x63, 0x37, 0x38, 0x66, 0x37, 0x34, 0x64, 0x39, 0x38, 0x32, 0x37, 0x62, 0x64, 0x63, 0x38, 0x61, 0x36, 0x34, 0x37, 0x33, 0x32, 0x37, 0x36, 0x65, 0x62, 0x38, 0x34, 0x66, 0x64, 0x63, 0x39, 0x37, 0x36, 0x32, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x36, 0x34, 0x31, 0x31, 0x65, 0x33, 0x61, 0x30, 0x32, 0x64, 0x65, 0x64, 0x62, 0x37, 0x32, 0x36, 0x66, 0x61, 0x37, 0x39, 0x31, 0x30, 0x37, 0x64, 0x63, 0x39, 0x30, 0x62, 0x63, 0x31, 0x63, 0x61, 0x65, 0x36, 0x34, 0x64, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x36, 0x65, 0x38, 0x66, 0x65, 0x31, 0x30, 0x39, 0x63, 0x63, 0x64, 0x32, 0x31, 0x35, 0x38, 0x65, 0x34, 0x64, 0x62, 0x31, 0x31, 0x34, 0x31, 0x33, 0x32, 0x66, 0x65, 0x37, 0x35, 0x66, 0x65, 0x63, 0x63, 0x38, 0x62, 0x65, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x64, 0x39, 0x34, 0x37, 0x64, 0x35, 0x61, 0x37, 0x33, 0x62, 0x31, 0x37, 0x35, 0x30, 0x30, 0x38, 0x61, 0x65, 0x36, 0x65, 0x65, 0x38, 0x32, 0x32, 0x38, 0x31, 0x36, 0x33, 0x64, 0x61, 0x32, 0x38, 0x39, 0x62, 0x31, 0x36, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x64, 0x39, 0x35, 0x30, 0x64, 0x35, 0x65, 0x39, 0x33, 0x65, 0x61, 0x31, 0x64, 0x35, 0x62, 0x34, 0x38, 0x64, 0x62, 0x34, 0x37, 0x31, 0x34, 0x66, 0x38, 0x36, 0x37, 0x62, 0x30, 0x33, 0x32, 0x30, 0x62, 0x33, 0x31, 0x63, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x39, 0x39, 0x62, 0x36, 0x32, 0x36, 0x30, 0x36, 0x32, 0x38, 0x31, 0x62, 0x35, 0x63, 0x65, 0x66, 0x61, 0x62, 0x66, 0x33, 0x36, 0x31, 0x35, 0x36, 0x63, 0x38, 0x66, 0x65, 0x36, 0x32, 0x38, 0x33, 0x39, 0x65, 0x66, 0x35, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x63, 0x38, 0x64, 0x30, 0x64, 0x39, 0x38, 0x32, 0x62, 0x35, 0x33, 0x39, 0x66, 0x34, 0x38, 0x66, 0x39, 0x38, 0x33, 0x30, 0x66, 0x39, 0x38, 0x39, 0x31, 0x66, 0x39, 0x64, 0x36, 0x30, 0x37, 0x61, 0x39, 0x34, 0x32, 0x36, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x31, 0x32, 0x37, 0x64, 0x35, 0x34, 0x31, 0x38, 0x38, 0x66, 0x65, 0x64, 0x65, 0x66, 0x30, 0x66, 0x33, 0x33, 0x38, 0x61, 0x35, 0x66, 0x33, 0x38, 0x63, 0x37, 0x66, 0x66, 0x37, 0x33, 0x61, 0x64, 0x39, 0x66, 0x36, 0x66, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x36, 0x34, 0x66, 0x65, 0x63, 0x30, 0x37, 0x65, 0x64, 0x31, 0x32, 0x31, 0x34, 0x61, 0x36, 0x35, 0x33, 0x31, 0x31, 0x65, 0x31, 0x31, 0x65, 0x33, 0x32, 0x39, 0x64, 0x65, 0x30, 0x34, 0x30, 0x64, 0x30, 0x34, 0x66, 0x30, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x35, 0x36, 0x33, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x30, 0x39, 0x61, 0x64, 0x32, 0x34, 0x31, 0x32, 0x36, 0x39, 0x31, 0x63, 0x63, 0x35, 0x38, 0x31, 0x63, 0x31, 0x61, 0x62, 0x33, 0x36, 0x62, 0x36, 0x66, 0x39, 0x34, 0x33, 0x34, 0x63, 0x64, 0x34, 0x66, 0x30, 0x38, 0x62, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x61, 0x37, 0x30, 0x66, 0x30, 0x34, 0x33, 0x31, 0x33, 0x66, 0x61, 0x65, 0x36, 0x35, 0x63, 0x33, 0x66, 0x66, 0x32, 0x32, 0x34, 0x61, 0x30, 0x35, 0x35, 0x63, 0x33, 0x64, 0x32, 0x64, 0x61, 0x62, 0x32, 0x38, 0x64, 0x64, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x36, 0x36, 0x38, 0x66, 0x61, 0x38, 0x32, 0x63, 0x31, 0x34, 0x64, 0x36, 0x65, 0x38, 0x64, 0x39, 0x33, 0x61, 0x35, 0x33, 0x31, 0x31, 0x33, 0x65, 0x66, 0x32, 0x38, 0x36, 0x32, 0x66, 0x61, 0x38, 0x31, 0x35, 0x38, 0x31, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x64, 0x38, 0x35, 0x38, 0x31, 0x30, 0x35, 0x65, 0x31, 0x62, 0x36, 0x34, 0x38, 0x31, 0x30, 0x31, 0x61, 0x63, 0x33, 0x66, 0x38, 0x35, 0x61, 0x30, 0x66, 0x38, 0x32, 0x32, 0x32, 0x62, 0x66, 0x34, 0x66, 0x38, 0x31, 0x64, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x33, 0x61, 0x31, 0x30, 0x32, 0x33, 0x63, 0x61, 0x63, 0x30, 0x34, 0x64, 0x62, 0x66, 0x34, 0x34, 0x66, 0x35, 0x61, 0x35, 0x66, 0x61, 0x36, 0x61, 0x39, 0x63, 0x66, 0x38, 0x35, 0x30, 0x38, 0x63, 0x64, 0x34, 0x66, 0x64, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x39, 0x33, 0x61, 0x62, 0x65, 0x36, 0x66, 0x31, 0x35, 0x33, 0x33, 0x33, 0x31, 0x31, 0x66, 0x64, 0x35, 0x31, 0x35, 0x33, 0x36, 0x38, 0x39, 0x31, 0x37, 0x38, 0x33, 0x62, 0x33, 0x66, 0x39, 0x36, 0x32, 0x35, 0x65, 0x66, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x37, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x36, 0x36, 0x37, 0x36, 0x33, 0x37, 0x65, 0x32, 0x39, 0x65, 0x63, 0x61, 0x30, 0x35, 0x62, 0x36, 0x62, 0x66, 0x62, 0x65, 0x66, 0x31, 0x66, 0x39, 0x36, 0x64, 0x34, 0x36, 0x30, 0x65, 0x65, 0x66, 0x62, 0x66, 0x39, 0x39, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x36, 0x64, 0x62, 0x61, 0x65, 0x62, 0x63, 0x33, 0x30, 0x64, 0x34, 0x65, 0x66, 0x36, 0x37, 0x62, 0x30, 0x33, 0x65, 0x36, 0x65, 0x36, 0x65, 0x63, 0x63, 0x36, 0x64, 0x38, 0x34, 0x65, 0x30, 0x30, 0x34, 0x64, 0x35, 0x30, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x64, 0x31, 0x61, 0x36, 0x33, 0x39, 0x39, 0x62, 0x33, 0x30, 0x31, 0x36, 0x61, 0x38, 0x35, 0x39, 0x37, 0x66, 0x38, 0x62, 0x36, 0x34, 0x30, 0x39, 0x32, 0x37, 0x62, 0x38, 0x61, 0x66, 0x62, 0x63, 0x65, 0x34, 0x62, 0x32, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x66, 0x64, 0x34, 0x37, 0x63, 0x35, 0x32, 0x35, 0x36, 0x30, 0x31, 0x32, 0x31, 0x39, 0x38, 0x66, 0x61, 0x35, 0x61, 0x62, 0x66, 0x31, 0x33, 0x31, 0x63, 0x30, 0x36, 0x64, 0x36, 0x61, 0x61, 0x31, 0x39, 0x36, 0x35, 0x66, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x32, 0x62, 0x62, 0x61, 0x31, 0x62, 0x31, 0x37, 0x39, 0x36, 0x38, 0x32, 0x31, 0x61, 0x37, 0x36, 0x36, 0x66, 0x63, 0x65, 0x36, 0x34, 0x62, 0x38, 0x34, 0x66, 0x32, 0x38, 0x65, 0x63, 0x36, 0x38, 0x66, 0x31, 0x35, 0x61, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x34, 0x62, 0x66, 0x31, 0x32, 0x64, 0x32, 0x64, 0x64, 0x66, 0x34, 0x35, 0x37, 0x64, 0x65, 0x63, 0x62, 0x31, 0x37, 0x38, 0x37, 0x34, 0x65, 0x66, 0x64, 0x65, 0x32, 0x30, 0x35, 0x32, 0x62, 0x36, 0x35, 0x63, 0x62, 0x62, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x64, 0x65, 0x31, 0x33, 0x62, 0x30, 0x39, 0x39, 0x33, 0x31, 0x38, 0x37, 0x37, 0x63, 0x39, 0x31, 0x30, 0x64, 0x35, 0x39, 0x33, 0x31, 0x36, 0x35, 0x63, 0x33, 0x36, 0x34, 0x63, 0x38, 0x61, 0x31, 0x36, 0x34, 0x31, 0x62, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x35, 0x63, 0x61, 0x39, 0x66, 0x30, 0x35, 0x63, 0x63, 0x31, 0x33, 0x34, 0x61, 0x62, 0x35, 0x34, 0x61, 0x65, 0x39, 0x62, 0x65, 0x61, 0x31, 0x63, 0x33, 0x66, 0x66, 0x38, 0x37, 0x61, 0x61, 0x38, 0x35, 0x31, 0x39, 0x38, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x39, 0x65, 0x63, 0x64, 0x36, 0x62, 0x64, 0x64, 0x39, 0x35, 0x32, 0x65, 0x66, 0x34, 0x39, 0x37, 0x63, 0x30, 0x30, 0x35, 0x30, 0x61, 0x65, 0x30, 0x61, 0x62, 0x38, 0x61, 0x38, 0x32, 0x61, 0x39, 0x31, 0x38, 0x39, 0x38, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x38, 0x62, 0x66, 0x65, 0x66, 0x38, 0x63, 0x36, 0x38, 0x61, 0x34, 0x38, 0x31, 0x36, 0x62, 0x33, 0x39, 0x31, 0x36, 0x66, 0x33, 0x35, 0x63, 0x62, 0x37, 0x62, 0x66, 0x63, 0x64, 0x37, 0x64, 0x33, 0x30, 0x34, 0x30, 0x39, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x64, 0x31, 0x33, 0x36, 0x62, 0x38, 0x38, 0x31, 0x37, 0x38, 0x62, 0x34, 0x38, 0x33, 0x37, 0x61, 0x36, 0x63, 0x37, 0x38, 0x30, 0x66, 0x65, 0x62, 0x61, 0x32, 0x32, 0x36, 0x62, 0x39, 0x38, 0x35, 0x36, 0x39, 0x61, 0x39, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x30, 0x65, 0x37, 0x64, 0x36, 0x33, 0x31, 0x63, 0x36, 0x65, 0x35, 0x37, 0x33, 0x61, 0x39, 0x30, 0x33, 0x33, 0x32, 0x66, 0x31, 0x37, 0x66, 0x37, 0x31, 0x66, 0x35, 0x66, 0x64, 0x31, 0x39, 0x62, 0x35, 0x32, 0x38, 0x63, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x61, 0x39, 0x61, 0x37, 0x31, 0x36, 0x39, 0x31, 0x33, 0x31, 0x37, 0x63, 0x32, 0x30, 0x36, 0x34, 0x32, 0x37, 0x31, 0x62, 0x35, 0x31, 0x63, 0x39, 0x33, 0x35, 0x33, 0x66, 0x62, 0x64, 0x65, 0x64, 0x33, 0x35, 0x30, 0x31, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x61, 0x30, 0x66, 0x36, 0x63, 0x63, 0x31, 0x38, 0x36, 0x63, 0x66, 0x36, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, 0x37, 0x33, 0x36, 0x65, 0x30, 0x36, 0x35, 0x61, 0x33, 0x39, 0x31, 0x66, 0x35, 0x32, 0x61, 0x39, 0x64, 0x66, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x32, 0x66, 0x66, 0x37, 0x33, 0x37, 0x30, 0x61, 0x31, 0x33, 0x65, 0x64, 0x33, 0x36, 0x30, 0x39, 0x37, 0x33, 0x66, 0x65, 0x64, 0x63, 0x39, 0x66, 0x66, 0x35, 0x64, 0x32, 0x63, 0x39, 0x33, 0x61, 0x35, 0x30, 0x35, 0x65, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x33, 0x39, 0x39, 0x36, 0x35, 0x39, 0x61, 0x63, 0x61, 0x36, 0x61, 0x35, 0x61, 0x38, 0x36, 0x33, 0x65, 0x61, 0x32, 0x32, 0x34, 0x35, 0x63, 0x39, 0x33, 0x33, 0x66, 0x65, 0x39, 0x61, 0x33, 0x35, 0x62, 0x37, 0x38, 0x38, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x32, 0x33, 0x39, 0x61, 0x63, 0x66, 0x66, 0x64, 0x34, 0x65, 0x62, 0x65, 0x32, 0x65, 0x31, 0x62, 0x61, 0x35, 0x62, 0x34, 0x31, 0x37, 0x30, 0x35, 0x37, 0x32, 0x64, 0x63, 0x37, 0x39, 0x63, 0x63, 0x36, 0x35, 0x33, 0x33, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x37, 0x62, 0x39, 0x66, 0x63, 0x33, 0x31, 0x39, 0x30, 0x35, 0x62, 0x34, 0x39, 0x39, 0x34, 0x62, 0x30, 0x34, 0x63, 0x39, 0x65, 0x32, 0x63, 0x66, 0x64, 0x63, 0x35, 0x65, 0x32, 0x37, 0x37, 0x30, 0x35, 0x30, 0x33, 0x66, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x38, 0x30, 0x64, 0x65, 0x36, 0x32, 0x32, 0x35, 0x34, 0x66, 0x32, 0x62, 0x61, 0x38, 0x32, 0x62, 0x35, 0x37, 0x38, 0x32, 0x31, 0x39, 0x63, 0x30, 0x37, 0x62, 0x61, 0x35, 0x62, 0x65, 0x34, 0x33, 0x30, 0x64, 0x63, 0x33, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x37, 0x62, 0x38, 0x66, 0x39, 0x66, 0x33, 0x61, 0x38, 0x64, 0x30, 0x39, 0x65, 0x39, 0x32, 0x30, 0x32, 0x63, 0x35, 0x32, 0x63, 0x32, 0x39, 0x65, 0x37, 0x32, 0x34, 0x31, 0x39, 0x36, 0x62, 0x38, 0x39, 0x37, 0x64, 0x33, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x38, 0x65, 0x61, 0x37, 0x30, 0x37, 0x62, 0x61, 0x65, 0x34, 0x33, 0x35, 0x37, 0x66, 0x31, 0x65, 0x62, 0x65, 0x61, 0x39, 0x35, 0x39, 0x63, 0x33, 0x61, 0x32, 0x35, 0x30, 0x61, 0x63, 0x64, 0x36, 0x61, 0x61, 0x32, 0x31, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x63, 0x37, 0x30, 0x35, 0x33, 0x61, 0x37, 0x31, 0x38, 0x36, 0x31, 0x36, 0x63, 0x66, 0x63, 0x37, 0x38, 0x62, 0x65, 0x65, 0x36, 0x33, 0x38, 0x32, 0x65, 0x65, 0x35, 0x31, 0x61, 0x64, 0x64, 0x30, 0x63, 0x37, 0x30, 0x33, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x64, 0x61, 0x63, 0x35, 0x61, 0x38, 0x61, 0x30, 0x32, 0x36, 0x34, 0x66, 0x62, 0x63, 0x31, 0x30, 0x35, 0x35, 0x33, 0x39, 0x31, 0x63, 0x35, 0x30, 0x39, 0x63, 0x63, 0x33, 0x65, 0x65, 0x32, 0x31, 0x61, 0x36, 0x65, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x62, 0x32, 0x61, 0x30, 0x66, 0x62, 0x39, 0x63, 0x61, 0x64, 0x34, 0x35, 0x63, 0x64, 0x36, 0x39, 0x39, 0x31, 0x39, 0x32, 0x63, 0x64, 0x32, 0x37, 0x35, 0x34, 0x30, 0x62, 0x38, 0x38, 0x64, 0x33, 0x33, 0x38, 0x34, 0x32, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x37, 0x63, 0x62, 0x39, 0x63, 0x31, 0x32, 0x34, 0x30, 0x35, 0x62, 0x37, 0x31, 0x31, 0x38, 0x30, 0x37, 0x35, 0x34, 0x33, 0x63, 0x34, 0x39, 0x33, 0x34, 0x34, 0x36, 0x35, 0x66, 0x38, 0x37, 0x66, 0x39, 0x38, 0x62, 0x64, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x66, 0x37, 0x32, 0x62, 0x62, 0x37, 0x35, 0x38, 0x30, 0x31, 0x36, 0x62, 0x33, 0x37, 0x34, 0x37, 0x31, 0x34, 0x64, 0x34, 0x38, 0x39, 0x39, 0x62, 0x63, 0x65, 0x32, 0x32, 0x62, 0x34, 0x61, 0x65, 0x63, 0x37, 0x30, 0x61, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x37, 0x32, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x34, 0x38, 0x30, 0x64, 0x65, 0x39, 0x66, 0x37, 0x34, 0x36, 0x31, 0x30, 0x30, 0x32, 0x39, 0x30, 0x38, 0x62, 0x34, 0x39, 0x66, 0x36, 0x30, 0x66, 0x63, 0x36, 0x31, 0x65, 0x32, 0x62, 0x36, 0x32, 0x64, 0x33, 0x31, 0x34, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x64, 0x35, 0x33, 0x32, 0x64, 0x33, 0x38, 0x64, 0x36, 0x64, 0x65, 0x65, 0x33, 0x66, 0x36, 0x30, 0x61, 0x64, 0x63, 0x36, 0x38, 0x62, 0x39, 0x33, 0x36, 0x31, 0x33, 0x33, 0x63, 0x37, 0x61, 0x32, 0x61, 0x31, 0x62, 0x30, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x61, 0x66, 0x62, 0x63, 0x62, 0x61, 0x31, 0x34, 0x32, 0x37, 0x61, 0x36, 0x61, 0x33, 0x39, 0x65, 0x37, 0x62, 0x61, 0x34, 0x38, 0x34, 0x39, 0x66, 0x37, 0x61, 0x62, 0x31, 0x63, 0x34, 0x33, 0x35, 0x38, 0x61, 0x63, 0x33, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x66, 0x36, 0x36, 0x34, 0x35, 0x65, 0x30, 0x64, 0x65, 0x65, 0x36, 0x34, 0x34, 0x62, 0x33, 0x64, 0x61, 0x64, 0x38, 0x31, 0x64, 0x35, 0x37, 0x31, 0x65, 0x66, 0x39, 0x62, 0x61, 0x66, 0x38, 0x34, 0x30, 0x30, 0x32, 0x31, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x63, 0x66, 0x38, 0x39, 0x30, 0x35, 0x39, 0x31, 0x65, 0x61, 0x65, 0x34, 0x61, 0x31, 0x38, 0x66, 0x38, 0x31, 0x32, 0x61, 0x32, 0x39, 0x35, 0x34, 0x63, 0x62, 0x32, 0x39, 0x35, 0x66, 0x36, 0x33, 0x33, 0x33, 0x32, 0x37, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x31, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x35, 0x62, 0x39, 0x37, 0x66, 0x32, 0x66, 0x63, 0x31, 0x62, 0x64, 0x32, 0x34, 0x62, 0x31, 0x32, 0x30, 0x37, 0x36, 0x65, 0x66, 0x61, 0x66, 0x33, 0x64, 0x31, 0x32, 0x38, 0x38, 0x30, 0x37, 0x33, 0x64, 0x32, 0x30, 0x63, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x63, 0x37, 0x65, 0x35, 0x65, 0x66, 0x62, 0x34, 0x38, 0x62, 0x33, 0x61, 0x65, 0x64, 0x34, 0x62, 0x37, 0x63, 0x36, 0x65, 0x38, 0x32, 0x34, 0x62, 0x34, 0x33, 0x35, 0x66, 0x33, 0x35, 0x37, 0x64, 0x66, 0x34, 0x63, 0x37, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x34, 0x64, 0x37, 0x30, 0x38, 0x64, 0x37, 0x33, 0x39, 0x38, 0x30, 0x32, 0x34, 0x35, 0x33, 0x33, 0x61, 0x35, 0x61, 0x32, 0x62, 0x32, 0x33, 0x30, 0x39, 0x62, 0x31, 0x39, 0x64, 0x33, 0x63, 0x35, 0x35, 0x31, 0x37, 0x31, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x33, 0x37, 0x30, 0x65, 0x38, 0x37, 0x32, 0x30, 0x32, 0x36, 0x34, 0x35, 0x31, 0x32, 0x35, 0x61, 0x33, 0x35, 0x62, 0x32, 0x30, 0x37, 0x61, 0x66, 0x31, 0x32, 0x33, 0x31, 0x66, 0x62, 0x36, 0x30, 0x37, 0x32, 0x66, 0x39, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x35, 0x35, 0x61, 0x66, 0x34, 0x63, 0x61, 0x64, 0x66, 0x63, 0x66, 0x64, 0x62, 0x34, 0x32, 0x35, 0x63, 0x66, 0x36, 0x35, 0x62, 0x61, 0x36, 0x34, 0x33, 0x31, 0x30, 0x37, 0x38, 0x66, 0x30, 0x37, 0x65, 0x63, 0x64, 0x35, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x64, 0x65, 0x35, 0x65, 0x38, 0x65, 0x61, 0x66, 0x62, 0x35, 0x66, 0x36, 0x32, 0x62, 0x31, 0x61, 0x30, 0x61, 0x66, 0x32, 0x31, 0x39, 0x35, 0x63, 0x66, 0x37, 0x39, 0x33, 0x63, 0x37, 0x38, 0x39, 0x34, 0x63, 0x39, 0x32, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x33, 0x63, 0x64, 0x37, 0x38, 0x38, 0x32, 0x31, 0x31, 0x38, 0x62, 0x38, 0x61, 0x39, 0x31, 0x65, 0x30, 0x37, 0x34, 0x64, 0x34, 0x63, 0x38, 0x66, 0x34, 0x62, 0x61, 0x39, 0x31, 0x38, 0x35, 0x31, 0x33, 0x30, 0x33, 0x62, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x34, 0x64, 0x37, 0x61, 0x61, 0x63, 0x33, 0x65, 0x65, 0x63, 0x62, 0x61, 0x65, 0x63, 0x61, 0x31, 0x61, 0x64, 0x35, 0x31, 0x39, 0x31, 0x62, 0x37, 0x35, 0x33, 0x66, 0x31, 0x37, 0x33, 0x66, 0x65, 0x31, 0x32, 0x65, 0x63, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x34, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x66, 0x62, 0x32, 0x36, 0x64, 0x31, 0x63, 0x61, 0x31, 0x65, 0x65, 0x63, 0x62, 0x61, 0x33, 0x64, 0x38, 0x32, 0x39, 0x38, 0x64, 0x39, 0x64, 0x31, 0x34, 0x38, 0x31, 0x31, 0x39, 0x61, 0x63, 0x32, 0x62, 0x62, 0x66, 0x35, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x33, 0x61, 0x63, 0x35, 0x33, 0x62, 0x65, 0x35, 0x36, 0x35, 0x64, 0x34, 0x36, 0x35, 0x33, 0x36, 0x62, 0x38, 0x32, 0x30, 0x37, 0x31, 0x35, 0x62, 0x39, 0x62, 0x38, 0x64, 0x33, 0x61, 0x65, 0x36, 0x38, 0x61, 0x34, 0x62, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x36, 0x31, 0x36, 0x63, 0x36, 0x66, 0x30, 0x30, 0x38, 0x61, 0x64, 0x66, 0x61, 0x30, 0x38, 0x32, 0x66, 0x33, 0x34, 0x64, 0x61, 0x37, 0x64, 0x30, 0x36, 0x35, 0x30, 0x34, 0x36, 0x30, 0x33, 0x36, 0x38, 0x30, 0x37, 0x35, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x66, 0x31, 0x30, 0x30, 0x63, 0x63, 0x33, 0x64, 0x61, 0x65, 0x38, 0x33, 0x61, 0x33, 0x33, 0x34, 0x30, 0x32, 0x30, 0x35, 0x31, 0x63, 0x65, 0x34, 0x34, 0x39, 0x36, 0x62, 0x31, 0x36, 0x36, 0x31, 0x35, 0x34, 0x38, 0x33, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x35, 0x63, 0x63, 0x61, 0x30, 0x64, 0x33, 0x36, 0x38, 0x32, 0x36, 0x36, 0x36, 0x32, 0x36, 0x38, 0x33, 0x63, 0x66, 0x37, 0x64, 0x30, 0x62, 0x32, 0x66, 0x64, 0x61, 0x63, 0x36, 0x38, 0x37, 0x66, 0x30, 0x32, 0x64, 0x30, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x61, 0x36, 0x62, 0x33, 0x61, 0x62, 0x34, 0x32, 0x33, 0x30, 0x31, 0x30, 0x66, 0x39, 0x38, 0x31, 0x61, 0x37, 0x34, 0x38, 0x39, 0x64, 0x34, 0x61, 0x61, 0x64, 0x32, 0x35, 0x65, 0x32, 0x36, 0x32, 0x35, 0x63, 0x35, 0x37, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x39, 0x30, 0x30, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x30, 0x34, 0x39, 0x61, 0x66, 0x30, 0x30, 0x35, 0x39, 0x37, 0x34, 0x64, 0x64, 0x31, 0x63, 0x37, 0x62, 0x33, 0x61, 0x39, 0x63, 0x61, 0x38, 0x64, 0x39, 0x61, 0x61, 0x37, 0x37, 0x31, 0x37, 0x35, 0x62, 0x61, 0x35, 0x33, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x37, 0x39, 0x32, 0x37, 0x65, 0x33, 0x30, 0x34, 0x38, 0x62, 0x62, 0x35, 0x31, 0x36, 0x32, 0x61, 0x65, 0x37, 0x63, 0x31, 0x35, 0x63, 0x66, 0x37, 0x36, 0x62, 0x64, 0x31, 0x32, 0x34, 0x66, 0x39, 0x34, 0x39, 0x37, 0x62, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x61, 0x34, 0x30, 0x32, 0x37, 0x30, 0x64, 0x32, 0x31, 0x65, 0x35, 0x63, 0x64, 0x65, 0x38, 0x36, 0x62, 0x36, 0x33, 0x31, 0x36, 0x64, 0x31, 0x61, 0x63, 0x33, 0x63, 0x35, 0x33, 0x33, 0x34, 0x39, 0x34, 0x62, 0x37, 0x39, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x36, 0x32, 0x35, 0x39, 0x62, 0x30, 0x61, 0x37, 0x35, 0x36, 0x37, 0x30, 0x31, 0x61, 0x38, 0x62, 0x36, 0x36, 0x33, 0x35, 0x32, 0x38, 0x35, 0x32, 0x32, 0x31, 0x35, 0x36, 0x63, 0x30, 0x32, 0x38, 0x38, 0x66, 0x30, 0x66, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x63, 0x37, 0x35, 0x65, 0x33, 0x63, 0x62, 0x34, 0x61, 0x61, 0x38, 0x39, 0x66, 0x33, 0x34, 0x36, 0x31, 0x39, 0x61, 0x31, 0x36, 0x34, 0x65, 0x32, 0x61, 0x34, 0x37, 0x38, 0x39, 0x38, 0x66, 0x35, 0x36, 0x37, 0x34, 0x64, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x37, 0x39, 0x38, 0x33, 0x33, 0x38, 0x38, 0x61, 0x62, 0x35, 0x39, 0x61, 0x34, 0x66, 0x66, 0x63, 0x32, 0x31, 0x35, 0x66, 0x38, 0x65, 0x38, 0x32, 0x36, 0x39, 0x34, 0x36, 0x31, 0x30, 0x32, 0x39, 0x63, 0x33, 0x66, 0x31, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x32, 0x61, 0x31, 0x33, 0x31, 0x61, 0x35, 0x61, 0x36, 0x35, 0x36, 0x61, 0x37, 0x61, 0x33, 0x61, 0x63, 0x61, 0x33, 0x35, 0x63, 0x38, 0x62, 0x64, 0x32, 0x30, 0x32, 0x32, 0x32, 0x32, 0x61, 0x37, 0x35, 0x39, 0x32, 0x32, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x30, 0x63, 0x61, 0x34, 0x66, 0x32, 0x31, 0x37, 0x65, 0x30, 0x35, 0x32, 0x37, 0x35, 0x33, 0x36, 0x31, 0x34, 0x64, 0x36, 0x62, 0x30, 0x31, 0x39, 0x39, 0x34, 0x38, 0x38, 0x32, 0x34, 0x64, 0x30, 0x64, 0x38, 0x36, 0x38, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x36, 0x63, 0x30, 0x33, 0x62, 0x64, 0x36, 0x30, 0x33, 0x65, 0x30, 0x39, 0x64, 0x65, 0x35, 0x34, 0x65, 0x39, 0x63, 0x34, 0x64, 0x35, 0x61, 0x63, 0x36, 0x64, 0x34, 0x31, 0x63, 0x62, 0x63, 0x65, 0x37, 0x31, 0x35, 0x37, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x39, 0x61, 0x66, 0x66, 0x31, 0x33, 0x62, 0x61, 0x32, 0x64, 0x61, 0x37, 0x35, 0x64, 0x34, 0x36, 0x32, 0x34, 0x30, 0x63, 0x61, 0x63, 0x30, 0x61, 0x32, 0x34, 0x36, 0x37, 0x63, 0x36, 0x35, 0x36, 0x39, 0x34, 0x39, 0x38, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x37, 0x62, 0x32, 0x34, 0x65, 0x65, 0x65, 0x38, 0x38, 0x33, 0x39, 0x65, 0x34, 0x66, 0x64, 0x31, 0x39, 0x64, 0x31, 0x32, 0x35, 0x30, 0x62, 0x64, 0x30, 0x62, 0x36, 0x36, 0x34, 0x35, 0x37, 0x39, 0x34, 0x61, 0x36, 0x31, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x66, 0x64, 0x36, 0x64, 0x34, 0x38, 0x33, 0x31, 0x35, 0x30, 0x36, 0x36, 0x63, 0x32, 0x30, 0x34, 0x66, 0x39, 0x36, 0x35, 0x31, 0x38, 0x36, 0x39, 0x63, 0x31, 0x30, 0x39, 0x36, 0x63, 0x31, 0x34, 0x66, 0x63, 0x39, 0x37, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x36, 0x33, 0x61, 0x38, 0x37, 0x33, 0x35, 0x35, 0x35, 0x62, 0x63, 0x30, 0x33, 0x39, 0x37, 0x65, 0x35, 0x37, 0x35, 0x63, 0x32, 0x34, 0x37, 0x31, 0x63, 0x66, 0x37, 0x37, 0x66, 0x61, 0x39, 0x64, 0x62, 0x31, 0x34, 0x36, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x61, 0x62, 0x31, 0x33, 0x65, 0x65, 0x32, 0x36, 0x36, 0x64, 0x37, 0x37, 0x39, 0x63, 0x33, 0x35, 0x65, 0x38, 0x62, 0x62, 0x30, 0x34, 0x63, 0x64, 0x38, 0x61, 0x39, 0x30, 0x63, 0x63, 0x32, 0x31, 0x30, 0x33, 0x61, 0x39, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x61, 0x63, 0x63, 0x65, 0x64, 0x37, 0x65, 0x34, 0x38, 0x63, 0x30, 0x38, 0x63, 0x36, 0x62, 0x39, 0x33, 0x34, 0x36, 0x34, 0x36, 0x64, 0x66, 0x61, 0x30, 0x61, 0x64, 0x66, 0x32, 0x39, 0x64, 0x63, 0x39, 0x34, 0x30, 0x37, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x65, 0x61, 0x36, 0x65, 0x61, 0x62, 0x31, 0x39, 0x64, 0x30, 0x30, 0x37, 0x36, 0x34, 0x65, 0x39, 0x61, 0x39, 0x35, 0x65, 0x31, 0x38, 0x33, 0x66, 0x32, 0x62, 0x31, 0x62, 0x32, 0x32, 0x66, 0x63, 0x37, 0x64, 0x63, 0x34, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x61, 0x35, 0x33, 0x65, 0x61, 0x33, 0x39, 0x66, 0x35, 0x39, 0x61, 0x33, 0x35, 0x62, 0x61, 0x64, 0x61, 0x38, 0x33, 0x35, 0x32, 0x35, 0x32, 0x31, 0x36, 0x34, 0x35, 0x35, 0x39, 0x34, 0x61, 0x31, 0x61, 0x37, 0x31, 0x34, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x31, 0x61, 0x65, 0x64, 0x38, 0x35, 0x62, 0x38, 0x36, 0x63, 0x36, 0x35, 0x36, 0x32, 0x63, 0x62, 0x38, 0x66, 0x61, 0x31, 0x65, 0x62, 0x36, 0x66, 0x38, 0x66, 0x33, 0x62, 0x63, 0x39, 0x64, 0x63, 0x61, 0x65, 0x36, 0x65, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x36, 0x61, 0x38, 0x65, 0x61, 0x38, 0x37, 0x66, 0x31, 0x65, 0x39, 0x39, 0x65, 0x38, 0x61, 0x32, 0x64, 0x63, 0x31, 0x62, 0x32, 0x36, 0x30, 0x38, 0x64, 0x31, 0x36, 0x36, 0x36, 0x36, 0x37, 0x63, 0x39, 0x64, 0x66, 0x61, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x32, 0x63, 0x62, 0x38, 0x62, 0x39, 0x33, 0x37, 0x38, 0x64, 0x66, 0x66, 0x33, 0x31, 0x61, 0x65, 0x63, 0x33, 0x63, 0x32, 0x32, 0x65, 0x30, 0x65, 0x36, 0x64, 0x61, 0x64, 0x66, 0x66, 0x33, 0x31, 0x34, 0x61, 0x62, 0x35, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x61, 0x64, 0x65, 0x62, 0x33, 0x64, 0x33, 0x65, 0x65, 0x64, 0x33, 0x66, 0x36, 0x32, 0x33, 0x31, 0x31, 0x64, 0x35, 0x32, 0x35, 0x35, 0x33, 0x65, 0x37, 0x30, 0x64, 0x66, 0x34, 0x61, 0x66, 0x63, 0x65, 0x35, 0x36, 0x66, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x65, 0x63, 0x61, 0x39, 0x36, 0x62, 0x62, 0x31, 0x63, 0x64, 0x63, 0x32, 0x31, 0x34, 0x30, 0x32, 0x39, 0x63, 0x62, 0x63, 0x35, 0x65, 0x31, 0x38, 0x31, 0x64, 0x33, 0x39, 0x38, 0x61, 0x62, 0x39, 0x34, 0x64, 0x33, 0x64, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x38, 0x33, 0x65, 0x62, 0x37, 0x66, 0x39, 0x31, 0x33, 0x37, 0x64, 0x64, 0x33, 0x39, 0x62, 0x65, 0x64, 0x35, 0x35, 0x66, 0x66, 0x65, 0x36, 0x62, 0x38, 0x64, 0x63, 0x38, 0x34, 0x35, 0x66, 0x33, 0x65, 0x31, 0x61, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x34, 0x61, 0x38, 0x63, 0x62, 0x35, 0x64, 0x33, 0x32, 0x31, 0x66, 0x63, 0x33, 0x33, 0x35, 0x31, 0x61, 0x37, 0x35, 0x32, 0x33, 0x61, 0x36, 0x31, 0x37, 0x64, 0x30, 0x66, 0x35, 0x38, 0x64, 0x61, 0x36, 0x37, 0x36, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x33, 0x33, 0x64, 0x37, 0x30, 0x38, 0x61, 0x33, 0x62, 0x38, 0x39, 0x65, 0x39, 0x30, 0x39, 0x65, 0x61, 0x66, 0x36, 0x35, 0x33, 0x62, 0x33, 0x30, 0x66, 0x64, 0x63, 0x33, 0x61, 0x35, 0x64, 0x35, 0x63, 0x63, 0x62, 0x34, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x36, 0x37, 0x30, 0x32, 0x62, 0x33, 0x62, 0x30, 0x35, 0x61, 0x35, 0x31, 0x31, 0x34, 0x62, 0x64, 0x62, 0x63, 0x61, 0x65, 0x63, 0x61, 0x32, 0x35, 0x35, 0x33, 0x31, 0x61, 0x65, 0x65, 0x62, 0x33, 0x34, 0x38, 0x33, 0x35, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x37, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x62, 0x39, 0x36, 0x66, 0x63, 0x39, 0x61, 0x63, 0x30, 0x33, 0x64, 0x34, 0x34, 0x38, 0x63, 0x31, 0x36, 0x31, 0x33, 0x61, 0x63, 0x39, 0x31, 0x64, 0x31, 0x35, 0x39, 0x37, 0x38, 0x31, 0x34, 0x35, 0x64, 0x62, 0x64, 0x66, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x66, 0x32, 0x30, 0x34, 0x63, 0x38, 0x31, 0x33, 0x66, 0x38, 0x33, 0x36, 0x64, 0x38, 0x33, 0x39, 0x36, 0x32, 0x63, 0x37, 0x38, 0x37, 0x30, 0x63, 0x37, 0x38, 0x30, 0x38, 0x63, 0x61, 0x33, 0x34, 0x37, 0x66, 0x64, 0x33, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x31, 0x33, 0x36, 0x33, 0x31, 0x61, 0x31, 0x62, 0x38, 0x39, 0x63, 0x62, 0x35, 0x36, 0x36, 0x35, 0x34, 0x38, 0x38, 0x39, 0x39, 0x61, 0x31, 0x64, 0x36, 0x30, 0x39, 0x31, 0x35, 0x63, 0x64, 0x63, 0x63, 0x34, 0x32, 0x30, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x37, 0x66, 0x37, 0x61, 0x62, 0x64, 0x36, 0x66, 0x61, 0x33, 0x31, 0x31, 0x39, 0x34, 0x32, 0x38, 0x39, 0x36, 0x37, 0x38, 0x65, 0x66, 0x62, 0x36, 0x33, 0x63, 0x66, 0x35, 0x38, 0x34, 0x65, 0x65, 0x35, 0x65, 0x32, 0x61, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x61, 0x33, 0x39, 0x33, 0x30, 0x38, 0x61, 0x38, 0x30, 0x65, 0x39, 0x65, 0x38, 0x34, 0x61, 0x61, 0x61, 0x66, 0x31, 0x36, 0x61, 0x63, 0x30, 0x31, 0x65, 0x33, 0x62, 0x30, 0x31, 0x64, 0x37, 0x34, 0x62, 0x64, 0x36, 0x62, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x34, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x64, 0x36, 0x64, 0x61, 0x39, 0x35, 0x38, 0x65, 0x65, 0x63, 0x62, 0x63, 0x30, 0x31, 0x36, 0x62, 0x61, 0x62, 0x39, 0x31, 0x30, 0x35, 0x38, 0x34, 0x34, 0x30, 0x64, 0x33, 0x39, 0x62, 0x34, 0x31, 0x63, 0x37, 0x62, 0x65, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x33, 0x64, 0x64, 0x37, 0x64, 0x34, 0x65, 0x34, 0x32, 0x39, 0x66, 0x65, 0x33, 0x39, 0x33, 0x30, 0x61, 0x36, 0x34, 0x31, 0x34, 0x30, 0x33, 0x35, 0x66, 0x35, 0x32, 0x62, 0x64, 0x63, 0x35, 0x39, 0x39, 0x64, 0x37, 0x38, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x36, 0x36, 0x33, 0x65, 0x38, 0x63, 0x64, 0x36, 0x36, 0x37, 0x39, 0x32, 0x61, 0x36, 0x34, 0x31, 0x66, 0x35, 0x36, 0x65, 0x35, 0x30, 0x30, 0x33, 0x36, 0x36, 0x30, 0x31, 0x34, 0x37, 0x38, 0x38, 0x30, 0x66, 0x30, 0x31, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x37, 0x38, 0x65, 0x63, 0x61, 0x32, 0x37, 0x66, 0x62, 0x64, 0x65, 0x61, 0x36, 0x66, 0x32, 0x36, 0x62, 0x65, 0x66, 0x62, 0x61, 0x38, 0x39, 0x37, 0x32, 0x62, 0x32, 0x39, 0x35, 0x65, 0x37, 0x38, 0x31, 0x34, 0x33, 0x36, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x39, 0x38, 0x35, 0x31, 0x62, 0x64, 0x39, 0x31, 0x37, 0x32, 0x37, 0x30, 0x36, 0x31, 0x30, 0x32, 0x36, 0x37, 0x64, 0x36, 0x30, 0x35, 0x31, 0x38, 0x62, 0x35, 0x34, 0x64, 0x33, 0x63, 0x61, 0x32, 0x62, 0x33, 0x35, 0x62, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x39, 0x63, 0x39, 0x35, 0x64, 0x66, 0x61, 0x62, 0x39, 0x37, 0x61, 0x35, 0x37, 0x34, 0x63, 0x65, 0x61, 0x32, 0x61, 0x61, 0x38, 0x30, 0x33, 0x62, 0x35, 0x63, 0x61, 0x61, 0x31, 0x39, 0x37, 0x63, 0x65, 0x66, 0x30, 0x63, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x30, 0x62, 0x34, 0x64, 0x30, 0x39, 0x37, 0x37, 0x66, 0x63, 0x62, 0x61, 0x64, 0x34, 0x64, 0x65, 0x62, 0x64, 0x35, 0x65, 0x36, 0x34, 0x61, 0x30, 0x34, 0x39, 0x37, 0x61, 0x65, 0x61, 0x65, 0x35, 0x31, 0x36, 0x38, 0x66, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x36, 0x36, 0x31, 0x30, 0x66, 0x62, 0x36, 0x38, 0x62, 0x61, 0x64, 0x36, 0x65, 0x64, 0x31, 0x63, 0x66, 0x61, 0x61, 0x30, 0x62, 0x62, 0x65, 0x33, 0x33, 0x61, 0x32, 0x34, 0x65, 0x62, 0x32, 0x65, 0x39, 0x36, 0x66, 0x61, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x35, 0x32, 0x34, 0x63, 0x39, 0x35, 0x61, 0x37, 0x38, 0x36, 0x30, 0x65, 0x32, 0x31, 0x38, 0x34, 0x30, 0x32, 0x39, 0x36, 0x61, 0x36, 0x31, 0x36, 0x32, 0x34, 0x34, 0x30, 0x31, 0x39, 0x34, 0x32, 0x31, 0x63, 0x34, 0x61, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x39, 0x37, 0x35, 0x61, 0x35, 0x66, 0x31, 0x65, 0x66, 0x32, 0x35, 0x32, 0x38, 0x63, 0x33, 0x30, 0x30, 0x62, 0x38, 0x33, 0x63, 0x30, 0x63, 0x36, 0x30, 0x37, 0x62, 0x38, 0x65, 0x38, 0x37, 0x64, 0x64, 0x36, 0x39, 0x33, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x33, 0x65, 0x36, 0x61, 0x62, 0x61, 0x66, 0x34, 0x34, 0x34, 0x36, 0x39, 0x63, 0x37, 0x32, 0x66, 0x31, 0x35, 0x31, 0x64, 0x34, 0x65, 0x32, 0x32, 0x33, 0x38, 0x31, 0x39, 0x61, 0x63, 0x65, 0x64, 0x34, 0x65, 0x33, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x30, 0x34, 0x61, 0x62, 0x63, 0x65, 0x34, 0x33, 0x33, 0x30, 0x38, 0x34, 0x32, 0x65, 0x33, 0x64, 0x33, 0x39, 0x36, 0x63, 0x61, 0x37, 0x33, 0x64, 0x64, 0x62, 0x35, 0x35, 0x31, 0x39, 0x65, 0x64, 0x33, 0x65, 0x63, 0x30, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x30, 0x39, 0x34, 0x38, 0x32, 0x62, 0x62, 0x35, 0x34, 0x39, 0x61, 0x62, 0x63, 0x34, 0x37, 0x37, 0x37, 0x62, 0x65, 0x61, 0x36, 0x64, 0x37, 0x66, 0x36, 0x35, 0x30, 0x30, 0x36, 0x32, 0x63, 0x39, 0x63, 0x35, 0x37, 0x61, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x30, 0x61, 0x63, 0x62, 0x64, 0x61, 0x33, 0x37, 0x32, 0x39, 0x30, 0x63, 0x30, 0x64, 0x33, 0x65, 0x63, 0x38, 0x34, 0x66, 0x63, 0x32, 0x30, 0x30, 0x30, 0x64, 0x37, 0x36, 0x39, 0x37, 0x66, 0x39, 0x61, 0x34, 0x62, 0x31, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x31, 0x39, 0x35, 0x30, 0x65, 0x61, 0x32, 0x63, 0x39, 0x30, 0x63, 0x31, 0x34, 0x32, 0x37, 0x64, 0x39, 0x33, 0x39, 0x64, 0x36, 0x31, 0x62, 0x34, 0x66, 0x32, 0x64, 0x65, 0x34, 0x63, 0x66, 0x31, 0x63, 0x66, 0x62, 0x66, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x39, 0x34, 0x65, 0x37, 0x36, 0x66, 0x65, 0x62, 0x65, 0x32, 0x30, 0x38, 0x31, 0x31, 0x36, 0x37, 0x33, 0x33, 0x65, 0x37, 0x36, 0x65, 0x38, 0x30, 0x35, 0x64, 0x34, 0x38, 0x64, 0x31, 0x31, 0x32, 0x65, 0x63, 0x39, 0x66, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x38, 0x65, 0x33, 0x62, 0x31, 0x66, 0x31, 0x33, 0x34, 0x33, 0x33, 0x39, 0x30, 0x30, 0x37, 0x33, 0x37, 0x64, 0x61, 0x61, 0x66, 0x31, 0x66, 0x36, 0x32, 0x39, 0x39, 0x63, 0x34, 0x38, 0x38, 0x37, 0x66, 0x38, 0x35, 0x62, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x32, 0x64, 0x37, 0x36, 0x63, 0x32, 0x65, 0x36, 0x35, 0x31, 0x34, 0x61, 0x33, 0x61, 0x66, 0x62, 0x36, 0x66, 0x65, 0x33, 0x64, 0x33, 0x63, 0x62, 0x39, 0x33, 0x61, 0x33, 0x35, 0x63, 0x35, 0x61, 0x65, 0x37, 0x38, 0x33, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x65, 0x61, 0x32, 0x38, 0x38, 0x65, 0x65, 0x61, 0x34, 0x32, 0x63, 0x34, 0x39, 0x35, 0x35, 0x65, 0x62, 0x39, 0x66, 0x61, 0x61, 0x64, 0x32, 0x61, 0x39, 0x66, 0x61, 0x66, 0x34, 0x37, 0x38, 0x33, 0x63, 0x62, 0x64, 0x64, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x37, 0x39, 0x30, 0x36, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x61, 0x62, 0x31, 0x61, 0x33, 0x63, 0x66, 0x34, 0x36, 0x63, 0x62, 0x38, 0x62, 0x30, 0x36, 0x34, 0x64, 0x66, 0x32, 0x65, 0x32, 0x32, 0x32, 0x64, 0x33, 0x39, 0x36, 0x30, 0x37, 0x33, 0x39, 0x34, 0x32, 0x30, 0x33, 0x32, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x38, 0x62, 0x32, 0x65, 0x61, 0x35, 0x66, 0x30, 0x61, 0x61, 0x61, 0x38, 0x37, 0x39, 0x63, 0x34, 0x64, 0x35, 0x65, 0x35, 0x34, 0x38, 0x61, 0x63, 0x39, 0x64, 0x39, 0x32, 0x61, 0x30, 0x63, 0x36, 0x37, 0x34, 0x38, 0x37, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x63, 0x35, 0x66, 0x65, 0x30, 0x31, 0x31, 0x39, 0x65, 0x31, 0x65, 0x38, 0x34, 0x38, 0x36, 0x34, 0x30, 0x63, 0x65, 0x65, 0x33, 0x30, 0x61, 0x64, 0x65, 0x61, 0x39, 0x36, 0x39, 0x34, 0x30, 0x66, 0x32, 0x61, 0x35, 0x64, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x37, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x30, 0x31, 0x66, 0x39, 0x66, 0x31, 0x34, 0x37, 0x65, 0x63, 0x34, 0x38, 0x36, 0x38, 0x35, 0x36, 0x66, 0x35, 0x65, 0x31, 0x62, 0x37, 0x31, 0x64, 0x65, 0x39, 0x66, 0x31, 0x31, 0x37, 0x65, 0x39, 0x39, 0x65, 0x32, 0x31, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x37, 0x63, 0x66, 0x65, 0x31, 0x31, 0x35, 0x37, 0x61, 0x35, 0x63, 0x36, 0x39, 0x31, 0x32, 0x30, 0x31, 0x30, 0x64, 0x64, 0x35, 0x36, 0x31, 0x35, 0x33, 0x33, 0x37, 0x39, 0x31, 0x37, 0x36, 0x39, 0x63, 0x32, 0x62, 0x36, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x36, 0x30, 0x64, 0x32, 0x62, 0x35, 0x61, 0x66, 0x33, 0x64, 0x33, 0x35, 0x66, 0x37, 0x61, 0x61, 0x66, 0x30, 0x63, 0x33, 0x39, 0x33, 0x30, 0x35, 0x32, 0x65, 0x37, 0x39, 0x63, 0x34, 0x64, 0x38, 0x32, 0x33, 0x64, 0x39, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x30, 0x34, 0x39, 0x61, 0x38, 0x62, 0x64, 0x66, 0x64, 0x37, 0x36, 0x31, 0x64, 0x65, 0x38, 0x65, 0x63, 0x30, 0x32, 0x63, 0x65, 0x65, 0x32, 0x38, 0x32, 0x39, 0x63, 0x34, 0x30, 0x30, 0x35, 0x62, 0x32, 0x33, 0x63, 0x30, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x34, 0x62, 0x63, 0x65, 0x37, 0x61, 0x38, 0x35, 0x33, 0x63, 0x39, 0x37, 0x30, 0x62, 0x62, 0x35, 0x65, 0x63, 0x37, 0x62, 0x62, 0x37, 0x35, 0x39, 0x62, 0x61, 0x65, 0x62, 0x39, 0x63, 0x37, 0x34, 0x31, 0x30, 0x38, 0x35, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x61, 0x62, 0x62, 0x38, 0x62, 0x30, 0x32, 0x31, 0x61, 0x37, 0x31, 0x30, 0x62, 0x64, 0x63, 0x37, 0x38, 0x65, 0x61, 0x35, 0x33, 0x34, 0x39, 0x34, 0x62, 0x32, 0x30, 0x36, 0x31, 0x34, 0x66, 0x66, 0x34, 0x65, 0x61, 0x66, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x37, 0x66, 0x36, 0x35, 0x61, 0x39, 0x30, 0x65, 0x38, 0x35, 0x30, 0x38, 0x38, 0x36, 0x37, 0x62, 0x63, 0x63, 0x63, 0x39, 0x31, 0x34, 0x32, 0x35, 0x36, 0x61, 0x31, 0x65, 0x61, 0x35, 0x37, 0x34, 0x63, 0x66, 0x30, 0x37, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x64, 0x30, 0x33, 0x38, 0x31, 0x35, 0x63, 0x36, 0x31, 0x66, 0x34, 0x31, 0x36, 0x62, 0x37, 0x31, 0x61, 0x32, 0x36, 0x31, 0x30, 0x61, 0x32, 0x64, 0x61, 0x62, 0x61, 0x35, 0x39, 0x66, 0x66, 0x36, 0x61, 0x36, 0x64, 0x65, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x66, 0x37, 0x36, 0x32, 0x30, 0x34, 0x39, 0x65, 0x64, 0x61, 0x38, 0x61, 0x63, 0x36, 0x39, 0x32, 0x37, 0x64, 0x39, 0x30, 0x34, 0x63, 0x37, 0x61, 0x66, 0x34, 0x32, 0x66, 0x39, 0x34, 0x65, 0x35, 0x35, 0x31, 0x39, 0x36, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x39, 0x33, 0x63, 0x39, 0x64, 0x34, 0x62, 0x36, 0x36, 0x34, 0x37, 0x33, 0x30, 0x66, 0x64, 0x39, 0x33, 0x63, 0x61, 0x36, 0x30, 0x31, 0x35, 0x31, 0x63, 0x32, 0x35, 0x63, 0x32, 0x65, 0x61, 0x65, 0x64, 0x39, 0x33, 0x63, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x32, 0x33, 0x66, 0x30, 0x39, 0x62, 0x32, 0x38, 0x38, 0x37, 0x36, 0x31, 0x32, 0x63, 0x37, 0x63, 0x39, 0x63, 0x66, 0x31, 0x39, 0x38, 0x38, 0x65, 0x33, 0x61, 0x33, 0x61, 0x36, 0x30, 0x32, 0x62, 0x33, 0x33, 0x39, 0x34, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x31, 0x33, 0x39, 0x38, 0x30, 0x63, 0x33, 0x32, 0x64, 0x63, 0x66, 0x33, 0x39, 0x32, 0x30, 0x62, 0x37, 0x38, 0x61, 0x34, 0x61, 0x37, 0x39, 0x30, 0x33, 0x33, 0x31, 0x32, 0x39, 0x30, 0x37, 0x63, 0x31, 0x62, 0x31, 0x32, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x38, 0x32, 0x65, 0x39, 0x36, 0x39, 0x63, 0x61, 0x63, 0x39, 0x66, 0x37, 0x61, 0x30, 0x65, 0x31, 0x63, 0x30, 0x63, 0x64, 0x39, 0x30, 0x66, 0x35, 0x64, 0x30, 0x63, 0x34, 0x33, 0x38, 0x61, 0x63, 0x35, 0x37, 0x30, 0x64, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x32, 0x32, 0x64, 0x61, 0x32, 0x61, 0x30, 0x32, 0x37, 0x31, 0x63, 0x38, 0x65, 0x66, 0x65, 0x31, 0x30, 0x32, 0x35, 0x33, 0x32, 0x37, 0x37, 0x33, 0x36, 0x33, 0x36, 0x61, 0x36, 0x39, 0x62, 0x31, 0x63, 0x31, 0x37, 0x65, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x61, 0x31, 0x30, 0x32, 0x31, 0x66, 0x35, 0x35, 0x30, 0x61, 0x66, 0x31, 0x35, 0x38, 0x63, 0x37, 0x34, 0x37, 0x36, 0x36, 0x38, 0x64, 0x64, 0x31, 0x33, 0x62, 0x34, 0x36, 0x33, 0x31, 0x36, 0x30, 0x66, 0x39, 0x35, 0x61, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x35, 0x31, 0x37, 0x38, 0x66, 0x66, 0x63, 0x34, 0x33, 0x61, 0x61, 0x38, 0x30, 0x37, 0x30, 0x65, 0x63, 0x65, 0x33, 0x32, 0x37, 0x65, 0x39, 0x33, 0x30, 0x66, 0x38, 0x30, 0x39, 0x61, 0x62, 0x31, 0x61, 0x35, 0x34, 0x66, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x31, 0x32, 0x39, 0x33, 0x61, 0x35, 0x30, 0x36, 0x65, 0x39, 0x30, 0x63, 0x61, 0x64, 0x32, 0x61, 0x35, 0x39, 0x65, 0x31, 0x62, 0x38, 0x35, 0x36, 0x31, 0x66, 0x35, 0x65, 0x36, 0x36, 0x39, 0x36, 0x31, 0x61, 0x36, 0x37, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x63, 0x33, 0x36, 0x31, 0x36, 0x34, 0x30, 0x64, 0x36, 0x62, 0x36, 0x39, 0x33, 0x37, 0x33, 0x62, 0x30, 0x38, 0x31, 0x63, 0x65, 0x30, 0x63, 0x34, 0x33, 0x33, 0x62, 0x64, 0x35, 0x39, 0x30, 0x32, 0x38, 0x37, 0x64, 0x35, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x33, 0x37, 0x32, 0x31, 0x36, 0x65, 0x65, 0x39, 0x31, 0x66, 0x31, 0x37, 0x37, 0x37, 0x33, 0x32, 0x66, 0x62, 0x35, 0x38, 0x66, 0x61, 0x34, 0x30, 0x39, 0x37, 0x32, 0x36, 0x37, 0x32, 0x30, 0x37, 0x65, 0x32, 0x63, 0x66, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x36, 0x64, 0x39, 0x65, 0x33, 0x64, 0x36, 0x33, 0x39, 0x38, 0x36, 0x31, 0x35, 0x39, 0x61, 0x38, 0x30, 0x30, 0x62, 0x34, 0x36, 0x38, 0x33, 0x37, 0x66, 0x34, 0x35, 0x65, 0x38, 0x62, 0x62, 0x39, 0x38, 0x30, 0x65, 0x65, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x37, 0x36, 0x66, 0x31, 0x32, 0x65, 0x35, 0x37, 0x61, 0x36, 0x35, 0x35, 0x30, 0x34, 0x30, 0x33, 0x33, 0x66, 0x32, 0x63, 0x30, 0x62, 0x63, 0x65, 0x36, 0x66, 0x63, 0x30, 0x33, 0x62, 0x64, 0x37, 0x66, 0x61, 0x30, 0x61, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x66, 0x31, 0x62, 0x32, 0x36, 0x34, 0x30, 0x38, 0x66, 0x30, 0x65, 0x63, 0x36, 0x37, 0x61, 0x64, 0x31, 0x64, 0x30, 0x64, 0x36, 0x66, 0x65, 0x32, 0x32, 0x65, 0x38, 0x35, 0x31, 0x35, 0x65, 0x31, 0x37, 0x34, 0x30, 0x36, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x36, 0x62, 0x61, 0x30, 0x31, 0x65, 0x61, 0x64, 0x32, 0x61, 0x39, 0x31, 0x32, 0x37, 0x30, 0x36, 0x33, 0x35, 0x66, 0x39, 0x35, 0x66, 0x32, 0x35, 0x62, 0x66, 0x61, 0x66, 0x32, 0x64, 0x64, 0x36, 0x31, 0x30, 0x63, 0x61, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x61, 0x39, 0x38, 0x62, 0x66, 0x31, 0x36, 0x30, 0x32, 0x37, 0x63, 0x65, 0x35, 0x38, 0x39, 0x63, 0x34, 0x65, 0x64, 0x32, 0x63, 0x39, 0x35, 0x38, 0x33, 0x31, 0x65, 0x32, 0x37, 0x32, 0x34, 0x32, 0x30, 0x35, 0x30, 0x36, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x38, 0x38, 0x61, 0x61, 0x63, 0x39, 0x33, 0x34, 0x36, 0x63, 0x62, 0x30, 0x65, 0x37, 0x33, 0x34, 0x37, 0x66, 0x62, 0x61, 0x37, 0x30, 0x39, 0x30, 0x35, 0x34, 0x37, 0x35, 0x62, 0x61, 0x38, 0x62, 0x33, 0x65, 0x35, 0x65, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x38, 0x63, 0x35, 0x32, 0x33, 0x32, 0x39, 0x66, 0x33, 0x38, 0x64, 0x32, 0x61, 0x32, 0x66, 0x61, 0x39, 0x63, 0x62, 0x61, 0x66, 0x35, 0x63, 0x35, 0x38, 0x33, 0x64, 0x61, 0x66, 0x31, 0x34, 0x39, 0x30, 0x62, 0x62, 0x31, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x65, 0x61, 0x33, 0x30, 0x32, 0x61, 0x34, 0x37, 0x32, 0x61, 0x39, 0x34, 0x30, 0x33, 0x37, 0x39, 0x64, 0x64, 0x33, 0x39, 0x38, 0x61, 0x32, 0x34, 0x65, 0x61, 0x66, 0x64, 0x62, 0x61, 0x64, 0x66, 0x38, 0x38, 0x61, 0x64, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x39, 0x64, 0x35, 0x62, 0x64, 0x61, 0x37, 0x34, 0x65, 0x30, 0x30, 0x33, 0x34, 0x37, 0x34, 0x38, 0x37, 0x32, 0x62, 0x64, 0x35, 0x38, 0x39, 0x34, 0x62, 0x38, 0x38, 0x35, 0x33, 0x33, 0x66, 0x66, 0x36, 0x34, 0x63, 0x32, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x32, 0x33, 0x37, 0x36, 0x36, 0x62, 0x36, 0x66, 0x36, 0x62, 0x30, 0x35, 0x37, 0x33, 0x37, 0x64, 0x61, 0x64, 0x38, 0x30, 0x61, 0x34, 0x31, 0x39, 0x63, 0x34, 0x30, 0x65, 0x64, 0x61, 0x34, 0x64, 0x37, 0x37, 0x31, 0x30, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x37, 0x32, 0x34, 0x39, 0x65, 0x30, 0x35, 0x35, 0x30, 0x34, 0x34, 0x61, 0x39, 0x31, 0x35, 0x35, 0x33, 0x35, 0x39, 0x61, 0x34, 0x30, 0x32, 0x39, 0x33, 0x37, 0x62, 0x62, 0x64, 0x39, 0x35, 0x34, 0x66, 0x65, 0x34, 0x38, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x65, 0x39, 0x38, 0x30, 0x63, 0x35, 0x35, 0x39, 0x61, 0x31, 0x61, 0x38, 0x65, 0x35, 0x65, 0x35, 0x30, 0x61, 0x34, 0x37, 0x66, 0x38, 0x66, 0x66, 0x66, 0x64, 0x63, 0x37, 0x37, 0x33, 0x62, 0x37, 0x65, 0x30, 0x36, 0x61, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x31, 0x30, 0x34, 0x37, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x37, 0x35, 0x63, 0x64, 0x36, 0x38, 0x34, 0x63, 0x33, 0x36, 0x37, 0x39, 0x64, 0x35, 0x38, 0x38, 0x37, 0x64, 0x30, 0x33, 0x36, 0x36, 0x34, 0x65, 0x33, 0x33, 0x38, 0x33, 0x34, 0x35, 0x64, 0x63, 0x33, 0x63, 0x64, 0x64, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x37, 0x63, 0x31, 0x61, 0x32, 0x34, 0x32, 0x30, 0x34, 0x63, 0x31, 0x65, 0x31, 0x31, 0x38, 0x64, 0x37, 0x35, 0x31, 0x34, 0x39, 0x64, 0x64, 0x31, 0x30, 0x39, 0x33, 0x31, 0x31, 0x65, 0x30, 0x37, 0x63, 0x30, 0x37, 0x33, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x31, 0x62, 0x33, 0x36, 0x39, 0x39, 0x34, 0x37, 0x35, 0x62, 0x65, 0x64, 0x35, 0x64, 0x37, 0x39, 0x30, 0x35, 0x66, 0x38, 0x39, 0x30, 0x35, 0x61, 0x61, 0x33, 0x34, 0x35, 0x36, 0x66, 0x31, 0x65, 0x64, 0x37, 0x38, 0x38, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x61, 0x64, 0x34, 0x64, 0x39, 0x39, 0x34, 0x36, 0x65, 0x66, 0x30, 0x39, 0x64, 0x38, 0x65, 0x39, 0x38, 0x38, 0x64, 0x39, 0x34, 0x36, 0x62, 0x31, 0x32, 0x32, 0x37, 0x66, 0x39, 0x31, 0x34, 0x31, 0x39, 0x30, 0x31, 0x37, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x62, 0x38, 0x61, 0x39, 0x35, 0x39, 0x32, 0x36, 0x33, 0x34, 0x66, 0x37, 0x33, 0x30, 0x30, 0x62, 0x37, 0x63, 0x35, 0x63, 0x35, 0x39, 0x61, 0x33, 0x33, 0x34, 0x35, 0x62, 0x38, 0x33, 0x35, 0x66, 0x30, 0x31, 0x62, 0x39, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x36, 0x31, 0x37, 0x32, 0x35, 0x66, 0x64, 0x63, 0x65, 0x64, 0x64, 0x31, 0x37, 0x39, 0x35, 0x32, 0x64, 0x35, 0x37, 0x62, 0x32, 0x33, 0x65, 0x66, 0x32, 0x38, 0x35, 0x62, 0x37, 0x65, 0x34, 0x62, 0x31, 0x31, 0x36, 0x39, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x66, 0x63, 0x35, 0x61, 0x39, 0x39, 0x63, 0x30, 0x63, 0x35, 0x34, 0x36, 0x30, 0x35, 0x30, 0x33, 0x61, 0x31, 0x33, 0x62, 0x30, 0x35, 0x30, 0x39, 0x34, 0x35, 0x39, 0x64, 0x61, 0x31, 0x39, 0x63, 0x65, 0x37, 0x63, 0x64, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x39, 0x64, 0x66, 0x37, 0x34, 0x32, 0x31, 0x62, 0x39, 0x33, 0x38, 0x32, 0x65, 0x34, 0x32, 0x63, 0x38, 0x39, 0x62, 0x30, 0x30, 0x36, 0x63, 0x37, 0x66, 0x30, 0x38, 0x37, 0x37, 0x30, 0x32, 0x61, 0x30, 0x37, 0x35, 0x37, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x34, 0x66, 0x34, 0x61, 0x37, 0x66, 0x35, 0x32, 0x61, 0x33, 0x35, 0x35, 0x62, 0x61, 0x31, 0x30, 0x35, 0x66, 0x63, 0x61, 0x32, 0x30, 0x37, 0x32, 0x64, 0x33, 0x30, 0x36, 0x35, 0x66, 0x63, 0x38, 0x66, 0x37, 0x39, 0x34, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x33, 0x31, 0x36, 0x66, 0x63, 0x37, 0x66, 0x31, 0x37, 0x38, 0x65, 0x61, 0x63, 0x32, 0x32, 0x65, 0x62, 0x32, 0x62, 0x32, 0x35, 0x61, 0x65, 0x64, 0x65, 0x61, 0x64, 0x66, 0x33, 0x64, 0x37, 0x35, 0x64, 0x30, 0x30, 0x31, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x39, 0x38, 0x64, 0x62, 0x32, 0x65, 0x30, 0x39, 0x61, 0x38, 0x61, 0x35, 0x65, 0x65, 0x37, 0x64, 0x37, 0x32, 0x30, 0x64, 0x32, 0x62, 0x35, 0x63, 0x34, 0x33, 0x62, 0x62, 0x31, 0x32, 0x36, 0x64, 0x31, 0x31, 0x65, 0x63, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x62, 0x38, 0x62, 0x65, 0x61, 0x63, 0x37, 0x62, 0x31, 0x63, 0x61, 0x33, 0x38, 0x38, 0x32, 0x39, 0x64, 0x36, 0x31, 0x61, 0x62, 0x35, 0x35, 0x32, 0x63, 0x37, 0x36, 0x36, 0x66, 0x34, 0x38, 0x61, 0x31, 0x30, 0x63, 0x33, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x31, 0x64, 0x63, 0x33, 0x38, 0x61, 0x64, 0x62, 0x34, 0x35, 0x39, 0x33, 0x37, 0x32, 0x39, 0x61, 0x37, 0x36, 0x66, 0x33, 0x33, 0x61, 0x38, 0x36, 0x31, 0x36, 0x64, 0x61, 0x62, 0x36, 0x66, 0x35, 0x66, 0x35, 0x39, 0x61, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x34, 0x30, 0x39, 0x36, 0x62, 0x63, 0x35, 0x34, 0x37, 0x64, 0x62, 0x66, 0x63, 0x34, 0x65, 0x37, 0x34, 0x38, 0x30, 0x39, 0x61, 0x33, 0x31, 0x63, 0x30, 0x33, 0x39, 0x65, 0x37, 0x62, 0x33, 0x38, 0x39, 0x64, 0x35, 0x65, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x64, 0x33, 0x37, 0x33, 0x31, 0x39, 0x39, 0x32, 0x64, 0x31, 0x64, 0x34, 0x30, 0x65, 0x31, 0x32, 0x31, 0x31, 0x63, 0x37, 0x66, 0x37, 0x33, 0x35, 0x66, 0x32, 0x31, 0x38, 0x39, 0x61, 0x66, 0x61, 0x30, 0x37, 0x30, 0x32, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x34, 0x30, 0x37, 0x33, 0x63, 0x31, 0x62, 0x39, 0x39, 0x64, 0x66, 0x36, 0x30, 0x61, 0x31, 0x35, 0x34, 0x39, 0x64, 0x36, 0x39, 0x37, 0x38, 0x39, 0x63, 0x37, 0x33, 0x31, 0x38, 0x64, 0x39, 0x34, 0x30, 0x33, 0x61, 0x38, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x33, 0x30, 0x39, 0x39, 0x35, 0x64, 0x64, 0x62, 0x31, 0x38, 0x35, 0x62, 0x39, 0x38, 0x36, 0x35, 0x64, 0x62, 0x65, 0x36, 0x32, 0x35, 0x33, 0x39, 0x61, 0x64, 0x39, 0x30, 0x64, 0x32, 0x32, 0x65, 0x34, 0x62, 0x37, 0x33, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x38, 0x63, 0x37, 0x32, 0x64, 0x64, 0x37, 0x33, 0x36, 0x35, 0x35, 0x38, 0x65, 0x66, 0x39, 0x65, 0x34, 0x62, 0x65, 0x39, 0x66, 0x64, 0x63, 0x33, 0x34, 0x66, 0x65, 0x66, 0x35, 0x34, 0x64, 0x37, 0x66, 0x63, 0x37, 0x65, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x62, 0x36, 0x31, 0x37, 0x66, 0x37, 0x35, 0x32, 0x65, 0x64, 0x65, 0x63, 0x61, 0x65, 0x33, 0x65, 0x39, 0x30, 0x39, 0x66, 0x62, 0x62, 0x39, 0x31, 0x31, 0x64, 0x32, 0x66, 0x38, 0x31, 0x39, 0x32, 0x66, 0x38, 0x34, 0x32, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x61, 0x65, 0x30, 0x32, 0x39, 0x62, 0x31, 0x37, 0x65, 0x33, 0x37, 0x33, 0x63, 0x64, 0x65, 0x33, 0x64, 0x65, 0x35, 0x61, 0x39, 0x31, 0x35, 0x32, 0x32, 0x30, 0x31, 0x61, 0x31, 0x34, 0x63, 0x61, 0x63, 0x34, 0x65, 0x31, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x65, 0x38, 0x34, 0x37, 0x34, 0x32, 0x39, 0x32, 0x65, 0x37, 0x61, 0x30, 0x35, 0x31, 0x36, 0x30, 0x34, 0x63, 0x61, 0x31, 0x36, 0x34, 0x63, 0x30, 0x37, 0x30, 0x37, 0x37, 0x38, 0x33, 0x62, 0x62, 0x32, 0x38, 0x38, 0x35, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x37, 0x36, 0x66, 0x32, 0x63, 0x62, 0x37, 0x32, 0x30, 0x38, 0x61, 0x33, 0x32, 0x65, 0x30, 0x35, 0x31, 0x66, 0x64, 0x39, 0x34, 0x65, 0x61, 0x38, 0x36, 0x36, 0x32, 0x39, 0x39, 0x32, 0x36, 0x33, 0x38, 0x32, 0x38, 0x37, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x38, 0x34, 0x65, 0x39, 0x35, 0x30, 0x65, 0x64, 0x34, 0x31, 0x30, 0x65, 0x35, 0x31, 0x62, 0x37, 0x65, 0x38, 0x38, 0x30, 0x31, 0x30, 0x34, 0x39, 0x61, 0x62, 0x32, 0x36, 0x33, 0x34, 0x62, 0x32, 0x38, 0x35, 0x66, 0x65, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x37, 0x37, 0x38, 0x34, 0x63, 0x61, 0x65, 0x61, 0x30, 0x31, 0x37, 0x39, 0x39, 0x63, 0x61, 0x33, 0x30, 0x32, 0x32, 0x37, 0x38, 0x32, 0x37, 0x36, 0x36, 0x37, 0x63, 0x65, 0x32, 0x30, 0x37, 0x63, 0x35, 0x63, 0x62, 0x63, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x66, 0x36, 0x35, 0x62, 0x33, 0x65, 0x32, 0x38, 0x38, 0x39, 0x35, 0x61, 0x34, 0x61, 0x30, 0x30, 0x31, 0x31, 0x35, 0x33, 0x33, 0x39, 0x31, 0x64, 0x31, 0x65, 0x36, 0x39, 0x63, 0x33, 0x31, 0x66, 0x62, 0x39, 0x64, 0x62, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x66, 0x62, 0x35, 0x61, 0x66, 0x62, 0x31, 0x34, 0x63, 0x31, 0x65, 0x66, 0x39, 0x61, 0x62, 0x37, 0x64, 0x31, 0x37, 0x39, 0x63, 0x35, 0x63, 0x33, 0x30, 0x30, 0x35, 0x30, 0x33, 0x66, 0x64, 0x36, 0x36, 0x61, 0x35, 0x65, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x32, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x34, 0x34, 0x36, 0x63, 0x34, 0x37, 0x38, 0x31, 0x61, 0x37, 0x33, 0x37, 0x61, 0x63, 0x34, 0x33, 0x32, 0x38, 0x62, 0x31, 0x65, 0x31, 0x35, 0x62, 0x38, 0x61, 0x30, 0x62, 0x33, 0x66, 0x62, 0x62, 0x30, 0x66, 0x64, 0x36, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x33, 0x39, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x38, 0x38, 0x66, 0x62, 0x32, 0x35, 0x63, 0x64, 0x35, 0x30, 0x64, 0x62, 0x62, 0x39, 0x65, 0x30, 0x34, 0x38, 0x66, 0x34, 0x31, 0x63, 0x61, 0x34, 0x37, 0x64, 0x37, 0x38, 0x62, 0x37, 0x38, 0x61, 0x32, 0x37, 0x63, 0x37, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x36, 0x63, 0x31, 0x30, 0x64, 0x36, 0x33, 0x38, 0x65, 0x38, 0x62, 0x38, 0x38, 0x62, 0x34, 0x37, 0x64, 0x36, 0x65, 0x36, 0x61, 0x34, 0x31, 0x34, 0x34, 0x39, 0x37, 0x61, 0x66, 0x64, 0x64, 0x30, 0x30, 0x36, 0x30, 0x30, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x34, 0x37, 0x66, 0x35, 0x66, 0x37, 0x36, 0x65, 0x33, 0x62, 0x39, 0x33, 0x30, 0x66, 0x64, 0x39, 0x34, 0x38, 0x35, 0x32, 0x30, 0x39, 0x65, 0x66, 0x61, 0x30, 0x64, 0x34, 0x37, 0x36, 0x33, 0x64, 0x61, 0x30, 0x37, 0x35, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x31, 0x63, 0x36, 0x33, 0x35, 0x31, 0x37, 0x37, 0x36, 0x61, 0x63, 0x33, 0x31, 0x30, 0x39, 0x31, 0x33, 0x39, 0x37, 0x65, 0x63, 0x66, 0x31, 0x36, 0x30, 0x30, 0x32, 0x64, 0x39, 0x37, 0x39, 0x61, 0x31, 0x62, 0x32, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x66, 0x36, 0x30, 0x33, 0x38, 0x39, 0x30, 0x32, 0x32, 0x38, 0x64, 0x37, 0x64, 0x35, 0x64, 0x65, 0x39, 0x33, 0x30, 0x39, 0x39, 0x34, 0x32, 0x62, 0x35, 0x63, 0x61, 0x64, 0x34, 0x32, 0x31, 0x39, 0x65, 0x66, 0x39, 0x61, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x32, 0x33, 0x63, 0x66, 0x63, 0x36, 0x38, 0x62, 0x31, 0x33, 0x65, 0x61, 0x37, 0x65, 0x32, 0x30, 0x35, 0x35, 0x38, 0x30, 0x33, 0x36, 0x34, 0x35, 0x63, 0x31, 0x65, 0x33, 0x32, 0x30, 0x31, 0x35, 0x36, 0x62, 0x64, 0x38, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x38, 0x66, 0x33, 0x37, 0x64, 0x30, 0x61, 0x64, 0x38, 0x66, 0x33, 0x33, 0x35, 0x64, 0x32, 0x61, 0x37, 0x31, 0x30, 0x31, 0x62, 0x34, 0x31, 0x31, 0x35, 0x36, 0x62, 0x36, 0x38, 0x38, 0x61, 0x38, 0x31, 0x61, 0x39, 0x63, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x33, 0x33, 0x34, 0x66, 0x63, 0x66, 0x31, 0x37, 0x34, 0x35, 0x38, 0x34, 0x30, 0x65, 0x34, 0x62, 0x30, 0x39, 0x34, 0x61, 0x33, 0x62, 0x62, 0x34, 0x30, 0x62, 0x62, 0x37, 0x36, 0x66, 0x39, 0x36, 0x30, 0x34, 0x63, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x31, 0x37, 0x36, 0x32, 0x34, 0x33, 0x30, 0x65, 0x61, 0x39, 0x63, 0x33, 0x61, 0x32, 0x36, 0x65, 0x35, 0x37, 0x34, 0x39, 0x61, 0x66, 0x64, 0x62, 0x37, 0x30, 0x64, 0x61, 0x35, 0x66, 0x37, 0x38, 0x64, 0x64, 0x62, 0x62, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x32, 0x31, 0x31, 0x36, 0x38, 0x31, 0x37, 0x62, 0x61, 0x39, 0x61, 0x61, 0x66, 0x38, 0x34, 0x33, 0x64, 0x31, 0x35, 0x30, 0x37, 0x63, 0x36, 0x35, 0x61, 0x35, 0x65, 0x61, 0x36, 0x34, 0x30, 0x61, 0x37, 0x62, 0x39, 0x65, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x36, 0x31, 0x66, 0x62, 0x33, 0x39, 0x31, 0x63, 0x36, 0x31, 0x39, 0x35, 0x37, 0x63, 0x62, 0x35, 0x63, 0x39, 0x65, 0x34, 0x30, 0x37, 0x64, 0x64, 0x61, 0x32, 0x39, 0x33, 0x33, 0x38, 0x64, 0x33, 0x62, 0x39, 0x32, 0x63, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x32, 0x39, 0x35, 0x32, 0x62, 0x34, 0x63, 0x34, 0x39, 0x66, 0x65, 0x64, 0x64, 0x30, 0x62, 0x63, 0x30, 0x35, 0x32, 0x38, 0x61, 0x33, 0x30, 0x38, 0x34, 0x39, 0x35, 0x65, 0x36, 0x64, 0x36, 0x61, 0x31, 0x63, 0x37, 0x31, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x65, 0x63, 0x38, 0x31, 0x32, 0x32, 0x38, 0x34, 0x30, 0x32, 0x36, 0x65, 0x34, 0x30, 0x39, 0x62, 0x63, 0x30, 0x36, 0x36, 0x64, 0x66, 0x65, 0x62, 0x66, 0x39, 0x64, 0x35, 0x61, 0x34, 0x61, 0x32, 0x62, 0x66, 0x38, 0x30, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x34, 0x36, 0x33, 0x63, 0x32, 0x36, 0x37, 0x39, 0x66, 0x62, 0x32, 0x37, 0x39, 0x31, 0x36, 0x34, 0x65, 0x32, 0x30, 0x63, 0x33, 0x64, 0x32, 0x36, 0x39, 0x31, 0x33, 0x35, 0x38, 0x37, 0x37, 0x33, 0x61, 0x30, 0x61, 0x64, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x61, 0x64, 0x66, 0x39, 0x38, 0x62, 0x36, 0x31, 0x65, 0x35, 0x63, 0x38, 0x39, 0x36, 0x65, 0x37, 0x64, 0x31, 0x30, 0x30, 0x61, 0x33, 0x33, 0x39, 0x31, 0x64, 0x33, 0x32, 0x35, 0x30, 0x32, 0x32, 0x35, 0x64, 0x36, 0x31, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x31, 0x33, 0x37, 0x66, 0x63, 0x31, 0x62, 0x32, 0x65, 0x63, 0x37, 0x63, 0x63, 0x37, 0x31, 0x30, 0x33, 0x61, 0x66, 0x39, 0x32, 0x31, 0x38, 0x39, 0x39, 0x62, 0x34, 0x61, 0x33, 0x39, 0x65, 0x31, 0x64, 0x39, 0x35, 0x39, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x61, 0x32, 0x62, 0x34, 0x33, 0x61, 0x37, 0x34, 0x33, 0x33, 0x64, 0x64, 0x31, 0x35, 0x30, 0x62, 0x62, 0x38, 0x32, 0x32, 0x32, 0x37, 0x65, 0x64, 0x35, 0x31, 0x39, 0x63, 0x64, 0x36, 0x62, 0x31, 0x34, 0x32, 0x64, 0x33, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x66, 0x33, 0x39, 0x62, 0x64, 0x33, 0x35, 0x64, 0x64, 0x39, 0x63, 0x65, 0x63, 0x33, 0x33, 0x37, 0x62, 0x39, 0x36, 0x66, 0x34, 0x37, 0x63, 0x36, 0x37, 0x37, 0x38, 0x31, 0x38, 0x31, 0x36, 0x30, 0x64, 0x66, 0x33, 0x37, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x38, 0x37, 0x62, 0x34, 0x34, 0x61, 0x32, 0x63, 0x61, 0x37, 0x39, 0x65, 0x34, 0x62, 0x63, 0x31, 0x64, 0x64, 0x38, 0x62, 0x66, 0x64, 0x64, 0x34, 0x33, 0x61, 0x32, 0x30, 0x37, 0x31, 0x35, 0x30, 0x66, 0x32, 0x65, 0x37, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x34, 0x38, 0x35, 0x36, 0x31, 0x32, 0x64, 0x30, 0x33, 0x34, 0x34, 0x36, 0x65, 0x63, 0x34, 0x63, 0x30, 0x35, 0x65, 0x35, 0x32, 0x34, 0x34, 0x65, 0x35, 0x36, 0x33, 0x66, 0x31, 0x63, 0x62, 0x61, 0x65, 0x30, 0x66, 0x31, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x32, 0x36, 0x32, 0x33, 0x65, 0x36, 0x32, 0x39, 0x64, 0x66, 0x39, 0x33, 0x30, 0x39, 0x36, 0x37, 0x30, 0x34, 0x62, 0x31, 0x36, 0x30, 0x38, 0x34, 0x62, 0x65, 0x32, 0x63, 0x64, 0x38, 0x39, 0x64, 0x35, 0x36, 0x32, 0x64, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x32, 0x66, 0x33, 0x38, 0x31, 0x34, 0x39, 0x31, 0x37, 0x39, 0x37, 0x63, 0x63, 0x35, 0x63, 0x30, 0x64, 0x34, 0x38, 0x32, 0x39, 0x36, 0x63, 0x31, 0x34, 0x66, 0x64, 0x30, 0x63, 0x64, 0x30, 0x30, 0x63, 0x64, 0x66, 0x61, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x37, 0x30, 0x63, 0x63, 0x33, 0x36, 0x35, 0x39, 0x34, 0x35, 0x38, 0x36, 0x38, 0x32, 0x31, 0x38, 0x32, 0x31, 0x63, 0x35, 0x63, 0x39, 0x39, 0x36, 0x62, 0x36, 0x65, 0x64, 0x63, 0x38, 0x33, 0x62, 0x36, 0x64, 0x35, 0x61, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x30, 0x35, 0x33, 0x37, 0x32, 0x64, 0x39, 0x33, 0x61, 0x39, 0x30, 0x31, 0x30, 0x39, 0x38, 0x38, 0x30, 0x31, 0x38, 0x66, 0x39, 0x66, 0x33, 0x31, 0x35, 0x64, 0x30, 0x33, 0x32, 0x65, 0x64, 0x31, 0x38, 0x38, 0x30, 0x66, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x36, 0x33, 0x32, 0x33, 0x38, 0x38, 0x62, 0x32, 0x37, 0x36, 0x35, 0x65, 0x65, 0x34, 0x34, 0x35, 0x32, 0x62, 0x35, 0x30, 0x31, 0x36, 0x31, 0x64, 0x31, 0x66, 0x66, 0x66, 0x64, 0x39, 0x31, 0x61, 0x62, 0x38, 0x31, 0x66, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x34, 0x61, 0x33, 0x64, 0x37, 0x37, 0x31, 0x61, 0x33, 0x64, 0x37, 0x30, 0x39, 0x37, 0x39, 0x36, 0x66, 0x62, 0x63, 0x34, 0x64, 0x35, 0x66, 0x34, 0x38, 0x66, 0x63, 0x65, 0x32, 0x66, 0x65, 0x33, 0x38, 0x63, 0x37, 0x39, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x30, 0x61, 0x35, 0x32, 0x35, 0x38, 0x30, 0x37, 0x32, 0x38, 0x35, 0x32, 0x30, 0x64, 0x66, 0x37, 0x35, 0x34, 0x36, 0x62, 0x63, 0x31, 0x65, 0x32, 0x38, 0x33, 0x32, 0x39, 0x31, 0x37, 0x38, 0x38, 0x64, 0x62, 0x61, 0x65, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x62, 0x35, 0x33, 0x61, 0x31, 0x31, 0x62, 0x63, 0x63, 0x36, 0x33, 0x64, 0x64, 0x66, 0x61, 0x61, 0x34, 0x30, 0x61, 0x30, 0x32, 0x62, 0x39, 0x65, 0x31, 0x38, 0x36, 0x34, 0x39, 0x36, 0x63, 0x64, 0x62, 0x62, 0x38, 0x61, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x38, 0x32, 0x65, 0x36, 0x39, 0x39, 0x33, 0x66, 0x62, 0x65, 0x37, 0x61, 0x39, 0x31, 0x32, 0x65, 0x61, 0x30, 0x34, 0x37, 0x31, 0x35, 0x33, 0x66, 0x66, 0x64, 0x39, 0x32, 0x37, 0x34, 0x32, 0x37, 0x30, 0x65, 0x32, 0x38, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x39, 0x39, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x39, 0x31, 0x65, 0x39, 0x63, 0x37, 0x39, 0x39, 0x30, 0x64, 0x35, 0x35, 0x32, 0x64, 0x64, 0x31, 0x61, 0x65, 0x31, 0x36, 0x63, 0x65, 0x62, 0x63, 0x33, 0x66, 0x63, 0x61, 0x33, 0x34, 0x32, 0x63, 0x62, 0x61, 0x66, 0x31, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x34, 0x37, 0x66, 0x64, 0x62, 0x34, 0x61, 0x65, 0x31, 0x31, 0x39, 0x35, 0x33, 0x65, 0x30, 0x31, 0x32, 0x39, 0x32, 0x62, 0x37, 0x38, 0x30, 0x37, 0x66, 0x61, 0x39, 0x32, 0x32, 0x33, 0x64, 0x30, 0x65, 0x34, 0x36, 0x30, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x65, 0x64, 0x31, 0x31, 0x36, 0x31, 0x32, 0x66, 0x62, 0x35, 0x63, 0x36, 0x64, 0x61, 0x39, 0x39, 0x64, 0x31, 0x65, 0x33, 0x30, 0x65, 0x33, 0x32, 0x30, 0x62, 0x63, 0x30, 0x39, 0x39, 0x35, 0x34, 0x36, 0x36, 0x31, 0x34, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x33, 0x62, 0x34, 0x66, 0x66, 0x39, 0x39, 0x65, 0x62, 0x38, 0x38, 0x66, 0x64, 0x38, 0x39, 0x62, 0x30, 0x62, 0x36, 0x64, 0x35, 0x37, 0x61, 0x39, 0x62, 0x63, 0x33, 0x33, 0x38, 0x65, 0x38, 0x38, 0x36, 0x66, 0x61, 0x30, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x63, 0x37, 0x35, 0x31, 0x37, 0x38, 0x36, 0x39, 0x33, 0x39, 0x62, 0x62, 0x61, 0x30, 0x64, 0x36, 0x37, 0x31, 0x61, 0x36, 0x37, 0x37, 0x61, 0x31, 0x35, 0x38, 0x63, 0x36, 0x61, 0x62, 0x65, 0x37, 0x32, 0x36, 0x35, 0x65, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x38, 0x31, 0x62, 0x62, 0x62, 0x65, 0x36, 0x39, 0x37, 0x32, 0x32, 0x64, 0x38, 0x31, 0x65, 0x66, 0x65, 0x63, 0x61, 0x61, 0x34, 0x38, 0x64, 0x31, 0x39, 0x35, 0x32, 0x61, 0x31, 0x30, 0x61, 0x32, 0x62, 0x66, 0x61, 0x63, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x39, 0x36, 0x63, 0x34, 0x63, 0x64, 0x33, 0x38, 0x31, 0x35, 0x36, 0x32, 0x34, 0x30, 0x31, 0x61, 0x61, 0x33, 0x32, 0x61, 0x38, 0x36, 0x65, 0x36, 0x35, 0x62, 0x39, 0x64, 0x35, 0x32, 0x66, 0x61, 0x38, 0x61, 0x65, 0x65, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x33, 0x64, 0x62, 0x61, 0x33, 0x36, 0x66, 0x37, 0x65, 0x39, 0x34, 0x66, 0x34, 0x30, 0x65, 0x61, 0x36, 0x61, 0x65, 0x61, 0x30, 0x64, 0x37, 0x39, 0x62, 0x38, 0x66, 0x35, 0x32, 0x31, 0x64, 0x65, 0x35, 0x35, 0x30, 0x37, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x63, 0x32, 0x39, 0x30, 0x38, 0x62, 0x30, 0x66, 0x33, 0x39, 0x38, 0x63, 0x30, 0x64, 0x66, 0x35, 0x62, 0x61, 0x63, 0x32, 0x63, 0x62, 0x31, 0x33, 0x63, 0x61, 0x37, 0x33, 0x31, 0x34, 0x66, 0x62, 0x61, 0x38, 0x66, 0x61, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x31, 0x34, 0x61, 0x36, 0x38, 0x30, 0x61, 0x35, 0x61, 0x65, 0x63, 0x35, 0x32, 0x32, 0x36, 0x64, 0x34, 0x62, 0x61, 0x61, 0x65, 0x63, 0x32, 0x65, 0x35, 0x35, 0x35, 0x32, 0x62, 0x34, 0x34, 0x64, 0x64, 0x37, 0x63, 0x38, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x31, 0x31, 0x37, 0x30, 0x66, 0x35, 0x38, 0x31, 0x64, 0x65, 0x38, 0x30, 0x65, 0x35, 0x38, 0x62, 0x32, 0x61, 0x30, 0x34, 0x35, 0x63, 0x38, 0x66, 0x37, 0x63, 0x31, 0x34, 0x39, 0x33, 0x62, 0x30, 0x30, 0x31, 0x62, 0x37, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x36, 0x35, 0x65, 0x34, 0x37, 0x33, 0x39, 0x36, 0x63, 0x37, 0x64, 0x62, 0x39, 0x37, 0x65, 0x62, 0x32, 0x61, 0x30, 0x33, 0x64, 0x39, 0x30, 0x38, 0x36, 0x33, 0x64, 0x35, 0x64, 0x34, 0x62, 0x61, 0x33, 0x31, 0x39, 0x61, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x34, 0x62, 0x65, 0x30, 0x34, 0x61, 0x30, 0x35, 0x32, 0x64, 0x37, 0x61, 0x63, 0x63, 0x62, 0x33, 0x64, 0x63, 0x63, 0x65, 0x39, 0x30, 0x33, 0x31, 0x39, 0x64, 0x62, 0x61, 0x34, 0x30, 0x32, 0x30, 0x61, 0x62, 0x32, 0x63, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x35, 0x34, 0x37, 0x39, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x30, 0x36, 0x31, 0x39, 0x64, 0x39, 0x64, 0x38, 0x61, 0x61, 0x33, 0x31, 0x33, 0x61, 0x39, 0x35, 0x33, 0x31, 0x61, 0x63, 0x37, 0x64, 0x62, 0x65, 0x30, 0x34, 0x63, 0x61, 0x30, 0x64, 0x36, 0x61, 0x35, 0x61, 0x64, 0x31, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x31, 0x34, 0x34, 0x32, 0x61, 0x62, 0x30, 0x35, 0x33, 0x34, 0x30, 0x61, 0x64, 0x65, 0x36, 0x38, 0x63, 0x39, 0x31, 0x35, 0x66, 0x33, 0x63, 0x33, 0x33, 0x39, 0x39, 0x62, 0x39, 0x39, 0x35, 0x35, 0x66, 0x33, 0x66, 0x37, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x35, 0x39, 0x33, 0x34, 0x64, 0x61, 0x38, 0x65, 0x37, 0x34, 0x34, 0x65, 0x61, 0x61, 0x33, 0x64, 0x65, 0x33, 0x34, 0x64, 0x62, 0x62, 0x63, 0x30, 0x38, 0x39, 0x34, 0x63, 0x34, 0x65, 0x64, 0x61, 0x30, 0x62, 0x36, 0x31, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x33, 0x38, 0x37, 0x34, 0x30, 0x61, 0x65, 0x32, 0x38, 0x64, 0x36, 0x36, 0x62, 0x61, 0x39, 0x33, 0x62, 0x30, 0x62, 0x65, 0x30, 0x38, 0x34, 0x38, 0x32, 0x62, 0x33, 0x32, 0x30, 0x35, 0x61, 0x30, 0x66, 0x37, 0x61, 0x30, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x39, 0x32, 0x34, 0x61, 0x39, 0x38, 0x31, 0x36, 0x62, 0x62, 0x37, 0x64, 0x64, 0x66, 0x33, 0x66, 0x65, 0x63, 0x31, 0x38, 0x34, 0x34, 0x38, 0x32, 0x38, 0x65, 0x39, 0x61, 0x64, 0x37, 0x64, 0x30, 0x36, 0x62, 0x66, 0x34, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x34, 0x37, 0x38, 0x32, 0x35, 0x62, 0x64, 0x65, 0x65, 0x38, 0x32, 0x34, 0x30, 0x65, 0x32, 0x38, 0x30, 0x34, 0x32, 0x63, 0x38, 0x33, 0x63, 0x61, 0x64, 0x36, 0x34, 0x32, 0x66, 0x32, 0x38, 0x36, 0x61, 0x33, 0x62, 0x64, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x31, 0x38, 0x61, 0x61, 0x61, 0x64, 0x35, 0x39, 0x62, 0x66, 0x33, 0x39, 0x35, 0x63, 0x62, 0x61, 0x32, 0x62, 0x32, 0x33, 0x65, 0x30, 0x39, 0x62, 0x30, 0x32, 0x66, 0x65, 0x30, 0x63, 0x38, 0x39, 0x38, 0x31, 0x36, 0x32, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x38, 0x39, 0x66, 0x35, 0x66, 0x64, 0x63, 0x61, 0x33, 0x64, 0x31, 0x35, 0x35, 0x34, 0x30, 0x39, 0x62, 0x36, 0x33, 0x38, 0x62, 0x39, 0x38, 0x61, 0x37, 0x34, 0x32, 0x65, 0x35, 0x35, 0x65, 0x62, 0x34, 0x36, 0x35, 0x32, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x37, 0x30, 0x34, 0x34, 0x65, 0x32, 0x33, 0x38, 0x33, 0x66, 0x38, 0x37, 0x30, 0x38, 0x33, 0x30, 0x35, 0x62, 0x34, 0x39, 0x35, 0x62, 0x64, 0x31, 0x31, 0x37, 0x36, 0x62, 0x39, 0x32, 0x65, 0x37, 0x65, 0x66, 0x30, 0x34, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x32, 0x65, 0x38, 0x30, 0x61, 0x35, 0x35, 0x34, 0x38, 0x37, 0x35, 0x61, 0x35, 0x36, 0x37, 0x39, 0x39, 0x66, 0x61, 0x30, 0x61, 0x39, 0x37, 0x66, 0x35, 0x35, 0x31, 0x30, 0x65, 0x37, 0x39, 0x35, 0x39, 0x37, 0x34, 0x63, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x62, 0x33, 0x62, 0x63, 0x63, 0x33, 0x31, 0x39, 0x36, 0x61, 0x38, 0x63, 0x33, 0x63, 0x62, 0x38, 0x33, 0x34, 0x63, 0x65, 0x63, 0x39, 0x34, 0x63, 0x33, 0x34, 0x66, 0x65, 0x64, 0x33, 0x35, 0x62, 0x33, 0x65, 0x31, 0x30, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x33, 0x35, 0x37, 0x39, 0x34, 0x62, 0x31, 0x34, 0x39, 0x61, 0x31, 0x38, 0x65, 0x31, 0x34, 0x37, 0x64, 0x31, 0x36, 0x65, 0x36, 0x32, 0x31, 0x61, 0x36, 0x39, 0x33, 0x31, 0x66, 0x30, 0x61, 0x34, 0x30, 0x61, 0x39, 0x36, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x39, 0x34, 0x36, 0x31, 0x35, 0x64, 0x62, 0x37, 0x35, 0x30, 0x36, 0x35, 0x36, 0x61, 0x63, 0x33, 0x38, 0x63, 0x37, 0x65, 0x31, 0x63, 0x66, 0x32, 0x39, 0x61, 0x39, 0x64, 0x31, 0x33, 0x36, 0x37, 0x37, 0x66, 0x34, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x62, 0x65, 0x34, 0x32, 0x35, 0x65, 0x36, 0x37, 0x30, 0x64, 0x33, 0x39, 0x30, 0x39, 0x34, 0x65, 0x32, 0x30, 0x66, 0x62, 0x35, 0x36, 0x34, 0x33, 0x61, 0x39, 0x64, 0x38, 0x31, 0x38, 0x65, 0x65, 0x64, 0x32, 0x33, 0x36, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x31, 0x65, 0x30, 0x65, 0x66, 0x62, 0x30, 0x34, 0x61, 0x63, 0x34, 0x65, 0x33, 0x66, 0x66, 0x32, 0x65, 0x36, 0x35, 0x35, 0x30, 0x65, 0x34, 0x39, 0x38, 0x32, 0x39, 0x35, 0x62, 0x66, 0x63, 0x64, 0x35, 0x36, 0x66, 0x66, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x36, 0x35, 0x35, 0x31, 0x31, 0x63, 0x61, 0x64, 0x61, 0x32, 0x35, 0x39, 0x32, 0x36, 0x30, 0x63, 0x31, 0x64, 0x64, 0x63, 0x34, 0x31, 0x39, 0x37, 0x34, 0x65, 0x63, 0x61, 0x65, 0x63, 0x64, 0x33, 0x32, 0x64, 0x36, 0x33, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x66, 0x63, 0x35, 0x66, 0x65, 0x30, 0x36, 0x66, 0x33, 0x33, 0x66, 0x35, 0x61, 0x34, 0x38, 0x30, 0x62, 0x37, 0x35, 0x61, 0x61, 0x39, 0x34, 0x65, 0x62, 0x38, 0x35, 0x35, 0x36, 0x64, 0x39, 0x39, 0x37, 0x61, 0x31, 0x36, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x64, 0x66, 0x32, 0x33, 0x62, 0x65, 0x62, 0x64, 0x63, 0x36, 0x35, 0x65, 0x62, 0x37, 0x35, 0x66, 0x65, 0x62, 0x39, 0x63, 0x62, 0x32, 0x66, 0x61, 0x64, 0x31, 0x63, 0x30, 0x37, 0x33, 0x36, 0x39, 0x32, 0x62, 0x32, 0x62, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x37, 0x65, 0x66, 0x38, 0x30, 0x62, 0x35, 0x64, 0x36, 0x30, 0x62, 0x36, 0x66, 0x62, 0x66, 0x66, 0x63, 0x35, 0x31, 0x66, 0x33, 0x61, 0x36, 0x34, 0x62, 0x38, 0x63, 0x37, 0x32, 0x30, 0x33, 0x36, 0x61, 0x35, 0x61, 0x62, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x37, 0x33, 0x65, 0x38, 0x34, 0x31, 0x66, 0x61, 0x30, 0x38, 0x31, 0x37, 0x34, 0x61, 0x32, 0x30, 0x38, 0x62, 0x30, 0x36, 0x30, 0x63, 0x63, 0x62, 0x37, 0x62, 0x34, 0x63, 0x30, 0x64, 0x37, 0x36, 0x39, 0x37, 0x31, 0x32, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x31, 0x36, 0x31, 0x30, 0x62, 0x31, 0x37, 0x38, 0x64, 0x35, 0x36, 0x31, 0x37, 0x64, 0x66, 0x61, 0x62, 0x39, 0x33, 0x34, 0x64, 0x32, 0x39, 0x33, 0x66, 0x35, 0x31, 0x32, 0x61, 0x39, 0x33, 0x65, 0x35, 0x63, 0x31, 0x30, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x39, 0x31, 0x36, 0x31, 0x34, 0x63, 0x35, 0x62, 0x61, 0x61, 0x34, 0x37, 0x64, 0x64, 0x36, 0x63, 0x39, 0x36, 0x38, 0x37, 0x34, 0x36, 0x34, 0x35, 0x66, 0x39, 0x37, 0x61, 0x64, 0x64, 0x32, 0x63, 0x33, 0x64, 0x38, 0x33, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x33, 0x34, 0x38, 0x30, 0x62, 0x66, 0x30, 0x38, 0x36, 0x35, 0x30, 0x37, 0x34, 0x61, 0x37, 0x32, 0x63, 0x37, 0x37, 0x35, 0x39, 0x65, 0x65, 0x35, 0x31, 0x33, 0x37, 0x62, 0x34, 0x64, 0x37, 0x30, 0x63, 0x35, 0x31, 0x63, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x34, 0x30, 0x65, 0x30, 0x31, 0x32, 0x66, 0x36, 0x30, 0x34, 0x32, 0x35, 0x61, 0x33, 0x34, 0x30, 0x64, 0x38, 0x32, 0x64, 0x30, 0x33, 0x61, 0x31, 0x63, 0x37, 0x35, 0x37, 0x62, 0x66, 0x61, 0x62, 0x63, 0x37, 0x30, 0x36, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x37, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x36, 0x34, 0x38, 0x62, 0x65, 0x64, 0x30, 0x31, 0x66, 0x33, 0x63, 0x64, 0x33, 0x32, 0x34, 0x39, 0x30, 0x38, 0x34, 0x65, 0x36, 0x33, 0x35, 0x64, 0x31, 0x34, 0x64, 0x61, 0x61, 0x39, 0x65, 0x37, 0x65, 0x63, 0x33, 0x63, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x66, 0x66, 0x36, 0x32, 0x32, 0x32, 0x32, 0x64, 0x38, 0x30, 0x63, 0x30, 0x31, 0x33, 0x63, 0x65, 0x63, 0x31, 0x61, 0x30, 0x65, 0x38, 0x38, 0x35, 0x30, 0x65, 0x64, 0x34, 0x64, 0x33, 0x35, 0x34, 0x64, 0x61, 0x63, 0x31, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x30, 0x64, 0x33, 0x36, 0x31, 0x39, 0x37, 0x30, 0x32, 0x66, 0x61, 0x35, 0x38, 0x33, 0x38, 0x63, 0x34, 0x38, 0x33, 0x39, 0x31, 0x38, 0x35, 0x39, 0x61, 0x38, 0x33, 0x39, 0x66, 0x62, 0x39, 0x63, 0x65, 0x37, 0x31, 0x36, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x30, 0x66, 0x35, 0x65, 0x30, 0x37, 0x32, 0x30, 0x34, 0x33, 0x63, 0x39, 0x65, 0x65, 0x37, 0x34, 0x30, 0x32, 0x34, 0x32, 0x31, 0x39, 0x37, 0x65, 0x37, 0x38, 0x63, 0x63, 0x34, 0x62, 0x39, 0x38, 0x63, 0x64, 0x66, 0x39, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x30, 0x61, 0x61, 0x32, 0x62, 0x62, 0x63, 0x65, 0x30, 0x63, 0x37, 0x32, 0x62, 0x34, 0x64, 0x30, 0x64, 0x66, 0x66, 0x66, 0x63, 0x63, 0x34, 0x32, 0x37, 0x31, 0x35, 0x62, 0x32, 0x62, 0x35, 0x34, 0x62, 0x30, 0x31, 0x62, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x65, 0x65, 0x64, 0x35, 0x30, 0x34, 0x37, 0x31, 0x61, 0x31, 0x61, 0x32, 0x62, 0x66, 0x35, 0x33, 0x65, 0x65, 0x33, 0x30, 0x62, 0x31, 0x32, 0x33, 0x32, 0x65, 0x36, 0x65, 0x39, 0x64, 0x38, 0x30, 0x65, 0x66, 0x38, 0x36, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x32, 0x38, 0x30, 0x38, 0x62, 0x39, 0x35, 0x31, 0x65, 0x64, 0x39, 0x65, 0x38, 0x37, 0x32, 0x64, 0x37, 0x62, 0x33, 0x32, 0x37, 0x39, 0x30, 0x66, 0x63, 0x63, 0x35, 0x39, 0x39, 0x34, 0x61, 0x65, 0x34, 0x31, 0x66, 0x66, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x30, 0x36, 0x63, 0x38, 0x39, 0x64, 0x35, 0x39, 0x38, 0x30, 0x37, 0x66, 0x61, 0x36, 0x30, 0x62, 0x63, 0x36, 0x30, 0x31, 0x33, 0x36, 0x66, 0x63, 0x66, 0x38, 0x31, 0x34, 0x63, 0x62, 0x61, 0x66, 0x32, 0x35, 0x34, 0x33, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x34, 0x62, 0x36, 0x30, 0x33, 0x63, 0x35, 0x64, 0x64, 0x34, 0x35, 0x37, 0x30, 0x63, 0x33, 0x34, 0x36, 0x36, 0x39, 0x35, 0x31, 0x35, 0x66, 0x64, 0x63, 0x63, 0x36, 0x36, 0x35, 0x38, 0x39, 0x30, 0x38, 0x34, 0x30, 0x63, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x65, 0x35, 0x63, 0x31, 0x33, 0x35, 0x64, 0x30, 0x63, 0x34, 0x63, 0x33, 0x33, 0x30, 0x33, 0x39, 0x33, 0x34, 0x37, 0x31, 0x31, 0x39, 0x39, 0x33, 0x64, 0x30, 0x64, 0x31, 0x36, 0x66, 0x66, 0x39, 0x65, 0x37, 0x62, 0x61, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x31, 0x33, 0x36, 0x31, 0x35, 0x35, 0x39, 0x66, 0x65, 0x65, 0x66, 0x38, 0x30, 0x65, 0x66, 0x31, 0x33, 0x37, 0x33, 0x30, 0x32, 0x31, 0x35, 0x33, 0x62, 0x64, 0x39, 0x65, 0x64, 0x32, 0x66, 0x32, 0x35, 0x64, 0x62, 0x33, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x36, 0x33, 0x31, 0x32, 0x32, 0x64, 0x65, 0x37, 0x30, 0x33, 0x37, 0x64, 0x61, 0x34, 0x39, 0x37, 0x31, 0x35, 0x33, 0x31, 0x66, 0x61, 0x65, 0x39, 0x61, 0x66, 0x38, 0x35, 0x38, 0x36, 0x37, 0x38, 0x38, 0x36, 0x63, 0x36, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x37, 0x65, 0x34, 0x65, 0x32, 0x36, 0x38, 0x38, 0x62, 0x31, 0x66, 0x64, 0x36, 0x36, 0x64, 0x38, 0x32, 0x31, 0x35, 0x32, 0x39, 0x65, 0x34, 0x36, 0x65, 0x64, 0x34, 0x66, 0x34, 0x32, 0x66, 0x38, 0x62, 0x33, 0x64, 0x62, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x37, 0x64, 0x62, 0x31, 0x63, 0x61, 0x64, 0x66, 0x31, 0x62, 0x37, 0x37, 0x31, 0x63, 0x62, 0x64, 0x37, 0x34, 0x37, 0x35, 0x65, 0x31, 0x62, 0x32, 0x37, 0x32, 0x36, 0x39, 0x30, 0x66, 0x35, 0x35, 0x38, 0x63, 0x38, 0x35, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x36, 0x35, 0x39, 0x64, 0x38, 0x66, 0x38, 0x63, 0x39, 0x61, 0x32, 0x66, 0x64, 0x34, 0x34, 0x66, 0x36, 0x38, 0x64, 0x61, 0x61, 0x35, 0x35, 0x64, 0x32, 0x33, 0x61, 0x36, 0x30, 0x38, 0x66, 0x62, 0x65, 0x35, 0x30, 0x30, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x61, 0x36, 0x34, 0x62, 0x31, 0x31, 0x37, 0x36, 0x37, 0x32, 0x34, 0x66, 0x35, 0x34, 0x30, 0x39, 0x65, 0x31, 0x34, 0x31, 0x34, 0x61, 0x33, 0x35, 0x32, 0x33, 0x36, 0x36, 0x31, 0x62, 0x61, 0x65, 0x65, 0x37, 0x34, 0x62, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x31, 0x34, 0x34, 0x32, 0x32, 0x64, 0x36, 0x66, 0x30, 0x61, 0x65, 0x35, 0x61, 0x37, 0x35, 0x38, 0x31, 0x39, 0x34, 0x65, 0x64, 0x31, 0x35, 0x37, 0x38, 0x30, 0x63, 0x38, 0x33, 0x38, 0x64, 0x36, 0x37, 0x66, 0x31, 0x65, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x35, 0x30, 0x33, 0x38, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x61, 0x30, 0x65, 0x36, 0x35, 0x32, 0x30, 0x34, 0x35, 0x34, 0x31, 0x66, 0x63, 0x61, 0x39, 0x62, 0x32, 0x66, 0x62, 0x32, 0x38, 0x32, 0x63, 0x64, 0x39, 0x35, 0x31, 0x33, 0x38, 0x66, 0x61, 0x65, 0x31, 0x36, 0x66, 0x38, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x31, 0x30, 0x37, 0x62, 0x33, 0x35, 0x33, 0x37, 0x32, 0x36, 0x63, 0x33, 0x61, 0x32, 0x62, 0x34, 0x36, 0x35, 0x36, 0x36, 0x65, 0x61, 0x61, 0x37, 0x64, 0x39, 0x66, 0x38, 0x30, 0x62, 0x35, 0x64, 0x32, 0x31, 0x64, 0x62, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x63, 0x61, 0x66, 0x62, 0x37, 0x32, 0x37, 0x66, 0x62, 0x35, 0x63, 0x36, 0x62, 0x37, 0x30, 0x62, 0x62, 0x32, 0x37, 0x35, 0x33, 0x33, 0x62, 0x38, 0x61, 0x39, 0x63, 0x63, 0x63, 0x39, 0x65, 0x66, 0x36, 0x38, 0x38, 0x38, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x34, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x66, 0x33, 0x66, 0x36, 0x30, 0x31, 0x66, 0x36, 0x30, 0x35, 0x34, 0x34, 0x31, 0x31, 0x34, 0x30, 0x35, 0x38, 0x36, 0x63, 0x65, 0x30, 0x36, 0x35, 0x36, 0x66, 0x61, 0x32, 0x34, 0x61, 0x61, 0x35, 0x62, 0x31, 0x64, 0x39, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x66, 0x63, 0x62, 0x65, 0x37, 0x63, 0x34, 0x31, 0x39, 0x33, 0x66, 0x66, 0x63, 0x62, 0x30, 0x38, 0x31, 0x34, 0x33, 0x37, 0x37, 0x39, 0x63, 0x39, 0x62, 0x65, 0x63, 0x38, 0x33, 0x66, 0x65, 0x37, 0x66, 0x64, 0x61, 0x39, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x65, 0x62, 0x63, 0x36, 0x33, 0x66, 0x64, 0x61, 0x36, 0x36, 0x36, 0x30, 0x61, 0x34, 0x36, 0x35, 0x30, 0x34, 0x35, 0x65, 0x32, 0x33, 0x35, 0x66, 0x62, 0x65, 0x36, 0x65, 0x35, 0x63, 0x66, 0x31, 0x39, 0x35, 0x37, 0x33, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x62, 0x61, 0x66, 0x36, 0x34, 0x33, 0x34, 0x64, 0x34, 0x30, 0x64, 0x36, 0x33, 0x35, 0x35, 0x62, 0x31, 0x65, 0x38, 0x30, 0x65, 0x34, 0x30, 0x63, 0x63, 0x34, 0x61, 0x62, 0x39, 0x63, 0x36, 0x38, 0x64, 0x39, 0x36, 0x31, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x32, 0x32, 0x32, 0x35, 0x61, 0x31, 0x62, 0x62, 0x35, 0x39, 0x62, 0x63, 0x38, 0x38, 0x61, 0x32, 0x33, 0x31, 0x36, 0x36, 0x37, 0x34, 0x64, 0x33, 0x33, 0x33, 0x62, 0x39, 0x62, 0x30, 0x61, 0x66, 0x63, 0x61, 0x36, 0x36, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x63, 0x33, 0x64, 0x61, 0x31, 0x33, 0x62, 0x32, 0x62, 0x34, 0x61, 0x66, 0x64, 0x34, 0x34, 0x66, 0x35, 0x64, 0x30, 0x64, 0x33, 0x31, 0x38, 0x39, 0x66, 0x34, 0x34, 0x34, 0x64, 0x34, 0x64, 0x64, 0x66, 0x39, 0x31, 0x62, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x61, 0x38, 0x65, 0x30, 0x31, 0x31, 0x37, 0x66, 0x63, 0x30, 0x62, 0x36, 0x61, 0x33, 0x65, 0x35, 0x36, 0x62, 0x32, 0x34, 0x61, 0x33, 0x61, 0x35, 0x38, 0x66, 0x65, 0x36, 0x63, 0x65, 0x66, 0x34, 0x34, 0x32, 0x66, 0x66, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x31, 0x34, 0x36, 0x39, 0x31, 0x33, 0x35, 0x36, 0x33, 0x61, 0x61, 0x37, 0x34, 0x35, 0x65, 0x32, 0x35, 0x38, 0x38, 0x34, 0x33, 0x30, 0x64, 0x39, 0x33, 0x34, 0x38, 0x65, 0x38, 0x36, 0x65, 0x61, 0x37, 0x63, 0x33, 0x35, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x35, 0x61, 0x66, 0x65, 0x34, 0x30, 0x66, 0x31, 0x38, 0x66, 0x66, 0x63, 0x34, 0x38, 0x64, 0x33, 0x61, 0x31, 0x61, 0x65, 0x63, 0x34, 0x31, 0x66, 0x63, 0x32, 0x39, 0x64, 0x65, 0x31, 0x37, 0x39, 0x66, 0x34, 0x64, 0x32, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x38, 0x31, 0x30, 0x31, 0x31, 0x34, 0x62, 0x32, 0x30, 0x32, 0x35, 0x64, 0x62, 0x39, 0x66, 0x62, 0x62, 0x35, 0x30, 0x30, 0x39, 0x39, 0x61, 0x36, 0x65, 0x30, 0x63, 0x62, 0x39, 0x65, 0x32, 0x65, 0x66, 0x61, 0x36, 0x62, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x65, 0x65, 0x39, 0x30, 0x61, 0x32, 0x38, 0x66, 0x31, 0x39, 0x32, 0x64, 0x36, 0x37, 0x36, 0x61, 0x38, 0x37, 0x37, 0x33, 0x32, 0x33, 0x32, 0x62, 0x35, 0x36, 0x66, 0x31, 0x38, 0x66, 0x32, 0x33, 0x39, 0x65, 0x32, 0x66, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x38, 0x37, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x36, 0x37, 0x36, 0x65, 0x39, 0x32, 0x64, 0x31, 0x38, 0x62, 0x30, 0x30, 0x30, 0x35, 0x30, 0x39, 0x63, 0x36, 0x31, 0x64, 0x65, 0x35, 0x34, 0x30, 0x65, 0x36, 0x63, 0x35, 0x64, 0x64, 0x62, 0x36, 0x37, 0x36, 0x64, 0x35, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x66, 0x63, 0x36, 0x35, 0x39, 0x63, 0x39, 0x63, 0x36, 0x30, 0x31, 0x65, 0x61, 0x34, 0x32, 0x61, 0x36, 0x62, 0x32, 0x31, 0x62, 0x38, 0x66, 0x31, 0x37, 0x30, 0x38, 0x34, 0x65, 0x63, 0x38, 0x37, 0x64, 0x37, 0x30, 0x32, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x35, 0x64, 0x36, 0x65, 0x38, 0x32, 0x31, 0x63, 0x36, 0x65, 0x65, 0x66, 0x39, 0x36, 0x38, 0x31, 0x30, 0x63, 0x38, 0x33, 0x63, 0x34, 0x39, 0x31, 0x34, 0x36, 0x38, 0x35, 0x36, 0x30, 0x65, 0x66, 0x37, 0x30, 0x62, 0x66, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x37, 0x38, 0x37, 0x36, 0x36, 0x38, 0x63, 0x32, 0x63, 0x35, 0x31, 0x37, 0x35, 0x62, 0x30, 0x31, 0x61, 0x38, 0x65, 0x65, 0x31, 0x61, 0x63, 0x33, 0x65, 0x63, 0x63, 0x39, 0x63, 0x38, 0x62, 0x32, 0x61, 0x62, 0x61, 0x39, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x62, 0x33, 0x33, 0x36, 0x66, 0x35, 0x62, 0x61, 0x35, 0x65, 0x64, 0x62, 0x37, 0x62, 0x31, 0x63, 0x63, 0x63, 0x37, 0x65, 0x62, 0x31, 0x61, 0x30, 0x64, 0x39, 0x38, 0x34, 0x63, 0x31, 0x32, 0x33, 0x31, 0x64, 0x30, 0x65, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x62, 0x62, 0x38, 0x61, 0x64, 0x66, 0x63, 0x36, 0x30, 0x34, 0x66, 0x34, 0x38, 0x64, 0x35, 0x39, 0x38, 0x34, 0x38, 0x31, 0x31, 0x64, 0x37, 0x66, 0x31, 0x64, 0x35, 0x32, 0x66, 0x65, 0x66, 0x36, 0x37, 0x35, 0x38, 0x32, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x30, 0x61, 0x38, 0x34, 0x62, 0x36, 0x38, 0x36, 0x66, 0x63, 0x33, 0x31, 0x62, 0x64, 0x63, 0x38, 0x33, 0x63, 0x32, 0x32, 0x31, 0x30, 0x35, 0x38, 0x35, 0x34, 0x36, 0x61, 0x37, 0x31, 0x62, 0x31, 0x31, 0x66, 0x38, 0x33, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x39, 0x34, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x35, 0x30, 0x37, 0x63, 0x66, 0x35, 0x35, 0x33, 0x35, 0x36, 0x38, 0x64, 0x61, 0x61, 0x66, 0x36, 0x35, 0x35, 0x30, 0x34, 0x61, 0x65, 0x34, 0x65, 0x61, 0x61, 0x31, 0x37, 0x61, 0x38, 0x65, 0x61, 0x33, 0x63, 0x64, 0x62, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x36, 0x30, 0x30, 0x39, 0x35, 0x32, 0x36, 0x61, 0x32, 0x63, 0x37, 0x62, 0x30, 0x63, 0x30, 0x39, 0x61, 0x36, 0x66, 0x36, 0x33, 0x61, 0x38, 0x30, 0x62, 0x64, 0x66, 0x32, 0x39, 0x64, 0x39, 0x63, 0x38, 0x37, 0x64, 0x65, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x32, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x39, 0x36, 0x30, 0x35, 0x32, 0x31, 0x33, 0x38, 0x33, 0x33, 0x38, 0x63, 0x37, 0x32, 0x32, 0x66, 0x31, 0x31, 0x34, 0x30, 0x38, 0x31, 0x35, 0x63, 0x66, 0x37, 0x37, 0x34, 0x39, 0x64, 0x30, 0x64, 0x33, 0x62, 0x33, 0x61, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x33, 0x31, 0x37, 0x35, 0x37, 0x65, 0x61, 0x65, 0x37, 0x35, 0x35, 0x37, 0x63, 0x62, 0x38, 0x61, 0x33, 0x37, 0x61, 0x34, 0x62, 0x31, 0x30, 0x36, 0x34, 0x34, 0x62, 0x36, 0x33, 0x65, 0x34, 0x64, 0x33, 0x62, 0x33, 0x63, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x64, 0x63, 0x37, 0x32, 0x37, 0x32, 0x39, 0x30, 0x32, 0x34, 0x33, 0x37, 0x35, 0x66, 0x63, 0x33, 0x37, 0x63, 0x62, 0x62, 0x39, 0x63, 0x37, 0x63, 0x32, 0x33, 0x39, 0x33, 0x64, 0x31, 0x30, 0x32, 0x33, 0x33, 0x33, 0x33, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x30, 0x39, 0x38, 0x38, 0x36, 0x36, 0x61, 0x36, 0x39, 0x62, 0x36, 0x38, 0x63, 0x30, 0x62, 0x36, 0x62, 0x63, 0x31, 0x36, 0x38, 0x32, 0x32, 0x39, 0x62, 0x39, 0x36, 0x30, 0x33, 0x35, 0x38, 0x37, 0x30, 0x35, 0x38, 0x39, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x61, 0x64, 0x62, 0x38, 0x66, 0x39, 0x36, 0x66, 0x33, 0x39, 0x34, 0x39, 0x32, 0x63, 0x39, 0x62, 0x62, 0x34, 0x37, 0x63, 0x35, 0x65, 0x64, 0x63, 0x38, 0x38, 0x36, 0x32, 0x34, 0x65, 0x34, 0x36, 0x30, 0x37, 0x35, 0x36, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x34, 0x64, 0x65, 0x38, 0x65, 0x33, 0x37, 0x34, 0x38, 0x61, 0x32, 0x38, 0x39, 0x63, 0x66, 0x37, 0x64, 0x30, 0x36, 0x30, 0x35, 0x31, 0x37, 0x64, 0x39, 0x64, 0x33, 0x38, 0x33, 0x38, 0x38, 0x64, 0x62, 0x30, 0x31, 0x66, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x65, 0x37, 0x35, 0x39, 0x35, 0x65, 0x61, 0x30, 0x66, 0x30, 0x36, 0x38, 0x34, 0x38, 0x39, 0x61, 0x32, 0x37, 0x30, 0x31, 0x65, 0x63, 0x34, 0x36, 0x34, 0x39, 0x31, 0x35, 0x38, 0x64, 0x64, 0x63, 0x34, 0x33, 0x65, 0x31, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x30, 0x32, 0x62, 0x34, 0x66, 0x36, 0x61, 0x30, 0x39, 0x39, 0x65, 0x62, 0x65, 0x37, 0x31, 0x36, 0x63, 0x62, 0x31, 0x34, 0x64, 0x66, 0x34, 0x66, 0x37, 0x39, 0x63, 0x30, 0x63, 0x64, 0x30, 0x31, 0x63, 0x36, 0x30, 0x37, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x37, 0x36, 0x38, 0x32, 0x30, 0x30, 0x30, 0x62, 0x31, 0x62, 0x63, 0x66, 0x33, 0x30, 0x30, 0x32, 0x66, 0x38, 0x35, 0x63, 0x38, 0x30, 0x63, 0x30, 0x66, 0x61, 0x32, 0x39, 0x34, 0x39, 0x62, 0x64, 0x31, 0x65, 0x38, 0x32, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x34, 0x66, 0x30, 0x30, 0x65, 0x32, 0x38, 0x33, 0x33, 0x36, 0x65, 0x61, 0x30, 0x39, 0x39, 0x34, 0x32, 0x35, 0x38, 0x38, 0x65, 0x65, 0x61, 0x63, 0x39, 0x32, 0x31, 0x38, 0x31, 0x31, 0x63, 0x35, 0x32, 0x32, 0x31, 0x34, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x33, 0x31, 0x63, 0x37, 0x30, 0x30, 0x35, 0x31, 0x39, 0x37, 0x65, 0x63, 0x39, 0x39, 0x37, 0x61, 0x38, 0x37, 0x65, 0x36, 0x39, 0x62, 0x65, 0x63, 0x34, 0x38, 0x36, 0x34, 0x39, 0x61, 0x62, 0x39, 0x34, 0x62, 0x62, 0x32, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x66, 0x64, 0x38, 0x66, 0x64, 0x39, 0x35, 0x39, 0x61, 0x65, 0x64, 0x32, 0x37, 0x36, 0x37, 0x65, 0x61, 0x37, 0x66, 0x61, 0x39, 0x36, 0x30, 0x63, 0x65, 0x31, 0x64, 0x62, 0x35, 0x33, 0x61, 0x66, 0x38, 0x30, 0x32, 0x35, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x65, 0x66, 0x39, 0x61, 0x64, 0x32, 0x37, 0x34, 0x34, 0x33, 0x36, 0x30, 0x34, 0x32, 0x39, 0x30, 0x33, 0x65, 0x34, 0x31, 0x33, 0x63, 0x33, 0x62, 0x30, 0x63, 0x36, 0x32, 0x66, 0x35, 0x66, 0x35, 0x32, 0x65, 0x64, 0x35, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x33, 0x61, 0x64, 0x32, 0x36, 0x30, 0x65, 0x39, 0x61, 0x36, 0x66, 0x34, 0x33, 0x32, 0x66, 0x62, 0x36, 0x65, 0x61, 0x32, 0x38, 0x37, 0x34, 0x33, 0x32, 0x39, 0x39, 0x62, 0x34, 0x61, 0x30, 0x39, 0x61, 0x64, 0x36, 0x35, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x63, 0x38, 0x31, 0x36, 0x61, 0x38, 0x32, 0x38, 0x33, 0x63, 0x61, 0x34, 0x64, 0x66, 0x36, 0x38, 0x61, 0x31, 0x61, 0x37, 0x33, 0x64, 0x36, 0x33, 0x62, 0x64, 0x38, 0x30, 0x32, 0x36, 0x30, 0x34, 0x38, 0x38, 0x64, 0x66, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x64, 0x33, 0x63, 0x37, 0x35, 0x39, 0x32, 0x30, 0x35, 0x39, 0x30, 0x34, 0x33, 0x38, 0x62, 0x38, 0x32, 0x63, 0x33, 0x65, 0x39, 0x35, 0x31, 0x35, 0x62, 0x65, 0x32, 0x65, 0x62, 0x36, 0x65, 0x64, 0x37, 0x61, 0x38, 0x62, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x33, 0x63, 0x62, 0x35, 0x39, 0x36, 0x35, 0x39, 0x33, 0x33, 0x65, 0x37, 0x64, 0x61, 0x64, 0x38, 0x38, 0x33, 0x36, 0x39, 0x33, 0x62, 0x39, 0x63, 0x33, 0x65, 0x31, 0x35, 0x62, 0x65, 0x62, 0x36, 0x38, 0x61, 0x34, 0x38, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x38, 0x39, 0x39, 0x65, 0x35, 0x39, 0x61, 0x39, 0x62, 0x34, 0x31, 0x61, 0x62, 0x37, 0x65, 0x61, 0x34, 0x31, 0x64, 0x66, 0x37, 0x35, 0x31, 0x37, 0x38, 0x36, 0x30, 0x66, 0x32, 0x61, 0x63, 0x62, 0x35, 0x39, 0x66, 0x34, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x37, 0x61, 0x38, 0x63, 0x61, 0x31, 0x32, 0x36, 0x38, 0x36, 0x33, 0x33, 0x61, 0x36, 0x63, 0x39, 0x33, 0x39, 0x63, 0x35, 0x64, 0x65, 0x31, 0x62, 0x39, 0x32, 0x39, 0x61, 0x65, 0x65, 0x39, 0x32, 0x61, 0x65, 0x61, 0x63, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x38, 0x30, 0x63, 0x65, 0x63, 0x35, 0x30, 0x32, 0x31, 0x65, 0x65, 0x39, 0x33, 0x30, 0x35, 0x30, 0x66, 0x38, 0x61, 0x65, 0x31, 0x32, 0x37, 0x32, 0x35, 0x31, 0x38, 0x33, 0x39, 0x65, 0x37, 0x34, 0x63, 0x31, 0x66, 0x31, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x39, 0x38, 0x36, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x37, 0x38, 0x34, 0x33, 0x63, 0x37, 0x30, 0x31, 0x30, 0x61, 0x61, 0x37, 0x65, 0x36, 0x31, 0x35, 0x31, 0x39, 0x62, 0x37, 0x36, 0x32, 0x64, 0x66, 0x65, 0x34, 0x39, 0x31, 0x32, 0x34, 0x61, 0x37, 0x36, 0x62, 0x30, 0x65, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x30, 0x66, 0x62, 0x61, 0x35, 0x38, 0x64, 0x62, 0x63, 0x30, 0x34, 0x38, 0x30, 0x33, 0x64, 0x38, 0x34, 0x63, 0x32, 0x31, 0x33, 0x30, 0x66, 0x30, 0x31, 0x39, 0x37, 0x38, 0x66, 0x39, 0x65, 0x30, 0x63, 0x37, 0x33, 0x31, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x36, 0x31, 0x61, 0x64, 0x33, 0x61, 0x31, 0x37, 0x32, 0x61, 0x62, 0x66, 0x31, 0x33, 0x31, 0x35, 0x66, 0x30, 0x66, 0x66, 0x65, 0x63, 0x33, 0x32, 0x37, 0x30, 0x39, 0x38, 0x36, 0x61, 0x38, 0x34, 0x30, 0x39, 0x63, 0x62, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x35, 0x61, 0x37, 0x39, 0x30, 0x31, 0x36, 0x31, 0x37, 0x36, 0x33, 0x32, 0x30, 0x39, 0x37, 0x33, 0x65, 0x38, 0x63, 0x64, 0x33, 0x38, 0x66, 0x36, 0x33, 0x37, 0x35, 0x35, 0x33, 0x30, 0x30, 0x32, 0x32, 0x35, 0x33, 0x31, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x61, 0x37, 0x33, 0x65, 0x66, 0x66, 0x38, 0x37, 0x37, 0x31, 0x63, 0x30, 0x31, 0x30, 0x33, 0x62, 0x61, 0x33, 0x63, 0x63, 0x31, 0x61, 0x39, 0x63, 0x32, 0x35, 0x39, 0x34, 0x34, 0x38, 0x63, 0x37, 0x32, 0x61, 0x62, 0x66, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x64, 0x34, 0x31, 0x32, 0x31, 0x37, 0x62, 0x61, 0x64, 0x63, 0x61, 0x35, 0x65, 0x30, 0x65, 0x36, 0x30, 0x33, 0x32, 0x37, 0x64, 0x38, 0x34, 0x35, 0x61, 0x33, 0x34, 0x36, 0x34, 0x66, 0x30, 0x66, 0x32, 0x37, 0x66, 0x38, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x31, 0x63, 0x31, 0x39, 0x31, 0x31, 0x34, 0x65, 0x33, 0x64, 0x36, 0x64, 0x65, 0x32, 0x37, 0x38, 0x35, 0x31, 0x34, 0x38, 0x34, 0x62, 0x38, 0x64, 0x32, 0x37, 0x31, 0x35, 0x65, 0x35, 0x30, 0x66, 0x38, 0x61, 0x31, 0x30, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x64, 0x32, 0x31, 0x65, 0x66, 0x66, 0x39, 0x35, 0x34, 0x66, 0x63, 0x36, 0x61, 0x37, 0x64, 0x65, 0x32, 0x36, 0x39, 0x31, 0x32, 0x61, 0x37, 0x63, 0x62, 0x62, 0x33, 0x30, 0x33, 0x61, 0x36, 0x36, 0x30, 0x37, 0x38, 0x30, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x30, 0x33, 0x64, 0x35, 0x61, 0x38, 0x31, 0x36, 0x61, 0x66, 0x66, 0x64, 0x39, 0x37, 0x65, 0x38, 0x33, 0x64, 0x39, 0x65, 0x34, 0x64, 0x61, 0x63, 0x32, 0x66, 0x37, 0x39, 0x30, 0x37, 0x32, 0x62, 0x62, 0x30, 0x30, 0x39, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x34, 0x63, 0x66, 0x65, 0x66, 0x65, 0x35, 0x30, 0x31, 0x37, 0x30, 0x64, 0x64, 0x39, 0x37, 0x61, 0x65, 0x30, 0x38, 0x66, 0x30, 0x61, 0x34, 0x34, 0x35, 0x34, 0x34, 0x39, 0x37, 0x38, 0x63, 0x35, 0x39, 0x39, 0x35, 0x34, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x37, 0x62, 0x38, 0x35, 0x30, 0x34, 0x34, 0x64, 0x66, 0x32, 0x63, 0x66, 0x30, 0x62, 0x34, 0x65, 0x64, 0x34, 0x38, 0x38, 0x32, 0x65, 0x38, 0x38, 0x38, 0x31, 0x39, 0x66, 0x65, 0x32, 0x32, 0x61, 0x65, 0x35, 0x66, 0x37, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x31, 0x33, 0x30, 0x64, 0x36, 0x66, 0x61, 0x35, 0x31, 0x64, 0x35, 0x63, 0x34, 0x38, 0x65, 0x63, 0x38, 0x64, 0x31, 0x64, 0x35, 0x32, 0x64, 0x63, 0x38, 0x61, 0x32, 0x32, 0x37, 0x62, 0x65, 0x38, 0x37, 0x33, 0x35, 0x63, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x39, 0x64, 0x33, 0x66, 0x39, 0x62, 0x63, 0x34, 0x61, 0x34, 0x63, 0x36, 0x65, 0x66, 0x62, 0x64, 0x35, 0x39, 0x36, 0x37, 0x39, 0x62, 0x36, 0x39, 0x38, 0x32, 0x36, 0x62, 0x63, 0x31, 0x66, 0x36, 0x33, 0x64, 0x39, 0x39, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x36, 0x35, 0x65, 0x30, 0x30, 0x34, 0x37, 0x36, 0x38, 0x31, 0x30, 0x39, 0x34, 0x37, 0x38, 0x31, 0x36, 0x61, 0x66, 0x31, 0x34, 0x32, 0x64, 0x34, 0x36, 0x64, 0x32, 0x65, 0x65, 0x37, 0x62, 0x63, 0x61, 0x38, 0x63, 0x63, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x37, 0x62, 0x30, 0x34, 0x66, 0x61, 0x32, 0x33, 0x64, 0x31, 0x32, 0x30, 0x33, 0x66, 0x61, 0x65, 0x30, 0x36, 0x31, 0x65, 0x61, 0x63, 0x34, 0x35, 0x34, 0x32, 0x63, 0x62, 0x36, 0x30, 0x66, 0x33, 0x61, 0x35, 0x37, 0x36, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x39, 0x32, 0x34, 0x38, 0x39, 0x62, 0x38, 0x35, 0x61, 0x39, 0x38, 0x32, 0x63, 0x31, 0x38, 0x38, 0x33, 0x32, 0x34, 0x36, 0x64, 0x39, 0x31, 0x35, 0x62, 0x32, 0x32, 0x39, 0x63, 0x62, 0x31, 0x33, 0x32, 0x30, 0x37, 0x66, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x34, 0x38, 0x33, 0x66, 0x66, 0x62, 0x38, 0x66, 0x36, 0x38, 0x30, 0x61, 0x65, 0x64, 0x66, 0x32, 0x61, 0x33, 0x38, 0x66, 0x37, 0x38, 0x33, 0x33, 0x61, 0x66, 0x64, 0x63, 0x64, 0x65, 0x35, 0x39, 0x62, 0x36, 0x31, 0x65, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x36, 0x64, 0x31, 0x31, 0x38, 0x32, 0x65, 0x35, 0x61, 0x61, 0x63, 0x61, 0x66, 0x66, 0x30, 0x64, 0x32, 0x36, 0x62, 0x32, 0x66, 0x63, 0x66, 0x37, 0x32, 0x66, 0x33, 0x63, 0x39, 0x66, 0x66, 0x62, 0x63, 0x64, 0x64, 0x39, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x63, 0x37, 0x66, 0x37, 0x38, 0x35, 0x63, 0x39, 0x33, 0x31, 0x36, 0x30, 0x65, 0x35, 0x38, 0x30, 0x37, 0x65, 0x64, 0x33, 0x34, 0x65, 0x35, 0x65, 0x35, 0x33, 0x34, 0x62, 0x63, 0x36, 0x31, 0x38, 0x38, 0x36, 0x34, 0x37, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x65, 0x34, 0x63, 0x65, 0x34, 0x37, 0x34, 0x38, 0x33, 0x62, 0x35, 0x33, 0x30, 0x34, 0x30, 0x61, 0x64, 0x62, 0x61, 0x62, 0x33, 0x35, 0x31, 0x37, 0x32, 0x63, 0x30, 0x31, 0x65, 0x66, 0x36, 0x34, 0x35, 0x30, 0x36, 0x65, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x36, 0x64, 0x36, 0x36, 0x62, 0x35, 0x32, 0x31, 0x35, 0x37, 0x31, 0x61, 0x34, 0x65, 0x34, 0x31, 0x30, 0x33, 0x61, 0x37, 0x66, 0x35, 0x36, 0x32, 0x63, 0x35, 0x31, 0x31, 0x65, 0x36, 0x61, 0x61, 0x37, 0x33, 0x32, 0x64, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x64, 0x39, 0x39, 0x65, 0x64, 0x63, 0x32, 0x31, 0x36, 0x30, 0x66, 0x32, 0x31, 0x30, 0x61, 0x30, 0x35, 0x65, 0x33, 0x61, 0x31, 0x66, 0x61, 0x30, 0x62, 0x30, 0x34, 0x33, 0x34, 0x63, 0x65, 0x64, 0x30, 0x30, 0x34, 0x33, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x34, 0x66, 0x30, 0x65, 0x62, 0x38, 0x36, 0x64, 0x62, 0x30, 0x65, 0x62, 0x36, 0x38, 0x37, 0x35, 0x33, 0x66, 0x31, 0x36, 0x39, 0x31, 0x38, 0x65, 0x35, 0x64, 0x34, 0x62, 0x38, 0x30, 0x37, 0x34, 0x33, 0x37, 0x62, 0x64, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x64, 0x35, 0x36, 0x36, 0x37, 0x31, 0x34, 0x30, 0x64, 0x31, 0x32, 0x36, 0x31, 0x34, 0x62, 0x32, 0x31, 0x63, 0x38, 0x65, 0x35, 0x65, 0x38, 0x61, 0x33, 0x33, 0x30, 0x38, 0x32, 0x65, 0x33, 0x32, 0x64, 0x66, 0x63, 0x66, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x63, 0x61, 0x62, 0x66, 0x32, 0x35, 0x30, 0x37, 0x37, 0x66, 0x33, 0x61, 0x61, 0x34, 0x31, 0x35, 0x34, 0x35, 0x33, 0x34, 0x34, 0x64, 0x35, 0x33, 0x62, 0x65, 0x31, 0x62, 0x32, 0x62, 0x39, 0x63, 0x33, 0x33, 0x39, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x63, 0x30, 0x64, 0x37, 0x63, 0x30, 0x31, 0x36, 0x66, 0x61, 0x37, 0x61, 0x61, 0x39, 0x35, 0x30, 0x31, 0x31, 0x34, 0x61, 0x61, 0x31, 0x64, 0x62, 0x30, 0x39, 0x34, 0x38, 0x38, 0x32, 0x65, 0x64, 0x61, 0x32, 0x37, 0x34, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x31, 0x31, 0x34, 0x35, 0x65, 0x35, 0x32, 0x39, 0x63, 0x37, 0x61, 0x37, 0x31, 0x34, 0x65, 0x36, 0x37, 0x39, 0x30, 0x33, 0x65, 0x65, 0x36, 0x32, 0x30, 0x36, 0x65, 0x34, 0x63, 0x33, 0x30, 0x34, 0x32, 0x62, 0x36, 0x37, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x65, 0x39, 0x39, 0x33, 0x39, 0x33, 0x33, 0x34, 0x66, 0x31, 0x32, 0x35, 0x32, 0x65, 0x64, 0x32, 0x62, 0x61, 0x32, 0x36, 0x38, 0x31, 0x34, 0x34, 0x38, 0x37, 0x64, 0x66, 0x64, 0x32, 0x39, 0x38, 0x32, 0x62, 0x33, 0x31, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x39, 0x62, 0x33, 0x65, 0x38, 0x37, 0x66, 0x39, 0x31, 0x33, 0x64, 0x64, 0x66, 0x64, 0x35, 0x37, 0x61, 0x65, 0x38, 0x30, 0x34, 0x39, 0x63, 0x37, 0x33, 0x31, 0x64, 0x62, 0x61, 0x39, 0x62, 0x36, 0x33, 0x36, 0x64, 0x66, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x34, 0x39, 0x32, 0x32, 0x35, 0x61, 0x36, 0x32, 0x66, 0x37, 0x30, 0x61, 0x65, 0x61, 0x34, 0x38, 0x30, 0x61, 0x30, 0x32, 0x39, 0x39, 0x31, 0x35, 0x61, 0x30, 0x31, 0x65, 0x35, 0x33, 0x37, 0x39, 0x65, 0x36, 0x34, 0x66, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x36, 0x62, 0x34, 0x66, 0x33, 0x37, 0x64, 0x35, 0x35, 0x64, 0x36, 0x33, 0x62, 0x37, 0x64, 0x30, 0x35, 0x36, 0x62, 0x36, 0x31, 0x35, 0x62, 0x62, 0x37, 0x34, 0x63, 0x39, 0x36, 0x62, 0x33, 0x62, 0x30, 0x31, 0x39, 0x39, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x64, 0x36, 0x62, 0x31, 0x63, 0x36, 0x64, 0x37, 0x34, 0x64, 0x30, 0x31, 0x30, 0x64, 0x31, 0x30, 0x30, 0x38, 0x64, 0x62, 0x61, 0x36, 0x65, 0x66, 0x38, 0x33, 0x35, 0x64, 0x34, 0x34, 0x33, 0x30, 0x62, 0x33, 0x35, 0x63, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x36, 0x33, 0x63, 0x64, 0x39, 0x30, 0x66, 0x62, 0x61, 0x62, 0x35, 0x62, 0x62, 0x38, 0x63, 0x34, 0x39, 0x61, 0x63, 0x32, 0x30, 0x66, 0x63, 0x36, 0x32, 0x63, 0x33, 0x39, 0x38, 0x66, 0x65, 0x36, 0x66, 0x62, 0x37, 0x34, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x34, 0x37, 0x39, 0x64, 0x61, 0x62, 0x35, 0x30, 0x32, 0x32, 0x63, 0x34, 0x64, 0x35, 0x64, 0x62, 0x61, 0x61, 0x66, 0x38, 0x64, 0x65, 0x31, 0x37, 0x31, 0x62, 0x34, 0x65, 0x39, 0x35, 0x31, 0x64, 0x64, 0x31, 0x61, 0x34, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x35, 0x34, 0x36, 0x38, 0x66, 0x61, 0x35, 0x63, 0x61, 0x32, 0x32, 0x36, 0x63, 0x37, 0x35, 0x33, 0x32, 0x65, 0x63, 0x66, 0x30, 0x36, 0x65, 0x31, 0x62, 0x63, 0x31, 0x63, 0x34, 0x35, 0x32, 0x32, 0x35, 0x64, 0x37, 0x65, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x61, 0x32, 0x30, 0x64, 0x30, 0x32, 0x38, 0x65, 0x32, 0x63, 0x36, 0x32, 0x31, 0x38, 0x62, 0x39, 0x64, 0x39, 0x35, 0x62, 0x34, 0x34, 0x35, 0x63, 0x37, 0x37, 0x31, 0x35, 0x32, 0x34, 0x36, 0x33, 0x36, 0x61, 0x32, 0x32, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x64, 0x32, 0x38, 0x63, 0x64, 0x35, 0x63, 0x37, 0x38, 0x61, 0x65, 0x65, 0x35, 0x31, 0x33, 0x35, 0x37, 0x63, 0x39, 0x35, 0x63, 0x31, 0x65, 0x66, 0x39, 0x32, 0x33, 0x35, 0x65, 0x37, 0x63, 0x31, 0x38, 0x62, 0x63, 0x38, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x33, 0x34, 0x39, 0x32, 0x61, 0x35, 0x63, 0x35, 0x31, 0x33, 0x39, 0x36, 0x61, 0x34, 0x38, 0x32, 0x38, 0x38, 0x31, 0x36, 0x36, 0x39, 0x63, 0x63, 0x66, 0x36, 0x64, 0x38, 0x64, 0x37, 0x37, 0x39, 0x66, 0x30, 0x30, 0x39, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x35, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x37, 0x32, 0x33, 0x62, 0x32, 0x38, 0x39, 0x61, 0x37, 0x33, 0x36, 0x37, 0x62, 0x36, 0x65, 0x63, 0x65, 0x32, 0x34, 0x35, 0x35, 0x65, 0x64, 0x36, 0x31, 0x65, 0x64, 0x62, 0x34, 0x39, 0x36, 0x37, 0x30, 0x61, 0x62, 0x39, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x39, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x65, 0x33, 0x35, 0x34, 0x32, 0x63, 0x33, 0x36, 0x31, 0x33, 0x36, 0x38, 0x37, 0x34, 0x36, 0x35, 0x66, 0x31, 0x35, 0x61, 0x37, 0x30, 0x61, 0x65, 0x65, 0x62, 0x38, 0x31, 0x36, 0x36, 0x32, 0x62, 0x36, 0x35, 0x63, 0x63, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x30, 0x33, 0x65, 0x36, 0x38, 0x62, 0x33, 0x34, 0x64, 0x61, 0x31, 0x32, 0x31, 0x61, 0x65, 0x66, 0x30, 0x38, 0x62, 0x36, 0x30, 0x32, 0x62, 0x61, 0x64, 0x62, 0x61, 0x66, 0x62, 0x34, 0x64, 0x31, 0x32, 0x34, 0x38, 0x31, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x63, 0x39, 0x30, 0x37, 0x65, 0x65, 0x38, 0x35, 0x65, 0x36, 0x66, 0x33, 0x65, 0x32, 0x32, 0x33, 0x34, 0x35, 0x39, 0x39, 0x39, 0x32, 0x65, 0x32, 0x35, 0x36, 0x61, 0x34, 0x33, 0x66, 0x61, 0x30, 0x38, 0x66, 0x61, 0x38, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x33, 0x62, 0x36, 0x61, 0x38, 0x65, 0x63, 0x38, 0x64, 0x61, 0x34, 0x30, 0x38, 0x31, 0x38, 0x36, 0x61, 0x63, 0x38, 0x61, 0x37, 0x64, 0x32, 0x61, 0x36, 0x64, 0x64, 0x36, 0x31, 0x35, 0x32, 0x33, 0x65, 0x37, 0x63, 0x65, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x36, 0x32, 0x38, 0x63, 0x36, 0x66, 0x62, 0x38, 0x65, 0x63, 0x37, 0x34, 0x33, 0x61, 0x64, 0x62, 0x64, 0x38, 0x37, 0x63, 0x65, 0x35, 0x65, 0x30, 0x31, 0x38, 0x64, 0x35, 0x33, 0x31, 0x64, 0x39, 0x32, 0x31, 0x30, 0x34, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x36, 0x63, 0x32, 0x38, 0x65, 0x33, 0x34, 0x63, 0x33, 0x38, 0x30, 0x38, 0x64, 0x39, 0x37, 0x36, 0x36, 0x66, 0x65, 0x38, 0x34, 0x32, 0x31, 0x65, 0x62, 0x66, 0x34, 0x66, 0x32, 0x62, 0x31, 0x63, 0x34, 0x66, 0x37, 0x64, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x31, 0x61, 0x64, 0x39, 0x61, 0x30, 0x34, 0x62, 0x65, 0x64, 0x63, 0x38, 0x62, 0x38, 0x36, 0x31, 0x65, 0x38, 0x65, 0x64, 0x34, 0x62, 0x64, 0x64, 0x66, 0x35, 0x37, 0x31, 0x37, 0x38, 0x31, 0x33, 0x62, 0x31, 0x62, 0x62, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x38, 0x35, 0x62, 0x63, 0x31, 0x66, 0x63, 0x35, 0x63, 0x62, 0x63, 0x39, 0x63, 0x30, 0x30, 0x31, 0x65, 0x38, 0x66, 0x31, 0x33, 0x37, 0x32, 0x65, 0x30, 0x37, 0x35, 0x30, 0x35, 0x33, 0x37, 0x30, 0x64, 0x38, 0x63, 0x37, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x32, 0x66, 0x39, 0x37, 0x36, 0x37, 0x33, 0x34, 0x62, 0x39, 0x64, 0x30, 0x30, 0x37, 0x30, 0x64, 0x31, 0x38, 0x38, 0x33, 0x63, 0x66, 0x37, 0x61, 0x63, 0x61, 0x62, 0x38, 0x62, 0x33, 0x65, 0x34, 0x39, 0x32, 0x30, 0x66, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x37, 0x61, 0x30, 0x32, 0x63, 0x30, 0x61, 0x39, 0x64, 0x66, 0x65, 0x32, 0x38, 0x37, 0x64, 0x65, 0x34, 0x34, 0x37, 0x66, 0x62, 0x36, 0x37, 0x61, 0x37, 0x30, 0x65, 0x63, 0x35, 0x62, 0x36, 0x32, 0x33, 0x36, 0x36, 0x36, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x61, 0x30, 0x31, 0x66, 0x62, 0x30, 0x34, 0x61, 0x63, 0x30, 0x64, 0x62, 0x32, 0x63, 0x63, 0x65, 0x35, 0x64, 0x62, 0x65, 0x32, 0x38, 0x31, 0x65, 0x31, 0x63, 0x34, 0x36, 0x65, 0x32, 0x38, 0x62, 0x33, 0x39, 0x64, 0x38, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x33, 0x30, 0x63, 0x35, 0x65, 0x35, 0x36, 0x35, 0x63, 0x65, 0x61, 0x61, 0x38, 0x61, 0x30, 0x66, 0x30, 0x66, 0x66, 0x65, 0x33, 0x32, 0x38, 0x37, 0x35, 0x65, 0x61, 0x65, 0x32, 0x61, 0x36, 0x63, 0x65, 0x36, 0x33, 0x63, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x34, 0x33, 0x34, 0x30, 0x65, 0x65, 0x34, 0x62, 0x39, 0x63, 0x64, 0x63, 0x38, 0x31, 0x66, 0x38, 0x35, 0x30, 0x61, 0x37, 0x35, 0x31, 0x31, 0x36, 0x64, 0x35, 0x30, 0x65, 0x65, 0x39, 0x62, 0x36, 0x39, 0x38, 0x32, 0x35, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x61, 0x66, 0x62, 0x37, 0x64, 0x38, 0x62, 0x37, 0x39, 0x33, 0x37, 0x30, 0x63, 0x66, 0x64, 0x36, 0x36, 0x33, 0x63, 0x36, 0x38, 0x63, 0x63, 0x36, 0x62, 0x39, 0x37, 0x30, 0x32, 0x61, 0x33, 0x37, 0x63, 0x64, 0x39, 0x65, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x31, 0x36, 0x38, 0x39, 0x35, 0x64, 0x66, 0x33, 0x32, 0x63, 0x38, 0x65, 0x64, 0x35, 0x34, 0x37, 0x38, 0x32, 0x36, 0x39, 0x34, 0x36, 0x38, 0x34, 0x32, 0x33, 0x61, 0x65, 0x61, 0x37, 0x62, 0x37, 0x66, 0x62, 0x63, 0x65, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x32, 0x66, 0x65, 0x34, 0x65, 0x34, 0x61, 0x37, 0x37, 0x64, 0x31, 0x34, 0x31, 0x66, 0x66, 0x34, 0x39, 0x61, 0x30, 0x63, 0x37, 0x66, 0x62, 0x63, 0x39, 0x35, 0x62, 0x30, 0x61, 0x32, 0x62, 0x32, 0x38, 0x33, 0x65, 0x65, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x30, 0x64, 0x66, 0x38, 0x39, 0x34, 0x33, 0x61, 0x38, 0x63, 0x39, 0x61, 0x35, 0x64, 0x62, 0x61, 0x37, 0x39, 0x34, 0x35, 0x33, 0x32, 0x37, 0x66, 0x64, 0x37, 0x65, 0x30, 0x38, 0x33, 0x37, 0x63, 0x31, 0x31, 0x61, 0x64, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x66, 0x62, 0x65, 0x65, 0x64, 0x36, 0x66, 0x36, 0x32, 0x36, 0x66, 0x63, 0x64, 0x66, 0x64, 0x35, 0x31, 0x61, 0x63, 0x61, 0x66, 0x62, 0x37, 0x33, 0x30, 0x62, 0x39, 0x65, 0x65, 0x66, 0x66, 0x36, 0x31, 0x32, 0x66, 0x35, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x64, 0x38, 0x38, 0x30, 0x36, 0x38, 0x65, 0x31, 0x33, 0x30, 0x37, 0x35, 0x66, 0x33, 0x61, 0x38, 0x63, 0x61, 0x63, 0x34, 0x36, 0x34, 0x61, 0x35, 0x66, 0x39, 0x34, 0x39, 0x64, 0x36, 0x64, 0x38, 0x31, 0x38, 0x63, 0x30, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x34, 0x35, 0x37, 0x32, 0x66, 0x62, 0x62, 0x31, 0x64, 0x37, 0x32, 0x62, 0x35, 0x37, 0x35, 0x64, 0x36, 0x39, 0x65, 0x63, 0x36, 0x61, 0x64, 0x31, 0x37, 0x33, 0x33, 0x33, 0x38, 0x37, 0x33, 0x65, 0x38, 0x35, 0x35, 0x32, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x34, 0x65, 0x61, 0x35, 0x31, 0x30, 0x36, 0x33, 0x34, 0x30, 0x35, 0x31, 0x35, 0x34, 0x61, 0x61, 0x65, 0x37, 0x33, 0x36, 0x62, 0x65, 0x32, 0x62, 0x66, 0x31, 0x65, 0x65, 0x33, 0x62, 0x39, 0x62, 0x65, 0x36, 0x33, 0x39, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x37, 0x66, 0x32, 0x30, 0x38, 0x39, 0x34, 0x66, 0x61, 0x37, 0x30, 0x65, 0x39, 0x34, 0x61, 0x38, 0x36, 0x61, 0x34, 0x39, 0x63, 0x64, 0x37, 0x34, 0x65, 0x30, 0x33, 0x32, 0x33, 0x38, 0x66, 0x36, 0x34, 0x64, 0x33, 0x63, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x39, 0x31, 0x34, 0x65, 0x33, 0x30, 0x31, 0x38, 0x61, 0x63, 0x30, 0x30, 0x34, 0x34, 0x39, 0x33, 0x34, 0x31, 0x63, 0x34, 0x39, 0x64, 0x61, 0x37, 0x31, 0x64, 0x30, 0x34, 0x64, 0x66, 0x65, 0x65, 0x65, 0x64, 0x36, 0x32, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x30, 0x31, 0x38, 0x31, 0x64, 0x34, 0x34, 0x35, 0x30, 0x30, 0x37, 0x62, 0x64, 0x30, 0x38, 0x37, 0x35, 0x61, 0x61, 0x66, 0x30, 0x36, 0x31, 0x63, 0x38, 0x64, 0x35, 0x31, 0x31, 0x35, 0x33, 0x39, 0x30, 0x30, 0x38, 0x33, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x39, 0x38, 0x37, 0x31, 0x31, 0x30, 0x32, 0x32, 0x31, 0x61, 0x38, 0x38, 0x30, 0x38, 0x32, 0x36, 0x61, 0x64, 0x62, 0x32, 0x65, 0x37, 0x61, 0x62, 0x35, 0x65, 0x63, 0x61, 0x37, 0x38, 0x63, 0x36, 0x65, 0x33, 0x31, 0x61, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x36, 0x31, 0x38, 0x65, 0x39, 0x64, 0x35, 0x37, 0x36, 0x32, 0x64, 0x66, 0x36, 0x32, 0x30, 0x32, 0x38, 0x36, 0x30, 0x31, 0x61, 0x38, 0x31, 0x64, 0x34, 0x34, 0x38, 0x37, 0x64, 0x36, 0x61, 0x30, 0x65, 0x63, 0x62, 0x38, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x63, 0x36, 0x35, 0x32, 0x64, 0x64, 0x31, 0x33, 0x65, 0x37, 0x66, 0x65, 0x31, 0x34, 0x64, 0x61, 0x62, 0x62, 0x62, 0x33, 0x36, 0x64, 0x35, 0x64, 0x33, 0x32, 0x30, 0x64, 0x62, 0x39, 0x66, 0x66, 0x65, 0x65, 0x38, 0x61, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x37, 0x33, 0x61, 0x65, 0x66, 0x64, 0x35, 0x65, 0x66, 0x61, 0x65, 0x65, 0x39, 0x36, 0x30, 0x39, 0x35, 0x64, 0x39, 0x65, 0x32, 0x38, 0x38, 0x66, 0x36, 0x61, 0x30, 0x34, 0x36, 0x63, 0x39, 0x37, 0x33, 0x37, 0x34, 0x62, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x64, 0x35, 0x31, 0x63, 0x64, 0x66, 0x32, 0x63, 0x33, 0x62, 0x66, 0x61, 0x63, 0x64, 0x66, 0x66, 0x31, 0x30, 0x36, 0x32, 0x32, 0x31, 0x64, 0x65, 0x32, 0x65, 0x31, 0x39, 0x61, 0x64, 0x36, 0x64, 0x34, 0x32, 0x30, 0x34, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x36, 0x39, 0x37, 0x65, 0x66, 0x32, 0x30, 0x63, 0x63, 0x63, 0x61, 0x61, 0x37, 0x30, 0x64, 0x33, 0x32, 0x64, 0x33, 0x37, 0x36, 0x66, 0x38, 0x32, 0x37, 0x32, 0x64, 0x39, 0x63, 0x31, 0x30, 0x37, 0x30, 0x63, 0x33, 0x64, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x32, 0x36, 0x63, 0x34, 0x32, 0x65, 0x30, 0x30, 0x66, 0x34, 0x35, 0x34, 0x30, 0x34, 0x38, 0x33, 0x36, 0x65, 0x62, 0x31, 0x65, 0x32, 0x38, 0x30, 0x64, 0x30, 0x37, 0x33, 0x65, 0x37, 0x30, 0x35, 0x39, 0x36, 0x38, 0x37, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x32, 0x33, 0x33, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x30, 0x37, 0x38, 0x35, 0x35, 0x33, 0x32, 0x63, 0x37, 0x37, 0x32, 0x33, 0x65, 0x34, 0x63, 0x30, 0x61, 0x66, 0x39, 0x33, 0x35, 0x37, 0x64, 0x35, 0x32, 0x37, 0x34, 0x62, 0x37, 0x33, 0x62, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x34, 0x33, 0x30, 0x65, 0x39, 0x33, 0x31, 0x64, 0x39, 0x33, 0x62, 0x65, 0x30, 0x31, 0x62, 0x34, 0x63, 0x33, 0x65, 0x66, 0x30, 0x64, 0x63, 0x35, 0x33, 0x35, 0x66, 0x31, 0x65, 0x30, 0x61, 0x39, 0x36, 0x31, 0x30, 0x30, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x33, 0x64, 0x35, 0x33, 0x36, 0x62, 0x38, 0x62, 0x31, 0x63, 0x62, 0x38, 0x34, 0x66, 0x35, 0x36, 0x61, 0x33, 0x39, 0x65, 0x30, 0x62, 0x63, 0x38, 0x31, 0x66, 0x64, 0x35, 0x34, 0x34, 0x32, 0x62, 0x63, 0x61, 0x63, 0x63, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x36, 0x64, 0x30, 0x34, 0x31, 0x64, 0x61, 0x37, 0x61, 0x66, 0x34, 0x34, 0x38, 0x37, 0x62, 0x39, 0x64, 0x63, 0x34, 0x38, 0x65, 0x38, 0x65, 0x31, 0x66, 0x36, 0x30, 0x37, 0x36, 0x36, 0x64, 0x30, 0x61, 0x35, 0x36, 0x64, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x62, 0x66, 0x62, 0x35, 0x39, 0x64, 0x35, 0x33, 0x38, 0x61, 0x66, 0x63, 0x34, 0x38, 0x37, 0x34, 0x64, 0x34, 0x66, 0x35, 0x39, 0x34, 0x31, 0x62, 0x30, 0x38, 0x63, 0x39, 0x37, 0x33, 0x30, 0x65, 0x33, 0x38, 0x65, 0x32, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x64, 0x62, 0x66, 0x64, 0x38, 0x65, 0x64, 0x61, 0x30, 0x31, 0x64, 0x30, 0x64, 0x65, 0x38, 0x65, 0x31, 0x35, 0x38, 0x62, 0x31, 0x36, 0x64, 0x30, 0x39, 0x33, 0x35, 0x66, 0x63, 0x32, 0x33, 0x38, 0x30, 0x61, 0x35, 0x64, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x36, 0x63, 0x64, 0x36, 0x36, 0x34, 0x61, 0x64, 0x39, 0x63, 0x31, 0x65, 0x64, 0x36, 0x34, 0x62, 0x66, 0x39, 0x38, 0x37, 0x34, 0x39, 0x66, 0x34, 0x30, 0x36, 0x34, 0x34, 0x62, 0x36, 0x32, 0x36, 0x65, 0x33, 0x37, 0x39, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x32, 0x65, 0x30, 0x64, 0x61, 0x38, 0x39, 0x33, 0x34, 0x36, 0x39, 0x39, 0x62, 0x62, 0x31, 0x61, 0x35, 0x35, 0x33, 0x65, 0x35, 0x35, 0x61, 0x30, 0x62, 0x38, 0x35, 0x63, 0x31, 0x36, 0x39, 0x34, 0x33, 0x35, 0x62, 0x65, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x39, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x39, 0x62, 0x66, 0x65, 0x65, 0x34, 0x61, 0x65, 0x63, 0x39, 0x62, 0x64, 0x37, 0x35, 0x62, 0x64, 0x32, 0x32, 0x63, 0x36, 0x62, 0x36, 0x37, 0x32, 0x38, 0x39, 0x38, 0x63, 0x61, 0x39, 0x61, 0x31, 0x65, 0x39, 0x35, 0x64, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x63, 0x34, 0x34, 0x63, 0x38, 0x37, 0x36, 0x31, 0x32, 0x33, 0x31, 0x62, 0x61, 0x31, 0x66, 0x31, 0x31, 0x66, 0x35, 0x66, 0x61, 0x61, 0x34, 0x30, 0x66, 0x61, 0x36, 0x36, 0x39, 0x61, 0x30, 0x31, 0x33, 0x65, 0x31, 0x32, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x33, 0x35, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x38, 0x30, 0x39, 0x61, 0x66, 0x35, 0x64, 0x35, 0x33, 0x32, 0x61, 0x31, 0x31, 0x63, 0x31, 0x61, 0x34, 0x64, 0x36, 0x65, 0x33, 0x32, 0x61, 0x61, 0x63, 0x37, 0x35, 0x63, 0x34, 0x63, 0x35, 0x32, 0x62, 0x30, 0x38, 0x65, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x63, 0x63, 0x32, 0x31, 0x62, 0x64, 0x39, 0x39, 0x66, 0x33, 0x39, 0x30, 0x30, 0x35, 0x63, 0x35, 0x38, 0x66, 0x65, 0x34, 0x61, 0x34, 0x34, 0x38, 0x39, 0x30, 0x39, 0x32, 0x32, 0x30, 0x32, 0x31, 0x38, 0x66, 0x36, 0x36, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x38, 0x30, 0x63, 0x31, 0x64, 0x38, 0x33, 0x35, 0x38, 0x61, 0x31, 0x35, 0x62, 0x63, 0x38, 0x34, 0x64, 0x61, 0x63, 0x38, 0x32, 0x35, 0x33, 0x63, 0x36, 0x38, 0x38, 0x33, 0x33, 0x31, 0x39, 0x30, 0x32, 0x30, 0x64, 0x66, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x61, 0x66, 0x36, 0x61, 0x33, 0x32, 0x38, 0x61, 0x34, 0x30, 0x37, 0x36, 0x30, 0x32, 0x34, 0x65, 0x66, 0x61, 0x36, 0x62, 0x36, 0x37, 0x62, 0x34, 0x38, 0x62, 0x32, 0x31, 0x65, 0x65, 0x64, 0x63, 0x63, 0x30, 0x66, 0x30, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x37, 0x62, 0x35, 0x65, 0x34, 0x64, 0x31, 0x66, 0x35, 0x37, 0x32, 0x62, 0x65, 0x63, 0x66, 0x32, 0x63, 0x30, 0x30, 0x66, 0x63, 0x39, 0x30, 0x63, 0x62, 0x34, 0x37, 0x36, 0x37, 0x62, 0x34, 0x61, 0x36, 0x65, 0x33, 0x33, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x62, 0x64, 0x31, 0x38, 0x35, 0x35, 0x38, 0x39, 0x66, 0x37, 0x61, 0x36, 0x38, 0x61, 0x36, 0x37, 0x61, 0x61, 0x34, 0x62, 0x31, 0x62, 0x64, 0x36, 0x35, 0x30, 0x37, 0x37, 0x66, 0x38, 0x63, 0x36, 0x34, 0x65, 0x34, 0x65, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x37, 0x38, 0x35, 0x34, 0x31, 0x37, 0x35, 0x36, 0x61, 0x62, 0x32, 0x62, 0x37, 0x30, 0x36, 0x65, 0x30, 0x64, 0x37, 0x30, 0x62, 0x31, 0x38, 0x61, 0x64, 0x62, 0x37, 0x30, 0x30, 0x66, 0x63, 0x34, 0x66, 0x31, 0x36, 0x34, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x30, 0x65, 0x63, 0x33, 0x64, 0x62, 0x38, 0x30, 0x34, 0x36, 0x39, 0x32, 0x64, 0x34, 0x64, 0x31, 0x65, 0x61, 0x33, 0x32, 0x34, 0x35, 0x33, 0x36, 0x35, 0x61, 0x61, 0x62, 0x30, 0x35, 0x39, 0x30, 0x30, 0x37, 0x35, 0x62, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x39, 0x31, 0x38, 0x30, 0x33, 0x32, 0x34, 0x33, 0x39, 0x31, 0x35, 0x39, 0x62, 0x62, 0x33, 0x31, 0x35, 0x62, 0x36, 0x37, 0x32, 0x35, 0x62, 0x36, 0x38, 0x33, 0x30, 0x64, 0x63, 0x38, 0x33, 0x36, 0x39, 0x37, 0x37, 0x33, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x31, 0x62, 0x30, 0x32, 0x31, 0x61, 0x37, 0x38, 0x66, 0x64, 0x65, 0x34, 0x32, 0x64, 0x39, 0x62, 0x35, 0x32, 0x32, 0x36, 0x64, 0x36, 0x65, 0x63, 0x32, 0x36, 0x65, 0x30, 0x36, 0x61, 0x61, 0x33, 0x36, 0x37, 0x30, 0x30, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x32, 0x35, 0x32, 0x33, 0x63, 0x63, 0x38, 0x33, 0x34, 0x66, 0x30, 0x30, 0x38, 0x36, 0x30, 0x35, 0x32, 0x34, 0x30, 0x32, 0x36, 0x32, 0x36, 0x32, 0x39, 0x36, 0x36, 0x37, 0x35, 0x31, 0x38, 0x36, 0x61, 0x38, 0x65, 0x35, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x62, 0x32, 0x65, 0x31, 0x35, 0x63, 0x61, 0x36, 0x38, 0x31, 0x66, 0x34, 0x63, 0x36, 0x36, 0x30, 0x34, 0x38, 0x66, 0x36, 0x66, 0x39, 0x62, 0x37, 0x39, 0x34, 0x31, 0x65, 0x64, 0x30, 0x38, 0x62, 0x31, 0x66, 0x66, 0x35, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x62, 0x39, 0x61, 0x39, 0x65, 0x36, 0x62, 0x64, 0x38, 0x38, 0x38, 0x30, 0x64, 0x39, 0x39, 0x39, 0x34, 0x61, 0x65, 0x30, 0x30, 0x64, 0x64, 0x30, 0x62, 0x39, 0x32, 0x38, 0x32, 0x61, 0x30, 0x62, 0x65, 0x61, 0x62, 0x38, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x64, 0x64, 0x62, 0x63, 0x38, 0x31, 0x33, 0x34, 0x66, 0x37, 0x37, 0x64, 0x35, 0x35, 0x35, 0x39, 0x37, 0x66, 0x63, 0x39, 0x37, 0x63, 0x32, 0x36, 0x64, 0x32, 0x36, 0x36, 0x39, 0x38, 0x30, 0x39, 0x30, 0x36, 0x30, 0x34, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x63, 0x33, 0x61, 0x39, 0x66, 0x36, 0x39, 0x35, 0x62, 0x31, 0x36, 0x64, 0x62, 0x31, 0x35, 0x39, 0x37, 0x32, 0x38, 0x36, 0x64, 0x31, 0x62, 0x33, 0x61, 0x38, 0x62, 0x37, 0x36, 0x39, 0x36, 0x63, 0x33, 0x39, 0x66, 0x61, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x31, 0x39, 0x34, 0x64, 0x38, 0x61, 0x66, 0x61, 0x33, 0x65, 0x38, 0x38, 0x33, 0x35, 0x30, 0x32, 0x37, 0x36, 0x37, 0x65, 0x64, 0x62, 0x63, 0x33, 0x30, 0x35, 0x38, 0x36, 0x61, 0x66, 0x33, 0x33, 0x62, 0x31, 0x31, 0x34, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x65, 0x66, 0x64, 0x30, 0x61, 0x39, 0x62, 0x63, 0x34, 0x30, 0x37, 0x65, 0x63, 0x65, 0x30, 0x33, 0x64, 0x36, 0x37, 0x65, 0x38, 0x65, 0x63, 0x38, 0x65, 0x39, 0x64, 0x32, 0x38, 0x33, 0x66, 0x34, 0x38, 0x64, 0x32, 0x61, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x62, 0x34, 0x35, 0x30, 0x39, 0x32, 0x30, 0x30, 0x37, 0x38, 0x61, 0x61, 0x62, 0x32, 0x33, 0x31, 0x37, 0x63, 0x37, 0x64, 0x62, 0x33, 0x62, 0x33, 0x38, 0x61, 0x66, 0x37, 0x64, 0x64, 0x32, 0x39, 0x38, 0x62, 0x32, 0x64, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x38, 0x32, 0x37, 0x36, 0x63, 0x34, 0x37, 0x37, 0x62, 0x34, 0x61, 0x30, 0x37, 0x62, 0x38, 0x30, 0x31, 0x30, 0x37, 0x62, 0x38, 0x34, 0x33, 0x35, 0x39, 0x34, 0x31, 0x38, 0x39, 0x36, 0x30, 0x37, 0x62, 0x35, 0x33, 0x62, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x37, 0x66, 0x34, 0x32, 0x31, 0x30, 0x61, 0x62, 0x35, 0x38, 0x30, 0x34, 0x39, 0x34, 0x30, 0x61, 0x30, 0x62, 0x37, 0x64, 0x62, 0x38, 0x63, 0x31, 0x34, 0x63, 0x32, 0x38, 0x33, 0x39, 0x36, 0x62, 0x36, 0x32, 0x61, 0x36, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x64, 0x66, 0x33, 0x62, 0x35, 0x33, 0x63, 0x62, 0x33, 0x62, 0x34, 0x37, 0x35, 0x35, 0x64, 0x65, 0x35, 0x34, 0x65, 0x31, 0x38, 0x30, 0x34, 0x35, 0x31, 0x63, 0x63, 0x34, 0x34, 0x63, 0x39, 0x65, 0x38, 0x61, 0x65, 0x30, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x39, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x63, 0x37, 0x30, 0x38, 0x30, 0x31, 0x35, 0x30, 0x37, 0x31, 0x64, 0x34, 0x66, 0x62, 0x30, 0x61, 0x33, 0x61, 0x32, 0x61, 0x30, 0x39, 0x61, 0x34, 0x35, 0x64, 0x31, 0x35, 0x36, 0x33, 0x39, 0x36, 0x65, 0x33, 0x33, 0x34, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x63, 0x61, 0x66, 0x61, 0x63, 0x33, 0x32, 0x32, 0x38, 0x30, 0x64, 0x30, 0x32, 0x31, 0x30, 0x32, 0x30, 0x62, 0x66, 0x36, 0x66, 0x32, 0x61, 0x39, 0x37, 0x38, 0x32, 0x38, 0x38, 0x33, 0x64, 0x37, 0x61, 0x61, 0x62, 0x65, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x39, 0x61, 0x61, 0x36, 0x66, 0x35, 0x64, 0x30, 0x37, 0x38, 0x63, 0x62, 0x30, 0x39, 0x37, 0x30, 0x38, 0x38, 0x32, 0x62, 0x63, 0x39, 0x39, 0x39, 0x32, 0x30, 0x30, 0x36, 0x66, 0x38, 0x66, 0x62, 0x64, 0x66, 0x33, 0x34, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x36, 0x36, 0x39, 0x31, 0x38, 0x30, 0x64, 0x65, 0x65, 0x32, 0x39, 0x35, 0x39, 0x38, 0x38, 0x36, 0x39, 0x62, 0x30, 0x38, 0x61, 0x37, 0x32, 0x31, 0x63, 0x37, 0x64, 0x32, 0x34, 0x63, 0x34, 0x63, 0x30, 0x65, 0x65, 0x36, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x61, 0x38, 0x61, 0x62, 0x32, 0x32, 0x64, 0x32, 0x66, 0x65, 0x64, 0x62, 0x63, 0x66, 0x63, 0x36, 0x33, 0x66, 0x36, 0x38, 0x34, 0x63, 0x30, 0x38, 0x61, 0x66, 0x64, 0x66, 0x31, 0x63, 0x31, 0x37, 0x35, 0x30, 0x39, 0x30, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x35, 0x61, 0x34, 0x34, 0x31, 0x39, 0x37, 0x34, 0x61, 0x38, 0x33, 0x64, 0x37, 0x34, 0x63, 0x36, 0x38, 0x37, 0x65, 0x62, 0x64, 0x63, 0x36, 0x33, 0x33, 0x66, 0x62, 0x31, 0x61, 0x34, 0x39, 0x65, 0x37, 0x62, 0x31, 0x61, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x62, 0x37, 0x36, 0x39, 0x63, 0x63, 0x33, 0x30, 0x35, 0x63, 0x65, 0x63, 0x66, 0x62, 0x36, 0x32, 0x39, 0x61, 0x30, 0x30, 0x63, 0x39, 0x30, 0x37, 0x30, 0x36, 0x39, 0x64, 0x37, 0x65, 0x66, 0x39, 0x62, 0x63, 0x33, 0x61, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x32, 0x30, 0x63, 0x37, 0x31, 0x31, 0x66, 0x30, 0x37, 0x37, 0x30, 0x35, 0x32, 0x37, 0x33, 0x38, 0x30, 0x37, 0x61, 0x61, 0x61, 0x61, 0x36, 0x64, 0x65, 0x34, 0x34, 0x64, 0x30, 0x65, 0x34, 0x62, 0x34, 0x38, 0x62, 0x65, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x61, 0x61, 0x37, 0x64, 0x38, 0x36, 0x64, 0x64, 0x66, 0x62, 0x61, 0x64, 0x33, 0x30, 0x31, 0x36, 0x39, 0x32, 0x66, 0x65, 0x61, 0x63, 0x38, 0x61, 0x30, 0x38, 0x66, 0x38, 0x34, 0x31, 0x63, 0x62, 0x32, 0x31, 0x35, 0x63, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x66, 0x35, 0x64, 0x33, 0x36, 0x31, 0x62, 0x35, 0x32, 0x61, 0x64, 0x30, 0x62, 0x36, 0x38, 0x62, 0x31, 0x35, 0x38, 0x38, 0x36, 0x30, 0x37, 0x65, 0x63, 0x33, 0x30, 0x34, 0x61, 0x65, 0x35, 0x36, 0x36, 0x35, 0x66, 0x63, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x38, 0x32, 0x61, 0x39, 0x64, 0x34, 0x38, 0x65, 0x63, 0x38, 0x33, 0x65, 0x61, 0x33, 0x36, 0x35, 0x32, 0x38, 0x39, 0x30, 0x66, 0x64, 0x30, 0x65, 0x65, 0x37, 0x39, 0x63, 0x39, 0x30, 0x37, 0x62, 0x35, 0x62, 0x32, 0x64, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x61, 0x31, 0x34, 0x34, 0x62, 0x31, 0x65, 0x61, 0x36, 0x37, 0x62, 0x39, 0x35, 0x31, 0x30, 0x66, 0x32, 0x32, 0x36, 0x37, 0x66, 0x39, 0x64, 0x61, 0x33, 0x39, 0x64, 0x33, 0x66, 0x39, 0x33, 0x64, 0x65, 0x32, 0x36, 0x36, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x65, 0x32, 0x30, 0x65, 0x62, 0x34, 0x64, 0x65, 0x31, 0x38, 0x62, 0x64, 0x30, 0x36, 0x30, 0x32, 0x32, 0x31, 0x36, 0x38, 0x39, 0x38, 0x39, 0x34, 0x62, 0x65, 0x65, 0x35, 0x61, 0x65, 0x62, 0x32, 0x35, 0x33, 0x35, 0x31, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x35, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x31, 0x61, 0x30, 0x61, 0x36, 0x34, 0x66, 0x39, 0x61, 0x66, 0x63, 0x63, 0x34, 0x34, 0x38, 0x61, 0x38, 0x61, 0x31, 0x33, 0x30, 0x64, 0x34, 0x64, 0x66, 0x63, 0x62, 0x65, 0x65, 0x38, 0x39, 0x35, 0x33, 0x37, 0x64, 0x38, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x38, 0x32, 0x36, 0x66, 0x62, 0x33, 0x63, 0x30, 0x31, 0x32, 0x62, 0x30, 0x64, 0x31, 0x35, 0x39, 0x65, 0x32, 0x39, 0x34, 0x62, 0x61, 0x35, 0x62, 0x38, 0x61, 0x34, 0x39, 0x39, 0x66, 0x66, 0x33, 0x63, 0x30, 0x65, 0x30, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x66, 0x62, 0x37, 0x62, 0x30, 0x31, 0x33, 0x61, 0x61, 0x31, 0x66, 0x38, 0x35, 0x34, 0x31, 0x63, 0x37, 0x65, 0x33, 0x32, 0x37, 0x62, 0x66, 0x36, 0x35, 0x30, 0x61, 0x64, 0x62, 0x64, 0x31, 0x39, 0x34, 0x63, 0x32, 0x30, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x65, 0x62, 0x35, 0x32, 0x33, 0x65, 0x38, 0x33, 0x32, 0x66, 0x35, 0x30, 0x30, 0x61, 0x30, 0x31, 0x37, 0x64, 0x65, 0x31, 0x33, 0x65, 0x63, 0x32, 0x37, 0x66, 0x35, 0x64, 0x33, 0x36, 0x36, 0x63, 0x35, 0x36, 0x30, 0x65, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x62, 0x66, 0x31, 0x37, 0x63, 0x34, 0x63, 0x31, 0x31, 0x66, 0x39, 0x38, 0x39, 0x34, 0x31, 0x66, 0x35, 0x30, 0x37, 0x65, 0x37, 0x37, 0x30, 0x38, 0x34, 0x66, 0x66, 0x66, 0x62, 0x64, 0x32, 0x64, 0x62, 0x64, 0x33, 0x64, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x30, 0x65, 0x63, 0x38, 0x33, 0x65, 0x61, 0x39, 0x33, 0x36, 0x32, 0x31, 0x66, 0x30, 0x33, 0x34, 0x65, 0x37, 0x62, 0x62, 0x33, 0x37, 0x36, 0x32, 0x62, 0x62, 0x38, 0x65, 0x32, 0x39, 0x64, 0x65, 0x64, 0x34, 0x63, 0x34, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x39, 0x63, 0x35, 0x31, 0x31, 0x38, 0x36, 0x34, 0x61, 0x31, 0x37, 0x37, 0x66, 0x34, 0x39, 0x62, 0x65, 0x37, 0x38, 0x32, 0x30, 0x32, 0x37, 0x37, 0x33, 0x66, 0x36, 0x30, 0x34, 0x38, 0x39, 0x66, 0x65, 0x30, 0x34, 0x65, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x66, 0x31, 0x61, 0x34, 0x34, 0x33, 0x30, 0x39, 0x30, 0x35, 0x31, 0x63, 0x36, 0x62, 0x32, 0x35, 0x65, 0x34, 0x37, 0x64, 0x66, 0x66, 0x39, 0x30, 0x39, 0x62, 0x31, 0x37, 0x39, 0x62, 0x62, 0x39, 0x61, 0x62, 0x35, 0x39, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x66, 0x65, 0x36, 0x62, 0x63, 0x63, 0x34, 0x62, 0x38, 0x61, 0x39, 0x38, 0x35, 0x30, 0x61, 0x62, 0x62, 0x65, 0x37, 0x35, 0x38, 0x30, 0x33, 0x37, 0x33, 0x30, 0x63, 0x39, 0x33, 0x32, 0x32, 0x35, 0x31, 0x66, 0x31, 0x34, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x38, 0x62, 0x35, 0x38, 0x64, 0x62, 0x33, 0x37, 0x34, 0x32, 0x30, 0x62, 0x34, 0x36, 0x34, 0x63, 0x30, 0x62, 0x65, 0x38, 0x38, 0x62, 0x34, 0x35, 0x65, 0x65, 0x32, 0x62, 0x39, 0x35, 0x32, 0x39, 0x30, 0x66, 0x38, 0x63, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x34, 0x64, 0x33, 0x32, 0x31, 0x31, 0x37, 0x37, 0x32, 0x35, 0x36, 0x65, 0x62, 0x64, 0x39, 0x61, 0x66, 0x62, 0x64, 0x61, 0x33, 0x30, 0x34, 0x31, 0x33, 0x35, 0x64, 0x35, 0x31, 0x37, 0x63, 0x33, 0x64, 0x63, 0x35, 0x36, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x31, 0x66, 0x62, 0x65, 0x35, 0x66, 0x30, 0x61, 0x65, 0x61, 0x33, 0x35, 0x39, 0x63, 0x35, 0x61, 0x61, 0x31, 0x66, 0x61, 0x30, 0x38, 0x63, 0x38, 0x38, 0x39, 0x35, 0x34, 0x31, 0x32, 0x63, 0x61, 0x38, 0x65, 0x30, 0x35, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x30, 0x64, 0x64, 0x37, 0x63, 0x66, 0x34, 0x65, 0x35, 0x64, 0x38, 0x36, 0x36, 0x31, 0x66, 0x36, 0x30, 0x32, 0x38, 0x39, 0x34, 0x33, 0x61, 0x34, 0x62, 0x39, 0x62, 0x37, 0x35, 0x63, 0x39, 0x31, 0x34, 0x34, 0x33, 0x36, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x39, 0x37, 0x39, 0x61, 0x39, 0x32, 0x37, 0x36, 0x30, 0x61, 0x31, 0x33, 0x35, 0x61, 0x64, 0x66, 0x36, 0x39, 0x64, 0x37, 0x32, 0x66, 0x37, 0x35, 0x65, 0x31, 0x36, 0x37, 0x37, 0x35, 0x35, 0x66, 0x31, 0x63, 0x62, 0x38, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x32, 0x32, 0x63, 0x64, 0x61, 0x33, 0x36, 0x30, 0x36, 0x64, 0x61, 0x35, 0x63, 0x61, 0x64, 0x30, 0x31, 0x33, 0x62, 0x38, 0x30, 0x37, 0x34, 0x37, 0x30, 0x36, 0x64, 0x37, 0x65, 0x39, 0x65, 0x37, 0x32, 0x31, 0x61, 0x35, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x37, 0x35, 0x35, 0x39, 0x61, 0x64, 0x63, 0x35, 0x35, 0x37, 0x36, 0x34, 0x63, 0x63, 0x36, 0x64, 0x66, 0x37, 0x39, 0x33, 0x32, 0x33, 0x30, 0x39, 0x32, 0x35, 0x33, 0x34, 0x65, 0x33, 0x64, 0x36, 0x36, 0x34, 0x35, 0x61, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x35, 0x32, 0x61, 0x64, 0x36, 0x31, 0x37, 0x30, 0x64, 0x32, 0x35, 0x62, 0x32, 0x61, 0x32, 0x65, 0x38, 0x35, 0x30, 0x65, 0x61, 0x64, 0x62, 0x62, 0x35, 0x32, 0x34, 0x31, 0x33, 0x66, 0x66, 0x32, 0x33, 0x30, 0x33, 0x65, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x64, 0x32, 0x38, 0x63, 0x33, 0x66, 0x30, 0x36, 0x38, 0x65, 0x30, 0x39, 0x34, 0x61, 0x33, 0x30, 0x34, 0x62, 0x38, 0x35, 0x33, 0x63, 0x39, 0x35, 0x30, 0x61, 0x36, 0x38, 0x30, 0x39, 0x65, 0x62, 0x63, 0x62, 0x30, 0x33, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x34, 0x37, 0x66, 0x32, 0x38, 0x37, 0x66, 0x34, 0x39, 0x38, 0x32, 0x33, 0x33, 0x37, 0x31, 0x33, 0x38, 0x35, 0x30, 0x64, 0x33, 0x31, 0x32, 0x36, 0x38, 0x32, 0x33, 0x63, 0x63, 0x36, 0x37, 0x64, 0x63, 0x65, 0x65, 0x32, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x33, 0x35, 0x39, 0x65, 0x35, 0x38, 0x61, 0x31, 0x33, 0x64, 0x34, 0x35, 0x37, 0x38, 0x61, 0x39, 0x33, 0x33, 0x38, 0x65, 0x33, 0x33, 0x35, 0x63, 0x36, 0x37, 0x65, 0x37, 0x36, 0x33, 0x39, 0x66, 0x35, 0x66, 0x62, 0x34, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x36, 0x38, 0x61, 0x32, 0x63, 0x65, 0x64, 0x62, 0x34, 0x35, 0x37, 0x35, 0x35, 0x35, 0x61, 0x31, 0x33, 0x39, 0x32, 0x39, 0x35, 0x61, 0x65, 0x61, 0x32, 0x38, 0x37, 0x37, 0x36, 0x65, 0x35, 0x34, 0x30, 0x30, 0x33, 0x63, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x39, 0x32, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x34, 0x31, 0x33, 0x37, 0x34, 0x62, 0x30, 0x66, 0x65, 0x65, 0x66, 0x34, 0x37, 0x39, 0x32, 0x65, 0x34, 0x62, 0x33, 0x33, 0x36, 0x39, 0x31, 0x66, 0x62, 0x38, 0x36, 0x38, 0x39, 0x37, 0x61, 0x34, 0x66, 0x66, 0x35, 0x36, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x65, 0x34, 0x38, 0x30, 0x35, 0x35, 0x33, 0x32, 0x37, 0x63, 0x32, 0x38, 0x62, 0x35, 0x39, 0x33, 0x36, 0x66, 0x64, 0x39, 0x66, 0x34, 0x34, 0x34, 0x37, 0x65, 0x37, 0x33, 0x62, 0x64, 0x62, 0x32, 0x64, 0x64, 0x33, 0x33, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x62, 0x37, 0x66, 0x65, 0x65, 0x62, 0x63, 0x35, 0x63, 0x35, 0x39, 0x62, 0x66, 0x36, 0x35, 0x65, 0x38, 0x36, 0x31, 0x63, 0x34, 0x63, 0x30, 0x62, 0x65, 0x34, 0x32, 0x61, 0x37, 0x36, 0x31, 0x31, 0x61, 0x35, 0x35, 0x34, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x61, 0x36, 0x64, 0x62, 0x36, 0x35, 0x32, 0x37, 0x34, 0x36, 0x37, 0x62, 0x63, 0x36, 0x64, 0x61, 0x64, 0x35, 0x34, 0x62, 0x63, 0x31, 0x36, 0x65, 0x39, 0x66, 0x65, 0x32, 0x39, 0x35, 0x33, 0x62, 0x36, 0x37, 0x39, 0x34, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x65, 0x61, 0x64, 0x31, 0x62, 0x62, 0x39, 0x30, 0x63, 0x63, 0x63, 0x33, 0x61, 0x65, 0x61, 0x32, 0x62, 0x30, 0x64, 0x63, 0x63, 0x35, 0x62, 0x35, 0x38, 0x30, 0x35, 0x36, 0x35, 0x35, 0x34, 0x36, 0x35, 0x35, 0x64, 0x31, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x39, 0x34, 0x62, 0x31, 0x39, 0x39, 0x39, 0x32, 0x63, 0x65, 0x62, 0x38, 0x63, 0x65, 0x36, 0x33, 0x62, 0x63, 0x39, 0x32, 0x65, 0x65, 0x34, 0x62, 0x35, 0x61, 0x64, 0x65, 0x64, 0x31, 0x30, 0x63, 0x34, 0x64, 0x39, 0x37, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x65, 0x39, 0x33, 0x65, 0x34, 0x64, 0x63, 0x31, 0x37, 0x31, 0x32, 0x31, 0x34, 0x38, 0x37, 0x39, 0x35, 0x32, 0x33, 0x33, 0x33, 0x36, 0x31, 0x34, 0x30, 0x30, 0x32, 0x62, 0x65, 0x34, 0x32, 0x33, 0x35, 0x36, 0x34, 0x39, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x62, 0x30, 0x30, 0x61, 0x62, 0x66, 0x35, 0x38, 0x32, 0x38, 0x64, 0x37, 0x65, 0x62, 0x66, 0x32, 0x36, 0x62, 0x34, 0x37, 0x63, 0x65, 0x61, 0x63, 0x63, 0x64, 0x62, 0x38, 0x62, 0x61, 0x30, 0x33, 0x33, 0x32, 0x35, 0x31, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x39, 0x61, 0x62, 0x32, 0x36, 0x33, 0x38, 0x62, 0x31, 0x63, 0x66, 0x64, 0x36, 0x35, 0x34, 0x64, 0x32, 0x35, 0x64, 0x61, 0x62, 0x30, 0x31, 0x38, 0x61, 0x30, 0x61, 0x65, 0x62, 0x64, 0x64, 0x66, 0x38, 0x35, 0x66, 0x64, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x32, 0x65, 0x64, 0x30, 0x37, 0x62, 0x38, 0x61, 0x33, 0x38, 0x61, 0x64, 0x35, 0x35, 0x30, 0x36, 0x33, 0x36, 0x33, 0x66, 0x63, 0x30, 0x37, 0x61, 0x30, 0x62, 0x36, 0x64, 0x37, 0x39, 0x39, 0x39, 0x33, 0x36, 0x62, 0x64, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x61, 0x39, 0x64, 0x30, 0x30, 0x63, 0x65, 0x66, 0x61, 0x39, 0x37, 0x62, 0x37, 0x61, 0x35, 0x38, 0x65, 0x66, 0x39, 0x34, 0x31, 0x37, 0x66, 0x63, 0x36, 0x32, 0x36, 0x37, 0x61, 0x35, 0x30, 0x36, 0x39, 0x30, 0x33, 0x39, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x61, 0x31, 0x63, 0x61, 0x64, 0x61, 0x31, 0x63, 0x63, 0x37, 0x35, 0x31, 0x30, 0x38, 0x32, 0x66, 0x66, 0x38, 0x64, 0x61, 0x39, 0x32, 0x38, 0x65, 0x33, 0x63, 0x66, 0x61, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x61, 0x39, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x31, 0x38, 0x63, 0x63, 0x31, 0x66, 0x34, 0x38, 0x64, 0x32, 0x33, 0x30, 0x38, 0x65, 0x32, 0x35, 0x32, 0x61, 0x62, 0x36, 0x30, 0x38, 0x39, 0x66, 0x62, 0x39, 0x39, 0x61, 0x37, 0x63, 0x31, 0x64, 0x35, 0x36, 0x39, 0x34, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x35, 0x64, 0x36, 0x39, 0x34, 0x65, 0x38, 0x38, 0x30, 0x62, 0x31, 0x33, 0x63, 0x63, 0x64, 0x30, 0x38, 0x34, 0x38, 0x61, 0x38, 0x36, 0x63, 0x35, 0x63, 0x65, 0x34, 0x31, 0x31, 0x66, 0x38, 0x38, 0x34, 0x37, 0x36, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x61, 0x37, 0x66, 0x37, 0x32, 0x38, 0x36, 0x37, 0x61, 0x37, 0x64, 0x63, 0x38, 0x36, 0x37, 0x37, 0x30, 0x62, 0x31, 0x36, 0x32, 0x62, 0x37, 0x35, 0x35, 0x37, 0x61, 0x34, 0x33, 0x34, 0x65, 0x64, 0x35, 0x30, 0x63, 0x63, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x65, 0x61, 0x31, 0x30, 0x34, 0x34, 0x35, 0x38, 0x32, 0x37, 0x65, 0x66, 0x31, 0x65, 0x35, 0x30, 0x32, 0x64, 0x61, 0x66, 0x37, 0x36, 0x62, 0x39, 0x32, 0x38, 0x61, 0x32, 0x30, 0x39, 0x65, 0x30, 0x64, 0x34, 0x30, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x35, 0x33, 0x61, 0x61, 0x32, 0x33, 0x62, 0x36, 0x38, 0x61, 0x61, 0x35, 0x66, 0x35, 0x37, 0x65, 0x31, 0x33, 0x35, 0x66, 0x65, 0x33, 0x39, 0x66, 0x64, 0x63, 0x32, 0x33, 0x35, 0x65, 0x61, 0x63, 0x61, 0x38, 0x63, 0x39, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x62, 0x34, 0x33, 0x62, 0x30, 0x31, 0x35, 0x64, 0x30, 0x30, 0x38, 0x31, 0x36, 0x34, 0x33, 0x63, 0x36, 0x63, 0x64, 0x61, 0x34, 0x36, 0x61, 0x37, 0x30, 0x37, 0x33, 0x61, 0x36, 0x64, 0x66, 0x64, 0x62, 0x63, 0x61, 0x38, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x32, 0x66, 0x64, 0x39, 0x66, 0x64, 0x66, 0x36, 0x39, 0x39, 0x36, 0x62, 0x65, 0x64, 0x61, 0x64, 0x32, 0x38, 0x34, 0x33, 0x31, 0x35, 0x39, 0x63, 0x30, 0x36, 0x66, 0x33, 0x37, 0x65, 0x30, 0x39, 0x32, 0x34, 0x33, 0x33, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x61, 0x34, 0x65, 0x62, 0x33, 0x36, 0x61, 0x37, 0x65, 0x34, 0x39, 0x38, 0x63, 0x33, 0x36, 0x66, 0x39, 0x39, 0x39, 0x37, 0x35, 0x63, 0x31, 0x61, 0x38, 0x64, 0x37, 0x32, 0x39, 0x66, 0x64, 0x36, 0x62, 0x33, 0x30, 0x35, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x64, 0x36, 0x36, 0x65, 0x61, 0x36, 0x32, 0x38, 0x38, 0x66, 0x61, 0x61, 0x34, 0x62, 0x33, 0x64, 0x36, 0x30, 0x36, 0x63, 0x32, 0x61, 0x61, 0x34, 0x35, 0x63, 0x37, 0x62, 0x36, 0x62, 0x38, 0x61, 0x32, 0x35, 0x32, 0x37, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x61, 0x34, 0x30, 0x32, 0x34, 0x33, 0x38, 0x65, 0x30, 0x35, 0x31, 0x39, 0x37, 0x37, 0x33, 0x64, 0x35, 0x34, 0x34, 0x38, 0x33, 0x32, 0x36, 0x62, 0x66, 0x62, 0x36, 0x31, 0x66, 0x38, 0x62, 0x32, 0x30, 0x63, 0x66, 0x35, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x66, 0x61, 0x66, 0x64, 0x64, 0x33, 0x30, 0x61, 0x63, 0x62, 0x36, 0x64, 0x36, 0x37, 0x30, 0x36, 0x65, 0x39, 0x32, 0x39, 0x33, 0x63, 0x62, 0x30, 0x32, 0x36, 0x34, 0x31, 0x66, 0x39, 0x65, 0x64, 0x62, 0x65, 0x30, 0x37, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x34, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x64, 0x62, 0x61, 0x32, 0x35, 0x36, 0x34, 0x37, 0x32, 0x64, 0x62, 0x34, 0x65, 0x30, 0x35, 0x38, 0x66, 0x32, 0x65, 0x34, 0x63, 0x64, 0x63, 0x33, 0x65, 0x61, 0x34, 0x65, 0x38, 0x61, 0x34, 0x32, 0x37, 0x37, 0x33, 0x38, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x38, 0x61, 0x62, 0x64, 0x65, 0x62, 0x31, 0x34, 0x63, 0x32, 0x36, 0x62, 0x37, 0x62, 0x37, 0x32, 0x33, 0x34, 0x64, 0x37, 0x30, 0x66, 0x63, 0x65, 0x61, 0x65, 0x66, 0x33, 0x36, 0x31, 0x61, 0x37, 0x36, 0x64, 0x66, 0x66, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x37, 0x33, 0x32, 0x34, 0x32, 0x64, 0x37, 0x35, 0x63, 0x61, 0x39, 0x61, 0x64, 0x35, 0x35, 0x38, 0x64, 0x36, 0x35, 0x30, 0x32, 0x39, 0x30, 0x64, 0x66, 0x31, 0x37, 0x36, 0x39, 0x32, 0x64, 0x35, 0x34, 0x63, 0x64, 0x38, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x63, 0x33, 0x36, 0x35, 0x39, 0x35, 0x37, 0x31, 0x62, 0x31, 0x31, 0x66, 0x38, 0x38, 0x39, 0x64, 0x64, 0x34, 0x33, 0x39, 0x62, 0x63, 0x64, 0x34, 0x64, 0x36, 0x37, 0x35, 0x31, 0x30, 0x61, 0x32, 0x35, 0x62, 0x65, 0x35, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x30, 0x39, 0x38, 0x36, 0x33, 0x33, 0x65, 0x65, 0x65, 0x65, 0x30, 0x63, 0x63, 0x65, 0x66, 0x64, 0x66, 0x36, 0x33, 0x32, 0x66, 0x39, 0x35, 0x37, 0x35, 0x34, 0x35, 0x36, 0x66, 0x36, 0x64, 0x64, 0x38, 0x30, 0x66, 0x63, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x61, 0x35, 0x31, 0x66, 0x63, 0x65, 0x34, 0x61, 0x31, 0x64, 0x35, 0x62, 0x39, 0x34, 0x62, 0x30, 0x37, 0x31, 0x38, 0x33, 0x38, 0x39, 0x62, 0x61, 0x34, 0x65, 0x37, 0x38, 0x31, 0x34, 0x31, 0x33, 0x39, 0x63, 0x61, 0x37, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x35, 0x36, 0x31, 0x62, 0x34, 0x31, 0x62, 0x32, 0x30, 0x39, 0x66, 0x32, 0x34, 0x38, 0x63, 0x38, 0x61, 0x39, 0x39, 0x66, 0x38, 0x35, 0x38, 0x37, 0x38, 0x38, 0x33, 0x37, 0x36, 0x32, 0x35, 0x30, 0x36, 0x30, 0x39, 0x63, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x64, 0x30, 0x66, 0x34, 0x64, 0x37, 0x32, 0x38, 0x65, 0x62, 0x65, 0x38, 0x32, 0x65, 0x38, 0x34, 0x62, 0x66, 0x35, 0x39, 0x37, 0x35, 0x31, 0x35, 0x61, 0x64, 0x34, 0x31, 0x62, 0x36, 0x30, 0x62, 0x66, 0x32, 0x38, 0x62, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x64, 0x66, 0x34, 0x33, 0x33, 0x39, 0x33, 0x63, 0x36, 0x34, 0x39, 0x63, 0x61, 0x65, 0x62, 0x65, 0x31, 0x62, 0x62, 0x31, 0x38, 0x30, 0x35, 0x39, 0x64, 0x65, 0x63, 0x62, 0x33, 0x39, 0x66, 0x30, 0x39, 0x66, 0x62, 0x34, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x38, 0x39, 0x35, 0x30, 0x38, 0x36, 0x37, 0x39, 0x61, 0x62, 0x66, 0x38, 0x63, 0x37, 0x31, 0x62, 0x66, 0x36, 0x37, 0x38, 0x31, 0x36, 0x38, 0x37, 0x31, 0x32, 0x30, 0x65, 0x33, 0x65, 0x36, 0x61, 0x38, 0x34, 0x35, 0x38, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x39, 0x30, 0x37, 0x66, 0x35, 0x39, 0x33, 0x31, 0x34, 0x38, 0x62, 0x35, 0x37, 0x63, 0x34, 0x36, 0x63, 0x31, 0x37, 0x37, 0x65, 0x32, 0x33, 0x64, 0x32, 0x35, 0x61, 0x62, 0x63, 0x34, 0x61, 0x61, 0x65, 0x31, 0x38, 0x33, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x66, 0x63, 0x63, 0x65, 0x61, 0x64, 0x66, 0x65, 0x35, 0x63, 0x31, 0x30, 0x39, 0x63, 0x35, 0x65, 0x61, 0x65, 0x61, 0x66, 0x34, 0x36, 0x32, 0x64, 0x34, 0x33, 0x38, 0x37, 0x33, 0x31, 0x34, 0x32, 0x63, 0x38, 0x38, 0x65, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x39, 0x32, 0x34, 0x39, 0x37, 0x33, 0x38, 0x62, 0x37, 0x65, 0x63, 0x65, 0x64, 0x37, 0x63, 0x62, 0x36, 0x36, 0x36, 0x61, 0x36, 0x36, 0x33, 0x63, 0x34, 0x39, 0x63, 0x62, 0x66, 0x36, 0x64, 0x65, 0x38, 0x33, 0x34, 0x33, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x63, 0x39, 0x39, 0x62, 0x61, 0x30, 0x38, 0x37, 0x34, 0x34, 0x38, 0x65, 0x31, 0x39, 0x63, 0x39, 0x37, 0x30, 0x31, 0x64, 0x66, 0x36, 0x36, 0x65, 0x30, 0x63, 0x61, 0x62, 0x35, 0x32, 0x33, 0x36, 0x38, 0x33, 0x33, 0x31, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x38, 0x65, 0x30, 0x63, 0x33, 0x30, 0x63, 0x62, 0x61, 0x33, 0x62, 0x63, 0x35, 0x61, 0x38, 0x38, 0x33, 0x65, 0x35, 0x34, 0x30, 0x33, 0x32, 0x30, 0x66, 0x39, 0x39, 0x39, 0x63, 0x37, 0x63, 0x64, 0x35, 0x35, 0x38, 0x65, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x39, 0x38, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x38, 0x38, 0x38, 0x61, 0x35, 0x37, 0x62, 0x64, 0x39, 0x36, 0x38, 0x37, 0x63, 0x62, 0x66, 0x39, 0x35, 0x30, 0x61, 0x65, 0x65, 0x61, 0x63, 0x66, 0x39, 0x37, 0x34, 0x30, 0x64, 0x63, 0x63, 0x34, 0x64, 0x31, 0x65, 0x66, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x62, 0x33, 0x36, 0x66, 0x65, 0x39, 0x62, 0x35, 0x31, 0x34, 0x31, 0x32, 0x64, 0x64, 0x63, 0x61, 0x31, 0x61, 0x35, 0x32, 0x31, 0x64, 0x36, 0x65, 0x39, 0x34, 0x62, 0x63, 0x39, 0x30, 0x31, 0x32, 0x31, 0x33, 0x64, 0x64, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x31, 0x34, 0x35, 0x30, 0x34, 0x36, 0x66, 0x61, 0x33, 0x36, 0x32, 0x38, 0x63, 0x66, 0x35, 0x66, 0x64, 0x34, 0x63, 0x36, 0x31, 0x33, 0x39, 0x32, 0x37, 0x62, 0x65, 0x35, 0x33, 0x31, 0x65, 0x36, 0x64, 0x62, 0x31, 0x66, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x32, 0x63, 0x35, 0x38, 0x63, 0x35, 0x37, 0x39, 0x34, 0x33, 0x31, 0x62, 0x36, 0x37, 0x33, 0x35, 0x34, 0x36, 0x62, 0x35, 0x33, 0x61, 0x38, 0x36, 0x34, 0x35, 0x39, 0x61, 0x63, 0x61, 0x66, 0x31, 0x64, 0x65, 0x39, 0x62, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x36, 0x61, 0x34, 0x37, 0x34, 0x64, 0x36, 0x36, 0x33, 0x34, 0x35, 0x62, 0x63, 0x64, 0x64, 0x37, 0x30, 0x37, 0x35, 0x39, 0x34, 0x61, 0x64, 0x62, 0x36, 0x33, 0x62, 0x33, 0x30, 0x63, 0x37, 0x38, 0x32, 0x32, 0x61, 0x66, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x36, 0x31, 0x35, 0x39, 0x30, 0x37, 0x34, 0x61, 0x62, 0x35, 0x37, 0x33, 0x65, 0x30, 0x65, 0x65, 0x35, 0x38, 0x31, 0x66, 0x30, 0x66, 0x33, 0x64, 0x66, 0x32, 0x64, 0x36, 0x61, 0x35, 0x39, 0x34, 0x36, 0x32, 0x39, 0x62, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x37, 0x66, 0x34, 0x36, 0x35, 0x35, 0x32, 0x30, 0x65, 0x63, 0x33, 0x35, 0x63, 0x63, 0x32, 0x33, 0x64, 0x36, 0x38, 0x65, 0x37, 0x35, 0x36, 0x35, 0x31, 0x62, 0x62, 0x36, 0x36, 0x38, 0x39, 0x35, 0x34, 0x34, 0x61, 0x31, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x30, 0x30, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x36, 0x64, 0x30, 0x32, 0x65, 0x39, 0x61, 0x34, 0x36, 0x62, 0x33, 0x37, 0x39, 0x66, 0x61, 0x63, 0x34, 0x61, 0x63, 0x39, 0x62, 0x31, 0x64, 0x37, 0x62, 0x35, 0x64, 0x34, 0x37, 0x62, 0x63, 0x38, 0x35, 0x30, 0x63, 0x65, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x35, 0x39, 0x30, 0x39, 0x34, 0x65, 0x30, 0x37, 0x34, 0x66, 0x38, 0x64, 0x37, 0x39, 0x31, 0x34, 0x32, 0x61, 0x62, 0x31, 0x34, 0x38, 0x39, 0x66, 0x31, 0x34, 0x38, 0x65, 0x33, 0x32, 0x31, 0x35, 0x31, 0x66, 0x32, 0x30, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x61, 0x36, 0x65, 0x34, 0x36, 0x61, 0x66, 0x32, 0x35, 0x61, 0x31, 0x33, 0x66, 0x35, 0x37, 0x31, 0x36, 0x39, 0x32, 0x35, 0x35, 0x61, 0x33, 0x34, 0x61, 0x34, 0x64, 0x61, 0x63, 0x37, 0x63, 0x65, 0x31, 0x32, 0x62, 0x65, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x31, 0x34, 0x35, 0x66, 0x36, 0x32, 0x30, 0x33, 0x39, 0x37, 0x63, 0x36, 0x39, 0x63, 0x62, 0x38, 0x65, 0x30, 0x30, 0x39, 0x36, 0x32, 0x39, 0x36, 0x31, 0x66, 0x30, 0x66, 0x34, 0x38, 0x38, 0x36, 0x36, 0x34, 0x33, 0x39, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x34, 0x62, 0x39, 0x32, 0x32, 0x66, 0x37, 0x38, 0x34, 0x31, 0x66, 0x63, 0x35, 0x37, 0x37, 0x34, 0x66, 0x30, 0x30, 0x65, 0x31, 0x34, 0x36, 0x30, 0x34, 0x61, 0x65, 0x30, 0x64, 0x66, 0x34, 0x32, 0x63, 0x38, 0x35, 0x35, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x32, 0x33, 0x32, 0x66, 0x66, 0x36, 0x36, 0x64, 0x64, 0x61, 0x64, 0x31, 0x66, 0x64, 0x38, 0x34, 0x31, 0x32, 0x36, 0x36, 0x33, 0x38, 0x30, 0x30, 0x33, 0x36, 0x61, 0x66, 0x64, 0x37, 0x63, 0x66, 0x37, 0x64, 0x37, 0x66, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x36, 0x39, 0x35, 0x34, 0x30, 0x32, 0x35, 0x66, 0x63, 0x61, 0x32, 0x36, 0x30, 0x38, 0x66, 0x34, 0x37, 0x64, 0x61, 0x38, 0x31, 0x63, 0x32, 0x31, 0x35, 0x65, 0x65, 0x64, 0x66, 0x64, 0x38, 0x34, 0x34, 0x61, 0x30, 0x39, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x61, 0x61, 0x30, 0x62, 0x38, 0x33, 0x33, 0x62, 0x62, 0x39, 0x31, 0x36, 0x64, 0x63, 0x31, 0x39, 0x61, 0x38, 0x64, 0x64, 0x36, 0x38, 0x33, 0x66, 0x30, 0x65, 0x64, 0x65, 0x32, 0x34, 0x31, 0x64, 0x39, 0x38, 0x38, 0x65, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x65, 0x61, 0x31, 0x61, 0x63, 0x63, 0x31, 0x33, 0x36, 0x65, 0x63, 0x61, 0x34, 0x62, 0x36, 0x38, 0x63, 0x38, 0x34, 0x32, 0x61, 0x39, 0x35, 0x61, 0x64, 0x66, 0x36, 0x62, 0x37, 0x66, 0x65, 0x65, 0x37, 0x65, 0x62, 0x38, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x61, 0x30, 0x65, 0x35, 0x34, 0x63, 0x36, 0x64, 0x39, 0x64, 0x63, 0x38, 0x62, 0x65, 0x39, 0x36, 0x32, 0x37, 0x36, 0x63, 0x65, 0x62, 0x66, 0x34, 0x66, 0x65, 0x63, 0x34, 0x36, 0x30, 0x66, 0x36, 0x32, 0x33, 0x35, 0x64, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x36, 0x32, 0x30, 0x66, 0x33, 0x65, 0x62, 0x33, 0x30, 0x34, 0x65, 0x38, 0x31, 0x33, 0x64, 0x32, 0x38, 0x62, 0x30, 0x32, 0x39, 0x37, 0x35, 0x35, 0x36, 0x64, 0x36, 0x35, 0x64, 0x63, 0x34, 0x65, 0x35, 0x64, 0x65, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x62, 0x39, 0x38, 0x34, 0x63, 0x36, 0x64, 0x62, 0x62, 0x39, 0x65, 0x32, 0x37, 0x39, 0x39, 0x36, 0x36, 0x61, 0x66, 0x61, 0x66, 0x64, 0x61, 0x35, 0x39, 0x63, 0x30, 0x31, 0x64, 0x30, 0x32, 0x36, 0x32, 0x37, 0x63, 0x38, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x66, 0x34, 0x38, 0x39, 0x61, 0x31, 0x65, 0x63, 0x37, 0x34, 0x37, 0x62, 0x63, 0x32, 0x39, 0x63, 0x33, 0x65, 0x35, 0x66, 0x39, 0x64, 0x38, 0x64, 0x62, 0x39, 0x37, 0x38, 0x37, 0x37, 0x64, 0x34, 0x64, 0x31, 0x62, 0x34, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x62, 0x63, 0x33, 0x65, 0x36, 0x63, 0x62, 0x34, 0x33, 0x33, 0x65, 0x31, 0x39, 0x34, 0x66, 0x34, 0x30, 0x66, 0x38, 0x32, 0x62, 0x34, 0x30, 0x66, 0x61, 0x61, 0x64, 0x62, 0x31, 0x66, 0x38, 0x62, 0x38, 0x35, 0x36, 0x31, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x39, 0x64, 0x61, 0x34, 0x30, 0x66, 0x62, 0x31, 0x62, 0x36, 0x30, 0x66, 0x39, 0x65, 0x61, 0x39, 0x62, 0x64, 0x37, 0x61, 0x34, 0x35, 0x33, 0x65, 0x35, 0x38, 0x34, 0x63, 0x66, 0x37, 0x62, 0x31, 0x62, 0x34, 0x64, 0x39, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x62, 0x62, 0x64, 0x64, 0x38, 0x33, 0x31, 0x65, 0x30, 0x66, 0x32, 0x30, 0x61, 0x65, 0x36, 0x65, 0x33, 0x37, 0x38, 0x32, 0x35, 0x32, 0x64, 0x65, 0x63, 0x64, 0x66, 0x39, 0x32, 0x66, 0x37, 0x63, 0x66, 0x30, 0x63, 0x36, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x32, 0x61, 0x64, 0x65, 0x30, 0x64, 0x64, 0x62, 0x35, 0x63, 0x36, 0x65, 0x66, 0x38, 0x64, 0x30, 0x63, 0x64, 0x38, 0x64, 0x65, 0x39, 0x34, 0x64, 0x38, 0x32, 0x62, 0x31, 0x31, 0x30, 0x38, 0x32, 0x63, 0x62, 0x32, 0x65, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x33, 0x32, 0x31, 0x39, 0x61, 0x32, 0x35, 0x39, 0x37, 0x36, 0x62, 0x62, 0x32, 0x61, 0x61, 0x34, 0x61, 0x66, 0x38, 0x62, 0x61, 0x64, 0x34, 0x31, 0x61, 0x63, 0x33, 0x35, 0x32, 0x36, 0x62, 0x34, 0x39, 0x33, 0x33, 0x36, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x33, 0x39, 0x61, 0x39, 0x65, 0x39, 0x38, 0x66, 0x38, 0x31, 0x66, 0x37, 0x36, 0x39, 0x64, 0x37, 0x33, 0x61, 0x61, 0x64, 0x32, 0x63, 0x65, 0x61, 0x64, 0x32, 0x37, 0x36, 0x61, 0x63, 0x31, 0x33, 0x38, 0x37, 0x62, 0x61, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x31, 0x61, 0x62, 0x63, 0x62, 0x36, 0x63, 0x63, 0x30, 0x33, 0x33, 0x30, 0x35, 0x39, 0x39, 0x31, 0x31, 0x38, 0x31, 0x35, 0x63, 0x39, 0x36, 0x66, 0x64, 0x31, 0x39, 0x31, 0x33, 0x36, 0x30, 0x61, 0x62, 0x30, 0x34, 0x34, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x64, 0x38, 0x30, 0x63, 0x33, 0x62, 0x38, 0x62, 0x61, 0x36, 0x38, 0x32, 0x38, 0x32, 0x32, 0x39, 0x30, 0x62, 0x37, 0x35, 0x65, 0x36, 0x35, 0x64, 0x38, 0x39, 0x37, 0x38, 0x61, 0x31, 0x35, 0x61, 0x38, 0x37, 0x37, 0x38, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x61, 0x38, 0x66, 0x37, 0x65, 0x32, 0x35, 0x66, 0x63, 0x32, 0x64, 0x38, 0x37, 0x31, 0x36, 0x31, 0x38, 0x65, 0x32, 0x34, 0x65, 0x34, 0x30, 0x31, 0x38, 0x34, 0x31, 0x39, 0x39, 0x31, 0x33, 0x37, 0x66, 0x39, 0x66, 0x36, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x61, 0x37, 0x34, 0x63, 0x32, 0x61, 0x63, 0x37, 0x35, 0x64, 0x63, 0x38, 0x62, 0x61, 0x61, 0x38, 0x62, 0x33, 0x31, 0x61, 0x39, 0x63, 0x37, 0x63, 0x62, 0x34, 0x62, 0x37, 0x38, 0x32, 0x39, 0x62, 0x32, 0x34, 0x35, 0x36, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x37, 0x62, 0x36, 0x31, 0x63, 0x35, 0x39, 0x62, 0x30, 0x31, 0x36, 0x33, 0x32, 0x32, 0x65, 0x38, 0x32, 0x32, 0x36, 0x63, 0x61, 0x66, 0x61, 0x65, 0x65, 0x39, 0x64, 0x39, 0x65, 0x37, 0x36, 0x64, 0x35, 0x30, 0x61, 0x31, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x32, 0x36, 0x65, 0x34, 0x38, 0x32, 0x35, 0x32, 0x39, 0x66, 0x30, 0x61, 0x31, 0x34, 0x65, 0x65, 0x63, 0x39, 0x38, 0x38, 0x37, 0x31, 0x64, 0x64, 0x64, 0x64, 0x30, 0x65, 0x37, 0x32, 0x31, 0x62, 0x30, 0x63, 0x64, 0x39, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x31, 0x64, 0x64, 0x39, 0x30, 0x64, 0x31, 0x34, 0x64, 0x34, 0x31, 0x66, 0x34, 0x66, 0x66, 0x37, 0x63, 0x34, 0x31, 0x33, 0x63, 0x32, 0x34, 0x32, 0x33, 0x38, 0x64, 0x33, 0x33, 0x35, 0x39, 0x63, 0x64, 0x36, 0x31, 0x61, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x38, 0x36, 0x37, 0x36, 0x32, 0x66, 0x37, 0x61, 0x34, 0x66, 0x32, 0x39, 0x34, 0x66, 0x32, 0x65, 0x30, 0x62, 0x31, 0x37, 0x33, 0x32, 0x37, 0x39, 0x61, 0x64, 0x32, 0x63, 0x38, 0x31, 0x61, 0x32, 0x32, 0x32, 0x33, 0x34, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x36, 0x37, 0x66, 0x36, 0x35, 0x32, 0x66, 0x39, 0x35, 0x37, 0x63, 0x32, 0x38, 0x63, 0x30, 0x65, 0x36, 0x36, 0x64, 0x30, 0x62, 0x36, 0x33, 0x34, 0x31, 0x37, 0x63, 0x38, 0x30, 0x63, 0x38, 0x63, 0x39, 0x64, 0x62, 0x38, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x39, 0x38, 0x65, 0x32, 0x33, 0x63, 0x62, 0x39, 0x36, 0x62, 0x65, 0x65, 0x65, 0x38, 0x30, 0x61, 0x31, 0x36, 0x38, 0x30, 0x36, 0x39, 0x65, 0x62, 0x62, 0x61, 0x38, 0x66, 0x32, 0x30, 0x65, 0x64, 0x64, 0x35, 0x35, 0x63, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x38, 0x65, 0x35, 0x62, 0x62, 0x38, 0x64, 0x33, 0x35, 0x32, 0x31, 0x36, 0x39, 0x35, 0x63, 0x37, 0x37, 0x65, 0x37, 0x63, 0x38, 0x33, 0x34, 0x65, 0x30, 0x32, 0x39, 0x31, 0x62, 0x66, 0x61, 0x63, 0x65, 0x65, 0x37, 0x34, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x33, 0x64, 0x30, 0x31, 0x35, 0x38, 0x39, 0x65, 0x62, 0x31, 0x32, 0x64, 0x34, 0x33, 0x39, 0x66, 0x37, 0x34, 0x34, 0x38, 0x66, 0x66, 0x35, 0x34, 0x33, 0x30, 0x37, 0x35, 0x32, 0x39, 0x66, 0x31, 0x39, 0x31, 0x38, 0x35, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x64, 0x39, 0x36, 0x30, 0x35, 0x62, 0x33, 0x65, 0x39, 0x31, 0x61, 0x63, 0x66, 0x64, 0x37, 0x37, 0x37, 0x38, 0x33, 0x30, 0x64, 0x31, 0x36, 0x34, 0x36, 0x33, 0x34, 0x37, 0x38, 0x61, 0x65, 0x30, 0x66, 0x63, 0x37, 0x37, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x62, 0x62, 0x39, 0x30, 0x64, 0x33, 0x37, 0x39, 0x38, 0x39, 0x61, 0x61, 0x62, 0x33, 0x31, 0x66, 0x65, 0x61, 0x65, 0x35, 0x34, 0x37, 0x65, 0x30, 0x65, 0x36, 0x66, 0x33, 0x39, 0x39, 0x39, 0x63, 0x65, 0x36, 0x61, 0x33, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x62, 0x66, 0x62, 0x33, 0x39, 0x62, 0x31, 0x31, 0x34, 0x38, 0x36, 0x64, 0x37, 0x39, 0x35, 0x37, 0x32, 0x38, 0x36, 0x36, 0x31, 0x39, 0x35, 0x62, 0x61, 0x32, 0x36, 0x63, 0x36, 0x33, 0x30, 0x62, 0x36, 0x37, 0x38, 0x34, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x36, 0x61, 0x31, 0x34, 0x34, 0x64, 0x37, 0x61, 0x66, 0x30, 0x61, 0x65, 0x38, 0x64, 0x66, 0x36, 0x34, 0x39, 0x61, 0x62, 0x61, 0x65, 0x35, 0x33, 0x35, 0x61, 0x31, 0x35, 0x39, 0x38, 0x33, 0x61, 0x61, 0x30, 0x34, 0x64, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x38, 0x63, 0x31, 0x66, 0x39, 0x33, 0x62, 0x63, 0x64, 0x62, 0x36, 0x66, 0x66, 0x32, 0x33, 0x63, 0x31, 0x30, 0x64, 0x30, 0x64, 0x63, 0x39, 0x32, 0x34, 0x37, 0x32, 0x38, 0x62, 0x37, 0x33, 0x62, 0x65, 0x32, 0x66, 0x66, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x36, 0x32, 0x62, 0x33, 0x30, 0x39, 0x36, 0x61, 0x39, 0x31, 0x65, 0x37, 0x64, 0x63, 0x31, 0x31, 0x61, 0x31, 0x35, 0x39, 0x32, 0x61, 0x32, 0x39, 0x33, 0x64, 0x64, 0x32, 0x35, 0x34, 0x32, 0x31, 0x35, 0x30, 0x64, 0x37, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x38, 0x66, 0x36, 0x36, 0x63, 0x36, 0x30, 0x31, 0x37, 0x62, 0x63, 0x65, 0x35, 0x62, 0x32, 0x30, 0x33, 0x34, 0x37, 0x32, 0x30, 0x34, 0x62, 0x36, 0x30, 0x32, 0x62, 0x37, 0x34, 0x33, 0x62, 0x61, 0x64, 0x37, 0x38, 0x64, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x35, 0x62, 0x33, 0x64, 0x63, 0x30, 0x65, 0x32, 0x62, 0x39, 0x33, 0x36, 0x30, 0x66, 0x39, 0x31, 0x32, 0x38, 0x39, 0x62, 0x31, 0x66, 0x65, 0x31, 0x33, 0x63, 0x65, 0x31, 0x32, 0x63, 0x30, 0x66, 0x62, 0x64, 0x61, 0x33, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x34, 0x36, 0x30, 0x35, 0x35, 0x35, 0x32, 0x34, 0x37, 0x31, 0x61, 0x36, 0x65, 0x65, 0x65, 0x34, 0x64, 0x61, 0x61, 0x62, 0x37, 0x31, 0x66, 0x66, 0x33, 0x62, 0x62, 0x34, 0x31, 0x33, 0x32, 0x36, 0x64, 0x34, 0x37, 0x33, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x33, 0x64, 0x32, 0x32, 0x36, 0x62, 0x62, 0x33, 0x36, 0x61, 0x35, 0x38, 0x66, 0x35, 0x32, 0x36, 0x35, 0x36, 0x38, 0x38, 0x35, 0x37, 0x62, 0x30, 0x62, 0x62, 0x31, 0x32, 0x64, 0x31, 0x30, 0x39, 0x65, 0x63, 0x39, 0x33, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x63, 0x38, 0x32, 0x32, 0x38, 0x65, 0x66, 0x39, 0x32, 0x38, 0x65, 0x31, 0x38, 0x62, 0x32, 0x61, 0x38, 0x30, 0x37, 0x64, 0x30, 0x30, 0x66, 0x62, 0x33, 0x63, 0x36, 0x63, 0x37, 0x39, 0x63, 0x64, 0x31, 0x64, 0x39, 0x65, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x66, 0x33, 0x32, 0x61, 0x35, 0x30, 0x31, 0x63, 0x30, 0x62, 0x37, 0x38, 0x31, 0x63, 0x30, 0x32, 0x38, 0x31, 0x30, 0x32, 0x32, 0x66, 0x34, 0x32, 0x61, 0x31, 0x32, 0x39, 0x33, 0x66, 0x66, 0x64, 0x37, 0x62, 0x38, 0x39, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x64, 0x61, 0x36, 0x30, 0x39, 0x64, 0x34, 0x30, 0x63, 0x64, 0x65, 0x38, 0x30, 0x66, 0x30, 0x30, 0x63, 0x65, 0x35, 0x62, 0x34, 0x66, 0x66, 0x62, 0x36, 0x61, 0x61, 0x39, 0x64, 0x30, 0x62, 0x30, 0x33, 0x34, 0x39, 0x34, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x36, 0x34, 0x64, 0x33, 0x63, 0x64, 0x38, 0x64, 0x32, 0x62, 0x37, 0x33, 0x66, 0x36, 0x36, 0x38, 0x34, 0x31, 0x62, 0x35, 0x63, 0x34, 0x36, 0x62, 0x62, 0x36, 0x39, 0x35, 0x62, 0x38, 0x38, 0x61, 0x39, 0x61, 0x62, 0x37, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x37, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x39, 0x63, 0x30, 0x38, 0x66, 0x37, 0x33, 0x38, 0x36, 0x36, 0x31, 0x66, 0x39, 0x36, 0x37, 0x36, 0x32, 0x33, 0x36, 0x65, 0x66, 0x66, 0x38, 0x32, 0x62, 0x61, 0x36, 0x32, 0x36, 0x31, 0x64, 0x64, 0x33, 0x66, 0x34, 0x38, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x62, 0x39, 0x37, 0x32, 0x35, 0x34, 0x34, 0x37, 0x34, 0x63, 0x30, 0x64, 0x32, 0x66, 0x35, 0x61, 0x37, 0x39, 0x37, 0x30, 0x64, 0x63, 0x64, 0x62, 0x32, 0x66, 0x35, 0x32, 0x66, 0x62, 0x31, 0x30, 0x39, 0x38, 0x62, 0x38, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x32, 0x35, 0x36, 0x32, 0x37, 0x33, 0x39, 0x36, 0x32, 0x62, 0x66, 0x36, 0x33, 0x31, 0x64, 0x30, 0x31, 0x34, 0x35, 0x35, 0x35, 0x63, 0x63, 0x31, 0x64, 0x61, 0x30, 0x64, 0x63, 0x63, 0x33, 0x31, 0x36, 0x31, 0x36, 0x62, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x61, 0x62, 0x64, 0x39, 0x65, 0x39, 0x33, 0x65, 0x37, 0x39, 0x35, 0x37, 0x65, 0x35, 0x62, 0x36, 0x33, 0x36, 0x62, 0x65, 0x36, 0x35, 0x37, 0x39, 0x30, 0x35, 0x31, 0x63, 0x31, 0x35, 0x65, 0x35, 0x63, 0x65, 0x30, 0x62, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x31, 0x38, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x32, 0x35, 0x39, 0x31, 0x65, 0x37, 0x32, 0x31, 0x37, 0x62, 0x34, 0x33, 0x35, 0x65, 0x38, 0x65, 0x38, 0x38, 0x34, 0x63, 0x64, 0x62, 0x66, 0x34, 0x31, 0x35, 0x66, 0x65, 0x33, 0x37, 0x37, 0x61, 0x36, 0x66, 0x65, 0x32, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x37, 0x61, 0x64, 0x62, 0x37, 0x34, 0x30, 0x66, 0x34, 0x35, 0x63, 0x62, 0x62, 0x64, 0x65, 0x33, 0x30, 0x39, 0x34, 0x65, 0x37, 0x65, 0x31, 0x33, 0x37, 0x31, 0x36, 0x66, 0x38, 0x31, 0x30, 0x33, 0x66, 0x35, 0x36, 0x33, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x65, 0x64, 0x35, 0x35, 0x39, 0x36, 0x63, 0x36, 0x39, 0x37, 0x32, 0x30, 0x37, 0x66, 0x33, 0x64, 0x35, 0x35, 0x62, 0x32, 0x61, 0x35, 0x31, 0x61, 0x61, 0x37, 0x64, 0x35, 0x30, 0x66, 0x30, 0x37, 0x66, 0x61, 0x30, 0x39, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x38, 0x65, 0x38, 0x30, 0x39, 0x37, 0x34, 0x31, 0x61, 0x33, 0x62, 0x31, 0x34, 0x61, 0x32, 0x32, 0x61, 0x34, 0x62, 0x31, 0x64, 0x39, 0x33, 0x37, 0x63, 0x38, 0x32, 0x63, 0x66, 0x65, 0x61, 0x34, 0x38, 0x39, 0x65, 0x65, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x32, 0x36, 0x34, 0x36, 0x61, 0x63, 0x31, 0x61, 0x63, 0x61, 0x61, 0x62, 0x66, 0x35, 0x64, 0x64, 0x61, 0x62, 0x61, 0x38, 0x66, 0x39, 0x34, 0x32, 0x39, 0x61, 0x61, 0x36, 0x61, 0x39, 0x34, 0x65, 0x37, 0x34, 0x39, 0x36, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x32, 0x39, 0x36, 0x66, 0x35, 0x30, 0x34, 0x34, 0x32, 0x37, 0x30, 0x64, 0x31, 0x37, 0x37, 0x30, 0x37, 0x36, 0x34, 0x36, 0x31, 0x32, 0x39, 0x63, 0x38, 0x36, 0x61, 0x61, 0x64, 0x31, 0x36, 0x34, 0x35, 0x65, 0x61, 0x64, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x65, 0x38, 0x61, 0x61, 0x64, 0x37, 0x65, 0x30, 0x61, 0x30, 0x36, 0x35, 0x64, 0x38, 0x38, 0x35, 0x32, 0x64, 0x37, 0x63, 0x33, 0x62, 0x39, 0x61, 0x36, 0x65, 0x35, 0x66, 0x64, 0x63, 0x34, 0x62, 0x66, 0x35, 0x30, 0x63, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x64, 0x62, 0x36, 0x62, 0x39, 0x62, 0x31, 0x30, 0x37, 0x65, 0x36, 0x32, 0x31, 0x30, 0x32, 0x66, 0x34, 0x33, 0x34, 0x61, 0x39, 0x64, 0x64, 0x30, 0x39, 0x36, 0x30, 0x63, 0x32, 0x30, 0x32, 0x31, 0x66, 0x35, 0x63, 0x65, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x39, 0x37, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x66, 0x63, 0x39, 0x33, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x61, 0x64, 0x66, 0x62, 0x63, 0x39, 0x62, 0x38, 0x35, 0x64, 0x32, 0x39, 0x64, 0x39, 0x32, 0x39, 0x31, 0x61, 0x30, 0x35, 0x66, 0x38, 0x66, 0x31, 0x34, 0x31, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x36, 0x65, 0x64, 0x36, 0x30, 0x30, 0x36, 0x61, 0x36, 0x61, 0x62, 0x65, 0x38, 0x38, 0x36, 0x65, 0x64, 0x33, 0x33, 0x64, 0x39, 0x35, 0x61, 0x34, 0x64, 0x65, 0x32, 0x38, 0x66, 0x63, 0x31, 0x32, 0x31, 0x38, 0x33, 0x39, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x34, 0x35, 0x61, 0x62, 0x31, 0x38, 0x31, 0x61, 0x33, 0x36, 0x61, 0x61, 0x38, 0x63, 0x62, 0x66, 0x32, 0x32, 0x38, 0x39, 0x64, 0x30, 0x63, 0x34, 0x35, 0x31, 0x36, 0x35, 0x62, 0x63, 0x37, 0x65, 0x62, 0x65, 0x32, 0x33, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x62, 0x30, 0x66, 0x64, 0x66, 0x35, 0x61, 0x36, 0x36, 0x33, 0x62, 0x35, 0x66, 0x62, 0x61, 0x32, 0x38, 0x64, 0x39, 0x63, 0x39, 0x30, 0x32, 0x61, 0x66, 0x30, 0x63, 0x38, 0x31, 0x31, 0x65, 0x32, 0x35, 0x32, 0x66, 0x32, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x66, 0x66, 0x30, 0x62, 0x64, 0x39, 0x31, 0x35, 0x34, 0x34, 0x33, 0x39, 0x63, 0x34, 0x61, 0x35, 0x62, 0x37, 0x32, 0x33, 0x33, 0x65, 0x32, 0x39, 0x31, 0x64, 0x37, 0x64, 0x38, 0x36, 0x38, 0x61, 0x66, 0x35, 0x33, 0x66, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x32, 0x36, 0x31, 0x66, 0x39, 0x61, 0x63, 0x62, 0x34, 0x35, 0x31, 0x63, 0x33, 0x37, 0x38, 0x38, 0x38, 0x34, 0x34, 0x66, 0x30, 0x63, 0x31, 0x34, 0x35, 0x31, 0x61, 0x33, 0x35, 0x62, 0x61, 0x64, 0x35, 0x30, 0x39, 0x38, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x31, 0x33, 0x64, 0x32, 0x36, 0x33, 0x66, 0x63, 0x35, 0x66, 0x66, 0x32, 0x34, 0x37, 0x39, 0x65, 0x39, 0x37, 0x30, 0x35, 0x39, 0x35, 0x64, 0x36, 0x62, 0x36, 0x62, 0x35, 0x36, 0x30, 0x66, 0x38, 0x64, 0x36, 0x64, 0x36, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x64, 0x31, 0x39, 0x36, 0x39, 0x34, 0x64, 0x31, 0x39, 0x32, 0x36, 0x61, 0x30, 0x66, 0x61, 0x39, 0x31, 0x38, 0x39, 0x65, 0x64, 0x65, 0x62, 0x61, 0x66, 0x63, 0x36, 0x37, 0x31, 0x63, 0x66, 0x31, 0x62, 0x32, 0x63, 0x61, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x33, 0x33, 0x36, 0x65, 0x39, 0x61, 0x37, 0x32, 0x32, 0x37, 0x32, 0x38, 0x64, 0x39, 0x36, 0x33, 0x65, 0x37, 0x61, 0x31, 0x63, 0x66, 0x32, 0x37, 0x35, 0x39, 0x66, 0x64, 0x30, 0x32, 0x37, 0x34, 0x35, 0x33, 0x30, 0x66, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x35, 0x35, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x62, 0x37, 0x61, 0x66, 0x31, 0x34, 0x36, 0x39, 0x38, 0x36, 0x63, 0x30, 0x66, 0x66, 0x38, 0x66, 0x38, 0x35, 0x64, 0x32, 0x32, 0x65, 0x36, 0x63, 0x63, 0x33, 0x33, 0x34, 0x30, 0x37, 0x37, 0x64, 0x38, 0x34, 0x65, 0x38, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x34, 0x66, 0x62, 0x64, 0x36, 0x36, 0x31, 0x30, 0x31, 0x35, 0x66, 0x36, 0x34, 0x36, 0x31, 0x65, 0x64, 0x36, 0x37, 0x33, 0x35, 0x63, 0x65, 0x66, 0x65, 0x66, 0x30, 0x31, 0x66, 0x33, 0x31, 0x34, 0x34, 0x35, 0x64, 0x65, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x35, 0x64, 0x66, 0x35, 0x62, 0x39, 0x34, 0x33, 0x35, 0x37, 0x64, 0x65, 0x39, 0x34, 0x38, 0x36, 0x30, 0x34, 0x63, 0x35, 0x31, 0x62, 0x37, 0x38, 0x39, 0x33, 0x63, 0x64, 0x64, 0x66, 0x36, 0x30, 0x37, 0x36, 0x62, 0x61, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x36, 0x37, 0x61, 0x30, 0x64, 0x65, 0x38, 0x31, 0x31, 0x64, 0x65, 0x36, 0x66, 0x66, 0x30, 0x39, 0x35, 0x62, 0x37, 0x65, 0x65, 0x36, 0x34, 0x65, 0x37, 0x66, 0x31, 0x62, 0x38, 0x33, 0x63, 0x32, 0x36, 0x31, 0x35, 0x62, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x35, 0x64, 0x62, 0x33, 0x62, 0x37, 0x34, 0x33, 0x36, 0x30, 0x62, 0x39, 0x61, 0x32, 0x36, 0x38, 0x36, 0x37, 0x37, 0x65, 0x37, 0x33, 0x63, 0x65, 0x61, 0x38, 0x32, 0x31, 0x36, 0x36, 0x38, 0x61, 0x66, 0x36, 0x66, 0x61, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x30, 0x34, 0x30, 0x64, 0x34, 0x30, 0x63, 0x62, 0x38, 0x30, 0x62, 0x61, 0x30, 0x31, 0x32, 0x35, 0x66, 0x33, 0x62, 0x31, 0x35, 0x66, 0x64, 0x65, 0x66, 0x63, 0x63, 0x38, 0x33, 0x66, 0x33, 0x30, 0x30, 0x35, 0x64, 0x61, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x66, 0x34, 0x37, 0x30, 0x65, 0x64, 0x36, 0x35, 0x39, 0x65, 0x32, 0x39, 0x39, 0x31, 0x63, 0x33, 0x37, 0x35, 0x39, 0x35, 0x37, 0x65, 0x35, 0x64, 0x64, 0x65, 0x63, 0x35, 0x62, 0x64, 0x31, 0x64, 0x33, 0x38, 0x32, 0x32, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x37, 0x66, 0x39, 0x62, 0x66, 0x31, 0x35, 0x32, 0x39, 0x64, 0x61, 0x66, 0x38, 0x37, 0x64, 0x34, 0x30, 0x37, 0x31, 0x37, 0x35, 0x65, 0x36, 0x66, 0x31, 0x37, 0x31, 0x62, 0x35, 0x65, 0x35, 0x39, 0x65, 0x39, 0x66, 0x66, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x65, 0x33, 0x62, 0x35, 0x38, 0x34, 0x30, 0x35, 0x36, 0x62, 0x36, 0x32, 0x63, 0x39, 0x37, 0x33, 0x63, 0x66, 0x35, 0x65, 0x62, 0x30, 0x39, 0x36, 0x66, 0x31, 0x37, 0x33, 0x33, 0x65, 0x35, 0x34, 0x63, 0x31, 0x35, 0x63, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x36, 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x33, 0x64, 0x65, 0x34, 0x32, 0x61, 0x31, 0x30, 0x39, 0x62, 0x36, 0x35, 0x37, 0x61, 0x36, 0x34, 0x65, 0x39, 0x32, 0x32, 0x32, 0x34, 0x63, 0x30, 0x38, 0x64, 0x63, 0x31, 0x32, 0x37, 0x35, 0x65, 0x38, 0x30, 0x64, 0x39, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x66, 0x63, 0x31, 0x33, 0x63, 0x66, 0x63, 0x62, 0x61, 0x63, 0x31, 0x62, 0x31, 0x37, 0x63, 0x65, 0x37, 0x37, 0x38, 0x33, 0x61, 0x63, 0x64, 0x34, 0x32, 0x33, 0x61, 0x38, 0x34, 0x35, 0x39, 0x34, 0x33, 0x66, 0x36, 0x62, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x66, 0x66, 0x38, 0x37, 0x34, 0x66, 0x61, 0x66, 0x63, 0x65, 0x34, 0x64, 0x61, 0x33, 0x31, 0x38, 0x64, 0x36, 0x63, 0x39, 0x33, 0x64, 0x35, 0x37, 0x65, 0x32, 0x63, 0x33, 0x38, 0x61, 0x30, 0x64, 0x37, 0x33, 0x65, 0x38, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x39, 0x39, 0x37, 0x64, 0x62, 0x63, 0x30, 0x37, 0x38, 0x61, 0x64, 0x30, 0x32, 0x39, 0x36, 0x31, 0x33, 0x35, 0x35, 0x64, 0x61, 0x30, 0x61, 0x31, 0x35, 0x39, 0x66, 0x32, 0x39, 0x32, 0x37, 0x65, 0x64, 0x34, 0x33, 0x64, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x35, 0x30, 0x38, 0x30, 0x62, 0x38, 0x33, 0x66, 0x37, 0x65, 0x32, 0x64, 0x63, 0x30, 0x61, 0x31, 0x64, 0x64, 0x31, 0x31, 0x62, 0x30, 0x39, 0x32, 0x61, 0x64, 0x30, 0x34, 0x32, 0x62, 0x66, 0x66, 0x37, 0x38, 0x38, 0x66, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x33, 0x38, 0x33, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x33, 0x39, 0x32, 0x30, 0x64, 0x30, 0x30, 0x31, 0x63, 0x34, 0x33, 0x65, 0x37, 0x32, 0x62, 0x32, 0x34, 0x65, 0x37, 0x63, 0x61, 0x34, 0x36, 0x66, 0x30, 0x66, 0x64, 0x36, 0x65, 0x30, 0x63, 0x32, 0x30, 0x61, 0x35, 0x66, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x64, 0x65, 0x37, 0x37, 0x66, 0x64, 0x38, 0x31, 0x63, 0x32, 0x35, 0x63, 0x30, 0x61, 0x66, 0x37, 0x31, 0x33, 0x62, 0x31, 0x30, 0x37, 0x30, 0x32, 0x37, 0x36, 0x38, 0x63, 0x31, 0x65, 0x62, 0x32, 0x66, 0x39, 0x37, 0x35, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x61, 0x61, 0x64, 0x64, 0x63, 0x62, 0x66, 0x32, 0x38, 0x36, 0x63, 0x62, 0x30, 0x65, 0x32, 0x31, 0x35, 0x64, 0x64, 0x61, 0x35, 0x35, 0x35, 0x39, 0x38, 0x66, 0x37, 0x66, 0x66, 0x30, 0x66, 0x34, 0x61, 0x64, 0x61, 0x35, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x65, 0x30, 0x32, 0x31, 0x37, 0x61, 0x35, 0x62, 0x33, 0x38, 0x61, 0x61, 0x34, 0x30, 0x35, 0x38, 0x33, 0x36, 0x32, 0x35, 0x39, 0x36, 0x37, 0x66, 0x61, 0x39, 0x38, 0x38, 0x33, 0x36, 0x39, 0x30, 0x33, 0x38, 0x38, 0x62, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x36, 0x34, 0x38, 0x31, 0x35, 0x35, 0x61, 0x36, 0x35, 0x38, 0x33, 0x37, 0x30, 0x66, 0x39, 0x32, 0x39, 0x62, 0x65, 0x33, 0x38, 0x34, 0x66, 0x37, 0x65, 0x30, 0x30, 0x31, 0x30, 0x34, 0x37, 0x65, 0x34, 0x39, 0x64, 0x64, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x63, 0x31, 0x62, 0x34, 0x34, 0x33, 0x39, 0x36, 0x38, 0x62, 0x31, 0x31, 0x37, 0x62, 0x35, 0x64, 0x64, 0x39, 0x62, 0x37, 0x35, 0x35, 0x35, 0x37, 0x32, 0x66, 0x63, 0x64, 0x33, 0x39, 0x63, 0x61, 0x35, 0x65, 0x63, 0x30, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x36, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x30, 0x32, 0x37, 0x65, 0x66, 0x62, 0x62, 0x33, 0x38, 0x35, 0x30, 0x33, 0x32, 0x32, 0x36, 0x65, 0x64, 0x38, 0x37, 0x31, 0x30, 0x39, 0x39, 0x63, 0x62, 0x33, 0x30, 0x62, 0x64, 0x62, 0x30, 0x32, 0x61, 0x66, 0x31, 0x33, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x63, 0x66, 0x31, 0x65, 0x35, 0x34, 0x62, 0x65, 0x33, 0x36, 0x33, 0x31, 0x30, 0x36, 0x62, 0x39, 0x32, 0x30, 0x37, 0x32, 0x39, 0x64, 0x32, 0x64, 0x30, 0x62, 0x61, 0x34, 0x36, 0x66, 0x30, 0x38, 0x36, 0x37, 0x39, 0x38, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x66, 0x34, 0x64, 0x37, 0x66, 0x65, 0x36, 0x66, 0x35, 0x36, 0x31, 0x66, 0x37, 0x66, 0x61, 0x31, 0x64, 0x61, 0x33, 0x30, 0x30, 0x35, 0x66, 0x64, 0x33, 0x36, 0x35, 0x34, 0x35, 0x31, 0x61, 0x64, 0x38, 0x39, 0x64, 0x66, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x33, 0x36, 0x39, 0x31, 0x36, 0x62, 0x64, 0x61, 0x63, 0x66, 0x39, 0x34, 0x62, 0x36, 0x39, 0x65, 0x35, 0x61, 0x38, 0x61, 0x36, 0x35, 0x36, 0x30, 0x32, 0x39, 0x37, 0x35, 0x65, 0x62, 0x30, 0x32, 0x36, 0x31, 0x30, 0x34, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x32, 0x33, 0x63, 0x30, 0x36, 0x31, 0x37, 0x37, 0x62, 0x33, 0x34, 0x32, 0x37, 0x65, 0x61, 0x34, 0x34, 0x38, 0x63, 0x30, 0x61, 0x36, 0x66, 0x66, 0x30, 0x31, 0x39, 0x62, 0x35, 0x34, 0x63, 0x63, 0x35, 0x34, 0x38, 0x64, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x32, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x39, 0x32, 0x37, 0x65, 0x30, 0x33, 0x64, 0x31, 0x35, 0x39, 0x39, 0x61, 0x37, 0x38, 0x63, 0x61, 0x32, 0x62, 0x66, 0x30, 0x63, 0x61, 0x64, 0x32, 0x61, 0x31, 0x38, 0x33, 0x64, 0x63, 0x65, 0x62, 0x37, 0x31, 0x65, 0x61, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x33, 0x39, 0x63, 0x61, 0x39, 0x31, 0x37, 0x33, 0x64, 0x66, 0x31, 0x35, 0x35, 0x33, 0x31, 0x64, 0x37, 0x33, 0x65, 0x36, 0x62, 0x37, 0x32, 0x61, 0x36, 0x38, 0x34, 0x62, 0x35, 0x31, 0x62, 0x61, 0x30, 0x66, 0x32, 0x62, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x34, 0x33, 0x62, 0x38, 0x61, 0x65, 0x36, 0x33, 0x39, 0x64, 0x65, 0x39, 0x31, 0x63, 0x66, 0x37, 0x33, 0x63, 0x35, 0x61, 0x65, 0x37, 0x36, 0x33, 0x65, 0x65, 0x65, 0x65, 0x64, 0x33, 0x64, 0x64, 0x62, 0x62, 0x39, 0x32, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x32, 0x36, 0x34, 0x33, 0x35, 0x61, 0x61, 0x63, 0x37, 0x32, 0x38, 0x64, 0x34, 0x39, 0x37, 0x62, 0x31, 0x39, 0x62, 0x33, 0x65, 0x37, 0x65, 0x35, 0x37, 0x63, 0x32, 0x38, 0x63, 0x35, 0x36, 0x33, 0x39, 0x35, 0x34, 0x66, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x33, 0x32, 0x37, 0x61, 0x31, 0x34, 0x64, 0x35, 0x63, 0x66, 0x61, 0x64, 0x64, 0x39, 0x38, 0x31, 0x30, 0x33, 0x66, 0x63, 0x30, 0x39, 0x39, 0x39, 0x37, 0x31, 0x38, 0x64, 0x37, 0x65, 0x64, 0x37, 0x30, 0x35, 0x32, 0x38, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x61, 0x33, 0x64, 0x63, 0x63, 0x66, 0x32, 0x66, 0x63, 0x66, 0x65, 0x30, 0x63, 0x39, 0x31, 0x61, 0x32, 0x36, 0x32, 0x34, 0x62, 0x64, 0x30, 0x63, 0x62, 0x66, 0x38, 0x38, 0x65, 0x65, 0x34, 0x61, 0x30, 0x37, 0x36, 0x63, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x62, 0x31, 0x66, 0x39, 0x65, 0x32, 0x37, 0x38, 0x33, 0x32, 0x63, 0x36, 0x64, 0x65, 0x36, 0x39, 0x31, 0x34, 0x64, 0x37, 0x30, 0x61, 0x66, 0x63, 0x32, 0x33, 0x38, 0x63, 0x37, 0x34, 0x39, 0x39, 0x39, 0x35, 0x61, 0x63, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x30, 0x64, 0x39, 0x38, 0x64, 0x33, 0x31, 0x62, 0x34, 0x33, 0x35, 0x33, 0x66, 0x63, 0x65, 0x65, 0x65, 0x38, 0x35, 0x36, 0x30, 0x63, 0x34, 0x63, 0x63, 0x66, 0x38, 0x30, 0x33, 0x65, 0x38, 0x38, 0x63, 0x30, 0x63, 0x34, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x31, 0x66, 0x30, 0x65, 0x30, 0x33, 0x63, 0x62, 0x39, 0x61, 0x61, 0x30, 0x32, 0x31, 0x66, 0x34, 0x64, 0x63, 0x65, 0x62, 0x66, 0x61, 0x39, 0x34, 0x65, 0x35, 0x63, 0x38, 0x38, 0x39, 0x63, 0x39, 0x63, 0x37, 0x62, 0x63, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x33, 0x38, 0x34, 0x32, 0x62, 0x31, 0x64, 0x30, 0x36, 0x39, 0x32, 0x66, 0x64, 0x31, 0x31, 0x31, 0x34, 0x30, 0x63, 0x66, 0x35, 0x61, 0x63, 0x64, 0x61, 0x34, 0x62, 0x66, 0x39, 0x36, 0x33, 0x30, 0x62, 0x61, 0x65, 0x35, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x64, 0x64, 0x35, 0x30, 0x61, 0x31, 0x35, 0x64, 0x61, 0x33, 0x34, 0x39, 0x36, 0x38, 0x38, 0x39, 0x30, 0x61, 0x35, 0x33, 0x62, 0x34, 0x66, 0x31, 0x33, 0x66, 0x65, 0x31, 0x61, 0x66, 0x30, 0x38, 0x31, 0x62, 0x61, 0x61, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x30, 0x37, 0x32, 0x61, 0x30, 0x65, 0x66, 0x31, 0x63, 0x66, 0x66, 0x33, 0x64, 0x35, 0x36, 0x37, 0x63, 0x64, 0x64, 0x32, 0x36, 0x30, 0x65, 0x37, 0x30, 0x38, 0x64, 0x64, 0x63, 0x31, 0x31, 0x63, 0x62, 0x63, 0x39, 0x61, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x61, 0x38, 0x38, 0x31, 0x39, 0x36, 0x66, 0x61, 0x63, 0x35, 0x66, 0x32, 0x33, 0x63, 0x33, 0x65, 0x31, 0x32, 0x61, 0x36, 0x39, 0x64, 0x65, 0x63, 0x34, 0x62, 0x38, 0x38, 0x30, 0x65, 0x62, 0x37, 0x64, 0x39, 0x37, 0x33, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x36, 0x33, 0x66, 0x38, 0x34, 0x35, 0x35, 0x36, 0x64, 0x32, 0x39, 0x30, 0x62, 0x66, 0x63, 0x64, 0x39, 0x39, 0x65, 0x34, 0x33, 0x34, 0x65, 0x65, 0x39, 0x39, 0x39, 0x37, 0x62, 0x66, 0x64, 0x37, 0x37, 0x39, 0x35, 0x37, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x31, 0x36, 0x37, 0x61, 0x61, 0x32, 0x34, 0x32, 0x62, 0x63, 0x34, 0x63, 0x31, 0x38, 0x39, 0x61, 0x64, 0x65, 0x63, 0x62, 0x33, 0x61, 0x63, 0x34, 0x61, 0x37, 0x63, 0x34, 0x35, 0x32, 0x63, 0x66, 0x31, 0x39, 0x32, 0x66, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x35, 0x63, 0x62, 0x38, 0x64, 0x65, 0x35, 0x65, 0x33, 0x64, 0x66, 0x35, 0x32, 0x30, 0x62, 0x34, 0x39, 0x39, 0x65, 0x66, 0x63, 0x39, 0x38, 0x30, 0x66, 0x35, 0x32, 0x62, 0x66, 0x66, 0x34, 0x30, 0x66, 0x35, 0x35, 0x63, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x63, 0x32, 0x37, 0x63, 0x65, 0x32, 0x31, 0x33, 0x33, 0x65, 0x38, 0x32, 0x64, 0x30, 0x35, 0x32, 0x35, 0x32, 0x30, 0x61, 0x66, 0x62, 0x35, 0x63, 0x35, 0x37, 0x36, 0x64, 0x39, 0x66, 0x37, 0x65, 0x62, 0x39, 0x33, 0x65, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x32, 0x33, 0x32, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x64, 0x63, 0x32, 0x62, 0x66, 0x38, 0x33, 0x62, 0x63, 0x36, 0x61, 0x66, 0x31, 0x39, 0x61, 0x38, 0x34, 0x32, 0x66, 0x66, 0x65, 0x61, 0x36, 0x36, 0x31, 0x61, 0x66, 0x35, 0x62, 0x34, 0x31, 0x62, 0x36, 0x37, 0x66, 0x64, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x62, 0x64, 0x34, 0x38, 0x64, 0x30, 0x66, 0x66, 0x64, 0x62, 0x64, 0x35, 0x36, 0x35, 0x36, 0x63, 0x64, 0x35, 0x65, 0x36, 0x38, 0x36, 0x33, 0x36, 0x33, 0x61, 0x36, 0x31, 0x31, 0x34, 0x35, 0x32, 0x32, 0x38, 0x66, 0x32, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x36, 0x64, 0x62, 0x30, 0x37, 0x64, 0x39, 0x66, 0x38, 0x31, 0x32, 0x66, 0x34, 0x37, 0x39, 0x36, 0x36, 0x32, 0x32, 0x64, 0x34, 0x30, 0x65, 0x30, 0x33, 0x64, 0x31, 0x33, 0x35, 0x38, 0x37, 0x34, 0x61, 0x38, 0x38, 0x61, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x31, 0x33, 0x63, 0x39, 0x37, 0x66, 0x66, 0x61, 0x34, 0x61, 0x36, 0x65, 0x32, 0x61, 0x37, 0x62, 0x62, 0x61, 0x38, 0x39, 0x36, 0x31, 0x64, 0x63, 0x39, 0x66, 0x63, 0x65, 0x38, 0x35, 0x33, 0x30, 0x61, 0x37, 0x38, 0x37, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x66, 0x66, 0x39, 0x65, 0x65, 0x34, 0x62, 0x36, 0x65, 0x63, 0x63, 0x31, 0x34, 0x31, 0x34, 0x31, 0x63, 0x63, 0x37, 0x34, 0x63, 0x61, 0x35, 0x32, 0x61, 0x39, 0x65, 0x37, 0x61, 0x32, 0x65, 0x65, 0x31, 0x34, 0x64, 0x39, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x38, 0x65, 0x62, 0x33, 0x30, 0x61, 0x37, 0x31, 0x36, 0x65, 0x35, 0x66, 0x65, 0x31, 0x35, 0x63, 0x37, 0x34, 0x32, 0x33, 0x33, 0x65, 0x30, 0x33, 0x39, 0x62, 0x66, 0x62, 0x31, 0x31, 0x30, 0x36, 0x65, 0x38, 0x31, 0x64, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x38, 0x38, 0x64, 0x31, 0x31, 0x34, 0x32, 0x32, 0x30, 0x66, 0x30, 0x38, 0x31, 0x63, 0x62, 0x33, 0x64, 0x35, 0x65, 0x31, 0x35, 0x62, 0x65, 0x38, 0x31, 0x35, 0x32, 0x61, 0x62, 0x30, 0x37, 0x33, 0x36, 0x36, 0x35, 0x37, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x30, 0x38, 0x66, 0x63, 0x65, 0x61, 0x61, 0x31, 0x62, 0x39, 0x38, 0x66, 0x33, 0x63, 0x36, 0x34, 0x30, 0x66, 0x34, 0x38, 0x66, 0x63, 0x62, 0x61, 0x33, 0x39, 0x66, 0x30, 0x35, 0x36, 0x30, 0x36, 0x36, 0x64, 0x36, 0x33, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x37, 0x64, 0x64, 0x32, 0x39, 0x66, 0x32, 0x64, 0x31, 0x39, 0x61, 0x61, 0x33, 0x64, 0x61, 0x34, 0x32, 0x33, 0x32, 0x37, 0x65, 0x61, 0x35, 0x30, 0x62, 0x63, 0x65, 0x38, 0x36, 0x66, 0x66, 0x35, 0x63, 0x39, 0x31, 0x31, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x31, 0x30, 0x36, 0x35, 0x64, 0x62, 0x63, 0x66, 0x39, 0x64, 0x37, 0x33, 0x63, 0x30, 0x34, 0x66, 0x66, 0x63, 0x37, 0x39, 0x30, 0x38, 0x38, 0x37, 0x30, 0x64, 0x38, 0x38, 0x31, 0x34, 0x36, 0x38, 0x63, 0x31, 0x65, 0x31, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x63, 0x39, 0x64, 0x38, 0x31, 0x31, 0x32, 0x65, 0x35, 0x62, 0x65, 0x62, 0x30, 0x32, 0x64, 0x64, 0x32, 0x39, 0x61, 0x32, 0x32, 0x35, 0x37, 0x62, 0x31, 0x66, 0x65, 0x36, 0x39, 0x62, 0x33, 0x35, 0x33, 0x36, 0x61, 0x39, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x63, 0x31, 0x62, 0x65, 0x31, 0x39, 0x37, 0x31, 0x31, 0x66, 0x37, 0x33, 0x62, 0x65, 0x65, 0x34, 0x65, 0x36, 0x33, 0x31, 0x36, 0x61, 0x65, 0x37, 0x35, 0x34, 0x39, 0x34, 0x35, 0x39, 0x61, 0x61, 0x63, 0x65, 0x61, 0x32, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x63, 0x66, 0x33, 0x34, 0x34, 0x31, 0x61, 0x38, 0x36, 0x36, 0x62, 0x64, 0x62, 0x65, 0x39, 0x36, 0x33, 0x30, 0x30, 0x39, 0x63, 0x65, 0x33, 0x33, 0x63, 0x38, 0x31, 0x63, 0x62, 0x62, 0x30, 0x32, 0x36, 0x31, 0x62, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x65, 0x32, 0x36, 0x65, 0x34, 0x65, 0x31, 0x64, 0x63, 0x66, 0x33, 0x30, 0x64, 0x30, 0x34, 0x38, 0x63, 0x63, 0x36, 0x65, 0x63, 0x66, 0x39, 0x64, 0x35, 0x31, 0x65, 0x63, 0x31, 0x32, 0x30, 0x35, 0x61, 0x34, 0x65, 0x39, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x37, 0x30, 0x31, 0x65, 0x32, 0x63, 0x34, 0x39, 0x33, 0x64, 0x61, 0x34, 0x37, 0x63, 0x31, 0x62, 0x35, 0x38, 0x66, 0x34, 0x32, 0x31, 0x62, 0x35, 0x34, 0x39, 0x35, 0x64, 0x65, 0x65, 0x34, 0x35, 0x62, 0x65, 0x61, 0x33, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x36, 0x38, 0x32, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x61, 0x30, 0x35, 0x61, 0x63, 0x65, 0x62, 0x39, 0x33, 0x39, 0x35, 0x63, 0x38, 0x36, 0x33, 0x35, 0x61, 0x33, 0x39, 0x61, 0x37, 0x63, 0x35, 0x64, 0x32, 0x36, 0x36, 0x61, 0x65, 0x36, 0x31, 0x30, 0x64, 0x31, 0x30, 0x62, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x33, 0x35, 0x35, 0x65, 0x63, 0x34, 0x37, 0x36, 0x38, 0x63, 0x37, 0x30, 0x61, 0x34, 0x39, 0x61, 0x66, 0x36, 0x39, 0x35, 0x31, 0x33, 0x63, 0x64, 0x38, 0x33, 0x61, 0x35, 0x62, 0x63, 0x61, 0x37, 0x65, 0x33, 0x62, 0x39, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x63, 0x30, 0x63, 0x31, 0x32, 0x38, 0x33, 0x32, 0x37, 0x61, 0x39, 0x61, 0x64, 0x38, 0x30, 0x31, 0x34, 0x38, 0x31, 0x33, 0x39, 0x65, 0x32, 0x36, 0x39, 0x37, 0x37, 0x33, 0x34, 0x32, 0x38, 0x65, 0x36, 0x33, 0x38, 0x63, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x66, 0x34, 0x38, 0x39, 0x38, 0x63, 0x34, 0x63, 0x35, 0x32, 0x36, 0x64, 0x39, 0x35, 0x35, 0x66, 0x32, 0x31, 0x66, 0x30, 0x35, 0x35, 0x63, 0x62, 0x36, 0x65, 0x34, 0x37, 0x62, 0x39, 0x31, 0x35, 0x65, 0x35, 0x31, 0x39, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x38, 0x32, 0x34, 0x65, 0x39, 0x34, 0x63, 0x63, 0x34, 0x33, 0x34, 0x38, 0x62, 0x63, 0x39, 0x36, 0x33, 0x32, 0x37, 0x39, 0x64, 0x63, 0x64, 0x66, 0x34, 0x37, 0x33, 0x39, 0x31, 0x37, 0x31, 0x35, 0x33, 0x32, 0x34, 0x63, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x61, 0x34, 0x35, 0x63, 0x65, 0x61, 0x30, 0x32, 0x64, 0x38, 0x37, 0x64, 0x32, 0x63, 0x63, 0x38, 0x66, 0x64, 0x61, 0x39, 0x34, 0x33, 0x34, 0x65, 0x32, 0x64, 0x39, 0x38, 0x35, 0x62, 0x64, 0x34, 0x30, 0x33, 0x31, 0x35, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x32, 0x30, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x38, 0x62, 0x39, 0x61, 0x62, 0x61, 0x36, 0x62, 0x64, 0x39, 0x64, 0x32, 0x38, 0x62, 0x63, 0x32, 0x30, 0x35, 0x36, 0x37, 0x37, 0x39, 0x64, 0x32, 0x66, 0x62, 0x66, 0x30, 0x66, 0x32, 0x38, 0x35, 0x35, 0x61, 0x33, 0x64, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x63, 0x34, 0x39, 0x38, 0x31, 0x37, 0x30, 0x39, 0x33, 0x34, 0x62, 0x38, 0x32, 0x33, 0x33, 0x64, 0x31, 0x61, 0x64, 0x31, 0x65, 0x37, 0x36, 0x39, 0x33, 0x31, 0x37, 0x64, 0x35, 0x63, 0x34, 0x37, 0x35, 0x66, 0x32, 0x66, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x32, 0x64, 0x32, 0x39, 0x61, 0x32, 0x36, 0x65, 0x38, 0x61, 0x34, 0x31, 0x38, 0x31, 0x38, 0x31, 0x38, 0x31, 0x37, 0x34, 0x36, 0x34, 0x36, 0x37, 0x66, 0x35, 0x38, 0x32, 0x65, 0x36, 0x65, 0x38, 0x34, 0x30, 0x31, 0x32, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x33, 0x32, 0x32, 0x30, 0x36, 0x30, 0x30, 0x61, 0x33, 0x36, 0x66, 0x37, 0x33, 0x66, 0x32, 0x34, 0x65, 0x31, 0x39, 0x30, 0x64, 0x31, 0x65, 0x64, 0x62, 0x32, 0x64, 0x36, 0x31, 0x62, 0x65, 0x33, 0x66, 0x34, 0x31, 0x33, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x34, 0x38, 0x32, 0x39, 0x36, 0x66, 0x37, 0x36, 0x33, 0x31, 0x37, 0x30, 0x38, 0x63, 0x39, 0x35, 0x64, 0x32, 0x62, 0x37, 0x34, 0x39, 0x37, 0x35, 0x62, 0x63, 0x34, 0x61, 0x62, 0x38, 0x38, 0x61, 0x63, 0x31, 0x33, 0x39, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x65, 0x30, 0x65, 0x39, 0x39, 0x37, 0x66, 0x31, 0x39, 0x37, 0x37, 0x61, 0x36, 0x31, 0x35, 0x66, 0x35, 0x61, 0x33, 0x31, 0x35, 0x61, 0x66, 0x34, 0x31, 0x33, 0x66, 0x64, 0x34, 0x38, 0x36, 0x39, 0x33, 0x34, 0x33, 0x62, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x36, 0x36, 0x62, 0x32, 0x32, 0x38, 0x30, 0x66, 0x61, 0x32, 0x38, 0x32, 0x63, 0x35, 0x62, 0x36, 0x37, 0x36, 0x33, 0x31, 0x63, 0x65, 0x35, 0x35, 0x32, 0x62, 0x36, 0x32, 0x65, 0x65, 0x35, 0x35, 0x61, 0x64, 0x38, 0x34, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x34, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x36, 0x65, 0x64, 0x32, 0x39, 0x61, 0x39, 0x35, 0x37, 0x35, 0x33, 0x63, 0x33, 0x61, 0x64, 0x39, 0x34, 0x38, 0x33, 0x34, 0x38, 0x65, 0x33, 0x65, 0x37, 0x62, 0x31, 0x61, 0x32, 0x35, 0x31, 0x30, 0x38, 0x30, 0x66, 0x66, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x32, 0x65, 0x37, 0x30, 0x66, 0x30, 0x34, 0x64, 0x31, 0x38, 0x34, 0x30, 0x38, 0x63, 0x62, 0x34, 0x31, 0x65, 0x32, 0x35, 0x36, 0x30, 0x33, 0x37, 0x33, 0x30, 0x35, 0x30, 0x36, 0x62, 0x33, 0x35, 0x61, 0x32, 0x38, 0x37, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x36, 0x62, 0x61, 0x61, 0x61, 0x33, 0x64, 0x65, 0x62, 0x39, 0x38, 0x39, 0x66, 0x32, 0x38, 0x39, 0x36, 0x32, 0x30, 0x30, 0x37, 0x36, 0x36, 0x36, 0x38, 0x36, 0x31, 0x38, 0x65, 0x39, 0x61, 0x63, 0x33, 0x33, 0x32, 0x38, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x35, 0x33, 0x61, 0x37, 0x35, 0x66, 0x39, 0x65, 0x64, 0x31, 0x30, 0x62, 0x32, 0x31, 0x36, 0x34, 0x33, 0x61, 0x30, 0x61, 0x33, 0x64, 0x63, 0x30, 0x35, 0x31, 0x37, 0x61, 0x63, 0x39, 0x36, 0x62, 0x31, 0x61, 0x34, 0x30, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x64, 0x39, 0x31, 0x35, 0x64, 0x35, 0x35, 0x30, 0x62, 0x37, 0x32, 0x33, 0x34, 0x31, 0x35, 0x36, 0x32, 0x30, 0x66, 0x35, 0x61, 0x39, 0x62, 0x35, 0x62, 0x38, 0x38, 0x61, 0x38, 0x35, 0x66, 0x33, 0x38, 0x32, 0x66, 0x30, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x39, 0x32, 0x62, 0x65, 0x35, 0x39, 0x63, 0x36, 0x37, 0x32, 0x31, 0x63, 0x61, 0x66, 0x34, 0x65, 0x30, 0x32, 0x38, 0x66, 0x39, 0x65, 0x38, 0x66, 0x30, 0x35, 0x63, 0x32, 0x35, 0x63, 0x35, 0x35, 0x35, 0x31, 0x35, 0x62, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x62, 0x36, 0x34, 0x33, 0x64, 0x36, 0x66, 0x61, 0x62, 0x64, 0x34, 0x33, 0x37, 0x61, 0x38, 0x35, 0x31, 0x61, 0x63, 0x63, 0x62, 0x65, 0x37, 0x39, 0x61, 0x62, 0x62, 0x37, 0x66, 0x64, 0x65, 0x31, 0x32, 0x36, 0x64, 0x63, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x37, 0x39, 0x37, 0x65, 0x35, 0x38, 0x36, 0x37, 0x35, 0x65, 0x64, 0x35, 0x63, 0x63, 0x34, 0x63, 0x31, 0x39, 0x39, 0x38, 0x30, 0x37, 0x38, 0x33, 0x64, 0x62, 0x64, 0x30, 0x63, 0x39, 0x35, 0x36, 0x30, 0x38, 0x35, 0x31, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x31, 0x34, 0x32, 0x65, 0x64, 0x61, 0x31, 0x31, 0x35, 0x37, 0x62, 0x39, 0x61, 0x39, 0x61, 0x36, 0x34, 0x33, 0x39, 0x30, 0x64, 0x66, 0x37, 0x65, 0x36, 0x61, 0x65, 0x36, 0x39, 0x34, 0x66, 0x61, 0x63, 0x39, 0x38, 0x39, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x36, 0x35, 0x37, 0x39, 0x64, 0x61, 0x65, 0x64, 0x64, 0x32, 0x39, 0x33, 0x37, 0x30, 0x64, 0x39, 0x62, 0x37, 0x33, 0x37, 0x65, 0x65, 0x33, 0x66, 0x35, 0x63, 0x64, 0x39, 0x64, 0x38, 0x34, 0x62, 0x63, 0x32, 0x62, 0x33, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x62, 0x39, 0x62, 0x30, 0x32, 0x61, 0x32, 0x36, 0x62, 0x66, 0x65, 0x31, 0x63, 0x63, 0x63, 0x33, 0x66, 0x30, 0x63, 0x36, 0x32, 0x31, 0x39, 0x65, 0x32, 0x36, 0x31, 0x63, 0x33, 0x39, 0x37, 0x66, 0x63, 0x35, 0x63, 0x61, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x65, 0x38, 0x64, 0x30, 0x62, 0x30, 0x30, 0x38, 0x34, 0x32, 0x31, 0x39, 0x35, 0x34, 0x66, 0x39, 0x32, 0x64, 0x30, 0x30, 0x30, 0x64, 0x33, 0x39, 0x30, 0x66, 0x62, 0x38, 0x66, 0x38, 0x65, 0x36, 0x35, 0x38, 0x65, 0x61, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x38, 0x39, 0x64, 0x30, 0x39, 0x66, 0x33, 0x38, 0x32, 0x36, 0x63, 0x33, 0x65, 0x35, 0x61, 0x66, 0x38, 0x63, 0x37, 0x35, 0x32, 0x61, 0x38, 0x31, 0x31, 0x35, 0x37, 0x32, 0x33, 0x61, 0x38, 0x34, 0x64, 0x38, 0x30, 0x39, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x35, 0x35, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x64, 0x35, 0x64, 0x38, 0x31, 0x65, 0x61, 0x62, 0x33, 0x37, 0x65, 0x31, 0x31, 0x65, 0x36, 0x32, 0x37, 0x36, 0x61, 0x33, 0x61, 0x31, 0x30, 0x39, 0x31, 0x32, 0x35, 0x31, 0x36, 0x30, 0x37, 0x65, 0x30, 0x64, 0x37, 0x65, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x38, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x65, 0x31, 0x62, 0x30, 0x66, 0x36, 0x61, 0x64, 0x63, 0x34, 0x37, 0x30, 0x35, 0x31, 0x65, 0x38, 0x61, 0x62, 0x33, 0x38, 0x62, 0x33, 0x39, 0x65, 0x64, 0x62, 0x34, 0x31, 0x38, 0x36, 0x62, 0x30, 0x33, 0x62, 0x61, 0x62, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x66, 0x63, 0x66, 0x35, 0x66, 0x32, 0x35, 0x30, 0x39, 0x31, 0x63, 0x65, 0x35, 0x37, 0x38, 0x37, 0x35, 0x66, 0x63, 0x36, 0x37, 0x34, 0x64, 0x63, 0x66, 0x31, 0x30, 0x34, 0x65, 0x32, 0x61, 0x37, 0x33, 0x64, 0x64, 0x32, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x33, 0x65, 0x66, 0x30, 0x35, 0x64, 0x61, 0x65, 0x39, 0x64, 0x63, 0x62, 0x64, 0x34, 0x38, 0x39, 0x66, 0x33, 0x30, 0x32, 0x34, 0x34, 0x30, 0x38, 0x36, 0x36, 0x39, 0x64, 0x65, 0x32, 0x34, 0x34, 0x63, 0x35, 0x32, 0x61, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x61, 0x38, 0x62, 0x33, 0x37, 0x31, 0x32, 0x37, 0x31, 0x34, 0x39, 0x62, 0x64, 0x62, 0x66, 0x65, 0x65, 0x32, 0x35, 0x63, 0x33, 0x34, 0x64, 0x38, 0x37, 0x38, 0x35, 0x31, 0x30, 0x39, 0x35, 0x31, 0x65, 0x61, 0x31, 0x30, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x38, 0x36, 0x33, 0x61, 0x63, 0x65, 0x63, 0x37, 0x35, 0x64, 0x30, 0x33, 0x64, 0x35, 0x33, 0x65, 0x38, 0x36, 0x30, 0x65, 0x36, 0x34, 0x30, 0x30, 0x32, 0x66, 0x32, 0x63, 0x31, 0x36, 0x35, 0x65, 0x35, 0x33, 0x38, 0x33, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x62, 0x39, 0x65, 0x37, 0x33, 0x33, 0x63, 0x62, 0x61, 0x34, 0x62, 0x65, 0x30, 0x30, 0x34, 0x32, 0x39, 0x62, 0x34, 0x62, 0x64, 0x39, 0x64, 0x66, 0x61, 0x36, 0x34, 0x37, 0x33, 0x32, 0x30, 0x35, 0x33, 0x61, 0x37, 0x64, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x61, 0x64, 0x66, 0x63, 0x64, 0x30, 0x39, 0x37, 0x38, 0x65, 0x64, 0x61, 0x64, 0x37, 0x34, 0x61, 0x33, 0x32, 0x62, 0x64, 0x30, 0x31, 0x61, 0x30, 0x61, 0x35, 0x31, 0x64, 0x33, 0x37, 0x66, 0x32, 0x34, 0x36, 0x65, 0x36, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x30, 0x39, 0x30, 0x38, 0x37, 0x36, 0x62, 0x61, 0x61, 0x64, 0x66, 0x65, 0x65, 0x36, 0x35, 0x63, 0x33, 0x64, 0x33, 0x36, 0x33, 0x62, 0x61, 0x35, 0x35, 0x33, 0x31, 0x32, 0x37, 0x34, 0x38, 0x63, 0x66, 0x61, 0x38, 0x37, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x38, 0x39, 0x66, 0x61, 0x37, 0x36, 0x39, 0x38, 0x34, 0x64, 0x62, 0x35, 0x65, 0x63, 0x34, 0x30, 0x30, 0x34, 0x62, 0x34, 0x36, 0x65, 0x65, 0x38, 0x61, 0x35, 0x39, 0x34, 0x39, 0x32, 0x63, 0x33, 0x30, 0x37, 0x34, 0x34, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x38, 0x35, 0x33, 0x36, 0x31, 0x65, 0x65, 0x36, 0x62, 0x66, 0x30, 0x36, 0x65, 0x66, 0x36, 0x35, 0x30, 0x38, 0x63, 0x63, 0x64, 0x32, 0x33, 0x64, 0x39, 0x34, 0x36, 0x34, 0x31, 0x66, 0x38, 0x31, 0x34, 0x64, 0x33, 0x65, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x62, 0x37, 0x33, 0x31, 0x31, 0x36, 0x30, 0x64, 0x32, 0x65, 0x38, 0x39, 0x36, 0x35, 0x36, 0x37, 0x30, 0x62, 0x64, 0x65, 0x39, 0x32, 0x35, 0x64, 0x39, 0x64, 0x65, 0x35, 0x35, 0x31, 0x30, 0x39, 0x33, 0x35, 0x33, 0x34, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x66, 0x34, 0x64, 0x38, 0x61, 0x32, 0x63, 0x32, 0x33, 0x63, 0x35, 0x32, 0x37, 0x39, 0x31, 0x38, 0x37, 0x62, 0x36, 0x34, 0x65, 0x39, 0x36, 0x66, 0x37, 0x34, 0x31, 0x34, 0x30, 0x34, 0x30, 0x38, 0x35, 0x33, 0x38, 0x35, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x34, 0x36, 0x36, 0x38, 0x33, 0x63, 0x63, 0x39, 0x39, 0x64, 0x62, 0x37, 0x63, 0x34, 0x61, 0x35, 0x32, 0x62, 0x63, 0x62, 0x61, 0x63, 0x61, 0x61, 0x62, 0x30, 0x62, 0x33, 0x32, 0x66, 0x36, 0x62, 0x66, 0x63, 0x39, 0x33, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x32, 0x37, 0x33, 0x65, 0x36, 0x33, 0x37, 0x65, 0x66, 0x31, 0x65, 0x61, 0x63, 0x34, 0x38, 0x31, 0x31, 0x31, 0x39, 0x34, 0x31, 0x33, 0x62, 0x39, 0x31, 0x63, 0x39, 0x38, 0x39, 0x64, 0x63, 0x35, 0x65, 0x61, 0x63, 0x31, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x66, 0x62, 0x61, 0x38, 0x66, 0x62, 0x32, 0x61, 0x63, 0x35, 0x62, 0x36, 0x37, 0x33, 0x30, 0x37, 0x32, 0x39, 0x61, 0x39, 0x37, 0x32, 0x65, 0x63, 0x32, 0x32, 0x34, 0x34, 0x32, 0x36, 0x61, 0x32, 0x38, 0x37, 0x63, 0x33, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x33, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x37, 0x33, 0x65, 0x65, 0x61, 0x63, 0x63, 0x30, 0x35, 0x30, 0x66, 0x37, 0x34, 0x37, 0x32, 0x30, 0x62, 0x34, 0x61, 0x31, 0x62, 0x64, 0x35, 0x37, 0x38, 0x39, 0x35, 0x62, 0x31, 0x63, 0x63, 0x65, 0x65, 0x62, 0x34, 0x39, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x61, 0x31, 0x32, 0x32, 0x61, 0x32, 0x33, 0x38, 0x32, 0x63, 0x35, 0x32, 0x33, 0x39, 0x33, 0x31, 0x66, 0x62, 0x35, 0x31, 0x61, 0x30, 0x63, 0x63, 0x61, 0x64, 0x33, 0x62, 0x65, 0x62, 0x35, 0x62, 0x37, 0x32, 0x35, 0x39, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x62, 0x37, 0x37, 0x39, 0x62, 0x39, 0x34, 0x62, 0x66, 0x61, 0x33, 0x63, 0x32, 0x65, 0x31, 0x66, 0x35, 0x38, 0x37, 0x62, 0x63, 0x63, 0x39, 0x63, 0x37, 0x65, 0x32, 0x31, 0x37, 0x38, 0x39, 0x32, 0x32, 0x32, 0x33, 0x37, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x66, 0x39, 0x35, 0x63, 0x35, 0x62, 0x31, 0x31, 0x61, 0x32, 0x39, 0x33, 0x39, 0x34, 0x30, 0x65, 0x33, 0x35, 0x63, 0x30, 0x62, 0x38, 0x39, 0x38, 0x64, 0x38, 0x62, 0x37, 0x35, 0x66, 0x30, 0x38, 0x61, 0x61, 0x62, 0x30, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x36, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x32, 0x32, 0x38, 0x38, 0x65, 0x66, 0x34, 0x65, 0x62, 0x66, 0x38, 0x38, 0x65, 0x38, 0x36, 0x64, 0x62, 0x31, 0x33, 0x64, 0x38, 0x61, 0x30, 0x65, 0x30, 0x62, 0x66, 0x35, 0x32, 0x61, 0x30, 0x35, 0x36, 0x35, 0x38, 0x32, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x65, 0x61, 0x35, 0x62, 0x31, 0x31, 0x61, 0x64, 0x38, 0x64, 0x32, 0x39, 0x62, 0x31, 0x61, 0x34, 0x63, 0x62, 0x36, 0x37, 0x62, 0x66, 0x35, 0x38, 0x63, 0x61, 0x36, 0x63, 0x39, 0x66, 0x39, 0x63, 0x33, 0x33, 0x38, 0x63, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x31, 0x37, 0x64, 0x36, 0x38, 0x64, 0x34, 0x61, 0x66, 0x33, 0x34, 0x31, 0x64, 0x36, 0x35, 0x31, 0x65, 0x37, 0x66, 0x30, 0x30, 0x37, 0x35, 0x63, 0x36, 0x64, 0x65, 0x36, 0x64, 0x37, 0x31, 0x34, 0x34, 0x65, 0x37, 0x34, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x35, 0x38, 0x30, 0x30, 0x32, 0x32, 0x37, 0x64, 0x34, 0x64, 0x63, 0x66, 0x37, 0x35, 0x65, 0x33, 0x30, 0x66, 0x35, 0x35, 0x39, 0x35, 0x63, 0x35, 0x62, 0x65, 0x64, 0x33, 0x66, 0x37, 0x32, 0x65, 0x33, 0x34, 0x31, 0x65, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x33, 0x37, 0x35, 0x39, 0x66, 0x33, 0x33, 0x33, 0x65, 0x31, 0x33, 0x65, 0x33, 0x30, 0x36, 0x39, 0x65, 0x32, 0x30, 0x33, 0x34, 0x62, 0x34, 0x66, 0x30, 0x35, 0x33, 0x39, 0x38, 0x39, 0x31, 0x38, 0x31, 0x31, 0x39, 0x64, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x39, 0x38, 0x64, 0x31, 0x36, 0x64, 0x61, 0x34, 0x65, 0x34, 0x36, 0x30, 0x63, 0x34, 0x36, 0x30, 0x63, 0x64, 0x34, 0x38, 0x35, 0x66, 0x61, 0x65, 0x30, 0x66, 0x61, 0x30, 0x35, 0x39, 0x39, 0x37, 0x30, 0x38, 0x65, 0x62, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x34, 0x62, 0x65, 0x63, 0x35, 0x30, 0x36, 0x39, 0x66, 0x38, 0x35, 0x35, 0x61, 0x34, 0x66, 0x64, 0x35, 0x38, 0x39, 0x32, 0x61, 0x36, 0x63, 0x34, 0x34, 0x39, 0x31, 0x64, 0x62, 0x30, 0x37, 0x63, 0x38, 0x38, 0x66, 0x66, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x32, 0x38, 0x33, 0x32, 0x39, 0x39, 0x36, 0x30, 0x33, 0x64, 0x38, 0x37, 0x35, 0x38, 0x65, 0x38, 0x63, 0x61, 0x62, 0x30, 0x38, 0x32, 0x31, 0x32, 0x35, 0x64, 0x32, 0x63, 0x38, 0x66, 0x37, 0x64, 0x34, 0x34, 0x35, 0x34, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x31, 0x35, 0x36, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x31, 0x31, 0x63, 0x32, 0x65, 0x39, 0x61, 0x61, 0x31, 0x61, 0x63, 0x33, 0x34, 0x36, 0x32, 0x65, 0x62, 0x61, 0x35, 0x65, 0x38, 0x38, 0x66, 0x63, 0x62, 0x35, 0x31, 0x32, 0x30, 0x65, 0x39, 0x66, 0x36, 0x65, 0x32, 0x63, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x35, 0x34, 0x37, 0x64, 0x33, 0x37, 0x36, 0x65, 0x35, 0x33, 0x36, 0x39, 0x62, 0x63, 0x66, 0x39, 0x37, 0x38, 0x66, 0x63, 0x31, 0x36, 0x32, 0x63, 0x33, 0x63, 0x35, 0x36, 0x61, 0x65, 0x34, 0x35, 0x33, 0x35, 0x34, 0x37, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x37, 0x34, 0x37, 0x65, 0x65, 0x35, 0x39, 0x36, 0x39, 0x62, 0x66, 0x37, 0x39, 0x64, 0x35, 0x37, 0x33, 0x38, 0x31, 0x64, 0x36, 0x66, 0x65, 0x33, 0x61, 0x32, 0x34, 0x30, 0x36, 0x63, 0x64, 0x30, 0x64, 0x38, 0x63, 0x65, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x39, 0x36, 0x32, 0x62, 0x37, 0x35, 0x64, 0x62, 0x35, 0x64, 0x32, 0x34, 0x63, 0x37, 0x65, 0x38, 0x62, 0x37, 0x63, 0x65, 0x66, 0x31, 0x30, 0x36, 0x38, 0x63, 0x33, 0x65, 0x36, 0x37, 0x63, 0x65, 0x62, 0x62, 0x33, 0x30, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x62, 0x66, 0x36, 0x36, 0x38, 0x38, 0x35, 0x32, 0x32, 0x66, 0x33, 0x35, 0x34, 0x36, 0x37, 0x61, 0x37, 0x66, 0x37, 0x35, 0x33, 0x30, 0x32, 0x33, 0x31, 0x34, 0x63, 0x30, 0x32, 0x62, 0x61, 0x31, 0x37, 0x36, 0x38, 0x30, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x63, 0x62, 0x36, 0x63, 0x33, 0x62, 0x30, 0x30, 0x37, 0x32, 0x64, 0x33, 0x31, 0x31, 0x36, 0x37, 0x36, 0x31, 0x62, 0x35, 0x33, 0x32, 0x62, 0x32, 0x31, 0x38, 0x34, 0x34, 0x33, 0x62, 0x35, 0x33, 0x65, 0x38, 0x66, 0x36, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x31, 0x37, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x63, 0x38, 0x30, 0x63, 0x61, 0x61, 0x30, 0x38, 0x31, 0x62, 0x33, 0x38, 0x33, 0x35, 0x31, 0x64, 0x32, 0x61, 0x30, 0x65, 0x30, 0x65, 0x30, 0x30, 0x66, 0x38, 0x30, 0x61, 0x33, 0x34, 0x65, 0x35, 0x36, 0x34, 0x37, 0x34, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x35, 0x61, 0x35, 0x30, 0x32, 0x61, 0x35, 0x62, 0x36, 0x37, 0x37, 0x32, 0x38, 0x37, 0x34, 0x37, 0x30, 0x66, 0x36, 0x35, 0x63, 0x35, 0x61, 0x61, 0x35, 0x31, 0x62, 0x38, 0x37, 0x63, 0x31, 0x30, 0x31, 0x35, 0x30, 0x35, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x31, 0x39, 0x34, 0x62, 0x34, 0x65, 0x63, 0x65, 0x66, 0x38, 0x62, 0x62, 0x37, 0x31, 0x31, 0x65, 0x61, 0x32, 0x66, 0x66, 0x32, 0x34, 0x66, 0x65, 0x63, 0x34, 0x65, 0x38, 0x37, 0x62, 0x64, 0x30, 0x33, 0x32, 0x66, 0x37, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x37, 0x35, 0x34, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x36, 0x62, 0x66, 0x31, 0x34, 0x30, 0x32, 0x63, 0x38, 0x33, 0x38, 0x30, 0x30, 0x66, 0x38, 0x39, 0x33, 0x65, 0x35, 0x38, 0x33, 0x31, 0x39, 0x32, 0x35, 0x38, 0x32, 0x61, 0x31, 0x33, 0x34, 0x65, 0x62, 0x35, 0x33, 0x32, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x63, 0x62, 0x31, 0x61, 0x64, 0x61, 0x35, 0x64, 0x61, 0x39, 0x61, 0x30, 0x34, 0x32, 0x33, 0x38, 0x37, 0x33, 0x38, 0x31, 0x34, 0x37, 0x39, 0x33, 0x66, 0x31, 0x36, 0x31, 0x34, 0x34, 0x65, 0x66, 0x33, 0x36, 0x62, 0x32, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x34, 0x33, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x63, 0x63, 0x65, 0x30, 0x36, 0x62, 0x64, 0x36, 0x30, 0x38, 0x39, 0x64, 0x30, 0x65, 0x34, 0x35, 0x38, 0x65, 0x66, 0x35, 0x36, 0x31, 0x66, 0x35, 0x61, 0x36, 0x38, 0x39, 0x34, 0x38, 0x30, 0x61, 0x66, 0x65, 0x37, 0x30, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x65, 0x36, 0x62, 0x63, 0x62, 0x30, 0x66, 0x30, 0x63, 0x30, 0x37, 0x38, 0x35, 0x32, 0x36, 0x34, 0x33, 0x33, 0x32, 0x34, 0x61, 0x61, 0x35, 0x64, 0x66, 0x35, 0x66, 0x64, 0x36, 0x32, 0x32, 0x35, 0x61, 0x62, 0x63, 0x33, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x37, 0x39, 0x39, 0x65, 0x39, 0x34, 0x33, 0x65, 0x33, 0x30, 0x36, 0x62, 0x61, 0x32, 0x65, 0x35, 0x62, 0x39, 0x39, 0x63, 0x38, 0x61, 0x36, 0x38, 0x35, 0x38, 0x63, 0x62, 0x62, 0x35, 0x32, 0x63, 0x30, 0x63, 0x66, 0x37, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x35, 0x62, 0x31, 0x64, 0x63, 0x62, 0x32, 0x65, 0x34, 0x31, 0x64, 0x63, 0x32, 0x37, 0x66, 0x66, 0x61, 0x30, 0x32, 0x34, 0x64, 0x61, 0x61, 0x64, 0x66, 0x36, 0x31, 0x39, 0x63, 0x31, 0x31, 0x31, 0x37, 0x35, 0x63, 0x30, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x65, 0x33, 0x38, 0x65, 0x65, 0x30, 0x63, 0x65, 0x34, 0x38, 0x63, 0x39, 0x63, 0x61, 0x36, 0x34, 0x35, 0x63, 0x31, 0x30, 0x31, 0x39, 0x66, 0x37, 0x33, 0x62, 0x35, 0x33, 0x35, 0x35, 0x35, 0x38, 0x31, 0x63, 0x35, 0x36, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x62, 0x34, 0x63, 0x33, 0x63, 0x31, 0x36, 0x62, 0x62, 0x31, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x36, 0x62, 0x37, 0x61, 0x31, 0x39, 0x62, 0x31, 0x32, 0x37, 0x61, 0x31, 0x61, 0x63, 0x39, 0x33, 0x39, 0x30, 0x63, 0x63, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x39, 0x37, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x63, 0x30, 0x32, 0x63, 0x64, 0x34, 0x33, 0x33, 0x30, 0x63, 0x39, 0x33, 0x64, 0x36, 0x66, 0x62, 0x64, 0x61, 0x34, 0x66, 0x36, 0x64, 0x62, 0x32, 0x61, 0x38, 0x35, 0x64, 0x66, 0x32, 0x32, 0x66, 0x34, 0x33, 0x63, 0x32, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x65, 0x63, 0x39, 0x31, 0x65, 0x66, 0x36, 0x39, 0x34, 0x31, 0x63, 0x66, 0x36, 0x33, 0x30, 0x62, 0x61, 0x39, 0x61, 0x33, 0x65, 0x37, 0x38, 0x37, 0x61, 0x30, 0x31, 0x32, 0x66, 0x34, 0x61, 0x32, 0x64, 0x39, 0x31, 0x64, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x61, 0x63, 0x30, 0x37, 0x33, 0x62, 0x65, 0x37, 0x39, 0x63, 0x65, 0x36, 0x35, 0x37, 0x61, 0x39, 0x33, 0x61, 0x61, 0x36, 0x39, 0x33, 0x65, 0x65, 0x34, 0x33, 0x62, 0x66, 0x30, 0x66, 0x61, 0x34, 0x31, 0x66, 0x65, 0x66, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x66, 0x65, 0x38, 0x38, 0x34, 0x64, 0x39, 0x30, 0x33, 0x37, 0x32, 0x39, 0x31, 0x62, 0x34, 0x64, 0x35, 0x32, 0x65, 0x36, 0x32, 0x38, 0x35, 0x61, 0x65, 0x36, 0x38, 0x64, 0x65, 0x61, 0x30, 0x62, 0x65, 0x39, 0x66, 0x66, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x31, 0x30, 0x37, 0x61, 0x39, 0x61, 0x66, 0x33, 0x33, 0x32, 0x32, 0x64, 0x35, 0x32, 0x33, 0x38, 0x64, 0x66, 0x30, 0x31, 0x33, 0x32, 0x34, 0x31, 0x39, 0x31, 0x33, 0x31, 0x36, 0x32, 0x39, 0x35, 0x33, 0x39, 0x35, 0x37, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x63, 0x61, 0x63, 0x35, 0x65, 0x64, 0x30, 0x33, 0x34, 0x37, 0x37, 0x64, 0x33, 0x39, 0x30, 0x62, 0x62, 0x32, 0x36, 0x37, 0x64, 0x34, 0x65, 0x62, 0x64, 0x34, 0x36, 0x31, 0x30, 0x31, 0x66, 0x62, 0x63, 0x32, 0x63, 0x33, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x66, 0x62, 0x39, 0x34, 0x37, 0x33, 0x36, 0x34, 0x65, 0x37, 0x36, 0x39, 0x35, 0x37, 0x36, 0x35, 0x33, 0x36, 0x31, 0x65, 0x62, 0x62, 0x31, 0x65, 0x38, 0x30, 0x31, 0x66, 0x66, 0x62, 0x38, 0x62, 0x39, 0x35, 0x65, 0x36, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x38, 0x36, 0x30, 0x39, 0x39, 0x37, 0x64, 0x37, 0x33, 0x30, 0x62, 0x32, 0x64, 0x38, 0x33, 0x62, 0x37, 0x33, 0x32, 0x34, 0x31, 0x61, 0x32, 0x35, 0x64, 0x33, 0x36, 0x36, 0x37, 0x64, 0x35, 0x31, 0x63, 0x39, 0x30, 0x38, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x39, 0x64, 0x35, 0x30, 0x36, 0x32, 0x63, 0x37, 0x39, 0x36, 0x64, 0x64, 0x37, 0x37, 0x36, 0x31, 0x66, 0x31, 0x66, 0x31, 0x33, 0x65, 0x35, 0x35, 0x38, 0x64, 0x37, 0x33, 0x61, 0x35, 0x39, 0x66, 0x38, 0x32, 0x66, 0x33, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x31, 0x34, 0x32, 0x66, 0x65, 0x34, 0x37, 0x65, 0x64, 0x61, 0x39, 0x37, 0x65, 0x36, 0x35, 0x30, 0x33, 0x62, 0x33, 0x38, 0x36, 0x62, 0x31, 0x38, 0x61, 0x32, 0x62, 0x65, 0x64, 0x64, 0x37, 0x33, 0x63, 0x63, 0x62, 0x35, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x61, 0x35, 0x64, 0x65, 0x30, 0x30, 0x38, 0x31, 0x37, 0x64, 0x65, 0x30, 0x63, 0x65, 0x64, 0x63, 0x65, 0x35, 0x66, 0x64, 0x30, 0x30, 0x30, 0x31, 0x32, 0x38, 0x64, 0x65, 0x64, 0x65, 0x31, 0x32, 0x36, 0x34, 0x38, 0x62, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x34, 0x62, 0x37, 0x34, 0x33, 0x39, 0x35, 0x35, 0x61, 0x35, 0x31, 0x32, 0x64, 0x65, 0x36, 0x65, 0x30, 0x64, 0x38, 0x38, 0x36, 0x61, 0x38, 0x63, 0x62, 0x64, 0x30, 0x32, 0x38, 0x32, 0x62, 0x65, 0x65, 0x36, 0x64, 0x32, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x65, 0x37, 0x39, 0x61, 0x65, 0x31, 0x66, 0x66, 0x34, 0x66, 0x31, 0x36, 0x30, 0x36, 0x64, 0x35, 0x39, 0x32, 0x37, 0x30, 0x32, 0x31, 0x36, 0x66, 0x61, 0x34, 0x36, 0x61, 0x62, 0x32, 0x64, 0x64, 0x64, 0x34, 0x65, 0x63, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x38, 0x31, 0x30, 0x31, 0x63, 0x65, 0x34, 0x36, 0x62, 0x37, 0x32, 0x30, 0x61, 0x32, 0x32, 0x31, 0x34, 0x64, 0x63, 0x64, 0x61, 0x65, 0x36, 0x36, 0x31, 0x38, 0x61, 0x35, 0x33, 0x31, 0x37, 0x37, 0x66, 0x66, 0x61, 0x33, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x38, 0x38, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x38, 0x37, 0x30, 0x63, 0x65, 0x33, 0x34, 0x32, 0x64, 0x34, 0x33, 0x33, 0x34, 0x33, 0x33, 0x33, 0x33, 0x36, 0x37, 0x33, 0x30, 0x33, 0x38, 0x62, 0x34, 0x37, 0x36, 0x34, 0x61, 0x34, 0x36, 0x65, 0x39, 0x32, 0x35, 0x66, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x33, 0x62, 0x64, 0x33, 0x35, 0x30, 0x32, 0x66, 0x34, 0x35, 0x66, 0x38, 0x62, 0x63, 0x34, 0x64, 0x61, 0x33, 0x37, 0x30, 0x62, 0x33, 0x32, 0x33, 0x62, 0x64, 0x61, 0x63, 0x33, 0x66, 0x63, 0x66, 0x35, 0x66, 0x31, 0x39, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x36, 0x37, 0x66, 0x34, 0x35, 0x34, 0x39, 0x61, 0x66, 0x62, 0x66, 0x65, 0x38, 0x38, 0x34, 0x63, 0x35, 0x39, 0x63, 0x62, 0x63, 0x31, 0x32, 0x62, 0x39, 0x36, 0x39, 0x33, 0x34, 0x39, 0x32, 0x33, 0x64, 0x34, 0x35, 0x64, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x32, 0x61, 0x34, 0x32, 0x65, 0x36, 0x65, 0x30, 0x33, 0x33, 0x64, 0x30, 0x31, 0x30, 0x36, 0x31, 0x31, 0x33, 0x31, 0x39, 0x32, 0x39, 0x66, 0x37, 0x61, 0x36, 0x65, 0x65, 0x31, 0x35, 0x33, 0x38, 0x30, 0x32, 0x31, 0x65, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x65, 0x31, 0x66, 0x37, 0x63, 0x62, 0x30, 0x30, 0x61, 0x31, 0x31, 0x30, 0x65, 0x64, 0x64, 0x30, 0x65, 0x62, 0x66, 0x38, 0x62, 0x33, 0x37, 0x37, 0x65, 0x66, 0x38, 0x61, 0x37, 0x62, 0x62, 0x38, 0x35, 0x36, 0x31, 0x31, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x38, 0x37, 0x65, 0x63, 0x64, 0x65, 0x30, 0x65, 0x65, 0x34, 0x63, 0x38, 0x30, 0x37, 0x39, 0x34, 0x39, 0x39, 0x66, 0x64, 0x38, 0x65, 0x30, 0x33, 0x34, 0x37, 0x33, 0x62, 0x64, 0x38, 0x38, 0x61, 0x64, 0x37, 0x35, 0x32, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x66, 0x66, 0x39, 0x30, 0x65, 0x36, 0x64, 0x63, 0x33, 0x35, 0x39, 0x64, 0x32, 0x35, 0x39, 0x30, 0x38, 0x38, 0x32, 0x62, 0x31, 0x34, 0x38, 0x33, 0x65, 0x64, 0x62, 0x63, 0x66, 0x38, 0x38, 0x37, 0x63, 0x30, 0x65, 0x34, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x65, 0x35, 0x31, 0x32, 0x31, 0x34, 0x39, 0x61, 0x31, 0x38, 0x64, 0x33, 0x36, 0x39, 0x62, 0x37, 0x33, 0x63, 0x37, 0x31, 0x65, 0x66, 0x61, 0x34, 0x33, 0x65, 0x38, 0x36, 0x63, 0x39, 0x65, 0x64, 0x61, 0x62, 0x61, 0x66, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x32, 0x30, 0x33, 0x30, 0x39, 0x35, 0x65, 0x64, 0x62, 0x37, 0x30, 0x32, 0x38, 0x65, 0x36, 0x38, 0x37, 0x31, 0x63, 0x65, 0x30, 0x61, 0x38, 0x34, 0x66, 0x35, 0x34, 0x38, 0x34, 0x35, 0x39, 0x66, 0x38, 0x33, 0x33, 0x30, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x62, 0x34, 0x62, 0x66, 0x33, 0x66, 0x64, 0x66, 0x66, 0x36, 0x64, 0x65, 0x33, 0x66, 0x34, 0x65, 0x35, 0x36, 0x62, 0x61, 0x36, 0x64, 0x37, 0x37, 0x39, 0x39, 0x64, 0x63, 0x34, 0x62, 0x39, 0x33, 0x61, 0x36, 0x35, 0x34, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x37, 0x35, 0x39, 0x35, 0x36, 0x65, 0x38, 0x66, 0x65, 0x64, 0x35, 0x30, 0x66, 0x35, 0x61, 0x37, 0x64, 0x64, 0x37, 0x63, 0x66, 0x64, 0x32, 0x37, 0x64, 0x61, 0x32, 0x30, 0x30, 0x66, 0x36, 0x37, 0x34, 0x36, 0x61, 0x65, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x63, 0x38, 0x65, 0x62, 0x65, 0x38, 0x39, 0x38, 0x38, 0x62, 0x64, 0x34, 0x31, 0x30, 0x35, 0x61, 0x63, 0x63, 0x34, 0x63, 0x30, 0x31, 0x38, 0x65, 0x35, 0x34, 0x36, 0x61, 0x31, 0x65, 0x38, 0x66, 0x39, 0x63, 0x37, 0x38, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x39, 0x61, 0x63, 0x64, 0x34, 0x34, 0x34, 0x35, 0x64, 0x39, 0x63, 0x39, 0x35, 0x35, 0x34, 0x36, 0x38, 0x39, 0x63, 0x61, 0x62, 0x62, 0x62, 0x61, 0x62, 0x31, 0x38, 0x38, 0x30, 0x30, 0x66, 0x66, 0x31, 0x37, 0x34, 0x31, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x33, 0x66, 0x32, 0x66, 0x61, 0x62, 0x37, 0x61, 0x66, 0x62, 0x36, 0x65, 0x30, 0x31, 0x37, 0x62, 0x39, 0x34, 0x37, 0x36, 0x36, 0x30, 0x36, 0x39, 0x61, 0x34, 0x62, 0x34, 0x33, 0x62, 0x33, 0x38, 0x39, 0x36, 0x34, 0x39, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x35, 0x36, 0x39, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x66, 0x37, 0x36, 0x35, 0x63, 0x34, 0x34, 0x66, 0x65, 0x34, 0x35, 0x66, 0x37, 0x39, 0x30, 0x36, 0x37, 0x37, 0x39, 0x34, 0x34, 0x38, 0x34, 0x34, 0x62, 0x65, 0x34, 0x66, 0x32, 0x64, 0x34, 0x32, 0x31, 0x36, 0x35, 0x66, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x38, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x63, 0x39, 0x64, 0x35, 0x62, 0x62, 0x34, 0x62, 0x31, 0x39, 0x63, 0x65, 0x63, 0x64, 0x39, 0x34, 0x66, 0x31, 0x39, 0x65, 0x63, 0x32, 0x35, 0x64, 0x32, 0x30, 0x30, 0x65, 0x61, 0x37, 0x32, 0x66, 0x32, 0x35, 0x64, 0x37, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x66, 0x36, 0x30, 0x61, 0x33, 0x35, 0x34, 0x38, 0x34, 0x66, 0x65, 0x37, 0x37, 0x39, 0x32, 0x62, 0x63, 0x63, 0x38, 0x61, 0x37, 0x62, 0x36, 0x33, 0x39, 0x33, 0x64, 0x30, 0x64, 0x64, 0x61, 0x31, 0x66, 0x36, 0x62, 0x37, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x38, 0x65, 0x64, 0x39, 0x39, 0x30, 0x61, 0x32, 0x61, 0x66, 0x66, 0x34, 0x34, 0x61, 0x39, 0x34, 0x31, 0x30, 0x35, 0x64, 0x35, 0x38, 0x63, 0x33, 0x30, 0x35, 0x32, 0x35, 0x37, 0x37, 0x33, 0x35, 0x63, 0x38, 0x36, 0x38, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x30, 0x62, 0x65, 0x38, 0x66, 0x64, 0x35, 0x65, 0x32, 0x39, 0x31, 0x38, 0x34, 0x36, 0x38, 0x62, 0x65, 0x32, 0x61, 0x61, 0x62, 0x65, 0x61, 0x38, 0x30, 0x64, 0x38, 0x32, 0x38, 0x34, 0x33, 0x35, 0x64, 0x37, 0x39, 0x36, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x65, 0x61, 0x36, 0x64, 0x32, 0x36, 0x64, 0x30, 0x38, 0x30, 0x65, 0x35, 0x37, 0x61, 0x65, 0x65, 0x33, 0x39, 0x32, 0x36, 0x62, 0x31, 0x38, 0x65, 0x38, 0x65, 0x64, 0x37, 0x33, 0x61, 0x34, 0x65, 0x35, 0x62, 0x32, 0x38, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x38, 0x32, 0x34, 0x62, 0x61, 0x31, 0x64, 0x62, 0x65, 0x62, 0x62, 0x65, 0x66, 0x39, 0x38, 0x34, 0x36, 0x65, 0x66, 0x33, 0x64, 0x30, 0x66, 0x36, 0x63, 0x31, 0x62, 0x30, 0x31, 0x37, 0x65, 0x36, 0x39, 0x31, 0x32, 0x65, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x37, 0x30, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x35, 0x30, 0x30, 0x63, 0x31, 0x36, 0x36, 0x66, 0x38, 0x62, 0x65, 0x61, 0x32, 0x66, 0x38, 0x32, 0x33, 0x34, 0x37, 0x36, 0x30, 0x36, 0x65, 0x35, 0x30, 0x32, 0x34, 0x62, 0x65, 0x39, 0x65, 0x34, 0x66, 0x34, 0x63, 0x65, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x33, 0x36, 0x39, 0x31, 0x36, 0x35, 0x66, 0x62, 0x37, 0x30, 0x62, 0x38, 0x31, 0x61, 0x33, 0x61, 0x37, 0x36, 0x35, 0x66, 0x31, 0x38, 0x38, 0x66, 0x64, 0x36, 0x30, 0x63, 0x62, 0x65, 0x35, 0x65, 0x37, 0x62, 0x30, 0x39, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x64, 0x64, 0x62, 0x64, 0x39, 0x62, 0x63, 0x61, 0x36, 0x36, 0x65, 0x32, 0x38, 0x37, 0x36, 0x35, 0x63, 0x32, 0x31, 0x36, 0x32, 0x63, 0x38, 0x34, 0x33, 0x33, 0x35, 0x34, 0x38, 0x63, 0x31, 0x30, 0x35, 0x32, 0x65, 0x64, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x38, 0x31, 0x31, 0x35, 0x36, 0x65, 0x36, 0x39, 0x38, 0x36, 0x33, 0x39, 0x39, 0x34, 0x33, 0x63, 0x30, 0x31, 0x61, 0x37, 0x35, 0x32, 0x37, 0x32, 0x61, 0x64, 0x33, 0x64, 0x33, 0x35, 0x38, 0x35, 0x31, 0x61, 0x62, 0x32, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x34, 0x39, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x38, 0x30, 0x34, 0x61, 0x61, 0x63, 0x36, 0x34, 0x62, 0x34, 0x31, 0x39, 0x39, 0x30, 0x38, 0x33, 0x39, 0x38, 0x32, 0x39, 0x30, 0x32, 0x39, 0x39, 0x34, 0x64, 0x39, 0x63, 0x35, 0x65, 0x64, 0x38, 0x38, 0x32, 0x38, 0x66, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x65, 0x38, 0x65, 0x39, 0x37, 0x61, 0x65, 0x39, 0x38, 0x33, 0x39, 0x62, 0x39, 0x65, 0x65, 0x35, 0x30, 0x37, 0x65, 0x65, 0x64, 0x62, 0x32, 0x38, 0x65, 0x64, 0x66, 0x62, 0x37, 0x34, 0x37, 0x37, 0x30, 0x33, 0x31, 0x34, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x38, 0x30, 0x38, 0x63, 0x61, 0x62, 0x62, 0x38, 0x66, 0x66, 0x35, 0x66, 0x62, 0x62, 0x36, 0x33, 0x31, 0x32, 0x64, 0x39, 0x63, 0x38, 0x65, 0x38, 0x34, 0x61, 0x66, 0x38, 0x63, 0x66, 0x31, 0x32, 0x65, 0x66, 0x30, 0x38, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x61, 0x35, 0x33, 0x39, 0x35, 0x38, 0x36, 0x65, 0x34, 0x37, 0x31, 0x39, 0x31, 0x37, 0x34, 0x61, 0x33, 0x62, 0x34, 0x36, 0x62, 0x39, 0x62, 0x33, 0x65, 0x36, 0x36, 0x33, 0x61, 0x37, 0x64, 0x31, 0x62, 0x35, 0x62, 0x39, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x61, 0x30, 0x36, 0x35, 0x66, 0x32, 0x38, 0x37, 0x64, 0x39, 0x31, 0x64, 0x37, 0x37, 0x63, 0x64, 0x36, 0x32, 0x36, 0x61, 0x66, 0x33, 0x38, 0x66, 0x66, 0x61, 0x32, 0x32, 0x30, 0x64, 0x39, 0x62, 0x35, 0x35, 0x32, 0x61, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x65, 0x36, 0x30, 0x39, 0x30, 0x30, 0x63, 0x61, 0x63, 0x63, 0x37, 0x32, 0x30, 0x33, 0x66, 0x33, 0x31, 0x34, 0x64, 0x63, 0x36, 0x30, 0x34, 0x33, 0x34, 0x37, 0x32, 0x35, 0x35, 0x31, 0x36, 0x37, 0x66, 0x63, 0x32, 0x61, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x36, 0x66, 0x38, 0x37, 0x62, 0x61, 0x36, 0x31, 0x37, 0x61, 0x32, 0x39, 0x33, 0x30, 0x62, 0x31, 0x36, 0x37, 0x30, 0x62, 0x65, 0x39, 0x32, 0x65, 0x64, 0x31, 0x32, 0x38, 0x31, 0x66, 0x62, 0x30, 0x62, 0x33, 0x34, 0x36, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x31, 0x34, 0x66, 0x66, 0x30, 0x64, 0x30, 0x66, 0x32, 0x34, 0x65, 0x66, 0x66, 0x38, 0x39, 0x36, 0x65, 0x64, 0x64, 0x65, 0x35, 0x34, 0x37, 0x31, 0x64, 0x65, 0x61, 0x34, 0x38, 0x34, 0x38, 0x32, 0x34, 0x61, 0x39, 0x39, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x38, 0x30, 0x66, 0x63, 0x37, 0x30, 0x32, 0x38, 0x32, 0x63, 0x62, 0x64, 0x64, 0x35, 0x66, 0x64, 0x65, 0x33, 0x35, 0x62, 0x66, 0x37, 0x38, 0x39, 0x38, 0x34, 0x64, 0x62, 0x33, 0x62, 0x64, 0x62, 0x31, 0x32, 0x30, 0x31, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x37, 0x61, 0x64, 0x30, 0x32, 0x35, 0x65, 0x62, 0x64, 0x65, 0x32, 0x35, 0x64, 0x32, 0x32, 0x32, 0x34, 0x33, 0x63, 0x62, 0x38, 0x33, 0x30, 0x65, 0x61, 0x31, 0x64, 0x33, 0x66, 0x36, 0x34, 0x61, 0x35, 0x36, 0x36, 0x33, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x61, 0x35, 0x32, 0x31, 0x34, 0x31, 0x66, 0x35, 0x36, 0x62, 0x65, 0x66, 0x39, 0x38, 0x39, 0x39, 0x31, 0x37, 0x32, 0x34, 0x63, 0x36, 0x65, 0x37, 0x30, 0x35, 0x33, 0x33, 0x38, 0x31, 0x64, 0x61, 0x38, 0x62, 0x35, 0x39, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x63, 0x38, 0x65, 0x61, 0x66, 0x66, 0x36, 0x33, 0x37, 0x65, 0x39, 0x34, 0x66, 0x63, 0x63, 0x35, 0x38, 0x64, 0x39, 0x31, 0x33, 0x63, 0x37, 0x37, 0x37, 0x30, 0x63, 0x38, 0x38, 0x66, 0x39, 0x62, 0x34, 0x37, 0x39, 0x32, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x36, 0x39, 0x65, 0x38, 0x63, 0x34, 0x34, 0x30, 0x34, 0x35, 0x30, 0x62, 0x30, 0x65, 0x35, 0x31, 0x32, 0x36, 0x32, 0x36, 0x66, 0x65, 0x38, 0x31, 0x37, 0x65, 0x36, 0x37, 0x35, 0x34, 0x61, 0x38, 0x31, 0x35, 0x32, 0x38, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x32, 0x37, 0x62, 0x65, 0x30, 0x61, 0x32, 0x61, 0x30, 0x30, 0x32, 0x31, 0x32, 0x30, 0x34, 0x38, 0x62, 0x35, 0x35, 0x32, 0x30, 0x66, 0x62, 0x65, 0x66, 0x62, 0x39, 0x35, 0x33, 0x65, 0x62, 0x63, 0x39, 0x64, 0x35, 0x34, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x38, 0x35, 0x38, 0x34, 0x39, 0x33, 0x66, 0x30, 0x37, 0x34, 0x31, 0x35, 0x65, 0x30, 0x39, 0x31, 0x32, 0x64, 0x30, 0x35, 0x37, 0x39, 0x33, 0x63, 0x39, 0x37, 0x32, 0x31, 0x31, 0x33, 0x65, 0x61, 0x65, 0x38, 0x61, 0x65, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x39, 0x31, 0x33, 0x30, 0x33, 0x31, 0x31, 0x36, 0x64, 0x35, 0x66, 0x32, 0x33, 0x38, 0x39, 0x62, 0x32, 0x33, 0x32, 0x33, 0x38, 0x62, 0x34, 0x64, 0x36, 0x35, 0x36, 0x61, 0x38, 0x35, 0x39, 0x36, 0x64, 0x39, 0x38, 0x34, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x34, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x30, 0x32, 0x65, 0x37, 0x30, 0x34, 0x63, 0x63, 0x32, 0x31, 0x36, 0x31, 0x37, 0x34, 0x33, 0x39, 0x61, 0x64, 0x34, 0x65, 0x61, 0x32, 0x37, 0x61, 0x35, 0x37, 0x31, 0x34, 0x66, 0x32, 0x66, 0x64, 0x61, 0x31, 0x65, 0x39, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x37, 0x64, 0x65, 0x31, 0x62, 0x63, 0x64, 0x32, 0x39, 0x32, 0x36, 0x39, 0x64, 0x35, 0x32, 0x31, 0x62, 0x38, 0x37, 0x36, 0x31, 0x63, 0x63, 0x33, 0x39, 0x63, 0x66, 0x62, 0x34, 0x33, 0x31, 0x39, 0x64, 0x32, 0x65, 0x61, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x33, 0x39, 0x61, 0x63, 0x33, 0x31, 0x64, 0x61, 0x39, 0x66, 0x36, 0x37, 0x32, 0x37, 0x31, 0x62, 0x64, 0x31, 0x30, 0x34, 0x30, 0x32, 0x62, 0x37, 0x36, 0x35, 0x34, 0x65, 0x35, 0x63, 0x65, 0x37, 0x36, 0x33, 0x62, 0x64, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x37, 0x33, 0x35, 0x65, 0x63, 0x37, 0x36, 0x35, 0x31, 0x38, 0x66, 0x63, 0x36, 0x61, 0x61, 0x39, 0x32, 0x64, 0x61, 0x38, 0x37, 0x31, 0x35, 0x61, 0x39, 0x65, 0x65, 0x33, 0x66, 0x36, 0x32, 0x35, 0x37, 0x38, 0x38, 0x66, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x37, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x32, 0x37, 0x37, 0x66, 0x65, 0x37, 0x63, 0x38, 0x31, 0x65, 0x65, 0x62, 0x64, 0x32, 0x35, 0x32, 0x61, 0x30, 0x33, 0x64, 0x66, 0x36, 0x39, 0x61, 0x36, 0x62, 0x39, 0x66, 0x33, 0x32, 0x36, 0x65, 0x32, 0x37, 0x32, 0x32, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x39, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x38, 0x30, 0x39, 0x38, 0x35, 0x33, 0x33, 0x66, 0x37, 0x64, 0x39, 0x62, 0x64, 0x63, 0x64, 0x33, 0x30, 0x37, 0x64, 0x62, 0x62, 0x32, 0x33, 0x65, 0x31, 0x37, 0x37, 0x37, 0x63, 0x61, 0x31, 0x38, 0x34, 0x31, 0x38, 0x39, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x62, 0x61, 0x36, 0x64, 0x35, 0x64, 0x30, 0x64, 0x63, 0x32, 0x30, 0x34, 0x65, 0x61, 0x38, 0x61, 0x32, 0x35, 0x61, 0x64, 0x61, 0x32, 0x65, 0x32, 0x36, 0x66, 0x35, 0x36, 0x37, 0x35, 0x62, 0x64, 0x35, 0x66, 0x32, 0x66, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x30, 0x37, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x33, 0x63, 0x31, 0x63, 0x36, 0x34, 0x35, 0x62, 0x39, 0x31, 0x37, 0x35, 0x34, 0x33, 0x31, 0x31, 0x33, 0x62, 0x33, 0x65, 0x36, 0x63, 0x31, 0x63, 0x30, 0x35, 0x34, 0x64, 0x61, 0x31, 0x66, 0x65, 0x37, 0x34, 0x32, 0x62, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x63, 0x64, 0x62, 0x61, 0x65, 0x61, 0x62, 0x39, 0x31, 0x30, 0x36, 0x66, 0x66, 0x65, 0x35, 0x64, 0x37, 0x62, 0x35, 0x31, 0x39, 0x36, 0x39, 0x36, 0x36, 0x30, 0x39, 0x61, 0x30, 0x35, 0x62, 0x61, 0x65, 0x62, 0x38, 0x35, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x61, 0x38, 0x32, 0x30, 0x61, 0x30, 0x36, 0x37, 0x32, 0x66, 0x31, 0x37, 0x64, 0x63, 0x37, 0x34, 0x61, 0x30, 0x38, 0x31, 0x31, 0x32, 0x62, 0x63, 0x36, 0x34, 0x33, 0x66, 0x64, 0x31, 0x31, 0x36, 0x37, 0x37, 0x33, 0x36, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x65, 0x66, 0x39, 0x34, 0x32, 0x31, 0x33, 0x38, 0x37, 0x39, 0x65, 0x30, 0x32, 0x36, 0x32, 0x32, 0x31, 0x34, 0x32, 0x62, 0x65, 0x61, 0x36, 0x31, 0x32, 0x39, 0x30, 0x39, 0x37, 0x38, 0x39, 0x33, 0x39, 0x61, 0x36, 0x30, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x32, 0x38, 0x31, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x64, 0x32, 0x31, 0x32, 0x61, 0x65, 0x65, 0x30, 0x34, 0x65, 0x30, 0x31, 0x33, 0x66, 0x33, 0x64, 0x32, 0x61, 0x62, 0x61, 0x64, 0x32, 0x61, 0x30, 0x32, 0x33, 0x36, 0x30, 0x36, 0x62, 0x66, 0x62, 0x35, 0x63, 0x36, 0x61, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x36, 0x39, 0x38, 0x65, 0x33, 0x34, 0x35, 0x33, 0x37, 0x38, 0x63, 0x36, 0x32, 0x64, 0x38, 0x65, 0x64, 0x61, 0x31, 0x38, 0x34, 0x64, 0x39, 0x34, 0x33, 0x36, 0x36, 0x61, 0x31, 0x34, 0x34, 0x62, 0x30, 0x63, 0x31, 0x30, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x35, 0x62, 0x34, 0x32, 0x66, 0x63, 0x35, 0x39, 0x65, 0x62, 0x64, 0x61, 0x30, 0x64, 0x66, 0x64, 0x36, 0x36, 0x61, 0x65, 0x39, 0x31, 0x34, 0x62, 0x63, 0x32, 0x38, 0x63, 0x31, 0x62, 0x30, 0x61, 0x36, 0x65, 0x66, 0x38, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x37, 0x36, 0x34, 0x31, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x61, 0x36, 0x37, 0x39, 0x31, 0x63, 0x31, 0x36, 0x65, 0x62, 0x34, 0x65, 0x32, 0x31, 0x36, 0x32, 0x66, 0x31, 0x34, 0x62, 0x36, 0x35, 0x33, 0x37, 0x61, 0x30, 0x32, 0x62, 0x33, 0x64, 0x36, 0x33, 0x62, 0x66, 0x63, 0x36, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x31, 0x30, 0x35, 0x66, 0x31, 0x61, 0x31, 0x31, 0x62, 0x36, 0x65, 0x34, 0x62, 0x31, 0x66, 0x35, 0x36, 0x30, 0x31, 0x32, 0x61, 0x32, 0x37, 0x39, 0x32, 0x32, 0x65, 0x32, 0x61, 0x63, 0x32, 0x64, 0x61, 0x34, 0x38, 0x31, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x30, 0x36, 0x64, 0x66, 0x39, 0x33, 0x31, 0x61, 0x39, 0x34, 0x30, 0x64, 0x35, 0x38, 0x63, 0x30, 0x31, 0x36, 0x36, 0x35, 0x66, 0x61, 0x34, 0x64, 0x30, 0x38, 0x30, 0x30, 0x38, 0x30, 0x32, 0x63, 0x30, 0x32, 0x65, 0x64, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x37, 0x62, 0x66, 0x37, 0x38, 0x63, 0x35, 0x38, 0x37, 0x35, 0x31, 0x35, 0x34, 0x37, 0x31, 0x31, 0x63, 0x62, 0x36, 0x34, 0x30, 0x64, 0x33, 0x37, 0x65, 0x61, 0x36, 0x64, 0x32, 0x38, 0x63, 0x66, 0x63, 0x62, 0x31, 0x32, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x32, 0x30, 0x31, 0x62, 0x64, 0x32, 0x32, 0x37, 0x61, 0x65, 0x36, 0x64, 0x63, 0x36, 0x62, 0x64, 0x66, 0x65, 0x64, 0x35, 0x66, 0x62, 0x64, 0x65, 0x38, 0x31, 0x31, 0x66, 0x65, 0x63, 0x66, 0x65, 0x35, 0x65, 0x39, 0x64, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x34, 0x38, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x61, 0x66, 0x62, 0x66, 0x39, 0x65, 0x39, 0x65, 0x64, 0x32, 0x63, 0x32, 0x31, 0x39, 0x66, 0x37, 0x66, 0x32, 0x37, 0x39, 0x31, 0x33, 0x37, 0x34, 0x65, 0x37, 0x64, 0x30, 0x35, 0x63, 0x62, 0x30, 0x36, 0x37, 0x37, 0x37, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x39, 0x62, 0x33, 0x35, 0x61, 0x64, 0x34, 0x61, 0x30, 0x61, 0x38, 0x36, 0x66, 0x37, 0x35, 0x38, 0x34, 0x34, 0x36, 0x66, 0x66, 0x66, 0x64, 0x65, 0x33, 0x34, 0x32, 0x36, 0x39, 0x64, 0x39, 0x34, 0x30, 0x63, 0x65, 0x61, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x34, 0x33, 0x32, 0x33, 0x32, 0x63, 0x63, 0x64, 0x34, 0x38, 0x38, 0x30, 0x64, 0x36, 0x66, 0x34, 0x36, 0x66, 0x61, 0x37, 0x35, 0x31, 0x61, 0x39, 0x36, 0x63, 0x64, 0x38, 0x32, 0x34, 0x37, 0x33, 0x33, 0x31, 0x35, 0x38, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x65, 0x66, 0x64, 0x63, 0x38, 0x35, 0x30, 0x65, 0x38, 0x37, 0x62, 0x37, 0x31, 0x35, 0x63, 0x37, 0x32, 0x37, 0x39, 0x31, 0x37, 0x37, 0x33, 0x63, 0x30, 0x33, 0x31, 0x36, 0x63, 0x33, 0x35, 0x35, 0x39, 0x62, 0x35, 0x38, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x63, 0x30, 0x33, 0x65, 0x32, 0x61, 0x33, 0x38, 0x39, 0x39, 0x38, 0x63, 0x32, 0x31, 0x36, 0x34, 0x38, 0x37, 0x36, 0x30, 0x66, 0x31, 0x65, 0x35, 0x61, 0x65, 0x37, 0x65, 0x61, 0x33, 0x30, 0x37, 0x37, 0x64, 0x38, 0x35, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x34, 0x32, 0x34, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x32, 0x35, 0x64, 0x30, 0x36, 0x30, 0x35, 0x36, 0x39, 0x36, 0x38, 0x62, 0x30, 0x30, 0x32, 0x32, 0x30, 0x36, 0x66, 0x66, 0x39, 0x31, 0x39, 0x38, 0x30, 0x31, 0x34, 0x30, 0x32, 0x34, 0x32, 0x62, 0x66, 0x61, 0x61, 0x34, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x35, 0x38, 0x65, 0x31, 0x30, 0x37, 0x63, 0x35, 0x65, 0x62, 0x35, 0x34, 0x63, 0x62, 0x37, 0x36, 0x30, 0x34, 0x65, 0x30, 0x63, 0x64, 0x38, 0x64, 0x63, 0x31, 0x65, 0x30, 0x37, 0x35, 0x30, 0x30, 0x64, 0x39, 0x31, 0x63, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x34, 0x37, 0x37, 0x32, 0x31, 0x32, 0x66, 0x66, 0x64, 0x64, 0x37, 0x35, 0x65, 0x35, 0x31, 0x35, 0x35, 0x36, 0x35, 0x31, 0x62, 0x37, 0x36, 0x35, 0x30, 0x36, 0x62, 0x31, 0x36, 0x34, 0x36, 0x36, 0x37, 0x31, 0x61, 0x31, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x34, 0x34, 0x61, 0x38, 0x35, 0x35, 0x65, 0x34, 0x30, 0x34, 0x63, 0x38, 0x36, 0x64, 0x30, 0x63, 0x61, 0x38, 0x65, 0x66, 0x33, 0x33, 0x32, 0x34, 0x32, 0x35, 0x31, 0x64, 0x66, 0x62, 0x33, 0x34, 0x39, 0x63, 0x35, 0x33, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x38, 0x39, 0x37, 0x66, 0x65, 0x39, 0x33, 0x32, 0x62, 0x62, 0x62, 0x33, 0x31, 0x35, 0x34, 0x63, 0x39, 0x35, 0x64, 0x33, 0x62, 0x63, 0x65, 0x36, 0x64, 0x39, 0x33, 0x62, 0x36, 0x64, 0x37, 0x33, 0x32, 0x39, 0x30, 0x34, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x36, 0x36, 0x34, 0x31, 0x62, 0x31, 0x33, 0x65, 0x31, 0x37, 0x32, 0x66, 0x63, 0x30, 0x37, 0x32, 0x63, 0x61, 0x34, 0x62, 0x38, 0x33, 0x32, 0x37, 0x61, 0x33, 0x62, 0x63, 0x32, 0x38, 0x61, 0x31, 0x35, 0x62, 0x36, 0x36, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x36, 0x62, 0x34, 0x33, 0x38, 0x37, 0x66, 0x62, 0x34, 0x64, 0x63, 0x63, 0x65, 0x30, 0x31, 0x31, 0x65, 0x37, 0x36, 0x65, 0x34, 0x64, 0x37, 0x33, 0x35, 0x34, 0x37, 0x64, 0x34, 0x34, 0x38, 0x31, 0x65, 0x30, 0x39, 0x62, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x62, 0x62, 0x32, 0x37, 0x63, 0x62, 0x39, 0x39, 0x66, 0x33, 0x65, 0x32, 0x63, 0x32, 0x63, 0x66, 0x39, 0x30, 0x61, 0x39, 0x38, 0x66, 0x37, 0x30, 0x37, 0x64, 0x33, 0x30, 0x65, 0x34, 0x61, 0x32, 0x30, 0x31, 0x61, 0x30, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x62, 0x66, 0x65, 0x31, 0x63, 0x33, 0x65, 0x66, 0x39, 0x34, 0x65, 0x31, 0x38, 0x34, 0x36, 0x66, 0x62, 0x39, 0x65, 0x33, 0x61, 0x63, 0x66, 0x65, 0x39, 0x62, 0x35, 0x30, 0x63, 0x33, 0x65, 0x39, 0x30, 0x36, 0x39, 0x32, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x63, 0x62, 0x33, 0x66, 0x33, 0x31, 0x32, 0x34, 0x63, 0x39, 0x63, 0x39, 0x63, 0x63, 0x33, 0x38, 0x33, 0x34, 0x62, 0x31, 0x32, 0x37, 0x34, 0x62, 0x63, 0x33, 0x33, 0x33, 0x36, 0x34, 0x35, 0x36, 0x61, 0x33, 0x38, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x37, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x62, 0x63, 0x35, 0x63, 0x37, 0x31, 0x61, 0x63, 0x65, 0x37, 0x39, 0x37, 0x34, 0x31, 0x34, 0x35, 0x30, 0x62, 0x30, 0x31, 0x32, 0x63, 0x66, 0x36, 0x62, 0x38, 0x64, 0x33, 0x66, 0x31, 0x37, 0x64, 0x62, 0x36, 0x38, 0x61, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x64, 0x62, 0x62, 0x34, 0x38, 0x63, 0x39, 0x38, 0x33, 0x30, 0x39, 0x37, 0x36, 0x34, 0x66, 0x39, 0x39, 0x63, 0x65, 0x64, 0x33, 0x36, 0x39, 0x32, 0x64, 0x63, 0x63, 0x61, 0x33, 0x35, 0x65, 0x65, 0x33, 0x30, 0x36, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x31, 0x30, 0x39, 0x31, 0x30, 0x62, 0x61, 0x36, 0x65, 0x30, 0x62, 0x63, 0x31, 0x37, 0x65, 0x30, 0x35, 0x35, 0x35, 0x35, 0x36, 0x36, 0x31, 0x34, 0x63, 0x62, 0x38, 0x37, 0x30, 0x39, 0x30, 0x66, 0x34, 0x64, 0x37, 0x65, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x66, 0x62, 0x65, 0x33, 0x34, 0x39, 0x38, 0x34, 0x62, 0x36, 0x33, 0x37, 0x31, 0x39, 0x36, 0x66, 0x33, 0x33, 0x31, 0x63, 0x36, 0x37, 0x39, 0x64, 0x30, 0x63, 0x30, 0x63, 0x34, 0x37, 0x64, 0x38, 0x33, 0x34, 0x31, 0x30, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x31, 0x32, 0x30, 0x66, 0x30, 0x63, 0x61, 0x61, 0x65, 0x34, 0x34, 0x66, 0x64, 0x39, 0x34, 0x62, 0x63, 0x61, 0x66, 0x65, 0x35, 0x35, 0x65, 0x32, 0x65, 0x32, 0x37, 0x39, 0x65, 0x66, 0x39, 0x36, 0x62, 0x61, 0x35, 0x63, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x35, 0x61, 0x66, 0x63, 0x66, 0x64, 0x38, 0x33, 0x30, 0x39, 0x63, 0x32, 0x64, 0x66, 0x39, 0x64, 0x31, 0x35, 0x62, 0x65, 0x35, 0x65, 0x36, 0x61, 0x35, 0x30, 0x34, 0x65, 0x37, 0x64, 0x37, 0x30, 0x36, 0x36, 0x32, 0x34, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x34, 0x36, 0x37, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x39, 0x35, 0x39, 0x63, 0x32, 0x30, 0x62, 0x37, 0x65, 0x39, 0x39, 0x33, 0x31, 0x64, 0x37, 0x32, 0x66, 0x35, 0x61, 0x38, 0x61, 0x65, 0x38, 0x36, 0x39, 0x64, 0x61, 0x66, 0x64, 0x64, 0x61, 0x64, 0x33, 0x62, 0x36, 0x64, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x34, 0x31, 0x33, 0x31, 0x30, 0x66, 0x65, 0x39, 0x65, 0x65, 0x64, 0x36, 0x38, 0x36, 0x34, 0x63, 0x65, 0x64, 0x64, 0x34, 0x62, 0x65, 0x65, 0x35, 0x38, 0x64, 0x66, 0x38, 0x38, 0x65, 0x62, 0x34, 0x65, 0x64, 0x33, 0x63, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x36, 0x64, 0x66, 0x34, 0x37, 0x65, 0x37, 0x36, 0x65, 0x34, 0x64, 0x37, 0x61, 0x37, 0x38, 0x39, 0x63, 0x64, 0x65, 0x65, 0x39, 0x31, 0x33, 0x63, 0x63, 0x39, 0x38, 0x33, 0x31, 0x36, 0x35, 0x30, 0x39, 0x33, 0x36, 0x63, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x61, 0x61, 0x61, 0x30, 0x34, 0x36, 0x35, 0x64, 0x31, 0x63, 0x32, 0x36, 0x30, 0x63, 0x34, 0x32, 0x30, 0x66, 0x61, 0x33, 0x30, 0x65, 0x32, 0x36, 0x32, 0x39, 0x38, 0x36, 0x39, 0x66, 0x62, 0x36, 0x35, 0x35, 0x39, 0x32, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x34, 0x39, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x36, 0x35, 0x35, 0x63, 0x36, 0x37, 0x38, 0x39, 0x65, 0x64, 0x64, 0x66, 0x34, 0x35, 0x35, 0x63, 0x62, 0x34, 0x62, 0x38, 0x38, 0x30, 0x39, 0x39, 0x37, 0x32, 0x30, 0x36, 0x33, 0x39, 0x33, 0x38, 0x39, 0x65, 0x65, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x33, 0x65, 0x62, 0x35, 0x30, 0x39, 0x32, 0x37, 0x38, 0x66, 0x65, 0x30, 0x64, 0x63, 0x64, 0x38, 0x65, 0x30, 0x62, 0x62, 0x65, 0x37, 0x38, 0x61, 0x31, 0x39, 0x34, 0x65, 0x30, 0x36, 0x62, 0x36, 0x38, 0x30, 0x33, 0x39, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x39, 0x34, 0x31, 0x30, 0x64, 0x33, 0x62, 0x39, 0x61, 0x38, 0x37, 0x65, 0x64, 0x35, 0x65, 0x34, 0x35, 0x31, 0x61, 0x36, 0x62, 0x39, 0x31, 0x62, 0x62, 0x38, 0x39, 0x32, 0x33, 0x66, 0x65, 0x39, 0x30, 0x66, 0x62, 0x32, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x39, 0x36, 0x30, 0x64, 0x63, 0x64, 0x30, 0x33, 0x64, 0x35, 0x62, 0x61, 0x39, 0x39, 0x63, 0x62, 0x31, 0x31, 0x35, 0x64, 0x31, 0x37, 0x66, 0x66, 0x34, 0x63, 0x30, 0x39, 0x32, 0x34, 0x38, 0x61, 0x64, 0x34, 0x64, 0x30, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x35, 0x37, 0x61, 0x61, 0x36, 0x36, 0x63, 0x61, 0x37, 0x36, 0x37, 0x65, 0x64, 0x65, 0x31, 0x32, 0x34, 0x61, 0x31, 0x63, 0x35, 0x62, 0x39, 0x63, 0x63, 0x35, 0x66, 0x63, 0x39, 0x34, 0x65, 0x66, 0x30, 0x62, 0x30, 0x31, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x37, 0x37, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x38, 0x61, 0x36, 0x63, 0x61, 0x38, 0x30, 0x31, 0x36, 0x38, 0x35, 0x33, 0x37, 0x65, 0x39, 0x37, 0x34, 0x64, 0x31, 0x34, 0x65, 0x31, 0x63, 0x33, 0x64, 0x31, 0x33, 0x39, 0x39, 0x30, 0x61, 0x34, 0x34, 0x63, 0x32, 0x63, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x39, 0x65, 0x34, 0x33, 0x30, 0x64, 0x65, 0x32, 0x62, 0x37, 0x34, 0x66, 0x34, 0x34, 0x32, 0x36, 0x35, 0x31, 0x64, 0x64, 0x63, 0x64, 0x62, 0x37, 0x30, 0x31, 0x37, 0x36, 0x62, 0x63, 0x30, 0x35, 0x34, 0x63, 0x61, 0x64, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x62, 0x66, 0x39, 0x66, 0x34, 0x34, 0x62, 0x61, 0x37, 0x64, 0x30, 0x35, 0x63, 0x33, 0x33, 0x35, 0x34, 0x30, 0x63, 0x33, 0x61, 0x35, 0x33, 0x62, 0x62, 0x30, 0x32, 0x63, 0x62, 0x62, 0x66, 0x66, 0x65, 0x37, 0x63, 0x33, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x33, 0x38, 0x39, 0x38, 0x35, 0x38, 0x62, 0x38, 0x30, 0x30, 0x65, 0x38, 0x63, 0x30, 0x65, 0x63, 0x33, 0x32, 0x66, 0x35, 0x31, 0x65, 0x64, 0x36, 0x31, 0x61, 0x33, 0x35, 0x35, 0x39, 0x34, 0x36, 0x63, 0x63, 0x34, 0x30, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x32, 0x39, 0x32, 0x39, 0x32, 0x37, 0x31, 0x65, 0x39, 0x64, 0x32, 0x30, 0x39, 0x35, 0x61, 0x32, 0x36, 0x34, 0x37, 0x36, 0x37, 0x65, 0x37, 0x62, 0x30, 0x64, 0x66, 0x35, 0x32, 0x65, 0x61, 0x30, 0x64, 0x31, 0x64, 0x34, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x32, 0x35, 0x30, 0x64, 0x34, 0x37, 0x36, 0x65, 0x30, 0x36, 0x32, 0x34, 0x38, 0x34, 0x65, 0x39, 0x30, 0x38, 0x30, 0x61, 0x33, 0x39, 0x36, 0x37, 0x62, 0x66, 0x33, 0x61, 0x34, 0x61, 0x37, 0x33, 0x32, 0x61, 0x64, 0x37, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x36, 0x37, 0x30, 0x33, 0x33, 0x64, 0x64, 0x38, 0x65, 0x65, 0x37, 0x66, 0x30, 0x63, 0x38, 0x61, 0x65, 0x35, 0x33, 0x34, 0x64, 0x34, 0x32, 0x61, 0x35, 0x31, 0x66, 0x37, 0x64, 0x39, 0x64, 0x34, 0x66, 0x37, 0x39, 0x37, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x38, 0x33, 0x64, 0x33, 0x34, 0x38, 0x36, 0x33, 0x65, 0x30, 0x65, 0x31, 0x37, 0x66, 0x39, 0x32, 0x36, 0x62, 0x37, 0x39, 0x32, 0x38, 0x65, 0x64, 0x66, 0x66, 0x33, 0x31, 0x37, 0x65, 0x39, 0x39, 0x38, 0x65, 0x39, 0x63, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x37, 0x31, 0x39, 0x32, 0x63, 0x30, 0x64, 0x66, 0x31, 0x63, 0x37, 0x64, 0x62, 0x36, 0x64, 0x39, 0x65, 0x64, 0x36, 0x35, 0x64, 0x37, 0x31, 0x31, 0x38, 0x34, 0x64, 0x38, 0x65, 0x34, 0x31, 0x35, 0x35, 0x61, 0x31, 0x37, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x65, 0x37, 0x62, 0x35, 0x35, 0x63, 0x32, 0x66, 0x39, 0x38, 0x32, 0x30, 0x65, 0x65, 0x64, 0x37, 0x33, 0x38, 0x38, 0x34, 0x33, 0x36, 0x31, 0x62, 0x35, 0x30, 0x36, 0x36, 0x61, 0x35, 0x39, 0x62, 0x36, 0x66, 0x34, 0x35, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x61, 0x39, 0x38, 0x33, 0x62, 0x62, 0x35, 0x65, 0x33, 0x30, 0x37, 0x33, 0x61, 0x38, 0x65, 0x64, 0x62, 0x35, 0x35, 0x37, 0x65, 0x66, 0x66, 0x65, 0x62, 0x34, 0x66, 0x39, 0x66, 0x62, 0x31, 0x64, 0x36, 0x30, 0x65, 0x66, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x35, 0x65, 0x65, 0x38, 0x65, 0x39, 0x62, 0x62, 0x30, 0x65, 0x38, 0x61, 0x62, 0x32, 0x66, 0x65, 0x63, 0x62, 0x34, 0x62, 0x33, 0x33, 0x64, 0x32, 0x39, 0x34, 0x37, 0x38, 0x62, 0x65, 0x35, 0x30, 0x62, 0x62, 0x64, 0x34, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x33, 0x39, 0x35, 0x39, 0x66, 0x63, 0x32, 0x39, 0x31, 0x31, 0x31, 0x30, 0x65, 0x38, 0x38, 0x32, 0x33, 0x32, 0x63, 0x33, 0x36, 0x62, 0x37, 0x36, 0x36, 0x37, 0x66, 0x63, 0x37, 0x38, 0x61, 0x33, 0x37, 0x39, 0x36, 0x31, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x37, 0x64, 0x35, 0x63, 0x34, 0x30, 0x64, 0x64, 0x61, 0x66, 0x63, 0x34, 0x35, 0x30, 0x62, 0x30, 0x34, 0x61, 0x37, 0x34, 0x61, 0x34, 0x64, 0x61, 0x62, 0x63, 0x32, 0x62, 0x62, 0x35, 0x64, 0x36, 0x36, 0x35, 0x30, 0x30, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x31, 0x35, 0x31, 0x38, 0x33, 0x62, 0x38, 0x66, 0x38, 0x30, 0x61, 0x39, 0x62, 0x63, 0x30, 0x33, 0x64, 0x32, 0x36, 0x63, 0x65, 0x39, 0x31, 0x32, 0x30, 0x37, 0x38, 0x33, 0x32, 0x61, 0x30, 0x64, 0x33, 0x39, 0x65, 0x36, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x30, 0x37, 0x35, 0x39, 0x30, 0x30, 0x35, 0x39, 0x61, 0x39, 0x66, 0x65, 0x63, 0x31, 0x38, 0x38, 0x31, 0x31, 0x34, 0x39, 0x61, 0x34, 0x34, 0x62, 0x33, 0x36, 0x39, 0x34, 0x39, 0x61, 0x65, 0x66, 0x38, 0x35, 0x64, 0x35, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x63, 0x35, 0x30, 0x66, 0x39, 0x32, 0x32, 0x61, 0x64, 0x31, 0x36, 0x62, 0x36, 0x31, 0x63, 0x36, 0x64, 0x31, 0x62, 0x61, 0x61, 0x30, 0x34, 0x35, 0x65, 0x64, 0x38, 0x31, 0x36, 0x38, 0x31, 0x35, 0x62, 0x61, 0x63, 0x34, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x35, 0x36, 0x36, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x31, 0x30, 0x39, 0x37, 0x38, 0x61, 0x33, 0x39, 0x61, 0x34, 0x36, 0x66, 0x66, 0x30, 0x62, 0x62, 0x38, 0x34, 0x38, 0x63, 0x66, 0x36, 0x35, 0x64, 0x64, 0x39, 0x63, 0x37, 0x37, 0x35, 0x30, 0x39, 0x61, 0x36, 0x64, 0x37, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x64, 0x63, 0x62, 0x62, 0x61, 0x39, 0x62, 0x39, 0x62, 0x66, 0x36, 0x37, 0x36, 0x32, 0x63, 0x31, 0x34, 0x35, 0x34, 0x31, 0x36, 0x63, 0x35, 0x30, 0x36, 0x61, 0x37, 0x31, 0x65, 0x33, 0x62, 0x34, 0x39, 0x37, 0x32, 0x30, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x65, 0x30, 0x31, 0x32, 0x38, 0x33, 0x63, 0x63, 0x38, 0x62, 0x33, 0x38, 0x34, 0x35, 0x33, 0x38, 0x64, 0x64, 0x36, 0x34, 0x36, 0x37, 0x37, 0x30, 0x62, 0x33, 0x35, 0x37, 0x63, 0x39, 0x36, 0x30, 0x64, 0x36, 0x63, 0x61, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x63, 0x66, 0x38, 0x33, 0x33, 0x36, 0x62, 0x33, 0x32, 0x38, 0x64, 0x62, 0x33, 0x64, 0x38, 0x37, 0x38, 0x31, 0x33, 0x61, 0x34, 0x37, 0x32, 0x62, 0x39, 0x65, 0x38, 0x39, 0x62, 0x37, 0x35, 0x65, 0x30, 0x63, 0x66, 0x33, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x32, 0x34, 0x66, 0x63, 0x34, 0x33, 0x36, 0x37, 0x35, 0x33, 0x61, 0x37, 0x33, 0x39, 0x64, 0x62, 0x32, 0x63, 0x38, 0x64, 0x34, 0x30, 0x65, 0x36, 0x64, 0x34, 0x64, 0x30, 0x34, 0x63, 0x35, 0x32, 0x38, 0x65, 0x38, 0x36, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x65, 0x39, 0x32, 0x39, 0x61, 0x36, 0x31, 0x63, 0x31, 0x62, 0x33, 0x38, 0x65, 0x64, 0x64, 0x62, 0x65, 0x38, 0x32, 0x63, 0x32, 0x35, 0x63, 0x32, 0x64, 0x36, 0x37, 0x35, 0x33, 0x63, 0x62, 0x31, 0x65, 0x31, 0x32, 0x64, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x34, 0x39, 0x66, 0x62, 0x61, 0x32, 0x39, 0x38, 0x33, 0x30, 0x33, 0x36, 0x30, 0x66, 0x63, 0x64, 0x62, 0x36, 0x64, 0x61, 0x32, 0x33, 0x62, 0x62, 0x66, 0x65, 0x61, 0x35, 0x63, 0x30, 0x62, 0x62, 0x61, 0x63, 0x35, 0x32, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x62, 0x65, 0x63, 0x61, 0x65, 0x34, 0x61, 0x33, 0x31, 0x64, 0x33, 0x36, 0x66, 0x33, 0x63, 0x62, 0x35, 0x37, 0x37, 0x66, 0x32, 0x61, 0x34, 0x33, 0x35, 0x39, 0x34, 0x66, 0x62, 0x31, 0x61, 0x62, 0x63, 0x31, 0x62, 0x62, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x63, 0x66, 0x36, 0x39, 0x38, 0x61, 0x30, 0x35, 0x33, 0x33, 0x32, 0x37, 0x65, 0x62, 0x64, 0x31, 0x36, 0x62, 0x37, 0x64, 0x37, 0x37, 0x30, 0x30, 0x30, 0x39, 0x32, 0x66, 0x65, 0x32, 0x65, 0x38, 0x35, 0x34, 0x32, 0x34, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x32, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x38, 0x30, 0x32, 0x64, 0x38, 0x61, 0x36, 0x35, 0x39, 0x65, 0x38, 0x39, 0x61, 0x32, 0x63, 0x34, 0x37, 0x65, 0x39, 0x30, 0x35, 0x34, 0x33, 0x30, 0x62, 0x32, 0x61, 0x38, 0x32, 0x37, 0x39, 0x37, 0x38, 0x39, 0x35, 0x30, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x36, 0x33, 0x36, 0x63, 0x64, 0x62, 0x31, 0x30, 0x39, 0x30, 0x35, 0x30, 0x65, 0x34, 0x33, 0x64, 0x35, 0x64, 0x36, 0x65, 0x63, 0x34, 0x37, 0x65, 0x33, 0x35, 0x39, 0x65, 0x32, 0x31, 0x38, 0x65, 0x38, 0x35, 0x37, 0x65, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x38, 0x38, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x38, 0x31, 0x33, 0x66, 0x66, 0x32, 0x62, 0x36, 0x65, 0x64, 0x35, 0x37, 0x62, 0x39, 0x33, 0x37, 0x64, 0x61, 0x62, 0x66, 0x32, 0x62, 0x33, 0x38, 0x31, 0x64, 0x31, 0x34, 0x38, 0x61, 0x34, 0x31, 0x31, 0x66, 0x61, 0x30, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x32, 0x35, 0x32, 0x35, 0x35, 0x31, 0x61, 0x36, 0x32, 0x34, 0x61, 0x65, 0x35, 0x31, 0x33, 0x37, 0x31, 0x39, 0x64, 0x61, 0x62, 0x65, 0x35, 0x32, 0x30, 0x37, 0x66, 0x62, 0x65, 0x66, 0x62, 0x32, 0x66, 0x64, 0x37, 0x37, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x34, 0x39, 0x36, 0x36, 0x38, 0x30, 0x34, 0x32, 0x65, 0x37, 0x31, 0x31, 0x32, 0x33, 0x61, 0x36, 0x34, 0x38, 0x39, 0x37, 0x35, 0x65, 0x30, 0x38, 0x65, 0x64, 0x36, 0x33, 0x38, 0x32, 0x66, 0x38, 0x33, 0x65, 0x30, 0x35, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x65, 0x63, 0x61, 0x35, 0x30, 0x31, 0x36, 0x33, 0x30, 0x61, 0x62, 0x63, 0x65, 0x33, 0x35, 0x32, 0x31, 0x38, 0x62, 0x31, 0x37, 0x34, 0x39, 0x35, 0x36, 0x62, 0x38, 0x39, 0x31, 0x62, 0x61, 0x32, 0x35, 0x65, 0x66, 0x62, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x30, 0x66, 0x39, 0x31, 0x62, 0x64, 0x35, 0x64, 0x31, 0x63, 0x35, 0x63, 0x63, 0x34, 0x37, 0x33, 0x39, 0x61, 0x65, 0x39, 0x31, 0x33, 0x30, 0x30, 0x64, 0x62, 0x38, 0x39, 0x65, 0x31, 0x63, 0x31, 0x33, 0x30, 0x33, 0x63, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x39, 0x35, 0x36, 0x30, 0x61, 0x33, 0x64, 0x65, 0x36, 0x32, 0x37, 0x38, 0x36, 0x38, 0x66, 0x39, 0x31, 0x66, 0x61, 0x38, 0x62, 0x66, 0x65, 0x31, 0x63, 0x31, 0x62, 0x37, 0x61, 0x66, 0x61, 0x66, 0x30, 0x38, 0x31, 0x38, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x32, 0x39, 0x64, 0x64, 0x31, 0x39, 0x63, 0x64, 0x34, 0x62, 0x61, 0x61, 0x39, 0x66, 0x63, 0x36, 0x34, 0x33, 0x31, 0x30, 0x65, 0x66, 0x65, 0x63, 0x65, 0x61, 0x62, 0x32, 0x32, 0x31, 0x31, 0x37, 0x32, 0x35, 0x31, 0x66, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x30, 0x35, 0x61, 0x37, 0x37, 0x32, 0x32, 0x38, 0x32, 0x62, 0x31, 0x66, 0x36, 0x32, 0x61, 0x66, 0x64, 0x61, 0x36, 0x33, 0x66, 0x38, 0x39, 0x62, 0x35, 0x64, 0x63, 0x36, 0x61, 0x62, 0x36, 0x34, 0x63, 0x38, 0x34, 0x63, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x66, 0x65, 0x39, 0x33, 0x36, 0x34, 0x32, 0x35, 0x64, 0x63, 0x63, 0x37, 0x62, 0x37, 0x34, 0x62, 0x39, 0x35, 0x35, 0x30, 0x38, 0x32, 0x62, 0x62, 0x61, 0x61, 0x66, 0x32, 0x61, 0x31, 0x31, 0x64, 0x37, 0x38, 0x62, 0x63, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x64, 0x30, 0x64, 0x39, 0x37, 0x32, 0x35, 0x65, 0x33, 0x62, 0x37, 0x30, 0x65, 0x36, 0x37, 0x35, 0x38, 0x34, 0x33, 0x31, 0x37, 0x33, 0x39, 0x33, 0x38, 0x65, 0x64, 0x33, 0x37, 0x31, 0x62, 0x36, 0x32, 0x63, 0x37, 0x66, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x65, 0x64, 0x32, 0x64, 0x38, 0x65, 0x37, 0x30, 0x38, 0x31, 0x34, 0x38, 0x32, 0x63, 0x39, 0x31, 0x39, 0x66, 0x63, 0x32, 0x33, 0x64, 0x38, 0x66, 0x30, 0x30, 0x39, 0x31, 0x62, 0x33, 0x63, 0x38, 0x32, 0x63, 0x34, 0x36, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x39, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x32, 0x33, 0x36, 0x35, 0x64, 0x37, 0x36, 0x34, 0x63, 0x35, 0x63, 0x65, 0x33, 0x35, 0x34, 0x30, 0x33, 0x39, 0x64, 0x64, 0x66, 0x63, 0x39, 0x31, 0x32, 0x65, 0x30, 0x32, 0x33, 0x61, 0x37, 0x35, 0x62, 0x38, 0x65, 0x31, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x63, 0x36, 0x30, 0x37, 0x63, 0x30, 0x61, 0x38, 0x61, 0x30, 0x36, 0x30, 0x64, 0x61, 0x38, 0x66, 0x30, 0x32, 0x61, 0x38, 0x65, 0x62, 0x33, 0x38, 0x61, 0x30, 0x31, 0x33, 0x65, 0x61, 0x38, 0x63, 0x64, 0x61, 0x35, 0x62, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x32, 0x63, 0x34, 0x35, 0x39, 0x39, 0x30, 0x65, 0x32, 0x31, 0x34, 0x37, 0x34, 0x34, 0x35, 0x31, 0x63, 0x66, 0x34, 0x66, 0x35, 0x39, 0x66, 0x30, 0x31, 0x39, 0x35, 0x35, 0x62, 0x33, 0x33, 0x31, 0x63, 0x37, 0x64, 0x37, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x61, 0x63, 0x32, 0x62, 0x34, 0x35, 0x38, 0x34, 0x35, 0x34, 0x61, 0x33, 0x36, 0x63, 0x37, 0x65, 0x39, 0x36, 0x63, 0x37, 0x33, 0x61, 0x38, 0x36, 0x36, 0x37, 0x32, 0x32, 0x32, 0x61, 0x31, 0x32, 0x32, 0x34, 0x32, 0x63, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x35, 0x35, 0x35, 0x30, 0x31, 0x30, 0x37, 0x37, 0x36, 0x65, 0x33, 0x63, 0x35, 0x63, 0x62, 0x33, 0x31, 0x31, 0x61, 0x35, 0x61, 0x64, 0x65, 0x65, 0x66, 0x65, 0x39, 0x65, 0x39, 0x32, 0x62, 0x62, 0x39, 0x61, 0x36, 0x34, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x33, 0x38, 0x30, 0x30, 0x38, 0x37, 0x37, 0x38, 0x36, 0x39, 0x36, 0x35, 0x31, 0x34, 0x39, 0x65, 0x38, 0x31, 0x34, 0x32, 0x33, 0x62, 0x31, 0x35, 0x65, 0x33, 0x31, 0x33, 0x62, 0x61, 0x33, 0x32, 0x63, 0x35, 0x63, 0x37, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x66, 0x38, 0x36, 0x62, 0x63, 0x30, 0x36, 0x31, 0x38, 0x38, 0x34, 0x65, 0x39, 0x65, 0x65, 0x66, 0x30, 0x35, 0x36, 0x34, 0x30, 0x65, 0x64, 0x64, 0x35, 0x31, 0x61, 0x32, 0x66, 0x37, 0x63, 0x30, 0x35, 0x39, 0x36, 0x63, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x39, 0x38, 0x65, 0x62, 0x33, 0x34, 0x64, 0x34, 0x36, 0x39, 0x37, 0x39, 0x62, 0x30, 0x61, 0x36, 0x64, 0x65, 0x38, 0x62, 0x30, 0x35, 0x61, 0x61, 0x35, 0x33, 0x33, 0x61, 0x38, 0x39, 0x62, 0x38, 0x32, 0x35, 0x64, 0x63, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x31, 0x66, 0x62, 0x37, 0x64, 0x32, 0x30, 0x66, 0x64, 0x32, 0x38, 0x30, 0x30, 0x31, 0x39, 0x32, 0x66, 0x30, 0x61, 0x61, 0x63, 0x31, 0x39, 0x38, 0x64, 0x36, 0x64, 0x36, 0x61, 0x33, 0x37, 0x64, 0x33, 0x66, 0x63, 0x62, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x30, 0x33, 0x35, 0x61, 0x62, 0x31, 0x65, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x31, 0x66, 0x30, 0x66, 0x33, 0x38, 0x30, 0x66, 0x31, 0x31, 0x33, 0x31, 0x62, 0x37, 0x33, 0x38, 0x37, 0x63, 0x38, 0x64, 0x39, 0x38, 0x31, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x32, 0x66, 0x35, 0x32, 0x66, 0x30, 0x61, 0x36, 0x37, 0x36, 0x63, 0x37, 0x37, 0x37, 0x31, 0x36, 0x64, 0x35, 0x37, 0x34, 0x63, 0x38, 0x31, 0x65, 0x63, 0x34, 0x36, 0x38, 0x34, 0x66, 0x39, 0x61, 0x30, 0x32, 0x30, 0x61, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x31, 0x65, 0x30, 0x66, 0x61, 0x36, 0x34, 0x63, 0x35, 0x31, 0x31, 0x33, 0x37, 0x34, 0x36, 0x35, 0x65, 0x65, 0x63, 0x66, 0x35, 0x62, 0x39, 0x30, 0x66, 0x31, 0x39, 0x37, 0x66, 0x37, 0x39, 0x33, 0x37, 0x66, 0x64, 0x62, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x36, 0x66, 0x64, 0x37, 0x64, 0x32, 0x34, 0x66, 0x38, 0x66, 0x38, 0x38, 0x33, 0x66, 0x35, 0x61, 0x37, 0x61, 0x32, 0x38, 0x32, 0x39, 0x35, 0x62, 0x66, 0x31, 0x37, 0x31, 0x35, 0x31, 0x63, 0x37, 0x61, 0x38, 0x34, 0x62, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x66, 0x35, 0x62, 0x38, 0x34, 0x30, 0x31, 0x34, 0x30, 0x64, 0x35, 0x61, 0x39, 0x61, 0x63, 0x65, 0x66, 0x34, 0x30, 0x32, 0x61, 0x63, 0x33, 0x63, 0x63, 0x33, 0x38, 0x38, 0x36, 0x61, 0x36, 0x38, 0x63, 0x61, 0x64, 0x32, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x62, 0x66, 0x36, 0x37, 0x61, 0x37, 0x66, 0x33, 0x63, 0x36, 0x63, 0x65, 0x35, 0x36, 0x62, 0x37, 0x62, 0x65, 0x34, 0x31, 0x36, 0x37, 0x35, 0x64, 0x62, 0x62, 0x61, 0x64, 0x66, 0x65, 0x37, 0x65, 0x61, 0x39, 0x33, 0x61, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x65, 0x35, 0x38, 0x34, 0x33, 0x33, 0x37, 0x64, 0x64, 0x62, 0x63, 0x38, 0x30, 0x66, 0x39, 0x65, 0x33, 0x34, 0x39, 0x38, 0x64, 0x66, 0x35, 0x35, 0x66, 0x30, 0x61, 0x32, 0x31, 0x65, 0x61, 0x63, 0x62, 0x35, 0x37, 0x66, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x33, 0x39, 0x33, 0x63, 0x35, 0x64, 0x39, 0x31, 0x62, 0x39, 0x64, 0x65, 0x35, 0x39, 0x37, 0x32, 0x30, 0x33, 0x65, 0x37, 0x35, 0x62, 0x61, 0x63, 0x34, 0x33, 0x30, 0x39, 0x62, 0x35, 0x66, 0x61, 0x33, 0x64, 0x32, 0x38, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x34, 0x63, 0x62, 0x62, 0x62, 0x66, 0x36, 0x66, 0x62, 0x35, 0x32, 0x61, 0x63, 0x34, 0x31, 0x34, 0x62, 0x65, 0x37, 0x65, 0x63, 0x36, 0x31, 0x66, 0x37, 0x62, 0x62, 0x37, 0x31, 0x34, 0x39, 0x35, 0x63, 0x65, 0x31, 0x64, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x37, 0x63, 0x34, 0x32, 0x63, 0x35, 0x65, 0x35, 0x32, 0x64, 0x36, 0x34, 0x31, 0x61, 0x30, 0x37, 0x61, 0x64, 0x37, 0x35, 0x30, 0x39, 0x39, 0x63, 0x36, 0x32, 0x39, 0x32, 0x38, 0x62, 0x37, 0x66, 0x38, 0x36, 0x36, 0x32, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x35, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x62, 0x66, 0x39, 0x39, 0x35, 0x65, 0x64, 0x38, 0x62, 0x61, 0x39, 0x32, 0x37, 0x30, 0x31, 0x64, 0x31, 0x30, 0x66, 0x65, 0x63, 0x34, 0x39, 0x66, 0x39, 0x65, 0x37, 0x64, 0x30, 0x31, 0x34, 0x64, 0x62, 0x65, 0x65, 0x30, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x32, 0x31, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x31, 0x39, 0x32, 0x30, 0x33, 0x35, 0x65, 0x32, 0x36, 0x31, 0x39, 0x62, 0x32, 0x34, 0x62, 0x30, 0x37, 0x30, 0x39, 0x64, 0x35, 0x36, 0x35, 0x39, 0x30, 0x65, 0x39, 0x31, 0x38, 0x33, 0x63, 0x63, 0x66, 0x32, 0x63, 0x31, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x36, 0x63, 0x64, 0x37, 0x35, 0x37, 0x37, 0x33, 0x38, 0x33, 0x65, 0x39, 0x30, 0x32, 0x39, 0x35, 0x31, 0x62, 0x36, 0x30, 0x61, 0x32, 0x30, 0x31, 0x37, 0x62, 0x61, 0x37, 0x65, 0x61, 0x32, 0x39, 0x65, 0x33, 0x33, 0x35, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x34, 0x33, 0x37, 0x65, 0x31, 0x35, 0x38, 0x30, 0x39, 0x30, 0x62, 0x32, 0x61, 0x32, 0x64, 0x36, 0x38, 0x66, 0x38, 0x32, 0x62, 0x35, 0x34, 0x61, 0x35, 0x38, 0x36, 0x34, 0x62, 0x39, 0x35, 0x64, 0x64, 0x36, 0x64, 0x62, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x30, 0x37, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x61, 0x35, 0x65, 0x65, 0x63, 0x62, 0x33, 0x38, 0x33, 0x30, 0x35, 0x64, 0x66, 0x39, 0x34, 0x39, 0x37, 0x31, 0x65, 0x66, 0x32, 0x64, 0x39, 0x65, 0x31, 0x37, 0x39, 0x61, 0x65, 0x36, 0x63, 0x65, 0x62, 0x61, 0x62, 0x33, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x63, 0x38, 0x63, 0x66, 0x31, 0x39, 0x36, 0x33, 0x63, 0x39, 0x61, 0x39, 0x35, 0x32, 0x36, 0x37, 0x62, 0x32, 0x32, 0x38, 0x63, 0x30, 0x38, 0x36, 0x32, 0x33, 0x39, 0x38, 0x38, 0x39, 0x66, 0x34, 0x64, 0x66, 0x64, 0x34, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x37, 0x37, 0x62, 0x38, 0x38, 0x64, 0x63, 0x62, 0x37, 0x31, 0x32, 0x66, 0x64, 0x31, 0x37, 0x65, 0x65, 0x39, 0x31, 0x61, 0x35, 0x62, 0x39, 0x34, 0x37, 0x34, 0x38, 0x64, 0x37, 0x32, 0x30, 0x63, 0x39, 0x30, 0x61, 0x39, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x61, 0x61, 0x66, 0x61, 0x30, 0x30, 0x36, 0x37, 0x36, 0x34, 0x37, 0x65, 0x64, 0x39, 0x39, 0x39, 0x30, 0x36, 0x36, 0x62, 0x37, 0x61, 0x34, 0x63, 0x61, 0x35, 0x62, 0x34, 0x62, 0x33, 0x66, 0x33, 0x66, 0x65, 0x61, 0x61, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x33, 0x36, 0x66, 0x37, 0x34, 0x35, 0x32, 0x31, 0x32, 0x31, 0x39, 0x31, 0x33, 0x65, 0x38, 0x30, 0x30, 0x65, 0x30, 0x66, 0x63, 0x64, 0x31, 0x61, 0x36, 0x35, 0x61, 0x35, 0x34, 0x37, 0x31, 0x63, 0x32, 0x33, 0x38, 0x34, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x32, 0x34, 0x62, 0x63, 0x62, 0x36, 0x66, 0x66, 0x61, 0x34, 0x33, 0x30, 0x66, 0x63, 0x61, 0x65, 0x32, 0x65, 0x38, 0x36, 0x62, 0x34, 0x35, 0x66, 0x32, 0x37, 0x65, 0x33, 0x66, 0x32, 0x31, 0x65, 0x38, 0x31, 0x65, 0x65, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x38, 0x31, 0x33, 0x61, 0x36, 0x34, 0x63, 0x35, 0x32, 0x36, 0x35, 0x64, 0x30, 0x32, 0x30, 0x32, 0x33, 0x35, 0x63, 0x62, 0x39, 0x63, 0x33, 0x31, 0x39, 0x62, 0x36, 0x63, 0x39, 0x36, 0x66, 0x39, 0x30, 0x36, 0x63, 0x34, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x34, 0x38, 0x63, 0x61, 0x37, 0x65, 0x62, 0x66, 0x66, 0x35, 0x63, 0x32, 0x34, 0x66, 0x39, 0x62, 0x39, 0x63, 0x33, 0x31, 0x36, 0x37, 0x39, 0x37, 0x61, 0x34, 0x33, 0x62, 0x66, 0x37, 0x63, 0x33, 0x35, 0x36, 0x32, 0x39, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x61, 0x36, 0x66, 0x65, 0x62, 0x36, 0x61, 0x62, 0x31, 0x31, 0x63, 0x37, 0x36, 0x36, 0x66, 0x64, 0x64, 0x39, 0x37, 0x37, 0x66, 0x38, 0x64, 0x66, 0x34, 0x31, 0x32, 0x31, 0x31, 0x35, 0x35, 0x66, 0x34, 0x37, 0x61, 0x31, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x35, 0x65, 0x39, 0x32, 0x62, 0x62, 0x63, 0x36, 0x64, 0x65, 0x30, 0x37, 0x62, 0x66, 0x33, 0x61, 0x36, 0x36, 0x30, 0x65, 0x62, 0x66, 0x35, 0x66, 0x65, 0x62, 0x31, 0x63, 0x38, 0x61, 0x33, 0x35, 0x32, 0x37, 0x65, 0x31, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x33, 0x36, 0x39, 0x65, 0x30, 0x30, 0x32, 0x65, 0x31, 0x62, 0x34, 0x63, 0x37, 0x39, 0x31, 0x33, 0x66, 0x63, 0x66, 0x30, 0x30, 0x66, 0x32, 0x64, 0x35, 0x65, 0x31, 0x39, 0x63, 0x35, 0x38, 0x31, 0x36, 0x35, 0x34, 0x37, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x30, 0x39, 0x36, 0x34, 0x38, 0x63, 0x31, 0x38, 0x61, 0x33, 0x63, 0x65, 0x35, 0x62, 0x61, 0x65, 0x37, 0x61, 0x30, 0x34, 0x37, 0x65, 0x63, 0x32, 0x66, 0x38, 0x36, 0x38, 0x64, 0x32, 0x34, 0x63, 0x64, 0x64, 0x61, 0x38, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x32, 0x62, 0x34, 0x35, 0x35, 0x36, 0x34, 0x36, 0x31, 0x34, 0x35, 0x31, 0x36, 0x63, 0x39, 0x31, 0x62, 0x30, 0x37, 0x66, 0x61, 0x39, 0x66, 0x37, 0x32, 0x64, 0x63, 0x66, 0x37, 0x38, 0x37, 0x63, 0x63, 0x65, 0x34, 0x65, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x31, 0x62, 0x64, 0x62, 0x37, 0x39, 0x39, 0x62, 0x32, 0x65, 0x61, 0x36, 0x33, 0x63, 0x65, 0x31, 0x33, 0x34, 0x36, 0x36, 0x38, 0x62, 0x64, 0x63, 0x31, 0x39, 0x38, 0x62, 0x35, 0x34, 0x38, 0x34, 0x30, 0x66, 0x31, 0x38, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x30, 0x36, 0x32, 0x63, 0x34, 0x34, 0x38, 0x36, 0x31, 0x38, 0x36, 0x34, 0x33, 0x30, 0x37, 0x35, 0x64, 0x65, 0x37, 0x61, 0x30, 0x30, 0x33, 0x30, 0x33, 0x34, 0x32, 0x64, 0x63, 0x65, 0x64, 0x36, 0x33, 0x64, 0x62, 0x61, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x35, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x64, 0x66, 0x64, 0x30, 0x35, 0x30, 0x34, 0x63, 0x30, 0x36, 0x63, 0x37, 0x34, 0x33, 0x65, 0x34, 0x36, 0x35, 0x33, 0x34, 0x66, 0x64, 0x37, 0x62, 0x35, 0x35, 0x66, 0x31, 0x66, 0x39, 0x63, 0x37, 0x65, 0x63, 0x33, 0x33, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x66, 0x63, 0x34, 0x36, 0x33, 0x35, 0x32, 0x36, 0x33, 0x39, 0x34, 0x34, 0x63, 0x65, 0x31, 0x34, 0x61, 0x34, 0x36, 0x63, 0x37, 0x35, 0x66, 0x61, 0x34, 0x61, 0x38, 0x32, 0x31, 0x66, 0x33, 0x39, 0x63, 0x65, 0x37, 0x66, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x63, 0x32, 0x64, 0x37, 0x63, 0x61, 0x35, 0x30, 0x34, 0x64, 0x61, 0x61, 0x33, 0x64, 0x39, 0x30, 0x36, 0x36, 0x64, 0x63, 0x30, 0x39, 0x31, 0x33, 0x37, 0x64, 0x63, 0x34, 0x32, 0x66, 0x33, 0x61, 0x61, 0x61, 0x62, 0x34, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x36, 0x30, 0x66, 0x38, 0x33, 0x36, 0x61, 0x63, 0x64, 0x65, 0x66, 0x33, 0x35, 0x34, 0x38, 0x61, 0x31, 0x66, 0x65, 0x66, 0x63, 0x63, 0x61, 0x31, 0x33, 0x65, 0x63, 0x36, 0x61, 0x39, 0x33, 0x37, 0x64, 0x62, 0x34, 0x34, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x31, 0x30, 0x61, 0x39, 0x37, 0x30, 0x35, 0x35, 0x36, 0x63, 0x39, 0x37, 0x31, 0x36, 0x65, 0x61, 0x35, 0x33, 0x61, 0x66, 0x36, 0x36, 0x64, 0x64, 0x65, 0x66, 0x39, 0x33, 0x31, 0x34, 0x33, 0x31, 0x32, 0x34, 0x39, 0x31, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x37, 0x33, 0x63, 0x38, 0x33, 0x35, 0x36, 0x34, 0x36, 0x61, 0x36, 0x37, 0x32, 0x65, 0x30, 0x31, 0x35, 0x32, 0x62, 0x65, 0x31, 0x30, 0x66, 0x66, 0x65, 0x38, 0x34, 0x31, 0x36, 0x32, 0x64, 0x64, 0x32, 0x35, 0x36, 0x65, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x38, 0x39, 0x37, 0x33, 0x33, 0x63, 0x61, 0x31, 0x64, 0x35, 0x38, 0x64, 0x39, 0x65, 0x37, 0x62, 0x35, 0x30, 0x32, 0x39, 0x62, 0x61, 0x35, 0x64, 0x34, 0x34, 0x34, 0x38, 0x35, 0x38, 0x62, 0x65, 0x63, 0x30, 0x33, 0x31, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x31, 0x35, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x38, 0x30, 0x36, 0x34, 0x37, 0x34, 0x63, 0x33, 0x35, 0x38, 0x30, 0x34, 0x37, 0x64, 0x39, 0x34, 0x30, 0x36, 0x65, 0x36, 0x61, 0x30, 0x37, 0x66, 0x34, 0x30, 0x39, 0x34, 0x35, 0x62, 0x63, 0x38, 0x33, 0x32, 0x38, 0x65, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x39, 0x35, 0x61, 0x34, 0x34, 0x35, 0x35, 0x64, 0x39, 0x35, 0x64, 0x31, 0x37, 0x38, 0x62, 0x34, 0x35, 0x33, 0x32, 0x61, 0x61, 0x34, 0x37, 0x32, 0x35, 0x62, 0x31, 0x39, 0x33, 0x66, 0x66, 0x65, 0x35, 0x31, 0x32, 0x39, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x33, 0x39, 0x37, 0x36, 0x33, 0x38, 0x62, 0x62, 0x33, 0x63, 0x65, 0x62, 0x66, 0x31, 0x66, 0x36, 0x32, 0x30, 0x36, 0x32, 0x37, 0x39, 0x34, 0x62, 0x35, 0x65, 0x62, 0x39, 0x34, 0x32, 0x66, 0x39, 0x31, 0x36, 0x31, 0x37, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x35, 0x38, 0x66, 0x38, 0x33, 0x62, 0x62, 0x32, 0x66, 0x64, 0x66, 0x62, 0x32, 0x37, 0x63, 0x65, 0x30, 0x34, 0x30, 0x39, 0x63, 0x64, 0x30, 0x33, 0x66, 0x39, 0x63, 0x35, 0x65, 0x64, 0x62, 0x66, 0x34, 0x63, 0x62, 0x65, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x66, 0x66, 0x30, 0x61, 0x35, 0x31, 0x65, 0x37, 0x63, 0x65, 0x63, 0x65, 0x38, 0x34, 0x30, 0x30, 0x32, 0x37, 0x36, 0x39, 0x37, 0x38, 0x64, 0x62, 0x64, 0x36, 0x32, 0x33, 0x36, 0x65, 0x66, 0x31, 0x36, 0x32, 0x63, 0x30, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x61, 0x37, 0x38, 0x33, 0x62, 0x35, 0x35, 0x36, 0x65, 0x35, 0x62, 0x66, 0x35, 0x33, 0x61, 0x61, 0x31, 0x33, 0x63, 0x38, 0x31, 0x31, 0x36, 0x36, 0x31, 0x33, 0x64, 0x36, 0x35, 0x37, 0x38, 0x32, 0x63, 0x39, 0x62, 0x36, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x61, 0x30, 0x61, 0x65, 0x63, 0x33, 0x37, 0x66, 0x66, 0x39, 0x66, 0x66, 0x33, 0x64, 0x35, 0x34, 0x30, 0x39, 0x66, 0x32, 0x61, 0x34, 0x66, 0x30, 0x63, 0x31, 0x32, 0x31, 0x32, 0x61, 0x61, 0x63, 0x63, 0x62, 0x30, 0x32, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x33, 0x37, 0x38, 0x61, 0x66, 0x37, 0x65, 0x66, 0x35, 0x34, 0x30, 0x34, 0x33, 0x66, 0x38, 0x39, 0x32, 0x61, 0x62, 0x37, 0x63, 0x65, 0x39, 0x37, 0x64, 0x36, 0x34, 0x37, 0x37, 0x39, 0x33, 0x35, 0x31, 0x31, 0x62, 0x31, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x63, 0x36, 0x62, 0x35, 0x66, 0x63, 0x30, 0x35, 0x66, 0x63, 0x37, 0x34, 0x38, 0x65, 0x35, 0x62, 0x34, 0x33, 0x38, 0x31, 0x37, 0x32, 0x36, 0x34, 0x34, 0x39, 0x61, 0x31, 0x63, 0x30, 0x61, 0x64, 0x30, 0x66, 0x62, 0x30, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x31, 0x37, 0x65, 0x63, 0x62, 0x30, 0x32, 0x33, 0x30, 0x35, 0x32, 0x63, 0x61, 0x37, 0x66, 0x35, 0x36, 0x35, 0x32, 0x62, 0x65, 0x32, 0x66, 0x61, 0x38, 0x35, 0x34, 0x63, 0x66, 0x65, 0x34, 0x35, 0x36, 0x33, 0x64, 0x66, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x34, 0x66, 0x37, 0x63, 0x33, 0x35, 0x63, 0x30, 0x32, 0x37, 0x64, 0x34, 0x37, 0x64, 0x66, 0x38, 0x65, 0x66, 0x34, 0x66, 0x39, 0x64, 0x66, 0x38, 0x35, 0x61, 0x39, 0x32, 0x34, 0x38, 0x61, 0x31, 0x37, 0x64, 0x64, 0x32, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x36, 0x33, 0x66, 0x63, 0x38, 0x39, 0x61, 0x62, 0x63, 0x37, 0x66, 0x33, 0x36, 0x65, 0x32, 0x38, 0x32, 0x64, 0x38, 0x30, 0x37, 0x38, 0x37, 0x62, 0x37, 0x62, 0x30, 0x34, 0x61, 0x66, 0x64, 0x36, 0x35, 0x35, 0x33, 0x65, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x64, 0x33, 0x64, 0x36, 0x37, 0x37, 0x37, 0x65, 0x63, 0x32, 0x36, 0x32, 0x30, 0x61, 0x65, 0x38, 0x33, 0x61, 0x30, 0x35, 0x35, 0x32, 0x38, 0x65, 0x64, 0x34, 0x32, 0x35, 0x30, 0x37, 0x32, 0x64, 0x33, 0x63, 0x61, 0x38, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x61, 0x64, 0x63, 0x66, 0x38, 0x33, 0x62, 0x36, 0x62, 0x32, 0x30, 0x61, 0x63, 0x36, 0x61, 0x34, 0x33, 0x34, 0x61, 0x62, 0x62, 0x31, 0x39, 0x39, 0x33, 0x63, 0x62, 0x64, 0x30, 0x35, 0x63, 0x36, 0x30, 0x65, 0x61, 0x32, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x36, 0x66, 0x39, 0x66, 0x34, 0x65, 0x35, 0x62, 0x37, 0x61, 0x65, 0x32, 0x37, 0x36, 0x62, 0x66, 0x35, 0x38, 0x34, 0x39, 0x37, 0x62, 0x64, 0x37, 0x62, 0x66, 0x32, 0x61, 0x37, 0x64, 0x32, 0x35, 0x32, 0x34, 0x35, 0x66, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x34, 0x61, 0x35, 0x37, 0x38, 0x38, 0x32, 0x61, 0x35, 0x32, 0x37, 0x33, 0x39, 0x62, 0x62, 0x65, 0x32, 0x61, 0x30, 0x36, 0x34, 0x37, 0x63, 0x38, 0x30, 0x63, 0x32, 0x34, 0x66, 0x35, 0x38, 0x61, 0x32, 0x62, 0x34, 0x66, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x38, 0x36, 0x65, 0x38, 0x39, 0x63, 0x64, 0x39, 0x64, 0x65, 0x38, 0x66, 0x37, 0x61, 0x38, 0x61, 0x30, 0x30, 0x63, 0x38, 0x36, 0x66, 0x66, 0x64, 0x62, 0x35, 0x33, 0x39, 0x39, 0x32, 0x64, 0x64, 0x39, 0x32, 0x35, 0x31, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x37, 0x33, 0x62, 0x36, 0x30, 0x32, 0x36, 0x37, 0x32, 0x31, 0x61, 0x31, 0x64, 0x64, 0x30, 0x34, 0x62, 0x37, 0x38, 0x32, 0x38, 0x63, 0x64, 0x36, 0x32, 0x62, 0x35, 0x39, 0x31, 0x62, 0x66, 0x62, 0x33, 0x34, 0x35, 0x33, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x66, 0x65, 0x66, 0x62, 0x35, 0x64, 0x63, 0x31, 0x61, 0x34, 0x35, 0x39, 0x38, 0x61, 0x61, 0x37, 0x31, 0x32, 0x36, 0x34, 0x30, 0x63, 0x35, 0x31, 0x37, 0x37, 0x37, 0x35, 0x64, 0x66, 0x61, 0x31, 0x64, 0x39, 0x31, 0x66, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x65, 0x33, 0x32, 0x34, 0x62, 0x65, 0x65, 0x62, 0x35, 0x62, 0x33, 0x36, 0x37, 0x36, 0x35, 0x65, 0x63, 0x64, 0x34, 0x36, 0x34, 0x32, 0x36, 0x30, 0x66, 0x37, 0x66, 0x32, 0x36, 0x30, 0x30, 0x36, 0x63, 0x35, 0x63, 0x36, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x38, 0x66, 0x62, 0x64, 0x37, 0x35, 0x33, 0x62, 0x39, 0x37, 0x39, 0x32, 0x33, 0x39, 0x35, 0x61, 0x65, 0x66, 0x37, 0x61, 0x34, 0x64, 0x37, 0x38, 0x64, 0x32, 0x36, 0x33, 0x63, 0x64, 0x63, 0x61, 0x61, 0x62, 0x64, 0x34, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x32, 0x39, 0x38, 0x35, 0x39, 0x31, 0x35, 0x32, 0x33, 0x65, 0x35, 0x30, 0x62, 0x31, 0x30, 0x33, 0x66, 0x30, 0x62, 0x37, 0x30, 0x31, 0x64, 0x36, 0x32, 0x33, 0x63, 0x62, 0x66, 0x30, 0x66, 0x37, 0x34, 0x35, 0x35, 0x36, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x30, 0x63, 0x65, 0x64, 0x37, 0x36, 0x32, 0x65, 0x31, 0x36, 0x36, 0x31, 0x66, 0x61, 0x65, 0x31, 0x61, 0x39, 0x32, 0x61, 0x66, 0x62, 0x31, 0x34, 0x30, 0x38, 0x38, 0x38, 0x39, 0x34, 0x31, 0x33, 0x37, 0x39, 0x34, 0x38, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x36, 0x37, 0x62, 0x36, 0x37, 0x62, 0x34, 0x66, 0x33, 0x37, 0x61, 0x30, 0x31, 0x35, 0x30, 0x39, 0x31, 0x35, 0x31, 0x31, 0x30, 0x65, 0x64, 0x65, 0x30, 0x37, 0x33, 0x62, 0x30, 0x35, 0x62, 0x38, 0x35, 0x33, 0x62, 0x64, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x37, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x31, 0x32, 0x32, 0x63, 0x66, 0x30, 0x66, 0x32, 0x39, 0x34, 0x38, 0x38, 0x39, 0x36, 0x62, 0x37, 0x34, 0x38, 0x34, 0x33, 0x66, 0x34, 0x39, 0x61, 0x66, 0x65, 0x64, 0x30, 0x62, 0x61, 0x31, 0x36, 0x31, 0x38, 0x65, 0x65, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x36, 0x62, 0x39, 0x35, 0x66, 0x38, 0x65, 0x35, 0x65, 0x66, 0x66, 0x64, 0x64, 0x63, 0x63, 0x39, 0x34, 0x66, 0x31, 0x61, 0x33, 0x31, 0x35, 0x62, 0x66, 0x30, 0x32, 0x39, 0x35, 0x64, 0x33, 0x62, 0x31, 0x65, 0x61, 0x35, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x31, 0x35, 0x36, 0x32, 0x34, 0x62, 0x63, 0x62, 0x36, 0x37, 0x39, 0x31, 0x33, 0x37, 0x62, 0x38, 0x64, 0x61, 0x65, 0x39, 0x61, 0x62, 0x35, 0x37, 0x64, 0x31, 0x31, 0x62, 0x34, 0x39, 0x30, 0x35, 0x65, 0x61, 0x65, 0x65, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x36, 0x38, 0x34, 0x35, 0x62, 0x66, 0x34, 0x31, 0x64, 0x35, 0x65, 0x65, 0x32, 0x37, 0x33, 0x63, 0x33, 0x65, 0x65, 0x36, 0x62, 0x35, 0x62, 0x30, 0x64, 0x36, 0x39, 0x66, 0x36, 0x66, 0x64, 0x35, 0x65, 0x61, 0x62, 0x62, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x37, 0x34, 0x37, 0x39, 0x31, 0x30, 0x39, 0x62, 0x34, 0x33, 0x62, 0x32, 0x36, 0x36, 0x35, 0x37, 0x66, 0x34, 0x34, 0x36, 0x35, 0x66, 0x34, 0x64, 0x31, 0x38, 0x63, 0x36, 0x66, 0x39, 0x37, 0x34, 0x62, 0x65, 0x35, 0x66, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x64, 0x36, 0x61, 0x39, 0x62, 0x61, 0x65, 0x35, 0x37, 0x66, 0x35, 0x31, 0x38, 0x35, 0x34, 0x39, 0x61, 0x64, 0x61, 0x36, 0x37, 0x37, 0x34, 0x36, 0x36, 0x66, 0x65, 0x61, 0x38, 0x61, 0x62, 0x30, 0x34, 0x66, 0x64, 0x39, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x39, 0x35, 0x38, 0x61, 0x34, 0x36, 0x64, 0x33, 0x30, 0x65, 0x33, 0x30, 0x62, 0x32, 0x37, 0x33, 0x65, 0x63, 0x63, 0x36, 0x65, 0x35, 0x64, 0x33, 0x35, 0x38, 0x61, 0x32, 0x31, 0x32, 0x65, 0x35, 0x33, 0x30, 0x37, 0x65, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x30, 0x33, 0x37, 0x31, 0x37, 0x39, 0x30, 0x37, 0x61, 0x37, 0x32, 0x35, 0x36, 0x30, 0x66, 0x34, 0x33, 0x30, 0x37, 0x66, 0x31, 0x62, 0x65, 0x65, 0x63, 0x63, 0x35, 0x34, 0x33, 0x36, 0x66, 0x34, 0x33, 0x64, 0x32, 0x31, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x61, 0x62, 0x39, 0x39, 0x62, 0x30, 0x65, 0x30, 0x65, 0x35, 0x35, 0x64, 0x37, 0x62, 0x62, 0x38, 0x37, 0x34, 0x62, 0x37, 0x63, 0x66, 0x65, 0x38, 0x33, 0x34, 0x64, 0x65, 0x36, 0x33, 0x31, 0x63, 0x39, 0x37, 0x65, 0x63, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x62, 0x34, 0x38, 0x64, 0x32, 0x64, 0x36, 0x31, 0x33, 0x37, 0x63, 0x33, 0x38, 0x35, 0x34, 0x64, 0x36, 0x31, 0x31, 0x63, 0x30, 0x31, 0x65, 0x61, 0x34, 0x32, 0x34, 0x32, 0x37, 0x61, 0x30, 0x66, 0x35, 0x39, 0x37, 0x62, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x30, 0x39, 0x65, 0x63, 0x30, 0x62, 0x65, 0x37, 0x30, 0x64, 0x30, 0x61, 0x64, 0x32, 0x36, 0x66, 0x36, 0x65, 0x36, 0x37, 0x63, 0x39, 0x64, 0x34, 0x37, 0x36, 0x32, 0x62, 0x35, 0x32, 0x65, 0x65, 0x35, 0x31, 0x31, 0x32, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x63, 0x33, 0x66, 0x30, 0x34, 0x35, 0x62, 0x62, 0x37, 0x64, 0x33, 0x38, 0x63, 0x39, 0x64, 0x32, 0x66, 0x33, 0x39, 0x35, 0x62, 0x30, 0x62, 0x61, 0x38, 0x34, 0x39, 0x32, 0x62, 0x32, 0x35, 0x33, 0x32, 0x33, 0x30, 0x39, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x63, 0x61, 0x36, 0x30, 0x64, 0x39, 0x64, 0x37, 0x30, 0x30, 0x65, 0x37, 0x38, 0x35, 0x39, 0x36, 0x62, 0x62, 0x62, 0x62, 0x62, 0x31, 0x66, 0x31, 0x65, 0x32, 0x66, 0x37, 0x30, 0x66, 0x34, 0x36, 0x32, 0x37, 0x66, 0x39, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x64, 0x37, 0x35, 0x62, 0x38, 0x65, 0x30, 0x38, 0x33, 0x31, 0x65, 0x34, 0x36, 0x66, 0x38, 0x30, 0x62, 0x63, 0x31, 0x37, 0x34, 0x31, 0x38, 0x38, 0x31, 0x38, 0x34, 0x65, 0x30, 0x30, 0x36, 0x66, 0x64, 0x65, 0x30, 0x65, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x36, 0x36, 0x37, 0x38, 0x39, 0x34, 0x62, 0x37, 0x38, 0x36, 0x33, 0x63, 0x30, 0x36, 0x38, 0x61, 0x64, 0x33, 0x34, 0x34, 0x38, 0x37, 0x33, 0x66, 0x63, 0x66, 0x66, 0x34, 0x62, 0x35, 0x36, 0x37, 0x31, 0x65, 0x30, 0x36, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x31, 0x36, 0x30, 0x39, 0x64, 0x36, 0x38, 0x35, 0x62, 0x37, 0x36, 0x62, 0x34, 0x38, 0x65, 0x63, 0x39, 0x30, 0x39, 0x61, 0x61, 0x30, 0x39, 0x39, 0x32, 0x31, 0x39, 0x30, 0x32, 0x32, 0x66, 0x38, 0x39, 0x62, 0x32, 0x63, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x65, 0x65, 0x37, 0x66, 0x30, 0x65, 0x66, 0x63, 0x38, 0x66, 0x37, 0x37, 0x38, 0x63, 0x36, 0x62, 0x36, 0x38, 0x37, 0x65, 0x63, 0x33, 0x32, 0x62, 0x65, 0x39, 0x65, 0x37, 0x64, 0x36, 0x66, 0x30, 0x32, 0x30, 0x62, 0x36, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x30, 0x61, 0x63, 0x35, 0x64, 0x31, 0x66, 0x33, 0x65, 0x66, 0x65, 0x32, 0x38, 0x66, 0x33, 0x38, 0x30, 0x32, 0x61, 0x66, 0x39, 0x32, 0x35, 0x62, 0x35, 0x37, 0x31, 0x65, 0x36, 0x33, 0x38, 0x36, 0x38, 0x62, 0x33, 0x39, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x66, 0x38, 0x66, 0x66, 0x65, 0x30, 0x37, 0x30, 0x38, 0x61, 0x39, 0x39, 0x62, 0x35, 0x32, 0x38, 0x63, 0x63, 0x31, 0x65, 0x64, 0x34, 0x65, 0x39, 0x63, 0x65, 0x34, 0x62, 0x30, 0x64, 0x30, 0x36, 0x33, 0x30, 0x62, 0x65, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x36, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x65, 0x65, 0x33, 0x38, 0x64, 0x36, 0x35, 0x39, 0x35, 0x37, 0x38, 0x38, 0x61, 0x35, 0x36, 0x65, 0x33, 0x66, 0x62, 0x39, 0x34, 0x36, 0x33, 0x34, 0x62, 0x33, 0x66, 0x66, 0x65, 0x31, 0x66, 0x62, 0x64, 0x62, 0x32, 0x36, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x37, 0x39, 0x38, 0x63, 0x62, 0x64, 0x61, 0x37, 0x31, 0x35, 0x65, 0x61, 0x39, 0x61, 0x39, 0x62, 0x39, 0x64, 0x36, 0x61, 0x61, 0x62, 0x39, 0x34, 0x32, 0x63, 0x35, 0x35, 0x31, 0x32, 0x31, 0x65, 0x39, 0x38, 0x62, 0x66, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x35, 0x61, 0x31, 0x36, 0x37, 0x62, 0x30, 0x33, 0x31, 0x65, 0x38, 0x34, 0x36, 0x31, 0x36, 0x64, 0x30, 0x66, 0x30, 0x31, 0x33, 0x66, 0x33, 0x31, 0x62, 0x64, 0x61, 0x39, 0x35, 0x64, 0x63, 0x63, 0x36, 0x33, 0x35, 0x30, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x39, 0x36, 0x63, 0x33, 0x64, 0x33, 0x63, 0x30, 0x39, 0x30, 0x38, 0x64, 0x32, 0x35, 0x34, 0x33, 0x36, 0x36, 0x62, 0x37, 0x62, 0x63, 0x61, 0x35, 0x35, 0x37, 0x34, 0x35, 0x32, 0x32, 0x32, 0x64, 0x39, 0x64, 0x34, 0x64, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x65, 0x39, 0x38, 0x35, 0x30, 0x35, 0x38, 0x36, 0x65, 0x39, 0x34, 0x66, 0x35, 0x32, 0x39, 0x39, 0x61, 0x62, 0x34, 0x39, 0x34, 0x62, 0x62, 0x38, 0x32, 0x31, 0x61, 0x35, 0x66, 0x34, 0x30, 0x63, 0x30, 0x30, 0x62, 0x64, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x35, 0x39, 0x63, 0x62, 0x63, 0x36, 0x33, 0x65, 0x33, 0x36, 0x63, 0x34, 0x33, 0x65, 0x38, 0x38, 0x66, 0x33, 0x30, 0x30, 0x30, 0x38, 0x61, 0x63, 0x61, 0x37, 0x63, 0x65, 0x30, 0x35, 0x38, 0x65, 0x65, 0x61, 0x61, 0x30, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x66, 0x32, 0x39, 0x31, 0x33, 0x62, 0x32, 0x36, 0x35, 0x63, 0x34, 0x33, 0x30, 0x66, 0x61, 0x31, 0x61, 0x62, 0x38, 0x61, 0x64, 0x66, 0x32, 0x36, 0x63, 0x33, 0x33, 0x33, 0x66, 0x63, 0x31, 0x64, 0x39, 0x62, 0x36, 0x36, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x65, 0x39, 0x65, 0x32, 0x61, 0x64, 0x37, 0x32, 0x39, 0x37, 0x30, 0x32, 0x36, 0x32, 0x36, 0x34, 0x31, 0x37, 0x65, 0x66, 0x32, 0x35, 0x64, 0x65, 0x30, 0x64, 0x63, 0x38, 0x30, 0x30, 0x66, 0x37, 0x61, 0x37, 0x37, 0x39, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x66, 0x62, 0x64, 0x34, 0x38, 0x31, 0x37, 0x30, 0x35, 0x30, 0x64, 0x39, 0x31, 0x64, 0x39, 0x64, 0x36, 0x32, 0x35, 0x63, 0x30, 0x32, 0x30, 0x35, 0x33, 0x63, 0x66, 0x36, 0x31, 0x61, 0x33, 0x65, 0x65, 0x32, 0x38, 0x35, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x39, 0x66, 0x65, 0x39, 0x64, 0x32, 0x63, 0x31, 0x66, 0x31, 0x63, 0x65, 0x34, 0x32, 0x32, 0x30, 0x37, 0x63, 0x39, 0x35, 0x38, 0x35, 0x30, 0x34, 0x34, 0x61, 0x36, 0x30, 0x38, 0x39, 0x39, 0x66, 0x33, 0x35, 0x39, 0x34, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x64, 0x38, 0x32, 0x63, 0x61, 0x65, 0x61, 0x31, 0x61, 0x38, 0x62, 0x34, 0x65, 0x64, 0x30, 0x35, 0x33, 0x31, 0x39, 0x62, 0x39, 0x63, 0x39, 0x38, 0x37, 0x30, 0x31, 0x37, 0x33, 0x63, 0x38, 0x31, 0x34, 0x65, 0x30, 0x36, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x35, 0x39, 0x35, 0x66, 0x31, 0x36, 0x65, 0x65, 0x65, 0x34, 0x63, 0x62, 0x30, 0x63, 0x31, 0x37, 0x64, 0x39, 0x61, 0x32, 0x64, 0x39, 0x33, 0x39, 0x62, 0x33, 0x63, 0x31, 0x30, 0x66, 0x36, 0x63, 0x36, 0x37, 0x37, 0x32, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x66, 0x38, 0x39, 0x64, 0x64, 0x35, 0x63, 0x63, 0x36, 0x65, 0x36, 0x34, 0x64, 0x37, 0x62, 0x31, 0x65, 0x65, 0x61, 0x63, 0x65, 0x30, 0x30, 0x37, 0x30, 0x32, 0x30, 0x32, 0x32, 0x63, 0x64, 0x37, 0x64, 0x32, 0x66, 0x30, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x61, 0x36, 0x63, 0x62, 0x61, 0x64, 0x37, 0x37, 0x36, 0x39, 0x32, 0x61, 0x33, 0x64, 0x38, 0x38, 0x64, 0x31, 0x34, 0x31, 0x65, 0x66, 0x37, 0x36, 0x39, 0x61, 0x39, 0x39, 0x62, 0x62, 0x39, 0x65, 0x33, 0x63, 0x39, 0x39, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x38, 0x63, 0x32, 0x33, 0x62, 0x65, 0x38, 0x37, 0x33, 0x34, 0x36, 0x36, 0x64, 0x34, 0x63, 0x37, 0x34, 0x63, 0x32, 0x32, 0x30, 0x61, 0x31, 0x39, 0x62, 0x32, 0x34, 0x35, 0x64, 0x31, 0x37, 0x38, 0x37, 0x65, 0x38, 0x30, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x36, 0x34, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x30, 0x35, 0x62, 0x31, 0x39, 0x32, 0x65, 0x38, 0x33, 0x63, 0x65, 0x36, 0x35, 0x39, 0x61, 0x61, 0x33, 0x35, 0x35, 0x62, 0x39, 0x64, 0x30, 0x63, 0x32, 0x30, 0x34, 0x65, 0x33, 0x65, 0x39, 0x35, 0x66, 0x39, 0x62, 0x62, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x36, 0x30, 0x38, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x62, 0x39, 0x66, 0x65, 0x66, 0x30, 0x61, 0x31, 0x33, 0x32, 0x39, 0x62, 0x30, 0x32, 0x64, 0x31, 0x36, 0x35, 0x30, 0x36, 0x32, 0x35, 0x35, 0x66, 0x35, 0x61, 0x32, 0x64, 0x62, 0x37, 0x31, 0x65, 0x63, 0x39, 0x32, 0x64, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x32, 0x35, 0x34, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x31, 0x30, 0x62, 0x37, 0x61, 0x36, 0x37, 0x62, 0x33, 0x32, 0x36, 0x38, 0x64, 0x35, 0x33, 0x33, 0x31, 0x62, 0x66, 0x62, 0x36, 0x61, 0x31, 0x34, 0x64, 0x65, 0x66, 0x35, 0x65, 0x61, 0x34, 0x61, 0x31, 0x36, 0x32, 0x63, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x65, 0x62, 0x32, 0x35, 0x36, 0x62, 0x35, 0x31, 0x63, 0x38, 0x31, 0x39, 0x64, 0x36, 0x30, 0x65, 0x61, 0x36, 0x31, 0x61, 0x38, 0x32, 0x64, 0x31, 0x32, 0x63, 0x39, 0x33, 0x35, 0x38, 0x64, 0x35, 0x39, 0x63, 0x31, 0x63, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x64, 0x65, 0x37, 0x65, 0x39, 0x33, 0x35, 0x32, 0x65, 0x39, 0x30, 0x62, 0x31, 0x33, 0x61, 0x35, 0x39, 0x61, 0x35, 0x38, 0x37, 0x38, 0x66, 0x66, 0x65, 0x63, 0x63, 0x37, 0x38, 0x33, 0x31, 0x63, 0x61, 0x63, 0x34, 0x64, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x32, 0x62, 0x32, 0x63, 0x37, 0x39, 0x63, 0x33, 0x36, 0x34, 0x37, 0x38, 0x63, 0x35, 0x34, 0x33, 0x31, 0x39, 0x30, 0x31, 0x66, 0x36, 0x64, 0x37, 0x30, 0x30, 0x62, 0x30, 0x34, 0x64, 0x62, 0x65, 0x39, 0x62, 0x38, 0x38, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x30, 0x33, 0x32, 0x36, 0x62, 0x32, 0x33, 0x66, 0x30, 0x34, 0x30, 0x39, 0x63, 0x30, 0x63, 0x30, 0x65, 0x39, 0x32, 0x33, 0x36, 0x38, 0x36, 0x33, 0x61, 0x31, 0x33, 0x33, 0x30, 0x37, 0x35, 0x61, 0x39, 0x34, 0x62, 0x61, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x65, 0x32, 0x31, 0x65, 0x64, 0x35, 0x36, 0x38, 0x36, 0x38, 0x66, 0x61, 0x62, 0x32, 0x38, 0x65, 0x30, 0x39, 0x34, 0x37, 0x39, 0x32, 0x37, 0x61, 0x64, 0x61, 0x66, 0x32, 0x39, 0x66, 0x32, 0x33, 0x65, 0x62, 0x61, 0x64, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x64, 0x36, 0x63, 0x39, 0x64, 0x31, 0x30, 0x63, 0x32, 0x36, 0x31, 0x38, 0x31, 0x39, 0x61, 0x31, 0x61, 0x30, 0x63, 0x61, 0x32, 0x63, 0x34, 0x38, 0x64, 0x38, 0x63, 0x37, 0x62, 0x32, 0x61, 0x37, 0x31, 0x37, 0x32, 0x38, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x34, 0x34, 0x35, 0x32, 0x36, 0x37, 0x63, 0x35, 0x39, 0x61, 0x62, 0x38, 0x64, 0x32, 0x61, 0x32, 0x64, 0x39, 0x65, 0x37, 0x30, 0x39, 0x39, 0x39, 0x30, 0x65, 0x30, 0x39, 0x36, 0x38, 0x32, 0x35, 0x38, 0x30, 0x63, 0x34, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x30, 0x34, 0x37, 0x63, 0x64, 0x66, 0x39, 0x33, 0x32, 0x64, 0x62, 0x33, 0x65, 0x34, 0x30, 0x34, 0x35, 0x66, 0x34, 0x39, 0x37, 0x36, 0x31, 0x32, 0x32, 0x33, 0x34, 0x31, 0x35, 0x33, 0x37, 0x65, 0x64, 0x35, 0x39, 0x36, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x33, 0x63, 0x66, 0x39, 0x37, 0x33, 0x31, 0x31, 0x66, 0x66, 0x33, 0x30, 0x66, 0x34, 0x36, 0x30, 0x39, 0x34, 0x35, 0x61, 0x39, 0x64, 0x38, 0x30, 0x39, 0x39, 0x66, 0x34, 0x61, 0x38, 0x38, 0x65, 0x32, 0x36, 0x64, 0x34, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x34, 0x66, 0x35, 0x39, 0x33, 0x62, 0x36, 0x31, 0x38, 0x63, 0x33, 0x33, 0x30, 0x62, 0x61, 0x32, 0x63, 0x33, 0x64, 0x35, 0x66, 0x34, 0x31, 0x65, 0x63, 0x65, 0x65, 0x62, 0x39, 0x32, 0x65, 0x32, 0x37, 0x65, 0x34, 0x32, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x61, 0x32, 0x66, 0x63, 0x38, 0x36, 0x37, 0x35, 0x66, 0x65, 0x62, 0x39, 0x37, 0x32, 0x66, 0x61, 0x34, 0x31, 0x62, 0x35, 0x30, 0x64, 0x66, 0x66, 0x64, 0x62, 0x62, 0x61, 0x65, 0x37, 0x66, 0x61, 0x32, 0x61, 0x64, 0x66, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x35, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x36, 0x35, 0x36, 0x31, 0x61, 0x38, 0x35, 0x36, 0x34, 0x35, 0x35, 0x64, 0x37, 0x65, 0x66, 0x38, 0x36, 0x65, 0x36, 0x33, 0x66, 0x38, 0x37, 0x63, 0x37, 0x33, 0x64, 0x62, 0x62, 0x36, 0x32, 0x38, 0x61, 0x35, 0x35, 0x66, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x64, 0x31, 0x37, 0x32, 0x34, 0x66, 0x64, 0x30, 0x30, 0x65, 0x35, 0x34, 0x61, 0x61, 0x62, 0x63, 0x64, 0x32, 0x64, 0x65, 0x32, 0x61, 0x39, 0x31, 0x65, 0x38, 0x34, 0x36, 0x32, 0x62, 0x31, 0x30, 0x34, 0x39, 0x64, 0x64, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x61, 0x30, 0x66, 0x39, 0x36, 0x65, 0x65, 0x30, 0x61, 0x35, 0x37, 0x33, 0x61, 0x33, 0x33, 0x30, 0x62, 0x35, 0x36, 0x38, 0x39, 0x37, 0x37, 0x36, 0x31, 0x66, 0x33, 0x64, 0x34, 0x63, 0x30, 0x31, 0x33, 0x30, 0x61, 0x38, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x36, 0x35, 0x63, 0x34, 0x31, 0x38, 0x38, 0x64, 0x37, 0x39, 0x32, 0x32, 0x35, 0x37, 0x36, 0x39, 0x30, 0x39, 0x36, 0x34, 0x32, 0x30, 0x34, 0x34, 0x66, 0x64, 0x63, 0x35, 0x32, 0x33, 0x39, 0x35, 0x35, 0x36, 0x30, 0x31, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x38, 0x38, 0x33, 0x30, 0x31, 0x30, 0x62, 0x34, 0x61, 0x63, 0x38, 0x35, 0x37, 0x66, 0x65, 0x64, 0x61, 0x63, 0x30, 0x33, 0x65, 0x61, 0x62, 0x32, 0x35, 0x35, 0x31, 0x37, 0x32, 0x33, 0x61, 0x38, 0x34, 0x34, 0x37, 0x66, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x32, 0x39, 0x61, 0x38, 0x61, 0x34, 0x61, 0x35, 0x62, 0x61, 0x32, 0x33, 0x66, 0x35, 0x37, 0x39, 0x64, 0x30, 0x30, 0x32, 0x35, 0x62, 0x31, 0x61, 0x64, 0x30, 0x66, 0x38, 0x61, 0x30, 0x64, 0x33, 0x35, 0x63, 0x64, 0x66, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x35, 0x63, 0x31, 0x66, 0x62, 0x31, 0x37, 0x37, 0x30, 0x38, 0x39, 0x66, 0x33, 0x65, 0x35, 0x38, 0x62, 0x31, 0x30, 0x36, 0x37, 0x39, 0x33, 0x35, 0x61, 0x36, 0x35, 0x39, 0x36, 0x65, 0x66, 0x31, 0x37, 0x33, 0x37, 0x66, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x65, 0x39, 0x37, 0x38, 0x37, 0x35, 0x33, 0x64, 0x39, 0x38, 0x32, 0x66, 0x37, 0x66, 0x39, 0x64, 0x31, 0x64, 0x32, 0x33, 0x38, 0x61, 0x31, 0x38, 0x62, 0x64, 0x34, 0x38, 0x38, 0x39, 0x61, 0x65, 0x66, 0x65, 0x34, 0x35, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x32, 0x30, 0x66, 0x34, 0x36, 0x64, 0x31, 0x34, 0x35, 0x31, 0x63, 0x32, 0x33, 0x35, 0x33, 0x64, 0x36, 0x32, 0x34, 0x33, 0x61, 0x35, 0x64, 0x34, 0x62, 0x34, 0x32, 0x37, 0x31, 0x33, 0x30, 0x62, 0x65, 0x32, 0x64, 0x34, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x64, 0x36, 0x38, 0x38, 0x66, 0x30, 0x36, 0x62, 0x62, 0x64, 0x62, 0x66, 0x35, 0x30, 0x66, 0x39, 0x39, 0x33, 0x32, 0x63, 0x34, 0x31, 0x34, 0x35, 0x63, 0x62, 0x65, 0x34, 0x38, 0x65, 0x63, 0x64, 0x66, 0x36, 0x38, 0x39, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x61, 0x39, 0x34, 0x38, 0x65, 0x61, 0x30, 0x32, 0x33, 0x39, 0x37, 0x37, 0x35, 0x35, 0x65, 0x66, 0x66, 0x62, 0x32, 0x66, 0x39, 0x64, 0x63, 0x39, 0x33, 0x39, 0x32, 0x64, 0x66, 0x31, 0x30, 0x35, 0x38, 0x66, 0x37, 0x65, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x64, 0x31, 0x34, 0x31, 0x37, 0x66, 0x39, 0x39, 0x63, 0x35, 0x36, 0x39, 0x65, 0x33, 0x62, 0x65, 0x62, 0x30, 0x39, 0x35, 0x38, 0x35, 0x36, 0x35, 0x33, 0x30, 0x66, 0x65, 0x31, 0x32, 0x64, 0x30, 0x66, 0x63, 0x65, 0x61, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x32, 0x31, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x37, 0x37, 0x62, 0x64, 0x66, 0x30, 0x30, 0x66, 0x64, 0x35, 0x39, 0x38, 0x35, 0x62, 0x35, 0x64, 0x62, 0x31, 0x32, 0x62, 0x62, 0x65, 0x66, 0x38, 0x30, 0x30, 0x33, 0x38, 0x30, 0x61, 0x62, 0x63, 0x32, 0x61, 0x30, 0x36, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x37, 0x61, 0x37, 0x65, 0x36, 0x65, 0x38, 0x32, 0x65, 0x31, 0x62, 0x39, 0x31, 0x64, 0x35, 0x31, 0x64, 0x65, 0x64, 0x64, 0x62, 0x36, 0x34, 0x34, 0x66, 0x30, 0x65, 0x39, 0x36, 0x64, 0x62, 0x62, 0x31, 0x66, 0x37, 0x66, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x62, 0x63, 0x62, 0x66, 0x33, 0x38, 0x62, 0x33, 0x63, 0x39, 0x30, 0x31, 0x36, 0x33, 0x61, 0x38, 0x34, 0x62, 0x31, 0x63, 0x64, 0x32, 0x61, 0x39, 0x33, 0x62, 0x35, 0x38, 0x62, 0x32, 0x61, 0x33, 0x33, 0x34, 0x38, 0x64, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x36, 0x62, 0x39, 0x33, 0x61, 0x33, 0x62, 0x65, 0x63, 0x31, 0x36, 0x33, 0x34, 0x39, 0x35, 0x34, 0x30, 0x63, 0x62, 0x66, 0x63, 0x61, 0x65, 0x39, 0x36, 0x63, 0x39, 0x36, 0x32, 0x31, 0x64, 0x36, 0x36, 0x34, 0x35, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x33, 0x30, 0x38, 0x38, 0x37, 0x39, 0x30, 0x35, 0x36, 0x64, 0x66, 0x65, 0x31, 0x33, 0x38, 0x65, 0x66, 0x38, 0x32, 0x30, 0x38, 0x66, 0x37, 0x39, 0x61, 0x39, 0x31, 0x35, 0x63, 0x36, 0x62, 0x63, 0x37, 0x65, 0x37, 0x30, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x38, 0x62, 0x36, 0x39, 0x33, 0x63, 0x61, 0x63, 0x65, 0x66, 0x64, 0x62, 0x64, 0x36, 0x63, 0x62, 0x35, 0x64, 0x37, 0x38, 0x39, 0x35, 0x61, 0x34, 0x32, 0x65, 0x33, 0x31, 0x39, 0x36, 0x33, 0x32, 0x37, 0x65, 0x32, 0x36, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x39, 0x35, 0x31, 0x39, 0x37, 0x30, 0x64, 0x66, 0x64, 0x30, 0x38, 0x33, 0x32, 0x66, 0x62, 0x38, 0x33, 0x62, 0x64, 0x61, 0x31, 0x32, 0x63, 0x32, 0x33, 0x35, 0x34, 0x35, 0x65, 0x37, 0x39, 0x30, 0x34, 0x31, 0x37, 0x35, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x64, 0x66, 0x37, 0x34, 0x32, 0x31, 0x33, 0x39, 0x34, 0x35, 0x39, 0x35, 0x33, 0x64, 0x62, 0x33, 0x39, 0x61, 0x64, 0x30, 0x65, 0x38, 0x61, 0x39, 0x37, 0x38, 0x31, 0x61, 0x64, 0x64, 0x37, 0x39, 0x32, 0x65, 0x34, 0x64, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x36, 0x32, 0x31, 0x38, 0x36, 0x35, 0x62, 0x36, 0x35, 0x39, 0x31, 0x33, 0x36, 0x35, 0x36, 0x30, 0x36, 0x65, 0x64, 0x33, 0x37, 0x38, 0x33, 0x30, 0x38, 0x63, 0x32, 0x64, 0x31, 0x64, 0x65, 0x66, 0x34, 0x66, 0x32, 0x32, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x64, 0x36, 0x61, 0x38, 0x61, 0x61, 0x31, 0x62, 0x66, 0x38, 0x64, 0x36, 0x65, 0x61, 0x66, 0x37, 0x33, 0x38, 0x34, 0x65, 0x39, 0x39, 0x33, 0x64, 0x66, 0x64, 0x66, 0x31, 0x30, 0x66, 0x30, 0x61, 0x66, 0x36, 0x38, 0x61, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x30, 0x61, 0x66, 0x33, 0x37, 0x35, 0x36, 0x36, 0x64, 0x31, 0x35, 0x32, 0x38, 0x30, 0x32, 0x66, 0x31, 0x61, 0x65, 0x38, 0x66, 0x39, 0x32, 0x38, 0x62, 0x32, 0x35, 0x61, 0x66, 0x39, 0x62, 0x31, 0x33, 0x39, 0x62, 0x34, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x36, 0x61, 0x66, 0x63, 0x64, 0x34, 0x30, 0x33, 0x37, 0x63, 0x31, 0x65, 0x64, 0x31, 0x34, 0x66, 0x61, 0x37, 0x34, 0x66, 0x66, 0x36, 0x37, 0x35, 0x38, 0x65, 0x30, 0x39, 0x34, 0x35, 0x61, 0x31, 0x38, 0x35, 0x61, 0x38, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x62, 0x32, 0x61, 0x61, 0x38, 0x63, 0x62, 0x32, 0x62, 0x66, 0x36, 0x32, 0x63, 0x64, 0x63, 0x31, 0x33, 0x61, 0x34, 0x37, 0x65, 0x63, 0x63, 0x34, 0x36, 0x35, 0x37, 0x66, 0x61, 0x63, 0x61, 0x61, 0x39, 0x39, 0x35, 0x66, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x38, 0x31, 0x34, 0x34, 0x65, 0x30, 0x38, 0x65, 0x38, 0x39, 0x36, 0x34, 0x37, 0x38, 0x31, 0x31, 0x66, 0x65, 0x36, 0x62, 0x37, 0x32, 0x64, 0x34, 0x34, 0x35, 0x64, 0x36, 0x61, 0x35, 0x66, 0x38, 0x30, 0x61, 0x64, 0x32, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x34, 0x66, 0x66, 0x35, 0x65, 0x35, 0x61, 0x37, 0x65, 0x32, 0x61, 0x66, 0x39, 0x39, 0x35, 0x64, 0x38, 0x38, 0x35, 0x37, 0x63, 0x65, 0x30, 0x32, 0x39, 0x30, 0x62, 0x35, 0x33, 0x61, 0x32, 0x62, 0x30, 0x65, 0x64, 0x61, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x64, 0x65, 0x64, 0x66, 0x63, 0x64, 0x30, 0x62, 0x33, 0x63, 0x32, 0x65, 0x31, 0x37, 0x63, 0x37, 0x30, 0x35, 0x64, 0x61, 0x32, 0x34, 0x38, 0x37, 0x39, 0x30, 0x65, 0x66, 0x39, 0x38, 0x61, 0x36, 0x62, 0x64, 0x35, 0x37, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x38, 0x61, 0x38, 0x61, 0x36, 0x66, 0x30, 0x31, 0x66, 0x39, 0x61, 0x62, 0x36, 0x38, 0x32, 0x66, 0x36, 0x33, 0x37, 0x63, 0x37, 0x39, 0x36, 0x39, 0x62, 0x65, 0x38, 0x38, 0x35, 0x66, 0x36, 0x63, 0x35, 0x33, 0x30, 0x32, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x32, 0x63, 0x36, 0x66, 0x65, 0x64, 0x62, 0x64, 0x61, 0x63, 0x39, 0x38, 0x61, 0x66, 0x32, 0x65, 0x65, 0x64, 0x31, 0x30, 0x62, 0x30, 0x30, 0x66, 0x33, 0x32, 0x62, 0x30, 0x30, 0x30, 0x35, 0x36, 0x63, 0x61, 0x35, 0x61, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x39, 0x37, 0x62, 0x33, 0x33, 0x39, 0x38, 0x31, 0x33, 0x62, 0x30, 0x63, 0x32, 0x64, 0x39, 0x36, 0x34, 0x62, 0x32, 0x34, 0x37, 0x31, 0x65, 0x62, 0x31, 0x63, 0x36, 0x30, 0x36, 0x66, 0x34, 0x65, 0x63, 0x62, 0x39, 0x36, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x37, 0x63, 0x39, 0x62, 0x63, 0x64, 0x36, 0x65, 0x33, 0x66, 0x33, 0x39, 0x39, 0x30, 0x61, 0x35, 0x32, 0x62, 0x65, 0x33, 0x65, 0x64, 0x61, 0x34, 0x37, 0x31, 0x30, 0x63, 0x32, 0x37, 0x35, 0x31, 0x38, 0x66, 0x34, 0x66, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x64, 0x34, 0x38, 0x63, 0x61, 0x32, 0x64, 0x62, 0x32, 0x66, 0x38, 0x35, 0x64, 0x38, 0x63, 0x35, 0x35, 0x35, 0x63, 0x62, 0x30, 0x65, 0x39, 0x63, 0x66, 0x65, 0x38, 0x32, 0x36, 0x39, 0x33, 0x36, 0x37, 0x38, 0x33, 0x66, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x32, 0x31, 0x34, 0x63, 0x30, 0x32, 0x33, 0x65, 0x32, 0x33, 0x32, 0x36, 0x66, 0x66, 0x36, 0x39, 0x36, 0x63, 0x30, 0x30, 0x33, 0x39, 0x33, 0x31, 0x36, 0x38, 0x63, 0x65, 0x34, 0x36, 0x66, 0x66, 0x61, 0x63, 0x33, 0x39, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x35, 0x37, 0x30, 0x61, 0x62, 0x32, 0x35, 0x39, 0x63, 0x39, 0x62, 0x31, 0x63, 0x33, 0x32, 0x63, 0x39, 0x37, 0x32, 0x39, 0x32, 0x30, 0x32, 0x66, 0x37, 0x37, 0x66, 0x35, 0x39, 0x30, 0x63, 0x30, 0x37, 0x64, 0x64, 0x36, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x34, 0x36, 0x61, 0x39, 0x35, 0x63, 0x36, 0x64, 0x36, 0x66, 0x35, 0x39, 0x66, 0x31, 0x30, 0x34, 0x63, 0x36, 0x35, 0x34, 0x31, 0x64, 0x37, 0x37, 0x36, 0x30, 0x37, 0x35, 0x37, 0x61, 0x62, 0x33, 0x39, 0x32, 0x62, 0x30, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x33, 0x33, 0x65, 0x33, 0x33, 0x34, 0x63, 0x34, 0x30, 0x66, 0x33, 0x61, 0x63, 0x62, 0x61, 0x64, 0x30, 0x63, 0x30, 0x62, 0x38, 0x35, 0x31, 0x31, 0x35, 0x38, 0x32, 0x30, 0x36, 0x39, 0x32, 0x34, 0x62, 0x65, 0x63, 0x61, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x35, 0x31, 0x35, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x35, 0x32, 0x61, 0x34, 0x39, 0x36, 0x65, 0x62, 0x61, 0x36, 0x37, 0x66, 0x31, 0x32, 0x62, 0x65, 0x36, 0x65, 0x65, 0x64, 0x61, 0x62, 0x33, 0x36, 0x30, 0x63, 0x64, 0x31, 0x33, 0x36, 0x36, 0x31, 0x64, 0x63, 0x37, 0x34, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x39, 0x63, 0x39, 0x36, 0x63, 0x31, 0x39, 0x31, 0x35, 0x31, 0x66, 0x66, 0x63, 0x62, 0x65, 0x32, 0x39, 0x61, 0x34, 0x36, 0x31, 0x36, 0x64, 0x30, 0x63, 0x35, 0x32, 0x62, 0x33, 0x39, 0x33, 0x33, 0x62, 0x34, 0x36, 0x35, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x32, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x37, 0x62, 0x38, 0x65, 0x32, 0x37, 0x64, 0x65, 0x33, 0x33, 0x64, 0x33, 0x63, 0x65, 0x37, 0x39, 0x36, 0x31, 0x62, 0x39, 0x38, 0x64, 0x31, 0x39, 0x61, 0x35, 0x32, 0x66, 0x65, 0x37, 0x39, 0x66, 0x36, 0x63, 0x32, 0x35, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x39, 0x31, 0x31, 0x34, 0x30, 0x35, 0x63, 0x66, 0x36, 0x65, 0x39, 0x39, 0x39, 0x65, 0x64, 0x30, 0x31, 0x31, 0x66, 0x30, 0x64, 0x64, 0x63, 0x64, 0x32, 0x61, 0x34, 0x66, 0x66, 0x37, 0x63, 0x32, 0x38, 0x66, 0x32, 0x35, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x61, 0x65, 0x31, 0x30, 0x38, 0x65, 0x36, 0x64, 0x62, 0x39, 0x39, 0x62, 0x39, 0x65, 0x36, 0x33, 0x37, 0x38, 0x37, 0x36, 0x62, 0x30, 0x36, 0x34, 0x63, 0x36, 0x33, 0x30, 0x33, 0x65, 0x64, 0x61, 0x38, 0x61, 0x36, 0x35, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x38, 0x33, 0x62, 0x65, 0x63, 0x63, 0x30, 0x38, 0x62, 0x39, 0x62, 0x65, 0x36, 0x38, 0x61, 0x64, 0x33, 0x62, 0x30, 0x38, 0x33, 0x36, 0x61, 0x61, 0x63, 0x33, 0x62, 0x36, 0x32, 0x30, 0x64, 0x63, 0x30, 0x30, 0x31, 0x37, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x61, 0x62, 0x63, 0x63, 0x37, 0x30, 0x63, 0x30, 0x34, 0x32, 0x30, 0x65, 0x30, 0x65, 0x31, 0x37, 0x32, 0x66, 0x39, 0x37, 0x64, 0x34, 0x33, 0x62, 0x38, 0x37, 0x64, 0x35, 0x65, 0x38, 0x30, 0x63, 0x33, 0x33, 0x36, 0x65, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x66, 0x31, 0x36, 0x61, 0x30, 0x66, 0x65, 0x32, 0x37, 0x34, 0x35, 0x32, 0x35, 0x38, 0x63, 0x64, 0x35, 0x32, 0x64, 0x62, 0x32, 0x62, 0x66, 0x32, 0x31, 0x39, 0x35, 0x34, 0x63, 0x39, 0x37, 0x35, 0x66, 0x63, 0x36, 0x61, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x32, 0x33, 0x63, 0x62, 0x38, 0x36, 0x36, 0x33, 0x35, 0x35, 0x34, 0x38, 0x37, 0x31, 0x66, 0x62, 0x62, 0x65, 0x30, 0x64, 0x39, 0x65, 0x36, 0x30, 0x33, 0x39, 0x37, 0x65, 0x66, 0x62, 0x36, 0x66, 0x61, 0x65, 0x64, 0x63, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x65, 0x64, 0x65, 0x33, 0x32, 0x63, 0x33, 0x34, 0x39, 0x66, 0x33, 0x33, 0x30, 0x30, 0x65, 0x66, 0x34, 0x63, 0x64, 0x33, 0x33, 0x62, 0x34, 0x64, 0x65, 0x37, 0x64, 0x63, 0x31, 0x38, 0x65, 0x34, 0x34, 0x33, 0x64, 0x33, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x38, 0x30, 0x36, 0x65, 0x38, 0x34, 0x35, 0x37, 0x33, 0x30, 0x66, 0x38, 0x30, 0x37, 0x33, 0x65, 0x36, 0x63, 0x63, 0x39, 0x30, 0x31, 0x38, 0x65, 0x65, 0x39, 0x30, 0x66, 0x35, 0x63, 0x30, 0x35, 0x66, 0x39, 0x30, 0x39, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x35, 0x63, 0x33, 0x33, 0x38, 0x61, 0x31, 0x33, 0x32, 0x35, 0x65, 0x33, 0x61, 0x31, 0x35, 0x37, 0x38, 0x65, 0x66, 0x61, 0x32, 0x39, 0x39, 0x65, 0x35, 0x37, 0x64, 0x39, 0x38, 0x36, 0x65, 0x62, 0x34, 0x37, 0x34, 0x66, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x66, 0x32, 0x39, 0x37, 0x66, 0x38, 0x66, 0x34, 0x35, 0x33, 0x35, 0x32, 0x33, 0x65, 0x64, 0x36, 0x36, 0x61, 0x31, 0x61, 0x63, 0x62, 0x37, 0x36, 0x37, 0x36, 0x38, 0x35, 0x36, 0x33, 0x33, 0x37, 0x62, 0x39, 0x33, 0x62, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x65, 0x38, 0x61, 0x33, 0x31, 0x61, 0x66, 0x32, 0x64, 0x32, 0x36, 0x35, 0x65, 0x33, 0x31, 0x61, 0x39, 0x66, 0x66, 0x66, 0x32, 0x64, 0x38, 0x66, 0x34, 0x36, 0x32, 0x38, 0x36, 0x64, 0x31, 0x32, 0x34, 0x35, 0x61, 0x34, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x64, 0x61, 0x66, 0x62, 0x61, 0x38, 0x39, 0x38, 0x34, 0x62, 0x61, 0x66, 0x36, 0x33, 0x31, 0x61, 0x38, 0x32, 0x30, 0x62, 0x36, 0x62, 0x39, 0x32, 0x62, 0x62, 0x63, 0x32, 0x63, 0x35, 0x33, 0x36, 0x35, 0x35, 0x66, 0x36, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x30, 0x32, 0x30, 0x30, 0x66, 0x31, 0x64, 0x31, 0x37, 0x65, 0x39, 0x63, 0x35, 0x34, 0x64, 0x61, 0x30, 0x36, 0x34, 0x37, 0x62, 0x62, 0x39, 0x36, 0x33, 0x39, 0x35, 0x64, 0x35, 0x37, 0x61, 0x37, 0x38, 0x35, 0x33, 0x38, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x33, 0x65, 0x62, 0x39, 0x34, 0x61, 0x33, 0x33, 0x39, 0x30, 0x38, 0x36, 0x65, 0x64, 0x31, 0x32, 0x64, 0x39, 0x62, 0x64, 0x65, 0x39, 0x63, 0x64, 0x31, 0x64, 0x34, 0x35, 0x38, 0x36, 0x30, 0x33, 0x63, 0x39, 0x37, 0x64, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x37, 0x65, 0x34, 0x37, 0x39, 0x30, 0x39, 0x34, 0x36, 0x34, 0x64, 0x38, 0x37, 0x31, 0x62, 0x39, 0x61, 0x36, 0x64, 0x63, 0x37, 0x36, 0x61, 0x38, 0x65, 0x39, 0x31, 0x39, 0x35, 0x64, 0x62, 0x33, 0x34, 0x38, 0x35, 0x65, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x37, 0x35, 0x64, 0x37, 0x38, 0x64, 0x39, 0x37, 0x34, 0x65, 0x65, 0x35, 0x62, 0x62, 0x39, 0x65, 0x34, 0x64, 0x34, 0x63, 0x61, 0x32, 0x61, 0x65, 0x37, 0x37, 0x63, 0x38, 0x34, 0x62, 0x39, 0x63, 0x33, 0x62, 0x34, 0x62, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x61, 0x32, 0x38, 0x39, 0x36, 0x36, 0x32, 0x33, 0x66, 0x34, 0x39, 0x31, 0x30, 0x32, 0x38, 0x37, 0x61, 0x32, 0x62, 0x64, 0x63, 0x35, 0x62, 0x65, 0x38, 0x33, 0x61, 0x65, 0x61, 0x33, 0x66, 0x32, 0x65, 0x36, 0x64, 0x65, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x34, 0x61, 0x64, 0x30, 0x63, 0x37, 0x32, 0x33, 0x64, 0x61, 0x34, 0x36, 0x61, 0x62, 0x35, 0x36, 0x64, 0x35, 0x32, 0x36, 0x64, 0x61, 0x30, 0x63, 0x31, 0x64, 0x32, 0x35, 0x63, 0x37, 0x33, 0x64, 0x61, 0x66, 0x66, 0x31, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x63, 0x66, 0x33, 0x36, 0x30, 0x61, 0x61, 0x32, 0x33, 0x32, 0x39, 0x65, 0x62, 0x37, 0x39, 0x64, 0x32, 0x62, 0x66, 0x37, 0x63, 0x61, 0x30, 0x34, 0x61, 0x32, 0x37, 0x61, 0x31, 0x37, 0x63, 0x35, 0x33, 0x32, 0x65, 0x34, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x36, 0x30, 0x35, 0x34, 0x39, 0x65, 0x63, 0x37, 0x35, 0x35, 0x33, 0x66, 0x35, 0x31, 0x31, 0x64, 0x32, 0x31, 0x34, 0x39, 0x66, 0x32, 0x64, 0x34, 0x36, 0x36, 0x36, 0x63, 0x62, 0x64, 0x39, 0x32, 0x34, 0x33, 0x64, 0x39, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x62, 0x37, 0x62, 0x65, 0x31, 0x37, 0x39, 0x35, 0x33, 0x66, 0x32, 0x63, 0x63, 0x63, 0x39, 0x33, 0x65, 0x31, 0x62, 0x63, 0x39, 0x39, 0x38, 0x30, 0x35, 0x62, 0x66, 0x34, 0x35, 0x35, 0x31, 0x31, 0x34, 0x33, 0x34, 0x65, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x34, 0x39, 0x62, 0x64, 0x34, 0x30, 0x62, 0x62, 0x62, 0x63, 0x32, 0x62, 0x33, 0x30, 0x30, 0x39, 0x35, 0x63, 0x61, 0x63, 0x38, 0x62, 0x65, 0x32, 0x63, 0x30, 0x37, 0x61, 0x30, 0x35, 0x38, 0x38, 0x65, 0x30, 0x61, 0x65, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x31, 0x30, 0x64, 0x66, 0x34, 0x32, 0x61, 0x35, 0x39, 0x39, 0x62, 0x63, 0x62, 0x30, 0x61, 0x35, 0x31, 0x39, 0x63, 0x63, 0x61, 0x39, 0x36, 0x31, 0x62, 0x34, 0x38, 0x38, 0x37, 0x35, 0x39, 0x61, 0x36, 0x66, 0x36, 0x37, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x31, 0x32, 0x61, 0x31, 0x62, 0x61, 0x31, 0x66, 0x62, 0x38, 0x61, 0x64, 0x66, 0x63, 0x62, 0x32, 0x30, 0x64, 0x66, 0x61, 0x31, 0x39, 0x35, 0x38, 0x32, 0x65, 0x35, 0x32, 0x35, 0x61, 0x61, 0x33, 0x62, 0x37, 0x34, 0x35, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x35, 0x65, 0x62, 0x38, 0x63, 0x30, 0x65, 0x39, 0x65, 0x31, 0x30, 0x31, 0x64, 0x65, 0x65, 0x64, 0x65, 0x63, 0x31, 0x31, 0x66, 0x32, 0x65, 0x63, 0x64, 0x62, 0x36, 0x36, 0x61, 0x65, 0x31, 0x61, 0x61, 0x65, 0x38, 0x38, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x39, 0x30, 0x36, 0x64, 0x37, 0x64, 0x35, 0x66, 0x31, 0x37, 0x34, 0x38, 0x32, 0x35, 0x38, 0x31, 0x37, 0x34, 0x62, 0x65, 0x34, 0x63, 0x62, 0x63, 0x33, 0x38, 0x39, 0x33, 0x30, 0x33, 0x30, 0x32, 0x61, 0x62, 0x37, 0x62, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x33, 0x66, 0x31, 0x65, 0x37, 0x34, 0x32, 0x61, 0x32, 0x63, 0x65, 0x63, 0x38, 0x36, 0x62, 0x30, 0x64, 0x37, 0x62, 0x33, 0x30, 0x36, 0x65, 0x35, 0x65, 0x61, 0x63, 0x62, 0x36, 0x63, 0x63, 0x62, 0x32, 0x66, 0x38, 0x35, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x64, 0x31, 0x61, 0x36, 0x32, 0x38, 0x30, 0x32, 0x33, 0x35, 0x31, 0x61, 0x34, 0x31, 0x35, 0x36, 0x38, 0x64, 0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x30, 0x34, 0x61, 0x63, 0x63, 0x36, 0x63, 0x30, 0x30, 0x35, 0x61, 0x35, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x38, 0x63, 0x35, 0x34, 0x36, 0x34, 0x39, 0x61, 0x38, 0x61, 0x36, 0x65, 0x39, 0x34, 0x37, 0x32, 0x32, 0x62, 0x64, 0x36, 0x64, 0x32, 0x31, 0x64, 0x31, 0x34, 0x37, 0x31, 0x34, 0x66, 0x37, 0x31, 0x37, 0x38, 0x30, 0x35, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x36, 0x35, 0x37, 0x65, 0x63, 0x30, 0x36, 0x66, 0x65, 0x35, 0x62, 0x63, 0x30, 0x39, 0x63, 0x66, 0x32, 0x33, 0x65, 0x35, 0x32, 0x61, 0x66, 0x37, 0x66, 0x38, 0x30, 0x63, 0x63, 0x33, 0x36, 0x38, 0x39, 0x65, 0x36, 0x65, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x62, 0x66, 0x37, 0x61, 0x35, 0x61, 0x62, 0x35, 0x39, 0x32, 0x39, 0x33, 0x31, 0x34, 0x39, 0x62, 0x35, 0x63, 0x36, 0x30, 0x63, 0x66, 0x33, 0x36, 0x34, 0x32, 0x36, 0x33, 0x65, 0x35, 0x65, 0x62, 0x66, 0x31, 0x61, 0x61, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x36, 0x64, 0x37, 0x38, 0x31, 0x63, 0x37, 0x37, 0x63, 0x34, 0x62, 0x61, 0x31, 0x66, 0x63, 0x61, 0x64, 0x66, 0x36, 0x38, 0x37, 0x33, 0x34, 0x31, 0x63, 0x31, 0x65, 0x33, 0x31, 0x37, 0x39, 0x39, 0x65, 0x39, 0x33, 0x64, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x30, 0x32, 0x38, 0x65, 0x34, 0x30, 0x39, 0x63, 0x63, 0x34, 0x33, 0x61, 0x33, 0x62, 0x64, 0x33, 0x33, 0x64, 0x32, 0x31, 0x61, 0x39, 0x66, 0x63, 0x35, 0x33, 0x65, 0x63, 0x36, 0x30, 0x36, 0x65, 0x39, 0x34, 0x39, 0x31, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x38, 0x31, 0x61, 0x31, 0x30, 0x61, 0x34, 0x64, 0x66, 0x35, 0x65, 0x65, 0x62, 0x63, 0x38, 0x32, 0x66, 0x34, 0x63, 0x66, 0x65, 0x31, 0x30, 0x37, 0x62, 0x61, 0x31, 0x64, 0x38, 0x61, 0x37, 0x36, 0x34, 0x30, 0x62, 0x64, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x65, 0x30, 0x38, 0x62, 0x63, 0x35, 0x33, 0x33, 0x34, 0x31, 0x33, 0x63, 0x32, 0x36, 0x65, 0x32, 0x39, 0x31, 0x62, 0x33, 0x31, 0x34, 0x33, 0x66, 0x66, 0x61, 0x37, 0x63, 0x63, 0x39, 0x61, 0x66, 0x62, 0x39, 0x37, 0x62, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x65, 0x66, 0x36, 0x61, 0x64, 0x32, 0x30, 0x66, 0x66, 0x37, 0x62, 0x64, 0x34, 0x66, 0x30, 0x30, 0x32, 0x62, 0x61, 0x63, 0x35, 0x38, 0x64, 0x34, 0x37, 0x35, 0x34, 0x34, 0x63, 0x66, 0x38, 0x37, 0x39, 0x61, 0x65, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x33, 0x36, 0x39, 0x36, 0x63, 0x66, 0x31, 0x66, 0x34, 0x32, 0x31, 0x37, 0x62, 0x31, 0x36, 0x33, 0x64, 0x31, 0x62, 0x63, 0x31, 0x32, 0x61, 0x35, 0x65, 0x61, 0x37, 0x33, 0x30, 0x66, 0x31, 0x63, 0x33, 0x32, 0x61, 0x31, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x35, 0x31, 0x33, 0x35, 0x62, 0x31, 0x61, 0x37, 0x66, 0x63, 0x31, 0x36, 0x30, 0x35, 0x36, 0x31, 0x34, 0x63, 0x38, 0x61, 0x61, 0x34, 0x64, 0x30, 0x61, 0x63, 0x36, 0x64, 0x62, 0x61, 0x64, 0x30, 0x38, 0x66, 0x34, 0x38, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x36, 0x62, 0x31, 0x38, 0x36, 0x64, 0x36, 0x31, 0x65, 0x61, 0x31, 0x66, 0x64, 0x37, 0x38, 0x64, 0x39, 0x39, 0x33, 0x30, 0x66, 0x65, 0x31, 0x32, 0x62, 0x30, 0x36, 0x35, 0x33, 0x37, 0x62, 0x30, 0x35, 0x63, 0x33, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x36, 0x36, 0x35, 0x37, 0x66, 0x35, 0x39, 0x37, 0x31, 0x31, 0x62, 0x31, 0x66, 0x38, 0x30, 0x33, 0x63, 0x36, 0x65, 0x62, 0x65, 0x66, 0x36, 0x38, 0x32, 0x66, 0x39, 0x31, 0x35, 0x62, 0x36, 0x32, 0x66, 0x39, 0x32, 0x64, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x38, 0x62, 0x62, 0x65, 0x65, 0x31, 0x38, 0x32, 0x65, 0x34, 0x35, 0x35, 0x64, 0x32, 0x30, 0x39, 0x38, 0x61, 0x63, 0x62, 0x33, 0x33, 0x38, 0x61, 0x36, 0x64, 0x34, 0x35, 0x62, 0x34, 0x62, 0x31, 0x37, 0x65, 0x64, 0x38, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x32, 0x64, 0x61, 0x30, 0x39, 0x33, 0x62, 0x62, 0x31, 0x36, 0x65, 0x62, 0x30, 0x36, 0x34, 0x66, 0x38, 0x62, 0x66, 0x61, 0x39, 0x65, 0x33, 0x30, 0x62, 0x39, 0x32, 0x39, 0x64, 0x31, 0x35, 0x66, 0x38, 0x65, 0x31, 0x63, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x64, 0x39, 0x63, 0x66, 0x30, 0x30, 0x64, 0x36, 0x35, 0x38, 0x64, 0x64, 0x34, 0x35, 0x35, 0x31, 0x37, 0x61, 0x34, 0x38, 0x61, 0x39, 0x64, 0x33, 0x66, 0x35, 0x66, 0x36, 0x33, 0x33, 0x35, 0x34, 0x31, 0x61, 0x35, 0x33, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x66, 0x36, 0x34, 0x62, 0x61, 0x62, 0x62, 0x37, 0x30, 0x33, 0x33, 0x31, 0x34, 0x32, 0x66, 0x32, 0x30, 0x65, 0x34, 0x36, 0x64, 0x37, 0x61, 0x61, 0x36, 0x32, 0x30, 0x31, 0x65, 0x64, 0x38, 0x36, 0x66, 0x36, 0x37, 0x31, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x65, 0x32, 0x62, 0x35, 0x39, 0x34, 0x31, 0x65, 0x30, 0x63, 0x30, 0x31, 0x39, 0x34, 0x34, 0x62, 0x66, 0x65, 0x31, 0x64, 0x35, 0x66, 0x62, 0x34, 0x65, 0x38, 0x61, 0x33, 0x34, 0x62, 0x39, 0x32, 0x32, 0x63, 0x63, 0x66, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x31, 0x34, 0x62, 0x30, 0x65, 0x61, 0x65, 0x35, 0x35, 0x37, 0x36, 0x39, 0x30, 0x33, 0x66, 0x38, 0x30, 0x62, 0x66, 0x62, 0x39, 0x38, 0x38, 0x34, 0x32, 0x64, 0x32, 0x34, 0x65, 0x64, 0x39, 0x32, 0x32, 0x33, 0x37, 0x66, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x64, 0x66, 0x30, 0x63, 0x34, 0x61, 0x62, 0x65, 0x37, 0x64, 0x65, 0x64, 0x35, 0x66, 0x65, 0x30, 0x36, 0x38, 0x65, 0x61, 0x64, 0x66, 0x31, 0x35, 0x34, 0x61, 0x63, 0x36, 0x39, 0x31, 0x37, 0x37, 0x34, 0x33, 0x32, 0x34, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x32, 0x30, 0x31, 0x30, 0x62, 0x64, 0x36, 0x36, 0x32, 0x64, 0x66, 0x34, 0x31, 0x37, 0x66, 0x32, 0x61, 0x32, 0x37, 0x31, 0x38, 0x37, 0x39, 0x61, 0x66, 0x62, 0x31, 0x33, 0x65, 0x66, 0x34, 0x63, 0x38, 0x38, 0x61, 0x33, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x38, 0x39, 0x36, 0x37, 0x39, 0x31, 0x38, 0x63, 0x64, 0x38, 0x39, 0x37, 0x64, 0x64, 0x30, 0x30, 0x30, 0x35, 0x65, 0x33, 0x36, 0x64, 0x63, 0x36, 0x63, 0x38, 0x38, 0x33, 0x65, 0x66, 0x34, 0x33, 0x38, 0x66, 0x63, 0x38, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x32, 0x32, 0x64, 0x65, 0x37, 0x65, 0x62, 0x36, 0x61, 0x65, 0x31, 0x32, 0x35, 0x30, 0x35, 0x32, 0x32, 0x61, 0x35, 0x31, 0x33, 0x31, 0x33, 0x33, 0x61, 0x39, 0x33, 0x62, 0x64, 0x34, 0x32, 0x38, 0x34, 0x39, 0x34, 0x37, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x65, 0x34, 0x34, 0x32, 0x63, 0x38, 0x32, 0x33, 0x38, 0x36, 0x31, 0x35, 0x34, 0x64, 0x32, 0x65, 0x39, 0x39, 0x33, 0x63, 0x62, 0x64, 0x31, 0x32, 0x38, 0x30, 0x62, 0x62, 0x37, 0x63, 0x61, 0x36, 0x62, 0x31, 0x32, 0x61, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x34, 0x32, 0x34, 0x62, 0x64, 0x38, 0x37, 0x38, 0x35, 0x62, 0x38, 0x63, 0x62, 0x34, 0x36, 0x31, 0x31, 0x30, 0x32, 0x61, 0x39, 0x30, 0x30, 0x32, 0x38, 0x33, 0x63, 0x33, 0x35, 0x64, 0x66, 0x61, 0x30, 0x37, 0x65, 0x66, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x32, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x62, 0x62, 0x65, 0x63, 0x35, 0x65, 0x37, 0x30, 0x62, 0x64, 0x65, 0x61, 0x64, 0x38, 0x62, 0x62, 0x33, 0x32, 0x62, 0x34, 0x32, 0x38, 0x30, 0x35, 0x39, 0x38, 0x38, 0x65, 0x39, 0x36, 0x34, 0x38, 0x63, 0x30, 0x61, 0x61, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x63, 0x30, 0x36, 0x66, 0x65, 0x32, 0x37, 0x62, 0x34, 0x34, 0x63, 0x37, 0x38, 0x34, 0x62, 0x32, 0x33, 0x39, 0x36, 0x65, 0x63, 0x39, 0x32, 0x66, 0x37, 0x62, 0x39, 0x32, 0x33, 0x61, 0x64, 0x31, 0x37, 0x65, 0x39, 0x30, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x64, 0x35, 0x35, 0x30, 0x34, 0x32, 0x37, 0x62, 0x35, 0x61, 0x35, 0x31, 0x34, 0x63, 0x37, 0x35, 0x31, 0x64, 0x37, 0x33, 0x61, 0x30, 0x66, 0x36, 0x64, 0x32, 0x39, 0x66, 0x62, 0x36, 0x35, 0x64, 0x32, 0x32, 0x65, 0x64, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x64, 0x65, 0x36, 0x30, 0x65, 0x62, 0x30, 0x38, 0x61, 0x30, 0x39, 0x39, 0x64, 0x37, 0x64, 0x61, 0x61, 0x33, 0x35, 0x36, 0x64, 0x61, 0x61, 0x61, 0x62, 0x32, 0x34, 0x37, 0x30, 0x64, 0x37, 0x62, 0x30, 0x32, 0x35, 0x61, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x62, 0x63, 0x63, 0x62, 0x66, 0x66, 0x38, 0x66, 0x34, 0x34, 0x33, 0x34, 0x37, 0x65, 0x62, 0x37, 0x66, 0x63, 0x61, 0x39, 0x35, 0x62, 0x32, 0x37, 0x63, 0x65, 0x37, 0x63, 0x39, 0x35, 0x32, 0x34, 0x39, 0x32, 0x61, 0x61, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x39, 0x35, 0x65, 0x30, 0x39, 0x36, 0x62, 0x30, 0x38, 0x61, 0x35, 0x61, 0x37, 0x32, 0x36, 0x38, 0x30, 0x30, 0x66, 0x63, 0x64, 0x31, 0x37, 0x64, 0x39, 0x63, 0x36, 0x34, 0x63, 0x36, 0x34, 0x65, 0x30, 0x38, 0x38, 0x64, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x65, 0x31, 0x33, 0x63, 0x30, 0x64, 0x34, 0x31, 0x32, 0x30, 0x30, 0x62, 0x34, 0x36, 0x64, 0x31, 0x39, 0x64, 0x65, 0x65, 0x35, 0x63, 0x34, 0x62, 0x63, 0x65, 0x63, 0x37, 0x31, 0x64, 0x38, 0x32, 0x62, 0x62, 0x38, 0x65, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x39, 0x33, 0x39, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x31, 0x34, 0x36, 0x31, 0x61, 0x33, 0x63, 0x66, 0x62, 0x64, 0x33, 0x32, 0x63, 0x39, 0x38, 0x36, 0x35, 0x35, 0x35, 0x35, 0x61, 0x34, 0x38, 0x31, 0x33, 0x31, 0x33, 0x37, 0x63, 0x30, 0x37, 0x36, 0x33, 0x31, 0x32, 0x33, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x30, 0x30, 0x66, 0x62, 0x31, 0x34, 0x39, 0x61, 0x64, 0x65, 0x64, 0x36, 0x35, 0x62, 0x63, 0x62, 0x61, 0x36, 0x63, 0x30, 0x34, 0x65, 0x39, 0x63, 0x64, 0x36, 0x62, 0x37, 0x61, 0x30, 0x33, 0x62, 0x38, 0x39, 0x33, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x66, 0x39, 0x32, 0x38, 0x36, 0x63, 0x30, 0x65, 0x37, 0x33, 0x38, 0x64, 0x31, 0x37, 0x32, 0x31, 0x61, 0x36, 0x39, 0x31, 0x63, 0x36, 0x62, 0x39, 0x35, 0x61, 0x62, 0x33, 0x64, 0x39, 0x61, 0x37, 0x39, 0x37, 0x65, 0x64, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x63, 0x38, 0x65, 0x35, 0x66, 0x31, 0x33, 0x33, 0x30, 0x66, 0x63, 0x62, 0x34, 0x62, 0x31, 0x34, 0x63, 0x61, 0x37, 0x35, 0x63, 0x62, 0x32, 0x35, 0x38, 0x30, 0x61, 0x34, 0x62, 0x39, 0x33, 0x64, 0x32, 0x30, 0x34, 0x65, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x35, 0x64, 0x66, 0x32, 0x32, 0x37, 0x62, 0x66, 0x61, 0x38, 0x35, 0x64, 0x37, 0x61, 0x64, 0x37, 0x36, 0x62, 0x34, 0x32, 0x36, 0x65, 0x31, 0x63, 0x65, 0x65, 0x39, 0x36, 0x33, 0x62, 0x63, 0x37, 0x66, 0x35, 0x31, 0x39, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x37, 0x35, 0x31, 0x30, 0x65, 0x33, 0x38, 0x36, 0x66, 0x35, 0x36, 0x33, 0x39, 0x33, 0x63, 0x65, 0x64, 0x38, 0x66, 0x34, 0x37, 0x37, 0x33, 0x37, 0x38, 0x61, 0x34, 0x34, 0x34, 0x63, 0x34, 0x38, 0x34, 0x66, 0x37, 0x64, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x39, 0x31, 0x65, 0x62, 0x35, 0x34, 0x37, 0x65, 0x37, 0x62, 0x66, 0x36, 0x39, 0x37, 0x36, 0x62, 0x39, 0x62, 0x31, 0x62, 0x35, 0x37, 0x37, 0x35, 0x34, 0x36, 0x37, 0x36, 0x31, 0x64, 0x65, 0x36, 0x35, 0x36, 0x32, 0x32, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x35, 0x61, 0x36, 0x66, 0x33, 0x36, 0x37, 0x37, 0x37, 0x66, 0x34, 0x30, 0x64, 0x36, 0x36, 0x31, 0x37, 0x65, 0x62, 0x35, 0x38, 0x31, 0x39, 0x38, 0x39, 0x36, 0x31, 0x38, 0x36, 0x39, 0x38, 0x33, 0x66, 0x64, 0x33, 0x37, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x35, 0x38, 0x30, 0x62, 0x37, 0x36, 0x36, 0x66, 0x37, 0x34, 0x35, 0x33, 0x35, 0x32, 0x35, 0x63, 0x61, 0x34, 0x63, 0x36, 0x61, 0x38, 0x38, 0x62, 0x30, 0x31, 0x62, 0x35, 0x30, 0x35, 0x37, 0x30, 0x65, 0x61, 0x30, 0x38, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x35, 0x64, 0x39, 0x36, 0x65, 0x61, 0x35, 0x37, 0x33, 0x65, 0x38, 0x64, 0x66, 0x37, 0x32, 0x36, 0x32, 0x62, 0x62, 0x66, 0x61, 0x35, 0x37, 0x32, 0x32, 0x32, 0x39, 0x62, 0x34, 0x62, 0x31, 0x36, 0x30, 0x31, 0x36, 0x62, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x65, 0x30, 0x39, 0x36, 0x34, 0x34, 0x30, 0x30, 0x63, 0x32, 0x38, 0x32, 0x62, 0x64, 0x64, 0x37, 0x38, 0x61, 0x39, 0x31, 0x39, 0x63, 0x36, 0x62, 0x66, 0x37, 0x37, 0x63, 0x36, 0x62, 0x35, 0x66, 0x37, 0x39, 0x36, 0x31, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x34, 0x65, 0x63, 0x36, 0x39, 0x61, 0x37, 0x34, 0x35, 0x34, 0x35, 0x37, 0x32, 0x31, 0x64, 0x37, 0x33, 0x31, 0x36, 0x61, 0x65, 0x66, 0x34, 0x64, 0x63, 0x66, 0x62, 0x34, 0x31, 0x61, 0x63, 0x35, 0x39, 0x65, 0x65, 0x32, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x32, 0x62, 0x33, 0x32, 0x36, 0x65, 0x37, 0x38, 0x65, 0x64, 0x31, 0x30, 0x65, 0x35, 0x35, 0x30, 0x66, 0x65, 0x65, 0x38, 0x65, 0x66, 0x61, 0x38, 0x66, 0x38, 0x30, 0x37, 0x30, 0x33, 0x39, 0x36, 0x35, 0x32, 0x32, 0x66, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x30, 0x38, 0x34, 0x31, 0x62, 0x39, 0x32, 0x61, 0x37, 0x66, 0x37, 0x30, 0x37, 0x35, 0x35, 0x36, 0x39, 0x64, 0x63, 0x34, 0x36, 0x32, 0x37, 0x65, 0x36, 0x62, 0x37, 0x36, 0x63, 0x61, 0x62, 0x30, 0x35, 0x61, 0x64, 0x65, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x61, 0x36, 0x31, 0x66, 0x31, 0x35, 0x32, 0x64, 0x65, 0x36, 0x31, 0x32, 0x33, 0x35, 0x31, 0x36, 0x63, 0x37, 0x35, 0x31, 0x32, 0x34, 0x32, 0x39, 0x37, 0x39, 0x32, 0x38, 0x35, 0x66, 0x37, 0x39, 0x36, 0x61, 0x63, 0x37, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x63, 0x38, 0x37, 0x39, 0x31, 0x64, 0x63, 0x33, 0x34, 0x32, 0x63, 0x33, 0x37, 0x33, 0x37, 0x36, 0x39, 0x65, 0x61, 0x36, 0x31, 0x66, 0x62, 0x37, 0x62, 0x35, 0x31, 0x30, 0x66, 0x32, 0x35, 0x31, 0x64, 0x33, 0x32, 0x30, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x36, 0x37, 0x63, 0x64, 0x34, 0x38, 0x65, 0x37, 0x33, 0x33, 0x34, 0x31, 0x38, 0x65, 0x38, 0x66, 0x39, 0x39, 0x66, 0x66, 0x64, 0x31, 0x33, 0x34, 0x31, 0x32, 0x31, 0x63, 0x34, 0x61, 0x34, 0x61, 0x62, 0x32, 0x37, 0x38, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x38, 0x61, 0x61, 0x61, 0x62, 0x61, 0x65, 0x39, 0x65, 0x64, 0x38, 0x33, 0x33, 0x64, 0x37, 0x62, 0x63, 0x32, 0x32, 0x32, 0x65, 0x39, 0x31, 0x66, 0x63, 0x61, 0x61, 0x30, 0x36, 0x34, 0x37, 0x62, 0x37, 0x37, 0x35, 0x38, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x39, 0x66, 0x33, 0x30, 0x31, 0x35, 0x38, 0x62, 0x35, 0x37, 0x34, 0x62, 0x39, 0x39, 0x39, 0x61, 0x61, 0x62, 0x33, 0x34, 0x38, 0x31, 0x30, 0x37, 0x62, 0x39, 0x65, 0x65, 0x64, 0x38, 0x35, 0x62, 0x31, 0x66, 0x66, 0x38, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x64, 0x30, 0x36, 0x31, 0x34, 0x39, 0x62, 0x32, 0x31, 0x63, 0x35, 0x35, 0x66, 0x66, 0x38, 0x36, 0x37, 0x63, 0x63, 0x33, 0x66, 0x62, 0x39, 0x37, 0x34, 0x30, 0x64, 0x32, 0x62, 0x63, 0x63, 0x37, 0x31, 0x30, 0x31, 0x32, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x33, 0x33, 0x38, 0x34, 0x33, 0x61, 0x37, 0x38, 0x64, 0x39, 0x33, 0x39, 0x63, 0x36, 0x39, 0x64, 0x34, 0x34, 0x38, 0x36, 0x65, 0x31, 0x30, 0x65, 0x62, 0x63, 0x37, 0x62, 0x36, 0x30, 0x32, 0x61, 0x33, 0x34, 0x39, 0x66, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x64, 0x66, 0x64, 0x61, 0x36, 0x63, 0x32, 0x31, 0x35, 0x37, 0x32, 0x30, 0x65, 0x64, 0x61, 0x32, 0x31, 0x33, 0x36, 0x66, 0x39, 0x31, 0x30, 0x35, 0x32, 0x33, 0x32, 0x31, 0x61, 0x66, 0x34, 0x65, 0x39, 0x33, 0x36, 0x63, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x31, 0x63, 0x35, 0x33, 0x33, 0x30, 0x30, 0x65, 0x34, 0x63, 0x31, 0x36, 0x38, 0x39, 0x31, 0x32, 0x31, 0x36, 0x33, 0x63, 0x37, 0x65, 0x39, 0x39, 0x62, 0x39, 0x35, 0x64, 0x61, 0x32, 0x36, 0x38, 0x61, 0x64, 0x32, 0x38, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x37, 0x65, 0x62, 0x62, 0x63, 0x37, 0x66, 0x34, 0x64, 0x61, 0x34, 0x31, 0x36, 0x65, 0x34, 0x32, 0x63, 0x38, 0x64, 0x34, 0x66, 0x38, 0x34, 0x32, 0x61, 0x62, 0x61, 0x31, 0x36, 0x32, 0x33, 0x33, 0x63, 0x31, 0x32, 0x35, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x63, 0x38, 0x39, 0x32, 0x32, 0x63, 0x34, 0x61, 0x63, 0x63, 0x37, 0x64, 0x32, 0x63, 0x62, 0x36, 0x66, 0x64, 0x35, 0x39, 0x61, 0x31, 0x34, 0x65, 0x62, 0x34, 0x35, 0x63, 0x66, 0x33, 0x65, 0x37, 0x30, 0x32, 0x32, 0x31, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x36, 0x63, 0x32, 0x38, 0x34, 0x61, 0x61, 0x63, 0x38, 0x61, 0x36, 0x39, 0x62, 0x37, 0x35, 0x63, 0x64, 0x64, 0x62, 0x30, 0x30, 0x66, 0x32, 0x38, 0x65, 0x31, 0x34, 0x35, 0x35, 0x38, 0x33, 0x62, 0x35, 0x36, 0x62, 0x65, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x37, 0x32, 0x65, 0x65, 0x35, 0x35, 0x30, 0x38, 0x62, 0x66, 0x38, 0x31, 0x36, 0x33, 0x65, 0x64, 0x32, 0x38, 0x34, 0x65, 0x35, 0x65, 0x65, 0x66, 0x39, 0x34, 0x63, 0x65, 0x34, 0x64, 0x37, 0x33, 0x36, 0x37, 0x65, 0x35, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x31, 0x32, 0x35, 0x62, 0x35, 0x39, 0x61, 0x63, 0x35, 0x31, 0x63, 0x65, 0x65, 0x30, 0x32, 0x39, 0x65, 0x34, 0x62, 0x64, 0x37, 0x38, 0x64, 0x37, 0x66, 0x35, 0x39, 0x34, 0x37, 0x64, 0x31, 0x65, 0x61, 0x34, 0x39, 0x62, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x38, 0x63, 0x61, 0x31, 0x65, 0x36, 0x65, 0x35, 0x66, 0x34, 0x64, 0x35, 0x35, 0x38, 0x64, 0x31, 0x33, 0x37, 0x38, 0x30, 0x66, 0x34, 0x38, 0x38, 0x66, 0x31, 0x30, 0x64, 0x34, 0x61, 0x64, 0x33, 0x31, 0x33, 0x30, 0x64, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x32, 0x35, 0x66, 0x64, 0x35, 0x61, 0x62, 0x62, 0x37, 0x39, 0x32, 0x36, 0x61, 0x36, 0x37, 0x63, 0x66, 0x33, 0x36, 0x62, 0x61, 0x32, 0x34, 0x36, 0x61, 0x32, 0x34, 0x62, 0x64, 0x32, 0x37, 0x62, 0x65, 0x36, 0x66, 0x36, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x32, 0x34, 0x31, 0x62, 0x34, 0x31, 0x65, 0x63, 0x62, 0x64, 0x30, 0x62, 0x66, 0x64, 0x66, 0x31, 0x32, 0x39, 0x35, 0x65, 0x39, 0x64, 0x34, 0x66, 0x61, 0x35, 0x39, 0x65, 0x61, 0x30, 0x39, 0x65, 0x36, 0x63, 0x36, 0x31, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x65, 0x34, 0x64, 0x31, 0x35, 0x32, 0x31, 0x39, 0x31, 0x38, 0x32, 0x66, 0x61, 0x66, 0x33, 0x61, 0x61, 0x32, 0x63, 0x35, 0x64, 0x34, 0x64, 0x32, 0x35, 0x39, 0x35, 0x66, 0x66, 0x32, 0x33, 0x30, 0x39, 0x31, 0x61, 0x37, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x30, 0x33, 0x64, 0x32, 0x39, 0x65, 0x36, 0x63, 0x35, 0x36, 0x62, 0x39, 0x32, 0x36, 0x39, 0x39, 0x63, 0x34, 0x62, 0x39, 0x32, 0x64, 0x31, 0x66, 0x36, 0x66, 0x38, 0x34, 0x36, 0x34, 0x38, 0x64, 0x63, 0x34, 0x63, 0x66, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x62, 0x34, 0x32, 0x64, 0x65, 0x31, 0x37, 0x30, 0x64, 0x62, 0x64, 0x37, 0x32, 0x33, 0x66, 0x34, 0x35, 0x34, 0x65, 0x38, 0x38, 0x66, 0x37, 0x37, 0x31, 0x36, 0x34, 0x35, 0x32, 0x64, 0x39, 0x32, 0x39, 0x38, 0x35, 0x30, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x35, 0x62, 0x37, 0x39, 0x64, 0x38, 0x66, 0x32, 0x33, 0x62, 0x36, 0x34, 0x38, 0x33, 0x64, 0x62, 0x65, 0x32, 0x62, 0x64, 0x61, 0x61, 0x36, 0x32, 0x62, 0x31, 0x30, 0x36, 0x34, 0x63, 0x63, 0x37, 0x36, 0x33, 0x36, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x30, 0x33, 0x34, 0x65, 0x38, 0x35, 0x38, 0x31, 0x64, 0x39, 0x34, 0x38, 0x34, 0x65, 0x38, 0x61, 0x66, 0x34, 0x32, 0x61, 0x32, 0x38, 0x64, 0x66, 0x31, 0x39, 0x30, 0x31, 0x33, 0x32, 0x65, 0x63, 0x32, 0x39, 0x63, 0x34, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x65, 0x36, 0x30, 0x34, 0x63, 0x37, 0x61, 0x39, 0x64, 0x63, 0x32, 0x39, 0x30, 0x39, 0x63, 0x65, 0x33, 0x32, 0x31, 0x64, 0x65, 0x36, 0x62, 0x39, 0x62, 0x32, 0x34, 0x66, 0x35, 0x37, 0x36, 0x37, 0x35, 0x37, 0x37, 0x35, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x33, 0x33, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x38, 0x37, 0x63, 0x65, 0x34, 0x65, 0x39, 0x36, 0x31, 0x61, 0x37, 0x38, 0x34, 0x37, 0x66, 0x35, 0x36, 0x30, 0x30, 0x37, 0x35, 0x63, 0x36, 0x34, 0x65, 0x31, 0x35, 0x39, 0x36, 0x62, 0x35, 0x36, 0x34, 0x31, 0x64, 0x32, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x63, 0x39, 0x64, 0x34, 0x61, 0x34, 0x32, 0x36, 0x32, 0x65, 0x37, 0x61, 0x30, 0x32, 0x37, 0x61, 0x62, 0x37, 0x35, 0x31, 0x39, 0x31, 0x31, 0x30, 0x64, 0x38, 0x30, 0x32, 0x63, 0x34, 0x39, 0x35, 0x63, 0x65, 0x65, 0x61, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x38, 0x61, 0x32, 0x63, 0x61, 0x35, 0x61, 0x38, 0x31, 0x33, 0x33, 0x33, 0x66, 0x31, 0x39, 0x39, 0x39, 0x38, 0x32, 0x35, 0x35, 0x66, 0x32, 0x30, 0x33, 0x32, 0x35, 0x36, 0x65, 0x31, 0x61, 0x38, 0x31, 0x39, 0x63, 0x30, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x38, 0x31, 0x31, 0x66, 0x61, 0x31, 0x39, 0x64, 0x61, 0x64, 0x62, 0x66, 0x30, 0x32, 0x39, 0x66, 0x38, 0x62, 0x66, 0x65, 0x35, 0x36, 0x39, 0x61, 0x64, 0x62, 0x31, 0x38, 0x32, 0x32, 0x38, 0x63, 0x38, 0x30, 0x34, 0x38, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x31, 0x66, 0x32, 0x61, 0x35, 0x37, 0x37, 0x31, 0x33, 0x65, 0x62, 0x63, 0x36, 0x65, 0x39, 0x34, 0x64, 0x65, 0x32, 0x39, 0x38, 0x34, 0x36, 0x65, 0x38, 0x38, 0x34, 0x34, 0x64, 0x33, 0x37, 0x36, 0x36, 0x36, 0x35, 0x37, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x62, 0x30, 0x62, 0x64, 0x31, 0x34, 0x38, 0x33, 0x30, 0x39, 0x31, 0x38, 0x36, 0x63, 0x66, 0x38, 0x63, 0x62, 0x64, 0x31, 0x33, 0x62, 0x37, 0x32, 0x33, 0x32, 0x64, 0x38, 0x30, 0x39, 0x35, 0x61, 0x63, 0x62, 0x38, 0x33, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x39, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x39, 0x32, 0x38, 0x62, 0x35, 0x35, 0x62, 0x63, 0x38, 0x36, 0x31, 0x35, 0x30, 0x39, 0x64, 0x35, 0x31, 0x63, 0x38, 0x63, 0x66, 0x31, 0x64, 0x35, 0x34, 0x36, 0x62, 0x66, 0x65, 0x63, 0x36, 0x65, 0x33, 0x65, 0x39, 0x30, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x34, 0x38, 0x30, 0x31, 0x36, 0x34, 0x62, 0x63, 0x64, 0x38, 0x34, 0x39, 0x37, 0x34, 0x65, 0x62, 0x63, 0x30, 0x64, 0x39, 0x30, 0x63, 0x39, 0x62, 0x39, 0x61, 0x66, 0x61, 0x62, 0x36, 0x32, 0x36, 0x63, 0x64, 0x31, 0x63, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x33, 0x33, 0x39, 0x66, 0x38, 0x34, 0x61, 0x35, 0x63, 0x32, 0x62, 0x34, 0x34, 0x63, 0x65, 0x35, 0x33, 0x64, 0x66, 0x64, 0x62, 0x36, 0x64, 0x34, 0x66, 0x39, 0x37, 0x64, 0x66, 0x37, 0x38, 0x32, 0x31, 0x32, 0x61, 0x37, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x65, 0x61, 0x63, 0x61, 0x61, 0x65, 0x64, 0x35, 0x37, 0x32, 0x38, 0x35, 0x65, 0x30, 0x61, 0x63, 0x37, 0x32, 0x36, 0x38, 0x63, 0x65, 0x36, 0x61, 0x34, 0x65, 0x33, 0x35, 0x65, 0x63, 0x66, 0x64, 0x62, 0x32, 0x34, 0x32, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x32, 0x64, 0x64, 0x38, 0x63, 0x64, 0x33, 0x66, 0x65, 0x33, 0x39, 0x39, 0x64, 0x31, 0x64, 0x30, 0x65, 0x63, 0x32, 0x38, 0x31, 0x32, 0x33, 0x31, 0x62, 0x37, 0x63, 0x65, 0x66, 0x63, 0x32, 0x30, 0x62, 0x39, 0x65, 0x34, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x64, 0x65, 0x64, 0x30, 0x34, 0x39, 0x61, 0x36, 0x65, 0x31, 0x66, 0x33, 0x32, 0x39, 0x64, 0x63, 0x34, 0x62, 0x39, 0x37, 0x31, 0x65, 0x37, 0x32, 0x32, 0x63, 0x39, 0x63, 0x31, 0x66, 0x32, 0x61, 0x64, 0x65, 0x38, 0x33, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x35, 0x36, 0x65, 0x31, 0x37, 0x36, 0x63, 0x39, 0x65, 0x66, 0x36, 0x39, 0x33, 0x65, 0x65, 0x31, 0x65, 0x65, 0x63, 0x36, 0x62, 0x39, 0x66, 0x38, 0x62, 0x31, 0x35, 0x31, 0x64, 0x33, 0x31, 0x33, 0x62, 0x65, 0x62, 0x30, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x65, 0x36, 0x34, 0x31, 0x35, 0x64, 0x35, 0x38, 0x37, 0x62, 0x30, 0x36, 0x35, 0x34, 0x39, 0x30, 0x66, 0x31, 0x65, 0x64, 0x37, 0x66, 0x32, 0x31, 0x64, 0x36, 0x65, 0x30, 0x66, 0x33, 0x38, 0x36, 0x65, 0x65, 0x36, 0x37, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x34, 0x31, 0x33, 0x35, 0x37, 0x36, 0x38, 0x36, 0x39, 0x63, 0x30, 0x38, 0x66, 0x39, 0x35, 0x31, 0x32, 0x61, 0x64, 0x33, 0x31, 0x31, 0x66, 0x65, 0x39, 0x32, 0x35, 0x39, 0x38, 0x38, 0x61, 0x35, 0x32, 0x64, 0x33, 0x34, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x39, 0x66, 0x35, 0x35, 0x34, 0x36, 0x30, 0x39, 0x34, 0x36, 0x64, 0x37, 0x62, 0x66, 0x62, 0x35, 0x37, 0x30, 0x64, 0x64, 0x65, 0x63, 0x37, 0x35, 0x37, 0x63, 0x61, 0x35, 0x37, 0x37, 0x33, 0x62, 0x35, 0x38, 0x34, 0x32, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x38, 0x30, 0x62, 0x38, 0x33, 0x65, 0x65, 0x35, 0x35, 0x37, 0x34, 0x33, 0x31, 0x37, 0x66, 0x32, 0x31, 0x63, 0x38, 0x30, 0x37, 0x32, 0x62, 0x31, 0x39, 0x31, 0x64, 0x38, 0x39, 0x35, 0x64, 0x34, 0x36, 0x31, 0x35, 0x33, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x63, 0x61, 0x39, 0x61, 0x35, 0x36, 0x32, 0x36, 0x39, 0x31, 0x33, 0x62, 0x30, 0x38, 0x63, 0x66, 0x63, 0x39, 0x61, 0x36, 0x36, 0x64, 0x34, 0x30, 0x35, 0x30, 0x38, 0x64, 0x63, 0x65, 0x35, 0x32, 0x62, 0x36, 0x30, 0x66, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x64, 0x30, 0x65, 0x34, 0x37, 0x35, 0x62, 0x35, 0x34, 0x34, 0x32, 0x31, 0x62, 0x64, 0x66, 0x63, 0x30, 0x63, 0x31, 0x32, 0x65, 0x61, 0x38, 0x65, 0x30, 0x38, 0x32, 0x62, 0x64, 0x37, 0x61, 0x35, 0x61, 0x66, 0x30, 0x61, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x64, 0x62, 0x30, 0x32, 0x63, 0x36, 0x31, 0x61, 0x32, 0x32, 0x37, 0x32, 0x38, 0x37, 0x36, 0x31, 0x31, 0x61, 0x64, 0x39, 0x35, 0x30, 0x36, 0x39, 0x36, 0x33, 0x36, 0x39, 0x63, 0x63, 0x34, 0x65, 0x36, 0x34, 0x37, 0x61, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x36, 0x37, 0x36, 0x38, 0x34, 0x31, 0x65, 0x65, 0x39, 0x66, 0x32, 0x64, 0x33, 0x31, 0x63, 0x31, 0x37, 0x32, 0x65, 0x38, 0x32, 0x33, 0x30, 0x33, 0x62, 0x30, 0x66, 0x65, 0x39, 0x62, 0x62, 0x66, 0x39, 0x66, 0x31, 0x65, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x32, 0x32, 0x32, 0x32, 0x35, 0x39, 0x64, 0x64, 0x39, 0x63, 0x33, 0x65, 0x33, 0x64, 0x65, 0x64, 0x31, 0x32, 0x37, 0x30, 0x38, 0x34, 0x66, 0x38, 0x30, 0x38, 0x65, 0x39, 0x32, 0x61, 0x31, 0x38, 0x38, 0x37, 0x33, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x33, 0x61, 0x37, 0x63, 0x63, 0x33, 0x61, 0x37, 0x64, 0x37, 0x62, 0x30, 0x30, 0x65, 0x64, 0x35, 0x32, 0x38, 0x32, 0x32, 0x32, 0x31, 0x61, 0x36, 0x30, 0x32, 0x35, 0x39, 0x66, 0x32, 0x35, 0x62, 0x66, 0x36, 0x35, 0x33, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x33, 0x66, 0x66, 0x39, 0x38, 0x37, 0x35, 0x34, 0x31, 0x64, 0x64, 0x65, 0x35, 0x63, 0x64, 0x65, 0x65, 0x30, 0x61, 0x38, 0x61, 0x39, 0x36, 0x64, 0x63, 0x63, 0x33, 0x66, 0x33, 0x33, 0x63, 0x33, 0x66, 0x32, 0x34, 0x63, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x31, 0x61, 0x34, 0x38, 0x32, 0x38, 0x31, 0x31, 0x39, 0x62, 0x65, 0x33, 0x30, 0x39, 0x62, 0x64, 0x38, 0x38, 0x32, 0x33, 0x36, 0x65, 0x34, 0x64, 0x34, 0x38, 0x32, 0x62, 0x35, 0x30, 0x34, 0x64, 0x63, 0x35, 0x35, 0x37, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x31, 0x38, 0x31, 0x31, 0x63, 0x33, 0x30, 0x35, 0x31, 0x66, 0x34, 0x36, 0x65, 0x36, 0x36, 0x34, 0x61, 0x65, 0x34, 0x62, 0x63, 0x39, 0x63, 0x38, 0x32, 0x34, 0x64, 0x31, 0x38, 0x35, 0x39, 0x32, 0x63, 0x34, 0x35, 0x37, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x66, 0x65, 0x30, 0x30, 0x36, 0x39, 0x36, 0x64, 0x62, 0x64, 0x38, 0x37, 0x62, 0x37, 0x39, 0x37, 0x36, 0x62, 0x32, 0x39, 0x64, 0x31, 0x31, 0x35, 0x36, 0x63, 0x38, 0x38, 0x34, 0x32, 0x61, 0x32, 0x65, 0x31, 0x37, 0x39, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x30, 0x31, 0x30, 0x65, 0x66, 0x33, 0x62, 0x38, 0x65, 0x39, 0x35, 0x65, 0x33, 0x66, 0x33, 0x30, 0x38, 0x66, 0x33, 0x30, 0x61, 0x38, 0x63, 0x62, 0x37, 0x66, 0x34, 0x65, 0x62, 0x34, 0x62, 0x66, 0x36, 0x30, 0x64, 0x39, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x30, 0x33, 0x30, 0x30, 0x63, 0x62, 0x31, 0x64, 0x34, 0x30, 0x37, 0x37, 0x65, 0x36, 0x61, 0x36, 0x64, 0x37, 0x65, 0x31, 0x36, 0x39, 0x61, 0x34, 0x36, 0x30, 0x34, 0x36, 0x38, 0x63, 0x66, 0x34, 0x61, 0x34, 0x39, 0x32, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x65, 0x64, 0x66, 0x36, 0x32, 0x65, 0x37, 0x34, 0x33, 0x66, 0x34, 0x64, 0x32, 0x63, 0x32, 0x61, 0x34, 0x62, 0x38, 0x37, 0x61, 0x37, 0x38, 0x37, 0x66, 0x35, 0x34, 0x32, 0x34, 0x61, 0x37, 0x61, 0x65, 0x62, 0x33, 0x39, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x37, 0x34, 0x34, 0x62, 0x39, 0x35, 0x31, 0x64, 0x30, 0x39, 0x34, 0x62, 0x33, 0x31, 0x30, 0x32, 0x36, 0x32, 0x63, 0x38, 0x66, 0x39, 0x38, 0x36, 0x63, 0x38, 0x36, 0x30, 0x64, 0x66, 0x39, 0x61, 0x62, 0x31, 0x64, 0x65, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x33, 0x61, 0x63, 0x36, 0x35, 0x31, 0x38, 0x33, 0x36, 0x35, 0x31, 0x38, 0x30, 0x30, 0x65, 0x32, 0x33, 0x35, 0x38, 0x30, 0x66, 0x38, 0x66, 0x30, 0x65, 0x61, 0x64, 0x33, 0x62, 0x62, 0x35, 0x39, 0x37, 0x65, 0x62, 0x38, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x30, 0x35, 0x66, 0x66, 0x35, 0x65, 0x63, 0x66, 0x30, 0x64, 0x66, 0x32, 0x64, 0x66, 0x38, 0x38, 0x37, 0x37, 0x35, 0x39, 0x66, 0x62, 0x38, 0x32, 0x37, 0x34, 0x64, 0x39, 0x33, 0x32, 0x33, 0x38, 0x61, 0x63, 0x32, 0x36, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x30, 0x65, 0x37, 0x31, 0x32, 0x66, 0x34, 0x30, 0x35, 0x63, 0x35, 0x39, 0x37, 0x32, 0x35, 0x66, 0x65, 0x38, 0x32, 0x39, 0x65, 0x39, 0x37, 0x37, 0x34, 0x62, 0x66, 0x34, 0x64, 0x66, 0x37, 0x66, 0x34, 0x64, 0x64, 0x39, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x34, 0x31, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x34, 0x34, 0x66, 0x66, 0x36, 0x37, 0x34, 0x36, 0x34, 0x31, 0x32, 0x31, 0x65, 0x33, 0x35, 0x61, 0x66, 0x63, 0x32, 0x39, 0x32, 0x32, 0x31, 0x37, 0x37, 0x31, 0x36, 0x34, 0x66, 0x61, 0x32, 0x66, 0x63, 0x62, 0x30, 0x32, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x39, 0x63, 0x62, 0x32, 0x65, 0x36, 0x30, 0x38, 0x32, 0x64, 0x36, 0x39, 0x33, 0x61, 0x31, 0x33, 0x65, 0x38, 0x64, 0x32, 0x66, 0x36, 0x38, 0x64, 0x64, 0x31, 0x64, 0x64, 0x38, 0x34, 0x36, 0x31, 0x66, 0x35, 0x35, 0x38, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x31, 0x37, 0x31, 0x65, 0x35, 0x33, 0x64, 0x31, 0x37, 0x61, 0x63, 0x39, 0x62, 0x36, 0x31, 0x32, 0x34, 0x31, 0x61, 0x65, 0x34, 0x33, 0x36, 0x64, 0x65, 0x65, 0x63, 0x37, 0x61, 0x66, 0x34, 0x35, 0x32, 0x65, 0x37, 0x34, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x66, 0x61, 0x32, 0x32, 0x63, 0x63, 0x36, 0x64, 0x33, 0x33, 0x32, 0x30, 0x36, 0x62, 0x37, 0x64, 0x37, 0x30, 0x31, 0x61, 0x31, 0x36, 0x33, 0x61, 0x30, 0x64, 0x61, 0x62, 0x33, 0x31, 0x61, 0x65, 0x34, 0x64, 0x33, 0x31, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x61, 0x38, 0x30, 0x33, 0x30, 0x37, 0x36, 0x39, 0x38, 0x34, 0x34, 0x62, 0x63, 0x33, 0x34, 0x31, 0x38, 0x36, 0x62, 0x38, 0x35, 0x63, 0x64, 0x34, 0x63, 0x37, 0x33, 0x34, 0x38, 0x38, 0x34, 0x39, 0x66, 0x66, 0x34, 0x39, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x36, 0x31, 0x36, 0x62, 0x34, 0x65, 0x63, 0x30, 0x39, 0x31, 0x32, 0x38, 0x63, 0x64, 0x66, 0x66, 0x33, 0x39, 0x64, 0x36, 0x65, 0x34, 0x62, 0x39, 0x61, 0x63, 0x38, 0x36, 0x65, 0x65, 0x63, 0x34, 0x37, 0x31, 0x64, 0x35, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x37, 0x32, 0x39, 0x35, 0x65, 0x62, 0x64, 0x39, 0x34, 0x62, 0x34, 0x38, 0x32, 0x36, 0x39, 0x63, 0x32, 0x64, 0x35, 0x36, 0x39, 0x63, 0x39, 0x62, 0x39, 0x61, 0x66, 0x39, 0x61, 0x61, 0x30, 0x35, 0x65, 0x38, 0x33, 0x65, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x35, 0x64, 0x35, 0x64, 0x61, 0x61, 0x31, 0x33, 0x38, 0x64, 0x64, 0x31, 0x64, 0x33, 0x37, 0x34, 0x63, 0x37, 0x31, 0x62, 0x39, 0x30, 0x31, 0x39, 0x39, 0x31, 0x36, 0x38, 0x31, 0x31, 0x66, 0x34, 0x62, 0x32, 0x30, 0x61, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x63, 0x36, 0x65, 0x64, 0x63, 0x35, 0x31, 0x35, 0x64, 0x33, 0x35, 0x35, 0x35, 0x37, 0x38, 0x30, 0x38, 0x64, 0x31, 0x33, 0x63, 0x64, 0x34, 0x34, 0x64, 0x63, 0x63, 0x34, 0x34, 0x30, 0x30, 0x62, 0x32, 0x35, 0x30, 0x34, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x38, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x63, 0x39, 0x35, 0x63, 0x62, 0x33, 0x32, 0x64, 0x62, 0x62, 0x35, 0x37, 0x34, 0x63, 0x38, 0x33, 0x32, 0x66, 0x61, 0x38, 0x31, 0x37, 0x34, 0x61, 0x38, 0x31, 0x33, 0x35, 0x36, 0x64, 0x33, 0x38, 0x62, 0x63, 0x39, 0x32, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x36, 0x30, 0x37, 0x31, 0x62, 0x63, 0x65, 0x62, 0x66, 0x63, 0x62, 0x61, 0x34, 0x61, 0x62, 0x35, 0x37, 0x66, 0x34, 0x64, 0x62, 0x39, 0x36, 0x66, 0x63, 0x37, 0x61, 0x36, 0x38, 0x62, 0x65, 0x63, 0x65, 0x32, 0x62, 0x61, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x63, 0x39, 0x33, 0x65, 0x30, 0x33, 0x61, 0x39, 0x62, 0x32, 0x65, 0x38, 0x65, 0x34, 0x63, 0x33, 0x36, 0x37, 0x32, 0x38, 0x33, 0x35, 0x61, 0x39, 0x65, 0x65, 0x37, 0x36, 0x66, 0x39, 0x36, 0x31, 0x35, 0x62, 0x63, 0x31, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x30, 0x33, 0x62, 0x62, 0x63, 0x30, 0x32, 0x33, 0x65, 0x31, 0x65, 0x39, 0x33, 0x66, 0x61, 0x33, 0x61, 0x33, 0x61, 0x36, 0x65, 0x34, 0x32, 0x38, 0x63, 0x66, 0x30, 0x63, 0x64, 0x38, 0x66, 0x39, 0x35, 0x65, 0x31, 0x65, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x31, 0x35, 0x33, 0x31, 0x66, 0x62, 0x39, 0x65, 0x37, 0x39, 0x31, 0x38, 0x39, 0x36, 0x62, 0x63, 0x66, 0x33, 0x61, 0x38, 0x30, 0x35, 0x35, 0x38, 0x61, 0x33, 0x35, 0x39, 0x66, 0x36, 0x65, 0x37, 0x63, 0x31, 0x34, 0x34, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x35, 0x36, 0x61, 0x36, 0x35, 0x64, 0x63, 0x34, 0x61, 0x62, 0x62, 0x37, 0x32, 0x66, 0x31, 0x31, 0x62, 0x61, 0x65, 0x33, 0x32, 0x62, 0x36, 0x66, 0x62, 0x62, 0x30, 0x37, 0x34, 0x34, 0x34, 0x37, 0x39, 0x31, 0x64, 0x35, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x33, 0x37, 0x61, 0x63, 0x62, 0x65, 0x30, 0x66, 0x36, 0x32, 0x32, 0x37, 0x62, 0x30, 0x65, 0x33, 0x36, 0x66, 0x33, 0x36, 0x65, 0x34, 0x62, 0x63, 0x66, 0x37, 0x63, 0x66, 0x36, 0x31, 0x33, 0x33, 0x33, 0x35, 0x66, 0x62, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x64, 0x34, 0x61, 0x39, 0x33, 0x31, 0x34, 0x30, 0x32, 0x63, 0x30, 0x63, 0x37, 0x39, 0x63, 0x34, 0x35, 0x37, 0x31, 0x38, 0x36, 0x66, 0x32, 0x34, 0x64, 0x66, 0x38, 0x37, 0x32, 0x39, 0x63, 0x66, 0x39, 0x35, 0x37, 0x30, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x32, 0x62, 0x32, 0x30, 0x63, 0x37, 0x37, 0x38, 0x39, 0x34, 0x34, 0x36, 0x33, 0x62, 0x61, 0x66, 0x37, 0x37, 0x34, 0x63, 0x63, 0x32, 0x35, 0x36, 0x64, 0x35, 0x62, 0x64, 0x64, 0x62, 0x62, 0x66, 0x37, 0x64, 0x64, 0x64, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x61, 0x34, 0x30, 0x36, 0x37, 0x64, 0x34, 0x34, 0x38, 0x63, 0x63, 0x32, 0x35, 0x64, 0x63, 0x38, 0x65, 0x37, 0x30, 0x65, 0x36, 0x35, 0x31, 0x63, 0x65, 0x61, 0x37, 0x63, 0x66, 0x38, 0x34, 0x65, 0x39, 0x32, 0x31, 0x30, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x33, 0x39, 0x32, 0x35, 0x64, 0x63, 0x32, 0x32, 0x30, 0x62, 0x62, 0x34, 0x61, 0x65, 0x32, 0x31, 0x37, 0x37, 0x62, 0x32, 0x38, 0x38, 0x33, 0x30, 0x37, 0x38, 0x62, 0x36, 0x64, 0x63, 0x33, 0x34, 0x36, 0x63, 0x61, 0x31, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x35, 0x37, 0x61, 0x61, 0x39, 0x64, 0x30, 0x30, 0x64, 0x31, 0x30, 0x63, 0x34, 0x33, 0x39, 0x62, 0x33, 0x35, 0x65, 0x66, 0x63, 0x63, 0x30, 0x62, 0x65, 0x63, 0x61, 0x63, 0x32, 0x65, 0x33, 0x39, 0x35, 0x35, 0x63, 0x33, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x33, 0x64, 0x34, 0x37, 0x61, 0x38, 0x63, 0x61, 0x38, 0x38, 0x35, 0x64, 0x35, 0x34, 0x30, 0x63, 0x34, 0x65, 0x35, 0x32, 0x36, 0x66, 0x32, 0x35, 0x64, 0x35, 0x63, 0x36, 0x66, 0x32, 0x63, 0x31, 0x30, 0x38, 0x63, 0x34, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x32, 0x63, 0x65, 0x37, 0x38, 0x32, 0x35, 0x30, 0x36, 0x32, 0x32, 0x35, 0x66, 0x64, 0x39, 0x38, 0x36, 0x30, 0x61, 0x32, 0x65, 0x64, 0x63, 0x31, 0x34, 0x61, 0x37, 0x61, 0x33, 0x30, 0x34, 0x37, 0x37, 0x33, 0x36, 0x64, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x61, 0x36, 0x34, 0x35, 0x65, 0x30, 0x36, 0x36, 0x37, 0x64, 0x66, 0x64, 0x37, 0x62, 0x33, 0x32, 0x64, 0x30, 0x37, 0x35, 0x63, 0x63, 0x32, 0x34, 0x36, 0x37, 0x64, 0x64, 0x38, 0x63, 0x36, 0x38, 0x30, 0x39, 0x30, 0x37, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x39, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x32, 0x65, 0x37, 0x33, 0x34, 0x30, 0x34, 0x32, 0x61, 0x33, 0x35, 0x35, 0x64, 0x30, 0x35, 0x66, 0x66, 0x62, 0x32, 0x65, 0x33, 0x39, 0x31, 0x35, 0x62, 0x31, 0x36, 0x38, 0x31, 0x31, 0x66, 0x34, 0x35, 0x61, 0x36, 0x39, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x62, 0x31, 0x63, 0x34, 0x37, 0x31, 0x61, 0x65, 0x39, 0x34, 0x65, 0x31, 0x32, 0x31, 0x36, 0x34, 0x34, 0x35, 0x32, 0x65, 0x38, 0x31, 0x31, 0x66, 0x62, 0x62, 0x65, 0x32, 0x62, 0x33, 0x63, 0x64, 0x37, 0x32, 0x37, 0x35, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x61, 0x64, 0x33, 0x64, 0x64, 0x37, 0x34, 0x65, 0x32, 0x63, 0x31, 0x66, 0x37, 0x39, 0x36, 0x61, 0x63, 0x36, 0x34, 0x30, 0x64, 0x65, 0x35, 0x36, 0x64, 0x63, 0x39, 0x39, 0x62, 0x34, 0x63, 0x37, 0x39, 0x32, 0x61, 0x34, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x39, 0x64, 0x37, 0x63, 0x64, 0x31, 0x37, 0x64, 0x34, 0x38, 0x34, 0x32, 0x66, 0x65, 0x30, 0x33, 0x66, 0x36, 0x32, 0x61, 0x39, 0x30, 0x62, 0x32, 0x66, 0x62, 0x66, 0x38, 0x66, 0x36, 0x61, 0x66, 0x37, 0x62, 0x62, 0x33, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x30, 0x31, 0x62, 0x65, 0x66, 0x37, 0x37, 0x62, 0x36, 0x36, 0x66, 0x35, 0x31, 0x65, 0x31, 0x35, 0x39, 0x39, 0x62, 0x30, 0x32, 0x66, 0x62, 0x31, 0x31, 0x30, 0x31, 0x39, 0x34, 0x61, 0x30, 0x30, 0x39, 0x39, 0x62, 0x37, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x65, 0x37, 0x36, 0x31, 0x36, 0x34, 0x32, 0x34, 0x63, 0x64, 0x30, 0x39, 0x36, 0x31, 0x61, 0x37, 0x31, 0x37, 0x32, 0x37, 0x32, 0x34, 0x37, 0x34, 0x33, 0x37, 0x66, 0x30, 0x30, 0x36, 0x39, 0x32, 0x37, 0x32, 0x32, 0x38, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x34, 0x66, 0x34, 0x62, 0x64, 0x34, 0x30, 0x34, 0x39, 0x66, 0x30, 0x34, 0x34, 0x36, 0x38, 0x35, 0x62, 0x38, 0x38, 0x33, 0x62, 0x36, 0x32, 0x39, 0x35, 0x39, 0x61, 0x65, 0x36, 0x33, 0x31, 0x64, 0x36, 0x36, 0x37, 0x65, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x65, 0x30, 0x31, 0x34, 0x37, 0x65, 0x63, 0x30, 0x33, 0x32, 0x63, 0x33, 0x36, 0x31, 0x38, 0x33, 0x31, 0x30, 0x63, 0x31, 0x66, 0x66, 0x32, 0x35, 0x36, 0x39, 0x30, 0x62, 0x66, 0x31, 0x37, 0x32, 0x31, 0x39, 0x33, 0x64, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x37, 0x31, 0x39, 0x63, 0x30, 0x36, 0x38, 0x32, 0x62, 0x32, 0x61, 0x63, 0x37, 0x66, 0x39, 0x65, 0x32, 0x37, 0x61, 0x62, 0x65, 0x62, 0x65, 0x63, 0x37, 0x65, 0x64, 0x66, 0x38, 0x64, 0x65, 0x63, 0x66, 0x30, 0x61, 0x65, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x32, 0x37, 0x32, 0x62, 0x38, 0x66, 0x36, 0x32, 0x65, 0x39, 0x66, 0x39, 0x66, 0x61, 0x38, 0x63, 0x65, 0x30, 0x34, 0x34, 0x32, 0x30, 0x65, 0x31, 0x61, 0x65, 0x61, 0x33, 0x65, 0x62, 0x61, 0x39, 0x36, 0x38, 0x36, 0x65, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x64, 0x61, 0x30, 0x63, 0x38, 0x66, 0x62, 0x37, 0x63, 0x32, 0x31, 0x30, 0x65, 0x30, 0x66, 0x32, 0x65, 0x63, 0x36, 0x31, 0x38, 0x66, 0x38, 0x35, 0x62, 0x64, 0x61, 0x65, 0x37, 0x64, 0x33, 0x65, 0x37, 0x33, 0x34, 0x62, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x31, 0x33, 0x33, 0x65, 0x37, 0x64, 0x33, 0x31, 0x38, 0x34, 0x35, 0x64, 0x35, 0x66, 0x32, 0x62, 0x36, 0x36, 0x61, 0x32, 0x36, 0x31, 0x38, 0x37, 0x39, 0x32, 0x65, 0x38, 0x36, 0x39, 0x33, 0x31, 0x31, 0x61, 0x63, 0x66, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x62, 0x36, 0x32, 0x63, 0x66, 0x38, 0x65, 0x32, 0x32, 0x63, 0x38, 0x38, 0x34, 0x62, 0x31, 0x62, 0x32, 0x38, 0x63, 0x36, 0x66, 0x61, 0x38, 0x38, 0x66, 0x62, 0x62, 0x63, 0x31, 0x37, 0x39, 0x33, 0x38, 0x61, 0x61, 0x37, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x30, 0x35, 0x63, 0x32, 0x64, 0x35, 0x36, 0x34, 0x37, 0x34, 0x37, 0x30, 0x38, 0x34, 0x38, 0x61, 0x33, 0x38, 0x34, 0x30, 0x66, 0x33, 0x38, 0x38, 0x37, 0x65, 0x39, 0x62, 0x30, 0x31, 0x35, 0x64, 0x33, 0x34, 0x37, 0x35, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x63, 0x61, 0x32, 0x32, 0x62, 0x63, 0x62, 0x38, 0x37, 0x39, 0x39, 0x65, 0x35, 0x33, 0x32, 0x37, 0x63, 0x34, 0x61, 0x61, 0x32, 0x61, 0x37, 0x64, 0x30, 0x39, 0x34, 0x39, 0x61, 0x31, 0x66, 0x63, 0x63, 0x65, 0x35, 0x66, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x39, 0x32, 0x35, 0x64, 0x64, 0x35, 0x64, 0x38, 0x65, 0x64, 0x36, 0x31, 0x33, 0x32, 0x61, 0x62, 0x36, 0x64, 0x30, 0x38, 0x36, 0x30, 0x62, 0x38, 0x32, 0x63, 0x34, 0x34, 0x65, 0x31, 0x61, 0x35, 0x31, 0x66, 0x31, 0x66, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x37, 0x62, 0x62, 0x37, 0x66, 0x31, 0x35, 0x37, 0x64, 0x39, 0x66, 0x65, 0x61, 0x61, 0x31, 0x37, 0x66, 0x37, 0x36, 0x64, 0x61, 0x34, 0x66, 0x37, 0x30, 0x34, 0x62, 0x37, 0x34, 0x64, 0x63, 0x31, 0x30, 0x33, 0x38, 0x33, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x38, 0x39, 0x35, 0x34, 0x66, 0x38, 0x64, 0x36, 0x31, 0x36, 0x36, 0x64, 0x65, 0x35, 0x30, 0x37, 0x63, 0x66, 0x36, 0x31, 0x32, 0x39, 0x37, 0x64, 0x30, 0x66, 0x63, 0x37, 0x63, 0x61, 0x36, 0x62, 0x39, 0x65, 0x37, 0x31, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x63, 0x31, 0x61, 0x64, 0x32, 0x33, 0x64, 0x32, 0x33, 0x66, 0x32, 0x34, 0x62, 0x33, 0x38, 0x34, 0x64, 0x30, 0x63, 0x33, 0x31, 0x34, 0x39, 0x31, 0x37, 0x37, 0x65, 0x38, 0x36, 0x36, 0x39, 0x37, 0x36, 0x31, 0x30, 0x64, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x32, 0x36, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x35, 0x64, 0x38, 0x34, 0x36, 0x66, 0x62, 0x30, 0x62, 0x63, 0x30, 0x32, 0x61, 0x37, 0x33, 0x33, 0x37, 0x32, 0x32, 0x36, 0x64, 0x36, 0x38, 0x35, 0x62, 0x65, 0x39, 0x65, 0x65, 0x37, 0x37, 0x33, 0x62, 0x39, 0x31, 0x39, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x63, 0x62, 0x36, 0x62, 0x33, 0x36, 0x61, 0x66, 0x34, 0x34, 0x33, 0x66, 0x32, 0x63, 0x36, 0x65, 0x32, 0x35, 0x38, 0x62, 0x34, 0x61, 0x33, 0x39, 0x35, 0x35, 0x33, 0x61, 0x38, 0x31, 0x38, 0x37, 0x34, 0x37, 0x38, 0x31, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x61, 0x34, 0x33, 0x66, 0x37, 0x30, 0x37, 0x35, 0x38, 0x31, 0x36, 0x62, 0x36, 0x30, 0x62, 0x62, 0x66, 0x63, 0x65, 0x36, 0x38, 0x62, 0x39, 0x39, 0x33, 0x61, 0x66, 0x30, 0x38, 0x38, 0x31, 0x32, 0x37, 0x30, 0x66, 0x36, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x33, 0x38, 0x38, 0x61, 0x65, 0x64, 0x64, 0x64, 0x33, 0x66, 0x65, 0x32, 0x61, 0x64, 0x35, 0x36, 0x66, 0x38, 0x35, 0x37, 0x34, 0x38, 0x65, 0x38, 0x30, 0x65, 0x37, 0x31, 0x30, 0x61, 0x33, 0x34, 0x62, 0x37, 0x63, 0x39, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x33, 0x31, 0x66, 0x38, 0x37, 0x65, 0x66, 0x63, 0x35, 0x65, 0x66, 0x30, 0x37, 0x65, 0x34, 0x33, 0x66, 0x30, 0x66, 0x32, 0x66, 0x34, 0x61, 0x37, 0x34, 0x37, 0x62, 0x35, 0x35, 0x31, 0x64, 0x37, 0x35, 0x30, 0x64, 0x39, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x62, 0x32, 0x63, 0x62, 0x65, 0x36, 0x35, 0x62, 0x63, 0x36, 0x63, 0x32, 0x65, 0x65, 0x37, 0x61, 0x33, 0x63, 0x37, 0x35, 0x62, 0x32, 0x65, 0x34, 0x37, 0x63, 0x31, 0x38, 0x39, 0x63, 0x30, 0x36, 0x32, 0x65, 0x38, 0x64, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x38, 0x37, 0x36, 0x35, 0x66, 0x34, 0x31, 0x32, 0x39, 0x39, 0x63, 0x37, 0x66, 0x34, 0x37, 0x39, 0x39, 0x32, 0x33, 0x63, 0x34, 0x66, 0x64, 0x31, 0x38, 0x66, 0x31, 0x32, 0x36, 0x64, 0x37, 0x32, 0x32, 0x39, 0x30, 0x34, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x33, 0x62, 0x61, 0x36, 0x64, 0x64, 0x39, 0x35, 0x34, 0x39, 0x62, 0x65, 0x31, 0x64, 0x33, 0x32, 0x38, 0x37, 0x61, 0x35, 0x61, 0x36, 0x35, 0x34, 0x64, 0x31, 0x30, 0x36, 0x63, 0x33, 0x34, 0x63, 0x36, 0x62, 0x35, 0x64, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x37, 0x30, 0x39, 0x39, 0x35, 0x66, 0x65, 0x31, 0x65, 0x35, 0x32, 0x32, 0x33, 0x32, 0x31, 0x64, 0x37, 0x35, 0x34, 0x33, 0x33, 0x37, 0x61, 0x34, 0x35, 0x63, 0x30, 0x63, 0x39, 0x64, 0x37, 0x62, 0x33, 0x38, 0x39, 0x35, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x38, 0x65, 0x64, 0x37, 0x64, 0x30, 0x64, 0x31, 0x35, 0x36, 0x33, 0x38, 0x33, 0x33, 0x30, 0x65, 0x64, 0x37, 0x65, 0x34, 0x65, 0x61, 0x63, 0x63, 0x61, 0x62, 0x38, 0x61, 0x34, 0x35, 0x38, 0x64, 0x37, 0x35, 0x37, 0x33, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x63, 0x35, 0x31, 0x30, 0x62, 0x66, 0x38, 0x64, 0x36, 0x65, 0x35, 0x36, 0x39, 0x62, 0x66, 0x32, 0x66, 0x33, 0x37, 0x64, 0x34, 0x37, 0x32, 0x36, 0x35, 0x64, 0x62, 0x63, 0x62, 0x35, 0x30, 0x32, 0x66, 0x66, 0x32, 0x62, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x63, 0x63, 0x66, 0x36, 0x31, 0x37, 0x38, 0x34, 0x34, 0x66, 0x64, 0x36, 0x31, 0x66, 0x62, 0x61, 0x36, 0x32, 0x63, 0x62, 0x30, 0x65, 0x34, 0x34, 0x35, 0x62, 0x37, 0x61, 0x63, 0x36, 0x38, 0x62, 0x63, 0x63, 0x31, 0x66, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x37, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x31, 0x30, 0x65, 0x32, 0x37, 0x61, 0x30, 0x31, 0x34, 0x66, 0x30, 0x64, 0x33, 0x30, 0x36, 0x62, 0x61, 0x66, 0x32, 0x36, 0x36, 0x64, 0x34, 0x38, 0x39, 0x37, 0x63, 0x38, 0x39, 0x61, 0x65, 0x65, 0x65, 0x32, 0x65, 0x39, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x32, 0x37, 0x30, 0x33, 0x39, 0x66, 0x30, 0x39, 0x35, 0x37, 0x30, 0x32, 0x39, 0x34, 0x30, 0x38, 0x38, 0x66, 0x64, 0x64, 0x66, 0x30, 0x34, 0x37, 0x31, 0x36, 0x35, 0x63, 0x33, 0x33, 0x65, 0x36, 0x39, 0x36, 0x61, 0x34, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x33, 0x37, 0x38, 0x66, 0x34, 0x32, 0x39, 0x32, 0x36, 0x64, 0x30, 0x31, 0x38, 0x34, 0x62, 0x37, 0x39, 0x33, 0x62, 0x30, 0x63, 0x38, 0x32, 0x37, 0x61, 0x36, 0x64, 0x64, 0x33, 0x65, 0x33, 0x64, 0x33, 0x33, 0x34, 0x66, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x31, 0x32, 0x34, 0x61, 0x65, 0x37, 0x66, 0x34, 0x35, 0x32, 0x66, 0x32, 0x36, 0x62, 0x33, 0x64, 0x35, 0x37, 0x34, 0x66, 0x36, 0x30, 0x38, 0x38, 0x38, 0x39, 0x34, 0x66, 0x61, 0x35, 0x64, 0x31, 0x63, 0x66, 0x62, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x65, 0x36, 0x31, 0x65, 0x34, 0x33, 0x63, 0x62, 0x30, 0x64, 0x30, 0x63, 0x39, 0x36, 0x62, 0x33, 0x30, 0x36, 0x39, 0x39, 0x66, 0x37, 0x37, 0x65, 0x30, 0x30, 0x64, 0x37, 0x31, 0x31, 0x64, 0x30, 0x61, 0x33, 0x39, 0x37, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x63, 0x37, 0x65, 0x64, 0x62, 0x38, 0x31, 0x31, 0x38, 0x65, 0x65, 0x32, 0x37, 0x62, 0x33, 0x34, 0x32, 0x32, 0x38, 0x35, 0x65, 0x62, 0x35, 0x39, 0x32, 0x36, 0x62, 0x34, 0x37, 0x61, 0x38, 0x35, 0x35, 0x62, 0x63, 0x37, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x35, 0x64, 0x39, 0x38, 0x35, 0x36, 0x35, 0x63, 0x36, 0x34, 0x37, 0x63, 0x61, 0x35, 0x66, 0x31, 0x37, 0x37, 0x61, 0x32, 0x61, 0x64, 0x62, 0x39, 0x64, 0x33, 0x30, 0x32, 0x32, 0x66, 0x61, 0x63, 0x32, 0x38, 0x37, 0x66, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x32, 0x32, 0x66, 0x65, 0x63, 0x37, 0x37, 0x31, 0x31, 0x37, 0x38, 0x31, 0x64, 0x32, 0x36, 0x65, 0x61, 0x61, 0x34, 0x65, 0x38, 0x34, 0x38, 0x35, 0x66, 0x37, 0x61, 0x61, 0x33, 0x66, 0x61, 0x63, 0x34, 0x34, 0x32, 0x34, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x34, 0x34, 0x32, 0x37, 0x35, 0x62, 0x31, 0x37, 0x31, 0x35, 0x62, 0x61, 0x65, 0x61, 0x31, 0x62, 0x30, 0x33, 0x34, 0x35, 0x37, 0x33, 0x35, 0x61, 0x32, 0x39, 0x61, 0x63, 0x34, 0x32, 0x63, 0x39, 0x66, 0x35, 0x31, 0x62, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x64, 0x38, 0x32, 0x61, 0x66, 0x39, 0x65, 0x30, 0x31, 0x61, 0x39, 0x33, 0x36, 0x64, 0x39, 0x37, 0x66, 0x38, 0x66, 0x38, 0x35, 0x39, 0x34, 0x30, 0x62, 0x39, 0x37, 0x30, 0x66, 0x39, 0x64, 0x34, 0x64, 0x62, 0x39, 0x39, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x35, 0x33, 0x33, 0x33, 0x39, 0x30, 0x65, 0x33, 0x34, 0x30, 0x66, 0x65, 0x30, 0x64, 0x65, 0x33, 0x62, 0x33, 0x63, 0x66, 0x35, 0x66, 0x62, 0x39, 0x66, 0x63, 0x38, 0x65, 0x61, 0x35, 0x35, 0x32, 0x65, 0x32, 0x39, 0x65, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x38, 0x34, 0x66, 0x30, 0x63, 0x65, 0x65, 0x39, 0x64, 0x32, 0x66, 0x66, 0x32, 0x39, 0x38, 0x39, 0x62, 0x36, 0x35, 0x35, 0x37, 0x34, 0x64, 0x30, 0x36, 0x66, 0x66, 0x64, 0x39, 0x61, 0x62, 0x30, 0x66, 0x37, 0x62, 0x38, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x39, 0x65, 0x62, 0x63, 0x63, 0x62, 0x61, 0x34, 0x32, 0x66, 0x39, 0x38, 0x31, 0x35, 0x65, 0x37, 0x38, 0x32, 0x33, 0x33, 0x32, 0x36, 0x36, 0x64, 0x64, 0x36, 0x65, 0x38, 0x33, 0x35, 0x62, 0x36, 0x61, 0x66, 0x63, 0x33, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x33, 0x32, 0x34, 0x39, 0x31, 0x32, 0x64, 0x36, 0x34, 0x65, 0x61, 0x33, 0x61, 0x65, 0x66, 0x37, 0x36, 0x62, 0x33, 0x63, 0x32, 0x66, 0x66, 0x39, 0x64, 0x66, 0x38, 0x32, 0x63, 0x37, 0x65, 0x31, 0x33, 0x61, 0x65, 0x39, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x63, 0x37, 0x34, 0x32, 0x66, 0x64, 0x37, 0x61, 0x38, 0x62, 0x37, 0x39, 0x30, 0x36, 0x62, 0x33, 0x62, 0x66, 0x65, 0x34, 0x66, 0x38, 0x39, 0x30, 0x34, 0x66, 0x63, 0x30, 0x62, 0x65, 0x35, 0x63, 0x37, 0x36, 0x38, 0x30, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x66, 0x62, 0x38, 0x62, 0x64, 0x31, 0x66, 0x30, 0x65, 0x36, 0x36, 0x62, 0x39, 0x30, 0x35, 0x33, 0x33, 0x65, 0x30, 0x37, 0x31, 0x65, 0x36, 0x63, 0x62, 0x65, 0x36, 0x31, 0x31, 0x31, 0x66, 0x65, 0x66, 0x30, 0x62, 0x63, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x38, 0x33, 0x61, 0x65, 0x62, 0x30, 0x32, 0x66, 0x63, 0x66, 0x30, 0x36, 0x37, 0x64, 0x36, 0x35, 0x61, 0x34, 0x37, 0x30, 0x38, 0x32, 0x66, 0x64, 0x39, 0x37, 0x37, 0x38, 0x33, 0x33, 0x61, 0x62, 0x31, 0x63, 0x65, 0x63, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x63, 0x62, 0x66, 0x61, 0x30, 0x38, 0x63, 0x64, 0x64, 0x34, 0x66, 0x62, 0x61, 0x37, 0x33, 0x37, 0x62, 0x61, 0x63, 0x34, 0x30, 0x37, 0x62, 0x65, 0x38, 0x32, 0x32, 0x34, 0x66, 0x34, 0x65, 0x65, 0x66, 0x33, 0x35, 0x38, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x33, 0x34, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x65, 0x65, 0x34, 0x30, 0x36, 0x65, 0x61, 0x34, 0x61, 0x37, 0x61, 0x65, 0x36, 0x61, 0x33, 0x61, 0x33, 0x38, 0x31, 0x65, 0x62, 0x34, 0x65, 0x64, 0x64, 0x32, 0x66, 0x30, 0x39, 0x66, 0x31, 0x37, 0x34, 0x62, 0x34, 0x39, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x63, 0x32, 0x33, 0x64, 0x38, 0x61, 0x35, 0x30, 0x32, 0x31, 0x32, 0x34, 0x65, 0x65, 0x31, 0x35, 0x30, 0x66, 0x30, 0x38, 0x64, 0x37, 0x31, 0x64, 0x63, 0x36, 0x37, 0x32, 0x37, 0x34, 0x31, 0x30, 0x61, 0x30, 0x66, 0x39, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x63, 0x30, 0x30, 0x63, 0x64, 0x62, 0x31, 0x66, 0x30, 0x32, 0x30, 0x33, 0x31, 0x30, 0x64, 0x35, 0x61, 0x63, 0x61, 0x62, 0x37, 0x62, 0x34, 0x39, 0x36, 0x61, 0x61, 0x61, 0x34, 0x34, 0x62, 0x37, 0x37, 0x39, 0x30, 0x38, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x39, 0x36, 0x35, 0x36, 0x35, 0x62, 0x37, 0x63, 0x37, 0x34, 0x30, 0x37, 0x64, 0x30, 0x36, 0x35, 0x33, 0x36, 0x35, 0x38, 0x30, 0x33, 0x35, 0x35, 0x66, 0x64, 0x64, 0x36, 0x64, 0x32, 0x33, 0x39, 0x31, 0x34, 0x34, 0x61, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x64, 0x35, 0x32, 0x64, 0x63, 0x63, 0x35, 0x66, 0x39, 0x36, 0x63, 0x63, 0x32, 0x38, 0x30, 0x30, 0x37, 0x62, 0x33, 0x65, 0x63, 0x62, 0x62, 0x34, 0x30, 0x39, 0x66, 0x37, 0x65, 0x32, 0x32, 0x61, 0x36, 0x34, 0x36, 0x63, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x32, 0x32, 0x32, 0x63, 0x37, 0x63, 0x34, 0x31, 0x63, 0x39, 0x62, 0x30, 0x34, 0x38, 0x65, 0x66, 0x63, 0x63, 0x65, 0x30, 0x61, 0x32, 0x33, 0x32, 0x34, 0x33, 0x34, 0x33, 0x36, 0x32, 0x65, 0x31, 0x32, 0x64, 0x36, 0x37, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x33, 0x62, 0x64, 0x62, 0x64, 0x38, 0x62, 0x63, 0x34, 0x32, 0x31, 0x63, 0x33, 0x32, 0x61, 0x34, 0x34, 0x33, 0x30, 0x33, 0x32, 0x64, 0x65, 0x62, 0x32, 0x65, 0x33, 0x65, 0x34, 0x63, 0x64, 0x35, 0x62, 0x61, 0x38, 0x62, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x64, 0x61, 0x35, 0x65, 0x36, 0x63, 0x37, 0x32, 0x66, 0x62, 0x33, 0x36, 0x62, 0x63, 0x65, 0x31, 0x64, 0x39, 0x37, 0x39, 0x38, 0x66, 0x37, 0x62, 0x63, 0x64, 0x66, 0x31, 0x64, 0x31, 0x38, 0x66, 0x34, 0x35, 0x39, 0x63, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x32, 0x66, 0x39, 0x38, 0x36, 0x35, 0x30, 0x37, 0x31, 0x32, 0x65, 0x62, 0x31, 0x35, 0x38, 0x37, 0x35, 0x33, 0x64, 0x38, 0x32, 0x39, 0x37, 0x32, 0x62, 0x38, 0x65, 0x39, 0x39, 0x63, 0x61, 0x33, 0x66, 0x36, 0x31, 0x38, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x61, 0x37, 0x63, 0x35, 0x30, 0x38, 0x65, 0x66, 0x37, 0x31, 0x35, 0x38, 0x32, 0x64, 0x64, 0x39, 0x61, 0x35, 0x34, 0x33, 0x37, 0x32, 0x66, 0x38, 0x39, 0x63, 0x62, 0x30, 0x31, 0x66, 0x32, 0x35, 0x32, 0x66, 0x62, 0x31, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x31, 0x32, 0x38, 0x33, 0x62, 0x34, 0x62, 0x64, 0x38, 0x35, 0x30, 0x34, 0x30, 0x35, 0x38, 0x63, 0x61, 0x33, 0x36, 0x30, 0x65, 0x39, 0x39, 0x33, 0x39, 0x39, 0x39, 0x62, 0x36, 0x32, 0x63, 0x62, 0x63, 0x38, 0x63, 0x64, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x63, 0x64, 0x64, 0x63, 0x62, 0x32, 0x63, 0x66, 0x63, 0x32, 0x62, 0x32, 0x35, 0x62, 0x30, 0x38, 0x37, 0x32, 0x39, 0x61, 0x30, 0x61, 0x39, 0x38, 0x64, 0x39, 0x65, 0x36, 0x66, 0x30, 0x32, 0x30, 0x32, 0x65, 0x61, 0x32, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x36, 0x30, 0x61, 0x34, 0x62, 0x39, 0x30, 0x38, 0x64, 0x64, 0x32, 0x62, 0x30, 0x35, 0x36, 0x37, 0x35, 0x39, 0x62, 0x34, 0x38, 0x38, 0x38, 0x35, 0x30, 0x62, 0x36, 0x36, 0x61, 0x38, 0x33, 0x38, 0x66, 0x63, 0x37, 0x37, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x31, 0x62, 0x31, 0x64, 0x31, 0x38, 0x37, 0x35, 0x31, 0x62, 0x39, 0x38, 0x66, 0x63, 0x39, 0x65, 0x32, 0x38, 0x38, 0x38, 0x61, 0x63, 0x37, 0x37, 0x35, 0x39, 0x66, 0x31, 0x35, 0x33, 0x35, 0x61, 0x32, 0x64, 0x62, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x32, 0x61, 0x31, 0x34, 0x66, 0x39, 0x37, 0x32, 0x34, 0x30, 0x31, 0x35, 0x64, 0x37, 0x39, 0x30, 0x31, 0x34, 0x65, 0x64, 0x38, 0x65, 0x35, 0x39, 0x30, 0x39, 0x36, 0x38, 0x31, 0x64, 0x35, 0x39, 0x36, 0x31, 0x34, 0x38, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x34, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x38, 0x39, 0x34, 0x33, 0x34, 0x66, 0x38, 0x32, 0x35, 0x61, 0x61, 0x66, 0x39, 0x63, 0x35, 0x35, 0x32, 0x66, 0x36, 0x38, 0x35, 0x65, 0x62, 0x61, 0x37, 0x63, 0x31, 0x31, 0x64, 0x62, 0x34, 0x61, 0x35, 0x66, 0x63, 0x37, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x37, 0x30, 0x31, 0x64, 0x31, 0x36, 0x63, 0x30, 0x64, 0x33, 0x63, 0x63, 0x31, 0x65, 0x34, 0x63, 0x64, 0x38, 0x35, 0x34, 0x34, 0x35, 0x65, 0x36, 0x61, 0x64, 0x30, 0x32, 0x65, 0x65, 0x61, 0x34, 0x61, 0x63, 0x30, 0x31, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x62, 0x39, 0x37, 0x38, 0x61, 0x39, 0x64, 0x37, 0x65, 0x39, 0x31, 0x65, 0x65, 0x35, 0x32, 0x39, 0x65, 0x61, 0x34, 0x66, 0x63, 0x34, 0x62, 0x37, 0x36, 0x66, 0x65, 0x61, 0x66, 0x38, 0x37, 0x36, 0x32, 0x66, 0x36, 0x39, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x39, 0x63, 0x66, 0x35, 0x30, 0x34, 0x62, 0x39, 0x66, 0x33, 0x66, 0x38, 0x33, 0x35, 0x31, 0x38, 0x31, 0x66, 0x64, 0x38, 0x34, 0x32, 0x34, 0x66, 0x35, 0x63, 0x63, 0x62, 0x63, 0x38, 0x65, 0x31, 0x62, 0x64, 0x64, 0x66, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x34, 0x39, 0x34, 0x31, 0x62, 0x36, 0x30, 0x33, 0x36, 0x30, 0x31, 0x39, 0x62, 0x34, 0x30, 0x31, 0x36, 0x61, 0x33, 0x30, 0x63, 0x31, 0x30, 0x33, 0x37, 0x64, 0x35, 0x61, 0x36, 0x39, 0x30, 0x33, 0x62, 0x61, 0x62, 0x61, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x64, 0x39, 0x38, 0x64, 0x30, 0x63, 0x31, 0x30, 0x36, 0x39, 0x39, 0x30, 0x38, 0x66, 0x30, 0x36, 0x37, 0x61, 0x35, 0x32, 0x61, 0x63, 0x61, 0x63, 0x32, 0x62, 0x38, 0x62, 0x35, 0x33, 0x34, 0x64, 0x61, 0x33, 0x37, 0x61, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x35, 0x34, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x38, 0x34, 0x39, 0x32, 0x33, 0x62, 0x36, 0x32, 0x65, 0x36, 0x38, 0x62, 0x62, 0x66, 0x37, 0x63, 0x32, 0x62, 0x39, 0x66, 0x33, 0x34, 0x31, 0x34, 0x64, 0x31, 0x33, 0x65, 0x66, 0x36, 0x63, 0x38, 0x31, 0x32, 0x61, 0x39, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x35, 0x61, 0x33, 0x39, 0x66, 0x64, 0x64, 0x61, 0x37, 0x30, 0x64, 0x66, 0x31, 0x31, 0x32, 0x36, 0x61, 0x62, 0x30, 0x64, 0x63, 0x34, 0x39, 0x61, 0x37, 0x33, 0x37, 0x38, 0x33, 0x31, 0x31, 0x61, 0x35, 0x33, 0x37, 0x61, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x61, 0x63, 0x65, 0x34, 0x63, 0x39, 0x39, 0x33, 0x62, 0x62, 0x31, 0x65, 0x35, 0x33, 0x38, 0x33, 0x66, 0x38, 0x61, 0x63, 0x37, 0x34, 0x65, 0x31, 0x37, 0x39, 0x30, 0x36, 0x36, 0x65, 0x38, 0x31, 0x34, 0x66, 0x30, 0x35, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x30, 0x39, 0x64, 0x38, 0x33, 0x61, 0x36, 0x63, 0x65, 0x31, 0x66, 0x66, 0x63, 0x39, 0x62, 0x36, 0x39, 0x30, 0x66, 0x33, 0x65, 0x39, 0x61, 0x38, 0x31, 0x65, 0x39, 0x38, 0x33, 0x65, 0x38, 0x62, 0x64, 0x63, 0x34, 0x64, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x31, 0x39, 0x34, 0x31, 0x37, 0x63, 0x34, 0x36, 0x37, 0x33, 0x32, 0x63, 0x66, 0x33, 0x34, 0x64, 0x31, 0x61, 0x31, 0x61, 0x66, 0x62, 0x37, 0x39, 0x63, 0x33, 0x65, 0x37, 0x65, 0x32, 0x63, 0x64, 0x38, 0x65, 0x65, 0x63, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x62, 0x33, 0x33, 0x39, 0x34, 0x34, 0x66, 0x32, 0x33, 0x36, 0x30, 0x36, 0x31, 0x35, 0x65, 0x35, 0x62, 0x65, 0x32, 0x33, 0x39, 0x35, 0x37, 0x37, 0x63, 0x38, 0x61, 0x31, 0x39, 0x62, 0x61, 0x35, 0x32, 0x64, 0x39, 0x38, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x39, 0x35, 0x64, 0x62, 0x65, 0x33, 0x30, 0x66, 0x31, 0x66, 0x31, 0x38, 0x37, 0x37, 0x63, 0x35, 0x64, 0x64, 0x37, 0x36, 0x38, 0x34, 0x61, 0x65, 0x65, 0x66, 0x33, 0x30, 0x32, 0x61, 0x62, 0x36, 0x38, 0x38, 0x35, 0x31, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x33, 0x66, 0x34, 0x62, 0x30, 0x32, 0x36, 0x36, 0x39, 0x63, 0x63, 0x66, 0x66, 0x36, 0x38, 0x30, 0x36, 0x62, 0x63, 0x38, 0x32, 0x36, 0x66, 0x63, 0x62, 0x37, 0x64, 0x65, 0x63, 0x61, 0x33, 0x62, 0x30, 0x65, 0x61, 0x39, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x30, 0x30, 0x63, 0x64, 0x38, 0x31, 0x33, 0x30, 0x38, 0x33, 0x39, 0x65, 0x39, 0x34, 0x34, 0x39, 0x35, 0x64, 0x32, 0x64, 0x38, 0x34, 0x31, 0x35, 0x61, 0x38, 0x65, 0x61, 0x32, 0x63, 0x39, 0x30, 0x65, 0x30, 0x63, 0x35, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x30, 0x35, 0x33, 0x31, 0x39, 0x31, 0x33, 0x31, 0x39, 0x65, 0x30, 0x36, 0x37, 0x61, 0x32, 0x35, 0x65, 0x36, 0x33, 0x36, 0x31, 0x64, 0x34, 0x37, 0x66, 0x33, 0x37, 0x66, 0x36, 0x33, 0x31, 0x38, 0x66, 0x38, 0x33, 0x34, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x63, 0x35, 0x37, 0x33, 0x62, 0x63, 0x64, 0x61, 0x32, 0x33, 0x62, 0x38, 0x62, 0x32, 0x36, 0x66, 0x39, 0x30, 0x37, 0x33, 0x64, 0x39, 0x30, 0x63, 0x32, 0x33, 0x30, 0x65, 0x38, 0x65, 0x37, 0x31, 0x65, 0x30, 0x32, 0x37, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x66, 0x37, 0x37, 0x36, 0x30, 0x36, 0x35, 0x37, 0x63, 0x31, 0x65, 0x32, 0x30, 0x32, 0x37, 0x35, 0x39, 0x30, 0x38, 0x36, 0x39, 0x36, 0x33, 0x65, 0x62, 0x34, 0x32, 0x31, 0x31, 0x63, 0x35, 0x66, 0x38, 0x31, 0x33, 0x39, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x36, 0x38, 0x39, 0x37, 0x61, 0x33, 0x31, 0x31, 0x61, 0x31, 0x34, 0x61, 0x64, 0x34, 0x33, 0x62, 0x37, 0x38, 0x65, 0x30, 0x39, 0x32, 0x30, 0x31, 0x30, 0x30, 0x63, 0x34, 0x34, 0x32, 0x36, 0x62, 0x66, 0x64, 0x36, 0x62, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x33, 0x35, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x32, 0x37, 0x36, 0x66, 0x30, 0x63, 0x64, 0x35, 0x66, 0x66, 0x64, 0x35, 0x66, 0x66, 0x62, 0x36, 0x33, 0x66, 0x39, 0x38, 0x62, 0x35, 0x37, 0x30, 0x33, 0x64, 0x35, 0x35, 0x39, 0x34, 0x65, 0x64, 0x65, 0x30, 0x38, 0x33, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x63, 0x33, 0x35, 0x63, 0x39, 0x31, 0x33, 0x63, 0x61, 0x31, 0x66, 0x63, 0x65, 0x61, 0x62, 0x34, 0x36, 0x31, 0x35, 0x38, 0x32, 0x66, 0x65, 0x31, 0x61, 0x35, 0x38, 0x31, 0x35, 0x31, 0x36, 0x34, 0x62, 0x34, 0x66, 0x64, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x33, 0x30, 0x36, 0x37, 0x66, 0x65, 0x37, 0x30, 0x64, 0x39, 0x62, 0x35, 0x35, 0x39, 0x37, 0x33, 0x62, 0x61, 0x35, 0x38, 0x64, 0x63, 0x36, 0x34, 0x64, 0x64, 0x37, 0x66, 0x33, 0x31, 0x31, 0x65, 0x35, 0x35, 0x34, 0x32, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x38, 0x66, 0x30, 0x64, 0x31, 0x35, 0x63, 0x63, 0x39, 0x36, 0x66, 0x62, 0x37, 0x66, 0x65, 0x39, 0x34, 0x66, 0x31, 0x30, 0x36, 0x35, 0x62, 0x63, 0x36, 0x39, 0x34, 0x30, 0x66, 0x38, 0x64, 0x31, 0x32, 0x39, 0x35, 0x37, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x64, 0x62, 0x61, 0x35, 0x32, 0x35, 0x30, 0x62, 0x61, 0x39, 0x36, 0x32, 0x35, 0x37, 0x35, 0x35, 0x32, 0x34, 0x36, 0x65, 0x30, 0x36, 0x37, 0x39, 0x36, 0x37, 0x66, 0x32, 0x61, 0x64, 0x32, 0x66, 0x30, 0x37, 0x39, 0x31, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x62, 0x37, 0x61, 0x30, 0x33, 0x64, 0x64, 0x61, 0x31, 0x34, 0x63, 0x61, 0x39, 0x63, 0x36, 0x36, 0x31, 0x61, 0x31, 0x64, 0x34, 0x36, 0x39, 0x66, 0x64, 0x33, 0x33, 0x37, 0x33, 0x36, 0x66, 0x36, 0x37, 0x33, 0x63, 0x38, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x39, 0x32, 0x33, 0x34, 0x39, 0x63, 0x65, 0x39, 0x66, 0x36, 0x66, 0x31, 0x34, 0x66, 0x38, 0x31, 0x64, 0x30, 0x36, 0x37, 0x34, 0x30, 0x39, 0x36, 0x62, 0x65, 0x66, 0x61, 0x31, 0x66, 0x39, 0x32, 0x32, 0x31, 0x63, 0x64, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x38, 0x35, 0x33, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x31, 0x35, 0x32, 0x37, 0x39, 0x64, 0x66, 0x66, 0x39, 0x39, 0x35, 0x32, 0x64, 0x61, 0x33, 0x62, 0x65, 0x38, 0x66, 0x37, 0x37, 0x32, 0x34, 0x39, 0x64, 0x62, 0x65, 0x32, 0x32, 0x32, 0x34, 0x33, 0x33, 0x37, 0x37, 0x62, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x34, 0x38, 0x31, 0x65, 0x38, 0x35, 0x36, 0x65, 0x62, 0x65, 0x64, 0x34, 0x38, 0x65, 0x61, 0x37, 0x30, 0x38, 0x61, 0x32, 0x37, 0x34, 0x32, 0x36, 0x65, 0x66, 0x32, 0x38, 0x65, 0x38, 0x36, 0x37, 0x66, 0x35, 0x37, 0x63, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x62, 0x38, 0x63, 0x37, 0x31, 0x39, 0x38, 0x32, 0x61, 0x30, 0x30, 0x66, 0x62, 0x38, 0x34, 0x32, 0x37, 0x35, 0x32, 0x39, 0x33, 0x32, 0x35, 0x33, 0x66, 0x38, 0x30, 0x34, 0x34, 0x35, 0x34, 0x34, 0x62, 0x36, 0x36, 0x62, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x66, 0x35, 0x38, 0x37, 0x30, 0x66, 0x32, 0x36, 0x62, 0x63, 0x65, 0x30, 0x38, 0x39, 0x36, 0x37, 0x37, 0x64, 0x66, 0x63, 0x32, 0x33, 0x62, 0x35, 0x30, 0x30, 0x31, 0x65, 0x65, 0x34, 0x39, 0x32, 0x34, 0x38, 0x33, 0x34, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x36, 0x37, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x32, 0x33, 0x66, 0x61, 0x63, 0x64, 0x31, 0x32, 0x63, 0x37, 0x36, 0x35, 0x63, 0x33, 0x36, 0x61, 0x62, 0x38, 0x31, 0x61, 0x36, 0x64, 0x64, 0x33, 0x34, 0x64, 0x38, 0x61, 0x61, 0x39, 0x65, 0x36, 0x38, 0x39, 0x31, 0x38, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x31, 0x32, 0x64, 0x39, 0x30, 0x32, 0x39, 0x33, 0x31, 0x36, 0x37, 0x36, 0x66, 0x66, 0x33, 0x39, 0x66, 0x63, 0x33, 0x34, 0x66, 0x65, 0x33, 0x63, 0x33, 0x63, 0x63, 0x38, 0x66, 0x62, 0x32, 0x31, 0x38, 0x32, 0x66, 0x61, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x39, 0x61, 0x36, 0x36, 0x31, 0x37, 0x32, 0x61, 0x65, 0x61, 0x33, 0x37, 0x30, 0x64, 0x39, 0x61, 0x36, 0x33, 0x64, 0x61, 0x30, 0x34, 0x66, 0x66, 0x37, 0x31, 0x66, 0x66, 0x62, 0x62, 0x66, 0x63, 0x66, 0x66, 0x37, 0x66, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x36, 0x39, 0x65, 0x61, 0x31, 0x35, 0x39, 0x35, 0x65, 0x64, 0x63, 0x35, 0x63, 0x34, 0x61, 0x37, 0x30, 0x37, 0x63, 0x66, 0x64, 0x65, 0x33, 0x38, 0x30, 0x39, 0x32, 0x39, 0x36, 0x33, 0x33, 0x32, 0x35, 0x31, 0x61, 0x32, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x32, 0x62, 0x34, 0x37, 0x65, 0x32, 0x37, 0x37, 0x35, 0x61, 0x31, 0x66, 0x61, 0x37, 0x31, 0x37, 0x38, 0x64, 0x61, 0x64, 0x39, 0x32, 0x39, 0x38, 0x35, 0x61, 0x35, 0x62, 0x62, 0x65, 0x34, 0x39, 0x33, 0x62, 0x61, 0x36, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x62, 0x39, 0x61, 0x39, 0x37, 0x61, 0x64, 0x61, 0x30, 0x36, 0x35, 0x63, 0x38, 0x37, 0x38, 0x31, 0x36, 0x65, 0x36, 0x38, 0x36, 0x30, 0x61, 0x38, 0x66, 0x31, 0x34, 0x32, 0x36, 0x66, 0x65, 0x36, 0x62, 0x33, 0x64, 0x37, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x66, 0x64, 0x38, 0x32, 0x31, 0x37, 0x33, 0x33, 0x39, 0x37, 0x32, 0x35, 0x64, 0x37, 0x65, 0x62, 0x61, 0x63, 0x31, 0x31, 0x61, 0x36, 0x33, 0x36, 0x35, 0x35, 0x66, 0x32, 0x36, 0x35, 0x65, 0x66, 0x66, 0x31, 0x63, 0x63, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x39, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x34, 0x30, 0x30, 0x34, 0x63, 0x30, 0x34, 0x30, 0x33, 0x66, 0x37, 0x65, 0x61, 0x62, 0x62, 0x30, 0x65, 0x61, 0x35, 0x38, 0x36, 0x66, 0x32, 0x31, 0x32, 0x31, 0x35, 0x36, 0x63, 0x34, 0x32, 0x30, 0x33, 0x64, 0x36, 0x37, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x37, 0x63, 0x62, 0x32, 0x66, 0x65, 0x36, 0x62, 0x66, 0x33, 0x65, 0x30, 0x39, 0x63, 0x62, 0x63, 0x64, 0x63, 0x31, 0x38, 0x37, 0x61, 0x66, 0x33, 0x38, 0x66, 0x61, 0x38, 0x66, 0x35, 0x30, 0x35, 0x33, 0x61, 0x37, 0x30, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x37, 0x30, 0x38, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x35, 0x31, 0x62, 0x32, 0x34, 0x34, 0x66, 0x66, 0x35, 0x30, 0x63, 0x66, 0x61, 0x65, 0x35, 0x39, 0x31, 0x64, 0x35, 0x65, 0x31, 0x61, 0x31, 0x34, 0x38, 0x64, 0x66, 0x36, 0x61, 0x39, 0x33, 0x38, 0x65, 0x66, 0x32, 0x61, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x35, 0x38, 0x64, 0x62, 0x34, 0x33, 0x66, 0x61, 0x36, 0x32, 0x64, 0x33, 0x30, 0x65, 0x36, 0x35, 0x66, 0x33, 0x64, 0x30, 0x39, 0x62, 0x66, 0x37, 0x38, 0x31, 0x63, 0x37, 0x62, 0x36, 0x37, 0x33, 0x37, 0x32, 0x65, 0x62, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x65, 0x30, 0x33, 0x37, 0x66, 0x30, 0x30, 0x61, 0x31, 0x38, 0x32, 0x37, 0x30, 0x62, 0x61, 0x35, 0x65, 0x63, 0x33, 0x34, 0x32, 0x30, 0x32, 0x32, 0x39, 0x64, 0x64, 0x62, 0x30, 0x61, 0x32, 0x63, 0x65, 0x33, 0x38, 0x66, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x61, 0x65, 0x61, 0x31, 0x66, 0x31, 0x30, 0x34, 0x36, 0x66, 0x33, 0x30, 0x66, 0x31, 0x30, 0x39, 0x66, 0x61, 0x65, 0x63, 0x31, 0x63, 0x36, 0x33, 0x65, 0x66, 0x35, 0x63, 0x37, 0x35, 0x39, 0x34, 0x65, 0x62, 0x30, 0x38, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x64, 0x37, 0x32, 0x36, 0x39, 0x66, 0x66, 0x30, 0x36, 0x63, 0x39, 0x66, 0x66, 0x64, 0x33, 0x33, 0x37, 0x35, 0x34, 0x63, 0x65, 0x35, 0x38, 0x38, 0x66, 0x37, 0x34, 0x61, 0x39, 0x36, 0x36, 0x61, 0x62, 0x62, 0x62, 0x62, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x37, 0x36, 0x37, 0x62, 0x36, 0x35, 0x66, 0x64, 0x39, 0x31, 0x31, 0x36, 0x31, 0x66, 0x34, 0x66, 0x62, 0x64, 0x63, 0x63, 0x36, 0x61, 0x36, 0x39, 0x65, 0x32, 0x66, 0x36, 0x61, 0x64, 0x37, 0x31, 0x31, 0x62, 0x62, 0x39, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x61, 0x65, 0x35, 0x62, 0x37, 0x63, 0x37, 0x65, 0x62, 0x34, 0x39, 0x32, 0x66, 0x66, 0x31, 0x66, 0x66, 0x61, 0x31, 0x36, 0x64, 0x64, 0x34, 0x32, 0x61, 0x64, 0x39, 0x63, 0x61, 0x64, 0x34, 0x30, 0x62, 0x37, 0x66, 0x38, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x34, 0x66, 0x32, 0x61, 0x65, 0x30, 0x32, 0x61, 0x64, 0x64, 0x31, 0x34, 0x63, 0x31, 0x32, 0x66, 0x61, 0x66, 0x36, 0x35, 0x63, 0x62, 0x32, 0x35, 0x39, 0x30, 0x32, 0x32, 0x64, 0x30, 0x38, 0x33, 0x30, 0x61, 0x38, 0x65, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x65, 0x66, 0x32, 0x66, 0x62, 0x63, 0x33, 0x64, 0x61, 0x66, 0x35, 0x65, 0x64, 0x61, 0x66, 0x34, 0x61, 0x32, 0x39, 0x35, 0x36, 0x32, 0x39, 0x63, 0x63, 0x66, 0x33, 0x31, 0x62, 0x63, 0x64, 0x66, 0x34, 0x30, 0x33, 0x38, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x39, 0x61, 0x64, 0x36, 0x66, 0x32, 0x62, 0x35, 0x37, 0x30, 0x36, 0x62, 0x62, 0x65, 0x32, 0x66, 0x36, 0x38, 0x39, 0x61, 0x34, 0x34, 0x63, 0x34, 0x62, 0x36, 0x34, 0x30, 0x62, 0x35, 0x38, 0x65, 0x39, 0x36, 0x62, 0x39, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x38, 0x33, 0x36, 0x64, 0x39, 0x64, 0x33, 0x62, 0x30, 0x65, 0x32, 0x63, 0x62, 0x64, 0x34, 0x64, 0x65, 0x30, 0x35, 0x30, 0x35, 0x39, 0x36, 0x66, 0x61, 0x61, 0x34, 0x39, 0x30, 0x63, 0x66, 0x66, 0x62, 0x36, 0x30, 0x64, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x66, 0x36, 0x32, 0x34, 0x37, 0x62, 0x30, 0x64, 0x35, 0x38, 0x32, 0x61, 0x61, 0x61, 0x32, 0x35, 0x65, 0x35, 0x31, 0x31, 0x34, 0x37, 0x36, 0x35, 0x65, 0x34, 0x62, 0x66, 0x33, 0x63, 0x37, 0x37, 0x34, 0x66, 0x34, 0x33, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x39, 0x33, 0x63, 0x37, 0x38, 0x63, 0x37, 0x64, 0x36, 0x61, 0x34, 0x34, 0x33, 0x62, 0x39, 0x64, 0x37, 0x34, 0x62, 0x30, 0x62, 0x61, 0x35, 0x65, 0x65, 0x37, 0x62, 0x62, 0x34, 0x37, 0x66, 0x64, 0x34, 0x31, 0x38, 0x35, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x62, 0x63, 0x38, 0x35, 0x65, 0x38, 0x37, 0x64, 0x63, 0x33, 0x34, 0x63, 0x34, 0x65, 0x38, 0x30, 0x61, 0x61, 0x66, 0x61, 0x30, 0x36, 0x36, 0x62, 0x61, 0x38, 0x64, 0x32, 0x39, 0x64, 0x62, 0x62, 0x38, 0x65, 0x34, 0x33, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x39, 0x66, 0x34, 0x64, 0x35, 0x65, 0x61, 0x61, 0x36, 0x35, 0x61, 0x32, 0x66, 0x34, 0x63, 0x62, 0x37, 0x35, 0x30, 0x61, 0x34, 0x39, 0x39, 0x32, 0x33, 0x34, 0x30, 0x31, 0x64, 0x61, 0x65, 0x35, 0x39, 0x30, 0x39, 0x30, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x62, 0x64, 0x34, 0x64, 0x62, 0x39, 0x30, 0x31, 0x39, 0x39, 0x35, 0x32, 0x64, 0x36, 0x38, 0x62, 0x31, 0x62, 0x30, 0x66, 0x36, 0x64, 0x38, 0x63, 0x66, 0x30, 0x36, 0x38, 0x33, 0x63, 0x30, 0x30, 0x33, 0x38, 0x37, 0x62, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x32, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x36, 0x34, 0x37, 0x39, 0x62, 0x61, 0x38, 0x65, 0x37, 0x64, 0x66, 0x38, 0x66, 0x36, 0x33, 0x65, 0x31, 0x62, 0x39, 0x35, 0x64, 0x31, 0x34, 0x39, 0x63, 0x64, 0x38, 0x35, 0x32, 0x39, 0x64, 0x37, 0x33, 0x35, 0x63, 0x32, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x36, 0x34, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x62, 0x32, 0x61, 0x63, 0x61, 0x31, 0x35, 0x34, 0x62, 0x38, 0x65, 0x30, 0x37, 0x36, 0x36, 0x63, 0x34, 0x65, 0x62, 0x61, 0x33, 0x30, 0x62, 0x63, 0x31, 0x30, 0x63, 0x37, 0x66, 0x33, 0x35, 0x30, 0x33, 0x36, 0x66, 0x33, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x34, 0x36, 0x34, 0x31, 0x39, 0x37, 0x37, 0x39, 0x31, 0x63, 0x38, 0x61, 0x33, 0x64, 0x61, 0x33, 0x63, 0x39, 0x32, 0x35, 0x34, 0x33, 0x36, 0x66, 0x32, 0x37, 0x37, 0x61, 0x62, 0x31, 0x33, 0x62, 0x66, 0x32, 0x66, 0x61, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x30, 0x61, 0x38, 0x38, 0x61, 0x38, 0x39, 0x39, 0x37, 0x66, 0x39, 0x32, 0x64, 0x32, 0x33, 0x38, 0x33, 0x37, 0x30, 0x66, 0x31, 0x61, 0x66, 0x66, 0x64, 0x65, 0x65, 0x36, 0x33, 0x34, 0x37, 0x30, 0x35, 0x30, 0x62, 0x30, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x64, 0x62, 0x66, 0x61, 0x66, 0x64, 0x38, 0x62, 0x36, 0x32, 0x62, 0x39, 0x32, 0x61, 0x32, 0x34, 0x65, 0x66, 0x64, 0x37, 0x35, 0x32, 0x35, 0x36, 0x64, 0x64, 0x38, 0x33, 0x61, 0x62, 0x64, 0x62, 0x64, 0x37, 0x62, 0x62, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x39, 0x39, 0x33, 0x62, 0x39, 0x36, 0x65, 0x65, 0x39, 0x32, 0x35, 0x61, 0x64, 0x61, 0x37, 0x64, 0x39, 0x39, 0x64, 0x37, 0x38, 0x36, 0x35, 0x37, 0x33, 0x64, 0x33, 0x66, 0x38, 0x39, 0x31, 0x38, 0x30, 0x63, 0x65, 0x33, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x63, 0x33, 0x36, 0x32, 0x62, 0x30, 0x65, 0x66, 0x39, 0x39, 0x31, 0x62, 0x63, 0x38, 0x32, 0x66, 0x62, 0x33, 0x36, 0x65, 0x36, 0x36, 0x66, 0x66, 0x37, 0x35, 0x39, 0x33, 0x32, 0x61, 0x65, 0x38, 0x64, 0x64, 0x38, 0x32, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x32, 0x33, 0x38, 0x32, 0x66, 0x66, 0x64, 0x38, 0x66, 0x38, 0x33, 0x39, 0x35, 0x36, 0x34, 0x36, 0x37, 0x39, 0x33, 0x37, 0x66, 0x39, 0x62, 0x61, 0x37, 0x32, 0x33, 0x37, 0x34, 0x36, 0x32, 0x33, 0x66, 0x31, 0x31, 0x62, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x64, 0x31, 0x61, 0x34, 0x64, 0x30, 0x63, 0x37, 0x35, 0x32, 0x34, 0x65, 0x30, 0x31, 0x38, 0x64, 0x34, 0x65, 0x30, 0x36, 0x65, 0x64, 0x33, 0x62, 0x36, 0x34, 0x38, 0x30, 0x39, 0x32, 0x62, 0x35, 0x62, 0x36, 0x61, 0x66, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x61, 0x37, 0x35, 0x30, 0x65, 0x61, 0x65, 0x35, 0x38, 0x37, 0x34, 0x37, 0x31, 0x31, 0x31, 0x31, 0x36, 0x64, 0x64, 0x37, 0x64, 0x34, 0x37, 0x62, 0x37, 0x31, 0x38, 0x36, 0x63, 0x65, 0x39, 0x39, 0x30, 0x64, 0x33, 0x31, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x65, 0x34, 0x32, 0x61, 0x34, 0x65, 0x33, 0x33, 0x64, 0x37, 0x35, 0x32, 0x36, 0x63, 0x63, 0x61, 0x31, 0x39, 0x64, 0x39, 0x61, 0x33, 0x36, 0x64, 0x63, 0x64, 0x36, 0x65, 0x38, 0x30, 0x34, 0x30, 0x64, 0x30, 0x65, 0x61, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x31, 0x62, 0x32, 0x32, 0x33, 0x30, 0x61, 0x66, 0x62, 0x62, 0x64, 0x33, 0x31, 0x30, 0x62, 0x34, 0x39, 0x32, 0x36, 0x61, 0x34, 0x63, 0x37, 0x37, 0x36, 0x64, 0x35, 0x61, 0x65, 0x37, 0x38, 0x31, 0x39, 0x63, 0x36, 0x36, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x66, 0x39, 0x66, 0x30, 0x64, 0x66, 0x65, 0x65, 0x61, 0x65, 0x62, 0x62, 0x35, 0x66, 0x36, 0x34, 0x62, 0x66, 0x39, 0x31, 0x61, 0x62, 0x37, 0x37, 0x31, 0x36, 0x36, 0x39, 0x62, 0x66, 0x30, 0x35, 0x32, 0x39, 0x35, 0x35, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x65, 0x34, 0x61, 0x32, 0x30, 0x32, 0x37, 0x35, 0x65, 0x33, 0x39, 0x62, 0x64, 0x63, 0x65, 0x66, 0x65, 0x62, 0x36, 0x35, 0x35, 0x63, 0x30, 0x33, 0x32, 0x32, 0x37, 0x34, 0x34, 0x62, 0x37, 0x36, 0x35, 0x31, 0x34, 0x30, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x62, 0x30, 0x38, 0x39, 0x65, 0x63, 0x38, 0x61, 0x37, 0x38, 0x33, 0x33, 0x37, 0x65, 0x38, 0x65, 0x66, 0x38, 0x38, 0x64, 0x65, 0x31, 0x31, 0x62, 0x34, 0x39, 0x65, 0x33, 0x64, 0x64, 0x39, 0x31, 0x30, 0x66, 0x37, 0x34, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x62, 0x63, 0x64, 0x33, 0x30, 0x61, 0x38, 0x66, 0x61, 0x31, 0x33, 0x38, 0x63, 0x35, 0x64, 0x39, 0x65, 0x35, 0x66, 0x36, 0x63, 0x37, 0x64, 0x32, 0x64, 0x61, 0x38, 0x30, 0x36, 0x39, 0x39, 0x32, 0x38, 0x31, 0x32, 0x64, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x38, 0x63, 0x36, 0x30, 0x33, 0x31, 0x33, 0x31, 0x30, 0x36, 0x65, 0x33, 0x66, 0x39, 0x33, 0x33, 0x34, 0x66, 0x65, 0x36, 0x66, 0x37, 0x65, 0x37, 0x36, 0x32, 0x34, 0x64, 0x32, 0x31, 0x31, 0x31, 0x33, 0x30, 0x63, 0x30, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x63, 0x66, 0x66, 0x62, 0x62, 0x61, 0x36, 0x32, 0x34, 0x65, 0x37, 0x65, 0x62, 0x33, 0x32, 0x31, 0x62, 0x63, 0x38, 0x33, 0x63, 0x36, 0x30, 0x63, 0x61, 0x36, 0x38, 0x31, 0x39, 0x39, 0x62, 0x34, 0x65, 0x33, 0x36, 0x36, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x63, 0x32, 0x38, 0x30, 0x33, 0x65, 0x64, 0x37, 0x62, 0x30, 0x65, 0x30, 0x38, 0x33, 0x37, 0x33, 0x35, 0x31, 0x34, 0x31, 0x31, 0x61, 0x38, 0x65, 0x36, 0x36, 0x33, 0x37, 0x64, 0x31, 0x36, 0x38, 0x62, 0x63, 0x35, 0x62, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x34, 0x39, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x33, 0x36, 0x36, 0x35, 0x64, 0x34, 0x38, 0x65, 0x39, 0x66, 0x31, 0x34, 0x31, 0x39, 0x63, 0x64, 0x39, 0x38, 0x34, 0x66, 0x63, 0x37, 0x66, 0x61, 0x39, 0x32, 0x37, 0x38, 0x38, 0x37, 0x31, 0x30, 0x63, 0x38, 0x66, 0x32, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x38, 0x39, 0x32, 0x31, 0x63, 0x39, 0x36, 0x38, 0x37, 0x64, 0x35, 0x35, 0x31, 0x30, 0x37, 0x34, 0x34, 0x35, 0x38, 0x34, 0x39, 0x33, 0x36, 0x65, 0x38, 0x38, 0x38, 0x36, 0x62, 0x64, 0x62, 0x66, 0x32, 0x64, 0x66, 0x36, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x34, 0x62, 0x62, 0x62, 0x38, 0x32, 0x31, 0x34, 0x63, 0x66, 0x38, 0x64, 0x61, 0x30, 0x63, 0x32, 0x66, 0x36, 0x36, 0x38, 0x61, 0x32, 0x61, 0x63, 0x37, 0x33, 0x65, 0x38, 0x36, 0x32, 0x34, 0x38, 0x35, 0x32, 0x38, 0x64, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x30, 0x63, 0x32, 0x61, 0x38, 0x30, 0x62, 0x39, 0x64, 0x65, 0x30, 0x38, 0x34, 0x62, 0x31, 0x37, 0x32, 0x38, 0x39, 0x34, 0x61, 0x37, 0x36, 0x63, 0x66, 0x34, 0x37, 0x33, 0x37, 0x61, 0x34, 0x66, 0x35, 0x32, 0x39, 0x65, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x66, 0x31, 0x39, 0x39, 0x66, 0x38, 0x62, 0x38, 0x35, 0x34, 0x32, 0x32, 0x32, 0x66, 0x31, 0x38, 0x32, 0x65, 0x34, 0x65, 0x31, 0x64, 0x30, 0x39, 0x39, 0x64, 0x34, 0x65, 0x33, 0x32, 0x33, 0x65, 0x32, 0x61, 0x61, 0x65, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x32, 0x64, 0x66, 0x62, 0x34, 0x35, 0x64, 0x65, 0x35, 0x64, 0x37, 0x34, 0x65, 0x33, 0x64, 0x66, 0x32, 0x30, 0x38, 0x33, 0x33, 0x32, 0x62, 0x63, 0x35, 0x37, 0x31, 0x63, 0x38, 0x30, 0x39, 0x62, 0x38, 0x64, 0x63, 0x66, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x34, 0x38, 0x31, 0x39, 0x64, 0x32, 0x65, 0x34, 0x34, 0x64, 0x36, 0x65, 0x64, 0x31, 0x64, 0x61, 0x32, 0x35, 0x62, 0x66, 0x63, 0x65, 0x38, 0x34, 0x63, 0x34, 0x39, 0x66, 0x63, 0x63, 0x61, 0x32, 0x35, 0x36, 0x31, 0x33, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x66, 0x36, 0x63, 0x63, 0x39, 0x30, 0x64, 0x36, 0x34, 0x39, 0x64, 0x65, 0x34, 0x65, 0x39, 0x36, 0x63, 0x66, 0x66, 0x65, 0x65, 0x31, 0x30, 0x37, 0x37, 0x61, 0x35, 0x62, 0x33, 0x30, 0x32, 0x61, 0x38, 0x34, 0x38, 0x64, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x39, 0x63, 0x37, 0x37, 0x64, 0x30, 0x37, 0x35, 0x30, 0x63, 0x35, 0x65, 0x36, 0x66, 0x62, 0x63, 0x32, 0x34, 0x37, 0x66, 0x32, 0x66, 0x64, 0x37, 0x39, 0x32, 0x37, 0x34, 0x36, 0x38, 0x36, 0x63, 0x62, 0x33, 0x35, 0x33, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x65, 0x38, 0x30, 0x32, 0x32, 0x37, 0x34, 0x30, 0x66, 0x34, 0x61, 0x66, 0x32, 0x39, 0x65, 0x62, 0x34, 0x38, 0x64, 0x62, 0x33, 0x32, 0x62, 0x63, 0x65, 0x63, 0x64, 0x64, 0x66, 0x64, 0x31, 0x34, 0x38, 0x64, 0x33, 0x64, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x62, 0x36, 0x31, 0x35, 0x30, 0x37, 0x33, 0x61, 0x34, 0x30, 0x64, 0x63, 0x64, 0x62, 0x39, 0x39, 0x66, 0x61, 0x61, 0x38, 0x34, 0x38, 0x35, 0x37, 0x32, 0x65, 0x39, 0x38, 0x37, 0x62, 0x33, 0x62, 0x30, 0x35, 0x36, 0x65, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x61, 0x64, 0x63, 0x63, 0x65, 0x65, 0x63, 0x35, 0x33, 0x64, 0x64, 0x39, 0x64, 0x39, 0x64, 0x64, 0x31, 0x35, 0x63, 0x38, 0x63, 0x63, 0x31, 0x61, 0x39, 0x65, 0x37, 0x33, 0x36, 0x64, 0x65, 0x34, 0x32, 0x34, 0x31, 0x64, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x65, 0x63, 0x38, 0x30, 0x39, 0x64, 0x66, 0x39, 0x33, 0x32, 0x35, 0x62, 0x39, 0x66, 0x34, 0x38, 0x33, 0x39, 0x39, 0x36, 0x65, 0x39, 0x39, 0x66, 0x37, 0x33, 0x33, 0x31, 0x30, 0x39, 0x37, 0x66, 0x30, 0x38, 0x61, 0x61, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x38, 0x63, 0x32, 0x66, 0x35, 0x34, 0x66, 0x66, 0x38, 0x65, 0x36, 0x32, 0x39, 0x62, 0x61, 0x62, 0x33, 0x36, 0x62, 0x31, 0x34, 0x34, 0x32, 0x62, 0x37, 0x36, 0x30, 0x62, 0x31, 0x32, 0x61, 0x38, 0x38, 0x66, 0x30, 0x32, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x33, 0x35, 0x33, 0x39, 0x39, 0x30, 0x37, 0x31, 0x61, 0x34, 0x61, 0x31, 0x30, 0x31, 0x65, 0x39, 0x31, 0x39, 0x34, 0x64, 0x61, 0x61, 0x33, 0x66, 0x30, 0x39, 0x66, 0x30, 0x34, 0x61, 0x30, 0x62, 0x35, 0x66, 0x39, 0x38, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x63, 0x33, 0x33, 0x36, 0x30, 0x38, 0x33, 0x62, 0x30, 0x34, 0x66, 0x39, 0x34, 0x37, 0x31, 0x62, 0x38, 0x63, 0x36, 0x65, 0x64, 0x37, 0x33, 0x36, 0x37, 0x39, 0x62, 0x37, 0x34, 0x64, 0x36, 0x36, 0x63, 0x33, 0x36, 0x33, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x31, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x64, 0x33, 0x66, 0x33, 0x30, 0x37, 0x36, 0x31, 0x36, 0x66, 0x31, 0x39, 0x64, 0x63, 0x62, 0x31, 0x34, 0x33, 0x65, 0x36, 0x34, 0x34, 0x34, 0x64, 0x61, 0x62, 0x39, 0x63, 0x33, 0x63, 0x33, 0x33, 0x36, 0x31, 0x31, 0x66, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x35, 0x63, 0x62, 0x38, 0x65, 0x65, 0x33, 0x39, 0x66, 0x66, 0x62, 0x63, 0x37, 0x35, 0x32, 0x33, 0x33, 0x31, 0x65, 0x35, 0x61, 0x65, 0x66, 0x63, 0x35, 0x38, 0x38, 0x65, 0x66, 0x30, 0x65, 0x65, 0x35, 0x39, 0x33, 0x34, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x63, 0x30, 0x31, 0x61, 0x66, 0x63, 0x33, 0x65, 0x30, 0x66, 0x30, 0x34, 0x35, 0x32, 0x32, 0x31, 0x64, 0x61, 0x31, 0x32, 0x38, 0x34, 0x64, 0x37, 0x38, 0x37, 0x38, 0x35, 0x37, 0x34, 0x34, 0x34, 0x32, 0x66, 0x62, 0x39, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x31, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x32, 0x36, 0x38, 0x33, 0x32, 0x37, 0x63, 0x33, 0x37, 0x33, 0x33, 0x33, 0x32, 0x65, 0x30, 0x36, 0x63, 0x33, 0x66, 0x36, 0x31, 0x36, 0x34, 0x32, 0x38, 0x37, 0x64, 0x34, 0x35, 0x35, 0x62, 0x39, 0x64, 0x35, 0x66, 0x61, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x36, 0x37, 0x61, 0x65, 0x34, 0x62, 0x30, 0x63, 0x65, 0x39, 0x36, 0x34, 0x66, 0x34, 0x61, 0x35, 0x34, 0x61, 0x66, 0x64, 0x34, 0x62, 0x35, 0x63, 0x33, 0x36, 0x38, 0x34, 0x39, 0x36, 0x64, 0x62, 0x31, 0x36, 0x39, 0x65, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x64, 0x37, 0x39, 0x65, 0x62, 0x35, 0x32, 0x30, 0x32, 0x37, 0x62, 0x31, 0x32, 0x63, 0x31, 0x38, 0x38, 0x32, 0x38, 0x65, 0x33, 0x65, 0x61, 0x61, 0x62, 0x32, 0x39, 0x36, 0x39, 0x62, 0x66, 0x63, 0x64, 0x32, 0x38, 0x37, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x36, 0x38, 0x34, 0x31, 0x63, 0x61, 0x62, 0x62, 0x63, 0x37, 0x64, 0x62, 0x64, 0x36, 0x39, 0x65, 0x66, 0x30, 0x63, 0x66, 0x38, 0x66, 0x38, 0x31, 0x64, 0x66, 0x66, 0x33, 0x63, 0x38, 0x61, 0x35, 0x65, 0x32, 0x31, 0x35, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x65, 0x62, 0x64, 0x64, 0x62, 0x39, 0x66, 0x39, 0x33, 0x39, 0x38, 0x37, 0x37, 0x37, 0x39, 0x62, 0x36, 0x38, 0x30, 0x31, 0x35, 0x35, 0x33, 0x37, 0x35, 0x34, 0x33, 0x38, 0x64, 0x62, 0x36, 0x35, 0x61, 0x66, 0x63, 0x62, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x33, 0x31, 0x64, 0x31, 0x38, 0x62, 0x62, 0x62, 0x62, 0x64, 0x33, 0x30, 0x64, 0x39, 0x65, 0x31, 0x37, 0x33, 0x32, 0x62, 0x66, 0x33, 0x36, 0x65, 0x64, 0x61, 0x65, 0x32, 0x63, 0x65, 0x38, 0x39, 0x30, 0x31, 0x61, 0x62, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x32, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x61, 0x64, 0x39, 0x36, 0x30, 0x66, 0x36, 0x62, 0x32, 0x63, 0x38, 0x34, 0x35, 0x36, 0x39, 0x63, 0x39, 0x66, 0x34, 0x64, 0x34, 0x37, 0x62, 0x66, 0x31, 0x39, 0x38, 0x35, 0x66, 0x63, 0x62, 0x32, 0x63, 0x36, 0x35, 0x64, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x64, 0x35, 0x39, 0x39, 0x65, 0x65, 0x30, 0x64, 0x35, 0x66, 0x38, 0x63, 0x33, 0x38, 0x61, 0x62, 0x32, 0x64, 0x33, 0x39, 0x32, 0x65, 0x32, 0x63, 0x36, 0x35, 0x62, 0x37, 0x34, 0x63, 0x33, 0x63, 0x65, 0x33, 0x31, 0x38, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x30, 0x63, 0x63, 0x38, 0x64, 0x61, 0x63, 0x38, 0x32, 0x34, 0x66, 0x61, 0x32, 0x34, 0x66, 0x63, 0x33, 0x63, 0x61, 0x61, 0x32, 0x31, 0x36, 0x39, 0x65, 0x36, 0x65, 0x30, 0x35, 0x37, 0x63, 0x66, 0x36, 0x33, 0x38, 0x61, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x35, 0x32, 0x36, 0x36, 0x63, 0x37, 0x36, 0x37, 0x36, 0x36, 0x33, 0x32, 0x66, 0x31, 0x33, 0x65, 0x66, 0x32, 0x39, 0x62, 0x65, 0x34, 0x35, 0x35, 0x65, 0x64, 0x39, 0x34, 0x38, 0x61, 0x64, 0x64, 0x35, 0x36, 0x37, 0x37, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x33, 0x34, 0x34, 0x30, 0x39, 0x38, 0x62, 0x61, 0x36, 0x31, 0x35, 0x61, 0x33, 0x39, 0x38, 0x66, 0x31, 0x31, 0x64, 0x30, 0x30, 0x39, 0x39, 0x30, 0x35, 0x62, 0x31, 0x37, 0x37, 0x63, 0x34, 0x34, 0x61, 0x37, 0x62, 0x36, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x30, 0x61, 0x63, 0x63, 0x61, 0x66, 0x34, 0x62, 0x36, 0x30, 0x37, 0x63, 0x66, 0x65, 0x36, 0x31, 0x64, 0x31, 0x37, 0x33, 0x33, 0x34, 0x63, 0x32, 0x31, 0x34, 0x62, 0x37, 0x35, 0x63, 0x64, 0x65, 0x66, 0x64, 0x62, 0x64, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x36, 0x36, 0x33, 0x34, 0x62, 0x35, 0x62, 0x38, 0x61, 0x34, 0x30, 0x31, 0x39, 0x35, 0x64, 0x39, 0x34, 0x39, 0x30, 0x32, 0x37, 0x61, 0x66, 0x34, 0x38, 0x32, 0x38, 0x38, 0x30, 0x32, 0x30, 0x39, 0x32, 0x63, 0x65, 0x65, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x38, 0x63, 0x34, 0x35, 0x37, 0x33, 0x32, 0x63, 0x30, 0x61, 0x33, 0x37, 0x38, 0x66, 0x31, 0x37, 0x61, 0x63, 0x38, 0x33, 0x32, 0x34, 0x39, 0x32, 0x36, 0x64, 0x34, 0x35, 0x39, 0x62, 0x61, 0x38, 0x62, 0x36, 0x35, 0x38, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x34, 0x33, 0x39, 0x39, 0x62, 0x34, 0x62, 0x66, 0x38, 0x36, 0x66, 0x37, 0x33, 0x33, 0x38, 0x66, 0x62, 0x66, 0x36, 0x34, 0x35, 0x65, 0x33, 0x62, 0x32, 0x32, 0x62, 0x30, 0x65, 0x30, 0x62, 0x37, 0x39, 0x37, 0x33, 0x39, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x37, 0x36, 0x33, 0x64, 0x64, 0x36, 0x64, 0x61, 0x39, 0x61, 0x37, 0x63, 0x31, 0x36, 0x31, 0x31, 0x37, 0x33, 0x38, 0x38, 0x38, 0x33, 0x32, 0x31, 0x65, 0x62, 0x61, 0x36, 0x62, 0x36, 0x33, 0x63, 0x38, 0x66, 0x62, 0x38, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x32, 0x66, 0x64, 0x35, 0x34, 0x30, 0x38, 0x39, 0x61, 0x66, 0x36, 0x36, 0x35, 0x64, 0x66, 0x35, 0x39, 0x37, 0x31, 0x64, 0x37, 0x33, 0x62, 0x38, 0x30, 0x34, 0x36, 0x31, 0x36, 0x30, 0x33, 0x39, 0x36, 0x34, 0x37, 0x33, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x30, 0x39, 0x36, 0x34, 0x36, 0x63, 0x39, 0x39, 0x61, 0x66, 0x34, 0x33, 0x38, 0x65, 0x39, 0x39, 0x66, 0x61, 0x32, 0x37, 0x34, 0x63, 0x62, 0x32, 0x66, 0x39, 0x63, 0x38, 0x35, 0x36, 0x63, 0x62, 0x36, 0x35, 0x66, 0x37, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x37, 0x33, 0x32, 0x37, 0x34, 0x64, 0x38, 0x63, 0x35, 0x61, 0x61, 0x34, 0x34, 0x61, 0x33, 0x63, 0x62, 0x65, 0x66, 0x63, 0x38, 0x32, 0x36, 0x33, 0x63, 0x33, 0x37, 0x62, 0x61, 0x31, 0x32, 0x31, 0x62, 0x32, 0x30, 0x61, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x66, 0x64, 0x30, 0x30, 0x34, 0x64, 0x30, 0x32, 0x66, 0x33, 0x36, 0x63, 0x64, 0x34, 0x64, 0x38, 0x62, 0x34, 0x61, 0x38, 0x63, 0x31, 0x61, 0x39, 0x35, 0x33, 0x33, 0x62, 0x36, 0x61, 0x66, 0x38, 0x35, 0x63, 0x64, 0x37, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x37, 0x38, 0x62, 0x30, 0x32, 0x35, 0x62, 0x36, 0x34, 0x32, 0x33, 0x33, 0x35, 0x35, 0x35, 0x63, 0x63, 0x33, 0x63, 0x31, 0x39, 0x61, 0x64, 0x61, 0x37, 0x66, 0x34, 0x31, 0x39, 0x39, 0x63, 0x39, 0x33, 0x34, 0x38, 0x62, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x35, 0x64, 0x64, 0x64, 0x33, 0x38, 0x33, 0x35, 0x35, 0x34, 0x38, 0x32, 0x62, 0x38, 0x63, 0x37, 0x64, 0x33, 0x62, 0x35, 0x31, 0x35, 0x62, 0x64, 0x61, 0x31, 0x35, 0x30, 0x30, 0x64, 0x64, 0x37, 0x64, 0x37, 0x61, 0x38, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x38, 0x61, 0x30, 0x64, 0x65, 0x65, 0x35, 0x63, 0x62, 0x30, 0x65, 0x31, 0x65, 0x39, 0x37, 0x65, 0x31, 0x35, 0x63, 0x66, 0x63, 0x61, 0x36, 0x65, 0x31, 0x39, 0x61, 0x64, 0x32, 0x31, 0x66, 0x39, 0x39, 0x35, 0x65, 0x66, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x34, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x39, 0x38, 0x63, 0x63, 0x32, 0x30, 0x65, 0x66, 0x38, 0x34, 0x62, 0x61, 0x64, 0x35, 0x31, 0x34, 0x36, 0x36, 0x33, 0x39, 0x63, 0x34, 0x63, 0x64, 0x31, 0x63, 0x61, 0x36, 0x63, 0x33, 0x39, 0x39, 0x36, 0x63, 0x62, 0x39, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x64, 0x61, 0x63, 0x35, 0x63, 0x31, 0x63, 0x62, 0x35, 0x36, 0x65, 0x32, 0x34, 0x35, 0x62, 0x66, 0x37, 0x30, 0x33, 0x33, 0x30, 0x30, 0x36, 0x36, 0x61, 0x38, 0x31, 0x37, 0x65, 0x61, 0x61, 0x66, 0x61, 0x63, 0x34, 0x63, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x30, 0x65, 0x39, 0x39, 0x36, 0x35, 0x34, 0x33, 0x33, 0x34, 0x34, 0x63, 0x36, 0x38, 0x31, 0x35, 0x66, 0x62, 0x39, 0x37, 0x63, 0x64, 0x61, 0x37, 0x61, 0x66, 0x34, 0x62, 0x38, 0x36, 0x39, 0x38, 0x37, 0x36, 0x35, 0x61, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x36, 0x31, 0x32, 0x37, 0x38, 0x31, 0x30, 0x33, 0x33, 0x62, 0x35, 0x37, 0x62, 0x31, 0x34, 0x36, 0x65, 0x65, 0x37, 0x34, 0x65, 0x37, 0x35, 0x33, 0x63, 0x36, 0x37, 0x32, 0x30, 0x31, 0x37, 0x66, 0x35, 0x33, 0x38, 0x35, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x33, 0x66, 0x63, 0x31, 0x36, 0x35, 0x35, 0x37, 0x36, 0x61, 0x61, 0x65, 0x64, 0x35, 0x32, 0x35, 0x65, 0x35, 0x35, 0x30, 0x32, 0x63, 0x38, 0x65, 0x31, 0x34, 0x30, 0x66, 0x38, 0x62, 0x32, 0x65, 0x38, 0x36, 0x39, 0x36, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x33, 0x33, 0x38, 0x34, 0x63, 0x34, 0x32, 0x62, 0x36, 0x66, 0x38, 0x66, 0x32, 0x39, 0x30, 0x35, 0x63, 0x65, 0x35, 0x32, 0x62, 0x37, 0x32, 0x30, 0x35, 0x63, 0x32, 0x32, 0x37, 0x34, 0x33, 0x37, 0x36, 0x63, 0x36, 0x31, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x65, 0x65, 0x31, 0x32, 0x62, 0x31, 0x62, 0x34, 0x32, 0x62, 0x30, 0x35, 0x61, 0x66, 0x39, 0x63, 0x66, 0x32, 0x30, 0x37, 0x64, 0x35, 0x66, 0x63, 0x61, 0x63, 0x32, 0x35, 0x35, 0x62, 0x32, 0x65, 0x63, 0x34, 0x31, 0x31, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x39, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x64, 0x37, 0x31, 0x65, 0x66, 0x61, 0x34, 0x62, 0x39, 0x33, 0x63, 0x38, 0x38, 0x39, 0x65, 0x37, 0x36, 0x35, 0x39, 0x33, 0x64, 0x65, 0x36, 0x30, 0x39, 0x63, 0x33, 0x62, 0x30, 0x34, 0x63, 0x62, 0x61, 0x66, 0x62, 0x65, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x38, 0x36, 0x63, 0x61, 0x32, 0x37, 0x62, 0x66, 0x32, 0x38, 0x35, 0x34, 0x64, 0x39, 0x38, 0x38, 0x37, 0x30, 0x38, 0x33, 0x37, 0x66, 0x62, 0x36, 0x66, 0x36, 0x64, 0x66, 0x65, 0x34, 0x62, 0x66, 0x36, 0x34, 0x35, 0x33, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x66, 0x66, 0x38, 0x65, 0x36, 0x37, 0x62, 0x33, 0x34, 0x64, 0x39, 0x65, 0x65, 0x36, 0x66, 0x37, 0x38, 0x65, 0x62, 0x33, 0x36, 0x66, 0x66, 0x65, 0x61, 0x31, 0x62, 0x39, 0x66, 0x37, 0x63, 0x31, 0x35, 0x37, 0x38, 0x37, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x34, 0x63, 0x62, 0x66, 0x33, 0x64, 0x38, 0x32, 0x38, 0x34, 0x38, 0x33, 0x33, 0x61, 0x65, 0x39, 0x39, 0x33, 0x34, 0x34, 0x33, 0x30, 0x33, 0x65, 0x30, 0x38, 0x62, 0x34, 0x64, 0x36, 0x31, 0x34, 0x62, 0x66, 0x64, 0x61, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x66, 0x31, 0x36, 0x30, 0x63, 0x34, 0x34, 0x66, 0x37, 0x32, 0x61, 0x32, 0x39, 0x39, 0x62, 0x35, 0x65, 0x63, 0x32, 0x64, 0x37, 0x31, 0x65, 0x32, 0x38, 0x63, 0x65, 0x35, 0x34, 0x34, 0x36, 0x64, 0x32, 0x66, 0x63, 0x62, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x61, 0x37, 0x63, 0x64, 0x61, 0x38, 0x66, 0x34, 0x38, 0x31, 0x66, 0x39, 0x64, 0x38, 0x39, 0x64, 0x34, 0x32, 0x63, 0x33, 0x30, 0x33, 0x61, 0x65, 0x31, 0x36, 0x33, 0x32, 0x62, 0x33, 0x62, 0x37, 0x30, 0x39, 0x64, 0x62, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x36, 0x36, 0x34, 0x39, 0x36, 0x31, 0x36, 0x32, 0x62, 0x61, 0x35, 0x38, 0x34, 0x33, 0x37, 0x37, 0x62, 0x65, 0x30, 0x34, 0x30, 0x61, 0x34, 0x66, 0x38, 0x37, 0x37, 0x37, 0x37, 0x61, 0x37, 0x30, 0x37, 0x61, 0x63, 0x61, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x63, 0x34, 0x36, 0x31, 0x34, 0x36, 0x32, 0x62, 0x36, 0x33, 0x32, 0x32, 0x62, 0x34, 0x36, 0x32, 0x62, 0x64, 0x62, 0x33, 0x33, 0x66, 0x32, 0x32, 0x37, 0x39, 0x39, 0x65, 0x38, 0x31, 0x30, 0x38, 0x65, 0x32, 0x34, 0x31, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x34, 0x37, 0x36, 0x33, 0x37, 0x65, 0x39, 0x37, 0x63, 0x31, 0x34, 0x36, 0x32, 0x32, 0x38, 0x38, 0x32, 0x62, 0x65, 0x30, 0x35, 0x37, 0x62, 0x65, 0x61, 0x32, 0x32, 0x39, 0x33, 0x38, 0x36, 0x66, 0x34, 0x30, 0x35, 0x32, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x35, 0x63, 0x32, 0x35, 0x31, 0x64, 0x37, 0x66, 0x64, 0x37, 0x38, 0x39, 0x33, 0x62, 0x61, 0x32, 0x30, 0x39, 0x66, 0x65, 0x35, 0x34, 0x31, 0x63, 0x65, 0x63, 0x64, 0x30, 0x63, 0x65, 0x32, 0x35, 0x33, 0x61, 0x39, 0x39, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x34, 0x39, 0x38, 0x38, 0x30, 0x30, 0x34, 0x34, 0x37, 0x31, 0x37, 0x37, 0x62, 0x38, 0x63, 0x38, 0x61, 0x66, 0x63, 0x33, 0x66, 0x64, 0x66, 0x61, 0x37, 0x66, 0x36, 0x39, 0x66, 0x34, 0x30, 0x35, 0x31, 0x62, 0x62, 0x36, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x34, 0x30, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x31, 0x36, 0x32, 0x33, 0x66, 0x33, 0x35, 0x31, 0x30, 0x37, 0x63, 0x66, 0x37, 0x34, 0x33, 0x31, 0x61, 0x38, 0x33, 0x66, 0x62, 0x33, 0x64, 0x32, 0x30, 0x34, 0x62, 0x32, 0x39, 0x65, 0x65, 0x30, 0x62, 0x31, 0x61, 0x37, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x33, 0x39, 0x35, 0x62, 0x33, 0x30, 0x61, 0x64, 0x64, 0x61, 0x31, 0x63, 0x66, 0x32, 0x31, 0x66, 0x30, 0x39, 0x31, 0x61, 0x34, 0x66, 0x34, 0x61, 0x37, 0x62, 0x37, 0x35, 0x33, 0x33, 0x37, 0x31, 0x31, 0x38, 0x39, 0x34, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x32, 0x34, 0x32, 0x38, 0x65, 0x34, 0x61, 0x36, 0x36, 0x39, 0x37, 0x34, 0x65, 0x64, 0x63, 0x38, 0x32, 0x32, 0x64, 0x35, 0x64, 0x62, 0x66, 0x62, 0x32, 0x34, 0x31, 0x62, 0x32, 0x37, 0x32, 0x38, 0x30, 0x37, 0x35, 0x31, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x37, 0x35, 0x66, 0x32, 0x38, 0x39, 0x31, 0x64, 0x63, 0x66, 0x63, 0x64, 0x61, 0x38, 0x33, 0x63, 0x35, 0x63, 0x66, 0x30, 0x31, 0x34, 0x37, 0x34, 0x61, 0x66, 0x31, 0x31, 0x65, 0x65, 0x30, 0x31, 0x62, 0x37, 0x32, 0x64, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x37, 0x32, 0x38, 0x31, 0x32, 0x31, 0x38, 0x37, 0x33, 0x66, 0x30, 0x34, 0x35, 0x36, 0x64, 0x30, 0x35, 0x31, 0x38, 0x62, 0x38, 0x30, 0x61, 0x62, 0x36, 0x35, 0x38, 0x30, 0x61, 0x32, 0x30, 0x33, 0x37, 0x30, 0x36, 0x35, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x36, 0x36, 0x39, 0x65, 0x62, 0x35, 0x61, 0x38, 0x30, 0x31, 0x64, 0x38, 0x62, 0x37, 0x35, 0x66, 0x62, 0x36, 0x61, 0x61, 0x35, 0x38, 0x63, 0x33, 0x34, 0x35, 0x31, 0x62, 0x37, 0x30, 0x35, 0x38, 0x63, 0x32, 0x34, 0x33, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x61, 0x65, 0x35, 0x34, 0x66, 0x62, 0x61, 0x30, 0x39, 0x64, 0x33, 0x65, 0x65, 0x31, 0x64, 0x36, 0x62, 0x64, 0x64, 0x31, 0x65, 0x39, 0x35, 0x37, 0x39, 0x32, 0x33, 0x39, 0x31, 0x39, 0x30, 0x32, 0x34, 0x63, 0x33, 0x35, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x35, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x33, 0x35, 0x34, 0x30, 0x38, 0x66, 0x32, 0x32, 0x36, 0x35, 0x36, 0x36, 0x31, 0x31, 0x36, 0x66, 0x62, 0x38, 0x61, 0x63, 0x64, 0x61, 0x61, 0x39, 0x65, 0x32, 0x63, 0x39, 0x64, 0x35, 0x39, 0x62, 0x37, 0x36, 0x36, 0x38, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x32, 0x31, 0x31, 0x63, 0x64, 0x32, 0x31, 0x32, 0x38, 0x38, 0x64, 0x36, 0x63, 0x35, 0x36, 0x66, 0x61, 0x65, 0x36, 0x36, 0x63, 0x33, 0x66, 0x66, 0x35, 0x34, 0x36, 0x32, 0x35, 0x64, 0x64, 0x34, 0x62, 0x31, 0x35, 0x34, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x37, 0x34, 0x36, 0x63, 0x35, 0x64, 0x36, 0x37, 0x30, 0x36, 0x34, 0x37, 0x31, 0x31, 0x62, 0x66, 0x63, 0x61, 0x36, 0x38, 0x35, 0x62, 0x39, 0x35, 0x61, 0x34, 0x66, 0x65, 0x32, 0x39, 0x31, 0x61, 0x32, 0x37, 0x30, 0x32, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x66, 0x31, 0x30, 0x35, 0x61, 0x62, 0x32, 0x33, 0x30, 0x32, 0x33, 0x62, 0x35, 0x35, 0x34, 0x63, 0x35, 0x38, 0x33, 0x65, 0x38, 0x36, 0x64, 0x37, 0x39, 0x32, 0x31, 0x31, 0x37, 0x39, 0x65, 0x65, 0x38, 0x33, 0x31, 0x36, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x66, 0x65, 0x64, 0x65, 0x66, 0x31, 0x39, 0x38, 0x64, 0x62, 0x30, 0x61, 0x39, 0x31, 0x34, 0x33, 0x66, 0x30, 0x39, 0x31, 0x32, 0x39, 0x62, 0x33, 0x66, 0x64, 0x36, 0x34, 0x64, 0x63, 0x62, 0x62, 0x39, 0x62, 0x34, 0x39, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x33, 0x38, 0x31, 0x61, 0x64, 0x63, 0x66, 0x38, 0x30, 0x31, 0x61, 0x33, 0x62, 0x66, 0x39, 0x66, 0x64, 0x37, 0x62, 0x66, 0x61, 0x63, 0x39, 0x63, 0x63, 0x63, 0x32, 0x62, 0x38, 0x34, 0x38, 0x32, 0x61, 0x64, 0x35, 0x65, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x34, 0x36, 0x30, 0x38, 0x66, 0x35, 0x30, 0x36, 0x38, 0x36, 0x36, 0x61, 0x64, 0x61, 0x36, 0x62, 0x66, 0x62, 0x66, 0x64, 0x66, 0x32, 0x30, 0x66, 0x65, 0x61, 0x34, 0x34, 0x30, 0x62, 0x65, 0x37, 0x36, 0x39, 0x38, 0x39, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x65, 0x36, 0x33, 0x39, 0x38, 0x39, 0x63, 0x61, 0x31, 0x65, 0x39, 0x30, 0x33, 0x62, 0x63, 0x36, 0x32, 0x30, 0x63, 0x66, 0x31, 0x62, 0x39, 0x63, 0x33, 0x66, 0x36, 0x37, 0x62, 0x39, 0x65, 0x32, 0x61, 0x65, 0x36, 0x35, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x30, 0x38, 0x35, 0x37, 0x66, 0x31, 0x63, 0x39, 0x31, 0x31, 0x62, 0x32, 0x34, 0x62, 0x38, 0x36, 0x63, 0x38, 0x61, 0x37, 0x30, 0x36, 0x38, 0x31, 0x34, 0x37, 0x33, 0x66, 0x65, 0x36, 0x61, 0x61, 0x61, 0x31, 0x63, 0x63, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x38, 0x65, 0x38, 0x64, 0x32, 0x37, 0x34, 0x66, 0x62, 0x32, 0x32, 0x61, 0x33, 0x66, 0x64, 0x33, 0x36, 0x61, 0x34, 0x37, 0x66, 0x65, 0x37, 0x32, 0x39, 0x38, 0x30, 0x34, 0x37, 0x31, 0x35, 0x34, 0x34, 0x62, 0x33, 0x34, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x37, 0x64, 0x33, 0x66, 0x63, 0x35, 0x30, 0x30, 0x33, 0x62, 0x66, 0x36, 0x33, 0x63, 0x30, 0x64, 0x38, 0x33, 0x65, 0x39, 0x33, 0x39, 0x35, 0x37, 0x38, 0x33, 0x36, 0x35, 0x31, 0x35, 0x66, 0x64, 0x32, 0x37, 0x39, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x38, 0x30, 0x39, 0x65, 0x38, 0x64, 0x61, 0x33, 0x66, 0x62, 0x65, 0x34, 0x62, 0x37, 0x66, 0x32, 0x38, 0x31, 0x66, 0x30, 0x62, 0x38, 0x62, 0x31, 0x37, 0x31, 0x35, 0x66, 0x34, 0x32, 0x30, 0x66, 0x37, 0x64, 0x37, 0x64, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x39, 0x30, 0x34, 0x62, 0x62, 0x37, 0x63, 0x34, 0x33, 0x30, 0x32, 0x39, 0x34, 0x33, 0x62, 0x37, 0x30, 0x39, 0x62, 0x31, 0x34, 0x64, 0x37, 0x39, 0x37, 0x30, 0x65, 0x34, 0x32, 0x62, 0x38, 0x33, 0x32, 0x34, 0x65, 0x31, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x32, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x37, 0x65, 0x33, 0x38, 0x36, 0x37, 0x61, 0x64, 0x61, 0x30, 0x39, 0x36, 0x38, 0x30, 0x37, 0x61, 0x30, 0x35, 0x31, 0x61, 0x36, 0x63, 0x39, 0x63, 0x33, 0x34, 0x63, 0x63, 0x33, 0x62, 0x33, 0x66, 0x34, 0x61, 0x64, 0x33, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x38, 0x38, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x62, 0x34, 0x36, 0x39, 0x65, 0x61, 0x65, 0x38, 0x39, 0x64, 0x34, 0x30, 0x30, 0x63, 0x65, 0x37, 0x64, 0x35, 0x64, 0x36, 0x36, 0x61, 0x39, 0x36, 0x39, 0x35, 0x30, 0x33, 0x37, 0x30, 0x33, 0x36, 0x62, 0x38, 0x38, 0x39, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x34, 0x35, 0x32, 0x30, 0x32, 0x66, 0x30, 0x63, 0x37, 0x34, 0x32, 0x39, 0x37, 0x61, 0x30, 0x30, 0x34, 0x65, 0x62, 0x33, 0x37, 0x32, 0x36, 0x61, 0x61, 0x36, 0x61, 0x38, 0x32, 0x64, 0x64, 0x37, 0x63, 0x30, 0x32, 0x66, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x38, 0x66, 0x36, 0x32, 0x66, 0x65, 0x65, 0x39, 0x37, 0x31, 0x31, 0x65, 0x36, 0x61, 0x30, 0x35, 0x64, 0x63, 0x30, 0x39, 0x31, 0x30, 0x62, 0x36, 0x31, 0x38, 0x34, 0x32, 0x30, 0x61, 0x61, 0x31, 0x32, 0x37, 0x66, 0x32, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x31, 0x64, 0x36, 0x35, 0x63, 0x35, 0x31, 0x38, 0x62, 0x31, 0x31, 0x64, 0x30, 0x65, 0x33, 0x66, 0x34, 0x66, 0x34, 0x37, 0x30, 0x32, 0x32, 0x31, 0x34, 0x31, 0x37, 0x30, 0x31, 0x33, 0x63, 0x38, 0x65, 0x35, 0x33, 0x65, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x30, 0x31, 0x30, 0x66, 0x63, 0x38, 0x62, 0x61, 0x66, 0x38, 0x34, 0x33, 0x37, 0x64, 0x31, 0x37, 0x61, 0x30, 0x34, 0x33, 0x36, 0x39, 0x38, 0x30, 0x39, 0x61, 0x31, 0x36, 0x38, 0x61, 0x31, 0x37, 0x63, 0x61, 0x35, 0x36, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x39, 0x39, 0x38, 0x31, 0x34, 0x34, 0x39, 0x36, 0x38, 0x61, 0x35, 0x63, 0x37, 0x30, 0x61, 0x36, 0x34, 0x31, 0x35, 0x35, 0x35, 0x34, 0x63, 0x65, 0x66, 0x65, 0x63, 0x32, 0x38, 0x32, 0x34, 0x36, 0x39, 0x30, 0x63, 0x34, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x35, 0x35, 0x39, 0x31, 0x38, 0x35, 0x66, 0x31, 0x36, 0x36, 0x66, 0x63, 0x39, 0x35, 0x31, 0x33, 0x63, 0x63, 0x37, 0x31, 0x31, 0x31, 0x36, 0x31, 0x34, 0x34, 0x63, 0x65, 0x32, 0x64, 0x65, 0x62, 0x30, 0x66, 0x31, 0x64, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x35, 0x62, 0x34, 0x63, 0x34, 0x31, 0x65, 0x37, 0x36, 0x32, 0x64, 0x39, 0x34, 0x32, 0x34, 0x30, 0x34, 0x33, 0x37, 0x33, 0x63, 0x61, 0x66, 0x32, 0x31, 0x65, 0x64, 0x34, 0x36, 0x31, 0x35, 0x64, 0x32, 0x35, 0x65, 0x36, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x35, 0x62, 0x30, 0x30, 0x30, 0x66, 0x30, 0x62, 0x37, 0x37, 0x32, 0x37, 0x35, 0x30, 0x63, 0x63, 0x33, 0x63, 0x32, 0x31, 0x37, 0x61, 0x35, 0x65, 0x66, 0x34, 0x32, 0x39, 0x61, 0x39, 0x32, 0x62, 0x66, 0x31, 0x63, 0x63, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x62, 0x64, 0x39, 0x66, 0x38, 0x31, 0x63, 0x66, 0x37, 0x38, 0x62, 0x64, 0x35, 0x66, 0x62, 0x36, 0x63, 0x34, 0x62, 0x39, 0x61, 0x32, 0x34, 0x62, 0x64, 0x34, 0x31, 0x34, 0x62, 0x62, 0x39, 0x62, 0x66, 0x61, 0x34, 0x63, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x37, 0x32, 0x36, 0x39, 0x31, 0x63, 0x38, 0x64, 0x64, 0x37, 0x63, 0x64, 0x34, 0x32, 0x33, 0x37, 0x66, 0x66, 0x37, 0x32, 0x61, 0x37, 0x35, 0x63, 0x31, 0x61, 0x39, 0x35, 0x30, 0x36, 0x64, 0x30, 0x63, 0x65, 0x35, 0x62, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x36, 0x35, 0x64, 0x66, 0x32, 0x35, 0x32, 0x38, 0x30, 0x65, 0x38, 0x65, 0x34, 0x66, 0x33, 0x38, 0x64, 0x34, 0x62, 0x31, 0x63, 0x66, 0x34, 0x34, 0x36, 0x66, 0x63, 0x35, 0x64, 0x37, 0x65, 0x62, 0x36, 0x35, 0x39, 0x65, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x34, 0x66, 0x62, 0x32, 0x31, 0x30, 0x35, 0x32, 0x32, 0x63, 0x35, 0x65, 0x32, 0x33, 0x62, 0x62, 0x36, 0x37, 0x64, 0x66, 0x62, 0x66, 0x38, 0x63, 0x32, 0x36, 0x61, 0x61, 0x36, 0x31, 0x36, 0x64, 0x61, 0x34, 0x39, 0x39, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x38, 0x37, 0x65, 0x36, 0x31, 0x33, 0x39, 0x65, 0x36, 0x31, 0x34, 0x36, 0x61, 0x37, 0x31, 0x37, 0x66, 0x65, 0x66, 0x39, 0x36, 0x62, 0x63, 0x32, 0x34, 0x39, 0x33, 0x34, 0x61, 0x35, 0x34, 0x34, 0x37, 0x66, 0x65, 0x30, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x31, 0x31, 0x30, 0x32, 0x37, 0x36, 0x63, 0x66, 0x65, 0x33, 0x31, 0x65, 0x34, 0x32, 0x38, 0x32, 0x35, 0x61, 0x35, 0x37, 0x37, 0x66, 0x36, 0x62, 0x34, 0x33, 0x35, 0x64, 0x62, 0x63, 0x63, 0x31, 0x30, 0x63, 0x66, 0x37, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x35, 0x31, 0x62, 0x38, 0x61, 0x33, 0x62, 0x62, 0x30, 0x39, 0x64, 0x33, 0x30, 0x33, 0x65, 0x61, 0x37, 0x63, 0x38, 0x36, 0x30, 0x35, 0x31, 0x35, 0x38, 0x32, 0x66, 0x64, 0x36, 0x30, 0x30, 0x66, 0x62, 0x33, 0x64, 0x63, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x34, 0x66, 0x32, 0x34, 0x65, 0x39, 0x39, 0x34, 0x65, 0x64, 0x38, 0x66, 0x38, 0x35, 0x30, 0x65, 0x61, 0x37, 0x38, 0x31, 0x38, 0x66, 0x34, 0x37, 0x31, 0x63, 0x38, 0x66, 0x61, 0x63, 0x33, 0x62, 0x63, 0x66, 0x30, 0x34, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x62, 0x32, 0x39, 0x39, 0x38, 0x64, 0x30, 0x63, 0x37, 0x33, 0x33, 0x30, 0x32, 0x63, 0x62, 0x32, 0x62, 0x61, 0x31, 0x33, 0x66, 0x34, 0x38, 0x39, 0x33, 0x31, 0x33, 0x33, 0x30, 0x31, 0x65, 0x30, 0x35, 0x33, 0x62, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x66, 0x36, 0x63, 0x38, 0x64, 0x35, 0x33, 0x39, 0x63, 0x39, 0x36, 0x64, 0x35, 0x30, 0x32, 0x35, 0x39, 0x65, 0x31, 0x62, 0x61, 0x36, 0x37, 0x31, 0x39, 0x65, 0x39, 0x63, 0x38, 0x30, 0x36, 0x30, 0x66, 0x33, 0x38, 0x38, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x39, 0x30, 0x31, 0x62, 0x32, 0x38, 0x62, 0x66, 0x37, 0x66, 0x38, 0x38, 0x65, 0x66, 0x37, 0x33, 0x64, 0x38, 0x66, 0x37, 0x33, 0x63, 0x63, 0x61, 0x39, 0x37, 0x35, 0x36, 0x34, 0x39, 0x31, 0x33, 0x65, 0x61, 0x38, 0x61, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x31, 0x38, 0x35, 0x39, 0x66, 0x32, 0x34, 0x32, 0x66, 0x31, 0x61, 0x30, 0x65, 0x63, 0x36, 0x30, 0x32, 0x66, 0x61, 0x38, 0x61, 0x33, 0x62, 0x30, 0x62, 0x35, 0x37, 0x36, 0x34, 0x30, 0x65, 0x63, 0x38, 0x39, 0x30, 0x37, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x36, 0x61, 0x65, 0x34, 0x63, 0x65, 0x65, 0x38, 0x37, 0x66, 0x62, 0x33, 0x33, 0x35, 0x33, 0x32, 0x31, 0x39, 0x66, 0x37, 0x37, 0x66, 0x31, 0x64, 0x36, 0x34, 0x38, 0x36, 0x63, 0x35, 0x38, 0x30, 0x32, 0x38, 0x30, 0x33, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x34, 0x30, 0x35, 0x35, 0x38, 0x62, 0x30, 0x36, 0x66, 0x39, 0x30, 0x61, 0x33, 0x39, 0x32, 0x33, 0x31, 0x34, 0x35, 0x35, 0x39, 0x32, 0x31, 0x32, 0x33, 0x62, 0x36, 0x37, 0x37, 0x34, 0x65, 0x34, 0x36, 0x65, 0x33, 0x31, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x66, 0x34, 0x33, 0x39, 0x37, 0x35, 0x62, 0x37, 0x36, 0x62, 0x66, 0x65, 0x37, 0x33, 0x35, 0x66, 0x65, 0x63, 0x33, 0x63, 0x62, 0x37, 0x64, 0x34, 0x64, 0x64, 0x32, 0x34, 0x66, 0x38, 0x30, 0x35, 0x62, 0x61, 0x30, 0x39, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x30, 0x33, 0x62, 0x34, 0x62, 0x32, 0x39, 0x32, 0x62, 0x38, 0x61, 0x39, 0x64, 0x65, 0x64, 0x64, 0x65, 0x64, 0x65, 0x38, 0x31, 0x62, 0x62, 0x32, 0x35, 0x64, 0x38, 0x39, 0x31, 0x37, 0x39, 0x66, 0x36, 0x34, 0x34, 0x36, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x39, 0x30, 0x39, 0x36, 0x64, 0x33, 0x34, 0x33, 0x63, 0x30, 0x36, 0x30, 0x64, 0x62, 0x35, 0x38, 0x31, 0x61, 0x31, 0x32, 0x30, 0x31, 0x31, 0x32, 0x62, 0x32, 0x37, 0x38, 0x36, 0x30, 0x37, 0x65, 0x63, 0x36, 0x65, 0x35, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x35, 0x38, 0x31, 0x39, 0x61, 0x63, 0x34, 0x63, 0x63, 0x31, 0x34, 0x63, 0x31, 0x33, 0x37, 0x66, 0x30, 0x35, 0x64, 0x64, 0x37, 0x39, 0x37, 0x37, 0x63, 0x37, 0x64, 0x61, 0x65, 0x30, 0x38, 0x64, 0x31, 0x61, 0x34, 0x61, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x33, 0x37, 0x33, 0x66, 0x65, 0x33, 0x63, 0x39, 0x30, 0x36, 0x62, 0x38, 0x63, 0x36, 0x35, 0x35, 0x39, 0x65, 0x65, 0x34, 0x39, 0x63, 0x63, 0x64, 0x30, 0x37, 0x66, 0x33, 0x37, 0x63, 0x64, 0x34, 0x66, 0x62, 0x35, 0x32, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x38, 0x32, 0x39, 0x38, 0x35, 0x32, 0x34, 0x64, 0x66, 0x35, 0x65, 0x63, 0x34, 0x62, 0x32, 0x34, 0x62, 0x30, 0x66, 0x66, 0x62, 0x39, 0x64, 0x66, 0x38, 0x35, 0x31, 0x37, 0x30, 0x61, 0x31, 0x34, 0x35, 0x61, 0x39, 0x65, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x63, 0x64, 0x61, 0x38, 0x34, 0x37, 0x61, 0x61, 0x66, 0x38, 0x64, 0x37, 0x66, 0x61, 0x38, 0x62, 0x63, 0x61, 0x30, 0x38, 0x30, 0x32, 0x39, 0x63, 0x61, 0x32, 0x38, 0x34, 0x39, 0x31, 0x36, 0x36, 0x61, 0x61, 0x31, 0x35, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x33, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x63, 0x37, 0x33, 0x39, 0x61, 0x36, 0x39, 0x39, 0x37, 0x30, 0x30, 0x62, 0x32, 0x65, 0x38, 0x65, 0x32, 0x63, 0x34, 0x61, 0x34, 0x63, 0x37, 0x62, 0x30, 0x35, 0x38, 0x61, 0x30, 0x65, 0x35, 0x31, 0x33, 0x64, 0x64, 0x65, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x62, 0x30, 0x35, 0x66, 0x37, 0x32, 0x32, 0x34, 0x62, 0x62, 0x35, 0x38, 0x30, 0x34, 0x38, 0x35, 0x36, 0x35, 0x35, 0x36, 0x63, 0x30, 0x37, 0x65, 0x65, 0x61, 0x64, 0x62, 0x65, 0x64, 0x38, 0x37, 0x62, 0x61, 0x38, 0x66, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x34, 0x31, 0x36, 0x66, 0x65, 0x33, 0x30, 0x64, 0x35, 0x38, 0x61, 0x66, 0x65, 0x35, 0x64, 0x39, 0x34, 0x35, 0x34, 0x63, 0x37, 0x66, 0x63, 0x65, 0x37, 0x66, 0x38, 0x33, 0x30, 0x62, 0x63, 0x63, 0x37, 0x35, 0x30, 0x33, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x35, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x65, 0x65, 0x36, 0x66, 0x31, 0x65, 0x39, 0x36, 0x33, 0x36, 0x30, 0x62, 0x37, 0x36, 0x38, 0x39, 0x62, 0x33, 0x30, 0x36, 0x39, 0x61, 0x64, 0x61, 0x66, 0x39, 0x61, 0x66, 0x38, 0x65, 0x62, 0x36, 0x30, 0x63, 0x65, 0x34, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x30, 0x64, 0x33, 0x63, 0x65, 0x65, 0x33, 0x64, 0x39, 0x38, 0x39, 0x32, 0x65, 0x61, 0x33, 0x62, 0x33, 0x37, 0x30, 0x30, 0x61, 0x32, 0x37, 0x66, 0x66, 0x38, 0x34, 0x31, 0x34, 0x30, 0x64, 0x39, 0x30, 0x32, 0x35, 0x34, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x63, 0x33, 0x36, 0x64, 0x65, 0x35, 0x33, 0x35, 0x39, 0x34, 0x35, 0x30, 0x61, 0x31, 0x65, 0x63, 0x30, 0x39, 0x63, 0x62, 0x30, 0x63, 0x34, 0x34, 0x63, 0x66, 0x32, 0x62, 0x62, 0x34, 0x32, 0x62, 0x33, 0x61, 0x65, 0x34, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x63, 0x38, 0x61, 0x64, 0x63, 0x31, 0x31, 0x31, 0x32, 0x35, 0x34, 0x33, 0x32, 0x62, 0x33, 0x62, 0x37, 0x37, 0x61, 0x63, 0x64, 0x36, 0x34, 0x36, 0x32, 0x35, 0x66, 0x65, 0x35, 0x38, 0x65, 0x62, 0x65, 0x65, 0x39, 0x64, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x65, 0x39, 0x63, 0x64, 0x34, 0x62, 0x37, 0x34, 0x32, 0x35, 0x35, 0x64, 0x32, 0x32, 0x62, 0x37, 0x64, 0x39, 0x62, 0x32, 0x37, 0x61, 0x65, 0x38, 0x64, 0x64, 0x34, 0x33, 0x65, 0x64, 0x36, 0x65, 0x64, 0x30, 0x32, 0x35, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x36, 0x35, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x65, 0x61, 0x31, 0x32, 0x64, 0x34, 0x39, 0x61, 0x33, 0x35, 0x61, 0x37, 0x34, 0x30, 0x37, 0x38, 0x30, 0x64, 0x64, 0x65, 0x65, 0x61, 0x65, 0x63, 0x65, 0x38, 0x34, 0x63, 0x30, 0x38, 0x33, 0x35, 0x62, 0x32, 0x36, 0x32, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x65, 0x66, 0x37, 0x62, 0x35, 0x35, 0x31, 0x66, 0x30, 0x62, 0x39, 0x63, 0x34, 0x36, 0x65, 0x37, 0x35, 0x35, 0x63, 0x30, 0x66, 0x33, 0x38, 0x65, 0x35, 0x62, 0x33, 0x61, 0x37, 0x33, 0x66, 0x65, 0x31, 0x31, 0x39, 0x39, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x36, 0x64, 0x37, 0x62, 0x31, 0x32, 0x30, 0x36, 0x31, 0x62, 0x63, 0x39, 0x36, 0x64, 0x31, 0x30, 0x34, 0x64, 0x36, 0x30, 0x36, 0x64, 0x36, 0x35, 0x66, 0x66, 0x61, 0x33, 0x32, 0x62, 0x30, 0x30, 0x33, 0x36, 0x65, 0x62, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x32, 0x30, 0x32, 0x31, 0x30, 0x32, 0x32, 0x36, 0x37, 0x38, 0x61, 0x30, 0x31, 0x36, 0x36, 0x64, 0x32, 0x30, 0x34, 0x62, 0x33, 0x61, 0x61, 0x61, 0x37, 0x61, 0x64, 0x34, 0x65, 0x63, 0x34, 0x62, 0x38, 0x38, 0x62, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x31, 0x31, 0x39, 0x36, 0x37, 0x31, 0x34, 0x61, 0x34, 0x38, 0x64, 0x66, 0x66, 0x37, 0x32, 0x36, 0x65, 0x61, 0x39, 0x34, 0x33, 0x33, 0x63, 0x64, 0x32, 0x39, 0x31, 0x32, 0x66, 0x31, 0x61, 0x34, 0x31, 0x34, 0x62, 0x33, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x32, 0x66, 0x62, 0x38, 0x38, 0x34, 0x63, 0x38, 0x61, 0x61, 0x66, 0x66, 0x36, 0x66, 0x35, 0x34, 0x33, 0x61, 0x63, 0x36, 0x32, 0x32, 0x38, 0x62, 0x64, 0x30, 0x38, 0x65, 0x34, 0x66, 0x36, 0x30, 0x62, 0x30, 0x61, 0x35, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x39, 0x64, 0x32, 0x32, 0x31, 0x61, 0x33, 0x64, 0x66, 0x38, 0x39, 0x64, 0x64, 0x64, 0x37, 0x62, 0x35, 0x66, 0x36, 0x31, 0x63, 0x31, 0x34, 0x36, 0x38, 0x63, 0x36, 0x37, 0x38, 0x37, 0x64, 0x36, 0x62, 0x33, 0x33, 0x33, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x37, 0x66, 0x35, 0x39, 0x63, 0x63, 0x38, 0x32, 0x37, 0x39, 0x35, 0x33, 0x32, 0x39, 0x33, 0x38, 0x34, 0x65, 0x34, 0x31, 0x65, 0x31, 0x32, 0x38, 0x33, 0x31, 0x31, 0x35, 0x65, 0x37, 0x39, 0x31, 0x66, 0x32, 0x36, 0x61, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x39, 0x35, 0x37, 0x39, 0x66, 0x31, 0x31, 0x39, 0x62, 0x62, 0x63, 0x38, 0x31, 0x39, 0x61, 0x30, 0x32, 0x62, 0x36, 0x31, 0x65, 0x33, 0x38, 0x64, 0x38, 0x38, 0x30, 0x33, 0x63, 0x39, 0x34, 0x32, 0x66, 0x32, 0x34, 0x64, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x32, 0x66, 0x32, 0x36, 0x32, 0x33, 0x35, 0x65, 0x31, 0x33, 0x37, 0x61, 0x37, 0x33, 0x32, 0x34, 0x65, 0x34, 0x64, 0x63, 0x31, 0x35, 0x34, 0x62, 0x35, 0x64, 0x66, 0x35, 0x61, 0x66, 0x34, 0x36, 0x65, 0x61, 0x31, 0x61, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x34, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x31, 0x35, 0x37, 0x39, 0x61, 0x66, 0x33, 0x33, 0x31, 0x32, 0x65, 0x34, 0x66, 0x38, 0x38, 0x61, 0x65, 0x39, 0x33, 0x63, 0x36, 0x38, 0x65, 0x39, 0x34, 0x34, 0x39, 0x63, 0x32, 0x65, 0x39, 0x61, 0x36, 0x38, 0x64, 0x39, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x62, 0x30, 0x34, 0x37, 0x32, 0x36, 0x64, 0x66, 0x61, 0x34, 0x31, 0x61, 0x66, 0x64, 0x63, 0x38, 0x31, 0x39, 0x31, 0x36, 0x38, 0x34, 0x31, 0x38, 0x36, 0x31, 0x30, 0x34, 0x37, 0x32, 0x39, 0x37, 0x30, 0x64, 0x37, 0x62, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x33, 0x63, 0x36, 0x34, 0x38, 0x39, 0x36, 0x61, 0x37, 0x35, 0x63, 0x61, 0x64, 0x38, 0x31, 0x36, 0x61, 0x39, 0x31, 0x30, 0x35, 0x65, 0x31, 0x38, 0x64, 0x38, 0x61, 0x61, 0x35, 0x62, 0x66, 0x38, 0x30, 0x66, 0x32, 0x33, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x64, 0x35, 0x38, 0x38, 0x61, 0x31, 0x34, 0x65, 0x63, 0x36, 0x34, 0x38, 0x63, 0x63, 0x66, 0x36, 0x34, 0x37, 0x32, 0x39, 0x66, 0x39, 0x31, 0x36, 0x37, 0x61, 0x61, 0x37, 0x62, 0x66, 0x38, 0x62, 0x65, 0x36, 0x65, 0x62, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x62, 0x32, 0x62, 0x65, 0x31, 0x31, 0x38, 0x62, 0x31, 0x36, 0x64, 0x38, 0x62, 0x32, 0x31, 0x37, 0x34, 0x37, 0x36, 0x39, 0x64, 0x31, 0x37, 0x62, 0x34, 0x63, 0x66, 0x38, 0x34, 0x66, 0x30, 0x37, 0x63, 0x61, 0x39, 0x34, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x62, 0x62, 0x35, 0x39, 0x66, 0x61, 0x33, 0x31, 0x32, 0x35, 0x38, 0x62, 0x65, 0x36, 0x32, 0x66, 0x38, 0x65, 0x64, 0x32, 0x33, 0x32, 0x66, 0x31, 0x61, 0x37, 0x64, 0x34, 0x37, 0x62, 0x34, 0x61, 0x30, 0x62, 0x34, 0x31, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x39, 0x61, 0x63, 0x37, 0x31, 0x35, 0x63, 0x64, 0x36, 0x66, 0x32, 0x36, 0x31, 0x30, 0x63, 0x35, 0x32, 0x62, 0x35, 0x38, 0x36, 0x37, 0x36, 0x34, 0x35, 0x36, 0x38, 0x38, 0x34, 0x32, 0x39, 0x37, 0x30, 0x31, 0x38, 0x62, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x32, 0x61, 0x33, 0x31, 0x39, 0x30, 0x30, 0x65, 0x32, 0x34, 0x30, 0x33, 0x39, 0x35, 0x62, 0x31, 0x39, 0x66, 0x31, 0x35, 0x39, 0x63, 0x31, 0x64, 0x30, 0x30, 0x64, 0x66, 0x65, 0x34, 0x64, 0x38, 0x39, 0x38, 0x65, 0x62, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x30, 0x62, 0x32, 0x34, 0x37, 0x33, 0x32, 0x31, 0x61, 0x33, 0x32, 0x61, 0x35, 0x61, 0x66, 0x66, 0x62, 0x39, 0x36, 0x62, 0x31, 0x65, 0x32, 0x37, 0x39, 0x39, 0x32, 0x37, 0x63, 0x63, 0x35, 0x38, 0x34, 0x64, 0x65, 0x39, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x36, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x61, 0x31, 0x61, 0x64, 0x65, 0x32, 0x64, 0x30, 0x66, 0x35, 0x32, 0x39, 0x31, 0x32, 0x33, 0x64, 0x31, 0x30, 0x35, 0x35, 0x66, 0x31, 0x39, 0x62, 0x31, 0x37, 0x39, 0x31, 0x39, 0x66, 0x35, 0x36, 0x32, 0x31, 0x34, 0x65, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x61, 0x30, 0x30, 0x64, 0x66, 0x31, 0x37, 0x30, 0x36, 0x37, 0x61, 0x34, 0x33, 0x61, 0x38, 0x32, 0x62, 0x63, 0x31, 0x64, 0x61, 0x65, 0x63, 0x61, 0x66, 0x62, 0x36, 0x63, 0x31, 0x34, 0x33, 0x30, 0x30, 0x65, 0x38, 0x39, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x39, 0x36, 0x38, 0x66, 0x63, 0x31, 0x63, 0x36, 0x34, 0x62, 0x61, 0x63, 0x30, 0x62, 0x37, 0x61, 0x65, 0x30, 0x64, 0x36, 0x38, 0x62, 0x61, 0x39, 0x34, 0x39, 0x38, 0x37, 0x34, 0x64, 0x36, 0x64, 0x62, 0x32, 0x35, 0x33, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x64, 0x38, 0x61, 0x64, 0x39, 0x61, 0x34, 0x64, 0x36, 0x31, 0x36, 0x38, 0x33, 0x62, 0x38, 0x30, 0x64, 0x34, 0x61, 0x36, 0x36, 0x37, 0x32, 0x65, 0x38, 0x34, 0x63, 0x32, 0x30, 0x64, 0x36, 0x32, 0x34, 0x32, 0x31, 0x65, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x64, 0x32, 0x61, 0x31, 0x32, 0x62, 0x30, 0x32, 0x66, 0x38, 0x63, 0x36, 0x38, 0x38, 0x63, 0x37, 0x62, 0x35, 0x64, 0x33, 0x61, 0x36, 0x65, 0x61, 0x31, 0x34, 0x64, 0x36, 0x33, 0x36, 0x38, 0x37, 0x64, 0x61, 0x62, 0x33, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x36, 0x33, 0x38, 0x36, 0x39, 0x66, 0x63, 0x37, 0x36, 0x37, 0x61, 0x34, 0x63, 0x36, 0x62, 0x31, 0x63, 0x64, 0x30, 0x65, 0x30, 0x36, 0x34, 0x39, 0x66, 0x33, 0x36, 0x33, 0x34, 0x63, 0x62, 0x31, 0x32, 0x31, 0x64, 0x32, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x66, 0x35, 0x32, 0x32, 0x66, 0x30, 0x35, 0x32, 0x30, 0x65, 0x62, 0x61, 0x35, 0x32, 0x64, 0x64, 0x31, 0x38, 0x61, 0x64, 0x32, 0x31, 0x66, 0x61, 0x34, 0x62, 0x38, 0x32, 0x39, 0x66, 0x32, 0x62, 0x38, 0x39, 0x63, 0x62, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x34, 0x39, 0x35, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x32, 0x33, 0x34, 0x61, 0x61, 0x66, 0x34, 0x35, 0x63, 0x36, 0x66, 0x32, 0x32, 0x65, 0x36, 0x36, 0x61, 0x32, 0x32, 0x35, 0x66, 0x66, 0x62, 0x39, 0x33, 0x61, 0x64, 0x64, 0x36, 0x32, 0x39, 0x62, 0x34, 0x65, 0x66, 0x38, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x64, 0x38, 0x62, 0x66, 0x34, 0x65, 0x66, 0x65, 0x38, 0x34, 0x62, 0x31, 0x36, 0x31, 0x36, 0x64, 0x31, 0x62, 0x38, 0x39, 0x65, 0x34, 0x32, 0x37, 0x64, 0x64, 0x63, 0x36, 0x63, 0x38, 0x38, 0x33, 0x30, 0x36, 0x38, 0x35, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x64, 0x62, 0x33, 0x36, 0x34, 0x61, 0x33, 0x33, 0x32, 0x64, 0x38, 0x38, 0x34, 0x62, 0x61, 0x39, 0x33, 0x62, 0x32, 0x36, 0x31, 0x37, 0x61, 0x65, 0x34, 0x64, 0x38, 0x35, 0x61, 0x31, 0x34, 0x38, 0x39, 0x62, 0x65, 0x61, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x37, 0x39, 0x38, 0x36, 0x39, 0x32, 0x34, 0x61, 0x65, 0x62, 0x30, 0x32, 0x36, 0x38, 0x37, 0x63, 0x64, 0x36, 0x34, 0x31, 0x38, 0x39, 0x31, 0x38, 0x39, 0x66, 0x62, 0x31, 0x36, 0x37, 0x64, 0x65, 0x64, 0x32, 0x64, 0x64, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x61, 0x66, 0x34, 0x65, 0x32, 0x61, 0x34, 0x36, 0x62, 0x37, 0x38, 0x39, 0x63, 0x63, 0x63, 0x32, 0x38, 0x38, 0x63, 0x38, 0x64, 0x31, 0x64, 0x39, 0x32, 0x39, 0x34, 0x65, 0x33, 0x66, 0x62, 0x30, 0x38, 0x35, 0x33, 0x38, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x32, 0x64, 0x63, 0x36, 0x61, 0x61, 0x33, 0x32, 0x38, 0x62, 0x38, 0x38, 0x30, 0x64, 0x65, 0x39, 0x39, 0x65, 0x61, 0x63, 0x35, 0x34, 0x36, 0x38, 0x32, 0x33, 0x66, 0x63, 0x63, 0x66, 0x37, 0x37, 0x34, 0x30, 0x34, 0x37, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x33, 0x62, 0x37, 0x66, 0x37, 0x38, 0x36, 0x64, 0x33, 0x63, 0x39, 0x39, 0x66, 0x66, 0x30, 0x31, 0x32, 0x63, 0x34, 0x61, 0x37, 0x63, 0x61, 0x65, 0x32, 0x36, 0x37, 0x37, 0x32, 0x37, 0x30, 0x32, 0x34, 0x30, 0x62, 0x39, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x36, 0x39, 0x63, 0x38, 0x33, 0x64, 0x32, 0x38, 0x66, 0x66, 0x30, 0x34, 0x37, 0x34, 0x63, 0x65, 0x65, 0x62, 0x65, 0x61, 0x63, 0x62, 0x33, 0x61, 0x64, 0x32, 0x32, 0x37, 0x61, 0x31, 0x34, 0x34, 0x65, 0x63, 0x65, 0x37, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x37, 0x34, 0x39, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x38, 0x32, 0x37, 0x63, 0x61, 0x65, 0x37, 0x66, 0x66, 0x34, 0x37, 0x34, 0x30, 0x39, 0x31, 0x38, 0x66, 0x32, 0x65, 0x30, 0x33, 0x30, 0x61, 0x62, 0x32, 0x36, 0x63, 0x62, 0x39, 0x38, 0x63, 0x34, 0x66, 0x34, 0x36, 0x63, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x38, 0x33, 0x65, 0x66, 0x30, 0x65, 0x64, 0x34, 0x63, 0x34, 0x34, 0x30, 0x31, 0x31, 0x39, 0x36, 0x37, 0x37, 0x34, 0x61, 0x39, 0x35, 0x63, 0x66, 0x34, 0x65, 0x64, 0x63, 0x38, 0x33, 0x65, 0x64, 0x63, 0x31, 0x34, 0x38, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x61, 0x64, 0x37, 0x34, 0x62, 0x63, 0x30, 0x62, 0x63, 0x65, 0x32, 0x61, 0x34, 0x35, 0x65, 0x35, 0x32, 0x66, 0x33, 0x36, 0x63, 0x33, 0x64, 0x65, 0x62, 0x62, 0x31, 0x62, 0x33, 0x61, 0x64, 0x61, 0x31, 0x62, 0x37, 0x36, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x34, 0x32, 0x33, 0x61, 0x35, 0x34, 0x63, 0x38, 0x64, 0x30, 0x66, 0x39, 0x37, 0x30, 0x37, 0x65, 0x37, 0x30, 0x34, 0x31, 0x37, 0x33, 0x64, 0x39, 0x32, 0x33, 0x62, 0x39, 0x34, 0x36, 0x65, 0x64, 0x63, 0x38, 0x65, 0x37, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x37, 0x35, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x65, 0x62, 0x37, 0x64, 0x62, 0x30, 0x62, 0x61, 0x35, 0x36, 0x62, 0x30, 0x66, 0x38, 0x62, 0x38, 0x31, 0x36, 0x63, 0x63, 0x62, 0x32, 0x30, 0x36, 0x65, 0x36, 0x31, 0x35, 0x64, 0x39, 0x32, 0x39, 0x31, 0x38, 0x35, 0x62, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x30, 0x38, 0x32, 0x63, 0x37, 0x35, 0x61, 0x38, 0x64, 0x65, 0x33, 0x31, 0x61, 0x35, 0x33, 0x39, 0x31, 0x33, 0x62, 0x62, 0x64, 0x34, 0x34, 0x64, 0x65, 0x33, 0x61, 0x30, 0x33, 0x37, 0x34, 0x66, 0x37, 0x66, 0x61, 0x61, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x64, 0x33, 0x65, 0x61, 0x61, 0x32, 0x39, 0x39, 0x38, 0x38, 0x37, 0x38, 0x36, 0x35, 0x35, 0x36, 0x39, 0x65, 0x38, 0x38, 0x62, 0x65, 0x32, 0x31, 0x39, 0x62, 0x65, 0x35, 0x30, 0x37, 0x31, 0x38, 0x39, 0x62, 0x65, 0x31, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x36, 0x31, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x35, 0x37, 0x63, 0x63, 0x31, 0x32, 0x39, 0x61, 0x39, 0x36, 0x61, 0x38, 0x39, 0x39, 0x38, 0x31, 0x64, 0x61, 0x63, 0x36, 0x30, 0x64, 0x32, 0x66, 0x66, 0x62, 0x38, 0x37, 0x37, 0x64, 0x35, 0x64, 0x63, 0x35, 0x65, 0x34, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x30, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x32, 0x34, 0x33, 0x34, 0x63, 0x63, 0x37, 0x37, 0x34, 0x34, 0x32, 0x32, 0x64, 0x34, 0x38, 0x64, 0x35, 0x33, 0x64, 0x35, 0x39, 0x63, 0x35, 0x64, 0x35, 0x36, 0x32, 0x63, 0x63, 0x65, 0x38, 0x34, 0x30, 0x37, 0x63, 0x39, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x35, 0x34, 0x36, 0x39, 0x31, 0x34, 0x64, 0x66, 0x64, 0x33, 0x61, 0x66, 0x32, 0x61, 0x64, 0x64, 0x34, 0x31, 0x62, 0x30, 0x66, 0x66, 0x33, 0x65, 0x38, 0x33, 0x66, 0x66, 0x64, 0x61, 0x37, 0x34, 0x31, 0x34, 0x65, 0x31, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x36, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x63, 0x66, 0x36, 0x32, 0x61, 0x33, 0x64, 0x65, 0x33, 0x66, 0x30, 0x36, 0x31, 0x64, 0x62, 0x39, 0x31, 0x34, 0x39, 0x38, 0x66, 0x64, 0x36, 0x31, 0x30, 0x36, 0x30, 0x66, 0x31, 0x66, 0x36, 0x33, 0x39, 0x38, 0x66, 0x66, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x64, 0x39, 0x38, 0x65, 0x35, 0x36, 0x33, 0x64, 0x31, 0x32, 0x63, 0x65, 0x30, 0x66, 0x64, 0x36, 0x30, 0x66, 0x34, 0x66, 0x31, 0x66, 0x38, 0x35, 0x30, 0x61, 0x65, 0x33, 0x39, 0x36, 0x61, 0x39, 0x38, 0x32, 0x33, 0x63, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x66, 0x38, 0x61, 0x33, 0x65, 0x31, 0x64, 0x34, 0x30, 0x66, 0x31, 0x33, 0x62, 0x37, 0x39, 0x65, 0x63, 0x38, 0x65, 0x33, 0x65, 0x31, 0x65, 0x63, 0x66, 0x32, 0x36, 0x32, 0x66, 0x64, 0x39, 0x32, 0x31, 0x31, 0x36, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x39, 0x65, 0x33, 0x63, 0x66, 0x63, 0x31, 0x39, 0x66, 0x36, 0x30, 0x35, 0x66, 0x66, 0x33, 0x65, 0x63, 0x39, 0x63, 0x39, 0x63, 0x37, 0x30, 0x65, 0x32, 0x35, 0x34, 0x30, 0x64, 0x37, 0x65, 0x65, 0x39, 0x37, 0x34, 0x33, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x33, 0x35, 0x37, 0x32, 0x66, 0x30, 0x65, 0x61, 0x36, 0x64, 0x66, 0x39, 0x62, 0x31, 0x39, 0x37, 0x63, 0x61, 0x65, 0x34, 0x30, 0x65, 0x34, 0x62, 0x38, 0x65, 0x63, 0x63, 0x30, 0x35, 0x36, 0x63, 0x34, 0x33, 0x37, 0x31, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x33, 0x63, 0x63, 0x38, 0x62, 0x65, 0x32, 0x32, 0x37, 0x36, 0x34, 0x36, 0x63, 0x62, 0x30, 0x39, 0x37, 0x31, 0x39, 0x31, 0x35, 0x39, 0x66, 0x32, 0x38, 0x65, 0x64, 0x30, 0x39, 0x63, 0x35, 0x64, 0x63, 0x30, 0x64, 0x63, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x39, 0x33, 0x32, 0x61, 0x33, 0x31, 0x64, 0x36, 0x66, 0x66, 0x37, 0x35, 0x66, 0x62, 0x33, 0x62, 0x31, 0x32, 0x37, 0x31, 0x61, 0x63, 0x65, 0x37, 0x63, 0x61, 0x61, 0x37, 0x64, 0x35, 0x65, 0x31, 0x66, 0x66, 0x31, 0x30, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x61, 0x39, 0x34, 0x62, 0x64, 0x35, 0x36, 0x31, 0x39, 0x38, 0x64, 0x61, 0x32, 0x34, 0x35, 0x65, 0x64, 0x30, 0x31, 0x64, 0x31, 0x65, 0x36, 0x34, 0x33, 0x30, 0x62, 0x32, 0x34, 0x62, 0x32, 0x37, 0x30, 0x38, 0x64, 0x63, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x39, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x62, 0x38, 0x62, 0x33, 0x33, 0x62, 0x32, 0x31, 0x64, 0x32, 0x33, 0x63, 0x64, 0x61, 0x38, 0x36, 0x64, 0x38, 0x32, 0x38, 0x38, 0x38, 0x38, 0x34, 0x61, 0x62, 0x34, 0x37, 0x30, 0x65, 0x31, 0x36, 0x34, 0x36, 0x39, 0x31, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x62, 0x63, 0x62, 0x66, 0x32, 0x32, 0x63, 0x30, 0x39, 0x36, 0x30, 0x37, 0x61, 0x63, 0x38, 0x34, 0x33, 0x34, 0x31, 0x64, 0x32, 0x65, 0x64, 0x62, 0x63, 0x30, 0x33, 0x62, 0x66, 0x62, 0x31, 0x37, 0x33, 0x39, 0x64, 0x37, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x31, 0x63, 0x35, 0x39, 0x61, 0x64, 0x63, 0x37, 0x34, 0x35, 0x30, 0x35, 0x64, 0x31, 0x38, 0x36, 0x34, 0x64, 0x31, 0x65, 0x63, 0x66, 0x63, 0x62, 0x38, 0x61, 0x66, 0x61, 0x30, 0x34, 0x31, 0x32, 0x35, 0x39, 0x33, 0x63, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x36, 0x38, 0x64, 0x66, 0x65, 0x39, 0x35, 0x64, 0x31, 0x35, 0x63, 0x64, 0x33, 0x61, 0x37, 0x66, 0x39, 0x38, 0x66, 0x66, 0x61, 0x36, 0x38, 0x38, 0x62, 0x34, 0x33, 0x34, 0x36, 0x38, 0x34, 0x32, 0x62, 0x65, 0x32, 0x36, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x35, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x31, 0x65, 0x66, 0x65, 0x30, 0x30, 0x38, 0x31, 0x64, 0x63, 0x65, 0x38, 0x63, 0x31, 0x34, 0x37, 0x39, 0x39, 0x66, 0x37, 0x62, 0x32, 0x61, 0x34, 0x33, 0x36, 0x31, 0x39, 0x63, 0x30, 0x63, 0x33, 0x62, 0x33, 0x66, 0x63, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x34, 0x66, 0x64, 0x30, 0x37, 0x33, 0x36, 0x31, 0x37, 0x30, 0x32, 0x32, 0x62, 0x36, 0x37, 0x66, 0x35, 0x63, 0x31, 0x33, 0x34, 0x39, 0x39, 0x62, 0x38, 0x32, 0x37, 0x66, 0x37, 0x36, 0x33, 0x36, 0x33, 0x39, 0x65, 0x34, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x30, 0x61, 0x37, 0x63, 0x38, 0x32, 0x65, 0x31, 0x35, 0x37, 0x35, 0x34, 0x30, 0x61, 0x30, 0x62, 0x30, 0x30, 0x39, 0x30, 0x31, 0x64, 0x62, 0x62, 0x38, 0x36, 0x63, 0x37, 0x31, 0x36, 0x65, 0x31, 0x61, 0x30, 0x36, 0x32, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x33, 0x35, 0x62, 0x34, 0x36, 0x66, 0x37, 0x31, 0x31, 0x64, 0x32, 0x64, 0x61, 0x36, 0x66, 0x30, 0x65, 0x31, 0x36, 0x33, 0x37, 0x30, 0x63, 0x64, 0x38, 0x65, 0x65, 0x34, 0x33, 0x65, 0x66, 0x62, 0x32, 0x63, 0x32, 0x64, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x37, 0x34, 0x38, 0x39, 0x32, 0x38, 0x65, 0x38, 0x63, 0x33, 0x65, 0x63, 0x34, 0x34, 0x33, 0x36, 0x61, 0x31, 0x64, 0x30, 0x39, 0x32, 0x66, 0x62, 0x65, 0x34, 0x33, 0x61, 0x63, 0x37, 0x34, 0x39, 0x62, 0x65, 0x31, 0x32, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x35, 0x37, 0x61, 0x62, 0x39, 0x34, 0x33, 0x39, 0x65, 0x66, 0x35, 0x30, 0x64, 0x32, 0x33, 0x37, 0x62, 0x35, 0x35, 0x33, 0x66, 0x30, 0x32, 0x35, 0x30, 0x38, 0x33, 0x36, 0x34, 0x61, 0x34, 0x36, 0x36, 0x61, 0x35, 0x63, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x39, 0x32, 0x38, 0x33, 0x37, 0x38, 0x64, 0x32, 0x37, 0x64, 0x35, 0x35, 0x63, 0x35, 0x32, 0x30, 0x63, 0x65, 0x65, 0x64, 0x66, 0x32, 0x34, 0x63, 0x65, 0x62, 0x31, 0x65, 0x38, 0x32, 0x32, 0x64, 0x38, 0x39, 0x30, 0x64, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x35, 0x31, 0x38, 0x34, 0x36, 0x34, 0x66, 0x64, 0x64, 0x38, 0x62, 0x37, 0x33, 0x63, 0x31, 0x62, 0x62, 0x36, 0x61, 0x63, 0x36, 0x64, 0x62, 0x36, 0x30, 0x30, 0x36, 0x35, 0x34, 0x39, 0x33, 0x38, 0x64, 0x62, 0x66, 0x31, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x34, 0x62, 0x66, 0x62, 0x65, 0x31, 0x35, 0x34, 0x36, 0x62, 0x63, 0x36, 0x63, 0x36, 0x35, 0x62, 0x35, 0x63, 0x37, 0x65, 0x61, 0x61, 0x35, 0x35, 0x33, 0x30, 0x34, 0x62, 0x33, 0x38, 0x62, 0x62, 0x66, 0x65, 0x63, 0x36, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x65, 0x30, 0x66, 0x63, 0x33, 0x63, 0x33, 0x61, 0x66, 0x66, 0x65, 0x64, 0x33, 0x64, 0x62, 0x36, 0x37, 0x31, 0x30, 0x39, 0x34, 0x37, 0x64, 0x31, 0x64, 0x36, 0x66, 0x62, 0x30, 0x31, 0x37, 0x66, 0x33, 0x65, 0x32, 0x37, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x63, 0x62, 0x63, 0x66, 0x61, 0x63, 0x62, 0x66, 0x61, 0x66, 0x65, 0x39, 0x66, 0x30, 0x30, 0x63, 0x33, 0x39, 0x32, 0x32, 0x61, 0x32, 0x34, 0x65, 0x32, 0x63, 0x66, 0x30, 0x30, 0x32, 0x36, 0x37, 0x35, 0x36, 0x63, 0x61, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x35, 0x66, 0x66, 0x61, 0x61, 0x30, 0x66, 0x37, 0x36, 0x31, 0x35, 0x37, 0x32, 0x36, 0x33, 0x35, 0x37, 0x38, 0x39, 0x31, 0x34, 0x37, 0x35, 0x38, 0x31, 0x38, 0x39, 0x33, 0x39, 0x64, 0x32, 0x30, 0x33, 0x37, 0x63, 0x66, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x32, 0x32, 0x32, 0x38, 0x36, 0x35, 0x37, 0x39, 0x39, 0x30, 0x37, 0x39, 0x61, 0x61, 0x66, 0x34, 0x66, 0x30, 0x36, 0x37, 0x34, 0x61, 0x30, 0x63, 0x64, 0x61, 0x61, 0x62, 0x30, 0x32, 0x61, 0x36, 0x64, 0x35, 0x37, 0x30, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x64, 0x63, 0x39, 0x30, 0x66, 0x34, 0x62, 0x65, 0x32, 0x31, 0x30, 0x38, 0x36, 0x35, 0x32, 0x31, 0x34, 0x61, 0x62, 0x35, 0x62, 0x33, 0x35, 0x65, 0x35, 0x61, 0x38, 0x64, 0x64, 0x37, 0x37, 0x34, 0x31, 0x35, 0x32, 0x37, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x37, 0x38, 0x33, 0x31, 0x65, 0x38, 0x33, 0x34, 0x63, 0x32, 0x30, 0x62, 0x31, 0x62, 0x61, 0x61, 0x36, 0x39, 0x37, 0x61, 0x66, 0x31, 0x64, 0x38, 0x65, 0x30, 0x63, 0x36, 0x32, 0x31, 0x63, 0x35, 0x61, 0x66, 0x66, 0x66, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x36, 0x64, 0x32, 0x37, 0x34, 0x62, 0x31, 0x61, 0x66, 0x36, 0x31, 0x35, 0x66, 0x62, 0x35, 0x30, 0x35, 0x61, 0x37, 0x36, 0x34, 0x61, 0x64, 0x38, 0x64, 0x64, 0x61, 0x37, 0x37, 0x30, 0x62, 0x31, 0x64, 0x62, 0x32, 0x66, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x65, 0x61, 0x32, 0x33, 0x61, 0x61, 0x30, 0x35, 0x37, 0x32, 0x30, 0x30, 0x65, 0x37, 0x63, 0x39, 0x63, 0x31, 0x35, 0x65, 0x38, 0x66, 0x66, 0x31, 0x39, 0x30, 0x64, 0x30, 0x65, 0x36, 0x36, 0x63, 0x30, 0x63, 0x30, 0x65, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x37, 0x61, 0x33, 0x63, 0x64, 0x31, 0x39, 0x34, 0x39, 0x36, 0x35, 0x33, 0x30, 0x61, 0x36, 0x64, 0x34, 0x32, 0x30, 0x34, 0x63, 0x33, 0x62, 0x35, 0x61, 0x31, 0x37, 0x63, 0x65, 0x30, 0x66, 0x32, 0x30, 0x37, 0x62, 0x31, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x33, 0x35, 0x61, 0x33, 0x36, 0x35, 0x32, 0x34, 0x37, 0x38, 0x66, 0x38, 0x32, 0x64, 0x62, 0x64, 0x36, 0x64, 0x31, 0x31, 0x35, 0x66, 0x61, 0x61, 0x38, 0x63, 0x61, 0x39, 0x34, 0x36, 0x65, 0x63, 0x39, 0x65, 0x36, 0x38, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x35, 0x38, 0x30, 0x31, 0x62, 0x31, 0x65, 0x62, 0x33, 0x30, 0x62, 0x37, 0x31, 0x32, 0x64, 0x38, 0x61, 0x30, 0x35, 0x37, 0x35, 0x61, 0x39, 0x61, 0x37, 0x31, 0x66, 0x66, 0x39, 0x36, 0x35, 0x64, 0x34, 0x66, 0x33, 0x34, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x64, 0x62, 0x62, 0x36, 0x61, 0x61, 0x61, 0x64, 0x31, 0x34, 0x39, 0x35, 0x38, 0x35, 0x62, 0x65, 0x34, 0x37, 0x33, 0x37, 0x35, 0x63, 0x35, 0x64, 0x36, 0x64, 0x65, 0x35, 0x66, 0x66, 0x30, 0x39, 0x31, 0x39, 0x31, 0x35, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x34, 0x33, 0x61, 0x30, 0x31, 0x31, 0x65, 0x63, 0x34, 0x32, 0x37, 0x30, 0x65, 0x65, 0x37, 0x65, 0x63, 0x38, 0x62, 0x39, 0x36, 0x38, 0x37, 0x33, 0x37, 0x35, 0x31, 0x35, 0x65, 0x35, 0x30, 0x33, 0x66, 0x38, 0x33, 0x30, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x33, 0x37, 0x31, 0x63, 0x37, 0x32, 0x63, 0x39, 0x66, 0x30, 0x33, 0x31, 0x36, 0x63, 0x65, 0x61, 0x32, 0x62, 0x64, 0x39, 0x63, 0x36, 0x66, 0x62, 0x62, 0x34, 0x30, 0x37, 0x39, 0x65, 0x37, 0x37, 0x35, 0x34, 0x32, 0x39, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x31, 0x64, 0x66, 0x39, 0x32, 0x65, 0x35, 0x31, 0x64, 0x66, 0x66, 0x37, 0x30, 0x62, 0x31, 0x39, 0x37, 0x33, 0x65, 0x30, 0x65, 0x39, 0x32, 0x34, 0x63, 0x36, 0x36, 0x32, 0x38, 0x37, 0x62, 0x34, 0x39, 0x34, 0x61, 0x31, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x35, 0x66, 0x34, 0x36, 0x63, 0x61, 0x61, 0x62, 0x32, 0x63, 0x33, 0x64, 0x34, 0x62, 0x32, 0x38, 0x39, 0x33, 0x39, 0x36, 0x62, 0x62, 0x62, 0x30, 0x37, 0x66, 0x32, 0x30, 0x33, 0x63, 0x34, 0x64, 0x61, 0x38, 0x32, 0x35, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x32, 0x39, 0x66, 0x63, 0x35, 0x32, 0x33, 0x61, 0x32, 0x63, 0x31, 0x36, 0x32, 0x39, 0x35, 0x33, 0x32, 0x31, 0x32, 0x31, 0x64, 0x61, 0x39, 0x39, 0x39, 0x38, 0x65, 0x39, 0x62, 0x35, 0x61, 0x62, 0x39, 0x64, 0x31, 0x62, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x62, 0x32, 0x36, 0x33, 0x31, 0x37, 0x32, 0x32, 0x37, 0x66, 0x34, 0x35, 0x63, 0x38, 0x37, 0x61, 0x32, 0x63, 0x62, 0x39, 0x30, 0x64, 0x63, 0x34, 0x63, 0x66, 0x64, 0x30, 0x32, 0x66, 0x62, 0x32, 0x33, 0x63, 0x61, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x65, 0x34, 0x36, 0x37, 0x38, 0x33, 0x33, 0x32, 0x39, 0x61, 0x37, 0x36, 0x39, 0x33, 0x30, 0x31, 0x62, 0x31, 0x37, 0x35, 0x30, 0x30, 0x39, 0x64, 0x33, 0x34, 0x36, 0x37, 0x36, 0x38, 0x66, 0x34, 0x63, 0x38, 0x37, 0x65, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x61, 0x64, 0x39, 0x64, 0x63, 0x32, 0x30, 0x64, 0x35, 0x38, 0x39, 0x63, 0x65, 0x34, 0x32, 0x38, 0x64, 0x38, 0x66, 0x64, 0x61, 0x33, 0x61, 0x39, 0x64, 0x35, 0x33, 0x61, 0x36, 0x30, 0x37, 0x62, 0x37, 0x39, 0x38, 0x38, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x30, 0x33, 0x34, 0x65, 0x31, 0x36, 0x32, 0x31, 0x38, 0x36, 0x35, 0x31, 0x33, 0x37, 0x63, 0x64, 0x34, 0x37, 0x33, 0x39, 0x62, 0x33, 0x34, 0x36, 0x64, 0x63, 0x31, 0x37, 0x64, 0x61, 0x33, 0x61, 0x32, 0x37, 0x63, 0x33, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x33, 0x32, 0x33, 0x39, 0x65, 0x32, 0x65, 0x38, 0x34, 0x31, 0x32, 0x34, 0x32, 0x64, 0x62, 0x39, 0x38, 0x39, 0x61, 0x36, 0x31, 0x35, 0x31, 0x38, 0x63, 0x32, 0x32, 0x32, 0x34, 0x37, 0x65, 0x38, 0x63, 0x35, 0x35, 0x32, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x33, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x30, 0x64, 0x36, 0x30, 0x39, 0x61, 0x61, 0x65, 0x32, 0x33, 0x33, 0x32, 0x62, 0x31, 0x33, 0x37, 0x61, 0x62, 0x33, 0x62, 0x32, 0x66, 0x32, 0x36, 0x36, 0x31, 0x35, 0x61, 0x38, 0x30, 0x38, 0x66, 0x33, 0x37, 0x65, 0x34, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x33, 0x34, 0x63, 0x35, 0x39, 0x30, 0x63, 0x37, 0x61, 0x34, 0x38, 0x37, 0x36, 0x39, 0x31, 0x30, 0x33, 0x30, 0x34, 0x35, 0x63, 0x35, 0x62, 0x36, 0x35, 0x33, 0x34, 0x63, 0x38, 0x61, 0x33, 0x34, 0x36, 0x39, 0x66, 0x34, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x34, 0x34, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x66, 0x63, 0x63, 0x61, 0x31, 0x33, 0x66, 0x39, 0x33, 0x34, 0x66, 0x30, 0x63, 0x66, 0x62, 0x65, 0x32, 0x33, 0x31, 0x64, 0x61, 0x31, 0x33, 0x30, 0x33, 0x39, 0x64, 0x37, 0x30, 0x34, 0x37, 0x35, 0x65, 0x36, 0x61, 0x31, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x37, 0x32, 0x38, 0x38, 0x64, 0x39, 0x31, 0x30, 0x38, 0x36, 0x64, 0x39, 0x65, 0x32, 0x65, 0x62, 0x39, 0x31, 0x30, 0x30, 0x31, 0x34, 0x64, 0x39, 0x61, 0x62, 0x39, 0x30, 0x61, 0x30, 0x32, 0x64, 0x37, 0x38, 0x63, 0x32, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x39, 0x31, 0x66, 0x62, 0x31, 0x61, 0x36, 0x39, 0x35, 0x35, 0x35, 0x33, 0x66, 0x30, 0x63, 0x36, 0x38, 0x65, 0x32, 0x31, 0x32, 0x37, 0x36, 0x64, 0x65, 0x63, 0x66, 0x30, 0x62, 0x38, 0x33, 0x39, 0x30, 0x39, 0x62, 0x38, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x36, 0x39, 0x35, 0x66, 0x63, 0x37, 0x65, 0x31, 0x33, 0x36, 0x37, 0x63, 0x65, 0x62, 0x31, 0x36, 0x33, 0x65, 0x62, 0x62, 0x30, 0x35, 0x33, 0x37, 0x35, 0x31, 0x66, 0x39, 0x66, 0x36, 0x38, 0x64, 0x64, 0x62, 0x30, 0x37, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x30, 0x39, 0x33, 0x62, 0x32, 0x33, 0x39, 0x62, 0x62, 0x66, 0x62, 0x61, 0x32, 0x33, 0x63, 0x37, 0x37, 0x37, 0x35, 0x63, 0x61, 0x37, 0x64, 0x61, 0x35, 0x61, 0x38, 0x36, 0x34, 0x38, 0x61, 0x39, 0x66, 0x35, 0x34, 0x63, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x64, 0x38, 0x66, 0x65, 0x65, 0x33, 0x63, 0x62, 0x38, 0x36, 0x34, 0x64, 0x63, 0x65, 0x32, 0x32, 0x62, 0x62, 0x32, 0x36, 0x63, 0x61, 0x39, 0x63, 0x32, 0x66, 0x30, 0x38, 0x36, 0x64, 0x35, 0x65, 0x39, 0x35, 0x65, 0x36, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x31, 0x35, 0x35, 0x32, 0x31, 0x33, 0x34, 0x34, 0x39, 0x38, 0x39, 0x32, 0x37, 0x34, 0x34, 0x62, 0x63, 0x36, 0x30, 0x66, 0x32, 0x65, 0x30, 0x34, 0x34, 0x30, 0x30, 0x37, 0x38, 0x38, 0x62, 0x64, 0x30, 0x34, 0x31, 0x66, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x61, 0x37, 0x31, 0x62, 0x32, 0x64, 0x30, 0x38, 0x35, 0x38, 0x65, 0x38, 0x33, 0x32, 0x37, 0x30, 0x30, 0x38, 0x35, 0x64, 0x39, 0x35, 0x61, 0x33, 0x62, 0x31, 0x35, 0x34, 0x39, 0x36, 0x35, 0x30, 0x30, 0x33, 0x35, 0x65, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x63, 0x31, 0x37, 0x62, 0x38, 0x31, 0x65, 0x64, 0x35, 0x31, 0x39, 0x31, 0x66, 0x62, 0x30, 0x38, 0x30, 0x32, 0x61, 0x61, 0x35, 0x34, 0x33, 0x33, 0x37, 0x33, 0x31, 0x33, 0x38, 0x33, 0x34, 0x31, 0x30, 0x37, 0x61, 0x61, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x30, 0x37, 0x36, 0x61, 0x61, 0x63, 0x39, 0x32, 0x32, 0x30, 0x38, 0x30, 0x36, 0x39, 0x65, 0x61, 0x33, 0x31, 0x38, 0x61, 0x33, 0x31, 0x66, 0x66, 0x38, 0x65, 0x65, 0x62, 0x31, 0x34, 0x62, 0x37, 0x65, 0x39, 0x39, 0x36, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x34, 0x36, 0x65, 0x37, 0x63, 0x31, 0x65, 0x39, 0x30, 0x37, 0x38, 0x63, 0x61, 0x65, 0x38, 0x36, 0x33, 0x30, 0x35, 0x61, 0x63, 0x37, 0x30, 0x36, 0x30, 0x62, 0x30, 0x31, 0x34, 0x36, 0x37, 0x64, 0x36, 0x36, 0x38, 0x35, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x39, 0x38, 0x31, 0x32, 0x37, 0x39, 0x38, 0x32, 0x66, 0x32, 0x66, 0x38, 0x61, 0x64, 0x33, 0x62, 0x36, 0x62, 0x38, 0x66, 0x63, 0x33, 0x63, 0x66, 0x32, 0x37, 0x62, 0x66, 0x36, 0x31, 0x37, 0x38, 0x30, 0x31, 0x62, 0x61, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x31, 0x64, 0x61, 0x63, 0x30, 0x31, 0x39, 0x35, 0x62, 0x31, 0x39, 0x65, 0x33, 0x37, 0x62, 0x35, 0x39, 0x62, 0x35, 0x33, 0x66, 0x37, 0x63, 0x30, 0x31, 0x37, 0x63, 0x30, 0x62, 0x32, 0x33, 0x39, 0x35, 0x62, 0x61, 0x34, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x33, 0x36, 0x63, 0x37, 0x35, 0x34, 0x35, 0x33, 0x63, 0x63, 0x63, 0x61, 0x34, 0x61, 0x31, 0x66, 0x31, 0x62, 0x36, 0x32, 0x65, 0x35, 0x63, 0x34, 0x61, 0x33, 0x30, 0x64, 0x38, 0x36, 0x64, 0x64, 0x65, 0x34, 0x62, 0x65, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x30, 0x30, 0x31, 0x62, 0x38, 0x39, 0x65, 0x64, 0x38, 0x37, 0x33, 0x65, 0x33, 0x61, 0x61, 0x65, 0x63, 0x31, 0x31, 0x35, 0x35, 0x36, 0x33, 0x34, 0x62, 0x34, 0x36, 0x38, 0x31, 0x36, 0x34, 0x33, 0x39, 0x38, 0x36, 0x33, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x39, 0x33, 0x62, 0x32, 0x36, 0x65, 0x63, 0x65, 0x30, 0x61, 0x30, 0x61, 0x61, 0x32, 0x31, 0x33, 0x36, 0x35, 0x61, 0x66, 0x65, 0x64, 0x31, 0x66, 0x61, 0x39, 0x61, 0x65, 0x61, 0x33, 0x31, 0x63, 0x64, 0x35, 0x34, 0x34, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x37, 0x66, 0x65, 0x62, 0x61, 0x62, 0x64, 0x66, 0x30, 0x38, 0x30, 0x66, 0x30, 0x66, 0x35, 0x64, 0x63, 0x61, 0x31, 0x64, 0x33, 0x66, 0x35, 0x37, 0x36, 0x36, 0x66, 0x32, 0x61, 0x37, 0x39, 0x63, 0x30, 0x66, 0x66, 0x61, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x34, 0x61, 0x66, 0x30, 0x65, 0x38, 0x36, 0x33, 0x64, 0x32, 0x36, 0x35, 0x36, 0x63, 0x38, 0x36, 0x33, 0x35, 0x62, 0x63, 0x36, 0x66, 0x66, 0x65, 0x63, 0x38, 0x64, 0x64, 0x39, 0x39, 0x32, 0x38, 0x39, 0x30, 0x38, 0x63, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x34, 0x38, 0x61, 0x65, 0x36, 0x32, 0x64, 0x31, 0x35, 0x33, 0x39, 0x37, 0x38, 0x38, 0x65, 0x62, 0x61, 0x30, 0x31, 0x33, 0x64, 0x37, 0x35, 0x65, 0x61, 0x36, 0x30, 0x62, 0x36, 0x34, 0x65, 0x65, 0x62, 0x61, 0x34, 0x65, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x31, 0x33, 0x33, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x33, 0x63, 0x63, 0x34, 0x35, 0x39, 0x34, 0x63, 0x66, 0x34, 0x61, 0x62, 0x62, 0x36, 0x33, 0x36, 0x38, 0x64, 0x65, 0x35, 0x39, 0x66, 0x64, 0x32, 0x62, 0x31, 0x32, 0x33, 0x30, 0x37, 0x33, 0x34, 0x36, 0x31, 0x32, 0x31, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x36, 0x62, 0x32, 0x38, 0x63, 0x38, 0x38, 0x34, 0x32, 0x31, 0x65, 0x34, 0x38, 0x35, 0x37, 0x65, 0x34, 0x35, 0x39, 0x32, 0x38, 0x31, 0x64, 0x37, 0x38, 0x34, 0x36, 0x31, 0x36, 0x39, 0x32, 0x34, 0x38, 0x39, 0x64, 0x33, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x36, 0x38, 0x35, 0x34, 0x35, 0x38, 0x38, 0x65, 0x63, 0x63, 0x65, 0x35, 0x34, 0x31, 0x34, 0x39, 0x35, 0x66, 0x38, 0x31, 0x63, 0x32, 0x38, 0x61, 0x32, 0x39, 0x30, 0x33, 0x37, 0x33, 0x64, 0x66, 0x30, 0x32, 0x37, 0x34, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x37, 0x36, 0x65, 0x38, 0x35, 0x62, 0x61, 0x35, 0x30, 0x62, 0x39, 0x62, 0x33, 0x31, 0x65, 0x63, 0x31, 0x65, 0x32, 0x36, 0x32, 0x30, 0x62, 0x63, 0x65, 0x36, 0x65, 0x37, 0x63, 0x38, 0x30, 0x35, 0x38, 0x63, 0x30, 0x65, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x30, 0x39, 0x39, 0x36, 0x62, 0x30, 0x35, 0x36, 0x36, 0x65, 0x63, 0x62, 0x33, 0x65, 0x37, 0x32, 0x34, 0x33, 0x62, 0x38, 0x32, 0x32, 0x37, 0x39, 0x38, 0x38, 0x64, 0x63, 0x62, 0x33, 0x35, 0x32, 0x63, 0x32, 0x31, 0x38, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x64, 0x31, 0x34, 0x35, 0x35, 0x32, 0x62, 0x31, 0x64, 0x63, 0x65, 0x30, 0x64, 0x36, 0x64, 0x63, 0x31, 0x66, 0x33, 0x32, 0x30, 0x64, 0x61, 0x36, 0x66, 0x66, 0x63, 0x38, 0x61, 0x33, 0x33, 0x31, 0x63, 0x64, 0x36, 0x66, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x61, 0x36, 0x31, 0x62, 0x31, 0x30, 0x39, 0x34, 0x38, 0x30, 0x62, 0x35, 0x62, 0x32, 0x63, 0x34, 0x66, 0x63, 0x66, 0x64, 0x65, 0x66, 0x39, 0x32, 0x64, 0x39, 0x30, 0x35, 0x38, 0x34, 0x31, 0x36, 0x30, 0x63, 0x30, 0x64, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x39, 0x34, 0x37, 0x38, 0x32, 0x32, 0x64, 0x35, 0x61, 0x63, 0x65, 0x37, 0x61, 0x36, 0x61, 0x64, 0x38, 0x33, 0x32, 0x36, 0x65, 0x39, 0x35, 0x34, 0x39, 0x36, 0x32, 0x32, 0x31, 0x65, 0x30, 0x62, 0x65, 0x36, 0x62, 0x37, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x32, 0x64, 0x65, 0x34, 0x36, 0x61, 0x61, 0x66, 0x38, 0x66, 0x31, 0x64, 0x37, 0x30, 0x38, 0x64, 0x35, 0x39, 0x64, 0x37, 0x39, 0x61, 0x66, 0x31, 0x64, 0x30, 0x33, 0x61, 0x64, 0x32, 0x63, 0x62, 0x36, 0x30, 0x39, 0x30, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x30, 0x64, 0x36, 0x36, 0x33, 0x33, 0x64, 0x62, 0x31, 0x65, 0x30, 0x63, 0x37, 0x66, 0x32, 0x33, 0x34, 0x61, 0x36, 0x64, 0x66, 0x31, 0x36, 0x33, 0x61, 0x31, 0x30, 0x65, 0x30, 0x61, 0x62, 0x33, 0x39, 0x63, 0x32, 0x30, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x62, 0x66, 0x39, 0x63, 0x30, 0x34, 0x38, 0x37, 0x34, 0x65, 0x35, 0x61, 0x37, 0x37, 0x66, 0x33, 0x38, 0x66, 0x34, 0x63, 0x33, 0x38, 0x35, 0x32, 0x37, 0x65, 0x38, 0x30, 0x63, 0x36, 0x37, 0x36, 0x66, 0x37, 0x62, 0x38, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x35, 0x32, 0x38, 0x33, 0x35, 0x30, 0x65, 0x30, 0x64, 0x39, 0x36, 0x37, 0x30, 0x61, 0x32, 0x65, 0x61, 0x32, 0x37, 0x66, 0x37, 0x62, 0x34, 0x61, 0x33, 0x33, 0x62, 0x39, 0x63, 0x30, 0x66, 0x39, 0x36, 0x32, 0x31, 0x64, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x63, 0x66, 0x37, 0x61, 0x30, 0x34, 0x35, 0x37, 0x62, 0x35, 0x36, 0x36, 0x62, 0x33, 0x34, 0x36, 0x63, 0x61, 0x36, 0x37, 0x33, 0x61, 0x31, 0x38, 0x30, 0x66, 0x34, 0x34, 0x34, 0x31, 0x33, 0x30, 0x32, 0x31, 0x36, 0x61, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x63, 0x66, 0x35, 0x36, 0x30, 0x39, 0x36, 0x34, 0x66, 0x66, 0x38, 0x33, 0x63, 0x31, 0x63, 0x39, 0x36, 0x37, 0x34, 0x63, 0x37, 0x38, 0x33, 0x63, 0x30, 0x66, 0x37, 0x33, 0x66, 0x63, 0x64, 0x38, 0x39, 0x39, 0x34, 0x33, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x66, 0x30, 0x36, 0x66, 0x36, 0x39, 0x39, 0x62, 0x65, 0x33, 0x31, 0x63, 0x34, 0x34, 0x30, 0x62, 0x34, 0x33, 0x62, 0x34, 0x64, 0x62, 0x30, 0x35, 0x30, 0x31, 0x65, 0x63, 0x30, 0x65, 0x32, 0x35, 0x32, 0x36, 0x31, 0x36, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x63, 0x65, 0x34, 0x64, 0x63, 0x35, 0x36, 0x30, 0x66, 0x63, 0x37, 0x33, 0x64, 0x63, 0x36, 0x39, 0x66, 0x62, 0x37, 0x61, 0x36, 0x32, 0x65, 0x33, 0x38, 0x38, 0x64, 0x62, 0x37, 0x65, 0x37, 0x32, 0x65, 0x61, 0x37, 0x36, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x35, 0x36, 0x30, 0x35, 0x35, 0x61, 0x31, 0x31, 0x61, 0x62, 0x39, 0x31, 0x66, 0x66, 0x36, 0x36, 0x38, 0x65, 0x32, 0x65, 0x63, 0x39, 0x32, 0x32, 0x39, 0x36, 0x31, 0x66, 0x32, 0x61, 0x32, 0x33, 0x65, 0x33, 0x64, 0x62, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x66, 0x62, 0x61, 0x66, 0x62, 0x63, 0x30, 0x65, 0x35, 0x62, 0x35, 0x63, 0x38, 0x36, 0x63, 0x64, 0x31, 0x61, 0x64, 0x36, 0x39, 0x37, 0x66, 0x65, 0x65, 0x61, 0x30, 0x34, 0x66, 0x34, 0x33, 0x31, 0x38, 0x38, 0x64, 0x65, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x35, 0x62, 0x34, 0x61, 0x62, 0x37, 0x35, 0x64, 0x38, 0x33, 0x36, 0x32, 0x64, 0x39, 0x31, 0x34, 0x34, 0x33, 0x35, 0x63, 0x65, 0x64, 0x65, 0x65, 0x31, 0x64, 0x61, 0x61, 0x32, 0x62, 0x31, 0x65, 0x65, 0x31, 0x61, 0x32, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x30, 0x30, 0x64, 0x36, 0x35, 0x31, 0x62, 0x62, 0x33, 0x66, 0x32, 0x64, 0x32, 0x33, 0x64, 0x35, 0x66, 0x38, 0x34, 0x39, 0x65, 0x36, 0x66, 0x39, 0x32, 0x64, 0x39, 0x63, 0x35, 0x37, 0x39, 0x35, 0x63, 0x34, 0x33, 0x61, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x31, 0x61, 0x61, 0x39, 0x31, 0x63, 0x38, 0x32, 0x66, 0x34, 0x32, 0x66, 0x61, 0x64, 0x35, 0x64, 0x64, 0x38, 0x65, 0x38, 0x62, 0x62, 0x35, 0x65, 0x61, 0x36, 0x39, 0x63, 0x38, 0x66, 0x33, 0x61, 0x35, 0x39, 0x37, 0x37, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x38, 0x36, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x39, 0x33, 0x35, 0x62, 0x62, 0x32, 0x35, 0x30, 0x37, 0x37, 0x38, 0x62, 0x33, 0x63, 0x34, 0x63, 0x37, 0x66, 0x37, 0x65, 0x30, 0x37, 0x66, 0x63, 0x32, 0x35, 0x31, 0x66, 0x61, 0x36, 0x33, 0x30, 0x33, 0x31, 0x34, 0x61, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x64, 0x33, 0x35, 0x36, 0x31, 0x35, 0x36, 0x61, 0x33, 0x38, 0x33, 0x31, 0x32, 0x33, 0x33, 0x34, 0x33, 0x64, 0x34, 0x38, 0x38, 0x34, 0x33, 0x62, 0x66, 0x66, 0x65, 0x64, 0x36, 0x31, 0x30, 0x33, 0x65, 0x38, 0x36, 0x36, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x30, 0x62, 0x34, 0x38, 0x65, 0x34, 0x38, 0x39, 0x64, 0x33, 0x30, 0x32, 0x62, 0x34, 0x62, 0x37, 0x62, 0x66, 0x32, 0x30, 0x34, 0x66, 0x39, 0x35, 0x37, 0x63, 0x31, 0x63, 0x39, 0x62, 0x65, 0x33, 0x38, 0x33, 0x62, 0x30, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x38, 0x35, 0x61, 0x65, 0x37, 0x65, 0x37, 0x65, 0x34, 0x64, 0x39, 0x33, 0x32, 0x31, 0x39, 0x37, 0x62, 0x35, 0x63, 0x37, 0x38, 0x35, 0x38, 0x63, 0x30, 0x30, 0x61, 0x33, 0x36, 0x37, 0x34, 0x36, 0x32, 0x36, 0x62, 0x37, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x30, 0x36, 0x64, 0x31, 0x65, 0x36, 0x39, 0x33, 0x30, 0x63, 0x31, 0x30, 0x35, 0x34, 0x36, 0x39, 0x32, 0x62, 0x37, 0x39, 0x65, 0x33, 0x64, 0x62, 0x65, 0x36, 0x65, 0x63, 0x63, 0x65, 0x35, 0x33, 0x39, 0x36, 0x36, 0x34, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x66, 0x35, 0x33, 0x64, 0x39, 0x36, 0x31, 0x39, 0x31, 0x34, 0x37, 0x31, 0x65, 0x30, 0x35, 0x39, 0x64, 0x65, 0x35, 0x31, 0x63, 0x37, 0x31, 0x38, 0x62, 0x39, 0x38, 0x33, 0x65, 0x34, 0x61, 0x35, 0x31, 0x64, 0x32, 0x61, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x37, 0x38, 0x36, 0x35, 0x34, 0x61, 0x63, 0x36, 0x37, 0x36, 0x31, 0x64, 0x62, 0x39, 0x30, 0x34, 0x61, 0x32, 0x66, 0x37, 0x65, 0x38, 0x35, 0x39, 0x35, 0x65, 0x63, 0x31, 0x65, 0x61, 0x61, 0x63, 0x37, 0x33, 0x34, 0x33, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x66, 0x65, 0x65, 0x33, 0x30, 0x64, 0x31, 0x37, 0x32, 0x38, 0x64, 0x39, 0x36, 0x63, 0x65, 0x63, 0x63, 0x31, 0x64, 0x61, 0x62, 0x33, 0x64, 0x61, 0x32, 0x65, 0x37, 0x37, 0x31, 0x61, 0x66, 0x62, 0x63, 0x66, 0x61, 0x61, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x63, 0x35, 0x64, 0x30, 0x36, 0x62, 0x31, 0x37, 0x30, 0x65, 0x65, 0x34, 0x64, 0x32, 0x36, 0x65, 0x62, 0x30, 0x61, 0x30, 0x65, 0x62, 0x34, 0x36, 0x63, 0x62, 0x37, 0x64, 0x39, 0x30, 0x63, 0x31, 0x63, 0x39, 0x31, 0x30, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x31, 0x32, 0x39, 0x63, 0x32, 0x36, 0x62, 0x37, 0x35, 0x64, 0x64, 0x65, 0x31, 0x32, 0x37, 0x66, 0x38, 0x33, 0x32, 0x30, 0x62, 0x64, 0x30, 0x66, 0x36, 0x33, 0x34, 0x31, 0x30, 0x63, 0x39, 0x32, 0x61, 0x39, 0x66, 0x38, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x36, 0x61, 0x65, 0x30, 0x35, 0x33, 0x66, 0x63, 0x62, 0x63, 0x33, 0x31, 0x38, 0x64, 0x36, 0x66, 0x64, 0x30, 0x66, 0x62, 0x63, 0x33, 0x35, 0x33, 0x62, 0x38, 0x62, 0x66, 0x35, 0x34, 0x32, 0x65, 0x36, 0x38, 0x30, 0x64, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x35, 0x61, 0x36, 0x30, 0x62, 0x66, 0x35, 0x32, 0x32, 0x66, 0x62, 0x64, 0x38, 0x66, 0x66, 0x66, 0x39, 0x37, 0x32, 0x33, 0x34, 0x34, 0x36, 0x62, 0x37, 0x65, 0x33, 0x34, 0x33, 0x61, 0x37, 0x30, 0x36, 0x38, 0x35, 0x36, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x37, 0x65, 0x31, 0x31, 0x65, 0x35, 0x65, 0x61, 0x32, 0x39, 0x30, 0x64, 0x36, 0x66, 0x63, 0x33, 0x62, 0x33, 0x38, 0x30, 0x34, 0x38, 0x39, 0x37, 0x39, 0x65, 0x30, 0x63, 0x64, 0x34, 0x34, 0x65, 0x63, 0x37, 0x63, 0x31, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x31, 0x65, 0x63, 0x66, 0x37, 0x37, 0x64, 0x37, 0x31, 0x62, 0x33, 0x64, 0x30, 0x65, 0x61, 0x39, 0x35, 0x63, 0x65, 0x34, 0x37, 0x35, 0x38, 0x61, 0x66, 0x65, 0x63, 0x64, 0x62, 0x39, 0x63, 0x31, 0x33, 0x31, 0x30, 0x37, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x39, 0x65, 0x66, 0x66, 0x34, 0x63, 0x37, 0x39, 0x38, 0x38, 0x31, 0x31, 0x64, 0x39, 0x36, 0x38, 0x64, 0x63, 0x63, 0x62, 0x34, 0x36, 0x30, 0x64, 0x39, 0x62, 0x30, 0x36, 0x39, 0x63, 0x66, 0x33, 0x30, 0x32, 0x37, 0x38, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x38, 0x39, 0x32, 0x65, 0x38, 0x30, 0x38, 0x31, 0x62, 0x66, 0x33, 0x36, 0x65, 0x34, 0x38, 0x38, 0x66, 0x64, 0x64, 0x62, 0x33, 0x62, 0x32, 0x36, 0x33, 0x30, 0x66, 0x33, 0x66, 0x31, 0x65, 0x38, 0x64, 0x61, 0x33, 0x30, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x64, 0x65, 0x37, 0x65, 0x33, 0x64, 0x63, 0x35, 0x30, 0x37, 0x34, 0x39, 0x63, 0x36, 0x63, 0x35, 0x30, 0x65, 0x32, 0x65, 0x32, 0x38, 0x31, 0x36, 0x38, 0x34, 0x37, 0x38, 0x63, 0x33, 0x34, 0x64, 0x62, 0x38, 0x31, 0x39, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x33, 0x30, 0x63, 0x61, 0x63, 0x63, 0x33, 0x66, 0x37, 0x32, 0x32, 0x36, 0x39, 0x66, 0x38, 0x62, 0x34, 0x66, 0x30, 0x34, 0x63, 0x66, 0x30, 0x37, 0x33, 0x64, 0x32, 0x62, 0x30, 0x35, 0x61, 0x38, 0x33, 0x64, 0x39, 0x61, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x31, 0x65, 0x62, 0x38, 0x37, 0x65, 0x37, 0x66, 0x62, 0x37, 0x33, 0x31, 0x31, 0x66, 0x35, 0x32, 0x32, 0x38, 0x63, 0x34, 0x37, 0x39, 0x62, 0x34, 0x38, 0x65, 0x63, 0x39, 0x38, 0x37, 0x38, 0x38, 0x33, 0x31, 0x61, 0x63, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x30, 0x31, 0x64, 0x61, 0x33, 0x34, 0x64, 0x34, 0x37, 0x30, 0x63, 0x31, 0x64, 0x31, 0x31, 0x35, 0x61, 0x63, 0x66, 0x34, 0x64, 0x38, 0x31, 0x31, 0x33, 0x63, 0x34, 0x64, 0x64, 0x38, 0x61, 0x38, 0x63, 0x33, 0x33, 0x38, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x32, 0x39, 0x66, 0x63, 0x30, 0x39, 0x33, 0x31, 0x63, 0x62, 0x65, 0x62, 0x30, 0x33, 0x33, 0x38, 0x38, 0x30, 0x66, 0x65, 0x34, 0x63, 0x39, 0x33, 0x39, 0x38, 0x63, 0x61, 0x34, 0x35, 0x62, 0x30, 0x65, 0x32, 0x64, 0x31, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x30, 0x63, 0x30, 0x37, 0x32, 0x38, 0x30, 0x32, 0x30, 0x31, 0x34, 0x65, 0x66, 0x30, 0x64, 0x35, 0x36, 0x31, 0x33, 0x34, 0x35, 0x61, 0x65, 0x63, 0x34, 0x38, 0x31, 0x65, 0x38, 0x65, 0x31, 0x31, 0x63, 0x62, 0x33, 0x35, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x65, 0x35, 0x64, 0x32, 0x62, 0x61, 0x65, 0x39, 0x39, 0x35, 0x63, 0x63, 0x66, 0x64, 0x30, 0x38, 0x61, 0x35, 0x63, 0x31, 0x36, 0x62, 0x62, 0x35, 0x32, 0x34, 0x65, 0x31, 0x66, 0x36, 0x33, 0x30, 0x34, 0x34, 0x38, 0x66, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x66, 0x38, 0x63, 0x30, 0x33, 0x65, 0x62, 0x33, 0x65, 0x38, 0x37, 0x32, 0x65, 0x35, 0x30, 0x66, 0x37, 0x63, 0x66, 0x64, 0x30, 0x63, 0x32, 0x66, 0x38, 0x64, 0x33, 0x62, 0x33, 0x66, 0x32, 0x63, 0x62, 0x35, 0x31, 0x38, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x30, 0x66, 0x32, 0x65, 0x35, 0x31, 0x33, 0x37, 0x38, 0x66, 0x36, 0x62, 0x30, 0x64, 0x37, 0x62, 0x61, 0x62, 0x36, 0x31, 0x37, 0x33, 0x33, 0x31, 0x35, 0x38, 0x30, 0x62, 0x36, 0x65, 0x33, 0x39, 0x61, 0x64, 0x33, 0x63, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x66, 0x32, 0x34, 0x31, 0x32, 0x35, 0x35, 0x64, 0x64, 0x37, 0x63, 0x33, 0x66, 0x37, 0x33, 0x63, 0x30, 0x37, 0x30, 0x34, 0x33, 0x30, 0x37, 0x31, 0x65, 0x63, 0x30, 0x38, 0x64, 0x64, 0x64, 0x39, 0x63, 0x35, 0x63, 0x64, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x65, 0x31, 0x62, 0x39, 0x34, 0x38, 0x38, 0x36, 0x34, 0x64, 0x38, 0x34, 0x37, 0x34, 0x65, 0x37, 0x36, 0x35, 0x31, 0x34, 0x35, 0x38, 0x35, 0x38, 0x66, 0x63, 0x61, 0x34, 0x35, 0x35, 0x30, 0x66, 0x37, 0x38, 0x34, 0x62, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x37, 0x34, 0x32, 0x63, 0x63, 0x64, 0x66, 0x34, 0x61, 0x62, 0x62, 0x63, 0x64, 0x30, 0x30, 0x35, 0x36, 0x38, 0x31, 0x66, 0x38, 0x31, 0x35, 0x39, 0x33, 0x34, 0x35, 0x63, 0x39, 0x65, 0x37, 0x39, 0x30, 0x35, 0x34, 0x62, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x65, 0x62, 0x39, 0x66, 0x37, 0x34, 0x37, 0x34, 0x32, 0x65, 0x61, 0x34, 0x39, 0x31, 0x38, 0x31, 0x33, 0x64, 0x62, 0x62, 0x66, 0x30, 0x64, 0x36, 0x66, 0x63, 0x64, 0x65, 0x31, 0x61, 0x31, 0x33, 0x31, 0x64, 0x34, 0x64, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x31, 0x65, 0x62, 0x39, 0x30, 0x39, 0x39, 0x34, 0x61, 0x32, 0x66, 0x62, 0x66, 0x39, 0x34, 0x62, 0x64, 0x63, 0x33, 0x32, 0x33, 0x33, 0x39, 0x31, 0x30, 0x32, 0x39, 0x36, 0x66, 0x37, 0x36, 0x66, 0x39, 0x62, 0x66, 0x36, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x63, 0x31, 0x61, 0x33, 0x37, 0x65, 0x65, 0x35, 0x66, 0x30, 0x38, 0x32, 0x36, 0x35, 0x61, 0x31, 0x65, 0x31, 0x30, 0x64, 0x33, 0x64, 0x39, 0x30, 0x64, 0x35, 0x34, 0x37, 0x32, 0x39, 0x35, 0x35, 0x66, 0x39, 0x37, 0x38, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x66, 0x39, 0x38, 0x62, 0x35, 0x32, 0x62, 0x65, 0x65, 0x39, 0x35, 0x33, 0x62, 0x65, 0x66, 0x39, 0x39, 0x32, 0x66, 0x33, 0x30, 0x35, 0x66, 0x64, 0x61, 0x30, 0x32, 0x37, 0x66, 0x38, 0x39, 0x31, 0x31, 0x63, 0x35, 0x38, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x34, 0x37, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x64, 0x63, 0x35, 0x33, 0x65, 0x66, 0x38, 0x63, 0x31, 0x38, 0x65, 0x64, 0x33, 0x30, 0x35, 0x31, 0x37, 0x38, 0x35, 0x64, 0x38, 0x38, 0x65, 0x39, 0x39, 0x36, 0x66, 0x33, 0x65, 0x34, 0x62, 0x32, 0x30, 0x65, 0x63, 0x64, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x37, 0x66, 0x34, 0x61, 0x32, 0x33, 0x63, 0x61, 0x30, 0x30, 0x63, 0x64, 0x30, 0x34, 0x33, 0x64, 0x32, 0x35, 0x63, 0x32, 0x38, 0x38, 0x38, 0x63, 0x31, 0x61, 0x61, 0x35, 0x36, 0x38, 0x38, 0x66, 0x38, 0x31, 0x61, 0x33, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x33, 0x36, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x37, 0x33, 0x35, 0x64, 0x32, 0x32, 0x34, 0x37, 0x39, 0x32, 0x33, 0x37, 0x36, 0x64, 0x33, 0x33, 0x31, 0x33, 0x36, 0x37, 0x63, 0x30, 0x39, 0x33, 0x64, 0x33, 0x31, 0x63, 0x38, 0x37, 0x39, 0x34, 0x33, 0x34, 0x31, 0x35, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x34, 0x34, 0x30, 0x63, 0x35, 0x62, 0x30, 0x37, 0x33, 0x62, 0x35, 0x32, 0x39, 0x62, 0x34, 0x38, 0x32, 0x39, 0x32, 0x30, 0x39, 0x64, 0x66, 0x66, 0x38, 0x38, 0x30, 0x39, 0x30, 0x65, 0x30, 0x37, 0x63, 0x34, 0x66, 0x36, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x37, 0x37, 0x32, 0x65, 0x32, 0x37, 0x66, 0x32, 0x38, 0x38, 0x30, 0x30, 0x63, 0x35, 0x30, 0x64, 0x64, 0x61, 0x39, 0x37, 0x33, 0x62, 0x62, 0x33, 0x33, 0x65, 0x31, 0x30, 0x37, 0x36, 0x32, 0x65, 0x36, 0x65, 0x65, 0x61, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x32, 0x39, 0x66, 0x61, 0x38, 0x38, 0x37, 0x33, 0x31, 0x66, 0x64, 0x64, 0x33, 0x35, 0x30, 0x65, 0x38, 0x65, 0x63, 0x64, 0x36, 0x65, 0x61, 0x35, 0x34, 0x32, 0x39, 0x36, 0x62, 0x36, 0x34, 0x38, 0x34, 0x66, 0x65, 0x36, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x64, 0x37, 0x36, 0x62, 0x37, 0x31, 0x36, 0x36, 0x62, 0x31, 0x66, 0x33, 0x61, 0x31, 0x32, 0x62, 0x34, 0x30, 0x39, 0x31, 0x65, 0x65, 0x32, 0x62, 0x32, 0x39, 0x64, 0x65, 0x38, 0x63, 0x61, 0x61, 0x37, 0x64, 0x30, 0x37, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x62, 0x64, 0x39, 0x35, 0x65, 0x39, 0x63, 0x34, 0x37, 0x30, 0x66, 0x37, 0x32, 0x38, 0x33, 0x35, 0x38, 0x33, 0x64, 0x63, 0x36, 0x65, 0x39, 0x64, 0x32, 0x63, 0x34, 0x64, 0x63, 0x65, 0x30, 0x62, 0x65, 0x61, 0x38, 0x66, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x33, 0x61, 0x37, 0x38, 0x61, 0x65, 0x61, 0x62, 0x61, 0x61, 0x35, 0x30, 0x64, 0x38, 0x64, 0x64, 0x64, 0x38, 0x35, 0x37, 0x30, 0x62, 0x63, 0x64, 0x33, 0x34, 0x32, 0x36, 0x35, 0x66, 0x31, 0x34, 0x62, 0x31, 0x39, 0x33, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x37, 0x39, 0x39, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x66, 0x39, 0x63, 0x34, 0x33, 0x32, 0x61, 0x34, 0x65, 0x35, 0x39, 0x61, 0x63, 0x38, 0x36, 0x32, 0x38, 0x32, 0x64, 0x36, 0x61, 0x64, 0x61, 0x62, 0x34, 0x63, 0x32, 0x65, 0x62, 0x38, 0x39, 0x31, 0x39, 0x31, 0x36, 0x30, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x36, 0x36, 0x30, 0x37, 0x30, 0x32, 0x31, 0x62, 0x36, 0x32, 0x64, 0x33, 0x34, 0x30, 0x63, 0x66, 0x32, 0x36, 0x35, 0x32, 0x66, 0x33, 0x66, 0x39, 0x35, 0x66, 0x64, 0x32, 0x64, 0x63, 0x36, 0x37, 0x36, 0x39, 0x38, 0x62, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x30, 0x39, 0x30, 0x39, 0x66, 0x64, 0x61, 0x32, 0x65, 0x61, 0x36, 0x62, 0x37, 0x62, 0x37, 0x61, 0x38, 0x38, 0x64, 0x62, 0x37, 0x61, 0x30, 0x61, 0x61, 0x63, 0x38, 0x36, 0x38, 0x30, 0x39, 0x31, 0x64, 0x64, 0x62, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x62, 0x38, 0x30, 0x65, 0x64, 0x39, 0x30, 0x66, 0x38, 0x34, 0x38, 0x33, 0x34, 0x61, 0x66, 0x61, 0x33, 0x66, 0x66, 0x38, 0x32, 0x65, 0x62, 0x39, 0x36, 0x34, 0x37, 0x30, 0x33, 0x62, 0x35, 0x36, 0x30, 0x39, 0x37, 0x37, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x34, 0x63, 0x61, 0x39, 0x65, 0x34, 0x37, 0x37, 0x39, 0x64, 0x35, 0x33, 0x30, 0x65, 0x63, 0x62, 0x61, 0x63, 0x64, 0x34, 0x37, 0x65, 0x36, 0x61, 0x38, 0x30, 0x35, 0x38, 0x63, 0x66, 0x64, 0x65, 0x36, 0x35, 0x64, 0x39, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x36, 0x63, 0x35, 0x63, 0x37, 0x32, 0x30, 0x64, 0x36, 0x36, 0x61, 0x36, 0x61, 0x62, 0x63, 0x61, 0x38, 0x33, 0x39, 0x37, 0x31, 0x34, 0x32, 0x65, 0x36, 0x33, 0x64, 0x32, 0x36, 0x38, 0x31, 0x38, 0x65, 0x61, 0x61, 0x62, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x63, 0x31, 0x33, 0x65, 0x37, 0x32, 0x64, 0x32, 0x36, 0x38, 0x65, 0x37, 0x31, 0x35, 0x30, 0x64, 0x63, 0x37, 0x39, 0x39, 0x65, 0x37, 0x63, 0x36, 0x63, 0x66, 0x30, 0x33, 0x63, 0x38, 0x38, 0x39, 0x35, 0x34, 0x63, 0x65, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x62, 0x64, 0x31, 0x65, 0x37, 0x31, 0x39, 0x33, 0x39, 0x30, 0x65, 0x36, 0x62, 0x39, 0x31, 0x30, 0x34, 0x33, 0x66, 0x38, 0x62, 0x36, 0x62, 0x39, 0x64, 0x66, 0x38, 0x39, 0x38, 0x65, 0x61, 0x38, 0x30, 0x30, 0x31, 0x62, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x62, 0x61, 0x36, 0x66, 0x34, 0x31, 0x33, 0x62, 0x38, 0x32, 0x66, 0x63, 0x64, 0x64, 0x66, 0x33, 0x61, 0x66, 0x66, 0x62, 0x62, 0x64, 0x64, 0x30, 0x39, 0x32, 0x38, 0x37, 0x64, 0x63, 0x66, 0x35, 0x30, 0x34, 0x31, 0x35, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x64, 0x33, 0x63, 0x37, 0x62, 0x65, 0x38, 0x64, 0x65, 0x37, 0x35, 0x38, 0x35, 0x31, 0x34, 0x30, 0x39, 0x35, 0x32, 0x61, 0x65, 0x62, 0x35, 0x30, 0x31, 0x64, 0x63, 0x31, 0x66, 0x38, 0x37, 0x36, 0x65, 0x63, 0x61, 0x66, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x36, 0x33, 0x66, 0x61, 0x39, 0x65, 0x32, 0x63, 0x62, 0x62, 0x66, 0x32, 0x33, 0x63, 0x34, 0x39, 0x66, 0x63, 0x64, 0x65, 0x66, 0x31, 0x63, 0x62, 0x61, 0x62, 0x66, 0x65, 0x36, 0x65, 0x30, 0x64, 0x31, 0x65, 0x31, 0x34, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x36, 0x65, 0x39, 0x39, 0x30, 0x64, 0x61, 0x61, 0x37, 0x31, 0x30, 0x35, 0x64, 0x65, 0x32, 0x35, 0x32, 0x36, 0x33, 0x33, 0x39, 0x38, 0x33, 0x33, 0x66, 0x37, 0x37, 0x62, 0x35, 0x63, 0x30, 0x62, 0x38, 0x35, 0x64, 0x38, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x61, 0x64, 0x64, 0x66, 0x30, 0x31, 0x39, 0x64, 0x36, 0x62, 0x39, 0x63, 0x61, 0x62, 0x37, 0x30, 0x61, 0x63, 0x62, 0x31, 0x33, 0x66, 0x30, 0x62, 0x33, 0x31, 0x31, 0x37, 0x39, 0x39, 0x39, 0x66, 0x30, 0x36, 0x32, 0x65, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x37, 0x34, 0x32, 0x38, 0x62, 0x63, 0x62, 0x32, 0x61, 0x30, 0x64, 0x62, 0x37, 0x36, 0x66, 0x63, 0x38, 0x65, 0x66, 0x31, 0x65, 0x32, 0x30, 0x65, 0x34, 0x36, 0x31, 0x61, 0x30, 0x61, 0x33, 0x32, 0x63, 0x35, 0x61, 0x63, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x30, 0x34, 0x38, 0x66, 0x65, 0x38, 0x34, 0x64, 0x39, 0x62, 0x30, 0x31, 0x30, 0x61, 0x36, 0x32, 0x65, 0x37, 0x33, 0x31, 0x36, 0x32, 0x37, 0x65, 0x34, 0x39, 0x62, 0x63, 0x32, 0x65, 0x62, 0x37, 0x33, 0x66, 0x34, 0x30, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x32, 0x36, 0x31, 0x33, 0x38, 0x33, 0x33, 0x30, 0x32, 0x37, 0x34, 0x64, 0x66, 0x34, 0x65, 0x30, 0x61, 0x33, 0x30, 0x38, 0x31, 0x65, 0x36, 0x64, 0x66, 0x37, 0x64, 0x64, 0x39, 0x38, 0x33, 0x65, 0x63, 0x36, 0x65, 0x37, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x33, 0x38, 0x32, 0x64, 0x33, 0x37, 0x64, 0x62, 0x30, 0x33, 0x39, 0x38, 0x61, 0x63, 0x37, 0x32, 0x34, 0x31, 0x30, 0x63, 0x66, 0x39, 0x38, 0x31, 0x33, 0x64, 0x65, 0x39, 0x66, 0x38, 0x65, 0x31, 0x65, 0x63, 0x38, 0x64, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x66, 0x36, 0x32, 0x66, 0x32, 0x61, 0x61, 0x61, 0x62, 0x63, 0x32, 0x39, 0x61, 0x64, 0x33, 0x61, 0x36, 0x62, 0x30, 0x34, 0x65, 0x31, 0x66, 0x66, 0x36, 0x66, 0x39, 0x63, 0x65, 0x34, 0x35, 0x32, 0x64, 0x31, 0x63, 0x31, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x66, 0x65, 0x66, 0x35, 0x38, 0x35, 0x38, 0x34, 0x34, 0x36, 0x35, 0x32, 0x34, 0x38, 0x61, 0x30, 0x38, 0x31, 0x30, 0x64, 0x36, 0x30, 0x34, 0x36, 0x33, 0x65, 0x65, 0x39, 0x33, 0x65, 0x35, 0x61, 0x36, 0x65, 0x65, 0x38, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x32, 0x62, 0x37, 0x30, 0x66, 0x65, 0x63, 0x63, 0x33, 0x37, 0x36, 0x34, 0x30, 0x66, 0x36, 0x39, 0x35, 0x31, 0x34, 0x66, 0x63, 0x37, 0x66, 0x33, 0x34, 0x30, 0x34, 0x39, 0x34, 0x36, 0x61, 0x61, 0x64, 0x38, 0x36, 0x62, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x39, 0x61, 0x38, 0x35, 0x62, 0x39, 0x33, 0x36, 0x35, 0x33, 0x30, 0x37, 0x35, 0x66, 0x61, 0x36, 0x35, 0x36, 0x32, 0x63, 0x34, 0x30, 0x39, 0x61, 0x35, 0x36, 0x35, 0x64, 0x30, 0x38, 0x37, 0x62, 0x61, 0x33, 0x65, 0x31, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x38, 0x36, 0x36, 0x34, 0x38, 0x36, 0x65, 0x63, 0x31, 0x36, 0x38, 0x66, 0x37, 0x39, 0x64, 0x62, 0x65, 0x30, 0x65, 0x31, 0x61, 0x62, 0x62, 0x31, 0x38, 0x38, 0x36, 0x34, 0x64, 0x39, 0x38, 0x39, 0x39, 0x31, 0x61, 0x65, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x65, 0x37, 0x34, 0x61, 0x66, 0x64, 0x62, 0x61, 0x64, 0x35, 0x35, 0x65, 0x39, 0x36, 0x63, 0x65, 0x62, 0x63, 0x35, 0x61, 0x33, 0x37, 0x34, 0x66, 0x32, 0x63, 0x38, 0x62, 0x37, 0x36, 0x38, 0x36, 0x38, 0x30, 0x66, 0x32, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x63, 0x31, 0x64, 0x36, 0x61, 0x61, 0x34, 0x31, 0x66, 0x65, 0x33, 0x64, 0x36, 0x35, 0x66, 0x36, 0x37, 0x62, 0x64, 0x30, 0x31, 0x64, 0x65, 0x32, 0x61, 0x38, 0x36, 0x36, 0x65, 0x64, 0x31, 0x65, 0x64, 0x39, 0x61, 0x65, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x34, 0x63, 0x30, 0x63, 0x37, 0x37, 0x62, 0x61, 0x37, 0x66, 0x32, 0x33, 0x36, 0x39, 0x32, 0x30, 0x64, 0x31, 0x65, 0x34, 0x33, 0x34, 0x64, 0x65, 0x35, 0x64, 0x61, 0x33, 0x33, 0x65, 0x34, 0x38, 0x65, 0x62, 0x66, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x34, 0x35, 0x62, 0x61, 0x35, 0x63, 0x33, 0x30, 0x65, 0x39, 0x38, 0x39, 0x36, 0x31, 0x62, 0x38, 0x36, 0x30, 0x32, 0x34, 0x36, 0x31, 0x64, 0x30, 0x33, 0x38, 0x35, 0x64, 0x34, 0x30, 0x66, 0x62, 0x64, 0x38, 0x30, 0x33, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x38, 0x33, 0x35, 0x63, 0x31, 0x61, 0x39, 0x31, 0x31, 0x38, 0x31, 0x37, 0x38, 0x37, 0x38, 0x61, 0x33, 0x33, 0x64, 0x31, 0x36, 0x37, 0x35, 0x36, 0x39, 0x65, 0x61, 0x33, 0x63, 0x64, 0x64, 0x33, 0x38, 0x37, 0x66, 0x33, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x31, 0x61, 0x36, 0x65, 0x33, 0x36, 0x32, 0x63, 0x39, 0x37, 0x66, 0x62, 0x62, 0x64, 0x37, 0x63, 0x35, 0x39, 0x37, 0x37, 0x61, 0x63, 0x62, 0x61, 0x32, 0x64, 0x61, 0x37, 0x34, 0x36, 0x38, 0x37, 0x33, 0x36, 0x35, 0x66, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x32, 0x30, 0x32, 0x63, 0x35, 0x63, 0x64, 0x37, 0x30, 0x37, 0x38, 0x64, 0x34, 0x66, 0x38, 0x38, 0x37, 0x36, 0x37, 0x33, 0x61, 0x62, 0x30, 0x37, 0x31, 0x30, 0x39, 0x61, 0x64, 0x38, 0x61, 0x64, 0x61, 0x38, 0x39, 0x37, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x62, 0x66, 0x65, 0x63, 0x32, 0x35, 0x66, 0x37, 0x34, 0x63, 0x64, 0x38, 0x38, 0x34, 0x33, 0x37, 0x36, 0x33, 0x31, 0x61, 0x37, 0x37, 0x33, 0x31, 0x39, 0x30, 0x36, 0x39, 0x33, 0x32, 0x37, 0x37, 0x36, 0x33, 0x35, 0x36, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x39, 0x30, 0x31, 0x34, 0x38, 0x34, 0x32, 0x33, 0x39, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x65, 0x34, 0x61, 0x66, 0x33, 0x30, 0x63, 0x64, 0x39, 0x33, 0x66, 0x36, 0x38, 0x36, 0x61, 0x31, 0x32, 0x32, 0x61, 0x64, 0x37, 0x62, 0x62, 0x31, 0x39, 0x66, 0x38, 0x61, 0x38, 0x37, 0x38, 0x35, 0x65, 0x65, 0x65, 0x33, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x39, 0x62, 0x31, 0x31, 0x31, 0x30, 0x32, 0x39, 0x63, 0x65, 0x31, 0x66, 0x32, 0x30, 0x63, 0x39, 0x31, 0x30, 0x39, 0x63, 0x37, 0x61, 0x37, 0x34, 0x65, 0x65, 0x65, 0x65, 0x66, 0x33, 0x34, 0x66, 0x34, 0x66, 0x32, 0x65, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x62, 0x39, 0x35, 0x37, 0x31, 0x66, 0x33, 0x39, 0x34, 0x62, 0x30, 0x62, 0x31, 0x61, 0x38, 0x65, 0x62, 0x61, 0x35, 0x36, 0x36, 0x34, 0x65, 0x39, 0x64, 0x38, 0x62, 0x35, 0x65, 0x38, 0x34, 0x30, 0x36, 0x37, 0x37, 0x62, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x66, 0x62, 0x33, 0x36, 0x63, 0x32, 0x37, 0x31, 0x30, 0x37, 0x65, 0x65, 0x32, 0x63, 0x61, 0x39, 0x61, 0x33, 0x32, 0x33, 0x36, 0x65, 0x32, 0x37, 0x34, 0x36, 0x63, 0x63, 0x61, 0x31, 0x39, 0x61, 0x63, 0x65, 0x36, 0x62, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x62, 0x63, 0x39, 0x37, 0x39, 0x62, 0x37, 0x30, 0x38, 0x30, 0x30, 0x39, 0x32, 0x66, 0x61, 0x31, 0x66, 0x39, 0x32, 0x66, 0x36, 0x65, 0x30, 0x66, 0x62, 0x33, 0x34, 0x37, 0x65, 0x32, 0x38, 0x64, 0x39, 0x39, 0x35, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x34, 0x62, 0x38, 0x36, 0x31, 0x62, 0x33, 0x64, 0x39, 0x61, 0x63, 0x63, 0x35, 0x36, 0x33, 0x61, 0x39, 0x30, 0x31, 0x36, 0x38, 0x39, 0x39, 0x34, 0x31, 0x61, 0x62, 0x31, 0x65, 0x31, 0x38, 0x36, 0x31, 0x31, 0x36, 0x31, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x63, 0x35, 0x35, 0x35, 0x62, 0x63, 0x32, 0x39, 0x33, 0x63, 0x64, 0x62, 0x31, 0x36, 0x63, 0x36, 0x33, 0x36, 0x32, 0x65, 0x64, 0x39, 0x37, 0x61, 0x65, 0x39, 0x35, 0x35, 0x30, 0x62, 0x39, 0x32, 0x65, 0x61, 0x31, 0x38, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x66, 0x30, 0x32, 0x62, 0x64, 0x37, 0x34, 0x38, 0x36, 0x39, 0x30, 0x65, 0x31, 0x66, 0x64, 0x31, 0x63, 0x37, 0x36, 0x64, 0x32, 0x37, 0x30, 0x38, 0x33, 0x33, 0x30, 0x34, 0x38, 0x62, 0x36, 0x36, 0x62, 0x32, 0x35, 0x66, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x63, 0x30, 0x31, 0x64, 0x62, 0x35, 0x34, 0x65, 0x34, 0x37, 0x63, 0x64, 0x63, 0x33, 0x63, 0x34, 0x33, 0x38, 0x36, 0x39, 0x34, 0x61, 0x62, 0x37, 0x31, 0x37, 0x61, 0x38, 0x35, 0x36, 0x63, 0x32, 0x33, 0x66, 0x65, 0x36, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x35, 0x36, 0x37, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x39, 0x61, 0x30, 0x37, 0x61, 0x38, 0x65, 0x35, 0x37, 0x63, 0x33, 0x31, 0x37, 0x32, 0x61, 0x39, 0x31, 0x39, 0x65, 0x66, 0x36, 0x34, 0x37, 0x38, 0x39, 0x34, 0x37, 0x34, 0x34, 0x39, 0x30, 0x66, 0x30, 0x64, 0x39, 0x66, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x37, 0x65, 0x32, 0x32, 0x61, 0x35, 0x30, 0x33, 0x65, 0x63, 0x35, 0x61, 0x62, 0x65, 0x39, 0x62, 0x30, 0x38, 0x63, 0x35, 0x30, 0x62, 0x64, 0x31, 0x34, 0x39, 0x39, 0x39, 0x66, 0x35, 0x32, 0x30, 0x66, 0x61, 0x34, 0x38, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x38, 0x37, 0x37, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x37, 0x37, 0x33, 0x36, 0x36, 0x39, 0x65, 0x38, 0x37, 0x64, 0x37, 0x36, 0x30, 0x31, 0x38, 0x63, 0x30, 0x39, 0x30, 0x66, 0x38, 0x32, 0x35, 0x35, 0x65, 0x35, 0x34, 0x34, 0x30, 0x39, 0x62, 0x39, 0x64, 0x63, 0x61, 0x38, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x65, 0x38, 0x63, 0x62, 0x63, 0x31, 0x36, 0x38, 0x31, 0x65, 0x35, 0x65, 0x39, 0x64, 0x62, 0x37, 0x34, 0x61, 0x30, 0x66, 0x39, 0x33, 0x66, 0x38, 0x65, 0x64, 0x32, 0x35, 0x38, 0x39, 0x37, 0x35, 0x31, 0x39, 0x31, 0x32, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x34, 0x63, 0x66, 0x35, 0x38, 0x30, 0x37, 0x34, 0x32, 0x39, 0x36, 0x31, 0x35, 0x65, 0x33, 0x30, 0x63, 0x64, 0x66, 0x61, 0x63, 0x65, 0x31, 0x65, 0x35, 0x61, 0x61, 0x65, 0x34, 0x64, 0x61, 0x64, 0x33, 0x30, 0x35, 0x35, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x64, 0x65, 0x30, 0x66, 0x63, 0x37, 0x35, 0x64, 0x36, 0x66, 0x31, 0x36, 0x63, 0x34, 0x34, 0x33, 0x63, 0x33, 0x30, 0x33, 0x38, 0x32, 0x31, 0x37, 0x33, 0x37, 0x32, 0x64, 0x39, 0x39, 0x66, 0x35, 0x64, 0x39, 0x30, 0x37, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x38, 0x66, 0x66, 0x65, 0x32, 0x37, 0x31, 0x66, 0x63, 0x33, 0x39, 0x37, 0x33, 0x35, 0x36, 0x35, 0x63, 0x33, 0x30, 0x33, 0x66, 0x32, 0x31, 0x33, 0x66, 0x36, 0x64, 0x32, 0x64, 0x61, 0x38, 0x39, 0x38, 0x39, 0x37, 0x65, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x33, 0x34, 0x36, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x31, 0x66, 0x63, 0x61, 0x66, 0x32, 0x32, 0x33, 0x39, 0x33, 0x37, 0x65, 0x66, 0x38, 0x39, 0x65, 0x38, 0x35, 0x36, 0x37, 0x35, 0x35, 0x30, 0x33, 0x62, 0x64, 0x62, 0x37, 0x63, 0x61, 0x36, 0x61, 0x39, 0x32, 0x38, 0x62, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x30, 0x61, 0x34, 0x35, 0x35, 0x32, 0x30, 0x65, 0x35, 0x32, 0x30, 0x36, 0x64, 0x39, 0x30, 0x30, 0x34, 0x30, 0x37, 0x30, 0x65, 0x36, 0x61, 0x66, 0x33, 0x65, 0x37, 0x62, 0x62, 0x32, 0x65, 0x38, 0x64, 0x64, 0x35, 0x33, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x34, 0x37, 0x34, 0x33, 0x39, 0x61, 0x64, 0x30, 0x64, 0x33, 0x39, 0x33, 0x62, 0x35, 0x61, 0x30, 0x33, 0x38, 0x36, 0x31, 0x64, 0x37, 0x37, 0x32, 0x39, 0x36, 0x33, 0x32, 0x36, 0x64, 0x65, 0x38, 0x62, 0x62, 0x39, 0x64, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x64, 0x30, 0x30, 0x61, 0x61, 0x64, 0x33, 0x39, 0x61, 0x30, 0x61, 0x37, 0x64, 0x31, 0x39, 0x63, 0x61, 0x30, 0x35, 0x33, 0x35, 0x30, 0x66, 0x37, 0x62, 0x30, 0x33, 0x37, 0x32, 0x37, 0x66, 0x30, 0x38, 0x64, 0x64, 0x38, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x31, 0x39, 0x39, 0x39, 0x64, 0x64, 0x64, 0x32, 0x30, 0x35, 0x35, 0x36, 0x33, 0x33, 0x32, 0x37, 0x62, 0x39, 0x62, 0x35, 0x33, 0x30, 0x37, 0x38, 0x35, 0x61, 0x63, 0x66, 0x66, 0x39, 0x62, 0x63, 0x37, 0x33, 0x61, 0x34, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x36, 0x37, 0x30, 0x37, 0x33, 0x31, 0x31, 0x37, 0x35, 0x38, 0x39, 0x33, 0x62, 0x62, 0x63, 0x66, 0x66, 0x34, 0x66, 0x61, 0x38, 0x35, 0x63, 0x65, 0x39, 0x37, 0x64, 0x39, 0x34, 0x66, 0x63, 0x35, 0x31, 0x63, 0x34, 0x62, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x35, 0x38, 0x31, 0x37, 0x31, 0x61, 0x30, 0x34, 0x64, 0x33, 0x35, 0x37, 0x61, 0x31, 0x33, 0x62, 0x34, 0x39, 0x34, 0x31, 0x63, 0x31, 0x36, 0x65, 0x37, 0x65, 0x35, 0x35, 0x64, 0x64, 0x64, 0x34, 0x39, 0x34, 0x31, 0x33, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x39, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x34, 0x38, 0x34, 0x63, 0x63, 0x36, 0x38, 0x34, 0x63, 0x34, 0x63, 0x39, 0x31, 0x64, 0x62, 0x35, 0x33, 0x65, 0x62, 0x36, 0x38, 0x61, 0x34, 0x64, 0x61, 0x34, 0x35, 0x61, 0x36, 0x61, 0x36, 0x62, 0x64, 0x61, 0x33, 0x30, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x64, 0x37, 0x35, 0x65, 0x64, 0x36, 0x30, 0x63, 0x37, 0x37, 0x34, 0x66, 0x38, 0x62, 0x33, 0x61, 0x35, 0x61, 0x35, 0x31, 0x37, 0x33, 0x66, 0x62, 0x31, 0x38, 0x33, 0x33, 0x61, 0x64, 0x37, 0x31, 0x30, 0x35, 0x61, 0x32, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x39, 0x32, 0x34, 0x31, 0x38, 0x61, 0x30, 0x63, 0x36, 0x63, 0x33, 0x31, 0x32, 0x34, 0x34, 0x64, 0x32, 0x32, 0x30, 0x32, 0x36, 0x30, 0x63, 0x62, 0x33, 0x65, 0x38, 0x36, 0x37, 0x64, 0x64, 0x37, 0x62, 0x34, 0x65, 0x66, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x36, 0x64, 0x35, 0x30, 0x63, 0x63, 0x61, 0x30, 0x31, 0x65, 0x39, 0x33, 0x38, 0x35, 0x30, 0x30, 0x65, 0x36, 0x34, 0x32, 0x31, 0x63, 0x63, 0x30, 0x37, 0x30, 0x63, 0x33, 0x35, 0x30, 0x37, 0x63, 0x36, 0x37, 0x64, 0x33, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x61, 0x38, 0x62, 0x39, 0x36, 0x62, 0x36, 0x63, 0x39, 0x65, 0x31, 0x33, 0x65, 0x62, 0x65, 0x63, 0x31, 0x65, 0x39, 0x66, 0x31, 0x38, 0x61, 0x63, 0x30, 0x32, 0x61, 0x36, 0x30, 0x65, 0x61, 0x38, 0x38, 0x61, 0x34, 0x38, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x35, 0x36, 0x35, 0x32, 0x38, 0x35, 0x33, 0x37, 0x34, 0x61, 0x34, 0x39, 0x65, 0x65, 0x64, 0x64, 0x35, 0x30, 0x34, 0x63, 0x39, 0x35, 0x37, 0x64, 0x35, 0x31, 0x30, 0x38, 0x37, 0x34, 0x64, 0x30, 0x30, 0x34, 0x35, 0x35, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x38, 0x63, 0x37, 0x39, 0x66, 0x34, 0x64, 0x65, 0x31, 0x39, 0x35, 0x33, 0x65, 0x62, 0x63, 0x65, 0x39, 0x38, 0x66, 0x65, 0x38, 0x30, 0x30, 0x36, 0x64, 0x35, 0x33, 0x61, 0x38, 0x31, 0x66, 0x62, 0x35, 0x31, 0x34, 0x30, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x62, 0x32, 0x64, 0x33, 0x34, 0x66, 0x64, 0x65, 0x30, 0x62, 0x31, 0x30, 0x32, 0x39, 0x32, 0x36, 0x32, 0x62, 0x34, 0x31, 0x37, 0x32, 0x63, 0x38, 0x31, 0x63, 0x31, 0x35, 0x39, 0x30, 0x34, 0x30, 0x35, 0x62, 0x30, 0x33, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x33, 0x39, 0x62, 0x64, 0x35, 0x30, 0x61, 0x32, 0x62, 0x64, 0x65, 0x31, 0x35, 0x66, 0x66, 0x65, 0x33, 0x37, 0x31, 0x39, 0x31, 0x66, 0x34, 0x31, 0x30, 0x33, 0x39, 0x30, 0x39, 0x36, 0x32, 0x61, 0x32, 0x62, 0x38, 0x38, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x33, 0x33, 0x62, 0x65, 0x31, 0x30, 0x63, 0x62, 0x34, 0x38, 0x36, 0x31, 0x33, 0x62, 0x64, 0x35, 0x65, 0x62, 0x63, 0x62, 0x33, 0x33, 0x65, 0x64, 0x34, 0x39, 0x30, 0x32, 0x66, 0x33, 0x38, 0x62, 0x35, 0x38, 0x33, 0x30, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x35, 0x37, 0x35, 0x31, 0x38, 0x31, 0x39, 0x62, 0x34, 0x66, 0x33, 0x64, 0x32, 0x36, 0x65, 0x64, 0x30, 0x63, 0x31, 0x61, 0x63, 0x35, 0x37, 0x31, 0x35, 0x35, 0x32, 0x37, 0x33, 0x35, 0x32, 0x37, 0x31, 0x64, 0x62, 0x65, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x30, 0x30, 0x34, 0x32, 0x39, 0x37, 0x35, 0x32, 0x66, 0x33, 0x39, 0x39, 0x63, 0x38, 0x30, 0x64, 0x30, 0x37, 0x33, 0x34, 0x37, 0x34, 0x34, 0x62, 0x61, 0x65, 0x30, 0x61, 0x30, 0x32, 0x32, 0x65, 0x63, 0x61, 0x36, 0x37, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x37, 0x35, 0x36, 0x31, 0x39, 0x64, 0x38, 0x61, 0x32, 0x33, 0x65, 0x34, 0x35, 0x64, 0x38, 0x39, 0x39, 0x38, 0x64, 0x31, 0x38, 0x34, 0x64, 0x34, 0x38, 0x30, 0x63, 0x30, 0x37, 0x34, 0x38, 0x39, 0x37, 0x30, 0x38, 0x32, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x63, 0x37, 0x32, 0x33, 0x30, 0x61, 0x31, 0x64, 0x33, 0x35, 0x62, 0x64, 0x64, 0x36, 0x38, 0x31, 0x39, 0x65, 0x64, 0x34, 0x62, 0x39, 0x61, 0x38, 0x38, 0x65, 0x39, 0x34, 0x61, 0x30, 0x65, 0x62, 0x30, 0x37, 0x38, 0x36, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x66, 0x39, 0x63, 0x39, 0x37, 0x32, 0x63, 0x31, 0x65, 0x39, 0x37, 0x33, 0x37, 0x37, 0x35, 0x35, 0x62, 0x33, 0x66, 0x66, 0x31, 0x62, 0x33, 0x30, 0x38, 0x38, 0x37, 0x33, 0x38, 0x33, 0x39, 0x36, 0x33, 0x39, 0x35, 0x62, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x36, 0x61, 0x34, 0x39, 0x36, 0x33, 0x62, 0x32, 0x37, 0x66, 0x31, 0x65, 0x65, 0x31, 0x39, 0x33, 0x32, 0x62, 0x31, 0x37, 0x32, 0x62, 0x65, 0x35, 0x39, 0x36, 0x34, 0x65, 0x30, 0x64, 0x33, 0x61, 0x65, 0x35, 0x34, 0x62, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x63, 0x65, 0x38, 0x38, 0x65, 0x36, 0x36, 0x63, 0x35, 0x61, 0x66, 0x32, 0x66, 0x32, 0x39, 0x62, 0x62, 0x64, 0x38, 0x66, 0x35, 0x39, 0x32, 0x61, 0x35, 0x36, 0x61, 0x33, 0x64, 0x31, 0x35, 0x66, 0x32, 0x30, 0x36, 0x63, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x33, 0x65, 0x33, 0x62, 0x61, 0x31, 0x63, 0x35, 0x31, 0x62, 0x38, 0x31, 0x30, 0x66, 0x63, 0x34, 0x36, 0x37, 0x64, 0x35, 0x62, 0x61, 0x34, 0x64, 0x65, 0x61, 0x34, 0x32, 0x66, 0x37, 0x61, 0x39, 0x38, 0x38, 0x35, 0x65, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x38, 0x33, 0x37, 0x61, 0x64, 0x30, 0x61, 0x30, 0x62, 0x66, 0x31, 0x34, 0x31, 0x38, 0x36, 0x39, 0x33, 0x37, 0x61, 0x63, 0x65, 0x30, 0x36, 0x63, 0x35, 0x35, 0x34, 0x36, 0x61, 0x33, 0x36, 0x61, 0x61, 0x35, 0x34, 0x66, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x66, 0x38, 0x66, 0x36, 0x37, 0x32, 0x39, 0x35, 0x61, 0x35, 0x63, 0x64, 0x30, 0x34, 0x39, 0x33, 0x36, 0x34, 0x64, 0x30, 0x35, 0x64, 0x32, 0x33, 0x35, 0x30, 0x32, 0x36, 0x32, 0x33, 0x61, 0x33, 0x65, 0x35, 0x32, 0x65, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x64, 0x30, 0x62, 0x62, 0x34, 0x37, 0x37, 0x39, 0x38, 0x63, 0x66, 0x34, 0x34, 0x63, 0x64, 0x66, 0x62, 0x65, 0x34, 0x64, 0x33, 0x33, 0x33, 0x64, 0x65, 0x36, 0x33, 0x37, 0x64, 0x66, 0x34, 0x61, 0x30, 0x30, 0x65, 0x34, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x61, 0x65, 0x38, 0x64, 0x34, 0x35, 0x34, 0x30, 0x64, 0x34, 0x64, 0x62, 0x36, 0x66, 0x64, 0x64, 0x65, 0x37, 0x31, 0x34, 0x36, 0x66, 0x34, 0x31, 0x35, 0x62, 0x34, 0x33, 0x31, 0x65, 0x62, 0x35, 0x35, 0x63, 0x37, 0x39, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x63, 0x63, 0x66, 0x31, 0x35, 0x30, 0x38, 0x62, 0x66, 0x64, 0x33, 0x35, 0x63, 0x32, 0x30, 0x35, 0x33, 0x30, 0x61, 0x61, 0x36, 0x34, 0x32, 0x35, 0x30, 0x30, 0x63, 0x31, 0x30, 0x64, 0x65, 0x65, 0x36, 0x35, 0x65, 0x61, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x33, 0x65, 0x61, 0x64, 0x35, 0x34, 0x66, 0x37, 0x38, 0x35, 0x30, 0x61, 0x66, 0x32, 0x31, 0x34, 0x33, 0x38, 0x63, 0x62, 0x65, 0x30, 0x37, 0x61, 0x66, 0x36, 0x38, 0x36, 0x32, 0x37, 0x39, 0x61, 0x33, 0x31, 0x35, 0x62, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x66, 0x36, 0x64, 0x61, 0x30, 0x32, 0x30, 0x34, 0x64, 0x62, 0x63, 0x34, 0x38, 0x36, 0x30, 0x62, 0x34, 0x36, 0x61, 0x64, 0x39, 0x37, 0x33, 0x66, 0x63, 0x31, 0x31, 0x31, 0x30, 0x30, 0x38, 0x64, 0x39, 0x65, 0x30, 0x63, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x37, 0x39, 0x33, 0x36, 0x64, 0x35, 0x39, 0x32, 0x30, 0x30, 0x38, 0x66, 0x64, 0x63, 0x37, 0x61, 0x61, 0x30, 0x34, 0x65, 0x64, 0x65, 0x65, 0x62, 0x37, 0x35, 0x35, 0x61, 0x62, 0x35, 0x31, 0x33, 0x64, 0x62, 0x62, 0x38, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x35, 0x33, 0x64, 0x63, 0x64, 0x62, 0x35, 0x36, 0x63, 0x65, 0x34, 0x63, 0x64, 0x63, 0x65, 0x39, 0x66, 0x38, 0x32, 0x65, 0x63, 0x30, 0x65, 0x62, 0x31, 0x33, 0x64, 0x36, 0x37, 0x33, 0x35, 0x32, 0x65, 0x37, 0x63, 0x38, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x34, 0x66, 0x34, 0x35, 0x30, 0x37, 0x62, 0x62, 0x36, 0x62, 0x39, 0x38, 0x31, 0x37, 0x39, 0x34, 0x32, 0x63, 0x65, 0x34, 0x33, 0x33, 0x37, 0x38, 0x31, 0x62, 0x37, 0x30, 0x38, 0x66, 0x62, 0x63, 0x64, 0x31, 0x36, 0x36, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x36, 0x34, 0x33, 0x32, 0x61, 0x66, 0x33, 0x37, 0x64, 0x63, 0x35, 0x31, 0x31, 0x33, 0x66, 0x31, 0x66, 0x34, 0x36, 0x64, 0x34, 0x38, 0x30, 0x61, 0x34, 0x64, 0x65, 0x30, 0x62, 0x32, 0x38, 0x30, 0x35, 0x32, 0x32, 0x33, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x38, 0x30, 0x61, 0x35, 0x36, 0x33, 0x30, 0x36, 0x62, 0x61, 0x31, 0x65, 0x36, 0x62, 0x62, 0x33, 0x33, 0x31, 0x39, 0x35, 0x32, 0x63, 0x32, 0x32, 0x35, 0x33, 0x39, 0x62, 0x38, 0x35, 0x38, 0x61, 0x66, 0x39, 0x66, 0x37, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x66, 0x31, 0x36, 0x39, 0x34, 0x64, 0x32, 0x32, 0x36, 0x37, 0x31, 0x62, 0x35, 0x61, 0x61, 0x64, 0x36, 0x61, 0x39, 0x34, 0x39, 0x39, 0x35, 0x63, 0x33, 0x36, 0x39, 0x66, 0x62, 0x65, 0x36, 0x31, 0x33, 0x33, 0x36, 0x37, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x34, 0x35, 0x66, 0x30, 0x66, 0x38, 0x34, 0x34, 0x32, 0x61, 0x35, 0x36, 0x64, 0x62, 0x64, 0x33, 0x39, 0x64, 0x62, 0x66, 0x31, 0x35, 0x39, 0x39, 0x39, 0x35, 0x34, 0x31, 0x35, 0x63, 0x35, 0x32, 0x65, 0x64, 0x34, 0x37, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x35, 0x39, 0x34, 0x31, 0x64, 0x34, 0x34, 0x63, 0x35, 0x30, 0x64, 0x32, 0x34, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x64, 0x33, 0x36, 0x34, 0x37, 0x36, 0x36, 0x65, 0x39, 0x39, 0x31, 0x63, 0x30, 0x32, 0x65, 0x31, 0x31, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x65, 0x36, 0x38, 0x64, 0x62, 0x38, 0x64, 0x62, 0x62, 0x61, 0x62, 0x61, 0x35, 0x66, 0x63, 0x32, 0x63, 0x62, 0x33, 0x33, 0x37, 0x63, 0x36, 0x32, 0x62, 0x63, 0x64, 0x30, 0x64, 0x36, 0x31, 0x62, 0x30, 0x35, 0x39, 0x31, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x66, 0x33, 0x36, 0x33, 0x31, 0x66, 0x35, 0x36, 0x36, 0x34, 0x62, 0x64, 0x61, 0x64, 0x35, 0x64, 0x30, 0x31, 0x33, 0x32, 0x63, 0x38, 0x33, 0x38, 0x38, 0x64, 0x33, 0x36, 0x64, 0x37, 0x64, 0x38, 0x39, 0x32, 0x30, 0x39, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x37, 0x35, 0x64, 0x37, 0x66, 0x31, 0x37, 0x34, 0x62, 0x64, 0x62, 0x31, 0x66, 0x37, 0x38, 0x39, 0x30, 0x31, 0x37, 0x63, 0x37, 0x63, 0x31, 0x37, 0x30, 0x35, 0x39, 0x38, 0x39, 0x36, 0x34, 0x36, 0x30, 0x37, 0x39, 0x64, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x62, 0x66, 0x32, 0x65, 0x64, 0x31, 0x65, 0x64, 0x33, 0x31, 0x32, 0x39, 0x34, 0x30, 0x65, 0x65, 0x36, 0x61, 0x64, 0x65, 0x64, 0x31, 0x35, 0x31, 0x36, 0x65, 0x32, 0x36, 0x38, 0x65, 0x34, 0x61, 0x36, 0x30, 0x34, 0x38, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x61, 0x61, 0x66, 0x30, 0x38, 0x35, 0x34, 0x64, 0x62, 0x36, 0x65, 0x62, 0x33, 0x39, 0x62, 0x63, 0x37, 0x62, 0x32, 0x65, 0x34, 0x33, 0x38, 0x34, 0x36, 0x61, 0x37, 0x36, 0x31, 0x37, 0x31, 0x63, 0x30, 0x34, 0x34, 0x35, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x31, 0x37, 0x64, 0x66, 0x31, 0x62, 0x39, 0x31, 0x66, 0x61, 0x66, 0x33, 0x30, 0x66, 0x65, 0x33, 0x32, 0x35, 0x31, 0x35, 0x37, 0x31, 0x37, 0x32, 0x37, 0x63, 0x39, 0x37, 0x31, 0x31, 0x62, 0x34, 0x35, 0x64, 0x38, 0x66, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x31, 0x33, 0x64, 0x36, 0x37, 0x30, 0x35, 0x38, 0x38, 0x34, 0x61, 0x62, 0x32, 0x31, 0x35, 0x37, 0x64, 0x64, 0x38, 0x64, 0x63, 0x63, 0x37, 0x30, 0x34, 0x36, 0x63, 0x61, 0x66, 0x35, 0x38, 0x65, 0x65, 0x39, 0x34, 0x62, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x38, 0x64, 0x63, 0x30, 0x39, 0x61, 0x31, 0x33, 0x31, 0x31, 0x33, 0x37, 0x37, 0x63, 0x30, 0x39, 0x33, 0x66, 0x39, 0x63, 0x63, 0x38, 0x61, 0x65, 0x37, 0x34, 0x31, 0x31, 0x31, 0x66, 0x36, 0x35, 0x66, 0x38, 0x32, 0x66, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x34, 0x33, 0x65, 0x64, 0x32, 0x32, 0x66, 0x39, 0x39, 0x37, 0x65, 0x35, 0x61, 0x32, 0x61, 0x34, 0x63, 0x31, 0x36, 0x65, 0x33, 0x36, 0x34, 0x34, 0x38, 0x36, 0x61, 0x65, 0x36, 0x34, 0x39, 0x37, 0x35, 0x36, 0x39, 0x32, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x33, 0x30, 0x35, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x61, 0x39, 0x38, 0x35, 0x35, 0x30, 0x31, 0x65, 0x65, 0x39, 0x35, 0x30, 0x38, 0x32, 0x39, 0x62, 0x31, 0x37, 0x66, 0x61, 0x65, 0x31, 0x63, 0x39, 0x63, 0x66, 0x33, 0x34, 0x38, 0x63, 0x33, 0x31, 0x35, 0x36, 0x35, 0x34, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x63, 0x62, 0x61, 0x35, 0x62, 0x32, 0x36, 0x62, 0x65, 0x61, 0x35, 0x64, 0x37, 0x33, 0x66, 0x61, 0x62, 0x62, 0x31, 0x61, 0x62, 0x61, 0x66, 0x61, 0x63, 0x64, 0x65, 0x66, 0x38, 0x35, 0x64, 0x65, 0x66, 0x33, 0x36, 0x38, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x37, 0x36, 0x65, 0x31, 0x33, 0x33, 0x64, 0x39, 0x64, 0x63, 0x33, 0x35, 0x34, 0x63, 0x31, 0x32, 0x61, 0x39, 0x35, 0x31, 0x30, 0x38, 0x37, 0x62, 0x36, 0x33, 0x39, 0x36, 0x35, 0x30, 0x66, 0x35, 0x33, 0x39, 0x61, 0x34, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x34, 0x63, 0x61, 0x39, 0x34, 0x39, 0x37, 0x32, 0x36, 0x33, 0x34, 0x66, 0x36, 0x33, 0x33, 0x61, 0x35, 0x31, 0x66, 0x33, 0x35, 0x36, 0x30, 0x62, 0x31, 0x64, 0x30, 0x36, 0x63, 0x30, 0x62, 0x32, 0x39, 0x33, 0x62, 0x33, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x65, 0x31, 0x66, 0x64, 0x66, 0x36, 0x32, 0x36, 0x65, 0x65, 0x36, 0x31, 0x38, 0x39, 0x31, 0x30, 0x32, 0x64, 0x37, 0x30, 0x64, 0x31, 0x33, 0x62, 0x33, 0x31, 0x30, 0x31, 0x32, 0x63, 0x39, 0x35, 0x63, 0x64, 0x31, 0x63, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x34, 0x38, 0x66, 0x63, 0x65, 0x39, 0x61, 0x62, 0x36, 0x31, 0x31, 0x63, 0x37, 0x64, 0x39, 0x39, 0x32, 0x30, 0x36, 0x65, 0x32, 0x33, 0x66, 0x61, 0x63, 0x36, 0x39, 0x61, 0x64, 0x34, 0x38, 0x38, 0x62, 0x39, 0x34, 0x66, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x31, 0x31, 0x39, 0x35, 0x64, 0x36, 0x35, 0x37, 0x65, 0x66, 0x33, 0x63, 0x39, 0x34, 0x32, 0x65, 0x36, 0x63, 0x62, 0x38, 0x33, 0x39, 0x34, 0x39, 0x65, 0x35, 0x61, 0x32, 0x30, 0x62, 0x35, 0x63, 0x66, 0x61, 0x38, 0x62, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x61, 0x35, 0x65, 0x38, 0x39, 0x39, 0x30, 0x30, 0x62, 0x64, 0x33, 0x66, 0x38, 0x31, 0x64, 0x64, 0x37, 0x31, 0x62, 0x61, 0x38, 0x36, 0x39, 0x64, 0x32, 0x35, 0x66, 0x65, 0x63, 0x36, 0x35, 0x32, 0x36, 0x31, 0x64, 0x66, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x66, 0x31, 0x65, 0x35, 0x35, 0x62, 0x31, 0x36, 0x39, 0x34, 0x30, 0x38, 0x39, 0x65, 0x62, 0x63, 0x62, 0x34, 0x66, 0x65, 0x37, 0x64, 0x37, 0x38, 0x38, 0x32, 0x61, 0x61, 0x36, 0x36, 0x63, 0x38, 0x39, 0x37, 0x36, 0x31, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x32, 0x39, 0x34, 0x62, 0x36, 0x36, 0x36, 0x32, 0x34, 0x32, 0x33, 0x30, 0x33, 0x62, 0x36, 0x64, 0x66, 0x30, 0x62, 0x31, 0x63, 0x38, 0x38, 0x64, 0x33, 0x37, 0x34, 0x32, 0x39, 0x62, 0x63, 0x38, 0x63, 0x39, 0x36, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x37, 0x31, 0x38, 0x37, 0x37, 0x65, 0x39, 0x64, 0x38, 0x32, 0x30, 0x63, 0x63, 0x36, 0x31, 0x38, 0x66, 0x63, 0x30, 0x39, 0x31, 0x39, 0x62, 0x32, 0x39, 0x65, 0x66, 0x64, 0x33, 0x33, 0x33, 0x66, 0x64, 0x61, 0x34, 0x39, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x30, 0x31, 0x66, 0x38, 0x30, 0x37, 0x37, 0x66, 0x33, 0x34, 0x31, 0x39, 0x30, 0x62, 0x62, 0x34, 0x37, 0x61, 0x38, 0x65, 0x32, 0x32, 0x37, 0x66, 0x61, 0x32, 0x39, 0x62, 0x33, 0x30, 0x63, 0x65, 0x31, 0x31, 0x33, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x32, 0x32, 0x38, 0x34, 0x34, 0x34, 0x30, 0x32, 0x32, 0x31, 0x63, 0x65, 0x31, 0x36, 0x61, 0x38, 0x33, 0x38, 0x32, 0x64, 0x65, 0x35, 0x66, 0x66, 0x30, 0x32, 0x32, 0x39, 0x34, 0x37, 0x32, 0x32, 0x36, 0x39, 0x64, 0x65, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x62, 0x61, 0x30, 0x33, 0x66, 0x66, 0x36, 0x62, 0x34, 0x61, 0x64, 0x35, 0x62, 0x66, 0x31, 0x38, 0x31, 0x38, 0x34, 0x61, 0x63, 0x62, 0x32, 0x31, 0x62, 0x31, 0x38, 0x38, 0x61, 0x33, 0x39, 0x39, 0x65, 0x39, 0x65, 0x62, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x37, 0x34, 0x34, 0x36, 0x31, 0x38, 0x64, 0x65, 0x33, 0x39, 0x36, 0x61, 0x35, 0x34, 0x33, 0x31, 0x39, 0x37, 0x65, 0x65, 0x34, 0x38, 0x39, 0x34, 0x61, 0x62, 0x64, 0x30, 0x36, 0x33, 0x39, 0x38, 0x64, 0x64, 0x37, 0x63, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x37, 0x39, 0x39, 0x30, 0x33, 0x33, 0x65, 0x66, 0x36, 0x64, 0x63, 0x37, 0x31, 0x32, 0x37, 0x38, 0x32, 0x32, 0x66, 0x37, 0x34, 0x35, 0x34, 0x32, 0x62, 0x62, 0x32, 0x32, 0x64, 0x62, 0x66, 0x63, 0x30, 0x39, 0x61, 0x33, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x31, 0x33, 0x61, 0x34, 0x35, 0x30, 0x38, 0x30, 0x66, 0x66, 0x32, 0x66, 0x65, 0x62, 0x65, 0x36, 0x32, 0x63, 0x64, 0x35, 0x38, 0x35, 0x34, 0x61, 0x62, 0x65, 0x32, 0x39, 0x65, 0x65, 0x34, 0x34, 0x36, 0x37, 0x66, 0x39, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x36, 0x31, 0x64, 0x32, 0x37, 0x66, 0x61, 0x33, 0x35, 0x30, 0x32, 0x63, 0x63, 0x37, 0x36, 0x62, 0x62, 0x31, 0x61, 0x36, 0x30, 0x38, 0x37, 0x34, 0x30, 0x65, 0x31, 0x34, 0x30, 0x33, 0x63, 0x66, 0x39, 0x64, 0x66, 0x63, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x39, 0x38, 0x39, 0x65, 0x64, 0x33, 0x33, 0x30, 0x35, 0x36, 0x33, 0x66, 0x64, 0x35, 0x37, 0x64, 0x66, 0x65, 0x63, 0x39, 0x62, 0x64, 0x33, 0x34, 0x33, 0x63, 0x33, 0x37, 0x36, 0x30, 0x62, 0x30, 0x37, 0x39, 0x39, 0x33, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x66, 0x37, 0x31, 0x31, 0x30, 0x64, 0x31, 0x62, 0x64, 0x39, 0x61, 0x37, 0x34, 0x62, 0x66, 0x64, 0x31, 0x64, 0x37, 0x64, 0x37, 0x64, 0x32, 0x64, 0x39, 0x64, 0x35, 0x35, 0x36, 0x30, 0x37, 0x65, 0x37, 0x62, 0x38, 0x33, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x37, 0x33, 0x65, 0x39, 0x64, 0x61, 0x61, 0x63, 0x30, 0x63, 0x38, 0x36, 0x37, 0x35, 0x66, 0x35, 0x33, 0x62, 0x37, 0x39, 0x37, 0x61, 0x31, 0x36, 0x30, 0x66, 0x36, 0x66, 0x63, 0x30, 0x33, 0x34, 0x61, 0x65, 0x36, 0x62, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x63, 0x39, 0x61, 0x39, 0x39, 0x65, 0x38, 0x61, 0x32, 0x31, 0x34, 0x38, 0x61, 0x35, 0x35, 0x61, 0x36, 0x64, 0x38, 0x32, 0x62, 0x64, 0x35, 0x31, 0x62, 0x39, 0x38, 0x65, 0x62, 0x35, 0x33, 0x39, 0x31, 0x66, 0x64, 0x62, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x65, 0x63, 0x30, 0x39, 0x31, 0x33, 0x63, 0x36, 0x33, 0x35, 0x62, 0x61, 0x63, 0x61, 0x32, 0x66, 0x35, 0x65, 0x35, 0x37, 0x61, 0x33, 0x37, 0x61, 0x61, 0x39, 0x66, 0x62, 0x37, 0x62, 0x36, 0x63, 0x39, 0x62, 0x36, 0x65, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x31, 0x61, 0x33, 0x61, 0x66, 0x32, 0x39, 0x37, 0x65, 0x66, 0x61, 0x34, 0x34, 0x33, 0x36, 0x61, 0x32, 0x39, 0x61, 0x66, 0x30, 0x30, 0x37, 0x32, 0x39, 0x32, 0x39, 0x61, 0x62, 0x66, 0x39, 0x38, 0x32, 0x36, 0x66, 0x35, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x34, 0x65, 0x66, 0x61, 0x36, 0x64, 0x62, 0x35, 0x39, 0x35, 0x62, 0x37, 0x39, 0x33, 0x31, 0x33, 0x32, 0x37, 0x37, 0x65, 0x38, 0x38, 0x33, 0x31, 0x39, 0x36, 0x32, 0x35, 0x30, 0x37, 0x36, 0x62, 0x35, 0x38, 0x30, 0x61, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x64, 0x38, 0x64, 0x64, 0x34, 0x65, 0x32, 0x35, 0x31, 0x63, 0x62, 0x63, 0x30, 0x32, 0x31, 0x66, 0x30, 0x35, 0x62, 0x30, 0x31, 0x30, 0x66, 0x32, 0x64, 0x35, 0x64, 0x63, 0x35, 0x32, 0x30, 0x63, 0x33, 0x38, 0x37, 0x32, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x34, 0x39, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x36, 0x37, 0x64, 0x36, 0x64, 0x62, 0x31, 0x64, 0x30, 0x33, 0x35, 0x31, 0x36, 0x63, 0x31, 0x32, 0x38, 0x62, 0x38, 0x66, 0x66, 0x32, 0x33, 0x34, 0x62, 0x66, 0x33, 0x64, 0x34, 0x39, 0x62, 0x32, 0x36, 0x64, 0x32, 0x39, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x36, 0x64, 0x33, 0x36, 0x35, 0x35, 0x33, 0x34, 0x35, 0x33, 0x30, 0x61, 0x35, 0x66, 0x63, 0x31, 0x35, 0x37, 0x37, 0x63, 0x30, 0x61, 0x35, 0x32, 0x34, 0x31, 0x63, 0x62, 0x38, 0x38, 0x63, 0x34, 0x64, 0x61, 0x37, 0x30, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x35, 0x66, 0x66, 0x30, 0x33, 0x65, 0x37, 0x62, 0x35, 0x66, 0x63, 0x34, 0x32, 0x32, 0x39, 0x38, 0x31, 0x66, 0x61, 0x65, 0x35, 0x65, 0x39, 0x39, 0x34, 0x31, 0x64, 0x61, 0x63, 0x62, 0x64, 0x61, 0x62, 0x61, 0x37, 0x35, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x33, 0x35, 0x34, 0x30, 0x65, 0x63, 0x65, 0x65, 0x31, 0x31, 0x62, 0x32, 0x31, 0x32, 0x65, 0x38, 0x62, 0x37, 0x37, 0x35, 0x64, 0x63, 0x38, 0x65, 0x37, 0x31, 0x66, 0x33, 0x37, 0x34, 0x61, 0x61, 0x65, 0x39, 0x62, 0x33, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x32, 0x65, 0x33, 0x66, 0x38, 0x66, 0x35, 0x39, 0x35, 0x39, 0x61, 0x37, 0x61, 0x61, 0x62, 0x37, 0x34, 0x31, 0x38, 0x36, 0x31, 0x32, 0x31, 0x32, 0x39, 0x62, 0x37, 0x30, 0x31, 0x63, 0x61, 0x31, 0x62, 0x38, 0x30, 0x30, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x61, 0x33, 0x66, 0x31, 0x35, 0x33, 0x63, 0x64, 0x63, 0x33, 0x38, 0x38, 0x32, 0x31, 0x63, 0x32, 0x30, 0x63, 0x35, 0x64, 0x38, 0x63, 0x38, 0x32, 0x34, 0x31, 0x62, 0x32, 0x39, 0x34, 0x61, 0x33, 0x66, 0x38, 0x32, 0x62, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x36, 0x31, 0x37, 0x35, 0x34, 0x30, 0x33, 0x34, 0x38, 0x31, 0x65, 0x30, 0x61, 0x62, 0x31, 0x35, 0x62, 0x62, 0x35, 0x31, 0x34, 0x36, 0x31, 0x35, 0x63, 0x62, 0x62, 0x39, 0x38, 0x39, 0x65, 0x62, 0x63, 0x36, 0x38, 0x66, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x30, 0x34, 0x65, 0x63, 0x63, 0x30, 0x65, 0x33, 0x33, 0x30, 0x64, 0x64, 0x31, 0x66, 0x38, 0x31, 0x62, 0x35, 0x38, 0x61, 0x63, 0x39, 0x64, 0x62, 0x62, 0x31, 0x61, 0x39, 0x66, 0x62, 0x66, 0x38, 0x38, 0x61, 0x33, 0x63, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x36, 0x36, 0x64, 0x37, 0x37, 0x30, 0x64, 0x38, 0x39, 0x38, 0x64, 0x38, 0x63, 0x39, 0x64, 0x34, 0x30, 0x35, 0x65, 0x34, 0x61, 0x30, 0x65, 0x35, 0x35, 0x31, 0x65, 0x66, 0x61, 0x66, 0x63, 0x64, 0x65, 0x35, 0x33, 0x63, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x61, 0x38, 0x61, 0x35, 0x34, 0x65, 0x36, 0x38, 0x31, 0x37, 0x36, 0x63, 0x34, 0x66, 0x65, 0x32, 0x63, 0x30, 0x31, 0x63, 0x66, 0x36, 0x37, 0x31, 0x63, 0x35, 0x31, 0x35, 0x62, 0x66, 0x62, 0x64, 0x64, 0x35, 0x32, 0x38, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x65, 0x31, 0x35, 0x63, 0x36, 0x30, 0x64, 0x64, 0x33, 0x38, 0x31, 0x65, 0x33, 0x61, 0x34, 0x62, 0x65, 0x32, 0x35, 0x30, 0x37, 0x31, 0x61, 0x62, 0x32, 0x34, 0x39, 0x61, 0x34, 0x63, 0x35, 0x63, 0x35, 0x32, 0x36, 0x34, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x35, 0x30, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x32, 0x38, 0x62, 0x66, 0x62, 0x65, 0x35, 0x35, 0x33, 0x35, 0x37, 0x38, 0x32, 0x66, 0x62, 0x35, 0x38, 0x38, 0x34, 0x30, 0x36, 0x62, 0x63, 0x39, 0x36, 0x36, 0x36, 0x30, 0x61, 0x34, 0x39, 0x62, 0x30, 0x31, 0x31, 0x61, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x64, 0x36, 0x62, 0x38, 0x64, 0x34, 0x64, 0x61, 0x38, 0x36, 0x37, 0x34, 0x30, 0x37, 0x62, 0x62, 0x39, 0x39, 0x37, 0x37, 0x34, 0x39, 0x64, 0x65, 0x62, 0x62, 0x63, 0x64, 0x63, 0x30, 0x62, 0x33, 0x35, 0x38, 0x35, 0x33, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x36, 0x65, 0x63, 0x33, 0x31, 0x33, 0x33, 0x37, 0x36, 0x32, 0x37, 0x31, 0x64, 0x66, 0x66, 0x35, 0x35, 0x34, 0x32, 0x33, 0x61, 0x62, 0x35, 0x34, 0x32, 0x32, 0x63, 0x63, 0x33, 0x61, 0x38, 0x62, 0x30, 0x36, 0x62, 0x32, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x38, 0x37, 0x64, 0x31, 0x32, 0x36, 0x37, 0x37, 0x61, 0x35, 0x65, 0x63, 0x32, 0x39, 0x31, 0x65, 0x35, 0x37, 0x65, 0x33, 0x31, 0x66, 0x66, 0x62, 0x66, 0x61, 0x64, 0x31, 0x30, 0x35, 0x63, 0x33, 0x33, 0x32, 0x34, 0x62, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x33, 0x38, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x65, 0x32, 0x66, 0x31, 0x31, 0x32, 0x32, 0x33, 0x66, 0x63, 0x38, 0x32, 0x33, 0x37, 0x66, 0x36, 0x39, 0x64, 0x39, 0x39, 0x63, 0x36, 0x32, 0x38, 0x39, 0x63, 0x31, 0x34, 0x38, 0x63, 0x30, 0x36, 0x30, 0x34, 0x66, 0x37, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x30, 0x30, 0x37, 0x33, 0x30, 0x61, 0x35, 0x35, 0x66, 0x36, 0x62, 0x32, 0x30, 0x65, 0x62, 0x64, 0x32, 0x34, 0x38, 0x31, 0x31, 0x66, 0x61, 0x61, 0x33, 0x64, 0x65, 0x39, 0x36, 0x64, 0x31, 0x36, 0x36, 0x32, 0x61, 0x62, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x65, 0x30, 0x38, 0x39, 0x36, 0x33, 0x35, 0x63, 0x65, 0x39, 0x37, 0x61, 0x62, 0x61, 0x63, 0x30, 0x36, 0x62, 0x34, 0x34, 0x38, 0x31, 0x39, 0x62, 0x65, 0x35, 0x62, 0x62, 0x30, 0x61, 0x33, 0x65, 0x32, 0x65, 0x30, 0x62, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x34, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x30, 0x63, 0x31, 0x61, 0x39, 0x38, 0x38, 0x63, 0x38, 0x61, 0x31, 0x37, 0x61, 0x64, 0x33, 0x35, 0x32, 0x38, 0x65, 0x62, 0x32, 0x38, 0x62, 0x33, 0x34, 0x30, 0x39, 0x64, 0x61, 0x61, 0x35, 0x38, 0x32, 0x32, 0x35, 0x66, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x65, 0x31, 0x63, 0x31, 0x39, 0x65, 0x35, 0x33, 0x63, 0x37, 0x31, 0x63, 0x65, 0x65, 0x34, 0x63, 0x37, 0x33, 0x66, 0x61, 0x65, 0x32, 0x64, 0x37, 0x66, 0x63, 0x37, 0x33, 0x62, 0x66, 0x39, 0x61, 0x62, 0x35, 0x65, 0x33, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x31, 0x37, 0x65, 0x65, 0x64, 0x38, 0x32, 0x62, 0x39, 0x61, 0x32, 0x35, 0x39, 0x32, 0x30, 0x31, 0x39, 0x61, 0x31, 0x62, 0x31, 0x62, 0x33, 0x63, 0x30, 0x66, 0x62, 0x61, 0x64, 0x34, 0x35, 0x63, 0x34, 0x30, 0x38, 0x64, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x34, 0x61, 0x37, 0x61, 0x33, 0x39, 0x64, 0x30, 0x39, 0x31, 0x36, 0x65, 0x30, 0x35, 0x66, 0x31, 0x63, 0x32, 0x34, 0x32, 0x64, 0x66, 0x35, 0x35, 0x36, 0x30, 0x37, 0x66, 0x33, 0x37, 0x64, 0x66, 0x38, 0x63, 0x35, 0x66, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x37, 0x30, 0x66, 0x34, 0x64, 0x64, 0x62, 0x66, 0x30, 0x36, 0x39, 0x64, 0x32, 0x31, 0x34, 0x33, 0x62, 0x64, 0x36, 0x62, 0x62, 0x63, 0x37, 0x66, 0x36, 0x39, 0x36, 0x62, 0x35, 0x32, 0x37, 0x38, 0x39, 0x62, 0x33, 0x32, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x32, 0x35, 0x62, 0x62, 0x39, 0x63, 0x61, 0x38, 0x65, 0x37, 0x30, 0x32, 0x32, 0x31, 0x37, 0x65, 0x39, 0x33, 0x33, 0x33, 0x32, 0x32, 0x35, 0x32, 0x35, 0x30, 0x65, 0x35, 0x33, 0x63, 0x33, 0x36, 0x38, 0x30, 0x34, 0x64, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x38, 0x33, 0x31, 0x37, 0x31, 0x39, 0x37, 0x39, 0x35, 0x39, 0x34, 0x32, 0x34, 0x30, 0x34, 0x31, 0x64, 0x39, 0x64, 0x37, 0x63, 0x36, 0x37, 0x61, 0x33, 0x65, 0x63, 0x65, 0x31, 0x64, 0x62, 0x62, 0x37, 0x38, 0x62, 0x62, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x62, 0x39, 0x35, 0x33, 0x61, 0x30, 0x65, 0x34, 0x32, 0x66, 0x35, 0x30, 0x33, 0x30, 0x38, 0x31, 0x32, 0x32, 0x32, 0x36, 0x32, 0x31, 0x37, 0x66, 0x66, 0x66, 0x63, 0x33, 0x63, 0x65, 0x32, 0x33, 0x30, 0x34, 0x35, 0x37, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x66, 0x34, 0x64, 0x63, 0x31, 0x64, 0x64, 0x62, 0x38, 0x61, 0x62, 0x62, 0x38, 0x38, 0x34, 0x38, 0x61, 0x38, 0x62, 0x31, 0x34, 0x65, 0x32, 0x35, 0x66, 0x33, 0x62, 0x35, 0x35, 0x61, 0x38, 0x35, 0x39, 0x31, 0x63, 0x32, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x34, 0x32, 0x63, 0x61, 0x39, 0x37, 0x31, 0x63, 0x36, 0x35, 0x37, 0x38, 0x64, 0x35, 0x61, 0x64, 0x65, 0x32, 0x39, 0x35, 0x63, 0x33, 0x65, 0x37, 0x66, 0x34, 0x61, 0x64, 0x33, 0x33, 0x31, 0x64, 0x64, 0x33, 0x34, 0x32, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x65, 0x31, 0x31, 0x36, 0x32, 0x63, 0x65, 0x61, 0x65, 0x33, 0x63, 0x66, 0x32, 0x31, 0x61, 0x33, 0x66, 0x36, 0x32, 0x64, 0x31, 0x30, 0x35, 0x39, 0x39, 0x30, 0x33, 0x30, 0x32, 0x65, 0x33, 0x30, 0x37, 0x66, 0x34, 0x65, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x31, 0x64, 0x63, 0x33, 0x33, 0x38, 0x37, 0x62, 0x34, 0x37, 0x62, 0x38, 0x34, 0x35, 0x31, 0x65, 0x35, 0x35, 0x31, 0x30, 0x36, 0x63, 0x30, 0x63, 0x63, 0x36, 0x37, 0x64, 0x36, 0x64, 0x63, 0x37, 0x32, 0x62, 0x37, 0x66, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x32, 0x38, 0x31, 0x39, 0x65, 0x38, 0x64, 0x35, 0x37, 0x38, 0x32, 0x31, 0x39, 0x32, 0x32, 0x65, 0x65, 0x34, 0x34, 0x35, 0x36, 0x35, 0x30, 0x63, 0x63, 0x61, 0x65, 0x63, 0x37, 0x64, 0x34, 0x30, 0x35, 0x34, 0x34, 0x61, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x32, 0x34, 0x62, 0x37, 0x38, 0x62, 0x61, 0x66, 0x32, 0x62, 0x61, 0x66, 0x63, 0x37, 0x66, 0x63, 0x63, 0x36, 0x39, 0x30, 0x31, 0x36, 0x34, 0x32, 0x36, 0x62, 0x65, 0x39, 0x37, 0x33, 0x65, 0x32, 0x30, 0x61, 0x35, 0x30, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x30, 0x63, 0x35, 0x32, 0x37, 0x33, 0x31, 0x32, 0x36, 0x64, 0x35, 0x31, 0x37, 0x63, 0x65, 0x36, 0x37, 0x31, 0x30, 0x31, 0x38, 0x31, 0x31, 0x63, 0x61, 0x62, 0x31, 0x36, 0x62, 0x38, 0x35, 0x33, 0x34, 0x63, 0x66, 0x39, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x32, 0x32, 0x35, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x31, 0x66, 0x39, 0x32, 0x39, 0x63, 0x61, 0x35, 0x39, 0x62, 0x35, 0x34, 0x66, 0x38, 0x34, 0x34, 0x33, 0x65, 0x33, 0x64, 0x34, 0x64, 0x37, 0x35, 0x64, 0x39, 0x35, 0x64, 0x65, 0x65, 0x32, 0x34, 0x33, 0x63, 0x65, 0x66, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x64, 0x33, 0x32, 0x35, 0x66, 0x64, 0x66, 0x66, 0x62, 0x39, 0x37, 0x62, 0x31, 0x39, 0x39, 0x39, 0x35, 0x32, 0x38, 0x34, 0x61, 0x66, 0x61, 0x35, 0x61, 0x62, 0x64, 0x62, 0x35, 0x37, 0x34, 0x61, 0x31, 0x64, 0x66, 0x31, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x63, 0x65, 0x38, 0x34, 0x32, 0x39, 0x62, 0x61, 0x34, 0x39, 0x63, 0x61, 0x61, 0x30, 0x33, 0x36, 0x39, 0x64, 0x31, 0x65, 0x34, 0x39, 0x34, 0x64, 0x62, 0x35, 0x37, 0x65, 0x38, 0x39, 0x65, 0x61, 0x62, 0x32, 0x61, 0x64, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x32, 0x62, 0x37, 0x36, 0x35, 0x31, 0x30, 0x32, 0x31, 0x34, 0x64, 0x63, 0x36, 0x32, 0x30, 0x66, 0x36, 0x63, 0x33, 0x61, 0x31, 0x64, 0x64, 0x32, 0x39, 0x61, 0x61, 0x32, 0x32, 0x62, 0x66, 0x36, 0x64, 0x32, 0x31, 0x34, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x36, 0x66, 0x32, 0x64, 0x61, 0x37, 0x66, 0x30, 0x30, 0x38, 0x35, 0x65, 0x66, 0x33, 0x66, 0x33, 0x66, 0x61, 0x30, 0x39, 0x62, 0x61, 0x65, 0x65, 0x32, 0x33, 0x32, 0x62, 0x39, 0x33, 0x63, 0x37, 0x34, 0x34, 0x64, 0x62, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x37, 0x30, 0x63, 0x36, 0x31, 0x62, 0x65, 0x37, 0x38, 0x37, 0x37, 0x32, 0x32, 0x33, 0x30, 0x63, 0x62, 0x35, 0x61, 0x33, 0x62, 0x62, 0x32, 0x34, 0x32, 0x39, 0x61, 0x37, 0x32, 0x36, 0x31, 0x34, 0x61, 0x30, 0x62, 0x33, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x36, 0x37, 0x36, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x64, 0x66, 0x63, 0x62, 0x31, 0x37, 0x61, 0x31, 0x62, 0x38, 0x37, 0x34, 0x34, 0x31, 0x30, 0x33, 0x36, 0x33, 0x37, 0x34, 0x62, 0x37, 0x36, 0x32, 0x61, 0x35, 0x64, 0x33, 0x34, 0x31, 0x38, 0x62, 0x31, 0x63, 0x62, 0x34, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x36, 0x37, 0x64, 0x66, 0x38, 0x39, 0x36, 0x39, 0x31, 0x30, 0x31, 0x61, 0x64, 0x61, 0x62, 0x64, 0x39, 0x31, 0x61, 0x63, 0x63, 0x64, 0x36, 0x62, 0x62, 0x31, 0x39, 0x39, 0x31, 0x32, 0x37, 0x34, 0x61, 0x66, 0x38, 0x64, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x39, 0x63, 0x35, 0x39, 0x36, 0x33, 0x31, 0x65, 0x32, 0x62, 0x61, 0x32, 0x65, 0x38, 0x65, 0x38, 0x32, 0x38, 0x39, 0x31, 0x66, 0x33, 0x39, 0x37, 0x39, 0x39, 0x32, 0x32, 0x61, 0x61, 0x61, 0x33, 0x62, 0x35, 0x36, 0x37, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x39, 0x66, 0x38, 0x63, 0x31, 0x30, 0x37, 0x62, 0x63, 0x37, 0x66, 0x30, 0x61, 0x63, 0x65, 0x61, 0x61, 0x30, 0x66, 0x31, 0x37, 0x30, 0x35, 0x32, 0x61, 0x61, 0x64, 0x62, 0x64, 0x32, 0x66, 0x39, 0x37, 0x33, 0x32, 0x62, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x34, 0x65, 0x38, 0x30, 0x39, 0x65, 0x32, 0x36, 0x36, 0x61, 0x65, 0x35, 0x66, 0x31, 0x33, 0x63, 0x64, 0x62, 0x65, 0x33, 0x38, 0x66, 0x39, 0x64, 0x30, 0x34, 0x35, 0x36, 0x65, 0x36, 0x33, 0x38, 0x36, 0x64, 0x31, 0x32, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x35, 0x35, 0x31, 0x30, 0x61, 0x32, 0x34, 0x32, 0x64, 0x66, 0x62, 0x30, 0x31, 0x38, 0x33, 0x64, 0x65, 0x39, 0x32, 0x35, 0x66, 0x62, 0x61, 0x38, 0x36, 0x36, 0x65, 0x33, 0x31, 0x32, 0x66, 0x61, 0x62, 0x63, 0x31, 0x36, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x36, 0x65, 0x30, 0x64, 0x39, 0x34, 0x62, 0x39, 0x35, 0x33, 0x36, 0x34, 0x61, 0x38, 0x32, 0x36, 0x37, 0x31, 0x62, 0x36, 0x30, 0x38, 0x63, 0x62, 0x32, 0x64, 0x33, 0x37, 0x33, 0x32, 0x34, 0x35, 0x36, 0x31, 0x32, 0x39, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x63, 0x34, 0x36, 0x36, 0x39, 0x36, 0x66, 0x66, 0x61, 0x63, 0x31, 0x66, 0x35, 0x38, 0x30, 0x30, 0x35, 0x66, 0x61, 0x38, 0x34, 0x33, 0x39, 0x38, 0x32, 0x34, 0x66, 0x30, 0x38, 0x65, 0x65, 0x64, 0x31, 0x64, 0x66, 0x38, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x66, 0x62, 0x31, 0x65, 0x65, 0x33, 0x37, 0x34, 0x31, 0x37, 0x64, 0x30, 0x38, 0x30, 0x61, 0x30, 0x64, 0x30, 0x34, 0x38, 0x39, 0x32, 0x33, 0x62, 0x64, 0x61, 0x62, 0x61, 0x62, 0x30, 0x39, 0x35, 0x64, 0x30, 0x37, 0x37, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x63, 0x39, 0x65, 0x63, 0x61, 0x34, 0x30, 0x39, 0x37, 0x33, 0x66, 0x36, 0x33, 0x62, 0x62, 0x35, 0x39, 0x32, 0x37, 0x62, 0x65, 0x30, 0x62, 0x63, 0x36, 0x61, 0x38, 0x61, 0x38, 0x62, 0x65, 0x31, 0x39, 0x35, 0x31, 0x66, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x31, 0x34, 0x62, 0x66, 0x64, 0x61, 0x30, 0x61, 0x36, 0x65, 0x37, 0x36, 0x36, 0x36, 0x38, 0x66, 0x38, 0x37, 0x38, 0x38, 0x33, 0x32, 0x31, 0x66, 0x30, 0x37, 0x64, 0x66, 0x33, 0x37, 0x38, 0x32, 0x34, 0x65, 0x63, 0x35, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x62, 0x34, 0x64, 0x34, 0x61, 0x64, 0x65, 0x35, 0x32, 0x66, 0x63, 0x63, 0x38, 0x31, 0x38, 0x61, 0x63, 0x63, 0x37, 0x61, 0x32, 0x63, 0x36, 0x62, 0x62, 0x32, 0x62, 0x30, 0x30, 0x32, 0x32, 0x34, 0x36, 0x35, 0x38, 0x66, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x39, 0x37, 0x66, 0x66, 0x65, 0x66, 0x62, 0x33, 0x63, 0x31, 0x64, 0x39, 0x64, 0x31, 0x30, 0x66, 0x31, 0x61, 0x65, 0x32, 0x61, 0x63, 0x38, 0x61, 0x63, 0x33, 0x63, 0x38, 0x65, 0x32, 0x64, 0x32, 0x32, 0x39, 0x32, 0x37, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x63, 0x65, 0x62, 0x32, 0x65, 0x31, 0x32, 0x34, 0x35, 0x33, 0x36, 0x63, 0x35, 0x62, 0x35, 0x66, 0x66, 0x63, 0x36, 0x34, 0x30, 0x65, 0x64, 0x31, 0x34, 0x66, 0x66, 0x31, 0x35, 0x65, 0x64, 0x39, 0x61, 0x38, 0x63, 0x62, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x30, 0x32, 0x62, 0x64, 0x61, 0x36, 0x63, 0x33, 0x36, 0x39, 0x32, 0x32, 0x61, 0x36, 0x62, 0x65, 0x36, 0x61, 0x35, 0x30, 0x39, 0x62, 0x65, 0x35, 0x31, 0x39, 0x30, 0x36, 0x64, 0x33, 0x39, 0x33, 0x66, 0x37, 0x62, 0x39, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x39, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x30, 0x30, 0x37, 0x37, 0x63, 0x39, 0x66, 0x37, 0x62, 0x39, 0x30, 0x37, 0x66, 0x66, 0x39, 0x63, 0x65, 0x63, 0x30, 0x63, 0x37, 0x37, 0x61, 0x34, 0x31, 0x61, 0x37, 0x30, 0x65, 0x39, 0x30, 0x32, 0x39, 0x61, 0x64, 0x64, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x39, 0x33, 0x36, 0x61, 0x33, 0x37, 0x64, 0x66, 0x38, 0x35, 0x62, 0x33, 0x61, 0x31, 0x35, 0x38, 0x63, 0x61, 0x66, 0x64, 0x39, 0x64, 0x65, 0x30, 0x32, 0x31, 0x66, 0x35, 0x38, 0x31, 0x33, 0x37, 0x36, 0x38, 0x31, 0x33, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x39, 0x63, 0x34, 0x32, 0x39, 0x32, 0x36, 0x36, 0x64, 0x66, 0x30, 0x35, 0x37, 0x65, 0x66, 0x61, 0x37, 0x38, 0x64, 0x64, 0x31, 0x64, 0x35, 0x66, 0x37, 0x37, 0x66, 0x63, 0x34, 0x30, 0x37, 0x34, 0x32, 0x61, 0x64, 0x34, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x35, 0x39, 0x66, 0x33, 0x62, 0x33, 0x30, 0x63, 0x65, 0x66, 0x66, 0x63, 0x35, 0x36, 0x34, 0x36, 0x31, 0x63, 0x63, 0x35, 0x62, 0x38, 0x64, 0x66, 0x34, 0x38, 0x39, 0x30, 0x32, 0x32, 0x34, 0x30, 0x65, 0x30, 0x65, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x35, 0x33, 0x34, 0x38, 0x31, 0x35, 0x64, 0x63, 0x36, 0x33, 0x35, 0x65, 0x66, 0x61, 0x35, 0x63, 0x63, 0x38, 0x34, 0x62, 0x32, 0x61, 0x63, 0x37, 0x33, 0x34, 0x37, 0x32, 0x33, 0x65, 0x32, 0x31, 0x62, 0x32, 0x39, 0x33, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x37, 0x33, 0x65, 0x35, 0x37, 0x61, 0x36, 0x35, 0x63, 0x39, 0x33, 0x62, 0x36, 0x65, 0x31, 0x38, 0x63, 0x62, 0x37, 0x35, 0x66, 0x30, 0x64, 0x63, 0x30, 0x37, 0x37, 0x64, 0x35, 0x62, 0x38, 0x39, 0x33, 0x33, 0x64, 0x63, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x62, 0x37, 0x38, 0x63, 0x39, 0x66, 0x61, 0x64, 0x38, 0x35, 0x62, 0x34, 0x33, 0x33, 0x34, 0x33, 0x66, 0x30, 0x62, 0x66, 0x63, 0x64, 0x30, 0x66, 0x61, 0x63, 0x31, 0x31, 0x63, 0x39, 0x39, 0x34, 0x39, 0x63, 0x61, 0x35, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x64, 0x32, 0x62, 0x37, 0x66, 0x38, 0x31, 0x30, 0x36, 0x36, 0x39, 0x35, 0x30, 0x37, 0x38, 0x65, 0x36, 0x63, 0x31, 0x33, 0x38, 0x65, 0x63, 0x38, 0x31, 0x61, 0x37, 0x34, 0x38, 0x36, 0x61, 0x61, 0x63, 0x61, 0x31, 0x65, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x39, 0x63, 0x38, 0x36, 0x36, 0x38, 0x30, 0x33, 0x36, 0x64, 0x31, 0x34, 0x33, 0x66, 0x62, 0x38, 0x61, 0x65, 0x37, 0x30, 0x62, 0x31, 0x31, 0x39, 0x39, 0x35, 0x36, 0x33, 0x31, 0x66, 0x33, 0x64, 0x66, 0x63, 0x61, 0x64, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x30, 0x32, 0x34, 0x35, 0x38, 0x64, 0x61, 0x38, 0x36, 0x66, 0x36, 0x64, 0x36, 0x61, 0x39, 0x64, 0x39, 0x65, 0x62, 0x30, 0x33, 0x64, 0x61, 0x66, 0x39, 0x37, 0x66, 0x65, 0x35, 0x36, 0x31, 0x39, 0x64, 0x34, 0x34, 0x32, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x36, 0x30, 0x37, 0x62, 0x33, 0x66, 0x31, 0x32, 0x34, 0x36, 0x39, 0x66, 0x34, 0x34, 0x36, 0x31, 0x32, 0x31, 0x63, 0x65, 0x62, 0x66, 0x33, 0x34, 0x37, 0x35, 0x33, 0x35, 0x36, 0x62, 0x37, 0x31, 0x62, 0x34, 0x33, 0x32, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x33, 0x38, 0x32, 0x37, 0x64, 0x35, 0x37, 0x36, 0x33, 0x30, 0x63, 0x66, 0x38, 0x37, 0x36, 0x31, 0x64, 0x35, 0x31, 0x32, 0x37, 0x39, 0x37, 0x62, 0x30, 0x62, 0x38, 0x35, 0x38, 0x65, 0x34, 0x37, 0x38, 0x62, 0x62, 0x64, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x39, 0x63, 0x34, 0x65, 0x66, 0x65, 0x39, 0x66, 0x34, 0x33, 0x33, 0x39, 0x38, 0x39, 0x65, 0x32, 0x33, 0x62, 0x65, 0x39, 0x34, 0x30, 0x34, 0x39, 0x32, 0x31, 0x35, 0x33, 0x32, 0x39, 0x66, 0x61, 0x35, 0x35, 0x62, 0x34, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x36, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x64, 0x39, 0x30, 0x35, 0x66, 0x31, 0x37, 0x31, 0x39, 0x66, 0x63, 0x37, 0x61, 0x63, 0x64, 0x30, 0x31, 0x35, 0x39, 0x64, 0x34, 0x64, 0x63, 0x31, 0x66, 0x38, 0x64, 0x62, 0x32, 0x66, 0x32, 0x31, 0x34, 0x37, 0x32, 0x33, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x38, 0x32, 0x65, 0x35, 0x32, 0x33, 0x63, 0x63, 0x32, 0x64, 0x63, 0x35, 0x39, 0x31, 0x64, 0x61, 0x33, 0x39, 0x35, 0x34, 0x65, 0x38, 0x62, 0x36, 0x62, 0x62, 0x32, 0x63, 0x61, 0x66, 0x36, 0x34, 0x36, 0x31, 0x65, 0x36, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x31, 0x36, 0x30, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x61, 0x66, 0x65, 0x35, 0x34, 0x39, 0x30, 0x32, 0x64, 0x36, 0x31, 0x35, 0x37, 0x38, 0x32, 0x35, 0x37, 0x36, 0x66, 0x38, 0x62, 0x61, 0x61, 0x63, 0x31, 0x33, 0x61, 0x63, 0x39, 0x37, 0x30, 0x63, 0x30, 0x35, 0x30, 0x66, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x37, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x66, 0x31, 0x31, 0x63, 0x63, 0x66, 0x36, 0x39, 0x39, 0x33, 0x30, 0x34, 0x64, 0x35, 0x66, 0x35, 0x38, 0x36, 0x32, 0x61, 0x66, 0x38, 0x36, 0x30, 0x38, 0x33, 0x34, 0x35, 0x31, 0x63, 0x32, 0x36, 0x65, 0x37, 0x39, 0x61, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x38, 0x35, 0x66, 0x65, 0x65, 0x36, 0x37, 0x31, 0x30, 0x37, 0x64, 0x63, 0x33, 0x61, 0x33, 0x63, 0x37, 0x34, 0x31, 0x65, 0x65, 0x32, 0x39, 0x30, 0x63, 0x39, 0x38, 0x39, 0x31, 0x38, 0x63, 0x39, 0x62, 0x39, 0x39, 0x33, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x33, 0x34, 0x33, 0x61, 0x65, 0x63, 0x61, 0x30, 0x37, 0x62, 0x36, 0x65, 0x64, 0x35, 0x38, 0x61, 0x30, 0x65, 0x36, 0x32, 0x66, 0x61, 0x34, 0x65, 0x63, 0x62, 0x34, 0x39, 0x38, 0x61, 0x31, 0x32, 0x34, 0x66, 0x63, 0x39, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x34, 0x61, 0x32, 0x38, 0x66, 0x62, 0x33, 0x32, 0x33, 0x30, 0x61, 0x39, 0x64, 0x64, 0x66, 0x61, 0x39, 0x36, 0x34, 0x65, 0x37, 0x37, 0x30, 0x66, 0x32, 0x63, 0x65, 0x33, 0x63, 0x32, 0x35, 0x33, 0x61, 0x37, 0x62, 0x65, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x38, 0x32, 0x39, 0x36, 0x37, 0x63, 0x65, 0x65, 0x36, 0x38, 0x64, 0x32, 0x61, 0x38, 0x33, 0x39, 0x66, 0x61, 0x64, 0x38, 0x61, 0x62, 0x34, 0x61, 0x37, 0x63, 0x33, 0x64, 0x64, 0x64, 0x66, 0x36, 0x63, 0x30, 0x61, 0x64, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x36, 0x38, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x64, 0x66, 0x34, 0x65, 0x33, 0x34, 0x34, 0x35, 0x64, 0x37, 0x36, 0x36, 0x32, 0x36, 0x32, 0x34, 0x63, 0x34, 0x38, 0x65, 0x62, 0x61, 0x37, 0x34, 0x63, 0x66, 0x39, 0x65, 0x30, 0x61, 0x35, 0x33, 0x65, 0x39, 0x66, 0x37, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x39, 0x66, 0x61, 0x61, 0x31, 0x37, 0x35, 0x34, 0x32, 0x66, 0x61, 0x66, 0x62, 0x62, 0x33, 0x38, 0x38, 0x65, 0x61, 0x62, 0x32, 0x31, 0x62, 0x63, 0x34, 0x63, 0x39, 0x34, 0x65, 0x38, 0x61, 0x37, 0x62, 0x33, 0x34, 0x37, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x62, 0x31, 0x38, 0x35, 0x30, 0x35, 0x32, 0x35, 0x64, 0x39, 0x34, 0x36, 0x66, 0x32, 0x61, 0x65, 0x38, 0x34, 0x66, 0x33, 0x31, 0x37, 0x62, 0x31, 0x35, 0x31, 0x38, 0x38, 0x63, 0x35, 0x33, 0x36, 0x61, 0x35, 0x64, 0x63, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x62, 0x61, 0x63, 0x36, 0x38, 0x64, 0x39, 0x34, 0x37, 0x38, 0x35, 0x39, 0x66, 0x35, 0x39, 0x65, 0x39, 0x32, 0x32, 0x36, 0x30, 0x38, 0x39, 0x63, 0x39, 0x36, 0x64, 0x36, 0x32, 0x65, 0x39, 0x66, 0x62, 0x65, 0x33, 0x63, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x62, 0x66, 0x63, 0x34, 0x31, 0x30, 0x64, 0x64, 0x64, 0x62, 0x32, 0x30, 0x37, 0x31, 0x31, 0x65, 0x34, 0x35, 0x63, 0x30, 0x37, 0x33, 0x38, 0x37, 0x65, 0x61, 0x62, 0x33, 0x30, 0x61, 0x30, 0x35, 0x34, 0x65, 0x31, 0x39, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x35, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x30, 0x61, 0x31, 0x38, 0x31, 0x39, 0x62, 0x64, 0x37, 0x63, 0x33, 0x35, 0x38, 0x36, 0x31, 0x65, 0x37, 0x39, 0x31, 0x38, 0x30, 0x34, 0x65, 0x35, 0x66, 0x62, 0x62, 0x33, 0x62, 0x63, 0x39, 0x37, 0x63, 0x39, 0x61, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x35, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x37, 0x62, 0x36, 0x31, 0x63, 0x30, 0x33, 0x62, 0x62, 0x39, 0x33, 0x37, 0x61, 0x39, 0x66, 0x35, 0x64, 0x30, 0x66, 0x63, 0x35, 0x61, 0x30, 0x39, 0x66, 0x31, 0x65, 0x61, 0x33, 0x33, 0x36, 0x33, 0x63, 0x37, 0x37, 0x30, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x30, 0x64, 0x66, 0x31, 0x64, 0x66, 0x34, 0x62, 0x65, 0x64, 0x32, 0x33, 0x37, 0x36, 0x30, 0x64, 0x32, 0x64, 0x31, 0x63, 0x30, 0x33, 0x37, 0x38, 0x31, 0x35, 0x38, 0x36, 0x64, 0x64, 0x66, 0x37, 0x39, 0x31, 0x38, 0x65, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x35, 0x31, 0x65, 0x65, 0x32, 0x65, 0x61, 0x31, 0x34, 0x33, 0x64, 0x37, 0x62, 0x31, 0x64, 0x36, 0x62, 0x37, 0x37, 0x65, 0x37, 0x65, 0x34, 0x34, 0x62, 0x64, 0x64, 0x37, 0x64, 0x61, 0x31, 0x32, 0x66, 0x34, 0x38, 0x35, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x35, 0x31, 0x32, 0x35, 0x62, 0x66, 0x30, 0x66, 0x35, 0x65, 0x62, 0x30, 0x62, 0x36, 0x66, 0x30, 0x32, 0x30, 0x65, 0x35, 0x36, 0x62, 0x66, 0x63, 0x32, 0x66, 0x64, 0x66, 0x33, 0x64, 0x34, 0x30, 0x32, 0x63, 0x30, 0x39, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x30, 0x63, 0x38, 0x33, 0x61, 0x61, 0x63, 0x35, 0x37, 0x31, 0x37, 0x39, 0x36, 0x32, 0x37, 0x33, 0x34, 0x65, 0x35, 0x63, 0x65, 0x61, 0x65, 0x61, 0x65, 0x63, 0x64, 0x33, 0x39, 0x62, 0x32, 0x38, 0x61, 0x64, 0x30, 0x36, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x30, 0x36, 0x36, 0x31, 0x66, 0x66, 0x39, 0x34, 0x31, 0x34, 0x30, 0x66, 0x32, 0x30, 0x33, 0x65, 0x37, 0x61, 0x34, 0x38, 0x32, 0x35, 0x37, 0x32, 0x34, 0x33, 0x37, 0x39, 0x33, 0x38, 0x62, 0x65, 0x63, 0x39, 0x63, 0x33, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x33, 0x30, 0x39, 0x37, 0x61, 0x37, 0x39, 0x62, 0x33, 0x63, 0x30, 0x64, 0x32, 0x65, 0x62, 0x66, 0x66, 0x30, 0x65, 0x36, 0x65, 0x38, 0x36, 0x61, 0x62, 0x30, 0x65, 0x64, 0x61, 0x64, 0x62, 0x65, 0x64, 0x34, 0x37, 0x30, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x65, 0x62, 0x34, 0x38, 0x39, 0x34, 0x61, 0x61, 0x64, 0x64, 0x30, 0x30, 0x38, 0x31, 0x62, 0x62, 0x64, 0x64, 0x64, 0x33, 0x65, 0x38, 0x38, 0x34, 0x36, 0x38, 0x30, 0x34, 0x62, 0x35, 0x38, 0x33, 0x64, 0x31, 0x39, 0x66, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x63, 0x39, 0x37, 0x37, 0x31, 0x66, 0x63, 0x61, 0x31, 0x39, 0x64, 0x35, 0x62, 0x39, 0x64, 0x32, 0x34, 0x35, 0x63, 0x38, 0x39, 0x31, 0x66, 0x38, 0x31, 0x35, 0x38, 0x66, 0x65, 0x34, 0x39, 0x66, 0x34, 0x37, 0x61, 0x30, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x30, 0x35, 0x64, 0x64, 0x31, 0x33, 0x65, 0x39, 0x33, 0x61, 0x62, 0x63, 0x66, 0x66, 0x33, 0x37, 0x37, 0x65, 0x37, 0x30, 0x30, 0x65, 0x33, 0x63, 0x31, 0x61, 0x30, 0x30, 0x38, 0x36, 0x65, 0x63, 0x61, 0x32, 0x37, 0x64, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x35, 0x65, 0x30, 0x34, 0x66, 0x30, 0x31, 0x38, 0x34, 0x33, 0x36, 0x39, 0x62, 0x63, 0x66, 0x61, 0x30, 0x36, 0x61, 0x63, 0x61, 0x36, 0x36, 0x66, 0x66, 0x61, 0x39, 0x31, 0x62, 0x66, 0x35, 0x39, 0x66, 0x61, 0x30, 0x66, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x36, 0x34, 0x33, 0x30, 0x39, 0x61, 0x39, 0x66, 0x61, 0x30, 0x37, 0x30, 0x39, 0x35, 0x36, 0x30, 0x30, 0x66, 0x37, 0x39, 0x65, 0x64, 0x63, 0x36, 0x35, 0x31, 0x32, 0x30, 0x63, 0x64, 0x63, 0x64, 0x32, 0x33, 0x64, 0x63, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x34, 0x39, 0x62, 0x35, 0x34, 0x65, 0x30, 0x34, 0x64, 0x35, 0x62, 0x31, 0x39, 0x62, 0x64, 0x63, 0x65, 0x64, 0x66, 0x62, 0x38, 0x34, 0x64, 0x61, 0x37, 0x37, 0x30, 0x31, 0x61, 0x62, 0x34, 0x37, 0x38, 0x63, 0x32, 0x37, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x39, 0x33, 0x63, 0x36, 0x35, 0x32, 0x38, 0x35, 0x65, 0x65, 0x36, 0x62, 0x62, 0x64, 0x36, 0x36, 0x33, 0x37, 0x66, 0x33, 0x62, 0x65, 0x38, 0x66, 0x38, 0x39, 0x61, 0x64, 0x34, 0x30, 0x64, 0x34, 0x38, 0x39, 0x66, 0x36, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x32, 0x34, 0x66, 0x38, 0x38, 0x30, 0x66, 0x39, 0x34, 0x37, 0x39, 0x61, 0x38, 0x39, 0x64, 0x33, 0x32, 0x66, 0x30, 0x39, 0x65, 0x35, 0x32, 0x62, 0x65, 0x39, 0x39, 0x30, 0x62, 0x32, 0x38, 0x38, 0x31, 0x33, 0x35, 0x63, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x62, 0x62, 0x35, 0x31, 0x62, 0x63, 0x33, 0x62, 0x66, 0x65, 0x39, 0x61, 0x31, 0x62, 0x32, 0x61, 0x32, 0x66, 0x36, 0x62, 0x31, 0x63, 0x64, 0x61, 0x39, 0x35, 0x62, 0x63, 0x61, 0x38, 0x62, 0x33, 0x38, 0x63, 0x38, 0x64, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x31, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x66, 0x34, 0x34, 0x38, 0x31, 0x64, 0x39, 0x64, 0x62, 0x37, 0x38, 0x64, 0x63, 0x34, 0x66, 0x32, 0x35, 0x66, 0x37, 0x62, 0x34, 0x61, 0x63, 0x38, 0x62, 0x64, 0x33, 0x62, 0x31, 0x63, 0x61, 0x30, 0x31, 0x30, 0x36, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x63, 0x61, 0x38, 0x62, 0x64, 0x34, 0x64, 0x63, 0x36, 0x34, 0x34, 0x66, 0x61, 0x63, 0x34, 0x37, 0x61, 0x66, 0x36, 0x37, 0x35, 0x35, 0x36, 0x33, 0x64, 0x35, 0x38, 0x30, 0x34, 0x61, 0x30, 0x64, 0x61, 0x32, 0x31, 0x65, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x66, 0x36, 0x34, 0x33, 0x65, 0x31, 0x61, 0x38, 0x66, 0x61, 0x30, 0x34, 0x61, 0x65, 0x31, 0x36, 0x30, 0x30, 0x36, 0x30, 0x32, 0x38, 0x31, 0x33, 0x38, 0x33, 0x33, 0x33, 0x61, 0x35, 0x39, 0x61, 0x39, 0x36, 0x64, 0x65, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x62, 0x38, 0x30, 0x38, 0x61, 0x36, 0x35, 0x62, 0x35, 0x31, 0x65, 0x36, 0x33, 0x33, 0x38, 0x39, 0x36, 0x39, 0x61, 0x66, 0x62, 0x39, 0x35, 0x65, 0x63, 0x37, 0x30, 0x37, 0x33, 0x35, 0x65, 0x34, 0x35, 0x31, 0x64, 0x35, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x34, 0x39, 0x32, 0x31, 0x38, 0x33, 0x38, 0x63, 0x63, 0x37, 0x37, 0x64, 0x36, 0x63, 0x39, 0x38, 0x62, 0x31, 0x37, 0x64, 0x39, 0x30, 0x33, 0x61, 0x33, 0x61, 0x65, 0x30, 0x65, 0x65, 0x30, 0x64, 0x61, 0x39, 0x35, 0x62, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x36, 0x39, 0x32, 0x34, 0x64, 0x30, 0x37, 0x63, 0x33, 0x65, 0x66, 0x35, 0x38, 0x39, 0x31, 0x39, 0x36, 0x36, 0x66, 0x65, 0x30, 0x61, 0x37, 0x38, 0x35, 0x36, 0x63, 0x38, 0x37, 0x62, 0x65, 0x66, 0x39, 0x64, 0x32, 0x30, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x37, 0x36, 0x37, 0x65, 0x34, 0x65, 0x63, 0x62, 0x34, 0x61, 0x35, 0x39, 0x38, 0x30, 0x35, 0x32, 0x37, 0x35, 0x30, 0x38, 0x64, 0x37, 0x62, 0x65, 0x63, 0x33, 0x64, 0x34, 0x35, 0x65, 0x34, 0x63, 0x36, 0x34, 0x39, 0x63, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x62, 0x65, 0x39, 0x39, 0x62, 0x39, 0x31, 0x30, 0x33, 0x63, 0x65, 0x37, 0x35, 0x35, 0x30, 0x61, 0x61, 0x37, 0x34, 0x66, 0x66, 0x31, 0x64, 0x62, 0x31, 0x38, 0x65, 0x30, 0x39, 0x64, 0x66, 0x65, 0x33, 0x32, 0x65, 0x30, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x35, 0x36, 0x34, 0x34, 0x63, 0x39, 0x35, 0x61, 0x38, 0x37, 0x33, 0x65, 0x66, 0x38, 0x63, 0x30, 0x36, 0x63, 0x64, 0x62, 0x39, 0x65, 0x39, 0x66, 0x36, 0x64, 0x38, 0x64, 0x37, 0x36, 0x38, 0x30, 0x30, 0x34, 0x33, 0x64, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x34, 0x34, 0x61, 0x66, 0x39, 0x36, 0x62, 0x33, 0x66, 0x30, 0x33, 0x32, 0x61, 0x65, 0x36, 0x34, 0x31, 0x62, 0x65, 0x62, 0x36, 0x37, 0x66, 0x34, 0x62, 0x36, 0x63, 0x38, 0x33, 0x33, 0x34, 0x32, 0x64, 0x33, 0x37, 0x63, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x61, 0x31, 0x30, 0x65, 0x63, 0x37, 0x61, 0x35, 0x63, 0x39, 0x33, 0x32, 0x34, 0x39, 0x39, 0x39, 0x64, 0x64, 0x39, 0x65, 0x39, 0x62, 0x36, 0x62, 0x64, 0x65, 0x37, 0x63, 0x39, 0x31, 0x31, 0x65, 0x35, 0x38, 0x34, 0x62, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x64, 0x64, 0x62, 0x65, 0x64, 0x37, 0x33, 0x32, 0x65, 0x62, 0x66, 0x65, 0x37, 0x35, 0x34, 0x30, 0x39, 0x36, 0x66, 0x64, 0x65, 0x39, 0x30, 0x38, 0x36, 0x62, 0x38, 0x65, 0x61, 0x34, 0x61, 0x34, 0x63, 0x64, 0x63, 0x36, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x35, 0x66, 0x61, 0x36, 0x36, 0x63, 0x30, 0x32, 0x35, 0x65, 0x66, 0x35, 0x35, 0x34, 0x30, 0x30, 0x37, 0x30, 0x65, 0x62, 0x63, 0x66, 0x30, 0x64, 0x33, 0x37, 0x32, 0x64, 0x38, 0x31, 0x37, 0x37, 0x63, 0x34, 0x36, 0x37, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x30, 0x38, 0x34, 0x37, 0x31, 0x64, 0x36, 0x38, 0x30, 0x30, 0x37, 0x61, 0x66, 0x66, 0x32, 0x61, 0x65, 0x32, 0x37, 0x39, 0x62, 0x63, 0x35, 0x65, 0x33, 0x66, 0x65, 0x34, 0x31, 0x35, 0x36, 0x66, 0x62, 0x62, 0x65, 0x33, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x64, 0x63, 0x30, 0x30, 0x61, 0x62, 0x37, 0x39, 0x32, 0x37, 0x36, 0x30, 0x33, 0x63, 0x32, 0x66, 0x63, 0x66, 0x33, 0x31, 0x63, 0x65, 0x65, 0x33, 0x35, 0x32, 0x66, 0x38, 0x30, 0x65, 0x36, 0x63, 0x34, 0x64, 0x36, 0x33, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x36, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x39, 0x33, 0x63, 0x62, 0x65, 0x37, 0x66, 0x39, 0x62, 0x61, 0x32, 0x31, 0x36, 0x35, 0x65, 0x35, 0x61, 0x37, 0x35, 0x35, 0x33, 0x35, 0x30, 0x30, 0x62, 0x36, 0x65, 0x37, 0x35, 0x64, 0x61, 0x33, 0x63, 0x33, 0x33, 0x61, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x36, 0x31, 0x37, 0x65, 0x62, 0x63, 0x34, 0x62, 0x65, 0x62, 0x63, 0x35, 0x66, 0x35, 0x64, 0x64, 0x65, 0x62, 0x31, 0x62, 0x37, 0x61, 0x37, 0x30, 0x63, 0x64, 0x65, 0x62, 0x36, 0x61, 0x65, 0x32, 0x66, 0x66, 0x61, 0x30, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x65, 0x61, 0x31, 0x39, 0x36, 0x32, 0x65, 0x33, 0x35, 0x64, 0x36, 0x32, 0x30, 0x35, 0x39, 0x37, 0x36, 0x38, 0x63, 0x37, 0x34, 0x39, 0x62, 0x65, 0x64, 0x64, 0x39, 0x36, 0x63, 0x61, 0x62, 0x39, 0x33, 0x30, 0x64, 0x33, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x33, 0x62, 0x33, 0x62, 0x63, 0x61, 0x36, 0x61, 0x32, 0x39, 0x39, 0x33, 0x35, 0x39, 0x65, 0x38, 0x38, 0x36, 0x63, 0x65, 0x33, 0x33, 0x61, 0x33, 0x30, 0x33, 0x34, 0x31, 0x66, 0x61, 0x66, 0x65, 0x34, 0x64, 0x35, 0x37, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x34, 0x64, 0x34, 0x37, 0x62, 0x33, 0x63, 0x30, 0x35, 0x32, 0x61, 0x35, 0x65, 0x35, 0x30, 0x65, 0x34, 0x32, 0x36, 0x31, 0x61, 0x65, 0x30, 0x36, 0x61, 0x32, 0x30, 0x66, 0x34, 0x35, 0x64, 0x38, 0x65, 0x65, 0x65, 0x32, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x32, 0x37, 0x65, 0x36, 0x37, 0x65, 0x66, 0x39, 0x31, 0x31, 0x62, 0x38, 0x31, 0x66, 0x36, 0x63, 0x66, 0x39, 0x63, 0x37, 0x33, 0x66, 0x63, 0x62, 0x66, 0x65, 0x62, 0x63, 0x32, 0x62, 0x30, 0x32, 0x62, 0x35, 0x62, 0x66, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x31, 0x30, 0x64, 0x36, 0x37, 0x39, 0x37, 0x66, 0x62, 0x61, 0x33, 0x64, 0x36, 0x36, 0x39, 0x33, 0x38, 0x33, 0x35, 0x61, 0x38, 0x34, 0x34, 0x65, 0x61, 0x32, 0x61, 0x64, 0x35, 0x34, 0x30, 0x36, 0x39, 0x31, 0x39, 0x37, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x64, 0x63, 0x39, 0x36, 0x30, 0x62, 0x39, 0x39, 0x38, 0x63, 0x31, 0x34, 0x31, 0x39, 0x39, 0x38, 0x31, 0x36, 0x30, 0x64, 0x63, 0x31, 0x37, 0x39, 0x62, 0x33, 0x36, 0x63, 0x31, 0x35, 0x64, 0x32, 0x38, 0x34, 0x37, 0x30, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x37, 0x36, 0x61, 0x36, 0x32, 0x64, 0x62, 0x31, 0x38, 0x37, 0x61, 0x61, 0x37, 0x34, 0x66, 0x36, 0x33, 0x38, 0x31, 0x37, 0x35, 0x33, 0x33, 0x62, 0x33, 0x30, 0x36, 0x63, 0x65, 0x61, 0x64, 0x30, 0x65, 0x38, 0x63, 0x65, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x35, 0x62, 0x36, 0x34, 0x31, 0x62, 0x31, 0x63, 0x64, 0x65, 0x61, 0x33, 0x36, 0x32, 0x63, 0x33, 0x62, 0x34, 0x63, 0x62, 0x62, 0x64, 0x30, 0x66, 0x35, 0x63, 0x63, 0x35, 0x30, 0x62, 0x31, 0x65, 0x31, 0x37, 0x36, 0x62, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x32, 0x36, 0x34, 0x36, 0x30, 0x64, 0x36, 0x39, 0x32, 0x63, 0x37, 0x31, 0x63, 0x39, 0x61, 0x66, 0x36, 0x66, 0x30, 0x35, 0x35, 0x37, 0x34, 0x64, 0x39, 0x33, 0x39, 0x39, 0x38, 0x33, 0x36, 0x38, 0x61, 0x32, 0x33, 0x37, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x30, 0x38, 0x30, 0x31, 0x39, 0x38, 0x36, 0x33, 0x63, 0x31, 0x61, 0x37, 0x37, 0x63, 0x31, 0x34, 0x39, 0x39, 0x65, 0x62, 0x33, 0x39, 0x62, 0x62, 0x64, 0x37, 0x62, 0x66, 0x32, 0x64, 0x64, 0x37, 0x61, 0x33, 0x31, 0x63, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x65, 0x65, 0x32, 0x30, 0x62, 0x30, 0x36, 0x64, 0x39, 0x61, 0x64, 0x35, 0x38, 0x39, 0x61, 0x37, 0x65, 0x37, 0x63, 0x65, 0x30, 0x34, 0x62, 0x39, 0x66, 0x35, 0x66, 0x37, 0x39, 0x35, 0x66, 0x34, 0x30, 0x32, 0x61, 0x65, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x33, 0x32, 0x62, 0x39, 0x64, 0x62, 0x61, 0x66, 0x31, 0x31, 0x62, 0x64, 0x62, 0x64, 0x37, 0x33, 0x62, 0x36, 0x35, 0x31, 0x39, 0x66, 0x63, 0x30, 0x61, 0x39, 0x30, 0x34, 0x31, 0x39, 0x38, 0x37, 0x37, 0x31, 0x61, 0x61, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x39, 0x34, 0x36, 0x64, 0x35, 0x36, 0x61, 0x34, 0x64, 0x33, 0x37, 0x31, 0x61, 0x39, 0x33, 0x33, 0x36, 0x38, 0x35, 0x33, 0x39, 0x36, 0x39, 0x30, 0x62, 0x36, 0x30, 0x65, 0x63, 0x38, 0x32, 0x35, 0x31, 0x30, 0x37, 0x34, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x66, 0x39, 0x66, 0x37, 0x63, 0x65, 0x66, 0x64, 0x37, 0x65, 0x33, 0x39, 0x34, 0x62, 0x39, 0x64, 0x33, 0x39, 0x32, 0x34, 0x34, 0x31, 0x32, 0x62, 0x66, 0x32, 0x63, 0x32, 0x38, 0x33, 0x31, 0x66, 0x61, 0x66, 0x31, 0x66, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x65, 0x62, 0x62, 0x31, 0x39, 0x32, 0x39, 0x61, 0x32, 0x33, 0x38, 0x37, 0x31, 0x63, 0x66, 0x37, 0x37, 0x66, 0x65, 0x30, 0x34, 0x39, 0x61, 0x62, 0x39, 0x36, 0x30, 0x32, 0x62, 0x65, 0x30, 0x38, 0x62, 0x65, 0x30, 0x61, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x64, 0x61, 0x63, 0x31, 0x61, 0x61, 0x35, 0x31, 0x37, 0x30, 0x30, 0x37, 0x65, 0x30, 0x30, 0x38, 0x39, 0x34, 0x33, 0x30, 0x62, 0x33, 0x33, 0x31, 0x36, 0x61, 0x31, 0x62, 0x61, 0x64, 0x64, 0x31, 0x32, 0x63, 0x30, 0x31, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x65, 0x36, 0x37, 0x31, 0x64, 0x65, 0x35, 0x35, 0x61, 0x66, 0x65, 0x63, 0x39, 0x36, 0x34, 0x62, 0x30, 0x37, 0x34, 0x64, 0x65, 0x35, 0x37, 0x34, 0x64, 0x35, 0x31, 0x35, 0x38, 0x64, 0x35, 0x64, 0x32, 0x31, 0x62, 0x30, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x31, 0x38, 0x31, 0x63, 0x34, 0x62, 0x34, 0x31, 0x66, 0x36, 0x66, 0x39, 0x37, 0x32, 0x62, 0x36, 0x36, 0x39, 0x35, 0x38, 0x32, 0x31, 0x35, 0x66, 0x31, 0x39, 0x66, 0x35, 0x37, 0x30, 0x63, 0x31, 0x35, 0x64, 0x64, 0x66, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x39, 0x35, 0x31, 0x39, 0x64, 0x31, 0x66, 0x33, 0x39, 0x38, 0x35, 0x66, 0x36, 0x62, 0x32, 0x35, 0x35, 0x65, 0x61, 0x64, 0x65, 0x64, 0x31, 0x32, 0x64, 0x35, 0x36, 0x32, 0x34, 0x61, 0x39, 0x37, 0x32, 0x37, 0x32, 0x31, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x39, 0x62, 0x62, 0x65, 0x66, 0x63, 0x34, 0x31, 0x63, 0x66, 0x64, 0x37, 0x64, 0x37, 0x63, 0x62, 0x62, 0x38, 0x64, 0x66, 0x63, 0x36, 0x33, 0x30, 0x32, 0x30, 0x65, 0x39, 0x66, 0x62, 0x30, 0x36, 0x64, 0x34, 0x39, 0x35, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x35, 0x61, 0x31, 0x38, 0x33, 0x61, 0x33, 0x61, 0x32, 0x33, 0x35, 0x66, 0x66, 0x62, 0x62, 0x30, 0x33, 0x62, 0x61, 0x38, 0x33, 0x35, 0x36, 0x37, 0x35, 0x32, 0x36, 0x37, 0x32, 0x32, 0x39, 0x34, 0x31, 0x37, 0x61, 0x30, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x64, 0x65, 0x33, 0x63, 0x62, 0x38, 0x31, 0x31, 0x38, 0x35, 0x36, 0x38, 0x65, 0x66, 0x34, 0x35, 0x30, 0x33, 0x66, 0x65, 0x39, 0x39, 0x38, 0x63, 0x63, 0x64, 0x66, 0x35, 0x33, 0x36, 0x62, 0x66, 0x31, 0x39, 0x61, 0x30, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x30, 0x35, 0x62, 0x32, 0x31, 0x63, 0x34, 0x66, 0x31, 0x37, 0x66, 0x39, 0x64, 0x37, 0x33, 0x66, 0x35, 0x66, 0x62, 0x32, 0x62, 0x30, 0x63, 0x62, 0x38, 0x39, 0x66, 0x66, 0x35, 0x33, 0x35, 0x36, 0x61, 0x36, 0x63, 0x63, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x63, 0x34, 0x63, 0x62, 0x61, 0x36, 0x32, 0x31, 0x66, 0x32, 0x32, 0x30, 0x36, 0x33, 0x37, 0x37, 0x34, 0x32, 0x30, 0x35, 0x37, 0x66, 0x36, 0x30, 0x35, 0x35, 0x62, 0x38, 0x30, 0x64, 0x66, 0x66, 0x64, 0x37, 0x37, 0x65, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x37, 0x36, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x62, 0x39, 0x34, 0x63, 0x35, 0x36, 0x38, 0x62, 0x66, 0x65, 0x35, 0x39, 0x61, 0x64, 0x65, 0x36, 0x35, 0x30, 0x36, 0x34, 0x35, 0x66, 0x34, 0x66, 0x32, 0x36, 0x33, 0x30, 0x36, 0x63, 0x37, 0x33, 0x36, 0x63, 0x61, 0x63, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x61, 0x36, 0x62, 0x38, 0x62, 0x38, 0x61, 0x64, 0x33, 0x31, 0x38, 0x34, 0x65, 0x33, 0x35, 0x37, 0x64, 0x61, 0x32, 0x38, 0x32, 0x39, 0x35, 0x31, 0x64, 0x37, 0x39, 0x31, 0x36, 0x31, 0x63, 0x66, 0x62, 0x30, 0x38, 0x39, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x30, 0x35, 0x38, 0x63, 0x35, 0x31, 0x37, 0x33, 0x37, 0x61, 0x34, 0x65, 0x39, 0x36, 0x63, 0x35, 0x35, 0x66, 0x32, 0x65, 0x66, 0x36, 0x62, 0x64, 0x37, 0x62, 0x62, 0x33, 0x35, 0x38, 0x31, 0x36, 0x37, 0x65, 0x63, 0x32, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x36, 0x30, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x31, 0x64, 0x34, 0x32, 0x34, 0x32, 0x37, 0x36, 0x62, 0x32, 0x31, 0x32, 0x33, 0x39, 0x36, 0x36, 0x35, 0x31, 0x38, 0x36, 0x31, 0x33, 0x33, 0x64, 0x36, 0x35, 0x33, 0x62, 0x62, 0x38, 0x62, 0x31, 0x38, 0x36, 0x32, 0x66, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x35, 0x66, 0x66, 0x62, 0x32, 0x62, 0x37, 0x34, 0x66, 0x38, 0x36, 0x37, 0x32, 0x30, 0x34, 0x66, 0x65, 0x35, 0x33, 0x31, 0x36, 0x35, 0x33, 0x62, 0x30, 0x32, 0x34, 0x38, 0x65, 0x32, 0x31, 0x63, 0x31, 0x33, 0x35, 0x34, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x66, 0x36, 0x33, 0x65, 0x62, 0x62, 0x63, 0x36, 0x32, 0x63, 0x37, 0x62, 0x37, 0x34, 0x34, 0x34, 0x30, 0x34, 0x30, 0x65, 0x62, 0x39, 0x39, 0x36, 0x32, 0x33, 0x39, 0x36, 0x34, 0x66, 0x37, 0x36, 0x36, 0x37, 0x62, 0x33, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x61, 0x33, 0x64, 0x37, 0x65, 0x62, 0x31, 0x33, 0x62, 0x31, 0x35, 0x63, 0x31, 0x30, 0x30, 0x31, 0x37, 0x37, 0x32, 0x33, 0x36, 0x64, 0x31, 0x62, 0x65, 0x62, 0x33, 0x30, 0x64, 0x31, 0x37, 0x65, 0x65, 0x31, 0x35, 0x34, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x66, 0x61, 0x38, 0x36, 0x32, 0x35, 0x63, 0x39, 0x64, 0x63, 0x38, 0x34, 0x33, 0x63, 0x37, 0x38, 0x63, 0x37, 0x61, 0x62, 0x32, 0x35, 0x39, 0x66, 0x66, 0x38, 0x37, 0x63, 0x39, 0x35, 0x39, 0x39, 0x65, 0x30, 0x37, 0x66, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x32, 0x36, 0x34, 0x61, 0x65, 0x64, 0x64, 0x35, 0x32, 0x64, 0x63, 0x61, 0x65, 0x39, 0x31, 0x38, 0x61, 0x30, 0x31, 0x32, 0x66, 0x62, 0x63, 0x64, 0x30, 0x63, 0x30, 0x33, 0x30, 0x65, 0x65, 0x36, 0x66, 0x37, 0x31, 0x38, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x31, 0x66, 0x34, 0x39, 0x30, 0x37, 0x62, 0x38, 0x66, 0x36, 0x31, 0x66, 0x30, 0x63, 0x35, 0x31, 0x35, 0x36, 0x38, 0x64, 0x36, 0x39, 0x32, 0x38, 0x30, 0x36, 0x62, 0x33, 0x38, 0x32, 0x66, 0x35, 0x30, 0x33, 0x32, 0x34, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x63, 0x65, 0x66, 0x36, 0x31, 0x63, 0x31, 0x63, 0x34, 0x34, 0x32, 0x62, 0x65, 0x66, 0x37, 0x63, 0x65, 0x30, 0x34, 0x62, 0x37, 0x33, 0x61, 0x64, 0x62, 0x32, 0x34, 0x39, 0x61, 0x38, 0x62, 0x61, 0x30, 0x34, 0x37, 0x65, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x38, 0x39, 0x33, 0x32, 0x38, 0x36, 0x34, 0x32, 0x37, 0x65, 0x37, 0x32, 0x64, 0x62, 0x32, 0x31, 0x39, 0x61, 0x32, 0x31, 0x66, 0x63, 0x34, 0x64, 0x63, 0x64, 0x35, 0x66, 0x62, 0x66, 0x35, 0x39, 0x32, 0x38, 0x33, 0x63, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x35, 0x65, 0x62, 0x36, 0x33, 0x61, 0x37, 0x62, 0x66, 0x34, 0x66, 0x62, 0x63, 0x32, 0x66, 0x36, 0x65, 0x34, 0x62, 0x61, 0x61, 0x30, 0x63, 0x36, 0x38, 0x61, 0x62, 0x31, 0x63, 0x62, 0x34, 0x63, 0x66, 0x39, 0x38, 0x66, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x65, 0x63, 0x31, 0x36, 0x65, 0x65, 0x39, 0x63, 0x61, 0x61, 0x62, 0x34, 0x31, 0x31, 0x63, 0x35, 0x35, 0x61, 0x36, 0x36, 0x32, 0x39, 0x65, 0x33, 0x31, 0x38, 0x64, 0x65, 0x36, 0x65, 0x65, 0x32, 0x31, 0x36, 0x34, 0x39, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x62, 0x36, 0x36, 0x31, 0x35, 0x30, 0x66, 0x31, 0x61, 0x36, 0x33, 0x34, 0x35, 0x37, 0x30, 0x32, 0x33, 0x66, 0x64, 0x64, 0x34, 0x35, 0x64, 0x30, 0x63, 0x63, 0x36, 0x63, 0x62, 0x35, 0x34, 0x65, 0x30, 0x63, 0x30, 0x66, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x31, 0x38, 0x33, 0x31, 0x36, 0x30, 0x64, 0x31, 0x37, 0x32, 0x64, 0x32, 0x65, 0x30, 0x38, 0x34, 0x64, 0x33, 0x32, 0x37, 0x62, 0x38, 0x36, 0x62, 0x63, 0x62, 0x37, 0x63, 0x31, 0x64, 0x38, 0x65, 0x36, 0x37, 0x38, 0x34, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x32, 0x30, 0x33, 0x38, 0x38, 0x66, 0x62, 0x65, 0x65, 0x38, 0x34, 0x61, 0x64, 0x36, 0x35, 0x36, 0x64, 0x64, 0x36, 0x38, 0x63, 0x64, 0x63, 0x31, 0x66, 0x62, 0x61, 0x61, 0x39, 0x33, 0x39, 0x32, 0x37, 0x38, 0x30, 0x62, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x37, 0x37, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x66, 0x37, 0x37, 0x34, 0x63, 0x39, 0x31, 0x34, 0x37, 0x64, 0x64, 0x65, 0x39, 0x30, 0x38, 0x35, 0x33, 0x64, 0x64, 0x63, 0x34, 0x33, 0x66, 0x30, 0x38, 0x66, 0x31, 0x36, 0x64, 0x34, 0x35, 0x35, 0x31, 0x37, 0x38, 0x62, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x31, 0x64, 0x37, 0x61, 0x35, 0x66, 0x32, 0x34, 0x36, 0x38, 0x62, 0x39, 0x34, 0x65, 0x61, 0x38, 0x32, 0x36, 0x39, 0x38, 0x32, 0x64, 0x62, 0x66, 0x32, 0x31, 0x32, 0x35, 0x37, 0x39, 0x33, 0x63, 0x36, 0x65, 0x34, 0x61, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x34, 0x33, 0x66, 0x64, 0x64, 0x30, 0x62, 0x63, 0x34, 0x63, 0x39, 0x37, 0x33, 0x64, 0x31, 0x36, 0x36, 0x33, 0x64, 0x35, 0x35, 0x66, 0x63, 0x31, 0x33, 0x35, 0x35, 0x30, 0x38, 0x65, 0x63, 0x35, 0x64, 0x34, 0x66, 0x34, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x63, 0x61, 0x31, 0x64, 0x61, 0x36, 0x63, 0x38, 0x30, 0x61, 0x36, 0x36, 0x62, 0x61, 0x61, 0x35, 0x64, 0x62, 0x35, 0x61, 0x63, 0x39, 0x38, 0x35, 0x34, 0x31, 0x63, 0x34, 0x62, 0x65, 0x32, 0x37, 0x36, 0x62, 0x34, 0x34, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x35, 0x35, 0x30, 0x62, 0x65, 0x62, 0x37, 0x33, 0x32, 0x62, 0x61, 0x39, 0x64, 0x64, 0x61, 0x66, 0x64, 0x61, 0x37, 0x61, 0x65, 0x34, 0x30, 0x36, 0x65, 0x31, 0x38, 0x66, 0x37, 0x66, 0x65, 0x62, 0x30, 0x66, 0x38, 0x62, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x63, 0x31, 0x39, 0x65, 0x63, 0x38, 0x33, 0x35, 0x61, 0x66, 0x65, 0x33, 0x65, 0x35, 0x38, 0x64, 0x38, 0x37, 0x64, 0x63, 0x39, 0x33, 0x61, 0x38, 0x61, 0x39, 0x32, 0x31, 0x33, 0x63, 0x39, 0x30, 0x34, 0x35, 0x31, 0x33, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x31, 0x64, 0x37, 0x39, 0x38, 0x61, 0x66, 0x31, 0x39, 0x39, 0x38, 0x39, 0x63, 0x33, 0x61, 0x65, 0x35, 0x62, 0x38, 0x34, 0x61, 0x37, 0x61, 0x37, 0x32, 0x38, 0x33, 0x63, 0x64, 0x37, 0x66, 0x64, 0x61, 0x31, 0x66, 0x61, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x34, 0x65, 0x36, 0x66, 0x31, 0x33, 0x66, 0x62, 0x35, 0x65, 0x33, 0x66, 0x37, 0x30, 0x63, 0x33, 0x37, 0x36, 0x30, 0x32, 0x36, 0x32, 0x61, 0x30, 0x33, 0x65, 0x33, 0x31, 0x37, 0x39, 0x38, 0x32, 0x36, 0x39, 0x31, 0x64, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x34, 0x65, 0x34, 0x33, 0x31, 0x31, 0x39, 0x38, 0x37, 0x30, 0x61, 0x66, 0x31, 0x30, 0x37, 0x61, 0x34, 0x34, 0x38, 0x64, 0x62, 0x31, 0x32, 0x37, 0x38, 0x62, 0x30, 0x34, 0x34, 0x38, 0x33, 0x38, 0x66, 0x66, 0x63, 0x64, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x61, 0x31, 0x31, 0x37, 0x38, 0x66, 0x35, 0x35, 0x64, 0x39, 0x37, 0x37, 0x37, 0x32, 0x62, 0x62, 0x31, 0x64, 0x32, 0x34, 0x31, 0x31, 0x31, 0x61, 0x34, 0x30, 0x34, 0x61, 0x34, 0x66, 0x38, 0x37, 0x31, 0x35, 0x62, 0x39, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x38, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x36, 0x65, 0x39, 0x37, 0x34, 0x37, 0x65, 0x31, 0x36, 0x32, 0x66, 0x38, 0x62, 0x34, 0x35, 0x63, 0x36, 0x35, 0x36, 0x65, 0x30, 0x66, 0x36, 0x63, 0x61, 0x65, 0x37, 0x61, 0x38, 0x34, 0x62, 0x61, 0x63, 0x38, 0x30, 0x65, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x65, 0x61, 0x63, 0x33, 0x31, 0x61, 0x62, 0x63, 0x65, 0x36, 0x64, 0x35, 0x66, 0x31, 0x64, 0x65, 0x61, 0x34, 0x32, 0x32, 0x30, 0x32, 0x62, 0x36, 0x61, 0x36, 0x37, 0x34, 0x31, 0x35, 0x33, 0x64, 0x62, 0x34, 0x37, 0x61, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x36, 0x37, 0x31, 0x31, 0x35, 0x34, 0x30, 0x65, 0x32, 0x65, 0x39, 0x39, 0x38, 0x33, 0x34, 0x33, 0x64, 0x34, 0x66, 0x35, 0x39, 0x30, 0x62, 0x36, 0x66, 0x63, 0x38, 0x66, 0x61, 0x63, 0x33, 0x62, 0x62, 0x38, 0x62, 0x33, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x35, 0x38, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x61, 0x34, 0x65, 0x63, 0x34, 0x30, 0x37, 0x30, 0x37, 0x37, 0x66, 0x34, 0x62, 0x39, 0x37, 0x30, 0x37, 0x62, 0x32, 0x64, 0x39, 0x64, 0x32, 0x65, 0x64, 0x65, 0x35, 0x65, 0x61, 0x35, 0x32, 0x38, 0x32, 0x62, 0x66, 0x31, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x30, 0x63, 0x31, 0x62, 0x34, 0x35, 0x66, 0x31, 0x36, 0x34, 0x62, 0x39, 0x35, 0x38, 0x30, 0x65, 0x32, 0x30, 0x32, 0x37, 0x35, 0x61, 0x35, 0x63, 0x33, 0x39, 0x65, 0x31, 0x64, 0x37, 0x31, 0x65, 0x33, 0x35, 0x66, 0x38, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x36, 0x33, 0x39, 0x34, 0x61, 0x37, 0x62, 0x66, 0x61, 0x34, 0x64, 0x32, 0x38, 0x39, 0x31, 0x31, 0x64, 0x35, 0x61, 0x35, 0x62, 0x32, 0x33, 0x65, 0x39, 0x33, 0x66, 0x33, 0x35, 0x65, 0x33, 0x34, 0x30, 0x63, 0x32, 0x32, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x39, 0x61, 0x63, 0x39, 0x33, 0x62, 0x32, 0x33, 0x33, 0x37, 0x30, 0x34, 0x37, 0x32, 0x64, 0x61, 0x61, 0x63, 0x33, 0x33, 0x37, 0x65, 0x39, 0x61, 0x66, 0x64, 0x66, 0x36, 0x34, 0x32, 0x35, 0x34, 0x33, 0x66, 0x33, 0x65, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x36, 0x31, 0x38, 0x65, 0x32, 0x35, 0x32, 0x32, 0x31, 0x61, 0x64, 0x39, 0x61, 0x37, 0x34, 0x30, 0x62, 0x32, 0x39, 0x39, 0x65, 0x64, 0x31, 0x34, 0x30, 0x36, 0x62, 0x63, 0x33, 0x39, 0x33, 0x34, 0x62, 0x30, 0x62, 0x31, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x37, 0x61, 0x63, 0x33, 0x33, 0x62, 0x64, 0x38, 0x66, 0x38, 0x34, 0x37, 0x35, 0x36, 0x37, 0x33, 0x37, 0x32, 0x39, 0x35, 0x31, 0x66, 0x34, 0x61, 0x31, 0x30, 0x64, 0x37, 0x61, 0x39, 0x31, 0x63, 0x65, 0x33, 0x66, 0x34, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x36, 0x61, 0x38, 0x39, 0x35, 0x62, 0x37, 0x39, 0x35, 0x63, 0x62, 0x34, 0x62, 0x66, 0x38, 0x35, 0x39, 0x30, 0x33, 0x64, 0x33, 0x63, 0x65, 0x30, 0x39, 0x63, 0x35, 0x61, 0x61, 0x34, 0x33, 0x39, 0x35, 0x33, 0x64, 0x33, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x37, 0x33, 0x39, 0x35, 0x34, 0x33, 0x39, 0x39, 0x66, 0x36, 0x64, 0x66, 0x62, 0x65, 0x36, 0x37, 0x31, 0x38, 0x31, 0x38, 0x32, 0x35, 0x39, 0x62, 0x62, 0x32, 0x37, 0x38, 0x65, 0x32, 0x65, 0x39, 0x32, 0x65, 0x65, 0x33, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x30, 0x66, 0x66, 0x31, 0x66, 0x33, 0x64, 0x32, 0x37, 0x61, 0x38, 0x65, 0x63, 0x39, 0x66, 0x62, 0x38, 0x66, 0x36, 0x62, 0x30, 0x63, 0x62, 0x32, 0x35, 0x34, 0x61, 0x36, 0x33, 0x62, 0x62, 0x61, 0x38, 0x32, 0x32, 0x34, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x36, 0x37, 0x36, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x31, 0x32, 0x65, 0x34, 0x39, 0x64, 0x38, 0x65, 0x30, 0x36, 0x61, 0x61, 0x32, 0x30, 0x66, 0x38, 0x38, 0x36, 0x32, 0x39, 0x33, 0x63, 0x30, 0x62, 0x39, 0x38, 0x65, 0x64, 0x37, 0x65, 0x66, 0x66, 0x37, 0x38, 0x38, 0x38, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x65, 0x66, 0x31, 0x36, 0x61, 0x32, 0x32, 0x36, 0x64, 0x64, 0x36, 0x38, 0x30, 0x37, 0x31, 0x66, 0x32, 0x34, 0x38, 0x33, 0x65, 0x31, 0x64, 0x61, 0x34, 0x32, 0x35, 0x39, 0x38, 0x33, 0x31, 0x39, 0x66, 0x36, 0x39, 0x62, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x36, 0x36, 0x61, 0x62, 0x31, 0x63, 0x36, 0x62, 0x30, 0x32, 0x31, 0x36, 0x32, 0x33, 0x30, 0x62, 0x39, 0x33, 0x39, 0x35, 0x34, 0x34, 0x33, 0x64, 0x35, 0x66, 0x61, 0x37, 0x35, 0x65, 0x36, 0x38, 0x34, 0x35, 0x36, 0x38, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x61, 0x37, 0x33, 0x35, 0x32, 0x30, 0x36, 0x36, 0x33, 0x36, 0x34, 0x34, 0x30, 0x34, 0x64, 0x62, 0x35, 0x30, 0x66, 0x30, 0x64, 0x30, 0x64, 0x37, 0x38, 0x64, 0x37, 0x35, 0x34, 0x61, 0x32, 0x32, 0x31, 0x39, 0x38, 0x65, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x34, 0x63, 0x61, 0x66, 0x37, 0x39, 0x62, 0x37, 0x31, 0x33, 0x33, 0x38, 0x65, 0x65, 0x39, 0x61, 0x61, 0x37, 0x63, 0x37, 0x33, 0x33, 0x62, 0x30, 0x32, 0x61, 0x63, 0x61, 0x61, 0x37, 0x64, 0x63, 0x30, 0x32, 0x35, 0x39, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x65, 0x32, 0x64, 0x65, 0x32, 0x31, 0x32, 0x30, 0x30, 0x62, 0x31, 0x38, 0x39, 0x39, 0x63, 0x33, 0x61, 0x30, 0x63, 0x30, 0x36, 0x35, 0x33, 0x62, 0x35, 0x30, 0x34, 0x30, 0x31, 0x33, 0x36, 0x64, 0x30, 0x64, 0x63, 0x38, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x65, 0x31, 0x35, 0x36, 0x36, 0x31, 0x30, 0x63, 0x64, 0x38, 0x66, 0x66, 0x36, 0x34, 0x65, 0x37, 0x38, 0x30, 0x64, 0x38, 0x39, 0x64, 0x30, 0x30, 0x35, 0x34, 0x33, 0x38, 0x35, 0x63, 0x61, 0x37, 0x36, 0x37, 0x35, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x36, 0x65, 0x62, 0x65, 0x37, 0x32, 0x33, 0x62, 0x36, 0x65, 0x64, 0x31, 0x66, 0x39, 0x61, 0x38, 0x36, 0x61, 0x36, 0x39, 0x64, 0x64, 0x64, 0x61, 0x36, 0x38, 0x64, 0x63, 0x34, 0x37, 0x34, 0x36, 0x35, 0x63, 0x32, 0x62, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x62, 0x66, 0x32, 0x61, 0x31, 0x66, 0x37, 0x61, 0x36, 0x39, 0x64, 0x65, 0x30, 0x65, 0x32, 0x35, 0x34, 0x36, 0x61, 0x64, 0x62, 0x38, 0x30, 0x38, 0x62, 0x33, 0x36, 0x33, 0x33, 0x35, 0x36, 0x34, 0x35, 0x64, 0x61, 0x39, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x66, 0x34, 0x34, 0x36, 0x36, 0x33, 0x64, 0x39, 0x32, 0x35, 0x36, 0x31, 0x30, 0x39, 0x31, 0x62, 0x38, 0x32, 0x61, 0x37, 0x30, 0x64, 0x63, 0x66, 0x35, 0x39, 0x33, 0x64, 0x37, 0x35, 0x34, 0x30, 0x30, 0x35, 0x39, 0x37, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x62, 0x39, 0x65, 0x36, 0x36, 0x34, 0x34, 0x66, 0x36, 0x62, 0x61, 0x34, 0x63, 0x64, 0x65, 0x31, 0x32, 0x36, 0x32, 0x37, 0x30, 0x64, 0x38, 0x31, 0x66, 0x36, 0x61, 0x62, 0x36, 0x30, 0x66, 0x32, 0x38, 0x36, 0x64, 0x66, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x35, 0x39, 0x65, 0x62, 0x32, 0x31, 0x33, 0x62, 0x31, 0x65, 0x37, 0x35, 0x36, 0x35, 0x65, 0x34, 0x35, 0x30, 0x34, 0x37, 0x65, 0x30, 0x34, 0x65, 0x61, 0x30, 0x33, 0x37, 0x34, 0x66, 0x31, 0x30, 0x37, 0x36, 0x32, 0x64, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x39, 0x35, 0x34, 0x34, 0x62, 0x36, 0x32, 0x33, 0x32, 0x63, 0x33, 0x64, 0x64, 0x37, 0x33, 0x37, 0x66, 0x39, 0x34, 0x35, 0x61, 0x30, 0x33, 0x31, 0x39, 0x33, 0x64, 0x31, 0x39, 0x62, 0x35, 0x66, 0x33, 0x66, 0x36, 0x35, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x37, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x38, 0x62, 0x62, 0x33, 0x39, 0x66, 0x33, 0x34, 0x36, 0x36, 0x35, 0x31, 0x37, 0x63, 0x64, 0x34, 0x36, 0x66, 0x39, 0x37, 0x39, 0x63, 0x66, 0x35, 0x39, 0x36, 0x35, 0x33, 0x65, 0x65, 0x37, 0x64, 0x38, 0x66, 0x31, 0x35, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x61, 0x38, 0x65, 0x32, 0x32, 0x63, 0x61, 0x31, 0x30, 0x65, 0x36, 0x37, 0x66, 0x65, 0x61, 0x34, 0x34, 0x65, 0x35, 0x32, 0x35, 0x65, 0x34, 0x37, 0x35, 0x31, 0x65, 0x65, 0x61, 0x63, 0x33, 0x36, 0x61, 0x33, 0x31, 0x31, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x38, 0x61, 0x65, 0x38, 0x30, 0x32, 0x33, 0x38, 0x65, 0x36, 0x30, 0x30, 0x30, 0x38, 0x35, 0x35, 0x37, 0x30, 0x37, 0x35, 0x61, 0x62, 0x36, 0x61, 0x66, 0x65, 0x30, 0x61, 0x37, 0x66, 0x32, 0x65, 0x37, 0x34, 0x64, 0x37, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x65, 0x64, 0x33, 0x33, 0x61, 0x63, 0x66, 0x34, 0x33, 0x66, 0x33, 0x35, 0x62, 0x39, 0x38, 0x63, 0x39, 0x32, 0x33, 0x30, 0x62, 0x39, 0x65, 0x36, 0x36, 0x34, 0x32, 0x65, 0x63, 0x62, 0x35, 0x33, 0x33, 0x30, 0x38, 0x33, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x31, 0x38, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x38, 0x34, 0x32, 0x61, 0x62, 0x38, 0x33, 0x30, 0x64, 0x61, 0x35, 0x30, 0x39, 0x39, 0x31, 0x33, 0x66, 0x38, 0x31, 0x64, 0x64, 0x31, 0x66, 0x30, 0x34, 0x66, 0x31, 0x30, 0x61, 0x66, 0x39, 0x65, 0x64, 0x64, 0x31, 0x63, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x66, 0x33, 0x37, 0x66, 0x30, 0x61, 0x62, 0x33, 0x61, 0x31, 0x64, 0x34, 0x34, 0x38, 0x61, 0x39, 0x65, 0x33, 0x63, 0x65, 0x34, 0x30, 0x39, 0x36, 0x35, 0x66, 0x39, 0x37, 0x61, 0x36, 0x34, 0x36, 0x30, 0x38, 0x33, 0x61, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x32, 0x62, 0x37, 0x30, 0x36, 0x36, 0x39, 0x63, 0x39, 0x37, 0x61, 0x61, 0x62, 0x37, 0x64, 0x36, 0x38, 0x31, 0x34, 0x38, 0x64, 0x38, 0x64, 0x34, 0x65, 0x39, 0x30, 0x34, 0x31, 0x31, 0x65, 0x32, 0x38, 0x31, 0x30, 0x64, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x65, 0x35, 0x35, 0x31, 0x30, 0x30, 0x66, 0x62, 0x64, 0x31, 0x39, 0x35, 0x36, 0x62, 0x62, 0x65, 0x64, 0x32, 0x63, 0x61, 0x35, 0x31, 0x38, 0x64, 0x34, 0x62, 0x31, 0x66, 0x61, 0x33, 0x37, 0x36, 0x30, 0x33, 0x32, 0x62, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x63, 0x63, 0x36, 0x62, 0x31, 0x61, 0x63, 0x63, 0x33, 0x32, 0x64, 0x38, 0x62, 0x32, 0x39, 0x35, 0x64, 0x66, 0x36, 0x38, 0x65, 0x64, 0x39, 0x64, 0x35, 0x65, 0x36, 0x30, 0x62, 0x38, 0x66, 0x36, 0x34, 0x63, 0x62, 0x36, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x38, 0x31, 0x63, 0x61, 0x31, 0x66, 0x34, 0x38, 0x38, 0x32, 0x64, 0x62, 0x36, 0x30, 0x34, 0x33, 0x64, 0x35, 0x61, 0x39, 0x31, 0x39, 0x30, 0x37, 0x30, 0x33, 0x66, 0x64, 0x65, 0x30, 0x61, 0x62, 0x33, 0x62, 0x66, 0x35, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x32, 0x30, 0x37, 0x37, 0x34, 0x34, 0x39, 0x61, 0x31, 0x33, 0x34, 0x61, 0x37, 0x61, 0x64, 0x31, 0x65, 0x66, 0x37, 0x65, 0x34, 0x64, 0x39, 0x32, 0x37, 0x61, 0x66, 0x66, 0x65, 0x63, 0x65, 0x65, 0x61, 0x64, 0x62, 0x35, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x39, 0x66, 0x65, 0x61, 0x37, 0x35, 0x35, 0x61, 0x65, 0x65, 0x31, 0x61, 0x34, 0x34, 0x63, 0x30, 0x61, 0x38, 0x39, 0x66, 0x30, 0x33, 0x62, 0x35, 0x64, 0x65, 0x62, 0x37, 0x36, 0x32, 0x62, 0x61, 0x33, 0x33, 0x30, 0x30, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x37, 0x31, 0x37, 0x37, 0x33, 0x31, 0x64, 0x61, 0x64, 0x36, 0x35, 0x31, 0x33, 0x32, 0x64, 0x61, 0x37, 0x39, 0x32, 0x64, 0x38, 0x37, 0x36, 0x30, 0x33, 0x30, 0x65, 0x34, 0x36, 0x61, 0x63, 0x32, 0x32, 0x37, 0x62, 0x62, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x37, 0x65, 0x62, 0x33, 0x64, 0x33, 0x31, 0x31, 0x33, 0x62, 0x64, 0x33, 0x62, 0x35, 0x39, 0x37, 0x37, 0x31, 0x34, 0x64, 0x33, 0x61, 0x39, 0x35, 0x34, 0x65, 0x64, 0x64, 0x30, 0x31, 0x38, 0x39, 0x38, 0x32, 0x61, 0x35, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x35, 0x37, 0x33, 0x34, 0x35, 0x62, 0x33, 0x38, 0x65, 0x30, 0x66, 0x30, 0x36, 0x37, 0x63, 0x39, 0x61, 0x33, 0x31, 0x64, 0x39, 0x64, 0x65, 0x61, 0x63, 0x35, 0x32, 0x37, 0x35, 0x61, 0x31, 0x30, 0x39, 0x34, 0x39, 0x33, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x65, 0x61, 0x35, 0x30, 0x34, 0x34, 0x62, 0x32, 0x30, 0x34, 0x62, 0x32, 0x33, 0x30, 0x37, 0x36, 0x62, 0x31, 0x61, 0x35, 0x38, 0x30, 0x33, 0x62, 0x66, 0x31, 0x64, 0x33, 0x30, 0x63, 0x30, 0x66, 0x38, 0x38, 0x38, 0x37, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x61, 0x62, 0x30, 0x66, 0x62, 0x65, 0x32, 0x38, 0x64, 0x35, 0x38, 0x34, 0x32, 0x30, 0x62, 0x35, 0x32, 0x30, 0x33, 0x36, 0x37, 0x37, 0x30, 0x61, 0x31, 0x32, 0x66, 0x39, 0x39, 0x35, 0x32, 0x61, 0x65, 0x61, 0x36, 0x39, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x61, 0x61, 0x30, 0x65, 0x35, 0x34, 0x38, 0x63, 0x30, 0x33, 0x35, 0x61, 0x66, 0x66, 0x65, 0x64, 0x36, 0x34, 0x63, 0x61, 0x36, 0x37, 0x38, 0x61, 0x39, 0x36, 0x33, 0x66, 0x61, 0x62, 0x65, 0x39, 0x61, 0x32, 0x36, 0x62, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x34, 0x38, 0x65, 0x61, 0x66, 0x35, 0x31, 0x36, 0x63, 0x65, 0x32, 0x64, 0x65, 0x63, 0x33, 0x65, 0x34, 0x31, 0x66, 0x65, 0x62, 0x34, 0x63, 0x36, 0x37, 0x39, 0x65, 0x34, 0x39, 0x35, 0x37, 0x36, 0x34, 0x31, 0x31, 0x36, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x39, 0x33, 0x62, 0x64, 0x65, 0x62, 0x36, 0x66, 0x63, 0x38, 0x32, 0x62, 0x35, 0x62, 0x63, 0x61, 0x37, 0x32, 0x31, 0x33, 0x35, 0x35, 0x32, 0x32, 0x33, 0x31, 0x37, 0x35, 0x64, 0x34, 0x37, 0x61, 0x30, 0x38, 0x34, 0x62, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x63, 0x62, 0x39, 0x38, 0x64, 0x37, 0x61, 0x63, 0x64, 0x38, 0x31, 0x37, 0x64, 0x65, 0x39, 0x64, 0x38, 0x38, 0x36, 0x64, 0x32, 0x32, 0x66, 0x61, 0x62, 0x33, 0x66, 0x31, 0x62, 0x35, 0x37, 0x64, 0x39, 0x32, 0x61, 0x36, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x38, 0x39, 0x30, 0x30, 0x64, 0x62, 0x37, 0x33, 0x37, 0x39, 0x35, 0x35, 0x62, 0x31, 0x35, 0x31, 0x39, 0x62, 0x31, 0x61, 0x37, 0x64, 0x31, 0x37, 0x30, 0x61, 0x31, 0x38, 0x38, 0x36, 0x34, 0x63, 0x65, 0x35, 0x39, 0x30, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x37, 0x66, 0x61, 0x35, 0x35, 0x34, 0x34, 0x36, 0x63, 0x34, 0x36, 0x30, 0x39, 0x36, 0x38, 0x62, 0x62, 0x37, 0x34, 0x62, 0x35, 0x65, 0x62, 0x63, 0x61, 0x39, 0x36, 0x63, 0x34, 0x65, 0x66, 0x32, 0x63, 0x37, 0x30, 0x39, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x38, 0x35, 0x35, 0x64, 0x35, 0x33, 0x34, 0x37, 0x37, 0x66, 0x35, 0x30, 0x35, 0x65, 0x63, 0x34, 0x63, 0x38, 0x64, 0x35, 0x65, 0x38, 0x62, 0x62, 0x39, 0x31, 0x38, 0x30, 0x64, 0x33, 0x38, 0x36, 0x38, 0x31, 0x31, 0x31, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x31, 0x61, 0x65, 0x61, 0x32, 0x35, 0x30, 0x62, 0x38, 0x37, 0x37, 0x64, 0x34, 0x32, 0x33, 0x61, 0x36, 0x33, 0x62, 0x61, 0x32, 0x62, 0x63, 0x65, 0x32, 0x66, 0x33, 0x61, 0x36, 0x31, 0x63, 0x30, 0x32, 0x34, 0x38, 0x64, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x36, 0x32, 0x31, 0x36, 0x39, 0x62, 0x36, 0x31, 0x35, 0x38, 0x37, 0x30, 0x31, 0x33, 0x34, 0x65, 0x62, 0x34, 0x61, 0x63, 0x36, 0x63, 0x35, 0x66, 0x34, 0x37, 0x31, 0x63, 0x36, 0x62, 0x66, 0x32, 0x66, 0x37, 0x38, 0x39, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x62, 0x30, 0x63, 0x31, 0x30, 0x30, 0x63, 0x34, 0x39, 0x31, 0x34, 0x39, 0x39, 0x33, 0x35, 0x64, 0x31, 0x34, 0x63, 0x30, 0x64, 0x63, 0x32, 0x30, 0x32, 0x63, 0x63, 0x65, 0x39, 0x30, 0x37, 0x63, 0x65, 0x61, 0x31, 0x61, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x34, 0x63, 0x30, 0x63, 0x34, 0x36, 0x39, 0x63, 0x32, 0x34, 0x36, 0x62, 0x38, 0x33, 0x62, 0x35, 0x64, 0x31, 0x62, 0x33, 0x65, 0x63, 0x61, 0x34, 0x34, 0x33, 0x62, 0x33, 0x39, 0x61, 0x66, 0x35, 0x65, 0x65, 0x31, 0x32, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x36, 0x38, 0x31, 0x30, 0x36, 0x39, 0x31, 0x64, 0x31, 0x61, 0x65, 0x30, 0x64, 0x31, 0x39, 0x65, 0x34, 0x37, 0x62, 0x64, 0x32, 0x32, 0x63, 0x65, 0x62, 0x65, 0x65, 0x30, 0x62, 0x33, 0x62, 0x61, 0x32, 0x37, 0x66, 0x38, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x39, 0x39, 0x39, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x64, 0x63, 0x63, 0x32, 0x34, 0x62, 0x64, 0x39, 0x63, 0x37, 0x32, 0x31, 0x30, 0x63, 0x65, 0x61, 0x63, 0x66, 0x62, 0x33, 0x30, 0x64, 0x61, 0x39, 0x38, 0x61, 0x65, 0x30, 0x34, 0x61, 0x34, 0x64, 0x37, 0x62, 0x38, 0x61, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x31, 0x62, 0x34, 0x65, 0x65, 0x66, 0x31, 0x38, 0x34, 0x63, 0x32, 0x34, 0x61, 0x62, 0x30, 0x39, 0x38, 0x65, 0x33, 0x36, 0x63, 0x38, 0x30, 0x32, 0x37, 0x31, 0x34, 0x62, 0x64, 0x34, 0x37, 0x34, 0x33, 0x64, 0x64, 0x30, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x62, 0x38, 0x63, 0x38, 0x32, 0x34, 0x38, 0x36, 0x39, 0x64, 0x65, 0x39, 0x65, 0x64, 0x32, 0x34, 0x66, 0x33, 0x62, 0x66, 0x66, 0x36, 0x38, 0x35, 0x34, 0x63, 0x62, 0x36, 0x64, 0x64, 0x34, 0x35, 0x63, 0x63, 0x33, 0x66, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x65, 0x37, 0x33, 0x61, 0x37, 0x39, 0x61, 0x65, 0x61, 0x30, 0x32, 0x37, 0x38, 0x35, 0x33, 0x33, 0x61, 0x63, 0x63, 0x66, 0x32, 0x31, 0x30, 0x37, 0x30, 0x39, 0x32, 0x32, 0x62, 0x31, 0x36, 0x31, 0x33, 0x66, 0x38, 0x66, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x39, 0x37, 0x34, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x62, 0x64, 0x32, 0x62, 0x39, 0x33, 0x32, 0x63, 0x37, 0x36, 0x33, 0x62, 0x61, 0x35, 0x62, 0x31, 0x62, 0x37, 0x61, 0x65, 0x33, 0x62, 0x33, 0x36, 0x32, 0x65, 0x61, 0x63, 0x33, 0x65, 0x38, 0x64, 0x34, 0x30, 0x31, 0x32, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x34, 0x62, 0x62, 0x63, 0x62, 0x31, 0x38, 0x31, 0x36, 0x35, 0x32, 0x31, 0x31, 0x62, 0x32, 0x36, 0x35, 0x62, 0x32, 0x38, 0x30, 0x37, 0x31, 0x36, 0x63, 0x62, 0x33, 0x66, 0x31, 0x66, 0x32, 0x31, 0x32, 0x31, 0x37, 0x36, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x32, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x37, 0x37, 0x65, 0x30, 0x63, 0x32, 0x30, 0x31, 0x64, 0x33, 0x33, 0x35, 0x62, 0x61, 0x33, 0x39, 0x35, 0x36, 0x39, 0x32, 0x39, 0x63, 0x35, 0x37, 0x31, 0x35, 0x38, 0x38, 0x62, 0x35, 0x31, 0x63, 0x35, 0x32, 0x32, 0x33, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x34, 0x35, 0x66, 0x65, 0x33, 0x37, 0x37, 0x66, 0x65, 0x36, 0x64, 0x34, 0x62, 0x37, 0x31, 0x65, 0x33, 0x65, 0x37, 0x39, 0x31, 0x66, 0x36, 0x66, 0x31, 0x37, 0x64, 0x62, 0x32, 0x34, 0x33, 0x63, 0x39, 0x62, 0x38, 0x62, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x38, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x39, 0x62, 0x33, 0x34, 0x61, 0x35, 0x37, 0x66, 0x33, 0x33, 0x37, 0x35, 0x61, 0x65, 0x35, 0x39, 0x63, 0x30, 0x61, 0x37, 0x35, 0x65, 0x31, 0x39, 0x63, 0x34, 0x62, 0x36, 0x34, 0x31, 0x32, 0x32, 0x38, 0x64, 0x39, 0x37, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x64, 0x36, 0x63, 0x38, 0x32, 0x65, 0x64, 0x64, 0x61, 0x65, 0x35, 0x39, 0x34, 0x37, 0x66, 0x62, 0x65, 0x39, 0x63, 0x64, 0x66, 0x62, 0x64, 0x35, 0x34, 0x38, 0x61, 0x65, 0x33, 0x33, 0x64, 0x39, 0x31, 0x61, 0x37, 0x31, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x64, 0x34, 0x34, 0x32, 0x35, 0x65, 0x31, 0x37, 0x31, 0x63, 0x33, 0x65, 0x37, 0x32, 0x39, 0x37, 0x35, 0x65, 0x62, 0x34, 0x36, 0x61, 0x63, 0x30, 0x61, 0x30, 0x31, 0x35, 0x64, 0x62, 0x33, 0x31, 0x35, 0x61, 0x35, 0x64, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x64, 0x32, 0x61, 0x61, 0x36, 0x32, 0x36, 0x62, 0x30, 0x39, 0x64, 0x36, 0x64, 0x34, 0x65, 0x34, 0x62, 0x31, 0x33, 0x66, 0x37, 0x66, 0x66, 0x63, 0x35, 0x61, 0x38, 0x38, 0x62, 0x64, 0x37, 0x61, 0x64, 0x33, 0x36, 0x37, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x33, 0x39, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x31, 0x63, 0x33, 0x34, 0x66, 0x63, 0x61, 0x63, 0x64, 0x61, 0x37, 0x30, 0x31, 0x61, 0x35, 0x61, 0x61, 0x38, 0x37, 0x30, 0x32, 0x34, 0x35, 0x39, 0x64, 0x65, 0x62, 0x30, 0x65, 0x34, 0x61, 0x65, 0x38, 0x33, 0x38, 0x64, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x35, 0x65, 0x30, 0x36, 0x30, 0x30, 0x65, 0x32, 0x61, 0x39, 0x32, 0x37, 0x62, 0x32, 0x64, 0x64, 0x38, 0x64, 0x33, 0x37, 0x39, 0x33, 0x35, 0x36, 0x62, 0x34, 0x35, 0x61, 0x32, 0x65, 0x37, 0x64, 0x35, 0x31, 0x64, 0x33, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x35, 0x38, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x66, 0x33, 0x33, 0x39, 0x32, 0x31, 0x34, 0x62, 0x36, 0x61, 0x64, 0x31, 0x62, 0x32, 0x34, 0x36, 0x36, 0x33, 0x63, 0x65, 0x37, 0x31, 0x36, 0x30, 0x33, 0x34, 0x37, 0x34, 0x39, 0x64, 0x36, 0x65, 0x66, 0x38, 0x33, 0x38, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x64, 0x39, 0x61, 0x35, 0x63, 0x33, 0x33, 0x61, 0x37, 0x64, 0x39, 0x65, 0x64, 0x63, 0x65, 0x30, 0x39, 0x39, 0x37, 0x62, 0x64, 0x66, 0x37, 0x37, 0x61, 0x62, 0x33, 0x30, 0x36, 0x34, 0x32, 0x34, 0x61, 0x31, 0x31, 0x65, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x37, 0x64, 0x61, 0x31, 0x32, 0x63, 0x66, 0x63, 0x31, 0x66, 0x37, 0x63, 0x31, 0x61, 0x32, 0x34, 0x36, 0x34, 0x64, 0x65, 0x66, 0x30, 0x38, 0x63, 0x32, 0x39, 0x62, 0x65, 0x64, 0x35, 0x65, 0x32, 0x66, 0x38, 0x35, 0x31, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x62, 0x66, 0x31, 0x33, 0x63, 0x33, 0x63, 0x38, 0x65, 0x61, 0x34, 0x65, 0x33, 0x64, 0x37, 0x33, 0x64, 0x37, 0x38, 0x65, 0x63, 0x37, 0x31, 0x37, 0x61, 0x66, 0x61, 0x66, 0x61, 0x34, 0x33, 0x30, 0x65, 0x35, 0x34, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x65, 0x65, 0x62, 0x30, 0x37, 0x62, 0x64, 0x32, 0x62, 0x37, 0x38, 0x39, 0x30, 0x31, 0x39, 0x35, 0x65, 0x37, 0x64, 0x34, 0x36, 0x62, 0x64, 0x66, 0x32, 0x30, 0x37, 0x31, 0x62, 0x36, 0x36, 0x31, 0x37, 0x35, 0x31, 0x34, 0x64, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x39, 0x61, 0x66, 0x39, 0x61, 0x31, 0x63, 0x32, 0x37, 0x33, 0x33, 0x32, 0x62, 0x31, 0x63, 0x33, 0x36, 0x39, 0x62, 0x62, 0x64, 0x61, 0x31, 0x62, 0x33, 0x64, 0x65, 0x31, 0x63, 0x36, 0x65, 0x39, 0x33, 0x33, 0x64, 0x36, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x34, 0x33, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x64, 0x32, 0x63, 0x36, 0x66, 0x63, 0x61, 0x38, 0x61, 0x64, 0x31, 0x66, 0x37, 0x35, 0x33, 0x39, 0x35, 0x32, 0x31, 0x30, 0x62, 0x35, 0x37, 0x64, 0x65, 0x35, 0x64, 0x66, 0x64, 0x36, 0x37, 0x33, 0x39, 0x33, 0x33, 0x39, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x64, 0x35, 0x64, 0x38, 0x38, 0x31, 0x61, 0x37, 0x33, 0x36, 0x32, 0x63, 0x39, 0x30, 0x37, 0x30, 0x30, 0x37, 0x33, 0x62, 0x64, 0x66, 0x62, 0x63, 0x37, 0x35, 0x65, 0x37, 0x32, 0x34, 0x35, 0x33, 0x61, 0x63, 0x35, 0x31, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x61, 0x63, 0x33, 0x36, 0x33, 0x37, 0x36, 0x65, 0x66, 0x61, 0x30, 0x36, 0x31, 0x30, 0x39, 0x64, 0x34, 0x30, 0x37, 0x32, 0x36, 0x33, 0x30, 0x37, 0x64, 0x64, 0x31, 0x61, 0x35, 0x37, 0x65, 0x32, 0x31, 0x33, 0x65, 0x61, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x65, 0x61, 0x34, 0x64, 0x66, 0x35, 0x31, 0x32, 0x32, 0x66, 0x61, 0x66, 0x64, 0x65, 0x62, 0x33, 0x36, 0x30, 0x37, 0x65, 0x64, 0x64, 0x64, 0x61, 0x31, 0x65, 0x61, 0x34, 0x66, 0x66, 0x64, 0x62, 0x39, 0x61, 0x62, 0x66, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x35, 0x65, 0x39, 0x33, 0x66, 0x62, 0x34, 0x63, 0x39, 0x63, 0x39, 0x64, 0x31, 0x32, 0x34, 0x36, 0x66, 0x38, 0x66, 0x32, 0x34, 0x37, 0x33, 0x35, 0x38, 0x65, 0x32, 0x32, 0x63, 0x33, 0x63, 0x35, 0x64, 0x31, 0x37, 0x62, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x31, 0x64, 0x64, 0x64, 0x33, 0x33, 0x63, 0x38, 0x31, 0x39, 0x36, 0x36, 0x64, 0x63, 0x38, 0x36, 0x32, 0x31, 0x37, 0x37, 0x36, 0x30, 0x37, 0x31, 0x61, 0x34, 0x31, 0x32, 0x39, 0x34, 0x38, 0x32, 0x66, 0x32, 0x63, 0x36, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x63, 0x62, 0x36, 0x36, 0x34, 0x39, 0x34, 0x64, 0x30, 0x61, 0x66, 0x36, 0x38, 0x39, 0x61, 0x62, 0x66, 0x39, 0x34, 0x38, 0x33, 0x64, 0x33, 0x36, 0x35, 0x64, 0x37, 0x38, 0x32, 0x34, 0x34, 0x34, 0x65, 0x37, 0x64, 0x65, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x35, 0x37, 0x31, 0x61, 0x32, 0x62, 0x38, 0x66, 0x38, 0x31, 0x63, 0x36, 0x62, 0x63, 0x66, 0x36, 0x36, 0x61, 0x62, 0x33, 0x61, 0x31, 0x30, 0x30, 0x38, 0x33, 0x32, 0x39, 0x35, 0x36, 0x31, 0x37, 0x31, 0x35, 0x30, 0x30, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x61, 0x63, 0x36, 0x36, 0x34, 0x65, 0x65, 0x38, 0x65, 0x30, 0x37, 0x39, 0x35, 0x65, 0x34, 0x32, 0x37, 0x35, 0x63, 0x62, 0x38, 0x35, 0x32, 0x62, 0x63, 0x62, 0x61, 0x36, 0x61, 0x34, 0x37, 0x39, 0x61, 0x64, 0x39, 0x63, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x38, 0x30, 0x33, 0x62, 0x62, 0x34, 0x30, 0x37, 0x63, 0x37, 0x36, 0x32, 0x66, 0x39, 0x30, 0x62, 0x37, 0x35, 0x39, 0x36, 0x65, 0x36, 0x66, 0x64, 0x65, 0x31, 0x39, 0x34, 0x39, 0x33, 0x31, 0x65, 0x37, 0x36, 0x39, 0x35, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x35, 0x30, 0x37, 0x65, 0x39, 0x65, 0x38, 0x31, 0x31, 0x39, 0x63, 0x62, 0x63, 0x65, 0x64, 0x61, 0x38, 0x61, 0x62, 0x30, 0x38, 0x37, 0x65, 0x37, 0x65, 0x63, 0x62, 0x30, 0x37, 0x31, 0x33, 0x38, 0x33, 0x64, 0x36, 0x39, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x37, 0x32, 0x37, 0x33, 0x34, 0x61, 0x66, 0x63, 0x63, 0x32, 0x32, 0x34, 0x65, 0x32, 0x65, 0x36, 0x30, 0x39, 0x66, 0x63, 0x35, 0x31, 0x64, 0x34, 0x66, 0x30, 0x35, 0x39, 0x37, 0x33, 0x32, 0x37, 0x34, 0x34, 0x63, 0x39, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x62, 0x62, 0x65, 0x62, 0x63, 0x66, 0x62, 0x65, 0x32, 0x33, 0x35, 0x65, 0x35, 0x37, 0x64, 0x64, 0x32, 0x33, 0x30, 0x36, 0x61, 0x64, 0x31, 0x61, 0x39, 0x65, 0x63, 0x35, 0x38, 0x31, 0x63, 0x37, 0x66, 0x39, 0x66, 0x34, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x38, 0x31, 0x34, 0x31, 0x30, 0x65, 0x61, 0x38, 0x33, 0x35, 0x34, 0x63, 0x63, 0x35, 0x63, 0x36, 0x35, 0x63, 0x34, 0x31, 0x62, 0x65, 0x38, 0x62, 0x64, 0x35, 0x64, 0x65, 0x37, 0x33, 0x33, 0x63, 0x30, 0x62, 0x31, 0x31, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x32, 0x63, 0x36, 0x62, 0x38, 0x63, 0x39, 0x35, 0x35, 0x62, 0x63, 0x30, 0x64, 0x38, 0x38, 0x38, 0x31, 0x32, 0x36, 0x37, 0x38, 0x61, 0x32, 0x33, 0x36, 0x37, 0x32, 0x35, 0x62, 0x33, 0x32, 0x37, 0x33, 0x39, 0x64, 0x39, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x65, 0x38, 0x31, 0x37, 0x37, 0x33, 0x38, 0x61, 0x62, 0x66, 0x31, 0x66, 0x62, 0x34, 0x38, 0x36, 0x35, 0x38, 0x33, 0x66, 0x38, 0x30, 0x63, 0x33, 0x35, 0x30, 0x33, 0x31, 0x38, 0x62, 0x65, 0x64, 0x38, 0x36, 0x30, 0x63, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x66, 0x35, 0x64, 0x66, 0x37, 0x36, 0x39, 0x39, 0x33, 0x34, 0x62, 0x38, 0x39, 0x34, 0x33, 0x63, 0x61, 0x39, 0x31, 0x33, 0x37, 0x64, 0x30, 0x65, 0x66, 0x65, 0x66, 0x32, 0x66, 0x65, 0x36, 0x65, 0x62, 0x62, 0x62, 0x33, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x34, 0x65, 0x34, 0x32, 0x36, 0x65, 0x38, 0x64, 0x63, 0x30, 0x30, 0x35, 0x64, 0x66, 0x61, 0x33, 0x35, 0x31, 0x36, 0x63, 0x62, 0x38, 0x61, 0x36, 0x38, 0x30, 0x62, 0x30, 0x32, 0x65, 0x65, 0x61, 0x39, 0x35, 0x61, 0x65, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x34, 0x35, 0x64, 0x64, 0x37, 0x63, 0x38, 0x39, 0x30, 0x30, 0x39, 0x33, 0x65, 0x38, 0x65, 0x34, 0x63, 0x38, 0x61, 0x61, 0x39, 0x32, 0x61, 0x36, 0x62, 0x62, 0x33, 0x35, 0x33, 0x35, 0x32, 0x32, 0x64, 0x33, 0x64, 0x63, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x61, 0x63, 0x38, 0x34, 0x36, 0x61, 0x66, 0x34, 0x31, 0x36, 0x39, 0x66, 0x31, 0x64, 0x39, 0x35, 0x34, 0x33, 0x31, 0x62, 0x33, 0x34, 0x31, 0x64, 0x38, 0x38, 0x30, 0x30, 0x62, 0x32, 0x32, 0x31, 0x38, 0x30, 0x61, 0x66, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x31, 0x34, 0x39, 0x35, 0x34, 0x63, 0x33, 0x63, 0x32, 0x66, 0x62, 0x36, 0x35, 0x37, 0x66, 0x39, 0x61, 0x30, 0x36, 0x66, 0x35, 0x31, 0x30, 0x65, 0x61, 0x32, 0x32, 0x37, 0x34, 0x38, 0x66, 0x30, 0x32, 0x37, 0x63, 0x64, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x33, 0x64, 0x63, 0x61, 0x37, 0x33, 0x64, 0x37, 0x64, 0x36, 0x65, 0x61, 0x33, 0x66, 0x33, 0x65, 0x36, 0x30, 0x36, 0x32, 0x33, 0x32, 0x32, 0x61, 0x38, 0x37, 0x33, 0x34, 0x31, 0x38, 0x30, 0x63, 0x30, 0x62, 0x37, 0x38, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x61, 0x63, 0x61, 0x32, 0x61, 0x63, 0x37, 0x34, 0x36, 0x32, 0x34, 0x62, 0x66, 0x33, 0x34, 0x38, 0x64, 0x61, 0x63, 0x39, 0x39, 0x38, 0x35, 0x31, 0x34, 0x33, 0x63, 0x66, 0x64, 0x36, 0x35, 0x32, 0x61, 0x34, 0x62, 0x65, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x31, 0x34, 0x38, 0x32, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x38, 0x30, 0x65, 0x39, 0x32, 0x33, 0x32, 0x64, 0x65, 0x61, 0x66, 0x66, 0x31, 0x39, 0x62, 0x61, 0x66, 0x39, 0x39, 0x38, 0x36, 0x39, 0x38, 0x38, 0x33, 0x61, 0x34, 0x62, 0x64, 0x66, 0x30, 0x30, 0x30, 0x34, 0x65, 0x35, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x35, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x31, 0x30, 0x38, 0x64, 0x61, 0x62, 0x32, 0x63, 0x35, 0x30, 0x66, 0x39, 0x39, 0x64, 0x65, 0x31, 0x31, 0x30, 0x65, 0x31, 0x62, 0x33, 0x62, 0x33, 0x62, 0x34, 0x63, 0x64, 0x38, 0x32, 0x66, 0x35, 0x64, 0x66, 0x32, 0x38, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x37, 0x61, 0x36, 0x34, 0x35, 0x64, 0x63, 0x39, 0x35, 0x63, 0x34, 0x39, 0x35, 0x34, 0x39, 0x66, 0x38, 0x39, 0x39, 0x63, 0x34, 0x65, 0x38, 0x62, 0x63, 0x66, 0x38, 0x37, 0x35, 0x33, 0x32, 0x34, 0x62, 0x32, 0x66, 0x35, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x32, 0x39, 0x39, 0x38, 0x65, 0x31, 0x64, 0x37, 0x35, 0x32, 0x32, 0x37, 0x66, 0x63, 0x65, 0x64, 0x37, 0x61, 0x37, 0x30, 0x62, 0x65, 0x31, 0x30, 0x39, 0x61, 0x34, 0x63, 0x30, 0x62, 0x34, 0x65, 0x64, 0x38, 0x36, 0x34, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x61, 0x37, 0x65, 0x38, 0x34, 0x33, 0x35, 0x64, 0x66, 0x66, 0x31, 0x34, 0x63, 0x32, 0x35, 0x35, 0x37, 0x37, 0x37, 0x33, 0x39, 0x64, 0x62, 0x35, 0x35, 0x63, 0x32, 0x34, 0x64, 0x35, 0x62, 0x66, 0x35, 0x37, 0x61, 0x33, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x61, 0x64, 0x38, 0x38, 0x64, 0x36, 0x38, 0x39, 0x34, 0x31, 0x36, 0x62, 0x31, 0x63, 0x39, 0x31, 0x66, 0x32, 0x33, 0x36, 0x34, 0x34, 0x32, 0x31, 0x33, 0x37, 0x35, 0x62, 0x37, 0x64, 0x33, 0x63, 0x37, 0x30, 0x66, 0x62, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x37, 0x39, 0x62, 0x32, 0x32, 0x32, 0x38, 0x63, 0x65, 0x63, 0x38, 0x66, 0x37, 0x62, 0x34, 0x64, 0x64, 0x61, 0x33, 0x66, 0x33, 0x32, 0x30, 0x65, 0x39, 0x61, 0x30, 0x34, 0x36, 0x36, 0x63, 0x32, 0x66, 0x35, 0x38, 0x35, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x37, 0x32, 0x36, 0x66, 0x33, 0x62, 0x38, 0x38, 0x35, 0x61, 0x32, 0x34, 0x66, 0x39, 0x32, 0x39, 0x39, 0x36, 0x64, 0x61, 0x38, 0x31, 0x36, 0x32, 0x35, 0x65, 0x63, 0x38, 0x61, 0x64, 0x31, 0x36, 0x64, 0x38, 0x63, 0x62, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x34, 0x33, 0x37, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x35, 0x31, 0x65, 0x34, 0x38, 0x65, 0x33, 0x63, 0x38, 0x36, 0x39, 0x65, 0x36, 0x62, 0x37, 0x32, 0x61, 0x31, 0x34, 0x33, 0x62, 0x36, 0x61, 0x34, 0x35, 0x30, 0x36, 0x38, 0x63, 0x64, 0x62, 0x39, 0x64, 0x34, 0x36, 0x36, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x64, 0x36, 0x31, 0x61, 0x63, 0x34, 0x63, 0x61, 0x39, 0x35, 0x34, 0x37, 0x35, 0x65, 0x35, 0x62, 0x37, 0x62, 0x66, 0x66, 0x64, 0x35, 0x66, 0x32, 0x66, 0x36, 0x39, 0x30, 0x62, 0x33, 0x31, 0x36, 0x37, 0x35, 0x39, 0x36, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x38, 0x61, 0x30, 0x64, 0x36, 0x31, 0x39, 0x32, 0x35, 0x33, 0x62, 0x66, 0x34, 0x34, 0x33, 0x32, 0x62, 0x35, 0x63, 0x64, 0x30, 0x32, 0x63, 0x37, 0x62, 0x38, 0x36, 0x32, 0x66, 0x37, 0x63, 0x32, 0x62, 0x37, 0x35, 0x36, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x37, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x36, 0x64, 0x34, 0x33, 0x31, 0x33, 0x32, 0x34, 0x63, 0x39, 0x32, 0x39, 0x31, 0x31, 0x61, 0x31, 0x37, 0x34, 0x39, 0x64, 0x66, 0x32, 0x39, 0x32, 0x37, 0x30, 0x39, 0x63, 0x31, 0x34, 0x62, 0x37, 0x37, 0x61, 0x36, 0x35, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x37, 0x36, 0x39, 0x34, 0x37, 0x65, 0x66, 0x66, 0x35, 0x66, 0x36, 0x61, 0x65, 0x35, 0x64, 0x61, 0x30, 0x38, 0x64, 0x64, 0x35, 0x34, 0x31, 0x31, 0x39, 0x32, 0x66, 0x33, 0x37, 0x38, 0x62, 0x34, 0x32, 0x38, 0x66, 0x66, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x32, 0x31, 0x30, 0x35, 0x38, 0x33, 0x63, 0x31, 0x36, 0x61, 0x34, 0x65, 0x31, 0x65, 0x31, 0x64, 0x61, 0x63, 0x38, 0x34, 0x65, 0x62, 0x64, 0x33, 0x37, 0x65, 0x33, 0x64, 0x30, 0x66, 0x37, 0x63, 0x35, 0x37, 0x65, 0x62, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x62, 0x36, 0x34, 0x64, 0x66, 0x34, 0x33, 0x37, 0x35, 0x38, 0x63, 0x37, 0x63, 0x66, 0x39, 0x37, 0x34, 0x66, 0x61, 0x36, 0x36, 0x30, 0x34, 0x38, 0x34, 0x66, 0x62, 0x62, 0x37, 0x31, 0x38, 0x66, 0x38, 0x63, 0x36, 0x37, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x32, 0x30, 0x35, 0x35, 0x39, 0x32, 0x38, 0x34, 0x34, 0x30, 0x35, 0x35, 0x62, 0x33, 0x63, 0x37, 0x61, 0x31, 0x66, 0x38, 0x30, 0x63, 0x65, 0x66, 0x65, 0x33, 0x62, 0x38, 0x65, 0x62, 0x35, 0x30, 0x39, 0x62, 0x63, 0x64, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x38, 0x39, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x36, 0x34, 0x38, 0x61, 0x35, 0x38, 0x31, 0x62, 0x33, 0x35, 0x30, 0x38, 0x65, 0x31, 0x33, 0x35, 0x61, 0x32, 0x39, 0x33, 0x35, 0x64, 0x31, 0x32, 0x63, 0x39, 0x36, 0x35, 0x37, 0x30, 0x34, 0x35, 0x64, 0x38, 0x37, 0x31, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x64, 0x31, 0x37, 0x35, 0x32, 0x34, 0x64, 0x30, 0x30, 0x62, 0x61, 0x64, 0x38, 0x32, 0x34, 0x39, 0x37, 0x63, 0x30, 0x66, 0x32, 0x37, 0x31, 0x35, 0x36, 0x61, 0x36, 0x34, 0x37, 0x66, 0x66, 0x35, 0x31, 0x64, 0x32, 0x37, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x35, 0x38, 0x32, 0x65, 0x39, 0x39, 0x65, 0x35, 0x30, 0x32, 0x63, 0x62, 0x66, 0x33, 0x64, 0x33, 0x63, 0x32, 0x33, 0x62, 0x64, 0x66, 0x66, 0x62, 0x37, 0x36, 0x65, 0x39, 0x30, 0x31, 0x61, 0x63, 0x36, 0x64, 0x35, 0x36, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x31, 0x66, 0x32, 0x38, 0x30, 0x39, 0x31, 0x35, 0x63, 0x37, 0x37, 0x34, 0x61, 0x33, 0x31, 0x64, 0x32, 0x32, 0x33, 0x63, 0x66, 0x38, 0x30, 0x63, 0x30, 0x36, 0x39, 0x32, 0x36, 0x36, 0x65, 0x35, 0x61, 0x64, 0x66, 0x31, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x63, 0x39, 0x31, 0x64, 0x39, 0x32, 0x39, 0x34, 0x33, 0x36, 0x30, 0x33, 0x65, 0x37, 0x35, 0x32, 0x32, 0x30, 0x33, 0x65, 0x30, 0x35, 0x33, 0x34, 0x30, 0x65, 0x35, 0x36, 0x36, 0x30, 0x31, 0x33, 0x62, 0x39, 0x30, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x35, 0x36, 0x31, 0x63, 0x35, 0x39, 0x33, 0x31, 0x31, 0x34, 0x33, 0x35, 0x33, 0x36, 0x33, 0x30, 0x39, 0x63, 0x31, 0x37, 0x65, 0x38, 0x33, 0x32, 0x35, 0x38, 0x37, 0x62, 0x36, 0x32, 0x35, 0x63, 0x33, 0x39, 0x30, 0x62, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x39, 0x39, 0x63, 0x38, 0x31, 0x61, 0x31, 0x64, 0x37, 0x30, 0x31, 0x62, 0x34, 0x34, 0x66, 0x30, 0x62, 0x36, 0x36, 0x66, 0x33, 0x33, 0x39, 0x39, 0x65, 0x36, 0x36, 0x62, 0x32, 0x37, 0x35, 0x61, 0x61, 0x61, 0x66, 0x38, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x38, 0x64, 0x62, 0x63, 0x65, 0x31, 0x38, 0x30, 0x65, 0x64, 0x39, 0x63, 0x35, 0x36, 0x33, 0x36, 0x33, 0x35, 0x61, 0x61, 0x64, 0x32, 0x64, 0x39, 0x37, 0x62, 0x34, 0x63, 0x62, 0x63, 0x34, 0x32, 0x38, 0x39, 0x30, 0x36, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x36, 0x31, 0x62, 0x65, 0x62, 0x34, 0x36, 0x66, 0x35, 0x65, 0x38, 0x35, 0x33, 0x64, 0x30, 0x61, 0x38, 0x35, 0x32, 0x31, 0x63, 0x37, 0x34, 0x34, 0x36, 0x65, 0x36, 0x38, 0x65, 0x33, 0x34, 0x63, 0x37, 0x64, 0x30, 0x39, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x33, 0x66, 0x32, 0x62, 0x61, 0x38, 0x35, 0x36, 0x63, 0x63, 0x62, 0x62, 0x30, 0x32, 0x33, 0x37, 0x66, 0x61, 0x37, 0x36, 0x36, 0x31, 0x31, 0x35, 0x36, 0x62, 0x31, 0x34, 0x62, 0x30, 0x31, 0x33, 0x66, 0x32, 0x31, 0x32, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x37, 0x34, 0x32, 0x65, 0x34, 0x38, 0x37, 0x65, 0x33, 0x61, 0x62, 0x38, 0x31, 0x61, 0x66, 0x32, 0x66, 0x39, 0x34, 0x61, 0x66, 0x64, 0x62, 0x65, 0x31, 0x62, 0x39, 0x62, 0x38, 0x66, 0x35, 0x63, 0x63, 0x63, 0x38, 0x31, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x37, 0x32, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x30, 0x30, 0x66, 0x65, 0x61, 0x62, 0x34, 0x61, 0x61, 0x39, 0x36, 0x63, 0x35, 0x33, 0x37, 0x35, 0x30, 0x34, 0x64, 0x39, 0x36, 0x30, 0x35, 0x37, 0x32, 0x32, 0x33, 0x31, 0x34, 0x31, 0x36, 0x39, 0x32, 0x63, 0x31, 0x39, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x62, 0x34, 0x38, 0x37, 0x35, 0x30, 0x30, 0x64, 0x66, 0x32, 0x30, 0x66, 0x62, 0x38, 0x33, 0x65, 0x62, 0x65, 0x64, 0x39, 0x31, 0x36, 0x37, 0x39, 0x31, 0x64, 0x35, 0x36, 0x31, 0x37, 0x37, 0x32, 0x61, 0x64, 0x62, 0x65, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x37, 0x30, 0x34, 0x63, 0x31, 0x36, 0x64, 0x32, 0x66, 0x64, 0x35, 0x62, 0x61, 0x33, 0x61, 0x32, 0x63, 0x30, 0x31, 0x64, 0x30, 0x65, 0x62, 0x32, 0x30, 0x34, 0x38, 0x34, 0x65, 0x36, 0x65, 0x63, 0x66, 0x61, 0x33, 0x31, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x31, 0x62, 0x63, 0x34, 0x32, 0x30, 0x63, 0x35, 0x33, 0x63, 0x30, 0x30, 0x32, 0x63, 0x39, 0x65, 0x39, 0x30, 0x30, 0x33, 0x37, 0x63, 0x34, 0x34, 0x66, 0x65, 0x36, 0x61, 0x38, 0x65, 0x66, 0x34, 0x64, 0x64, 0x63, 0x39, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x65, 0x35, 0x37, 0x37, 0x62, 0x35, 0x31, 0x35, 0x63, 0x62, 0x32, 0x62, 0x30, 0x38, 0x36, 0x30, 0x61, 0x61, 0x66, 0x65, 0x31, 0x63, 0x65, 0x30, 0x39, 0x61, 0x35, 0x39, 0x65, 0x30, 0x39, 0x66, 0x65, 0x37, 0x64, 0x30, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x39, 0x39, 0x39, 0x65, 0x33, 0x38, 0x35, 0x63, 0x35, 0x61, 0x65, 0x62, 0x63, 0x61, 0x63, 0x38, 0x64, 0x36, 0x66, 0x33, 0x66, 0x30, 0x64, 0x36, 0x30, 0x64, 0x35, 0x61, 0x61, 0x37, 0x32, 0x35, 0x33, 0x33, 0x36, 0x64, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x36, 0x63, 0x65, 0x33, 0x35, 0x39, 0x36, 0x31, 0x63, 0x64, 0x37, 0x34, 0x62, 0x64, 0x35, 0x39, 0x30, 0x64, 0x30, 0x34, 0x63, 0x34, 0x61, 0x64, 0x34, 0x61, 0x31, 0x39, 0x38, 0x39, 0x65, 0x30, 0x35, 0x36, 0x39, 0x31, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x37, 0x36, 0x34, 0x32, 0x34, 0x63, 0x30, 0x66, 0x64, 0x35, 0x39, 0x37, 0x64, 0x33, 0x65, 0x33, 0x34, 0x31, 0x61, 0x39, 0x36, 0x34, 0x32, 0x61, 0x64, 0x31, 0x65, 0x65, 0x31, 0x31, 0x38, 0x62, 0x32, 0x62, 0x35, 0x37, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x34, 0x30, 0x63, 0x37, 0x63, 0x61, 0x32, 0x66, 0x39, 0x36, 0x34, 0x62, 0x36, 0x39, 0x37, 0x32, 0x65, 0x66, 0x36, 0x36, 0x34, 0x61, 0x32, 0x32, 0x36, 0x31, 0x64, 0x64, 0x65, 0x38, 0x39, 0x32, 0x36, 0x31, 0x39, 0x64, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x30, 0x64, 0x35, 0x33, 0x35, 0x35, 0x62, 0x32, 0x63, 0x65, 0x65, 0x62, 0x36, 0x65, 0x36, 0x32, 0x31, 0x30, 0x37, 0x64, 0x38, 0x31, 0x65, 0x35, 0x31, 0x32, 0x37, 0x30, 0x62, 0x32, 0x36, 0x62, 0x66, 0x34, 0x35, 0x36, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x61, 0x64, 0x61, 0x33, 0x30, 0x30, 0x32, 0x38, 0x33, 0x66, 0x36, 0x62, 0x63, 0x63, 0x31, 0x33, 0x34, 0x61, 0x39, 0x31, 0x34, 0x35, 0x36, 0x37, 0x36, 0x30, 0x62, 0x30, 0x64, 0x37, 0x37, 0x64, 0x65, 0x34, 0x31, 0x30, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x38, 0x64, 0x37, 0x66, 0x31, 0x38, 0x61, 0x64, 0x66, 0x65, 0x35, 0x64, 0x36, 0x63, 0x63, 0x37, 0x37, 0x35, 0x33, 0x39, 0x34, 0x39, 0x38, 0x39, 0x65, 0x31, 0x39, 0x33, 0x30, 0x63, 0x39, 0x37, 0x39, 0x64, 0x30, 0x30, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x66, 0x39, 0x32, 0x32, 0x30, 0x63, 0x38, 0x30, 0x34, 0x37, 0x38, 0x32, 0x36, 0x62, 0x64, 0x35, 0x64, 0x35, 0x31, 0x38, 0x33, 0x66, 0x34, 0x65, 0x36, 0x37, 0x36, 0x61, 0x36, 0x64, 0x37, 0x37, 0x62, 0x66, 0x65, 0x64, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x33, 0x33, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x64, 0x32, 0x30, 0x34, 0x66, 0x39, 0x30, 0x38, 0x35, 0x66, 0x38, 0x63, 0x38, 0x65, 0x37, 0x64, 0x65, 0x32, 0x33, 0x65, 0x35, 0x38, 0x39, 0x62, 0x36, 0x34, 0x63, 0x36, 0x65, 0x66, 0x66, 0x36, 0x39, 0x32, 0x63, 0x63, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x32, 0x39, 0x31, 0x36, 0x62, 0x38, 0x64, 0x32, 0x65, 0x38, 0x63, 0x63, 0x31, 0x32, 0x65, 0x32, 0x30, 0x37, 0x61, 0x62, 0x34, 0x36, 0x34, 0x64, 0x34, 0x33, 0x33, 0x65, 0x32, 0x33, 0x37, 0x30, 0x64, 0x38, 0x32, 0x33, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x32, 0x64, 0x36, 0x61, 0x65, 0x62, 0x37, 0x31, 0x30, 0x65, 0x33, 0x61, 0x35, 0x30, 0x62, 0x66, 0x62, 0x34, 0x34, 0x64, 0x36, 0x63, 0x33, 0x31, 0x30, 0x39, 0x32, 0x39, 0x36, 0x39, 0x61, 0x31, 0x31, 0x61, 0x61, 0x37, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x63, 0x65, 0x34, 0x35, 0x66, 0x36, 0x30, 0x30, 0x64, 0x62, 0x31, 0x38, 0x61, 0x39, 0x64, 0x30, 0x38, 0x35, 0x31, 0x62, 0x32, 0x39, 0x64, 0x39, 0x33, 0x39, 0x33, 0x65, 0x62, 0x64, 0x61, 0x61, 0x66, 0x65, 0x33, 0x64, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x31, 0x33, 0x37, 0x30, 0x61, 0x37, 0x34, 0x32, 0x65, 0x63, 0x32, 0x36, 0x38, 0x37, 0x65, 0x37, 0x36, 0x31, 0x61, 0x31, 0x39, 0x61, 0x63, 0x35, 0x61, 0x37, 0x39, 0x34, 0x33, 0x32, 0x39, 0x65, 0x65, 0x36, 0x37, 0x34, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x32, 0x61, 0x64, 0x35, 0x38, 0x65, 0x37, 0x37, 0x64, 0x65, 0x64, 0x64, 0x65, 0x64, 0x65, 0x32, 0x31, 0x38, 0x37, 0x36, 0x34, 0x36, 0x63, 0x34, 0x36, 0x35, 0x39, 0x34, 0x35, 0x61, 0x38, 0x64, 0x63, 0x33, 0x66, 0x36, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x35, 0x38, 0x62, 0x63, 0x30, 0x64, 0x30, 0x63, 0x32, 0x30, 0x64, 0x38, 0x66, 0x34, 0x39, 0x34, 0x36, 0x35, 0x36, 0x36, 0x34, 0x31, 0x35, 0x33, 0x63, 0x35, 0x63, 0x31, 0x39, 0x36, 0x66, 0x65, 0x35, 0x39, 0x65, 0x36, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x30, 0x36, 0x33, 0x61, 0x66, 0x34, 0x63, 0x63, 0x31, 0x64, 0x64, 0x39, 0x36, 0x31, 0x39, 0x61, 0x62, 0x35, 0x64, 0x38, 0x62, 0x66, 0x66, 0x33, 0x66, 0x63, 0x64, 0x31, 0x66, 0x61, 0x61, 0x38, 0x34, 0x38, 0x38, 0x32, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x32, 0x33, 0x31, 0x65, 0x62, 0x32, 0x36, 0x65, 0x35, 0x66, 0x39, 0x65, 0x34, 0x62, 0x34, 0x64, 0x32, 0x38, 0x38, 0x66, 0x30, 0x33, 0x39, 0x30, 0x36, 0x37, 0x30, 0x34, 0x66, 0x61, 0x62, 0x39, 0x36, 0x63, 0x38, 0x37, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x35, 0x63, 0x32, 0x64, 0x39, 0x62, 0x31, 0x63, 0x35, 0x34, 0x36, 0x61, 0x38, 0x36, 0x65, 0x65, 0x66, 0x64, 0x35, 0x64, 0x30, 0x61, 0x35, 0x31, 0x32, 0x30, 0x63, 0x39, 0x65, 0x34, 0x65, 0x37, 0x33, 0x30, 0x31, 0x39, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x39, 0x39, 0x33, 0x36, 0x61, 0x39, 0x32, 0x61, 0x38, 0x63, 0x63, 0x66, 0x37, 0x31, 0x30, 0x65, 0x61, 0x61, 0x63, 0x33, 0x34, 0x32, 0x62, 0x63, 0x34, 0x35, 0x34, 0x62, 0x39, 0x62, 0x31, 0x34, 0x65, 0x62, 0x65, 0x63, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x64, 0x62, 0x64, 0x62, 0x38, 0x31, 0x37, 0x61, 0x30, 0x64, 0x38, 0x34, 0x30, 0x34, 0x63, 0x36, 0x62, 0x64, 0x64, 0x36, 0x31, 0x35, 0x30, 0x34, 0x33, 0x37, 0x34, 0x65, 0x39, 0x63, 0x34, 0x33, 0x63, 0x39, 0x32, 0x31, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x65, 0x62, 0x65, 0x33, 0x30, 0x62, 0x32, 0x61, 0x39, 0x35, 0x66, 0x34, 0x61, 0x65, 0x66, 0x64, 0x61, 0x36, 0x36, 0x35, 0x36, 0x35, 0x31, 0x64, 0x63, 0x30, 0x63, 0x66, 0x37, 0x65, 0x66, 0x35, 0x37, 0x35, 0x38, 0x31, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x37, 0x30, 0x33, 0x38, 0x66, 0x66, 0x39, 0x31, 0x61, 0x30, 0x39, 0x30, 0x30, 0x63, 0x62, 0x62, 0x61, 0x62, 0x34, 0x38, 0x38, 0x61, 0x66, 0x34, 0x38, 0x33, 0x63, 0x37, 0x39, 0x30, 0x65, 0x36, 0x65, 0x63, 0x30, 0x30, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x61, 0x35, 0x64, 0x38, 0x63, 0x35, 0x62, 0x33, 0x66, 0x32, 0x39, 0x34, 0x65, 0x66, 0x64, 0x34, 0x39, 0x35, 0x61, 0x62, 0x36, 0x39, 0x64, 0x37, 0x36, 0x38, 0x66, 0x38, 0x31, 0x38, 0x37, 0x32, 0x35, 0x30, 0x38, 0x35, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x66, 0x33, 0x62, 0x36, 0x65, 0x61, 0x62, 0x63, 0x39, 0x34, 0x61, 0x66, 0x66, 0x64, 0x33, 0x33, 0x31, 0x30, 0x63, 0x31, 0x63, 0x34, 0x64, 0x30, 0x65, 0x36, 0x35, 0x33, 0x37, 0x35, 0x65, 0x31, 0x33, 0x31, 0x31, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x65, 0x38, 0x31, 0x64, 0x33, 0x31, 0x61, 0x37, 0x39, 0x32, 0x33, 0x30, 0x32, 0x32, 0x65, 0x31, 0x32, 0x35, 0x62, 0x66, 0x34, 0x38, 0x61, 0x33, 0x65, 0x30, 0x33, 0x36, 0x39, 0x33, 0x62, 0x39, 0x38, 0x64, 0x63, 0x39, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x38, 0x37, 0x64, 0x63, 0x36, 0x61, 0x33, 0x33, 0x64, 0x66, 0x65, 0x64, 0x35, 0x61, 0x63, 0x31, 0x65, 0x64, 0x65, 0x66, 0x65, 0x33, 0x35, 0x65, 0x66, 0x39, 0x31, 0x61, 0x32, 0x31, 0x36, 0x32, 0x33, 0x31, 0x61, 0x63, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x38, 0x65, 0x34, 0x37, 0x61, 0x65, 0x33, 0x62, 0x31, 0x65, 0x66, 0x35, 0x30, 0x63, 0x39, 0x64, 0x35, 0x34, 0x61, 0x33, 0x38, 0x65, 0x31, 0x34, 0x32, 0x30, 0x38, 0x63, 0x31, 0x61, 0x62, 0x64, 0x33, 0x36, 0x30, 0x33, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x34, 0x35, 0x65, 0x33, 0x38, 0x37, 0x63, 0x34, 0x63, 0x62, 0x64, 0x66, 0x39, 0x38, 0x32, 0x32, 0x38, 0x30, 0x66, 0x36, 0x61, 0x61, 0x30, 0x31, 0x63, 0x34, 0x30, 0x65, 0x34, 0x62, 0x65, 0x39, 0x35, 0x38, 0x64, 0x64, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x64, 0x39, 0x34, 0x39, 0x34, 0x65, 0x35, 0x30, 0x63, 0x35, 0x64, 0x64, 0x35, 0x39, 0x63, 0x35, 0x39, 0x39, 0x64, 0x62, 0x61, 0x33, 0x38, 0x31, 0x30, 0x62, 0x61, 0x31, 0x37, 0x35, 0x35, 0x65, 0x36, 0x35, 0x33, 0x37, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x62, 0x35, 0x35, 0x37, 0x38, 0x61, 0x36, 0x62, 0x62, 0x37, 0x63, 0x33, 0x32, 0x31, 0x35, 0x33, 0x31, 0x39, 0x35, 0x62, 0x30, 0x64, 0x38, 0x30, 0x32, 0x30, 0x61, 0x36, 0x39, 0x31, 0x34, 0x38, 0x35, 0x32, 0x63, 0x30, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x66, 0x38, 0x63, 0x36, 0x37, 0x34, 0x65, 0x32, 0x34, 0x36, 0x32, 0x64, 0x38, 0x64, 0x35, 0x64, 0x61, 0x61, 0x30, 0x65, 0x38, 0x30, 0x31, 0x39, 0x35, 0x61, 0x38, 0x37, 0x30, 0x38, 0x65, 0x31, 0x31, 0x61, 0x32, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x34, 0x35, 0x39, 0x65, 0x66, 0x33, 0x36, 0x39, 0x33, 0x61, 0x61, 0x63, 0x64, 0x31, 0x36, 0x34, 0x37, 0x63, 0x64, 0x35, 0x64, 0x38, 0x39, 0x32, 0x39, 0x38, 0x33, 0x39, 0x32, 0x30, 0x34, 0x63, 0x65, 0x66, 0x35, 0x33, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x61, 0x33, 0x37, 0x31, 0x65, 0x36, 0x30, 0x30, 0x64, 0x33, 0x30, 0x36, 0x38, 0x38, 0x64, 0x34, 0x37, 0x31, 0x30, 0x65, 0x30, 0x38, 0x38, 0x65, 0x30, 0x32, 0x66, 0x64, 0x66, 0x32, 0x62, 0x39, 0x35, 0x32, 0x34, 0x64, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x34, 0x64, 0x64, 0x36, 0x64, 0x33, 0x36, 0x30, 0x33, 0x33, 0x62, 0x30, 0x36, 0x33, 0x36, 0x66, 0x63, 0x63, 0x38, 0x64, 0x30, 0x39, 0x33, 0x38, 0x36, 0x30, 0x39, 0x66, 0x34, 0x64, 0x64, 0x36, 0x34, 0x66, 0x34, 0x61, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x64, 0x36, 0x32, 0x34, 0x62, 0x35, 0x34, 0x38, 0x63, 0x62, 0x36, 0x35, 0x39, 0x37, 0x33, 0x36, 0x39, 0x30, 0x37, 0x65, 0x64, 0x38, 0x61, 0x61, 0x33, 0x63, 0x30, 0x63, 0x37, 0x30, 0x35, 0x65, 0x32, 0x34, 0x62, 0x35, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x34, 0x35, 0x39, 0x39, 0x30, 0x39, 0x32, 0x65, 0x38, 0x37, 0x39, 0x61, 0x65, 0x32, 0x35, 0x33, 0x37, 0x32, 0x61, 0x38, 0x34, 0x64, 0x37, 0x33, 0x35, 0x61, 0x66, 0x35, 0x63, 0x34, 0x65, 0x35, 0x31, 0x30, 0x63, 0x64, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x36, 0x36, 0x63, 0x64, 0x34, 0x62, 0x64, 0x36, 0x34, 0x64, 0x35, 0x63, 0x38, 0x63, 0x31, 0x62, 0x35, 0x65, 0x65, 0x61, 0x32, 0x38, 0x31, 0x65, 0x31, 0x30, 0x36, 0x64, 0x31, 0x63, 0x35, 0x61, 0x61, 0x64, 0x32, 0x33, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x35, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x34, 0x38, 0x62, 0x63, 0x33, 0x36, 0x35, 0x30, 0x65, 0x64, 0x35, 0x31, 0x39, 0x62, 0x66, 0x38, 0x39, 0x31, 0x61, 0x35, 0x37, 0x32, 0x36, 0x37, 0x39, 0x66, 0x64, 0x39, 0x39, 0x32, 0x66, 0x38, 0x37, 0x38, 0x30, 0x63, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x37, 0x34, 0x61, 0x37, 0x63, 0x62, 0x31, 0x62, 0x62, 0x38, 0x63, 0x35, 0x38, 0x66, 0x63, 0x65, 0x32, 0x36, 0x37, 0x34, 0x36, 0x36, 0x61, 0x33, 0x30, 0x33, 0x35, 0x38, 0x61, 0x64, 0x61, 0x66, 0x35, 0x32, 0x37, 0x66, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x31, 0x30, 0x38, 0x30, 0x30, 0x32, 0x38, 0x32, 0x64, 0x31, 0x62, 0x37, 0x64, 0x64, 0x63, 0x37, 0x38, 0x66, 0x61, 0x39, 0x32, 0x64, 0x38, 0x32, 0x33, 0x30, 0x30, 0x37, 0x34, 0x65, 0x31, 0x62, 0x66, 0x36, 0x61, 0x65, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x64, 0x62, 0x62, 0x36, 0x37, 0x31, 0x36, 0x63, 0x35, 0x34, 0x65, 0x38, 0x33, 0x31, 0x36, 0x35, 0x38, 0x32, 0x39, 0x61, 0x34, 0x61, 0x62, 0x62, 0x33, 0x36, 0x37, 0x35, 0x37, 0x38, 0x34, 0x39, 0x62, 0x36, 0x65, 0x34, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x62, 0x33, 0x61, 0x63, 0x33, 0x66, 0x35, 0x64, 0x34, 0x64, 0x61, 0x35, 0x61, 0x38, 0x38, 0x35, 0x37, 0x64, 0x30, 0x62, 0x33, 0x66, 0x33, 0x30, 0x66, 0x63, 0x34, 0x62, 0x32, 0x62, 0x36, 0x39, 0x32, 0x62, 0x37, 0x37, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x32, 0x61, 0x35, 0x38, 0x65, 0x30, 0x33, 0x35, 0x66, 0x31, 0x66, 0x65, 0x39, 0x63, 0x64, 0x64, 0x31, 0x36, 0x39, 0x62, 0x63, 0x66, 0x32, 0x30, 0x39, 0x37, 0x30, 0x33, 0x34, 0x35, 0x64, 0x31, 0x32, 0x62, 0x39, 0x63, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x31, 0x62, 0x64, 0x66, 0x31, 0x62, 0x62, 0x32, 0x37, 0x36, 0x64, 0x62, 0x64, 0x64, 0x38, 0x36, 0x61, 0x65, 0x64, 0x63, 0x64, 0x62, 0x33, 0x39, 0x37, 0x61, 0x30, 0x31, 0x65, 0x66, 0x63, 0x30, 0x65, 0x30, 0x30, 0x63, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x34, 0x65, 0x39, 0x34, 0x37, 0x37, 0x65, 0x62, 0x66, 0x34, 0x37, 0x32, 0x37, 0x63, 0x37, 0x34, 0x35, 0x62, 0x63, 0x61, 0x62, 0x62, 0x65, 0x64, 0x63, 0x62, 0x36, 0x63, 0x63, 0x66, 0x32, 0x39, 0x39, 0x39, 0x34, 0x30, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x62, 0x39, 0x36, 0x64, 0x65, 0x62, 0x38, 0x37, 0x38, 0x34, 0x38, 0x38, 0x35, 0x64, 0x38, 0x64, 0x33, 0x62, 0x34, 0x61, 0x31, 0x36, 0x36, 0x31, 0x34, 0x33, 0x63, 0x63, 0x34, 0x33, 0x35, 0x64, 0x32, 0x35, 0x35, 0x35, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x64, 0x39, 0x38, 0x30, 0x61, 0x31, 0x32, 0x65, 0x65, 0x33, 0x62, 0x66, 0x32, 0x33, 0x63, 0x63, 0x35, 0x63, 0x64, 0x62, 0x36, 0x33, 0x62, 0x34, 0x61, 0x65, 0x34, 0x35, 0x36, 0x39, 0x31, 0x66, 0x37, 0x34, 0x63, 0x38, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x66, 0x62, 0x64, 0x33, 0x38, 0x34, 0x37, 0x63, 0x31, 0x37, 0x61, 0x36, 0x31, 0x63, 0x66, 0x33, 0x66, 0x31, 0x37, 0x62, 0x35, 0x32, 0x66, 0x38, 0x65, 0x62, 0x61, 0x31, 0x62, 0x39, 0x36, 0x30, 0x62, 0x33, 0x66, 0x33, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x63, 0x39, 0x34, 0x31, 0x65, 0x30, 0x65, 0x35, 0x30, 0x31, 0x38, 0x37, 0x32, 0x36, 0x62, 0x37, 0x32, 0x39, 0x30, 0x66, 0x63, 0x34, 0x37, 0x33, 0x62, 0x34, 0x37, 0x31, 0x64, 0x34, 0x31, 0x64, 0x61, 0x65, 0x38, 0x30, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x36, 0x62, 0x63, 0x65, 0x64, 0x63, 0x65, 0x33, 0x66, 0x65, 0x61, 0x64, 0x63, 0x65, 0x61, 0x33, 0x62, 0x63, 0x33, 0x65, 0x39, 0x36, 0x65, 0x62, 0x31, 0x30, 0x34, 0x30, 0x64, 0x66, 0x64, 0x38, 0x66, 0x66, 0x65, 0x31, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x39, 0x34, 0x34, 0x61, 0x61, 0x31, 0x38, 0x35, 0x61, 0x31, 0x33, 0x33, 0x37, 0x30, 0x36, 0x31, 0x61, 0x65, 0x32, 0x30, 0x64, 0x63, 0x39, 0x64, 0x64, 0x39, 0x36, 0x63, 0x38, 0x33, 0x62, 0x32, 0x62, 0x61, 0x34, 0x36, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x34, 0x63, 0x61, 0x61, 0x34, 0x32, 0x39, 0x63, 0x36, 0x31, 0x39, 0x64, 0x39, 0x34, 0x30, 0x66, 0x38, 0x65, 0x36, 0x37, 0x34, 0x31, 0x38, 0x32, 0x36, 0x61, 0x30, 0x64, 0x62, 0x36, 0x39, 0x32, 0x62, 0x31, 0x39, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x35, 0x63, 0x39, 0x62, 0x31, 0x30, 0x61, 0x61, 0x39, 0x38, 0x31, 0x63, 0x66, 0x34, 0x61, 0x36, 0x37, 0x61, 0x37, 0x31, 0x63, 0x63, 0x35, 0x32, 0x63, 0x35, 0x30, 0x34, 0x64, 0x65, 0x65, 0x38, 0x63, 0x66, 0x35, 0x38, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x38, 0x37, 0x34, 0x36, 0x38, 0x36, 0x62, 0x36, 0x37, 0x33, 0x33, 0x64, 0x31, 0x30, 0x64, 0x37, 0x30, 0x33, 0x63, 0x39, 0x66, 0x39, 0x62, 0x65, 0x63, 0x36, 0x63, 0x35, 0x32, 0x65, 0x62, 0x38, 0x36, 0x32, 0x38, 0x64, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x37, 0x34, 0x66, 0x61, 0x63, 0x64, 0x37, 0x62, 0x33, 0x66, 0x38, 0x64, 0x36, 0x38, 0x36, 0x34, 0x39, 0x64, 0x36, 0x30, 0x64, 0x34, 0x35, 0x35, 0x30, 0x65, 0x65, 0x36, 0x39, 0x66, 0x66, 0x30, 0x34, 0x38, 0x34, 0x31, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x65, 0x34, 0x36, 0x39, 0x63, 0x38, 0x38, 0x36, 0x35, 0x39, 0x33, 0x38, 0x31, 0x35, 0x62, 0x33, 0x34, 0x39, 0x35, 0x36, 0x33, 0x38, 0x35, 0x39, 0x35, 0x64, 0x61, 0x65, 0x66, 0x30, 0x36, 0x36, 0x35, 0x66, 0x61, 0x65, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x66, 0x66, 0x36, 0x66, 0x65, 0x62, 0x34, 0x33, 0x32, 0x31, 0x32, 0x30, 0x36, 0x30, 0x62, 0x62, 0x31, 0x35, 0x30, 0x33, 0x64, 0x37, 0x61, 0x33, 0x39, 0x37, 0x66, 0x63, 0x30, 0x38, 0x66, 0x34, 0x65, 0x37, 0x30, 0x33, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x30, 0x62, 0x30, 0x34, 0x36, 0x35, 0x34, 0x65, 0x30, 0x30, 0x33, 0x62, 0x34, 0x36, 0x38, 0x33, 0x30, 0x34, 0x31, 0x66, 0x31, 0x63, 0x62, 0x64, 0x36, 0x62, 0x63, 0x33, 0x38, 0x66, 0x64, 0x61, 0x37, 0x63, 0x64, 0x62, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x63, 0x64, 0x62, 0x35, 0x33, 0x32, 0x65, 0x33, 0x39, 0x37, 0x35, 0x37, 0x39, 0x36, 0x36, 0x32, 0x62, 0x32, 0x61, 0x34, 0x36, 0x31, 0x34, 0x31, 0x65, 0x37, 0x38, 0x66, 0x38, 0x32, 0x33, 0x35, 0x39, 0x33, 0x36, 0x61, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x61, 0x38, 0x63, 0x32, 0x63, 0x62, 0x37, 0x64, 0x33, 0x35, 0x38, 0x65, 0x35, 0x37, 0x33, 0x39, 0x39, 0x34, 0x31, 0x64, 0x39, 0x34, 0x35, 0x62, 0x61, 0x39, 0x30, 0x34, 0x35, 0x61, 0x30, 0x32, 0x33, 0x61, 0x38, 0x62, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x65, 0x66, 0x35, 0x63, 0x64, 0x63, 0x36, 0x37, 0x31, 0x64, 0x66, 0x35, 0x35, 0x36, 0x32, 0x61, 0x39, 0x30, 0x31, 0x61, 0x65, 0x65, 0x35, 0x64, 0x62, 0x37, 0x31, 0x36, 0x62, 0x39, 0x62, 0x65, 0x37, 0x36, 0x64, 0x63, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x34, 0x31, 0x31, 0x30, 0x65, 0x37, 0x31, 0x61, 0x66, 0x65, 0x35, 0x37, 0x38, 0x61, 0x61, 0x32, 0x31, 0x38, 0x65, 0x34, 0x66, 0x63, 0x32, 0x38, 0x36, 0x34, 0x30, 0x33, 0x62, 0x30, 0x33, 0x33, 0x30, 0x61, 0x63, 0x65, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x34, 0x33, 0x64, 0x63, 0x62, 0x39, 0x35, 0x66, 0x64, 0x65, 0x33, 0x31, 0x38, 0x30, 0x37, 0x35, 0x61, 0x35, 0x36, 0x37, 0x66, 0x31, 0x65, 0x36, 0x62, 0x35, 0x37, 0x36, 0x31, 0x37, 0x30, 0x35, 0x35, 0x65, 0x66, 0x39, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x65, 0x65, 0x61, 0x30, 0x31, 0x30, 0x37, 0x35, 0x36, 0x66, 0x38, 0x31, 0x64, 0x61, 0x34, 0x62, 0x61, 0x32, 0x35, 0x62, 0x37, 0x32, 0x31, 0x37, 0x38, 0x37, 0x66, 0x30, 0x35, 0x38, 0x31, 0x37, 0x30, 0x62, 0x65, 0x66, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x38, 0x32, 0x35, 0x35, 0x65, 0x64, 0x64, 0x63, 0x66, 0x35, 0x32, 0x31, 0x63, 0x36, 0x66, 0x38, 0x31, 0x64, 0x39, 0x37, 0x66, 0x35, 0x61, 0x34, 0x32, 0x31, 0x38, 0x31, 0x63, 0x39, 0x30, 0x37, 0x33, 0x64, 0x34, 0x65, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x30, 0x37, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x34, 0x37, 0x31, 0x38, 0x39, 0x61, 0x33, 0x65, 0x36, 0x34, 0x33, 0x39, 0x37, 0x31, 0x36, 0x37, 0x66, 0x30, 0x36, 0x32, 0x30, 0x65, 0x34, 0x38, 0x34, 0x35, 0x36, 0x35, 0x62, 0x37, 0x36, 0x32, 0x62, 0x66, 0x62, 0x62, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x66, 0x33, 0x39, 0x62, 0x32, 0x37, 0x35, 0x38, 0x61, 0x65, 0x34, 0x32, 0x32, 0x37, 0x37, 0x62, 0x38, 0x36, 0x64, 0x36, 0x39, 0x66, 0x37, 0x35, 0x65, 0x36, 0x32, 0x38, 0x64, 0x39, 0x35, 0x38, 0x65, 0x62, 0x63, 0x61, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x37, 0x66, 0x35, 0x66, 0x64, 0x63, 0x36, 0x65, 0x63, 0x39, 0x37, 0x64, 0x32, 0x66, 0x38, 0x36, 0x36, 0x61, 0x31, 0x63, 0x66, 0x64, 0x30, 0x64, 0x33, 0x61, 0x34, 0x64, 0x61, 0x34, 0x33, 0x38, 0x37, 0x62, 0x32, 0x32, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x33, 0x33, 0x31, 0x64, 0x66, 0x32, 0x61, 0x33, 0x63, 0x62, 0x65, 0x65, 0x33, 0x35, 0x32, 0x30, 0x65, 0x39, 0x31, 0x31, 0x64, 0x65, 0x61, 0x39, 0x66, 0x37, 0x33, 0x65, 0x39, 0x30, 0x35, 0x66, 0x38, 0x39, 0x32, 0x35, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x35, 0x64, 0x31, 0x36, 0x65, 0x64, 0x36, 0x35, 0x65, 0x33, 0x65, 0x64, 0x37, 0x65, 0x38, 0x62, 0x39, 0x36, 0x63, 0x61, 0x39, 0x37, 0x32, 0x62, 0x63, 0x38, 0x36, 0x31, 0x37, 0x33, 0x65, 0x33, 0x35, 0x30, 0x30, 0x62, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x39, 0x38, 0x34, 0x31, 0x38, 0x36, 0x32, 0x65, 0x37, 0x37, 0x66, 0x62, 0x62, 0x65, 0x39, 0x31, 0x39, 0x34, 0x37, 0x30, 0x39, 0x33, 0x35, 0x35, 0x38, 0x33, 0x61, 0x39, 0x33, 0x63, 0x66, 0x30, 0x32, 0x37, 0x65, 0x34, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x64, 0x64, 0x32, 0x37, 0x66, 0x31, 0x36, 0x62, 0x66, 0x32, 0x32, 0x34, 0x35, 0x30, 0x66, 0x35, 0x37, 0x37, 0x31, 0x62, 0x39, 0x66, 0x65, 0x34, 0x65, 0x64, 0x34, 0x66, 0x66, 0x63, 0x62, 0x33, 0x30, 0x39, 0x33, 0x36, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x63, 0x38, 0x61, 0x31, 0x61, 0x38, 0x39, 0x38, 0x66, 0x31, 0x62, 0x38, 0x39, 0x35, 0x64, 0x38, 0x33, 0x30, 0x31, 0x66, 0x65, 0x36, 0x34, 0x61, 0x62, 0x33, 0x61, 0x64, 0x35, 0x64, 0x65, 0x39, 0x34, 0x31, 0x66, 0x36, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x37, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x63, 0x34, 0x65, 0x65, 0x37, 0x63, 0x38, 0x36, 0x34, 0x63, 0x34, 0x64, 0x36, 0x62, 0x35, 0x65, 0x33, 0x37, 0x65, 0x61, 0x31, 0x33, 0x33, 0x31, 0x63, 0x32, 0x30, 0x33, 0x37, 0x33, 0x39, 0x65, 0x38, 0x32, 0x36, 0x62, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x35, 0x30, 0x65, 0x33, 0x65, 0x38, 0x35, 0x38, 0x63, 0x32, 0x36, 0x61, 0x64, 0x65, 0x63, 0x63, 0x61, 0x64, 0x66, 0x33, 0x36, 0x61, 0x35, 0x36, 0x36, 0x33, 0x63, 0x32, 0x32, 0x61, 0x61, 0x38, 0x34, 0x63, 0x34, 0x31, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x39, 0x65, 0x30, 0x62, 0x63, 0x61, 0x35, 0x35, 0x65, 0x30, 0x36, 0x39, 0x64, 0x65, 0x38, 0x35, 0x30, 0x34, 0x65, 0x38, 0x39, 0x61, 0x63, 0x61, 0x36, 0x65, 0x63, 0x61, 0x32, 0x31, 0x64, 0x33, 0x38, 0x61, 0x39, 0x61, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x30, 0x66, 0x37, 0x66, 0x61, 0x30, 0x33, 0x65, 0x33, 0x38, 0x39, 0x38, 0x37, 0x36, 0x64, 0x33, 0x39, 0x30, 0x38, 0x62, 0x36, 0x30, 0x61, 0x35, 0x33, 0x37, 0x61, 0x36, 0x37, 0x30, 0x36, 0x33, 0x30, 0x34, 0x66, 0x62, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x30, 0x37, 0x33, 0x32, 0x36, 0x39, 0x37, 0x32, 0x39, 0x65, 0x36, 0x34, 0x31, 0x34, 0x62, 0x32, 0x36, 0x65, 0x63, 0x38, 0x64, 0x63, 0x30, 0x66, 0x64, 0x39, 0x33, 0x35, 0x63, 0x37, 0x33, 0x62, 0x35, 0x37, 0x39, 0x66, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x66, 0x63, 0x64, 0x31, 0x33, 0x39, 0x31, 0x65, 0x37, 0x64, 0x37, 0x33, 0x32, 0x66, 0x34, 0x31, 0x37, 0x36, 0x36, 0x63, 0x64, 0x61, 0x63, 0x64, 0x38, 0x34, 0x66, 0x61, 0x31, 0x64, 0x65, 0x62, 0x39, 0x66, 0x66, 0x64, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x33, 0x37, 0x36, 0x38, 0x37, 0x34, 0x36, 0x37, 0x33, 0x37, 0x63, 0x65, 0x36, 0x64, 0x61, 0x33, 0x31, 0x32, 0x64, 0x35, 0x33, 0x65, 0x35, 0x34, 0x35, 0x33, 0x34, 0x65, 0x31, 0x30, 0x36, 0x66, 0x39, 0x36, 0x37, 0x63, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x32, 0x66, 0x37, 0x35, 0x37, 0x30, 0x38, 0x33, 0x38, 0x36, 0x36, 0x35, 0x33, 0x63, 0x38, 0x30, 0x31, 0x37, 0x31, 0x64, 0x30, 0x36, 0x36, 0x33, 0x62, 0x66, 0x65, 0x33, 0x30, 0x62, 0x30, 0x31, 0x37, 0x65, 0x64, 0x30, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x35, 0x62, 0x30, 0x38, 0x36, 0x34, 0x33, 0x37, 0x66, 0x64, 0x32, 0x31, 0x39, 0x32, 0x64, 0x30, 0x61, 0x30, 0x66, 0x36, 0x34, 0x66, 0x36, 0x65, 0x64, 0x30, 0x34, 0x34, 0x66, 0x33, 0x38, 0x65, 0x66, 0x33, 0x64, 0x61, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x39, 0x63, 0x38, 0x62, 0x36, 0x39, 0x66, 0x63, 0x36, 0x31, 0x34, 0x64, 0x36, 0x39, 0x35, 0x36, 0x34, 0x39, 0x39, 0x39, 0x62, 0x30, 0x30, 0x64, 0x63, 0x62, 0x34, 0x32, 0x64, 0x62, 0x36, 0x37, 0x66, 0x39, 0x37, 0x65, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x32, 0x39, 0x32, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x62, 0x37, 0x30, 0x31, 0x66, 0x39, 0x66, 0x35, 0x63, 0x64, 0x64, 0x30, 0x39, 0x65, 0x34, 0x62, 0x61, 0x36, 0x32, 0x62, 0x61, 0x65, 0x62, 0x61, 0x65, 0x33, 0x61, 0x38, 0x38, 0x32, 0x35, 0x37, 0x31, 0x30, 0x35, 0x38, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x37, 0x62, 0x38, 0x63, 0x35, 0x34, 0x64, 0x63, 0x35, 0x37, 0x62, 0x30, 0x34, 0x30, 0x32, 0x30, 0x36, 0x32, 0x37, 0x31, 0x39, 0x64, 0x65, 0x65, 0x37, 0x65, 0x66, 0x35, 0x65, 0x33, 0x37, 0x65, 0x61, 0x33, 0x35, 0x64, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x37, 0x37, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x66, 0x61, 0x62, 0x66, 0x62, 0x63, 0x33, 0x39, 0x30, 0x63, 0x62, 0x65, 0x34, 0x33, 0x63, 0x65, 0x38, 0x39, 0x31, 0x38, 0x38, 0x66, 0x30, 0x38, 0x36, 0x38, 0x62, 0x32, 0x37, 0x64, 0x63, 0x62, 0x30, 0x66, 0x30, 0x63, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x63, 0x64, 0x62, 0x63, 0x34, 0x31, 0x31, 0x35, 0x34, 0x30, 0x36, 0x66, 0x35, 0x32, 0x65, 0x35, 0x61, 0x61, 0x38, 0x35, 0x64, 0x30, 0x66, 0x65, 0x61, 0x31, 0x37, 0x30, 0x64, 0x32, 0x39, 0x37, 0x39, 0x63, 0x63, 0x37, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x33, 0x38, 0x31, 0x34, 0x33, 0x30, 0x39, 0x64, 0x65, 0x34, 0x65, 0x36, 0x33, 0x35, 0x63, 0x66, 0x35, 0x38, 0x35, 0x65, 0x30, 0x64, 0x33, 0x36, 0x35, 0x34, 0x37, 0x37, 0x66, 0x63, 0x34, 0x30, 0x65, 0x36, 0x36, 0x63, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x63, 0x66, 0x66, 0x30, 0x65, 0x39, 0x33, 0x33, 0x36, 0x61, 0x39, 0x66, 0x38, 0x30, 0x66, 0x39, 0x62, 0x31, 0x63, 0x62, 0x39, 0x36, 0x38, 0x63, 0x61, 0x66, 0x36, 0x62, 0x31, 0x64, 0x31, 0x63, 0x34, 0x39, 0x33, 0x32, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x61, 0x39, 0x34, 0x31, 0x63, 0x39, 0x36, 0x31, 0x65, 0x38, 0x63, 0x61, 0x38, 0x62, 0x31, 0x30, 0x37, 0x30, 0x66, 0x32, 0x33, 0x63, 0x36, 0x64, 0x36, 0x64, 0x30, 0x64, 0x32, 0x61, 0x37, 0x35, 0x38, 0x61, 0x34, 0x34, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x37, 0x62, 0x65, 0x62, 0x33, 0x61, 0x34, 0x38, 0x63, 0x34, 0x35, 0x66, 0x31, 0x35, 0x32, 0x38, 0x32, 0x38, 0x34, 0x63, 0x62, 0x36, 0x61, 0x39, 0x35, 0x66, 0x37, 0x64, 0x65, 0x34, 0x35, 0x33, 0x33, 0x35, 0x38, 0x65, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x64, 0x31, 0x33, 0x31, 0x63, 0x37, 0x34, 0x61, 0x30, 0x36, 0x38, 0x61, 0x33, 0x37, 0x63, 0x39, 0x30, 0x61, 0x64, 0x65, 0x64, 0x34, 0x66, 0x33, 0x30, 0x39, 0x63, 0x32, 0x34, 0x30, 0x39, 0x66, 0x36, 0x34, 0x37, 0x38, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x33, 0x36, 0x37, 0x35, 0x62, 0x38, 0x34, 0x32, 0x64, 0x37, 0x64, 0x38, 0x62, 0x34, 0x36, 0x31, 0x66, 0x37, 0x32, 0x32, 0x62, 0x34, 0x31, 0x31, 0x37, 0x63, 0x62, 0x38, 0x31, 0x64, 0x61, 0x63, 0x38, 0x65, 0x36, 0x33, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x31, 0x62, 0x65, 0x39, 0x32, 0x39, 0x39, 0x62, 0x33, 0x65, 0x36, 0x62, 0x33, 0x65, 0x36, 0x33, 0x62, 0x37, 0x39, 0x62, 0x30, 0x39, 0x31, 0x36, 0x39, 0x64, 0x31, 0x61, 0x39, 0x34, 0x38, 0x61, 0x65, 0x36, 0x64, 0x62, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x30, 0x36, 0x37, 0x65, 0x64, 0x33, 0x65, 0x31, 0x32, 0x64, 0x37, 0x31, 0x31, 0x65, 0x64, 0x34, 0x37, 0x35, 0x66, 0x35, 0x31, 0x35, 0x36, 0x65, 0x66, 0x37, 0x65, 0x37, 0x31, 0x61, 0x38, 0x30, 0x64, 0x39, 0x33, 0x34, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x64, 0x39, 0x37, 0x65, 0x61, 0x64, 0x66, 0x63, 0x62, 0x37, 0x62, 0x30, 0x36, 0x34, 0x65, 0x31, 0x63, 0x63, 0x64, 0x39, 0x63, 0x38, 0x39, 0x37, 0x39, 0x66, 0x62, 0x65, 0x65, 0x35, 0x65, 0x37, 0x37, 0x61, 0x39, 0x37, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x36, 0x30, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x34, 0x63, 0x32, 0x61, 0x62, 0x37, 0x64, 0x62, 0x30, 0x32, 0x36, 0x39, 0x33, 0x39, 0x64, 0x62, 0x64, 0x33, 0x62, 0x63, 0x36, 0x38, 0x33, 0x38, 0x34, 0x61, 0x66, 0x36, 0x36, 0x30, 0x61, 0x36, 0x31, 0x38, 0x31, 0x36, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x34, 0x63, 0x37, 0x33, 0x61, 0x37, 0x65, 0x64, 0x65, 0x37, 0x62, 0x31, 0x36, 0x34, 0x66, 0x65, 0x30, 0x37, 0x32, 0x31, 0x31, 0x34, 0x38, 0x34, 0x33, 0x36, 0x35, 0x34, 0x65, 0x34, 0x64, 0x38, 0x37, 0x38, 0x31, 0x64, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x30, 0x34, 0x39, 0x34, 0x33, 0x61, 0x61, 0x66, 0x31, 0x36, 0x37, 0x39, 0x36, 0x65, 0x30, 0x62, 0x33, 0x34, 0x31, 0x62, 0x62, 0x63, 0x64, 0x66, 0x32, 0x31, 0x64, 0x31, 0x31, 0x63, 0x63, 0x35, 0x38, 0x36, 0x63, 0x64, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x38, 0x31, 0x63, 0x61, 0x38, 0x36, 0x33, 0x38, 0x35, 0x34, 0x30, 0x63, 0x64, 0x39, 0x64, 0x34, 0x64, 0x37, 0x33, 0x64, 0x30, 0x36, 0x30, 0x66, 0x32, 0x63, 0x65, 0x62, 0x66, 0x32, 0x32, 0x34, 0x31, 0x66, 0x66, 0x63, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x34, 0x34, 0x66, 0x65, 0x65, 0x39, 0x64, 0x33, 0x34, 0x61, 0x34, 0x61, 0x38, 0x38, 0x30, 0x30, 0x32, 0x33, 0x63, 0x37, 0x38, 0x39, 0x33, 0x32, 0x63, 0x30, 0x30, 0x62, 0x35, 0x39, 0x64, 0x35, 0x63, 0x38, 0x32, 0x61, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x66, 0x34, 0x36, 0x30, 0x61, 0x65, 0x36, 0x34, 0x36, 0x63, 0x64, 0x32, 0x37, 0x38, 0x30, 0x66, 0x64, 0x33, 0x35, 0x63, 0x35, 0x30, 0x61, 0x36, 0x61, 0x66, 0x34, 0x62, 0x39, 0x61, 0x63, 0x63, 0x66, 0x61, 0x38, 0x35, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x32, 0x33, 0x32, 0x64, 0x35, 0x33, 0x62, 0x33, 0x65, 0x36, 0x62, 0x65, 0x38, 0x66, 0x38, 0x39, 0x35, 0x33, 0x36, 0x31, 0x64, 0x33, 0x31, 0x63, 0x33, 0x34, 0x64, 0x34, 0x37, 0x36, 0x32, 0x62, 0x31, 0x32, 0x63, 0x38, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x62, 0x32, 0x61, 0x63, 0x61, 0x32, 0x33, 0x66, 0x61, 0x31, 0x36, 0x32, 0x36, 0x64, 0x31, 0x38, 0x65, 0x66, 0x64, 0x36, 0x37, 0x37, 0x37, 0x66, 0x62, 0x39, 0x37, 0x64, 0x62, 0x30, 0x32, 0x64, 0x38, 0x65, 0x30, 0x61, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x34, 0x65, 0x34, 0x37, 0x31, 0x35, 0x36, 0x30, 0x63, 0x39, 0x39, 0x63, 0x38, 0x61, 0x32, 0x61, 0x34, 0x62, 0x31, 0x62, 0x31, 0x61, 0x64, 0x30, 0x63, 0x33, 0x36, 0x61, 0x61, 0x36, 0x35, 0x30, 0x32, 0x62, 0x37, 0x63, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x32, 0x63, 0x62, 0x64, 0x37, 0x61, 0x64, 0x38, 0x32, 0x35, 0x34, 0x37, 0x62, 0x34, 0x66, 0x35, 0x66, 0x66, 0x38, 0x62, 0x33, 0x61, 0x62, 0x35, 0x36, 0x66, 0x39, 0x34, 0x32, 0x61, 0x36, 0x34, 0x34, 0x35, 0x61, 0x33, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x65, 0x63, 0x62, 0x32, 0x64, 0x66, 0x61, 0x36, 0x35, 0x37, 0x37, 0x39, 0x63, 0x37, 0x35, 0x39, 0x32, 0x64, 0x30, 0x34, 0x31, 0x63, 0x64, 0x32, 0x31, 0x30, 0x35, 0x61, 0x38, 0x31, 0x66, 0x34, 0x66, 0x64, 0x34, 0x65, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x33, 0x31, 0x38, 0x36, 0x32, 0x35, 0x38, 0x31, 0x38, 0x65, 0x63, 0x31, 0x33, 0x66, 0x31, 0x31, 0x38, 0x33, 0x35, 0x61, 0x65, 0x39, 0x37, 0x33, 0x35, 0x33, 0x63, 0x65, 0x33, 0x37, 0x37, 0x64, 0x36, 0x66, 0x35, 0x39, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x65, 0x66, 0x33, 0x35, 0x63, 0x65, 0x38, 0x37, 0x65, 0x64, 0x61, 0x36, 0x63, 0x32, 0x38, 0x64, 0x66, 0x32, 0x34, 0x38, 0x37, 0x38, 0x35, 0x38, 0x31, 0x35, 0x30, 0x35, 0x33, 0x65, 0x63, 0x39, 0x37, 0x61, 0x35, 0x30, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x35, 0x31, 0x34, 0x65, 0x36, 0x32, 0x34, 0x32, 0x66, 0x36, 0x62, 0x36, 0x38, 0x63, 0x31, 0x33, 0x37, 0x65, 0x39, 0x37, 0x66, 0x65, 0x61, 0x31, 0x65, 0x37, 0x38, 0x65, 0x62, 0x35, 0x35, 0x35, 0x61, 0x37, 0x65, 0x35, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x34, 0x30, 0x62, 0x35, 0x66, 0x36, 0x37, 0x38, 0x65, 0x34, 0x35, 0x65, 0x65, 0x30, 0x35, 0x65, 0x62, 0x37, 0x30, 0x38, 0x62, 0x62, 0x37, 0x61, 0x62, 0x62, 0x36, 0x65, 0x63, 0x38, 0x66, 0x30, 0x38, 0x66, 0x31, 0x62, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x63, 0x63, 0x30, 0x38, 0x64, 0x30, 0x37, 0x33, 0x32, 0x61, 0x61, 0x35, 0x38, 0x61, 0x64, 0x65, 0x66, 0x37, 0x36, 0x31, 0x39, 0x62, 0x65, 0x64, 0x34, 0x36, 0x35, 0x35, 0x38, 0x61, 0x64, 0x37, 0x37, 0x37, 0x34, 0x31, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x34, 0x33, 0x39, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x65, 0x39, 0x61, 0x34, 0x61, 0x64, 0x32, 0x61, 0x64, 0x35, 0x37, 0x34, 0x38, 0x34, 0x64, 0x64, 0x37, 0x30, 0x30, 0x35, 0x36, 0x35, 0x62, 0x64, 0x64, 0x62, 0x34, 0x36, 0x34, 0x32, 0x33, 0x62, 0x64, 0x39, 0x62, 0x64, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x62, 0x65, 0x65, 0x62, 0x32, 0x35, 0x39, 0x31, 0x38, 0x34, 0x61, 0x36, 0x65, 0x30, 0x31, 0x63, 0x63, 0x63, 0x66, 0x63, 0x32, 0x32, 0x30, 0x37, 0x62, 0x62, 0x64, 0x38, 0x38, 0x33, 0x37, 0x38, 0x35, 0x61, 0x63, 0x39, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x39, 0x39, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x34, 0x61, 0x62, 0x31, 0x31, 0x35, 0x30, 0x64, 0x35, 0x65, 0x31, 0x30, 0x66, 0x35, 0x65, 0x33, 0x34, 0x39, 0x39, 0x35, 0x30, 0x38, 0x66, 0x30, 0x62, 0x66, 0x37, 0x30, 0x36, 0x35, 0x30, 0x66, 0x30, 0x32, 0x38, 0x64, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x33, 0x36, 0x31, 0x31, 0x30, 0x35, 0x64, 0x64, 0x39, 0x30, 0x66, 0x39, 0x65, 0x64, 0x65, 0x35, 0x36, 0x36, 0x34, 0x39, 0x39, 0x64, 0x36, 0x39, 0x65, 0x39, 0x31, 0x33, 0x30, 0x33, 0x39, 0x35, 0x66, 0x31, 0x32, 0x61, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x62, 0x39, 0x61, 0x35, 0x37, 0x30, 0x34, 0x64, 0x33, 0x35, 0x31, 0x63, 0x66, 0x65, 0x39, 0x38, 0x33, 0x66, 0x37, 0x39, 0x61, 0x62, 0x65, 0x65, 0x63, 0x33, 0x64, 0x62, 0x62, 0x62, 0x61, 0x65, 0x33, 0x62, 0x62, 0x36, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x66, 0x35, 0x30, 0x34, 0x30, 0x36, 0x65, 0x62, 0x31, 0x62, 0x31, 0x31, 0x61, 0x39, 0x34, 0x36, 0x63, 0x61, 0x62, 0x34, 0x35, 0x39, 0x32, 0x37, 0x63, 0x63, 0x61, 0x33, 0x37, 0x34, 0x37, 0x30, 0x65, 0x35, 0x61, 0x32, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x39, 0x34, 0x32, 0x65, 0x37, 0x39, 0x34, 0x39, 0x64, 0x36, 0x37, 0x38, 0x38, 0x62, 0x62, 0x37, 0x38, 0x30, 0x61, 0x37, 0x65, 0x38, 0x61, 0x30, 0x37, 0x39, 0x32, 0x37, 0x38, 0x31, 0x62, 0x31, 0x36, 0x31, 0x34, 0x62, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x62, 0x61, 0x39, 0x61, 0x37, 0x64, 0x30, 0x34, 0x32, 0x33, 0x65, 0x30, 0x33, 0x61, 0x35, 0x32, 0x35, 0x66, 0x65, 0x32, 0x65, 0x62, 0x65, 0x62, 0x36, 0x36, 0x31, 0x64, 0x32, 0x30, 0x38, 0x35, 0x37, 0x37, 0x38, 0x62, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x63, 0x30, 0x33, 0x35, 0x38, 0x61, 0x61, 0x36, 0x34, 0x37, 0x39, 0x64, 0x65, 0x32, 0x31, 0x38, 0x36, 0x36, 0x66, 0x65, 0x32, 0x31, 0x30, 0x37, 0x31, 0x39, 0x32, 0x34, 0x62, 0x36, 0x35, 0x65, 0x37, 0x30, 0x66, 0x38, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x63, 0x62, 0x39, 0x63, 0x38, 0x62, 0x36, 0x39, 0x66, 0x34, 0x33, 0x38, 0x37, 0x36, 0x37, 0x35, 0x63, 0x34, 0x38, 0x32, 0x35, 0x33, 0x65, 0x32, 0x33, 0x34, 0x63, 0x62, 0x37, 0x65, 0x30, 0x64, 0x37, 0x34, 0x61, 0x34, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x39, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x35, 0x66, 0x34, 0x34, 0x30, 0x32, 0x36, 0x62, 0x35, 0x37, 0x36, 0x61, 0x34, 0x61, 0x64, 0x62, 0x34, 0x31, 0x65, 0x39, 0x35, 0x39, 0x36, 0x31, 0x35, 0x36, 0x31, 0x64, 0x34, 0x31, 0x30, 0x33, 0x39, 0x63, 0x61, 0x33, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x33, 0x61, 0x37, 0x33, 0x61, 0x34, 0x61, 0x32, 0x32, 0x32, 0x38, 0x65, 0x65, 0x65, 0x30, 0x35, 0x63, 0x34, 0x66, 0x66, 0x64, 0x37, 0x31, 0x38, 0x62, 0x62, 0x66, 0x33, 0x66, 0x39, 0x63, 0x31, 0x62, 0x31, 0x32, 0x39, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x63, 0x35, 0x32, 0x64, 0x38, 0x66, 0x38, 0x64, 0x39, 0x66, 0x63, 0x37, 0x34, 0x32, 0x61, 0x38, 0x62, 0x38, 0x32, 0x37, 0x36, 0x37, 0x66, 0x30, 0x35, 0x35, 0x35, 0x33, 0x38, 0x37, 0x63, 0x35, 0x36, 0x33, 0x65, 0x66, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x35, 0x36, 0x61, 0x37, 0x35, 0x62, 0x62, 0x39, 0x39, 0x36, 0x35, 0x35, 0x61, 0x37, 0x34, 0x31, 0x32, 0x63, 0x65, 0x39, 0x37, 0x64, 0x61, 0x30, 0x38, 0x31, 0x38, 0x31, 0x36, 0x64, 0x66, 0x64, 0x62, 0x32, 0x62, 0x31, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x63, 0x31, 0x30, 0x31, 0x66, 0x64, 0x31, 0x66, 0x30, 0x31, 0x63, 0x36, 0x33, 0x66, 0x36, 0x62, 0x31, 0x64, 0x31, 0x39, 0x62, 0x63, 0x39, 0x32, 0x30, 0x64, 0x39, 0x66, 0x39, 0x33, 0x32, 0x33, 0x31, 0x34, 0x62, 0x31, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x62, 0x63, 0x32, 0x32, 0x35, 0x30, 0x34, 0x32, 0x61, 0x36, 0x35, 0x39, 0x32, 0x63, 0x66, 0x61, 0x31, 0x33, 0x65, 0x62, 0x65, 0x35, 0x34, 0x65, 0x66, 0x61, 0x34, 0x31, 0x30, 0x34, 0x30, 0x38, 0x37, 0x38, 0x61, 0x35, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x65, 0x65, 0x63, 0x36, 0x65, 0x32, 0x31, 0x37, 0x66, 0x34, 0x64, 0x34, 0x31, 0x61, 0x61, 0x39, 0x32, 0x30, 0x65, 0x34, 0x32, 0x34, 0x62, 0x39, 0x35, 0x32, 0x35, 0x31, 0x39, 0x37, 0x30, 0x34, 0x31, 0x63, 0x64, 0x34, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x32, 0x38, 0x31, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x32, 0x34, 0x37, 0x64, 0x31, 0x38, 0x36, 0x35, 0x31, 0x30, 0x38, 0x30, 0x39, 0x66, 0x37, 0x31, 0x63, 0x66, 0x66, 0x63, 0x34, 0x35, 0x35, 0x39, 0x34, 0x37, 0x31, 0x63, 0x33, 0x39, 0x31, 0x30, 0x38, 0x35, 0x38, 0x31, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x31, 0x35, 0x32, 0x62, 0x32, 0x66, 0x62, 0x38, 0x36, 0x35, 0x39, 0x64, 0x34, 0x33, 0x37, 0x37, 0x36, 0x65, 0x62, 0x62, 0x31, 0x65, 0x38, 0x31, 0x36, 0x37, 0x33, 0x61, 0x61, 0x38, 0x34, 0x31, 0x36, 0x39, 0x62, 0x65, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x34, 0x39, 0x36, 0x64, 0x64, 0x62, 0x32, 0x37, 0x37, 0x39, 0x39, 0x61, 0x32, 0x32, 0x32, 0x34, 0x35, 0x37, 0x64, 0x37, 0x33, 0x39, 0x37, 0x39, 0x31, 0x31, 0x36, 0x37, 0x32, 0x38, 0x65, 0x38, 0x61, 0x31, 0x38, 0x34, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x31, 0x30, 0x33, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x34, 0x30, 0x35, 0x33, 0x62, 0x33, 0x31, 0x64, 0x30, 0x65, 0x65, 0x35, 0x64, 0x62, 0x61, 0x66, 0x62, 0x31, 0x64, 0x30, 0x36, 0x62, 0x64, 0x37, 0x61, 0x63, 0x37, 0x66, 0x66, 0x33, 0x32, 0x32, 0x32, 0x63, 0x34, 0x37, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x37, 0x62, 0x65, 0x61, 0x34, 0x65, 0x66, 0x33, 0x66, 0x37, 0x33, 0x61, 0x65, 0x30, 0x32, 0x33, 0x33, 0x64, 0x66, 0x31, 0x65, 0x31, 0x30, 0x30, 0x37, 0x31, 0x38, 0x63, 0x62, 0x65, 0x32, 0x39, 0x33, 0x31, 0x30, 0x62, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x33, 0x36, 0x65, 0x32, 0x34, 0x61, 0x36, 0x66, 0x63, 0x66, 0x32, 0x39, 0x39, 0x34, 0x33, 0x62, 0x33, 0x36, 0x30, 0x38, 0x65, 0x36, 0x36, 0x32, 0x32, 0x39, 0x30, 0x61, 0x32, 0x31, 0x35, 0x66, 0x36, 0x35, 0x32, 0x39, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x36, 0x35, 0x33, 0x36, 0x31, 0x63, 0x32, 0x65, 0x63, 0x32, 0x66, 0x38, 0x33, 0x36, 0x31, 0x36, 0x63, 0x65, 0x38, 0x33, 0x36, 0x33, 0x61, 0x61, 0x65, 0x32, 0x31, 0x30, 0x32, 0x35, 0x66, 0x32, 0x35, 0x36, 0x36, 0x66, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x65, 0x36, 0x63, 0x33, 0x32, 0x32, 0x32, 0x62, 0x36, 0x62, 0x36, 0x66, 0x39, 0x62, 0x65, 0x32, 0x38, 0x37, 0x35, 0x64, 0x32, 0x61, 0x38, 0x39, 0x66, 0x31, 0x32, 0x37, 0x66, 0x62, 0x36, 0x34, 0x31, 0x30, 0x30, 0x66, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x62, 0x62, 0x63, 0x31, 0x34, 0x66, 0x36, 0x37, 0x61, 0x66, 0x30, 0x36, 0x33, 0x39, 0x61, 0x61, 0x62, 0x31, 0x34, 0x34, 0x31, 0x65, 0x36, 0x61, 0x30, 0x38, 0x64, 0x34, 0x63, 0x65, 0x37, 0x31, 0x36, 0x32, 0x30, 0x39, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x32, 0x30, 0x35, 0x38, 0x63, 0x37, 0x32, 0x38, 0x32, 0x63, 0x66, 0x36, 0x37, 0x63, 0x38, 0x63, 0x33, 0x63, 0x66, 0x39, 0x33, 0x30, 0x31, 0x33, 0x33, 0x63, 0x38, 0x39, 0x36, 0x31, 0x37, 0x63, 0x65, 0x37, 0x35, 0x64, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x34, 0x64, 0x39, 0x63, 0x38, 0x39, 0x63, 0x63, 0x65, 0x34, 0x38, 0x34, 0x64, 0x66, 0x30, 0x30, 0x30, 0x32, 0x37, 0x37, 0x31, 0x39, 0x38, 0x65, 0x64, 0x38, 0x30, 0x37, 0x35, 0x66, 0x61, 0x36, 0x33, 0x35, 0x37, 0x32, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x63, 0x64, 0x39, 0x37, 0x65, 0x39, 0x33, 0x37, 0x38, 0x62, 0x35, 0x63, 0x66, 0x31, 0x38, 0x66, 0x31, 0x37, 0x33, 0x39, 0x36, 0x33, 0x32, 0x33, 0x36, 0x63, 0x39, 0x39, 0x35, 0x31, 0x65, 0x66, 0x37, 0x34, 0x33, 0x38, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x34, 0x37, 0x62, 0x64, 0x33, 0x30, 0x63, 0x66, 0x61, 0x38, 0x65, 0x63, 0x35, 0x34, 0x36, 0x38, 0x61, 0x61, 0x61, 0x36, 0x61, 0x39, 0x34, 0x36, 0x34, 0x32, 0x63, 0x65, 0x64, 0x39, 0x63, 0x38, 0x31, 0x39, 0x63, 0x38, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x31, 0x30, 0x66, 0x38, 0x66, 0x38, 0x62, 0x33, 0x65, 0x33, 0x62, 0x36, 0x30, 0x64, 0x65, 0x39, 0x30, 0x61, 0x61, 0x31, 0x32, 0x64, 0x31, 0x35, 0x35, 0x66, 0x39, 0x66, 0x66, 0x35, 0x66, 0x66, 0x62, 0x32, 0x32, 0x63, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x62, 0x37, 0x61, 0x39, 0x38, 0x38, 0x64, 0x31, 0x33, 0x66, 0x66, 0x38, 0x39, 0x31, 0x38, 0x36, 0x37, 0x33, 0x36, 0x66, 0x30, 0x33, 0x66, 0x64, 0x66, 0x34, 0x36, 0x31, 0x37, 0x35, 0x62, 0x35, 0x33, 0x64, 0x31, 0x36, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x66, 0x61, 0x66, 0x65, 0x39, 0x37, 0x62, 0x31, 0x64, 0x64, 0x31, 0x64, 0x37, 0x31, 0x32, 0x62, 0x65, 0x38, 0x36, 0x64, 0x34, 0x31, 0x64, 0x66, 0x37, 0x39, 0x38, 0x39, 0x35, 0x33, 0x34, 0x35, 0x38, 0x37, 0x35, 0x61, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x36, 0x63, 0x64, 0x31, 0x66, 0x33, 0x39, 0x36, 0x33, 0x39, 0x36, 0x63, 0x30, 0x61, 0x36, 0x34, 0x34, 0x36, 0x34, 0x36, 0x35, 0x31, 0x64, 0x37, 0x63, 0x32, 0x30, 0x35, 0x65, 0x66, 0x61, 0x66, 0x33, 0x38, 0x37, 0x63, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x30, 0x30, 0x39, 0x36, 0x62, 0x32, 0x31, 0x65, 0x39, 0x35, 0x61, 0x63, 0x62, 0x38, 0x64, 0x36, 0x31, 0x39, 0x64, 0x31, 0x37, 0x36, 0x61, 0x34, 0x61, 0x31, 0x64, 0x38, 0x64, 0x35, 0x32, 0x39, 0x62, 0x61, 0x64, 0x62, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x34, 0x34, 0x34, 0x34, 0x66, 0x39, 0x30, 0x66, 0x62, 0x62, 0x35, 0x34, 0x65, 0x35, 0x36, 0x66, 0x33, 0x61, 0x63, 0x39, 0x62, 0x36, 0x63, 0x66, 0x63, 0x63, 0x61, 0x61, 0x34, 0x38, 0x31, 0x39, 0x65, 0x34, 0x36, 0x31, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x31, 0x35, 0x62, 0x33, 0x35, 0x31, 0x31, 0x64, 0x66, 0x36, 0x66, 0x30, 0x33, 0x34, 0x32, 0x65, 0x37, 0x33, 0x34, 0x38, 0x63, 0x63, 0x38, 0x39, 0x61, 0x66, 0x33, 0x39, 0x61, 0x31, 0x36, 0x38, 0x62, 0x37, 0x37, 0x33, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x36, 0x66, 0x66, 0x38, 0x32, 0x63, 0x39, 0x33, 0x37, 0x37, 0x30, 0x35, 0x39, 0x66, 0x62, 0x33, 0x30, 0x64, 0x39, 0x32, 0x31, 0x35, 0x37, 0x32, 0x33, 0x66, 0x36, 0x30, 0x63, 0x37, 0x37, 0x35, 0x63, 0x38, 0x39, 0x31, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x32, 0x34, 0x61, 0x38, 0x63, 0x63, 0x63, 0x63, 0x34, 0x39, 0x35, 0x31, 0x38, 0x64, 0x31, 0x37, 0x30, 0x61, 0x33, 0x32, 0x38, 0x32, 0x37, 0x30, 0x61, 0x32, 0x66, 0x38, 0x38, 0x31, 0x33, 0x33, 0x66, 0x62, 0x61, 0x66, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x37, 0x61, 0x30, 0x36, 0x62, 0x65, 0x31, 0x39, 0x39, 0x61, 0x33, 0x61, 0x35, 0x38, 0x30, 0x31, 0x39, 0x64, 0x38, 0x34, 0x36, 0x61, 0x63, 0x39, 0x63, 0x62, 0x64, 0x34, 0x64, 0x39, 0x35, 0x64, 0x64, 0x37, 0x35, 0x37, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x34, 0x34, 0x61, 0x63, 0x37, 0x65, 0x35, 0x33, 0x31, 0x30, 0x62, 0x65, 0x36, 0x39, 0x36, 0x61, 0x36, 0x33, 0x62, 0x30, 0x30, 0x33, 0x63, 0x34, 0x30, 0x62, 0x64, 0x30, 0x33, 0x39, 0x33, 0x37, 0x30, 0x35, 0x36, 0x31, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x33, 0x36, 0x32, 0x36, 0x38, 0x38, 0x38, 0x34, 0x35, 0x66, 0x61, 0x32, 0x34, 0x34, 0x63, 0x63, 0x38, 0x30, 0x37, 0x65, 0x34, 0x62, 0x31, 0x31, 0x33, 0x30, 0x65, 0x62, 0x33, 0x37, 0x34, 0x31, 0x61, 0x38, 0x30, 0x35, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x64, 0x30, 0x33, 0x36, 0x30, 0x35, 0x31, 0x35, 0x66, 0x31, 0x37, 0x64, 0x61, 0x62, 0x61, 0x39, 0x30, 0x66, 0x63, 0x62, 0x61, 0x63, 0x38, 0x32, 0x30, 0x35, 0x64, 0x35, 0x36, 0x39, 0x62, 0x39, 0x31, 0x35, 0x64, 0x36, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x33, 0x35, 0x39, 0x34, 0x63, 0x37, 0x63, 0x66, 0x62, 0x32, 0x61, 0x30, 0x38, 0x66, 0x32, 0x38, 0x34, 0x63, 0x63, 0x39, 0x64, 0x37, 0x61, 0x36, 0x33, 0x62, 0x62, 0x64, 0x66, 0x63, 0x30, 0x62, 0x33, 0x31, 0x39, 0x37, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x63, 0x32, 0x32, 0x38, 0x37, 0x33, 0x31, 0x64, 0x31, 0x38, 0x36, 0x64, 0x32, 0x64, 0x65, 0x64, 0x35, 0x62, 0x35, 0x66, 0x62, 0x65, 0x30, 0x30, 0x34, 0x63, 0x36, 0x36, 0x36, 0x63, 0x38, 0x65, 0x34, 0x36, 0x39, 0x62, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x65, 0x34, 0x31, 0x34, 0x36, 0x30, 0x33, 0x65, 0x38, 0x30, 0x64, 0x34, 0x65, 0x35, 0x61, 0x30, 0x66, 0x35, 0x63, 0x31, 0x38, 0x37, 0x37, 0x34, 0x32, 0x30, 0x34, 0x36, 0x34, 0x32, 0x32, 0x35, 0x38, 0x32, 0x30, 0x38, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x36, 0x63, 0x65, 0x35, 0x37, 0x39, 0x30, 0x35, 0x33, 0x32, 0x65, 0x30, 0x35, 0x34, 0x38, 0x63, 0x36, 0x31, 0x30, 0x32, 0x61, 0x33, 0x30, 0x64, 0x33, 0x65, 0x61, 0x63, 0x38, 0x33, 0x36, 0x62, 0x64, 0x36, 0x33, 0x38, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x65, 0x38, 0x31, 0x32, 0x66, 0x37, 0x36, 0x66, 0x31, 0x35, 0x66, 0x32, 0x65, 0x31, 0x66, 0x32, 0x66, 0x39, 0x62, 0x63, 0x34, 0x38, 0x32, 0x33, 0x34, 0x38, 0x33, 0x63, 0x38, 0x38, 0x30, 0x34, 0x36, 0x33, 0x36, 0x66, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x36, 0x66, 0x65, 0x66, 0x35, 0x65, 0x36, 0x30, 0x31, 0x36, 0x34, 0x32, 0x63, 0x39, 0x31, 0x38, 0x63, 0x62, 0x38, 0x39, 0x31, 0x36, 0x30, 0x66, 0x63, 0x32, 0x32, 0x39, 0x33, 0x62, 0x61, 0x37, 0x31, 0x64, 0x61, 0x39, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x62, 0x38, 0x34, 0x35, 0x33, 0x36, 0x62, 0x37, 0x34, 0x63, 0x38, 0x63, 0x30, 0x31, 0x35, 0x34, 0x33, 0x64, 0x61, 0x38, 0x38, 0x62, 0x38, 0x34, 0x64, 0x37, 0x38, 0x62, 0x62, 0x39, 0x35, 0x37, 0x34, 0x37, 0x64, 0x38, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x61, 0x38, 0x30, 0x61, 0x66, 0x61, 0x64, 0x35, 0x33, 0x65, 0x66, 0x31, 0x66, 0x38, 0x34, 0x31, 0x36, 0x35, 0x63, 0x66, 0x64, 0x38, 0x35, 0x32, 0x62, 0x30, 0x66, 0x64, 0x66, 0x31, 0x62, 0x31, 0x63, 0x32, 0x34, 0x62, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x30, 0x33, 0x36, 0x32, 0x36, 0x33, 0x33, 0x36, 0x31, 0x34, 0x62, 0x66, 0x63, 0x62, 0x35, 0x38, 0x33, 0x35, 0x36, 0x39, 0x34, 0x33, 0x38, 0x65, 0x63, 0x63, 0x34, 0x65, 0x61, 0x35, 0x37, 0x62, 0x31, 0x64, 0x33, 0x33, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x35, 0x31, 0x37, 0x39, 0x35, 0x32, 0x37, 0x64, 0x65, 0x63, 0x61, 0x35, 0x39, 0x31, 0x36, 0x63, 0x61, 0x39, 0x61, 0x33, 0x38, 0x66, 0x32, 0x31, 0x35, 0x63, 0x31, 0x65, 0x39, 0x63, 0x65, 0x37, 0x33, 0x37, 0x62, 0x34, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x35, 0x64, 0x66, 0x38, 0x36, 0x36, 0x36, 0x36, 0x36, 0x61, 0x31, 0x39, 0x34, 0x62, 0x32, 0x36, 0x63, 0x65, 0x62, 0x62, 0x34, 0x30, 0x37, 0x65, 0x34, 0x61, 0x31, 0x66, 0x64, 0x37, 0x33, 0x65, 0x32, 0x30, 0x38, 0x64, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x39, 0x65, 0x38, 0x32, 0x34, 0x66, 0x61, 0x30, 0x37, 0x32, 0x35, 0x38, 0x32, 0x62, 0x34, 0x30, 0x33, 0x32, 0x36, 0x38, 0x33, 0x61, 0x63, 0x37, 0x65, 0x65, 0x63, 0x63, 0x31, 0x63, 0x30, 0x34, 0x62, 0x34, 0x63, 0x61, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x36, 0x33, 0x34, 0x33, 0x37, 0x31, 0x65, 0x31, 0x37, 0x33, 0x30, 0x34, 0x63, 0x62, 0x66, 0x33, 0x33, 0x39, 0x62, 0x31, 0x34, 0x35, 0x32, 0x61, 0x34, 0x63, 0x65, 0x34, 0x33, 0x38, 0x64, 0x63, 0x37, 0x36, 0x34, 0x63, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x37, 0x32, 0x64, 0x66, 0x63, 0x38, 0x66, 0x38, 0x30, 0x63, 0x64, 0x31, 0x66, 0x38, 0x63, 0x64, 0x38, 0x35, 0x33, 0x39, 0x64, 0x63, 0x32, 0x36, 0x30, 0x38, 0x32, 0x30, 0x31, 0x34, 0x66, 0x35, 0x61, 0x38, 0x65, 0x33, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x37, 0x36, 0x31, 0x38, 0x33, 0x32, 0x38, 0x61, 0x39, 0x30, 0x31, 0x33, 0x30, 0x37, 0x61, 0x31, 0x62, 0x37, 0x61, 0x30, 0x64, 0x30, 0x35, 0x38, 0x66, 0x63, 0x64, 0x35, 0x37, 0x38, 0x36, 0x65, 0x39, 0x65, 0x37, 0x32, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x32, 0x33, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x35, 0x37, 0x31, 0x31, 0x35, 0x33, 0x64, 0x62, 0x31, 0x63, 0x34, 0x65, 0x64, 0x37, 0x61, 0x63, 0x61, 0x65, 0x66, 0x65, 0x31, 0x33, 0x65, 0x63, 0x64, 0x66, 0x64, 0x62, 0x37, 0x32, 0x65, 0x37, 0x65, 0x34, 0x66, 0x30, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x39, 0x31, 0x30, 0x61, 0x32, 0x33, 0x64, 0x36, 0x38, 0x35, 0x30, 0x36, 0x31, 0x33, 0x36, 0x35, 0x34, 0x61, 0x66, 0x37, 0x38, 0x36, 0x33, 0x33, 0x37, 0x61, 0x64, 0x32, 0x61, 0x37, 0x30, 0x38, 0x36, 0x38, 0x61, 0x63, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x61, 0x35, 0x65, 0x64, 0x63, 0x36, 0x38, 0x38, 0x62, 0x30, 0x63, 0x62, 0x36, 0x32, 0x65, 0x31, 0x34, 0x30, 0x33, 0x64, 0x31, 0x37, 0x30, 0x30, 0x64, 0x39, 0x64, 0x63, 0x62, 0x39, 0x39, 0x66, 0x66, 0x65, 0x33, 0x66, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x32, 0x34, 0x37, 0x31, 0x61, 0x36, 0x37, 0x66, 0x36, 0x30, 0x34, 0x37, 0x39, 0x31, 0x38, 0x37, 0x37, 0x32, 0x64, 0x30, 0x65, 0x33, 0x36, 0x38, 0x33, 0x39, 0x32, 0x35, 0x35, 0x65, 0x64, 0x39, 0x64, 0x36, 0x39, 0x31, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x38, 0x36, 0x38, 0x33, 0x32, 0x34, 0x33, 0x33, 0x37, 0x65, 0x31, 0x31, 0x62, 0x61, 0x31, 0x30, 0x36, 0x63, 0x62, 0x34, 0x38, 0x31, 0x64, 0x61, 0x39, 0x36, 0x32, 0x66, 0x33, 0x61, 0x38, 0x34, 0x35, 0x33, 0x38, 0x30, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x66, 0x39, 0x34, 0x35, 0x37, 0x39, 0x34, 0x39, 0x36, 0x37, 0x32, 0x35, 0x62, 0x35, 0x63, 0x62, 0x35, 0x33, 0x64, 0x37, 0x39, 0x38, 0x35, 0x63, 0x39, 0x38, 0x39, 0x37, 0x34, 0x39, 0x61, 0x66, 0x66, 0x38, 0x34, 0x39, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x38, 0x31, 0x63, 0x35, 0x66, 0x66, 0x36, 0x36, 0x63, 0x63, 0x34, 0x65, 0x39, 0x36, 0x38, 0x30, 0x32, 0x35, 0x31, 0x66, 0x63, 0x34, 0x63, 0x64, 0x32, 0x66, 0x66, 0x39, 0x30, 0x37, 0x63, 0x62, 0x33, 0x32, 0x37, 0x38, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x32, 0x38, 0x37, 0x32, 0x64, 0x31, 0x39, 0x65, 0x35, 0x37, 0x38, 0x35, 0x33, 0x63, 0x66, 0x61, 0x31, 0x36, 0x65, 0x66, 0x66, 0x65, 0x39, 0x33, 0x64, 0x30, 0x62, 0x31, 0x64, 0x34, 0x37, 0x62, 0x34, 0x66, 0x39, 0x33, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x63, 0x38, 0x64, 0x66, 0x64, 0x65, 0x30, 0x62, 0x38, 0x65, 0x30, 0x31, 0x64, 0x61, 0x64, 0x63, 0x32, 0x65, 0x37, 0x34, 0x38, 0x63, 0x38, 0x32, 0x34, 0x63, 0x63, 0x30, 0x33, 0x36, 0x39, 0x64, 0x66, 0x30, 0x39, 0x30, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x64, 0x64, 0x30, 0x34, 0x38, 0x62, 0x66, 0x62, 0x38, 0x34, 0x30, 0x65, 0x32, 0x62, 0x63, 0x38, 0x35, 0x63, 0x62, 0x35, 0x33, 0x66, 0x63, 0x62, 0x37, 0x35, 0x61, 0x62, 0x63, 0x34, 0x34, 0x33, 0x63, 0x37, 0x65, 0x39, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x37, 0x39, 0x37, 0x31, 0x34, 0x61, 0x34, 0x35, 0x65, 0x62, 0x38, 0x66, 0x35, 0x32, 0x63, 0x33, 0x64, 0x35, 0x37, 0x62, 0x62, 0x64, 0x65, 0x66, 0x64, 0x32, 0x63, 0x31, 0x35, 0x62, 0x32, 0x65, 0x32, 0x66, 0x31, 0x31, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x37, 0x62, 0x30, 0x34, 0x38, 0x31, 0x63, 0x63, 0x33, 0x32, 0x65, 0x36, 0x66, 0x61, 0x65, 0x66, 0x32, 0x33, 0x38, 0x36, 0x61, 0x30, 0x37, 0x30, 0x32, 0x32, 0x62, 0x63, 0x62, 0x36, 0x64, 0x32, 0x63, 0x33, 0x62, 0x34, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x61, 0x61, 0x35, 0x66, 0x30, 0x32, 0x30, 0x31, 0x66, 0x30, 0x34, 0x64, 0x33, 0x62, 0x62, 0x65, 0x62, 0x38, 0x39, 0x38, 0x31, 0x33, 0x32, 0x66, 0x37, 0x63, 0x31, 0x31, 0x36, 0x37, 0x39, 0x34, 0x36, 0x36, 0x64, 0x39, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x64, 0x66, 0x36, 0x33, 0x61, 0x39, 0x37, 0x31, 0x39, 0x39, 0x39, 0x33, 0x33, 0x33, 0x33, 0x30, 0x33, 0x38, 0x33, 0x62, 0x33, 0x65, 0x64, 0x37, 0x35, 0x37, 0x30, 0x62, 0x39, 0x36, 0x63, 0x34, 0x38, 0x31, 0x32, 0x33, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x37, 0x33, 0x32, 0x64, 0x38, 0x65, 0x66, 0x34, 0x39, 0x66, 0x66, 0x64, 0x61, 0x30, 0x34, 0x62, 0x31, 0x39, 0x37, 0x38, 0x30, 0x66, 0x64, 0x33, 0x63, 0x31, 0x38, 0x34, 0x36, 0x39, 0x66, 0x62, 0x33, 0x37, 0x34, 0x31, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x35, 0x30, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x39, 0x32, 0x64, 0x36, 0x65, 0x34, 0x35, 0x34, 0x38, 0x63, 0x37, 0x38, 0x39, 0x39, 0x36, 0x35, 0x30, 0x39, 0x65, 0x65, 0x36, 0x38, 0x34, 0x62, 0x32, 0x65, 0x65, 0x32, 0x39, 0x62, 0x61, 0x33, 0x63, 0x35, 0x33, 0x32, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x66, 0x34, 0x62, 0x61, 0x64, 0x35, 0x39, 0x36, 0x36, 0x33, 0x33, 0x34, 0x37, 0x39, 0x61, 0x32, 0x61, 0x32, 0x39, 0x66, 0x39, 0x61, 0x38, 0x62, 0x33, 0x66, 0x37, 0x38, 0x65, 0x65, 0x66, 0x64, 0x30, 0x37, 0x65, 0x36, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x34, 0x34, 0x36, 0x30, 0x61, 0x37, 0x36, 0x65, 0x36, 0x64, 0x62, 0x32, 0x62, 0x39, 0x66, 0x63, 0x64, 0x31, 0x35, 0x32, 0x64, 0x39, 0x63, 0x37, 0x37, 0x31, 0x38, 0x64, 0x39, 0x61, 0x63, 0x36, 0x65, 0x64, 0x38, 0x63, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x33, 0x62, 0x36, 0x62, 0x31, 0x63, 0x35, 0x37, 0x30, 0x35, 0x30, 0x65, 0x38, 0x38, 0x63, 0x66, 0x30, 0x63, 0x33, 0x31, 0x30, 0x36, 0x37, 0x62, 0x38, 0x64, 0x34, 0x63, 0x64, 0x31, 0x66, 0x66, 0x38, 0x30, 0x63, 0x62, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x62, 0x36, 0x62, 0x36, 0x61, 0x64, 0x62, 0x65, 0x32, 0x66, 0x35, 0x62, 0x33, 0x65, 0x32, 0x64, 0x36, 0x38, 0x32, 0x63, 0x36, 0x36, 0x61, 0x66, 0x31, 0x62, 0x63, 0x34, 0x39, 0x30, 0x35, 0x33, 0x34, 0x30, 0x63, 0x33, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x39, 0x33, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x34, 0x61, 0x37, 0x31, 0x39, 0x35, 0x61, 0x63, 0x37, 0x63, 0x31, 0x35, 0x31, 0x63, 0x61, 0x32, 0x35, 0x38, 0x63, 0x61, 0x66, 0x64, 0x61, 0x30, 0x63, 0x61, 0x62, 0x30, 0x38, 0x33, 0x65, 0x30, 0x34, 0x39, 0x63, 0x36, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x33, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x35, 0x35, 0x63, 0x33, 0x35, 0x37, 0x66, 0x64, 0x38, 0x66, 0x37, 0x35, 0x64, 0x35, 0x31, 0x35, 0x39, 0x61, 0x33, 0x64, 0x66, 0x61, 0x36, 0x39, 0x63, 0x35, 0x62, 0x38, 0x37, 0x61, 0x33, 0x35, 0x39, 0x64, 0x65, 0x61, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x64, 0x37, 0x38, 0x34, 0x34, 0x61, 0x34, 0x37, 0x31, 0x65, 0x66, 0x38, 0x39, 0x61, 0x38, 0x64, 0x38, 0x37, 0x37, 0x35, 0x35, 0x35, 0x35, 0x38, 0x33, 0x63, 0x65, 0x65, 0x62, 0x64, 0x31, 0x34, 0x33, 0x39, 0x65, 0x61, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x62, 0x34, 0x35, 0x34, 0x34, 0x31, 0x36, 0x65, 0x39, 0x66, 0x62, 0x34, 0x32, 0x37, 0x34, 0x65, 0x36, 0x61, 0x64, 0x64, 0x66, 0x38, 0x35, 0x33, 0x34, 0x32, 0x38, 0x61, 0x30, 0x31, 0x39, 0x38, 0x64, 0x36, 0x32, 0x65, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x38, 0x64, 0x64, 0x32, 0x31, 0x63, 0x65, 0x62, 0x65, 0x37, 0x35, 0x35, 0x31, 0x32, 0x36, 0x37, 0x30, 0x34, 0x62, 0x34, 0x38, 0x63, 0x30, 0x66, 0x30, 0x64, 0x63, 0x32, 0x33, 0x34, 0x63, 0x36, 0x30, 0x62, 0x61, 0x39, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x31, 0x64, 0x62, 0x34, 0x63, 0x38, 0x34, 0x36, 0x35, 0x64, 0x66, 0x34, 0x34, 0x36, 0x61, 0x34, 0x63, 0x65, 0x31, 0x35, 0x62, 0x66, 0x38, 0x31, 0x64, 0x34, 0x37, 0x65, 0x32, 0x66, 0x31, 0x37, 0x63, 0x39, 0x38, 0x30, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x62, 0x63, 0x34, 0x65, 0x32, 0x35, 0x33, 0x62, 0x30, 0x38, 0x30, 0x61, 0x65, 0x62, 0x34, 0x33, 0x37, 0x39, 0x38, 0x34, 0x61, 0x62, 0x30, 0x35, 0x62, 0x63, 0x61, 0x30, 0x39, 0x37, 0x39, 0x61, 0x61, 0x34, 0x33, 0x65, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x65, 0x33, 0x35, 0x62, 0x31, 0x32, 0x32, 0x33, 0x31, 0x66, 0x31, 0x39, 0x63, 0x33, 0x66, 0x64, 0x37, 0x37, 0x34, 0x63, 0x38, 0x38, 0x66, 0x65, 0x63, 0x38, 0x63, 0x62, 0x65, 0x65, 0x64, 0x66, 0x31, 0x34, 0x30, 0x38, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x65, 0x32, 0x65, 0x32, 0x65, 0x37, 0x30, 0x34, 0x33, 0x30, 0x37, 0x63, 0x63, 0x63, 0x35, 0x62, 0x35, 0x63, 0x61, 0x33, 0x66, 0x31, 0x36, 0x34, 0x66, 0x65, 0x63, 0x65, 0x32, 0x65, 0x61, 0x37, 0x62, 0x32, 0x65, 0x35, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x31, 0x34, 0x66, 0x31, 0x65, 0x62, 0x39, 0x35, 0x64, 0x31, 0x32, 0x37, 0x37, 0x65, 0x39, 0x33, 0x62, 0x36, 0x65, 0x36, 0x31, 0x62, 0x36, 0x36, 0x38, 0x62, 0x37, 0x64, 0x37, 0x37, 0x66, 0x31, 0x33, 0x61, 0x31, 0x31, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x65, 0x31, 0x33, 0x30, 0x32, 0x33, 0x62, 0x64, 0x39, 0x63, 0x61, 0x39, 0x36, 0x61, 0x64, 0x34, 0x63, 0x35, 0x33, 0x66, 0x64, 0x66, 0x64, 0x34, 0x31, 0x30, 0x63, 0x62, 0x36, 0x62, 0x31, 0x66, 0x34, 0x32, 0x30, 0x62, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x32, 0x32, 0x34, 0x66, 0x33, 0x32, 0x66, 0x34, 0x65, 0x63, 0x65, 0x35, 0x63, 0x38, 0x38, 0x36, 0x37, 0x30, 0x39, 0x30, 0x64, 0x34, 0x34, 0x30, 0x39, 0x64, 0x35, 0x35, 0x65, 0x35, 0x30, 0x62, 0x31, 0x38, 0x34, 0x33, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x38, 0x33, 0x38, 0x35, 0x35, 0x30, 0x35, 0x31, 0x65, 0x65, 0x38, 0x66, 0x66, 0x62, 0x37, 0x30, 0x62, 0x34, 0x38, 0x31, 0x37, 0x64, 0x62, 0x61, 0x33, 0x32, 0x31, 0x31, 0x65, 0x64, 0x32, 0x33, 0x35, 0x35, 0x38, 0x36, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x33, 0x39, 0x31, 0x38, 0x39, 0x61, 0x66, 0x38, 0x37, 0x36, 0x65, 0x37, 0x36, 0x32, 0x63, 0x37, 0x31, 0x64, 0x36, 0x63, 0x33, 0x65, 0x37, 0x34, 0x31, 0x38, 0x39, 0x33, 0x64, 0x66, 0x32, 0x32, 0x36, 0x63, 0x65, 0x64, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x37, 0x35, 0x36, 0x32, 0x33, 0x34, 0x39, 0x35, 0x61, 0x34, 0x36, 0x63, 0x64, 0x62, 0x66, 0x32, 0x35, 0x39, 0x35, 0x33, 0x30, 0x66, 0x66, 0x38, 0x33, 0x38, 0x61, 0x31, 0x37, 0x39, 0x39, 0x65, 0x63, 0x33, 0x38, 0x39, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x62, 0x33, 0x39, 0x62, 0x38, 0x38, 0x64, 0x39, 0x39, 0x30, 0x30, 0x64, 0x62, 0x63, 0x34, 0x61, 0x36, 0x63, 0x64, 0x63, 0x34, 0x38, 0x31, 0x65, 0x31, 0x30, 0x36, 0x30, 0x30, 0x38, 0x30, 0x61, 0x38, 0x61, 0x65, 0x63, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x61, 0x66, 0x36, 0x64, 0x37, 0x34, 0x39, 0x36, 0x32, 0x30, 0x38, 0x30, 0x33, 0x65, 0x38, 0x33, 0x34, 0x38, 0x61, 0x66, 0x33, 0x37, 0x31, 0x30, 0x65, 0x35, 0x63, 0x34, 0x66, 0x62, 0x66, 0x32, 0x30, 0x66, 0x63, 0x38, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x33, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x35, 0x34, 0x65, 0x34, 0x65, 0x64, 0x34, 0x37, 0x39, 0x61, 0x38, 0x35, 0x36, 0x38, 0x32, 0x39, 0x63, 0x36, 0x62, 0x62, 0x34, 0x32, 0x64, 0x61, 0x39, 0x66, 0x30, 0x62, 0x36, 0x39, 0x32, 0x61, 0x37, 0x35, 0x66, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x36, 0x61, 0x36, 0x63, 0x38, 0x35, 0x38, 0x33, 0x61, 0x38, 0x34, 0x34, 0x38, 0x34, 0x65, 0x33, 0x64, 0x66, 0x34, 0x33, 0x61, 0x31, 0x32, 0x33, 0x38, 0x33, 0x37, 0x66, 0x38, 0x63, 0x37, 0x65, 0x32, 0x33, 0x31, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x33, 0x33, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x33, 0x35, 0x64, 0x31, 0x35, 0x63, 0x62, 0x35, 0x65, 0x63, 0x65, 0x65, 0x62, 0x62, 0x36, 0x31, 0x32, 0x39, 0x39, 0x65, 0x30, 0x65, 0x38, 0x32, 0x37, 0x66, 0x61, 0x38, 0x32, 0x37, 0x34, 0x38, 0x39, 0x31, 0x31, 0x64, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x64, 0x37, 0x39, 0x32, 0x61, 0x37, 0x35, 0x36, 0x37, 0x37, 0x39, 0x61, 0x65, 0x64, 0x66, 0x31, 0x33, 0x34, 0x33, 0x65, 0x38, 0x38, 0x38, 0x33, 0x61, 0x36, 0x36, 0x31, 0x39, 0x63, 0x36, 0x63, 0x32, 0x38, 0x31, 0x31, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x63, 0x32, 0x31, 0x33, 0x34, 0x38, 0x38, 0x61, 0x30, 0x32, 0x30, 0x63, 0x33, 0x63, 0x66, 0x62, 0x33, 0x39, 0x30, 0x31, 0x34, 0x65, 0x66, 0x35, 0x62, 0x61, 0x36, 0x34, 0x30, 0x34, 0x37, 0x32, 0x34, 0x62, 0x63, 0x61, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x33, 0x63, 0x34, 0x39, 0x30, 0x66, 0x61, 0x35, 0x62, 0x66, 0x37, 0x66, 0x33, 0x37, 0x32, 0x38, 0x38, 0x38, 0x65, 0x36, 0x30, 0x37, 0x64, 0x39, 0x35, 0x38, 0x66, 0x61, 0x62, 0x37, 0x66, 0x39, 0x35, 0x35, 0x62, 0x61, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x65, 0x31, 0x39, 0x34, 0x36, 0x36, 0x31, 0x61, 0x61, 0x63, 0x37, 0x30, 0x34, 0x65, 0x65, 0x39, 0x64, 0x65, 0x61, 0x30, 0x34, 0x33, 0x39, 0x37, 0x34, 0x65, 0x39, 0x36, 0x39, 0x32, 0x64, 0x65, 0x64, 0x38, 0x34, 0x61, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x36, 0x62, 0x35, 0x38, 0x33, 0x36, 0x34, 0x62, 0x66, 0x37, 0x66, 0x31, 0x39, 0x35, 0x31, 0x63, 0x33, 0x30, 0x39, 0x65, 0x30, 0x63, 0x62, 0x61, 0x30, 0x35, 0x39, 0x35, 0x32, 0x30, 0x31, 0x63, 0x64, 0x37, 0x33, 0x66, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x30, 0x39, 0x64, 0x33, 0x34, 0x30, 0x39, 0x31, 0x34, 0x34, 0x35, 0x62, 0x33, 0x32, 0x33, 0x32, 0x35, 0x39, 0x30, 0x62, 0x64, 0x37, 0x30, 0x66, 0x34, 0x66, 0x31, 0x30, 0x30, 0x32, 0x35, 0x62, 0x32, 0x63, 0x39, 0x35, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x39, 0x62, 0x63, 0x32, 0x37, 0x31, 0x62, 0x32, 0x37, 0x62, 0x61, 0x33, 0x61, 0x62, 0x36, 0x39, 0x36, 0x32, 0x63, 0x39, 0x34, 0x61, 0x35, 0x35, 0x39, 0x30, 0x30, 0x36, 0x61, 0x65, 0x33, 0x38, 0x64, 0x35, 0x66, 0x35, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x30, 0x65, 0x32, 0x66, 0x65, 0x63, 0x33, 0x30, 0x34, 0x32, 0x30, 0x37, 0x34, 0x36, 0x37, 0x65, 0x31, 0x65, 0x33, 0x33, 0x30, 0x37, 0x66, 0x36, 0x34, 0x63, 0x62, 0x66, 0x33, 0x30, 0x61, 0x66, 0x38, 0x66, 0x64, 0x39, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x62, 0x30, 0x62, 0x37, 0x61, 0x38, 0x61, 0x36, 0x65, 0x31, 0x61, 0x63, 0x64, 0x64, 0x30, 0x35, 0x65, 0x34, 0x37, 0x66, 0x39, 0x34, 0x63, 0x30, 0x39, 0x36, 0x38, 0x38, 0x61, 0x61, 0x31, 0x36, 0x63, 0x37, 0x61, 0x64, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x32, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x36, 0x66, 0x39, 0x32, 0x31, 0x32, 0x34, 0x62, 0x35, 0x65, 0x36, 0x33, 0x30, 0x33, 0x35, 0x38, 0x35, 0x39, 0x65, 0x33, 0x39, 0x30, 0x36, 0x32, 0x38, 0x38, 0x36, 0x39, 0x64, 0x62, 0x64, 0x65, 0x61, 0x39, 0x34, 0x38, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x65, 0x36, 0x65, 0x32, 0x35, 0x65, 0x36, 0x35, 0x36, 0x62, 0x37, 0x36, 0x32, 0x35, 0x35, 0x38, 0x36, 0x31, 0x39, 0x66, 0x31, 0x34, 0x37, 0x61, 0x32, 0x31, 0x39, 0x38, 0x35, 0x62, 0x38, 0x38, 0x37, 0x34, 0x65, 0x64, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x33, 0x65, 0x31, 0x39, 0x34, 0x37, 0x61, 0x39, 0x32, 0x34, 0x32, 0x62, 0x33, 0x35, 0x35, 0x35, 0x36, 0x31, 0x63, 0x33, 0x30, 0x61, 0x38, 0x32, 0x39, 0x64, 0x66, 0x65, 0x65, 0x63, 0x61, 0x32, 0x38, 0x31, 0x35, 0x61, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x37, 0x38, 0x32, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x32, 0x30, 0x61, 0x64, 0x33, 0x62, 0x39, 0x34, 0x36, 0x35, 0x36, 0x64, 0x62, 0x64, 0x63, 0x30, 0x64, 0x64, 0x32, 0x31, 0x61, 0x33, 0x39, 0x33, 0x64, 0x38, 0x61, 0x37, 0x64, 0x39, 0x65, 0x30, 0x32, 0x31, 0x33, 0x38, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x61, 0x32, 0x61, 0x38, 0x33, 0x38, 0x33, 0x33, 0x30, 0x62, 0x31, 0x37, 0x33, 0x30, 0x32, 0x64, 0x61, 0x37, 0x33, 0x31, 0x64, 0x33, 0x30, 0x64, 0x62, 0x34, 0x38, 0x61, 0x30, 0x34, 0x66, 0x30, 0x66, 0x32, 0x30, 0x37, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x36, 0x30, 0x38, 0x36, 0x38, 0x61, 0x61, 0x66, 0x64, 0x34, 0x66, 0x66, 0x34, 0x63, 0x35, 0x63, 0x35, 0x37, 0x39, 0x31, 0x34, 0x62, 0x38, 0x65, 0x64, 0x35, 0x38, 0x62, 0x34, 0x32, 0x35, 0x37, 0x37, 0x33, 0x64, 0x66, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x35, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x34, 0x38, 0x30, 0x30, 0x33, 0x63, 0x32, 0x35, 0x62, 0x66, 0x64, 0x34, 0x61, 0x61, 0x39, 0x30, 0x65, 0x37, 0x66, 0x63, 0x62, 0x35, 0x64, 0x37, 0x62, 0x31, 0x36, 0x62, 0x63, 0x64, 0x30, 0x63, 0x66, 0x66, 0x63, 0x30, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x62, 0x31, 0x38, 0x35, 0x64, 0x39, 0x34, 0x33, 0x65, 0x65, 0x32, 0x62, 0x35, 0x38, 0x36, 0x33, 0x31, 0x65, 0x33, 0x33, 0x64, 0x66, 0x66, 0x35, 0x61, 0x66, 0x36, 0x38, 0x35, 0x34, 0x63, 0x31, 0x37, 0x39, 0x39, 0x33, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x31, 0x39, 0x38, 0x38, 0x38, 0x37, 0x39, 0x35, 0x61, 0x64, 0x37, 0x34, 0x35, 0x39, 0x32, 0x34, 0x63, 0x37, 0x35, 0x37, 0x36, 0x30, 0x64, 0x64, 0x62, 0x31, 0x38, 0x32, 0x37, 0x64, 0x66, 0x66, 0x64, 0x38, 0x63, 0x64, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x64, 0x35, 0x32, 0x31, 0x31, 0x33, 0x32, 0x64, 0x39, 0x38, 0x36, 0x63, 0x62, 0x39, 0x36, 0x38, 0x36, 0x39, 0x38, 0x34, 0x32, 0x36, 0x32, 0x32, 0x61, 0x37, 0x64, 0x64, 0x61, 0x32, 0x36, 0x63, 0x33, 0x65, 0x64, 0x30, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x33, 0x65, 0x33, 0x32, 0x62, 0x37, 0x34, 0x65, 0x61, 0x34, 0x34, 0x39, 0x30, 0x61, 0x62, 0x39, 0x32, 0x36, 0x30, 0x36, 0x66, 0x64, 0x61, 0x30, 0x61, 0x61, 0x32, 0x35, 0x37, 0x62, 0x66, 0x32, 0x33, 0x64, 0x63, 0x62, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x31, 0x32, 0x33, 0x36, 0x37, 0x65, 0x35, 0x65, 0x35, 0x35, 0x61, 0x39, 0x36, 0x64, 0x35, 0x61, 0x31, 0x39, 0x31, 0x36, 0x38, 0x66, 0x36, 0x65, 0x62, 0x32, 0x62, 0x63, 0x37, 0x65, 0x39, 0x39, 0x37, 0x31, 0x66, 0x38, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x32, 0x39, 0x61, 0x31, 0x34, 0x61, 0x38, 0x34, 0x35, 0x61, 0x64, 0x34, 0x35, 0x38, 0x66, 0x32, 0x64, 0x31, 0x30, 0x38, 0x62, 0x35, 0x36, 0x38, 0x64, 0x38, 0x31, 0x33, 0x31, 0x36, 0x36, 0x62, 0x63, 0x64, 0x66, 0x34, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x61, 0x38, 0x63, 0x32, 0x31, 0x36, 0x33, 0x36, 0x30, 0x32, 0x61, 0x33, 0x32, 0x65, 0x65, 0x32, 0x34, 0x63, 0x66, 0x34, 0x61, 0x61, 0x39, 0x37, 0x66, 0x64, 0x39, 0x65, 0x61, 0x34, 0x31, 0x34, 0x35, 0x31, 0x36, 0x39, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x63, 0x65, 0x61, 0x37, 0x31, 0x66, 0x61, 0x34, 0x36, 0x34, 0x64, 0x36, 0x32, 0x61, 0x30, 0x37, 0x30, 0x36, 0x33, 0x66, 0x39, 0x32, 0x30, 0x62, 0x30, 0x63, 0x63, 0x39, 0x31, 0x37, 0x35, 0x33, 0x39, 0x37, 0x33, 0x33, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x38, 0x31, 0x66, 0x33, 0x61, 0x62, 0x62, 0x31, 0x66, 0x39, 0x33, 0x33, 0x62, 0x31, 0x64, 0x66, 0x33, 0x39, 0x36, 0x62, 0x38, 0x65, 0x39, 0x63, 0x63, 0x37, 0x32, 0x33, 0x61, 0x38, 0x39, 0x62, 0x37, 0x63, 0x39, 0x38, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x62, 0x31, 0x62, 0x38, 0x63, 0x30, 0x31, 0x32, 0x63, 0x64, 0x34, 0x63, 0x37, 0x38, 0x66, 0x36, 0x39, 0x38, 0x65, 0x34, 0x37, 0x30, 0x66, 0x39, 0x30, 0x32, 0x35, 0x36, 0x65, 0x36, 0x61, 0x33, 0x30, 0x66, 0x34, 0x38, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x33, 0x66, 0x32, 0x63, 0x36, 0x37, 0x33, 0x30, 0x36, 0x39, 0x61, 0x63, 0x39, 0x37, 0x63, 0x32, 0x30, 0x32, 0x33, 0x36, 0x30, 0x37, 0x31, 0x35, 0x32, 0x39, 0x38, 0x31, 0x66, 0x35, 0x63, 0x64, 0x36, 0x30, 0x36, 0x33, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x65, 0x66, 0x61, 0x35, 0x66, 0x63, 0x61, 0x37, 0x39, 0x35, 0x33, 0x38, 0x63, 0x65, 0x36, 0x30, 0x36, 0x38, 0x62, 0x66, 0x33, 0x31, 0x64, 0x32, 0x63, 0x35, 0x31, 0x36, 0x64, 0x34, 0x64, 0x35, 0x33, 0x63, 0x30, 0x38, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x38, 0x33, 0x63, 0x32, 0x32, 0x32, 0x65, 0x36, 0x37, 0x65, 0x39, 0x36, 0x39, 0x31, 0x39, 0x30, 0x64, 0x33, 0x32, 0x31, 0x39, 0x65, 0x66, 0x31, 0x34, 0x64, 0x61, 0x33, 0x37, 0x38, 0x35, 0x30, 0x65, 0x32, 0x36, 0x63, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x63, 0x33, 0x61, 0x66, 0x35, 0x37, 0x38, 0x34, 0x39, 0x32, 0x37, 0x66, 0x65, 0x39, 0x61, 0x35, 0x39, 0x38, 0x66, 0x63, 0x34, 0x65, 0x65, 0x63, 0x33, 0x38, 0x62, 0x38, 0x31, 0x30, 0x32, 0x66, 0x33, 0x37, 0x62, 0x63, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x65, 0x35, 0x36, 0x61, 0x62, 0x33, 0x62, 0x61, 0x65, 0x31, 0x62, 0x30, 0x61, 0x34, 0x34, 0x34, 0x33, 0x33, 0x34, 0x35, 0x38, 0x33, 0x33, 0x33, 0x63, 0x34, 0x62, 0x30, 0x35, 0x61, 0x32, 0x34, 0x38, 0x66, 0x38, 0x32, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x39, 0x63, 0x66, 0x63, 0x33, 0x62, 0x62, 0x32, 0x39, 0x33, 0x64, 0x64, 0x62, 0x32, 0x38, 0x35, 0x65, 0x36, 0x32, 0x35, 0x66, 0x33, 0x35, 0x38, 0x32, 0x66, 0x37, 0x34, 0x61, 0x36, 0x62, 0x30, 0x61, 0x35, 0x61, 0x36, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x38, 0x65, 0x31, 0x66, 0x31, 0x33, 0x66, 0x36, 0x61, 0x66, 0x34, 0x64, 0x38, 0x34, 0x62, 0x33, 0x37, 0x31, 0x64, 0x37, 0x64, 0x65, 0x34, 0x62, 0x32, 0x37, 0x33, 0x64, 0x30, 0x33, 0x61, 0x32, 0x36, 0x33, 0x32, 0x37, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x61, 0x39, 0x32, 0x32, 0x38, 0x64, 0x33, 0x38, 0x38, 0x37, 0x32, 0x37, 0x66, 0x33, 0x38, 0x39, 0x31, 0x35, 0x30, 0x65, 0x61, 0x30, 0x33, 0x62, 0x37, 0x33, 0x63, 0x38, 0x32, 0x64, 0x65, 0x38, 0x65, 0x62, 0x32, 0x65, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x61, 0x37, 0x61, 0x36, 0x66, 0x66, 0x34, 0x65, 0x61, 0x33, 0x64, 0x36, 0x30, 0x65, 0x63, 0x33, 0x30, 0x37, 0x63, 0x61, 0x35, 0x31, 0x36, 0x61, 0x34, 0x38, 0x64, 0x33, 0x30, 0x35, 0x33, 0x62, 0x62, 0x37, 0x39, 0x63, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x33, 0x38, 0x34, 0x30, 0x64, 0x38, 0x62, 0x63, 0x61, 0x37, 0x64, 0x61, 0x39, 0x38, 0x61, 0x36, 0x66, 0x33, 0x64, 0x30, 0x39, 0x36, 0x64, 0x38, 0x33, 0x64, 0x65, 0x37, 0x38, 0x62, 0x37, 0x30, 0x62, 0x37, 0x31, 0x65, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x37, 0x66, 0x64, 0x32, 0x33, 0x38, 0x34, 0x38, 0x66, 0x34, 0x64, 0x62, 0x30, 0x37, 0x39, 0x30, 0x36, 0x61, 0x37, 0x64, 0x31, 0x30, 0x63, 0x30, 0x34, 0x62, 0x32, 0x31, 0x38, 0x30, 0x33, 0x62, 0x62, 0x30, 0x38, 0x32, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x64, 0x34, 0x33, 0x33, 0x34, 0x65, 0x63, 0x33, 0x38, 0x35, 0x65, 0x38, 0x61, 0x61, 0x35, 0x34, 0x65, 0x65, 0x64, 0x61, 0x65, 0x61, 0x64, 0x62, 0x33, 0x30, 0x30, 0x32, 0x32, 0x66, 0x30, 0x63, 0x64, 0x66, 0x61, 0x34, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x32, 0x39, 0x39, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x62, 0x30, 0x38, 0x35, 0x66, 0x62, 0x30, 0x38, 0x36, 0x66, 0x33, 0x64, 0x30, 0x64, 0x36, 0x38, 0x62, 0x66, 0x31, 0x32, 0x39, 0x32, 0x36, 0x62, 0x31, 0x63, 0x63, 0x33, 0x31, 0x34, 0x32, 0x63, 0x61, 0x65, 0x38, 0x37, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x38, 0x37, 0x66, 0x30, 0x33, 0x34, 0x65, 0x36, 0x66, 0x36, 0x38, 0x66, 0x34, 0x65, 0x37, 0x34, 0x66, 0x66, 0x65, 0x36, 0x30, 0x63, 0x36, 0x34, 0x38, 0x31, 0x39, 0x34, 0x33, 0x36, 0x30, 0x33, 0x36, 0x63, 0x66, 0x37, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x30, 0x61, 0x62, 0x30, 0x38, 0x30, 0x62, 0x36, 0x34, 0x33, 0x65, 0x31, 0x63, 0x32, 0x62, 0x61, 0x65, 0x33, 0x36, 0x33, 0x65, 0x30, 0x64, 0x31, 0x39, 0x35, 0x64, 0x65, 0x32, 0x65, 0x66, 0x66, 0x66, 0x63, 0x31, 0x63, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x66, 0x33, 0x63, 0x37, 0x37, 0x39, 0x64, 0x64, 0x37, 0x39, 0x30, 0x32, 0x33, 0x65, 0x61, 0x39, 0x32, 0x61, 0x37, 0x38, 0x62, 0x36, 0x35, 0x63, 0x31, 0x61, 0x31, 0x37, 0x38, 0x30, 0x66, 0x36, 0x32, 0x64, 0x35, 0x63, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x64, 0x35, 0x63, 0x37, 0x30, 0x35, 0x34, 0x30, 0x38, 0x31, 0x65, 0x39, 0x31, 0x38, 0x65, 0x63, 0x36, 0x38, 0x37, 0x62, 0x35, 0x61, 0x62, 0x33, 0x36, 0x65, 0x39, 0x37, 0x33, 0x64, 0x31, 0x38, 0x31, 0x33, 0x32, 0x39, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x36, 0x32, 0x65, 0x65, 0x30, 0x32, 0x31, 0x39, 0x32, 0x36, 0x36, 0x38, 0x32, 0x62, 0x33, 0x31, 0x63, 0x35, 0x66, 0x32, 0x30, 0x30, 0x63, 0x65, 0x34, 0x35, 0x37, 0x61, 0x62, 0x65, 0x61, 0x37, 0x36, 0x63, 0x36, 0x63, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x36, 0x61, 0x30, 0x39, 0x64, 0x66, 0x36, 0x36, 0x63, 0x62, 0x31, 0x35, 0x30, 0x65, 0x39, 0x37, 0x35, 0x37, 0x38, 0x65, 0x32, 0x39, 0x37, 0x66, 0x62, 0x30, 0x36, 0x65, 0x31, 0x33, 0x30, 0x34, 0x30, 0x63, 0x38, 0x39, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x32, 0x34, 0x30, 0x61, 0x66, 0x32, 0x61, 0x66, 0x39, 0x30, 0x62, 0x33, 0x33, 0x63, 0x30, 0x38, 0x61, 0x65, 0x39, 0x37, 0x36, 0x34, 0x31, 0x30, 0x33, 0x65, 0x33, 0x35, 0x64, 0x63, 0x65, 0x33, 0x36, 0x33, 0x38, 0x34, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x36, 0x34, 0x35, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x62, 0x32, 0x38, 0x61, 0x63, 0x64, 0x61, 0x39, 0x37, 0x31, 0x37, 0x32, 0x35, 0x37, 0x36, 0x39, 0x64, 0x62, 0x38, 0x66, 0x35, 0x36, 0x33, 0x64, 0x32, 0x38, 0x36, 0x36, 0x36, 0x64, 0x34, 0x31, 0x64, 0x64, 0x61, 0x62, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x64, 0x34, 0x39, 0x31, 0x38, 0x64, 0x66, 0x61, 0x63, 0x31, 0x35, 0x64, 0x37, 0x37, 0x63, 0x34, 0x37, 0x66, 0x39, 0x65, 0x64, 0x34, 0x30, 0x30, 0x61, 0x38, 0x35, 0x30, 0x31, 0x39, 0x30, 0x64, 0x36, 0x34, 0x66, 0x31, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x32, 0x32, 0x35, 0x30, 0x62, 0x30, 0x66, 0x65, 0x34, 0x32, 0x65, 0x36, 0x62, 0x37, 0x64, 0x63, 0x64, 0x35, 0x63, 0x38, 0x39, 0x30, 0x61, 0x36, 0x66, 0x30, 0x63, 0x38, 0x38, 0x66, 0x35, 0x66, 0x35, 0x66, 0x62, 0x35, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x61, 0x32, 0x61, 0x39, 0x61, 0x34, 0x63, 0x32, 0x63, 0x30, 0x61, 0x34, 0x61, 0x39, 0x32, 0x34, 0x63, 0x62, 0x65, 0x30, 0x61, 0x35, 0x33, 0x61, 0x62, 0x39, 0x64, 0x30, 0x63, 0x36, 0x32, 0x37, 0x61, 0x31, 0x63, 0x66, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x33, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x36, 0x39, 0x66, 0x62, 0x38, 0x36, 0x37, 0x64, 0x37, 0x31, 0x66, 0x31, 0x33, 0x38, 0x37, 0x66, 0x38, 0x36, 0x33, 0x62, 0x36, 0x39, 0x38, 0x64, 0x30, 0x39, 0x66, 0x64, 0x66, 0x62, 0x38, 0x37, 0x63, 0x34, 0x39, 0x62, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x39, 0x61, 0x37, 0x35, 0x62, 0x62, 0x39, 0x33, 0x33, 0x66, 0x63, 0x61, 0x31, 0x66, 0x63, 0x61, 0x39, 0x61, 0x61, 0x31, 0x33, 0x30, 0x33, 0x61, 0x36, 0x34, 0x62, 0x36, 0x63, 0x62, 0x34, 0x34, 0x65, 0x61, 0x33, 0x30, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x33, 0x33, 0x31, 0x65, 0x33, 0x30, 0x37, 0x39, 0x36, 0x63, 0x65, 0x36, 0x36, 0x34, 0x62, 0x32, 0x37, 0x30, 0x30, 0x65, 0x30, 0x64, 0x34, 0x31, 0x35, 0x33, 0x37, 0x30, 0x30, 0x65, 0x64, 0x63, 0x38, 0x36, 0x39, 0x37, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x35, 0x66, 0x62, 0x37, 0x35, 0x37, 0x39, 0x33, 0x64, 0x30, 0x34, 0x33, 0x66, 0x31, 0x62, 0x63, 0x64, 0x34, 0x33, 0x38, 0x38, 0x35, 0x65, 0x30, 0x33, 0x37, 0x62, 0x64, 0x33, 0x30, 0x61, 0x35, 0x32, 0x38, 0x63, 0x39, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x30, 0x65, 0x65, 0x36, 0x66, 0x37, 0x63, 0x32, 0x62, 0x33, 0x37, 0x31, 0x34, 0x61, 0x65, 0x39, 0x39, 0x31, 0x36, 0x63, 0x34, 0x35, 0x35, 0x36, 0x36, 0x36, 0x30, 0x35, 0x62, 0x36, 0x35, 0x36, 0x66, 0x33, 0x32, 0x34, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x35, 0x30, 0x63, 0x65, 0x32, 0x65, 0x32, 0x36, 0x34, 0x62, 0x39, 0x66, 0x65, 0x32, 0x62, 0x30, 0x36, 0x38, 0x33, 0x30, 0x36, 0x31, 0x37, 0x61, 0x65, 0x64, 0x66, 0x35, 0x30, 0x32, 0x62, 0x32, 0x33, 0x35, 0x31, 0x62, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x36, 0x30, 0x30, 0x30, 0x64, 0x65, 0x31, 0x35, 0x37, 0x38, 0x36, 0x31, 0x39, 0x33, 0x32, 0x30, 0x61, 0x62, 0x61, 0x35, 0x65, 0x33, 0x39, 0x32, 0x37, 0x30, 0x36, 0x62, 0x31, 0x33, 0x31, 0x66, 0x62, 0x31, 0x64, 0x65, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x35, 0x33, 0x66, 0x39, 0x33, 0x34, 0x63, 0x30, 0x65, 0x62, 0x32, 0x64, 0x30, 0x66, 0x31, 0x34, 0x34, 0x62, 0x64, 0x61, 0x62, 0x30, 0x30, 0x34, 0x38, 0x33, 0x66, 0x64, 0x38, 0x31, 0x39, 0x34, 0x38, 0x36, 0x35, 0x63, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x66, 0x64, 0x39, 0x61, 0x36, 0x63, 0x38, 0x37, 0x34, 0x63, 0x32, 0x66, 0x61, 0x62, 0x33, 0x66, 0x66, 0x33, 0x36, 0x65, 0x39, 0x61, 0x66, 0x62, 0x66, 0x38, 0x63, 0x65, 0x30, 0x64, 0x33, 0x32, 0x63, 0x37, 0x64, 0x65, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x63, 0x64, 0x36, 0x38, 0x65, 0x63, 0x33, 0x35, 0x33, 0x36, 0x32, 0x63, 0x35, 0x61, 0x64, 0x38, 0x34, 0x63, 0x38, 0x32, 0x61, 0x64, 0x34, 0x65, 0x64, 0x63, 0x32, 0x33, 0x32, 0x31, 0x32, 0x35, 0x39, 0x31, 0x32, 0x64, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x36, 0x37, 0x36, 0x36, 0x30, 0x61, 0x31, 0x33, 0x36, 0x38, 0x65, 0x66, 0x63, 0x64, 0x36, 0x32, 0x36, 0x65, 0x66, 0x33, 0x36, 0x62, 0x32, 0x62, 0x31, 0x62, 0x36, 0x30, 0x31, 0x39, 0x38, 0x30, 0x39, 0x34, 0x31, 0x63, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x65, 0x62, 0x33, 0x39, 0x30, 0x32, 0x37, 0x61, 0x66, 0x38, 0x37, 0x37, 0x39, 0x39, 0x32, 0x62, 0x38, 0x39, 0x66, 0x32, 0x65, 0x63, 0x34, 0x61, 0x31, 0x66, 0x38, 0x32, 0x32, 0x65, 0x63, 0x64, 0x66, 0x31, 0x32, 0x36, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x32, 0x66, 0x38, 0x38, 0x31, 0x66, 0x61, 0x31, 0x31, 0x32, 0x62, 0x38, 0x31, 0x39, 0x39, 0x65, 0x63, 0x62, 0x63, 0x37, 0x33, 0x65, 0x63, 0x34, 0x31, 0x38, 0x35, 0x37, 0x39, 0x30, 0x65, 0x36, 0x31, 0x34, 0x61, 0x32, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x38, 0x61, 0x35, 0x32, 0x65, 0x30, 0x37, 0x38, 0x61, 0x38, 0x30, 0x35, 0x35, 0x39, 0x36, 0x62, 0x30, 0x64, 0x35, 0x36, 0x65, 0x61, 0x34, 0x61, 0x65, 0x31, 0x33, 0x33, 0x35, 0x61, 0x66, 0x30, 0x31, 0x63, 0x36, 0x36, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x37, 0x63, 0x66, 0x61, 0x61, 0x38, 0x34, 0x63, 0x62, 0x33, 0x33, 0x31, 0x30, 0x36, 0x38, 0x30, 0x30, 0x61, 0x38, 0x63, 0x38, 0x30, 0x32, 0x66, 0x62, 0x38, 0x61, 0x61, 0x34, 0x36, 0x33, 0x38, 0x39, 0x36, 0x63, 0x35, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x65, 0x33, 0x39, 0x31, 0x66, 0x30, 0x33, 0x63, 0x37, 0x36, 0x35, 0x62, 0x31, 0x31, 0x64, 0x36, 0x39, 0x30, 0x32, 0x36, 0x66, 0x64, 0x31, 0x61, 0x62, 0x33, 0x35, 0x33, 0x39, 0x35, 0x64, 0x63, 0x33, 0x38, 0x30, 0x32, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x39, 0x32, 0x66, 0x30, 0x36, 0x61, 0x62, 0x30, 0x35, 0x32, 0x64, 0x35, 0x66, 0x64, 0x37, 0x66, 0x39, 0x34, 0x65, 0x65, 0x61, 0x38, 0x33, 0x31, 0x38, 0x65, 0x38, 0x32, 0x37, 0x38, 0x31, 0x35, 0x66, 0x65, 0x36, 0x37, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x30, 0x61, 0x62, 0x38, 0x39, 0x34, 0x62, 0x64, 0x33, 0x66, 0x34, 0x65, 0x36, 0x39, 0x37, 0x64, 0x62, 0x63, 0x66, 0x62, 0x38, 0x35, 0x39, 0x64, 0x34, 0x39, 0x37, 0x61, 0x39, 0x62, 0x61, 0x31, 0x39, 0x35, 0x39, 0x39, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x35, 0x30, 0x31, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x37, 0x65, 0x65, 0x61, 0x66, 0x64, 0x36, 0x62, 0x34, 0x30, 0x30, 0x39, 0x64, 0x65, 0x61, 0x66, 0x38, 0x62, 0x64, 0x35, 0x62, 0x38, 0x35, 0x61, 0x37, 0x32, 0x39, 0x38, 0x33, 0x61, 0x38, 0x64, 0x63, 0x63, 0x33, 0x34, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x62, 0x30, 0x66, 0x31, 0x37, 0x63, 0x64, 0x34, 0x34, 0x36, 0x39, 0x64, 0x64, 0x63, 0x63, 0x66, 0x62, 0x37, 0x64, 0x61, 0x36, 0x39, 0x37, 0x65, 0x38, 0x32, 0x61, 0x39, 0x31, 0x61, 0x35, 0x66, 0x39, 0x65, 0x37, 0x37, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x31, 0x37, 0x32, 0x62, 0x32, 0x37, 0x38, 0x64, 0x64, 0x64, 0x34, 0x34, 0x65, 0x65, 0x61, 0x32, 0x66, 0x64, 0x66, 0x34, 0x63, 0x62, 0x31, 0x64, 0x31, 0x36, 0x39, 0x36, 0x32, 0x33, 0x39, 0x31, 0x63, 0x34, 0x35, 0x33, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x64, 0x31, 0x37, 0x32, 0x61, 0x62, 0x30, 0x37, 0x35, 0x63, 0x35, 0x31, 0x64, 0x62, 0x31, 0x63, 0x64, 0x34, 0x30, 0x61, 0x38, 0x63, 0x61, 0x38, 0x64, 0x62, 0x66, 0x66, 0x30, 0x64, 0x39, 0x33, 0x62, 0x38, 0x34, 0x33, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x32, 0x37, 0x31, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x39, 0x62, 0x35, 0x65, 0x37, 0x36, 0x33, 0x61, 0x33, 0x39, 0x64, 0x63, 0x63, 0x37, 0x39, 0x35, 0x32, 0x32, 0x33, 0x64, 0x37, 0x33, 0x61, 0x31, 0x64, 0x62, 0x62, 0x37, 0x64, 0x39, 0x34, 0x63, 0x61, 0x37, 0x35, 0x61, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x61, 0x31, 0x32, 0x61, 0x62, 0x30, 0x62, 0x39, 0x36, 0x36, 0x36, 0x63, 0x66, 0x30, 0x63, 0x65, 0x63, 0x36, 0x36, 0x37, 0x31, 0x61, 0x31, 0x35, 0x32, 0x39, 0x32, 0x66, 0x32, 0x36, 0x35, 0x33, 0x34, 0x37, 0x36, 0x61, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x35, 0x61, 0x65, 0x37, 0x62, 0x66, 0x37, 0x38, 0x65, 0x63, 0x37, 0x35, 0x65, 0x39, 0x30, 0x63, 0x62, 0x35, 0x30, 0x33, 0x63, 0x37, 0x37, 0x38, 0x63, 0x63, 0x64, 0x33, 0x62, 0x32, 0x34, 0x62, 0x34, 0x66, 0x31, 0x61, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x65, 0x33, 0x38, 0x35, 0x37, 0x65, 0x66, 0x64, 0x31, 0x65, 0x32, 0x30, 0x32, 0x61, 0x34, 0x34, 0x31, 0x37, 0x37, 0x30, 0x61, 0x37, 0x37, 0x37, 0x61, 0x34, 0x39, 0x64, 0x63, 0x63, 0x34, 0x35, 0x65, 0x32, 0x65, 0x30, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x30, 0x33, 0x63, 0x36, 0x61, 0x34, 0x66, 0x31, 0x31, 0x64, 0x36, 0x30, 0x31, 0x39, 0x34, 0x35, 0x37, 0x39, 0x64, 0x35, 0x38, 0x63, 0x32, 0x37, 0x36, 0x36, 0x61, 0x37, 0x65, 0x66, 0x31, 0x36, 0x63, 0x33, 0x30, 0x61, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x38, 0x62, 0x64, 0x35, 0x36, 0x35, 0x66, 0x39, 0x39, 0x66, 0x64, 0x65, 0x34, 0x38, 0x30, 0x35, 0x33, 0x66, 0x37, 0x39, 0x31, 0x37, 0x66, 0x65, 0x33, 0x33, 0x33, 0x63, 0x66, 0x38, 0x34, 0x61, 0x64, 0x35, 0x34, 0x38, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x36, 0x38, 0x65, 0x64, 0x63, 0x65, 0x37, 0x66, 0x32, 0x39, 0x36, 0x31, 0x63, 0x66, 0x32, 0x39, 0x35, 0x62, 0x39, 0x66, 0x63, 0x64, 0x35, 0x61, 0x34, 0x35, 0x63, 0x30, 0x36, 0x63, 0x64, 0x65, 0x64, 0x61, 0x36, 0x65, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x35, 0x30, 0x38, 0x36, 0x38, 0x65, 0x62, 0x37, 0x65, 0x33, 0x63, 0x37, 0x31, 0x39, 0x33, 0x37, 0x65, 0x63, 0x37, 0x33, 0x66, 0x61, 0x38, 0x39, 0x64, 0x64, 0x38, 0x62, 0x39, 0x65, 0x65, 0x31, 0x30, 0x64, 0x34, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x37, 0x34, 0x39, 0x38, 0x63, 0x30, 0x34, 0x36, 0x34, 0x36, 0x36, 0x38, 0x66, 0x33, 0x31, 0x31, 0x35, 0x30, 0x66, 0x34, 0x64, 0x33, 0x63, 0x34, 0x62, 0x63, 0x64, 0x64, 0x61, 0x35, 0x32, 0x32, 0x31, 0x62, 0x61, 0x31, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x33, 0x66, 0x61, 0x62, 0x34, 0x34, 0x62, 0x31, 0x36, 0x62, 0x62, 0x65, 0x35, 0x35, 0x34, 0x64, 0x34, 0x34, 0x61, 0x66, 0x64, 0x31, 0x37, 0x38, 0x61, 0x62, 0x31, 0x64, 0x30, 0x32, 0x66, 0x33, 0x37, 0x61, 0x65, 0x61, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x65, 0x65, 0x36, 0x39, 0x31, 0x66, 0x32, 0x33, 0x37, 0x65, 0x65, 0x36, 0x35, 0x32, 0x39, 0x62, 0x36, 0x35, 0x35, 0x37, 0x66, 0x32, 0x66, 0x63, 0x64, 0x64, 0x33, 0x64, 0x63, 0x66, 0x30, 0x63, 0x35, 0x39, 0x65, 0x63, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x35, 0x30, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x65, 0x64, 0x33, 0x37, 0x37, 0x62, 0x37, 0x64, 0x36, 0x65, 0x63, 0x32, 0x35, 0x39, 0x37, 0x31, 0x63, 0x31, 0x61, 0x35, 0x39, 0x37, 0x61, 0x33, 0x62, 0x30, 0x66, 0x33, 0x62, 0x65, 0x61, 0x64, 0x35, 0x37, 0x63, 0x39, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x35, 0x66, 0x65, 0x65, 0x65, 0x61, 0x32, 0x61, 0x61, 0x34, 0x65, 0x30, 0x65, 0x66, 0x64, 0x61, 0x31, 0x32, 0x65, 0x31, 0x35, 0x38, 0x38, 0x64, 0x32, 0x66, 0x34, 0x38, 0x33, 0x32, 0x39, 0x30, 0x65, 0x64, 0x65, 0x38, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x31, 0x64, 0x64, 0x63, 0x62, 0x34, 0x64, 0x64, 0x34, 0x65, 0x38, 0x61, 0x65, 0x36, 0x62, 0x65, 0x33, 0x33, 0x36, 0x64, 0x64, 0x39, 0x36, 0x35, 0x34, 0x39, 0x37, 0x31, 0x64, 0x39, 0x66, 0x65, 0x63, 0x38, 0x36, 0x62, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x31, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x63, 0x30, 0x66, 0x35, 0x37, 0x33, 0x65, 0x63, 0x63, 0x66, 0x36, 0x32, 0x63, 0x35, 0x34, 0x38, 0x31, 0x30, 0x65, 0x65, 0x36, 0x62, 0x61, 0x38, 0x64, 0x31, 0x66, 0x31, 0x31, 0x33, 0x35, 0x34, 0x32, 0x62, 0x33, 0x30, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x30, 0x39, 0x65, 0x31, 0x38, 0x62, 0x62, 0x30, 0x61, 0x33, 0x39, 0x63, 0x39, 0x65, 0x66, 0x38, 0x32, 0x66, 0x61, 0x31, 0x39, 0x35, 0x39, 0x37, 0x66, 0x63, 0x35, 0x65, 0x64, 0x38, 0x65, 0x39, 0x65, 0x62, 0x36, 0x64, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x34, 0x65, 0x36, 0x65, 0x31, 0x34, 0x35, 0x33, 0x38, 0x32, 0x62, 0x34, 0x64, 0x62, 0x38, 0x32, 0x31, 0x66, 0x65, 0x30, 0x66, 0x32, 0x64, 0x39, 0x38, 0x33, 0x38, 0x38, 0x66, 0x34, 0x35, 0x36, 0x30, 0x39, 0x63, 0x36, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x38, 0x66, 0x33, 0x37, 0x32, 0x34, 0x33, 0x66, 0x33, 0x66, 0x66, 0x30, 0x62, 0x65, 0x66, 0x35, 0x65, 0x31, 0x64, 0x63, 0x38, 0x35, 0x65, 0x62, 0x34, 0x33, 0x30, 0x38, 0x64, 0x39, 0x33, 0x34, 0x30, 0x63, 0x32, 0x39, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x65, 0x39, 0x39, 0x34, 0x39, 0x36, 0x38, 0x30, 0x62, 0x65, 0x63, 0x65, 0x36, 0x38, 0x34, 0x31, 0x62, 0x39, 0x61, 0x37, 0x65, 0x35, 0x32, 0x35, 0x30, 0x64, 0x30, 0x38, 0x61, 0x63, 0x64, 0x38, 0x37, 0x64, 0x31, 0x36, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x32, 0x62, 0x64, 0x33, 0x61, 0x32, 0x65, 0x39, 0x64, 0x37, 0x34, 0x31, 0x31, 0x30, 0x62, 0x32, 0x34, 0x39, 0x36, 0x31, 0x63, 0x35, 0x33, 0x37, 0x37, 0x37, 0x66, 0x32, 0x32, 0x66, 0x31, 0x66, 0x34, 0x36, 0x64, 0x63, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x30, 0x31, 0x65, 0x30, 0x61, 0x37, 0x30, 0x36, 0x31, 0x30, 0x64, 0x63, 0x37, 0x30, 0x62, 0x62, 0x39, 0x31, 0x65, 0x39, 0x39, 0x32, 0x36, 0x66, 0x61, 0x39, 0x39, 0x35, 0x37, 0x66, 0x33, 0x37, 0x32, 0x66, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x66, 0x36, 0x38, 0x37, 0x37, 0x31, 0x37, 0x32, 0x34, 0x36, 0x64, 0x61, 0x38, 0x61, 0x32, 0x30, 0x30, 0x64, 0x32, 0x30, 0x65, 0x35, 0x65, 0x39, 0x62, 0x63, 0x61, 0x63, 0x36, 0x30, 0x62, 0x36, 0x37, 0x66, 0x33, 0x38, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x34, 0x36, 0x31, 0x37, 0x66, 0x36, 0x30, 0x32, 0x32, 0x35, 0x30, 0x31, 0x65, 0x39, 0x37, 0x65, 0x37, 0x62, 0x33, 0x65, 0x32, 0x64, 0x38, 0x38, 0x33, 0x36, 0x61, 0x61, 0x36, 0x31, 0x66, 0x30, 0x66, 0x66, 0x32, 0x64, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x36, 0x65, 0x65, 0x39, 0x39, 0x64, 0x33, 0x35, 0x34, 0x38, 0x36, 0x32, 0x33, 0x61, 0x30, 0x33, 0x62, 0x35, 0x66, 0x39, 0x39, 0x38, 0x35, 0x39, 0x64, 0x32, 0x64, 0x37, 0x38, 0x35, 0x61, 0x31, 0x37, 0x37, 0x38, 0x64, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x34, 0x32, 0x34, 0x65, 0x65, 0x34, 0x37, 0x66, 0x35, 0x38, 0x33, 0x63, 0x64, 0x63, 0x65, 0x30, 0x37, 0x61, 0x65, 0x33, 0x31, 0x38, 0x62, 0x36, 0x66, 0x61, 0x64, 0x34, 0x36, 0x32, 0x33, 0x38, 0x31, 0x64, 0x34, 0x64, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x38, 0x32, 0x35, 0x30, 0x37, 0x33, 0x30, 0x63, 0x34, 0x63, 0x36, 0x31, 0x63, 0x35, 0x37, 0x66, 0x31, 0x32, 0x39, 0x38, 0x33, 0x35, 0x66, 0x32, 0x36, 0x38, 0x30, 0x38, 0x39, 0x34, 0x37, 0x39, 0x34, 0x35, 0x34, 0x32, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x31, 0x62, 0x32, 0x34, 0x62, 0x36, 0x39, 0x31, 0x32, 0x64, 0x35, 0x31, 0x62, 0x33, 0x33, 0x34, 0x61, 0x63, 0x30, 0x64, 0x65, 0x36, 0x65, 0x37, 0x37, 0x31, 0x63, 0x37, 0x63, 0x30, 0x34, 0x35, 0x34, 0x36, 0x39, 0x35, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x64, 0x35, 0x31, 0x37, 0x30, 0x66, 0x64, 0x31, 0x61, 0x38, 0x31, 0x31, 0x38, 0x64, 0x35, 0x35, 0x38, 0x65, 0x37, 0x35, 0x31, 0x31, 0x65, 0x33, 0x36, 0x34, 0x62, 0x32, 0x34, 0x39, 0x30, 0x36, 0x63, 0x34, 0x66, 0x36, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x34, 0x39, 0x63, 0x31, 0x34, 0x38, 0x39, 0x38, 0x33, 0x31, 0x36, 0x35, 0x36, 0x37, 0x64, 0x38, 0x62, 0x37, 0x30, 0x39, 0x63, 0x32, 0x65, 0x35, 0x30, 0x35, 0x39, 0x34, 0x62, 0x33, 0x36, 0x36, 0x63, 0x36, 0x64, 0x33, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x33, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x65, 0x61, 0x32, 0x36, 0x65, 0x61, 0x62, 0x62, 0x65, 0x32, 0x66, 0x36, 0x34, 0x63, 0x63, 0x63, 0x63, 0x66, 0x65, 0x30, 0x36, 0x38, 0x32, 0x39, 0x63, 0x32, 0x35, 0x64, 0x34, 0x36, 0x33, 0x37, 0x35, 0x32, 0x30, 0x32, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x35, 0x34, 0x31, 0x39, 0x35, 0x36, 0x35, 0x63, 0x33, 0x61, 0x61, 0x64, 0x34, 0x65, 0x37, 0x31, 0x34, 0x65, 0x30, 0x37, 0x33, 0x39, 0x33, 0x32, 0x38, 0x65, 0x33, 0x35, 0x32, 0x31, 0x63, 0x39, 0x38, 0x66, 0x30, 0x35, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x33, 0x62, 0x35, 0x30, 0x66, 0x64, 0x33, 0x62, 0x32, 0x62, 0x37, 0x32, 0x62, 0x63, 0x36, 0x63, 0x34, 0x33, 0x30, 0x62, 0x61, 0x66, 0x31, 0x39, 0x34, 0x61, 0x35, 0x31, 0x35, 0x35, 0x38, 0x35, 0x64, 0x33, 0x39, 0x38, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x37, 0x34, 0x63, 0x33, 0x37, 0x33, 0x64, 0x30, 0x34, 0x62, 0x66, 0x62, 0x30, 0x66, 0x64, 0x36, 0x30, 0x61, 0x31, 0x38, 0x61, 0x30, 0x31, 0x61, 0x38, 0x38, 0x66, 0x62, 0x65, 0x38, 0x34, 0x37, 0x37, 0x30, 0x65, 0x35, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x37, 0x66, 0x34, 0x35, 0x32, 0x36, 0x64, 0x65, 0x61, 0x39, 0x62, 0x31, 0x36, 0x33, 0x66, 0x38, 0x65, 0x38, 0x65, 0x33, 0x33, 0x61, 0x36, 0x62, 0x63, 0x66, 0x39, 0x32, 0x66, 0x62, 0x39, 0x30, 0x37, 0x64, 0x65, 0x36, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x61, 0x34, 0x39, 0x66, 0x30, 0x62, 0x63, 0x38, 0x36, 0x38, 0x38, 0x63, 0x63, 0x39, 0x65, 0x36, 0x64, 0x63, 0x30, 0x34, 0x65, 0x31, 0x65, 0x30, 0x38, 0x64, 0x35, 0x32, 0x31, 0x30, 0x32, 0x36, 0x65, 0x36, 0x35, 0x35, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x35, 0x63, 0x30, 0x30, 0x63, 0x32, 0x38, 0x31, 0x38, 0x32, 0x31, 0x30, 0x63, 0x32, 0x38, 0x35, 0x35, 0x35, 0x61, 0x30, 0x66, 0x66, 0x32, 0x39, 0x30, 0x31, 0x30, 0x32, 0x38, 0x39, 0x64, 0x33, 0x66, 0x38, 0x32, 0x33, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x31, 0x32, 0x33, 0x33, 0x37, 0x31, 0x34, 0x66, 0x32, 0x30, 0x34, 0x64, 0x65, 0x39, 0x64, 0x65, 0x34, 0x65, 0x65, 0x39, 0x36, 0x64, 0x30, 0x37, 0x33, 0x62, 0x33, 0x36, 0x38, 0x64, 0x38, 0x31, 0x39, 0x37, 0x39, 0x38, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x36, 0x34, 0x64, 0x39, 0x38, 0x64, 0x32, 0x38, 0x31, 0x37, 0x33, 0x30, 0x62, 0x61, 0x33, 0x35, 0x62, 0x32, 0x65, 0x33, 0x61, 0x33, 0x31, 0x34, 0x37, 0x39, 0x36, 0x65, 0x37, 0x62, 0x34, 0x32, 0x66, 0x65, 0x64, 0x66, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x34, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x65, 0x65, 0x63, 0x30, 0x31, 0x61, 0x62, 0x65, 0x35, 0x63, 0x30, 0x64, 0x39, 0x35, 0x32, 0x64, 0x65, 0x39, 0x31, 0x30, 0x36, 0x63, 0x33, 0x64, 0x63, 0x33, 0x30, 0x36, 0x33, 0x39, 0x64, 0x38, 0x35, 0x30, 0x30, 0x35, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x64, 0x36, 0x30, 0x64, 0x36, 0x35, 0x62, 0x37, 0x64, 0x39, 0x66, 0x63, 0x34, 0x38, 0x38, 0x34, 0x30, 0x62, 0x65, 0x35, 0x66, 0x38, 0x39, 0x31, 0x63, 0x37, 0x34, 0x35, 0x63, 0x65, 0x37, 0x36, 0x65, 0x65, 0x35, 0x30, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x33, 0x35, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x36, 0x31, 0x33, 0x36, 0x65, 0x32, 0x31, 0x38, 0x64, 0x65, 0x30, 0x61, 0x36, 0x31, 0x61, 0x31, 0x33, 0x37, 0x62, 0x32, 0x62, 0x33, 0x39, 0x36, 0x32, 0x64, 0x32, 0x61, 0x36, 0x31, 0x31, 0x32, 0x62, 0x38, 0x30, 0x39, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x32, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x34, 0x33, 0x32, 0x35, 0x38, 0x62, 0x37, 0x33, 0x39, 0x32, 0x61, 0x39, 0x33, 0x30, 0x38, 0x33, 0x39, 0x61, 0x35, 0x31, 0x62, 0x32, 0x65, 0x66, 0x38, 0x61, 0x64, 0x32, 0x33, 0x34, 0x31, 0x32, 0x66, 0x37, 0x35, 0x61, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x33, 0x66, 0x32, 0x35, 0x38, 0x61, 0x62, 0x32, 0x61, 0x33, 0x63, 0x32, 0x63, 0x66, 0x33, 0x33, 0x39, 0x63, 0x34, 0x34, 0x39, 0x39, 0x66, 0x37, 0x35, 0x61, 0x34, 0x62, 0x64, 0x31, 0x64, 0x33, 0x34, 0x37, 0x32, 0x65, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x64, 0x64, 0x34, 0x62, 0x35, 0x38, 0x30, 0x66, 0x66, 0x31, 0x30, 0x66, 0x65, 0x30, 0x36, 0x63, 0x34, 0x61, 0x30, 0x33, 0x31, 0x31, 0x36, 0x32, 0x33, 0x39, 0x65, 0x66, 0x39, 0x36, 0x36, 0x32, 0x32, 0x62, 0x61, 0x65, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x31, 0x35, 0x37, 0x63, 0x35, 0x38, 0x37, 0x36, 0x63, 0x35, 0x63, 0x61, 0x64, 0x35, 0x35, 0x33, 0x63, 0x39, 0x31, 0x32, 0x63, 0x61, 0x66, 0x36, 0x63, 0x65, 0x32, 0x64, 0x35, 0x32, 0x37, 0x37, 0x65, 0x30, 0x35, 0x63, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x61, 0x31, 0x62, 0x38, 0x38, 0x36, 0x65, 0x33, 0x61, 0x37, 0x39, 0x35, 0x63, 0x39, 0x62, 0x61, 0x37, 0x37, 0x39, 0x31, 0x34, 0x65, 0x30, 0x61, 0x32, 0x66, 0x65, 0x35, 0x36, 0x37, 0x36, 0x66, 0x30, 0x66, 0x35, 0x63, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x30, 0x63, 0x62, 0x61, 0x66, 0x64, 0x33, 0x39, 0x37, 0x65, 0x64, 0x64, 0x35, 0x35, 0x36, 0x63, 0x30, 0x36, 0x37, 0x38, 0x39, 0x38, 0x38, 0x63, 0x62, 0x32, 0x61, 0x66, 0x35, 0x63, 0x32, 0x36, 0x31, 0x37, 0x65, 0x30, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x37, 0x62, 0x62, 0x34, 0x39, 0x65, 0x37, 0x35, 0x34, 0x66, 0x36, 0x66, 0x62, 0x34, 0x66, 0x37, 0x33, 0x33, 0x63, 0x36, 0x65, 0x30, 0x36, 0x66, 0x33, 0x39, 0x38, 0x39, 0x62, 0x34, 0x66, 0x36, 0x35, 0x64, 0x34, 0x62, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x34, 0x62, 0x64, 0x65, 0x63, 0x38, 0x63, 0x33, 0x36, 0x63, 0x35, 0x63, 0x36, 0x38, 0x62, 0x61, 0x61, 0x32, 0x64, 0x64, 0x66, 0x31, 0x64, 0x34, 0x33, 0x31, 0x36, 0x39, 0x33, 0x32, 0x32, 0x39, 0x37, 0x32, 0x36, 0x63, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x34, 0x65, 0x32, 0x38, 0x34, 0x39, 0x62, 0x65, 0x61, 0x35, 0x38, 0x33, 0x61, 0x62, 0x30, 0x63, 0x63, 0x33, 0x37, 0x39, 0x37, 0x35, 0x31, 0x39, 0x30, 0x66, 0x33, 0x32, 0x32, 0x62, 0x33, 0x39, 0x35, 0x30, 0x35, 0x35, 0x35, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x38, 0x30, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x32, 0x31, 0x63, 0x39, 0x63, 0x65, 0x30, 0x31, 0x32, 0x33, 0x32, 0x36, 0x36, 0x35, 0x37, 0x34, 0x31, 0x30, 0x39, 0x36, 0x61, 0x63, 0x30, 0x37, 0x32, 0x33, 0x35, 0x39, 0x30, 0x33, 0x61, 0x64, 0x31, 0x66, 0x65, 0x32, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x36, 0x34, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x33, 0x64, 0x65, 0x64, 0x37, 0x61, 0x34, 0x30, 0x64, 0x33, 0x61, 0x66, 0x66, 0x30, 0x64, 0x37, 0x61, 0x38, 0x63, 0x34, 0x35, 0x66, 0x61, 0x36, 0x31, 0x33, 0x36, 0x61, 0x61, 0x30, 0x34, 0x33, 0x33, 0x64, 0x62, 0x34, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x62, 0x35, 0x62, 0x33, 0x34, 0x64, 0x31, 0x32, 0x34, 0x38, 0x66, 0x63, 0x66, 0x30, 0x31, 0x37, 0x66, 0x38, 0x63, 0x38, 0x66, 0x66, 0x63, 0x34, 0x30, 0x38, 0x63, 0x65, 0x38, 0x39, 0x39, 0x63, 0x65, 0x65, 0x66, 0x39, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x61, 0x31, 0x66, 0x33, 0x32, 0x30, 0x34, 0x30, 0x37, 0x39, 0x36, 0x34, 0x66, 0x64, 0x33, 0x63, 0x38, 0x66, 0x32, 0x65, 0x32, 0x63, 0x63, 0x38, 0x61, 0x34, 0x35, 0x38, 0x30, 0x64, 0x61, 0x39, 0x34, 0x66, 0x30, 0x31, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x38, 0x30, 0x30, 0x64, 0x34, 0x62, 0x34, 0x39, 0x62, 0x61, 0x30, 0x37, 0x32, 0x35, 0x30, 0x34, 0x36, 0x30, 0x66, 0x39, 0x39, 0x33, 0x62, 0x38, 0x63, 0x62, 0x65, 0x30, 0x30, 0x62, 0x32, 0x36, 0x36, 0x61, 0x32, 0x35, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x32, 0x37, 0x64, 0x35, 0x36, 0x65, 0x64, 0x32, 0x64, 0x33, 0x32, 0x37, 0x32, 0x30, 0x64, 0x34, 0x61, 0x62, 0x66, 0x31, 0x30, 0x33, 0x64, 0x36, 0x64, 0x30, 0x65, 0x66, 0x34, 0x64, 0x33, 0x62, 0x63, 0x64, 0x35, 0x35, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x32, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x62, 0x39, 0x63, 0x37, 0x32, 0x31, 0x37, 0x65, 0x36, 0x36, 0x37, 0x34, 0x33, 0x30, 0x33, 0x31, 0x65, 0x62, 0x33, 0x37, 0x37, 0x61, 0x66, 0x36, 0x35, 0x63, 0x37, 0x37, 0x64, 0x62, 0x37, 0x33, 0x35, 0x39, 0x64, 0x63, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x30, 0x33, 0x31, 0x39, 0x64, 0x62, 0x30, 0x61, 0x38, 0x66, 0x39, 0x33, 0x65, 0x35, 0x62, 0x62, 0x37, 0x64, 0x34, 0x64, 0x62, 0x66, 0x34, 0x38, 0x31, 0x36, 0x33, 0x31, 0x34, 0x66, 0x62, 0x65, 0x64, 0x38, 0x33, 0x36, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x32, 0x38, 0x61, 0x32, 0x63, 0x34, 0x30, 0x38, 0x36, 0x30, 0x39, 0x31, 0x63, 0x62, 0x35, 0x64, 0x61, 0x32, 0x32, 0x36, 0x61, 0x36, 0x35, 0x37, 0x63, 0x65, 0x33, 0x32, 0x34, 0x38, 0x65, 0x38, 0x65, 0x61, 0x37, 0x62, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x32, 0x33, 0x61, 0x36, 0x66, 0x65, 0x66, 0x31, 0x61, 0x66, 0x37, 0x62, 0x35, 0x38, 0x31, 0x65, 0x37, 0x37, 0x32, 0x63, 0x66, 0x39, 0x31, 0x38, 0x38, 0x32, 0x64, 0x65, 0x62, 0x32, 0x35, 0x31, 0x36, 0x66, 0x63, 0x30, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x33, 0x36, 0x64, 0x37, 0x61, 0x63, 0x36, 0x33, 0x37, 0x61, 0x34, 0x38, 0x66, 0x36, 0x31, 0x64, 0x33, 0x38, 0x62, 0x31, 0x34, 0x63, 0x66, 0x64, 0x34, 0x38, 0x36, 0x35, 0x64, 0x33, 0x36, 0x64, 0x31, 0x34, 0x32, 0x38, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x63, 0x32, 0x36, 0x30, 0x36, 0x30, 0x39, 0x62, 0x39, 0x64, 0x66, 0x34, 0x30, 0x39, 0x35, 0x65, 0x36, 0x63, 0x35, 0x64, 0x66, 0x66, 0x33, 0x39, 0x38, 0x65, 0x65, 0x62, 0x35, 0x65, 0x32, 0x64, 0x66, 0x34, 0x39, 0x39, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x65, 0x35, 0x63, 0x39, 0x65, 0x33, 0x34, 0x34, 0x63, 0x38, 0x30, 0x36, 0x36, 0x35, 0x30, 0x64, 0x61, 0x63, 0x66, 0x63, 0x39, 0x30, 0x34, 0x64, 0x33, 0x33, 0x65, 0x64, 0x62, 0x61, 0x35, 0x31, 0x30, 0x37, 0x62, 0x30, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x36, 0x37, 0x33, 0x39, 0x36, 0x64, 0x32, 0x35, 0x35, 0x33, 0x66, 0x39, 0x39, 0x38, 0x37, 0x38, 0x35, 0x66, 0x37, 0x30, 0x34, 0x65, 0x30, 0x37, 0x61, 0x36, 0x33, 0x39, 0x31, 0x39, 0x37, 0x64, 0x64, 0x31, 0x39, 0x34, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x30, 0x64, 0x38, 0x31, 0x35, 0x39, 0x63, 0x63, 0x39, 0x34, 0x35, 0x37, 0x36, 0x38, 0x63, 0x37, 0x34, 0x35, 0x30, 0x37, 0x39, 0x30, 0x62, 0x61, 0x30, 0x37, 0x33, 0x65, 0x63, 0x30, 0x64, 0x39, 0x66, 0x38, 0x39, 0x65, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x33, 0x63, 0x34, 0x38, 0x39, 0x33, 0x35, 0x62, 0x65, 0x61, 0x66, 0x66, 0x30, 0x66, 0x64, 0x65, 0x31, 0x39, 0x62, 0x30, 0x34, 0x64, 0x33, 0x30, 0x39, 0x63, 0x64, 0x35, 0x33, 0x30, 0x61, 0x32, 0x38, 0x65, 0x35, 0x32, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x37, 0x66, 0x34, 0x65, 0x30, 0x38, 0x30, 0x39, 0x39, 0x64, 0x38, 0x63, 0x66, 0x33, 0x39, 0x65, 0x65, 0x31, 0x31, 0x36, 0x30, 0x31, 0x38, 0x33, 0x38, 0x65, 0x66, 0x39, 0x66, 0x63, 0x30, 0x36, 0x64, 0x37, 0x66, 0x63, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x37, 0x32, 0x33, 0x65, 0x33, 0x63, 0x33, 0x30, 0x65, 0x38, 0x62, 0x37, 0x33, 0x31, 0x65, 0x65, 0x34, 0x35, 0x36, 0x61, 0x32, 0x39, 0x31, 0x65, 0x65, 0x30, 0x65, 0x37, 0x39, 0x38, 0x62, 0x30, 0x32, 0x30, 0x34, 0x61, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x36, 0x35, 0x32, 0x65, 0x32, 0x61, 0x38, 0x62, 0x37, 0x37, 0x62, 0x64, 0x39, 0x37, 0x61, 0x37, 0x39, 0x30, 0x64, 0x30, 0x65, 0x39, 0x31, 0x33, 0x36, 0x31, 0x63, 0x39, 0x38, 0x38, 0x39, 0x30, 0x64, 0x62, 0x62, 0x30, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x31, 0x30, 0x31, 0x35, 0x62, 0x39, 0x37, 0x36, 0x37, 0x30, 0x62, 0x31, 0x30, 0x64, 0x35, 0x65, 0x35, 0x38, 0x33, 0x66, 0x33, 0x64, 0x36, 0x32, 0x61, 0x36, 0x31, 0x63, 0x31, 0x63, 0x37, 0x39, 0x63, 0x35, 0x31, 0x34, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x63, 0x32, 0x34, 0x61, 0x36, 0x61, 0x39, 0x35, 0x38, 0x63, 0x32, 0x30, 0x63, 0x37, 0x64, 0x31, 0x32, 0x34, 0x39, 0x36, 0x36, 0x30, 0x66, 0x37, 0x35, 0x38, 0x36, 0x32, 0x32, 0x36, 0x39, 0x35, 0x30, 0x62, 0x30, 0x64, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x66, 0x39, 0x65, 0x38, 0x63, 0x39, 0x62, 0x36, 0x32, 0x31, 0x37, 0x64, 0x35, 0x36, 0x37, 0x36, 0x39, 0x61, 0x66, 0x39, 0x37, 0x64, 0x62, 0x62, 0x31, 0x63, 0x38, 0x65, 0x31, 0x62, 0x38, 0x62, 0x65, 0x37, 0x39, 0x39, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x34, 0x33, 0x36, 0x38, 0x39, 0x31, 0x38, 0x61, 0x63, 0x65, 0x36, 0x34, 0x30, 0x39, 0x63, 0x37, 0x39, 0x65, 0x63, 0x61, 0x38, 0x30, 0x63, 0x64, 0x61, 0x61, 0x65, 0x34, 0x33, 0x39, 0x31, 0x64, 0x32, 0x62, 0x36, 0x32, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x33, 0x37, 0x30, 0x37, 0x30, 0x37, 0x31, 0x65, 0x32, 0x61, 0x65, 0x32, 0x31, 0x65, 0x65, 0x64, 0x39, 0x37, 0x37, 0x38, 0x39, 0x31, 0x64, 0x63, 0x37, 0x39, 0x63, 0x64, 0x35, 0x64, 0x38, 0x65, 0x65, 0x31, 0x63, 0x32, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x62, 0x66, 0x64, 0x39, 0x37, 0x38, 0x36, 0x38, 0x39, 0x62, 0x65, 0x63, 0x30, 0x34, 0x38, 0x66, 0x63, 0x37, 0x37, 0x36, 0x61, 0x61, 0x31, 0x35, 0x32, 0x34, 0x37, 0x66, 0x35, 0x65, 0x31, 0x64, 0x37, 0x63, 0x33, 0x39, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x39, 0x31, 0x35, 0x64, 0x34, 0x65, 0x32, 0x32, 0x35, 0x61, 0x36, 0x36, 0x38, 0x31, 0x36, 0x32, 0x61, 0x65, 0x65, 0x37, 0x64, 0x36, 0x63, 0x32, 0x35, 0x66, 0x63, 0x66, 0x63, 0x36, 0x65, 0x64, 0x31, 0x38, 0x64, 0x62, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x33, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x35, 0x35, 0x31, 0x62, 0x61, 0x39, 0x33, 0x63, 0x64, 0x35, 0x34, 0x36, 0x39, 0x33, 0x63, 0x31, 0x38, 0x33, 0x66, 0x62, 0x39, 0x61, 0x64, 0x36, 0x30, 0x64, 0x36, 0x35, 0x65, 0x31, 0x36, 0x30, 0x39, 0x36, 0x37, 0x33, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x63, 0x30, 0x62, 0x30, 0x32, 0x66, 0x61, 0x66, 0x30, 0x32, 0x63, 0x62, 0x35, 0x35, 0x31, 0x39, 0x64, 0x64, 0x61, 0x38, 0x38, 0x34, 0x64, 0x65, 0x37, 0x62, 0x62, 0x63, 0x38, 0x63, 0x38, 0x38, 0x61, 0x32, 0x64, 0x61, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x30, 0x63, 0x35, 0x63, 0x64, 0x37, 0x39, 0x39, 0x65, 0x62, 0x63, 0x34, 0x38, 0x36, 0x34, 0x32, 0x65, 0x66, 0x39, 0x37, 0x64, 0x37, 0x34, 0x65, 0x38, 0x65, 0x34, 0x32, 0x39, 0x30, 0x36, 0x34, 0x66, 0x65, 0x65, 0x34, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x39, 0x33, 0x31, 0x62, 0x34, 0x34, 0x39, 0x65, 0x61, 0x38, 0x66, 0x31, 0x32, 0x63, 0x64, 0x62, 0x64, 0x35, 0x65, 0x32, 0x63, 0x38, 0x63, 0x63, 0x37, 0x36, 0x62, 0x61, 0x64, 0x32, 0x63, 0x32, 0x37, 0x63, 0x30, 0x36, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x61, 0x35, 0x66, 0x65, 0x65, 0x36, 0x33, 0x66, 0x33, 0x33, 0x37, 0x61, 0x33, 0x37, 0x36, 0x65, 0x34, 0x62, 0x39, 0x31, 0x38, 0x65, 0x61, 0x38, 0x32, 0x31, 0x34, 0x38, 0x66, 0x39, 0x34, 0x64, 0x34, 0x38, 0x61, 0x36, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x36, 0x34, 0x32, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x36, 0x63, 0x32, 0x64, 0x66, 0x30, 0x30, 0x65, 0x38, 0x36, 0x65, 0x63, 0x61, 0x34, 0x30, 0x66, 0x32, 0x31, 0x66, 0x66, 0x64, 0x61, 0x31, 0x61, 0x36, 0x37, 0x61, 0x31, 0x36, 0x39, 0x30, 0x66, 0x34, 0x37, 0x37, 0x63, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x65, 0x33, 0x37, 0x65, 0x31, 0x39, 0x34, 0x30, 0x38, 0x66, 0x32, 0x63, 0x66, 0x62, 0x65, 0x63, 0x38, 0x33, 0x33, 0x34, 0x39, 0x64, 0x64, 0x34, 0x38, 0x31, 0x35, 0x33, 0x61, 0x34, 0x61, 0x37, 0x39, 0x35, 0x61, 0x30, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x35, 0x35, 0x61, 0x32, 0x37, 0x62, 0x62, 0x31, 0x65, 0x32, 0x66, 0x64, 0x34, 0x65, 0x32, 0x63, 0x63, 0x37, 0x38, 0x34, 0x63, 0x61, 0x65, 0x65, 0x39, 0x32, 0x39, 0x33, 0x39, 0x66, 0x63, 0x30, 0x36, 0x65, 0x32, 0x66, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x66, 0x39, 0x37, 0x31, 0x39, 0x62, 0x65, 0x38, 0x37, 0x63, 0x36, 0x66, 0x34, 0x36, 0x37, 0x35, 0x36, 0x64, 0x62, 0x34, 0x38, 0x39, 0x31, 0x64, 0x62, 0x39, 0x62, 0x36, 0x31, 0x31, 0x64, 0x32, 0x34, 0x36, 0x39, 0x63, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x32, 0x66, 0x39, 0x30, 0x33, 0x34, 0x63, 0x39, 0x32, 0x35, 0x34, 0x37, 0x31, 0x39, 0x63, 0x33, 0x38, 0x65, 0x35, 0x30, 0x63, 0x39, 0x61, 0x61, 0x36, 0x34, 0x33, 0x30, 0x35, 0x65, 0x64, 0x36, 0x39, 0x36, 0x64, 0x66, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x31, 0x66, 0x31, 0x32, 0x64, 0x37, 0x30, 0x66, 0x34, 0x34, 0x61, 0x61, 0x37, 0x62, 0x31, 0x31, 0x33, 0x62, 0x32, 0x38, 0x35, 0x63, 0x32, 0x32, 0x64, 0x63, 0x64, 0x62, 0x34, 0x35, 0x38, 0x37, 0x33, 0x34, 0x35, 0x34, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x65, 0x34, 0x30, 0x34, 0x37, 0x35, 0x64, 0x33, 0x34, 0x35, 0x62, 0x30, 0x37, 0x31, 0x32, 0x64, 0x65, 0x65, 0x37, 0x30, 0x33, 0x64, 0x38, 0x37, 0x63, 0x64, 0x37, 0x36, 0x35, 0x37, 0x66, 0x63, 0x37, 0x66, 0x33, 0x62, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x31, 0x39, 0x62, 0x66, 0x39, 0x31, 0x63, 0x62, 0x61, 0x64, 0x37, 0x34, 0x63, 0x63, 0x65, 0x62, 0x35, 0x66, 0x38, 0x31, 0x31, 0x64, 0x62, 0x32, 0x37, 0x65, 0x34, 0x31, 0x31, 0x62, 0x63, 0x32, 0x65, 0x61, 0x30, 0x36, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x30, 0x36, 0x32, 0x37, 0x30, 0x32, 0x63, 0x35, 0x39, 0x36, 0x31, 0x35, 0x64, 0x33, 0x34, 0x34, 0x34, 0x65, 0x66, 0x36, 0x32, 0x31, 0x34, 0x62, 0x38, 0x38, 0x36, 0x32, 0x62, 0x30, 0x30, 0x39, 0x61, 0x30, 0x32, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x39, 0x39, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x39, 0x61, 0x63, 0x34, 0x66, 0x62, 0x65, 0x33, 0x38, 0x33, 0x65, 0x33, 0x36, 0x37, 0x33, 0x38, 0x38, 0x35, 0x35, 0x65, 0x33, 0x36, 0x34, 0x61, 0x35, 0x37, 0x66, 0x34, 0x37, 0x31, 0x62, 0x32, 0x62, 0x66, 0x61, 0x31, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x35, 0x39, 0x61, 0x37, 0x38, 0x65, 0x62, 0x39, 0x61, 0x37, 0x34, 0x61, 0x37, 0x66, 0x62, 0x64, 0x61, 0x65, 0x66, 0x61, 0x66, 0x61, 0x38, 0x32, 0x65, 0x61, 0x64, 0x61, 0x38, 0x34, 0x37, 0x35, 0x66, 0x30, 0x37, 0x66, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x36, 0x35, 0x37, 0x37, 0x66, 0x33, 0x39, 0x30, 0x39, 0x61, 0x34, 0x64, 0x36, 0x64, 0x65, 0x30, 0x66, 0x34, 0x31, 0x31, 0x35, 0x32, 0x32, 0x64, 0x34, 0x35, 0x37, 0x30, 0x33, 0x38, 0x36, 0x34, 0x30, 0x30, 0x33, 0x34, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x62, 0x66, 0x32, 0x66, 0x37, 0x62, 0x36, 0x65, 0x33, 0x32, 0x38, 0x61, 0x61, 0x66, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x30, 0x39, 0x33, 0x66, 0x61, 0x32, 0x32, 0x64, 0x61, 0x32, 0x39, 0x65, 0x66, 0x32, 0x66, 0x34, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x30, 0x66, 0x37, 0x31, 0x35, 0x31, 0x34, 0x30, 0x35, 0x30, 0x39, 0x66, 0x66, 0x61, 0x62, 0x66, 0x39, 0x37, 0x34, 0x35, 0x34, 0x36, 0x66, 0x61, 0x62, 0x33, 0x39, 0x30, 0x32, 0x32, 0x61, 0x34, 0x31, 0x39, 0x35, 0x32, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x35, 0x37, 0x32, 0x65, 0x64, 0x64, 0x32, 0x64, 0x38, 0x37, 0x63, 0x61, 0x32, 0x37, 0x31, 0x61, 0x36, 0x37, 0x31, 0x34, 0x63, 0x31, 0x35, 0x61, 0x33, 0x62, 0x33, 0x37, 0x37, 0x36, 0x31, 0x64, 0x63, 0x63, 0x61, 0x30, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x37, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x38, 0x65, 0x63, 0x64, 0x32, 0x35, 0x61, 0x64, 0x63, 0x38, 0x36, 0x62, 0x63, 0x32, 0x30, 0x35, 0x31, 0x64, 0x39, 0x36, 0x66, 0x36, 0x35, 0x33, 0x36, 0x34, 0x38, 0x36, 0x36, 0x62, 0x34, 0x32, 0x61, 0x34, 0x32, 0x36, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x37, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x37, 0x32, 0x39, 0x64, 0x34, 0x38, 0x32, 0x38, 0x32, 0x63, 0x39, 0x65, 0x38, 0x37, 0x31, 0x36, 0x36, 0x64, 0x35, 0x65, 0x65, 0x66, 0x32, 0x64, 0x30, 0x31, 0x65, 0x64, 0x61, 0x39, 0x64, 0x62, 0x66, 0x37, 0x38, 0x38, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x37, 0x36, 0x32, 0x35, 0x36, 0x30, 0x65, 0x38, 0x32, 0x61, 0x39, 0x33, 0x62, 0x33, 0x66, 0x35, 0x32, 0x32, 0x65, 0x30, 0x65, 0x35, 0x32, 0x34, 0x61, 0x64, 0x62, 0x38, 0x36, 0x31, 0x32, 0x63, 0x33, 0x61, 0x37, 0x34, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x30, 0x30, 0x65, 0x34, 0x64, 0x31, 0x63, 0x39, 0x38, 0x32, 0x34, 0x62, 0x61, 0x39, 0x66, 0x35, 0x62, 0x36, 0x33, 0x35, 0x63, 0x66, 0x61, 0x33, 0x61, 0x38, 0x63, 0x32, 0x63, 0x33, 0x38, 0x62, 0x62, 0x64, 0x34, 0x63, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x31, 0x65, 0x66, 0x66, 0x61, 0x62, 0x36, 0x63, 0x66, 0x30, 0x66, 0x35, 0x39, 0x37, 0x32, 0x63, 0x66, 0x66, 0x65, 0x34, 0x64, 0x35, 0x36, 0x35, 0x39, 0x36, 0x65, 0x39, 0x38, 0x39, 0x36, 0x38, 0x31, 0x34, 0x34, 0x61, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x34, 0x65, 0x63, 0x66, 0x32, 0x31, 0x31, 0x37, 0x39, 0x33, 0x31, 0x63, 0x36, 0x64, 0x35, 0x33, 0x35, 0x61, 0x33, 0x31, 0x31, 0x65, 0x34, 0x66, 0x66, 0x65, 0x61, 0x65, 0x66, 0x39, 0x64, 0x34, 0x39, 0x34, 0x30, 0x35, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x39, 0x63, 0x63, 0x34, 0x37, 0x31, 0x31, 0x62, 0x36, 0x32, 0x37, 0x35, 0x35, 0x65, 0x61, 0x32, 0x39, 0x36, 0x34, 0x34, 0x35, 0x61, 0x63, 0x33, 0x62, 0x37, 0x37, 0x66, 0x63, 0x36, 0x33, 0x33, 0x38, 0x32, 0x31, 0x63, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x39, 0x38, 0x39, 0x63, 0x62, 0x34, 0x38, 0x37, 0x62, 0x66, 0x31, 0x61, 0x37, 0x64, 0x31, 0x37, 0x65, 0x34, 0x63, 0x31, 0x62, 0x37, 0x63, 0x34, 0x62, 0x37, 0x61, 0x61, 0x66, 0x64, 0x64, 0x61, 0x36, 0x62, 0x30, 0x61, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x38, 0x35, 0x32, 0x37, 0x66, 0x65, 0x62, 0x66, 0x61, 0x31, 0x61, 0x64, 0x65, 0x32, 0x39, 0x65, 0x32, 0x36, 0x34, 0x31, 0x39, 0x33, 0x32, 0x39, 0x64, 0x33, 0x39, 0x33, 0x62, 0x39, 0x34, 0x30, 0x62, 0x62, 0x62, 0x37, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x65, 0x31, 0x33, 0x65, 0x32, 0x32, 0x33, 0x32, 0x32, 0x61, 0x63, 0x66, 0x62, 0x33, 0x35, 0x35, 0x63, 0x64, 0x32, 0x31, 0x66, 0x64, 0x30, 0x64, 0x66, 0x36, 0x30, 0x63, 0x66, 0x39, 0x33, 0x61, 0x64, 0x64, 0x32, 0x36, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x66, 0x66, 0x32, 0x34, 0x34, 0x66, 0x63, 0x66, 0x65, 0x33, 0x64, 0x34, 0x66, 0x61, 0x32, 0x66, 0x34, 0x66, 0x64, 0x39, 0x39, 0x66, 0x38, 0x37, 0x65, 0x35, 0x35, 0x62, 0x62, 0x33, 0x31, 0x35, 0x62, 0x38, 0x31, 0x65, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x35, 0x38, 0x31, 0x61, 0x35, 0x35, 0x63, 0x65, 0x32, 0x33, 0x61, 0x62, 0x31, 0x30, 0x64, 0x38, 0x61, 0x64, 0x38, 0x63, 0x34, 0x34, 0x33, 0x37, 0x38, 0x66, 0x35, 0x39, 0x30, 0x37, 0x39, 0x62, 0x64, 0x36, 0x66, 0x36, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x37, 0x33, 0x66, 0x61, 0x34, 0x39, 0x62, 0x38, 0x37, 0x31, 0x31, 0x37, 0x63, 0x62, 0x39, 0x30, 0x38, 0x63, 0x66, 0x31, 0x61, 0x62, 0x35, 0x31, 0x32, 0x64, 0x61, 0x37, 0x35, 0x34, 0x61, 0x39, 0x33, 0x32, 0x64, 0x34, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x61, 0x38, 0x32, 0x39, 0x33, 0x33, 0x63, 0x39, 0x65, 0x61, 0x64, 0x61, 0x62, 0x64, 0x39, 0x38, 0x31, 0x65, 0x35, 0x64, 0x36, 0x64, 0x36, 0x30, 0x61, 0x36, 0x38, 0x31, 0x38, 0x66, 0x66, 0x38, 0x30, 0x36, 0x65, 0x33, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x39, 0x38, 0x30, 0x36, 0x30, 0x33, 0x32, 0x62, 0x63, 0x37, 0x64, 0x38, 0x32, 0x38, 0x66, 0x31, 0x39, 0x61, 0x63, 0x36, 0x61, 0x36, 0x34, 0x30, 0x63, 0x36, 0x38, 0x65, 0x33, 0x64, 0x38, 0x32, 0x30, 0x66, 0x61, 0x34, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x37, 0x62, 0x32, 0x64, 0x30, 0x37, 0x33, 0x63, 0x35, 0x39, 0x30, 0x63, 0x35, 0x30, 0x33, 0x30, 0x36, 0x66, 0x35, 0x62, 0x31, 0x31, 0x39, 0x35, 0x61, 0x34, 0x62, 0x32, 0x62, 0x61, 0x39, 0x65, 0x63, 0x64, 0x61, 0x36, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x31, 0x33, 0x64, 0x37, 0x36, 0x30, 0x34, 0x39, 0x38, 0x64, 0x37, 0x31, 0x39, 0x33, 0x63, 0x61, 0x36, 0x38, 0x35, 0x39, 0x62, 0x63, 0x39, 0x35, 0x63, 0x39, 0x30, 0x31, 0x33, 0x38, 0x36, 0x34, 0x32, 0x33, 0x64, 0x37, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x36, 0x37, 0x38, 0x34, 0x61, 0x66, 0x36, 0x30, 0x39, 0x36, 0x33, 0x30, 0x62, 0x30, 0x37, 0x30, 0x64, 0x34, 0x39, 0x61, 0x38, 0x62, 0x63, 0x64, 0x31, 0x32, 0x32, 0x33, 0x35, 0x63, 0x36, 0x34, 0x32, 0x38, 0x61, 0x34, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x65, 0x37, 0x31, 0x36, 0x32, 0x32, 0x62, 0x63, 0x62, 0x64, 0x33, 0x31, 0x63, 0x31, 0x61, 0x33, 0x36, 0x39, 0x37, 0x36, 0x65, 0x37, 0x65, 0x35, 0x66, 0x36, 0x37, 0x30, 0x63, 0x30, 0x37, 0x66, 0x66, 0x65, 0x31, 0x36, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x36, 0x39, 0x38, 0x30, 0x33, 0x35, 0x33, 0x39, 0x31, 0x65, 0x36, 0x37, 0x61, 0x34, 0x39, 0x30, 0x31, 0x33, 0x63, 0x30, 0x30, 0x30, 0x32, 0x30, 0x37, 0x39, 0x35, 0x39, 0x33, 0x31, 0x31, 0x34, 0x66, 0x65, 0x62, 0x33, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x32, 0x38, 0x37, 0x31, 0x65, 0x35, 0x30, 0x37, 0x63, 0x37, 0x62, 0x65, 0x33, 0x39, 0x36, 0x35, 0x34, 0x39, 0x38, 0x65, 0x38, 0x66, 0x62, 0x34, 0x36, 0x32, 0x30, 0x32, 0x35, 0x61, 0x31, 0x61, 0x31, 0x63, 0x34, 0x32, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x37, 0x38, 0x66, 0x62, 0x62, 0x34, 0x64, 0x66, 0x37, 0x36, 0x39, 0x63, 0x65, 0x32, 0x63, 0x31, 0x35, 0x36, 0x39, 0x32, 0x30, 0x63, 0x66, 0x65, 0x64, 0x66, 0x64, 0x61, 0x30, 0x33, 0x33, 0x61, 0x30, 0x65, 0x32, 0x35, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x65, 0x36, 0x66, 0x39, 0x33, 0x64, 0x61, 0x63, 0x32, 0x32, 0x38, 0x62, 0x63, 0x37, 0x35, 0x38, 0x35, 0x61, 0x32, 0x35, 0x37, 0x33, 0x35, 0x61, 0x63, 0x32, 0x64, 0x30, 0x37, 0x36, 0x63, 0x63, 0x33, 0x61, 0x34, 0x30, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x31, 0x66, 0x39, 0x31, 0x66, 0x33, 0x30, 0x31, 0x66, 0x34, 0x62, 0x35, 0x36, 0x35, 0x62, 0x63, 0x61, 0x32, 0x34, 0x37, 0x35, 0x31, 0x61, 0x61, 0x31, 0x66, 0x37, 0x36, 0x31, 0x33, 0x32, 0x32, 0x37, 0x30, 0x39, 0x64, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x37, 0x66, 0x39, 0x35, 0x38, 0x37, 0x66, 0x66, 0x37, 0x61, 0x32, 0x64, 0x37, 0x32, 0x39, 0x35, 0x66, 0x31, 0x66, 0x35, 0x37, 0x31, 0x63, 0x38, 0x38, 0x36, 0x62, 0x64, 0x33, 0x33, 0x39, 0x32, 0x36, 0x61, 0x35, 0x32, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x35, 0x66, 0x35, 0x38, 0x37, 0x65, 0x35, 0x65, 0x66, 0x66, 0x66, 0x37, 0x37, 0x33, 0x61, 0x32, 0x32, 0x30, 0x37, 0x32, 0x36, 0x61, 0x31, 0x33, 0x64, 0x30, 0x66, 0x32, 0x31, 0x33, 0x30, 0x64, 0x39, 0x66, 0x38, 0x39, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x36, 0x61, 0x61, 0x38, 0x38, 0x32, 0x65, 0x65, 0x33, 0x32, 0x32, 0x63, 0x61, 0x38, 0x34, 0x38, 0x35, 0x37, 0x38, 0x63, 0x30, 0x36, 0x63, 0x62, 0x30, 0x66, 0x61, 0x39, 0x31, 0x31, 0x64, 0x33, 0x36, 0x30, 0x38, 0x33, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x32, 0x63, 0x62, 0x35, 0x66, 0x38, 0x36, 0x31, 0x62, 0x31, 0x38, 0x37, 0x66, 0x39, 0x64, 0x66, 0x32, 0x31, 0x63, 0x64, 0x34, 0x34, 0x38, 0x35, 0x62, 0x65, 0x64, 0x39, 0x30, 0x62, 0x35, 0x30, 0x66, 0x66, 0x65, 0x32, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x61, 0x35, 0x37, 0x37, 0x64, 0x63, 0x32, 0x65, 0x62, 0x33, 0x61, 0x65, 0x36, 0x63, 0x62, 0x39, 0x64, 0x66, 0x63, 0x37, 0x37, 0x61, 0x66, 0x36, 0x39, 0x37, 0x64, 0x37, 0x65, 0x66, 0x64, 0x66, 0x65, 0x38, 0x39, 0x61, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x37, 0x33, 0x34, 0x31, 0x39, 0x64, 0x35, 0x63, 0x39, 0x66, 0x36, 0x33, 0x32, 0x39, 0x35, 0x35, 0x31, 0x64, 0x63, 0x34, 0x64, 0x33, 0x64, 0x30, 0x63, 0x65, 0x61, 0x63, 0x31, 0x62, 0x37, 0x30, 0x31, 0x62, 0x38, 0x36, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x36, 0x61, 0x65, 0x30, 0x61, 0x63, 0x61, 0x34, 0x38, 0x65, 0x62, 0x63, 0x66, 0x61, 0x65, 0x31, 0x36, 0x36, 0x30, 0x36, 0x30, 0x32, 0x35, 0x30, 0x35, 0x32, 0x35, 0x66, 0x36, 0x33, 0x39, 0x36, 0x35, 0x65, 0x37, 0x36, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x66, 0x38, 0x64, 0x65, 0x32, 0x63, 0x32, 0x38, 0x33, 0x64, 0x35, 0x66, 0x64, 0x34, 0x61, 0x66, 0x62, 0x64, 0x61, 0x38, 0x35, 0x64, 0x65, 0x64, 0x66, 0x39, 0x37, 0x36, 0x30, 0x65, 0x61, 0x62, 0x62, 0x62, 0x62, 0x35, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x30, 0x61, 0x66, 0x33, 0x34, 0x37, 0x34, 0x65, 0x32, 0x32, 0x66, 0x30, 0x36, 0x39, 0x65, 0x63, 0x33, 0x34, 0x30, 0x37, 0x38, 0x37, 0x30, 0x64, 0x64, 0x37, 0x37, 0x30, 0x34, 0x34, 0x33, 0x64, 0x35, 0x62, 0x31, 0x32, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x32, 0x36, 0x32, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x33, 0x63, 0x32, 0x33, 0x31, 0x34, 0x32, 0x38, 0x33, 0x63, 0x39, 0x32, 0x64, 0x34, 0x62, 0x30, 0x36, 0x34, 0x66, 0x30, 0x61, 0x65, 0x66, 0x39, 0x62, 0x62, 0x35, 0x32, 0x34, 0x36, 0x61, 0x37, 0x30, 0x30, 0x37, 0x66, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x62, 0x33, 0x66, 0x35, 0x36, 0x31, 0x65, 0x65, 0x37, 0x61, 0x36, 0x65, 0x32, 0x35, 0x39, 0x34, 0x31, 0x65, 0x39, 0x38, 0x61, 0x35, 0x33, 0x32, 0x35, 0x62, 0x37, 0x38, 0x61, 0x64, 0x63, 0x37, 0x39, 0x37, 0x38, 0x35, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x34, 0x33, 0x30, 0x36, 0x64, 0x37, 0x66, 0x36, 0x39, 0x34, 0x37, 0x61, 0x63, 0x31, 0x37, 0x34, 0x34, 0x64, 0x34, 0x65, 0x31, 0x33, 0x62, 0x38, 0x65, 0x66, 0x33, 0x32, 0x63, 0x62, 0x36, 0x35, 0x37, 0x65, 0x31, 0x63, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x65, 0x63, 0x32, 0x65, 0x66, 0x65, 0x39, 0x39, 0x66, 0x66, 0x35, 0x63, 0x66, 0x30, 0x30, 0x64, 0x30, 0x33, 0x61, 0x38, 0x33, 0x31, 0x37, 0x62, 0x39, 0x32, 0x61, 0x32, 0x34, 0x61, 0x65, 0x66, 0x34, 0x34, 0x31, 0x66, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x64, 0x62, 0x66, 0x38, 0x61, 0x31, 0x32, 0x38, 0x35, 0x33, 0x62, 0x34, 0x30, 0x61, 0x63, 0x36, 0x31, 0x39, 0x39, 0x36, 0x66, 0x38, 0x62, 0x66, 0x31, 0x64, 0x63, 0x38, 0x66, 0x64, 0x62, 0x61, 0x64, 0x64, 0x64, 0x33, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x39, 0x33, 0x66, 0x61, 0x62, 0x36, 0x65, 0x32, 0x32, 0x38, 0x34, 0x35, 0x66, 0x38, 0x66, 0x34, 0x35, 0x61, 0x30, 0x37, 0x34, 0x39, 0x36, 0x66, 0x31, 0x31, 0x64, 0x65, 0x37, 0x31, 0x35, 0x33, 0x30, 0x64, 0x65, 0x62, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x32, 0x30, 0x34, 0x66, 0x34, 0x66, 0x34, 0x61, 0x62, 0x61, 0x32, 0x35, 0x32, 0x35, 0x62, 0x61, 0x37, 0x32, 0x38, 0x61, 0x66, 0x64, 0x66, 0x37, 0x38, 0x37, 0x39, 0x32, 0x63, 0x62, 0x64, 0x65, 0x62, 0x37, 0x33, 0x35, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x66, 0x61, 0x64, 0x35, 0x30, 0x30, 0x33, 0x38, 0x64, 0x30, 0x64, 0x39, 0x64, 0x34, 0x63, 0x33, 0x66, 0x62, 0x62, 0x34, 0x62, 0x63, 0x65, 0x30, 0x35, 0x36, 0x30, 0x36, 0x65, 0x63, 0x61, 0x64, 0x63, 0x64, 0x35, 0x31, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x30, 0x36, 0x61, 0x61, 0x64, 0x64, 0x62, 0x33, 0x33, 0x36, 0x64, 0x34, 0x35, 0x65, 0x37, 0x39, 0x37, 0x32, 0x65, 0x39, 0x33, 0x63, 0x62, 0x30, 0x37, 0x35, 0x34, 0x37, 0x31, 0x64, 0x31, 0x35, 0x38, 0x39, 0x37, 0x62, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x38, 0x61, 0x31, 0x65, 0x65, 0x30, 0x65, 0x64, 0x33, 0x33, 0x31, 0x64, 0x37, 0x39, 0x35, 0x32, 0x63, 0x63, 0x62, 0x65, 0x31, 0x63, 0x37, 0x39, 0x37, 0x34, 0x62, 0x32, 0x38, 0x35, 0x32, 0x62, 0x64, 0x31, 0x39, 0x33, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x38, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x30, 0x32, 0x32, 0x38, 0x65, 0x34, 0x62, 0x62, 0x31, 0x32, 0x61, 0x38, 0x64, 0x34, 0x62, 0x35, 0x65, 0x30, 0x61, 0x37, 0x39, 0x37, 0x62, 0x30, 0x63, 0x35, 0x63, 0x66, 0x32, 0x61, 0x37, 0x35, 0x30, 0x39, 0x31, 0x33, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x33, 0x61, 0x31, 0x61, 0x61, 0x34, 0x34, 0x38, 0x38, 0x62, 0x33, 0x35, 0x31, 0x61, 0x61, 0x37, 0x35, 0x36, 0x30, 0x63, 0x66, 0x35, 0x65, 0x65, 0x36, 0x33, 0x30, 0x61, 0x32, 0x66, 0x64, 0x34, 0x35, 0x63, 0x33, 0x32, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x38, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x37, 0x32, 0x65, 0x38, 0x35, 0x32, 0x35, 0x38, 0x32, 0x65, 0x30, 0x39, 0x33, 0x34, 0x33, 0x34, 0x34, 0x61, 0x30, 0x66, 0x65, 0x64, 0x32, 0x31, 0x37, 0x38, 0x33, 0x30, 0x34, 0x64, 0x66, 0x32, 0x35, 0x64, 0x34, 0x36, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x65, 0x61, 0x32, 0x31, 0x36, 0x33, 0x61, 0x33, 0x38, 0x63, 0x64, 0x66, 0x39, 0x61, 0x31, 0x32, 0x33, 0x66, 0x38, 0x32, 0x61, 0x35, 0x65, 0x63, 0x30, 0x30, 0x32, 0x35, 0x38, 0x64, 0x61, 0x65, 0x30, 0x62, 0x63, 0x37, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x66, 0x65, 0x64, 0x30, 0x61, 0x65, 0x65, 0x36, 0x66, 0x35, 0x64, 0x66, 0x64, 0x37, 0x65, 0x32, 0x35, 0x37, 0x36, 0x39, 0x32, 0x35, 0x34, 0x63, 0x33, 0x63, 0x66, 0x61, 0x64, 0x31, 0x35, 0x61, 0x64, 0x65, 0x63, 0x63, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x35, 0x62, 0x37, 0x34, 0x30, 0x36, 0x32, 0x30, 0x66, 0x31, 0x37, 0x33, 0x66, 0x31, 0x36, 0x65, 0x35, 0x32, 0x34, 0x37, 0x31, 0x64, 0x63, 0x33, 0x38, 0x62, 0x39, 0x63, 0x35, 0x31, 0x34, 0x61, 0x30, 0x62, 0x31, 0x35, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x65, 0x33, 0x30, 0x36, 0x32, 0x62, 0x32, 0x33, 0x32, 0x31, 0x65, 0x39, 0x64, 0x66, 0x62, 0x30, 0x38, 0x37, 0x35, 0x63, 0x65, 0x33, 0x38, 0x34, 0x39, 0x63, 0x39, 0x62, 0x32, 0x65, 0x33, 0x35, 0x32, 0x32, 0x64, 0x35, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x33, 0x66, 0x62, 0x61, 0x65, 0x62, 0x62, 0x65, 0x34, 0x36, 0x62, 0x33, 0x35, 0x62, 0x36, 0x65, 0x35, 0x62, 0x37, 0x34, 0x39, 0x34, 0x36, 0x61, 0x35, 0x66, 0x39, 0x39, 0x62, 0x63, 0x31, 0x35, 0x38, 0x35, 0x63, 0x61, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x38, 0x31, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x61, 0x38, 0x65, 0x34, 0x37, 0x31, 0x65, 0x61, 0x66, 0x62, 0x37, 0x39, 0x38, 0x66, 0x34, 0x35, 0x35, 0x34, 0x63, 0x63, 0x36, 0x65, 0x35, 0x32, 0x36, 0x37, 0x33, 0x30, 0x66, 0x64, 0x35, 0x36, 0x65, 0x36, 0x32, 0x63, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x37, 0x64, 0x64, 0x30, 0x35, 0x33, 0x38, 0x35, 0x39, 0x65, 0x64, 0x66, 0x66, 0x31, 0x63, 0x62, 0x36, 0x66, 0x39, 0x64, 0x32, 0x61, 0x63, 0x62, 0x65, 0x64, 0x36, 0x64, 0x64, 0x35, 0x65, 0x33, 0x33, 0x32, 0x34, 0x32, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x34, 0x33, 0x34, 0x35, 0x64, 0x36, 0x38, 0x31, 0x32, 0x65, 0x38, 0x37, 0x30, 0x61, 0x65, 0x39, 0x30, 0x63, 0x35, 0x36, 0x38, 0x63, 0x36, 0x37, 0x64, 0x32, 0x63, 0x35, 0x36, 0x37, 0x63, 0x66, 0x62, 0x34, 0x66, 0x30, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x61, 0x30, 0x38, 0x32, 0x35, 0x32, 0x63, 0x38, 0x35, 0x39, 0x35, 0x31, 0x37, 0x37, 0x63, 0x63, 0x32, 0x65, 0x36, 0x30, 0x66, 0x63, 0x32, 0x37, 0x35, 0x39, 0x33, 0x65, 0x32, 0x33, 0x37, 0x39, 0x63, 0x38, 0x31, 0x66, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x61, 0x66, 0x32, 0x31, 0x61, 0x63, 0x62, 0x65, 0x34, 0x38, 0x32, 0x66, 0x38, 0x31, 0x33, 0x31, 0x38, 0x39, 0x36, 0x61, 0x32, 0x32, 0x38, 0x30, 0x33, 0x36, 0x62, 0x61, 0x35, 0x31, 0x62, 0x31, 0x39, 0x34, 0x35, 0x33, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x65, 0x33, 0x66, 0x65, 0x38, 0x36, 0x65, 0x39, 0x33, 0x64, 0x61, 0x34, 0x38, 0x36, 0x62, 0x31, 0x34, 0x32, 0x36, 0x36, 0x65, 0x61, 0x64, 0x66, 0x30, 0x35, 0x36, 0x63, 0x62, 0x66, 0x61, 0x34, 0x64, 0x39, 0x31, 0x34, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x34, 0x62, 0x30, 0x33, 0x62, 0x62, 0x61, 0x38, 0x35, 0x38, 0x32, 0x61, 0x65, 0x35, 0x34, 0x39, 0x38, 0x65, 0x32, 0x64, 0x63, 0x32, 0x32, 0x64, 0x31, 0x39, 0x39, 0x34, 0x39, 0x34, 0x36, 0x37, 0x61, 0x62, 0x35, 0x33, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x31, 0x31, 0x38, 0x65, 0x61, 0x33, 0x63, 0x38, 0x33, 0x35, 0x30, 0x35, 0x61, 0x39, 0x64, 0x38, 0x39, 0x33, 0x62, 0x62, 0x36, 0x37, 0x65, 0x32, 0x64, 0x65, 0x31, 0x34, 0x32, 0x64, 0x35, 0x33, 0x37, 0x61, 0x33, 0x65, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x32, 0x66, 0x31, 0x63, 0x32, 0x36, 0x38, 0x39, 0x61, 0x35, 0x63, 0x65, 0x37, 0x39, 0x66, 0x31, 0x62, 0x63, 0x39, 0x37, 0x30, 0x62, 0x33, 0x31, 0x35, 0x38, 0x34, 0x66, 0x31, 0x62, 0x63, 0x66, 0x32, 0x32, 0x38, 0x33, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x32, 0x38, 0x65, 0x34, 0x63, 0x62, 0x65, 0x33, 0x34, 0x65, 0x31, 0x35, 0x31, 0x30, 0x61, 0x66, 0x62, 0x37, 0x32, 0x63, 0x32, 0x62, 0x65, 0x65, 0x61, 0x63, 0x38, 0x61, 0x34, 0x35, 0x31, 0x33, 0x65, 0x61, 0x65, 0x62, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x37, 0x62, 0x63, 0x63, 0x30, 0x38, 0x35, 0x61, 0x62, 0x33, 0x66, 0x37, 0x32, 0x39, 0x66, 0x32, 0x34, 0x34, 0x30, 0x30, 0x34, 0x31, 0x36, 0x38, 0x33, 0x37, 0x62, 0x36, 0x39, 0x39, 0x33, 0x36, 0x62, 0x61, 0x38, 0x38, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x63, 0x37, 0x34, 0x38, 0x37, 0x33, 0x61, 0x66, 0x39, 0x32, 0x32, 0x62, 0x39, 0x64, 0x66, 0x34, 0x37, 0x34, 0x38, 0x35, 0x33, 0x62, 0x30, 0x66, 0x61, 0x37, 0x66, 0x66, 0x30, 0x62, 0x66, 0x38, 0x63, 0x38, 0x32, 0x36, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x65, 0x62, 0x64, 0x31, 0x63, 0x37, 0x63, 0x61, 0x64, 0x32, 0x61, 0x66, 0x66, 0x31, 0x39, 0x32, 0x37, 0x35, 0x63, 0x36, 0x35, 0x37, 0x63, 0x34, 0x64, 0x38, 0x30, 0x38, 0x64, 0x30, 0x31, 0x30, 0x65, 0x66, 0x61, 0x30, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x63, 0x30, 0x34, 0x62, 0x34, 0x64, 0x38, 0x62, 0x38, 0x32, 0x63, 0x61, 0x66, 0x36, 0x37, 0x30, 0x39, 0x39, 0x36, 0x66, 0x31, 0x36, 0x30, 0x63, 0x33, 0x36, 0x32, 0x39, 0x34, 0x30, 0x64, 0x36, 0x36, 0x66, 0x63, 0x66, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x39, 0x37, 0x39, 0x34, 0x38, 0x31, 0x32, 0x31, 0x37, 0x33, 0x32, 0x65, 0x36, 0x33, 0x64, 0x39, 0x63, 0x31, 0x34, 0x38, 0x31, 0x39, 0x34, 0x65, 0x63, 0x61, 0x64, 0x34, 0x36, 0x65, 0x33, 0x30, 0x62, 0x37, 0x34, 0x39, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x37, 0x39, 0x37, 0x62, 0x66, 0x62, 0x31, 0x32, 0x63, 0x39, 0x62, 0x65, 0x64, 0x36, 0x38, 0x32, 0x62, 0x39, 0x31, 0x66, 0x62, 0x63, 0x35, 0x39, 0x33, 0x35, 0x39, 0x31, 0x64, 0x35, 0x65, 0x34, 0x30, 0x32, 0x33, 0x37, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x39, 0x62, 0x38, 0x63, 0x33, 0x34, 0x62, 0x37, 0x38, 0x65, 0x65, 0x39, 0x34, 0x37, 0x66, 0x66, 0x38, 0x31, 0x34, 0x37, 0x32, 0x65, 0x64, 0x61, 0x37, 0x61, 0x66, 0x39, 0x64, 0x32, 0x30, 0x34, 0x62, 0x63, 0x38, 0x34, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x33, 0x66, 0x35, 0x37, 0x62, 0x38, 0x65, 0x65, 0x36, 0x34, 0x33, 0x34, 0x64, 0x30, 0x34, 0x37, 0x32, 0x32, 0x33, 0x64, 0x65, 0x66, 0x37, 0x34, 0x62, 0x32, 0x30, 0x66, 0x36, 0x33, 0x66, 0x39, 0x65, 0x34, 0x66, 0x39, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x61, 0x65, 0x31, 0x38, 0x37, 0x39, 0x30, 0x30, 0x37, 0x64, 0x38, 0x30, 0x31, 0x63, 0x62, 0x35, 0x66, 0x33, 0x35, 0x32, 0x37, 0x31, 0x36, 0x61, 0x34, 0x64, 0x64, 0x38, 0x62, 0x61, 0x32, 0x37, 0x32, 0x31, 0x64, 0x65, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x34, 0x62, 0x62, 0x31, 0x63, 0x36, 0x32, 0x33, 0x62, 0x61, 0x32, 0x38, 0x64, 0x63, 0x34, 0x32, 0x62, 0x64, 0x61, 0x61, 0x61, 0x36, 0x65, 0x37, 0x34, 0x65, 0x31, 0x64, 0x32, 0x61, 0x61, 0x31, 0x32, 0x35, 0x36, 0x63, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x33, 0x63, 0x30, 0x30, 0x64, 0x30, 0x30, 0x33, 0x38, 0x38, 0x65, 0x63, 0x62, 0x66, 0x34, 0x66, 0x32, 0x36, 0x33, 0x64, 0x30, 0x61, 0x63, 0x37, 0x37, 0x38, 0x62, 0x62, 0x34, 0x31, 0x61, 0x35, 0x37, 0x61, 0x34, 0x30, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x32, 0x63, 0x31, 0x66, 0x38, 0x38, 0x39, 0x36, 0x31, 0x64, 0x30, 0x31, 0x39, 0x63, 0x33, 0x65, 0x39, 0x65, 0x61, 0x33, 0x33, 0x30, 0x30, 0x39, 0x31, 0x35, 0x32, 0x65, 0x30, 0x36, 0x39, 0x33, 0x66, 0x62, 0x66, 0x38, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x39, 0x39, 0x63, 0x62, 0x64, 0x35, 0x61, 0x36, 0x61, 0x39, 0x64, 0x63, 0x64, 0x34, 0x62, 0x39, 0x36, 0x36, 0x62, 0x65, 0x33, 0x38, 0x37, 0x64, 0x36, 0x39, 0x37, 0x37, 0x35, 0x64, 0x61, 0x35, 0x65, 0x33, 0x33, 0x63, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x61, 0x33, 0x31, 0x61, 0x37, 0x63, 0x33, 0x38, 0x66, 0x33, 0x64, 0x62, 0x30, 0x39, 0x33, 0x32, 0x32, 0x65, 0x61, 0x65, 0x31, 0x31, 0x64, 0x32, 0x32, 0x37, 0x32, 0x31, 0x34, 0x31, 0x65, 0x61, 0x32, 0x32, 0x39, 0x39, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x31, 0x61, 0x31, 0x35, 0x61, 0x63, 0x63, 0x31, 0x39, 0x39, 0x63, 0x38, 0x39, 0x66, 0x61, 0x39, 0x63, 0x62, 0x32, 0x32, 0x34, 0x34, 0x31, 0x63, 0x63, 0x37, 0x30, 0x33, 0x33, 0x30, 0x62, 0x64, 0x63, 0x63, 0x65, 0x36, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x62, 0x65, 0x64, 0x36, 0x65, 0x37, 0x65, 0x30, 0x63, 0x61, 0x39, 0x63, 0x38, 0x34, 0x66, 0x62, 0x65, 0x39, 0x65, 0x62, 0x63, 0x66, 0x39, 0x64, 0x34, 0x65, 0x66, 0x39, 0x62, 0x62, 0x34, 0x39, 0x34, 0x32, 0x38, 0x31, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x63, 0x66, 0x64, 0x36, 0x30, 0x31, 0x38, 0x38, 0x65, 0x66, 0x64, 0x66, 0x62, 0x32, 0x66, 0x38, 0x63, 0x32, 0x65, 0x37, 0x62, 0x31, 0x36, 0x39, 0x38, 0x61, 0x62, 0x62, 0x39, 0x35, 0x32, 0x36, 0x63, 0x31, 0x35, 0x31, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x39, 0x33, 0x36, 0x66, 0x33, 0x62, 0x39, 0x64, 0x32, 0x32, 0x63, 0x34, 0x30, 0x33, 0x64, 0x62, 0x35, 0x65, 0x37, 0x33, 0x30, 0x66, 0x66, 0x31, 0x37, 0x37, 0x64, 0x37, 0x34, 0x65, 0x65, 0x66, 0x34, 0x32, 0x64, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x31, 0x66, 0x65, 0x37, 0x31, 0x32, 0x66, 0x36, 0x34, 0x32, 0x30, 0x37, 0x61, 0x32, 0x66, 0x64, 0x35, 0x30, 0x32, 0x32, 0x37, 0x32, 0x38, 0x38, 0x34, 0x33, 0x35, 0x34, 0x38, 0x62, 0x66, 0x62, 0x38, 0x63, 0x62, 0x62, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x64, 0x35, 0x34, 0x65, 0x38, 0x33, 0x61, 0x64, 0x34, 0x38, 0x36, 0x61, 0x39, 0x33, 0x34, 0x63, 0x66, 0x61, 0x65, 0x61, 0x65, 0x32, 0x38, 0x33, 0x61, 0x33, 0x33, 0x65, 0x66, 0x64, 0x32, 0x32, 0x37, 0x63, 0x30, 0x65, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x33, 0x39, 0x61, 0x33, 0x64, 0x38, 0x63, 0x61, 0x32, 0x38, 0x30, 0x65, 0x32, 0x37, 0x64, 0x32, 0x34, 0x31, 0x35, 0x62, 0x32, 0x36, 0x64, 0x31, 0x66, 0x63, 0x37, 0x39, 0x33, 0x32, 0x32, 0x38, 0x62, 0x36, 0x36, 0x30, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x31, 0x66, 0x33, 0x34, 0x62, 0x35, 0x32, 0x33, 0x65, 0x35, 0x62, 0x34, 0x31, 0x63, 0x30, 0x39, 0x63, 0x38, 0x37, 0x63, 0x32, 0x39, 0x38, 0x65, 0x32, 0x39, 0x39, 0x63, 0x62, 0x63, 0x30, 0x65, 0x32, 0x39, 0x64, 0x30, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x33, 0x31, 0x36, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x61, 0x61, 0x36, 0x38, 0x65, 0x65, 0x36, 0x63, 0x64, 0x66, 0x30, 0x64, 0x33, 0x34, 0x34, 0x35, 0x34, 0x61, 0x37, 0x36, 0x39, 0x62, 0x30, 0x64, 0x61, 0x31, 0x34, 0x38, 0x61, 0x31, 0x66, 0x61, 0x61, 0x61, 0x31, 0x38, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x33, 0x38, 0x61, 0x37, 0x37, 0x36, 0x38, 0x64, 0x39, 0x63, 0x32, 0x61, 0x63, 0x61, 0x38, 0x62, 0x61, 0x32, 0x37, 0x39, 0x61, 0x64, 0x66, 0x65, 0x65, 0x34, 0x62, 0x31, 0x66, 0x34, 0x39, 0x31, 0x65, 0x33, 0x32, 0x36, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x65, 0x37, 0x37, 0x61, 0x34, 0x37, 0x34, 0x30, 0x62, 0x61, 0x30, 0x38, 0x65, 0x37, 0x66, 0x37, 0x33, 0x66, 0x62, 0x65, 0x33, 0x61, 0x31, 0x36, 0x37, 0x34, 0x39, 0x31, 0x32, 0x39, 0x33, 0x31, 0x37, 0x34, 0x32, 0x65, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x36, 0x37, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x65, 0x38, 0x31, 0x30, 0x66, 0x65, 0x30, 0x66, 0x65, 0x63, 0x63, 0x39, 0x36, 0x34, 0x34, 0x37, 0x34, 0x61, 0x31, 0x64, 0x62, 0x39, 0x37, 0x37, 0x32, 0x38, 0x62, 0x63, 0x38, 0x37, 0x65, 0x39, 0x37, 0x33, 0x66, 0x63, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x63, 0x32, 0x38, 0x62, 0x35, 0x36, 0x37, 0x38, 0x61, 0x66, 0x33, 0x37, 0x64, 0x37, 0x32, 0x37, 0x65, 0x63, 0x30, 0x35, 0x65, 0x34, 0x34, 0x34, 0x37, 0x37, 0x39, 0x30, 0x66, 0x31, 0x35, 0x66, 0x37, 0x31, 0x66, 0x32, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x36, 0x63, 0x30, 0x36, 0x32, 0x31, 0x39, 0x33, 0x65, 0x61, 0x63, 0x32, 0x33, 0x64, 0x32, 0x66, 0x64, 0x62, 0x66, 0x39, 0x39, 0x37, 0x64, 0x35, 0x30, 0x36, 0x33, 0x61, 0x33, 0x34, 0x36, 0x62, 0x62, 0x33, 0x62, 0x34, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x37, 0x35, 0x62, 0x39, 0x35, 0x32, 0x38, 0x66, 0x32, 0x33, 0x61, 0x66, 0x31, 0x66, 0x30, 0x65, 0x32, 0x65, 0x63, 0x30, 0x38, 0x61, 0x63, 0x38, 0x65, 0x62, 0x61, 0x61, 0x37, 0x38, 0x36, 0x61, 0x32, 0x63, 0x62, 0x38, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x35, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x39, 0x64, 0x38, 0x61, 0x65, 0x34, 0x35, 0x32, 0x64, 0x63, 0x66, 0x33, 0x62, 0x36, 0x61, 0x63, 0x36, 0x34, 0x35, 0x65, 0x36, 0x33, 0x30, 0x34, 0x30, 0x39, 0x33, 0x38, 0x35, 0x35, 0x35, 0x31, 0x66, 0x61, 0x61, 0x65, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x62, 0x63, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x33, 0x35, 0x39, 0x38, 0x62, 0x35, 0x32, 0x32, 0x31, 0x36, 0x36, 0x64, 0x36, 0x65, 0x39, 0x64, 0x64, 0x61, 0x31, 0x32, 0x31, 0x64, 0x36, 0x32, 0x37, 0x64, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x33, 0x36, 0x61, 0x62, 0x61, 0x35, 0x63, 0x33, 0x31, 0x65, 0x61, 0x30, 0x63, 0x61, 0x37, 0x65, 0x32, 0x37, 0x37, 0x62, 0x61, 0x61, 0x33, 0x32, 0x65, 0x63, 0x34, 0x36, 0x63, 0x65, 0x39, 0x33, 0x63, 0x66, 0x37, 0x35, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x63, 0x62, 0x63, 0x64, 0x37, 0x61, 0x35, 0x37, 0x65, 0x61, 0x39, 0x64, 0x62, 0x32, 0x33, 0x34, 0x39, 0x62, 0x38, 0x37, 0x38, 0x61, 0x66, 0x33, 0x34, 0x62, 0x31, 0x61, 0x64, 0x36, 0x34, 0x32, 0x61, 0x37, 0x66, 0x31, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x61, 0x61, 0x65, 0x35, 0x39, 0x37, 0x36, 0x38, 0x65, 0x64, 0x64, 0x66, 0x66, 0x38, 0x33, 0x63, 0x66, 0x65, 0x36, 0x30, 0x62, 0x62, 0x35, 0x31, 0x32, 0x65, 0x37, 0x33, 0x30, 0x61, 0x30, 0x35, 0x61, 0x31, 0x36, 0x31, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x38, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x65, 0x39, 0x33, 0x62, 0x34, 0x39, 0x65, 0x61, 0x37, 0x63, 0x35, 0x30, 0x39, 0x64, 0x65, 0x37, 0x63, 0x34, 0x34, 0x64, 0x36, 0x63, 0x66, 0x65, 0x64, 0x64, 0x65, 0x66, 0x35, 0x39, 0x31, 0x30, 0x64, 0x65, 0x61, 0x61, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x33, 0x64, 0x39, 0x38, 0x30, 0x32, 0x32, 0x30, 0x66, 0x61, 0x62, 0x32, 0x35, 0x39, 0x61, 0x66, 0x36, 0x61, 0x31, 0x66, 0x34, 0x62, 0x33, 0x38, 0x63, 0x66, 0x30, 0x65, 0x66, 0x33, 0x63, 0x36, 0x65, 0x32, 0x65, 0x61, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x64, 0x30, 0x61, 0x66, 0x31, 0x31, 0x66, 0x66, 0x32, 0x38, 0x37, 0x30, 0x64, 0x61, 0x30, 0x36, 0x38, 0x31, 0x30, 0x30, 0x34, 0x61, 0x66, 0x65, 0x31, 0x38, 0x62, 0x30, 0x31, 0x33, 0x66, 0x37, 0x62, 0x64, 0x33, 0x38, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x33, 0x65, 0x35, 0x63, 0x36, 0x33, 0x33, 0x32, 0x32, 0x31, 0x61, 0x38, 0x66, 0x37, 0x33, 0x36, 0x33, 0x65, 0x36, 0x35, 0x38, 0x37, 0x30, 0x63, 0x39, 0x66, 0x32, 0x38, 0x37, 0x34, 0x32, 0x34, 0x64, 0x32, 0x61, 0x39, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x33, 0x33, 0x34, 0x62, 0x66, 0x65, 0x30, 0x34, 0x66, 0x66, 0x66, 0x61, 0x35, 0x39, 0x30, 0x32, 0x31, 0x33, 0x65, 0x61, 0x62, 0x33, 0x36, 0x35, 0x31, 0x34, 0x66, 0x33, 0x33, 0x38, 0x62, 0x38, 0x36, 0x34, 0x62, 0x37, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x31, 0x66, 0x31, 0x39, 0x37, 0x31, 0x61, 0x37, 0x37, 0x35, 0x63, 0x33, 0x35, 0x30, 0x34, 0x66, 0x65, 0x66, 0x35, 0x30, 0x37, 0x39, 0x66, 0x36, 0x34, 0x30, 0x63, 0x32, 0x63, 0x34, 0x62, 0x63, 0x65, 0x37, 0x61, 0x63, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x34, 0x34, 0x63, 0x34, 0x37, 0x66, 0x63, 0x33, 0x30, 0x33, 0x61, 0x63, 0x37, 0x36, 0x65, 0x37, 0x34, 0x66, 0x39, 0x37, 0x31, 0x39, 0x34, 0x63, 0x63, 0x61, 0x36, 0x37, 0x62, 0x35, 0x62, 0x62, 0x33, 0x63, 0x30, 0x32, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x37, 0x34, 0x66, 0x35, 0x65, 0x35, 0x38, 0x65, 0x32, 0x65, 0x64, 0x66, 0x37, 0x36, 0x64, 0x61, 0x66, 0x37, 0x30, 0x31, 0x35, 0x31, 0x39, 0x36, 0x34, 0x61, 0x30, 0x62, 0x38, 0x66, 0x31, 0x64, 0x65, 0x30, 0x36, 0x36, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x38, 0x62, 0x39, 0x31, 0x62, 0x33, 0x35, 0x31, 0x39, 0x30, 0x62, 0x36, 0x64, 0x39, 0x64, 0x65, 0x65, 0x64, 0x30, 0x32, 0x31, 0x63, 0x33, 0x30, 0x61, 0x66, 0x30, 0x39, 0x34, 0x62, 0x39, 0x35, 0x33, 0x66, 0x64, 0x63, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x33, 0x38, 0x64, 0x65, 0x38, 0x34, 0x31, 0x66, 0x61, 0x64, 0x37, 0x66, 0x35, 0x33, 0x66, 0x65, 0x30, 0x32, 0x64, 0x61, 0x31, 0x31, 0x35, 0x62, 0x64, 0x38, 0x36, 0x61, 0x61, 0x66, 0x36, 0x36, 0x32, 0x34, 0x36, 0x36, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x31, 0x36, 0x37, 0x35, 0x61, 0x32, 0x35, 0x35, 0x35, 0x34, 0x36, 0x30, 0x37, 0x61, 0x33, 0x62, 0x36, 0x63, 0x39, 0x32, 0x61, 0x39, 0x65, 0x65, 0x38, 0x66, 0x33, 0x36, 0x66, 0x37, 0x35, 0x65, 0x64, 0x64, 0x33, 0x65, 0x33, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x61, 0x38, 0x37, 0x30, 0x35, 0x62, 0x66, 0x35, 0x35, 0x63, 0x66, 0x32, 0x31, 0x39, 0x63, 0x30, 0x39, 0x35, 0x36, 0x62, 0x35, 0x65, 0x33, 0x66, 0x63, 0x30, 0x31, 0x63, 0x34, 0x34, 0x37, 0x34, 0x61, 0x36, 0x63, 0x64, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x39, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x30, 0x35, 0x66, 0x31, 0x32, 0x30, 0x63, 0x38, 0x39, 0x65, 0x39, 0x66, 0x62, 0x63, 0x39, 0x33, 0x64, 0x34, 0x61, 0x62, 0x30, 0x63, 0x35, 0x65, 0x32, 0x62, 0x34, 0x61, 0x30, 0x64, 0x66, 0x30, 0x39, 0x32, 0x62, 0x34, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x64, 0x31, 0x31, 0x39, 0x35, 0x66, 0x37, 0x39, 0x37, 0x64, 0x34, 0x66, 0x33, 0x35, 0x37, 0x31, 0x37, 0x64, 0x31, 0x35, 0x65, 0x36, 0x66, 0x39, 0x38, 0x31, 0x30, 0x61, 0x39, 0x61, 0x33, 0x66, 0x66, 0x35, 0x35, 0x34, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x61, 0x36, 0x31, 0x64, 0x63, 0x33, 0x30, 0x61, 0x38, 0x65, 0x33, 0x62, 0x33, 0x30, 0x61, 0x37, 0x36, 0x33, 0x63, 0x34, 0x32, 0x31, 0x33, 0x63, 0x38, 0x30, 0x31, 0x63, 0x62, 0x66, 0x39, 0x38, 0x37, 0x33, 0x38, 0x31, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x62, 0x64, 0x66, 0x33, 0x34, 0x66, 0x34, 0x63, 0x63, 0x63, 0x34, 0x38, 0x33, 0x65, 0x34, 0x63, 0x61, 0x35, 0x33, 0x30, 0x63, 0x63, 0x37, 0x63, 0x66, 0x32, 0x62, 0x62, 0x31, 0x38, 0x66, 0x65, 0x62, 0x65, 0x39, 0x32, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x36, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x65, 0x30, 0x39, 0x65, 0x39, 0x38, 0x66, 0x65, 0x31, 0x33, 0x30, 0x30, 0x33, 0x33, 0x32, 0x31, 0x30, 0x34, 0x63, 0x31, 0x63, 0x61, 0x33, 0x34, 0x66, 0x62, 0x66, 0x61, 0x63, 0x35, 0x35, 0x34, 0x33, 0x36, 0x34, 0x65, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x64, 0x36, 0x38, 0x36, 0x32, 0x64, 0x35, 0x31, 0x37, 0x64, 0x34, 0x64, 0x65, 0x34, 0x35, 0x35, 0x39, 0x64, 0x34, 0x65, 0x65, 0x63, 0x30, 0x61, 0x30, 0x36, 0x63, 0x61, 0x64, 0x30, 0x35, 0x65, 0x32, 0x66, 0x39, 0x34, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x39, 0x34, 0x65, 0x63, 0x39, 0x64, 0x61, 0x33, 0x31, 0x30, 0x62, 0x63, 0x36, 0x62, 0x34, 0x62, 0x62, 0x64, 0x66, 0x35, 0x34, 0x33, 0x62, 0x30, 0x65, 0x66, 0x34, 0x35, 0x61, 0x62, 0x66, 0x63, 0x33, 0x65, 0x31, 0x62, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x33, 0x34, 0x38, 0x36, 0x31, 0x64, 0x33, 0x34, 0x32, 0x32, 0x35, 0x33, 0x31, 0x39, 0x34, 0x66, 0x66, 0x63, 0x36, 0x36, 0x35, 0x32, 0x64, 0x66, 0x64, 0x65, 0x35, 0x31, 0x61, 0x62, 0x34, 0x34, 0x63, 0x61, 0x64, 0x33, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x36, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x30, 0x61, 0x65, 0x37, 0x66, 0x61, 0x62, 0x34, 0x63, 0x66, 0x62, 0x35, 0x61, 0x36, 0x34, 0x36, 0x65, 0x65, 0x30, 0x34, 0x63, 0x65, 0x61, 0x64, 0x66, 0x39, 0x62, 0x66, 0x39, 0x64, 0x64, 0x35, 0x61, 0x38, 0x65, 0x35, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x39, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x32, 0x62, 0x64, 0x66, 0x61, 0x39, 0x31, 0x37, 0x63, 0x31, 0x66, 0x33, 0x31, 0x30, 0x65, 0x36, 0x66, 0x61, 0x33, 0x35, 0x61, 0x61, 0x38, 0x61, 0x66, 0x31, 0x36, 0x39, 0x33, 0x39, 0x63, 0x32, 0x33, 0x33, 0x63, 0x64, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x30, 0x36, 0x30, 0x34, 0x36, 0x32, 0x63, 0x34, 0x37, 0x66, 0x66, 0x39, 0x36, 0x37, 0x39, 0x62, 0x61, 0x65, 0x66, 0x30, 0x37, 0x31, 0x35, 0x39, 0x63, 0x61, 0x65, 0x30, 0x38, 0x63, 0x32, 0x39, 0x66, 0x32, 0x37, 0x34, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x64, 0x31, 0x32, 0x65, 0x38, 0x34, 0x61, 0x32, 0x65, 0x34, 0x63, 0x34, 0x61, 0x36, 0x33, 0x34, 0x35, 0x61, 0x66, 0x31, 0x64, 0x64, 0x31, 0x64, 0x61, 0x39, 0x66, 0x32, 0x35, 0x30, 0x34, 0x61, 0x32, 0x61, 0x39, 0x39, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x35, 0x30, 0x30, 0x31, 0x37, 0x38, 0x63, 0x62, 0x39, 0x39, 0x38, 0x66, 0x31, 0x32, 0x36, 0x34, 0x31, 0x37, 0x38, 0x33, 0x31, 0x61, 0x30, 0x38, 0x63, 0x32, 0x64, 0x37, 0x61, 0x62, 0x66, 0x66, 0x66, 0x36, 0x61, 0x62, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x38, 0x39, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x33, 0x37, 0x37, 0x61, 0x33, 0x38, 0x35, 0x32, 0x37, 0x32, 0x39, 0x30, 0x30, 0x63, 0x62, 0x34, 0x33, 0x36, 0x61, 0x33, 0x62, 0x62, 0x37, 0x39, 0x36, 0x32, 0x63, 0x64, 0x66, 0x66, 0x65, 0x39, 0x33, 0x66, 0x35, 0x64, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x61, 0x38, 0x33, 0x61, 0x30, 0x37, 0x33, 0x38, 0x37, 0x39, 0x39, 0x62, 0x39, 0x37, 0x31, 0x62, 0x66, 0x32, 0x64, 0x65, 0x37, 0x30, 0x38, 0x63, 0x32, 0x65, 0x62, 0x66, 0x39, 0x31, 0x31, 0x63, 0x61, 0x37, 0x39, 0x65, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x61, 0x35, 0x65, 0x34, 0x64, 0x65, 0x34, 0x33, 0x39, 0x33, 0x65, 0x65, 0x63, 0x63, 0x66, 0x30, 0x35, 0x38, 0x31, 0x61, 0x63, 0x31, 0x31, 0x62, 0x35, 0x32, 0x63, 0x36, 0x38, 0x33, 0x63, 0x37, 0x36, 0x65, 0x61, 0x31, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x37, 0x66, 0x64, 0x65, 0x61, 0x66, 0x66, 0x39, 0x31, 0x64, 0x34, 0x34, 0x36, 0x30, 0x66, 0x65, 0x36, 0x63, 0x64, 0x30, 0x65, 0x38, 0x61, 0x31, 0x62, 0x30, 0x62, 0x64, 0x38, 0x64, 0x32, 0x32, 0x61, 0x36, 0x32, 0x65, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x66, 0x35, 0x38, 0x36, 0x30, 0x31, 0x34, 0x39, 0x65, 0x34, 0x62, 0x62, 0x63, 0x30, 0x34, 0x62, 0x38, 0x61, 0x63, 0x35, 0x62, 0x32, 0x37, 0x32, 0x62, 0x65, 0x35, 0x35, 0x61, 0x64, 0x31, 0x61, 0x63, 0x61, 0x35, 0x38, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x31, 0x33, 0x35, 0x65, 0x62, 0x31, 0x35, 0x61, 0x38, 0x62, 0x61, 0x63, 0x37, 0x32, 0x62, 0x36, 0x39, 0x39, 0x31, 0x35, 0x33, 0x34, 0x32, 0x61, 0x36, 0x30, 0x62, 0x62, 0x63, 0x30, 0x36, 0x62, 0x37, 0x65, 0x30, 0x37, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x64, 0x34, 0x61, 0x33, 0x30, 0x39, 0x36, 0x38, 0x61, 0x33, 0x39, 0x65, 0x32, 0x62, 0x33, 0x34, 0x39, 0x38, 0x63, 0x33, 0x61, 0x36, 0x61, 0x34, 0x65, 0x64, 0x34, 0x35, 0x63, 0x31, 0x63, 0x36, 0x36, 0x34, 0x36, 0x38, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x34, 0x62, 0x37, 0x32, 0x36, 0x34, 0x64, 0x64, 0x38, 0x33, 0x36, 0x62, 0x65, 0x65, 0x38, 0x65, 0x38, 0x37, 0x39, 0x37, 0x30, 0x33, 0x34, 0x30, 0x65, 0x64, 0x32, 0x62, 0x39, 0x61, 0x65, 0x64, 0x38, 0x65, 0x64, 0x30, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x37, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x30, 0x61, 0x33, 0x35, 0x34, 0x63, 0x65, 0x63, 0x30, 0x34, 0x64, 0x36, 0x39, 0x65, 0x35, 0x64, 0x39, 0x36, 0x64, 0x64, 0x63, 0x30, 0x63, 0x35, 0x31, 0x33, 0x38, 0x64, 0x33, 0x64, 0x33, 0x33, 0x31, 0x35, 0x30, 0x61, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x33, 0x64, 0x38, 0x33, 0x62, 0x65, 0x30, 0x39, 0x34, 0x35, 0x39, 0x65, 0x66, 0x38, 0x33, 0x39, 0x30, 0x62, 0x32, 0x65, 0x33, 0x30, 0x64, 0x37, 0x66, 0x37, 0x63, 0x32, 0x38, 0x64, 0x65, 0x34, 0x62, 0x34, 0x32, 0x38, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x62, 0x66, 0x37, 0x63, 0x64, 0x35, 0x64, 0x38, 0x61, 0x39, 0x32, 0x39, 0x65, 0x31, 0x63, 0x37, 0x38, 0x35, 0x66, 0x39, 0x65, 0x35, 0x34, 0x34, 0x39, 0x31, 0x30, 0x36, 0x61, 0x63, 0x32, 0x33, 0x32, 0x34, 0x36, 0x33, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x66, 0x38, 0x65, 0x66, 0x36, 0x64, 0x39, 0x37, 0x30, 0x36, 0x33, 0x36, 0x62, 0x30, 0x64, 0x63, 0x61, 0x61, 0x34, 0x66, 0x32, 0x30, 0x30, 0x66, 0x66, 0x64, 0x63, 0x39, 0x65, 0x37, 0x35, 0x61, 0x66, 0x31, 0x37, 0x34, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x66, 0x30, 0x39, 0x64, 0x37, 0x30, 0x32, 0x34, 0x33, 0x66, 0x33, 0x39, 0x65, 0x64, 0x38, 0x63, 0x64, 0x38, 0x30, 0x30, 0x62, 0x66, 0x39, 0x36, 0x35, 0x31, 0x34, 0x37, 0x39, 0x65, 0x38, 0x66, 0x34, 0x61, 0x63, 0x61, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x38, 0x63, 0x39, 0x31, 0x63, 0x61, 0x64, 0x64, 0x39, 0x32, 0x34, 0x63, 0x39, 0x32, 0x35, 0x37, 0x39, 0x65, 0x31, 0x31, 0x62, 0x34, 0x31, 0x32, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x39, 0x35, 0x36, 0x63, 0x64, 0x61, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x38, 0x33, 0x36, 0x31, 0x38, 0x38, 0x64, 0x39, 0x61, 0x32, 0x39, 0x32, 0x35, 0x33, 0x65, 0x30, 0x63, 0x62, 0x64, 0x61, 0x36, 0x35, 0x37, 0x31, 0x62, 0x30, 0x35, 0x38, 0x63, 0x32, 0x38, 0x39, 0x61, 0x30, 0x62, 0x62, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x61, 0x36, 0x39, 0x34, 0x36, 0x65, 0x66, 0x66, 0x64, 0x35, 0x66, 0x66, 0x35, 0x33, 0x31, 0x35, 0x34, 0x66, 0x38, 0x32, 0x30, 0x31, 0x30, 0x32, 0x35, 0x33, 0x64, 0x66, 0x34, 0x37, 0x61, 0x65, 0x32, 0x38, 0x30, 0x63, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x63, 0x37, 0x65, 0x62, 0x63, 0x35, 0x62, 0x33, 0x65, 0x37, 0x61, 0x66, 0x31, 0x36, 0x66, 0x34, 0x37, 0x64, 0x63, 0x35, 0x36, 0x31, 0x37, 0x61, 0x62, 0x31, 0x30, 0x65, 0x30, 0x66, 0x33, 0x39, 0x62, 0x34, 0x61, 0x66, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x37, 0x65, 0x63, 0x64, 0x61, 0x32, 0x32, 0x35, 0x36, 0x37, 0x63, 0x32, 0x64, 0x39, 0x31, 0x63, 0x62, 0x30, 0x33, 0x66, 0x38, 0x63, 0x35, 0x32, 0x31, 0x35, 0x63, 0x32, 0x32, 0x65, 0x39, 0x64, 0x63, 0x64, 0x61, 0x39, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x36, 0x36, 0x62, 0x38, 0x34, 0x37, 0x36, 0x39, 0x35, 0x36, 0x36, 0x61, 0x62, 0x36, 0x37, 0x39, 0x34, 0x35, 0x64, 0x35, 0x66, 0x61, 0x38, 0x31, 0x33, 0x37, 0x33, 0x35, 0x35, 0x36, 0x62, 0x63, 0x63, 0x33, 0x61, 0x31, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x33, 0x37, 0x33, 0x64, 0x61, 0x61, 0x62, 0x34, 0x36, 0x33, 0x31, 0x36, 0x66, 0x64, 0x37, 0x65, 0x31, 0x35, 0x37, 0x36, 0x63, 0x36, 0x31, 0x65, 0x36, 0x61, 0x66, 0x66, 0x63, 0x62, 0x36, 0x35, 0x35, 0x39, 0x64, 0x64, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x35, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x61, 0x65, 0x62, 0x61, 0x38, 0x66, 0x63, 0x30, 0x62, 0x62, 0x64, 0x61, 0x35, 0x35, 0x33, 0x63, 0x61, 0x37, 0x32, 0x65, 0x33, 0x30, 0x65, 0x66, 0x33, 0x64, 0x37, 0x33, 0x32, 0x65, 0x32, 0x36, 0x65, 0x38, 0x32, 0x30, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x38, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x35, 0x34, 0x63, 0x31, 0x39, 0x64, 0x39, 0x65, 0x66, 0x33, 0x38, 0x37, 0x33, 0x62, 0x66, 0x64, 0x31, 0x66, 0x37, 0x61, 0x36, 0x32, 0x32, 0x64, 0x30, 0x32, 0x64, 0x38, 0x36, 0x32, 0x34, 0x39, 0x61, 0x33, 0x32, 0x38, 0x66, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x32, 0x38, 0x34, 0x37, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x35, 0x33, 0x30, 0x39, 0x61, 0x37, 0x64, 0x34, 0x35, 0x64, 0x31, 0x38, 0x31, 0x32, 0x66, 0x35, 0x31, 0x65, 0x36, 0x65, 0x38, 0x64, 0x66, 0x35, 0x61, 0x37, 0x62, 0x39, 0x36, 0x66, 0x36, 0x63, 0x39, 0x30, 0x38, 0x38, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x30, 0x30, 0x39, 0x65, 0x33, 0x63, 0x36, 0x34, 0x38, 0x38, 0x62, 0x64, 0x35, 0x65, 0x35, 0x37, 0x30, 0x64, 0x31, 0x64, 0x61, 0x33, 0x34, 0x65, 0x61, 0x62, 0x65, 0x32, 0x38, 0x65, 0x64, 0x30, 0x32, 0x34, 0x64, 0x65, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x39, 0x37, 0x37, 0x63, 0x61, 0x64, 0x37, 0x64, 0x30, 0x64, 0x63, 0x64, 0x63, 0x35, 0x32, 0x62, 0x39, 0x61, 0x63, 0x39, 0x66, 0x32, 0x66, 0x66, 0x61, 0x31, 0x33, 0x36, 0x65, 0x38, 0x36, 0x34, 0x32, 0x38, 0x38, 0x32, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x33, 0x39, 0x61, 0x62, 0x64, 0x66, 0x61, 0x65, 0x33, 0x65, 0x39, 0x61, 0x66, 0x35, 0x34, 0x35, 0x37, 0x66, 0x35, 0x32, 0x65, 0x64, 0x32, 0x62, 0x39, 0x31, 0x66, 0x64, 0x30, 0x61, 0x62, 0x34, 0x64, 0x39, 0x63, 0x37, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x34, 0x65, 0x63, 0x36, 0x61, 0x30, 0x61, 0x65, 0x37, 0x66, 0x35, 0x61, 0x39, 0x34, 0x32, 0x37, 0x64, 0x32, 0x33, 0x64, 0x62, 0x39, 0x37, 0x32, 0x34, 0x63, 0x30, 0x64, 0x30, 0x63, 0x66, 0x66, 0x62, 0x32, 0x61, 0x62, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x32, 0x61, 0x36, 0x63, 0x32, 0x64, 0x39, 0x38, 0x35, 0x64, 0x61, 0x66, 0x30, 0x65, 0x34, 0x66, 0x35, 0x66, 0x32, 0x30, 0x37, 0x61, 0x65, 0x38, 0x35, 0x31, 0x61, 0x61, 0x66, 0x37, 0x32, 0x39, 0x62, 0x33, 0x33, 0x32, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x65, 0x35, 0x32, 0x66, 0x63, 0x35, 0x33, 0x33, 0x64, 0x37, 0x64, 0x64, 0x36, 0x30, 0x38, 0x63, 0x39, 0x32, 0x61, 0x32, 0x36, 0x30, 0x62, 0x33, 0x37, 0x63, 0x33, 0x66, 0x34, 0x35, 0x64, 0x65, 0x62, 0x34, 0x65, 0x62, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x62, 0x32, 0x65, 0x36, 0x61, 0x37, 0x32, 0x61, 0x34, 0x30, 0x62, 0x61, 0x36, 0x65, 0x64, 0x39, 0x30, 0x38, 0x63, 0x64, 0x62, 0x63, 0x65, 0x63, 0x33, 0x63, 0x35, 0x36, 0x31, 0x32, 0x35, 0x38, 0x33, 0x31, 0x33, 0x32, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x30, 0x33, 0x38, 0x36, 0x30, 0x62, 0x31, 0x39, 0x31, 0x30, 0x30, 0x38, 0x63, 0x31, 0x35, 0x35, 0x38, 0x33, 0x62, 0x66, 0x63, 0x38, 0x38, 0x31, 0x35, 0x38, 0x30, 0x39, 0x39, 0x33, 0x30, 0x31, 0x37, 0x36, 0x32, 0x38, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x32, 0x32, 0x38, 0x32, 0x34, 0x30, 0x66, 0x39, 0x39, 0x65, 0x31, 0x64, 0x65, 0x39, 0x63, 0x62, 0x33, 0x32, 0x64, 0x38, 0x32, 0x63, 0x30, 0x66, 0x32, 0x66, 0x61, 0x39, 0x61, 0x33, 0x64, 0x34, 0x34, 0x62, 0x30, 0x62, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x35, 0x34, 0x64, 0x61, 0x65, 0x61, 0x64, 0x62, 0x35, 0x34, 0x35, 0x38, 0x33, 0x38, 0x63, 0x62, 0x63, 0x36, 0x61, 0x61, 0x30, 0x63, 0x35, 0x35, 0x37, 0x35, 0x31, 0x39, 0x30, 0x32, 0x66, 0x35, 0x32, 0x38, 0x36, 0x38, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x39, 0x32, 0x61, 0x62, 0x61, 0x33, 0x38, 0x65, 0x37, 0x32, 0x61, 0x30, 0x39, 0x38, 0x31, 0x37, 0x30, 0x62, 0x39, 0x32, 0x39, 0x35, 0x39, 0x32, 0x34, 0x36, 0x35, 0x33, 0x37, 0x61, 0x32, 0x65, 0x35, 0x35, 0x35, 0x36, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x33, 0x64, 0x37, 0x61, 0x66, 0x66, 0x61, 0x63, 0x64, 0x63, 0x33, 0x65, 0x39, 0x66, 0x33, 0x64, 0x61, 0x65, 0x37, 0x61, 0x66, 0x63, 0x62, 0x34, 0x30, 0x30, 0x36, 0x66, 0x35, 0x38, 0x66, 0x38, 0x61, 0x34, 0x34, 0x36, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x64, 0x37, 0x38, 0x64, 0x38, 0x39, 0x62, 0x33, 0x35, 0x66, 0x34, 0x37, 0x32, 0x37, 0x31, 0x36, 0x65, 0x63, 0x65, 0x61, 0x66, 0x65, 0x62, 0x66, 0x36, 0x30, 0x30, 0x35, 0x32, 0x37, 0x64, 0x33, 0x61, 0x31, 0x66, 0x39, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x30, 0x66, 0x39, 0x64, 0x65, 0x36, 0x65, 0x30, 0x61, 0x66, 0x37, 0x65, 0x63, 0x30, 0x32, 0x61, 0x30, 0x37, 0x63, 0x36, 0x30, 0x39, 0x63, 0x61, 0x38, 0x34, 0x34, 0x37, 0x66, 0x31, 0x35, 0x37, 0x65, 0x36, 0x33, 0x34, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x33, 0x35, 0x32, 0x66, 0x64, 0x66, 0x38, 0x31, 0x39, 0x62, 0x61, 0x32, 0x36, 0x35, 0x66, 0x31, 0x34, 0x63, 0x30, 0x36, 0x61, 0x36, 0x33, 0x31, 0x35, 0x63, 0x34, 0x61, 0x63, 0x31, 0x66, 0x65, 0x31, 0x33, 0x31, 0x62, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x34, 0x37, 0x33, 0x32, 0x38, 0x65, 0x65, 0x30, 0x33, 0x32, 0x30, 0x31, 0x63, 0x39, 0x64, 0x33, 0x35, 0x65, 0x64, 0x32, 0x62, 0x35, 0x34, 0x31, 0x32, 0x62, 0x32, 0x35, 0x64, 0x65, 0x63, 0x63, 0x38, 0x35, 0x39, 0x33, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x33, 0x65, 0x33, 0x35, 0x39, 0x61, 0x33, 0x33, 0x39, 0x37, 0x39, 0x34, 0x34, 0x63, 0x35, 0x61, 0x32, 0x37, 0x35, 0x61, 0x62, 0x31, 0x61, 0x32, 0x66, 0x37, 0x30, 0x61, 0x35, 0x65, 0x35, 0x61, 0x33, 0x66, 0x36, 0x39, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x66, 0x35, 0x38, 0x65, 0x66, 0x62, 0x65, 0x61, 0x30, 0x37, 0x38, 0x34, 0x65, 0x62, 0x30, 0x36, 0x38, 0x61, 0x64, 0x65, 0x63, 0x66, 0x61, 0x30, 0x62, 0x62, 0x32, 0x31, 0x35, 0x30, 0x38, 0x34, 0x63, 0x37, 0x33, 0x61, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x62, 0x66, 0x65, 0x31, 0x62, 0x34, 0x35, 0x63, 0x61, 0x63, 0x64, 0x65, 0x36, 0x32, 0x37, 0x34, 0x66, 0x64, 0x38, 0x36, 0x30, 0x38, 0x64, 0x39, 0x61, 0x31, 0x37, 0x38, 0x62, 0x66, 0x33, 0x65, 0x65, 0x62, 0x36, 0x65, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x64, 0x35, 0x62, 0x31, 0x37, 0x66, 0x66, 0x65, 0x32, 0x64, 0x37, 0x62, 0x62, 0x62, 0x37, 0x39, 0x63, 0x63, 0x37, 0x64, 0x37, 0x39, 0x33, 0x30, 0x62, 0x63, 0x62, 0x32, 0x65, 0x35, 0x31, 0x38, 0x66, 0x62, 0x31, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x61, 0x32, 0x39, 0x63, 0x35, 0x30, 0x37, 0x39, 0x65, 0x32, 0x36, 0x62, 0x33, 0x66, 0x31, 0x38, 0x33, 0x31, 0x38, 0x62, 0x62, 0x32, 0x65, 0x35, 0x30, 0x65, 0x38, 0x65, 0x38, 0x62, 0x33, 0x34, 0x36, 0x65, 0x35, 0x62, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x33, 0x39, 0x32, 0x38, 0x35, 0x32, 0x66, 0x33, 0x61, 0x62, 0x64, 0x39, 0x32, 0x66, 0x66, 0x34, 0x62, 0x62, 0x35, 0x62, 0x62, 0x32, 0x36, 0x63, 0x62, 0x36, 0x30, 0x38, 0x37, 0x34, 0x66, 0x32, 0x62, 0x65, 0x36, 0x37, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x38, 0x35, 0x32, 0x39, 0x34, 0x33, 0x34, 0x39, 0x32, 0x39, 0x37, 0x30, 0x66, 0x38, 0x64, 0x36, 0x32, 0x39, 0x61, 0x31, 0x35, 0x33, 0x36, 0x36, 0x63, 0x64, 0x64, 0x61, 0x30, 0x36, 0x61, 0x39, 0x34, 0x66, 0x34, 0x35, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x35, 0x64, 0x66, 0x63, 0x31, 0x65, 0x61, 0x32, 0x31, 0x61, 0x64, 0x63, 0x34, 0x32, 0x63, 0x66, 0x38, 0x63, 0x33, 0x66, 0x36, 0x65, 0x33, 0x36, 0x31, 0x65, 0x32, 0x34, 0x33, 0x66, 0x64, 0x30, 0x64, 0x61, 0x36, 0x31, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x32, 0x62, 0x66, 0x63, 0x33, 0x36, 0x31, 0x30, 0x36, 0x66, 0x30, 0x33, 0x38, 0x32, 0x35, 0x30, 0x63, 0x30, 0x31, 0x38, 0x30, 0x31, 0x36, 0x38, 0x35, 0x37, 0x38, 0x35, 0x62, 0x31, 0x36, 0x63, 0x38, 0x36, 0x63, 0x36, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x36, 0x30, 0x61, 0x65, 0x65, 0x31, 0x61, 0x37, 0x38, 0x66, 0x38, 0x65, 0x64, 0x61, 0x38, 0x62, 0x34, 0x32, 0x34, 0x63, 0x37, 0x33, 0x65, 0x33, 0x35, 0x33, 0x33, 0x35, 0x34, 0x61, 0x65, 0x36, 0x37, 0x63, 0x33, 0x30, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x39, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x32, 0x39, 0x32, 0x39, 0x30, 0x30, 0x33, 0x38, 0x34, 0x39, 0x33, 0x35, 0x35, 0x39, 0x31, 0x39, 0x34, 0x65, 0x39, 0x34, 0x36, 0x64, 0x34, 0x65, 0x34, 0x36, 0x30, 0x62, 0x39, 0x36, 0x66, 0x63, 0x33, 0x38, 0x61, 0x31, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x39, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x30, 0x36, 0x65, 0x33, 0x36, 0x64, 0x39, 0x32, 0x39, 0x62, 0x66, 0x34, 0x35, 0x64, 0x38, 0x66, 0x31, 0x36, 0x32, 0x33, 0x31, 0x62, 0x31, 0x32, 0x36, 0x61, 0x30, 0x31, 0x31, 0x61, 0x65, 0x32, 0x38, 0x33, 0x64, 0x39, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x64, 0x30, 0x33, 0x35, 0x37, 0x32, 0x61, 0x34, 0x35, 0x32, 0x34, 0x35, 0x64, 0x62, 0x64, 0x34, 0x33, 0x36, 0x38, 0x63, 0x34, 0x66, 0x38, 0x32, 0x63, 0x39, 0x35, 0x37, 0x31, 0x34, 0x62, 0x64, 0x32, 0x31, 0x36, 0x37, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x36, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x34, 0x33, 0x32, 0x35, 0x33, 0x38, 0x65, 0x33, 0x35, 0x62, 0x37, 0x36, 0x36, 0x34, 0x39, 0x35, 0x36, 0x61, 0x65, 0x34, 0x39, 0x35, 0x61, 0x33, 0x32, 0x61, 0x62, 0x64, 0x66, 0x30, 0x34, 0x31, 0x61, 0x37, 0x61, 0x32, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x37, 0x36, 0x32, 0x36, 0x34, 0x62, 0x65, 0x63, 0x38, 0x35, 0x32, 0x36, 0x63, 0x30, 0x63, 0x30, 0x66, 0x32, 0x37, 0x30, 0x36, 0x37, 0x37, 0x61, 0x62, 0x61, 0x66, 0x34, 0x66, 0x30, 0x65, 0x34, 0x34, 0x31, 0x65, 0x31, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x38, 0x31, 0x34, 0x65, 0x33, 0x34, 0x35, 0x32, 0x33, 0x65, 0x33, 0x38, 0x65, 0x31, 0x66, 0x39, 0x32, 0x37, 0x61, 0x37, 0x64, 0x63, 0x65, 0x38, 0x34, 0x36, 0x36, 0x61, 0x34, 0x34, 0x37, 0x61, 0x30, 0x39, 0x33, 0x36, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x38, 0x61, 0x35, 0x36, 0x39, 0x65, 0x39, 0x36, 0x35, 0x35, 0x32, 0x34, 0x65, 0x62, 0x31, 0x64, 0x30, 0x61, 0x63, 0x33, 0x64, 0x33, 0x37, 0x33, 0x33, 0x65, 0x61, 0x62, 0x39, 0x30, 0x39, 0x66, 0x62, 0x33, 0x64, 0x36, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x64, 0x63, 0x30, 0x39, 0x66, 0x37, 0x31, 0x37, 0x66, 0x63, 0x32, 0x61, 0x35, 0x62, 0x36, 0x39, 0x66, 0x64, 0x36, 0x30, 0x62, 0x61, 0x30, 0x38, 0x65, 0x62, 0x66, 0x34, 0x30, 0x62, 0x66, 0x34, 0x65, 0x38, 0x32, 0x34, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x39, 0x61, 0x37, 0x33, 0x33, 0x65, 0x36, 0x62, 0x38, 0x35, 0x35, 0x61, 0x63, 0x35, 0x39, 0x32, 0x64, 0x36, 0x36, 0x33, 0x31, 0x35, 0x36, 0x31, 0x38, 0x36, 0x61, 0x38, 0x61, 0x31, 0x37, 0x34, 0x64, 0x32, 0x34, 0x34, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x33, 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x64, 0x66, 0x61, 0x63, 0x62, 0x39, 0x64, 0x39, 0x30, 0x32, 0x33, 0x63, 0x33, 0x34, 0x31, 0x37, 0x31, 0x38, 0x32, 0x65, 0x39, 0x31, 0x30, 0x30, 0x65, 0x38, 0x65, 0x61, 0x31, 0x64, 0x33, 0x37, 0x33, 0x33, 0x39, 0x33, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x36, 0x34, 0x34, 0x30, 0x61, 0x65, 0x62, 0x33, 0x37, 0x33, 0x37, 0x62, 0x38, 0x65, 0x66, 0x30, 0x66, 0x31, 0x61, 0x66, 0x39, 0x62, 0x30, 0x63, 0x31, 0x35, 0x66, 0x34, 0x63, 0x32, 0x31, 0x34, 0x66, 0x66, 0x63, 0x37, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x32, 0x65, 0x35, 0x63, 0x34, 0x33, 0x62, 0x30, 0x66, 0x35, 0x32, 0x34, 0x33, 0x38, 0x39, 0x36, 0x35, 0x35, 0x61, 0x39, 0x62, 0x33, 0x66, 0x66, 0x32, 0x34, 0x66, 0x32, 0x64, 0x34, 0x64, 0x62, 0x33, 0x64, 0x61, 0x31, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x35, 0x61, 0x36, 0x30, 0x36, 0x38, 0x39, 0x39, 0x39, 0x38, 0x36, 0x33, 0x39, 0x61, 0x64, 0x37, 0x35, 0x62, 0x63, 0x31, 0x30, 0x35, 0x61, 0x33, 0x37, 0x31, 0x37, 0x34, 0x33, 0x65, 0x65, 0x66, 0x30, 0x66, 0x37, 0x39, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x32, 0x37, 0x61, 0x39, 0x66, 0x63, 0x38, 0x32, 0x65, 0x31, 0x63, 0x66, 0x66, 0x63, 0x35, 0x63, 0x31, 0x37, 0x35, 0x66, 0x61, 0x31, 0x34, 0x38, 0x35, 0x61, 0x39, 0x62, 0x65, 0x66, 0x61, 0x32, 0x63, 0x64, 0x62, 0x64, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x38, 0x38, 0x33, 0x61, 0x32, 0x34, 0x66, 0x37, 0x66, 0x31, 0x36, 0x36, 0x32, 0x30, 0x35, 0x66, 0x31, 0x61, 0x36, 0x61, 0x39, 0x39, 0x34, 0x39, 0x30, 0x37, 0x36, 0x63, 0x32, 0x36, 0x61, 0x37, 0x36, 0x65, 0x37, 0x31, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x39, 0x35, 0x66, 0x65, 0x35, 0x66, 0x66, 0x63, 0x66, 0x39, 0x39, 0x38, 0x66, 0x39, 0x66, 0x39, 0x61, 0x63, 0x30, 0x65, 0x39, 0x61, 0x38, 0x31, 0x64, 0x61, 0x62, 0x38, 0x33, 0x65, 0x61, 0x64, 0x37, 0x37, 0x30, 0x30, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x39, 0x37, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x30, 0x39, 0x35, 0x35, 0x64, 0x63, 0x30, 0x62, 0x63, 0x31, 0x35, 0x36, 0x66, 0x36, 0x63, 0x34, 0x31, 0x38, 0x34, 0x39, 0x66, 0x36, 0x62, 0x64, 0x37, 0x37, 0x36, 0x62, 0x61, 0x34, 0x34, 0x62, 0x30, 0x65, 0x66, 0x30, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x32, 0x30, 0x33, 0x65, 0x32, 0x32, 0x39, 0x64, 0x37, 0x65, 0x36, 0x64, 0x34, 0x31, 0x39, 0x64, 0x66, 0x34, 0x33, 0x37, 0x38, 0x65, 0x61, 0x39, 0x38, 0x37, 0x31, 0x35, 0x35, 0x31, 0x35, 0x66, 0x36, 0x33, 0x31, 0x34, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x34, 0x39, 0x39, 0x61, 0x31, 0x32, 0x32, 0x38, 0x66, 0x66, 0x32, 0x64, 0x37, 0x65, 0x65, 0x33, 0x30, 0x37, 0x37, 0x35, 0x39, 0x33, 0x36, 0x34, 0x35, 0x30, 0x36, 0x66, 0x38, 0x65, 0x38, 0x63, 0x38, 0x33, 0x30, 0x37, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x30, 0x34, 0x63, 0x65, 0x63, 0x34, 0x32, 0x30, 0x61, 0x64, 0x34, 0x33, 0x32, 0x32, 0x31, 0x35, 0x32, 0x34, 0x36, 0x64, 0x37, 0x37, 0x66, 0x65, 0x31, 0x37, 0x38, 0x64, 0x33, 0x33, 0x39, 0x65, 0x64, 0x30, 0x62, 0x35, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x32, 0x62, 0x35, 0x66, 0x34, 0x34, 0x38, 0x66, 0x33, 0x35, 0x32, 0x38, 0x64, 0x33, 0x66, 0x65, 0x34, 0x31, 0x63, 0x63, 0x37, 0x64, 0x31, 0x66, 0x61, 0x39, 0x63, 0x30, 0x64, 0x63, 0x37, 0x36, 0x66, 0x31, 0x62, 0x37, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x35, 0x30, 0x35, 0x38, 0x37, 0x34, 0x31, 0x32, 0x38, 0x32, 0x32, 0x33, 0x30, 0x34, 0x65, 0x62, 0x63, 0x62, 0x61, 0x30, 0x37, 0x64, 0x61, 0x62, 0x33, 0x61, 0x30, 0x66, 0x30, 0x39, 0x66, 0x66, 0x66, 0x65, 0x65, 0x34, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x65, 0x32, 0x61, 0x30, 0x34, 0x64, 0x33, 0x39, 0x30, 0x39, 0x65, 0x66, 0x34, 0x35, 0x34, 0x65, 0x35, 0x34, 0x34, 0x63, 0x63, 0x66, 0x64, 0x36, 0x31, 0x34, 0x62, 0x66, 0x65, 0x66, 0x61, 0x37, 0x31, 0x30, 0x38, 0x39, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x61, 0x32, 0x63, 0x34, 0x65, 0x35, 0x39, 0x65, 0x31, 0x63, 0x37, 0x66, 0x63, 0x35, 0x34, 0x38, 0x30, 0x35, 0x35, 0x38, 0x30, 0x34, 0x33, 0x38, 0x61, 0x65, 0x64, 0x33, 0x65, 0x34, 0x34, 0x61, 0x66, 0x64, 0x66, 0x30, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x39, 0x32, 0x38, 0x31, 0x34, 0x66, 0x35, 0x39, 0x61, 0x33, 0x33, 0x61, 0x31, 0x38, 0x34, 0x33, 0x66, 0x61, 0x61, 0x30, 0x31, 0x62, 0x61, 0x61, 0x30, 0x38, 0x39, 0x65, 0x62, 0x30, 0x32, 0x66, 0x66, 0x62, 0x35, 0x63, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x66, 0x32, 0x38, 0x35, 0x34, 0x30, 0x35, 0x30, 0x66, 0x38, 0x37, 0x32, 0x36, 0x35, 0x38, 0x65, 0x64, 0x38, 0x32, 0x65, 0x35, 0x32, 0x62, 0x30, 0x61, 0x64, 0x37, 0x62, 0x62, 0x63, 0x31, 0x63, 0x62, 0x39, 0x32, 0x31, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x30, 0x39, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x64, 0x63, 0x61, 0x35, 0x65, 0x31, 0x30, 0x32, 0x62, 0x33, 0x62, 0x38, 0x31, 0x62, 0x36, 0x30, 0x66, 0x31, 0x61, 0x35, 0x30, 0x34, 0x36, 0x33, 0x34, 0x39, 0x34, 0x37, 0x63, 0x33, 0x37, 0x34, 0x61, 0x38, 0x38, 0x63, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x32, 0x66, 0x65, 0x61, 0x64, 0x36, 0x30, 0x66, 0x37, 0x62, 0x66, 0x64, 0x64, 0x36, 0x61, 0x39, 0x64, 0x65, 0x63, 0x34, 0x38, 0x31, 0x32, 0x35, 0x65, 0x33, 0x37, 0x33, 0x35, 0x64, 0x62, 0x31, 0x62, 0x36, 0x36, 0x35, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x66, 0x37, 0x62, 0x33, 0x63, 0x30, 0x36, 0x35, 0x66, 0x32, 0x63, 0x31, 0x65, 0x37, 0x63, 0x36, 0x65, 0x62, 0x30, 0x39, 0x32, 0x62, 0x61, 0x30, 0x64, 0x31, 0x35, 0x30, 0x36, 0x36, 0x66, 0x33, 0x39, 0x33, 0x64, 0x31, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x65, 0x33, 0x36, 0x64, 0x38, 0x31, 0x64, 0x31, 0x32, 0x38, 0x63, 0x35, 0x39, 0x64, 0x61, 0x31, 0x34, 0x35, 0x36, 0x35, 0x32, 0x31, 0x39, 0x33, 0x65, 0x65, 0x63, 0x32, 0x62, 0x66, 0x64, 0x39, 0x36, 0x35, 0x38, 0x36, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x65, 0x64, 0x64, 0x62, 0x34, 0x34, 0x38, 0x64, 0x36, 0x39, 0x30, 0x65, 0x64, 0x37, 0x32, 0x65, 0x30, 0x35, 0x63, 0x32, 0x32, 0x35, 0x64, 0x33, 0x34, 0x66, 0x63, 0x38, 0x33, 0x35, 0x30, 0x66, 0x61, 0x31, 0x65, 0x34, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x34, 0x62, 0x36, 0x31, 0x62, 0x33, 0x34, 0x34, 0x63, 0x30, 0x65, 0x66, 0x39, 0x36, 0x35, 0x31, 0x37, 0x39, 0x32, 0x33, 0x38, 0x31, 0x35, 0x35, 0x66, 0x32, 0x37, 0x37, 0x63, 0x33, 0x38, 0x32, 0x39, 0x64, 0x30, 0x62, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x33, 0x64, 0x61, 0x35, 0x32, 0x36, 0x63, 0x66, 0x63, 0x65, 0x38, 0x38, 0x32, 0x39, 0x37, 0x33, 0x30, 0x32, 0x66, 0x33, 0x34, 0x63, 0x34, 0x39, 0x63, 0x61, 0x35, 0x32, 0x30, 0x64, 0x63, 0x32, 0x37, 0x31, 0x66, 0x39, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x38, 0x39, 0x65, 0x65, 0x63, 0x33, 0x30, 0x37, 0x65, 0x38, 0x38, 0x33, 0x39, 0x62, 0x39, 0x64, 0x37, 0x32, 0x33, 0x37, 0x63, 0x66, 0x64, 0x61, 0x30, 0x38, 0x38, 0x32, 0x32, 0x39, 0x36, 0x32, 0x61, 0x62, 0x65, 0x34, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x39, 0x64, 0x65, 0x32, 0x35, 0x38, 0x61, 0x34, 0x31, 0x37, 0x33, 0x63, 0x65, 0x39, 0x61, 0x63, 0x33, 0x38, 0x65, 0x64, 0x65, 0x32, 0x36, 0x63, 0x30, 0x62, 0x33, 0x62, 0x65, 0x61, 0x33, 0x63, 0x30, 0x39, 0x37, 0x33, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x35, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x30, 0x63, 0x62, 0x30, 0x36, 0x63, 0x34, 0x32, 0x65, 0x33, 0x64, 0x38, 0x38, 0x39, 0x34, 0x38, 0x65, 0x34, 0x35, 0x62, 0x64, 0x37, 0x62, 0x30, 0x64, 0x34, 0x65, 0x32, 0x39, 0x31, 0x61, 0x65, 0x66, 0x65, 0x65, 0x61, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x39, 0x30, 0x65, 0x38, 0x31, 0x63, 0x64, 0x37, 0x38, 0x35, 0x35, 0x39, 0x39, 0x65, 0x61, 0x32, 0x33, 0x36, 0x62, 0x64, 0x31, 0x39, 0x36, 0x36, 0x63, 0x66, 0x35, 0x32, 0x36, 0x33, 0x30, 0x32, 0x63, 0x33, 0x35, 0x62, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x61, 0x30, 0x65, 0x64, 0x38, 0x66, 0x31, 0x64, 0x36, 0x39, 0x33, 0x33, 0x39, 0x66, 0x30, 0x35, 0x39, 0x66, 0x32, 0x61, 0x30, 0x65, 0x30, 0x32, 0x34, 0x37, 0x31, 0x63, 0x62, 0x34, 0x34, 0x66, 0x62, 0x38, 0x63, 0x33, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x33, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x39, 0x35, 0x38, 0x61, 0x39, 0x62, 0x64, 0x31, 0x38, 0x39, 0x63, 0x32, 0x39, 0x38, 0x35, 0x66, 0x38, 0x36, 0x63, 0x35, 0x38, 0x61, 0x38, 0x63, 0x36, 0x39, 0x61, 0x37, 0x61, 0x37, 0x38, 0x38, 0x30, 0x36, 0x65, 0x38, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x62, 0x65, 0x36, 0x39, 0x36, 0x64, 0x35, 0x31, 0x65, 0x33, 0x39, 0x30, 0x66, 0x66, 0x31, 0x63, 0x35, 0x30, 0x31, 0x62, 0x38, 0x61, 0x30, 0x66, 0x36, 0x33, 0x33, 0x31, 0x62, 0x36, 0x32, 0x38, 0x64, 0x64, 0x63, 0x35, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x64, 0x30, 0x62, 0x38, 0x63, 0x64, 0x30, 0x37, 0x37, 0x63, 0x36, 0x39, 0x64, 0x39, 0x66, 0x33, 0x32, 0x64, 0x39, 0x63, 0x63, 0x61, 0x34, 0x33, 0x62, 0x33, 0x63, 0x32, 0x30, 0x38, 0x61, 0x32, 0x31, 0x65, 0x64, 0x34, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x65, 0x37, 0x63, 0x30, 0x63, 0x39, 0x64, 0x35, 0x62, 0x66, 0x31, 0x30, 0x38, 0x32, 0x31, 0x62, 0x66, 0x31, 0x34, 0x30, 0x63, 0x35, 0x35, 0x38, 0x61, 0x31, 0x34, 0x35, 0x62, 0x37, 0x63, 0x61, 0x63, 0x32, 0x31, 0x33, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x37, 0x33, 0x36, 0x65, 0x62, 0x31, 0x38, 0x33, 0x35, 0x33, 0x36, 0x32, 0x39, 0x62, 0x64, 0x65, 0x39, 0x36, 0x37, 0x36, 0x64, 0x61, 0x64, 0x64, 0x31, 0x36, 0x35, 0x30, 0x33, 0x34, 0x63, 0x65, 0x35, 0x65, 0x63, 0x63, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x61, 0x33, 0x36, 0x35, 0x33, 0x34, 0x33, 0x63, 0x63, 0x34, 0x65, 0x62, 0x31, 0x65, 0x37, 0x37, 0x30, 0x33, 0x36, 0x38, 0x65, 0x31, 0x66, 0x31, 0x31, 0x34, 0x34, 0x61, 0x37, 0x37, 0x62, 0x38, 0x33, 0x32, 0x64, 0x37, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x66, 0x35, 0x35, 0x33, 0x37, 0x62, 0x38, 0x35, 0x38, 0x34, 0x32, 0x66, 0x38, 0x39, 0x63, 0x66, 0x65, 0x65, 0x33, 0x35, 0x39, 0x65, 0x61, 0x65, 0x35, 0x30, 0x30, 0x66, 0x63, 0x34, 0x34, 0x39, 0x64, 0x32, 0x31, 0x31, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x31, 0x66, 0x31, 0x64, 0x37, 0x35, 0x38, 0x37, 0x33, 0x66, 0x33, 0x33, 0x64, 0x63, 0x62, 0x32, 0x64, 0x64, 0x34, 0x62, 0x33, 0x39, 0x38, 0x37, 0x61, 0x31, 0x32, 0x64, 0x30, 0x37, 0x39, 0x31, 0x61, 0x35, 0x63, 0x65, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x66, 0x37, 0x30, 0x33, 0x62, 0x34, 0x31, 0x63, 0x33, 0x36, 0x32, 0x34, 0x65, 0x31, 0x35, 0x66, 0x34, 0x30, 0x35, 0x34, 0x39, 0x36, 0x32, 0x33, 0x39, 0x30, 0x62, 0x63, 0x62, 0x61, 0x33, 0x30, 0x35, 0x32, 0x66, 0x30, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x35, 0x65, 0x31, 0x64, 0x65, 0x30, 0x31, 0x34, 0x37, 0x39, 0x31, 0x31, 0x63, 0x63, 0x64, 0x38, 0x38, 0x30, 0x38, 0x37, 0x35, 0x66, 0x62, 0x62, 0x65, 0x61, 0x36, 0x31, 0x66, 0x36, 0x61, 0x31, 0x34, 0x32, 0x64, 0x31, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x34, 0x31, 0x39, 0x63, 0x36, 0x64, 0x64, 0x32, 0x64, 0x33, 0x63, 0x65, 0x36, 0x66, 0x63, 0x62, 0x62, 0x33, 0x63, 0x37, 0x33, 0x65, 0x32, 0x66, 0x61, 0x30, 0x37, 0x39, 0x66, 0x30, 0x36, 0x30, 0x35, 0x31, 0x62, 0x64, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x65, 0x62, 0x37, 0x38, 0x35, 0x30, 0x33, 0x65, 0x63, 0x33, 0x31, 0x61, 0x35, 0x34, 0x61, 0x39, 0x30, 0x31, 0x33, 0x36, 0x37, 0x38, 0x31, 0x61, 0x65, 0x31, 0x30, 0x39, 0x30, 0x30, 0x34, 0x63, 0x37, 0x34, 0x33, 0x32, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x35, 0x65, 0x34, 0x63, 0x37, 0x30, 0x62, 0x63, 0x34, 0x36, 0x35, 0x36, 0x33, 0x32, 0x63, 0x38, 0x39, 0x65, 0x35, 0x36, 0x32, 0x35, 0x61, 0x38, 0x33, 0x32, 0x61, 0x37, 0x37, 0x32, 0x32, 0x66, 0x36, 0x62, 0x66, 0x66, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x34, 0x64, 0x32, 0x61, 0x33, 0x38, 0x32, 0x36, 0x39, 0x30, 0x36, 0x39, 0x63, 0x31, 0x38, 0x35, 0x35, 0x37, 0x37, 0x37, 0x30, 0x64, 0x35, 0x39, 0x31, 0x64, 0x32, 0x34, 0x63, 0x35, 0x31, 0x32, 0x31, 0x66, 0x35, 0x65, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x64, 0x31, 0x35, 0x38, 0x61, 0x63, 0x33, 0x64, 0x33, 0x65, 0x31, 0x31, 0x30, 0x39, 0x61, 0x62, 0x36, 0x65, 0x35, 0x37, 0x30, 0x65, 0x39, 0x30, 0x65, 0x38, 0x35, 0x64, 0x33, 0x38, 0x39, 0x32, 0x63, 0x64, 0x37, 0x36, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x36, 0x37, 0x39, 0x61, 0x34, 0x37, 0x64, 0x66, 0x32, 0x64, 0x39, 0x39, 0x61, 0x34, 0x39, 0x62, 0x30, 0x31, 0x63, 0x39, 0x38, 0x64, 0x31, 0x63, 0x33, 0x65, 0x30, 0x63, 0x39, 0x38, 0x37, 0x63, 0x65, 0x31, 0x65, 0x31, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x35, 0x62, 0x39, 0x34, 0x39, 0x64, 0x65, 0x33, 0x33, 0x33, 0x33, 0x61, 0x33, 0x37, 0x37, 0x64, 0x35, 0x30, 0x31, 0x39, 0x64, 0x38, 0x39, 0x33, 0x37, 0x35, 0x34, 0x61, 0x35, 0x65, 0x34, 0x36, 0x35, 0x36, 0x66, 0x66, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x31, 0x37, 0x35, 0x39, 0x38, 0x61, 0x38, 0x65, 0x66, 0x35, 0x34, 0x66, 0x37, 0x39, 0x37, 0x61, 0x65, 0x35, 0x31, 0x35, 0x63, 0x63, 0x62, 0x36, 0x35, 0x31, 0x37, 0x64, 0x31, 0x38, 0x35, 0x39, 0x62, 0x66, 0x38, 0x30, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x61, 0x66, 0x30, 0x38, 0x37, 0x39, 0x62, 0x35, 0x62, 0x36, 0x64, 0x62, 0x31, 0x35, 0x39, 0x62, 0x35, 0x38, 0x39, 0x66, 0x38, 0x34, 0x35, 0x37, 0x38, 0x62, 0x36, 0x61, 0x37, 0x34, 0x66, 0x36, 0x63, 0x31, 0x30, 0x33, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x35, 0x33, 0x36, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x64, 0x34, 0x35, 0x64, 0x39, 0x64, 0x37, 0x36, 0x32, 0x35, 0x64, 0x31, 0x35, 0x31, 0x35, 0x36, 0x63, 0x39, 0x33, 0x32, 0x62, 0x37, 0x37, 0x31, 0x63, 0x61, 0x37, 0x62, 0x30, 0x35, 0x32, 0x37, 0x31, 0x33, 0x30, 0x39, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x39, 0x32, 0x35, 0x34, 0x39, 0x61, 0x37, 0x32, 0x37, 0x66, 0x38, 0x31, 0x36, 0x35, 0x35, 0x34, 0x32, 0x39, 0x63, 0x62, 0x39, 0x32, 0x38, 0x62, 0x35, 0x32, 0x39, 0x66, 0x32, 0x35, 0x64, 0x66, 0x34, 0x64, 0x31, 0x33, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x32, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x62, 0x30, 0x30, 0x39, 0x62, 0x61, 0x65, 0x61, 0x66, 0x37, 0x38, 0x38, 0x61, 0x32, 0x37, 0x36, 0x62, 0x64, 0x33, 0x35, 0x38, 0x31, 0x33, 0x61, 0x64, 0x36, 0x35, 0x62, 0x34, 0x30, 0x30, 0x62, 0x38, 0x34, 0x39, 0x66, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x64, 0x38, 0x38, 0x34, 0x34, 0x35, 0x39, 0x66, 0x38, 0x30, 0x39, 0x64, 0x66, 0x61, 0x31, 0x30, 0x31, 0x36, 0x65, 0x37, 0x37, 0x30, 0x65, 0x64, 0x61, 0x66, 0x33, 0x65, 0x39, 0x66, 0x65, 0x66, 0x34, 0x36, 0x66, 0x61, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x39, 0x64, 0x32, 0x66, 0x32, 0x66, 0x35, 0x31, 0x31, 0x30, 0x61, 0x34, 0x64, 0x35, 0x38, 0x62, 0x31, 0x37, 0x35, 0x37, 0x39, 0x33, 0x35, 0x30, 0x31, 0x35, 0x34, 0x30, 0x38, 0x37, 0x34, 0x30, 0x66, 0x65, 0x63, 0x37, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x33, 0x30, 0x34, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x34, 0x36, 0x63, 0x31, 0x33, 0x33, 0x32, 0x35, 0x63, 0x64, 0x38, 0x65, 0x64, 0x66, 0x30, 0x32, 0x33, 0x30, 0x64, 0x30, 0x36, 0x38, 0x38, 0x39, 0x36, 0x34, 0x38, 0x36, 0x66, 0x30, 0x30, 0x37, 0x62, 0x66, 0x34, 0x65, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x35, 0x34, 0x63, 0x37, 0x66, 0x38, 0x62, 0x39, 0x38, 0x39, 0x36, 0x65, 0x37, 0x35, 0x64, 0x37, 0x64, 0x35, 0x66, 0x35, 0x63, 0x37, 0x36, 0x30, 0x32, 0x35, 0x38, 0x36, 0x39, 0x39, 0x39, 0x35, 0x37, 0x31, 0x34, 0x32, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x63, 0x38, 0x66, 0x31, 0x66, 0x61, 0x34, 0x33, 0x62, 0x66, 0x38, 0x34, 0x36, 0x39, 0x39, 0x39, 0x65, 0x63, 0x66, 0x34, 0x37, 0x62, 0x32, 0x62, 0x33, 0x32, 0x34, 0x64, 0x66, 0x62, 0x36, 0x62, 0x36, 0x33, 0x66, 0x65, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x35, 0x30, 0x36, 0x39, 0x34, 0x34, 0x34, 0x61, 0x36, 0x61, 0x39, 0x38, 0x34, 0x64, 0x65, 0x32, 0x30, 0x38, 0x34, 0x65, 0x34, 0x36, 0x36, 0x39, 0x32, 0x61, 0x62, 0x39, 0x39, 0x66, 0x36, 0x37, 0x31, 0x66, 0x63, 0x37, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x34, 0x39, 0x63, 0x31, 0x34, 0x33, 0x39, 0x61, 0x34, 0x31, 0x64, 0x36, 0x62, 0x33, 0x63, 0x66, 0x32, 0x36, 0x62, 0x62, 0x36, 0x37, 0x65, 0x30, 0x33, 0x36, 0x35, 0x32, 0x32, 0x34, 0x65, 0x35, 0x65, 0x33, 0x38, 0x66, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x64, 0x66, 0x62, 0x35, 0x63, 0x63, 0x38, 0x39, 0x30, 0x65, 0x65, 0x38, 0x62, 0x32, 0x38, 0x37, 0x37, 0x65, 0x38, 0x38, 0x35, 0x64, 0x32, 0x36, 0x37, 0x63, 0x32, 0x35, 0x36, 0x31, 0x38, 0x37, 0x64, 0x30, 0x31, 0x39, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x37, 0x63, 0x33, 0x64, 0x65, 0x64, 0x37, 0x63, 0x32, 0x38, 0x66, 0x34, 0x35, 0x39, 0x63, 0x39, 0x32, 0x66, 0x65, 0x31, 0x33, 0x62, 0x34, 0x64, 0x39, 0x35, 0x62, 0x61, 0x66, 0x62, 0x61, 0x62, 0x30, 0x32, 0x33, 0x36, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x38, 0x37, 0x34, 0x64, 0x37, 0x35, 0x34, 0x36, 0x33, 0x35, 0x61, 0x37, 0x36, 0x32, 0x62, 0x33, 0x38, 0x31, 0x61, 0x35, 0x63, 0x34, 0x63, 0x37, 0x39, 0x32, 0x34, 0x38, 0x33, 0x61, 0x66, 0x38, 0x66, 0x32, 0x33, 0x64, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x62, 0x62, 0x33, 0x32, 0x62, 0x37, 0x64, 0x30, 0x32, 0x34, 0x33, 0x35, 0x30, 0x65, 0x33, 0x33, 0x32, 0x31, 0x66, 0x61, 0x32, 0x30, 0x63, 0x39, 0x61, 0x39, 0x31, 0x34, 0x30, 0x33, 0x35, 0x33, 0x37, 0x32, 0x66, 0x66, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x63, 0x34, 0x32, 0x39, 0x64, 0x36, 0x31, 0x38, 0x61, 0x36, 0x36, 0x61, 0x34, 0x63, 0x66, 0x38, 0x32, 0x64, 0x62, 0x62, 0x32, 0x64, 0x38, 0x32, 0x34, 0x65, 0x39, 0x33, 0x35, 0x36, 0x65, 0x66, 0x66, 0x61, 0x31, 0x32, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x32, 0x34, 0x34, 0x66, 0x39, 0x37, 0x64, 0x39, 0x63, 0x34, 0x34, 0x62, 0x31, 0x35, 0x38, 0x61, 0x34, 0x30, 0x65, 0x64, 0x39, 0x36, 0x30, 0x36, 0x64, 0x39, 0x66, 0x37, 0x62, 0x64, 0x33, 0x38, 0x39, 0x31, 0x33, 0x33, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x65, 0x32, 0x32, 0x30, 0x38, 0x37, 0x36, 0x32, 0x36, 0x32, 0x63, 0x32, 0x31, 0x38, 0x61, 0x66, 0x34, 0x66, 0x35, 0x36, 0x37, 0x38, 0x34, 0x37, 0x39, 0x38, 0x63, 0x37, 0x65, 0x35, 0x35, 0x64, 0x61, 0x30, 0x39, 0x65, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x35, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x34, 0x31, 0x63, 0x63, 0x61, 0x63, 0x33, 0x30, 0x31, 0x37, 0x32, 0x30, 0x35, 0x32, 0x64, 0x35, 0x32, 0x32, 0x63, 0x64, 0x32, 0x66, 0x32, 0x66, 0x39, 0x35, 0x37, 0x64, 0x32, 0x34, 0x38, 0x31, 0x35, 0x33, 0x34, 0x30, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x31, 0x66, 0x61, 0x37, 0x66, 0x62, 0x32, 0x37, 0x30, 0x61, 0x62, 0x63, 0x64, 0x66, 0x35, 0x61, 0x32, 0x65, 0x61, 0x62, 0x39, 0x35, 0x61, 0x61, 0x33, 0x30, 0x63, 0x34, 0x62, 0x35, 0x33, 0x36, 0x33, 0x36, 0x65, 0x66, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x66, 0x65, 0x61, 0x30, 0x36, 0x64, 0x37, 0x31, 0x31, 0x33, 0x66, 0x62, 0x36, 0x61, 0x65, 0x63, 0x32, 0x38, 0x36, 0x39, 0x66, 0x34, 0x61, 0x39, 0x64, 0x66, 0x62, 0x30, 0x39, 0x30, 0x30, 0x37, 0x66, 0x61, 0x63, 0x65, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x35, 0x34, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x36, 0x36, 0x32, 0x38, 0x61, 0x35, 0x33, 0x63, 0x32, 0x63, 0x34, 0x31, 0x39, 0x33, 0x64, 0x61, 0x38, 0x38, 0x33, 0x35, 0x39, 0x63, 0x65, 0x37, 0x31, 0x38, 0x64, 0x61, 0x64, 0x64, 0x39, 0x32, 0x62, 0x37, 0x61, 0x34, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x38, 0x34, 0x30, 0x39, 0x30, 0x38, 0x33, 0x65, 0x30, 0x31, 0x62, 0x33, 0x39, 0x37, 0x63, 0x66, 0x31, 0x32, 0x39, 0x32, 0x38, 0x61, 0x30, 0x35, 0x62, 0x36, 0x38, 0x34, 0x35, 0x35, 0x63, 0x65, 0x36, 0x32, 0x30, 0x31, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x62, 0x63, 0x62, 0x62, 0x37, 0x39, 0x62, 0x66, 0x34, 0x37, 0x39, 0x61, 0x34, 0x32, 0x61, 0x64, 0x37, 0x31, 0x64, 0x62, 0x63, 0x61, 0x62, 0x37, 0x37, 0x62, 0x35, 0x61, 0x64, 0x66, 0x61, 0x61, 0x38, 0x37, 0x32, 0x63, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x37, 0x64, 0x34, 0x30, 0x33, 0x37, 0x30, 0x38, 0x31, 0x66, 0x36, 0x63, 0x36, 0x35, 0x66, 0x39, 0x34, 0x37, 0x36, 0x62, 0x30, 0x36, 0x38, 0x37, 0x64, 0x39, 0x37, 0x66, 0x31, 0x65, 0x30, 0x34, 0x34, 0x64, 0x30, 0x61, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x65, 0x39, 0x30, 0x64, 0x34, 0x31, 0x32, 0x31, 0x32, 0x39, 0x64, 0x35, 0x61, 0x34, 0x64, 0x30, 0x34, 0x32, 0x34, 0x33, 0x36, 0x31, 0x64, 0x36, 0x36, 0x34, 0x39, 0x64, 0x34, 0x65, 0x34, 0x37, 0x61, 0x36, 0x32, 0x33, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x61, 0x62, 0x33, 0x63, 0x61, 0x39, 0x62, 0x38, 0x37, 0x30, 0x65, 0x33, 0x66, 0x35, 0x34, 0x38, 0x35, 0x31, 0x37, 0x33, 0x30, 0x36, 0x62, 0x62, 0x61, 0x34, 0x64, 0x65, 0x32, 0x35, 0x39, 0x31, 0x61, 0x66, 0x61, 0x66, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x36, 0x31, 0x61, 0x62, 0x37, 0x39, 0x62, 0x34, 0x30, 0x38, 0x64, 0x64, 0x33, 0x32, 0x32, 0x39, 0x66, 0x36, 0x36, 0x32, 0x35, 0x39, 0x33, 0x37, 0x30, 0x35, 0x64, 0x37, 0x32, 0x66, 0x31, 0x65, 0x31, 0x34, 0x37, 0x62, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x37, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x31, 0x37, 0x37, 0x66, 0x39, 0x64, 0x35, 0x36, 0x39, 0x35, 0x33, 0x64, 0x65, 0x64, 0x37, 0x31, 0x61, 0x35, 0x36, 0x31, 0x31, 0x66, 0x33, 0x39, 0x33, 0x33, 0x32, 0x32, 0x63, 0x33, 0x30, 0x32, 0x37, 0x39, 0x38, 0x39, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x63, 0x62, 0x32, 0x36, 0x30, 0x62, 0x37, 0x31, 0x36, 0x64, 0x34, 0x63, 0x30, 0x61, 0x62, 0x37, 0x32, 0x36, 0x65, 0x65, 0x65, 0x62, 0x30, 0x37, 0x63, 0x38, 0x37, 0x30, 0x37, 0x32, 0x30, 0x34, 0x65, 0x32, 0x37, 0x36, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x33, 0x35, 0x35, 0x32, 0x35, 0x33, 0x62, 0x32, 0x37, 0x37, 0x34, 0x38, 0x65, 0x33, 0x66, 0x33, 0x34, 0x66, 0x65, 0x39, 0x63, 0x61, 0x65, 0x31, 0x66, 0x62, 0x37, 0x31, 0x38, 0x63, 0x38, 0x66, 0x32, 0x34, 0x39, 0x35, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x30, 0x39, 0x64, 0x66, 0x35, 0x34, 0x63, 0x61, 0x62, 0x63, 0x65, 0x37, 0x30, 0x63, 0x39, 0x35, 0x65, 0x63, 0x33, 0x30, 0x33, 0x33, 0x31, 0x34, 0x39, 0x63, 0x64, 0x36, 0x36, 0x37, 0x38, 0x61, 0x36, 0x66, 0x64, 0x34, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x34, 0x38, 0x36, 0x37, 0x64, 0x32, 0x31, 0x37, 0x35, 0x61, 0x62, 0x35, 0x62, 0x39, 0x34, 0x36, 0x39, 0x33, 0x36, 0x31, 0x35, 0x39, 0x35, 0x35, 0x34, 0x36, 0x35, 0x35, 0x34, 0x36, 0x38, 0x34, 0x63, 0x64, 0x61, 0x34, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x30, 0x36, 0x65, 0x34, 0x36, 0x34, 0x32, 0x34, 0x35, 0x63, 0x61, 0x64, 0x36, 0x31, 0x34, 0x39, 0x33, 0x39, 0x65, 0x30, 0x61, 0x66, 0x30, 0x38, 0x34, 0x35, 0x65, 0x36, 0x64, 0x37, 0x33, 0x30, 0x65, 0x32, 0x30, 0x33, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x33, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x31, 0x30, 0x65, 0x33, 0x34, 0x61, 0x39, 0x34, 0x64, 0x62, 0x36, 0x65, 0x64, 0x31, 0x35, 0x36, 0x64, 0x30, 0x33, 0x38, 0x39, 0x61, 0x30, 0x65, 0x32, 0x62, 0x38, 0x30, 0x66, 0x34, 0x66, 0x64, 0x36, 0x62, 0x30, 0x61, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x66, 0x66, 0x66, 0x33, 0x65, 0x38, 0x64, 0x32, 0x33, 0x63, 0x32, 0x61, 0x33, 0x34, 0x62, 0x35, 0x36, 0x62, 0x64, 0x31, 0x62, 0x33, 0x62, 0x64, 0x34, 0x35, 0x63, 0x37, 0x39, 0x33, 0x37, 0x34, 0x34, 0x33, 0x32, 0x32, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x37, 0x64, 0x64, 0x35, 0x65, 0x65, 0x36, 0x31, 0x34, 0x64, 0x62, 0x62, 0x36, 0x66, 0x62, 0x66, 0x62, 0x63, 0x64, 0x32, 0x36, 0x33, 0x30, 0x35, 0x32, 0x34, 0x37, 0x61, 0x30, 0x35, 0x38, 0x63, 0x34, 0x31, 0x66, 0x61, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x39, 0x65, 0x63, 0x61, 0x39, 0x63, 0x35, 0x61, 0x62, 0x61, 0x38, 0x65, 0x31, 0x33, 0x39, 0x66, 0x38, 0x30, 0x30, 0x33, 0x65, 0x64, 0x66, 0x31, 0x31, 0x36, 0x33, 0x61, 0x66, 0x62, 0x37, 0x30, 0x61, 0x61, 0x33, 0x61, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x34, 0x32, 0x64, 0x65, 0x34, 0x37, 0x38, 0x34, 0x66, 0x37, 0x61, 0x34, 0x38, 0x37, 0x31, 0x36, 0x63, 0x30, 0x66, 0x64, 0x34, 0x62, 0x39, 0x64, 0x35, 0x34, 0x61, 0x36, 0x65, 0x35, 0x34, 0x63, 0x35, 0x66, 0x32, 0x66, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x64, 0x61, 0x65, 0x36, 0x32, 0x32, 0x36, 0x33, 0x30, 0x64, 0x31, 0x31, 0x33, 0x36, 0x33, 0x38, 0x31, 0x39, 0x33, 0x33, 0x64, 0x32, 0x61, 0x64, 0x36, 0x62, 0x32, 0x32, 0x62, 0x38, 0x33, 0x39, 0x64, 0x38, 0x32, 0x31, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x66, 0x31, 0x32, 0x66, 0x61, 0x31, 0x39, 0x65, 0x38, 0x32, 0x66, 0x37, 0x36, 0x63, 0x37, 0x31, 0x38, 0x66, 0x30, 0x31, 0x62, 0x64, 0x63, 0x61, 0x30, 0x30, 0x30, 0x33, 0x36, 0x37, 0x34, 0x35, 0x32, 0x33, 0x65, 0x66, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x31, 0x63, 0x38, 0x33, 0x31, 0x63, 0x63, 0x36, 0x66, 0x34, 0x34, 0x66, 0x31, 0x39, 0x36, 0x35, 0x65, 0x63, 0x35, 0x37, 0x35, 0x37, 0x61, 0x62, 0x34, 0x65, 0x35, 0x62, 0x33, 0x63, 0x61, 0x34, 0x63, 0x66, 0x66, 0x64, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x31, 0x32, 0x39, 0x64, 0x35, 0x62, 0x33, 0x63, 0x30, 0x63, 0x64, 0x65, 0x34, 0x37, 0x65, 0x61, 0x30, 0x64, 0x65, 0x66, 0x34, 0x64, 0x66, 0x63, 0x30, 0x37, 0x30, 0x64, 0x31, 0x66, 0x34, 0x61, 0x35, 0x39, 0x39, 0x35, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x63, 0x64, 0x63, 0x65, 0x65, 0x30, 0x65, 0x38, 0x35, 0x64, 0x31, 0x31, 0x37, 0x64, 0x61, 0x62, 0x62, 0x66, 0x35, 0x33, 0x36, 0x61, 0x33, 0x66, 0x34, 0x30, 0x36, 0x39, 0x62, 0x66, 0x34, 0x34, 0x33, 0x66, 0x35, 0x34, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x39, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x31, 0x38, 0x62, 0x64, 0x38, 0x34, 0x38, 0x65, 0x65, 0x37, 0x66, 0x39, 0x64, 0x33, 0x38, 0x62, 0x66, 0x64, 0x64, 0x31, 0x63, 0x34, 0x65, 0x62, 0x32, 0x65, 0x64, 0x32, 0x34, 0x39, 0x36, 0x61, 0x65, 0x34, 0x33, 0x30, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x35, 0x34, 0x39, 0x62, 0x62, 0x66, 0x65, 0x36, 0x34, 0x37, 0x34, 0x30, 0x31, 0x38, 0x39, 0x38, 0x39, 0x32, 0x39, 0x33, 0x32, 0x35, 0x33, 0x38, 0x64, 0x61, 0x61, 0x66, 0x34, 0x36, 0x64, 0x32, 0x62, 0x36, 0x31, 0x64, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x33, 0x66, 0x30, 0x65, 0x37, 0x36, 0x37, 0x32, 0x66, 0x37, 0x31, 0x66, 0x65, 0x37, 0x35, 0x32, 0x35, 0x62, 0x61, 0x33, 0x30, 0x62, 0x39, 0x37, 0x35, 0x35, 0x31, 0x38, 0x33, 0x61, 0x32, 0x30, 0x62, 0x39, 0x31, 0x36, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x30, 0x33, 0x36, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x38, 0x33, 0x62, 0x38, 0x35, 0x30, 0x34, 0x38, 0x31, 0x61, 0x62, 0x34, 0x34, 0x64, 0x34, 0x39, 0x65, 0x30, 0x61, 0x32, 0x32, 0x39, 0x61, 0x32, 0x65, 0x34, 0x36, 0x34, 0x39, 0x30, 0x32, 0x63, 0x36, 0x39, 0x35, 0x33, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x64, 0x64, 0x64, 0x30, 0x34, 0x32, 0x32, 0x63, 0x38, 0x36, 0x65, 0x66, 0x36, 0x35, 0x62, 0x66, 0x30, 0x63, 0x37, 0x66, 0x63, 0x33, 0x34, 0x35, 0x32, 0x38, 0x36, 0x32, 0x62, 0x31, 0x32, 0x32, 0x38, 0x62, 0x30, 0x38, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x35, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x38, 0x63, 0x33, 0x31, 0x33, 0x34, 0x34, 0x35, 0x63, 0x32, 0x32, 0x64, 0x39, 0x31, 0x39, 0x65, 0x65, 0x34, 0x36, 0x63, 0x63, 0x32, 0x64, 0x30, 0x63, 0x64, 0x66, 0x66, 0x30, 0x34, 0x33, 0x61, 0x37, 0x35, 0x35, 0x38, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x65, 0x39, 0x64, 0x62, 0x63, 0x65, 0x37, 0x61, 0x32, 0x63, 0x62, 0x30, 0x33, 0x36, 0x39, 0x34, 0x37, 0x39, 0x39, 0x38, 0x39, 0x37, 0x62, 0x65, 0x64, 0x37, 0x63, 0x35, 0x34, 0x64, 0x31, 0x35, 0x35, 0x66, 0x64, 0x61, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x35, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x66, 0x63, 0x63, 0x66, 0x36, 0x32, 0x64, 0x32, 0x63, 0x33, 0x33, 0x39, 0x35, 0x34, 0x35, 0x33, 0x62, 0x37, 0x35, 0x38, 0x37, 0x62, 0x39, 0x65, 0x32, 0x36, 0x66, 0x35, 0x63, 0x66, 0x66, 0x39, 0x65, 0x62, 0x37, 0x34, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x34, 0x31, 0x64, 0x39, 0x65, 0x31, 0x62, 0x34, 0x65, 0x66, 0x66, 0x65, 0x31, 0x38, 0x64, 0x38, 0x62, 0x30, 0x64, 0x31, 0x66, 0x36, 0x33, 0x66, 0x63, 0x34, 0x32, 0x35, 0x35, 0x66, 0x62, 0x34, 0x65, 0x30, 0x36, 0x63, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x36, 0x39, 0x65, 0x61, 0x66, 0x64, 0x30, 0x32, 0x33, 0x33, 0x63, 0x61, 0x64, 0x62, 0x34, 0x30, 0x35, 0x39, 0x61, 0x62, 0x37, 0x37, 0x39, 0x63, 0x34, 0x36, 0x65, 0x64, 0x66, 0x32, 0x61, 0x30, 0x35, 0x30, 0x36, 0x65, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x38, 0x38, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x61, 0x34, 0x38, 0x63, 0x36, 0x36, 0x65, 0x34, 0x66, 0x62, 0x34, 0x61, 0x64, 0x30, 0x39, 0x39, 0x39, 0x33, 0x34, 0x65, 0x33, 0x32, 0x30, 0x32, 0x32, 0x65, 0x38, 0x32, 0x37, 0x34, 0x32, 0x37, 0x66, 0x32, 0x37, 0x37, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x36, 0x39, 0x38, 0x30, 0x65, 0x33, 0x61, 0x34, 0x61, 0x39, 0x64, 0x32, 0x39, 0x61, 0x36, 0x61, 0x36, 0x65, 0x39, 0x30, 0x36, 0x30, 0x34, 0x35, 0x33, 0x37, 0x61, 0x33, 0x31, 0x31, 0x34, 0x62, 0x63, 0x62, 0x32, 0x38, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x31, 0x37, 0x33, 0x32, 0x61, 0x34, 0x38, 0x31, 0x63, 0x33, 0x38, 0x30, 0x65, 0x35, 0x37, 0x65, 0x64, 0x36, 0x32, 0x64, 0x36, 0x63, 0x32, 0x39, 0x64, 0x65, 0x39, 0x39, 0x38, 0x61, 0x66, 0x33, 0x66, 0x61, 0x33, 0x62, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x64, 0x36, 0x61, 0x31, 0x34, 0x31, 0x39, 0x31, 0x38, 0x64, 0x31, 0x32, 0x36, 0x62, 0x31, 0x30, 0x36, 0x64, 0x39, 0x66, 0x32, 0x65, 0x62, 0x66, 0x36, 0x39, 0x65, 0x31, 0x30, 0x32, 0x64, 0x65, 0x34, 0x64, 0x33, 0x32, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x35, 0x38, 0x39, 0x61, 0x36, 0x63, 0x30, 0x30, 0x36, 0x61, 0x35, 0x34, 0x63, 0x61, 0x64, 0x37, 0x30, 0x31, 0x30, 0x33, 0x31, 0x32, 0x33, 0x61, 0x61, 0x65, 0x30, 0x61, 0x38, 0x32, 0x31, 0x33, 0x35, 0x66, 0x64, 0x65, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x32, 0x35, 0x65, 0x38, 0x63, 0x37, 0x35, 0x33, 0x62, 0x33, 0x61, 0x63, 0x62, 0x66, 0x64, 0x63, 0x61, 0x35, 0x35, 0x66, 0x33, 0x63, 0x36, 0x32, 0x64, 0x66, 0x65, 0x31, 0x61, 0x35, 0x39, 0x34, 0x35, 0x34, 0x39, 0x36, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x30, 0x64, 0x63, 0x62, 0x30, 0x62, 0x37, 0x38, 0x36, 0x38, 0x32, 0x62, 0x39, 0x34, 0x62, 0x63, 0x33, 0x30, 0x30, 0x30, 0x32, 0x38, 0x31, 0x34, 0x34, 0x38, 0x64, 0x35, 0x35, 0x37, 0x61, 0x32, 0x30, 0x62, 0x66, 0x63, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x34, 0x66, 0x38, 0x30, 0x37, 0x36, 0x61, 0x30, 0x66, 0x32, 0x39, 0x36, 0x39, 0x65, 0x63, 0x64, 0x33, 0x33, 0x33, 0x65, 0x65, 0x66, 0x38, 0x64, 0x65, 0x34, 0x31, 0x30, 0x34, 0x32, 0x39, 0x38, 0x36, 0x32, 0x39, 0x31, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x31, 0x34, 0x35, 0x62, 0x37, 0x34, 0x35, 0x30, 0x36, 0x64, 0x31, 0x61, 0x38, 0x64, 0x30, 0x34, 0x37, 0x63, 0x64, 0x63, 0x64, 0x63, 0x35, 0x35, 0x33, 0x39, 0x32, 0x61, 0x37, 0x62, 0x35, 0x33, 0x35, 0x30, 0x37, 0x39, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x39, 0x33, 0x31, 0x34, 0x36, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x39, 0x61, 0x38, 0x32, 0x35, 0x66, 0x66, 0x32, 0x62, 0x63, 0x64, 0x33, 0x39, 0x37, 0x63, 0x62, 0x61, 0x64, 0x35, 0x62, 0x37, 0x31, 0x31, 0x64, 0x39, 0x64, 0x63, 0x63, 0x39, 0x35, 0x66, 0x31, 0x63, 0x63, 0x31, 0x31, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x61, 0x36, 0x37, 0x30, 0x65, 0x62, 0x32, 0x63, 0x38, 0x62, 0x39, 0x36, 0x63, 0x62, 0x61, 0x33, 0x37, 0x39, 0x32, 0x31, 0x37, 0x66, 0x35, 0x39, 0x32, 0x39, 0x63, 0x32, 0x62, 0x38, 0x39, 0x32, 0x66, 0x33, 0x39, 0x65, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x63, 0x66, 0x63, 0x34, 0x65, 0x32, 0x35, 0x63, 0x33, 0x35, 0x63, 0x31, 0x33, 0x62, 0x36, 0x39, 0x66, 0x37, 0x65, 0x37, 0x37, 0x64, 0x62, 0x66, 0x62, 0x30, 0x38, 0x62, 0x61, 0x66, 0x35, 0x38, 0x37, 0x35, 0x36, 0x62, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x32, 0x64, 0x62, 0x38, 0x35, 0x32, 0x39, 0x33, 0x66, 0x36, 0x30, 0x36, 0x65, 0x38, 0x38, 0x39, 0x38, 0x38, 0x63, 0x33, 0x37, 0x30, 0x34, 0x63, 0x62, 0x33, 0x66, 0x30, 0x63, 0x30, 0x62, 0x62, 0x62, 0x66, 0x63, 0x61, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x37, 0x33, 0x63, 0x33, 0x63, 0x62, 0x63, 0x32, 0x36, 0x61, 0x31, 0x37, 0x35, 0x30, 0x36, 0x32, 0x65, 0x61, 0x30, 0x33, 0x32, 0x30, 0x64, 0x64, 0x38, 0x34, 0x62, 0x32, 0x35, 0x33, 0x62, 0x63, 0x65, 0x36, 0x34, 0x33, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x38, 0x30, 0x37, 0x31, 0x33, 0x64, 0x34, 0x30, 0x38, 0x30, 0x38, 0x65, 0x32, 0x61, 0x35, 0x30, 0x65, 0x64, 0x30, 0x31, 0x33, 0x31, 0x35, 0x30, 0x61, 0x32, 0x61, 0x36, 0x39, 0x34, 0x62, 0x39, 0x36, 0x61, 0x37, 0x66, 0x31, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x65, 0x33, 0x32, 0x66, 0x31, 0x34, 0x66, 0x34, 0x63, 0x61, 0x35, 0x65, 0x32, 0x38, 0x37, 0x63, 0x64, 0x61, 0x63, 0x30, 0x35, 0x37, 0x61, 0x37, 0x37, 0x39, 0x35, 0x65, 0x61, 0x39, 0x65, 0x30, 0x34, 0x33, 0x39, 0x39, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x65, 0x39, 0x63, 0x35, 0x66, 0x31, 0x64, 0x32, 0x31, 0x65, 0x36, 0x31, 0x37, 0x35, 0x37, 0x61, 0x36, 0x62, 0x32, 0x65, 0x65, 0x37, 0x35, 0x39, 0x31, 0x33, 0x66, 0x63, 0x35, 0x61, 0x31, 0x61, 0x34, 0x31, 0x30, 0x31, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x63, 0x34, 0x64, 0x31, 0x61, 0x37, 0x63, 0x33, 0x63, 0x37, 0x34, 0x39, 0x38, 0x34, 0x66, 0x36, 0x38, 0x35, 0x37, 0x62, 0x32, 0x66, 0x35, 0x66, 0x30, 0x37, 0x65, 0x38, 0x66, 0x61, 0x63, 0x65, 0x36, 0x38, 0x30, 0x35, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x35, 0x31, 0x64, 0x63, 0x34, 0x32, 0x30, 0x65, 0x30, 0x38, 0x63, 0x33, 0x32, 0x39, 0x33, 0x62, 0x32, 0x37, 0x64, 0x32, 0x34, 0x39, 0x37, 0x38, 0x39, 0x30, 0x65, 0x62, 0x35, 0x30, 0x32, 0x32, 0x33, 0x61, 0x65, 0x32, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x34, 0x61, 0x33, 0x39, 0x39, 0x35, 0x66, 0x38, 0x30, 0x37, 0x64, 0x65, 0x31, 0x64, 0x62, 0x30, 0x31, 0x61, 0x32, 0x65, 0x62, 0x39, 0x63, 0x36, 0x32, 0x65, 0x39, 0x37, 0x64, 0x30, 0x35, 0x34, 0x38, 0x66, 0x36, 0x39, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x30, 0x35, 0x61, 0x30, 0x38, 0x65, 0x32, 0x32, 0x61, 0x31, 0x30, 0x39, 0x30, 0x31, 0x35, 0x61, 0x32, 0x32, 0x66, 0x36, 0x38, 0x35, 0x33, 0x30, 0x35, 0x33, 0x35, 0x34, 0x36, 0x36, 0x32, 0x61, 0x35, 0x35, 0x33, 0x31, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x63, 0x37, 0x37, 0x33, 0x33, 0x36, 0x37, 0x63, 0x38, 0x38, 0x32, 0x35, 0x64, 0x33, 0x35, 0x39, 0x36, 0x63, 0x36, 0x38, 0x36, 0x66, 0x34, 0x32, 0x62, 0x66, 0x30, 0x64, 0x31, 0x34, 0x33, 0x31, 0x39, 0x65, 0x33, 0x66, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x39, 0x32, 0x39, 0x63, 0x66, 0x38, 0x39, 0x35, 0x64, 0x62, 0x30, 0x31, 0x37, 0x61, 0x66, 0x37, 0x39, 0x66, 0x33, 0x65, 0x61, 0x64, 0x32, 0x32, 0x31, 0x36, 0x62, 0x31, 0x62, 0x64, 0x36, 0x39, 0x63, 0x33, 0x37, 0x64, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x64, 0x33, 0x32, 0x35, 0x34, 0x65, 0x31, 0x62, 0x33, 0x61, 0x36, 0x64, 0x63, 0x36, 0x63, 0x63, 0x32, 0x63, 0x36, 0x39, 0x37, 0x64, 0x34, 0x35, 0x37, 0x31, 0x31, 0x61, 0x63, 0x61, 0x32, 0x31, 0x64, 0x35, 0x31, 0x36, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x35, 0x64, 0x32, 0x32, 0x31, 0x61, 0x66, 0x63, 0x64, 0x33, 0x64, 0x32, 0x39, 0x33, 0x35, 0x35, 0x66, 0x35, 0x30, 0x38, 0x65, 0x61, 0x64, 0x66, 0x63, 0x61, 0x34, 0x30, 0x38, 0x63, 0x65, 0x33, 0x33, 0x63, 0x61, 0x39, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x36, 0x63, 0x66, 0x31, 0x37, 0x64, 0x37, 0x31, 0x34, 0x31, 0x32, 0x38, 0x30, 0x35, 0x66, 0x34, 0x61, 0x66, 0x63, 0x33, 0x34, 0x34, 0x34, 0x61, 0x30, 0x62, 0x38, 0x64, 0x64, 0x31, 0x64, 0x39, 0x33, 0x33, 0x39, 0x64, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x31, 0x39, 0x32, 0x36, 0x33, 0x66, 0x37, 0x35, 0x34, 0x30, 0x32, 0x63, 0x30, 0x62, 0x35, 0x33, 0x32, 0x35, 0x66, 0x32, 0x36, 0x33, 0x62, 0x65, 0x34, 0x61, 0x35, 0x30, 0x38, 0x30, 0x36, 0x35, 0x31, 0x30, 0x38, 0x37, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x33, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x31, 0x63, 0x32, 0x34, 0x39, 0x63, 0x64, 0x39, 0x36, 0x32, 0x62, 0x30, 0x30, 0x66, 0x64, 0x31, 0x31, 0x34, 0x61, 0x39, 0x33, 0x34, 0x39, 0x66, 0x36, 0x61, 0x36, 0x63, 0x63, 0x37, 0x37, 0x38, 0x64, 0x37, 0x36, 0x63, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x66, 0x65, 0x62, 0x63, 0x63, 0x65, 0x32, 0x30, 0x66, 0x65, 0x37, 0x61, 0x39, 0x30, 0x39, 0x38, 0x61, 0x37, 0x35, 0x35, 0x62, 0x64, 0x39, 0x30, 0x39, 0x38, 0x38, 0x36, 0x30, 0x32, 0x61, 0x34, 0x38, 0x63, 0x30, 0x38, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x31, 0x38, 0x30, 0x30, 0x66, 0x33, 0x35, 0x66, 0x61, 0x30, 0x32, 0x64, 0x33, 0x65, 0x62, 0x36, 0x66, 0x66, 0x35, 0x62, 0x32, 0x35, 0x32, 0x38, 0x35, 0x66, 0x35, 0x65, 0x34, 0x61, 0x64, 0x64, 0x31, 0x33, 0x62, 0x33, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x62, 0x39, 0x30, 0x34, 0x34, 0x34, 0x30, 0x65, 0x39, 0x30, 0x65, 0x37, 0x32, 0x30, 0x64, 0x36, 0x61, 0x63, 0x31, 0x63, 0x32, 0x61, 0x64, 0x37, 0x39, 0x63, 0x33, 0x32, 0x31, 0x64, 0x63, 0x63, 0x31, 0x63, 0x31, 0x61, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x61, 0x61, 0x30, 0x30, 0x39, 0x35, 0x30, 0x63, 0x30, 0x65, 0x38, 0x31, 0x66, 0x61, 0x33, 0x32, 0x31, 0x30, 0x31, 0x37, 0x33, 0x65, 0x37, 0x32, 0x39, 0x61, 0x61, 0x66, 0x31, 0x36, 0x33, 0x61, 0x32, 0x37, 0x63, 0x64, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x33, 0x36, 0x30, 0x34, 0x62, 0x30, 0x35, 0x30, 0x33, 0x30, 0x34, 0x36, 0x65, 0x36, 0x32, 0x34, 0x63, 0x64, 0x32, 0x36, 0x61, 0x38, 0x62, 0x36, 0x66, 0x62, 0x34, 0x37, 0x34, 0x32, 0x64, 0x63, 0x65, 0x30, 0x32, 0x61, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x39, 0x38, 0x35, 0x39, 0x34, 0x62, 0x66, 0x36, 0x38, 0x62, 0x35, 0x37, 0x33, 0x35, 0x31, 0x65, 0x38, 0x38, 0x31, 0x34, 0x61, 0x65, 0x39, 0x65, 0x36, 0x64, 0x66, 0x64, 0x32, 0x64, 0x32, 0x35, 0x34, 0x61, 0x61, 0x30, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x34, 0x35, 0x32, 0x30, 0x32, 0x61, 0x32, 0x35, 0x66, 0x36, 0x61, 0x64, 0x30, 0x30, 0x31, 0x31, 0x66, 0x31, 0x31, 0x35, 0x61, 0x35, 0x61, 0x37, 0x32, 0x32, 0x30, 0x34, 0x66, 0x32, 0x66, 0x32, 0x31, 0x39, 0x38, 0x38, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x32, 0x64, 0x30, 0x36, 0x32, 0x38, 0x37, 0x33, 0x33, 0x33, 0x34, 0x35, 0x34, 0x35, 0x63, 0x65, 0x61, 0x32, 0x39, 0x32, 0x31, 0x38, 0x65, 0x34, 0x30, 0x35, 0x37, 0x37, 0x36, 0x30, 0x35, 0x39, 0x30, 0x66, 0x37, 0x34, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x64, 0x64, 0x62, 0x32, 0x65, 0x65, 0x39, 0x38, 0x64, 0x65, 0x31, 0x39, 0x65, 0x65, 0x34, 0x63, 0x39, 0x31, 0x66, 0x36, 0x36, 0x31, 0x65, 0x65, 0x38, 0x65, 0x36, 0x37, 0x61, 0x39, 0x31, 0x64, 0x30, 0x35, 0x34, 0x62, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x66, 0x32, 0x39, 0x32, 0x38, 0x62, 0x65, 0x65, 0x66, 0x30, 0x39, 0x61, 0x34, 0x30, 0x66, 0x39, 0x62, 0x66, 0x63, 0x39, 0x35, 0x33, 0x62, 0x65, 0x30, 0x36, 0x61, 0x32, 0x35, 0x31, 0x31, 0x31, 0x36, 0x31, 0x38, 0x32, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x62, 0x34, 0x37, 0x35, 0x38, 0x65, 0x39, 0x65, 0x31, 0x34, 0x35, 0x30, 0x65, 0x37, 0x61, 0x66, 0x34, 0x32, 0x36, 0x38, 0x63, 0x33, 0x63, 0x37, 0x62, 0x31, 0x65, 0x37, 0x62, 0x64, 0x36, 0x66, 0x35, 0x63, 0x37, 0x35, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x35, 0x37, 0x30, 0x64, 0x62, 0x61, 0x39, 0x37, 0x35, 0x32, 0x32, 0x37, 0x62, 0x31, 0x63, 0x34, 0x32, 0x64, 0x36, 0x65, 0x38, 0x64, 0x65, 0x61, 0x32, 0x63, 0x35, 0x36, 0x63, 0x39, 0x61, 0x64, 0x39, 0x36, 0x30, 0x36, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x30, 0x64, 0x38, 0x62, 0x38, 0x61, 0x30, 0x30, 0x31, 0x36, 0x64, 0x31, 0x34, 0x33, 0x30, 0x35, 0x34, 0x66, 0x31, 0x34, 0x39, 0x66, 0x62, 0x33, 0x62, 0x38, 0x65, 0x35, 0x35, 0x30, 0x64, 0x63, 0x30, 0x37, 0x39, 0x37, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x62, 0x33, 0x39, 0x62, 0x30, 0x36, 0x30, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x63, 0x61, 0x31, 0x30, 0x34, 0x39, 0x62, 0x61, 0x31, 0x35, 0x34, 0x62, 0x63, 0x66, 0x61, 0x30, 0x30, 0x66, 0x66, 0x38, 0x61, 0x66, 0x32, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x35, 0x65, 0x31, 0x38, 0x37, 0x36, 0x39, 0x64, 0x37, 0x65, 0x65, 0x37, 0x32, 0x37, 0x63, 0x37, 0x30, 0x31, 0x33, 0x66, 0x39, 0x32, 0x64, 0x65, 0x32, 0x34, 0x64, 0x31, 0x31, 0x37, 0x39, 0x36, 0x37, 0x66, 0x66, 0x33, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x38, 0x65, 0x62, 0x39, 0x65, 0x31, 0x64, 0x32, 0x38, 0x35, 0x64, 0x61, 0x62, 0x65, 0x39, 0x33, 0x65, 0x35, 0x64, 0x34, 0x62, 0x61, 0x65, 0x37, 0x36, 0x62, 0x65, 0x65, 0x66, 0x65, 0x34, 0x33, 0x62, 0x35, 0x32, 0x31, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x31, 0x38, 0x35, 0x32, 0x31, 0x33, 0x32, 0x31, 0x61, 0x62, 0x61, 0x66, 0x35, 0x62, 0x32, 0x36, 0x35, 0x31, 0x33, 0x61, 0x34, 0x61, 0x39, 0x35, 0x32, 0x38, 0x30, 0x38, 0x36, 0x66, 0x32, 0x32, 0x30, 0x61, 0x64, 0x63, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x36, 0x35, 0x66, 0x36, 0x65, 0x31, 0x37, 0x31, 0x36, 0x33, 0x62, 0x35, 0x64, 0x32, 0x30, 0x33, 0x36, 0x34, 0x31, 0x66, 0x35, 0x31, 0x63, 0x63, 0x37, 0x62, 0x32, 0x34, 0x62, 0x30, 0x30, 0x66, 0x30, 0x32, 0x63, 0x38, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x31, 0x66, 0x61, 0x65, 0x64, 0x31, 0x32, 0x35, 0x36, 0x31, 0x62, 0x62, 0x37, 0x61, 0x65, 0x65, 0x30, 0x34, 0x65, 0x35, 0x31, 0x38, 0x35, 0x61, 0x66, 0x38, 0x30, 0x32, 0x62, 0x31, 0x63, 0x33, 0x34, 0x33, 0x38, 0x64, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x65, 0x64, 0x36, 0x37, 0x31, 0x35, 0x66, 0x38, 0x36, 0x32, 0x62, 0x31, 0x66, 0x66, 0x38, 0x36, 0x30, 0x35, 0x38, 0x32, 0x30, 0x31, 0x66, 0x63, 0x63, 0x65, 0x35, 0x30, 0x38, 0x32, 0x62, 0x33, 0x36, 0x65, 0x36, 0x32, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x34, 0x35, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x66, 0x66, 0x35, 0x62, 0x34, 0x63, 0x66, 0x30, 0x31, 0x36, 0x30, 0x32, 0x37, 0x65, 0x38, 0x33, 0x32, 0x33, 0x34, 0x39, 0x37, 0x64, 0x34, 0x34, 0x32, 0x38, 0x64, 0x33, 0x65, 0x35, 0x61, 0x38, 0x33, 0x62, 0x38, 0x37, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x39, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x65, 0x38, 0x31, 0x36, 0x61, 0x66, 0x63, 0x31, 0x62, 0x35, 0x63, 0x30, 0x66, 0x33, 0x39, 0x38, 0x35, 0x32, 0x31, 0x33, 0x31, 0x39, 0x35, 0x39, 0x64, 0x39, 0x34, 0x36, 0x65, 0x62, 0x33, 0x62, 0x30, 0x37, 0x62, 0x35, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x33, 0x63, 0x66, 0x32, 0x38, 0x34, 0x32, 0x63, 0x62, 0x39, 0x64, 0x65, 0x38, 0x37, 0x36, 0x63, 0x32, 0x37, 0x36, 0x66, 0x61, 0x36, 0x34, 0x37, 0x36, 0x37, 0x64, 0x31, 0x61, 0x38, 0x65, 0x63, 0x66, 0x35, 0x37, 0x33, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x63, 0x36, 0x65, 0x33, 0x65, 0x65, 0x37, 0x61, 0x35, 0x36, 0x63, 0x65, 0x38, 0x66, 0x31, 0x34, 0x61, 0x33, 0x37, 0x35, 0x33, 0x32, 0x35, 0x39, 0x30, 0x66, 0x36, 0x33, 0x37, 0x31, 0x36, 0x62, 0x39, 0x39, 0x36, 0x36, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x64, 0x32, 0x35, 0x64, 0x33, 0x66, 0x33, 0x64, 0x38, 0x34, 0x36, 0x64, 0x32, 0x33, 0x39, 0x66, 0x35, 0x32, 0x35, 0x66, 0x61, 0x38, 0x63, 0x61, 0x63, 0x39, 0x37, 0x62, 0x63, 0x34, 0x33, 0x35, 0x37, 0x38, 0x64, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x36, 0x36, 0x37, 0x37, 0x34, 0x64, 0x38, 0x32, 0x32, 0x37, 0x39, 0x33, 0x66, 0x66, 0x32, 0x35, 0x66, 0x31, 0x37, 0x36, 0x30, 0x39, 0x30, 0x39, 0x34, 0x37, 0x39, 0x63, 0x66, 0x36, 0x32, 0x34, 0x39, 0x31, 0x62, 0x66, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x37, 0x37, 0x39, 0x61, 0x35, 0x36, 0x35, 0x36, 0x66, 0x66, 0x30, 0x30, 0x64, 0x37, 0x33, 0x65, 0x61, 0x63, 0x33, 0x61, 0x64, 0x30, 0x63, 0x33, 0x38, 0x62, 0x36, 0x63, 0x38, 0x35, 0x33, 0x30, 0x39, 0x34, 0x66, 0x62, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x37, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x65, 0x65, 0x64, 0x33, 0x32, 0x37, 0x66, 0x38, 0x65, 0x62, 0x31, 0x64, 0x31, 0x33, 0x33, 0x38, 0x61, 0x33, 0x63, 0x62, 0x37, 0x62, 0x30, 0x66, 0x38, 0x61, 0x34, 0x62, 0x61, 0x61, 0x35, 0x39, 0x30, 0x37, 0x63, 0x64, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x34, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x38, 0x38, 0x65, 0x62, 0x61, 0x63, 0x63, 0x34, 0x31, 0x62, 0x33, 0x36, 0x38, 0x37, 0x66, 0x33, 0x39, 0x65, 0x34, 0x62, 0x35, 0x39, 0x65, 0x31, 0x35, 0x39, 0x35, 0x39, 0x39, 0x62, 0x38, 0x30, 0x63, 0x62, 0x61, 0x33, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x37, 0x34, 0x66, 0x33, 0x65, 0x32, 0x39, 0x38, 0x35, 0x64, 0x35, 0x66, 0x37, 0x62, 0x34, 0x30, 0x36, 0x36, 0x32, 0x37, 0x65, 0x31, 0x37, 0x62, 0x61, 0x61, 0x37, 0x37, 0x32, 0x62, 0x30, 0x31, 0x61, 0x62, 0x63, 0x63, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x31, 0x30, 0x34, 0x35, 0x38, 0x64, 0x61, 0x63, 0x61, 0x37, 0x39, 0x65, 0x34, 0x61, 0x36, 0x62, 0x32, 0x34, 0x62, 0x32, 0x39, 0x61, 0x38, 0x61, 0x38, 0x61, 0x64, 0x61, 0x37, 0x31, 0x31, 0x62, 0x37, 0x66, 0x32, 0x65, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x31, 0x30, 0x36, 0x30, 0x66, 0x63, 0x35, 0x38, 0x63, 0x37, 0x35, 0x30, 0x63, 0x34, 0x30, 0x35, 0x31, 0x32, 0x66, 0x38, 0x33, 0x33, 0x36, 0x39, 0x63, 0x30, 0x61, 0x36, 0x33, 0x33, 0x34, 0x30, 0x63, 0x31, 0x32, 0x32, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x32, 0x37, 0x35, 0x37, 0x63, 0x63, 0x33, 0x35, 0x35, 0x31, 0x61, 0x30, 0x39, 0x35, 0x38, 0x37, 0x38, 0x64, 0x39, 0x37, 0x38, 0x37, 0x35, 0x36, 0x31, 0x35, 0x66, 0x65, 0x30, 0x63, 0x36, 0x61, 0x33, 0x32, 0x61, 0x61, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x36, 0x35, 0x39, 0x64, 0x38, 0x35, 0x65, 0x37, 0x63, 0x33, 0x34, 0x66, 0x38, 0x38, 0x33, 0x33, 0x65, 0x61, 0x37, 0x66, 0x34, 0x38, 0x38, 0x64, 0x65, 0x31, 0x66, 0x62, 0x62, 0x35, 0x64, 0x34, 0x31, 0x34, 0x39, 0x62, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x30, 0x37, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x34, 0x39, 0x62, 0x35, 0x37, 0x32, 0x36, 0x63, 0x61, 0x66, 0x36, 0x64, 0x35, 0x65, 0x62, 0x35, 0x62, 0x66, 0x32, 0x61, 0x63, 0x63, 0x34, 0x31, 0x64, 0x34, 0x65, 0x32, 0x64, 0x63, 0x33, 0x32, 0x38, 0x64, 0x65, 0x31, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x65, 0x30, 0x63, 0x63, 0x34, 0x32, 0x34, 0x62, 0x35, 0x33, 0x61, 0x33, 0x31, 0x66, 0x30, 0x39, 0x31, 0x36, 0x62, 0x65, 0x30, 0x38, 0x65, 0x63, 0x38, 0x31, 0x63, 0x35, 0x30, 0x62, 0x66, 0x38, 0x65, 0x61, 0x62, 0x30, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x37, 0x31, 0x32, 0x37, 0x30, 0x31, 0x36, 0x31, 0x39, 0x63, 0x61, 0x37, 0x36, 0x32, 0x33, 0x63, 0x35, 0x35, 0x64, 0x62, 0x33, 0x61, 0x30, 0x61, 0x64, 0x33, 0x30, 0x65, 0x38, 0x36, 0x37, 0x64, 0x62, 0x30, 0x31, 0x36, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x63, 0x61, 0x33, 0x33, 0x36, 0x63, 0x38, 0x65, 0x39, 0x31, 0x62, 0x64, 0x32, 0x30, 0x65, 0x33, 0x31, 0x34, 0x63, 0x32, 0x30, 0x62, 0x32, 0x64, 0x64, 0x34, 0x36, 0x30, 0x38, 0x62, 0x39, 0x63, 0x38, 0x62, 0x39, 0x34, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x61, 0x63, 0x64, 0x61, 0x61, 0x39, 0x66, 0x62, 0x31, 0x37, 0x64, 0x33, 0x63, 0x33, 0x30, 0x39, 0x39, 0x31, 0x31, 0x61, 0x37, 0x37, 0x62, 0x30, 0x35, 0x66, 0x35, 0x33, 0x39, 0x31, 0x66, 0x61, 0x30, 0x33, 0x34, 0x65, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x37, 0x64, 0x37, 0x64, 0x65, 0x61, 0x62, 0x32, 0x39, 0x36, 0x63, 0x38, 0x62, 0x34, 0x66, 0x61, 0x30, 0x37, 0x63, 0x61, 0x33, 0x62, 0x65, 0x31, 0x38, 0x34, 0x31, 0x36, 0x33, 0x64, 0x35, 0x61, 0x36, 0x64, 0x36, 0x30, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x62, 0x39, 0x35, 0x34, 0x35, 0x66, 0x37, 0x65, 0x64, 0x30, 0x38, 0x36, 0x65, 0x35, 0x35, 0x32, 0x39, 0x32, 0x34, 0x36, 0x33, 0x39, 0x66, 0x39, 0x61, 0x39, 0x65, 0x64, 0x62, 0x62, 0x64, 0x35, 0x35, 0x34, 0x30, 0x62, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x36, 0x36, 0x62, 0x38, 0x31, 0x64, 0x65, 0x63, 0x62, 0x30, 0x32, 0x65, 0x65, 0x37, 0x30, 0x61, 0x65, 0x32, 0x35, 0x30, 0x63, 0x65, 0x65, 0x35, 0x63, 0x64, 0x63, 0x37, 0x37, 0x62, 0x35, 0x39, 0x64, 0x37, 0x62, 0x36, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x65, 0x33, 0x63, 0x63, 0x34, 0x33, 0x62, 0x63, 0x64, 0x62, 0x30, 0x32, 0x36, 0x61, 0x61, 0x64, 0x37, 0x35, 0x39, 0x63, 0x37, 0x30, 0x36, 0x36, 0x66, 0x35, 0x35, 0x35, 0x62, 0x62, 0x66, 0x32, 0x61, 0x63, 0x36, 0x36, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x63, 0x62, 0x64, 0x38, 0x35, 0x66, 0x65, 0x65, 0x61, 0x36, 0x61, 0x37, 0x35, 0x34, 0x66, 0x63, 0x66, 0x33, 0x34, 0x34, 0x39, 0x34, 0x34, 0x39, 0x65, 0x33, 0x37, 0x66, 0x66, 0x39, 0x37, 0x38, 0x34, 0x66, 0x37, 0x37, 0x37, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x61, 0x37, 0x34, 0x34, 0x65, 0x66, 0x61, 0x36, 0x64, 0x35, 0x63, 0x32, 0x31, 0x33, 0x37, 0x64, 0x65, 0x66, 0x65, 0x66, 0x38, 0x65, 0x66, 0x39, 0x31, 0x38, 0x37, 0x62, 0x36, 0x34, 0x39, 0x65, 0x65, 0x65, 0x31, 0x63, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x37, 0x36, 0x35, 0x35, 0x65, 0x39, 0x66, 0x33, 0x65, 0x35, 0x62, 0x61, 0x35, 0x64, 0x36, 0x65, 0x38, 0x37, 0x65, 0x34, 0x31, 0x32, 0x61, 0x65, 0x62, 0x65, 0x39, 0x65, 0x65, 0x30, 0x64, 0x34, 0x39, 0x32, 0x34, 0x37, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x32, 0x30, 0x62, 0x38, 0x31, 0x61, 0x65, 0x35, 0x33, 0x39, 0x32, 0x36, 0x61, 0x63, 0x65, 0x39, 0x66, 0x37, 0x64, 0x37, 0x34, 0x31, 0x35, 0x61, 0x30, 0x35, 0x30, 0x63, 0x30, 0x33, 0x31, 0x64, 0x35, 0x38, 0x35, 0x66, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x34, 0x34, 0x66, 0x31, 0x33, 0x33, 0x31, 0x31, 0x35, 0x38, 0x62, 0x39, 0x63, 0x65, 0x32, 0x36, 0x62, 0x62, 0x65, 0x30, 0x62, 0x39, 0x32, 0x33, 0x36, 0x62, 0x39, 0x32, 0x30, 0x33, 0x63, 0x61, 0x33, 0x35, 0x31, 0x34, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x63, 0x32, 0x33, 0x36, 0x31, 0x34, 0x31, 0x64, 0x61, 0x65, 0x63, 0x38, 0x33, 0x37, 0x65, 0x63, 0x65, 0x30, 0x34, 0x66, 0x64, 0x61, 0x65, 0x65, 0x31, 0x64, 0x39, 0x30, 0x63, 0x66, 0x38, 0x62, 0x62, 0x64, 0x63, 0x31, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x33, 0x64, 0x33, 0x37, 0x38, 0x36, 0x34, 0x61, 0x34, 0x61, 0x35, 0x33, 0x37, 0x64, 0x33, 0x35, 0x63, 0x38, 0x64, 0x39, 0x39, 0x37, 0x32, 0x33, 0x63, 0x64, 0x36, 0x34, 0x30, 0x36, 0x63, 0x65, 0x32, 0x35, 0x36, 0x32, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x39, 0x34, 0x38, 0x33, 0x66, 0x36, 0x61, 0x38, 0x34, 0x34, 0x34, 0x66, 0x32, 0x35, 0x34, 0x39, 0x64, 0x36, 0x31, 0x31, 0x61, 0x66, 0x65, 0x30, 0x32, 0x63, 0x34, 0x33, 0x32, 0x64, 0x31, 0x35, 0x65, 0x31, 0x31, 0x30, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x64, 0x36, 0x34, 0x33, 0x37, 0x33, 0x66, 0x32, 0x66, 0x62, 0x63, 0x64, 0x39, 0x63, 0x30, 0x66, 0x61, 0x63, 0x61, 0x36, 0x30, 0x35, 0x34, 0x37, 0x63, 0x61, 0x64, 0x36, 0x32, 0x65, 0x32, 0x36, 0x64, 0x39, 0x38, 0x35, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x39, 0x63, 0x30, 0x33, 0x36, 0x65, 0x64, 0x37, 0x63, 0x34, 0x39, 0x32, 0x38, 0x37, 0x39, 0x39, 0x32, 0x31, 0x62, 0x65, 0x34, 0x31, 0x65, 0x31, 0x30, 0x63, 0x61, 0x31, 0x36, 0x39, 0x38, 0x31, 0x39, 0x38, 0x61, 0x37, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x36, 0x32, 0x63, 0x38, 0x39, 0x63, 0x61, 0x61, 0x39, 0x64, 0x38, 0x64, 0x37, 0x38, 0x39, 0x31, 0x62, 0x32, 0x35, 0x34, 0x35, 0x64, 0x65, 0x66, 0x32, 0x31, 0x36, 0x66, 0x37, 0x34, 0x36, 0x34, 0x64, 0x35, 0x62, 0x62, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x30, 0x33, 0x36, 0x36, 0x61, 0x37, 0x63, 0x66, 0x62, 0x64, 0x33, 0x34, 0x34, 0x35, 0x61, 0x37, 0x30, 0x64, 0x62, 0x37, 0x66, 0x65, 0x35, 0x61, 0x65, 0x33, 0x34, 0x38, 0x38, 0x35, 0x37, 0x35, 0x34, 0x66, 0x64, 0x34, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x35, 0x32, 0x63, 0x66, 0x30, 0x38, 0x39, 0x35, 0x62, 0x62, 0x33, 0x35, 0x65, 0x36, 0x35, 0x36, 0x31, 0x36, 0x31, 0x65, 0x34, 0x64, 0x63, 0x34, 0x36, 0x61, 0x65, 0x30, 0x65, 0x39, 0x36, 0x64, 0x64, 0x33, 0x65, 0x36, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x63, 0x66, 0x37, 0x31, 0x62, 0x32, 0x32, 0x36, 0x35, 0x38, 0x33, 0x65, 0x33, 0x61, 0x39, 0x32, 0x31, 0x31, 0x30, 0x33, 0x61, 0x35, 0x33, 0x31, 0x36, 0x66, 0x38, 0x35, 0x35, 0x61, 0x36, 0x35, 0x37, 0x37, 0x39, 0x64, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x36, 0x62, 0x36, 0x30, 0x62, 0x62, 0x36, 0x64, 0x36, 0x37, 0x39, 0x32, 0x38, 0x63, 0x32, 0x39, 0x66, 0x64, 0x30, 0x33, 0x31, 0x33, 0x63, 0x36, 0x36, 0x36, 0x64, 0x61, 0x38, 0x66, 0x31, 0x36, 0x39, 0x38, 0x64, 0x39, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x34, 0x35, 0x34, 0x62, 0x33, 0x61, 0x38, 0x62, 0x66, 0x66, 0x39, 0x37, 0x30, 0x39, 0x66, 0x64, 0x30, 0x65, 0x31, 0x39, 0x30, 0x38, 0x37, 0x37, 0x65, 0x36, 0x63, 0x62, 0x36, 0x63, 0x38, 0x39, 0x39, 0x37, 0x34, 0x64, 0x62, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x61, 0x61, 0x63, 0x37, 0x66, 0x61, 0x31, 0x39, 0x37, 0x66, 0x66, 0x38, 0x35, 0x63, 0x33, 0x30, 0x65, 0x30, 0x33, 0x62, 0x37, 0x61, 0x35, 0x33, 0x38, 0x32, 0x62, 0x39, 0x35, 0x37, 0x66, 0x34, 0x31, 0x66, 0x33, 0x61, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x36, 0x65, 0x35, 0x36, 0x30, 0x63, 0x39, 0x62, 0x63, 0x36, 0x32, 0x30, 0x64, 0x34, 0x62, 0x65, 0x61, 0x33, 0x61, 0x39, 0x34, 0x64, 0x34, 0x37, 0x66, 0x37, 0x38, 0x38, 0x30, 0x62, 0x66, 0x34, 0x37, 0x66, 0x32, 0x64, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x66, 0x64, 0x30, 0x35, 0x62, 0x30, 0x65, 0x33, 0x63, 0x34, 0x31, 0x37, 0x64, 0x35, 0x35, 0x62, 0x33, 0x33, 0x34, 0x33, 0x30, 0x36, 0x30, 0x34, 0x38, 0x36, 0x63, 0x64, 0x64, 0x35, 0x65, 0x39, 0x32, 0x61, 0x61, 0x37, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x35, 0x39, 0x61, 0x30, 0x38, 0x32, 0x34, 0x36, 0x61, 0x38, 0x32, 0x30, 0x36, 0x66, 0x38, 0x64, 0x35, 0x38, 0x66, 0x37, 0x30, 0x62, 0x62, 0x31, 0x66, 0x30, 0x64, 0x33, 0x35, 0x63, 0x35, 0x62, 0x63, 0x63, 0x37, 0x31, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x66, 0x66, 0x66, 0x35, 0x30, 0x64, 0x62, 0x33, 0x36, 0x61, 0x37, 0x38, 0x35, 0x35, 0x35, 0x35, 0x66, 0x30, 0x37, 0x36, 0x35, 0x32, 0x61, 0x31, 0x35, 0x33, 0x62, 0x30, 0x63, 0x34, 0x32, 0x62, 0x31, 0x62, 0x38, 0x62, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x34, 0x66, 0x35, 0x65, 0x64, 0x66, 0x32, 0x62, 0x63, 0x66, 0x32, 0x34, 0x33, 0x33, 0x66, 0x32, 0x31, 0x31, 0x64, 0x61, 0x64, 0x64, 0x30, 0x63, 0x63, 0x34, 0x35, 0x30, 0x64, 0x62, 0x31, 0x62, 0x30, 0x30, 0x38, 0x65, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x37, 0x38, 0x66, 0x64, 0x34, 0x33, 0x38, 0x32, 0x35, 0x31, 0x31, 0x65, 0x39, 0x36, 0x38, 0x65, 0x64, 0x31, 0x39, 0x32, 0x31, 0x30, 0x36, 0x37, 0x33, 0x37, 0x64, 0x33, 0x32, 0x34, 0x66, 0x34, 0x35, 0x34, 0x62, 0x35, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x34, 0x30, 0x38, 0x39, 0x35, 0x35, 0x33, 0x61, 0x65, 0x34, 0x63, 0x32, 0x32, 0x63, 0x61, 0x30, 0x39, 0x66, 0x62, 0x63, 0x39, 0x38, 0x66, 0x35, 0x37, 0x30, 0x37, 0x35, 0x63, 0x66, 0x32, 0x65, 0x63, 0x35, 0x39, 0x35, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x65, 0x66, 0x33, 0x66, 0x61, 0x34, 0x63, 0x34, 0x33, 0x63, 0x63, 0x64, 0x63, 0x35, 0x37, 0x62, 0x32, 0x32, 0x61, 0x34, 0x62, 0x39, 0x62, 0x32, 0x33, 0x33, 0x31, 0x61, 0x38, 0x32, 0x65, 0x35, 0x33, 0x38, 0x31, 0x38, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x38, 0x65, 0x36, 0x35, 0x31, 0x32, 0x35, 0x34, 0x32, 0x31, 0x38, 0x38, 0x30, 0x64, 0x34, 0x32, 0x62, 0x64, 0x66, 0x31, 0x30, 0x31, 0x38, 0x61, 0x62, 0x39, 0x37, 0x37, 0x38, 0x64, 0x39, 0x36, 0x39, 0x32, 0x38, 0x66, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x35, 0x31, 0x38, 0x65, 0x35, 0x64, 0x30, 0x32, 0x62, 0x32, 0x30, 0x35, 0x31, 0x38, 0x30, 0x66, 0x30, 0x34, 0x36, 0x33, 0x61, 0x33, 0x32, 0x30, 0x30, 0x34, 0x34, 0x37, 0x31, 0x66, 0x37, 0x35, 0x33, 0x63, 0x35, 0x32, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x34, 0x32, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x61, 0x37, 0x34, 0x30, 0x31, 0x32, 0x36, 0x32, 0x33, 0x38, 0x34, 0x65, 0x32, 0x65, 0x38, 0x62, 0x34, 0x62, 0x32, 0x36, 0x64, 0x64, 0x31, 0x35, 0x34, 0x37, 0x39, 0x39, 0x62, 0x35, 0x35, 0x31, 0x34, 0x35, 0x65, 0x66, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x36, 0x39, 0x32, 0x30, 0x61, 0x36, 0x34, 0x62, 0x33, 0x36, 0x33, 0x62, 0x38, 0x64, 0x35, 0x64, 0x39, 0x30, 0x38, 0x30, 0x32, 0x34, 0x39, 0x34, 0x63, 0x66, 0x35, 0x36, 0x34, 0x62, 0x35, 0x34, 0x37, 0x63, 0x34, 0x33, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x61, 0x62, 0x34, 0x62, 0x64, 0x33, 0x35, 0x38, 0x38, 0x66, 0x34, 0x36, 0x63, 0x62, 0x32, 0x37, 0x32, 0x65, 0x35, 0x36, 0x65, 0x39, 0x33, 0x64, 0x65, 0x65, 0x64, 0x33, 0x38, 0x36, 0x62, 0x61, 0x38, 0x62, 0x37, 0x35, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x32, 0x39, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x38, 0x38, 0x64, 0x61, 0x39, 0x62, 0x35, 0x37, 0x66, 0x64, 0x30, 0x35, 0x65, 0x64, 0x63, 0x34, 0x66, 0x66, 0x39, 0x39, 0x65, 0x37, 0x66, 0x65, 0x66, 0x33, 0x30, 0x31, 0x35, 0x31, 0x39, 0x63, 0x38, 0x61, 0x30, 0x61, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x62, 0x32, 0x64, 0x36, 0x63, 0x66, 0x36, 0x35, 0x63, 0x36, 0x66, 0x34, 0x61, 0x33, 0x34, 0x37, 0x64, 0x64, 0x63, 0x36, 0x35, 0x37, 0x32, 0x36, 0x35, 0x35, 0x33, 0x35, 0x34, 0x64, 0x38, 0x61, 0x34, 0x31, 0x32, 0x62, 0x32, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x33, 0x31, 0x39, 0x31, 0x33, 0x39, 0x66, 0x62, 0x61, 0x62, 0x32, 0x65, 0x38, 0x65, 0x32, 0x61, 0x63, 0x63, 0x63, 0x31, 0x64, 0x39, 0x32, 0x34, 0x64, 0x34, 0x62, 0x31, 0x31, 0x64, 0x66, 0x36, 0x36, 0x39, 0x36, 0x63, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x33, 0x37, 0x37, 0x62, 0x62, 0x30, 0x33, 0x61, 0x62, 0x35, 0x32, 0x63, 0x34, 0x63, 0x62, 0x37, 0x39, 0x62, 0x65, 0x66, 0x61, 0x31, 0x64, 0x64, 0x31, 0x31, 0x34, 0x39, 0x38, 0x32, 0x39, 0x32, 0x34, 0x63, 0x34, 0x61, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x37, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x39, 0x34, 0x39, 0x63, 0x36, 0x34, 0x37, 0x66, 0x64, 0x63, 0x66, 0x64, 0x32, 0x35, 0x31, 0x34, 0x63, 0x37, 0x64, 0x35, 0x38, 0x65, 0x33, 0x31, 0x66, 0x32, 0x38, 0x61, 0x35, 0x33, 0x32, 0x64, 0x38, 0x63, 0x35, 0x38, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x65, 0x35, 0x65, 0x39, 0x64, 0x61, 0x37, 0x33, 0x35, 0x66, 0x66, 0x30, 0x37, 0x37, 0x32, 0x34, 0x39, 0x64, 0x63, 0x62, 0x39, 0x61, 0x61, 0x66, 0x33, 0x64, 0x62, 0x32, 0x61, 0x34, 0x38, 0x64, 0x39, 0x34, 0x39, 0x38, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x36, 0x66, 0x35, 0x66, 0x34, 0x32, 0x62, 0x36, 0x31, 0x39, 0x33, 0x62, 0x31, 0x61, 0x64, 0x31, 0x36, 0x32, 0x30, 0x36, 0x65, 0x34, 0x61, 0x66, 0x62, 0x35, 0x32, 0x33, 0x39, 0x64, 0x34, 0x64, 0x37, 0x64, 0x62, 0x34, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x61, 0x34, 0x62, 0x65, 0x33, 0x31, 0x37, 0x65, 0x37, 0x65, 0x34, 0x62, 0x65, 0x64, 0x38, 0x34, 0x63, 0x30, 0x34, 0x39, 0x35, 0x65, 0x65, 0x65, 0x33, 0x32, 0x64, 0x36, 0x30, 0x37, 0x65, 0x63, 0x33, 0x38, 0x63, 0x61, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x30, 0x39, 0x34, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x31, 0x30, 0x31, 0x30, 0x36, 0x64, 0x65, 0x62, 0x64, 0x32, 0x39, 0x31, 0x61, 0x31, 0x63, 0x64, 0x38, 0x30, 0x62, 0x30, 0x66, 0x62, 0x62, 0x62, 0x38, 0x64, 0x38, 0x64, 0x39, 0x65, 0x39, 0x33, 0x61, 0x37, 0x63, 0x63, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x34, 0x32, 0x66, 0x39, 0x61, 0x61, 0x63, 0x65, 0x34, 0x63, 0x31, 0x38, 0x34, 0x35, 0x30, 0x34, 0x61, 0x62, 0x66, 0x35, 0x34, 0x32, 0x35, 0x37, 0x36, 0x32, 0x61, 0x63, 0x61, 0x32, 0x36, 0x66, 0x37, 0x31, 0x66, 0x62, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x62, 0x34, 0x66, 0x64, 0x33, 0x31, 0x35, 0x35, 0x35, 0x39, 0x34, 0x33, 0x36, 0x30, 0x34, 0x35, 0x64, 0x63, 0x62, 0x39, 0x39, 0x64, 0x34, 0x39, 0x64, 0x63, 0x65, 0x63, 0x30, 0x33, 0x66, 0x34, 0x30, 0x63, 0x34, 0x32, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x32, 0x62, 0x36, 0x34, 0x64, 0x62, 0x38, 0x65, 0x66, 0x37, 0x64, 0x36, 0x64, 0x66, 0x38, 0x37, 0x63, 0x37, 0x38, 0x38, 0x36, 0x33, 0x39, 0x63, 0x32, 0x32, 0x39, 0x30, 0x62, 0x65, 0x38, 0x34, 0x38, 0x32, 0x64, 0x35, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x65, 0x30, 0x39, 0x34, 0x32, 0x37, 0x63, 0x31, 0x65, 0x36, 0x33, 0x64, 0x65, 0x65, 0x64, 0x37, 0x65, 0x31, 0x32, 0x62, 0x38, 0x63, 0x35, 0x35, 0x61, 0x36, 0x61, 0x31, 0x39, 0x33, 0x32, 0x30, 0x65, 0x66, 0x34, 0x62, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x61, 0x64, 0x39, 0x30, 0x35, 0x64, 0x38, 0x34, 0x37, 0x63, 0x37, 0x62, 0x32, 0x33, 0x34, 0x31, 0x38, 0x61, 0x65, 0x65, 0x63, 0x62, 0x65, 0x33, 0x61, 0x64, 0x64, 0x62, 0x38, 0x64, 0x64, 0x33, 0x66, 0x38, 0x39, 0x32, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x39, 0x33, 0x31, 0x39, 0x65, 0x38, 0x31, 0x30, 0x36, 0x39, 0x65, 0x35, 0x64, 0x36, 0x30, 0x64, 0x66, 0x30, 0x30, 0x66, 0x33, 0x64, 0x65, 0x35, 0x61, 0x64, 0x65, 0x65, 0x33, 0x35, 0x30, 0x35, 0x65, 0x63, 0x64, 0x35, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x33, 0x34, 0x38, 0x66, 0x32, 0x66, 0x65, 0x34, 0x37, 0x62, 0x37, 0x65, 0x34, 0x31, 0x33, 0x63, 0x30, 0x37, 0x37, 0x61, 0x37, 0x62, 0x61, 0x66, 0x33, 0x61, 0x37, 0x35, 0x66, 0x62, 0x66, 0x38, 0x34, 0x32, 0x38, 0x36, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x65, 0x38, 0x63, 0x35, 0x30, 0x62, 0x38, 0x30, 0x61, 0x33, 0x35, 0x32, 0x62, 0x32, 0x34, 0x30, 0x63, 0x65, 0x37, 0x33, 0x34, 0x32, 0x62, 0x62, 0x66, 0x64, 0x66, 0x35, 0x36, 0x39, 0x30, 0x63, 0x63, 0x38, 0x63, 0x62, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x31, 0x63, 0x37, 0x39, 0x32, 0x63, 0x31, 0x39, 0x37, 0x64, 0x31, 0x38, 0x62, 0x64, 0x30, 0x34, 0x35, 0x64, 0x37, 0x30, 0x32, 0x34, 0x39, 0x33, 0x37, 0x63, 0x31, 0x66, 0x38, 0x34, 0x62, 0x36, 0x30, 0x66, 0x34, 0x34, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x39, 0x61, 0x66, 0x34, 0x66, 0x33, 0x34, 0x61, 0x64, 0x61, 0x61, 0x32, 0x33, 0x33, 0x30, 0x62, 0x30, 0x65, 0x34, 0x39, 0x64, 0x63, 0x37, 0x34, 0x65, 0x63, 0x31, 0x38, 0x61, 0x62, 0x32, 0x66, 0x39, 0x32, 0x66, 0x38, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x65, 0x39, 0x39, 0x66, 0x35, 0x63, 0x62, 0x62, 0x38, 0x33, 0x36, 0x62, 0x37, 0x61, 0x64, 0x33, 0x36, 0x32, 0x34, 0x37, 0x35, 0x37, 0x31, 0x61, 0x33, 0x30, 0x32, 0x63, 0x62, 0x65, 0x34, 0x62, 0x34, 0x38, 0x31, 0x63, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x33, 0x66, 0x62, 0x64, 0x65, 0x38, 0x64, 0x34, 0x36, 0x64, 0x32, 0x62, 0x63, 0x63, 0x30, 0x66, 0x61, 0x39, 0x62, 0x33, 0x33, 0x62, 0x64, 0x38, 0x62, 0x61, 0x37, 0x66, 0x38, 0x30, 0x34, 0x32, 0x31, 0x32, 0x35, 0x35, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x38, 0x37, 0x37, 0x39, 0x63, 0x61, 0x32, 0x64, 0x62, 0x65, 0x36, 0x36, 0x33, 0x65, 0x36, 0x33, 0x64, 0x62, 0x33, 0x66, 0x65, 0x37, 0x35, 0x36, 0x38, 0x33, 0x65, 0x61, 0x30, 0x65, 0x63, 0x36, 0x32, 0x65, 0x32, 0x33, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x33, 0x63, 0x62, 0x34, 0x35, 0x30, 0x66, 0x39, 0x35, 0x62, 0x62, 0x34, 0x36, 0x65, 0x32, 0x35, 0x61, 0x66, 0x62, 0x35, 0x30, 0x66, 0x65, 0x30, 0x35, 0x66, 0x65, 0x65, 0x65, 0x36, 0x66, 0x62, 0x38, 0x63, 0x63, 0x38, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x61, 0x62, 0x36, 0x36, 0x66, 0x65, 0x32, 0x31, 0x33, 0x65, 0x61, 0x35, 0x36, 0x63, 0x33, 0x61, 0x66, 0x62, 0x31, 0x32, 0x63, 0x37, 0x35, 0x62, 0x65, 0x33, 0x33, 0x66, 0x38, 0x65, 0x33, 0x32, 0x66, 0x64, 0x30, 0x38, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x30, 0x33, 0x64, 0x30, 0x36, 0x32, 0x35, 0x34, 0x39, 0x36, 0x39, 0x30, 0x63, 0x38, 0x65, 0x38, 0x62, 0x36, 0x33, 0x65, 0x61, 0x65, 0x34, 0x31, 0x64, 0x36, 0x63, 0x31, 0x30, 0x39, 0x34, 0x37, 0x36, 0x65, 0x32, 0x35, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x62, 0x30, 0x65, 0x61, 0x30, 0x32, 0x66, 0x65, 0x62, 0x36, 0x31, 0x64, 0x65, 0x63, 0x39, 0x65, 0x32, 0x32, 0x61, 0x35, 0x30, 0x37, 0x30, 0x39, 0x35, 0x39, 0x33, 0x33, 0x30, 0x32, 0x39, 0x39, 0x63, 0x34, 0x33, 0x30, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x63, 0x34, 0x37, 0x35, 0x62, 0x66, 0x30, 0x32, 0x65, 0x38, 0x62, 0x39, 0x32, 0x31, 0x34, 0x61, 0x64, 0x61, 0x35, 0x66, 0x61, 0x64, 0x30, 0x32, 0x66, 0x64, 0x66, 0x64, 0x31, 0x35, 0x62, 0x61, 0x33, 0x36, 0x35, 0x63, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x34, 0x39, 0x36, 0x36, 0x63, 0x63, 0x32, 0x32, 0x31, 0x33, 0x62, 0x35, 0x62, 0x38, 0x63, 0x62, 0x35, 0x62, 0x64, 0x36, 0x30, 0x38, 0x39, 0x65, 0x66, 0x39, 0x63, 0x64, 0x64, 0x62, 0x65, 0x66, 0x37, 0x65, 0x64, 0x66, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x37, 0x61, 0x30, 0x33, 0x36, 0x35, 0x35, 0x61, 0x66, 0x33, 0x36, 0x30, 0x38, 0x34, 0x31, 0x65, 0x38, 0x31, 0x30, 0x64, 0x38, 0x33, 0x66, 0x35, 0x65, 0x36, 0x31, 0x66, 0x62, 0x34, 0x30, 0x66, 0x34, 0x63, 0x64, 0x31, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x32, 0x30, 0x39, 0x66, 0x64, 0x63, 0x61, 0x39, 0x37, 0x39, 0x64, 0x30, 0x61, 0x36, 0x34, 0x37, 0x30, 0x31, 0x30, 0x61, 0x66, 0x39, 0x61, 0x38, 0x62, 0x35, 0x32, 0x66, 0x63, 0x37, 0x64, 0x32, 0x30, 0x64, 0x38, 0x63, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x31, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x39, 0x34, 0x65, 0x61, 0x65, 0x36, 0x65, 0x34, 0x32, 0x30, 0x61, 0x33, 0x64, 0x35, 0x36, 0x30, 0x30, 0x61, 0x33, 0x39, 0x63, 0x34, 0x31, 0x34, 0x31, 0x66, 0x38, 0x33, 0x38, 0x66, 0x66, 0x38, 0x65, 0x37, 0x63, 0x63, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x37, 0x37, 0x63, 0x63, 0x36, 0x31, 0x63, 0x66, 0x37, 0x35, 0x36, 0x62, 0x65, 0x33, 0x62, 0x33, 0x63, 0x32, 0x30, 0x63, 0x64, 0x34, 0x34, 0x39, 0x31, 0x63, 0x36, 0x39, 0x64, 0x32, 0x37, 0x35, 0x65, 0x37, 0x61, 0x31, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x62, 0x66, 0x36, 0x62, 0x61, 0x31, 0x36, 0x36, 0x65, 0x32, 0x33, 0x34, 0x30, 0x64, 0x62, 0x30, 0x35, 0x32, 0x65, 0x61, 0x32, 0x33, 0x64, 0x32, 0x38, 0x30, 0x32, 0x39, 0x62, 0x30, 0x64, 0x65, 0x36, 0x61, 0x61, 0x33, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x31, 0x30, 0x66, 0x32, 0x61, 0x30, 0x34, 0x36, 0x33, 0x62, 0x36, 0x35, 0x61, 0x65, 0x33, 0x30, 0x62, 0x30, 0x37, 0x30, 0x62, 0x33, 0x64, 0x66, 0x31, 0x38, 0x63, 0x66, 0x34, 0x36, 0x66, 0x35, 0x31, 0x65, 0x38, 0x39, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x39, 0x39, 0x35, 0x32, 0x64, 0x30, 0x62, 0x62, 0x34, 0x65, 0x62, 0x66, 0x61, 0x30, 0x65, 0x66, 0x64, 0x30, 0x31, 0x61, 0x33, 0x61, 0x61, 0x39, 0x65, 0x38, 0x65, 0x38, 0x37, 0x66, 0x30, 0x35, 0x32, 0x35, 0x37, 0x34, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x32, 0x33, 0x62, 0x36, 0x62, 0x38, 0x31, 0x37, 0x66, 0x66, 0x61, 0x35, 0x63, 0x36, 0x36, 0x34, 0x61, 0x63, 0x64, 0x61, 0x64, 0x37, 0x39, 0x62, 0x62, 0x37, 0x62, 0x37, 0x32, 0x36, 0x64, 0x33, 0x30, 0x61, 0x66, 0x30, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x63, 0x32, 0x30, 0x30, 0x34, 0x30, 0x63, 0x63, 0x64, 0x39, 0x61, 0x31, 0x61, 0x33, 0x32, 0x38, 0x33, 0x64, 0x61, 0x34, 0x64, 0x34, 0x61, 0x32, 0x66, 0x33, 0x36, 0x35, 0x38, 0x32, 0x30, 0x38, 0x34, 0x33, 0x64, 0x37, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x34, 0x39, 0x65, 0x37, 0x61, 0x34, 0x32, 0x36, 0x39, 0x38, 0x38, 0x32, 0x62, 0x64, 0x38, 0x37, 0x32, 0x32, 0x64, 0x34, 0x61, 0x36, 0x66, 0x35, 0x36, 0x36, 0x33, 0x34, 0x37, 0x36, 0x32, 0x39, 0x36, 0x32, 0x34, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x36, 0x32, 0x39, 0x62, 0x64, 0x35, 0x32, 0x66, 0x30, 0x65, 0x31, 0x30, 0x37, 0x62, 0x63, 0x30, 0x37, 0x31, 0x31, 0x37, 0x36, 0x63, 0x36, 0x34, 0x64, 0x66, 0x31, 0x30, 0x38, 0x66, 0x36, 0x34, 0x37, 0x37, 0x37, 0x64, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x37, 0x62, 0x32, 0x65, 0x30, 0x64, 0x38, 0x38, 0x38, 0x36, 0x37, 0x66, 0x66, 0x31, 0x35, 0x64, 0x32, 0x30, 0x37, 0x63, 0x32, 0x32, 0x32, 0x62, 0x65, 0x62, 0x66, 0x39, 0x34, 0x66, 0x61, 0x36, 0x63, 0x65, 0x38, 0x33, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x63, 0x65, 0x36, 0x38, 0x34, 0x62, 0x30, 0x39, 0x61, 0x62, 0x64, 0x61, 0x35, 0x33, 0x33, 0x38, 0x39, 0x61, 0x38, 0x37, 0x35, 0x33, 0x36, 0x39, 0x66, 0x37, 0x31, 0x39, 0x35, 0x38, 0x61, 0x65, 0x61, 0x63, 0x33, 0x62, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x62, 0x63, 0x33, 0x64, 0x61, 0x30, 0x33, 0x38, 0x31, 0x65, 0x63, 0x33, 0x33, 0x39, 0x63, 0x31, 0x63, 0x30, 0x34, 0x39, 0x65, 0x62, 0x31, 0x65, 0x64, 0x39, 0x65, 0x65, 0x33, 0x34, 0x66, 0x64, 0x63, 0x65, 0x61, 0x36, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x39, 0x61, 0x62, 0x38, 0x30, 0x37, 0x39, 0x30, 0x62, 0x32, 0x38, 0x66, 0x66, 0x31, 0x66, 0x66, 0x64, 0x36, 0x62, 0x61, 0x33, 0x39, 0x34, 0x65, 0x66, 0x63, 0x37, 0x34, 0x36, 0x33, 0x31, 0x30, 0x35, 0x63, 0x33, 0x36, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x62, 0x33, 0x36, 0x61, 0x66, 0x39, 0x61, 0x65, 0x65, 0x65, 0x64, 0x66, 0x39, 0x37, 0x62, 0x36, 0x62, 0x30, 0x32, 0x32, 0x38, 0x30, 0x66, 0x31, 0x31, 0x34, 0x66, 0x31, 0x33, 0x39, 0x38, 0x34, 0x65, 0x61, 0x33, 0x32, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x35, 0x37, 0x65, 0x37, 0x31, 0x36, 0x38, 0x37, 0x36, 0x63, 0x30, 0x63, 0x39, 0x35, 0x65, 0x66, 0x35, 0x65, 0x61, 0x65, 0x62, 0x64, 0x33, 0x35, 0x63, 0x38, 0x66, 0x34, 0x31, 0x62, 0x30, 0x36, 0x39, 0x62, 0x36, 0x62, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x32, 0x62, 0x30, 0x33, 0x32, 0x33, 0x35, 0x39, 0x62, 0x33, 0x36, 0x33, 0x39, 0x36, 0x34, 0x66, 0x63, 0x31, 0x31, 0x61, 0x35, 0x31, 0x38, 0x32, 0x36, 0x33, 0x62, 0x66, 0x64, 0x30, 0x35, 0x34, 0x33, 0x31, 0x65, 0x38, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x63, 0x63, 0x31, 0x66, 0x31, 0x63, 0x62, 0x35, 0x66, 0x34, 0x61, 0x38, 0x30, 0x30, 0x32, 0x65, 0x31, 0x38, 0x36, 0x62, 0x32, 0x30, 0x38, 0x38, 0x35, 0x64, 0x39, 0x64, 0x62, 0x63, 0x30, 0x33, 0x30, 0x63, 0x30, 0x38, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x36, 0x63, 0x38, 0x35, 0x65, 0x31, 0x36, 0x31, 0x33, 0x62, 0x39, 0x30, 0x30, 0x66, 0x61, 0x33, 0x35, 0x37, 0x62, 0x38, 0x32, 0x38, 0x33, 0x62, 0x31, 0x32, 0x30, 0x65, 0x36, 0x35, 0x61, 0x65, 0x66, 0x63, 0x64, 0x64, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x39, 0x39, 0x39, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x30, 0x62, 0x30, 0x32, 0x37, 0x34, 0x64, 0x37, 0x31, 0x32, 0x63, 0x37, 0x37, 0x65, 0x30, 0x38, 0x61, 0x35, 0x37, 0x30, 0x37, 0x64, 0x36, 0x66, 0x33, 0x65, 0x37, 0x30, 0x63, 0x30, 0x63, 0x65, 0x33, 0x64, 0x39, 0x32, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x64, 0x33, 0x61, 0x36, 0x65, 0x39, 0x33, 0x35, 0x37, 0x39, 0x63, 0x35, 0x36, 0x64, 0x34, 0x39, 0x34, 0x31, 0x37, 0x31, 0x66, 0x63, 0x35, 0x33, 0x33, 0x65, 0x37, 0x61, 0x39, 0x30, 0x65, 0x36, 0x66, 0x35, 0x39, 0x34, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x30, 0x65, 0x33, 0x30, 0x65, 0x32, 0x31, 0x34, 0x32, 0x39, 0x30, 0x64, 0x37, 0x34, 0x33, 0x64, 0x64, 0x33, 0x30, 0x65, 0x62, 0x30, 0x38, 0x32, 0x66, 0x31, 0x66, 0x30, 0x61, 0x35, 0x32, 0x32, 0x35, 0x61, 0x64, 0x65, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x37, 0x31, 0x38, 0x35, 0x32, 0x30, 0x65, 0x61, 0x65, 0x30, 0x61, 0x34, 0x64, 0x36, 0x32, 0x64, 0x37, 0x30, 0x64, 0x65, 0x31, 0x62, 0x65, 0x30, 0x63, 0x61, 0x34, 0x33, 0x31, 0x63, 0x35, 0x65, 0x65, 0x61, 0x32, 0x34, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x37, 0x66, 0x37, 0x39, 0x63, 0x62, 0x34, 0x31, 0x35, 0x61, 0x31, 0x66, 0x62, 0x38, 0x64, 0x62, 0x62, 0x64, 0x30, 0x39, 0x34, 0x36, 0x30, 0x37, 0x65, 0x65, 0x38, 0x64, 0x34, 0x31, 0x66, 0x62, 0x37, 0x63, 0x35, 0x61, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x64, 0x32, 0x35, 0x32, 0x65, 0x65, 0x39, 0x34, 0x30, 0x32, 0x62, 0x30, 0x65, 0x65, 0x66, 0x31, 0x34, 0x34, 0x32, 0x39, 0x35, 0x66, 0x30, 0x65, 0x36, 0x39, 0x66, 0x30, 0x64, 0x62, 0x35, 0x38, 0x36, 0x63, 0x30, 0x38, 0x37, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x62, 0x39, 0x32, 0x38, 0x61, 0x37, 0x36, 0x66, 0x61, 0x64, 0x36, 0x35, 0x37, 0x38, 0x66, 0x30, 0x34, 0x66, 0x30, 0x35, 0x35, 0x35, 0x65, 0x36, 0x33, 0x39, 0x35, 0x32, 0x63, 0x64, 0x32, 0x31, 0x64, 0x31, 0x35, 0x32, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x61, 0x35, 0x31, 0x37, 0x64, 0x37, 0x61, 0x64, 0x33, 0x35, 0x38, 0x32, 0x30, 0x62, 0x30, 0x39, 0x64, 0x34, 0x39, 0x37, 0x66, 0x61, 0x37, 0x65, 0x35, 0x35, 0x34, 0x30, 0x63, 0x64, 0x65, 0x39, 0x34, 0x39, 0x35, 0x38, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x65, 0x38, 0x38, 0x36, 0x33, 0x31, 0x37, 0x62, 0x36, 0x61, 0x36, 0x36, 0x61, 0x35, 0x62, 0x34, 0x66, 0x38, 0x31, 0x62, 0x66, 0x31, 0x36, 0x34, 0x63, 0x35, 0x33, 0x38, 0x63, 0x32, 0x36, 0x34, 0x33, 0x35, 0x31, 0x37, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x37, 0x30, 0x62, 0x34, 0x33, 0x64, 0x62, 0x61, 0x65, 0x34, 0x62, 0x31, 0x66, 0x33, 0x35, 0x61, 0x39, 0x32, 0x37, 0x62, 0x34, 0x66, 0x61, 0x38, 0x31, 0x32, 0x34, 0x64, 0x33, 0x38, 0x36, 0x36, 0x63, 0x61, 0x66, 0x39, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x36, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x62, 0x34, 0x32, 0x35, 0x37, 0x63, 0x66, 0x34, 0x31, 0x62, 0x36, 0x65, 0x32, 0x38, 0x38, 0x37, 0x38, 0x64, 0x35, 0x30, 0x64, 0x35, 0x37, 0x62, 0x39, 0x39, 0x39, 0x31, 0x34, 0x66, 0x66, 0x61, 0x38, 0x39, 0x38, 0x37, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x33, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x38, 0x62, 0x63, 0x32, 0x39, 0x63, 0x32, 0x62, 0x34, 0x38, 0x62, 0x31, 0x36, 0x39, 0x66, 0x66, 0x32, 0x62, 0x64, 0x63, 0x31, 0x36, 0x37, 0x31, 0x34, 0x63, 0x35, 0x38, 0x36, 0x65, 0x36, 0x63, 0x62, 0x38, 0x35, 0x63, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x37, 0x32, 0x63, 0x34, 0x63, 0x31, 0x63, 0x39, 0x39, 0x33, 0x39, 0x66, 0x37, 0x61, 0x61, 0x66, 0x36, 0x63, 0x66, 0x61, 0x63, 0x30, 0x34, 0x30, 0x39, 0x30, 0x66, 0x30, 0x30, 0x34, 0x37, 0x34, 0x38, 0x34, 0x30, 0x61, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x36, 0x62, 0x36, 0x35, 0x65, 0x61, 0x62, 0x38, 0x64, 0x66, 0x63, 0x39, 0x31, 0x37, 0x65, 0x63, 0x30, 0x32, 0x35, 0x31, 0x62, 0x39, 0x64, 0x62, 0x30, 0x65, 0x63, 0x66, 0x61, 0x30, 0x66, 0x61, 0x30, 0x33, 0x32, 0x38, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x32, 0x65, 0x37, 0x63, 0x63, 0x34, 0x36, 0x66, 0x31, 0x64, 0x37, 0x62, 0x34, 0x65, 0x36, 0x65, 0x39, 0x64, 0x39, 0x35, 0x38, 0x36, 0x38, 0x62, 0x66, 0x64, 0x33, 0x37, 0x30, 0x35, 0x37, 0x33, 0x31, 0x37, 0x38, 0x66, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x36, 0x37, 0x66, 0x35, 0x38, 0x36, 0x38, 0x64, 0x63, 0x66, 0x34, 0x32, 0x33, 0x33, 0x61, 0x37, 0x38, 0x33, 0x30, 0x36, 0x30, 0x39, 0x36, 0x38, 0x32, 0x63, 0x61, 0x66, 0x32, 0x64, 0x66, 0x34, 0x62, 0x31, 0x62, 0x38, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x39, 0x36, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x38, 0x32, 0x66, 0x35, 0x30, 0x64, 0x30, 0x36, 0x34, 0x37, 0x35, 0x66, 0x36, 0x38, 0x34, 0x64, 0x66, 0x31, 0x62, 0x33, 0x39, 0x32, 0x65, 0x30, 0x30, 0x64, 0x61, 0x33, 0x34, 0x31, 0x61, 0x61, 0x31, 0x34, 0x35, 0x34, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x36, 0x38, 0x65, 0x65, 0x35, 0x61, 0x33, 0x37, 0x38, 0x66, 0x38, 0x63, 0x61, 0x64, 0x62, 0x33, 0x62, 0x61, 0x66, 0x64, 0x62, 0x65, 0x64, 0x31, 0x64, 0x31, 0x39, 0x61, 0x61, 0x61, 0x63, 0x66, 0x39, 0x33, 0x36, 0x37, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x38, 0x36, 0x36, 0x31, 0x33, 0x65, 0x36, 0x63, 0x34, 0x61, 0x34, 0x63, 0x39, 0x63, 0x35, 0x35, 0x66, 0x35, 0x63, 0x31, 0x30, 0x62, 0x63, 0x64, 0x61, 0x33, 0x32, 0x31, 0x37, 0x35, 0x64, 0x63, 0x62, 0x62, 0x34, 0x61, 0x66, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x39, 0x36, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x63, 0x64, 0x31, 0x32, 0x33, 0x39, 0x39, 0x32, 0x31, 0x39, 0x34, 0x62, 0x33, 0x34, 0x63, 0x34, 0x37, 0x38, 0x31, 0x33, 0x31, 0x34, 0x33, 0x30, 0x33, 0x62, 0x30, 0x33, 0x63, 0x35, 0x34, 0x39, 0x34, 0x38, 0x66, 0x34, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x30, 0x34, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x66, 0x30, 0x35, 0x38, 0x64, 0x34, 0x36, 0x31, 0x34, 0x37, 0x65, 0x39, 0x30, 0x30, 0x36, 0x64, 0x32, 0x39, 0x62, 0x66, 0x32, 0x63, 0x30, 0x39, 0x33, 0x30, 0x34, 0x61, 0x64, 0x31, 0x63, 0x64, 0x64, 0x64, 0x36, 0x65, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x30, 0x32, 0x32, 0x36, 0x65, 0x66, 0x65, 0x37, 0x62, 0x35, 0x33, 0x61, 0x38, 0x61, 0x66, 0x34, 0x36, 0x32, 0x64, 0x31, 0x31, 0x37, 0x61, 0x30, 0x31, 0x30, 0x38, 0x30, 0x38, 0x39, 0x62, 0x64, 0x65, 0x63, 0x63, 0x32, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x36, 0x32, 0x39, 0x32, 0x61, 0x31, 0x39, 0x31, 0x62, 0x64, 0x64, 0x61, 0x33, 0x34, 0x63, 0x34, 0x64, 0x61, 0x36, 0x62, 0x36, 0x62, 0x64, 0x36, 0x39, 0x31, 0x34, 0x37, 0x62, 0x66, 0x37, 0x35, 0x65, 0x32, 0x61, 0x39, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x62, 0x38, 0x61, 0x61, 0x30, 0x31, 0x36, 0x30, 0x63, 0x64, 0x37, 0x39, 0x66, 0x30, 0x30, 0x35, 0x66, 0x38, 0x38, 0x35, 0x31, 0x30, 0x61, 0x37, 0x31, 0x34, 0x39, 0x31, 0x33, 0x64, 0x37, 0x30, 0x61, 0x64, 0x33, 0x62, 0x65, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x62, 0x32, 0x66, 0x66, 0x33, 0x62, 0x61, 0x65, 0x31, 0x39, 0x39, 0x33, 0x66, 0x66, 0x65, 0x61, 0x34, 0x64, 0x33, 0x62, 0x31, 0x38, 0x30, 0x32, 0x33, 0x31, 0x64, 0x61, 0x34, 0x33, 0x39, 0x66, 0x37, 0x35, 0x30, 0x32, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x30, 0x38, 0x61, 0x61, 0x39, 0x39, 0x38, 0x33, 0x35, 0x33, 0x30, 0x37, 0x65, 0x65, 0x61, 0x34, 0x61, 0x36, 0x63, 0x35, 0x65, 0x62, 0x38, 0x30, 0x31, 0x66, 0x65, 0x36, 0x39, 0x34, 0x31, 0x31, 0x37, 0x66, 0x37, 0x30, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x30, 0x61, 0x35, 0x35, 0x66, 0x32, 0x64, 0x66, 0x39, 0x39, 0x36, 0x64, 0x63, 0x33, 0x61, 0x65, 0x64, 0x62, 0x36, 0x39, 0x36, 0x63, 0x30, 0x38, 0x64, 0x64, 0x65, 0x30, 0x33, 0x39, 0x62, 0x32, 0x36, 0x34, 0x31, 0x64, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x64, 0x66, 0x33, 0x63, 0x33, 0x65, 0x37, 0x39, 0x35, 0x35, 0x66, 0x34, 0x66, 0x32, 0x64, 0x38, 0x35, 0x39, 0x38, 0x33, 0x31, 0x62, 0x65, 0x33, 0x38, 0x30, 0x30, 0x30, 0x62, 0x31, 0x30, 0x37, 0x36, 0x62, 0x33, 0x38, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x32, 0x32, 0x38, 0x61, 0x64, 0x65, 0x39, 0x35, 0x65, 0x38, 0x62, 0x62, 0x31, 0x37, 0x64, 0x31, 0x61, 0x65, 0x32, 0x33, 0x62, 0x66, 0x62, 0x30, 0x35, 0x31, 0x38, 0x34, 0x31, 0x34, 0x64, 0x34, 0x39, 0x37, 0x65, 0x30, 0x65, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x34, 0x36, 0x63, 0x38, 0x31, 0x64, 0x62, 0x37, 0x38, 0x30, 0x63, 0x31, 0x36, 0x37, 0x34, 0x61, 0x63, 0x37, 0x33, 0x64, 0x33, 0x31, 0x34, 0x66, 0x30, 0x36, 0x35, 0x33, 0x39, 0x65, 0x65, 0x35, 0x36, 0x65, 0x62, 0x63, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x32, 0x64, 0x36, 0x66, 0x33, 0x30, 0x64, 0x61, 0x62, 0x39, 0x39, 0x31, 0x33, 0x35, 0x65, 0x34, 0x65, 0x63, 0x61, 0x35, 0x31, 0x64, 0x35, 0x32, 0x34, 0x33, 0x64, 0x36, 0x63, 0x38, 0x36, 0x32, 0x31, 0x31, 0x30, 0x32, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x61, 0x30, 0x64, 0x39, 0x65, 0x38, 0x39, 0x36, 0x30, 0x31, 0x37, 0x37, 0x32, 0x62, 0x34, 0x39, 0x36, 0x38, 0x34, 0x37, 0x61, 0x32, 0x62, 0x62, 0x34, 0x33, 0x34, 0x30, 0x31, 0x38, 0x36, 0x37, 0x38, 0x37, 0x64, 0x32, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x37, 0x34, 0x37, 0x35, 0x37, 0x36, 0x34, 0x34, 0x36, 0x61, 0x34, 0x63, 0x38, 0x66, 0x33, 0x30, 0x62, 0x30, 0x38, 0x33, 0x34, 0x30, 0x66, 0x65, 0x65, 0x31, 0x39, 0x38, 0x64, 0x65, 0x36, 0x33, 0x65, 0x63, 0x39, 0x32, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x63, 0x33, 0x31, 0x66, 0x65, 0x37, 0x34, 0x38, 0x35, 0x38, 0x33, 0x37, 0x38, 0x37, 0x63, 0x64, 0x64, 0x33, 0x65, 0x35, 0x32, 0x35, 0x62, 0x32, 0x38, 0x31, 0x62, 0x32, 0x31, 0x38, 0x39, 0x36, 0x31, 0x37, 0x33, 0x39, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x31, 0x30, 0x66, 0x38, 0x30, 0x62, 0x64, 0x62, 0x38, 0x32, 0x36, 0x63, 0x31, 0x37, 0x35, 0x34, 0x36, 0x32, 0x61, 0x62, 0x30, 0x37, 0x31, 0x36, 0x65, 0x36, 0x39, 0x65, 0x34, 0x36, 0x63, 0x32, 0x34, 0x61, 0x64, 0x30, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x37, 0x35, 0x61, 0x65, 0x36, 0x31, 0x63, 0x63, 0x31, 0x64, 0x38, 0x30, 0x34, 0x32, 0x36, 0x35, 0x33, 0x62, 0x35, 0x62, 0x61, 0x65, 0x63, 0x34, 0x34, 0x34, 0x33, 0x65, 0x30, 0x35, 0x31, 0x63, 0x35, 0x65, 0x37, 0x61, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x34, 0x38, 0x39, 0x32, 0x39, 0x30, 0x37, 0x61, 0x30, 0x37, 0x32, 0x30, 0x64, 0x66, 0x36, 0x66, 0x64, 0x33, 0x34, 0x31, 0x33, 0x65, 0x36, 0x33, 0x66, 0x66, 0x37, 0x36, 0x37, 0x64, 0x36, 0x62, 0x33, 0x39, 0x38, 0x30, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x31, 0x38, 0x39, 0x34, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x66, 0x31, 0x34, 0x36, 0x33, 0x32, 0x61, 0x37, 0x65, 0x32, 0x38, 0x32, 0x30, 0x62, 0x65, 0x36, 0x65, 0x38, 0x66, 0x36, 0x64, 0x66, 0x38, 0x32, 0x33, 0x35, 0x35, 0x38, 0x32, 0x38, 0x33, 0x64, 0x61, 0x64, 0x61, 0x62, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x63, 0x37, 0x66, 0x37, 0x64, 0x61, 0x64, 0x38, 0x35, 0x64, 0x66, 0x35, 0x33, 0x66, 0x31, 0x32, 0x37, 0x31, 0x31, 0x35, 0x32, 0x34, 0x30, 0x33, 0x66, 0x34, 0x65, 0x31, 0x65, 0x34, 0x66, 0x64, 0x62, 0x33, 0x61, 0x66, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x33, 0x30, 0x66, 0x65, 0x61, 0x63, 0x33, 0x37, 0x61, 0x63, 0x39, 0x66, 0x37, 0x32, 0x64, 0x37, 0x62, 0x34, 0x61, 0x66, 0x30, 0x66, 0x32, 0x62, 0x63, 0x37, 0x33, 0x39, 0x35, 0x32, 0x63, 0x37, 0x34, 0x66, 0x64, 0x35, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x36, 0x64, 0x34, 0x62, 0x36, 0x36, 0x32, 0x62, 0x62, 0x64, 0x31, 0x30, 0x38, 0x30, 0x63, 0x66, 0x65, 0x34, 0x34, 0x34, 0x35, 0x62, 0x30, 0x66, 0x61, 0x32, 0x31, 0x33, 0x38, 0x36, 0x34, 0x34, 0x33, 0x35, 0x62, 0x37, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x65, 0x63, 0x38, 0x31, 0x64, 0x64, 0x31, 0x32, 0x33, 0x64, 0x34, 0x62, 0x37, 0x63, 0x32, 0x64, 0x64, 0x39, 0x62, 0x34, 0x64, 0x34, 0x33, 0x38, 0x61, 0x37, 0x30, 0x37, 0x32, 0x63, 0x31, 0x31, 0x64, 0x63, 0x38, 0x37, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x66, 0x39, 0x35, 0x37, 0x35, 0x62, 0x65, 0x35, 0x37, 0x64, 0x30, 0x30, 0x34, 0x37, 0x39, 0x33, 0x63, 0x37, 0x61, 0x34, 0x65, 0x62, 0x38, 0x34, 0x62, 0x37, 0x31, 0x35, 0x38, 0x37, 0x66, 0x39, 0x37, 0x63, 0x62, 0x62, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x34, 0x62, 0x34, 0x37, 0x30, 0x33, 0x30, 0x37, 0x61, 0x30, 0x35, 0x39, 0x38, 0x35, 0x34, 0x30, 0x35, 0x35, 0x64, 0x39, 0x31, 0x65, 0x63, 0x33, 0x37, 0x39, 0x34, 0x64, 0x38, 0x30, 0x62, 0x35, 0x33, 0x64, 0x30, 0x66, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x66, 0x36, 0x63, 0x37, 0x65, 0x65, 0x39, 0x39, 0x64, 0x66, 0x32, 0x37, 0x31, 0x62, 0x61, 0x31, 0x35, 0x62, 0x66, 0x33, 0x38, 0x34, 0x63, 0x30, 0x62, 0x37, 0x36, 0x34, 0x61, 0x64, 0x63, 0x62, 0x34, 0x64, 0x61, 0x31, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x61, 0x65, 0x33, 0x65, 0x65, 0x35, 0x62, 0x39, 0x31, 0x35, 0x62, 0x33, 0x36, 0x34, 0x38, 0x37, 0x66, 0x39, 0x31, 0x36, 0x31, 0x66, 0x31, 0x39, 0x38, 0x34, 0x36, 0x64, 0x31, 0x30, 0x31, 0x34, 0x33, 0x33, 0x33, 0x31, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x63, 0x66, 0x39, 0x64, 0x38, 0x63, 0x39, 0x38, 0x30, 0x34, 0x34, 0x35, 0x39, 0x66, 0x36, 0x34, 0x37, 0x63, 0x31, 0x34, 0x31, 0x33, 0x38, 0x65, 0x64, 0x35, 0x30, 0x66, 0x61, 0x64, 0x35, 0x36, 0x33, 0x62, 0x34, 0x31, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x61, 0x38, 0x63, 0x38, 0x35, 0x38, 0x64, 0x66, 0x31, 0x30, 0x32, 0x63, 0x62, 0x31, 0x32, 0x34, 0x32, 0x31, 0x30, 0x30, 0x38, 0x62, 0x30, 0x61, 0x33, 0x31, 0x63, 0x34, 0x63, 0x37, 0x31, 0x39, 0x30, 0x61, 0x64, 0x35, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x66, 0x64, 0x30, 0x62, 0x66, 0x37, 0x63, 0x37, 0x32, 0x35, 0x65, 0x66, 0x33, 0x65, 0x30, 0x34, 0x37, 0x65, 0x35, 0x61, 0x65, 0x31, 0x63, 0x32, 0x39, 0x66, 0x65, 0x31, 0x38, 0x66, 0x31, 0x32, 0x61, 0x37, 0x32, 0x39, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x30, 0x61, 0x36, 0x31, 0x32, 0x62, 0x64, 0x36, 0x64, 0x64, 0x61, 0x39, 0x65, 0x61, 0x62, 0x30, 0x64, 0x64, 0x64, 0x63, 0x66, 0x66, 0x34, 0x61, 0x61, 0x66, 0x34, 0x31, 0x32, 0x32, 0x64, 0x33, 0x38, 0x66, 0x65, 0x61, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x37, 0x31, 0x33, 0x37, 0x61, 0x65, 0x30, 0x64, 0x31, 0x31, 0x36, 0x64, 0x30, 0x33, 0x33, 0x35, 0x33, 0x33, 0x63, 0x34, 0x65, 0x61, 0x62, 0x34, 0x39, 0x36, 0x66, 0x38, 0x61, 0x39, 0x66, 0x62, 0x30, 0x39, 0x35, 0x36, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x34, 0x39, 0x66, 0x32, 0x30, 0x37, 0x32, 0x36, 0x34, 0x37, 0x31, 0x61, 0x63, 0x31, 0x63, 0x37, 0x61, 0x38, 0x33, 0x65, 0x66, 0x31, 0x30, 0x36, 0x65, 0x39, 0x37, 0x37, 0x35, 0x63, 0x65, 0x62, 0x36, 0x36, 0x32, 0x35, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x37, 0x30, 0x36, 0x36, 0x35, 0x35, 0x65, 0x32, 0x38, 0x34, 0x64, 0x63, 0x66, 0x30, 0x62, 0x62, 0x33, 0x37, 0x66, 0x65, 0x30, 0x37, 0x35, 0x64, 0x36, 0x31, 0x33, 0x61, 0x31, 0x38, 0x64, 0x63, 0x31, 0x32, 0x66, 0x66, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x37, 0x36, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x61, 0x66, 0x37, 0x61, 0x64, 0x39, 0x64, 0x35, 0x32, 0x32, 0x33, 0x63, 0x66, 0x37, 0x63, 0x38, 0x63, 0x31, 0x33, 0x66, 0x32, 0x30, 0x64, 0x66, 0x36, 0x37, 0x65, 0x62, 0x65, 0x35, 0x66, 0x66, 0x63, 0x35, 0x62, 0x62, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x38, 0x32, 0x34, 0x32, 0x66, 0x38, 0x33, 0x33, 0x36, 0x65, 0x65, 0x63, 0x64, 0x38, 0x32, 0x34, 0x32, 0x65, 0x31, 0x66, 0x30, 0x30, 0x30, 0x66, 0x34, 0x31, 0x39, 0x33, 0x37, 0x65, 0x37, 0x31, 0x64, 0x66, 0x66, 0x62, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x65, 0x64, 0x35, 0x31, 0x62, 0x62, 0x62, 0x33, 0x61, 0x63, 0x65, 0x36, 0x39, 0x65, 0x30, 0x36, 0x30, 0x32, 0x34, 0x62, 0x33, 0x33, 0x66, 0x38, 0x36, 0x38, 0x34, 0x34, 0x63, 0x34, 0x37, 0x33, 0x34, 0x38, 0x64, 0x62, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x35, 0x31, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x35, 0x36, 0x36, 0x61, 0x38, 0x61, 0x66, 0x61, 0x64, 0x31, 0x39, 0x36, 0x38, 0x32, 0x64, 0x63, 0x32, 0x63, 0x65, 0x38, 0x36, 0x37, 0x39, 0x61, 0x33, 0x63, 0x65, 0x34, 0x34, 0x34, 0x61, 0x35, 0x62, 0x30, 0x66, 0x64, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x37, 0x33, 0x38, 0x66, 0x62, 0x32, 0x31, 0x37, 0x63, 0x65, 0x61, 0x64, 0x32, 0x66, 0x36, 0x39, 0x35, 0x39, 0x34, 0x63, 0x30, 0x38, 0x31, 0x37, 0x30, 0x64, 0x65, 0x31, 0x61, 0x66, 0x31, 0x30, 0x63, 0x34, 0x31, 0x39, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x30, 0x33, 0x32, 0x34, 0x34, 0x36, 0x65, 0x37, 0x64, 0x36, 0x31, 0x30, 0x61, 0x61, 0x30, 0x30, 0x65, 0x63, 0x38, 0x63, 0x35, 0x36, 0x63, 0x39, 0x62, 0x35, 0x37, 0x34, 0x64, 0x33, 0x36, 0x63, 0x61, 0x31, 0x63, 0x30, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x61, 0x36, 0x61, 0x31, 0x33, 0x32, 0x63, 0x65, 0x31, 0x63, 0x64, 0x32, 0x38, 0x38, 0x62, 0x65, 0x65, 0x33, 0x30, 0x65, 0x63, 0x37, 0x63, 0x66, 0x65, 0x66, 0x66, 0x62, 0x38, 0x35, 0x63, 0x31, 0x66, 0x35, 0x30, 0x61, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x35, 0x66, 0x32, 0x36, 0x64, 0x64, 0x30, 0x65, 0x37, 0x32, 0x64, 0x39, 0x63, 0x32, 0x39, 0x65, 0x62, 0x61, 0x66, 0x36, 0x39, 0x37, 0x61, 0x38, 0x61, 0x66, 0x37, 0x37, 0x34, 0x37, 0x32, 0x63, 0x32, 0x62, 0x35, 0x38, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x35, 0x62, 0x64, 0x30, 0x32, 0x63, 0x61, 0x66, 0x31, 0x39, 0x64, 0x36, 0x32, 0x30, 0x32, 0x62, 0x62, 0x63, 0x64, 0x63, 0x38, 0x33, 0x36, 0x64, 0x31, 0x38, 0x37, 0x62, 0x64, 0x31, 0x63, 0x30, 0x31, 0x63, 0x66, 0x32, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x33, 0x32, 0x32, 0x65, 0x36, 0x31, 0x31, 0x66, 0x64, 0x62, 0x38, 0x32, 0x30, 0x64, 0x34, 0x37, 0x63, 0x36, 0x66, 0x38, 0x66, 0x63, 0x36, 0x34, 0x62, 0x36, 0x66, 0x61, 0x64, 0x37, 0x34, 0x63, 0x61, 0x39, 0x35, 0x66, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x32, 0x35, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x61, 0x64, 0x64, 0x66, 0x35, 0x32, 0x65, 0x66, 0x62, 0x64, 0x37, 0x34, 0x64, 0x61, 0x39, 0x35, 0x62, 0x39, 0x36, 0x39, 0x61, 0x35, 0x34, 0x37, 0x36, 0x66, 0x34, 0x66, 0x62, 0x62, 0x62, 0x35, 0x36, 0x33, 0x62, 0x66, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x33, 0x61, 0x63, 0x34, 0x31, 0x37, 0x39, 0x39, 0x32, 0x65, 0x39, 0x66, 0x39, 0x62, 0x36, 0x30, 0x33, 0x38, 0x36, 0x65, 0x64, 0x39, 0x35, 0x33, 0x65, 0x36, 0x64, 0x37, 0x64, 0x66, 0x66, 0x32, 0x62, 0x30, 0x39, 0x30, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x66, 0x30, 0x33, 0x63, 0x66, 0x31, 0x61, 0x62, 0x63, 0x35, 0x65, 0x31, 0x62, 0x35, 0x31, 0x64, 0x62, 0x63, 0x34, 0x34, 0x34, 0x62, 0x32, 0x38, 0x39, 0x65, 0x35, 0x34, 0x32, 0x63, 0x39, 0x64, 0x64, 0x66, 0x62, 0x30, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x66, 0x34, 0x62, 0x61, 0x65, 0x36, 0x66, 0x38, 0x34, 0x64, 0x39, 0x31, 0x30, 0x64, 0x36, 0x64, 0x37, 0x64, 0x35, 0x61, 0x63, 0x39, 0x31, 0x34, 0x62, 0x31, 0x65, 0x36, 0x38, 0x33, 0x37, 0x32, 0x66, 0x39, 0x34, 0x31, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x38, 0x33, 0x61, 0x32, 0x39, 0x33, 0x63, 0x33, 0x32, 0x34, 0x64, 0x34, 0x31, 0x30, 0x36, 0x63, 0x31, 0x38, 0x66, 0x61, 0x61, 0x38, 0x38, 0x38, 0x38, 0x66, 0x36, 0x34, 0x64, 0x32, 0x39, 0x39, 0x30, 0x35, 0x34, 0x63, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x65, 0x65, 0x34, 0x66, 0x65, 0x30, 0x30, 0x66, 0x62, 0x63, 0x65, 0x64, 0x36, 0x34, 0x37, 0x30, 0x36, 0x38, 0x64, 0x34, 0x66, 0x35, 0x37, 0x63, 0x30, 0x31, 0x63, 0x62, 0x32, 0x32, 0x61, 0x38, 0x30, 0x62, 0x63, 0x63, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x34, 0x31, 0x30, 0x30, 0x64, 0x62, 0x34, 0x63, 0x35, 0x64, 0x30, 0x65, 0x65, 0x63, 0x35, 0x35, 0x37, 0x38, 0x32, 0x33, 0x62, 0x35, 0x38, 0x33, 0x34, 0x33, 0x37, 0x35, 0x38, 0x62, 0x63, 0x63, 0x32, 0x63, 0x38, 0x30, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x37, 0x35, 0x31, 0x64, 0x63, 0x36, 0x38, 0x63, 0x62, 0x35, 0x62, 0x64, 0x37, 0x33, 0x37, 0x30, 0x32, 0x37, 0x61, 0x62, 0x66, 0x37, 0x64, 0x64, 0x62, 0x37, 0x37, 0x33, 0x39, 0x30, 0x63, 0x64, 0x37, 0x37, 0x63, 0x31, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x30, 0x33, 0x30, 0x32, 0x66, 0x61, 0x61, 0x31, 0x39, 0x32, 0x39, 0x61, 0x33, 0x32, 0x36, 0x39, 0x30, 0x34, 0x64, 0x33, 0x37, 0x36, 0x62, 0x66, 0x30, 0x62, 0x38, 0x64, 0x63, 0x39, 0x33, 0x61, 0x64, 0x30, 0x34, 0x63, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x34, 0x31, 0x39, 0x66, 0x64, 0x39, 0x39, 0x31, 0x32, 0x62, 0x38, 0x35, 0x31, 0x33, 0x35, 0x36, 0x35, 0x39, 0x65, 0x37, 0x37, 0x61, 0x39, 0x33, 0x62, 0x63, 0x33, 0x64, 0x66, 0x31, 0x38, 0x32, 0x64, 0x34, 0x35, 0x31, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x30, 0x39, 0x37, 0x31, 0x39, 0x38, 0x62, 0x34, 0x65, 0x37, 0x65, 0x65, 0x39, 0x31, 0x66, 0x66, 0x38, 0x32, 0x63, 0x63, 0x32, 0x66, 0x33, 0x62, 0x64, 0x39, 0x35, 0x66, 0x65, 0x64, 0x37, 0x33, 0x63, 0x35, 0x34, 0x30, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x32, 0x34, 0x64, 0x39, 0x65, 0x32, 0x32, 0x63, 0x65, 0x31, 0x64, 0x61, 0x33, 0x63, 0x65, 0x31, 0x39, 0x66, 0x32, 0x31, 0x39, 0x63, 0x63, 0x65, 0x65, 0x35, 0x32, 0x33, 0x33, 0x37, 0x36, 0x38, 0x37, 0x33, 0x66, 0x33, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x30, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x34, 0x65, 0x65, 0x31, 0x61, 0x65, 0x39, 0x39, 0x36, 0x61, 0x61, 0x30, 0x61, 0x31, 0x64, 0x39, 0x32, 0x34, 0x32, 0x38, 0x64, 0x30, 0x36, 0x36, 0x35, 0x32, 0x61, 0x36, 0x62, 0x65, 0x61, 0x36, 0x64, 0x32, 0x64, 0x31, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x61, 0x34, 0x31, 0x34, 0x39, 0x61, 0x32, 0x63, 0x37, 0x62, 0x31, 0x62, 0x33, 0x61, 0x36, 0x37, 0x65, 0x61, 0x32, 0x38, 0x61, 0x66, 0x66, 0x33, 0x34, 0x37, 0x32, 0x35, 0x65, 0x30, 0x62, 0x66, 0x38, 0x64, 0x37, 0x35, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x64, 0x36, 0x35, 0x32, 0x36, 0x32, 0x65, 0x64, 0x35, 0x64, 0x31, 0x32, 0x32, 0x64, 0x66, 0x32, 0x62, 0x32, 0x37, 0x35, 0x31, 0x34, 0x31, 0x30, 0x66, 0x39, 0x38, 0x63, 0x33, 0x32, 0x64, 0x31, 0x32, 0x33, 0x38, 0x66, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x30, 0x39, 0x35, 0x34, 0x64, 0x30, 0x66, 0x34, 0x31, 0x30, 0x38, 0x63, 0x38, 0x32, 0x64, 0x34, 0x64, 0x63, 0x62, 0x32, 0x31, 0x34, 0x38, 0x64, 0x32, 0x36, 0x62, 0x62, 0x64, 0x39, 0x32, 0x34, 0x66, 0x36, 0x64, 0x64, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x62, 0x37, 0x64, 0x32, 0x65, 0x31, 0x31, 0x62, 0x63, 0x36, 0x62, 0x35, 0x38, 0x66, 0x30, 0x61, 0x38, 0x64, 0x34, 0x35, 0x63, 0x32, 0x66, 0x36, 0x64, 0x65, 0x33, 0x30, 0x31, 0x30, 0x35, 0x37, 0x30, 0x61, 0x63, 0x38, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x31, 0x31, 0x35, 0x32, 0x35, 0x32, 0x62, 0x31, 0x62, 0x38, 0x34, 0x35, 0x63, 0x64, 0x38, 0x35, 0x37, 0x66, 0x30, 0x30, 0x32, 0x64, 0x36, 0x33, 0x30, 0x66, 0x31, 0x62, 0x36, 0x66, 0x61, 0x33, 0x37, 0x61, 0x34, 0x65, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x61, 0x38, 0x31, 0x38, 0x31, 0x33, 0x35, 0x61, 0x34, 0x31, 0x34, 0x32, 0x31, 0x30, 0x63, 0x33, 0x37, 0x63, 0x36, 0x32, 0x62, 0x36, 0x32, 0x35, 0x61, 0x63, 0x61, 0x31, 0x61, 0x35, 0x34, 0x36, 0x31, 0x31, 0x61, 0x63, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x31, 0x65, 0x61, 0x30, 0x63, 0x35, 0x39, 0x39, 0x61, 0x66, 0x62, 0x39, 0x63, 0x64, 0x33, 0x36, 0x63, 0x61, 0x61, 0x63, 0x62, 0x62, 0x62, 0x35, 0x32, 0x62, 0x35, 0x62, 0x62, 0x62, 0x39, 0x37, 0x35, 0x39, 0x37, 0x33, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x36, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x37, 0x61, 0x34, 0x66, 0x38, 0x30, 0x37, 0x33, 0x35, 0x37, 0x61, 0x34, 0x62, 0x62, 0x65, 0x36, 0x38, 0x65, 0x31, 0x61, 0x61, 0x38, 0x30, 0x36, 0x33, 0x39, 0x33, 0x32, 0x31, 0x30, 0x63, 0x34, 0x31, 0x31, 0x63, 0x63, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x34, 0x30, 0x63, 0x61, 0x32, 0x37, 0x38, 0x32, 0x36, 0x64, 0x39, 0x37, 0x37, 0x33, 0x31, 0x62, 0x33, 0x65, 0x38, 0x36, 0x65, 0x66, 0x66, 0x63, 0x64, 0x37, 0x62, 0x39, 0x32, 0x61, 0x34, 0x31, 0x36, 0x31, 0x66, 0x65, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x33, 0x31, 0x32, 0x37, 0x37, 0x64, 0x37, 0x62, 0x64, 0x64, 0x31, 0x30, 0x34, 0x35, 0x37, 0x64, 0x63, 0x30, 0x31, 0x37, 0x34, 0x30, 0x38, 0x63, 0x38, 0x64, 0x62, 0x62, 0x62, 0x64, 0x34, 0x31, 0x34, 0x61, 0x38, 0x64, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x62, 0x38, 0x31, 0x64, 0x35, 0x39, 0x38, 0x31, 0x31, 0x34, 0x31, 0x65, 0x63, 0x37, 0x61, 0x37, 0x31, 0x34, 0x31, 0x30, 0x36, 0x30, 0x64, 0x66, 0x63, 0x66, 0x38, 0x66, 0x33, 0x35, 0x39, 0x39, 0x66, 0x66, 0x63, 0x36, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x36, 0x38, 0x38, 0x34, 0x31, 0x30, 0x66, 0x66, 0x32, 0x35, 0x64, 0x36, 0x35, 0x34, 0x64, 0x37, 0x32, 0x65, 0x62, 0x32, 0x62, 0x63, 0x30, 0x36, 0x65, 0x34, 0x61, 0x64, 0x32, 0x34, 0x66, 0x38, 0x33, 0x33, 0x62, 0x30, 0x39, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x31, 0x30, 0x31, 0x32, 0x30, 0x35, 0x62, 0x33, 0x32, 0x33, 0x64, 0x37, 0x37, 0x35, 0x34, 0x34, 0x64, 0x36, 0x64, 0x63, 0x35, 0x32, 0x61, 0x66, 0x33, 0x37, 0x61, 0x63, 0x61, 0x33, 0x63, 0x65, 0x63, 0x36, 0x66, 0x37, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x36, 0x38, 0x35, 0x63, 0x31, 0x35, 0x65, 0x34, 0x33, 0x39, 0x39, 0x36, 0x35, 0x65, 0x66, 0x36, 0x32, 0x36, 0x62, 0x66, 0x30, 0x64, 0x38, 0x33, 0x34, 0x63, 0x64, 0x31, 0x61, 0x38, 0x39, 0x66, 0x32, 0x62, 0x35, 0x36, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x37, 0x33, 0x37, 0x30, 0x36, 0x62, 0x31, 0x62, 0x30, 0x65, 0x34, 0x64, 0x63, 0x37, 0x61, 0x39, 0x34, 0x39, 0x61, 0x37, 0x61, 0x37, 0x39, 0x36, 0x32, 0x35, 0x38, 0x61, 0x35, 0x62, 0x38, 0x33, 0x62, 0x62, 0x35, 0x61, 0x61, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x64, 0x61, 0x66, 0x39, 0x33, 0x32, 0x32, 0x39, 0x62, 0x34, 0x35, 0x65, 0x65, 0x36, 0x37, 0x32, 0x66, 0x36, 0x35, 0x64, 0x62, 0x35, 0x30, 0x36, 0x66, 0x62, 0x35, 0x65, 0x63, 0x61, 0x30, 0x30, 0x66, 0x37, 0x66, 0x63, 0x65, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x35, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x36, 0x39, 0x30, 0x34, 0x62, 0x61, 0x65, 0x31, 0x66, 0x36, 0x39, 0x37, 0x39, 0x30, 0x35, 0x39, 0x31, 0x37, 0x30, 0x39, 0x62, 0x30, 0x36, 0x30, 0x39, 0x37, 0x38, 0x33, 0x37, 0x33, 0x33, 0x66, 0x32, 0x35, 0x37, 0x33, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x32, 0x65, 0x61, 0x37, 0x61, 0x33, 0x62, 0x32, 0x63, 0x38, 0x36, 0x65, 0x65, 0x64, 0x33, 0x32, 0x66, 0x66, 0x34, 0x66, 0x32, 0x63, 0x37, 0x33, 0x35, 0x31, 0x34, 0x63, 0x63, 0x36, 0x33, 0x62, 0x61, 0x63, 0x66, 0x62, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x36, 0x63, 0x30, 0x32, 0x32, 0x31, 0x30, 0x61, 0x34, 0x35, 0x30, 0x61, 0x62, 0x30, 0x62, 0x33, 0x36, 0x33, 0x37, 0x30, 0x36, 0x35, 0x35, 0x66, 0x37, 0x31, 0x37, 0x61, 0x61, 0x38, 0x37, 0x62, 0x64, 0x31, 0x63, 0x30, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x39, 0x34, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x36, 0x61, 0x63, 0x32, 0x35, 0x30, 0x37, 0x34, 0x30, 0x39, 0x63, 0x37, 0x61, 0x33, 0x38, 0x33, 0x61, 0x62, 0x32, 0x65, 0x65, 0x65, 0x31, 0x38, 0x32, 0x32, 0x61, 0x35, 0x64, 0x37, 0x33, 0x38, 0x62, 0x33, 0x36, 0x62, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x32, 0x66, 0x39, 0x63, 0x31, 0x39, 0x61, 0x63, 0x37, 0x36, 0x31, 0x33, 0x36, 0x35, 0x39, 0x34, 0x34, 0x33, 0x32, 0x33, 0x39, 0x33, 0x62, 0x30, 0x34, 0x37, 0x31, 0x64, 0x30, 0x38, 0x39, 0x30, 0x32, 0x31, 0x36, 0x34, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x33, 0x32, 0x39, 0x36, 0x32, 0x65, 0x61, 0x39, 0x39, 0x37, 0x30, 0x30, 0x64, 0x39, 0x33, 0x32, 0x32, 0x38, 0x65, 0x39, 0x64, 0x62, 0x64, 0x61, 0x64, 0x32, 0x63, 0x63, 0x33, 0x37, 0x62, 0x62, 0x39, 0x39, 0x66, 0x30, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x32, 0x37, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x65, 0x35, 0x38, 0x34, 0x65, 0x38, 0x31, 0x30, 0x65, 0x35, 0x36, 0x37, 0x37, 0x30, 0x32, 0x63, 0x36, 0x31, 0x64, 0x35, 0x35, 0x64, 0x34, 0x33, 0x34, 0x62, 0x33, 0x34, 0x63, 0x64, 0x62, 0x35, 0x65, 0x65, 0x33, 0x30, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x61, 0x39, 0x33, 0x65, 0x66, 0x39, 0x64, 0x62, 0x65, 0x61, 0x32, 0x36, 0x33, 0x36, 0x32, 0x36, 0x33, 0x64, 0x30, 0x36, 0x64, 0x38, 0x34, 0x39, 0x32, 0x66, 0x36, 0x61, 0x34, 0x31, 0x64, 0x65, 0x39, 0x30, 0x37, 0x63, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x35, 0x30, 0x31, 0x36, 0x65, 0x32, 0x34, 0x35, 0x37, 0x33, 0x38, 0x37, 0x39, 0x35, 0x36, 0x35, 0x36, 0x32, 0x35, 0x38, 0x37, 0x31, 0x31, 0x35, 0x61, 0x61, 0x38, 0x37, 0x35, 0x39, 0x64, 0x38, 0x36, 0x39, 0x35, 0x66, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x30, 0x31, 0x32, 0x39, 0x65, 0x61, 0x61, 0x37, 0x36, 0x36, 0x62, 0x35, 0x61, 0x32, 0x39, 0x66, 0x35, 0x62, 0x33, 0x61, 0x66, 0x32, 0x35, 0x37, 0x34, 0x65, 0x34, 0x34, 0x30, 0x39, 0x66, 0x38, 0x66, 0x36, 0x64, 0x33, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x32, 0x35, 0x39, 0x36, 0x35, 0x64, 0x32, 0x62, 0x38, 0x38, 0x64, 0x61, 0x31, 0x39, 0x37, 0x64, 0x34, 0x34, 0x35, 0x39, 0x62, 0x65, 0x33, 0x64, 0x63, 0x39, 0x33, 0x38, 0x36, 0x33, 0x34, 0x34, 0x63, 0x63, 0x31, 0x66, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x38, 0x62, 0x64, 0x63, 0x64, 0x61, 0x65, 0x37, 0x39, 0x34, 0x66, 0x63, 0x34, 0x34, 0x30, 0x38, 0x32, 0x65, 0x36, 0x36, 0x37, 0x35, 0x30, 0x31, 0x33, 0x34, 0x34, 0x31, 0x31, 0x38, 0x65, 0x61, 0x39, 0x36, 0x63, 0x64, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x65, 0x39, 0x64, 0x30, 0x35, 0x32, 0x36, 0x65, 0x64, 0x61, 0x30, 0x31, 0x65, 0x34, 0x33, 0x31, 0x31, 0x36, 0x61, 0x33, 0x39, 0x35, 0x33, 0x32, 0x32, 0x64, 0x64, 0x61, 0x38, 0x39, 0x37, 0x30, 0x35, 0x37, 0x38, 0x66, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x63, 0x38, 0x39, 0x62, 0x33, 0x39, 0x66, 0x39, 0x66, 0x35, 0x32, 0x37, 0x36, 0x61, 0x35, 0x35, 0x33, 0x65, 0x38, 0x64, 0x61, 0x33, 0x30, 0x65, 0x36, 0x65, 0x63, 0x31, 0x37, 0x61, 0x61, 0x34, 0x37, 0x65, 0x65, 0x66, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x32, 0x33, 0x36, 0x36, 0x36, 0x36, 0x62, 0x32, 0x64, 0x30, 0x36, 0x65, 0x36, 0x33, 0x65, 0x61, 0x34, 0x65, 0x32, 0x61, 0x62, 0x38, 0x34, 0x33, 0x35, 0x37, 0x65, 0x32, 0x64, 0x66, 0x63, 0x39, 0x37, 0x37, 0x65, 0x35, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x64, 0x66, 0x39, 0x34, 0x37, 0x63, 0x34, 0x39, 0x35, 0x62, 0x65, 0x62, 0x61, 0x65, 0x62, 0x38, 0x65, 0x38, 0x38, 0x39, 0x62, 0x33, 0x66, 0x39, 0x35, 0x33, 0x64, 0x35, 0x33, 0x33, 0x38, 0x37, 0x34, 0x62, 0x66, 0x31, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x30, 0x65, 0x64, 0x36, 0x36, 0x61, 0x62, 0x33, 0x63, 0x65, 0x66, 0x66, 0x32, 0x34, 0x63, 0x61, 0x30, 0x35, 0x65, 0x63, 0x64, 0x34, 0x37, 0x31, 0x65, 0x66, 0x62, 0x34, 0x39, 0x32, 0x63, 0x31, 0x35, 0x66, 0x35, 0x66, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x63, 0x37, 0x30, 0x64, 0x30, 0x64, 0x36, 0x64, 0x61, 0x62, 0x37, 0x36, 0x36, 0x33, 0x61, 0x61, 0x39, 0x65, 0x64, 0x39, 0x63, 0x65, 0x65, 0x61, 0x35, 0x36, 0x37, 0x65, 0x65, 0x32, 0x63, 0x36, 0x62, 0x30, 0x32, 0x37, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x38, 0x39, 0x33, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x38, 0x39, 0x36, 0x37, 0x36, 0x64, 0x31, 0x35, 0x61, 0x30, 0x34, 0x34, 0x34, 0x38, 0x33, 0x34, 0x34, 0x32, 0x33, 0x30, 0x64, 0x34, 0x66, 0x66, 0x32, 0x37, 0x63, 0x39, 0x35, 0x65, 0x64, 0x66, 0x31, 0x32, 0x32, 0x63, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x33, 0x34, 0x37, 0x66, 0x30, 0x61, 0x39, 0x38, 0x37, 0x37, 0x36, 0x33, 0x39, 0x30, 0x31, 0x36, 0x35, 0x63, 0x31, 0x36, 0x36, 0x64, 0x33, 0x32, 0x39, 0x36, 0x33, 0x62, 0x66, 0x37, 0x34, 0x64, 0x63, 0x64, 0x30, 0x61, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x37, 0x64, 0x38, 0x36, 0x38, 0x35, 0x66, 0x61, 0x65, 0x65, 0x31, 0x34, 0x37, 0x63, 0x35, 0x32, 0x30, 0x66, 0x64, 0x39, 0x38, 0x36, 0x37, 0x30, 0x39, 0x31, 0x37, 0x35, 0x62, 0x66, 0x32, 0x66, 0x38, 0x38, 0x36, 0x62, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x64, 0x63, 0x64, 0x30, 0x65, 0x35, 0x62, 0x30, 0x35, 0x61, 0x39, 0x37, 0x37, 0x63, 0x39, 0x36, 0x32, 0x33, 0x65, 0x35, 0x61, 0x65, 0x32, 0x66, 0x35, 0x39, 0x62, 0x39, 0x61, 0x64, 0x61, 0x32, 0x66, 0x33, 0x33, 0x65, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x37, 0x39, 0x31, 0x39, 0x34, 0x65, 0x63, 0x39, 0x65, 0x39, 0x37, 0x64, 0x62, 0x39, 0x62, 0x65, 0x65, 0x38, 0x33, 0x34, 0x33, 0x62, 0x37, 0x63, 0x37, 0x37, 0x64, 0x39, 0x64, 0x37, 0x66, 0x33, 0x66, 0x31, 0x64, 0x63, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x64, 0x32, 0x30, 0x65, 0x63, 0x63, 0x62, 0x35, 0x31, 0x38, 0x62, 0x36, 0x30, 0x63, 0x61, 0x62, 0x30, 0x39, 0x35, 0x62, 0x37, 0x32, 0x30, 0x66, 0x35, 0x37, 0x31, 0x35, 0x37, 0x30, 0x63, 0x61, 0x61, 0x61, 0x34, 0x34, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x66, 0x38, 0x33, 0x30, 0x63, 0x66, 0x35, 0x35, 0x66, 0x62, 0x30, 0x30, 0x64, 0x35, 0x61, 0x30, 0x65, 0x30, 0x33, 0x35, 0x31, 0x34, 0x66, 0x65, 0x63, 0x64, 0x34, 0x34, 0x33, 0x31, 0x34, 0x62, 0x64, 0x36, 0x64, 0x39, 0x66, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x62, 0x32, 0x35, 0x63, 0x61, 0x37, 0x64, 0x31, 0x38, 0x38, 0x65, 0x37, 0x31, 0x65, 0x34, 0x64, 0x36, 0x39, 0x33, 0x64, 0x37, 0x62, 0x31, 0x37, 0x30, 0x37, 0x31, 0x37, 0x64, 0x36, 0x66, 0x38, 0x66, 0x30, 0x61, 0x37, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x36, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x61, 0x32, 0x62, 0x34, 0x39, 0x31, 0x34, 0x65, 0x38, 0x35, 0x35, 0x33, 0x62, 0x66, 0x30, 0x64, 0x37, 0x63, 0x30, 0x30, 0x63, 0x61, 0x35, 0x33, 0x32, 0x33, 0x36, 0x39, 0x62, 0x38, 0x37, 0x39, 0x66, 0x39, 0x33, 0x31, 0x62, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x30, 0x65, 0x36, 0x62, 0x32, 0x32, 0x62, 0x66, 0x34, 0x33, 0x30, 0x39, 0x36, 0x36, 0x66, 0x61, 0x33, 0x32, 0x62, 0x36, 0x61, 0x63, 0x62, 0x39, 0x61, 0x35, 0x30, 0x36, 0x65, 0x65, 0x62, 0x66, 0x36, 0x36, 0x32, 0x63, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x64, 0x65, 0x35, 0x64, 0x36, 0x36, 0x62, 0x39, 0x34, 0x34, 0x62, 0x62, 0x38, 0x36, 0x30, 0x63, 0x30, 0x65, 0x66, 0x64, 0x63, 0x38, 0x36, 0x32, 0x37, 0x36, 0x64, 0x35, 0x38, 0x66, 0x34, 0x36, 0x35, 0x33, 0x66, 0x37, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x61, 0x66, 0x66, 0x39, 0x66, 0x38, 0x66, 0x38, 0x31, 0x31, 0x33, 0x30, 0x36, 0x34, 0x64, 0x33, 0x39, 0x35, 0x37, 0x61, 0x63, 0x36, 0x64, 0x36, 0x65, 0x31, 0x31, 0x65, 0x65, 0x65, 0x34, 0x32, 0x63, 0x38, 0x31, 0x39, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x38, 0x66, 0x64, 0x37, 0x37, 0x37, 0x35, 0x65, 0x35, 0x34, 0x61, 0x36, 0x64, 0x39, 0x63, 0x39, 0x61, 0x33, 0x62, 0x66, 0x38, 0x39, 0x30, 0x65, 0x37, 0x36, 0x31, 0x66, 0x36, 0x35, 0x37, 0x37, 0x36, 0x39, 0x33, 0x66, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x30, 0x61, 0x35, 0x36, 0x64, 0x34, 0x31, 0x66, 0x36, 0x65, 0x39, 0x65, 0x66, 0x62, 0x64, 0x63, 0x65, 0x61, 0x30, 0x33, 0x34, 0x32, 0x65, 0x30, 0x62, 0x37, 0x39, 0x32, 0x39, 0x61, 0x38, 0x63, 0x64, 0x66, 0x63, 0x62, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x33, 0x65, 0x64, 0x32, 0x64, 0x39, 0x38, 0x35, 0x62, 0x35, 0x66, 0x32, 0x31, 0x62, 0x35, 0x35, 0x62, 0x32, 0x37, 0x34, 0x36, 0x34, 0x33, 0x62, 0x63, 0x36, 0x64, 0x61, 0x30, 0x33, 0x31, 0x64, 0x38, 0x65, 0x64, 0x64, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x31, 0x35, 0x36, 0x64, 0x31, 0x30, 0x65, 0x66, 0x61, 0x38, 0x62, 0x32, 0x33, 0x30, 0x63, 0x39, 0x39, 0x34, 0x31, 0x30, 0x36, 0x33, 0x30, 0x64, 0x33, 0x37, 0x65, 0x32, 0x36, 0x39, 0x64, 0x34, 0x30, 0x39, 0x33, 0x63, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x38, 0x39, 0x63, 0x32, 0x30, 0x30, 0x34, 0x34, 0x30, 0x62, 0x38, 0x37, 0x38, 0x39, 0x39, 0x31, 0x62, 0x36, 0x39, 0x64, 0x36, 0x30, 0x39, 0x35, 0x64, 0x66, 0x65, 0x36, 0x39, 0x65, 0x33, 0x33, 0x61, 0x32, 0x32, 0x65, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x38, 0x30, 0x31, 0x34, 0x65, 0x66, 0x63, 0x37, 0x63, 0x62, 0x65, 0x35, 0x62, 0x30, 0x63, 0x65, 0x35, 0x30, 0x66, 0x33, 0x35, 0x36, 0x32, 0x63, 0x66, 0x34, 0x65, 0x36, 0x37, 0x66, 0x38, 0x35, 0x39, 0x33, 0x63, 0x64, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x36, 0x31, 0x32, 0x64, 0x30, 0x37, 0x32, 0x34, 0x65, 0x38, 0x34, 0x65, 0x61, 0x34, 0x61, 0x37, 0x66, 0x65, 0x61, 0x61, 0x33, 0x64, 0x32, 0x31, 0x34, 0x32, 0x62, 0x64, 0x35, 0x65, 0x65, 0x38, 0x32, 0x64, 0x33, 0x32, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x38, 0x33, 0x32, 0x61, 0x39, 0x33, 0x64, 0x66, 0x39, 0x64, 0x37, 0x66, 0x37, 0x34, 0x63, 0x64, 0x30, 0x66, 0x62, 0x38, 0x35, 0x34, 0x36, 0x62, 0x37, 0x31, 0x39, 0x38, 0x62, 0x66, 0x35, 0x33, 0x37, 0x37, 0x64, 0x39, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x32, 0x63, 0x36, 0x37, 0x30, 0x30, 0x39, 0x36, 0x64, 0x33, 0x66, 0x39, 0x33, 0x39, 0x33, 0x30, 0x35, 0x33, 0x32, 0x35, 0x34, 0x32, 0x37, 0x65, 0x62, 0x39, 0x35, 0x35, 0x61, 0x38, 0x61, 0x36, 0x30, 0x64, 0x62, 0x33, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x32, 0x38, 0x37, 0x62, 0x38, 0x31, 0x35, 0x66, 0x35, 0x63, 0x38, 0x32, 0x33, 0x38, 0x30, 0x61, 0x37, 0x33, 0x62, 0x30, 0x62, 0x31, 0x33, 0x66, 0x62, 0x61, 0x66, 0x39, 0x38, 0x32, 0x62, 0x65, 0x32, 0x34, 0x63, 0x34, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x35, 0x63, 0x33, 0x62, 0x33, 0x38, 0x61, 0x35, 0x38, 0x61, 0x33, 0x66, 0x33, 0x33, 0x64, 0x35, 0x35, 0x36, 0x39, 0x30, 0x61, 0x35, 0x61, 0x35, 0x39, 0x37, 0x36, 0x36, 0x62, 0x65, 0x31, 0x38, 0x35, 0x65, 0x30, 0x32, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x39, 0x34, 0x30, 0x64, 0x63, 0x39, 0x33, 0x36, 0x34, 0x61, 0x38, 0x35, 0x32, 0x31, 0x36, 0x35, 0x66, 0x34, 0x37, 0x34, 0x31, 0x34, 0x65, 0x32, 0x37, 0x66, 0x35, 0x30, 0x30, 0x32, 0x34, 0x34, 0x35, 0x61, 0x34, 0x66, 0x31, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x62, 0x38, 0x32, 0x36, 0x31, 0x39, 0x36, 0x63, 0x30, 0x65, 0x31, 0x62, 0x63, 0x31, 0x31, 0x31, 0x39, 0x62, 0x30, 0x32, 0x31, 0x63, 0x66, 0x36, 0x64, 0x32, 0x35, 0x39, 0x61, 0x36, 0x31, 0x30, 0x63, 0x39, 0x39, 0x36, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x61, 0x31, 0x35, 0x63, 0x65, 0x66, 0x31, 0x64, 0x36, 0x63, 0x38, 0x32, 0x36, 0x30, 0x65, 0x61, 0x66, 0x31, 0x35, 0x39, 0x65, 0x61, 0x33, 0x66, 0x30, 0x31, 0x38, 0x30, 0x64, 0x38, 0x36, 0x37, 0x37, 0x64, 0x63, 0x65, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x30, 0x36, 0x30, 0x34, 0x34, 0x65, 0x32, 0x39, 0x33, 0x63, 0x36, 0x35, 0x32, 0x63, 0x34, 0x36, 0x37, 0x66, 0x65, 0x37, 0x34, 0x31, 0x34, 0x36, 0x62, 0x66, 0x31, 0x38, 0x35, 0x62, 0x32, 0x31, 0x33, 0x33, 0x38, 0x61, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x31, 0x35, 0x63, 0x31, 0x30, 0x61, 0x30, 0x33, 0x32, 0x64, 0x31, 0x33, 0x63, 0x33, 0x34, 0x62, 0x38, 0x39, 0x37, 0x36, 0x66, 0x61, 0x36, 0x65, 0x33, 0x62, 0x64, 0x32, 0x63, 0x39, 0x31, 0x33, 0x31, 0x61, 0x38, 0x62, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x39, 0x35, 0x66, 0x61, 0x34, 0x32, 0x33, 0x64, 0x36, 0x66, 0x63, 0x31, 0x32, 0x30, 0x32, 0x37, 0x34, 0x61, 0x61, 0x63, 0x64, 0x65, 0x31, 0x39, 0x66, 0x34, 0x65, 0x65, 0x62, 0x37, 0x36, 0x36, 0x66, 0x31, 0x30, 0x34, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x61, 0x34, 0x66, 0x38, 0x33, 0x63, 0x33, 0x39, 0x66, 0x38, 0x35, 0x61, 0x66, 0x39, 0x63, 0x38, 0x62, 0x31, 0x62, 0x33, 0x31, 0x32, 0x62, 0x66, 0x65, 0x35, 0x66, 0x63, 0x33, 0x34, 0x32, 0x33, 0x61, 0x66, 0x61, 0x36, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x38, 0x63, 0x65, 0x30, 0x64, 0x61, 0x61, 0x30, 0x32, 0x39, 0x62, 0x37, 0x64, 0x65, 0x64, 0x30, 0x32, 0x32, 0x65, 0x35, 0x66, 0x63, 0x35, 0x37, 0x34, 0x64, 0x31, 0x31, 0x63, 0x64, 0x65, 0x33, 0x65, 0x63, 0x62, 0x35, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x65, 0x63, 0x31, 0x38, 0x61, 0x37, 0x34, 0x65, 0x64, 0x34, 0x33, 0x38, 0x35, 0x35, 0x34, 0x30, 0x39, 0x61, 0x32, 0x36, 0x61, 0x64, 0x65, 0x37, 0x38, 0x33, 0x30, 0x64, 0x65, 0x38, 0x65, 0x34, 0x32, 0x36, 0x38, 0x35, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x62, 0x64, 0x62, 0x65, 0x64, 0x66, 0x39, 0x35, 0x39, 0x30, 0x38, 0x34, 0x37, 0x36, 0x64, 0x37, 0x31, 0x34, 0x38, 0x61, 0x33, 0x37, 0x30, 0x63, 0x63, 0x36, 0x39, 0x33, 0x37, 0x34, 0x33, 0x36, 0x32, 0x38, 0x30, 0x35, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x62, 0x38, 0x66, 0x66, 0x65, 0x34, 0x33, 0x66, 0x39, 0x38, 0x64, 0x65, 0x38, 0x65, 0x61, 0x65, 0x31, 0x38, 0x34, 0x36, 0x32, 0x33, 0x61, 0x65, 0x35, 0x32, 0x36, 0x34, 0x65, 0x34, 0x32, 0x34, 0x64, 0x30, 0x62, 0x38, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x30, 0x63, 0x65, 0x62, 0x65, 0x66, 0x32, 0x39, 0x32, 0x63, 0x33, 0x65, 0x62, 0x30, 0x38, 0x31, 0x61, 0x30, 0x35, 0x66, 0x64, 0x38, 0x61, 0x61, 0x66, 0x37, 0x64, 0x33, 0x39, 0x62, 0x66, 0x30, 0x37, 0x62, 0x38, 0x39, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x32, 0x61, 0x32, 0x33, 0x33, 0x61, 0x64, 0x65, 0x64, 0x65, 0x36, 0x36, 0x66, 0x65, 0x31, 0x31, 0x32, 0x36, 0x64, 0x36, 0x63, 0x31, 0x36, 0x38, 0x32, 0x33, 0x62, 0x36, 0x32, 0x61, 0x30, 0x32, 0x31, 0x66, 0x65, 0x64, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x63, 0x64, 0x36, 0x34, 0x65, 0x30, 0x32, 0x38, 0x34, 0x65, 0x65, 0x63, 0x35, 0x33, 0x61, 0x61, 0x34, 0x36, 0x33, 0x39, 0x61, 0x66, 0x63, 0x34, 0x37, 0x35, 0x30, 0x38, 0x31, 0x30, 0x62, 0x39, 0x37, 0x66, 0x61, 0x62, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x39, 0x35, 0x33, 0x66, 0x65, 0x61, 0x34, 0x39, 0x37, 0x31, 0x30, 0x34, 0x65, 0x66, 0x39, 0x61, 0x64, 0x32, 0x64, 0x34, 0x65, 0x35, 0x38, 0x34, 0x31, 0x63, 0x32, 0x37, 0x31, 0x66, 0x30, 0x37, 0x33, 0x35, 0x31, 0x39, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x37, 0x64, 0x34, 0x31, 0x34, 0x32, 0x61, 0x66, 0x37, 0x37, 0x30, 0x35, 0x31, 0x35, 0x64, 0x64, 0x37, 0x30, 0x36, 0x32, 0x61, 0x66, 0x39, 0x33, 0x34, 0x39, 0x38, 0x64, 0x62, 0x66, 0x64, 0x66, 0x66, 0x32, 0x39, 0x66, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x31, 0x39, 0x31, 0x61, 0x33, 0x35, 0x31, 0x35, 0x37, 0x64, 0x37, 0x38, 0x31, 0x33, 0x37, 0x33, 0x66, 0x62, 0x34, 0x31, 0x31, 0x62, 0x66, 0x39, 0x66, 0x32, 0x35, 0x32, 0x39, 0x30, 0x30, 0x34, 0x37, 0x63, 0x35, 0x65, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x36, 0x37, 0x64, 0x37, 0x62, 0x39, 0x62, 0x64, 0x62, 0x37, 0x62, 0x34, 0x61, 0x65, 0x64, 0x32, 0x32, 0x65, 0x36, 0x35, 0x61, 0x31, 0x35, 0x64, 0x63, 0x38, 0x30, 0x33, 0x63, 0x62, 0x37, 0x61, 0x32, 0x31, 0x33, 0x66, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x65, 0x34, 0x33, 0x66, 0x65, 0x30, 0x64, 0x32, 0x35, 0x63, 0x37, 0x38, 0x32, 0x38, 0x36, 0x30, 0x61, 0x66, 0x38, 0x31, 0x65, 0x61, 0x38, 0x39, 0x64, 0x64, 0x37, 0x39, 0x33, 0x63, 0x31, 0x33, 0x66, 0x30, 0x63, 0x62, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x38, 0x34, 0x37, 0x36, 0x36, 0x39, 0x31, 0x64, 0x33, 0x34, 0x39, 0x34, 0x32, 0x65, 0x65, 0x61, 0x36, 0x62, 0x32, 0x66, 0x37, 0x36, 0x38, 0x38, 0x39, 0x32, 0x32, 0x33, 0x30, 0x34, 0x37, 0x64, 0x62, 0x34, 0x36, 0x31, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x32, 0x31, 0x63, 0x63, 0x66, 0x32, 0x39, 0x37, 0x33, 0x39, 0x62, 0x39, 0x37, 0x34, 0x65, 0x35, 0x61, 0x35, 0x31, 0x36, 0x66, 0x31, 0x38, 0x66, 0x33, 0x61, 0x38, 0x34, 0x33, 0x36, 0x37, 0x31, 0x65, 0x33, 0x39, 0x36, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x64, 0x37, 0x31, 0x61, 0x36, 0x65, 0x62, 0x33, 0x64, 0x37, 0x66, 0x33, 0x32, 0x37, 0x65, 0x31, 0x38, 0x33, 0x34, 0x32, 0x37, 0x38, 0x65, 0x32, 0x38, 0x30, 0x62, 0x30, 0x33, 0x39, 0x65, 0x64, 0x64, 0x64, 0x33, 0x31, 0x63, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x32, 0x64, 0x31, 0x35, 0x61, 0x36, 0x39, 0x66, 0x36, 0x62, 0x62, 0x33, 0x33, 0x62, 0x32, 0x34, 0x36, 0x61, 0x65, 0x66, 0x34, 0x30, 0x34, 0x35, 0x30, 0x37, 0x35, 0x31, 0x63, 0x32, 0x66, 0x36, 0x37, 0x35, 0x36, 0x61, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x38, 0x39, 0x66, 0x32, 0x62, 0x36, 0x37, 0x38, 0x61, 0x31, 0x61, 0x31, 0x35, 0x62, 0x39, 0x31, 0x33, 0x34, 0x65, 0x63, 0x35, 0x65, 0x62, 0x37, 0x30, 0x63, 0x36, 0x61, 0x36, 0x32, 0x30, 0x37, 0x31, 0x66, 0x62, 0x61, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x62, 0x66, 0x39, 0x34, 0x33, 0x63, 0x31, 0x36, 0x33, 0x33, 0x66, 0x65, 0x33, 0x32, 0x66, 0x38, 0x62, 0x63, 0x63, 0x63, 0x64, 0x62, 0x36, 0x33, 0x30, 0x32, 0x62, 0x34, 0x30, 0x37, 0x61, 0x35, 0x37, 0x32, 0x34, 0x65, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x30, 0x32, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x61, 0x36, 0x63, 0x36, 0x66, 0x39, 0x65, 0x39, 0x63, 0x34, 0x62, 0x33, 0x38, 0x33, 0x64, 0x37, 0x31, 0x36, 0x62, 0x33, 0x31, 0x64, 0x65, 0x37, 0x38, 0x64, 0x35, 0x36, 0x34, 0x31, 0x34, 0x64, 0x65, 0x38, 0x66, 0x61, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x36, 0x31, 0x37, 0x35, 0x65, 0x63, 0x39, 0x62, 0x65, 0x66, 0x63, 0x37, 0x33, 0x38, 0x32, 0x34, 0x39, 0x35, 0x33, 0x35, 0x64, 0x64, 0x64, 0x65, 0x33, 0x34, 0x36, 0x38, 0x38, 0x63, 0x64, 0x33, 0x36, 0x65, 0x64, 0x66, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x63, 0x65, 0x37, 0x39, 0x39, 0x35, 0x30, 0x39, 0x33, 0x35, 0x63, 0x66, 0x66, 0x35, 0x35, 0x62, 0x66, 0x37, 0x38, 0x65, 0x34, 0x63, 0x63, 0x65, 0x63, 0x32, 0x66, 0x65, 0x36, 0x33, 0x31, 0x37, 0x38, 0x35, 0x64, 0x62, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x39, 0x38, 0x62, 0x33, 0x61, 0x37, 0x39, 0x61, 0x34, 0x38, 0x66, 0x33, 0x32, 0x62, 0x31, 0x66, 0x35, 0x66, 0x63, 0x39, 0x31, 0x35, 0x62, 0x38, 0x37, 0x62, 0x36, 0x34, 0x35, 0x64, 0x38, 0x30, 0x35, 0x64, 0x31, 0x61, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x34, 0x38, 0x38, 0x31, 0x31, 0x36, 0x35, 0x63, 0x62, 0x34, 0x32, 0x62, 0x62, 0x38, 0x32, 0x65, 0x39, 0x37, 0x33, 0x39, 0x36, 0x63, 0x38, 0x65, 0x66, 0x34, 0x34, 0x61, 0x64, 0x62, 0x66, 0x31, 0x37, 0x33, 0x66, 0x62, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x62, 0x30, 0x35, 0x33, 0x33, 0x62, 0x38, 0x31, 0x64, 0x30, 0x32, 0x61, 0x36, 0x31, 0x37, 0x62, 0x39, 0x32, 0x32, 0x39, 0x63, 0x37, 0x65, 0x63, 0x35, 0x64, 0x36, 0x66, 0x32, 0x66, 0x36, 0x37, 0x32, 0x65, 0x35, 0x62, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x35, 0x66, 0x30, 0x39, 0x37, 0x64, 0x39, 0x61, 0x63, 0x64, 0x64, 0x63, 0x64, 0x64, 0x61, 0x66, 0x61, 0x66, 0x32, 0x61, 0x31, 0x30, 0x37, 0x65, 0x62, 0x39, 0x33, 0x61, 0x34, 0x30, 0x66, 0x63, 0x39, 0x34, 0x62, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x34, 0x62, 0x35, 0x33, 0x64, 0x30, 0x62, 0x62, 0x31, 0x32, 0x35, 0x36, 0x35, 0x36, 0x63, 0x64, 0x64, 0x63, 0x35, 0x32, 0x65, 0x62, 0x38, 0x35, 0x32, 0x61, 0x62, 0x37, 0x31, 0x64, 0x37, 0x32, 0x35, 0x39, 0x66, 0x33, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x37, 0x39, 0x63, 0x37, 0x66, 0x34, 0x30, 0x33, 0x39, 0x63, 0x36, 0x37, 0x61, 0x33, 0x39, 0x64, 0x37, 0x35, 0x31, 0x33, 0x38, 0x38, 0x34, 0x63, 0x64, 0x63, 0x30, 0x65, 0x32, 0x63, 0x33, 0x34, 0x32, 0x32, 0x32, 0x34, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x36, 0x32, 0x30, 0x39, 0x62, 0x37, 0x66, 0x64, 0x61, 0x35, 0x34, 0x65, 0x38, 0x64, 0x64, 0x62, 0x39, 0x64, 0x39, 0x65, 0x34, 0x64, 0x33, 0x64, 0x31, 0x39, 0x65, 0x62, 0x64, 0x63, 0x38, 0x65, 0x38, 0x38, 0x63, 0x32, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x66, 0x65, 0x37, 0x64, 0x37, 0x35, 0x37, 0x33, 0x31, 0x66, 0x36, 0x33, 0x36, 0x64, 0x63, 0x64, 0x30, 0x39, 0x64, 0x62, 0x64, 0x61, 0x30, 0x36, 0x37, 0x31, 0x33, 0x39, 0x33, 0x62, 0x61, 0x30, 0x63, 0x38, 0x32, 0x61, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x32, 0x34, 0x38, 0x64, 0x35, 0x38, 0x65, 0x34, 0x31, 0x34, 0x62, 0x32, 0x30, 0x66, 0x65, 0x64, 0x33, 0x61, 0x36, 0x63, 0x34, 0x38, 0x32, 0x62, 0x35, 0x39, 0x64, 0x39, 0x64, 0x38, 0x66, 0x35, 0x61, 0x34, 0x62, 0x37, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x65, 0x31, 0x39, 0x34, 0x66, 0x33, 0x34, 0x62, 0x31, 0x64, 0x62, 0x36, 0x30, 0x39, 0x32, 0x38, 0x38, 0x35, 0x30, 0x39, 0x63, 0x63, 0x64, 0x32, 0x65, 0x37, 0x33, 0x62, 0x36, 0x31, 0x33, 0x31, 0x61, 0x32, 0x35, 0x33, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x66, 0x32, 0x39, 0x39, 0x36, 0x39, 0x65, 0x37, 0x35, 0x63, 0x36, 0x35, 0x65, 0x30, 0x31, 0x63, 0x65, 0x33, 0x64, 0x38, 0x36, 0x31, 0x35, 0x34, 0x32, 0x30, 0x37, 0x64, 0x30, 0x61, 0x39, 0x65, 0x37, 0x63, 0x37, 0x36, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x31, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x39, 0x33, 0x31, 0x39, 0x39, 0x62, 0x39, 0x63, 0x39, 0x30, 0x62, 0x63, 0x34, 0x39, 0x31, 0x35, 0x62, 0x64, 0x38, 0x35, 0x39, 0x65, 0x33, 0x64, 0x34, 0x32, 0x38, 0x36, 0x36, 0x64, 0x63, 0x38, 0x63, 0x31, 0x38, 0x37, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x66, 0x65, 0x30, 0x61, 0x66, 0x62, 0x39, 0x64, 0x63, 0x65, 0x64, 0x64, 0x33, 0x37, 0x62, 0x32, 0x65, 0x32, 0x32, 0x63, 0x34, 0x35, 0x31, 0x62, 0x61, 0x36, 0x66, 0x65, 0x61, 0x62, 0x36, 0x37, 0x33, 0x34, 0x38, 0x30, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x66, 0x38, 0x35, 0x34, 0x63, 0x39, 0x63, 0x32, 0x66, 0x30, 0x38, 0x37, 0x64, 0x66, 0x66, 0x61, 0x39, 0x38, 0x35, 0x61, 0x63, 0x38, 0x32, 0x30, 0x31, 0x65, 0x36, 0x32, 0x36, 0x63, 0x61, 0x35, 0x34, 0x36, 0x37, 0x36, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x62, 0x62, 0x36, 0x36, 0x34, 0x66, 0x39, 0x31, 0x31, 0x37, 0x30, 0x33, 0x37, 0x36, 0x32, 0x38, 0x35, 0x39, 0x34, 0x64, 0x61, 0x37, 0x65, 0x33, 0x63, 0x35, 0x30, 0x38, 0x39, 0x66, 0x64, 0x36, 0x31, 0x38, 0x62, 0x35, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x64, 0x31, 0x37, 0x34, 0x32, 0x34, 0x63, 0x37, 0x36, 0x37, 0x62, 0x65, 0x61, 0x33, 0x31, 0x32, 0x30, 0x35, 0x37, 0x33, 0x39, 0x61, 0x32, 0x62, 0x35, 0x37, 0x61, 0x37, 0x32, 0x37, 0x37, 0x32, 0x31, 0x34, 0x65, 0x65, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x61, 0x38, 0x64, 0x62, 0x34, 0x61, 0x35, 0x65, 0x66, 0x65, 0x66, 0x63, 0x38, 0x30, 0x66, 0x34, 0x63, 0x64, 0x39, 0x62, 0x62, 0x63, 0x63, 0x63, 0x62, 0x30, 0x33, 0x32, 0x36, 0x35, 0x39, 0x33, 0x31, 0x33, 0x33, 0x32, 0x62, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x36, 0x65, 0x36, 0x62, 0x36, 0x32, 0x62, 0x61, 0x36, 0x65, 0x34, 0x30, 0x65, 0x35, 0x32, 0x61, 0x61, 0x62, 0x31, 0x36, 0x37, 0x64, 0x32, 0x31, 0x64, 0x66, 0x30, 0x32, 0x35, 0x64, 0x30, 0x30, 0x35, 0x35, 0x37, 0x35, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x38, 0x63, 0x34, 0x30, 0x61, 0x37, 0x39, 0x65, 0x31, 0x38, 0x39, 0x39, 0x34, 0x66, 0x66, 0x39, 0x39, 0x65, 0x63, 0x32, 0x35, 0x31, 0x65, 0x65, 0x31, 0x30, 0x64, 0x30, 0x38, 0x38, 0x63, 0x33, 0x39, 0x31, 0x32, 0x65, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x61, 0x33, 0x33, 0x31, 0x31, 0x39, 0x35, 0x62, 0x39, 0x37, 0x37, 0x33, 0x32, 0x35, 0x63, 0x32, 0x61, 0x61, 0x32, 0x38, 0x66, 0x61, 0x32, 0x66, 0x34, 0x32, 0x63, 0x62, 0x32, 0x35, 0x65, 0x63, 0x33, 0x63, 0x32, 0x35, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x63, 0x35, 0x38, 0x35, 0x34, 0x66, 0x66, 0x31, 0x35, 0x39, 0x39, 0x66, 0x39, 0x38, 0x38, 0x39, 0x32, 0x63, 0x35, 0x37, 0x32, 0x35, 0x64, 0x32, 0x36, 0x32, 0x62, 0x65, 0x31, 0x64, 0x61, 0x39, 0x38, 0x61, 0x61, 0x64, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x34, 0x33, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x61, 0x62, 0x30, 0x39, 0x65, 0x37, 0x33, 0x66, 0x38, 0x37, 0x61, 0x61, 0x30, 0x66, 0x33, 0x62, 0x65, 0x30, 0x31, 0x33, 0x39, 0x64, 0x66, 0x30, 0x63, 0x38, 0x65, 0x62, 0x36, 0x62, 0x65, 0x35, 0x36, 0x33, 0x34, 0x66, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x30, 0x34, 0x30, 0x35, 0x33, 0x36, 0x39, 0x35, 0x38, 0x64, 0x35, 0x39, 0x39, 0x38, 0x63, 0x65, 0x34, 0x62, 0x65, 0x63, 0x30, 0x63, 0x66, 0x63, 0x39, 0x63, 0x32, 0x32, 0x30, 0x34, 0x39, 0x38, 0x39, 0x38, 0x34, 0x38, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x34, 0x37, 0x32, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x64, 0x36, 0x62, 0x32, 0x36, 0x33, 0x64, 0x39, 0x65, 0x39, 0x66, 0x34, 0x31, 0x31, 0x36, 0x63, 0x34, 0x31, 0x31, 0x34, 0x32, 0x34, 0x66, 0x63, 0x39, 0x39, 0x35, 0x35, 0x37, 0x38, 0x33, 0x63, 0x37, 0x36, 0x33, 0x30, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x39, 0x36, 0x63, 0x62, 0x62, 0x30, 0x34, 0x35, 0x39, 0x61, 0x36, 0x61, 0x30, 0x31, 0x36, 0x30, 0x30, 0x66, 0x63, 0x35, 0x38, 0x39, 0x61, 0x35, 0x35, 0x61, 0x33, 0x32, 0x62, 0x34, 0x35, 0x34, 0x32, 0x31, 0x37, 0x66, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x33, 0x30, 0x32, 0x63, 0x33, 0x31, 0x31, 0x65, 0x66, 0x38, 0x65, 0x35, 0x64, 0x63, 0x36, 0x36, 0x34, 0x31, 0x35, 0x38, 0x64, 0x64, 0x35, 0x38, 0x33, 0x63, 0x38, 0x31, 0x31, 0x39, 0x34, 0x64, 0x36, 0x65, 0x30, 0x64, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x36, 0x34, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x62, 0x32, 0x38, 0x34, 0x30, 0x34, 0x30, 0x31, 0x33, 0x30, 0x61, 0x62, 0x66, 0x37, 0x63, 0x31, 0x64, 0x31, 0x36, 0x33, 0x37, 0x31, 0x32, 0x33, 0x37, 0x31, 0x63, 0x63, 0x37, 0x65, 0x32, 0x38, 0x61, 0x64, 0x36, 0x36, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x32, 0x66, 0x30, 0x63, 0x61, 0x34, 0x63, 0x64, 0x34, 0x37, 0x39, 0x65, 0x36, 0x36, 0x31, 0x37, 0x37, 0x35, 0x30, 0x35, 0x33, 0x62, 0x63, 0x63, 0x34, 0x39, 0x65, 0x33, 0x39, 0x30, 0x66, 0x36, 0x37, 0x30, 0x64, 0x64, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x39, 0x37, 0x66, 0x30, 0x38, 0x33, 0x61, 0x34, 0x36, 0x39, 0x63, 0x34, 0x35, 0x39, 0x31, 0x63, 0x33, 0x64, 0x32, 0x62, 0x31, 0x64, 0x32, 0x63, 0x37, 0x37, 0x32, 0x37, 0x38, 0x37, 0x62, 0x65, 0x66, 0x65, 0x32, 0x37, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x38, 0x62, 0x36, 0x62, 0x61, 0x38, 0x61, 0x62, 0x30, 0x38, 0x65, 0x61, 0x63, 0x65, 0x33, 0x39, 0x63, 0x35, 0x30, 0x32, 0x65, 0x66, 0x36, 0x37, 0x32, 0x62, 0x64, 0x35, 0x63, 0x63, 0x62, 0x36, 0x61, 0x36, 0x37, 0x61, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x31, 0x33, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x62, 0x66, 0x66, 0x31, 0x64, 0x66, 0x61, 0x39, 0x39, 0x37, 0x31, 0x36, 0x36, 0x38, 0x33, 0x36, 0x30, 0x63, 0x30, 0x64, 0x38, 0x32, 0x38, 0x32, 0x38, 0x34, 0x33, 0x32, 0x65, 0x32, 0x37, 0x62, 0x66, 0x35, 0x34, 0x65, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x36, 0x35, 0x35, 0x62, 0x62, 0x34, 0x65, 0x65, 0x30, 0x65, 0x38, 0x64, 0x35, 0x34, 0x37, 0x38, 0x35, 0x32, 0x36, 0x66, 0x62, 0x39, 0x66, 0x31, 0x35, 0x65, 0x34, 0x30, 0x36, 0x34, 0x65, 0x30, 0x39, 0x66, 0x66, 0x33, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x31, 0x66, 0x38, 0x35, 0x35, 0x62, 0x37, 0x30, 0x31, 0x34, 0x39, 0x61, 0x63, 0x38, 0x33, 0x34, 0x37, 0x33, 0x62, 0x39, 0x37, 0x30, 0x36, 0x66, 0x62, 0x34, 0x34, 0x64, 0x34, 0x37, 0x38, 0x32, 0x38, 0x62, 0x39, 0x38, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x61, 0x31, 0x35, 0x32, 0x35, 0x36, 0x64, 0x35, 0x30, 0x63, 0x65, 0x30, 0x35, 0x38, 0x62, 0x66, 0x30, 0x65, 0x61, 0x63, 0x34, 0x33, 0x61, 0x61, 0x35, 0x33, 0x33, 0x61, 0x61, 0x31, 0x36, 0x65, 0x63, 0x39, 0x62, 0x33, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x62, 0x63, 0x66, 0x63, 0x31, 0x64, 0x34, 0x33, 0x62, 0x34, 0x62, 0x61, 0x31, 0x39, 0x64, 0x65, 0x37, 0x62, 0x32, 0x37, 0x34, 0x62, 0x64, 0x66, 0x66, 0x62, 0x33, 0x35, 0x31, 0x33, 0x39, 0x34, 0x31, 0x32, 0x64, 0x33, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x32, 0x38, 0x38, 0x66, 0x38, 0x30, 0x66, 0x66, 0x65, 0x32, 0x33, 0x32, 0x63, 0x32, 0x62, 0x61, 0x34, 0x37, 0x63, 0x63, 0x39, 0x34, 0x63, 0x37, 0x36, 0x33, 0x63, 0x66, 0x36, 0x66, 0x63, 0x39, 0x62, 0x38, 0x32, 0x62, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x63, 0x62, 0x38, 0x33, 0x65, 0x63, 0x35, 0x65, 0x62, 0x36, 0x66, 0x31, 0x65, 0x65, 0x62, 0x38, 0x35, 0x65, 0x39, 0x39, 0x62, 0x32, 0x66, 0x63, 0x36, 0x33, 0x38, 0x31, 0x32, 0x66, 0x64, 0x65, 0x39, 0x35, 0x37, 0x31, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x31, 0x39, 0x61, 0x39, 0x38, 0x34, 0x31, 0x34, 0x32, 0x33, 0x36, 0x33, 0x32, 0x36, 0x37, 0x35, 0x37, 0x35, 0x35, 0x36, 0x36, 0x30, 0x38, 0x39, 0x33, 0x34, 0x30, 0x65, 0x65, 0x61, 0x30, 0x65, 0x61, 0x32, 0x30, 0x38, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x38, 0x39, 0x66, 0x36, 0x61, 0x64, 0x31, 0x64, 0x39, 0x61, 0x39, 0x34, 0x61, 0x32, 0x39, 0x37, 0x37, 0x38, 0x39, 0x31, 0x35, 0x36, 0x38, 0x39, 0x39, 0x64, 0x62, 0x36, 0x34, 0x31, 0x35, 0x34, 0x66, 0x31, 0x64, 0x62, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x38, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x30, 0x39, 0x62, 0x66, 0x34, 0x66, 0x31, 0x34, 0x36, 0x65, 0x65, 0x61, 0x36, 0x62, 0x30, 0x64, 0x63, 0x38, 0x65, 0x30, 0x36, 0x64, 0x64, 0x63, 0x66, 0x34, 0x34, 0x34, 0x38, 0x61, 0x31, 0x66, 0x63, 0x63, 0x63, 0x39, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x31, 0x66, 0x61, 0x32, 0x65, 0x32, 0x30, 0x65, 0x33, 0x31, 0x39, 0x38, 0x35, 0x65, 0x62, 0x65, 0x32, 0x63, 0x30, 0x66, 0x30, 0x63, 0x39, 0x33, 0x62, 0x35, 0x34, 0x63, 0x30, 0x66, 0x62, 0x36, 0x37, 0x61, 0x32, 0x36, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x65, 0x38, 0x66, 0x66, 0x38, 0x37, 0x66, 0x63, 0x32, 0x36, 0x30, 0x65, 0x30, 0x37, 0x36, 0x37, 0x36, 0x33, 0x38, 0x64, 0x64, 0x35, 0x64, 0x30, 0x32, 0x66, 0x63, 0x34, 0x36, 0x37, 0x32, 0x65, 0x30, 0x65, 0x63, 0x30, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x66, 0x31, 0x62, 0x62, 0x62, 0x31, 0x65, 0x35, 0x61, 0x38, 0x33, 0x66, 0x64, 0x65, 0x38, 0x32, 0x34, 0x38, 0x66, 0x38, 0x38, 0x65, 0x65, 0x33, 0x30, 0x31, 0x38, 0x61, 0x66, 0x61, 0x32, 0x64, 0x31, 0x33, 0x33, 0x32, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x33, 0x61, 0x61, 0x62, 0x33, 0x33, 0x35, 0x65, 0x62, 0x62, 0x66, 0x61, 0x61, 0x38, 0x37, 0x30, 0x63, 0x63, 0x34, 0x64, 0x36, 0x30, 0x35, 0x65, 0x37, 0x64, 0x32, 0x65, 0x37, 0x34, 0x63, 0x36, 0x36, 0x38, 0x33, 0x36, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x34, 0x66, 0x62, 0x31, 0x61, 0x65, 0x61, 0x37, 0x63, 0x64, 0x30, 0x66, 0x35, 0x37, 0x30, 0x65, 0x61, 0x35, 0x65, 0x36, 0x31, 0x62, 0x34, 0x30, 0x61, 0x34, 0x66, 0x34, 0x35, 0x31, 0x30, 0x62, 0x36, 0x32, 0x36, 0x34, 0x65, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x30, 0x62, 0x33, 0x38, 0x36, 0x32, 0x31, 0x31, 0x32, 0x61, 0x65, 0x65, 0x63, 0x33, 0x61, 0x30, 0x33, 0x34, 0x39, 0x32, 0x62, 0x31, 0x62, 0x30, 0x35, 0x66, 0x34, 0x34, 0x30, 0x65, 0x63, 0x61, 0x35, 0x34, 0x32, 0x35, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x66, 0x34, 0x30, 0x30, 0x37, 0x39, 0x33, 0x31, 0x37, 0x38, 0x36, 0x35, 0x39, 0x33, 0x62, 0x32, 0x32, 0x39, 0x65, 0x66, 0x65, 0x35, 0x39, 0x35, 0x39, 0x66, 0x33, 0x61, 0x34, 0x65, 0x32, 0x31, 0x39, 0x65, 0x35, 0x31, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x63, 0x31, 0x34, 0x65, 0x35, 0x34, 0x38, 0x35, 0x64, 0x65, 0x32, 0x62, 0x33, 0x65, 0x65, 0x66, 0x35, 0x65, 0x37, 0x34, 0x63, 0x34, 0x36, 0x31, 0x34, 0x36, 0x64, 0x62, 0x38, 0x65, 0x34, 0x35, 0x34, 0x65, 0x30, 0x33, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x32, 0x31, 0x63, 0x31, 0x65, 0x35, 0x61, 0x33, 0x64, 0x37, 0x65, 0x30, 0x62, 0x35, 0x30, 0x36, 0x38, 0x31, 0x36, 0x37, 0x39, 0x64, 0x64, 0x36, 0x63, 0x37, 0x39, 0x32, 0x64, 0x62, 0x63, 0x61, 0x38, 0x37, 0x64, 0x65, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x36, 0x65, 0x62, 0x62, 0x66, 0x34, 0x39, 0x62, 0x33, 0x65, 0x33, 0x36, 0x64, 0x36, 0x37, 0x36, 0x39, 0x34, 0x61, 0x64, 0x37, 0x39, 0x66, 0x38, 0x66, 0x66, 0x33, 0x36, 0x37, 0x36, 0x37, 0x61, 0x63, 0x36, 0x66, 0x61, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x37, 0x37, 0x33, 0x39, 0x31, 0x32, 0x34, 0x65, 0x64, 0x31, 0x35, 0x33, 0x30, 0x35, 0x32, 0x35, 0x30, 0x33, 0x66, 0x63, 0x31, 0x30, 0x31, 0x34, 0x31, 0x30, 0x64, 0x31, 0x66, 0x66, 0x64, 0x38, 0x63, 0x64, 0x31, 0x33, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x30, 0x32, 0x36, 0x63, 0x61, 0x64, 0x33, 0x66, 0x65, 0x34, 0x65, 0x61, 0x31, 0x63, 0x65, 0x37, 0x66, 0x63, 0x61, 0x32, 0x36, 0x30, 0x64, 0x33, 0x64, 0x34, 0x35, 0x65, 0x62, 0x30, 0x39, 0x65, 0x61, 0x36, 0x61, 0x33, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x66, 0x63, 0x38, 0x34, 0x61, 0x33, 0x65, 0x35, 0x30, 0x61, 0x35, 0x30, 0x61, 0x66, 0x30, 0x32, 0x66, 0x39, 0x34, 0x64, 0x61, 0x30, 0x33, 0x38, 0x33, 0x65, 0x64, 0x35, 0x39, 0x66, 0x37, 0x31, 0x66, 0x66, 0x30, 0x31, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x61, 0x62, 0x30, 0x30, 0x30, 0x62, 0x30, 0x34, 0x30, 0x38, 0x65, 0x64, 0x30, 0x31, 0x35, 0x61, 0x33, 0x37, 0x63, 0x30, 0x34, 0x37, 0x34, 0x37, 0x62, 0x63, 0x34, 0x36, 0x31, 0x61, 0x62, 0x31, 0x34, 0x65, 0x31, 0x35, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x66, 0x66, 0x36, 0x66, 0x62, 0x62, 0x31, 0x66, 0x30, 0x39, 0x62, 0x64, 0x39, 0x65, 0x31, 0x30, 0x32, 0x62, 0x61, 0x30, 0x33, 0x33, 0x64, 0x36, 0x33, 0x36, 0x61, 0x63, 0x31, 0x63, 0x34, 0x63, 0x30, 0x66, 0x35, 0x33, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x36, 0x30, 0x36, 0x66, 0x35, 0x31, 0x31, 0x33, 0x39, 0x37, 0x61, 0x33, 0x38, 0x66, 0x63, 0x37, 0x38, 0x37, 0x32, 0x62, 0x64, 0x33, 0x62, 0x30, 0x62, 0x64, 0x30, 0x33, 0x63, 0x37, 0x31, 0x62, 0x62, 0x64, 0x37, 0x36, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x34, 0x36, 0x64, 0x37, 0x64, 0x65, 0x39, 0x32, 0x37, 0x34, 0x31, 0x63, 0x30, 0x38, 0x66, 0x63, 0x35, 0x38, 0x61, 0x36, 0x34, 0x64, 0x62, 0x35, 0x35, 0x62, 0x30, 0x36, 0x32, 0x64, 0x64, 0x65, 0x30, 0x31, 0x32, 0x64, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x66, 0x31, 0x35, 0x32, 0x32, 0x33, 0x33, 0x31, 0x30, 0x64, 0x34, 0x34, 0x64, 0x65, 0x38, 0x62, 0x36, 0x36, 0x33, 0x36, 0x36, 0x38, 0x35, 0x66, 0x33, 0x61, 0x34, 0x63, 0x33, 0x64, 0x39, 0x63, 0x35, 0x36, 0x35, 0x35, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x38, 0x36, 0x30, 0x65, 0x32, 0x65, 0x36, 0x36, 0x33, 0x66, 0x34, 0x36, 0x64, 0x62, 0x35, 0x33, 0x34, 0x32, 0x37, 0x62, 0x32, 0x39, 0x66, 0x65, 0x33, 0x65, 0x61, 0x35, 0x65, 0x35, 0x62, 0x66, 0x36, 0x32, 0x62, 0x62, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x62, 0x39, 0x34, 0x33, 0x33, 0x38, 0x35, 0x35, 0x34, 0x62, 0x63, 0x34, 0x38, 0x38, 0x63, 0x63, 0x38, 0x38, 0x61, 0x65, 0x32, 0x64, 0x39, 0x64, 0x39, 0x34, 0x30, 0x38, 0x30, 0x64, 0x36, 0x62, 0x64, 0x66, 0x38, 0x34, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x35, 0x63, 0x63, 0x31, 0x31, 0x31, 0x30, 0x39, 0x32, 0x63, 0x31, 0x32, 0x32, 0x31, 0x31, 0x36, 0x66, 0x31, 0x61, 0x38, 0x35, 0x66, 0x34, 0x65, 0x65, 0x33, 0x31, 0x34, 0x30, 0x38, 0x37, 0x34, 0x31, 0x61, 0x37, 0x64, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x37, 0x36, 0x66, 0x30, 0x61, 0x33, 0x30, 0x36, 0x32, 0x36, 0x39, 0x63, 0x37, 0x38, 0x33, 0x30, 0x36, 0x62, 0x33, 0x64, 0x36, 0x35, 0x30, 0x64, 0x63, 0x33, 0x65, 0x39, 0x63, 0x33, 0x37, 0x30, 0x38, 0x34, 0x64, 0x62, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x30, 0x63, 0x63, 0x33, 0x66, 0x39, 0x35, 0x31, 0x34, 0x38, 0x32, 0x63, 0x63, 0x38, 0x61, 0x32, 0x39, 0x32, 0x35, 0x38, 0x31, 0x35, 0x36, 0x38, 0x34, 0x65, 0x62, 0x39, 0x66, 0x39, 0x34, 0x65, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x34, 0x33, 0x37, 0x32, 0x64, 0x62, 0x66, 0x61, 0x31, 0x38, 0x31, 0x64, 0x63, 0x39, 0x32, 0x34, 0x32, 0x66, 0x33, 0x39, 0x62, 0x66, 0x31, 0x64, 0x33, 0x37, 0x33, 0x31, 0x64, 0x66, 0x66, 0x65, 0x32, 0x62, 0x64, 0x61, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x62, 0x61, 0x62, 0x34, 0x62, 0x30, 0x31, 0x61, 0x37, 0x63, 0x38, 0x34, 0x62, 0x61, 0x31, 0x33, 0x66, 0x65, 0x65, 0x61, 0x39, 0x62, 0x30, 0x62, 0x62, 0x31, 0x39, 0x31, 0x62, 0x37, 0x37, 0x61, 0x33, 0x61, 0x61, 0x64, 0x63, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x61, 0x61, 0x30, 0x35, 0x65, 0x35, 0x36, 0x64, 0x37, 0x64, 0x33, 0x32, 0x33, 0x38, 0x35, 0x34, 0x32, 0x31, 0x63, 0x66, 0x39, 0x33, 0x33, 0x36, 0x65, 0x39, 0x30, 0x64, 0x33, 0x64, 0x31, 0x35, 0x61, 0x39, 0x66, 0x38, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x35, 0x32, 0x62, 0x61, 0x64, 0x32, 0x30, 0x33, 0x35, 0x37, 0x32, 0x32, 0x38, 0x66, 0x61, 0x61, 0x31, 0x65, 0x39, 0x39, 0x36, 0x62, 0x65, 0x64, 0x37, 0x39, 0x30, 0x63, 0x39, 0x33, 0x36, 0x37, 0x34, 0x62, 0x61, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x31, 0x32, 0x38, 0x66, 0x34, 0x62, 0x33, 0x35, 0x35, 0x62, 0x65, 0x31, 0x64, 0x63, 0x34, 0x61, 0x36, 0x66, 0x39, 0x34, 0x66, 0x61, 0x35, 0x31, 0x30, 0x64, 0x37, 0x66, 0x31, 0x35, 0x64, 0x35, 0x33, 0x63, 0x32, 0x61, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x32, 0x37, 0x39, 0x33, 0x61, 0x63, 0x35, 0x62, 0x33, 0x37, 0x32, 0x36, 0x38, 0x37, 0x37, 0x34, 0x61, 0x37, 0x31, 0x33, 0x30, 0x64, 0x65, 0x32, 0x62, 0x62, 0x64, 0x33, 0x33, 0x30, 0x34, 0x30, 0x35, 0x36, 0x36, 0x31, 0x37, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x31, 0x39, 0x61, 0x33, 0x39, 0x38, 0x32, 0x32, 0x33, 0x30, 0x33, 0x36, 0x38, 0x66, 0x30, 0x31, 0x37, 0x37, 0x32, 0x31, 0x39, 0x63, 0x62, 0x31, 0x30, 0x63, 0x62, 0x32, 0x35, 0x39, 0x63, 0x64, 0x62, 0x32, 0x32, 0x35, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x31, 0x37, 0x39, 0x34, 0x64, 0x61, 0x35, 0x30, 0x39, 0x63, 0x62, 0x32, 0x39, 0x37, 0x30, 0x35, 0x33, 0x36, 0x36, 0x31, 0x61, 0x31, 0x34, 0x61, 0x61, 0x38, 0x39, 0x32, 0x33, 0x33, 0x33, 0x32, 0x33, 0x31, 0x65, 0x33, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x37, 0x63, 0x38, 0x38, 0x31, 0x30, 0x63, 0x63, 0x37, 0x63, 0x63, 0x38, 0x39, 0x65, 0x38, 0x30, 0x34, 0x65, 0x36, 0x64, 0x33, 0x65, 0x33, 0x38, 0x31, 0x32, 0x31, 0x38, 0x35, 0x30, 0x34, 0x37, 0x32, 0x38, 0x37, 0x37, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x33, 0x63, 0x62, 0x63, 0x33, 0x37, 0x38, 0x32, 0x63, 0x65, 0x62, 0x64, 0x36, 0x37, 0x39, 0x38, 0x39, 0x62, 0x33, 0x30, 0x35, 0x63, 0x34, 0x31, 0x33, 0x33, 0x62, 0x32, 0x63, 0x64, 0x65, 0x33, 0x32, 0x32, 0x31, 0x31, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x33, 0x32, 0x34, 0x39, 0x30, 0x38, 0x39, 0x37, 0x62, 0x62, 0x62, 0x34, 0x63, 0x65, 0x38, 0x62, 0x37, 0x66, 0x36, 0x62, 0x38, 0x33, 0x37, 0x65, 0x34, 0x63, 0x62, 0x61, 0x38, 0x34, 0x38, 0x66, 0x62, 0x65, 0x39, 0x39, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x38, 0x34, 0x61, 0x63, 0x36, 0x65, 0x65, 0x32, 0x37, 0x63, 0x33, 0x39, 0x65, 0x32, 0x66, 0x32, 0x37, 0x38, 0x63, 0x32, 0x32, 0x30, 0x62, 0x64, 0x66, 0x61, 0x35, 0x62, 0x61, 0x65, 0x64, 0x36, 0x32, 0x36, 0x64, 0x39, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x34, 0x35, 0x39, 0x32, 0x38, 0x35, 0x38, 0x36, 0x33, 0x65, 0x61, 0x32, 0x64, 0x62, 0x33, 0x37, 0x35, 0x39, 0x65, 0x35, 0x34, 0x36, 0x63, 0x65, 0x62, 0x33, 0x66, 0x62, 0x33, 0x37, 0x36, 0x31, 0x66, 0x35, 0x39, 0x30, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x32, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x33, 0x34, 0x65, 0x66, 0x63, 0x32, 0x34, 0x33, 0x37, 0x31, 0x31, 0x30, 0x37, 0x62, 0x34, 0x63, 0x62, 0x66, 0x30, 0x33, 0x66, 0x37, 0x39, 0x61, 0x39, 0x33, 0x64, 0x66, 0x64, 0x39, 0x33, 0x65, 0x34, 0x33, 0x31, 0x64, 0x35, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x32, 0x31, 0x33, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x39, 0x66, 0x35, 0x39, 0x61, 0x65, 0x64, 0x61, 0x34, 0x31, 0x38, 0x63, 0x31, 0x34, 0x39, 0x34, 0x36, 0x38, 0x32, 0x64, 0x39, 0x34, 0x31, 0x61, 0x61, 0x62, 0x34, 0x39, 0x32, 0x34, 0x62, 0x35, 0x66, 0x34, 0x39, 0x32, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x33, 0x31, 0x31, 0x63, 0x39, 0x35, 0x33, 0x33, 0x66, 0x30, 0x30, 0x39, 0x32, 0x63, 0x37, 0x32, 0x34, 0x38, 0x63, 0x39, 0x37, 0x33, 0x39, 0x62, 0x35, 0x62, 0x32, 0x63, 0x38, 0x36, 0x34, 0x61, 0x33, 0x34, 0x62, 0x31, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x33, 0x34, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x65, 0x36, 0x32, 0x31, 0x65, 0x61, 0x61, 0x62, 0x30, 0x31, 0x66, 0x32, 0x30, 0x65, 0x66, 0x30, 0x38, 0x33, 0x36, 0x62, 0x37, 0x63, 0x61, 0x64, 0x34, 0x37, 0x34, 0x36, 0x34, 0x63, 0x62, 0x35, 0x66, 0x64, 0x33, 0x63, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x31, 0x30, 0x32, 0x63, 0x64, 0x36, 0x64, 0x62, 0x33, 0x64, 0x66, 0x31, 0x34, 0x61, 0x64, 0x36, 0x61, 0x66, 0x30, 0x66, 0x38, 0x37, 0x63, 0x37, 0x32, 0x34, 0x37, 0x39, 0x38, 0x36, 0x31, 0x62, 0x66, 0x63, 0x33, 0x64, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x35, 0x61, 0x39, 0x63, 0x30, 0x33, 0x66, 0x36, 0x39, 0x64, 0x31, 0x37, 0x64, 0x36, 0x36, 0x63, 0x62, 0x62, 0x38, 0x61, 0x64, 0x37, 0x32, 0x31, 0x30, 0x30, 0x38, 0x61, 0x39, 0x65, 0x62, 0x62, 0x62, 0x38, 0x33, 0x36, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x37, 0x32, 0x63, 0x65, 0x62, 0x65, 0x36, 0x32, 0x61, 0x39, 0x65, 0x39, 0x66, 0x36, 0x31, 0x63, 0x63, 0x33, 0x66, 0x62, 0x66, 0x38, 0x38, 0x61, 0x39, 0x65, 0x66, 0x62, 0x66, 0x65, 0x33, 0x65, 0x39, 0x61, 0x38, 0x64, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x61, 0x62, 0x31, 0x31, 0x36, 0x31, 0x37, 0x35, 0x30, 0x32, 0x34, 0x34, 0x64, 0x30, 0x65, 0x63, 0x64, 0x30, 0x34, 0x38, 0x65, 0x65, 0x30, 0x64, 0x33, 0x65, 0x35, 0x31, 0x61, 0x62, 0x62, 0x31, 0x34, 0x33, 0x61, 0x32, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x38, 0x36, 0x37, 0x38, 0x35, 0x62, 0x38, 0x39, 0x37, 0x32, 0x30, 0x62, 0x36, 0x31, 0x31, 0x34, 0x35, 0x66, 0x65, 0x61, 0x38, 0x30, 0x39, 0x37, 0x38, 0x64, 0x36, 0x61, 0x63, 0x63, 0x38, 0x65, 0x30, 0x62, 0x63, 0x31, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x61, 0x32, 0x62, 0x34, 0x66, 0x63, 0x35, 0x64, 0x38, 0x31, 0x61, 0x63, 0x65, 0x36, 0x37, 0x64, 0x63, 0x34, 0x62, 0x62, 0x61, 0x30, 0x33, 0x66, 0x37, 0x62, 0x34, 0x35, 0x35, 0x34, 0x31, 0x33, 0x64, 0x34, 0x36, 0x66, 0x65, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x32, 0x65, 0x63, 0x37, 0x65, 0x34, 0x32, 0x61, 0x64, 0x31, 0x36, 0x63, 0x65, 0x33, 0x65, 0x32, 0x35, 0x35, 0x35, 0x61, 0x64, 0x34, 0x63, 0x35, 0x34, 0x33, 0x30, 0x36, 0x65, 0x64, 0x61, 0x30, 0x62, 0x32, 0x36, 0x37, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x66, 0x61, 0x37, 0x32, 0x33, 0x35, 0x35, 0x32, 0x61, 0x35, 0x64, 0x30, 0x35, 0x31, 0x32, 0x65, 0x32, 0x62, 0x36, 0x32, 0x66, 0x34, 0x38, 0x64, 0x63, 0x61, 0x37, 0x62, 0x32, 0x62, 0x38, 0x31, 0x30, 0x35, 0x33, 0x30, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x63, 0x33, 0x66, 0x39, 0x32, 0x62, 0x61, 0x61, 0x31, 0x64, 0x32, 0x31, 0x64, 0x61, 0x62, 0x37, 0x33, 0x38, 0x32, 0x62, 0x38, 0x39, 0x33, 0x32, 0x36, 0x31, 0x61, 0x30, 0x33, 0x35, 0x36, 0x66, 0x61, 0x37, 0x63, 0x31, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x32, 0x37, 0x63, 0x36, 0x30, 0x36, 0x38, 0x34, 0x32, 0x36, 0x37, 0x31, 0x61, 0x62, 0x64, 0x65, 0x38, 0x32, 0x39, 0x35, 0x65, 0x65, 0x35, 0x64, 0x64, 0x39, 0x34, 0x63, 0x37, 0x66, 0x35, 0x34, 0x39, 0x35, 0x33, 0x34, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x39, 0x65, 0x34, 0x36, 0x65, 0x31, 0x35, 0x64, 0x32, 0x32, 0x63, 0x65, 0x35, 0x36, 0x65, 0x30, 0x63, 0x33, 0x32, 0x66, 0x31, 0x38, 0x37, 0x37, 0x62, 0x37, 0x64, 0x31, 0x61, 0x32, 0x36, 0x34, 0x63, 0x66, 0x39, 0x34, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x64, 0x31, 0x35, 0x37, 0x65, 0x34, 0x63, 0x30, 0x61, 0x39, 0x36, 0x34, 0x33, 0x37, 0x61, 0x36, 0x64, 0x32, 0x38, 0x35, 0x37, 0x34, 0x31, 0x64, 0x64, 0x32, 0x33, 0x65, 0x63, 0x34, 0x33, 0x36, 0x31, 0x66, 0x61, 0x33, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x66, 0x38, 0x66, 0x34, 0x35, 0x31, 0x35, 0x35, 0x65, 0x39, 0x38, 0x63, 0x35, 0x30, 0x32, 0x39, 0x61, 0x34, 0x65, 0x62, 0x63, 0x35, 0x62, 0x35, 0x32, 0x37, 0x61, 0x39, 0x32, 0x65, 0x39, 0x66, 0x61, 0x38, 0x33, 0x31, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x33, 0x36, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x62, 0x61, 0x32, 0x62, 0x35, 0x65, 0x32, 0x37, 0x66, 0x66, 0x37, 0x38, 0x62, 0x61, 0x61, 0x61, 0x62, 0x35, 0x63, 0x64, 0x63, 0x39, 0x38, 0x38, 0x62, 0x37, 0x62, 0x65, 0x38, 0x35, 0x35, 0x63, 0x65, 0x62, 0x62, 0x64, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x62, 0x33, 0x39, 0x38, 0x33, 0x37, 0x63, 0x62, 0x33, 0x63, 0x61, 0x63, 0x38, 0x61, 0x38, 0x30, 0x32, 0x61, 0x66, 0x65, 0x33, 0x66, 0x31, 0x32, 0x61, 0x32, 0x35, 0x38, 0x62, 0x62, 0x63, 0x61, 0x36, 0x32, 0x64, 0x61, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x39, 0x62, 0x37, 0x63, 0x62, 0x63, 0x39, 0x34, 0x30, 0x30, 0x33, 0x66, 0x63, 0x39, 0x34, 0x38, 0x66, 0x30, 0x63, 0x64, 0x65, 0x32, 0x37, 0x62, 0x31, 0x30, 0x30, 0x64, 0x62, 0x38, 0x63, 0x63, 0x64, 0x36, 0x65, 0x30, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x64, 0x62, 0x39, 0x65, 0x64, 0x37, 0x66, 0x30, 0x32, 0x34, 0x63, 0x37, 0x65, 0x32, 0x36, 0x33, 0x37, 0x32, 0x66, 0x65, 0x61, 0x63, 0x66, 0x32, 0x62, 0x30, 0x35, 0x30, 0x38, 0x30, 0x33, 0x34, 0x34, 0x35, 0x65, 0x33, 0x38, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x38, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x62, 0x63, 0x31, 0x65, 0x34, 0x35, 0x31, 0x38, 0x64, 0x37, 0x33, 0x34, 0x30, 0x30, 0x63, 0x36, 0x64, 0x30, 0x34, 0x36, 0x33, 0x35, 0x39, 0x34, 0x33, 0x39, 0x66, 0x62, 0x36, 0x38, 0x65, 0x61, 0x31, 0x61, 0x34, 0x39, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x33, 0x64, 0x61, 0x34, 0x66, 0x33, 0x32, 0x34, 0x30, 0x38, 0x34, 0x34, 0x63, 0x39, 0x62, 0x36, 0x33, 0x32, 0x33, 0x62, 0x34, 0x39, 0x39, 0x36, 0x39, 0x32, 0x31, 0x32, 0x30, 0x37, 0x31, 0x32, 0x32, 0x34, 0x35, 0x34, 0x33, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x35, 0x33, 0x39, 0x36, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x61, 0x66, 0x61, 0x37, 0x33, 0x62, 0x63, 0x30, 0x34, 0x37, 0x65, 0x66, 0x34, 0x36, 0x62, 0x39, 0x37, 0x37, 0x66, 0x64, 0x39, 0x37, 0x36, 0x33, 0x66, 0x38, 0x37, 0x32, 0x38, 0x36, 0x61, 0x36, 0x62, 0x65, 0x36, 0x38, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x62, 0x65, 0x38, 0x65, 0x31, 0x63, 0x32, 0x62, 0x38, 0x61, 0x30, 0x30, 0x39, 0x66, 0x38, 0x35, 0x66, 0x31, 0x61, 0x64, 0x33, 0x63, 0x65, 0x38, 0x30, 0x64, 0x32, 0x65, 0x30, 0x35, 0x33, 0x35, 0x30, 0x65, 0x65, 0x33, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x35, 0x61, 0x32, 0x64, 0x30, 0x61, 0x62, 0x64, 0x61, 0x30, 0x33, 0x62, 0x62, 0x65, 0x32, 0x31, 0x35, 0x37, 0x38, 0x31, 0x62, 0x34, 0x66, 0x66, 0x32, 0x39, 0x36, 0x63, 0x38, 0x63, 0x36, 0x31, 0x62, 0x64, 0x62, 0x61, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x36, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x39, 0x64, 0x31, 0x64, 0x63, 0x30, 0x62, 0x61, 0x61, 0x37, 0x37, 0x64, 0x36, 0x65, 0x32, 0x30, 0x63, 0x33, 0x64, 0x38, 0x34, 0x39, 0x63, 0x37, 0x38, 0x38, 0x36, 0x32, 0x64, 0x64, 0x31, 0x63, 0x30, 0x35, 0x34, 0x63, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x63, 0x65, 0x66, 0x38, 0x38, 0x36, 0x37, 0x39, 0x35, 0x37, 0x33, 0x39, 0x34, 0x37, 0x65, 0x39, 0x34, 0x39, 0x39, 0x37, 0x37, 0x39, 0x38, 0x61, 0x31, 0x65, 0x33, 0x32, 0x37, 0x65, 0x30, 0x38, 0x36, 0x30, 0x33, 0x61, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x30, 0x62, 0x39, 0x64, 0x62, 0x31, 0x38, 0x66, 0x66, 0x38, 0x34, 0x62, 0x66, 0x30, 0x63, 0x37, 0x64, 0x61, 0x34, 0x39, 0x65, 0x61, 0x33, 0x37, 0x38, 0x31, 0x64, 0x39, 0x32, 0x30, 0x39, 0x30, 0x61, 0x64, 0x37, 0x65, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x31, 0x63, 0x37, 0x35, 0x39, 0x33, 0x31, 0x36, 0x39, 0x36, 0x62, 0x63, 0x33, 0x64, 0x34, 0x32, 0x37, 0x64, 0x39, 0x33, 0x65, 0x37, 0x36, 0x63, 0x37, 0x37, 0x66, 0x64, 0x31, 0x33, 0x62, 0x32, 0x34, 0x31, 0x66, 0x36, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x66, 0x32, 0x62, 0x33, 0x32, 0x30, 0x65, 0x36, 0x64, 0x66, 0x64, 0x37, 0x30, 0x39, 0x30, 0x36, 0x63, 0x35, 0x39, 0x37, 0x62, 0x61, 0x64, 0x32, 0x66, 0x39, 0x35, 0x30, 0x31, 0x33, 0x31, 0x32, 0x63, 0x37, 0x38, 0x32, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x63, 0x31, 0x64, 0x35, 0x31, 0x31, 0x31, 0x64, 0x30, 0x39, 0x61, 0x66, 0x32, 0x35, 0x66, 0x64, 0x66, 0x63, 0x61, 0x63, 0x34, 0x35, 0x35, 0x63, 0x37, 0x63, 0x65, 0x63, 0x32, 0x38, 0x33, 0x65, 0x36, 0x64, 0x36, 0x37, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x37, 0x65, 0x63, 0x65, 0x30, 0x38, 0x36, 0x62, 0x34, 0x62, 0x36, 0x31, 0x39, 0x62, 0x33, 0x62, 0x33, 0x36, 0x39, 0x33, 0x35, 0x32, 0x65, 0x65, 0x33, 0x38, 0x62, 0x37, 0x31, 0x64, 0x64, 0x62, 0x30, 0x36, 0x34, 0x33, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x30, 0x37, 0x63, 0x32, 0x31, 0x35, 0x30, 0x64, 0x33, 0x65, 0x31, 0x62, 0x39, 0x39, 0x66, 0x32, 0x34, 0x66, 0x61, 0x31, 0x63, 0x37, 0x64, 0x35, 0x34, 0x30, 0x61, 0x64, 0x64, 0x33, 0x35, 0x63, 0x34, 0x65, 0x62, 0x65, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x39, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x34, 0x38, 0x35, 0x63, 0x38, 0x31, 0x38, 0x37, 0x32, 0x38, 0x63, 0x31, 0x39, 0x37, 0x66, 0x65, 0x61, 0x34, 0x38, 0x37, 0x66, 0x62, 0x62, 0x36, 0x65, 0x38, 0x32, 0x39, 0x31, 0x35, 0x39, 0x65, 0x62, 0x61, 0x38, 0x33, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x33, 0x38, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x36, 0x37, 0x30, 0x38, 0x31, 0x35, 0x66, 0x62, 0x36, 0x37, 0x61, 0x65, 0x61, 0x65, 0x61, 0x35, 0x37, 0x62, 0x38, 0x36, 0x35, 0x33, 0x34, 0x65, 0x64, 0x63, 0x30, 0x30, 0x63, 0x64, 0x66, 0x35, 0x36, 0x34, 0x66, 0x65, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x64, 0x66, 0x36, 0x38, 0x31, 0x35, 0x30, 0x36, 0x65, 0x33, 0x34, 0x39, 0x33, 0x30, 0x61, 0x63, 0x37, 0x61, 0x35, 0x63, 0x36, 0x37, 0x61, 0x35, 0x34, 0x63, 0x33, 0x65, 0x38, 0x39, 0x63, 0x65, 0x39, 0x32, 0x62, 0x39, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x35, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x66, 0x32, 0x65, 0x62, 0x37, 0x61, 0x38, 0x63, 0x63, 0x61, 0x63, 0x32, 0x61, 0x64, 0x65, 0x61, 0x65, 0x66, 0x30, 0x65, 0x65, 0x38, 0x37, 0x33, 0x34, 0x37, 0x64, 0x35, 0x33, 0x35, 0x64, 0x33, 0x62, 0x39, 0x34, 0x30, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x64, 0x63, 0x34, 0x33, 0x66, 0x32, 0x30, 0x35, 0x36, 0x31, 0x39, 0x31, 0x32, 0x37, 0x35, 0x30, 0x37, 0x62, 0x32, 0x62, 0x31, 0x63, 0x31, 0x63, 0x66, 0x64, 0x66, 0x33, 0x32, 0x64, 0x32, 0x38, 0x33, 0x31, 0x30, 0x39, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x31, 0x39, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x63, 0x32, 0x39, 0x30, 0x34, 0x65, 0x39, 0x66, 0x61, 0x36, 0x36, 0x34, 0x61, 0x31, 0x31, 0x65, 0x65, 0x32, 0x35, 0x36, 0x35, 0x36, 0x64, 0x38, 0x66, 0x64, 0x32, 0x63, 0x63, 0x30, 0x64, 0x39, 0x61, 0x35, 0x32, 0x32, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x36, 0x37, 0x30, 0x66, 0x62, 0x62, 0x30, 0x35, 0x64, 0x33, 0x33, 0x30, 0x31, 0x34, 0x34, 0x34, 0x34, 0x62, 0x38, 0x64, 0x31, 0x65, 0x38, 0x65, 0x37, 0x37, 0x30, 0x30, 0x32, 0x35, 0x38, 0x62, 0x38, 0x63, 0x61, 0x61, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x36, 0x30, 0x65, 0x64, 0x36, 0x31, 0x32, 0x65, 0x31, 0x62, 0x34, 0x38, 0x65, 0x37, 0x33, 0x66, 0x33, 0x66, 0x63, 0x31, 0x35, 0x62, 0x63, 0x34, 0x33, 0x32, 0x31, 0x62, 0x38, 0x66, 0x32, 0x33, 0x62, 0x38, 0x61, 0x32, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x61, 0x36, 0x32, 0x62, 0x66, 0x39, 0x32, 0x33, 0x33, 0x65, 0x31, 0x34, 0x36, 0x66, 0x66, 0x65, 0x63, 0x33, 0x38, 0x37, 0x36, 0x65, 0x34, 0x35, 0x66, 0x32, 0x30, 0x65, 0x65, 0x38, 0x34, 0x31, 0x34, 0x61, 0x64, 0x65, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x64, 0x34, 0x65, 0x63, 0x31, 0x37, 0x64, 0x35, 0x63, 0x65, 0x62, 0x32, 0x63, 0x38, 0x39, 0x34, 0x62, 0x64, 0x63, 0x35, 0x39, 0x64, 0x30, 0x61, 0x36, 0x61, 0x36, 0x39, 0x35, 0x64, 0x61, 0x64, 0x32, 0x62, 0x34, 0x33, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x33, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x35, 0x66, 0x63, 0x38, 0x34, 0x33, 0x65, 0x31, 0x39, 0x61, 0x34, 0x39, 0x31, 0x33, 0x64, 0x31, 0x38, 0x38, 0x31, 0x65, 0x62, 0x36, 0x39, 0x62, 0x36, 0x39, 0x63, 0x30, 0x66, 0x61, 0x33, 0x62, 0x65, 0x35, 0x63, 0x35, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x30, 0x31, 0x61, 0x62, 0x61, 0x37, 0x37, 0x63, 0x30, 0x32, 0x65, 0x31, 0x37, 0x32, 0x30, 0x38, 0x36, 0x63, 0x31, 0x39, 0x35, 0x30, 0x66, 0x66, 0x66, 0x62, 0x63, 0x61, 0x61, 0x33, 0x30, 0x62, 0x38, 0x33, 0x34, 0x38, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x65, 0x66, 0x62, 0x63, 0x61, 0x30, 0x39, 0x62, 0x33, 0x35, 0x38, 0x30, 0x62, 0x39, 0x38, 0x65, 0x37, 0x33, 0x66, 0x35, 0x62, 0x32, 0x66, 0x37, 0x66, 0x34, 0x64, 0x63, 0x30, 0x62, 0x66, 0x30, 0x32, 0x63, 0x35, 0x32, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x64, 0x39, 0x31, 0x36, 0x35, 0x37, 0x34, 0x65, 0x36, 0x38, 0x63, 0x34, 0x39, 0x66, 0x37, 0x65, 0x66, 0x39, 0x64, 0x33, 0x64, 0x38, 0x32, 0x64, 0x31, 0x36, 0x33, 0x38, 0x62, 0x32, 0x62, 0x37, 0x65, 0x65, 0x30, 0x39, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x62, 0x30, 0x64, 0x33, 0x32, 0x63, 0x66, 0x33, 0x37, 0x36, 0x37, 0x66, 0x61, 0x36, 0x62, 0x33, 0x35, 0x33, 0x37, 0x63, 0x38, 0x34, 0x33, 0x32, 0x38, 0x62, 0x61, 0x61, 0x39, 0x66, 0x35, 0x30, 0x34, 0x35, 0x38, 0x31, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x65, 0x34, 0x36, 0x38, 0x36, 0x34, 0x34, 0x36, 0x66, 0x31, 0x39, 0x34, 0x39, 0x65, 0x62, 0x65, 0x64, 0x36, 0x37, 0x32, 0x31, 0x35, 0x65, 0x62, 0x30, 0x64, 0x35, 0x61, 0x31, 0x64, 0x64, 0x37, 0x32, 0x63, 0x31, 0x31, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x31, 0x37, 0x37, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x33, 0x37, 0x66, 0x63, 0x62, 0x38, 0x37, 0x36, 0x64, 0x61, 0x30, 0x30, 0x64, 0x31, 0x65, 0x62, 0x33, 0x62, 0x38, 0x38, 0x66, 0x65, 0x62, 0x33, 0x64, 0x66, 0x33, 0x66, 0x61, 0x34, 0x30, 0x34, 0x32, 0x66, 0x61, 0x63, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x65, 0x33, 0x38, 0x66, 0x66, 0x35, 0x34, 0x35, 0x66, 0x33, 0x30, 0x66, 0x65, 0x31, 0x34, 0x63, 0x61, 0x38, 0x36, 0x33, 0x64, 0x34, 0x66, 0x35, 0x32, 0x39, 0x37, 0x66, 0x64, 0x34, 0x38, 0x63, 0x37, 0x33, 0x61, 0x35, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x32, 0x38, 0x61, 0x30, 0x65, 0x35, 0x61, 0x32, 0x36, 0x37, 0x64, 0x36, 0x36, 0x37, 0x65, 0x39, 0x33, 0x39, 0x33, 0x61, 0x36, 0x35, 0x38, 0x34, 0x65, 0x31, 0x39, 0x62, 0x33, 0x34, 0x64, 0x63, 0x39, 0x62, 0x65, 0x39, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x33, 0x37, 0x34, 0x39, 0x32, 0x38, 0x63, 0x64, 0x66, 0x31, 0x39, 0x33, 0x37, 0x30, 0x35, 0x34, 0x34, 0x33, 0x62, 0x31, 0x34, 0x63, 0x63, 0x32, 0x30, 0x64, 0x61, 0x34, 0x32, 0x33, 0x34, 0x37, 0x33, 0x63, 0x64, 0x39, 0x63, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x38, 0x31, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x30, 0x36, 0x66, 0x35, 0x64, 0x64, 0x37, 0x32, 0x63, 0x61, 0x62, 0x36, 0x36, 0x64, 0x38, 0x61, 0x36, 0x65, 0x63, 0x62, 0x64, 0x36, 0x62, 0x66, 0x62, 0x34, 0x39, 0x34, 0x61, 0x37, 0x62, 0x36, 0x62, 0x30, 0x39, 0x61, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x65, 0x66, 0x33, 0x34, 0x30, 0x65, 0x36, 0x36, 0x62, 0x30, 0x64, 0x37, 0x61, 0x66, 0x63, 0x63, 0x65, 0x32, 0x30, 0x61, 0x31, 0x39, 0x63, 0x62, 0x37, 0x62, 0x66, 0x63, 0x38, 0x31, 0x64, 0x61, 0x33, 0x33, 0x64, 0x39, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x31, 0x32, 0x64, 0x62, 0x34, 0x35, 0x33, 0x38, 0x32, 0x37, 0x61, 0x35, 0x38, 0x65, 0x31, 0x36, 0x63, 0x31, 0x33, 0x36, 0x35, 0x36, 0x30, 0x38, 0x64, 0x33, 0x36, 0x65, 0x64, 0x36, 0x35, 0x38, 0x37, 0x32, 0x30, 0x35, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x35, 0x39, 0x36, 0x33, 0x38, 0x64, 0x33, 0x63, 0x35, 0x66, 0x61, 0x61, 0x37, 0x37, 0x31, 0x31, 0x62, 0x66, 0x30, 0x38, 0x35, 0x37, 0x34, 0x35, 0x66, 0x39, 0x64, 0x35, 0x62, 0x64, 0x63, 0x32, 0x33, 0x64, 0x34, 0x39, 0x38, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x30, 0x38, 0x66, 0x63, 0x37, 0x63, 0x62, 0x61, 0x64, 0x66, 0x66, 0x62, 0x64, 0x30, 0x64, 0x37, 0x66, 0x65, 0x34, 0x34, 0x66, 0x38, 0x64, 0x66, 0x64, 0x36, 0x30, 0x61, 0x37, 0x39, 0x64, 0x37, 0x32, 0x31, 0x61, 0x31, 0x63, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x33, 0x34, 0x37, 0x30, 0x32, 0x38, 0x32, 0x64, 0x35, 0x65, 0x32, 0x61, 0x32, 0x61, 0x65, 0x66, 0x64, 0x37, 0x61, 0x37, 0x35, 0x30, 0x39, 0x34, 0x63, 0x38, 0x32, 0x32, 0x63, 0x34, 0x66, 0x35, 0x61, 0x65, 0x65, 0x66, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x32, 0x37, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x62, 0x33, 0x39, 0x36, 0x35, 0x63, 0x32, 0x31, 0x66, 0x61, 0x38, 0x39, 0x33, 0x39, 0x33, 0x31, 0x30, 0x37, 0x39, 0x62, 0x65, 0x61, 0x63, 0x66, 0x66, 0x66, 0x61, 0x66, 0x31, 0x35, 0x33, 0x36, 0x37, 0x38, 0x62, 0x36, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x33, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x64, 0x64, 0x39, 0x34, 0x37, 0x31, 0x63, 0x62, 0x66, 0x61, 0x32, 0x36, 0x32, 0x37, 0x30, 0x39, 0x66, 0x35, 0x66, 0x34, 0x38, 0x36, 0x62, 0x63, 0x62, 0x37, 0x37, 0x34, 0x63, 0x35, 0x66, 0x35, 0x32, 0x37, 0x62, 0x38, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x36, 0x30, 0x63, 0x39, 0x32, 0x34, 0x31, 0x36, 0x32, 0x38, 0x37, 0x33, 0x66, 0x63, 0x37, 0x65, 0x61, 0x34, 0x64, 0x61, 0x37, 0x66, 0x39, 0x37, 0x32, 0x65, 0x33, 0x35, 0x30, 0x31, 0x36, 0x37, 0x33, 0x37, 0x36, 0x30, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x30, 0x31, 0x33, 0x63, 0x35, 0x31, 0x62, 0x64, 0x30, 0x37, 0x38, 0x61, 0x30, 0x39, 0x38, 0x66, 0x61, 0x65, 0x30, 0x35, 0x62, 0x66, 0x32, 0x61, 0x63, 0x65, 0x30, 0x38, 0x34, 0x39, 0x63, 0x36, 0x62, 0x65, 0x31, 0x37, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x32, 0x33, 0x62, 0x32, 0x36, 0x30, 0x66, 0x63, 0x63, 0x32, 0x36, 0x65, 0x37, 0x64, 0x31, 0x30, 0x66, 0x34, 0x62, 0x64, 0x30, 0x34, 0x34, 0x61, 0x66, 0x37, 0x39, 0x34, 0x35, 0x37, 0x39, 0x34, 0x36, 0x30, 0x64, 0x39, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x64, 0x62, 0x30, 0x33, 0x62, 0x63, 0x63, 0x66, 0x64, 0x36, 0x61, 0x35, 0x66, 0x34, 0x64, 0x30, 0x32, 0x36, 0x36, 0x62, 0x38, 0x32, 0x61, 0x32, 0x32, 0x61, 0x33, 0x36, 0x38, 0x37, 0x39, 0x32, 0x63, 0x37, 0x37, 0x64, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x30, 0x63, 0x62, 0x65, 0x36, 0x61, 0x36, 0x64, 0x63, 0x62, 0x36, 0x31, 0x66, 0x31, 0x31, 0x30, 0x63, 0x34, 0x35, 0x62, 0x61, 0x32, 0x61, 0x61, 0x33, 0x36, 0x31, 0x64, 0x37, 0x66, 0x63, 0x61, 0x64, 0x33, 0x64, 0x61, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x64, 0x33, 0x61, 0x35, 0x61, 0x39, 0x30, 0x31, 0x66, 0x32, 0x66, 0x36, 0x62, 0x64, 0x39, 0x33, 0x35, 0x36, 0x66, 0x31, 0x31, 0x32, 0x61, 0x37, 0x30, 0x31, 0x38, 0x30, 0x65, 0x35, 0x61, 0x31, 0x35, 0x35, 0x30, 0x62, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x32, 0x31, 0x39, 0x32, 0x32, 0x39, 0x65, 0x38, 0x63, 0x64, 0x35, 0x36, 0x36, 0x35, 0x39, 0x61, 0x36, 0x35, 0x63, 0x32, 0x61, 0x39, 0x34, 0x33, 0x65, 0x32, 0x64, 0x64, 0x39, 0x61, 0x38, 0x66, 0x34, 0x62, 0x66, 0x64, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x30, 0x64, 0x30, 0x37, 0x31, 0x62, 0x31, 0x62, 0x30, 0x30, 0x33, 0x30, 0x36, 0x33, 0x34, 0x39, 0x37, 0x64, 0x37, 0x39, 0x39, 0x30, 0x65, 0x31, 0x32, 0x34, 0x39, 0x64, 0x61, 0x62, 0x66, 0x33, 0x36, 0x63, 0x33, 0x35, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x33, 0x35, 0x63, 0x38, 0x65, 0x38, 0x62, 0x37, 0x34, 0x61, 0x32, 0x63, 0x61, 0x32, 0x61, 0x65, 0x33, 0x66, 0x34, 0x61, 0x38, 0x64, 0x30, 0x66, 0x36, 0x62, 0x39, 0x35, 0x34, 0x61, 0x33, 0x65, 0x32, 0x61, 0x38, 0x33, 0x39, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x32, 0x64, 0x35, 0x63, 0x39, 0x32, 0x30, 0x35, 0x33, 0x38, 0x65, 0x39, 0x35, 0x33, 0x63, 0x61, 0x61, 0x66, 0x32, 0x34, 0x66, 0x30, 0x37, 0x33, 0x37, 0x66, 0x35, 0x35, 0x34, 0x63, 0x63, 0x36, 0x39, 0x32, 0x37, 0x37, 0x34, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x64, 0x66, 0x36, 0x63, 0x34, 0x32, 0x38, 0x30, 0x65, 0x36, 0x65, 0x62, 0x30, 0x35, 0x62, 0x39, 0x33, 0x34, 0x61, 0x63, 0x65, 0x34, 0x32, 0x38, 0x65, 0x31, 0x31, 0x64, 0x34, 0x32, 0x33, 0x31, 0x62, 0x35, 0x39, 0x30, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x61, 0x36, 0x39, 0x36, 0x65, 0x63, 0x62, 0x64, 0x37, 0x38, 0x37, 0x65, 0x36, 0x36, 0x61, 0x62, 0x61, 0x65, 0x34, 0x66, 0x65, 0x38, 0x37, 0x62, 0x36, 0x33, 0x35, 0x66, 0x30, 0x37, 0x63, 0x61, 0x35, 0x37, 0x64, 0x38, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x38, 0x31, 0x37, 0x37, 0x32, 0x31, 0x37, 0x35, 0x32, 0x33, 0x37, 0x65, 0x62, 0x34, 0x63, 0x62, 0x65, 0x30, 0x66, 0x65, 0x32, 0x64, 0x63, 0x61, 0x66, 0x64, 0x61, 0x64, 0x66, 0x66, 0x65, 0x62, 0x36, 0x61, 0x31, 0x39, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x34, 0x37, 0x38, 0x33, 0x63, 0x38, 0x65, 0x35, 0x37, 0x62, 0x34, 0x38, 0x30, 0x37, 0x39, 0x33, 0x63, 0x62, 0x64, 0x36, 0x39, 0x61, 0x34, 0x35, 0x64, 0x39, 0x30, 0x63, 0x37, 0x62, 0x34, 0x66, 0x30, 0x63, 0x34, 0x38, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x34, 0x66, 0x30, 0x39, 0x30, 0x61, 0x64, 0x66, 0x33, 0x66, 0x38, 0x64, 0x62, 0x37, 0x65, 0x31, 0x39, 0x34, 0x62, 0x33, 0x35, 0x30, 0x66, 0x62, 0x62, 0x37, 0x37, 0x35, 0x30, 0x30, 0x36, 0x39, 0x39, 0x66, 0x36, 0x36, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x39, 0x38, 0x32, 0x34, 0x62, 0x35, 0x63, 0x31, 0x33, 0x32, 0x31, 0x31, 0x31, 0x62, 0x63, 0x61, 0x32, 0x34, 0x64, 0x64, 0x66, 0x62, 0x61, 0x37, 0x65, 0x35, 0x37, 0x35, 0x61, 0x35, 0x63, 0x64, 0x37, 0x32, 0x39, 0x36, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x32, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x63, 0x65, 0x37, 0x32, 0x64, 0x30, 0x36, 0x38, 0x63, 0x37, 0x63, 0x33, 0x66, 0x35, 0x35, 0x62, 0x31, 0x64, 0x32, 0x38, 0x31, 0x39, 0x35, 0x34, 0x35, 0x65, 0x37, 0x37, 0x33, 0x31, 0x37, 0x63, 0x61, 0x65, 0x38, 0x32, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x31, 0x35, 0x65, 0x31, 0x64, 0x39, 0x66, 0x34, 0x65, 0x32, 0x62, 0x35, 0x65, 0x35, 0x37, 0x65, 0x33, 0x34, 0x38, 0x32, 0x36, 0x62, 0x37, 0x63, 0x66, 0x64, 0x38, 0x38, 0x38, 0x31, 0x62, 0x38, 0x35, 0x34, 0x36, 0x38, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x30, 0x31, 0x63, 0x30, 0x30, 0x66, 0x63, 0x31, 0x64, 0x62, 0x38, 0x38, 0x62, 0x36, 0x39, 0x63, 0x34, 0x62, 0x63, 0x33, 0x32, 0x35, 0x32, 0x62, 0x35, 0x63, 0x61, 0x37, 0x30, 0x65, 0x61, 0x36, 0x65, 0x65, 0x35, 0x63, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x36, 0x30, 0x62, 0x31, 0x63, 0x61, 0x64, 0x64, 0x33, 0x62, 0x35, 0x63, 0x31, 0x61, 0x38, 0x65, 0x36, 0x63, 0x62, 0x33, 0x61, 0x62, 0x63, 0x61, 0x66, 0x35, 0x32, 0x65, 0x65, 0x37, 0x63, 0x33, 0x64, 0x39, 0x66, 0x61, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x32, 0x37, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x65, 0x34, 0x35, 0x61, 0x31, 0x32, 0x61, 0x61, 0x37, 0x31, 0x31, 0x63, 0x37, 0x30, 0x39, 0x61, 0x63, 0x65, 0x66, 0x65, 0x39, 0x35, 0x66, 0x33, 0x33, 0x62, 0x37, 0x38, 0x36, 0x31, 0x32, 0x64, 0x32, 0x61, 0x64, 0x32, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x33, 0x32, 0x64, 0x66, 0x35, 0x30, 0x62, 0x31, 0x33, 0x63, 0x30, 0x31, 0x33, 0x34, 0x39, 0x30, 0x61, 0x35, 0x64, 0x37, 0x63, 0x37, 0x35, 0x64, 0x62, 0x66, 0x61, 0x33, 0x36, 0x36, 0x64, 0x61, 0x38, 0x37, 0x62, 0x36, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x36, 0x37, 0x63, 0x66, 0x30, 0x36, 0x34, 0x63, 0x30, 0x38, 0x37, 0x31, 0x39, 0x38, 0x39, 0x62, 0x39, 0x30, 0x64, 0x38, 0x62, 0x32, 0x65, 0x62, 0x31, 0x34, 0x63, 0x63, 0x63, 0x36, 0x33, 0x62, 0x33, 0x36, 0x30, 0x38, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x31, 0x34, 0x34, 0x62, 0x36, 0x37, 0x37, 0x63, 0x32, 0x64, 0x63, 0x36, 0x31, 0x34, 0x63, 0x65, 0x65, 0x66, 0x64, 0x66, 0x35, 0x30, 0x39, 0x38, 0x35, 0x66, 0x31, 0x31, 0x38, 0x33, 0x32, 0x30, 0x38, 0x65, 0x61, 0x36, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x37, 0x63, 0x34, 0x64, 0x36, 0x64, 0x63, 0x37, 0x32, 0x39, 0x63, 0x64, 0x36, 0x62, 0x31, 0x35, 0x37, 0x63, 0x30, 0x33, 0x61, 0x64, 0x32, 0x33, 0x37, 0x63, 0x61, 0x31, 0x39, 0x61, 0x32, 0x30, 0x39, 0x33, 0x34, 0x36, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x39, 0x64, 0x65, 0x34, 0x34, 0x37, 0x32, 0x34, 0x61, 0x34, 0x30, 0x35, 0x34, 0x64, 0x61, 0x30, 0x65, 0x61, 0x61, 0x36, 0x30, 0x35, 0x61, 0x62, 0x63, 0x63, 0x38, 0x30, 0x32, 0x36, 0x36, 0x38, 0x37, 0x37, 0x38, 0x62, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x31, 0x34, 0x30, 0x63, 0x38, 0x65, 0x35, 0x61, 0x34, 0x33, 0x30, 0x37, 0x66, 0x61, 0x62, 0x30, 0x63, 0x63, 0x32, 0x37, 0x62, 0x61, 0x64, 0x64, 0x39, 0x32, 0x39, 0x35, 0x30, 0x31, 0x38, 0x62, 0x66, 0x38, 0x37, 0x39, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x33, 0x61, 0x63, 0x64, 0x62, 0x33, 0x62, 0x61, 0x31, 0x61, 0x61, 0x62, 0x32, 0x37, 0x35, 0x30, 0x37, 0x62, 0x38, 0x36, 0x62, 0x31, 0x35, 0x64, 0x36, 0x37, 0x66, 0x61, 0x66, 0x39, 0x31, 0x65, 0x63, 0x66, 0x36, 0x32, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x32, 0x61, 0x30, 0x63, 0x39, 0x61, 0x62, 0x36, 0x34, 0x64, 0x66, 0x35, 0x38, 0x64, 0x64, 0x66, 0x62, 0x31, 0x64, 0x62, 0x61, 0x63, 0x66, 0x38, 0x62, 0x61, 0x30, 0x64, 0x38, 0x39, 0x63, 0x38, 0x35, 0x62, 0x33, 0x31, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x63, 0x62, 0x39, 0x37, 0x33, 0x30, 0x32, 0x34, 0x36, 0x33, 0x30, 0x34, 0x37, 0x30, 0x30, 0x64, 0x61, 0x39, 0x30, 0x62, 0x34, 0x31, 0x35, 0x33, 0x65, 0x37, 0x31, 0x31, 0x34, 0x31, 0x36, 0x32, 0x32, 0x65, 0x31, 0x63, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x64, 0x63, 0x38, 0x63, 0x38, 0x62, 0x39, 0x32, 0x37, 0x61, 0x64, 0x62, 0x65, 0x64, 0x66, 0x61, 0x38, 0x66, 0x35, 0x64, 0x36, 0x33, 0x39, 0x62, 0x34, 0x33, 0x35, 0x32, 0x33, 0x35, 0x31, 0x66, 0x32, 0x66, 0x33, 0x36, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x34, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x35, 0x33, 0x39, 0x31, 0x65, 0x39, 0x33, 0x38, 0x62, 0x33, 0x34, 0x38, 0x35, 0x38, 0x63, 0x66, 0x39, 0x36, 0x35, 0x62, 0x38, 0x34, 0x30, 0x35, 0x33, 0x31, 0x64, 0x35, 0x65, 0x66, 0x64, 0x61, 0x34, 0x31, 0x30, 0x62, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x35, 0x65, 0x32, 0x30, 0x31, 0x31, 0x65, 0x62, 0x63, 0x32, 0x35, 0x61, 0x30, 0x30, 0x37, 0x66, 0x32, 0x31, 0x33, 0x36, 0x32, 0x39, 0x36, 0x30, 0x34, 0x39, 0x38, 0x61, 0x66, 0x62, 0x38, 0x61, 0x66, 0x32, 0x38, 0x30, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x39, 0x66, 0x62, 0x31, 0x66, 0x35, 0x61, 0x66, 0x32, 0x66, 0x62, 0x66, 0x37, 0x66, 0x66, 0x63, 0x35, 0x30, 0x32, 0x39, 0x63, 0x65, 0x65, 0x34, 0x32, 0x62, 0x37, 0x30, 0x66, 0x66, 0x35, 0x63, 0x32, 0x37, 0x35, 0x62, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x32, 0x33, 0x32, 0x64, 0x30, 0x36, 0x38, 0x64, 0x35, 0x30, 0x30, 0x36, 0x34, 0x39, 0x30, 0x33, 0x63, 0x39, 0x65, 0x62, 0x63, 0x35, 0x36, 0x33, 0x62, 0x35, 0x31, 0x35, 0x61, 0x63, 0x63, 0x38, 0x62, 0x37, 0x62, 0x30, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x32, 0x37, 0x34, 0x66, 0x65, 0x61, 0x38, 0x32, 0x63, 0x64, 0x33, 0x30, 0x62, 0x36, 0x63, 0x32, 0x39, 0x62, 0x32, 0x33, 0x33, 0x35, 0x30, 0x65, 0x34, 0x66, 0x34, 0x66, 0x33, 0x64, 0x33, 0x31, 0x30, 0x61, 0x35, 0x38, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x62, 0x66, 0x62, 0x31, 0x62, 0x62, 0x34, 0x36, 0x34, 0x62, 0x38, 0x61, 0x35, 0x38, 0x65, 0x35, 0x30, 0x30, 0x64, 0x32, 0x65, 0x64, 0x38, 0x64, 0x65, 0x39, 0x37, 0x32, 0x63, 0x34, 0x35, 0x66, 0x35, 0x66, 0x31, 0x63, 0x30, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x66, 0x38, 0x64, 0x38, 0x62, 0x63, 0x66, 0x39, 0x30, 0x65, 0x37, 0x37, 0x37, 0x66, 0x31, 0x39, 0x62, 0x33, 0x61, 0x36, 0x34, 0x39, 0x37, 0x35, 0x39, 0x61, 0x64, 0x39, 0x35, 0x30, 0x32, 0x37, 0x61, 0x62, 0x64, 0x66, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x64, 0x32, 0x33, 0x35, 0x34, 0x37, 0x34, 0x37, 0x37, 0x66, 0x36, 0x64, 0x30, 0x39, 0x64, 0x37, 0x62, 0x32, 0x61, 0x30, 0x30, 0x35, 0x63, 0x35, 0x65, 0x65, 0x36, 0x35, 0x30, 0x63, 0x35, 0x31, 0x30, 0x63, 0x35, 0x36, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x33, 0x62, 0x38, 0x62, 0x35, 0x38, 0x61, 0x31, 0x32, 0x37, 0x30, 0x33, 0x65, 0x35, 0x38, 0x31, 0x63, 0x65, 0x35, 0x66, 0x66, 0x64, 0x37, 0x65, 0x32, 0x31, 0x63, 0x35, 0x37, 0x64, 0x31, 0x65, 0x35, 0x63, 0x36, 0x36, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x33, 0x31, 0x30, 0x62, 0x33, 0x61, 0x61, 0x38, 0x38, 0x37, 0x30, 0x33, 0x61, 0x37, 0x32, 0x35, 0x64, 0x66, 0x61, 0x35, 0x37, 0x64, 0x65, 0x36, 0x65, 0x36, 0x34, 0x36, 0x39, 0x33, 0x35, 0x31, 0x36, 0x34, 0x38, 0x30, 0x32, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x34, 0x31, 0x62, 0x31, 0x66, 0x62, 0x66, 0x35, 0x34, 0x32, 0x39, 0x38, 0x66, 0x35, 0x64, 0x30, 0x62, 0x63, 0x32, 0x64, 0x31, 0x32, 0x32, 0x66, 0x34, 0x65, 0x62, 0x39, 0x35, 0x64, 0x61, 0x34, 0x65, 0x35, 0x63, 0x64, 0x33, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x30, 0x62, 0x33, 0x36, 0x64, 0x31, 0x62, 0x65, 0x61, 0x66, 0x62, 0x61, 0x35, 0x66, 0x63, 0x63, 0x36, 0x34, 0x34, 0x64, 0x36, 0x30, 0x61, 0x63, 0x36, 0x65, 0x34, 0x36, 0x65, 0x64, 0x32, 0x39, 0x32, 0x37, 0x65, 0x37, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x61, 0x34, 0x39, 0x32, 0x62, 0x63, 0x65, 0x31, 0x61, 0x64, 0x31, 0x30, 0x37, 0x65, 0x33, 0x33, 0x37, 0x66, 0x34, 0x62, 0x64, 0x34, 0x61, 0x37, 0x61, 0x63, 0x39, 0x61, 0x37, 0x62, 0x61, 0x62, 0x63, 0x63, 0x63, 0x64, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x66, 0x30, 0x32, 0x33, 0x66, 0x65, 0x66, 0x32, 0x39, 0x30, 0x61, 0x34, 0x39, 0x62, 0x62, 0x37, 0x38, 0x62, 0x62, 0x37, 0x61, 0x62, 0x63, 0x39, 0x35, 0x64, 0x36, 0x36, 0x39, 0x63, 0x35, 0x30, 0x64, 0x35, 0x32, 0x38, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x62, 0x37, 0x39, 0x66, 0x33, 0x33, 0x38, 0x33, 0x39, 0x30, 0x64, 0x31, 0x62, 0x61, 0x31, 0x62, 0x33, 0x37, 0x33, 0x37, 0x61, 0x32, 0x39, 0x61, 0x30, 0x32, 0x35, 0x37, 0x65, 0x35, 0x64, 0x39, 0x31, 0x65, 0x30, 0x37, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x38, 0x32, 0x65, 0x34, 0x63, 0x32, 0x30, 0x34, 0x31, 0x30, 0x62, 0x39, 0x35, 0x31, 0x30, 0x38, 0x39, 0x65, 0x31, 0x39, 0x62, 0x61, 0x39, 0x36, 0x61, 0x32, 0x66, 0x65, 0x65, 0x33, 0x64, 0x39, 0x31, 0x63, 0x63, 0x65, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x34, 0x38, 0x37, 0x31, 0x33, 0x31, 0x34, 0x35, 0x65, 0x66, 0x38, 0x33, 0x63, 0x33, 0x66, 0x30, 0x65, 0x66, 0x34, 0x64, 0x33, 0x31, 0x64, 0x38, 0x32, 0x33, 0x37, 0x38, 0x36, 0x66, 0x37, 0x65, 0x39, 0x63, 0x63, 0x36, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x65, 0x32, 0x31, 0x39, 0x63, 0x38, 0x39, 0x63, 0x61, 0x38, 0x61, 0x63, 0x31, 0x34, 0x61, 0x65, 0x34, 0x63, 0x62, 0x61, 0x36, 0x31, 0x33, 0x30, 0x65, 0x65, 0x62, 0x37, 0x37, 0x64, 0x39, 0x65, 0x36, 0x64, 0x33, 0x39, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x39, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x39, 0x61, 0x30, 0x34, 0x32, 0x61, 0x36, 0x61, 0x38, 0x30, 0x36, 0x66, 0x66, 0x63, 0x39, 0x32, 0x31, 0x37, 0x39, 0x35, 0x30, 0x30, 0x64, 0x32, 0x34, 0x34, 0x32, 0x39, 0x65, 0x38, 0x61, 0x62, 0x35, 0x32, 0x38, 0x31, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x63, 0x39, 0x35, 0x39, 0x33, 0x62, 0x32, 0x64, 0x61, 0x36, 0x64, 0x66, 0x36, 0x61, 0x33, 0x34, 0x64, 0x37, 0x31, 0x62, 0x31, 0x61, 0x61, 0x33, 0x38, 0x64, 0x61, 0x63, 0x66, 0x38, 0x37, 0x36, 0x66, 0x39, 0x35, 0x62, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x34, 0x33, 0x38, 0x32, 0x36, 0x37, 0x32, 0x33, 0x31, 0x37, 0x30, 0x34, 0x66, 0x63, 0x37, 0x32, 0x38, 0x30, 0x64, 0x35, 0x36, 0x33, 0x61, 0x64, 0x66, 0x34, 0x37, 0x36, 0x33, 0x38, 0x34, 0x34, 0x61, 0x38, 0x30, 0x37, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x38, 0x39, 0x65, 0x31, 0x61, 0x62, 0x35, 0x65, 0x37, 0x63, 0x64, 0x30, 0x30, 0x37, 0x34, 0x36, 0x62, 0x33, 0x39, 0x33, 0x38, 0x65, 0x66, 0x30, 0x66, 0x30, 0x64, 0x30, 0x36, 0x34, 0x61, 0x32, 0x30, 0x32, 0x35, 0x62, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x34, 0x62, 0x36, 0x30, 0x66, 0x61, 0x65, 0x63, 0x37, 0x34, 0x30, 0x61, 0x32, 0x31, 0x65, 0x33, 0x30, 0x37, 0x31, 0x33, 0x39, 0x31, 0x66, 0x39, 0x36, 0x61, 0x61, 0x35, 0x33, 0x34, 0x66, 0x37, 0x63, 0x31, 0x66, 0x34, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x37, 0x63, 0x62, 0x34, 0x65, 0x34, 0x38, 0x62, 0x32, 0x35, 0x30, 0x33, 0x31, 0x61, 0x61, 0x31, 0x63, 0x34, 0x66, 0x39, 0x32, 0x39, 0x32, 0x35, 0x64, 0x36, 0x33, 0x31, 0x61, 0x38, 0x63, 0x33, 0x65, 0x64, 0x63, 0x37, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x32, 0x37, 0x38, 0x38, 0x62, 0x35, 0x65, 0x32, 0x39, 0x62, 0x66, 0x34, 0x66, 0x35, 0x66, 0x35, 0x35, 0x61, 0x65, 0x31, 0x64, 0x64, 0x62, 0x33, 0x32, 0x30, 0x38, 0x35, 0x66, 0x64, 0x61, 0x39, 0x31, 0x62, 0x38, 0x65, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x35, 0x65, 0x31, 0x38, 0x32, 0x63, 0x34, 0x66, 0x62, 0x62, 0x61, 0x64, 0x37, 0x39, 0x62, 0x64, 0x39, 0x33, 0x33, 0x34, 0x32, 0x32, 0x34, 0x32, 0x64, 0x34, 0x64, 0x63, 0x63, 0x66, 0x32, 0x62, 0x65, 0x35, 0x38, 0x39, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x34, 0x38, 0x62, 0x37, 0x37, 0x30, 0x61, 0x35, 0x31, 0x31, 0x38, 0x65, 0x64, 0x65, 0x38, 0x37, 0x64, 0x62, 0x61, 0x32, 0x66, 0x36, 0x39, 0x30, 0x33, 0x33, 0x37, 0x66, 0x36, 0x31, 0x36, 0x64, 0x65, 0x36, 0x38, 0x33, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x32, 0x37, 0x35, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x63, 0x32, 0x64, 0x38, 0x33, 0x35, 0x66, 0x31, 0x33, 0x65, 0x65, 0x39, 0x30, 0x35, 0x38, 0x30, 0x34, 0x30, 0x38, 0x65, 0x36, 0x61, 0x33, 0x32, 0x38, 0x33, 0x63, 0x38, 0x63, 0x63, 0x61, 0x36, 0x61, 0x34, 0x33, 0x34, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x65, 0x34, 0x33, 0x38, 0x30, 0x61, 0x33, 0x62, 0x31, 0x66, 0x37, 0x34, 0x39, 0x36, 0x37, 0x33, 0x65, 0x32, 0x37, 0x30, 0x32, 0x32, 0x39, 0x39, 0x39, 0x33, 0x65, 0x65, 0x35, 0x35, 0x66, 0x33, 0x35, 0x36, 0x36, 0x33, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x36, 0x37, 0x35, 0x65, 0x35, 0x36, 0x34, 0x37, 0x62, 0x39, 0x64, 0x38, 0x64, 0x61, 0x66, 0x34, 0x64, 0x33, 0x64, 0x66, 0x66, 0x31, 0x65, 0x35, 0x35, 0x32, 0x66, 0x36, 0x62, 0x30, 0x37, 0x31, 0x35, 0x34, 0x61, 0x63, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x32, 0x63, 0x31, 0x65, 0x33, 0x34, 0x30, 0x36, 0x34, 0x66, 0x30, 0x34, 0x37, 0x35, 0x66, 0x37, 0x66, 0x61, 0x38, 0x33, 0x31, 0x63, 0x63, 0x62, 0x32, 0x35, 0x30, 0x31, 0x34, 0x63, 0x33, 0x61, 0x61, 0x33, 0x31, 0x63, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x37, 0x63, 0x37, 0x35, 0x34, 0x33, 0x30, 0x64, 0x65, 0x34, 0x30, 0x31, 0x63, 0x33, 0x34, 0x31, 0x30, 0x33, 0x32, 0x36, 0x38, 0x36, 0x31, 0x31, 0x32, 0x37, 0x39, 0x30, 0x66, 0x34, 0x36, 0x64, 0x34, 0x64, 0x33, 0x36, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x36, 0x38, 0x31, 0x64, 0x39, 0x39, 0x31, 0x32, 0x64, 0x64, 0x64, 0x30, 0x37, 0x65, 0x61, 0x61, 0x62, 0x62, 0x38, 0x38, 0x64, 0x30, 0x35, 0x64, 0x39, 0x30, 0x66, 0x37, 0x36, 0x36, 0x65, 0x38, 0x36, 0x32, 0x34, 0x31, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x34, 0x64, 0x64, 0x61, 0x34, 0x32, 0x31, 0x64, 0x63, 0x31, 0x65, 0x62, 0x37, 0x33, 0x62, 0x62, 0x32, 0x34, 0x65, 0x33, 0x65, 0x35, 0x36, 0x61, 0x32, 0x34, 0x38, 0x30, 0x31, 0x33, 0x62, 0x38, 0x37, 0x63, 0x30, 0x66, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x62, 0x39, 0x37, 0x65, 0x38, 0x64, 0x35, 0x39, 0x65, 0x65, 0x65, 0x36, 0x34, 0x38, 0x61, 0x62, 0x36, 0x63, 0x61, 0x66, 0x38, 0x36, 0x39, 0x36, 0x66, 0x38, 0x39, 0x39, 0x33, 0x37, 0x31, 0x34, 0x33, 0x38, 0x36, 0x34, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x63, 0x31, 0x33, 0x30, 0x63, 0x37, 0x36, 0x32, 0x62, 0x38, 0x37, 0x36, 0x35, 0x62, 0x31, 0x39, 0x64, 0x32, 0x61, 0x62, 0x63, 0x39, 0x61, 0x30, 0x38, 0x33, 0x61, 0x62, 0x38, 0x66, 0x33, 0x61, 0x61, 0x64, 0x37, 0x39, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x36, 0x35, 0x30, 0x64, 0x36, 0x39, 0x38, 0x39, 0x66, 0x31, 0x39, 0x39, 0x61, 0x62, 0x31, 0x63, 0x63, 0x34, 0x37, 0x39, 0x36, 0x33, 0x36, 0x64, 0x65, 0x64, 0x33, 0x30, 0x66, 0x32, 0x34, 0x31, 0x30, 0x32, 0x31, 0x66, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x63, 0x39, 0x36, 0x65, 0x37, 0x30, 0x66, 0x30, 0x35, 0x61, 0x65, 0x30, 0x65, 0x36, 0x63, 0x64, 0x36, 0x30, 0x32, 0x31, 0x62, 0x32, 0x30, 0x38, 0x33, 0x37, 0x35, 0x30, 0x61, 0x37, 0x37, 0x31, 0x37, 0x63, 0x64, 0x65, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x31, 0x30, 0x36, 0x63, 0x32, 0x37, 0x64, 0x32, 0x30, 0x62, 0x37, 0x34, 0x62, 0x34, 0x62, 0x39, 0x38, 0x63, 0x61, 0x36, 0x32, 0x62, 0x32, 0x33, 0x32, 0x62, 0x64, 0x35, 0x63, 0x39, 0x37, 0x34, 0x31, 0x31, 0x31, 0x37, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x61, 0x62, 0x36, 0x36, 0x30, 0x38, 0x33, 0x61, 0x34, 0x66, 0x61, 0x32, 0x33, 0x38, 0x34, 0x38, 0x62, 0x38, 0x38, 0x36, 0x66, 0x39, 0x65, 0x36, 0x36, 0x64, 0x37, 0x39, 0x63, 0x64, 0x63, 0x31, 0x35, 0x30, 0x63, 0x63, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x38, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x36, 0x31, 0x35, 0x36, 0x33, 0x33, 0x36, 0x62, 0x65, 0x32, 0x63, 0x64, 0x62, 0x65, 0x33, 0x32, 0x31, 0x34, 0x30, 0x64, 0x66, 0x30, 0x38, 0x61, 0x32, 0x62, 0x61, 0x35, 0x35, 0x66, 0x64, 0x30, 0x61, 0x35, 0x38, 0x34, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x34, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x38, 0x32, 0x64, 0x37, 0x36, 0x61, 0x31, 0x35, 0x66, 0x38, 0x34, 0x37, 0x64, 0x64, 0x34, 0x31, 0x66, 0x31, 0x39, 0x32, 0x32, 0x61, 0x66, 0x33, 0x36, 0x38, 0x66, 0x65, 0x36, 0x37, 0x38, 0x64, 0x30, 0x65, 0x36, 0x38, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x39, 0x65, 0x38, 0x65, 0x32, 0x39, 0x64, 0x33, 0x33, 0x62, 0x65, 0x61, 0x65, 0x38, 0x66, 0x62, 0x36, 0x62, 0x61, 0x61, 0x37, 0x38, 0x33, 0x64, 0x31, 0x33, 0x33, 0x65, 0x31, 0x64, 0x39, 0x65, 0x63, 0x31, 0x62, 0x63, 0x30, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x32, 0x35, 0x36, 0x37, 0x34, 0x63, 0x30, 0x31, 0x65, 0x33, 0x66, 0x37, 0x32, 0x39, 0x30, 0x64, 0x35, 0x32, 0x32, 0x36, 0x33, 0x33, 0x39, 0x66, 0x62, 0x65, 0x61, 0x63, 0x36, 0x37, 0x64, 0x32, 0x32, 0x31, 0x32, 0x37, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x30, 0x63, 0x39, 0x61, 0x39, 0x39, 0x62, 0x37, 0x34, 0x37, 0x35, 0x39, 0x64, 0x37, 0x38, 0x32, 0x66, 0x32, 0x35, 0x63, 0x31, 0x63, 0x65, 0x63, 0x61, 0x38, 0x30, 0x32, 0x61, 0x32, 0x37, 0x65, 0x30, 0x62, 0x34, 0x33, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x62, 0x66, 0x38, 0x34, 0x64, 0x35, 0x61, 0x62, 0x30, 0x32, 0x36, 0x66, 0x35, 0x38, 0x63, 0x38, 0x37, 0x33, 0x66, 0x38, 0x36, 0x66, 0x66, 0x30, 0x64, 0x66, 0x63, 0x61, 0x38, 0x32, 0x62, 0x35, 0x35, 0x37, 0x33, 0x33, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x37, 0x33, 0x34, 0x61, 0x30, 0x61, 0x38, 0x31, 0x63, 0x39, 0x35, 0x36, 0x32, 0x66, 0x34, 0x64, 0x39, 0x65, 0x39, 0x65, 0x31, 0x30, 0x61, 0x38, 0x35, 0x30, 0x33, 0x64, 0x61, 0x31, 0x35, 0x64, 0x62, 0x34, 0x36, 0x64, 0x37, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x32, 0x31, 0x62, 0x63, 0x33, 0x61, 0x39, 0x66, 0x38, 0x37, 0x31, 0x31, 0x66, 0x65, 0x63, 0x62, 0x31, 0x30, 0x66, 0x35, 0x30, 0x37, 0x39, 0x37, 0x64, 0x37, 0x31, 0x30, 0x38, 0x33, 0x65, 0x33, 0x34, 0x31, 0x65, 0x62, 0x39, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x30, 0x31, 0x64, 0x39, 0x63, 0x61, 0x32, 0x66, 0x33, 0x62, 0x66, 0x65, 0x30, 0x32, 0x36, 0x32, 0x37, 0x39, 0x63, 0x64, 0x36, 0x38, 0x31, 0x39, 0x66, 0x37, 0x39, 0x61, 0x32, 0x39, 0x33, 0x64, 0x39, 0x38, 0x31, 0x35, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x34, 0x39, 0x64, 0x35, 0x31, 0x61, 0x66, 0x32, 0x39, 0x66, 0x37, 0x32, 0x34, 0x63, 0x39, 0x36, 0x37, 0x66, 0x35, 0x39, 0x34, 0x32, 0x33, 0x62, 0x38, 0x35, 0x62, 0x32, 0x36, 0x38, 0x31, 0x65, 0x37, 0x62, 0x31, 0x35, 0x31, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x35, 0x33, 0x61, 0x63, 0x39, 0x37, 0x35, 0x34, 0x38, 0x61, 0x30, 0x63, 0x34, 0x65, 0x38, 0x62, 0x38, 0x30, 0x62, 0x63, 0x37, 0x32, 0x35, 0x39, 0x30, 0x63, 0x64, 0x36, 0x61, 0x30, 0x39, 0x38, 0x66, 0x65, 0x37, 0x35, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x33, 0x32, 0x31, 0x66, 0x64, 0x62, 0x64, 0x34, 0x34, 0x39, 0x31, 0x38, 0x30, 0x64, 0x62, 0x38, 0x64, 0x64, 0x64, 0x33, 0x34, 0x66, 0x30, 0x66, 0x65, 0x39, 0x30, 0x36, 0x65, 0x63, 0x31, 0x38, 0x65, 0x65, 0x30, 0x39, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x37, 0x66, 0x35, 0x35, 0x35, 0x33, 0x36, 0x62, 0x66, 0x38, 0x35, 0x61, 0x64, 0x61, 0x35, 0x31, 0x38, 0x34, 0x31, 0x66, 0x30, 0x32, 0x38, 0x37, 0x36, 0x32, 0x33, 0x61, 0x39, 0x66, 0x30, 0x65, 0x64, 0x30, 0x39, 0x61, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x35, 0x37, 0x33, 0x35, 0x33, 0x61, 0x61, 0x66, 0x66, 0x32, 0x61, 0x61, 0x64, 0x62, 0x30, 0x61, 0x30, 0x34, 0x66, 0x39, 0x30, 0x31, 0x34, 0x65, 0x38, 0x64, 0x61, 0x37, 0x38, 0x38, 0x34, 0x65, 0x38, 0x36, 0x35, 0x38, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x30, 0x37, 0x64, 0x64, 0x63, 0x38, 0x38, 0x64, 0x62, 0x34, 0x38, 0x39, 0x62, 0x30, 0x33, 0x33, 0x65, 0x36, 0x62, 0x32, 0x66, 0x39, 0x61, 0x38, 0x31, 0x35, 0x35, 0x33, 0x35, 0x37, 0x31, 0x61, 0x62, 0x33, 0x63, 0x38, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x30, 0x35, 0x37, 0x61, 0x66, 0x39, 0x61, 0x61, 0x36, 0x36, 0x33, 0x30, 0x37, 0x65, 0x63, 0x39, 0x66, 0x30, 0x33, 0x33, 0x62, 0x32, 0x39, 0x37, 0x32, 0x34, 0x64, 0x33, 0x62, 0x32, 0x66, 0x34, 0x31, 0x65, 0x62, 0x36, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x31, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x66, 0x38, 0x33, 0x36, 0x62, 0x36, 0x66, 0x35, 0x37, 0x62, 0x39, 0x30, 0x31, 0x62, 0x34, 0x34, 0x30, 0x63, 0x33, 0x30, 0x65, 0x34, 0x64, 0x62, 0x64, 0x30, 0x36, 0x35, 0x63, 0x66, 0x33, 0x37, 0x64, 0x33, 0x64, 0x34, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x30, 0x35, 0x31, 0x37, 0x36, 0x34, 0x61, 0x66, 0x36, 0x62, 0x38, 0x30, 0x38, 0x65, 0x34, 0x32, 0x31, 0x32, 0x63, 0x37, 0x37, 0x65, 0x33, 0x30, 0x61, 0x35, 0x35, 0x37, 0x32, 0x65, 0x61, 0x61, 0x33, 0x31, 0x37, 0x30, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x61, 0x61, 0x33, 0x30, 0x63, 0x33, 0x31, 0x35, 0x31, 0x39, 0x62, 0x35, 0x38, 0x34, 0x65, 0x39, 0x37, 0x32, 0x35, 0x30, 0x65, 0x64, 0x32, 0x61, 0x33, 0x63, 0x66, 0x33, 0x33, 0x38, 0x35, 0x65, 0x64, 0x35, 0x66, 0x64, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x38, 0x34, 0x32, 0x63, 0x61, 0x32, 0x63, 0x35, 0x65, 0x66, 0x31, 0x33, 0x33, 0x39, 0x31, 0x37, 0x61, 0x32, 0x33, 0x36, 0x61, 0x30, 0x64, 0x34, 0x61, 0x63, 0x34, 0x30, 0x36, 0x39, 0x30, 0x31, 0x31, 0x30, 0x62, 0x30, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x31, 0x36, 0x37, 0x30, 0x32, 0x36, 0x64, 0x33, 0x39, 0x61, 0x62, 0x37, 0x61, 0x38, 0x35, 0x36, 0x33, 0x35, 0x39, 0x34, 0x34, 0x65, 0x64, 0x39, 0x65, 0x64, 0x62, 0x32, 0x62, 0x66, 0x65, 0x62, 0x61, 0x31, 0x31, 0x38, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x62, 0x65, 0x65, 0x61, 0x37, 0x31, 0x36, 0x63, 0x62, 0x64, 0x38, 0x31, 0x37, 0x30, 0x30, 0x61, 0x37, 0x33, 0x64, 0x36, 0x37, 0x66, 0x39, 0x66, 0x66, 0x30, 0x33, 0x39, 0x35, 0x32, 0x39, 0x63, 0x32, 0x64, 0x39, 0x30, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x34, 0x62, 0x37, 0x65, 0x38, 0x30, 0x38, 0x37, 0x39, 0x39, 0x61, 0x38, 0x33, 0x64, 0x37, 0x32, 0x38, 0x37, 0x63, 0x36, 0x37, 0x37, 0x30, 0x36, 0x66, 0x32, 0x61, 0x62, 0x66, 0x34, 0x39, 0x61, 0x34, 0x39, 0x36, 0x34, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x65, 0x38, 0x66, 0x30, 0x63, 0x33, 0x31, 0x62, 0x37, 0x34, 0x31, 0x35, 0x35, 0x31, 0x31, 0x64, 0x63, 0x65, 0x64, 0x31, 0x63, 0x64, 0x37, 0x64, 0x34, 0x36, 0x33, 0x32, 0x33, 0x65, 0x34, 0x62, 0x64, 0x31, 0x32, 0x32, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x36, 0x37, 0x66, 0x61, 0x31, 0x31, 0x35, 0x35, 0x66, 0x65, 0x64, 0x37, 0x33, 0x32, 0x63, 0x66, 0x62, 0x38, 0x64, 0x63, 0x61, 0x35, 0x61, 0x30, 0x64, 0x37, 0x36, 0x35, 0x63, 0x65, 0x30, 0x64, 0x30, 0x37, 0x30, 0x35, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x31, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x35, 0x35, 0x32, 0x36, 0x35, 0x36, 0x38, 0x61, 0x63, 0x31, 0x32, 0x33, 0x61, 0x66, 0x63, 0x30, 0x65, 0x38, 0x34, 0x61, 0x61, 0x37, 0x31, 0x35, 0x31, 0x32, 0x34, 0x66, 0x65, 0x62, 0x65, 0x38, 0x33, 0x64, 0x63, 0x38, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x65, 0x39, 0x38, 0x37, 0x36, 0x36, 0x35, 0x32, 0x34, 0x62, 0x30, 0x63, 0x66, 0x32, 0x37, 0x34, 0x37, 0x63, 0x35, 0x30, 0x64, 0x64, 0x34, 0x33, 0x62, 0x39, 0x35, 0x36, 0x37, 0x35, 0x39, 0x34, 0x64, 0x39, 0x37, 0x33, 0x31, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x36, 0x64, 0x66, 0x32, 0x30, 0x37, 0x35, 0x65, 0x62, 0x64, 0x32, 0x34, 0x30, 0x64, 0x34, 0x34, 0x38, 0x36, 0x39, 0x63, 0x32, 0x62, 0x65, 0x36, 0x62, 0x64, 0x66, 0x38, 0x32, 0x65, 0x36, 0x33, 0x64, 0x34, 0x65, 0x66, 0x31, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x66, 0x35, 0x63, 0x61, 0x62, 0x31, 0x32, 0x63, 0x30, 0x64, 0x39, 0x35, 0x37, 0x66, 0x64, 0x33, 0x33, 0x33, 0x66, 0x33, 0x38, 0x32, 0x65, 0x65, 0x62, 0x37, 0x35, 0x31, 0x30, 0x37, 0x61, 0x36, 0x34, 0x63, 0x62, 0x38, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x35, 0x35, 0x65, 0x66, 0x64, 0x32, 0x36, 0x30, 0x32, 0x39, 0x65, 0x30, 0x64, 0x31, 0x31, 0x62, 0x39, 0x33, 0x30, 0x64, 0x66, 0x34, 0x66, 0x35, 0x33, 0x62, 0x31, 0x36, 0x32, 0x63, 0x38, 0x63, 0x33, 0x66, 0x64, 0x32, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x63, 0x35, 0x33, 0x65, 0x66, 0x61, 0x33, 0x33, 0x66, 0x65, 0x34, 0x61, 0x33, 0x61, 0x31, 0x61, 0x38, 0x30, 0x32, 0x30, 0x35, 0x63, 0x37, 0x33, 0x65, 0x63, 0x33, 0x62, 0x31, 0x64, 0x62, 0x63, 0x61, 0x64, 0x30, 0x36, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x38, 0x35, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x36, 0x62, 0x33, 0x37, 0x35, 0x39, 0x65, 0x38, 0x37, 0x39, 0x34, 0x65, 0x39, 0x32, 0x36, 0x64, 0x61, 0x63, 0x34, 0x37, 0x33, 0x64, 0x39, 0x31, 0x33, 0x61, 0x38, 0x66, 0x62, 0x36, 0x31, 0x61, 0x64, 0x30, 0x63, 0x32, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x32, 0x61, 0x61, 0x37, 0x39, 0x38, 0x62, 0x66, 0x34, 0x31, 0x64, 0x66, 0x31, 0x37, 0x39, 0x66, 0x38, 0x35, 0x35, 0x32, 0x30, 0x31, 0x33, 0x30, 0x66, 0x31, 0x35, 0x63, 0x63, 0x64, 0x66, 0x35, 0x39, 0x62, 0x35, 0x65, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x30, 0x62, 0x32, 0x33, 0x64, 0x33, 0x38, 0x30, 0x62, 0x38, 0x32, 0x35, 0x63, 0x34, 0x36, 0x65, 0x30, 0x33, 0x39, 0x33, 0x38, 0x39, 0x39, 0x61, 0x38, 0x35, 0x35, 0x35, 0x36, 0x34, 0x36, 0x32, 0x64, 0x61, 0x30, 0x65, 0x31, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x31, 0x66, 0x34, 0x36, 0x36, 0x33, 0x61, 0x62, 0x34, 0x34, 0x66, 0x66, 0x37, 0x39, 0x33, 0x34, 0x35, 0x66, 0x34, 0x32, 0x37, 0x61, 0x30, 0x66, 0x36, 0x66, 0x38, 0x61, 0x36, 0x63, 0x38, 0x61, 0x35, 0x33, 0x66, 0x66, 0x32, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x35, 0x65, 0x66, 0x31, 0x37, 0x32, 0x62, 0x66, 0x37, 0x37, 0x33, 0x31, 0x35, 0x65, 0x61, 0x36, 0x34, 0x65, 0x38, 0x35, 0x64, 0x30, 0x30, 0x36, 0x31, 0x39, 0x38, 0x36, 0x63, 0x37, 0x39, 0x34, 0x63, 0x36, 0x66, 0x35, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x61, 0x63, 0x35, 0x34, 0x37, 0x30, 0x31, 0x37, 0x31, 0x33, 0x34, 0x63, 0x30, 0x34, 0x61, 0x65, 0x31, 0x65, 0x31, 0x31, 0x64, 0x36, 0x30, 0x65, 0x36, 0x33, 0x65, 0x63, 0x30, 0x34, 0x64, 0x31, 0x38, 0x64, 0x62, 0x34, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x31, 0x62, 0x30, 0x63, 0x62, 0x34, 0x36, 0x61, 0x61, 0x65, 0x63, 0x66, 0x64, 0x37, 0x39, 0x62, 0x38, 0x38, 0x30, 0x63, 0x61, 0x64, 0x30, 0x66, 0x32, 0x64, 0x64, 0x61, 0x38, 0x61, 0x38, 0x64, 0x65, 0x64, 0x64, 0x30, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x34, 0x30, 0x38, 0x62, 0x34, 0x64, 0x37, 0x61, 0x32, 0x63, 0x30, 0x65, 0x36, 0x65, 0x63, 0x61, 0x34, 0x31, 0x34, 0x33, 0x66, 0x32, 0x63, 0x61, 0x63, 0x64, 0x62, 0x62, 0x63, 0x63, 0x62, 0x61, 0x31, 0x32, 0x31, 0x62, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x35, 0x32, 0x36, 0x61, 0x31, 0x34, 0x30, 0x36, 0x38, 0x33, 0x65, 0x64, 0x66, 0x31, 0x34, 0x33, 0x31, 0x63, 0x66, 0x61, 0x61, 0x31, 0x32, 0x38, 0x61, 0x39, 0x33, 0x35, 0x65, 0x32, 0x62, 0x36, 0x31, 0x34, 0x64, 0x38, 0x38, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x39, 0x37, 0x32, 0x38, 0x61, 0x37, 0x38, 0x36, 0x31, 0x38, 0x64, 0x31, 0x61, 0x31, 0x37, 0x62, 0x39, 0x65, 0x33, 0x34, 0x65, 0x30, 0x66, 0x65, 0x64, 0x38, 0x65, 0x38, 0x35, 0x37, 0x64, 0x35, 0x63, 0x34, 0x30, 0x36, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x63, 0x34, 0x64, 0x34, 0x62, 0x65, 0x32, 0x64, 0x62, 0x30, 0x64, 0x39, 0x39, 0x64, 0x61, 0x33, 0x66, 0x61, 0x61, 0x61, 0x66, 0x37, 0x35, 0x32, 0x35, 0x61, 0x66, 0x32, 0x38, 0x32, 0x30, 0x35, 0x31, 0x64, 0x36, 0x61, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x38, 0x35, 0x63, 0x38, 0x65, 0x61, 0x37, 0x37, 0x34, 0x64, 0x37, 0x33, 0x30, 0x34, 0x34, 0x61, 0x37, 0x33, 0x34, 0x66, 0x61, 0x37, 0x39, 0x30, 0x61, 0x31, 0x62, 0x31, 0x65, 0x37, 0x34, 0x33, 0x65, 0x37, 0x37, 0x65, 0x64, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x33, 0x38, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x32, 0x37, 0x32, 0x36, 0x32, 0x39, 0x34, 0x31, 0x34, 0x38, 0x62, 0x38, 0x36, 0x63, 0x37, 0x38, 0x61, 0x39, 0x33, 0x37, 0x32, 0x34, 0x39, 0x37, 0x65, 0x34, 0x35, 0x39, 0x38, 0x39, 0x38, 0x65, 0x64, 0x33, 0x66, 0x65, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x61, 0x38, 0x36, 0x63, 0x34, 0x30, 0x32, 0x33, 0x38, 0x38, 0x66, 0x64, 0x64, 0x63, 0x35, 0x39, 0x30, 0x32, 0x38, 0x66, 0x65, 0x63, 0x37, 0x30, 0x32, 0x31, 0x65, 0x39, 0x38, 0x63, 0x62, 0x66, 0x38, 0x33, 0x30, 0x65, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x32, 0x31, 0x61, 0x66, 0x33, 0x39, 0x38, 0x61, 0x35, 0x62, 0x32, 0x64, 0x61, 0x36, 0x39, 0x66, 0x36, 0x35, 0x63, 0x36, 0x33, 0x38, 0x31, 0x61, 0x65, 0x63, 0x38, 0x38, 0x63, 0x65, 0x39, 0x63, 0x63, 0x36, 0x34, 0x34, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x36, 0x36, 0x38, 0x36, 0x62, 0x30, 0x66, 0x31, 0x37, 0x65, 0x30, 0x37, 0x65, 0x64, 0x66, 0x63, 0x35, 0x39, 0x62, 0x37, 0x35, 0x39, 0x63, 0x37, 0x37, 0x64, 0x35, 0x62, 0x65, 0x66, 0x31, 0x36, 0x34, 0x64, 0x33, 0x38, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x64, 0x33, 0x38, 0x64, 0x65, 0x31, 0x63, 0x37, 0x33, 0x39, 0x30, 0x36, 0x66, 0x36, 0x61, 0x37, 0x63, 0x61, 0x36, 0x65, 0x66, 0x65, 0x62, 0x39, 0x37, 0x63, 0x66, 0x36, 0x66, 0x36, 0x39, 0x63, 0x63, 0x34, 0x32, 0x31, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x33, 0x66, 0x39, 0x38, 0x61, 0x34, 0x34, 0x33, 0x65, 0x66, 0x65, 0x30, 0x30, 0x66, 0x33, 0x65, 0x37, 0x31, 0x31, 0x64, 0x35, 0x32, 0x35, 0x64, 0x39, 0x38, 0x39, 0x34, 0x64, 0x63, 0x39, 0x61, 0x36, 0x31, 0x31, 0x35, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x31, 0x63, 0x38, 0x61, 0x30, 0x34, 0x63, 0x39, 0x30, 0x64, 0x37, 0x33, 0x35, 0x62, 0x38, 0x61, 0x31, 0x35, 0x32, 0x39, 0x30, 0x39, 0x61, 0x65, 0x61, 0x65, 0x36, 0x33, 0x36, 0x66, 0x62, 0x30, 0x63, 0x65, 0x31, 0x36, 0x36, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x39, 0x39, 0x39, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x38, 0x37, 0x63, 0x65, 0x63, 0x30, 0x30, 0x35, 0x39, 0x30, 0x38, 0x37, 0x66, 0x64, 0x63, 0x37, 0x31, 0x33, 0x64, 0x34, 0x64, 0x32, 0x64, 0x36, 0x35, 0x65, 0x37, 0x37, 0x64, 0x61, 0x65, 0x66, 0x65, 0x64, 0x63, 0x31, 0x35, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x35, 0x32, 0x30, 0x33, 0x37, 0x35, 0x30, 0x66, 0x37, 0x31, 0x34, 0x38, 0x61, 0x39, 0x61, 0x61, 0x32, 0x36, 0x32, 0x39, 0x32, 0x31, 0x65, 0x38, 0x36, 0x64, 0x34, 0x33, 0x62, 0x66, 0x36, 0x34, 0x31, 0x39, 0x37, 0x34, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x34, 0x36, 0x34, 0x61, 0x36, 0x38, 0x30, 0x35, 0x62, 0x34, 0x36, 0x32, 0x34, 0x31, 0x32, 0x61, 0x39, 0x30, 0x31, 0x64, 0x32, 0x64, 0x62, 0x38, 0x31, 0x37, 0x34, 0x62, 0x30, 0x36, 0x63, 0x32, 0x32, 0x64, 0x65, 0x65, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x33, 0x34, 0x37, 0x31, 0x63, 0x64, 0x39, 0x61, 0x34, 0x31, 0x39, 0x32, 0x35, 0x62, 0x33, 0x39, 0x30, 0x34, 0x61, 0x35, 0x61, 0x38, 0x66, 0x66, 0x63, 0x61, 0x33, 0x36, 0x35, 0x39, 0x65, 0x30, 0x33, 0x34, 0x62, 0x65, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x31, 0x66, 0x66, 0x32, 0x33, 0x33, 0x65, 0x31, 0x61, 0x32, 0x31, 0x31, 0x63, 0x30, 0x31, 0x37, 0x32, 0x63, 0x39, 0x32, 0x62, 0x34, 0x36, 0x63, 0x66, 0x39, 0x39, 0x37, 0x30, 0x33, 0x30, 0x35, 0x38, 0x32, 0x63, 0x38, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x33, 0x30, 0x62, 0x32, 0x37, 0x61, 0x37, 0x38, 0x38, 0x37, 0x36, 0x34, 0x38, 0x35, 0x64, 0x30, 0x66, 0x34, 0x38, 0x62, 0x37, 0x30, 0x64, 0x64, 0x35, 0x33, 0x33, 0x36, 0x35, 0x34, 0x39, 0x36, 0x37, 0x39, 0x63, 0x61, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x61, 0x39, 0x62, 0x32, 0x31, 0x62, 0x33, 0x35, 0x31, 0x30, 0x36, 0x62, 0x65, 0x31, 0x35, 0x39, 0x64, 0x31, 0x63, 0x31, 0x63, 0x32, 0x36, 0x35, 0x37, 0x61, 0x63, 0x35, 0x36, 0x63, 0x64, 0x32, 0x39, 0x66, 0x66, 0x64, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x61, 0x63, 0x32, 0x62, 0x34, 0x34, 0x30, 0x38, 0x65, 0x66, 0x35, 0x34, 0x33, 0x31, 0x61, 0x31, 0x33, 0x62, 0x38, 0x35, 0x30, 0x38, 0x65, 0x38, 0x36, 0x32, 0x35, 0x30, 0x39, 0x38, 0x32, 0x31, 0x31, 0x34, 0x65, 0x31, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x31, 0x64, 0x66, 0x33, 0x34, 0x64, 0x31, 0x32, 0x32, 0x35, 0x62, 0x63, 0x64, 0x34, 0x32, 0x32, 0x34, 0x65, 0x36, 0x33, 0x36, 0x38, 0x30, 0x64, 0x35, 0x63, 0x34, 0x63, 0x30, 0x39, 0x62, 0x63, 0x65, 0x37, 0x33, 0x35, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x65, 0x62, 0x36, 0x66, 0x64, 0x38, 0x35, 0x36, 0x37, 0x31, 0x61, 0x39, 0x30, 0x36, 0x33, 0x61, 0x62, 0x37, 0x36, 0x37, 0x38, 0x65, 0x62, 0x65, 0x32, 0x36, 0x35, 0x61, 0x32, 0x30, 0x66, 0x36, 0x31, 0x61, 0x30, 0x32, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x32, 0x61, 0x66, 0x33, 0x64, 0x33, 0x65, 0x38, 0x64, 0x30, 0x37, 0x35, 0x33, 0x34, 0x34, 0x39, 0x32, 0x36, 0x35, 0x34, 0x36, 0x66, 0x32, 0x65, 0x33, 0x32, 0x38, 0x38, 0x37, 0x62, 0x66, 0x39, 0x33, 0x62, 0x31, 0x36, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x36, 0x31, 0x66, 0x61, 0x32, 0x33, 0x30, 0x63, 0x39, 0x30, 0x31, 0x64, 0x34, 0x33, 0x66, 0x66, 0x35, 0x37, 0x39, 0x66, 0x34, 0x37, 0x38, 0x30, 0x64, 0x33, 0x39, 0x39, 0x66, 0x33, 0x31, 0x65, 0x36, 0x30, 0x37, 0x36, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x61, 0x37, 0x34, 0x63, 0x65, 0x65, 0x63, 0x66, 0x66, 0x36, 0x35, 0x63, 0x62, 0x39, 0x33, 0x62, 0x32, 0x66, 0x39, 0x34, 0x39, 0x64, 0x37, 0x37, 0x33, 0x65, 0x66, 0x31, 0x61, 0x64, 0x37, 0x66, 0x62, 0x34, 0x61, 0x32, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x32, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x39, 0x38, 0x32, 0x65, 0x39, 0x36, 0x34, 0x33, 0x66, 0x66, 0x65, 0x63, 0x65, 0x37, 0x32, 0x33, 0x30, 0x37, 0x35, 0x61, 0x34, 0x30, 0x66, 0x65, 0x37, 0x37, 0x36, 0x65, 0x35, 0x61, 0x63, 0x65, 0x30, 0x34, 0x62, 0x32, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x38, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x37, 0x30, 0x65, 0x38, 0x62, 0x34, 0x37, 0x35, 0x39, 0x63, 0x30, 0x63, 0x33, 0x63, 0x38, 0x32, 0x63, 0x63, 0x30, 0x30, 0x61, 0x63, 0x34, 0x65, 0x39, 0x61, 0x39, 0x34, 0x64, 0x64, 0x35, 0x62, 0x61, 0x66, 0x62, 0x32, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x30, 0x33, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x66, 0x32, 0x65, 0x39, 0x39, 0x31, 0x66, 0x64, 0x33, 0x32, 0x34, 0x63, 0x35, 0x66, 0x35, 0x64, 0x31, 0x37, 0x37, 0x36, 0x38, 0x65, 0x39, 0x66, 0x36, 0x31, 0x33, 0x33, 0x35, 0x64, 0x62, 0x36, 0x33, 0x31, 0x39, 0x64, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x65, 0x38, 0x34, 0x62, 0x33, 0x35, 0x63, 0x35, 0x62, 0x32, 0x32, 0x36, 0x35, 0x35, 0x30, 0x37, 0x30, 0x36, 0x31, 0x64, 0x33, 0x30, 0x62, 0x36, 0x66, 0x31, 0x32, 0x64, 0x61, 0x30, 0x33, 0x33, 0x66, 0x65, 0x36, 0x66, 0x38, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x39, 0x35, 0x65, 0x38, 0x30, 0x39, 0x39, 0x39, 0x64, 0x34, 0x30, 0x36, 0x61, 0x64, 0x35, 0x39, 0x32, 0x65, 0x32, 0x62, 0x32, 0x36, 0x32, 0x37, 0x33, 0x37, 0x64, 0x33, 0x35, 0x66, 0x37, 0x64, 0x62, 0x34, 0x62, 0x36, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x35, 0x66, 0x35, 0x33, 0x34, 0x33, 0x34, 0x36, 0x64, 0x32, 0x66, 0x66, 0x62, 0x37, 0x38, 0x37, 0x66, 0x61, 0x39, 0x63, 0x66, 0x31, 0x38, 0x35, 0x64, 0x37, 0x34, 0x35, 0x62, 0x61, 0x34, 0x32, 0x39, 0x38, 0x36, 0x62, 0x64, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x33, 0x36, 0x38, 0x62, 0x39, 0x37, 0x30, 0x39, 0x61, 0x35, 0x63, 0x31, 0x62, 0x35, 0x31, 0x63, 0x30, 0x61, 0x64, 0x66, 0x31, 0x38, 0x37, 0x61, 0x36, 0x35, 0x64, 0x66, 0x31, 0x34, 0x65, 0x31, 0x32, 0x62, 0x37, 0x64, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x38, 0x39, 0x36, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x31, 0x37, 0x36, 0x64, 0x62, 0x65, 0x33, 0x32, 0x34, 0x39, 0x65, 0x33, 0x34, 0x35, 0x63, 0x64, 0x34, 0x66, 0x61, 0x39, 0x36, 0x37, 0x63, 0x30, 0x65, 0x64, 0x31, 0x33, 0x62, 0x32, 0x34, 0x63, 0x34, 0x37, 0x65, 0x35, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x66, 0x36, 0x61, 0x36, 0x66, 0x65, 0x33, 0x65, 0x39, 0x61, 0x39, 0x32, 0x32, 0x61, 0x31, 0x32, 0x66, 0x32, 0x31, 0x66, 0x61, 0x61, 0x30, 0x33, 0x38, 0x31, 0x35, 0x36, 0x39, 0x31, 0x38, 0x63, 0x34, 0x66, 0x63, 0x62, 0x39, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x62, 0x64, 0x33, 0x31, 0x32, 0x35, 0x32, 0x65, 0x63, 0x32, 0x38, 0x38, 0x66, 0x39, 0x31, 0x65, 0x32, 0x39, 0x38, 0x63, 0x64, 0x38, 0x31, 0x32, 0x63, 0x39, 0x32, 0x31, 0x36, 0x30, 0x65, 0x37, 0x33, 0x38, 0x33, 0x33, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x35, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x34, 0x33, 0x64, 0x64, 0x36, 0x64, 0x31, 0x36, 0x39, 0x65, 0x65, 0x63, 0x38, 0x61, 0x32, 0x31, 0x33, 0x62, 0x62, 0x66, 0x37, 0x61, 0x38, 0x61, 0x66, 0x39, 0x66, 0x66, 0x64, 0x31, 0x35, 0x64, 0x34, 0x66, 0x66, 0x37, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x36, 0x35, 0x62, 0x64, 0x37, 0x38, 0x30, 0x63, 0x37, 0x34, 0x33, 0x34, 0x31, 0x31, 0x35, 0x31, 0x36, 0x32, 0x30, 0x32, 0x37, 0x35, 0x36, 0x35, 0x32, 0x32, 0x33, 0x66, 0x34, 0x34, 0x65, 0x35, 0x34, 0x39, 0x38, 0x66, 0x66, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x61, 0x64, 0x66, 0x35, 0x37, 0x33, 0x63, 0x65, 0x34, 0x63, 0x65, 0x65, 0x63, 0x37, 0x38, 0x62, 0x38, 0x65, 0x31, 0x62, 0x32, 0x31, 0x62, 0x30, 0x65, 0x64, 0x37, 0x38, 0x65, 0x62, 0x31, 0x31, 0x33, 0x62, 0x32, 0x63, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x34, 0x61, 0x61, 0x66, 0x63, 0x38, 0x61, 0x65, 0x35, 0x63, 0x65, 0x36, 0x66, 0x34, 0x39, 0x30, 0x33, 0x63, 0x38, 0x39, 0x64, 0x37, 0x66, 0x61, 0x63, 0x39, 0x63, 0x62, 0x31, 0x39, 0x35, 0x31, 0x32, 0x32, 0x32, 0x34, 0x37, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x63, 0x34, 0x64, 0x34, 0x37, 0x36, 0x35, 0x61, 0x39, 0x34, 0x32, 0x66, 0x35, 0x62, 0x66, 0x39, 0x36, 0x39, 0x33, 0x31, 0x61, 0x39, 0x65, 0x38, 0x63, 0x63, 0x37, 0x61, 0x62, 0x38, 0x62, 0x37, 0x35, 0x37, 0x66, 0x66, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x63, 0x37, 0x38, 0x35, 0x31, 0x66, 0x35, 0x66, 0x66, 0x64, 0x34, 0x63, 0x65, 0x65, 0x39, 0x38, 0x64, 0x66, 0x33, 0x30, 0x66, 0x33, 0x62, 0x32, 0x35, 0x35, 0x39, 0x37, 0x61, 0x66, 0x38, 0x61, 0x36, 0x63, 0x61, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x33, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x33, 0x32, 0x30, 0x32, 0x31, 0x39, 0x38, 0x33, 0x38, 0x65, 0x38, 0x35, 0x39, 0x62, 0x32, 0x66, 0x39, 0x66, 0x31, 0x38, 0x62, 0x37, 0x32, 0x65, 0x33, 0x64, 0x34, 0x30, 0x37, 0x33, 0x63, 0x61, 0x35, 0x30, 0x62, 0x33, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x62, 0x62, 0x66, 0x33, 0x39, 0x62, 0x31, 0x62, 0x36, 0x37, 0x39, 0x39, 0x35, 0x61, 0x34, 0x32, 0x32, 0x34, 0x31, 0x35, 0x30, 0x34, 0x66, 0x39, 0x37, 0x30, 0x33, 0x64, 0x32, 0x61, 0x31, 0x34, 0x61, 0x35, 0x31, 0x35, 0x36, 0x39, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x38, 0x30, 0x30, 0x62, 0x66, 0x64, 0x31, 0x62, 0x33, 0x65, 0x64, 0x34, 0x61, 0x35, 0x37, 0x64, 0x38, 0x37, 0x35, 0x61, 0x65, 0x64, 0x32, 0x36, 0x64, 0x34, 0x32, 0x66, 0x31, 0x61, 0x37, 0x37, 0x30, 0x38, 0x64, 0x37, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x33, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x38, 0x35, 0x65, 0x36, 0x30, 0x65, 0x32, 0x61, 0x66, 0x30, 0x35, 0x34, 0x34, 0x66, 0x32, 0x66, 0x30, 0x31, 0x63, 0x36, 0x34, 0x65, 0x32, 0x30, 0x33, 0x32, 0x39, 0x30, 0x30, 0x65, 0x62, 0x64, 0x33, 0x38, 0x61, 0x33, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x61, 0x63, 0x30, 0x31, 0x63, 0x33, 0x66, 0x62, 0x30, 0x39, 0x32, 0x39, 0x30, 0x33, 0x33, 0x66, 0x30, 0x63, 0x63, 0x63, 0x37, 0x65, 0x31, 0x61, 0x63, 0x66, 0x65, 0x61, 0x61, 0x62, 0x61, 0x37, 0x39, 0x34, 0x35, 0x64, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x34, 0x35, 0x39, 0x32, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x35, 0x35, 0x64, 0x33, 0x65, 0x63, 0x30, 0x63, 0x66, 0x62, 0x39, 0x30, 0x37, 0x64, 0x38, 0x64, 0x62, 0x62, 0x31, 0x62, 0x66, 0x33, 0x34, 0x36, 0x34, 0x65, 0x34, 0x35, 0x38, 0x31, 0x32, 0x38, 0x31, 0x39, 0x30, 0x62, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x63, 0x30, 0x38, 0x64, 0x37, 0x34, 0x34, 0x37, 0x35, 0x34, 0x64, 0x65, 0x37, 0x30, 0x39, 0x63, 0x65, 0x39, 0x36, 0x65, 0x31, 0x35, 0x61, 0x65, 0x30, 0x64, 0x31, 0x64, 0x33, 0x39, 0x35, 0x62, 0x33, 0x61, 0x32, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x66, 0x37, 0x37, 0x34, 0x35, 0x31, 0x64, 0x66, 0x61, 0x32, 0x63, 0x36, 0x34, 0x33, 0x65, 0x30, 0x30, 0x62, 0x31, 0x35, 0x36, 0x64, 0x36, 0x63, 0x36, 0x66, 0x66, 0x38, 0x34, 0x65, 0x32, 0x33, 0x37, 0x33, 0x65, 0x62, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x30, 0x33, 0x34, 0x33, 0x36, 0x37, 0x66, 0x38, 0x37, 0x64, 0x32, 0x34, 0x64, 0x33, 0x30, 0x37, 0x37, 0x66, 0x61, 0x39, 0x61, 0x32, 0x65, 0x33, 0x38, 0x61, 0x38, 0x62, 0x30, 0x63, 0x63, 0x62, 0x31, 0x31, 0x30, 0x34, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x33, 0x34, 0x37, 0x33, 0x65, 0x37, 0x32, 0x31, 0x31, 0x35, 0x31, 0x31, 0x30, 0x64, 0x30, 0x63, 0x33, 0x66, 0x31, 0x31, 0x37, 0x30, 0x38, 0x66, 0x38, 0x36, 0x65, 0x37, 0x37, 0x62, 0x65, 0x32, 0x62, 0x62, 0x30, 0x39, 0x38, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x31, 0x65, 0x36, 0x63, 0x61, 0x65, 0x63, 0x31, 0x38, 0x39, 0x63, 0x32, 0x33, 0x30, 0x61, 0x31, 0x36, 0x32, 0x65, 0x63, 0x30, 0x30, 0x36, 0x35, 0x33, 0x30, 0x31, 0x39, 0x33, 0x65, 0x36, 0x37, 0x63, 0x66, 0x39, 0x64, 0x31, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x63, 0x61, 0x66, 0x38, 0x32, 0x37, 0x62, 0x65, 0x39, 0x64, 0x36, 0x30, 0x37, 0x39, 0x31, 0x35, 0x62, 0x33, 0x36, 0x35, 0x63, 0x38, 0x33, 0x66, 0x30, 0x64, 0x33, 0x62, 0x37, 0x65, 0x61, 0x38, 0x63, 0x37, 0x39, 0x62, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x61, 0x34, 0x62, 0x32, 0x66, 0x61, 0x35, 0x39, 0x64, 0x36, 0x38, 0x34, 0x62, 0x32, 0x37, 0x61, 0x38, 0x31, 0x30, 0x64, 0x66, 0x38, 0x39, 0x37, 0x38, 0x61, 0x37, 0x33, 0x64, 0x66, 0x33, 0x30, 0x38, 0x61, 0x36, 0x33, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x36, 0x35, 0x66, 0x66, 0x35, 0x37, 0x35, 0x66, 0x64, 0x39, 0x63, 0x31, 0x36, 0x64, 0x33, 0x63, 0x62, 0x36, 0x66, 0x64, 0x36, 0x38, 0x66, 0x66, 0x63, 0x38, 0x66, 0x34, 0x38, 0x33, 0x66, 0x63, 0x33, 0x32, 0x65, 0x63, 0x38, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x32, 0x65, 0x65, 0x36, 0x36, 0x36, 0x63, 0x34, 0x62, 0x33, 0x35, 0x65, 0x38, 0x32, 0x61, 0x35, 0x30, 0x36, 0x38, 0x30, 0x38, 0x62, 0x34, 0x34, 0x33, 0x63, 0x65, 0x62, 0x64, 0x35, 0x63, 0x36, 0x33, 0x32, 0x63, 0x37, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x33, 0x30, 0x36, 0x30, 0x38, 0x63, 0x36, 0x37, 0x38, 0x65, 0x31, 0x61, 0x63, 0x34, 0x36, 0x34, 0x61, 0x38, 0x39, 0x39, 0x34, 0x63, 0x33, 0x62, 0x33, 0x33, 0x65, 0x35, 0x63, 0x64, 0x66, 0x33, 0x34, 0x39, 0x37, 0x31, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x63, 0x37, 0x63, 0x65, 0x34, 0x63, 0x30, 0x64, 0x63, 0x33, 0x63, 0x32, 0x62, 0x62, 0x62, 0x39, 0x39, 0x63, 0x63, 0x31, 0x38, 0x35, 0x37, 0x62, 0x38, 0x61, 0x34, 0x35, 0x35, 0x66, 0x36, 0x31, 0x31, 0x37, 0x31, 0x31, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x32, 0x37, 0x34, 0x64, 0x35, 0x30, 0x38, 0x30, 0x34, 0x64, 0x39, 0x63, 0x37, 0x37, 0x64, 0x61, 0x39, 0x33, 0x66, 0x61, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x65, 0x66, 0x65, 0x35, 0x37, 0x62, 0x61, 0x35, 0x30, 0x31, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x30, 0x39, 0x63, 0x32, 0x36, 0x64, 0x64, 0x33, 0x35, 0x30, 0x63, 0x32, 0x33, 0x35, 0x65, 0x34, 0x34, 0x62, 0x32, 0x62, 0x39, 0x63, 0x31, 0x64, 0x64, 0x64, 0x63, 0x63, 0x64, 0x30, 0x61, 0x39, 0x64, 0x39, 0x66, 0x38, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x64, 0x66, 0x61, 0x33, 0x34, 0x64, 0x30, 0x65, 0x62, 0x66, 0x31, 0x62, 0x30, 0x34, 0x61, 0x66, 0x35, 0x33, 0x62, 0x39, 0x39, 0x62, 0x38, 0x32, 0x34, 0x39, 0x34, 0x61, 0x39, 0x65, 0x33, 0x64, 0x38, 0x61, 0x61, 0x31, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x34, 0x30, 0x32, 0x34, 0x32, 0x62, 0x62, 0x33, 0x34, 0x61, 0x37, 0x30, 0x38, 0x35, 0x35, 0x65, 0x66, 0x30, 0x66, 0x64, 0x39, 0x30, 0x66, 0x33, 0x38, 0x30, 0x32, 0x64, 0x65, 0x63, 0x32, 0x31, 0x33, 0x36, 0x62, 0x33, 0x32, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x61, 0x65, 0x64, 0x36, 0x36, 0x37, 0x34, 0x61, 0x66, 0x66, 0x64, 0x39, 0x66, 0x36, 0x34, 0x32, 0x33, 0x33, 0x32, 0x37, 0x32, 0x61, 0x35, 0x37, 0x38, 0x64, 0x64, 0x39, 0x33, 0x38, 0x36, 0x62, 0x39, 0x39, 0x63, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x34, 0x33, 0x34, 0x61, 0x33, 0x65, 0x33, 0x32, 0x65, 0x35, 0x34, 0x65, 0x63, 0x66, 0x32, 0x37, 0x32, 0x66, 0x65, 0x33, 0x34, 0x37, 0x30, 0x62, 0x35, 0x66, 0x36, 0x66, 0x35, 0x31, 0x32, 0x66, 0x36, 0x37, 0x35, 0x35, 0x32, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x37, 0x39, 0x61, 0x35, 0x30, 0x37, 0x30, 0x63, 0x35, 0x30, 0x33, 0x64, 0x32, 0x66, 0x61, 0x63, 0x38, 0x39, 0x62, 0x38, 0x62, 0x33, 0x61, 0x66, 0x61, 0x30, 0x38, 0x30, 0x66, 0x64, 0x34, 0x35, 0x65, 0x64, 0x34, 0x62, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x65, 0x31, 0x36, 0x39, 0x61, 0x39, 0x33, 0x38, 0x30, 0x38, 0x64, 0x38, 0x30, 0x33, 0x35, 0x36, 0x39, 0x38, 0x66, 0x38, 0x31, 0x35, 0x63, 0x37, 0x32, 0x33, 0x35, 0x36, 0x31, 0x33, 0x63, 0x31, 0x65, 0x36, 0x35, 0x39, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x39, 0x62, 0x31, 0x31, 0x36, 0x66, 0x35, 0x39, 0x36, 0x33, 0x30, 0x31, 0x63, 0x35, 0x64, 0x38, 0x62, 0x62, 0x36, 0x32, 0x65, 0x30, 0x65, 0x39, 0x37, 0x61, 0x38, 0x32, 0x34, 0x38, 0x31, 0x32, 0x36, 0x65, 0x33, 0x39, 0x66, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x37, 0x30, 0x31, 0x31, 0x62, 0x36, 0x39, 0x38, 0x62, 0x66, 0x33, 0x33, 0x37, 0x31, 0x31, 0x33, 0x32, 0x64, 0x37, 0x34, 0x34, 0x35, 0x62, 0x31, 0x39, 0x65, 0x62, 0x35, 0x62, 0x30, 0x39, 0x34, 0x33, 0x35, 0x36, 0x61, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x36, 0x64, 0x65, 0x31, 0x38, 0x39, 0x31, 0x64, 0x38, 0x31, 0x39, 0x36, 0x34, 0x36, 0x31, 0x33, 0x39, 0x35, 0x66, 0x39, 0x62, 0x31, 0x33, 0x36, 0x32, 0x36, 0x35, 0x62, 0x33, 0x62, 0x39, 0x35, 0x34, 0x36, 0x66, 0x36, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x33, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x36, 0x35, 0x36, 0x34, 0x65, 0x35, 0x63, 0x39, 0x63, 0x32, 0x34, 0x65, 0x61, 0x61, 0x61, 0x37, 0x34, 0x34, 0x63, 0x39, 0x63, 0x37, 0x63, 0x39, 0x36, 0x38, 0x63, 0x39, 0x65, 0x32, 0x63, 0x39, 0x66, 0x31, 0x66, 0x62, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x35, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x62, 0x30, 0x32, 0x31, 0x32, 0x66, 0x33, 0x32, 0x39, 0x35, 0x65, 0x30, 0x32, 0x39, 0x63, 0x61, 0x62, 0x31, 0x64, 0x39, 0x36, 0x31, 0x62, 0x30, 0x34, 0x31, 0x33, 0x33, 0x61, 0x31, 0x38, 0x30, 0x39, 0x65, 0x37, 0x62, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x38, 0x61, 0x36, 0x39, 0x61, 0x34, 0x30, 0x37, 0x31, 0x35, 0x65, 0x31, 0x62, 0x33, 0x31, 0x33, 0x65, 0x31, 0x33, 0x35, 0x34, 0x65, 0x36, 0x30, 0x30, 0x38, 0x30, 0x30, 0x61, 0x31, 0x65, 0x36, 0x64, 0x63, 0x30, 0x32, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x66, 0x30, 0x63, 0x63, 0x65, 0x31, 0x66, 0x65, 0x39, 0x39, 0x36, 0x64, 0x39, 0x31, 0x37, 0x36, 0x33, 0x35, 0x66, 0x30, 0x30, 0x37, 0x31, 0x32, 0x66, 0x34, 0x30, 0x35, 0x32, 0x30, 0x39, 0x31, 0x64, 0x66, 0x66, 0x39, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x30, 0x66, 0x65, 0x66, 0x32, 0x39, 0x36, 0x39, 0x35, 0x35, 0x35, 0x38, 0x38, 0x63, 0x61, 0x61, 0x65, 0x37, 0x34, 0x63, 0x36, 0x32, 0x65, 0x63, 0x33, 0x32, 0x61, 0x32, 0x33, 0x61, 0x34, 0x35, 0x34, 0x65, 0x30, 0x39, 0x61, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x31, 0x33, 0x66, 0x30, 0x37, 0x37, 0x31, 0x39, 0x34, 0x39, 0x37, 0x35, 0x33, 0x63, 0x34, 0x37, 0x32, 0x36, 0x61, 0x63, 0x61, 0x61, 0x32, 0x62, 0x64, 0x33, 0x36, 0x31, 0x39, 0x63, 0x35, 0x63, 0x32, 0x30, 0x66, 0x66, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x36, 0x65, 0x63, 0x66, 0x61, 0x30, 0x33, 0x61, 0x66, 0x32, 0x63, 0x36, 0x65, 0x31, 0x34, 0x34, 0x62, 0x37, 0x63, 0x34, 0x36, 0x39, 0x32, 0x61, 0x38, 0x36, 0x39, 0x35, 0x31, 0x65, 0x39, 0x30, 0x32, 0x65, 0x39, 0x65, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x62, 0x65, 0x35, 0x65, 0x31, 0x63, 0x39, 0x61, 0x64, 0x32, 0x62, 0x31, 0x64, 0x63, 0x63, 0x66, 0x30, 0x61, 0x33, 0x30, 0x35, 0x66, 0x63, 0x39, 0x35, 0x32, 0x32, 0x66, 0x34, 0x36, 0x36, 0x39, 0x64, 0x64, 0x33, 0x61, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x65, 0x39, 0x62, 0x37, 0x31, 0x38, 0x32, 0x33, 0x39, 0x35, 0x32, 0x65, 0x31, 0x66, 0x36, 0x36, 0x39, 0x35, 0x38, 0x63, 0x32, 0x37, 0x38, 0x66, 0x63, 0x32, 0x38, 0x62, 0x31, 0x31, 0x39, 0x36, 0x61, 0x36, 0x63, 0x35, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x65, 0x32, 0x30, 0x62, 0x63, 0x33, 0x37, 0x65, 0x37, 0x66, 0x34, 0x38, 0x61, 0x38, 0x30, 0x66, 0x66, 0x64, 0x37, 0x61, 0x64, 0x38, 0x34, 0x66, 0x66, 0x62, 0x66, 0x31, 0x61, 0x31, 0x61, 0x62, 0x65, 0x31, 0x37, 0x33, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x66, 0x33, 0x31, 0x33, 0x63, 0x66, 0x38, 0x61, 0x64, 0x30, 0x30, 0x30, 0x39, 0x31, 0x34, 0x61, 0x30, 0x61, 0x31, 0x37, 0x36, 0x64, 0x63, 0x36, 0x61, 0x34, 0x33, 0x34, 0x32, 0x62, 0x37, 0x39, 0x65, 0x63, 0x32, 0x35, 0x33, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x31, 0x61, 0x63, 0x37, 0x63, 0x61, 0x37, 0x30, 0x39, 0x37, 0x31, 0x31, 0x35, 0x66, 0x32, 0x36, 0x32, 0x30, 0x35, 0x65, 0x65, 0x65, 0x30, 0x65, 0x66, 0x37, 0x64, 0x34, 0x31, 0x65, 0x62, 0x34, 0x65, 0x33, 0x31, 0x31, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x66, 0x61, 0x66, 0x64, 0x62, 0x63, 0x37, 0x63, 0x39, 0x30, 0x66, 0x31, 0x33, 0x32, 0x30, 0x65, 0x35, 0x34, 0x62, 0x39, 0x38, 0x66, 0x33, 0x37, 0x34, 0x36, 0x31, 0x37, 0x66, 0x62, 0x64, 0x30, 0x31, 0x64, 0x31, 0x30, 0x39, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x62, 0x31, 0x31, 0x64, 0x30, 0x36, 0x36, 0x35, 0x38, 0x38, 0x63, 0x65, 0x37, 0x34, 0x61, 0x35, 0x37, 0x32, 0x61, 0x38, 0x35, 0x61, 0x36, 0x33, 0x32, 0x38, 0x37, 0x33, 0x39, 0x32, 0x31, 0x32, 0x61, 0x61, 0x38, 0x62, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x32, 0x63, 0x33, 0x34, 0x62, 0x62, 0x34, 0x38, 0x37, 0x64, 0x33, 0x37, 0x36, 0x32, 0x63, 0x33, 0x63, 0x63, 0x61, 0x37, 0x38, 0x32, 0x63, 0x63, 0x64, 0x64, 0x37, 0x61, 0x38, 0x66, 0x62, 0x62, 0x30, 0x61, 0x39, 0x39, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x62, 0x65, 0x38, 0x38, 0x61, 0x64, 0x31, 0x65, 0x35, 0x31, 0x38, 0x62, 0x30, 0x62, 0x62, 0x62, 0x30, 0x32, 0x34, 0x61, 0x62, 0x31, 0x64, 0x38, 0x66, 0x30, 0x65, 0x37, 0x33, 0x66, 0x37, 0x39, 0x30, 0x65, 0x30, 0x63, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x37, 0x34, 0x39, 0x34, 0x63, 0x63, 0x65, 0x34, 0x34, 0x38, 0x35, 0x35, 0x63, 0x63, 0x38, 0x30, 0x35, 0x38, 0x32, 0x38, 0x34, 0x32, 0x62, 0x65, 0x39, 0x35, 0x38, 0x61, 0x30, 0x64, 0x31, 0x63, 0x30, 0x30, 0x37, 0x32, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x33, 0x35, 0x36, 0x39, 0x35, 0x34, 0x32, 0x63, 0x39, 0x37, 0x64, 0x35, 0x36, 0x36, 0x30, 0x31, 0x38, 0x63, 0x39, 0x30, 0x37, 0x61, 0x63, 0x66, 0x63, 0x66, 0x33, 0x39, 0x31, 0x64, 0x31, 0x34, 0x30, 0x36, 0x37, 0x65, 0x38, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x35, 0x32, 0x39, 0x36, 0x30, 0x62, 0x30, 0x62, 0x66, 0x36, 0x62, 0x32, 0x38, 0x34, 0x38, 0x66, 0x64, 0x65, 0x61, 0x64, 0x38, 0x30, 0x31, 0x33, 0x36, 0x64, 0x62, 0x35, 0x66, 0x35, 0x30, 0x37, 0x66, 0x38, 0x62, 0x65, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x63, 0x30, 0x66, 0x35, 0x62, 0x39, 0x64, 0x66, 0x34, 0x33, 0x36, 0x32, 0x35, 0x37, 0x39, 0x38, 0x65, 0x37, 0x65, 0x30, 0x33, 0x63, 0x31, 0x61, 0x35, 0x66, 0x64, 0x36, 0x61, 0x36, 0x64, 0x30, 0x39, 0x31, 0x61, 0x66, 0x38, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x63, 0x39, 0x64, 0x33, 0x38, 0x38, 0x65, 0x62, 0x64, 0x38, 0x37, 0x33, 0x65, 0x36, 0x36, 0x62, 0x31, 0x37, 0x31, 0x33, 0x34, 0x34, 0x38, 0x33, 0x39, 0x37, 0x64, 0x30, 0x66, 0x33, 0x37, 0x66, 0x38, 0x62, 0x64, 0x33, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x32, 0x35, 0x39, 0x62, 0x64, 0x32, 0x66, 0x64, 0x64, 0x66, 0x62, 0x62, 0x63, 0x36, 0x66, 0x62, 0x61, 0x64, 0x33, 0x62, 0x36, 0x65, 0x38, 0x37, 0x34, 0x66, 0x30, 0x62, 0x62, 0x63, 0x30, 0x32, 0x63, 0x64, 0x61, 0x31, 0x38, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x38, 0x38, 0x36, 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x38, 0x37, 0x66, 0x66, 0x35, 0x32, 0x66, 0x34, 0x36, 0x31, 0x31, 0x31, 0x37, 0x61, 0x64, 0x62, 0x33, 0x65, 0x31, 0x64, 0x61, 0x61, 0x37, 0x31, 0x39, 0x33, 0x32, 0x64, 0x31, 0x34, 0x39, 0x33, 0x63, 0x36, 0x35, 0x66, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x35, 0x32, 0x34, 0x32, 0x38, 0x64, 0x32, 0x62, 0x35, 0x38, 0x36, 0x34, 0x39, 0x37, 0x61, 0x63, 0x64, 0x33, 0x30, 0x63, 0x35, 0x36, 0x61, 0x61, 0x31, 0x33, 0x66, 0x62, 0x35, 0x35, 0x38, 0x32, 0x66, 0x38, 0x34, 0x34, 0x30, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x34, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x39, 0x36, 0x66, 0x30, 0x30, 0x64, 0x65, 0x31, 0x64, 0x63, 0x33, 0x62, 0x62, 0x30, 0x31, 0x64, 0x34, 0x37, 0x61, 0x38, 0x63, 0x63, 0x64, 0x31, 0x65, 0x35, 0x64, 0x31, 0x64, 0x64, 0x39, 0x61, 0x31, 0x65, 0x62, 0x37, 0x37, 0x39, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x37, 0x34, 0x39, 0x33, 0x63, 0x64, 0x39, 0x62, 0x63, 0x36, 0x32, 0x33, 0x37, 0x30, 0x32, 0x61, 0x32, 0x34, 0x61, 0x35, 0x36, 0x66, 0x39, 0x66, 0x38, 0x32, 0x65, 0x33, 0x66, 0x64, 0x34, 0x38, 0x66, 0x33, 0x63, 0x64, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x61, 0x64, 0x66, 0x65, 0x64, 0x62, 0x30, 0x36, 0x64, 0x39, 0x31, 0x66, 0x33, 0x63, 0x63, 0x37, 0x33, 0x39, 0x30, 0x34, 0x35, 0x30, 0x62, 0x38, 0x35, 0x35, 0x35, 0x30, 0x32, 0x37, 0x30, 0x38, 0x38, 0x33, 0x63, 0x37, 0x62, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x35, 0x34, 0x34, 0x63, 0x33, 0x32, 0x63, 0x30, 0x37, 0x66, 0x64, 0x30, 0x38, 0x34, 0x32, 0x63, 0x37, 0x36, 0x31, 0x64, 0x35, 0x33, 0x61, 0x38, 0x39, 0x37, 0x64, 0x36, 0x63, 0x39, 0x35, 0x30, 0x62, 0x62, 0x37, 0x35, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x32, 0x39, 0x37, 0x64, 0x37, 0x33, 0x30, 0x66, 0x65, 0x30, 0x66, 0x37, 0x61, 0x39, 0x65, 0x65, 0x32, 0x34, 0x65, 0x30, 0x38, 0x66, 0x62, 0x31, 0x30, 0x38, 0x37, 0x62, 0x33, 0x31, 0x61, 0x64, 0x62, 0x33, 0x30, 0x36, 0x61, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x36, 0x34, 0x66, 0x65, 0x30, 0x39, 0x33, 0x39, 0x61, 0x38, 0x64, 0x31, 0x65, 0x65, 0x61, 0x32, 0x61, 0x30, 0x65, 0x63, 0x64, 0x39, 0x61, 0x39, 0x37, 0x33, 0x30, 0x66, 0x64, 0x37, 0x39, 0x35, 0x38, 0x65, 0x33, 0x33, 0x31, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x36, 0x65, 0x61, 0x62, 0x30, 0x39, 0x61, 0x36, 0x31, 0x30, 0x63, 0x36, 0x61, 0x35, 0x33, 0x64, 0x35, 0x36, 0x61, 0x39, 0x34, 0x36, 0x62, 0x32, 0x63, 0x34, 0x33, 0x34, 0x38, 0x37, 0x61, 0x63, 0x31, 0x64, 0x35, 0x62, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x65, 0x39, 0x62, 0x38, 0x32, 0x66, 0x37, 0x32, 0x39, 0x39, 0x36, 0x33, 0x31, 0x34, 0x30, 0x38, 0x36, 0x35, 0x39, 0x64, 0x64, 0x37, 0x34, 0x65, 0x38, 0x39, 0x31, 0x63, 0x62, 0x38, 0x66, 0x33, 0x38, 0x36, 0x30, 0x66, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x64, 0x61, 0x38, 0x30, 0x66, 0x34, 0x65, 0x64, 0x30, 0x37, 0x34, 0x61, 0x65, 0x61, 0x36, 0x39, 0x37, 0x61, 0x65, 0x64, 0x64, 0x66, 0x32, 0x38, 0x33, 0x62, 0x36, 0x33, 0x64, 0x62, 0x63, 0x61, 0x33, 0x64, 0x63, 0x34, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x36, 0x38, 0x36, 0x63, 0x35, 0x30, 0x35, 0x37, 0x30, 0x39, 0x33, 0x63, 0x31, 0x37, 0x31, 0x63, 0x36, 0x36, 0x64, 0x62, 0x39, 0x39, 0x65, 0x30, 0x31, 0x62, 0x30, 0x65, 0x63, 0x65, 0x63, 0x62, 0x33, 0x30, 0x38, 0x36, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x34, 0x39, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x35, 0x37, 0x32, 0x35, 0x63, 0x30, 0x66, 0x30, 0x38, 0x66, 0x30, 0x38, 0x31, 0x31, 0x66, 0x35, 0x66, 0x30, 0x30, 0x36, 0x65, 0x65, 0x63, 0x39, 0x31, 0x63, 0x35, 0x63, 0x35, 0x63, 0x31, 0x32, 0x36, 0x62, 0x31, 0x32, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x38, 0x65, 0x36, 0x37, 0x61, 0x35, 0x30, 0x35, 0x30, 0x61, 0x31, 0x64, 0x63, 0x39, 0x66, 0x62, 0x31, 0x39, 0x30, 0x39, 0x31, 0x39, 0x61, 0x33, 0x33, 0x64, 0x61, 0x38, 0x33, 0x38, 0x65, 0x66, 0x34, 0x34, 0x35, 0x30, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x64, 0x34, 0x38, 0x34, 0x66, 0x66, 0x38, 0x61, 0x33, 0x30, 0x37, 0x33, 0x36, 0x34, 0x65, 0x62, 0x36, 0x36, 0x63, 0x35, 0x32, 0x35, 0x61, 0x35, 0x37, 0x31, 0x61, 0x61, 0x63, 0x37, 0x30, 0x31, 0x63, 0x35, 0x63, 0x33, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x37, 0x31, 0x62, 0x31, 0x38, 0x32, 0x63, 0x39, 0x66, 0x37, 0x34, 0x31, 0x61, 0x30, 0x63, 0x64, 0x33, 0x63, 0x33, 0x35, 0x36, 0x63, 0x37, 0x33, 0x63, 0x32, 0x33, 0x31, 0x32, 0x36, 0x64, 0x34, 0x66, 0x39, 0x65, 0x36, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x30, 0x32, 0x34, 0x39, 0x65, 0x30, 0x31, 0x64, 0x39, 0x34, 0x35, 0x62, 0x65, 0x66, 0x39, 0x33, 0x65, 0x65, 0x35, 0x65, 0x63, 0x36, 0x31, 0x39, 0x32, 0x35, 0x65, 0x30, 0x33, 0x63, 0x35, 0x63, 0x61, 0x35, 0x30, 0x39, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x39, 0x36, 0x38, 0x66, 0x37, 0x64, 0x33, 0x35, 0x66, 0x32, 0x30, 0x38, 0x38, 0x37, 0x31, 0x36, 0x33, 0x31, 0x63, 0x36, 0x36, 0x38, 0x37, 0x62, 0x33, 0x66, 0x33, 0x64, 0x61, 0x65, 0x61, 0x62, 0x63, 0x36, 0x36, 0x31, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x66, 0x36, 0x32, 0x62, 0x38, 0x61, 0x33, 0x64, 0x37, 0x66, 0x31, 0x31, 0x32, 0x32, 0x30, 0x37, 0x30, 0x31, 0x61, 0x62, 0x39, 0x66, 0x66, 0x66, 0x66, 0x63, 0x62, 0x33, 0x32, 0x37, 0x39, 0x35, 0x39, 0x61, 0x32, 0x37, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x38, 0x35, 0x61, 0x31, 0x38, 0x61, 0x61, 0x62, 0x66, 0x34, 0x35, 0x34, 0x31, 0x62, 0x37, 0x62, 0x37, 0x62, 0x37, 0x65, 0x63, 0x64, 0x33, 0x30, 0x66, 0x36, 0x66, 0x61, 0x65, 0x36, 0x38, 0x36, 0x39, 0x64, 0x39, 0x35, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x33, 0x66, 0x62, 0x35, 0x37, 0x37, 0x61, 0x34, 0x64, 0x32, 0x31, 0x34, 0x66, 0x65, 0x30, 0x31, 0x30, 0x64, 0x33, 0x32, 0x63, 0x63, 0x61, 0x37, 0x63, 0x33, 0x65, 0x65, 0x64, 0x61, 0x36, 0x33, 0x66, 0x38, 0x37, 0x63, 0x65, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x65, 0x38, 0x36, 0x64, 0x30, 0x62, 0x30, 0x34, 0x33, 0x38, 0x34, 0x31, 0x39, 0x63, 0x65, 0x62, 0x31, 0x61, 0x30, 0x33, 0x38, 0x33, 0x31, 0x39, 0x32, 0x33, 0x37, 0x62, 0x61, 0x35, 0x32, 0x30, 0x36, 0x64, 0x37, 0x32, 0x65, 0x34, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x36, 0x36, 0x32, 0x39, 0x32, 0x66, 0x30, 0x65, 0x38, 0x30, 0x64, 0x34, 0x33, 0x61, 0x37, 0x38, 0x37, 0x37, 0x34, 0x32, 0x37, 0x37, 0x35, 0x39, 0x30, 0x61, 0x39, 0x65, 0x62, 0x34, 0x35, 0x39, 0x36, 0x31, 0x32, 0x31, 0x34, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x33, 0x63, 0x30, 0x33, 0x32, 0x33, 0x66, 0x62, 0x66, 0x39, 0x63, 0x32, 0x36, 0x63, 0x31, 0x64, 0x38, 0x61, 0x63, 0x34, 0x34, 0x65, 0x66, 0x37, 0x34, 0x33, 0x39, 0x31, 0x64, 0x30, 0x38, 0x30, 0x34, 0x36, 0x39, 0x36, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x62, 0x63, 0x34, 0x63, 0x34, 0x34, 0x39, 0x31, 0x30, 0x64, 0x35, 0x61, 0x65, 0x64, 0x64, 0x36, 0x36, 0x65, 0x64, 0x32, 0x33, 0x35, 0x35, 0x35, 0x33, 0x38, 0x61, 0x36, 0x62, 0x31, 0x39, 0x33, 0x63, 0x33, 0x36, 0x31, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x66, 0x30, 0x34, 0x66, 0x35, 0x32, 0x31, 0x30, 0x39, 0x61, 0x65, 0x62, 0x65, 0x63, 0x39, 0x61, 0x37, 0x62, 0x31, 0x65, 0x39, 0x33, 0x33, 0x32, 0x37, 0x36, 0x31, 0x65, 0x39, 0x66, 0x65, 0x32, 0x62, 0x39, 0x37, 0x62, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x34, 0x61, 0x39, 0x31, 0x34, 0x64, 0x32, 0x62, 0x62, 0x30, 0x32, 0x39, 0x66, 0x33, 0x32, 0x65, 0x35, 0x66, 0x65, 0x66, 0x35, 0x63, 0x32, 0x33, 0x34, 0x63, 0x34, 0x66, 0x65, 0x63, 0x32, 0x64, 0x32, 0x64, 0x64, 0x35, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x65, 0x36, 0x31, 0x39, 0x66, 0x35, 0x37, 0x61, 0x62, 0x63, 0x31, 0x65, 0x39, 0x38, 0x37, 0x61, 0x61, 0x39, 0x33, 0x36, 0x61, 0x65, 0x33, 0x61, 0x32, 0x32, 0x36, 0x34, 0x39, 0x36, 0x32, 0x65, 0x37, 0x65, 0x62, 0x32, 0x64, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x36, 0x62, 0x66, 0x36, 0x64, 0x61, 0x62, 0x32, 0x32, 0x64, 0x38, 0x34, 0x31, 0x62, 0x34, 0x38, 0x36, 0x63, 0x33, 0x38, 0x65, 0x37, 0x62, 0x61, 0x36, 0x61, 0x62, 0x33, 0x33, 0x61, 0x31, 0x34, 0x38, 0x37, 0x65, 0x64, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x61, 0x30, 0x34, 0x36, 0x65, 0x33, 0x64, 0x32, 0x62, 0x32, 0x62, 0x66, 0x36, 0x38, 0x31, 0x34, 0x38, 0x38, 0x38, 0x32, 0x36, 0x65, 0x33, 0x32, 0x64, 0x39, 0x63, 0x30, 0x36, 0x31, 0x35, 0x31, 0x38, 0x63, 0x66, 0x65, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x38, 0x32, 0x32, 0x37, 0x35, 0x66, 0x37, 0x34, 0x35, 0x61, 0x32, 0x63, 0x61, 0x63, 0x30, 0x32, 0x37, 0x36, 0x66, 0x62, 0x64, 0x62, 0x30, 0x32, 0x64, 0x34, 0x62, 0x32, 0x61, 0x33, 0x61, 0x62, 0x31, 0x37, 0x31, 0x31, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x30, 0x31, 0x64, 0x66, 0x37, 0x39, 0x66, 0x35, 0x39, 0x34, 0x39, 0x30, 0x31, 0x61, 0x66, 0x65, 0x31, 0x34, 0x34, 0x34, 0x34, 0x38, 0x35, 0x65, 0x36, 0x62, 0x32, 0x30, 0x63, 0x33, 0x62, 0x64, 0x61, 0x32, 0x62, 0x39, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x63, 0x33, 0x65, 0x65, 0x63, 0x32, 0x36, 0x34, 0x30, 0x61, 0x37, 0x35, 0x32, 0x63, 0x34, 0x36, 0x36, 0x65, 0x32, 0x62, 0x37, 0x65, 0x37, 0x65, 0x65, 0x36, 0x38, 0x35, 0x61, 0x66, 0x65, 0x39, 0x61, 0x63, 0x34, 0x31, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x32, 0x34, 0x32, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x33, 0x34, 0x64, 0x64, 0x31, 0x63, 0x39, 0x64, 0x66, 0x30, 0x64, 0x36, 0x63, 0x38, 0x61, 0x35, 0x38, 0x31, 0x32, 0x34, 0x32, 0x36, 0x62, 0x62, 0x35, 0x35, 0x63, 0x37, 0x36, 0x31, 0x63, 0x61, 0x38, 0x33, 0x31, 0x66, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x32, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x63, 0x35, 0x37, 0x61, 0x61, 0x36, 0x36, 0x36, 0x66, 0x61, 0x65, 0x32, 0x38, 0x65, 0x39, 0x66, 0x31, 0x30, 0x37, 0x61, 0x34, 0x39, 0x63, 0x62, 0x35, 0x30, 0x38, 0x39, 0x61, 0x34, 0x65, 0x32, 0x32, 0x31, 0x35, 0x31, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x63, 0x32, 0x32, 0x39, 0x37, 0x33, 0x32, 0x39, 0x61, 0x36, 0x66, 0x64, 0x39, 0x39, 0x31, 0x31, 0x37, 0x65, 0x35, 0x34, 0x66, 0x63, 0x36, 0x61, 0x66, 0x33, 0x37, 0x39, 0x62, 0x34, 0x64, 0x35, 0x35, 0x36, 0x35, 0x34, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x35, 0x38, 0x35, 0x32, 0x30, 0x30, 0x36, 0x38, 0x33, 0x61, 0x34, 0x30, 0x33, 0x39, 0x30, 0x31, 0x33, 0x37, 0x32, 0x39, 0x31, 0x32, 0x61, 0x38, 0x39, 0x38, 0x33, 0x34, 0x61, 0x61, 0x64, 0x63, 0x62, 0x35, 0x35, 0x66, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x34, 0x39, 0x62, 0x66, 0x31, 0x38, 0x35, 0x65, 0x37, 0x30, 0x64, 0x30, 0x34, 0x35, 0x30, 0x37, 0x39, 0x39, 0x39, 0x66, 0x39, 0x32, 0x61, 0x34, 0x64, 0x65, 0x34, 0x34, 0x35, 0x35, 0x33, 0x31, 0x32, 0x38, 0x32, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x36, 0x62, 0x63, 0x39, 0x61, 0x34, 0x36, 0x62, 0x30, 0x33, 0x61, 0x65, 0x35, 0x34, 0x30, 0x34, 0x66, 0x30, 0x34, 0x33, 0x64, 0x66, 0x63, 0x66, 0x32, 0x31, 0x38, 0x38, 0x33, 0x65, 0x34, 0x31, 0x31, 0x30, 0x63, 0x63, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x34, 0x39, 0x62, 0x38, 0x36, 0x64, 0x30, 0x64, 0x33, 0x39, 0x34, 0x35, 0x35, 0x39, 0x30, 0x36, 0x39, 0x38, 0x61, 0x36, 0x61, 0x61, 0x66, 0x31, 0x36, 0x37, 0x33, 0x63, 0x33, 0x37, 0x37, 0x35, 0x35, 0x63, 0x61, 0x38, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x65, 0x62, 0x31, 0x39, 0x39, 0x37, 0x61, 0x61, 0x64, 0x32, 0x37, 0x37, 0x63, 0x63, 0x33, 0x33, 0x34, 0x33, 0x30, 0x65, 0x36, 0x31, 0x31, 0x31, 0x65, 0x64, 0x30, 0x39, 0x34, 0x33, 0x35, 0x39, 0x34, 0x30, 0x34, 0x38, 0x62, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x30, 0x38, 0x38, 0x33, 0x30, 0x35, 0x34, 0x63, 0x32, 0x64, 0x30, 0x32, 0x62, 0x63, 0x37, 0x61, 0x38, 0x35, 0x32, 0x62, 0x31, 0x66, 0x38, 0x36, 0x63, 0x34, 0x32, 0x37, 0x37, 0x37, 0x64, 0x30, 0x64, 0x35, 0x63, 0x38, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x34, 0x39, 0x61, 0x37, 0x37, 0x35, 0x38, 0x31, 0x34, 0x65, 0x63, 0x30, 0x30, 0x30, 0x35, 0x31, 0x61, 0x37, 0x39, 0x35, 0x61, 0x38, 0x37, 0x35, 0x64, 0x65, 0x32, 0x34, 0x35, 0x39, 0x32, 0x65, 0x61, 0x34, 0x30, 0x30, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x33, 0x39, 0x36, 0x38, 0x33, 0x64, 0x37, 0x62, 0x33, 0x64, 0x32, 0x32, 0x35, 0x62, 0x63, 0x37, 0x64, 0x38, 0x64, 0x66, 0x61, 0x64, 0x65, 0x66, 0x36, 0x33, 0x31, 0x36, 0x33, 0x34, 0x34, 0x31, 0x62, 0x65, 0x34, 0x31, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x62, 0x61, 0x30, 0x64, 0x33, 0x61, 0x33, 0x36, 0x31, 0x37, 0x62, 0x31, 0x65, 0x33, 0x31, 0x62, 0x34, 0x65, 0x34, 0x32, 0x32, 0x63, 0x65, 0x32, 0x36, 0x39, 0x65, 0x38, 0x37, 0x33, 0x38, 0x32, 0x38, 0x64, 0x35, 0x64, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x31, 0x36, 0x66, 0x33, 0x64, 0x63, 0x64, 0x35, 0x64, 0x62, 0x37, 0x34, 0x34, 0x62, 0x64, 0x30, 0x30, 0x38, 0x38, 0x38, 0x37, 0x36, 0x38, 0x37, 0x61, 0x61, 0x30, 0x65, 0x63, 0x39, 0x66, 0x64, 0x37, 0x32, 0x39, 0x32, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x31, 0x39, 0x66, 0x34, 0x39, 0x62, 0x37, 0x32, 0x30, 0x64, 0x61, 0x36, 0x38, 0x38, 0x35, 0x36, 0x66, 0x34, 0x62, 0x39, 0x65, 0x37, 0x30, 0x38, 0x66, 0x32, 0x35, 0x36, 0x34, 0x35, 0x62, 0x64, 0x62, 0x63, 0x34, 0x62, 0x34, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x30, 0x37, 0x39, 0x36, 0x61, 0x62, 0x63, 0x30, 0x64, 0x62, 0x38, 0x34, 0x61, 0x66, 0x38, 0x32, 0x64, 0x61, 0x35, 0x32, 0x61, 0x30, 0x65, 0x64, 0x36, 0x38, 0x37, 0x33, 0x34, 0x64, 0x65, 0x37, 0x65, 0x36, 0x33, 0x36, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x62, 0x36, 0x38, 0x35, 0x34, 0x37, 0x38, 0x38, 0x61, 0x37, 0x63, 0x36, 0x34, 0x39, 0x36, 0x63, 0x64, 0x62, 0x66, 0x35, 0x66, 0x38, 0x34, 0x62, 0x39, 0x65, 0x63, 0x35, 0x65, 0x66, 0x33, 0x39, 0x32, 0x62, 0x37, 0x38, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x32, 0x66, 0x62, 0x65, 0x65, 0x65, 0x38, 0x65, 0x61, 0x63, 0x63, 0x35, 0x63, 0x35, 0x64, 0x37, 0x37, 0x63, 0x31, 0x36, 0x61, 0x62, 0x64, 0x34, 0x36, 0x32, 0x65, 0x65, 0x39, 0x63, 0x38, 0x31, 0x34, 0x35, 0x66, 0x33, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x31, 0x36, 0x38, 0x34, 0x62, 0x61, 0x61, 0x39, 0x63, 0x30, 0x62, 0x34, 0x62, 0x35, 0x66, 0x35, 0x35, 0x33, 0x33, 0x38, 0x65, 0x36, 0x66, 0x36, 0x65, 0x37, 0x63, 0x38, 0x65, 0x31, 0x34, 0x36, 0x64, 0x34, 0x31, 0x63, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x32, 0x36, 0x62, 0x34, 0x32, 0x39, 0x66, 0x64, 0x34, 0x33, 0x64, 0x38, 0x34, 0x65, 0x63, 0x31, 0x37, 0x39, 0x38, 0x32, 0x35, 0x33, 0x32, 0x34, 0x62, 0x61, 0x64, 0x35, 0x62, 0x66, 0x62, 0x39, 0x31, 0x36, 0x62, 0x33, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x32, 0x31, 0x38, 0x36, 0x32, 0x34, 0x39, 0x33, 0x32, 0x34, 0x32, 0x63, 0x30, 0x61, 0x65, 0x62, 0x38, 0x34, 0x62, 0x39, 0x30, 0x64, 0x65, 0x30, 0x35, 0x64, 0x32, 0x35, 0x30, 0x63, 0x31, 0x65, 0x35, 0x30, 0x63, 0x30, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x61, 0x37, 0x34, 0x32, 0x35, 0x66, 0x65, 0x30, 0x39, 0x65, 0x62, 0x32, 0x38, 0x63, 0x66, 0x38, 0x36, 0x65, 0x62, 0x31, 0x37, 0x39, 0x33, 0x65, 0x34, 0x31, 0x62, 0x32, 0x31, 0x31, 0x65, 0x35, 0x37, 0x62, 0x64, 0x36, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x38, 0x37, 0x35, 0x65, 0x34, 0x65, 0x32, 0x66, 0x33, 0x63, 0x61, 0x62, 0x65, 0x34, 0x66, 0x33, 0x37, 0x65, 0x30, 0x65, 0x61, 0x65, 0x64, 0x37, 0x64, 0x31, 0x66, 0x36, 0x64, 0x63, 0x63, 0x36, 0x66, 0x66, 0x65, 0x66, 0x34, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x36, 0x36, 0x33, 0x66, 0x38, 0x31, 0x34, 0x35, 0x64, 0x62, 0x66, 0x65, 0x63, 0x36, 0x63, 0x36, 0x34, 0x36, 0x66, 0x63, 0x35, 0x63, 0x34, 0x39, 0x39, 0x36, 0x31, 0x33, 0x34, 0x35, 0x64, 0x65, 0x31, 0x63, 0x39, 0x66, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x39, 0x63, 0x32, 0x32, 0x66, 0x31, 0x61, 0x34, 0x65, 0x31, 0x64, 0x34, 0x37, 0x34, 0x36, 0x65, 0x63, 0x66, 0x61, 0x61, 0x35, 0x39, 0x65, 0x64, 0x33, 0x38, 0x36, 0x66, 0x65, 0x65, 0x31, 0x32, 0x64, 0x35, 0x31, 0x65, 0x33, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x39, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x66, 0x38, 0x36, 0x62, 0x35, 0x31, 0x32, 0x33, 0x62, 0x63, 0x64, 0x63, 0x31, 0x37, 0x65, 0x64, 0x34, 0x63, 0x65, 0x38, 0x65, 0x30, 0x35, 0x62, 0x37, 0x65, 0x31, 0x32, 0x65, 0x35, 0x31, 0x33, 0x39, 0x33, 0x61, 0x31, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x33, 0x64, 0x31, 0x38, 0x37, 0x30, 0x34, 0x31, 0x32, 0x36, 0x61, 0x61, 0x39, 0x39, 0x65, 0x65, 0x33, 0x33, 0x34, 0x32, 0x63, 0x65, 0x36, 0x30, 0x66, 0x35, 0x64, 0x34, 0x63, 0x38, 0x35, 0x66, 0x31, 0x38, 0x36, 0x37, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x64, 0x35, 0x33, 0x31, 0x61, 0x39, 0x36, 0x34, 0x62, 0x63, 0x65, 0x61, 0x31, 0x33, 0x38, 0x32, 0x39, 0x36, 0x32, 0x30, 0x63, 0x30, 0x63, 0x65, 0x64, 0x37, 0x32, 0x34, 0x32, 0x32, 0x64, 0x61, 0x64, 0x62, 0x34, 0x63, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x32, 0x39, 0x64, 0x34, 0x37, 0x64, 0x35, 0x37, 0x61, 0x37, 0x33, 0x33, 0x66, 0x35, 0x36, 0x62, 0x39, 0x62, 0x32, 0x31, 0x37, 0x30, 0x36, 0x33, 0x62, 0x35, 0x31, 0x33, 0x64, 0x63, 0x33, 0x62, 0x33, 0x31, 0x35, 0x39, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x31, 0x65, 0x38, 0x30, 0x63, 0x31, 0x38, 0x31, 0x36, 0x31, 0x36, 0x33, 0x34, 0x32, 0x65, 0x62, 0x62, 0x33, 0x66, 0x62, 0x33, 0x39, 0x39, 0x32, 0x30, 0x37, 0x32, 0x66, 0x31, 0x62, 0x32, 0x38, 0x62, 0x38, 0x30, 0x32, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x33, 0x31, 0x33, 0x66, 0x66, 0x64, 0x36, 0x33, 0x35, 0x62, 0x66, 0x32, 0x66, 0x33, 0x33, 0x32, 0x34, 0x38, 0x34, 0x31, 0x61, 0x38, 0x38, 0x63, 0x30, 0x37, 0x65, 0x64, 0x31, 0x34, 0x36, 0x31, 0x34, 0x34, 0x63, 0x65, 0x65, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x34, 0x66, 0x65, 0x62, 0x37, 0x32, 0x64, 0x66, 0x39, 0x38, 0x66, 0x66, 0x33, 0x35, 0x61, 0x31, 0x33, 0x38, 0x65, 0x30, 0x31, 0x37, 0x36, 0x31, 0x64, 0x31, 0x32, 0x30, 0x33, 0x66, 0x39, 0x62, 0x37, 0x65, 0x64, 0x66, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x31, 0x36, 0x39, 0x33, 0x63, 0x33, 0x30, 0x33, 0x37, 0x36, 0x35, 0x30, 0x38, 0x35, 0x31, 0x33, 0x30, 0x38, 0x32, 0x30, 0x32, 0x30, 0x63, 0x63, 0x32, 0x62, 0x36, 0x33, 0x65, 0x39, 0x66, 0x61, 0x39, 0x32, 0x31, 0x33, 0x31, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x33, 0x31, 0x33, 0x35, 0x63, 0x62, 0x35, 0x34, 0x66, 0x31, 0x30, 0x32, 0x63, 0x62, 0x65, 0x66, 0x65, 0x30, 0x39, 0x65, 0x39, 0x36, 0x31, 0x30, 0x33, 0x61, 0x31, 0x61, 0x37, 0x39, 0x36, 0x37, 0x31, 0x38, 0x66, 0x66, 0x35, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x36, 0x31, 0x31, 0x35, 0x35, 0x62, 0x61, 0x30, 0x30, 0x39, 0x64, 0x63, 0x64, 0x65, 0x62, 0x65, 0x66, 0x31, 0x30, 0x62, 0x32, 0x38, 0x64, 0x39, 0x64, 0x61, 0x33, 0x64, 0x31, 0x62, 0x63, 0x36, 0x63, 0x39, 0x63, 0x65, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x63, 0x39, 0x34, 0x38, 0x31, 0x31, 0x65, 0x37, 0x31, 0x37, 0x35, 0x62, 0x31, 0x34, 0x38, 0x62, 0x32, 0x38, 0x31, 0x63, 0x31, 0x61, 0x38, 0x34, 0x35, 0x62, 0x66, 0x63, 0x39, 0x62, 0x62, 0x36, 0x66, 0x62, 0x63, 0x31, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x64, 0x39, 0x63, 0x63, 0x61, 0x38, 0x66, 0x35, 0x35, 0x65, 0x65, 0x61, 0x30, 0x30, 0x34, 0x30, 0x65, 0x63, 0x36, 0x65, 0x62, 0x33, 0x34, 0x38, 0x61, 0x31, 0x37, 0x37, 0x34, 0x62, 0x39, 0x35, 0x64, 0x39, 0x33, 0x65, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x36, 0x32, 0x31, 0x32, 0x35, 0x61, 0x64, 0x65, 0x63, 0x33, 0x33, 0x37, 0x30, 0x61, 0x63, 0x35, 0x32, 0x31, 0x31, 0x30, 0x39, 0x35, 0x33, 0x61, 0x34, 0x65, 0x37, 0x36, 0x30, 0x62, 0x65, 0x39, 0x34, 0x35, 0x31, 0x65, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x61, 0x31, 0x65, 0x36, 0x62, 0x63, 0x36, 0x34, 0x63, 0x63, 0x33, 0x31, 0x38, 0x30, 0x66, 0x36, 0x32, 0x30, 0x65, 0x39, 0x34, 0x64, 0x63, 0x35, 0x62, 0x31, 0x62, 0x63, 0x66, 0x64, 0x38, 0x31, 0x35, 0x38, 0x65, 0x34, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x32, 0x33, 0x37, 0x31, 0x34, 0x38, 0x64, 0x33, 0x30, 0x63, 0x31, 0x33, 0x38, 0x33, 0x36, 0x66, 0x66, 0x61, 0x32, 0x63, 0x61, 0x64, 0x35, 0x32, 0x30, 0x65, 0x65, 0x34, 0x64, 0x32, 0x65, 0x35, 0x63, 0x34, 0x65, 0x65, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x30, 0x32, 0x34, 0x65, 0x37, 0x66, 0x30, 0x32, 0x39, 0x63, 0x36, 0x61, 0x61, 0x66, 0x33, 0x61, 0x38, 0x62, 0x39, 0x31, 0x30, 0x66, 0x35, 0x65, 0x30, 0x38, 0x30, 0x38, 0x37, 0x33, 0x62, 0x38, 0x35, 0x37, 0x39, 0x35, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x38, 0x33, 0x63, 0x64, 0x34, 0x36, 0x37, 0x35, 0x64, 0x61, 0x35, 0x38, 0x63, 0x34, 0x39, 0x36, 0x35, 0x35, 0x36, 0x31, 0x35, 0x31, 0x64, 0x61, 0x66, 0x64, 0x38, 0x30, 0x63, 0x37, 0x66, 0x39, 0x39, 0x35, 0x64, 0x33, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x39, 0x62, 0x32, 0x39, 0x39, 0x33, 0x32, 0x37, 0x34, 0x39, 0x30, 0x64, 0x37, 0x32, 0x66, 0x39, 0x61, 0x39, 0x65, 0x64, 0x66, 0x66, 0x31, 0x31, 0x62, 0x38, 0x33, 0x61, 0x66, 0x64, 0x30, 0x65, 0x39, 0x64, 0x33, 0x63, 0x34, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x33, 0x33, 0x33, 0x61, 0x33, 0x62, 0x32, 0x33, 0x31, 0x30, 0x37, 0x36, 0x35, 0x61, 0x30, 0x64, 0x31, 0x38, 0x33, 0x32, 0x62, 0x39, 0x62, 0x65, 0x34, 0x63, 0x30, 0x61, 0x30, 0x33, 0x37, 0x30, 0x34, 0x63, 0x31, 0x63, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x61, 0x66, 0x31, 0x63, 0x33, 0x31, 0x32, 0x35, 0x34, 0x61, 0x36, 0x65, 0x30, 0x30, 0x35, 0x66, 0x62, 0x61, 0x37, 0x66, 0x35, 0x61, 0x62, 0x30, 0x65, 0x63, 0x37, 0x39, 0x64, 0x37, 0x66, 0x63, 0x32, 0x62, 0x36, 0x33, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x33, 0x33, 0x64, 0x62, 0x34, 0x32, 0x63, 0x31, 0x34, 0x31, 0x36, 0x33, 0x63, 0x37, 0x62, 0x65, 0x34, 0x63, 0x61, 0x62, 0x38, 0x36, 0x61, 0x63, 0x35, 0x39, 0x33, 0x65, 0x30, 0x36, 0x32, 0x36, 0x36, 0x64, 0x36, 0x39, 0x39, 0x64, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x34, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x32, 0x64, 0x32, 0x35, 0x65, 0x62, 0x30, 0x65, 0x61, 0x32, 0x62, 0x38, 0x62, 0x33, 0x30, 0x32, 0x38, 0x61, 0x34, 0x63, 0x37, 0x61, 0x31, 0x35, 0x35, 0x64, 0x63, 0x31, 0x61, 0x61, 0x65, 0x38, 0x36, 0x35, 0x37, 0x38, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x37, 0x31, 0x30, 0x36, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x61, 0x32, 0x33, 0x31, 0x39, 0x66, 0x65, 0x64, 0x38, 0x63, 0x32, 0x64, 0x34, 0x36, 0x32, 0x61, 0x64, 0x66, 0x32, 0x65, 0x31, 0x37, 0x66, 0x65, 0x65, 0x63, 0x36, 0x61, 0x36, 0x66, 0x33, 0x30, 0x35, 0x31, 0x36, 0x65, 0x39, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x39, 0x63, 0x66, 0x61, 0x61, 0x39, 0x36, 0x37, 0x66, 0x33, 0x61, 0x66, 0x62, 0x66, 0x35, 0x35, 0x30, 0x33, 0x31, 0x30, 0x36, 0x31, 0x66, 0x63, 0x34, 0x63, 0x65, 0x66, 0x38, 0x38, 0x66, 0x38, 0x35, 0x64, 0x61, 0x35, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x64, 0x62, 0x37, 0x66, 0x66, 0x39, 0x35, 0x61, 0x30, 0x38, 0x36, 0x64, 0x32, 0x38, 0x65, 0x62, 0x62, 0x66, 0x62, 0x38, 0x32, 0x66, 0x62, 0x38, 0x66, 0x62, 0x35, 0x66, 0x32, 0x33, 0x30, 0x61, 0x35, 0x65, 0x62, 0x63, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x33, 0x66, 0x39, 0x31, 0x32, 0x38, 0x62, 0x30, 0x37, 0x32, 0x30, 0x33, 0x61, 0x33, 0x65, 0x31, 0x30, 0x64, 0x37, 0x64, 0x35, 0x37, 0x35, 0x35, 0x63, 0x30, 0x63, 0x34, 0x61, 0x62, 0x63, 0x36, 0x65, 0x32, 0x63, 0x61, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x34, 0x64, 0x31, 0x65, 0x37, 0x65, 0x34, 0x35, 0x36, 0x31, 0x32, 0x38, 0x34, 0x61, 0x33, 0x34, 0x66, 0x65, 0x66, 0x39, 0x36, 0x37, 0x33, 0x63, 0x30, 0x64, 0x33, 0x34, 0x65, 0x31, 0x32, 0x61, 0x66, 0x34, 0x61, 0x61, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x34, 0x61, 0x66, 0x32, 0x31, 0x62, 0x37, 0x65, 0x62, 0x66, 0x61, 0x34, 0x36, 0x37, 0x65, 0x32, 0x63, 0x65, 0x64, 0x36, 0x35, 0x61, 0x61, 0x33, 0x34, 0x65, 0x64, 0x64, 0x33, 0x61, 0x30, 0x65, 0x63, 0x37, 0x31, 0x33, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x64, 0x32, 0x33, 0x31, 0x61, 0x37, 0x30, 0x63, 0x31, 0x64, 0x66, 0x65, 0x62, 0x33, 0x36, 0x30, 0x61, 0x62, 0x64, 0x39, 0x37, 0x66, 0x36, 0x31, 0x36, 0x65, 0x32, 0x64, 0x31, 0x30, 0x64, 0x33, 0x39, 0x66, 0x33, 0x63, 0x61, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x35, 0x64, 0x37, 0x33, 0x33, 0x35, 0x61, 0x63, 0x62, 0x30, 0x33, 0x36, 0x32, 0x62, 0x34, 0x37, 0x64, 0x66, 0x61, 0x33, 0x61, 0x38, 0x61, 0x34, 0x64, 0x33, 0x66, 0x35, 0x39, 0x34, 0x39, 0x35, 0x34, 0x34, 0x64, 0x33, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x65, 0x31, 0x66, 0x32, 0x62, 0x39, 0x63, 0x31, 0x36, 0x63, 0x33, 0x30, 0x39, 0x38, 0x37, 0x34, 0x64, 0x65, 0x65, 0x37, 0x66, 0x61, 0x63, 0x33, 0x32, 0x36, 0x37, 0x35, 0x61, 0x66, 0x66, 0x31, 0x32, 0x39, 0x63, 0x33, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x33, 0x62, 0x36, 0x64, 0x61, 0x36, 0x63, 0x62, 0x37, 0x61, 0x61, 0x63, 0x35, 0x37, 0x31, 0x64, 0x66, 0x66, 0x32, 0x37, 0x66, 0x30, 0x39, 0x64, 0x33, 0x39, 0x66, 0x38, 0x34, 0x36, 0x66, 0x35, 0x33, 0x37, 0x36, 0x39, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x37, 0x39, 0x32, 0x37, 0x34, 0x62, 0x66, 0x31, 0x38, 0x30, 0x33, 0x61, 0x33, 0x33, 0x36, 0x65, 0x34, 0x64, 0x33, 0x62, 0x30, 0x30, 0x64, 0x64, 0x64, 0x39, 0x33, 0x66, 0x32, 0x64, 0x34, 0x66, 0x35, 0x66, 0x34, 0x61, 0x36, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x36, 0x34, 0x34, 0x65, 0x64, 0x39, 0x32, 0x32, 0x63, 0x63, 0x32, 0x33, 0x37, 0x61, 0x33, 0x65, 0x35, 0x63, 0x34, 0x39, 0x37, 0x39, 0x61, 0x39, 0x39, 0x35, 0x34, 0x37, 0x37, 0x66, 0x33, 0x36, 0x65, 0x35, 0x30, 0x62, 0x63, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x36, 0x63, 0x30, 0x33, 0x34, 0x32, 0x39, 0x39, 0x36, 0x39, 0x63, 0x61, 0x31, 0x32, 0x36, 0x32, 0x63, 0x62, 0x33, 0x66, 0x30, 0x61, 0x34, 0x61, 0x35, 0x34, 0x61, 0x66, 0x61, 0x37, 0x64, 0x33, 0x34, 0x38, 0x64, 0x37, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x66, 0x30, 0x36, 0x32, 0x34, 0x36, 0x62, 0x38, 0x64, 0x34, 0x62, 0x64, 0x32, 0x39, 0x36, 0x36, 0x31, 0x66, 0x34, 0x33, 0x65, 0x39, 0x33, 0x37, 0x36, 0x32, 0x32, 0x30, 0x31, 0x64, 0x32, 0x38, 0x36, 0x39, 0x33, 0x35, 0x61, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x31, 0x38, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x34, 0x39, 0x37, 0x32, 0x61, 0x38, 0x33, 0x63, 0x61, 0x34, 0x31, 0x31, 0x32, 0x62, 0x63, 0x38, 0x37, 0x31, 0x63, 0x37, 0x32, 0x64, 0x34, 0x61, 0x65, 0x31, 0x36, 0x31, 0x36, 0x63, 0x32, 0x66, 0x30, 0x37, 0x32, 0x38, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x36, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x30, 0x39, 0x38, 0x66, 0x35, 0x65, 0x34, 0x65, 0x33, 0x64, 0x66, 0x66, 0x61, 0x35, 0x31, 0x61, 0x66, 0x32, 0x33, 0x37, 0x62, 0x64, 0x61, 0x38, 0x36, 0x35, 0x32, 0x63, 0x34, 0x66, 0x37, 0x33, 0x65, 0x64, 0x39, 0x63, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x64, 0x65, 0x64, 0x32, 0x35, 0x37, 0x34, 0x62, 0x32, 0x37, 0x64, 0x31, 0x36, 0x31, 0x33, 0x61, 0x37, 0x64, 0x39, 0x38, 0x62, 0x37, 0x31, 0x35, 0x31, 0x35, 0x39, 0x62, 0x30, 0x64, 0x30, 0x30, 0x62, 0x61, 0x61, 0x62, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x64, 0x39, 0x33, 0x31, 0x64, 0x34, 0x63, 0x35, 0x36, 0x32, 0x39, 0x34, 0x64, 0x63, 0x62, 0x65, 0x37, 0x37, 0x63, 0x38, 0x36, 0x35, 0x35, 0x62, 0x65, 0x34, 0x36, 0x39, 0x35, 0x66, 0x30, 0x30, 0x36, 0x64, 0x34, 0x61, 0x33, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x63, 0x62, 0x37, 0x31, 0x61, 0x61, 0x36, 0x38, 0x38, 0x30, 0x63, 0x62, 0x30, 0x62, 0x38, 0x34, 0x30, 0x31, 0x32, 0x64, 0x39, 0x30, 0x65, 0x36, 0x30, 0x37, 0x34, 0x30, 0x65, 0x63, 0x30, 0x36, 0x61, 0x63, 0x64, 0x37, 0x38, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x37, 0x64, 0x32, 0x39, 0x39, 0x35, 0x62, 0x30, 0x65, 0x62, 0x64, 0x66, 0x33, 0x66, 0x33, 0x63, 0x61, 0x36, 0x63, 0x30, 0x31, 0x35, 0x65, 0x62, 0x30, 0x34, 0x32, 0x36, 0x30, 0x64, 0x62, 0x62, 0x39, 0x38, 0x62, 0x37, 0x63, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x33, 0x38, 0x36, 0x30, 0x66, 0x34, 0x31, 0x32, 0x31, 0x63, 0x34, 0x33, 0x32, 0x65, 0x62, 0x64, 0x63, 0x38, 0x65, 0x63, 0x36, 0x61, 0x30, 0x33, 0x33, 0x31, 0x62, 0x31, 0x62, 0x37, 0x30, 0x39, 0x37, 0x39, 0x32, 0x65, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x30, 0x30, 0x63, 0x33, 0x37, 0x36, 0x65, 0x38, 0x39, 0x63, 0x30, 0x35, 0x65, 0x38, 0x38, 0x37, 0x38, 0x31, 0x37, 0x61, 0x39, 0x64, 0x64, 0x30, 0x37, 0x34, 0x38, 0x64, 0x39, 0x36, 0x66, 0x33, 0x34, 0x31, 0x61, 0x61, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x37, 0x61, 0x30, 0x31, 0x38, 0x66, 0x30, 0x39, 0x36, 0x38, 0x61, 0x35, 0x31, 0x64, 0x31, 0x66, 0x36, 0x36, 0x30, 0x33, 0x63, 0x35, 0x63, 0x34, 0x39, 0x64, 0x63, 0x35, 0x34, 0x35, 0x62, 0x63, 0x62, 0x30, 0x66, 0x66, 0x32, 0x39, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x64, 0x37, 0x33, 0x38, 0x36, 0x33, 0x30, 0x33, 0x38, 0x63, 0x63, 0x63, 0x61, 0x32, 0x32, 0x66, 0x39, 0x36, 0x61, 0x66, 0x66, 0x64, 0x61, 0x31, 0x30, 0x34, 0x39, 0x36, 0x65, 0x35, 0x31, 0x65, 0x31, 0x65, 0x36, 0x63, 0x64, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x38, 0x65, 0x61, 0x36, 0x66, 0x35, 0x62, 0x35, 0x61, 0x37, 0x62, 0x38, 0x38, 0x34, 0x31, 0x37, 0x35, 0x35, 0x31, 0x62, 0x34, 0x31, 0x32, 0x33, 0x64, 0x63, 0x31, 0x32, 0x37, 0x64, 0x66, 0x65, 0x39, 0x33, 0x34, 0x32, 0x64, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x31, 0x34, 0x62, 0x37, 0x66, 0x36, 0x37, 0x62, 0x31, 0x34, 0x66, 0x35, 0x64, 0x39, 0x38, 0x33, 0x64, 0x38, 0x37, 0x30, 0x31, 0x34, 0x66, 0x35, 0x37, 0x30, 0x63, 0x38, 0x62, 0x39, 0x39, 0x33, 0x62, 0x39, 0x38, 0x37, 0x32, 0x62, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x63, 0x38, 0x39, 0x62, 0x64, 0x39, 0x62, 0x38, 0x33, 0x30, 0x31, 0x65, 0x36, 0x62, 0x30, 0x36, 0x37, 0x37, 0x66, 0x61, 0x32, 0x35, 0x66, 0x63, 0x66, 0x30, 0x66, 0x35, 0x38, 0x66, 0x30, 0x63, 0x63, 0x37, 0x62, 0x36, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x62, 0x34, 0x62, 0x30, 0x31, 0x38, 0x35, 0x63, 0x39, 0x32, 0x62, 0x36, 0x34, 0x33, 0x39, 0x61, 0x30, 0x38, 0x65, 0x37, 0x33, 0x32, 0x32, 0x31, 0x36, 0x38, 0x63, 0x62, 0x33, 0x35, 0x33, 0x63, 0x38, 0x61, 0x37, 0x37, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x31, 0x36, 0x35, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x39, 0x64, 0x63, 0x30, 0x38, 0x65, 0x66, 0x62, 0x62, 0x33, 0x64, 0x37, 0x32, 0x65, 0x32, 0x36, 0x33, 0x66, 0x37, 0x38, 0x61, 0x62, 0x37, 0x36, 0x31, 0x30, 0x64, 0x30, 0x32, 0x32, 0x36, 0x64, 0x65, 0x37, 0x36, 0x62, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x61, 0x38, 0x32, 0x36, 0x30, 0x38, 0x32, 0x36, 0x32, 0x39, 0x34, 0x37, 0x32, 0x36, 0x61, 0x37, 0x35, 0x62, 0x66, 0x33, 0x39, 0x63, 0x64, 0x39, 0x61, 0x61, 0x39, 0x65, 0x30, 0x37, 0x61, 0x33, 0x65, 0x61, 0x31, 0x34, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x62, 0x35, 0x63, 0x36, 0x63, 0x64, 0x37, 0x31, 0x33, 0x63, 0x61, 0x34, 0x34, 0x37, 0x62, 0x38, 0x34, 0x38, 0x61, 0x65, 0x32, 0x66, 0x35, 0x36, 0x62, 0x37, 0x36, 0x31, 0x63, 0x61, 0x31, 0x34, 0x64, 0x37, 0x61, 0x64, 0x35, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x31, 0x38, 0x35, 0x64, 0x64, 0x37, 0x63, 0x32, 0x33, 0x36, 0x33, 0x32, 0x66, 0x34, 0x36, 0x63, 0x37, 0x35, 0x39, 0x34, 0x37, 0x33, 0x65, 0x62, 0x61, 0x65, 0x39, 0x36, 0x36, 0x30, 0x30, 0x38, 0x63, 0x64, 0x33, 0x35, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x34, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x64, 0x36, 0x37, 0x61, 0x37, 0x65, 0x32, 0x35, 0x66, 0x32, 0x62, 0x31, 0x32, 0x63, 0x64, 0x62, 0x38, 0x35, 0x35, 0x38, 0x35, 0x30, 0x30, 0x39, 0x66, 0x38, 0x61, 0x63, 0x63, 0x34, 0x39, 0x62, 0x39, 0x36, 0x37, 0x33, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x39, 0x31, 0x33, 0x62, 0x35, 0x64, 0x33, 0x33, 0x39, 0x63, 0x39, 0x35, 0x64, 0x38, 0x37, 0x37, 0x34, 0x35, 0x35, 0x36, 0x32, 0x35, 0x36, 0x33, 0x66, 0x65, 0x61, 0x39, 0x38, 0x62, 0x32, 0x33, 0x63, 0x36, 0x30, 0x63, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x37, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x64, 0x63, 0x39, 0x66, 0x31, 0x62, 0x63, 0x66, 0x34, 0x64, 0x31, 0x39, 0x65, 0x65, 0x39, 0x36, 0x35, 0x39, 0x31, 0x30, 0x33, 0x30, 0x65, 0x37, 0x37, 0x32, 0x63, 0x33, 0x33, 0x34, 0x33, 0x30, 0x32, 0x66, 0x37, 0x64, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x39, 0x61, 0x35, 0x61, 0x65, 0x33, 0x63, 0x39, 0x65, 0x30, 0x35, 0x39, 0x37, 0x37, 0x64, 0x64, 0x31, 0x30, 0x36, 0x39, 0x65, 0x39, 0x66, 0x64, 0x39, 0x64, 0x33, 0x61, 0x65, 0x66, 0x62, 0x61, 0x65, 0x30, 0x34, 0x62, 0x38, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x64, 0x32, 0x39, 0x36, 0x62, 0x65, 0x30, 0x33, 0x61, 0x64, 0x37, 0x33, 0x37, 0x63, 0x39, 0x32, 0x66, 0x39, 0x63, 0x36, 0x38, 0x36, 0x39, 0x65, 0x38, 0x64, 0x38, 0x30, 0x61, 0x37, 0x31, 0x63, 0x35, 0x37, 0x31, 0x34, 0x61, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x31, 0x33, 0x36, 0x35, 0x37, 0x35, 0x32, 0x36, 0x62, 0x31, 0x37, 0x37, 0x63, 0x61, 0x64, 0x35, 0x34, 0x37, 0x63, 0x33, 0x39, 0x30, 0x38, 0x63, 0x38, 0x34, 0x30, 0x65, 0x66, 0x66, 0x36, 0x34, 0x37, 0x62, 0x34, 0x35, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x37, 0x30, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x39, 0x66, 0x63, 0x63, 0x32, 0x36, 0x65, 0x64, 0x32, 0x32, 0x35, 0x66, 0x37, 0x62, 0x32, 0x65, 0x33, 0x37, 0x39, 0x38, 0x33, 0x34, 0x63, 0x35, 0x32, 0x34, 0x64, 0x37, 0x30, 0x63, 0x31, 0x37, 0x33, 0x35, 0x65, 0x35, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x64, 0x65, 0x34, 0x33, 0x35, 0x39, 0x39, 0x65, 0x30, 0x32, 0x66, 0x38, 0x34, 0x66, 0x34, 0x63, 0x33, 0x30, 0x31, 0x34, 0x35, 0x37, 0x31, 0x63, 0x39, 0x37, 0x36, 0x62, 0x31, 0x33, 0x61, 0x33, 0x36, 0x63, 0x36, 0x35, 0x61, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x34, 0x61, 0x34, 0x66, 0x30, 0x62, 0x65, 0x62, 0x37, 0x31, 0x66, 0x66, 0x64, 0x35, 0x35, 0x38, 0x61, 0x36, 0x62, 0x36, 0x65, 0x38, 0x66, 0x32, 0x32, 0x38, 0x62, 0x37, 0x38, 0x37, 0x39, 0x36, 0x63, 0x34, 0x63, 0x66, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x64, 0x65, 0x35, 0x61, 0x61, 0x64, 0x33, 0x61, 0x35, 0x66, 0x64, 0x38, 0x30, 0x33, 0x66, 0x31, 0x62, 0x31, 0x61, 0x65, 0x62, 0x36, 0x31, 0x30, 0x33, 0x63, 0x62, 0x38, 0x65, 0x31, 0x34, 0x66, 0x65, 0x37, 0x32, 0x33, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x64, 0x36, 0x37, 0x64, 0x62, 0x64, 0x65, 0x30, 0x37, 0x61, 0x38, 0x35, 0x36, 0x65, 0x62, 0x64, 0x38, 0x39, 0x33, 0x62, 0x35, 0x65, 0x64, 0x63, 0x34, 0x66, 0x33, 0x61, 0x35, 0x62, 0x65, 0x34, 0x32, 0x30, 0x32, 0x36, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x33, 0x30, 0x66, 0x31, 0x38, 0x32, 0x33, 0x39, 0x31, 0x30, 0x62, 0x38, 0x36, 0x64, 0x33, 0x61, 0x63, 0x62, 0x35, 0x61, 0x36, 0x61, 0x66, 0x63, 0x39, 0x64, 0x65, 0x66, 0x62, 0x36, 0x66, 0x33, 0x61, 0x33, 0x30, 0x62, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x36, 0x33, 0x64, 0x31, 0x38, 0x35, 0x61, 0x37, 0x39, 0x31, 0x32, 0x39, 0x66, 0x64, 0x61, 0x62, 0x31, 0x39, 0x62, 0x35, 0x38, 0x62, 0x62, 0x36, 0x33, 0x31, 0x65, 0x61, 0x33, 0x36, 0x61, 0x34, 0x32, 0x30, 0x35, 0x34, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x66, 0x36, 0x36, 0x30, 0x61, 0x39, 0x31, 0x64, 0x61, 0x62, 0x39, 0x66, 0x37, 0x33, 0x30, 0x66, 0x36, 0x31, 0x39, 0x30, 0x64, 0x35, 0x30, 0x63, 0x38, 0x33, 0x39, 0x30, 0x35, 0x36, 0x31, 0x35, 0x30, 0x30, 0x37, 0x35, 0x36, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x61, 0x31, 0x66, 0x30, 0x66, 0x61, 0x36, 0x64, 0x32, 0x30, 0x62, 0x35, 0x30, 0x61, 0x37, 0x39, 0x34, 0x66, 0x30, 0x32, 0x65, 0x66, 0x35, 0x32, 0x30, 0x38, 0x35, 0x63, 0x39, 0x64, 0x30, 0x33, 0x36, 0x61, 0x61, 0x36, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x65, 0x63, 0x37, 0x36, 0x38, 0x32, 0x39, 0x35, 0x65, 0x65, 0x61, 0x62, 0x61, 0x66, 0x63, 0x34, 0x32, 0x39, 0x35, 0x38, 0x34, 0x31, 0x35, 0x65, 0x32, 0x32, 0x62, 0x65, 0x32, 0x31, 0x36, 0x63, 0x64, 0x65, 0x37, 0x37, 0x36, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x34, 0x38, 0x66, 0x63, 0x35, 0x61, 0x34, 0x36, 0x31, 0x33, 0x32, 0x33, 0x62, 0x35, 0x37, 0x62, 0x65, 0x33, 0x30, 0x33, 0x63, 0x62, 0x38, 0x39, 0x33, 0x36, 0x31, 0x62, 0x39, 0x39, 0x31, 0x39, 0x31, 0x33, 0x64, 0x66, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x37, 0x64, 0x62, 0x32, 0x32, 0x34, 0x61, 0x63, 0x61, 0x65, 0x31, 0x37, 0x64, 0x65, 0x37, 0x37, 0x39, 0x38, 0x37, 0x39, 0x37, 0x64, 0x38, 0x32, 0x63, 0x64, 0x66, 0x38, 0x32, 0x35, 0x33, 0x30, 0x31, 0x37, 0x64, 0x66, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x65, 0x61, 0x34, 0x30, 0x33, 0x37, 0x39, 0x33, 0x34, 0x37, 0x61, 0x35, 0x63, 0x38, 0x39, 0x31, 0x64, 0x35, 0x39, 0x61, 0x36, 0x33, 0x36, 0x33, 0x33, 0x31, 0x35, 0x36, 0x34, 0x30, 0x66, 0x35, 0x61, 0x37, 0x65, 0x30, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x35, 0x37, 0x66, 0x63, 0x61, 0x31, 0x36, 0x61, 0x36, 0x65, 0x35, 0x63, 0x32, 0x61, 0x36, 0x34, 0x37, 0x63, 0x33, 0x63, 0x32, 0x39, 0x66, 0x33, 0x36, 0x63, 0x65, 0x32, 0x32, 0x39, 0x61, 0x62, 0x39, 0x33, 0x62, 0x31, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x34, 0x39, 0x32, 0x38, 0x31, 0x38, 0x61, 0x61, 0x36, 0x38, 0x34, 0x65, 0x35, 0x61, 0x36, 0x37, 0x36, 0x35, 0x36, 0x31, 0x62, 0x37, 0x32, 0x35, 0x64, 0x34, 0x32, 0x66, 0x33, 0x63, 0x63, 0x35, 0x36, 0x61, 0x65, 0x35, 0x31, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x34, 0x31, 0x38, 0x38, 0x34, 0x66, 0x61, 0x34, 0x37, 0x38, 0x35, 0x66, 0x62, 0x37, 0x37, 0x33, 0x62, 0x32, 0x38, 0x65, 0x39, 0x37, 0x31, 0x35, 0x66, 0x61, 0x65, 0x39, 0x39, 0x61, 0x35, 0x31, 0x33, 0x34, 0x33, 0x30, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x39, 0x34, 0x34, 0x33, 0x61, 0x37, 0x39, 0x34, 0x36, 0x38, 0x61, 0x35, 0x62, 0x62, 0x66, 0x37, 0x63, 0x31, 0x33, 0x63, 0x36, 0x65, 0x32, 0x32, 0x35, 0x64, 0x31, 0x64, 0x65, 0x39, 0x31, 0x61, 0x65, 0x65, 0x30, 0x37, 0x64, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x64, 0x34, 0x30, 0x30, 0x38, 0x62, 0x34, 0x61, 0x38, 0x38, 0x38, 0x61, 0x38, 0x32, 0x36, 0x66, 0x32, 0x34, 0x38, 0x65, 0x65, 0x36, 0x61, 0x30, 0x62, 0x30, 0x64, 0x66, 0x64, 0x65, 0x39, 0x66, 0x39, 0x33, 0x32, 0x31, 0x30, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x34, 0x39, 0x38, 0x30, 0x65, 0x62, 0x34, 0x35, 0x36, 0x35, 0x63, 0x31, 0x30, 0x34, 0x38, 0x33, 0x31, 0x37, 0x61, 0x38, 0x66, 0x34, 0x37, 0x66, 0x64, 0x62, 0x62, 0x34, 0x36, 0x31, 0x39, 0x36, 0x35, 0x62, 0x65, 0x34, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x39, 0x39, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x35, 0x64, 0x37, 0x30, 0x64, 0x32, 0x30, 0x37, 0x38, 0x39, 0x32, 0x62, 0x65, 0x64, 0x33, 0x39, 0x38, 0x35, 0x39, 0x30, 0x30, 0x32, 0x34, 0x65, 0x32, 0x34, 0x32, 0x31, 0x62, 0x31, 0x63, 0x63, 0x31, 0x31, 0x39, 0x33, 0x35, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x65, 0x63, 0x38, 0x66, 0x65, 0x36, 0x39, 0x62, 0x37, 0x37, 0x31, 0x36, 0x63, 0x30, 0x38, 0x36, 0x35, 0x61, 0x66, 0x38, 0x38, 0x38, 0x61, 0x31, 0x31, 0x62, 0x32, 0x62, 0x31, 0x32, 0x66, 0x37, 0x32, 0x30, 0x65, 0x64, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x39, 0x62, 0x37, 0x34, 0x65, 0x31, 0x36, 0x39, 0x32, 0x36, 0x35, 0x66, 0x30, 0x31, 0x61, 0x38, 0x39, 0x65, 0x63, 0x34, 0x63, 0x39, 0x30, 0x37, 0x32, 0x63, 0x35, 0x61, 0x34, 0x63, 0x64, 0x37, 0x32, 0x65, 0x34, 0x65, 0x38, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x33, 0x65, 0x39, 0x35, 0x63, 0x63, 0x33, 0x39, 0x35, 0x37, 0x64, 0x32, 0x35, 0x32, 0x63, 0x65, 0x30, 0x62, 0x66, 0x30, 0x63, 0x38, 0x37, 0x64, 0x35, 0x62, 0x34, 0x66, 0x32, 0x32, 0x33, 0x34, 0x36, 0x37, 0x32, 0x65, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x66, 0x66, 0x31, 0x31, 0x35, 0x64, 0x30, 0x31, 0x32, 0x36, 0x36, 0x63, 0x39, 0x66, 0x37, 0x33, 0x62, 0x30, 0x36, 0x33, 0x63, 0x31, 0x63, 0x32, 0x33, 0x38, 0x65, 0x66, 0x33, 0x35, 0x36, 0x35, 0x65, 0x36, 0x33, 0x62, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x38, 0x63, 0x35, 0x63, 0x36, 0x39, 0x37, 0x30, 0x62, 0x39, 0x31, 0x36, 0x31, 0x62, 0x62, 0x31, 0x63, 0x37, 0x62, 0x37, 0x61, 0x64, 0x66, 0x65, 0x64, 0x39, 0x63, 0x64, 0x65, 0x64, 0x65, 0x38, 0x61, 0x31, 0x62, 0x61, 0x38, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x36, 0x61, 0x66, 0x65, 0x32, 0x63, 0x63, 0x39, 0x32, 0x38, 0x61, 0x63, 0x38, 0x33, 0x39, 0x31, 0x65, 0x62, 0x31, 0x65, 0x31, 0x36, 0x35, 0x66, 0x63, 0x34, 0x30, 0x30, 0x34, 0x30, 0x65, 0x33, 0x37, 0x34, 0x32, 0x31, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x37, 0x35, 0x36, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x63, 0x63, 0x64, 0x61, 0x35, 0x30, 0x65, 0x34, 0x62, 0x32, 0x36, 0x61, 0x30, 0x66, 0x66, 0x63, 0x30, 0x65, 0x66, 0x39, 0x32, 0x65, 0x39, 0x32, 0x30, 0x35, 0x33, 0x31, 0x30, 0x37, 0x30, 0x36, 0x62, 0x65, 0x63, 0x32, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x37, 0x37, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x65, 0x39, 0x61, 0x33, 0x39, 0x64, 0x37, 0x35, 0x30, 0x66, 0x65, 0x39, 0x39, 0x34, 0x33, 0x39, 0x34, 0x65, 0x62, 0x36, 0x38, 0x32, 0x38, 0x36, 0x65, 0x35, 0x65, 0x61, 0x36, 0x32, 0x61, 0x36, 0x39, 0x39, 0x37, 0x38, 0x38, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x62, 0x35, 0x38, 0x31, 0x30, 0x31, 0x66, 0x34, 0x34, 0x66, 0x37, 0x65, 0x33, 0x38, 0x39, 0x65, 0x31, 0x32, 0x64, 0x34, 0x37, 0x31, 0x64, 0x31, 0x36, 0x33, 0x35, 0x62, 0x37, 0x31, 0x36, 0x31, 0x34, 0x66, 0x64, 0x64, 0x36, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x39, 0x33, 0x64, 0x61, 0x63, 0x37, 0x38, 0x35, 0x66, 0x38, 0x38, 0x66, 0x31, 0x61, 0x38, 0x34, 0x62, 0x66, 0x39, 0x32, 0x37, 0x64, 0x35, 0x33, 0x36, 0x35, 0x32, 0x62, 0x34, 0x35, 0x61, 0x31, 0x35, 0x34, 0x63, 0x63, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x31, 0x35, 0x64, 0x30, 0x39, 0x36, 0x61, 0x62, 0x30, 0x36, 0x32, 0x39, 0x33, 0x31, 0x38, 0x33, 0x66, 0x33, 0x63, 0x30, 0x33, 0x33, 0x64, 0x32, 0x35, 0x66, 0x36, 0x63, 0x66, 0x37, 0x31, 0x37, 0x38, 0x61, 0x63, 0x33, 0x62, 0x63, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x65, 0x33, 0x38, 0x37, 0x62, 0x30, 0x33, 0x63, 0x65, 0x39, 0x35, 0x63, 0x63, 0x66, 0x64, 0x37, 0x66, 0x61, 0x35, 0x31, 0x64, 0x64, 0x38, 0x34, 0x30, 0x31, 0x38, 0x33, 0x62, 0x63, 0x34, 0x33, 0x35, 0x33, 0x32, 0x38, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x33, 0x34, 0x62, 0x32, 0x65, 0x61, 0x65, 0x33, 0x30, 0x62, 0x61, 0x66, 0x65, 0x38, 0x64, 0x61, 0x65, 0x63, 0x63, 0x64, 0x65, 0x38, 0x31, 0x39, 0x61, 0x37, 0x39, 0x34, 0x63, 0x64, 0x38, 0x39, 0x65, 0x30, 0x39, 0x35, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x61, 0x32, 0x37, 0x39, 0x62, 0x66, 0x64, 0x38, 0x37, 0x36, 0x37, 0x66, 0x39, 0x35, 0x36, 0x62, 0x66, 0x37, 0x66, 0x61, 0x30, 0x62, 0x64, 0x35, 0x36, 0x36, 0x30, 0x31, 0x36, 0x38, 0x64, 0x61, 0x37, 0x35, 0x36, 0x38, 0x36, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x38, 0x63, 0x61, 0x33, 0x31, 0x37, 0x38, 0x35, 0x65, 0x66, 0x30, 0x36, 0x62, 0x65, 0x34, 0x39, 0x61, 0x31, 0x65, 0x34, 0x37, 0x65, 0x38, 0x36, 0x34, 0x66, 0x36, 0x30, 0x64, 0x30, 0x37, 0x36, 0x63, 0x61, 0x34, 0x37, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x36, 0x38, 0x62, 0x35, 0x32, 0x33, 0x34, 0x65, 0x62, 0x61, 0x33, 0x61, 0x39, 0x39, 0x36, 0x38, 0x62, 0x33, 0x34, 0x64, 0x36, 0x64, 0x64, 0x62, 0x34, 0x38, 0x31, 0x63, 0x38, 0x34, 0x31, 0x39, 0x62, 0x33, 0x36, 0x35, 0x35, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x31, 0x30, 0x34, 0x37, 0x64, 0x37, 0x30, 0x33, 0x66, 0x36, 0x33, 0x62, 0x39, 0x33, 0x34, 0x32, 0x34, 0x66, 0x62, 0x62, 0x64, 0x36, 0x65, 0x32, 0x66, 0x31, 0x66, 0x39, 0x65, 0x37, 0x34, 0x64, 0x65, 0x31, 0x33, 0x65, 0x37, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x35, 0x30, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x61, 0x32, 0x34, 0x63, 0x65, 0x38, 0x64, 0x34, 0x38, 0x35, 0x63, 0x63, 0x34, 0x63, 0x38, 0x36, 0x65, 0x34, 0x39, 0x64, 0x65, 0x62, 0x33, 0x39, 0x30, 0x32, 0x32, 0x66, 0x39, 0x32, 0x63, 0x37, 0x34, 0x33, 0x30, 0x65, 0x36, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x32, 0x66, 0x39, 0x64, 0x37, 0x63, 0x36, 0x34, 0x65, 0x38, 0x65, 0x32, 0x36, 0x33, 0x35, 0x61, 0x65, 0x62, 0x38, 0x38, 0x33, 0x64, 0x64, 0x37, 0x33, 0x62, 0x61, 0x36, 0x38, 0x34, 0x65, 0x65, 0x37, 0x63, 0x31, 0x30, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x31, 0x35, 0x64, 0x39, 0x64, 0x35, 0x61, 0x32, 0x31, 0x62, 0x31, 0x39, 0x32, 0x39, 0x65, 0x37, 0x39, 0x30, 0x33, 0x37, 0x31, 0x61, 0x31, 0x37, 0x66, 0x31, 0x36, 0x64, 0x39, 0x35, 0x66, 0x30, 0x63, 0x36, 0x39, 0x36, 0x35, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x35, 0x61, 0x65, 0x35, 0x31, 0x62, 0x39, 0x35, 0x30, 0x30, 0x63, 0x35, 0x38, 0x64, 0x35, 0x34, 0x31, 0x33, 0x36, 0x35, 0x64, 0x39, 0x37, 0x35, 0x36, 0x39, 0x66, 0x31, 0x34, 0x62, 0x62, 0x32, 0x61, 0x33, 0x37, 0x30, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x39, 0x63, 0x31, 0x37, 0x37, 0x66, 0x31, 0x61, 0x65, 0x34, 0x34, 0x32, 0x34, 0x31, 0x31, 0x64, 0x64, 0x61, 0x63, 0x66, 0x31, 0x38, 0x37, 0x64, 0x34, 0x36, 0x64, 0x62, 0x39, 0x35, 0x36, 0x31, 0x34, 0x38, 0x33, 0x36, 0x30, 0x65, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x31, 0x37, 0x33, 0x30, 0x37, 0x34, 0x39, 0x38, 0x30, 0x31, 0x35, 0x33, 0x61, 0x65, 0x61, 0x61, 0x34, 0x62, 0x30, 0x64, 0x63, 0x62, 0x63, 0x37, 0x31, 0x33, 0x32, 0x65, 0x61, 0x64, 0x63, 0x65, 0x63, 0x32, 0x31, 0x62, 0x36, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x31, 0x66, 0x31, 0x36, 0x65, 0x35, 0x65, 0x30, 0x37, 0x33, 0x35, 0x61, 0x66, 0x35, 0x36, 0x37, 0x35, 0x31, 0x62, 0x30, 0x65, 0x32, 0x32, 0x35, 0x62, 0x32, 0x34, 0x32, 0x31, 0x31, 0x37, 0x31, 0x33, 0x39, 0x34, 0x30, 0x39, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x35, 0x32, 0x62, 0x37, 0x37, 0x65, 0x31, 0x35, 0x36, 0x36, 0x34, 0x38, 0x31, 0x34, 0x66, 0x33, 0x39, 0x65, 0x34, 0x66, 0x32, 0x37, 0x31, 0x62, 0x65, 0x36, 0x34, 0x31, 0x33, 0x30, 0x38, 0x64, 0x39, 0x31, 0x64, 0x36, 0x63, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x39, 0x63, 0x38, 0x38, 0x33, 0x32, 0x35, 0x38, 0x35, 0x34, 0x36, 0x63, 0x63, 0x37, 0x65, 0x34, 0x65, 0x39, 0x37, 0x31, 0x66, 0x35, 0x32, 0x32, 0x65, 0x33, 0x38, 0x39, 0x39, 0x31, 0x38, 0x64, 0x61, 0x35, 0x65, 0x61, 0x36, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x61, 0x31, 0x36, 0x32, 0x36, 0x39, 0x61, 0x61, 0x63, 0x39, 0x63, 0x30, 0x64, 0x38, 0x30, 0x33, 0x30, 0x36, 0x38, 0x64, 0x38, 0x32, 0x66, 0x63, 0x37, 0x39, 0x31, 0x35, 0x31, 0x64, 0x61, 0x64, 0x64, 0x33, 0x33, 0x34, 0x62, 0x36, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x39, 0x61, 0x31, 0x31, 0x30, 0x63, 0x62, 0x31, 0x31, 0x66, 0x32, 0x35, 0x39, 0x38, 0x62, 0x32, 0x62, 0x32, 0x30, 0x65, 0x32, 0x63, 0x61, 0x34, 0x30, 0x30, 0x33, 0x32, 0x35, 0x65, 0x34, 0x31, 0x65, 0x39, 0x64, 0x62, 0x33, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x33, 0x65, 0x38, 0x33, 0x62, 0x61, 0x35, 0x35, 0x65, 0x36, 0x37, 0x65, 0x31, 0x33, 0x65, 0x30, 0x65, 0x37, 0x36, 0x66, 0x38, 0x33, 0x39, 0x32, 0x64, 0x38, 0x37, 0x33, 0x63, 0x64, 0x32, 0x31, 0x66, 0x62, 0x66, 0x37, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x35, 0x65, 0x62, 0x65, 0x38, 0x34, 0x64, 0x61, 0x61, 0x34, 0x32, 0x62, 0x61, 0x32, 0x35, 0x36, 0x65, 0x61, 0x37, 0x38, 0x39, 0x31, 0x30, 0x35, 0x63, 0x65, 0x63, 0x34, 0x62, 0x36, 0x39, 0x33, 0x66, 0x31, 0x32, 0x66, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x38, 0x63, 0x34, 0x33, 0x30, 0x63, 0x65, 0x34, 0x33, 0x35, 0x39, 0x62, 0x30, 0x36, 0x62, 0x63, 0x32, 0x63, 0x64, 0x66, 0x35, 0x63, 0x32, 0x39, 0x38, 0x35, 0x66, 0x63, 0x39, 0x35, 0x30, 0x65, 0x35, 0x30, 0x64, 0x35, 0x63, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x31, 0x65, 0x62, 0x39, 0x62, 0x36, 0x65, 0x36, 0x34, 0x33, 0x35, 0x31, 0x66, 0x35, 0x36, 0x34, 0x32, 0x34, 0x35, 0x30, 0x39, 0x36, 0x34, 0x35, 0x66, 0x38, 0x33, 0x65, 0x37, 0x39, 0x65, 0x65, 0x65, 0x37, 0x36, 0x63, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x32, 0x39, 0x30, 0x63, 0x30, 0x31, 0x39, 0x36, 0x37, 0x63, 0x38, 0x31, 0x32, 0x65, 0x34, 0x64, 0x63, 0x34, 0x63, 0x39, 0x30, 0x62, 0x31, 0x37, 0x34, 0x63, 0x31, 0x62, 0x34, 0x30, 0x31, 0x35, 0x62, 0x61, 0x65, 0x37, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x34, 0x39, 0x39, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x64, 0x32, 0x31, 0x33, 0x39, 0x34, 0x37, 0x66, 0x63, 0x62, 0x39, 0x30, 0x34, 0x61, 0x64, 0x37, 0x33, 0x38, 0x34, 0x38, 0x30, 0x62, 0x31, 0x65, 0x65, 0x64, 0x32, 0x66, 0x35, 0x63, 0x33, 0x32, 0x39, 0x66, 0x32, 0x37, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x37, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x31, 0x37, 0x64, 0x30, 0x33, 0x31, 0x35, 0x63, 0x38, 0x37, 0x38, 0x38, 0x31, 0x33, 0x63, 0x37, 0x31, 0x37, 0x65, 0x31, 0x38, 0x63, 0x61, 0x66, 0x61, 0x31, 0x65, 0x61, 0x62, 0x32, 0x36, 0x35, 0x34, 0x65, 0x30, 0x31, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x39, 0x37, 0x32, 0x61, 0x38, 0x61, 0x37, 0x63, 0x32, 0x61, 0x34, 0x34, 0x63, 0x39, 0x33, 0x62, 0x32, 0x31, 0x34, 0x33, 0x36, 0x63, 0x33, 0x38, 0x64, 0x32, 0x31, 0x62, 0x39, 0x32, 0x35, 0x32, 0x63, 0x33, 0x34, 0x35, 0x66, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x63, 0x62, 0x32, 0x38, 0x61, 0x63, 0x31, 0x61, 0x32, 0x30, 0x61, 0x31, 0x30, 0x36, 0x66, 0x37, 0x66, 0x33, 0x37, 0x33, 0x36, 0x39, 0x32, 0x63, 0x35, 0x63, 0x65, 0x34, 0x63, 0x37, 0x33, 0x66, 0x31, 0x33, 0x37, 0x33, 0x32, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x61, 0x62, 0x31, 0x36, 0x34, 0x62, 0x33, 0x62, 0x35, 0x32, 0x34, 0x63, 0x38, 0x32, 0x64, 0x36, 0x61, 0x62, 0x66, 0x62, 0x63, 0x30, 0x64, 0x65, 0x38, 0x33, 0x31, 0x31, 0x32, 0x36, 0x61, 0x65, 0x38, 0x64, 0x31, 0x33, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x34, 0x36, 0x66, 0x38, 0x32, 0x32, 0x33, 0x34, 0x35, 0x32, 0x39, 0x38, 0x32, 0x61, 0x31, 0x65, 0x65, 0x61, 0x30, 0x31, 0x39, 0x61, 0x38, 0x38, 0x31, 0x36, 0x65, 0x66, 0x63, 0x32, 0x64, 0x36, 0x66, 0x63, 0x30, 0x30, 0x37, 0x36, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x64, 0x63, 0x34, 0x37, 0x30, 0x38, 0x66, 0x31, 0x34, 0x66, 0x34, 0x30, 0x64, 0x63, 0x63, 0x31, 0x35, 0x61, 0x37, 0x39, 0x35, 0x66, 0x37, 0x64, 0x63, 0x38, 0x63, 0x62, 0x30, 0x62, 0x37, 0x66, 0x61, 0x61, 0x39, 0x65, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x36, 0x66, 0x64, 0x63, 0x39, 0x66, 0x65, 0x65, 0x33, 0x35, 0x31, 0x66, 0x61, 0x31, 0x35, 0x33, 0x38, 0x65, 0x62, 0x30, 0x64, 0x38, 0x37, 0x64, 0x38, 0x31, 0x39, 0x66, 0x63, 0x66, 0x30, 0x39, 0x65, 0x37, 0x63, 0x31, 0x30, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x31, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x37, 0x62, 0x65, 0x38, 0x32, 0x63, 0x36, 0x35, 0x39, 0x33, 0x63, 0x31, 0x65, 0x65, 0x64, 0x64, 0x64, 0x32, 0x61, 0x65, 0x30, 0x62, 0x31, 0x35, 0x30, 0x30, 0x31, 0x66, 0x66, 0x32, 0x30, 0x31, 0x61, 0x62, 0x35, 0x37, 0x62, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x64, 0x32, 0x30, 0x65, 0x36, 0x61, 0x65, 0x34, 0x63, 0x61, 0x64, 0x33, 0x66, 0x38, 0x32, 0x39, 0x65, 0x61, 0x63, 0x30, 0x37, 0x65, 0x35, 0x61, 0x63, 0x39, 0x37, 0x62, 0x36, 0x36, 0x66, 0x64, 0x64, 0x35, 0x36, 0x63, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x32, 0x64, 0x38, 0x64, 0x61, 0x66, 0x30, 0x34, 0x62, 0x35, 0x34, 0x31, 0x34, 0x61, 0x30, 0x32, 0x36, 0x31, 0x66, 0x35, 0x34, 0x39, 0x66, 0x66, 0x36, 0x34, 0x37, 0x37, 0x62, 0x38, 0x30, 0x66, 0x32, 0x66, 0x31, 0x64, 0x30, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x34, 0x62, 0x66, 0x63, 0x65, 0x66, 0x30, 0x34, 0x39, 0x31, 0x61, 0x30, 0x61, 0x65, 0x30, 0x36, 0x39, 0x34, 0x62, 0x33, 0x37, 0x63, 0x65, 0x61, 0x63, 0x30, 0x32, 0x34, 0x35, 0x38, 0x34, 0x66, 0x32, 0x61, 0x61, 0x30, 0x34, 0x36, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x63, 0x35, 0x66, 0x65, 0x61, 0x66, 0x65, 0x32, 0x31, 0x30, 0x63, 0x31, 0x32, 0x62, 0x66, 0x63, 0x39, 0x61, 0x35, 0x64, 0x30, 0x35, 0x39, 0x32, 0x35, 0x61, 0x31, 0x32, 0x33, 0x66, 0x31, 0x65, 0x37, 0x33, 0x66, 0x62, 0x65, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x32, 0x33, 0x63, 0x37, 0x30, 0x39, 0x35, 0x36, 0x65, 0x30, 0x34, 0x61, 0x39, 0x32, 0x64, 0x37, 0x30, 0x30, 0x32, 0x35, 0x61, 0x61, 0x64, 0x32, 0x39, 0x37, 0x62, 0x35, 0x33, 0x39, 0x61, 0x66, 0x33, 0x35, 0x35, 0x38, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x36, 0x64, 0x64, 0x66, 0x31, 0x31, 0x35, 0x39, 0x63, 0x66, 0x32, 0x32, 0x66, 0x64, 0x38, 0x63, 0x37, 0x61, 0x34, 0x62, 0x63, 0x38, 0x64, 0x35, 0x38, 0x30, 0x37, 0x37, 0x35, 0x36, 0x64, 0x34, 0x33, 0x33, 0x63, 0x34, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x36, 0x33, 0x38, 0x65, 0x61, 0x35, 0x37, 0x31, 0x38, 0x39, 0x61, 0x36, 0x61, 0x36, 0x39, 0x39, 0x30, 0x32, 0x34, 0x61, 0x64, 0x37, 0x38, 0x63, 0x37, 0x31, 0x64, 0x39, 0x33, 0x39, 0x63, 0x31, 0x63, 0x32, 0x66, 0x66, 0x38, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x30, 0x64, 0x32, 0x35, 0x65, 0x64, 0x32, 0x63, 0x38, 0x61, 0x64, 0x61, 0x35, 0x39, 0x63, 0x30, 0x38, 0x38, 0x63, 0x66, 0x37, 0x30, 0x64, 0x64, 0x32, 0x32, 0x62, 0x66, 0x32, 0x64, 0x62, 0x39, 0x33, 0x61, 0x63, 0x63, 0x31, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x35, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x38, 0x37, 0x35, 0x39, 0x32, 0x38, 0x34, 0x35, 0x38, 0x65, 0x63, 0x32, 0x30, 0x30, 0x35, 0x64, 0x62, 0x62, 0x35, 0x37, 0x38, 0x63, 0x35, 0x63, 0x64, 0x33, 0x33, 0x35, 0x38, 0x30, 0x66, 0x30, 0x63, 0x66, 0x31, 0x34, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x61, 0x64, 0x35, 0x31, 0x35, 0x37, 0x64, 0x64, 0x61, 0x39, 0x32, 0x31, 0x65, 0x36, 0x62, 0x61, 0x66, 0x61, 0x63, 0x64, 0x39, 0x30, 0x38, 0x36, 0x61, 0x65, 0x37, 0x33, 0x61, 0x65, 0x31, 0x66, 0x36, 0x31, 0x31, 0x64, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x39, 0x33, 0x34, 0x38, 0x39, 0x65, 0x35, 0x36, 0x63, 0x33, 0x62, 0x64, 0x64, 0x38, 0x32, 0x39, 0x30, 0x30, 0x37, 0x64, 0x63, 0x32, 0x66, 0x39, 0x35, 0x36, 0x34, 0x31, 0x32, 0x39, 0x30, 0x36, 0x66, 0x37, 0x36, 0x62, 0x66, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x39, 0x36, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x37, 0x36, 0x31, 0x32, 0x64, 0x65, 0x39, 0x31, 0x31, 0x31, 0x30, 0x63, 0x34, 0x38, 0x32, 0x65, 0x36, 0x66, 0x35, 0x30, 0x35, 0x62, 0x63, 0x64, 0x32, 0x33, 0x66, 0x33, 0x63, 0x35, 0x30, 0x34, 0x37, 0x64, 0x31, 0x64, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x31, 0x38, 0x34, 0x37, 0x38, 0x36, 0x35, 0x35, 0x61, 0x34, 0x38, 0x35, 0x31, 0x63, 0x63, 0x39, 0x30, 0x36, 0x65, 0x36, 0x36, 0x30, 0x66, 0x65, 0x61, 0x63, 0x36, 0x31, 0x66, 0x37, 0x66, 0x34, 0x63, 0x38, 0x62, 0x66, 0x66, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x31, 0x37, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x31, 0x62, 0x37, 0x39, 0x37, 0x39, 0x62, 0x66, 0x37, 0x63, 0x35, 0x63, 0x61, 0x30, 0x31, 0x66, 0x61, 0x38, 0x32, 0x64, 0x64, 0x36, 0x34, 0x30, 0x62, 0x34, 0x31, 0x63, 0x33, 0x39, 0x65, 0x36, 0x63, 0x36, 0x62, 0x63, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x39, 0x64, 0x34, 0x61, 0x32, 0x62, 0x63, 0x62, 0x65, 0x35, 0x62, 0x39, 0x65, 0x30, 0x38, 0x36, 0x39, 0x64, 0x37, 0x30, 0x66, 0x30, 0x66, 0x65, 0x32, 0x65, 0x31, 0x64, 0x36, 0x61, 0x61, 0x63, 0x64, 0x34, 0x35, 0x65, 0x64, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x32, 0x39, 0x62, 0x62, 0x33, 0x37, 0x35, 0x62, 0x65, 0x35, 0x65, 0x64, 0x33, 0x34, 0x65, 0x64, 0x39, 0x39, 0x39, 0x62, 0x62, 0x38, 0x33, 0x30, 0x65, 0x65, 0x32, 0x39, 0x35, 0x37, 0x64, 0x64, 0x65, 0x37, 0x36, 0x64, 0x31, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x30, 0x30, 0x36, 0x32, 0x36, 0x38, 0x34, 0x34, 0x36, 0x36, 0x34, 0x33, 0x65, 0x63, 0x35, 0x65, 0x38, 0x31, 0x65, 0x37, 0x61, 0x63, 0x62, 0x33, 0x66, 0x31, 0x37, 0x66, 0x31, 0x63, 0x33, 0x35, 0x31, 0x65, 0x65, 0x32, 0x65, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x64, 0x64, 0x64, 0x30, 0x31, 0x34, 0x64, 0x63, 0x35, 0x32, 0x62, 0x66, 0x62, 0x63, 0x63, 0x35, 0x35, 0x35, 0x33, 0x32, 0x35, 0x61, 0x34, 0x30, 0x62, 0x35, 0x31, 0x36, 0x66, 0x34, 0x38, 0x36, 0x36, 0x61, 0x31, 0x64, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x64, 0x36, 0x37, 0x37, 0x36, 0x39, 0x35, 0x38, 0x65, 0x65, 0x32, 0x33, 0x31, 0x34, 0x33, 0x61, 0x38, 0x31, 0x61, 0x64, 0x61, 0x64, 0x65, 0x62, 0x30, 0x38, 0x33, 0x38, 0x32, 0x30, 0x30, 0x39, 0x65, 0x39, 0x39, 0x36, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x33, 0x34, 0x65, 0x30, 0x33, 0x64, 0x33, 0x36, 0x61, 0x32, 0x62, 0x64, 0x34, 0x64, 0x31, 0x39, 0x61, 0x35, 0x66, 0x61, 0x31, 0x36, 0x32, 0x31, 0x38, 0x64, 0x31, 0x64, 0x36, 0x31, 0x65, 0x33, 0x66, 0x66, 0x61, 0x30, 0x62, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x63, 0x30, 0x63, 0x31, 0x37, 0x37, 0x66, 0x31, 0x31, 0x63, 0x35, 0x63, 0x33, 0x65, 0x33, 0x65, 0x37, 0x38, 0x66, 0x32, 0x65, 0x66, 0x64, 0x36, 0x36, 0x33, 0x64, 0x31, 0x33, 0x32, 0x32, 0x31, 0x34, 0x38, 0x38, 0x35, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x31, 0x34, 0x31, 0x33, 0x35, 0x64, 0x61, 0x38, 0x66, 0x39, 0x38, 0x31, 0x31, 0x30, 0x37, 0x35, 0x37, 0x38, 0x33, 0x62, 0x66, 0x31, 0x61, 0x62, 0x36, 0x37, 0x30, 0x36, 0x32, 0x61, 0x66, 0x38, 0x64, 0x33, 0x65, 0x39, 0x66, 0x34, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x33, 0x65, 0x62, 0x37, 0x31, 0x33, 0x63, 0x34, 0x63, 0x39, 0x65, 0x30, 0x33, 0x38, 0x31, 0x63, 0x64, 0x38, 0x31, 0x35, 0x34, 0x63, 0x37, 0x63, 0x39, 0x61, 0x37, 0x64, 0x62, 0x38, 0x36, 0x34, 0x35, 0x63, 0x64, 0x65, 0x31, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x39, 0x63, 0x34, 0x37, 0x62, 0x33, 0x65, 0x66, 0x64, 0x38, 0x36, 0x62, 0x36, 0x65, 0x36, 0x61, 0x35, 0x62, 0x63, 0x39, 0x34, 0x31, 0x38, 0x64, 0x31, 0x66, 0x39, 0x66, 0x65, 0x63, 0x38, 0x31, 0x34, 0x62, 0x36, 0x39, 0x65, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x66, 0x31, 0x64, 0x61, 0x31, 0x32, 0x37, 0x62, 0x38, 0x33, 0x33, 0x37, 0x36, 0x66, 0x31, 0x62, 0x38, 0x38, 0x63, 0x38, 0x32, 0x61, 0x33, 0x33, 0x35, 0x39, 0x66, 0x36, 0x37, 0x61, 0x35, 0x65, 0x36, 0x37, 0x64, 0x64, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x34, 0x64, 0x66, 0x62, 0x61, 0x35, 0x30, 0x62, 0x38, 0x32, 0x39, 0x62, 0x65, 0x63, 0x63, 0x35, 0x66, 0x34, 0x66, 0x31, 0x34, 0x64, 0x31, 0x62, 0x30, 0x34, 0x61, 0x61, 0x62, 0x33, 0x33, 0x32, 0x30, 0x61, 0x32, 0x39, 0x35, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x39, 0x32, 0x34, 0x64, 0x66, 0x30, 0x30, 0x37, 0x65, 0x39, 0x63, 0x30, 0x38, 0x37, 0x38, 0x34, 0x31, 0x37, 0x63, 0x66, 0x65, 0x36, 0x33, 0x62, 0x39, 0x37, 0x36, 0x65, 0x61, 0x31, 0x61, 0x33, 0x38, 0x32, 0x61, 0x38, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x34, 0x33, 0x38, 0x66, 0x64, 0x32, 0x62, 0x33, 0x32, 0x61, 0x39, 0x62, 0x64, 0x64, 0x36, 0x37, 0x34, 0x62, 0x34, 0x39, 0x64, 0x38, 0x63, 0x63, 0x35, 0x66, 0x61, 0x32, 0x65, 0x66, 0x66, 0x39, 0x37, 0x38, 0x31, 0x38, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x39, 0x34, 0x35, 0x32, 0x39, 0x64, 0x30, 0x39, 0x64, 0x30, 0x31, 0x37, 0x32, 0x37, 0x31, 0x33, 0x35, 0x39, 0x37, 0x33, 0x30, 0x30, 0x32, 0x37, 0x30, 0x37, 0x35, 0x62, 0x38, 0x37, 0x61, 0x64, 0x38, 0x33, 0x64, 0x61, 0x65, 0x36, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x62, 0x34, 0x39, 0x31, 0x30, 0x30, 0x37, 0x35, 0x37, 0x37, 0x37, 0x32, 0x66, 0x33, 0x33, 0x63, 0x31, 0x37, 0x37, 0x62, 0x39, 0x61, 0x37, 0x36, 0x62, 0x61, 0x39, 0x35, 0x32, 0x32, 0x36, 0x63, 0x38, 0x66, 0x33, 0x64, 0x64, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x36, 0x33, 0x63, 0x34, 0x39, 0x33, 0x36, 0x31, 0x62, 0x36, 0x32, 0x35, 0x65, 0x37, 0x36, 0x38, 0x37, 0x37, 0x31, 0x63, 0x39, 0x36, 0x31, 0x35, 0x31, 0x64, 0x62, 0x66, 0x62, 0x64, 0x31, 0x63, 0x39, 0x30, 0x36, 0x39, 0x37, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x39, 0x64, 0x66, 0x38, 0x30, 0x66, 0x62, 0x65, 0x32, 0x33, 0x32, 0x30, 0x30, 0x39, 0x64, 0x61, 0x63, 0x66, 0x30, 0x61, 0x61, 0x38, 0x63, 0x61, 0x63, 0x35, 0x39, 0x33, 0x37, 0x36, 0x65, 0x32, 0x34, 0x37, 0x36, 0x32, 0x30, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x39, 0x62, 0x36, 0x64, 0x62, 0x64, 0x65, 0x36, 0x33, 0x32, 0x63, 0x31, 0x39, 0x66, 0x35, 0x61, 0x66, 0x34, 0x37, 0x63, 0x62, 0x34, 0x39, 0x33, 0x31, 0x31, 0x34, 0x62, 0x65, 0x62, 0x64, 0x39, 0x62, 0x30, 0x33, 0x63, 0x31, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x61, 0x31, 0x34, 0x33, 0x31, 0x65, 0x65, 0x34, 0x35, 0x33, 0x64, 0x31, 0x65, 0x34, 0x39, 0x61, 0x30, 0x35, 0x35, 0x30, 0x64, 0x31, 0x32, 0x35, 0x36, 0x38, 0x37, 0x39, 0x62, 0x34, 0x66, 0x35, 0x64, 0x31, 0x30, 0x32, 0x30, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x64, 0x33, 0x37, 0x36, 0x31, 0x36, 0x62, 0x37, 0x39, 0x33, 0x66, 0x39, 0x34, 0x39, 0x31, 0x31, 0x38, 0x33, 0x38, 0x61, 0x63, 0x38, 0x65, 0x31, 0x39, 0x65, 0x65, 0x39, 0x34, 0x34, 0x39, 0x64, 0x66, 0x39, 0x32, 0x31, 0x65, 0x63, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x36, 0x37, 0x30, 0x63, 0x30, 0x33, 0x36, 0x64, 0x66, 0x37, 0x35, 0x34, 0x62, 0x65, 0x34, 0x33, 0x64, 0x61, 0x64, 0x64, 0x38, 0x66, 0x35, 0x30, 0x66, 0x65, 0x65, 0x61, 0x32, 0x38, 0x39, 0x64, 0x30, 0x36, 0x31, 0x66, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x39, 0x38, 0x38, 0x34, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x37, 0x37, 0x38, 0x65, 0x33, 0x39, 0x30, 0x66, 0x61, 0x31, 0x37, 0x35, 0x31, 0x30, 0x61, 0x33, 0x34, 0x32, 0x38, 0x61, 0x66, 0x32, 0x38, 0x37, 0x30, 0x63, 0x34, 0x32, 0x37, 0x33, 0x35, 0x34, 0x37, 0x64, 0x33, 0x38, 0x36, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x31, 0x36, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x38, 0x39, 0x66, 0x34, 0x36, 0x33, 0x32, 0x64, 0x66, 0x35, 0x39, 0x30, 0x39, 0x65, 0x35, 0x38, 0x62, 0x32, 0x61, 0x39, 0x39, 0x36, 0x34, 0x66, 0x37, 0x34, 0x66, 0x65, 0x62, 0x39, 0x61, 0x33, 0x62, 0x30, 0x31, 0x65, 0x30, 0x63, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x34, 0x30, 0x36, 0x37, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x36, 0x63, 0x32, 0x37, 0x35, 0x33, 0x35, 0x62, 0x63, 0x62, 0x35, 0x39, 0x63, 0x65, 0x31, 0x66, 0x61, 0x32, 0x64, 0x38, 0x63, 0x39, 0x31, 0x39, 0x63, 0x61, 0x62, 0x65, 0x62, 0x34, 0x61, 0x36, 0x62, 0x62, 0x61, 0x30, 0x31, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x62, 0x66, 0x34, 0x33, 0x66, 0x66, 0x33, 0x35, 0x64, 0x66, 0x39, 0x30, 0x39, 0x30, 0x38, 0x38, 0x32, 0x34, 0x33, 0x33, 0x36, 0x63, 0x39, 0x62, 0x33, 0x31, 0x63, 0x65, 0x33, 0x33, 0x30, 0x36, 0x37, 0x65, 0x32, 0x66, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x34, 0x36, 0x38, 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x33, 0x62, 0x63, 0x62, 0x31, 0x37, 0x34, 0x63, 0x32, 0x35, 0x31, 0x38, 0x33, 0x34, 0x38, 0x62, 0x38, 0x31, 0x38, 0x61, 0x65, 0x63, 0x65, 0x30, 0x32, 0x30, 0x33, 0x36, 0x34, 0x35, 0x39, 0x36, 0x34, 0x36, 0x36, 0x62, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x64, 0x64, 0x34, 0x36, 0x30, 0x63, 0x64, 0x30, 0x31, 0x36, 0x37, 0x32, 0x35, 0x61, 0x36, 0x34, 0x62, 0x32, 0x32, 0x65, 0x61, 0x34, 0x66, 0x38, 0x65, 0x30, 0x36, 0x65, 0x30, 0x36, 0x36, 0x37, 0x34, 0x65, 0x30, 0x33, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x61, 0x31, 0x37, 0x34, 0x31, 0x31, 0x30, 0x39, 0x63, 0x30, 0x32, 0x36, 0x35, 0x62, 0x33, 0x66, 0x62, 0x32, 0x62, 0x66, 0x38, 0x64, 0x35, 0x65, 0x63, 0x39, 0x63, 0x32, 0x62, 0x38, 0x61, 0x33, 0x33, 0x34, 0x36, 0x62, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x62, 0x38, 0x62, 0x38, 0x65, 0x32, 0x61, 0x66, 0x37, 0x31, 0x36, 0x61, 0x65, 0x34, 0x31, 0x66, 0x63, 0x37, 0x63, 0x30, 0x34, 0x62, 0x63, 0x66, 0x32, 0x39, 0x35, 0x34, 0x30, 0x31, 0x35, 0x36, 0x34, 0x36, 0x31, 0x65, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x35, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x39, 0x66, 0x35, 0x32, 0x33, 0x61, 0x61, 0x35, 0x31, 0x33, 0x36, 0x34, 0x63, 0x62, 0x63, 0x37, 0x64, 0x39, 0x39, 0x35, 0x31, 0x36, 0x33, 0x64, 0x33, 0x34, 0x65, 0x62, 0x35, 0x39, 0x30, 0x64, 0x65, 0x64, 0x32, 0x66, 0x30, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x35, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x65, 0x37, 0x34, 0x66, 0x30, 0x62, 0x64, 0x62, 0x32, 0x37, 0x38, 0x66, 0x66, 0x30, 0x61, 0x38, 0x30, 0x35, 0x61, 0x36, 0x34, 0x38, 0x36, 0x31, 0x38, 0x65, 0x63, 0x35, 0x32, 0x62, 0x31, 0x36, 0x36, 0x66, 0x66, 0x31, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x65, 0x61, 0x64, 0x32, 0x39, 0x30, 0x33, 0x37, 0x61, 0x31, 0x32, 0x38, 0x39, 0x36, 0x34, 0x37, 0x38, 0x62, 0x31, 0x32, 0x39, 0x36, 0x61, 0x62, 0x37, 0x31, 0x34, 0x65, 0x39, 0x63, 0x62, 0x39, 0x35, 0x34, 0x32, 0x38, 0x63, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x65, 0x63, 0x66, 0x35, 0x36, 0x37, 0x35, 0x34, 0x33, 0x33, 0x63, 0x64, 0x62, 0x30, 0x63, 0x32, 0x65, 0x35, 0x35, 0x61, 0x36, 0x38, 0x64, 0x62, 0x35, 0x64, 0x38, 0x62, 0x62, 0x65, 0x37, 0x38, 0x34, 0x31, 0x39, 0x64, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x32, 0x34, 0x63, 0x63, 0x65, 0x62, 0x63, 0x32, 0x33, 0x34, 0x34, 0x63, 0x63, 0x65, 0x35, 0x36, 0x34, 0x31, 0x37, 0x66, 0x62, 0x36, 0x38, 0x34, 0x63, 0x66, 0x38, 0x31, 0x36, 0x31, 0x33, 0x66, 0x30, 0x66, 0x34, 0x62, 0x39, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x37, 0x30, 0x31, 0x30, 0x36, 0x66, 0x32, 0x30, 0x64, 0x36, 0x33, 0x66, 0x38, 0x37, 0x35, 0x32, 0x36, 0x35, 0x65, 0x34, 0x38, 0x65, 0x30, 0x64, 0x33, 0x35, 0x66, 0x30, 0x30, 0x65, 0x31, 0x37, 0x64, 0x30, 0x32, 0x62, 0x63, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x30, 0x36, 0x63, 0x33, 0x62, 0x33, 0x62, 0x34, 0x63, 0x61, 0x31, 0x62, 0x30, 0x39, 0x31, 0x34, 0x39, 0x38, 0x36, 0x30, 0x32, 0x63, 0x62, 0x31, 0x39, 0x37, 0x38, 0x62, 0x66, 0x33, 0x62, 0x39, 0x35, 0x32, 0x32, 0x31, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x64, 0x34, 0x35, 0x36, 0x33, 0x65, 0x61, 0x35, 0x37, 0x38, 0x36, 0x62, 0x65, 0x31, 0x31, 0x35, 0x39, 0x39, 0x33, 0x35, 0x61, 0x62, 0x62, 0x30, 0x66, 0x31, 0x64, 0x35, 0x38, 0x37, 0x39, 0x63, 0x33, 0x65, 0x37, 0x33, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x38, 0x32, 0x62, 0x66, 0x64, 0x31, 0x65, 0x32, 0x64, 0x65, 0x37, 0x30, 0x66, 0x34, 0x36, 0x37, 0x36, 0x34, 0x36, 0x66, 0x39, 0x62, 0x63, 0x30, 0x39, 0x65, 0x61, 0x35, 0x62, 0x31, 0x66, 0x63, 0x66, 0x34, 0x35, 0x30, 0x61, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x34, 0x39, 0x61, 0x32, 0x62, 0x39, 0x38, 0x37, 0x39, 0x63, 0x64, 0x38, 0x66, 0x62, 0x37, 0x33, 0x36, 0x65, 0x36, 0x37, 0x30, 0x33, 0x62, 0x30, 0x63, 0x37, 0x37, 0x34, 0x37, 0x38, 0x34, 0x39, 0x37, 0x39, 0x36, 0x66, 0x31, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x33, 0x35, 0x38, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x63, 0x31, 0x64, 0x33, 0x63, 0x31, 0x34, 0x66, 0x30, 0x66, 0x62, 0x38, 0x36, 0x34, 0x30, 0x65, 0x33, 0x36, 0x37, 0x32, 0x34, 0x64, 0x63, 0x34, 0x33, 0x32, 0x32, 0x39, 0x64, 0x32, 0x65, 0x61, 0x37, 0x61, 0x31, 0x65, 0x34, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x34, 0x62, 0x33, 0x63, 0x33, 0x63, 0x34, 0x34, 0x33, 0x65, 0x31, 0x39, 0x32, 0x39, 0x35, 0x64, 0x37, 0x65, 0x66, 0x36, 0x66, 0x61, 0x61, 0x37, 0x66, 0x33, 0x37, 0x34, 0x61, 0x34, 0x37, 0x39, 0x38, 0x34, 0x38, 0x36, 0x61, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x37, 0x35, 0x38, 0x63, 0x65, 0x63, 0x62, 0x36, 0x30, 0x65, 0x38, 0x66, 0x36, 0x31, 0x34, 0x63, 0x63, 0x65, 0x39, 0x36, 0x31, 0x33, 0x37, 0x65, 0x66, 0x37, 0x32, 0x62, 0x34, 0x66, 0x62, 0x64, 0x30, 0x37, 0x37, 0x37, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x38, 0x31, 0x66, 0x37, 0x31, 0x32, 0x37, 0x37, 0x35, 0x63, 0x30, 0x64, 0x61, 0x64, 0x39, 0x37, 0x35, 0x31, 0x38, 0x66, 0x66, 0x65, 0x64, 0x63, 0x62, 0x34, 0x37, 0x62, 0x39, 0x61, 0x64, 0x31, 0x64, 0x36, 0x63, 0x32, 0x37, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x36, 0x65, 0x38, 0x30, 0x31, 0x62, 0x36, 0x32, 0x63, 0x38, 0x32, 0x37, 0x31, 0x39, 0x31, 0x64, 0x64, 0x36, 0x38, 0x64, 0x33, 0x31, 0x61, 0x30, 0x31, 0x31, 0x39, 0x39, 0x30, 0x39, 0x34, 0x37, 0x66, 0x64, 0x30, 0x65, 0x62, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x34, 0x34, 0x37, 0x30, 0x34, 0x36, 0x33, 0x31, 0x33, 0x62, 0x32, 0x66, 0x33, 0x61, 0x35, 0x65, 0x31, 0x39, 0x62, 0x39, 0x34, 0x38, 0x66, 0x64, 0x33, 0x62, 0x38, 0x62, 0x65, 0x64, 0x63, 0x38, 0x32, 0x63, 0x37, 0x31, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x37, 0x30, 0x31, 0x31, 0x30, 0x31, 0x61, 0x34, 0x31, 0x30, 0x39, 0x66, 0x39, 0x63, 0x62, 0x33, 0x36, 0x30, 0x64, 0x63, 0x35, 0x37, 0x62, 0x37, 0x37, 0x34, 0x34, 0x32, 0x36, 0x37, 0x33, 0x64, 0x35, 0x65, 0x35, 0x39, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x62, 0x32, 0x35, 0x63, 0x61, 0x65, 0x38, 0x36, 0x64, 0x63, 0x61, 0x66, 0x61, 0x32, 0x61, 0x36, 0x30, 0x65, 0x37, 0x37, 0x32, 0x33, 0x36, 0x33, 0x31, 0x66, 0x63, 0x35, 0x66, 0x61, 0x34, 0x39, 0x63, 0x31, 0x61, 0x64, 0x38, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x39, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x33, 0x61, 0x63, 0x34, 0x36, 0x63, 0x32, 0x30, 0x33, 0x62, 0x65, 0x31, 0x35, 0x33, 0x38, 0x31, 0x31, 0x31, 0x62, 0x31, 0x35, 0x31, 0x65, 0x63, 0x38, 0x32, 0x32, 0x30, 0x63, 0x37, 0x38, 0x36, 0x64, 0x38, 0x34, 0x31, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x34, 0x35, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x63, 0x33, 0x64, 0x33, 0x62, 0x30, 0x65, 0x31, 0x37, 0x66, 0x39, 0x37, 0x64, 0x31, 0x65, 0x37, 0x35, 0x36, 0x65, 0x36, 0x38, 0x34, 0x66, 0x39, 0x34, 0x65, 0x31, 0x34, 0x37, 0x30, 0x66, 0x39, 0x39, 0x63, 0x39, 0x35, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x39, 0x30, 0x30, 0x61, 0x38, 0x32, 0x33, 0x36, 0x62, 0x30, 0x38, 0x63, 0x32, 0x62, 0x36, 0x35, 0x34, 0x30, 0x35, 0x64, 0x33, 0x39, 0x64, 0x37, 0x35, 0x66, 0x32, 0x30, 0x30, 0x36, 0x32, 0x61, 0x37, 0x35, 0x36, 0x31, 0x66, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x33, 0x38, 0x39, 0x38, 0x63, 0x34, 0x39, 0x61, 0x33, 0x34, 0x64, 0x35, 0x30, 0x39, 0x62, 0x66, 0x65, 0x64, 0x34, 0x66, 0x37, 0x36, 0x30, 0x34, 0x31, 0x65, 0x65, 0x39, 0x31, 0x63, 0x61, 0x66, 0x33, 0x61, 0x61, 0x36, 0x61, 0x61, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x35, 0x33, 0x32, 0x35, 0x65, 0x61, 0x62, 0x32, 0x61, 0x35, 0x39, 0x62, 0x33, 0x65, 0x64, 0x38, 0x36, 0x33, 0x63, 0x38, 0x36, 0x61, 0x35, 0x66, 0x32, 0x39, 0x30, 0x36, 0x61, 0x30, 0x34, 0x32, 0x32, 0x39, 0x66, 0x66, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x36, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x61, 0x34, 0x33, 0x30, 0x31, 0x37, 0x30, 0x31, 0x35, 0x32, 0x64, 0x65, 0x35, 0x31, 0x37, 0x32, 0x36, 0x33, 0x33, 0x64, 0x64, 0x38, 0x32, 0x36, 0x32, 0x64, 0x31, 0x30, 0x37, 0x61, 0x30, 0x61, 0x66, 0x64, 0x39, 0x36, 0x61, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x30, 0x65, 0x65, 0x37, 0x30, 0x36, 0x31, 0x32, 0x63, 0x39, 0x37, 0x36, 0x32, 0x38, 0x37, 0x64, 0x34, 0x39, 0x39, 0x64, 0x64, 0x66, 0x61, 0x36, 0x63, 0x30, 0x64, 0x63, 0x63, 0x31, 0x32, 0x63, 0x30, 0x36, 0x64, 0x65, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x63, 0x30, 0x37, 0x33, 0x38, 0x30, 0x34, 0x38, 0x34, 0x66, 0x36, 0x63, 0x62, 0x63, 0x38, 0x37, 0x32, 0x34, 0x61, 0x64, 0x33, 0x32, 0x62, 0x63, 0x38, 0x36, 0x34, 0x63, 0x33, 0x62, 0x35, 0x61, 0x64, 0x35, 0x30, 0x30, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x35, 0x31, 0x36, 0x32, 0x66, 0x32, 0x33, 0x35, 0x34, 0x64, 0x63, 0x34, 0x39, 0x32, 0x63, 0x37, 0x35, 0x66, 0x64, 0x36, 0x65, 0x33, 0x61, 0x31, 0x30, 0x37, 0x32, 0x36, 0x38, 0x36, 0x36, 0x30, 0x65, 0x65, 0x63, 0x62, 0x34, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x38, 0x34, 0x35, 0x65, 0x39, 0x66, 0x39, 0x30, 0x65, 0x39, 0x36, 0x33, 0x33, 0x36, 0x62, 0x61, 0x63, 0x33, 0x63, 0x36, 0x31, 0x36, 0x62, 0x65, 0x39, 0x64, 0x38, 0x38, 0x34, 0x30, 0x32, 0x36, 0x38, 0x33, 0x65, 0x30, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x33, 0x63, 0x37, 0x62, 0x30, 0x63, 0x62, 0x38, 0x63, 0x64, 0x35, 0x39, 0x62, 0x38, 0x32, 0x62, 0x64, 0x38, 0x39, 0x30, 0x36, 0x34, 0x34, 0x61, 0x35, 0x37, 0x64, 0x61, 0x66, 0x34, 0x30, 0x63, 0x38, 0x35, 0x65, 0x32, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x37, 0x38, 0x34, 0x39, 0x34, 0x38, 0x62, 0x66, 0x39, 0x39, 0x38, 0x34, 0x38, 0x63, 0x38, 0x39, 0x65, 0x34, 0x34, 0x35, 0x36, 0x33, 0x38, 0x35, 0x30, 0x34, 0x64, 0x64, 0x36, 0x39, 0x38, 0x32, 0x37, 0x31, 0x62, 0x35, 0x39, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x33, 0x37, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x33, 0x39, 0x66, 0x34, 0x63, 0x30, 0x30, 0x62, 0x32, 0x36, 0x33, 0x30, 0x63, 0x61, 0x62, 0x37, 0x64, 0x62, 0x37, 0x32, 0x39, 0x35, 0x65, 0x66, 0x34, 0x33, 0x64, 0x34, 0x37, 0x64, 0x35, 0x30, 0x31, 0x65, 0x31, 0x37, 0x66, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x66, 0x62, 0x37, 0x64, 0x31, 0x39, 0x37, 0x62, 0x33, 0x62, 0x61, 0x34, 0x66, 0x65, 0x30, 0x34, 0x35, 0x65, 0x66, 0x63, 0x32, 0x33, 0x64, 0x35, 0x30, 0x61, 0x31, 0x34, 0x35, 0x38, 0x35, 0x66, 0x35, 0x35, 0x38, 0x64, 0x39, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x30, 0x34, 0x33, 0x62, 0x36, 0x37, 0x63, 0x36, 0x33, 0x65, 0x36, 0x30, 0x66, 0x38, 0x34, 0x31, 0x63, 0x63, 0x63, 0x61, 0x31, 0x35, 0x62, 0x31, 0x32, 0x39, 0x63, 0x64, 0x66, 0x65, 0x36, 0x35, 0x39, 0x30, 0x63, 0x38, 0x65, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x63, 0x61, 0x30, 0x31, 0x34, 0x35, 0x39, 0x35, 0x37, 0x65, 0x36, 0x62, 0x30, 0x64, 0x66, 0x65, 0x33, 0x36, 0x38, 0x37, 0x35, 0x66, 0x62, 0x65, 0x37, 0x61, 0x30, 0x64, 0x65, 0x63, 0x35, 0x35, 0x65, 0x31, 0x37, 0x61, 0x32, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x65, 0x37, 0x32, 0x30, 0x31, 0x65, 0x61, 0x62, 0x38, 0x63, 0x30, 0x36, 0x33, 0x33, 0x30, 0x32, 0x39, 0x33, 0x30, 0x64, 0x36, 0x39, 0x33, 0x39, 0x32, 0x39, 0x64, 0x30, 0x37, 0x66, 0x39, 0x35, 0x65, 0x37, 0x31, 0x39, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x37, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x30, 0x33, 0x34, 0x39, 0x38, 0x35, 0x64, 0x33, 0x66, 0x32, 0x38, 0x63, 0x32, 0x64, 0x33, 0x39, 0x62, 0x31, 0x61, 0x33, 0x34, 0x62, 0x63, 0x65, 0x64, 0x34, 0x64, 0x33, 0x62, 0x32, 0x62, 0x36, 0x63, 0x61, 0x32, 0x33, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x30, 0x65, 0x30, 0x64, 0x62, 0x66, 0x33, 0x65, 0x66, 0x65, 0x66, 0x39, 0x30, 0x38, 0x34, 0x65, 0x61, 0x31, 0x63, 0x64, 0x37, 0x65, 0x35, 0x30, 0x33, 0x66, 0x34, 0x30, 0x62, 0x33, 0x62, 0x34, 0x61, 0x38, 0x34, 0x34, 0x33, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x38, 0x39, 0x36, 0x61, 0x33, 0x37, 0x65, 0x35, 0x64, 0x38, 0x38, 0x32, 0x35, 0x61, 0x32, 0x64, 0x30, 0x31, 0x37, 0x36, 0x35, 0x61, 0x65, 0x35, 0x64, 0x65, 0x36, 0x32, 0x39, 0x39, 0x37, 0x37, 0x64, 0x65, 0x38, 0x33, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x39, 0x66, 0x35, 0x34, 0x37, 0x66, 0x32, 0x63, 0x31, 0x64, 0x65, 0x30, 0x65, 0x64, 0x39, 0x38, 0x61, 0x35, 0x33, 0x64, 0x31, 0x36, 0x31, 0x64, 0x66, 0x35, 0x37, 0x36, 0x33, 0x35, 0x64, 0x64, 0x32, 0x31, 0x61, 0x30, 0x30, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x66, 0x65, 0x61, 0x31, 0x62, 0x32, 0x66, 0x38, 0x33, 0x34, 0x66, 0x30, 0x32, 0x66, 0x63, 0x35, 0x34, 0x33, 0x33, 0x33, 0x66, 0x38, 0x61, 0x38, 0x30, 0x39, 0x66, 0x30, 0x34, 0x33, 0x38, 0x65, 0x35, 0x38, 0x37, 0x30, 0x61, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x62, 0x33, 0x31, 0x38, 0x33, 0x36, 0x61, 0x33, 0x30, 0x61, 0x30, 0x31, 0x36, 0x61, 0x64, 0x61, 0x31, 0x35, 0x37, 0x62, 0x36, 0x33, 0x38, 0x61, 0x63, 0x31, 0x35, 0x64, 0x61, 0x37, 0x33, 0x66, 0x31, 0x38, 0x63, 0x66, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x63, 0x39, 0x36, 0x37, 0x66, 0x65, 0x34, 0x34, 0x31, 0x38, 0x63, 0x31, 0x38, 0x62, 0x39, 0x39, 0x38, 0x35, 0x38, 0x39, 0x36, 0x36, 0x64, 0x38, 0x37, 0x30, 0x36, 0x37, 0x38, 0x64, 0x63, 0x61, 0x32, 0x62, 0x38, 0x38, 0x38, 0x37, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x36, 0x62, 0x61, 0x65, 0x35, 0x64, 0x32, 0x34, 0x65, 0x66, 0x66, 0x39, 0x31, 0x37, 0x37, 0x38, 0x63, 0x64, 0x39, 0x38, 0x62, 0x34, 0x64, 0x33, 0x61, 0x31, 0x63, 0x63, 0x33, 0x31, 0x36, 0x32, 0x66, 0x34, 0x34, 0x61, 0x61, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x37, 0x36, 0x65, 0x31, 0x32, 0x36, 0x37, 0x66, 0x38, 0x36, 0x32, 0x34, 0x37, 0x63, 0x63, 0x39, 0x30, 0x38, 0x38, 0x31, 0x36, 0x66, 0x32, 0x65, 0x37, 0x61, 0x64, 0x35, 0x33, 0x38, 0x38, 0x63, 0x39, 0x35, 0x32, 0x64, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x32, 0x30, 0x33, 0x61, 0x65, 0x30, 0x31, 0x64, 0x34, 0x63, 0x34, 0x31, 0x63, 0x61, 0x65, 0x31, 0x38, 0x36, 0x35, 0x65, 0x30, 0x34, 0x62, 0x31, 0x66, 0x35, 0x62, 0x35, 0x33, 0x63, 0x64, 0x66, 0x61, 0x65, 0x63, 0x61, 0x65, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x36, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x34, 0x62, 0x64, 0x35, 0x62, 0x31, 0x32, 0x32, 0x64, 0x38, 0x65, 0x66, 0x37, 0x62, 0x37, 0x63, 0x38, 0x66, 0x30, 0x36, 0x36, 0x37, 0x34, 0x35, 0x30, 0x33, 0x32, 0x30, 0x64, 0x62, 0x32, 0x31, 0x31, 0x36, 0x31, 0x34, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x39, 0x34, 0x61, 0x64, 0x34, 0x66, 0x64, 0x39, 0x65, 0x36, 0x35, 0x33, 0x30, 0x65, 0x36, 0x66, 0x35, 0x63, 0x35, 0x33, 0x66, 0x61, 0x65, 0x63, 0x62, 0x65, 0x64, 0x65, 0x38, 0x31, 0x63, 0x62, 0x31, 0x37, 0x32, 0x64, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x39, 0x39, 0x36, 0x30, 0x32, 0x36, 0x36, 0x64, 0x66, 0x36, 0x34, 0x39, 0x32, 0x30, 0x36, 0x33, 0x35, 0x33, 0x38, 0x61, 0x39, 0x39, 0x66, 0x34, 0x38, 0x37, 0x63, 0x39, 0x35, 0x30, 0x61, 0x33, 0x61, 0x35, 0x65, 0x63, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x38, 0x30, 0x36, 0x39, 0x66, 0x38, 0x34, 0x62, 0x35, 0x32, 0x31, 0x34, 0x39, 0x33, 0x66, 0x34, 0x37, 0x31, 0x35, 0x30, 0x33, 0x37, 0x66, 0x33, 0x32, 0x32, 0x36, 0x62, 0x32, 0x35, 0x66, 0x33, 0x33, 0x62, 0x36, 0x30, 0x35, 0x38, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x36, 0x63, 0x38, 0x33, 0x34, 0x62, 0x66, 0x31, 0x31, 0x31, 0x33, 0x32, 0x36, 0x64, 0x32, 0x30, 0x37, 0x33, 0x39, 0x35, 0x32, 0x39, 0x35, 0x62, 0x32, 0x65, 0x35, 0x38, 0x33, 0x65, 0x61, 0x37, 0x66, 0x33, 0x33, 0x35, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x63, 0x37, 0x33, 0x64, 0x36, 0x31, 0x63, 0x63, 0x65, 0x37, 0x63, 0x38, 0x66, 0x65, 0x34, 0x63, 0x38, 0x66, 0x63, 0x65, 0x32, 0x39, 0x66, 0x33, 0x39, 0x30, 0x39, 0x32, 0x63, 0x64, 0x31, 0x39, 0x33, 0x65, 0x30, 0x66, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x66, 0x62, 0x66, 0x30, 0x36, 0x36, 0x35, 0x36, 0x35, 0x39, 0x37, 0x30, 0x36, 0x33, 0x39, 0x65, 0x31, 0x33, 0x30, 0x64, 0x66, 0x32, 0x61, 0x37, 0x64, 0x31, 0x36, 0x62, 0x30, 0x65, 0x31, 0x34, 0x64, 0x36, 0x30, 0x39, 0x31, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x31, 0x62, 0x39, 0x30, 0x35, 0x64, 0x65, 0x36, 0x36, 0x33, 0x66, 0x63, 0x31, 0x37, 0x33, 0x38, 0x36, 0x35, 0x32, 0x33, 0x62, 0x33, 0x61, 0x32, 0x38, 0x65, 0x32, 0x66, 0x37, 0x64, 0x30, 0x33, 0x37, 0x61, 0x36, 0x35, 0x35, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x64, 0x61, 0x30, 0x63, 0x65, 0x31, 0x35, 0x33, 0x33, 0x30, 0x37, 0x30, 0x37, 0x66, 0x31, 0x30, 0x62, 0x63, 0x65, 0x33, 0x32, 0x30, 0x31, 0x31, 0x37, 0x32, 0x64, 0x32, 0x30, 0x31, 0x38, 0x62, 0x39, 0x64, 0x64, 0x65, 0x61, 0x37, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x37, 0x66, 0x63, 0x34, 0x35, 0x61, 0x62, 0x66, 0x37, 0x36, 0x66, 0x35, 0x30, 0x38, 0x38, 0x65, 0x32, 0x65, 0x35, 0x62, 0x35, 0x61, 0x38, 0x64, 0x31, 0x33, 0x32, 0x66, 0x32, 0x38, 0x61, 0x34, 0x64, 0x34, 0x65, 0x63, 0x31, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x64, 0x62, 0x39, 0x66, 0x62, 0x36, 0x66, 0x34, 0x36, 0x63, 0x34, 0x38, 0x30, 0x61, 0x66, 0x33, 0x34, 0x34, 0x36, 0x35, 0x64, 0x37, 0x39, 0x37, 0x35, 0x33, 0x62, 0x34, 0x65, 0x32, 0x62, 0x37, 0x34, 0x61, 0x36, 0x37, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x65, 0x34, 0x36, 0x63, 0x63, 0x33, 0x63, 0x33, 0x34, 0x63, 0x33, 0x32, 0x66, 0x35, 0x61, 0x64, 0x64, 0x36, 0x63, 0x33, 0x31, 0x39, 0x35, 0x62, 0x62, 0x34, 0x38, 0x36, 0x63, 0x34, 0x37, 0x31, 0x33, 0x65, 0x62, 0x39, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x64, 0x32, 0x61, 0x39, 0x65, 0x65, 0x31, 0x61, 0x36, 0x64, 0x62, 0x32, 0x30, 0x66, 0x35, 0x33, 0x31, 0x37, 0x63, 0x63, 0x61, 0x37, 0x66, 0x62, 0x65, 0x32, 0x33, 0x31, 0x33, 0x38, 0x39, 0x35, 0x64, 0x62, 0x38, 0x65, 0x66, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x39, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x63, 0x63, 0x34, 0x35, 0x61, 0x32, 0x62, 0x36, 0x33, 0x63, 0x32, 0x37, 0x63, 0x30, 0x62, 0x34, 0x34, 0x32, 0x39, 0x65, 0x35, 0x38, 0x63, 0x64, 0x34, 0x32, 0x64, 0x61, 0x35, 0x39, 0x62, 0x65, 0x37, 0x33, 0x39, 0x62, 0x64, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x34, 0x33, 0x62, 0x38, 0x31, 0x66, 0x39, 0x39, 0x33, 0x35, 0x36, 0x63, 0x30, 0x61, 0x66, 0x31, 0x34, 0x31, 0x61, 0x30, 0x33, 0x30, 0x31, 0x30, 0x64, 0x37, 0x37, 0x62, 0x64, 0x30, 0x34, 0x32, 0x63, 0x37, 0x31, 0x63, 0x31, 0x65, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x63, 0x34, 0x35, 0x64, 0x34, 0x63, 0x39, 0x61, 0x37, 0x32, 0x35, 0x64, 0x31, 0x31, 0x31, 0x31, 0x32, 0x62, 0x66, 0x63, 0x62, 0x63, 0x61, 0x30, 0x30, 0x62, 0x66, 0x33, 0x31, 0x31, 0x38, 0x36, 0x63, 0x63, 0x61, 0x61, 0x64, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x39, 0x66, 0x32, 0x37, 0x31, 0x66, 0x37, 0x61, 0x37, 0x65, 0x31, 0x32, 0x65, 0x33, 0x36, 0x64, 0x64, 0x32, 0x66, 0x65, 0x39, 0x66, 0x61, 0x63, 0x65, 0x62, 0x66, 0x33, 0x38, 0x35, 0x66, 0x65, 0x36, 0x31, 0x34, 0x32, 0x62, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x32, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x63, 0x65, 0x38, 0x30, 0x61, 0x34, 0x36, 0x31, 0x62, 0x36, 0x34, 0x38, 0x61, 0x35, 0x30, 0x31, 0x66, 0x64, 0x30, 0x62, 0x38, 0x32, 0x34, 0x36, 0x39, 0x30, 0x63, 0x38, 0x38, 0x36, 0x38, 0x62, 0x30, 0x65, 0x34, 0x64, 0x65, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x66, 0x37, 0x64, 0x64, 0x65, 0x31, 0x64, 0x37, 0x33, 0x38, 0x64, 0x38, 0x63, 0x64, 0x36, 0x37, 0x39, 0x65, 0x61, 0x31, 0x65, 0x65, 0x39, 0x36, 0x35, 0x62, 0x65, 0x65, 0x32, 0x32, 0x34, 0x62, 0x65, 0x37, 0x64, 0x30, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x31, 0x63, 0x38, 0x31, 0x65, 0x65, 0x31, 0x36, 0x39, 0x37, 0x66, 0x63, 0x31, 0x34, 0x34, 0x62, 0x37, 0x63, 0x30, 0x62, 0x65, 0x35, 0x34, 0x39, 0x33, 0x62, 0x35, 0x36, 0x31, 0x35, 0x61, 0x65, 0x37, 0x66, 0x64, 0x64, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x30, 0x38, 0x66, 0x39, 0x38, 0x37, 0x62, 0x32, 0x64, 0x65, 0x33, 0x34, 0x61, 0x65, 0x34, 0x63, 0x66, 0x31, 0x39, 0x33, 0x64, 0x65, 0x38, 0x35, 0x62, 0x66, 0x66, 0x36, 0x31, 0x33, 0x38, 0x39, 0x36, 0x32, 0x31, 0x66, 0x38, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x32, 0x36, 0x63, 0x66, 0x33, 0x34, 0x35, 0x39, 0x39, 0x62, 0x63, 0x33, 0x36, 0x65, 0x61, 0x36, 0x37, 0x62, 0x39, 0x65, 0x37, 0x61, 0x39, 0x66, 0x39, 0x62, 0x34, 0x33, 0x33, 0x30, 0x63, 0x39, 0x64, 0x35, 0x34, 0x32, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x32, 0x31, 0x30, 0x38, 0x64, 0x32, 0x61, 0x65, 0x33, 0x63, 0x61, 0x62, 0x31, 0x30, 0x63, 0x62, 0x63, 0x66, 0x31, 0x36, 0x35, 0x37, 0x61, 0x66, 0x32, 0x32, 0x33, 0x65, 0x30, 0x32, 0x37, 0x63, 0x38, 0x32, 0x31, 0x30, 0x66, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x35, 0x32, 0x31, 0x38, 0x33, 0x63, 0x66, 0x64, 0x33, 0x38, 0x65, 0x33, 0x35, 0x32, 0x65, 0x35, 0x37, 0x39, 0x64, 0x33, 0x36, 0x64, 0x65, 0x63, 0x65, 0x63, 0x35, 0x62, 0x31, 0x38, 0x34, 0x35, 0x30, 0x66, 0x37, 0x66, 0x62, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x62, 0x39, 0x30, 0x63, 0x37, 0x39, 0x33, 0x62, 0x33, 0x35, 0x33, 0x39, 0x37, 0x36, 0x31, 0x65, 0x31, 0x63, 0x38, 0x31, 0x34, 0x61, 0x32, 0x39, 0x36, 0x37, 0x31, 0x31, 0x34, 0x38, 0x36, 0x39, 0x32, 0x31, 0x39, 0x33, 0x65, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x30, 0x37, 0x36, 0x32, 0x31, 0x32, 0x64, 0x34, 0x66, 0x37, 0x35, 0x38, 0x63, 0x38, 0x65, 0x63, 0x37, 0x31, 0x32, 0x31, 0x63, 0x31, 0x63, 0x37, 0x64, 0x37, 0x34, 0x32, 0x35, 0x34, 0x39, 0x32, 0x36, 0x34, 0x35, 0x39, 0x32, 0x38, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x35, 0x63, 0x65, 0x65, 0x61, 0x62, 0x36, 0x35, 0x34, 0x31, 0x30, 0x35, 0x36, 0x34, 0x37, 0x30, 0x39, 0x39, 0x35, 0x31, 0x37, 0x37, 0x33, 0x63, 0x38, 0x34, 0x34, 0x35, 0x61, 0x64, 0x39, 0x66, 0x34, 0x65, 0x63, 0x37, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x39, 0x39, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x35, 0x33, 0x36, 0x31, 0x64, 0x38, 0x65, 0x62, 0x36, 0x39, 0x34, 0x31, 0x64, 0x34, 0x65, 0x39, 0x30, 0x66, 0x62, 0x37, 0x65, 0x31, 0x34, 0x31, 0x38, 0x61, 0x39, 0x35, 0x61, 0x33, 0x32, 0x64, 0x35, 0x32, 0x35, 0x37, 0x37, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x35, 0x37, 0x38, 0x33, 0x62, 0x66, 0x33, 0x33, 0x34, 0x33, 0x32, 0x66, 0x66, 0x38, 0x32, 0x61, 0x63, 0x34, 0x39, 0x38, 0x39, 0x38, 0x35, 0x64, 0x37, 0x64, 0x34, 0x36, 0x30, 0x61, 0x65, 0x36, 0x37, 0x65, 0x63, 0x33, 0x36, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x63, 0x64, 0x34, 0x62, 0x64, 0x66, 0x64, 0x31, 0x30, 0x34, 0x34, 0x38, 0x39, 0x61, 0x30, 0x32, 0x36, 0x65, 0x63, 0x39, 0x39, 0x64, 0x35, 0x39, 0x37, 0x33, 0x30, 0x37, 0x61, 0x30, 0x34, 0x32, 0x37, 0x39, 0x66, 0x31, 0x37, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x37, 0x36, 0x63, 0x33, 0x66, 0x32, 0x31, 0x38, 0x62, 0x34, 0x37, 0x37, 0x36, 0x64, 0x66, 0x33, 0x63, 0x61, 0x39, 0x64, 0x62, 0x66, 0x62, 0x32, 0x37, 0x30, 0x64, 0x65, 0x31, 0x35, 0x32, 0x64, 0x39, 0x34, 0x65, 0x64, 0x32, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x61, 0x33, 0x36, 0x38, 0x36, 0x39, 0x61, 0x64, 0x34, 0x37, 0x38, 0x39, 0x39, 0x37, 0x63, 0x62, 0x66, 0x36, 0x64, 0x38, 0x39, 0x32, 0x34, 0x64, 0x32, 0x30, 0x61, 0x33, 0x63, 0x38, 0x30, 0x31, 0x38, 0x65, 0x39, 0x38, 0x35, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x62, 0x33, 0x66, 0x65, 0x30, 0x39, 0x62, 0x62, 0x38, 0x33, 0x36, 0x38, 0x36, 0x31, 0x35, 0x32, 0x39, 0x64, 0x37, 0x35, 0x31, 0x38, 0x64, 0x61, 0x32, 0x37, 0x36, 0x33, 0x35, 0x66, 0x35, 0x33, 0x38, 0x35, 0x30, 0x35, 0x36, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x39, 0x39, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x39, 0x33, 0x65, 0x38, 0x32, 0x39, 0x38, 0x31, 0x39, 0x66, 0x64, 0x32, 0x65, 0x32, 0x35, 0x62, 0x39, 0x37, 0x33, 0x38, 0x30, 0x30, 0x62, 0x62, 0x33, 0x64, 0x35, 0x38, 0x34, 0x31, 0x64, 0x64, 0x31, 0x35, 0x32, 0x64, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x32, 0x36, 0x64, 0x39, 0x31, 0x66, 0x37, 0x61, 0x64, 0x38, 0x36, 0x64, 0x65, 0x62, 0x62, 0x30, 0x35, 0x35, 0x37, 0x63, 0x36, 0x31, 0x32, 0x63, 0x61, 0x32, 0x37, 0x36, 0x65, 0x62, 0x37, 0x66, 0x39, 0x36, 0x64, 0x30, 0x30, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x61, 0x38, 0x31, 0x64, 0x32, 0x37, 0x63, 0x62, 0x36, 0x64, 0x34, 0x37, 0x37, 0x30, 0x66, 0x66, 0x34, 0x66, 0x33, 0x63, 0x34, 0x61, 0x33, 0x62, 0x61, 0x31, 0x38, 0x65, 0x35, 0x65, 0x35, 0x37, 0x66, 0x30, 0x37, 0x35, 0x31, 0x37, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x34, 0x66, 0x37, 0x62, 0x31, 0x33, 0x61, 0x63, 0x36, 0x64, 0x34, 0x65, 0x62, 0x34, 0x64, 0x62, 0x33, 0x64, 0x34, 0x65, 0x36, 0x61, 0x32, 0x35, 0x32, 0x61, 0x66, 0x38, 0x61, 0x30, 0x37, 0x62, 0x64, 0x35, 0x39, 0x35, 0x37, 0x64, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x35, 0x64, 0x32, 0x36, 0x63, 0x31, 0x30, 0x62, 0x64, 0x63, 0x31, 0x30, 0x33, 0x66, 0x36, 0x62, 0x39, 0x63, 0x32, 0x31, 0x32, 0x37, 0x32, 0x65, 0x62, 0x37, 0x63, 0x62, 0x32, 0x64, 0x39, 0x31, 0x30, 0x38, 0x63, 0x34, 0x37, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x30, 0x64, 0x30, 0x61, 0x32, 0x61, 0x64, 0x34, 0x35, 0x66, 0x35, 0x39, 0x61, 0x39, 0x64, 0x63, 0x63, 0x63, 0x36, 0x39, 0x35, 0x64, 0x38, 0x35, 0x66, 0x32, 0x35, 0x63, 0x61, 0x34, 0x36, 0x65, 0x64, 0x33, 0x31, 0x61, 0x35, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x32, 0x33, 0x32, 0x33, 0x61, 0x61, 0x64, 0x37, 0x31, 0x64, 0x62, 0x63, 0x39, 0x36, 0x64, 0x38, 0x35, 0x61, 0x66, 0x39, 0x30, 0x66, 0x30, 0x38, 0x34, 0x62, 0x39, 0x39, 0x63, 0x33, 0x66, 0x30, 0x39, 0x64, 0x65, 0x63, 0x62, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x33, 0x64, 0x61, 0x33, 0x61, 0x34, 0x65, 0x33, 0x66, 0x35, 0x66, 0x61, 0x62, 0x31, 0x30, 0x34, 0x63, 0x61, 0x39, 0x62, 0x63, 0x31, 0x61, 0x30, 0x66, 0x37, 0x66, 0x33, 0x62, 0x62, 0x34, 0x61, 0x35, 0x36, 0x66, 0x33, 0x35, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x32, 0x64, 0x63, 0x36, 0x35, 0x65, 0x65, 0x32, 0x35, 0x36, 0x62, 0x35, 0x39, 0x61, 0x35, 0x62, 0x64, 0x37, 0x39, 0x32, 0x39, 0x37, 0x37, 0x34, 0x66, 0x39, 0x30, 0x34, 0x62, 0x33, 0x35, 0x38, 0x64, 0x66, 0x33, 0x61, 0x64, 0x61, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x31, 0x33, 0x31, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x38, 0x32, 0x64, 0x66, 0x35, 0x38, 0x33, 0x31, 0x35, 0x35, 0x64, 0x38, 0x35, 0x34, 0x38, 0x66, 0x33, 0x66, 0x39, 0x33, 0x34, 0x34, 0x30, 0x63, 0x64, 0x35, 0x66, 0x36, 0x38, 0x63, 0x62, 0x37, 0x39, 0x64, 0x36, 0x30, 0x32, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x36, 0x36, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x63, 0x39, 0x36, 0x37, 0x65, 0x33, 0x30, 0x36, 0x31, 0x62, 0x38, 0x37, 0x61, 0x37, 0x35, 0x33, 0x65, 0x38, 0x34, 0x35, 0x30, 0x37, 0x65, 0x62, 0x36, 0x30, 0x39, 0x38, 0x36, 0x37, 0x38, 0x32, 0x63, 0x38, 0x66, 0x33, 0x30, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x33, 0x61, 0x32, 0x36, 0x32, 0x61, 0x66, 0x64, 0x32, 0x39, 0x33, 0x36, 0x38, 0x31, 0x39, 0x32, 0x33, 0x30, 0x38, 0x39, 0x32, 0x66, 0x64, 0x65, 0x38, 0x34, 0x66, 0x32, 0x64, 0x35, 0x61, 0x35, 0x39, 0x34, 0x61, 0x62, 0x32, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x38, 0x36, 0x38, 0x64, 0x64, 0x62, 0x32, 0x61, 0x37, 0x39, 0x34, 0x64, 0x30, 0x32, 0x65, 0x62, 0x64, 0x61, 0x32, 0x66, 0x61, 0x34, 0x38, 0x30, 0x37, 0x63, 0x37, 0x36, 0x65, 0x33, 0x36, 0x30, 0x39, 0x38, 0x35, 0x38, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x32, 0x37, 0x38, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x64, 0x33, 0x35, 0x66, 0x66, 0x30, 0x31, 0x30, 0x65, 0x63, 0x35, 0x30, 0x31, 0x61, 0x37, 0x32, 0x31, 0x61, 0x31, 0x62, 0x32, 0x66, 0x30, 0x37, 0x61, 0x39, 0x63, 0x61, 0x35, 0x38, 0x37, 0x37, 0x64, 0x66, 0x63, 0x66, 0x39, 0x35, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x38, 0x32, 0x34, 0x61, 0x37, 0x65, 0x32, 0x32, 0x38, 0x33, 0x38, 0x32, 0x37, 0x37, 0x31, 0x33, 0x34, 0x33, 0x30, 0x38, 0x63, 0x35, 0x66, 0x34, 0x62, 0x35, 0x30, 0x64, 0x61, 0x62, 0x36, 0x35, 0x65, 0x34, 0x33, 0x62, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x66, 0x37, 0x61, 0x33, 0x61, 0x32, 0x31, 0x62, 0x33, 0x66, 0x35, 0x61, 0x36, 0x35, 0x64, 0x38, 0x31, 0x65, 0x30, 0x66, 0x63, 0x62, 0x37, 0x64, 0x35, 0x32, 0x64, 0x64, 0x30, 0x30, 0x61, 0x31, 0x61, 0x61, 0x33, 0x36, 0x64, 0x62, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x35, 0x31, 0x33, 0x66, 0x63, 0x61, 0x39, 0x66, 0x33, 0x36, 0x66, 0x64, 0x37, 0x38, 0x38, 0x63, 0x66, 0x65, 0x61, 0x37, 0x61, 0x33, 0x34, 0x30, 0x65, 0x38, 0x36, 0x64, 0x66, 0x39, 0x38, 0x32, 0x39, 0x34, 0x61, 0x32, 0x34, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x38, 0x33, 0x65, 0x36, 0x32, 0x35, 0x32, 0x62, 0x34, 0x65, 0x66, 0x63, 0x66, 0x34, 0x36, 0x35, 0x34, 0x33, 0x39, 0x31, 0x61, 0x63, 0x62, 0x37, 0x35, 0x66, 0x39, 0x30, 0x33, 0x63, 0x35, 0x39, 0x62, 0x37, 0x38, 0x63, 0x35, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x64, 0x62, 0x61, 0x61, 0x66, 0x62, 0x63, 0x32, 0x31, 0x62, 0x65, 0x38, 0x66, 0x32, 0x35, 0x35, 0x36, 0x32, 0x66, 0x31, 0x65, 0x64, 0x36, 0x64, 0x30, 0x35, 0x64, 0x36, 0x61, 0x66, 0x62, 0x35, 0x38, 0x66, 0x30, 0x32, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x64, 0x63, 0x66, 0x65, 0x38, 0x33, 0x37, 0x65, 0x61, 0x31, 0x63, 0x66, 0x32, 0x38, 0x63, 0x36, 0x35, 0x66, 0x63, 0x63, 0x65, 0x63, 0x33, 0x62, 0x65, 0x66, 0x31, 0x66, 0x38, 0x34, 0x65, 0x35, 0x39, 0x64, 0x31, 0x35, 0x30, 0x63, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x32, 0x38, 0x62, 0x61, 0x36, 0x35, 0x31, 0x63, 0x62, 0x39, 0x33, 0x30, 0x65, 0x64, 0x39, 0x37, 0x38, 0x37, 0x31, 0x35, 0x36, 0x32, 0x39, 0x39, 0x61, 0x33, 0x64, 0x65, 0x34, 0x34, 0x63, 0x64, 0x30, 0x38, 0x62, 0x37, 0x32, 0x31, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x64, 0x34, 0x37, 0x34, 0x39, 0x33, 0x63, 0x39, 0x66, 0x38, 0x39, 0x66, 0x65, 0x36, 0x38, 0x30, 0x62, 0x64, 0x61, 0x35, 0x37, 0x35, 0x34, 0x64, 0x64, 0x37, 0x63, 0x39, 0x63, 0x66, 0x65, 0x37, 0x63, 0x62, 0x35, 0x62, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x34, 0x35, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x38, 0x39, 0x65, 0x64, 0x64, 0x64, 0x33, 0x66, 0x61, 0x30, 0x64, 0x37, 0x31, 0x64, 0x38, 0x61, 0x62, 0x30, 0x66, 0x66, 0x38, 0x64, 0x61, 0x35, 0x35, 0x38, 0x30, 0x36, 0x38, 0x36, 0x65, 0x33, 0x64, 0x34, 0x66, 0x37, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x30, 0x35, 0x66, 0x35, 0x31, 0x36, 0x36, 0x66, 0x31, 0x32, 0x34, 0x34, 0x30, 0x64, 0x38, 0x35, 0x37, 0x36, 0x32, 0x63, 0x39, 0x36, 0x37, 0x64, 0x33, 0x61, 0x65, 0x38, 0x36, 0x31, 0x38, 0x34, 0x66, 0x38, 0x66, 0x34, 0x64, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x35, 0x64, 0x61, 0x64, 0x34, 0x39, 0x35, 0x61, 0x31, 0x31, 0x61, 0x38, 0x36, 0x62, 0x39, 0x65, 0x65, 0x65, 0x63, 0x65, 0x31, 0x65, 0x65, 0x65, 0x63, 0x38, 0x30, 0x35, 0x65, 0x35, 0x37, 0x66, 0x31, 0x35, 0x37, 0x66, 0x61, 0x66, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x38, 0x34, 0x63, 0x62, 0x61, 0x37, 0x37, 0x63, 0x36, 0x64, 0x62, 0x34, 0x66, 0x37, 0x66, 0x39, 0x30, 0x65, 0x66, 0x31, 0x33, 0x64, 0x35, 0x65, 0x65, 0x32, 0x31, 0x65, 0x38, 0x63, 0x66, 0x63, 0x37, 0x66, 0x38, 0x33, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x61, 0x37, 0x38, 0x37, 0x62, 0x63, 0x35, 0x31, 0x39, 0x36, 0x66, 0x33, 0x34, 0x38, 0x35, 0x37, 0x66, 0x65, 0x30, 0x63, 0x33, 0x37, 0x32, 0x66, 0x34, 0x64, 0x66, 0x33, 0x37, 0x36, 0x61, 0x61, 0x61, 0x37, 0x36, 0x36, 0x31, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x30, 0x64, 0x33, 0x63, 0x39, 0x38, 0x37, 0x32, 0x62, 0x38, 0x35, 0x30, 0x35, 0x36, 0x65, 0x61, 0x30, 0x63, 0x30, 0x65, 0x36, 0x64, 0x31, 0x65, 0x63, 0x66, 0x37, 0x61, 0x37, 0x37, 0x65, 0x33, 0x63, 0x65, 0x36, 0x61, 0x62, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x39, 0x39, 0x37, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x65, 0x34, 0x64, 0x32, 0x65, 0x33, 0x39, 0x63, 0x38, 0x38, 0x33, 0x36, 0x36, 0x32, 0x39, 0x65, 0x35, 0x62, 0x34, 0x38, 0x37, 0x62, 0x31, 0x39, 0x31, 0x38, 0x61, 0x36, 0x36, 0x39, 0x61, 0x65, 0x62, 0x64, 0x64, 0x39, 0x35, 0x33, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x63, 0x37, 0x30, 0x33, 0x61, 0x35, 0x66, 0x33, 0x37, 0x39, 0x34, 0x63, 0x38, 0x34, 0x64, 0x36, 0x63, 0x62, 0x33, 0x35, 0x34, 0x34, 0x39, 0x31, 0x38, 0x63, 0x61, 0x65, 0x31, 0x34, 0x61, 0x33, 0x35, 0x63, 0x33, 0x62, 0x64, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x62, 0x65, 0x62, 0x32, 0x30, 0x66, 0x37, 0x35, 0x39, 0x31, 0x30, 0x30, 0x35, 0x34, 0x32, 0x61, 0x61, 0x39, 0x33, 0x64, 0x34, 0x31, 0x31, 0x31, 0x38, 0x62, 0x33, 0x32, 0x31, 0x31, 0x64, 0x36, 0x36, 0x34, 0x39, 0x32, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x37, 0x37, 0x33, 0x35, 0x30, 0x30, 0x37, 0x64, 0x37, 0x30, 0x62, 0x30, 0x36, 0x38, 0x34, 0x34, 0x64, 0x61, 0x39, 0x39, 0x30, 0x31, 0x63, 0x64, 0x66, 0x61, 0x64, 0x62, 0x31, 0x31, 0x61, 0x32, 0x35, 0x38, 0x32, 0x63, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x66, 0x31, 0x30, 0x37, 0x39, 0x36, 0x30, 0x62, 0x37, 0x65, 0x63, 0x33, 0x34, 0x65, 0x64, 0x36, 0x39, 0x30, 0x62, 0x36, 0x36, 0x35, 0x30, 0x32, 0x34, 0x64, 0x36, 0x30, 0x38, 0x33, 0x38, 0x63, 0x31, 0x39, 0x30, 0x66, 0x37, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x33, 0x61, 0x30, 0x33, 0x61, 0x62, 0x39, 0x63, 0x35, 0x36, 0x62, 0x36, 0x30, 0x30, 0x66, 0x36, 0x64, 0x32, 0x35, 0x62, 0x36, 0x36, 0x30, 0x63, 0x32, 0x31, 0x65, 0x31, 0x36, 0x33, 0x33, 0x35, 0x35, 0x31, 0x37, 0x61, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x30, 0x36, 0x34, 0x36, 0x35, 0x62, 0x62, 0x64, 0x31, 0x39, 0x65, 0x31, 0x62, 0x36, 0x62, 0x63, 0x65, 0x35, 0x30, 0x64, 0x31, 0x62, 0x31, 0x31, 0x35, 0x37, 0x64, 0x63, 0x35, 0x39, 0x30, 0x39, 0x35, 0x61, 0x33, 0x36, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x39, 0x64, 0x65, 0x63, 0x30, 0x32, 0x38, 0x34, 0x31, 0x61, 0x64, 0x66, 0x35, 0x63, 0x63, 0x39, 0x32, 0x30, 0x35, 0x37, 0x36, 0x61, 0x35, 0x31, 0x38, 0x37, 0x65, 0x64, 0x64, 0x32, 0x62, 0x64, 0x34, 0x33, 0x34, 0x61, 0x31, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x37, 0x32, 0x61, 0x63, 0x31, 0x61, 0x62, 0x61, 0x30, 0x64, 0x65, 0x32, 0x33, 0x61, 0x65, 0x34, 0x31, 0x61, 0x37, 0x63, 0x61, 0x65, 0x31, 0x64, 0x63, 0x30, 0x38, 0x34, 0x32, 0x64, 0x38, 0x61, 0x62, 0x66, 0x63, 0x31, 0x30, 0x33, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x37, 0x34, 0x65, 0x64, 0x30, 0x65, 0x32, 0x34, 0x66, 0x66, 0x38, 0x30, 0x64, 0x39, 0x62, 0x32, 0x63, 0x34, 0x61, 0x34, 0x34, 0x62, 0x61, 0x61, 0x39, 0x39, 0x37, 0x35, 0x34, 0x32, 0x38, 0x63, 0x64, 0x36, 0x62, 0x39, 0x33, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x30, 0x34, 0x39, 0x35, 0x33, 0x32, 0x66, 0x64, 0x34, 0x35, 0x38, 0x61, 0x38, 0x33, 0x63, 0x61, 0x31, 0x62, 0x66, 0x66, 0x32, 0x65, 0x65, 0x62, 0x61, 0x63, 0x62, 0x36, 0x64, 0x35, 0x63, 0x61, 0x36, 0x33, 0x66, 0x34, 0x61, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x32, 0x35, 0x36, 0x39, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x65, 0x36, 0x39, 0x39, 0x63, 0x30, 0x37, 0x30, 0x37, 0x61, 0x37, 0x38, 0x33, 0x36, 0x32, 0x35, 0x32, 0x62, 0x32, 0x39, 0x32, 0x66, 0x30, 0x34, 0x37, 0x63, 0x65, 0x38, 0x61, 0x64, 0x32, 0x38, 0x39, 0x62, 0x32, 0x66, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x33, 0x36, 0x39, 0x36, 0x66, 0x33, 0x63, 0x36, 0x30, 0x64, 0x65, 0x33, 0x32, 0x34, 0x33, 0x32, 0x61, 0x32, 0x65, 0x34, 0x63, 0x33, 0x39, 0x35, 0x65, 0x66, 0x30, 0x33, 0x30, 0x33, 0x62, 0x37, 0x65, 0x38, 0x31, 0x65, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x33, 0x64, 0x65, 0x65, 0x30, 0x33, 0x65, 0x33, 0x37, 0x39, 0x39, 0x39, 0x35, 0x32, 0x64, 0x30, 0x37, 0x33, 0x38, 0x38, 0x34, 0x33, 0x64, 0x34, 0x62, 0x65, 0x38, 0x66, 0x63, 0x30, 0x61, 0x38, 0x30, 0x33, 0x66, 0x62, 0x32, 0x30, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x38, 0x35, 0x33, 0x32, 0x31, 0x35, 0x62, 0x39, 0x62, 0x39, 0x66, 0x32, 0x64, 0x32, 0x63, 0x64, 0x30, 0x37, 0x34, 0x31, 0x65, 0x35, 0x38, 0x35, 0x65, 0x39, 0x38, 0x37, 0x62, 0x35, 0x66, 0x62, 0x38, 0x30, 0x63, 0x32, 0x31, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x35, 0x31, 0x63, 0x30, 0x64, 0x36, 0x32, 0x62, 0x65, 0x34, 0x36, 0x33, 0x35, 0x64, 0x34, 0x37, 0x37, 0x37, 0x65, 0x38, 0x30, 0x33, 0x35, 0x65, 0x33, 0x37, 0x65, 0x34, 0x62, 0x61, 0x38, 0x35, 0x31, 0x37, 0x63, 0x36, 0x31, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x37, 0x36, 0x62, 0x37, 0x34, 0x33, 0x66, 0x39, 0x38, 0x31, 0x62, 0x36, 0x39, 0x33, 0x30, 0x37, 0x32, 0x61, 0x31, 0x33, 0x31, 0x62, 0x32, 0x32, 0x62, 0x61, 0x35, 0x31, 0x30, 0x39, 0x36, 0x35, 0x63, 0x32, 0x66, 0x65, 0x66, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x39, 0x62, 0x64, 0x32, 0x35, 0x61, 0x64, 0x65, 0x31, 0x61, 0x33, 0x33, 0x34, 0x36, 0x63, 0x35, 0x39, 0x63, 0x34, 0x65, 0x39, 0x33, 0x30, 0x64, 0x62, 0x32, 0x61, 0x39, 0x64, 0x37, 0x31, 0x35, 0x65, 0x66, 0x30, 0x61, 0x32, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x65, 0x63, 0x34, 0x65, 0x65, 0x30, 0x64, 0x37, 0x63, 0x61, 0x31, 0x38, 0x30, 0x32, 0x39, 0x30, 0x62, 0x36, 0x62, 0x64, 0x32, 0x30, 0x66, 0x39, 0x39, 0x39, 0x32, 0x33, 0x34, 0x32, 0x66, 0x36, 0x30, 0x66, 0x66, 0x36, 0x38, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x33, 0x34, 0x33, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x66, 0x64, 0x37, 0x32, 0x35, 0x37, 0x36, 0x30, 0x61, 0x36, 0x38, 0x38, 0x32, 0x33, 0x66, 0x66, 0x31, 0x65, 0x30, 0x36, 0x32, 0x66, 0x34, 0x63, 0x63, 0x39, 0x37, 0x65, 0x31, 0x33, 0x36, 0x30, 0x65, 0x38, 0x64, 0x39, 0x39, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x66, 0x30, 0x31, 0x37, 0x37, 0x30, 0x36, 0x62, 0x38, 0x33, 0x30, 0x66, 0x62, 0x39, 0x63, 0x33, 0x30, 0x65, 0x66, 0x62, 0x30, 0x61, 0x30, 0x39, 0x66, 0x35, 0x30, 0x36, 0x62, 0x39, 0x31, 0x35, 0x37, 0x34, 0x35, 0x37, 0x35, 0x33, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x30, 0x66, 0x62, 0x38, 0x36, 0x65, 0x37, 0x64, 0x32, 0x62, 0x35, 0x31, 0x34, 0x30, 0x31, 0x66, 0x63, 0x35, 0x65, 0x38, 0x63, 0x37, 0x32, 0x30, 0x31, 0x35, 0x64, 0x65, 0x63, 0x62, 0x34, 0x65, 0x66, 0x38, 0x66, 0x63, 0x32, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x37, 0x64, 0x32, 0x62, 0x38, 0x30, 0x38, 0x39, 0x65, 0x39, 0x33, 0x31, 0x32, 0x63, 0x63, 0x39, 0x61, 0x65, 0x61, 0x61, 0x32, 0x37, 0x37, 0x33, 0x66, 0x33, 0x35, 0x33, 0x30, 0x38, 0x65, 0x63, 0x36, 0x63, 0x32, 0x61, 0x37, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x63, 0x38, 0x32, 0x32, 0x30, 0x32, 0x39, 0x32, 0x31, 0x38, 0x61, 0x63, 0x38, 0x65, 0x39, 0x38, 0x61, 0x32, 0x36, 0x30, 0x63, 0x31, 0x65, 0x30, 0x36, 0x34, 0x30, 0x32, 0x39, 0x33, 0x34, 0x38, 0x38, 0x33, 0x39, 0x38, 0x37, 0x35, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x36, 0x38, 0x61, 0x36, 0x36, 0x31, 0x33, 0x38, 0x37, 0x38, 0x33, 0x61, 0x36, 0x33, 0x63, 0x39, 0x38, 0x63, 0x63, 0x36, 0x37, 0x35, 0x61, 0x39, 0x65, 0x63, 0x37, 0x37, 0x61, 0x66, 0x34, 0x35, 0x39, 0x38, 0x64, 0x33, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x37, 0x30, 0x37, 0x39, 0x32, 0x35, 0x37, 0x36, 0x66, 0x30, 0x35, 0x64, 0x35, 0x31, 0x34, 0x34, 0x39, 0x33, 0x66, 0x66, 0x64, 0x31, 0x66, 0x35, 0x65, 0x38, 0x34, 0x62, 0x65, 0x63, 0x34, 0x62, 0x32, 0x64, 0x66, 0x38, 0x31, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x31, 0x39, 0x31, 0x66, 0x39, 0x34, 0x36, 0x39, 0x38, 0x32, 0x31, 0x30, 0x35, 0x31, 0x36, 0x63, 0x66, 0x36, 0x33, 0x32, 0x31, 0x61, 0x31, 0x34, 0x32, 0x30, 0x37, 0x30, 0x65, 0x32, 0x30, 0x35, 0x39, 0x37, 0x36, 0x37, 0x34, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x30, 0x63, 0x61, 0x33, 0x32, 0x37, 0x37, 0x39, 0x34, 0x32, 0x65, 0x37, 0x34, 0x34, 0x35, 0x38, 0x37, 0x34, 0x62, 0x65, 0x33, 0x31, 0x63, 0x65, 0x62, 0x39, 0x30, 0x32, 0x39, 0x37, 0x32, 0x37, 0x31, 0x34, 0x66, 0x31, 0x38, 0x32, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x35, 0x65, 0x30, 0x39, 0x36, 0x31, 0x32, 0x30, 0x64, 0x65, 0x61, 0x61, 0x35, 0x63, 0x31, 0x65, 0x63, 0x62, 0x31, 0x36, 0x34, 0x35, 0x65, 0x32, 0x63, 0x63, 0x62, 0x38, 0x62, 0x34, 0x65, 0x64, 0x62, 0x64, 0x39, 0x32, 0x39, 0x39, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x32, 0x62, 0x62, 0x66, 0x38, 0x34, 0x36, 0x34, 0x31, 0x65, 0x33, 0x35, 0x34, 0x31, 0x66, 0x36, 0x63, 0x33, 0x33, 0x65, 0x36, 0x65, 0x64, 0x36, 0x38, 0x33, 0x61, 0x36, 0x33, 0x35, 0x61, 0x37, 0x30, 0x62, 0x64, 0x65, 0x32, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x32, 0x37, 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x32, 0x64, 0x37, 0x37, 0x61, 0x65, 0x30, 0x31, 0x61, 0x39, 0x32, 0x64, 0x33, 0x35, 0x31, 0x31, 0x37, 0x62, 0x61, 0x63, 0x37, 0x30, 0x35, 0x61, 0x61, 0x63, 0x64, 0x39, 0x38, 0x32, 0x64, 0x30, 0x32, 0x65, 0x37, 0x34, 0x63, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x62, 0x62, 0x30, 0x38, 0x38, 0x39, 0x66, 0x63, 0x30, 0x34, 0x32, 0x39, 0x32, 0x36, 0x62, 0x30, 0x35, 0x65, 0x66, 0x35, 0x37, 0x62, 0x32, 0x35, 0x32, 0x30, 0x39, 0x31, 0x30, 0x61, 0x62, 0x63, 0x34, 0x62, 0x34, 0x31, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x61, 0x31, 0x61, 0x33, 0x33, 0x36, 0x39, 0x36, 0x32, 0x64, 0x36, 0x65, 0x30, 0x63, 0x36, 0x33, 0x30, 0x33, 0x31, 0x63, 0x63, 0x38, 0x33, 0x63, 0x36, 0x61, 0x35, 0x63, 0x36, 0x61, 0x36, 0x66, 0x34, 0x34, 0x37, 0x38, 0x65, 0x63, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x64, 0x31, 0x35, 0x34, 0x39, 0x30, 0x33, 0x35, 0x31, 0x33, 0x62, 0x38, 0x64, 0x61, 0x34, 0x66, 0x30, 0x31, 0x39, 0x66, 0x36, 0x38, 0x32, 0x38, 0x34, 0x62, 0x30, 0x36, 0x35, 0x36, 0x61, 0x31, 0x64, 0x30, 0x31, 0x36, 0x39, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x33, 0x37, 0x37, 0x63, 0x64, 0x32, 0x35, 0x65, 0x62, 0x35, 0x33, 0x65, 0x38, 0x33, 0x61, 0x65, 0x30, 0x39, 0x31, 0x61, 0x30, 0x61, 0x31, 0x64, 0x32, 0x62, 0x34, 0x35, 0x31, 0x36, 0x66, 0x34, 0x38, 0x34, 0x61, 0x66, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x63, 0x32, 0x66, 0x32, 0x33, 0x36, 0x61, 0x63, 0x34, 0x61, 0x64, 0x63, 0x64, 0x33, 0x66, 0x64, 0x61, 0x39, 0x66, 0x62, 0x63, 0x36, 0x65, 0x34, 0x35, 0x33, 0x32, 0x32, 0x35, 0x33, 0x66, 0x39, 0x64, 0x61, 0x33, 0x62, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x31, 0x31, 0x33, 0x35, 0x64, 0x38, 0x66, 0x30, 0x35, 0x39, 0x36, 0x33, 0x63, 0x39, 0x30, 0x35, 0x61, 0x34, 0x61, 0x30, 0x37, 0x39, 0x32, 0x32, 0x39, 0x30, 0x39, 0x32, 0x33, 0x35, 0x61, 0x38, 0x39, 0x36, 0x61, 0x35, 0x32, 0x65, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x30, 0x35, 0x34, 0x36, 0x35, 0x30, 0x38, 0x61, 0x33, 0x64, 0x32, 0x36, 0x38, 0x32, 0x63, 0x38, 0x62, 0x39, 0x38, 0x38, 0x34, 0x66, 0x31, 0x33, 0x36, 0x33, 0x37, 0x62, 0x38, 0x38, 0x34, 0x37, 0x62, 0x34, 0x34, 0x64, 0x62, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x64, 0x36, 0x31, 0x62, 0x66, 0x63, 0x35, 0x36, 0x38, 0x37, 0x33, 0x39, 0x32, 0x33, 0x63, 0x32, 0x62, 0x30, 0x30, 0x30, 0x39, 0x35, 0x64, 0x63, 0x33, 0x65, 0x61, 0x61, 0x30, 0x66, 0x35, 0x39, 0x30, 0x64, 0x38, 0x61, 0x65, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x66, 0x61, 0x36, 0x61, 0x66, 0x36, 0x63, 0x32, 0x38, 0x33, 0x62, 0x30, 0x34, 0x36, 0x65, 0x32, 0x37, 0x37, 0x32, 0x63, 0x36, 0x30, 0x36, 0x33, 0x62, 0x30, 0x62, 0x32, 0x31, 0x35, 0x35, 0x33, 0x63, 0x34, 0x30, 0x31, 0x30, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x63, 0x61, 0x62, 0x63, 0x36, 0x30, 0x34, 0x38, 0x61, 0x35, 0x33, 0x34, 0x36, 0x34, 0x34, 0x32, 0x34, 0x66, 0x63, 0x66, 0x37, 0x36, 0x65, 0x65, 0x62, 0x39, 0x65, 0x36, 0x65, 0x31, 0x38, 0x30, 0x31, 0x66, 0x61, 0x32, 0x33, 0x64, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x39, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x30, 0x63, 0x63, 0x33, 0x64, 0x34, 0x34, 0x35, 0x65, 0x62, 0x64, 0x66, 0x37, 0x36, 0x61, 0x37, 0x64, 0x37, 0x61, 0x65, 0x35, 0x37, 0x31, 0x63, 0x36, 0x39, 0x37, 0x31, 0x64, 0x66, 0x66, 0x36, 0x38, 0x63, 0x63, 0x38, 0x35, 0x38, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x66, 0x33, 0x33, 0x61, 0x33, 0x62, 0x64, 0x33, 0x36, 0x61, 0x62, 0x64, 0x62, 0x64, 0x34, 0x31, 0x32, 0x37, 0x30, 0x37, 0x62, 0x38, 0x65, 0x33, 0x31, 0x30, 0x64, 0x36, 0x30, 0x31, 0x31, 0x34, 0x35, 0x34, 0x61, 0x37, 0x61, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x32, 0x64, 0x62, 0x65, 0x62, 0x65, 0x38, 0x39, 0x62, 0x30, 0x33, 0x35, 0x37, 0x61, 0x65, 0x61, 0x39, 0x38, 0x62, 0x62, 0x65, 0x38, 0x65, 0x34, 0x39, 0x36, 0x33, 0x33, 0x38, 0x64, 0x65, 0x62, 0x62, 0x32, 0x38, 0x65, 0x38, 0x30, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x66, 0x35, 0x32, 0x31, 0x32, 0x38, 0x32, 0x65, 0x39, 0x62, 0x32, 0x37, 0x38, 0x64, 0x63, 0x38, 0x63, 0x30, 0x33, 0x34, 0x63, 0x37, 0x32, 0x61, 0x66, 0x35, 0x33, 0x65, 0x65, 0x32, 0x39, 0x65, 0x35, 0x34, 0x34, 0x33, 0x64, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x35, 0x61, 0x34, 0x38, 0x61, 0x38, 0x35, 0x30, 0x30, 0x66, 0x39, 0x62, 0x34, 0x65, 0x32, 0x32, 0x66, 0x30, 0x65, 0x62, 0x31, 0x36, 0x63, 0x36, 0x66, 0x34, 0x36, 0x34, 0x39, 0x36, 0x38, 0x37, 0x36, 0x37, 0x34, 0x32, 0x36, 0x37, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x31, 0x32, 0x37, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x62, 0x33, 0x61, 0x61, 0x33, 0x66, 0x63, 0x64, 0x32, 0x31, 0x32, 0x38, 0x35, 0x34, 0x64, 0x37, 0x35, 0x37, 0x38, 0x66, 0x63, 0x63, 0x33, 0x30, 0x66, 0x64, 0x65, 0x64, 0x65, 0x36, 0x37, 0x34, 0x32, 0x61, 0x33, 0x31, 0x32, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x30, 0x64, 0x32, 0x38, 0x30, 0x39, 0x61, 0x65, 0x31, 0x64, 0x31, 0x66, 0x66, 0x64, 0x38, 0x66, 0x36, 0x33, 0x65, 0x64, 0x61, 0x30, 0x31, 0x64, 0x65, 0x34, 0x39, 0x64, 0x64, 0x35, 0x35, 0x32, 0x64, 0x66, 0x33, 0x64, 0x31, 0x62, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x36, 0x61, 0x35, 0x35, 0x66, 0x30, 0x30, 0x64, 0x66, 0x66, 0x34, 0x30, 0x35, 0x64, 0x63, 0x34, 0x64, 0x65, 0x35, 0x65, 0x35, 0x38, 0x63, 0x35, 0x37, 0x66, 0x36, 0x66, 0x36, 0x66, 0x30, 0x63, 0x61, 0x63, 0x35, 0x35, 0x64, 0x32, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x36, 0x32, 0x37, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x65, 0x38, 0x34, 0x32, 0x65, 0x38, 0x31, 0x38, 0x35, 0x38, 0x65, 0x63, 0x66, 0x65, 0x64, 0x66, 0x36, 0x35, 0x30, 0x36, 0x63, 0x36, 0x38, 0x36, 0x64, 0x63, 0x32, 0x30, 0x34, 0x61, 0x63, 0x31, 0x35, 0x62, 0x66, 0x38, 0x62, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x65, 0x36, 0x61, 0x30, 0x39, 0x65, 0x34, 0x33, 0x30, 0x37, 0x66, 0x65, 0x34, 0x38, 0x64, 0x34, 0x31, 0x32, 0x62, 0x38, 0x64, 0x31, 0x61, 0x31, 0x61, 0x38, 0x32, 0x38, 0x34, 0x64, 0x63, 0x65, 0x34, 0x38, 0x36, 0x32, 0x36, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x63, 0x37, 0x61, 0x63, 0x30, 0x62, 0x64, 0x64, 0x39, 0x33, 0x34, 0x32, 0x62, 0x35, 0x65, 0x61, 0x64, 0x34, 0x33, 0x36, 0x30, 0x39, 0x32, 0x33, 0x66, 0x36, 0x38, 0x63, 0x37, 0x32, 0x61, 0x36, 0x62, 0x61, 0x36, 0x33, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x61, 0x38, 0x66, 0x33, 0x30, 0x62, 0x36, 0x65, 0x34, 0x63, 0x35, 0x65, 0x36, 0x35, 0x32, 0x39, 0x30, 0x66, 0x62, 0x39, 0x38, 0x36, 0x34, 0x32, 0x35, 0x39, 0x62, 0x63, 0x35, 0x39, 0x39, 0x30, 0x66, 0x61, 0x38, 0x65, 0x65, 0x38, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x34, 0x64, 0x33, 0x37, 0x61, 0x35, 0x31, 0x37, 0x34, 0x37, 0x62, 0x66, 0x38, 0x62, 0x37, 0x37, 0x31, 0x62, 0x66, 0x62, 0x66, 0x34, 0x33, 0x39, 0x34, 0x33, 0x39, 0x33, 0x33, 0x64, 0x31, 0x30, 0x30, 0x64, 0x32, 0x31, 0x34, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x61, 0x30, 0x34, 0x64, 0x35, 0x33, 0x38, 0x39, 0x65, 0x62, 0x30, 0x30, 0x36, 0x66, 0x39, 0x63, 0x65, 0x38, 0x38, 0x30, 0x63, 0x33, 0x30, 0x64, 0x31, 0x35, 0x33, 0x35, 0x33, 0x66, 0x38, 0x64, 0x31, 0x31, 0x63, 0x34, 0x62, 0x33, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x32, 0x36, 0x61, 0x31, 0x34, 0x63, 0x39, 0x30, 0x65, 0x33, 0x66, 0x38, 0x34, 0x31, 0x34, 0x34, 0x63, 0x37, 0x36, 0x35, 0x63, 0x66, 0x66, 0x61, 0x63, 0x62, 0x61, 0x33, 0x65, 0x30, 0x64, 0x66, 0x31, 0x31, 0x62, 0x34, 0x38, 0x62, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x62, 0x37, 0x62, 0x64, 0x35, 0x36, 0x33, 0x63, 0x65, 0x61, 0x62, 0x36, 0x38, 0x36, 0x66, 0x39, 0x36, 0x32, 0x34, 0x34, 0x66, 0x39, 0x64, 0x64, 0x63, 0x30, 0x32, 0x61, 0x64, 0x37, 0x62, 0x30, 0x62, 0x31, 0x34, 0x62, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x62, 0x65, 0x36, 0x37, 0x32, 0x61, 0x31, 0x38, 0x35, 0x37, 0x35, 0x30, 0x38, 0x66, 0x36, 0x33, 0x30, 0x66, 0x32, 0x61, 0x35, 0x65, 0x64, 0x62, 0x35, 0x36, 0x33, 0x64, 0x39, 0x65, 0x39, 0x64, 0x65, 0x39, 0x32, 0x38, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x31, 0x37, 0x30, 0x37, 0x30, 0x63, 0x32, 0x65, 0x39, 0x63, 0x35, 0x61, 0x39, 0x34, 0x30, 0x61, 0x34, 0x65, 0x63, 0x30, 0x65, 0x34, 0x39, 0x35, 0x34, 0x63, 0x34, 0x64, 0x37, 0x64, 0x36, 0x34, 0x33, 0x62, 0x65, 0x38, 0x66, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x39, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x32, 0x64, 0x31, 0x62, 0x37, 0x33, 0x35, 0x37, 0x37, 0x32, 0x34, 0x65, 0x63, 0x34, 0x63, 0x30, 0x33, 0x31, 0x38, 0x35, 0x62, 0x38, 0x37, 0x39, 0x62, 0x36, 0x33, 0x66, 0x35, 0x37, 0x65, 0x32, 0x36, 0x35, 0x38, 0x39, 0x31, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x61, 0x37, 0x61, 0x63, 0x34, 0x64, 0x65, 0x37, 0x62, 0x35, 0x31, 0x30, 0x66, 0x30, 0x65, 0x38, 0x64, 0x65, 0x35, 0x31, 0x39, 0x64, 0x39, 0x37, 0x33, 0x66, 0x61, 0x34, 0x63, 0x30, 0x31, 0x62, 0x61, 0x38, 0x33, 0x34, 0x30, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x33, 0x62, 0x34, 0x35, 0x61, 0x31, 0x38, 0x36, 0x34, 0x61, 0x63, 0x35, 0x63, 0x37, 0x65, 0x38, 0x66, 0x30, 0x63, 0x61, 0x61, 0x65, 0x62, 0x61, 0x30, 0x64, 0x38, 0x37, 0x33, 0x63, 0x64, 0x35, 0x64, 0x31, 0x31, 0x33, 0x62, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x33, 0x37, 0x35, 0x33, 0x39, 0x62, 0x35, 0x66, 0x36, 0x61, 0x35, 0x32, 0x32, 0x61, 0x34, 0x38, 0x32, 0x63, 0x64, 0x63, 0x64, 0x33, 0x61, 0x39, 0x62, 0x62, 0x37, 0x30, 0x34, 0x33, 0x61, 0x66, 0x33, 0x39, 0x62, 0x64, 0x64, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x39, 0x32, 0x37, 0x61, 0x62, 0x64, 0x32, 0x64, 0x32, 0x38, 0x61, 0x61, 0x61, 0x61, 0x32, 0x34, 0x64, 0x62, 0x33, 0x31, 0x37, 0x37, 0x38, 0x64, 0x32, 0x37, 0x34, 0x31, 0x39, 0x64, 0x66, 0x38, 0x65, 0x31, 0x62, 0x30, 0x34, 0x62, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x37, 0x35, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x65, 0x30, 0x38, 0x35, 0x66, 0x64, 0x64, 0x64, 0x31, 0x34, 0x36, 0x38, 0x62, 0x61, 0x30, 0x37, 0x34, 0x31, 0x35, 0x62, 0x32, 0x37, 0x34, 0x65, 0x37, 0x33, 0x34, 0x65, 0x31, 0x31, 0x32, 0x33, 0x37, 0x66, 0x62, 0x32, 0x61, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x37, 0x30, 0x39, 0x33, 0x38, 0x35, 0x32, 0x32, 0x61, 0x66, 0x62, 0x35, 0x65, 0x38, 0x66, 0x39, 0x39, 0x34, 0x38, 0x37, 0x33, 0x63, 0x39, 0x66, 0x62, 0x64, 0x63, 0x32, 0x36, 0x65, 0x33, 0x62, 0x33, 0x37, 0x65, 0x33, 0x31, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x64, 0x65, 0x35, 0x66, 0x32, 0x36, 0x65, 0x66, 0x36, 0x61, 0x64, 0x65, 0x64, 0x36, 0x66, 0x30, 0x36, 0x64, 0x33, 0x62, 0x39, 0x31, 0x31, 0x33, 0x34, 0x36, 0x65, 0x65, 0x37, 0x30, 0x34, 0x30, 0x31, 0x64, 0x61, 0x34, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x35, 0x34, 0x37, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x66, 0x66, 0x62, 0x36, 0x39, 0x32, 0x39, 0x32, 0x34, 0x31, 0x66, 0x37, 0x38, 0x38, 0x36, 0x39, 0x33, 0x32, 0x37, 0x33, 0x65, 0x37, 0x30, 0x32, 0x32, 0x65, 0x36, 0x30, 0x65, 0x33, 0x65, 0x61, 0x62, 0x31, 0x66, 0x65, 0x38, 0x34, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x36, 0x61, 0x64, 0x32, 0x61, 0x65, 0x63, 0x36, 0x63, 0x38, 0x63, 0x33, 0x66, 0x31, 0x39, 0x65, 0x31, 0x35, 0x31, 0x35, 0x62, 0x62, 0x62, 0x37, 0x64, 0x64, 0x39, 0x31, 0x32, 0x38, 0x35, 0x32, 0x35, 0x36, 0x62, 0x36, 0x33, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x37, 0x37, 0x33, 0x30, 0x66, 0x35, 0x66, 0x38, 0x65, 0x62, 0x66, 0x38, 0x39, 0x61, 0x63, 0x37, 0x32, 0x65, 0x66, 0x38, 0x30, 0x65, 0x34, 0x36, 0x63, 0x31, 0x32, 0x31, 0x39, 0x35, 0x30, 0x33, 0x38, 0x65, 0x63, 0x64, 0x63, 0x34, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x33, 0x39, 0x61, 0x39, 0x64, 0x37, 0x61, 0x61, 0x33, 0x35, 0x38, 0x31, 0x64, 0x66, 0x30, 0x37, 0x65, 0x65, 0x34, 0x32, 0x37, 0x39, 0x61, 0x65, 0x36, 0x63, 0x33, 0x31, 0x32, 0x65, 0x66, 0x32, 0x31, 0x30, 0x33, 0x33, 0x36, 0x35, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x36, 0x32, 0x32, 0x37, 0x63, 0x64, 0x66, 0x61, 0x30, 0x66, 0x64, 0x33, 0x62, 0x39, 0x64, 0x37, 0x65, 0x36, 0x61, 0x37, 0x34, 0x34, 0x36, 0x38, 0x35, 0x66, 0x35, 0x62, 0x65, 0x39, 0x61, 0x61, 0x33, 0x36, 0x36, 0x61, 0x37, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x34, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x39, 0x65, 0x33, 0x62, 0x35, 0x39, 0x61, 0x31, 0x35, 0x38, 0x36, 0x34, 0x37, 0x33, 0x37, 0x64, 0x34, 0x39, 0x33, 0x63, 0x31, 0x64, 0x32, 0x33, 0x63, 0x63, 0x35, 0x33, 0x64, 0x62, 0x66, 0x38, 0x64, 0x63, 0x62, 0x31, 0x33, 0x36, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x64, 0x30, 0x38, 0x65, 0x30, 0x63, 0x64, 0x64, 0x65, 0x63, 0x30, 0x39, 0x37, 0x64, 0x62, 0x37, 0x39, 0x30, 0x31, 0x65, 0x61, 0x38, 0x31, 0x39, 0x61, 0x33, 0x64, 0x31, 0x66, 0x64, 0x39, 0x64, 0x65, 0x38, 0x39, 0x35, 0x31, 0x61, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x33, 0x33, 0x34, 0x34, 0x34, 0x35, 0x38, 0x34, 0x30, 0x38, 0x32, 0x65, 0x62, 0x61, 0x36, 0x35, 0x34, 0x65, 0x31, 0x61, 0x64, 0x33, 0x30, 0x65, 0x31, 0x34, 0x39, 0x37, 0x33, 0x35, 0x63, 0x36, 0x66, 0x37, 0x62, 0x61, 0x39, 0x32, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x61, 0x38, 0x61, 0x34, 0x33, 0x31, 0x37, 0x63, 0x34, 0x35, 0x66, 0x61, 0x61, 0x30, 0x35, 0x35, 0x34, 0x63, 0x63, 0x64, 0x62, 0x34, 0x38, 0x32, 0x35, 0x34, 0x38, 0x31, 0x38, 0x33, 0x65, 0x32, 0x39, 0x35, 0x61, 0x32, 0x34, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x63, 0x65, 0x33, 0x34, 0x39, 0x31, 0x35, 0x39, 0x65, 0x65, 0x62, 0x31, 0x34, 0x34, 0x65, 0x66, 0x30, 0x36, 0x66, 0x66, 0x32, 0x36, 0x33, 0x36, 0x35, 0x38, 0x38, 0x61, 0x65, 0x66, 0x37, 0x39, 0x66, 0x36, 0x32, 0x38, 0x33, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x64, 0x31, 0x64, 0x39, 0x37, 0x33, 0x31, 0x62, 0x64, 0x35, 0x34, 0x38, 0x63, 0x31, 0x64, 0x64, 0x36, 0x66, 0x63, 0x65, 0x61, 0x36, 0x31, 0x62, 0x65, 0x62, 0x37, 0x35, 0x64, 0x39, 0x31, 0x37, 0x35, 0x34, 0x66, 0x37, 0x64, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x31, 0x33, 0x30, 0x32, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x37, 0x30, 0x35, 0x36, 0x66, 0x36, 0x61, 0x62, 0x66, 0x33, 0x62, 0x31, 0x31, 0x38, 0x64, 0x30, 0x32, 0x36, 0x65, 0x39, 0x34, 0x34, 0x64, 0x35, 0x63, 0x30, 0x37, 0x33, 0x34, 0x33, 0x33, 0x63, 0x61, 0x34, 0x35, 0x31, 0x64, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x66, 0x31, 0x62, 0x33, 0x35, 0x32, 0x31, 0x31, 0x30, 0x64, 0x36, 0x38, 0x39, 0x30, 0x31, 0x64, 0x38, 0x66, 0x36, 0x37, 0x61, 0x61, 0x63, 0x34, 0x36, 0x61, 0x36, 0x63, 0x66, 0x61, 0x66, 0x65, 0x30, 0x33, 0x31, 0x34, 0x37, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x66, 0x37, 0x38, 0x39, 0x65, 0x33, 0x30, 0x33, 0x39, 0x37, 0x63, 0x35, 0x33, 0x62, 0x66, 0x32, 0x35, 0x36, 0x66, 0x63, 0x33, 0x36, 0x34, 0x65, 0x36, 0x65, 0x66, 0x33, 0x39, 0x66, 0x38, 0x35, 0x33, 0x35, 0x30, 0x34, 0x31, 0x31, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x30, 0x62, 0x62, 0x62, 0x38, 0x63, 0x30, 0x36, 0x62, 0x62, 0x62, 0x66, 0x32, 0x34, 0x30, 0x38, 0x34, 0x33, 0x63, 0x63, 0x37, 0x35, 0x37, 0x38, 0x32, 0x65, 0x65, 0x30, 0x32, 0x66, 0x30, 0x38, 0x61, 0x39, 0x37, 0x34, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x66, 0x66, 0x37, 0x61, 0x63, 0x39, 0x39, 0x63, 0x38, 0x65, 0x34, 0x66, 0x65, 0x62, 0x36, 0x30, 0x63, 0x39, 0x37, 0x35, 0x30, 0x30, 0x35, 0x34, 0x62, 0x64, 0x63, 0x31, 0x34, 0x63, 0x65, 0x31, 0x38, 0x35, 0x37, 0x66, 0x31, 0x38, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x36, 0x66, 0x33, 0x36, 0x61, 0x66, 0x39, 0x30, 0x61, 0x62, 0x31, 0x61, 0x36, 0x35, 0x36, 0x63, 0x36, 0x65, 0x63, 0x38, 0x63, 0x37, 0x64, 0x35, 0x32, 0x31, 0x35, 0x31, 0x32, 0x37, 0x36, 0x32, 0x62, 0x62, 0x61, 0x33, 0x65, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x39, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x31, 0x31, 0x62, 0x35, 0x34, 0x63, 0x64, 0x31, 0x39, 0x36, 0x36, 0x33, 0x62, 0x31, 0x31, 0x62, 0x39, 0x34, 0x64, 0x61, 0x31, 0x64, 0x65, 0x32, 0x34, 0x34, 0x38, 0x32, 0x38, 0x35, 0x63, 0x64, 0x39, 0x66, 0x36, 0x38, 0x64, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x66, 0x35, 0x30, 0x39, 0x32, 0x39, 0x37, 0x37, 0x37, 0x38, 0x32, 0x34, 0x63, 0x32, 0x39, 0x31, 0x61, 0x34, 0x39, 0x63, 0x34, 0x36, 0x64, 0x63, 0x38, 0x35, 0x34, 0x66, 0x33, 0x37, 0x39, 0x61, 0x36, 0x62, 0x65, 0x61, 0x30, 0x38, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x38, 0x33, 0x36, 0x30, 0x34, 0x65, 0x34, 0x66, 0x66, 0x36, 0x62, 0x65, 0x37, 0x66, 0x39, 0x36, 0x66, 0x36, 0x30, 0x31, 0x38, 0x64, 0x33, 0x65, 0x63, 0x33, 0x30, 0x37, 0x32, 0x65, 0x63, 0x35, 0x32, 0x35, 0x64, 0x66, 0x66, 0x36, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x33, 0x31, 0x62, 0x62, 0x36, 0x62, 0x35, 0x66, 0x33, 0x63, 0x33, 0x37, 0x33, 0x39, 0x35, 0x65, 0x30, 0x39, 0x63, 0x65, 0x61, 0x63, 0x63, 0x64, 0x31, 0x34, 0x61, 0x39, 0x31, 0x38, 0x61, 0x36, 0x30, 0x36, 0x30, 0x37, 0x38, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x37, 0x32, 0x65, 0x34, 0x35, 0x33, 0x61, 0x36, 0x62, 0x36, 0x32, 0x39, 0x66, 0x32, 0x37, 0x36, 0x37, 0x38, 0x63, 0x63, 0x38, 0x61, 0x65, 0x62, 0x35, 0x65, 0x35, 0x37, 0x63, 0x65, 0x38, 0x35, 0x65, 0x63, 0x30, 0x61, 0x65, 0x66, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x39, 0x32, 0x34, 0x66, 0x62, 0x32, 0x31, 0x31, 0x61, 0x61, 0x64, 0x32, 0x33, 0x63, 0x66, 0x35, 0x63, 0x65, 0x36, 0x30, 0x30, 0x65, 0x30, 0x61, 0x61, 0x65, 0x38, 0x30, 0x36, 0x33, 0x39, 0x36, 0x34, 0x34, 0x34, 0x30, 0x38, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x38, 0x63, 0x36, 0x37, 0x32, 0x33, 0x61, 0x36, 0x37, 0x35, 0x33, 0x32, 0x39, 0x39, 0x63, 0x62, 0x39, 0x31, 0x34, 0x34, 0x37, 0x37, 0x64, 0x30, 0x34, 0x61, 0x33, 0x62, 0x64, 0x32, 0x31, 0x38, 0x64, 0x66, 0x38, 0x63, 0x37, 0x37, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x30, 0x30, 0x34, 0x38, 0x34, 0x37, 0x38, 0x38, 0x64, 0x62, 0x35, 0x30, 0x66, 0x63, 0x36, 0x61, 0x34, 0x38, 0x65, 0x33, 0x37, 0x39, 0x64, 0x31, 0x32, 0x33, 0x65, 0x35, 0x30, 0x38, 0x62, 0x30, 0x66, 0x36, 0x65, 0x35, 0x61, 0x62, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x35, 0x30, 0x65, 0x33, 0x64, 0x62, 0x63, 0x62, 0x63, 0x66, 0x63, 0x38, 0x34, 0x63, 0x63, 0x66, 0x38, 0x39, 0x62, 0x37, 0x33, 0x34, 0x32, 0x37, 0x37, 0x36, 0x33, 0x61, 0x35, 0x36, 0x35, 0x63, 0x32, 0x33, 0x65, 0x36, 0x30, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x66, 0x66, 0x61, 0x30, 0x36, 0x32, 0x31, 0x32, 0x32, 0x61, 0x63, 0x33, 0x30, 0x37, 0x34, 0x31, 0x38, 0x38, 0x32, 0x31, 0x61, 0x64, 0x62, 0x39, 0x33, 0x31, 0x31, 0x30, 0x37, 0x35, 0x61, 0x33, 0x37, 0x30, 0x33, 0x62, 0x66, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x31, 0x32, 0x30, 0x36, 0x63, 0x65, 0x32, 0x32, 0x65, 0x61, 0x34, 0x38, 0x30, 0x65, 0x38, 0x35, 0x39, 0x34, 0x30, 0x64, 0x33, 0x31, 0x33, 0x31, 0x34, 0x65, 0x30, 0x64, 0x36, 0x34, 0x66, 0x34, 0x65, 0x34, 0x64, 0x33, 0x61, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x30, 0x32, 0x34, 0x66, 0x35, 0x39, 0x34, 0x66, 0x39, 0x35, 0x35, 0x38, 0x66, 0x30, 0x34, 0x39, 0x34, 0x33, 0x36, 0x31, 0x38, 0x65, 0x62, 0x30, 0x65, 0x36, 0x62, 0x32, 0x65, 0x65, 0x35, 0x30, 0x31, 0x64, 0x63, 0x32, 0x37, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x32, 0x62, 0x37, 0x63, 0x64, 0x62, 0x34, 0x66, 0x66, 0x34, 0x62, 0x36, 0x31, 0x64, 0x35, 0x62, 0x37, 0x63, 0x65, 0x30, 0x62, 0x32, 0x32, 0x37, 0x30, 0x62, 0x62, 0x62, 0x35, 0x32, 0x36, 0x39, 0x37, 0x34, 0x33, 0x65, 0x63, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x62, 0x63, 0x37, 0x34, 0x37, 0x30, 0x36, 0x39, 0x36, 0x34, 0x39, 0x36, 0x30, 0x64, 0x66, 0x65, 0x30, 0x64, 0x63, 0x61, 0x33, 0x64, 0x63, 0x61, 0x37, 0x39, 0x65, 0x39, 0x32, 0x31, 0x36, 0x30, 0x35, 0x36, 0x66, 0x31, 0x63, 0x66, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x65, 0x62, 0x39, 0x30, 0x33, 0x31, 0x36, 0x32, 0x32, 0x37, 0x31, 0x63, 0x31, 0x61, 0x66, 0x61, 0x33, 0x35, 0x66, 0x65, 0x36, 0x39, 0x65, 0x33, 0x37, 0x33, 0x32, 0x32, 0x63, 0x38, 0x61, 0x34, 0x64, 0x32, 0x39, 0x62, 0x31, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x63, 0x36, 0x32, 0x36, 0x35, 0x64, 0x65, 0x61, 0x31, 0x31, 0x38, 0x37, 0x36, 0x63, 0x39, 0x30, 0x33, 0x62, 0x37, 0x31, 0x38, 0x65, 0x34, 0x63, 0x64, 0x38, 0x61, 0x62, 0x32, 0x34, 0x66, 0x65, 0x32, 0x36, 0x35, 0x62, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x62, 0x61, 0x32, 0x38, 0x38, 0x63, 0x64, 0x33, 0x63, 0x31, 0x65, 0x62, 0x34, 0x64, 0x35, 0x39, 0x64, 0x64, 0x62, 0x30, 0x36, 0x61, 0x36, 0x34, 0x32, 0x31, 0x63, 0x31, 0x34, 0x63, 0x33, 0x34, 0x35, 0x61, 0x34, 0x37, 0x62, 0x32, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x63, 0x32, 0x32, 0x34, 0x32, 0x36, 0x30, 0x35, 0x35, 0x62, 0x37, 0x36, 0x66, 0x31, 0x31, 0x66, 0x30, 0x61, 0x32, 0x64, 0x65, 0x31, 0x61, 0x37, 0x66, 0x38, 0x31, 0x39, 0x61, 0x36, 0x31, 0x39, 0x36, 0x38, 0x35, 0x66, 0x65, 0x36, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x36, 0x33, 0x61, 0x39, 0x30, 0x63, 0x62, 0x33, 0x66, 0x31, 0x33, 0x65, 0x31, 0x66, 0x30, 0x36, 0x34, 0x33, 0x34, 0x32, 0x33, 0x36, 0x33, 0x36, 0x62, 0x65, 0x61, 0x62, 0x38, 0x34, 0x63, 0x31, 0x32, 0x33, 0x62, 0x30, 0x36, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x62, 0x35, 0x63, 0x65, 0x64, 0x39, 0x39, 0x38, 0x37, 0x63, 0x30, 0x37, 0x36, 0x35, 0x66, 0x39, 0x30, 0x30, 0x65, 0x34, 0x39, 0x63, 0x66, 0x39, 0x64, 0x61, 0x32, 0x64, 0x39, 0x66, 0x39, 0x63, 0x31, 0x31, 0x33, 0x38, 0x38, 0x35, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x62, 0x62, 0x37, 0x36, 0x30, 0x64, 0x35, 0x63, 0x32, 0x38, 0x39, 0x61, 0x33, 0x65, 0x31, 0x64, 0x62, 0x31, 0x38, 0x64, 0x62, 0x30, 0x39, 0x35, 0x33, 0x34, 0x35, 0x63, 0x61, 0x34, 0x31, 0x33, 0x62, 0x39, 0x61, 0x34, 0x33, 0x63, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x36, 0x61, 0x62, 0x37, 0x39, 0x32, 0x39, 0x34, 0x30, 0x37, 0x34, 0x63, 0x38, 0x62, 0x36, 0x32, 0x37, 0x64, 0x38, 0x34, 0x32, 0x64, 0x61, 0x62, 0x34, 0x31, 0x65, 0x31, 0x37, 0x64, 0x64, 0x37, 0x30, 0x63, 0x35, 0x64, 0x65, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x62, 0x64, 0x64, 0x35, 0x38, 0x62, 0x39, 0x36, 0x65, 0x37, 0x63, 0x39, 0x31, 0x36, 0x64, 0x64, 0x32, 0x66, 0x62, 0x33, 0x30, 0x33, 0x35, 0x36, 0x66, 0x32, 0x61, 0x65, 0x62, 0x66, 0x61, 0x61, 0x66, 0x31, 0x64, 0x38, 0x36, 0x33, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x36, 0x31, 0x32, 0x35, 0x39, 0x37, 0x62, 0x63, 0x33, 0x31, 0x37, 0x34, 0x33, 0x63, 0x37, 0x38, 0x36, 0x33, 0x33, 0x66, 0x36, 0x33, 0x33, 0x66, 0x32, 0x33, 0x39, 0x62, 0x31, 0x65, 0x39, 0x34, 0x32, 0x36, 0x62, 0x64, 0x39, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x30, 0x35, 0x31, 0x38, 0x61, 0x33, 0x31, 0x39, 0x34, 0x62, 0x61, 0x64, 0x31, 0x33, 0x35, 0x30, 0x62, 0x38, 0x39, 0x34, 0x39, 0x65, 0x36, 0x35, 0x30, 0x35, 0x36, 0x35, 0x64, 0x65, 0x62, 0x65, 0x36, 0x64, 0x62, 0x33, 0x31, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x65, 0x64, 0x64, 0x34, 0x61, 0x64, 0x31, 0x30, 0x37, 0x62, 0x32, 0x37, 0x31, 0x65, 0x38, 0x39, 0x34, 0x38, 0x36, 0x63, 0x62, 0x66, 0x38, 0x30, 0x65, 0x62, 0x64, 0x36, 0x32, 0x31, 0x64, 0x64, 0x39, 0x37, 0x34, 0x35, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x33, 0x36, 0x63, 0x30, 0x62, 0x36, 0x33, 0x62, 0x66, 0x64, 0x37, 0x35, 0x63, 0x32, 0x66, 0x38, 0x65, 0x66, 0x62, 0x30, 0x36, 0x30, 0x38, 0x38, 0x33, 0x64, 0x38, 0x36, 0x38, 0x63, 0x63, 0x63, 0x64, 0x36, 0x63, 0x62, 0x64, 0x62, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x34, 0x36, 0x36, 0x36, 0x35, 0x38, 0x37, 0x32, 0x65, 0x34, 0x30, 0x62, 0x30, 0x64, 0x37, 0x61, 0x61, 0x32, 0x66, 0x66, 0x38, 0x32, 0x37, 0x32, 0x39, 0x63, 0x61, 0x61, 0x62, 0x61, 0x35, 0x62, 0x63, 0x33, 0x65, 0x38, 0x39, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x35, 0x66, 0x62, 0x37, 0x65, 0x61, 0x32, 0x64, 0x64, 0x63, 0x31, 0x35, 0x39, 0x38, 0x62, 0x36, 0x36, 0x37, 0x61, 0x39, 0x64, 0x35, 0x37, 0x64, 0x64, 0x33, 0x39, 0x65, 0x38, 0x35, 0x61, 0x33, 0x38, 0x66, 0x33, 0x35, 0x64, 0x35, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x31, 0x34, 0x32, 0x31, 0x66, 0x38, 0x65, 0x65, 0x32, 0x32, 0x31, 0x30, 0x63, 0x37, 0x31, 0x65, 0x64, 0x38, 0x37, 0x30, 0x66, 0x65, 0x36, 0x31, 0x38, 0x32, 0x37, 0x36, 0x63, 0x38, 0x39, 0x35, 0x34, 0x61, 0x66, 0x62, 0x65, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x33, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x38, 0x61, 0x39, 0x61, 0x34, 0x34, 0x65, 0x31, 0x66, 0x34, 0x31, 0x64, 0x65, 0x33, 0x64, 0x62, 0x62, 0x61, 0x37, 0x61, 0x33, 0x36, 0x33, 0x61, 0x33, 0x61, 0x62, 0x34, 0x31, 0x32, 0x63, 0x31, 0x32, 0x34, 0x63, 0x64, 0x31, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x32, 0x62, 0x63, 0x65, 0x64, 0x33, 0x38, 0x61, 0x62, 0x32, 0x61, 0x62, 0x36, 0x63, 0x30, 0x38, 0x30, 0x66, 0x33, 0x62, 0x30, 0x35, 0x34, 0x31, 0x62, 0x38, 0x34, 0x35, 0x36, 0x65, 0x37, 0x30, 0x38, 0x32, 0x34, 0x62, 0x33, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x34, 0x31, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x65, 0x34, 0x38, 0x34, 0x64, 0x30, 0x36, 0x32, 0x31, 0x66, 0x30, 0x66, 0x35, 0x33, 0x33, 0x31, 0x62, 0x33, 0x35, 0x64, 0x35, 0x34, 0x30, 0x38, 0x64, 0x39, 0x61, 0x61, 0x65, 0x34, 0x65, 0x62, 0x31, 0x61, 0x63, 0x66, 0x32, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x61, 0x34, 0x37, 0x36, 0x62, 0x64, 0x32, 0x63, 0x39, 0x65, 0x36, 0x36, 0x34, 0x63, 0x36, 0x33, 0x61, 0x62, 0x32, 0x36, 0x36, 0x61, 0x61, 0x34, 0x63, 0x36, 0x65, 0x34, 0x61, 0x34, 0x38, 0x32, 0x35, 0x66, 0x35, 0x31, 0x36, 0x63, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x36, 0x64, 0x66, 0x32, 0x30, 0x39, 0x34, 0x38, 0x34, 0x64, 0x37, 0x62, 0x39, 0x34, 0x37, 0x30, 0x32, 0x62, 0x30, 0x33, 0x61, 0x35, 0x33, 0x65, 0x35, 0x36, 0x62, 0x39, 0x66, 0x62, 0x30, 0x36, 0x36, 0x30, 0x66, 0x36, 0x66, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x39, 0x37, 0x30, 0x66, 0x62, 0x31, 0x62, 0x31, 0x34, 0x34, 0x64, 0x64, 0x37, 0x35, 0x31, 0x65, 0x34, 0x63, 0x65, 0x32, 0x65, 0x63, 0x61, 0x37, 0x63, 0x61, 0x61, 0x32, 0x30, 0x65, 0x33, 0x36, 0x33, 0x64, 0x63, 0x34, 0x64, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x31, 0x64, 0x64, 0x37, 0x39, 0x66, 0x62, 0x31, 0x35, 0x38, 0x31, 0x36, 0x30, 0x65, 0x35, 0x62, 0x34, 0x65, 0x38, 0x65, 0x32, 0x33, 0x66, 0x33, 0x31, 0x32, 0x65, 0x36, 0x61, 0x39, 0x30, 0x37, 0x66, 0x62, 0x63, 0x34, 0x64, 0x34, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x65, 0x35, 0x63, 0x61, 0x38, 0x30, 0x35, 0x64, 0x63, 0x65, 0x32, 0x33, 0x61, 0x66, 0x38, 0x39, 0x63, 0x32, 0x64, 0x34, 0x34, 0x34, 0x65, 0x37, 0x65, 0x34, 0x30, 0x37, 0x36, 0x36, 0x63, 0x35, 0x34, 0x63, 0x37, 0x34, 0x30, 0x34, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x34, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x65, 0x30, 0x66, 0x33, 0x37, 0x65, 0x63, 0x64, 0x66, 0x62, 0x30, 0x30, 0x38, 0x36, 0x65, 0x33, 0x65, 0x38, 0x36, 0x32, 0x61, 0x39, 0x37, 0x30, 0x33, 0x34, 0x34, 0x34, 0x37, 0x62, 0x31, 0x65, 0x34, 0x64, 0x65, 0x63, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x31, 0x30, 0x61, 0x63, 0x31, 0x39, 0x63, 0x35, 0x34, 0x36, 0x66, 0x63, 0x32, 0x35, 0x34, 0x37, 0x63, 0x36, 0x31, 0x63, 0x31, 0x33, 0x39, 0x66, 0x35, 0x64, 0x31, 0x66, 0x34, 0x35, 0x61, 0x36, 0x36, 0x36, 0x36, 0x64, 0x35, 0x62, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x37, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x63, 0x37, 0x33, 0x64, 0x30, 0x30, 0x62, 0x36, 0x65, 0x32, 0x35, 0x64, 0x38, 0x65, 0x62, 0x39, 0x63, 0x31, 0x66, 0x66, 0x34, 0x61, 0x64, 0x38, 0x32, 0x37, 0x62, 0x36, 0x62, 0x39, 0x65, 0x39, 0x63, 0x66, 0x36, 0x64, 0x32, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x37, 0x37, 0x31, 0x64, 0x39, 0x65, 0x30, 0x63, 0x61, 0x38, 0x61, 0x30, 0x38, 0x61, 0x31, 0x31, 0x33, 0x37, 0x37, 0x35, 0x37, 0x33, 0x31, 0x34, 0x33, 0x34, 0x65, 0x62, 0x33, 0x32, 0x37, 0x30, 0x35, 0x39, 0x39, 0x63, 0x34, 0x30, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x36, 0x39, 0x64, 0x31, 0x63, 0x33, 0x37, 0x38, 0x62, 0x37, 0x37, 0x31, 0x65, 0x30, 0x66, 0x65, 0x66, 0x66, 0x30, 0x35, 0x31, 0x64, 0x62, 0x36, 0x39, 0x64, 0x39, 0x36, 0x36, 0x61, 0x63, 0x36, 0x37, 0x37, 0x39, 0x66, 0x34, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x65, 0x66, 0x38, 0x35, 0x62, 0x34, 0x39, 0x64, 0x30, 0x38, 0x61, 0x37, 0x35, 0x31, 0x39, 0x38, 0x36, 0x39, 0x32, 0x39, 0x31, 0x34, 0x65, 0x64, 0x64, 0x62, 0x34, 0x62, 0x32, 0x32, 0x63, 0x66, 0x35, 0x66, 0x61, 0x34, 0x34, 0x35, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x37, 0x30, 0x61, 0x33, 0x37, 0x63, 0x64, 0x64, 0x31, 0x63, 0x62, 0x64, 0x61, 0x39, 0x37, 0x34, 0x36, 0x64, 0x39, 0x33, 0x39, 0x36, 0x35, 0x38, 0x61, 0x65, 0x32, 0x61, 0x36, 0x31, 0x38, 0x31, 0x32, 0x38, 0x38, 0x35, 0x37, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x39, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x65, 0x65, 0x37, 0x36, 0x31, 0x38, 0x34, 0x37, 0x65, 0x33, 0x33, 0x66, 0x64, 0x36, 0x31, 0x64, 0x39, 0x39, 0x33, 0x38, 0x37, 0x65, 0x65, 0x31, 0x34, 0x36, 0x32, 0x38, 0x36, 0x39, 0x34, 0x64, 0x31, 0x62, 0x66, 0x64, 0x35, 0x32, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x37, 0x31, 0x64, 0x33, 0x64, 0x34, 0x38, 0x31, 0x63, 0x62, 0x38, 0x38, 0x65, 0x37, 0x36, 0x37, 0x31, 0x61, 0x64, 0x32, 0x31, 0x36, 0x39, 0x34, 0x39, 0x62, 0x36, 0x33, 0x36, 0x35, 0x65, 0x30, 0x36, 0x33, 0x30, 0x33, 0x64, 0x65, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x32, 0x35, 0x35, 0x64, 0x63, 0x36, 0x39, 0x31, 0x35, 0x35, 0x61, 0x34, 0x35, 0x62, 0x39, 0x37, 0x30, 0x63, 0x36, 0x30, 0x34, 0x64, 0x33, 0x30, 0x30, 0x34, 0x37, 0x65, 0x32, 0x66, 0x35, 0x33, 0x30, 0x36, 0x39, 0x30, 0x65, 0x37, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x61, 0x62, 0x61, 0x62, 0x36, 0x32, 0x37, 0x34, 0x65, 0x64, 0x31, 0x35, 0x30, 0x38, 0x39, 0x37, 0x33, 0x37, 0x65, 0x32, 0x38, 0x37, 0x62, 0x65, 0x38, 0x37, 0x38, 0x62, 0x37, 0x35, 0x37, 0x39, 0x33, 0x34, 0x38, 0x36, 0x34, 0x65, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x65, 0x66, 0x65, 0x35, 0x36, 0x61, 0x30, 0x66, 0x66, 0x31, 0x61, 0x31, 0x39, 0x34, 0x37, 0x64, 0x62, 0x61, 0x30, 0x39, 0x32, 0x33, 0x66, 0x37, 0x64, 0x64, 0x32, 0x35, 0x38, 0x64, 0x38, 0x66, 0x31, 0x32, 0x66, 0x61, 0x34, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x61, 0x32, 0x63, 0x31, 0x30, 0x33, 0x37, 0x32, 0x38, 0x62, 0x37, 0x33, 0x30, 0x35, 0x62, 0x35, 0x61, 0x65, 0x36, 0x65, 0x39, 0x36, 0x31, 0x63, 0x39, 0x34, 0x65, 0x65, 0x39, 0x39, 0x63, 0x39, 0x66, 0x65, 0x38, 0x65, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x34, 0x39, 0x38, 0x62, 0x62, 0x30, 0x66, 0x35, 0x32, 0x30, 0x30, 0x30, 0x35, 0x62, 0x36, 0x32, 0x31, 0x36, 0x61, 0x34, 0x34, 0x32, 0x35, 0x62, 0x37, 0x35, 0x61, 0x61, 0x39, 0x61, 0x64, 0x63, 0x35, 0x32, 0x64, 0x36, 0x32, 0x32, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x31, 0x31, 0x33, 0x32, 0x38, 0x37, 0x38, 0x32, 0x33, 0x35, 0x63, 0x35, 0x64, 0x64, 0x62, 0x61, 0x35, 0x64, 0x39, 0x66, 0x33, 0x32, 0x32, 0x38, 0x62, 0x35, 0x32, 0x33, 0x36, 0x65, 0x34, 0x37, 0x30, 0x32, 0x30, 0x64, 0x63, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x38, 0x31, 0x36, 0x32, 0x32, 0x65, 0x35, 0x35, 0x37, 0x35, 0x37, 0x64, 0x61, 0x65, 0x61, 0x36, 0x36, 0x37, 0x35, 0x39, 0x37, 0x35, 0x64, 0x64, 0x39, 0x33, 0x35, 0x33, 0x38, 0x64, 0x61, 0x37, 0x64, 0x31, 0x36, 0x39, 0x39, 0x31, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x65, 0x32, 0x64, 0x65, 0x61, 0x62, 0x35, 0x31, 0x63, 0x30, 0x61, 0x39, 0x61, 0x65, 0x30, 0x39, 0x63, 0x64, 0x32, 0x31, 0x32, 0x63, 0x34, 0x66, 0x61, 0x34, 0x63, 0x63, 0x35, 0x32, 0x62, 0x35, 0x33, 0x63, 0x63, 0x30, 0x64, 0x65, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x36, 0x61, 0x31, 0x65, 0x61, 0x64, 0x65, 0x65, 0x62, 0x33, 0x30, 0x34, 0x36, 0x31, 0x33, 0x34, 0x35, 0x64, 0x39, 0x65, 0x66, 0x36, 0x62, 0x64, 0x30, 0x35, 0x32, 0x31, 0x36, 0x66, 0x61, 0x32, 0x34, 0x37, 0x63, 0x30, 0x64, 0x30, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x62, 0x31, 0x66, 0x65, 0x31, 0x61, 0x62, 0x34, 0x64, 0x66, 0x64, 0x30, 0x30, 0x38, 0x38, 0x63, 0x64, 0x64, 0x37, 0x66, 0x36, 0x30, 0x31, 0x36, 0x33, 0x65, 0x66, 0x35, 0x39, 0x65, 0x63, 0x32, 0x61, 0x65, 0x65, 0x30, 0x36, 0x66, 0x35, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x62, 0x62, 0x63, 0x33, 0x66, 0x33, 0x35, 0x38, 0x61, 0x36, 0x36, 0x38, 0x64, 0x64, 0x31, 0x61, 0x31, 0x31, 0x66, 0x30, 0x33, 0x38, 0x30, 0x66, 0x33, 0x66, 0x37, 0x33, 0x31, 0x30, 0x38, 0x34, 0x32, 0x36, 0x61, 0x62, 0x64, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x31, 0x65, 0x36, 0x65, 0x38, 0x31, 0x30, 0x63, 0x32, 0x34, 0x61, 0x62, 0x30, 0x34, 0x38, 0x38, 0x64, 0x65, 0x39, 0x65, 0x30, 0x31, 0x65, 0x35, 0x37, 0x34, 0x38, 0x33, 0x37, 0x38, 0x32, 0x39, 0x66, 0x37, 0x63, 0x37, 0x37, 0x64, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x33, 0x65, 0x62, 0x33, 0x63, 0x62, 0x38, 0x36, 0x30, 0x66, 0x36, 0x30, 0x32, 0x38, 0x64, 0x61, 0x35, 0x35, 0x34, 0x64, 0x33, 0x34, 0x34, 0x61, 0x32, 0x62, 0x62, 0x35, 0x61, 0x35, 0x30, 0x30, 0x61, 0x65, 0x38, 0x62, 0x38, 0x36, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x35, 0x34, 0x38, 0x31, 0x61, 0x37, 0x66, 0x65, 0x64, 0x34, 0x32, 0x62, 0x39, 0x30, 0x31, 0x62, 0x62, 0x65, 0x64, 0x32, 0x30, 0x37, 0x38, 0x39, 0x62, 0x64, 0x34, 0x61, 0x64, 0x65, 0x35, 0x30, 0x64, 0x35, 0x66, 0x38, 0x33, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x66, 0x33, 0x64, 0x61, 0x36, 0x38, 0x66, 0x65, 0x38, 0x37, 0x65, 0x61, 0x66, 0x34, 0x33, 0x61, 0x38, 0x32, 0x39, 0x61, 0x62, 0x36, 0x64, 0x37, 0x65, 0x63, 0x35, 0x61, 0x36, 0x65, 0x30, 0x30, 0x39, 0x62, 0x32, 0x30, 0x34, 0x66, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x35, 0x34, 0x39, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x30, 0x30, 0x33, 0x37, 0x39, 0x38, 0x38, 0x37, 0x30, 0x32, 0x36, 0x37, 0x31, 0x61, 0x63, 0x62, 0x65, 0x38, 0x39, 0x32, 0x63, 0x30, 0x33, 0x66, 0x65, 0x35, 0x37, 0x38, 0x38, 0x61, 0x61, 0x39, 0x38, 0x61, 0x66, 0x32, 0x38, 0x37, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x64, 0x62, 0x34, 0x37, 0x33, 0x33, 0x35, 0x33, 0x39, 0x37, 0x39, 0x61, 0x32, 0x30, 0x36, 0x38, 0x37, 0x39, 0x64, 0x65, 0x31, 0x34, 0x34, 0x63, 0x31, 0x30, 0x61, 0x33, 0x63, 0x35, 0x31, 0x64, 0x37, 0x64, 0x37, 0x30, 0x38, 0x31, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x32, 0x62, 0x64, 0x66, 0x66, 0x63, 0x32, 0x34, 0x30, 0x61, 0x38, 0x38, 0x66, 0x66, 0x37, 0x34, 0x33, 0x31, 0x61, 0x66, 0x33, 0x62, 0x66, 0x66, 0x35, 0x30, 0x65, 0x31, 0x34, 0x64, 0x61, 0x33, 0x37, 0x64, 0x35, 0x31, 0x38, 0x33, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x37, 0x34, 0x38, 0x36, 0x39, 0x64, 0x34, 0x61, 0x39, 0x39, 0x31, 0x31, 0x65, 0x65, 0x31, 0x65, 0x61, 0x66, 0x35, 0x35, 0x38, 0x62, 0x63, 0x34, 0x63, 0x32, 0x62, 0x36, 0x33, 0x65, 0x63, 0x36, 0x33, 0x61, 0x63, 0x66, 0x64, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x37, 0x35, 0x36, 0x61, 0x64, 0x35, 0x32, 0x66, 0x33, 0x62, 0x66, 0x37, 0x34, 0x61, 0x37, 0x64, 0x32, 0x34, 0x63, 0x36, 0x37, 0x34, 0x37, 0x31, 0x65, 0x30, 0x38, 0x38, 0x37, 0x34, 0x33, 0x36, 0x39, 0x33, 0x36, 0x35, 0x30, 0x34, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x62, 0x64, 0x30, 0x62, 0x36, 0x35, 0x61, 0x35, 0x30, 0x65, 0x66, 0x35, 0x63, 0x65, 0x66, 0x38, 0x34, 0x66, 0x65, 0x63, 0x34, 0x32, 0x30, 0x62, 0x65, 0x37, 0x62, 0x38, 0x39, 0x65, 0x64, 0x31, 0x34, 0x37, 0x30, 0x63, 0x65, 0x62, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x39, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x66, 0x32, 0x36, 0x66, 0x37, 0x63, 0x36, 0x62, 0x66, 0x34, 0x35, 0x33, 0x65, 0x32, 0x30, 0x37, 0x38, 0x66, 0x30, 0x38, 0x39, 0x35, 0x33, 0x65, 0x34, 0x62, 0x32, 0x38, 0x30, 0x30, 0x34, 0x61, 0x32, 0x63, 0x31, 0x65, 0x32, 0x30, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x63, 0x35, 0x33, 0x32, 0x64, 0x62, 0x39, 0x65, 0x30, 0x63, 0x30, 0x36, 0x63, 0x32, 0x36, 0x66, 0x64, 0x34, 0x30, 0x61, 0x63, 0x63, 0x35, 0x36, 0x61, 0x63, 0x35, 0x35, 0x63, 0x31, 0x65, 0x65, 0x39, 0x32, 0x64, 0x33, 0x63, 0x33, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x65, 0x36, 0x37, 0x30, 0x64, 0x30, 0x31, 0x36, 0x33, 0x39, 0x36, 0x36, 0x37, 0x35, 0x37, 0x36, 0x61, 0x32, 0x32, 0x64, 0x64, 0x30, 0x35, 0x64, 0x33, 0x32, 0x34, 0x36, 0x64, 0x36, 0x31, 0x66, 0x30, 0x36, 0x65, 0x30, 0x38, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x36, 0x37, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x63, 0x66, 0x34, 0x34, 0x65, 0x31, 0x30, 0x35, 0x34, 0x30, 0x64, 0x36, 0x35, 0x37, 0x31, 0x36, 0x34, 0x32, 0x33, 0x62, 0x31, 0x62, 0x63, 0x62, 0x35, 0x34, 0x32, 0x64, 0x32, 0x31, 0x66, 0x66, 0x38, 0x33, 0x61, 0x39, 0x34, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x39, 0x36, 0x62, 0x34, 0x63, 0x30, 0x30, 0x37, 0x36, 0x36, 0x66, 0x35, 0x33, 0x37, 0x33, 0x36, 0x61, 0x38, 0x35, 0x37, 0x34, 0x66, 0x38, 0x32, 0x32, 0x65, 0x36, 0x34, 0x37, 0x34, 0x63, 0x32, 0x66, 0x32, 0x31, 0x64, 0x61, 0x32, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x38, 0x64, 0x38, 0x39, 0x31, 0x37, 0x30, 0x62, 0x39, 0x32, 0x62, 0x32, 0x62, 0x65, 0x32, 0x63, 0x30, 0x38, 0x64, 0x35, 0x37, 0x63, 0x34, 0x38, 0x61, 0x37, 0x62, 0x31, 0x39, 0x30, 0x61, 0x32, 0x66, 0x31, 0x34, 0x36, 0x37, 0x32, 0x30, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x31, 0x34, 0x32, 0x62, 0x38, 0x37, 0x63, 0x35, 0x30, 0x34, 0x33, 0x66, 0x66, 0x62, 0x35, 0x61, 0x39, 0x31, 0x64, 0x66, 0x31, 0x38, 0x63, 0x32, 0x65, 0x31, 0x30, 0x39, 0x63, 0x65, 0x64, 0x36, 0x66, 0x65, 0x34, 0x61, 0x37, 0x31, 0x64, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x32, 0x64, 0x33, 0x34, 0x39, 0x34, 0x30, 0x65, 0x64, 0x64, 0x32, 0x65, 0x37, 0x30, 0x30, 0x35, 0x64, 0x34, 0x36, 0x65, 0x32, 0x31, 0x38, 0x38, 0x65, 0x34, 0x63, 0x66, 0x65, 0x63, 0x65, 0x38, 0x33, 0x31, 0x31, 0x64, 0x37, 0x34, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x36, 0x32, 0x31, 0x30, 0x35, 0x65, 0x38, 0x32, 0x62, 0x30, 0x39, 0x39, 0x37, 0x33, 0x35, 0x64, 0x65, 0x34, 0x39, 0x66, 0x36, 0x32, 0x36, 0x39, 0x32, 0x63, 0x63, 0x38, 0x37, 0x63, 0x64, 0x33, 0x38, 0x61, 0x38, 0x65, 0x64, 0x63, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x34, 0x35, 0x37, 0x62, 0x63, 0x65, 0x66, 0x33, 0x37, 0x64, 0x64, 0x33, 0x64, 0x36, 0x30, 0x62, 0x32, 0x64, 0x64, 0x30, 0x31, 0x39, 0x65, 0x33, 0x66, 0x65, 0x36, 0x31, 0x64, 0x34, 0x36, 0x62, 0x33, 0x66, 0x31, 0x65, 0x37, 0x32, 0x35, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x66, 0x38, 0x38, 0x38, 0x32, 0x33, 0x35, 0x39, 0x63, 0x30, 0x66, 0x62, 0x32, 0x33, 0x33, 0x38, 0x37, 0x66, 0x35, 0x36, 0x37, 0x34, 0x30, 0x37, 0x34, 0x64, 0x38, 0x62, 0x31, 0x37, 0x61, 0x64, 0x65, 0x35, 0x31, 0x32, 0x66, 0x39, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x30, 0x63, 0x30, 0x38, 0x31, 0x64, 0x61, 0x35, 0x32, 0x61, 0x39, 0x61, 0x65, 0x33, 0x36, 0x36, 0x34, 0x32, 0x61, 0x64, 0x66, 0x35, 0x65, 0x30, 0x38, 0x32, 0x30, 0x35, 0x66, 0x30, 0x35, 0x63, 0x35, 0x34, 0x31, 0x36, 0x38, 0x61, 0x36, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x35, 0x35, 0x31, 0x65, 0x37, 0x37, 0x38, 0x34, 0x37, 0x37, 0x38, 0x65, 0x66, 0x38, 0x65, 0x30, 0x34, 0x38, 0x65, 0x34, 0x39, 0x35, 0x64, 0x66, 0x34, 0x39, 0x66, 0x32, 0x36, 0x31, 0x34, 0x66, 0x38, 0x34, 0x61, 0x34, 0x66, 0x31, 0x64, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x33, 0x63, 0x38, 0x36, 0x39, 0x63, 0x30, 0x39, 0x36, 0x39, 0x36, 0x35, 0x32, 0x33, 0x63, 0x65, 0x64, 0x38, 0x32, 0x34, 0x61, 0x30, 0x37, 0x30, 0x34, 0x31, 0x34, 0x36, 0x30, 0x35, 0x62, 0x62, 0x37, 0x36, 0x32, 0x33, 0x31, 0x66, 0x66, 0x32, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x65, 0x37, 0x66, 0x31, 0x38, 0x61, 0x30, 0x32, 0x65, 0x63, 0x63, 0x61, 0x61, 0x35, 0x64, 0x36, 0x31, 0x61, 0x62, 0x38, 0x66, 0x62, 0x66, 0x30, 0x33, 0x30, 0x33, 0x34, 0x33, 0x63, 0x34, 0x33, 0x34, 0x61, 0x32, 0x35, 0x65, 0x66, 0x37, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x36, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x33, 0x32, 0x38, 0x64, 0x35, 0x35, 0x63, 0x63, 0x62, 0x33, 0x66, 0x63, 0x65, 0x35, 0x33, 0x31, 0x66, 0x31, 0x39, 0x39, 0x33, 0x38, 0x32, 0x33, 0x33, 0x39, 0x66, 0x30, 0x65, 0x35, 0x37, 0x36, 0x65, 0x65, 0x38, 0x34, 0x30, 0x61, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x39, 0x64, 0x30, 0x66, 0x33, 0x34, 0x37, 0x65, 0x38, 0x32, 0x36, 0x62, 0x37, 0x64, 0x63, 0x65, 0x61, 0x61, 0x64, 0x32, 0x37, 0x39, 0x30, 0x36, 0x30, 0x61, 0x33, 0x35, 0x63, 0x30, 0x30, 0x36, 0x31, 0x65, 0x63, 0x66, 0x33, 0x33, 0x34, 0x62, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x36, 0x38, 0x30, 0x36, 0x34, 0x30, 0x38, 0x33, 0x38, 0x62, 0x64, 0x30, 0x37, 0x61, 0x34, 0x34, 0x37, 0x62, 0x31, 0x36, 0x38, 0x64, 0x36, 0x64, 0x39, 0x32, 0x33, 0x62, 0x39, 0x30, 0x63, 0x66, 0x36, 0x63, 0x34, 0x33, 0x63, 0x64, 0x63, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x39, 0x35, 0x31, 0x39, 0x30, 0x30, 0x63, 0x33, 0x34, 0x31, 0x61, 0x62, 0x62, 0x62, 0x33, 0x62, 0x61, 0x66, 0x62, 0x66, 0x37, 0x65, 0x65, 0x32, 0x30, 0x32, 0x39, 0x33, 0x37, 0x37, 0x30, 0x37, 0x31, 0x64, 0x62, 0x63, 0x33, 0x36, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x64, 0x66, 0x35, 0x38, 0x31, 0x30, 0x61, 0x30, 0x65, 0x62, 0x32, 0x66, 0x62, 0x32, 0x65, 0x33, 0x32, 0x33, 0x32, 0x33, 0x62, 0x62, 0x32, 0x63, 0x39, 0x39, 0x35, 0x30, 0x39, 0x61, 0x62, 0x33, 0x32, 0x30, 0x66, 0x32, 0x34, 0x61, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x32, 0x34, 0x38, 0x39, 0x61, 0x63, 0x31, 0x32, 0x36, 0x39, 0x33, 0x34, 0x64, 0x34, 0x64, 0x36, 0x61, 0x39, 0x34, 0x64, 0x66, 0x30, 0x38, 0x37, 0x34, 0x33, 0x64, 0x61, 0x37, 0x62, 0x37, 0x36, 0x39, 0x31, 0x65, 0x39, 0x37, 0x39, 0x38, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x34, 0x32, 0x66, 0x39, 0x30, 0x35, 0x32, 0x33, 0x31, 0x63, 0x37, 0x37, 0x30, 0x66, 0x30, 0x61, 0x34, 0x30, 0x36, 0x66, 0x32, 0x62, 0x37, 0x36, 0x38, 0x38, 0x37, 0x37, 0x66, 0x62, 0x34, 0x39, 0x65, 0x65, 0x65, 0x30, 0x66, 0x32, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x37, 0x35, 0x36, 0x66, 0x34, 0x35, 0x65, 0x33, 0x66, 0x61, 0x36, 0x39, 0x33, 0x34, 0x37, 0x61, 0x39, 0x61, 0x39, 0x37, 0x33, 0x61, 0x37, 0x32, 0x35, 0x65, 0x33, 0x63, 0x39, 0x38, 0x62, 0x63, 0x34, 0x64, 0x62, 0x30, 0x62, 0x35, 0x61, 0x30, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x31, 0x2c, 0x22, 0x68, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x64, 0x61, 0x6f, 0x46, 0x6f, 0x72, 0x6b, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x64, 0x61, 0x6f, 0x46, 0x6f, 0x72, 0x6b, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x30, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x32, 0x34, 0x36, 0x33, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x30, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x30, 0x38, 0x36, 0x37, 0x39, 0x39, 0x61, 0x65, 0x65, 0x62, 0x65, 0x61, 0x65, 0x31, 0x33, 0x35, 0x63, 0x32, 0x34, 0x36, 0x63, 0x36, 0x35, 0x30, 0x32, 0x31, 0x63, 0x38, 0x32, 0x62, 0x34, 0x65, 0x31, 0x35, 0x61, 0x32, 0x63, 0x34, 0x35, 0x31, 0x33, 0x34, 0x30, 0x39, 0x39, 0x33, 0x61, 0x61, 0x63, 0x66, 0x64, 0x32, 0x37, 0x35, 0x31, 0x38, 0x38, 0x36, 0x35, 0x31, 0x34, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x35, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x32, 0x36, 0x37, 0x35, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x38, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x32, 0x36, 0x37, 0x35, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x62, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x34, 0x33, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x70, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62, 0x75, 0x72, 0x67, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x39, 0x30, 0x36, 0x39, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x6d, 0x75, 0x69, 0x72, 0x47, 0x6c, 0x61, 0x63, 0x69, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x62, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x32, 0x32, 0x34, 0x34, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x6c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x32, 0x39, 0x36, 0x35, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x47, 0x6c, 0x61, 0x63, 0x69, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x33, 0x37, 0x37, 0x33, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x67, 0x72, 0x61, 0x79, 0x47, 0x6c, 0x61, 0x63, 0x69, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x35, 0x38, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x31, 0x36, 0x38, 0x31, 0x33, 0x33, 0x38, 0x34, 0x35, 0x35, 0x2c, 0x22, 0x63, 0x61, 0x6e, 0x63, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x31, 0x37, 0x31, 0x30, 0x33, 0x33, 0x38, 0x31, 0x33, 0x35, 0x2c, 0x22, 0x65, 0x74, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x7d, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x62, 0x62, 0x65, 0x38, 0x64, 0x62, 0x34, 0x65, 0x33, 0x34, 0x37, 0x62, 0x34, 0x65, 0x38, 0x63, 0x39, 0x33, 0x37, 0x63, 0x31, 0x63, 0x38, 0x33, 0x37, 0x30, 0x65, 0x34, 0x62, 0x35, 0x65, 0x64, 0x33, 0x33, 0x61, 0x64, 0x62, 0x33, 0x64, 0x62, 0x36, 0x39, 0x63, 0x62, 0x64, 0x62, 0x37, 0x61, 0x33, 0x38, 0x65, 0x31, 0x65, 0x35, 0x30, 0x62, 0x31, 0x62, 0x38, 0x32, 0x66, 0x61, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x33, 0x38, 0x38, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x22, 0x7d }; namespace silkworm { constinit const std::string_view kGenesisMainnetJson{&kGenesisMainnetDataInternal[0], sizeof(kGenesisMainnetDataInternal)}; } ================================================ FILE: silkworm/core/chain/genesis_mainnet.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { constinit extern const std::string_view kGenesisMainnetJson; } ================================================ FILE: silkworm/core/chain/genesis_mainnet.json ================================================ { "alloc": { "3282791d6fd713f1e94f4bfd565eaa78b3a0599d": { "balance": "1337000000000000000000" }, "17961d633bcf20a7b029a7d94b7df4da2ec5427f": { "balance": "229427000000000000000" }, "493a67fe23decc63b10dda75f3287695a81bd5ab": { "balance": "880000000000000000000" }, "01fb8ec12425a04f813e46c54c05748ca6b29aa9": { "balance": "259800000000000000000" }, "d2a030ac8952325f9e1db378a71485a24e1b07b2": { "balance": "2000000000000000000000" }, "77a34907f305a54c85db09c363fde3c47e6ae21f": { "balance": "985000000000000000000" }, "391a77405c09a72b5e8436237aaaf95d68da1709": { "balance": "49082000000000000000" }, "00aada25ea2286709abb422d41923fd380cd04c7": { "balance": "650100000000000000000" }, "acc46a2a555c74ded4a2bd094e821b97843b40c0": { "balance": "1940000000000000000000" }, "de07fb5b7a464e3ba7fbe09e9acb271af5338c58": { "balance": "50000000000000000000" }, "4c696be99f3a690440c3436a59a7d7e937d6ba0d": { "balance": "3460000000000000000000" }, "fa33553285a973719a0d5f956ff861b2d89ed304": { "balance": "20000000000000000000" }, "67cfda6e70bf7657d39059b59790e5145afdbe61": { "balance": "646000000000000000000" }, "a321091d3018064279db399d2b2a88a6f440ae24": { "balance": "3200000000000000000000" }, "fb3fa1ac08aba9cc3bf0fe9d483820688f65b410": { "balance": "30000000000000000000000" }, "6715c14035fb57bb3d667f7b707498c41074b855": { "balance": "700000000000000000000" }, "d4344f7d5cad65d17e5c2d0e7323943d6f62fe92": { "balance": "267400000000000000000" }, "a3294626ec2984c43b43da4d5d8e4669b11d4b59": { "balance": "1008000000000000000000" }, "656018584130db83ab0591a8128d9381666a8d0e": { "balance": "63960000000000000000" }, "0fa010ce0c731d3b628e36b91f571300e49dbeab": { "balance": "999800000000000000000" }, "3098b65db93ecacaf7353c48808390a223d57684": { "balance": "449965000000000000000" }, "ae635bf73831119d2d29c0d04ff8f8d8d0a57a46": { "balance": "1337000000000000000000" }, "0f7515ff0e808f695e0c20485ff96ed2f7b79310": { "balance": "1000169000000000000000" }, "8b30c04098d7a7e6420c357ea7bfa49bac9a8a18": { "balance": "8000200000000000000000" }, "64dba2d6615b8bd7571836dc75bc79d314f5ecee": { "balance": "10000000000000000000000" }, "e7912d4cf4562c573ddc5b71e37310e378ef86c9": { "balance": "394000000000000000000" }, "a4da34450d22ec0ffcede0004b02f7872ee0b73a": { "balance": "93342000000000000000" }, "34437d1465640b136cb5841c3f934f9ba0b7097d": { "balance": "173000000000000000000" }, "c652871d192422c6bc235fa063b44a7e1d43e385": { "balance": "155000000000000000000" }, "a8a708e84f82db86a35502193b4c6ee9a76ebe8f": { "balance": "1015200000000000000000" }, "5c3f567faff7bad1b5120022e8cbcaa82b4917b3": { "balance": "2000000000000000000000" }, "dbc1d0ee2bab531140de137722cd36bdb4e47194": { "balance": "200000000000000000000" }, "f59dab1bf8df11327e61f9b7a14b563a96ec3554": { "balance": "6000000000000000000000" }, "456f8d746682b224679349064d1b368c7c05b176": { "balance": "3700000000000000000000" }, "5f13154631466dcb1353c890932a7c97e0878e90": { "balance": "6000000000000000000000" }, "f4b1626e24f30bcad9273c527fcc714b5d007b8f": { "balance": "200000000000000000000" }, "a8db0b9b201453333c757f6ad9bcb555c02da93b": { "balance": "2199970000000000000000" }, "a0fc7e53c5ebd27a2abdac45261f84ab3b51aefb": { "balance": "3008250000000000000000" }, "1b636b7a496f044d7359596e353a104616436f6b": { "balance": "360354000000000000000" }, "74bce9ec38362d6c94ccac26d5c0e13a8b3b1d40": { "balance": "999954000000000000000" }, "9834682180b982d166badb9d9d1d9bbf016d87ee": { "balance": "2000000000000000000000" }, "1e6e0153fc161bc05e656bbb144c7187bf4fe84d": { "balance": "2000000000000000000000" }, "989c0ccff654da03aeb11af701054561d6297e1d": { "balance": "4000000000000000000000" }, "78a1e254409fb1b55a7cb4dd8eba3b30c8bad9ef": { "balance": "100000000000000000000" }, "9ef1896b007c32a15114fb89d73dbd47f9122b69": { "balance": "4000000000000000000000" }, "33320dd90f2baa110dd334872a998f148426453c": { "balance": "999972000000000000000" }, "e72e1d335cc29a96b9b1c02f003a16d971e90b9d": { "balance": "1580000000000000000000" }, "0921605f99164e3bcc28f31caece78973182561d": { "balance": "793744000000000000000" }, "fc00a420a36107dfd5f495128a5fe5abb2db0f34": { "balance": "5960000000000000000000" }, "dfcbdf09454e1a5e4a40d3eef7c5cf1cd3de9486": { "balance": "4000000000000000000000" }, "646e043d0597a664948fbb0dc15475a3a4f3a6ed": { "balance": "20000000000000000000" }, "79aeb34566b974c35a5881dec020927da7df5d25": { "balance": "2000000000000000000000" }, "dbadc61ed5f0460a7f18e51b2fb2614d9264a0e0": { "balance": "40000000000000000000" }, "97b91efe7350c2d57e7e406bab18f3617bcde14a": { "balance": "9999980000000000000000" }, "8398e07ebcb4f75ff2116de77c1c2a99f303a4cf": { "balance": "500000000000000000000" }, "f02796295101674288c1d93467053d042219b794": { "balance": "740000000000000000000" }, "f4ed848ec961739c2c7e352f435ba70a7cd5db38": { "balance": "1970000000000000000000" }, "82485728d0e281563758c75ab27ed9e882a0002d": { "balance": "147000000000000000000" }, "427ec668ac9404e895cc861511d1620a4912be98": { "balance": "40000000000000000000000" }, "1bbc199e586790be87afedc849c04726745c5d7b": { "balance": "4000000000000000000000" }, "10d945334ecde47beb9ca3816c173dfbbd0b5333": { "balance": "1400000000000000000000" }, "1dcebcb7656df5dcaa3368a055d22f9ed6cdd940": { "balance": "499800000000000000000" }, "2ac1f8d7bf721f3cfe74d20fea9b87a28aaa982c": { "balance": "161000000000000000000" }, "0a47ad9059a249fc936b2662353da6905f75c2b9": { "balance": "2000000000000000000000" }, "768498934e37e905f1d0e77b44b574bcf3ec4ae8": { "balance": "20000000000000000000000" }, "f46b6b9c7cb552829c1d3dfd8ffb11aabae782f6": { "balance": "21000000000000000000" }, "7aea25d42b2612286e99c53697c6bc4100e2dbbf": { "balance": "2000000000000000000000" }, "af3615c789d0b1152ad4db25fe5dcf222804cf62": { "balance": "1000000000000000000000" }, "92e6581e1da1f9b846e09347333dc818e2d2ac66": { "balance": "3640000000000000000000" }, "240305727313d01e73542c775ff59d11cd35f819": { "balance": "5931229000000000000000" }, "b95cfda8465ba9c2661b249fc3ab661bdfa35ff0": { "balance": "318949000000000000000" }, "1b0d076817e8d68ee2df4e1da1c1142d198c4435": { "balance": "1550000000000000000000" }, "93c2e64e5de5589ed25006e843196ee9b1cf0b3e": { "balance": "1670000000000000000000" }, "0e2e504a2d1122b5a9feee5cb1451bf4c2ace87b": { "balance": "3940000000000000000000" }, "22b96ab2cad55db100b53001f9e4db378104c807": { "balance": "10000000000000000000000" }, "a927d48bb6cb814bc609cbcaa9151f5d459a27e1": { "balance": "271600000000000000000" }, "5cbd8daf27ddf704cdd0d909a789ba36ed4f37b2": { "balance": "13400000000000000000" }, "9adbd3bc7b0afc05d1d2eda49ff863939c48db46": { "balance": "199955000000000000000" }, "ac7e03702723cb16ee27e22dd0b815dc2d5cae9f": { "balance": "16000000000000000000000" }, "1e210e7047886daa52aaf70f4b991dac68e3025e": { "balance": "200000000000000000000" }, "c98048687f2bfcc9bd90ed18736c57edd352b65d": { "balance": "1000000000000000000000" }, "81c18c2a238ddc4cba230a072dd7dc101e620273": { "balance": "1337000000000000000000" }, "cb3d766c983f192bcecac70f4ee03dd9ff714d51": { "balance": "100000000000000000000" }, "44a63d18424587b9b307bfc3c364ae10cd04c713": { "balance": "20000000000000000000" }, "4ab2d34f04834fbf7479649cab923d2c4725c553": { "balance": "3520000000000000000000" }, "b834acf3015322c58382eeb2b79638906e88b6de": { "balance": "24000000000000000000000" }, "7d551397f79a2988b064afd0efebee802c7721bc": { "balance": "39400000000000000000000" }, "b537d36a70eeb8d3e5c80de815225c1158cb92c4": { "balance": "1500000000000000000000" }, "805ce51297a0793b812067f017b3e7b2df9bb1f9": { "balance": "100000000000000000000" }, "085ba65febe23eefc2c802666ab1262382cfc494": { "balance": "400000000000000000000" }, "b1c0d08b36e184f9952a4037e3e53a667d070a4e": { "balance": "1000000000000000000000" }, "83fe5a1b328bae440711beaf6aad6026eda6d220": { "balance": "20000000000000000000000" }, "7fd679e5fb0da2a5d116194dcb508318edc580f3": { "balance": "6560000000000000000000" }, "41ad369f758fef38a19aa3149379832c818ef2a0": { "balance": "1000060000000000000000" }, "6d846dc12657e91af25008519c3e857f51707dd6": { "balance": "4590000000000000000000" }, "c02d6eadeacf1b78b3ca85035c637bb1ce01f490": { "balance": "4000000000000000000000" }, "826eb7cd7319b82dd07a1f3b409071d96e39677f": { "balance": "1000000000000000000000" }, "4ac9905a4cb6ab1cfd62546ee5917300b87c4fde": { "balance": "1015200000000000000000" }, "cf6e52e6b77480b1867efec6446d9fc3cc3577e8": { "balance": "222010000000000000000" }, "2476b2bb751ce748e1a4c4ff7b230be0c15d2245": { "balance": "4000000000000000000000" }, "1a505e62a74e87e577473e4f3afa16bedd3cfa52": { "balance": "500000000000000000000" }, "21d02705f3f64905d80ed9147913ea8c7307d695": { "balance": "1363740000000000000000" }, "7b1daf14891b8a1e1bd429d8b36b9a4aa1d9afbf": { "balance": "500000000000000000000" }, "5338ef70eac9dd9af5a0503b5efad1039e67e725": { "balance": "2674000000000000000000" }, "50ca86b5eb1d01874df8e5f34945d49c6c1ab848": { "balance": "1000000000000000000000" }, "f3cc8bcb559465f81bfe583bd7ab0a2306453b9e": { "balance": "20000000000000000000000" }, "5c323457e187761a8276e359b7b7af3f3b6e3df6": { "balance": "10000000000000000000000" }, "4d82d7700c123bb919419bbaf046799c6b0e2c66": { "balance": "20000000000000000000000" }, "8a66abbc2d30ce21a833b0db8e561d5105e0a72c": { "balance": "699958000000000000000" }, "2ae53866fc2d14d572ab73b4a065a1188267f527": { "balance": "8000000000000000000000" }, "9af5c9894c33e42c2c518e3ac670ea9505d1b53e": { "balance": "18200000000000000000" }, "cba25c7a503cc8e0d04971ca05c762f9b762b48b": { "balance": "500000000000000000000" }, "fda3042819af3e662900e1b92b4358eda6e92590": { "balance": "118200000000000000000000" }, "9bd7c38a4210304a4d653edeff1b3ce45fce7843": { "balance": "282000000000000000000" }, "edc22fb92c638e1e21ff5cf039daa6e734dafb29": { "balance": "298000000000000000000" }, "a1f193a0592f1feb9fdfc90aa813784eb80471c9": { "balance": "1400000000000000000000" }, "e97fde0b67716325cf0ecce8a191a3761b2c791d": { "balance": "1004700000000000000000" }, "110237cf9117e767922fc4a1b78d7964da82df20": { "balance": "3940000000000000000000" }, "e32f95766d57b5cd4b173289d6876f9e64558194": { "balance": "100000000000000000000" }, "f2d59c8923759073d6f415aaf8eb065ff2f3b685": { "balance": "7880000000000000000000" }, "c53d79f7cb9b70952fd30fce58d54b9f0b59f647": { "balance": "5089200000000000000000" }, "9eb281c32719c40fdb3e216db0f37fbc73a026b7": { "balance": "20000000000000000000" }, "2d6511fd7a3800b26854c7ec39c0dcb5f4c4e8e8": { "balance": "399910000000000000000" }, "61ba87c77e9b596de7ba0e326fddfeec2163ef66": { "balance": "200000000000000000000" }, "de1121829c9a08284087a43fbd2fc1142a3233b4": { "balance": "1000000000000000000000" }, "22a25812ab56dcc423175ed1d8adacce33cd1810": { "balance": "1850000000000000000000" }, "518cef27b10582b6d14f69483ddaa0dd3c87bb5c": { "balance": "600000000000000000000" }, "59161749fedcf1c721f2202d13ade2abcf460b3d": { "balance": "2000000000000000000000" }, "3e36c17253c11cf38974ed0db1b759160da63783": { "balance": "7000000000000000000000" }, "cbfa76db04ce38fb205d37b8d377cf1380da0317": { "balance": "1430000000000000000000" }, "a7e83772bc200f9006aa2a260dbaa8483dc52b30": { "balance": "207730000000000000000" }, "e87eac6d602b4109c9671bf57b950c2cfdb99d55": { "balance": "49932000000000000000" }, "9b06ad841dffbe4ccf46f1039fc386f3c321446e": { "balance": "2000000000000000000000" }, "e0f903c1e48ac421ab48528f3d4a2648080fe043": { "balance": "1015200000000000000000" }, "5d872b122e994ef27c71d7deb457bf65429eca6c": { "balance": "7999973000000000000000" }, "f34083ecea385017aa40bdd35ef7effb4ce7762d": { "balance": "400000000000000000000" }, "7f3709391f3fbeba3592d175c740e87a09541d02": { "balance": "480000000000000000000" }, "888e94917083d152202b53163939869d271175b4": { "balance": "4000000000000000000000" }, "bed4c8f006a27c1e5f7ce205de75f516bfb9f764": { "balance": "16000000000000000000000" }, "b3a6bd41f9d9c3201e050b87198fbda399342210": { "balance": "3622615000000000000000" }, "550aadae1221b07afea39fba2ed62e05e5b7b5f9": { "balance": "20000000000000000000" }, "bcedc4267ccb89b31bb764d7211171008d94d44d": { "balance": "200000000000000000000" }, "6229dcc203b1edccfdf06e87910c452a1f4d7a72": { "balance": "32500000000000000000000" }, "94be3ae54f62d663b0d4cc9e1ea8fe9556ea9ebf": { "balance": "23280000000000000000" }, "0e0c9d005ea016c295cd795cc9213e87febc33eb": { "balance": "198000000000000000000" }, "55d057bcc04bd0f4af9642513aa5090bb3ff93fe": { "balance": "1106680000000000000000" }, "ed9e030ca75cb1d29ea01d0d4cdfdccd3844b6e4": { "balance": "30895000000000000000" }, "86c4ce06d9ac185bb148d96f7b7abe73f441006d": { "balance": "10000000000000000000000" }, "2c04115c3e52961b0dc0b0bf31fba4546f5966fd": { "balance": "200000000000000000000" }, "b959dce02e91d9db02b1bd8b7d17a9c41a97af09": { "balance": "8000000000000000000000" }, "e01547ba42fcafaf93938becf7699f74290af74f": { "balance": "2000000000000000000000" }, "c593d6e37d14b566643ac4135f243caa0787c182": { "balance": "12000000000000000000000" }, "2c0ee134d8b36145b47beee7af8d2738dbda08e8": { "balance": "201000000000000000000" }, "0ef54ac7264d2254abbb5f8b41adde875157db7c": { "balance": "40000000000000000000" }, "0349634dc2a9e80c3f7721ee2b5046aeaaedfbb5": { "balance": "4000000000000000000000" }, "873e49135c3391991060290aa7f6ccb8f85a78db": { "balance": "20000000000000000000" }, "05236d4c90d065f9e3938358aaffd777b86aec49": { "balance": "500000000000000000000" }, "d2abd84a181093e5e229136f42d835e8235de109": { "balance": "100007000000000000000" }, "b56a780028039c81caf37b6775c620e786954764": { "balance": "2000000000000000000000" }, "86df73bd377f2c09de63c45d67f283eaefa0f4ab": { "balance": "1000000000000000000000" }, "7670b02f2c3cf8fd4f4730f3381a71ea431c33c7": { "balance": "267400000000000000000" }, "24aa1151bb765fa3a89ca50eb6e1b1c706417fd4": { "balance": "3100000000000000000000" }, "43227d65334e691cf231b4a4e1d339b95d598afb": { "balance": "10000000000000000000000" }, "695550656cbf90b75d92ad9122d90d23ca68ca4d": { "balance": "1000000000000000000000" }, "5281733473e00d87f11e9955e589b59f4ac28e7a": { "balance": "660360000000000000000000" }, "99a96bf2242ea1b39ece6fcc0d18aed00c0179f3": { "balance": "300000000000000000000" }, "b1cf94f8091505055f010ab4bac696e0ca0f67a1": { "balance": "1580000000000000000000" }, "54391b4d176d476cea164e5fb535c69700cb2535": { "balance": "100076000000000000000" }, "152f2bd229ddf3cb0fdaf455c183209c0e1e39a2": { "balance": "2000000000000000000000" }, "affc99d5ebb4a84fe7788d97dce274b038240438": { "balance": "5000000000000000000000" }, "23df8f48ee009256ea797e1fa369beebcf6bc663": { "balance": "2302671000000000000000" }, "3a72d635aadeee4382349db98a1813a4cfeb3df1": { "balance": "200000000000000000000000" }, "ce26f9a5305f8381094354dbfc92664e84f902b5": { "balance": "230200000000000000000" }, "d283b8edb10a25528a4404de1c65e7410dbcaa67": { "balance": "12000000000000000000000" }, "a7859fc07f756ea7dcebbccd42f05817582d973f": { "balance": "10000000000000000000000" }, "b28181a458a440f1c6bb1de8400281a3148f4c35": { "balance": "376000000000000000000" }, "27b1694eafa165ebd7cc7bc99e74814a951419dc": { "balance": "800000000000000000000" }, "66cc8ab23c00d1b82acd7d73f38c99e0d05a4fa6": { "balance": "100000000000000000000" }, "926082cb7eed4b1993ad245a477267e1c33cd568": { "balance": "374300000000000000000" }, "4a47fc3e177f567a1e3893e000e36bba23520ab8": { "balance": "2000000000000000000000" }, "594a76f06935388dde5e234696a0668bc20d2ddc": { "balance": "2800000000000000000000" }, "e91fa0badaddb9a97e88d3f4db7c55d6bb7430fe": { "balance": "376000000000000000000" }, "574de1b3f38d915846ae3718564a5ada20c2f3ed": { "balance": "4000000000000000000000" }, "5816c2687777b6d7d2a2432d59a41fa059e3a406": { "balance": "133700000000000000000000" }, "b50955aa6e341571986608bdc891c2139f540cdf": { "balance": "1970000000000000000000" }, "6d44974a31d187eda16ddd47b9c7ec5002d61fbe": { "balance": "940000000000000000000" }, "80abec5aa36e5c9d098f1b942881bd5acac6963d": { "balance": "2000000000000000000000" }, "294f494b3f2e143c2ffc9738cbfd9501850b874e": { "balance": "2240000000000000000000" }, "bca3ffd4683fba0ad3bbc90734b611da9cfb457e": { "balance": "200000000000000000000" }, "5992624c54cdec60a5ae938033af8be0c50cbb0a": { "balance": "3621678000000000000000" }, "6560941328ff587cbc56c38c78238a7bb5f442f6": { "balance": "744900000000000000000" }, "74b7e0228baed65957aebb4d916d333aae164f0e": { "balance": "2000000000000000000000" }, "8516fcaf77c893970fcd1a958ba9a00e49044019": { "balance": "196279000000000000000" }, "b992a967308c02b98af91ee760fd3b6b4824ab0e": { "balance": "2000000000000000000000" }, "30bb4357cd6910c86d2238bf727cbe8156680e62": { "balance": "100014000000000000000" }, "b8cc0f060aad92d4eb8b36b3b95ce9e90eb383d7": { "balance": "150000000000000000000000" }, "28d4ebf41e3d3c451e943bdd7e1f175fae932a3d": { "balance": "6000000000000000000000" }, "8c83d424a3cf24d51f01923dd54a18d6b6fede7b": { "balance": "4000000000000000000000" }, "7efc90766a00bc52372cac97fabd8a3c831f8ecd": { "balance": "158000000000000000000" }, "7c2b9603884a4f2e464eceb97d17938d828bc02c": { "balance": "3000000000000000000000" }, "9d250ae4f110d71cafc7b0adb52e8d9acb6679b8": { "balance": "9840000000000000000000" }, "61b3df2e9e9fd968131f1e88f0a0eb5bd765464d": { "balance": "4000000000000000000000" }, "9ae13bd882f2576575921a94974cbea861ba0d35": { "balance": "3160000000000000000000" }, "3d09688d93ad07f3abe68c722723cd680990435e": { "balance": "29999948000000000000000" }, "5e58e255fc19870a04305ff2a04631f2ff294bb1": { "balance": "17600000000000000000" }, "bcaed0acb6a76f113f7c613555a2c3b0f5bf34a5": { "balance": "193600000000000000000" }, "159adce27aa10b47236429a34a5ac42cad5b6416": { "balance": "31867951000000000000000" }, "e834c64318205ca7dd4a21abcb08266cb21ff02c": { "balance": "999999000000000000000" }, "7b6a84718dd86e63338429ac811d7c8a860f21f1": { "balance": "1790000000000000000000" }, "2118c116ab0cdf6fd11d54a4309307b477c3fc0f": { "balance": "10000000000000000000000" }, "34a901a69f036bcf9f7843c0ba01b426e8c3dc2b": { "balance": "4000000000000000000000" }, "c7d44fe32c7f8cd5f1a97427b6cd3afc9e45023e": { "balance": "1580000000000000000000" }, "c6045b3c350b4ce9ca0c6b754fb41a69b97e9900": { "balance": "925000000000000000000" }, "cf5a6f9df75579c644f794711215b30d77a0ce40": { "balance": "2000000000000000000000" }, "e2904b1aefa056398b6234cb35811288d736db67": { "balance": "40000000000000000000" }, "7101bd799e411cde14bdfac25b067ac890eab8e8": { "balance": "1450054000000000000000" }, "cc45fb3a555bad807b388a0357c855205f7c75e8": { "balance": "865000000000000000000" }, "ff0c3c7798e8733dd2668152891bab80a8be955c": { "balance": "80220000000000000000" }, "3536453322c1466cb905af5c335ca8db74bff1e6": { "balance": "447000000000000000000" }, "08cac8952641d8fc526ec1ab4f2df826a5e7710f": { "balance": "300000000000000000000" }, "0d8aab8f74ea862cdf766805009d3f3e42d8d00b": { "balance": "5820000000000000000000" }, "8908760cd39b9c1e8184e6a752ee888e3f0b7045": { "balance": "6000000000000000000000" }, "8156360bbd370961ceca6b6691d75006ad204cf2": { "balance": "40000000000000000000000" }, "a304588f0d850cd8d38f76e9e83c1bf63e333ede": { "balance": "39800000000000000000" }, "14c63ba2dcb1dd4df33ddab11c4f0007fa96a62d": { "balance": "15500000000000000000000" }, "a009bf076f1ba3fa57d2a7217218bed5565a7a7a": { "balance": "1000000000000000000000" }, "1c89060f987c518fa079ec2c0a5ebfa30f5d20f7": { "balance": "38000000000000000000000" }, "8895eb726226edc3f78cc6a515077b3296fdb95e": { "balance": "3940000000000000000000" }, "7919e7627f9b7d54ea3b14bb4dd4649f4f39dee0": { "balance": "1670000000000000000000" }, "b3c65b845aba6cd816fbaae983e0e46c82aa8622": { "balance": "1000000000000000000000" }, "eff51d72adfae143edf3a42b1aec55a2ccdd0b90": { "balance": "300000000000000000000" }, "05bb64a916be66f460f5e3b64332110d209e19ae": { "balance": "4200000000000000000000" }, "d5b117ec116eb846418961eb7edb629cd0dd697f": { "balance": "3000000000000000000000" }, "05e97b09492cd68f63b12b892ed1d11d152c0eca": { "balance": "1015200000000000000000" }, "84cc7878da605fdb019fab9b4ccfc157709cdda5": { "balance": "1336922000000000000000" }, "79cac6494f11ef2798748cb53285bd8e22f97cda": { "balance": "2000000000000000000000" }, "bd5a8c94bd8be6470644f70c8f8a33a8a55c6341": { "balance": "200000000000000000000" }, "b119e79aa9b916526581cbf521ef474ae84dcff4": { "balance": "1470700000000000000000" }, "aff1045adf27a1aa329461b24de1bae9948a698b": { "balance": "33400000000000000000" }, "4398628ea6632d393e929cbd928464c568aa4a0c": { "balance": "1400000000000000000000" }, "99997668f7c1a4ff9e31f9977ae3224bcb887a85": { "balance": "291200000000000000000" }, "bc0e8745c3a549445c2be900f52300804ab56289": { "balance": "33104697000000000000000" }, "e5bab4f0afd8a9d1a381b45761aa18f3d3cce105": { "balance": "1508010000000000000000" }, "be60037e90714a4b917e61f193d834906703b13a": { "balance": "1700000000000000000000" }, "8ed4284c0f47449c15b8d9b3245de8beb6ce80bf": { "balance": "800000000000000000000" }, "333ad1596401e05aea2d36ca47318ef4cd2cb3df": { "balance": "2910000000000000000000" }, "22db559f2c3c1475a2e6ffe83a5979599196a7fa": { "balance": "1000000000000000000000" }, "fdf449f108c6fb4f5a2b081eed7e45e6919e4d25": { "balance": "2000000000000000000000" }, "0be1bcb90343fae5303173f461bd914a4839056c": { "balance": "6000000000000000000000" }, "b981ad5e6b7793a23fc6c1e8692eb2965d18d0da": { "balance": "9999924000000000000000" }, "c75d2259306aec7df022768c69899a652185dbc4": { "balance": "4000000000000000000000" }, "6c2e9be6d4ab450fd12531f33f028c614674f197": { "balance": "3580000000000000000000" }, "6dcc7e64fcafcbc2dc6c0e5e662cb347bffcd702": { "balance": "20000000000000000000000" }, "aabdb35c1514984a039213793f3345a168e81ff1": { "balance": "309760000000000000000" }, "d315deea1d8c1271f9d1311263ab47c007afb6f5": { "balance": "69760000000000000000" }, "4faf90b76ecfb9631bf9022176032d8b2c207009": { "balance": "1000032000000000000000" }, "3e7a966b5dc357ffb07e9fe067c45791fd8e3049": { "balance": "59100000000000000000" }, "2e64a8d71111a22f4c5de1e039b336f68d398a7c": { "balance": "2000000000000000000000" }, "181fbba852a7f50178b1c7f03ed9e58d54162929": { "balance": "666000000000000000000" }, "4f7330096f79ed264ee0127f5d30d2f73c52b3d8": { "balance": "499970000000000000000" }, "a8a8dbdd1a85d1beee2569e91ccc4d09ae7f6ea1": { "balance": "5800000000000000000000" }, "1f9c3268458da301a2be5ab08257f77bb5a98aa4": { "balance": "200000000000000000000" }, "fc372ff6927cb396d9cf29803500110da632bc52": { "balance": "2000000000000000000000" }, "4fa554ab955c249217386a4d3263bbf72895434e": { "balance": "19982000000000000000" }, "2a59e47ea5d8f0e7c028a3e8e093a49c1b50b9a3": { "balance": "2000000000000000000000" }, "5e32c72191b8392c55f510d8e3326e3a60501d62": { "balance": "44000000000000000000000" }, "1dfaee077212f1beaf0e6f2f1840537ae154ad86": { "balance": "1000000000000000000000" }, "7eaba035e2af3793fd74674b102540cf190addb9": { "balance": "1273000000000000000000" }, "d62edb96fce2969aaf6c545e967cf1c0bc805205": { "balance": "85705000000000000000" }, "220dc68df019b6b0ccbffb784b5a5ab4b15d4060": { "balance": "3940000000000000000000" }, "45bb829652d8bfb58b8527f0ecb621c29e212ec3": { "balance": "2000000000000000000000" }, "79b120eb8806732321288f675a27a9225f1cd2eb": { "balance": "2465000000000000000000" }, "740af1eefd3365d78ba7b12cb1a673e06a077246": { "balance": "19700000000000000000000" }, "0f042c9c2fb18766f836bb59f735f27dc329fe3c": { "balance": "10000000000000000000000" }, "6dda5f788a6c688ddf921fa3852eb6d6c6c62966": { "balance": "40000000000000000000" }, "96ad579bbfa8db8ebec9d286a72e4661eed8e356": { "balance": "1070750000000000000000" }, "0c2073ba44d3ddbdb639c04e191039a71716237f": { "balance": "1430000000000000000000" }, "1a3520453582c718a21c42375bc50773255253e1": { "balance": "790000000000000000000" }, "efcaae9ff64d2cd95b5249dcffe7faa0a0c0e44d": { "balance": "401100000000000000000" }, "0a3de155d5ecd8e81c1ff9bbf0378301f8d4c623": { "balance": "4000000000000000000000" }, "80f07ac09e7b2c3c0a3d1e9413a544c73a41becb": { "balance": "20000000000000000000" }, "c3631c7698b6c5111989bf452727b3f9395a6dea": { "balance": "10683500000000000000000" }, "4cc22c9bc9ad05d875a397dbe847ed221c920c67": { "balance": "2000000000000000000000" }, "1a987e3f83de75a42f1bde7c997c19217b4a5f24": { "balance": "2000000000000000000000" }, "5b2b64e9c058e382a8b299224eecaa16e09c8d92": { "balance": "161000000000000000000" }, "86caafacf32aa0317c032ac36babed974791dc03": { "balance": "40000000000000000000000" }, "1cd1f0a314cbb200de0a0cb1ef97e920709d97c2": { "balance": "2000000000000000000000" }, "7d980f4b566bb045517e4c14c87750de9346744b": { "balance": "1337000000000000000000" }, "8b5f29cc2faa262cdef30ef554f50eb488146eac": { "balance": "5818250000000000000000" }, "5153a0c3c8912881bf1c3501bf64b45649e48222": { "balance": "4000000000000000000000" }, "d21a7341eb84fd151054e5e387bb25d36e499c09": { "balance": "14000000000000000000000" }, "9560e8ac6718a6a1cdcff189d603c9063e413da6": { "balance": "4000000000000000000000" }, "e49ba0cd96816c4607773cf8a5970bb5bc16a1e6": { "balance": "1670000000000000000000" }, "b8ac117d9f0dba80901445823c4c9d4fa3fedc6e": { "balance": "15759015000000000000000" }, "af67fd3e127fd9dc36eb3fcd6a80c7be4f7532b2": { "balance": "1670000000000000000000" }, "b43c27f7a0a122084b98f483922541c8836cee2c": { "balance": "715000000000000000000" }, "4d9279962029a8bd45639737e98b511eff074c21": { "balance": "1337000000000000000000" }, "c667441e7f29799aba616451d53b3f489f9e0f48": { "balance": "13920000000000000000000" }, "275875ff4fbb0cf3a430213127487f7608d04cba": { "balance": "500080000000000000000" }, "9a953b5bcc709379fcb559d7b916afdaa50cadcc": { "balance": "100000000000000000000" }, "7ea791ebab0445a00efdfc4e4a8e9a7e7565136d": { "balance": "18200000000000000000" }, "6ffe5cf82cc9ea5e36cad7c2974ce7249f3749e6": { "balance": "1940000000000000000000" }, "f1b4ecc63525f7432c3d834ffe2b970fbeb87212": { "balance": "3000064000000000000000" }, "6b72a8f061cfe6996ad447d3c72c28c0c08ab3a7": { "balance": "4271316000000000000000" }, "bba3c68004248e489573abb2743677066b24c8a7": { "balance": "2000000000000000000000" }, "b7c0d0cc0b4d342d4062bac624ccc3c70cc6da3f": { "balance": "4000000000000000000000" }, "fe98c664c3e447a95e69bd582171b7176ea2a685": { "balance": "4000000000000000000000" }, "ce71086d4c602554b82dcbfce88d20634d53cc4d": { "balance": "43250000000000000000000" }, "1c601993789207f965bb865cbb4cd657cce76fc0": { "balance": "98294000000000000000" }, "476b5599089a3fb6f29c6c72e49b2e4740ea808d": { "balance": "2800000000000000000000" }, "3439998b247cb4bf8bc80a6d2b3527f1dfe9a6d2": { "balance": "140000000000000000000" }, "c4f7d2e2e22084c44f70feaab6c32105f3da376f": { "balance": "1970000000000000000000" }, "c1eba5684aa1b24cba63150263b7a9131aeec28d": { "balance": "20000000000000000000" }, "94ad4bad824bd0eb9ea49c58cebcc0ff5e08346b": { "balance": "1940000000000000000000" }, "ded877378407b94e781c4ef4af7cfc5bc220b516": { "balance": "372500000000000000000" }, "699c9ee47195511f35f862ca4c22fd35ae8ffbf4": { "balance": "80000000000000000000" }, "e3a89a1927cc4e2d43fbcda1e414d324a7d9e057": { "balance": "205500000000000000000" }, "4d93696fa24859f5d2939aebfa54b4b51ae1dccc": { "balance": "19100000000000000000" }, "0af65f14784e55a6f95667fd73252a1c94072d2a": { "balance": "192987000000000000000" }, "5b70c49cc98b3df3fbe2b1597f5c1b6347a388b7": { "balance": "970000000000000000000" }, "426f78f70db259ac8534145b2934f4ef1098b5d8": { "balance": "360000000000000000000" }, "58b8ae8f63ef35ed0762f0b6233d4ac14e64b64d": { "balance": "2000000000000000000000" }, "8eae29435598ba8f1c93428cdb3e2b4d31078e00": { "balance": "2000000000000000000000" }, "17fd9b551a98cb61c2e07fbf41d3e8c9a530cba5": { "balance": "26989000000000000000" }, "ab3e78294ba886a0cfd5d3487fb3a3078d338d6e": { "balance": "1970000000000000000000" }, "bdf6e68c0cd7584080e847d72cbb23aad46aeb1d": { "balance": "1970000000000000000000" }, "f989346772995ec1906faffeba2a7fe7de9c6bab": { "balance": "6685000000000000000000" }, "dc5f5ad663a6f263327d64cac9cb133d2c960597": { "balance": "2000000000000000000000" }, "68fe1357218d095849cd579842c4aa02ff888d93": { "balance": "2000000000000000000000" }, "e09c68e61998d9c81b14e4ee802ba7adf6d74cdb": { "balance": "4000000000000000000000" }, "890fe11f3c24db8732d6c2e772e2297c7e65f139": { "balance": "62980000000000000000000" }, "a76929890a7b47fb859196016c6fdd8289ceb755": { "balance": "5000000000000000000000" }, "2dc79d6e7f55bce2e2d0c02ad07ceca8bb529354": { "balance": "1580000000000000000000" }, "19687daa39c368139b6e7be60dc1753a9f0cbea3": { "balance": "8000000000000000000000" }, "c69be440134d6280980144a9f64d84748a37f349": { "balance": "715000000000000000000" }, "3d8d0723721e73a6c0d860aa0557abd14c1ee362": { "balance": "5000000000000000000000" }, "2b241f037337eb4acc61849bd272ac133f7cdf4b": { "balance": "378000000000000000000000" }, "24b95ebef79500baa0eda72e77f877415df75c33": { "balance": "910000000000000000000" }, "106ed5c719b5261477890425ae7551dc59bd255c": { "balance": "11979600000000000000000" }, "5b2e2f1618552eab0db98add55637c2951f1fb19": { "balance": "12000000000000000000000" }, "403145cb4ae7489fcc90cd985c6dc782b3cc4e44": { "balance": "5999800000000000000000" }, "e8be24f289443ee473bc76822f55098d89b91cc5": { "balance": "2000000000000000000000" }, "f6bc37b1d2a3788d589b6de212dc1713b2f6e78e": { "balance": "5000000000000000000000" }, "67fc527dce1785f0fb8bc7e518b1c669f7ecdfb5": { "balance": "240000000000000000000" }, "6580b1bc94390f04b397bd73e95d96ef11eaf3a8": { "balance": "20000000000000000000" }, "98bf4af3810b842387db70c14d46099626003d10": { "balance": "4000000000000000000000" }, "17993d312aa1106957868f6a55a5e8f12f77c843": { "balance": "450065000000000000000" }, "0729b4b47c09eb16158464c8aa7fd9690b438839": { "balance": "1999800000000000000000" }, "ae70e69d2c4a0af818807b1a2705f79fd0b5dbc4": { "balance": "985000000000000000000" }, "38b50146e71916a5448de12a4d742135dcf39833": { "balance": "32200000000000000000000" }, "38439aaa24e3636f3a18e020ea1da7e145160d86": { "balance": "2600000000000000000000" }, "54b4429b182f0377be7e626939c5db6440f75d7a": { "balance": "1970000000000000000000" }, "7179726f5c71ae1b6d16a68428174e6b34b23646": { "balance": "7353500000000000000000" }, "c2ee91d3ef58c9d1a589844ea1ae3125d6c5ba69": { "balance": "970000000000000000000" }, "912304118b80473d9e9fe3ee458fbe610ffda2bb": { "balance": "200000000000000000000" }, "3308b03466c27a17dfe1aafceb81e16d2934566f": { "balance": "17000000000000000000000" }, "10346414bec6d3dcc44e50e54d54c2b8c3734e3e": { "balance": "4000000000000000000000" }, "4fee50c5f988206b09a573469fb1d0b42ebb6dce": { "balance": "2009400000000000000000" }, "9ece1400800936c7c6485fcdd3626017d09afbf6": { "balance": "310000000000000000000" }, "ddf3ad76353810be6a89d731b787f6f17188612b": { "balance": "20000000000000000000000" }, "72402300e81d146c2e644e2bbda1da163ca3fb56": { "balance": "7000000000000000000000" }, "bb4b4a4b548070ff41432c9e08a0ca6fa7bc9f76": { "balance": "850000000000000000000" }, "c3dd58903886303b928625257ae1a013d71ae216": { "balance": "2000000000000000000000" }, "ca6c818befd251361e02744068be99d8aa60b84a": { "balance": "6000000000000000000000" }, "b8d2ddc66f308c0158ae3ccb7b869f7d199d7b32": { "balance": "844800000000000000000" }, "8e486a0442d171c8605be348fee57eb5085eff0d": { "balance": "4000000000000000000000" }, "a807104f2703d679f8deafc442befe849e42950b": { "balance": "2000000000000000000000" }, "bb61a04bffd57c10470d45c39103f64650347616": { "balance": "1000000000000000000000" }, "d1c45954a62b911ad701ff2e90131e8ceb89c95c": { "balance": "1394000000000000000000" }, "5e65458be964ae449f71773704979766f8898761": { "balance": "528600000000000000000" }, "f9b37825f03073d31e249378c30c795c33f83af2": { "balance": "200152000000000000000" }, "e309974ce39d60aadf2e69673251bf0e04760a10": { "balance": "254030000000000000000" }, "d541ac187ad7e090522de6da3213e9a7f4439673": { "balance": "2000000000000000000000" }, "f33efc6397aa65fb53a8f07a0f893aae30e8bcee": { "balance": "2304850000000000000000" }, "d2f1998e1cb1580cec4f6c047dcd3dcec54cf73c": { "balance": "200000000000000000000" }, "0ed76c2c3b5d50ff8fb50b3eeacd681590be1c2d": { "balance": "100000000000000000000" }, "637d67d87f586f0a5a479e20ee13ea310a10b647": { "balance": "48300000000000000000000" }, "1a5ee533acbfb3a2d76d5b685277b796c56a052b": { "balance": "2000000000000000000000" }, "323fca5ed77f699f9d9930f5ceeff8e56f59f03c": { "balance": "1337000000000000000000" }, "a5fe2ce97f0e8c3856be0de5f4dcb2ce5d389a16": { "balance": "22892000000000000000" }, "93258255b37c7f58f4b10673a932dd3afd90f4f2": { "balance": "1000000000000000000000" }, "950fe9c6cad50c18f11a9ed9c45740a6180612d0": { "balance": "8000000000000000000000" }, "ee31167f9cc93b3c6465609d79db0cde90e8484c": { "balance": "2000000000000000000000" }, "6ebb5e6957aa821ef659b6018a393a504cae4450": { "balance": "2000000000000000000000" }, "be305a796e33bbf7f9aeae6512959066efda1010": { "balance": "10880000000000000000000" }, "537f9d4d31ef70839d84b0d9cdb72b9afedbdf35": { "balance": "70000000000000000000000" }, "fe9e1197d7974a7648dcc7a03112a88edbc9045d": { "balance": "4925000000000000000000" }, "99f77f998b20e0bcdcd9fc838641526cf25918ef": { "balance": "1790000000000000000000" }, "76ffc157ad6bf8d56d9a1a7fddbc0fea010aabf4": { "balance": "1000000000000000000000" }, "defe9141f4704599159d7b223de42bffd80496b3": { "balance": "100000000000000000000" }, "7b1bf53a9cbe83a7dea434579fe72aac8d2a0cd0": { "balance": "199800000000000000000" }, "23ccc3c6acd85c2e460c4ffdd82bc75dc849ea14": { "balance": "4000000000000000000000" }, "9f86a066edb61fcb5856de93b75c8c791864b97b": { "balance": "2000000000000000000000" }, "871b8a8b51dea1989a5921f13ec1a955a515ad47": { "balance": "8000000000000000000000" }, "4efcd9c79fb4334ca6247b0a33bd9cc33208e272": { "balance": "1337000000000000000000" }, "35ac1d3ed7464fa3db14e7729213ceaa378c095e": { "balance": "1520000000000000000000" }, "c69d663c8d60908391c8d236191533fdf7775613": { "balance": "485000000000000000000" }, "c2ed5ffdd1add855a2692fe062b5d618742360d4": { "balance": "1200000000000000000000" }, "454f0141d721d33cbdc41018bd01119aa4784818": { "balance": "6000000000000000000000" }, "6c8687e3417710bb8a93559021a1469e6a86bc77": { "balance": "11126675000000000000000" }, "ec5b198a00cfb55a97b5d53644cffa8a04d2ab45": { "balance": "2000000000000000000000" }, "cd59f3dde77e09940befb6ee58031965cae7a336": { "balance": "10000000000000000000000" }, "8eebec1a62c08b05a7d1d59180af9ff0d18e3f36": { "balance": "500000000000000000000" }, "92a971a739799f8cb48ea8475d72b2d2474172e6": { "balance": "3940000000000000000000" }, "bed4649df646e2819229032d8868556fe1e053d3": { "balance": "18200000000000000000" }, "c50fe415a641b0856c4e75bf960515441afa358d": { "balance": "2000000000000000000000" }, "91f516146cda20281719978060c6be4149067c88": { "balance": "2000000000000000000000" }, "54a1370116fe22099e015d07cd2669dd291cc9d1": { "balance": "20000000000000000000" }, "80c04efd310f440483c73f744b5b9e64599ce3ec": { "balance": "1200000000000000000000" }, "a8914c95b560ec13f140577338c32bcbb77d3a7a": { "balance": "180000000000000000000" }, "e3c812737ac606baf7522ad817428a36050e7a34": { "balance": "1940000000000000000000" }, "6d1456fff0104ee844a3314737843338d24cd66c": { "balance": "141840000000000000000" }, "0e6ece99111cad1961c748ed3df51edd69d2a3b1": { "balance": "100000000000000000000000" }, "019d709579ff4bc09fdcdde431dc1447d2c260bc": { "balance": "20000000000000000000" }, "ebff84bbef423071e604c361bba677f5593def4e": { "balance": "10000000000000000000000" }, "e10c540088113fa6ec00b4b2c8824f8796e96ec4": { "balance": "236400000000000000000000" }, "e03220c697bcd28f26ef0b74404a8beb06b2ba7b": { "balance": "8000000000000000000000" }, "e69a6cdb3a8a7db8e1f30c8b84cd73bae02bc0f8": { "balance": "16915503000000000000000" }, "e5fb31a5caee6a96de393bdbf89fbe65fe125bb3": { "balance": "1000000000000000000000" }, "030fb3401f72bd3418b7d1da75bf8c519dd707dc": { "balance": "3000000000000000000000" }, "1c751e7f24df9d94a637a5dedeffc58277b5db19": { "balance": "3220000000000000000000" }, "bded7e07d0711e684de65ac8b2ab57c55c1a8645": { "balance": "591000000000000000000" }, "dd7ff441ba6ffe3671f3c0dabbff1823a5043370": { "balance": "2000000000000000000000" }, "b55474ba58f0f2f40e6cbabed4ea176e011fcad6": { "balance": "1970000000000000000000" }, "b92427ad7578b4bfe20a9f63a7c5506d5ca12dc8": { "balance": "2000000000000000000000" }, "91a8baaed012ea2e63803b593d0d0c2aab4c5b0a": { "balance": "1500000000000000000000" }, "a97e072144499fe5ebbd354acc7e7efb58985d08": { "balance": "2674000000000000000000" }, "75c2ffa1bef54919d2097f7a142d2e14f9b04a58": { "balance": "2673866000000000000000" }, "53faf165be031ec18330d9fce5bd1281a1af08db": { "balance": "140000000000000000000" }, "055ab658c6f0ed4f875ed6742e4bc7292d1abbf0": { "balance": "83500000000000000000" }, "6f18ec767e320508195f1374500e3f2e125689ff": { "balance": "1000000000000000000000" }, "90fc537b210658660a83baa9ac4a8402f65746a8": { "balance": "1880000000000000000000" }, "34664d220fa7f37958024a3332d684bcc6d4c8bd": { "balance": "10000000000000000000000" }, "15acb61568ec4af7ea2819386181b116a6c5ee70": { "balance": "31000000000000000000000" }, "69d98f38a3ba3dbc01fa5c2c1427d862832f2f70": { "balance": "100000000000000000000000" }, "ece1152682b7598fe2d1e21ec15533885435ac85": { "balance": "4000000000000000000000" }, "f618d9b104411480a863e623fc55232d1a4f48aa": { "balance": "265793000000000000000" }, "f9debaecb5f339beea4894e5204bfa340d067f25": { "balance": "1665000000000000000000" }, "5e731b55ced452bb3f3fe871ddc3ed7ee6510a8f": { "balance": "3000000000000000000000" }, "67df242d240dd4b8071d72f8fcf35bb3809d71e8": { "balance": "4000000000000000000000" }, "c4cf930e5d116ab8d13b9f9a7ec4ab5003a6abde": { "balance": "320000000000000000000" }, "01a25a5f5af0169b30864c3be4d7563ccd44f09e": { "balance": "1430000000000000000000" }, "7f6efb6f4318876d2ee624e27595f44446f68e93": { "balance": "1550000000000000000000" }, "82249fe70f61c6b16f19a324840fdc020231bb02": { "balance": "9504014000000000000000" }, "205237c4be146fba99478f3a7dad17b09138da95": { "balance": "2000000000000000000000" }, "fd1fb5a89a89a721b8797068fbc47f3e9d52e149": { "balance": "236400000000000000000" }, "e47fbaed99fc209962604ebd20e240f74f4591f1": { "balance": "2000000000000000000000" }, "a24c3ab62181e9a15b78c4621e4c7c588127be26": { "balance": "162410000000000000000" }, "b6cd7432d5161be79768ad45de3e447a07982063": { "balance": "4000000000000000000000" }, "32a70691255c9fc9791a4f75c8b81f388e0a2503": { "balance": "985000000000000000000" }, "562f16d79abfcec3943e34b20f05f97bdfcda605": { "balance": "4000000000000000000000" }, "dbc66965e426ff1ac87ad6eb78c1d95271158f9f": { "balance": "18200000000000000000" }, "7e87863ec43a481df04d017762edcb5caa629b5a": { "balance": "39400000000000000000" }, "587d6849b168f6c3332b7abae7eb6c42c37f48bf": { "balance": "880000000000000000000" }, "721158be5762b119cc9b2035e88ee4ee78f29b82": { "balance": "10000000000000000000000" }, "84b91e2e2902d05e2b591b41083bd7beb2d52c74": { "balance": "9848621000000000000000" }, "632cecb10cfcf38ec986b43b8770adece9200221": { "balance": "20000000000000000000" }, "c34e3ba1322ed0571183a24f94204ee49c186641": { "balance": "58200000000000000000" }, "ae78bb849139a6ba38ae92a09a69601cc4cb62d1": { "balance": "500000000000000000000" }, "5ce0b6862cce9162e87e0849e387cb5df4f9118c": { "balance": "1670000000000000000000" }, "f52c0a7877345fe0c233bb0f04fd6ab18b6f14ba": { "balance": "400440000000000000000000" }, "e016dc138e25815b90be3fe9eee8ffb2e105624f": { "balance": "500000000000000000000" }, "5789d01db12c816ac268e9af19dc0dd6d99f15df": { "balance": "200000000000000000000" }, "d8b77db9b81bbe90427b62f702b201ffc29ff618": { "balance": "930200000000000000000" }, "5dff811dad819ece3ba602c383fb5dc64c0a3a48": { "balance": "186000000000000000000" }, "af3087e62e04bf900d5a54dc3e946274da92423b": { "balance": "20000000000000000000" }, "8c1023fde1574db8bb54f1739670157ca47da652": { "balance": "6969382000000000000000" }, "bb3b010b18e6e2be1135871026b7ba15ea0fde24": { "balance": "10044000000000000000000" }, "cabdaf354f4720a466a764a528d60e3a482a393c": { "balance": "1000000000000000000000" }, "94bbc67d13f89ebca594be94bc5170920c30d9f3": { "balance": "80200000000000000000" }, "3275496fd4dd8931fd69fb0a0b04c4d1ff879ef5": { "balance": "446000000000000000000" }, "281250a29121270a4ee5d78d24feafe82c70ba3a": { "balance": "1000000000000000000000" }, "590ccb5911cf78f6f622f535c474375f4a12cfcf": { "balance": "20000000000000000000000" }, "542e8096bafb88162606002e8c8a3ed19814aeac": { "balance": "2000000000000000000000" }, "a65426cff378ed23253513b19f496de45fa7e18f": { "balance": "7200000000000000000000" }, "4aa693b122f314482a47b11cc77c68a497876162": { "balance": "1970000000000000000000" }, "d9b783d31d32adc50fa3eacaa15d92b568eaeb47": { "balance": "34010000000000000000000" }, "068e655766b944fb263619658740b850c94afa31": { "balance": "35200000000000000000" }, "9e23c5e4b782b00a5fadf1aead87dacf5b0367a1": { "balance": "20000000000000000000" }, "bf17f397f8f46f1bae45d187148c06eeb959fa4d": { "balance": "1001440000000000000000" }, "8578e10212ca14ff0732a8241e37467db85632a9": { "balance": "6000000000000000000000" }, "2cb5495a505336c2465410d1cae095b8e1ba5cdd": { "balance": "20000000000000000000000" }, "695b0f5242753701b264a67071a2dc880836b8db": { "balance": "16400000000000000000" }, "f2edde37f9a8c39ddea24d79f4015757d06bf786": { "balance": "100000000000000000000000" }, "480f31b989311e4124c6a7465f5a44094d36f9d0": { "balance": "1025000000000000000000" }, "cf157612764e0fd696c8cb5fba85df4c0ddc3cb0": { "balance": "30000000000000000000000" }, "27521deb3b6ef1416ea4c781a2e5d7b36ee81c61": { "balance": "2000000000000000000000" }, "6efd90b535e00bbd889fda7e9c3184f879a151db": { "balance": "10100000000000000000000" }, "b635a4bc71fb28fdd5d2c322983a56c284426e69": { "balance": "170000000000000000000" }, "a17c9e4323069518189d5207a0728dcb92306a3f": { "balance": "1000000000000000000000" }, "6af940f63ec9b8d876272aca96fef65cdacecdea": { "balance": "3000000000000000000000" }, "469358709332c82b887e20bcddd0220f8edba7d0": { "balance": "17300000000000000000000" }, "a257ad594bd88328a7d90fc0a907df95eecae316": { "balance": "520510000000000000000" }, "6f051666cb4f7bd2b1907221b829b555d7a3db74": { "balance": "1760000000000000000000" }, "46bfc5b207eb2013e2e60f775fecd71810c5990c": { "balance": "1550000000000000000000" }, "62b9081e7710345e38e02e16449ace1b85bcfc4e": { "balance": "910000000000000000000" }, "bc73f7b1ca3b773b34249ada2e2c8a9274cc17c2": { "balance": "2000000000000000000000" }, "1adaf4abfa867db17f99af6abebf707a3cf55df6": { "balance": "6000000000000000000000" }, "8d629c20608135491b5013f1002586a0383130e5": { "balance": "1370000000000000000000" }, "38e46de4453c38e941e7930f43304f94bb7b2be8": { "balance": "2005500000000000000000" }, "3485f621256433b98a4200dad857efe55937ec98": { "balance": "2000000000000000000000" }, "775c10c93e0db7205b2643458233c64fc33fd75b": { "balance": "2000000000000000000000" }, "7c4401ae98f12ef6de39ae24cf9fc51f80eba16b": { "balance": "200000000000000000000" }, "17b807afa3ddd647e723542e7b52fee39527f306": { "balance": "400010000000000000000" }, "0ab366e6e7d5abbce6b44a438d69a1cabb90d133": { "balance": "320000000000000000000" }, "194ffe78bbf5d20dd18a1f01da552e00b7b11db1": { "balance": "7000000000000000000000" }, "c45d47ab0c9aa98a5bd62d16223ea2471b121ca4": { "balance": "593640000000000000000" }, "2487c3c4be86a2723d917c06b458550170c3edba": { "balance": "1000000000000000000000" }, "ec4d08aa2e47496dca87225de33f2b40a8a5b36f": { "balance": "158000000000000000000" }, "aaa8defe11e3613f11067fb983625a08995a8dfc": { "balance": "200000000000000000000" }, "50bb67c8b8d8bd0f63c4760904f2d333f400aace": { "balance": "2000000000000000000000" }, "1227e10a4dbf9caca31b1780239f557615fc35c1": { "balance": "200000000000000000000" }, "44a8989e32308121f72466978db395d1f76c3a4b": { "balance": "7236900000000000000000" }, "59569a21d28fba4bda37753405a081f2063da150": { "balance": "4000000000000000000000" }, "c3756bcdcc7eec74ed896adfc335275930266e08": { "balance": "6000000000000000000000" }, "ce3a61f0461b00935e85fa1ead82c45e5a64d488": { "balance": "500000000000000000000" }, "012f396a2b5eb83559bac515e5210df2c8c362ba": { "balance": "200000000000000000000" }, "93bc7d9a4abd44c8bbb8fe8ba804c61ad8d6576c": { "balance": "3999922000000000000000" }, "e20bb9f3966419e14bbbaaaa6789e92496cfa479": { "balance": "3465116000000000000000" }, "9eef442d291a447d74c5d253c49ef324eac1d8f0": { "balance": "3420000000000000000000" }, "db6c2a73dac7424ab0d031b66761122566c01043": { "balance": "3000000000000000000000" }, "704d243c2978e46c2c86adbecd246e3b295ff633": { "balance": "2012000000000000000000" }, "d2ff672016f63b2f85398f4a6fedbb60a50d3cce": { "balance": "342500000000000000000" }, "d2051cb3cb6704f0548cc890ab0a19db3415b42a": { "balance": "334000000000000000000" }, "1111e5dbf45e6f906d62866f1708101788ddd571": { "balance": "1300200000000000000000" }, "6a686bf220b593deb9b7324615fb9144ded3f39d": { "balance": "1460000000000000000000" }, "911feea61fe0ed50c5b9e5a0d66071399d28bdc6": { "balance": "60000000000000000000" }, "3881defae1c07b3ce04c78abe26b0cdc8d73f010": { "balance": "200000000000000000000" }, "ea94f32808a2ef8a9bf0861d1d2404f7b7be258a": { "balance": "20000000000000000000" }, "2eef6b1417d7b10ecfc19b123a8a89e73e526c58": { "balance": "600000000000000000000" }, "dd8af9e7765223f4446f44d3d509819a3d3db411": { "balance": "10000000000000000000000" }, "2efc4c647dac6acac35577ad221758fef6616faa": { "balance": "8000000000000000000000" }, "1547b9bf7ad66274f3413827231ba405ee8c88c1": { "balance": "17300000000000000000000" }, "250a40cef3202397f240469548beb5626af4f23c": { "balance": "92500000000000000000" }, "c175be3194e669422d15fee81eb9f2c56c67d9c9": { "balance": "200000000000000000000" }, "c9e02608066828848aeb28c73672a12925181f4d": { "balance": "500038000000000000000" }, "8229ceb9f0d70839498d44e6abed93c5ca059f5d": { "balance": "123300000000000000000000" }, "39f198331e4b21c1b760a3155f4ab2fe00a74619": { "balance": "2000000000000000000000" }, "3ffcb870d4023d255d5167d8a507cefc366b68ba": { "balance": "649400000000000000000" }, "00dae27b350bae20c5652124af5d8b5cba001ec1": { "balance": "40000000000000000000" }, "fc5500825105cf712a318a5e9c3bfc69c89d0c12": { "balance": "4000000000000000000000" }, "1ed8bb3f06778b039e9961d81cb71a73e6787c8e": { "balance": "2000000000000000000000" }, "530ffac3bc3412e2ec0ea47b7981c770f5bb2f35": { "balance": "133700000000000000000" }, "5f344b01c7191a32d0762ac188f0ec2dd460911d": { "balance": "1000000000000000000000" }, "5cfa9877f719c79d9e494a08d1e41cf103fc87c9": { "balance": "200000000000000000000" }, "f6eaac7032d492ef17fd6095afc11d634f56b382": { "balance": "500038000000000000000" }, "962c0dec8a3d464bf39b1215eafd26480ae490cd": { "balance": "2001680000000000000000" }, "262a8bfd7d9dc5dd3ad78161b6bb560824373655": { "balance": "1169820000000000000000" }, "9b4824ff9fb2abda554dee4fb8cf549165570631": { "balance": "20000000000000000000" }, "bb3b9005f46fd2ca3b30162599928c77d9f6b601": { "balance": "8000014000000000000000" }, "f7dc251196fbcbb77c947d7c1946b0ff65021cea": { "balance": "1000000000000000000000" }, "af1148ef6c8e103d7530efc91679c9ac27000993": { "balance": "200000000000000000000" }, "0bb2650ea01aca755bc0c017b64b1ab5a66d82e3": { "balance": "1337000000000000000000" }, "0cda12bf72d461bbc479eb92e6491d057e6b5ad1": { "balance": "10000000000000000000000" }, "4e5b77f9066159e615933f2dda7477fa4e47d648": { "balance": "200000000000000000000" }, "391161b0e43c302066e8a68d2ce7e199ecdb1d57": { "balance": "4000000000000000000000" }, "c7e330cd0c890ac99fe771fcc7e7b009b7413d8a": { "balance": "4000000000000000000000" }, "d4b38a5fdb63e01714e9801db47bc990bd509183": { "balance": "5999000000000000000000" }, "bc0f98598f88056a26339620923b8f1eb074a9fd": { "balance": "200000000000000000000" }, "dbc59ed88973dead310884223af49763c05030f1": { "balance": "20000000000000000000" }, "0f85e42b1df321a4b3e835b50c00b06173968436": { "balance": "985000000000000000000" }, "d7788ef28658aa06cc53e1f3f0de58e5c371be78": { "balance": "6685000000000000000000" }, "ecd276af64c79d1bd9a92b86b5e88d9a95eb88f8": { "balance": "20000000000000000000" }, "81c9e1aee2d3365d53bcfdcd96c7c538b0fd7eec": { "balance": "1820000000000000000000" }, "5d39ef9ea6bdfff15d11fe91f561a6f9e31f5da5": { "balance": "2000000000000000000000" }, "99878f9d6e0a7ed9aec78297b73879a80195afe0": { "balance": "3980000000000000000000" }, "7294c918b1aefb4d25927ef9d799e71f93a28e85": { "balance": "197000000000000000000" }, "a33f70da7275ef057104dfa7db64f472e9f5d553": { "balance": "80220000000000000000" }, "255bdd6474cc8262f26a22c38f45940e1ceea69b": { "balance": "4000000000000000000000" }, "52f8b509fee1a874ab6f9d87367fbeaf15ac137f": { "balance": "1000000000000000000000" }, "e2728a3e8c2aaac983d05dc6877374a8f446eee9": { "balance": "197600000000000000000" }, "ed0206cb23315128f8caff26f6a30b985467d022": { "balance": "40000000000000000000000" }, "87cf36ad03c9eae9053abb5242de9117bb0f2a0b": { "balance": "500000000000000000000" }, "a929c8bd71db0c308dac06080a1747f21b1465aa": { "balance": "500000000000000000000" }, "9da6e075989c7419094cc9f6d2e49393bb199688": { "balance": "11100000000000000000000" }, "763eece0b08ac89e32bfa4bece769514d8cb5b85": { "balance": "4000000000000000000000" }, "5df3277ca85936c7a0d2c0795605ad25095e7159": { "balance": "2000000000000000000000" }, "7163758cbb6c4c525e0414a40a049dcccce919bb": { "balance": "200000000000000000000" }, "14cdddbc8b09e6675a9e9e05091cb92238c39e1e": { "balance": "5100000000000000000000" }, "b3b7f493b44a2c8d80ec78b1cdc75a652b73b06c": { "balance": "2000000000000000000000" }, "c69b855539ce1b04714728eec25a37f367951de7": { "balance": "2000000000000000000000" }, "052eab1f61b6d45517283f41d1441824878749d0": { "balance": "4000000000000000000000" }, "515651d6db4faf9ecd103a921bbbbe6ae970fdd4": { "balance": "20000000000000000000000" }, "c7aff91929797489555a2ff1d14d5c695a108355": { "balance": "1000000000000000000000" }, "d7ca7fdcfebe4588eff5421d1522b61328df7bf3": { "balance": "4001070000000000000000" }, "eefba12dfc996742db790464ca7d273be6e81b3e": { "balance": "1000000000000000000000" }, "ebaa216de9cc5a43031707d36fe6d5bedc05bdf0": { "balance": "1969606000000000000000" }, "559194304f14b1b93afe444f0624e053c23a0009": { "balance": "400000000000000000000" }, "4ecc19948dd9cd87b4c7201ab48e758f28e7cc76": { "balance": "500200000000000000000" }, "f224eb900b37b4490eee6a0b6420d85c947d8733": { "balance": "970000000000000000000" }, "97810bafc37e84306332aacb35e92ad911d23d24": { "balance": "1000000000000000000000" }, "bd67d2e2f82da8861341bc96a2c0791fddf39e40": { "balance": "200014000000000000000" }, "1b6495891240e64e594493c2662171db5e30ce13": { "balance": "172400000000000000000" }, "00bdd4013aa31c04616c2bc9785f2788f915679b": { "balance": "13400000000000000000" }, "c6ae287ddbe1149ba16ddcca4fe06aa2eaa988a9": { "balance": "400000000000000000000" }, "b7c9f12b038e73436d17e1c12ffe1aeccdb3f58c": { "balance": "540000000000000000000" }, "c1b500011cfba95d7cd636e95e6cbf6167464b25": { "balance": "200000000000000000000" }, "39e0db4d60568c800b8c5500026c2594f5768960": { "balance": "1000000000000000000000" }, "40e3c283f7e24de0410c121bee60a5607f3e29a6": { "balance": "1000000000000000000000" }, "2f7d3290851be5c6b4b43f7d4574329f61a792c3": { "balance": "100000000000000000000" }, "c33ece935a8f4ef938ea7e1bac87cb925d8490ca": { "balance": "33122000000000000000000" }, "57bddf078834009c89d88e6282759dc45335b470": { "balance": "2148000000000000000000" }, "50ad187ab21167c2b6e78be0153f44504a07945e": { "balance": "100076000000000000000" }, "5bd24aac3612b20c609eb46779bf95698407c57c": { "balance": "1970000000000000000000" }, "16526c9edf943efa4f6d0f0bae81e18b31c54079": { "balance": "985000000000000000000" }, "4c6a9dc2cab10abb2e7c137006f08fecb5b779e1": { "balance": "499000000000000000000" }, "02c9f7940a7b8b7a410bf83dc9c22333d4275dd3": { "balance": "5000000000000000000000" }, "b9fd3833e88e7cf1fa9879bdf55af4b99cd5ce3f": { "balance": "1000000000000000000000" }, "7e268f131ddf687cc325c412f78ba961205e9112": { "balance": "16000600000000000000000" }, "180478a655d78d0f3b0c4f202b61485bc4002fd5": { "balance": "2000000000000000000000" }, "ed4014538cee664a2fbcb6dc669f7ab16d0ba57c": { "balance": "200000000000000000000" }, "f63a579bc3eac2a9490410128dbcebe6d9de8243": { "balance": "1490000000000000000000" }, "5d822d9b3ef4b502627407da272f67814a6becd4": { "balance": "20000000000000000000" }, "eb52ab10553492329c1c54833ae610f398a65b9d": { "balance": "152000000000000000000" }, "63340a57716bfa63eb6cd133721202575bf796f0": { "balance": "209967000000000000000" }, "933bf33f8299702b3a902642c33e0bfaea5c1ca3": { "balance": "15200000000000000000" }, "25bc49ef288cd165e525c661a812cf84fbec8f33": { "balance": "338464000000000000000" }, "c8231ba5a411a13e222b29bfc1083f763158f226": { "balance": "1000090000000000000000" }, "6c15ec3520bf8ebbc820bd0ff19778375494cf9d": { "balance": "2005500000000000000000" }, "aaced8a9563b1bc311dbdffc1ae7f57519c4440c": { "balance": "2000000000000000000000" }, "d90f3009db437e4e11c780bec8896f738d65ef0d": { "balance": "4000000000000000000000" }, "5603241eb8f08f721e348c9d9ad92f48e390aa24": { "balance": "200000000000000000000" }, "53cec6c88092f756efe56f7db11228a2db45b122": { "balance": "4000000000000000000000" }, "194cebb4929882bf3b4bf9864c2b1b0f62c283f9": { "balance": "571300000000000000000" }, "4be8628a8154874e048d80c142181022b180bcc1": { "balance": "60000000000000000000" }, "5fd973af366aa5157c54659bcfb27cbfa5ac15d6": { "balance": "4000000000000000000000" }, "303139bc596403d5d3931f774c66c4ba467454db": { "balance": "1699830000000000000000" }, "87584a3f613bd4fac74c1e780b86d6caeb890cb2": { "balance": "1700000000000000000000" }, "77f4e3bdf056883cc87280dbe640a18a0d02a207": { "balance": "193806000000000000000" }, "4de3fe34a6fbf634c051997f47cc7f48791f5824": { "balance": "1999000000000000000000" }, "c45a1ca1036b95004187cdac44a36e33a94ab5c3": { "balance": "254800000000000000000" }, "65d33eb39cda6453b19e61c1fe4db93170ef9d34": { "balance": "13370000000000000000" }, "f65616be9c8b797e7415227c9138faa0891742d7": { "balance": "790000000000000000000" }, "e17812f66c5e65941e186c46922b6e7b2f0eeb46": { "balance": "1820000000000000000000" }, "d47f50df89a1cff96513bef1b2ae3a2971accf2c": { "balance": "840000000000000000000" }, "8ed1528b447ed4297902f639c514d0944a88f8c8": { "balance": "198800000000000000000" }, "a4fb14409a67b45688a8593e5cc2cf596ced6f11": { "balance": "1790000000000000000000" }, "855d9aef2c39c6230d09c99ef6494989abe68785": { "balance": "161000000000000000000" }, "778c43d11afe3b586ff374192d96a7f23d2b9b7f": { "balance": "2577139000000000000000" }, "e3ece1f632711d13bfffa1f8f6840871ee58fb27": { "balance": "4000000000000000000000" }, "beb3358c50cf9f75ffc76d443c2c7f55075a0589": { "balance": "2674000000000000000000" }, "f156dc0b2a981e5b55d3f2f03b8134e331dbadb7": { "balance": "100000000000000000000" }, "eb9cc9fe0869d2dab52cc7aae8fd57adb35f9feb": { "balance": "1966000000000000000000" }, "2467c6a5c696ede9a1e542bf1ad06bcc4b06aca0": { "balance": "18500000000000000000" }, "ec75b4a47513120ba5f86039814f1998e3817ac3": { "balance": "178756000000000000000" }, "9c3d0692ceeef80aa4965ceed262ffc7f069f2dc": { "balance": "200000000000000000000" }, "e05029aceb0778675bef1741ab2cd2931ef7c84b": { "balance": "5000057000000000000000" }, "41d3b731a326e76858baa5f4bd89b57b36932343": { "balance": "394000000000000000000" }, "c346cb1fbce2ab285d8e5401f42dd7234d37e86d": { "balance": "83500000000000000000" }, "45f4fc60f08eaca10598f0336329801e3c92cb46": { "balance": "200000000000000000000" }, "f04a6a379708b9428d722aa2b06b77e88935cf89": { "balance": "300000000000000000000" }, "232832cd5977e00a4c30d0163f2e24f088a6cb09": { "balance": "3000000000000000000000" }, "d2ac0d3a58605e1d0f0eb3de25b2cad129ed6058": { "balance": "4000000000000000000000" }, "a356551bb77d4f45a6d7e09f0a089e79cca249cb": { "balance": "340000000000000000000" }, "b50c9f5789ae44e2dce017c714caf00c830084c2": { "balance": "394000000000000000000" }, "21fd6c5d97f9c600b76821ddd4e776350fce2be0": { "balance": "1999946000000000000000" }, "f0d5c31ccb6cbe30c7c9ea19f268d159851f8c9c": { "balance": "16700000000000000000000" }, "ab7091932e4bc39dbb552380ca934fd7166d1e6e": { "balance": "3340000000000000000000" }, "acd8dd91f714764c45677c63d852e56eb9eece2e": { "balance": "2000000000000000000000" }, "57d032a43d164e71aa2ef3ffd8491b0a4ef1ea5b": { "balance": "2000000000000000000000" }, "5af46a25ac09cb73616b53b14fb42ff0a51cddb2": { "balance": "4000000000000000000000" }, "1ea6bf2f15ae9c1dbc64daa7f8ea4d0d81aad3eb": { "balance": "4200000000000000000000" }, "03337012ae1d7ff3ee7f697c403e7780188bf0ef": { "balance": "200000000000000000000" }, "32eb64be1b5dede408c6bdefbe6e405c16b7ed02": { "balance": "1970000000000000000000" }, "22e2488e2da26a49ae84c01bd54b21f2947891c6": { "balance": "1730000000000000000000" }, "be98a77fd41097b34f59d7589baad021659ff712": { "balance": "900000000000000000000" }, "dda4ed2a58a8dd20a73275347b580d71b95bf99a": { "balance": "399000000000000000000" }, "671110d96aaff11523cc546bf9940eedffb2faf7": { "balance": "4000000000000000000000" }, "5d71799c8df3bccb7ee446df50b8312bc4eb71c5": { "balance": "200000000000000000000" }, "ae179a460db66326743d24e67523a57b246daf7f": { "balance": "4722920000000000000000" }, "198bfcf1b07ae308fa2c02069ac9dafe7135fb47": { "balance": "20000000000000000000" }, "4662a1765ee921842ddc88898d1dc8627597bd7e": { "balance": "10000000000000000000000" }, "783eec8aa5dac77b2e6623ed5198a431abbaee07": { "balance": "440000000000000000000" }, "ed6643c0e8884b2d3211853785a08bf8f33ed29f": { "balance": "1337000000000000000000" }, "5cc7d3066d45d27621f78bb4b339473e442a860f": { "balance": "9999908000000000000000" }, "94ef8be45077c7d4c5652740de946a62624f713f": { "balance": "100085000000000000000" }, "2f853817afd3b8f3b86e9f60ee77b5d97773c0e3": { "balance": "1451450000000000000000" }, "3e0b8ed86ed669e12723af7572fbacfe829b1e16": { "balance": "1499800000000000000000" }, "fa68e0cb3edf51f0a6f211c9b2cb5e073c9bffe6": { "balance": "291200000000000000000" }, "2c234f505ca8dcc77d9b7e01d257c318cc19396d": { "balance": "100000000000000000000" }, "f3f24fc29e20403fc0e8f5ebbb553426f78270a2": { "balance": "100000000000000000000" }, "91546b79ecf69f936b5a561508b0d7e50cc5992f": { "balance": "267400000000000000000" }, "435443b81dfdb9bd8c6787bc2518e2d47e57c15f": { "balance": "5968500000000000000000" }, "3a06e3bb1edcfd0c44c3074de0bb606b049894a2": { "balance": "10000000000000000000000" }, "3a3108c1e680a33b336c21131334409d97e5adec": { "balance": "20000000000000000000" }, "2caf6bf4ec7d5a19c5e0897a5eeb011dcece4210": { "balance": "139740000000000000000" }, "f44f8551ace933720712c5c491cdb6f2f951736c": { "balance": "4000000000000000000000" }, "5bc1f95507b1018642e45cd9c0e22733b9b1a326": { "balance": "100000000000000000000" }, "94ca56de777fd453177f5e0694c478e66aff8a84": { "balance": "500000000000000000000" }, "afdd1b786162b8317e20f0e979f4b2ce486d765d": { "balance": "20000000000000000000" }, "3a805fa0f7387f73055b7858ca8519edd93d634f": { "balance": "1850000000000000000000" }, "8b36224c7356e751f0c066c35e3b44860364bfc2": { "balance": "998987000000000000000" }, "cfecbea07c27002f65fe534bb8842d0925c78402": { "balance": "4000000000000000000000" }, "482982ac1f1c6d1721feecd9b9c96cd949805055": { "balance": "10000000000000000000000" }, "af880fc7567d5595cacce15c3fc14c8742c26c9e": { "balance": "133700000000000000000" }, "acc1c78786ab4d2b3b277135b5ba123e0400486b": { "balance": "78800000000000000000" }, "41f27e744bd29de2b0598f02a0bb9f98e681eaa4": { "balance": "7760000000000000000000" }, "09a025316f967fa8b9a1d60700063f5a68001caa": { "balance": "38200000000000000000" }, "391f20176d12360d724d51470a90703675594a4d": { "balance": "1600000000000000000000" }, "fe4d8403216fd571572bf1bdb01d00578978d688": { "balance": "9850000000000000000000" }, "900f0b8e35b668f81ef252b13855aa5007d012e7": { "balance": "425000000000000000000" }, "c35b95a2a3737cb8f0f596b34524872bd30da234": { "balance": "7540000000000000000000" }, "412a68f6c645559cc977fc4964047a201d1bb0e2": { "balance": "50000000000000000000000" }, "d3dad1b6d08d4581ccae65a8732db6ac69f0c69e": { "balance": "6000000000000000000000" }, "35855ec641ab9e081ed0c2a6dcd81354d0244a87": { "balance": "1201897000000000000000" }, "88015d7203c5e0224aeda286ed12f1a51b789333": { "balance": "4999711000000000000000" }, "251c12722c6879227992a304eb3576cd18434ea5": { "balance": "2000000000000000000000" }, "1f6f0030349752061c96072bc3d6eb3549208d6b": { "balance": "23891000000000000000" }, "86153063a1ae7f02f1a88136d4d69c7c5e3e4327": { "balance": "1000000000000000000000" }, "78355df0a230f83d032c703154414de3eedab557": { "balance": "2000000000000000000000" }, "c5b56cd234267c28e89c6f6b2266b086a12f970c": { "balance": "4000000000000000000000" }, "3e3cd3bec06591d6346f254b621eb41c89008d31": { "balance": "993800000000000000000" }, "378ea1dc8edc19bae82638029ea8752ce98bcfcd": { "balance": "2000000000000000000000" }, "67632046dcb25a54936928a96f423f3320cbed92": { "balance": "2000000000000000000000" }, "ddbee6f094eae63420b003fb4757142aea6cd0fd": { "balance": "2000000000000000000000" }, "b555d00f9190cc3677aef314acd73fdc39399259": { "balance": "2000000000000000000000" }, "e230fe1bff03186d0219f15d4c481b7d59be286a": { "balance": "36710000000000000000" }, "3e4e9265223c9738324cf20bd06006d0073edb8c": { "balance": "133700000000000000000" }, "7450ff7f99eaa9116275deac68e428df5bbcd8b9": { "balance": "2000000000000000000000" }, "021f69043de88c4917ca10f1842897eec0589c7c": { "balance": "1978760000000000000000" }, "351787843505f8e4eff46566cce6a59f4d1c5fe7": { "balance": "9250000000000000000000" }, "ebd37b256563e30c6f9289a8e2702f0852880833": { "balance": "1999944000000000000000" }, "ed41e1a28f5caa843880ef4e8b08bd6c33141edf": { "balance": "790174000000000000000" }, "8d238e036596987643d73173c37b0ad06055b96c": { "balance": "2089724000000000000000" }, "478e524ef2a381d70c82588a93ca7a5fa9d51cbf": { "balance": "254908000000000000000000" }, "4419ac618d5dea7cdc6077206fb07dbdd71c1702": { "balance": "4000000000000000000000" }, "ca25ff34934c1942e22a4e7bd56f14021a1af088": { "balance": "197000000000000000000" }, "5552f4b3ed3e1da79a2f78bb13e8ae5a68a9df3b": { "balance": "1000000000000000000000" }, "4354221e62dc09e6406436163a185ef06d114a81": { "balance": "2000000000000000000000" }, "ca0432cb157b5179f02ebba5c9d1b54fec4d88ca": { "balance": "1000000000000000000000" }, "8a780ab87a9145fe10ed60fa476a740af4cab1d2": { "balance": "334000000000000000000" }, "4ff676e27f681a982d8fd9d20e648b3dce05e945": { "balance": "2800000000000000000000" }, "6c63fc85029a2654d79b2bea4de349e4524577c5": { "balance": "660000000000000000000" }, "1ac089c3bc4d82f06a20051a9d732dc0e734cb61": { "balance": "700300000000000000000" }, "4bf4479799ef82eea20943374f56a1bf54001e5e": { "balance": "3940000000000000000000" }, "08411652c871713609af0062a8a1281bf1bbcfd9": { "balance": "1400000000000000000000" }, "e1bfaa5a45c504428923c4a61192a55b1400b45d": { "balance": "2674000000000000000000" }, "5e1fbd4e58e2312b3c78d7aaaafa10bf9c3189e3": { "balance": "40000000000000000000000" }, "bb27c6a7f91075475ab229619040f804c8ec7a6a": { "balance": "10000000000000000000000" }, "5d8d31faa864e22159cd6f5175ccecc53fa54d72": { "balance": "26980000000000000000000" }, "2dd8eeef87194abc2ce7585da1e35b7cea780cb7": { "balance": "999999000000000000000" }, "0e1801e70b6262861b1134ccbc391f568afc92f7": { "balance": "4000000000000000000000" }, "61042b80fd6095d1b87be2f00f109fabafd157a6": { "balance": "100000000000000000000" }, "fb5518714cefc36d04865de5915ef0ff47dfe743": { "balance": "2000000000000000000000" }, "b5add1e7809f7d03069bfe883b0a932210be8712": { "balance": "1000000000000000000000" }, "c2e2d498f70dcd0859e50b023a710a6d4b2133bd": { "balance": "1037130000000000000000" }, "4ad047fae67ef162fe68fedbc27d3b65caf10c36": { "balance": "1970000000000000000000" }, "69cb3e2153998d86e5ee20c1fcd1a6baeeb2863f": { "balance": "4000000000000000000000" }, "683633010a88686bea5a98ea53e87997cbf73e69": { "balance": "99960000000000000000" }, "6cb11ecb32d3ce829601310636f5a10cf7cf9b5f": { "balance": "20068370000000000000000" }, "a613456996408af1c2e93e177788ab55895e2b32": { "balance": "6366000000000000000000" }, "8308ed0af7f8a3c1751fafc877b5a42af7d35882": { "balance": "1000000000000000000000" }, "e5edf8123f2403ce1a0299becf7aac744d075f23": { "balance": "200200000000000000000" }, "05665155cc49cbf6aabdd5ae92cbfaad82b8c0c1": { "balance": "400000000000000000000" }, "00b277b099a8e866ca0ec65bcb87284fd142a582": { "balance": "1970000000000000000000" }, "4b9e068fc4680976e61504912985fd5ce94bab0d": { "balance": "668500000000000000000" }, "12134e7f6b017bf48e855a399ca58e2e892fa5c8": { "balance": "1000000000000000000000" }, "dffcea5421ec15900c6ecfc777184e140e209e24": { "balance": "19980000000000000000" }, "2132c0516a2e17174ac547c43b7b0020d1eb4c59": { "balance": "985000000000000000000" }, "d39a5da460392b940b3c69bc03757bf3f2e82489": { "balance": "7019250000000000000000" }, "66c8331efe7198e98b2d32b938688e3241d0e24f": { "balance": "9620000000000000000000" }, "bdca2a0ff34588af625fa8e28fc3015ab5a3aa00": { "balance": "2339800000000000000000" }, "7dfc342dffcf45dfee74f84c0995397bd1a63172": { "balance": "250000000000000000000" }, "a202547242806f6e70e74058d6e5292defc8c8d4": { "balance": "2002000000000000000000" }, "3bbc13d04accc0707aebdcaef087d0b87e0b5ee3": { "balance": "3520000000000000000000" }, "be5cba8d37427986e8ca2600e858bb03c359520f": { "balance": "2955000000000000000000" }, "4174fa1bc12a3b7183cbabb77a0b59557ba5f1db": { "balance": "2000000000000000000000" }, "9eb3a7cb5e6726427a3a361cfa8d6164dbd0ba16": { "balance": "804000000000000000000" }, "25e661c939863acc044e6f17b5698cce379ec3cc": { "balance": "1370000000000000000000" }, "24bd5904059091d2f9e12d6a26a010ca22ab14e8": { "balance": "1880000000000000000000" }, "c96626728aaa4c4fb3d31c26df3af310081710d1": { "balance": "3340000000000000000000" }, "0fb5d2c673bfb1ddca141b9894fd6d3f05da6720": { "balance": "100000000000000000000" }, "2de31afd189a13a76ff6fe73ead9f74bb5c4a629": { "balance": "6000000000000000000000" }, "bd09126c891c4a83068059fe0e15796c4661a9f4": { "balance": "800000000000000000000" }, "496f5843f6d24cd98d255e4c23d1e1f023227545": { "balance": "1754143000000000000000" }, "540cf23dd95c4d558a279d778d2b3735b3164191": { "balance": "10000000000000000000000" }, "9b5ec18e8313887df461d2902e81e67a8f113bb1": { "balance": "100000000000000000000" }, "b7a7f77c348f92a9f1100c6bd829a8ac6d7fcf91": { "balance": "1820000000000000000000" }, "2590126870e0bde8a663ab040a72a5573d8d41c2": { "balance": "5000000000000000000000" }, "090fa9367bda57d0d3253a0a8ff76ce0b8e19a73": { "balance": "1000000000000000000000" }, "2a5ba9e34cd58da54c9a2712663a3be274c8e47b": { "balance": "197000000000000000000" }, "3e8641d43c42003f0a33c929f711079deb2b9e46": { "balance": "500000000000000000000" }, "f4d97664cc4eec9edbe7fa09f4750a663b507d79": { "balance": "4000000000000000000000" }, "b1540e94cff3465cc3d187e7c8e3bdaf984659e2": { "balance": "2989950000000000000000" }, "f96883582459908c827627e86f28e646f9c7fc7a": { "balance": "8350000000000000000000" }, "d4feed99e8917c5c5458635f3603ecb7e817a7d0": { "balance": "300031000000000000000" }, "14b1603ec62b20022033eec4d6d6655ac24a015a": { "balance": "50000000000000000000" }, "af8e1dcb314c950d3687434d309858e1a8739cd4": { "balance": "267400000000000000000" }, "4b9206ba6b549a1a7f969e1d5dba867539d1fa67": { "balance": "7880000000000000000000" }, "471010da492f4018833b088d9872901e06129174": { "balance": "500000000000000000000" }, "d243184c801e5d79d2063f3578dbae81e7b3a9cb": { "balance": "1989700000000000000000" }, "3eada8c92f56067e1bb73ce378da56dc2cdfd365": { "balance": "2210000000000000000000" }, "33ea6b7855e05b07ab80dab1e14de9b649e99b6c": { "balance": "532000000000000000000" }, "700711e311bb947355f755b579250ca7fd765a3e": { "balance": "1790000000000000000000" }, "87fb26c31e48644d693134205cae43b21f18614b": { "balance": "1370000000000000000000" }, "001d14804b399c6ef80e64576f657660804fec0b": { "balance": "4200000000000000000000" }, "f9642086b1fbae61a6804dbe5fb15ec2d2b537f4": { "balance": "2000000000000000000000" }, "6919dd5e5dfb1afa404703b9faea8cee35d00d70": { "balance": "5910000000000000000000" }, "9ac4da51d27822d1e208c96ea64a1e5b55299723": { "balance": "100040000000000000000" }, "1bd8ebaa7674bb18e19198db244f570313075f43": { "balance": "150000000000000000000" }, "e64ef012658d54f8e8609c4e9023c09fe865c83b": { "balance": "28000000000000000000" }, "43b079baf0727999e66bf743d5bcbf776c3b0922": { "balance": "2000000000000000000000" }, "06ac26ad92cb859bd5905ddce4266aa0ec50a9c5": { "balance": "775000000000000000000" }, "99c1d9f40c6ab7f8a92fce2fdce47a54a586c53f": { "balance": "985000000000000000000" }, "4ae93082e45187c26160e66792f57fad3551c73a": { "balance": "21658000000000000000000" }, "7da7613445a21299aa74f0ad71431ec43fbb1be9": { "balance": "68000000000000000000" }, "4a9a26fd0a8ba10f977da4f77c31908dab4a8016": { "balance": "1790000000000000000000" }, "972c2f96aa00cf8a2f205abcf8937c0c75f5d8d9": { "balance": "200000000000000000000" }, "b5046cb3dc1dedbd364514a2848e44c1de4ed147": { "balance": "16445100000000000000000" }, "48c2ee91a50756d8ce9abeeb7589d22c6fee5dfb": { "balance": "3220000000000000000000" }, "46c1aa2244b9c8a957ca8fac431b0595a3b86824": { "balance": "4000000000000000000000" }, "21fd0bade5f4ef7474d058b7f3d854cb1300524e": { "balance": "20000000000000000000" }, "1864a3c7b48155448c54c88c708f166709736d31": { "balance": "133700000000000000000" }, "5dd53ae897526b167d39f1744ef7c3da5b37a293": { "balance": "8000000000000000000000" }, "ece111670b563ccdbebca52384290ecd68fe5c92": { "balance": "20000000000000000000" }, "74d671d99cbea1ab57906375b63ff42b50451d17": { "balance": "1000000000000000000000" }, "5717cc9301511d4a81b9f583148beed3d3cc8309": { "balance": "2600000000000000000000" }, "8f92844f282a92999ee5b4a8d773d06b694dbd9f": { "balance": "1940000000000000000000" }, "b5a606f4ddcbb9471ec67f658caf2b00ee73025e": { "balance": "4325000000000000000000" }, "bdb60b823a1173d45a0792245fb496f1fd3301cf": { "balance": "2000000000000000000000" }, "1d2615f8b6ca5012b663bdd094b0c5137c778ddf": { "balance": "10000000000000000000000" }, "82ff716fdf033ec7e942c909d9831867b8b6e2ef": { "balance": "1790000000000000000000" }, "44c14765127cde11fab46c5d2cf4d4b2890023fd": { "balance": "2000000000000000000000" }, "c72cb301258e91bc08998a805dd192f25c2f9a35": { "balance": "591000000000000000000" }, "ad732c976593eec4783b4e2ecd793979780bfedb": { "balance": "2000000000000000000000" }, "d8f62036f03b7635b858f1103f8a1d9019a892b6": { "balance": "50000000000000000000" }, "0a06fad7dcd7a492cbc053eeabde6934b39d8637": { "balance": "20000000000000000000" }, "67f2bb78b8d3e11f7c458a10b5c8e0a1d374467d": { "balance": "1790000000000000000000" }, "4b5cdb1e428c91dd7cb54a6aed4571da054bfe52": { "balance": "88000000000000000000" }, "b3557d39b5411b84445f5f54f38f62d2714d0087": { "balance": "600000000000000000000" }, "0b0e055b28cbd03dc5ff44aa64f3dce04f5e63fb": { "balance": "2000000000000000000000" }, "9b2be7f56754f505e3441a10f7f0e20fd3ddf849": { "balance": "340000000000000000000" }, "0b93fca4a4f09cac20db60e065edcccc11e0a5b6": { "balance": "200000000000000000000" }, "3bc85d6c735b9cda4bba5f48b24b13e70630307b": { "balance": "1970000000000000000000" }, "52102354a6aca95d8a2e86d5debda6de69346076": { "balance": "2000000000000000000000" }, "cda4530f4b9bc50905b79d17c28fc46f95349bdf": { "balance": "942000000000000000000" }, "ff545bbb66fbd00eb5e6373ff4e326f5feb5fe12": { "balance": "20000000000000000000" }, "4030a925706b2c101c8c5cb9bd05fbb4f6759b18": { "balance": "4000000000000000000000" }, "f11e01c7a9d12499005f4dae7716095a34176277": { "balance": "400000000000000000000" }, "a4826b6c3882fad0ed5c8fbb25cc40cc4f33759f": { "balance": "2068000000000000000000" }, "28510e6eff1fc829b6576f4328bc3938ec7a6580": { "balance": "10000000000000000000000" }, "9ce5363b13e8238aa4dd15acd0b2e8afe0873247": { "balance": "200000000000000000000" }, "d97bc84abd47c05bbf457b2ef659d61ca5e5e48f": { "balance": "122000000000000000000" }, "4a719061f5285495b37b9d7ef8a51b07d6e6acac": { "balance": "199800000000000000000" }, "8b714522fa2839620470edcf0c4401b713663df1": { "balance": "200000000000000000000" }, "b6decf82969819ba02de29b9b593f21b64eeda0f": { "balance": "740000000000000000000" }, "c87d3ae3d88704d9ab0009dcc1a0067131f8ba3c": { "balance": "1969606000000000000000" }, "dccb370ed68aa922283043ef7cad1b9d403fc34a": { "balance": "4000000000000000000000" }, "2d532df4c63911d1ce91f6d1fcbff7960f78a885": { "balance": "1669833000000000000000" }, "1fcfd1d57f872290560cb62d600e1defbefccc1c": { "balance": "1490000000000000000000" }, "d9e27eb07dfc71a706060c7f079238ca93e88539": { "balance": "1000000000000000000000" }, "da7732f02f2e272eaf28df972ecc0ddeed9cf498": { "balance": "205274000000000000000" }, "bf09d77048e270b662330e9486b38b43cd781495": { "balance": "436000000000000000000000" }, "619f171445d42b02e2e07004ad8afe694fa53d6a": { "balance": "20000000000000000000" }, "2bdd03bebbee273b6ca1059b34999a5bbd61bb79": { "balance": "20000000000000000000" }, "8da1d359ba6cb4bcc57d7a437720d55db2f01c72": { "balance": "80000000000000000000" }, "be935793f45b70d8045d2654d8dd3ad24b5b6137": { "balance": "880000000000000000000" }, "ee71793e3acf12a7274f563961f537529d89c7de": { "balance": "2000000000000000000000" }, "86f05d19063e9369c6004eb3f123943a7cff4eab": { "balance": "1999944000000000000000" }, "87b10f9c280098179a2b76e9ce90be61fc844d0d": { "balance": "1337000000000000000000" }, "243c84d12420570cc4ef3baba1c959c283249520": { "balance": "2345000000000000000000" }, "6bc85acd5928722ef5095331ee88f484b8cf8357": { "balance": "180000000000000000000" }, "2561a138dcf83bd813e0e7f108642be3de3d6f05": { "balance": "999940000000000000000" }, "7d0350e40b338dda736661872be33f1f9752d755": { "balance": "49933000000000000000" }, "e5dc9349cb52e161196122cf87a38936e2c57f34": { "balance": "2000000000000000000000" }, "543a8c0efb8bcd15c543e2a6a4f807597631adef": { "balance": "5893800000000000000000" }, "0413d0cf78c001898a378b918cd6e498ea773c4d": { "balance": "280000000000000000000" }, "3708e59de6b4055088782902e0579c7201a8bf50": { "balance": "200000000000000000000000" }, "699fc6d68a4775573c1dcdaec830fefd50397c4e": { "balance": "60000000000000000000" }, "379a7f755a81a17edb7daaa28afc665dfa6be63a": { "balance": "25000000000000000000" }, "260a230e4465077e0b14ee4442a482d5b0c914bf": { "balance": "1677935000000000000000" }, "3daa01ceb70eaf9591fa521ba4a27ea9fb8ede4a": { "balance": "1667400000000000000000" }, "7f3a1e45f67e92c880e573b43379d71ee089db54": { "balance": "100000000000000000000000" }, "38643babea6011316cc797d9b093c897a17bdae7": { "balance": "334400000000000000000" }, "84675e9177726d45eaa46b3992a340ba7f710c95": { "balance": "1000000000000000000000" }, "0f83461ba224bb1e8fdd9dae535172b735acb4e0": { "balance": "200000000000000000000" }, "31aa3b1ebe8c4dbcb6a708b1d74831e60e497660": { "balance": "400000000000000000000" }, "a32cf7dde20c3dd5679ff5e325845c70c5962662": { "balance": "20000000000000000000" }, "c007f0bdb6e7009202b7af3ea90902697c721413": { "balance": "2999966000000000000000" }, "05c64004a9a826e94e5e4ee267fa2a7632dd4e6f": { "balance": "16191931000000000000000" }, "f622e584a6623eaaf99f2be49e5380c5cbcf5cd8": { "balance": "200000000000000000000" }, "9dc10fa38f9fb06810e11f60173ec3d2fd6a751e": { "balance": "1970000000000000000000" }, "423c3107f4bace414e499c64390a51f74615ca5e": { "balance": "2000000000000000000000" }, "92438e5203b6346ff886d7c36288aacccc78ceca": { "balance": "1000000000000000000000" }, "bef07d97c3481f9d6aee1c98f9d91a180a32442b": { "balance": "100000000000000000000000" }, "55aa5d313ebb084da0e7801091e29e92c5dec3aa": { "balance": "2000000000000000000000" }, "89c433d601fad714da6369308fd26c1dc9942bbf": { "balance": "2000000000000000000000" }, "25106ab6755df86d6b63a187703b0cfea0e594a0": { "balance": "27400000000000000000" }, "494256e99b0f9cd6e5ebca3899863252900165c8": { "balance": "14000000000000000000000" }, "5f4ace4c1cc13391e01f00b198e1f20b5f91cbf5": { "balance": "5000196000000000000000" }, "135cecd955e5798370769230159303d9b1839f66": { "balance": "5000000000000000000000" }, "ced81ec3533ff1bfebf3e3843ee740ad11758d3e": { "balance": "1970000000000000000000" }, "688eb3853bbcc50ecfee0fa87f0ab693cabdef02": { "balance": "31600000000000000000000" }, "2159240813a73095a7ebf7c3b3743e8028ae5f09": { "balance": "2000000000000000000000" }, "99d1579cd42682b7644e1d4f7128441eeffe339d": { "balance": "20000000000000000000000" }, "8a243a0a9fea49b839547745ff2d11af3f4b0522": { "balance": "985000000000000000000" }, "c1a41a5a27199226e4c7eb198b031b59196f9842": { "balance": "191000000000000000000" }, "7514adbdc63f483f304d8e94b67ff3309f180b82": { "balance": "622911000000000000000" }, "74aeec915de01cc69b2cb5a6356feea14658c6c5": { "balance": "232500000000000000000" }, "76f9ad3d9bbd04ae055c1477c0c35e7592cb2a20": { "balance": "40200000000000000000000" }, "a8a7b68adab4e3eadff19ffa58e34a3fcec0d96a": { "balance": "6000000000000000000000" }, "60de22a1507432a47b01cc68c52a0bf8a2e0d098": { "balance": "19100000000000000000" }, "ceb33d78e7547a9da2e87d51aec5f3441c87923a": { "balance": "20000000000000000000" }, "432809a2390f07c665921ff37d547d12f1c9966a": { "balance": "30000000000000000000000" }, "d5e656a1b916f9bf45afb07dd8afaf73b4c56f41": { "balance": "97000000000000000000" }, "e3410bb7557cf91d79fa69d0dfea0aa075402651": { "balance": "2000000000000000000000" }, "dee942d5caf5fac11421d86b010b458e5c392990": { "balance": "4000000000000000000000" }, "a98f109835f5eacd0543647c34a6b269e3802fac": { "balance": "400000000000000000000" }, "932b9c04d40d2ac83083d94298169dae81ab2ed0": { "balance": "2000000000000000000000" }, "ba10f2764290f875434372f79dbf713801caac01": { "balance": "955000000000000000000" }, "a2c7eaffdc2c9d937345206c909a52dfb14c478f": { "balance": "143000000000000000000" }, "6c67e0d7b62e2a08506945a5dfe38263339f1f22": { "balance": "1970000000000000000000" }, "60c3714fdddb634659e4a2b1ea42c4728cc7b8ba": { "balance": "13370000000000000000" }, "73b4d499de3f38bf35aaf769a6e318bc6d123692": { "balance": "2000000000000000000000" }, "3b22dea3c25f1b59c7bd27bb91d3a3eaecef3984": { "balance": "100000000000000000000" }, "1e3badb1b6e1380e27039c576ae6222e963a5b53": { "balance": "20000000000000000000000" }, "abd4d6c1666358c0406fdf3af248f78ece830104": { "balance": "2112000000000000000000" }, "0c925ad5eb352c8ef76d0c222d115b0791b962a1": { "balance": "3180000000000000000000" }, "be9186c34a52514abb9107860f674f97b821bd5b": { "balance": "509600000000000000000" }, "b7f67314cb832e32e63b15a40ce0d7ffbdb26985": { "balance": "1060866000000000000000" }, "3f30d3bc9f602232bc724288ca46cd0b0788f715": { "balance": "4000000000000000000000" }, "970abd53a54fca4a6429207c182d4d57bb39d4a0": { "balance": "2000000000000000000000" }, "36d85dc3683156e63bf880a9fab7788cf8143a27": { "balance": "20000000000000000000000" }, "2836123046b284e5ef102bfd22b1765e508116ad": { "balance": "411880000000000000000" }, "de06d5ea777a4eb1475e605dbcbf43444e8037ea": { "balance": "50000000000000000000000" }, "9af11399511c213181bfda3a8b264c05fc81b3ce": { "balance": "14000000000000000000000" }, "e2191215983f33fd33e22cd4a2490054da53fddc": { "balance": "15800000000000000000" }, "2eebf59432b52892f9380bd140aa99dcf8ad0c0f": { "balance": "152000000000000000000" }, "dc087f9390fb9e976ac23ab689544a0942ec2021": { "balance": "1820000000000000000000" }, "fd4b989558ae11be0c3b36e2d6f2a54a9343ca2e": { "balance": "2000000000000000000000" }, "770c2fb2c4a81753ac0182ea460ec09c90a516f8": { "balance": "20000000000000000000" }, "b28dbfc6499894f73a71faa00abe0f4bc9d19f2a": { "balance": "100000000000000000000" }, "b0cef8e8fb8984a6019f01c679f272bbe68f5c77": { "balance": "152000000000000000000" }, "f400f93d5f5c7e3fc303129ac8fb0c2f786407fa": { "balance": "2000000000000000000000" }, "f2133431d1d9a37ba2f0762bc40c5acc8aa6978e": { "balance": "2000000000000000000000" }, "9003d270891ba2df643da8341583193545e3e000": { "balance": "4000000000000000000000" }, "8938d1b4daee55a54d738cf17e4477f6794e46f7": { "balance": "18200000000000000000" }, "98e6f547db88e75f1f9c8ac2c5cf1627ba580b3e": { "balance": "1000000000000000000000" }, "009fdbf44e1f4a6362b769c39a475f95a96c2bc7": { "balance": "564000000000000000000" }, "d0f9597811b0b992bb7d3757aa25b4c2561d32e2": { "balance": "500000000000000000000" }, "dcd10c55bb854f754434f1219c2c9a98ace79f03": { "balance": "4000086000000000000000" }, "67048f3a12a4dd1f626c64264cb1d7971de2ca38": { "balance": "180000000000000000000" }, "d33cf82bf14c592640a08608914c237079d5be34": { "balance": "2000000000000000000000" }, "f5b068989df29c253577d0405ade6e0e7528f89e": { "balance": "1610000000000000000000" }, "a9a8eca11a23d64689a2aa3e417dbb3d336bb59a": { "balance": "262025000000000000000" }, "99413704b1a32e70f3bc0d69dd881c38566b54cb": { "balance": "27382708000000000000000" }, "2a085e25b64862f5e68d768e2b0f7a8529858eee": { "balance": "1983618000000000000000" }, "833d3fae542ad5f8b50ce19bde2bec579180c88c": { "balance": "346000000000000000000" }, "c3483d6e88ac1f4ae73cc4408d6c03abe0e49dca": { "balance": "17000000000000000000000" }, "fde395bc0b6d5cbb4c1d8fea3e0b4bff635e9db7": { "balance": "2000000000000000000000" }, "eddacd94ec89a2ef968fcf977a08f1fae2757869": { "balance": "8000000000000000000000" }, "dc29119745d2337320da51e19100c948d980b915": { "balance": "160000000000000000000" }, "640bf87415e0cf407301e5599a68366da09bbac8": { "balance": "493207000000000000000" }, "afcc7dbb8356d842d43ae7e23c8422b022a30803": { "balance": "30400000000000000000000" }, "9120e71173e1ba19ba8f9f4fdbdcaa34e1d6bb78": { "balance": "2000000000000000000000" }, "9092918707c621fdbd1d90fb80eb787fd26f7350": { "balance": "2460000000000000000000" }, "263e57dacbe0149f82fe65a2664898866ff5b463": { "balance": "38000000000000000000000" }, "315db7439fa1d5b423afa7dd7198c1cf74c918bc": { "balance": "600000000000000000000" }, "09b4668696f86a080f8bebb91db8e6f87015915a": { "balance": "656010000000000000000" }, "5c31996dcac015f9be985b611f468730ef244d90": { "balance": "200000000000000000000" }, "b1179589e19db9d41557bbec1cb24ccc2dec1c7f": { "balance": "100000000000000000000000" }, "3b1937d5e793b89b63fb8eb5f1b1c9ca6ba0fa8e": { "balance": "2000000000000000000000" }, "c9127b7f6629ee13fc3f60bc2f4467a20745a762": { "balance": "16465639000000000000000" }, "7306de0e288b56cfdf987ef0d3cc29660793f6dd": { "balance": "508060000000000000000" }, "2aa192777ca5b978b6b2c2ff800ac1860f753f47": { "balance": "335000000000000000000" }, "55da9dcdca61cbfe1f133c7bcefc867b9c8122f9": { "balance": "880000000000000000000" }, "cdd9efac4d6d60bd71d95585dce5d59705c13564": { "balance": "100000000000000000000" }, "ad8e48a377695de014363a523a28b1a40c78f208": { "balance": "1000000000000000000000" }, "252b6555afdc80f2d96d972d17db84ea5ad521ac": { "balance": "7880000000000000000000" }, "60ab71cd26ea6d6e59a7a0f627ee079c885ebbf6": { "balance": "26740000000000000000" }, "f40b134fea22c6b29c8457f49f000f9cda789adb": { "balance": "600000000000000000000" }, "85a2f6ea94d05e8c1d9ae2f4910338a358e98ded": { "balance": "2000000000000000000000" }, "ae13a08511110f32e53be4127845c843a1a57c7b": { "balance": "500000000000000000000" }, "40db1ba585ce34531edec5494849391381e6ccd3": { "balance": "1790000000000000000000" }, "0c5589a7a89b9ad15b02751930415948a875fbef": { "balance": "126000000000000000000" }, "89054430dcdc28ac15fa635ef87c105e602bf70c": { "balance": "108000000000000000000" }, "6c882c27732cef5c7c13a686f0a2ea77555ac289": { "balance": "100000000000000000000000" }, "de374299c1d07d79537385190f442ef9ca24061f": { "balance": "133700000000000000000" }, "b146a0b925553cf06fcaf54a1b4dfea621290757": { "balance": "2000200000000000000000" }, "09ae49e37f121df5dc158cfde806f173a06b0c7f": { "balance": "3988000000000000000000" }, "b758896f1baa864f17ebed16d953886fee68aae6": { "balance": "1000000000000000000000" }, "30730466b8eb6dc90d5496aa76a3472d7dbe0bbe": { "balance": "1999800000000000000000" }, "fc02734033e57f70517e0afc7ee62461f06fad8e": { "balance": "394000000000000000000" }, "a9b2d2e0494eab18e07d37bbb856d80e80f84cd3": { "balance": "10000000000000000000000" }, "95278b08dee7c0f2c8c0f722f9fcbbb9a5241fda": { "balance": "2408672000000000000000" }, "dab6bcdb83cf24a0ae1cb21b3b5b83c2f3824927": { "balance": "50000000000000000000000" }, "94439ca9cc169a79d4a09cae5e67764a6f871a21": { "balance": "240000000000000000000" }, "e06c29a81517e0d487b67fb0b6aabc4f57368388": { "balance": "401100000000000000000" }, "458e3cc99e947844a18e6a42918fef7e7f5f5eb3": { "balance": "36400000000000000000000" }, "0a9804137803ba6868d93a55f9985fcd540451e4": { "balance": "13370000000000000000" }, "40630024bd2c58d248edd8465617b2bf1647da0e": { "balance": "1000000000000000000000" }, "15224ad1c0face46f9f556e4774a3025ad06bd52": { "balance": "13370000000000000000" }, "2e2810dee44ae4dff3d86342ab126657d653c336": { "balance": "200000000000000000000" }, "48a30de1c919d3fd3180e97d5f2b2a9dbd964d2d": { "balance": "44000000000000000000" }, "46a30b8a808931217445c3f5a93e882c0345b426": { "balance": "250019000000000000000" }, "455396a4bbd9bae8af9fb7c4d64d471db9c24505": { "balance": "161000000000000000000" }, "edfda2d5db98f9380714664d54b4ee971a1cae03": { "balance": "40044000000000000000" }, "f5eadcd2d1b8657a121f33c458a8b13e76b65526": { "balance": "249828000000000000000" }, "90e7070f4d033fe6910c9efe5a278e1fc6234def": { "balance": "100392000000000000000" }, "d55508adbbbe9be81b80f97a6ea89add68da674f": { "balance": "2000000000000000000000" }, "66925de3e43f4b41bf9dadde27d5488ef569ea0d": { "balance": "39400000000000000000" }, "b7c077946674ba9341fb4c747a5d50f5d2da6415": { "balance": "1000000000000000000000" }, "c52d1a0c73c2a1be84915185f8b34faa0adf1de3": { "balance": "1400001000000000000000" }, "79b8aad879dd30567e8778d2d231c8f37ab8734e": { "balance": "2000000000000000000000" }, "3aae4872fd9093cbcad1406f1e8078bab50359e2": { "balance": "39400000000000000000" }, "b2e9d76bf50fc36bf7d3944b63e9ca889b699968": { "balance": "2660000000000000000000" }, "405f596b94b947344c033ce2dcbff12e25b79784": { "balance": "2000000000000000000000" }, "232cb1cd49993c144a3f88b3611e233569a86bd6": { "balance": "15576000000000000000000" }, "9e232c08c14dc1a6ed0b8a3b2868977ba5c17d10": { "balance": "20000000000000000000" }, "095270cc42141dd998ad2862dbd1fe9b44e7e650": { "balance": "1200000000000000000000" }, "15d99468507aa0413fb60dca2adc7f569cb36b54": { "balance": "2000000000000000000000" }, "04852732b4c652f6c2e58eb36587e60a62da14db": { "balance": "20000000000000000000000" }, "ecf24cdd7c22928c441e694de4aa31b0fab59778": { "balance": "600000000000000000000" }, "512b91bbfaa9e581ef683fc90d9db22a8f49f48b": { "balance": "310000000000000000000000" }, "a88577a073fbaf33c4cd202e00ea70ef711b4006": { "balance": "2000000000000000000000" }, "00acc6f082a442828764d11f58d6894ae408f073": { "balance": "60000000000000000000000" }, "0355bcacbd21441e95adeedc30c17218c8a408ce": { "balance": "400000000000000000000" }, "4e73cf2379f124860f73d6d91bf59acc5cfc845b": { "balance": "40110000000000000000" }, "2a742b8910941e0932830a1d9692cfd28494cf40": { "balance": "499986000000000000000" }, "41a8c2830081b102df6e0131657c07ab635b54ce": { "balance": "1999944000000000000000" }, "b63064bd3355e6e07e2d377024125a33776c4afa": { "balance": "38800000000000000000000" }, "1a25e1c5bc7e5f50ec16f8885f210ea1b938800e": { "balance": "4000000000000000000000" }, "09b59b8698a7fbd3d2f8c73a008988de3e406b2b": { "balance": "40000000000000000000000" }, "c555b93156f09101233c6f7cf6eb3c4f196d3346": { "balance": "3000000000000000000000" }, "12f32c0a1f2daab676fe69abd9e018352d4ccd45": { "balance": "50000000000000000000" }, "5956b28ec7890b76fc061a1feb52d82ae81fb635": { "balance": "2000000000000000000000" }, "c739259e7f85f2659bef5f609ed86b3d596c201e": { "balance": "200000000000000000000" }, "fae92c1370e9e1859a5df83b56d0f586aa3b404c": { "balance": "106480000000000000000" }, "d5a7bec332adde18b3104b5792546aa59b879b52": { "balance": "2000000000000000000000" }, "4f88dfd01091a45a9e2676021e64286cd36b8d34": { "balance": "1000000000000000000000" }, "102c477d69aadba9a0b0f62b7459e17fbb1c1561": { "balance": "2000000000000000000000" }, "34272d5e7574315dcae9abbd317bac90289d4765": { "balance": "1820000000000000000000" }, "fe615d975c0887e0c9113ec7298420a793af8b96": { "balance": "8000000000000000000000" }, "487adf7d70a6740f8d51cbdd68bb3f91c4a5ce68": { "balance": "66850000000000000000" }, "7e5d9993104e4cb545e179a2a3f971f744f98482": { "balance": "2000000000000000000000" }, "5529830a61c1f13c197e550beddfd6bd195c9d02": { "balance": "10000000000000000000000" }, "2f282abbb6d4a3c3cd3b5ca812f7643e80305f06": { "balance": "1850000000000000000000" }, "7352586d021ad0cf77e0e928404a59f374ff4582": { "balance": "3400000000000000000000" }, "03f7b92008813ae0a676eb212814afab35221069": { "balance": "2000000000000000000000" }, "056686078fb6bcf9ba0a8a8dc63a906f5feac0ea": { "balance": "499800000000000000000" }, "8063379a7bf2cb923a84c5093e68dac7f75481c5": { "balance": "322102000000000000000" }, "200264a09f8c68e3e6629795280f56254f8640d0": { "balance": "20000000000000000000" }, "5a891155f50e42074374c739baadf7df2651153a": { "balance": "4775000000000000000000" }, "80022a1207e910911fc92849b069ab0cdad043d3": { "balance": "13370000000000000000" }, "e781ec732d401202bb9bd13860910dd6c29ac0b6": { "balance": "1240000000000000000000" }, "4c2f1afef7c5868c44832fc77cb03b55f89e6d6e": { "balance": "20000000000000000000000" }, "34ff582952ff24458f7b13d51f0b4f987022c1fe": { "balance": "2804400000000000000000" }, "73914b22fc2f131584247d82be4fecbf978ad4ba": { "balance": "2000000000000000000000" }, "562be95aba17c5371fe2ba828799b1f55d2177d6": { "balance": "38200000000000000000000" }, "648f5bd2a2ae8902db37847d1cb0db9390b06248": { "balance": "7769965000000000000000" }, "6a9758743b603eea3aa0524b42889723c4153948": { "balance": "10100000000000000000000" }, "5985c59a449dfc5da787d8244e746c6d70caa55f": { "balance": "100000000000000000000" }, "56ee197f4bbf9f1b0662e41c2bbd9aa1f799e846": { "balance": "1000000000000000000000" }, "d47c242edffea091bc54d57df5d1fdb93101476c": { "balance": "2914000000000000000000" }, "d482e7f68e41f238fe517829de15477fe0f6dd1d": { "balance": "500000000000000000000" }, "05bf4fcfe772e45b826443852e6c351350ce72a2": { "balance": "8000000000000000000000" }, "f10462e58fcc07f39584a187639451167e859201": { "balance": "169830000000000000000" }, "1aa27699cada8dc3a76f7933aa66c71919040e88": { "balance": "400000000000000000000" }, "24046b91da9b61b629cb8b8ec0c351a07e0703e4": { "balance": "2000000000000000000000" }, "41033c1b6d05e1ca89b0948fc64453fbe87ab25e": { "balance": "1337000000000000000000" }, "369822f5578b40dd1f4471706b22cd971352da6b": { "balance": "346000000000000000000" }, "044e853144e3364495e7a69fa1d46abea3ac0964": { "balance": "49225000000000000000" }, "abf728cf9312f22128024e7046c251f5dc5901ed": { "balance": "29550000000000000000000" }, "d781f7fc09184611568570b4986e2c72872b7ed0": { "balance": "20002000000000000000" }, "6bb4a661a33a71d424d49bb5df28622ed4dffcf4": { "balance": "630400000000000000000" }, "fef3b3dead1a6926d49aa32b12c22af54d9ff985": { "balance": "1000000000000000000000" }, "fa410971ad229c3036f41acf852f2ac999281950": { "balance": "3997400000000000000000" }, "de176b5284bcee3a838ba24f67fc7cbf67d78ef6": { "balance": "37600000000000000000" }, "23120046f6832102a752a76656691c863e17e59c": { "balance": "329800000000000000000" }, "a2f472fe4f22b77db489219ea4023d11582a9329": { "balance": "40000000000000000000000" }, "f0d64cf9df09741133d170485fd24b005011d520": { "balance": "498680000000000000000" }, "8b505e2871f7deb7a63895208e8227dcaa1bff05": { "balance": "61216600000000000000000" }, "481e3a91bfdc2f1c8428a0119d03a41601417e1c": { "balance": "1000000000000000000000" }, "bc69a0d2a31c3dbf7a9122116901b2bdfe9802a0": { "balance": "3000000000000000000000" }, "20a81680e465f88790f0074f60b4f35f5d1e6aa5": { "balance": "1279851000000000000000" }, "194a6bb302b8aba7a5b579df93e0df1574967625": { "balance": "500000000000000000000" }, "264cc8086a8710f91b21720905912cd7964ae868": { "balance": "26740000000000000000" }, "24aca08d5be85ebb9f3132dfc1b620824edfedf9": { "balance": "18200000000000000000" }, "1851a063ccdb30549077f1d139e72de7971197d5": { "balance": "2000000000000000000000" }, "f64a4ac8d540a9289c68d960d5fb7cc45a77831c": { "balance": "2000000000000000000000" }, "c3db5657bb72f10d58f231fddf11980aff678693": { "balance": "5910000000000000000000" }, "b46ace865e2c50ea4698d216ab455dff5a11cd72": { "balance": "1000000000000000000000" }, "9faea13c733412dc4b490402bfef27a0397a9bc3": { "balance": "310000000000000000000" }, "b40594c4f3664ef849cca6227b8a25aa690925ee": { "balance": "4000000000000000000000" }, "672fa0a019088db3166f6119438d07a99f8ba224": { "balance": "13370000000000000000000" }, "c1ffad07db96138c4b2a530ec1c7de29b8a0592c": { "balance": "17600000000000000000" }, "87af25d3f6f8eea15313d5fe4557e810c524c083": { "balance": "19700000000000000000000" }, "d6a22e598dabd38ea6e958bd79d48ddd9604f4df": { "balance": "1000000000000000000000" }, "a2a435de44a01bd0ecb29e44e47644e46a0cdffb": { "balance": "500171000000000000000" }, "549b47649cfad993e4064d2636a4baa0623305cc": { "balance": "601650000000000000000" }, "1321b605026f4ffb296a3e0edcb390c9c85608b7": { "balance": "2000000000000000000000" }, "b4bf24cb83686bc469869fefb044b909716993e2": { "balance": "2000000000000000000000" }, "12d91a92d74fc861a729646db192a125b79f5374": { "balance": "18200000000000000000" }, "7f0662b410298c99f311d3a1454a1eedba2fea76": { "balance": "200000000000000000000" }, "83908aa7478a6d1c9b9b0281148f8f9f242b9fdc": { "balance": "2000000000000000000000" }, "c1438c99dd51ef1ca8386af0a317e9b041457888": { "balance": "223500000000000000000" }, "545bb070e781172eb1608af7fc2895d6cb87197e": { "balance": "2244000000000000000000" }, "161d26ef6759ba5b9f20fdcd66f16132c352415e": { "balance": "2000000000000000000000" }, "d7f370d4bed9d57c6f49c999de729ee569d3f4e4": { "balance": "200000000000000000000" }, "90e35aabb2deef408bb9b5acef714457dfde6272": { "balance": "100076000000000000000" }, "0fcfc4065008cfd323305f6286b57a4dd7eee23b": { "balance": "20000000000000000000000" }, "cd725d70be97e677e3c8e85c0b26ef31e9955045": { "balance": "1337000000000000000000" }, "dcf6b657266e91a4dae6033ddac15332dd8d2b34": { "balance": "1760000000000000000000" }, "31f006f3494ed6c16eb92aaf9044fa8abb5fd5a3": { "balance": "500000000000000000000" }, "cdea386f9d0fd804d02818f237b7d9fa7646d35e": { "balance": "3012139000000000000000" }, "d45b3341e8f15c80329320c3977e3b90e7826a7e": { "balance": "500000000000000000000" }, "0b649da3b96a102cdc6db652a0c07d65b1e443e6": { "balance": "2000000000000000000000" }, "0a58fddd71898de773a74fdae45e7bd84ef43646": { "balance": "20000000000000000000" }, "0256149f5b5063bea14e15661ffb58f9b459a957": { "balance": "704000000000000000000" }, "4438e880cb2766b0c1ceaec9d2418fceb952a044": { "balance": "133712000000000000000" }, "9ed80eda7f55054db9fb5282451688f26bb374c1": { "balance": "300000000000000000000" }, "8dab948ae81da301d972e3f617a912e5a753712e": { "balance": "400000000000000000000" }, "5b5d8c8eed6c85ac215661de026676823faa0a0c": { "balance": "20000000000000000000000" }, "46722a36a01e841d03f780935e917d85d5a67abd": { "balance": "14900000000000000000" }, "d4b8bdf3df9a51b0b91d16abbea05bb4783c8661": { "balance": "1000000000000000000000" }, "98f6b8e6213dbc9a5581f4cce6655f95252bdb07": { "balance": "319968000000000000000" }, "3599493ce65772cf93e98af1195ec0955dc98002": { "balance": "1500048000000000000000" }, "ecab5aba5b828de1705381f38bc744b32ba1b437": { "balance": "940000000000000000000" }, "9a82826d3c29481dcc2bd2950047e8b60486c338": { "balance": "20000000000000000000000" }, "6c474bc66a54780066aa4f512eefa773abf919c7": { "balance": "94000000000000000000" }, "d5903e9978ee20a38c3f498d63d57f31a39f6a06": { "balance": "10380000000000000000000" }, "341480cc8cb476f8d01ff30812e7c70e05afaf5d": { "balance": "2000000000000000000000" }, "af771039345a343001bc0f8a5923b126b60d509c": { "balance": "985000000000000000000" }, "b5a4679685fa14196c2e9230c8c4e33bffbc10e2": { "balance": "1400000000000000000000" }, "2a400dff8594de7228b4fd15c32322b75bb87da8": { "balance": "95810000000000000000" }, "a1336dfb96b6bcbe4b3edf3205be5723c90fad52": { "balance": "5000000000000000000000" }, "e9b1f1fca3fa47269f21b061c353b7f5e96d905a": { "balance": "500000000000000000000" }, "0ee414940487fd24e390378285c5d7b9334d8b65": { "balance": "2680000000000000000000" }, "6ab5b4c41cddb829690c2fda7f20c85e629dd5d5": { "balance": "1860000000000000000000" }, "dd63042f25ed32884ad26e3ad959eb94ea36bf67": { "balance": "21340000000000000000000" }, "c0b3f244bca7b7de5b48a53edb9cbeab0b6d88c0": { "balance": "5820000000000000000000" }, "ed1a5c43c574d4e934299b24f1472cdc9fd6f010": { "balance": "200000000000000000000" }, "b2d9ab9664bcf6df203c346fc692fd9cbab9205e": { "balance": "438000000000000000000" }, "ede8c2cb876fbe8a4cca8290361a7ea01a69fdf8": { "balance": "7813091000000000000000" }, "6a7c252042e7468a3ff773d6450bba85efa26391": { "balance": "500000000000000000000" }, "a106e6923edd53ca8ed650968a9108d6ccfd9670": { "balance": "9499935000000000000000" }, "031e25db516b0f099faebfd94f890cf96660836b": { "balance": "2000000000000000000000" }, "7fdbc3a844e40d96b2f3a635322e6065f4ca0e84": { "balance": "2000000000000000000000" }, "df47a61b72535193c561cccc75c3f3ce0804a20e": { "balance": "398000000000000000000" }, "ed31305c319f9273d3936d8f5b2f71e9b1b22963": { "balance": "100000000000000000000" }, "a6b2d573297360102c07a18fc21df2e7499ff4eb": { "balance": "4011000000000000000000" }, "f68464bf64f2411356e4d3250efefe5c50a5f65b": { "balance": "20000000000000000000" }, "927cc2bfda0e088d02eff70b38b08aa53cc30941": { "balance": "1852700000000000000000" }, "41cb9896445f70a10a14215296daf614e32cf4d5": { "balance": "1910000000000000000000" }, "3ad70243d88bf0400f57c8c1fd57811848af162a": { "balance": "860000000000000000000" }, "63b9754d75d12d384039ec69063c0be210d5e0e3": { "balance": "2694055000000000000000" }, "ad1799aad7602b4540cd832f9db5f11150f1687a": { "balance": "2000000000000000000000" }, "a8b65ba3171a3f77a6350b9daf1f8d55b4d201eb": { "balance": "745000000000000000000" }, "ad0a4ae478e9636e88c604f242cf5439c6d45639": { "balance": "3520000000000000000000" }, "4cd0b0a6436362595ceade052ebc9b929fb6c6c0": { "balance": "2000000000000000000000" }, "c1d4af38e9ba799040894849b8a8219375f1ac78": { "balance": "20000000000000000000000" }, "49ddee902e1d0c99d1b11af3cc8a96f78e4dcf1a": { "balance": "199358000000000000000" }, "ae842210f44d14c4a4db91fc9d3b3b50014f7bf7": { "balance": "4000000000000000000000" }, "10a1c42dc1ba746986b985a522a73c93eae64c63": { "balance": "1000000000000000000000" }, "5103bc09933e9921fd53dc536f11f05d0d47107d": { "balance": "4000000000000000000000" }, "c88eec54d305c928cc2848c2fee23531acb96d49": { "balance": "1999946000000000000000" }, "9a2ce43b5d89d6936b8e8c354791b8afff962425": { "balance": "2000000000000000000000" }, "562020e3ed792d2f1835fe5f55417d5111460c6a": { "balance": "20000000000000000000000" }, "ed16ce39feef3bd7f5d162045e0f67c0f00046bb": { "balance": "20000000000000000000" }, "ab948a4ae3795cbca13126e19253bdc21d3a8514": { "balance": "200000000000000000000" }, "c12b7f40df9a2f7bf983661422ab84c9c1f50858": { "balance": "8000000000000000000000" }, "62e6b2f5eb94fa7a43831fc87e254a3fe3bf8f89": { "balance": "250000000000000000000" }, "423bca47abc00c7057e3ad34fca63e375fbd8b4a": { "balance": "18000000000000000000000" }, "5ff326cd60fd136b245e29e9087a6ad3a6527f0d": { "balance": "1880000000000000000000" }, "79ffb4ac13812a0b78c4a37b8275223e176bfda5": { "balance": "17300000000000000000" }, "f757fc8720d3c4fa5277075e60bd5c411aebd977": { "balance": "2000000000000000000000" }, "0bdbc54cc8bdbbb402a08911e2232a5460ce866b": { "balance": "3000000000000000000000" }, "9ee9760cc273d4706aa08375c3e46fa230aff3d5": { "balance": "8950000000000000000000" }, "d23a24d7f9468343c143a41d73b88f7cbe63be5e": { "balance": "200000000000000000000" }, "46d80631284203f6288ecd4e5758bb9d41d05dbe": { "balance": "2000000000000000000000" }, "3f4cd1399f8a34eddb9a17a471fc922b5870aafc": { "balance": "200000000000000000000" }, "44c54eaa8ac940f9e80f1e74e82fc14f1676856a": { "balance": "7880000000000000000000" }, "aec27ff5d7f9ddda91183f46f9d52543b6cd2b2f": { "balance": "450000000000000000000" }, "203c6283f20df7bc86542fdfb4e763ecdbbbeef5": { "balance": "25000000000000000000000" }, "bcaf347918efb2d63dde03e39275bbe97d26df50": { "balance": "100000000000000000000" }, "974d0541ab4a47ec7f75369c0069b64a1b817710": { "balance": "400000000000000000000" }, "5da54785c9bd30575c89deb59d2041d20a39e17b": { "balance": "1967031000000000000000" }, "1fb463a0389983df7d593f7bdd6d78497fed8879": { "balance": "20000000000000000000" }, "6e1ea4b183e252c9bb7767a006d4b43696cb8ae9": { "balance": "294245000000000000000" }, "c2aa74847e86edfdd3f3db22f8a2152feee5b7f7": { "balance": "2048852000000000000000" }, "a13b9d82a99b3c9bba5ae72ef2199edc7d3bb36c": { "balance": "1999944000000000000000" }, "5135fb8757600cf474546252f74dc0746d06262c": { "balance": "2000000000000000000000" }, "43e7ec846358d7d0f937ad1c350ba069d7bf72bf": { "balance": "118800000000000000000" }, "f2ed3e77254acb83231dc0860e1a11242ba627db": { "balance": "1980000000000000000000" }, "c0a02ab94ebe56d045b41b629b98462e3a024a93": { "balance": "100000000000000000000" }, "f21549bdd1487912f900a7523db5f7626121bba3": { "balance": "10000000000000000000000" }, "886d0a9e17c9c095af2ea2358b89ec705212ee94": { "balance": "28000000000000000000" }, "211b29cefc79ae976744fdebcebd3cbb32c51303": { "balance": "14000000000000000000000" }, "b8c2703d8c3f2f44c584bc10e7c0a6b64c1c097e": { "balance": "5550000000000000000000" }, "ec30addd895b82ee319e54fb04cb2bb03971f36b": { "balance": "2000000000000000000000" }, "b71b62f4b448c02b1201cb5e394ae627b0a560ee": { "balance": "500000000000000000000" }, "e1334e998379dfe983177062791b90f80ee22d8d": { "balance": "500000000000000000000" }, "1d633097a85225a1ff4321b12988fdd55c2b3844": { "balance": "4000000000000000000000" }, "8bd8d4c4e943f6c8073921dc17e3e8d7a0761627": { "balance": "2933330000000000000000" }, "a5d96e697d46358d119af7819dc7087f6ae47fef": { "balance": "14605131000000000000000" }, "d0809498c548047a1e2a2aa6a29cd61a0ee268bd": { "balance": "2000000000000000000000" }, "3cd6b7593cbee77830a8b19d0801958fcd4bc57a": { "balance": "500000000000000000000" }, "ead4d2eefb76abae5533961edd11400406b298fc": { "balance": "3880000000000000000000" }, "6331028cbb5a21485bc51b565142993bdb2582a9": { "balance": "534800000000000000000" }, "163bad4a122b457d64e8150a413eae4d07023e6b": { "balance": "18800000000000000000" }, "c522e20fbf04ed7f6b05a37b4718d6fce0142e1a": { "balance": "4000000000000000000000" }, "2d9bad6f1ee02a70f1f13def5cccb27a9a274031": { "balance": "1790000000000000000000" }, "5ed0d6338559ef44dc7a61edeb893fa5d83fa1b5": { "balance": "220000000000000000000" }, "ec8c1d7b6aaccd429db3a91ee4c9eb1ca4f6f73c": { "balance": "4250000000000000000000" }, "3896ad743579d38e2302454d1fb6e2ab69e01bfd": { "balance": "1880000000000000000000" }, "e73ccf436725c151e255ccf5210cfce5a43f13e3": { "balance": "19982000000000000000" }, "9483d98f14a33fdc118d403955c29935edfc5f70": { "balance": "459600000000000000000" }, "1cfcf7517f0c08459720942b647ad192aa9c8828": { "balance": "800000000000000000000" }, "8d378f0edc0bb0f0686d6a20be6a7692c4fa24b8": { "balance": "100000000000000000000" }, "06f68de3d739db41121eacf779aada3de8762107": { "balance": "28000000000000000000" }, "9909650dd5b1397b8b8b0eb69499b291b0ad1213": { "balance": "200000000000000000000" }, "b66675142e3111a1c2ea1eb2419cfa42aaf7a234": { "balance": "1000000000000000000000" }, "7836f7ef6bc7bd0ff3acaf449c84dd6b1e2c939f": { "balance": "4142296000000000000000" }, "3ddedbe48923fbf9e536bf9ffb0747c9cdd39eef": { "balance": "16100000000000000000000" }, "c47d610b399250f70ecf1389bab6292c91264f23": { "balance": "288800000000000000000" }, "51a6d627f66a8923d88d6094c4715380d3057cb6": { "balance": "1152044000000000000000" }, "6c0cc917cbee7d7c099763f14e64df7d34e2bf09": { "balance": "250000000000000000000" }, "aaaae68b321402c8ebc13468f341c63c0cf03fce": { "balance": "1520000000000000000000" }, "819cdaa5303678ef7cec59d48c82163acc60b952": { "balance": "14523448000000000000000" }, "d071192966eb69c3520fca3aa4dd04297ea04b4e": { "balance": "110000000000000000000" }, "e53425d8df1f11c341ff58ae5f1438abf1ca53cf": { "balance": "322000000000000000000" }, "8ffe322997b8e404422d19c54aadb18f5bc8e9b7": { "balance": "3940000000000000000000" }, "305f78d618b990b4295bac8a2dfa262884f804ea": { "balance": "4000000000000000000000" }, "274d69170fe7141401882b886ac4618c6ae40edb": { "balance": "955000000000000000000" }, "69c94e07c4a9be3384d95dfa3cb9290051873b7b": { "balance": "70000000000000000000" }, "859c600cf13d1d0273d5d1da3cd789e495899f27": { "balance": "2674000000000000000000" }, "c06cebbbf7f5149a66f7eb976b3e47d56516da2f": { "balance": "2000000000000000000000" }, "37bbc47212d82fcb5ee08f5225ecc2041ad2da7d": { "balance": "3280000000000000000000" }, "11e7997edd904503d77da6038ab0a4c834bbd563": { "balance": "388000000000000000000" }, "d333627445f2d787901ef33bb2a8a3675e27ffec": { "balance": "400000000000000000000" }, "16a58e985dccd707a594d193e7cca78b5d027849": { "balance": "1360000000000000000000" }, "f8ae857b67a4a2893a3fbe7c7a87ff1c01c6a6e7": { "balance": "4000000000000000000000" }, "491561db8b6fafb9007e62d050c282e92c4b6bc8": { "balance": "30000000000000000000000" }, "21df1ec24b4e4bfe79b0c095cebae198f291fbd1": { "balance": "20000000000000000000000" }, "e208812a684098f3da4efe6aba256256adfe3fe6": { "balance": "2000000000000000000000" }, "f4ec8e97a20aa5f8dd206f55207e06b813df2cc0": { "balance": "200000000000000000000" }, "29eb7eefdae9feb449c63ff5f279d67510eb1422": { "balance": "19400000000000000000" }, "0d678706d037187f3e22e6f69b99a592d11ebc59": { "balance": "1580000000000000000000" }, "de6d363106cc6238d2f092f0f0372136d1cd50c6": { "balance": "5348000000000000000000" }, "c8710d7e8b5a3bd69a42fe0fa8b87c357fddcdc8": { "balance": "4000000000000000000000" }, "5267f4d41292f370863c90d793296903843625c7": { "balance": "1400000000000000000000" }, "4cda41dd533991290794e22ae324143e309b3d3d": { "balance": "2400000000000000000000" }, "f8a50cee2e688ceee3aca4d4a29725d4072cc483": { "balance": "2000000000000000000000" }, "5ed3bbc05240e0d399eb6ddfe60f62de4d9509af": { "balance": "193999806000000000000000" }, "0befb54707f61b2c9fb04715ab026e1bb72042bd": { "balance": "4000000000000000000000" }, "cab9a301e6bd46e940355028eccd40ce4d5a1ac3": { "balance": "400000000000000000000" }, "64672da3ab052821a0243d1ce4b6e0a36517b8eb": { "balance": "200000000000000000000" }, "eac0827eff0c6e3ff28a7d4a54f65cb7689d7b99": { "balance": "2856500000000000000000" }, "f4b6cdcfcb24230b337d770df6034dfbd4e1503f": { "balance": "19000000000000000000000" }, "7be2f7680c802da6154c92c0194ae732517a7169": { "balance": "18200000000000000000" }, "869f1aa30e4455beb1822091de5cadec79a8f946": { "balance": "8000000000000000000000" }, "c4681e73bb0e32f6b726204831ff69baa4877e32": { "balance": "1820000000000000000000" }, "962cd22a8edf1e4f4e55b4b15ddbfb5d9d541971": { "balance": "2000000000000000000000" }, "131df8d330eb7cc7147d0a55576f05de8d26a8b7": { "balance": "188000000000000000000" }, "19f99f2c0b46ce8906875dc9f90ae104dae35594": { "balance": "4507300000000000000000" }, "91bb3f79022bf3c453f4ff256e269b15cf2c9cbd": { "balance": "1519000000000000000000" }, "7301dc4cf26d7186f2a11bf8b08bf229463f64a3": { "balance": "2000000000000000000000" }, "7cbca88fca6a0060b960985c9aa1b02534dc2208": { "balance": "462500000000000000000" }, "f3c1abd29dc57b41dc192d0e384d021df0b4f6d4": { "balance": "2798000000000000000000" }, "5d32f6f86e787ff78e63d78b0ef95fe6071852b8": { "balance": "401100000000000000000" }, "1678c5f2a522393225196361894f53cc752fe2f3": { "balance": "1936000000000000000000" }, "1cf04cb14380059efd3f238b65d5beb86afa14d8": { "balance": "20000000000000000000" }, "52e1731350f983cc2c4189842fde0613fad50ce1": { "balance": "11640000000000000000000" }, "d0b11d6f2bce945e0c6a5020c3b52753f803f9d1": { "balance": "200000000000000000000" }, "409bd75085821c1de70cdc3b11ffc3d923c74010": { "balance": "4000000000000000000000" }, "0bb7160aba293762f8734f3e0326ffc9a4cac190": { "balance": "1000000000000000000000" }, "7aad4dbcd3acf997df93586956f72b64d8ad94ee": { "balance": "4000000000000000000000" }, "2dec98329d1f96c3a59caa7981755452d4da49d5": { "balance": "200000000000000000000" }, "c18ab467feb5a0aadfff91230ff056464d78d800": { "balance": "2000000000000000000000" }, "c90c3765156bca8e4897ab802419153cbe5225a9": { "balance": "200000000000000000000" }, "85c8f3cc7a354feac99a5e7bfe7cdfa351cfe355": { "balance": "400000000000000000000" }, "f4fc4d39bc0c2c4068a36de50e4ab4d4db7e340a": { "balance": "25380000000000000000" }, "f50abbd4aa45d3eb88515465a8ba0b310fd9b521": { "balance": "6685000000000000000000" }, "4d200110124008d56f76981256420c946a6ff45c": { "balance": "199955000000000000000" }, "f4ba6a46d55140c439cbcf076cc657136262f4f8": { "balance": "2000000000000000000000" }, "fa7adf660b8d99ce15933d7c5f072f3cbeb99d33": { "balance": "5910000000000000000000" }, "84503334630d77f74147f68b2e086613c8f1ade9": { "balance": "1600000000000000000000" }, "31ed858788bda4d5270992221cc04206ec62610d": { "balance": "1176000000000000000000" }, "bfbca418d3529cb393081062032a6e1183c6b2dc": { "balance": "8000000000000000000000" }, "8263ece5d709e0d7ae71cca868ed37cd2fef807b": { "balance": "990000000000000000000" }, "23ba3864da583dab56f420873c37679690e02f00": { "balance": "9800000000000000000000" }, "cedcb3a1d6843fb6bef643617deaf38f8e98dd5f": { "balance": "477500000000000000000" }, "8fac748f784a0fed68dba43319b42a75b4649c6e": { "balance": "910000000000000000000" }, "18b8bcf98321da61fb4e3eacc1ec5417272dc27e": { "balance": "880000000000000000000" }, "776943ffb2ef5cdd35b83c28bc046bd4f4677098": { "balance": "3000000000000000000000" }, "fb8113f94d9173eefd5a3073f516803a10b286ae": { "balance": "80000000000000000000" }, "3e8349b67f5745449f659367d9ad4712db5b895a": { "balance": "1820000000000000000000" }, "79cfa9780ae6d87b2c31883f09276986c89a6735": { "balance": "1000000000000000000000" }, "5006fe4c22173980f00c74342b39cd231c653129": { "balance": "2000000000000000000000" }, "13848b46ea75beb7eaa85f59d866d77fd24cf21a": { "balance": "50000000000000000000000" }, "d64a2d50f8858537188a24e0f50df1681ab07ed7": { "balance": "38800000000000000000000" }, "4f9ce2af9b8c5e42c6808a3870ec576f313545d1": { "balance": "10000000000000000000000" }, "8764d02722000996ecd475b433298e9f540b05bf": { "balance": "200000000000000000000" }, "3b7c77dbe95dc2602ce3269a9545d04965fefdbd": { "balance": "2000000000000000000000" }, "c9dcbb056f4db7d9da39936202c5bd8230b3b477": { "balance": "20000000000000000000000" }, "9ecbabb0b22782b3754429e1757aaba04b81189f": { "balance": "823743000000000000000" }, "831c44b3084047184b2ad218680640903750c45d": { "balance": "1970000000000000000000" }, "ff8eb07de3d49d9d52bbe8e5b26dbe1d160fa834": { "balance": "3986000000000000000000" }, "8ccf3aa21ab742576ad8c422f71bb188591dea8a": { "balance": "1000000000000000000000" }, "ddac312a9655426a9c0c9efa3fd82559ef4505bf": { "balance": "401100000000000000000" }, "9a3e2b1bf346dd070b027357feac44a4b2c97db8": { "balance": "10000000000000000000000" }, "69d39d510889e552a396135bfcdb06e37e387633": { "balance": "4000000000000000000000" }, "83a3148833d9644984f7c475a7850716efb480ff": { "balance": "3400000000000000000000" }, "62b4a9226e61683c72c183254690daf511b4117a": { "balance": "260000000000000000000" }, "50763add868fd7361178342fc055eaa2b95f6846": { "balance": "66838000000000000000" }, "91898eab8c05c0222883cd4db23b7795e1a24ad7": { "balance": "2000000000000000000000" }, "066647cfc85d23d37605573d208ca154b244d76c": { "balance": "10000000000000000000000" }, "aaf9ee4b886c6d1e95496fd274235bf4ecfcb07d": { "balance": "1400000000000000000000" }, "06860a93525955ff624940fadcffb8e149fd599c": { "balance": "1999800000000000000000" }, "e81c2d346c0adf4cc56708f6394ba6c8c8a64a1e": { "balance": "2000000000000000000000" }, "41a8e236a30e6d63c1ff644d132aa25c89537e01": { "balance": "20000000000000000000" }, "6a679e378fdce6bfd97fe62f043c6f6405d79e99": { "balance": "4000000000000000000000" }, "933436c8472655f64c3afaaf7c4c621c83a62b38": { "balance": "1000000000000000000000" }, "abe07ced6ac5ddf991eff6c3da226a741bd243fe": { "balance": "10000000000000000000000" }, "bb56a404723cff20d0685488b05a02cdc35aacaa": { "balance": "20000000000000000000" }, "0d551ec1a2133c981d5fc6a8c8173f9e7c4f47af": { "balance": "2000000000000000000000" }, "23376ecabf746ce53321cf42c86649b92b67b2ff": { "balance": "2000000000000000000000" }, "644ba6c61082e989109f5c11d4b40e991660d403": { "balance": "4000000000000000000000" }, "680d5911ed8dd9eec45c060c223f89a7f620bbd5": { "balance": "20000000000000000000000" }, "cb1bb6f1da5eb10d4899f7e61d06c1b00fdfb52d": { "balance": "1038000000000000000000" }, "303a30ac4286ae17cf483dad7b870c6bd64d7b4a": { "balance": "500000000000000000000" }, "7b0b31ff6e24745ead8ed9bb85fc0bf2fe1d55d4": { "balance": "800000000000000000000" }, "854691ce714f325ced55ce5928ce9ba12facd1b8": { "balance": "4380000000000000000000" }, "a13cfe826d6d1841dcae443be8c387518136b5e8": { "balance": "140000000000000000000000" }, "5fcd84546896dd081db1a320bd4d8c1dd1528c4c": { "balance": "20000000000000000000" }, "3db5fe6a68bd3612ac15a99a61e555928eeceaf3": { "balance": "1580000000000000000000" }, "7a79e30ff057f70a3d0191f7f53f761537af7dff": { "balance": "400000000000000000000" }, "3d3fad49c9e5d2759c8e8e5a7a4d60a0dd135692": { "balance": "20000000000000000000" }, "05a830724302bc0f6ebdaa1ebeeeb46e6ce00b39": { "balance": "98500000000000000000" }, "e4b6ae22c7735f5b89f34dd77ad0975f0acc9181": { "balance": "1000000000000000000000" }, "3f2dd55db7eab0ebee65b33ed8202c1e992e958b": { "balance": "820000000000000000000" }, "395d6d255520a8db29abc47d83a5db8a1a7df087": { "balance": "100000000000000000000" }, "1cc90876004109cd79a3dea866cb840ac364ba1b": { "balance": "2000000000000000000000" }, "c83e9d6a58253beebeb793e6f28b054a58491b74": { "balance": "281800000000000000000" }, "901d99b699e5c6911519cb2076b4c76330c54d22": { "balance": "2000000000000000000000" }, "3a9132b7093d3ec42e1e4fb8cb31ecdd43ae773c": { "balance": "2000000000000000000000" }, "b41eaf5d51a5ba1ba39bb418dbb54fab750efb1f": { "balance": "1000000000000000000000" }, "aa493d3f4fb866491cf8f800efb7e2324ed7cfe5": { "balance": "1700000000000000000000" }, "509982f56237ee458951047e0a2230f804e2e895": { "balance": "17500000000000000000000" }, "316e92a91bbda68b9e2f98b3c048934e3cc0b416": { "balance": "2000000000000000000000" }, "a3430e1f647f321ed34739562323c7d623410b56": { "balance": "999942000000000000000" }, "fca43bbc23a0d321ba9e46b929735ce7d8ef0c18": { "balance": "20000000000000000000" }, "ff45cb34c928364d9cc9d8bb00373474618f06f3": { "balance": "100000000000000000000" }, "8c999591fd72ef7111efca7a9e97a2356b3b000a": { "balance": "4084000000000000000000" }, "8579dadf1a395a3471e20b6f763d9a0ff19a3f6f": { "balance": "4000000000000000000000" }, "c8d4e1599d03b79809e0130a8dc38408f05e8cd3": { "balance": "2945500000000000000000" }, "2abce1808940cd4ef5b5e05285f82df7a9ab5e03": { "balance": "9800000000000000000000" }, "0bb0c12682a2f15c9b5741b2385cbe41f034068e": { "balance": "1500000000000000000000" }, "08b7bdcf944d5570838be70460243a8694485858": { "balance": "2000000000000000000000" }, "c452e0e4b3d6ae06b836f032ca09db409ddfe0fb": { "balance": "800000000000000000000" }, "48d4f2468f963fd79a006198bb67895d2d5aa4d3": { "balance": "1400000000000000000000" }, "f9e7222faaf0f4da40c1c4a40630373a09bed7b6": { "balance": "2865000000000000000000" }, "bf59aee281fa43fe97194351a9857e01a3b897b2": { "balance": "600000000000000000000" }, "da0d4b7ef91fb55ad265f251142067f10376ced6": { "balance": "20000000000000000000000" }, "2c6f5c124cc789f8bb398e3f889751bc4b602d9e": { "balance": "24928000000000000000" }, "c85ef27d820403805fc9ed259fff64acb8d6346a": { "balance": "2000000000000000000000" }, "9aa8308f42910e5ade09c1a5e282d6d91710bdbf": { "balance": "200000000000000000000" }, "9e4cec353ac3e381835e3c0991f8faa5b7d0a8e6": { "balance": "9999917000000000000000" }, "137cf341e8516c815814ebcd73e6569af14cf7bc": { "balance": "1000000000000000000000" }, "889da662eb4a0a2a069d2bc24b05b4ee2e92c41b": { "balance": "1663417000000000000000" }, "0998d8273115b56af43c505e087aff0676ed3659": { "balance": "3999984000000000000000" }, "3e4d13c55a84e46ed7e9cb90fd355e8ad991e38f": { "balance": "1000000000000000000000" }, "abc068b4979b0ea64a62d3b7aa897d73810dc533": { "balance": "1970000000000000000000" }, "d8fdf546674738c984d8fab857880b3e4280c09e": { "balance": "20000000000000000000" }, "aff161740a6d909fe99c59a9b77945c91cc91448": { "balance": "60000000000000000000" }, "92ad1b3d75fba67d54663da9fc848a8ade10fa67": { "balance": "2000000000000000000000" }, "819eb4990b5aba5547093da12b6b3c1093df6d46": { "balance": "1000000000000000000000" }, "643d9aeed4b180947ed2b9207cce4c3ddc55e1f7": { "balance": "200000000000000000000" }, "ab3e62e77a8b225e411592b1af300752fe412463": { "balance": "9850000000000000000000" }, "650b425555e4e4c51718146836a2c1ee77a5b421": { "balance": "20000000000000000000000" }, "ba8e46d69d2e2343d86c60d82cf42c2041a0c1c2": { "balance": "100000000000000000000" }, "f9570e924c95debb7061369792cf2efec2a82d5e": { "balance": "20000000000000000000" }, "4dc4bf5e7589c47b28378d7503cf96488061dbbd": { "balance": "1760000000000000000000" }, "3d7ea5bf03528100ed8af8aed2653e921b6e6725": { "balance": "1000000000000000000000" }, "a02bde6461686e19ac650c970d0672e76dcb4fc2": { "balance": "8865000000000000000000" }, "b0e760bb07c081777345e0578e8bc898226d4e3b": { "balance": "2000000000000000000000" }, "979cbf21dfec8ace3f1c196d82df962534df394f": { "balance": "2832860000000000000000" }, "9f8245c3ab7d173164861cd3991b94f1ba40a93a": { "balance": "2860000000000000000000" }, "c25cf826550c8eaf10af2234fef904ddb95213be": { "balance": "1000000000000000000000" }, "967bfaf76243cdb9403c67d2ceefdee90a3feb73": { "balance": "970582000000000000000" }, "0b2113504534642a1daf102eee10b9ebde76e261": { "balance": "2733351000000000000000" }, "74bc4a5e2045f4ff8db184cf3a9b0c065ad807d2": { "balance": "2000000000000000000000" }, "f1da40736f99d5df3b068a5d745fafc6463fc9b1": { "balance": "121546000000000000000" }, "0fa6c7b0973d0bae2940540e247d3627e37ca347": { "balance": "1000000000000000000000" }, "72b05962fb2ad589d65ad16a22559eba1458f387": { "balance": "133700000000000000000" }, "6ceae3733d8fa43d6cd80c1a96e8eb93109c83b7": { "balance": "298000000000000000000" }, "28eaea78cd4d95faecfb68836eafe83520f3bbb7": { "balance": "200000000000000000000" }, "f49f6f9baabc018c8f8e119e0115f491fc92a8a4": { "balance": "10000000000000000000000" }, "833316985d47742bfed410604a91953c05fb12b0": { "balance": "2000000000000000000000" }, "ead75016e3a0815072b6b108bcc1b799acf0383e": { "balance": "2000000000000000000000" }, "0032403587947b9f15622a68d104d54d33dbd1cd": { "balance": "77500000000000000000" }, "8f64b9c1246d857831643107d355b5c75fef5d4f": { "balance": "1999944000000000000000" }, "15dcafcc2bace7b55b54c01a1c514626bf61ebd8": { "balance": "9400000000000000000000" }, "6886ada7bbb0617bda842191c68c922ea3a8ac82": { "balance": "1160000000000000000000" }, "f736dc96760012388fe88b66c06efe57e0d7cf0a": { "balance": "2100000000000000000000" }, "0b288a5a8b75f3dc4191eb0457e1c83dbd204d25": { "balance": "4853000000000000000000" }, "56b6c23dd2ec90b4728f3bb2e764c3c50c85f144": { "balance": "1000000000000000000000" }, "6310b020fd98044957995092090f17f04e52cdfd": { "balance": "1580000000000000000000" }, "b0baeb30e313776c4c6d247402ba4167afcda1cc": { "balance": "1970000000000000000000" }, "7641f7d26a86cddb2be13081810e01c9c83c4b20": { "balance": "13370000000000000000" }, "07a8dadec142571a7d53a4297051786d072cba55": { "balance": "22729000000000000000" }, "cc73dd356b4979b579b401d4cc7a31a268ddce5a": { "balance": "500000000000000000000" }, "adf1acfe99bc8c14b304c8d905ba27657b8a7bc4": { "balance": "20000000000000000000000" }, "72dabb5b6eed9e99be915888f6568056381608f8": { "balance": "208433000000000000000" }, "9de20ae76aa08263b205d5142461961e2408d266": { "balance": "252000000000000000000" }, "9d4ff989b7bed9ab109d10c8c7e55f02d76734ad": { "balance": "1000000000000000000000" }, "e58dd23238ee6ea7c2138d385df500c325f376be": { "balance": "1820000000000000000000" }, "4bd6dd0cff23400e1730ba7b894504577d14e74a": { "balance": "206028000000000000000000" }, "35147430c3106500e79fa2f502462e94703c23b1": { "balance": "1999944000000000000000" }, "c0ae14d724832e2fce2778de7f7b8daf7b12a93e": { "balance": "20000000000000000000" }, "b57413060af3f14eb479065f1e9d19b3757ae8cc": { "balance": "40000000000000000000" }, "7d04d2edc058a1afc761d9c99ae4fc5c85d4c8a6": { "balance": "314807840000000000000000" }, "1c94d636e684eb155895ce6db4a2588fba1d001b": { "balance": "2000000000000000000000" }, "c721b2a7aa44c21298e85039d00e2e460e670b9c": { "balance": "140800000000000000000" }, "2d89a8006a4f137a20dc2bec46fe2eb312ea9654": { "balance": "200000000000000000000" }, "646afba71d849e80c0ed59cac519b278e7f7abe4": { "balance": "1000000000000000000000" }, "71f2cdd1b046e2da2fbb5a26723422b8325e25a3": { "balance": "99960000000000000000" }, "2c9fa72c95f37d08e9a36009e7a4b07f29bad41a": { "balance": "16100000000000000000" }, "848fbd29d67cf4a013cb02a4b176ef244e9ee68d": { "balance": "20116000000000000000" }, "68190ca885da4231874c1cfb42b1580a21737f38": { "balance": "3820000000000000000000" }, "9adf458bff3599eee1a26398853c575bc38c6313": { "balance": "280000000000000000000" }, "b72220ade364d0369f2d2da783ca474d7b9b34ce": { "balance": "499986000000000000000" }, "38e2af73393ea98a1d993a74df5cd754b98d529a": { "balance": "1790000000000000000000" }, "4d38d90f83f4515c03cc78326a154d358bd882b7": { "balance": "185000000000000000000" }, "aa8eb0823b07b0e6d20aadda0e95cf3835be192e": { "balance": "32000000000000000000" }, "008639dabbe3aeac887b5dc0e43e13bcd287d76c": { "balance": "310200000000000000000" }, "fa3a0c4b903f6ea52ea7ab7b8863b6a616ad6650": { "balance": "20000000000000000000" }, "e26bf322774e18288769d67e3107deb7447707b8": { "balance": "2000000000000000000000" }, "e061a4f2fc77b296d19ada238e49a5cb8ecbfa70": { "balance": "4000000000000000000000" }, "b320834836d1dbfda9e7a3184d1ad1fd4320ccc0": { "balance": "1000000000000000000000" }, "0ed3bb3a4eb554cfca97947d575507cdfd6d21d8": { "balance": "547863000000000000000" }, "32fa0e86cd087dd68d693190f32d93310909ed53": { "balance": "4000000000000000000000" }, "5b759fa110a31c88469f54d44ba303d57dd3e10f": { "balance": "1683760000000000000000" }, "136f4907cab41e27084b9845069ff2fd0c9ade79": { "balance": "4000000000000000000000" }, "3d89e505cb46e211a53f32f167a877bec87f4b0a": { "balance": "25019000000000000000" }, "57a852fdb9b1405bf53ccf9508f83299d3206c52": { "balance": "2000000000000000000000" }, "747abc9649056d3926044d28c3ad09ed17b67d70": { "balance": "5000057000000000000000" }, "5c29f9e9a523c1f8669448b55c48cbd47c25e610": { "balance": "964320000000000000000" }, "30a9da72574c51e7ee0904ba1f73a6b7b83b9b9d": { "balance": "20200000000000000000" }, "220e2b92c0f6c902b513d9f1e6fab6a8b0def3d7": { "balance": "800000000000000000000" }, "5af7c072b2c5acd71c76addcce535cf7f8f93585": { "balance": "20000000000000000000" }, "81556db27349ab8b27004944ed50a46e941a0f5f": { "balance": "3998000000000000000000" }, "987618c85656207c7bac1507c0ffefa2fb64b092": { "balance": "64419000000000000000" }, "e0f372347c96b55f7d4306034beb83266fd90966": { "balance": "400000000000000000000" }, "71784c105117c1f68935797fe159abc74e43d16a": { "balance": "2001600000000000000000" }, "9284f96ddb47b5186ee558aa31324df5361c0f73": { "balance": "16000000000000000000000" }, "a60c1209754f5d87b181da4f0817a81859ef9fd8": { "balance": "50000000000000000000" }, "5afda9405c8e9736514574da928de67456010918": { "balance": "6008500000000000000000" }, "6978696d5150a9a263513f8f74c696f8b1397cab": { "balance": "6640000000000000000000" }, "a9ad1926bc66bdb331588ea8193788534d982c98": { "balance": "30000000000000000000000" }, "e3f80b40fb83fb97bb0d5230af4f6ed59b1c7cc8": { "balance": "1337000000000000000000" }, "e207578e1f4ddb8ff6d5867b39582d71b9812ac5": { "balance": "3880000000000000000000" }, "86883d54cd3915e549095530f9ab1805e8c5432d": { "balance": "4000000000000000000000" }, "6974c8a414ceaefd3c2e4dfdbef430568d9a960b": { "balance": "334250000000000000000" }, "532d32b00f305bcc24dcef56817d622f34fb2c24": { "balance": "1800000000000000000000" }, "761f8a3a2af0a8bdbe1da009321fb29764eb62a1": { "balance": "10000000000000000000000" }, "4677b04e0343a32131fd6abb39b1b6156bba3d5b": { "balance": "200000000000000000000" }, "ef69781f32ffce33346f2c9ae3f08493f3e82f89": { "balance": "18200000000000000000" }, "e3b3d2c9bf570be6a2f72adca1862c310936a43c": { "balance": "100100000000000000000" }, "d19caf39bb377fdf2cf19bd4fb52591c2631a63c": { "balance": "1000000000000000000000" }, "5d68324bcb776d3ffd0bf9fea91d9f037fd6ab0f": { "balance": "2000000000000000000000" }, "1c99fe9bb6c6d1066d912099547fd1f4809eacd9": { "balance": "2000000000000000000000" }, "bbfe0a830cace87b7293993a7e9496ce64f8e394": { "balance": "6000000000000000000000" }, "26c0054b700d3a7c2dcbe275689d4f4cad16a335": { "balance": "2000000000000000000000" }, "7d7e7c61779adb7706c94d32409a2bb4e994bf60": { "balance": "865992000000000000000" }, "d037d215d11d1df3d54fbd321cd295c5465e273b": { "balance": "1400000000000000000000" }, "08166f02313feae18bb044e7877c808b55b5bf58": { "balance": "1970000000000000000000" }, "781b1501647a2e06c0ed43ff197fccec35e1700b": { "balance": "3000000000000000000000" }, "74316adf25378c10f576d5b41a6f47fa98fce33d": { "balance": "336082000000000000000" }, "44e2fdc679e6bee01e93ef4a3ab1bcce012abc7c": { "balance": "410231000000000000000" }, "178eaf6b8554c45dfde16b78ce0c157f2ee31351": { "balance": "320000000000000000000" }, "cf923a5d8fbc3d01aa079d1cfe4b43ce071b1611": { "balance": "2000000000000000000000" }, "0c28847e4f09dfce5f9b25af7c4e530f59c880fe": { "balance": "1000000000000000000000" }, "54ce88275956def5f9458e3b95decacd484021a0": { "balance": "2000000000000000000000" }, "9d4213339a01551861764c87a93ce8f85f87959a": { "balance": "200000000000000000000" }, "e559b5fd337b9c5572a9bf9e0f2521f7d446dbe4": { "balance": "200000000000000000000" }, "dcb03bfa6c1131234e56b7ea7c4f721487546b7a": { "balance": "1337000000000000000000" }, "db6ff71b3db0928f839e05a7323bfb57d29c87aa": { "balance": "910000000000000000000" }, "eb7c202b462b7cc5855d7484755f6e26ef43a115": { "balance": "2000000000000000000000" }, "323486ca64b375474fb2b759a9e7a135859bd9f6": { "balance": "400000000000000000000" }, "2c1df8a76f48f6b54bcf9caf56f0ee1cf57ab33d": { "balance": "10118000000000000000000" }, "2cd87866568dd81ad47d9d3ad0846e5a65507373": { "balance": "400000000000000000000" }, "8566610901aace38b83244f3a9c831306a67b9dc": { "balance": "3256000000000000000000" }, "1c257ad4a55105ea3b58ed374b198da266c85f63": { "balance": "10000000000000000000000" }, "cf4f1138f1bd6bf5b6d485cce4c1017fcb85f07d": { "balance": "882038000000000000000" }, "c934becaf71f225f8b4a4bf7b197f4ac9630345c": { "balance": "20000000000000000000000" }, "1e2bf4ba8e5ef18d37de6d6ad636c4cae489d0cc": { "balance": "2000000000000000000000" }, "9d78a975b7db5e4d8e28845cfbe7e31401be0dd9": { "balance": "1340000000000000000000" }, "16aa52cb0b554723e7060f21f327b0a68315fea3": { "balance": "250000000000000000000" }, "97e28973b860c567402800fbb63ce39a048a3d79": { "balance": "97000000000000000000" }, "4ac5acad000b8877214cb1ae00eac9a37d59a0fd": { "balance": "4000000000000000000000" }, "01226e0ad8d62277b162621c62c928e96e0b9a8c": { "balance": "2000000000000000000000" }, "479abf2da4d58716fd973a0d13a75f530150260a": { "balance": "20000000000000000000" }, "31d81d526c195e3f10b5c6db52b5e59afbe0a995": { "balance": "264000000000000000000" }, "749087ac0f5a97c6fad021538bf1d6cda18e0daa": { "balance": "1000000000000000000000" }, "1565af837ef3b0bd4e2b23568d5023cd34b16498": { "balance": "393284000000000000000" }, "997d6592a31589acc31b9901fbeb3cc3d65b3215": { "balance": "2000000000000000000000" }, "9d207517422cc0d60de7c237097a4d4fce20940c": { "balance": "500000000000000000000" }, "24b8b446debd1947955dd084f2c544933346d3ad": { "balance": "4324135000000000000000" }, "107a03cf0842dbdeb0618fb587ca69189ec92ff5": { "balance": "1970000000000000000000" }, "7f603aec1759ea5f07c7f8d41a1428fbbaf9e762": { "balance": "20000000000000000000" }, "53a244672895480f4a2b1cdf7da5e5a242ec4dbc": { "balance": "1000000000000000000000" }, "7db4c7d5b797e9296e6382f203693db409449d62": { "balance": "400000000000000000000" }, "2ae82dab92a66389eea1abb901d1d57f5a7cca0b": { "balance": "2000000000000000000000" }, "16bc40215abbd9ae5d280b95b8010b4514ff1292": { "balance": "200000000000000000000" }, "bba4fac3c42039d828e742cde0efffe774941b39": { "balance": "1999946000000000000000" }, "5431ca427e6165a644bae326bd09750a178c650d": { "balance": "2000000000000000000000" }, "dcf33965531380163168fc11f67e89c6f1bc178a": { "balance": "334885000000000000000" }, "65fd02d704a12a4dace9471b0645f962a89671c8": { "balance": "28615000000000000000" }, "135d1719bf03e3f866312479fe338118cd387e70": { "balance": "2000000000000000000000" }, "f3159866c2bc86bba40f9d73bb99f1eee57bb9d7": { "balance": "1000000000000000000000" }, "e3a4621b66004588e31206f718cb00a319889cf0": { "balance": "2000000000000000000000" }, "abcdbc8f1dd13af578d4a4774a62182bedf9f9be": { "balance": "36660000000000000000" }, "9fbe066de57236dc830725d32a02aef9246c6c5e": { "balance": "2000000000000000000000" }, "81cfad760913d3c322fcc77b49c2ae3907e74f6e": { "balance": "197000000000000000000" }, "0ab59d390702c9c059db148eb4f3fcfa7d04c7e7": { "balance": "18200000000000000000" }, "2c2db28c3309375eea3c6d72cd6d0eec145afcc0": { "balance": "2000000000000000000000" }, "08306de51981e7aca1856859b7c778696a6b69f9": { "balance": "3200000000000000000000" }, "f814799f6ddf4dcb29c7ee870e75f9cc2d35326d": { "balance": "1000000000000000000000" }, "ee867d20916bd2e9c9ece08aa04385db667c912e": { "balance": "50000000000000000000000" }, "97a86f01ce3f7cfd4441330e1c9b19e1b10606ef": { "balance": "2000000000000000000000" }, "4c759813ad1386bed27ffae9e4815e3630cca312": { "balance": "2000000000000000000000" }, "8f226096c184ebb40105e08dac4d22e1c2d54d30": { "balance": "306552000000000000000" }, "13acada8980affc7504921be84eb4944c8fbb2bd": { "balance": "1601600000000000000000" }, "122dcfd81addb97d1a0e4925c4b549806e9f3beb": { "balance": "1514954000000000000000" }, "232f525d55859b7d4e608d20487faadb00293135": { "balance": "4000000000000000000000" }, "6f7ac681d45e418fce8b3a1db5bc3be6f06c9849": { "balance": "2000000000000000000000" }, "0c8692eeff2a53d6d1688ed56a9ddbbd68dabba1": { "balance": "2000000000000000000000" }, "6a6337833f8f6a6bf10ca7ec21aa810ed444f4cb": { "balance": "1028200000000000000000" }, "209377b6ad3fe101c9685b3576545c6b1684e73c": { "balance": "1820000000000000000000" }, "560fc08d079f047ed8d7df75551aa53501f57013": { "balance": "7600000000000000000000" }, "8e78f351457d016f4ad2755ec7424e5c21ba6d51": { "balance": "146000000000000000000" }, "2ce11a92fad024ff2b3e87e3b542e6c60dcbd996": { "balance": "4000000000000000000000" }, "8ab839aeaf2ad37cb78bacbbb633bcc5c099dc46": { "balance": "2000000000000000000000" }, "673144f0ec142e770f4834fee0ee311832f3087b": { "balance": "500038000000000000000" }, "ba8a63f3f40de4a88388bc50212fea8e064fbb86": { "balance": "2000000000000000000000" }, "ee899b02cbcb3939cd61de1342d50482abb68532": { "balance": "1760000000000000000000" }, "c2d9eedbc9019263d9d16cc5ae072d1d3dd9db03": { "balance": "20000000000000000000000" }, "355c0c39f5d5700b41d375b3f17851dcd52401f9": { "balance": "3979000000000000000000" }, "8179c80970182cc5b7d82a4df06ea94db63a25f3": { "balance": "727432000000000000000" }, "b388b5dfecd2c5e4b596577c642556dbfe277855": { "balance": "20000000000000000000" }, "a9e28337e6357193d9e2cb236b01be44b81427df": { "balance": "2200000000000000000000" }, "04ba4bb87140022c214a6fac42db5a16dd954045": { "balance": "1000000000000000000000" }, "67c926093e9b8927933810d98222d62e2b8206bb": { "balance": "1910000000000000000000" }, "ed7346766e1a676d0d06ec821867a276a083bf31": { "balance": "4012890000000000000000" }, "92558226b384626cad48e09d966bf1395ee7ea5d": { "balance": "334250000000000000000" }, "bdf693f833c3fe471753184788eb4bfe4adc3f96": { "balance": "1970000000000000000000" }, "4474299d0ee090dc90789a1486489c3d0d645e6d": { "balance": "1000000000000000000000" }, "b1178ad47383c31c8134a1941cbcd474d06244e2": { "balance": "1000000000000000000000" }, "979d681c617da16f21bcaca101ed16ed015ab696": { "balance": "1880000000000000000000" }, "6b20c080606a79c73bd8e75b11717a4e8db3f1c3": { "balance": "299720000000000000000" }, "b85218f342f8012eda9f274e63ce2152b2dcfdab": { "balance": "3100000000000000000000" }, "530b61e42f39426d2408d40852b9e34ab5ebebc5": { "balance": "267400000000000000000" }, "76afc225f4fa307de484552bbe1d9d3f15074c4a": { "balance": "2998800000000000000000" }, "1e783e522ab7df0acaac9eeed3593039e5ac7579": { "balance": "203435800000000000000000" }, "0f7bf6373f771a4601762c4dae5fbbf4fedd9cc9": { "balance": "2000000000000000000000" }, "7a8797690ab77b5470bf7c0c1bba612508e1ac7d": { "balance": "8865000000000000000000" }, "2a2ab6b74c7af1d9476bb5bcb4524797bedc3552": { "balance": "1000000000000000000000" }, "523e140dc811b186dee5d6c88bf68e90b8e096fd": { "balance": "2000000000000000000000" }, "ea8168fbf225e786459ca6bb18d963d26b505309": { "balance": "500000000000000000000" }, "20ff3ede8cadb5c37b48cb14580fb65e23090a7b": { "balance": "42000000000000000000000" }, "e482d255ede56b04c3e8df151f56e9ca62aaa8c2": { "balance": "500000000000000000000" }, "2e0880a34596230720f05ac8f065af8681dcb6c2": { "balance": "100000000000000000000000" }, "c674f28c8afd073f8b799691b2f0584df942e844": { "balance": "2000000000000000000000" }, "b646df98b49442746b61525c81a3b04ba3106250": { "balance": "1970000000000000000000" }, "d55c1c8dfbe1e02cacbca60fdbdd405b09f0b75f": { "balance": "2000000000000000000000" }, "65ebaed27edb9dcc1957aee5f452ac2105a65c0e": { "balance": "43531987000000000000000" }, "f079e1b1265f50e8c8a98ec0c7815eb3aeac9eb4": { "balance": "20094000000000000000" }, "867eba56748a5904350d2ca2a5ce9ca00b670a9b": { "balance": "20000000000000000000000" }, "51ee0cca3bcb10cd3e983722ced8493d926c0866": { "balance": "999972000000000000000" }, "88d541c840ce43cefbaf6d19af6b9859b573c145": { "balance": "170000000000000000000" }, "f851b010f633c40af1a8f06a73ebbaab65077ab5": { "balance": "4400000000000000000000" }, "e0aa69365555b73f282333d1e30c1bbd072854e8": { "balance": "7000000000000000000000" }, "c7b1c83e63203f9547263ef6282e7da33b6ed659": { "balance": "18200000000000000000" }, "af06f5fa6d1214ec43967d1bd4dde74ab814a938": { "balance": "88000000000000000000" }, "991173601947c2084a62d639527e961512579af9": { "balance": "600000000000000000000" }, "7a381122bada791a7ab1f6037dac80432753baad": { "balance": "10000000000000000000000" }, "e766f34ff16f3cfcc97321721f43ddf5a38b0cf4": { "balance": "1550000000000000000000" }, "d785a8f18c38b9bc4ffb9b8fa8c7727bd642ee1c": { "balance": "1000000000000000000000" }, "aebd4f205de799b64b3564b256d42a711d37ef99": { "balance": "1177100000000000000000" }, "a2fa17c0fb506ce494008b9557841c3f641b8cae": { "balance": "20000000000000000000" }, "a8aca748f9d312ec747f8b6578142694c7e9f399": { "balance": "2000000000000000000000" }, "950c68a40988154d2393fff8da7ccda99614f72c": { "balance": "4597943000000000000000" }, "075d15e2d33d8b4fa7dba8b9e607f04a261e340b": { "balance": "1910000000000000000000" }, "3616d448985f5d32aefa8b93a993e094bd854986": { "balance": "205400000000000000000" }, "4bb9655cfb2a36ea7c637a7b859b4a3154e26ebe": { "balance": "16000000000000000000000" }, "84949dba559a63bfc845ded06e9f2d9b7f11ef24": { "balance": "2000000000000000000000" }, "937563d8a80fd5a537b0e66d20a02525d5d88660": { "balance": "2500000000000000000000" }, "b183ebee4fcb42c220e47774f59d6c54d5e32ab1": { "balance": "1604266000000000000000" }, "21e5d77320304c201c1e53b261a123d0a1063e81": { "balance": "86972000000000000000" }, "fa14b566234abee73042c31d21717182cba14aa1": { "balance": "328000000000000000000" }, "2da617695009cc57d26ad490b32a5dfbeb934e5e": { "balance": "20000000000000000000000" }, "3326b88de806184454c40b27f309d9dd6dcfb978": { "balance": "17900000000000000000000" }, "95e6a54b2d5f67a24a4875af75107ca7ea9fd2fa": { "balance": "1337000000000000000000" }, "8db58e406e202df9bc703c480bd8ed248d52a032": { "balance": "2000000000000000000000" }, "f777361a3dd8ab62e5f1b9b047568cc0b555704c": { "balance": "1000000000000000000000" }, "83a93b5ba41bf88720e415790cdc0b67b4af34c4": { "balance": "200000000000000000000" }, "8a1cc5ac111c49bfcfd848f37dd768aa65c88802": { "balance": "10000000000000000000000" }, "52214378b54004056a7cc08c891327798ac6b248": { "balance": "15200000000000000000000" }, "ad80d865b85c34d2e6494b2e7aefea6b9af184db": { "balance": "4000000000000000000000" }, "e7d6240620f42c5edbb2ede6aec43da4ed9b5757": { "balance": "1000000000000000000000" }, "d0e35e047646e759f4517093d6408642517f084d": { "balance": "3939507000000000000000" }, "9340345ca6a3eabdb77363f2586043f29438ce0b": { "balance": "530922000000000000000" }, "6640ccf053555c130ae2b656647ea6e31637b9ab": { "balance": "1970000000000000000000" }, "184d86f3466ae6683b19729982e7a7e1a48347b2": { "balance": "10000000000000000000000" }, "84ec06f24700fe42414cb9897c154c88de2f6132": { "balance": "1337000000000000000000" }, "d1e5e234a9f44266a4a6241a84d7a1a55ad5a7fe": { "balance": "20000000000000000000000" }, "e8a9a41740f44f54c3688b53e1ddd42e43c9fe94": { "balance": "4000000000000000000000" }, "6e3a51db743d334d2fe88224b5fe7c008e80e624": { "balance": "106000000000000000000" }, "3e94df5313fa520570ef232bc3311d5f622ff183": { "balance": "2000000000000000000000" }, "8957727e72cf629020f4e05edf799aa7458062d0": { "balance": "2200000000000000000000" }, "cf5e0eacd1b39d0655f2f77535ef6608eb950ba0": { "balance": "2000000000000000000000" }, "f4aaa3a6163e3706577b49c0767e948a681e16ee": { "balance": "2000000000000000000000" }, "97f1fe4c8083e596212a187728dd5cf80a31bec5": { "balance": "20000000000000000000" }, "57d5fd0e3d3049330ffcdcd020456917657ba2da": { "balance": "1991240000000000000000" }, "49bdbc7ba5abebb6389e91a3285220d3451bd253": { "balance": "1000000000000000000000" }, "ae126b382cf257fad7f0bc7d16297e54cc7267da": { "balance": "300000000000000000000" }, "bbf8616d97724af3def165d0e28cda89b800009a": { "balance": "114063000000000000000" }, "adb948b1b6fefe207de65e9bbc2de98e605d0b57": { "balance": "2000000000000000000000" }, "8a217db38bc35f215fd92906be42436fe7e6ed19": { "balance": "6000000000000000000000" }, "e28b062259e96eeb3c8d4104943f9eb325893cf5": { "balance": "1337000000000000000000" }, "6a6b18a45a76467e2e5d5a2ef911c3e12929857b": { "balance": "82000000000000000000000" }, "cb68ae5abe02dcf8cbc5aa719c25814651af8b85": { "balance": "500000000000000000000" }, "4c7e2e2b77ad0cd6f44acb2861f0fb8b28750ef9": { "balance": "20000000000000000000" }, "58ba1569650e5bbbb21d35d3e175c0d6b0c651a9": { "balance": "500000000000000000000" }, "1eb4bf73156a82a0a6822080c6edf49c469af8b9": { "balance": "1910000000000000000000" }, "4103299671d46763978fa4aa19ee34b1fc952784": { "balance": "200000000000000000000" }, "e321bb4a946adafdade4571fb15c0043d39ee35f": { "balance": "1575212000000000000000" }, "893608751d68d046e85802926673cdf2f57f7cb8": { "balance": "19700000000000000000" }, "70fee08b00c6c2c04a3c625c1ff77caf1c32df01": { "balance": "200000000000000000000" }, "7b0fea1176d52159333a143c294943da36bbddb4": { "balance": "9380000000000000000000" }, "d331c823825a9e5263d052d8915d4dcde07a5c37": { "balance": "564000000000000000000" }, "a45432a6f2ac9d56577b938a37fabac8cc7c461c": { "balance": "1000000000000000000000" }, "764fc46d428b6dbc228a0f5f55c9508c772eab9f": { "balance": "26000000000000000000000" }, "1a95a8a8082e4652e4170df9271cb4bb4305f0b2": { "balance": "50000000000000000000" }, "08c9f1bfb689fdf804d769f82123360215aff93b": { "balance": "1970000000000000000000" }, "1572cdfab72a01ce968e78f5b5448da29853fbdd": { "balance": "5061500000000000000000" }, "379c7166849bc24a02d6535e2def13daeef8aa8d": { "balance": "100000000000000000000" }, "e0a254ac09b9725bebc8e460431dd0732ebcabbf": { "balance": "6000000000000000000000" }, "3225c1ca5f2a9c88156bb7d9cdc44a326653c214": { "balance": "400000000000000000000" }, "84686c7bad762c54b667d59f90943cd14d117a26": { "balance": "20000000000000000000" }, "3d5a8b2b80be8b35d8ecf789b5ed7a0775c5076c": { "balance": "20000000000000000000" }, "2ccf80e21898125eb4e807cd82e09b9d28592f6e": { "balance": "2000000000000000000000" }, "dde969aef34ea87ac299b7597e292b4a0155cc8a": { "balance": "298819000000000000000" }, "19e94e620050aad766b9e1bad931238312d4bf49": { "balance": "2396000000000000000000" }, "959f57fded6ae37913d900b81e5f48a79322c627": { "balance": "255599000000000000000" }, "b9b0a3219a3288d9b35b091b14650b8fe23dce2b": { "balance": "14000000000000000000000" }, "3575c770668a9d179f1ef768c293f80166e2aa3d": { "balance": "474000000000000000000" }, "58f05b262560503ca761c61890a4035f4c737280": { "balance": "8000000000000000000000" }, "3286d1bc657a312c8847d93cb3cb7950f2b0c6e3": { "balance": "20000000000000000000000" }, "1d9e6aaf8019a05f230e5def05af5d889bd4d0f2": { "balance": "133700000000000000000" }, "a375b4bc24a24e1f797593cc302b2f331063fa5c": { "balance": "200000000000000000000" }, "108ba7c2895c50e072dc6f964932d50c282d3034": { "balance": "500000000000000000000" }, "b6b34a263f10c3d2eceb0acc559a7b2ab85ce565": { "balance": "4000000000000000000000" }, "a4d2b429f1ad5349e31704969edc5f25ee8aca10": { "balance": "10000000000000000000000" }, "674adb21df4c98c7a347ac4c3c24266757dd7039": { "balance": "2000000000000000000000" }, "33565ba9da2c03e778ce12294f081dfe81064d24": { "balance": "16000000000000000000000" }, "4ddda7586b2237b053a7f3289cf460dc57d37a09": { "balance": "10000000000000000000000" }, "cc4faac00be6628f92ef6b8cb1b1e76aac81fa18": { "balance": "205410000000000000000" }, "5f99dc8e49e61d57daef606acdd91b4d7007326a": { "balance": "3000000000000000000000" }, "b8a979352759ba09e35aa5935df175bff678a108": { "balance": "20000000000000000000" }, "86fff220e59305c09f483860d6f94e96fbe32f57": { "balance": "42900000000000000000" }, "03e8b084537557e709eae2e1e1a5a6bce1ef8314": { "balance": "20000000000000000000" }, "dda4ff7de491c687df4574dd1b17ff8f246ba3d1": { "balance": "19600000000000000000000" }, "2538532936813c91e653284f017c80c3b8f8a36f": { "balance": "2002000000000000000000" }, "5a82f96cd4b7e2d93d10f3185dc8f43d4b75aa69": { "balance": "1999400000000000000000" }, "86740a46648e845a5d96461b18091ff57be8a16f": { "balance": "98000000000000000000000" }, "7e3f63e13129a221ba1ab06326342cd98b5126ae": { "balance": "1597960000000000000000" }, "1f5f3b34bd134b2781afe5a0424ac5846cdefd11": { "balance": "99000000000000000000" }, "39936c2719450b9420cc2522cf91db01f227c1c1": { "balance": "500000000000000000000" }, "967076a877b18ec15a415bb116f06ef32645dba3": { "balance": "2000000000000000000000" }, "a42908e7fe53980a9abf4044e957a54b70e99cbe": { "balance": "2000000000000000000000" }, "5eb371c407406c427b3b7de271ad3c1e04269579": { "balance": "3000000000000000000000" }, "a570223ae3caa851418a9843a1ac55db4824f4fd": { "balance": "200000000000000000000" }, "764692cccb33405dd0ab0c3379b49caf8e6221ba": { "balance": "20000000000000000000" }, "a365918bfe3f2627b9f3a86775d8756e0fd8a94b": { "balance": "400000000000000000000" }, "069ed0ab7aa77de571f16106051d92afe195f2d0": { "balance": "200000000000000000000" }, "bd432a3916249b4724293af9146e49b8280a7f2a": { "balance": "4000000000000000000000" }, "61c9dce8b2981cb40e98b0402bc3eb28348f03ac": { "balance": "196910000000000000000" }, "8f1fcc3c51e252b693bc5b0ec3f63529fe69281e": { "balance": "6000000000000000000000" }, "55fd08d18064bd202c0ec3d2cce0ce0b9d169c4d": { "balance": "1970000000000000000000" }, "383a7c899ee18bc214969870bc7482f6d8f3570e": { "balance": "10000000000000000000000" }, "b14cc8de33d6338236539a489020ce4655a32bc6": { "balance": "8000000000000000000000" }, "448bf410ad9bbc2fecc4508d87a7fc2e4b8561ad": { "balance": "199955000000000000000" }, "06f7dc8d1b9462cef6feb13368a7e3974b097f9f": { "balance": "2000000000000000000000" }, "9c9f89a3910f6a2ae8a91047a17ab788bddec170": { "balance": "10000000000000000000000" }, "5de598aba344378cab4431555b4f79992dc290c6": { "balance": "1337000000000000000000" }, "87e6034ecf23f8b5639d5f0ea70a22538a920423": { "balance": "328000000000000000000" }, "8b27392206b958cd375d7ef8af2cf8ef0598c0bc": { "balance": "1000000000000000000000" }, "49136fe6e28b7453fcb16b6bbbe9aaacba8337fd": { "balance": "2000000000000000000000" }, "6982fe8a867e93eb4a0bd051589399f2ec9a5292": { "balance": "2000000000000000000000" }, "9fd1052a60506bd1a9ef003afd9d033c267d8e99": { "balance": "1000000000000000000000" }, "d38fa2c4cc147ad06ad5a2f75579281f22a7cc1f": { "balance": "20000000000000000000000" }, "6f794dbdf623daa6e0d00774ad6962737c921ea4": { "balance": "2000000000000000000000" }, "e96b184e1f0f54924ac874f60bbf44707446b72b": { "balance": "2910840000000000000000" }, "b5ba29917c78a1d9e5c5c713666c1e411d7f693a": { "balance": "3100000000000000000000" }, "81d619ff5726f2405f12904c72eb1e24a0aaee4f": { "balance": "20000000000000000000000" }, "b02fa29387ec12e37f6922ac4ce98c5b09e0b00f": { "balance": "2000000000000000000000" }, "b7230d1d1ff2aca366963914a79df9f7c5ea2c98": { "balance": "8000000000000000000000" }, "7b4007c45e5a573fdbb6f8bd746bf94ad04a3c26": { "balance": "15202564000000000000000" }, "8d9a0c70d2262042df1017d6c303132024772712": { "balance": "2000000000000000000000" }, "323aad41df4b6fc8fece8c93958aa901fa680843": { "balance": "970000000000000000000" }, "db04fad9c49f9e880beb8fcf1d3a3890e4b3846f": { "balance": "1242482000000000000000" }, "27824666d278d70423f03dfe1dc7a3f02f43e2b5": { "balance": "1000070000000000000000" }, "e04920dc6ecc1d6ecc084f88aa0af5db97bf893a": { "balance": "182000000000000000000" }, "b0c1b177a220e41f7c74d07cde8569c21c75c2f9": { "balance": "5600000000000000000000" }, "7864dc999fe4f8e003c0f43decc39aae1522dc0f": { "balance": "94400000000000000000" }, "c75c37ce2da06bbc40081159c6ba0f976e3993b1": { "balance": "1078640000000000000000" }, "179a825e0f1f6e985309668465cffed436f6aea9": { "balance": "20000000000000000000" }, "2c6b699d9ead349f067f45711a074a641db6a897": { "balance": "20000000000000000000" }, "068ce8bd6e902a45cb83b51541b40f39c4469712": { "balance": "5240000000000000000000" }, "767ac690791c2e23451089fe6c7083fe55deb62b": { "balance": "820000000000000000000" }, "b34f04b8db65bba9c26efc4ce6efc50481f3d65d": { "balance": "20000000000000000000000" }, "29aef48de8c9fbad4b9e4ca970797a5533eb722d": { "balance": "10000000000000000000000" }, "0a0ecda6636f7716ef1973614687fd89a820a706": { "balance": "394000000000000000000" }, "b32825d5f3db249ef4e85cc4f33153958976e8bc": { "balance": "501375000000000000000" }, "7ef16fd8d15b378a0fba306b8d03dd98fc92619f": { "balance": "700000000000000000000" }, "b58b52865ea55d8036f2fab26098b352ca837e18": { "balance": "18200000000000000000" }, "9b658fb361e046d4fcaa8aef6d02a99111223625": { "balance": "2000000000000000000000" }, "b2a498f03bd7178bd8a789a00f5237af79a3e3f8": { "balance": "19400000000000000000000" }, "cb48fe8265d9af55eb7006bc335645b0a3a183be": { "balance": "3000000000000000000000" }, "3cf9a1d465e78b7039e3694478e2627b36fcd141": { "balance": "1372000000000000000000" }, "5db84400570069a9573cab04b4e6b69535e202b8": { "balance": "9700000000000000000000" }, "214c89c5bd8e7d22bc574bb35e48950211c6f776": { "balance": "18903000000000000000" }, "53396f4a26c2b4604496306c5442e7fcba272e36": { "balance": "20055000000000000000000" }, "720994dbe56a3a95929774e20e1fe525cf3704e4": { "balance": "8000000000000000000000" }, "3571cf7ad304ecaee595792f4bbfa484418549d6": { "balance": "5825500000000000000000" }, "6042c644bae2b96f25f94d31f678c90dc96690db": { "balance": "2000000000000000000000" }, "2e24b597873bb141bdb237ea8a5ab747799af02d": { "balance": "20000000000000000000000" }, "08c802f87758349fa03e6bc2e2fd0791197eea9a": { "balance": "2000000000000000000000" }, "297a88921b5fca10e5bb9ded60025437ae221694": { "balance": "200000000000000000000" }, "aee49d68adedb081fd43705a5f78c778fb90de48": { "balance": "20000000000000000000" }, "4cee901b4ac8b156c5e2f8a6f1bef572a7dceb7e": { "balance": "1000000000000000000000" }, "dfaf31e622c03d9e18a0ddb8be60fbe3e661be0a": { "balance": "9999800000000000000000" }, "00aa5381b2138ebeffc191d5d8c391753b7098d2": { "balance": "990049000000000000000" }, "5b4c0c60f10ed2894bdb42d9dd1d210587810a0d": { "balance": "500000000000000000000" }, "c44f4ab5bc60397c737eb0683391b633f83c48fa": { "balance": "1000000000000000000000" }, "50bef2756248f9a7a380f91b051ba3be28a649ed": { "balance": "1999884000000000000000" }, "1bd909ac0d4a1102ec98dcf2cca96a0adcd7a951": { "balance": "20055000000000000000" }, "9ec03e02e587b7769def538413e97f7e55be71d8": { "balance": "19700000000000000000000" }, "9874803fe1f3a0365e7922b14270eaeb032cc1b5": { "balance": "1124500000000000000000" }, "4e2310191ead8d3bc6489873a5f0c2ec6b87e1be": { "balance": "1000000000000000000000" }, "93678a3c57151aeb68efdc43ef4d36cb59a009f3": { "balance": "30060000000000000000" }, "f483f607a21fcc28100a018c568ffbe140380410": { "balance": "1000000000000000000000" }, "2a91a9fed41b7d0e5cd2d83158d3e8a41a9a2d71": { "balance": "1940000000000000000000" }, "240e559e274aaef0c258998c979f671d1173b88b": { "balance": "4000000000000000000000" }, "108a2b7c336f784779d8b54d02a8d31d9a139c0a": { "balance": "10000000000000000000000" }, "9c98fdf1fdcd8ba8f4c5b04c3ae8587efdf0f6e6": { "balance": "6000000000000000000000" }, "194ff44aefc17bd20efd7a204c47d1620c86db5d": { "balance": "2999400000000000000000" }, "1f8116bd0af5570eaf0c56c49c7ab5e37a580458": { "balance": "2000000000000000000000" }, "d79835e404fb86bf845fba090d6ba25e0c8866a6": { "balance": "2400000000000000000000" }, "a8e7201ff619faffc332e6ad37ed41e301bf014a": { "balance": "600000000000000000000" }, "286906b6bd4972e3c71655e04baf36260c7cb153": { "balance": "340000000000000000000" }, "db4bc83b0e6baadb1156c5cf06e0f721808c52c7": { "balance": "880000000000000000000" }, "a158148a2e0f3e92dc2ce38febc20107e3253c96": { "balance": "2000000000000000000000" }, "9f6a322a6d469981426ae844865d7ee0bb15c7b3": { "balance": "50003000000000000000" }, "32f29e8727a74c6b4301e3ffff0687c1b870dae9": { "balance": "1000000000000000000000" }, "19918aa09e7d494e98ffa5db50350892f7156ac6": { "balance": "10000000000000000000000" }, "5a5f8508da0ebebb90be9033bd4d9e274105ae00": { "balance": "6685000000000000000000" }, "6fc25e7e00ca4f60a9fe6f28d1fde3542e2d1079": { "balance": "792000000000000000000" }, "72094f3951ffc9771dced23ada080bcaf9c7cca7": { "balance": "6000000000000000000000" }, "43f7e86e381ec51ec4906d1476cba97a3db584e4": { "balance": "1000000000000000000000" }, "05696b73916bd3033e05521e3211dfec026e98e4": { "balance": "2000000000000000000000" }, "5e7f70378775589fc66a81d3f653e954f55560eb": { "balance": "2434000000000000000000" }, "895613236f3584216ad75c5d3e07e3fa6863a778": { "balance": "2000000000000000000000" }, "4eb1454b573805c8aca37edec7149a41f61202f4": { "balance": "300000000000000000000" }, "d99999a2490d9494a530cae4daf38554f4dd633e": { "balance": "120000000000000000000" }, "1704cefcfb1331ec7a78388b29393e85c1af7916": { "balance": "400000000000000000000" }, "ac4acfc36ed6094a27e118ecc911cd473e8fb91f": { "balance": "1799800000000000000000" }, "a975b077fcb4cc8efcbf838459b6fa243a4159d6": { "balance": "40000000000000000000" }, "9c405cf697956138065e11c5f7559e67245bd1a5": { "balance": "200000000000000000000" }, "cafde855864c2598da3cafc05ad98df2898e8048": { "balance": "14179272000000000000000" }, "8ef711e43a13918f1303e81d0ea78c9eefd67eb2": { "balance": "4000000000000000000000" }, "0b14891999a65c9ef73308efe3100ca1b20e8192": { "balance": "800000000000000000000" }, "47cf9cdaf92fc999cc5efbb7203c61e4f1cdd4c3": { "balance": "131400000000000000000" }, "04ba8a3f03f08b895095994dda619edaacee3e7a": { "balance": "2000000000000000000000" }, "02b6d65cb00b7b36e1fb5ed3632c4cb20a894130": { "balance": "20000000000000000000000" }, "f99aee444b5783c093cfffd1c4632cf93c6f050c": { "balance": "400000000000000000000" }, "2541314a0b408e95a694444977712a50713591ab": { "balance": "1634706000000000000000" }, "3096dca34108085bcf04ae72b94574a13e1a3e1d": { "balance": "200000000000000000000" }, "56df05bad46c3f00ae476ecf017bb8c877383ff1": { "balance": "197248000000000000000" }, "6d59b21cd0e2748804d9abe064eac2bef0c95f27": { "balance": "2000000000000000000000" }, "b29f5b7c1930d9f97a115e067066f0b54db44b3b": { "balance": "1000000000000000000000" }, "888c16144933197cac26504dd76e06fd6600c789": { "balance": "100000000000000000000" }, "dfe3c52a92c30396a4e33a50170dc900fcf8c9cf": { "balance": "50000000000000000000" }, "f76f69cee4faa0a63b30ae1e7881f4f715657010": { "balance": "200000000000000000000" }, "ee0007b0960d00908a94432a737557876aac7c31": { "balance": "53053000000000000000" }, "effc15e487b1beda0a8d1325bdb4172240dc540a": { "balance": "64940000000000000000" }, "40ab0a3e83d0c8ac9366910520eab1772bac3b1a": { "balance": "976600000000000000000" }, "1895a0eb4a4372722fcbc5afe6936f289c88a419": { "balance": "910000000000000000000" }, "81efe296ae76c860d1c5fbd33d47e8ce9996d157": { "balance": "1000000000000000000000" }, "9ddd355e634ee9927e4b7f6c97e7bf3a2f1e687a": { "balance": "50000000000000000000" }, "f2b4ab2c9427a9015ef6eefff5edb60139b719d1": { "balance": "716800000000000000000" }, "765be2e12f629e6349b97d21b62a17b7c830edab": { "balance": "6000000000000000000000" }, "ff61c9c1b7a3d8b53bba20b34466544b7b216644": { "balance": "2000000000000000000000" }, "36a08fd6fd1ac17ce15ed57eefb12a2be28188bf": { "balance": "1337000000000000000000" }, "17049311101d817efb1d65910f663662a699c98c": { "balance": "1999800000000000000000" }, "30511832918d8034a7bee72ef2bfee440ecbbcf6": { "balance": "16100000000000000000000" }, "d27c234ff7accace3d996708f8f9b04970f97d36": { "balance": "1337000000000000000000" }, "a961171f5342b173dd70e7bfe5b5ca238b13bcdd": { "balance": "3397053000000000000000" }, "30bf61b2d877fe10635126326fa189e4b0b1c3b0": { "balance": "1027580000000000000000" }, "4bb6d86b8314c22d8d37ea516d0019f156aae12d": { "balance": "1000000000000000000000" }, "5f363e0ab747e02d1b3b66abb69ea53c7baf523a": { "balance": "11640000000000000000000" }, "283e11203749b1fa4f32febb71e49d135919382a": { "balance": "1000000000000000000000" }, "ac5999a89d2dd286d5a80c6dee7e86aad40f9e12": { "balance": "3880000000000000000000" }, "3f6dd3650ee428dcb7759553b017a96a94286ac9": { "balance": "1337000000000000000000" }, "b3fc1d6881abfcb8becc0bb021b8b73b7233dd91": { "balance": "50000000000000000000" }, "f0832a6bb25503eeca435be31b0bf905ca1fcf57": { "balance": "6685000000000000000000" }, "9d7fda7070bf3ee9bbd9a41f55cad4854ae6c22c": { "balance": "11027380000000000000000" }, "4b0bd8acfcbc53a6010b40d4d08ddd2d9d69622d": { "balance": "668500000000000000000" }, "f3b668b3f14d920ebc379092db98031b67b219b3": { "balance": "199955000000000000000" }, "d91d889164479ce436ece51763e22cda19b22d6b": { "balance": "3365200000000000000000" }, "ffe28db53c9044b4ecd4053fd1b4b10d7056c688": { "balance": "100000000000000000000" }, "c77b01a6e911fa988d01a3ab33646beef9c138f3": { "balance": "721400000000000000000" }, "c0064f1d9474ab915d56906c9fb320a2c7098c9b": { "balance": "358000000000000000000" }, "4e3edad4864dab64cae4c5417a76774053dc6432": { "balance": "590943000000000000000" }, "71d2cc6d02578c65f73c575e76ce8fbcfadcf356": { "balance": "72400000000000000000" }, "9971df60f0ae66dce9e8c84e17149f09f9c52f64": { "balance": "200000000000000000000" }, "58e661d0ba73d6cf24099a5562b808f7b3673b68": { "balance": "2000000000000000000000" }, "84b0ee6bb837d3a4c4c5011c3a228c0edab4634a": { "balance": "20000000000000000000" }, "84375afbf59b3a1d61a1be32d075e0e15a4fbca5": { "balance": "200000000000000000000" }, "9ae9476bfecd3591964dd325cf8c2a24faed82c1": { "balance": "4000000000000000000000" }, "6a4c8907b600248057b1e46354b19bdc859c991a": { "balance": "20000000000000000000" }, "1c045649cd53dc23541f8ed4d341812808d5dd9c": { "balance": "7000000000000000000000" }, "c5e488cf2b5677933971f64cb8202dd05752a2c0": { "balance": "1000000000000000000000" }, "eb25481fcd9c221f1ac7e5fd1ecd9307a16215b8": { "balance": "197000000000000000000" }, "a61887818f914a20e31077290b83715a6b2d6ef9": { "balance": "1880000000000000000000" }, "679437eacf437878dc293d48a39c87b7421a216c": { "balance": "64528000000000000000" }, "331a1c26cc6994cdd3c14bece276ffff4b9df77c": { "balance": "18049000000000000000" }, "75b95696e8ec4510d56868a7c1a735c68b244890": { "balance": "6400000000000000000000" }, "a77f3ee19e9388bbbb2215c62397b96560132360": { "balance": "200000000000000000000" }, "bc7afc8477412274fc265df13c054473427d43c6": { "balance": "130034000000000000000" }, "91050a5cffadedb4bb6eaafbc9e5013428e96c80": { "balance": "1700000000000000000000" }, "24586ec5451735eeaaeb470dc8736aae752f82e5": { "balance": "17600000000000000000" }, "51039377eed0c573f986c5e8a95fb99a59e9330f": { "balance": "1970000000000000000000" }, "fbb161fe875f09290a4b262bc60110848f0d2226": { "balance": "2000000000000000000000" }, "ed52a2cc0869dc9e9f842bd0957c47a8e9b0c9ff": { "balance": "9550000000000000000000" }, "bad235d5085dc7b068a67c412677b03e1836884c": { "balance": "2000000000000000000000" }, "055eac4f1ad3f58f0bd024d68ea60dbe01c6afb3": { "balance": "100000000000000000000" }, "4058808816fdaa3a5fc98ed47cfae6c18315422e": { "balance": "199800000000000000000" }, "3540c7bd7a8442d5bee21a2180a1c4edff1649e0": { "balance": "1239295000000000000000" }, "c5edbbd2ca0357654ad0ea4793f8c5cecd30e254": { "balance": "6000000000000000000000" }, "b5906b0ae9a28158e8ac550e39da086ee3157623": { "balance": "200000000000000000000" }, "4d801093c19ca9b8f342e33cc9c77bbd4c8312cf": { "balance": "345005000000000000000" }, "206482ee6f138a778fe1ad62b180ce856fbb23e6": { "balance": "2000000000000000000000" }, "c0ed0d4ad10de03435b153a0fc25de3b93f45204": { "balance": "3160000000000000000000" }, "29e67990e1b6d52e1055ffe049c53195a81542cf": { "balance": "20000000000000000000000" }, "e6d22209ffd0b87509ade3a8e2ef429879cb89b5": { "balance": "17260000000000000000000" }, "d6644d40e90bc97fe7dfe7cabd3269fd579ba4b3": { "balance": "159000000000000000000" }, "ece1290877b583e361a2d41b009346e6274e2538": { "balance": "300000000000000000000" }, "ab3861226ffec1289187fb84a08ec3ed043264e8": { "balance": "1000000000000000000000" }, "60e0bdd0a259bb9cb09d3f37e5cd8b9daceabf8a": { "balance": "1370000000000000000000" }, "28b77585cb3d55a199ab291d3a18c68fe89a848a": { "balance": "1960000000000000000000" }, "73128173489528012e76b41a5e28c68ba4e3a9d4": { "balance": "1000000000000000000000" }, "018492488ba1a292342247b31855a55905fef269": { "balance": "140000000000000000000" }, "0bb54c72fd6610bfa4363397e020384b022b0c49": { "balance": "1337000000000000000000" }, "520f66a0e2657ff0ac4195f2f064cf2fa4b24250": { "balance": "40000000000000000000" }, "a1432ed2c6b7777a88e8d46d388e70477f208ca5": { "balance": "7999538000000000000000" }, "149ba10f0da2725dc704733e87f5a524ca88515e": { "balance": "7880000000000000000000" }, "b287f7f8d8c3872c1b586bcd7d0aedbf7e732732": { "balance": "20000000000000000000" }, "c46bbdef76d4ca60d316c07f5d1a780e3b165f7e": { "balance": "2000000000000000000000" }, "b5a589dd9f4071dbb6fba89b3f5d5dae7d96c163": { "balance": "2000000000000000000000" }, "d218efb4db981cdd6a797f4bd48c7c26293ceb40": { "balance": "2975000000000000000000" }, "af87d2371ef378957fbd05ba2f1d66931b01e2b8": { "balance": "700000000000000000000" }, "86ef6426211949cc37f4c75e7850369d0cf5f479": { "balance": "13399196000000000000000" }, "fb3a0b0d6b6a718f6fc0292a825dc9247a90a5d0": { "balance": "199950000000000000000" }, "da16dd5c3d1a2714358fe3752cae53dbab2be98c": { "balance": "19400000000000000000000" }, "9eb7834e171d41e069a77947fca87622f0ba4e48": { "balance": "100000000000000000000" }, "e1d91b0954cede221d6f24c7985fc59965fb98b8": { "balance": "2000000000000000000000" }, "85d0d88754ac84b8b21ba93dd2bfec72626faba8": { "balance": "1000000000000000000000" }, "695b4cce085856d9e1f9ff3e79942023359e5fbc": { "balance": "5000000000000000000000" }, "9156d18029350e470408f15f1aa3be9f040a67c6": { "balance": "1000000000000000000000" }, "a9d64b4f3bb7850722b58b478ba691375e224e42": { "balance": "6000000000000000000000" }, "17e4a0e52bac3ee44efe0954e753d4b85d644e05": { "balance": "2000000000000000000000" }, "b8a79c84945e47a9c3438683d6b5842cff7684b1": { "balance": "2000000000000000000000" }, "cfac2e1bf33205b05533691a02267ee19cd81836": { "balance": "1000000000000000000000" }, "6b992521ec852370848ad697cc2df64e63cc06ff": { "balance": "1000000000000000000000" }, "60af0ee118443c9b37d2fead77f5e521debe1573": { "balance": "1910000000000000000000" }, "c6dbdb9efd5ec1b3786e0671eb2279b253f215ed": { "balance": "1000000000000000000000" }, "659c0a72c767a3a65ced0e1ca885a4c51fd9b779": { "balance": "2000000000000000000000" }, "ed1276513b6fc68628a74185c2e20cbbca7817bf": { "balance": "191000000000000000000" }, "5ad12c5ed4fa827e2150cfa0d68c0aa37b1769b8": { "balance": "800000000000000000000" }, "17c0fef6986cfb2e4041f9979d9940b69dff3de2": { "balance": "4000000000000000000000" }, "ca98c7988efa08e925ef9c9945520326e9f43b99": { "balance": "4000000000000000000000" }, "fe8f1fdcab7fbec9a6a3fcc507619600505c36a3": { "balance": "19700000000000000000" }, "4420aa35465be617ad2498f370de0a3cc4d230af": { "balance": "2000000000000000000000" }, "8232d1f9742edf8dd927da353b2ae7b4cbce7592": { "balance": "668500000000000000000" }, "eca5f58792b8c62d2af556717ee3ee3028be4dce": { "balance": "2000000000000000000000" }, "6bf86f1e2f2b8032a95c4d7738a109d3d0ed8104": { "balance": "1820000000000000000000" }, "3ac2f0ff1612e4a1c346d53382abf6d8a25baa53": { "balance": "2000000000000000000000" }, "daa1bd7a9148fb865cd612dd35f162861d0f3bdc": { "balance": "3066243000000000000000" }, "5169c60aee4ceed1849ab36d664cff97061e8ea8": { "balance": "3000000000000000000000" }, "2a5e3a40d2cd0325766de73a3d671896b362c73b": { "balance": "100000000000000000000000" }, "a83382b6e15267974a8550b98f7176c1a353f9be": { "balance": "3541608000000000000000" }, "b50c149a1906fad2786ffb135aab501737e9e56f": { "balance": "388000000000000000000" }, "d9775965b716476675a8d513eb14bbf7b07cd14a": { "balance": "5076200000000000000000" }, "66662006015c1f8e3ccfcaebc8ee6807ee196303": { "balance": "500024000000000000000" }, "78746a958dced4c764f876508c414a68342cecb9": { "balance": "50600000000000000000" }, "e982e6f28c548f5f96f45e63f7ab708724f53fa1": { "balance": "396238000000000000000" }, "740bfd52e01667a3419b029a1b8e45576a86a2db": { "balance": "16800000000000000000000" }, "2bd252e0d732ff1d7c78f0a02e6cb25423cf1b1a": { "balance": "2674000000000000000000" }, "2e2d7ea66b9f47d8cc52c01c52b6e191bc7d4786": { "balance": "3999800000000000000000" }, "3e3161f1ea2fbf126e79da1801da9512b37988c9": { "balance": "49250000000000000000000" }, "7e2ba86da52e785d8625334f3397ba1c4bf2e8d1": { "balance": "197000000000000000000" }, "7608f437b31f18bc0b64d381ae86fd978ed7b31f": { "balance": "50000000000000000000" }, "25a5a44d38a2f44c6a9db9cdbc6b1e2e97abb509": { "balance": "17000000000000000000000" }, "745ad3abc6eeeb2471689b539e789ce2b8268306": { "balance": "1129977000000000000000" }, "09e437d448861228a232b62ee8d37965a904ed9c": { "balance": "21708305000000000000000" }, "be53322f43fbb58494d7cce19dda272b2450e827": { "balance": "200018000000000000000" }, "4166fc08ca85f766fde831460e9dc93c0e21aa6c": { "balance": "1000000000000000000000" }, "99c0174cf84e0783c220b4eb6ae18fe703854ad3": { "balance": "2074800000000000000000" }, "3cf484524fbdfadae26dc185e32b2b630fd2e726": { "balance": "448798000000000000000" }, "fdcd5d80b105897a57abc47865768b2900524295": { "balance": "6400000000000000000000" }, "f22f4078febbbaa8b0e78e642c8a42f35d433905": { "balance": "1999944000000000000000" }, "eac768bf14b8f9432e69eaa82a99fbeb94cd0c9c": { "balance": "98500000000000000000000" }, "2639eee9873ceec26fcc9454b548b9e7c54aa65c": { "balance": "1000000000000000000000" }, "c3c3c2510d678020485a63735d1307ec4ca6302b": { "balance": "1000000000000000000000" }, "b73d6a77559c86cf6574242903394bacf96e3570": { "balance": "91200000000000000000" }, "5ce2e7ceaaa18af0f8aafa7fbad74cc89e3cd436": { "balance": "20000000000000000000000" }, "03377c0e556b640103289a6189e1aeae63493467": { "balance": "20000000000000000000000" }, "6eb0a5a9ae96d22cf01d8fd6483b9f38f08c2c8b": { "balance": "4000000000000000000000" }, "fc8215a0a69913f62a43bf1c8590b9ddcd0d8ddb": { "balance": "2000000000000000000000" }, "4a835c25824c47ecbfc79439bf3f5c3481aa75cd": { "balance": "1400000000000000000000" }, "b5493ef173724445cf345c035d279ba759f28d51": { "balance": "20000000000000000000" }, "b9e90c1192b3d5d3e3ab0700f1bf655f5dd4347a": { "balance": "499928000000000000000" }, "419bde7316cc1ed295c885ace342c79bf7ee33ea": { "balance": "6000000000000000000000" }, "e4625501f52b7af52b19ed612e9d54fdd006b492": { "balance": "209440000000000000000" }, "e9d599456b2543e6db80ea9b210e908026e2146e": { "balance": "200000000000000000000" }, "2c06dd922b61514aafedd84488c0c28e6dcf0e99": { "balance": "100000000000000000000000" }, "06b5ede6fdf1d6e9a34721379aeaa17c713dd82a": { "balance": "2000000000000000000000" }, "d8930a39c77357c30ad3a060f00b06046331fd62": { "balance": "820000000000000000000" }, "b2a2c2111612fb8bbb8e7dd9378d67f1a384f050": { "balance": "20000000000000000000" }, "1f174f40a0447234e66653914d75bc003e5690dc": { "balance": "160000000000000000000" }, "e06cb6294704eea7437c2fc3d30773b7bf38889a": { "balance": "20094000000000000000" }, "cd06f8c1b5cdbd28e2d96b6346c3e85a0483ba24": { "balance": "1000000000000000000000" }, "f316ef1df2ff4d6c1808dba663ec8093697968e0": { "balance": "1794400000000000000000" }, "1e6915ebd9a19c81b692ad99b1218a592c1ac7b1": { "balance": "4000000000000000000000" }, "885493bda36a0432976546c1ddce71c3f4570021": { "balance": "216700000000000000000" }, "18b0407cdad4ce52600623bd5e1f6a81ab61f026": { "balance": "319489000000000000000" }, "187d9f0c07f8eb74faaad15ebc7b80447417f782": { "balance": "20000000000000000000" }, "5d6ccf806738091042ad97a6e095fe8c36aa79c5": { "balance": "188000000000000000000" }, "53437fecf34ab9d435f4deb8ca181519e2592035": { "balance": "188000000000000000000" }, "fd1faa347b0fcc804c2da86c36d5f1d18b7087bb": { "balance": "52380000000000000000" }, "650cf67db060cce17568d5f2a423687c49647609": { "balance": "100000000000000000000" }, "bcd95ef962462b6edfa10fda87d72242fe3edb5c": { "balance": "334133000000000000000" }, "3b5e8b3c77f792decb7a8985df916efb490aac23": { "balance": "2000000000000000000000" }, "f13b083093ba564e2dc631568cf7540d9a0ec719": { "balance": "1999944000000000000000" }, "373c547e0cb5ce632e1c5ad66155720c01c40995": { "balance": "4691588000000000000000" }, "7313461208455455465445a459b06c3773b0eb30": { "balance": "2000000000000000000000" }, "441f37e8a029fd02482f289c49b5d06d00e408a4": { "balance": "333333000000000000000" }, "d30d4c43adcf55b2cb53d68323264134498d89ce": { "balance": "1000000000000000000000" }, "f648ea89c27525710172944e79edff847803b775": { "balance": "100000000000000000000000" }, "0c7f869f8e90d53fdc03e8b2819b016b9d18eb26": { "balance": "20000000000000000000000" }, "c71f92a3a54a7b8c2f5ea44305fccb84eee23148": { "balance": "49980000000000000000" }, "7988901331e387f713faceb9005cb9b65136eb14": { "balance": "1970000000000000000000" }, "e9a39a8bac0f01c349c64cedb69897f633234ed2": { "balance": "3980000000000000000000" }, "ad2a5c00f923aaf21ab9f3fb066efa0a03de2fb2": { "balance": "999996000000000000000" }, "f25259a5c939cd25966c9b6303d3731c53ddbc4c": { "balance": "200000000000000000000" }, "d1682c2159018dc3d07f08240a8c606daf65f8e1": { "balance": "200000000000000000000000" }, "a99991cebd98d9c838c25f7a7416d9e244ca250d": { "balance": "1000000000000000000000" }, "5a285755391e914e58025faa48cc685f4fd4f5b8": { "balance": "26000000000000000000000" }, "4d24b7ac47d2f27de90974ba3de5ead203544bcd": { "balance": "100000000000000000000" }, "21b182f2da2b384493cf5f35f83d9d1ee14f2a21": { "balance": "2000000000000000000000" }, "31ab088966ecc7229258f6098fce68cf39b38485": { "balance": "1000000000000000000000" }, "4977a7939d0939689455ce2639d0ee5a4cd910ed": { "balance": "1820000000000000000000" }, "07af938c1237a27c9030094dcf240750246e3d2c": { "balance": "500000000000000000000" }, "4e2bfa4a466f82671b800eee426ad00c071ba170": { "balance": "4000000000000000000000" }, "107379d4c467464f235bc18e55938aad3e688ad7": { "balance": "50000000000000000000" }, "f7b29b82195c882dab7897c2ae95e77710f57875": { "balance": "2199000000000000000000" }, "56586391040c57eec6f5affd8cd4abde10b50acc": { "balance": "4000000000000000000000" }, "ac608e2bac9dd20728d2947effbbbf900a9ce94b": { "balance": "6000600000000000000000" }, "48548b4ba62bcb2f0d34a88dc69a680e539cf046": { "balance": "100084000000000000000" }, "1665ab1739d71119ee6132abbd926a279fe67948": { "balance": "100000000000000000000" }, "af4493e8521ca89d95f5267c1ab63f9f45411e1b": { "balance": "200000000000000000000" }, "bf6925c00751008440a6739a02bf2b6cdaab5e3a": { "balance": "1000000000000000000000" }, "3fe40fbd919aad2818df01ee4df46c46842ac539": { "balance": "6000000000000000000000" }, "455b9296921a74d1fc41617f43b8303e6f3ed76c": { "balance": "4200000000000000000000" }, "7086b4bde3e35d4aeb24b825f1a215f99d85f745": { "balance": "1999800000000000000000" }, "d4ee4919fb37f2bb970c3fff54aaf1f3dda6c03f": { "balance": "40000000000000000000000" }, "a4489a50ead5d5445a7bee4d2d5536c2a76c41f8": { "balance": "200000000000000000000" }, "505e4f7c275588c533a20ebd2ac13b409bbdea3c": { "balance": "17600000000000000000" }, "3bb53598cc20e2055dc553b049404ac9b7dd1e83": { "balance": "615020000000000000000" }, "52cd20403ba7eda6bc307a3d63b5911b817c1263": { "balance": "20000000000000000000" }, "a211da03cc0e31ecce5309998718515528a090df": { "balance": "200000000000000000000" }, "bcb422dc4dd2aae94abae95ea45dd1731bb6b0ba": { "balance": "447500000000000000000" }, "cbde9734b8e6aa538c291d6d7facedb0f338f857": { "balance": "2000000000000000000000" }, "171ca02a8b6d62bf4ca47e906914079861972cb2": { "balance": "200000000000000000000" }, "d40d0055fd9a38488aff923fd03d35ec46d711b3": { "balance": "4999711000000000000000" }, "3887192c7f705006b630091276b39ac680448d6b": { "balance": "60000000000000000000" }, "3f3c8e61e5604cef0605d436dd22accd862217fc": { "balance": "1337000000000000000000" }, "4258fd662fc4ce3295f0d4ed8f7bb1449600a0a9": { "balance": "6719600000000000000000" }, "4571de672b9904bad8743692c21c4fdcea4c2e01": { "balance": "4000000000000000000000" }, "5be045512a026e3f1cebfd5a7ec0cfc36f2dc16b": { "balance": "120000000000000000000" }, "d6300b3215b11de762ecde4b70b7927d01291582": { "balance": "2000000000000000000000" }, "f9e37447406c412197b2e2aebc001d6e30c98c60": { "balance": "8346700000000000000000" }, "bd047ff1e69cc6b29ad26497a9a6f27a903fc4dd": { "balance": "865000000000000000000" }, "23fa7eb51a48229598f97e762be0869652dffc66": { "balance": "1000000000000000000000" }, "6679aeecd87a57a73f3356811d2cf49d0c4d96dc": { "balance": "600000000000000000000" }, "23c55aeb5739876f0ac8d7ebea13be729685f000": { "balance": "1337000000000000000000" }, "757b65876dbf29bf911d4f0692a2c9beb1139808": { "balance": "4124263000000000000000" }, "e8fc36b0131ec120ac9e85afc10ce70b56d8b6ba": { "balance": "200000000000000000000" }, "1a89899cbebdbb64bb26a195a63c08491fcd9eee": { "balance": "2000000000000000000000" }, "6edf7f5283725c953ee64317f66188af1184b033": { "balance": "8050000000000000000000" }, "297385e88634465685c231a314a0d5dcd146af01": { "balance": "1550000000000000000000" }, "018f20a27b27ec441af723fd9099f2cbb79d6263": { "balance": "2167000000000000000000" }, "a5a4227f6cf98825c0d5baff5315752ccc1a1391": { "balance": "10000000000000000000000" }, "69517083e303d4fbb6c2114514215d69bc46a299": { "balance": "100000000000000000000" }, "1dab172effa6fbee534c94b17e794edac54f55f8": { "balance": "1970000000000000000000" }, "c6ee35934229693529dc41d9bb71a2496658b88e": { "balance": "19700000000000000000000" }, "a8ee1df5d44b128469e913569ef6ac81eeda4fc8": { "balance": "500000000000000000000" }, "35bd246865fab490ac087ac1f1d4f2c10d0cda03": { "balance": "400000000000000000000" }, "4bf8bf1d35a231315764fc8001809a949294fc49": { "balance": "66850000000000000000" }, "c70fa45576bf9c865f983893002c414926f61029": { "balance": "400400000000000000000" }, "fdeaac2acf1d138e19f2fc3f9fb74592e3ed818a": { "balance": "668500000000000000000" }, "bfbfbcb656c2992be8fcde8219fbc54aadd59f29": { "balance": "9999924000000000000000" }, "1722c4cbe70a94b6559d425084caeed4d6e66e21": { "balance": "4000000000000000000000" }, "00e681bc2d10db62de85848324492250348e90bf": { "balance": "20000000000000000000000" }, "5c308bac4857d33baea074f3956d3621d9fa28e1": { "balance": "4999711000000000000000" }, "68c08490c89bf0d6b6f320b1aca95c8312c00608": { "balance": "4000000000000000000000" }, "ce1884ddbbb8e10e4dba6e44feeec2a7e5f92f05": { "balance": "4000000000000000000000" }, "427417bd16b1b3d22dbb902d8f9657016f24a61c": { "balance": "2000000000000000000000" }, "5ff93de6ee054cad459b2d5eb0f6870389dfcb74": { "balance": "220000000000000000000" }, "71946b7117fc915ed107385f42d99ddac63249c2": { "balance": "2000000000000000000000" }, "11ec00f849b6319cf51aa8dd8f66b35529c0be77": { "balance": "2000000000000000000000" }, "610fd6ee4eebab10a8c55d0b4bd2e7d6ef817156": { "balance": "20002000000000000000" }, "a422e4bf0bf74147cc895bed8f16d3cef3426154": { "balance": "349281000000000000000" }, "745aecbaf9bb39b74a67ea1ce623de368481baa6": { "balance": "10000000000000000000000" }, "9f496cb2069563144d0811677ba0e4713a0a4143": { "balance": "1122000000000000000000" }, "c500b720734ed22938d78c5e48b2ba9367a575ba": { "balance": "33400000000000000000000" }, "cd072e6e1833137995196d7bb1725fef8761f655": { "balance": "6000000000000000000000" }, "94644ad116a41ce2ca7fbec609bdef738a2ac7c7": { "balance": "5000000000000000000000" }, "e8d942d82f175ecb1c16a405b10143b3f46b963a": { "balance": "568600000000000000000" }, "f73dd9c142b71bce11d06e30e7e7d032f2ec9c9e": { "balance": "1970000000000000000000" }, "1327d759d56e0ab87af37ecf63fe01f310be100a": { "balance": "659200000000000000000" }, "28fa2580f9ebe420f3e5eefdd371638e3b7af499": { "balance": "6000000000000000000000" }, "024bdd2c7bfd500ee7404f7fb3e9fb31dd20fbd1": { "balance": "180000000000000000000" }, "b4b14bf45455d0ab0803358b7524a72be1a2045b": { "balance": "500000000000000000000" }, "b1e2dd95e39ae9775c55aeb13f12c2fa233053ba": { "balance": "2000000000000000000000" }, "35b03ea4245736f57b85d2eb79628f036ddcd705": { "balance": "4000000000000000000000" }, "eb2ef3d38fe652403cd4c9d85ed7f0682cd7c2de": { "balance": "42784000000000000000000" }, "690594d306613cd3e2fd24bca9994ad98a3d73f8": { "balance": "2000000000000000000000" }, "8397a1bc47acd647418159b99cea57e1e6532d6e": { "balance": "9169160000000000000000" }, "b44815a0f28e569d0e921a4ade8fb2642526497a": { "balance": "55500000000000000000" }, "e24109be2f513d87498e926a286499754f9ed49e": { "balance": "886500000000000000000" }, "37ac29bda93f497bc4aeaab935452c431510341e": { "balance": "985000000000000000000" }, "4a81abe4984c7c6bef63d69820e55743c61f201c": { "balance": "16011846000000000000000" }, "66dcc5fb4ee7fee046e141819aa968799d644491": { "balance": "1337000000000000000000" }, "43ff38743ed0cd43308c066509cc8e7e72c862aa": { "balance": "1940000000000000000000" }, "b8f20005b61352ffa7699a1b52f01f5ab39167f1": { "balance": "10000000000000000000000" }, "1cda411bd5163baeca1e558563601ce720e24ee1": { "balance": "18200000000000000000" }, "86245f596691093ece3f3d3ca2263eace81941d9": { "balance": "188000000000000000000" }, "f52a5882e8927d944b359b26366ba2b9cacfbae8": { "balance": "25000080000000000000000" }, "118c18b2dce170e8f445753ba5d7513cb7636d2d": { "balance": "8800000000000000000000" }, "7168b3bb8c167321d9bdb023a6e9fd11afc9afd9": { "balance": "1790000000000000000000" }, "d9103bb6b67a55a7fece2d1af62d457c2178946d": { "balance": "1000000000000000000000" }, "8b9fda7d981fe9d64287f85c94d83f9074849fcc": { "balance": "14000000000000000000000" }, "91211712719f2b084d3b3875a85069f466363141": { "balance": "1000000000000000000000" }, "4863849739265a63b0a2bf236a5913e6f959ce15": { "balance": "1520000000000000000000" }, "c2d1778ef6ee5fe488c145f3586b6ebbe3fbb445": { "balance": "1146000000000000000000" }, "2b77a4d88c0d56a3dbe3bae04a05f4fcd1b757e1": { "balance": "300000000000000000000" }, "fe9c0fffefb803081256c0cf4d6659e6d33eb4fb": { "balance": "1528000000000000000000" }, "893017ff1adad499aa065401b4236ce6e92b625a": { "balance": "1999944000000000000000" }, "073c67e09b5c713c5221c8a0c7f3f74466c347b0": { "balance": "19400000000000000000000" }, "93e303411afaf6c107a44101c9ac5b36e9d6538b": { "balance": "66000000000000000000000" }, "0ec50aa823f465b9464b0bc0c4a57724a555f5d6": { "balance": "59100000000000000000000" }, "a3e3a6ea509573e21bd0239ece0523a7b7d89b2f": { "balance": "1970000000000000000000" }, "c069ef0eb34299abd2e32dabc47944b272334824": { "balance": "120000000000000000000" }, "28a3da09a8194819ae199f2e6d9d1304817e28a5": { "balance": "2000000000000000000000" }, "e9495ba5842728c0ed97be37d0e422b98d69202c": { "balance": "2000000000000000000000" }, "bba976f1a1215f7512871892d45f7048acd356c8": { "balance": "2000000000000000000000" }, "887cac41cd706f3345f2d34ac34e01752a6e5909": { "balance": "595366000000000000000" }, "e0e0b2e29dde73af75987ee4446c829a189c95bc": { "balance": "149000000000000000000" }, "4a5fae3b0372c230c125d6d470140337ab915656": { "balance": "1600000000000000000000" }, "425177eb74ad0a9d9a5752228147ee6d6356a6e6": { "balance": "13370000000000000000" }, "5db7bba1f9573f24115d8c8c62e9ce8895068e9f": { "balance": "49984000000000000000" }, "fa6a37f018e97967937fc5e8617ba1d786dd5f77": { "balance": "19999800000000000000000" }, "45e3a93e72144ada860cbc56ff85145ada38c6da": { "balance": "1610000000000000000000" }, "67da922effa472a6b124e84ea8f86b24e0f515aa": { "balance": "20000000000000000000" }, "aa9bd4589535db27fa2bc903ca17d679dd654806": { "balance": "2000000000000000000000" }, "16a9e9b73ae98b864d1728798b8766dbc6ea8d12": { "balance": "957480000000000000000" }, "d6580ab5ed4c7dfa506fa6fe64ad5ce129707732": { "balance": "4000000000000000000000" }, "984a7985e3cc7eb5c93691f6f8cc7b8f245d01b2": { "balance": "6000000000000000000000" }, "7746b6c6699c8f34ca2768a820f1ffa4c207fe05": { "balance": "4000086000000000000000" }, "2fa491fb5920a6574ebd289f39c1b2430d2d9a6a": { "balance": "2000000000000000000000" }, "fae76719d97eac41870428e940279d97dd57b2f6": { "balance": "98500000000000000000000" }, "41b2dbd79dda9b864f6a7030275419c39d3efd3b": { "balance": "3200000000000000000000" }, "dd8254121a6e942fc90828f2431f511dad7f32e6": { "balance": "3018000000000000000000" }, "37fac1e6bc122e936dfb84de0c4bef6e0d60c2d7": { "balance": "2000000000000000000000" }, "3a10888b7e149cae272c01302c327d0af01a0b24": { "balance": "17000000000000000000" }, "401354a297952fa972ad383ca07a0a2811d74a71": { "balance": "14000000000000000000" }, "51865db148881951f51251710e82b9be0d7eadb2": { "balance": "2000000000000000000000" }, "bbbd6ecbb5752891b4ceb3cce73a8f477059376f": { "balance": "36000000000000000000" }, "3f236108eec72289bac3a65cd283f95e041d144c": { "balance": "999925000000000000000" }, "dc83b6fd0d512131204707eaf72ea0c8c9bef976": { "balance": "2000000000000000000000" }, "036eeff5ba90a6879a14dff4c5043b18ca0460c9": { "balance": "100000000000000000000" }, "fac5ca94758078fbfccd19db3558da7ee8a0a768": { "balance": "1017500000000000000000" }, "d0d62c47ea60fb90a3639209bbfdd4d933991cc6": { "balance": "194000000000000000000" }, "891cb8238c88e93a1bcf61db49bd82b47a7f4f84": { "balance": "2680000000000000000000" }, "df53003346d65c5e7a646bc034f2b7d32fcbe56a": { "balance": "2000000000000000000000" }, "6e89c51ea6de13e06cdc748b67c4410fe9bcab03": { "balance": "4000000000000000000000" }, "a61cdbadf04b1e54c883de6005fcdf16beb8eb2f": { "balance": "2000000000000000000000" }, "e3951de5aefaf0458768d774c254f7157735e505": { "balance": "1600930000000000000000" }, "f2732cf2c13b8bb8e7492a988f5f89e38273ddc8": { "balance": "600000000000000000000" }, "4752218e54de423f86c0501933917aea08c8fed5": { "balance": "20000000000000000000000" }, "152f4e860ef3ee806a502777a1b8dbc91a907668": { "balance": "600000000000000000000" }, "15b96f30c23b8664e7490651066b00c4391fbf84": { "balance": "410650000000000000000" }, "8693e9b8be94425eef7969bc69f9d42f7cad671e": { "balance": "1000090000000000000000" }, "f41557dfdfb1a1bdcefefe2eba1e21fe0a4a9942": { "balance": "1970000000000000000000" }, "38458e0685573cb4d28f53098829904570179266": { "balance": "40000000000000000000" }, "53e4d9696dcb3f4d7b3f70dcaa4eecb71782ff5c": { "balance": "200000000000000000000" }, "2dca0e449ab646dbdfd393a96662960bcab5ae1e": { "balance": "40000000000000000000000" }, "87d7ac0653ccc67aa9c3469eef4352193f7dbb86": { "balance": "200000000000000000000000" }, "ae9f5c3fbbe0c9bcbf1af8ff74ea280b3a5d8b08": { "balance": "1730000000000000000000" }, "7751f363a0a7fd0533190809ddaf9340d8d11291": { "balance": "20000000000000000000" }, "708a2af425ceb01e87ffc1be54c0f532b20eacd6": { "balance": "134159000000000000000" }, "ac122a03cd058c122e5fe17b872f4877f9df9572": { "balance": "1969606000000000000000" }, "5da4ca88935c27f55c311048840e589e04a8a049": { "balance": "80000000000000000000" }, "e67c2c1665c88338688187629f49e99b60b2d3ba": { "balance": "200000000000000000000" }, "dec82373ade8ebcf2acb6f8bc2414dd7abb70d77": { "balance": "200000000000000000000" }, "47c247f53b9fbeb17bba0703a00c009fdb0f6eae": { "balance": "20000000000000000000000" }, "9a522e52c195bfb7cf5ffaaedb91a3ba7468161d": { "balance": "1000000000000000000000" }, "3159e90c48a915904adfe292b22fa5fd5e72796b": { "balance": "1008800000000000000000" }, "defddfd59b8d2c154eecf5c7c167bf0ba2905d3e": { "balance": "93588000000000000000" }, "ad1d68a038fd2586067ef6d135d9628e79c2c924": { "balance": "4686168000000000000000" }, "038e45eadd3d88b87fe4dab066680522f0dfc8f9": { "balance": "10000000000000000000000" }, "2561ec0f379218fe5ed4e028a3f744aa41754c72": { "balance": "13370000000000000000" }, "b95396daaa490df2569324fcc6623be052f132ca": { "balance": "2000000000000000000000" }, "2376ada90333b1d181084c97e645e810aa5b76f1": { "balance": "750000000000000000000" }, "07800d2f8068e448c79a4f69b1f15ef682aae5f6": { "balance": "19400000000000000000000" }, "adeb204aa0c38e179e81a94ed8b3e7d53047c26b": { "balance": "608000000000000000000" }, "0dc100b107011c7fc0a1339612a16ccec3285208": { "balance": "2000000000000000000000" }, "f0b1340b996f6f0bf0d9561c849caf7f4430befa": { "balance": "100000000000000000000" }, "e1443dbd95cc41237f613a48456988a04f683282": { "balance": "4000086000000000000000" }, "d3c6f1e0f50ec3d2a67e6bcd193ec7ae38f1657f": { "balance": "6618150000000000000000" }, "b68899e7610d4c93a23535bcc448945ba1666f1c": { "balance": "200000000000000000000" }, "a7253763cf4a75df92ca1e766dc4ee8a2745147b": { "balance": "10740000000000000000000" }, "75d67ce14e8d29e8c2ffe381917b930b1aff1a87": { "balance": "3000000000000000000000" }, "493d48bda015a9bfcf1603936eab68024ce551e0": { "balance": "22528000000000000000" }, "7ddd57165c87a2707f025dcfc2508c09834759bc": { "balance": "1400000000000000000000" }, "cff7f89a4d4219a38295251331568210ffc1c134": { "balance": "1760000000000000000000" }, "168d30e53fa681092b52e9bae15a0dcb41a8c9bb": { "balance": "100000000000000000000" }, "99b743d1d9eff90d9a1934b4db21d519d89b4a38": { "balance": "100000000000000000000" }, "a3d0b03cffbb269f796ac29d80bfb07dc7c6ad06": { "balance": "2000000000000000000000" }, "816d9772cf11399116cc1e72c26c6774c9edd739": { "balance": "200000000000000000000" }, "a880e2a8bf88a1a82648b4013c49c4594c433cc8": { "balance": "4728000000000000000000" }, "2a44a7218fe44d65a1b4b7a7d9b1c2c52c8c3e34": { "balance": "62221355000000000000000" }, "cb86edbc8bbb1f9131022be649565ebdb09e32a1": { "balance": "2000000000000000000000" }, "3915eab5ab2e5977d075dec47d96b68b4b5cf515": { "balance": "61520000000000000000000" }, "8165cab0eafb5a328fc41ac64dae715b2eef2c65": { "balance": "1000000000000000000000" }, "416c86b72083d1f8907d84efd2d2d783dffa3efb": { "balance": "1999944000000000000000" }, "c524086d46c8112b128b2faf6f7c7d8160a8386c": { "balance": "400000000000000000000" }, "902d74a157f7d2b9a3378b1f56703730e03a1719": { "balance": "4000000000000000000000" }, "74ef2869cbe608856045d8c2041118579f2236ea": { "balance": "59724000000000000000" }, "af992dd669c0883e5515d3f3112a13f617a4c367": { "balance": "2000000000000000000000" }, "4c6a248fc97d705def495ca20759169ef0d36471": { "balance": "760000000000000000000" }, "974d2f17895f2902049deaaecf09c3046507402d": { "balance": "14707000000000000000" }, "0239b4f21f8e05cd01512b2be7a0e18a6d974607": { "balance": "1000000000000000000000" }, "b97a6733cd5fe99864b3b33460d1672434d5cafd": { "balance": "1999579000000000000000" }, "f558a2b2dd26dd9593aae04531fd3c3cc3854b67": { "balance": "198000000000000000000" }, "b577b6befa054e9c040461855094b002d7f57bd7": { "balance": "114000000000000000000000" }, "73bfe7710f31cab949b7a2604fbf5239cee79015": { "balance": "2000000000000000000000" }, "5717f2d8f18ffcc0e5fe247d3a4219037c3a649c": { "balance": "3998000000000000000000" }, "20707e425d2a11d2c89f391b2b809f556c592421": { "balance": "2000000000000000000000" }, "9a6708ddb8903c289f83fe889c1edcd61f854423": { "balance": "1000000000000000000000" }, "fa27cc49d00b6c987336a875ae39da58fb041b2e": { "balance": "10000000000000000000000" }, "d688e785c98f00f84b3aa1533355c7a258e87948": { "balance": "500000000000000000000" }, "927cb7dc187036b5427bc7e200c5ec450c1d27d4": { "balance": "216000000000000000000" }, "b2bfaa58b5196c5cb7f89de15f479d1838de713d": { "balance": "21000000000000000000" }, "e180de9e86f57bafacd7904f9826b6b4b26337a3": { "balance": "830400000000000000000" }, "a1204dad5f560728a35c0d8fc79481057bf77386": { "balance": "1000000000000000000000" }, "6b0da25af267d7836c226bcae8d872d2ce52c941": { "balance": "6000000000000000000000" }, "0517448dada761cc5ba4033ee881c83037036400": { "balance": "1998000000000000000000" }, "7ed0a5a847bef9a9da7cba1d6411f5c316312619": { "balance": "39842000000000000000" }, "5b5d517029321562111b43086d0b043591109a70": { "balance": "2600000000000000000000" }, "56fc1a7bad4047237ce116146296238e078f93ad": { "balance": "178000000000000000000" }, "6c5422fb4b14e6d98b6091fdec71f1f08640419d": { "balance": "400000000000000000000" }, "108fe8ee2a13da487b22c6ab6d582ea71064d98c": { "balance": "399800000000000000000" }, "0ad3e44d3c001fa290b393617030544108ac6eb9": { "balance": "1969019000000000000000" }, "25aee68d09afb71d8817f3f184ec562f7897b734": { "balance": "2000000000000000000000" }, "c2340a4ca94c9678b7494c3c852528ede5ee529f": { "balance": "48669000000000000000" }, "44901e0d0e08ac3d5e95b8ec9d5e0ff5f12e0393": { "balance": "417500000000000000000" }, "8775a610c502b9f1e6ad4cdadb8ce29bff75f6e4": { "balance": "600000000000000000000" }, "682897bc4f8e89029120fcffb787c01a93e64184": { "balance": "10000000000000000000000" }, "f7acff934b84da0969dc37a8fcf643b7d7fbed41": { "balance": "1999944000000000000000" }, "f05fcd4c0d73aa167e5553c8c0d6d4f2faa39757": { "balance": "13334000000000000000000" }, "c981d312d287d558871edd973abb76b979e5c35e": { "balance": "1970000000000000000000" }, "9da61ccd62bf860656e0325d7157e2f160d93bb5": { "balance": "4999980000000000000000" }, "d284a50382f83a616d39b8a9c0f396e0ebbfa95d": { "balance": "1000070000000000000000" }, "d6cf5c1bcf9da662bcea2255905099f9d6e84dcc": { "balance": "8349332000000000000000" }, "c71b2a3d7135d2a85fb5a571dcbe695e13fc43cd": { "balance": "1000000000000000000000" }, "b22dadd7e1e05232a93237baed98e0df92b1869e": { "balance": "2000000000000000000000" }, "b09fe6d4349b99bc37938054022d54fca366f7af": { "balance": "200000000000000000000000" }, "427e4751c3babe78cff8830886febc10f9908d74": { "balance": "1970000000000000000000" }, "60b358cb3dbefa37f47df2d7365840da8e3bc98c": { "balance": "20000000000000000000" }, "dcd5bca2005395b675fde5035659b26bfefc49ee": { "balance": "197000000000000000000" }, "81186931184137d1192ac88cd3e1e5d0fdb86a74": { "balance": "2900000000000000000000" }, "de212293f8f1d231fa10e609470d512cb8ffc512": { "balance": "2000000000000000000000" }, "1937c5c515057553ccbd46d5866455ce66290284": { "balance": "1000000000000000000000000" }, "592777261e3bd852c48eca95b3a44c5b7f2d422c": { "balance": "20000000000000000000000" }, "bbf84292d954acd9e4072fb860b1504106e077ae": { "balance": "1500000000000000000000" }, "3b4100e30a73b0c734b18ffa8426d19b19312f1a": { "balance": "55300000000000000000000" }, "a03a3dc7c533d1744295be955d61af3f52b51af5": { "balance": "40000000000000000000" }, "4aa148c2c33401e66a2b586e6577c4b292d3f240": { "balance": "216200000000000000000" }, "ff850e3be1eb6a4d726c08fa73aad358f39706da": { "balance": "1940000000000000000000" }, "743651b55ef8429df50cf81938c2508de5c8870f": { "balance": "2000000000000000000000" }, "3700e3027424d939dbde5d42fb78f6c4dbec1a8f": { "balance": "40000000000000000000" }, "c1cbd2e2332a524cf219b10d871ccc20af1fb0fa": { "balance": "1000000000000000000000" }, "e25b9f76b8ad023f057eb11ad94257a0862e4e8c": { "balance": "2000000000000000000000" }, "719e891fbcc0a33e19c12dc0f02039ca05b801df": { "balance": "6185800000000000000000" }, "39636b25811b176abfcfeeca64bc87452f1fdff4": { "balance": "400000000000000000000" }, "631030a5b27b07288a45696f189e1114f12a81c0": { "balance": "499970000000000000000" }, "bcc84597b91e73d5c5b4d69c80ecf146860f779a": { "balance": "4380000000000000000000" }, "095e0174829f34c3781be1a5e38d1541ea439b7f": { "balance": "6000000000000000000000" }, "2e7e05e29edda7e4ae25c5173543efd71f6d3d80": { "balance": "6000000000000000000000" }, "dbb6ac484027041642bbfd8d80f9d0c1cf33c1eb": { "balance": "2000000000000000000000" }, "153c08aa8b96a611ef63c0253e2a4334829e579d": { "balance": "394000000000000000000" }, "10f4bff0caa5027c0a6a2dcfc952824de2940909": { "balance": "2000000000000000000000" }, "2ef869f0350b57d53478d701e3fee529bc911c75": { "balance": "50000000000000000000" }, "70ab34bc17b66f9c3b63f151274f2a727c539263": { "balance": "2000000000000000000000" }, "3201259caf734ad7581c561051ba0bca7fd6946b": { "balance": "180000000000000000000000" }, "84e9cf8166c36abfa49053b7a1ad4036202681ef": { "balance": "2000000000000000000000" }, "4ebc5629f9a6a66b2cf3363ac4895c0348e8bf87": { "balance": "1000090000000000000000" }, "e50b464ac9de35a5618b7cbf254674182b81b97e": { "balance": "4100000000000000000000" }, "2abdf1a637ef6c42a7e2fe217773d677e804ebdd": { "balance": "5000000000000000000000" }, "7a0a78a9cc393f91c3d9e39a6b8c069f075e6bf5": { "balance": "1337000000000000000000" }, "2d9c5fecd2b44fbb6a1ec732ea059f4f1f9d2b5c": { "balance": "1010694000000000000000" }, "7b712c7af11676006a66d2fc5c1ab4c479ce6037": { "balance": "8000000000000000000000" }, "3466f67e39636c01f43b3a21a0e8529325c08624": { "balance": "842864000000000000000" }, "fdd502a74e813bcfa355ceda3c176f6a6871af7f": { "balance": "400000000000000000000" }, "26475419c06d5f147aa597248eb46cf7befa64a5": { "balance": "1640000000000000000000" }, "9243d7762d77287b12638688b9854e88a769b271": { "balance": "1000000000000000000000" }, "723d8baa2551d2addc43c21b45e8af4ca2bfb2c2": { "balance": "1760000000000000000000" }, "f2fbb6d887f8b8cc3a869aba847f3d1f643c53d6": { "balance": "3999000000000000000000" }, "2cdb3944650616e47cb182e060322fa1487978ce": { "balance": "1820000000000000000000" }, "f0d21663d8b0176e05fde1b90ef31f8530fda95f": { "balance": "1999944000000000000000" }, "77cc02f623a9cf98530997ea67d95c3b491859ae": { "balance": "1354900000000000000000" }, "d1b5a454ac3405bb4179208c6c84de006bcb9be9": { "balance": "500000000000000000000" }, "b9920fd0e2c735c256463caa240fb7ac86a93dfa": { "balance": "1760000000000000000000" }, "ed1f1e115a0d60ce02fb25df014d289e3a0cbe7d": { "balance": "500000000000000000000" }, "23e2c6a8be8e0acfa5c4df5e36058bb7cbac5a81": { "balance": "2000000000000000000000" }, "f0be0faf4d7923fc444622d1980cf2d990aab307": { "balance": "2000000000000000000000" }, "0829d0f7bb7c446cfbb0deadb2394d9db7249a87": { "balance": "40110000000000000000" }, "2ecac504b233866eb5a4a99e7bd2901359e43b3d": { "balance": "20000000000000000000000" }, "06d6cb308481c336a6e1a225a912f6e6355940a1": { "balance": "1760000000000000000000" }, "d4879fd12b1f3a27f7e109761b23ca343c48e3d8": { "balance": "666000000000000000000" }, "857f100b1a5930225efc7e9020d78327b41c02cb": { "balance": "2000000000000000000000" }, "3aa42c21b9b31c3e27ccd17e099af679cdf56907": { "balance": "8000000000000000000000" }, "764d5212263aff4a2a14f031f04ec749dc883e45": { "balance": "1850000000000000000000" }, "d03a2da41e868ed3fef5745b96f5eca462ff6fda": { "balance": "3000000000000000000000" }, "4f26690c992b7a312ab12e1385d94acd58288e7b": { "balance": "14000000000000000000000" }, "7b122162c913e7146cad0b7ed37affc92a0bf27f": { "balance": "1506799000000000000000" }, "c87352dba582ee2066b9c002a962e003134f78b1": { "balance": "500000000000000000000" }, "9f4ac9c9e7e24cb2444a0454fa5b9ad9d92d3853": { "balance": "835000000000000000000" }, "ccf62a663f1353ba2ef8e6521dc1ecb673ec8ef7": { "balance": "152000000000000000000" }, "557f5e65e0da33998219ad4e99570545b2a9d511": { "balance": "11024000000000000000000" }, "a5f0077b351f6c505cd515dfa6d2fa7f5c4cd287": { "balance": "40000000000000000000000" }, "79c6002f8452ca157f1317e80a2faf24475559b7": { "balance": "20000000000000000000" }, "3aa07a34a1afc8967d3d1383b96b62cf96d5fa90": { "balance": "20000000000000000000000" }, "7f389c12f3c6164f6446566c77669503c2792527": { "balance": "98500000000000000000" }, "ac4cc256ae74d624ace80db078b2207f57198f6b": { "balance": "2001000000000000000000" }, "823ba7647238d113bce9964a43d0a098118bfe4d": { "balance": "200000000000000000000" }, "f5a7676ad148ae9c1ef8b6f5e5a0c2c473be850b": { "balance": "200000000000000000000" }, "7d34803569e00bd6b59fff081dfa5c0ab4197a62": { "balance": "1712700000000000000000" }, "061ea4877cd08944eb64c2966e9db8dedcfec06b": { "balance": "1000000000000000000000" }, "df37c22e603aedb60a627253c47d8ba866f6d972": { "balance": "24000000000000000000000" }, "529aa002c6962a3a8545027fd8b05f22b5bf9564": { "balance": "1670000000000000000000" }, "eb89a882670909cf377e9e78286ee97ba78d46c2": { "balance": "802200000000000000000" }, "9ac85397792a69d78f286b86432a07aeceb60e64": { "balance": "14300000000000000000" }, "9610592202c282ab9bd8a884518b3e0bd4758137": { "balance": "268000000000000000000" }, "73932709a97f02c98e51b091312865122385ae8e": { "balance": "1430000000000000000000" }, "5ef8c96186b37984cbfe04c598406e3b0ac3171f": { "balance": "9400000000000000000000" }, "b6f78da4f4d041b3bc14bc5ba519a5ba0c32f128": { "balance": "172326253000000000000000" }, "6f0edd23bcd85f6015f9289c28841fe04c83efeb": { "balance": "19100000000000000000" }, "a8a43c009100616cb4ae4e033f1fc5d7e0b6f152": { "balance": "3939015000000000000000" }, "7081fa6baad6cfb7f51b2cca16fb8970991a64ba": { "balance": "233953000000000000000" }, "9de7386dde401ce4c67b71b6553f8aa34ea5a17d": { "balance": "60000000000000000000" }, "54ec7300b81ac84333ed1b033cd5d7a33972e234": { "balance": "200000000000000000000" }, "67a80e0190721f94390d6802729dd12c31a895ad": { "balance": "1999964000000000000000" }, "3a4297da3c555e46c073669d0478fce75f2f790e": { "balance": "1969606000000000000000" }, "c2e0584a71348cc314b73b2029b6230b92dbb116": { "balance": "2000000000000000000000" }, "0a2ade95b2e8c66d8ae6f0ba64ca57d783be6d44": { "balance": "4000000000000000000000" }, "544b5b351d1bc82e9297439948cf4861dac9ae11": { "balance": "22000000000000000000000" }, "3ae62bd271a760637fad79c31c94ff62b4cd12f7": { "balance": "2000000000000000000000" }, "0d8023929d917234ae40512b1aabb5e8a4512771": { "balance": "148000000000000000000" }, "2858acacaf21ea81cab7598fdbd86b452e9e8e15": { "balance": "666000000000000000000" }, "c033b1325a0af45472c25527853b1f1c21fa35de": { "balance": "2000000000000000000000" }, "bbf85aaaa683738f073baef44ac9dc34c4c779ea": { "balance": "2000000000000000000000" }, "6ae57f27917c562a132a4d1bf7ec0ac785832926": { "balance": "6000000000000000000000" }, "88e6f9b247f988f6c0fc14c56f1de53ec69d43cc": { "balance": "100000000000000000000" }, "b72c2a011c0df50fbb6e28b20ae1aad217886790": { "balance": "4000000000000000000000" }, "161caf5a972ace8379a6d0a04ae6e163fe21df2b": { "balance": "100000000000000000000000" }, "2a63590efe9986c3fee09b0a0a338b15bed91f21": { "balance": "6458400000000000000000" }, "50e1c8ec98415bef442618708799437b86e6c205": { "balance": "6000000000000000000000" }, "33f4a6471eb1bca6a9f85b3b4872e10755c82be1": { "balance": "2000000000000000000000" }, "9c49deff47085fc09704caa2dca8c287a9a137da": { "balance": "8000000000000000000000" }, "e1173a247d29d8238df0922f4df25a05f2af77c3": { "balance": "40007051000000000000000" }, "51891b2ccdd2f5a44b2a8bc49a5d9bca6477251c": { "balance": "310000000000000000000" }, "ecaf3350b7ce144d068b186010852c84dd0ce0f0": { "balance": "2000000000000000000000" }, "72393d37b451effb9e1ff3b8552712e2a970d8c2": { "balance": "985000000000000000000" }, "1bbc60bcc80e5cdc35c5416a1f0a40a83dae867b": { "balance": "2000000000000000000000" }, "b8ab39805bd821184f6cbd3d2473347b12bf175c": { "balance": "118200000000000000000" }, "c55a6b4761fd11e8c85f15174d74767cd8bd9a68": { "balance": "133700000000000000000" }, "99d1b585965f406a42a49a1ca70f769e765a3f98": { "balance": "16700000000000000000000" }, "9ab988b505cfee1dbe9cd18e9b5473b9a2d4f536": { "balance": "320000000000000000000" }, "7fef8c38779fb307ec6f044bebe47f3cfae796f1": { "balance": "168561000000000000000" }, "322d6f9a140d213f4c80cd051afe25c620bf4c7d": { "balance": "20000000000000000000" }, "3bd9a06d1bd36c4edd27fc0d1f5b088ddae3c72a": { "balance": "499970000000000000000" }, "5dcdb6b87a503c6d8a3c65c2cf9a9aa883479a1e": { "balance": "9200000000000000000000" }, "6e84c2fd18d8095714a96817189ca21cca62bab1": { "balance": "340935000000000000000" }, "a5bad86509fbe0e0e3c0e93f6d381f1af6e9d481": { "balance": "6000000000000000000000" }, "3954bdfe0bf587c695a305d9244c3d5bdddac9bb": { "balance": "19187461000000000000000" }, "63f0e5a752f79f67124eed633ad3fd2705a397d4": { "balance": "3940000000000000000000" }, "33fd718f0b91b5cec88a5dc15eecf0ecefa4ef3d": { "balance": "432500000000000000000" }, "68027d19558ed7339a08aee8de3559be063ec2ea": { "balance": "2000000000000000000000" }, "96f0462ae6f8b96088f7e9c68c74b9d8ad34b347": { "balance": "1790000000000000000000" }, "f1f391ca92808817b755a8b8f4e2ca08d1fd1108": { "balance": "6000000000000000000000" }, "7fcf5ba6666f966c5448c17bf1cb0bbcd8019b06": { "balance": "99999000000000000000" }, "e9b9a2747510e310241d2ece98f56b3301d757e0": { "balance": "2000000000000000000000" }, "2100381d60a5b54adc09d19683a8f6d5bb4bfbcb": { "balance": "10000000000000000000000" }, "7495ae78c0d90261e2140ef2063104731a60d1ed": { "balance": "34250000000000000000" }, "dc911cf7dc5dd0813656670528e9338e67034786": { "balance": "2000000000000000000000" }, "262aed4bc0f4a4b2c6fb35793e835a49189cdfec": { "balance": "10000000000000000000000" }, "9ee93f339e6726ec65eea44f8a4bfe10da3d3282": { "balance": "2000000000000000000000" }, "a3a57b0716132804d60aac281197ff2b3d237b01": { "balance": "1400000000000000000000" }, "c799e34e88ff88be7de28e15e4f2a63d0b33c4cb": { "balance": "200000000000000000000" }, "c7506c1019121ff08a2c8c1591a65eb4bdfb4a3f": { "balance": "600000000000000000000" }, "795ebc2626fc39b0c86294e0e837dcf523553090": { "balance": "1000000000000000000000" }, "441aca82631324acbfa2468bda325bbd78477bbf": { "balance": "6000000000000000000000" }, "9f271d285500d73846b18f733e25dd8b4f5d4a8b": { "balance": "722000000000000000000" }, "d77892e2273b235d7689e430e7aeed9cbce8a1f3": { "balance": "2000000000000000000000" }, "4f8972838f70c903c9b6c6c46162e99d6216d451": { "balance": "4610000000000000000000" }, "4c85ed362f24f6b9f04cdfccd022ae535147cbb9": { "balance": "1500000000000000000000" }, "3807eff43aa97c76910a19752dd715ee0182d94e": { "balance": "250190000000000000000" }, "3a9e5441d44b243be55b75027a1ceb9eacf50df2": { "balance": "1000000000000000000000" }, "3deae43327913f62808faa1b6276a2bd6368ead9": { "balance": "2000000000000000000000" }, "c270456885342b640b4cfc1b520e1a544ee0d571": { "balance": "1820000000000000000000" }, "77798f201257b9c35204957057b54674aefa51df": { "balance": "149000000000000000000" }, "225f9eb3fb6ff3e9e3c8447e14a66e8d4f3779f6": { "balance": "2000000000000000000000" }, "78df2681d6d602e22142d54116dea15d454957aa": { "balance": "298000000000000000000" }, "283396ce3cac398bcbe7227f323e78ff96d08767": { "balance": "400000000000000000000" }, "747ff7943b71dc4dcdb1668078f83dd7cc4520c2": { "balance": "60000000000000000000" }, "a4ed11b072d89fb136759fc69b428c48aa5d4ced": { "balance": "262800000000000000000" }, "cc043c4388d345f884c6855e71142a9f41fd6935": { "balance": "20000000000000000000" }, "ab14d221e33d544629198cd096ed63dfa28d9f47": { "balance": "6000000000000000000000" }, "251e6838f7cec5b383c1d90146341274daf8e502": { "balance": "147510000000000000000" }, "36a0e61e1be47fa87e30d32888ee0330901ca991": { "balance": "20000000000000000000" }, "bcfc98e5c82b6adb180a3fcb120b9a7690c86a3f": { "balance": "1970000000000000000000" }, "18a6d2fc52be73084023c91802f05bc24a4be09f": { "balance": "2000000000000000000000" }, "80591a42179f34e64d9df75dcd463b28686f5574": { "balance": "20000000000000000000000" }, "881230047c211d2d5b00d8de4c5139de5e3227c7": { "balance": "10000000000000000000000" }, "9eb1ff71798f28d6e989fa1ea0588e27ba86cb7d": { "balance": "140800000000000000000" }, "a01fd1906a908506dedae1e208128872b56ee792": { "balance": "3000000000000000000000" }, "1b05ea6a6ac8af7cb6a8b911a8cce8fe1a2acfc8": { "balance": "2000000000000000000000" }, "6add932193cd38494aa3f03aeccc4b7ab7fabca2": { "balance": "89600000000000000000" }, "2aaa35274d742546670b7426264521032af4f4c3": { "balance": "10000000000000000000000" }, "67b8a6e90fdf0a1cac441793301e8750a9fa7957": { "balance": "895000000000000000000" }, "5b5be0d8c67276baabd8edb30d48ea75640b8b29": { "balance": "824480000000000000000" }, "28d7e5866f1d85fd1ceb32bfbe1dfc36db434566": { "balance": "7199000000000000000000" }, "98e3e90b28fccaee828779b8d40a5568c4116e21": { "balance": "40000000000000000000" }, "2dd578f7407dfbd548d05e95ccc39c485429626a": { "balance": "4200000000000000000000" }, "8ca6989746b06e32e2487461b1ce996a273acfd7": { "balance": "20000000000000000000" }, "a6f93307f8bce03195fece872043e8a03f7bd11a": { "balance": "2886000000000000000000" }, "efbd52f97da5fd3a673a46cbf330447b7e8aad5c": { "balance": "100033000000000000000" }, "52bdd9af5978850bc24110718b3723759b437e59": { "balance": "1730000000000000000000" }, "6e073b66d1b8c66744d88096a8dd99ec7e0228da": { "balance": "4000000000000000000000" }, "a29d661a6376f66d0b74e2fe9d8f26c0247ec84c": { "balance": "4117300000000000000000" }, "7d34ff59ae840a7413c6ba4c5bb2ba2c75eab018": { "balance": "3000000000000000000000" }, "2eca6a3c5d9f449d0956bd43fa7b4d7be8435958": { "balance": "2000020000000000000000" }, "f59f9f02bbc98efe097eabb78210979021898bfd": { "balance": "9999800000000000000000" }, "90e300ac71451e401f887f6e7728851647a80e07": { "balance": "400000000000000000000" }, "05ae7fd4bbcc80ca11a90a1ec7a301f7cccc83db": { "balance": "910000000000000000000" }, "e54102534de8f23effb093b31242ad3b233facfd": { "balance": "4000000000000000000000" }, "c127aab59065a28644a56ba3f15e2eac13da2995": { "balance": "600000000000000000000" }, "ed60c4ab6e540206317e35947a63a9ca6b03e2cb": { "balance": "57275000000000000000" }, "d855b03ccb029a7747b1f07303e0a664793539c8": { "balance": "2000000000000000000000" }, "1178501ff94add1c5881fe886136f6dfdbe61a94": { "balance": "158000000000000000000" }, "f447108b98df64b57e871033885c1ad71db1a3f9": { "balance": "6916709000000000000000" }, "deee2689fa9006b59cf285237de53b3a7fd01438": { "balance": "450034000000000000000" }, "7f01dc7c3747ca608f983dfc8c9b39e755a3b914": { "balance": "206980000000000000000" }, "9edeac4c026b93054dc5b1d6610c6f3960f2ad73": { "balance": "1200000000000000000000" }, "e3cffe239c64e7e20388e622117391301b298696": { "balance": "500000000000000000000" }, "ebbb4f2c3da8be3eb62d1ffb1f950261cf98ecda": { "balance": "2000000000000000000000" }, "38c10b90c859cbb7815692f99dae520ab5febf5e": { "balance": "13169000000000000000000" }, "23f9ecf3e5dddca38815d3e59ed34b5b90b4a353": { "balance": "204608000000000000000" }, "d7fa5ffb6048f96fb1aba09ef87b1c11dd7005e4": { "balance": "1000000000000000000000" }, "9ca42ee7a0b898f6a5cc60b5a5d7b1bfa3c33231": { "balance": "2000000000000000000000" }, "8b9577920053b1a00189304d888010d9ef2cb4bf": { "balance": "500000000000000000000" }, "fcd0b4827cd208ffbf5e759dba8c3cc61d8c2c3c": { "balance": "8000000000000000000000" }, "01ff1eb1dead50a7f2f9638fdee6eccf3a7b2ac8": { "balance": "600000000000000000000" }, "abde147b2af789eaa586547e66c4fa2664d328a4": { "balance": "247545000000000000000" }, "64042ba68b12d4c151651ca2813b7352bd56f08e": { "balance": "600000000000000000000" }, "dccca42045ec3e16508b603fd936e7fd7de5f36a": { "balance": "19700000000000000000" }, "e77a89bd45dc04eeb4e41d7b596b707e6e51e74c": { "balance": "12000000000000000000000" }, "f77c7b845149efba19e261bc7c75157908afa990": { "balance": "2000000000000000000000" }, "fa5201fe1342af11307b9142a041243ca92e2f09": { "balance": "152150000000000000000000" }, "40df495ecf3f8b4cef2a6c189957248fe884bc2b": { "balance": "12000000000000000000000" }, "3d79a853d71be0621b44e29759656ca075fdf409": { "balance": "2000000000000000000000" }, "6de02f2dd67efdb7393402fa9eaacbcf589d2e56": { "balance": "1182000000000000000000" }, "729aad4627744e53f5d66309aa74448b3acdf46f": { "balance": "2000000000000000000000" }, "4e4318f5e13e824a54edfe30a7ed4f26cd3da504": { "balance": "2000000000000000000000" }, "c6a286e065c85f3af74812ed8bd3a8ce5d25e21d": { "balance": "18200000000000000000" }, "fd686de53fa97f99639e2568549720bc588c9efc": { "balance": "1969606000000000000000" }, "06b0ff834073cce1cbc9ea557ea87b605963e8b4": { "balance": "300000000000000000000" }, "72b5633fe477fe542e742facfd690c137854f216": { "balance": "1670000000000000000000" }, "8bf373d076814cbc57e1c6d16a82c5be13c73d37": { "balance": "200000000000000000000" }, "cf264e6925130906c4d7c18591aa41b2a67f6f58": { "balance": "2000000000000000000000" }, "0ea2a210312b3e867ee0d1cc682ce1d666f18ed5": { "balance": "10000000000000000000000" }, "d02afecf8e2ec2b62ac8ad204161fd1fae771d0e": { "balance": "2000000000000000000000" }, "e6b20f980ad853ad04cbfc887ce6601c6be0b24c": { "balance": "4000000000000000000000" }, "4280a58f8bb10b9440de94f42b4f592120820191": { "balance": "2000000000000000000000" }, "a914cdb571bfd93d64da66a4e108ea134e50d000": { "balance": "1430143000000000000000" }, "60864236930d04d8402b5dcbeb807f3caf611ea2": { "balance": "4000000000000000000000" }, "f9dd239008182fb519fb30eedd2093fed1639be8": { "balance": "500000000000000000000" }, "18e53243981aabc8767da10c73449f1391560eaa": { "balance": "6000000000000000000000" }, "c3a9226ae275df2cab312b911040634a9c9c9ef6": { "balance": "4000000000000000000000" }, "4fcc19ea9f4c57dcbce893193cfb166aa914edc5": { "balance": "7001380000000000000000" }, "c1e1409ca52c25435134d006c2a6a8542dfb7273": { "balance": "34380000000000000000" }, "981ddf0404e4d22dda556a0726f00b2d98ab9569": { "balance": "999972000000000000000" }, "e5bcc88c3b256f6ed5fe550e4a18198b943356ad": { "balance": "2000000000000000000000" }, "74a17f064b344e84db6365da9591ff1628257643": { "balance": "20000000000000000000" }, "2720f9ca426ef2f2cbd2fecd39920c4f1a89e16d": { "balance": "2000000000000000000000" }, "8d04a5ebfb5db409db0617c9fa5631c192861f4a": { "balance": "970000000000000000000" }, "f18b14cbf6694336d0fe12ac1f25df2da0c05dbb": { "balance": "3999800000000000000000" }, "56ac20d63bd803595cec036da7ed1dc66e0a9e07": { "balance": "63927000000000000000" }, "92c94c2820dfcf7156e6f13088ece7958b3676fd": { "balance": "95500000000000000000" }, "968dea60df3e09ae3c8d3505e9c080454be0e819": { "balance": "6000000000000000000000" }, "9268d62646563611dc3b832a30aa2394c64613e3": { "balance": "2000000000000000000000" }, "5a192b964afd80773e5f5eda6a56f14e25e0c6f3": { "balance": "500000000000000000000" }, "df8d48b1eb07b3c217790e6c2df04dc319e7e848": { "balance": "500000000000000000000" }, "7f61fa6cf5f898b440dac5abd8600d6d691fdef9": { "balance": "280000000000000000000" }, "929d368eb46a2d1fbdc8ffa0607ede4ba88f59ad": { "balance": "2000000000000000000000" }, "9982a5890ffb5406d3aca8d2bfc1dd70aaa80ae0": { "balance": "2000000000000000000000" }, "bf2aea5a1dcf6ed3b5e8323944e983fedfd1acfb": { "balance": "1580000000000000000000" }, "46aa501870677e7f0a504876b4e8801a0ad01c46": { "balance": "800000000000000000000" }, "8f473d0ab876ddaa15608621d7013e6ff714b675": { "balance": "470400000000000000000" }, "02290fb5f9a517f82845acdeca0fc846039be233": { "balance": "2000000000000000000000" }, "8a5831282ce14a657a730dc18826f7f9b99db968": { "balance": "4330268000000000000000" }, "0328510c09dbcd85194a98d67c33ac49f2f94d60": { "balance": "11000000000000000000000" }, "cf883a20329667ea226a1e3c765dbb6bab32219f": { "balance": "3038972000000000000000" }, "2615100ea7e25bba9bca746058afbbb4ffbe4244": { "balance": "500000000000000000000" }, "b115ee3ab7641e1aa6d000e41bfc1ec7210c2f32": { "balance": "13000000000000000000000" }, "5cfa8d568575658ca4c1a593ac4c5d0e44c60745": { "balance": "291000000000000000000" }, "d3c24d4b3a5e0ff8a4622d518edd73f16ab28610": { "balance": "20000000000000000000" }, "a639acd96b31ba53b0d08763229e1f06fd105e9d": { "balance": "8000000000000000000000" }, "ffa4aff1a37f984b0a67272149273ae9bd41e3bc": { "balance": "10000000000000000000000" }, "cf684dfb8304729355b58315e8019b1aa2ad1bac": { "balance": "432500000000000000000" }, "5797b60fd2894ab3c2f4aede86daf2e788d745ad": { "balance": "6000000000000000000000" }, "a6a0de421ae54f6d17281308f5646d2f39f7775d": { "balance": "2000000000000000000000" }, "08504f05643fab5919f5eea55925d7a3ed7d807a": { "balance": "20000000000000000000" }, "7a7068e1c3375c0e599db1fbe6b2ea23b8f407d2": { "balance": "2000000000000000000000" }, "1078d7f61b0e56c74ee6635b2e1819ef1e3d8785": { "balance": "1000000000000000000000" }, "6e12b51e225b4a4372e59ad7a2a1a13ea3d3a137": { "balance": "14172200000000000000000" }, "6a2e86469a5bf37cee82e88b4c3863895d28fcaf": { "balance": "519000000000000000000" }, "197672fd39d6f246ce66a790d13aa922d70ea109": { "balance": "1000000000000000000000" }, "8009a7cbd192b3aed4adb983d5284552c16c7451": { "balance": "4000000000000000000000" }, "f6c3c48a1ac0a34799f04db86ec7a975fe7768f3": { "balance": "1970000000000000000000" }, "16be75e98a995a395222d00bd79ff4b6e638e191": { "balance": "36000000000000000000000" }, "6c05e34e5ef2f42ed09deff1026cd66bcb6960bb": { "balance": "2000000000000000000000" }, "5d6ae8cbd6b3393c22d16254100d0238e808147c": { "balance": "719992000000000000000" }, "1a376e1b2d2f590769bb858d4575320d4e149970": { "balance": "4841200000000000000000" }, "f6ead67dbf5b7eb13358e10f36189d53e643cfcf": { "balance": "40000000000000000000000" }, "467d5988249a68614716659840ed0ae6f6f457bc": { "balance": "387500000000000000000" }, "aa960e10c52391c54e15387cc67af827b5316dcc": { "balance": "2000000000000000000000" }, "483ba99034e900e3aedf61499d3b2bce39beb7aa": { "balance": "985000000000000000000" }, "86f23e9c0aafc78b9c404dcd60339a925bffa266": { "balance": "400000000000000000000" }, "d05a447c911dbb275bfb2e5a37e5a703a56f9997": { "balance": "200000000000000000000" }, "edb71ec41bda7dce86e766e6e8c3e9907723a69b": { "balance": "20000000000000000000" }, "f86a3ea8071f7095c7db8a05ae507a8929dbb876": { "balance": "336000000000000000000" }, "323b3cfe3ee62bbde2a261e53cb3ecc05810f2c6": { "balance": "13790000000000000000000" }, "936f3813f5f6a13b8e4ffec83fe7f826186a71cd": { "balance": "520000000000000000000" }, "6db72bfd43fef465ca5632b45aab7261404e13bf": { "balance": "2000000000000000000000" }, "9bb76204186af2f63be79168601687fc9bad661f": { "balance": "300000000000000000000" }, "28ab165ffb69eda0c549ae38e9826f5f7f92f853": { "balance": "1296890000000000000000" }, "c73e2112282215dc0762f32b7e807dcd1a7aae3e": { "balance": "6900000000000000000000" }, "f8086e42661ea929d2dda1ab6c748ce3055d111e": { "balance": "1000000000000000000000" }, "4db21284bcd4f787a7556500d6d7d8f36623cf35": { "balance": "1939806000000000000000" }, "c48651c1d9c16bff4c9554886c3f3f26431f6f68": { "balance": "658000000000000000000" }, "9bdbdc9b973431d13c89a3f9757e9b3b6275bfc7": { "balance": "499971000000000000000" }, "560da37e956d862f81a75fd580a7135c1b246352": { "balance": "10000000000000000000000" }, "4b60a3e253bf38c8d5662010bb93a473c965c3e5": { "balance": "1490000000000000000000" }, "64e02abb016cc23a2934f6bcddb681905021d563": { "balance": "1000000000000000000000" }, "ac2c8e09d06493a63858437bd20be01962450365": { "balance": "1910000000000000000000" }, "9bf9b3b2f23cf461eb591f28340bc719931c8364": { "balance": "1000000000000000000000" }, "9b5c39f7e0ac168c8ed0ed340477117d1b682ee9": { "balance": "98000000000000000000" }, "f75bb39c799779ebc04a336d260da63146ed98d0": { "balance": "25000000000000000000" }, "a7966c489f4c748a7ae980aa27a574251767caf9": { "balance": "3000000000000000000000" }, "ea53c954f4ed97fd4810111bdab69ef981ef25b9": { "balance": "17300000000000000000000" }, "03a26cfc4c18316f70d59e9e1a79ee3e8b962f4c": { "balance": "2000000000000000000000" }, "3e63ce3b24ca2865b4c5a687b7aea3597ef6e548": { "balance": "2000000000000000000000" }, "500c902958f6421594d1b6ded712490d52ed6c44": { "balance": "1970000000000000000000" }, "6f44ca09f0c6a8294cbd519cdc594ad42c67579f": { "balance": "50000000000000000000" }, "3616fb46c81578c9c8eb4d3bf880451a88379d7d": { "balance": "200000000000000000000" }, "57bc20e2d62b3d19663cdb4c309d5b4f2fc2db8f": { "balance": "100000000000000000000" }, "1cebf0985d7f680aaa915c44cc62edb49eab269e": { "balance": "1000000000000000000000" }, "c0cbf6032fa39e7c46ff778a94f7d445fe22cf30": { "balance": "310000000000000000000" }, "c58b9cc61dedbb98c33f224d271f0e228b583433": { "balance": "3880000000000000000000" }, "e9c6dfae97f7099fc5f4e94b784db802923a1419": { "balance": "48800000000000000000" }, "9bacd3d40f3b82ac91a264d9d88d908eac8664b9": { "balance": "20000000000000000000000" }, "63d80048877596e0c28489e650cd4ac180096a49": { "balance": "280000000000000000000" }, "e6a6f6dd6f70a456f4ec15ef7ad5e5dbb68bd7dc": { "balance": "200000000000000000000" }, "d418870bc2e4fa7b8a6121ae0872d55247b62501": { "balance": "1580000000000000000000" }, "e2f9383d5810ea7b43182b8704b62b27f5925d39": { "balance": "400000000000000000000" }, "bd5e473abce8f97a6932f77c2facaf9cc0a00514": { "balance": "1117350000000000000000" }, "2ff1ca55fd9cec1b1fe9f0a9abb74c513c1e2aaa": { "balance": "3000000000000000000000" }, "9d99b189bbd9a48fc2e16e8fcda33bb99a317bbb": { "balance": "1126900000000000000000" }, "6e96faeda3054302c45f58f161324c99a3eebb62": { "balance": "20000000000000000000" }, "ef93818f684db0c3675ec81332b3183ecc28a495": { "balance": "1550000000000000000000" }, "2659facb1e83436553b5b42989adb8075f9953ed": { "balance": "29356000000000000000" }, "c4ffadaaf2823fbea7bff702021bffc4853eb5c9": { "balance": "42233000000000000000" }, "e9864c1afc8eaad37f3ba56fcb7477cc622009b7": { "balance": "79000000000000000000" }, "87ef6d8b6a7cbf9b5c8c97f67ee2adc2a73b3f77": { "balance": "200400000000000000000" }, "c043f2452dcb9602ef62bd360e033dd23971fe84": { "balance": "2000000000000000000000" }, "0fdd65402395df9bd19fee4507ef5345f745104c": { "balance": "5000000000000000000000" }, "939c4313d2280edf5e071bced846063f0a975d54": { "balance": "120000000000000000000000" }, "b28245037cb192f75785cb86cbfe7c930da258b0": { "balance": "16000000000000000000000" }, "a80cb1738bac08d4f9c08b4deff515545fa8584f": { "balance": "500000000000000000000" }, "62971bf2634cee0be3c9890f51a56099dbb9519b": { "balance": "656000000000000000000" }, "f2efe96560c9d97b72bd36447843885c1d90c231": { "balance": "2000000000000000000000" }, "0e390f44053ddfcef0d608b35e4d9c2cbe9871bb": { "balance": "1970000000000000000000" }, "61d101a033ee0e2ebb3100ede766df1ad0244954": { "balance": "500000000000000000000" }, "6785513cf732e47e87670770b5419be10cd1fc74": { "balance": "2000000000000000000000" }, "167699f48a78c615512515739958993312574f07": { "balance": "39000000000000000000" }, "68ec79d5be7155716c40941c79d78d17de9ef803": { "balance": "500600000000000000000" }, "a0e8ba661b48154cf843d4c2a5c0f792d528ee29": { "balance": "400000000000000000000" }, "1a201b4327cea7f399046246a3c87e6e03a3cda8": { "balance": "1000000000000000000000" }, "f60f62d73937953fef35169e11d872d2ea317eec": { "balance": "5348000000000000000000" }, "c0c04d0106810e3ec0e54a19f2ab8597e69a573d": { "balance": "50000000000000000000" }, "ef47cf073e36f271d522d7fa4e7120ad5007a0bc": { "balance": "2500000000000000000000" }, "a44fe800d96fcad73b7170d0f610cb8c0682d6ce": { "balance": "4000000000000000000000" }, "010f4a98dfa1d9799bf5c796fb550efbe7ecd877": { "balance": "8023366000000000000000" }, "708fa11fe33d85ad1befcbae3818acb71f6a7d7e": { "balance": "18200000000000000000" }, "b38c4e537b5df930d65a74d043831d6b485bbde4": { "balance": "400000000000000000000" }, "250a69430776f6347703f9529783955a6197b682": { "balance": "1940000000000000000000" }, "2d35a9df62757f7ffad1049afb06ca4afc464c51": { "balance": "20000000000000000000" }, "6aff1466c2623675e3cb0e75e423d37a25e442eb": { "balance": "1730000000000000000000" }, "fc15cb99a8d1030b12770add033a79ee0d0c908c": { "balance": "350056000000000000000" }, "e784dcc873aa8c1513ec26ff36bc92eac6d4c968": { "balance": "200000000000000000000" }, "b1c328fb98f2f19ab6646f0a7c8c566fda5a8540": { "balance": "2500000000000000000000" }, "247a0a11c57f0383b949de540b66dee68604b0a1": { "balance": "1069600000000000000000" }, "1af60343360e0b2d75255210375720df21db5c7d": { "balance": "1000000000000000000000" }, "8794bf47d54540ece5c72237a1ffb511ddb74762": { "balance": "2000000000000000000000" }, "e76d945aa89df1e457aa342b31028a5e9130b2ce": { "balance": "1015200000000000000000" }, "a30e0acb534c9b3084e8501da090b4eb16a2c0cd": { "balance": "2000000000000000000000" }, "7099d12f6ec656899b049a7657065d62996892c8": { "balance": "400000000000000000000" }, "7be7f2456971883b9a8dbe4c91dec08ac34e8862": { "balance": "3000000000000000000000" }, "42746aeea14f27beff0c0da64253f1e7971890a0": { "balance": "1550000000000000000000" }, "736b44503dd2f6dd5469ff4c5b2db8ea4fec65d0": { "balance": "313950000000000000000" }, "822edff636563a6106e52e9a2598f7e6d0ef2782": { "balance": "36099000000000000000" }, "03c647a9f929b0781fe9ae01caa3e183e876777e": { "balance": "445800000000000000000" }, "63612e7862c27b587cfb6daf9912cb051f030a9f": { "balance": "43458000000000000000" }, "d46bae61b027e5bb422e83a3f9c93f3c8fc77d27": { "balance": "2000000000000000000000" }, "5f23ba1f37a96c45bc490259538a54c28ba3b0d5": { "balance": "1200000000000000000000" }, "d41d7fb49fe701baac257170426cc9b38ca3a9b2": { "balance": "176000000000000000000" }, "1ebacb7844fdc322f805904fbf1962802db1537c": { "balance": "10000000000000000000000" }, "9c80bc18e9f8d4968b185da8c79fa6e11ffc3e23": { "balance": "240000000000000000000" }, "e4ca0a5238564dfc91e8bf22bade2901619a1cd4": { "balance": "1000000000000000000000" }, "1ad72d20a76e7fcc6b764058f48d417d496fa6cd": { "balance": "2000000000000000000000" }, "d3bc730937fa75d8452616ad1ef1fe7fffe0d0e7": { "balance": "83363000000000000000" }, "eac1482826acb6111e19d340a45fb851576bed60": { "balance": "32177000000000000000" }, "01e40521122530d9ac91113c06a0190b6d63850b": { "balance": "1337000000000000000000" }, "9e20e5fd361eabcf63891f5b87b09268b8eb3793": { "balance": "100000000000000000000" }, "69ff429074cb9b6c63bc914284bce5f0c8fbf7d0": { "balance": "500000000000000000000" }, "0d3265d3e7bdb93d5e8e8b1ca47f210a793ecc8e": { "balance": "200000000000000000000" }, "5b4ea16db6809b0352d4b6e81c3913f76a51bb32": { "balance": "400000000000000000000" }, "d8fe088fffce948f5137ee23b01d959e84ac4223": { "balance": "227942000000000000000" }, "7e4e9409704121d1d77997026ff06ea9b19a8b90": { "balance": "2602600000000000000000" }, "96b434fe0657e42acc8212b6865139dede15979c": { "balance": "4000000000000000000000" }, "22f004df8de9e6ebf523ccace457accb26f97281": { "balance": "10000000000000000000000" }, "d8f9240c55cff035523c6d5bd300d370dc8f0c95": { "balance": "285000000000000000000" }, "9d9e57fde30e5068c03e49848edce343b7028358": { "balance": "1730000000000000000000" }, "317cf4a23cb191cdc56312c29d15e210b3b9b784": { "balance": "144000000000000000000" }, "79f08e01ce0988e63c7f8f2908fade43c7f9f5c9": { "balance": "18200000000000000000" }, "04e5f5bc7c923fd1e31735e72ef968fd67110c6e": { "balance": "1611000000000000000000" }, "1ec4ec4b77bf19d091a868e6f49154180541f90e": { "balance": "2000000000000000000000" }, "8737dae671823a8d5917e0157ace9c43468d946b": { "balance": "1999944000000000000000" }, "f998ca3411730a6cd10e7455b0410fb0f6d3ff80": { "balance": "2000000000000000000000" }, "6e2eab85dc89fe29dc0aa1853247dab43a523d56": { "balance": "80000000000000000000" }, "72c083beadbdc227c5fb43881597e32e83c26056": { "balance": "20000000000000000000000" }, "5902e44af769a87246a21e079c08bf36b06efeb3": { "balance": "1000000000000000000000" }, "cc2d04f0a4017189b340ca77198641dcf6456b91": { "balance": "3940000000000000000000" }, "bde4c73f969b89e9ceae66a2b51844480e038e9a": { "balance": "1000000000000000000000" }, "adff0d1d0b97471e76d789d2e49c8a74f9bd54ff": { "balance": "1880000000000000000000" }, "397cdb8c80c67950b18d654229610e93bfa6ee1a": { "balance": "1172938000000000000000" }, "a3e051fb744aa3410c3b88f899f5d57f168df12d": { "balance": "2955000000000000000000" }, "810db25675f45ea4c7f3177f37ce29e22d67999c": { "balance": "200000000000000000000" }, "1e13ec51142cebb7a26083412c3ce35144ba56a1": { "balance": "5000000000000000000000" }, "25bdfa3ee26f3849617b230062588a97e3cae701": { "balance": "1000008000000000000000" }, "ae538c73c5b38d8d584d7ebdadefb15cabe48357": { "balance": "999000000000000000000" }, "a2ecce2c49f72a0995a0bda57aacf1e9f001e22a": { "balance": "4000000000000000000000" }, "7e24fbdad290175eb2df6d180a19b9a9f41370be": { "balance": "1000000000000000000000" }, "e8cc43bc4f8acf39bff04ebfbf42aac06a328470": { "balance": "400000000000000000000" }, "c2779771f0536d79a8708f6931abc44b3035e999": { "balance": "20002000000000000000000" }, "ab27ba78c8e5e3daef31ad05aef0ff0325721e08": { "balance": "468000000000000000000" }, "563cb8803c1d32a25b27b64114852bd04d9c20cd": { "balance": "204400000000000000000" }, "08d4267feb15da9700f7ccc3c84a8918bf17cfde": { "balance": "1790000000000000000000" }, "d1778c13fbd968bc083cb7d1024ffe1f49d02caa": { "balance": "4020000000000000000000" }, "1796bcc97b8abc717f4b4a7c6b1036ea2182639f": { "balance": "355242000000000000000" }, "beecd6af900c8b064afcc6073f2d85d59af11956": { "balance": "2000000000000000000000" }, "045ed7f6d9ee9f252e073268db022c6326adfc5b": { "balance": "100000000000000000000" }, "b88a37c27f78a617d5c091b7d5b73a3761e65f2a": { "balance": "2000000000000000000000" }, "72fb49c29d23a18950c4b2dc0ddf410f532d6f53": { "balance": "2000000000000000000000" }, "6ecaefa6fc3ee534626db02c6f85a0c395571e77": { "balance": "600000000000000000000" }, "d1811c55976980f083901d8a0db269222dfb5cfe": { "balance": "1550000000000000000000" }, "98855c7dfbee335344904a12c40c731795b13a54": { "balance": "1069600000000000000000" }, "92a898d46f19719c38126a8a3c27867ae2cee596": { "balance": "2000000000000000000000" }, "ca428863a5ca30369892d612183ef9fb1a04bcea": { "balance": "1520000000000000000000" }, "797427e3dbf0feae7a2506f12df1dc40326e8505": { "balance": "1000000000000000000000" }, "3d574fcf00fae1d98cc8bf9ddfa1b3953b9741bc": { "balance": "1970000000000000000000" }, "28818e18b610001321b31df6fe7d2815cdadc9f5": { "balance": "1000000000000000000000" }, "5f3e1e6739b0c62200e00a003691d9efb238d89f": { "balance": "3000000000000000000000" }, "d9d370fec63576ab15b318bf9e58364dc2a3552a": { "balance": "100000000000000000000" }, "b223bf1fbf80485ca2b5567d98db7bc3534dd669": { "balance": "4000000000000000000000" }, "7b27d0d1f3dd3c140294d0488b783ebf4015277d": { "balance": "400000000000000000000" }, "7930c2d9cbfa87f510f8f98777ff8a8448ca5629": { "balance": "199955000000000000000" }, "820c19291196505b65059d9914b7090be1db87de": { "balance": "140000000000000000000" }, "e545ee84ea48e564161e9482d59bcf406a602ca2": { "balance": "1850000000000000000000" }, "af4cf41785161f571d0ca69c94f8021f41294eca": { "balance": "9850000000000000000000" }, "7a4f9b850690c7c94600dbee0ca4b0a411e9c221": { "balance": "1910000000000000000000" }, "ddab6b51a9030b40fb95cf0b748a059c2417bec7": { "balance": "2000000000000000000000" }, "315ef2da620fd330d12ee55de5f329a696e0a968": { "balance": "150000000000000000000" }, "4db1c43a0f834d7d0478b8960767ec1ac44c9aeb": { "balance": "872870000000000000000" }, "2fef81478a4b2e8098db5ff387ba2153f4e22b79": { "balance": "999000000000000000000" }, "6c6aa0d30b64721990b9504a863fa0bfb5e57da7": { "balance": "2700000000000000000000" }, "33380c6fff5acd2651309629db9a71bf3f20c5ba": { "balance": "16100000000000000000000" }, "4eebf1205d0cc20cee6c7f8ff3115f56d48fba26": { "balance": "19400000000000000000" }, "03cc9d2d21f86b84ac8ceaf971dba78a90e62570": { "balance": "1610000000000000000000" }, "728f9ab080157db3073156dbca1a169ef3179407": { "balance": "500000000000000000000" }, "30ed11b77bc17e5e6694c8bc5b6e4798f68d9ca7": { "balance": "143731500000000000000000" }, "f617b967b9bd485f7695d2ef51fb7792d898f500": { "balance": "500000000000000000000" }, "c0cbad3ccdf654da22cbcf5c786597ca1955c115": { "balance": "2000000000000000000000" }, "80522ddf944ec52e27d724ed4c93e1f7be6083d6": { "balance": "200000000000000000000" }, "4e90ccb13258acaa9f4febc0a34292f95991e230": { "balance": "15800000000000000000" }, "ff207308ced238a6c01ad0213ca9eb4465d42590": { "balance": "1999944000000000000000" }, "35f2949cf78bc219bb4f01907cf3b4b3d3865482": { "balance": "289800000000000000000" }, "68f525921dc11c329b754fbf3e529fc723c834cd": { "balance": "1610000000000000000000" }, "81139bfdcca656c430203f72958c543b6580d40c": { "balance": "2000000000000000000000" }, "9d511543b3d9dc60d47f09d49d01b6c498d82078": { "balance": "11245000000000000000000" }, "084d103254759b343cb2b9c2d8ff9e1ac5f14596": { "balance": "7600000000000000000000" }, "b323dcbf2eddc5382ee4bbbb201ca3931be8b438": { "balance": "2000000000000000000000" }, "349d2c918fd09e2807318e66ce432909176bd50b": { "balance": "1120000000000000000000" }, "b535f8db879fc67fec58824a5cbe6e5498aba692": { "balance": "1910000000000000000000" }, "824074312806da4748434266ee002140e3819ac2": { "balance": "1507000000000000000000" }, "e8ef100d7ce0895832f2678df72d4acf8c28b8e3": { "balance": "500038000000000000000" }, "84af1b157342d54368260d17876230a534b54b0e": { "balance": "985000000000000000000" }, "419a71a36c11d105e0f2aef5a3e598078e85c80b": { "balance": "5000000000000000000000" }, "55af092f94ba6a79918b0cf939eab3f01b3f51c7": { "balance": "149940000000000000000" }, "35a549e8fd6c368d6dcca6d2e7d18e4db95f5284": { "balance": "499938000000000000000" }, "f0e2649c7e6a3f2c5dfe33bbfbd927ca3c350a58": { "balance": "2000000000000000000000" }, "f4b759cc8a1c75f80849ebbcda878dc8f0d66de4": { "balance": "400000000000000000000" }, "21846f2fdf5a41ed8df36e5ed8544df75988ece3": { "balance": "1999944000000000000000" }, "229ff80bf5708009a9f739e0f8b560914016d5a6": { "balance": "333333000000000000000" }, "da505537537ffb33c415fec64e69bae090c5f60f": { "balance": "160000000000000000000" }, "b91d9e916cd40d193db60e79202778a0087716fc": { "balance": "404800000000000000000" }, "bb6823a1bd819f13515538264a2de052b4442208": { "balance": "25610000000000000000" }, "459393d63a063ef3721e16bd9fde45ee9dbd77fb": { "balance": "1968818000000000000000" }, "95f62d0243ede61dad9a3165f53905270d54e242": { "balance": "1610000000000000000000" }, "b0bb29a861ea1d424d45acd4bfc492fb8ed809b7": { "balance": "80000000000000000000" }, "5e74ed80e9655788e1bb269752319667fe754e5a": { "balance": "56000000000000000000" }, "a276b058cb98d88beedb67e543506c9a0d9470d8": { "balance": "2668652000000000000000" }, "8ae9ef8c8a8adfa6ab798ab2cdc405082a1bbb70": { "balance": "2000000000000000000000" }, "e5102c3b711b810344197419b1cd8a7059f13e32": { "balance": "299999000000000000000" }, "c32038ca52aee19745be5c31fcdc54148bb2c4d0": { "balance": "49984000000000000000" }, "13e321728c9c57628058e93fc866a032dd0bda90": { "balance": "714580000000000000000" }, "c2bae4a233c2d85724f0dabebda0249d833e37d3": { "balance": "5000000000000000000000" }, "10d32416722ca4e648630548ead91edd79c06aff": { "balance": "100000000000000000000" }, "d5f07552b5c693c20067b378b809cee853b8f136": { "balance": "505540000000000000000" }, "8668af868a1e98885f937f2615ded6751804eb2d": { "balance": "20000000000000000000" }, "139d3531c9922ad56269f6309aa789fb2485f98c": { "balance": "4000000000000000000000" }, "1d29c7aab42b2048d2b25225d498dba67a03fbb2": { "balance": "200000000000000000000" }, "d35075ca61fe59d123969c36a82d1ab2d918aa38": { "balance": "2674000000000000000000" }, "d6fc0446c6a8d40ae3551db7e701d1fa876e4a49": { "balance": "2000000000000000000000" }, "fccd0d1ecee27addea95f6857aeec8c7a04b28ee": { "balance": "10000000000000000000000" }, "c12cfb7b3df70fceca0ede263500e27873f8ed16": { "balance": "1000000000000000000000" }, "d0db456178206f5c4430fe005063903c3d7a49a7": { "balance": "706245000000000000000" }, "73cf80ae9688e1580e68e782cd0811f7aa494d2c": { "balance": "7760000000000000000000" }, "d60651e393783423e5cc1bc5f889e44ef7ea243e": { "balance": "398800000000000000000" }, "048a8970ea4145c64d5517b8de5b46d0595aad06": { "balance": "20000000000000000000000" }, "dd9b485a3b1cd33a6a9c62f1e5bee92701856d25": { "balance": "225073000000000000000" }, "5b287c7e734299e727626f93fb1187a60d5057fe": { "balance": "101230000000000000000" }, "635c00fdf035bca15fa3610df3384e0fb79068b1": { "balance": "9000000000000000000000" }, "630a913a9031c9492abd4c41dbb15054cfec4416": { "balance": "5688000000000000000000" }, "af3614dcb68a36e45a4e911e62796247222d595b": { "balance": "2259800000000000000000" }, "335e22025b7a77c3a074c78b8e3dfe071341946e": { "balance": "10178744000000000000000" }, "f0e1dfa42adeac2f17f6fdf584c94862fd563393": { "balance": "500000000000000000000" }, "1a9e702f385dcd105e8b9fa428eea21c57ff528a": { "balance": "1400000000000000000000" }, "8ce4949d8a16542d423c17984e6739fa72ceb177": { "balance": "24999975000000000000000" }, "5f29c9de765dde25852af07d33f2ce468fd20982": { "balance": "2000000000000000000000" }, "dbf5f061a0f48e5e69618739a77d2ec19768d201": { "balance": "152000000000000000000" }, "b247cf9c72ec482af3eaa759658f793d670a570c": { "balance": "912000000000000000000" }, "99f4147ccc6bcb80cc842e69f6d00e30fa4133d9": { "balance": "400000000000000000000" }, "ba6d31b9a261d640b5dea51ef2162c3109f1eba8": { "balance": "5000000000000000000000" }, "f05ba8d7b68539d933300bc9289c3d9474d0419e": { "balance": "126400000000000000000" }, "682e96276f518d31d7e56e30dfb009c1218201bd": { "balance": "20000000000000000000" }, "0927220492194b2eda9fc4bbe38f25d681dfd36c": { "balance": "6000000000000000000000" }, "a3c33afc8cb4704e23153de2049d35ae71332472": { "balance": "799600000000000000000" }, "05c736d365aa37b5c0be9c12c8ad5cd903c32cf9": { "balance": "6002000000000000000000" }, "d8eef4cf4beb01ee20d111748b61cb4d3f641a01": { "balance": "2740000000000000000000" }, "16c1bf5b7dc9c83c179efacbcf2eb174e3561cb3": { "balance": "1000000000000000000000" }, "d79db5ab43621a7a3da795e58929f3dd25af67d9": { "balance": "1999944000000000000000" }, "28efae6356509edface89fc61a7fdcdb39eea8e5": { "balance": "5348000000000000000000" }, "c55005a6c37e8ca7e543ce259973a3cace961a4a": { "balance": "2000000000000000000000" }, "ab3d86bc82927e0cd421d146e07f919327cdf6f9": { "balance": "1910000000000000000000" }, "b74ed2666001c16333cf7af59e4a3d4860363b9c": { "balance": "193600000000000000000" }, "1899f69f653b05a5a6e81f480711d09bbf97588c": { "balance": "1955000000000000000000" }, "27fc85a49cff90dbcfdadc9ddd40d6b9a2210a6c": { "balance": "100000000000000000000" }, "cd1ed263fbf6f6f7b48aef8f733d329d4382c7c7": { "balance": "18500000000000000000" }, "d97fe6f53f2a58f6d76d752adf74a8a2c18e9074": { "balance": "309990000000000000000" }, "80da2fdda29a9e27f9e115975e69ae9cfbf3f27e": { "balance": "200000000000000000000" }, "09146ea3885176f07782e1fe30dce3ce24c49e1f": { "balance": "20000000000000000000" }, "393ff4255e5c658f2e7f10ecbd292572671bc2d2": { "balance": "2000000000000000000000" }, "a390ca122b8501ee3e5e07a8ca4b419f7e4dae15": { "balance": "100000000000000000000" }, "6d9193996b194617211106d1635eb26cc4b66c6c": { "balance": "399640000000000000000" }, "999c49c174ca13bc836c1e0a92bff48b271543ca": { "balance": "3280000000000000000000" }, "7421ce5be381738ddc83f02621974ff0686c79b8": { "balance": "1632000000000000000000" }, "6be9030ee6e2fbc491aca3de4022d301772b7b7d": { "balance": "26740000000000000000" }, "81bd75abd865e0c3f04a0b4fdbcb74d34082fbb7": { "balance": "4000000000000000000000" }, "8bc1ff8714828bf286ff7e8a7709106548ed1b18": { "balance": "10000000000000000000000" }, "a0aadbd9509722705f6d2358a5c79f37970f00f6": { "balance": "200000000000000000000" }, "3d881433f04a7d0d27f84944e08a512da3555287": { "balance": "1200000000000000000000" }, "cc1d6ead01aada3e8dc7b95dca25df26eefa639d": { "balance": "2000000000000000000000" }, "35106ba94e8563d4b3cb3c5c692c10e604b7ced8": { "balance": "2000000000000000000000" }, "4d8697af0fbf2ca36e8768f4af22133570685a60": { "balance": "20000000000000000000" }, "1afcc585896cd0ede129ee2de5c19ea811540b64": { "balance": "3231259000000000000000" }, "e5215631b14248d45a255296bed1fbfa0330ff35": { "balance": "1310000000000000000000" }, "e3878f91ca86053fced5444686a330e09cc388fb": { "balance": "194000000000000000000" }, "555df19390c16d01298772bae8bc3a1152199cbd": { "balance": "200000000000000000000" }, "dc3dae59ed0fe18b58511e6fe2fb69b219689423": { "balance": "100000000000000000000" }, "74648caac748dd135cd91ea14c28e1bd4d7ff6ae": { "balance": "3100000000000000000000" }, "cf2e2ad635e9861ae95cb9bafcca036b5281f5ce": { "balance": "35200000000000000000000" }, "14eec09bf03e352bd6ff1b1e876be664ceffd0cf": { "balance": "20094000000000000000" }, "856e5ab3f64c9ab56b009393b01664fc0324050e": { "balance": "1790000000000000000000" }, "632b9149d70178a7333634275e82d5953f27967b": { "balance": "700000000000000000000" }, "2a39190a4fde83dfb3ddcb4c5fbb83ac6c49755c": { "balance": "1000000000000000000000" }, "369ef761195f3a373e24ece6cd22520fe0b9e86e": { "balance": "534933000000000000000" }, "16afa787fc9f94bdff6976b1a42f430a8bf6fb0f": { "balance": "2000000000000000000000" }, "1b0b31afff4b6df3653a94d7c87978ae35f34aae": { "balance": "354600000000000000000" }, "b4d82f2e69943f7de0f5f7743879406fac2e9cec": { "balance": "40000000000000000000" }, "09d6cefd75b0c4b3f8f1d687a522c96123f1f539": { "balance": "6000000000000000000000" }, "01577afd4e50890247c9b10d44af73229aec884f": { "balance": "680000000000000000000" }, "a35606d51220ee7f2146d411582ee4ee4a45596e": { "balance": "3996800000000000000000" }, "352e77c861696ef96ad54934f894aa8ea35151dd": { "balance": "1000000000000000000000" }, "b87f5376c2de0b6cc3c179c06087aa473d6b4674": { "balance": "1337000000000000000000" }, "5b49afcd75447838f6e7ceda8d21777d4fc1c3c0": { "balance": "4000000000000000000000" }, "b884add88d83dc564ab8e0e02cbdb63919aea844": { "balance": "2000000000000000000000" }, "5c312a56c784b122099b764d059c21ece95e84ca": { "balance": "95000000000000000000" }, "4697baaf9ccb603fd30430689d435445e9c98bf5": { "balance": "199600000000000000000" }, "c625f8c98d27a09a1bcabd5128b1c2a94856af30": { "balance": "200000000000000000000" }, "19f5caf4c40e6908813c0745b0aea9586d9dd931": { "balance": "664000000000000000000" }, "1e596a81b357c6f24970cc313df6dbdaabd0d09e": { "balance": "2000000000000000000000" }, "c1631228efbf2a2e3a4092ee8900c639ed34fbc8": { "balance": "955000000000000000000" }, "6f6cf20649a9e973177ac67dbadee4ebe5c7bdda": { "balance": "5080000000000000000000" }, "5fa7bfe043886127d4011d8356a47e947963aca8": { "balance": "1820000000000000000000" }, "6af8e55969682c715f48ad4fc0fbb67eb59795a3": { "balance": "2000000000000000000000" }, "122f56122549d168a5c5e267f52662e5c5cce5c8": { "balance": "185000000000000000000" }, "7713ab8037411c09ba687f6f9364f0d3239fac28": { "balance": "10000000000000000000000" }, "31ccc616b3118268e75d9ab8996c8858ebd7f3c3": { "balance": "399924000000000000000" }, "09c88f917e4d6ad473fa12e98ea3c4472a5ed6da": { "balance": "10000000000000000000000" }, "e796fd4e839b4c95d7510fb7c5c72b83c6c3e3c7": { "balance": "512200000000000000000" }, "a8285539869d88f8a961533755717d7eb65576ae": { "balance": "200000000000000000000" }, "d929c65d69d5bbaea59762662ef418bc21ad924a": { "balance": "1000000000000000000000" }, "f7418aa0e713d248228776b2e7434222ae75e3a5": { "balance": "2000000000000000000000" }, "7f0b90a1fdd48f27b268feb38382e55ddb50ef0f": { "balance": "940000000000000000000" }, "34a0431fff5ead927f3c69649616dc6e97945f6f": { "balance": "400000000000000000000" }, "1b3cb81e51011b549d78bf720b0d924ac763a7c2": { "balance": "560000000000000000000000" }, "155b3779bb6d56342e2fda817b5b2d81c7f41327": { "balance": "50200000000000000000" }, "ecd486fc196791b92cf612d348614f9156488b7e": { "balance": "12000000000000000000000" }, "82a8cbbfdff02b2e38ae4bbfca15f1f0e83b1aea": { "balance": "84999000000000000000" }, "06b0c1e37f5a5ec4bbf50840548f9d3ac0288897": { "balance": "4000098000000000000000" }, "e6d49f86c228f47367a35e886caacb271e539429": { "balance": "412656000000000000000" }, "704a6eb41ba34f13addde7d2db7df04915c7a221": { "balance": "1820000000000000000000" }, "745ccf2d819edbbddea8117b5c49ed3c2a066e93": { "balance": "4000000000000000000000" }, "6d3b7836a2b9d899721a4d237b522385dce8dfcd": { "balance": "1000070000000000000000" }, "856aa23c82d7215bec8d57f60ad75ef14fa35f44": { "balance": "20000000000000000000000" }, "ea79057dabef5e64e7b44f7f18648e7e533718d2": { "balance": "200000000000000000000" }, "9df057cd03a4e27e8e032f857985fd7f01adc8d7": { "balance": "2000000000000000000000" }, "5f2f07d2d697e8c567fcfdfe020f49f360be2139": { "balance": "2000000000000000000000" }, "5efbdfe5389999633c26605a5bfc2c1bb5959393": { "balance": "69200000000000000000" }, "047e87c8f7d1fce3b01353a85862a948ac049f3e": { "balance": "1490000000000000000000" }, "265383d68b52d034161bfab01ae1b047942fbc32": { "balance": "21000600000000000000000" }, "760ff3354e0fde938d0fb5b82cef5ba15c3d2916": { "balance": "10000000000000000000000" }, "bc46d537cf2edd403565bde733b2e34b215001bd": { "balance": "20000000000000000000000" }, "ee58fb3db29070d0130188ce472be0a172b89055": { "balance": "10021400000000000000000" }, "75abe5270f3a78ce007cf37f8fbc045d489b7bb1": { "balance": "1999944000000000000000" }, "5fc6c11426b4a1eae7e51dd512ad1090c6f1a85b": { "balance": "2730000000000000000000" }, "26cfffd052152bb3f957b478d5f98b233a7c2b92": { "balance": "4000000000000000000000" }, "0a4a011995c681bc999fdd79754e9a324ae3b379": { "balance": "41350300000000000000000" }, "6fa60df818a5446418b1bbd62826e0b9825e1318": { "balance": "13200000000000000000000" }, "63d55ad99b9137fd1b20cc2b4f03d42cbaddf334": { "balance": "400000000000000000000" }, "679b9a109930517e8999099ccf2a914c4c8dd934": { "balance": "60000000000000000000" }, "3e83544f0082552572c782bee5d218f1ef064a9d": { "balance": "100076000000000000000" }, "968b14648f018333687cd213fa640aec04ce6323": { "balance": "1000000000000000000000" }, "427b462ab84e5091f48a46eb0cdc92ddcb26e078": { "balance": "2000000000000000000000" }, "df8510793eee811c2dab1c93c6f4473f30fbef5b": { "balance": "1000000000000000000000" }, "362fbcb10662370a068fc2652602a2577937cce6": { "balance": "200000000000000000000" }, "5d83b21bd2712360436b67a597ee3378db3e7ae4": { "balance": "2000000000000000000000" }, "5777441c83e03f0be8dd340bde636850847c620b": { "balance": "10000000000000000000000" }, "c94a585203da7bbafd93e15884e660d4b1ead854": { "balance": "7000000000000000000000" }, "35a08081799173e001cc5bd46a02406dc95d1787": { "balance": "10000000000000000000000" }, "21d13f0c4024e967d9470791b50f22de3afecf1b": { "balance": "4452210000000000000000" }, "fdfd6134c04a8ab7eb16f00643f8fed7daaaecb2": { "balance": "400000000000000000000" }, "fd812bc69fb170ef57e2327e80affd14f8e4b6d2": { "balance": "2000000000000000000000" }, "7148aef33261d8031fac3f7182ff35928daf54d9": { "balance": "4100000000000000000000" }, "0b06390f2437b20ec4a3d3431b3279c6583e5ed7": { "balance": "194000000000000000000" }, "4909b31998ead414b8fb0e846bd5cbde393935be": { "balance": "4000000000000000000000" }, "b70dba9391682b4a364e77fe99256301a6c0bf1f": { "balance": "200000000000000000000" }, "6b83bae7b565244558555bcf4ba8da2011891c17": { "balance": "2000000000000000000000" }, "70a03549aa6168e97e88a508330a5a0bea74711a": { "balance": "1337000000000000000000" }, "0fc9a0e34145fbfdd2c9d2a499b617d7a02969b9": { "balance": "180000000000000000000" }, "2ddf40905769bcc426cb2c2938ffe077e1e89d98": { "balance": "3000000000000000000000" }, "794b51c39e53d9e762b0613b829a44b472f4fff3": { "balance": "667965000000000000000" }, "d062588171cf99bbeb58f126b870f9a3728d61ec": { "balance": "4500000000000000000000" }, "8db185fe1b70a94a6a080e7e23a8bedc4acbf34b": { "balance": "1400000000000000000000" }, "e73bfeada6f0fd016fbc843ebcf6e370a65be70c": { "balance": "1970000000000000000000" }, "79ed10cf1f6db48206b50919b9b697081fbdaaf3": { "balance": "2000000000000000000000" }, "276b0521b0e68b277df0bb32f3fd48326350bfb2": { "balance": "50000000000000000000" }, "2e439348df8a4277b22a768457d1158e97c40904": { "balance": "776970000000000000000" }, "6c25327f8dcbb2f45e561e86e35d8850e53ab059": { "balance": "1103200000000000000000" }, "04d73896cf6593a691972a13a6e4871ff2c42b13": { "balance": "2000000000000000000000" }, "b10fd2a647102f881f74c9fbc37da632949f2375": { "balance": "40000000000000000000" }, "615f82365c5101f071e7d2cb6af14f7aad2c16c6": { "balance": "20000000000000000000" }, "93aa8f92ebfff991fc055e906e651ac768d32bc8": { "balance": "940000000000000000000" }, "0cbf8770f0d1082e5c20c5aead34e5fca9ae7ae2": { "balance": "1000000000000000000000" }, "ffc9cc3094b041ad0e076f968a0de3b167255866": { "balance": "432400000000000000000" }, "46531e8b1bde097fdf849d6d119885608a008df7": { "balance": "200000000000000000000" }, "23cd2598a20e149ead2ad69379576ecedb60e38e": { "balance": "2000000000000000000000" }, "85ca8bc6da2803d0725f5e1a456c89f9bc774e2f": { "balance": "600000000000000000000" }, "c0725ec2bdc33a1d826071dea29d62d4385a8c25": { "balance": "40740000000000000000000" }, "0e4765790352656bc656682c24fc5ef3e76a23c7": { "balance": "46610000000000000000" }, "2ef9e465716acacfb8c8252fa8e7bc7969ebf6e4": { "balance": "2760000000000000000000" }, "0ec5308b31282e218fc9e759d4fec5db3708cec4": { "balance": "1001000000000000000000" }, "bf7701fc6225d5a17815438a8941d21ebc5d059d": { "balance": "1880000000000000000000" }, "c489c83ffbb0252ac0dbe3521217630e0f491f14": { "balance": "4000000000000000000000" }, "8eb51774af206b966b8909c45aa6722748802c0c": { "balance": "500000000000000000000" }, "7b9226d46fe751940bc416a798b69ccf0dfab667": { "balance": "4200000000000000000000" }, "8f660f8b2e4c7cc2b4ac9c47ed28508d5f8f8650": { "balance": "20000000000000000000000" }, "9f19fac8a32437d80ac6837a0bb7841729f4972e": { "balance": "650100000000000000000" }, "201864a8f784c2277b0b7c9ee734f7b377eab648": { "balance": "4467000000000000000000" }, "a6101c961e8e1c15798ffcd0e3201d7786ec373a": { "balance": "6000000000000000000000" }, "d4ff46203efa23064b1caf00516e28704a82a4f8": { "balance": "1337000000000000000000" }, "aa136b47962bb8b4fb540db4ccf5fdd042ffb8cf": { "balance": "500038000000000000000" }, "704ae21d762d6e1dde28c235d13104597236db1a": { "balance": "2000000000000000000000" }, "f17a92e0361dbacecdc5de0d1894955af6a9b606": { "balance": "2000000000000000000000" }, "8b48e19d39dd35b66e6e1bb6b9c657cb2cf59d04": { "balance": "17844175000000000000000" }, "9ad47fdcf9cd942d28effd5b84115b31a658a13e": { "balance": "3290000000000000000000" }, "df0d08617bd252a911df8bd41a39b83ddf809673": { "balance": "10000000000000000000000" }, "4c666b86f1c5ee8ca41285f5bde4f79052081406": { "balance": "500000000000000000000" }, "88dec5bd3f4eba2d18b8aacefa7b721548c319ba": { "balance": "1370000000000000000000" }, "9f9fe0c95f10fee87af1af207236c8f3614ef02f": { "balance": "6000000000000000000000" }, "f7d0d310acea18406138baaabbfe0571e80de85f": { "balance": "1337000000000000000000" }, "9569c63a9284a805626db3a32e9d236393476151": { "balance": "1970000000000000000000" }, "5d5c2c1099bbeefb267e74b58880b444d94449e0": { "balance": "253574000000000000000" }, "8c6ae7a05a1de57582ae2768204276c0ff47ed03": { "balance": "208000000000000000000000" }, "432d884bd69db1acc0d89c64ade4cb4fc3a88b7a": { "balance": "2483000000000000000000" }, "672cbca8440a8577097b19aff593a2ad9d28a756": { "balance": "80000000000000000000" }, "19df9445a81c1b3d804aeaeb6f6e204e4236663f": { "balance": "37387000000000000000" }, "1cb5f33b4d488936d13e3161da33a1da7df70d1b": { "balance": "200000000000000000000" }, "df60f18c812a11ed4e2776e7a80ecf5e5305b3d6": { "balance": "900000000000000000000" }, "c99a9cd6c9c1be3534eecd92ecc22f5c38e9515b": { "balance": "4821030000000000000000" }, "00c40fe2095423509b9fd9b754323158af2310f3": { "balance": "0" }, "da4a5f557f3bab390a92f49b9b900af30c46ae80": { "balance": "10000000000000000000000" }, "f36df02fbd89607347afce2969b9c4236a58a506": { "balance": "2000000000000000000000" }, "c549df83c6f65eec0f1dc9a0934a5c5f3a50fd88": { "balance": "2910000000000000000000" }, "9f662e95274121f177566e636d23964cf1fd686f": { "balance": "2000000000000000000000" }, "5a267331facb262daaecd9dd63a9700c5f5259df": { "balance": "100000000000000000000" }, "117d9aa3c4d13bee12c7500f09f5dd1c66c46504": { "balance": "206000000000000000000" }, "1b4d07acd38183a61bb2783d2b7b178dd502ac8d": { "balance": "200000000000000000000" }, "3c0c3defac9cea7acc319a96c30b8e1fedab4574": { "balance": "1940000000000000000000" }, "e4dc22ed595bf0a337c01e03cc6be744255fc9e8": { "balance": "191000000000000000000" }, "8f067c7c1bbd57780b7b9eeb9ec0032f90d0dcf9": { "balance": "20000000000000000000000" }, "40e2440ae142c880366a12c6d4102f4b8434b62a": { "balance": "1000000000000000000000" }, "f9ece022bccd2c92346911e79dd50303c01e0188": { "balance": "1000000000000000000000" }, "f70328ef97625fe745faa49ee0f9d4aa3b0dfb69": { "balance": "1000000000000000000000" }, "b6aacb8cb30bab2ae4a2424626e6e12b02d04605": { "balance": "8000000000000000000000" }, "154459fa2f21318e3434449789d826cdc1570ce5": { "balance": "2000000000000000000000" }, "684a44c069339d08e19a75668bdba303be855332": { "balance": "70000000000000000000000" }, "9fe501aa57ead79278937cd6308c5cfa7a5629fe": { "balance": "50003000000000000000" }, "3e45bd55db9060eced923bb9cb733cb3573fb531": { "balance": "1640000000000000000000" }, "9c9f3b8a811b21f3ff3fe20fe970051ce66a824f": { "balance": "1157740000000000000000" }, "e99aece90541cae224b87da673965e0aeb296afd": { "balance": "920000000000000000000" }, "2f6dce1330c59ef921602154572d4d4bacbd048a": { "balance": "1000000000000000000000" }, "6a6353b971589f18f2955cba28abe8acce6a5761": { "balance": "3000000000000000000000" }, "98c10ebf2c4f97cba5a1ab3f2aafe1cac423f8cb": { "balance": "300000000000000000000" }, "8077c3e4c445586e094ce102937fa05b737b568c": { "balance": "100000000000000000000" }, "13371f92a56ea8381e43059a95128bdc4d43c5a6": { "balance": "1000000000000000000000" }, "35a6885083c899dabbf530ed6c12f4dd3a204cf5": { "balance": "200000000000000000000" }, "36b2c85e3aeeebb70d63c4a4730ce2e8e88a3624": { "balance": "10000000000000000000000" }, "5ce44068b8f4a3fe799e6a8311dbfdeda29dee0e": { "balance": "2000000000000000000000" }, "6fa6388d402b30afe59934c3b9e13d1186476018": { "balance": "670000000000000000000" }, "8251358ca4e060ddb559ca58bc0bddbeb4070203": { "balance": "2000000000000000000000" }, "17e86f3b5b30c0ba59f2b2e858425ba89f0a10b0": { "balance": "2000000000000000000000" }, "298ec76b440d8807b3f78b5f90979bee42ed43db": { "balance": "30000000000000000000000" }, "ce4b065dbcb23047203262fb48c1188364977470": { "balance": "500000000000000000000" }, "c8e2adeb545e499d982c0c117363ceb489c5b11f": { "balance": "985000000000000000000" }, "9928ff715afc3a2b60f8eb4cc4ba4ee8dab6e59d": { "balance": "440000000000000000000" }, "c76130c73cb9210238025c9df95d0be54ac67fbe": { "balance": "1500000000000000000000" }, "72d03d4dfab3500cf89b86866f15d4528e14a195": { "balance": "4488000000000000000000" }, "d193e583d6070563e7b862b9614a47e99489f3e5": { "balance": "999972000000000000000" }, "4df140ba796585dd5489315bca4bba680adbb818": { "balance": "2674000000000000000000" }, "009eef0a0886056e3f69211853b9b7457f3782e4": { "balance": "3000512000000000000000" }, "6e255b700ae7138a4bacf22888a9e2c00a285eec": { "balance": "4000000000000000000000" }, "aa47a4ffc979363232c99b99fada0f2734b0aeee": { "balance": "8121800000000000000000" }, "9d069197d1de50045a186f5ec744ac40e8af91c6": { "balance": "2000000000000000000000" }, "b514882c979bb642a80dd38754d5b8c8296d9a07": { "balance": "955000000000000000000" }, "17c0478657e1d3d17aaa331dd429cecf91f8ae5d": { "balance": "999942000000000000000" }, "5f9616c47b4a67f406b95a14fe6fc268396f1721": { "balance": "200000000000000000000" }, "f70a998a717b338d1dd99854409b1a338deea4b0": { "balance": "2000000000000000000000" }, "d1ee905957fe7cc70ec8f2868b43fe47b13febff": { "balance": "44000000000000000000" }, "fc018a690ad6746dbe3acf9712ddca52b6250039": { "balance": "10000000000000000000000" }, "5118557d600d05c2fcbf3806ffbd93d02025d730": { "balance": "11360000000000000000000" }, "1ef5c9c73650cfbbde5c885531d427c7c3fe5544": { "balance": "6000000000000000000000" }, "d1a396dcdab2c7494130b3fd307820340dfd8c1f": { "balance": "17952000000000000000" }, "2d8e061892a5dcce21966ae1bb0788fd3e8ba059": { "balance": "250066000000000000000" }, "8834b2453471f324fb26be5b25166b5b5726025d": { "balance": "573000000000000000000" }, "14f221159518783bc4a706676fc4f3c5ee405829": { "balance": "200000000000000000000" }, "c056d4bd6bf3cbacac65f8f5a0e3980b852740ae": { "balance": "100000000000000000000" }, "560536794a9e2b0049d10233c41adc5f418a264a": { "balance": "1000000000000000000000" }, "bc9e0ec6788f7df4c7fc210aacd220c27e45c910": { "balance": "500000000000000000000" }, "54bcb8e7f73cda3d73f4d38b2d0847e600ba0df8": { "balance": "1078000000000000000000" }, "4361d4846fafb377b6c0ee49a596a78ddf3516a3": { "balance": "3580000000000000000000" }, "41c3c2367534d13ba2b33f185cdbe6ac43c2fa31": { "balance": "4000000000000000000000" }, "5dc6f45fef26b06e3302313f884daf48e2746fb9": { "balance": "500000000000000000000" }, "ad414d29cb7ee973fec54e22a388491786cf5402": { "balance": "14000000000000000000000" }, "802dc3c4ff2d7d925ee2859f4a06d7ba60f1308c": { "balance": "98040000000000000000" }, "2aed2ce531c056b0097efc3c6de10c4762004ed9": { "balance": "10430000000000000000000" }, "39782ffe06ac78822a3c3a8afe305e50a56188ce": { "balance": "10000000000000000000000" }, "ec73833de4b810bb027810fc8f69f544e83c12d1": { "balance": "1000000000000000000000" }, "8d51a4cc62011322c696fd725b9fb8f53feaaa07": { "balance": "1000000000000000000000" }, "29298ccbdff689f87fe41aa6e98fdfb53deaf37a": { "balance": "19800000000000000000000" }, "827531a6c5817ae35f82b00b9754fcf74c55e232": { "balance": "3600000000000000000000" }, "9c581a60b61028d934167929b22d70b313c34fd0": { "balance": "50000000000000000000000" }, "0a077db13ffeb09484c217709d5886b8bf9c5a8b": { "balance": "4000000000000000000000" }, "07b7a57033f8f11330e4665e185d234e83ec140b": { "balance": "4325683000000000000000" }, "17f523f117bc9fe978aa481eb4f5561711371bc8": { "balance": "1999884000000000000000" }, "de42fcd24ce4239383304367595f068f0c610740": { "balance": "45120000000000000000" }, "2a46d353777176ff8e83ffa8001f4f70f9733aa5": { "balance": "106000000000000000000" }, "92e4392816e5f2ef5fb65837cec2c2325cc64922": { "balance": "10000000000000000000000" }, "9a3da65023a13020d22145cfc18bab10bd19ce4e": { "balance": "456516000000000000000" }, "1a085d43ec92414ea27b914fe767b6d46b1eef44": { "balance": "29550000000000000000000" }, "3b2367f8494b5fe18d683c055d89999c9f3d1b34": { "balance": "10000000000000000000000" }, "84244fc95a6957ed7c1504e49f30b8c35eca4b79": { "balance": "2000000000000000000000" }, "5e031b0a724471d476f3bcd2eb078338bf67fbef": { "balance": "18200000000000000000" }, "97e5cc6127c4f885be02f44b42d1c8b0ac91e493": { "balance": "200000000000000000000" }, "eb1cea7b45d1bd4d0e2a007bd3bfb354759e2c16": { "balance": "198000000000000000000" }, "72feaf124579523954645b7fafff0378d1c8242e": { "balance": "1000000000000000000000" }, "8d07d42d831c2d7c838aa1872b3ad5d277176823": { "balance": "349200000000000000000" }, "9637dc12723d9c78588542eab082664f3f038d9d": { "balance": "1000000000000000000000" }, "e84b55b525f1039e744b918cb3332492e45eca7a": { "balance": "200000000000000000000" }, "b1d6b01b94d854fe8b374aa65e895cf22aa2560e": { "balance": "940000000000000000000" }, "8161d940c3760100b9080529f8a60325030f6edc": { "balance": "300000000000000000000" }, "d30ee9a12b4d68abace6baca9ad7bf5cd1faf91c": { "balance": "1499936000000000000000" }, "057949e1ca0570469e4ce3c690ae613a6b01c559": { "balance": "200000000000000000000" }, "4bf8e26f4c2790da6533a2ac9abac3c69a199433": { "balance": "200000000000000000000" }, "36fec62c2c425e219b18448ad757009d8c54026f": { "balance": "400000000000000000000" }, "77bfe93ccda750847e41a1affee6b2da96e7214e": { "balance": "300000000000000000000" }, "cc48414d2ac4d42a5962f29eee4497092f431352": { "balance": "161000000000000000000" }, "ddbddd1bbd38ffade0305d30f02028d92e9f3aa8": { "balance": "2000000000000000000000" }, "30c01142907acb1565f70438b9980ae731818738": { "balance": "2000000000000000000000" }, "cffc49c1787eebb2b56cabe92404b636147d4558": { "balance": "5679305000000000000000" }, "f99eeece39fa7ef5076d855061384009792cf2e0": { "balance": "500000000000000000000" }, "e9b6a790009bc16642c8d820b7cde0e9fd16d8f5": { "balance": "3640000000000000000000" }, "03b41b51f41df20dd279bae18c12775f77ad771c": { "balance": "1000000000000000000000" }, "787d313fd36b053eeeaedbce74b9fb0678333289": { "balance": "27160000000000000000000" }, "35d2970f49dcc81ea9ee707e9c8a0ab2a8bb7463": { "balance": "1440000000000000000000" }, "4c0aca508b3caf5ee028bc707dd1e800b838f453": { "balance": "18200000000000000000" }, "514632efbd642c04de6ca342315d40dd90a2dba6": { "balance": "2674000000000000000000" }, "36810ff9d213a271eda2b8aa798be654fa4bbe06": { "balance": "2000000000000000000000" }, "0c088006c64b30c4ddafbc36cb5f05469eb62834": { "balance": "2000000000000000000000" }, "568df31856699bb5acfc1fe1d680df9960ca4359": { "balance": "1379999000000000000000" }, "d48e3f9357e303513841b3f84bda83fc89727587": { "balance": "1000000000000000000000" }, "953ef652e7b769f53d6e786a58952fa93ee6abe7": { "balance": "2860000000000000000000" }, "7c60a05f7a4a5f8cf2784391362e755a8341ef59": { "balance": "1892300000000000000000" }, "7a6b26f438d9a352449155b8876cbd17c9d99b64": { "balance": "6000000000000000000000" }, "68f719ae342bd7fef18a05cbb02f705ad38ed5b2": { "balance": "1050000000000000000000" }, "45ca8d956608f9e00a2f9974028640888465668f": { "balance": "2000000000000000000000" }, "3eaf316b87615d88f7adc77c58e712ed4d77966b": { "balance": "100141000000000000000" }, "1f0412bfedcd964e837d092c71a5fcbaf30126e2": { "balance": "20000000000000000000" }, "7471f72eeb300624eb282eab4d03723c649b1b58": { "balance": "8000000000000000000000" }, "9bf71f7fb537ac54f4e514947fa7ff6728f16d2f": { "balance": "33400000000000000000" }, "1098c774c20ca1daac5ddb620365316d353f109c": { "balance": "100000000000000000000" }, "7dd8d7a1a34fa1f8e73ccb005fc2a03a15b8229c": { "balance": "200000000000000000000" }, "0151fa5d17a2dce2d7f1eb39ef7fe2ad213d5d89": { "balance": "4000000000000000000000" }, "ad6628352ed3390bafa86d923e56014cfcb360f4": { "balance": "2000000000000000000000" }, "02af2459a93d0b3f4d062636236cd4b29e3bcecf": { "balance": "1910000000000000000000" }, "ace2abb63b0604409fbde3e716d2876d44e8e5dd": { "balance": "152000000000000000000" }, "e710dcd09b8101f9437bd97db90a73ef993d0bf4": { "balance": "386100000000000000000" }, "d43ee438d83de9a37562bb4e286cb1bd19f4964d": { "balance": "1000000000000000000000" }, "ea3779d14a13f6c78566bcde403591413a6239db": { "balance": "197000000000000000000000" }, "6704f169e0d0b36b57bbc39f3c45437b5ee3d28d": { "balance": "394000000000000000000" }, "5584423050e3c2051f0bbd8f44bd6dbc27ecb62c": { "balance": "3000000000000000000000" }, "2f315d9016e8ee5f536681202f9084b032544d4d": { "balance": "1037400000000000000000" }, "e1b63201fae1f129f95c7a116bd9dde5159c6cda": { "balance": "22837462000000000000000" }, "2bbe62eac80ca7f4d6fdee7e7d8e28b63acf770e": { "balance": "2396000000000000000000" }, "38da1ba2de9e2c954b092dd9d81204fd016ba016": { "balance": "10156000000000000000000" }, "8a86e4a51c013b1fb4c76bcf30667c78d52eedef": { "balance": "2000000000000000000000" }, "8f717ec1552f4c440084fba1154a81dc003ebdc0": { "balance": "10000000000000000000000" }, "c760971bbc181c6a7cf77441f24247d19ce9b4cf": { "balance": "2000000000000000000000" }, "7f150afb1a77c2b45928c268c1e9bdb4641d47d8": { "balance": "2000000000000000000000" }, "1ea334b5750807ea74aac5ab8694ec5f28aa77cf": { "balance": "492500000000000000000" }, "2afb058c3d31032b353bf24f09ae20d54de57dbe": { "balance": "1100000000000000000000" }, "caef027b1ab504c73f41f2a10979b474f97e309f": { "balance": "200000000000000000000" }, "5dd112f368c0e6ceff77a9df02a5481651a02fb7": { "balance": "169800000000000000000" }, "bd93e550403e2a06113ed4c3fba1a8913b19407e": { "balance": "2000000000000000000000" }, "500c16352e901d48ba8d04e2c767121772790b02": { "balance": "30239000000000000000" }, "d2a80327cbe55c4c7bd51ff9dde4ca648f9eb3f8": { "balance": "50000000000000000000" }, "355ccfe0e77d557b971be1a558bc02df9eee0594": { "balance": "1759120000000000000000" }, "5aed0e6cfe95f9d680c76472a81a2b680a7f93e2": { "balance": "197000000000000000000" }, "f56442f60e21691395d0bffaa9194dcaff12e2b7": { "balance": "260000000000000000000" }, "7db9eacc52e429dc83b461c5f4d86010e5383a28": { "balance": "1000000000000000000000" }, "4b984ef26c576e815a2eaed2f5177f07dbb1c476": { "balance": "1560000000000000000000" }, "9846648836a307a057184fd51f628a5f8c12427c": { "balance": "19100000000000000000000" }, "4af0db077bb9ba5e443e21e148e59f379105c592": { "balance": "600000000000000000000" }, "e96e2d3813efd1165f12f602f97f4a62909d3c66": { "balance": "2300000000000000000000" }, "30e789b3d2465e946e6210fa5b35de4e8c93085f": { "balance": "2000000000000000000000" }, "97f99b6ba31346cd98a9fe4c308f87c5a58c5151": { "balance": "6000000000000000000000" }, "595e23d788a2d4bb85a15df7136d264a635511b3": { "balance": "3940000000000000000000" }, "2f61efa5819d705f2b1e4ee754aeb8a819506a75": { "balance": "1460000000000000000000" }, "3554947b7b947b0040da52ca180925c6d3b88ffe": { "balance": "66850000000000000000" }, "8feffadb387a1547fb284da9b8147f3e7c6dc6da": { "balance": "837200000000000000000" }, "258939bbf00c9de9af5338f5d714abf6d0c1c671": { "balance": "1550000000000000000000" }, "5b333696e04cca1692e71986579c920d6b2916f9": { "balance": "500000000000000000000" }, "5381448503c0c702542b1de7cc5fb5f6ab1cf6a5": { "balance": "8000000000000000000000" }, "7e81f6449a03374191f3b7cb05d938b72e090dff": { "balance": "100000000000000000000" }, "4ef1c214633ad9c0703b4e2374a2e33e3e429291": { "balance": "1337000000000000000000" }, "fed8476d10d584b38bfa6737600ef19d35c41ed8": { "balance": "1820000000000000000000" }, "1a95c9b7546b5d1786c3858fb1236446bc0ca4ce": { "balance": "1970000000000000000000" }, "3b07db5a357f5af2484cbc9d77d73b1fd0519fc7": { "balance": "500000000000000000000" }, "5f68a24c7eb4117667737b33393fb3c2148a53b6": { "balance": "51800000000000000000" }, "d8f665fd8cd5c2bcc6ddc0a8ae521e4dc6aa6060": { "balance": "1700000000000000000000" }, "d66acc0d11b689cea6d9ea5ff4014c224a5dc7c4": { "balance": "18200000000000000000" }, "6e72b2a1186a8e2916543b1cb36a68870ea5d197": { "balance": "186000000000000000000" }, "5102a4a42077e11c58df4773e3ac944623a66d9f": { "balance": "2000325000000000000000" }, "72480bede81ad96423f2228b5c61be44fb523100": { "balance": "6400000000000000000000" }, "e076db30ab486f79194ebbc45d8fab9a9242f654": { "balance": "4840000000000000000000" }, "8ceea15eec3bdad8023f98ecf25b2b8fef27db29": { "balance": "2000000000000000000000" }, "40652360d6716dc55cf9aab21f3482f816cc2cbd": { "balance": "10000000000000000000000" }, "13e02fb448d6c84ae17db310ad286d056160da95": { "balance": "2000000000000000000000" }, "d6598b1386e93c5ccb9602ff4bbbecdbd3701dc4": { "balance": "224096000000000000000" }, "d5ea472cb9466018110af00c37495b5c2c713112": { "balance": "4997800000000000000000" }, "bb75cb5051a0b0944b4673ca752a97037f7c8c15": { "balance": "200000000000000000000" }, "8af626a5f327d7506589eeb7010ff9c9446020d2": { "balance": "1400000000000000000000" }, "318c76ecfd8af68d70555352e1f601e35988042d": { "balance": "501600000000000000000" }, "5c3d19441d196cb443662020fcad7fbb79b29e78": { "balance": "14300000000000000000" }, "27101a0f56d39a88c5a84f9b324cdde33e5cb68c": { "balance": "2000000000000000000000" }, "e229e746a83f2ce253b0b03eb1472411b57e5700": { "balance": "5730000000000000000000" }, "604cdf18628dbfa8329194d478dd5201eecc4be7": { "balance": "23000000000000000000" }, "657473774f63ac3d6279fd0743d5790c4f161503": { "balance": "200000000000000000000" }, "1ddefefd35ab8f658b2471e54790bc17af98dea4": { "balance": "1000000000000000000000" }, "ac3900298dd14d7cc96d4abb428da1bae213ffed": { "balance": "24730250000000000000000" }, "944f07b96f90c5f0d7c0c580533149f3f585a078": { "balance": "74000000000000000000" }, "232c6d03b5b6e6711efff190e49c28eef36c82b0": { "balance": "1337000000000000000000" }, "c87c77e3c24adecdcd1038a38b56e18dead3b702": { "balance": "8800000000000000000000" }, "c4b6e5f09cc1b90df07803ce3d4d13766a9c46f4": { "balance": "6000000000000000000000" }, "d44334b4e23a169a0c16bd21e866bba52d970587": { "balance": "2600000000000000000000" }, "7757a4b9cc3d0247ccaaeb9909a0e56e1dd6dcc2": { "balance": "20000000000000000000" }, "cf694081c76d18c64ca71382be5cd63b3cb476f8": { "balance": "1000000000000000000000" }, "133e4f15e1e39c53435930aaedf3e0fe56fde843": { "balance": "20000000000000000000" }, "f067fb10dfb293e998abe564c055e3348f9fbf1e": { "balance": "2000000000000000000000" }, "94449c01b32a7fa55af8104f42cdd844aa8cbc40": { "balance": "16548000000000000000000" }, "0e2094ac1654a46ba1c4d3a40bb8c17da7f39688": { "balance": "358000000000000000000" }, "738ca94db7ce8be1c3056cd6988eb376359f3353": { "balance": "25500000000000000000000" }, "0cfb172335b16c87d519cd1475530d20577f5e0e": { "balance": "100000000000000000000000" }, "3cb561ce86424b359891e364ec925ffeff277df7": { "balance": "200000000000000000000" }, "5f981039fcf50225e2adf762752112d1cc26b6e3": { "balance": "499954000000000000000" }, "b43657a50eecbc3077e005d8f8d94f377876bad4": { "balance": "35460000000000000000" }, "d07e511864b1cf9969e3560602829e32fc4e71f5": { "balance": "50000000000000000000" }, "11306c7d57588637780fc9fde8e98ecb008f0164": { "balance": "1999944000000000000000" }, "45ca9862003b4e40a3171fb5cafa9028cac8de19": { "balance": "13790000000000000000000" }, "231d94155dbcfe2a93a319b6171f63b20bd2b6fa": { "balance": "3819952000000000000000" }, "e7533e270cc61fa164ac1553455c105d04887e14": { "balance": "121550000000000000000" }, "070d5d364cb7bbf822fc2ca91a35bdd441b215d5": { "balance": "2000000000000000000000" }, "d475477fa56390d33017518d6711027f05f28dbf": { "balance": "1975032000000000000000" }, "cea34a4dd93dd9aefd399002a97d997a1b4b89cd": { "balance": "1500000000000000000000" }, "560becdf52b71f3d8827d927610f1a980f33716f": { "balance": "429413000000000000000" }, "f632adff490da4b72d1236d04b510f74d2faa3cd": { "balance": "1400000000000000000000" }, "2fdd9b79df8df530ad63c20e62af431ae99216b8": { "balance": "21000000000000000000" }, "535201a0a1d73422801f55ded4dfaee4fbaa6e3b": { "balance": "39641000000000000000" }, "409d5a962edeeebea178018c0f38b9cdb213f289": { "balance": "20000000000000000000" }, "9d911f3682f32fe0792e9fb6ff3cfc47f589fca5": { "balance": "4000000000000000000000" }, "9f7a0392f857732e3004a375e6b1068d49d83031": { "balance": "2000000000000000000000" }, "6a04f5d53fc0f515be942b8f12a9cb7ab0f39778": { "balance": "3129800000000000000000" }, "be478e8e3dde6bd403bb2d1c657c4310ee192723": { "balance": "492500000000000000000" }, "007622d84a234bb8b078230fcf84b67ae9a8acae": { "balance": "698800000000000000000" }, "9475c510ec9a26979247744c3d8c3b0e0b5f44d3": { "balance": "10000000000000000000000" }, "df47a8ef95f2f49f8e6f58184154145d11f72797": { "balance": "1910000000000000000000" }, "13ce332dff65a6ab933897588aa23e000980fa82": { "balance": "258400000000000000000" }, "9c4bbcd5f1644a6f075824ddfe85c571d6abf69c": { "balance": "1800000000000000000000" }, "d42b20bd0311608b66f8a6d15b2a95e6de27c5bf": { "balance": "2000000000000000000000" }, "a4dd59ab5e517d398e49fa537f899fed4c15e95d": { "balance": "20000000000000000000000" }, "1a8a5ce414de9cd172937e37f2d59cff71ce57a0": { "balance": "10000000000000000000000" }, "55c564664166a1edf3913e0169f1cd451fdb5d0c": { "balance": "2399800000000000000000" }, "58ae2ddc5f4c8ada97e06c0086171767c423f5d7": { "balance": "1610000000000000000000" }, "fb79abdb925c55b9f98efeef64cfc9eb61f51bb1": { "balance": "1794000000000000000000" }, "e7a42f59fee074e4fb13ea9e57ecf1cc48282249": { "balance": "20000000000000000000000" }, "07e2b4cdeed9d087b12e556d9e770c13c099615f": { "balance": "668500000000000000000" }, "68473b7a7d965904bedba556dfbc17136cd5d434": { "balance": "100000000000000000000" }, "6c5c3a54cda7c2f118edba434ed81e6ebb11dd7a": { "balance": "200000000000000000000" }, "24c117d1d2b3a97ab11a4679c99a774a9eade8d1": { "balance": "1000000000000000000000" }, "f68c5e33fa97139df5b2e63886ce34ebf3e4979c": { "balance": "3320000000000000000000" }, "bd7419dc2a090a46e2873d7de6eaaad59e19c479": { "balance": "6802000000000000000000" }, "1a0a1ddfb031e5c8cc1d46cf05842d50fddc7130": { "balance": "1000000000000000000000" }, "2b3a68db6b0cae8a7c7a476bdfcfbd6205e10687": { "balance": "2400000000000000000000" }, "426d15f407a01135b13a6b72f8f2520b3531e302": { "balance": "20000000000000000000" }, "0394b90fadb8604f86f43fc1e35d3124b32a5989": { "balance": "764000000000000000000" }, "7412c9bc30b4df439f023100e63924066afd53af": { "balance": "500000000000000000000" }, "80e7b3205230a566a1f061d922819bb4d4d2a0e1": { "balance": "14000000000000000000000" }, "ff4fc66069046c525658c337a917f2d4b832b409": { "balance": "2000000000000000000000" }, "f5061ee2e5ee26b815503677130e1de07a52db07": { "balance": "100000000000000000000" }, "49793463e1681083d6abd6e725d5bba745dccde8": { "balance": "545974000000000000000" }, "23551f56975fe92b31fa469c49ea66ee6662f41e": { "balance": "1910000000000000000000" }, "fad96ab6ac768ad5099452ac4777bd1a47edc48f": { "balance": "100000000000000000000" }, "2a746cd44027af3ebd37c378c85ef7f754ab5f28": { "balance": "394000000000000000000" }, "b8d389e624a3a7aebce4d3e5dbdf6cdc29932aed": { "balance": "200000000000000000000" }, "7b761feb7fcfa7ded1f0eb058f4a600bf3a708cb": { "balance": "4600000000000000000000" }, "5435c6c1793317d32ce13bba4c4ffeb973b78adc": { "balance": "250070000000000000000" }, "dd04eee74e0bf30c3f8d6c2c7f52e0519210df93": { "balance": "80000000000000000000" }, "4331ab3747d35720a9d8ca25165cd285acd4bda8": { "balance": "2000000000000000000000" }, "b84c8b9fd33ece00af9199f3cf5fe0cce28cd14a": { "balance": "3820000000000000000000" }, "393f783b5cdb86221bf0294fb714959c7b45899c": { "balance": "5910000000000000000000" }, "259ec4d265f3ab536b7c70fa97aca142692c13fc": { "balance": "20400000000000000000" }, "5d2f7f0b04ba4be161e19cb6f112ce7a5e7d7fe4": { "balance": "35200000000000000000" }, "d54ba2d85681dc130e5b9b02c4e8c851391fd9b9": { "balance": "3940000000000000000000" }, "5cd8af60de65f24dc3ce5730ba92653022dc5963": { "balance": "1790000000000000000000" }, "3b42a66d979f582834747a8b60428e9b4eeccd23": { "balance": "620400000000000000000" }, "4b19eb0c354bc1393960eb06063b83926f0d67b2": { "balance": "29000000000000000000" }, "8cf3546fd1cda33d58845fc8fcfecabca7c5642a": { "balance": "574027000000000000000" }, "113612bc3ba0ee4898b49dd20233905f2f458f62": { "balance": "14000000000000000000000" }, "1f2afc0aed11bfc71e77a907657b36ea76e3fb99": { "balance": "4000000000000000000000" }, "03714b41d2a6f751008ef8dd4d2b29aecab8f36e": { "balance": "6000000000000000000000" }, "25721c87b0dc21377c7200e524b14a22f0af69fb": { "balance": "4000000000000000000000" }, "335858f749f169cabcfe52b796e3c11ec47ea3c2": { "balance": "200000000000000000000" }, "52fb46ac5d00c3518b2c3a1c177d442f8165555f": { "balance": "1500000000000000000000" }, "7a8c89c014509d56d7b68130668ff6a3ecec7370": { "balance": "300000000000000000000" }, "7d5d2f73949dadda0856b206989df0078d51a1e5": { "balance": "10560000000000000000000" }, "be538246dd4e6f0c20bf5ad1373c3b463a131e86": { "balance": "200000000000000000000" }, "62680a15f8ccb8bdc02f7360c25ad8cfb57b8ccd": { "balance": "1000000000000000000000" }, "aa0ca3737337178a0caac3099c584b056c56301c": { "balance": "880000000000000000000" }, "1d341fa5a3a1bd051f7db807b6db2fc7ba4f9b45": { "balance": "18200000000000000000" }, "6463f715d594a1a4ace4bb9c3b288a74decf294d": { "balance": "1970000000000000000000" }, "e00d153b10369143f97f54b8d4ca229eb3e8f324": { "balance": "152000000000000000000" }, "8d0b9ea53fd263415eac11391f7ce9123c447062": { "balance": "2000000000000000000000" }, "cacb675e0996235404efafbb2ecb8152271b55e0": { "balance": "700000000000000000000" }, "b615e940143eb57f875893bc98a61b3d618c1e8c": { "balance": "20000000000000000000" }, "606f177121f7855c21a5062330c8762264a97b31": { "balance": "4000000000000000000000" }, "e3925509c8d0b2a6738c5f6a72f35314491248ce": { "balance": "1012961000000000000000" }, "3f08d9ad894f813e8e2148c160d24b353a8e74b0": { "balance": "60000000000000000000000" }, "40f4f4c06c732cd35b119b893b127e7d9d0771e4": { "balance": "10000000000000000000000" }, "1406854d149e081ac09cb4ca560da463f3123059": { "balance": "1337000000000000000000" }, "ecf05d07ea026e7ebf4941002335baf2fed0f002": { "balance": "200000000000000000000" }, "9a990b8aeb588d7ee7ec2ed8c2e64f7382a9fee2": { "balance": "33518000000000000000" }, "a2e0683a805de6a05edb2ffbb5e96f0570b637c3": { "balance": "20000000000000000000" }, "fba5486d53c6e240494241abf87e43c7600d413a": { "balance": "1987592000000000000000" }, "d81bd54ba2c44a6f6beb1561d68b80b5444e6dc6": { "balance": "1163806000000000000000" }, "5298ab182a19359ffcecafd7d1b5fa212dede6dd": { "balance": "20000000000000000000" }, "d1acb5adc1183973258d6b8524ffa28ffeb23de3": { "balance": "4000000000000000000000" }, "4e7aa67e12183ef9d7468ea28ad239c2eef71b76": { "balance": "4925000000000000000000" }, "509a20bc48e72be1cdaf9569c711e8648d957334": { "balance": "2000000000000000000000" }, "949f84f0b1d7c4a7cf49ee7f8b2c4a134de32878": { "balance": "685000000000000000000" }, "edbac9527b54d6df7ae2e000cca3613ba015cae3": { "balance": "1970000000000000000000" }, "c697b70477cab42e2b8b266681f4ae7375bb2541": { "balance": "5577200000000000000000" }, "86c934e38e53be3b33f274d0539cfca159a4d0d1": { "balance": "970000000000000000000" }, "0877eeaeab78d5c00e83c32b2d98fa79ad51482f": { "balance": "439420000000000000000" }, "5e11ecf69d551d7f4f84df128046b3a13240a328": { "balance": "20000000000000000000" }, "43ff8853e98ed8406b95000ada848362d6a0392a": { "balance": "22100000000000000000000" }, "f11cf5d363746fee6864d3ca336dd80679bb87ae": { "balance": "40000000000000000000000" }, "fb223c1e22eac1269b32ee156a5385922ed36fb8": { "balance": "2000000000000000000000" }, "4e6600806289454acda330a2a3556010dfacade6": { "balance": "6000000000000000000000" }, "cfe2caaf3cec97061d0939748739bffe684ae91f": { "balance": "10000000000000000000000" }, "adeb52b604e5f77faaac88275b8d6b49e9f9f97f": { "balance": "2089268000000000000000" }, "d53c567f0c3ff2e08b7d59e2b5c73485437fc58d": { "balance": "600000000000000000000" }, "fbf75933e01b75b154ef0669076be87f62dffae1": { "balance": "78000000000000000000000" }, "7dfd2962b575bcbeee97f49142d63c30ab009f66": { "balance": "4000000000000000000000" }, "df6485c4297ac152b289b19dde32c77ec417f47d": { "balance": "1000000000000000000000" }, "ffb974673367f5c07be5fd270dc4b7138b074d57": { "balance": "2470407000000000000000" }, "f7d7af204c56f31fd94398e40df1964bd8bf123c": { "balance": "150011000000000000000" }, "4506fe19fa4b006baa3984529d8516db2b2b50ab": { "balance": "2000000000000000000000" }, "f4dc7ba85480bbb3f535c09568aaa3af6f3721c6": { "balance": "7214962000000000000000" }, "d171c3f2258aef35e599c7da1aa07300234da9a6": { "balance": "2000000000000000000000" }, "33581cee233088c0860d944e0cf1ceabb8261c2e": { "balance": "13370000000000000000" }, "1c2e3607e127caca0fbd5c5948adad7dd830b285": { "balance": "19700000000000000000000" }, "fd7ede8f5240a06541eb699d782c2f9afb2170f6": { "balance": "1337000000000000000000" }, "368c5414b56b8455171fbf076220c1cba4b5ca31": { "balance": "557940000000000000000" }, "3e8745ba322f5fd6cb50124ec46688c7a69a7fae": { "balance": "4925000000000000000000" }, "76506eb4a780c951c74a06b03d3b8362f0999d71": { "balance": "500000000000000000000" }, "96d62dfd46087f62409d93dd606188e70e381257": { "balance": "2000000000000000000000" }, "37eada93c475ded2f7e15e7787d400470fa52062": { "balance": "200000000000000000000" }, "26babf42b267fdcf3861fdd4236a5e474848b358": { "balance": "1000000000000000000000" }, "3526eece1a6bdc3ee7b400fe935b48463f31bed7": { "balance": "82400000000000000000" }, "27b62816e1e3b8d19b79d1513d5dfa855b0c3a2a": { "balance": "99941000000000000000" }, "b3e3c439069880156600c2892e448d4136c92d9b": { "balance": "850000000000000000000" }, "574ad9355390e4889ef42acd138b2a27e78c00ae": { "balance": "1557000000000000000000" }, "f0b9d683cea12ba600baace219b0b3c97e8c00e4": { "balance": "100000000000000000000" }, "a437fe6ec103ca8d158f63b334224eccac5b3ea3": { "balance": "8000000000000000000000" }, "7a48d877b63a8f8f9383e9d01e53e80c528e955f": { "balance": "8000000000000000000000" }, "e965daa34039f7f0df62375a37e5ab8a72b301e7": { "balance": "4796000000000000000000" }, "72cd048a110574482983492dfb1bd27942a696ba": { "balance": "2000000000000000000000" }, "6611ce59a98b072ae959dc49ad511daaaaa19d6b": { "balance": "200000000000000000000" }, "0d92582fdba05eabc3e51538c56db8813785b328": { "balance": "191000000000000000000" }, "e87e9bbfbbb71c1a740c74c723426df55d063dd9": { "balance": "7998000000000000000000" }, "9c99a1da91d5920bc14e0cb914fdf62b94cb8358": { "balance": "20000000000000000000000" }, "fe8e6e3665570dff7a1bda697aa589c0b4e9024a": { "balance": "2000000000000000000000" }, "811461a2b0ca90badac06a9ea16e787b33b196cc": { "balance": "164000000000000000000" }, "d211b21f1b12b5096181590de07ef81a89537ead": { "balance": "2000000000000000000000" }, "01155057002f6b0d18acb9388d3bc8129f8f7a20": { "balance": "1340000000000000000000" }, "8ce22f9fa372449a420610b47ae0c8d565481232": { "balance": "2000000000000000000000" }, "e02b74a47628be315b1f76b315054ad44ae9716f": { "balance": "4000000000000000000000" }, "92a7c5a64362e9f842a23deca21035857f889800": { "balance": "1999944000000000000000" }, "5213f459e078ad3ab95a0920239fcf1633dc04ca": { "balance": "2599989000000000000000" }, "c9957ba94c1b29e5277ec36622704904c63dc023": { "balance": "1923000000000000000000" }, "6ac40f532dfee5118117d2ad352da77d4f6da2c8": { "balance": "400000000000000000000" }, "ea1efb3ce789bedec3d67c3e1b3bc0e9aa227f90": { "balance": "734000000000000000000" }, "b01e389b28a31d8e4995bdd7d7c81beeab1e4119": { "balance": "1000000000000000000000" }, "ee97aa8ac69edf7a987d6d70979f8ec1fbca7a94": { "balance": "376000000000000000000" }, "0fad05507cdc8f24b2be4cb7fa5d927ddb911b88": { "balance": "3004447000000000000000" }, "b6e8afd93dfa9af27f39b4df06076710bee3dfab": { "balance": "25000000000000000000" }, "7d0b255efb57e10f7008aa22d40e9752dfcf0378": { "balance": "29944000000000000000" }, "aef5b12258a18dec07d5ec2e316574919d79d6d6": { "balance": "2000000000000000000000" }, "63666755bd41b5986997783c13043008242b3cb5": { "balance": "500000000000000000000" }, "921f5261f4f612760706892625c75e7bce96b708": { "balance": "2000000000000000000000" }, "10e1e3377885c42d7df218522ee7766887c05e6a": { "balance": "300031000000000000000" }, "134163be9fbbe1c5696ee255e90b13254395c318": { "balance": "200000000000000000000" }, "870f15e5df8b0eabd02569537a8ef93b56785c42": { "balance": "388000000000000000000" }, "68eec1e288ac31b6eaba7e1fbd4f04ad579a6b5d": { "balance": "2000000000000000000000" }, "1a2694ec07cf5e4d68ba40f3e7a14c53f3038c6e": { "balance": "1000073000000000000000" }, "cd9b4cef73390c83a8fd71d7b540a7f9cf8b8c92": { "balance": "90000000000000000000" }, "c8de7a564c7f4012a6f6d10fd08f47890fbf07d4": { "balance": "300000000000000000000" }, "c0345b33f49ce27fe82cf7c84d141c68f590ce76": { "balance": "1000000000000000000000" }, "fe53b94989d89964da2061539526bbe979dd2ea9": { "balance": "1930600000000000000000" }, "14410fb310711be074a80883c635d0ef6afb2539": { "balance": "2000000000000000000000" }, "1d344e962567cb27e44db9f2fac7b68df1c1e6f7": { "balance": "1940000000000000000000" }, "fe016ec17ec5f10e3bb98ff4a1eda045157682ab": { "balance": "375804000000000000000" }, "e89da96e06beaf6bd880b378f0680c43fd2e9d30": { "balance": "601400000000000000000" }, "0fee81ac331efd8f81161c57382bb4507bb9ebec": { "balance": "400030000000000000000" }, "40cf90ef5b768c5da585002ccbe6617650d8e837": { "balance": "999800000000000000000" }, "256fa150cc87b5056a07d004efc84524739e62b5": { "balance": "200000000000000000000" }, "1b9b2dc2960e4cb9408f7405827c9b59071612fd": { "balance": "1000000000000000000000" }, "0efd1789eb1244a3dede0f5de582d8963cb1f39f": { "balance": "1500000000000000000000" }, "049c5d4bc6f25d4e456c697b52a07811ccd19fb1": { "balance": "300048000000000000000" }, "02b7b1d6b34ce053a40eb65cd4a4f7dddd0e9f30": { "balance": "685000000000000000000" }, "c1827686c0169485ec15b3a7c8c01517a2874de1": { "balance": "40000000000000000000" }, "d8e5c9675ef4deed266b86956fc4590ea7d4a27d": { "balance": "1000000000000000000000" }, "48f883e567b436a27bb5a3124dbc84dec775a800": { "balance": "771840000000000000000" }, "a34076f84bd917f20f8342c98ba79e6fb08ecd31": { "balance": "4200000000000000000000" }, "21ce6d5b9018cec04ad6967944bea39e8030b6b8": { "balance": "20000000000000000000" }, "0596a27dc3ee115fce2f94b481bc207a9e261525": { "balance": "1000000000000000000000" }, "717cf9beab3638308ded7e195e0c86132d163fed": { "balance": "15097428000000000000000" }, "d5ce55d1b62f59433c2126bcec09bafc9dfaa514": { "balance": "197000000000000000000" }, "7dd46da677e161825e12e80dc446f58276e1127c": { "balance": "820000000000000000000" }, "98c5494a03ac91a768dffc0ea1dde0acbf889019": { "balance": "200000000000000000000000" }, "617ff2cc803e31c9082233b825d025be3f7b1056": { "balance": "1970000000000000000000" }, "1091176be19b9964a8f72e0ece6bf8e3cfad6e9c": { "balance": "10020000000000000000000" }, "4ea56e1112641c038d0565a9c296c463afefc17e": { "balance": "182000000000000000000" }, "e303167f3d4960fe881b32800a2b4aeff1b088d4": { "balance": "2000000000000000000000" }, "773141127d8cf318aebf88365add3d5527d85b6a": { "balance": "1000076000000000000000" }, "b916b1a01cdc4e56e7657715ea37e2a0f087d106": { "balance": "2406017000000000000000" }, "46a430a2d4a894a0d8aa3feac615361415c3f81f": { "balance": "2000000000000000000000" }, "e6a3010f0201bc94ff67a2f699dfc206f9e76742": { "balance": "879088000000000000000" }, "d7ad09c6d32657685355b5c6ec8e9f57b4ebb982": { "balance": "1970000000000000000000" }, "95e80a82c20cbe3d2060242cb92d735810d034a2": { "balance": "32511000000000000000" }, "9a390162535e398877e416787d6239e0754e937c": { "balance": "1000000000000000000000" }, "d85fdeaf2a61f95db902f9b5a53c9b8f9266c3ac": { "balance": "2010000000000000000000" }, "c3e20c96df8d4e38f50b265a98a906d61bc51a71": { "balance": "2000000000000000000000" }, "2949fd1def5c76a286b3872424809a07db3966f3": { "balance": "5236067000000000000000" }, "86cdb7e51ac44772be3690f61d0e59766e8bfc18": { "balance": "4000000000000000000000" }, "749a4a768b5f237248938a12c623847bd4e688dc": { "balance": "72000000000000000000" }, "3524a000234ebaaf0789a134a2a417383ce5282a": { "balance": "5635000000000000000000" }, "7b43c7eea8d62355b0a8a81da081c6446b33e9e0": { "balance": "4000000000000000000000" }, "0eb189ef2c2d5762a963d6b7bdf9698ea8e7b48a": { "balance": "1337000000000000000000" }, "767fd7797d5169a05f7364321c19843a8c348e1e": { "balance": "18800000000000000000" }, "1b2639588b55c344b023e8de5fd4087b1f040361": { "balance": "1500000000000000000000" }, "1e33d1c2fb5e084f2f1d54bc5267727fec3f985d": { "balance": "500000000000000000000" }, "06b106649aa8c421ddcd1b8c32cd0418cf30da1f": { "balance": "40000000000000000000000" }, "3c5a241459c6abbf630239c98a30d20b8b3ac561": { "balance": "157600000000000000000" }, "0f4f94b9191bb7bb556aaad7c74ddb288417a50b": { "balance": "1400000000000000000000" }, "d6f4a7d04e8faf20e8c6eb859cf7f78dd23d7a15": { "balance": "131784000000000000000" }, "61adf5929a5e2981684ea243baa01f7d1f5e148a": { "balance": "110302000000000000000" }, "8f58d8348fc1dc4e0dd8343b6543c857045ee940": { "balance": "13632400000000000000000" }, "a6e3baa38e104a1e27a4d82869afb1c0ae6eff8d": { "balance": "19690000000000000000" }, "67350b5331926f5e28f3c1e986f96443809c8b8c": { "balance": "352000000000000000000" }, "0b5d66b13c87b392e94d91d5f76c0d450a552843": { "balance": "2000000000000000000000" }, "562a8dcbbeeef7b360685d27303bd69e094accf6": { "balance": "10000000000000000000000" }, "b5d9934d7b292bcf603b2880741eb760288383a0": { "balance": "16700000000000000000" }, "6fc53662371dca587b59850de78606e2359df383": { "balance": "180000000000000000000" }, "e069c0173352b10bf6834719db5bed01adf97bbc": { "balance": "18894000000000000000" }, "10a93457496f1108cd98e140a1ecdbae5e6de171": { "balance": "399600000000000000000" }, "69ff8901b541763f817c5f2998f02dcfc1df2997": { "balance": "40000000000000000000" }, "00c27d63fde24b92ee8a1e7ed5d26d8dc5c83b03": { "balance": "2000000000000000000000" }, "77f81b1b26fc84d6de97ef8b9fbd72a33130cc4a": { "balance": "1000000000000000000000" }, "6d20ef9704670a500bb269b5832e859802049f01": { "balance": "130000000000000000000" }, "186afdc085f2a3dce4615edffbadf71a11780f50": { "balance": "200000000000000000000" }, "7ff0c63f70241bece19b737e5341b12b109031d8": { "balance": "346000000000000000000" }, "9d4174aa6af28476e229dadb46180808c67505c1": { "balance": "1219430000000000000000" }, "5fec49c665e64ee89dd441ee74056e1f01e92870": { "balance": "6320000000000000000000" }, "6cd228dc712169307fe27ceb7477b48cfc8272e5": { "balance": "77600000000000000000" }, "fd918536a8efa6f6cefe1fa1153995fef5e33d3b": { "balance": "500000000000000000000" }, "2fbb504a5dc527d3e3eb0085e2fc3c7dd538cb7a": { "balance": "1249961000000000000000" }, "6ab323ae5056ed0a453072c5abe2e42fcf5d7139": { "balance": "880000000000000000000" }, "67d682a282ef73fb8d6e9071e2614f47ab1d0f5e": { "balance": "1000000000000000000000" }, "1858cf11aea79f5398ad2bb22267b5a3c952ea74": { "balance": "9850000000000000000000" }, "39d6caca22bccd6a72f87ee7d6b59e0bde21d719": { "balance": "2002000000000000000000" }, "daa63cbda45dd487a3f1cd4a746a01bb5e060b90": { "balance": "4797800000000000000000" }, "a90476e2efdfee4f387b0f32a50678b0efb573b5": { "balance": "10000000000000000000000" }, "ae5aa1e6c2b60f6fd3efe721bb4a719cbe3d6f5d": { "balance": "795860000000000000000" }, "ac2e766dac3f648f637ac6713fddb068e4a4f04d": { "balance": "197000000000000000000" }, "6191ddc9b64a8e0890b4323709d7a07c48b92a64": { "balance": "775000000000000000000" }, "cc4f0ff2aeb67d54ce3bc8c6510b9ae83e9d328b": { "balance": "400000000000000000000" }, "ca23f62dff0d6460036c62e840aec5577e0befd2": { "balance": "140800000000000000000" }, "97dc26ec670a31e0221d2a75bc5dc9f90c1f6fd4": { "balance": "50000000000000000000" }, "848c994a79003fe7b7c26cc63212e1fc2f9c19eb": { "balance": "2000000000000000000000" }, "20c284ba10a20830fc3d699ec97d2dfa27e1b95e": { "balance": "2000000000000000000000" }, "4fa3f32ef4086448b344d5f0a9890d1ce4d617c3": { "balance": "1500000000000000000000" }, "255abc8d08a096a88f3d6ab55fbc7352bddcb9ce": { "balance": "82161000000000000000" }, "7c60e51f0be228e4d56fdd2992c814da7740c6bc": { "balance": "200000000000000000000" }, "1c356cfdb95febb714633b28d5c132dd84a9b436": { "balance": "25000000000000000000" }, "5062e5134c612f12694dbd0e131d4ce197d1b6a4": { "balance": "1000000000000000000000" }, "ed862616fcbfb3becb7406f73c5cbff00c940755": { "balance": "1700000000000000000000" }, "62c9b271ffd5b770a5eee4edc9787b5cdc709714": { "balance": "2000000000000000000000" }, "3c925619c9b33144463f0537d896358706c520b0": { "balance": "2000000000000000000000" }, "ffe2e28c3fb74749d7e780dc8a5d422538e6e451": { "balance": "253319000000000000000" }, "37195a635dcc62f56a718049d47e8f9f96832891": { "balance": "1970000000000000000000" }, "90e9a9a82edaa814c284d232b6e9ba90701d4952": { "balance": "100007000000000000000" }, "e0c4ab9072b4e6e3654a49f8a8db026a4b3386a9": { "balance": "2000000000000000000000" }, "439dee3f7679ff1030733f9340c096686b49390b": { "balance": "2000000000000000000000" }, "548558d08cfcb101181dac1eb6094b4e1a896fa6": { "balance": "1999944000000000000000" }, "3090f8130ec44466afadb36ed3c926133963677b": { "balance": "4000000000000000000000" }, "d1648503b1ccc5b8be03fa1ec4f3ee267e6adf7b": { "balance": "5828000000000000000000" }, "65b42faecc1edfb14283ca979af545f63b30e60c": { "balance": "18200000000000000000" }, "6420f8bcc8164a6152a99d6b99693005ccf7e053": { "balance": "999972000000000000000" }, "84b4b74e6623ba9d1583e0cfbe49643f16384149": { "balance": "20000000000000000000" }, "b8310a16cc6abc465007694b930f978ece1930bd": { "balance": "740000000000000000000" }, "16019a4dafab43f4d9bf4163fae0847d848afca2": { "balance": "25060000000000000000" }, "479298a9de147e63a1c7d6d2fce089c7e64083bd": { "balance": "9999999000000000000000" }, "030973807b2f426914ad00181270acd27b8ff61f": { "balance": "5348000000000000000000" }, "b07bcf1cc5d4462e5124c965ecf0d70dc27aca75": { "balance": "1600000000000000000000" }, "a2f798e077b07d86124e1407df32890dbb4b6379": { "balance": "200000000000000000000" }, "0cbd921dbe121563b98a6871fecb14f1cc7e88d7": { "balance": "200000000000000000000" }, "6042276df2983fe2bc4759dc1943e18fdbc34f77": { "balance": "1970000000000000000000" }, "be2b2280523768ea8ac35cd9e888d60a719300d4": { "balance": "2000000000000000000000" }, "2f4da753430fc09e73acbccdcde9da647f2b5d37": { "balance": "200000000000000000000" }, "734223d27ff23e5906caed22595701bb34830ca1": { "balance": "2000000000000000000000" }, "5b430d779696a3653fc60e74fbcbacf6b9c2baf1": { "balance": "14000000000000000000000" }, "84232107932b12e03186583525ce023a703ef8d9": { "balance": "2000000000000000000000" }, "4ed14d81b60b23fb25054d8925dfa573dcae6168": { "balance": "340000000000000000000" }, "8b338411f26ccf37658cc75521d77629099e467d": { "balance": "2000000000000000000000" }, "a37622ac9bbdc4d82b75015d745b9f8de65a28ec": { "balance": "2910000000000000000000" }, "1dd77441844afe9cc18f15d8c77bccfb655ee034": { "balance": "4850000000000000000000" }, "65849be1af20100eb8a3ba5a5be4d3ae8db5a70e": { "balance": "400000000000000000000" }, "d5586da4e59583c8d86cccf71a86197f17996749": { "balance": "2000000000000000000000" }, "4b53ae59c784b6b5c43616b9a0809558e684e10c": { "balance": "1200000000000000000000" }, "55d42eb495bf46a634997b5f2ea362814918e2b0": { "balance": "106128000000000000000" }, "959ff17f1d51b473b44010052755a7fa8c75bd54": { "balance": "1970000000000000000000" }, "5a2daab25c31a61a92a4c82c9925a1d2ef58585e": { "balance": "225400000000000000000" }, "24c0c88b54a3544709828ab4ab06840559f6c5e2": { "balance": "2674000000000000000000" }, "7e8649e690fc8c1bfda1b5e186581f649b50fe33": { "balance": "98500000000000000000" }, "4acfa9d94eda6625c9dfa5f9f4f5d107c4031fdf": { "balance": "39400000000000000000" }, "5778ffdc9b94c5a59e224eb965b6de90f222d170": { "balance": "335320000000000000000" }, "825a7f4e10949cb6f8964268f1fa5f57e712b4c4": { "balance": "20000000000000000000" }, "6f39cc37caaa2ddc9b610f6131e0619fae772a3c": { "balance": "500000000000000000000" }, "5b437365ae3a9a2ff97c68e6f90a7620188c7d19": { "balance": "2002000000000000000000" }, "6710c2c03c65992b2e774be52d3ab4a6ba217ef7": { "balance": "11600000000000000000000" }, "896e335ca47af57962fa0f4dbf3e45e688cba584": { "balance": "1368500000000000000000" }, "b57549bfbc9bdd18f736b22650e48a73601fa65c": { "balance": "446000000000000000000" }, "85ca1e727e9d1a87991cc2c41840ebb9edf21d1b": { "balance": "13370000000000000000" }, "cf4166746e1d3bc1f8d0714b01f17e8a62df1464": { "balance": "1004700000000000000000" }, "4a75c3d4fa6fccbd5dd5a703c15379a1e783e9b7": { "balance": "1820000000000000000000" }, "9e5811b40be1e2a1e1d28c3b0774acde0a09603d": { "balance": "3000000000000000000000" }, "763886e333c56feff85be3951ab0b889ce262e95": { "balance": "2000000000000000000000" }, "2b101e822cd962962a06800a2c08d3b15d82b735": { "balance": "152000000000000000000" }, "a01e9476df84431825c836e8803a97e22fa5a0cd": { "balance": "6000000000000000000000" }, "be4e7d983f2e2a636b1102ec7039efebc842e98d": { "balance": "66000000000000000000" }, "9e427272516b3e67d4fcbf82f59390d04c8e28e5": { "balance": "4000000000000000000000" }, "e0d231e144ec9107386c7c9b02f1702ceaa4f700": { "balance": "5000057000000000000000" }, "6a0f056066c2d56628850273d7ecb7f8e6e9129e": { "balance": "5000016000000000000000" }, "d1538e9a87e59ca9ec8e5826a5b793f99f96c4c3": { "balance": "1000000000000000000000" }, "f85bab1cb3710fc05fa19ffac22e67521a0ba21d": { "balance": "2003000000000000000000" }, "f7cbdba6be6cfe68dbc23c2b0ff530ee05226f84": { "balance": "20000000000000000000" }, "4eb87ba8788eba0df87e5b9bd50a8e45368091c1": { "balance": "20000000000000000000" }, "1479a9ec7480b74b5db8fc499be352da7f84ee9c": { "balance": "1000000000000000000000" }, "d311bcd7aa4e9b4f383ff3d0d6b6e07e21e3705d": { "balance": "200000000000000000000" }, "425c1816868f7777cc2ba6c6d28c9e1e796c52b3": { "balance": "10000000000000000000000" }, "8510ee934f0cbc900e1007eb38a21e2a5101b8b2": { "balance": "106000000000000000000" }, "01e864d354741b423e6f42851724468c74f5aa9c": { "balance": "20000000000000000000000" }, "a543a066fb32a8668aa0736a0c9cd40d78098727": { "balance": "1000000000000000000000" }, "f3eb1948b951e22df1617829bf3b8d8680ec6b68": { "balance": "4000000000000000000000" }, "f6b782f4dcd745a6c0e2e030600e04a24b25e542": { "balance": "400000000000000000000" }, "229f4f1a2a4f540774505b4707a81de44410255b": { "balance": "2000000000000000000000" }, "cff8d06b00e3f50c191099ad56ba6ae26571cd88": { "balance": "1000000000000000000000" }, "910b7d577a7e39aa23acf62ad7f1ef342934b968": { "balance": "10000000000000000000000" }, "392433d2ce83d3fb4a7602cca3faca4ec140a4b0": { "balance": "51000000000000000000" }, "8ff46045687723dc33e4d099a06904f1ebb584dc": { "balance": "2000000000000000000000" }, "9ca0429f874f8dcee2e9c062a9020a842a587ab9": { "balance": "2000000000000000000000" }, "160ceb6f980e04315f53c4fc988b2bf69e284d7d": { "balance": "19100000000000000000" }, "c340f9b91c26728c31d121d5d6fc3bb56d3d8624": { "balance": "2000000000000000000000" }, "afa1d5ad38fed44759c05b8993c1aa0dace19f40": { "balance": "80000000000000000000" }, "3969b4f71bb8751ede43c016363a7a614f76118e": { "balance": "2000000000000000000000" }, "2bb6f578adfbe7b2a116b3554facf9969813c319": { "balance": "7400000000000000000000" }, "8334764b7b397a4e578f50364d60ce44899bff94": { "balance": "92500000000000000000" }, "9dd2196624a1ddf14a9d375e5f07152baf22afa2": { "balance": "1211747000000000000000" }, "f242da845d42d4bf779a00f295b40750fe49ea13": { "balance": "1000000000000000000000" }, "c6234657a807384126f8968ca1708bb07baa493c": { "balance": "20000000000000000000" }, "94c055e858357aaa30cf2041fa9059ce164a1f91": { "balance": "19999000000000000000000" }, "74c73c90528a157336f1e7ea20620ae53fd24728": { "balance": "8969310000000000000000" }, "19e7f3eb7bf67f3599209ebe08b62ad3327f8cde": { "balance": "2000000000000000000000" }, "b2b516fdd19e7f3864b6d2cf1b252a4156f1b03b": { "balance": "53720000000000000000" }, "8164e78314ae16b28926cc553d2ccb16f356270d": { "balance": "8450000000000000000000" }, "4d828894752f6f25175daf2177094487954b6f9f": { "balance": "1459683000000000000000" }, "ab84a0f147ad265400002b85029a41fc9ce57f85": { "balance": "1000000000000000000000" }, "f3fe51fde34413c73318b9c85437fe7e820f561a": { "balance": "1003200000000000000000" }, "16c7b31e8c376282ac2271728c31c95e35d952c3": { "balance": "2000000000000000000000" }, "80d5c40c59c7f54ea3a55fcfd175471ea35099b3": { "balance": "1000000000000000000000" }, "7abb10f5bd9bc33b8ec1a82d64b55b6b18777541": { "balance": "20000000000000000000000" }, "095b0ea2b218d82e0aea7c2889238a39c9bf9077": { "balance": "20000000000000000000000" }, "5d5cdbe25b2a044b7b9be383bcaa5807b06d3c6b": { "balance": "2000000000000000000000" }, "323749a3b971959e46c8b4822dcafaf7aaf9bd6e": { "balance": "20064000000000000000" }, "e0272213e8d2fd3e96bd6217b24b4ba01b617079": { "balance": "20000000000000000000" }, "00acbfb2f25a5485c739ef70a44eeeeb7c65a66f": { "balance": "100000000000000000000" }, "52f15423323c24f19ae2ab673717229d3f747d9b": { "balance": "1026115000000000000000" }, "cb4abfc282aed76e5d57affda542c1f382fcacf4": { "balance": "8136100000000000000000" }, "f71b4534f286e43093b1e15efea749e7597b8b57": { "balance": "104410000000000000000000" }, "44cd77535a893fa7c4d5eb3a240e79d099a72d2d": { "balance": "820000000000000000000" }, "eb3ce7fc381c51db7d5fbd692f8f9e058a4c703d": { "balance": "200000000000000000000" }, "f1c8c4a941b4628c0d6c30fda56452d99c7e1b64": { "balance": "1449000000000000000000" }, "277677aba1e52c3b53bfa2071d4e859a0af7e8e1": { "balance": "1000000000000000000000" }, "a5f075fd401335577b6683c281e6d101432dc6e0": { "balance": "2680000000000000000000" }, "e28dbc8efd5e416a762ec0e018864bb9aa83287b": { "balance": "24533161000000000000000" }, "2b717cd432a323a4659039848d3b87de26fc9546": { "balance": "500000000000000000000000" }, "b358e97c70b605b1d7d729dfb640b43c5eafd1e7": { "balance": "20000000000000000000000" }, "293c2306df3604ae4fda0d207aba736f67de0792": { "balance": "200000000000000000000" }, "74d366b07b2f56477d7c7077ac6fe497e0eb6559": { "balance": "5000000000000000000000" }, "490145afa8b54522bb21f352f06da5a788fa8f1d": { "balance": "9231182000000000000000" }, "862569211e8c6327b5415e3a67e5738b15baaf6e": { "balance": "140000000000000000000" }, "5a74ba62e7c81a3474e27d894fed33dd24ad95fe": { "balance": "18200000000000000000" }, "536e4d8029b73f5579dca33e70b24eba89e11d7e": { "balance": "1970000000000000000000" }, "25c6e74ff1d928df98137af4df8430df24f07cd7": { "balance": "390000000000000000000" }, "19b36b0c87ea664ed80318dc77b688dde87d95a5": { "balance": "1948386000000000000000" }, "abc4caeb474d4627cb6eb456ecba0ecd08ed8ae1": { "balance": "3940000000000000000000" }, "8ea656e71ec651bfa17c5a5759d86031cc359977": { "balance": "100000000000000000000" }, "8d620bde17228f6cbba74df6be87264d985cc179": { "balance": "100000000000000000000" }, "b2aa2f1f8e93e79713d92cea9ffce9a40af9c82d": { "balance": "2000000000000000000000" }, "198ef1ec325a96cc354c7266a038be8b5c558f67": { "balance": "608334724000000000000000" }, "6a13d5e32c1fd26d7e91ff6e053160a89b2c8aad": { "balance": "53480000000000000000" }, "e056bf3ff41c26256fef51716612b9d39ade999c": { "balance": "100009000000000000000" }, "2c128c95d957215101f043dd8fc582456d41016d": { "balance": "835000000000000000000" }, "2560b09b89a4ae6849ed5a3c9958426631714466": { "balance": "1700000000000000000000" }, "d3d6e9fb82542fd29ed9ea3609891e151396b6f7": { "balance": "54000000000000000000000" }, "a7607b42573bb6f6b4d4f23c7e2a26b3a0f6b6f0": { "balance": "1610000000000000000000" }, "020362c3ade878ca90d6b2d889a4cc5510eed5f3": { "balance": "1042883000000000000000" }, "14830704e99aaad5c55e1f502b27b22c12c91933": { "balance": "620000000000000000000" }, "8030b111c6983f0485ddaca76224c6180634789f": { "balance": "80000000000000000000" }, "2c5b7d7b195a371bf9abddb42fe04f2f1d9a9910": { "balance": "200000000000000000000" }, "77d43fa7b481dbf3db530cfbf5fdced0e6571831": { "balance": "2000000000000000000000" }, "2d90b415a38e2e19cdd02ff3ad81a97af7cbf672": { "balance": "109800000000000000000" }, "2fc82ef076932341264f617a0c80dd571e6ae939": { "balance": "7160000000000000000000" }, "dfe549fe8430e552c6d07cc3b92ccd43b12fb50f": { "balance": "83620000000000000000" }, "1e8e689b02917cdc29245d0c9c68b094b41a9ed6": { "balance": "2000000000000000000000" }, "21c3a8bba267c8cca27b1a9afabad86f607af708": { "balance": "8940000000000000000000" }, "143c639752caeecf6a997d39709fc8f19878c7e8": { "balance": "1970000000000000000000" }, "02603d7a3bb297c67c877e5d34fbd5b913d4c63a": { "balance": "20000000000000000000" }, "a166f911c644ac3213d29e0e1ae010f794d5ad26": { "balance": "2000000000000000000000" }, "6eb3819617404058268f0c3cff3596bfe9148c1c": { "balance": "1670000000000000000000" }, "7a67dd043a504fc2f2fc7194e9becf484cecb1fb": { "balance": "250000000000000000000" }, "f824ee331e4ac3cc587693395b57ecf625a6c0c2": { "balance": "1600930000000000000000" }, "1179c60dbd068b150b074da4be23033b20c68558": { "balance": "680000000000000000000" }, "d2a479404347c5543aab292ae1bb4a6f158357fa": { "balance": "4000000000000000000000" }, "b0d32bd7e4e695b7b01aa3d0416f80557dba9903": { "balance": "16300000000000000000000" }, "f734ec03724ddee5bb5279aa1afcf61b0cb448a1": { "balance": "4238080000000000000000" }, "c04069dfb18b096c7867f8bee77a6dc7477ad062": { "balance": "2674000000000000000000" }, "80c53ee7e3357f94ce0d7868009c208b4a130125": { "balance": "2000000000000000000000" }, "0f32d9cb4d0fdaa0150656bb608dcc43ed7d9301": { "balance": "753978000000000000000" }, "6ddb6092779d5842ead378e21e8120fd4c6bc132": { "balance": "2000000000000000000000" }, "82ea01e3bf2e83836e71704e22a2719377efd9c3": { "balance": "3040000000000000000000" }, "44c1110b18870ec81178d93d215838c551d48e64": { "balance": "199958000000000000000" }, "7727af101f0aaba4d23a1cafe17c6eb5dab1c6dc": { "balance": "2000000000000000000000" }, "a11a03c4bb26d21eff677d5d555c80b25453ee7a": { "balance": "69979000000000000000" }, "19e5dea3370a2c746aae34a37c531f41da264e83": { "balance": "200000000000000000000" }, "c325c352801ba883b3226c5feb0df9eae2d6e653": { "balance": "3940000000000000000000" }, "ae5055814cb8be0c117bb8b1c8d2b63b4698b728": { "balance": "32035000000000000000" }, "deb1bc34d86d4a4dde2580d8beaf074eb0e1a244": { "balance": "1580000000000000000000" }, "558360206883dd1b6d4a59639e5629d0f0c675d0": { "balance": "2000000000000000000000" }, "a9d6f871ca781a759a20ac3adb972cf12829a208": { "balance": "925000000000000000000" }, "b0ac4eff6680ee14169cdadbffdb30804f6d25f5": { "balance": "2000000000000000000000" }, "f1b58faffa8794f50af8e88309c7a6265455d51a": { "balance": "999800000000000000000" }, "a61a54df784a44d71b771b87317509211381f200": { "balance": "1000000000000000000000" }, "baa4b64c2b15b79f5f204246fd70bcbd86e4a92a": { "balance": "500000000000000000000" }, "a20d8ff60caae31d02e0b665fa435d76f77c9442": { "balance": "489600000000000000000" }, "f3e74f470c7d3a3f0033780f76a89f3ef691e6cb": { "balance": "3021800000000000000000" }, "d330728131fe8e3a15487a34573c93457e2afe95": { "balance": "4000000000000000000000" }, "9af9dbe47422d177f945bdead7e6d82930356230": { "balance": "3940000000000000000000" }, "0eb5b662a1c718608fd52f0c25f9378830178519": { "balance": "6091400000000000000000" }, "fda6810ea5ac985d6ffbf1c511f1c142edcfddf7": { "balance": "4000000000000000000000" }, "832c54176bdf43d2c9bcd7b808b89556b89cbf31": { "balance": "200000000000000000000" }, "704d5de4846d39b53cd21d1c49f096db5c19ba29": { "balance": "152000000000000000000" }, "344a8db086faed4efc37131b3a22b0782dad7095": { "balance": "500000000000000000000" }, "8c7fa5cae82fedb69ab189d3ff27ae209293fb93": { "balance": "400030000000000000000" }, "ad660dec825522a9f62fcec3c5b731980dc286ea": { "balance": "3000000000000000000000" }, "13b9b10715714c09cfd610cf9c9846051cb1d513": { "balance": "1970000000000000000000" }, "40467d80e74c35407b7db51789234615fea66818": { "balance": "388000000000000000000" }, "30e9d5a0088f1ddb2fd380e2a049192266c51cbf": { "balance": "196910000000000000000" }, "b2d1e99af91231858e7065dd1918330dc4c747d5": { "balance": "16700000000000000000000" }, "9f21302ca5096bea7402b91b0fd506254f999a3d": { "balance": "1246832000000000000000" }, "d24b6644f439c8051dfc64d381b8c86c75c17538": { "balance": "2000000000000000000000" }, "8228ebc087480fd64547ca281f5eace3041453b9": { "balance": "1970000000000000000000" }, "29da3e35b23bb1f72f8e2258cf7f553359d24bac": { "balance": "20000000000000000000000" }, "c8e558a3c5697e6fb23a2594c880b7a1b68f9860": { "balance": "10000000000000000000000" }, "6b951a43274eeafc8a0903b0af2ec92bf1efc839": { "balance": "100000000000000000000" }, "d015f6fcb84df7bb410e8c8f04894a881dcac237": { "balance": "1038000000000000000000" }, "6ccb03acf7f53ce87aadcc21a9932de915f89804": { "balance": "8000000000000000000000" }, "388c85a9b9207d8146033fe38143f6d34b595c47": { "balance": "200000000000000000000" }, "429c06b487e8546abdfc958a25a3f0fba53f6f00": { "balance": "13503000000000000000" }, "771507aeee6a255dc2cd9df55154062d0897b297": { "balance": "334250000000000000000" }, "5a2b1c853aeb28c45539af76a00ac2d8a8242896": { "balance": "25000000000000000000" }, "f4d67a9044b435b66e8977ff39a28dc4bd53729a": { "balance": "200000000000000000000" }, "063759dd1c4e362eb19398951ff9f8fad1d31068": { "balance": "10000000000000000000000" }, "cb58990bcd90cfbf6d8f0986f6fa600276b94e2d": { "balance": "999925000000000000000" }, "6df5c84f7b909aab3e61fe0ecb1b3bf260222ad2": { "balance": "4000000000000000000000" }, "deb2495d6aca7b2a6a2d138b6e1a42e2dc311fdd": { "balance": "2000000000000000000000" }, "59203cc37599b648312a7cc9e06dacb589a9ae6a": { "balance": "148689000000000000000" }, "fc9b347464b2f9929d807e039dae48d3d98de379": { "balance": "14000000000000000000000" }, "48d2434b7a7dbbff08223b6387b05da2e5093126": { "balance": "18000000000000000000000" }, "c9d76446d5aadff80b68b91b08cd9bc8f5551ac1": { "balance": "714000000000000000000" }, "3d31587b5fd5869845788725a663290a49d3678c": { "balance": "500000000000000000000" }, "d8715ef9176f850b2e30eb8e382707f777a6fbe9": { "balance": "2000000000000000000000" }, "2c2147947ae33fb098b489a5c16bfff9abcd4e2a": { "balance": "200000000000000000000" }, "d6c0d0bc93a62e257174700e10f024c8b23f1f87": { "balance": "2000000000000000000000" }, "d1978f2e34407fab1dc2183d95cfda6260b35982": { "balance": "788000000000000000000" }, "1bf974d9904f45ce81a845e11ef4cbcf27af719e": { "balance": "100000000000000000000" }, "6e761eaa0f345f777b5441b73a0fa5b56b85f22d": { "balance": "2000000000000000000000" }, "ea60436912de6bf187d3a472ff8f5333a0f7ed06": { "balance": "19700000000000000000" }, "94f8f057db7e60e675ad940f155885d1a477348e": { "balance": "401100000000000000000" }, "8933491760c8f0b4df8caac78ed835caee21046d": { "balance": "20000000000000000000000" }, "a7775e4af6a23afa201fb78b915e51a515b7a728": { "balance": "120000000000000000000" }, "d8d64384249b776794063b569878d5e3b530a4b2": { "balance": "177569000000000000000" }, "be633a3737f68439bac7c90a52142058ee8e8a6f": { "balance": "960000000000000000000" }, "90bd62a050845261fa4a9f7cf241ea630b05efb8": { "balance": "500000000000000000000" }, "552987f0651b915b2e1e5328c121960d4bdd6af4": { "balance": "1790000000000000000000" }, "0baf6ecdb91acb3606a8357c0bc4f45cfd2d7e6f": { "balance": "1000000000000000000000" }, "9e5a311d9f69898a7c6a9d6360680438e67a7b2f": { "balance": "1490000000000000000000" }, "78859c5b548b700d9284cee4b6633c2f52e529c2": { "balance": "2955000000000000000000" }, "d572309169b1402ec8131a17a6aac3222f89e6eb": { "balance": "13800000000000000000000" }, "8e6d7485cbe990acc1ad0ee9e8ccf39c0c93440e": { "balance": "955000000000000000000" }, "75c11d024d12ae486c1095b7a7b9c4af3e8edeb9": { "balance": "20000000000000000000" }, "903413878aea3bc1086309a3fe768b65559e8cab": { "balance": "8000000000000000000000" }, "6d0569e5558fc7df2766f2ba15dc8aeffc5beb75": { "balance": "4001070000000000000000" }, "3815b0743f94fc8cc8654fd9d597ed7d8b77c57e": { "balance": "738578000000000000000" }, "0f26480a150961b8e30750713a94ee6f2e47fc00": { "balance": "1000000000000000000000" }, "ede5de7c7fb7eee0f36e64530a41440edfbefacf": { "balance": "617200000000000000000" }, "763a7cbab70d7a64d0a7e52980f681472593490c": { "balance": "600000000000000000000" }, "6e270ad529f1f0b8d9cb6d2427ec1b7e2dc64a74": { "balance": "200000000000000000000" }, "eb3bdd59dcdda5a9bb2ac1641fd02180f5f36560": { "balance": "6600000000000000000000" }, "f4ebf50bc7e54f82e9b9bd24baef29438e259ce6": { "balance": "10000000000000000000000" }, "882c8f81872c79fed521cb5f950d8b032322ea69": { "balance": "40000000000000000000000" }, "394132600f4155e07f4d45bc3eb8d9fb72dcd784": { "balance": "2941000000000000000000" }, "0be2b94ad950a2a62640c35bfccd6c67dae450f6": { "balance": "1940000000000000000000" }, "d4c6ac742e7c857d4a05a04c33d4d05c1467571d": { "balance": "200000000000000000000" }, "1fddd85fc98be9c4045961f40f93805ecc4549e5": { "balance": "164000000000000000000" }, "534065361cb854fac42bfb5c9fcde0604ac919da": { "balance": "2000000000000000000000" }, "9a6ff5f6a7af7b7ae0ed9c20ecec5023d281b786": { "balance": "2547000000000000000000" }, "4f3a4854911145ea01c644044bdb2e5a960a982f": { "balance": "4000000000000000000000" }, "00497e92cdc0e0b963d752b2296acb87da828b24": { "balance": "194800000000000000000" }, "4ff67fb87f6efba9279930cfbd1b7a343c79fade": { "balance": "400000000000000000000" }, "62f2e5ccecd52cc4b95e0597df27cc079715608c": { "balance": "143000000000000000000" }, "1eda084e796500ba14c5121c0d90846f66e4be62": { "balance": "534800000000000000000" }, "9836b4d30473641ab56aeee19242761d72725178": { "balance": "2000000000000000000000" }, "de55de0458f850b37e4d78a641dd2eb2dd8f38ce": { "balance": "4000000000000000000000" }, "140ca28ff33b9f66d7f1fc0078f8c1eef69a1bc0": { "balance": "1600000000000000000000" }, "2014261f01089f53795630ba9dd24f9a34c2d942": { "balance": "1337000000000000000000" }, "11415fab61e0dfd4b90676141a557a869ba0bde9": { "balance": "2048000000000000000000" }, "88344909644c7ad4930fd873ca1c0da2d434c07f": { "balance": "131970000000000000000" }, "88b217ccb786a254cf4dc57f5d9ac3c455a30483": { "balance": "925000000000000000000" }, "dfdbcec1014b96da2158ca513e9c8d3b9af1c3d0": { "balance": "2000000000000000000000" }, "1ba9f7997e5387b6b2aa0135ac2452fe36b4c20d": { "balance": "850000000000000000000" }, "d70ad2c4e9eebfa637ef56bd486ad2a1e5bce093": { "balance": "200000000000000000000" }, "9ce27f245e02d1c312c1d500788c9def7690453b": { "balance": "200000000000000000000" }, "8234f463d18485501f8f85ace4972c9b632dbccc": { "balance": "2000000000000000000000" }, "994152fc95d5c1ca8b88113abbad4d710e40def6": { "balance": "500000000000000000000" }, "e5b980d28eece2c06fca6c9473068b37d4a6d6e9": { "balance": "695200000000000000000" }, "2d426912d059fad9740b2e390a2eeac0546ff01b": { "balance": "1400000000000000000000" }, "6d9997509882027ea947231424bedede2965d0ba": { "balance": "2001600000000000000000" }, "167ce7de65e84708595a525497a3eb5e5a665073": { "balance": "575400000000000000000" }, "e430c0024fdbf73a82e21fccf8cbd09138421c21": { "balance": "4000000000000000000000" }, "2e52912bc10ea39d54e293f7aed6b99a0f4c73be": { "balance": "400000000000000000000" }, "12cf8b0e465213211a5b53dfb0dd271a282c12c9": { "balance": "15200000000000000000" }, "06964e2d17e9189f88a8203936b40ac96e533c06": { "balance": "18200000000000000000" }, "66b1a63da4dcd9f81fe54f5e3fcb4055ef7ec54f": { "balance": "201412000000000000000" }, "0a77e7f72b437b574f00128b21f2ac265133528c": { "balance": "2000000000000000000000" }, "78f5c74785c5668a838072048bf8b453594ddaab": { "balance": "400000000000000000000" }, "58e554af3d87629620da61d538c7f5b4b54c4afe": { "balance": "1297081000000000000000" }, "37a10451f36166cf643dd2de6c1cbba8a011cfa3": { "balance": "380000000000000000000" }, "fe9ad12ef05d6d90261f96c8340a0381974df477": { "balance": "2000000000000000000000" }, "057f7f81cd7a406fc45994408b5049912c566463": { "balance": "1700000000000000000000" }, "55a3df57b7aaec16a162fd5316f35bec082821cf": { "balance": "1970000000000000000000" }, "c0e0b903088e0c63f53dd069575452aff52410c3": { "balance": "3000000000000000000000" }, "63e88e2e539ffb450386b4e46789b223f5476c45": { "balance": "6292000000000000000000" }, "3727341f26c12001e378405ee38b2d8464ec7140": { "balance": "2000000000000000000000" }, "c96751656c0a8ef4357b7344322134b983504aca": { "balance": "2000000000000000000000" }, "1e060dc6c5f1cb8cc7e1452e02ee167508b56542": { "balance": "12715500000000000000000" }, "18136c9df167aa17b6f18e22a702c88f4bc28245": { "balance": "4000000000000000000000" }, "116108c12084612eeda7a93ddcf8d2602e279e5c": { "balance": "2000000000000000000000" }, "bbb643d2187b364afc10a6fd368d7d55f50d1a3c": { "balance": "1000000000000000000000" }, "ec83e798c396b7a55e2a2224abcd834b27ea459c": { "balance": "12000000000000000000000" }, "973f4e361fe5decd989d4c8f7d7cc97990385daf": { "balance": "388500000000000000000" }, "c0f29ed0076611b5e55e130547e68a48e26df5e4": { "balance": "3000000000000000000000" }, "fd4b551f6fdbcda6c511b5bb372250a6b783e534": { "balance": "20600000000000000000" }, "144b19f1f66cbe318347e48d84b14039466c5909": { "balance": "2000000000000000000000" }, "bf183641edb886ce60b8190261e14f42d93cce01": { "balance": "25019000000000000000" }, "94db807873860aac3d5aea1e885e52bff2869954": { "balance": "3220000000000000000000" }, "7a74cee4fa0f6370a7894f116cd00c1147b83e59": { "balance": "800000000000000000000" }, "cd32a4a8a27f1cc63954aa634f7857057334c7a3": { "balance": "1085000000000000000000" }, "7cbeb99932e97e6e02058cfc62d0b26bc7cca52b": { "balance": "2000000000000000000000" }, "8cde8b732e6023878eb23ed16229124b5f7afbec": { "balance": "133700000000000000000" }, "45c4ecb4ee891ea984a7c5cefd8dfb00310b2850": { "balance": "1980000000000000000000" }, "8b393fb0813ee101db1e14ecc7d322c72b8c0473": { "balance": "455578000000000000000" }, "7b66126879844dfa34fe65c9f288117fefb449ad": { "balance": "6000000000000000000000" }, "162ba503276214b509f97586bd842110d103d517": { "balance": "9002000000000000000000" }, "7dece6998ae1900dd3770cf4b93812bad84f0322": { "balance": "100000000000000000000" }, "ec0927bac7dc36669c28354ab1be83d7eec30934": { "balance": "2000000000000000000000" }, "8d7f3e61299c2db9b9c0487cf627519ed00a9123": { "balance": "1742400000000000000000" }, "4fc46c396e674869ad9481638f0013630c87caac": { "balance": "1000000000000000000000" }, "bf68d28aaf1eeefef646b65e8cc8d190f6c6da9c": { "balance": "2000000000000000000000" }, "00969747f7a5b30645fe00e44901435ace24cc37": { "balance": "1700000000000000000000" }, "494dec4d5ee88a2771a815f1ee7264942fb58b28": { "balance": "2000000000000000000000" }, "ffeac0305ede3a915295ec8e61c7f881006f4474": { "balance": "98500000000000000000" }, "b39139576194a0866195151f33f2140ad1cc86cf": { "balance": "100000000000000000000000" }, "fead1803e5e737a68e18472d9ac715f0994cc2be": { "balance": "500000000000000000000" }, "698ab9a2f33381e07c0c47433d0d21d6f336b127": { "balance": "20000000000000000000" }, "e5edc73e626f5d3441a45539b5f7a398c593edf6": { "balance": "865000000000000000000" }, "dd4f5fa2111db68f6bde3589b63029395b69a92d": { "balance": "158400000000000000000" }, "8c93c3c6db9d37717de165c3a1b4fe51952c08de": { "balance": "400000000000000000000" }, "f87bb07b289df7301e54c0efda6a2cf291e89200": { "balance": "1400000000000000000000" }, "e7a4560c84b20e0fb54c49670c2903b0a96c42a4": { "balance": "598000000000000000000" }, "00a5797f52c9d58f189f36b1d45d1bf6041f2f6b": { "balance": "5456900000000000000000" }, "9da3302240af0511c6fd1857e6ddb7394f77ab6b": { "balance": "3100000000000000000000" }, "2c2d15ff39561c1b72eda1cc027ffef23743a144": { "balance": "3920000000000000000000" }, "9b4c2715780ca4e99e60ebf219f1590c8cad500a": { "balance": "1600000000000000000000" }, "ff5e7ee7d5114821e159dca5e81f18f1bfffbff9": { "balance": "2000000000000000000000" }, "0169c1c210eae845e56840412e1f65993ea90fb4": { "balance": "2000000000000000000000" }, "abc45f84db7382dde54c5f7d8938c42f4f3a3bc4": { "balance": "200000000000000000000" }, "d9383d4b6d17b3f9cd426e10fb944015c0d44bfb": { "balance": "800000000000000000000" }, "c090fe23dcd86b358c32e48d2af91024259f6566": { "balance": "200000000000000000000" }, "9ffedcc36b7cc312ad2a9ede431a514fccb49ba3": { "balance": "669800000000000000000" }, "2ffe93ec1a5636e9ee34af70dff52682e6ff7079": { "balance": "2000000000000000000000" }, "6e01e4ad569c95d007ada30d5e2db12888492294": { "balance": "4000000000000000000000" }, "d4d92c62b280e00f626d8657f1b86166cb1f740f": { "balance": "200028000000000000000" }, "1d36683063b7e9eb99462dabd569bddce71686f2": { "balance": "1000000000000000000000" }, "3a48e0a7098b06a905802b87545731118e89f439": { "balance": "2000000000000000000000" }, "bd9e56e902f4be1fc8768d8038bac63e2acbbf8e": { "balance": "999972000000000000000" }, "4d67f2ab8599fef5fc413999aa01fd7fce70b43d": { "balance": "10000000000000000000000" }, "8e74e0d1b77ebc823aca03f119854cb12027f6d7": { "balance": "107200000000000000000000" }, "7e5b19ae1be94ff4dee635492a1b012d14db0213": { "balance": "100000000000000000000" }, "5de9e7d5d1b667d095dd34099c85b0421a0bc681": { "balance": "20000000000000000000" }, "316eb4e47df71b42e16d6fe46825b7327baf3124": { "balance": "4000000000000000000000" }, "772c297f0ad194482ee8c3f036bdeb01c201d5cc": { "balance": "200000000000000000000" }, "d7052519756af42590f15391b723a03fa564a951": { "balance": "4615591000000000000000" }, "2c6846a1aa999a2246a287056000ba4dcba8e63d": { "balance": "10020000000000000000000" }, "de5b005fe8daae8d1f05de3eda042066c6c4691c": { "balance": "1100000000000000000000" }, "254c1ecc630c2877de8095f0a8dba1e8bf1f550c": { "balance": "1700000000000000000000" }, "f8f226142a428434ab17a1864a2597f64aab2f06": { "balance": "172473000000000000000" }, "a6c910ce4d494a919ccdaaa1fc3b82aa74ba06cf": { "balance": "8000000000000000000000" }, "e587b16abc8a74081e3613e14342c03375bf0847": { "balance": "2000000000000000000000" }, "6f176065e88e3c6fe626267d18a088aaa4db80bc": { "balance": "3520000000000000000000" }, "50dcbc27bcad984093a212a9b4178eabe9017561": { "balance": "145512000000000000000" }, "e1953c6e975814c571311c34c0f6a99cdf48ab82": { "balance": "50000000000000000000" }, "be0a2f385f09dbfce96732e12bb40ac349871ba8": { "balance": "1610348000000000000000" }, "4712540265cbeec3847022c59f1b318d43400a9e": { "balance": "3500000000000000000000" }, "29bdc4f28de0180f433c2694eb74f5504ce94337": { "balance": "2000000000000000000000" }, "2f66bfbf2262efcc8d2bd0444fc5b0696298ff1e": { "balance": "9940000000000000000000" }, "506411fd79003480f6f2b6aac26b7ba792f094b2": { "balance": "500000000000000000000" }, "23ea669e3564819a83b0c26c00a16d9e826f6c46": { "balance": "1430590000000000000000" }, "e3ffb02cb7d9ea5243701689afd5d417d7ed2ece": { "balance": "78000000000000000000" }, "38e7dba8fd4f1f850dbc2649d8e84f0952e3eb3c": { "balance": "50000000000000000000" }, "8644cc281be332ccced36da483fb2a0746d9ba2e": { "balance": "400000000000000000000" }, "e8a91da6cf1b9d65c74a02ec1f96eecb6dd241f3": { "balance": "1940000000000000000000" }, "0631dc40d74e5095e3729eddf49544ecd4396f67": { "balance": "160000000000000000000" }, "83c897a84b695eebe46679f7da19d776621c2694": { "balance": "500000000000000000000" }, "db73460b59d8e85045d5e752e62559875e42502e": { "balance": "999800000000000000000" }, "0dd4e674bbadb1b0dc824498713dce3b5156da29": { "balance": "170000000000000000000" }, "e3933d61b77dcdc716407f8250bc91e4ffaeb09d": { "balance": "86600000000000000000000" }, "58c90754d2f20a1cb1dd330625e04b45fa619d5c": { "balance": "2000000000000000000000" }, "895ec5545644e0b78330fffab8ddeac9e833156c": { "balance": "600000000000000000000" }, "7e1e29721d6cb91057f6c4042d8a0bbc644afe73": { "balance": "159800000000000000000" }, "72b90a4dc097239492c5b9777dcd1e52ba2be2c2": { "balance": "6000000000000000000000" }, "64241a7844290e0ab855f1d4aa75b55345032224": { "balance": "1600000000000000000000" }, "6fd4e0f3f32bee6d3767fdbc9d353a6d3aab7899": { "balance": "695240000000000000000" }, "3a035594c747476d42d1ee966c36224cdd224993": { "balance": "355890000000000000000" }, "de97f4330700b48c496d437c91ca1de9c4b01ba4": { "balance": "2910840000000000000000" }, "716ad3c33a9b9a0a18967357969b94ee7d2abc10": { "balance": "482000000000000000000" }, "bfbe05e88c9cbbcc0e92a405fac1d85de248ee24": { "balance": "100000000000000000000" }, "cfc4e6f7f8b011414bfba42f23adfaa78d4ecc5e": { "balance": "1850000000000000000000" }, "d931ac2668ba6a84481ab139735aec14b7bfbabf": { "balance": "2000000000000000000000" }, "e3263ce8af6db3e467584502ed7109125eae22a5": { "balance": "2000000000000000000000" }, "f78258c12481bcdddbb72a8ca0c043097261c6c5": { "balance": "20000000000000000000" }, "4493123c021ece3b33b1a452c9268de14007f9d3": { "balance": "6685000000000000000000" }, "431f2c19e316b044a4b3e61a0c6ff8c104a1a12f": { "balance": "1000000000000000000000" }, "e63e787414b9048478a50733359ecdd7e3647aa6": { "balance": "1580000000000000000000" }, "e4715956f52f15306ee9506bf82bccc406b3895e": { "balance": "274944000000000000000" }, "f7f91e7acb5b8129a306877ce3168e6f438b66a1": { "balance": "176000000000000000000" }, "dcdbbd4e2604e40e1710cc6730289dccfad3892d": { "balance": "4600000000000000000000" }, "2b5f4b3f1e11707a227aa5e69fa49dded33fb321": { "balance": "6000000000000000000000" }, "01488ad3da603c4cdd6cb0b7a1e30d2a30c8fc38": { "balance": "200000000000000000000" }, "841145b44840c946e21dbc190264b8e0d5029369": { "balance": "300000000000000000000000" }, "bf05070c2c34219311c4548b2614a438810ded6d": { "balance": "2000000000000000000000" }, "38f387e1a4ed4a73106ef2b462e474e2e3143ad0": { "balance": "6000000000000000000000" }, "f116b0b4680f53ab72c968ba802e10aa1be11dc8": { "balance": "20000000000000000000" }, "bea0afc93aae2108a3fac059623bf86fa582a75e": { "balance": "1700000000000000000000" }, "4c997992036c5b433ac33d25a8ea1dc3d4e4e6d8": { "balance": "29200000000000000000" }, "ab7e0b83ed9a424c6d1e6a6f87a4dbf06409c7d6": { "balance": "2400000000000000000000" }, "d71fb130f0150c565269e00efb43902b52a455a6": { "balance": "200000000000000000000" }, "99b018932bcad355b6792b255db6702dec8ce5dd": { "balance": "4000086000000000000000" }, "4b904e934bd0cc8b20705f879e905b93ea0ccc30": { "balance": "2000000000000000000000" }, "672ec42faa8cd69aaa71b32cc7b404881d52ff91": { "balance": "10000000000000000000000" }, "acbc2d19e06c3babbb5b6f052b6bf7fc37e07229": { "balance": "200000000000000000000" }, "cea8743341533cb2f0b9c6efb8fda80d77162825": { "balance": "100000000000000000000" }, "9568b7de755628af359a84543de23504e15e41e6": { "balance": "40000000000000000000000" }, "6ec96d13bdb24dc7a557293f029e02dd74b97a55": { "balance": "4000000000000000000000" }, "d95c90ffbe5484864780b867494a83c89256d6e4": { "balance": "1640000000000000000000" }, "ade6f8163bf7c7bb4abe8e9893bd0cc112fe8872": { "balance": "327600000000000000000" }, "250eb7c66f869ddf49da85f3393e980c029aa434": { "balance": "4000000000000000000000" }, "a35c19132cac1935576abfed6c0495fb07881ba0": { "balance": "2000000000000000000000" }, "d5550caaf743b037c56fd2558a1c8ed235130750": { "balance": "5347598000000000000000" }, "03097923ba155e16d82f3ad3f6b815540884b92c": { "balance": "1820000000000000000000" }, "d6d9e30f0842012a7176a917d9d2048ca0738759": { "balance": "4000000000000000000000" }, "ab9ad36e5c74ce2e96399f57839431d0e79f96ab": { "balance": "164000000000000000000" }, "75be8ff65e5788aec6b2a52d5fa7b1e7a03ba675": { "balance": "67720000000000000000" }, "4f6d4737d7a940382487264886697cf7637f8015": { "balance": "1670000000000000000000" }, "5f7b3bbac16dab831a4a0fc53b0c549dc36c31ca": { "balance": "1940000000000000000000" }, "d843ee0863ce933e22f89c802d31287b9671e81c": { "balance": "13370000000000000000" }, "361f3ba9ed956b770f257d3672fe1ff9f7b0240c": { "balance": "600000000000000000000" }, "6c0ae9f043c834d44271f13406593dfe094f389f": { "balance": "1517545000000000000000" }, "db34745ede8576b499db01beb7c1ecda85cf4abe": { "balance": "80000000000000000000" }, "7be8ccb4f11b66ca6e1d57c0b5396221a31ba53a": { "balance": "20000000000000000000" }, "128b908fe743a434203de294c441c7e20a86ea67": { "balance": "713304000000000000000" }, "df236bf6abf4f3293795bf0c28718f93e3b1b36b": { "balance": "1337000000000000000000" }, "14254ea126b52d0142da0a7e188ce255d8c47178": { "balance": "775000000000000000000" }, "ceed47ca5b899fd1623f21e9bd4db65a10e5b09d": { "balance": "133196000000000000000" }, "30acd858875fa24eef0d572fc7d62aad0ebddc35": { "balance": "400000000000000000000" }, "47a281dff64167197855bf6e705eb9f2cef632ea": { "balance": "1000072000000000000000" }, "297d5dbe222f2fb52531acbd0b013dc446ac7368": { "balance": "20000000000000000000000" }, "adf85203c8376a5fde9815384a350c3879c4cb93": { "balance": "1147300000000000000000" }, "c3e0471c64ff35fa5232cc3121d1d38d1a0fb7de": { "balance": "2000000000000000000000" }, "fdecc82ddfc56192e26f563c3d68cb544a96bfed": { "balance": "440000000000000000000" }, "2614f42d5da844377578e6b448dc24305bef2b03": { "balance": "2000000000000000000000" }, "1d96bcd58457bbf1d3c2a46ffaf16dbf7d836859": { "balance": "171313000000000000000" }, "bd66ffedb530ea0b2e856dd12ac2296c31fe29e0": { "balance": "200000000000000000000" }, "6e84876dbb95c40b6656e42ba9aea08a993b54dc": { "balance": "1101932000000000000000" }, "a1c4f45a82e1c478d845082eb18875c4ea6539ab": { "balance": "200000000000000000000000" }, "2c964849b1f69cc7cea4442538ed87fdf16cfc8f": { "balance": "2000000000000000000000" }, "45b47105fe42c4712dce6e2a21c05bffd5ea47a9": { "balance": "2000000000000000000000" }, "31e9c00f0c206a4e4e7e0522170dc81e88f3eb70": { "balance": "2685000000000000000000" }, "5fe77703808f823e6c399352108bdb2c527cb87c": { "balance": "1960000000000000000000" }, "2272186ef27dcbe2f5fc373050fdae7f2ace2316": { "balance": "16100000000000000000000" }, "b7576e9d314df41ec5506494293afb1bd5d3f65d": { "balance": "20000000000000000000" }, "ac9fff68c61b011efbecf038ed72db97bb9e7281": { "balance": "9550000000000000000000" }, "cd9529492b5c29e475acb941402b3d3ba50686b0": { "balance": "1970000000000000000000" }, "f19b39389d47b11b8a2c3f1da9124decffbefaf7": { "balance": "2000000000000000000000" }, "9e951f6dc5e352afb8d04299d2478a451259bf56": { "balance": "72004000000000000000" }, "8eb1fbe4e5d3019cd7d30dae9c0d5b4c76fb6331": { "balance": "2000000000000000000000" }, "29cc804d922be91f5909f348b0aaa5d21b607830": { "balance": "4000000000000000000000" }, "5c7b9ec7a2438d1e3c7698b545b9c3fd77b7cd55": { "balance": "1000000000000000000000" }, "a16160851d2b9c349b92e46f829abfb210943595": { "balance": "1790000000000000000000" }, "eac6b98842542ea10bb74f26d7c7488f698b6452": { "balance": "20000000000000000000000" }, "57825aeb09076caa477887fbc9ae37e8b27cc962": { "balance": "100000000000000000000" }, "b35e8a1c0dac7e0e66dbac736a592abd44012561": { "balance": "14974000000000000000" }, "756b84eb85fcc1f4fcdcc2b08db6a86e135fbc25": { "balance": "3220000000000000000000" }, "e13b3d2bbfdcbc8772a23315724c1425167c5688": { "balance": "1032115000000000000000" }, "0a2dcb7a671701dbb8f495728088265873356c8e": { "balance": "152120000000000000000" }, "03cb4c4f4516c4ff79a1b6244fbf572e1c7fea79": { "balance": "2740000000000000000000" }, "98ba4e9ca72fddc20c69b4396f76f8183f7a2a4e": { "balance": "12800000000000000000000" }, "f8087786b42da04ed6d1e0fe26f6c0eefe1e9f5a": { "balance": "10000000000000000000000" }, "02f7f67209b16a17550c694c72583819c80b54ad": { "balance": "98400000000000000000" }, "32bb2e9693e4e085344d2f0dbd46a283e3a087fd": { "balance": "400000000000000000000" }, "9c78963fbc263c09bd72e4f8def74a9475f7055c": { "balance": "13790000000000000000000" }, "27144ca9a7771a836ad50f803f64d869b2ae2b20": { "balance": "4000000000000000000000" }, "cc758d071d25a6320af68c5dc9c4f6955ba94520": { "balance": "6000000000000000000000" }, "cb42b44eb5fd60b5837e4f9eb47267523d1a229c": { "balance": "865000000000000000000" }, "aaf5b207b88b0de4ac40d747cee06e172df6e745": { "balance": "31428000000000000000000" }, "52d380511df19d5ec2807bbcb676581b67fd37a3": { "balance": "13400000000000000000" }, "aa1b3768c16d821f580e76c8e4c8e86d7dc78853": { "balance": "400000000000000000000" }, "41098a81452317c19e3eef0bd123bbe178e9e9ca": { "balance": "2800000000000000000000" }, "267148fd72c54f620a592fb92799319cc4532b5c": { "balance": "410000000000000000000" }, "d7cdbd41fff20df727c70b6255c1ba7606055468": { "balance": "200000000000000000000" }, "0e33fcbbc003510be35785b52a9c5d216bc005f4": { "balance": "1880000000000000000000" }, "6727daf5b9d68efcab489fedec96d7f7325dd423": { "balance": "2000000000000000000000" }, "cd0a161bc367ae0927a92aac9cf6e5086714efca": { "balance": "2000000000000000000000" }, "612667f172135b950b2cd1de10afdece6857b873": { "balance": "1000000000000000000000" }, "900194c4b1074305d19de405b0ac78280ecaf967": { "balance": "1000000000000000000000" }, "51f55ef47e6456a418ab32b9221ed27dba6608ee": { "balance": "4200000000000000000000" }, "0da532c910e3ac0dfb14db61cd739a93353fd05f": { "balance": "1336866000000000000000" }, "21df2dcdaf74b2bf803404dd4de6a35eabec1bbd": { "balance": "6920000000000000000000" }, "f0e7fb9e420a5340d536f40408344feaefc06aef": { "balance": "1000000000000000000000" }, "6742a2cfce8d79a2c4a51b77747498912245cd6a": { "balance": "258064000000000000000" }, "8663a241a0a89e70e182c845e2105c8ad7264bcf": { "balance": "14825507000000000000000" }, "18e113d8177c691a61be785852fa5bb47aeebdaf": { "balance": "1337000000000000000000" }, "1bec4d02ce85fc48feb62489841d85b170586a9b": { "balance": "2400000000000000000000" }, "287cf9d0902ef819a7a5f149445bf1775ee8c47c": { "balance": "16000000000000000000000" }, "28967280214e218a120c5dda37041b111ea36d74": { "balance": "200000000000000000000" }, "a0b771951ce1deee363ae2b771b73e07c4b5e800": { "balance": "1400000000000000000000" }, "29f8fba4c30772b057edbbe62ae7420c390572e1": { "balance": "1000000000000000000000" }, "ee34c7e7995db9f187cff156918cfb6f13f6e003": { "balance": "1960000000000000000000" }, "916bf7e3c545921d3206d900c24f14127cbd5e70": { "balance": "18020000000000000000000" }, "93235f340d2863e18d2f4c52996516138d220267": { "balance": "73800000000000000000" }, "7efec0c6253caf397f71287c1c07f6c9582b5b86": { "balance": "482839000000000000000" }, "8d2e31b08803b2c5f13d398ecad88528209f6057": { "balance": "9993000000000000000000" }, "964eab4b276b4cd8983e15ca72b106900fe41fce": { "balance": "500000000000000000000" }, "eea1e97988de75d821cd28ad6822b22cce988b31": { "balance": "520000000000000000000" }, "278c0bde630ec393b1e7267fc9d7d97019e4145b": { "balance": "2000000000000000000000" }, "82e4461eb9d849f0041c1404219e4272c4900ab4": { "balance": "2000000000000000000000" }, "4a73389298031b8816cca946421c199e18b343d6": { "balance": "631254000000000000000" }, "9a5af31c7e06339ac8b4628d7c4db0ce0f45c8a4": { "balance": "500000000000000000000" }, "cb9b5103e4ce89af4f64916150bff9eecb9faa5c": { "balance": "500000000000000000000" }, "740f641614779dcfa88ed1d425d60db42a060ca6": { "balance": "998630000000000000000" }, "a4e623451e7e94e7e89ba5ed95c8a83a62ffc4ea": { "balance": "20000000000000000000" }, "25a500eeec7a662a841552b5168b707b0de21e9e": { "balance": "10020000000000000000000" }, "185a7fc4ace368d233e620b2a45935661292bdf2": { "balance": "20000000000000000000000" }, "9b68f67416a63bf4451a31164c92f672a68759e9": { "balance": "60000000000000000000000" }, "a38b5bd81a9db9d2b21d5ec7c60552cd02ed561b": { "balance": "6000000000000000000000" }, "61c830f1654718f075ccaba316faacb85b7d120b": { "balance": "400000000000000000000" }, "8392e53776713578015bff4940cf43849d7dcba1": { "balance": "153190000000000000000" }, "dc57477dafa42f705c7fe40eae9c81756e0225f1": { "balance": "500044000000000000000" }, "febc3173bc9072136354002b7b4fb3bfc53f22f1": { "balance": "370000000000000000000" }, "d78f84e38944a0e0255faece48ba4950d4bd39d2": { "balance": "5000000000000000000000" }, "a7a3bb6139b0ada00c1f7f1f9f56d994ba4d1fa8": { "balance": "2000000000000000000000" }, "aa3f29601a1331745e05c42830a15e71938a6237": { "balance": "1700000000000000000000" }, "bec6640f4909b58cbf1e806342961d607595096c": { "balance": "1999944000000000000000" }, "9be3c329b62a28b8b0886cbd8b99f8bc930ce3e6": { "balance": "74500000000000000000" }, "e3eb2c0a132a524f72ccc0d60fee8b41685d39e2": { "balance": "1970000000000000000000" }, "90b1f370f9c1eb0be0fb8e2b8ad96a416371dd8a": { "balance": "900000000000000000000" }, "f2742e6859c569d5f2108351e0bf4dca352a48a8": { "balance": "10000000000000000000000" }, "b134c004391ab4992878337a51ec242f42285742": { "balance": "2000000000000000000000" }, "ab7416ff32254951cbbc624ec7fb45fc7ecaa872": { "balance": "340000000000000000000" }, "9795f64319fc17dd0f8261f9d206fb66b64cd0c9": { "balance": "200000000000000000000" }, "64e03ef070a54703b7184e48276c5c0077ef4b34": { "balance": "320000000000000000000" }, "3430a16381f869f6ea5423915855e800883525a9": { "balance": "17900000000000000000000" }, "f4a367b166d2991a2bfda9f56463a09f252c1b1d": { "balance": "1970000000000000000000" }, "77c4a697e603d42b12056cbba761e7f51d0443f5": { "balance": "680000000000000000000" }, "153ef58a1e2e7a3eb6b459a80ab2a547c94182a2": { "balance": "96000000000000000000000" }, "6dbe8abfa1742806263981371bf3d35590806b6e": { "balance": "20000000000000000000000" }, "4c99dae96481e807c1f99f8b7fbde29b7547c5bf": { "balance": "150000000000000000000" }, "d5b9d277d8aad20697a51f76e20978996bffe055": { "balance": "143250000000000000000" }, "0f24105abbdaa03fa6309ef6c188e51f714a6e59": { "balance": "200000000000000000000" }, "1cb6b2d7cfc559b7f41e6f56ab95c7c958cd0e4c": { "balance": "1337000000000000000000" }, "f37b426547a1642d8033324814f0ede3114fc212": { "balance": "401100000000000000000" }, "318f1f8bd220b0558b95fb33100ffdbb640d7ca6": { "balance": "4000000000000000000000" }, "206d55d5792a514ec108e090599f2a065e501185": { "balance": "200550000000000000000" }, "11d2247a221e70c2d66d17ee138d38c55ffb8640": { "balance": "10000000000000000000000" }, "e8de725eca5def805ff7941d31ac1c2e342dfe95": { "balance": "2462500000000000000000" }, "d561cbbc05515de73ab8cf9eae1357341e7dfdf4": { "balance": "6000000000000000000000" }, "0455dcec8a7fc4461bfd7f37456fce3f4c3caac7": { "balance": "400000000000000000000" }, "5161fd49e847f67455f1c8bb7abb36e985260d03": { "balance": "1200000000000000000000" }, "8e073bad25e42218615f4a0e6b2ea8f8de2230c0": { "balance": "2402500000000000000000" }, "6c08a6dc0173c7342955d1d3f2c065d62f83aec7": { "balance": "20000000000000000000" }, "95cb6d8a6379f94aba8b885669562c4d448e56a7": { "balance": "2000000000000000000000" }, "2805415e1d7fdec6dedfb89e521d10592d743c10": { "balance": "100000000000000000000" }, "daacdaf42226d15cb1cf98fa15048c7f4ceefe69": { "balance": "300000000000000000000" }, "e33df4ce80ccb62a76b12bcdfcecc46289973aa9": { "balance": "6000000000000000000000" }, "8f8cd26e82e7c6defd02dfad07979021cbf7150c": { "balance": "3000000000000000000000" }, "77a17122fa31b98f1711d32a99f03ec326f33d08": { "balance": "1700000000000000000000" }, "6f791d359bc3536a315d6382b88311af8ed6da47": { "balance": "92000000000000000000" }, "de30e49e5ab313214d2f01dcabce8940b81b1c76": { "balance": "197000000000000000000" }, "cf9be9b9ab86c66b59968e67b8d4dcff46b1814a": { "balance": "660000000000000000000" }, "7fdfc88d78bf1b285ac64f1adb35dc11fcb03951": { "balance": "2287900000000000000000" }, "c5134cfbb1df7a20b0ed7057622eeed280947dad": { "balance": "3800000000000000000000" }, "fa9ec8efe08686fa58c181335872ba698560ecab": { "balance": "1999944000000000000000" }, "f6a8635757c5e8c134d20d028cf778cf8609e46a": { "balance": "1459416000000000000000" }, "6265b2e7730f36b776b52d0c9d02ada55d8e3cb6": { "balance": "1000000000000000000000" }, "6a8cea2de84a8df997fd3f84e3083d93de57cda9": { "balance": "100007000000000000000" }, "1b7ed974b6e234ce81247498429a5bd4a0a2d139": { "balance": "2000000000000000000000" }, "9ba53dc8c95e9a472feba2c4e32c1dc4dd7bab46": { "balance": "1337000000000000000000" }, "d7b740dff8c457668fdf74f6a266bfc1dcb723f9": { "balance": "20000000000000000000" }, "07bc2cc8eedc01970700efc9c4fb36735e98cd71": { "balance": "4000000000000000000000" }, "3e1c962063e0d5295941f210dca3ab531eec8809": { "balance": "3000000000000000000000" }, "b447571dacbb3ecbb6d1cf0b0c8f3838e52324e2": { "balance": "30199000000000000000" }, "87764e3677eef604cbc59aed24abdc566b09fc25": { "balance": "3000000000000000000000" }, "03aa622881236dd0f4940c24c324ff8b7b7e2186": { "balance": "3200000000000000000000" }, "a4a7d306f510cd58359428c0d2f7c3609d5674d7": { "balance": "3349000000000000000000" }, "3c83c1701db0388b68210d00f5717cd9bd322c6a": { "balance": "30000000000000000000000" }, "047d5a26d7ad8f8e70600f70a398ddaa1c2db26f": { "balance": "6000000000000000000000" }, "43767bf7fd2af95b72e9312da9443cb1688e4343": { "balance": "300000000000000000000" }, "34a85d6d243fb1dfb7d1d2d44f536e947a4cee9e": { "balance": "20000000000000000000000" }, "65a9dad42e1632ba3e4e49623fab62a17e4d3611": { "balance": "93120000000000000000" }, "48e0cbd67f18acdb7a6291e1254db32e0972737f": { "balance": "100007000000000000000" }, "a5de5e434fdcdd688f1c31b6fb512cb196724701": { "balance": "800000000000000000000" }, "6d63d38ee8b90e0e6ed8f192eda051b2d6a58bfd": { "balance": "30000000000000000000" }, "b079bb4d9866143a6da72ae7ac0022062981315c": { "balance": "760000000000000000000" }, "c0413f5a7c2d9a4b8108289ef6ecd271781524f4": { "balance": "50000000000000000000000" }, "a91a5a7b341f99c535144e20be9c6b3bb4c28e4d": { "balance": "5431790000000000000000" }, "993f146178605e66d517be782ef0b3c61a4e1925": { "balance": "7011998000000000000000" }, "966c04781cb5e67dde3235d7f8620e1ab663a9a5": { "balance": "75800000000000000000000" }, "b3f82a87e59a39d0d2808f0751eb72c2329cdcc5": { "balance": "5000000000000000000000" }, "9b77ebced7e215f0920e8c2b870024f6ecb2ff31": { "balance": "1000000000000000000000" }, "fe697ff22ca547bfc95e33d960da605c6763f35b": { "balance": "1325000000000000000000" }, "480af52076009ca73781b70e43b95916a62203ab": { "balance": "924171000000000000000" }, "a9dc0424c6969d798358b393b1933a1f51bee00a": { "balance": "20000000000000000000000" }, "7aba56f63a48bc0817d6b97039039a7ad62fae2e": { "balance": "600000000000000000000" }, "59d139e2e40c7b97239d23dfaca33858f602d22b": { "balance": "2000000000000000000000" }, "8d6170ff66978e773bb621bf72b1ba7be3a7f87e": { "balance": "200000000000000000000" }, "d668523a90f0293d65c538d2dd6c57673710196e": { "balance": "39500000000000000000" }, "bbb5a0f4802c8648009e8a6998af352cde87544f": { "balance": "95500000000000000000" }, "fc43829ac787ff88aaf183ba352aadbf5a15b193": { "balance": "3960000000000000000000" }, "fe22a0b388668d1ae2643e771dacf38a434223cc": { "balance": "4000304000000000000000" }, "092acb624b08c05510189bbbe21e6524d644ccad": { "balance": "18200000000000000000" }, "8f0538ed71da1155e0f3bde5667ceb84318a1a87": { "balance": "1940000000000000000000" }, "06994cd83aa2640a97b2600b41339d1e0d3ede6c": { "balance": "250000000000000000000" }, "9d460c1b379ddb19a8c85b4c6747050ddf17a875": { "balance": "3340000000000000000000" }, "77a769fafdecf4a638762d5ba3969df63120a41d": { "balance": "2000000000000000000000" }, "5f375b86600c40cca8b2676b7a1a1d1644c5f52c": { "balance": "78838000000000000000" }, "15ee0fc63ebf1b1fc49d7bb38f8863823a2e17d2": { "balance": "1910000000000000000000" }, "6651736fb59b91fee9c93aa0bd6ea2f7b2506180": { "balance": "500000000000000000000" }, "361d9ed80b5bd27cf9f1226f26753258ee5f9b3f": { "balance": "3530900000000000000000" }, "c9b6b686111691ee6aa197c7231a88dc60bd295d": { "balance": "500000000000000000000" }, "e9b4a4853577a9dbcc2e795be0310d1bed28641a": { "balance": "1000000000000000000000" }, "36758e049cd98bcea12277a676f9297362890023": { "balance": "4000000000000000000000" }, "6bb50813146a9add42ee22038c9f1f7469d47f47": { "balance": "200200000000000000000" }, "6de4b581385cf7fc9fe8c77d131fe2ee7724c76a": { "balance": "2308840000000000000000" }, "d2a5a024230a57ccc666760b89b0e26cafd189c7": { "balance": "49997115000000000000000" }, "65af9087e05167715497c9a5a749189489004def": { "balance": "835000000000000000000" }, "ead21c1deccfbf1c5cd96688a2476b69ba07ce4a": { "balance": "72800000000000000000" }, "e308435204793764f5fcbe65eb510f5a744a655a": { "balance": "200000000000000000000" }, "9376dce2af2ec8dcda741b7e7345664681d93668": { "balance": "1000000000000000000000" }, "a1b47c4d0ed6018842e6cfc8630ac3a3142e5e6b": { "balance": "20000000000000000000" }, "e2198c8ca1b399f7521561fd5384a7132fba486b": { "balance": "1015200000000000000000" }, "92c13fe0d6ce87fd50e03def9fa6400509bd7073": { "balance": "40000000000000000000" }, "7517f16c28d132bb40e3ba36c6aef131c462da17": { "balance": "18200000000000000000" }, "6a023af57d584d845e698736f130db9db40dfa9a": { "balance": "98800000000000000000" }, "1518627b88351fede796d3f3083364fbd4887b0c": { "balance": "16000000000000000000000" }, "f5b6e9061a4eb096160777e26762cf48bdd8b55d": { "balance": "254030000000000000000" }, "28073efc17d05cab3195c2db332b61984777a612": { "balance": "1000000000000000000000" }, "f06a854a3c5dc36d1c49f4c87d6db333b57e4add": { "balance": "10000000000000000000000" }, "9225983860a1cb4623c72480ac16272b0c95e5f5": { "balance": "2000000000000000000000" }, "5260dc51ee07bddaababb9ee744b393c7f4793a6": { "balance": "34040000000000000000" }, "0f127bbf8e311caea2ba502a33feced3f730ba42": { "balance": "188000000000000000000" }, "17d521a8d9779023f7164d233c3b6420ffd223ed": { "balance": "20000000000000000000" }, "8c2b7d8b608d28b77f5caa9cd645242a823e4cd9": { "balance": "1820000000000000000000" }, "6e866d032d405abdd65cf651411d803796c22311": { "balance": "2000000000000000000000" }, "dc51b2dc9d247a1d0e5bc36ca3156f7af21ff9f6": { "balance": "1000000000000000000000" }, "c84d9bea0a7b9f140220fd8b9097cfbfd5edf564": { "balance": "123047000000000000000" }, "ff86e5e8e15b53909600e41308dab75f0e24e46b": { "balance": "902400000000000000000" }, "d7164aa261c09ad9b2b5068d453ed8eb6aa13083": { "balance": "3000000000000000000000" }, "76aaf8c1ac012f8752d4c09bb46607b6651d5ca8": { "balance": "20000000000000000000" }, "41786a10d447f484d33244ccb7facd8b427b5b8c": { "balance": "1000000000000000000000" }, "2e0c57b47150f95aa6a7e16ab9b1cbf54328979a": { "balance": "100000000000000000000" }, "3f747237806fed3f828a6852eb0867f79027af89": { "balance": "1500000000000000000000" }, "a568db4d57e4d67462d733c69a9e0fe26e218327": { "balance": "1096140000000000000000" }, "1f88f8a1338fc7c10976abcd3fb8d38554b5ec9c": { "balance": "13400000000000000000" }, "d1ea4d72a67b5b3e0f315559f52bd0614d713069": { "balance": "2000000000000000000000" }, "bfaeb91067617dcf8b44172b02af615674835dba": { "balance": "160661000000000000000" }, "b71a13ba8e95167b80331b52d69e37054fe7a826": { "balance": "200000000000000000000" }, "b67a80f170197d96cdcc4ab6cba627b4afa6e12c": { "balance": "2400000000000000000000" }, "35af040a0cc2337a76af288154c7561e1a233349": { "balance": "1000000000000000000000" }, "c86190904b8d079ec010e462cbffc90834ffaa5c": { "balance": "10100000000000000000000" }, "383304dd7a5720b29c1a10f60342219f48032f80": { "balance": "5600000000000000000000" }, "191313525238a21c767457a91374f02200c55448": { "balance": "116400000000000000000" }, "cc4a2f2cf86cf3e43375f360a4734691195f1490": { "balance": "1348127000000000000000" }, "4e020779b5ddd3df228a00cb48c2fc979da6ae38": { "balance": "2000000000000000000000" }, "e206fb7324e9deb79e19903496d6961b9be56603": { "balance": "100000000000000000000" }, "3ae160e3cd60ae31b9d6742d68e14e76bd96c517": { "balance": "30000000000000000000" }, "1f7d8e86d6eeb02545aad90e91327bd369d7d2f3": { "balance": "20000000000000000000" }, "68c7d1711b011a33f16f1f55b5c902cce970bdd7": { "balance": "152000000000000000000" }, "637be71b3aa815ff453d5642f73074450b64c82a": { "balance": "2000000000000000000000" }, "1584a2c066b7a455dbd6ae2807a7334e83c35fa5": { "balance": "130000000000000000000" }, "9c05e9d0f0758e795303717e31da213ca157e686": { "balance": "1000000000000000000000" }, "4f1a2da54a4c6da19d142412e56e815741db2325": { "balance": "100000000000000000000" }, "9a4ca8b82117894e43db72b9fa78f0b9b93ace09": { "balance": "50000000000000000000" }, "26c99f8849c9802b83c861217fd07a9e84cdb79d": { "balance": "300000000000000000000" }, "45c0d19f0b8e054f9e893836d5ecae7901af2812": { "balance": "5000000000000000000000" }, "00dc01cbf44978a42e8de8e436edf94205cfb6ec": { "balance": "1458440000000000000000" }, "de7dee220f0457a7187d56c1c41f2eb00ac56021": { "balance": "629924000000000000000" }, "1c128bd6cda5fca27575e4b43b3253c8c4172afe": { "balance": "2000000000000000000000" }, "666746fb93d1935c5a3c684e725010c4fad0b1d8": { "balance": "20000000000000000000" }, "51d78b178d707e396e8710965c4f41b1a1d9179d": { "balance": "110600000000000000000" }, "68f7573cd457e14c03fea43e302d30347c10705c": { "balance": "5000000000000000000000" }, "9d30cb237bc096f17036fc80dd21ca68992ca2d9": { "balance": "30380000000000000000000" }, "fbcfcc4a7b0f26cf26e9f3332132e2fc6a230766": { "balance": "8000000000000000000000" }, "b166e37d2e501ae73c84142b5ffb5aa655dd5a99": { "balance": "1999000000000000000000" }, "6df24f6685a62f791ba337bf3ff67e91f3d4bc3a": { "balance": "2166000000000000000000" }, "92e435340e9d253c00256389f52b067d55974e76": { "balance": "268000000000000000000" }, "ea53d26564859d9e90bb0e53b7abf560e0162c38": { "balance": "400000000000000000000" }, "e26657f0ed201ea2392c9222b80a7003608ddf30": { "balance": "40000000000000000000" }, "f4177a0d85d48b0e264211ce2aa2efd3f1b47f08": { "balance": "3593425000000000000000" }, "9d47ba5b4c8505ad8da42934280b61a0e1e8b971": { "balance": "100000000000000000000" }, "63c2a3d235e5eeabd0d4a6afdb89d94627396495": { "balance": "1241620000000000000000" }, "446a8039cecf9dce4879cbcaf3493bf545a88610": { "balance": "7000000000000000000000" }, "7fa37ed67887751a471f0eb306be44e0dbcd6089": { "balance": "1060000000000000000000" }, "26d4a16891f52922789217fcd886f7fce296d400": { "balance": "2000000000000000000000" }, "487e108502b0b189ef9c8c6da4d0db6261eec6c0": { "balance": "1910000000000000000000" }, "7484d26becc1eea8c6315ec3ee0a450117dc86a0": { "balance": "12000000000000000000000" }, "ad9e97a0482f353a05c0f792b977b6c7e811fa5f": { "balance": "200000000000000000000" }, "2273bad7bc4e487622d175ef7a66988b6a93c4ee": { "balance": "20000000000000000000" }, "3b93b16136f11eaf10996c95990d3b2739ccea5f": { "balance": "10000000000000000000000" }, "f3f1fa3918ca34e2cf7e84670b1f4d8eca160db3": { "balance": "680000000000000000000" }, "88a2154430c0e41147d3c1fee3b3b006f851edbd": { "balance": "999972000000000000000" }, "25185f325acf2d64500698f65c769ddf68301602": { "balance": "5000000000000000000000" }, "e9cafe41a5e8bbd90ba02d9e06585b4eb546c57f": { "balance": "2000000000000000000000" }, "95681cdae69b2049ce101e325c759892cac3f811": { "balance": "2857600000000000000000" }, "475066f9ad26655196d5535327bbeb9b7929cb04": { "balance": "3040000000000000000000" }, "6685fd2e2544702c360b8bb9ee78f130dad16da5": { "balance": "2000000000000000000000" }, "45e68db94c7d0ab7ac41857a71d67147870f4e71": { "balance": "400000000000000000000000" }, "4ad95d188d6464709add2555fb4d97fe1ebf311f": { "balance": "346000000000000000000" }, "73bedd6fda7ba3272185087b6351fc133d484e37": { "balance": "5057200000000000000000" }, "1ea4715504c6af107b0194f4f7b1cb6fcccd6f4b": { "balance": "590598000000000000000" }, "77306ffe2e4a8f3ca826c1a249f7212da43aeffd": { "balance": "20000000000000000000000" }, "eb453f5a3adddd8ab56750fadb0fe7f94d9c89e7": { "balance": "20000000000000000000" }, "7201d1c06920cd397ae8ad869bcda6e47ffb1b5a": { "balance": "20000000000000000000" }, "821cb5cd05c7ef909fe1be60733d8963d760dc41": { "balance": "4000000000000000000000" }, "496e319592b341eaccd778dda7c8196d54cac775": { "balance": "9250000000000000000000" }, "88609e0a465b6e99fce907166d57e9da0814f5c8": { "balance": "20000000000000000000000" }, "c7ec62b804b1f69b1e3070b5d362c62fb309b070": { "balance": "13068074000000000000000" }, "3eb9ef06d0c259040319947e8c7a6812aa0253d8": { "balance": "167000000000000000000" }, "cbf37ff854a2f1ce53934494777892d3ec655782": { "balance": "10000000000000000000000" }, "02b1af72339b2a2256389fd64607de24f0de600a": { "balance": "2000000000000000000000" }, "a8beb91c2b99c8964aa95b6b4a184b1269fc3483": { "balance": "400000000000000000000" }, "922a20c79a1d3a26dd3829677bf1d45c8f672bb6": { "balance": "4000000000000000000000" }, "c5843399d150066bf7979c34ba294620368ad7c0": { "balance": "200000000000000000000" }, "8cd0cd22e620eda79c0461e896c93c44837e2968": { "balance": "2000000000000000000000" }, "6170dd0687bd55ca88b87adef51cfdc55c4dd458": { "balance": "2005160000000000000000" }, "eed384ef2d41d9d203974e57c12328ea760e08ea": { "balance": "1000000000000000000000" }, "b129a5cb7105fe810bd895dc7206a991a4545488": { "balance": "30000000000000000000" }, "3872f48dc5e3f817bc6b2ad2d030fc5e0471193d": { "balance": "4000000000000000000000" }, "514b7512c9ae5ea63cbf11715b63f21e18d296c1": { "balance": "1999944000000000000000" }, "7ab256b204800af20137fabcc916a23258752501": { "balance": "20000000000000000000000" }, "fc66faba277f4b5de64ad45eb19c31e00ced3ed5": { "balance": "5640000000000000000000" }, "39824f8bced176fd3ea22ec6a493d0ccc33fc147": { "balance": "4000000000000000000000" }, "e338e859fe2e8c15554848b75caecda877a0e832": { "balance": "1801800000000000000000" }, "e53c68796212033e4e6f9cff56e19c461eb454f9": { "balance": "1000000000000000000000" }, "8461ecc4a6a45eb1a5b947fb86b88069b91fcd6f": { "balance": "2000000000000000000000" }, "6b4b99cb3fa9f7b74ce3a48317b1cd13090a1a7a": { "balance": "57300000000000000000" }, "97de21e421c37fe4b8025f9a51b7b390b5df7804": { "balance": "80000000000000000000000" }, "d25aecd7eb8bd6345b063b5dbd271c77d3514494": { "balance": "1820000000000000000000" }, "57b23d6a1adc06c652a779c6a7fb6b95b9fead66": { "balance": "200000000000000000000" }, "0d658014a199061cf6b39433140303c20ffd4e5a": { "balance": "8200000000000000000000" }, "30eac740e4f02cb56eef0526e5d300322600d03e": { "balance": "1970000000000000000000" }, "4eead40aad8c73ef08fc84bc0a92c9092f6a36bf": { "balance": "26740000000000000000" }, "30f7d025d16f7bee105580486f9f561c7bae3fef": { "balance": "500000000000000000000" }, "0977bfba038a44fb49b03970d8d8cf2cb61f8b25": { "balance": "420000000000000000000" }, "b14bbeff70720975dc6191b2a44ff49f2672873c": { "balance": "143000000000000000000" }, "d588c3a5df228185d98ee7e60748255cdea68b01": { "balance": "4000000000000000000000" }, "225d35faedb391c7bc2db7fa9071160405996d00": { "balance": "167774000000000000000" }, "c0e457bd56ec36a1246bfa3230fff38e5926ef22": { "balance": "1940000000000000000000" }, "2a9c57fe7b6b138a920d676f3c76b6c2a0eef699": { "balance": "9400000000000000000000" }, "36df8f883c1273ec8a171f7a33cfd649b1fe6075": { "balance": "227290000000000000000" }, "234f46bab73fe45d31bf87f0a1e0466199f2ebac": { "balance": "485000000000000000000" }, "a2e1b8aa900e9c139b3fa122354f6156d92a18b1": { "balance": "500000000000000000000" }, "517cd7608e5d0d83a26b717f3603dac2277dc3a4": { "balance": "2000000000000000000000" }, "75f7539d309e9039989efe2e8b2dbd865a0df088": { "balance": "2460000000000000000000" }, "4b792e29683eb586e394bb33526c6001b397999e": { "balance": "600000000000000000000" }, "a34f9d568bf7afd94c2a5b8a5ff55c66c4087999": { "balance": "2444000000000000000000" }, "4b31bf41abc75c9ae2cd8f7f35163b6e2b745054": { "balance": "382000000000000000000" }, "e35453eef2cc3c7a044d0ac134ba615908fa82ee": { "balance": "147510000000000000000" }, "7aa79ac04316cc8d08f20065baa6d4142897d54e": { "balance": "1400000000000000000000" }, "f1dc8ac81042c67a9c3c6792b230c46ac016ca10": { "balance": "200000000000000000000" }, "2bb366b9edcb0da680f0e10b3b6e28748190d6c3": { "balance": "5799400000000000000000" }, "a567770b6ae320bdde50f904d663e746a61dace6": { "balance": "2000000000000000000000" }, "d9d42fd13ebd4bf69cac5e9c7e82483ab46dd7e9": { "balance": "5348000000000000000000" }, "27830c5f6023afaaf79745676c204a0faccda0ba": { "balance": "240000000000000000000" }, "3cb179cb4801a99b95c3b0c324a2bdc101a65360": { "balance": "26000000000000000000" }, "976e3ceaf3f1af51f8c29aff5d7fa21f0386d8ee": { "balance": "240000000000000000000" }, "752a5ee232612cd3005fb26e5b597de19f776be6": { "balance": "5460000000000000000000" }, "7d5aa33fc14b51841a06906edb2bb49c2a117269": { "balance": "300048000000000000000" }, "55ca6abe79ea2497f46fdbb830346010fe469cbe": { "balance": "5730000000000000000000" }, "6bec311ad05008b4af353c958c40bd06739a3ff3": { "balance": "16380000000000000000000" }, "30e9698cf1e08a9d048bd8d8048f28be7ed9409f": { "balance": "6685000000000000000000" }, "9afa536b4c66bc38d875c4b30099d9261fdb38eb": { "balance": "205981000000000000000" }, "6b63a2dfb2bcd0caec0022b88be30c1451ea56aa": { "balance": "809021000000000000000" }, "d07be0f90997caf903c8ac1d53cde904fb190741": { "balance": "1000200000000000000000" }, "893cdddf5377f3c751bf2e541120045a47cba101": { "balance": "100000000000000000000" }, "c1cdc601f89c0428b31302d187e0dc08ad7d1c57": { "balance": "6000000000000000000000" }, "8f8acb107607388479f64baaabea8ff007ada97d": { "balance": "27281800000000000000000" }, "88bc43012edb0ea9f062ac437843250a39b78fbb": { "balance": "20000000000000000000000" }, "fcfc3a5004d678613f0b36a642269a7f371c3f6a": { "balance": "1000000000000000000000" }, "f509557e90183fbf0f0651a786487bcc428ba175": { "balance": "194000000000000000000" }, "e3d915eda3b825d6ee4af9328d32ac18ada35497": { "balance": "500000000000000000000" }, "f237ef05261c34d79cc22b860de0f17f793c3860": { "balance": "200000000000000000000" }, "a3a2e319e7d3a1448b5aa2468953160c2dbcba71": { "balance": "2000000000000000000000" }, "3a368efe4ad786e26395ec9fc6ad698cae29fe01": { "balance": "632200000000000000000" }, "8e3240b0810e1cf407a500804740cf8d616432a4": { "balance": "40309000000000000000" }, "5691dd2f6745f20e22d2e1d1b955aa2903d65656": { "balance": "1969606000000000000000" }, "5f93ff832774db5114c55bb4bf44ccf3b58f903f": { "balance": "192026650000000000000000" }, "2c1cc6e18c152488ba11c2cc1bcefa2df306abd1": { "balance": "1670000000000000000000" }, "bde9786a84e75b48f18e726dd78d70e4af3ed802": { "balance": "5730000000000000000000" }, "79551cede376f747e3716c8d79400d766d2e0195": { "balance": "46250000000000000000000" }, "49f028395b5a86c9e07f7778630e4c2e3d373a77": { "balance": "122735000000000000000" }, "6a3694424c7cc6b8bcd9bccaba540cc1f5df18d7": { "balance": "2000000000000000000000" }, "068e29b3f191c812a6393918f71ab933ae6847f2": { "balance": "1999944000000000000000" }, "6e64e6129f224e378c0e6e736a7e7a06c211e9ec": { "balance": "1000000000000000000000" }, "c4c15318d370c73318cc18bdd466dbaa4c6603bf": { "balance": "19700000000000000000" }, "8035bcffaefdeeea35830c497d14289d362023de": { "balance": "300000000000000000000" }, "a997dfc7986a27050848fa1c64d7a7d6e07acca2": { "balance": "143000000000000000000" }, "2fe13a8d0785de8758a5e41876c36e916cf75074": { "balance": "4000000000000000000000" }, "6f24c9af2b763480515d1b0951bb77a540f1e3f9": { "balance": "1970000000000000000000" }, "4c23b370fc992bb67cec06e26715b62f0b3a4ac3": { "balance": "10000000000000000000000" }, "4ac07673e42f64c1a25ec2fa2d86e5aa2b34e039": { "balance": "2000000000000000000000" }, "117db836377fe15455e02c2ebda40b1ceb551b19": { "balance": "6000000000000000000000" }, "ef1c0477f1184d60accab374d374557a0a3e10f3": { "balance": "152000000000000000000" }, "99fe0d201228a753145655d428eb9fd94985d36d": { "balance": "1939268000000000000000" }, "b3731b046c8ac695a127fd79d0a5d5fa6ae6d12e": { "balance": "1998000000000000000000" }, "dce30c31f3ca66721ecb213c809aab561d9b52e4": { "balance": "2000000000000000000000" }, "ddd69c5b9bf5eb5a39cee7c3341a120d973fdb34": { "balance": "1987730000000000000000" }, "216e41864ef98f060da08ecae19ad1166a17d036": { "balance": "5730000000000000000000" }, "6a53d41ae4a752b21abed5374649953a513de5e5": { "balance": "2000000000000000000000" }, "20dd8fcbb46ea46fe381a68b8ca0ea5be21fe9a5": { "balance": "2000000000000000000000" }, "19732bf973055dbd91a4533adaa2149a91d38380": { "balance": "2000000000000000000000" }, "51ea1c0934e3d04022ed9c95a087a150ef705e81": { "balance": "6280000000000000000000" }, "a0de5c601e696635c698b7ae9ca4539fc7b941ec": { "balance": "346150000000000000000" }, "94e1f5cb9b8abace03a1a6428256553b690c2355": { "balance": "20000000000000000000" }, "a539b4a401b584dfe0f344b1b422c65543167e2e": { "balance": "200000000000000000000" }, "50584d9206a46ce15c301117ee28f15c30e60e75": { "balance": "13400000000000000000" }, "856eb204241a87830fb229031343dc30854f581a": { "balance": "1000000000000000000000" }, "9dd46b1c6d3f05e29e9c6f037eed9a595af4a9aa": { "balance": "500000000000000000000" }, "8925da4549e15155e57a628522cea9dddf627d81": { "balance": "1000070000000000000000" }, "a89df34859edd7c820db887740d8ff9e15157c7b": { "balance": "2000000000000000000000" }, "ad9f4c890a3b511cee51dfe6cfd7f1093b76412c": { "balance": "506600000000000000000" }, "f8c7f34a38b31801da43063477b12b27d0f203ff": { "balance": "494800000000000000000" }, "a642501004c90ea9c9ed1998ba140a4cd62c6f5f": { "balance": "250543000000000000000" }, "508cf19119db70aa86454253da764a2cb1b2be1a": { "balance": "1000000000000000000000" }, "2979741174a8c1ea0b7f9edf658177859417f512": { "balance": "461283000000000000000" }, "654f524847b3a6acc0d3d5f1f362b603edf65f96": { "balance": "8000000000000000000000" }, "5cf18fa7c8a7c0a2b3d5efd1990f64ddc569242c": { "balance": "1000000000000000000000" }, "17e82e7078dc4fd9e879fb8a50667f53a5c54591": { "balance": "200000000000000000000" }, "8b07d050754dc9ba230db01c310afdb5395aa1b3": { "balance": "118080000000000000000" }, "5f77a107ab1226b3f95f10ee83aefc6c5dff3edc": { "balance": "500000000000000000000" }, "475a6193572d4a4e59d7be09cb960ddd8c530e2f": { "balance": "667323000000000000000" }, "6470a4f92ec6b0fccd01234fa59023e9ff1f3aac": { "balance": "3000000000000000000000" }, "2fbcef3384d420e4bf61a0669990bc7054f1a5af": { "balance": "2000000000000000000000" }, "bbabf6643beb4bd01c120bd0598a0987d82967d1": { "balance": "3342500000000000000000" }, "41a2f2e6ecb86394ec0e338c0fc97e9c5583ded2": { "balance": "2009400000000000000000" }, "fb9473cf7712350a1fa0395273fc80560752e4fb": { "balance": "123300000000000000000" }, "38b2197106123387a0d4de368431a8bacdda30e2": { "balance": "20000000000000000000" }, "5ed56115bd6505a88273df5c56839470d24a2db7": { "balance": "65601000000000000000" }, "523f6d64690fdacd942853591bb0ff20d3656d95": { "balance": "1820000000000000000000" }, "55caff4bba04d220c9a5d2018672ec85e31ef83e": { "balance": "2000000000000000000000" }, "65af8d8b5b1d1eedfa77bcbc96c1b133f83306df": { "balance": "98000000000000000000" }, "7456c5b2c5436e3e571008933f1805ccfe34e9ec": { "balance": "1000000000000000000000" }, "a6eebbe464d39187bf80ca9c13d72027ec5ba8be": { "balance": "3000000000000000000000" }, "dd35cfdbcb993395537aecc9f59085a8d5ddb6f5": { "balance": "1000000000000000000000" }, "98e2b6d606fd2d6991c9d6d4077fdf3fdd4585da": { "balance": "901520000000000000000" }, "860f5ffc10de767ded807f71e861d647dfd219b1": { "balance": "10000000000000000000000" }, "1a644a50cbc2aee823bd2bf243e825be4d47df02": { "balance": "100007000000000000000" }, "a8455b411765d6901e311e726403091e42c56683": { "balance": "3380000000000000000000" }, "3a86ee94862b743dd34f410969d94e2c5652d4ad": { "balance": "201610000000000000000" }, "a57360f002e0d64d2d74457d8ca4857ee00bcddf": { "balance": "335780000000000000000" }, "e59b3bd300893f97233ef947c46f7217e392f7e9": { "balance": "1000000000000000000000" }, "9f3a74fd5e7edcc1162993171381cbb632b7cff0": { "balance": "10000000000000000000000" }, "675d5caa609bf70a18aca580465d8fb7310d1bbb": { "balance": "20000000000000000000000" }, "77f609ca8720a023262c55c46f2d26fb3930ac69": { "balance": "17300000000000000000" }, "f8ac4a39b53c11307820973b441365cffe596f66": { "balance": "2000000000000000000000" }, "112634b4ec30ff786e024159f796a57939ea144e": { "balance": "1999944000000000000000" }, "49d2c28ee9bc545eaaf7fd14c27c4073b4bb5f1a": { "balance": "1474134000000000000000" }, "91cc46aa379f856a6640dccd5a648a7902f849d9": { "balance": "200000000000000000000" }, "b46440c797a556e04c7d9104660491f96bb076bf": { "balance": "14900000000000000000" }, "e5968797468ef767101b761d431fce14abffdbb4": { "balance": "8040000000000000000000" }, "c0895efd056d9a3a81c3da578ada311bfb9356cf": { "balance": "200000000000000000000" }, "76846f0de03b5a76971ead298cdd08843a4bc6c6": { "balance": "15500000000000000000" }, "5f708eaf39d823946c51b3a3e9b7b3c003e26341": { "balance": "1820000000000000000000" }, "24f7450ddbf18b020feb1a2032d9d54b633edf37": { "balance": "50000000000000000000" }, "cae3a253bcb2cf4e13ba80c298ab0402da7c2aa0": { "balance": "5400000000000000000000" }, "91e8810652e8e6161525d63bb7751dc20f676076": { "balance": "725000000000000000000" }, "543629c95cdef428ad37d453ca9538a9f90900ac": { "balance": "43250000000000000000000" }, "6e79edd4845b076e4cd88d188b6e432dd93f35aa": { "balance": "955000000000000000000" }, "bd325d4029e0d8729f6d399c478224ae9e7ae41e": { "balance": "3880000000000000000000" }, "42cecfd2921079c2d7df3f08b07aa3beee5e219a": { "balance": "1000000000000000000000" }, "3690246ba3c80679e22eac4412a1aefce6d7cd82": { "balance": "20000000000000000000000" }, "577aeee8d4bc08fc97ab156ed57fb970925366be": { "balance": "333046000000000000000" }, "fe00bf439911a553982db638039245bcf032dbdc": { "balance": "394000000000000000000" }, "91f624b24a1fa5a056fe571229e7379db14b9a1e": { "balance": "11999974000000000000000" }, "f206d328e471d0117b246d2a4619827709e96df3": { "balance": "3001000000000000000000" }, "073f1ed1c9c3e9c52a9b0249a5c1caa0571fdf05": { "balance": "70400000000000000000" }, "f56048dd2181d4a36f64fcecc6215481e42abc15": { "balance": "200000000000000000000" }, "ef76a4cd8febcbc9b818f17828f8d93473f3f3cb": { "balance": "4000000000000000000000" }, "1031e0ecb54985ae21af1793950dc811888fde7c": { "balance": "20000000000000000000" }, "8e0fee38685a94aabcd7ce857b6b1409824f75b8": { "balance": "500000000000000000000" }, "f0cbef84e169630098d4e301b20208ef05846ac9": { "balance": "259084000000000000000" }, "bbca65b3266ea2fb73a03f921635f912c7bede00": { "balance": "1970000000000000000000" }, "0aec2e426ed6cc0cf3c249c1897eac47a7faa9bd": { "balance": "200000000000000000000" }, "b8f30758faa808dbc919aa7b425ec922b93b8129": { "balance": "1000076000000000000000" }, "936dcf000194e3bff50ac5b4243a3ba014d661d8": { "balance": "10000000000000000000000" }, "b14ddb0386fb606398b8cc47565afae00ff1d66a": { "balance": "2973024000000000000000" }, "2ec95822eb887bc113b4712a4dfd7f13b097b5e7": { "balance": "1000000000000000000000" }, "0136a5af6c3299c6b5f005fdaddb148c070b299b": { "balance": "20368000000000000000" }, "37cb868d2c3f95b257611eb34a4188d58b749802": { "balance": "2000000000000000000000" }, "cd7f09d7ed66d0c38bc5ad4e32b7f2b08dc1b30d": { "balance": "1148000000000000000000" }, "b5fa8184e43ed3e0b8ab91216461b3528d84fd09": { "balance": "2680000000000000000000" }, "3dbf0dbfd77890800533f09dea8301b9f025d2a6": { "balance": "1000000000000000000000" }, "b553d25d6b5421e81c2ad05e0b8ba751f8f010e3": { "balance": "2000000000000000000000" }, "dbf8b13967f55125272de0562536c450ba5655a0": { "balance": "2046830000000000000000" }, "0f6e840a3f2a24647d8e43e09d45c7c335df4248": { "balance": "2500000000000000000000" }, "fa2fd29d03fee9a07893df3a269f56b72f2e1e64": { "balance": "10000000000000000000000" }, "8b57b2bc83cc8d4de331204e893f2f3b1db1079a": { "balance": "40000000000000000000" }, "7f541491d2ac00d2612f94aa7f0bcb014651fbd4": { "balance": "376000000000000000000" }, "4f4a9be10cd5d3fb5de48c17be296f895690645b": { "balance": "40000000000000000000000" }, "45d1c9eedf7cab41a779057b79395f5428d80528": { "balance": "2000000000000000000000" }, "662334814724935b7931ddca6100e00d467727cd": { "balance": "637000000000000000000" }, "2c52c984102ee0cd3e31821b84d408930efa1ac7": { "balance": "2000000000000000000000" }, "000d836201318ec6899a67540690382780743280": { "balance": "200000000000000000000" }, "81498ca07b0f2f17e8bbc7e61a7f4ae7be66b78b": { "balance": "101600000000000000000" }, "7860a3de38df382ae4a4dce18c0c07b98bce3dfa": { "balance": "1000000000000000000000" }, "5e8e4df18cf0af770978a8df8dac90931510a679": { "balance": "2000000000000000000000" }, "05d68dad61d3bbdfb3f779265c49474aff3fcd30": { "balance": "39399000000000000000" }, "96eafbf2fb6f4db9a436a74c45b5654452e23819": { "balance": "20000000000000000000" }, "d7d7f2caa462a41b3b30a34aeb3ba61010e2626f": { "balance": "2000000000000000000000" }, "0b71f554122469ef978e2f1fefd7cbb410982772": { "balance": "3880000000000000000000" }, "504666ce8931175e11a5ed11c1dcaa06e57f4e66": { "balance": "11792000000000000000000" }, "d00f067286c0fbd082f9f4a61083ec76deb3cee6": { "balance": "1000000000000000000000" }, "02e4cb22be46258a40e16d4338d802fffd00c151": { "balance": "379786000000000000000" }, "1c13d38637b9a47ce79d37a86f50fb409c060728": { "balance": "1337000000000000000000" }, "e30212b2011bb56bdbf1bc35690f3a4e0fd905ea": { "balance": "8022000000000000000000" }, "1df6911672679bb0ef3509038c0c27e394fdfe30": { "balance": "540000000000000000000" }, "2b8fe4166e23d11963c0932b8ade8e0145ea0770": { "balance": "43250000000000000000000" }, "6509eeb1347e842ffb413e37155e2cbc738273fd": { "balance": "2000000000000000000000" }, "8b7e9f6f05f7e36476a16e3e7100c9031cf404af": { "balance": "1000000000000000000000" }, "bec8caf7ee49468fee552eff3ac5234eb9b17d42": { "balance": "2000000000000000000000" }, "38898bbb4553e00bbfd0cf268b2fc464d154add5": { "balance": "320000000000000000000" }, "cbb3189e4bd7f45f178b1c30c76e26314d4a4b0a": { "balance": "295007000000000000000" }, "be1cd7f4c472070968f3bde268366b21eeea8321": { "balance": "4300000000000000000000" }, "976a18536af41874426308871bcd1512a775c9f8": { "balance": "10000000000000000000000" }, "e9c758f8da41e3346e4350e5ac3976345c6c1082": { "balance": "1930050000000000000000" }, "64ec8a5b743f3479e707dae9ee20ddaa4f40f1d9": { "balance": "200000000000000000000" }, "9e01765aff08bc220550aca5ea2e1ce8e5b09923": { "balance": "1000000000000000000000" }, "ba0f39023bdb29eb1862a9f9059cab5d306e662f": { "balance": "2000000000000000000000" }, "2baf8d6e221174124820ee492b9459ec4fadafbb": { "balance": "2000000000000000000000" }, "655d5cd7489629e2413c2105b5a172d933c27af8": { "balance": "4040060000000000000000" }, "badc2aef9f5951a8d78a6b35c3d0b3a4e6e2e739": { "balance": "6000000000000000000000" }, "e64f6e1d6401b56c076b64a1b0867d0b2f310d4e": { "balance": "51570000000000000000" }, "7a8563867901206f3f2bf0fa3e1c8109cabccd85": { "balance": "137000000000000000000" }, "d17fbe22d90462ed37280670a2ea0b3086a0d6d6": { "balance": "199955000000000000000" }, "e96d7d4cdd15553a4e4d316d6d6480ca3cea1e38": { "balance": "12200000000000000000000" }, "f04d2c91efb6e9c45ffbe74b434c8c5f2b028f1f": { "balance": "1000000000000000000000" }, "81164deb10814ae08391f32c08667b6248c27d7a": { "balance": "394000000000000000000" }, "7f5ae05ae0f8cbe5dfe721f044d7a7bef4c27997": { "balance": "60000000000000000000" }, "c982586d63b0d74c201b1af8418372e30c7616be": { "balance": "100000000000000000000" }, "64cf0935bf19d2cebbecd8780d27d2e2b2c34166": { "balance": "1970000000000000000000" }, "cd566ad7b883f01fd3998a9a58a9dee4724ddca5": { "balance": "58848000000000000000" }, "9da609fa3a7e6cf2cc0e70cdabe78dc4e382e11e": { "balance": "1200000000000000000000" }, "0d69100c395ce6c5eaadf95d05d872837ededd21": { "balance": "400000000000000000000" }, "fe91eccf2bd566afa11696c5049fa84c69630a52": { "balance": "1940000000000000000000" }, "005d0ee8155ec0a6ff6808552ca5f16bb5be323a": { "balance": "197000000000000000000" }, "3e5cb8928c417825c03a3bfcc52183e5c91e42d7": { "balance": "4264790000000000000000" }, "9c1b771f09af882af0643083de2aa79dc097c40e": { "balance": "2480000000000000000000" }, "eba388b0da27c87b1cc0eac6c57b2c5a0b459c1a": { "balance": "6800000000000000000000" }, "7529f3797bb6a20f7ea6492419c84c867641d81c": { "balance": "2000000000000000000000" }, "532a7da0a5ad7407468d3be8e07e69c7dd64e861": { "balance": "500000000000000000000" }, "de82cc8d4a1bb1d9434392965b3e80bad3c03d4f": { "balance": "1477500000000000000000" }, "4a82694fa29d9e213202a1a209285df6e745c209": { "balance": "4000000000000000000000" }, "3e53ff2107a8debe3328493a92a586a7e1f49758": { "balance": "23143470000000000000000" }, "b2ddb786d3794e270187d0451ad6c8b79e0e8745": { "balance": "400000000000000000000" }, "6ebcf9957f5fc5e985add475223b04b8c14a7aed": { "balance": "1730000000000000000000" }, "c5c7590b5621ecf8358588de9b6890f2626143f1": { "balance": "3000000000000000000000" }, "ae4f122e35c0b1d1e4069291457c83c07f965fa3": { "balance": "1000000000000000000000" }, "47885ababedf4d928e1c3c71d7ca40d563ed595f": { "balance": "1820000000000000000000" }, "78ce3e3d474a8a047b92c41542242d0a08c70f99": { "balance": "10000000000000000000000" }, "6134d942f037f2cc3d424a230c603d67abd3edf7": { "balance": "2000000000000000000000" }, "1360e87df24c69ee6d51c76e73767ffe19a2131c": { "balance": "92000000000000000000" }, "5fd1c3e31778276cb42ea740f5eae9c641dbc701": { "balance": "194000000000000000000" }, "98397342ec5f3d4cb877e54ef5d6f1d366731bd4": { "balance": "5910000000000000000000" }, "6d4b5c05d06a20957e1748ab6df206f343f92f01": { "balance": "10020475000000000000000" }, "e6115b13f9795f7e956502d5074567dab945ce6b": { "balance": "100000000000000000000000" }, "23730c357a91026e44b1d0e2fc2a51d071d8d77b": { "balance": "4000000000000000000000" }, "fae881937047895a660cf229760f27e66828d643": { "balance": "182000000000000000000" }, "ff3ef6ba151c21b59986ae64f6e8228bc9a2c733": { "balance": "2000000000000000000000" }, "dfbd4232c17c407a980db87ffbcda03630e5c459": { "balance": "553150000000000000000" }, "4429a29fee198450672c0c1d073162250bec6474": { "balance": "999200000000000000000" }, "7e8f96cc29f57b0975120cb593b7dd833d606b53": { "balance": "197000000000000000000" }, "5ed3f1ebe2ae6756b5d8dc19cad02c419aa5778b": { "balance": "0" }, "daa776a6754469d7b9267a89b86725e740da0fa0": { "balance": "1970000000000000000000" }, "139e479764b499d666208c4a8a047a97043163dd": { "balance": "598880000000000000000" }, "5ad5e420755613886f35aa56ac403eebdfe4b0d0": { "balance": "80000000000000000000000" }, "3fe801e61335c5140dc7eda2ef5204460a501230": { "balance": "2000000000000000000000" }, "ce8a6b6d5033b1498b1ffeb41a41550405fa03a2": { "balance": "4000000000000000000000" }, "26c2ffc30efdc5273e76183a16c2698d6e531286": { "balance": "776000000000000000000" }, "71ec3aec3f8f9221f9149fede06903a0f9a232f2": { "balance": "200000000000000000000" }, "ef35f6d4b1075e6aa139151c974b2f4658f70538": { "balance": "1111111000000000000000" }, "26a68eab905a8b3dce00e317308225dab1b9f6b8": { "balance": "1980000000000000000000" }, "63f5b53d79bf2e411489526530223845fac6f601": { "balance": "30000000000000000000000" }, "481115296ab7db52492ff7b647d63329fb5cbc6b": { "balance": "16100000000000000000000" }, "f19f193508393e4d2a127b20b2031f39c82581c6": { "balance": "3500088000000000000000" }, "500e34cde5bd9e2b71bb92d7cf55eee188d5fa0c": { "balance": "5348000000000000000000" }, "65ea67ad3fb56ad5fb94387dd38eb383001d7c68": { "balance": "100000000000000000000" }, "7f9f9b56e4289dfb58e70fd5f12a97b56d35c6a5": { "balance": "1970000000000000000000" }, "60be6f953f2a4d25b6256ffd2423ac1438252e4e": { "balance": "150000000000000000000" }, "ac1dfc984b71a19929a81d81f04a7cbb14073703": { "balance": "600000000000000000000" }, "a3c14ace28b192cbb062145fcbbd5869c67271f6": { "balance": "8000000000000000000000" }, "2da76b7c39b420e388ba2c1020b0856b0270648a": { "balance": "2000000000000000000000" }, "622be4b45495fcd93143efc412d699d6cdc23dc5": { "balance": "17300000000000000000" }, "d3f873bd9956135789ab00ebc195b922e94b259d": { "balance": "2000000000000000000000" }, "975f3764e97bbccf767cbd3b795ba86d8ba9840e": { "balance": "346000000000000000000" }, "fc39be41094b1997d2169e8264c2c3baa6c99bc4": { "balance": "2000000000000000000000" }, "12ffc1128605cb0c13709a7290506f2690977193": { "balance": "3340000000000000000000" }, "9b1168de8ab64b47552f3389800a9cc08b4666cf": { "balance": "1730000000000000000000" }, "9f1aa8fcfc89a1a5328cbd6344b71f278a2ca4a0": { "balance": "500000000000000000000" }, "505a33a18634dd4800693c67f48a1d693d4833f8": { "balance": "7252000000000000000000" }, "d08fc09a0030fd0928cd321198580182a76aae9f": { "balance": "1000000000000000000000" }, "6acddca3cd2b4990e25cd65c24149d0912099e79": { "balance": "3000037000000000000000" }, "397a6ef8763a18f00fac217e055c0d3094101011": { "balance": "2000000000000000000000" }, "4e0bd32473c4c51bf25654def69f797c6b29a232": { "balance": "1600930000000000000000" }, "28d8c35fb7eea622582135e3ad47a227c9a663bd": { "balance": "18200000000000000000" }, "f96488698590dc3b2c555642b871348dfa067ad5": { "balance": "500000000000000000000" }, "4eebe80cb6f3ae5904f6f4b28d907f907189fcab": { "balance": "1999944000000000000000" }, "8d1abd897dacd4312e18080c88fb9647eab44052": { "balance": "216000000000000000000" }, "457029c469c4548d168cec3e65872e4428d42b67": { "balance": "2000000000000000000000" }, "1296acded1e063af39fe8ba0b4b63df789f70517": { "balance": "100014000000000000000" }, "71762c63678c18d1c6378ce068e666381315147e": { "balance": "2000000000000000000000" }, "6cc1c878fa6cde8a9a0b8311247e741e4642fe6d": { "balance": "985000000000000000000" }, "8d9ed7f4553058c26f7836a3802d3064eb1b363d": { "balance": "90000000000000000000" }, "5032e4bcf7932b49fdba377b6f1499636513cfc3": { "balance": "100000000000000000000" }, "462b678b51b584f3ed7ada070b5cd99c0bf7b87f": { "balance": "100000000000000000000" }, "c8aa49e3809f0899f28ab57e6743709d58419033": { "balance": "880000000000000000000" }, "01b1cae91a3b9559afb33cdc6d689442fdbfe037": { "balance": "200000000000000000000" }, "b1043004ec1941a8cf4f2b00b15700ddac6ff17e": { "balance": "1000000000000000000000" }, "5ba2c6c35dfaec296826591904d544464aeabd5e": { "balance": "20000000000000000000" }, "b32400fd13c5500917cb037b29fe22e7d5228f2d": { "balance": "40000000000000000000000" }, "d59d92d2c8701980cc073c375d720af064743c0c": { "balance": "19000000000000000000000" }, "11dd6185d9a8d73ddfdaa71e9b7774431c4dfec2": { "balance": "1000000000000000000000" }, "d4cb21e590c5a0e06801366aff342c7d7db16424": { "balance": "494000000000000000000" }, "5b6d55f6712967405c659129f4b1de09acf2cb7b": { "balance": "267400000000000000000" }, "6179979907fe7f037e4c38029d60bcbab832b3d6": { "balance": "1610000000000000000000" }, "33c407133b84b3ca4c3ded1f4658900c38101624": { "balance": "2800000000000000000000" }, "cd2a36d753e9e0ed012a584d716807587b41d56a": { "balance": "261400000000000000000" }, "8155fa6c51eb31d808412d748aa086105018122f": { "balance": "1880000000000000000000" }, "3ecc8e1668dde995dc570fe414f44211c534a615": { "balance": "2000000000000000000000" }, "d6395db5a4bb66e60f4cfbcdf0057bb4d97862e2": { "balance": "910000000000000000000" }, "b6fb39786250081426a342c70d47ee521e5bc563": { "balance": "15000000000000000000000" }, "510eda5601499a0d5e1a006bfffd833672f2e267": { "balance": "2000000000000000000000" }, "98c19dba810ba611e68f2f83ee16f6e7744f0c1f": { "balance": "200000000000000000000" }, "34ff26eb60a8d1a95a489fae136ee91d4e58084c": { "balance": "600000000000000000000" }, "6ad90be252d9cd464d998125fab693060ba8e429": { "balance": "4000000000000000000000" }, "038323b184cff7a82ae2e1bda7793fe4319ca0bf": { "balance": "20000000000000000000000" }, "dc5305b4020a06b49d657c7ca34c35c91c5f2c56": { "balance": "7045990000000000000000" }, "c9c80dc12e7bab86e949d01e4c3ed35f2b9bba5f": { "balance": "2000000000000000000000" }, "7beb81fb2f5e91526b2ac9795e76c69bcff04bc0": { "balance": "69400000000000000000000" }, "b8bc9bca7f71b4ed12e620438d620f53c114342f": { "balance": "500000000000000000000" }, "d288e7cb7ba9f620ab0f7452e508633d1c5aa276": { "balance": "4000000000000000000000" }, "a2e460a989cb15565f9ecca7d121a18e4eb405b6": { "balance": "2000000000000000000000" }, "7489cc8abe75cda4ef0d01cef2605e47eda67ab1": { "balance": "133700000000000000000" }, "38b403fb1fb7c14559a2d6f6564a5552bca39aff": { "balance": "2000000000000000000000" }, "e55c80520a1b0f755b9a2cd3ce214f7625653e8a": { "balance": "2000000000000000000000" }, "451b7070259bdba27100e36e23428a53dfe304e9": { "balance": "13370000000000000000" }, "8b5c914b128bf1695c088923fa467e7911f351fa": { "balance": "98500000000000000000" }, "17df49518d73b129f0da36b1c9b40cb66420fdc7": { "balance": "10000000000000000000000" }, "c1950543554d8a713003f662bb612c10ad4cdf21": { "balance": "18200000000000000000" }, "fa7606435b356cee257bd2fcd3d9eacb3cd1c4e1": { "balance": "100000000000000000000" }, "e0bad98eee9698dbf6d76085b7923de5754e906d": { "balance": "167000000000000000000" }, "ce53c8cdd74296aca987b2bc19c2b875a48749d0": { "balance": "3000000000000000000000" }, "d0c55abf976fdc3db2afe9be99d499484d576c02": { "balance": "1000000000000000000000" }, "238a6b7635252f5244486c0af0a73a207385e039": { "balance": "1370000000000000000000" }, "ceb389381d48a8ae4ffc483ad0bb5e204cfdb1ec": { "balance": "740745000000000000000" }, "3847667038f33b01c1cc795d8daf5475eff5a0d4": { "balance": "728330000000000000000" }, "a08d215b5b6aac4861a281ac7e400b78fef04cbf": { "balance": "20000000000000000000" }, "2d0dec51a6e87330a6a8fa2a0f65d88d4abcdf73": { "balance": "185000000000000000000" }, "9e8f64ddcde9b8b451bafaa235a9bf511a25ac91": { "balance": "2674000000000000000000" }, "ddac6bf4bbdd7d597d9c686d0695593bedccc7fa": { "balance": "865000000000000000000" }, "22e15158b5ee3e86eb0332e3e6a9ac6cd9b55ecd": { "balance": "160000000000000000000" }, "3aea4e82d2400248f99871a41ca257060d3a221b": { "balance": "1000000000000000000000" }, "fb126f0ec769f49dcefca2f200286451583084b8": { "balance": "5013750000000000000000" }, "1b8bd6d2eca20185a78e7d98e8e185678dac4830": { "balance": "16700000000000000000000" }, "664cd67dccc9ac8228b45c55db8d76550b659cdc": { "balance": "394000000000000000000" }, "553f37d92466550e9fd775ae74362df030179132": { "balance": "2000000000000000000000" }, "730d8763c6a4fd824ab8b859161ef7e3a96a1200": { "balance": "20000000000000000000000" }, "04c2c64bb54c3eccd05585e10ec6f99a0cdb01a3": { "balance": "100000000000000000000" }, "f1624d980b65336feac5a6d54125005cfcf2aacb": { "balance": "2000000000000000000000" }, "0b7fc9ddf70576f6330669eaaa71b6a831e99528": { "balance": "140000000000000000000" }, "fa2bbca15d3fe39f8a328e91f90da14f7ac6253d": { "balance": "200000000000000000000" }, "07feef54c136850829badc4b49c3f2a73c89fb9e": { "balance": "118200000000000000000" }, "3703350c4d6fe337342cddc65bf1e2386bf3f9b2": { "balance": "2020000000000000000000" }, "6d7d1c949511f88303808c60c5ea0640fcc02683": { "balance": "10000000000000000000000" }, "34fa7792bad8bbd7ff64056214a33eb6600c1ea8": { "balance": "50000000000000000000" }, "994cc2b5227ec3cf048512467c41b7b7b748909f": { "balance": "2000000000000000000000" }, "08da3a7a0f452161cfbcec311bb68ebfdee17e88": { "balance": "2000000000000000000000" }, "bbb4ee1d82f2e156442cc93338a2fc286fa28864": { "balance": "1370000000000000000000" }, "7a2dfc770e24368131b7847795f203f3d50d5b56": { "balance": "11400000000000000000000" }, "7cef4d43aa417f9ef8b787f8b99d53f1fea1ee88": { "balance": "1910000000000000000000" }, "c6a30ef5bb3320f40dc5e981230d52ae3ac19322": { "balance": "182000000000000000000" }, "6a74844d8e9cb5581c45079a2e94462a6cee8821": { "balance": "1082970000000000000000" }, "c3110be01dc9734cfc6e1ce07f87d77d1345b7e1": { "balance": "4999998000000000000000" }, "aeb916ebf49d0f86c13f7331cef19e129937512d": { "balance": "599908000000000000000" }, "3e5abd09ce5af7ba8487c359e0f2a93a986b0b18": { "balance": "10000000000000000000000" }, "cdd60d73efaad873c9bbfb178ca1b7105a81a681": { "balance": "32000000000000000000" }, "31eb123c95c82bf685ace7a75a1881a289efca10": { "balance": "920034000000000000000" }, "86e8670e27598ea09c3899ab7711d3b9fe901c17": { "balance": "200000000000000000000" }, "a144f6b60f72d64a21e330dadb62d8990ade2b09": { "balance": "1000000000000000000000" }, "68883e152e5660fee59626e7e3b4f05110e6222f": { "balance": "54683300000000000000000" }, "fe4249127950e2f896ec0e7e2e3d055aab10550f": { "balance": "668500000000000000000" }, "403d53cf620f0922b417848dee96c190b5bc8271": { "balance": "9850000000000000000000" }, "bec2e6de39c07c2bae556acfbee2c4728b9982e3": { "balance": "573000000000000000000" }, "f3c4716d1ee5279a86d0163a14618181e16136c7": { "balance": "1000000000000000000000" }, "e38ef28a5ed984a7db24a1ae782dfb87f397dfc6": { "balance": "143000000000000000000" }, "30fbe5885f9fcce9ea5edb82ed4a1196dd259aed": { "balance": "5200000000000000000000" }, "48bf14d7b1fc84ebf3c96be12f7bce01aa69b03e": { "balance": "120000000000000000000" }, "b8d5c324a8209d7c8049d0d4aede02ba80ab578b": { "balance": "16889329000000000000000" }, "43d5a71ce8b8f8ae02b2eaf8eaf2ca2840b93fb6": { "balance": "6000000000000000000000" }, "f9a59c3cc5ffacbcb67be0fc7256f64c9b127cb4": { "balance": "2000000000000000000000" }, "0e21af1b8dbf27fcf63f37e047b87a825cbe7c27": { "balance": "3000000000000000000000" }, "1c35aab688a0cd8ef82e76541ba7ac39527f743b": { "balance": "500000000000000000000" }, "91ac5cfe67c54aa7ebfba448666c461a3b1fe2e1": { "balance": "401880000000000000000" }, "4ba53ab549e2016dfa223c9ed5a38fad91288d07": { "balance": "1400000000000000000000" }, "99a4de19ded79008cfdcd45d014d2e584b8914a8": { "balance": "1500000000000000000000" }, "4adbf4aae0e3ef44f7dd4d8985cfaf096ec48e98": { "balance": "150000000000000000000" }, "9a633fcd112cceeb765fe0418170732a9705e79c": { "balance": "18200000000000000000" }, "292f228b0a94748c8eec612d246f989363e08f08": { "balance": "185000000000000000000" }, "9f3497f5ef5fe63095836c004eb9ce02e9013b4b": { "balance": "633424000000000000000" }, "0e6dfd553b2e873d2aec15bd5fbb3f8472d8d394": { "balance": "12000000000000000000000" }, "74ebf4425646e6cf81b109ce7bf4a2a63d84815f": { "balance": "40000000000000000000" }, "8ce5e3b5f591d5eca38abf228f2e3c35134bdac0": { "balance": "2319920000000000000000" }, "90c41eba008e20cbe927f346603fc88698125969": { "balance": "42000000000000000000" }, "382ba76db41b75606dd48a48f0137e9174e031b6": { "balance": "20000000000000000000" }, "5d24bdbc1c47f0eb83d128cae48ac33c4817e91f": { "balance": "1000000000000000000000" }, "a64e5ffb704c2c9139d77ef61d8cdfa31d7a88e9": { "balance": "143000000000000000000" }, "a18360e985f2062e8f8efe02ad2cbc91ad9a5aad": { "balance": "3000000000000000000000" }, "d251f903ae18727259eee841a189a1f569a5fd76": { "balance": "10000000000000000000000" }, "efa6b1f0db603537826891b8b4bc163984bb40cd": { "balance": "985000000000000000000" }, "47fff42c678551d141eb75a6ee398117df3e4a8d": { "balance": "100010000000000000000" }, "f2294adbb6f0dcc76e632ebef48ab49f124dbba4": { "balance": "1443690000000000000000" }, "53700d53254d430f22781a4a76a463933b5d6b08": { "balance": "1970000000000000000000" }, "b14a7aaa8f49f2fb9a8102d6bbe4c48ae7c06fb2": { "balance": "8000000000000000000000" }, "9ed4e63f526542d44fddd34d59cd25388ffd6bda": { "balance": "3885000000000000000000" }, "4cac91fb83a147d2f76c3267984b910a79933348": { "balance": "2167000000000000000000" }, "9b32cf4f5115f4b34a00a64c617de06387354323": { "balance": "105501000000000000000" }, "b8bedd576a4b4c2027da735a5bc3f533252a1808": { "balance": "2000000000000000000000" }, "c5a3b98e4593fea0b38c4f455a5065f051a2f815": { "balance": "20309030000000000000000" }, "eaf52388546ec35aca6f6c6393d8d609de3a4bf3": { "balance": "20000000000000000000" }, "4c423c76930d07f93c47a5cc4f615745c45a9d72": { "balance": "100000000000000000000" }, "9052f2e4a3e3c12dd1c71bf78a4ec3043dc88b7e": { "balance": "267400000000000000000" }, "2bade91d154517620fd4b439ac97157a4102a9f7": { "balance": "4000000000000000000000" }, "da698d64c65c7f2b2c7253059cd3d181d899b6b7": { "balance": "295500000000000000000" }, "c6d8954e8f3fc533d2d230ff025cb4dce14f3426": { "balance": "400000000000000000000" }, "349a816b17ab3d27bbc0ae0051f6a070be1ff29d": { "balance": "10000000000000000000000" }, "ff4d9c8484c43c42ff2c5ab759996498d323994d": { "balance": "4000000000000000000000" }, "22944fbca9b57963084eb84df7c85fb9bcdfb856": { "balance": "4649845000000000000000" }, "bfd93c90c29c07bc5fb5fc49aeea55a40e134f35": { "balance": "28000000000000000000000" }, "3caedb5319fe806543c56e5021d372f71be9062e": { "balance": "40000000000000000000000" }, "9a079c92a629ca15c8cafa2eb28d5bc17af82811": { "balance": "500000000000000000000" }, "7d2a52a7cf0c8436a8e007976b6c26b7229d1e15": { "balance": "438040000000000000000" }, "cf89f7460ba3dfe83c5a1d3a019ee1250f242f0f": { "balance": "985177000000000000000" }, "577bfe64e3a1e3800e94db1c6c184d8dc8aafc66": { "balance": "1498000000000000000000" }, "7ffd02ed370c7060b2ae53c078c8012190dfbb75": { "balance": "10000000000000000000000" }, "90b62f131a5f29b45571513ee7a74a8f0b232202": { "balance": "158000000000000000000" }, "6e8212b722afd408a7a73ed3e2395ee6454a0330": { "balance": "159000000000000000000" }, "515f30bc90cdf4577ee47d65d785fbe2e837c6bc": { "balance": "10166128000000000000000" }, "c27376f45d21e15ede3b26f2655fcee02ccc0f2a": { "balance": "20000000000000000000" }, "3da39ce3ef4a7a3966b32ee7ea4ebc2335a8f11f": { "balance": "2000000000000000000000" }, "25259d975a21d83ae30e33f800f53f37dfa01938": { "balance": "20000000000000000000" }, "8ed143701f2f72280fd04a7b4164281979ea87c9": { "balance": "14000000000000000000" }, "5ac99ad7816ae9020ff8adf79fa9869b7cea6601": { "balance": "21000000000000000000000" }, "f51fded80acb502890e87369741f3722514cefff": { "balance": "20000042000000000000000" }, "f657fcbe682eb4e8db152ecf892456000b513d15": { "balance": "1940000000000000000000" }, "62c37c52b97f4b040b1aa391d6dec152893c4707": { "balance": "1000000000000000000000" }, "89fc8e4d386b0d0bb4a707edf3bd560df1ad8f4e": { "balance": "2955000000000000000000" }, "53c0bb7fc88ea422d2ef7e540e2d8f28b1bb8183": { "balance": "20000000000000000000" }, "56f493a3d108aaa2d18d98922f8efe1662cfb73d": { "balance": "2020000000000000000000" }, "e9458f68bb272cb5673a04f781b403556fd3a387": { "balance": "61000000000000000000" }, "be525a33ea916177f17283fca29e8b350b7f530b": { "balance": "2638000000000000000000" }, "4feb846be43041fd6b34202897943e3f21cb7f04": { "balance": "83226000000000000000" }, "15aa530dc36958b4edb38eee6dd9e3c77d4c9145": { "balance": "2000000000000000000000" }, "2458d6555ff98a129cce4037953d00206eff4287": { "balance": "197000000000000000000" }, "8035fe4e6b6af27ae492a578515e9d39fa6fa65b": { "balance": "4000000000000000000000" }, "296b71c0015819c242a7861e6ff7eded8a5f71e3": { "balance": "1999800000000000000000" }, "8f1952eed1c548d9ee9b97d0169a07933be69f63": { "balance": "1000000000000000000000" }, "a421dbb89b3a07419084ad10c3c15dfe9b32d0c2": { "balance": "20000000000000000000000" }, "554336ee4ea155f9f24f87bca9ca72e253e12cd2": { "balance": "100000000000000000000" }, "ffc5fc4b7e8a0293ff39a3a0f7d60d2646d37a74": { "balance": "2000000000000000000000" }, "ea2c197d26e98b0da83e1b72c787618c979d3db0": { "balance": "19700000000000000000" }, "96aa573fed2f233410dbae5180145b23c31a02f0": { "balance": "1730000000000000000000" }, "c23b2f921ce4a37a259ee4ad8b2158d15d664f59": { "balance": "25403000000000000000" }, "d874b9dfae456a929ba3b1a27e572c9b2cecdfb3": { "balance": "170000000000000000000" }, "bf8b8005d636a49664f74275ef42438acd65ac91": { "balance": "200000000000000000000" }, "441a52001661fac718b2d7b351b7c6fb521a7afd": { "balance": "400000000000000000000" }, "812a55c43caedc597218379000ce510d548836fd": { "balance": "18200000000000000000" }, "5e90c85877198756b0366c0e17b28e52b446505a": { "balance": "374288000000000000000" }, "da3017c150dd0dce7fcf881b0a48d0d1c756c4c7": { "balance": "100014000000000000000" }, "6baf7a2a02ae78801e8904ad7ac05108fc56cff6": { "balance": "1000000000000000000000" }, "177dae78bc0113d8d39c4402f2a641ae2a105ab8": { "balance": "1818320000000000000000" }, "01b5b5bc5a117fa08b34ed1db9440608597ac548": { "balance": "200000000000000000000" }, "aae732eda65988c3a00c7f472f351c463b1c968e": { "balance": "2000000000000000000000" }, "d95342953c8a21e8b635eefac7819bea30f17047": { "balance": "94160000000000000000000" }, "8d616b1eee77eef6f176e0698db3c0c141b2fc8f": { "balance": "500000000000000000000" }, "12d20790b7d3dbd88c81a279b812039e8a603bd0": { "balance": "1604400000000000000000" }, "3734cb187491ede713ae5b3b2d12284af46b8101": { "balance": "3000000000000000000000" }, "dd967c4c5f8ae47e266fb416aad1964ee3e7e8c3": { "balance": "7750000000000000000000" }, "3dcef19c868b15d34eda426ec7e04b18b6017002": { "balance": "1999800000000000000000" }, "ce9d21c692cd3c01f2011f505f870036fa8f6cd2": { "balance": "400000000000000000000" }, "d44f6ac3923b5fd731a4c45944ec4f7ec52a6ae4": { "balance": "10000000000000000000000" }, "b424d68d9d0d00cec1938c854e15ffb880ba0170": { "balance": "200000000000000000000" }, "1f2186ded23e0cf9521694e4e164593e690a9685": { "balance": "300000000000000000000" }, "7f4b5e278578c046cceaf65730a0e068329ed5b6": { "balance": "1880000000000000000000" }, "8c50aa2a9212bcde56418ae261f0b35e7a9dbb82": { "balance": "400000000000000000000" }, "1953313e2ad746239cb2270f48af34d8bb9c4465": { "balance": "2000000000000000000000" }, "a15025f595acdbf3110f77c5bf24477e6548f9e8": { "balance": "2000000000000000000000" }, "53af32c22fef99803f178cf90b802fb571c61cb9": { "balance": "3880000000000000000000" }, "d0a8abd80a199b54b08b65f01d209c27fef0115b": { "balance": "6525979000000000000000" }, "2b68306ba7f8daaf73f4c644ef7d2743c0f26856": { "balance": "864800000000000000000" }, "96924191b7df655b3319dc6d6137f481a73a0ff3": { "balance": "4020000000000000000000" }, "6fa72015fa78696efd9a86174f7f1f21019286b1": { "balance": "1337000000000000000000" }, "0b119df99c6b8de58a1e2c3f297a6744bf552277": { "balance": "2000000000000000000000" }, "61733947fab820dbd351efd67855ea0e881373a0": { "balance": "20000000000000000000" }, "8ae6f80b70e1f23c91fbd5a966b0e499d95df832": { "balance": "197000000000000000000" }, "01a7d9fa7d0eb1185c67e54da83c2e75db69e39f": { "balance": "7623900000000000000000" }, "9932ef1c85b75a9b2a80057d508734c51085becc": { "balance": "50170000000000000000" }, "aefcfe88c826ccf131d54eb4ea9eb80e61e1ee25": { "balance": "340000000000000000000" }, "c21fa6643a1f14c02996ad7144b75926e87ecb4b": { "balance": "20000000000000000000000" }, "97d9e46a7604d7b5a4ea4ee61a42b3d2350fc3ed": { "balance": "2000000000000000000000" }, "3cafaf5e62505615068af8eb22a13ad8a9e55070": { "balance": "1999600000000000000000" }, "22f2dcff5ad78c3eb6850b5cb951127b659522e6": { "balance": "13700000000000000000" }, "aaad1baade5af04e2b17439e935987bf8c2bb4b9": { "balance": "2000000000000000000000" }, "298887bab57c5ba4f0615229d7525fa113b7ea89": { "balance": "40000000000000000000" }, "7539333046deb1ef3c4daf50619993f444e1de68": { "balance": "1182000000000000000000" }, "9752d14f5e1093f071711c1adbc4e3eb1e5c57f3": { "balance": "2000000000000000000000" }, "ed641e06368fb0efaa1703e01fe48f4a685309eb": { "balance": "200000000000000000000" }, "d0ee4d02cf24382c3090d3e99560de3678735cdf": { "balance": "2400000000000000000000" }, "47e25df8822538a8596b28c637896b4d143c351d": { "balance": "80500000000000000000000" }, "559706c332d20779c45f8a6d046a699159b74921": { "balance": "380123000000000000000" }, "3a4da78dce05aeb87de9aead9185726da1926798": { "balance": "200000000000000000000" }, "3041445a33ba158741160d9c344eb88e5c306f94": { "balance": "60000000000000000000" }, "08d4311c9c1bbaf87fabe1a1d01463828d5d98ce": { "balance": "90000000000000000000000" }, "6bd3e59f239fafe4776bb9bddd6bee83ba5d9d9f": { "balance": "1000000000000000000000" }, "29eaae82761762f4d2db53a9c68b0f6b0b6d4e66": { "balance": "2000000000000000000000" }, "0b7d339371e5be6727e6e331b5821fa24bdb9d5a": { "balance": "857738000000000000000" }, "4714cfa4f46bd6bd70737d75878197e08f88e631": { "balance": "11792000000000000000000" }, "ad92ca066edb7c711dfc5b166192d1edf8e77185": { "balance": "36000000000000000000000" }, "f97b56ebd5b77abc9fbacbabd494b9d2c221cd03": { "balance": "1970000000000000000000" }, "591bef3171d1c5957717a4e98d17eb142c214e56": { "balance": "20000000000000000000000" }, "899b3c249f0c4b81df75d212004d3d6d952fd223": { "balance": "2000000000000000000000" }, "a819d2ece122e028c8e8a04a064d02b9029b08b9": { "balance": "1000000000000000000000" }, "e341642d40d2afce2e9107c67079ac7a2660086c": { "balance": "400000000000000000000" }, "0329188f080657ab3a2afa522467178279832085": { "balance": "216700000000000000000" }, "03317826d1f70aa4bddfa09be0c4105552d2358b": { "balance": "38800000000000000000" }, "3ac9dc7a436ae98fd01c7a9621aa8e9d0b8b531d": { "balance": "1790000000000000000000" }, "93c88e2d88621e30f58a9586bed4098999eb67dd": { "balance": "31200000000000000000000" }, "cd1e66ed539dd92fc40bbaa1fa16de8c02c14d45": { "balance": "230000000000000000000" }, "e6c81ffcecb47ecdc55c0b71e4855f3e5e97fc1e": { "balance": "334250000000000000000" }, "50f8fa4bb9e2677c990a4ee8ce70dd1523251e4f": { "balance": "26030000000000000000" }, "4f64a85e8e9a40498c0c75fceb0337fb49083e5e": { "balance": "1000000000000000000000" }, "4b29437c97b4a844be71cca3b648d4ca0fdd9ba4": { "balance": "150200000000000000000" }, "1eee6cbee4fe96ad615a9cf5857a647940df8c78": { "balance": "19400000000000000000" }, "29f0edc60338e7112085a1d114da8c42ce8f55d6": { "balance": "2958000000000000000000" }, "23b1c4917fbd93ee3d48389306957384a5496cbf": { "balance": "4000086000000000000000" }, "1767525c5f5a22ed80e9d4d7710f0362d29efa33": { "balance": "400000000000000000000" }, "3064899a963c4779cbf613cd6980846af1e6ec65": { "balance": "6999908000000000000000" }, "68531f4dda808f5320767a03113428ca0ce2f389": { "balance": "19400000000000000000" }, "1db9ac9a9eaeec0a523757050c71f47278c72d50": { "balance": "1337000000000000000000" }, "7592c69d067b51b6cc639d1164d5578c60d2d244": { "balance": "20000000000000000000" }, "cf3fbfa1fd32d7a6e0e6f8ef4eab57be34025c4c": { "balance": "1063120000000000000000" }, "8efec058cc546157766a632775404a334aaada87": { "balance": "1999000000000000000000" }, "faf5f0b7b6d558f5090d9ea1fb2d42259c586078": { "balance": "6401000000000000000000" }, "19ecf2abf40c9e857b252fe1dbfd3d4c5d8f816e": { "balance": "2000000000000000000000" }, "6e8a26689f7a2fdefd009cbaaa5310253450daba": { "balance": "2049982000000000000000" }, "e2f40d358f5e3fe7463ec70480bd2ed398a7063b": { "balance": "20000000000000000000" }, "fa19d6f7a50f4f079893d167bf14e21d0073d196": { "balance": "530000000000000000000" }, "3e2ca0d234baf607ad466a1b85f4a6488ef00ae7": { "balance": "89505000000000000000" }, "f8a49ca2390c1f6d5c0e62513b079571743f7cc6": { "balance": "3000000000000000000000" }, "5d3f3b1f7130b0bb21a0fd32396239179a25657f": { "balance": "62474000000000000000000" }, "f332c0f3e05a27d9126fd0b641a8c2d4060608fd": { "balance": "5001041000000000000000" }, "e304a32f05a83762744a9542976ff9b723fa31ea": { "balance": "1576256000000000000000" }, "f768f321fd6433d96b4f354d3cc1652c1732f57f": { "balance": "10000000000000000000000" }, "147af46ae9ccd18bb35ca01b353b51990e49dce1": { "balance": "4000000000000000000000" }, "21eae6feffa9fbf4cd874f4739ace530ccbe5937": { "balance": "5000000000000000000000" }, "6994fb3231d7e41d491a9d68d1fa4cae2cc15960": { "balance": "4000000000000000000000" }, "51126446ab3d8032557e8eba65597d75fadc815c": { "balance": "322000000000000000000" }, "24daaaddf7b06bbcea9b80590085a88567682b4e": { "balance": "319008000000000000000" }, "cd020f8edfcf524798a9b73a640334bbf72f80a5": { "balance": "133700000000000000000" }, "56febf9e1003af15b1bd4907ec089a4a1b91d268": { "balance": "200000000000000000000" }, "3c79c863c3d372b3ff0c6f452734a7f97042d706": { "balance": "176000000000000000000" }, "e1203eb3a723e99c2220117ca6afeb66fa424f61": { "balance": "9461996000000000000000" }, "18fb09188f27f1038e654031924f628a2106703d": { "balance": "2000000000000000000000" }, "2eba0c6ee5a1145c1c573984963a605d880a7a20": { "balance": "500000000000000000000" }, "4cefbe2398e47d52e78db4334c8b697675f193ae": { "balance": "4011000000000000000000" }, "c02471e3fc2ea0532615a7571d493289c13c36ef": { "balance": "20000000000000000000" }, "ba469aa5c386b19295d4a1b5473b540353390c85": { "balance": "2000000000000000000000" }, "7b11673cc019626b290cbdce26046f7e6d141e21": { "balance": "500000000000000000000" }, "26784ade91c8a83a8e39658c8d8277413ccc9954": { "balance": "6000000000000000000000" }, "57d3df804f2beee6ef53ab94cb3ee9cf524a18d3": { "balance": "393606000000000000000" }, "ccae0d3d852a7da3860f0636154c0a6ca31628d4": { "balance": "106560000000000000000" }, "bfe3a1fc6e24c8f7b3250560991f93cba2cf8047": { "balance": "80000000000000000000000" }, "724ce858857ec5481c86bd906e83a04882e5821d": { "balance": "3000000000000000000000" }, "fb37cf6b4f81a9e222fba22e9bd24b5098b733cf": { "balance": "38800000000000000000" }, "9b22a80d5c7b3374a05b446081f97d0a34079e7f": { "balance": "3000000000000000000000" }, "0a29a8a4d5fd950075ffb34d77afeb2d823bd689": { "balance": "200000000000000000000" }, "d01af9134faf5257174e8b79186f42ee354e642d": { "balance": "1000000000000000000000" }, "7f1619988f3715e94ff1d253262dc5581db3de1c": { "balance": "900000000000000000000" }, "6f137a71a6f197df2cbbf010dcbd3c444ef5c925": { "balance": "2000000000000000000000" }, "11efb8a20451161b644a8ccebbc1d343a3bbcb52": { "balance": "3200000000000000000000" }, "46504e6a215ac83bccf956befc82ab5a679371c8": { "balance": "518898000000000000000" }, "b523fff9749871b35388438837f7e6e0dea9cb6b": { "balance": "2000000000000000000000" }, "c5c6a4998a33feb764437a8be929a73ba34a0764": { "balance": "50000000000000000000000" }, "3cd7f7c7c2353780cde081eeec45822b25f2860c": { "balance": "200000000000000000000" }, "b3050beff9de33c80e1fa15225e28f2c413ae313": { "balance": "700000000000000000000" }, "59268171b833e0aa13c54b52ccc0422e4fa03aeb": { "balance": "3000000000000000000000" }, "7169724ee72271c534cad6420fb04ee644cb86fe": { "balance": "410164000000000000000" }, "6e6d5bbbb9053b89d744a27316c2a7b8c09b547d": { "balance": "909831000000000000000" }, "3f3f46b75cabe37bfacc8760281f4341ca7f463d": { "balance": "602709000000000000000" }, "7a33834e8583733e2d52aead589bd1affb1dd256": { "balance": "1000000000000000000000" }, "e94ded99dcb572b9bb1dcba32f6dee91e057984e": { "balance": "394000000000000000000" }, "19336a236ded755872411f2e0491d83e3e00159e": { "balance": "940000000000000000000" }, "63ac545c991243fa18aec41d4f6f598e555015dc": { "balance": "600000000000000000000" }, "cfee05c69d1f29e7714684c88de5a16098e91399": { "balance": "1970000000000000000000" }, "77be6b64d7c733a436adec5e14bf9ad7402b1b46": { "balance": "1000000000000000000000" }, "233bdddd5da94852f4ade8d212885682d9076bc6": { "balance": "4000000000000000000000" }, "952c57d2fb195107d4cd5ca300774119dfad2f78": { "balance": "2000000000000000000000" }, "e237baa4dbc9926e32a3d85d1264402d54db012f": { "balance": "2000000000000000000000" }, "aa91237e740d25a92f7fa146faa18ce56dc6e1f3": { "balance": "925000000000000000000" }, "2339e9492870afea2537f389ac2f838302a33c06": { "balance": "2000000000000000000000" }, "1d45586eb803ca2190650bf748a2b174312bb507": { "balance": "1400000000000000000000" }, "c61446b754c24e3b1642d9e51765b4d3e46b34b6": { "balance": "2000000000000000000000" }, "ac28b5edea05b76f8c5f97084541277c96696a4c": { "balance": "1000000000000000000000" }, "1a1c9a26e0e02418a5cf687da75a275c622c9440": { "balance": "5000000000000000000000" }, "299368609042a858d1ecdf1fc0ada5eaceca29cf": { "balance": "2000000000000000000000" }, "095f5a51d06f6340d80b6d29ea2e88118ad730fe": { "balance": "2000200000000000000000" }, "751a2ca34e7187c163d28e3618db28b13c196d26": { "balance": "500000000000000000000" }, "75b0e9c942a4f0f6f86d3f95ff998022fa67963b": { "balance": "1490000000000000000000" }, "d1b37f03cb107424e9c4dd575ccd4f4cee57e6cd": { "balance": "2000000000000000000000" }, "7f993ddb7e02c282b898f6155f680ef5b9aff907": { "balance": "20000000000000000000000" }, "a3d583a7b65b23f60b7905f3e4aa62aac87f4227": { "balance": "1046779000000000000000" }, "526bb533b76e20c8ee1ebf123f1e9ff4148e40be": { "balance": "197000000000000000000" }, "2160b4c02cac0a81de9108de434590a8bfe68735": { "balance": "1970000000000000000000" }, "010007394b8b7565a1658af88ce463499135d6b7": { "balance": "100000000000000000000" }, "64457fa33b0832506c4f7d1180dce48f46f3e0ff": { "balance": "2000000000000000000000" }, "b51e558eb5512fbcfa81f8d0bd938c79ebb5242b": { "balance": "715000000000000000000" }, "94f13f9f0836a3ee2437a84922d2984dc0f7d53b": { "balance": "2999916000000000000000" }, "6bd457ade051795df3f2465c3839aed3c5dee978": { "balance": "999925000000000000000" }, "f3dbcf135acb9dee1a489c593c024f03c2bbaece": { "balance": "2000000000000000000000" }, "61b902c5a673885826820d1fe14549e4865fbdc2": { "balance": "334703000000000000000" }, "2acc9c1a32240b4d5b2f777a2ea052b42fc1271c": { "balance": "41764000000000000000000" }, "6ddfef639155daab0a5cb4953aa8c5afaa880453": { "balance": "1820000000000000000000" }, "96ff6f509968f36cb42cba48db32f21f5676abf8": { "balance": "1970000000000000000000" }, "b4c8170f7b2ab536d1d9a25bdd203ae1288dc3d5": { "balance": "200000000000000000000" }, "78d4f8c71c1e68a69a98f52fcb45da8af56ea1a0": { "balance": "2000000000000000000000" }, "dec99e972fca7177508c8e1a47ac22d768acab7c": { "balance": "2000000000000000000000" }, "a07aa16d74aee8a9a3288d52db1551d593883297": { "balance": "600000000000000000000" }, "cf1169041c1745e45b172435a2fc99b49ace2b00": { "balance": "31960000000000000000" }, "526cb09ce3ada3672eec1deb46205be89a4b563e": { "balance": "2468000000000000000000" }, "ee6959de2b67967b71948c891ab00d8c8f38c7dc": { "balance": "118200000000000000000" }, "ca7ba3ff536c7e5f0e153800bd383db8312998e0": { "balance": "169600000000000000000" }, "1ed06ee51662a86c634588fb62dc43c8f27e7c17": { "balance": "200000000000000000000" }, "730447f97ce9b25f22ba1afb36df27f9586beb9b": { "balance": "820000000000000000000" }, "ae5c9bdad3c5c8a1220444aea5c229c1839f1d64": { "balance": "477500000000000000000" }, "a38306cb70baa8e49186bd68aa70a83d242f2907": { "balance": "2000000000000000000000" }, "71213fca313404204ecba87197741aa9dfe96338": { "balance": "60000000000000000000" }, "10e390ad2ba33d82b37388d09c4544c6b0225de5": { "balance": "200000000000000000000" }, "3b6e814f770748a7c3997806347605480a3fd509": { "balance": "2000000000000000000000" }, "fd452c3969ece3801c542020f1cdcaa1c71ed23d": { "balance": "100000000000000000000000" }, "e742b1e6069a8ffc3c4767235defb0d49cbed222": { "balance": "800000000000000000000" }, "d7225738dcf3578438f8e7c8b3837e42e04a262f": { "balance": "445860000000000000000" }, "cd0b0257e783a3d2c2e3ba9d6e79b75ef98024d4": { "balance": "2945500000000000000000" }, "e80e7fef18a5db15b01473f3ad6b78b2a2f8acd9": { "balance": "500000000000000000000" }, "261575e9cf59c8226fa7aaf91de86fb70f5ac3ae": { "balance": "300022000000000000000" }, "7e71171f2949fa0c3ac254254b1f0440e5e6a038": { "balance": "40000000000000000000" }, "96ea6ac89a2bac95347b51dba63d8bd5ebdedce1": { "balance": "2000000000000000000000" }, "e6ec5cf0c49b9c317e1e706315ef9eb7c0bf11a7": { "balance": "17200000000000000000000" }, "2b99b42e4f42619ee36baa7e4af2d65eacfcba35": { "balance": "40000000000000000000000" }, "c6e4cc0c7283fc1c85bc4813effaaf72b49823c0": { "balance": "276926000000000000000" }, "dbc1ce0e49b1a705d22e2037aec878ee0d75c703": { "balance": "250000000000000000000" }, "806f44bdeb688037015e84ff218049e382332a33": { "balance": "1999000000000000000000" }, "1a3a330e4fcb69dbef5e6901783bf50fd1c15342": { "balance": "4200000000000000000000" }, "d2a84f75675c62d80c88756c428eee2bcb185421": { "balance": "1200000000000000000000" }, "c593b546b7698710a205ad468b2c13152219a342": { "balance": "1550000000000000000000" }, "3f627a769e6a950eb87017a7cd9ca20871136831": { "balance": "13790000000000000000000" }, "f2d5763ce073127e2cedde6faba786c73ca94141": { "balance": "7900000000000000000000" }, "162110f29eac5f7d02b543d8dcd5bb59a5e33b73": { "balance": "2000000000000000000000" }, "59473cd300fffae240f5785626c65dfec792b9af": { "balance": "20000000000000000000" }, "4dcd11815818ae29b85d01367349a8a7fb12d06b": { "balance": "7900000000000000000000" }, "9329ffdc268babde8874b366406c81445b9b2d35": { "balance": "422415000000000000000" }, "0ab4281ebb318590abb89a81df07fa3af904258a": { "balance": "500000000000000000000" }, "875061ee12e820041a01942cb0e65bb427b00060": { "balance": "2800000000000000000000" }, "c9b698e898d20d4d4f408e4e4d061922aa856307": { "balance": "40000000000000000000" }, "ca49a5f58adbefae23ee59eea241cf0482622eaa": { "balance": "1430000000000000000000" }, "196e85df7e732b4a8f0ed03623f4db9db0b8fa31": { "balance": "21165000000000000000" }, "4c760cd9e195ee4f2d6bce2500ff96da7c43ee91": { "balance": "60000000000000000000000" }, "024a098ae702bef5406c9c22b78bd4eb2cc7a293": { "balance": "4000000000000000000000" }, "9d81aea69aed6ad07089d61445348c17f34bfc5b": { "balance": "300000000000000000000" }, "76ab87dd5a05ad839a4e2fc8c85aa6ba05641730": { "balance": "2000000000000000000000" }, "c6e2f5af979a03fd723a1b6efa728318cf9c1800": { "balance": "668500000000000000000" }, "5db69fe93e6fb6fbd450966b97238b110ad8279a": { "balance": "40000000000000000000000" }, "a4259f8345f7e3a8b72b0fec2cf75e321fda4dc2": { "balance": "1910000000000000000000" }, "095030e4b82692dcf8b8d0912494b9b378ec9328": { "balance": "1340000000000000000000" }, "4b470f7ba030bc7cfcf338d4bf0432a91e2ea5ff": { "balance": "2000000000000000000000" }, "99c9f93e45fe3c1418c353e4c5ac3894eef8121e": { "balance": "101870000000000000000" }, "ffac3db879a6c7158e8dec603b407463ba0d31cf": { "balance": "1970000000000000000000" }, "ac8e87ddda5e78fcbcb9fa7fc3ce038f9f7d2e34": { "balance": "2000000000000000000000" }, "7a0589b143a8e5e107c9ac66a9f9f8597ab3e7ab": { "balance": "1510990000000000000000" }, "b7d581fe0af1ec383f3b3c416783f385146a7612": { "balance": "20000000000000000000000" }, "bb3fc0a29c034d710812dcc775c8cab9d28d6975": { "balance": "1066806000000000000000" }, "2c603ff0fe93616c43573ef279bfea40888d6ae7": { "balance": "4740000000000000000000" }, "15f2b7b16432ee50a5f55b41232f6334ed58bdc0": { "balance": "400000000000000000000" }, "7f3d7203c8a447f7bf36d88ae9b6062a5eee78ae": { "balance": "6000000000000000000000" }, "f067e1f1d683556a4cc4fd0c0313239f32c4cfd8": { "balance": "1000000000000000000000" }, "52738c90d860e04cb12f498d96fdb5bf36fc340e": { "balance": "30000000000000000000" }, "45781bbe7714a1c8f73b1c747921df4f84278b70": { "balance": "2000000000000000000000" }, "4a97e8fcf4635ea7fc5e96ee51752ec388716b60": { "balance": "546000000000000000000" }, "54939ff08921b467cf2946751d856378296c63ed": { "balance": "1000000000000000000000" }, "6485470e61db110aebdbafd536769e3c599cc908": { "balance": "600000000000000000000" }, "e20d1bcb71286dc7128a9fc7c6ed7f733892eef5": { "balance": "1003400000000000000000" }, "d6eea898d4ae2b718027a19ce9a5eb7300abe3ca": { "balance": "27475000000000000000" }, "014974a1f46bf204944a853111e52f1602617def": { "balance": "2000000000000000000000" }, "6aa5732f3b86fb8c81efbe6b5b47b563730b06c8": { "balance": "1000000000000000000000" }, "6107d71dd6d0eefb11d4c916404cb98c753e117d": { "balance": "2000000000000000000000" }, "dd7bcda65924aaa49b80984ae173750258b92847": { "balance": "10000000000000000000000" }, "4e7b54474d01fefd388dfcd53b9f662624418a05": { "balance": "8000000000000000000000" }, "24fc73d20793098e09ddab5798506224fa1e1850": { "balance": "200000000000000000000" }, "2b8488bd2d3c197a3d26151815b5a798d27168dc": { "balance": "6680000000000000000000" }, "949131f28943925cfc97d41e0cea0b262973a730": { "balance": "2800000000000000000000" }, "60b8d6b73b79534fb08bb8cbcefac7f393c57bfe": { "balance": "1760000000000000000000" }, "d6acc220ba2e51dfcf21d443361eea765cbd35d8": { "balance": "20000000000000000000" }, "c4c6cb723dd7afa7eb535615e53f3cef14f18118": { "balance": "1999999000000000000000" }, "4c9a862ad115d6c8274ed0b944bdd6a5500510a7": { "balance": "100000000000000000000" }, "85732c065cbd64119941aed430ac59670b6c51c4": { "balance": "731345000000000000000" }, "0126e12ebc17035f35c0e9d11dd148393c405d7a": { "balance": "1999600000000000000000" }, "472048cc609aeb242165eaaa8705850cf3125de0": { "balance": "1000000000000000000000" }, "d2edd1ddd6d86dc005baeb541d22b640d5c7cae5": { "balance": "20000000000000000000" }, "4549b15979255f7e65e99b0d5604db98dfcac8bf": { "balance": "4000000000000000000000" }, "c6c7c191379897dd9c9d9a33839c4a5f62c0890d": { "balance": "4000085000000000000000" }, "d367009ab658263b62c2333a1c9e4140498e1389": { "balance": "2000000000000000000000" }, "143f5f1658d9e578f4f3d95f80c0b1bd3933cbda": { "balance": "1490000000000000000000" }, "1a09fdc2c7a20e23574b97c69e93deba67d37220": { "balance": "1998000000000000000000" }, "ac8b509aefea1dbfaf2bb33500d6570b6fd96d51": { "balance": "1820000000000000000000" }, "16ffac84032940f0121a09668b858a7e79ffa3bb": { "balance": "3879210000000000000000" }, "f338459f32a159b23db30ac335769ab2351aa63c": { "balance": "30000000000000000000000" }, "d82251456dc1380f8f5692f962828640ab9f2a03": { "balance": "4879980000000000000000" }, "47f4696bd462b20da09fb83ed2039818d77625b3": { "balance": "149000000000000000000" }, "3dde8b15b3ccbaa5780112c3d674f313bba68026": { "balance": "1773000000000000000000" }, "f70d637a845c06db6cdc91e6371ce7c4388a628e": { "balance": "20000000000000000000" }, "68295e8ea5afd9093fc0a465d157922b5d2ae234": { "balance": "19982000000000000000" }, "614e8bef3dd2c59b59a4145674401018351884ea": { "balance": "20000000000000000000" }, "4737d042dc6ae73ec73ae2517acea2fdd96487c5": { "balance": "1000000000000000000000" }, "cec6fc65853f9cce5f8e844676362e1579015f02": { "balance": "2000000000000000000000" }, "ae47e2609cfafe369d66d415d939de05081a9872": { "balance": "27060000000000000000000" }, "09a928d528ec1b3e25ffc83e218c1e0afe8928c7": { "balance": "18200000000000000000" }, "9b444fd337e5d75293adcfff70e1ea01db023222": { "balance": "100000000000000000000" }, "168bdec818eafc6d2992e5ef54aa0e1601e3c561": { "balance": "1000110000000000000000" }, "353dbec42f92b50f975129b93c4c997375f09073": { "balance": "1999000000000000000000" }, "6fcc2c732bdd934af6ccd16846fb26ef89b2aa9b": { "balance": "10001242000000000000000" }, "6f2576da4de283bbe8e3ee69ddd66e5e711db3f5": { "balance": "1260800000000000000000" }, "3a3dd104cd7eb04f21932fd433ea7affd39369f5": { "balance": "357500000000000000000" }, "d44f4ac5fad76bdc1537a3b3af6472319b410d9d": { "balance": "1600000000000000000000" }, "3d9d6be57ff83e065985664f12564483f2e600b2": { "balance": "2041600000000000000000" }, "88f1045f19f2d3191816b1df18bb6e1435ad1b38": { "balance": "240000000000000000000" }, "ddab75fb2ff9fecb88f89476688e2b00e367ebf9": { "balance": "19400000000000000000000" }, "092e815558402d67f90d6bfe6da0b2fffa91455a": { "balance": "60000000000000000000" }, "a7024cfd742c1ec13c01fea18d3042e65f1d5dee": { "balance": "11272229000000000000000" }, "7f46bb25460dd7dae4211ca7f15ad312fc7dc75c": { "balance": "6685000000000000000000" }, "93f18cd2526040761488c513174d1e7963768b2c": { "balance": "2416500000000000000000" }, "352f25babf4a690673e35195efa8f79d05848aad": { "balance": "66800000000000000000000" }, "f7b151cc5e571c17c76539dbe9964cbb6fe5de79": { "balance": "2148000000000000000000" }, "ff3eee57c34d6dae970d8b311117c53586cd3502": { "balance": "1700000000000000000000" }, "ae6f0c73fdd77c489727512174d9b50296611c4c": { "balance": "6000000000000000000000" }, "7819b0458e314e2b53bfe00c38495fd4b9fdf8d6": { "balance": "20000000000000000000" }, "7fdba031c78f9c096d62d05a369eeab0bccc55e5": { "balance": "2800000000000000000000" }, "735e328666ed5637142b3306b77ccc5460e72c3d": { "balance": "1968682000000000000000" }, "0bfbb6925dc75e52cf2684224bbe0550fea685d3": { "balance": "1970000000000000000000" }, "6be16313643ebc91ff9bb1a2e116b854ea933a45": { "balance": "500000000000000000000" }, "d6acffd0bfd99c382e7bd56ff0e6144a9e52b08e": { "balance": "160000000000000000000" }, "276a006e3028ecd44cdb62ba0a77ce94ebd9f10f": { "balance": "1800000000000000000000" }, "10711c3dda32317885f0a2fd8ae92e82069b0d0b": { "balance": "4000000000000000000000" }, "43cb9652818c6f4d6796b0e89409306c79db6349": { "balance": "2000000000000000000000" }, "7109dd011d15f3122d9d3a27588c10d77744508b": { "balance": "2000000000000000000000" }, "3497dd66fd118071a78c2cb36e40b6651cc82598": { "balance": "109600000000000000000" }, "9bf672d979b36652fc5282547a6a6bc212ae4368": { "balance": "656000000000000000000" }, "eaed16eaf5daab5bf0295e5e077f59fb8255900b": { "balance": "4000000000000000000000" }, "7ac58f6ffc4f8107ae6e30378e4e9f99c57fbb24": { "balance": "40000000000000000000" }, "45a570dcc2090c86a6b3ea29a60863dde41f13b5": { "balance": "232500000000000000000" }, "433a3b68e56b0df1862b90586bbd39c840ff1936": { "balance": "2000000000000000000000" }, "e8eaf12944092dc3599b3953fa7cb1c9761cc246": { "balance": "1800000000000000000000" }, "ec11362cec810985d0ebbd7b73451444985b369f": { "balance": "30000047000000000000000" }, "78e83f80b3678c7a0a4e3e8c84dccde064426277": { "balance": "1790000000000000000000" }, "0cc67f8273e1bae0867fd42e8b8193d72679dbf8": { "balance": "500000000000000000000" }, "c70d856d621ec145303c0a6400cd17bbd6f5eaf7": { "balance": "20000000000000000000" }, "f468906e7edf664ab0d8be3d83eb7ab3f7ffdc78": { "balance": "1700000000000000000000" }, "3c286cfb30146e5fd790c2c8541552578de334d8": { "balance": "10203000000000000000000" }, "c401c427cccff10decb864202f36f5808322a0a8": { "balance": "3329300000000000000000" }, "afd019ff36a09155346b69974815a1c912c90aa4": { "balance": "2000000000000000000000" }, "96fe59c3dbb3aa7cc8cb62480c65e56e6204a7e2": { "balance": "20000000000000000000000" }, "a47779d8bc1c7bce0f011ccb39ef68b854f8de8f": { "balance": "2000000000000000000000" }, "58c650ced40bb65641b8e8a924a039def46854df": { "balance": "18500000000000000000" }, "86f4f40ad984fbb80933ae626e0e42f9333fdd41": { "balance": "1000000000000000000000" }, "b22d5055d9623135961e6abd273c90deea16a3e7": { "balance": "1400000000000000000000" }, "ee3564f5f1ba0f94ec7bac164bddbf31c6888b55": { "balance": "100000000000000000000" }, "cf26b47bd034bc508e6c4bcfd6c7d30034925761": { "balance": "1800000000000000000000" }, "e87dbac636a37721df54b08a32ef4959b5e4ff82": { "balance": "2000000000000000000000" }, "3bf86ed8a3153ec933786a02ac090301855e576b": { "balance": "450000000000000000000000" }, "cfd2728dfb8bdbf3bf73598a6e13eaf43052ea2b": { "balance": "170000000000000000000" }, "85b16f0b8b34dff3804f69e2168a4f7b24d1042b": { "balance": "317000000000000000000" }, "84db1459bb00812ea67ecb3dc189b72187d9c501": { "balance": "148851000000000000000" }, "8c3a9ee71f729f236cba3867b4d79d8ceee25dbc": { "balance": "100000000000000000000" }, "e677c31fd9cb720075dca49f1abccd59ec33f734": { "balance": "7800000000000000000000" }, "8889448316ccf14ed86df8e2f478dc63c4338340": { "balance": "15200000000000000000" }, "b279c7d355c2880392aad1aa21ee867c3b3507df": { "balance": "1261000000000000000000" }, "12b5e28945bb2969f9c64c63cc05b6f1f8d6f4d5": { "balance": "7722162000000000000000" }, "8d2303341e1e1eb5e8189bde03f73a60a2a54861": { "balance": "100000000000000000000" }, "94d81074db5ae197d2bb1373ab80a87d121c4bd3": { "balance": "9400000000000000000000" }, "752c9febf42f66c4787bfa7eb17cf5333bba5070": { "balance": "1966448000000000000000" }, "16816aac0ede0d2d3cd442da79e063880f0f1d67": { "balance": "2000000000000000000000" }, "daac91c1e859d5e57ed3084b50200f9766e2c52b": { "balance": "400000000000000000000" }, "32c2fde2b6aabb80e5aea2b949a217f3cb092283": { "balance": "5614827000000000000000" }, "cdab46a5902080646fbf954204204ae88404822b": { "balance": "544942000000000000000" }, "fdf42343019b0b0c6bf260b173afab7e45b9d621": { "balance": "1999944000000000000000" }, "791f6040b4e3e50dcf3553f182cd97a90630b75d": { "balance": "4000000000000000000000" }, "4b762166dd1118e84369f804c75f9cd657bf730c": { "balance": "500000000000000000000" }, "a76d3f156251b72c0ccf4b47a3393cbd6f49a9c5": { "balance": "1337000000000000000000" }, "c5eb42295e9cadeaf2af12dede8a8d53c579c469": { "balance": "3820000000000000000000" }, "db9371b30c4c844e59e03e924be606a938d1d310": { "balance": "2000000000000000000000" }, "2cd39334ac7eac797257abe3736195f5b4b5ce0f": { "balance": "99964000000000000000" }, "ad44357e017e244f476931c7b8189efee80a5d0a": { "balance": "300000000000000000000" }, "4ca7b717d9bc8793b04e051a8d23e1640f5ba5e3": { "balance": "1248980000000000000000" }, "73e4a2b60cf48e8baf2b777e175a5b1e4d0c2d8f": { "balance": "100000000000000000000" }, "5a1d2d2d1d520304b6208849570437eb3091bb9f": { "balance": "1970000000000000000000" }, "53047dc8ac9083d90672e8b3473c100ccd278323": { "balance": "40000000000000000000" }, "26fe174cbf526650e0cd009bd6126502ce8e684d": { "balance": "11640000000000000000000" }, "e2df23f6ea04becf4ab701748dc0963184555cdb": { "balance": "2000000000000000000000" }, "c1170dbaadb3dee6198ea544baec93251860fda5": { "balance": "1200000000000000000000" }, "8bbeacfc29cfe93402db3c41d99ab759662e73ec": { "balance": "2000000000000000000000" }, "165305b787322e25dc6ad0cefe6c6f334678d569": { "balance": "2000000000000000000000" }, "095457f8ef8e2bdc362196b9a9125da09c67e3ab": { "balance": "200000000000000000000" }, "702802f36d00250fab53adbcd696f0176f638a49": { "balance": "2000000000000000000000" }, "489334c2b695c8ee0794bd864217fb9fd8f8b135": { "balance": "18200000000000000000" }, "fa8cf4e627698c5d5788abb7880417e750231399": { "balance": "4244640000000000000000" }, "3329eb3baf4345d600ced40e6e9975656f113742": { "balance": "4999711000000000000000" }, "b4dd5499daeb2507fb2de12297731d4c72b16bb0": { "balance": "20000000000000000000" }, "88c2516a7cdb09a6276d7297d30f5a4db1e84b86": { "balance": "4000000000000000000000" }, "612ced8dc0dc9e899ee46f7962333315f3f55e44": { "balance": "338830000000000000000" }, "d71e43a45177ad51cbe0f72184a5cb503917285a": { "balance": "200000000000000000000" }, "2fb566c94bbba4e3cb67cdda7d5fad7131539102": { "balance": "2000000000000000000000" }, "03be5b4629aefbbcab9de26d39576cb7f691d764": { "balance": "200550000000000000000" }, "025367960304beee34591118e9ac2d1358d8021a": { "balance": "2000000000000000000000" }, "a5d5b8b62d002def92413710d13b6ff8d4fc7dd3": { "balance": "400000000000000000000" }, "df3b72c5bd71d4814e88a62321a93d4011e3578b": { "balance": "4000000000000000000000" }, "3588895ac9fbafec012092dc05c0c302d90740fa": { "balance": "3000000000000000000000" }, "6021e85a8814fce1e82a41abd1d3b2dad2faefe0": { "balance": "2000000000000000000000" }, "17ee9f54d4ddc84d670eff11e54a659fd72f4455": { "balance": "16000000000000000000000" }, "873c6f70efb6b1d0f2bbc57eebcd70617c6ce662": { "balance": "1013478000000000000000" }, "1fcc7ce6a8485895a3199e16481f72e1f762defe": { "balance": "1000000000000000000000" }, "d0a7209b80cf60db62f57d0a5d7d521a69606655": { "balance": "160000000000000000000" }, "a514d00edd7108a6be839a638db2415418174196": { "balance": "30000000000000000000000" }, "046377f864b0143f282174a892a73d3ec8ec6132": { "balance": "191000000000000000000" }, "c126573d87b0175a5295f1dd07c575cf8cfa15f2": { "balance": "10000000000000000000000" }, "0e123d7da6d1e6fac2dcadd27029240bb39052fe": { "balance": "1000000000000000000000" }, "ad5a8d3c6478b69f657db3837a2575ef8e1df931": { "balance": "36990000000000000000" }, "db882eacedd0eff263511b312adbbc59c6b8b25b": { "balance": "9100000000000000000000" }, "0b43bd2391025581d8956ce42a072579cbbfcb14": { "balance": "18800000000000000000" }, "affea0473722cb7f0e0e86b9e11883bf428d8d54": { "balance": "1940000000000000000000" }, "e32b1c4725a1875449e98f970eb3e54062d15800": { "balance": "200000000000000000000" }, "98f4af3af0aede5fafdc42a081ecc1f89e3ccf20": { "balance": "9400000000000000000000" }, "3b4768fd71e2db2cbe7fa050483c27b4eb931df3": { "balance": "2000000000000000000000" }, "d5f7c41e07729dfa6dfc64c4423160a22c609fd3": { "balance": "1790000000000000000000" }, "d944c8a69ff2ca1249690c1229c7192f36251062": { "balance": "1970000000000000000000" }, "5ae64e853ba0a51282cb8db52e41615e7c9f733f": { "balance": "2000000000000000000000" }, "b13f93af30e8d7667381b2b95bc1a699d5e3e129": { "balance": "420000000000000000000" }, "8a20e5b5cee7cd1f5515bace3bf4f77ffde5cc07": { "balance": "80000000000000000000" }, "2448596f91c09baa30bc96106a2d37b5705e5d28": { "balance": "2000000000000000000000" }, "ccca24d8c56d6e2c07db086ec07e585be267ac8d": { "balance": "200000000000000000000" }, "f67bb8e2118bbcd59027666eedf6943ec9f880a5": { "balance": "4000000000000000000000" }, "7ae659eb3bc46852fa86fac4e21c768d50388945": { "balance": "286000000000000000000" }, "467e0ed54f3b76ae0636176e07420815a021736e": { "balance": "2000000000000000000000" }, "a46cd237b63eea438c8e3b6585f679e4860832ac": { "balance": "1000000000000000000000" }, "6b760d4877e6a627c1c967bee451a8507ddddbab": { "balance": "910000000000000000000" }, "593044670faeff00a55b5ae051eb7be870b11694": { "balance": "133700000000000000000" }, "533c06928f19d0a956cc28866bf6c8d8f4191a94": { "balance": "292320000000000000000" }, "262dc1364ccf6df85c43268ee182554dae692e29": { "balance": "4927600000000000000000" }, "e4368bc1420b35efda95fafbc73090521916aa34": { "balance": "4000000000000000000000" }, "feb92d30bf01ff9a1901666c5573532bfa07eeec": { "balance": "1000000000000000000000" }, "ee25b9a7032679b113588ed52c137d1a053a1e94": { "balance": "199820000000000000000" }, "20134cbff88bfadc466b52eceaa79857891d831e": { "balance": "1000000000000000000000" }, "07b1a306cb4312df66482c2cae72d1e061400fcd": { "balance": "20000000000000000000000" }, "e791d585b89936b25d298f9d35f9f9edc25a2932": { "balance": "2000000000000000000000" }, "2e6933543d4f2cc00b5350bd8068ba9243d6beb0": { "balance": "2000000000000000000000" }, "dae0d33eaa341569fa9ff5982684854a4a328a6e": { "balance": "1000000000000000000000" }, "125cc5e4d56b2bcc2ee1c709fb9e68fb177440bd": { "balance": "2000000000000000000000" }, "ec99e95dece46ffffb175eb6400fbebb08ee9b95": { "balance": "100000000000000000000" }, "c538a0ff282aaa5f4b75cfb62c70037ee67d4fb5": { "balance": "2000000000000000000000" }, "60676d1fa21fca052297e24bf96389c5b12a70d7": { "balance": "241500000000000000000" }, "4b3dfbdb454be5279a3b8addfd0ed1cd37a9420d": { "balance": "2000000000000000000000" }, "cdb597299030183f6e2d238533f4642aa58754b6": { "balance": "400000000000000000000" }, "1ef2dcbfe0a500411d956eb8c8939c3d6cfe669d": { "balance": "776000000000000000000" }, "a7247c53d059eb7c9310f628d7fc6c6a0a773f08": { "balance": "500000000000000000000" }, "9799ca21dbcf69bfa1b3f72bac51b9e3ca587cf9": { "balance": "1700000000000000000000" }, "ddf95c1e99ce2f9f5698057c19d5c94027ee4a6e": { "balance": "6000000000000000000000" }, "83563bc364ed81a0c6da3b56ff49bbf267827a9c": { "balance": "17332000000000000000000" }, "a192698007cc11aa603d221d5feea076bcf7c30d": { "balance": "2000000000000000000000" }, "0134ff38155fabae94fd35c4ffe1d79de7ef9c59": { "balance": "985000000000000000000" }, "80977316944e5942e79b0e3abad38da746086519": { "balance": "38800000000000000000" }, "193d37ed347d1c2f4e35350d9a444bc57ca4db43": { "balance": "60000000000000000000" }, "009a6d7db326679b77c90391a7476d238f3ba33e": { "balance": "200200000000000000000" }, "337b3bdf86d713dbd07b5dbfcc022b7a7b1946ae": { "balance": "3980000000000000000000" }, "7de7fe419cc61f91f408d234cc80d5ca3d054d99": { "balance": "20000000000000000000" }, "f47bb134da30a812d003af8dccb888f44bbf5724": { "balance": "5190000000000000000000" }, "fd920f722682afb5af451b0544d4f41b3b9d5742": { "balance": "2330200000000000000000" }, "0a917f3b5cb0b883047fd9b6593dbcd557f453b9": { "balance": "1000000000000000000000" }, "ce9786d3712fa200e9f68537eeaa1a06a6f45a4b": { "balance": "1790000000000000000000" }, "9ab98d6dbb1eaae16d45a04568541ad3d8fe06cc": { "balance": "272451000000000000000" }, "0b7bb342f01bc9888e6a9af4a887cbf4c2dd2caf": { "balance": "16000000000000000000000" }, "4c0b1515dfced7a13e13ee12c0f523ae504f032b": { "balance": "50000000000000000000000" }, "ac2889b5966f0c7f9edb42895cb69d1c04f923a2": { "balance": "5000000000000000000000" }, "d008513b27604a89ba1763b6f84ce688b346945b": { "balance": "1000000000000000000000" }, "a4b09de6e713dc69546e76ef0acf40b94f0241e6": { "balance": "322656000000000000000" }, "b153f828dd076d4a7c1c2574bb2dee1a44a318a8": { "balance": "400000000000000000000" }, "02ade5db22f8b758ee1443626c64ec2f32aa0a15": { "balance": "20000000000000000000000" }, "0a0650861f785ed8e4bf1005c450bbd06eb48fb6": { "balance": "3066860000000000000000" }, "b75149e185f6e3927057739073a1822ae1cf0df2": { "balance": "4000086000000000000000" }, "84cb7da0502df45cf561817bbd2362f451be02da": { "balance": "1337000000000000000000" }, "c91bb562e42bd46130e2d3ae4652b6a4eb86bc0f": { "balance": "540000000000000000000" }, "b234035f7544463ce1e22bc553064684c513cd51": { "balance": "249750000000000000000" }, "e5e33800a1b2e96bde1031630a959aa007f26e51": { "balance": "1337000000000000000000" }, "ae5ce3355a7ba9b332760c0950c2bc45a85fa9a0": { "balance": "400000000000000000000" }, "e6f5eb649afb99599c414b27a9c9c855357fa878": { "balance": "2674000000000000000000" }, "7010be2df57bd0ab9ae8196cd50ab0c521aba9f9": { "balance": "1970000000000000000000" }, "ca4288014eddc5632f5facb5e38517a8f8bc5d98": { "balance": "340000000000000000000" }, "2784903f1d7c1b5cd901f8875d14a79b3cbe2a56": { "balance": "22388000000000000000000" }, "f8dce867f0a39c5bef9eeba609229efa02678b6c": { "balance": "2000000000000000000000" }, "e020e86362b487752836a6de0bc02cd8d89a8b6a": { "balance": "6000000000000000000000" }, "c4088c025f3e85013f5439fb3440a17301e544fe": { "balance": "2325000000000000000000" }, "befb448c0c5f683fb67ee570baf0db5686599751": { "balance": "1970000000000000000000" }, "2f187d5a704d5a338c5b2876a090dce964284e29": { "balance": "4000000000000000000000" }, "ec0e18a01dc4dc5daae567c3fa4c7f8f9b590205": { "balance": "315900000000000000000" }, "637f5869d6e4695f0eb9e27311c4878aff333380": { "balance": "1969212000000000000000" }, "d1100dd00fe2ddf18163ad964d0b69f1f2e9658a": { "balance": "5959598000000000000000" }, "17ef4acc1bf147e326749d10e677dcffd76f9e06": { "balance": "39980000000000000000000" }, "200dfc0b71e359b2b465440a36a6cdc352773007": { "balance": "1500000000000000000000" }, "efe0675da98a5dda70cd96196b87f4e726b43348": { "balance": "1164000000000000000000" }, "d5bd5e8455c130169357c471e3e681b7996a7276": { "balance": "841500000000000000000" }, "9c7b6dc5190fe2912963fcd579683ec7395116b0": { "balance": "776000000000000000000" }, "b105dd3d987cffd813e9c8500a80a1ad257d56c6": { "balance": "1999944000000000000000" }, "145250b06e4fa7cb2749422eb817bdda8b54de5f": { "balance": "219000000000000000000" }, "d96db33b7b5a950c3efa2dc31b10ba10a532ef87": { "balance": "2000000000000000000000" }, "af529bdb459cc185bee5a1c58bf7e8cce25c150d": { "balance": "197000000000000000000" }, "185546e8768d506873818ac9751c1f12116a3bef": { "balance": "200000000000000000000" }, "51d24bc3736f88dd63b7222026886630b6eb878d": { "balance": "2000000000000000000000" }, "69af28b0746cac0da17084b9398c5e36bb3a0df2": { "balance": "1004700000000000000000" }, "76f83ac3da30f7092628c7339f208bfc142cb1ee": { "balance": "2842600000000000000000" }, "00f463e137dcf625fbf3bca39eca98d2b968cf7f": { "balance": "5910000000000000000000" }, "2084fce505d97bebf1ad8c5ff6826fc645371fb2": { "balance": "30000000000000000000" }, "53a714f99fa00fef758e23a2e746326dad247ca7": { "balance": "1490000000000000000000" }, "0bf064428f83626722a7b5b26a9ab20421a7723e": { "balance": "133700000000000000000" }, "ac6f68e837cf1961cb14ab47446da168a16dde89": { "balance": "1337000000000000000000" }, "4b3c7388cc76da3d62d40067dabccd7ef0433d23": { "balance": "100076000000000000000" }, "deb9a49a43873020f0759185e20bbb4cf381bb8f": { "balance": "211628000000000000000" }, "5bf9f2226e5aeacf1d80ae0a59c6e38038bc8db5": { "balance": "6000000000000000000000" }, "9d0e7d92fb305853d798263bf15e97c72bf9d7e0": { "balance": "1000000000000000000000" }, "2b5c60e84535eeb4d580de127a12eb2677ccb392": { "balance": "20000000000000000000000" }, "d8d65420c18c2327cc5af97425f857e4a9fd51b3": { "balance": "1760000000000000000000" }, "30ec9392244a2108c987bc5cdde0ed9f837a817b": { "balance": "1560562000000000000000" }, "56a1d60d40f57f308eebf087dee3b37f1e7c2cba": { "balance": "1159600000000000000000" }, "a9a1cdc33bfd376f1c0d76fb6c84b6b4ac274d68": { "balance": "5000000000000000000000" }, "a67f38819565423aa85f3e3ab61bc763cbab89dd": { "balance": "2130000000000000000000" }, "62d5cc7117e18500ac2f9e3c26c86b0a94b0de15": { "balance": "105000000000000000000" }, "4970d3acf72b5b1f32a7003cf102c64ee0547941": { "balance": "140000000000000000000000" }, "76628150e2995b5b279fc83e0dd5f102a671dd1c": { "balance": "40000000000000000000000" }, "3d8f39881b9edfe91227c33fa4cdd91e678544b0": { "balance": "86111000000000000000" }, "ff0b7cb71da9d4c1ea6ecc28ebda504c63f82fd1": { "balance": "1043000000000000000000" }, "8d795c5f4a5689ad62da961671f028065286d554": { "balance": "2048000000000000000000" }, "be2346a27ff9b702044f500deff2e7ffe6824541": { "balance": "20000000000000000000" }, "0dbd417c372b8b0d01bcd944706bd32e60ae28d1": { "balance": "340000000000000000000" }, "467fbf41441600757fe15830c8cd5f4ffbbbd560": { "balance": "10000000000000000000000" }, "090cd67b60e81d54e7b5f6078f3e021ba65b9a1e": { "balance": "1000000000000000000000" }, "55a4cac0cb8b582d9fef38c5c9fff9bd53093d1f": { "balance": "1970000000000000000000" }, "3b7b4f53c45655f3dc5f017edc23b16f9bc536fa": { "balance": "100000000000000000000" }, "d508d39c70916f6abc4cc7f999f011f077105802": { "balance": "100470000000000000000" }, "037dd056e7fdbd641db5b6bea2a8780a83fae180": { "balance": "140000000000000000000" }, "660557bb43f4be3a1b8b85e7df7b3c5bcd548057": { "balance": "6000000000000000000000" }, "02089361a3fe7451fb1f87f01a2d866653dc0b07": { "balance": "39976000000000000000" }, "c4bec96308a20f90cab18399c493fd3d065abf45": { "balance": "14000000000000000000000" }, "cca07bb794571d4acf041dad87f0d1ef3185b319": { "balance": "2000000000000000000000" }, "f2d0e986d814ea13c8f466a0538c53dc922651f0": { "balance": "1380000000000000000000" }, "662cfa038fab37a01745a364e1b98127c503746d": { "balance": "3940000000000000000000" }, "3336c3ef6e8b50ee90e037b164b7a8ea5faac65d": { "balance": "272712000000000000000" }, "30e33358fc21c85006e40f32357dc8895940aaf0": { "balance": "1910000000000000000000" }, "41a9a404fc9f5bfee48ec265b12523338e29a8bf": { "balance": "388000000000000000000" }, "6af235d2bbe050e6291615b71ca5829658810142": { "balance": "3000000000000000000000" }, "fd5a63157f914fd398eab19c137dd9550bb7715c": { "balance": "100000000000000000000" }, "8a4314fb61cd938fc33e15e816b113f2ac89a7fb": { "balance": "432800000000000000000" }, "b216dc59e27c3d7279f5cd5bb2becfb2606e14d9": { "balance": "400000000000000000000" }, "f5a5459fcdd5e5b273830df88eea4cb77ddadfb9": { "balance": "74500000000000000000" }, "df31025f5649d2c6eea41ed3bdd3471a790f759a": { "balance": "20000000000000000000" }, "721f9d17e5a0e74205947aeb9bc6a7938961038f": { "balance": "51900000000000000000" }, "08d0864dc32f9acb36bf4ea447e8dd6726906a15": { "balance": "2000200000000000000000" }, "54575c3114751e3c631971da6a2a02fd3ffbfcc8": { "balance": "1940000000000000000000" }, "8f60895fbebbb5017fcbff3cdda397292bf25ba6": { "balance": "429177000000000000000" }, "91fe8a4c6164df8fa606995d6ba7adcaf1c893ce": { "balance": "17000000000000000000000" }, "889087f66ff284f8b5efbd29493b706733ab1447": { "balance": "9850000000000000000000" }, "051633080d07a557adde319261b074997f14692d": { "balance": "5800000000000000000000" }, "59a12df2e3ef857aceff9306b309f6a500f70134": { "balance": "1000000000000000000000" }, "9f64a8e8dacf4ade30d10f4d59b0a3d5abfdbf74": { "balance": "1000060000000000000000" }, "8846928d683289a2d11df8db7a9474988ef01348": { "balance": "10000000000000000000000" }, "dff1b220de3d8e9ca4c1b5be34a799bcded4f61c": { "balance": "385428000000000000000" }, "7e7c1e9a61a08a83984835c70ec31d34d3eaa87f": { "balance": "191000000000000000000" }, "fe210b8f04dc6d4f76216acfcbd59ba83be9b630": { "balance": "20000000000000000000" }, "dc8c2912f084a6d184aa73638513ccbc326e0102": { "balance": "1295000000000000000000" }, "dddd7b9e6eab409b92263ac272da801b664f8a57": { "balance": "500000000000000000000000" }, "86a5f8259ed5b09e188ce346ee92d34aa5dd93fa": { "balance": "200000000000000000000" }, "dc1f1979615f082140b8bb78c67b27a1942713b1": { "balance": "60000000000000000000" }, "ea66e7b84dcdbf36eea3e75b85382a75f1a15d96": { "balance": "1729135000000000000000" }, "039e7a4ebc284e2ccd42b1bdd60bd6511c0f7706": { "balance": "17300000000000000000" }, "36bfe1fa3b7b70c172eb042f6819a8972595413e": { "balance": "1000000000000000000000" }, "039ef1ce52fe7963f166d5a275c4b1069fe3a832": { "balance": "400008000000000000000" }, "f1df55dcc34a051012b575cb968bc9c458ea09c9": { "balance": "4000000000000000000000" }, "168b5019b818691644835fe69bf229e17112d52c": { "balance": "28000000000000000000000" }, "f60bd735543e6bfd2ea6f11bff627340bc035a23": { "balance": "2000000000000000000000" }, "2cbb0c73df91b91740b6693b774a7d05177e8e58": { "balance": "1850000000000000000000" }, "9ffcf5ef46d933a519d1d16c6ba3189b27496224": { "balance": "1000000000000000000000" }, "0e11d77a8977fac30d268445e531149b31541a24": { "balance": "2000000000000000000000" }, "dfb1626ef48a1d7d7552a5e0298f1fc23a3b482d": { "balance": "1713860000000000000000" }, "cc943be1222cd1400a2399dd1b459445cf6d54a9": { "balance": "12530000000000000000000" }, "b37c2b9f50637bece0ca959208aefee6463ba720": { "balance": "400000000000000000000" }, "96b906ea729f4655afe3e57d35277c967dfa1577": { "balance": "1000000000000000000000" }, "7995bd8ce2e0c67bf1c7a531d477bca1b2b97561": { "balance": "5945100000000000000000" }, "96f820500b70f4a3e3239d619cff8f222075b135": { "balance": "200000000000000000000" }, "ad3565d52b688added08168b2d3872d17d0a26ae": { "balance": "100000000000000000000" }, "9e7c2050a227bbfd60937e268cea3e68fea8d1fe": { "balance": "100000000000000000000" }, "7e59dc60be8b2fc19abd0a5782c52c28400bce97": { "balance": "1000000000000000000000" }, "01ed5fba8d2eab673aec042d30e4e8a611d8c55a": { "balance": "2000000000000000000000" }, "59a087b9351ca42f58f36e021927a22988284f38": { "balance": "18500000000000000000" }, "2fe0023f5722650f3a8ac01009125e74e3f82e9b": { "balance": "3000000000000000000000" }, "bd1803370bddb129d239fd16ea8526a6188ae58e": { "balance": "500000000000000000000" }, "c70527d444c490e9fc3f5cc44e66eb4f306b380f": { "balance": "4000000000000000000000" }, "0f206e1a1da7207ea518b112418baa8b06260328": { "balance": "600000000000000000000" }, "6e1a046caf5b4a57f4fd4bc173622126b4e2fd86": { "balance": "1790000000000000000000" }, "84008a72f8036f3feba542e35078c057f32a8825": { "balance": "100000000000000000000" }, "246291165b59332df5f18ce5c98856fae95897d6": { "balance": "1700000000000000000000" }, "7e99dfbe989d3ba529d19751b7f4317f8953a3e2": { "balance": "400000000000000000000" }, "748c285ef1233fe4d31c8fb1378333721c12e27a": { "balance": "2000000000000000000000" }, "3dd12e556a603736feba4a6fa8bd4ac45d662a04": { "balance": "167450000000000000000000" }, "d0ae735d915e946866e1fea77e5ea466b5cadd16": { "balance": "2000000000000000000000" }, "4f767bc8794aef9a0a38fea5c81f14694ff21a13": { "balance": "512200000000000000000" }, "0e2f8e28a681f77c583bd0ecde16634bdd7e00cd": { "balance": "95060000000000000000" }, "d74a6e8d6aab34ce85976814c1327bd6ea0784d2": { "balance": "100000000000000000000000" }, "629be7ab126a5398edd6da9f18447e78c692a4fd": { "balance": "2000000000000000000000" }, "2e46fcee6a3bb145b594a243a3913fce5dad6fba": { "balance": "10000000000000000000000" }, "e39b11a8ab1ff5e22e5ae6517214f73c5b9b55dc": { "balance": "2000000000000000000000" }, "119aa64d5b7d181dae9d3cb449955c89c1f963fa": { "balance": "700000000000000000000" }, "ce079f51887774d8021cb3b575f58f18e9acf984": { "balance": "180000000000000000000" }, "550c306f81ef5d9580c06cb1ab201b95c748a691": { "balance": "665800000000000000000" }, "06dc7f18cee7edab5b795337b1df6a9e8bd8ae59": { "balance": "400000000000000000000" }, "e21c778ef2a0d7f751ea8c074d1f812243863e4e": { "balance": "5308559000000000000000" }, "45d4b54d37a8cf599821235f062fa9d170ede8a4": { "balance": "324000000000000000000" }, "893a6c2eb8b40ab096b4f67e74a897b840746e86": { "balance": "1730000000000000000000" }, "d44d81e18f46e2cfb5c1fcf5041bc8569767d100": { "balance": "36381800000000000000000" }, "c5de1203d3cc2cea31c82ee2de5916880799eafd": { "balance": "5000000000000000000000" }, "7f0f04fcf37a53a4e24ede6e93104e78be1d3c9e": { "balance": "2000000000000000000000" }, "3ce1dc97fcd7b7c4d3a18a49d6f2a5c1b1a906d7": { "balance": "200000000000000000000" }, "ac4ee9d502e7d2d2e99e59d8ca7d5f00c94b4dd6": { "balance": "1000000000000000000000" }, "7640a37f8052981515bce078da93afa4789b5734": { "balance": "2000000000000000000000" }, "76cac488111a4fd595f568ae3a858770fc915d5f": { "balance": "200000000000000000000" }, "ff4a408f50e9e72146a28ce4fc8d90271f116e84": { "balance": "1970000000000000000000" }, "249db29dbc19d1235da7298a04081c315742e9ac": { "balance": "1801800000000000000000" }, "3a04572847d31e81f7765ca5bfc9d557159f3683": { "balance": "133031000000000000000" }, "b6771b0bf3427f9ae7a93e7c2e61ee63941fdb08": { "balance": "18800000000000000000000" }, "30c26a8e971baa1855d633ba703f028cc7873140": { "balance": "10000000000000000000000" }, "167e3e3ae2003348459392f7dfce44af7c21ad59": { "balance": "500000000000000000000" }, "43f16f1e75c3c06a9478e8c597a40a3cb0bf04cc": { "balance": "2914000000000000000000" }, "056b1546894f9a85e203fb336db569b16c25e04f": { "balance": "169397000000000000000" }, "70616e2892fa269705b2046b8fe3e72fa55816d3": { "balance": "20000000000000000000000" }, "8f4d1d41693e462cf982fd81d0aa701d3a5374c9": { "balance": "4000000000000000000000" }, "c518799a5925576213e21896e0539abb85b05ae3": { "balance": "1000000000000000000000" }, "0e3a28c1dfafb0505bdce19fe025f506a6d01ceb": { "balance": "2000000000000000000000" }, "e4a47e3933246c3fd62979a1ea19ffdf8c72ef37": { "balance": "148273000000000000000" }, "d231929735132102471ba59007b6644cc0c1de3e": { "balance": "1000090000000000000000" }, "555d8d3ce1798aca902754f164b8be2a02329c6c": { "balance": "10000000000000000000000" }, "5ab1a5615348001c7c775dc75748669b8be4de14": { "balance": "690200000000000000000" }, "2fee36a49ee50ecf716f1047915646779f8ba03f": { "balance": "1056230000000000000000" }, "54db5e06b4815d31cb56a8719ba33af2d73e7252": { "balance": "670000000000000000000" }, "7c8bb65a6fbb49bd413396a9d7e31053bbb37aa9": { "balance": "6000000000000000000000" }, "c1384c6e717ebe4b23014e51f31c9df7e4e25b31": { "balance": "500000000000000000000" }, "474158a1a9dc693c133f65e47b5c3ae2f773a86f": { "balance": "200200000000000000000" }, "2934c0df7bbc172b6c186b0b72547ace8bf75454": { "balance": "60000000000000000000" }, "6966063aa5de1db5c671f3dd699d5abe213ee902": { "balance": "8000000000000000000000" }, "9225d46a5a80943924a39e5b84b96da0ac450581": { "balance": "40000000000000000000000" }, "671bbca099ff899bab07ea1cf86965c3054c8960": { "balance": "50000000000000000000" }, "f1f766b0e46d73fcd4d52e7a72e1b9190cc632b3": { "balance": "8000000000000000000000" }, "ef0dc7dd7a53d612728bcbd2b27c19dd4d7d666f": { "balance": "705668000000000000000" }, "38d2e9154964b41c8d50a7487d391e7ee2c3d3c2": { "balance": "3500000000000000000000" }, "352a785f4a921632504ce5d015f83c49aa838d6d": { "balance": "4314800000000000000000" }, "743de50026ca67c94df54f066260e1d14acc11ac": { "balance": "2000000000000000000000" }, "b188078444027e386798a8ae68698919d5cc230d": { "balance": "267400000000000000000" }, "53608105ce4b9e11f86bf497ffca3b78967b5f96": { "balance": "20000000000000000000000" }, "3b159099075207c6807663b1f0f7eda54ac8cce3": { "balance": "1969543000000000000000" }, "141a5e39ee2f680a600fbf6fa297de90f3225cdd": { "balance": "10000000000000000000000" }, "44fff37be01a3888d3b8b8e18880a7ddefeeead3": { "balance": "259145000000000000000" }, "c5a629a3962552cb8eded889636aafbd0c18ce65": { "balance": "10000000000000000000000" }, "fdba5359f7ec3bc770ac49975d844ec9716256f1": { "balance": "1000000000000000000000" }, "7c1df24a4f7fb2c7b472e0bb006cb27dcd164156": { "balance": "1000000000000000000000" }, "ab7d54c7c6570efca5b4b8ce70f52a5773e5d53b": { "balance": "279600000000000000000" }, "3f173aa6edf469d185e59bd26ae4236b92b4d8e1": { "balance": "320000000000000000000" }, "a3f4ad14e0bb44e2ce2c14359c75b8e732d37054": { "balance": "200000000000000000000" }, "ac5f627231480d0d95302e6d89fc32cb1d4fe7e3": { "balance": "200000000000000000000" }, "d0775dba2af4c30a3a78365939cd71c2f9de95d2": { "balance": "1940000000000000000000" }, "ad94235fc3b3f47a2413af31e884914908ef0c45": { "balance": "500008000000000000000" }, "eaedcc6b8b6962d5d9288c156c579d47c0a9fcff": { "balance": "85000000000000000000" }, "7ac48d40c664cc9a6d89f1c5f5c80a1c70e744e6": { "balance": "3008000000000000000000" }, "ec73114c5e406fdbbe09b4fa621bd70ed54ea1ef": { "balance": "24500000000000000000000" }, "a690f1a4b20ab7ba34628620de9ca040c43c1963": { "balance": "4000000000000000000000" }, "cad14f9ebba76680eb836b079c7f7baaf481ed6d": { "balance": "238600000000000000000" }, "6c714a58fff6e97d14b8a5e305eb244065688bbd": { "balance": "4000000000000000000000" }, "3e618350fa01657ab0ef3ebac8e37012f8fc2b6f": { "balance": "2804400000000000000000" }, "c946d5acc1346eba0a7279a0ac1d465c996d827e": { "balance": "16385128000000000000000" }, "1164caaa8cc5977afe1fad8a7d6028ce2d57299b": { "balance": "400000000000000000000" }, "7917e5bd82a9790fd650d043cdd930f7799633db": { "balance": "3999800000000000000000" }, "d52aecc6493938a28ca1c367b701c21598b6a02e": { "balance": "1100000000000000000000" }, "98bed3a72eccfbafb923489293e429e703c7e25b": { "balance": "2000000000000000000000" }, "42db0b902559e04087dd5c441bc7611934184b89": { "balance": "2014420000000000000000" }, "43bc2d4ddcd6583be2c7bc094b28fb72e62ba83b": { "balance": "2000000000000000000000" }, "85f0e7c1e3aff805a627a2aaf2cff6b4c0dbe9cb": { "balance": "20000000000000000000" }, "581b9fd6eae372f3501f42eb9619eec820b78a84": { "balance": "19699015000000000000000" }, "541db20a80cf3b17f1621f1b3ff79b882f50def3": { "balance": "1000000000000000000000" }, "4e8a6d63489ccc10a57f885f96eb04ecbb546024": { "balance": "18500000000000000000000" }, "28349f7ef974ea55fe36a1583b34cec3c45065f0": { "balance": "234490000000000000000" }, "a3241d890a92baf52908dc4aa049726be426ebd3": { "balance": "19999560000000000000000" }, "b4b11d109f608fa8edd3fea9f8c315649aeb3d11": { "balance": "5000000000000000000000" }, "5f321b3daaa296cadf29439f9dab062a4bffedd6": { "balance": "81868000000000000000" }, "c5ae86b0c6c7e3900f1368105c56537faf8d743e": { "balance": "188000000000000000000" }, "9a8eca4189ff4aa8ff7ed4b6b7039f0902219b15": { "balance": "20000000000000000000" }, "a3facc50195c0b4933c85897fecc5bbd995c34b8": { "balance": "20000000000000000000" }, "f07bd0e5c2ce69c7c4a724bd26bbfa9d2a17ca03": { "balance": "5910000000000000000000" }, "640aba6de984d94517377803705eaea7095f4a11": { "balance": "10000000000000000000000" }, "204ac98867a7c9c7ed711cb82f28a878caf69b48": { "balance": "6000000000000000000000" }, "9d34dac25bd15828faefaaf28f710753b39e89dc": { "balance": "1090400000000000000000" }, "fe418b421a9c6d373602790475d2303e11a75930": { "balance": "1015200000000000000000" }, "3f472963197883bbda5a9b7dfcb22db11440ad31": { "balance": "481445000000000000000" }, "1578bdbc371b4d243845330556fff2d5ef4dff67": { "balance": "100000000000000000000" }, "dba4796d0ceb4d3a836b84c96f910afc103f5ba0": { "balance": "166666000000000000000" }, "466fda6b9b58c5532750306a10a2a8c768103b07": { "balance": "199955000000000000000" }, "2770f14efb165ddeba79c10bb0af31c31e59334c": { "balance": "3000000000000000000000" }, "7c382c0296612e4e97e440e02d3871273b55f53b": { "balance": "197600000000000000000" }, "1fb7bd310d95f2a6d9baaf8a8a430a9a04453a8b": { "balance": "3000000000000000000000" }, "a9acf600081bb55bb6bfbab1815ffc4e17e85a95": { "balance": "200000000000000000000" }, "f93d5bcb0644b0cce5fcdda343f5168ffab2877d": { "balance": "209978000000000000000" }, "db0cc78f74d9827bdc8a6473276eb84fdc976212": { "balance": "2000000000000000000000" }, "b66411e3a02dedb726fa79107dc90bc1cae64d48": { "balance": "2000000000000000000000" }, "4d6e8fe109ccd2158e4db114132fe75fecc8be5b": { "balance": "25019000000000000000" }, "6fd947d5a73b175008ae6ee8228163da289b167d": { "balance": "30000000000000000000000" }, "32d950d5e93ea1d5b48db4714f867b0320b31c0f": { "balance": "1015200000000000000000" }, "9c99b62606281b5cefabf36156c8fe62839ef5f3": { "balance": "4000000000000000000000" }, "86c8d0d982b539f48f9830f9891f9d607a942659": { "balance": "13260000000000000000000" }, "f2127d54188fedef0f338a5f38c7ff73ad9f6f42": { "balance": "20000000000000000000000" }, "e864fec07ed1214a65311e11e329de040d04f0fd": { "balance": "1656353000000000000000" }, "1d09ad2412691cc581c1ab36b6f9434cd4f08b54": { "balance": "7000000000000000000000" }, "4ea70f04313fae65c3ff224a055c3d2dab28dddf": { "balance": "19999800000000000000000" }, "e0668fa82c14d6e8d93a53113ef2862fa81581bc": { "balance": "870400000000000000000" }, "f0d858105e1b648101ac3f85a0f8222bf4f81d6a": { "balance": "600000000000000000000" }, "0f3a1023cac04dbf44f5a5fa6a9cf8508cd4fddf": { "balance": "1820000000000000000000" }, "5793abe6f1533311fd51536891783b3f9625ef1c": { "balance": "827268000000000000000" }, "8d667637e29eca05b6bfbef1f96d460eefbf9984": { "balance": "4000000000000000000000" }, "d76dbaebc30d4ef67b03e6e6ecc6d84e004d502d": { "balance": "2019250000000000000000" }, "42d1a6399b3016a8597f8b640927b8afbce4b215": { "balance": "2980000000000000000000" }, "21fd47c5256012198fa5abf131c06d6aa1965f75": { "balance": "7880000000000000000000" }, "2f2bba1b1796821a766fce64b84f28ec68f15aea": { "balance": "20000000000000000000" }, "d24bf12d2ddf457decb17874efde2052b65cbb49": { "balance": "14000000000000000000000" }, "88de13b09931877c910d593165c364c8a1641bd3": { "balance": "3000000000000000000000" }, "555ca9f05cc134ab54ae9bea1c3ff87aa85198ca": { "balance": "100000000000000000000" }, "ae9ecd6bdd952ef497c0050ae0ab8a82a91898ce": { "balance": "30000000000000000000" }, "ad8bfef8c68a4816b3916f35cb7bfcd7d3040976": { "balance": "40000000000000000000000" }, "dad136b88178b4837a6c780feba226b98569a94c": { "balance": "200000000000000000000" }, "800e7d631c6e573a90332f17f71f5fd19b528cb9": { "balance": "152000000000000000000" }, "94a9a71691317c2064271b51c9353fbded3501a8": { "balance": "3340000000000000000000" }, "80a0f6cc186cf6201400736e065a391f52a9df4a": { "balance": "10000000000000000000000" }, "712ff7370a13ed360973fedc9ff5d2c93a505e9e": { "balance": "3940000000000000000000" }, "42399659aca6a5a863ea2245c933fe9a35b7880e": { "balance": "2044000000000000000000" }, "ae239acffd4ebe2e1ba5b4170572dc79cc6533ec": { "balance": "12000000000000000000000" }, "007b9fc31905b4994b04c9e2cfdc5e2770503f42": { "balance": "1999000000000000000000" }, "7480de62254f2ba82b578219c07ba5be430dc3cb": { "balance": "7040000000000000000000" }, "917b8f9f3a8d09e9202c52c29e724196b897d35e": { "balance": "161000000000000000000" }, "708ea707bae4357f1ebea959c3a250acd6aa21b3": { "balance": "500000000000000000000" }, "6dc7053a718616cfc78bee6382ee51add0c70330": { "balance": "2000000000000000000000" }, "c4dac5a8a0264fbc1055391c509cc3ee21a6e04c": { "balance": "6501000000000000000000" }, "c1b2a0fb9cad45cd699192cd27540b88d3384279": { "balance": "500000000000000000000" }, "b07cb9c12405b711807543c4934465f87f98bd2d": { "balance": "2000000000000000000000" }, "c7f72bb758016b374714d4899bce22b4aec70a31": { "balance": "1072706000000000000000" }, "0c480de9f7461002908b49f60fc61e2b62d3140b": { "balance": "10000000000000000000000" }, "83d532d38d6dee3f60adc68b936133c7a2a1b0dd": { "balance": "500000000000000000000" }, "12afbcba1427a6a39e7ba4849f7ab1c4358ac31b": { "balance": "20000000000000000000000" }, "f8f6645e0dee644b3dad81d571ef9baf840021ad": { "balance": "2000000000000000000000" }, "40cf890591eae4a18f812a2954cb295f633327e6": { "balance": "48132000000000000000" }, "735b97f2fc1bd24b12076efaf3d1288073d20c8c": { "balance": "20000000000000000000" }, "47c7e5efb48b3aed4b7c6e824b435f357df4c723": { "balance": "18200000000000000000" }, "d34d708d7398024533a5a2b2309b19d3c55171bb": { "balance": "400000000000000000000" }, "64370e87202645125a35b207af1231fb6072f9a7": { "balance": "200000000000000000000" }, "b055af4cadfcfdb425cf65ba6431078f07ecd5ab": { "balance": "100000000000000000000" }, "c7de5e8eafb5f62b1a0af2195cf793c7894c9268": { "balance": "1000000000000000000000" }, "c63cd7882118b8a91e074d4c8f4ba91851303b9a": { "balance": "260000000000000000000" }, "164d7aac3eecbaeca1ad5191b753f173fe12ec33": { "balance": "744090000000000000000" }, "e4fb26d1ca1eecba3d8298d9d148119ac2bbf580": { "balance": "400000000000000000000" }, "613ac53be565d46536b820715b9b8d3ae68a4b95": { "balance": "3760000000000000000000" }, "7f616c6f008adfa082f34da7d0650460368075fb": { "balance": "1000000000000000000000" }, "9af100cc3dae83a33402051ce4496b16615483f6": { "balance": "2000000000000000000000" }, "b45cca0d36826662683cf7d0b2fdac687f02d0c4": { "balance": "1000000000000000000000" }, "93a6b3ab423010f981a7489d4aad25e2625c5741": { "balance": "20190033000000000000000" }, "ee049af005974dd1c7b3a9ca8d9aa77175ba53aa": { "balance": "333333000000000000000" }, "687927e3048bb5162ae7c15cf76bd124f9497b9e": { "balance": "2000000000000000000000" }, "1aa40270d21e5cde86b6316d1ac3c533494b79ed": { "balance": "20000000000000000000" }, "426259b0a756701a8b663528522156c0288f0f24": { "balance": "9900000000000000000000" }, "91c75e3cb4aa89f34619a164e2a47898f5674d9c": { "balance": "2000000000000000000000" }, "437983388ab59a4ffc215f8e8269461029c3f1c1": { "balance": "20000000000000000000000" }, "272a131a5a656a7a3aca35c8bd202222a7592258": { "balance": "2674000000000000000000" }, "bc0ca4f217e052753614d6b019948824d0d8688b": { "balance": "400000000000000000000" }, "cc6c03bd603e09de54e9c4d5ac6d41cbce715724": { "balance": "98500000000000000000" }, "d79aff13ba2da75d46240cac0a2467c656949823": { "balance": "1730000000000000000000" }, "477b24eee8839e4fd19d1250bd0b6645794a61ca": { "balance": "8000000000000000000000" }, "79fd6d48315066c204f9651869c1096c14fc9781": { "balance": "2000000000000000000000" }, "1463a873555bc0397e575c2471cf77fa9db146e0": { "balance": "10000000000000000000000" }, "89ab13ee266d779c35e8bb04cd8a90cc2103a95b": { "balance": "60000000000000000000000" }, "90acced7e48c08c6b934646dfa0adf29dc94074f": { "balance": "56154000000000000000" }, "31ea6eab19d00764e9a95e183f2b1b22fc7dc40f": { "balance": "20000000000000000000" }, "87a53ea39f59a35bada8352521645594a1a714cb": { "balance": "1910000000000000000000" }, "1e1aed85b86c6562cb8fa1eb6f8f3bc9dcae6e79": { "balance": "4516200000000000000000" }, "e36a8ea87f1e99e8a2dc1b2608d166667c9dfa01": { "balance": "100000000000000000000" }, "ec2cb8b9378dff31aec3c22e0e6dadff314ab5dd": { "balance": "2000000000000000000000" }, "3cadeb3d3eed3f62311d52553e70df4afce56f23": { "balance": "4000000000000000000000" }, "3ceca96bb1cdc214029cbc5e181d398ab94d3d41": { "balance": "80000000000000000000000" }, "3283eb7f9137dd39bed55ffe6b8dc845f3e1a079": { "balance": "66224000000000000000" }, "0954a8cb5d321fc3351a7523a617d0f58da676a7": { "balance": "2506000000000000000000" }, "de33d708a3b89e909eaf653b30fdc3a5d5ccb4b3": { "balance": "177300000000000000000" }, "1c6702b3b05a5114bdbcaeca25531aeeb34835f4": { "balance": "26071500000000000000000" }, "e5b96fc9ac03d448c1613ac91d15978145dbdfd1": { "balance": "200000000000000000000" }, "fbf204c813f836d83962c7870c7808ca347fd33e": { "balance": "20000000000000000000" }, "3b13631a1b89cb566548899a1d60915cdcc4205b": { "balance": "2000000000000000000000" }, "a87f7abd6fa31194289678efb63cf584ee5e2a61": { "balance": "4000000000000000000000" }, "c0a39308a80e9e84aaaf16ac01e3b01d74bd6b2d": { "balance": "136499000000000000000" }, "ffd6da958eecbc016bab91058440d39b41c7be83": { "balance": "20000000000000000000000" }, "0e3dd7d4e429fe3930a6414035f52bdc599d784d": { "balance": "40110000000000000000" }, "e0663e8cd66792a641f56e5003660147880f018e": { "balance": "2000000000000000000000" }, "5b78eca27fbdea6f26befba8972b295e7814364b": { "balance": "2000000000000000000000" }, "ec9851bd917270610267d60518b54d3ca2b35b17": { "balance": "40000000000000000000000" }, "bc9c95dfab97a574cea2aa803b5caa197cef0cff": { "balance": "420000000000000000000" }, "100b4d0977fcbad4debd5e64a0497aeae5168fab": { "balance": "314500000000000000000" }, "1b6610fb68bad6ed1cfaa0bbe33a24eb2e96fafb": { "balance": "152000000000000000000" }, "b4524c95a7860e21840296a616244019421c4aba": { "balance": "8000000000000000000000" }, "88975a5f1ef2528c300b83c0c607b8e87dd69315": { "balance": "83500000000000000000" }, "853e6abaf44469c72f151d4e223819aced4e3728": { "balance": "2000000000000000000000" }, "d604abce4330842e3d396ca73ddb5519ed3ec03f": { "balance": "163940000000000000000" }, "d209482bb549abc4777bea6d7f650062c9c57a1c": { "balance": "320880000000000000000" }, "590acbda37290c0d3ec84fc2000d7697f9a4b15d": { "balance": "500000000000000000000" }, "571950ea2c90c1427d939d61b4f2de4cf1cfbfb0": { "balance": "20000000000000000000" }, "cb94e76febe208116733e76e805d48d112ec9fca": { "balance": "1000000000000000000000" }, "fa8e3b1f13433900737daaf1f6299c4887f85b5f": { "balance": "715000000000000000000" }, "162d76c2e6514a3afb6fe3d3cb93a35c5ae783f1": { "balance": "2000000000000000000000" }, "4bea288eea42c4955eb9faad2a9faf4783cbddac": { "balance": "28790618000000000000000" }, "c8ab1a3cf46cb8b064df2e222d39607394203277": { "balance": "2000000000000000000000" }, "318b2ea5f0aaa879c4d5e548ac9d92a0c67487b7": { "balance": "200000000000000000000" }, "53c5fe0119e1e848640cee30adea96940f2a5d8b": { "balance": "21746000000000000000000" }, "0701f9f147ec486856f5e1b71de9f117e99e2105": { "balance": "173360000000000000000" }, "337cfe1157a5c6912010dd561533791769c2b6a6": { "balance": "1000000000000000000000" }, "fd60d2b5af3d35f7aaf0c393052e79c4d823d985": { "balance": "56400000000000000000" }, "0f049a8bdfd761de8ec02cee2829c4005b23c06b": { "balance": "252000000000000000000" }, "924bce7a853c970bb5ec7bb759baeb9c7410857b": { "balance": "13700000000000000000" }, "16abb8b021a710bdc78ea53494b20614ff4eafe8": { "balance": "158000000000000000000" }, "9e7f65a90e8508867bccc914256a1ea574cf07e3": { "balance": "1240000000000000000000" }, "01d03815c61f416b71a2610a2daba59ff6a6de5b": { "balance": "9553100000000000000000" }, "3df762049eda8ac6927d904c7af42f94e5519601": { "balance": "2000000000000000000000" }, "5593c9d4b664730fd93ca60151c25c2eaed93c3b": { "balance": "200000000000000000000" }, "e023f09b2887612c7c9cf1988e3a3a602b3394c9": { "balance": "2000000000000000000000" }, "4c13980c32dcf3920b78a4a7903312907c1b123f": { "balance": "60024000000000000000" }, "a282e969cac9f7a0e1c0cd90f5d0c438ac570da3": { "balance": "627760000000000000000" }, "3b22da2a0271c8efe102532773636a69b1c17e09": { "balance": "502000000000000000000" }, "1aa1021f550af158c747668dd13b463160f95a40": { "balance": "1470000000000000000000" }, "f15178ffc43aa8070ece327e930f809ab1a54f9d": { "balance": "197600000000000000000" }, "db1293a506e90cad2a59e1b8561f5e66961a6788": { "balance": "2000000000000000000000" }, "88c361640d6b69373b081ce0c433bd590287d5ec": { "balance": "50000000000000000000000" }, "3737216ee91f177732fb58fa4097267207e2cf55": { "balance": "1520000000000000000000" }, "a16d9e3d63986159a800b46837f45e8bb980ee0b": { "balance": "2030400000000000000000" }, "ec76f12e57a65504033f2c0bce6fc03bd7fa0ac4": { "balance": "3580000000000000000000" }, "d9f1b26408f0ec67ad1d0d6fe22e8515e1740624": { "balance": "24000000000000000000" }, "716ba01ead2a91270635f95f25bfaf2dd610ca23": { "balance": "44750000000000000000000" }, "42a98bf16027ce589c4ed2c95831e2724205064e": { "balance": "10000000000000000000000" }, "0f88aac9346cb0e7347fba70905475ba8b3e5ece": { "balance": "10000000000000000000000" }, "2d8c52329f38d2a2fa9cbaf5c583daf1490bb11c": { "balance": "20000000000000000000" }, "3cea302a472a940379dd398a24eafdbadf88ad79": { "balance": "3000000000000000000000" }, "a29d5bda74e003474872bd5894b88533ff64c2b5": { "balance": "10000000000000000000000" }, "2d23766b6f6b05737dad80a419c40eda4d77103e": { "balance": "3820000000000000000000" }, "b07249e055044a9155359a402937bbd954fe48b6": { "balance": "100000000000000000000" }, "f1e980c559a1a8e5e50a47f8fffdc773b7e06a54": { "balance": "30104784000000000000000" }, "8275cd684c3679d5887d03664e338345dc3cdde1": { "balance": "15800000000000000000" }, "b27c1a24204c1e118d75149dd109311e07c073ab": { "balance": "3100000000000000000000" }, "451b3699475bed5d7905f8905aa3456f1ed788fc": { "balance": "2560000000000000000000" }, "31ad4d9946ef09d8e988d946b1227f9141901736": { "balance": "22880000000000000000000" }, "52b8a9592634f7300b7c5c59a3345b835f01b95c": { "balance": "2000000000000000000000" }, "b161725fdcedd17952d57b23ef285b7e4b1169e8": { "balance": "50071000000000000000" }, "74fc5a99c0c5460503a13b0509459da19ce7cd90": { "balance": "200000000000000000000" }, "d99df7421b9382e42c89b006c7f087702a0757c0": { "balance": "480000000000000000000" }, "8a4f4a7f52a355ba105fca2072d3065fc8f7944b": { "balance": "500000000000000000000" }, "12316fc7f178eac22eb2b25aedeadf3d75d00177": { "balance": "19999999000000000000000" }, "f598db2e09a8a5ee7d720d2b5c43bb126d11ecc2": { "balance": "200000000000000000000" }, "37b8beac7b1ca38829d61ab552c766f48a10c32f": { "balance": "400000000000000000000" }, "851dc38adb4593729a76f33a8616dab6f5f59a77": { "balance": "100000000000000000000" }, "bf4096bc547dbfc4e74809a31c039e7b389d5e17": { "balance": "3940000000000000000000" }, "98d3731992d1d40e1211c7f735f2189afa0702e0": { "balance": "8000000000000000000000" }, "0f4073c1b99df60a1549d69789c7318d9403a814": { "balance": "20000000000000000000000" }, "a430995ddb185b9865dbe62539ad90d22e4b73c2": { "balance": "10000000000000000000000" }, "898c72dd736558ef9e4be9fdc34fef54d7fc7e08": { "balance": "1000000000000000000000" }, "f9b617f752edecae3e909fbb911d2f8192f84209": { "balance": "2674000000000000000000" }, "e1ae029b17e373cde3de5a9152201a14cac4e119": { "balance": "99968000000000000000" }, "d8e8474292e7a051604ca164c0707783bb2885e8": { "balance": "13370000000000000000000" }, "f476f2cb7208a32e051fd94ea8662992638287a2": { "balance": "100000000000000000000" }, "3a84e950ed410e51b7e8801049ab2634b285fea1": { "balance": "18690000000000000000000" }, "5b7784caea01799ca30227827667ce207c5cbc76": { "balance": "2000000000000000000000" }, "3af65b3e28895a4a001153391d1e69c31fb9db39": { "balance": "3940000000000000000000" }, "95fb5afb14c1ef9ab7d179c5c300503fd66a5ee2": { "balance": "34225000000000000000" }, "a8446c4781a737ac4328b1e15b8a0b3fbb0fd668": { "balance": "21390500000000000000000" }, "4888fb25cd50dbb9e048f41ca47d78b78a27c7d9": { "balance": "17300000000000000000000" }, "566c10d638e8b88b47d6e6a414497afdd00600d4": { "balance": "99960000000000000000" }, "bd47f5f76e3b930fd9485209efa0d4763da07568": { "balance": "1000000000000000000000" }, "1e1c6351776ac31091397ecf16002d979a1b2d51": { "balance": "1400000000000000000000" }, "edf603890228d7d5de9309942b5cad4219ef9ad7": { "balance": "5000000000000000000000" }, "1923cfc68b13ea7e2055803645c1e320156bd88d": { "balance": "1337000000000000000000" }, "8f8f37d0ad8f335d2a7101b41156b688a81a9cbe": { "balance": "70000000000000000000" }, "63334fcf1745840e4b094a3bb40bb76f9604c04c": { "balance": "3978000000000000000000" }, "001762430ea9c3a26e5749afdb70da5f78ddbb8c": { "balance": "200000000000000000000" }, "512116817ba9aaf843d1507c65a5ea640a7b9eec": { "balance": "50000000000000000000" }, "2961fb391c61957cb5c9e407dda29338d3b92c80": { "balance": "999942000000000000000" }, "fc2952b4c49fedd0bc0528a308495e6d6a1c71d6": { "balance": "2000000000000000000000" }, "13ec812284026e409bc066dfebf9d5a4a2bf801e": { "balance": "1610000000000000000000" }, "ef463c2679fb279164e20c3d2691358773a0ad95": { "balance": "2000000000000000000000" }, "3aadf98b61e5c896e7d100a3391d3250225d61df": { "balance": "234000000000000000000" }, "e8137fc1b2ec7cc7103af921899b4a39e1d959a1": { "balance": "1490000000000000000000" }, "b1a2b43a7433dd150bb82227ed519cd6b142d382": { "balance": "2738000000000000000000" }, "c1f39bd35dd9cec337b96f47c677818160df37b7": { "balance": "20000000000000000000" }, "b587b44a2ca79e4bc1dd8bfdd43a207150f2e7e0": { "balance": "630400000000000000000" }, "41485612d03446ec4c05e5244e563f1cbae0f197": { "balance": "970000000000000000000" }, "a12623e629df93096704b16084be2cd89d562da4": { "balance": "8500000000000000000000" }, "3f2f381491797cc5c0d48296c14fd0cd00cdfa2d": { "balance": "804000000000000000000" }, "9470cc36594586821821c5c996b6edc83b6d5a32": { "balance": "24000000000000000000" }, "3605372d93a9010988018f9f315d032ed1880fa1": { "balance": "500066000000000000000" }, "12632388b2765ee4452b50161d1fffd91ab81f4a": { "balance": "740000000000000000000" }, "274a3d771a3d709796fbc4d5f48fce2fe38c79d6": { "balance": "20000000000000000000" }, "d60a52580728520df7546bc1e283291788dbae0c": { "balance": "999910000000000000000" }, "1ab53a11bcc63ddfaa40a02b9e186496cdbb8aff": { "balance": "1996800000000000000000" }, "c282e6993fbe7a912ea047153ffd9274270e285b": { "balance": "139939000000000000000" }, "a291e9c7990d552dd1ae16cebc3fca342cbaf1d1": { "balance": "20000000000000000000000" }, "5547fdb4ae11953e01292b7807fa9223d0e4606a": { "balance": "98940000000000000000" }, "bded11612fb5c6da99d1e30e320bc0995466141e": { "balance": "400000000000000000000" }, "b73b4ff99eb88fd89b0b6d57a9bc338e886fa06a": { "balance": "32000000000000000000" }, "b1c751786939bba0d671a677a158c6abe7265e46": { "balance": "10000000000000000000000" }, "e881bbbe69722d81efecaa48d1952a10a2bfac8f": { "balance": "16000000000000000000000" }, "fe96c4cd381562401aa32a86e65b9d52fa8aee27": { "balance": "2640000000000000000000" }, "683dba36f7e94f40ea6aea0d79b8f521de55076e": { "balance": "140000000000000000000" }, "5ac2908b0f398c0df5bac2cb13ca7314fba8fa3d": { "balance": "199800000000000000000" }, "8914a680a5aec5226d4baaec2e5552b44dd7c874": { "balance": "100076000000000000000" }, "041170f581de80e58b2a045c8f7c1493b001b7cb": { "balance": "889800000000000000000" }, "4665e47396c7db97eb2a03d90863d5d4ba319a94": { "balance": "600000000000000000000" }, "ed4be04a052d7accb3dcce90319dba4020ab2c68": { "balance": "37547947000000000000000" }, "4b0619d9d8aa313a9531ac7dbe04ca0d6a5ad1b6": { "balance": "2000000000000000000000" }, "a21442ab05340ade68c915f3c3399b9955f3f7eb": { "balance": "775000000000000000000" }, "655934da8e744eaa3de34dbbc0894c4eda0b61f2": { "balance": "200000000000000000000" }, "6038740ae28d66ba93b0be08482b3205a0f7a07b": { "balance": "316000000000000000000" }, "99924a9816bb7ddf3fec1844828e9ad7d06bf4e6": { "balance": "1760000000000000000000" }, "6847825bdee8240e28042c83cad642f286a3bddc": { "balance": "1500000000000000000000" }, "a718aaad59bf395cba2b23e09b02fe0c89816247": { "balance": "999600000000000000000" }, "2c89f5fdca3d155409b638b98a742e55eb4652b7": { "balance": "98500000000000000000000" }, "1a7044e2383f8708305b495bd1176b92e7ef043a": { "balance": "200000000000000000000" }, "282e80a554875a56799fa0a97f5510e795974c4e": { "balance": "1000000000000000000000" }, "ffb3bcc3196a8c3cb834cec94c34fed35b3e1054": { "balance": "1340000000000000000000" }, "d135794b149a18e147d16e621a6931f0a40a969a": { "balance": "20000000000000000000000" }, "6b94615db750656ac38c7e1cf29a9d13677f4e15": { "balance": "12000000000000000000000" }, "ecbe425e670d39094e20fb5643a9d818eed236de": { "balance": "5000000000000000000000" }, "511e0efb04ac4e3ff2e6550e498295bfcd56ffd5": { "balance": "668500000000000000000" }, "ff65511cada259260c1ddc41974ecaecd32d6357": { "balance": "1760000000000000000000" }, "9ffc5fe06f33f5a480b75aa94eb8556d997a16c0": { "balance": "20000000000000000000" }, "57df23bebdc65eb75feb9cb2fad1c073692b2baf": { "balance": "4000000000000000000000" }, "207ef80b5d60b6fbffc51f3a64b8c72036a5abbd": { "balance": "6685000000000000000000" }, "c573e841fa08174a208b060ccb7b4c0d7697127f": { "balance": "668500000000000000000" }, "411610b178d5617dfab934d293f512a93e5c10e1": { "balance": "170000000000000000000" }, "9991614c5baa47dd6c96874645f97add2c3d8380": { "balance": "1970000000000000000000" }, "2d3480bf0865074a72c7759ee5137b4d70c51ce9": { "balance": "200000000000000000000" }, "9d40e012f60425a340d82d03a1c757bfabc706fb": { "balance": "169799000000000000000" }, "47648bed01f3cd3249084e635d14daa9e7ec3c8a": { "balance": "194000000000000000000" }, "a5ff62222d80c013cec1a0e8850ed4d354dac16d": { "balance": "207600000000000000000" }, "f80d3619702fa5838c48391859a839fb9ce7160f": { "balance": "1992800000000000000000" }, "7c0f5e072043c9ee740242197e78cc4b98cdf960": { "balance": "200000000000000000000" }, "a40aa2bbce0c72b4d0dfffcc42715b2b54b01bfa": { "balance": "1000000000000000000000" }, "2eeed50471a1a2bf53ee30b1232e6e9d80ef866d": { "balance": "20000000000000000000" }, "0c2808b951ed9e872d7b32790fcc5994ae41ffdc": { "balance": "102000000000000000000000" }, "7f06c89d59807fa60bc60136fcf814cbaf2543bd": { "balance": "10000000000000000000000" }, "8d4b603c5dd4570c34669515fdcc665890840c77": { "balance": "18200000000000000000" }, "d5e5c135d0c4c3303934711993d0d16ff9e7baa0": { "balance": "2000000000000000000000" }, "241361559feef80ef137302153bd9ed2f25db3ef": { "balance": "20000000000000000000000" }, "db63122de7037da4971531fae9af85867886c692": { "balance": "277000000000000000000" }, "417e4e2688b1fd66d821529e46ed4f42f8b3db3d": { "balance": "2000000000000000000000" }, "127db1cadf1b771cbd7475e1b272690f558c8565": { "balance": "14000000000000000000000" }, "48659d8f8c9a2fd44f68daa55d23a608fbe500dc": { "balance": "2000000000000000000000" }, "b3a64b1176724f5409e1414a3523661baee74b4a": { "balance": "25610000000000000000" }, "aa14422d6f0ae5a758194ed15780c838d67f1ee1": { "balance": "28503824000000000000000" }, "a0a0e65204541fca9b2fb282cd95138fae16f809": { "balance": "10000000000000000000000" }, "d2107b353726c3a2b46566eaa7d9f80b5d21dbe3": { "balance": "20000000000000000000" }, "e4cafb727fb5c6b70bb27533b8a9ccc9ef6888e1": { "balance": "300443000000000000000" }, "09f3f601f605441140586ce0656fa24aa5b1d9ae": { "balance": "1539400000000000000000" }, "87fcbe7c4193ffcb08143779c9bec83fe7fda9fc": { "balance": "100275000000000000000" }, "03ebc63fda6660a465045e235fbe6e5cf195735f": { "balance": "141840000000000000000" }, "bdbaf6434d40d6355b1e80e40cc4ab9c68d96116": { "balance": "100000000000000000000" }, "4e2225a1bb59bc88a2316674d333b9b0afca6655": { "balance": "155000000000000000000" }, "4dc3da13b2b4afd44f5d0d3189f444d4ddf91b1b": { "balance": "2000000000000000000000" }, "4ba8e0117fc0b6a3e56b24a3a58fe6cef442ff98": { "balance": "5640000000000000000000" }, "27146913563aa745e2588430d9348e86ea7c3510": { "balance": "400000000000000000000" }, "4c5afe40f18ffc48d3a1aec41fc29de179f4d297": { "balance": "2000000000000000000000" }, "8a810114b2025db9fbb50099a6e0cb9e2efa6bdc": { "balance": "1910000000000000000000" }, "2dee90a28f192d676a8773232b56f18f239e2fad": { "balance": "18587970000000000000000" }, "60676e92d18b000509c61de540e6c5ddb676d509": { "balance": "1200000000000000000000" }, "9bfc659c9c601ea42a6b21b8f17084ec87d70212": { "balance": "10000000000000000000000" }, "5d5d6e821c6eef96810c83c491468560ef70bfb5": { "balance": "2000000000000000000000" }, "d5787668c2c5175b01a8ee1ac3ecc9c8b2aba95a": { "balance": "1999944000000000000000" }, "33b336f5ba5edb7b1ccc7eb1a0d984c1231d0edc": { "balance": "2000000000000000000000" }, "3abb8adfc604f48d5984811d7f1d52fef6758270": { "balance": "4475000000000000000000" }, "980a84b686fc31bdc83c221058546a71b11f838a": { "balance": "779471000000000000000" }, "0b507cf553568daaf65504ae4eaa17a8ea3cdbf5": { "balance": "2000000000000000000000" }, "896009526a2c7b0c09a6f63a80bdf29d9c87de9c": { "balance": "3462830000000000000000" }, "9696052138338c722f1140815cf7749d0d3b3a74": { "balance": "500000000000000000000" }, "3831757eae7557cb8a37a4b10644b63e4d3b3c75": { "balance": "200000000000000000000" }, "62dc72729024375fc37cbb9c7c2393d10233330f": { "balance": "2000000000000000000000" }, "44098866a69b68c0b6bc168229b9603587058967": { "balance": "188000000000000000000" }, "25adb8f96f39492c9bb47c5edc88624e46075697": { "balance": "26740000000000000000000" }, "fd4de8e3748a289cf7d060517d9d38388db01fb8": { "balance": "250000000000000000000" }, "6be7595ea0f068489a2701ec4649158ddc43e178": { "balance": "2000000000000000000000" }, "d402b4f6a099ebe716cb14df4f79c0cd01c6071b": { "balance": "2000000000000000000000" }, "a07682000b1bcf3002f85c80c0fa2949bd1e82fd": { "balance": "4000000000000000000000" }, "eb4f00e28336ea09942588eeac921811c522143c": { "balance": "2000000000000000000000" }, "8f31c7005197ec997a87e69bec48649ab94bb2a5": { "balance": "4000000000000000000000" }, "e7fd8fd959aed2767ea7fa960ce1db53af802573": { "balance": "1000000000000000000000" }, "a8ef9ad274436042903e413c3b0c62f5f52ed584": { "balance": "10000000000000000000000" }, "d83ad260e9a6f432fb6ea28743299b4a09ad658c": { "balance": "2000000000000000000000" }, "b5c816a8283ca4df68a1a73d63bd80260488df08": { "balance": "200000000000000000000" }, "d7d3c75920590438b82c3e9515be2eb6ed7a8b1a": { "balance": "60000000000000000000000" }, "af3cb5965933e7dad883693b9c3e15beb68a4873": { "balance": "2000000000000000000000" }, "6e899e59a9b41ab7ea41df7517860f2acb59f4fd": { "balance": "20000000000000000000000" }, "527a8ca1268633a6c939c5de1b929aee92aeac8d": { "balance": "900000000000000000000" }, "1680cec5021ee93050f8ae127251839e74c1f1fd": { "balance": "13098657000000000000000" }, "ff7843c7010aa7e61519b762dfe49124a76b0e4e": { "balance": "933580000000000000000000" }, "140fba58dbc04803d84c2130f01978f9e0c73129": { "balance": "400000000000000000000" }, "0261ad3a172abf1315f0ffec3270986a8409cb25": { "balance": "203500000000000000000" }, "ab5a79016176320973e8cd38f6375530022531c0": { "balance": "1000000000000000000000" }, "fca73eff8771c0103ba3cc1a9c259448c72abf0b": { "balance": "1000000000000000000000" }, "07d41217badca5e0e60327d845a3464f0f27f84a": { "balance": "4000000000000000000000" }, "2c1c19114e3d6de27851484b8d2715e50f8a1065": { "balance": "100000000000000000000" }, "abd21eff954fc6a7de26912a7cbb303a6607804e": { "balance": "1517000000000000000000" }, "f303d5a816affd97e83d9e4dac2f79072bb0098f": { "balance": "960000000000000000000" }, "114cfefe50170dd97ae08f0a44544978c599548d": { "balance": "863000000000000000000" }, "647b85044df2cf0b4ed4882e88819fe22ae5f793": { "balance": "1000032000000000000000" }, "1b130d6fa51d5c48ec8d1d52dc8a227be8735c8a": { "balance": "2000000000000000000000" }, "0d9d3f9bc4a4c6efbd59679b69826bc1f63d9916": { "balance": "600000000000000000000" }, "c765e00476810947816af142d46d2ee7bca8cc4f": { "balance": "500000000000000000000" }, "b57b04fa23d1203fae061eac4542cb60f3a57637": { "balance": "191000000000000000000" }, "e192489b85a982c1883246d915b229cb13207f38": { "balance": "5000000000000000000000" }, "5f483ffb8f680aedf2a38f7833afdcde59b61e4b": { "balance": "2000000000000000000000" }, "b46d1182e5aacaff0d26b2fcf72f3c9ffbcdd97d": { "balance": "3139000000000000000000" }, "59c7f785c93160e5807ed34e5e534bc6188647a7": { "balance": "640000000000000000000" }, "18e4ce47483b53040adbab35172c01ef64506e0c": { "balance": "9000000000000000000000" }, "296d66b521571a4e4103a7f562c511e6aa732d81": { "balance": "668500000000000000000" }, "bcd99edc2160f210a05e3a1fa0b0434ced00439b": { "balance": "2000000000000000000000" }, "f14f0eb86db0eb68753f16918e5d4b807437bd3e": { "balance": "200000000000000000000" }, "60d5667140d12614b21c8e5e8a33082e32dfcf23": { "balance": "20000000000000000000000" }, "8ccabf25077f3aa41545344d53be1b2b9c339000": { "balance": "1695400000000000000000" }, "8cc0d7c016fa7aa950114aa1db094882eda274ea": { "balance": "159800000000000000000" }, "c71145e529c7a714e67903ee6206e4c3042b6727": { "balance": "1430000000000000000000" }, "c5e9939334f1252ed2ba26814487dfd2982b3128": { "balance": "70000000000000000000" }, "f09b3e87f913ddfd57ae8049c731dba9b636dfc3": { "balance": "608000000000000000000" }, "4349225a62f70aea480a029915a01e5379e64fa5": { "balance": "2598000000000000000000" }, "666b4f37d55d63b7d056b615bb74c96b3b01991a": { "balance": "4000000000000000000000" }, "8bd6b1c6d74d010d1008dba6ef835d4430b35c32": { "balance": "50000000000000000000" }, "7363cd90fbab5bb8c49ac20fc62c398fe6fb744c": { "balance": "2000000000000000000000" }, "b7479dab5022c4d5dbaaf8de171b4e951dd1a457": { "balance": "80000000000000000000" }, "5a5468fa5ca226c7532ecf06e1bc1c45225d7ec9": { "balance": "1910000000000000000000" }, "32a20d028e2c6218b9d95b445c771524636a22ef": { "balance": "9500000000000000000000" }, "1bd28cd5c78aee51357c95c1ef9235e7c18bc854": { "balance": "2000000000000000000000" }, "693492a5c51396a482881669ccf6d8d779f00951": { "balance": "345827000000000000000" }, "bd723b289a7367b6ece2455ed61edb49670ab9c4": { "balance": "4999995000000000000000" }, "1be3542c3613687465f15a70aeeb81662b65cca8": { "balance": "2000000000000000000000" }, "5803e68b34da121aef08b602badbafb4d12481ca": { "balance": "18000000000000000000000" }, "9ac907ee85e6f3e223459992e256a43fa08fa8b2": { "balance": "10000000000000000000000" }, "833b6a8ec8da408186ac8a7d2a6dd61523e7ce84": { "balance": "16000000000000000000000" }, "64628c6fb8ec743adbd87ce5e018d531d9210437": { "balance": "26740000000000000000" }, "566c28e34c3808d9766fe8421ebf4f2b1c4f7d77": { "balance": "1970000000000000000000" }, "171ad9a04bedc8b861e8ed4bddf5717813b1bb48": { "balance": "400000000000000000000" }, "4f85bc1fc5cbc9c001e8f1372e07505370d8c71f": { "balance": "940000000000000000000" }, "6d2f976734b9d0070d1883cf7acab8b3e4920fc1": { "balance": "10000000000000000000000" }, "357a02c0a9dfe287de447fb67a70ec5b62366647": { "balance": "26740000000000000000" }, "44a01fb04ac0db2cce5dbe281e1c46e28b39d878": { "balance": "1999944000000000000000" }, "3630c5e565ceaa8a0f0ffe32875eae2a6ce63c19": { "balance": "170016000000000000000" }, "334340ee4b9cdc81f850a75116d50ee9b69825bf": { "balance": "2000000000000000000000" }, "c0afb7d8b79370cfd663c68cc6b9702a37cd9eff": { "balance": "1000000000000000000000" }, "2016895df32c8ed5478269468423aea7b7fbce50": { "balance": "20000000000000000000" }, "1e2fe4e4a77d141ff49a0c7fbc95b0a2b283eeeb": { "balance": "2000000000000000000000" }, "260df8943a8c9a5dba7945327fd7e0837c11ad07": { "balance": "200000000000000000000" }, "32fbeed6f626fcdfd51acafb730b9eeff612f564": { "balance": "2000000000000000000000" }, "9bd88068e13075f3a8cac464a5f949d6d818c0f6": { "balance": "6000000000000000000000" }, "ab4572fbb1d72b575d69ec6ad17333873e8552fc": { "balance": "1999942000000000000000" }, "e44ea51063405154aae736be2bf1ee3b9be639ae": { "balance": "4000000000000000000000" }, "617f20894fa70e94a86a49cd74e03238f64d3cd9": { "balance": "5000057000000000000000" }, "3e914e3018ac00449341c49da71d04dfeeed6221": { "balance": "4000000000000000000000" }, "590181d445007bd0875aaf061c8d51153900836a": { "balance": "2000000000000000000000" }, "27987110221a880826adb2e7ab5eca78c6e31aec": { "balance": "4000000000000000000000" }, "06618e9d5762df62028601a81d4487d6a0ecb80e": { "balance": "1337000000000000000000" }, "8cc652dd13e7fe14dabbb36d5d320db9ffee8a54": { "balance": "1790000000000000000000" }, "8973aefd5efaee96095d9e288f6a046c97374b43": { "balance": "141000000000000000000" }, "dbd51cdf2c3bfacdff106221de2e19ad6d420414": { "balance": "1760000000000000000000" }, "25697ef20cccaa70d32d376f8272d9c1070c3d78": { "balance": "200000000000000000000" }, "0726c42e00f45404836eb1e280d073e7059687f5": { "balance": "1623331000000000000000" }, "5e0785532c7723e4c0af9357d5274b73bdddddde": { "balance": "25000088000000000000000" }, "38430e931d93be01b4c3ef0dc535f1e0a9610063": { "balance": "10000000000000000000000" }, "143d536b8b1cb84f56a39e0bc81fd5442bcacce1": { "balance": "100000000000000000000" }, "5c6d041da7af4487b9dc48e8e1f60766d0a56dbc": { "balance": "1457800000000000000000" }, "f9bfb59d538afc4874d4f5941b08c9730e38e24b": { "balance": "40000000000000000000" }, "83dbfd8eda01d0de8e158b16d0935fc2380a5dc7": { "balance": "600000000000000000000" }, "0e6cd664ad9c1ed64bf98749f40644b626e3792c": { "balance": "60000000000000000000000" }, "ce2e0da8934699bb1a553e55a0b85c169435bea3": { "balance": "4999962000000000000000" }, "a39bfee4aec9bd75bd22c6b672898ca9a1e95d32": { "balance": "10000000000000000000000" }, "1bc44c8761231ba1f11f5faa40fa669a013e12ce": { "balance": "203586000000000000000" }, "68809af5d532a11c1a4d6e32aac75c4c52b08ead": { "balance": "10000000000000000000000" }, "80cc21bd99f39005c58fe4a448909220218f66cb": { "balance": "1000072000000000000000" }, "1080c1d8358a15bc84dac8253c6883319020df2c": { "balance": "2674000000000000000000" }, "9eaf6a328a4076024efa6b67b48b21eedcc0f0b8": { "balance": "158000000000000000000" }, "1e7b5e4d1f572becf2c00fc90cb4767b4a6e33d4": { "balance": "112970000000000000000" }, "acbd185589f7a68a67aa4b1bd65077f8c64e4e21": { "balance": "200000000000000000000" }, "ff78541756ab2b706e0d70b18adb700fc4f1643d": { "balance": "43250000000000000000000" }, "7f0ec3db804692d4d1ea3245365aab0590075bc4": { "balance": "4000000000000000000000" }, "4a918032439159bb315b6725b6830dc83697739f": { "balance": "343800000000000000000" }, "bc1b021a78fde42d9b5226d6ec26e06aa3670090": { "balance": "80000000000000000000" }, "2f2523cc834f0086052402626296675186a8e582": { "balance": "16000000000000000000000" }, "9db2e15ca681f4c66048f6f9b7941ed08b1ff506": { "balance": "4000000000000000000000" }, "20b9a9e6bd8880d9994ae00dd0b9282a0beab816": { "balance": "500000000000000000000" }, "3bddbc8134f77d55597fc97c26d26698090604eb": { "balance": "13700000000000000000" }, "80c3a9f695b16db1597286d1b3a8b7696c39fa27": { "balance": "100000000000000000000" }, "53194d8afa3e883502767edbc30586af33b114d3": { "balance": "2000000000000000000000" }, "e2efd0a9bc407ece03d67e8ec8e9d283f48d2a49": { "balance": "12280000000000000000000" }, "1cb450920078aab2317c7db3b38af7dd298b2d41": { "balance": "340000000000000000000" }, "ca8276c477b4a07b80107b843594189607b53bec": { "balance": "6000000000000000000000" }, "147f4210ab5804940a0b7db8c14c28396b62a6bf": { "balance": "2000000000000000000000" }, "d3df3b53cb3b4755de54e180451cc44c9e8ae0aa": { "balance": "659801000000000000000" }, "f7c708015071d4fb0a3a2a09a45d156396e3349e": { "balance": "3000000000000000000000" }, "a8cafac32280d021020bf6f2a9782883d7aabe12": { "balance": "100000000000000000000" }, "399aa6f5d078cb0970882bc9992006f8fbdf3471": { "balance": "1000000000000000000000" }, "15669180dee29598869b08a721c7d24c4c0ee63f": { "balance": "1000000000000000000000" }, "bba8ab22d2fedbcfc63f684c08afdf1c175090b5": { "balance": "99091000000000000000" }, "5e5a441974a83d74c687ebdc633fb1a49e7b1ad7": { "balance": "3000000000000000000000" }, "98b769cc305cecfb629a00c907069d7ef9bc3a12": { "balance": "26000000000000000000" }, "c820c711f07705273807aaaa6de44d0e4b48be2e": { "balance": "155000000000000000000" }, "12aa7d86ddfbad301692feac8a08f841cb215c37": { "balance": "137000000000000000000" }, "6ff5d361b52ad0b68b1588607ec304ae5665fc98": { "balance": "1940000000000000000000" }, "2382a9d48ec83ea3652890fd0ee79c907b5b2dc1": { "balance": "133700000000000000000" }, "b2a144b1ea67b9510f2267f9da39d3f93de26642": { "balance": "2000000000000000000000" }, "b3e20eb4de18bd060221689894bee5aeb25351ee": { "balance": "73535000000000000000" }, "101a0a64f9afcc448a8a130d4dfcbee89537d854": { "balance": "15200000000000000000000" }, "1b826fb3c012b0d159e294ba5b8a499ff3c0e03c": { "balance": "2000000000000000000000" }, "aafb7b013aa1f8541c7e327bf650adbd194c208f": { "balance": "1358000000000000000000" }, "96eb523e832f500a017de13ec27f5d366c560eff": { "balance": "307600000000000000000" }, "c7bf17c4c11f98941f507e77084fffbd2dbd3db5": { "balance": "1000000000000000000000" }, "840ec83ea93621f034e7bb3762bb8e29ded4c479": { "balance": "2500000000000000000000" }, "0e9c511864a177f49be78202773f60489fe04e52": { "balance": "6000000000000000000000" }, "f6f1a44309051c6b25e47dff909b179bb9ab591c": { "balance": "1940000000000000000000" }, "63fe6bcc4b8a9850abbe75803730c932251f145b": { "balance": "18200000000000000000" }, "f88b58db37420b464c0be88b45ee2b95290f8cfa": { "balance": "40000000000000000000" }, "9d4d321177256ebd9afbda304135d517c3dc5693": { "balance": "616000000000000000000" }, "8c1fbe5f0aea359c5aa1fa08c8895412ca8e05a6": { "balance": "1000000000000000000000" }, "cb0dd7cf4e5d8661f6028943a4b9b75c914436a7": { "balance": "120000000000000000000000" }, "a3979a92760a135adf69d72f75e167755f1cb8c3": { "balance": "100000000000000000000" }, "ca22cda3606da5cad013b8074706d7e9e721a50c": { "balance": "6816200000000000000000" }, "157559adc55764cc6df79323092534e3d6645a66": { "balance": "6000000000000000000000" }, "4f52ad6170d25b2a2e850eadbb52413ff2303e7f": { "balance": "3040000000000000000000" }, "eed28c3f068e094a304b853c950a6809ebcb03e0": { "balance": "17300000000000000000000" }, "2e47f287f498233713850d3126823cc67dcee255": { "balance": "14600000000000000000" }, "6c359e58a13d4578a9338e335c67e7639f5fb4d7": { "balance": "218000000000000000000" }, "4968a2cedb457555a139295aea28776e54003c87": { "balance": "10092310000000000000000" }, "4041374b0feef4792e4b33691fb86897a4ff560c": { "balance": "365000000000000000000" }, "83e48055327c28b5936fd9f4447e73bdb2dd3376": { "balance": "2674000000000000000000" }, "32b7feebc5c59bf65e861c4c0be42a7611a5541a": { "balance": "2212000000000000000000" }, "21a6db6527467bc6dad54bc16e9fe2953b6794ed": { "balance": "14000000000000000000000" }, "e8ead1bb90ccc3aea2b0dcc5b58056554655d1d5": { "balance": "7760000000000000000000" }, "7a94b19992ceb8ce63bc92ee4b5aded10c4d9725": { "balance": "16770000000000000000000" }, "90e93e4dc17121487952333614002be42356498e": { "balance": "1910000000000000000000" }, "aab00abf5828d7ebf26b47ceaccdb8ba03325166": { "balance": "10000000000000000000000" }, "0a9ab2638b1cfd654d25dab018a0aebddf85fd55": { "balance": "21801000000000000000" }, "b12ed07b8a38ad5506363fc07a0b6d799936bdaf": { "balance": "10000000000000000000000" }, "f4a9d00cefa97b7a58ef9417fc6267a5069039ee": { "balance": "21800000000000000000" }, "04a1cada1cc751082ff8da928e3cfa000820a9e9": { "balance": "40000000000000000000" }, "9018cc1f48d2308e252ab6089fb99a7c1d569410": { "balance": "200000000000000000000" }, "895d694e880b13ccd0848a86c5ce411f88476bbf": { "balance": "199955000000000000000" }, "40a7f72867a7dc86770b162b7557a434ed50cce9": { "balance": "1000000000000000000000" }, "467ea10445827ef1e502daf76b928a209e0d4032": { "balance": "2000000000000000000000" }, "7553aa23b68aa5f57e135fe39fdc235eaca8c98c": { "balance": "1000000000000000000000" }, "31b43b015d0081643c6cda46a7073a6dfdbca825": { "balance": "50019600000000000000000" }, "d82fd9fdf6996bedad2843159c06f37e0924337d": { "balance": "1688800000000000000000" }, "24a4eb36a7e498c36f99975c1a8d729fd6b305d7": { "balance": "258000000000000000000" }, "91d66ea6288faa4b3d606c2aa45c7b6b8a252739": { "balance": "2000000000000000000000" }, "83a402438e0519773d5448326bfb61f8b20cf52d": { "balance": "1520000000000000000000" }, "c2fafdd30acb6d6706e9293cb02641f9edbe07b5": { "balance": "1494224000000000000000" }, "79dba256472db4e058f2e4cdc3ea4e8a42773833": { "balance": "1460000000000000000000" }, "498abdeb14c26b7b7234d70fceaef361a76dff72": { "balance": "3000000000000000000000" }, "7b73242d75ca9ad558d650290df17692d54cd8b8": { "balance": "2000200000000000000000" }, "6ec3659571b11f889dd439bcd4d67510a25be57e": { "balance": "123000000000000000000" }, "ab098633eeee0ccefdf632f9575456f6dd80fc86": { "balance": "200000000000000000000000" }, "f4a51fce4a1d5b94b0718389ba4e7814139ca738": { "balance": "300000000000000000000" }, "8f561b41b209f248c8a99f858788376250609cf3": { "balance": "1700000000000000000000" }, "05d0f4d728ebe82e84bf597515ad41b60bf28b39": { "balance": "4200000000000000000000" }, "dfdf43393c649caebe1bb18059decb39f09fb4e8": { "balance": "400000000000000000000" }, "0089508679abf8c71bf6781687120e3e6a84584d": { "balance": "1800000000000000000000" }, "80907f593148b57c46c177e23d25abc4aae18361": { "balance": "100000000000000000000" }, "94fcceadfe5c109c5eaeaf462d43873142c88e22": { "balance": "4800000000000000000000" }, "e89249738b7eced7cb666a663c49cbf6de8343ea": { "balance": "2000000000000000000000" }, "23c99ba087448e19c9701df66e0cab52368331fa": { "balance": "2000000000000000000000" }, "a68e0c30cba3bc5a883e540320f999c7cd558e5c": { "balance": "1799869000000000000000" }, "88888a57bd9687cbf950aeeacf9740dcc4d1ef59": { "balance": "1820000000000000000000" }, "e9b36fe9b51412ddca1a521d6e94bc901213dda8": { "balance": "10000000000000000000000" }, "a9145046fa3628cf5fd4c613927be531e6db1fdd": { "balance": "112000000000000000000" }, "e82c58c579431b673546b53a86459acaf1de9b93": { "balance": "1000000000000000000000" }, "bd6a474d66345bcdd707594adb63b30c7822af54": { "balance": "4000000000000000000000" }, "6a6159074ab573e0ee581f0f3df2d6a594629b74": { "balance": "310000000000000000000" }, "2e7f465520ec35cc23d68e75651bb6689544a196": { "balance": "1050049000000000000000" }, "ac6d02e9a46b379fac4ac9b1d7b5d47bc850ce16": { "balance": "1760000000000000000000" }, "bd59094e074f8d79142ab1489f148e32151f2089": { "balance": "20000000000000000000" }, "0ba6e46af25a13f57169255a34a4dac7ce12be04": { "balance": "500000000000000000000" }, "35145f620397c69cb8e00962961f0f4886643989": { "balance": "6000000000000000000000" }, "d84b922f7841fc5774f00e14604ae0df42c8551e": { "balance": "4011000000000000000000" }, "44232ff66ddad1fd841266380036afd7cf7d7f42": { "balance": "200000000000000000000" }, "516954025fca2608f47da81c215eedfd844a09ff": { "balance": "382000000000000000000" }, "e5aa0b833bb916dc19a8dd683f0ede241d988eba": { "balance": "3000000000000000000000" }, "80ea1acc136eca4b68c842a95adf6b7fee7eb8a2": { "balance": "4000000000000000000000" }, "98a0e54c6d9dc8be96276cebf4fec460f6235d85": { "balance": "1969803000000000000000" }, "91620f3eb304e813d28b0297556d65dc4e5de5aa": { "balance": "3820000000000000000000" }, "7bb984c6dbb9e279966afafda59c01d02627c804": { "balance": "8050000000000000000000" }, "41f489a1ec747bc29c3e5f9d8db97877d4d1b4e9": { "balance": "133700000000000000000" }, "8dbc3e6cb433e194f40f82b40faadb1f8b856116": { "balance": "1910000000000000000000" }, "889da40fb1b60f9ea9bd7a453e584cf7b1b4d9f7": { "balance": "40000000000000000000" }, "debbdd831e0f20ae6e378252decdf92f7cf0c658": { "balance": "2000000000000000000000" }, "a22ade0ddb5c6ef8d0cd8de94d82b11082cb2e91": { "balance": "1020000000000000000000" }, "823219a25976bb2aa4af8bad41ac3526b493361f": { "balance": "2000000000000000000000" }, "6d39a9e98f81f769d73aad2cead276ac1387babe": { "balance": "394000000000000000000" }, "751abcb6cc033059911815c96fd191360ab0442d": { "balance": "8000000000000000000000" }, "64d80c3b8ba68282290b75e65d8978a15a87782c": { "balance": "1970000000000000000000" }, "6ba8f7e25fc2d871618e24e40184199137f9f6aa": { "balance": "400020000000000000000" }, "25a74c2ac75dc8baa8b31a9c7cb4b7829b2456da": { "balance": "2000000000000000000000" }, "0f7b61c59b016322e8226cafaee9d9e76d50a1b3": { "balance": "4000000000000000000000" }, "7526e482529f0a14eec98871dddd0e721b0cd9a2": { "balance": "20000000000000000000" }, "071dd90d14d41f4ff7c413c24238d3359cd61a07": { "balance": "36400000000000000000000" }, "a986762f7a4f294f2e0b173279ad2c81a2223458": { "balance": "20000000000000000000" }, "e667f652f957c28c0e66d0b63417c80c8c9db878": { "balance": "601650000000000000000" }, "7b98e23cb96beee80a168069ebba8f20edd55ccf": { "balance": "214500000000000000000" }, "2d8e5bb8d3521695c77e7c834e0291bfacee7408": { "balance": "1970000000000000000000" }, "f23d01589eb12d439f7448ff54307529f191858d": { "balance": "2000000000000000000000" }, "abd9605b3e91acfd777830d16463478ae0fc7720": { "balance": "133700000000000000000" }, "eabb90d37989aab31feae547e0e6f3999ce6a35d": { "balance": "2000000000000000000000" }, "0abfb39b11486d79572866195ba26c630b6784db": { "balance": "121500000000000000000000" }, "d56a144d7af0ae8df649abae535a15983aa04d02": { "balance": "5000000000000000000000" }, "998c1f93bcdb6ff23c10d0dc924728b73be2ff9f": { "balance": "1002750000000000000000" }, "bc62b3096a91e7dc11a1592a293dd2542150d751": { "balance": "1000000000000000000000" }, "0c8f66c6017bce5b20347204b602b743bad78d60": { "balance": "2000000000000000000000" }, "4c5b3dc0e2b9360f91289b1fe13ce12c0fbda3e1": { "balance": "2000000000000000000000" }, "b44605552471a6eee4daab71ff3bb41326d473e0": { "balance": "839200000000000000000" }, "fc3d226bb36a58f526568857b0bb12d109ec9301": { "balance": "2000000000000000000000" }, "adc8228ef928e18b2a807d00fb3c6c79cd1d9e96": { "balance": "22800000000000000000" }, "9df32a501c0b781c0281022f42a1293ffd7b892a": { "balance": "9000000000000000000000" }, "e7da609d40cde80f00ce5b4ffb6aa9d0b03494fc": { "balance": "1000000000000000000000" }, "9b64d3cd8d2b73f66841b5c46bb695b88a9ab75d": { "balance": "20769000000000000000" }, "8e9c08f738661f9676236eff82ba6261dd3f4822": { "balance": "100000000000000000000" }, "deb97254474c0d2f5a7970dcdb2f52fb1098b896": { "balance": "1000000000000000000000" }, "b4256273962bf631d014555cc1da0dcc31616b49": { "balance": "2000000000000000000000" }, "23abd9e93e7957e5b636be6579051c15e5ce0b0e": { "balance": "17188400000000000000000" }, "382591e7217b435e8e884cdbf415fe377a6fe29e": { "balance": "8022000000000000000000" }, "f17adb740f45cbbde3094e7e13716f8103f563bd": { "balance": "2000000000000000000000" }, "61ed5596c697207f3d55b2a51aa7d50f07fa09e8": { "balance": "2000000000000000000000" }, "788e809741a3b14a22a4b1d937c82cfea489eebe": { "balance": "7000000000000000000000" }, "992646ac1acaabf5ddaba8f9429aa6a94e7496a7": { "balance": "1000110000000000000000" }, "51296f5044270d17707646129c86aad1645eadc1": { "balance": "1337133000000000000000" }, "6ee8aad7e0a065d8852d7c3b9a6e5fdc4bf50c00": { "balance": "20000000000000000000" }, "30db6b9b107e62102f434a9dd0960c2021f5ce4c": { "balance": "599742000000000000000" }, "63fc93001305adfbc9b85d29d9291a05f8f1410b": { "balance": "1000000000000000000000" }, "df6ed6006a6abe886ed33d95a4de28fc12183927": { "balance": "910000000000000000000" }, "4745ab181a36aa8cbf2289d0c45165bc7ebe2381": { "balance": "39400000000000000000" }, "7bb0fdf5a663b5fba28d9c902af0c811e252f298": { "balance": "200000000000000000000" }, "e0ff0bd9154439c4a5b7233e291d7d868af53f33": { "balance": "396110000000000000000" }, "09261f9acb451c3788844f0c1451a35bad5098e3": { "balance": "8664000000000000000000" }, "2813d263fc5ff2479e970595d6b6b560f8d6d6d1": { "balance": "2000000000000000000000" }, "2cd19694d1926a0fa9189edebafc671cf1b2caa5": { "balance": "1000000000000000000000" }, "05336e9a722728d963e7a1cf2759fd0274530fca": { "balance": "915583000000000000000" }, "e5b7af146986c0ff8f85d22e6cc334077d84e824": { "balance": "2000000000000000000000" }, "3e4fbd661015f6461ed6735cefef01f31445de3a": { "balance": "16200000000000000000000" }, "4f5df5b94357de948604c51b7893cddf6076baad": { "balance": "3760000000000000000000" }, "9567a0de811de6ff095b7ee64e7f1b83c2615b80": { "balance": "267400000000000000000" }, "955db3b74360b9a268677e73cea821668af6face": { "balance": "30000000000000000000000" }, "3e040d40cb80ba0125f3b15fdefcc83f3005da1b": { "balance": "1038000000000000000000" }, "43f470ed659e2991c375957e5ddec5bd1d382231": { "balance": "100000000000000000000" }, "047f9bf1529daf87d407175e6f171b5e59e9ff3e": { "balance": "650000000000000000000" }, "15e3b584056b62c973cf5eb096f1733e54c15c91": { "balance": "936702000000000000000" }, "c03de42a109b657a64e92224c08dc1275e80d9b2": { "balance": "20000000000000000000" }, "e4fc13cfcbac1b17ce7783acd423a845943f6b3a": { "balance": "20000000000000000000" }, "65ff874fafce4da318d6c93d57e2c38a0d73e820": { "balance": "1000160000000000000000" }, "8b997dbc078ad02961355da0a159f2927ed43d64": { "balance": "197000000000000000000" }, "2f5080b83f7e2dc0a1dd11b092ad042bff788f4c": { "balance": "3338355000000000000000" }, "1b3920d001c43e72b24e7ca46f0fd6e0c20a5ff2": { "balance": "2000000000000000000000" }, "5ade77fd81c25c0af713b10702768c1eb2f975e7": { "balance": "20000000000000000000" }, "acaaddcbf286cb0e215dda55598f7ff0f4ada5c6": { "balance": "1000000000000000000000" }, "64e0217a5b38aa40583625967fa9883690388b6f": { "balance": "200000000000000000000" }, "ae648155a658370f929be384f7e001047e49dd46": { "balance": "13561000000000000000000" }, "f7c1b443968b117b5dd9b755572fcd39ca5ec04b": { "balance": "456082000000000000000" }, "de027efbb38503226ed871099cb30bdb02af1335": { "balance": "1000000000000000000000" }, "49cf1e54be363106b920729d2d0ba46f0867989a": { "balance": "268000000000000000000" }, "e7f4d7fe6f561f7fa1da3005fd365451ad89df89": { "balance": "200000000000000000000" }, "b036916bdacf94b69e5a8a65602975eb026104dd": { "balance": "20000000000000000000" }, "e923c06177b3427ea448c0a6ff019b54cc548d95": { "balance": "36281000000000000000" }, "ad927e03d1599a78ca2bf0cad2a183dceb71eac0": { "balance": "1970000000000000000000" }, "ef39ca9173df15531d73e6b72a684b51ba0f2bb4": { "balance": "1598000000000000000000" }, "6443b8ae639de91cf73c5ae763eeeed3ddbb9253": { "balance": "2000000000000000000000" }, "8026435aac728d497b19b3e7e57c28c563954f2b": { "balance": "1730000000000000000000" }, "ed327a14d5cfadd98103fc0999718d7ed70528ea": { "balance": "1440000000000000000000" }, "38a3dccf2fcfe0c91a2624bd0cbf88ee4a076c33": { "balance": "2000000000000000000000" }, "f0b1f9e27832c6de6914d70afc238c749995ace4": { "balance": "2000000000000000000000" }, "770d98d31b4353fceee8560c4ccf803e88c0c4e0": { "balance": "600000000000000000000" }, "ba1f0e03cb9aa021f4dcebfa94e5c889c9c7bc9e": { "balance": "32200000000000000000000" }, "233842b1d0692fd11140cf5acda4bf9630bae5f8": { "balance": "2000000000000000000000" }, "b5dd50a15da34968890a53b4f13fe1af081baaaa": { "balance": "4000000000000000000000" }, "72072a0ef1cff3d567cdd260e708ddc11cbc9a31": { "balance": "100000000000000000000" }, "81a88196fac5f23c3e12a69dec4b880eb7d97310": { "balance": "2000000000000000000000" }, "6c63f84556d290bfcd99e434ee9997bfd779577a": { "balance": "2000000000000000000000" }, "5f167aa242bc4c189adecb3ac4a7c452cf192fcf": { "balance": "1999980000000000000000" }, "445cb8de5e3df520b499efc980f52bff40f55c76": { "balance": "2000000000000000000000" }, "aec27ce2133e82d052520afb5c576d9f7eb93ed2": { "balance": "65232380000000000000000" }, "07dc2bf83bc6af19a842ffea661af5b41b67fda1": { "balance": "1500000000000000000000" }, "febd48d0ffdbd5656cd5e686363a61145228f279": { "balance": "2800000000000000000000" }, "a86db07d9f812f4796622d40e03d135874a88a74": { "balance": "20000000000000000000" }, "5413c97ffa4a6e2a7bba8961dc9fce8530a787d7": { "balance": "1000000000000000000000" }, "e2ff9ee4b6ecc14141cc74ca52a9e7a2ee14d908": { "balance": "1400000000000000000000" }, "2e8eb30a716e5fe15c74233e039bfb1106e81d12": { "balance": "100000000000000000000" }, "fd88d114220f081cb3d5e15be8152ab07366576a": { "balance": "300000000000000000000" }, "e408fceaa1b98f3c640f48fcba39f056066d6308": { "balance": "10000000000000000000000" }, "057dd29f2d19aa3da42327ea50bce86ff5c911d9": { "balance": "4000000000000000000000" }, "ed1065dbcf9d73c04ffc7908870d881468c1e132": { "balance": "2000000000000000000000" }, "bbc9d8112e5beb02dd29a2257b1fe69b3536a945": { "balance": "2000000000000000000000" }, "79c1be19711f73bee4e6316ae7549459aacea2e0": { "balance": "400000000000000000000" }, "1bcf3441a866bdbe963009ce33c81cbb0261b02c": { "balance": "182000000000000000000" }, "e2e26e4e1dcf30d048cc6ecf9d51ec1205a4e926": { "balance": "4000000000000000000000" }, "77701e2c493da47c1b58f421b5495dee45bea39b": { "balance": "6068279000000000000000" }, "37a05aceb9395c8635a39a7c5d266ae610d10bf2": { "balance": "30000000000000000000000" }, "c6355ec4768c70a49af69513cd83a5bca7e3b9cd": { "balance": "6000000000000000000000" }, "e3c0c128327a9ad80148139e269773428e638cb0": { "balance": "2000000000000000000000" }, "f7f4898c4c526d955f21f055cb6e47b915e51964": { "balance": "2288000000000000000000" }, "29824e94cc4348bc963279dcdf47391715324cd3": { "balance": "1940000000000000000000" }, "eaa45cea02d87d2cc8fda9434e2d985bd4031584": { "balance": "1920750000000000000000" }, "e08b9aba6bd9d28bc2056779d2fbf0f2855a3d9d": { "balance": "2000000000000000000000" }, "87c498170934b8233d1ad1e769317d5c475f2f40": { "balance": "1015200000000000000000" }, "352d29a26e8a41818181746467f582e6e84012e0": { "balance": "6000000000000000000000" }, "403220600a36f73f24e190d1edb2d61be3f41354": { "balance": "304000000000000000000" }, "0a48296f7631708c95d2b74975bc4ab88ac1392a": { "balance": "5000000000000000000000" }, "ffe0e997f1977a615f5a315af413fd4869343ba0": { "balance": "100076000000000000000" }, "ca66b2280fa282c5b67631ce552b62ee55ad8474": { "balance": "1969488000000000000000" }, "2b6ed29a95753c3ad948348e3e7b1a251080ffb9": { "balance": "250000000000000000000000" }, "492e70f04d18408cb41e25603730506b35a2876b": { "balance": "39400000000000000000" }, "0e6baaa3deb989f289620076668618e9ac332865": { "balance": "200000000000000000000" }, "b753a75f9ed10b21643a0a3dc0517ac96b1a4068": { "balance": "401800000000000000000" }, "3ad915d550b723415620f5a9b5b88a85f382f035": { "balance": "1000000000000000000000" }, "c992be59c6721caf4e028f9e8f05c25c55515bd4": { "balance": "20000000000000000000" }, "02b643d6fabd437a851accbe79abb7fde126dccf": { "balance": "7200000000000000000000" }, "88797e58675ed5cc4c19980783dbd0c956085153": { "balance": "2000000000000000000000" }, "ac142eda1157b9a9a64390df7e6ae694fac98905": { "balance": "200000000000000000000" }, "656579daedd29370d9b737ee3f5cd9d84bc2b342": { "balance": "1430000000000000000000" }, "9bb9b02a26bfe1ccc3f0c6219e261c397fc5ca78": { "balance": "1337000000000000000000" }, "bee8d0b008421954f92d000d390fb8f8e658eaee": { "balance": "1000000000000000000000" }, "7989d09f3826c3e5af8c752a8115723a84d80970": { "balance": "415554000000000000000" }, "7cd5d81eab37e11e6276a3a1091251607e0d7e38": { "balance": "62856000000000000000" }, "6ce1b0f6adc47051e8ab38b39edb4186b03babcc": { "balance": "1207800000000000000000" }, "abfcf5f25091ce57875fc674dcf104e2a73dd2f2": { "balance": "19700000000000000000" }, "1c3ef05dae9dcbd489f3024408669de244c52a02": { "balance": "20000000000000000000000" }, "cfa8b37127149bdbfee25c34d878510951ea10eb": { "balance": "2000000000000000000000" }, "74863acec75d03d53e860e64002f2c165e538377": { "balance": "1000000000000000000000" }, "59b9e733cba4be00429b4bd9dfa64732053a7d55": { "balance": "20000000000000000000" }, "aeadfcd0978edad74a32bd01a0a51d37f246e661": { "balance": "260000000000000000000" }, "08090876baadfee65c3d363ba55312748cfa873d": { "balance": "1700170000000000000000" }, "e589fa76984db5ec4004b46ee8a59492c30744ce": { "balance": "2800000000000000000000" }, "3485361ee6bf06ef6508ccd23d94641f814d3e2f": { "balance": "2000000000000000000000" }, "5cb731160d2e8965670bde925d9de5510935347d": { "balance": "40000000000000000000" }, "8ef4d8a2c23c5279187b64e96f741404085385f3": { "balance": "299598000000000000000" }, "e246683cc99db7c4a52bcbacaab0b32f6bfc93d7": { "balance": "2000000000000000000000" }, "7d273e637ef1eac481119413b91c989dc5eac122": { "balance": "500000000000000000000" }, "6efba8fb2ac5b6730729a972ec224426a287c3ad": { "balance": "283152000000000000000" }, "0773eeacc050f74720b4a1bd57895b1cceeb495d": { "balance": "10000000000000000000000" }, "88a122a2382c523931fb51a0ccad3beb5b7259c3": { "balance": "2000000000000000000000" }, "b0b779b94bfa3c2e1f587bcc9c7e21789222378f": { "balance": "1550000000000000000000" }, "86f95c5b11a293940e35c0b898d8b75f08aab06d": { "balance": "29605000000000000000000" }, "cf2288ef4ebf88e86db13d8a0e0bf52a056582c3": { "balance": "2533000000000000000000" }, "71ea5b11ad8d29b1a4cb67bf58ca6c9f9c338c16": { "balance": "1600000000000000000000" }, "9917d68d4af341d651e7f0075c6de6d7144e7409": { "balance": "5660000000000000000000" }, "1e5800227d4dcf75e30f5595c5bed3f72e341e3b": { "balance": "248300000000000000000" }, "123759f333e13e3069e2034b4f05398918119d36": { "balance": "20000000000000000000000" }, "f798d16da4e460c460cd485fae0fa0599708eb82": { "balance": "1000000000000000000000" }, "864bec5069f855a4fd5892a6c4491db07c88ff7c": { "balance": "1000000000000000000000" }, "fa283299603d8758e8cab082125d2c8f7d445429": { "balance": "6415633000000000000000" }, "c811c2e9aa1ac3462eba5e88fcb5120e9f6e2ca2": { "balance": "1400140000000000000000" }, "61547d376e5369bcf978fc162c3c56ae453547e8": { "balance": "200000000000000000000" }, "0d747ee5969bf79d57381d6fe3a2406cd0d8ce27": { "balance": "100000000000000000000000" }, "f8962b75db5d24c7e8b7cef1068c3e67cebb30a5": { "balance": "280000000000000000000" }, "35bf6688522f35467a7f75302314c02ba176800e": { "balance": "17400000000000000000000" }, "05cb6c3b0072d3116761b532b218443b53e8f6c5": { "balance": "141722000000000000000000" }, "91c80caa081b38351d2a0e0e00f80a34e56474c1": { "balance": "1000000000000000000000" }, "d75a502a5b677287470f65c5aa51b87c10150572": { "balance": "907400000000000000000" }, "3e194b4ecef8bb711ea2ff24fec4e87bd032f7d1": { "balance": "2575465000000000000000" }, "736bf1402c83800f893e583192582a134eb532e9": { "balance": "9999996000000000000000" }, "c2cb1ada5da9a0423873814793f16144ef36b2f3": { "balance": "1334326000000000000000" }, "efcce06bd6089d0e458ef561f5a689480afe7000": { "balance": "600000000000000000000" }, "bfe6bcb0f0c07852643324aa5df5fd6225abc3ca": { "balance": "74500000000000000000" }, "9d799e943e306ba2e5b99c8a6858cbb52c0cf735": { "balance": "300000000000000000000" }, "f45b1dcb2e41dc27ffa024daadf619c11175c087": { "balance": "19700000000000000000" }, "08e38ee0ce48c9ca645c1019f73b5355581c56e6": { "balance": "1600000000000000000000" }, "2cb4c3c16bb1c55e7c6b7a19b127a1ac9390cc09": { "balance": "3397053000000000000000" }, "bdc02cd4330c93d6fbda4f6db2a85df22f43c233": { "balance": "2000000000000000000000" }, "acec91ef6941cf630ba9a3e787a012f4a2d91dd4": { "balance": "80000000000000000000000" }, "27ac073be79ce657a93aa693ee43bf0fa41fef04": { "balance": "50000000000000000000000" }, "22fe884d9037291b4d52e6285ae68dea0be9ffb5": { "balance": "2000000000000000000000" }, "c3107a9af3322d5238df0132419131629539577d": { "balance": "492650000000000000000" }, "b5cac5ed03477d390bb267d4ebd46101fbc2c3da": { "balance": "197000000000000000000" }, "58fb947364e7695765361ebb1e801ffb8b95e6d0": { "balance": "200000000000000000000" }, "32860997d730b2d83b73241a25d3667d51c908ef": { "balance": "499938000000000000000" }, "c79d5062c796dd7761f1f13e558d73a59f82f38b": { "balance": "8000000000000000000000" }, "fa142fe47eda97e6503b386b18a2bedd73ccb5b1": { "balance": "850080000000000000000" }, "6ca5de00817de0cedce5fd000128dede12648b3c": { "balance": "20000000000000000000" }, "214b743955a512de6e0d886a8cbd0282bee6d2a2": { "balance": "2000000000000000000000" }, "ede79ae1ff4f1606d59270216fa46ab2ddd4ecaa": { "balance": "146000000000000000000" }, "528101ce46b720a2214dcdae6618a53177ffa377": { "balance": "508876000000000000000" }, "b5870ce342d43343333673038b4764a46e925f3e": { "balance": "1000000000000000000000" }, "843bd3502f45f8bc4da370b323bdac3fcf5f19a6": { "balance": "1476000000000000000000" }, "5067f4549afbfe884c59cbc12b96934923d45db0": { "balance": "1000000000000000000000" }, "6f2a42e6e033d01061131929f7a6ee1538021e52": { "balance": "2000000000000000000000" }, "e9e1f7cb00a110edd0ebf8b377ef8a7bb856117f": { "balance": "200000000000000000000" }, "a387ecde0ee4c8079499fd8e03473bd88ad7522a": { "balance": "1970000000000000000000" }, "6dff90e6dc359d2590882b1483edbcf887c0e423": { "balance": "1000000000000000000000" }, "22e512149a18d369b73c71efa43e86c9edabaf1d": { "balance": "1455000000000000000000" }, "a3203095edb7028e6871ce0a84f548459f83300a": { "balance": "4000000000000000000000" }, "93b4bf3fdff6de3f4e56ba6d7799dc4b93a6548f": { "balance": "19100000000000000000" }, "8c75956e8fed50f5a7dd7cfd27da200f6746aea6": { "balance": "1000000000000000000000" }, "afc8ebe8988bd4105acc4c018e546a1e8f9c7888": { "balance": "500000000000000000000" }, "bf9acd4445d9c9554689cabbbab18800ff1741c2": { "balance": "1000000000000000000000" }, "603f2fab7afb6e017b94766069a4b43b38964923": { "balance": "1656954000000000000000" }, "a1f765c44fe45f790677944844be4f2d42165fbd": { "balance": "3687750000000000000000" }, "4dc9d5bb4b19cecd94f19ec25d200ea72f25d7ed": { "balance": "2000000000000000000000" }, "48f60a35484fe7792bcc8a7b6393d0dda1f6b717": { "balance": "3600000000000000000000" }, "588ed990a2aff44a94105d58c305257735c868ac": { "balance": "16100000000000000000000" }, "710be8fd5e2918468be2aabea80d828435d79612": { "balance": "17600000000000000000" }, "03ea6d26d080e57aee3926b18e8ed73a4e5b2826": { "balance": "200000000000000000000" }, "20824ba1dbebbef9846ef3d0f6c1b017e6912ec4": { "balance": "7170194000000000000000" }, "f7500c166f8bea2f82347606e5024be9e4f4ce99": { "balance": "20000000000000000000" }, "9d369165fb70b81a3a765f188fd60cbe5e7b0968": { "balance": "2000000000000000000000" }, "6fddbd9bca66e28765c2162c8433548c1052ed11": { "balance": "82720000000000000000000" }, "8b81156e698639943c01a75272ad3d35851ab282": { "balance": "344946000000000000000" }, "75804aac64b4199083982902994d9c5ed8828f11": { "balance": "557800000000000000000" }, "d6e8e97ae9839b9ee507eedb28edfb7477031439": { "balance": "2000000000000000000000" }, "6c808cabb8ff5fbb6312d9c8e84af8cf12ef0875": { "balance": "4000086000000000000000" }, "afa539586e4719174a3b46b9b3e663a7d1b5b987": { "balance": "5000000000000000000000" }, "f8a065f287d91d77cd626af38ffa220d9b552a2b": { "balance": "1910000000000000000000" }, "30e60900cacc7203f314dc604347255167fc2a0f": { "balance": "2000000000000000000000" }, "796f87ba617a2930b1670be92ed1281fb0b346e1": { "balance": "128400000000000000000" }, "f114ff0d0f24eff896edde5471dea484824a99b3": { "balance": "13700000000000000000" }, "0b80fc70282cbdd5fde35bf78984db3bdb120188": { "balance": "1000160000000000000000" }, "da7ad025ebde25d22243cb830ea1d3f64a566323": { "balance": "500000000000000000000" }, "65a52141f56bef98991724c6e7053381da8b5925": { "balance": "60140000000000000000" }, "bbc8eaff637e94fcc58d913c7770c88f9b479277": { "balance": "200000000000000000000" }, "0469e8c440450b0e512626fe817e6754a8152830": { "balance": "2000000000000000000000" }, "0727be0a2a00212048b5520fbefb953ebc9d54a0": { "balance": "10000000000000000000000" }, "7d858493f07415e0912d05793c972113eae8ae88": { "balance": "1818000000000000000000" }, "7091303116d5f2389b23238b4d656a8596d984d3": { "balance": "1094014000000000000000" }, "3702e704cc21617439ad4ea27a5714f2fda1e932": { "balance": "1000000000000000000000" }, "b87de1bcd29269d521b8761cc39cfb4319d2ead5": { "balance": "1000000000000000000000" }, "f639ac31da9f67271bd10402b7654e5ce763bd47": { "balance": "399996000000000000000" }, "e7735ec76518fc6aa92da8715a9ee3f625788f13": { "balance": "1997803000000000000000" }, "51277fe7c81eebd252a03df69a6b9f326e272207": { "balance": "59965000000000000000" }, "3b8098533f7d9bdcd307dbb23e1777ca18418936": { "balance": "2000000000000000000000" }, "2cba6d5d0dc204ea8a25ada2e26f5675bd5f2fdc": { "balance": "1330755000000000000000" }, "5c3c1c645b917543113b3e6c1c054da1fe742b9a": { "balance": "800000000000000000000" }, "5ecdbaeab9106ffe5d7b519696609a05baeb85ad": { "balance": "20000000000000000000" }, "45a820a0672f17dc74a08112bc643fd1167736c3": { "balance": "199943000000000000000" }, "beef94213879e02622142bea61290978939a60d7": { "balance": "5728109000000000000000" }, "6cd212aee04e013f3d2abad2a023606bfb5c6ac7": { "balance": "1999944000000000000000" }, "92698e345378c62d8eda184d94366a144b0c105b": { "balance": "1400000000000000000000" }, "2d5b42fc59ebda0dfd66ae914bc28c1b0a6ef83a": { "balance": "206764195000000000000000" }, "b7a6791c16eb4e2162f14b6537a02b3d63bfc602": { "balance": "780700000000000000000" }, "fa105f1a11b6e4b1f56012a27922e2ac2da4812f": { "balance": "9550000000000000000000" }, "2306df931a940d58c01665fa4d0800802c02edfe": { "balance": "1000000000000000000000" }, "f37bf78c5875154711cb640d37ea6d28cfcb1259": { "balance": "200000000000000000000" }, "66201bd227ae6dc6bdfed5fbde811fecfe5e9dd9": { "balance": "594808000000000000000" }, "2bafbf9e9ed2c219f7f2791374e7d05cb06777e7": { "balance": "220000000000000000000" }, "8e9b35ad4a0a86f758446fffde34269d940ceacd": { "balance": "4000000000000000000000" }, "1b43232ccd4880d6f46fa751a96cd82473315841": { "balance": "80000000000000000000" }, "6eefdc850e87b715c72791773c0316c3559b58a4": { "balance": "4000000000000000000000" }, "f2c03e2a38998c21648760f1e5ae7ea3077d8522": { "balance": "2642456000000000000000" }, "0625d06056968b002206ff91980140242bfaa499": { "balance": "1000000000000000000000" }, "6158e107c5eb54cb7604e0cd8dc1e07500d91c3c": { "balance": "50000000000000000000" }, "02477212ffdd75e5155651b76506b1646671a1eb": { "balance": "1760000000000000000000" }, "fa44a855e404c86d0ca8ef3324251dfb349c539e": { "balance": "1552000000000000000000" }, "49897fe932bbb3154c95d3bce6d93b6d732904dd": { "balance": "4000000000000000000000" }, "9b6641b13e172fc072ca4b8327a3bc28a15b66a9": { "balance": "120000000000000000000" }, "a46b4387fb4dcce011e76e4d73547d4481e09be5": { "balance": "1337000000000000000000" }, "72bb27cb99f3e2c2cf90a98f707d30e4a201a071": { "balance": "1640000000000000000000" }, "b6bfe1c3ef94e1846fb9e3acfe9b50c3e9069233": { "balance": "1999944000000000000000" }, "e6cb3f3124c9c9cc3834b1274bc3336456a38bac": { "balance": "427382000000000000000" }, "fcbc5c71ace79741450b012cf6b8d3f17db68a70": { "balance": "9550000000000000000000" }, "15dbb48c98309764f99ced3692dcca35ee306bac": { "balance": "150000000000000000000000" }, "2e10910ba6e0bc17e055556614cb87090f4d7e5b": { "balance": "200000000000000000000" }, "e5fbe34984b637196f331c679d0c0c47d83410e1": { "balance": "2000050000000000000000" }, "6d120f0caae44fd94bcafe55e2e279ef96ba5c7a": { "balance": "4000000000000000000000" }, "aa5afcfd8309c2df9d15be5e6a504e7d706624c5": { "balance": "5846763000000000000000" }, "37959c20b7e9931d72f5a8ae869dafddad3b6d5c": { "balance": "200000000000000000000" }, "b041310fe9eed6864cedd4bee58df88eb4ed3cac": { "balance": "10000000000000000000000" }, "986df47e76e4d7a789cdee913cc9831650936c9d": { "balance": "5000000000000000000000" }, "35aaa0465d1c260c420fa30e2629869fb6559207": { "balance": "704976000000000000000" }, "7f655c6789eddf455cb4b88099720639389eebac": { "balance": "6000000000000000000000" }, "9e3eb509278fe0dcd8e0bbe78a194e06b6803943": { "balance": "940000000000000000000" }, "3e9410d3b9a87ed5e451a6b91bb8923fe90fb2b5": { "balance": "200000000000000000000" }, "9e960dcd03d5ba99cb115d17ff4c09248ad4d0be": { "balance": "200000000000000000000" }, "f057aa66ca767ede124a1c5b9cc5fc94ef0b0137": { "balance": "2077730000000000000000" }, "f38a6ca80168537e974d14e1c3d13990a44c2c1b": { "balance": "6000000000000000000000" }, "229e430de2b74f442651ddcdb70176bc054cad54": { "balance": "13545000000000000000" }, "27bf9f44ba7d05c33540c3a53bb02cbbffe7c3c6": { "balance": "2000000000000000000000" }, "10389858b800e8c0ec32f51ed61a355946cc409b": { "balance": "200000000000000000000" }, "fd2929271e9d2095a264767e7b0df52ea0d1d400": { "balance": "3000040000000000000000" }, "44250d476e062484e9080a3967bf3a4a732ad73f": { "balance": "20000000000000000000" }, "0c67033dd8ee7f0c8ae534d42a51f7d9d4f7978f": { "balance": "200000000000000000000" }, "e083d34863e0e17f926b7928edff317e998e9c4b": { "balance": "400000000000000000000" }, "7f7192c0df1c7db6d9ed65d71184d8e4155a17ba": { "balance": "79800000000000000000" }, "51e7b55c2f9820eed73884361b5066a59b6f45c6": { "balance": "2000000000000000000000" }, "4fa983bb5e3073a8edb557effeb4f9fb1d60ef86": { "balance": "1599800000000000000000" }, "5a5ee8e9bb0e8ab2fecb4b33d29478be50bbd44b": { "balance": "776000000000000000000" }, "1f3959fc291110e88232c36b7667fc78a379613f": { "balance": "18200000000000000000" }, "2d7d5c40ddafc450b04a74a4dabc2bb5d665002e": { "balance": "2000000000000000000000" }, "5215183b8f80a9bc03d26ce91207832a0d39e620": { "balance": "1000000000000000000000" }, "5607590059a9fec1881149a44b36949aef85d560": { "balance": "2000000000000000000000" }, "f7c50f922ad16b61c6d1baa045ed816815bac48f": { "balance": "12566370000000000000000" }, "da10978a39a46ff0bb848cf65dd9c77509a6d70e": { "balance": "2000000000000000000000" }, "a7dcbba9b9bf6762c145416c506a71e3b497209c": { "balance": "1999944000000000000000" }, "54e01283cc8b384538dd646770b357c960d6cacd": { "balance": "5000000000000000000000" }, "78cf8336b328db3d87813a472b9e89b75e0cf3bc": { "balance": "1000000000000000000000" }, "ba24fc436753a739db2c8d40e6d4d04c528e86fa": { "balance": "13000000000000000000000" }, "dfe929a61c1b38eddbe82c25c2d6753cb1e12d68": { "balance": "402500000000000000000" }, "2b49fba29830360fcdb6da23bbfea5c0bbac5281": { "balance": "20000000000000000000" }, "76becae4a31d36f3cb577f2a43594fb1abc1bb96": { "balance": "24860000000000000000000" }, "e0cf698a053327ebd16b7d7700092fe2e8542446": { "balance": "95275000000000000000" }, "a3802d8a659e89a2c47e905430b2a827978950a7": { "balance": "1000000000000000000000" }, "75636cdb109050e43d5d6ec47e359e218e857eca": { "balance": "22886800000000000000000" }, "3d813ff2b6ed57b937dabf2b381d148a411fa085": { "balance": "100000000000000000000" }, "a9252551a624ae513719dabe5207fbefb2fd7749": { "balance": "40000000000000000000" }, "c749668042e71123a648975e08ed6382f83e05e2": { "balance": "14000000000000000000000" }, "04eca501630abce35218b174956b891ba25efb23": { "balance": "1000060000000000000000" }, "790f91bd5d1c5cc4739ae91300db89e1c1303c93": { "balance": "2000000000000000000000" }, "009560a3de627868f91fa8bfe1c1b7afaf08186b": { "balance": "524000000000000000000" }, "1329dd19cd4baa9fc64310efeceab22117251f12": { "balance": "200000000000000000000" }, "7005a772282b1f62afda63f89b5dc6ab64c84cb9": { "balance": "18000000000000000000000" }, "abfe936425dcc7b74b955082bbaaf2a11d78bc05": { "balance": "1400000000000000000000" }, "97d0d9725e3b70e675843173938ed371b62c7fac": { "balance": "170000000000000000000" }, "41ed2d8e7081482c919fc23d8f0091b3c82c4685": { "balance": "1295460000000000000000" }, "992365d764c5ce354039ddfc912e023a75b8e168": { "balance": "18200000000000000000" }, "e1c607c0a8a060da8f02a8eb38a013ea8cda5b8c": { "balance": "805000000000000000000" }, "3b2c45990e21474451cf4f59f01955b331c7d7c9": { "balance": "2000000000000000000000" }, "29ac2b458454a36c7e96c73a8667222a12242c71": { "balance": "4000000000000000000000" }, "b8555010776e3c5cb311a5adeefe9e92bb9a64b9": { "balance": "4000000000000000000000" }, "30380087786965149e81423b15e313ba32c5c783": { "balance": "18200000000000000000" }, "a2f86bc061884e9eef05640edd51a2f7c0596c69": { "balance": "2000050000000000000000" }, "9f98eb34d46979b0a6de8b05aa533a89b825dcf1": { "balance": "86500000000000000000" }, "c81fb7d20fd2800192f0aac198d6d6a37d3fcb7d": { "balance": "259500000000000000000" }, "a4035ab1e5180821f0f380f1131b7387c8d981cd": { "balance": "20000000000000000000" }, "782f52f0a676c77716d574c81ec4684f9a020a97": { "balance": "850055000000000000000" }, "261e0fa64c51137465eecf5b90f197f7937fdb05": { "balance": "18000000000000000000000" }, "276fd7d24f8f883f5a7a28295bf17151c7a84b03": { "balance": "2000000000000000000000" }, "a1f5b840140d5a9acef402ac3cc3886a68cad248": { "balance": "2000000000000000000000" }, "d2bf67a7f3c6ce56b7be41675dbbadfe7ea93a33": { "balance": "400000000000000000000" }, "8ee584337ddbc80f9e3498df55f0a21eacb57fb1": { "balance": "20000000000000000000" }, "34393c5d91b9de597203e75bac4309b5fa3d28c3": { "balance": "194000000000000000000" }, "114cbbbf6fb52ac414be7ec61f7bb71495ce1dfa": { "balance": "3000000000000000000000" }, "ab7c42c5e52d641a07ad75099c62928b7f86622f": { "balance": "335940000000000000000" }, "80bf995ed8ba92701d10fec49f9e7d014dbee026": { "balance": "572153000000000000000" }, "4a192035e2619b24b0709d56590e9183ccf2c1d9": { "balance": "10000000000000000000000" }, "376cd7577383e902951b60a2017ba7ea29e33576": { "balance": "2000000000000000000000" }, "f5437e158090b2a2d68f82b54a5864b95dd6dbea": { "balance": "4010732000000000000000" }, "13a5eecb38305df94971ef2d9e179ae6cebab337": { "balance": "330000000000000000000" }, "efc8cf1963c9a95267b228c086239889f4dfd467": { "balance": "10000000000000000000000" }, "db77b88dcb712fd17ee91a5b94748d720c90a994": { "balance": "2000000000000000000000" }, "9aaafa0067647ed999066b7a4ca5b4b3f3feaa6f": { "balance": "1000000000000000000000" }, "ae36f7452121913e800e0fcd1a65a5471c23846f": { "balance": "164000000000000000000" }, "b124bcb6ffa430fcae2e86b45f27e3f21e81ee08": { "balance": "2000000000000000000000" }, "f2813a64c5265d020235cb9c319b6c96f906c41e": { "balance": "350000000000000000000" }, "e848ca7ebff5c24f9b9c316797a43bf7c356292d": { "balance": "114000000000000000000" }, "21a6feb6ab11c766fdd977f8df4121155f47a1c0": { "balance": "57200000000000000000" }, "e95e92bbc6de07bf3a660ebf5feb1c8a3527e1c5": { "balance": "18200000000000000000" }, "0b369e002e1b4c7913fcf00f2d5e19c58165478f": { "balance": "64520000000000000000" }, "0909648c18a3ce5bae7a047ec2f868d24cdda81d": { "balance": "3820000000000000000000" }, "d32b45564614516c91b07fa9f72dcf787cce4e1c": { "balance": "291000000000000000000" }, "cf1bdb799b2ea63ce134668bdc198b54840f180b": { "balance": "18200000000000000000" }, "ae062c448618643075de7a0030342dced63dbad7": { "balance": "825982000000000000000" }, "99dfd0504c06c743e46534fd7b55f1f9c7ec3329": { "balance": "2000000000000000000000" }, "87fc4635263944ce14a46c75fa4a821f39ce7f72": { "balance": "20000000000000000000" }, "27c2d7ca504daa3d9066dc09137dc42f3aaab452": { "balance": "600000000000000000000" }, "cc60f836acdef3548a1fefcca13ec6a937db44a0": { "balance": "86500000000000000000" }, "c910a970556c9716ea53af66ddef93143124913d": { "balance": "1580000000000000000000" }, "8173c835646a672e0152be10ffe84162dd256e4c": { "balance": "492000000000000000000" }, "e989733ca1d58d9e7b5029ba5d444858bec03172": { "balance": "581595000000000000000" }, "86806474c358047d9406e6a07f40945bc8328e67": { "balance": "6884000000000000000000" }, "5395a4455d95d178b4532aa4725b193ffe512961": { "balance": "1000000000000000000000" }, "56397638bb3cebf1f62062794b5eb942f916171d": { "balance": "2000000000000000000000" }, "6958f83bb2fdfb27ce0409cd03f9c5edbf4cbedd": { "balance": "20000000000000000000000" }, "26ff0a51e7cece8400276978dbd6236ef162c0e6": { "balance": "100020000000000000000000" }, "4ca783b556e5bf53aa13c8116613d65782c9b642": { "balance": "25200000000000000000000" }, "15a0aec37ff9ff3d5409f2a4f0c1212aaccb0296": { "balance": "1000000000000000000000" }, "50378af7ef54043f892ab7ce97d647793511b108": { "balance": "19700000000000000000" }, "e7c6b5fc05fc748e5b4381726449a1c0ad0fb0f1": { "balance": "2000000000000000000000" }, "5317ecb023052ca7f5652be2fa854cfe4563df4d": { "balance": "499986000000000000000" }, "c94f7c35c027d47df8ef4f9df85a9248a17dd23b": { "balance": "29944000000000000000" }, "6a63fc89abc7f36e282d80787b7b04afd6553e71": { "balance": "160000000000000000000" }, "5fd3d6777ec2620ae83a05528ed425072d3ca8fd": { "balance": "2000000000000000000000" }, "29adcf83b6b20ac6a434abb1993cbd05c60ea2e4": { "balance": "10000000000000000000000" }, "8c6f9f4e5b7ae276bf58497bd7bf2a7d25245f64": { "balance": "2730000000000000000000" }, "d94a57882a52739bbe2a0647c80c24f58a2b4f1c": { "balance": "1341230000000000000000" }, "7286e89cd9de8f7a8a00c86ffdb53992dd9251d1": { "balance": "1940000000000000000000" }, "5773b6026721a1dd04b7828cd62b591bfb34534c": { "balance": "27000000000000000000000" }, "11fefb5dc1a4598aa712640c517775dfa1d91f8c": { "balance": "10000000000000000000000" }, "c6e324beeb5b36765ecd464260f7f26006c5c62e": { "balance": "2000000000000000000000" }, "118fbd753b9792395aef7a4d78d263cdcaabd4f7": { "balance": "999800000000000000000" }, "f8298591523e50b103f0b701d623cbf0f74556f6": { "balance": "200000000000000000000" }, "ab0ced762e1661fae1a92afb1408889413794825": { "balance": "1910000000000000000000" }, "fa67b67b4f37a0150915110ede073b05b853bda2": { "balance": "647490000000000000000" }, "ca122cf0f2948896b74843f49afed0ba1618eed7": { "balance": "560000000000000000000" }, "186b95f8e5effddcc94f1a315bf0295d3b1ea588": { "balance": "1999944000000000000000" }, "2915624bcb679137b8dae9ab57d11b4905eaee4b": { "balance": "20000000000000000000" }, "0c6845bf41d5ee273c3ee6b5b0d69f6fd5eabbf7": { "balance": "3000026000000000000000" }, "cb7479109b43b26657f4465f4d18c6f974be5f42": { "balance": "1820000000000000000000" }, "8dd6a9bae57f518549ada677466fea8ab04fd9b4": { "balance": "4000000000000000000000" }, "34958a46d30e30b273ecc6e5d358a212e5307e8c": { "balance": "2000000000000000000000" }, "2003717907a72560f4307f1beecc5436f43d21e7": { "balance": "500000000000000000000" }, "55ab99b0e0e55d7bb874b7cfe834de631c97ec23": { "balance": "1031400000000000000000" }, "79b48d2d6137c3854d611c01ea42427a0f597bb7": { "balance": "191000000000000000000" }, "d609ec0be70d0ad26f6e67c9d4762b52ee51122c": { "balance": "1000000000000000000000" }, "e8c3f045bb7d38c9d2f395b0ba8492b253230901": { "balance": "9000000000000000000000" }, "aaca60d9d700e78596bbbbb1f1e2f70f4627f9d8": { "balance": "999996000000000000000" }, "89d75b8e0831e46f80bc174188184e006fde0eae": { "balance": "1000000000000000000000" }, "b3667894b7863c068ad344873fcff4b5671e0689": { "balance": "20000000000000000000000" }, "bc1609d685b76b48ec909aa099219022f89b2ccd": { "balance": "1182000000000000000000" }, "88ee7f0efc8f778c6b687ec32be9e7d6f020b674": { "balance": "2000000000000000000000" }, "470ac5d1f3efe28f3802af925b571e63868b397d": { "balance": "2000000000000000000000" }, "abf8ffe0708a99b528cc1ed4e9ce4b0d0630be8c": { "balance": "2263600000000000000000" }, "8cee38d6595788a56e3fb94634b3ffe1fbdb26d6": { "balance": "20000000000000000000000" }, "19798cbda715ea9a9b9d6aab942c55121e98bf91": { "balance": "1200000000000000000000" }, "e25a167b031e84616d0f013f31bda95dcc6350b9": { "balance": "10560000000000000000000" }, "6196c3d3c0908d254366b7bca55745222d9d4db1": { "balance": "4000000000000000000000" }, "e8e9850586e94f5299ab494bb821a5f40c00bd04": { "balance": "3820000000000000000000" }, "1059cbc63e36c43e88f30008aca7ce058eeaa096": { "balance": "100000000000000000000000" }, "c4f2913b265c430fa1ab8adf26c333fc1d9b66f2": { "balance": "20000000000000000000" }, "26e9e2ad729702626417ef25de0dc800f7a779b3": { "balance": "1000000000000000000000" }, "0dfbd4817050d91d9d625c02053cf61a3ee28572": { "balance": "340000000000000000000" }, "709fe9d2c1f1ce42207c9585044a60899f35942f": { "balance": "2000000000000000000000" }, "7ad82caea1a8b4ed05319b9c9870173c814e06ee": { "balance": "616000000000000000000" }, "2a595f16eee4cb0c17d9a2d939b3c10f6c677243": { "balance": "1100000000000000000000" }, "a8f89dd5cc6e64d7b1eeace00702022cd7d2f03d": { "balance": "700000000000000000000" }, "c0a6cbad77692a3d88d141ef769a99bb9e3c9951": { "balance": "100000000000000000000" }, "868c23be873466d4c74c220a19b245d1787e807f": { "balance": "1366481000000000000000" }, "2905b192e83ce659aa355b9d0c204e3e95f9bb9a": { "balance": "2160817000000000000000" }, "50b9fef0a1329b02d16506255f5a2db71ec92d1f": { "balance": "1325464000000000000000" }, "fc10b7a67b3268d5331bfb6a14def5ea4a162ca3": { "balance": "200000000000000000000" }, "85eb256b51c819d60ea61a82d12c9358d59c1cae": { "balance": "460000000000000000000" }, "75de7e9352e90b13a59a5878ffecc7831cac4d82": { "balance": "2740000000000000000000" }, "d32b2c79c36478c5431901f6d700b04dbe9b8810": { "balance": "396000000000000000000" }, "2d0326b23f0409c0c0e9236863a133075a94ba18": { "balance": "210380000000000000000" }, "d2e21ed56868fab28e0947927adaf29f23ebad6c": { "balance": "1994000000000000000000" }, "2ad6c9d10c261819a1a0ca2c48d8c7b2a71728df": { "balance": "1000000000000000000000" }, "7d445267c59ab8d2a2d9e709990e09682580c49f": { "balance": "1000000000000000000000" }, "b6047cdf932db3e4045f4976122341537ed5961e": { "balance": "20000000000000000000" }, "2b3cf97311ff30f460945a9d8099f4a88e26d456": { "balance": "2000000000000000000000" }, "7f4f593b618c330ba2c3d5f41eceeb92e27e426c": { "balance": "2775000000000000000000" }, "72a2fc8675feb972fa41b50dffdbbae7fa2adfb7": { "balance": "2853840000000000000000" }, "076561a856455d7ef86e63f87c73dbb628a55f45": { "balance": "900000000000000000000" }, "03d1724fd00e54aabcd2de2a91e8462b1049dd3a": { "balance": "2640000000000000000000" }, "7ea0f96ee0a573a330b56897761f3d4c0130a8e3": { "balance": "1337000000000000000000" }, "fe65c4188d7922576909642044fdc52395560165": { "balance": "4000000000000000000000" }, "57883010b4ac857fedac03eab2551723a8447ffb": { "balance": "1000000000000000000000" }, "0729a8a4a5ba23f579d0025b1ad0f8a0d35cdfd2": { "balance": "9700000000000000000000" }, "e75c1fb177089f3e58b1067935a6596ef1737fb5": { "balance": "99910000000000000000" }, "e0e978753d982f7f9d1d238a18bd4889aefe451b": { "balance": "9700000000000000000000" }, "5620f46d1451c2353d6243a5d4b427130be2d407": { "balance": "60000000000000000000" }, "f3d688f06bbdbf50f9932c4145cbe48ecdf68904": { "balance": "20000000000000000000" }, "3aa948ea02397755effb2f9dc9392df1058f7e33": { "balance": "850000000000000000000" }, "20d1417f99c569e3beb095856530fe12d0fceaaa": { "balance": "1182175000000000000000" }, "ac77bdf00fd5985b5db12bbef800380abc2a0677": { "balance": "1000000000000000000000" }, "267a7e6e82e1b91d51deddb644f0e96dbb1f7f7e": { "balance": "20000000000000000000" }, "4bbcbf38b3c90163a84b1cd2a93b58b2a3348d87": { "balance": "8000000000000000000000" }, "4c6b93a3bec16349540cbfcae96c9621d6645010": { "balance": "2000000000000000000000" }, "c9308879056dfe138ef8208f79a915c6bc7e70a8": { "balance": "10000000000000000000000" }, "c48b693cacefdbd6cb5d7895a42e3196327e261c": { "balance": "1000000000000000000000" }, "a0951970dfd0832fb83bda12c23545e79041756c": { "balance": "600000000000000000000" }, "7cdf74213945953db39ad0e8a9781add792e4d1d": { "balance": "2000000000000000000000" }, "75621865b6591365606ed378308c2d1def4f222c": { "balance": "3100000000000000000000" }, "67d6a8aa1bf8d6eaf7384e993dfdf10f0af68a61": { "balance": "198067000000000000000" }, "8f0af37566d152802f1ae8f928b25af9b139b448": { "balance": "200000000000000000000" }, "2c6afcd4037c1ed14fa74ff6758e0945a185a8e8": { "balance": "17600000000000000000" }, "c1b2aa8cb2bf62cdc13a47ecc4657facaa995f98": { "balance": "1000129000000000000000" }, "9e8144e08e89647811fe6b72d445d6a5f80ad244": { "balance": "10000000000000000000000" }, "e04ff5e5a7e2af995d8857ce0290b53a2b0eda5d": { "balance": "1000000000000000000000" }, "03dedfcd0b3c2e17c705da248790ef98a6bd5751": { "balance": "1337000000000000000000" }, "698a8a6f01f9ab682f637c7969be885f6c5302bf": { "balance": "19400000000000000000" }, "d82c6fedbdac98af2eed10b00f32b00056ca5a6d": { "balance": "200000000000000000000" }, "2697b339813b0c2d964b2471eb1c606f4ecb9616": { "balance": "1154000000000000000000" }, "987c9bcd6e3f3990a52be3eda4710c27518f4f72": { "balance": "400000000000000000000" }, "c5d48ca2db2f85d8c555cb0e9cfe826936783f9e": { "balance": "200000000000000000000" }, "da214c023e2326ff696c00393168ce46ffac39ec": { "balance": "1000000000000000000000" }, "86570ab259c9b1c32c9729202f77f590c07dd612": { "balance": "200000000000000000000" }, "a646a95c6d6f59f104c6541d7760757ab392b08c": { "balance": "4200000000000000000000" }, "1933e334c40f3acbad0c0b851158206924beca3a": { "balance": "7551541000000000000000" }, "3552a496eba67f12be6eedab360cd13661dc7480": { "balance": "300000000000000000000" }, "2a9c96c19151ffcbe29a4616d0c52b3933b4659f": { "balance": "69263000000000000000" }, "3b7b8e27de33d3ce7961b98d19a52fe79f6c25be": { "balance": "100000000000000000000000" }, "a1911405cf6e999ed011f0ddcd2a4ff7c28f2526": { "balance": "40000000000000000000" }, "0cae108e6db99b9e637876b064c6303eda8a65c8": { "balance": "3000000000000000000000" }, "3883becc08b9be68ad3b0836aac3b620dc0017ef": { "balance": "2000000000000000000000" }, "d0abcc70c0420e0e172f97d43b87d5e80c336ea9": { "balance": "10000000000000000000000" }, "cbf16a0fe2745258cd52db2bf21954c975fc6a15": { "balance": "300000000000000000000" }, "1b23cb8663554871fbbe0d9e60397efb6faedc3e": { "balance": "200000000000000000000" }, "fbede32c349f3300ef4cd33b4de7dc18e443d326": { "balance": "3160000000000000000000" }, "5e806e845730f8073e6cc9018ee90f5c05f909a3": { "balance": "9480000000000000000000" }, "425c338a1325e3a1578efa299e57d986eb474f81": { "balance": "2000000000000000000000" }, "8bf297f8f453523ed66a1acb7676856337b93bf0": { "balance": "4000000000000000000000" }, "38e8a31af2d265e31a9fff2d8f46286d1245a467": { "balance": "20000000000000000000" }, "7edafba8984baf631a820b6b92bbc2c53655f6bd": { "balance": "2000000000000000000000" }, "aa0200f1d17e9c54da0647bb96395d57a78538d8": { "balance": "1056000000000000000000" }, "433eb94a339086ed12d9bde9cd1d458603c97dd6": { "balance": "100000000000000000000000" }, "cd7e47909464d871b9a6dc76a8e9195db3485e7a": { "balance": "9850000000000000000000" }, "5975d78d974ee5bb9e4d4ca2ae77c84b9c3b4b82": { "balance": "1370000000000000000000" }, "cea2896623f4910287a2bdc5be83aea3f2e6de08": { "balance": "9359000000000000000000" }, "cb4ad0c723da46ab56d526da0c1d25c73daff10a": { "balance": "510000000000000000000" }, "e2cf360aa2329eb79d2bf7ca04a27a17c532e4d8": { "balance": "102000000000000000000" }, "ea60549ec7553f511d2149f2d4666cbd9243d93c": { "balance": "2000000000000000000000" }, "cbb7be17953f2ccc93e1bc99805bf45511434e4c": { "balance": "50440000000000000000000" }, "3549bd40bbbc2b30095cac8be2c07a0588e0aed6": { "balance": "20000000000000000000" }, "6510df42a599bcb0a519cca961b488759a6f6777": { "balance": "2000000000000000000000" }, "ed12a1ba1fb8adfcb20dfa19582e525aa3b74524": { "balance": "6685000000000000000000" }, "135eb8c0e9e101deedec11f2ecdb66ae1aae8867": { "balance": "20000000000000000000000" }, "ee906d7d5f1748258174be4cbc38930302ab7b42": { "balance": "200000000000000000000" }, "253f1e742a2cec86b0d7b306e5eacb6ccb2f8554": { "balance": "20040000000000000000000" }, "ecd1a62802351a41568d23033004acc6c005a5d3": { "balance": "50000000000000000000" }, "558c54649a8a6e94722bd6d21d14714f71780534": { "balance": "2000000000000000000000" }, "ca657ec06fe5bc09cf23e52af7f80cc3689e6ede": { "balance": "900000000000000000000" }, "74bf7a5ab59293149b5c60cf364263e5ebf1aa0d": { "balance": "115800000000000000000" }, "7a6d781c77c4ba1fcadf687341c1e31799e93d27": { "balance": "274000000000000000000" }, "77028e409cc43a3bd33d21a9fc53ec606e94910e": { "balance": "3880000000000000000000" }, "4781a10a4df5eebc82f4cfe107ba1d8a7640bd66": { "balance": "1790000000000000000000" }, "78e08bc533413c26e291b3143ffa7cc9afb97b78": { "balance": "200000000000000000000" }, "03ef6ad20ff7bd4f002bac58d47544cf879ae728": { "balance": "6895000000000000000000" }, "0e3696cf1f4217b163d1bc12a5ea730f1c32a14a": { "balance": "4000000000000000000000" }, "825135b1a7fc1605614c8aa4d0ac6dbad08f480e": { "balance": "1430000000000000000000" }, "286b186d61ea1fd78d9930fe12b06537b05c3d51": { "balance": "1000000000000000000000" }, "8d6657f59711b1f803c6ebef682f915b62f92dc9": { "balance": "2000000000000000000000" }, "da8bbee182e455d2098acb338a6d45b4b17ed8b6": { "balance": "2000000000000000000000" }, "3f2da093bb16eb064f8bfa9e30b929d15f8e1c4c": { "balance": "2000000000000000000000" }, "f5d9cf00d658dd45517a48a9d3f5f633541a533d": { "balance": "116400000000000000000" }, "c5f64babb7033142f20e46d7aa6201ed86f67103": { "balance": "2000000000000000000000" }, "a2e2b5941e0c01944bfe1d5fb4e8a34b922ccfb1": { "balance": "200000000000000000000" }, "6114b0eae5576903f80bfb98842d24ed92237f1e": { "balance": "100000000000000000000" }, "38df0c4abe7ded5fe068eadf154ac691774324a4": { "balance": "1790000000000000000000" }, "1c2010bd662df417f2a271879afb13ef4c88a3ae": { "balance": "4000000000000000000000" }, "918967918cd897dd0005e36dc6c883ef438fc8c7": { "balance": "140000000000000000000" }, "a522de7eb6ae1250522a513133a93bd42849475c": { "balance": "20000000000000000000000" }, "7de442c82386154d2e993cbd1280bb7ca6b12ada": { "balance": "4002000000000000000000" }, "66424bd8785b8cb461102a900283c35dfa07ef6a": { "balance": "40221000000000000000" }, "7bbbec5e70bdead8bb32b42805988e9648c0aa97": { "balance": "1000076000000000000000" }, "fec06fe27b44c784b2396ec92f7b923ad17e9077": { "balance": "2000000000000000000000" }, "95d550427b5a514c751d73a0f6d29fb65d22ed10": { "balance": "300000000000000000000" }, "8dde60eb08a099d7daa356daaab2470d7b025a6b": { "balance": "197000000000000000000" }, "81bccbff8f44347eb7fca95b27ce7c952492aaad": { "balance": "152240000000000000000" }, "3995e096b08a5a726800fcd17d9c64c64e088d2b": { "balance": "200000000000000000000" }, "4ee13c0d41200b46d19dee5c4bcec71d82bb8e38": { "balance": "7893915000000000000000" }, "c41461a3cfbd32c9865555a4813137c076312360": { "balance": "999999000000000000000" }, "3300fb149aded65bcba6c04e9cd6b7a03b893bb1": { "balance": "18200000000000000000" }, "29f9286c0e738d1721a691c6b95ab3d9a797ede8": { "balance": "200000000000000000000000" }, "34c8e5f1330fcb4b14ca75cb2580a4b93d204e36": { "balance": "2000000000000000000000" }, "ec5df227bfa85d7ad76b426e1cee963bc7f519dd": { "balance": "1000000000000000000000" }, "797510e386f56393ced8f477378a444c484f7dad": { "balance": "1000000000000000000000" }, "0191eb547e7bf6976b9b1b577546761de65622e2": { "balance": "1999980000000000000000" }, "615a6f36777f40d6617eb5819896186983fd3731": { "balance": "5910000000000000000000" }, "17580b766f7453525ca4c6a88b01b50570ea088c": { "balance": "100000000000000000000" }, "945d96ea573e8df7262bbfa572229b4b16016b0f": { "balance": "209300000000000000000" }, "2de0964400c282bdd78a919c6bf77c6b5f796179": { "balance": "200000000000000000000" }, "304ec69a74545721d7316aef4dcfb41ac59ee2f0": { "balance": "200000000000000000000" }, "be2b326e78ed10e550fee8efa8f8070396522f5a": { "balance": "39400000000000000000000" }, "1a0841b92a7f7075569dc4627e6b76cab05ade91": { "balance": "1520000000000000000000" }, "5fa61f152de6123516c751242979285f796ac791": { "balance": "204000000000000000000" }, "68c8791dc342c373769ea61fb7b510f251d32088": { "balance": "1000000000000000000000" }, "4167cd48e733418e8f99ffd134121c4a4ab278c4": { "balance": "3640000000000000000000" }, "598aaabae9ed833d7bc222e91fcaa0647b77580b": { "balance": "1800000000000000000000" }, "979f30158b574b999aab348107b9eed85b1ff8c1": { "balance": "970000000000000000000" }, "3ad06149b21c55ff867cc3fb9740d2bcc7101231": { "balance": "197000000000000000000000" }, "7133843a78d939c69d4486e10ebc7b602a349ff7": { "balance": "329000000000000000000" }, "8bdfda6c215720eda2136f91052321af4e936c1f": { "balance": "1000008000000000000000" }, "3e1c53300e4c168912163c7e99b95da268ad280a": { "balance": "1003200000000000000000" }, "e07ebbc7f4da416e42c8d4f842aba16233c12580": { "balance": "2000000000000000000000" }, "bac8922c4acc7d2cb6fd59a14eb45cf3e702214b": { "balance": "800000000000000000000" }, "bb6c284aac8a69b75cddb00f28e145583b56bece": { "balance": "2000000000000000000000" }, "0372ee5508bf8163ed284e5eef94ce4d7367e522": { "balance": "100000000000000000000" }, "17125b59ac51cee029e4bd78d7f5947d1ea49bb2": { "balance": "22000000000000000000000" }, "c88ca1e6e5f4d558d13780f488f10d4ad3130d34": { "balance": "1550000000000000000000" }, "a825fd5abb7926a67cf36ba246a24bd27be6f6ed": { "balance": "17600000000000000000" }, "04241b41ecbd0bfdf1295e9d4fa59ea09e6c6186": { "balance": "1870000000000000000000" }, "6de4d15219182faf3aa2c5d4d2595ff23091a727": { "balance": "1580000000000000000000" }, "b203d29e6c56b92699c4b92d1f6f84648dc4cfbc": { "balance": "400000000000000000000" }, "80b42de170dbd723f454e88f7716452d92985092": { "balance": "300202000000000000000" }, "0a5b79d8f23b6483dbe2bdaa62b1064cc76366ae": { "balance": "1969803000000000000000" }, "32034e8581d9484e8af42a28df190132ec29c466": { "balance": "3460000000000000000000" }, "7ee604c7a9dc2909ce321de6b9b24f5767577555": { "balance": "5533575000000000000000" }, "a387ce4e961a7847f560075c64e1596b5641d21c": { "balance": "668500000000000000000" }, "fcc9d4a4262e7a027ab7519110d802c495ceea39": { "balance": "6370000000000000000000" }, "ff8a2ca5a81333f19998255f203256e1a819c0aa": { "balance": "224000000000000000000" }, "f9811fa19dadbf029f8bfe569adb18228c80481a": { "balance": "200000000000000000000" }, "0d1f2a57713ebc6e94de29846e8844d376665763": { "balance": "5000000000000000000000" }, "eab0bd148309186cf8cbd13b7232d8095acb833a": { "balance": "10691800000000000000000" }, "36928b55bc861509d51c8cf1d546bfec6e3e90af": { "balance": "1970000000000000000000" }, "30480164bcd84974ebc0d90c9b9afab626cd1c73": { "balance": "800000000000000000000" }, "36339f84a5c2b44ce53dfdb6d4f97df78212a7df": { "balance": "321600000000000000000" }, "cfeacaaed57285e0ac7268ce6a4e35ecfdb242d7": { "balance": "1086400000000000000000" }, "572dd8cd3fe399d1d0ec281231b7cefc20b9e4bb": { "balance": "10400000000000000000000" }, "5dded049a6e1f329dc4b971e722c9c1f2ade83f0": { "balance": "1000000000000000000000" }, "9756e176c9ef693ee1eec6b9f8b151d313beb099": { "balance": "1200000000000000000000" }, "01e6415d587b065490f1ed7f21d6e0f386ee6747": { "balance": "2000000000000000000000" }, "b4413576869c08f9512ad311fe925988a52d3414": { "balance": "10000000000000000000000" }, "da9f55460946d7bfb570ddec757ca5773b58429a": { "balance": "507600000000000000000" }, "7180b83ee5574317f21c8072b191d895d46153c3": { "balance": "460000000000000000000" }, "0aca9a5626913b08cfc9a66d40508dce52b60f87": { "balance": "1910000000000000000000" }, "5cd0e475b54421bdfc0c12ea8e082bd7a5af0a6a": { "balance": "59000000000000000000" }, "7edb02c61a227287611ad950696369cc4e647a68": { "balance": "274000000000000000000" }, "b2676841ee9f2d31c172e82303b0fe9bbf9f1e09": { "balance": "200000000000000000000" }, "a2222259dd9c3e3ded127084f808e92a1887302c": { "balance": "162000000000000000000" }, "4b3a7cc3a7d7b00ed5282221a60259f25bf6538a": { "balance": "1000000000000000000000" }, "e33ff987541dde5cdee0a8a96dcc3f33c3f24cc2": { "balance": "200000000000000000000000" }, "1e1a4828119be309bd88236e4d482b504dc55711": { "balance": "2955000000000000000000" }, "9b1811c3051f46e664ae4bc9c824d18592c4574a": { "balance": "199955000000000000000" }, "59fe00696dbd87b7976b29d1156c8842a2e17914": { "balance": "2000000000000000000000" }, "48010ef3b8e95e3f308f30a8cb7f4eb4bf60d965": { "balance": "2000000000000000000000" }, "c90300cb1d4077e6a6d7e169a460468cf4a492d7": { "balance": "2000000000000000000000" }, "6dedf62e743f4d2c2a4b87a787f5424a7aeb393c": { "balance": "180000000000000000000" }, "fb744b951d094b310262c8f986c860df9ab1de65": { "balance": "52009000000000000000" }, "193ac65183651800e23580f8f0ead3bb597eb8a4": { "balance": "50020000000000000000" }, "bf05ff5ecf0df2df887759fb8274d93238ac267d": { "balance": "800000000000000000000" }, "6c0e712f405c59725fe829e9774bf4df7f4dd965": { "balance": "57413800000000000000000" }, "2744ff67464121e35afc2922177164fa2fcb0267": { "balance": "100000000000000000000" }, "d09cb2e6082d693a13e8d2f68dd1dd8461f55840": { "balance": "1000000000000000000000" }, "bc171e53d17ac9b61241ae436deec7af452e7496": { "balance": "5348000000000000000000" }, "71fa22cc6d33206b7d701a163a0dab31ae4d31d6": { "balance": "1610000000000000000000" }, "4da8030769844bc34186b85cd4c7348849ff49e9": { "balance": "10000000000000000000000" }, "c8616b4ec09128cdff39d6e4b9ac86eec471d5f2": { "balance": "19400000000000000000" }, "407295ebd94b48269c2d569c9b9af9aa05e83e5e": { "balance": "10000000000000000000000" }, "d45d5daa138dd1d374c71b9019916811f4b20a4e": { "balance": "576000000000000000000" }, "42c6edc515d35557808d13cd44dcc4400b2504e4": { "balance": "197876000000000000000" }, "0bc95cb32dbb574c832fa8174a81356d38bc92ac": { "balance": "2000000000000000000000" }, "5a6071bcebfcba4ab57f4db96fc7a68bece2ba5b": { "balance": "2000000000000000000000" }, "54c93e03a9b2e8e4c3672835a9ee76f9615bc14e": { "balance": "19400000000000000000" }, "3c03bbc023e1e93fa3a3a6e428cf0cd8f95e1ec6": { "balance": "1520000000000000000000" }, "ba1531fb9e791896bcf3a80558a359f6e7c144bd": { "balance": "3940000000000000000000" }, "aa56a65dc4abb72f11bae32b6fbb07444791d5c9": { "balance": "748600000000000000000" }, "e437acbe0f6227b0e36f36e4bcf7cf613335fb68": { "balance": "200000000000000000000" }, "39d4a931402c0c79c457186f24df8729cf957031": { "balance": "4000000000000000000000" }, "e22b20c77894463baf774cc256d5bddbbf7ddd09": { "balance": "1000000000000000000000" }, "70a4067d448cc25dc8e70e651cea7cf84e92109e": { "balance": "176000000000000000000" }, "aa3925dc220bb4ae2177b2883078b6dc346ca1b2": { "balance": "8000000000000000000000" }, "ad57aa9d00d10c439b35efcc0becac2e3955c313": { "balance": "200000000000000000000" }, "e93d47a8ca885d540c4e526f25d5c6f2c108c4b8": { "balance": "112640000000000000000000" }, "232ce782506225fd9860a2edc14a7a3047736da2": { "balance": "20000000000000000000" }, "49a645e0667dfd7b32d075cc2467dd8c680907c4": { "balance": "129560000000000000000" }, "cf2e734042a355d05ffb2e3915b16811f45a695e": { "balance": "2000000000000000000000" }, "39b1c471ae94e12164452e811fbbe2b3cd7275ac": { "balance": "2000000000000000000000" }, "ffad3dd74e2c1f796ac640de56dc99b4c792a402": { "balance": "5000000000000000000000" }, "a69d7cd17d4842fe03f62a90b2fbf8f6af7bb380": { "balance": "100000000000000000000" }, "2001bef77b66f51e1599b02fb110194a0099b78d": { "balance": "2000000000000000000000" }, "95e7616424cd0961a71727247437f0069272280e": { "balance": "400000000000000000000" }, "c04f4bd4049f044685b883b62959ae631d667e35": { "balance": "5820000000000000000000" }, "ede0147ec032c3618310c1ff25690bf172193dac": { "balance": "2000000000000000000000" }, "66719c0682b2ac7f9e27abebec7edf8decf0ae0d": { "balance": "20000000000000000000" }, "45272b8f62e9f9fa8ce04420e1aea3eba9686eac": { "balance": "4000000000000000000000" }, "d1da0c8fb7c210e0f2ec618f85bdae7d3e734b1c": { "balance": "1970000000000000000000" }, "e9133e7d31845d5f2b66a2618792e869311acf66": { "balance": "24050000000000000000000" }, "ebb62cf8e22c884b1b28c6fa88fbbc17938aa787": { "balance": "798000000000000000000" }, "6205c2d5647470848a3840f3887e9b015d34755c": { "balance": "1800000000000000000000" }, "76ca22bcb8799e5327c4aa2a7d0949a1fcce5f29": { "balance": "1524180000000000000000" }, "6b925dd5d8ed6132ab6d0860b82c44e1a51f1fee": { "balance": "1480000000000000000000" }, "797bb7f157d9feaa17f76da4f704b74dc1038341": { "balance": "3340000000000000000000" }, "ae8954f8d6166de507cf61297d0fc7ca6b9e7128": { "balance": "300000000000000000000" }, "75c1ad23d23f24b384d0c3149177e86697610d21": { "balance": "6426082000000000000000" }, "805d846fb0bc02a7337226d685be9ee773b9198a": { "balance": "19999800000000000000000" }, "c3cb6b36af443f2c6e258b4a39553a818747811f": { "balance": "1610000000000000000000" }, "cea43f7075816b60bbfce68b993af0881270f6c4": { "balance": "2000000000000000000000" }, "e0388aeddd3fe2ad56f85748e80e710a34b7c92e": { "balance": "500000000000000000000" }, "e131f87efc5ef07e43f0f2f4a747b551d750d9e6": { "balance": "19999000000000000000000" }, "c2b2cbe65bc6c2ee7a3c75b2e47c189c062e8d8b": { "balance": "20000000000000000000000" }, "bd8765f41299c7f479923c4fd18f126d7229047d": { "balance": "4000000000000000000000" }, "c83ba6dd9549be1d3287a5a654d106c34c6b5da2": { "balance": "7000000000000000000000" }, "f870995fe1e522321d754337a45c0c9d7b38951c": { "balance": "20000000000000000000" }, "0d8ed7d0d15638330ed7e4eaccab8a458d75737e": { "balance": "2000000000000000000000" }, "36c510bf8d6e569bf2f37d47265dbcb502ff2bce": { "balance": "30000000000000000000000" }, "0eccf617844fd61fba62cb0e445b7ac68bcc1fbe": { "balance": "387260000000000000000" }, "ae10e27a014f0d306baf266d4897c89aeee2e974": { "balance": "20000000000000000000000" }, "1827039f09570294088fddf047165c33e696a492": { "balance": "9550000000000000000000" }, "23378f42926d0184b793b0c827a6dd3e3d334fcd": { "balance": "56000000000000000000" }, "467124ae7f452f26b3d574f6088894fa5d1cfb3b": { "balance": "2700000000000000000000" }, "aae61e43cb0d0c96b30699f77e00d711d0a3979b": { "balance": "1000000000000000000000" }, "15c7edb8118ee27b342285eb5926b47a855bc7a5": { "balance": "20000000000000000000" }, "0d5d98565c647ca5f177a2adb9d3022fac287f21": { "balance": "200000000000000000000" }, "7222fec7711781d26eaa4e8485f7aa3fac442483": { "balance": "456000000000000000000" }, "dc44275b1715baea1b0345735a29ac42c9f51b4f": { "balance": "1164000000000000000000" }, "04d82af9e01a936d97f8f85940b970f9d4db9936": { "balance": "200000000000000000000" }, "45533390e340fe0de3b3cf5fb9fc8ea552e29e62": { "balance": "1460000000000000000000" }, "1284f0cee9d2ff2989b65574d06ffd9ab0f7b805": { "balance": "400000000000000000000" }, "ed9ebccba42f9815e78233266dd6e835b6afc31b": { "balance": "6000000000000000000000" }, "e4324912d64ea3aef76b3c2ff9df82c7e13ae991": { "balance": "2000000000000000000000" }, "94c742fd7a8b7906b3bfe4f8904fc0be5c768033": { "balance": "20000000000000000000000" }, "62fb8bd1f0e66b90533e071e6cbe6111fef0bc63": { "balance": "17600000000000000000000" }, "2c83aeb02fcf067d65a47082fd977833ab1cec91": { "balance": "150400000000000000000" }, "06cbfa08cdd4fba737bac407be8224f4eef35828": { "balance": "593459000000000000000" }, "67ee406ea4a7ae6a3a381eb4edd2f09f174b4928": { "balance": "1036000000000000000000" }, "83c23d8a502124ee150f08d71dc6727410a0f901": { "balance": "33999600000000000000000" }, "f7c00cdb1f020310d5acab7b496aaa44b779085e": { "balance": "1670000000000000000000" }, "d096565b7c7407d06536580355fdd6d239144aa1": { "balance": "250000000000000000000" }, "f8d52dcc5f96cc28007b3ecbb409f7e22a646caa": { "balance": "149200000000000000000" }, "0c222c7c41c9b048efcce0a232434362e12d673b": { "balance": "10007600000000000000000" }, "503bdbd8bc421c32a443032deb2e3e4cd5ba8b4e": { "balance": "2000000000000000000000" }, "77da5e6c72fb36bce1d9798f7bcdf1d18f459c2e": { "balance": "22380000000000000000" }, "e62f98650712eb158753d82972b8e99ca3f61877": { "balance": "2000000000000000000000" }, "87a7c508ef71582dd9a54372f89cb01f252fb180": { "balance": "200000000000000000000" }, "f61283b4bd8504058ca360e993999b62cbc8cd67": { "balance": "255000000000000000000" }, "9ccddcb2cfc2b25b08729a0a98d9e6f0202ea2c1": { "balance": "100000000000000000000" }, "d460a4b908dd2b056759b488850b66a838fc77a8": { "balance": "1970000000000000000000" }, "5431b1d18751b98fc9e2888ac7759f1535a2db47": { "balance": "2000000000000000000000" }, "da2a14f9724015d79014ed8e5909681d596148f1": { "balance": "48499000000000000000" }, "c989434f825aaf9c552f685eba7c11db4a5fc73a": { "balance": "501000000000000000000" }, "2b701d16c0d3cc1e4cd85445e6ad02eea4ac012d": { "balance": "600000000000000000000" }, "78b978a9d7e91ee529ea4fc4b76feaf8762f698c": { "balance": "32000000000000000000000" }, "c89cf504b9f3f835181fd8424f5ccbc8e1bddf7d": { "balance": "10000000000000000000000" }, "e94941b6036019b4016a30c1037d5a6903babaad": { "balance": "780000000000000000000" }, "95d98d0c1069908f067a52acac2b8b534da37afd": { "balance": "2054053000000000000000" }, "8284923b62e68bbf7c2b9f3414d13ef6c812a904": { "balance": "3880000000000000000000" }, "3e5a39fdda70df1126ab0dc49a7378311a537a1f": { "balance": "2400000000000000000000" }, "a2ace4c993bb1e5383f8ac74e179066e814f0591": { "balance": "100000000000000000000" }, "0609d83a6ce1ffc9b690f3e9a81e983e8bdc4d9d": { "balance": "70000000000000000000000" }, "d119417c46732cf34d1a1afb79c3e7e2cd8eece4": { "balance": "2000000000000000000000" }, "fdb33944f2360615e5be239577c8a19ba52d9887": { "balance": "601650000000000000000" }, "dd95dbe30f1f1877c5dd7684aeef302ab6885192": { "balance": "8372000000000000000000" }, "413f4b02669ccff6806bc826fcb7deca3b0ea9bc": { "balance": "20000000000000000000" }, "5800cd8130839e94495d2d8415a8ea2c90e0c5cb": { "balance": "200000000000000000000" }, "65053191319e067a25e6361d47f37f6318f83419": { "balance": "394000000000000000000" }, "9bc573bcda23b8b26f9073d90c230e8e71e0270b": { "balance": "999544000000000000000" }, "97f7760657c1e202759086963eb4211c5f8139b9": { "balance": "49770000000000000000000" }, "126897a311a14ad43b78e0920100c4426bfd6bdd": { "balance": "973581000000000000000" }, "d5276f0cd5ffd5ffb63f98b5703d5594ede0838b": { "balance": "400000000000000000000" }, "e9c35c913ca1fceab461582fe1a5815164b4fd21": { "balance": "8000000000000000000000" }, "b43067fe70d9b55973ba58dc64dd7f311e554259": { "balance": "200000000000000000000" }, "6f8f0d15cc96fb7fe94f1065bc6940f8d12957b2": { "balance": "1000000000000000000000" }, "b1dba5250ba9625755246e067967f2ad2f0791de": { "balance": "80000000000000000000000" }, "72b7a03dda14ca9c661a1d469fd33736f673c8e8": { "balance": "2000000000000000000000" }, "e792349ce9f6f14f81d0674096befa1f9221cdea": { "balance": "1685365000000000000000" }, "1815279dff9952da3be8f77249dbe22243377be7": { "balance": "4749800000000000000000" }, "33481e856ebed48ea708a27426ef28e867f57cd1": { "balance": "200000000000000000000" }, "8eb8c71982a00fb84275293253f8044544b66b49": { "balance": "400000000000000000000" }, "65f5870f26bce089677dfc23b5001ee492483428": { "balance": "5067230000000000000000" }, "8e23facd12c765c36ab81a6dd34d8aa9e68918ae": { "balance": "167310000000000000000" }, "4912d902931676ff39fc34fe3c3cc8fb2182fa7a": { "balance": "20000000000000000000" }, "c09a66172aea370d9a63da04ff71ffbbfcff7f94": { "balance": "2000000000000000000000" }, "e969ea1595edc5c4a707cfde380929633251a2b0": { "balance": "200000000000000000000" }, "4f2b47e2775a1fa7178dad92985a5bbe493ba6d6": { "balance": "200000000000000000000" }, "cab9a97ada065c87816e6860a8f1426fe6b3d775": { "balance": "1000000000000000000000" }, "cdfd8217339725d7ebac11a63655f265eff1cc3d": { "balance": "4999962000000000000000" }, "ab4004c0403f7eabb0ea586f212156c4203d67f1": { "balance": "1999944000000000000000" }, "1c7cb2fe6bf3e09cbcdc187af38fa8f5053a70b6": { "balance": "9970823000000000000000" }, "a951b244ff50cfae591d5e1a148df6a938ef2a1a": { "balance": "1734000000000000000000" }, "b158db43fa62d30e65f3d09bf781c7b67372ebaa": { "balance": "1999000000000000000000" }, "25e037f00a18270ba5ec3420229ddb0a2ce38fa2": { "balance": "10000000000000000000000" }, "2aaea1f1046f30f109faec1c63ef5c7594eb08da": { "balance": "4000000000000000000000" }, "73d7269ff06c9ffd33754ce588f74a966abbbbba": { "balance": "6600000000000000000000" }, "4c767b65fd91161f4fbdcc6a69e2f6ad711bb918": { "balance": "720000000000000000000" }, "92ae5b7c7eb492ff1ffa16dd42ad9cad40b7f8dc": { "balance": "865000000000000000000" }, "a04f2ae02add14c12faf65cb259022d0830a8e26": { "balance": "100000000000000000000000" }, "63ef2fbc3daf5edaf4a295629ccf31bcdf4038e5": { "balance": "1460000000000000000000" }, "749ad6f2b5706bbe2f689a44c4b640b58e96b992": { "balance": "100000000000000000000" }, "4d836d9d3b0e2cbd4de050596faa490cffb60d5d": { "balance": "300000000000000000000" }, "59f6247b0d582aaa25e5114765e4bf3c774f43c2": { "balance": "50000000000000000000" }, "1293c78c7d6a443b9d74b0ba5ee7bb47fd418588": { "balance": "6685000000000000000000" }, "67bc85e87dc34c4e80aafa066ba8d29dbb8e438e": { "balance": "402500000000000000000" }, "a09f4d5eaa65a2f4cb750a49923401dae59090af": { "balance": "140000000000000000000" }, "ebbd4db9019952d68b1b0f6d8cf0683c00387bb5": { "balance": "332330000000000000000" }, "b16479ba8e7df8f63e1b95d149cd8529d735c2da": { "balance": "846477000000000000000" }, "e1b2aca154b8e0766c4eba30bc10c7f35036f368": { "balance": "19980000000000000000" }, "5c464197791c8a3da3c925436f277ab13bf2faa2": { "balance": "8000000000000000000000" }, "170a88a8997f92d238370f1affdee6347050b013": { "balance": "3000800000000000000000" }, "dadbfafd8b62b92a24efd75256dd83abdbd7bbdb": { "balance": "19700000000000000000" }, "bb993b96ee925ada7d99d786573d3f89180ce3aa": { "balance": "2000000000000000000000" }, "f2c362b0ef991bc82fb36e66ff75932ae8dd8225": { "balance": "74000000000000000000" }, "7f2382ffd8f83956467937f9ba72374623f11b38": { "balance": "600000000000000000000" }, "74d1a4d0c7524e018d4e06ed3b648092b5b6af2c": { "balance": "50000000000000000000" }, "24a750eae5874711116dd7d47b7186ce990d3103": { "balance": "200000000000000000000" }, "a8e42a4e33d7526cca19d9a36dcd6e8040d0ea73": { "balance": "1080000000000000000000" }, "3e1b2230afbbd310b4926a4c776d5ae7819c661d": { "balance": "30000000000000000000000" }, "6af9f0dfeeaebb5f64bf91ab771669bf05295553": { "balance": "400000000000000000000" }, "41e4a20275e39bdcefeb655c0322744b765140c2": { "balance": "10000000000000000000000" }, "ceb089ec8a78337e8ef88de11b49e3dd910f748f": { "balance": "1000000000000000000000" }, "e6bcd30a8fa138c5d9e5f6c7d2da806992812dcd": { "balance": "260000000000000000000000" }, "e08c60313106e3f9334fe6f7e7624d211130c077": { "balance": "40000000000000000000" }, "f5cffbba624e7eb321bc83c60ca68199b4e36671": { "balance": "2000000000000000000000" }, "d7c2803ed7b0e0837351411a8e6637d168bc5b05": { "balance": "29549015000000000000000" }, "0f3665d48e9f1419cd984fc7fa92788710c8f2e4": { "balance": "2000000000000000000000" }, "b48921c9687d5510744584936e8886bdbf2df69b": { "balance": "1000000000000000000000" }, "a94bbb8214cf8da0c2f668a2ac73e86248528d4b": { "balance": "960000000000000000000" }, "be0c2a80b9de084b172894a76cf4737a4f529e1a": { "balance": "1999944000000000000000" }, "fcf199f8b854222f182e4e1d099d4e323e2aae01": { "balance": "1000000000000000000000" }, "b52dfb45de5d74e3df208332bc571c809b8dcf32": { "balance": "6000000000000000000000" }, "704819d2e44d6ed1da25bfce84c49fcca25613e5": { "balance": "400000000000000000000" }, "6ff6cc90d649de4e96cffee1077a5b302a848dcb": { "balance": "28600000000000000000" }, "4d9c77d0750c5e6fbc247f2fd79274686cb353d6": { "balance": "20000000000000000000" }, "68e8022740f4af29eb48db32bcecddfd148d3de3": { "balance": "1000000000000000000000" }, "2cb615073a40dcdb99faa848572e987b3b056efb": { "balance": "799600000000000000000" }, "64adcceec53dd9d9dd15c8cc1a9e736de4241d2c": { "balance": "56000000000000000000" }, "2aec809df9325b9f483996e99f7331097f08aa0e": { "balance": "4000000000000000000000" }, "438c2f54ff8e629bab36b1442b760b12a88f02ae": { "balance": "2000000000000000000000" }, "9e35399071a4a101e9194daa3f09f04a0b5f9870": { "balance": "4000000000000000000000" }, "a5c336083b04f9471b8c6ed73679b74d66c363ec": { "balance": "3014100000000000000000" }, "7ad3f307616f19dcb143e6444dab9c3c33611f52": { "balance": "50000000000000000000" }, "455cb8ee39ffbc752331e5aefc588ef0ee593454": { "balance": "999963000000000000000" }, "c4c01afc3e0f045221da1284d7878574442fb9ac": { "balance": "7419944000000000000000" }, "99268327c373332e06c3f6164287d455b9d5fa4b": { "balance": "2000000000000000000000" }, "4367ae4b0ce964f4a54afd4b5c368496db169e9a": { "balance": "2000000000000000000000" }, "2cd79eb52027b12c18828e3eaab2969bfcd287e9": { "balance": "20000000000000000000" }, "b96841cabbc7dbd69ef0cf8f81dff3c8a5e21570": { "balance": "12000000000000000000000" }, "d7ebddb9f93987779b680155375438db65afcb6a": { "balance": "100600000000000000000" }, "0631d18bbbbd30d9e1732bf36edae2ce8901ab80": { "balance": "3024800000000000000000" }, "5fad960f6b2c84569c9f4d47bf1985fcb2c65da6": { "balance": "999972000000000000000" }, "01d599ee0d5f8c38ab2d392e2c65b74c3ce31820": { "balance": "510000000000000000000" }, "ff0cc8dac824fa24fc3caa2169e6e057cf638ad6": { "balance": "4000000000000000000000" }, "c25266c7676632f13ef29be455ed948add567792": { "balance": "1337000000000000000000" }, "9c344098ba615a398f11d009905b177c44a7b602": { "balance": "1000000000000000000000" }, "3b0accaf4b607cfe61d17334c214b75cdefdbd89": { "balance": "2000000000000000000000" }, "6d6634b5b8a40195d949027af4828802092ceeb6": { "balance": "3000000000000000000000" }, "208c45732c0a378f17ac8324926d459ba8b658b4": { "balance": "2955000000000000000000" }, "c24399b4bf86f7338fbf645e3b22b0e0b7973912": { "balance": "2000000000000000000000" }, "29763dd6da9a7c161173888321eba6b63c8fb845": { "balance": "328000000000000000000" }, "9c2fd54089af665df5971d73b804616039647375": { "balance": "1000000000000000000000" }, "0e09646c99af438e99fa274cb2f9c856cb65f736": { "balance": "1910000000000000000000" }, "be73274d8c5aa44a3cbefc8263c37ba121b20ad3": { "balance": "500000000000000000000" }, "ecfd004d02f36cd4d8b4a8c1a9533b6af85cd716": { "balance": "5003800000000000000000" }, "f978b025b64233555cc3c19ada7f4199c9348bf7": { "balance": "400000000000000000000000" }, "705ddd38355482b8c7d3b515bda1500dd7d7a817": { "balance": "400000000000000000000" }, "2b8a0dee5cb0e1e97e15cfca6e19ad21f995efad": { "balance": "504206000000000000000" }, "1098cc20ef84bad5146639c4cd1ca6c3996cb99b": { "balance": "18200000000000000000" }, "afdac5c1cb56e245bf70330066a817eaafac4cd1": { "balance": "20000000000000000000" }, "910e996543344c6815fb97cda7af4b8698765a5b": { "balance": "103400000000000000000" }, "94612781033b57b146ee74e753c672017f5385e4": { "balance": "3600000000000000000000" }, "d03fc165576aaed525e5502c8e140f8b2e869639": { "balance": "6850000000000000000000" }, "293384c42b6f8f2905ce52b7205c2274376c612b": { "balance": "1400000000000000000000" }, "09ee12b1b42b05af9cf207d5fcac255b2ec411f2": { "balance": "58929000000000000000" }, "dbd71efa4b93c889e76593de609c3b04cbafbe08": { "balance": "20000000000000000000" }, "fa86ca27bf2854d98870837fb6f6dfe4bf6453fc": { "balance": "322061000000000000000" }, "61ff8e67b34d9ee6f78eb36ffea1b9f7c15787af": { "balance": "1640000000000000000000" }, "6d4cbf3d8284833ae99344303e08b4d614bfda3b": { "balance": "12000000000000000000000" }, "2ff160c44f72a299b5ec2d71e28ce5446d2fcbaf": { "balance": "360000000000000000000" }, "94a7cda8f481f9d89d42c303ae1632b3b709db1d": { "balance": "300000000000000000000" }, "7566496162ba584377be040a4f87777a707acaeb": { "balance": "4000000000000000000000" }, "bdc461462b6322b462bdb33f22799e8108e2417d": { "balance": "668500000000000000000" }, "7e47637e97c14622882be057bea229386f4052e5": { "balance": "440000000000000000000" }, "3b5c251d7fd7893ba209fe541cecd0ce253a990d": { "balance": "30000000000000000000000" }, "0e498800447177b8c8afc3fdfa7f69f4051bb629": { "balance": "2140234000000000000000" }, "b71623f35107cf7431a83fb3d204b29ee0b1a7f4": { "balance": "19700000000000000000" }, "1d395b30adda1cf21f091a4f4a7b753371189441": { "balance": "100000000000000000000000" }, "2c2428e4a66974edc822d5dbfb241b2728075158": { "balance": "2000000000000000000000" }, "a575f2891dcfcda83c5cf01474af11ee01b72dc2": { "balance": "100076000000000000000" }, "ad728121873f0456d0518b80ab6580a203706595": { "balance": "500000000000000000000" }, "48669eb5a801d8b75fb6aa58c3451b7058c243bf": { "balance": "30940000000000000000000" }, "b3ae54fba09d3ee1d6bdd1e957923919024c35fa": { "balance": "65513000000000000000" }, "0d35408f226566116fb8acdaa9e2c9d59b76683f": { "balance": "940000000000000000000" }, "df211cd21288d6c56fae66c3ff54625dd4b15427": { "balance": "2500024000000000000000" }, "8a746c5d67064711bfca685b95a4fe291a27028e": { "balance": "40000000000000000000" }, "1cf105ab23023b554c583e86d7921179ee83169f": { "balance": "1970000000000000000000" }, "8cfedef198db0a9143f09129b3fd64dcbb9b4956": { "balance": "2000000000000000000000" }, "1e381adcf801a3bf9fd7bfac9ccc2b8482ad5e66": { "balance": "600200000000000000000" }, "e74608f506866ada6bfbfdf20fea440be76989ef": { "balance": "1999944000000000000000" }, "27e63989ca1e903bc620cf1b9c3f67b9e2ae6581": { "balance": "1337000000000000000000" }, "bb0857f1c911b24b86c8a70681473fe6aaa1cce2": { "balance": "100000000000000000000" }, "4f8e8d274fb22a3fd36a47fe72980471544b3434": { "balance": "200000000000000000000" }, "127d3fc5003bf63c0d83e93957836515fd279045": { "balance": "111890000000000000000" }, "95809e8da3fbe4b7f281f0b8b1715f420f7d7d63": { "balance": "2000000000000000000000" }, "28904bb7c4302943b709b14d7970e42b8324e1a1": { "balance": "10027500000000000000000" }, "c07e3867ada096807a051a6c9c34cc3b3f4ad34a": { "balance": "1788210000000000000000" }, "f0b469eae89d400ce7d5d66a9695037036b88903": { "balance": "20000000000000000000000" }, "7445202f0c74297a004eb3726aa6a82dd7c02fa1": { "balance": "2000000000000000000000" }, "c58f62fee9711e6a05dc0910b618420aa127f288": { "balance": "3980000000000000000000" }, "801d65c518b11d0e3f4f470221417013c8e53ec5": { "balance": "4000000000000000000000" }, "41010fc8baf8437d17a04369809a168a17ca56fb": { "balance": "100000000000000000000" }, "a1998144968a5c70a6415554cefec2824690c4a5": { "balance": "20000000000000000000" }, "e9559185f166fc9513cc71116144ce2deb0f1d4b": { "balance": "20000000000000000000000" }, "ed5b4c41e762d942404373caf21ed4615d25e6c1": { "balance": "2013960000000000000000" }, "665b000f0b772750cc3c217a5ef429a92bf1ccbb": { "balance": "4000000000000000000000" }, "febd9f81cf78bd5fb6c4b9a24bd414bb9bfa4c4e": { "balance": "1990019000000000000000" }, "a072691c8dd7cd4237ff72a75c1a9506d0ce5b9e": { "balance": "370000000000000000000" }, "6765df25280e8e4f38d4b1cf446fc5d7eb659e34": { "balance": "100000000000000000000" }, "524fb210522c5e23bb67dfbf8c26aa616da49955": { "balance": "999971000000000000000" }, "e987e6139e6146a717fef96bc24934a5447fe05d": { "balance": "2000000000000000000000" }, "d6110276cfe31e42825a577f6b435dbcc10cf764": { "balance": "1000000000000000000000" }, "5e51b8a3bb09d303ea7c86051582fd600fb3dc1a": { "balance": "20000000000000000000" }, "5c4f24e994ed8f850ea7818f471c8fac3bcf0452": { "balance": "1724800000000000000000" }, "85b2998d0c73302cb2ba13f489313301e053be15": { "balance": "10000000000000000000000" }, "0af6c8d539c96d50259e1ba6719e9c8060f388c2": { "balance": "1000000000000000000000" }, "7d901b28bf7f88ef73d8f73cca97564913ea8a24": { "balance": "955000000000000000000" }, "e01859f242f1a0ec602fa8a3b0b57640ec89075e": { "balance": "555000000000000000000" }, "c66ae4cee87fb3353219f77f1d6486c580280332": { "balance": "29550000000000000000" }, "2d40558b06f90a3923145592123b6774e46e31f4": { "balance": "1000000000000000000000" }, "ccf43975b76bfe735fec3cb7d4dd24f805ba0962": { "balance": "60000000000000000000" }, "1703b4b292b8a9deddede81bb25d89179f6446b6": { "balance": "19690000000000000000000" }, "0e9096d343c060db581a120112b278607ec6e52b": { "balance": "20000000000000000000" }, "f65819ac4cc14c137f05dd7977c7dae08d1a4ab5": { "balance": "102000000000000000000" }, "ca373fe3c906b8c6559ee49ccd07f37cd4fb5266": { "balance": "1790000000000000000000" }, "d28298524df5ec4b24b0ffb9df85170a145a9eb5": { "balance": "287700000000000000000" }, "5fcda847aaf8d7fa8bca08029ca2849166aa15a3": { "balance": "623350000000000000000" }, "bdc739a699700b2e8e2c4a4c7b058a0e513ddebe": { "balance": "2000000000000000000000" }, "0bb05f7224bb5804856556c07eeadbed87ba8f7c": { "balance": "401100000000000000000" }, "ab416fe30d58afe5d9454c7fce7f830bcc750356": { "balance": "114515000000000000000" }, "3eee6f1e96360b7689b3069adaf9af8eb60ce481": { "balance": "1000000000000000000000" }, "9a0d3cee3d9892ea3b3700a27ff84140d9025493": { "balance": "60000000000000000000" }, "5dc36de5359450a1ec09cb0c44cf2bb42b3ae435": { "balance": "1117500000000000000000" }, "35c8adc11125432b3b77acd64625fe58ebee9d66": { "balance": "2000000000000000000000" }, "a5e9cd4b74255d22b7d9b27ae8dd43ed6ed0252b": { "balance": "766527000000000000000" }, "31ea12d49a35a740780ddeeaece84c0835b26270": { "balance": "200000000000000000000" }, "7aef7b551f0b9c46e755c0f38e5b3a73fe1199f5": { "balance": "1490000000000000000000" }, "cc6d7b12061bc96d104d606d65ffa32b0036eb07": { "balance": "10000000000000000000000" }, "322021022678a0166d204b3aaa7ad4ec4b88b7d0": { "balance": "400000000000000000000" }, "b31196714a48dff726ea9433cd2912f1a414b3b3": { "balance": "2680000000000000000000" }, "0f2fb884c8aaff6f543ac6228bd08e4f60b0a5fd": { "balance": "3145000000000000000000" }, "7d9d221a3df89ddd7b5f61c1468c6787d6b333e6": { "balance": "138000000000000000000" }, "367f59cc82795329384e41e1283115e791f26a01": { "balance": "2000000000000000000000" }, "fd9579f119bbc819a02b61e38d8803c942f24d32": { "balance": "105600000000000000000" }, "3e2f26235e137a7324e4dc154b5df5af46ea1a49": { "balance": "22458000000000000000" }, "4c1579af3312e4f88ae93c68e9449c2e9a68d9c4": { "balance": "2000000000000000000000" }, "ffb04726dfa41afdc819168418610472970d7bfc": { "balance": "4000000000000000000000" }, "403c64896a75cad816a9105e18d8aa5bf80f238e": { "balance": "985000000000000000000" }, "5cd588a14ec648ccf64729f9167aa7bf8be6eb3d": { "balance": "1000000000000000000000" }, "24b2be118b16d8b2174769d17b4cf84f07ca946d": { "balance": "2000000000000000000000" }, "d3bb59fa31258be62f8ed232f1a7d47b4a0b41ee": { "balance": "100000000000000000000" }, "cc9ac715cd6f2610c52b58676456884297018b29": { "balance": "13370000000000000000" }, "6f2a31900e240395b19f159c1d00dfe4d898ebdf": { "balance": "1999600000000000000000" }, "d60b247321a32a5affb96b1e279927cc584de943": { "balance": "2265500000000000000000" }, "f7a1ade2d0f529123d1055f19b17919f56214e67": { "balance": "500000000000000000000" }, "bea00df17067a43a82bc1daecafb6c14300e89e6": { "balance": "1820000000000000000000" }, "a2968fc1c64bac0b7ae0d68ba949874d6db253f4": { "balance": "20000000000000000000000" }, "92d8ad9a4d61683b80d4a6672e84c20d62421e80": { "balance": "20000000000000000000" }, "6ed2a12b02f8c688c7b5d3a6ea14d63687dab3b6": { "balance": "2000000000000000000000" }, "7a63869fc767a4c6b1cd0e0649f3634cb121d24b": { "balance": "77500000000000000000" }, "84f522f0520eba52dd18ad21fa4b829f2b89cb97": { "balance": "4949566000000000000000" }, "d6234aaf45c6f22e66a225ffb93add629b4ef80f": { "balance": "1000000000000000000000" }, "e3d8bf4efe84b1616d1b89e427ddc6c8830685ae": { "balance": "2000000000000000000000" }, "a3db364a332d884ba93b2617ae4d85a1489bea47": { "balance": "1700000000000000000000" }, "9f7986924aeb02687cd64189189fb167ded2dd5c": { "balance": "985000000000000000000" }, "2eaf4e2a46b789ccc288c8d1d9294e3fb0853896": { "balance": "2000000000000000000000" }, "a02dc6aa328b880de99eac546823fccf774047fb": { "balance": "1970000000000000000000" }, "873b7f786d3c99ff012c4a7cae2677270240b9c5": { "balance": "1730000000000000000000" }, "1d69c83d28ff0474ceebeacb3ad227a144ece7a3": { "balance": "5474937000000000000000" }, "7b827cae7ff4740918f2e030ab26cb98c4f46cf5": { "balance": "7460000000000000000000" }, "3083ef0ed4c4401196774a95cf4edc83edc1484f": { "balance": "170000000000000000000000" }, "40ad74bc0bce2a45e52f36c3debb1b3ada1b7619": { "balance": "6790000000000000000000" }, "05423a54c8d0f9707e704173d923b946edc8e700": { "balance": "127543000000000000000" }, "22eb7db0ba56b0f8b816ccb206e615d929185b0d": { "balance": "80500000000000000000" }, "66082c75a8de31a53913bbd44de3a0374f7faa41": { "balance": "1460000000000000000000" }, "e3d3eaa299887865569e88be219be507189be1c9": { "balance": "456156000000000000000" }, "ae57cc129a96a89981dac60d2ffb877d5dc5e432": { "balance": "1110994000000000000000" }, "1a2434cc774422d48d53d59c5d562cce8407c94b": { "balance": "30000000000000000000" }, "21546914dfd3af2add41b0ff3e83ffda7414e1e0": { "balance": "5969100000000000000000" }, "4dcf62a3de3f061db91498fd61060f1f6398ff73": { "balance": "1999944000000000000000" }, "6fd98e563d12ce0fd60f4f1f850ae396a9823c02": { "balance": "1261000000000000000000" }, "edf8a3e1d40f13b79ec8e3e1ecf262fd92116263": { "balance": "158000000000000000000" }, "c09e3cfc19f605ff3ec9c9c70e2540d7ee974366": { "balance": "500000000000000000000" }, "953572f0ea6df9b197cae40e4b8ecc056c4371c5": { "balance": "1000000000000000000000" }, "163cc8be227646cb09719159f28ed09c5dc0dce0": { "balance": "1337000000000000000000" }, "a3932a31d6ff75fb3b1271ace7caa7d5e1ff1051": { "balance": "20000000000000000000000" }, "f9a94bd56198da245ed01d1e6430b24b2708dcc0": { "balance": "749938000000000000000" }, "3eb8b33b21d23cda86d8288884ab470e164691b5": { "balance": "500000000000000000000" }, "84bcbf22c09607ac84341d2edbc03bfb1739d744": { "balance": "500000000000000000000" }, "961c59adc74505d1864d1ecfcb8afa0412593c93": { "balance": "40000000000000000000000" }, "f068dfe95d15cd3a7f98ffa688b4346842be2690": { "balance": "1255160000000000000000" }, "291efe0081dce8c14799f7b2a43619c0c3b3fc1f": { "balance": "1200000000000000000000" }, "be4fd073617022b67f5c13499b827f763639e4e3": { "balance": "2000000000000000000000" }, "e40a7c82e157540a0b00901dbb86c716e1a062da": { "balance": "49800000000000000000" }, "6635b46f711d2da6f0e16370cd8ee43efb2c2d52": { "balance": "2000000000000000000000" }, "43748928e8c3ec4436a1d092fbe43ac749be1251": { "balance": "400000000000000000000" }, "b557ab9439ef50d237b553f02508364a466a5c03": { "balance": "200000000000000000000" }, "11928378d27d55c520ceedf24ceb1e822d890df0": { "balance": "8000000000000000000000" }, "61518464fdd8b73c1bb6ac6db600654938dbf17a": { "balance": "200000000000000000000" }, "004bfbe1546bc6c65b5c7eaa55304b38bbfec6d3": { "balance": "2000000000000000000000" }, "a5e0fc3c3affed3db6710947d1d6fb017f3e276d": { "balance": "2000000000000000000000" }, "8ecbcfacbfafe9f00c3922a24e2cf0026756ca20": { "balance": "5640000000000000000000" }, "fb5ffaa0f7615726357891475818939d2037cf96": { "balance": "20000000000000000000" }, "ae222865799079aaf4f0674a0cdaab02a6d570ff": { "balance": "2000000000000000000000" }, "9edc90f4be210865214ab5b35e5a8dd77415279d": { "balance": "4000000000000000000000" }, "9d7831e834c20b1baa697af1d8e0c621c5afff9a": { "balance": "86500000000000000000" }, "046d274b1af615fb505a764ad8dda770b1db2f3d": { "balance": "2000000000000000000000" }, "eaea23aa057200e7c9c15e8ff190d0e66c0c0e83": { "balance": "2000000000000000000000" }, "417a3cd19496530a6d4204c3b5a17ce0f207b1a5": { "balance": "8000000000000000000000" }, "a035a3652478f82dbd6d115faa8ca946ec9e681d": { "balance": "109880000000000000000" }, "4f5801b1eb30b712d8a0575a9a71ff965d4f34eb": { "balance": "300000000000000000000" }, "91dbb6aaad149585be47375c5d6de5ff09191518": { "balance": "20000000000000000000000" }, "d043a011ec4270ee7ec8b968737515e503f83028": { "balance": "500000000000000000000" }, "bb371c72c9f0316cea2bd9c6fbb4079e775429ef": { "balance": "1760000000000000000000" }, "aa1df92e51dff70b1973e0e924c66287b494a178": { "balance": "534400000000000000000" }, "bd5f46caab2c3d4b289396bbb07f203c4da82530": { "balance": "80000000000000000000" }, "4d29fc523a2c1629532121da9998e9b5ab9d1b45": { "balance": "15800000000000000000" }, "addb26317227f45c87a2cb90dc4cfd02fb23caf8": { "balance": "1000000000000000000000" }, "52e46783329a769301b175009d346768f4c87ee4": { "balance": "2000000000000000000000" }, "caad9dc20d589ce428d8fda3a9d53a607b7988b5": { "balance": "4000000000000000000000" }, "95034e1621865137cd4739b346dc17da3a27c34e": { "balance": "1580000000000000000000" }, "0c3239e2e841242db989a61518c22247e8c55208": { "balance": "263656000000000000000" }, "5a0d609aae2332b137ab3b2f26615a808f37e433": { "balance": "160000000000000000000000" }, "2334c590c7a48769103045c5b6534c8a3469f44a": { "balance": "17443200000000000000000" }, "ddfcca13f934f0cfbe231da13039d70475e6a1d0": { "balance": "1000169000000000000000" }, "ee7288d91086d9e2eb910014d9ab90a02d78c2a0": { "balance": "2000000000000000000000" }, "fb91fb1a695553f0c68e21276decf0b83909b86d": { "balance": "100016000000000000000" }, "38695fc7e1367ceb163ebb053751f9f68ddb07a0": { "balance": "2000000000000000000000" }, "65093b239bbfba23c7775ca7da5a8648a9f54cf7": { "balance": "400000000000000000000" }, "73d8fee3cb864dce22bb26ca9c2f086d5e95e63b": { "balance": "1000000000000000000000" }, "f7155213449892744bc60f2e04400788bd041fdd": { "balance": "66850000000000000000" }, "d1a71b2d0858e83270085d95a3b1549650035e23": { "balance": "14900000000000000000000" }, "eac17b81ed5191fb0802aa54337313834107aaa4": { "balance": "8000000000000000000000" }, "bb076aac92208069ea318a31ff8eeb14b7e996e3": { "balance": "149000000000000000000" }, "9f46e7c1e9078cae86305ac7060b01467d6685ee": { "balance": "668500000000000000000" }, "1598127982f2f8ad3b6b8fc3cf27bf617801ba2b": { "balance": "173000000000000000000" }, "e91dac0195b19e37b59b53f7c017c0b2395ba44c": { "balance": "1880000000000000000000" }, "a436c75453ccca4a1f1b62e5c4a30d86dde4be68": { "balance": "2000000000000000000000" }, "11001b89ed873e3aaec1155634b4681643986323": { "balance": "1000000000000000000000" }, "ab93b26ece0a0aa21365afed1fa9aea31cd54468": { "balance": "1608000000000000000000" }, "e77febabdf080f0f5dca1d3f5766f2a79c0ffa7c": { "balance": "1386000000000000000000" }, "1c4af0e863d2656c8635bc6ffec8dd9928908cb5": { "balance": "2000000000000000000000" }, "0c48ae62d1539788eba013d75ea60b64eeba4e80": { "balance": "2213311000000000000000" }, "423cc4594cf4abb6368de59fd2b1230734612143": { "balance": "2000000000000000000000" }, "7f6b28c88421e4857e459281d78461692489d3fb": { "balance": "2000000000000000000000" }, "806854588ecce541495f81c28a290373df0274b2": { "balance": "582000000000000000000" }, "dc76e85ba50b9b31ec1e2620bce6e7c8058c0eaf": { "balance": "20000000000000000000" }, "b00996b0566ecb3e7243b8227988dcb352c21899": { "balance": "12000000000000000000000" }, "f5d14552b1dce0d6dc1f320da6ffc8a331cd6f0c": { "balance": "1337000000000000000000" }, "55a61b109480b5b2c4fcfdef92d90584160c0d35": { "balance": "44700000000000000000" }, "b8947822d5ace7a6ad8326e95496221e0be6b73d": { "balance": "20000000000000000000" }, "492de46aaf8f1d708d59d79af1d03ad2cb60902f": { "balance": "2000000000000000000000" }, "0e0d6633db1e0c7f234a6df163a10e0ab39c200f": { "balance": "200000000000000000000" }, "f8bf9c04874e5a77f38f4c38527e80c676f7b887": { "balance": "2000000000000000000000" }, "15528350e0d9670a2ea27f7b4a33b9c0f9621d21": { "balance": "4000086000000000000000" }, "eccf7a0457b566b346ca673a180f444130216ac3": { "balance": "100000000000000000000" }, "10cf560964ff83c1c9674c783c0f73fcd89943fc": { "balance": "40000000000000000000000" }, "e7f06f699be31c440b43b4db0501ec0e25261644": { "balance": "500000000000000000000" }, "b6ce4dc560fc73dc69fb7a62e388db7e72ea764f": { "balance": "966000000000000000000" }, "f456055a11ab91ff668e2ec922961f2a23e3db25": { "balance": "18200000000000000000" }, "8dfbafbc0e5b5c86cd1ad697feea04f43188de96": { "balance": "390060000000000000000" }, "085b4ab75d8362d914435cedee1daa2b1ee1a23b": { "balance": "3880000000000000000000" }, "e400d651bb3f2d23d5f849e6f92d9c5795c43a8a": { "balance": "2674000000000000000000" }, "851aa91c82f42fad5dd8e8bb5ea69c8f3a5977d1": { "balance": "148607000000000000000" }, "4c935bb250778b3c4c7f7e07fc251fa630314aab": { "balance": "1500000000000000000000" }, "ebd356156a383123343d48843bffed6103e866b3": { "balance": "1970000000000000000000" }, "da0b48e489d302b4b7bf204f957c1c9be383b0df": { "balance": "2000000000000000000000" }, "7085ae7e7e4d932197b5c7858c00a3674626b7a5": { "balance": "6000000000000000000000" }, "5b06d1e6930c1054692b79e3dbe6ecce53966420": { "balance": "205400000000000000000" }, "8df53d96191471e059de51c718b983e4a51d2afd": { "balance": "32000000000000000000000" }, "0678654ac6761db904a2f7e8595ec1eaac734308": { "balance": "878000000000000000000" }, "89fee30d1728d96cecc1dab3da2e771afbcfaa41": { "balance": "1999944000000000000000" }, "59c5d06b170ee4d26eb0a0eb46cb7d90c1c91019": { "balance": "10000000000000000000000" }, "2b129c26b75dde127f8320bd0f63410c92a9f876": { "balance": "2200000000000000000000" }, "3d6ae053fcbc318d6fd0fbc353b8bf542e680d27": { "balance": "14300000000000000000" }, "755a60bf522fbd8fff9723446b7e343a7068567e": { "balance": "20000000000000000000000" }, "947e11e5ea290d6fc3b38048979e0cd44ec7c17f": { "balance": "2000000000000000000000" }, "711ecf77d71b3d0ea95ce4758afecdb9c131079d": { "balance": "760000000000000000000" }, "de9eff4c798811d968dccb460d9b069cf30278e0": { "balance": "400000000000000000000" }, "4e892e8081bf36e488fddb3b2630f3f1e8da30d2": { "balance": "12003800000000000000000" }, "8ede7e3dc50749c6c50e2e28168478c34db81946": { "balance": "19999800000000000000000" }, "0c30cacc3f72269f8b4f04cf073d2b05a83d9ad1": { "balance": "2001000000000000000000" }, "e51eb87e7fb7311f5228c479b48ec9878831ac4c": { "balance": "2000000000000000000000" }, "8b01da34d470c1d115acf4d8113c4dd8a8c338e4": { "balance": "25220000000000000000000" }, "4329fc0931cbeb033880fe4c9398ca45b0e2d11a": { "balance": "2000400000000000000000" }, "540c072802014ef0d561345aec481e8e11cb3570": { "balance": "8000000000000000000000" }, "21e5d2bae995ccfd08a5c16bb524e1f630448f82": { "balance": "2800000000000000000000" }, "5cf8c03eb3e872e50f7cfd0c2f8d3b3f2cb5183a": { "balance": "200000000000000000000" }, "5c0f2e51378f6b0d7bab617331580b6e39ad3ca5": { "balance": "9600000000000000000000" }, "d2f241255dd7c3f73c07043071ec08ddd9c5cde5": { "balance": "500000000000000000000" }, "cbe1b948864d8474e765145858fca4550f784b92": { "balance": "10000000000000000000000" }, "30742ccdf4abbcd005681f8159345c9e79054b1a": { "balance": "668500000000000000000" }, "6aeb9f74742ea491813dbbf0d6fcde1a131d4db3": { "balance": "440800000000000000000" }, "821eb90994a2fbf94bdc3233910296f76f9bf6e7": { "balance": "10000000000000000000000" }, "25c1a37ee5f08265a1e10d3d90d5472955f97806": { "balance": "1820000000000000000000" }, "7ef98b52bee953bef992f305fda027f8911c5851": { "balance": "514717000000000000000" }, "8adc53ef8c18ed3051785d88e996f3e4b20ecd51": { "balance": "42000000000000000000000" }, "007f4a23ca00cd043d25c2888c1aa5688f81a344": { "balance": "773658000000000000000" }, "4a735d224792376d331367c093d31c8794341582": { "balance": "1900000000000000000000" }, "05440c5b073b529b4829209dff88090e07c4f6f5": { "balance": "1288000000000000000000" }, "5e772e27f28800c50dda973bb33e10762e6eea20": { "balance": "1790000000000000000000" }, "a429fa88731fdd350e8ecd6ea54296b6484fe695": { "balance": "1969606000000000000000" }, "e0d76b7166b1f3a12b4091ee2b29de8caa7d07db": { "balance": "2000000000000000000000" }, "7ebd95e9c470f7283583dc6e9d2c4dce0bea8f84": { "balance": "14000000000000000000000" }, "883a78aeabaa50d8ddd8570bcd34265f14b19363": { "balance": "3879951000000000000000" }, "51f9c432a4e59ac86282d6adab4c2eb8919160eb": { "balance": "530000000000000000000000" }, "b86607021b62d340cf2652f3f95fd2dc67698bdf": { "balance": "5000000000000000000000" }, "acc0909fda2ea6b7b7a88db7a0aac868091ddbf6": { "balance": "22155000000000000000" }, "69b80ed90f84834afa3ff82eb964703b560977d6": { "balance": "26740000000000000000" }, "ca4ca9e4779d530ecbacd47e6a8058cfde65d98f": { "balance": "800000000000000000000" }, "5d6c5c720d66a6abca8397142e63d26818eaab54": { "balance": "40000000000000000000" }, "c2c13e72d268e7150dc799e7c6cf03c88954ced7": { "balance": "700000000000000000000" }, "6bbd1e719390e6b91043f8b6b9df898ea8001b34": { "balance": "2000053000000000000000" }, "a9ba6f413b82fcddf3affbbdd09287dcf50415ca": { "balance": "4000000000000000000000" }, "ced3c7be8de7585140952aeb501dc1f876ecafb0": { "balance": "4000000000000000000000" }, "1c63fa9e2cbbf23c49fcdef1cbabfe6e0d1e14c1": { "balance": "1000000000000000000000" }, "7d6e990daa7105de2526339833f77b5c0b85d84f": { "balance": "20000000000000000000000" }, "68addf019d6b9cab70acb13f0b3117999f062e12": { "balance": "49941000000000000000" }, "a77428bcb2a0db76fc8ef1e20e461a0a32c5ac15": { "balance": "401100000000000000000" }, "26048fe84d9b010a62e731627e49bc2eb73f408f": { "balance": "4000000000000000000000" }, "ff26138330274df4e0a3081e6df7dd983ec6e78f": { "balance": "2000000000000000000000" }, "b7382d37db0398ac72410cf9813de9f8e1ec8dad": { "balance": "1000070000000000000000" }, "44f62f2aaabc29ad3a6b04e1ff6f9ce452d1c140": { "balance": "17000000000000000000000" }, "47fef58584465248a0810d60463ee93e5a6ee8d3": { "balance": "283100000000000000000" }, "bd2b70fecc37640f69514fc7f3404946aad86b11": { "balance": "1200000000000000000000" }, "649a85b93653075fa6562c409a565d087ba3e1ba": { "balance": "2000000000000000000000" }, "55866486ec168f79dbe0e1abb18864d98991ae2c": { "balance": "16100000000000000000" }, "d7e74afdbad55e96cebc5a374f2c8b768680f2b0": { "balance": "99000000000000000000" }, "a8c1d6aa41fe3d65f67bd01de2a866ed1ed9ae52": { "balance": "30000000000000000000" }, "744c0c77ba7f236920d1e434de5da33e48ebf02c": { "balance": "1970000000000000000000" }, "9445ba5c30e98961b8602461d0385d40fbd80311": { "balance": "10000000000000000000000" }, "eb835c1a911817878a33d167569ea3cdd387f328": { "balance": "1000000000000000000000" }, "761a6e362c97fbbd7c5977acba2da74687365f49": { "balance": "183840000000000000000" }, "38202c5cd7078d4f887673ab07109ad8ada89720": { "balance": "1000000000000000000000" }, "5abfec25f74cd88437631a7731906932776356f9": { "balance": "11901484239480000000000000" }, "28e4af30cd93f686a122ad7bb19f8a8785eee342": { "balance": "2101000000000000000000" }, "3a9b111029ce1f20c9109c7a74eeeef34f4f2eb2": { "balance": "4000000000000000000000" }, "7bb9571f394b0b1a8eba5664e9d8b5e840677bea": { "balance": "19700000000000000000" }, "50fb36c27107ee2ca9a3236e2746cca19ace6b49": { "balance": "2000000000000000000000" }, "a3bc979b7080092fa1f92f6e0fb347e28d995045": { "balance": "2800000000000000000000" }, "d04b861b3d9acc563a901689941ab1e1861161a2": { "balance": "20000000000000000000" }, "58c555bc293cdb16c6362ed97ae9550b92ea180e": { "balance": "20000000000000000000" }, "8bf02bd748690e1fd1c76d270833048b66b25fd3": { "balance": "11800000000000000000000" }, "fbc01db54e47cdc3c438694ab717a856c23fe6e9": { "balance": "8456774000000000000000" }, "9c9a07a8e57c3172a919ef64789474490f0d9f51": { "balance": "10000000000000000000000" }, "fc7e22a503ec5abe9b08c50bd14999f520fa4884": { "balance": "6387725000000000000000" }, "9b773669e87d76018c090f8255e54409b9dca8b2": { "balance": "20000000000000000000" }, "ffe8cbc1681e5e9db74a0f93f8ed25897519120f": { "balance": "1507000000000000000000" }, "4d4cf5807429615e30cdface1e5aae4dad3055e6": { "balance": "600000000000000000000" }, "cfde0fc75d6f16c443c3038217372d99f5d907f7": { "balance": "2419000000000000000000" }, "818ffe271fc3973565c303f213f6d2da89897ebd": { "balance": "5734655000000000000000" }, "ba1fcaf223937ef89e85675503bdb7ca6a928b78": { "balance": "640000000000000000000" }, "a30a45520e5206d9004070e6af3e7bb2e8dd5313": { "balance": "400000000000000000000" }, "a747439ad0d393b5a03861d77296326de8bb9db9": { "balance": "1000000000000000000000" }, "14d00aad39a0a7d19ca05350f7b03727f08dd82e": { "balance": "500000000000000000000" }, "551999ddd205563327b9b530785acff9bc73a4ba": { "balance": "6000000000000000000000" }, "a4670731175893bbcff4fa85ce97d94fc51c4ba8": { "balance": "8000000000000000000000" }, "f858171a04d357a13b4941c16e7e55ddd4941329": { "balance": "41984000000000000000" }, "a6484cc684c4c91db53eb68a4da45a6a6bda3067": { "balance": "6000000000000000000000" }, "00d75ed60c774f8b3a5a5173fb1833ad7105a2d9": { "balance": "2005500000000000000000" }, "bf92418a0c6c31244d220260cb3e867dd7b4ef49": { "balance": "99800000000000000000" }, "716d50cca01e938500e6421cc070c3507c67d387": { "balance": "2000000000000000000000" }, "82a8b96b6c9e13ebec1e9f18ac02a60ea88a48ff": { "balance": "1999998000000000000000" }, "5a565285374a49eedd504c957d510874d00455bc": { "balance": "100000000000000000000" }, "778c79f4de1953ebce98fe8006d53a81fb514012": { "balance": "999800000000000000000" }, "41b2d34fde0b1029262b4172c81c1590405b03ae": { "balance": "1000000000000000000000" }, "4039bd50a2bde15ffe37191f410390962a2b8886": { "balance": "200000000000000000000" }, "c033be10cb48613bd5ebcb33ed4902f38b583003": { "balance": "3000000000000000000000" }, "5d5751819b4f3d26ed0c1ac571552735271dbefa": { "balance": "1000000000000000000000" }, "b600429752f399c80d0734744bae0a022eca67c6": { "balance": "20000000000000000000" }, "f875619d8a23e45d8998d184d480c0748970822a": { "balance": "4000000000000000000000" }, "71c7230a1d35bdd6819ed4b9a88e94a0eb0786dd": { "balance": "4365000000000000000000" }, "b2f9c972c1e9737755b3ff1b3088738396395b26": { "balance": "20000000000000000000000" }, "a66a4963b27f1ee1932b172be5964e0d3ae54b51": { "balance": "173000000000000000000" }, "53ce88e66c5af2f29bbd8f592a56a3d15f206c32": { "balance": "140840000000000000000" }, "433e3ba1c51b810fc467d5ba4dea42f7a9885e69": { "balance": "40000000000000000000000" }, "c7837ad0a0bf14186937ace06c5546a36aa54f46": { "balance": "4000000000000000000000" }, "c3f8f67295a5cd049364d05d23502623a3e52e84": { "balance": "6000000000000000000000" }, "3fd0bb47798cf44cdfbe4d333de637df4a00e45c": { "balance": "100040000000000000000" }, "a1ae8d4540d4db6fdde7146f415b431eb55c7983": { "balance": "197000000000000000000" }, "5cccf1508bfd35c20530aa642500c10dee65eaed": { "balance": "850000000000000000000" }, "a53ead54f7850af21438cbe07af686279a315b86": { "balance": "10000000000000000000000" }, "8cf6da0204dbc4860b46ad973fc111008d9e0c46": { "balance": "200000000000000000000" }, "8e7936d592008fdc7aa04edeeb755ab513dbb89d": { "balance": "20000000000000000000" }, "4a53dcdb56ce4cdce9f82ec0eb13d67352e7c88b": { "balance": "4200000000000000000000" }, "2b4f4507bb6b9817942ce433781b708fbcd166fd": { "balance": "18200000000000000000" }, "026432af37dc5113f1f46d480a4de0b28052237e": { "balance": "355800000000000000000" }, "e780a56306ba1e6bb331952c22539b858af9f77d": { "balance": "50000000000000000000000" }, "d1f1694d22671b5aad6a94995c369fbe6133676f": { "balance": "1000000000000000000000" }, "7c45f0f8442a56dbd39dbf159995415c52ed479b": { "balance": "2000000000000000000000" }, "b65941d44c50d24666670d364766e991c02e11c2": { "balance": "600000000000000000000" }, "45e68db8dbbaba5fc2cb337c62bcd0d61b059189": { "balance": "2000000000000000000000" }, "05f3631f5664bdad5d0132c8388d36d7d8920918": { "balance": "20000000000000000000" }, "5475d7f174bdb1f789017c7c1705989646079d49": { "balance": "9400000000000000000000" }, "c7bf2ed1ed312940ee6aded1516e268e4a604856": { "balance": "6000000000000000000000" }, "39aaf0854db6eb39bc7b2e43846a76171c0445de": { "balance": "1850000000000000000000" }, "c817df1b91faf30fe3251571727c9711b45d8f06": { "balance": "1999944000000000000000" }, "7d13d6705884ab2157dd8dcc7046caf58ee94be4": { "balance": "137200000000000000000000" }, "478dc09a1311377c093f9cc8ae74111f65f82f39": { "balance": "4000000000000000000000" }, "8043ed22f997e5a2a4c16e364486ae64975692c4": { "balance": "1130513000000000000000" }, "b9a985501ee950829b17fae1c9cf348c3156542c": { "balance": "294100000000000000000" }, "d5cba5b26bea5d73fabb1abafacdef85def368cc": { "balance": "200000000000000000000" }, "6776e133d9dc354c12a951087b639650f539a433": { "balance": "120000000000000000000" }, "804ca94972634f633a51f3560b1d06c0b293b3b1": { "balance": "200000000000000000000" }, "0be1fdf626ee6189102d70d13b31012c95cd1cd6": { "balance": "2000000000000000000000" }, "f848fce9ab611c7d99206e23fac69ad488b94fe1": { "balance": "48500000000000000000" }, "f01195d657ef3c942e6cb83949e5a20b5cfa8b1e": { "balance": "25760000000000000000000" }, "78a5e89900bd3f81dd71ba869d25fec65261df15": { "balance": "51900000000000000000000" }, "d6f1e55b1694089ebcb4fe7d7882aa66c8976176": { "balance": "19998846000000000000000" }, "d5294b666242303b6df0b1c88d37429bc8c965aa": { "balance": "300700000000000000000" }, "3171877e9d820cc618fc0919b29efd333fda4934": { "balance": "1000000000000000000000" }, "2901f8077f34190bb47a8e227fa29b30ce113b31": { "balance": "100000000000000000000" }, "6b2284440221ce16a8382de5ff0229472269deec": { "balance": "1000000000000000000000" }, "1bba03ff6b4ad5bf18184acb21b188a399e9eb4a": { "balance": "1790000000000000000000" }, "80744618de396a543197ee4894abd06398dd7c27": { "balance": "2000000000000000000000" }, "1b799033ef6dc7127822f74542bb22dbfc09a308": { "balance": "100000000000000000000" }, "d513a45080ff2febe62cd5854abe29ee4467f996": { "balance": "153200000000000000000" }, "e761d27fa3502cc76bb1a608740e1403cf9dfc69": { "balance": "280000000000000000000" }, "53989ed330563fd57dfec9bd343c3760b0799390": { "balance": "6208000000000000000000" }, "ccf7110d1bd9a74bfd1d7d7d2d9d55607e7b837d": { "balance": "900000000000000000000" }, "f373e9daac0c8675f53b797a160f6fc034ae6b23": { "balance": "100000000000000000000" }, "abc9a99e8a2148a55a6d82bd51b98eb5391fdbaf": { "balance": "6000000000000000000000" }, "ffec0913c635baca2f5e57a37aa9fb7b6c9b6e26": { "balance": "805000000000000000000" }, "581a3af297efa4436a29af0072929abf9826f58b": { "balance": "2000000000000000000000" }, "924efa6db595b79313277e88319625076b580a10": { "balance": "2000000000000000000000" }, "65d8dd4e251cbc021f05b010f2d5dc520c3872e0": { "balance": "834956000000000000000" }, "6c67d6db1d03516c128b8ff234bf3d49b26d2941": { "balance": "100000000000000000000000" }, "496d365534530a5fc1577c0a5241cb88c4da7072": { "balance": "1790000000000000000000" }, "b85ff03e7b5fc422981fae5e9941dacbdaba7584": { "balance": "1337000000000000000000" }, "e13540ecee11b212e8b775dc8e71f374aae9b3f8": { "balance": "2000000000000000000000" }, "a02e3f8f5959a7aab7418612129b701ca1b80010": { "balance": "20000000000000000000" }, "a7a3f153cdc38821c20c5d8c8241b294a3f82b24": { "balance": "500000000000000000000" }, "366175403481e0ab15bb514615cbb989ebc68f82": { "balance": "2000000000000000000000" }, "5104ecc0e330dd1f81b58ac9dbb1a9fbf88a3c85": { "balance": "100000000000000000000000" }, "a466d770d898d8c9d405e4a0e551efafcde53cf9": { "balance": "492500000000000000000" }, "5fa8a54e68176c4fe2c01cf671c515bfbdd528a8": { "balance": "330000000000000000000000" }, "e2e15c60dd381e3a4be25071ab249a4c5c5264da": { "balance": "2350502000000000000000" }, "0628bfbe5535782fb588406bc96660a49b011af5": { "balance": "1520000000000000000000" }, "04d6b8d4da867407bb997749debbcdc0b358538a": { "balance": "1000000000000000000000" }, "0e6ec313376271dff55423ab5422cc3a8b06b22b": { "balance": "4000000000000000000000" }, "8787d12677a5ec291e57e31ffbfad105c3324b87": { "balance": "12438777000000000000000" }, "58e2f11223fc8237f69d99c6289c148c0604f742": { "balance": "24000000000000000000000" }, "5600730a55f6b20ebd24811faa3de96d1662abab": { "balance": "1880000000000000000000" }, "fce089635ce97abac06b44819be5bb0a3e2e0b37": { "balance": "92491000000000000000" }, "fa0c1a988c8a17ad3528eb28b3409daa58225f26": { "balance": "200000000000000000000" }, "7ae1c19e53c71cee4c73fae2d7fc73bf9ab5e392": { "balance": "1000000000000000000000" }, "bd17eed82b9a2592019a1b1b3c0fbad45c408d22": { "balance": "250000000000000000000" }, "884a7a39d0916e05f1c242df55607f37df8c5fda": { "balance": "23400000000000000000000" }, "ca70f4ddbf069d2143bd6bbc7f696b52789b32e7": { "balance": "3000000000000000000000" }, "7b25bb9ca8e702217e9333225250e53c36804d48": { "balance": "1880000000000000000000" }, "ea8317197959424041d9d7c67a3ece1dbb78bb55": { "balance": "394000000000000000000" }, "5cb953a0e42f5030812226217fffc3ce230457e4": { "balance": "100000000000000000000" }, "d1f4dc1ddb8abb8848a8b14e25f3b55a8591c266": { "balance": "250000000000000000000" }, "6a42ca971c6578d5ade295c3e7f4ad331dd3424e": { "balance": "6000000000000000000000" }, "07e1162ceae3cf21a3f62d105990302e307f4e3b": { "balance": "1530000000000000000000" }, "5d1dc3387b47b8451e55106c0cc67d6dc72b7f0b": { "balance": "2000000000000000000000" }, "5d2819e8d57821922ee445650ccaec7d40544a8d": { "balance": "200000000000000000000" }, "4c24b78baf2bafc7fcc69016426be973e20a50b2": { "balance": "3000000000000000000000" }, "630c5273126d517ce67101811cab16b8534cf9a8": { "balance": "9422595000000000000000" }, "291f929ca59b54f8443e3d4d75d95dee243cef78": { "balance": "499938000000000000000" }, "2dd325fdffb97b19995284afa5abdb574a1df16a": { "balance": "500000000000000000000" }, "4fce8429ba49caa0369d1e494db57e89eab2ad39": { "balance": "200000000000000000000000" }, "712b76510214dc620f6c3a1dd29aa22bf6d214fb": { "balance": "6000000000000000000000" }, "266f2da7f0085ef3f3fa09baee232b93c744db2e": { "balance": "60000000000000000000000" }, "0770c61be78772230cb5a3bb2429a72614a0b336": { "balance": "6767695000000000000000" }, "02dfcb17a1b87441036374b762a5d3418b1cb4d4": { "balance": "1340860000000000000000" }, "5e67df8969101adabd91accd6bb1991274af8df2": { "balance": "500000000000000000000" }, "7d9c59631e2ba2e8e82891f3979922aaa3b567a1": { "balance": "8000000000000000000000" }, "949f8c107bc7f0aceaa0f17052aadbd2f9732b2e": { "balance": "2000000000000000000000" }, "ea4e809e266ae5f13cdbe38f9d0456e6386d1274": { "balance": "4500000000000000000000" }, "cd5510a242dfb0183de925fba866e312fabc1657": { "balance": "2400000000000000000000" }, "a36e0d94b95364a82671b608cb2d373245612909": { "balance": "150011000000000000000" }, "0ec46696ffac1f58005fa8439824f08eed1df89b": { "balance": "10000000000000000000000" }, "c6fb1ee37417d080a0d048923bdabab095d077c6": { "balance": "200000000000000000000" }, "53c9eca40973f63bb5927be0bc6a8a8be1951f74": { "balance": "2000000000000000000000" }, "ea14bfda0a6e76668f8788321f07df37824ec5df": { "balance": "200000000000000000000000" }, "dfb4d4ade52fcc818acc7a2c6bb2b00224658f78": { "balance": "7750000000000000000000" }, "5997ffefb3c1d9d10f1ae2ac8ac3c8e2d2292783": { "balance": "1000000000000000000000" }, "8eceb2e124536c5b5ffc640ed14ff15ed9a8cb71": { "balance": "2000000000000000000000" }, "8f02bda6c36922a6be6a509be51906d393f7b99b": { "balance": "1019835000000000000000" }, "530077c9f7b907ff9cec0c77a41a70e9029add4a": { "balance": "2000000000000000000000" }, "08936a37df85b3a158cafd9de021f58137681347": { "balance": "18200000000000000000" }, "8e9c429266df057efa78dd1d5f77fc40742ad466": { "balance": "300061000000000000000" }, "acc59f3b30ceffc56461cc5b8df48902240e0e7b": { "balance": "2000000000000000000000" }, "f5534815dc635efa5cc84b2ac734723e21b29372": { "balance": "1580000000000000000000" }, "f873e57a65c93b6e18cb75f0dc077d5b8933dc5c": { "balance": "197000000000000000000" }, "25b78c9fad85b43343f0bfcd0fac11c9949ca5eb": { "balance": "2000000000000000000000" }, "aad2b7f8106695078e6c138ec81a7486aaca1eb2": { "balance": "200000000000000000000" }, "509c8668036d143fb8ae70b11995631f3dfcad87": { "balance": "1000000000000000000000" }, "3602458da86f6d6a9d9eb03daf97fe5619d442fa": { "balance": "2000000000000000000000" }, "9f607b3f12469f446121cebf3475356b71b4328c": { "balance": "4000000000000000000000" }, "fe3827d57630cf8761d512797b0b858e478bbd12": { "balance": "20000000000000000000" }, "9d9c4efe9f433989e23be94049215329fa55b4cb": { "balance": "256215000000000000000" }, "9bd905f1719fc7acd0159d4dc1f8db2f21472338": { "balance": "1000000000000000000000" }, "7d82e523cc2dc591da3954e8b6bb2caf6461e69c": { "balance": "2316058000000000000000" }, "74afe54902d615782576f8baac13ac970c050f6e": { "balance": "177670000000000000000" }, "aff11ccf699304d5f5862af86083451c26e79ae5": { "balance": "1999000000000000000000" }, "3885fee67107dc3a3c741ee290c98918c9b99397": { "balance": "20000000000000000000" }, "36343aeca07b6ed58a0e62fa4ecb498a124fc971": { "balance": "300000000000000000000" }, "c94a28fb3230a9ddfa964e770f2ce3c253a7be4f": { "balance": "200000000000000000000" }, "9882967cee68d2a839fad8ab4a7c3dddf6c0adc8": { "balance": "1336866000000000000000" }, "95df4e3445d7662624c48eba74cf9e0a53e9f732": { "balance": "56000000000000000000000" }, "ca9faa17542fafbb388eab21bc4c94e8a7b34788": { "balance": "1999999000000000000000" }, "c8b1850525d946f2ae84f317b15188c536a5dc86": { "balance": "2685000000000000000000" }, "39bac68d947859f59e9226089c96d62e9fbe3cde": { "balance": "40000000000000000000" }, "a9bfc410dddb20711e45c07387eab30a054e19ac": { "balance": "1154750000000000000000" }, "540a1819bd7c35861e791804e5fbb3bc97c9abb1": { "balance": "1454400000000000000000" }, "667b61c03bb937a9f5d0fc5a09f1ea3363c77035": { "balance": "4250000000000000000000" }, "010df1df4bed23760d2d1c03781586ddf7918e54": { "balance": "60000000000000000000" }, "bd51ee2ea143d7b1d6b77e7e44bdd7da12f485ac": { "balance": "1318800000000000000000" }, "fb5125bf0f5eb0b6f020e56bfc2fdf3d402c097e": { "balance": "5910000000000000000000" }, "3f0c83aac5717962734e5ceaeaecd39b28ad06be": { "balance": "2000000000000000000000" }, "f10661ff94140f203e7a482572437938bec9c3f7": { "balance": "20000000000000000000000" }, "bd3097a79b3c0d2ebff0e6e86ab0edadbed47096": { "balance": "1670000000000000000000" }, "edeb4894aadd0081bbddd3e8846804b583d19f27": { "balance": "2000000000000000000000" }, "49c9771fca19d5b9d245c891f8158fe49f47a062": { "balance": "10000000000000000000000" }, "6405dd13e93abcff377e700e3c1a0086eca27d29": { "balance": "18200000000000000000" }, "ce5e04f0184369bcfa06aca66ffa91bf59fa0fb9": { "balance": "40000000000000000000" }, "4364309a9fa07095600f79edc65120cdcd23dc64": { "balance": "10000000000000000000000" }, "b749b54e04d5b19bdcedfb84da7701ab478c27ae": { "balance": "2680000000000000000000" }, "f593c65285ee6bbd6637f3be8f89ad40d489f655": { "balance": "3000000000000000000000" }, "d224f880f9479a89d32f09e52be990b288135cef": { "balance": "17300000000000000000000" }, "85bb51bc3bfe9a1b2a2f6b1cda95bca8b38c8d5e": { "balance": "321750000000000000000" }, "caf4481d9db78dc4f25f7b4ac8bd3b1ca0106b31": { "balance": "5000000000000000000000" }, "51ca8bd4dc644fac47af675563d5804a0da21eeb": { "balance": "788000000000000000000" }, "19f643e1a8fa04ae16006028138333a59a96de87": { "balance": "20000000000000000000" }, "58b808a65b51e6338969afb95ec70735e451d526": { "balance": "39998000000000000000000" }, "574921838cc77d6c98b17d903a3ae0ee0da95bd0": { "balance": "53480000000000000000000" }, "7c6924d07c3ef5891966fe0a7856c87bef9d2034": { "balance": "2000000000000000000000" }, "f9767e4ecb4a5980527508d7bec3d45e4c649c13": { "balance": "1910000000000000000000" }, "f3be99b9103ce7550aa74ff1db18e09dfe32e005": { "balance": "2000000000000000000000" }, "625644c95a873ef8c06cdb9e9f6d8d7680043d62": { "balance": "1800000000000000000000" }, "6a44af96b3f032ae641beb67f4b6c83342d37c5d": { "balance": "29000000000000000000" }, "d3a10ec7a5c9324999dd9e9b6bde7c911e584bda": { "balance": "600000000000000000000" }, "e8ddbed732ebfe754096fde9086b8ea4a4cdc616": { "balance": "2000000000000000000000" }, "235fa66c025ef5540070ebcf0d372d8177c467ab": { "balance": "33400000000000000000000" }, "4d08471d68007aff2ae279bc5e3fe4156fbbe3de": { "balance": "40000000000000000000000" }, "dadc00ab7927603c2fcf31cee352f80e6c4d6351": { "balance": "1999664000000000000000" }, "7393cbe7f9ba2165e5a7553500b6e75da3c33abf": { "balance": "100000000000000000000" }, "77617ebc4bebc5f5ddeb1b7a70cdeb6ae2ffa024": { "balance": "1970000000000000000000" }, "7fea1962e35d62059768c749bedd96cab930d378": { "balance": "2000000000000000000000" }, "243b3bca6a299359e886ce33a30341fafe4d573d": { "balance": "20000000000000000000000" }, "b94d47b3c052a5e50e4261ae06a20f45d8eee297": { "balance": "2000000000000000000000" }, "e727e67ef911b81f6cf9c73fcbfebc2b02b5bfc6": { "balance": "2000000000000000000000" }, "e510d6797fba3d6693835a844ea2ad540691971b": { "balance": "17381000000000000000000" }, "0cdc960b998c141998160dc179b36c15d28470ed": { "balance": "500038000000000000000" }, "3e76a62db187aa74f63817533b306cead0e8cebe": { "balance": "31200000000000000000000" }, "495b641b1cdea362c3b4cbbd0f5cc50b1e176b9c": { "balance": "1000000000000000000000" }, "5126460d692c71c9af6f05574d93998368a23799": { "balance": "52000000000000000000" }, "a008019863c1a77c1499eb39bbd7bf2dd7a31cb9": { "balance": "137000000000000000000" }, "65ee20b06d9ad589a7e7ce04b9f5f795f402aece": { "balance": "2000000000000000000000" }, "f432b9dbaf11bdbd73b6519fc0a904198771aac6": { "balance": "152000000000000000000" }, "85946d56a4d371a93368539690b60ec825107454": { "balance": "1730000000000000000000" }, "26f9f7cefd7e394b9d3924412bf2c2831faf1f85": { "balance": "4000000000000000000000" }, "d4ebb1929a23871cf77fe049ab9602be08be0a73": { "balance": "1910000000000000000000" }, "4fdac1aa517007e0089430b3316a1badd12c01c7": { "balance": "500000000000000000000" }, "05e671de55afec964b074de574d5158d5d21b0a3": { "balance": "3940000000000000000000" }, "20181c4b41f6f972b66958215f19f570c15ddff1": { "balance": "1600000000000000000000" }, "cc9519d1f3985f6b255eaded12d5624a972721e1": { "balance": "1000000000000000000000" }, "169bbefc41cfd7d7cbb8dfc63020e9fb06d49546": { "balance": "2000000000000000000000" }, "175a183a3a235ffbb03ba835675267229417a091": { "balance": "16000000000000000000000" }, "8dde3cb8118568ef4503fe998ccdf536bf19a098": { "balance": "4000000000000000000000" }, "6a05b21c4f17f9d73f5fb2b0cb89ff5356a6cc7e": { "balance": "1500000000000000000000" }, "5cc4cba621f220637742057f6055b80dffd77e13": { "balance": "39997692000000000000000" }, "ecb94c568bfe59ade650645f4f26306c736cace4": { "balance": "267400000000000000000" }, "dfa6b8b8ad3184e357da282951d79161cfb089bc": { "balance": "400000000000000000000" }, "a3058c51737a4e96c55f2ef6bd7bb358167ec2a7": { "balance": "606093000000000000000" }, "051d424276b21239665186133d653bb8b1862f89": { "balance": "1000000000000000000000" }, "d05ffb2b74f867204fe531653b0248e21c13544e": { "balance": "1000000000000000000000" }, "e1f63ebbc62c7b7444040eb99623964f7667b376": { "balance": "20000000000000000000" }, "e5a3d7eb13b15c100177236d1beb30d17ee15420": { "balance": "2000000000000000000000" }, "18fa8625c9dc843c78c7ab259ff87c9599e07f10": { "balance": "1000000000000000000000" }, "64264aedd52dcae918a012fbcd0c030ee6f71821": { "balance": "1000000000000000000000" }, "6f1f4907b8f61f0c51568d692806b382f50324f5": { "balance": "2000000000000000000000" }, "becef61c1c442bef7ce04b73adb249a8ba047e00": { "balance": "1000400000000000000000" }, "7b893286427e72db219a21fc4dcd5fbf59283c31": { "balance": "10000000000000000000000" }, "ce5eb63a7bf4fbc2f6e4baa0c68ab1cb4cf98fb4": { "balance": "2000000000000000000000" }, "66ec16ee9caab411c55a6629e318de6ee216491d": { "balance": "865000000000000000000" }, "30b66150f1a63457023fdd45d0cc6cb54e0c0f06": { "balance": "1000000000000000000000" }, "87183160d172d2e084d327b86bcb7c1d8e6784ef": { "balance": "4000086000000000000000" }, "c420388fbee84ad656dd68cdc1fbaa9392780b34": { "balance": "187767000000000000000" }, "90f774c9147dde90853ddc43f08f16d455178b8c": { "balance": "4000000000000000000000" }, "1e1d7a5f2468b94ea826982dbf2125793c6e4a5a": { "balance": "999940000000000000000" }, "8043fdd0bc4c973d1663d55fc135508ec5d4f4fa": { "balance": "20000000000000000000" }, "7bca1da6c80a66baa5db5ac98541c4be276b447d": { "balance": "679000000000000000000" }, "73550beb732ba9ddafda7ae406e18f7feb0f8bb2": { "balance": "2800000000000000000000" }, "adc19ec835afe3e58d87dc93a8a9213c90451326": { "balance": "1971200000000000000000" }, "821d798af19989c3ae5b84a7a7283cd7fda1fabe": { "balance": "20000000000000000000000" }, "4c4e6f13fb5e3f70c3760262a03e317982691d10": { "balance": "100000000000000000000" }, "664e43119870af107a448db1278b044838ffcdaf": { "balance": "400000000000000000000" }, "8da1178f55d97772bb1d24111a404a4f8715b95d": { "balance": "878149000000000000000" }, "5e6e9747e162f8b45c656e0f6cae7a84bac80e4e": { "balance": "2000000000000000000000" }, "c7eac31abce6d5f1dea42202b6a674153db47a29": { "balance": "591000000000000000000" }, "d96711540e2e998343d4f590b6fc8fac3bb8b31d": { "balance": "1758944000000000000000" }, "9da4ec407077f4b9707b2d9d2ede5ea5282bf1df": { "balance": "4000000000000000000000" }, "f60c1b45f164b9580e20275a5c39e1d71e35f891": { "balance": "2000000000000000000000" }, "eb6394a7bfa4d28911d5a5b23e93f35e340c2294": { "balance": "78000000000000000000" }, "a89ac93b23370472daac337e9afdf642543f3e57": { "balance": "10000000000000000000000" }, "bb618e25221ad9a740b299ed1406bc3934b0b16d": { "balance": "1000000000000000000000" }, "817ac33bd8f847567372951f4a10d7a91ce3f430": { "balance": "200015000000000000000" }, "fe6a895b795cb4bf85903d3ce09c5aa43953d3bf": { "balance": "3400000000000000000000" }, "3673954399f6dfbe671818259bb278e2e92ee315": { "balance": "200000000000000000000000" }, "df0ff1f3d27a8ec9fb8f6b0cb254a63bba8224a5": { "balance": "4367636000000000000000" }, "ff12e49d8e06aa20f886293c0b98ed7eff788805": { "balance": "4000000000000000000000" }, "5aef16a226dd68071f2483e1da42598319f69b2c": { "balance": "2000000000000000000000" }, "0266ab1c6b0216230b9395443d5fa75e684568c6": { "balance": "1000000000000000000000" }, "14a7352066364404db50f0d0d78d754a22198ef4": { "balance": "1880000000000000000000" }, "444caf79b71338ee9aa7c733b02acaa7dc025948": { "balance": "40000000000000000000" }, "64e2de21200b1899c3a0c0653b5040136d0dc842": { "balance": "20000000000000000000000" }, "36e156610cd8ff64e780d89d0054385ca76755aa": { "balance": "14000000000000000000000" }, "0a6ebe723b6ed1f9a86a69ddda68dc47465c2b1b": { "balance": "1185000000000000000000" }, "38bf2a1f7a69de0e2546adb808b36335645da9ff": { "balance": "2000320000000000000000" }, "39f44663d92561091b82a70dcf593d754005973a": { "balance": "199999000000000000000" }, "24b9e6644f6ba4cde126270d81f6ab60f286dff4": { "balance": "133700000000000000000" }, "9b59eb213b1e7565e45047e04ea0374f10762d16": { "balance": "2000000000000000000000" }, "309544b6232c3dd737f945a03193d19b5f3f65b9": { "balance": "1087440000000000000000" }, "b28bb39f3466517cd46f979cf59653ee7d8f152e": { "balance": "450000000000000000000" }, "9da8e22ca10e67fea44e525e4751eeac36a31194": { "balance": "260000000000000000000" }, "4f8ae80238e60008557075ab6afe0a7f2e74d729": { "balance": "100000000000000000000" }, "74ed33acf43f35b98c9230b9e6642ecb5330839e": { "balance": "681872000000000000000" }, "22842ab830da509913f81dd1f04f10af9edd1c55": { "balance": "2000000000000000000000" }, "a8f37f0ab3a1d448a9e3ce40965f97a646083a34": { "balance": "329800000000000000000" }, "582b70669c97aab7d68148d8d4e90411e2810d56": { "balance": "999972000000000000000" }, "d5e55100fbd1956bbed2ca518d4b1fa376032b0b": { "balance": "100000000000000000000" }, "b7cc6b1acc32d8b295df68ed9d5e60b8f64cb67b": { "balance": "300000000000000000000" }, "e081ca1f4882db6043d5a9190703fde0ab3bf56d": { "balance": "400000000000000000000" }, "c02077449a134a7ad1ef7e4d927affeceeadb5ae": { "balance": "18200000000000000000" }, "e09fea755aee1a44c0a89f03b5deb762ba33006f": { "balance": "1100070000000000000000" }, "b3717731dad65132da792d876030e46ac227bb8a": { "balance": "1000000000000000000000" }, "157eb3d3113bd3b597714d3a954edd018982a5cb": { "balance": "2000000000000000000000" }, "dc57345b38e0f067c9a31d9deac5275a10949321": { "balance": "200000000000000000000" }, "40ea5044b204b23076b1a5803bf1d30c0f88871a": { "balance": "14000000000000000000000" }, "2bab0fbe28d58420b52036770a12f9952aea6911": { "balance": "3820000000000000000000" }, "adaa0e548c035affed64ca678a963fabe9a26bfd": { "balance": "70000000000000000000" }, "bb48eaf516ce2dec3e41feb4c679e4957641164f": { "balance": "3820000000000000000000" }, "7693bdeb6fc82b5bca721355223175d47a084b4d": { "balance": "22000000000000000000000" }, "03cb98d7acd817de9d886d22fab3f1b57d92a608": { "balance": "1600000000000000000000" }, "f88900db737955b1519b1a7d170a18864ce590eb": { "balance": "18200000000000000000" }, "757fa55446c460968bb74b5ebca96c4ef2c709c5": { "balance": "1015200000000000000000" }, "da855d53477f505ec4c8d5e8bb9180d38681119c": { "balance": "5600000000000000000000" }, "e41aea250b877d423a63ba2bce2f3a61c0248d56": { "balance": "260000000000000000000" }, "8262169b615870134eb4ac6c5f471c6bf2f789fc": { "balance": "462500000000000000000" }, "66b0c100c49149935d14c0dc202cce907cea1a3d": { "balance": "1970000000000000000000" }, "854c0c469c246b83b5d1b3eca443b39af5ee128a": { "balance": "1600000000000000000000" }, "eb6810691d1ae0d19e47bd22cebee0b3ba27f88a": { "balance": "2499922000000000000000" }, "24dcc24bd9c7210ceacfb30da98ae04a4d7b8ab9": { "balance": "1000000000000000000000" }, "e31b4eef184c24ab098e36c802714bd4743dd0d4": { "balance": "200000000000000000000" }, "99b8c824869de9ed24f3bff6854cb6dd45cc3f9f": { "balance": "1880000000000000000000" }, "2ae73a79aea0278533accf21070922b1613f8f32": { "balance": "3097417000000000000000" }, "ddbd2b932c763ba5b1b7ae3b362eac3e8d40121a": { "balance": "10000000000000000000000" }, "1b4bbcb18165211b265b280716cb3f1f212176e8": { "balance": "472325000000000000000" }, "e177e0c201d335ba3956929c571588b51c5223ae": { "balance": "2000000000000000000000" }, "1945fe377fe6d4b71e3e791f6f17db243c9b8b0f": { "balance": "2185500000000000000000" }, "3e9b34a57f3375ae59c0a75e19c4b641228d9700": { "balance": "17900000000000000000" }, "a4d6c82eddae5947fbe9cdfbd548ae33d91a7191": { "balance": "8000000000000000000000" }, "bad4425e171c3e72975eb46ac0a015db315a5d8f": { "balance": "2000000000000000000000" }, "a2d2aa626b09d6d4e4b13f7ffc5a88bd7ad36742": { "balance": "4639390000000000000000" }, "b61c34fcacda701a5aa8702459deb0e4ae838df8": { "balance": "35000000000000000000000" }, "145e0600e2a927b2dd8d379356b45a2e7d51d3ae": { "balance": "2545843000000000000000" }, "8df339214b6ad1b24663ce716034749d6ef838d9": { "balance": "11000000000000000000000" }, "8fd9a5c33a7d9edce0997bdf77ab306424a11ea9": { "balance": "2000000000000000000000" }, "097da12cfc1f7c1a2464def08c29bed5e2f851e9": { "balance": "20000000000000000000" }, "ddabf13c3c8ea4e3d73d78ec717afafa430e5479": { "balance": "41600000000000000000000" }, "9eeb07bd2b7890195e7d46bdf2071b6617514ddb": { "balance": "2000000000000000000000" }, "819af9a1c27332b1c369bbda1b3de1c6e933d640": { "balance": "314308000000000000000" }, "d7d2c6fca8ad1f75395210b57de5dfd673933909": { "balance": "340000000000000000000" }, "cdd5d881a7362c9070073bdfbc75e72453ac510e": { "balance": "842000000000000000000" }, "e9ac36376efa06109d40726307dd1a57e213eaa9": { "balance": "194000000000000000000" }, "1bea4df5122fafdeb3607eddda1ea4ffdb9abf2a": { "balance": "346000000000000000000" }, "3e5e93fb4c9c9d1246f8f247358e22c3c5d17b6a": { "balance": "150000000000000000000" }, "6c1ddd33c81966dc8621776071a4129482f2c65f": { "balance": "40000000000000000000000" }, "2ccb66494d0af689abf9483d365d782444e7dead": { "balance": "1000000000000000000000" }, "19571a2b8f81c6bcf66ab3a10083295617150003": { "balance": "492500000000000000000" }, "38ac664ee8e0795e4275cb852bcba6a479ad9c8d": { "balance": "20000000000000000000" }, "c4803bb407c762f90b7596e6fde194931e769590": { "balance": "4000000000000000000000" }, "93507e9e8119cbceda8ab087e7ecb071383d6981": { "balance": "14000000000000000000000" }, "b672734afcc224e2e609fc51d4f059732744c948": { "balance": "295500000000000000000" }, "fbbbebcfbe235e57dd2306ad1a9ec581c7f9f48f": { "balance": "40000000000000000000" }, "8c81410ea8354cc5c65c41be8bd5de733c0b111d": { "balance": "9550000000000000000000" }, "942c6b8c955bc0d88812678a236725b32739d947": { "balance": "1550000000000000000000" }, "d2e817738abf1fb486583f80c350318bed860c80": { "balance": "240010000000000000000" }, "bff5df769934b8943ca9137d0efef2fe6ebbb34e": { "balance": "100000000000000000000" }, "6c4e426e8dc005dfa3516cb8a680b02eea95ae8e": { "balance": "1337000000000000000000" }, "f645dd7c890093e8e4c8aa92a6bb353522d3dc98": { "balance": "134000000000000000000" }, "4bac846af4169f1d95431b341d8800b22180af1a": { "balance": "20000000000000000000" }, "0514954c3c2fb657f9a06f510ea22748f027cdd3": { "balance": "400000000000000000000" }, "163dca73d7d6ea3f3e6062322a8734180c0b78ef": { "balance": "2941400000000000000000" }, "feaca2ac74624bf348dac9985143cfd652a4be55": { "balance": "26148245000000000000000" }, "fe80e9232deaff19baf99869883a4bdf0004e53c": { "balance": "855680000000000000000" }, "17108dab2c50f99de110e1b3b3b4cd82f5df28e7": { "balance": "980000000000000000000" }, "837a645dc95c49549f899c4e8bcf875324b2f57c": { "balance": "600400000000000000000" }, "762998e1d75227fced7a70be109a4c0b4ed86414": { "balance": "20000000000000000000" }, "c0a7e8435dff14c25577739db55c24d5bf57a3d9": { "balance": "49250000000000000000000" }, "aead88d689416b1c91f2364421375b7d3c70fb2e": { "balance": "2000000000000000000000" }, "9279b2228cec8f7b4dda3f320e9a0466c2f585ca": { "balance": "5000000000000000000000" }, "36726f3b885a24f92996da81625ec8ad16d8cbe6": { "balance": "1543723000000000000000" }, "3951e48e3c869e6b72a143b6a45068cdb9d466d0": { "balance": "20000000000000000000" }, "f5d61ac4ca95475e5b7bffd5f2f690b316759615": { "balance": "31040000000000000000000" }, "158a0d619253bf4432b5cd02c7b862f7c2b75636": { "balance": "135733000000000000000" }, "e56d431324c92911a1749df292709c14b77a65cd": { "balance": "8200000000000000000000" }, "9976947eff5f6ae5da08dd541192f378b428ff94": { "balance": "8000000000000000000000" }, "83210583c16a4e1e1dac84ebd37e3d0f7c57eba4": { "balance": "2000000000000000000000" }, "dcb64df43758c7cf974fa660484fbb718f8c67c1": { "balance": "20000000000000000000000" }, "d4205592844055b3c7a1f80cefe3b8eb509bcde7": { "balance": "178973000000000000000" }, "d0648a581b3508e135a2935d12c9657045d871ca": { "balance": "8022000000000000000000" }, "e7d17524d00bad82497c0f27156a647ff51d2792": { "balance": "20000000000000000000" }, "21582e99e502cbf3d3c23bdffb76e901ac6d56b2": { "balance": "100000000000000000000" }, "e61f280915c774a31d223cf80c069266e5adf19b": { "balance": "880000000000000000000" }, "03c91d92943603e752203e05340e566013b90045": { "balance": "802200000000000000000" }, "22561c5931143536309c17e832587b625c390b9a": { "balance": "4000000000000000000000" }, "e399c81a1d701b44f0b66f3399e66b275aaaf8c1": { "balance": "1000000000000000000000" }, "7f8dbce180ed9c563635aad2d97b4cbc428906d9": { "balance": "2674000000000000000000" }, "9f61beb46f5e853d0a8521c7446e68e34c7d0973": { "balance": "560000000000000000000" }, "6d3f2ba856ccbb0237fa7661156b14b013f21240": { "balance": "1000000000000000000000" }, "5f742e487e3ab81af2f94afdbe1b9b8f5ccc81bc": { "balance": "2172412000000000000000" }, "b600feab4aa96c537504d96057223141692c193a": { "balance": "400000000000000000000" }, "fab487500df20fb83ebed916791d561772adbebf": { "balance": "1999980000000000000000" }, "f8704c16d2fd5ba3a2c01d0eb20484e6ecfa3109": { "balance": "200000000000000000000" }, "3f1bc420c53c002c9e90037c44fe6a8ef4ddc962": { "balance": "173000000000000000000" }, "82e577b515cb2b0860aafe1ce09a59e09fe7d040": { "balance": "600000000000000000000" }, "bc999e385c5aebcac8d6f3f0d60d5aa725336d0d": { "balance": "2000000000000000000000" }, "e16ce35961cd74bd590d04c4ad4a1989e05691c6": { "balance": "146000000000000000000" }, "eb76424c0fd597d3e341a9642ad1ee118b2b579d": { "balance": "4000000000000000000000" }, "c440c7ca2f964b6972ef664a2261dde892619d9c": { "balance": "20000000000000000000000" }, "460d5355b2ceeb6e62107d81e51270b26bf45620": { "balance": "2005500000000000000000" }, "fcada300283f6bcc134a91456760b0d77de410e0": { "balance": "2000000000000000000000" }, "be8d7f18adfe5d6cc775394989e1930c979d007d": { "balance": "1000000000000000000000" }, "a7f9220c8047826bd5d5183f4e676a6d77bfed36": { "balance": "153368000000000000000" }, "98d204f9085f8c8e7de23e589b64c6eff692cc63": { "balance": "2000000000000000000000" }, "5a2916b8d2e8cc12e207ab464d433e2370d823d9": { "balance": "2000000000000000000000" }, "c42d6aeb710e3a50bfb44d6c31092969a11aa7f3": { "balance": "150052000000000000000" }, "04ce45f600db18a9d0851b29d9393ebdaafe3dc5": { "balance": "20000000000000000000" }, "7a1370a742ec2687e761a19ac5a794329ee67404": { "balance": "2999988000000000000000" }, "da2ad58e77deddede2187646c465945a8dc3f641": { "balance": "660000000000000000000" }, "ec58bc0d0c20d8f49465664153c5c196fe59e6be": { "balance": "400000000000000000000" }, "f8063af4cc1dd9619ab5d8bff3fcd1faa8488221": { "balance": "2000000000000000000000" }, "b9231eb26e5f9e4b4d288f03906704fab96c87d6": { "balance": "19700000000000000000000" }, "6e5c2d9b1c546a86eefd5d0a5120c9e4e730190e": { "balance": "199600000000000000000" }, "e49936a92a8ccf710eaac342bc454b9b14ebecb1": { "balance": "2000000000000000000000" }, "21dbdb817a0d8404c6bdd61504374e9c43c9210e": { "balance": "9999917000000000000000" }, "5cebe30b2a95f4aefda665651dc0cf7ef5758199": { "balance": "18200000000000000000" }, "597038ff91a0900cbbab488af483c790e6ec00a0": { "balance": "10000000000000000000000" }, "0fa5d8c5b3f294efd495ab69d768f81872508548": { "balance": "2000000000000000000000" }, "feef3b6eabc94affd3310c1c4d0e65375e131119": { "balance": "20000000000000000000" }, "1ce81d31a7923022e125bf48a3e03693b98dc9dd": { "balance": "2000000000000000000000" }, "5887dc6a33dfed5ac1edefe35ef91a216231ac96": { "balance": "250000000000000000000" }, "4e8e47ae3b1ef50c9d54a38e14208c1abd3603c2": { "balance": "2235000000000000000000" }, "e845e387c4cbdf982280f6aa01c40e4be958ddb2": { "balance": "25000000000000000000000" }, "71d9494e50c5dd59c599dba3810ba1755e6537f0": { "balance": "4000000000000000000000" }, "6eb5578a6bb7c32153195b0d8020a6914852c059": { "balance": "660000000000000000000000" }, "543f8c674e2462d8d5daa0e80195a8708e11a29e": { "balance": "63940000000000000000" }, "a0459ef3693aacd1647cd5d8929839204cef53be": { "balance": "1000000000000000000000" }, "dda371e600d30688d4710e088e02fdf2b9524d5f": { "balance": "6920000000000000000000" }, "dd4dd6d36033b0636fcc8d0938609f4dd64f4a86": { "balance": "60000000000000000000" }, "3bd624b548cb659736907ed8aa3c0c705e24b575": { "balance": "2000000000000000000000" }, "414599092e879ae25372a84d735af5c4e510cd6d": { "balance": "400000000000000000000" }, "3d66cd4bd64d5c8c1b5eea281e106d1c5aad2373": { "balance": "1951100000000000000000" }, "5948bc3650ed519bf891a572679fd992f8780c57": { "balance": "197000000000000000000" }, "8b74a7cb1bb8c58fce267466a30358adaf527f61": { "balance": "13620000000000000000000" }, "3f10800282d1b7ddc78fa92d8230074e1bf6aeae": { "balance": "4925000000000000000000" }, "32dbb6716c54e83165829a4abb36757849b6e47d": { "balance": "1000000000000000000000" }, "e6b3ac3f5d4da5a8857d0b3f30fc4b2b692b77d7": { "balance": "1460000000000000000000" }, "052a58e035f1fe9cdd169bcf20970345d12b9c51": { "balance": "1490000000000000000000" }, "581bdf1bb276dbdd86aedcdb397a01efc0e00c5b": { "balance": "1000000000000000000000" }, "604e9477ebf4727c745bcabbedcb6ccf29994022": { "balance": "1000060000000000000000" }, "59b96deb8784885d8d3b4a166143cc435d2555a1": { "balance": "1337000000000000000000" }, "37d980a12ee3bf23cc5cdb63b4ae45691f74c837": { "balance": "2000000000000000000000" }, "3bfbd3847c17a61cf3f17b52f8eba1b960b3f39f": { "balance": "3000000000000000000000" }, "49c941e0e5018726b7290fc473b471d41dae80d1": { "balance": "500000000000000000000" }, "f26bcedce3feadcea3bc3e96eb1040dfd8ffe1a0": { "balance": "775000000000000000000" }, "d0944aa185a1337061ae20dc9dd96c83b2ba4602": { "balance": "200000000000000000000" }, "904caa429c619d940f8e6741826a0db692b19728": { "balance": "1000000000000000000000" }, "b95c9b10aa981cf4a67a71cc52c504dee8cf58bd": { "balance": "4000000000000000000000" }, "15874686b6733d10d703c9f9bec6c52eb8628d67": { "balance": "2000000000000000000000" }, "1374facd7b3f8d68649d60d4550ee69ff0484133": { "balance": "269700000000000000000" }, "b0e469c886593815b3495638595daef0665fae62": { "balance": "1940000000000000000000" }, "47ff6feb43212060bb1503d7a397fc08f4e70352": { "balance": "2000000000000000000000" }, "c60b04654e003b4683041f1cbd6bc38fda7cdbd6": { "balance": "2000000000000000000000" }, "3ecdb532e397579662b2a46141e78f8235936a5f": { "balance": "66850000000000000000" }, "b3a8c2cb7d358e5739941d945ba9045a023a8bbb": { "balance": "1000000000000000000000" }, "32ef5cdc671df5562a901aee5db716b9be76dcf6": { "balance": "2000000000000000000000" }, "c94110e71afe578aa218e4fc286403b0330ace8d": { "balance": "2000000000000000000000" }, "9b43dcb95fde318075a567f1e6b57617055ef9e8": { "balance": "3940000000000000000000" }, "efeea010756f81da4ba25b721787f058170befbd": { "balance": "32470000000000000000" }, "c88255eddcf521c6f81d97f5a42181c9073d4ef1": { "balance": "290793000000000000000" }, "dd47189a3e64397167f0620e484565b762bfbbf4": { "balance": "1850000000000000000000" }, "82f39b2758ae42277b86d69f75e628d958ebcab0": { "balance": "40000000000000000000000" }, "e37f5fdc6ec97d2f866a1cfd0d3a4da4387b22b5": { "balance": "10000000000000000000000" }, "62331df2a3cbee3520e911dea9f73e905f892505": { "balance": "2000000000000000000000" }, "8c5d16ed65e3ed7e8b96ca972bc86173e3500b03": { "balance": "2000000000000000000000" }, "8b9841862e77fbbe919470935583a93cf027e450": { "balance": "2000054000000000000000" }, "c8dd27f16bf22450f5771b9fe4ed4ffcb30936f4": { "balance": "197000000000000000000" }, "dec8a1a898f1b895d8301fe64ab3ad5de941f689": { "balance": "787803000000000000000" }, "61c4ee7c864c4d6b5e37ea1331c203739e826b2f": { "balance": "30063000000000000000" }, "3250e3e858c26adeccadf36a5663c22aa84c4170": { "balance": "5000000000000000000000" }, "299e0bca55e069de8504e89aca6eca21d38a9a5d": { "balance": "55500000000000000000" }, "d50f7fa03e389876d3908b60a537a6706304fb56": { "balance": "100000000000000000000" }, "69073269729e6414b26ec8dc0fd935c73b579f1e": { "balance": "30000000000000000000000" }, "14fcd1391e7d732f41766cdacd84fa1deb9ffdd2": { "balance": "2000000000000000000000" }, "823768746737ce6da312d53e54534e106f967cf3": { "balance": "20000000000000000000" }, "882f75708386653c80171d0663bfe30b017ed0ad": { "balance": "2000000000000000000000" }, "a25b086437fd2192d0a0f64f6ed044f38ef3da32": { "balance": "335000000000000000000" }, "5a9c8b69fc614d69564999b00dcb42db67f97e90": { "balance": "3429227000000000000000" }, "a2b701f9f5cdd09e4ba62baebae3a88257105885": { "balance": "1000000000000000000000" }, "5e7b8c54dc57b0402062719dee7ef5e37ea35d62": { "balance": "2877224000000000000000" }, "7ffabfbc390cbe43ce89188f0868b27dcb0f0cad": { "balance": "6370000000000000000000" }, "b5cdbc4115406f52e5aa85d0fea170d2979cc7ba": { "balance": "1337000000000000000000" }, "263814309de4e635cf585e0d365477fc40e66cf7": { "balance": "146000000000000000000" }, "24cff0e9336a9f80f9b1cb968caf6b1d1c4932a4": { "balance": "200200000000000000000" }, "d3a941c961e8ca8b1070f23c6d6d0d2a758a4444": { "balance": "200000000000000000000" }, "a97beb3a48c45f1528284cb6a95f7de453358ec6": { "balance": "31000000000000000000000" }, "4dd131c74a068a37c90aded4f309c2409f6478d3": { "balance": "400008000000000000000" }, "653675b842d7d8b461f722b4117cb81dac8e639d": { "balance": "31000000000000000000" }, "561be9299b3e6b3e63b79b09169d1a948ae6db01": { "balance": "500000000000000000000" }, "dc067ed3e12d711ed475f5156ef7e71a80d934b9": { "balance": "9550000000000000000000" }, "08d97eadfcb7b064e1ccd9c8979fbee5e77a9719": { "balance": "266063000000000000000" }, "6e4c2ab7db026939dbd3bc68384af660a61816b2": { "balance": "167000000000000000000" }, "bf4c73a7ede7b164fe072114843654e4d8781dde": { "balance": "2000000000000000000000" }, "f504943aaf16796e0b341bbcdf21d11cc586cdd1": { "balance": "9000000000000000000000" }, "ea81ca8638540cd9d4d73d060f2cebf2241ffc3e": { "balance": "1970000000000000000000" }, "9944fee9d34a4a880023c78932c00b59d5c82a82": { "balance": "750022000000000000000" }, "12f460ae646cd2780fd35c50a6af4b9accfa85c6": { "balance": "1000000000000000000000" }, "4e232d53b3e6be8f895361d31c34d4762b12c82e": { "balance": "1760000000000000000000" }, "6bb2aca23fa1626d18efd6777fb97db02d8e0ae4": { "balance": "40000000000000000000000" }, "bc4e471560c99c8a2a4b1b1ad0c36aa6502b7c4b": { "balance": "12000000000000000000000" }, "2e2cbd7ad82547b4f5ff8b3ab56f942a6445a3b0": { "balance": "200000000000000000000" }, "21ecb2dfa65779c7592d041cd2105a81f4fd4e46": { "balance": "1000000000000000000000" }, "34318625818ec13f11835ae97353ce377d6f590a": { "balance": "1520000000000000000000" }, "a7ef35ce87eda6c28df248785815053ec97a5045": { "balance": "4999998000000000000000" }, "6a514e6242f6b68c137e97fea1e78eb555a7e5f7": { "balance": "20000000000000000000" }, "9340b5f678e45ee05eb708bb7abb6ec8f08f1b6b": { "balance": "6000000000000000000000" }, "43cc08d0732aa58adef7619bed46558ad7774173": { "balance": "4443926000000000000000" }, "12e9a4ad2ad57484dd700565bddb46423bd9bd31": { "balance": "19999800000000000000000" }, "ebbeeb259184a6e01cccfc2207bbd883785ac90a": { "balance": "619966000000000000000" }, "704ab1150d5e10f5e3499508f0bf70650f028d4b": { "balance": "4000000000000000000000" }, "fc361105dd90f9ede566499d69e9130395f12ac8": { "balance": "395000000000000000000000" }, "c1b9a5704d351cfe983f79abeec3dbbbae3bb629": { "balance": "20000000000000000000" }, "66f50406eb1b11a946cab45927cca37470e5a208": { "balance": "2000000000000000000000" }, "53942e7949d6788bb780a7e8a0792781b1614b84": { "balance": "15899600000000000000000" }, "32ba9a7d0423e03a525fe2ebeb661d2085778bd8": { "balance": "20000000000000000000000" }, "11c0358aa6479de21866fe21071924b65e70f8b9": { "balance": "36400000000000000000000" }, "76cb9c8b69f4387675c48253e234cb7e0d74a426": { "balance": "7396300000000000000000" }, "9f5f44026b576a4adb41e95961561d41039ca391": { "balance": "250000000000000000000" }, "533a73a4a2228eee05c4ffd718bbf3f9c1b129a7": { "balance": "6000000000000000000000" }, "dcc52d8f8d9fc742a8b82767f0555387c563efff": { "balance": "500000000000000000000" }, "f456a75bb99655a7412ce97da081816dfdb2b1f2": { "balance": "200000000000000000000" }, "d0c101fd1f01c63f6b1d19bc920d9f932314b136": { "balance": "20000000000000000000000" }, "dabc225042a6592cfa13ebe54efa41040878a5a2": { "balance": "259550000000000000000" }, "38eec6e217f4d41aa920e424b9525197041cd4c6": { "balance": "4428166000000000000000" }, "8a247d186510809f71cffc4559471c3910858121": { "balance": "1790000000000000000000" }, "4f152b2fb8659d43776ebb1e81673aa84169be96": { "balance": "2000000000000000000000" }, "b4496ddb27799a222457d73979116728e8a1845b": { "balance": "2610331000000000000000" }, "4a4053b31d0ee5dbafb1d06bd7ac7ff3222c47d6": { "balance": "1400000000000000000000" }, "0f7bea4ef3f73ae0233df1e100718cbe29310bb0": { "balance": "2000000000000000000000" }, "c836e24a6fcf29943b3608e662290a215f6529ea": { "balance": "292000000000000000000" }, "1765361c2ec2f83616ce8363aae21025f2566f40": { "balance": "5000000000000000000000" }, "b6e6c3222b6b6f9be2875d2a89f127fb64100fe2": { "balance": "8008000000000000000000" }, "01bbc14f67af0639aab1441e6a08d4ce7162090f": { "balance": "1309500000000000000000" }, "af2058c7282cf67c8c3cf930133c89617ce75d29": { "balance": "6920000000000000000000" }, "464d9c89cce484df000277198ed8075fa63572d1": { "balance": "20000000000000000000" }, "50cd97e9378b5cf18f173963236c9951ef7438a5": { "balance": "1400000000000000000000" }, "cb47bd30cfa8ec5468aaa6a94642ced9c819c8d4": { "balance": "4000000000000000000000" }, "6b10f8f8b3e3b60de90aa12d155f9ff5ffb22c50": { "balance": "2000000000000000000000" }, "09b7a988d13ff89186736f03fdf46175b53d16e0": { "balance": "6000000000000000000000" }, "5bfafe97b1dd1d712be86d41df79895345875a87": { "balance": "500000000000000000000" }, "a06cd1f396396c0a64464651d7c205efaf387ca3": { "balance": "1999944000000000000000" }, "fc0096b21e95acb8d619d176a4a1d8d529badbef": { "balance": "384601000000000000000" }, "a74444f90fbb54e56f3ac9b6cfccaa4819e4614a": { "balance": "20000000000000000000" }, "3c15b3511df6f0342e7348cc89af39a168b7730f": { "balance": "1000000000000000000000" }, "3d6ff82c9377059fb30d9215723f60c775c891fe": { "balance": "250066000000000000000" }, "a524a8cccc49518d170a328270a2f88133fbaf5d": { "balance": "294500000000000000000" }, "8a7a06be199a3a58019d846ac9cbd4d95dd757de": { "balance": "3000200000000000000000" }, "d744ac7e5310be696a63b003c40bd039370561c6": { "balance": "1670000000000000000000" }, "fe362688845fa244cc807e4b1130eb3741a8051e": { "balance": "1000000000000000000000" }, "b2d0360515f17daba90fcbac8205d569b915d6ac": { "balance": "6000000000000000000000" }, "c53594c7cfb2a08f284cc9d7a63bbdfc0b319732": { "balance": "49200000000000000000000" }, "b3c228731d186d2ded5b5fbe004c666c8e469b86": { "balance": "29000000000000000000" }, "63e414603e80d4e5a0f5c18774204642258208e4": { "balance": "5000000000000000000000" }, "826ce5790532e0548c6102a30d3eac836bd6388f": { "balance": "18000000000000000000000" }, "c5e812f76f15f2e1f2f9bc4823483c8804636f67": { "balance": "73000000000000000000" }, "116fef5e601642c918cb89160fc2293ba71da936": { "balance": "802200000000000000000" }, "08b84536b74c8c01543da88b84d78bb95747d822": { "balance": "200000000000000000000" }, "04a80afad53ef1f84165cfd852b0fdf1b1c24ba8": { "balance": "58000000000000000000" }, "2b0362633614bfcb583569438ecc4ea57b1d337e": { "balance": "20000000000000000000000" }, "e95179527deca5916ca9a38f215c1e9ce737b4c9": { "balance": "10000000000000000000000" }, "2c5df866666a194b26cebb407e4a1fd73e208d5e": { "balance": "1000000000000000000000" }, "529e824fa072582b4032683ac7eecc1c04b4cac1": { "balance": "2000000000000000000000" }, "78634371e17304cbf339b1452a4ce438dc764cce": { "balance": "10000000000000000000000" }, "e172dfc8f80cd1f8cd8539dc26082014f5a8e3e8": { "balance": "3000000000000000000000" }, "b07618328a901307a1b7a0d058fcd5786e9e72fe": { "balance": "30239500000000000000000" }, "b0571153db1c4ed7acaefe13ecdfdb72e7e4f06a": { "balance": "80520000000000000000000" }, "ad910a23d6850613654af786337ad2a70868ac6d": { "balance": "1999800000000000000000" }, "4da5edc688b0cb62e1403d1700d9dcb99ffe3fd3": { "balance": "2000000000000000000000" }, "be2471a67f6047918772d0e36839255ed9d691ae": { "balance": "4000000000000000000000" }, "28868324337e11ba106cb481da962f3a8453808d": { "balance": "2000000000000000000000" }, "d8f94579496725b5cb53d7985c989749aff849c0": { "balance": "17000000000000000000000" }, "4981c5ff66cc4e9680251fc4cd2ff907cb327865": { "balance": "750000000000000000000" }, "fd2872d19e57853cfa16effe93d0b1d47b4f93fb": { "balance": "4000000000000000000000" }, "63c8dfde0b8e01dadc2e748c824cc0369df090b3": { "balance": "3880000000000000000000" }, "c4dd048bfb840e2bc85cb53fcb75abc443c7e90f": { "balance": "3716000000000000000000" }, "f579714a45eb8f52c3d57bbdefd2c15b2e2f11df": { "balance": "1560000000000000000000" }, "cc7b0481cc32e6faef2386a07022bcb6d2c3b4fc": { "balance": "3160000000000000000000" }, "a0aa5f0201f04d3bbeb898132f7c11679466d901": { "balance": "36600000000000000000" }, "f3df63a97199933330383b3ed7570b96c4812334": { "balance": "2000000000000000000000" }, "42732d8ef49ffda04b19780fd3c18469fb374106": { "balance": "425068000000000000000" }, "6f92d6e4548c78996509ee684b2ee29ba3c532b4": { "balance": "1000000000000000000000" }, "fff4bad596633479a2a29f9a8b3f78eefd07e6ee": { "balance": "100000000000000000000" }, "ac4460a76e6db2b9fcd152d9c7718d9ac6ed8c6f": { "balance": "200000000000000000000" }, "553b6b1c57050e88cf0c31067b8d4cd1ff80cb09": { "balance": "400000000000000000000" }, "84b6b6adbe2f5b3e2d682c66af1bc4905340c3ed": { "balance": "619333000000000000000" }, "9f4a7195ac7c151ca258cafda0cab083e049c602": { "balance": "1537100000000000000000" }, "2955c357fd8f75d5159a3dfa69c5b87a359dea8c": { "balance": "2000000000000000000000" }, "11d7844a471ef89a8d877555583ceebd1439ea26": { "balance": "10098000000000000000000" }, "34b454416e9fb4274e6addf853428a0198d62ee1": { "balance": "407000000000000000000" }, "308dd21cebe755126704b48c0f0dc234c60ba9b1": { "balance": "200000000000000000000" }, "381db4c8465df446a4ce15bf81d47e2f17c980bf": { "balance": "32000000000000000000000" }, "1abc4e253b080aeb437984ab05bca0979aa43e1c": { "balance": "1000000000000000000000" }, "53e35b12231f19c3fd774c88fec8cbeedf1408b2": { "balance": "512000000000000000000" }, "69e2e2e704307ccc5b5ca3f164fece2ea7b2e512": { "balance": "7000000000000000000000" }, "1914f1eb95d1277e93b6e61b668b7d77f13a11a1": { "balance": "970000000000000000000" }, "50e13023bd9ca96ad4c53fdfd410cb6b1f420bdf": { "balance": "200000000000000000000" }, "46224f32f4ece5c8867090d4409d55e50b18432d": { "balance": "6000000000000000000000" }, "ff83855051ee8ffb70b4817dba3211ed2355869d": { "balance": "400000000000000000000" }, "fb39189af876e762c71d6c3e741893df226cedd6": { "balance": "4000000000000000000000" }, "9875623495a46cdbf259530ff838a1799ec38991": { "balance": "2000000000000000000000" }, "e1b39b88d9900dbc4a6cdc481e1060080a8aec3c": { "balance": "2000000000000000000000" }, "5baf6d749620803e8348af3710e5c4fbf20fc894": { "balance": "5003680000000000000000" }, "9c54e4ed479a856829c6bb42da9f0b692a75f728": { "balance": "7520000000000000000000" }, "486a6c8583a84484e3df43a123837f8c7e2317d0": { "balance": "323378000000000000000" }, "d235d15cb5eceebb61299e0e827fa82748911d89": { "balance": "4000000000000000000000" }, "47d792a756779aedf1343e8883a6619c6c281184": { "balance": "2000000000000000000000" }, "70c213488a020c3cfb39014ef5ba6404724bcaa3": { "balance": "1940000000000000000000" }, "133c490fa5bf7f372888e607d958fab7f955bae1": { "balance": "1580000000000000000000" }, "a9e194661aac704ee9dea043974e9692ded84a5d": { "balance": "482400000000000000000" }, "bc6b58364bf7f1951c309e0cba0595201cd73f9a": { "balance": "1812400000000000000000" }, "2309d34091445b3232590bd70f4f10025b2c9509": { "balance": "10000000000000000000000" }, "d89bc271b27ba3ab6962c94a559006ae38d5f56a": { "balance": "2000000000000000000000" }, "ff0e2fec304207467e1e3307f64cbf30af8fd9cd": { "balance": "2000000000000000000000" }, "c0b0b7a8a6e1acdd05e47f94c09688aa16c7ad8d": { "balance": "64234000000000000000" }, "b66f92124b5e63035859e390628869dbdea9485e": { "balance": "9850000000000000000000" }, "a9e6e25e656b762558619f147a21985b8874edfe": { "balance": "2000000000000000000000" }, "a43e1947a9242b355561c30a829dfeeca2815af8": { "balance": "3878255000000000000000" }, "8b20ad3b94656dbdc0dd21a393d8a7d9e02138cb": { "balance": "3000000000000000000000" }, "aca2a838330b17302da731d30db48a04f0f207c1": { "balance": "1337000000000000000000" }, "fa60868aafd4ff4c5c57914b8ed58b425773dfa9": { "balance": "8557400000000000000000" }, "1848003c25bfd4aa90e7fcb5d7b16bcd0cffc0d8": { "balance": "1000000000000000000000" }, "b4b185d943ee2b58631e33dff5af6854c17993ac": { "balance": "1000000000000000000000" }, "7719888795ad745924c75760ddb1827dffd8cda8": { "balance": "1999980000000000000000" }, "ccd521132d986cb96869842622a7dda26c3ed057": { "balance": "2000000000000000000000" }, "253e32b74ea4490ab92606fda0aa257bf23dcb8b": { "balance": "10000000000000000000000" }, "3712367e5e55a96d5a19168f6eb2bc7e9971f869": { "balance": "1000000000000000000000" }, "8f29a14a845ad458f2d108b568d813166bcdf477": { "balance": "10000000000000000000000" }, "51a8c2163602a32ee24cf4aa97fd9ea414516941": { "balance": "62904000000000000000" }, "61cea71fa464d62a07063f920b0cc917539733d8": { "balance": "1670000000000000000000" }, "6f81f3abb1f933b1df396b8e9cc723a89b7c9806": { "balance": "280000000000000000000" }, "61b1b8c012cd4c78f698e470f90256e6a30f48dd": { "balance": "200000000000000000000" }, "4f3f2c673069ac97c2023607152981f5cd6063a0": { "balance": "600000000000000000000" }, "e2efa5fca79538ce6068bf31d2c516d4d53c08e5": { "balance": "131200000000000000000" }, "2383c222e67e969190d3219ef14da37850e26c55": { "balance": "2000000000000000000000" }, "eac3af5784927fe9a598fc4eec38b8102f37bc58": { "balance": "1000000000000000000000" }, "4fe56ab3bae1b0a44433458333c4b05a248f8241": { "balance": "2180000000000000000000" }, "fe9cfc3bb293ddb285e625f3582f74a6b0a5a6cd": { "balance": "1970000000000000000000" }, "f48e1f13f6af4d84b371d7de4b273d03a263278e": { "balance": "600000000000000000000" }, "1ba9228d388727f389150ea03b73c82de8eb2e09": { "balance": "7258000000000000000000" }, "37a7a6ff4ea3d60ec307ca516a48d3053bb79cbb": { "balance": "2000000000000000000000" }, "e33840d8bca7da98a6f3d096d83de78b70b71ef8": { "balance": "2000000000000000000000" }, "8e7fd23848f4db07906a7d10c04b21803bb08227": { "balance": "1000000000000000000000" }, "07d4334ec385e8aa54eedaeadb30022f0cdfa4ab": { "balance": "2629946000000000000000" }, "d4b085fb086f3d0d68bf12926b1cc3142cae8770": { "balance": "3700000000000000000000" }, "5a87f034e6f68f4e74ffe60c64819436036cf7d7": { "balance": "20000000000000000000" }, "c00ab080b643e1c2bae363e0d195de2efffc1c44": { "balance": "500000000000000000000" }, "22f3c779dd79023ea92a78b65c1a1780f62d5c4a": { "balance": "1970000000000000000000" }, "c7d5c7054081e918ec687b5ab36e973d18132935": { "balance": "182000000000000000000" }, "9662ee021926682b31c5f200ce457abea76c6ce9": { "balance": "670500000000000000000" }, "116a09df66cb150e97578e297fb06e13040c893c": { "balance": "2000000000000000000000" }, "b7240af2af90b33c08ae9764103e35dce3638428": { "balance": "8464547000000000000000" }, "e8b28acda971725769db8f563d28666d41ddab6c": { "balance": "10000000000000000000000" }, "17d4918dfac15d77c47f9ed400a850190d64f151": { "balance": "2000000000000000000000" }, "c42250b0fe42e6b7dcd5c890a6f0c88f5f5fb574": { "balance": "149800000000000000000" }, "5da2a9a4c2c0a4a924cbe0a53ab9d0c627a1cfa0": { "balance": "733202000000000000000" }, "5869fb867d71f1387f863b698d09fdfb87c49b5c": { "balance": "3666000000000000000000" }, "d49a75bb933fca1fca9aa1303a64b6cb44ea30e1": { "balance": "10000000000000000000000" }, "76331e30796ce664b2700e0d4153700edc869777": { "balance": "2000000000000000000000" }, "8a5fb75793d043f1bcd43885e037bd30a528c927": { "balance": "356500000000000000000" }, "fc0ee6f7c2b3714ae9916c45566605b656f32441": { "balance": "1760000000000000000000" }, "bf50ce2e264b9fe2b06830617aedf502b2351b45": { "balance": "1000000000000000000000" }, "0f6000de1578619320aba5e392706b131fb1de6f": { "balance": "499986000000000000000" }, "c953f934c0eb2d0f144bdab00483fd8194865ce7": { "balance": "2000000000000000000000" }, "24fd9a6c874c2fab3ff36e9afbf8ce0d32c7de92": { "balance": "1337000000000000000000" }, "c6cd68ec35362c5ad84c82ad4edc232125912d99": { "balance": "27750000000000000000000" }, "2a67660a1368efcd626ef36b2b1b601980941c05": { "balance": "133700000000000000000" }, "9deb39027af877992b89f2ec4a1f822ecdf12693": { "balance": "2000000000000000000000" }, "c12f881fa112b8199ecbc73ec4185790e614a20f": { "balance": "2000000000000000000000" }, "d58a52e078a805596b0d56ea4ae1335af01c66eb": { "balance": "267400000000000000000" }, "4d7cfaa84cb33106800a8c802fb8aa463896c599": { "balance": "1790000000000000000000" }, "0ee391f03c765b11d69026fd1ab35395dc3802a0": { "balance": "200000000000000000000" }, "a192f06ab052d5fd7f94eea8318e827815fe677a": { "balance": "131400000000000000000" }, "8f0ab894bd3f4e697dbcfb859d497a9ba195994a": { "balance": "39501652000000000000000" }, "387eeafd6b4009deaf8bd5b85a72983a8dcc3487": { "balance": "4000000000000000000000" }, "03b0f17cd4469ddccfb7da697e82a91a5f9e7774": { "balance": "20000000000000000000" }, "11172b278ddd44eea2fdf4cb1d16962391c453d9": { "balance": "935900000000000000000000" }, "33d172ab075c51db1cd40a8ca8dbff0d93b843bb": { "balance": "5727139000000000000000" }, "909b5e763a39dcc795223d73a1dbb7d94ca75ac8": { "balance": "2000000000000000000000" }, "0ca12ab0b9666cf0cec6671a15292f2653476ab2": { "balance": "210000600000000000000000" }, "6b5ae7bf78ec75e90cb503c778ccd3b24b4f1aaf": { "balance": "800000000000000000000" }, "d9e3857efd1e202a441770a777a49dcc45e2e0d3": { "balance": "223500000000000000000" }, "d703c6a4f11d60194579d58c2766a7ef16c30a29": { "balance": "2000000000000000000000" }, "838bd565f99fde48053f7917fe333cf84ad548ab": { "balance": "200000000000000000000" }, "8168edce7f2961cf295b9fcd5a45c06cdeda6ef5": { "balance": "200000000000000000000" }, "de50868eb7e3c71937ec73fa89dd8b9ee10d45aa": { "balance": "1000000000000000000000" }, "087498c0464668f31150f4d3c4bcdda5221ba102": { "balance": "20000000000000000000" }, "613fab44b16bbe554d44afd178ab1d02f37aeaa5": { "balance": "2000000000000000000000" }, "e2ee691f237ee6529b6557f2fcdd3dcf0c59ec63": { "balance": "5450048000000000000000" }, "a9ed377b7d6ec25971c1a597a3b0f3bead57c98f": { "balance": "400000000000000000000" }, "175feeea2aa4e0efda12e1588d2f483290ede81a": { "balance": "200000000000000000000" }, "b51ddcb4dd4e8ae6be336dd9654971d9fec86b41": { "balance": "421133000000000000000" }, "92c0f573eccf62c54810ee6ba8d1f113542b301b": { "balance": "3384000000000000000000" }, "a109e18bb0a39c9ef82fa19597fc5ed8e9eb6d58": { "balance": "1640000000000000000000" }, "f74e6e145382b4db821fe0f2d98388f45609c69f": { "balance": "100000000000000000000" }, "378f37243f3ff0bef5e1dc85eb4308d9340c29f9": { "balance": "2000200000000000000000" }, "84e9949680bece6841b9a7e5250d08acd87d16cd": { "balance": "200000000000000000000" }, "882bd3a2e9d74110b24961c53777f22f1f46dc5d": { "balance": "13370000000000000000000" }, "acce01e0a70610dc70bb91e9926fa9957f372fba": { "balance": "537000000000000000000" }, "c5f687717246da8a200d20e5e9bcac60b67f3861": { "balance": "28650000000000000000" }, "e14617f6022501e97e7b3e2d8836aa61f0ff2dba": { "balance": "200000000000000000000" }, "076ee99d3548623a03b5f99859d2d785a1778d48": { "balance": "200000000000000000000" }, "2c424ee47f583cdce07ae318b6fad462381d4d2b": { "balance": "4000000000000000000000" }, "f98250730c4c61c57f129835f2680894794542f3": { "balance": "4000000000000000000000" }, "ed1b24b6912d51b334ac0de6e771c7c0454695ea": { "balance": "40000000000000000000" }, "ffd5170fd1a8118d558e7511e364b24906c4f6b3": { "balance": "60085000000000000000" }, "bf49c14898316567d8b709c2e50594b366c6d38c": { "balance": "733202000000000000000" }, "65ea26eabbe2f64ccccfe06829c25d4637520225": { "balance": "700000000000000000000" }, "5c5419565c3aad4e714e0739328e3521c98f05cc": { "balance": "528000000000000000000" }, "c53b50fd3b2b72bc6c430baf194a515585d3986d": { "balance": "20000000000000000000" }, "2b74c373d04bfb0fd60a18a01a88fbe84770e58c": { "balance": "40000000000000000000" }, "d97f4526dea9b163f8e8e33a6bcf92fb907de6ec": { "balance": "284000000000000000000" }, "a4a49f0bc8688cc9e6dc04e1e08d521026e65574": { "balance": "200000000000000000000" }, "575c00c2818210c28555a0ff29010289d3f82309": { "balance": "10000000000000000000000" }, "3f1233714f204de9de4ee96d073b368d8197989f": { "balance": "38606000000000000000" }, "f964d98d281730ba35b2e3a314796e7b42fedf67": { "balance": "1543800000000000000000" }, "1deec01abe5c0d952de9106c3dc30639d85005d6": { "balance": "2000000000000000000000" }, "12d60d65b7d9fc48840be5f891c745ce76ee501e": { "balance": "21359400000000000000000" }, "5c6136e218de0a61a137b2b3962d2a6112b809d7": { "balance": "294273000000000000000" }, "cd43258b7392a930839a51b2ef8ad23412f75a9f": { "balance": "2000000000000000000000" }, "db3f258ab2a3c2cf339c4499f75a4bd1d3472e9e": { "balance": "1500000000000000000000" }, "0edd4b580ff10fe06c4a03116239ef96622bae35": { "balance": "197000000000000000000" }, "1d157c5876c5cad553c912caf6ce2d5277e05c73": { "balance": "2000000000000000000000" }, "cda1b886e3a795c9ba77914e0a2fe5676f0f5ccf": { "balance": "106024000000000000000" }, "f50cbafd397edd556c0678988cb2af5c2617e0a2": { "balance": "716000000000000000000" }, "327bb49e754f6fb4f733c6e06f3989b4f65d4bee": { "balance": "20000000000000000000" }, "c44bdec8c36c5c68baa2ddf1d431693229726c43": { "balance": "100000000000000000000000" }, "34e2849bea583ab0cc37975190f322b395055582": { "balance": "7780340000000000000000" }, "9221c9ce01232665741096ac07235903ad1fe2fc": { "balance": "126489000000000000000" }, "ff3ded7a40d3aff0d7a8c45fa6136aa0433db457": { "balance": "1999800000000000000000" }, "10b5b34d1248fcf017f8c8ffc408ce899ceef92f": { "balance": "267400000000000000000" }, "f1a1f320407964fd3c8f2e2cc8a4580da94f01ea": { "balance": "2000040000000000000000" }, "6c800d4b49ba07250460f993b8cbe00b266a2553": { "balance": "492500000000000000000" }, "f827d56ed2d32720d4abf103d6d0ef4d3bcd559b": { "balance": "26265000000000000000" }, "ffb9c7217e66743031eb377af65c77db7359dcda": { "balance": "40000000000000000000" }, "530319db0a8f93e5bb7d4dbf4816314fbed8361b": { "balance": "2000000000000000000000" }, "9c28a2c4086091cb5da226a657ce3248e8ea7b6f": { "balance": "280000000000000000000" }, "db23a6fef1af7b581e772cf91882deb2516fc0a7": { "balance": "200000000000000000000" }, "6636d7ac637a48f61d38b14cfd4865d36d142805": { "balance": "500000000000000000000" }, "b3c260609b9df4095e6c5dff398eeb5e2df49985": { "balance": "254030000000000000000" }, "58e5c9e344c806650dacfc904d33edba5107b0de": { "balance": "19100000000000000000" }, "4f67396d2553f998785f704e07a639197dd1948d": { "balance": "300080000000000000000" }, "510d8159cc945768c7450790ba073ec0d9f89e30": { "balance": "2560000000000000000000" }, "593c48935beaff0fde19b04d309cd530a28e52ce": { "balance": "4000000000000000000000" }, "c27f4e08099d8cf39ee11601838ef9fc06d7fc41": { "balance": "1790000000000000000000" }, "07723e3c30e8b731ee456a291ee0e798b0204a77": { "balance": "2000000000000000000000" }, "0a652e2a8b77bd97a790d0e91361c98890dbb04e": { "balance": "1000000000000000000000" }, "671015b97670b10d5e583f3d62a61c1c79c5143f": { "balance": "400000000000000000000" }, "7cc24a6a958c20c7d1249660f7586226950b0d9a": { "balance": "1970000000000000000000" }, "6ef9e8c9b6217d56769af97dbb1c8e1b8be799d2": { "balance": "182000000000000000000" }, "5c4368918ace6409c79eca80cdaae4391d2b624e": { "balance": "4000000000000000000000" }, "043707071e2ae21eed977891dc79cd5d8ee1c2da": { "balance": "2000000000000000000000" }, "39bfd978689bec048fc776aa15247f5e1d7c39a2": { "balance": "20000000000000000000000" }, "05915d4e225a668162aee7d6c25fcfc6ed18db03": { "balance": "66348000000000000000" }, "3f551ba93cd54693c183fb9ad60d65e1609673c9": { "balance": "2000000000000000000000" }, "a8c0b02faf02cb5519dda884de7bbc8c88a2da81": { "balance": "16700000000000000000" }, "bd0c5cd799ebc48642ef97d74e8e429064fee492": { "balance": "326000000000000000000" }, "0a931b449ea8f12cdbd5e2c8cc76bad2c27c0639": { "balance": "23031000000000000000" }, "2ea5fee63f337a376e4b918ea82148f94d48a626": { "balance": "1864242000000000000000" }, "cc6c2df00e86eca40f21ffda1a67a1690f477c65": { "balance": "3160000000000000000000" }, "e5e37e19408f2cfbec83349dd48153a4a795a08f": { "balance": "4200000000000000000000" }, "f555a27bb1e2fd4e2cc784caee92939fc06e2fc9": { "balance": "2000000000000000000000" }, "dcf9719be87c6f46756db4891db9b611d2469c50": { "balance": "1000000000000000000000" }, "8e2f9034c9254719c38e50c9aa64305ed696df1e": { "balance": "4728000000000000000000" }, "a01f12d70f44aa7b113b285c22dcdb45873454a7": { "balance": "18200000000000000000" }, "bce40475d345b0712dee703d87cd7657fc7f3b62": { "balance": "7750000000000000000000" }, "bb19bf91cbad74cceb5f811db27e411bc2ea0656": { "balance": "17600000000000000000" }, "acc062702c59615d3444ef6214b8862b009a02ed": { "balance": "1499936000000000000000" }, "449ac4fbe383e36738855e364a57f471b2bfa131": { "balance": "197000000000000000000000" }, "ad59a78eb9a74a7fbdaefafa82eada8475f07f95": { "balance": "500000000000000000000" }, "6b6577f3909a4d6de0f411522d4570386400345c": { "balance": "1880000000000000000000" }, "79bf2f7b6e328aaf26e0bb093fa22da29ef2f471": { "balance": "1790000000000000000000" }, "940f715140509ffabf974546fab39022a41952d2": { "balance": "1400000000000000000000" }, "1d572edd2d87ca271a6714c15a3b37761dcca005": { "balance": "127674000000000000000" }, "d78ecd25adc86bc2051d96f65364866b42a426b7": { "balance": "3877300000000000000000" }, "f9729d48282c9e87166d5eef2d01eda9dbf78821": { "balance": "99981000000000000000" }, "17762560e82a93b3f522e0e524adb8612c3a7470": { "balance": "1000000000000000000000" }, "d500e4d1c9824ba9f5b635cfa3a8c2c38bbd4ced": { "balance": "400000000000000000000" }, "a11effab6cf0f5972cffe4d56596e98968144a8f": { "balance": "1670000000000000000000" }, "f64ecf2117931c6d535a311e4ffeaef9d49405b8": { "balance": "2674000000000000000000" }, "229cc4711b62755ea296445ac3b77fc633821cf2": { "balance": "39481000000000000000" }, "fc989cb487bf1a7d17e4c1b7c4b7aafdda6b0a8d": { "balance": "20000000000000000000" }, "ea8527febfa1ade29e26419329d393b940bbb7dc": { "balance": "1999944000000000000000" }, "bce13e22322acfb355cd21fd0df60cf93add26c6": { "balance": "200000000000000000000" }, "19ff244fcfe3d4fa2f4fd99f87e55bb315b81eb6": { "balance": "200000000000000000000" }, "d2581a55ce23ab10d8ad8c44378f59079bd6f658": { "balance": "8800000000000000000000" }, "4073fa49b87117cb908cf1ab512da754a932d477": { "balance": "1970000000000000000000" }, "b6a82933c9eadabd981e5d6d60a6818ff806e36b": { "balance": "400000000000000000000" }, "c79806032bc7d828f19ac6a640c68e3d820fa442": { "balance": "20000000000000000000" }, "577b2d073c590c50306f5b1195a4b2ba9ecda625": { "balance": "373600000000000000000" }, "7f13d760498d7193ca6859bc95c901386423d76c": { "balance": "5000000000000000000000" }, "416784af609630b070d49a8bcd12235c6428a408": { "balance": "20000000000000000000000" }, "fbe71622bcbd31c1a36976e7e5f670c07ffe16de": { "balance": "400000000000000000000" }, "a5698035391e67a49013c0002079593114feb353": { "balance": "240000000000000000000" }, "ab2871e507c7be3965498e8fb462025a1a1c4264": { "balance": "775000000000000000000" }, "9c78fbb4df769ce2c156920cfedfda033a0e254a": { "balance": "1970000000000000000000" }, "95e6f93dac228bc7585a25735ac2d076cc3a4017": { "balance": "6000000000000000000000" }, "3c1f91f301f4b565bca24751aa1f761322709ddd": { "balance": "1790000000000000000000" }, "f77f9587ff7a2d7295f1f571c886bd33926a527c": { "balance": "1999800000000000000000" }, "755f587e5efff773a220726a13d0f2130d9f896b": { "balance": "1000000000000000000000" }, "8c6aa882ee322ca848578c06cb0fa911d3608305": { "balance": "600000000000000000000" }, "492cb5f861b187f9df21cd4485bed90b50ffe22d": { "balance": "499928000000000000000" }, "95a577dc2eb3ae6cb9dfc77af697d7efdfe89a01": { "balance": "136000000000000000000" }, "4173419d5c9f6329551dc4d3d0ceac1b701b869e": { "balance": "88000000000000000000" }, "456ae0aca48ebcfae166060250525f63965e760f": { "balance": "300000000000000000000" }, "81f8de2c283d5fd4afbda85dedf9760eabbbb572": { "balance": "3000000000000000000000" }, "cd0af3474e22f069ec3407870dd770443d5b12b0": { "balance": "2626262000000000000000" }, "283c2314283c92d4b064f0aef9bb5246a7007f39": { "balance": "200000000000000000000" }, "29b3f561ee7a6e25941e98a5325b78adc79785f3": { "balance": "100000000000000000000" }, "cd4306d7f6947ac1744d4e13b8ef32cb657e1c00": { "balance": "499986000000000000000" }, "d9ec2efe99ff5cf00d03a8317b92a24aef441f7e": { "balance": "2000000000000000000000" }, "83dbf8a12853b40ac61996f8bf1dc8fdbaddd329": { "balance": "970000000000000000000" }, "9d93fab6e22845f8f45a07496f11de71530debc7": { "balance": "1998000000000000000000" }, "fd204f4f4aba2525ba728afdf78792cbdeb735ae": { "balance": "2000000000000000000000" }, "99fad50038d0d9d4c3fbb4bce05606ecadcd5121": { "balance": "2000000000000000000000" }, "d206aaddb336d45e7972e93cb075471d15897b5d": { "balance": "600000000000000000000" }, "428a1ee0ed331d7952ccbe1c7974b2852bd1938a": { "balance": "2208370000000000000000" }, "690228e4bb12a8d4b5e0a797b0c5cf2a7509131e": { "balance": "1880000000000000000000" }, "fa3a1aa4488b351aa7560cf5ee630a2fd45c3222": { "balance": "878850000000000000000" }, "0372e852582e0934344a0fed2178304df25d4628": { "balance": "20000000000000000000000" }, "35ea2163a38cdf9a123f82a5ec00258dae0bc767": { "balance": "4000000000000000000000" }, "d1fed0aee6f5dfd7e25769254c3cfad15adeccaa": { "balance": "730000000000000000000" }, "c05b740620f173f16e52471dc38b9c514a0b1526": { "balance": "140000000000000000000" }, "87e3062b2321e9dfb0875ce3849c9b2e3522d50a": { "balance": "10000000000000000000000" }, "303fbaebbe46b35b6e5b74946a5f99bc1585cae7": { "balance": "878148000000000000000" }, "e7a8e471eafb798f4554cc6e526730fd56e62c7d": { "balance": "1000000000000000000000" }, "ad7dd053859edff1cb6f9d2acbed6dd5e332426f": { "balance": "1970000000000000000000" }, "dc4345d6812e870ae90c568c67d2c567cfb4f03c": { "balance": "6700000000000000000000" }, "a6a08252c8595177cc2e60fc27593e2379c81fb1": { "balance": "20055000000000000000" }, "a9af21acbe482f8131896a228036ba51b19453c3": { "balance": "49999000000000000000" }, "86e3fe86e93da486b14266eadf056cbfa4d91443": { "balance": "2000000000000000000000" }, "744b03bba8582ae5498e2dc22d19949467ab53fc": { "balance": "500000000000000000000" }, "d3118ea3c83505a9d893bb67e2de142d537a3ee7": { "balance": "20000000000000000000" }, "b32f1c2689a5ce79f1bc970b31584f1bcf2283e7": { "balance": "20000000000000000000" }, "4828e4cbe34e1510afb72c2beeac8a4513eaebd9": { "balance": "3940000000000000000000" }, "b07bcc085ab3f729f24400416837b69936ba8873": { "balance": "2000140000000000000000" }, "bdc74873af922b9df474853b0fa7ff0bf8c82695": { "balance": "3999000000000000000000" }, "15ebd1c7cad2aff19275c657c4d808d010efa0f5": { "balance": "200550000000000000000" }, "cbc04b4d8b82caf670996f160c362940d66fcf1a": { "balance": "6000000000000000000000" }, "8197948121732e63d9c148194ecad46e30b749c8": { "balance": "4000000000000000000000" }, "69797bfb12c9bed682b91fbc593591d5e4023728": { "balance": "10000000000000000000000" }, "be9b8c34b78ee947ff81472eda7af9d204bc8466": { "balance": "150000000000000000000" }, "df3f57b8ee6434d047223def74b20f63f9e4f955": { "balance": "250500000000000000000" }, "a3ae1879007d801cb5f352716a4dd8ba2721de3d": { "balance": "200000000000000000000000" }, "cb4bb1c623ba28dc42bdaaa6e74e1d2aa1256c2a": { "balance": "1999944000000000000000" }, "e03c00d00388ecbf4f263d0ac778bb41a57a40d9": { "balance": "1000072000000000000000" }, "fc2c1f88961d019c3e9ea33009152e0693fbf88a": { "balance": "8000000000000000000000" }, "8599cbd5a6a9dcd4b966be387d69775da5e33c6f": { "balance": "58180000000000000000000" }, "b7a31a7c38f3db09322eae11d2272141ea229902": { "balance": "2000000000000000000000" }, "231a15acc199c89fa9cb22441cc70330bdcce617": { "balance": "500000000000000000000" }, "3fbed6e7e0ca9c84fbe9ebcf9d4ef9bb49428165": { "balance": "2000000000000000000000" }, "92cfd60188efdfb2f8c2e7b1698abb9526c1511f": { "balance": "2000000000000000000000" }, "5c936f3b9d22c403db5e730ff177d74eef42dbbf": { "balance": "75000000000000000000" }, "931fe712f64207a2fd5022728843548bfb8cbb05": { "balance": "2000000000000000000000" }, "08d54e83ad486a934cfaeae283a33efd227c0e99": { "balance": "1039000000000000000000" }, "a339a3d8ca280e27d2415b26d1fc793228b66043": { "balance": "1013600000000000000000" }, "581f34b523e5b41c09c87c298e299cbc0e29d066": { "balance": "1131607000000000000000" }, "caaa68ee6cdf0d34454a769b0da148a1faaa1865": { "balance": "7216000000000000000000" }, "0838a7768d9c2aca8ba279adfee4b1f491e326f1": { "balance": "200000000000000000000" }, "dde77a4740ba08e7f73fbe3a1674912931742eeb": { "balance": "19867021000000000000000" }, "cbe810fe0fecc964474a1db97728bc87e973fcbd": { "balance": "10000000000000000000000" }, "86c28b5678af37d727ec05e4447790f15f71f2ea": { "balance": "200000000000000000000" }, "dd6c062193eac23d2fdbf997d5063a346bb3b470": { "balance": "20000000000000000000" }, "5975b9528f23af1f0e2ec08ac8ebaa786a2cb8e0": { "balance": "345827000000000000000" }, "e29d8ae452dcf3b6ac645e630409385551faae0a": { "balance": "80276000000000000000" }, "2fbc85798a583598b522166d6e9dda121d627dbc": { "balance": "200000000000000000000" }, "7a36aba5c31ea0ca7e277baa32ec46ce93cf7506": { "balance": "20000000000000000000000" }, "dbcbcd7a57ea9db2349b878af34b1ad642a7f1d1": { "balance": "200000000000000000000" }, "92aae59768eddff83cfe60bb512e730a05a161d7": { "balance": "1708015000000000000000" }, "a5e93b49ea7c509de7c44d6cfeddef5910deaaf2": { "balance": "2000000000000000000000" }, "e33d980220fab259af6a1f4b38cf0ef3c6e2ea1a": { "balance": "2000000000000000000000" }, "8ed0af11ff2870da0681004afe18b013f7bd3882": { "balance": "4000000000000000000000" }, "f23e5c633221a8f7363e65870c9f287424d2a960": { "balance": "1380000000000000000000" }, "96334bfe04fffa590213eab36514f338b864b736": { "balance": "400000000000000000000" }, "fa1f1971a775c3504fef5079f640c2c4bce7ac05": { "balance": "2000000000000000000000" }, "df44c47fc303ac76e74f97194cca67b5bb3c023f": { "balance": "591000000000000000000" }, "4b74f5e58e2edf76daf70151964a0b8f1de0663c": { "balance": "324020000000000000000" }, "e38b91b35190b6d9deed021c30af094b953fdcaa": { "balance": "33340000000000000000" }, "6b38de841fad7f53fe02da115bd86aaf662466bd": { "balance": "1730000000000000000000" }, "11675a25554607a3b6c92a9ee8f36f75edd3e336": { "balance": "159800000000000000000" }, "0ba8705bf55cf219c0956b5e3fc01c4474a6cdc1": { "balance": "94963000000000000000" }, "0f05f120c89e9fbc93d4ab0c5e2b4a0df092b424": { "balance": "30000000000000000000000" }, "fdd1195f797d4f35717d15e6f9810a9a3ff55460": { "balance": "18200000000000000000" }, "63a61dc30a8e3b30a763c4213c801cbf98738178": { "balance": "1000000000000000000000" }, "e5bdf34f4ccc483e4ca530cc7cf2bb18febe92b3": { "balance": "126260000000000000000" }, "d6e09e98fe1300332104c1ca34fbfac554364ed9": { "balance": "2000000000000000000000" }, "5bd6862d517d4de4559d4eec0a06cad05e2f946e": { "balance": "200000000000000000000" }, "7294ec9da310bc6b4bbdf543b0ef45abfc3e1b4d": { "balance": "22000000000000000000000" }, "ae34861d342253194ffc6652dfde51ab44cad3fe": { "balance": "466215000000000000000" }, "f50ae7fab4cfb5a646ee04ceadf9bf9dd5a8e540": { "balance": "3999952000000000000000" }, "dd2bdfa917c1f310e6fa35aa8af16939c233cd7d": { "balance": "400000000000000000000" }, "e0060462c47ff9679baef07159cae08c29f274a9": { "balance": "2000000000000000000000" }, "b7d12e84a2e4c4a6345af1dd1da9f2504a2a996e": { "balance": "200000000000000000000" }, "f5500178cb998f126417831a08c2d7abfff6ab5f": { "balance": "1308923000000000000000" }, "fd377a385272900cb436a3bb7962cdffe93f5dad": { "balance": "2000000000000000000000" }, "a4a83a0738799b971bf2de708c2ebf911ca79eb2": { "balance": "600000000000000000000" }, "52a5e4de4393eeccf0581ac11b52c683c76ea15d": { "balance": "19999800000000000000000" }, "b07fdeaff91d4460fe6cd0e8a1b0bd8d22a62e87": { "balance": "5260000000000000000000" }, "35f5860149e4bbc04b8ac5b272be55ad1aca58e0": { "balance": "200000000000000000000" }, "fb135eb15a8bac72b69915342a60bbc06b7e077c": { "balance": "20000000000000000000000" }, "02d4a30968a39e2b3498c3a6a4ed45c1c6646822": { "balance": "2000000000000000000000" }, "e44b7264dd836bee8e87970340ed2b9aed8ed0a5": { "balance": "5772100000000000000000" }, "e90a354cec04d69e5d96ddc0c5138d3d33150aa0": { "balance": "499971000000000000000" }, "693d83be09459ef8390b2e30d7f7c28de4b4284e": { "balance": "2000000000000000000000" }, "87bf7cd5d8a929e1c785f9e5449106ac232463c9": { "balance": "77800000000000000000" }, "e5f8ef6d970636b0dcaa4f200ffdc9e75af1741c": { "balance": "2000000000000000000000" }, "fef09d70243f39ed8cd800bf9651479e8f4aca3c": { "balance": "200000000000000000000" }, "e98c91cadd924c92579e11b41217b282956cdaa1": { "balance": "135800000000000000000" }, "c2836188d9a29253e0cbda6571b058c289a0bb32": { "balance": "2000000000000000000000" }, "afa6946effd5ff53154f82010253df47ae280ccc": { "balance": "1970000000000000000000" }, "43c7ebc5b3e7af16f47dc5617ab10e0f39b4afbb": { "balance": "1910000000000000000000" }, "097ecda22567c2d91cb03f8c5215c22e9dcda949": { "balance": "20055000000000000000" }, "3e66b84769566ab67945d5fa81373556bcc3a1fa": { "balance": "152000000000000000000" }, "56373daab46316fd7e1576c61e6affcb6559ddd7": { "balance": "215340000000000000000" }, "faaeba8fc0bbda553ca72e30ef3d732e26e82041": { "balance": "1338337000000000000000" }, "f54c19d9ef3873bfd1f7a622d02d86249a328f06": { "balance": "44284729000000000000000" }, "825309a7d45d1812f51e6e8df5a7b96f6c908887": { "balance": "2365000000000000000000" }, "89009e3c6488bd5e570d1da34eabe28ed024de1b": { "balance": "20000000000000000000000" }, "63977cad7d0dcdc52b9ac9f2ffa136e8642882b8": { "balance": "75000000000000000000" }, "c239abdfae3e9af5457f52ed2b91fd0ab4d9c700": { "balance": "2000000000000000000000" }, "1a4ec6a0ae7f5a9427d23db9724c0d0cffb2ab2f": { "balance": "179000000000000000000" }, "a12a6c2d985daf0e4f5f207ae851aaf729b332cd": { "balance": "100000000000000000000000" }, "cbe52fc533d7dd608c92a260b37c3f45deb4eb33": { "balance": "1000000000000000000000" }, "abb2e6a72a40ba6ed908cdbcec3c5612583132fe": { "balance": "1460000000000000000000" }, "6503860b191008c15583bfc88158099301762828": { "balance": "1000000000000000000000" }, "a0228240f99e1de9cb32d82c0f2fa9a3d44b0bf3": { "balance": "1600000000000000000000" }, "e154daeadb545838cbc6aa0c55751902f528682a": { "balance": "4925000000000000000000" }, "8e92aba38e72a098170b92959246537a2e5556c0": { "balance": "267400000000000000000" }, "d23d7affacdc3e9f3dae7afcb4006f58f8a44600": { "balance": "3600000000000000000000" }, "00d78d89b35f472716eceafebf600527d3a1f969": { "balance": "27750000000000000000000" }, "120f9de6e0af7ec02a07c609ca8447f157e6344c": { "balance": "267400000000000000000" }, "e0352fdf819ba265f14c06a6315c4ac1fe131b2e": { "balance": "1000000000000000000000" }, "8f47328ee03201c9d35ed2b5412b25decc859362": { "balance": "2000000000000000000000" }, "453e359a3397944c5a275ab1a2f70a5e5a3f6989": { "balance": "240000000000000000000" }, "9bf58efbea0784eb068adecfa0bb215084c73a35": { "balance": "5800000000000000000000" }, "21bfe1b45cacde6274fd8608d9a178bf3eeb6edc": { "balance": "2009400000000000000000" }, "d1d5b17ffe2d7bbb79cc7d7930bcb2e518fb1bbf": { "balance": "3000000000000000000000" }, "20a29c5079e26b3f18318bb2e50e8e8b346e5be8": { "balance": "499986000000000000000" }, "7d392852f3abd92ff4bb5bb26cb60874f2be6795": { "balance": "1000070000000000000000" }, "55852943492970f8d629a15366cdda06a94f4513": { "balance": "2000000000000000000000" }, "ab5dfc1ea21adc42cf8c3f6e361e243fd0da61e5": { "balance": "300000000000000000000" }, "9d2bfc36106f038250c01801685785b16c86c60d": { "balance": "380000000000000000000000" }, "6e60aee1a78f8eda8b424c73e353354ae67c3042": { "balance": "3490300000000000000000" }, "7e29290038493559194e946d4e460b96fc38a156": { "balance": "309072000000000000000" }, "6006e36d929bf45d8f16231b126a011ae283d925": { "balance": "176000000000000000000" }, "d6d03572a45245dbd4368c4f82c95714bd2167e2": { "balance": "1162200000000000000000" }, "d1432538e35b7664956ae495a32abdf041a7a21c": { "balance": "19700000000000000000000" }, "2276264bec8526c0c0f270677abaf4f0e441e167": { "balance": "1000000000000000000000" }, "c8814e34523e38e1f927a7dce8466a447a093603": { "balance": "10000000000000000000000" }, "688a569e965524eb1d0ac3d3733eab909fb3d61e": { "balance": "1320000000000000000000" }, "90dc09f717fc2a5b69fd60ba08ebf40bf4e8246c": { "balance": "4000086000000000000000" }, "239a733e6b855ac592d663156186a8a174d2449e": { "balance": "1637020000000000000000" }, "bcdfacb9d9023c3417182e9100e8ea1d373393a3": { "balance": "59100000000000000000" }, "ba6440aeb3737b8ef0f1af9b0c15f4c214ffc7cf": { "balance": "1000000000000000000000" }, "322e5c43b0f524389655a9b3ff24f2d4db3da10f": { "balance": "4650000000000000000000" }, "be5a60689998639ad75bc105a371743eef0f7940": { "balance": "501700000000000000000" }, "b727a9fc82e1cffc5c175fa1485a9befa2cdbdd1": { "balance": "999000000000000000000" }, "a3883a24f7f166205f1a6a9949076c26a76e7178": { "balance": "1820000000000000000000" }, "5e95fe5ffcf998f9f9ac0e9a81dab83ead77003d": { "balance": "539766000000000000000" }, "e60955dc0bc156f6c41849f6bd776ba44b0ef0a1": { "balance": "299982000000000000000" }, "af203e229d7e6d419df4378ea98715515f631485": { "balance": "1970000000000000000000" }, "86499a1228ff2d7ee307759364506f8e8c8307a5": { "balance": "1970000000000000000000" }, "1a04cec420ad432215246d77fe178d339ed0b595": { "balance": "316000000000000000000" }, "cc2b5f448f3528d3fe41cc7d1fa9c0dc76f1b776": { "balance": "60000000000000000000" }, "cb50587412822304ebcba07dab3a0f09fffee486": { "balance": "1370000000000000000000" }, "4ae2a04d3909ef454e544ccfd614bfefa71089ae": { "balance": "442800000000000000000" }, "c8a2c4e59e1c7fc54805580438aed3e44afdf00e": { "balance": "44000000000000000000" }, "5792814f59a33a1843faa01baa089eb02ffb5cf1": { "balance": "499986000000000000000" }, "a1f2854050f872658ed82e52b0ad7bbc1cb921f6": { "balance": "2010918000000000000000" }, "92dca5e102b3b81b60f1a504634947c374a88ccb": { "balance": "2000000000000000000000" }, "732fead60f7bfdd6a9dec48125e3735db1b6654f": { "balance": "20000000000000000000" }, "6bf7b3c065f2c1e7c6eb092ba0d15066f393d1b8": { "balance": "400000000000000000000" }, "cde36d81d128c59da145652193eec2bfd96586ef": { "balance": "4000000000000000000000" }, "40eddb448d690ed72e05c225d34fc8350fa1e4c5": { "balance": "7000000000000000000000" }, "454b61b344c0ef965179238155f277c3829d0b38": { "balance": "2000000000000000000000" }, "ac3da526cfce88297302f34c49ca520dc271f9b2": { "balance": "800000000000000000000" }, "c989eec307e8839b9d7237cfda08822962abe487": { "balance": "400000000000000000000" }, "e99de258a4173ce9ac38ede26c0b3bea3c0973d5": { "balance": "1656800000000000000000" }, "ff0cb06c42e3d88948e45bd7b0d4e291aefeea51": { "balance": "1910000000000000000000" }, "0990e81cd785599ea236bd1966cf526302c35b9c": { "balance": "1000000000000000000000" }, "6da0ed8f1d69339f059f2a0e02471cb44fb8c3bb": { "balance": "935900000000000000000" }, "5d958a9bd189c2985f86c58a8c69a7a78806e8da": { "balance": "10200000000000000000000" }, "98be696d51e390ff1c501b8a0f6331b628ddc5ad": { "balance": "2000000000000000000000" }, "09d0b8cd077c69d9f32d9cca43b3c208a21ed48b": { "balance": "150011000000000000000" }, "96e7c0c9d5bf10821bf140c558a145b7cac21397": { "balance": "1056000000000000000000" }, "5b736eb18353629bde9676dadd165034ce5ecc68": { "balance": "1970000000000000000000" }, "e5a365343cc4eb1e770368e1f1144a77b832d7e0": { "balance": "20000000000000000000" }, "4cf5537b85842f89cfee359eae500fc449d2118f": { "balance": "1000000000000000000000" }, "c71f1d75873f33dcb2dd4b3987a12d0791a5ce27": { "balance": "1015200000000000000000" }, "9bf703b41c3624e15f4054962390bcba3052f0fd": { "balance": "6055000000000000000000" }, "145e1de0147911ccd880875fbbea61f6a142d11d": { "balance": "4000000000000000000000" }, "68419c6dd2d3ce6fcbb3c73e2fa079f06051bde6": { "balance": "1970000000000000000000" }, "d8eb78503ec31a54a90136781ae109004c743257": { "balance": "1000000000000000000000" }, "f25e4c70bc465632c89e5625a832a7722f6bffab": { "balance": "4488000000000000000000" }, "7b4d2a38269069c18557770d591d24c5121f5e83": { "balance": "700000000000000000000" }, "27d158ac3d3e1109ab6e570e90e85d3892cd7680": { "balance": "100000000000000000000" }, "d3679a47df2d99a49b01c98d1c3e0c987ce1e158": { "balance": "280000000000000000000" }, "095b949de3333a377d5019d893754a5e4656ff97": { "balance": "340000000000000000000" }, "6b17598a8ef54f797ae515ccb6517d1859bf8011": { "balance": "100000000000000000000" }, "3eaf0879b5b6db159b589f84578b6a74f6c10357": { "balance": "7253657000000000000000" }, "40d45d9d7625d15156c932b771ca7b0527130958": { "balance": "100000000000000000000000" }, "0392549a727f81655429cb928b529f25df4d1385": { "balance": "26248000000000000000" }, "c5b009baeaf788a276bd35813ad65b400b849f3b": { "balance": "1000000000000000000000" }, "6ed884459f809dfa1016e770edaf3e9fef46fa30": { "balance": "3400170000000000000000" }, "439d2f2f5110a4d58b1757935015408740fec7f8": { "balance": "3830421000000000000000" }, "dc46c13325cd8edf0230d068896486f007bf4ef1": { "balance": "1337000000000000000000" }, "8c54c7f8b9896e75d7d5f5c760258699957142ad": { "balance": "40000000000000000000" }, "61c8f1fa43bf846999ecf47b2b324dfb6b63fe3a": { "balance": "800000000000000000000" }, "935069444a6a984de2084e46692ab99f671fc727": { "balance": "9000000000000000000000" }, "fc49c1439a41d6b3cf26bb67e0365224e5e38f5f": { "balance": "1000076000000000000000" }, "e1dfb5cc890ee8b2877e885d267c256187d019e6": { "balance": "100000000000000000000" }, "ee7c3ded7c28f459c92fe13b4d95bafbab02367d": { "balance": "700000000000000000000" }, "a5874d754635a762b381a5c4c792483af8f23d1d": { "balance": "50000000000000000000" }, "cfbb32b7d024350e3321fa20c9a914035372ffc6": { "balance": "401100000000000000000" }, "2bc429d618a66a4cf82dbb2d824e9356effa126a": { "balance": "1999944000000000000000" }, "db244f97d9c44b158a40ed9606d9f7bd38913331": { "balance": "102000000000000000000" }, "55e220876262c218af4f56784798c7e55da09e91": { "balance": "133566000000000000000" }, "ca41ccac30172052d522cd2f2f957d248153409f": { "balance": "1970000000000000000000" }, "b11fa7fb270abcdf5a2eab95aa30c4b53636efbf": { "balance": "800000000000000000000" }, "0ffea06d7113fb6aec2869f4a9dfb09007facef4": { "balance": "225416000000000000000" }, "646628a53c2c4193da88359ce718dadd92b7a48d": { "balance": "200032000000000000000" }, "ca8409083e01b397cf12928a05b68455ce6201df": { "balance": "1600000000000000000000" }, "dbbcbb79bf479a42ad71dbcab77b5adfaa872c58": { "balance": "1730000000000000000000" }, "db7d4037081f6c65f9476b0687d97f1e044d0a1d": { "balance": "660000000000000000000" }, "4be90d412129d5a4d0424361d6649d4e47a62316": { "balance": "1015200000000000000000" }, "e3ab3ca9b870e3f548517306bba4de2591afafc2": { "balance": "1200062000000000000000" }, "5c61ab79b408dd3229f662593705d72f1e147bb8": { "balance": "22729000000000000000000" }, "4f177f9d56953ded71a5611f393322c30279895c": { "balance": "246000000000000000000" }, "e6cb260b716d4c0ab726eeeb07c8707204e276ae": { "balance": "1000000000000000000000" }, "44355253b27748e3f34fe9cae1fb718c8f249529": { "balance": "200000000000000000000" }, "a309df54cabce70c95ec3033149cd6678a6fd4cf": { "balance": "223600000000000000000" }, "ec4867d2175ab5b9469361595546554684cda460": { "balance": "3000000000000000000000" }, "8d06e464245cad614939e0af0845e6d730e20374": { "balance": "200359000000000000000" }, "9810e34a94db6ed156d0389a0e2b80f4fd6b0a8a": { "balance": "2000000000000000000000" }, "dcfff3e8d23c2a34b56bd1b3bd45c79374432239": { "balance": "5000000000000000000000" }, "7d7dd5ee614dbb6fbfbcd26305247a058c41faa1": { "balance": "2000000000000000000000" }, "8a9eca9c5aba8e139f8003edf1163afb70aa3aa9": { "balance": "660000000000000000000" }, "d942de4784f7a48716c0fd4b9d54a6e54c5f2f3e": { "balance": "20000000000000000000000" }, "07dae622630d1136381933d2ad6b22b839d82102": { "balance": "200000000000000000000" }, "abf12fa19e82f76c718f01bdca0003674523ef30": { "balance": "2000000000000000000000" }, "411c831cc6f44f1965ec5757ab4e5b3ca4cffd1f": { "balance": "425000000000000000000" }, "99129d5b3c0cde47ea0def4dfc070d1f4a599527": { "balance": "2000000000000000000000" }, "c5cdcee0e85d117dabbf536a3f4069bf443f54e7": { "balance": "1969606000000000000000" }, "f218bd848ee7f9d38bfdd1c4eb2ed2496ae4305f": { "balance": "500000000000000000000" }, "fe549bbfe64740189892932538daaf46d2b61d4f": { "balance": "40000000000000000000" }, "dc3f0e7672f71fe7525ba30b9755183a20b9166a": { "balance": "9603617000000000000000" }, "0e83b850481ab44d49e0a229a2e464902c69539b": { "balance": "100000000000000000000" }, "07ddd0422c86ef65bf0c7fc3452862b1228b08b8": { "balance": "2065302000000000000000" }, "a68c313445c22d919ee46cc2d0cdff043a755825": { "balance": "75189000000000000000" }, "a9e9dbce7a2cb03694799897bed7c54d155fdaa8": { "balance": "197559000000000000000" }, "18fccf62d2c3395453b7587b9e26f5cff9eb7482": { "balance": "1000000000000000000000" }, "ff41d9e1b4effe18d8b0d1f63fc4255fb4e06c3d": { "balance": "1337000000000000000000" }, "8f69eafd0233cadb4059ab779c46edf2a0506e48": { "balance": "1788210000000000000000" }, "9aa48c66e4fb4ad099934e32022e827427f277ba": { "balance": "10000000000000000000000" }, "f46980e3a4a9d29a6a6e90604537a3114bcb2897": { "balance": "500000000000000000000" }, "801732a481c380e57ed62d6c29de998af3fa3b13": { "balance": "100000000000000000000" }, "0cd6a141918d126b106d9f2ebf69e102de4d3277": { "balance": "20000000000000000000" }, "17589a6c006a54cad70103123aae0a82135fdeb4": { "balance": "4000000000000000000000" }, "8725e8c753b3acbfdca55f3c62dfe1a59454968a": { "balance": "1000090000000000000000" }, "d20dcb0b78682b94bc3000281448d557a20bfc83": { "balance": "895000000000000000000" }, "e84f8076a0f2969ecd333eef8de41042986291f2": { "balance": "432000000000000000000" }, "b3145b74506d1a8d047cdcdc55392a7b5350799a": { "balance": "129314663000000000000000" }, "0d9a825ff2bcd397cbad5b711d9dcc95f1cc112d": { "balance": "12800000000000000000000" }, "0ca670eb2c8b96cba379217f5929c2b892f39ef6": { "balance": "2000000000000000000000" }, "25cfc4e25c35c13b69f7e77dbfb08baf58756b8d": { "balance": "40000000000000000000000" }, "182db85293f606e88988c3704cb3f0c0bbbfca5a": { "balance": "133700000000000000000" }, "bd73c3cbc26a175062ea0320dd84b253bce64358": { "balance": "394000000000000000000" }, "2680713d40808e2a50ed013150a2a694b96a7f1d": { "balance": "1790000000000000000000" }, "51e32f14f4ca5e287cdac057a7795ea9e0439953": { "balance": "500000000000000000000" }, "b1e9c5f1d21e61757a6b2ee75913fc5a1a4101c3": { "balance": "2000000000000000000000" }, "d4c4d1a7c3c74984f6857b2f5f07e8face68056d": { "balance": "2000000000000000000000" }, "4651dc420e08c3293b27d2497890eb50223ae2f4": { "balance": "20000000000000000000000" }, "c74a3995f807de1db01a2eb9c62e97d0548f696f": { "balance": "1000000000000000000000" }, "0505a08e22a109015a22f685305354662a5531d5": { "balance": "2600000000000000000000" }, "39c773367c8825d3596c686f42bf0d14319e3f84": { "balance": "133700000000000000000" }, "0f929cf895db017af79f3ead2216b1bd69c37dc7": { "balance": "2000000000000000000000" }, "bdd3254e1b3a6dc6cc2c697d45711aca21d516b2": { "balance": "2000000000000000000000" }, "ae5d221afcd3d29355f508eadfca408ce33ca903": { "balance": "100000000000000000000000" }, "916cf17d71412805f4afc3444a0b8dd1d9339d16": { "balance": "14300000000000000000" }, "4319263f75402c0b5325f263be4a5080651087f0": { "balance": "983086000000000000000" }, "0f1c249cd962b00fd114a9349f6a6cc778d76c4d": { "balance": "2000000000000000000000" }, "54febcce20fe7a9098a755bd90988602a48c089e": { "balance": "640000000000000000000" }, "2c1800f35fa02d3eb6ff5b25285f5e4add13b38d": { "balance": "906400000000000000000" }, "72b904440e90e720d6ac1c2ad79c321dcc1c1a86": { "balance": "1550000000000000000000" }, "b0aa00950c0e81fa3210173e729aaf163a27cd71": { "balance": "40000000000000000000000" }, "663604b0503046e624cd26a8b6fb4742dce02a6f": { "balance": "65400000000000000000" }, "3c98594bf68b57351e8814ae9e6dfd2d254aa06f": { "balance": "300000000000000000000" }, "9c45202a25f6ad0011f115a5a72204f2f2198866": { "balance": "5014000000000000000000" }, "b02d062873334545cea29218e4057760590f7423": { "balance": "3186000000000000000000" }, "7bddb2ee98de19ee4c91f661ee8e67a91d054b97": { "balance": "1000000000000000000000" }, "9cf2928beef09a40f9bfc953be06a251116182fb": { "balance": "6000000000000000000000" }, "51b4758e9e1450e7af4268c3c7b1e7bd6f5c7550": { "balance": "1000000000000000000000" }, "eb570dba975227b1c42d6e8dea2c56c9ad960670": { "balance": "2000000000000000000000" }, "970d8b8a0016d143054f149fb3b8e550dc0797c7": { "balance": "1000000000000000000000" }, "c7b39b060451000ca1049ba154bcfa00ff8af262": { "balance": "100000000000000000000000" }, "945e18769d7ee727c7013f92de24d117967ff317": { "balance": "2000000000000000000000" }, "d18eb9e1d285dabe93e5d4bae76beefe43b521e8": { "balance": "668500000000000000000" }, "c618521321abaf5b26513a4a9528086f220adc6f": { "balance": "27000000000000000000" }, "dd65f6e17163b5d203641f51cc7b24b00f02c8fb": { "balance": "200000000000000000000" }, "131faed12561bb7aee04e5185af802b1c3438d9b": { "balance": "219000000000000000000" }, "1ced6715f862b1ff86058201fcce5082b36e62b2": { "balance": "6684522000000000000000" }, "a0ff5b4cf016027e8323497d4428d3e5a83b8795": { "balance": "6596500000000000000000" }, "02e816afc1b5c0f39852131959d946eb3b07b5ad": { "balance": "1000000000000000000000" }, "153cf2842cb9de876c276fa64767d1a8ecf573bb": { "balance": "2000000000000000000000" }, "3bc6e3ee7a56ce8f14a37532590f63716b9966e8": { "balance": "2000000000000000000000" }, "f6d25d3f3d846d239f525fa8cac97bc43578dbac": { "balance": "896000000000000000000" }, "2066774d822793ff25f1760909479cf62491bf88": { "balance": "55160000000000000000000" }, "46779a5656ff00d73eac3ad0c38b6c853094fb40": { "balance": "230752000000000000000" }, "22eed327f8eb1d1338a3cb7b0f8a4baa5907cd95": { "balance": "23445000000000000000" }, "ff88ebacc41b3687f39e4b59e159599b80cba33f": { "balance": "400000000000000000000" }, "2874f3e2985d5f7b406627e17baa772b01abcc9e": { "balance": "6014000000000000000000" }, "eb10458daca79e4a6b24b29a8a8ada711b7f2eb6": { "balance": "3998000000000000000000" }, "541060fc58c750c40512f83369c0a63340c122b6": { "balance": "1970000000000000000000" }, "fd2757cc3551a095878d97875615fe0c6a32aa8a": { "balance": "598200000000000000000" }, "be659d85e7c34f8833ea7f488de1fbb5d4149bef": { "balance": "9072500000000000000000" }, "e149b5726caf6d5eb5bf2acc41d4e2dc328de182": { "balance": "1940000000000000000000" }, "2fe0cc424b53a31f0916be08ec81c50bf8eab0c1": { "balance": "600000000000000000000" }, "e3712701619ca7623c55db3a0ad30e867db0168b": { "balance": "20000000000000000000" }, "f8ca336c8e91bd20e314c20b2dd4608b9c8b9459": { "balance": "846000000000000000000" }, "68acdaa9fb17d3c309911a77b05f5391fa034ee9": { "balance": "8950000000000000000000" }, "e77d7deab296c8b4fa07ca3be184163d5a6d606c": { "balance": "92538000000000000000" }, "e6b9545f7ed086e552924639f9a9edbbd5540b3e": { "balance": "3760000000000000000000" }, "2866b81decb02ee70ae250cee5cdc77b59d7b679": { "balance": "2000000000000000000000" }, "60e3cc43bcdb026aad759c7066f555bbf2ac66f5": { "balance": "2000000000000000000000" }, "fcbd85feea6a754fcf3449449e37ff9784f7773c": { "balance": "3086000000000000000000" }, "38a744efa6d5c2137defef8ef9187b649eee1c78": { "balance": "4000000000000000000000" }, "9d7655e9f3e5ba5d6e87e412aebe9ee0d49247ee": { "balance": "2620100000000000000000" }, "2020b81ae53926ace9f7d7415a050c031d585f20": { "balance": "341200000000000000000" }, "4244f1331158b9ce26bbe0b9236b9203ca351434": { "balance": "10000000000000000000000" }, "99c236141daec837ece04fdaee1d90cf8bbdc104": { "balance": "2184000000000000000000" }, "943d37864a4a537d35c8d99723cd6406ce2562e6": { "balance": "2000000000000000000000" }, "d79483f6a8444f2549d611afe02c432d15e11051": { "balance": "20000000000000000000" }, "9fd64373f2fbcd9c0faca60547cad62e26d9851f": { "balance": "1000000000000000000000" }, "b89c036ed7c492879921be41e10ca1698198a74c": { "balance": "1820000000000000000000" }, "7462c89caa9d8d7891b2545def216f7464d5bb21": { "balance": "109162000000000000000" }, "bb0366a7cfbd3445a70db7fe5ae34885754fd468": { "balance": "6160000000000000000000" }, "6c52cf0895bb35e656161e4dc46ae0e96dd3e62c": { "balance": "4000086000000000000000" }, "b9cf71b226583e3a921103a5316f855a65779d1b": { "balance": "24000000000000000000000" }, "016b60bb6d67928c29fd0313c666da8f1698d9c5": { "balance": "2000000000000000000000" }, "9454b3a8bff9709fd0e190877e6cb6c89974dbd6": { "balance": "2674000000000000000000" }, "84aac7fa197ff85c30e03b7a5382b957f41f3afb": { "balance": "157600000000000000000" }, "db6e560c9bc620d4bea3a94d47f7880bf47f2d5f": { "balance": "89500000000000000000" }, "eefd05b0e3c417d55b3343060486cdd5e92aa7a6": { "balance": "1430000000000000000000" }, "3a59a08246a8206f8d58f70bb1f0d35c5bcc71bd": { "balance": "185000000000000000000" }, "9bfff50db36a785555f07652a153b0c42b1b8b76": { "balance": "2000000000000000000000" }, "d44f5edf2bcf2433f211dadd0cc450db1b008e14": { "balance": "267400000000000000000" }, "2378fd4382511e968ed192106737d324f454b535": { "balance": "1000000000000000000000" }, "c94089553ae4c22ca09fbc98f57075cf2ec59504": { "balance": "4000000000000000000000" }, "08ef3fa4c43ccdc57b22a4b9b2331a82e53818f2": { "balance": "4000000000000000000000" }, "e48e65125421880d42bdf1018ab9778d96928f3f": { "balance": "4200000000000000000000" }, "67518e5d02b205180f0463a32004471f753c523e": { "balance": "1984289000000000000000" }, "0da7401262384e2e8b4b26dd154799b55145efa0": { "balance": "300000000000000000000" }, "0b6920a64b363b8d5d90802494cf564b547c430d": { "balance": "1200000000000000000000" }, "a5ab4bd3588f46cb272e56e93deed386ba8b753d": { "balance": "1332989000000000000000" }, "1788da9b57fd05edc4ff99e7fef301519c8a0a1e": { "balance": "2000000000000000000000" }, "17b2d6cf65c6f4a347ddc6572655354d8a412b29": { "balance": "2000000000000000000000" }, "d0319139fbab2e8e2accc1d924d4b11df6696c5a": { "balance": "200000000000000000000" }, "4c377bb03ab52c4cb79befa1dd114982924c4ae9": { "balance": "1827814000000000000000" }, "fb949c647fdcfd2514c7d58e31f28a532d8c5833": { "balance": "20000000000000000000000" }, "70e5e9da735ff077249dcb9aaf3db2a48d9498c0": { "balance": "1000000000000000000000" }, "fe6f5f42b6193b1ad16206e4afb5239d4d7db45e": { "balance": "1730000000000000000000" }, "bda4be317e7e4bed84c0495eee32d607ec38ca52": { "balance": "2309457000000000000000" }, "5910106debd291a1cd80b0fbbb8d8d9e93a7cc1e": { "balance": "2000000000000000000000" }, "ba42f9aace4c184504abf5425762aca26f71fbdc": { "balance": "37400000000000000000" }, "beb4fd315559436045dcb99d49dcec03f40c42dc": { "balance": "2000000000000000000000" }, "452b64db8ef7d6df87c788639c2290be8482d575": { "balance": "8000000000000000000000" }, "66e09427c1e63deed7e12b8c55a6a19320ef4b6a": { "balance": "170000000000000000000" }, "faad905d847c7b23418aeecbe3addb8dd3f8924a": { "balance": "1970000000000000000000" }, "a29319e81069e5d60df00f3de5adee3505ecd5fb": { "balance": "2000000000000000000000" }, "cf348f2fe47b7e413c077a7baf3a75fbf8428692": { "balance": "2000000000000000000000" }, "e1e8c50b80a352b240ce7342bbfdf5690cc8cb14": { "balance": "394000000000000000000" }, "131c792c197d18bd045d7024937c1f84b60f4438": { "balance": "4000000000000000000000" }, "e49af4f34adaa2330b0e49dc74ec18ab2f92f827": { "balance": "2000000000000000000000" }, "f2e99f5cbb836b7ad36247571a302cbe4b481c69": { "balance": "1970000000000000000000" }, "c93fbde8d46d2bcc0fa9b33bd8ba7f8042125565": { "balance": "1400000000000000000000" }, "038779ca2dbe663e63db3fe75683ea0ec62e2383": { "balance": "1670000000000000000000" }, "a33cb450f95bb46e25afb50fe05feee6fb8cc8ea": { "balance": "776000000000000000000" }, "40ab66fe213ea56c3afb12c75be33f8e32fd085d": { "balance": "4000000000000000000000" }, "6403d062549690c8e8b63eae41d6c109476e2588": { "balance": "2000000000000000000000" }, "bfb0ea02feb61dec9e22a5070959330299c43072": { "balance": "20000000000000000000000" }, "99c475bf02e8b9214ada5fad02fdfd15ba365c0c": { "balance": "591000000000000000000" }, "904966cc2213b5b8cb5bd6089ef9cddbef7edfcc": { "balance": "2000000000000000000000" }, "767a03655af360841e810d83f5e61fb40f4cd113": { "balance": "985000000000000000000" }, "ab209fdca979d0a647010af9a8b52fc7d20d8cd1": { "balance": "9129000000000000000000" }, "6294eae6e420a3d5600a39c4141f838ff8e7cc48": { "balance": "2955000000000000000000" }, "9777cc61cf756be3b3c20cd4491c69d275e7a120": { "balance": "10000000000000000000000" }, "bcbf6ba166e2340db052ea23d28029b0de6aa380": { "balance": "3880000000000000000000" }, "9f10f2a0463b65ae30b070b3df18cf46f51e89bd": { "balance": "1910000000000000000000" }, "8d9952d0bb4ebfa0efd01a3aa9e8e87f0525742e": { "balance": "3460000000000000000000" }, "4f23b6b817ffa5c664acdad79bb7b726d30af0f9": { "balance": "1760000000000000000000" }, "b4c20040ccd9a1a3283da4d4a2f365820843d7e2": { "balance": "1000000000000000000000" }, "7f49e7a4269882bd8722d4a6f566347629624079": { "balance": "2000000000000000000000" }, "33629bd52f0e107bc071176c64df108f64777d49": { "balance": "33425000000000000000" }, "6a7b2e0d88867ff15d207c222bebf94fa6ce8397": { "balance": "60000000000000000000000" }, "b7ce684b09abda53389a875369f71958aeac3bdd": { "balance": "2000000000000000000000" }, "ffbc3da0381ec339c1c049eb1ed9ee34fdcea6ca": { "balance": "4000000000000000000000" }, "849ab80790b28ff1ffd6ba394efc7463105c36f7": { "balance": "34600000000000000000" }, "b0b36af9aeeedf97b6b02280f114f13984ea3260": { "balance": "985000000000000000000" }, "4d57e716876c0c95ef5eaebd35c8f41b069b6bfe": { "balance": "2000000000000000000000" }, "2d2b032359b363964fc11a518263bfd05431e867": { "balance": "149600000000000000000" }, "2ccc1f1cb5f4a8002e186b20885d9dbc030c0894": { "balance": "2000000000000000000000" }, "016c85e1613b900fa357b8283b120e65aefcdd08": { "balance": "799954000000000000000" }, "710b0274d712c77e08a5707d6f3e70c0ce3d92cf": { "balance": "6400000000000000000000" }, "3cd3a6e93579c56d494171fc533e7a90e6f59464": { "balance": "2000000000000000000000" }, "fe0e30e214290d743dd30eb082f1f0a5225ade61": { "balance": "200000000000000000000" }, "d0718520eae0a4d62d70de1be0ca431c5eea2482": { "balance": "2000000000000000000000" }, "af7f79cb415a1fb8dbbd094607ee8d41fb7c5a3b": { "balance": "10000000000000000000000" }, "b7d252ee9402b0eef144295f0e69f0db586c0871": { "balance": "660000000000000000000" }, "c3b928a76fad6578f04f0555e63952cd21d1520a": { "balance": "2000000000000000000000" }, "a7a517d7ad35820b09d497fa7e5540cde9495853": { "balance": "2000000000000000000000" }, "e6e886317b6a66a5b4f81bf164c538c264351765": { "balance": "2000000000000000000000" }, "0770b43dbae4b1f35a927b4fa8124d3866caf97b": { "balance": "1016390000000000000000" }, "52b4257cf41b6e28878d50d57b99914ffa89873a": { "balance": "3930150000000000000000" }, "e08bc29c2b48b169ff2bdc16714c586e6cb85ccf": { "balance": "20000000000000000000" }, "2372c4c1c9939f7aaf6cfac04090f00474840a09": { "balance": "10000000000000000000000" }, "ab6b65eab8dfc917ec0251b9db0ecfa0fa032849": { "balance": "500000000000000000000" }, "582e7cc46f1d7b4e6e9d95868bfd370573178f4c": { "balance": "2000000000000000000000" }, "f167f5868dcf4233a7830609682caf2df4b1b807": { "balance": "2396150000000000000000" }, "ec82f50d06475f684df1b392e00da341aa145444": { "balance": "2000000000000000000000" }, "0968ee5a378f8cadb3bafdbed1d19aaacf936711": { "balance": "1000000000000000000000" }, "a86613e6c4a4c9c55f5c10bcda32175dcbb4af60": { "balance": "10696140000000000000000" }, "a5cd123992194b34c4781314303b03c54948f4b9": { "balance": "2010462000000000000000" }, "52f058d46147e9006d29bf2c09304ad1cddd6e15": { "balance": "1500000000000000000000" }, "160226efe7b53a8af462d117a0108089bdecc2d1": { "balance": "200550000000000000000" }, "256292a191bdda34c4da6b6bd69147bf75e2a9ab": { "balance": "14051000000000000000" }, "1b8aa0160cd79f005f88510a714913d70ad3be33": { "balance": "201760000000000000000" }, "d4b2ff3bae1993ffea4d3b180231da439f7502a2": { "balance": "2000000000000000000000" }, "e408aa99835307eea4a6c5eb801fe694117f707d": { "balance": "500000000000000000000" }, "e60a55f2df996dc3aedb696c08dde039b2641de8": { "balance": "2000000000000000000000" }, "73df3c3e7955f4f2d859831be38000b1076b3884": { "balance": "1970000000000000000000" }, "6228ade95e8bb17d1ae23bfb0518414d497e0eb8": { "balance": "400000000000000000000" }, "0f46c81db780c1674ac73d314f06539ee56ebc83": { "balance": "9850000000000000000000" }, "762d6f30dab99135e4eca51d5243d6c8621102d5": { "balance": "282000000000000000000" }, "4ba0d9e89601772b496847a2bb4340186787d265": { "balance": "1000000000000000000000" }, "ca747576446a4c8f30b08340fee198de63ec92cf": { "balance": "7020000000000000000000" }, "99c31fe748583787cdd3e525b281b218961739e3": { "balance": "1015200000000000000000" }, "1210f80bdb826c175462ab0716e69e46c24ad076": { "balance": "100000000000000000000" }, "3f75ae61cc1d8042653b5baec4443e051c5e7abd": { "balance": "95500000000000000000" }, "5c4892907a0720df6fd3413e63ff767d6b398023": { "balance": "13189467000000000000000" }, "17f14632a7e2820be6e8f6df823558283dadab2d": { "balance": "2000000000000000000000" }, "1dc7f7dad85df53f1271152403f4e1e4fdb3afa0": { "balance": "200000000000000000000" }, "5a30feac37ac9f72d7b4af0f2bc73952c74fd5c3": { "balance": "2000000000000000000000" }, "136d4b662bbd1080cfe4445b0fa213864435b7f1": { "balance": "4000000000000000000000" }, "c1ec81dd123d4b7c2dd9b4d438a7072c11dc874c": { "balance": "2000000000000000000000" }, "09f9575be57d004793c7a4eb84b71587f97cbb6a": { "balance": "200000000000000000000" }, "2c4b470307a059854055d91ec3794d80b53d0f4a": { "balance": "20000000000000000000000" }, "6af6c7ee99df271ba15bf384c0b764adcb4da182": { "balance": "999972000000000000000" }, "0dae3ee5b915b36487f9161f19846d101433318a": { "balance": "1910000000000000000000" }, "0dcf9d8c9804459f647c14138ed50fad563b4154": { "balance": "173000000000000000000" }, "bfa8c858df102cb12421008b0a31c4c7190ad560": { "balance": "200000000000000000000" }, "c2fd0bf7c725ef3e047e5ae1c29fe18f12a7299c": { "balance": "1337000000000000000000" }, "d70a612bd6dda9eab0dddcff4aaf4122d38feae4": { "balance": "540000000000000000000" }, "e07137ae0d116d033533c4eab496f8a9fb09569c": { "balance": "1400000000000000000000" }, "7f49f20726471ac1c7a83ef106e9775ceb662566": { "balance": "5910000000000000000000" }, "1e706655e284dcf0bb37fe075d613a18dc12ff4a": { "balance": "4376760000000000000000" }, "03af7ad9d5223cf7c8c13f20df67ebe5ffc5bb41": { "balance": "200000000000000000000" }, "228242f8336eecd8242e1f000f41937e71dffbbf": { "balance": "5000000000000000000000" }, "e8ed51bbb3ace69e06024b33f86844c47348db9e": { "balance": "165170600000000000000000" }, "3b566a8afad19682dc2ce8679a3ce444a5b0fd4f": { "balance": "2000000000000000000000" }, "dc738fb217cead2f69594c08170de1af10c419e3": { "balance": "100000000000000000000000" }, "13032446e7d610aa00ec8c56c9b574d36ca1c016": { "balance": "2000000000000000000000" }, "6ca6a132ce1cd288bee30ec7cfeffb85c1f50a54": { "balance": "2000000000000000000000" }, "b85f26dd0e72d9c29ebaf697a8af77472c2b58b5": { "balance": "11900000000000000000000" }, "055bd02caf19d6202bbcdc836d187bd1c01cf261": { "balance": "100000000000000000000" }, "3c322e611fdb820d47c6f8fc64b6fad74ca95f5e": { "balance": "242514000000000000000" }, "8daddf52efbd74da95b969a5476f4fbbb563bfd2": { "balance": "835000000000000000000" }, "c63ac417992e9f9b60386ed953e6d7dff2b090e8": { "balance": "4000086000000000000000" }, "27f03cf1abc5e1b51dbc444b289e542c9ddfb0e6": { "balance": "5000000000000000000000" }, "d8f4bae6f84d910d6d7d5ac914b1e68372f94135": { "balance": "100000000000000000000" }, "9f83a293c324d4106c18faa8888f64d299054ca0": { "balance": "200000000000000000000" }, "39ee4fe00fbced647068d4f57c01cb22a80bccd1": { "balance": "6000000000000000000000" }, "404100db4c5d0eec557823b58343758bcc2c8083": { "balance": "20000000000000000000" }, "02751dc68cb5bd737027abf7ddb77390cd77c16b": { "balance": "20000000000000000000" }, "d10302faa1929a326904d376bf0b8dc93ad04c4c": { "balance": "1790000000000000000000" }, "cc419fd9912b85135659e77a93bc3df182d45115": { "balance": "10000000000000000000000" }, "10097198b4e7ee91ff82cc2f3bd95fed73c540c0": { "balance": "2000000000000000000000" }, "7e24d9e22ce1da3ce19f219ccee523376873f367": { "balance": "5900150000000000000000" }, "2e4ee1ae996aa0a1d92428d06652a6bea6d2d15d": { "balance": "2000000000000000000000" }, "91a4149a2c7b1b3a67ea28aff34725e0bf8d7524": { "balance": "1940000000000000000000" }, "ead65262ed5d122df2b2751410f98c32d1238f51": { "balance": "101680000000000000000" }, "e20954d0f4108c82d4dcb2148d26bbd924f6dd24": { "balance": "10000000000000000000000" }, "ebb7d2e11bc6b58f0a8d45c2f6de3010570ac891": { "balance": "26740000000000000000" }, "ef115252b1b845cd857f002d630f1b6fa37a4e50": { "balance": "1970000000000000000000" }, "01a818135a414210c37c62b625aca1a54611ac36": { "balance": "260000000000000000000" }, "ea1ea0c599afb9cd36caacbbb52b5bbb97597377": { "balance": "1069600000000000000000" }, "7a7a4f807357a4bbe68e1aa806393210c411ccb3": { "balance": "30000000000000000000000" }, "6d40ca27826d97731b3e86effcd7b92a4161fe89": { "balance": "2000000000000000000000" }, "8431277d7bdd10457dc017408c8dbbbd414a8df3": { "balance": "39400000000000000000" }, "69b81d5981141ec7a7141060dfcf8f3599ffc63e": { "balance": "5000000000000000000000" }, "47688410ff25d654d72eb2bc06e4ad24f833b094": { "balance": "160440000000000000000" }, "6c101205b323d77544d6dc52af37aca3cec6f7f1": { "balance": "10000000000000000000000" }, "fb685c15e439965ef626bf0d834cd1a89f2b5695": { "balance": "3940000000000000000000" }, "673706b1b0e4dc7a949a7a796258a5b83bb5aa83": { "balance": "16100000000000000000000" }, "ecdaf93229b45ee672f65db506fb5eca00f7fce6": { "balance": "1605009000000000000000" }, "ec6904bae1f69790591709b0609783733f2573e3": { "balance": "500000000000000000000" }, "812ea7a3b2c86eed32ff4f2c73514cc63bacfbce": { "balance": "1000000000000000000000" }, "196c02210a450ab0b36370655f717aa87bd1c004": { "balance": "259456000000000000000" }, "d96ac2507409c7a383ab2eee1822a5d738b36b56": { "balance": "200000000000000000000" }, "ae2f9c19ac76136594432393b0471d08902164d3": { "balance": "698600000000000000000" }, "9d32962ea99700d93228e9dbdad2cc37bb99f07e": { "balance": "3327560000000000000000" }, "17e584e810e567702c61d55d434b34cdb5ee30f6": { "balance": "5000000000000000000000" }, "a3a93ef9dbea2636263d06d8492f6a41de907c22": { "balance": "60000000000000000000" }, "2b5016e2457387956562587115aa8759d8695fdf": { "balance": "200000000000000000000000" }, "140129eaa766b5a29f5b3af2574e4409f8f6d3f1": { "balance": "6400000000000000000000" }, "7025965d2b88da197d4459be3dc9386344cc1f31": { "balance": "2005500000000000000000" }, "388bdcdae794fc44082e667501344118ea96cd96": { "balance": "1670000000000000000000" }, "eee9d0526eda01e43116a395322dda8970578f39": { "balance": "9999980000000000000000" }, "6ec89b39f9f5276a553e8da30e6ec17aa47eefc7": { "balance": "447500000000000000000" }, "7e236666b2d06e63ea4e2ab84357e2dfc977e50e": { "balance": "999972000000000000000" }, "68df947c495bebaeb8e889b3f953d533874bf106": { "balance": "546000000000000000000" }, "d40ed66ab3ceff24ca05ecd471efb492c15f5ffa": { "balance": "500000000000000000000" }, "f0c70d0d6dab7663aa9ed9ceea567ee2c6b02765": { "balance": "2089349000000000000000" }, "b589676d15a04448344230d4ff27c95edf122c49": { "balance": "1000000000000000000000" }, "a0347f0a98776390165c166d32963bf74dcd0a2f": { "balance": "1000000000000000000000" }, "d47d8685faee147c520fd986709175bf2f886bef": { "balance": "2000000000000000000000" }, "a1dcd0e5b05a977c9623e5ae2f59b9ada2f33e31": { "balance": "100000000000000000000" }, "4979194ec9e97db9bee8343b7c77d9d7f3f1dc9f": { "balance": "20000000000000000000" }, "7cd20eccb518b60cab095b720f571570caaa447e": { "balance": "500000000000000000000" }, "2ff830cf55fb00d5a0e03514fecd44314bd6d9f1": { "balance": "10000000000000000000000" }, "0bb25ca7d188e71e4d693d7b170717d6f8f0a70a": { "balance": "336870000000000000000" }, "e9a2b4914e8553bf0d7c00ca532369b879f931bf": { "balance": "2000000000000000000000" }, "720e6b22bf430966fa32b6acb9a506eebf662c61": { "balance": "152000000000000000000" }, "7ade5d66b944bb860c0efdc86276d58f4653f711": { "balance": "2000000000000000000000" }, "2eaff9f8f8113064d3957ac6d6e11eee42c8195d": { "balance": "1970000000000000000000" }, "0c8fd7775e54a6d9c9a3bf890e761f6577693ff0": { "balance": "9850000000000000000000" }, "290a56d41f6e9efbdcea0342e0b7929a8cdfcb05": { "balance": "344000000000000000000" }, "d73ed2d985b5f21b55b274643bc6da031d8edd8d": { "balance": "49250000000000000000000" }, "80156d10efa8b230c99410630d37e269d4093cea": { "balance": "2000000000000000000000" }, "0989c200440b878991b69d6095dfe69e33a22e70": { "balance": "1910000000000000000000" }, "ec8014efc7cbe5b0ce50f3562cf4e67f8593cd32": { "balance": "17300000000000000000" }, "de612d0724e84ea4a7feaa3d2142bd5ee82d3201": { "balance": "20000000000000000000" }, "0f832a93df9d7f74cd0fb8546b7198bf5377d925": { "balance": "143000000000000000000" }, "aa2c670096d3f939305325427eb955a8a60db3c5": { "balance": "2003010000000000000000" }, "25287b815f5c82380a73b0b13fbaf982be24c4d3": { "balance": "40000000000000000000" }, "e75c3b38a58a3f33d55690a5a59766be185e0284": { "balance": "500000000000000000000" }, "1940dc9364a852165f47414e27f5002445a4f143": { "balance": "10850000000000000000000" }, "e5b826196c0e1bc1119b021cf6d259a610c99670": { "balance": "200000000000000000000" }, "82a15cef1d6c8260eaf159ea3f0180d8677dce1c": { "balance": "2000000000000000000000" }, "da06044e293c652c467fe74146bf185b21338a1c": { "balance": "1000000000000000000000" }, "f815c10a032d13c34b8976fa6e3bd2c9131a8ba9": { "balance": "1337000000000000000000" }, "cd95fa423d6fc120274aacde19f4eeb766f10420": { "balance": "200000000000000000000" }, "e3a4f83c39f85af9c8b1b312bfe5fc3423afa634": { "balance": "28650000000000000000" }, "768ce0daa029b7ded022e5fc574d11cde3ecb517": { "balance": "322000000000000000000" }, "e3ec18a74ed43855409a26ade7830de8e42685ef": { "balance": "19700000000000000000" }, "b2bdbedf95908476d7148a370cc693743628057f": { "balance": "4000000000000000000000" }, "bbb8ffe43f98de8eae184623ae5264e424d0b8d7": { "balance": "107600000000000000000" }, "090cebef292c3eb081a05fd8aaf7d39bf07b89d4": { "balance": "4000000000000000000000" }, "dd2a233adede66fe1126d6c16823b62a021feddb": { "balance": "2000000000000000000000" }, "d8cd64e0284eec53aa4639afc4750810b97fab56": { "balance": "20000000000000000000" }, "e5953fea497104ef9ad2d4e5841c271f073519c2": { "balance": "704000000000000000000" }, "967d4142af770515dd7062af93498dbfdff29f20": { "balance": "20200000000000000000" }, "fd191a35157d781373fb411bf9f25290047c5eef": { "balance": "1000000000000000000000" }, "8967d7b9bdb7b4aed22e65a15dc803cb7a213f10": { "balance": "400000000000000000000" }, "51e43fe0d25c782860af81ea89dd793c13f0cbb1": { "balance": "60000000000000000000" }, "a38476691d34942eea6b2f76889223047db4617a": { "balance": "2000000000000000000000" }, "1321ccf29739b974e5a516f18f3a843671e39642": { "balance": "4000000000000000000000" }, "4d71a6eb3d7f327e1834278e280b039eddd31c2f": { "balance": "6000000000000000000000" }, "dc2d15a69f6bb33b246aef40450751c2f6756ad2": { "balance": "1996000000000000000000" }, "ec89f2b678a1a15b9134ec5eb70c6a62071fbaf9": { "balance": "200000000000000000000" }, "27bf943c1633fe32f8bcccdb6302b407a5724e44": { "balance": "940229000000000000000" }, "d0a6c6f9e9c4b383d716b31de78d56414de8fa91": { "balance": "300000000000000000000" }, "7b6175ec9befc738249535ddde34688cd36edf25": { "balance": "10000000000000000000000" }, "41ce79950935cff55bf78e4ccec2fe631785db95": { "balance": "2000000000000000000000" }, "5598b3a79a48f32b1f5fc915b87b645d805d1afe": { "balance": "500000000000000000000" }, "5c4881165cb42bb82e97396c8ef44adbf173fb99": { "balance": "110600000000000000000" }, "25b0533b81d02a617b9229c7ec5d6f2f672e5b5a": { "balance": "1000000000000000000000" }, "015f097d9acddcddafaf2a107eb93a40fc94b04c": { "balance": "20000000000000000000000" }, "b84b53d0bb125656cddc52eb852ab71d7259f3d5": { "balance": "16000000000000000000000" }, "1a79c7f4039c67a39d7513884cdc0e2c34222490": { "balance": "20000000000000000000" }, "926209b7fda54e8ddb9d9e4d3d19ebdc8e88c29f": { "balance": "2000000000000000000000" }, "c2fe7d75731f636dcd09dbda0671393ba0c82a7d": { "balance": "2200000000000000000000" }, "30248d58e414b20fed3a6c482b59d9d8f5a4b7e2": { "balance": "60000000000000000000" }, "d0e194f34b1db609288509ccd2e73b6131a2538b": { "balance": "999972000000000000000" }, "e8f29969e75c65e01ce3d86154207d0a9e7c76f2": { "balance": "2991807000000000000000" }, "cb93199b9c90bc4915bd859e3d42866dc8c18749": { "balance": "231800000000000000000" }, "e6fe0afb9dcedd37b2e22c451ba6feab67348033": { "balance": "10000000000000000000000" }, "82f854c9c2f087dffa985ac8201e626ca5467686": { "balance": "100000000000000000000000" }, "63bb664f9117037628594da7e3c5089fd618b5b5": { "balance": "20000000000000000000" }, "f8d17424c767bea31205739a2b57a7277214eebe": { "balance": "42000000000000000000" }, "4ca8db4a5efefc80f4cd9bbcccb03265931332b6": { "balance": "200000000000000000000" }, "c56e6b62ba6e40e52aab167d21df025d0055754b": { "balance": "2000000000000000000000" }, "0d8c40a79e18994ff99ec251ee10d088c3912e80": { "balance": "114600000000000000000" }, "40a331195b977325c2aa28fa2f42cb25ec3c253c": { "balance": "2000000000000000000000" }, "a2c5854ff1599f98892c5725d262be1da98aadac": { "balance": "314315000000000000000" }, "23ab09e73f87aa0f3be0139df0c8eb6be5634f95": { "balance": "8000000000000000000000" }, "b8040536958d5998ce4bec0cfc9c2204989848e9": { "balance": "24472420000000000000000" }, "42d6b263d9e9f4116c411424fc9955783c763030": { "balance": "2000000000000000000000" }, "c496cbb0459a6a01600fc589a55a32b454217f9d": { "balance": "274000000000000000000" }, "48302c311ef8e5dc664158dd583c81194d6e0d58": { "balance": "3364760000000000000000" }, "d5b284040130abf7c1d163712371cc7e28ad66da": { "balance": "1970000000000000000000" }, "d22f0ca4cd479e661775053bcc49e390f670dd8a": { "balance": "1000000000000000000000" }, "e597f083a469c4591c3d2b1d2c772787befe27b2": { "balance": "280000000000000000000" }, "668b6ba8ab08eace39c502ef672bd5ccb6a67a20": { "balance": "31135320000000000000000" }, "a3bff1dfa9971668360c0d82828432e27bf54e67": { "balance": "200000000000000000000" }, "ee655bb4ee0e8d5478526fb9f15e4064e09ff3dd": { "balance": "200000000000000000000" }, "121f855b70149ac83473b9706fb44d47828b983b": { "balance": "1400000000000000000000" }, "20a15256d50ce058bf0eac43aa533aa16ec9b380": { "balance": "20000000000000000000" }, "69bcfc1d43b4ba19de7b274bdffb35139412d3d7": { "balance": "985000000000000000000" }, "db288f80ffe232c2ba47cc94c763cf6fc9b82b0d": { "balance": "85000000000000000000" }, "e1cb83ec5eb6f1eeb85e99b2fc63812fde957184": { "balance": "20000000000000000000000" }, "a419a984142363267575566089340eea0ea20819": { "balance": "1999944000000000000000" }, "8489f6ad1d9a94a297789156899db64154f1dbb5": { "balance": "358849000000000000000" }, "d609bf4f146eea6b0dc8e06ddcf4448a1fccc9fa": { "balance": "2000000000000000000000" }, "df1fa2e20e31985ebe2c0f0c93b54c0fb67a264b": { "balance": "200000000000000000000" }, "efe8ff87fc260e0767638dd5d02fc4672e0ec06d": { "balance": "2000000000000000000000" }, "eef1bbb1e5a83fde8248f88ee3018afa2d1332eb": { "balance": "200000000000000000000" }, "4b3aab335ebbfaa870cc4d605e7d2e74c668369f": { "balance": "60000000000000000000000" }, "8f4fb1aea7cd0f570ea5e61b40a4f4510b6264e4": { "balance": "4000000000000000000000" }, "0b0b3862112aeec3a03492b1b05f440eca54256e": { "balance": "4000000000000000000000" }, "dff4007931786593b229efe5959f3a4e219e51af": { "balance": "4925000000000000000000" }, "fec14e5485de2b3eef5e74c46146db8e454e0335": { "balance": "179000000000000000000" }, "ac21c1e5a3d7e0b50681679dd6c792dbca87decb": { "balance": "100000000000000000000000" }, "796ebbf49b3e36d67694ad79f8ff36767ac6fab0": { "balance": "60800000000000000000" }, "ae7739124ed153052503fc101410d1ffd8cd13b7": { "balance": "999942000000000000000" }, "86026cad3fe4ea1ce7fca260d3d45eb09ea6a364": { "balance": "200000000000000000000" }, "b2fc84a3e50a50af02f94da0383ed59f71ff01d7": { "balance": "30000000000000000000000" }, "bbab000b0408ed015a37c04747bc461ab14e151b": { "balance": "6000000000000000000000" }, "c4ff6fbb1f09bd9e102ba033d636ac1c4c0f5304": { "balance": "1000000000000000000000" }, "cc606f511397a38fc7872bd3b0bd03c71bbd768b": { "balance": "1000000000000000000000" }, "f346d7de92741c08fc58a64db55b062dde012d14": { "balance": "295106000000000000000" }, "33f15223310d44de8b6636685f3a4c3d9c5655a5": { "balance": "250500000000000000000" }, "3c860e2e663f46db53427b29fe3ea5e5bf62bbcc": { "balance": "98500000000000000000" }, "acb94338554bc488cc88ae2d9d94080d6bdf8410": { "balance": "1000000000000000000000" }, "9c5cc111092c122116f1a85f4ee31408741a7d2f": { "balance": "492500000000000000000" }, "5f76f0a306269c78306b3d650dc3e9c37084db61": { "balance": "2400000000000000000000" }, "2c0cc3f951482cc8a2925815684eb9f94e060200": { "balance": "6000000000000000000000" }, "b74372dbfa181dc9242f39bf1d3731dffe2bdacf": { "balance": "2000000000000000000000" }, "3bab4b01a7c84ba13feea9b0bb191b77a3aadca3": { "balance": "200000000000000000000" }, "39aa05e56d7d32385421cf9336e90d3d15a9f859": { "balance": "26000000000000000000" }, "4a52bad20357228faa1e996bed790c93674ba7d0": { "balance": "1337000000000000000000" }, "ff128f4b355be1dc4a6f94fa510d7f15d53c2aff": { "balance": "2720000000000000000000" }, "92793ac5b37268774a7130de2bbd330405661773": { "balance": "40110000000000000000" }, "db19a3982230368f0177219cb10cb259cdb2257c": { "balance": "2000000000000000000000" }, "8d1794da509cb297053661a14aa892333231e3c1": { "balance": "199600000000000000000" }, "9b7c8810cc7cc89e804e6d3e38121850472877fe": { "balance": "2000000000000000000000" }, "ed3cbc3782cebd67989b305c4133b2cde32211eb": { "balance": "400000000000000000000" }, "8532490897bbb4ce8b7f6b837e4cba848fbe9976": { "balance": "100000000000000000000" }, "c384ac6ee27c39e2f278c220bdfa5baed626d9d3": { "balance": "600000000000000000000" }, "b1459285863ea2db3759e546ceb3fb3761f5909c": { "balance": "1122309000000000000000" }, "634efc24371107b4cbf03f79a93dfd93e431d5fd": { "balance": "1221341000000000000000" }, "ef9f59aeda418c1494682d941aab4924b5f4929a": { "balance": "100000000000000000000000" }, "e7311c9533f0092c7248c9739b5b2c864a34b1ce": { "balance": "2803436000000000000000" }, "e6e621eaab01f20ef0836b7cad47464cb5fd3c96": { "balance": "316014000000000000000" }, "cd102cd6db3df14ad6af0f87c72479861bfc3d24": { "balance": "2000000000000000000000" }, "005a9c03f69d17d66cbb8ad721008a9ebbb836fb": { "balance": "2000000000000000000000" }, "a072cebe62a9e9f61cc3fbf88a9efbfe3e9a8d70": { "balance": "400000000000000000000" }, "f2ab1161750244d0ecd048ee0d3e51abb143a2fd": { "balance": "1235800000000000000000" }, "f686785b89720b61145fea80978d6acc8e0bc196": { "balance": "4000000000000000000000" }, "0a2b4fc5d81ace67dc4bba03f7b455413d46fe3d": { "balance": "197000000000000000000" }, "c32ec7e42ad16ce3e2555ad4c54306eda0b26758": { "balance": "2000000000000000000000" }, "f3fa723552a5d0512e2b62f48dca7b2b8105305b": { "balance": "137000000000000000000" }, "6dc3f92baa1d21dab7382b893261a0356fa7c187": { "balance": "1730000000000000000000" }, "4627c606842671abde8295ee5dd94c7f549534f4": { "balance": "286600000000000000000" }, "e39e46e15d22ce56e0c32f1877b7d1a264cf94f3": { "balance": "20000000000000000000000" }, "d7d157e4c0a96437a6d285741dd23ec4361fa36b": { "balance": "2000000000000000000000" }, "68f8f45155e98c5029a4ebc5b527a92e9fa83120": { "balance": "4436101000000000000000" }, "9aba2b5e27ff78baaab5cdc988b7be855cebbdce": { "balance": "9999000000000000000000" }, "66b39837cb3cac8a802afe3f12a258bbca62dacd": { "balance": "400000000000000000000" }, "d39b7cbc94003fc948f0cde27b100db8ccd6e063": { "balance": "400000000000000000000" }, "3db9ed7f024c7e26372feacf2b050803445e3810": { "balance": "1285600000000000000000" }, "3fbc1e4518d73400c6d046359439fb68ea1a49f4": { "balance": "16400000000000000000000" }, "e3da4f3240844c9b6323b4996921207122454399": { "balance": "11539639000000000000000" }, "09afa73bc047ef46b977fd9763f87286a6be68c6": { "balance": "501500000000000000000" }, "1dbe8e1c2b8a009f85f1ad3ce80d2e05350ee39c": { "balance": "135400000000000000000" }, "2c5a2d0abda03bbe215781b4ff296c8c61bdbaf6": { "balance": "30617000000000000000" }, "9a9d1dc0baa77d6e20c3d849c78862dd1c054c87": { "balance": "880000000000000000000" }, "3ccef88679573947e94997798a1e327e08603a65": { "balance": "807700000000000000000" }, "850b9db18ff84bf0c7da49ea3781d92090ad7e64": { "balance": "2600000000000000000000" }, "361c75931696bc3d427d93e76c77fd13b241f6f4": { "balance": "549212000000000000000" }, "c8f2b320e6dfd70906c597bad2f9501312c78259": { "balance": "1504800000000000000000" }, "8dc1d5111d09af25fdfcac455c7cec283e6d6775": { "balance": "2000000000000000000000" }, "cd7ece086b4b619b3b369352ee38b71ddb06439a": { "balance": "200000000000000000000" }, "f607c2150d3e1b99f24fa1c7d540add35c4ebe1e": { "balance": "3098020000000000000000" }, "32485c818728c197fea487fbb6e829159eba8370": { "balance": "1053893000000000000000" }, "8e670815fb67aeaea57b86534edc00cdf564fee5": { "balance": "3300000000000000000000" }, "10df681506e34930ac7a5c67a54c3e89ce92b981": { "balance": "2153800000000000000000" }, "1cf2eb7a8ccac2adeaef0ee87347d535d3b94058": { "balance": "2000000000000000000000" }, "f0dc43f205619127507b2b1c1cfdf32d28310920": { "balance": "301973000000000000000" }, "f2c2904e9fa664a11ee25656d8fd2cc0d9a522a0": { "balance": "13370000000000000000" }, "70670fbb05d33014444b8d1e8e7700258b8caa6d": { "balance": "2000000000000000000000" }, "5160ed612e1b48e73f3fc15bc4321b8f23b8a24b": { "balance": "562800000000000000000" }, "54a62bf9233e146ffec3876e45f20ee8414adeba": { "balance": "10000000000000000000000" }, "26d4ec17d5ceb2c894bdc59d0a6a695dad2b43cc": { "balance": "2935300000000000000000" }, "205fc843e19a4913d1881eb69b69c0fa3be5c50b": { "balance": "9700000000000000000000" }, "e001aba77c02e172086c1950fffbcaa30b83488f": { "balance": "1970000000000000000000" }, "21efbca09b3580b98e73f5b2f7f4dc0bf02c529c": { "balance": "2000000000000000000000" }, "c4d916574e68c49f7ef9d3d82d1638b2b7ee0985": { "balance": "1580000000000000000000" }, "cab0d32cf3767fa6b3537c84328baa9f50458136": { "balance": "8960000000000000000000" }, "7ce4686446f1949ebed67215eb0d5a1dd72c11b8": { "balance": "2217776000000000000000" }, "7837fcb876da00d1eb3b88feb3df3fa4042fac82": { "balance": "1760000000000000000000" }, "71e38ff545f30fe14ca863d4f5297fd48c73a5ce": { "balance": "3580000000000000000000" }, "e528a0e5a267d667e9393a6584e19b34dc9be973": { "balance": "5600000000000000000000" }, "c5374928cdf193705443b14cc20da423473cd9cf": { "balance": "138139000000000000000" }, "e406f5dd72cab66d8a6ecbd6bfb494a7b6b09afe": { "balance": "100000000000000000000" }, "d7ef340e66b0d7afcce20a19cb7bfc81da33d94e": { "balance": "3000000000000000000000" }, "e012db453827a58e16c1365608d36ed658720507": { "balance": "2000000000000000000000" }, "d59638d3c5faa7711bf085745f9d5bdc23d498d8": { "balance": "2000000000000000000000" }, "008fc7cbadffbd0d7fe44f8dfd60a79d721a1c9c": { "balance": "1000000000000000000000" }, "8a3470282d5e2a2aefd7a75094c822c4f5aeef8a": { "balance": "242743000000000000000" }, "38b3965c21fa893931079beacfffaf153678b6eb": { "balance": "170374000000000000000" }, "57dd9471cbfa262709f5f486bcb774c5f527b8f8": { "balance": "197000000000000000000" }, "5a60c924162873fc7ea4da7f972e350167376031": { "balance": "83583000000000000000" }, "b9013c51bd078a098fae05bf2ace0849c6be17a5": { "balance": "80000000000000000000" }, "dc23b260fcc26e7d10f4bd044af794579460d9da": { "balance": "500038000000000000000" }, "45db03bccfd6a5f4d0266b82a22a368792c77d83": { "balance": "8000000000000000000000" }, "3e0cbe6a6dcb61f110c45ba2aa361d7fcad3da73": { "balance": "8022000000000000000000" }, "42d3a5a901f2f6bd9356f112a70180e5a1550b60": { "balance": "925000000000000000000" }, "47219229e8cd56659a65c2a943e2dd9a8f4bfd89": { "balance": "1520000000000000000000" }, "a20d071b1b003063497d7990e1249dabf36c35f7": { "balance": "1000000000000000000000" }, "6835c8e8b74a2ca2ae3f4a8d0f6b954a3e2a8392": { "balance": "60140000000000000000" }, "0c2d5c920538e953caaf24f0737f554cc6927742": { "balance": "1000000000000000000000" }, "eedf6c4280e6eb05b934ace428e11d4231b5905b": { "balance": "200000000000000000000" }, "ffa696ecbd787e66abae4fe87b635f07ca57d848": { "balance": "1337000000000000000000" }, "3e81772175237eb4cbe0fe2dcafdadffeb6a1999": { "balance": "8800000000000000000000" }, "b44783c8e57b480793cbd69a45d90c7b4f0c48ac": { "balance": "20000000000000000000" }, "f84f090adf3f8db7e194b350fbb77500699f66fd": { "balance": "1970000000000000000000" }, "2e9824b5c132111bca24ddfba7e575a5cd7296c1": { "balance": "17201900000000000000000" }, "5cce72d068c7c3f55b1d2819545e77317cae8240": { "balance": "1940000000000000000000" }, "d815e1d9f4e2b5e57e34826b7cfd8881b8546890": { "balance": "17300000000000000000" }, "f901c00fc1db88b69c4bc3252b5ca70ea6ee5cf6": { "balance": "400000000000000000000" }, "a960b1cadd3b5c1a8e6cb3abcaf52ee7c3d9fa88": { "balance": "1522704000000000000000" }, "f7e45a12aa711c709acefe95f33b78612d2ad22a": { "balance": "66230000000000000000000" }, "c332df50b13c013490a5d7c75dbfa366da87b6d6": { "balance": "4000000000000000000000" }, "d467cf064c0871989b90d8b2eb14ccc63b360823": { "balance": "200000000000000000000" }, "b9144b677c2dc614ceefdf50985f1183208ea64c": { "balance": "2000000000000000000000" }, "ea7c4d6dc729cd6b157c03ad237ca19a209346c3": { "balance": "2000000000000000000000" }, "9c9de44724a4054da0eaa605abcc802668778bea": { "balance": "200020000000000000000" }, "d7140c8e5a4307fab0cc27badd9295018bf87970": { "balance": "109600000000000000000" }, "c33acdb3ba1aab27507b86b15d67faf91ecf6293": { "balance": "2000000000000000000000" }, "db2a0c9ab64df58ddfb1dbacf8ba0d89c85b31b4": { "balance": "4000000000000000000000" }, "bfcb9730246304700da90b4153e71141622e1c41": { "balance": "1000000000000000000000" }, "07dc8c8b927adbedfa8f5d639b4352351f2f36d2": { "balance": "314382000000000000000" }, "2d5391e938b34858cf965b840531d5efda410b09": { "balance": "1400000000000000000000" }, "0b5e2011ebc25a007f21362960498afb8af280fb": { "balance": "2000000000000000000000" }, "ed9fb1f5af2fbf7ffc5029cee42b70ff5c275bf5": { "balance": "280000000000000000000" }, "a3232d068d50064903c9ebc563b515acc8b7b097": { "balance": "2002000000000000000000" }, "66274fea82cd30b6c29b23350e4f4f3d310a5899": { "balance": "2070000000000000000000" }, "dbfb1bb464b8a58e500d2ed8de972c45f5f1c0fb": { "balance": "1600000000000000000000" }, "a1f8d8bcf90e777f19b3a649759ad95027abdfc3": { "balance": "200000000000000000000" }, "5bd23547477f6d09d7b2a005c5ee650c510c56d7": { "balance": "10000000000000000000000" }, "ec3b8b58a12703e581ce5ffd7e21c57d1e5c663f": { "balance": "1700000000000000000000" }, "54310b3aa88703a725dfa57de6e646935164802c": { "balance": "1910000000000000000000" }, "8f41b1fbf54298f5d0bc2d122f4eb95da4e5cd3d": { "balance": "354200000000000000000" }, "c80b36d1beafba5fcc644d60ac6e46ed2927e7dc": { "balance": "13370000000000000000" }, "1ea492bce1ad107e337f4bd4a7ac9a7babcccdab": { "balance": "100000000000000000000" }, "aaf023fef290a49bb78bb7abc95d669c50d528b0": { "balance": "200000000000000000000" }, "80b79f338390d1ba1b3737a29a0257e5d91e0731": { "balance": "20000000000000000000" }, "f382e4c20410b951089e19ba96a2fee3d91cce7e": { "balance": "5054000000000000000000" }, "0748713145ef83c3f0ef4d31d823786f7e9cc689": { "balance": "4500000000000000000000" }, "21e219c89ca8ac14ae4cba6130eeb77d9e6d3962": { "balance": "789580000000000000000" }, "ca9a042a6a806ffc92179500d24429e8ab528117": { "balance": "1100000000000000000000" }, "bcc9593b2da6df6a34d71b1aa38dacf876f95b88": { "balance": "20000000000000000000" }, "d1438267231704fc7280d563adf4763844a80722": { "balance": "200000000000000000000" }, "4989e1ab5e7cd00746b3938ef0f0d064a2025ba5": { "balance": "2000000000000000000000" }, "bd4b60faec740a21e3071391f96aa534f7c1f44e": { "balance": "182000000000000000000" }, "8c7cb4e48b25031aa1c4f92925d631a8c3edc761": { "balance": "1000000000000000000000" }, "322788b5e29bf4f5f55ae1ddb32085fda91b8ebe": { "balance": "200000000000000000000" }, "f15e182c4fbbad79bd93342242d4dccf2be58925": { "balance": "1940000000000000000000" }, "1548b770a5118ede87dba2f690337f616de683ab": { "balance": "527558000000000000000" }, "69c2d835f13ee90580408e6a3283c8cca6a434a2": { "balance": "656000000000000000000" }, "a1e4380a3b1f749673e270229993ee55f35663b4": { "balance": "2000000000000000000000" }, "c7675e5647b9d8daf4d3dff1e552f6b07154ac38": { "balance": "180000000000000000000" }, "a02c1e34064f0475f7fa831ccb25014c3aa31ca2": { "balance": "60000000000000000000" }, "517c75430de401c341032686112790f46d4d369e": { "balance": "388000000000000000000" }, "29681d9912ddd07eaabb88d05d90f766e862417d": { "balance": "1000000000000000000000" }, "544dda421dc1eb73bb24e3e56a248013b87c0f44": { "balance": "1970000000000000000000" }, "2ab97e8d59eee648ab6caf8696f89937143864d6": { "balance": "3820000000000000000000" }, "79c130c762b8765b19d2abc9a083ab8f3aad7940": { "balance": "3940000000000000000000" }, "f9650d6989f199ab1cc479636ded30f241021f65": { "balance": "850000000000000000000" }, "d1c96e70f05ae0e6cd6021b2083750a7717cde56": { "balance": "500000000000000000000" }, "88106c27d20b74b4b98ca62b232bd5c97411171f": { "balance": "197000000000000000000" }, "37ab66083a4fa23848b886f9e66d79cdc150cc70": { "balance": "88510000000000000000000" }, "8e6156336be2cdbe32140df08a2ba55fd0a58463": { "balance": "74480000000000000000" }, "2982d76a15f847dd41f1922af368fe678d0e681e": { "balance": "100000000000000000000" }, "209e8e29d33beae8fb6baa783d133e1d9ec1bc0b": { "balance": "835000000000000000000" }, "b325674c01e3f7290d5226339fbeac67d221279f": { "balance": "2800000000000000000000" }, "f20c9a99b74759d782f25c1ceca802a27e0b436c": { "balance": "1670000000000000000000" }, "61bf84d5ab026f58c873f86ff0dfca82b55733ae": { "balance": "2000000000000000000000" }, "0734a0a81c9562f4d9e9e10a8503da15db46d76e": { "balance": "18200000000000000000" }, "0521bc3a9f8711fecb10f50797d71083e341eb9d": { "balance": "20000000000000000000" }, "3301d9ca2f3bfe026279cd6819f79a293d98156e": { "balance": "50000000000000000000000" }, "549d51af29f724c967f59423b85b2681e7b15136": { "balance": "3760000000000000000000" }, "2053ac97548a0c4e8b80bc72590cd6a098fe7516": { "balance": "187000000000000000000" }, "aa321fdbd449180db8ddd34f0fe906ec18ee0914": { "balance": "685000000000000000000" }, "697f55536bf85ada51841f0287623a9f0ed09a17": { "balance": "10000000000000000000000" }, "df57353aaff2aadb0a04f9014e8da7884e86589c": { "balance": "152800000000000000000" }, "6807ddc88db489b033e6b2f9a81553571ab3c805": { "balance": "29944000000000000000" }, "90057af9aa66307ec9f033b29724d3b2f41eb6f9": { "balance": "121930000000000000000000" }, "3ff836b6f57b901b440c30e4dbd065cf37d3d48c": { "balance": "200000000000000000000" }, "91051764af6b808e4212c77e30a5572eaa317070": { "balance": "1000000000000000000000" }, "7faa30c31519b584e97250ed2a3cf3385ed5fd50": { "balance": "2000000000000000000000" }, "fb842ca2c5ef133917a236a0d4ac40690110b038": { "balance": "306000000000000000000" }, "aa167026d39ab7a85635944ed9edb2bfeba11850": { "balance": "8298000000000000000000" }, "57beea716cbd81700a73d67f9ff039529c2d9025": { "balance": "200000000000000000000" }, "654b7e808799a83d7287c67706f2abf49a496404": { "balance": "1970000000000000000000" }, "dde8f0c31b7415511dced1cd7d46323e4bd12232": { "balance": "1610000000000000000000" }, "8667fa1155fed732cfb8dca5a0d765ce0d0705ed": { "balance": "81770000000000000000" }, "905526568ac123afc0e84aa715124febe83dc87c": { "balance": "17900000000000000000" }, "8e98766524b0cf2747c50dd43b9567594d9731de": { "balance": "1997200000000000000000" }, "c6df2075ebd240d44869c2be6bdf82e63d4ef1f5": { "balance": "20000000000000000000" }, "2ff5cab12c0d957fd333f382eeb75107a64cb8e8": { "balance": "10000000000000000000000" }, "3055efd26029e0d11b930df4f53b162c8c3fd2ce": { "balance": "499938000000000000000" }, "b2c53efa33fe4a3a1a80205c73ec3b1dbcad0602": { "balance": "1918595000000000000000" }, "766b3759e8794e926dac473d913a8fb61ad0c2c9": { "balance": "86500000000000000000" }, "882aa798bf41df179f85520130f15ccdf59b5e58": { "balance": "2000000000000000000000" }, "80b23d380b825c46e0393899a85556462da0e18c": { "balance": "2000000000000000000000" }, "51f4663ab44ff79345f427a0f6f8a6c8a53ff234": { "balance": "20000000000000000000000" }, "8d5ef172bf77315ea64e85d0061986c794c6f519": { "balance": "3940000000000000000000" }, "75ac547017134c04ae1e11d60e63ec04d18db4ef": { "balance": "6000000000000000000000" }, "ce1b0cb46aaecfd79b880cad0f2dda8a8dedd0b1": { "balance": "20000000000000000000" }, "21408b4d7a2c0e6eca4143f2cacdbbccba121bd8": { "balance": "20000000000000000000000" }, "9c526a140683edf1431cfaa128a935e2b614d88b": { "balance": "111000000000000000000" }, "599728a78618d1a17b9e34e0fed8e857d5c40622": { "balance": "14000000000000000000000" }, "6ac4d4be2db0d99da3faaaf7525af282051d6a90": { "balance": "80185000000000000000" }, "785c8ea774d73044a734fa790a1b1e743e77ed7c": { "balance": "238750000000000000000" }, "ff2726294148b86c78a9372497e459898ed3fee3": { "balance": "1970000000000000000000" }, "68a86c402388fddc59028fec7021e98cbf830eac": { "balance": "19100000000000000000" }, "6121af398a5b2da69f65c6381aec88ce9cc6441f": { "balance": "640000000000000000000" }, "5a6686b0f17e07edfc59b759c77d5bef164d3879": { "balance": "1490000000000000000000" }, "a2d38de1c73906f6a7ca6efeb97cf6f69cc421be": { "balance": "1000000000000000000000" }, "ae3f98a443efe00f3e711d525d9894dc9a61157b": { "balance": "295500000000000000000" }, "5f1c8a04c90d735b8a152909aeae636fb0ce1665": { "balance": "6999974000000000000000" }, "d687cec0059087fdc713d4d2d65e77daefedc15f": { "balance": "60000000000000000000" }, "845203750f7148a9aa262921e86d43bf641974fd": { "balance": "100000000000000000000" }, "64464a6805b462412a901d2db8174b06c22deea6": { "balance": "475600000000000000000" }, "053471cd9a41925b3904a5a8ffca3659e034be23": { "balance": "199600000000000000000" }, "911ff233e1a211c0172c92b46cf997030582c83a": { "balance": "1970000000000000000000" }, "d930b27a78876485d0f48b70dd5336549679ca8f": { "balance": "40000000000000000000" }, "6ba9b21b35106be159d1c1c2657ac56cd29ffd44": { "balance": "4480000000000000000000" }, "ebac2b4408ef5431a13b8508e86250982114e145": { "balance": "4000000000000000000000" }, "931df34d1225bcd4224e63680d5c4c09bce735a6": { "balance": "68000000000000000000" }, "23eb6fd85671a9063ab7678ebe265a20f61a02b3": { "balance": "2000000000000000000000" }, "b32af3d3e8d075344926546f2e32887bf93b16bd": { "balance": "200000000000000000000" }, "8261fa230c901d43ff579f4780d399f31e6076bc": { "balance": "2000000000000000000000" }, "84a74ceecff65cb93b2f949d773ef1ad7fb4a245": { "balance": "92998000000000000000" }, "da982e9643ffece723075a40fe776e5ace04b29b": { "balance": "160884000000000000000" }, "ba70e8b4759c0c3c82cc00ac4e9a94dd5bafb2b8": { "balance": "890342000000000000000" }, "82f2e991fd324c5f5d17768e9f61335db6319d6c": { "balance": "500000000000000000000" }, "3e84b35c5b2265507061d30b6f12da033fe6f8b9": { "balance": "1790000000000000000000" }, "2895e80999d406ad592e2b262737d35f7db4b699": { "balance": "1940000000000000000000" }, "65f534346d2ffb787fa9cf185d745ba42986bd6e": { "balance": "500000000000000000000" }, "c7368b9709a5c1b51c0adf187a65df14e12b7dba": { "balance": "9489681000000000000000" }, "ba176dbe3249e345cd4fa967c0ed13b24c47e586": { "balance": "399990000000000000000" }, "cff6a6fe3e9a922a12f21faa038156918c4fcb9c": { "balance": "78800000000000000000" }, "bcbd31252ec288f91e298cd812c92160e738331a": { "balance": "1975802000000000000000" }, "5543dd6d169eec8a213bbf7a8af9ffd15d4ff759": { "balance": "18200000000000000000" }, "b65bd780c7434115162027565223f44e5498ff8c": { "balance": "19999800000000000000000" }, "4cadf573ce4ceec78b8e1b21b0ed78eb113b2c0e": { "balance": "2000000000000000000000" }, "04aafc8ae5ce6f4903c89d7fac9cb19512224777": { "balance": "500000000000000000000" }, "fdc4d4765a942f5bf96931a9e8cc7ab8b757ff4c": { "balance": "87000000000000000000000" }, "38c7851f5ffd4cee98df30f3b25597af8a6ca263": { "balance": "2631920000000000000000" }, "0e320219838e859b2f9f18b72e3d4073ca50b37d": { "balance": "2000000000000000000000" }, "bbbf39b1b67995a42241504f9703d2a14a515696": { "balance": "1580000000000000000000" }, "5b800bfd1b3ed4a57d875aed26d42f1a7708d72a": { "balance": "6392000000000000000000" }, "5b85e60e2af0544f2f01c64e2032900ebd38a3c7": { "balance": "2000000000000000000000" }, "c9ac01c3fb0929033f0ccc7e1acfeaaba7945d47": { "balance": "12459235000000000000000" }, "f355d3ec0cfb907d8dbb1bf3464e458128190bac": { "balance": "4925600000000000000000" }, "69c08d744754de709ce96e15ae0d1d395b3a2263": { "balance": "1000000000000000000000" }, "cef77451dfa2c643e00b156d6c6ff84e2373eb66": { "balance": "188000000000000000000" }, "f3034367f87d24d3077fa9a2e38a8b0ccb1104ef": { "balance": "1000000000000000000000" }, "73473e72115110d0c3f11708f86e77be2bb0983c": { "balance": "20000000000000000000" }, "761e6caec189c230a162ec006530193e67cf9d19": { "balance": "2000000000000000000000" }, "e9caf827be9d607915b365c83f0d3b7ea8c79b50": { "balance": "3000000000000000000000" }, "eda4b2fa59d684b27a810df8978a73df308a63c2": { "balance": "4000000000000000000000" }, "065ff575fd9c16d3cb6fd68ffc8f483fc32ec835": { "balance": "200000000000000000000" }, "a72ee666c4b35e82a506808b443cebd5c632c7dd": { "balance": "800000000000000000000" }, "5b30608c678e1ac464a8994c3b33e5cdf3497112": { "balance": "400000000000000000000" }, "b0c7ce4c0dc3c2bbb99cc1857b8a455f611711ce": { "balance": "4000000000000000000000" }, "d7274d50804d9c77da93fa480156efe57ba501de": { "balance": "1940000000000000000000" }, "a609c26dd350c235e44b2b9c1dddccd0a9d9f837": { "balance": "1000000000000000000000" }, "bddfa34d0ebf1b04af53b99b82494a9e3d8aa100": { "balance": "12000000000000000000000" }, "fd40242bb34a70855ef0fd90f3802dec2136b327": { "balance": "1930600000000000000000" }, "58aed6674affd9f64233272a578dd9386b99c263": { "balance": "3400000000000000000000" }, "24434a3e32e54ecf272fe3470b5f6f512f675520": { "balance": "5910000000000000000000" }, "a379a5070c503d2fac89b8b3afa080fd45ed4bec": { "balance": "19700000000000000000000" }, "37e169a93808d8035698f815c7235613c1e659f2": { "balance": "1000000000000000000000" }, "849b116f596301c5d8bb62e0e97a8248126e39f3": { "balance": "300000000000000000000" }, "fe7011b698bf3371132d7445b19eb5b094356aee": { "balance": "2000000000000000000000" }, "f16de1891d8196461395f9b136265b3b9546f6ef": { "balance": "31313000000000000000" }, "6c6564e5c9c24eaaa744c9c7c968c9e2c9f1fbae": { "balance": "1357800000000000000000" }, "8bb0212f3295e029cab1d961b04133a1809e7b91": { "balance": "2000000000000000000000" }, "408a69a40715e1b313e1354e600800a1e6dc02a5": { "balance": "35144000000000000000" }, "ddf0cce1fe996d917635f00712f4052091dff9ea": { "balance": "2000000000000000000000" }, "50fef296955588caae74c62ec32a23a454e09ab8": { "balance": "1201200000000000000000" }, "d913f0771949753c4726acaa2bd3619c5c20ff77": { "balance": "3000000000000000000000" }, "9d6ecfa03af2c6e144b7c4692a86951e902e9e1f": { "balance": "3000310000000000000000" }, "ecbe5e1c9ad2b1dccf0a305fc9522f4669dd3ae7": { "balance": "5000000000000000000000" }, "33e9b71823952e1f66958c278fc28b1196a6c5a4": { "balance": "100000000000000000000" }, "9de20bc37e7f48a80ffd7ad84ffbf1a1abe1738c": { "balance": "200000000000000000000" }, "16f313cf8ad000914a0a176dc6a4342b79ec2538": { "balance": "2000000000000000000000" }, "991ac7ca7097115f26205eee0ef7d41eb4e311ae": { "balance": "20000000000000000000" }, "ddfafdbc7c90f1320e54b98f374617fbd01d109f": { "balance": "13370000000000000000" }, "26b11d066588ce74a572a85a6328739212aa8b40": { "balance": "2000000000000000000000" }, "ef2c34bb487d3762c3cca782ccdd7a8fbb0a9931": { "balance": "180000000000000000000" }, "a9be88ad1e518b0bbb024ab1d8f0e73f790e0c76": { "balance": "2800000000000000000000" }, "4a7494cce44855cc80582842be958a0d1c0072ee": { "balance": "2400000000000000000000" }, "23569542c97d566018c907acfcf391d14067e87e": { "balance": "2000000000000000000000" }, "d252960b0bf6b2848fdead80136db5f507f8be02": { "balance": "2000000000000000000000" }, "2c0f5b9df43625798e7e03c1a5fd6a6d091af82b": { "balance": "31200000000000000000" }, "a7c9d388ebd873e66b1713448397d0f37f8bd3a8": { "balance": "5000000000000000000000" }, "3259bd2fddfbbc6fbad3b6e874f0bbc02cda18b5": { "balance": "11886645000000000000000" }, "f287ff52f461117adb3e1daa71932d1493c65f2e": { "balance": "3640000000000000000000" }, "c852428d2b586497acd30c56aa13fb5582f84402": { "balance": "945600000000000000000" }, "296f00de1dc3bb01d47a8ccd1e5d1dd9a1eb7791": { "balance": "1000000000000000000000" }, "817493cd9bc623702a24a56f9f82e3fd48f3cd31": { "balance": "2920000000000000000000" }, "7adfedb06d91f3cc7390450b85550270883c7bb7": { "balance": "322312000000000000000" }, "8d544c32c07fd0842c761d53a897d6c950bb7599": { "balance": "200000000000000000000" }, "86297d730fe0f7a9ee24e08fb1087b31adb306a7": { "balance": "2000000000000000000000" }, "f64fe0939a8d1eea2a0ecd9a9730fd7958e33109": { "balance": "20600000000000000000" }, "b06eab09a610c6a53d56a946b2c43487ac1d5b2d": { "balance": "1000000000000000000000" }, "bae9b82f7299631408659dd74e891cb8f3860fe5": { "balance": "1970000000000000000000" }, "0eda80f4ed074aea697aeddf283b63dbca3dc4da": { "balance": "2000000000000000000000" }, "ea686c5057093c171c66db99e01b0ececb308683": { "balance": "384907000000000000000" }, "425725c0f08f0811f5f006eec91c5c5c126b12ae": { "balance": "150000000000000000000" }, "b18e67a5050a1dc9fb190919a33da838ef445014": { "balance": "20000000000000000000" }, "8dd484ff8a307364eb66c525a571aac701c5c318": { "balance": "4000000000000000000000" }, "6671b182c9f741a0cd3c356c73c23126d4f9e6f4": { "balance": "200000000000000000000" }, "ba0249e01d945bef93ee5ec61925e03c5ca509fd": { "balance": "4000000000000000000000" }, "b2968f7d35f208871631c6687b3f3daeabc6616c": { "balance": "156060000000000000000" }, "a6f62b8a3d7f11220701ab9ffffcb327959a2785": { "balance": "506000000000000000000" }, "c885a18aabf4541b7b7b7ecd30f6fae6869d9569": { "balance": "2000000000000000000000" }, "33fb577a4d214fe010d32cca7c3eeda63f87ceef": { "balance": "1000000000000000000000" }, "be86d0b0438419ceb1a038319237ba5206d72e46": { "balance": "999942000000000000000" }, "466292f0e80d43a78774277590a9eb45961214f4": { "balance": "970000000000000000000" }, "b33c0323fbf9c26c1d8ac44ef74391d0804696da": { "balance": "20000000000000000000" }, "f7bc4c44910d5aedd66ed2355538a6b193c361ec": { "balance": "96980000000000000000" }, "d0f04f52109aebec9a7b1e9332761e9fe2b97bb5": { "balance": "4000000000000000000000" }, "cb4a914d2bb029f32e5fef5c234c4fec2d2dd577": { "balance": "1800000000000000000000" }, "2e619f57abc1e987aa936ae3a2264962e7eb2d9a": { "balance": "756000000000000000000" }, "166bf6dab22d841b486c38e7ba6ab33a1487ed8c": { "balance": "20000000000000000000000" }, "c3a046e3d2b2bf681488826e32d9c061518cfe8c": { "balance": "2600000000000000000000" }, "d082275f745a2cac0276fbdb02d4b2a3ab1711fe": { "balance": "30000000000000000000" }, "a701df79f594901afe1444485e6b20c3bda2b9b3": { "balance": "1000000000000000000000" }, "dec3eec2640a752c466e2b7e7ee685afe9ac41f4": { "balance": "1324245000000000000000" }, "8134dd1c9df0d6c8a5812426bb55c761ca831f08": { "balance": "122360000000000000000" }, "bfc57aa666fae28e9f107a49cb5089a4e22151dd": { "balance": "1000000000000000000000" }, "c3c2297329a6fd99117e54fc6af379b4d556547e": { "balance": "6000000000000000000000" }, "40585200683a403901372912a89834aadcb55fdb": { "balance": "2000000000000000000000" }, "cd49bf185e70d04507999f92a4de4455312827d0": { "balance": "1000000000000000000000" }, "9c6bc9a46b03ae5404f043dfcf21883e4110cc33": { "balance": "200000000000000000000" }, "1f49b86d0d3945590698a6aaf1673c37755ca80d": { "balance": "700000000000000000000" }, "efeb1997aad277cc33430e6111ed0943594048b8": { "balance": "2000000000000000000000" }, "7c0883054c2d02bc7a852b1f86c42777d0d5c856": { "balance": "500000000000000000000" }, "ff49a775814ec00051a795a875de24592ea400d4": { "balance": "200000000000000000000000" }, "f039683d7b3d225bc7d8dfadef63163441be41e2": { "balance": "34380000000000000000" }, "a3ba0d3a3617b1e31b4e422ce269e873828d5d69": { "balance": "850000000000000000000" }, "d116f3dcd5db744bd008887687aa0ec9fd7292aa": { "balance": "1000000000000000000000" }, "5719f49b720da68856f4b9e708f25645bdbc4b41": { "balance": "640000000000000000000" }, "870796abc0db84af82da52a0ed68734de7e636f5": { "balance": "300000000000000000000" }, "68b6854788a7c6496cdbf5f84b9ec5ef392b78bb": { "balance": "19700000000000000000000" }, "8c2fbeee8eacc5c5d77c16abd462ee9c8145f34b": { "balance": "1940000000000000000000" }, "421684baa9c0b4b5f55338e6f6e7c8e146d41cb7": { "balance": "1500000000000000000000" }, "dd26b429fd43d84ec179825324bad5bfb916b360": { "balance": "5142000000000000000000" }, "3821862493242c0aeb84b90de05d250c1e50c074": { "balance": "322200000000000000000" }, "68a7425fe09eb28cf86eb1793e41b211e57bd68d": { "balance": "668500000000000000000" }, "da875e4e2f3cabe4f37e0eaed7d1f6dcc6ffef43": { "balance": "2000000000000000000000" }, "c2663f8145dbfec6c646fc5c49961345de1c9f11": { "balance": "690000000000000000000" }, "e89c22f1a4e1d4746ecfaa59ed386fee12d51e37": { "balance": "44932000000000000000" }, "eff86b5123bcdc17ed4ce8e05b7e12e51393a1f7": { "balance": "500000000000000000000" }, "6c3d18704126aa99ee3342ce60f5d4c85f1867cd": { "balance": "50000000000000000000" }, "b8d531a964bcea13829620c0ced72422dadb4cca": { "balance": "169990000000000000000" }, "7c29d47d57a733f56b9b217063b513dc3b315923": { "balance": "4000000000000000000000" }, "bc1e80c181616342ebb3fb3992072f1b28b802c6": { "balance": "4000000000000000000000" }, "31313ffd635bf2f3324841a88c07ed146144ceeb": { "balance": "1970000000000000000000" }, "cc4feb72df98ff35a138e01761d1203f9b7edf0a": { "balance": "7000000000000000000000" }, "741693c30376508513082020cc2b63e9fa92131b": { "balance": "1200000000000000000000" }, "aa3135cb54f102cbefe09e96103a1a796718ff54": { "balance": "57800000000000000000" }, "ef61155ba009dcdebef10b28d9da3d1bc6c9ced4": { "balance": "59100000000000000000" }, "b3c94811e7175b148b281c1a845bfc9bb6fbc115": { "balance": "200000000000000000000" }, "96d9cca8f55eea0040ec6eb348a1774b95d93ef4": { "balance": "4000000000000000000000" }, "ce62125adec3370ac52110953a4e760be9451e3b": { "balance": "152000000000000000000" }, "aca1e6bc64cc3180f620e94dc5b1bcfd8158e45d": { "balance": "2000000000000000000000" }, "bc237148d30c13836ffa2cad520ee4d2e5c4eeff": { "balance": "1970000000000000000000" }, "0e024e7f029c6aaf3a8b910f5e080873b85795aa": { "balance": "1000000000000000000000" }, "7283cd4675da58c496556151dafd80c7f995d318": { "balance": "760000000000000000000" }, "39b299327490d72f9a9edff11b83afd0e9d3c450": { "balance": "200000000000000000000" }, "5f333a3b2310765a0d1832b9be4c0a03704c1c09": { "balance": "1000000000000000000000" }, "5aaf1c31254a6e005fba7f5ab0ec79d7fc2b630e": { "balance": "5910000000000000000000" }, "833db42c14163c7be4cab86ac593e06266d699d5": { "balance": "174212000000000000000000" }, "f32d25eb0ea2b8b3028a4c7a155dc1aae865784d": { "balance": "5710684000000000000000" }, "1fa2319fed8c2d462adf2e17feec6a6f30516e95": { "balance": "125300000000000000000" }, "c49cfaa967f3afbf55031061fc4cef88f85da584": { "balance": "2000000000000000000000" }, "43db7ff95a086d28ebbfb82fb8fb5f230a5ebccd": { "balance": "16100000000000000000" }, "cf3f9128b07203a3e10d7d5755c0c4abc6e2cac2": { "balance": "5000000000000000000000" }, "8f4d1e7e4561284a34fef9673c0d34e12af4aa03": { "balance": "2000000000000000000000" }, "934af21b7ebfa467e2ced65aa34edd3a0ec71332": { "balance": "35420000000000000000000" }, "5d231a70c1dfeb360abd97f616e2d10d39f3cab5": { "balance": "400000000000000000000" }, "2d5d7335acb0362b47dfa3a8a4d3f5949544d380": { "balance": "200000000000000000000" }, "d1e1f2b9c16c309874dee7fac32675aff129c398": { "balance": "72800000000000000000" }, "a43b6da6cb7aac571dff27f09d39f846f53769b1": { "balance": "380000000000000000000" }, "779274bf1803a336e4d3b00ddd93f2d4f5f4a62e": { "balance": "1000000000000000000000" }, "a644ed922cc237a3e5c4979a995477f36e50bc62": { "balance": "583900000000000000000" }, "ee6c03429969ca1262cb3f0a4a54afa7d348d7f5": { "balance": "256100000000000000000" }, "4f06246b8d4bd29661f43e93762201d286935ab1": { "balance": "4818730000000000000000" }, "e04972a83ca4112bc871c72d4ae1616c2f0728db": { "balance": "267606000000000000000" }, "df098f5e4e3dffa51af237bda8652c4f73ed9ca6": { "balance": "502000000000000000000" }, "dfded2574b27d1613a7d98b715159b0d00baab28": { "balance": "20000000000000000000000" }, "17d931d4c56294dcbe77c8655be4695f006d4a3c": { "balance": "2000000000000000000000" }, "3ccb71aa6880cb0b84012d90e60740ec06acd78f": { "balance": "2000000000000000000000" }, "e57d2995b0ebdf3f3ca6c015eb04260dbb98b7c6": { "balance": "2000000000000000000000" }, "fb3860f4121c432ebdc8ec6a0331b1b709792e90": { "balance": "600400000000000000000" }, "fa00c376e89c05e887817a9dd0748d96f341aa89": { "balance": "300700000000000000000" }, "c7a018f0968a51d1f6603c5c49dc545bcb0ff293": { "balance": "4000000000000000000000" }, "7d73863038ccca22f96affda10496e51e1e6cd48": { "balance": "20000000000000000000" }, "38ea6f5b5a7b88417551b4123dc127dfe9342da6": { "balance": "400000000000000000000" }, "014b7f67b14f5d983d87014f570c8b993b9872b5": { "balance": "200000000000000000000" }, "8ac89bd9b8301e6b0677fa25fcf0f58f0cc7b611": { "balance": "20000000000000000000" }, "7eb4b0185c92b6439a08e7322168cb353c8a774a": { "balance": "10165988000000000000000" }, "d29dc08efbb3d72e263f78ab7610d0226de76b00": { "balance": "12000000000000000000000" }, "72a8260826294726a75bf39cd9aa9e07a3ea14cd": { "balance": "2000000000000000000000" }, "4cb5c6cd713ca447b848ae2f56b761ca14d7ad57": { "balance": "267400000000000000000" }, "49185dd7c23632f46c759473ebae966008cd3598": { "balance": "254030000000000000000" }, "13d67a7e25f2b12cdb85585009f8acc49b967301": { "balance": "1999944000000000000000" }, "9d913b5d339c95d87745562563fea98b23c60cc4": { "balance": "170718000000000000000" }, "abdc9f1bcf4d19ee96591030e772c334302f7d83": { "balance": "40110000000000000000000" }, "e9a5ae3c9e05977dd1069e9fd9d3aefbae04b8df": { "balance": "1970000000000000000000" }, "1fd296be03ad737c92f9c6869e8d80a71c5714aa": { "balance": "13370000000000000000" }, "2f13657526b177cad547c3908c840eff647b45d9": { "balance": "1170685000000000000000" }, "e69fcc26ed225f7b2e379834c524d70c1735e5bc": { "balance": "2000000000000000000000" }, "bade43599e02f84f4c3014571c976b13a36c65ab": { "balance": "4000000000000000000000" }, "184a4f0beb71ffd558a6b6e8f228b78796c4cf3e": { "balance": "12000000000000000000000" }, "d1de5aad3a5fd803f1b1aeb6103cb8e14fe723b7": { "balance": "20000000000000000000" }, "0bd67dbde07a856ebd893b5edc4f3a5be4202616": { "balance": "2000000000000000000000" }, "6b30f1823910b86d3acb5a6afc9defb6f3a30bf8": { "balance": "4200000000000000000000" }, "9a63d185a79129fdab19b58bb631ea36a420544e": { "balance": "42000000000000000000" }, "df660a91dab9f730f6190d50c8390561500756ca": { "balance": "2000000000000000000000" }, "a1a1f0fa6d20b50a794f02ef52085c9d036aa6ca": { "balance": "1000000000000000000000" }, "4ec768295eeabafc42958415e22be216cde77618": { "balance": "59600000000000000000" }, "c348fc5a461323b57be303cb89361b991913df28": { "balance": "100000000000000000000000" }, "3a7db224acae17de7798797d82cdf8253017dfa8": { "balance": "5000000000000000000000" }, "8bea40379347a5c891d59a6363315640f5a7e07a": { "balance": "1999992000000000000000" }, "2257fca16a6e5c2a647c3c29f36ce229ab93b17e": { "balance": "4000000000000000000000" }, "e492818aa684e5a676561b725d42f3cc56ae5198": { "balance": "800000000000000000000" }, "c841884fa4785fb773b28e9715fae99a5134305d": { "balance": "2000000000000000000000" }, "0d9443a79468a5bbf7c13c6e225d1de91aee07df": { "balance": "70000000000000000000" }, "6d4008b4a888a826f248ee6a0b0dfde9f93210b9": { "balance": "5460000000000000000000" }, "884980eb4565c1048317a8f47fdbb461965be481": { "balance": "3999922000000000000000" }, "985d70d207892bed398590024e2421b1cc119359": { "balance": "20000000000000000000000" }, "d9ec8fe69b7716c0865af888a11b2b12f720ed33": { "balance": "4000000000000000000000" }, "49b74e169265f01a89ec4c9072c5a4cd72e4e835": { "balance": "16100000000000000000000" }, "4c3e95cc3957d252ce0bf0c87d5b4f2234672e70": { "balance": "2500000000000000000000" }, "d9ff115d01266c9f73b063c1c238ef3565e63b36": { "balance": "680000000000000000000" }, "48c5c6970b9161bb1c7b7adfed9cdede8a1ba864": { "balance": "4000000000000000000000" }, "ea6afe2cc928ac8391eb1e165fc40040e37421e7": { "balance": "2997569000000000000000" }, "08ccda50e4b26a0ffc0ef92e9205310706bec2c7": { "balance": "6077440000000000000000" }, "e6e9a39d750fe994394eb68286e5ea62a6997882": { "balance": "600000000000000000000" }, "4b58101f44f7e389e12d471d1635b71614fdd605": { "balance": "160000000000000000000" }, "8d93dac785f88f1a84bf927d53652b45a154ccdd": { "balance": "158000000000000000000" }, "415d096ab06293183f3c033d25f6cf7178ac3bc7": { "balance": "40000000000000000000" }, "c3e387b03ce95ccfd7fa51dd840183bc43532809": { "balance": "2000000000000000000000" }, "da34b2eae30bafe8daeccde819a794cd89e09549": { "balance": "2000000000000000000000" }, "fa279bfd8767f956bf7fa0bd5660168da75686bd": { "balance": "2674000000000000000000" }, "b98ca31785ef06be49a1e47e864f60d076ca472e": { "balance": "4000000000000000000000" }, "b768b5234eba3a9968b34d6ddb481c8419b3655d": { "balance": "14974000000000000000" }, "31047d703f63b93424fbbd6e2f1f9e74de13e709": { "balance": "2850123000000000000000" }, "9a24ce8d485cc4c86e49deb39022f92c7430e67e": { "balance": "1300000000000000000000" }, "e62f9d7c64e8e2635aeb883dd73ba684ee7c1079": { "balance": "8000000000000000000000" }, "f15d9d5a21b1929e790371a17f16d95f0c69655c": { "balance": "2000000000000000000000" }, "285ae51b9500c58d541365d97569f14bb2a3709b": { "balance": "2000000000000000000000" }, "09c177f1ae442411ddacf187d46db956148360e7": { "balance": "8950000000000000000000" }, "12173074980153aeaa4b0dcbc7132eadcec21b64": { "balance": "240000000000000000000" }, "351f16e5e0735af56751b0e225b2421171394090": { "balance": "13370000000000000000000" }, "ac52b77e15664814f39e4f271be641308d91d6cc": { "balance": "220000000000000000000" }, "99c883258546cc7e4e971f522e389918da5ea63a": { "balance": "4000000000000000000000" }, "aa16269aac9c0d803068d82fc79151dadd334b66": { "balance": "4000000000000000000000" }, "7c9a110cb11f2598b2b20e2ca400325e41e9db33": { "balance": "26000000000000000000000" }, "583e83ba55e67e13e0e76f8392d873cd21fbf798": { "balance": "20000000000000000000" }, "555ebe84daa42ba256ea789105cec4b693f12f18": { "balance": "100000000000000000000" }, "978c430ce4359b06bc2cdf5c2985fc950e50d5c8": { "balance": "480000000000000000000" }, "dc1eb9b6e64351f56424509645f83e79eee76cf4": { "balance": "4000000000000000000000" }, "5b290c01967c812e4dc4c90b174c1b4015bae71e": { "balance": "149946000000000000000" }, "e7d213947fcb904ad738480b1eed2f5c329f27e8": { "balance": "18718000000000000000" }, "c517d0315c878813c717e18cafa1eab2654e01da": { "balance": "10000000000000000000000" }, "7e972a8a7c2a44c93b21436c38d21b9252c345fe": { "balance": "1790000000000000000000" }, "9cb28ac1a20a106f7f373692c5ce4c73f13732a1": { "balance": "1000000000000000000000" }, "14ab164b3b524c82d6abfbc0de831126ae8d1375": { "balance": "2000000000000000000000" }, "d46f8223452982a1eea019a8816efc2d6fc00768": { "balance": "137000000000000000000" }, "5cdc4708f14f40dcc15a795f7dc8cb0b7faa9e6e": { "balance": "537000000000000000000" }, "66fdc9fee351fa1538eb0d87d819fcf09e7c106a": { "balance": "6016500000000000000000" }, "e7be82c6593c1eeddd2ae0b15001ff201ab57b2f": { "balance": "19100000000000000000" }, "47d20e6ae4cad3f829eac07e5ac97b66fdd56cf5": { "balance": "1000000000000000000000" }, "0f2d8daf04b5414a0261f549ff6477b80f2f1d07": { "balance": "200000000000000000000000" }, "84bfcef0491a0ae0694b37ceac024584f2aa0467": { "balance": "1999944000000000000000" }, "ec5feafe210c12bfc9a5d05925a123f1e73fbef8": { "balance": "456000000000000000000000" }, "7023c70956e04a92d70025aad297b539af355869": { "balance": "2000000000000000000000" }, "d66ddf1159cf22fd8c7a4bc8d5807756d433c43e": { "balance": "2200000000000000000000" }, "d0638ea57189a6a699024ad78c71d939c1c2ff8c": { "balance": "2632000000000000000000" }, "70d25ed2c8ada59c088cf70dd22bf2db93acc18a": { "balance": "1056600000000000000000" }, "a4875928458ec2005dbb578c5cd33580f0cf1452": { "balance": "1000000000000000000000" }, "b5ad5157dda921e6bafacd9086ae73ae1f611d3f": { "balance": "2000000000000000000000" }, "c493489e56c3bdd829007dc2f956412906f76bfa": { "balance": "48968000000000000000" }, "c57612de91110c482e6f505bcd23f3c5047d1d61": { "balance": "3580000000000000000000" }, "9b18478655a4851cc906e660feac61f7f4c8bffc": { "balance": "4174120000000000000000" }, "b21b7979bf7c5ca01fa82dd640b41c39e6c6bc75": { "balance": "1999944000000000000000" }, "a9d4a2bcbe5b9e0869d70f0fe2e1d6aacd45edc5": { "balance": "198800000000000000000" }, "6f29bb375be5ed34ed999bb830ee2957dde76d16": { "balance": "2000000000000000000000" }, "a006268446643ec5e81e7acb3f17f1c351ee2ed9": { "balance": "4000000000000000000000" }, "42ddd014dc52bfbcc555325a40b516f4866a1dd3": { "balance": "2000000000000000000000" }, "d6d6776958ee23143a81adadeb08382009e996c2": { "balance": "3000000000000000000000" }, "d34e03d36a2bd4d19a5fa16218d1d61e3ffa0b15": { "balance": "320000000000000000000" }, "dac0c177f11c5c3e3e78f2efd663d13221488574": { "balance": "1000000000000000000000" }, "814135da8f9811075783bf1ab67062af8d3e9f40": { "balance": "20000000000000000000" }, "7c3eb713c4c9e0381cd8154c7c9a7db8645cde17": { "balance": "200000000000000000000" }, "f49c47b3efd86b6e6a5bc9418d1f9fec814b69ef": { "balance": "20000000000000000000000" }, "35f1da127b83376f1b88c82a3359f67a5e67dd50": { "balance": "1910000000000000000000" }, "44dfba50b829becc5f4f14d1b04aab3320a295e5": { "balance": "1000000000000000000000" }, "0b924df007e9c0878417cfe63b976ea1a382a897": { "balance": "40000000000000000000" }, "82438fd2b32a9bdd674b49d8cc5fa2eff9781847": { "balance": "20000000000000000000" }, "794529d09d017271359730027075b87ad83dae6e": { "balance": "310000000000000000000" }, "f4b49100757772f33c177b9a76ba95226c8f3dd8": { "balance": "6700000000000000000000" }, "8563c49361b625e768771c96151dbfbd1c906976": { "balance": "2000000000000000000000" }, "0b9df80fbe232009dacf0aa8cac59376e2476203": { "balance": "2000000000000000000000" }, "149b6dbde632c19f5af47cb493114bebd9b03c1f": { "balance": "12000000000000000000000" }, "d7a1431ee453d1e49a0550d1256879b4f5d10201": { "balance": "1670000000000000000000" }, "1d37616b793f94911838ac8e19ee9449df921ec4": { "balance": "1500000000000000000000" }, "d6670c036df754be43dadd8f50feea289d061fd6": { "balance": "5988459000000000000000" }, "02778e390fa17510a3428af2870c4273547d386c": { "balance": "16163700000000000000000" }, "b89f4632df5909e58b2a9964f74feb9a3b01e0c5": { "balance": "21406707000000000000000" }, "76c27535bcb59ce1fa2d8c919cabeb4a6bba01d1": { "balance": "2000000000000000000000" }, "36bf43ff35df90908824336c9b31ce33067e2f50": { "balance": "346837200000000000000000" }, "b53bcb174c2518348b818aece020364596466ba3": { "balance": "2000000000000000000000" }, "b4dd460cd016725a64b22ea4f8e06e06674e033e": { "balance": "5370000000000000000000" }, "cda1741109c0265b3fb2bf8d5ec9c2b8a3346b63": { "balance": "20000000000000000000" }, "feb8b8e2af716ae41fc7c04bcf29540156461e6b": { "balance": "1555396000000000000000" }, "a49f523aa51364cbc7d995163d34eb590ded2f08": { "balance": "2659160000000000000000" }, "a7e74f0bdb278ff0a805a648618ec52b166ff1be": { "balance": "100000000000000000000" }, "5ead29037a12896478b1296ab714e9cb95428c81": { "balance": "71500000000000000000" }, "cdecf5675433cdb0c2e55a68db5d8bbe78419dd2": { "balance": "20000000000000000000" }, "c24ccebc2344cce56417fb684cf81613f0f4b9bd": { "balance": "1550000000000000000000" }, "5a70106f20d63f875265e48e0d35f00e17d02bc9": { "balance": "20000000000000000000" }, "2606c3b3b4ca1b091498602cb1978bf3b95221c0": { "balance": "400000000000000000000" }, "1ad4563ea5786be1159935abb0f1d5879c3e7372": { "balance": "6000000000000000000000" }, "b782bfd1e2de70f467646f9bc09ea5b1fcf450af": { "balance": "267400000000000000000" }, "649a2b9879cd8fb736e6703b0c7747849796f10f": { "balance": "7358102000000000000000" }, "1cc1d3c14f0fb8640e36724dc43229d2ea7a1e48": { "balance": "1700000000000000000000" }, "824b3c3c443e19295d7ef6faa7f374a4798486a8": { "balance": "20000000000000000000" }, "a7758cecb60e8f614cce96137ef72b4fbd07774a": { "balance": "500000000000000000000" }, "981f712775c0dad97518ffedcb47b9ad1d6c2762": { "balance": "6685000000000000000000" }, "26e801b62c827191dd68d31a011990947fd0ebe0": { "balance": "20000000000000000000" }, "95447046313b2f3a5e19b948fd3b8bedc82c717c": { "balance": "500000000000000000000" }, "0b701101a4109f9cb360dc57b77442673d5e5983": { "balance": "2000000000000000000000" }, "5b25cae86dcafa2a60e7723631fc5fa49c1ad87d": { "balance": "2491200000000000000000" }, "f73ac46c203be1538111b151ec8220c786d84144": { "balance": "294515000000000000000" }, "e8c3d3b0e17f97d1e756e684f94e1470f99c95a1": { "balance": "400000000000000000000" }, "8c900a8236b08c2b65405d39d75f20062a7561fd": { "balance": "1640000000000000000000" }, "43898c49a34d509bfed4f76041ee91caf3aa6aa5": { "balance": "300000000000000000000" }, "c85325eab2a59b3ed863c86a5f2906a04229ffa9": { "balance": "465600000000000000000" }, "4a430170152de5172633dd8262d107a0afd96a0f": { "balance": "3160000000000000000000" }, "6e0ee70612c976287d499ddfa6c0dcc12c06deea": { "balance": "129980000000000000000" }, "21c07380484f6cbc8724ad32bc864c3b5ad500b7": { "balance": "1000000000000000000000" }, "ff5162f2354dc492c75fd6e3a107268660eecb47": { "balance": "1700000000000000000000" }, "8845e9f90e96336bac3c616be9d88402683e004c": { "balance": "2000000000000000000000" }, "f23c7b0cb8cd59b82bd890644a57daf40c85e278": { "balance": "50038000000000000000" }, "1784948bf99848c89e445638504dd698271b5924": { "balance": "6037580000000000000000" }, "b39f4c00b2630cab7db7295ef43d47d501e17fd7": { "balance": "4000000000000000000000" }, "3fb7d197b3ba4fe045efc23d50a14585f558d9b2": { "balance": "20000000000000000000" }, "bd043b67c63e60f841ccca15b129cdfe6590c8e3": { "balance": "200000000000000000000" }, "86ca0145957e6b0dfe36875fbe7a0dec55e17a28": { "balance": "10000000000000000000000" }, "dae7201eab8c063302930d693929d07f95e71962": { "balance": "2687370000000000000000" }, "cc034985d3f28c2d39b1a34bced4d3b2b6ca234e": { "balance": "182000000000000000000" }, "40e0dbf3efef9084ea1cd7e503f40b3b4a8443f6": { "balance": "4000000000000000000000" }, "b1896a37e5d8825a2d01765ae5de629977de8352": { "balance": "200000000000000000000" }, "d9f547f2c1de0ed98a53d161df57635dd21a00bd": { "balance": "98500000000000000000" }, "2fea1b2f834f02fc54333f8a809f0438e5870aa9": { "balance": "20200000000000000000" }, "68b31836a30a016ada157b638ac15da73f18cfde": { "balance": "26000000000000000000" }, "bc967fe4418c18b99858966d870678dca2b88879": { "balance": "8740000000000000000000" }, "16bae5d24eff91778cd98b4d3a1cc3162f44aa77": { "balance": "401100000000000000000" }, "f476e1267f86247cc908816f2e7ad5388c952db0": { "balance": "4000000000000000000000" }, "0203ae01d4c41cae1865e04b1f5b53cdfaecae31": { "balance": "1006054000000000000000" }, "bd4bd5b122d8ef7b7c8f0667450320db2116142e": { "balance": "600000000000000000000" }, "a394ad4fd9e6530e6f5c53faecbede81cb172da1": { "balance": "5600000000000000000000" }, "3a9960266df6492063538a99f487c950a3a5ec9e": { "balance": "24000000000000000000000" }, "d8069f84b521493f4715037f3226b25f33b60586": { "balance": "1910000000000000000000" }, "136c834bf111326d207395295b2e583ea7f33572": { "balance": "100000000000000000000" }, "c5c73d61cce7c8fe4c8fce29f39092cd193e0fff": { "balance": "8000000000000000000000" }, "3cfbf066565970639e130df2a7d16b0e14d6091c": { "balance": "1700000000000000000000" }, "61b905de663fc17386523b3a28e2f7d037a655cd": { "balance": "500000000000000000000" }, "fda0ce15330707f10bce3201172d2018b9ddea74": { "balance": "51900000000000000000" }, "f7fc45abf76f5088e2e5b5a8d132f28a4d4ec1c0": { "balance": "2000000000000000000000" }, "c3db9fb6f46c480af34465d79753b4e2b74a67ce": { "balance": "20000000000000000000000" }, "ebe46cc3c34c32f5add6c3195bb486c4713eb918": { "balance": "1000000000000000000000" }, "91d2a9ee1a6db20f5317cca7fbe2313895db8ef8": { "balance": "8499600000000000000000" }, "c4cc45a2b63c27c0b4429e58cd42da59be739bd6": { "balance": "1000000000000000000000" }, "a43b81f99356c0af141a03010d77bd042c71c1ee": { "balance": "2000000000000000000000" }, "4c45d4c9a725d11112bfcbca00bf31186ccaadb7": { "balance": "400000000000000000000" }, "bf9f271f7a7e12e36dd2fe9facebf385fe6142bd": { "balance": "62760000000000000000" }, "e0ce80a461b648a501fd0b824690c8868b0e4de8": { "balance": "500000000000000000000" }, "a1f7dde1d738d8cd679ea1ee965bee224be7d04d": { "balance": "1127000000000000000000" }, "7f1c81ee1697fc144b7c0be5493b5615ae7fddca": { "balance": "500200000000000000000" }, "b508f987b2de34ae4cf193de85bff61389621f88": { "balance": "6000000000000000000000" }, "5f26cf34599bc36ea67b9e7a9f9b4330c9d542a3": { "balance": "1000000000000000000000" }, "d02108d2ae3cab10cbcf1657af223e027c8210f6": { "balance": "2000140000000000000000" }, "952183cfd38e352e579d36decec5b18450f7fba0": { "balance": "2000000000000000000000" }, "eb90c793b3539761e1c814a29671148692193eb4": { "balance": "12000000000000000000000" }, "1076212d4f758c8ec7121c1c7d74254926459284": { "balance": "35000056000000000000000" }, "f05ceeab65410564709951773c8445ad9f4ec797": { "balance": "299982000000000000000" }, "05361d8eb6941d4e90fb7e1418a95a32d5257732": { "balance": "20000000000000000000" }, "a5783bf33432ff82ac498985d7d460ae67ec3673": { "balance": "1820000000000000000000" }, "b1cd4bdfd104489a026ec99d597307a04279f173": { "balance": "20000000000000000000000" }, "876c3f218b4776df3ca9dbfb270de152d94ed252": { "balance": "100000000000000000000" }, "8a36869ad478997cbf6d8924d20a3c8018e9855b": { "balance": "20000000000000000000" }, "fb3fe09bb836861529d7518da27635f538505615": { "balance": "1399904000000000000000" }, "d093e829819fd2e25b973800bb3d5841dd152d05": { "balance": "4000000000000000000000" }, "126d91f7ad86debb0557c612ca276eb7f96d00a1": { "balance": "100000000000000000000" }, "2a81d27cb6d4770ff4f3c4a3ba18e5e57f07517c": { "balance": "2000000000000000000000" }, "c4f7b13ac6d4eb4db3d4e6a252af8a07bd5957da": { "balance": "200000000000000000000" }, "305d26c10bdc103f6b9c21272eb7cb2d9108c47e": { "balance": "500000000000000000000" }, "d0d0a2ad45f59a9dccc695d85f25ca46ed31a5a3": { "balance": "840000000000000000000" }, "522323aad71dbc96d85af90f084b99c3f09decb7": { "balance": "6000000000000000000000" }, "f43da3a4e3f5fab104ca9bc1a0f7f3bb4a56f351": { "balance": "1999944000000000000000" }, "a2dc65ee256b59a5bd7929774f904b358df3ada1": { "balance": "21319600000000000000000" }, "f382df583155d8548f3f93440cd5f68cb79d6026": { "balance": "266619800000000000000000" }, "0c967e3061b87a753e84507eb60986782c8f3013": { "balance": "100000000000000000000" }, "a3a262afd2936819230892fde84f2d5a594ab283": { "balance": "1880000000000000000000" }, "93868ddb2a794d02ebda2fa4807c76e3609858dc": { "balance": "2027851000000000000000" }, "cd35ff010ec501a721a1b2f07a9ca5877dfcf95a": { "balance": "4011000000000000000000" }, "5824a7e22838277134308c5f4b50dab65e43bb31": { "balance": "6000000000000000000000" }, "7f7a3a21b3f5a65d81e0fcb7d52dd00a1aa36dba": { "balance": "100000000000000000000" }, "30513fca9f36fd788cfea7a340e86df98294a244": { "balance": "447000000000000000000" }, "283e6252b4efcf4654391acb75f903c59b78c5fb": { "balance": "12000000000000000000000" }, "eddbaafbc21be8f25562f1ed6d05d6afb58f02c2": { "balance": "2000000000000000000000" }, "0dcfe837ea1cf28c65fccec3bef1f84e59d150c0": { "balance": "200000000000000000000" }, "828ba651cb930ed9787156299a3de44cd08b7212": { "balance": "1337000000000000000000" }, "cfd47493c9f89fe680bda5754dd7c9cfe7cb5bbe": { "balance": "54508000000000000000" }, "0e89eddd3fa0d71d8ab0ff8da5580686e3d4f74f": { "balance": "2000000000000000000000" }, "205f5166f12440d85762c967d3ae86184f8f4d98": { "balance": "432500000000000000000" }, "25dad495a11a86b9eeece1eeec805e57f157faff": { "balance": "16000000000000000000000" }, "6c84cba77c6db4f7f90ef13d5ee21e8cfc7f8314": { "balance": "2000000000000000000000" }, "91a787bc5196f34857fe0c372f4df376aaa76613": { "balance": "2000000000000000000000" }, "b0d3c9872b85056ea0c0e6d1ecf7a77e3ce6ab85": { "balance": "4999711000000000000000" }, "6e4d2e39c8836629e5b487b1918a669aebdd9536": { "balance": "1000000000000000000000" }, "dc703a5f3794c84d6cb3544918cae14a35c3bd4f": { "balance": "1850000000000000000000" }, "47beb20f759100542aa93d41118b3211d664920e": { "balance": "2000000000000000000000" }, "5a7735007d70b06844da9901cdfadb11a2582c2f": { "balance": "6000000000000000000000" }, "aff107960b7ec34ed690b665024d60838c190f70": { "balance": "500000000000000000000" }, "563a03ab9c56b600f6d25b660c21e16335517a75": { "balance": "1000000000000000000000" }, "a106465bbd19e1b6bce50d1b1157dc59095a3630": { "balance": "2000000000000000000000" }, "ca9dec02841adf5cc920576a5187edd2bd434a18": { "balance": "500000000000000000000" }, "572ac1aba0de23ae41a7cae1dc0842d8abfc103b": { "balance": "1910000000000000000000" }, "5f74ed0e24ff80d9b2c4a44baa9975428cd6b935": { "balance": "2980000000000000000000" }, "f2049532fd458a83ca1bff2eebacb6d5ca63f4a4": { "balance": "3625693000000000000000" }, "cee699c0707a7836252b292f047ce8ad289b2f55": { "balance": "324700000000000000000" }, "8b3696f3c60de32432a2e4c395ef0303b7e81e75": { "balance": "30000000000000000000000" }, "13dee03e3799952d0738843d4be8fc0a803fb20e": { "balance": "2000000000000000000000" }, "c853215b9b9f2d2cd0741e585e987b5fb80c212e": { "balance": "1550000000000000000000" }, "851c0d62be4635d4777e8035e37e4ba8517c6132": { "balance": "500000000000000000000" }, "a76b743f981b693072a131b22ba510965c2fefd7": { "balance": "18200000000000000000" }, "69bd25ade1a3346c59c4e930db2a9d715ef0a27a": { "balance": "4000000000000000000000" }, "0fec4ee0d7ca180290b6bd20f9992342f60ff68d": { "balance": "334383000000000000000" }, "ccfd725760a68823ff1e062f4cc97e1360e8d997": { "balance": "399800000000000000000" }, "9f017706b830fb9c30efb0a09f506b9157457534": { "balance": "2000000000000000000000" }, "420fb86e7d2b51401fc5e8c72015decb4ef8fc2e": { "balance": "1000000000000000000000" }, "cb7d2b8089e9312cc9aeaa2773f35308ec6c2a7b": { "balance": "10000000000000000000000" }, "6c822029218ac8e98a260c1e064029348839875b": { "balance": "5010000000000000000000" }, "1c68a66138783a63c98cc675a9ec77af4598d35e": { "balance": "50100000000000000000" }, "f270792576f05d514493ffd1f5e84bec4b2df810": { "balance": "1000000000000000000000" }, "9191f94698210516cf6321a142070e20597674ed": { "balance": "17194000000000000000" }, "c0ca3277942e7445874be31ceb902972714f1823": { "balance": "250000000000000000000" }, "35e096120deaa5c1ecb1645e2ccb8b4edbd9299a": { "balance": "500000000000000000000" }, "e2bbf84641e3541f6c33e6ed683a635a70bde2ec": { "balance": "502763000000000000000" }, "d12d77ae01a92d35117bac705aacd982d02e74c1": { "balance": "1000000000000000000000" }, "dabb0889fc042926b05ef57b2520910abc4b4149": { "balance": "2000000000000000000000" }, "5a1a336962d6e0c63031cc83c6a5c6a6f4478ecb": { "balance": "1000000000000000000000" }, "abd154903513b8da4f019f68284b0656a1d0169b": { "balance": "1000000000000000000000" }, "ad377cd25eb53e83ae091a0a1d2b4516f484afde": { "balance": "1940000000000000000000" }, "08c2f236ac4adcd3fda9fbc6e4532253f9da3bec": { "balance": "20000000000000000000" }, "71135d8f05963c905a4a07922909235a896a52ea": { "balance": "3000000000000000000000" }, "080546508a3d2682c8b9884f13637b8847b44db3": { "balance": "2000000000000000000000" }, "2d61bfc56873923c2b00095dc3eaa0f590d8ae0f": { "balance": "20760000000000000000000" }, "cbfa6af6c283b046e2772c6063b0b21553c40106": { "balance": "2000000000000000000000" }, "ccabc6048a53464424fcf76eeb9e6e1801fa23d4": { "balance": "49250000000000000000" }, "60cc3d445ebdf76a7d7ae571c6971dff68cc8585": { "balance": "1000000000000000000000" }, "fff33a3bd36abdbd412707b8e310d6011454a7ae": { "balance": "8000000000000000000000" }, "d2dbebe89b0357aea98bbe8e496338debb28e805": { "balance": "4000000000000000000000" }, "5f521282e9b278dc8c034c72af53ee29e5443d78": { "balance": "6520000000000000000000" }, "c5a48a8500f9b4e22f0eb16c6f4649687674267d": { "balance": "812721000000000000000" }, "8cb3aa3fcd212854d7578fcc30fdede6742a312a": { "balance": "300000000000000000000" }, "90d2809ae1d1ffd8f63eda01de49dd552df3d1bc": { "balance": "3998000000000000000000" }, "96a55f00dff405dc4de5e58c57f6f6f0cac55d2f": { "balance": "1962711000000000000000" }, "ae842e81858ecfedf6506c686dc204ac15bf8b24": { "balance": "40000000000000000000" }, "0be6a09e4307fe48d412b8d1a1a8284dce486261": { "balance": "19180000000000000000000" }, "c9c7ac0bdd9342b5ead4360923f68c72a6ba633a": { "balance": "500000000000000000000" }, "ea8f30b6e4c5e65290fb9864259bc5990fa8ee8a": { "balance": "20000000000000000000" }, "74d37a51747bf8b771bfbf43943933d100d21483": { "balance": "1000000000000000000000" }, "1a04d5389eb006f9ce880c30d15353f8d11c4b31": { "balance": "17072800000000000000000" }, "726a14c90e3f84144c765cffacba3e0df11b48be": { "balance": "10000000000000000000000" }, "86b7bd563ceab686f96244f9ddc02ad7b0b14bc2": { "balance": "10000000000000000000000" }, "2bbe672a1857508f630f2a5edb563d9e9de92815": { "balance": "2000000000000000000000" }, "a17070c2e9c5a940a4ec0e4954c4d7d643be8f49": { "balance": "1999965000000000000000" }, "f2d1b7357724ec4c03185b879b63f57e26589153": { "balance": "6000000000000000000000" }, "d6a7ac4de7b510f0e8de519d973fa4c01ba83400": { "balance": "1880000000000000000000" }, "593b45a1864ac5c7e8f0caaeba0d873cd5d113b2": { "balance": "6000000000000000000000" }, "0837539b5f6a522a482cdcd3a9bb7043af39bdd2": { "balance": "6000000000000000000000" }, "b927abd2d28aaaa24db31778d27419df8e1b04bb": { "balance": "27531000000000000000" }, "b2e085fddd1468ba07415b274e734e11237fb2a9": { "balance": "100000000000000000000" }, "970938522afb5e8f994873c9fbdc26e3b37e314c": { "balance": "1000000000000000000000" }, "f3de5f26ef6aded6f06d3b911346ee70401da4a0": { "balance": "354718000000000000000" }, "bffb6929241f788693273e7022e60e3eab1fe84f": { "balance": "2000000000000000000000" }, "b56ad2aec6c8c3f19e1515bbb7dd91285256b639": { "balance": "1000000000000000000000" }, "47730f5f8ebf89ac72ef80e46c12195038ecdc49": { "balance": "3160000000000000000000" }, "f39a9d7aa3581df07ee4279ae6c312ef21033658": { "balance": "4000000000000000000000" }, "36227cdfa0fd3b9d7e6a744685f5be9aa366a7f0": { "balance": "198479000000000000000" }, "89e3b59a15864737d493c1d23cc53dbf8dcb1362": { "balance": "4000000000000000000000" }, "bd08e0cddec097db7901ea819a3d1fd9de8951a2": { "balance": "20000000000000000000" }, "533444584082eba654e1ad30e149735c6f7ba922": { "balance": "1730000000000000000000" }, "6a8a4317c45faa0554ccdb482548183e295a24b9": { "balance": "1000000000000000000000" }, "22ce349159eeb144ef06ff2636588aef79f62832": { "balance": "188000000000000000000" }, "3cd1d9731bd548c1dd6fcea61beb75d91754f7d3": { "balance": "5130285000000000000000" }, "8b7056f6abf3b118d026e944d5c073433ca451d7": { "balance": "999999000000000000000" }, "15f1b352110d68901d8f67aac46a6cfafe031477": { "balance": "200000000000000000000" }, "0f789e30397c53bf256fc364e6ef39f853504114": { "balance": "3640000000000000000000" }, "750bbb8c06bbbf240843cc75782ee02f08a97453": { "balance": "835000000000000000000" }, "fff7ac99c8e4feb60c9750054bdc14ce1857f181": { "balance": "1000000000000000000000" }, "5c6f36af90ab1a656c6ec8c7d521512762bba3e1": { "balance": "1999800000000000000000" }, "6811b54cd19663b11b94da1de2448285cd9f68d9": { "balance": "1100000000000000000000" }, "6f50929777824c291a49c46dc854f379a6bea080": { "balance": "360000000000000000000" }, "e83604e4ff6be7f96f6018d3ec3072ec525dff6b": { "balance": "182000000000000000000" }, "d731bb6b5f3c37395e09ceaccd14a918a6060789": { "balance": "3940000000000000000000" }, "372e453a6b629f27678cc8aeb5e57ce85ec0aef9": { "balance": "200000000000000000000" }, "86924fb211aad23cf5ce600e0aae806396444087": { "balance": "10000000000000000000000" }, "18c6723a6753299cb914477d04a3bd218df8c775": { "balance": "1000000000000000000000" }, "e00484788db50fc6a48e379d123e508b0f6e5ab1": { "balance": "1000000000000000000000" }, "150e3dbcbcfc84ccf89b73427763a565c23e60d0": { "balance": "40000000000000000000" }, "8ffa062122ac307418821adb9311075a3703bfa3": { "balance": "1000000000000000000000" }, "21206ce22ea480e85940d31314e0d64f4e4d3a04": { "balance": "1000000000000000000000" }, "ac024f594f9558f04943618eb0e6b2ee501dc272": { "balance": "2000000000000000000000" }, "b2b7cdb4ff4b61d5b7ce0b2270bbb5269743ec04": { "balance": "2000000000000000000000" }, "abc74706964960dfe0dca3dca79e9216056f1cf4": { "balance": "40000000000000000000000" }, "d7eb903162271c1afa35fe69e37322c8a4d29b11": { "balance": "10000000000000000000000" }, "d7c6265dea11876c903b718e4cd8ab24fe265bde": { "balance": "2000000000000000000000" }, "cba288cd3c1eb4d59ddb06a6421c14c345a47b24": { "balance": "4000000000000000000000" }, "8c22426055b76f11f0a2de1a7f819a619685fe60": { "balance": "1980000000000000000000" }, "f463a90cb3f13e1f0643423636beab84c123b06d": { "balance": "40000000000000000000" }, "2b5ced9987c0765f900e49cf9da2d9f9c1138855": { "balance": "400000000000000000000" }, "9bb760d5c289a3e1db18db095345ca413b9a43c2": { "balance": "197000000000000000000" }, "d66ab79294074c8b627d842dab41e17dd70c5de5": { "balance": "1000000000000000000000" }, "0bdd58b96e7c916dd2fb30356f2aebfaaf1d8630": { "balance": "2000000000000000000000" }, "d612597bc31743c78633f633f239b1e9426bd925": { "balance": "76000000000000000000000" }, "140518a3194bad1350b8949e650565debe6db315": { "balance": "2000000000000000000000" }, "daedd4ad107b271e89486cbf80ebd621dd974578": { "balance": "2000000000000000000000" }, "c36c0b63bfd75c2f8efb060883d868cccd6cbdb4": { "balance": "3000000000000000000000" }, "e646665872e40b0d7aa2ff82729caaba5bc3e89e": { "balance": "400000000000000000000" }, "b5fb7ea2ddc1598b667a9d57dd39e85a38f35d56": { "balance": "500000000000000000000" }, "e51421f8ee2210c71ed870fe618276c8954afbe9": { "balance": "1337000000000000000000" }, "08a9a44e1f41de3dbba7a363a3ab412c124cd15e": { "balance": "200000000000000000000" }, "562bced38ab2ab6c080f3b0541b8456e70824b3f": { "balance": "641760000000000000000" }, "1e484d0621f0f5331b35d5408d9aae4eb1acf21e": { "balance": "20000000000000000000" }, "3a476bd2c9e664c63ab266aa4c6e4a4825f516c3": { "balance": "200000000000000000000" }, "8d6df209484d7b94702b03a53e56b9fb0660f6f0": { "balance": "2000000000000000000000" }, "5970fb1b144dd751e4ce2eca7caa20e363dc4da3": { "balance": "10000000000000000000000" }, "d1dd79fb158160e5b4e8e23f312e6a907fbc4d4e": { "balance": "500000000000000000000" }, "7ee5ca805dce23af89c2d444e7e40766c54c7404": { "balance": "240660000000000000000" }, "93e0f37ecdfb0086e3e862a97034447b1e4dec1a": { "balance": "30000000000000000000" }, "e10ac19c546fc2547c61c139f5d1f45a6666d5b0": { "balance": "4775000000000000000000" }, "1c73d00b6e25d8eb9c1ff4ad827b6b9e9cf6d20c": { "balance": "200000000000000000000" }, "d771d9e0ca8a08a113775731434eb3270599c40d": { "balance": "20000000000000000000" }, "e69d1c378b771e0feff051db69d966ac6779f4ed": { "balance": "553000000000000000000" }, "0ef85b49d08a75198692914eddb4b22cf5fa4450": { "balance": "2004800000000000000000" }, "ed70a37cdd1cbda9746d939658ae2a6181288578": { "balance": "9600000000000000000000" }, "eee761847e33fd61d99387ee14628694d1bfd525": { "balance": "2000000000000000000000" }, "271d3d481cb88e7671ad216949b6365e06303de0": { "balance": "4000000000000000000000" }, "5255dc69155a45b970c604d30047e2f530690e7f": { "balance": "20000000000000000000" }, "cabab6274ed15089737e287be878b757934864e2": { "balance": "20000000000000000000000" }, "9defe56a0ff1a1947dba0923f7dd258d8f12fa45": { "balance": "26880000000000000000000" }, "b7a2c103728b7305b5ae6e961c94ee99c9fe8e2b": { "balance": "50000000000000000000000" }, "b498bb0f520005b6216a4425b75aa9adc52d622b": { "balance": "4000000000000000000000" }, "c1132878235c5ddba5d9f3228b5236e47020dc6f": { "balance": "1000000000000000000000" }, "f81622e55757daea6675975dd93538da7d16991e": { "balance": "2000000000000000000000" }, "ce2deab51c0a9ae09cd212c4fa4cc52b53cc0dec": { "balance": "2000000000000000000000" }, "86a1eadeeb30461345d9ef6bd05216fa247c0d0c": { "balance": "2000000000000000000000" }, "7b1fe1ab4dfd0088cdd7f60163ef59ec2aee06f5": { "balance": "2000000000000000000000" }, "6bbc3f358a668dd1a11f0380f3f73108426abd4a": { "balance": "4000000000000000000000" }, "b1e6e810c24ab0488de9e01e574837829f7c77d0": { "balance": "400000000000000000000" }, "03eb3cb860f6028da554d344a2bb5a500ae8b86f": { "balance": "2000000000000000000000" }, "e5481a7fed42b901bbed20789bd4ade50d5f83b9": { "balance": "2000000000000000000000" }, "1f3da68fe87eaf43a829ab6d7ec5a6e009b204fb": { "balance": "554988000000000000000" }, "30037988702671acbe892c03fe5788aa98af287a": { "balance": "2800000000000000000000" }, "edb473353979a206879de144c10a3c51d7d7081a": { "balance": "6000000000000000000000" }, "22bdffc240a88ff7431af3bff50e14da37d5183e": { "balance": "1000000000000000000000" }, "9374869d4a9911ee1eaf558bc4c2b63ec63acfdd": { "balance": "1000000000000000000000" }, "b756ad52f3bf74a7d24c67471e0887436936504c": { "balance": "20000000000000000000000" }, "8bd0b65a50ef5cef84fec420be7b89ed1470ceb9": { "balance": "11999000000000000000000" }, "af26f7c6bf453e2078f08953e4b28004a2c1e209": { "balance": "100000000000000000000" }, "7c532db9e0c06c26fd40acc56ac55c1ee92d3c3a": { "balance": "300000000000000000000000" }, "dde670d01639667576a22dd05d3246d61f06e083": { "balance": "26740000000000000000" }, "5cf44e10540d65716423b1bcb542d21ff83a94cd": { "balance": "10000000000000000000000" }, "f96b4c00766f53736a8574f822e6474c2f21da2d": { "balance": "400000000000000000000" }, "8d89170b92b2be2c08d57c48a7b190a2f146720f": { "balance": "19700000000000000000000" }, "142b87c5043ffb5a91df18c2e109ced6fe4a71db": { "balance": "200000000000000000000" }, "42d34940edd2e7005d46e2188e4cfece8311d74d": { "balance": "158000000000000000000" }, "562105e82b099735de49f62692cc87cd38a8edcd": { "balance": "6000000000000000000000" }, "457bcef37dd3d60b2dd019e3fe61d46b3f1e7252": { "balance": "20000000000000000000" }, "cf8882359c0fb23387f5674074d8b17ade512f98": { "balance": "6000000000000000000000" }, "f0c081da52a9ae36642adf5e08205f05c54168a6": { "balance": "111000000000000000000" }, "551e7784778ef8e048e495df49f2614f84a4f1dc": { "balance": "600000000000000000000" }, "3c869c09696523ced824a070414605bb76231ff2": { "balance": "1000000000000000000000" }, "7e7f18a02eccaa5d61ab8fbf030343c434a25ef7": { "balance": "66850000000000000000" }, "9328d55ccb3fce531f199382339f0e576ee840a3": { "balance": "4000000000000000000000" }, "9d0f347e826b7dceaad279060a35c0061ecf334b": { "balance": "4000000000000000000000" }, "680640838bd07a447b168d6d923b90cf6c43cdca": { "balance": "1730000000000000000000" }, "c951900c341abbb3bafbf7ee2029377071dbc36a": { "balance": "327600000000000000000" }, "ddf5810a0eb2fb2e32323bb2c99509ab320f24ac": { "balance": "17900000000000000000000" }, "2489ac126934d4d6a94df08743da7b7691e9798e": { "balance": "1000000000000000000000" }, "f42f905231c770f0a406f2b768877fb49eee0f21": { "balance": "197000000000000000000" }, "756f45e3fa69347a9a973a725e3c98bc4db0b5a0": { "balance": "200000000000000000000" } }, "coinbase": "0x0000000000000000000000000000000000000000", "config": { "chainId": 1, "homesteadBlock": 1150000, "daoForkBlock": 1920000, "daoForkSupport": true, "eip150Block": 2463000, "eip150Hash": "0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0", "eip155Block": 2675000, "eip158Block": 2675000, "byzantiumBlock": 4370000, "constantinopleBlock": 7280000, "petersburgBlock": 7280000, "istanbulBlock": 9069000, "muirGlacierBlock": 9200000, "berlinBlock": 12244000, "londonBlock": 12965000, "arrowGlacierBlock": 13773000, "grayGlacierBlock": 15050000, "terminalTotalDifficulty": "58750000000000000000000", "shanghaiTime": 1681338455, "cancunTime": 1710338135, "ethash": {} }, "difficulty": "0x0400000000", "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa", "gasLimit": "0x1388", "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "nonce": "0x0000000000000042", "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "timestamp": "0x00" } ================================================ FILE: silkworm/core/chain/genesis_sepolia.cpp ================================================ /* Generated from genesis_sepolia.json using silkworm embed_json tool */ #include "genesis_sepolia.hpp" constexpr char kGenesisSepoliaDataInternal[] = { 0x7b, 0x22, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x30, 0x78, 0x61, 0x32, 0x41, 0x36, 0x64, 0x39, 0x33, 0x34, 0x33, 0x39, 0x31, 0x34, 0x34, 0x46, 0x46, 0x45, 0x34, 0x44, 0x32, 0x37, 0x63, 0x39, 0x45, 0x30, 0x38, 0x38, 0x64, 0x43, 0x44, 0x38, 0x62, 0x37, 0x38, 0x33, 0x39, 0x34, 0x36, 0x32, 0x36, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x42, 0x63, 0x31, 0x31, 0x32, 0x39, 0x35, 0x39, 0x33, 0x36, 0x41, 0x61, 0x37, 0x39, 0x64, 0x35, 0x39, 0x34, 0x31, 0x33, 0x39, 0x64, 0x65, 0x31, 0x42, 0x32, 0x65, 0x31, 0x32, 0x36, 0x32, 0x39, 0x34, 0x31, 0x34, 0x46, 0x33, 0x42, 0x44, 0x42, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x37, 0x63, 0x46, 0x35, 0x62, 0x37, 0x39, 0x62, 0x66, 0x65, 0x32, 0x39, 0x31, 0x41, 0x36, 0x37, 0x41, 0x42, 0x30, 0x32, 0x62, 0x33, 0x39, 0x33, 0x45, 0x34, 0x35, 0x36, 0x63, 0x43, 0x63, 0x34, 0x63, 0x32, 0x36, 0x36, 0x46, 0x37, 0x35, 0x33, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x61, 0x61, 0x65, 0x63, 0x38, 0x36, 0x33, 0x39, 0x34, 0x34, 0x34, 0x31, 0x66, 0x39, 0x31, 0x35, 0x62, 0x63, 0x65, 0x33, 0x65, 0x36, 0x61, 0x62, 0x33, 0x39, 0x39, 0x39, 0x37, 0x37, 0x65, 0x39, 0x39, 0x30, 0x36, 0x66, 0x33, 0x62, 0x36, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x46, 0x34, 0x37, 0x43, 0x61, 0x45, 0x31, 0x43, 0x46, 0x37, 0x39, 0x63, 0x61, 0x36, 0x37, 0x35, 0x38, 0x42, 0x66, 0x63, 0x37, 0x38, 0x37, 0x64, 0x62, 0x44, 0x32, 0x31, 0x45, 0x36, 0x62, 0x64, 0x42, 0x65, 0x37, 0x31, 0x31, 0x32, 0x42, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x64, 0x37, 0x65, 0x44, 0x44, 0x42, 0x37, 0x38, 0x45, 0x44, 0x32, 0x39, 0x35, 0x42, 0x33, 0x43, 0x39, 0x36, 0x32, 0x39, 0x32, 0x34, 0x30, 0x45, 0x38, 0x39, 0x32, 0x34, 0x66, 0x62, 0x38, 0x44, 0x38, 0x38, 0x37, 0x34, 0x64, 0x64, 0x44, 0x38, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x38, 0x62, 0x37, 0x46, 0x30, 0x39, 0x37, 0x37, 0x42, 0x62, 0x34, 0x66, 0x30, 0x66, 0x42, 0x45, 0x37, 0x30, 0x37, 0x36, 0x46, 0x41, 0x32, 0x32, 0x62, 0x43, 0x32, 0x34, 0x61, 0x63, 0x41, 0x30, 0x34, 0x33, 0x35, 0x38, 0x33, 0x46, 0x35, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x65, 0x32, 0x65, 0x32, 0x36, 0x35, 0x39, 0x30, 0x32, 0x38, 0x31, 0x34, 0x33, 0x37, 0x38, 0x34, 0x64, 0x35, 0x35, 0x37, 0x62, 0x63, 0x65, 0x63, 0x36, 0x66, 0x66, 0x33, 0x61, 0x30, 0x37, 0x32, 0x31, 0x30, 0x34, 0x38, 0x38, 0x38, 0x30, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x64, 0x39, 0x61, 0x35, 0x31, 0x37, 0x39, 0x66, 0x30, 0x39, 0x31, 0x64, 0x38, 0x35, 0x30, 0x35, 0x31, 0x64, 0x33, 0x63, 0x39, 0x38, 0x32, 0x37, 0x38, 0x35, 0x65, 0x66, 0x64, 0x31, 0x34, 0x35, 0x35, 0x63, 0x65, 0x63, 0x38, 0x36, 0x39, 0x39, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x62, 0x65, 0x65, 0x66, 0x33, 0x32, 0x63, 0x61, 0x35, 0x62, 0x39, 0x61, 0x31, 0x39, 0x38, 0x64, 0x32, 0x37, 0x42, 0x34, 0x65, 0x30, 0x32, 0x46, 0x34, 0x63, 0x37, 0x30, 0x34, 0x33, 0x39, 0x66, 0x45, 0x36, 0x30, 0x33, 0x35, 0x36, 0x43, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x33, 0x43, 0x32, 0x31, 0x42, 0x43, 0x45, 0x43, 0x43, 0x45, 0x44, 0x41, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x31, 0x36, 0x61, 0x38, 0x37, 0x62, 0x38, 0x32, 0x33, 0x33, 0x33, 0x66, 0x34, 0x32, 0x34, 0x35, 0x30, 0x34, 0x36, 0x36, 0x32, 0x33, 0x62, 0x32, 0x33, 0x37, 0x39, 0x34, 0x63, 0x36, 0x35, 0x63, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x34, 0x35, 0x39, 0x35, 0x31, 0x36, 0x31, 0x34, 0x30, 0x31, 0x34, 0x38, 0x34, 0x41, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x62, 0x32, 0x31, 0x63, 0x33, 0x33, 0x64, 0x65, 0x31, 0x66, 0x61, 0x62, 0x33, 0x66, 0x61, 0x31, 0x35, 0x34, 0x39, 0x39, 0x63, 0x36, 0x32, 0x62, 0x35, 0x39, 0x66, 0x65, 0x30, 0x63, 0x63, 0x33, 0x32, 0x35, 0x30, 0x30, 0x32, 0x30, 0x64, 0x31, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x42, 0x37, 0x44, 0x32, 0x44, 0x43, 0x43, 0x38, 0x30, 0x43, 0x44, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x31, 0x30, 0x46, 0x35, 0x64, 0x34, 0x35, 0x38, 0x35, 0x34, 0x65, 0x30, 0x33, 0x38, 0x30, 0x37, 0x31, 0x34, 0x38, 0x35, 0x41, 0x43, 0x39, 0x65, 0x34, 0x30, 0x32, 0x33, 0x30, 0x38, 0x63, 0x46, 0x38, 0x30, 0x44, 0x32, 0x64, 0x32, 0x66, 0x45, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x42, 0x37, 0x44, 0x32, 0x44, 0x43, 0x43, 0x38, 0x30, 0x43, 0x44, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x64, 0x37, 0x64, 0x37, 0x36, 0x63, 0x35, 0x38, 0x62, 0x33, 0x61, 0x35, 0x31, 0x39, 0x65, 0x39, 0x66, 0x41, 0x36, 0x43, 0x63, 0x34, 0x44, 0x32, 0x32, 0x64, 0x43, 0x30, 0x31, 0x37, 0x32, 0x35, 0x39, 0x42, 0x43, 0x34, 0x39, 0x46, 0x31, 0x45, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x32, 0x42, 0x37, 0x44, 0x32, 0x44, 0x43, 0x43, 0x38, 0x30, 0x43, 0x44, 0x32, 0x45, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x30, 0x78, 0x37, 0x39, 0x39, 0x44, 0x33, 0x32, 0x39, 0x65, 0x35, 0x66, 0x35, 0x38, 0x33, 0x34, 0x31, 0x39, 0x31, 0x36, 0x37, 0x63, 0x44, 0x37, 0x32, 0x32, 0x39, 0x36, 0x32, 0x34, 0x38, 0x35, 0x39, 0x32, 0x36, 0x45, 0x33, 0x33, 0x38, 0x46, 0x34, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x44, 0x45, 0x30, 0x42, 0x36, 0x42, 0x33, 0x41, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x31, 0x31, 0x31, 0x35, 0x35, 0x31, 0x31, 0x31, 0x2c, 0x22, 0x68, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x30, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x65, 0x69, 0x70, 0x31, 0x35, 0x35, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x62, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x70, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62, 0x75, 0x72, 0x67, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6d, 0x75, 0x69, 0x72, 0x47, 0x6c, 0x61, 0x63, 0x69, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x62, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x4e, 0x65, 0x74, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x31, 0x37, 0x33, 0x35, 0x33, 0x37, 0x31, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x31, 0x36, 0x37, 0x37, 0x35, 0x35, 0x37, 0x30, 0x38, 0x38, 0x2c, 0x22, 0x63, 0x61, 0x6e, 0x63, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x31, 0x37, 0x30, 0x36, 0x36, 0x35, 0x35, 0x30, 0x37, 0x32, 0x2c, 0x22, 0x70, 0x72, 0x61, 0x67, 0x75, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x3a, 0x31, 0x37, 0x34, 0x31, 0x31, 0x35, 0x39, 0x37, 0x37, 0x36, 0x2c, 0x22, 0x65, 0x74, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x7d, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x53, 0x65, 0x70, 0x6f, 0x6c, 0x69, 0x61, 0x2c, 0x20, 0x41, 0x74, 0x68, 0x65, 0x6e, 0x73, 0x2c, 0x20, 0x41, 0x74, 0x74, 0x69, 0x63, 0x61, 0x2c, 0x20, 0x47, 0x72, 0x65, 0x65, 0x63, 0x65, 0x21, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x43, 0x39, 0x43, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x31, 0x35, 0x39, 0x41, 0x46, 0x31, 0x39, 0x22, 0x7d }; namespace silkworm { constinit const std::string_view kGenesisSepoliaJson{&kGenesisSepoliaDataInternal[0], sizeof(kGenesisSepoliaDataInternal)}; } ================================================ FILE: silkworm/core/chain/genesis_sepolia.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { constinit extern const std::string_view kGenesisSepoliaJson; } ================================================ FILE: silkworm/core/chain/genesis_sepolia.json ================================================ { "alloc": { "0xa2A6d93439144FFE4D27c9E088dCD8b783946263": { "balance": "0xD3C21BCECCEDA1000000" }, "0xBc11295936Aa79d594139de1B2e12629414F3BDB": { "balance": "0xD3C21BCECCEDA1000000" }, "0x7cF5b79bfe291A67AB02b393E456cCc4c266F753": { "balance": "0xD3C21BCECCEDA1000000" }, "0xaaec86394441f915bce3e6ab399977e9906f3b69": { "balance": "0xD3C21BCECCEDA1000000" }, "0xF47CaE1CF79ca6758Bfc787dbD21E6bdBe7112B8": { "balance": "0xD3C21BCECCEDA1000000" }, "0xd7eDDB78ED295B3C9629240E8924fb8D8874ddD8": { "balance": "0xD3C21BCECCEDA1000000" }, "0x8b7F0977Bb4f0fBE7076FA22bC24acA043583F5e": { "balance": "0xD3C21BCECCEDA1000000" }, "0xe2e2659028143784d557bcec6ff3a0721048880a": { "balance": "0xD3C21BCECCEDA1000000" }, "0xd9a5179f091d85051d3c982785efd1455cec8699": { "balance": "0xD3C21BCECCEDA1000000" }, "0xbeef32ca5b9a198d27B4e02F4c70439fE60356Cf": { "balance": "0xD3C21BCECCEDA1000000" }, "0x0000006916a87b82333f4245046623b23794c65c": { "balance": "0x84595161401484A000000" }, "0xb21c33de1fab3fa15499c62b59fe0cc3250020d1": { "balance": "0x52B7D2DCC80CD2E4000000" }, "0x10F5d45854e038071485AC9e402308cF80D2d2fE": { "balance": "0x52B7D2DCC80CD2E4000000" }, "0xd7d76c58b3a519e9fA6Cc4D22dC017259BC49F1E": { "balance": "0x52B7D2DCC80CD2E4000000" }, "0x799D329e5f583419167cD722962485926E338F4a": { "balance": "0xDE0B6B3A7640000" } }, "coinbase": "0x0000000000000000000000000000000000000000", "config": { "chainId": 11155111, "homesteadBlock": 0, "eip150Block": 0, "eip155Block": 0, "byzantiumBlock": 0, "constantinopleBlock": 0, "petersburgBlock": 0, "istanbulBlock": 0, "muirGlacierBlock": 0, "berlinBlock": 0, "londonBlock": 0, "terminalTotalDifficulty": "17000000000000000", "mergeNetsplitBlock": 1735371, "shanghaiTime": 1677557088, "cancunTime": 1706655072, "pragueTime": 1741159776, "ethash": {} }, "difficulty": "0x20000", "extraData": "Sepolia, Athens, Attica, Greece!", "gasLimit": "0x1C9C380", "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "nonce": "0x0", "timestamp": "0x6159AF19" } ================================================ FILE: silkworm/core/chain/genesis_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include namespace silkworm { void test_genesis_config(const ChainConfig& x) { const std::string_view genesis_data{read_genesis_data(x.chain_id)}; const nlohmann::json genesis_json = nlohmann::json::parse(genesis_data, nullptr, /* allow_exceptions = */ false); REQUIRE(!genesis_json.is_discarded()); REQUIRE(genesis_json.contains("config")); REQUIRE(genesis_json["config"].is_object()); const std::optional config{ChainConfig::from_json(genesis_json["config"])}; CHECK(config == x); } TEST_CASE("unknown genesis") { const std::string_view genesis_data{read_genesis_data(1'000u)}; const nlohmann::json genesis_json = nlohmann::json::parse(genesis_data, nullptr, /* allow_exceptions = */ false); CHECK(genesis_json.is_discarded()); } nlohmann::json sanity_checked_json(uint64_t chain_id) { // Parse genesis data std::string_view genesis_data{read_genesis_data(static_cast(chain_id))}; nlohmann::json genesis_json = nlohmann::json::parse(genesis_data, nullptr, /* allow_exceptions = */ false); CHECK_FALSE(genesis_json.is_discarded()); CHECK(genesis_json.contains("difficulty")); CHECK(genesis_json.contains("gasLimit")); CHECK(genesis_json.contains("timestamp")); CHECK((genesis_json.contains("alloc") && genesis_json["alloc"].is_object() && !genesis_json["alloc"].empty())); return genesis_json; } evmc::bytes32 state_root(const nlohmann::json& genesis_json) { InMemoryState state{read_genesis_allocation(genesis_json["alloc"])}; return state.state_root_hash(); } // https://etherscan.io/block/0 TEST_CASE("mainnet_genesis") { test_genesis_config(kMainnetConfig); nlohmann::json genesis_json = sanity_checked_json(kMainnetConfig.chain_id); auto expected_state_root{0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544_bytes32}; auto actual_state_root{state_root(genesis_json)}; CHECK(to_hex(expected_state_root) == to_hex(actual_state_root)); BlockHeader header{read_genesis_header(genesis_json, actual_state_root)}; // Verify our RLP encoding produces the same result auto computed_hash{header.hash()}; CHECK(to_hex(computed_hash) == to_hex(kMainnetGenesisHash)); // TODO (Andrea) Why this fails for genesis ? // auto seal_hash(header.hash(/*for_sealing =*/true)); // ethash::hash256 sealh256{}; // std::memcpy(sealh256.bytes, seal_hash.bytes, 32); // auto boundary{ethash::get_boundary_from_diff(header.difficulty)}; // auto epoch_context{ethash::create_epoch_context(0)}; // auto result{ethash::hash(*epoch_context, sealh256, nonce)}; // CHECK(ethash::is_less_or_equal(result.final_hash, boundary)); } TEST_CASE("Holesky genesis") { test_genesis_config(kHoleskyConfig); nlohmann::json genesis_json = sanity_checked_json(kHoleskyConfig.chain_id); BlockHeader header{read_genesis_header(genesis_json, state_root(genesis_json))}; CHECK(to_hex(header.hash()) == to_hex(kHoleskyGenesisHash)); } // https://sepolia.etherscan.io/block/0 TEST_CASE("Sepolia genesis") { test_genesis_config(kSepoliaConfig); nlohmann::json genesis_json = sanity_checked_json(kSepoliaConfig.chain_id); CHECK(genesis_json["extraData"] == "Sepolia, Athens, Attica, Greece!"); auto expected_state_root{0x5eb6e371a698b8d68f665192350ffcecbbbf322916f4b51bd79bb6887da3f494_bytes32}; auto actual_state_root{state_root(genesis_json)}; CHECK(to_hex(expected_state_root) == to_hex(actual_state_root)); BlockHeader header{read_genesis_header(genesis_json, actual_state_root)}; auto computed_hash{header.hash()}; CHECK(to_hex(computed_hash) == to_hex(kSepoliaGenesisHash)); } TEST_CASE("Polygon PoS genesis") { test_genesis_config(kBorMainnetConfig); nlohmann::json genesis_json = sanity_checked_json(kBorMainnetConfig.chain_id); auto expected_state_root{0x654f28d19b44239d1012f27038f1f71b3d4465dc415a382fb2b7009cba1527c8_bytes32}; auto actual_state_root{state_root(genesis_json)}; CHECK(to_hex(expected_state_root) == to_hex(actual_state_root)); BlockHeader header{read_genesis_header(genesis_json, actual_state_root)}; auto computed_hash{header.hash()}; CHECK(to_hex(computed_hash) == to_hex(kBorMainnetGenesisHash)); } TEST_CASE("Amoy genesis") { test_genesis_config(kAmoyConfig); nlohmann::json genesis_json = sanity_checked_json(kAmoyConfig.chain_id); auto expected_state_root{0x3cfe247720ff1d26dfc97de26f6be0047b93d6fe47f77f4f36beff9fabe68cce_bytes32}; auto actual_state_root{state_root(genesis_json)}; CHECK(to_hex(expected_state_root) == to_hex(actual_state_root)); BlockHeader header{read_genesis_header(genesis_json, actual_state_root)}; auto computed_hash{header.hash()}; CHECK(to_hex(computed_hash) == to_hex(kAmoyGenesisHash)); } } // namespace silkworm ================================================ FILE: silkworm/core/common/assert.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "assert.hpp" #include #include namespace silkworm { void abort_due_to_assertion_failure(char const* expr, char const* file, int line) { std::cerr << "Assert failed: " << expr << " Source: " << file << ", line " << line << "\n"; std::abort(); } } // namespace silkworm ================================================ FILE: silkworm/core/common/assert.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once namespace silkworm { [[noreturn]] void abort_due_to_assertion_failure(char const* expr, char const* file, int line); } // SILKWORM_ASSERT always aborts program execution on assertion failure, even when NDEBUG is defined. #define SILKWORM_ASSERT(expr) \ if ((expr)) [[likely]] \ static_cast(0); \ else \ ::silkworm::abort_due_to_assertion_failure(#expr, __FILE__, __LINE__) ================================================ FILE: silkworm/core/common/base.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // The most common and basic macros, concepts, types, and constants. #include #include #include #include #include #include #include #if defined(__wasm__) #define SILKWORM_THREAD_LOCAL static #else #define SILKWORM_THREAD_LOCAL thread_local #endif namespace silkworm { using namespace std::string_view_literals; template concept UnsignedIntegral = std::unsigned_integral || std::same_as || std::same_as || std::same_as; using TxnId = uint64_t; inline constexpr TxnId kMaxTxnId = std::numeric_limits::max(); struct TxnIdRange { TxnId start; TxnId end; TxnIdRange(TxnId start1, TxnId end1) : start(start1), end(end1) {} friend bool operator==(const TxnIdRange&, const TxnIdRange&) = default; bool contains(TxnId num) const { return (start <= num) && (num < end); } bool contains_range(TxnIdRange range) const { return (start <= range.start) && (range.end <= end); } TxnId size() const { return end - start; } std::string to_string() const { return std::string("[") + std::to_string(start) + ", " + std::to_string(end) + ")"; } }; using BlockNum = uint64_t; inline constexpr BlockNum kMaxBlockNum = std::numeric_limits::max(); struct BlockNumRange { BlockNum start; BlockNum end; BlockNumRange(BlockNum start1, BlockNum end1) : start(start1), end(end1) {} friend bool operator==(const BlockNumRange&, const BlockNumRange&) = default; bool contains(BlockNum block_num) const { return (start <= block_num) && (block_num < end); } bool contains_range(BlockNumRange range) const { return (start <= range.start) && (range.end <= end); } BlockNum size() const { return end - start; } std::string to_string() const { return std::string("[") + std::to_string(start) + ", " + std::to_string(end) + ")"; } }; using BlockTime = uint64_t; inline constexpr BlockNum kEarliestBlockNum{0ul}; inline constexpr size_t kAddressLength{20}; inline constexpr size_t kHashLength{32}; // https://en.wikipedia.org/wiki/Binary_prefix inline constexpr uint64_t kKibi{1024}; inline constexpr uint64_t kMebi{1024 * kKibi}; inline constexpr uint64_t kGibi{1024 * kMebi}; inline constexpr uint64_t kTebi{1024 * kGibi}; inline constexpr uint64_t kGiga{1'000'000'000}; // = 10^9 inline constexpr uint64_t kEther{kGiga * kGiga}; // = 10^18 consteval uint64_t operator"" _Kibi(unsigned long long x) { SILKWORM_ASSERT(x <= std::numeric_limits::max() / kKibi); return x * kKibi; } consteval uint64_t operator"" _Mebi(unsigned long long x) { SILKWORM_ASSERT(x <= std::numeric_limits::max() / kMebi); return x * kMebi; } consteval uint64_t operator"" _Gibi(unsigned long long x) { SILKWORM_ASSERT(x <= std::numeric_limits::max() / kGibi); return x * kGibi; } consteval uint64_t operator"" _Tebi(unsigned long long x) { SILKWORM_ASSERT(x <= std::numeric_limits::max() / kTebi); return x * kTebi; } } // namespace silkworm ================================================ FILE: silkworm/core/common/block_cache.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm { class BlockCache { public: explicit BlockCache(size_t capacity = 1024, bool shared_cache = true) : block_cache_(capacity, shared_cache) {} std::shared_ptr get(const evmc::bytes32& key) { auto result = block_cache_.get_as_copy(key); if (result) { return *result; } return nullptr; } void insert(const evmc::bytes32& key, const std::shared_ptr& block) { block_cache_.put(key, block); } private: LruCache> block_cache_; }; } // namespace silkworm ================================================ FILE: silkworm/core/common/block_cache_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block_cache.hpp" #include namespace silkworm { TEST_CASE("check get cache key not present(lock)", "[rpc][commands][block_cache]") { BlockCache block_cache(1, true); evmc::bytes32 bh1{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; auto b = block_cache.get(bh1); CHECK(!b); } TEST_CASE("check get cache key not present(no-lock)", "[rpc][commands][block_cache]") { BlockCache block_cache(1, false); evmc::bytes32 bh1{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; auto b = block_cache.get(bh1); CHECK(!b); } TEST_CASE("insert entry in cache(lock)", "[rpc][commands][block_cache]") { evmc::bytes32 bh1{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; BlockCache block_cache(1, true); auto ret_block_option = block_cache.get(bh1); CHECK(!ret_block_option); auto block1 = std::make_shared(); block_cache.insert(bh1, block1); auto ret_block = block_cache.get(bh1); CHECK(ret_block->hash == block1->hash); } TEST_CASE("insert entry in cache(no-lock)", "[rpc][commands][block_cache]") { evmc::bytes32 bh1{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; BlockCache block_cache(1, false); auto ret_block_option = block_cache.get(bh1); CHECK(!ret_block_option); auto block1 = std::make_shared(); block_cache.insert(bh1, block1); auto ret_block = block_cache.get(bh1); CHECK(ret_block->hash == block1->hash); } } // namespace silkworm ================================================ FILE: silkworm/core/common/bytes.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { using Bytes = evmc::bytes; class ByteView : public evmc::bytes_view { public: constexpr ByteView() noexcept = default; // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) constexpr ByteView(const evmc::bytes_view& other) noexcept : evmc::bytes_view{other.data(), other.size()} {} // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) ByteView(const Bytes& str) noexcept : evmc::bytes_view{str.data(), str.size()} {} constexpr ByteView(const uint8_t* data, size_type size) noexcept : evmc::bytes_view{data, size} {} template // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) constexpr ByteView(const uint8_t (&array)[N]) noexcept : evmc::bytes_view{array, N} {} template // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) constexpr ByteView(const std::array& array) noexcept : evmc::bytes_view{array.data(), N} {} template // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) constexpr ByteView(std::span span) noexcept : evmc::bytes_view{span.data(), span.size()} {} bool is_null() const noexcept { return data() == nullptr; } private: // see code style P28 using evmc::bytes_view::length; }; template using ByteSpan = std::span; struct BytesOrByteView : public std::variant { using std::variant::operator=; bool holds_bytes() const { return std::holds_alternative(*this); } BytesOrByteView substr(size_t offset) { return holds_bytes() ? BytesOrByteView{std::get(*this).substr(offset)} : BytesOrByteView{std::get(*this).substr(offset)}; } // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) operator ByteView() const { return holds_bytes() ? std::get(*this) : std::get(*this); } }; } // namespace silkworm ================================================ FILE: silkworm/core/common/bytes_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bytes.hpp" #include namespace silkworm { TEST_CASE("Byteviews") { Bytes source{'0', '1', '2'}; ByteView bv1(source); bv1.remove_prefix(3); REQUIRE(bv1.empty()); ByteView bv2{}; REQUIRE(bv2.empty()); REQUIRE(bv1 == bv2); REQUIRE_FALSE(bv1.data() == bv2.data()); REQUIRE(bv2.is_null()); } } // namespace silkworm ================================================ FILE: silkworm/core/common/bytes_to_string.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // Utilities for type casting #include #include #include #include namespace silkworm { // Cast between pointers to char and unsigned char (i.e. uint8_t) inline char* byte_ptr_cast(uint8_t* ptr) { return reinterpret_cast(ptr); } inline const char* byte_ptr_cast(const uint8_t* ptr) { return reinterpret_cast(ptr); } inline uint8_t* byte_ptr_cast(char* ptr) { return reinterpret_cast(ptr); } inline const uint8_t* byte_ptr_cast(const char* ptr) { return reinterpret_cast(ptr); } inline Bytes string_to_bytes(const std::string& s) { return {s.begin(), s.end()}; } inline ByteView string_view_to_byte_view(std::string_view v) { return {byte_ptr_cast(v.data()), v.size()}; } template ByteView array_to_byte_view(const std::array& array) { return ByteView{reinterpret_cast(array.data()), Size}; } inline std::string bytes_to_string(Bytes b) { return {b.begin(), b.end()}; } inline std::string_view byte_view_to_string_view(ByteView v) { return {byte_ptr_cast(v.data()), v.size()}; } inline std::span byte_view_to_str_span(ByteView v) { return {byte_ptr_cast(v.data()), v.size()}; } } // namespace silkworm ================================================ FILE: silkworm/core/common/decoding_result.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { // Error codes for RLP and other decoding enum class [[nodiscard]] DecodingError { kOverflow, kLeadingZero, kInputTooShort, kInputTooLong, kNonCanonicalSize, kUnexpectedLength, kUnexpectedString, kUnexpectedList, kUnexpectedListElements, kInvalidVInSignature, // v != 27 && v != 28 && v < 35, see EIP-155 kUnsupportedTransactionType, // EIP-2718 kInvalidFieldset, kUnexpectedEip2718Serialization, kInvalidHashesLength, // trie::Node decoding kInvalidMasksSubsets, // trie::Node decoding }; // TODO(C++23) Switch to std::expected using DecodingResult = tl::expected; } // namespace silkworm ================================================ FILE: silkworm/core/common/empty_hashes.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { using namespace evmc::literals; inline constexpr evmc::bytes32 kZeroHash = 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32; // Keccak-256 hash of an empty string, KEC(""). inline constexpr evmc::bytes32 kEmptyHash{0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470_bytes32}; // Keccak-256 hash of the RLP of an empty list, KEC("\xc0"). inline constexpr evmc::bytes32 kEmptyListHash{ 0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347_bytes32}; // Root hash of an empty trie. inline constexpr evmc::bytes32 kEmptyRoot{0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32}; } // namespace silkworm ================================================ FILE: silkworm/core/common/empty_hashes_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "empty_hashes.hpp" #include #include #include #include "bytes.hpp" #include "util.hpp" namespace silkworm { TEST_CASE("Empty hashes") { const ByteView empty_string; const ethash::hash256 hash_of_empty_string{keccak256(empty_string)}; CHECK(std::bit_cast(hash_of_empty_string) == kEmptyHash); const Bytes empty_list_rlp(1, rlp::kEmptyListCode); const ethash::hash256 hash_of_empty_list_rlp{keccak256(empty_list_rlp)}; CHECK(std::bit_cast(hash_of_empty_list_rlp) == kEmptyListHash); // See https://github.com/ethereum/yellowpaper/pull/852 const Bytes empty_string_rlp(1, rlp::kEmptyStringCode); const ethash::hash256 hash_of_empty_string_rlp{keccak256(empty_string_rlp)}; CHECK(std::bit_cast(hash_of_empty_string_rlp) == kEmptyRoot); } } // namespace silkworm ================================================ FILE: silkworm/core/common/endian.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "endian.hpp" #include namespace silkworm::endian { ByteView to_big_compact(const uint64_t value) { if (!value) { return {}; } SILKWORM_THREAD_LOCAL uint8_t full_be[sizeof(uint64_t)]; store_big_u64(&full_be[0], value); return zeroless_view(full_be); } ByteView to_big_compact(const intx::uint256& value) { if (!value) { return {}; } SILKWORM_THREAD_LOCAL uint8_t full_be[sizeof(intx::uint256)]; intx::be::store(full_be, value); return zeroless_view(full_be); } } // namespace silkworm::endian ================================================ FILE: silkworm/core/common/endian.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once /* Facilities to deal with byte order/endianness See https://en.wikipedia.org/wiki/Endianness */ #include #include #include #include #include #include namespace silkworm::endian { // NOLINTBEGIN(readability-identifier-naming) // Similar to boost::endian::load_big_u16 const auto load_big_u16 = intx::be::unsafe::load; // Similar to boost::endian::load_big_u32 const auto load_big_u32 = intx::be::unsafe::load; // Similar to boost::endian::load_big_u64 const auto load_big_u64 = intx::be::unsafe::load; // Similar to boost::endian::load_little_u16 const auto load_little_u16 = intx::le::unsafe::load; // Similar to boost::endian::load_little_u32 const auto load_little_u32 = intx::le::unsafe::load; // Similar to boost::endian::load_little_u64 const auto load_little_u64 = intx::le::unsafe::load; // Similar to boost::endian::store_big_u16 const auto store_big_u16 = intx::be::unsafe::store; // Similar to boost::endian::store_big_u32 const auto store_big_u32 = intx::be::unsafe::store; // Similar to boost::endian::store_big_u64 const auto store_big_u64 = intx::be::unsafe::store; // Similar to boost::endian::store_little_u16 const auto store_little_u16 = intx::le::unsafe::store; // Similar to boost::endian::store_little_u32 const auto store_little_u32 = intx::le::unsafe::store; // Similar to boost::endian::store_little_u64 const auto store_little_u64 = intx::le::unsafe::store; // NOLINTEND(readability-identifier-naming) //! \brief Transforms a uint64_t stored in memory with native endianness to it's compacted big endian byte form //! \param [in] value : the value to be transformed //! \return A ByteView (std::string_view) into an internal static buffer (thread specific) of the function //! \remarks each function call overwrites the buffer, therefore invalidating a previously returned result //! \remarks so each returned ByteView must be used immediately (before a further call to the same function). //! \remarks See Erigon TxIndex value //! \remarks A "compact" big endian form strips leftmost bytes valued to zero ByteView to_big_compact(uint64_t value); //! \brief Transforms a uint256 stored in memory with native endianness to it's compacted big endian byte form //! \param [in] value : the value to be transformed //! \return A ByteView (std::string_view) into an internal static buffer (thread specific) of the function //! \remarks each function call overwrites the buffer, therefore invalidating a previously returned result //! \remarks so each returned ByteView must be used immediately (before a further call to the same function) //! \remarks See Erigon TxIndex value //! \remarks A "compact" big endian form strips leftmost bytes valued to zero ByteView to_big_compact(const intx::uint256& value); //! \brief Parses unsigned integer from a compacted big endian byte form. //! \param [in] data : byte view of a compacted value. //! Its length must not be greater than the sizeof the UnsignedIntegral type; otherwise, kOverflow is returned. //! \param [out] out: the corresponding integer with native endianness. //! \return Success or kOverflow or kLeadingZero. //! \remarks A "compact" big endian form strips leftmost bytes valued to zero; //! if the input is not compact kLeadingZero is returned. template static DecodingResult from_big_compact(ByteView data, T& out) { if (data.size() > sizeof(T)) { return tl::unexpected{DecodingError::kOverflow}; } out = 0; if (data.empty()) { return {}; } if (data[0] == 0) { return tl::unexpected{DecodingError::kLeadingZero}; } auto* ptr{reinterpret_cast(&out)}; std::memcpy(ptr + (sizeof(T) - data.size()), &data[0], data.size()); out = intx::to_big_endian(out); return {}; } } // namespace silkworm::endian ================================================ FILE: silkworm/core/common/endian_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "endian.hpp" #include #include #include namespace silkworm::endian { TEST_CASE("16-bit Endian") { uint8_t bytes[2]; uint16_t value{0x1234}; store_big_u16(bytes, value); CHECK(bytes[0] == 0x12); CHECK(bytes[1] == 0x34); uint16_t be{load_big_u16(bytes)}; CHECK(be == value); uint16_t le{load_little_u16(bytes)}; CHECK(le == 0x3412); } TEST_CASE("32-bit Endian") { uint8_t bytes[4]; uint32_t value{0x12345678}; store_big_u32(bytes, value); CHECK(bytes[0] == 0x12); CHECK(bytes[1] == 0x34); CHECK(bytes[2] == 0x56); CHECK(bytes[3] == 0x78); uint32_t be{load_big_u32(bytes)}; CHECK(be == value); uint32_t le{load_little_u32(bytes)}; CHECK(le == 0x78563412); } TEST_CASE("64-bit Endian") { uint8_t bytes[8]; uint64_t value{0x123456789abcdef0}; store_big_u64(bytes, value); CHECK(bytes[0] == 0x12); CHECK(bytes[1] == 0x34); CHECK(bytes[2] == 0x56); CHECK(bytes[3] == 0x78); CHECK(bytes[4] == 0x9a); CHECK(bytes[5] == 0xbc); CHECK(bytes[6] == 0xde); CHECK(bytes[7] == 0xf0); uint64_t be{load_big_u64(bytes)}; CHECK(be == value); uint64_t le{load_little_u64(bytes)}; CHECK(le == 0xf0debc9a78563412); } static std::string hex_endian_swap(const std::string& native_hex) { std::string ret{}; for (unsigned int i = 0; i < native_hex.size(); i += 2) { ret.insert(0, native_hex.substr(i, 2)); } return ret; } TEST_CASE("Block as key and compact form") { const std::string block_num_hex{"000000005485ffde"}; // i.e. 1418067934 const std::string block_num_hex_rev{hex_endian_swap(block_num_hex)}; auto block_num{std::stoull(block_num_hex, nullptr, 16)}; REQUIRE(block_num == 1418067934u); SECTION("Block number as key") { // Check the sequence of bytes in memory ByteView block_num_view(reinterpret_cast(&block_num), sizeof(uint64_t)); if constexpr (std::endian::native == std::endian::little) { // Check we've switched to native endianness CHECK(to_hex(block_num_view) == block_num_hex_rev); } else { // Check our hex form matches input form CHECK(to_hex(block_num_view) == block_num_hex); } alignas(uint64_t) uint8_t block_num_as_key[8]; store_big_u64(&block_num_as_key[0], block_num); // Check data value is byte swapped if endianness requires auto block_num_from_key{*reinterpret_cast(block_num_as_key)}; if constexpr (std::endian::native == std::endian::little) { CHECK(block_num_from_key != block_num); } else { CHECK(block_num_from_key == block_num); } CHECK(intx::to_big_endian(block_num_from_key) == block_num); } SECTION("Block number as compact") { // Convert block number to compact and check initial zeroes are stripped auto block_num_compact_bytes{to_big_compact(block_num)}; CHECK(to_hex(block_num_compact_bytes) == "5485ffde"); // Convert back and check uint64_t out64{0}; REQUIRE(from_big_compact(block_num_compact_bytes, out64)); CHECK(out64 == block_num); // Try compact empty bytes Bytes empty_bytes{}; CHECK(zeroless_view(empty_bytes).empty()); // Try compact zeroed bytes Bytes zeroed_bytes(2, 0); CHECK(zeroless_view(zeroed_bytes).empty()); // Compact block == 0 CHECK(to_big_compact(0).empty()); // Try retrieve a compacted value from an empty Byte string REQUIRE(from_big_compact(Bytes{}, out64)); CHECK(out64 == 0u); // Try retrieve a compacted value from a too large Byte string Bytes extra_long_bytes(sizeof(uint64_t) + 1, 0); CHECK(from_big_compact(extra_long_bytes, out64) == tl::unexpected{DecodingError::kOverflow}); uint32_t out32{0}; const Bytes non_compact_be{*from_hex("00AB")}; CHECK(from_big_compact(non_compact_be, out32) == tl::unexpected{DecodingError::kLeadingZero}); } } } // namespace silkworm::endian ================================================ FILE: silkworm/core/common/hash_maps.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #if defined(SILKWORM_CORE_USE_ABSEIL) #include #include #else #include #include #endif namespace silkworm { /* Alias templates to fast hash maps and sets, such as Abseil "Swiss tables" The following aliases are defined: FlatHashMap – a hash map that might not have pointer stability. FlatHashSet – a hash set that might not have pointer stability. See https://abseil.io/docs/cpp/guides/container#hash-tables and https://abseil.io/docs/cpp/guides/container#fn:pointer-stability */ #if defined(SILKWORM_CORE_USE_ABSEIL) template using FlatHashMap = absl::flat_hash_map; template using FlatHashSet = absl::flat_hash_set; #else // Abseil is not compatible with Wasm due to its multi-threading features, // at least not under CMake, but see // https://github.com/abseil/abseil-cpp/pull/721 template using FlatHashMap = std::unordered_map; template using FlatHashSet = std::unordered_set; #endif } // namespace silkworm ================================================ FILE: silkworm/core/common/lru_cache.hpp ================================================ /* Copyright (c) 2014, lamerman 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 lamerman 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 HOLDER 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: Alexander Ponomarev * * Created on June 20, 2013, 5:09 PM * * Modified by Andrew Ashikhmin */ #pragma once #include #include #include #include #include #include namespace silkworm { #ifndef __wasm__ #define SILKWORM_LRU_CACHE_GUARD \ std::unique_lock lock; \ if (thread_safe_) { \ lock = std::unique_lock{access_}; \ } #else #define SILKWORM_LRU_CACHE_GUARD #endif template class LruCache { public: using key_value_pair_t = std::pair; using list_iterator_t = std::list::iterator; explicit LruCache(size_t max_size, bool thread_safe = false) : max_size_(max_size), thread_safe_(thread_safe) {} LruCache(const LruCache&) = default; LruCache(LruCache&&) noexcept = default; void put(const key_t& key, const value_t& value) { SILKWORM_LRU_CACHE_GUARD auto it = cache_items_map_.find(key); cache_items_list_.push_front(key_value_pair_t(key, value)); if (it != cache_items_map_.end()) { cache_items_list_.erase(it->second); cache_items_map_.erase(it); } cache_items_map_[key] = cache_items_list_.begin(); if (cache_items_map_.size() > max_size_) { auto last = cache_items_list_.end(); --last; cache_items_map_.erase(last->first); cache_items_list_.pop_back(); } } // this method is not thread-safe. Returns address of the element in the internal map const value_t* get(const key_t& key) { SILKWORM_ASSERT(!thread_safe_); return get_internal(key); } std::optional get_as_copy(const key_t& key) { SILKWORM_LRU_CACHE_GUARD auto val = get_internal(key); if (val == nullptr) { return std::nullopt; } return {*val}; } bool remove(const key_t& key) { SILKWORM_LRU_CACHE_GUARD auto it = cache_items_map_.find(key); if (it == cache_items_map_.end()) { return false; } cache_items_list_.erase(it->second); cache_items_map_.erase(it); return true; } size_t size() const noexcept { SILKWORM_LRU_CACHE_GUARD return cache_items_map_.size(); } size_t max_size() const noexcept { return max_size_; } void clear() noexcept { SILKWORM_LRU_CACHE_GUARD cache_items_map_.clear(); cache_items_list_.clear(); } private: const value_t* get_internal(const key_t& key) { auto it = cache_items_map_.find(key); if (it == cache_items_map_.end()) { return nullptr; } cache_items_list_.splice(cache_items_list_.begin(), cache_items_list_, it->second); return &(it->second->second); } std::list cache_items_list_; std::unordered_map cache_items_map_; size_t max_size_; bool thread_safe_; #ifndef __wasm__ mutable std::mutex access_; #endif }; } // namespace silkworm ================================================ FILE: silkworm/core/common/lru_cache_test.cpp ================================================ /* Copyright (c) 2014, lamerman 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 lamerman 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 HOLDER 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 "lru_cache.hpp" #include namespace silkworm { TEST_CASE("SimplePut") { LruCache cache_lru(1); cache_lru.put(7, 777); REQUIRE(cache_lru.get(7)); CHECK(777 == *cache_lru.get(7)); CHECK(1 == cache_lru.size()); } TEST_CASE("MissingValue") { LruCache cache_lru(1); CHECK(cache_lru.get(7) == nullptr); } TEST_CASE("KeepsAllValuesWithinCapacity") { static constexpr int kNumOfRecords = 100; static constexpr int kCacheCapacity = 50; LruCache cache_lru(kCacheCapacity); for (int i = 0; i < kNumOfRecords; ++i) { cache_lru.put(i, i); } for (int i = 0; i < kNumOfRecords - kCacheCapacity; ++i) { CHECK(cache_lru.get(i) == nullptr); } for (int i = kNumOfRecords - kCacheCapacity; i < kNumOfRecords; ++i) { REQUIRE(cache_lru.get(i)); CHECK(i == *cache_lru.get(i)); } size_t size = cache_lru.size(); CHECK(kCacheCapacity == size); } TEST_CASE("DiscardStaleElement") { LruCache cache_lru(3); cache_lru.put(1, 111); cache_lru.put(2, 222); cache_lru.put(3, 333); cache_lru.get(1); // refresh item 1 cache_lru.put(4, 444); // will cause item 2 removal REQUIRE(cache_lru.get(2) == nullptr); } TEST_CASE("GetWithCopy") { LruCache cache_lru(1); cache_lru.put(1, 111); REQUIRE(cache_lru.get(1)); REQUIRE(cache_lru.get_as_copy(1)); REQUIRE(!cache_lru.get_as_copy(2)); CHECK(111 == *cache_lru.get(1)); CHECK(111 == cache_lru.get_as_copy(1)); CHECK(1 == cache_lru.size()); } TEST_CASE("RemoveElement") { LruCache cache_lru(3); cache_lru.put(1, 111); cache_lru.put(2, 222); cache_lru.put(3, 333); REQUIRE(cache_lru.remove(2) == true); REQUIRE(cache_lru.remove(4) == false); REQUIRE(cache_lru.get(2) == nullptr); cache_lru.put(4, 444); REQUIRE(cache_lru.get(1) != nullptr); // element 1 is still here because removal freed 1 slot REQUIRE(cache_lru.get(3) != nullptr); REQUIRE(cache_lru.get(4) != nullptr); } } // namespace silkworm ================================================ FILE: silkworm/core/common/math.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::math { // Computes the least integer value not less than num template constexpr T int_ceil(double num) { if (num <= static_cast(std::numeric_limits::min())) { return std::numeric_limits::min(); } if (num >= static_cast(std::numeric_limits::max())) { return std::numeric_limits::max(); } const T i{static_cast(num)}; return num > static_cast(i) ? i + 1 : i; } } // namespace silkworm::math ================================================ FILE: silkworm/core/common/math_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "math.hpp" #include namespace silkworm::math { TEST_CASE("Integer ceil") { static_assert(int_ceil(-1.0E100) == std::numeric_limits::min()); static_assert(int_ceil(std::numeric_limits::min()) == std::numeric_limits::min()); static_assert(int_ceil(std::numeric_limits::min() + 0.5) == std::numeric_limits::min() + 1); static_assert(int_ceil(std::numeric_limits::min() + 1) == std::numeric_limits::min() + 1); static_assert(int_ceil(-2.9) == -2); static_assert(int_ceil(-2.5) == -2); static_assert(int_ceil(-2.4) == -2); static_assert(int_ceil(-2.0) == -2); static_assert(int_ceil(-0.0) == 0); static_assert(int_ceil(+0.0) == 0); static_assert(int_ceil(2.0) == 2); static_assert(int_ceil(2.4) == 3); static_assert(int_ceil(2.5) == 3); static_assert(int_ceil(2.9) == 3); static_assert(int_ceil(std::numeric_limits::max() - 1) == std::numeric_limits::max() - 1); static_assert(int_ceil(std::numeric_limits::max() - 0.5) == std::numeric_limits::max()); static_assert(int_ceil(std::numeric_limits::max()) == std::numeric_limits::max()); static_assert(int_ceil(1.0E100) == std::numeric_limits::max()); } } // namespace silkworm::math ================================================ FILE: silkworm/core/common/object_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #ifndef __wasm__ #include #endif #include #ifndef __wasm__ #define SILKWORM_DETAIL_OBJECT_POOL_GUARD \ std::unique_lock lock; \ if (thread_safe_) { \ lock = std::unique_lock{mutex_}; \ } #else #define SILKWORM_DETAIL_OBJECT_POOL_GUARD #endif namespace silkworm { template > class ObjectPool { public: explicit ObjectPool(bool thread_safe = false) : thread_safe_{thread_safe} {} // Not copyable nor movable ObjectPool(const ObjectPool&) = delete; ObjectPool& operator=(const ObjectPool&) = delete; void add(gsl::owner t) { SILKWORM_DETAIL_OBJECT_POOL_GUARD pool_.push({t, TDtor()}); } gsl::owner acquire() { SILKWORM_DETAIL_OBJECT_POOL_GUARD if (pool_.empty()) { return nullptr; } gsl::owner ret(pool_.top().release()); pool_.pop(); return ret; } bool empty() const { SILKWORM_DETAIL_OBJECT_POOL_GUARD return pool_.empty(); } size_t size() const { SILKWORM_DETAIL_OBJECT_POOL_GUARD return pool_.size(); } private: using PointerType = std::unique_ptr; std::stack> pool_{}; bool thread_safe_{false}; #ifndef __wasm__ mutable std::mutex mutex_; #endif }; } // namespace silkworm ================================================ FILE: silkworm/core/common/overloaded.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once namespace silkworm { // Helper type for std::visit // See https://en.cppreference.com/w/cpp/utility/variant/visit template struct Overloaded : Ts... { using Ts::operator()...; }; template Overloaded(Ts...) -> Overloaded; } // namespace silkworm ================================================ FILE: silkworm/core/common/random_number.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { class RandomNumber { public: // Use to generate integers uniformly distributed on the closed interval [a, b] explicit RandomNumber(uint64_t a = 0, uint64_t b = std::numeric_limits::max()) : distr_(a, b) {} // Not copyable nor movable RandomNumber(const RandomNumber&) = delete; RandomNumber& operator=(const RandomNumber&) = delete; uint64_t generate_one() { return distr_(generator_); } private: std::mt19937_64 generator_{std::random_device{}()}; // seed the generator randomly std::uniform_int_distribution distr_; }; } // namespace silkworm ================================================ FILE: silkworm/core/common/random_number_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "random_number.hpp" #include #include namespace silkworm { TEST_CASE("random numbers") { uint64_t a = 0; uint64_t b = 3; RandomNumber random_number(a, b); for (int i = 0; i < 100; ++i) { auto a_number = random_number.generate_one(); REQUIRE((a <= a_number && a_number <= b)); } } } // namespace silkworm ================================================ FILE: silkworm/core/common/small_map.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm { // SmallMap is a constexpr-friendly immutable map suitable for a small number of elements. template class SmallMap { public: using ValueType = std::pair; constexpr SmallMap() noexcept = default; constexpr SmallMap(std::initializer_list init) : size_(init.size()) { SILKWORM_ASSERT(size_ <= maximum_size); for (size_t i{0}; i < size_; ++i) { data_[i] = *(std::data(init) + i); } sort(); } template constexpr SmallMap(InputIt first, InputIt last) { for (InputIt it{first}; it != last; ++it) { SILKWORM_ASSERT(size_ < maximum_size); data_[size_++] = *it; } sort(); } constexpr SmallMap(const SmallMap& other) : size_{other.size_} { for (size_t i{0}; i < maximum_size; ++i) { data_[i] = other.data_[i]; } } constexpr SmallMap& operator=(const SmallMap& other) { if (this == &other) { return *this; } size_ = other.size_; for (size_t i{0}; i < maximum_size; ++i) { data_[i] = other.data_[i]; } return *this; } constexpr bool empty() const noexcept { return size_ == 0; } constexpr size_t size() const noexcept { return size_; } static constexpr size_t max_size() noexcept { return maximum_size; } constexpr auto begin() const noexcept { return data_.begin(); } constexpr auto end() const noexcept { return begin() + size_; } constexpr const T* find(const Key& key) const noexcept { // linear search is faster than binary for small sizes for (size_t i{0}; i < size_; ++i) { if (data_[i].first == key) { return &data_[i].second; } } return nullptr; } template NewKeyType = Key> std::map to_std_map() const { std::map ret; for (const auto& [key, val] : *this) { ret[NewKeyType(key)] = val; } return ret; } private: constexpr void sort() { std::sort(data_.begin(), data_.begin() + size_, [](const ValueType& a, const ValueType& b) { return a.first < b.first; }); } std::array data_{}; size_t size_{0}; }; template constexpr bool operator==(const SmallMap& a, const SmallMap& b) { return std::equal(a.begin(), a.end(), b.begin(), b.end()); } } // namespace silkworm ================================================ FILE: silkworm/core/common/small_map_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "small_map.hpp" #include namespace silkworm { TEST_CASE("SmallMap find") { static constexpr SmallMap kConfig{{20, 20.20}, {10, 10.10}, {30, 30.30}}; static_assert(!kConfig.find(0)); static_assert(*kConfig.find(10) == 10.10); static_assert(!kConfig.find(15)); static_assert(*kConfig.find(20) == 20.20); static_assert(!kConfig.find(25)); static_assert(*kConfig.find(30) == 30.30); static_assert(!kConfig.find(100)); } TEST_CASE("SmallMap to_std_map") { static constexpr SmallMap kSmallMap{{20, 20.20}, {10, 10.10}, {30, 30.30}}; static const std::map kStdMap{{20, 20.20}, {10, 10.10}, {30, 30.30}}; CHECK(kSmallMap.to_std_map() == kStdMap); } } // namespace silkworm ================================================ FILE: silkworm/core/common/test_util.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "test_util.hpp" #include #include namespace silkworm::test { std::vector sample_transactions() { std::vector transactions; transactions.resize(2); transactions[0].nonce = 172339; transactions[0].max_priority_fee_per_gas = 50 * kGiga; transactions[0].max_fee_per_gas = 50 * kGiga; transactions[0].gas_limit = 90'000; transactions[0].to = 0xe5ef458d37212a06e3f59d40c454e76150ae7c32_address; transactions[0].value = 1'027'501'080 * kGiga; transactions[0].data = {}; static_cast(transactions[0].set_v(27)); transactions[0].r = intx::from_string("0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353"); transactions[0].s = intx::from_string("0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804"); transactions[1].type = TransactionType::kDynamicFee; transactions[1].nonce = 1; transactions[1].max_priority_fee_per_gas = 5 * kGiga; transactions[1].max_fee_per_gas = 30 * kGiga; transactions[1].gas_limit = 1'000'000; transactions[1].to = {}; transactions[1].value = 0; transactions[1].data = *from_hex("602a6000556101c960015560068060166000396000f3600035600055"); static_cast(transactions[1].set_v(37)); transactions[1].r = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); transactions[1].s = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); return transactions; } std::vector sample_receipts() { std::vector receipts{}; receipts.resize(2); receipts[0].type = TransactionType::kLegacy; receipts[0].success = false; receipts[0].cumulative_gas_used = 0x32f05d; receipts[0].logs = { Log{ 0xea674fdde714fd979de3edf0f56aa9716b898ec8_address, {}, *from_hex("0x010043"), }, Log{ 0x44fd3ab8381cc3d14afa7c4af7fd13cdc65026e1_address, {to_bytes32(*from_hex("dead")), to_bytes32(*from_hex("abba"))}, *from_hex("0xaabbff780043"), }, }; receipts[1].type = TransactionType::kDynamicFee; receipts[1].success = true; receipts[1].cumulative_gas_used = 0xbeadd0; receipts[1].logs = {}; return receipts; } } // namespace silkworm::test ================================================ FILE: silkworm/core/common/test_util.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::test { //! Always Frontier rules. inline constexpr ChainConfig kFrontierConfig{ .chain_id = 1, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }; //! Enables London from genesis. inline constexpr ChainConfig kLondonConfig{ .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }; //! Enables Shanghai from genesis. inline constexpr ChainConfig kShanghaiConfig{ .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 0, }; //! Enables Prague from genesis. inline constexpr ChainConfig kPragueConfig{ .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 0, .cancun_time = 0, .prague_time = 0, }; inline const std::map kNetworkConfig{ {"Frontier", test::kFrontierConfig}, {"Homestead", { .chain_id = 1, .homestead_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"FrontierToHomesteadAt5", { .chain_id = 1, .homestead_block = 5, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"HomesteadToDaoAt5", { .chain_id = 1, .homestead_block = 0, .dao_block = 5, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"EIP150", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"HomesteadToEIP150At5", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 5, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"EIP158", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"Byzantium", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"EIP158ToByzantiumAt5", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 5, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"Constantinople", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"ConstantinopleFix", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"ByzantiumToConstantinopleFixAt5", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 5, .petersburg_block = 5, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"Istanbul", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"EIP2384", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .muir_glacier_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"Berlin", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .muir_glacier_block = 0, .berlin_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"London", test::kLondonConfig}, {"BerlinToLondonAt5", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .muir_glacier_block = 0, .berlin_block = 0, .london_block = 5, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"ArrowGlacier", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .arrow_glacier_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"GrayGlacier", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .gray_glacier_block = 0, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"Merge", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, }}, {"Paris", // same as Merge { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, }}, {"ArrowGlacierToMergeAtDiffC0000", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .arrow_glacier_block = 0, .terminal_total_difficulty = 0xC0000, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"ArrowGlacierToParisAtDiffC0000", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .arrow_glacier_block = 0, .terminal_total_difficulty = 0xC0000, .rule_set_config = protocol::EthashConfig{.validate_seal = false}, }}, {"Shanghai", test::kShanghaiConfig}, {"MergeToShanghaiAtTime15k", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 15'000, }}, {"ParisToShanghaiAtTime15k", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 15'000, }}, {"Cancun", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 0, .cancun_time = 0, }}, {"ShanghaiToCancunAtTime15k", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 0, .cancun_time = 15'000, }}, {"Prague", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 0, .cancun_time = 0, .prague_time = 0, }}, {"CancunToPragueAtTime15k", { .chain_id = 1, .homestead_block = 0, .tangerine_whistle_block = 0, .spurious_dragon_block = 0, .byzantium_block = 0, .constantinople_block = 0, .petersburg_block = 0, .istanbul_block = 0, .berlin_block = 0, .london_block = 0, .terminal_total_difficulty = 0, .shanghai_time = 0, .cancun_time = 0, .prague_time = 15'000, }}, }; std::vector sample_transactions(); std::vector sample_receipts(); } // namespace silkworm::test ================================================ FILE: silkworm/core/common/util.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include #include #include namespace silkworm { // ASCII -> hex value (0xff means bad [hex] char) static constexpr uint8_t kUnhexTable[256] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; // ASCII -> hex value << 4 (upper nibble) (0xff means bad [hex] char) static constexpr uint8_t kUnhexTable4[256] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; ByteView zeroless_view(ByteView data) { const auto is_zero_byte = [](const auto& b) { return b == 0x0; }; const auto first_nonzero_byte_it{std::ranges::find_if_not(data, is_zero_byte)}; return data.substr(static_cast(std::distance(data.begin(), first_nonzero_byte_it))); } std::string to_hex(ByteView bytes, bool with_prefix) { static constexpr std::string_view kHexDigits{"0123456789abcdef"}; std::string out(bytes.size() * 2 + (with_prefix ? 2 : 0), '\0'); char* dest{&out[0]}; if (with_prefix) { *dest++ = '0'; *dest++ = 'x'; } for (const auto& b : bytes) { *dest++ = kHexDigits[b >> 4]; // Hi *dest++ = kHexDigits[b & 0x0f]; // Lo } return out; } std::string abridge(std::string_view input, size_t length) { if (input.length() <= length) { return std::string(input); } return std::string(input.substr(0, length)) + "..."; } static uint8_t unhex_lut(uint8_t x) { return kUnhexTable[x]; } static uint8_t unhex_lut4(uint8_t x) { return kUnhexTable4[x]; } std::optional decode_hex_digit(char ch) noexcept { auto ret{unhex_lut(static_cast(ch))}; if (ret == 0xff) { return std::nullopt; } return ret; } std::optional from_hex(std::string_view hex) noexcept { if (has_hex_prefix(hex)) { hex.remove_prefix(2); } if (hex.empty()) { return Bytes{}; } size_t pos(hex.length() & 1); // "[0x]1" is legit and has to be treated as "[0x]01" Bytes out((hex.length() + pos) / 2, '\0'); const char* src{hex.data()}; const char* last = src + hex.length(); uint8_t* dst{&out[0]}; if (pos) { auto b{unhex_lut(static_cast(*src++))}; if (b == 0xff) { return std::nullopt; } *dst++ = b; } // following "while" is unrolling the loop when we have >= 4 target bytes // this is optional, but 5-10% faster while (last - src >= 8) { auto a{unhex_lut4(static_cast(*src++))}; auto b{unhex_lut(static_cast(*src++))}; auto c{unhex_lut4(static_cast(*src++))}; auto d{unhex_lut(static_cast(*src++))}; auto e{unhex_lut4(static_cast(*src++))}; auto f{unhex_lut(static_cast(*src++))}; auto g{unhex_lut4(static_cast(*src++))}; auto h{unhex_lut(static_cast(*src++))}; if ((b | d | f | h) == 0xff || (a | c | e | g) == 0xff) { return std::nullopt; } *dst++ = a | b; *dst++ = c | d; *dst++ = e | f; *dst++ = g | h; } while (src < last) { auto a{unhex_lut4(static_cast(*src++))}; auto b{unhex_lut(static_cast(*src++))}; if (a == 0xff || b == 0xff) { return std::nullopt; } *dst++ = a | b; } return out; } inline bool case_insensitive_char_comparer(char a, char b) { return (tolower(a) == tolower(b)); } bool iequals(const std::string_view a, const std::string_view b) { return (a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin(), case_insensitive_char_comparer)); } std::optional parse_size(const std::string& sizestr) { if (sizestr.empty()) { return 0ull; } static const std::regex kPattern{R"(^(\d*)(\.\d{1,3})?\ *?(B|KB|MB|GB|TB)?$)", std::regex_constants::icase}; std::smatch matches; if (!std::regex_search(sizestr, matches, kPattern, std::regex_constants::match_default)) { return std::nullopt; } std::string int_part, dec_part, suf_part; uint64_t multiplier{1}; // Default for bytes (B|b) int_part = matches[1].str(); if (!matches[2].str().empty()) { dec_part = matches[2].str().substr(1); } suf_part = matches[3].str(); if (!suf_part.empty()) { if (iequals(suf_part, "KB")) { multiplier = kKibi; } else if (iequals(suf_part, "MB")) { multiplier = kMebi; } else if (iequals(suf_part, "GB")) { multiplier = kGibi; } else if (iequals(suf_part, "TB")) { multiplier = kTebi; } } auto number{std::strtoull(int_part.c_str(), nullptr, 10)}; number *= multiplier; if (!dec_part.empty()) { // Use literals, so we don't deal with floats and doubles auto base{"1" + std::string(dec_part.size(), '0')}; auto b{std::strtoul(base.c_str(), nullptr, 10)}; auto d{std::strtoul(dec_part.c_str(), nullptr, 10)}; number += multiplier * d / b; } return number; } std::string human_size(uint64_t bytes, const char* unit) { static const char* suffix[]{"", "K", "M", "G", "T"}; uint32_t index{0}; double value{static_cast(bytes)}; while (value >= kKibi) { value /= kKibi; if (++index == (std::size(suffix) - 1)) { break; } } static constexpr size_t kBufferSize{64}; SILKWORM_THREAD_LOCAL char output[kBufferSize]; SILKWORM_ASSERT(std::snprintf(output, kBufferSize, "%.02lf %s%s", value, suffix[index], unit) > 0); return output; } size_t prefix_length(ByteView a, ByteView b) { size_t len{std::min(a.size(), b.size())}; for (size_t i{0}; i < len; ++i) { if (a[i] != b[i]) { return i; } } return len; } float to_float(const intx::uint256& n) noexcept { static constexpr float k2to64{18446744073709551616.}; // 2^64 const uint64_t* words{intx::as_words(n)}; auto res{static_cast(words[3])}; res = k2to64 * res + static_cast(words[2]); res = k2to64 * res + static_cast(words[1]); res = k2to64 * res + static_cast(words[0]); return res; } std::string snake_to_camel(std::string_view snake) { std::string camel; camel += static_cast(std::toupper(static_cast(snake[0]))); for (size_t i = 1; i < snake.length(); ++i) { if (snake[i] == '_' && (i + 1) < snake.length()) { camel += static_cast(std::toupper(static_cast(snake[++i]))); } else { camel += snake[i]; } } return camel; } } // namespace silkworm ================================================ FILE: silkworm/core/common/util.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include // intx does not include operator<< overloading for uint namespace intx { template inline std::ostream& operator<<(std::ostream& out, const uint& value) { out << "0x" << intx::hex(value); return out; } } // namespace intx namespace silkworm { //! \brief Strips leftmost zeroed bytes from byte sequence //! \param [in] data : The view to process //! \return A new view of the sequence ByteView zeroless_view(ByteView data); inline bool has_hex_prefix(std::string_view s) { return s.length() >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X'); } inline bool is_valid_hex(std::string_view s) { static const std::regex kHexRegex("^0x[0-9a-fA-F]+$"); return std::regex_match(s.data(), kHexRegex); } inline bool is_valid_dec(std::string_view s) { static const std::regex kHexRegex("^[0-9]+$"); return std::regex_match(s.data(), kHexRegex); } inline bool is_valid_hash(std::string_view s) { if (s.length() != 2 + kHashLength * 2) { return false; } return is_valid_hex(s); } inline bool is_valid_address(std::string_view s) { if (s.length() != 2 + kAddressLength * 2) { return false; } return is_valid_hex(s); } //! \brief Returns a string representing the hex form of provided string of bytes std::string to_hex(ByteView bytes, bool with_prefix = false); //! \brief Returns a string representing the hex form of provided integral template requires(std::is_integral_v && std::is_unsigned_v) std::string to_hex(T value, bool with_prefix = false) { uint8_t bytes[sizeof(T)]; intx::be::store(bytes, value); std::string hexed{to_hex(zeroless_view(bytes), with_prefix)}; if (hexed.size() == (with_prefix ? 2 : 0)) { hexed += "00"; } return hexed; } //! \brief Abridges a string to given length and eventually adds an ellipsis if input length is gt required length std::string abridge(std::string_view input, size_t length); std::optional decode_hex_digit(char ch) noexcept; std::optional from_hex(std::string_view hex) noexcept; // Parses a string input value representing a size in // human-readable format with qualifiers. eg "256MB" std::optional parse_size(const std::string& sizestr); // Converts a number of bytes in a human-readable format std::string human_size(uint64_t bytes, const char* unit = "B"); // Compares two strings for equality with case insensitivity bool iequals(std::string_view a, std::string_view b); // The length of the longest common prefix of a and b. size_t prefix_length(ByteView a, ByteView b); inline ethash::hash256 keccak256(ByteView view) { return ethash::keccak256(view.data(), view.size()); } //! \brief Create an intx::uint256 from a string supporting both fixed decimal and scientific notation template constexpr Int from_string_sci(const char* str) { auto s = str; auto m = Int{}; int num_digits = 0; int num_decimal_digits = 0; bool count_decimals{false}; char c = 0; while ((c = *s++)) { if (c == '.') { count_decimals = true; continue; } if (c == 'e') { if (*s++ != '+') intx::throw_(s); break; } if (num_digits++ > std::numeric_limits::digits10) { intx::throw_(s); } if (count_decimals) { ++num_decimal_digits; } const auto d = intx::from_dec_digit(c); m = m * Int{10} + d; if (m < d) { intx::throw_(s); } } if (!c) { if (num_decimal_digits == 0) return m; intx::throw_(s); } int e = 0; while ((c = *s++)) { const auto d = intx::from_dec_digit(c); e = e * 10 + d; if (e < d) { intx::throw_(s); } } if (e < num_decimal_digits) { intx::throw_(s); } auto x = m; auto exp = e - num_decimal_digits; while (exp > 0) { x *= Int{10}; --exp; } return x; } inline std::ostream& operator<<(std::ostream& out, ByteView bytes) { for (const auto& b : bytes) { out << std::hex << std::setw(2) << std::setfill('0') << int{b}; } out << std::dec; return out; } inline std::ostream& operator<<(std::ostream& out, const Bytes& bytes) { out << to_hex(bytes); return out; } float to_float(const intx::uint256&) noexcept; std::string snake_to_camel(std::string_view snake); } // namespace silkworm ================================================ FILE: silkworm/core/common/util_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include #include namespace silkworm { using namespace evmc::literals; TEST_CASE("Hex") { CHECK(decode_hex_digit('g').has_value() == false); auto parsed_bytes = from_hex(""); CHECK((parsed_bytes.has_value() == true && parsed_bytes->empty())); parsed_bytes = from_hex("0x"); CHECK((parsed_bytes.has_value() == true && parsed_bytes->empty())); parsed_bytes = from_hex("0xg"); CHECK(parsed_bytes.has_value() == false); Bytes expected_bytes{0x0}; parsed_bytes = from_hex("0"); CHECK((parsed_bytes.has_value() == true && parsed_bytes.value() == expected_bytes)); parsed_bytes = from_hex("0x0"); CHECK((parsed_bytes.has_value() == true && parsed_bytes.value() == expected_bytes)); expected_bytes = Bytes{0x0a}; parsed_bytes = from_hex("0xa"); CHECK((parsed_bytes.has_value() == true && parsed_bytes.value() == expected_bytes)); parsed_bytes = from_hex("0x0a"); CHECK((parsed_bytes.has_value() == true && parsed_bytes.value() == expected_bytes)); expected_bytes = {0x0a, 0x1f}; parsed_bytes = from_hex("0xa1f"); CHECK((parsed_bytes.has_value() == true && parsed_bytes.value() == expected_bytes)); parsed_bytes = from_hex("0x0a1f"); CHECK((parsed_bytes.has_value() == true && parsed_bytes.value() == expected_bytes)); std::string src(24, '1'); Bytes expected(12, 0x11); for (size_t i = 0; i < 24; ++i) { auto parsed = from_hex(src); CHECK((parsed.has_value() == true && parsed.value() == expected)); src[i] = 'g'; CHECK(from_hex(src).has_value() == false); src[i] = '1'; } } TEST_CASE("Integrals to hex") { uint8_t uint8{10}; CHECK(to_hex(uint8, true) == "0x0a"); uint8 = 16; CHECK(to_hex(uint8, true) == "0x10"); uint8 = UINT8_MAX; CHECK(to_hex(uint8, true) == "0xff"); uint8 = 0; CHECK(to_hex(uint8, true) == "0x00"); uint16_t uint16{256}; CHECK(to_hex(uint16, true) == "0x0100"); uint16 = 584; CHECK(to_hex(uint16, true) == "0x0248"); uint16 = UINT16_MAX; CHECK(to_hex(uint16, true) == "0xffff"); uint32_t uint32{5642869}; CHECK(to_hex(uint32, false) == "561a75"); uint32 = UINT32_MAX; CHECK(to_hex(uint32, false) == "ffffffff"); uint32_t uint64{5642869}; CHECK(to_hex(uint64, false) == "561a75"); } TEST_CASE("Zeroless view") { SECTION("from bytes32") { CHECK(to_hex(zeroless_view((0x0000000000000000000000000000000000000000000000000000000000000000_bytes32).bytes)).empty()); CHECK(to_hex(zeroless_view((0x000000000000000000000000000000000000000000000000000000000004bc00_bytes32).bytes)) == "04bc00"); CHECK(to_hex(zeroless_view((0x100000000000000000000000000000000000000000000000000000000004bc00_bytes32).bytes)) == "100000000000000000000000000000000000000000000000000000000004bc00"); } SECTION("from Bytes") { Bytes block_num_as_bytes(sizeof(BlockNum), '\0'); intx::be::unsafe::store(block_num_as_bytes.data(), 12'209'569); CHECK(to_hex(zeroless_view(block_num_as_bytes)) == "ba4da1"); } SECTION("from ByteView") { CHECK(to_hex(zeroless_view(ByteView{})).empty()); CHECK(to_hex(zeroless_view(ByteView{{0x01, 0x00}})) == "0100"); CHECK(to_hex(zeroless_view(ByteView{{00, 01}})) == "01"); } } TEST_CASE("to_bytes32") { CHECK(to_hex(to_bytes32(*from_hex("05"))) == "0000000000000000000000000000000000000000000000000000000000000005"); CHECK(to_hex(to_bytes32(*from_hex("0x05"))) == "0000000000000000000000000000000000000000000000000000000000000005"); CHECK(to_hex(to_bytes32(*from_hex("9d36d8120b564f654564a91259a6ca6d37d6473827d45210190ad10f8ca451f2"))) == "9d36d8120b564f654564a91259a6ca6d37d6473827d45210190ad10f8ca451f2"); CHECK(to_hex(to_bytes32(*from_hex("0X9d36d8120b564f654564a91259a6ca6d37d6473827d45210190ad10f8ca451f2"))) == "9d36d8120b564f654564a91259a6ca6d37d6473827d45210190ad10f8ca451f2"); CHECK(to_hex(to_bytes32(*from_hex("7576351873263824fff23784264823469344629364396429864239864938264a" "8236423964bbb009874e"))) == "7576351873263824fff23784264823469344629364396429864239864938264a"); } TEST_CASE("iequals") { std::string a{"Hello World"}; std::string b{"Hello wOrld"}; std::string c{"Hello World "}; CHECK(iequals(a, b)); CHECK(!iequals(a, c)); } TEST_CASE("abridge") { std::string a{"0x1234567890abcdef"}; std::string b{abridge(a, 6)}; CHECK(b == "0x1234..."); b = abridge(a, a.size() + 1); CHECK(b == a); } TEST_CASE("parse_size") { std::optional size{parse_size("")}; CHECK((size && *size == 0)); static_assert(kKibi == 1024ull); static_assert(kMebi == 1024ull * 1024ull); static_assert(kGibi == 1024ull * 1024ull * 1024ull); static_assert(kTebi == 1024ull * 1024ull * 1024ull * 1024ull); size = parse_size("128"); CHECK((size && *size == 128)); size = parse_size("256B"); CHECK((size && *size == 256)); size = parse_size("640KB"); CHECK((size && *size == 640 * kKibi)); size = parse_size("75MB"); CHECK((size && *size == 75 * kMebi)); size = parse_size("400GB"); CHECK((size && *size == 400 * kGibi)); size = parse_size("2TB"); CHECK((size && *size == 2 * kTebi)); size = parse_size(".5TB"); CHECK((size && *size == (kTebi / 2))); size = parse_size("0.5TB"); CHECK((size && *size == (kTebi / 2))); size = parse_size("0.5 TB"); CHECK((size && *size == (kTebi / 2))); CHECK(!parse_size("ABBA")); } TEST_CASE("human_size") { uint64_t val{1 * kTebi}; CHECK(human_size(val) == "1.00 TB"); val += 512 * kGibi; CHECK(human_size(val) == "1.50 TB"); val = 128; CHECK(human_size(val) == "128.00 B"); val = kKibi; CHECK(human_size(val) == "1.00 KB"); } TEST_CASE("intx::uint256 from scientific notation string") { static constexpr intx::uint256 kMainnetTTD{intx::from_string("58750000000000000000000")}; CHECK(from_string_sci("5.875e+22") == kMainnetTTD); CHECK(from_string_sci("58750000000000000000000") == kMainnetTTD); static constexpr intx::uint256 kSepoliaTTD{intx::from_string("17000000000000000")}; CHECK(from_string_sci("1.7e+16") == kSepoliaTTD); CHECK(from_string_sci("17000000000000000") == kSepoliaTTD); CHECK(from_string_sci("0") == intx::from_string("0")); CHECK(from_string_sci("0e+0") == intx::from_string("0")); CHECK(from_string_sci("0.0e+1") == intx::from_string("0")); CHECK(from_string_sci("18") == intx::from_string("18")); CHECK(from_string_sci("18e+0") == intx::from_string("18")); CHECK(from_string_sci("18e+1") == intx::from_string("180")); CHECK(from_string_sci("18.1e+1") == intx::from_string("181")); CHECK(from_string_sci("18e+2") == intx::from_string("1800")); CHECK(from_string_sci("18.1e+2") == intx::from_string("1810")); CHECK(from_string_sci("18.12e+2") == intx::from_string("1812")); static constexpr char kMaxFixedDecimalNotation[] = "115792089237316195423570985008687907853269984665640564039457584007913129639935"; CHECK(from_string_sci(kMaxFixedDecimalNotation) == std::numeric_limits::max()); static constexpr char kMaxScientificNotation[] = "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77"; CHECK(from_string_sci(kMaxScientificNotation) == std::numeric_limits::max()); } TEST_CASE("intx::uint256 to_float") { CHECK(to_float(0) == 0.f); CHECK(to_float(1) == 1.f); CHECK(to_float(24) == 24.f); CHECK(to_float(intx::from_string("1000000000000000000000000")) == 1e24f); } TEST_CASE("print intx::uint256") { const intx::uint256 i{intx::from_string("1000000000000000000000000")}; CHECK(test_util::null_stream() << i); } TEST_CASE("print Bytes") { Bytes b{}; CHECK(test_util::null_stream() << b); } TEST_CASE("print ByteView") { ByteView bv1; CHECK(test_util::null_stream() << bv1); Bytes b{*from_hex("0x0608")}; ByteView bv2{b}; CHECK(test_util::null_stream() << bv2); } } // namespace silkworm ================================================ FILE: silkworm/core/concurrency/resettable_once_flag.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #ifdef SILKWORM_CORE_USE_ABSEIL #include #endif namespace silkworm { #ifdef SILKWORM_CORE_USE_ABSEIL // Resettable once_flag. Helper class for lazy evaluation of derived fields such as transaction hash & sender. // On one hand, we want such evaluation to happen exactly once and be safe to invoke concurrently (call_once). // On the other hand, we need to re-calculate when the inputs to the evaluation change (thus resettable). // N.B. This version is based on absl::call_once. class ResettableOnceFlag { public: constexpr ResettableOnceFlag() = default; ResettableOnceFlag(const ResettableOnceFlag& other) { const uint32_t other_flag{other.flag_.load(std::memory_order_acquire)}; if (other_flag == absl::base_internal::kOnceDone) { flag_.store(absl::base_internal::kOnceDone, std::memory_order_release); } else { // Have to re-evaluate if the other is in the middle of calculations (other_flag == kOnceRunning || kOnceWaiter) flag_.store(0, std::memory_order_release); } } ResettableOnceFlag& operator=(const ResettableOnceFlag& other) { if (this == &other) { return *this; } const uint32_t other_flag{other.flag_.load(std::memory_order_acquire)}; if (other_flag == absl::base_internal::kOnceDone) { flag_.store(absl::base_internal::kOnceDone, std::memory_order_release); } else { // Have to re-evaluate if the other is in the middle of calculations (other_flag == kOnceRunning || kOnceWaiter) flag_.store(0, std::memory_order_release); } return *this; } void reset() { flag_.store(0, std::memory_order_release); } template void call_once(Callable&& fn, Args&&... args) { std::atomic* once{&flag_}; const uint32_t s{once->load(std::memory_order_acquire)}; if (s != absl::base_internal::kOnceDone) [[unlikely]] { absl::base_internal::CallOnceImpl( once, absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL, std::forward(fn), std::forward(args)...); } } private: std::atomic flag_{0}; }; #else // Warning: this version is only suitable for protecting lazy fields in a single-threaded environment. // In a multi-threaded environment use the Abseil-based version above. class ResettableOnceFlag { public: constexpr ResettableOnceFlag() = default; ResettableOnceFlag(const ResettableOnceFlag&) = default; ResettableOnceFlag& operator=(const ResettableOnceFlag&) = default; void reset() { done_ = false; } template void call_once(Callable&& fn, Args&&... args) { if (!done_) { std::invoke(std::forward(fn), std::forward(args)...); done_ = true; } } private: bool done_{false}; }; #endif } // namespace silkworm ================================================ FILE: silkworm/core/crypto/ecdsa.c ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ecdsa.h" #include #include #include #include //! \brief Tries recover public key used for message signing. static bool recover(uint8_t public_key[65], const uint8_t message[32], const uint8_t signature[64], uint8_t recovery_id, const secp256k1_context* context) { secp256k1_ecdsa_recoverable_signature sig; if (!secp256k1_ecdsa_recoverable_signature_parse_compact(context, &sig, signature, recovery_id)) { return false; } secp256k1_pubkey pub_key; if (!secp256k1_ecdsa_recover(context, &pub_key, &sig, message)) { return false; } size_t key_len = 65; return secp256k1_ec_pubkey_serialize(context, public_key, &key_len, &pub_key, SECP256K1_EC_UNCOMPRESSED); } //! Tries extract address from recovered public key //! \param [in] public_key: The recovered public key //! \return Whether the recovery has succeeded. static bool public_key_to_address(uint8_t out[20], const uint8_t public_key[65]) { if (public_key[0] != 4u) { return false; } // Ignore first byte of public key const union ethash_hash256 key_hash = ethash_keccak256(public_key + 1, 64); memcpy(out, &key_hash.bytes[12], 20); return true; } bool silkworm_recover_address(uint8_t out[20], const uint8_t message[32], const uint8_t signature[64], uint8_t recovery_id, const secp256k1_context* context) { uint8_t public_key[65]; if (!recover(public_key, message, signature, recovery_id, context)) { return false; } return public_key_to_address(out, public_key); } ================================================ FILE: silkworm/core/crypto/ecdsa.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // See Yellow Paper, Appendix F "Signing Transactions" #include #include #include #include #if defined(__cplusplus) extern "C" { #endif enum { SILKWORM_SECP256K1_CONTEXT_FLAGS = (SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY) }; //! \brief Tries recover the address used for message signing //! \param [in] message : the signed message //! \param [in] signature : the signature //! \param [in] recovery_id : the recovery id (0, 1, 2 or 3) //! \param [in] context: a pointer to an existing secp256k1 context //! \return Whether the recovery has succeeded bool silkworm_recover_address(uint8_t out[20], const uint8_t message[32], const uint8_t signature[64], uint8_t recovery_id, const secp256k1_context* context); #if defined(__cplusplus) } #endif ================================================ FILE: silkworm/core/crypto/secp256k1n.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "secp256k1n.hpp" namespace silkworm { bool is_valid_signature(const intx::uint256& r, const intx::uint256& s, bool homestead) noexcept { if (!r || !s) { return false; } if (r >= kSecp256k1n || s >= kSecp256k1n) { return false; } // https://eips.ethereum.org/EIPS/eip-2 if (homestead && s > kSecp256k1Halfn) { return false; } return true; } } // namespace silkworm ================================================ FILE: silkworm/core/crypto/secp256k1n.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // See Yellow Paper, Appendix F "Signing Transactions" // and EIP-2: Homestead Hard-fork Changes. #include #include namespace silkworm { // See Appendix F "Signing Transactions" of the Yellow Paper. inline constexpr intx::uint256 kSecp256k1n{ intx::from_string("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141")}; inline constexpr intx::uint256 kSecp256k1Halfn{kSecp256k1n >> 1}; // Verifies whether the signature values are valid with // the given chain rules. //! Verifies whether the signature values are valid with the provided chain rules //! \param [in] r : signature's r //! \param [in] s : signature's s //! \param [in] homestead : whether the chain has homestead rules //! \return True or false bool is_valid_signature(const intx::uint256& r, const intx::uint256& s, bool homestead) noexcept; } // namespace silkworm ================================================ FILE: silkworm/core/crypto/secp256k1n_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "secp256k1n.hpp" #include namespace silkworm { TEST_CASE("is_valid_signature") { bool homestead = false; CHECK(!is_valid_signature(0, 0, homestead)); CHECK(!is_valid_signature(0, 1, homestead)); CHECK(!is_valid_signature(1, 0, homestead)); CHECK(is_valid_signature(1, 1, homestead)); CHECK(is_valid_signature(1, kSecp256k1Halfn, homestead)); CHECK(is_valid_signature(1, kSecp256k1Halfn + 1, homestead)); CHECK(is_valid_signature(kSecp256k1n - 1, kSecp256k1n - 1, homestead)); CHECK(!is_valid_signature(kSecp256k1n - 1, kSecp256k1n, homestead)); CHECK(!is_valid_signature(kSecp256k1n, kSecp256k1n - 1, homestead)); CHECK(!is_valid_signature(kSecp256k1n, kSecp256k1n, homestead)); homestead = true; CHECK(!is_valid_signature(0, 0, homestead)); CHECK(!is_valid_signature(0, 1, homestead)); CHECK(!is_valid_signature(1, 0, homestead)); CHECK(is_valid_signature(1, 1, homestead)); CHECK(is_valid_signature(1, kSecp256k1Halfn, homestead)); CHECK(!is_valid_signature(1, kSecp256k1Halfn + 1, homestead)); CHECK(!is_valid_signature(kSecp256k1n - 1, kSecp256k1n - 1, homestead)); CHECK(!is_valid_signature(kSecp256k1n - 1, kSecp256k1n, homestead)); CHECK(!is_valid_signature(kSecp256k1n, kSecp256k1n - 1, homestead)); CHECK(!is_valid_signature(kSecp256k1n, kSecp256k1n, homestead)); } } // namespace silkworm ================================================ FILE: silkworm/core/execution/call_tracer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call_tracer.hpp" #include #include #include #include #include #include #include using namespace evmone; using namespace evmone::baseline; // The following functions have been temporarily copied from evmone because not exported or need changes. // We need to ask evmone for it to be exported/modified or an extended tracing interface (e.g. on_instruction_end?). namespace { //! Copy of evmone::check_requirements: not exported template evmc_status_code check_requirements( const CostTable& cost_table, int64_t& gas_left, const uint256* stack_top, const uint256* stack_bottom) noexcept { static_assert( !instr::has_const_gas_cost(Op) || instr::gas_costs[EVMC_FRONTIER][Op] != instr::undefined, "undefined instructions must not be handled by check_requirements()"); auto gas_cost = instr::gas_costs[EVMC_FRONTIER][Op]; // Init assuming const cost. if constexpr (!instr::has_const_gas_cost(Op)) { gas_cost = cost_table[Op]; // If not, load the cost from the table. // Negative cost marks an undefined instruction. // This check must be first to produce correct error code. if (INTX_UNLIKELY(gas_cost < 0)) return EVMC_UNDEFINED_INSTRUCTION; } // Check stack requirements first. This is order is not required, // but it is nicer because complete gas check may need to inspect operands. if constexpr (instr::traits[Op].stack_height_change > 0) { static_assert(instr::traits[Op].stack_height_change == 1, "unexpected instruction with multiple results"); if (INTX_UNLIKELY(stack_top == stack_bottom + StackSpace::limit)) return EVMC_STACK_OVERFLOW; } if constexpr (instr::traits[Op].stack_height_required > 0) { // Check stack underflow using pointer comparison <= (better optimization). static constexpr int kMinOffset = instr::traits[Op].stack_height_required - 1; if (INTX_UNLIKELY(stack_top <= stack_bottom + kMinOffset)) return EVMC_STACK_UNDERFLOW; } if (INTX_UNLIKELY((gas_left -= gas_cost) < 0)) { // NOLINT(*-assignment-in-if-condition) return EVMC_OUT_OF_GAS; } return EVMC_SUCCESS; } //! Adaptation of evmone::grow_memory: we need just to check gas requirements w/o growing memory int64_t check_memory_gas(int64_t gas_left, Memory& memory, uint64_t new_size) noexcept { const auto new_words = static_cast(silkworm::num_words(new_size)); const auto current_words = static_cast(memory.size() / word_size); const auto new_cost = 3 * new_words + new_words * new_words / 512; const auto current_cost = 3 * current_words + current_words * current_words / 512; const auto cost = new_cost - current_cost; gas_left -= cost; // We *must* avoid growing memory up here otherwise the subsequent gas costs change and block execution fails // (e.g. block 2'310'926 on Sepolia) /*if (gas_left >= 0) [[likely]] memory.grow(static_cast(new_words * word_size));*/ return gas_left; } //! Adaptation of evmone::check_memory: we need just to check gas requirements w/o growing memory bool check_memory_gas(int64_t& gas_left, Memory& memory, const uint256& offset, uint64_t size) noexcept { if (((offset[3] | offset[2] | offset[1]) != 0) || (offset[0] > max_buffer_size)) return false; // There is "branch-less" variant of this using | instead of ||, but benchmarks difference // is within noise. This should be decided when moving the implementation to intx. const auto new_size = static_cast(offset) + size; if (new_size > memory.size()) gas_left = check_memory_gas(gas_left, memory, new_size); return gas_left >= 0; // Always true for no-grow case. } //! Adaptation of evmone::check_memory: we need just to check gas requirements w/o growing memory inline bool check_memory_gas(int64_t& gas_left, Memory& memory, const uint256& offset, const uint256& size) noexcept { if (size == 0) // Copy of size 0 is always valid (even if offset is huge). return true; // This check has 3 same word checks with the check above. // However, compilers do decent although not perfect job unifying common instructions. if (((size[3] | size[2] | size[1]) != 0) || (size[0] > max_buffer_size)) return false; return check_memory_gas(gas_left, memory, offset, static_cast(size)); } } // namespace template inline evmc_status_code check_preconditions(const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& state) noexcept { const auto& cost_table{get_baseline_cost_table(state.rev, state.analysis.baseline->eof_header().version)}; return check_requirements(cost_table, gas, stack_top, stack_top - stack_height); } namespace silkworm { void CallTracer::on_execution_start(evmc_revision /*rev*/, const evmc_message& msg, evmone::bytes_view /*code*/) noexcept { if (msg.kind == EVMC_CALLCODE) { traces_.senders.insert(msg.sender); traces_.recipients.insert(msg.code_address); } else if (msg.kind == EVMC_DELEGATECALL) { traces_.senders.insert(msg.recipient); traces_.recipients.insert(msg.code_address); } else { traces_.senders.insert(msg.sender); traces_.recipients.insert(msg.recipient); } } template void on_create_start(const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& state, const IntraBlockState& intra_block_state, CallTraces& traces) { if (const auto status{check_preconditions(stack_top, stack_height, gas, state)}; status != EVMC_SUCCESS) { return; // Early failure in pre-execution checks, do not trace anything for compatibility w/ Erigon } if (stack_height < 3 + 1 * (Op == Opcode::OP_CREATE2)) { return; // Invariant break for current implementation of OP_CREATE or OP_CREATE2, let's handle gracefully. } StackTop stack{const_cast(stack_top)}; // NOLINT(cppcoreguidelines-pro-type-const-cast) const auto init_code_offset_u256 = stack[1]; const auto init_code_size_u256 = stack[2]; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) if (!check_memory_gas(gas, const_cast(state.memory), init_code_offset_u256, init_code_size_u256)) { return; // The execution has run of out-of-gas during contract deployment, do not trace anything } const auto init_code_offset = static_cast(init_code_offset_u256); if (init_code_offset >= state.memory.size()) { return; // Invariant break for current implementation of OP_CREATE2, let's handle gracefully. } const auto init_code_size = static_cast(init_code_size_u256); if (init_code_size >= state.memory.size() - init_code_offset) { return; // Invariant break for current implementation of OP_CREATE2, let's handle gracefully. } if (state.rev >= EVMC_SHANGHAI && init_code_size > 0xC000) { return; // The execution has run of out-of-gas during contract deployment, do not trace anything } const auto init_code_word_cost = 6 * (Op == Opcode::OP_CREATE2) + 2 * (state.rev >= EVMC_SHANGHAI); const auto init_code_cost = static_cast(silkworm::num_words(init_code_size)) * init_code_word_cost; if (gas - init_code_cost < 0) { return; // The execution has run of out-of-gas during contract deployment, do not trace anything } evmc::address contract_address; if (Op == Opcode::OP_CREATE) { const uint64_t nonce{intra_block_state.get_nonce(state.msg->recipient)}; contract_address = create_address(state.msg->recipient, nonce); } else { SILKWORM_ASSERT(Op == Opcode::OP_CREATE2); const evmc::bytes32 salt2{intx::be::store(stack[3])}; auto init_code_hash{ init_code_size > 0 ? ethash::keccak256(&state.memory.data()[init_code_offset], init_code_size) : ethash_hash256{}}; contract_address = create2_address(state.msg->recipient, salt2, init_code_hash.bytes); } traces.senders.insert(state.msg->recipient); traces.recipients.insert(contract_address); } void CallTracer::on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& state, const IntraBlockState& intra_block_state) noexcept { const auto op_code = state.original_code[pc]; if (op_code == evmc_opcode::OP_CREATE) { on_create_start(stack_top, stack_height, gas, state, intra_block_state, traces_); } else if (op_code == evmc_opcode::OP_CREATE2) { on_create_start(stack_top, stack_height, gas, state, intra_block_state, traces_); } } void CallTracer::on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept { traces_.senders.insert(address); traces_.recipients.insert(beneficiary); } void CallTracer::on_block_end(const silkworm::Block& block) noexcept { traces_.recipients.insert(block.header.beneficiary); for (const auto& ommer : block.ommers) { traces_.recipients.insert(ommer.beneficiary); } } } // namespace silkworm ================================================ FILE: silkworm/core/execution/call_tracer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wattributes" #include #pragma GCC diagnostic pop #include namespace silkworm { //! CallTracer collects source and destination account addresses touched during execution by tracing EVM calls. class CallTracer : public EvmTracer { public: explicit CallTracer(CallTraces& traces) : traces_{traces} {} CallTracer(const CallTracer&) = delete; CallTracer& operator=(const CallTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& state, const IntraBlockState& intra_block_state) noexcept override; void on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept override; void on_block_end(const silkworm::Block& block) noexcept override; private: CallTraces& traces_; }; } // namespace silkworm ================================================ FILE: silkworm/core/execution/evm.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { class DelegatingTracer : public evmone::Tracer { public: explicit DelegatingTracer(EvmTracer& tracer, IntraBlockState& intra_block_state) noexcept : tracer_(tracer), intra_block_state_(intra_block_state) {} private: void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override { tracer_.on_execution_start(rev, msg, code); } void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& state) noexcept override { tracer_.on_instruction_start(pc, stack_top, stack_height, gas, state, intra_block_state_); } void on_execution_end(const evmc_result& result) noexcept override { tracer_.on_execution_end(result, intra_block_state_); } friend class EVM; EvmTracer& tracer_; IntraBlockState& intra_block_state_; }; #ifdef __wasm__ evmc::VM EVM::evm1_{evmc_create_evmone()}; // we cannot use SILKWORM_THREAD_LOCAL i.e. static in WASM (duplicate-decl-specifier) #else SILKWORM_THREAD_LOCAL evmc::VM EVM::evm1_{evmc_create_evmone()}; #endif // __wasm__ EVM::EVM(const Block& block, IntraBlockState& state, const ChainConfig& config) noexcept : beneficiary{block.header.beneficiary}, block_{block}, state_{state}, config_{config} {} EVM::~EVM() { vm_impl().remove_tracers(); } CallResult EVM::execute(const Transaction& txn, uint64_t gas) noexcept { SILKWORM_ASSERT(txn.sender()); // sender must be valid txn_ = &txn; const bool contract_creation{!txn.to.has_value()}; const evmc::address destination{contract_creation ? evmc::address{} : *txn.to}; const evmc_message message{ .kind = contract_creation ? EVMC_CREATE : EVMC_CALL, .gas = static_cast(gas), .recipient = destination, .sender = *txn.sender(), .input_data = txn.data.data(), .input_size = txn.data.size(), .value = intx::be::store(txn.value), .code_address = destination, }; evmc::Result res{contract_creation ? create(message) : call(message)}; const auto gas_left = static_cast(res.gas_left); const auto gas_refund = static_cast(res.gas_refund); return {ValidationResult::kOk, res.status_code, gas_left, gas_refund, std::nullopt, {res.output_data, res.output_size}}; } evmc::Result EVM::create(const evmc_message& message) noexcept { evmc::Result res{EVMC_SUCCESS, message.gas, 0}; auto value{intx::be::load(message.value)}; const auto owned_funds = state_.get_balance(message.sender); if (!bailout && owned_funds < value) { res.status_code = EVMC_INSUFFICIENT_BALANCE; for (auto tracer : tracers_) { tracer.get().on_pre_check_failed(res.raw(), message); } return res; } const uint64_t nonce{state_.get_nonce(message.sender)}; if (nonce + 1 < nonce) { // EIP-2681: Limit account nonce to 2^64-1 // See also https://github.com/ethereum/go-ethereum/blob/v1.10.13/core/vm/evm.go#L426 res.status_code = EVMC_ARGUMENT_OUT_OF_RANGE; for (auto tracer : tracers_) { tracer.get().on_pre_check_failed(res.raw(), message); } return res; } state_.set_nonce(message.sender, nonce + 1); evmc::address contract_addr{}; if (message.kind == EVMC_CREATE) { contract_addr = create_address(message.sender, nonce); } else if (message.kind == EVMC_CREATE2) { auto init_code_hash{ethash::keccak256(message.input_data, message.input_size)}; contract_addr = create2_address(message.sender, message.create2_salt, init_code_hash.bytes); } state_.access_account(contract_addr); if (state_.get_nonce(contract_addr) != 0 || state_.get_code_hash(contract_addr) != kEmptyHash) { // https://github.com/ethereum/EIPs/issues/684 res.status_code = EVMC_INVALID_INSTRUCTION; res.gas_left = 0; return res; } auto snapshot{state_.take_snapshot()}; state_.create_contract(contract_addr, false); const evmc_revision rev{revision()}; if (rev >= EVMC_SPURIOUS_DRAGON) { state_.set_nonce(contract_addr, 1); } transfer(state_, message.sender, contract_addr, value, bailout); const evmc_message deploy_message{ .kind = message.depth > 0 ? message.kind : EVMC_CALL, .depth = message.depth, .gas = message.gas, .gas_cost = message.gas_cost, .recipient = contract_addr, .sender = message.sender, .value = message.value, .create2_salt = message.create2_salt, }; auto evm_res{execute(deploy_message, ByteView{message.input_data, message.input_size}, /*code_hash=*/nullptr)}; if (evm_res.status_code == EVMC_SUCCESS) { const size_t code_len{evm_res.output_size}; const uint64_t code_deploy_gas{code_len * protocol::fee::kGCodeDeposit}; if (rev >= EVMC_SPURIOUS_DRAGON && code_len > protocol::kMaxCodeSize) { // EIP-170: Contract code size limit evm_res.status_code = EVMC_ARGUMENT_OUT_OF_RANGE; } else if (rev >= EVMC_LONDON && code_len > 0 && evm_res.output_data[0] == 0xEF) { // EIP-3541: Reject new contract code starting with the 0xEF byte evm_res.status_code = EVMC_CONTRACT_VALIDATION_FAILURE; } else if (std::cmp_greater_equal(evm_res.gas_left, code_deploy_gas)) { evm_res.gas_left -= static_cast(code_deploy_gas); state_.set_code(contract_addr, {evm_res.output_data, evm_res.output_size}); } else if (rev >= EVMC_HOMESTEAD) { evm_res.status_code = EVMC_OUT_OF_GAS; } } if (evm_res.status_code == EVMC_SUCCESS) { evm_res.create_address = contract_addr; } else { state_.revert_to_snapshot(snapshot); evm_res.gas_refund = 0; if (evm_res.status_code != EVMC_REVERT) { evm_res.gas_left = 0; } } // Explicitly notify registered tracers (if any) because evmc_result has been changed post execute for (auto tracer : tracers_) { tracer.get().on_creation_completed(evm_res, state_); } return evmc::Result{evm_res}; } evmc::Result EVM::call(const evmc_message& message) noexcept { evmc::Result res{EVMC_SUCCESS, message.gas}; const auto value{intx::be::load(message.value)}; const auto owned_funds = state_.get_balance(message.sender); if (!bailout && message.kind != EVMC_DELEGATECALL && owned_funds < value) { res.status_code = EVMC_INSUFFICIENT_BALANCE; return res; } const auto snapshot{state_.take_snapshot()}; const evmc_revision rev{revision()}; if (message.kind == EVMC_CALL) { if (message.flags & EVMC_STATIC) { // Match geth logic // https://github.com/ethereum/go-ethereum/blob/v1.9.25/core/vm/evm.go#L391 if (!precompile::is_precompile(message.recipient, rev)) { state_.touch(message.recipient); } } else { transfer(state_, message.sender, message.recipient, value, bailout); } } if (precompile::is_precompile(message.code_address, rev)) { static_assert(std::size(precompile::kContracts) < 256); const uint8_t num{message.code_address.bytes[kAddressLength - 1]}; const precompile::Contract& contract{precompile::kContracts[num]->contract}; const ByteView input{message.input_data, message.input_size}; const uint64_t gas{contract.gas(input, rev)}; if (std::cmp_greater(gas, message.gas)) { res.status_code = EVMC_OUT_OF_GAS; } else { const std::optional output{contract.run(input)}; if (output) { res = evmc::Result{EVMC_SUCCESS, message.gas - static_cast(gas), 0, message.gas_cost, output->data(), output->size()}; } else { res.status_code = EVMC_PRECOMPILE_FAILURE; } } // Explicitly notify registered tracers (if any) for (auto tracer : tracers_) { const ByteView empty_code{}; // Any precompile code is empty tracer.get().on_execution_start(rev, message, empty_code); tracer.get().on_precompiled_run(res.raw(), state_); tracer.get().on_execution_end(res.raw(), state_); } } else { const ByteView code{state_.get_code(message.code_address)}; if (code.empty() && tracers_.empty()) { // Do not skip execution if there are any tracers return res; } const evmc::bytes32 code_hash{state_.get_code_hash(message.code_address)}; res = evmc::Result{execute(message, code, &code_hash)}; } if (res.status_code != EVMC_SUCCESS) { state_.revert_to_snapshot(snapshot); res.gas_refund = 0; if (res.status_code != EVMC_REVERT) { res.gas_left = 0; } } return res; } evmc_result EVM::execute(const evmc_message& message, ByteView code, const evmc::bytes32* code_hash) noexcept { const evmc_revision rev{revision()}; if (exo_evm) { EvmHost host{*this}; return exo_evm->execute(exo_evm, &EvmHost::get_interface(), host.to_context(), rev, &message, code.data(), code.size()); } return execute_with_baseline_interpreter(rev, message, code, code_hash); } evmc_result EVM::execute_with_baseline_interpreter(evmc_revision rev, const evmc_message& message, ByteView code, const evmc::bytes32* code_hash) noexcept { std::shared_ptr analysis; const bool use_cache{code_hash && analysis_cache}; if (use_cache) { const auto optional_analysis{analysis_cache->get_as_copy(*code_hash)}; if (optional_analysis) { analysis = *optional_analysis; } } if (!analysis) { // EOF is disabled although evmone supports it. This will be needed as early as Prague, maybe later. analysis = std::make_shared(evmone::baseline::analyze(code, /*eof_enabled=*/false)); if (use_cache) { analysis_cache->put(*code_hash, analysis); } } EvmHost host{*this}; evmc_result res{evmone::baseline::execute(vm_impl(), EvmHost::get_interface(), host.to_context(), rev, message, *analysis)}; return res; } evmc_revision EVM::revision() const noexcept { return config().revision(block_.header.number, block_.header.timestamp); } void EVM::add_tracer(EvmTracer& tracer) noexcept { vm_impl().add_tracer(std::make_unique(tracer, state_)); tracers_.push_back(std::ref(tracer)); } void EVM::remove_tracers() noexcept { vm_impl().remove_tracers(); tracers_.clear(); } bool EvmHost::account_exists(const evmc::address& address) const noexcept { const evmc_revision rev{evm_.revision()}; if (rev >= EVMC_SPURIOUS_DRAGON) { return !evm_.state().is_dead(address); } return evm_.state().exists(address); } evmc_access_status EvmHost::access_account(const evmc::address& address) noexcept { const evmc_revision rev{evm_.revision()}; if (precompile::is_precompile(address, rev)) { return EVMC_ACCESS_WARM; } return evm_.state().access_account(address); } evmc_access_status EvmHost::access_storage(const evmc::address& address, const evmc::bytes32& key) noexcept { return evm_.state().access_storage(address, key); } evmc::bytes32 EvmHost::get_storage(const evmc::address& address, const evmc::bytes32& key) const noexcept { return evm_.state().get_current_storage(address, key); } evmc_storage_status EvmHost::set_storage(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& value) noexcept { const evmc::bytes32 current_val{evm_.state().get_current_storage(address, key)}; if (current_val == value) { return EVMC_STORAGE_ASSIGNED; } evm_.state().set_storage(address, key, value); // https://eips.ethereum.org/EIPS/eip-1283 const evmc::bytes32 original_val{evm_.state().get_original_storage(address, key)}; if (original_val == current_val) { if (is_zero(original_val)) { return EVMC_STORAGE_ADDED; } // !is_zero(original_val) if (is_zero(value)) { return EVMC_STORAGE_DELETED; } return EVMC_STORAGE_MODIFIED; } // original_val != current_val if (!is_zero(original_val)) { if (is_zero(current_val)) { if (original_val == value) { return EVMC_STORAGE_DELETED_RESTORED; } return EVMC_STORAGE_DELETED_ADDED; } // !is_zero(current_val) if (is_zero(value)) { return EVMC_STORAGE_MODIFIED_DELETED; } // !is_zero(value) if (original_val == value) { return EVMC_STORAGE_MODIFIED_RESTORED; } return EVMC_STORAGE_ASSIGNED; } // is_zero(original_val) if (original_val == value) { return EVMC_STORAGE_ADDED_DELETED; } return EVMC_STORAGE_ASSIGNED; } evmc::uint256be EvmHost::get_balance(const evmc::address& address) const noexcept { intx::uint256 balance{evm_.state().get_balance(address)}; return intx::be::store(balance); } size_t EvmHost::get_code_size(const evmc::address& address) const noexcept { return evm_.state().get_code(address).size(); } evmc::bytes32 EvmHost::get_code_hash(const evmc::address& address) const noexcept { if (evm_.state().is_dead(address)) { return {}; } return evm_.state().get_code_hash(address); } size_t EvmHost::copy_code(const evmc::address& address, size_t code_offset, uint8_t* buffer_data, size_t buffer_size) const noexcept { ByteView code{evm_.state().get_code(address)}; if (code_offset >= code.size()) { return 0; } size_t n{std::min(buffer_size, code.size() - code_offset)}; std::copy_n(&code[code_offset], n, buffer_data); return n; } bool EvmHost::selfdestruct(const evmc::address& address, const evmc::address& beneficiary) noexcept { const intx::uint256 balance{evm_.state().get_balance(address)}; evm_.state().add_to_balance(beneficiary, balance); bool recorded{false}; if (evm_.revision() >= EVMC_CANCUN && !evm_.state().created().contains(address)) { evm_.state().subtract_from_balance(address, balance); } else { evm_.state().set_balance(address, 0); recorded = evm_.state().record_suicide(address); } for (auto tracer : evm_.tracers()) { tracer.get().on_self_destruct(address, beneficiary); } return recorded; } evmc::Result EvmHost::call(const evmc_message& message) noexcept { if (message.kind == EVMC_CREATE || message.kind == EVMC_CREATE2) { evmc::Result res{evm_.create(message)}; // https://eips.ethereum.org/EIPS/eip-211 if (res.status_code == EVMC_REVERT) { // geth returns CREATE output only in case of REVERT return res; } evmc::Result res_with_no_output{res.status_code, res.gas_left, res.gas_refund}; res_with_no_output.create_address = res.create_address; return res_with_no_output; } return evm_.call(message); } evmc_tx_context EvmHost::get_tx_context() const noexcept { const BlockHeader& header{evm_.block_.header}; evmc_tx_context context{}; const intx::uint256 base_fee_per_gas{header.base_fee_per_gas.value_or(0)}; const intx::uint256 effective_gas_price{evm_.txn_->effective_gas_price(base_fee_per_gas)}; intx::be::store(context.tx_gas_price.bytes, effective_gas_price); context.tx_origin = *evm_.txn_->sender(); context.block_coinbase = evm_.beneficiary; SILKWORM_ASSERT(header.number <= INT64_MAX); // EIP-1985 context.block_number = static_cast(header.number); context.block_timestamp = static_cast(header.timestamp); SILKWORM_ASSERT(header.gas_limit <= INT64_MAX); // EIP-1985 context.block_gas_limit = static_cast(header.gas_limit); if (header.difficulty == 0) { // EIP-4399: Supplant DIFFICULTY opcode with RANDOM // We use 0 header difficulty as the telltale of PoS blocks std::memcpy(context.block_prev_randao.bytes, header.prev_randao.bytes, kHashLength); } else { intx::be::store(context.block_prev_randao.bytes, header.difficulty); } intx::be::store(context.chain_id.bytes, intx::uint256{evm_.config().chain_id}); intx::be::store(context.block_base_fee.bytes, base_fee_per_gas); const intx::uint256 blob_gas_price{header.blob_gas_price().value_or(0)}; intx::be::store(context.blob_base_fee.bytes, blob_gas_price); context.blob_hashes = evm_.txn_->blob_versioned_hashes.data(); context.blob_hashes_count = evm_.txn_->blob_versioned_hashes.size(); return context; } evmc::bytes32 EVM::get_block_hash(int64_t block_num) noexcept { SILKWORM_ASSERT(block_num >= 0); const uint64_t current_block_num{block_.header.number}; SILKWORM_ASSERT(static_cast(block_num) < current_block_num); const uint64_t new_size_u64{current_block_num - static_cast(block_num)}; SILKWORM_ASSERT(std::in_range(new_size_u64)); const size_t new_size{static_cast(new_size_u64)}; std::vector& hashes{block_hashes_}; if (hashes.empty()) { hashes.push_back(block_.header.parent_hash); } const size_t old_size{hashes.size()}; if (old_size < new_size) { hashes.resize(new_size); } for (size_t i{old_size}; i < new_size; ++i) { std::optional header{state().db().read_header(current_block_num - i, hashes[i - 1])}; if (!header) { break; } hashes[i] = header->parent_hash; } return hashes[new_size - 1]; } evmc::bytes32 EvmHost::get_block_hash(int64_t block_num) const noexcept { return evm_.get_block_hash(block_num); } void EvmHost::emit_log(const evmc::address& address, const uint8_t* data, size_t data_size, const evmc::bytes32 topics[], size_t num_topics) noexcept { Log log{address}; std::copy_n(topics, num_topics, std::back_inserter(log.topics)); std::copy_n(data, data_size, std::back_inserter(log.data)); evm_.state().add_log(log); } evmc::bytes32 EvmHost::get_transient_storage(const evmc::address& addr, const evmc::bytes32& key) const noexcept { return evm_.state().get_transient_storage(addr, key); } void EvmHost::set_transient_storage(const evmc::address& addr, const evmc::bytes32& key, const evmc::bytes32& value) noexcept { evm_.state().set_transient_storage(addr, key, value); } } // namespace silkworm ================================================ FILE: silkworm/core/execution/evm.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "silkworm/core/types/address.hpp" namespace silkworm { struct CallResult { ValidationResult validation_result{ValidationResult::kOk}; evmc_status_code status{EVMC_SUCCESS}; uint64_t gas_left{0}; uint64_t gas_refund{0}; std::optional gas_used{0}; Bytes data; std::string error_message; }; class EvmTracer { public: virtual ~EvmTracer() = default; virtual void on_block_start(const Block& /*block*/) noexcept {} virtual void on_execution_start(evmc_revision /*rev*/, const evmc_message& /*msg*/, evmone::bytes_view /*code*/) noexcept {} virtual void on_instruction_start(uint32_t /*pc*/, const intx::uint256* /*stack_top*/, int /*stack_height*/, int64_t /*gas*/, const evmone::ExecutionState& /*state*/, const IntraBlockState& /*intra_block_state*/) noexcept {} virtual void on_execution_end(const evmc_result& /*result*/, const IntraBlockState& /*intra_block_state*/) noexcept {} virtual void on_pre_check_failed(const evmc_result& /*result*/, const evmc_message& /*msg*/) noexcept {}; virtual void on_creation_completed(const evmc_result& /*result*/, const IntraBlockState& /*intra_block_state*/) noexcept {} virtual void on_precompiled_run(const evmc_result& /*result*/, const IntraBlockState& /*intra_block_state*/) noexcept {} virtual void on_reward_granted(const CallResult& /*result*/, const IntraBlockState& /*intra_block_state*/) noexcept {} virtual void on_self_destruct(const evmc::address& /*address*/, const evmc::address& /*beneficiary*/) noexcept {} virtual void on_block_end(const Block& /*block*/) noexcept {} }; using EvmTracers = std::vector>; using AnalysisCache = LruCache>; using TransferFunc = void(IntraBlockState& state, const evmc::address& sender, const evmc::address& recipient, const intx::uint256& amount, bool bailout); // See consensus.Transfer in Erigon inline void standard_transfer(IntraBlockState& state, const evmc::address& sender, const evmc::address& recipient, const intx::uint256& amount, bool bailout) { // TODO(yperbasis) why is the bailout condition different from Erigon? if (!bailout || state.get_balance(sender) >= amount) { state.subtract_from_balance(sender, amount); } state.add_to_balance(recipient, amount); } class EVM { public: // Not copyable nor movable EVM(const EVM&) = delete; EVM& operator=(const EVM&) = delete; EVM(const Block& block, IntraBlockState& state, const ChainConfig& config) noexcept; ~EVM(); /// Returns the reference to the underlying evmone's VM object. evmc::VM& vm() noexcept { return evm1_; } /// Returns the reference to the evmone's internal interface for EVM. evmone::VM& vm_impl() noexcept { // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast) return *static_cast(evm1_.get_raw_pointer()); } const Block& block() const noexcept { return block_; } const ChainConfig& config() const noexcept { return config_; } IntraBlockState& state() noexcept { return state_; } const IntraBlockState& state() const noexcept { return state_; } // Precondition: txn.from must be recovered CallResult execute(const Transaction& txn, uint64_t gas) noexcept; evmc_revision revision() const noexcept; void add_tracer(EvmTracer& tracer) noexcept; void remove_tracers() noexcept; const EvmTracers& tracers() const noexcept { return tracers_; }; AnalysisCache* analysis_cache{nullptr}; // provide one for better performance evmc_vm* exo_evm{nullptr}; // it's possible to use an exogenous EVMC VM evmc::address beneficiary; // see IRuleSet::get_beneficiary gsl::not_null transfer{standard_transfer}; bool bailout{false}; [[nodiscard]] evmc::bytes32 get_block_hash(int64_t block_num) noexcept; private: friend class EvmHost; evmc::Result create(const evmc_message& message) noexcept; evmc::Result call(const evmc_message& message) noexcept; evmc_result execute(const evmc_message& message, ByteView code, const evmc::bytes32* code_hash) noexcept; evmc_result execute_with_baseline_interpreter(evmc_revision rev, const evmc_message& message, ByteView code, const evmc::bytes32* code_hash) noexcept; const Block& block_; IntraBlockState& state_; const ChainConfig& config_; const Transaction* txn_{nullptr}; std::vector block_hashes_{}; EvmTracers tracers_; // evmone is defined as static since it's stateless and doesn't have to be recreated every time EVM class is created #ifdef __wasm__ static evmc::VM evm1_; // we cannot use SILKWORM_THREAD_LOCAL i.e. static in WASM (duplicate-decl-specifier) #else SILKWORM_THREAD_LOCAL static evmc::VM evm1_; // since evmone is not thread safe it should be unique per thread #endif // __wasm__ }; class EvmHost : public evmc::Host { public: explicit EvmHost(EVM& evm) noexcept : evm_{evm} {} bool account_exists(const evmc::address& address) const noexcept override; evmc_access_status access_account(const evmc::address& address) noexcept override; evmc_access_status access_storage(const evmc::address& address, const evmc::bytes32& key) noexcept override; evmc::bytes32 get_storage(const evmc::address& address, const evmc::bytes32& key) const noexcept override; evmc_storage_status set_storage(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& value) noexcept override; evmc::uint256be get_balance(const evmc::address& address) const noexcept override; size_t get_code_size(const evmc::address& address) const noexcept override; evmc::bytes32 get_code_hash(const evmc::address& address) const noexcept override; size_t copy_code(const evmc::address& address, size_t code_offset, uint8_t* buffer_data, size_t buffer_size) const noexcept override; bool selfdestruct(const evmc::address& address, const evmc::address& beneficiary) noexcept override; evmc::Result call(const evmc_message& message) noexcept override; evmc_tx_context get_tx_context() const noexcept override; evmc::bytes32 get_block_hash(int64_t block_num) const noexcept override; void emit_log(const evmc::address& address, const uint8_t* data, size_t data_size, const evmc::bytes32 topics[], size_t num_topics) noexcept override; evmc::bytes32 get_transient_storage(const evmc::address& addr, const evmc::bytes32& key) const noexcept override; void set_transient_storage(const evmc::address& addr, const evmc::bytes32& key, const evmc::bytes32& value) noexcept override; private: EVM& evm_; }; } // namespace silkworm ================================================ FILE: silkworm/core/execution/evm_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm.hpp" #include #include #include #include #include #include #include #include #include #include namespace silkworm { constexpr auto kIsCodeDelegation = false; TEST_CASE("Value transfer", "[core][execution]") { Block block{}; block.header.number = 10336006; evmc::address from{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; intx::uint256 value{10'200'000'000'000'000}; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; CHECK(state.get_balance(from) == 0); CHECK(state.get_balance(to) == 0); Transaction txn{}; txn.set_sender(from); txn.to = to; txn.value = value; CallResult res{evm.execute(txn, 0)}; CHECK(res.status == EVMC_INSUFFICIENT_BALANCE); CHECK(res.data.empty()); state.add_to_balance(from, kEther); res = evm.execute(txn, 0); CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); CHECK(state.get_balance(from) == kEther - value); CHECK(state.get_balance(to) == value); CHECK(state.touched().count(from) == 1); CHECK(state.touched().count(to) == 1); } TEST_CASE("Destruct and recreate", "[core][execution]") { evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; InMemoryState db; { IntraBlockState state{db}; // First, create the contract and set one storage location to non-zero in a block state.clear_journal_and_substate(); REQUIRE(state.get_original_storage(to, {}) == evmc::bytes32{}); REQUIRE(state.get_current_storage(to, {}) == evmc::bytes32{}); state.create_contract(to, kIsCodeDelegation); state.set_storage(to, {}, evmc::bytes32{1}); REQUIRE(state.get_current_storage(to, {}) == evmc::bytes32{1}); state.finalize_transaction(EVMC_SHANGHAI); state.write_to_db(1); REQUIRE(db.state_root_hash() == 0xc2d663880f143c9bdd3c7bd2c282dc8d24e2bccf81bc779c058d18685a4a7386_bytes32); } SECTION("destruct_send-funds_recreate_same_block") { IntraBlockState state{db}; // Then, in another block, destruct it state.clear_journal_and_substate(); REQUIRE(state.get_original_storage(to, {}) == evmc::bytes32{1}); REQUIRE(state.get_current_storage(to, {}) == evmc::bytes32{1}); REQUIRE(state.record_suicide(to)); state.destruct_suicides(); REQUIRE(state.get_current_storage(to, {}) == evmc::bytes32{}); state.finalize_transaction(EVMC_SHANGHAI); // Add some balance to it state.clear_journal_and_substate(); state.add_to_balance(to, 1); state.finalize_transaction(EVMC_SHANGHAI); // And recreate it: the storage location previously set to non-zero must be zeroed state.clear_journal_and_substate(); CHECK(state.get_original_storage(to, {}) == evmc::bytes32{}); CHECK(state.get_current_storage(to, {}) == evmc::bytes32{}); state.create_contract(to, kIsCodeDelegation); CHECK(state.get_current_storage(to, {}) == evmc::bytes32{}); state.finalize_transaction(EVMC_SHANGHAI); state.write_to_db(2); } SECTION("destruct_send-funds_recreate_separate_block") { { IntraBlockState state{db}; // Then, in another block, destruct it state.clear_journal_and_substate(); REQUIRE(state.get_original_storage(to, {}) == evmc::bytes32{1}); REQUIRE(state.get_current_storage(to, {}) == evmc::bytes32{1}); REQUIRE(state.record_suicide(to)); state.destruct_suicides(); REQUIRE(state.get_current_storage(to, {}) == evmc::bytes32{}); state.finalize_transaction(EVMC_SHANGHAI); // Add some balance to it state.clear_journal_and_substate(); state.add_to_balance(to, 1); state.finalize_transaction(EVMC_SHANGHAI); CHECK(state.get_current_storage(to, {}) == evmc::bytes32{}); state.write_to_db(2); CHECK(state.get_current_storage(to, {}) == evmc::bytes32{}); CHECK(db.state_root_hash() == 0x8e723de3b34ef0632b5421f0f8ad8dfa6c981e99009141b5b7130c790f0d38c6_bytes32); } { IntraBlockState state{db}; // Finally, in the last block, recreate it: the storage location previously set to non-zero must be zeroed state.clear_journal_and_substate(); CHECK(state.get_original_storage(to, {}) == evmc::bytes32{}); CHECK(state.get_current_storage(to, {}) == evmc::bytes32{}); state.create_contract(to, kIsCodeDelegation); CHECK(state.get_original_storage(to, {}) == evmc::bytes32{}); CHECK(state.get_current_storage(to, {}) == evmc::bytes32{}); state.finalize_transaction(EVMC_SHANGHAI); state.write_to_db(3); } } // Post-conditions: account must have incarnation == 2 and storage location zeroed const auto contract_address = db.read_account(to); REQUIRE(contract_address); CHECK(contract_address->incarnation == 2); CHECK(db.read_storage(to, contract_address->incarnation, {}) == evmc::bytes32{0}); CHECK(db.state_root_hash() == 0x8e723de3b34ef0632b5421f0f8ad8dfa6c981e99009141b5b7130c790f0d38c6_bytes32); } TEST_CASE("Create contract, destruct and then recreate", "[core][execution]") { evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; InMemoryState db; { IntraBlockState state{db}; // First, create an empty contract in one block REQUIRE((state.get_nonce(to) == 0 && state.get_code_hash(to) == kEmptyHash)); state.create_contract(to, kIsCodeDelegation); state.set_code(to, *from_hex("30600155")); state.finalize_transaction(EVMC_SHANGHAI); state.write_to_db(1); const auto account{db.read_account(to)}; CHECK((account && account->incarnation == 1)); } { IntraBlockState state{db}; // Then, in another block, destruct it state.clear_journal_and_substate(); REQUIRE(state.record_suicide(to)); state.destruct_suicides(); state.finalize_transaction(EVMC_SHANGHAI); state.write_to_db(2); CHECK(!db.read_account(to)); } { IntraBlockState state{db}; // Finally, recreate the contract in another block state.create_contract(to, kIsCodeDelegation); state.set_code(to, *from_hex("30600255")); state.finalize_transaction(EVMC_SHANGHAI); state.write_to_db(3); const auto account{db.read_account(to)}; CHECK((account && account->incarnation == 2)); } } TEST_CASE("Create empty contract and recreate non-empty in same block", "[core][execution]") { evmc::address to{0x8b299e2b7d7f43c0ce3068263545309ff4ffb521_address}; InMemoryState db; IntraBlockState state{db}; // First, create an empty contract in one transaction REQUIRE((state.get_nonce(to) == 0 && state.get_code_hash(to) == kEmptyHash)); state.create_contract(to, kIsCodeDelegation); state.finalize_transaction(EVMC_SHANGHAI); // Then, recreate it adding some code in another transaction state.clear_journal_and_substate(); REQUIRE((state.get_nonce(to) == 0 && state.get_code_hash(to) == kEmptyHash)); state.create_contract(to, kIsCodeDelegation); state.set_code(to, *from_hex("30600055")); state.finalize_transaction(EVMC_SHANGHAI); state.write_to_db(1); const auto account{db.read_account(to)}; CHECK((account && account->incarnation == 2)); } TEST_CASE("Smart contract with storage", "[core][execution]") { Block block{}; block.header.number = 1; evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; // This contract initially sets its 0th storage to 0x2a // and its 1st storage to 0x01c9. // When called, it updates the 0th storage to the input provided. Bytes code{*from_hex("602a5f556101c960015560048060135f395ff35f355f55")}; // https://github.com/CoinCulture/evm-tools/blob/master/analysis/guide.md#contracts // 0x00 PUSH1 => 2a // 0x02 PUSH0 // 0x03 SSTORE // storage[0] = 0x2a // 0x04 PUSH2 => 01c9 // 0x07 PUSH1 => 01 // 0x09 SSTORE // storage[1] = 0x01c9 // 0x0a PUSH1 => 04 // deploy begin // 0x0c DUP1 // 0x0d PUSH1 => 13 // 0x0f PUSH0 // 0x10 CODECOPY // 0x11 PUSH0 // 0x12 RETURN // deploy end // 0x13 PUSH0 // contract code // 0x14 CALLDATALOAD // 0x15 PUSH0 // 0x16 SSTORE // storage[0] = input[0] InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, test::kShanghaiConfig}; Transaction txn{}; txn.set_sender(caller); txn.data = code; uint64_t gas{0}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_OUT_OF_GAS); CHECK(res.data.empty()); gas = 50'000; res = evm.execute(txn, gas); CHECK(res.status == EVMC_SUCCESS); CHECK(to_hex(res.data) == "5f355f55"); evmc::address contract_address{create_address(caller, /*nonce=*/1)}; evmc::bytes32 key0{}; CHECK(to_hex(zeroless_view(state.get_current_storage(contract_address, key0).bytes)) == "2a"); evmc::bytes32 new_val{to_bytes32(*from_hex("f5"))}; txn.to = contract_address; txn.data = ByteView{new_val}; res = evm.execute(txn, gas); CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); CHECK(state.get_current_storage(contract_address, key0) == new_val); } #if !(defined(SILKWORM_SANITIZE) && defined(__APPLE__)) TEST_CASE("Maximum call depth", "[core][execution]") { Block block{}; block.header.number = 1'431'916; evmc::address caller{0x8e4d1ea201b908ab5e1f5a1c3f9f1b4f6c1e9cf1_address}; evmc::address contract{0x3589d05a1ec4af9f65b0e5554e645707775ee43c_address}; // The contract just calls itself recursively a given number of times. Bytes code{*from_hex("60003580600857005b6001900360005260008060208180305a6103009003f1602357fe5b")}; /* https://github.com/CoinCulture/evm-tools 0 PUSH1 => 00 2 CALLDATALOAD 3 DUP1 4 PUSH1 => 08 6 JUMPI 7 STOP 8 JUMPDEST 9 PUSH1 => 01 11 SWAP1 12 SUB 13 PUSH1 => 00 15 MSTORE 16 PUSH1 => 00 18 DUP1 19 PUSH1 => 20 21 DUP2 22 DUP1 23 ADDRESS 24 GAS 25 PUSH2 => 0300 28 SWAP1 29 SUB 30 CALL 31 PUSH1 => 23 33 JUMPI 34 INVALID 35 JUMPDEST */ InMemoryState db; IntraBlockState state{db}; state.set_code(contract, code); EVM evm{block, state, kMainnetConfig}; AnalysisCache analysis_cache{/*max_size=*/16}; evm.analysis_cache = &analysis_cache; Transaction txn{}; txn.set_sender(caller); txn.to = contract; uint64_t gas{1'000'000}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); evmc::bytes32 num_of_recursions{to_bytes32(*from_hex("0400"))}; txn.data = ByteView{num_of_recursions}; res = evm.execute(txn, gas); CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); num_of_recursions = to_bytes32(*from_hex("0401")); txn.data = ByteView{num_of_recursions}; res = evm.execute(txn, gas); CHECK(res.status == EVMC_INVALID_INSTRUCTION); CHECK(res.data.empty()); } #endif // SILKWORM_SANITIZE TEST_CASE("DELEGATECALL", "[core][execution]") { Block block{}; block.header.number = 1'639'560; evmc::address caller_address{0x8e4d1ea201b908ab5e1f5a1c3f9f1b4f6c1e9cf1_address}; evmc::address callee_address{0x3589d05a1ec4af9f65b0e5554e645707775ee43c_address}; // The callee writes the ADDRESS to storage. Bytes callee_code{*from_hex("30600055")}; /* https://github.com/CoinCulture/evm-tools 0 ADDRESS 1 PUSH1 => 00 3 SSTORE */ // The caller delegate-calls the input contract. Bytes caller_code{*from_hex("6000808080803561eeeef4")}; /* https://github.com/CoinCulture/evm-tools 0 PUSH1 => 00 2 DUP1 3 DUP1 4 DUP1 5 DUP1 6 CALLDATALOAD 7 PUSH2 => eeee 10 DELEGATECALL */ InMemoryState db; IntraBlockState state{db}; state.set_code(caller_address, caller_code); state.set_code(callee_address, callee_code); EVM evm{block, state, kMainnetConfig}; CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); Transaction txn{}; txn.set_sender(caller_address); txn.to = caller_address; txn.data = ByteView{to_bytes32(callee_address.bytes)}; uint64_t gas{1'000'000}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); evmc::bytes32 key0{}; CHECK(to_hex(zeroless_view(state.get_current_storage(caller_address, key0).bytes), true) == address_to_hex(caller_address)); CHECK(call_traces.senders.size() == 1); CHECK(call_traces.recipients.size() == 2); CHECK(call_traces.senders.contains(caller_address)); // call from caller to self CHECK(call_traces.recipients.contains(caller_address)); // call from caller to self CHECK(call_traces.recipients.contains(callee_address)); // delegate call from caller to callee } // https://eips.ethereum.org/EIPS/eip-211#specification TEST_CASE("CREATE should only return on failure", "[core][execution]") { Block block{}; block.header.number = 4'575'910; evmc::address caller{0xf466859ead1932d743d622cb74fc058882e8648a_address}; Bytes code{ *from_hex("0x602180601360003960006000f0503d600055006211223360005260206000602060006000600461900" "0f1503d60005560206000f3")}; /* https://github.com/CoinCulture/evm-tools 0 PUSH1 => 21 2 DUP1 3 PUSH1 => 13 5 PUSH1 => 00 7 CODECOPY 8 PUSH1 => 00 10 PUSH1 => 00 12 CREATE 13 POP 14 RETURNDATASIZE 15 PUSH1 => 00 17 SSTORE 18 STOP 19 PUSH3 => 112233 23 PUSH1 => 00 25 MSTORE 26 PUSH1 => 20 28 PUSH1 => 00 30 PUSH1 => 20 32 PUSH1 => 00 34 PUSH1 => 00 36 PUSH1 => 04 38 PUSH2 => 9000 41 CALL 42 POP 43 RETURNDATASIZE 44 PUSH1 => 00 46 SSTORE 47 PUSH1 => 20 49 PUSH1 => 00 51 RETURN */ InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; Transaction txn{}; txn.set_sender(caller); txn.data = code; uint64_t gas{150'000}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); evmc::address contract_address{create_address(caller, /*nonce=*/0)}; evmc::bytes32 key0{}; CHECK(is_zero(state.get_current_storage(contract_address, key0))); } // https://github.com/ethereum/EIPs/issues/684 TEST_CASE("Contract overwrite", "[core][execution]") { Block block{}; block.header.number = 7'753'545; Bytes old_code{*from_hex("6000")}; Bytes new_code{*from_hex("6001")}; evmc::address caller{0x92a1d964b8fc79c5694343cc943c27a94a3be131_address}; evmc::address contract_address{create_address(caller, /*nonce=*/0)}; InMemoryState db; IntraBlockState state{db}; state.set_code(contract_address, old_code); EVM evm{block, state, kMainnetConfig}; Transaction txn{}; txn.set_sender(caller); txn.data = new_code; uint64_t gas{100'000}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_INVALID_INSTRUCTION); CHECK(res.gas_left == 0); CHECK(res.data.empty()); } TEST_CASE("EIP-3541: Reject new contracts starting with the 0xEF byte", "[core][execution]") { const ChainConfig& config{kMainnetConfig}; Block block; block.header.number = 13'500'000; REQUIRE(config.revision(block.header.number, block.header.timestamp) == EVMC_LONDON); InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, config}; Transaction txn; txn.set_sender(0x1000000000000000000000000000000000000000_address); const uint64_t gas{50'000}; // https://eips.ethereum.org/EIPS/eip-3541#test-cases txn.data = *from_hex("0x60ef60005360016000f3"); CHECK(evm.execute(txn, gas).status == EVMC_CONTRACT_VALIDATION_FAILURE); txn.data = *from_hex("0x60ef60005360026000f3"); CHECK(evm.execute(txn, gas).status == EVMC_CONTRACT_VALIDATION_FAILURE); txn.data = *from_hex("0x60ef60005360036000f3"); CHECK(evm.execute(txn, gas).status == EVMC_CONTRACT_VALIDATION_FAILURE); txn.data = *from_hex("0x60ef60005360206000f3"); CHECK(evm.execute(txn, gas).status == EVMC_CONTRACT_VALIDATION_FAILURE); txn.data = *from_hex("0x60fe60005360016000f3"); CHECK(evm.execute(txn, gas).status == EVMC_SUCCESS); } class TestTracer : public EvmTracer { public: explicit TestTracer(std::optional contract_address = std::nullopt, std::optional key = std::nullopt) : contract_address_(contract_address), key_(key), rev_{} {} void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view bytecode) noexcept override { execution_start_called_ = true; rev_ = rev; msg_stack_.push_back(msg); bytecode_ = Bytes{bytecode}; } void on_instruction_start(uint32_t pc, const intx::uint256* /*stack_top*/, int /*stack_height*/, int64_t /*gas*/, const evmone::ExecutionState& state, const IntraBlockState& intra_block_state) noexcept override { pc_stack_.push_back(pc); memory_size_stack_[pc] = state.memory.size(); if (contract_address_) { storage_stack_[pc] = intra_block_state.get_current_storage(contract_address_.value(), key_.value_or(evmc::bytes32{})); } } void on_execution_end(const evmc_result& res, const IntraBlockState& intra_block_state) noexcept override { execution_end_called_ = true; const auto gas_left = static_cast(res.gas_left); const auto gas_refund = static_cast(res.gas_refund); result_ = {ValidationResult::kOk, res.status_code, gas_left, gas_refund, std::nullopt, {res.output_data, res.output_size}}; if (contract_address_ && !pc_stack_.empty()) { const auto pc = pc_stack_.back(); storage_stack_[pc] = intra_block_state.get_current_storage(contract_address_.value(), key_.value_or(evmc::bytes32{})); } } void on_creation_completed(const evmc_result& /*result*/, const IntraBlockState& /*intra_block_state*/) noexcept override { creation_completed_called_ = true; } void on_self_destruct(const evmc::address& /*address*/, const evmc::address& /*beneficiary*/) noexcept override { self_destruct_called_ = true; } void reset() { execution_start_called_ = false; execution_end_called_ = false; creation_completed_called_ = false; self_destruct_called_ = false; contract_address_.reset(); key_.reset(); rev_ = EVMC_FRONTIER; msg_stack_.clear(); bytecode_.clear(); pc_stack_.clear(); memory_size_stack_.clear(); storage_stack_.clear(); result_ = {}; } bool execution_start_called() const { return execution_start_called_; } bool execution_end_called() const { return execution_end_called_; } bool creation_completed_called() const { return creation_completed_called_; } bool self_destruct_called() const { return self_destruct_called_; } const Bytes& bytecode() const { return bytecode_; } const evmc_revision& rev() const { return rev_; } const std::vector& msg_stack() const { return msg_stack_; } const std::vector& pc_stack() const { return pc_stack_; } const std::map& memory_size_stack() const { return memory_size_stack_; } const std::map& storage_stack() const { return storage_stack_; } const CallResult& result() const { return result_; } private: bool execution_start_called_{false}; bool execution_end_called_{false}; bool creation_completed_called_{false}; bool self_destruct_called_{false}; std::optional contract_address_; std::optional key_; evmc_revision rev_{EVMC_FRONTIER}; std::vector msg_stack_; Bytes bytecode_; std::vector pc_stack_; std::map memory_size_stack_; std::map storage_stack_; CallResult result_; }; TEST_CASE("Tracing smart contract with storage", "[core][execution]") { Block block{}; block.header.number = 10'336'006; const evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; const evmc::address contract_address0{create_address(caller, 0)}; // This contract initially sets its 0th storage to 0x2a and its 1st storage to 0x01c9. // When called, it updates the 0th storage to the input provided. Bytes code{*from_hex("602a6000556101c960015560068060166000396000f3600035600055")}; // https://github.com/CoinCulture/evm-tools // 0 PUSH1 => 2a // 2 PUSH1 => 00 // 4 SSTORE // storage[0] = 0x2a // 5 PUSH2 => 01c9 // 8 PUSH1 => 01 // 10 SSTORE // storage[1] = 0x01c9 // 11 PUSH1 => 06 // deploy begin // 13 DUP1 // 14 PUSH1 => 16 // 16 PUSH1 => 00 // 18 CODECOPY // 19 PUSH1 => 00 // 21 RETURN // deploy end // 22 PUSH1 => 00 // contract code // 24 CALLDATALOAD // 25 PUSH1 => 00 // 27 SSTORE // storage[0] = input[0] InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; Transaction txn{}; txn.set_sender(caller); txn.data = code; CHECK(evm.tracers().empty()); // First execution: out of gas TestTracer tracer1; evm.add_tracer(tracer1); CallTraces call_traces1; CallTracer call_tracer1{call_traces1}; evm.add_tracer(call_tracer1); CHECK(evm.tracers().size() == 2); uint64_t gas{0}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_OUT_OF_GAS); CHECK(res.data.empty()); CHECK((tracer1.execution_start_called() && tracer1.execution_end_called() && tracer1.creation_completed_called())); CHECK(tracer1.rev() == evmc_revision::EVMC_ISTANBUL); CHECK(tracer1.msg_stack().at(0).kind == evmc_call_kind::EVMC_CALL); CHECK(tracer1.msg_stack().at(0).flags == 0); CHECK(tracer1.msg_stack().at(0).depth == 0); CHECK(tracer1.msg_stack().at(0).gas == 0); CHECK(tracer1.bytecode() == code); CHECK(tracer1.pc_stack() == std::vector{0}); CHECK(tracer1.memory_size_stack() == std::map{{0, 0}}); CHECK(tracer1.result().status == EVMC_OUT_OF_GAS); CHECK(tracer1.result().gas_left == 0); CHECK(tracer1.result().data.empty()); CHECK(call_traces1.senders.contains(caller)); CHECK(call_traces1.recipients.contains(contract_address0)); // even if deployment fails // Second execution: success const evmc::address contract_address1{create_address(caller, 1)}; TestTracer tracer2; evm.add_tracer(tracer2); CallTraces call_traces2; CallTracer call_tracer2{call_traces2}; evm.add_tracer(call_tracer2); CHECK(evm.tracers().size() == 4); gas = 50'000; res = evm.execute(txn, gas); CHECK(res.status == EVMC_SUCCESS); CHECK(res.data == from_hex("600035600055")); CHECK((tracer2.execution_start_called() && tracer2.execution_end_called())); CHECK(tracer2.rev() == evmc_revision::EVMC_ISTANBUL); CHECK(tracer2.msg_stack().at(0).kind == evmc_call_kind::EVMC_CALL); CHECK(tracer2.msg_stack().at(0).flags == 0); CHECK(tracer2.msg_stack().at(0).depth == 0); CHECK(tracer2.msg_stack().at(0).gas == 50'000); CHECK(tracer2.bytecode() == code); CHECK(tracer2.pc_stack() == std::vector{0, 2, 4, 5, 8, 10, 11, 13, 14, 16, 18, 19, 21}); CHECK(tracer2.memory_size_stack() == std::map{{0, 0}, {2, 0}, {4, 0}, {5, 0}, {8, 0}, {10, 0}, {11, 0}, {13, 0}, {14, 0}, {16, 0}, {18, 0}, {19, 32}, {21, 32}}); CHECK(tracer2.result().status == EVMC_SUCCESS); CHECK(tracer2.result().gas_left == 9964); CHECK(tracer2.result().data == res.data); CHECK(call_traces2.senders.contains(caller)); CHECK(call_traces2.recipients.contains(contract_address1)); // Third execution: success evmc::bytes32 key0{}; TestTracer tracer3{contract_address1, key0}; evm.add_tracer(tracer3); CallTraces call_traces3; CallTracer call_tracer3{call_traces3}; evm.add_tracer(call_tracer3); CHECK(evm.tracers().size() == 6); CHECK(to_hex(zeroless_view(state.get_current_storage(contract_address1, key0).bytes)) == "2a"); evmc::bytes32 new_val{to_bytes32(*from_hex("f5"))}; txn.to = contract_address1; txn.data = ByteView{new_val}; gas = 50'000; res = evm.execute(txn, gas); CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); CHECK(state.get_current_storage(contract_address1, key0) == new_val); CHECK((tracer3.execution_start_called() && tracer3.execution_end_called())); CHECK(tracer3.rev() == evmc_revision::EVMC_ISTANBUL); CHECK(tracer3.msg_stack().at(0).kind == evmc_call_kind::EVMC_CALL); CHECK(tracer3.msg_stack().at(0).flags == 0); CHECK(tracer3.msg_stack().at(0).depth == 0); CHECK(tracer3.msg_stack().at(0).gas == 50'000); CHECK(tracer3.storage_stack() == std::map{ {0, to_bytes32(*from_hex("2a"))}, {2, to_bytes32(*from_hex("2a"))}, {3, to_bytes32(*from_hex("2a"))}, {5, to_bytes32(*from_hex("f5"))}, }); CHECK(tracer3.pc_stack() == std::vector{0, 2, 3, 5}); CHECK(tracer3.memory_size_stack() == std::map{{0, 0}, {2, 0}, {3, 0}, {5, 0}}); CHECK(tracer3.result().status == EVMC_SUCCESS); CHECK(tracer3.result().gas_left == 49191); CHECK(tracer3.result().data.empty()); CHECK(call_traces3.senders.contains(caller)); CHECK(call_traces3.recipients.contains(contract_address1)); } TEST_CASE("Tracing smart contract creation with CREATE", "[core][execution]") { Block block{}; block.header.number = 10'336'006; const evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; Bytes code{*from_hex( "6080604052348015600f57600080fd5b50604051601a90603b565b6040518091" "03906000f0801580156035573d6000803e3d6000fd5b50506047565b605c8061" "009483390190565b603f806100556000396000f3fe6080604052600080fdfea2" "646970667358221220a6baacd5f97c2b771bee61b48c72a104dab25ffee7f1d6" "a26fcd81322047223364736f6c634300081300336080604052348015600f5760" "0080fd5b50603f80601d6000396000f3fe6080604052600080fdfea264697066" "7358221220f6587bd1dd592bb64698cf04f378d03a5f9e55c27c86df8890b628" "7d8694a43164736f6c63430008130033")}; // pragma solidity 0.8.19; // // contract Factory { // constructor() { // new Item(); // } // } // contract Item { // constructor() {} // } InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; Transaction txn{}; txn.set_sender(caller); txn.data = code; TestTracer tracer; evm.add_tracer(tracer); CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); CHECK(evm.tracers().size() == 2); const auto factory0_address{create_address(caller, state.get_nonce(caller))}; const auto item0_address{create_address(factory0_address, 1)}; uint64_t gas1 = {100'000}; // largely abundant (required 57'470) CallResult res1{evm.execute(txn, gas1)}; CHECK(res1.status == EVMC_SUCCESS); CHECK(tracer.msg_stack().size() == 2); if (tracer.msg_stack().size() == 2) { CHECK(tracer.msg_stack().at(0).depth == 0); CHECK(tracer.msg_stack().at(0).kind == evmc_call_kind::EVMC_CALL); CHECK(tracer.msg_stack().at(0).recipient == factory0_address); CHECK(evmc::is_zero(tracer.msg_stack().at(0).code_address)); CHECK(tracer.msg_stack().at(1).depth == 1); CHECK(tracer.msg_stack().at(1).kind == evmc_call_kind::EVMC_CREATE); CHECK(tracer.msg_stack().at(1).recipient == item0_address); } CHECK(evmc::is_zero(tracer.msg_stack().at(1).code_address)); CHECK(call_traces.senders.size() == 2); CHECK(call_traces.senders.contains(caller)); CHECK(call_traces.senders.contains(factory0_address)); CHECK(call_traces.recipients.size() == 2); CHECK(call_traces.recipients.contains(factory0_address)); CHECK(call_traces.recipients.contains(item0_address)); tracer.reset(); call_traces.senders.clear(); call_traces.recipients.clear(); // Trigger an early failure in evmone::baseline::check_requirements for CREATE opcode const auto factory1_address{create_address(caller, state.get_nonce(caller))}; const auto item1_address{create_address(factory1_address, 1)}; uint64_t gas2 = {138}; // causes out-of-gas at instruction 34 opcode CREATE in check_requirements CallResult res2 = evm.execute(txn, gas2); CHECK(res2.status == EVMC_OUT_OF_GAS); CHECK(tracer.msg_stack().size() == 1); if (tracer.msg_stack().size() == 1) { CHECK(tracer.msg_stack().at(0).depth == 0); CHECK(tracer.msg_stack().at(0).kind == evmc_call_kind::EVMC_CALL); CHECK(tracer.msg_stack().at(0).recipient == factory1_address); CHECK(evmc::is_zero(tracer.msg_stack().at(0).code_address)); } CHECK(call_traces.senders.size() == 1); CHECK(call_traces.senders.contains(caller)); CHECK(!call_traces.senders.contains(factory1_address)); CHECK(call_traces.recipients.size() == 1); CHECK(call_traces.recipients.contains(factory1_address)); CHECK(!call_traces.recipients.contains(item1_address)); } TEST_CASE("Tracing smart contract creation with CREATE2", "[core][execution]") { Block block{}; block.header.number = 10'336'006; const evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; Bytes code{*from_hex( "6080604052348015600f57600080fd5b506000801b604051601e906043565b81" "90604051809103906000f5905080158015603d573d6000803e3d6000fd5b5050" "604f565b605c8061009c83390190565b603f8061005d6000396000f3fe608060" "4052600080fdfea2646970667358221220ffaf2d6fdd061c3273248388b99d0e" "48f13466b078ba552718eb14d618127f5f64736f6c6343000813003360806040" "52348015600f57600080fd5b50603f80601d6000396000f3fe60806040526000" "80fdfea2646970667358221220ea2cccbd9b69291ff50e3244e6b74392bb58de" "7268abedc75e862628e939d32e64736f6c63430008130033")}; // pragma solidity 0.8.19; // // contract Factory { // constructor() { // new TestContract{salt: 0}(); // } // } // contract TestContract { // constructor() {} // } InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; Transaction txn{}; txn.set_sender(caller); txn.data = code; TestTracer tracer; evm.add_tracer(tracer); CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); CHECK(evm.tracers().size() == 2); uint64_t gas = {100'000}; CallResult res{evm.execute(txn, gas)}; CHECK(tracer.msg_stack().at(0).depth == 0); CHECK(tracer.msg_stack().at(0).kind == evmc_call_kind::EVMC_CALL); CHECK(tracer.msg_stack().at(0).recipient == 0xb7698071d0a593014f241f9d7fbbc49bcd62e014_address); CHECK(evmc::is_zero(tracer.msg_stack().at(0).code_address)); CHECK(tracer.msg_stack().at(1).depth == 1); CHECK(tracer.msg_stack().at(1).kind == evmc_call_kind::EVMC_CREATE2); CHECK(tracer.msg_stack().at(1).recipient == 0xe3e8f1881ba12f7d2494c010422982a8bf6045f7_address); CHECK(evmc::is_zero(tracer.msg_stack().at(1).code_address)); CHECK(call_traces.senders.contains(caller)); CHECK(call_traces.recipients.contains(0xb7698071d0a593014f241f9d7fbbc49bcd62e014_address)); CHECK(call_traces.recipients.contains(0xe3e8f1881ba12f7d2494c010422982a8bf6045f7_address)); } TEST_CASE("Tracing smart contract w/o code", "[core][execution]") { Block block{}; block.header.number = 10'336'006; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; CHECK(evm.tracers().empty()); TestTracer tracer1; evm.add_tracer(tracer1); CHECK(evm.tracers().size() == 1); // Deploy contract without code evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; Bytes code{}; Transaction txn{}; txn.set_sender(caller); txn.data = code; uint64_t gas{50'000}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); CHECK(tracer1.execution_start_called()); CHECK(tracer1.execution_end_called()); CHECK(tracer1.rev() == evmc_revision::EVMC_ISTANBUL); CHECK(tracer1.bytecode() == code); CHECK(tracer1.pc_stack().empty()); CHECK(tracer1.memory_size_stack().empty()); CHECK(tracer1.result().status == EVMC_SUCCESS); CHECK(tracer1.result().gas_left == gas); CHECK(tracer1.result().data.empty()); // Send message to empty contract evmc::address contract_address{create_address(caller, 1)}; evmc::bytes32 key0{}; TestTracer tracer2{contract_address, key0}; evm.add_tracer(tracer2); CHECK(evm.tracers().size() == 2); txn.to = contract_address; txn.data = ByteView{to_bytes32(*from_hex("f5"))}; res = evm.execute(txn, gas); CHECK(res.status == EVMC_SUCCESS); CHECK(res.data.empty()); CHECK(tracer2.execution_start_called()); CHECK(tracer2.execution_end_called()); CHECK(tracer2.rev() == evmc_revision::EVMC_ISTANBUL); CHECK(tracer2.bytecode() == code); CHECK(tracer2.pc_stack().empty()); CHECK(tracer2.memory_size_stack().empty()); CHECK(tracer2.result().status == EVMC_SUCCESS); CHECK(tracer2.result().gas_left == gas); CHECK(tracer2.result().data.empty()); } TEST_CASE("Tracing precompiled contract failure", "[core][execution]") { Block block{}; block.header.number = 10'336'006; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; CHECK(evm.tracers().empty()); TestTracer tracer1; evm.add_tracer(tracer1); CHECK(evm.tracers().size() == 1); // Execute transaction Deploy contract without code evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; evmc::address blake2f_precompile{0x0000000000000000000000000000000000000009_address}; Transaction txn{}; txn.set_sender(caller); txn.to = blake2f_precompile; uint64_t gas{50'000}; CallResult res{evm.execute(txn, gas)}; CHECK(res.status == EVMC_PRECOMPILE_FAILURE); } TEST_CASE("Smart contract creation w/ insufficient balance", "[core][execution]") { Block block{}; block.header.number = 1; const evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; Bytes code{*from_hex("602a5f556101c960015560048060135f395ff35f355f55")}; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, test::kShanghaiConfig}; CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); Transaction txn{}; txn.set_sender(caller); txn.data = code; txn.value = intx::uint256{1}; uint64_t gas = 50'000; CallResult res = evm.execute(txn, gas); CHECK(res.status == EVMC_INSUFFICIENT_BALANCE); CHECK(call_traces.senders.empty()); // No call tracer notification (compatibility w/ Erigon) CHECK(call_traces.recipients.empty()); // No call tracer notification (compatibility w/ Erigon) } TEST_CASE("Smart contract creation w/ insufficient gas", "[core][execution]") { Block block{}; block.header.number = 1; const evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; const evmc::address contract_address{create_address(caller, 0)}; Bytes code{*from_hex("602a5f556101c960015560048060135f395ff35f355f55")}; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, test::kShanghaiConfig}; CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); Transaction txn{}; txn.set_sender(caller); txn.data = code; uint64_t gas = 10'000; CallResult res = evm.execute(txn, gas); CHECK(res.status == EVMC_OUT_OF_GAS); CHECK(call_traces.senders.size() == 1); CHECK(call_traces.senders.contains(caller)); CHECK(call_traces.recipients.size() == 1); CHECK(call_traces.recipients.contains(contract_address)); } TEST_CASE("Tracing destruction of smart contract", "[core][execution]") { // Deployed code compiled using solc 0.8.19+commit.4fc1097e const Bytes deployed_code{*from_hex( "6080604052348015600f57600080fd5b506004361060285760003560e01c8063" "41c0e1b514602d575b600080fd5b60336035565b005b600073ffffffffffffff" "ffffffffffffffffffffffffff16fffea2646970667358221220c08c48851b75" "79ee6720e88f475624478fb5b0287b58e91a51315b243356fb9264736f6c6343" "0008130033")}; // pragma solidity 0.8.19; // // contract TestContract { // constructor() {} // // function kill() public { // selfdestruct(payable(address(0))); // } // } // Bytecode contains SHR opcode so requires EIP-145, hence at least Constantinople HF const auto chain_config{kMainnetConfig}; REQUIRE(chain_config.constantinople_block); Block block{}; block.header.number = *chain_config.constantinople_block; const evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; const evmc::address contract_address{create_address(caller, 0)}; InMemoryState db; IntraBlockState state{db}; state.set_code(contract_address, deployed_code); EVM evm{block, state, chain_config}; REQUIRE(evm.revision() >= EVMC_CONSTANTINOPLE); TestTracer test_tracer; evm.add_tracer(test_tracer); CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); CHECK(evm.tracers().size() == 2); Transaction txn{}; txn.set_sender(caller); txn.to = contract_address; txn.data = ByteView{*from_hex("41c0e1b5")}; // methodID for kill uint64_t gas = {100'000}; CallResult res = evm.execute(txn, gas); CHECK(res.status == EVMC_SUCCESS); CHECK(test_tracer.self_destruct_called()); CHECK(call_traces.senders.size() == 2); CHECK(call_traces.recipients.size() == 2); CHECK(call_traces.senders.contains(caller)); // external tx CHECK(call_traces.recipients.contains(contract_address)); // external tx CHECK(call_traces.senders.contains(contract_address)); // self-destruct CHECK(call_traces.recipients.contains(evmc::address{})); // self-destruct } // First occurrence at mainnet block 116'525 TEST_CASE("State changes for creation+destruction of smart contract", "[core][execution]") { // Bytecode compiled using solc 0.8.19+commit.4fc1097e const Bytes code{*from_hex( "6080604052348015600f57600080fd5b5060858061001e6000396000f3fe" "6080604052348015600f57600080fd5b506004361060285760003560e01c8063" "41c0e1b514602d575b600080fd5b60336035565b005b600073ffffffffffffff" "ffffffffffffffffffffffffff16fffea2646970667358221220c08c48851b75" "79ee6720e88f475624478fb5b0287b58e91a51315b243356fb9264736f6c6343" "0008130033")}; // pragma solidity 0.8.19; // // contract TestContract { // constructor() {} // // function kill() public { // selfdestruct(payable(address(0))); // } // } // Bytecode contains SHR opcode so requires EIP-145, hence at least Constantinople HF const auto chain_config{kMainnetConfig}; REQUIRE(chain_config.constantinople_block); Block block{}; block.header.number = *chain_config.constantinople_block; static constexpr evmc::address kZeroAddress = 0x0000000000000000000000000000000000000000_address; const evmc::address caller{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; const auto contract_address{create_address(caller, 0)}; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, chain_config}; REQUIRE(evm.revision() >= EVMC_CONSTANTINOPLE); TestTracer test_tracer; evm.add_tracer(test_tracer); // 1st tx creates the code at contract_address, thus changing such account state Transaction txn1{}; txn1.set_sender(caller); txn1.data = code; uint64_t gas = {100'000}; CallResult res1{evm.execute(txn1, gas)}; CHECK(res1.status == EVMC_SUCCESS); CHECK(test_tracer.creation_completed_called()); state.finalize_transaction(EVMC_CONSTANTINOPLE); state.clear_journal_and_substate(); // 2nd tx destroys the contract triggering self-destruct, thus changing such account back to empty state Transaction txn2{}; txn2.set_sender(caller); txn2.to = contract_address; txn2.data = ByteView{*from_hex("41c0e1b5")}; // methodID for kill CallResult res2 = evm.execute(txn2, gas); CHECK(res2.status == EVMC_SUCCESS); CHECK(test_tracer.self_destruct_called()); state.finalize_transaction(EVMC_CONSTANTINOPLE); state.write_to_db(block.header.number); CHECK(!db.accounts().contains(contract_address)); const auto account_changes_per_block{db.account_changes()}; CHECK(account_changes_per_block.contains(block.header.number)); if (account_changes_per_block.contains(block.header.number)) { const auto& account_changes{account_changes_per_block.at(block.header.number)}; CHECK(account_changes.contains(caller)); // transaction caller pays for execution CHECK(!account_changes.contains(kZeroAddress)); // destruction beneficiary receives zero balance (hence unchanged) CHECK(!account_changes.contains(contract_address)); // contract address hasn't changed after all } CHECK(state.number_of_self_destructs() == 1); } // First occurrence at mainnet block 1'639'553 TEST_CASE("Missing sender in call traces for DELEGATECALL", "[core][execution]") { static constexpr evmc::address kZeroAddress = 0x0000000000000000000000000000000000000000_address; evmc::address external_account{0xf466859ead1932d743d622cb74fc058882e8648a_address}; const auto caller_address{create_address(external_account, 0)}; const auto callee_address{create_address(external_account, 1)}; // The callee writes the ADDRESS to storage. const Bytes callee_code{*from_hex("30600055")}; /* https://github.com/CoinCulture/evm-tools 0 ADDRESS 1 PUSH1 => 00 3 SSTORE */ // The caller delegate-calls the input contract. const Bytes caller_code{*from_hex("6000808080803561eeeef4")}; /* https://github.com/CoinCulture/evm-tools 0 PUSH1 => 00 2 DUP1 3 DUP1 4 DUP1 5 DUP1 6 CALLDATALOAD 7 PUSH2 => eeee 10 DELEGATECALL */ Block block{}; block.header.number = 1'639'553; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); // 1st tx creates the code at caller_address Transaction txn1{}; txn1.set_sender(external_account); txn1.data = caller_code; uint64_t gas = {1'000'000}; CallResult res1{evm.execute(txn1, gas)}; CHECK(res1.status == EVMC_SUCCESS); state.set_code(caller_address, caller_code); state.finalize_transaction(EVMC_CONSTANTINOPLE); state.clear_journal_and_substate(); // 2nd tx creates the code at callee_address Transaction txn2{}; txn2.set_sender(external_account); txn2.data = callee_code; CallResult res2 = evm.execute(txn2, gas); CHECK(res2.status == EVMC_SUCCESS); state.set_code(callee_address, callee_code); state.finalize_transaction(EVMC_CONSTANTINOPLE); state.clear_journal_and_substate(); // 3rd tx calls the code at caller_address which in turn delegate-calls the code at callee address Transaction txn3{}; txn3.set_sender(external_account); txn3.to = caller_address; txn3.data = ByteView{to_bytes32(callee_address.bytes)}; CallResult res3{evm.execute(txn3, gas)}; CHECK(res3.status == EVMC_SUCCESS); CHECK(res3.data.empty()); state.finalize_transaction(EVMC_CONSTANTINOPLE); state.write_to_db(block.header.number); evmc::bytes32 key0{}; CHECK(to_hex(zeroless_view(db.storage().at(caller_address).at(1).at(key0).bytes), true) == address_to_hex(caller_address)); CHECK(call_traces.senders.size() == 2); CHECK(call_traces.senders.contains(external_account)); // all txs originates from external_account CHECK(call_traces.senders.contains(caller_address)); // 3rd tx triggers one delegate call from caller_address CHECK(call_traces.recipients.size() == 3); CHECK(call_traces.recipients.contains(kZeroAddress)); // 1st+2nd txs go to zero_address (contract creation) CHECK(call_traces.recipients.contains(caller_address)); // 3rd tx goes to caller_address CHECK(call_traces.recipients.contains(callee_address)); // 3rd tx triggers one delegate call to callee_address } // First occurrence at mainnet block 1'305'821 TEST_CASE("Missing call traces for CREATE/CREATE2 when completed w/o executing", "[core][execution]") { const evmc::address external_account{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; // Bytecode compiled using solc 0.8.19+commit.4fc1097e const Bytes item_code{*from_hex( "6080604052348015600f57600080fd5b50603f80601d6000396000f3fe60806040" "52600080fdfea2646970667358221220a3544cc91a06a14e2a9610d3b786201808" "2accb02f8555e847bc238a80ec0ec664736f6c63430008130033")}; // pragma solidity 0.8.19; // // contract Item { // constructor() {} // } const Bytes factory_and_test_contract_code{*from_hex( "608060405234801561001057600080fd5b5061014d806100206000396000f3fe60" "8060405234801561001057600080fd5b50600436106100365760003560e01c8063" "efc81a8c1461003b578063f5eacece14610045575b600080fd5b61004361004f56" "5b005b61004d61007b565b005b60405161005b906100af565b6040518091039060" "00f080158015610077573d6000803e3d6000fd5b5050565b6000801b6040516100" "8b906100af565b8190604051809103906000f59050801580156100ab573d600080" "3e3d6000fd5b5050565b605c806100bc8339019056fe6080604052348015600f57" "600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea264697066" "7358221220a3544cc91a06a14e2a9610d3b7862018082accb02f8555e847bc238a" "80ec0ec664736f6c63430008130033a26469706673582212207dbb3b4abbeee927" "e9bf764d2f83d595ce57ab4f1a5f5db3b84aaa22d5cdf4a264736f6c6343000813" "0033")}; // pragma solidity 0.8.19; // // contract Factory { // constructor() {} // // function create() public { // new Item(); // } // // function create2() public { // new Item{salt: 0}(); // } // } // // contract Item { // constructor() {} // } // Bytecode contains PUSH0 opcode so requires EIP-3855, hence at least Shanghai HF const auto chain_config{kMainnetConfig}; REQUIRE(chain_config.shanghai_time); Block block{}; block.header.number = 18'700'000; InMemoryState db; IntraBlockState state{db}; EVM evm{block, state, kMainnetConfig}; // 1st tx deploys the factory at factory_address const auto factory_address{create_address(external_account, 0)}; Transaction txn1{}; txn1.set_sender(external_account); txn1.data = factory_and_test_contract_code; TestTracer tracer; evm.add_tracer(tracer); CallTraces call_traces; CallTracer call_tracer{call_traces}; evm.add_tracer(call_tracer); CHECK(evm.tracers().size() == 2); uint64_t gas1 = {1'000'000}; // largely abundant CallResult res1{evm.execute(txn1, gas1)}; CHECK(res1.status == EVMC_SUCCESS); CHECK(call_traces.senders.size() == 1); CHECK(call_traces.senders.contains(external_account)); // 1st tx originates from external_account CHECK(call_traces.recipients.size() == 1); CHECK(call_traces.recipients.contains(factory_address)); // 1st tx goes to factory_address call_traces.senders.clear(); call_traces.recipients.clear(); // 2nd tx asks the factory to deploy an item using CREATE at item1_address const auto item1_address{create_address(factory_address, 1)}; Transaction txn2{}; txn2.set_sender(external_account); txn2.to = factory_address; txn2.data = ByteView{*from_hex("efc81a8c")}; // methodID for create uint64_t gas2 = {1'000'000}; // largely abundant CallResult res2{evm.execute(txn2, gas2)}; CHECK(res2.status == EVMC_SUCCESS); CHECK(call_traces.senders.size() == 2); CHECK(call_traces.senders.contains(external_account)); // 2nd tx originates from external_account CHECK(call_traces.senders.contains(factory_address)); CHECK(call_traces.recipients.size() == 2); CHECK(call_traces.recipients.contains(factory_address)); // 2nd tx goes to factory_address CHECK(call_traces.recipients.contains(item1_address)); call_traces.senders.clear(); call_traces.recipients.clear(); // 3rd tx asks the factory to deploy an item using CREATE2 at item2_address ethash::hash256 item_code_hash{keccak256(item_code)}; const auto item2_address{create2_address(factory_address, evmc::bytes32{0}, item_code_hash.bytes)}; Transaction txn3{}; txn3.set_sender(external_account); txn3.to = factory_address; txn3.data = ByteView{*from_hex("f5eacece")}; // methodID for create2 uint64_t gas3 = {1'000'000}; // largely abundant CallResult res3{evm.execute(txn3, gas3)}; CHECK(res3.status == EVMC_SUCCESS); CHECK(call_traces.senders.size() == 2); CHECK(call_traces.senders.contains(external_account)); // 3rd tx originates from external_account CHECK(call_traces.senders.contains(factory_address)); // item creation originates from factory_address CHECK(call_traces.recipients.size() == 2); CHECK(call_traces.recipients.contains(factory_address)); // 3rd tx goes to factory_address CHECK(call_traces.recipients.contains(item2_address)); // item gets deployed at item2_address call_traces.senders.clear(); call_traces.recipients.clear(); // 4th execution is like 2nd but triggers early failure in check_requirements due to insufficient gas const auto item1bis_address{create_address(factory_address, 3)}; uint64_t gas4 = {10'000}; CallResult res4{evm.execute(txn2, gas4)}; CHECK(res4.status == EVMC_OUT_OF_GAS); CHECK(call_traces.senders.size() == 1); CHECK(call_traces.senders.contains(external_account)); // 2nd tx originates from external_account CHECK(!call_traces.senders.contains(factory_address)); // factory_address not traced because creation failed CHECK(call_traces.recipients.size() == 1); CHECK(call_traces.recipients.contains(factory_address)); // 2nd tx goes to factory_address CHECK(!call_traces.recipients.contains(item1bis_address)); // item1bis_address not traced because creation failed call_traces.senders.clear(); call_traces.recipients.clear(); // 5th execution is like 3rd but triggers early failure in check_requirements due to insufficient gas uint64_t gas5 = {10'000}; CallResult res5{evm.execute(txn3, gas5)}; CHECK(res5.status == EVMC_OUT_OF_GAS); CHECK(call_traces.senders.size() == 1); CHECK(call_traces.senders.contains(external_account)); // 3rd tx originates from external_account CHECK(!call_traces.senders.contains(factory_address)); // factory_address not traced because creation failed CHECK(call_traces.recipients.size() == 1); CHECK(call_traces.recipients.contains(factory_address)); // 3rd tx goes to factory_address CHECK(!call_traces.recipients.contains(item2_address)); // item2_address not traced because creation failed } } // namespace silkworm ================================================ FILE: silkworm/core/execution/execution.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm { /** * @brief Execute a given block, write resulting changes into the state and return the transaction receipts. * @precondition validate_block_header & pre_validate_block_body must return kOk; transaction senders must be already populated. * @warning This method does not verify state root; pre-Byzantium receipt root isn't validated either. * @warning For better performance use ExecutionProcessor directly and set EVM state_pool and analysis_cache. * @param block The block to execute. * @param state The chain state at the beginning of the block. * @param chain_config The configuration parameters for the chain. * @param receipts The transaction receipts produced by block execution. */ inline ValidationResult execute_block( const Block& block, State& state, const ChainConfig& chain_config, std::vector& receipts) noexcept { const auto rule_set{protocol::rule_set_factory(chain_config)}; if (!rule_set) { return ValidationResult::kUnknownProtocolRuleSet; } ExecutionProcessor processor{block, *rule_set, state, chain_config, true}; if (const ValidationResult res = processor.execute_block(receipts); res != ValidationResult::kOk) { return res; } processor.flush_state(); return ValidationResult::kOk; } /** * @brief Execute a given block and write resulting changes into the state. * @precondition validate_block_header & pre_validate_block_body must return kOk; transaction senders must be already populated. * @warning This method does not verify state root; pre-Byzantium receipt root isn't validated either. * @warning For better performance use ExecutionProcessor directly and set EVM state_pool and analysis_cache. * @param block The block to execute. * @param state The chain state at the beginning of the block. * @param chain_config The configuration parameters for the chain. */ inline ValidationResult execute_block( const Block& block, State& state, const ChainConfig& chain_config) noexcept { std::vector receipts; return execute_block(block, state, chain_config, receipts); } } // namespace silkworm ================================================ FILE: silkworm/core/execution/execution_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "execution.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { static constexpr evmc::address kMiner{0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c_address}; static constexpr evmc::address kSender{0xb685342b8c54347aad148e1f22eff3eb3eb29391_address}; TEST_CASE("Execute two blocks") { // --------------------------------------- // Prepare // --------------------------------------- Block block{}; block.header.number = 1; block.header.beneficiary = kMiner; block.header.gas_limit = 100'000; block.header.gas_used = 98'824; static constexpr auto kEncoder = [](Bytes& to, const Receipt& r) { rlp::encode(to, r); }; std::vector receipts{ {TransactionType::kDynamicFee, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); // This contract initially sets its 0th storage to 0x2a and its 1st storage to 0x01c9. // When called, it updates its 0th storage to the input provided. Bytes contract_code{*from_hex("600035600055")}; Bytes deployment_code{*from_hex("602a6000556101c960015560068060166000396000f3") + contract_code}; block.transactions.resize(1); block.transactions[0].data = deployment_code; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kDynamicFee; block.transactions[0].max_priority_fee_per_gas = 0; block.transactions[0].max_fee_per_gas = 20 * kGiga; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(kSender); InMemoryState state; Account sender_account{}; sender_account.balance = kEther; state.update_account(kSender, std::nullopt, sender_account); // --------------------------------------- // Execute first block // --------------------------------------- REQUIRE(execute_block(block, state, test::kLondonConfig) == ValidationResult::kOk); auto contract_address{create_address(kSender, /*nonce=*/0)}; std::optional contract_account{state.read_account(contract_address)}; REQUIRE(contract_account != std::nullopt); ethash::hash256 code_hash{keccak256(contract_code)}; CHECK(to_hex(contract_account->code_hash) == to_hex(code_hash.bytes)); evmc::bytes32 storage_key0{}; evmc::bytes32 storage0{state.read_storage(contract_address, kDefaultIncarnation, storage_key0)}; CHECK(to_hex(storage0) == "000000000000000000000000000000000000000000000000000000000000002a"); evmc::bytes32 storage_key1{to_bytes32(*from_hex("01"))}; evmc::bytes32 storage1{state.read_storage(contract_address, kDefaultIncarnation, storage_key1)}; CHECK(to_hex(storage1) == "00000000000000000000000000000000000000000000000000000000000001c9"); std::optional miner_account{state.read_account(kMiner)}; REQUIRE(miner_account); CHECK(miner_account->balance == protocol::kBlockRewardConstantinople); // --------------------------------------- // Execute second block // --------------------------------------- std::string new_val{"000000000000000000000000000000000000000000000000000000000000003e"}; block.header.number = 2; block.header.gas_used = 26'149; receipts[0].cumulative_gas_used = block.header.gas_used; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions[0].nonce = 1; block.transactions[0].to = contract_address; block.transactions[0].data = *from_hex(new_val); block.transactions[0].max_priority_fee_per_gas = 20 * kGiga; REQUIRE(execute_block(block, state, test::kLondonConfig) == ValidationResult::kOk); storage0 = state.read_storage(contract_address, kDefaultIncarnation, storage_key0); CHECK(to_hex(storage0) == new_val); miner_account = state.read_account(kMiner); REQUIRE(miner_account != std::nullopt); CHECK(miner_account->balance > 2 * protocol::kBlockRewardConstantinople); CHECK(miner_account->balance < 3 * protocol::kBlockRewardConstantinople); } class BlockTracer : public EvmTracer { public: explicit BlockTracer() = default; void on_block_start(const silkworm::Block& /*block*/) noexcept override { block_start_called_ = true; } void on_block_end(const silkworm::Block& /*block*/) noexcept override { block_end_called_ = true; } bool block_start_called() const { return block_start_called_; } bool block_end_called() const { return block_end_called_; } private: bool block_start_called_{false}; bool block_end_called_{false}; }; TEST_CASE("Execute block with tracing") { // --------------------------------------- // Prepare // --------------------------------------- Block block{}; block.header.number = 1; block.header.beneficiary = kMiner; block.header.gas_limit = 100'000; block.header.gas_used = 0; static constexpr auto kEncoder = [](Bytes& to, const Receipt& r) { rlp::encode(to, r); }; block.header.receipts_root = trie::root_hash(std::vector{}, kEncoder); InMemoryState state; Account sender_account{}; sender_account.balance = kEther; state.update_account(kSender, std::nullopt, sender_account); // --------------------------------------- // Execute block // --------------------------------------- const auto chain_config{test::kLondonConfig}; std::vector receipts; const auto rule_set{protocol::rule_set_factory(chain_config)}; REQUIRE(rule_set); ExecutionProcessor processor{block, *rule_set, state, chain_config, true}; BlockTracer block_tracer{}; processor.evm().add_tracer(block_tracer); CallTraces call_traces{}; CallTracer call_tracer{call_traces}; processor.evm().add_tracer(call_tracer); REQUIRE(processor.execute_block(receipts) == ValidationResult::kOk); CHECK((block_tracer.block_start_called() && block_tracer.block_end_called())); CHECK(call_traces.senders.empty()); CHECK(call_traces.recipients.size() == 1); CHECK(call_traces.recipients.contains(kMiner)); // header beneficiary } } // namespace silkworm ================================================ FILE: silkworm/core/execution/precompile.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "precompile.hpp" #include #include #include #include #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wold-style-cast" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wsign-conversion" #include #include #include #pragma GCC diagnostic pop #include #include #include #include #include namespace silkworm::precompile { static void right_pad(Bytes& str, const size_t min_size) noexcept { if (str.size() < min_size) { str.resize(min_size, '\0'); } } uint64_t ecrec_gas(ByteView, evmc_revision) noexcept { return 3'000; } std::optional ecrec_run(ByteView input) noexcept { Bytes d{input}; right_pad(d, 128); const auto v{intx::be::unsafe::load(&d[32])}; const auto r{intx::be::unsafe::load(&d[64])}; const auto s{intx::be::unsafe::load(&d[96])}; const bool homestead{false}; // See EIP-2 if (!is_valid_signature(r, s, homestead)) { return Bytes{}; } if (v != 27 && v != 28) { return Bytes{}; } Bytes out(32, 0); static secp256k1_context* context{secp256k1_context_create(SILKWORM_SECP256K1_CONTEXT_FLAGS)}; if (!silkworm_recover_address(&out[12], &d[0], &d[64], v != 27, context)) { return Bytes{}; } return out; } uint64_t sha256_gas(ByteView input, evmc_revision) noexcept { return 60 + 12 * num_words(input.size()); } std::optional sha256_run(ByteView input) noexcept { Bytes out(32, 0); evmone::crypto::sha256(reinterpret_cast(out.data()), reinterpret_cast(input.data()), input.size()); return out; } uint64_t rip160_gas(ByteView input, evmc_revision) noexcept { return 600 + 120 * num_words(input.size()); } std::optional rip160_run(ByteView input) noexcept { Bytes out(32, 0); SILKWORM_ASSERT(input.size() <= std::numeric_limits::max()); evmone::crypto::ripemd160(reinterpret_cast(&out[12]), reinterpret_cast(input.data()), input.size()); return out; } uint64_t id_gas(ByteView input, evmc_revision) noexcept { return 15 + 3 * num_words(input.size()); } std::optional id_run(ByteView input) noexcept { return Bytes{input}; } static intx::uint256 mult_complexity_eip198(const intx::uint256& x) noexcept { const intx::uint256 x_squared{x * x}; if (x <= 64) { return x_squared; } if (x <= 1024) { return (x_squared >> 2) + 96 * x - 3072; } return (x_squared >> 4) + 480 * x - 199680; } static intx::uint256 mult_complexity_eip2565(const intx::uint256& max_length) noexcept { const intx::uint256 words{(max_length + 7) >> 3}; // ⌈max_length/8⌉ return words * words; } uint64_t expmod_gas(ByteView input_view, evmc_revision rev) noexcept { const uint64_t min_gas{rev < EVMC_BERLIN ? 0 : 200u}; Bytes input{input_view}; right_pad(input, 3 * 32); intx::uint256 base_len256{intx::be::unsafe::load(&input[0])}; intx::uint256 exp_len256{intx::be::unsafe::load(&input[32])}; intx::uint256 mod_len256{intx::be::unsafe::load(&input[64])}; if (base_len256 == 0 && mod_len256 == 0) { return min_gas; } if (intx::count_significant_words(base_len256) > 1 || intx::count_significant_words(exp_len256) > 1 || intx::count_significant_words(mod_len256) > 1) { return UINT64_MAX; } uint64_t base_len64{static_cast(base_len256)}; uint64_t exp_len64{static_cast(exp_len256)}; input.erase(0, 3 * 32); intx::uint256 exp_head{0}; // first 32 bytes of the exponent if (input.size() > base_len64) { input.erase(0, static_cast(base_len64)); right_pad(input, 3 * 32); if (exp_len64 < 32) { input.erase(static_cast(exp_len64)); input.insert(0, 32 - static_cast(exp_len64), '\0'); } exp_head = intx::be::unsafe::load(input.data()); } unsigned bit_len{256 - clz(exp_head)}; intx::uint256 adjusted_exponent_len{0}; if (exp_len256 > 32) { adjusted_exponent_len = 8 * (exp_len256 - 32); } if (bit_len > 1) { adjusted_exponent_len += bit_len - 1; } if (adjusted_exponent_len < 1) { adjusted_exponent_len = 1; } const intx::uint256 max_length{std::max(mod_len256, base_len256)}; intx::uint256 gas; if (rev < EVMC_BERLIN) { gas = mult_complexity_eip198(max_length) * adjusted_exponent_len / 20; } else { gas = mult_complexity_eip2565(max_length) * adjusted_exponent_len / 3; } if (intx::count_significant_words(gas) > 1) { return UINT64_MAX; } return std::max(min_gas, static_cast(gas)); } std::optional expmod_run(ByteView input_view) noexcept { Bytes input{input_view}; right_pad(input, 3 * 32); uint64_t base_len{endian::load_big_u64(&input[24])}; input.erase(0, 32); uint64_t exponent_len{endian::load_big_u64(&input[24])}; input.erase(0, 32); uint64_t modulus_len{endian::load_big_u64(&input[24])}; input.erase(0, 32); if (modulus_len == 0) { return Bytes{}; } right_pad(input, static_cast(base_len + exponent_len + modulus_len)); mpz_t base; mpz_init(base); if (base_len) { mpz_import(base, base_len, 1, 1, 0, 0, input.data()); input.erase(0, static_cast(base_len)); } mpz_t exponent; mpz_init(exponent); if (exponent_len) { mpz_import(exponent, exponent_len, 1, 1, 0, 0, input.data()); input.erase(0, static_cast(exponent_len)); } mpz_t modulus; mpz_init(modulus); mpz_import(modulus, modulus_len, 1, 1, 0, 0, input.data()); Bytes out(static_cast(modulus_len), 0); if (mpz_sgn(modulus) == 0) { mpz_clear(modulus); mpz_clear(exponent); mpz_clear(base); return out; } mpz_t result; mpz_init(result); mpz_powm(result, base, exponent, modulus); // export as little-endian mpz_export(out.data(), nullptr, -1, 1, 0, 0, result); // and convert to big-endian std::ranges::reverse(out); mpz_clear(result); mpz_clear(modulus); mpz_clear(exponent); mpz_clear(base); return out; } // Utility functions for zkSNARK related precompiled contracts. // See Yellow Paper, Appendix E "Precompiled Contracts", as well as // EIP-196: Precompiled contracts for addition and scalar multiplication on the elliptic curve alt_bn128 // EIP-197: Precompiled contracts for optimal ate pairing check on the elliptic curve alt_bn128 using Scalar = libff::bigint; // Must be called prior to invoking any other method. // May be called many times from multiple threads. static void init_libff() noexcept { // magic static [[maybe_unused]] static bool initialized = []() noexcept { libff::inhibit_profiling_info = true; libff::inhibit_profiling_counters = true; libff::alt_bn128_pp::init_public_params(); return true; }(); } static Scalar to_scalar(const uint8_t bytes_be[32]) noexcept { mpz_t m; mpz_init(m); mpz_import(m, 32, /*order=*/1, /*size=*/1, /*endian=*/0, /*nails=*/0, bytes_be); Scalar out{m}; mpz_clear(m); return out; } // Notation warning: Yellow Paper's p is the same libff's q. // Returns x < p (YP notation). static bool valid_element_of_fp(const Scalar& x) noexcept { return mpn_cmp(x.data, libff::alt_bn128_modulus_q.data, libff::alt_bn128_q_limbs) < 0; } static std::optional decode_g1_element(const uint8_t bytes_be[64]) noexcept { Scalar x{to_scalar(bytes_be)}; if (!valid_element_of_fp(x)) { return {}; } Scalar y{to_scalar(bytes_be + 32)}; if (!valid_element_of_fp(y)) { return {}; } if (x.is_zero() && y.is_zero()) { return libff::alt_bn128_G1::zero(); } libff::alt_bn128_G1 point{x, y, libff::alt_bn128_Fq::one()}; if (!point.is_well_formed()) { return {}; } return point; } static std::optional decode_fp2_element(const uint8_t bytes_be[64]) noexcept { // big-endian encoding Scalar c0{to_scalar(bytes_be + 32)}; Scalar c1{to_scalar(bytes_be)}; if (!valid_element_of_fp(c0) || !valid_element_of_fp(c1)) { return {}; } return libff::alt_bn128_Fq2{c0, c1}; } static std::optional decode_g2_element(const uint8_t bytes_be[128]) noexcept { std::optional x{decode_fp2_element(bytes_be)}; if (!x) { return {}; } std::optional y{decode_fp2_element(bytes_be + 64)}; if (!y) { return {}; } if (x->is_zero() && y->is_zero()) { return libff::alt_bn128_G2::zero(); } libff::alt_bn128_G2 point{*x, *y, libff::alt_bn128_Fq2::one()}; if (!point.is_well_formed()) { return {}; } if (!(libff::alt_bn128_G2::order() * point).is_zero()) { // wrong order, doesn't belong to the subgroup G2 return {}; } return point; } static Bytes encode_g1_element(libff::alt_bn128_G1 p) noexcept { Bytes out(64, '\0'); if (p.is_zero()) { return out; } p.to_affine_coordinates(); auto x{p.X.as_bigint()}; auto y{p.Y.as_bigint()}; // Here we convert little-endian data to big-endian output static_assert(sizeof(x.data) == 32); std::memcpy(&out[0], y.data, 32); std::memcpy(&out[32], x.data, 32); std::ranges::reverse(out); return out; } uint64_t bn_add_gas(ByteView, evmc_revision rev) noexcept { return rev >= EVMC_ISTANBUL ? 150 : 500; } std::optional bn_add_run(ByteView input_view) noexcept { Bytes input{input_view}; right_pad(input, 128); init_libff(); std::optional x{decode_g1_element(input.data())}; if (!x) { return std::nullopt; } std::optional y{decode_g1_element(&input[64])}; if (!y) { return std::nullopt; } libff::alt_bn128_G1 sum{*x + *y}; return encode_g1_element(sum); } uint64_t bn_mul_gas(ByteView, evmc_revision rev) noexcept { return rev >= EVMC_ISTANBUL ? 6'000 : 40'000; } std::optional bn_mul_run(ByteView input_view) noexcept { Bytes input{input_view}; right_pad(input, 96); init_libff(); std::optional x{decode_g1_element(input.data())}; if (!x) { return std::nullopt; } Scalar n{to_scalar(&input[64])}; libff::alt_bn128_G1 product{n * *x}; return encode_g1_element(product); } static constexpr size_t kSnarkvStride{192}; uint64_t snarkv_gas(ByteView input, evmc_revision rev) noexcept { uint64_t k{input.size() / kSnarkvStride}; return rev >= EVMC_ISTANBUL ? 34'000 * k + 45'000 : 80'000 * k + 100'000; } std::optional snarkv_run(ByteView input) noexcept { if (input.size() % kSnarkvStride != 0) { return std::nullopt; } size_t k{input.size() / kSnarkvStride}; init_libff(); using namespace libff; static const auto kOne{alt_bn128_Fq12::one()}; auto accumulator{kOne}; for (size_t i{0}; i < k; ++i) { std::optional a{decode_g1_element(&input[i * kSnarkvStride])}; if (!a) { return std::nullopt; } std::optional b{decode_g2_element(&input[i * kSnarkvStride + 64])}; if (!b) { return std::nullopt; } if (a->is_zero() || b->is_zero()) { continue; } accumulator = accumulator * alt_bn128_miller_loop(alt_bn128_precompute_G1(*a), alt_bn128_precompute_G2(*b)); } Bytes out(32, 0); if (alt_bn128_final_exponentiation(accumulator) == kOne) { out[31] = 1; } return out; } uint64_t blake2_f_gas(ByteView input, evmc_revision) noexcept { if (input.size() < 4) { // blake2_f_run will fail anyway return 0; } return endian::load_big_u32(input.data()); } std::optional blake2_f_run(ByteView input) noexcept { if (input.size() != 213) { return std::nullopt; } const uint8_t f{input[212]}; if (f != 0 && f != 1) { return std::nullopt; } uint64_t h[8]; std::memcpy(h, &input[4], sizeof(h)); uint64_t m[16]; std::memcpy(m, &input[68], sizeof(m)); uint64_t t[2]; std::memcpy(t, &input[196], sizeof(t)); static_assert(std::endian::native == std::endian::little); uint32_t r{endian::load_big_u32(input.data())}; evmone::crypto::blake2b_compress(r, h, m, t, f != 0); Bytes out(sizeof(h), 0); std::memcpy(&out[0], h, sizeof(h)); return out; } uint64_t point_evaluation_gas(ByteView, evmc_revision) noexcept { return 50000; } // https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile std::optional point_evaluation_run(ByteView input) noexcept { if (input.size() != 192) { return std::nullopt; } std::span versioned_hash{&input[0], 32}; std::span z{&input[32], 32}; std::span y{&input[64], 32}; std::span commitment{&input[96], 48}; std::span proof{&input[144], 48}; if (!evmone::crypto::kzg_verify_proof( std::as_bytes(versioned_hash).data(), std::as_bytes(z).data(), std::as_bytes(y).data(), std::as_bytes(commitment).data(), std::as_bytes(proof).data())) { return std::nullopt; } return from_hex( "0000000000000000000000000000000000000000000000000000000000001000" "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001"); } bool is_precompile(const evmc::address& address, evmc_revision rev) noexcept { using namespace evmc::literals; static_assert(std::size(kContracts) < 256); static constexpr evmc::address kMaxOneByteAddress{0x00000000000000000000000000000000000000ff_address}; if (address > kMaxOneByteAddress) { return false; } const uint8_t num{address.bytes[kAddressLength - 1]}; if (num >= std::size(kContracts) || !kContracts[num]) { return false; } return kContracts[num]->added_in <= rev; } } // namespace silkworm::precompile ================================================ FILE: silkworm/core/execution/precompile.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include // See Yellow Paper, Appendix E "Precompiled Contracts" namespace silkworm::precompile { using GasFunction = uint64_t (*)(ByteView input, evmc_revision) noexcept; using RunFunction = std::optional (*)(ByteView input) noexcept; struct Contract { GasFunction gas; RunFunction run; }; uint64_t ecrec_gas(ByteView input, evmc_revision) noexcept; std::optional ecrec_run(ByteView input) noexcept; uint64_t sha256_gas(ByteView input, evmc_revision) noexcept; std::optional sha256_run(ByteView input) noexcept; uint64_t rip160_gas(ByteView input, evmc_revision) noexcept; std::optional rip160_run(ByteView input) noexcept; uint64_t id_gas(ByteView input, evmc_revision) noexcept; std::optional id_run(ByteView input) noexcept; // EIP-2565: ModExp Gas Cos uint64_t expmod_gas(ByteView input, evmc_revision) noexcept; // EIP-198: Big integer modular exponentiation std::optional expmod_run(ByteView input) noexcept; // EIP-196: Precompiled contracts for addition and scalar multiplication on the elliptic curve alt_bn128 uint64_t bn_add_gas(ByteView input, evmc_revision) noexcept; std::optional bn_add_run(ByteView input) noexcept; // EIP-196: Precompiled contracts for addition and scalar multiplication on the elliptic curve alt_bn128 uint64_t bn_mul_gas(ByteView input, evmc_revision) noexcept; std::optional bn_mul_run(ByteView input) noexcept; // EIP-197: Precompiled contracts for optimal ate pairing check on the elliptic curve alt_bn128 uint64_t snarkv_gas(ByteView input, evmc_revision) noexcept; std::optional snarkv_run(ByteView input) noexcept; // EIP-152: Add BLAKE2 compression function `F` precompile uint64_t blake2_f_gas(ByteView input, evmc_revision) noexcept; std::optional blake2_f_run(ByteView input) noexcept; // EIP-4844: Shard Blob Transactions uint64_t point_evaluation_gas(ByteView input, evmc_revision) noexcept; std::optional point_evaluation_run(ByteView input) noexcept; struct SupportedContract { Contract contract; evmc_revision added_in; }; inline constexpr std::optional kContracts[]{ std::nullopt, // 0x00 SupportedContract{{ecrec_gas, ecrec_run}, EVMC_FRONTIER}, // 0x01 SupportedContract{{sha256_gas, sha256_run}, EVMC_FRONTIER}, // 0x02 SupportedContract{{rip160_gas, rip160_run}, EVMC_FRONTIER}, // 0x03 SupportedContract{{id_gas, id_run}, EVMC_FRONTIER}, // 0x04 SupportedContract{{expmod_gas, expmod_run}, EVMC_BYZANTIUM}, // 0x05 SupportedContract{{bn_add_gas, bn_add_run}, EVMC_BYZANTIUM}, // 0x06 SupportedContract{{bn_mul_gas, bn_mul_run}, EVMC_BYZANTIUM}, // 0x07 SupportedContract{{snarkv_gas, snarkv_run}, EVMC_BYZANTIUM}, // 0x08 SupportedContract{{blake2_f_gas, blake2_f_run}, EVMC_ISTANBUL}, // 0x09 SupportedContract{{point_evaluation_gas, point_evaluation_run}, EVMC_CANCUN}, // 0x0a }; bool is_precompile(const evmc::address&, evmc_revision) noexcept; } // namespace silkworm::precompile ================================================ FILE: silkworm/core/execution/precompile_benchmark.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include static void ec_recovery(benchmark::State& state) { using namespace silkworm; Bytes in{ *from_hex("18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c0000000000000000000000000000" "00000000000000000000000000000000001c73b1693892219d736caba55bdb67216e485557ea6b6af75f37096c9a" "a6a5a75feeb940b1d03b21e36b0e47e79769f095fe2ab855bd91e3a38756b7d75a9c4549")}; for ([[maybe_unused]] auto _ : state) { precompile::ecrec_run(in); } } BENCHMARK(ec_recovery); ================================================ FILE: silkworm/core/execution/precompile_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "precompile.hpp" #include #include namespace silkworm::precompile { using namespace evmc::literals; TEST_CASE("Ecrecover") { Bytes in{ *from_hex("18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c0000000000000000000000000000" "00000000000000000000000000000000001c73b1693892219d736caba55bdb67216e485557ea6b6af75f37096c9a" "a6a5a75feeb940b1d03b21e36b0e47e79769f095fe2ab855bd91e3a38756b7d75a9c4549")}; std::optional out{ecrec_run(in)}; REQUIRE(out); CHECK(to_hex(*out) == "000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"); // Unrecoverable key in = *from_hex( "a8b53bdf3306a35a7103ab5504a0c9b492295564b6202b1942a84ef3001072810000000000000000000000000000" "00000000000000000000000000000000001b30783565316530336635336365313862373732636362303039336666" "37316633663533663563373562373464636233316138356161386238383932623465386211223344556677889910" "11121314151617181920212223242526272829303132"); out = ecrec_run(in); CHECK((out && out->empty())); } TEST_CASE("SHA256") { Bytes in{ *from_hex("38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9ed98873e0000000000000000000000000000" "00000000000000000000000000000000001b38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9" "ed98873e789d1dd423d25f0772d2748d60f7e4b81bb14d086eba8e8e8efb6dcff8a4ae02")}; std::optional out{sha256_run(in)}; REQUIRE(out); CHECK(to_hex(*out) == "811c7003375852fabd0d362e40e68607a12bdabae61a7d068fe5fdd1dbbf2a5d"); } TEST_CASE("RIPEMD160") { Bytes in{ *from_hex("38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9ed98873e0000000000000000000000000000" "00000000000000000000000000000000001b38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9" "ed98873e789d1dd423d25f0772d2748d60f7e4b81bb14d086eba8e8e8efb6dcff8a4ae02")}; std::optional out{rip160_run(in)}; REQUIRE(out); CHECK(to_hex(*out) == "0000000000000000000000009215b8d9882ff46f0dfde6684d78e831467f65e6"); } TEST_CASE("EXPMOD") { Bytes in{ *from_hex("0000000000000000000000000000000000000000000000000000000000000001" "0000000000000000000000000000000000000000000000000000000000000020" "0000000000000000000000000000000000000000000000000000000000000020" "03" "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2e" "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f")}; CHECK(expmod_gas(in, EVMC_BYZANTIUM) == 13056); std::optional out{expmod_run(in)}; REQUIRE(out); CHECK(to_hex(*out) == "0000000000000000000000000000000000000000000000000000000000000001"); in = *from_hex( "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000020" "0000000000000000000000000000000000000000000000000000000000000020" "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2e" "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"); out = expmod_run(in); REQUIRE(out); CHECK(to_hex(*out) == "0000000000000000000000000000000000000000000000000000000000000000"); in = *from_hex( "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000020" "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe" "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd"); CHECK(expmod_gas(in, EVMC_BYZANTIUM) == UINT64_MAX); CHECK(expmod_gas(in, EVMC_BERLIN) == UINT64_MAX); in = *from_hex( "0000000000000000000000000000000000000000000000000000000000000100" "0000000000000000000000000000000000000000000000000000000000000003" "0000000000000000000000000000000000000000000000000000000000000100" "94fff7dfe2f9c757463dab3aaa4103e9b820bed33aaa0f2b6c0ec056d338288dcd7c568aeb0a1c7bfdde436f4c69" "f242f79661df1d8c5b65836a41070f0b562002c67c5e6037b1e4d9e7c9e4e5faf6c9d3b46ed618b75dbf01c8f519" "ebd5afde96cf446a1cbd6fa58077592d22bdb661c16ebd9a207571f331d8e45eb0e3f58731eda925429d4e10d823" "fed0a6819ce94f68791bc90222b2f767e884858b5d054ac6fbfb0ec6dbdc88371bed2a85e13c2fd3f85963b7e8d0" "06373f9a7dd295ce1e87fdb28e3a9e1a3851169e24042bb401b872a0bdd55e8b36a01efed0d65fc3adf94dbf5eb3" "7365afa8add999aa5fcb772439f607c6127c32c7fe920efd7b74" "010001" "aa05b012cda6a5d91d80dc970a252e4b70aff168381da61bd7c655db438afe1322cc387442a8a801f974dbf4ffb1" "10e5b68c03202ca47470bda7cff40c50c2762a0e45222a4df1e6c6d69a1dccafd1535a1bb82d6c17dd2ac04b8d02" "6092d4189ab630d1348baac2ff5612faf07961f48482571f59e922c744dab8b9c7acf6295fcc72566626c6423776" "1c9d571616e1cbeef439413f348f9c6e89226a971b393fc8d45472951d68897eaf264acdbb5cd54b6c4ea520b45c" "3abbbd78fa27dd113921d3facbcc1d6040243c9761867c69a1dc13d9f71898121ff696561458d9d9f87536d6a84f" "b602c91f9b07e561fa2f54eb0f9f1984f3cbe728ec142cbed52f"); CHECK(expmod_gas(in, EVMC_BYZANTIUM) == 30310); CHECK(expmod_gas(in, EVMC_BERLIN) == 5461); } TEST_CASE("BN_ADD") { Bytes in{ *from_hex("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000" "00000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000" "000000010000000000000000000000000000000000000000000000000000000000000002")}; std::optional out{bn_add_run(in)}; REQUIRE(out); CHECK(to_hex(*out) == "030644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd315ed738c0e0a7c92e7845f96b2" "ae9c0a68a6a449e3538fc7ff3ebf7a5a18a2c4"); } TEST_CASE("BN_MUL") { Bytes in{ *from_hex("1a87b0584ce92f4593d161480614f2989035225609f08058ccfa3d0f940febe31a2f3c951f6dadcc7ee" "9007dff81504b0fcd6d7cf59996efdc33d92bf7f9f8f600000000000000000000000000000000000000" "00000000000000000000000009")}; std::optional out{bn_mul_run(in)}; REQUIRE(out); CHECK(to_hex(*out) == "1dbad7d39dbc56379f78fac1bca147dc8e66de1b9d183c7b167351bfe0aeab742cd757d51289cd8dbd0acf9e67" "3ad67d0f0a89f912af47ed1be53664f5692575"); } TEST_CASE("SNARKV") { // empty input Bytes in{}; std::optional out{snarkv_run(in)}; REQUIRE(out); CHECK(to_hex(*out) == "0000000000000000000000000000000000000000000000000000000000000001"); // input size is not a multiple of 192 in = *from_hex("ab"); out = snarkv_run(in); CHECK(!out); in = *from_hex( "0f25929bcb43d5a57391564615c9e70a992b10eafa4db109709649cf48c50dd216da2f5cb6be7a0aa72c440c53c9" "bbdfec6c36c7d515536431b3a865468acbba2e89718ad33c8bed92e210e81d1853435399a271913a6520736a4729" "cf0d51eb01a9e2ffa2e92599b68e44de5bcf354fa2642bd4f26b259daa6f7ce3ed57aeb314a9a87b789a58af499b" "314e13c3d65bede56c07ea2d418d6874857b70763713178fb49a2d6cd347dc58973ff49613a20757d0fcc22079f9" "abd10c3baee245901b9e027bd5cfc2cb5db82d4dc9677ac795ec500ecd47deee3b5da006d6d049b811d7511c7815" "8de484232fc68daf8a45cf217d1c2fae693ff5871e8752d73b21198e9393920d483a7260bfb731fb5d25f1aa4933" "35a9e71297e485b7aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed0906" "89d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408f" "e3d1e7690c43d37b4ce6cc0166fa7daa"); out = snarkv_run(in); REQUIRE(out); CHECK(to_hex(*out) == "0000000000000000000000000000000000000000000000000000000000000001"); in = *from_hex( "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000" "000000000000000000000000000000000002198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7" "aef312c21800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed090689d0585ff075ec9e" "99ad690c3395bc4b313370b38ef355acdadcd122975b12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b" "4ce6cc0166fa7daa"); out = snarkv_run(in); REQUIRE(out); CHECK(to_hex(*out) == "0000000000000000000000000000000000000000000000000000000000000000"); } // https://eips.ethereum.org/EIPS/eip-152#test-cases TEST_CASE("BLAKE2") { Bytes in{ *from_hex("00000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e" "2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000300000000000000000000000000000001")}; std::optional out{blake2_f_run(in)}; CHECK(!out); in = *from_hex( "000000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f" "6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b6162630000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000300000000000000000000000000000001"); out = blake2_f_run(in); CHECK(!out); in = *from_hex( "0000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c" "3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b616263000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000300000000000000000000000000000002"); out = blake2_f_run(in); CHECK(!out); in = *from_hex( "0000000048c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c" "3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b616263000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000300000000000000000000000000000001"); out = blake2_f_run(in); REQUIRE(out); CHECK(to_hex(*out) == "08c9bcf367e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d282e6ad7f520e511f6c3e2b8c" "68059b9442be0454267ce079217e1319cde05b"); in = *from_hex( "0000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c" "3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b616263000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000300000000000000000000000000000001"); out = blake2_f_run(in); REQUIRE(out); CHECK(to_hex(*out) == "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de45" "33cc9518d38aa8dbf1925ab92386edd4009923"); in = *from_hex( "0000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c" "3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b616263000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000300000000000000000000000000000000"); out = blake2_f_run(in); REQUIRE(out); CHECK(to_hex(*out) == "75ab69d3190a562c51aef8d88f1c2775876944407270c42c9844252c26d2875298743e7f6d5ea2f2d3e8d22603" "9cd31b4e426ac4f2d3d666a610c2116fde4735"); in = *from_hex( "0000000148c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c" "3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b616263000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000300000000000000000000000000000001"); out = blake2_f_run(in); REQUIRE(out); CHECK(to_hex(*out) == "b63a380cb2897d521994a85234ee2c181b5f844d2c624c002677e9703449d2fba551b3a8333bcdf5f2f7e08993" "d53923de3d64fcc68c034e717b9293fed7a421"); } // https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile TEST_CASE("POINT_EVALUATION") { static constexpr intx::uint256 kBlsModulus{intx::from_string( "52435875175126190479447740508185965837690552500527637822603658699938581184513")}; Bytes in{ *from_hex( "014edfed8547661f6cb416eba53061a2f6dce872c0497e6dd485a876fe2567f1" "564c0a11a0f704f4fc3e8acfe0f8245f0ad1347b378fbf96e206da11a5d36306" "6d928e13fe443e957d82e3e71d48cb65d51028eb4483e719bf8efcdf12f7c321" "a421e229565952cfff4ef3517100a97da1d4fe57956fa50a442f92af03b1bf37adacc8ad4ed209b31287ea5bb94d9d06" "a444d6bb5aadc3ceb615b50d6606bd54bfe529f59247987cd1ab848d19de599a9052f1835fb0d0d44cf70183e19a68c9")}; std::optional out{point_evaluation_run(in)}; REQUIRE((out && out->size() == 64)); intx::uint256 field_elements_per_blob{intx::be::unsafe::load(out->data())}; CHECK(field_elements_per_blob == 4096); intx::uint256 bls_modulus{intx::be::unsafe::load(out->data() + 32)}; CHECK(bls_modulus == kBlsModulus); // change hash version in[0] = 0x2; out = point_evaluation_run(in); CHECK(!out); in[0] = 0x1; // truncate input in.pop_back(); out = point_evaluation_run(in); CHECK(!out); in.push_back(0xba); // extra input in.push_back(0); out = point_evaluation_run(in); CHECK(!out); in.pop_back(); // Try z > BLS_MODULUS intx::uint256 z{intx::le::unsafe::load(&in[32])}; z += kBlsModulus; intx::le::unsafe::store(&in[32], z); out = point_evaluation_run(in); CHECK(!out); } TEST_CASE("is_precompile") { CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_FRONTIER) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_FRONTIER) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_FRONTIER) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_FRONTIER) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_FRONTIER) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_HOMESTEAD) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_HOMESTEAD) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_HOMESTEAD) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_HOMESTEAD) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_HOMESTEAD) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_SPURIOUS_DRAGON) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_SPURIOUS_DRAGON) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_SPURIOUS_DRAGON) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_SPURIOUS_DRAGON) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_SPURIOUS_DRAGON) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_BYZANTIUM) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_BYZANTIUM) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_CONSTANTINOPLE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_CONSTANTINOPLE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_PETERSBURG) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_PETERSBURG) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_ISTANBUL) == true); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_ISTANBUL) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_BERLIN) == true); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_BERLIN) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_BERLIN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_SHANGHAI) == true); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_SHANGHAI) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_CANCUN) == true); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_CANCUN) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_CANCUN) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000000_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000001_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000002_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000003_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000004_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000005_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000006_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000007_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000008_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x0000000000000000000000000000000000000009_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x000000000000000000000000000000000000000a_address, EVMC_PRAGUE) == true); CHECK(is_precompile(0x000000000000000000000000000000000000000b_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000c_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000d_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000e_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x000000000000000000000000000000000000000f_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000010_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000011_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000012_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000013_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000014_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000015_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000016_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000017_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x00000000000000000000000000000000000000ff_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0000000000000000000000000000000000000100_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x00000000000000000000000000000000000001ff_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0x0100000000000000000000000000000000000000_address, EVMC_PRAGUE) == false); CHECK(is_precompile(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, EVMC_PRAGUE) == false); } } // namespace silkworm::precompile ================================================ FILE: silkworm/core/execution/processor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "processor.hpp" #include #include #include #include #include namespace silkworm { class StateView final : public evmone::state::StateView { IntraBlockState& state_; public: explicit StateView(IntraBlockState& state) noexcept : state_{state} {} std::optional get_account(const evmc::address& addr) const noexcept override { const auto* obj = state_.get_object(addr); if (obj == nullptr || !obj->current.has_value()) return std::nullopt; const auto& cur = *obj->current; return Account{ .nonce = cur.nonce, .balance = cur.balance, .code_hash = cur.code_hash, // This information is only needed to implement EIP-7610 (create address collision). // Proper way of doing so is to inspect the account's storage root hash, // but this information is currently unavailable to EVM. // The false value is safe "do nothing" option. .has_storage = false, }; } evmone::bytes get_account_code(const evmc::address& addr) const noexcept override { return evmone::bytes{state_.get_code(addr)}; } evmc::bytes32 get_storage(const evmc::address& addr, const evmc::bytes32& key) const noexcept override { return state_.get_original_storage(addr, key); } }; namespace { class BlockHashes final : public evmone::state::BlockHashes { EVM& evm_; public: explicit BlockHashes(EVM& evm) noexcept : evm_{evm} {} evmc::bytes32 get_block_hash(int64_t block_number) const noexcept override { return evm_.get_block_hash(block_number); } }; /// Checks the result of the transaction execution in evmone (APIv2) /// against the result produced by Silkworm. void check_evm1_execution_result(const evmone::state::StateDiff& state_diff, const IntraBlockState& state) { for (const auto& entry : state_diff.modified_accounts) { if (std::ranges::find(state_diff.deleted_accounts, entry.addr) != state_diff.deleted_accounts.end()) { continue; } for (const auto& [k, v] : entry.modified_storage) { auto expected = state.get_current_storage(entry.addr, k); if (v != expected) { std::cerr << "k: " << hex(k) << "e1: " << hex(v) << ", silkworm: " << hex(expected) << "\n"; } } } for (const auto& a : state_diff.deleted_accounts) { SILKWORM_ASSERT(!state.exists(a)); } for (const auto& m : state_diff.modified_accounts) { if (std::ranges::find(state_diff.deleted_accounts, m.addr) != state_diff.deleted_accounts.end()) { continue; } SILKWORM_ASSERT(state.get_nonce(m.addr) == m.nonce); if (m.balance != state.get_balance(m.addr)) { std::cerr << "b: " << hex(m.addr) << " " << to_string(m.balance) << ", silkworm: " << to_string(state.get_balance(m.addr)) << "\n"; SILKWORM_ASSERT(state.get_balance(m.addr) == m.balance); } if (m.code) { SILKWORM_ASSERT(state.get_code(m.addr) == m.code); } } } } // namespace ExecutionProcessor::ExecutionProcessor(const Block& block, protocol::RuleSet& rule_set, State& state, const ChainConfig& config, bool evm1_v2) : state_{state}, rule_set_{rule_set}, evm_{block, state_, config}, evm1_v2_{evm1_v2} { evm_.beneficiary = rule_set.get_beneficiary(block.header); evm_.transfer = rule_set.transfer_func(); evm1_block_ = { .number = static_cast(block.header.number), .timestamp = static_cast(block.header.timestamp), .gas_limit = static_cast(block.header.gas_limit), .coinbase = block.header.beneficiary, .difficulty = static_cast(block.header.difficulty), .prev_randao = block.header.difficulty == 0 ? block.header.prev_randao : intx::be::store(intx::uint256{block.header.difficulty}), .base_fee = static_cast(block.header.base_fee_per_gas.value_or(0)), .excess_blob_gas = block.header.excess_blob_gas.value_or(0), .blob_base_fee = block.header.blob_gas_price().value_or(0), }; for (const auto& o : block.ommers) evm1_block_.ommers.emplace_back(evmone::state::Ommer{o.beneficiary, static_cast(block.header.number - o.number)}); if (block.withdrawals) { for (const auto& w : *block.withdrawals) evm1_block_.withdrawals.emplace_back(evmone::state::Withdrawal{w.index, w.validator_index, w.address, w.amount}); } } void ExecutionProcessor::execute_transaction(const Transaction& txn, Receipt& receipt) noexcept { // Plain debug assertion instead of SILKWORM_ASSERT not to validate txn twice (see execute_block_no_post_validation) assert(protocol::validate_transaction(txn, state_, available_gas()) == ValidationResult::kOk); StateView evm1_state_view{state_}; BlockHashes evm1_block_hashes{evm_}; evmone::state::Transaction evm1_txn{ .type = static_cast(txn.type), .data = txn.data, .gas_limit = static_cast(txn.gas_limit), .max_gas_price = txn.max_fee_per_gas, .max_priority_gas_price = txn.max_priority_fee_per_gas, .max_blob_gas_price = txn.max_fee_per_blob_gas, .sender = *txn.sender(), .to = txn.to, .value = txn.value, // access_list // blob_hashes // TODO: This should be corrected in the evmone APIv2, // because it uses transaction's chain id for CHAINID instruction. .chain_id = evm().config().chain_id, .nonce = txn.nonce}; for (const auto& [account, storage_keys] : txn.access_list) evm1_txn.access_list.emplace_back(account, storage_keys); for (const evmc::bytes32& h : txn.blob_versioned_hashes) evm1_txn.blob_hashes.emplace_back(h); for (const auto& authorization : txn.authorizations) { evm1_txn.authorization_list.push_back({.chain_id = authorization.chain_id, .addr = authorization.address, .nonce = authorization.nonce, .signer = authorization.recover_authority(txn), .r = authorization.r, .s = authorization.s, .v = authorization.v()}); } const auto rev = evm_.revision(); const auto g0 = protocol::intrinsic_gas(txn, rev); SILKWORM_ASSERT(g0 <= INT64_MAX); // true due to the precondition (transaction must be valid) const auto execution_gas_limit = txn.gas_limit - static_cast(g0); // Execute transaction with evmone APIv2. // This must be done before the Silkworm execution so that the state is unmodified. // evmone will not modify the state itself: state is read-only and the state modifications // are provided as the state diff in the returned receipt. // EIP-7623: Increase calldata cost const int64_t floor_cost = rev >= EVMC_PRAGUE ? static_cast(protocol::floor_cost(txn)) : 0; auto evm1_receipt = evmone::state::transition( evm1_state_view, evm1_block_, evm1_block_hashes, evm1_txn, rev, evm_.vm(), {.execution_gas_limit = static_cast(execution_gas_limit), .min_gas_cost = floor_cost}); auto gas_used = static_cast(evm1_receipt.gas_used); cumulative_gas_used_ += gas_used; // Prepare the receipt using the result from evmone. receipt.type = txn.type; receipt.success = evm1_receipt.status == EVMC_SUCCESS; receipt.cumulative_gas_used = cumulative_gas_used_; receipt.logs.clear(); // can be dirty receipt.logs.reserve(evm1_receipt.logs.size()); for (auto& [addr, data, topics] : evm1_receipt.logs) receipt.logs.emplace_back(Log{addr, std::move(topics), std::move(data)}); receipt.bloom = logs_bloom(receipt.logs); if (evm1_v2_) { // Apply the state diff produced by evmone APIv2 to the state and skip the Silkworm execution. const auto& state_diff = evm1_receipt.state_diff; for (const auto& m : state_diff.modified_accounts) { if (m.code) { state_.create_contract(m.addr, eip7702::is_code_delegated(*m.code)); state_.set_code(m.addr, *m.code); } auto& acc = state_.get_or_create_object(m.addr); acc.current->nonce = m.nonce; acc.current->balance = m.balance; auto& storage = state_.storage_[m.addr]; for (const auto& [k, v] : m.modified_storage) { storage.committed[k].original = v; } } for (const auto& a : state_diff.deleted_accounts) { state_.destruct(a); } return; } state_.clear_journal_and_substate(); const std::optional sender{txn.sender()}; SILKWORM_ASSERT(sender); update_access_lists(*sender, txn, rev); if (txn.to) { // EVM itself increments the nonce for contract creation state_.set_nonce(*sender, txn.nonce + 1); } const BlockHeader& header{evm_.block().header}; const intx::uint256 sender_initial_balance{state_.get_balance(*sender)}; const intx::uint256 recipient_initial_balance{state_.get_balance(evm_.beneficiary)}; // EIP-1559 normal gas cost const intx::uint256 base_fee_per_gas{header.base_fee_per_gas.value_or(0)}; const intx::uint256 effective_gas_price{txn.effective_gas_price(base_fee_per_gas)}; state_.subtract_from_balance(*sender, txn.gas_limit * effective_gas_price); // EIP-4844 blob gas cost (calc_data_fee) const intx::uint256 blob_gas_price{header.blob_gas_price().value_or(0)}; state_.subtract_from_balance(*sender, txn.total_blob_gas() * blob_gas_price); const CallResult vm_res = evm_.execute(txn, execution_gas_limit); SILKWORM_ASSERT((vm_res.status == EVMC_SUCCESS) == receipt.success); SILKWORM_ASSERT(state_.logs().size() == receipt.logs.size()); auto gas_left = calculate_refund_gas(txn, vm_res.gas_left, vm_res.gas_refund); gas_used = txn.gas_limit - gas_left; // EIP-7623: Increase calldata cost if (evm().revision() >= EVMC_PRAGUE) { gas_used = std::max(gas_used, protocol::floor_cost(txn)); SILKWORM_ASSERT(gas_used <= txn.gas_limit); } gas_left = txn.gas_limit - gas_used; state_.add_to_balance(*txn.sender(), gas_left * effective_gas_price); // award the fee recipient const intx::uint256 amount{txn.priority_fee_per_gas(base_fee_per_gas) * gas_used}; state_.add_to_balance(evm_.beneficiary, amount); if (rev >= EVMC_LONDON) { const evmc::address* burnt_contract{protocol::bor::config_value_lookup(evm_.config().burnt_contract, header.number)}; if (burnt_contract) { const intx::uint256 would_be_burnt{gas_used * base_fee_per_gas}; state_.add_to_balance(*burnt_contract, would_be_burnt); } } rule_set_.add_fee_transfer_log(state_, amount, *sender, sender_initial_balance, evm_.beneficiary, recipient_initial_balance); state_.finalize_transaction(rev); check_evm1_execution_result(evm1_receipt.state_diff, state_); } CallResult ExecutionProcessor::call(const Transaction& txn, const std::vector>& tracers, bool refund) noexcept { const std::optional sender{txn.sender()}; SILKWORM_ASSERT(sender); ValidationResult validation_result = protocol::validate_call_precheck(txn, evm_); if (validation_result != ValidationResult::kOk) { return {validation_result, EVMC_SUCCESS, 0, {}, {}}; } const BlockHeader& header{evm_.block().header}; const intx::uint256 base_fee_per_gas{header.base_fee_per_gas.value_or(0)}; const intx::uint256 effective_gas_price{txn.max_fee_per_gas >= base_fee_per_gas ? txn.effective_gas_price(base_fee_per_gas) : txn.max_priority_fee_per_gas}; for (auto& tracer : tracers) { evm_.add_tracer(*tracer); } const evmc_revision rev{evm_.revision()}; update_access_lists(*sender, txn, rev); if (txn.to) { state_.set_nonce(*sender, state_.get_nonce(*txn.sender()) + 1); } intx::uint256 required_funds = protocol::compute_call_cost(txn, effective_gas_price, evm_); if (evm().bailout) { // If the bailout option is on, add the required funds to the sender's balance // so that after the transaction costs are deducted, the sender's balance is unchanged. state_.add_to_balance(*txn.sender(), required_funds); } validation_result = protocol::validate_call_funds(txn, evm_, state_.get_balance(*txn.sender()), evm().bailout); if (validation_result != ValidationResult::kOk) { return {validation_result, EVMC_SUCCESS, 0, {}, {}}; } state_.subtract_from_balance(*txn.sender(), required_funds); const intx::uint128 g0{protocol::intrinsic_gas(txn, evm_.revision())}; const auto result = evm_.execute(txn, txn.gas_limit - static_cast(g0)); uint64_t gas_left{result.gas_left}; uint64_t gas_used{txn.gas_limit - result.gas_left}; uint64_t gas_refund = 0; if (refund && !evm().bailout) { const uint64_t gas_left_plus_refund = calculate_refund_gas(txn, result.gas_left, result.gas_refund); gas_refund = gas_left_plus_refund - result.gas_left; gas_used = txn.gas_limit - gas_left_plus_refund; // EIP-7623: Increase calldata cost if (evm().revision() >= EVMC_PRAGUE) { gas_used = std::max(gas_used, protocol::floor_cost(txn)); SILKWORM_ASSERT(gas_used <= txn.gas_limit); } gas_left = txn.gas_limit - gas_used; state_.add_to_balance(*txn.sender(), gas_left * effective_gas_price); } // Reward the fee recipient const intx::uint256 priority_fee_per_gas{txn.max_fee_per_gas >= base_fee_per_gas ? txn.priority_fee_per_gas(base_fee_per_gas) : txn.max_priority_fee_per_gas}; state_.add_to_balance(evm_.beneficiary, priority_fee_per_gas * gas_used); for (auto& tracer : evm_.tracers()) { tracer.get().on_reward_granted(result, state_); } state_.finalize_transaction(evm_.revision()); evm_.remove_tracers(); return {ValidationResult::kOk, result.status, gas_left, gas_refund, gas_used, result.data, result.error_message}; } void ExecutionProcessor::reset() { state_.clear_journal_and_substate(); } uint64_t ExecutionProcessor::available_gas() const noexcept { return evm_.block().header.gas_limit - cumulative_gas_used_; } void ExecutionProcessor::update_access_lists(const evmc::address& sender, const Transaction& txn, evmc_revision rev) noexcept { state_.access_account(sender); if (txn.to) { state_.access_account(*txn.to); } for (const AccessListEntry& ae : txn.access_list) { state_.access_account(ae.account); for (const evmc::bytes32& key : ae.storage_keys) { state_.access_storage(ae.account, key); } } if (rev >= EVMC_SHANGHAI) { // EIP-3651: Warm COINBASE state_.access_account(evm_.beneficiary); } } uint64_t ExecutionProcessor::calculate_refund_gas(const Transaction& txn, uint64_t gas_left, uint64_t gas_refund) const noexcept { const evmc_revision rev{evm_.revision()}; const uint64_t max_refund_quotient{rev >= EVMC_LONDON ? protocol::kMaxRefundQuotientLondon : protocol::kMaxRefundQuotientFrontier}; const uint64_t max_refund{(txn.gas_limit - gas_left) / max_refund_quotient}; uint64_t refund = std::min(gas_refund, max_refund); gas_left += refund; return gas_left; } ValidationResult ExecutionProcessor::execute_block_no_post_validation(std::vector& receipts) noexcept { const evmc_revision rev{evm_.revision()}; rule_set_.initialize(evm_); state_.finalize_transaction(rev); cumulative_gas_used_ = 0; const Block& block{evm_.block()}; notify_block_execution_start(block); receipts.resize(block.transactions.size()); auto receipt_it{receipts.begin()}; for (const auto& txn : block.transactions) { const ValidationResult err{protocol::validate_transaction(txn, state_, available_gas())}; if (err != ValidationResult::kOk) { return err; } execute_transaction(txn, *receipt_it); ++receipt_it; } std::vector logs; logs.reserve(receipts.size()); for (const auto& receipt : receipts) { std::ranges::copy(receipt.logs, std::back_inserter(logs)); } state_.clear_journal_and_substate(); const auto finalization_result = rule_set_.finalize(state_, block, evm_, logs); state_.finalize_transaction(rev); notify_block_execution_end(block); return finalization_result; } ValidationResult ExecutionProcessor::execute_block(std::vector& receipts) noexcept { if (const ValidationResult res{execute_block_no_post_validation(receipts)}; res != ValidationResult::kOk) { return res; } const auto& header{evm_.block().header}; if (cumulative_gas_used_ != header.gas_used) { return ValidationResult::kWrongBlockGas; } if (evm_.revision() >= EVMC_BYZANTIUM) { // Prior to Byzantium (EIP-658), receipts contained the root of the state after each individual transaction. // We don't calculate such intermediate state roots and thus can't verify the receipt root before Byzantium. static constexpr auto kEncoder = [](Bytes& to, const Receipt& r) { rlp::encode(to, r); }; evmc::bytes32 receipt_root{trie::root_hash(receipts, kEncoder)}; if (receipt_root != header.receipts_root) { return ValidationResult::kWrongReceiptsRoot; } } Bloom bloom{}; // zero initialization for (const Receipt& receipt : receipts) { join(bloom, receipt.bloom); } if (bloom != header.logs_bloom) { return ValidationResult::kWrongLogsBloom; } return ValidationResult::kOk; } void ExecutionProcessor::flush_state() { state_.write_to_db(evm_.block().header.number); } //! \brief Notify the registered tracers at the start of block execution. void ExecutionProcessor::notify_block_execution_start(const Block& block) { for (auto& tracer : evm_.tracers()) { tracer.get().on_block_start(block); } } //! \brief Notify the registered tracers at the end of block execution. void ExecutionProcessor::notify_block_execution_end(const Block& block) { for (auto& tracer : evm_.tracers()) { tracer.get().on_block_end(block); } } } // namespace silkworm ================================================ FILE: silkworm/core/execution/processor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm { class ExecutionProcessor { public: ExecutionProcessor(const ExecutionProcessor&) = delete; ExecutionProcessor& operator=(const ExecutionProcessor&) = delete; ExecutionProcessor(const Block& block, protocol::RuleSet& rule_set, State& state, const ChainConfig& config, bool evm1_v2); /** * Execute a transaction, but do not write to the DB yet. * Precondition: transaction must be valid. */ void execute_transaction(const Transaction& txn, Receipt& receipt) noexcept; CallResult call(const Transaction& txn, const std::vector>& tracers, bool refund) noexcept; //! \brief Execute the block. //! \remarks Warning: This method does not verify state root; pre-Byzantium receipt root isn't validated either. //! \pre RuleSet's validate_block_header & pre_validate_block_body must return kOk. ValidationResult execute_block(std::vector& receipts) noexcept; //! \brief Flush IntraBlockState into cumulative State. void flush_state(); uint64_t available_gas() const noexcept; EVM& evm() noexcept { return evm_; } const EVM& evm() const noexcept { return evm_; } IntraBlockState& intra_block_state() { return state_; } const IntraBlockState& intra_block_state() const { return state_; } void reset(); private: //! Update the transaction-context-wide access sets introduced by EIP-2929 and refined in EIP-3651 void update_access_lists(const evmc::address& sender, const Transaction& txn, evmc_revision rev) noexcept; /** * Execute the block, but do not write to the DB yet. * Does not perform any post-execution validation (for example, receipt root is not checked). * Precondition: validate_block_header & pre_validate_block_body must return kOk. */ ValidationResult execute_block_no_post_validation(std::vector& receipts) noexcept; //! \brief Notify the registered tracers at the start of block execution. void notify_block_execution_start(const Block& block); //! \brief Notify the registered tracers at the end of block execution. void notify_block_execution_end(const Block& block); uint64_t calculate_refund_gas(const Transaction& txn, uint64_t gas_left, uint64_t gas_refund) const noexcept; uint64_t cumulative_gas_used_{0}; IntraBlockState state_; protocol::RuleSet& rule_set_; EVM evm_; evmone::state::BlockInfo evm1_block_; //! Execute transactions using evmone APIv2 only and apply the result state diff to the state. bool evm1_v2_ = false; }; } // namespace silkworm ================================================ FILE: silkworm/core/execution/processor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "processor.hpp" #include #include #include #include #include #include namespace silkworm { TEST_CASE("Zero gas price") { Block block{}; block.header.number = 2'687'232; block.header.gas_limit = 3'303'221; block.header.beneficiary = 0x4bb96091ee9d802ed039c4d1a5f6216f90f81b01_address; // The sender does not exist evmc::address sender{0x004512399a230565b99be5c3b0030a56f3ace68c_address}; Transaction txn{}; txn.gas_limit = 764'017; txn.data = *from_hex("0x606060"); txn.odd_y_parity = false; txn.r = 1; txn.s = 1; txn.set_sender(sender); InMemoryState state; auto rule_set{protocol::rule_set_factory(kMainnetConfig)}; ExecutionProcessor processor{block, *rule_set, state, kMainnetConfig, true}; Receipt receipt; processor.execute_transaction(txn, receipt); CHECK(receipt.success); } TEST_CASE("No refund on error") { Block block{}; block.header.number = 10'050'107; block.header.gas_limit = 328'646; block.header.beneficiary = 0x5146556427ff689250ed1801a783d12138c3dd5e_address; evmc::address caller{0x834e9b529ac9fa63b39a06f8d8c9b0d6791fa5df_address}; uint64_t nonce{3}; // This contract initially sets its 0th storage to 0x2a. // When called, it updates the 0th storage to the input provided. Bytes code{*from_hex("602a60005560098060106000396000f36000358060005531")}; /* https://github.com/CoinCulture/evm-tools 0 PUSH1 => 2a 2 PUSH1 => 00 4 SSTORE 5 PUSH1 => 09 7 DUP1 8 PUSH1 => 10 10 PUSH1 => 00 12 CODECOPY 13 PUSH1 => 00 15 RETURN ----------------------------- 16 PUSH1 => 00 18 CALLDATALOAD 19 DUP1 20 PUSH1 => 00 22 SSTORE 23 BALANCE */ InMemoryState state; auto rule_set{protocol::rule_set_factory(kMainnetConfig)}; ExecutionProcessor processor{block, *rule_set, state, kMainnetConfig, true}; Transaction txn{}; txn.nonce = nonce; txn.max_priority_fee_per_gas = 59 * kGiga; txn.max_fee_per_gas = 59 * kGiga; txn.gas_limit = 103'858; txn.data = code; txn.odd_y_parity = false; txn.r = 1; txn.s = 1; processor.evm().state().add_to_balance(caller, kEther); processor.evm().state().set_nonce(caller, nonce); txn.set_sender(caller); Receipt receipt1; processor.execute_transaction(txn, receipt1); CHECK(receipt1.success); // Call the newly created contract txn.nonce = nonce + 1; txn.to = create_address(caller, nonce); // It should run SSTORE(0,0) with a potential refund txn.data.clear(); // But then there's not enough gas for the BALANCE operation txn.gas_limit = protocol::fee::kGTransaction + 5'020; Receipt receipt2; processor.execute_transaction(txn, receipt2); CHECK(!receipt2.success); CHECK(receipt2.cumulative_gas_used - receipt1.cumulative_gas_used == txn.gas_limit); } TEST_CASE("Self-destruct") { Block block{}; block.header.number = 1'487'375; block.header.gas_limit = 4'712'388; block.header.beneficiary = 0x61c808d82a3ac53231750dadc13c777b59310bd9_address; const evmc::address suicidal_address{0x6d20c1c07e56b7098eb8c50ee03ba0f6f498a91d_address}; const evmc::address caller_address{0x4bf2054ffae7a454a35fd8cf4be21b23b1f25a6f_address}; const evmc::address originator{0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c_address}; // The contract self-destructs if called with zero value. Bytes suicidal_code{*from_hex("346007576000ff5b")}; /* https://github.com/CoinCulture/evm-tools 0 CALLVALUE 1 PUSH1 => 07 3 JUMPI 4 PUSH1 => 00 6 SUICIDE 7 JUMPDEST */ // The caller calls the input contract three times: // twice with zero value and once with non-zero value. Bytes caller_code{*from_hex("600080808080803561eeeef150600080808080803561eeeef15060008080806005813561eeeef1")}; /* https://github.com/CoinCulture/evm-tools 0 PUSH1 => 00 2 DUP1 3 DUP1 4 DUP1 5 DUP1 6 DUP1 7 CALLDATALOAD 8 PUSH2 => eeee 11 CALL 12 POP 13 PUSH1 => 00 15 DUP1 16 DUP1 17 DUP1 18 DUP1 19 DUP1 20 CALLDATALOAD 21 PUSH2 => eeee 24 CALL 25 POP 26 PUSH1 => 00 28 DUP1 29 DUP1 30 DUP1 31 PUSH1 => 05 33 DUP2 34 CALLDATALOAD 35 PUSH2 => eeee 38 CALL */ InMemoryState state; auto rule_set{protocol::rule_set_factory(kMainnetConfig)}; ExecutionProcessor processor{block, *rule_set, state, kMainnetConfig, true}; processor.evm().state().add_to_balance(originator, kEther); processor.evm().state().set_code(caller_address, caller_code); processor.evm().state().set_code(suicidal_address, suicidal_code); Transaction txn{}; txn.max_priority_fee_per_gas = 20 * kGiga; txn.max_fee_per_gas = 20 * kGiga; txn.gas_limit = 100'000; txn.to = caller_address; txn.odd_y_parity = false; txn.r = 1; txn.s = 1; txn.set_sender(originator); evmc::bytes32 address_as_hash{to_bytes32(suicidal_address.bytes)}; txn.data = ByteView{address_as_hash}; Receipt receipt1; processor.execute_transaction(txn, receipt1); CHECK(receipt1.success); CHECK(!processor.evm().state().exists(suicidal_address)); // Now the contract is self-destructed, this is a simple value transfer txn.nonce = 1; txn.to = suicidal_address; txn.data.clear(); Receipt receipt2; processor.execute_transaction(txn, receipt2); CHECK(receipt2.success); CHECK(processor.evm().state().exists(suicidal_address)); CHECK(processor.evm().state().get_balance(suicidal_address) == 0); CHECK(receipt2.cumulative_gas_used == receipt1.cumulative_gas_used + protocol::fee::kGTransaction); } TEST_CASE("Out of Gas during account re-creation") { uint64_t block_num{2'081'788}; Block block{}; block.header.number = block_num; block.header.gas_limit = 4'712'388; block.header.beneficiary = 0xa42af2c70d316684e57aefcc6e393fecb1c7e84e_address; evmc::address caller{0xc789e5aba05051b1468ac980e30068e19fad8587_address}; uint64_t nonce{0}; evmc::address address{create_address(caller, nonce)}; InMemoryState state; // Some funds were previously transferred to the address: // https://etherscan.io/address/0x78c65b078353a8c4ce58fb4b5acaac6042d591d5 Account account{}; account.balance = 66'252'368 * kGiga; state.update_account(address, /*initial=*/std::nullopt, account); Transaction txn{}; txn.nonce = nonce; txn.max_priority_fee_per_gas = 20 * kGiga; txn.max_fee_per_gas = 20 * kGiga; txn.gas_limit = 690'000; txn.data = *from_hex( "0x6060604052604051610ca3380380610ca3833981016040528080518201919060200150505b600281511015" "61003357610002565b8060006000509080519060200190828054828255906000526020600020908101928215" "6100a4579160200282015b828111156100a35782518260006101000a81548173ffffffffffffffffffffffff" "ffffffffffffffff0219169083021790555091602001919060010190610061565b5b5090506100eb91906100" "b1565b808211156100e757600081816101000a81549073ffffffffffffffffffffffffffffffffffffffff02" "19169055506001016100b1565b5090565b50506000600160006101000a81548160ff02191690830217905550" "5b50610b8d806101166000396000f360606040523615610095576000357c0100000000000000000000000000" "000000000000000000000000000000900480632079fb9a14610120578063391252151461016257806345550a" "51146102235780637df73e27146102ac578063979f1976146102da578063a0b7967b14610306578063a68a76" "cc14610329578063abe3219c14610362578063fc0f392d1461038757610095565b61011e5b60003411156101" "1b577f6e89d517057028190560dd200cf6bf792842861353d1173761dfa362e1c133f0333460003660405180" "8573ffffffffffffffffffffffffffffffffffffffff16815260200184815260200180602001828103825284" "848281815260200192508082843782019150509550505050505060405180910390a15b5b565b005b61013660" "04808035906020019091905050610396565b604051808273ffffffffffffffffffffffffffffffffffffffff" "16815260200191505060405180910390f35b6102216004808035906020019091908035906020019091908035" "906020019082018035906020019191908080601f016020809104026020016040519081016040528093929190" "8181526020018383808284378201915050505050509090919080359060200190919080359060200190919080" "35906020019082018035906020019191908080601f0160208091040260200160405190810160405280939291" "908181526020018383808284378201915050505050509090919050506103d8565b005b610280600480803590" "6020019091908035906020019082018035906020019191908080601f01602080910402602001604051908101" "604052809392919081815260200183838082843782019150505050505090909190505061064b565b60405180" "8273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6102c260" "048080359060200190919050506106fa565b60405180821515815260200191505060405180910390f35b6102" "f060048080359060200190919050506107a8565b6040518082815260200191505060405180910390f35b6103" "136004805050610891565b6040518082815260200191505060405180910390f35b6103366004805050610901" "565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390" "f35b61036f600480505061093b565b60405180821515815260200191505060405180910390f35b6103946004" "80505061094e565b005b600060005081815481101561000257906000526020600020900160005b9150909054" "906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600060006103e5336106fa56" "5b15156103f057610002565b600160009054906101000a900460ff1680156104125750610410886106fa565b" "155b1561041c57610002565b4285101561042957610002565b610432846107a8565b50878787878760405180" "8673ffffffffffffffffffffffffffffffffffffffff166c0100000000000000000000000002815260140185" "81526020018480519060200190808383829060006004602084601f0104600f02600301f15090500183815260" "200182815260200195505050505050604051809103902091506104b7828461064b565b90506104c2816106fa" "565b15156104cd57610002565b3373ffffffffffffffffffffffffffffffffffffffff168173ffffffffffff" "ffffffffffffffffffffffffffff16141561050657610002565b8773ffffffffffffffffffffffffffffffff" "ffffffff16600088604051809050600060405180830381858888f19350505050151561054357610002565b7f" "59bed9ab5d78073465dd642a9e3e76dfdb7d53bcae9d09df7d0b8f5234d5a8063382848b8b8b604051808773" "ffffffffffffffffffffffffffffffffffffffff1681526020018673ffffffffffffffffffffffffffffffff" "ffffffff168152602001856000191681526020018473ffffffffffffffffffffffffffffffffffffffff1681" "5260200183815260200180602001828103825283818151815260200191508051906020019080838382906000" "6004602084601f0104600f02600301f150905090810190601f16801561062e57808203805160018360200361" "01000a031916815260200191505b5097505050505050505060405180910390a15b5050505050505050565b60" "006000600060006041855114151561066357610002565b602085015192506040850151915060ff6041860151" "169050601b8160ff16101561069057601b8101905080505b6001868285856040518085600019168152602001" "8460ff1681526020018360001916815260200182600019168152602001945050505050602060405180830381" "6000866161da5a03f1156100025750506040518051906020015093506106f1565b50505092915050565b6000" "6000600090505b600060005080549050811015610799578273ffffffffffffffffffffffffffffffffffffff" "ff16600060005082815481101561000257906000526020600020900160005b9054906101000a900473ffffff" "ffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614156107" "8b57600191506107a2565b5b8080600101915050610703565b600091506107a2565b50919050565b60006000" "60006107b7336106fa565b15156107c257610002565b60009150600090505b600a8160ff16101561084b5783" "60026000508260ff16600a8110156100025790900160005b505414156107fd57610002565b60026000508260" "0a8110156100025790900160005b505460026000508260ff16600a8110156100025790900160005b50541015" "61083d578060ff16915081505b5b80806001019150506107cb565b600260005082600a811015610002579090" "0160005b505484101561086e57610002565b83600260005083600a8110156100025790900160005b50819055" "505b5050919050565b60006000600060009150600090505b600a8110156108f15781600260005082600a8110" "156100025790900160005b505411156108e357600260005081600a8110156100025790900160005b50549150" "81505b5b80806001019150506108a0565b6001820192506108fc565b505090565b600061090c336106fa565b" "151561091757610002565b6040516101c2806109cb833901809050604051809103906000f09050610938565b" "90565b600160009054906101000a900460ff1681565b610957336106fa565b151561096257610002565b6001" "600160006101000a81548160ff021916908302179055507f0909e8f76a4fd3e970f2eaef56c0ee6dfaf8b87c" "5b8d3f56ffce78e825a9115733604051808273ffffffffffffffffffffffffffffffffffffffff1681526020" "0191505060405180910390a15b5660606040525b33600060006101000a81548173ffffffffffffffffffffff" "ffffffffffffffffff021916908302179055505b6101838061003f6000396000f36060604052361561004857" "6000357c0100000000000000000000000000000000000000000000000000000000900480636b9f96ea146100" "a6578063ca325469146100b557610048565b6100a45b600060009054906101000a900473ffffffffffffffff" "ffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16600034604051809050" "600060405180830381858888f19350505050505b565b005b6100b360048050506100ee565b005b6100c26004" "80505061015d565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060" "405180910390f35b600060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673" "ffffffffffffffffffffffffffffffffffffffff1660003073ffffffffffffffffffffffffffffffffffffff" "ff1631604051809050600060405180830381858888f19350505050505b565b600060009054906101000a9004" "73ffffffffffffffffffffffffffffffffffffffff1681560000000000000000000000000000000000000000" "0000000000000000000000200000000000000000000000000000000000000000000000000000000000000002" "000000000000000000000000c789e5aba05051b1468ac980e30068e19fad8587000000000000000000000000" "99c426b2a0453e27decaecd93c3722fb0f378fc5"); txn.odd_y_parity = false; txn.r = 1; txn.s = 1; txn.set_sender(caller); auto rule_set{protocol::rule_set_factory(kMainnetConfig)}; ExecutionProcessor processor{block, *rule_set, state, kMainnetConfig, true}; processor.evm().state().add_to_balance(caller, kEther); Receipt receipt; processor.execute_transaction(txn, receipt); // out of gas CHECK(!receipt.success); processor.evm().state().write_to_db(block_num); // only the caller and the miner should change CHECK(state.read_account(address) == account); } TEST_CASE("Empty suicide beneficiary") { uint64_t block_num{2'687'389}; Block block{}; block.header.number = block_num; block.header.gas_limit = 4'712'388; block.header.beneficiary = 0x2a65aca4d5fc5b5c859090a6c34d164135398226_address; evmc::address caller{0x5ed8cee6b63b1c6afce3ad7c92f4fd7e1b8fad9f_address}; evmc::address suicide_beneficiary{0xee098e6c2a43d9e2c04f08f0c3a87b0ba59079d5_address}; Transaction txn{}; txn.max_priority_fee_per_gas = 30 * kGiga; txn.max_fee_per_gas = 30 * kGiga; txn.gas_limit = 360'000; txn.data = *from_hex( "0x6000607f5359610043806100135939610056566c010000000000000000000000007fee098e6c2" "a43d9e2c04f08f0c3a87b0ba59079d4d53532071d6cd0cb86facd5605ff6100008061003f600039" "61003f565b6000f35b816000f0905050596100718061006c59396100dd5661005f8061000e60003" "961006d566000603f5359610043806100135939610056566c010000000000000000000000007fee" "098e6c2a43d9e2c04f08f0c3a87b0ba59079d4d53532071d6cd0cb86facd5605ff6100008061003" "f60003961003f565b6000f35b816000f0905050fe5b6000f35b816000f090506040526000600060" "0060006000604051620249f0f15061000080610108600039610108565b6000f3"); txn.odd_y_parity = false; txn.r = 1; txn.s = 1; txn.set_sender(caller); InMemoryState state; auto rule_set{protocol::rule_set_factory(kMainnetConfig)}; ExecutionProcessor processor{block, *rule_set, state, kMainnetConfig, true}; processor.evm().state().add_to_balance(caller, kEther); Receipt receipt; processor.execute_transaction(txn, receipt); CHECK(receipt.success); processor.evm().state().write_to_db(block_num); // suicide_beneficiary should've been touched and deleted CHECK(!state.read_account(suicide_beneficiary)); } TEST_CASE("CHAINID instruction") { // Set chain_id to a value other than 1 ChainConfig config = kMainnetConfig; config.chain_id = 42; Block block{}; block.header.number = 20'000'000; // PUSH0 enabled block.header.gas_limit = 50'000; const auto caller = 0x5ed8cee6b63b1c6afce3ad7c92f4fd7e1b8fad9f_address; const auto code = *from_hex("465955"); // SSTORE(0, CHAINID) Transaction txn{}; txn.to = 0xc0de_address; txn.gas_limit = block.header.gas_limit; txn.set_sender(caller); SECTION("protected") { txn.chain_id = config.chain_id; // chain id matches in a valid transaction } SECTION("legacy") { txn.chain_id = std::nullopt; // valid legacy transaction may not have the chain id } InMemoryState state; ExecutionProcessor processor{block, *protocol::rule_set_factory(config), state, config, true}; processor.evm().state().add_to_balance(caller, kEther); processor.evm().state().set_code(*txn.to, code); Receipt receipt; processor.execute_transaction(txn, receipt); CHECK(receipt.success); const auto v = processor.evm().state().get_current_storage(*txn.to, 0x00_bytes32); CHECK(v == evmc::bytes32{config.chain_id}); } } // namespace silkworm ================================================ FILE: silkworm/core/protocol/blockchain.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "blockchain.hpp" #include #include #include "silkworm/core/state/in_memory_state.hpp" namespace silkworm::protocol { Blockchain::Blockchain(State& state, const ChainConfig& config, const Block& genesis_block) : state_{state}, config_{config}, rule_set_{rule_set_factory(config)} { prime_state_with_genesis(genesis_block); } ValidationResult Blockchain::insert_block(Block& block, bool check_state_root) { ValidationResult err{rule_set_->validate_block_header(block.header, state_, /*with_future_timestamp_check=*/false)}; if (err != ValidationResult::kOk) { return err; } err = rule_set_->pre_validate_block_body(block, state_); if (err != ValidationResult::kOk) { return err; } evmc::bytes32 hash{block.header.hash()}; if (auto it{bad_blocks_.find(hash)}; it != bad_blocks_.end()) { return it->second; } uint64_t ancestor{canonical_ancestor(block.header, hash)}; uint64_t current_canonical_block{state_.current_canonical_block()}; unwind_last_changes(ancestor, current_canonical_block); uint64_t block_num = block.header.number; std::vector chain{intermediate_chain(block_num - 1, block.header.parent_hash, ancestor)}; chain.push_back({block, hash}); size_t num_of_executed_chain_blocks{0}; for (const BlockWithHash& x : chain) { err = execute_block(x.block, check_state_root); if (err != ValidationResult::kOk) { break; } ++num_of_executed_chain_blocks; } if (err != ValidationResult::kOk) { bad_blocks_[hash] = err; unwind_last_changes(ancestor, ancestor + num_of_executed_chain_blocks); re_execute_canonical_chain(ancestor, current_canonical_block); return err; } state_.insert_block(block, hash); intx::uint256 current_total_difficulty{ *state_.total_difficulty(current_canonical_block, *state_.canonical_hash(current_canonical_block))}; // Non-strict comparison because of the Merge if (state_.total_difficulty(block_num, hash) >= current_total_difficulty) { // canonize the new chain for (uint64_t i{current_canonical_block}; i > ancestor; --i) { state_.decanonize_block(i); } for (const BlockWithHash& x : chain) { state_.canonize_block(x.block.header.number, x.hash); } } else { unwind_last_changes(ancestor, ancestor + num_of_executed_chain_blocks); re_execute_canonical_chain(ancestor, current_canonical_block); } return ValidationResult::kOk; } ValidationResult Blockchain::execute_block(const Block& block, bool check_state_root) { ExecutionProcessor processor{block, *rule_set_, state_, config_, true}; processor.evm().exo_evm = exo_evm; if (const ValidationResult res = processor.execute_block(receipts_); res != ValidationResult::kOk) { return res; } processor.flush_state(); if (check_state_root) { evmc::bytes32 state_root{state_.state_root_hash()}; if (state_root != block.header.state_root) { state_.unwind_state_changes(block.header.number); return ValidationResult::kWrongStateRoot; } } return ValidationResult::kOk; } void Blockchain::prime_state_with_genesis(const Block& genesis_block) { evmc::bytes32 hash{genesis_block.header.hash()}; state_.insert_block(genesis_block, hash); state_.canonize_block(genesis_block.header.number, hash); } void Blockchain::re_execute_canonical_chain(uint64_t ancestor, uint64_t tip) { SILKWORM_ASSERT(ancestor <= tip); for (uint64_t block_num = ancestor + 1; block_num <= tip; ++block_num) { std::optional hash{state_.canonical_hash(block_num)}; SILKWORM_ASSERT(hash != std::nullopt); BlockBody body; SILKWORM_ASSERT(state_.read_body(block_num, *hash, body)); std::optional header{state_.read_header(block_num, *hash)}; SILKWORM_ASSERT(header != std::nullopt); Block block; block.header = header.value(); block.transactions = std::move(body.transactions); block.ommers = std::move(body.ommers); [[maybe_unused]] ValidationResult err{execute_block(block, /*check_state_root=*/false)}; SILKWORM_ASSERT(err == ValidationResult::kOk); } } void Blockchain::unwind_last_changes(uint64_t ancestor, uint64_t tip) { SILKWORM_ASSERT(ancestor <= tip); for (uint64_t block_num{tip}; block_num > ancestor; --block_num) { state_.unwind_state_changes(block_num); } } std::vector Blockchain::intermediate_chain( uint64_t block_num, evmc::bytes32 hash, uint64_t canonical_ancestor) const { SILKWORM_ASSERT(block_num >= canonical_ancestor); std::vector chain(static_cast(block_num - canonical_ancestor)); for (; block_num > canonical_ancestor; --block_num) { BlockWithHash& x{chain[static_cast(block_num - canonical_ancestor - 1)]}; BlockBody body; SILKWORM_ASSERT(state_.read_body(block_num, hash, body)); std::optional header{state_.read_header(block_num, hash)}; SILKWORM_ASSERT(header != std::nullopt); x.block.header = *header; x.block.transactions = std::move(body.transactions); x.block.ommers = std::move(body.ommers); x.hash = hash; hash = header->parent_hash; } return chain; } uint64_t Blockchain::canonical_ancestor(const BlockHeader& header, const evmc::bytes32& hash) const { if (state_.canonical_hash(header.number) == hash) { return header.number; } std::optional parent{state_.read_header(header.number - 1, header.parent_hash)}; // Blockchain::insert_block fails for blocks whose parent is not in the state, // so all ancestors should be in the state. SILKWORM_ASSERT(parent != std::nullopt); return canonical_ancestor(*parent, header.parent_hash); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/blockchain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::protocol { /** * Reference implementation of Ethereum blockchain logic. * Used for running Ethereum EL tests; the real node will use staged sync instead * (https://github.com/erigontech/erigon/blob/main/eth/stagedsync/README.md) */ class Blockchain { public: //! Creates a new instance of Blockchain. /** * In the beginning the state must have the genesis allocation. * Later on the state may only be modified by the created instance of Blockchain. */ explicit Blockchain(State& state, const ChainConfig& config, const Block& genesis_block); // Not copyable nor movable Blockchain(const Blockchain&) = delete; Blockchain& operator=(const Blockchain&) = delete; ValidationResult insert_block(Block& block, bool check_state_root); evmc_vm* exo_evm{nullptr}; private: ValidationResult execute_block(const Block& block, bool check_state_root); void prime_state_with_genesis(const Block& genesis_block); void re_execute_canonical_chain(uint64_t ancestor, uint64_t tip); void unwind_last_changes(uint64_t ancestor, uint64_t tip); std::vector intermediate_chain( uint64_t block_num, evmc::bytes32 hash, uint64_t canonical_ancestor) const; uint64_t canonical_ancestor(const BlockHeader& header, const evmc::bytes32& hash) const; State& state_; const ChainConfig& config_; RuleSetPtr rule_set_; std::unordered_map bad_blocks_; std::vector receipts_; }; } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/bor/config.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "config.hpp" #include #include #include #include #include #include namespace silkworm::protocol::bor { uint64_t Config::sprint_size(BlockNum block_num) const noexcept { const uint64_t* size = config_value_lookup(sprint, block_num); SILKWORM_ASSERT(size); return *size; } nlohmann::json Config::to_json() const noexcept { nlohmann::json ret; for (const auto& [from, val] : period) { ret["period"][std::to_string(from)] = val; } for (const auto& [from, val] : sprint) { ret["sprint"][std::to_string(from)] = val; } ret["validatorContract"] = to_hex(validator_contract.bytes, /*with_prefix=*/true); for (const auto& [block, rewrites] : rewrite_code) { const std::string block_str{std::to_string(block)}; for (const auto& [address, code] : rewrites) { const std::string code_hex{to_hex(string_view_to_byte_view(code), /*with_prefix=*/true)}; ret["blockAlloc"][block_str][to_hex(address.bytes, true)]["code"] = code_hex; } } ret["jaipurBlock"] = jaipur_block; ret["agraBlock"] = agra_block; return ret; } std::optional Config::from_json(const nlohmann::json& json) noexcept { if (json.is_discarded() || !json.is_object()) { return std::nullopt; } Config config; std::vector> period; for (const auto& item : json["period"].items()) { const BlockNum from{std::stoull(item.key(), nullptr, 0)}; period.emplace_back(from, item.value().get()); } if (period.size() > SmallMap::max_size()) { return std::nullopt; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Warray-bounds" // silence misdiagnostics in gcc 14 config.period = {period.begin(), period.end()}; #pragma GCC diagnostic pop std::vector> sprint; for (const auto& item : json["sprint"].items()) { const BlockNum from{std::stoull(item.key(), nullptr, 0)}; sprint.emplace_back(from, item.value().get()); } if (sprint.size() > SmallMap::max_size()) { return std::nullopt; } config.sprint = {sprint.begin(), sprint.end()}; config.validator_contract = hex_to_address(json["validatorContract"].get(), /*return_zero_on_err=*/true); if (is_zero(config.validator_contract)) { return std::nullopt; } SILKWORM_THREAD_LOCAL std::set codes; if (json.contains("blockAlloc")) { std::vector>> out_vec; for (const auto& outer : json["blockAlloc"].items()) { const BlockNum block_num = std::stoull(outer.key(), nullptr, 0); std::vector> inner_vec; for (const auto& inner : outer.value().items()) { const evmc::address contract{hex_to_address(inner.key(), /*return_zero_on_err=*/true)}; if (is_zero(contract)) { return std::nullopt; } const std::optional code{from_hex(inner.value()["code"].get())}; if (!code) { return std::nullopt; } auto code_it{codes.find(*code)}; if (code_it == codes.end()) { code_it = codes.insert(*code).first; } inner_vec.emplace_back(contract, byte_view_to_string_view(*code_it)); } out_vec.emplace_back(block_num, SmallMap{inner_vec.begin(), inner_vec.end()}); } config.rewrite_code = {out_vec.begin(), out_vec.end()}; } config.jaipur_block = json["jaipurBlock"].get(); config.agra_block = json["agraBlock"].get(); return config; } } // namespace silkworm::protocol::bor ================================================ FILE: silkworm/core/protocol/bor/config.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::protocol::bor { struct Config { SmallMap period; SmallMap sprint; // from block -> sprint size evmc::address validator_contract; SmallMap> rewrite_code; BlockNum jaipur_block{0}; // https://forum.polygon.technology/t/pip-28-agra-hardfork BlockNum agra_block{0}; uint64_t sprint_size(BlockNum block_num) const noexcept; nlohmann::json to_json() const noexcept; static std::optional from_json(const nlohmann::json& json) noexcept; bool operator==(const Config&) const = default; }; // Looks up a config value as of a given block number. // The assumption here is that config is a càdlàg map of starting_from_block -> value. // For example, config of {{0, "a"}, {10, "b"}, {20, "c"}} // means that the config value is "a" for blocks 0–9, // "b" for blocks 10–19, and "c" for block 20 and above. // // N.B. Similar to borKeyValueConfigHelper in Erigon. template constexpr const T* config_value_lookup(const SmallMap& config, BlockNum block_num) noexcept { auto it{config.begin()}; if (config.empty() || it->first > block_num) { return nullptr; } for (; (it + 1) != config.end(); ++it) { if (it->first <= block_num && block_num < (it + 1)->first) { return &(it->second); } } return &(it->second); } } // namespace silkworm::protocol::bor ================================================ FILE: silkworm/core/protocol/bor/config_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "config.hpp" #include #include using namespace std::string_view_literals; namespace silkworm::protocol::bor { using namespace evmc::literals; TEST_CASE("BorConfig JSON") { const auto json = nlohmann::json::parse(R"({ "period": { "0": 2, "25275000": 5, "29638656": 2 }, "sprint": { "0": 64, "38189056": 16 }, "validatorContract": "0x0000000000000000000000000000000000001000", "blockAlloc": { "22244000": { "0x0000000000000000000000000000000000001010": { "code": "0x60806040526004361061019c" } }, "41874000": { "0x0000000000000000000000000000000000001001": { "code": "0x60806040523482" } } }, "jaipurBlock": 123, "agraBlock": 789 })"); const std::optional config{Config::from_json(json)}; REQUIRE(config); static constexpr Config kExpectedConfig{ .period = { {0, 2}, {25'275'000, 5}, {29'638'656, 2}, }, .sprint = { {0, 64}, {38189056, 16}, }, .validator_contract = 0x0000000000000000000000000000000000001000_address, .rewrite_code = { { 22244000, {{ 0x0000000000000000000000000000000000001010_address, "\x60\x80\x60\x40\x52\x60\x04\x36\x10\x61\x01\x9c"sv, }}, }, { 41874000, {{ 0x0000000000000000000000000000000000001001_address, "\x60\x80\x60\x40\x52\x34\x82"sv, }}, }, }, .jaipur_block = 123, .agra_block = 789, }; CHECK(config == kExpectedConfig); CHECK(config->to_json() == json); } TEST_CASE("bor_config_value_lookup") { static constexpr SmallMap kConfig{{20, "b"}, {10, "a"}, {30, "c"}}; static_assert(!config_value_lookup(kConfig, 0)); static_assert(!config_value_lookup(kConfig, 1)); static_assert(!config_value_lookup(kConfig, 9)); static_assert(*config_value_lookup(kConfig, 10) == "a"); static_assert(*config_value_lookup(kConfig, 11) == "a"); static_assert(*config_value_lookup(kConfig, 19) == "a"); static_assert(*config_value_lookup(kConfig, 20) == "b"); static_assert(*config_value_lookup(kConfig, 21) == "b"); static_assert(*config_value_lookup(kConfig, 29) == "b"); static_assert(*config_value_lookup(kConfig, 30) == "c"); static_assert(*config_value_lookup(kConfig, 31) == "c"); static_assert(*config_value_lookup(kConfig, 100) == "c"); } } // namespace silkworm::protocol::bor ================================================ FILE: silkworm/core/protocol/bor/span.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "span.hpp" #include namespace silkworm::protocol::bor { std::optional get_current_span(EVM& evm, const evmc_address& validator_contract) { static constexpr uint8_t kFunctionSelector[]{0xaf, 0x26, 0xaa, 0x96}; // getCurrentSpan() Transaction system_txn{}; system_txn.type = TransactionType::kSystem; system_txn.to = validator_contract; system_txn.data = ByteView{kFunctionSelector}; system_txn.set_sender(kSystemAddress); const CallResult res{evm.execute(system_txn, kSystemCallGasLimit)}; if (res.status != EVMC_SUCCESS || res.data.size() != 32 * 3) { return std::nullopt; } const auto id{intx::be::unsafe::load(&res.data[0])}; const auto start_block{intx::be::unsafe::load(&res.data[32])}; const auto end_block{intx::be::unsafe::load(&res.data[64])}; if (intx::count_significant_words(id) > 1 || intx::count_significant_words(start_block) > 1 || intx::count_significant_words(end_block) > 1) { return std::nullopt; } return Span{.id = static_cast(id), .start_block = static_cast(start_block), .end_block = static_cast(end_block)}; } } // namespace silkworm::protocol::bor ================================================ FILE: silkworm/core/protocol/bor/span.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::protocol::bor { struct Span { uint64_t id{0}; BlockNum start_block{0}; BlockNum end_block{0}; }; // See GetCurrentSpan in polygon/bor/spanner.go std::optional get_current_span(EVM& evm, const evmc_address& validator_contract); } // namespace silkworm::protocol::bor ================================================ FILE: silkworm/core/protocol/bor/span_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "span.hpp" #include #include #include namespace silkworm::protocol::bor { // See https://docs.soliditylang.org/en/latest/abi-spec.html TEST_CASE("GetCurrentSpan ABI") { static constexpr std::string_view kFunctionSignature{"getCurrentSpan()"}; const ethash::hash256 hash{keccak256(string_view_to_byte_view(kFunctionSignature))}; const ByteView selector{ByteView{hash.bytes}.substr(0, 4)}; CHECK(to_hex(selector) == "af26aa96"); } } // namespace silkworm::protocol::bor ================================================ FILE: silkworm/core/protocol/bor_rule_set.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bor_rule_set.hpp" #include #include #include #include #include "param.hpp" namespace silkworm::protocol { static bool is_sprint_start(BlockNum block_num, uint64_t sprint_size) { // N.B. Works fine for the specific Polygon sprint size config, but is flawed in general // (e.g. it wouldn't work for {0->5, 10->3}) return block_num % sprint_size == 0; } ValidationResult BorRuleSet::validate_block_header(const BlockHeader& header, const BlockState& state, bool with_future_timestamp_check) { if (!is_zero(header.prev_randao)) { return ValidationResult::kInvalidMixDigest; } ValidationResult res{RuleSet::validate_block_header(header, state, with_future_timestamp_check)}; if (res != ValidationResult::kOk) { return res; } const std::optional parent{get_parent_header(state, header)}; const uint64_t* period{bor::config_value_lookup(config().period, header.number)}; SILKWORM_ASSERT(period); if (parent->timestamp + *period > header.timestamp) { return ValidationResult::kInvalidTimestamp; } // TODO(yperbasis): verify validators // https://github.com/maticnetwork/bor/blob/v1.1.0-beta4/consensus/bor/bor.go#L465 return ValidationResult::kOk; } // validate_extra_data validates that the extra-data contains both the vanity and signature. // header.Extra = header.Vanity + header.ProducerBytes (optional) + header.Seal ValidationResult BorRuleSet::validate_extra_data(const BlockHeader& header) const { static constexpr size_t kExtraVanityLength{32}; static constexpr size_t kValidatorHeaderLength{kAddressLength + 20}; // address + power // See https://github.com/maticnetwork/bor/blob/v1.0.6/consensus/bor/bor.go#L393 if (header.extra_data.size() < kExtraVanityLength) { return ValidationResult::kMissingVanity; } if (header.extra_data.size() < kExtraVanityLength + kExtraSealSize) { return ValidationResult::kMissingSignature; } // The end of a sprint at block n == the start of next sprint at block n+1 // See https://github.com/maticnetwork/bor/blob/v1.0.6/consensus/bor/bor.go#L351 const bool is_sprint_end{is_sprint_start(header.number + 1, config().sprint_size(header.number))}; // Ensure that the extra-data contains a signer list on checkpoint, but none otherwise const size_t signers_length{header.extra_data.size() - (kExtraVanityLength + kExtraSealSize)}; if (!is_sprint_end && signers_length != 0) { return ValidationResult::kExtraValidators; } if (is_sprint_end && signers_length % kValidatorHeaderLength != 0) { return ValidationResult::kInvalidSpanValidators; } return ValidationResult::kOk; } static std::optional ecrecover(const BlockHeader& header, const BlockNum jaipur_block) { evmc::bytes32 seal_hash{header.hash(/*for_sealing=*/false, /*exclude_extra_data_sig=*/true)}; if (header.base_fee_per_gas && header.number < jaipur_block) { // See https://github.com/maticnetwork/bor/pull/269 BlockHeader copy{header}; copy.base_fee_per_gas = std::nullopt; seal_hash = copy.hash(/*for_sealing=*/false, /*exclude_extra_data_sig=*/true); } ByteView signature{&header.extra_data[header.extra_data.size() - kExtraSealSize], kExtraSealSize - 1}; uint8_t recovery_id{header.extra_data[header.extra_data.size() - 1]}; static secp256k1_context* context{secp256k1_context_create(SILKWORM_SECP256K1_CONTEXT_FLAGS)}; evmc::address beneficiary; if (!silkworm_recover_address(beneficiary.bytes, seal_hash.bytes, signature.data(), recovery_id, context)) { return std::nullopt; } return beneficiary; } static void rewrite_code_if_needed(const SmallMap>& rewrite_code, IntraBlockState& state, BlockNum block_num) { const SmallMap* rewrites{rewrite_code.find(block_num)}; if (!rewrites) { return; } for (const auto& [address, code] : *rewrites) { state.set_code(address, string_view_to_byte_view(code)); } } ValidationResult BorRuleSet::finalize(IntraBlockState& state, const Block& block, EVM&, const std::vector&) { const BlockNum header_number{block.header.number}; if (is_sprint_start(header_number, config().sprint_size(header_number))) { // TODO(yperbasis): implement // https://github.com/maticnetwork/bor/blob/v1.2.0/consensus/bor/bor.go#L827 } rewrite_code_if_needed(config().rewrite_code, state, header_number); return ValidationResult::kOk; } ValidationResult BorRuleSet::validate_difficulty_and_seal(const BlockHeader& header, const BlockHeader&) { if (!ecrecover(header, config().jaipur_block)) { return ValidationResult::kInvalidSignature; } // TODO(yperbasis): implement // https://github.com/maticnetwork/bor/blob/v1.1.0-beta4/consensus/bor/bor.go#L654 return ValidationResult::kOk; } evmc::address BorRuleSet::get_beneficiary(const BlockHeader& header) { return *ecrecover(header, config().jaipur_block); } namespace { // See https://github.com/maticnetwork/bor/blob/v1.3.7/core/bor_fee_log.go void add_transfer_log(IntraBlockState& state, const evmc::bytes32& event_sig, const evmc::address& sender, const evmc::address& recipient, const intx::uint256& amount, const intx::uint256& input1, const intx::uint256& input2, const intx::uint256& output1, const intx::uint256& output2) { if (amount == 0) { return; } static constexpr evmc::address kFeeAddress{0x0000000000000000000000000000000000001010_address}; SILKWORM_THREAD_LOCAL Log log{ .address = kFeeAddress, .topics = { {}, to_bytes32(kFeeAddress.bytes), {}, {}, }, .data = Bytes(32 * 5, 0), }; log.topics[0] = event_sig; log.topics[2] = to_bytes32(sender.bytes); log.topics[3] = to_bytes32(recipient.bytes); intx::be::unsafe::store(&log.data[32 * 0], amount); intx::be::unsafe::store(&log.data[32 * 1], input1); intx::be::unsafe::store(&log.data[32 * 2], input2); intx::be::unsafe::store(&log.data[32 * 3], output1); intx::be::unsafe::store(&log.data[32 * 4], output2); state.add_log(log); } void bor_transfer(IntraBlockState& state, const evmc::address& sender, const evmc::address& recipient, const intx::uint256& amount, bool bailout) { static constexpr evmc::bytes32 kTransferLogSig{ 0xe6497e3ee548a3372136af2fcb0696db31fc6cf20260707645068bd3fe97f3c4_bytes32}; intx::uint256 sender_initial_balance{state.get_balance(sender)}; intx::uint256 recipient_initial_balance{state.get_balance(recipient)}; // TODO(yperbasis) why is the bailout condition different from that of Erigon? if (!bailout || sender_initial_balance >= amount) { state.subtract_from_balance(sender, amount); } state.add_to_balance(recipient, amount); intx::uint256 output1{state.get_balance(sender)}; intx::uint256 output2{state.get_balance(recipient)}; add_transfer_log(state, kTransferLogSig, sender, recipient, amount, sender_initial_balance, recipient_initial_balance, output1, output2); } } // namespace void BorRuleSet::add_fee_transfer_log(IntraBlockState& state, const intx::uint256& amount, const evmc::address& sender, const intx::uint256& sender_initial_balance, const evmc::address& recipient, const intx::uint256& recipient_initial_balance) { static constexpr evmc::bytes32 kTransferFeeLogSig{ 0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63_bytes32}; SILKWORM_ASSERT(amount <= sender_initial_balance); add_transfer_log(state, kTransferFeeLogSig, sender, recipient, amount, sender_initial_balance, recipient_initial_balance, sender_initial_balance - amount, recipient_initial_balance + amount); } TransferFunc* BorRuleSet::transfer_func() const { return bor_transfer; } const bor::Config& BorRuleSet::config() const { return std::get(chain_config_->rule_set_config); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/bor_rule_set.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::protocol { // See https://github.com/maticnetwork/bor/blob/master/consensus/bor/bor.go class BorRuleSet : public RuleSet { public: explicit BorRuleSet(const ChainConfig& chain_config) : RuleSet(chain_config, /*prohibit_ommers=*/true) {} ValidationResult validate_block_header(const BlockHeader& header, const BlockState& state, bool with_future_timestamp_check) override; void initialize(EVM&) override {} ValidationResult finalize(IntraBlockState&, const Block&, EVM&, const std::vector& logs) override; evmc::address get_beneficiary(const BlockHeader& header) override; void add_fee_transfer_log(IntraBlockState& state, const intx::uint256& amount, const evmc::address& sender, const intx::uint256& sender_initial_balance, const evmc::address& recipient, const intx::uint256& recipient_initial_balance) override; TransferFunc* transfer_func() const override; protected: ValidationResult validate_extra_data(const BlockHeader& header) const override; ValidationResult validate_difficulty_and_seal(const BlockHeader& header, const BlockHeader& parent) override; private: const bor::Config& config() const; }; } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/ethash_config.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ethash_config.hpp" namespace silkworm::protocol { nlohmann::json EthashConfig::to_json() const noexcept { nlohmann::json ret(nlohmann::json::value_t::object); if (!validate_seal) { ret.emplace("validateSeal", validate_seal); } return ret; } std::optional EthashConfig::from_json(const nlohmann::json& json) noexcept { if (json.is_discarded() || !json.is_object()) { return std::nullopt; } EthashConfig config; if (json.contains("validateSeal")) { config.validate_seal = json["validateSeal"].get(); } return config; } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/ethash_config.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::protocol { //! \see EthashRuleSet struct EthashConfig { bool validate_seal{true}; nlohmann::json to_json() const noexcept; static std::optional from_json(const nlohmann::json& json) noexcept; bool operator==(const EthashConfig&) const = default; }; } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/ethash_rule_set.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ethash_rule_set.hpp" #include #include #include #include "param.hpp" namespace silkworm::protocol { // Ethash ProofOfWork verification ValidationResult EthashRuleSet::validate_difficulty_and_seal(const BlockHeader& header, const BlockHeader& parent) { const bool parent_has_uncles{parent.ommers_hash != kEmptyListHash}; if (header.difficulty != difficulty(header.number, header.timestamp, parent.difficulty, parent.timestamp, parent_has_uncles, *chain_config_)) { return ValidationResult::kWrongDifficulty; } if (!std::get(chain_config_->rule_set_config).validate_seal) { return ValidationResult::kOk; } const int epoch_number{static_cast(header.number / ethash::epoch_length)}; if (!epoch_context_ || epoch_context_->epoch_number != epoch_number) { epoch_context_.reset(); // Firstly release the obsoleted context epoch_context_ = ethash::create_epoch_context(epoch_number); } const auto nonce{endian::load_big_u64(header.nonce.data())}; const auto seal_hash(header.hash(/*for_sealing =*/true)); const auto diff256{intx::be::store(header.difficulty)}; const auto sealh256{ethash::hash256_from_bytes(seal_hash.bytes)}; const auto mixh256{ethash::hash256_from_bytes(header.prev_randao.bytes)}; const auto ec{ethash::verify_against_difficulty(*epoch_context_, sealh256, mixh256, nonce, diff256)}; return ec ? ValidationResult::kInvalidSeal : ValidationResult::kOk; } ValidationResult EthashRuleSet::validate_extra_data(const BlockHeader& header) const { // EIP-779: Hardfork Meta: DAO Fork if (chain_config_->dao_block && chain_config_->dao_block <= header.number && header.number <= *(chain_config_->dao_block) + 9) { static const Bytes kDaoExtraData{*from_hex("0x64616f2d686172642d666f726b")}; if (header.extra_data != kDaoExtraData) { return ValidationResult::kWrongDaoExtraData; } } return RuleSet::validate_extra_data(header); } void EthashRuleSet::initialize(EVM& evm) { if (evm.block().header.number == evm.config().dao_block) { transfer_dao_balances(evm.state()); } } ValidationResult EthashRuleSet::finalize(IntraBlockState& state, const Block& block, EVM&, const std::vector&) { const BlockReward reward{compute_reward(block)}; state.add_to_balance(get_beneficiary(block.header), reward.miner); for (size_t i{0}; i < block.ommers.size(); ++i) { state.add_to_balance(block.ommers[i].beneficiary, reward.ommers[i]); } return ValidationResult::kOk; } static intx::uint256 block_reward_base(const evmc_revision rev) { if (rev >= EVMC_CONSTANTINOPLE) { return kBlockRewardConstantinople; } if (rev >= EVMC_BYZANTIUM) { return kBlockRewardByzantium; } return kBlockRewardFrontier; } BlockReward EthashRuleSet::compute_reward(const Block& block) { const BlockNum block_num = block.header.number; const evmc_revision rev{chain_config_->revision(block_num, block.header.timestamp)}; const intx::uint256 base{block_reward_base(rev)}; intx::uint256 miner_reward{base}; std::vector ommer_rewards; ommer_rewards.reserve(block.ommers.size()); // Accumulate the rewards for the miner and any included uncles for (const BlockHeader& ommer : block.ommers) { const intx::uint256 ommer_reward{((8 + ommer.number - block_num) * base) >> 3}; ommer_rewards.push_back(ommer_reward); miner_reward += base >> 5; // div 32 } return {miner_reward, ommer_rewards}; } intx::uint256 EthashRuleSet::difficulty( uint64_t block_num, const uint64_t block_timestamp, const intx::uint256& parent_difficulty, const uint64_t parent_timestamp, const bool parent_has_uncles, const ChainConfig& config) { const evmc_revision rev = config.revision(block_num, block_timestamp); intx::uint256 difficulty{parent_difficulty}; const intx::uint256 x{parent_difficulty >> 11}; // parent_difficulty / 2048; if (rev >= EVMC_BYZANTIUM) { difficulty -= x * 99; // https://eips.ethereum.org/EIPS/eip-100 const uint64_t y{parent_has_uncles ? 2u : 1u}; const uint64_t z{(block_timestamp - parent_timestamp) / 9}; if (99 + y > z) { difficulty += (99 + y - z) * x; } } else if (rev >= EVMC_HOMESTEAD) { difficulty -= x * 99; const uint64_t z{(block_timestamp - parent_timestamp) / 10}; if (100 > z) { difficulty += (100 - z) * x; } } else { if (block_timestamp - parent_timestamp < 13) { difficulty += x; } else { difficulty -= x; } } uint64_t bomb_delay{0}; if (config.gray_glacier_block.has_value() && block_num >= config.gray_glacier_block) { // EIP-5133: Delaying Difficulty Bomb to mid-September 2022 bomb_delay = 11'400'000; } else if (config.arrow_glacier_block.has_value() && block_num >= config.arrow_glacier_block) { // EIP-4345: Difficulty Bomb Delay to June 2022 bomb_delay = 10'700'000; } else if (rev >= EVMC_LONDON) { // EIP-3554: Difficulty Bomb Delay to December 2021 bomb_delay = 9'700'000; } else if (config.muir_glacier_block.has_value() && block_num >= config.muir_glacier_block) { // EIP-2384: Muir Glacier Difficulty Bomb Delay bomb_delay = 9'000'000; } else if (rev >= EVMC_CONSTANTINOPLE) { // EIP-1234: Constantinople Difficulty Bomb Delay and Block Reward Adjustment bomb_delay = 5'000'000; } else if (rev >= EVMC_BYZANTIUM) { // EIP-649: Metropolis Difficulty Bomb Delay and Block Reward Reduction bomb_delay = 3'000'000; } if (block_num > bomb_delay) { block_num -= bomb_delay; } else { block_num = 0; } const uint64_t n = block_num / 100'000; if (n >= 2) { static constexpr intx::uint256 kOne{1}; difficulty += kOne << (n - 2); } static constexpr uint64_t kMinDifficulty{0x20000}; if (difficulty < kMinDifficulty) { difficulty = kMinDifficulty; } return difficulty; } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/ethash_rule_set.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::protocol { // Proof of Work implementation class EthashRuleSet : public RuleSet { public: explicit EthashRuleSet(const ChainConfig& chain_config) : RuleSet(chain_config, /*prohibit_ommers=*/false) {} void initialize(EVM& evm) override; //! \brief See [YP] Section 11.3 "Reward Application". //! \param [in] state: current state. //! \param [in] block: current block to apply rewards for. ValidationResult finalize(IntraBlockState& state, const Block& block, EVM& evm, const std::vector& logs) override; BlockReward compute_reward(const Block& block) override; // Canonical difficulty of a Proof-of-Work block header. // See Section 4.3.4 "Block Header Validity" of the Yellow Paper and also // EIP-2, EIP-100, EIP-649, EIP-1234, EIP-2384, EIP-3554, EIP-4345. static intx::uint256 difficulty( uint64_t block_num, uint64_t block_timestamp, const intx::uint256& parent_difficulty, uint64_t parent_timestamp, bool parent_has_uncles, const ChainConfig& config); protected: ValidationResult validate_extra_data(const BlockHeader& header) const override; ValidationResult validate_difficulty_and_seal(const BlockHeader& header, const BlockHeader& parent) override; private: ethash::epoch_context_ptr epoch_context_{nullptr, ethash_destroy_epoch_context}; }; } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/ethash_rule_set_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ethash_rule_set.hpp" #include namespace silkworm::protocol { TEST_CASE("DifficultyTest34") { uint64_t block_num{0x33e140}; uint64_t block_timestamp{0x04bdbdaf}; uint64_t parent_difficulty{0x7268db7b46b0b154}; uint64_t parent_timestamp{0x04bdbdaf}; bool parent_has_uncles{false}; intx::uint256 difficulty{EthashRuleSet::difficulty(block_num, block_timestamp, parent_difficulty, parent_timestamp, parent_has_uncles, kMainnetConfig)}; CHECK(difficulty == 0x72772897b619876a); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/intrinsic_gas.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "intrinsic_gas.hpp" #include #include "param.hpp" namespace silkworm::protocol { intx::uint128 intrinsic_gas(const UnsignedTransaction& txn, const evmc_revision rev) noexcept { intx::uint128 gas{fee::kGTransaction}; const bool contract_creation{!txn.to}; if (contract_creation && rev >= EVMC_HOMESTEAD) { gas += fee::kGTxCreate; } // EIP-2930: Optional access lists gas += intx::uint128{txn.access_list.size()} * fee::kAccessListAddressCost; intx::uint128 total_num_of_storage_keys{0}; for (const AccessListEntry& e : txn.access_list) { total_num_of_storage_keys += e.storage_keys.size(); } gas += total_num_of_storage_keys * fee::kAccessListStorageKeyCost; // EIP-7702 Set EOA account code gas += txn.authorizations.size() * fee::kPerEmptyAccountCost; const uint64_t data_len{txn.data.size()}; if (data_len == 0) { return gas; } const intx::uint128 non_zero_bytes{std::ranges::count_if(txn.data, [](uint8_t c) { return c != 0; })}; const intx::uint128 non_zero_gas{rev >= EVMC_ISTANBUL ? fee::kGTxDataNonZeroIstanbul : fee::kGTxDataNonZeroFrontier}; gas += non_zero_bytes * non_zero_gas; const intx::uint128 zero_bytes{data_len - non_zero_bytes}; gas += zero_bytes * fee::kGTxDataZero; // EIP-3860: Limit and meter initcode if (contract_creation && rev >= EVMC_SHANGHAI) { gas += num_words(data_len) * fee::kInitCodeWordCost; } return gas; } // EIP-7623: Increase calldata cost uint64_t floor_cost(const UnsignedTransaction& txn) noexcept { const uint64_t zero_bytes = static_cast(std::ranges::count(txn.data, 0)); const uint64_t non_zero_bytes{txn.data.size() - zero_bytes}; return fee::kGTransaction + (zero_bytes + non_zero_bytes * 4) * fee::kTotalCostFloorPerToken; } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/intrinsic_gas.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { // Words in EVM are 32-bytes long constexpr uint64_t num_words(uint64_t num_bytes) noexcept { return num_bytes / 32 + static_cast(num_bytes % 32 != 0); } namespace protocol { // Returns the intrinsic gas of a transaction. // Refer to g0 in Section 6.2 "Execution" of the Yellow Paper // and EIP-3860 "Limit and meter initcode". intx::uint128 intrinsic_gas(const UnsignedTransaction& txn, evmc_revision rev) noexcept; // Returns the floor cost (valid since Pectra) // Refer to: EIP-7623: Increase calldata cost uint64_t floor_cost(const UnsignedTransaction& txn) noexcept; } // namespace protocol } // namespace silkworm ================================================ FILE: silkworm/core/protocol/intrinsic_gas_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "intrinsic_gas.hpp" #include #include #include "param.hpp" namespace silkworm { TEST_CASE("num_words") { CHECK(num_words(0) == 0); CHECK(num_words(1) == 1); CHECK(num_words(31) == 1); CHECK(num_words(32) == 1); CHECK(num_words(33) == 2); CHECK(num_words(0xFFFFFFFFFFFFFFDF) == 0x7FFFFFFFFFFFFFF); CHECK(num_words(0xFFFFFFFFFFFFFFE0) == 0x7FFFFFFFFFFFFFF); CHECK(num_words(0xFFFFFFFFFFFFFFE1) == 0x800000000000000); CHECK(num_words(0xFFFFFFFFFFFFFFFE) == 0x800000000000000); CHECK(num_words(0xFFFFFFFFFFFFFFFF) == 0x800000000000000); } namespace protocol { TEST_CASE("EIP-2930 intrinsic gas") { std::vector access_list{ {0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae_address, { 0x0000000000000000000000000000000000000000000000000000000000000003_bytes32, 0x0000000000000000000000000000000000000000000000000000000000000007_bytes32, }}, {0xbb9bc244d798123fde783fcc1c72d3bb8c189413_address, {}}, }; UnsignedTransaction txn{ .type = TransactionType::kAccessList, .chain_id = kSepoliaConfig.chain_id, .nonce = 7, .max_priority_fee_per_gas = 30000000000, .max_fee_per_gas = 30000000000, .gas_limit = 5748100, .to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address, .value = 2 * kEther, .access_list = access_list}; intx::uint128 g0{intrinsic_gas(txn, EVMC_ISTANBUL)}; CHECK(g0 == fee::kGTransaction + 2 * fee::kAccessListAddressCost + 2 * fee::kAccessListStorageKeyCost); } TEST_CASE("EIP-7623 intrinsic gas") { // EIP-7623 rules should take precedence const Bytes calldata = Bytes(22 * 1024, 1); UnsignedTransaction txn{ .type = TransactionType::kDynamicFee, .chain_id = kSepoliaConfig.chain_id, .nonce = 7, .max_priority_fee_per_gas = 30000000000, .max_fee_per_gas = 30000000000, .gas_limit = 25748100, .value = 2 * kEther, .data = calldata}; intx::uint128 g0{intrinsic_gas(txn, EVMC_PRAGUE)}; intx::uint128 eip7623_floor_cost = floor_cost(txn); // Calldata contains only 'ones' and the cost per EIP-7623 is higher CHECK(eip7623_floor_cost > g0); } } // namespace protocol } // namespace silkworm ================================================ FILE: silkworm/core/protocol/merge_rule_set.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "merge_rule_set.hpp" #include #include #include #include "param.hpp" #include "silkworm/core/types/eip_7685_requests.hpp" namespace silkworm::protocol { MergeRuleSet::MergeRuleSet(RuleSetPtr pre_merge_rule_set, const ChainConfig& chain_config) : RuleSet{chain_config, /*prohibit_ommers=*/true}, terminal_total_difficulty_{*chain_config.terminal_total_difficulty}, pre_merge_rule_set_{std::move(pre_merge_rule_set)} {} ValidationResult MergeRuleSet::pre_validate_block_body(const Block& block, const BlockState& state) { if (block.header.difficulty != 0) { if (!pre_merge_rule_set_) { return ValidationResult::kUnknownProtocolRuleSet; } return pre_merge_rule_set_->pre_validate_block_body(block, state); } return RuleSet::pre_validate_block_body(block, state); } ValidationResult MergeRuleSet::validate_block_header(const BlockHeader& header, const BlockState& state, bool with_future_timestamp_check) { // TODO(yperbasis) how will all this work with backwards sync? const std::optional parent{RuleSet::get_parent_header(state, header)}; if (!parent) { return ValidationResult::kUnknownParent; } const std::optional parent_total_difficulty{ state.total_difficulty(parent->number, header.parent_hash)}; if (!parent_total_difficulty) { return ValidationResult::kUnknownParentTotalDifficulty; } const bool ttd_reached{parent_total_difficulty >= terminal_total_difficulty_}; if (header.difficulty != 0) { if (ttd_reached) { return ValidationResult::kPoWBlockAfterMerge; } if (!pre_merge_rule_set_) { return ValidationResult::kUnknownProtocolRuleSet; } return pre_merge_rule_set_->validate_block_header(header, state, with_future_timestamp_check); } // PoS block if (!ttd_reached) { return ValidationResult::kPoSBlockBeforeMerge; } return RuleSet::validate_block_header(header, state, with_future_timestamp_check); } ValidationResult MergeRuleSet::validate_difficulty_and_seal(const BlockHeader& header, const BlockHeader&) { SILKWORM_ASSERT(header.difficulty == 0); return header.nonce == BlockHeader::NonceType{} ? ValidationResult::kOk : ValidationResult::kInvalidNonce; } void MergeRuleSet::initialize(EVM& evm) { const BlockHeader& header{evm.block().header}; if (header.difficulty != 0) { if (pre_merge_rule_set_) { pre_merge_rule_set_->initialize(evm); } return; } if (evm.revision() >= EVMC_CANCUN) { // EIP-4788: Beacon block root in the EVM SILKWORM_ASSERT(header.parent_beacon_block_root); Transaction system_txn{}; system_txn.type = TransactionType::kSystem; system_txn.to = kBeaconRootsAddress; system_txn.data = Bytes{ByteView{*header.parent_beacon_block_root}}; system_txn.set_sender(kSystemAddress); evm.execute(system_txn, kSystemCallGasLimit); evm.state().destruct_touched_dead(); } if (evm.revision() >= EVMC_PRAGUE) { // EIP-2935: Serve historical block hashes from state Transaction system_txn{}; system_txn.type = TransactionType::kSystem; system_txn.to = kHistoryStorageAddress; system_txn.data = Bytes{ByteView{header.parent_hash}}; system_txn.set_sender(kSystemAddress); evm.execute(system_txn, kSystemCallGasLimit); evm.state().destruct_touched_dead(); } } ValidationResult MergeRuleSet::finalize(IntraBlockState& state, const Block& block, EVM& evm, const std::vector& logs) { if (block.header.difficulty != 0) { if (pre_merge_rule_set_) { return pre_merge_rule_set_->finalize(state, block, evm, logs); } } if (block.withdrawals) { // See EIP-4895: Beacon chain push withdrawals as operations for (const Withdrawal& w : *block.withdrawals) { const auto amount_in_wei{intx::uint256{w.amount} * intx::uint256{kGiga}}; state.add_to_balance(w.address, amount_in_wei); state.destruct_touched_dead(); } } if (evm.revision() >= EVMC_PRAGUE && block.header.requests_hash) { return validate_requests_root(block.header, logs, evm); } return ValidationResult::kOk; } evmc::address MergeRuleSet::get_beneficiary(const BlockHeader& header) { if (header.difficulty != 0 && pre_merge_rule_set_) { return pre_merge_rule_set_->get_beneficiary(header); } return RuleSet::get_beneficiary(header); } ValidationResult MergeRuleSet::validate_ommers(const Block& block, const BlockState& state) { if (block.header.difficulty != 0) { if (!pre_merge_rule_set_) { return ValidationResult::kUnknownProtocolRuleSet; } return pre_merge_rule_set_->validate_ommers(block, state); } return RuleSet::validate_ommers(block, state); } BlockReward MergeRuleSet::compute_reward(const Block& block) { if (block.header.difficulty != 0 && pre_merge_rule_set_) { return pre_merge_rule_set_->compute_reward(block); } return RuleSet::compute_reward(block); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/merge_rule_set.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::protocol { // Mainnet protocol rule set that can handle blocks before, during, and after the Merge. // See EIP-3675: Upgrade consensus to Proof-of-Stake. class MergeRuleSet : public RuleSet { public: explicit MergeRuleSet(RuleSetPtr pre_merge_rule_set, const ChainConfig& chain_config); ValidationResult pre_validate_block_body(const Block& block, const BlockState& state) override; ValidationResult validate_block_header(const BlockHeader& header, const BlockState& state, bool with_future_timestamp_check) override; ValidationResult validate_ommers(const Block& block, const BlockState& state) override; void initialize(EVM& evm) override; ValidationResult finalize(IntraBlockState& state, const Block& block, EVM& evm, const std::vector& logs) override; evmc::address get_beneficiary(const BlockHeader& header) override; BlockReward compute_reward(const Block& block) override; protected: ValidationResult validate_difficulty_and_seal(const BlockHeader& header, const BlockHeader& parent) override; private: intx::uint256 terminal_total_difficulty_; RuleSetPtr pre_merge_rule_set_; }; } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/merge_rule_set_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "merge_rule_set.hpp" #include #include #include #include "ethash_rule_set.hpp" namespace silkworm::protocol { TEST_CASE("Proof-of-Stake RuleSet") { BlockHeader header; header.parent_hash = 0xfe92df9ede9d5074e5439198607f01714d6ed665f92d63df8764c1d46e65e795_bytes32; header.ommers_hash = kEmptyListHash; header.beneficiary = 0x002e08000acbbae2155fab7ac01929564949070d_address; header.state_root = 0x1e9e5c33cff9f79838862632235f310c4b378c69b2778b24f506a4898c6d00ef_bytes32; header.transactions_root = kEmptyRoot; header.receipts_root = kEmptyRoot; header.difficulty = 0; header.number = 14'000'000; header.gas_limit = 30'000'000; header.gas_used = 0; header.timestamp = 1'650'000'000; header.prev_randao = 0x2f73f29450aad18c0956ec6350524c2910f3be67ec6e80b7b597240a195788e1_bytes32; header.nonce = {}; Block parent; parent.header.number = header.number - 1; parent.header.gas_limit = header.gas_limit; parent.header.base_fee_per_gas = 1'000'000'000; parent.header.difficulty = 1000; ChainConfig config{kMainnetConfig}; config.terminal_total_difficulty = parent.header.difficulty; MergeRuleSet rule_set{std::make_unique(config), config}; header.base_fee_per_gas = expected_base_fee_per_gas(parent.header); InMemoryState state; state.insert_block(parent, header.parent_hash); CHECK(rule_set.validate_block_header(header, state, /*with_future_timestamp_check=*/false) == ValidationResult::kOk); header.nonce[2] = 5; CHECK(rule_set.validate_block_header(header, state, /*with_future_timestamp_check=*/false) == ValidationResult::kInvalidNonce); header.nonce[2] = 0; header.difficulty = 1000; CHECK(rule_set.validate_block_header(header, state, /*with_future_timestamp_check=*/false) == ValidationResult::kPoWBlockAfterMerge); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/param.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::protocol { // Gas fee schedule—see Appendix G of the Yellow Paper // https://ethereum.github.io/yellowpaper/paper.pdf namespace fee { inline constexpr uint64_t kAccessListStorageKeyCost{1'900}; // EIP-2930 inline constexpr uint64_t kAccessListAddressCost{2'400}; // EIP-2930 inline constexpr uint64_t kGCodeDeposit{200}; inline constexpr uint64_t kGTransaction{21'000}; inline constexpr uint64_t kGTxCreate{32'000}; inline constexpr uint64_t kGTxDataZero{4}; inline constexpr uint64_t kGTxDataNonZeroFrontier{68}; inline constexpr uint64_t kGTxDataNonZeroIstanbul{16}; // EIP-2028 inline constexpr uint64_t kInitCodeWordCost{2}; // EIP-3860 inline constexpr uint64_t kTotalCostFloorPerToken{10}; // EIP-7623: Increase calldata cost inline constexpr uint64_t kPerEmptyAccountCost{25000}; // EIP-7702 Set EOA account code } // namespace fee inline constexpr uint64_t kMinGasLimit{5000}; // https://github.com/ethereum/go-ethereum/blob/v1.13.4/params/protocol_params.go#L28 // EIP-1985: Sane limits for certain EVM parameters inline constexpr uint64_t kMaxGasLimit{INT64_MAX}; // 2^63-1 inline constexpr size_t kMaxCodeSize{0x6000}; // EIP-170 inline constexpr size_t kMaxInitCodeSize{2 * kMaxCodeSize}; // EIP-3860 inline constexpr uint64_t kMaxExtraDataBytes{32}; inline constexpr uint64_t kBlockRewardFrontier{5 * kEther}; inline constexpr uint64_t kBlockRewardByzantium{3 * kEther}; // EIP-649 inline constexpr uint64_t kBlockRewardConstantinople{2 * kEther}; // EIP-1234 // EIP-3529: Reduction in refunds inline constexpr uint64_t kMaxRefundQuotientFrontier{2}; inline constexpr uint64_t kMaxRefundQuotientLondon{5}; // EIP-1559: Fee market change for ETH 1.0 chain inline constexpr uint64_t kInitialBaseFee{kGiga}; inline constexpr uint64_t kBaseFeeMaxChangeDenominator{8}; inline constexpr uint64_t kElasticityMultiplier{2}; // EIP-4844: Shard Blob Transactions inline constexpr uint8_t kBlobCommitmentVersionKzg{1}; inline constexpr uint64_t kGasPerBlob{1u << 17}; inline constexpr uint64_t kTargetBlobGasPerBlock{3 * kGasPerBlob}; inline constexpr uint64_t kMaxBlobGasPerBlock{6 * kGasPerBlob}; inline constexpr uint64_t kMinBlobGasPrice{1}; inline constexpr uint64_t kBlobGasPriceUpdateFraction{3338477}; // EIP-7691: Blob throughput increase inline constexpr uint64_t kTargetBlobGasPerBlockPrague{786432}; inline constexpr uint64_t kMaxBlobGasPerBlockPrague{1179648}; inline constexpr uint64_t kBlobGasPriceUpdateFractionPrague{5007716}; // EIP-4788: Beacon block root in the EVM using namespace evmc::literals; inline constexpr uint64_t kSystemCallGasLimit{30'000'000}; inline constexpr evmc::address kSystemAddress{0xfffffffffffffffffffffffffffffffffffffffe_address}; inline constexpr evmc::address kBeaconRootsAddress{0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02_address}; // EIP-6110: Supply validator deposits on chain inline constexpr auto kDepositContractAddress{0x00000000219ab540356cbb839cbe05303d7705fa_address}; // EIP-7002: Execution layer triggerable withdrawals inline constexpr auto kWithdrawalRequestAddress{0x00000961EF480EB55E80D19AD83579A64C007002_address}; // EIP-7251: Increase the MAX_EFFECTIVE_BALANCE inline constexpr auto kConsolidationRequestAddress{0x0000BBDDC7CE488642FB579F8B00F3A590007251_address}; // EIP-2935: Serve historical block hashes from state inline constexpr evmc::address kHistoryStorageAddress{0x0000F90827F1C53A10CB7A02335B175320002935_address}; // Used in Bor inline constexpr size_t kExtraSealSize{65}; } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/rule_set.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rule_set.hpp" #include #include #include #include #include "bor_rule_set.hpp" #include "ethash_rule_set.hpp" #include "merge_rule_set.hpp" #include "param.hpp" namespace silkworm::protocol { ValidationResult RuleSet::pre_validate_block_body(const Block& block, const BlockState& state) { const BlockHeader& header{block.header}; const evmc_revision rev{chain_config_->revision(header.number, header.timestamp)}; const evmc::bytes32 txn_root{compute_transaction_root(block)}; if (txn_root != header.transactions_root) { return ValidationResult::kWrongTransactionsRoot; } if (ValidationResult err{pre_validate_transactions(block, *chain_config_)}; err != ValidationResult::kOk) { return err; } if (chain_config_->withdrawals_activated(header.timestamp)) { if (!block.withdrawals) { return ValidationResult::kMissingField; } } else { if (block.withdrawals) { return ValidationResult::kFieldBeforeFork; } } const std::optional withdrawals_root{compute_withdrawals_root(block)}; if (withdrawals_root != header.withdrawals_root) { return ValidationResult::kWrongWithdrawalsRoot; } std::optional blob_gas_used{std::nullopt}; if (rev >= EVMC_CANCUN) { blob_gas_used = 0; for (const Transaction& tx : block.transactions) { *blob_gas_used += tx.total_blob_gas(); } const auto max_blob_gas_per_block = rev >= EVMC_PRAGUE ? kMaxBlobGasPerBlockPrague : kMaxBlobGasPerBlock; if (blob_gas_used > max_blob_gas_per_block) { return ValidationResult::kTooManyBlobs; } } if (header.blob_gas_used != blob_gas_used) { return ValidationResult::kWrongBlobGasUsed; } if (block.ommers.empty()) { return header.ommers_hash == kEmptyListHash ? ValidationResult::kOk : ValidationResult::kWrongOmmersHash; } if (prohibit_ommers_) { return ValidationResult::kTooManyOmmers; } const evmc::bytes32 ommers_hash{compute_ommers_hash(block)}; if (ByteView{ommers_hash.bytes} != ByteView{header.ommers_hash}) { return ValidationResult::kWrongOmmersHash; } return validate_ommers(block, state); } ValidationResult RuleSet::validate_ommers(const Block& block, const BlockState& state) { if (prohibit_ommers_) { return block.ommers.empty() ? ValidationResult::kOk : ValidationResult::kTooManyOmmers; } if (block.ommers.size() > 2) { return ValidationResult::kTooManyOmmers; } if (block.ommers.size() == 2 && block.ommers[0] == block.ommers[1]) { return ValidationResult::kDuplicateOmmer; } const BlockHeader& header{block.header}; const std::optional parent{get_parent_header(state, header)}; for (const BlockHeader& ommer : block.ommers) { if (ValidationResult err{validate_block_header(ommer, state, /*with_future_timestamp_check=*/false)}; err != ValidationResult::kOk) { return ValidationResult::kInvalidOmmerHeader; } std::vector old_ommers; if (!is_kin(ommer, *parent, header.parent_hash, 6, state, old_ommers)) { return ValidationResult::kNotAnOmmer; } if (std::ranges::find(old_ommers, ommer) != old_ommers.end()) { return ValidationResult::kDuplicateOmmer; } } return ValidationResult::kOk; } ValidationResult RuleSet::validate_block_header(const BlockHeader& header, const BlockState& state, bool with_future_timestamp_check) { if (with_future_timestamp_check) { const std::time_t now{std::time(nullptr)}; if (header.timestamp > static_cast(now)) { return ValidationResult::kFutureBlock; } } if (header.gas_used > header.gas_limit) { return ValidationResult::kGasAboveLimit; } if (header.gas_limit < kMinGasLimit || header.gas_limit > kMaxGasLimit) { return ValidationResult::kInvalidGasLimit; } if (ValidationResult res{validate_extra_data(header)}; res != ValidationResult::kOk) { return res; } if (prohibit_ommers_ && header.ommers_hash != kEmptyListHash) { return ValidationResult::kWrongOmmersHash; } const std::optional parent{get_parent_header(state, header)}; if (!parent.has_value()) { return ValidationResult::kUnknownParent; } if (header.timestamp <= parent->timestamp) { return ValidationResult::kInvalidTimestamp; } uint64_t parent_gas_limit{parent->gas_limit}; if (header.number == chain_config_->london_block) { parent_gas_limit = parent->gas_limit * kElasticityMultiplier; // EIP-1559 } const uint64_t gas_delta{header.gas_limit > parent_gas_limit ? header.gas_limit - parent_gas_limit : parent_gas_limit - header.gas_limit}; if (gas_delta >= parent_gas_limit / 1024) { return ValidationResult::kInvalidGasLimit; } const evmc_revision rev{chain_config_->revision(header.number, header.timestamp)}; if (rev < EVMC_LONDON) { if (header.base_fee_per_gas) { return ValidationResult::kFieldBeforeFork; } } else { if (!header.base_fee_per_gas) { return ValidationResult::kMissingField; } if (header.base_fee_per_gas != expected_base_fee_per_gas(*parent)) { return ValidationResult::kWrongBaseFee; } } if (chain_config_->withdrawals_activated(header.timestamp)) { if (!header.withdrawals_root) { return ValidationResult::kMissingField; } } else { if (header.withdrawals_root) { return ValidationResult::kFieldBeforeFork; } } if (rev < EVMC_CANCUN) { if (header.blob_gas_used || header.excess_blob_gas || header.parent_beacon_block_root) { return ValidationResult::kFieldBeforeFork; } } else { if (!header.blob_gas_used || !header.excess_blob_gas || !header.parent_beacon_block_root) { return ValidationResult::kMissingField; } if (header.excess_blob_gas != calc_excess_blob_gas(*parent, rev)) { return ValidationResult::kWrongExcessBlobGas; } } if (rev < EVMC_PRAGUE) { if (header.requests_hash) { return ValidationResult::kFieldBeforeFork; } } return validate_difficulty_and_seal(header, *parent); } ValidationResult RuleSet::validate_extra_data(const BlockHeader& header) const { if (header.extra_data.size() > kMaxExtraDataBytes) { return ValidationResult::kExtraDataTooLong; } return ValidationResult::kOk; } std::optional RuleSet::get_parent_header(const BlockState& state, const BlockHeader& header) { if (header.number == 0) { return std::nullopt; } return state.read_header(header.number - 1, header.parent_hash); } bool RuleSet::is_kin(const BlockHeader& branch_header, const BlockHeader& mainline_header, const evmc::bytes32& mainline_hash, unsigned int n, const BlockState& state, std::vector& old_ommers) { if (n == 0 || branch_header == mainline_header) { return false; } BlockBody mainline_body; if (!state.read_body(mainline_header.number, mainline_hash, mainline_body)) { return false; } old_ommers.insert(old_ommers.end(), mainline_body.ommers.begin(), mainline_body.ommers.end()); std::optional mainline_parent{get_parent_header(state, mainline_header)}; if (!mainline_parent) { return false; } std::optional branch_parent{get_parent_header(state, branch_header)}; if (branch_parent == mainline_parent) { return true; } return is_kin(branch_header, mainline_parent.value(), mainline_header.parent_hash, n - 1, state, old_ommers); } evmc::address RuleSet::get_beneficiary(const BlockHeader& header) { return header.beneficiary; } BlockReward RuleSet::compute_reward(const Block&) { return {0, {}}; } void RuleSet::add_fee_transfer_log(IntraBlockState&, const intx::uint256&, const evmc::address&, const intx::uint256&, const evmc::address&, const intx::uint256&) { // do nothing by default } static RuleSetPtr pre_merge_rule_set(const ChainConfig& chain_config) { return std::visit( Overloaded{ [&](const NoPreMergeConfig&) { return nullptr; }, [&](const EthashConfig&) { return std::make_unique(chain_config); }, [&](const bor::Config&) { return std::make_unique(chain_config); }, }, chain_config.rule_set_config); } RuleSetPtr rule_set_factory(const ChainConfig& chain_config) { SILKWORM_ASSERT(chain_config.valid_pre_merge_config()); RuleSetPtr rule_set{pre_merge_rule_set(chain_config)}; if (chain_config.terminal_total_difficulty) { rule_set = std::make_unique(std::move(rule_set), chain_config); } return rule_set; } std::ostream& operator<<(std::ostream& out, const BlockReward& reward) { out << reward.to_string(); return out; } std::string BlockReward::to_string() const { const auto& reward = *this; std::stringstream out; out << "miner_reward: " << intx::to_string(reward.miner) << " ommer_rewards: ["; for (size_t i{0}; i < reward.ommers.size(); ++i) { out << intx::to_string(reward.ommers[i]); if (i != reward.ommers.size() - 1) { out << " "; } } out << "]"; return out.str(); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/rule_set.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::protocol { struct BlockReward { intx::uint256 miner; std::vector ommers; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const BlockReward& reward); // Abstract class representing a set of protocol rules. // For example, its subclass BorRuleSet corresponds to the protocol rule set of Polygon PoS. class RuleSet { public: // Only movable RuleSet(RuleSet&& other) = default; RuleSet& operator=(RuleSet&& other) = default; virtual ~RuleSet() = default; //! \brief Performs validation of block body that can be done prior to sender recovery and execution. //! \brief See [YP] Sections 4.3.2 "Holistic Validity" and 11.1 "Ommer Validation". //! \param [in] block: block to pre-validate. //! \param [in] state: current state. //! \note Shouldn't be used for genesis block. virtual ValidationResult pre_validate_block_body(const Block& block, const BlockState& state); //! \brief See [YP] Section 4.3.4 "Block Header Validity". //! \param [in] header: header to validate. //! \param [in] state: current state. //! \param [in] with_future_timestamp_check : whether to check header timestamp is in the future wrt host current //! time \see https://github.com/erigontech/silkworm/issues/448 //! \note Shouldn't be used for genesis block. virtual ValidationResult validate_block_header(const BlockHeader& header, const BlockState& state, bool with_future_timestamp_check); //! \brief Performs validation of block ommers only. //! \brief See [YP] Sections 11.1 "Ommer Validation". //! \param [in] block: block to validate. //! \param [in] state: current state. virtual ValidationResult validate_ommers(const Block& block, const BlockState& state); //! \brief Initializes block execution by applying changes stipulated by the protocol //! (e.g. storing parent beacon root) virtual void initialize(EVM& evm) = 0; //! \brief Finalizes block execution by applying changes stipulated by the protocol //! (e.g. block rewards, withdrawals) //! \param [in] state: current state. //! \param [in] block: current block to apply rewards for. //! \remarks For Ethash See [YP] Section 11.3 "Reward Application". virtual ValidationResult finalize(IntraBlockState& state, const Block& block, EVM& evm, const std::vector& logs) = 0; //! \brief See [YP] Section 11.3 "Reward Application". //! \param [in] header: Current block to get beneficiary from virtual evmc::address get_beneficiary(const BlockHeader& header); virtual BlockReward compute_reward(const Block& block); //! \brief Bor adds a transfer log after each transaction reflecting the gas fee transfer virtual void add_fee_transfer_log(IntraBlockState& state, const intx::uint256& amount, const evmc::address& sender, const intx::uint256& sender_initial_balance, const evmc::address& recipient, const intx::uint256& recipient_initial_balance); virtual TransferFunc* transfer_func() const { return standard_transfer; } protected: explicit RuleSet(const ChainConfig& chain_config, bool prohibit_ommers) : chain_config_{&chain_config}, prohibit_ommers_{prohibit_ommers} {} virtual ValidationResult validate_extra_data(const BlockHeader& header) const; //! \brief Validates the difficulty and the seal of the header //! \note Used by validate_block_header virtual ValidationResult validate_difficulty_and_seal(const BlockHeader& header, const BlockHeader& parent) = 0; //! \brief Returns parent header (if any) of provided header static std::optional get_parent_header(const BlockState& state, const BlockHeader& header); gsl::not_null chain_config_; private: //! \brief See [YP] Section 11.1 "Ommer Validation" static bool is_kin(const BlockHeader& branch_header, const BlockHeader& mainline_header, const evmc::bytes32& mainline_hash, unsigned int n, const BlockState& state, std::vector& old_ommers); bool prohibit_ommers_{false}; }; using RuleSetPtr = std::unique_ptr; //! \brief Creates an instance of the proper Rule Set on behalf of chain configuration RuleSetPtr rule_set_factory(const ChainConfig& chain_config); } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/rule_set_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rule_set.hpp" #include #include #include namespace silkworm::protocol { TEST_CASE("Rule Set factory") { RuleSetPtr rule_set; rule_set = rule_set_factory(kMainnetConfig); // Ethash rule set CHECK(rule_set); CHECK(rule_set->compute_reward(Block{}).miner == 0); rule_set = rule_set_factory(kHoleskyConfig); // Merged from genesis CHECK(rule_set); CHECK(rule_set->compute_reward(Block{}).miner == 0); rule_set = rule_set_factory(kSepoliaConfig); // Ethash rule set CHECK(rule_set); CHECK(rule_set->compute_reward(Block{}).miner == 0); rule_set = rule_set_factory(test::kLondonConfig); // No-proof rule set CHECK(rule_set); CHECK(rule_set->compute_reward(Block{}).miner == 2000000000000000000); rule_set = rule_set_factory(ChainConfig{.rule_set_config = bor::Config{}}); CHECK(rule_set); CHECK(rule_set->compute_reward(Block{}).miner == 0); rule_set = rule_set_factory(ChainConfig{.rule_set_config = NoPreMergeConfig{}}); CHECK(!rule_set); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/validation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "validation.hpp" #include #include #include #include #include #include #include "intrinsic_gas.hpp" #include "param.hpp" #include "silkworm/core/types/eip_7685_requests.hpp" namespace silkworm::protocol { bool transaction_type_is_supported(TransactionType type, evmc_revision rev) { static constexpr evmc_revision kMinRevisionByType[]{ EVMC_FRONTIER, // kLegacy EVMC_BERLIN, // kAccessList EVMC_LONDON, // kDynamicFee EVMC_CANCUN, // kBlob EVMC_PRAGUE, // kSetCode }; const auto i{static_cast(type)}; return i < std::size(kMinRevisionByType) && rev >= kMinRevisionByType[i]; } ValidationResult pre_validate_transaction(const Transaction& txn, const evmc_revision rev, const uint64_t chain_id, const std::optional& base_fee_per_gas, const std::optional& blob_gas_price) { if (const auto common_check = pre_validate_common_base(txn, rev, chain_id); common_check != ValidationResult::kOk) { return common_check; } if (!is_valid_signature(txn.r, txn.s, rev >= EVMC_HOMESTEAD)) { return ValidationResult::kInvalidSignature; } if (rev >= EVMC_LONDON) { if (base_fee_per_gas.has_value() && txn.max_fee_per_gas < base_fee_per_gas.value()) { return ValidationResult::kMaxFeeLessThanBase; } // https://github.com/ethereum/EIPs/pull/3594 if (txn.max_priority_fee_per_gas > txn.max_fee_per_gas) { return ValidationResult::kMaxPriorityFeeGreaterThanMax; } } if (const auto forks_check = pre_validate_common_forks(txn, rev, blob_gas_price); forks_check != ValidationResult::kOk) { return forks_check; } return ValidationResult::kOk; } ValidationResult validate_transaction(const Transaction& txn, const IntraBlockState& state, uint64_t available_gas) noexcept { const std::optional sender{txn.sender()}; if (!sender) { return ValidationResult::kInvalidSignature; } if (state.get_code_hash(*sender) != kEmptyHash) { const auto code = state.get_code(*sender); if (!eip7702::is_code_delegated(code)) { return ValidationResult::kSenderNoEOA; // EIP-3607 } } const uint64_t nonce{state.get_nonce(*sender)}; if (nonce != txn.nonce) { return ValidationResult::kWrongNonce; } // See YP, Eq (61) in Section 6.2 "Execution" const intx::uint512 v0{txn.maximum_gas_cost() + txn.value}; if (state.get_balance(*sender) < v0) { return ValidationResult::kInsufficientFunds; } if (available_gas < txn.gas_limit) { // Corresponds to the final condition of Eq (58) in Yellow Paper Section 6.2 "Execution". // The sum of the transaction’s gas limit and the gas utilized in this block prior // must be no greater than the block’s gas limit. return ValidationResult::kBlockGasLimitExceeded; } return ValidationResult::kOk; } ValidationResult pre_validate_transactions(const Block& block, const ChainConfig& config) { const BlockHeader& header{block.header}; const evmc_revision rev{config.revision(header.number, header.timestamp)}; const std::optional blob_gas_price{header.blob_gas_price()}; for (const Transaction& txn : block.transactions) { ValidationResult err{pre_validate_transaction(txn, rev, config.chain_id, header.base_fee_per_gas, blob_gas_price)}; if (err != ValidationResult::kOk) { return err; } } return ValidationResult::kOk; } ValidationResult validate_call_precheck(const Transaction& txn, const EVM& evm) noexcept { const std::optional sender{txn.sender()}; if (!sender) { return ValidationResult::kInvalidSignature; } if (const auto common_check = pre_validate_common_base(txn, evm.revision(), evm.config().chain_id); common_check != ValidationResult::kOk) { return common_check; } if (evm.revision() >= EVMC_LONDON) { if (txn.max_fee_per_gas > 0 || txn.max_priority_fee_per_gas > 0) { if (txn.max_fee_per_gas < txn.max_priority_fee_per_gas) { return ValidationResult::kMaxPriorityFeeGreaterThanMax; } if (txn.max_fee_per_gas < evm.block().header.base_fee_per_gas) { return ValidationResult::kMaxFeeLessThanBase; } } } if (const auto forks_check = pre_validate_common_forks(txn, evm.revision(), evm.block().header.blob_gas_price()); forks_check != ValidationResult::kOk) { return forks_check; } return ValidationResult::kOk; } ValidationResult pre_validate_common_base(const Transaction& txn, evmc_revision revision, uint64_t chain_id) noexcept { if (txn.chain_id.has_value()) { if (revision < EVMC_SPURIOUS_DRAGON) { // EIP-155 transaction before EIP-155 was activated return ValidationResult::kUnsupportedTransactionType; } if (txn.chain_id.value() != chain_id) { return ValidationResult::kWrongChainId; } } if (!transaction_type_is_supported(txn.type, revision)) { return ValidationResult::kUnsupportedTransactionType; } const intx::uint128 g0{intrinsic_gas(txn, revision)}; if (txn.gas_limit < g0) { return ValidationResult::kIntrinsicGas; } if (intx::count_significant_bytes(txn.maximum_gas_cost()) > 32) { return ValidationResult::kInsufficientFunds; } // EIP-2681: Limit account nonce to 2^64-1 if (txn.nonce >= UINT64_MAX) { return ValidationResult::kNonceTooHigh; } return ValidationResult::kOk; } ValidationResult pre_validate_common_forks(const Transaction& txn, const evmc_revision rev, const std::optional& blob_gas_price) noexcept { // EIP-3860: Limit and meter initcode const bool contract_creation{!txn.to}; if (rev >= EVMC_SHANGHAI && contract_creation && txn.data.size() > kMaxInitCodeSize) { return ValidationResult::kMaxInitCodeSizeExceeded; } if (rev >= EVMC_CANCUN) { // EIP-4844: Shard Blob Transactions if (txn.type == TransactionType::kBlob) { if (txn.blob_versioned_hashes.empty()) { return ValidationResult::kNoBlobs; } for (const Hash& h : txn.blob_versioned_hashes) { if (h.bytes[0] != kBlobCommitmentVersionKzg) { return ValidationResult::kWrongBlobCommitmentVersion; } } SILKWORM_ASSERT(blob_gas_price); if (txn.max_fee_per_blob_gas < blob_gas_price) { return ValidationResult::kMaxFeePerBlobGasTooLow; } if (!txn.to) { return ValidationResult::kProhibitedContractCreation; } } } if (rev >= EVMC_PRAGUE) { // EIP-7702 if (txn.type == TransactionType::kSetCode) { // Contract creation is disallowed for SetCode transactions if (contract_creation) { return ValidationResult::kProhibitedContractCreation; } if (std::empty(txn.authorizations)) { return ValidationResult::kEmptyAuthorizations; } } // EIP-7623 const auto floor_cost = protocol::floor_cost(txn); if (txn.gas_limit < floor_cost) { return ValidationResult::kFloorCost; } } return ValidationResult::kOk; } ValidationResult validate_call_funds(const Transaction& txn, const EVM& evm, const intx::uint256& owned_funds, bool bailout) noexcept { const intx::uint256 base_fee{evm.block().header.base_fee_per_gas.value_or(0)}; const intx::uint256 effective_gas_price{txn.max_fee_per_gas >= evm.block().header.base_fee_per_gas ? txn.effective_gas_price(base_fee) : txn.max_priority_fee_per_gas}; intx::uint512 required_funds = compute_call_cost(txn, effective_gas_price, evm); // EIP-7623 Increase calldata cost if (evm.revision() >= EVMC_PRAGUE) { const auto floor_cost = protocol::floor_cost(txn); const intx::uint512 gas_limit = std::max(txn.gas_limit, floor_cost); required_funds = std::max(required_funds, gas_limit * effective_gas_price); } const intx::uint256 value = bailout ? 0 : txn.value; if (owned_funds < required_funds + value) { return ValidationResult::kInsufficientFunds; } return ValidationResult::kOk; } intx::uint256 compute_call_cost(const Transaction& txn, const intx::uint256& effective_gas_price, const EVM& evm) { // EIP-1559 normal gas cost intx::uint256 required_funds; if (txn.max_fee_per_gas > 0 || txn.max_priority_fee_per_gas > 0) { // This method should be called after check (max_fee and base_fee) present in pre_check() method required_funds = txn.gas_limit * effective_gas_price; } else { required_funds = 0; } // EIP-4844 blob gas cost (calc_data_fee) if (evm.block().header.blob_gas_used && evm.revision() >= EVMC_CANCUN) { // compute blob fee for eip-4844 data blobs if any const intx::uint256 blob_gas_price{evm.block().header.blob_gas_price().value_or(0)}; required_funds += txn.total_blob_gas() * blob_gas_price; } return required_funds; } intx::uint256 expected_base_fee_per_gas(const BlockHeader& parent) { if (!parent.base_fee_per_gas) { return kInitialBaseFee; } const uint64_t parent_gas_target{parent.gas_limit / kElasticityMultiplier}; const intx::uint256& parent_base_fee_per_gas{*parent.base_fee_per_gas}; if (parent.gas_used == parent_gas_target) { return parent_base_fee_per_gas; } if (parent.gas_used > parent_gas_target) { const intx::uint256 gas_used_delta{parent.gas_used - parent_gas_target}; intx::uint256 base_fee_per_gas_delta{parent_base_fee_per_gas * gas_used_delta / parent_gas_target / kBaseFeeMaxChangeDenominator}; if (base_fee_per_gas_delta < 1) { base_fee_per_gas_delta = 1; } return parent_base_fee_per_gas + base_fee_per_gas_delta; } const intx::uint256 gas_used_delta{parent_gas_target - parent.gas_used}; const intx::uint256 base_fee_per_gas_delta{parent_base_fee_per_gas * gas_used_delta / parent_gas_target / kBaseFeeMaxChangeDenominator}; if (parent_base_fee_per_gas > base_fee_per_gas_delta) { return parent_base_fee_per_gas - base_fee_per_gas_delta; } return 0; } uint64_t calc_excess_blob_gas(const BlockHeader& parent, evmc_revision revision) { const uint64_t parent_excess_blob_gas{parent.excess_blob_gas.value_or(0)}; const uint64_t consumed_blob_gas{parent.blob_gas_used.value_or(0)}; // EIP-7691: Blob throughput increase const auto target_block_gas_per_block = revision >= EVMC_PRAGUE ? kTargetBlobGasPerBlockPrague : kTargetBlobGasPerBlock; if (parent_excess_blob_gas + consumed_blob_gas < target_block_gas_per_block) { return 0; } return parent_excess_blob_gas + consumed_blob_gas - target_block_gas_per_block; } evmc::bytes32 compute_transaction_root(const BlockBody& body) { static constexpr auto kEncoder = [](Bytes& to, const Transaction& txn) { rlp::encode(to, txn, /*wrap_eip2718_into_string=*/false); }; return trie::root_hash(body.transactions, kEncoder); } std::optional compute_withdrawals_root(const BlockBody& body) { if (!body.withdrawals) { return std::nullopt; } static constexpr auto kEncoder = [](Bytes& to, const Withdrawal& w) { rlp::encode(to, w); }; return trie::root_hash(*body.withdrawals, kEncoder); } evmc::bytes32 compute_ommers_hash(const BlockBody& body) { if (body.ommers.empty()) { return kEmptyListHash; } Bytes ommers_rlp; rlp::encode(ommers_rlp, body.ommers); return std::bit_cast(keccak256(ommers_rlp)); } ValidationResult validate_requests_root(const BlockHeader& header, const std::vector& logs, EVM& evm) { FlatRequests requests; // Dequeue deposit requests by parsing logs requests.extract_deposits_from_logs(logs); // Withdrawal requests { Transaction system_txn{}; system_txn.type = TransactionType::kSystem; system_txn.to = kWithdrawalRequestAddress; system_txn.data = Bytes{}; system_txn.set_sender(kSystemAddress); const auto withdrawals = evm.execute(system_txn, kSystemCallGasLimit); evm.state().destruct_touched_dead(); requests.add_request(FlatRequestType::kWithdrawalRequest, withdrawals.data); } // Consolidation requests { Transaction system_txn{}; system_txn.type = TransactionType::kSystem; system_txn.to = kConsolidationRequestAddress; system_txn.data = Bytes{}; system_txn.set_sender(kSystemAddress); const auto consolidations = evm.execute(system_txn, kSystemCallGasLimit); evm.state().destruct_touched_dead(); requests.add_request(FlatRequestType::kConsolidationRequest, consolidations.data); } const auto computed_hash = requests.calculate_sha256(); if (computed_hash != header.requests_hash) { return ValidationResult::kRequestsRootMismatch; } return ValidationResult::kOk; } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/protocol/validation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm { class EVM; // Classification of invalid transactions and blocks. enum class [[nodiscard]] ValidationResult { kOk, // All checks passed kUnknownProtocolRuleSet, // Unsupported protocol rule set kFutureBlock, // Block has a timestamp in the future // [YP] Section 4.3.2 "Holistic Validity", Eq (31) kWrongStateRoot, // wrong Hr kWrongOmmersHash, // wrong Ho kWrongTransactionsRoot, // wrong Ht kWrongReceiptsRoot, // wrong He kWrongLogsBloom, // wrong Hb // [YP] Section 4.3.4 "Block Header Validity", Eq (50) kUnknownParent, // P(H) = ∅ ∨ Hi ≠ P(H)Hi + 1 kUnknownParentTotalDifficulty, // failed to look up parent's total difficulty kWrongDifficulty, // Hd ≠ D(H) kGasAboveLimit, // Hg > Hl kInvalidGasLimit, // |Hl-P(H)Hl|≥P(H)Hl/1024 ∨ Hl<5000 kInvalidTimestamp, // Hs ≤ P(H)Hs kExtraDataTooLong, // ‖Hx‖ > 32 kWrongDaoExtraData, // see EIP-779 kInvalidSeal, // Nonce or mix_hash (invalid Proof of Work) kMissingField, // e.g. missing withdrawals in a post-Shanghai block kFieldBeforeFork, // e.g. withdrawals present in a pre-Shanghai block // [YP] Section 6.2 "Execution", Eq (58) kSenderNoEOA, // EIP-3607: σ[S(T)]c ≠ KEC( () ) kWrongNonce, // Tn ≠ σ[S(T)]n kIntrinsicGas, // g0 > Tg kInsufficientFunds, // v0 > σ[S(T)]b kBlockGasLimitExceeded, // Tg > BHl - l(BR)u // [YP] Section 11.1 "Ommer Validation", Eq (157) kTooManyOmmers, // ‖BU‖ > 2 kInvalidOmmerHeader, // ¬V(U) kNotAnOmmer, // ¬k(U, P(BH)H, 6) kDuplicateOmmer, // not well covered by the YP actually // [YP] Section 11.2 "Transaction Validation", Eq (160) kWrongBlockGas, // BHg ≠ l(BR)u // Various other transaction validation kInvalidSignature, // EIP-2 violated or otherwise invalid signature kWrongChainId, // EIP-155 kUnsupportedTransactionType, // EIP-2718 kNonceTooHigh, // Tn ≥ 2^64 - 1 (EIP-2681) // EIP-1559: Fee market change for ETH 1.0 chain kWrongBaseFee, kMaxFeeLessThanBase, // max_fee_per_gas < base_fee_per_gas kMaxPriorityFeeGreaterThanMax, // max_priority_fee_per_gas > max_fee_per_gas // EIP-3675: Upgrade consensus to Proof-of-Stake kInvalidNonce, // Hn != 0 in a PoS block kPoSBlockBeforeMerge, kPoWBlockAfterMerge, // EIP-3860: Limit and meter initcode kMaxInitCodeSizeExceeded, // EIP-4895: Beacon chain push withdrawals as operations kWrongWithdrawalsRoot, // EIP-4844: Shard Blob Transactions kWrongBlobGasUsed, kWrongExcessBlobGas, kNoBlobs, kTooManyBlobs, kWrongBlobCommitmentVersion, kMaxFeePerBlobGasTooLow, // max_fee_per_blob_gas < blob_gas_price // EIP-4844 and EIP 7702 kProhibitedContractCreation, // Blob and SetCode transactions cannot have the form of a create transaction // EIP-7702 kEmptyAuthorizations, // EIP-7685: Requests root mismatch kRequestsRootMismatch, // EIP-7623: Increase calldata cost kFloorCost, // EIP-7702 Set EOA account code kIncorrectAuthorization, // Bor validation errors. See https://github.com/erigontech/erigon/blob/main/consensus/bor/bor.go kMissingVanity, // Block's extra-data section is shorter than 32 bytes, which is required to store the signer vanity kMissingSignature, // Block's extra-data section doesn't seem to contain a 65 byte secp256k1 signature kInvalidMixDigest, // Block's mix digest is non-zero kExtraValidators, // Non-sprint-end block contains extra validator list kInvalidSpanValidators, // Invalid validator list on sprint end block }; namespace protocol { bool transaction_type_is_supported(TransactionType, evmc_revision); //! \brief First part of transaction validation that can be done prior to sender recovery //! and without access to the state. //! \remarks Should sender of transaction not yet recovered a check on signature's validity is performed //! \remarks These function is agnostic to whole block validity ValidationResult pre_validate_transaction(const Transaction& txn, evmc_revision revision, uint64_t chain_id, const std::optional& base_fee_per_gas, const std::optional& blob_gas_price); ValidationResult pre_validate_transactions(const Block& block, const ChainConfig& config); //! \brief Final part of transaction validation that requires access to the state. //! //! Precondition: //! pre_validate_transaction(txn) must return kOk ValidationResult validate_transaction(const Transaction& txn, const IntraBlockState& state, uint64_t available_gas) noexcept; ValidationResult validate_call_precheck(const Transaction& txn, const EVM& evm) noexcept; ValidationResult pre_validate_common_base(const Transaction& txn, evmc_revision revision, uint64_t chain_id) noexcept; ValidationResult pre_validate_common_forks(const Transaction& txn, evmc_revision rev, const std::optional& blob_gas_price) noexcept; ValidationResult validate_call_funds(const Transaction& txn, const EVM& evm, const intx::uint256& owned_funds, bool bailout) noexcept; intx::uint256 compute_call_cost(const Transaction& txn, const intx::uint256& effective_gas_price, const EVM& evm); //! \see EIP-1559: Fee market change for ETH 1.0 chain intx::uint256 expected_base_fee_per_gas(const BlockHeader& parent); //! \see EIP-4844: Shard Blob Transactions uint64_t calc_excess_blob_gas(const BlockHeader& parent, evmc_revision revision); //! \brief Calculate the transaction root of a block body evmc::bytes32 compute_transaction_root(const BlockBody& body); //! \brief Calculate the withdrawals root of a block body std::optional compute_withdrawals_root(const BlockBody& body); //! \brief Calculate the hash of ommers of a block body evmc::bytes32 compute_ommers_hash(const BlockBody& body); //! \brief Calculates requests rook in block header ValidationResult validate_requests_root(const BlockHeader& header, const std::vector& logs, EVM& evm); } // namespace protocol } // namespace silkworm ================================================ FILE: silkworm/core/protocol/validation_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "validation.hpp" #include #include #include #include #include "silkworm/core/crypto/secp256k1n.hpp" namespace silkworm::protocol { TEST_CASE("Validate transaction types") { const std::optional base_fee_per_gas{std::nullopt}; const std::optional blob_gas_price{std::nullopt}; Transaction txn; txn.type = TransactionType::kLegacy; CHECK(pre_validate_transaction(txn, EVMC_ISTANBUL, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_BERLIN, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kUnsupportedTransactionType); txn.type = static_cast(0x03); // unsupported transaction type CHECK(pre_validate_transaction(txn, EVMC_ISTANBUL, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_BERLIN, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kUnsupportedTransactionType); txn.type = TransactionType::kAccessList; CHECK(pre_validate_transaction(txn, EVMC_ISTANBUL, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_BERLIN, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kUnsupportedTransactionType); txn.type = TransactionType::kDynamicFee; CHECK(pre_validate_transaction(txn, EVMC_ISTANBUL, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_BERLIN, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kUnsupportedTransactionType); CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kUnsupportedTransactionType); } TEST_CASE("Validate max_fee_per_gas") { const std::optional base_fee_per_gas{1'000'000'000}; const std::optional blob_gas_price{std::nullopt}; Transaction txn; txn.type = TransactionType::kDynamicFee; txn.gas_limit = 100'000; txn.r = kSecp256k1n - 1; txn.s = kSecp256k1Halfn - 1; txn.max_priority_fee_per_gas = 500'000'000; txn.max_fee_per_gas = 700'000'000; CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kMaxFeeLessThanBase); txn.max_priority_fee_per_gas = 3'000'000'000; txn.max_fee_per_gas = 2'000'000'000; CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kMaxPriorityFeeGreaterThanMax); txn.max_priority_fee_per_gas = 2'000'000'000; txn.max_fee_per_gas = 2'000'000'000; CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kMaxPriorityFeeGreaterThanMax); txn.max_priority_fee_per_gas = 1'000'000'000; txn.max_fee_per_gas = 2'000'000'000; CHECK(pre_validate_transaction(txn, EVMC_LONDON, 1, base_fee_per_gas, blob_gas_price) != ValidationResult::kMaxPriorityFeeGreaterThanMax); } TEST_CASE("Validate withdrawals_root") { BlockBody body; SECTION("no withdrawals") { CHECK(compute_withdrawals_root(body) == std::nullopt); } SECTION("empty withdrawals") { body.withdrawals = std::vector{}; CHECK(compute_withdrawals_root(body) == kEmptyRoot); } SECTION("non-empty withdrawals") { // mainnet block 17'034'871 body.withdrawals = std::vector{ {.index = 0, .validator_index = 24862, .address = 0x6193f68d97921f4765d72A3E6964fc990c59E0e5_address, .amount = 4451500756}, {.index = 1, .validator_index = 26591, .address = 0x9d213dE20AFd12c56075137bCb68d0d386122A0c_address, .amount = 4547643423}, {.index = 2, .validator_index = 27573, .address = 0xcfc7E96Be27d836b034b37132052549611341108_address, .amount = 4440880509}, }; CHECK(compute_withdrawals_root(body) == 0xc32381c919dad80afe8fe0df79460418e350725a63f67c55b27ee168ef464e5d_bytes32); } } TEST_CASE("EIP-3607: Reject transactions from senders with deployed code") { const evmc::address sender{0x71562b71999873DB5b286dF957af199Ec94617F7_address}; Transaction txn{test::sample_transactions()[0]}; txn.nonce = 0; txn.set_sender(sender); InMemoryState state; IntraBlockState ibs{state}; ibs.add_to_balance(sender, 10 * kEther); ibs.set_code(sender, *from_hex("B0B0FACE")); CHECK(validate_transaction(txn, ibs, UINT64_MAX) == ValidationResult::kSenderNoEOA); } TEST_CASE("EIP-7702: Reject create transactions with zero destination address") { const evmc::address sender{0x71562b71999873DB5b286dF957af199Ec94617F7_address}; Transaction txn{test::sample_transactions()[0]}; txn.type = TransactionType::kSetCode; txn.nonce = 0; txn.set_sender(sender); txn.max_priority_fee_per_gas = 500'000'000; txn.max_fee_per_gas = 700'000'000; txn.to = std::nullopt; txn.authorizations.emplace_back(Authorization{}); InMemoryState state; IntraBlockState ibs{state}; ibs.add_to_balance(sender, 10 * kEther); const std::optional base_fee_per_gas{500'000'000}; const std::optional blob_gas_price{std::nullopt}; CHECK(pre_validate_transaction(txn, EVMC_PRAGUE, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kProhibitedContractCreation); } TEST_CASE("EIP-7702: Reject transactions with empty authorization list") { const evmc::address sender{0x71562b71999873DB5b286dF957af199Ec94617F7_address}; Transaction txn{test::sample_transactions()[0]}; txn.type = TransactionType::kSetCode; txn.nonce = 0; txn.set_sender(sender); txn.max_priority_fee_per_gas = 500'000'000; txn.max_fee_per_gas = 700'000'000; InMemoryState state; IntraBlockState ibs{state}; ibs.add_to_balance(sender, 10 * kEther); const std::optional base_fee_per_gas{500'000'000}; const std::optional blob_gas_price{std::nullopt}; CHECK(pre_validate_transaction(txn, EVMC_PRAGUE, 1, base_fee_per_gas, blob_gas_price) == ValidationResult::kEmptyAuthorizations); } } // namespace silkworm::protocol ================================================ FILE: silkworm/core/rlp/decode.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "decode.hpp" #include #include #include namespace silkworm::rlp { tl::expected decode_header(ByteView& from) noexcept { if (from.empty()) { return tl::unexpected{DecodingError::kInputTooShort}; } Header h{.list = false}; uint8_t b{from[0]}; if (b < 0x80) { h.payload_length = 1; } else if (b < 0xB8) { from.remove_prefix(1); h.payload_length = b - 0x80u; if (h.payload_length == 1) { if (from.empty()) { return tl::unexpected{DecodingError::kInputTooShort}; } if (from[0] < 0x80) { return tl::unexpected{DecodingError::kNonCanonicalSize}; } } } else if (b < 0xC0) { from.remove_prefix(1); const size_t len_of_len{b - 0xB7u}; if (from.size() < len_of_len) { return tl::unexpected{DecodingError::kInputTooShort}; } uint64_t len{0}; if (DecodingResult res{endian::from_big_compact(from.substr(0, len_of_len), len)}; !res) { return tl::unexpected{res.error()}; } h.payload_length = static_cast(len); from.remove_prefix(len_of_len); if (h.payload_length < 56) { return tl::unexpected{DecodingError::kNonCanonicalSize}; } } else if (b < 0xF8) { from.remove_prefix(1); h.list = true; h.payload_length = b - 0xC0u; } else { from.remove_prefix(1); h.list = true; const size_t len_of_len{b - 0xF7u}; if (from.size() < len_of_len) { return tl::unexpected{DecodingError::kInputTooShort}; } uint64_t len{0}; if (DecodingResult res{endian::from_big_compact(from.substr(0, len_of_len), len)}; !res) { return tl::unexpected{res.error()}; } h.payload_length = static_cast(len); from.remove_prefix(len_of_len); if (h.payload_length < 56) { return tl::unexpected{DecodingError::kNonCanonicalSize}; } } if (from.size() < h.payload_length) { return tl::unexpected{DecodingError::kInputTooShort}; } return h; } DecodingResult decode(ByteView& from, Bytes& to, Leftover mode) noexcept { const auto h{decode_header(from)}; if (!h) { return tl::unexpected{h.error()}; } if (h->list) { return tl::unexpected{DecodingError::kUnexpectedList}; } to = from.substr(0, h->payload_length); from.remove_prefix(h->payload_length); if (mode != Leftover::kAllow && !from.empty()) { return tl::unexpected{DecodingError::kInputTooLong}; } return {}; } DecodingResult decode(ByteView& from, bool& to, Leftover mode) noexcept { uint64_t i{0}; if (DecodingResult res{decode(from, i, mode)}; !res) { return tl::unexpected{res.error()}; } if (i > 1) { return tl::unexpected{DecodingError::kOverflow}; } to = i; return {}; } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/rlp/decode.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // RLP decoding functions as per // https://eth.wiki/en/fundamentals/rlp #pragma once #include #include #include #include #include #include #include #include namespace silkworm::rlp { // Whether to allow or prohibit trailing characters in an input after decoding. // If prohibited and the input does contain extra characters, decode() returns DecodingResult::kInputTooLong. enum class Leftover { kProhibit, kAllow, }; // Consumes an RLP header unless it's a single byte in the [0x00, 0x7f] range, // in which case the byte is put back. tl::expected decode_header(ByteView& from) noexcept; DecodingResult decode(ByteView& from, Bytes& to, Leftover mode = Leftover::kProhibit) noexcept; template DecodingResult decode(ByteView& from, T& to, Leftover mode = Leftover::kProhibit) noexcept { const auto h{decode_header(from)}; if (!h) { return tl::unexpected{h.error()}; } if (h->list) { return tl::unexpected{DecodingError::kUnexpectedList}; } if (DecodingResult res{endian::from_big_compact(from.substr(0, h->payload_length), to)}; !res) { return res; } from.remove_prefix(h->payload_length); if (mode != Leftover::kAllow && !from.empty()) { return tl::unexpected{DecodingError::kInputTooLong}; } return {}; } DecodingResult decode(ByteView& from, bool& to, Leftover mode = Leftover::kProhibit) noexcept; template DecodingResult decode(ByteView& from, std::span to, Leftover mode = Leftover::kProhibit) noexcept { static_assert(N != std::dynamic_extent); const auto h{decode_header(from)}; if (!h) { return tl::unexpected{h.error()}; } if (h->list) { return tl::unexpected{DecodingError::kUnexpectedList}; } if (h->payload_length != N) { return tl::unexpected{DecodingError::kUnexpectedLength}; } std::memcpy(to.data(), from.data(), N); from.remove_prefix(N); if (mode != Leftover::kAllow && !from.empty()) { return tl::unexpected{DecodingError::kInputTooLong}; } return {}; } template DecodingResult decode(ByteView& from, uint8_t (&to)[N], Leftover mode = Leftover::kProhibit) noexcept { return decode(from, std::span{to}, mode); } template DecodingResult decode(ByteView& from, std::array& to, Leftover mode = Leftover::kProhibit) noexcept { return decode(from, std::span{to}, mode); } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/rlp/decode_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "decode.hpp" #include #include #include "decode_vector.hpp" namespace silkworm::rlp { template static T decode_success(std::string_view hex) { Bytes bytes{*from_hex(hex)}; ByteView view{bytes}; T res{}; REQUIRE(decode(view, res)); return res; } template static DecodingError decode_failure(std::string_view hex) { Bytes bytes{*from_hex(hex)}; ByteView view{bytes}; T x; DecodingResult res{decode(view, x)}; REQUIRE(!res); return res.error(); } TEST_CASE("RLP decoding") { SECTION("strings") { CHECK(to_hex(decode_success("00")) == "00"); CHECK(to_hex(decode_success("8D6F62636465666768696A6B6C6D")) == "6f62636465666768696a6b6c6d"); CHECK(decode_failure("8D6F62636465666768696A6B6C6Daa") == DecodingError::kInputTooLong); CHECK(decode_failure("C0") == DecodingError::kUnexpectedList); } SECTION("uint64") { CHECK(decode_success("09") == 9); CHECK(decode_success("80") == 0); CHECK(decode_success("820505") == 0x0505); CHECK(decode_success("85CE05050505") == 0xCE05050505); CHECK(decode_failure("85CE05050505aa") == DecodingError::kInputTooLong); CHECK(decode_failure("C0") == DecodingError::kUnexpectedList); CHECK(decode_failure("00") == DecodingError::kLeadingZero); CHECK(decode_failure("8105") == DecodingError::kNonCanonicalSize); CHECK(decode_failure("8200F4") == DecodingError::kLeadingZero); CHECK(decode_failure("B8020004") == DecodingError::kNonCanonicalSize); CHECK(decode_failure("8AFFFFFFFFFFFFFFFFFF7C") == DecodingError::kOverflow); } SECTION("uint256") { CHECK(decode_success("09") == 9); CHECK(decode_success("80") == 0); CHECK(decode_success("820505") == 0x0505); CHECK(decode_success("85CE05050505") == 0xCE05050505); CHECK(decode_success("8AFFFFFFFFFFFFFFFFFF7C") == intx::from_string("0xFFFFFFFFFFFFFFFFFF7C")); CHECK(decode_failure("8BFFFFFFFFFFFFFFFFFF7C") == DecodingError::kInputTooShort); CHECK(decode_failure("8AFFFFFFFFFFFFFFFFFF7Caa") == DecodingError::kInputTooLong); CHECK(decode_failure("C0") == DecodingError::kUnexpectedList); CHECK(decode_failure("00") == DecodingError::kLeadingZero); CHECK(decode_failure("8105") == DecodingError::kNonCanonicalSize); CHECK(decode_failure("8200F4") == DecodingError::kLeadingZero); CHECK(decode_failure("B8020004") == DecodingError::kNonCanonicalSize); CHECK(decode_failure("A101000000000000000000000000000000000000008B000000000000000000000000") == DecodingError::kOverflow); } SECTION("lists") { CHECK(decode_success>("C0").empty()); CHECK(decode_success>("C883BBCCB583FFC0B5") == std::vector{0xBBCCB5, 0xFFC0B5}); CHECK(decode_failure>("C883BBCCB583FFC0B5aa") == DecodingError::kInputTooLong); } } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/rlp/decode_vector.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rlp { //! Decodes an RLP list of dynamic size with items of type T template DecodingResult decode(ByteView& from, std::vector& to, Leftover mode = Leftover::kProhibit) noexcept { const auto h{decode_header(from)}; if (!h) { return tl::unexpected{h.error()}; } if (!h->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } to.clear(); ByteView payload_view{from.substr(0, h->payload_length)}; while (!payload_view.empty()) { to.emplace_back(); if (DecodingResult res{decode(payload_view, to.back(), Leftover::kAllow)}; !res) { return res; } } from.remove_prefix(h->payload_length); if (mode != Leftover::kAllow && !from.empty()) { return tl::unexpected{DecodingError::kInputTooLong}; } return {}; } template DecodingResult decode_items(ByteView& from, Arg1& arg1, Arg2& arg2) noexcept { if (DecodingResult res{decode(from, arg1, Leftover::kAllow)}; !res) { return res; } return decode(from, arg2, Leftover::kAllow); } template DecodingResult decode_items(ByteView& from, Arg1& arg1, Arg2& arg2, Args&... args) noexcept { if (DecodingResult res{decode(from, arg1, Leftover::kAllow)}; !res) { return res; } return decode_items(from, arg2, args...); } //! Decodes an RLP list with a fixed number of items with various types template DecodingResult decode(ByteView& from, Leftover mode, Arg1& arg1, Arg2& arg2, Args&... args) noexcept { const auto header{decode_header(from)}; if (!header) { return tl::unexpected{header.error()}; } if (!header->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } const uint64_t leftover{from.size() - header->payload_length}; if (mode != Leftover::kAllow && leftover) { return tl::unexpected{DecodingError::kInputTooLong}; } if (DecodingResult res{decode_items(from, arg1, arg2, args...)}; !res) { return res; } if (from.size() != leftover) { return tl::unexpected{DecodingError::kUnexpectedListElements}; } return {}; } /** * Decodes an RLP list of dynamic size with items of any type. * The resulting RlpByteView-s refer to RLP-encoded data of the list items. * Use rlp::decode(to[i].data, ...) to fully decode them. */ template <> inline DecodingResult decode(ByteView& from, std::vector& to, Leftover mode) noexcept { auto header = decode_header(from); if (!header) { return tl::unexpected{header.error()}; } if (!header->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } to.clear(); ByteView payload_view = from.substr(0, header->payload_length); while (!payload_view.empty()) { auto item_start = payload_view.begin(); auto item_header = decode_header(payload_view); if (!item_header) { return tl::unexpected{header.error()}; } auto item_end = payload_view.begin() + item_header->payload_length; to.emplace_back(ByteView{std::span{item_start, item_end}}); payload_view.remove_prefix(item_header->payload_length); } from.remove_prefix(header->payload_length); if ((mode != Leftover::kAllow) && !from.empty()) { return tl::unexpected{DecodingError::kInputTooLong}; } return {}; } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/rlp/encode.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "encode.hpp" namespace silkworm::rlp { void encode_header(Bytes& to, Header header) { if (header.payload_length < 56) { const uint8_t code{header.list ? kEmptyListCode : kEmptyStringCode}; to.push_back(static_cast(code + header.payload_length)); } else { auto len_be{endian::to_big_compact(header.payload_length)}; const uint8_t code = header.list ? 0xF7 : 0xB7; to.push_back(static_cast(code + len_be.size())); to.append(len_be); } } size_t length_of_length(uint64_t payload_length) noexcept { if (payload_length < 56) { return 1; } return 1 + intx::count_significant_bytes(payload_length); } void encode(Bytes& to, bool x) { to.push_back(x ? uint8_t{1} : kEmptyStringCode); } void encode(Bytes& to, ByteView s) { if (s.size() != 1 || s[0] >= kEmptyStringCode) { encode_header(to, {.list = false, .payload_length = s.size()}); } to.append(s); } size_t length(ByteView s) noexcept { size_t len{s.size()}; if (s.size() != 1 || s[0] >= kEmptyStringCode) { len += length_of_length(s.size()); } return len; } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/rlp/encode.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // RLP encoding functions as per // https://eth.wiki/en/fundamentals/rlp #pragma once #include #include #include #include namespace silkworm::rlp { struct Header { bool list{false}; size_t payload_length{0}; }; inline constexpr uint8_t kEmptyStringCode{0x80}; inline constexpr uint8_t kEmptyListCode{0xC0}; void encode_header(Bytes& to, Header header); void encode(Bytes& to, ByteView str); template void encode(Bytes& to, const T& n) { if (n == 0) { to.push_back(kEmptyStringCode); } else if (n < kEmptyStringCode) { to.push_back(static_cast(n)); } else { const ByteView be{endian::to_big_compact(n)}; encode_header(to, {.list = false, .payload_length = be.size()}); to.append(be); } } void encode(Bytes& to, bool); size_t length_of_length(uint64_t payload_length) noexcept; size_t length(ByteView) noexcept; template size_t length(const T& n) noexcept { if (n < kEmptyStringCode) { return 1; } const size_t n_bytes{intx::count_significant_bytes(n)}; return n_bytes + length_of_length(n_bytes); } inline size_t length(bool) noexcept { return 1; } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/rlp/encode_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include namespace silkworm { template static Bytes encoded(const T& x) { Bytes s{}; silkworm::rlp::encode(s, x); return s; } TEST_CASE("RLP encoding") { SECTION("strings") { CHECK(to_hex(encoded(ByteView{})) == "80"); CHECK(to_hex(encoded(*from_hex("7B"))) == "7b"); CHECK(to_hex(encoded(*from_hex("80"))) == "8180"); CHECK(to_hex(encoded(*from_hex("ABBA"))) == "82abba"); } SECTION("uint64") { CHECK(to_hex(encoded(0u)) == "80"); CHECK(to_hex(encoded(1u)) == "01"); CHECK(to_hex(encoded(0x7Fu)) == "7f"); CHECK(to_hex(encoded(0x80u)) == "8180"); CHECK(to_hex(encoded(0x400u)) == "820400"); CHECK(to_hex(encoded(0xFFCCB5u)) == "83ffccb5"); CHECK(to_hex(encoded(0xFFCCB5DDu)) == "84ffccb5dd"); CHECK(to_hex(encoded(0xFFCCB5DDFFu)) == "85ffccb5ddff"); CHECK(to_hex(encoded(0xFFCCB5DDFFEEu)) == "86ffccb5ddffee"); CHECK(to_hex(encoded(0xFFCCB5DDFFEE14u)) == "87ffccb5ddffee14"); CHECK(to_hex(encoded(0xFFCCB5DDFFEE1483u)) == "88ffccb5ddffee1483"); } SECTION("uint256") { CHECK(to_hex(encoded(intx::uint256{})) == "80"); CHECK(to_hex(encoded(intx::uint256{1})) == "01"); CHECK(to_hex(encoded(intx::uint256{0x7F})) == "7f"); CHECK(to_hex(encoded(intx::uint256{0x80})) == "8180"); CHECK(to_hex(encoded(intx::uint256{0x400})) == "820400"); CHECK(to_hex(encoded(intx::uint256{0xFFCCB5})) == "83ffccb5"); CHECK(to_hex(encoded(intx::uint256{0xFFCCB5DD})) == "84ffccb5dd"); CHECK(to_hex(encoded(intx::uint256{0xFFCCB5DDFF})) == "85ffccb5ddff"); CHECK(to_hex(encoded(intx::uint256{0xFFCCB5DDFFEE})) == "86ffccb5ddffee"); CHECK(to_hex(encoded(intx::uint256{0xFFCCB5DDFFEE14})) == "87ffccb5ddffee14"); CHECK(to_hex(encoded(intx::uint256{0xFFCCB5DDFFEE1483})) == "88ffccb5ddffee1483"); CHECK(to_hex(encoded(intx::from_string("0x10203E405060708090A0B0C0D0E0F2"))) == "8f10203e405060708090a0b0c0d0e0f2"); CHECK(to_hex(encoded( intx::from_string("0x0100020003000400050006000700080009000A0B4B000C000D000E01"))) == "9c0100020003000400050006000700080009000a0b4b000c000d000e01"); } SECTION("vectors") { CHECK(to_hex(encoded(std::vector{})) == "c0"); CHECK(to_hex(encoded(std::vector{0xFFCCB5, 0xFFC0B5})) == "c883ffccb583ffc0b5"); } } } // namespace silkworm ================================================ FILE: silkworm/core/rlp/encode_vector.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rlp { // std::span to RLP overloads template size_t length_items(const std::span& v) { return std::accumulate(v.begin(), v.end(), size_t{0}, [](size_t sum, const T& x) { return sum + length(x); }); } template size_t length(const std::span& v) { const size_t payload_length = length_items(v); return length_of_length(payload_length) + payload_length; } template void encode_items(Bytes& to, const std::span& v) { for (const T& x : v) { encode(to, x); } } template void encode(Bytes& to, const std::span& v) { const Header h{.list = true, .payload_length = length_items(v)}; to.reserve(to.size() + length_of_length(h.payload_length) + h.payload_length); encode_header(to, h); encode_items(to, v); } // std::vector to RLP overloads template size_t length_items(const std::vector& v) { return length_items(std::span{v.data(), v.size()}); } template size_t length(const std::vector& v) { return length(std::span{v.data(), v.size()}); } template void encode_items(Bytes& to, const std::vector& v) { encode_items(to, std::span{v.data(), v.size()}); } template void encode(Bytes& to, const std::vector& v) { encode(to, std::span{v.data(), v.size()}); } // variadic arguments to RLP overloads template size_t length_items(const Arg1& arg1, const Arg2& arg2) { return length(arg1) + length(arg2); } template size_t length_items(const Arg1& arg1, const Arg2& arg2, const Args&... args) { return length(arg1) + length_items(arg2, args...); } template size_t length(const Arg1& arg1, const Arg2& arg2, const Args&... args) { const size_t payload_length = length_items(arg1, arg2, args...); return length_of_length(payload_length) + payload_length; } template void encode_items(Bytes& to, const Arg1& arg1, const Arg2& arg2) { encode(to, arg1); encode(to, arg2); } template void encode_items(Bytes& to, const Arg1& arg1, const Arg2& arg2, const Args&... args) { encode(to, arg1); encode_items(to, arg2, args...); } template void encode(Bytes& to, const Arg1& arg1, const Arg2& arg2, const Args&... args) { const Header h{/*list=*/true, /*payload_length=*/length_items(arg1, arg2, args...)}; to.reserve(to.size() + length_of_length(h.payload_length) + h.payload_length); encode_header(to, h); encode_items(to, arg1, arg2, args...); } // RlpBytes to RLP overloads /** * RlpBytes represents a raw RLP-encoded list item. * It is useful when RLP structure has a dynamic list with elements of different types. * Each item can be encoded separately and then assembled using the methods below. */ struct RlpBytes { Bytes data; explicit RlpBytes(Bytes data1) : data(std::move(data1)) {} }; //! see RlpBytes struct RlpByteView { ByteView data; explicit RlpByteView(ByteView data1) : data(data1) {} }; template <> inline void encode(Bytes& to, const std::span& v) { Header header{true, 0}; for (const auto& item : v) { header.payload_length += item.data.size(); } to.reserve(to.size() + length_of_length(header.payload_length) + header.payload_length); encode_header(to, header); for (const auto& item : v) { to.append(item.data); } } template <> inline void encode(Bytes& to, const std::vector& v) { encode(to, std::span{v.data(), v.size()}); } template <> inline void encode(Bytes& to, const std::span& v) { std::vector views; views.reserve(v.size()); for (const auto& item : v) { views.emplace_back(item.data); } encode(to, views); } template <> inline void encode(Bytes& to, const std::vector& v) { encode(to, std::span{v.data(), v.size()}); } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/state/block_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { class BlockState { public: virtual ~BlockState() = default; virtual std::optional read_header( BlockNum block_num, const evmc::bytes32& block_hash) const noexcept = 0; // Returns true on success and false on missing block [[nodiscard]] virtual bool read_body( BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept = 0; virtual std::optional total_difficulty( uint64_t block_num, const evmc::bytes32& block_hash) const noexcept = 0; }; } // namespace silkworm ================================================ FILE: silkworm/core/state/delta.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "delta.hpp" #include #include namespace silkworm::state { CreateDelta::CreateDelta(const evmc::address& address) noexcept : address_{address} {} void CreateDelta::revert(IntraBlockState& state) noexcept { state.objects_.erase(address_); } UpdateDelta::UpdateDelta(const evmc::address& address, const Object& previous) noexcept : address_{address}, previous_{previous} {} void UpdateDelta::revert(IntraBlockState& state) noexcept { state.objects_[address_] = previous_; } UpdateBalanceDelta::UpdateBalanceDelta(const evmc::address& address, const intx::uint256& previous) noexcept : address_{address}, previous_{previous} {} void UpdateBalanceDelta::revert(IntraBlockState& state) noexcept { state.objects_[address_].current->balance = previous_; } SuicideDelta::SuicideDelta(const evmc::address& address) noexcept : address_{address} {} void SuicideDelta::revert(IntraBlockState& state) noexcept { state.self_destructs_.erase(address_); } TouchDelta::TouchDelta(const evmc::address& address) noexcept : address_{address} {} void TouchDelta::revert(IntraBlockState& state) noexcept { state.touched_.erase(address_); } StorageChangeDelta::StorageChangeDelta(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& previous) noexcept : address_{address}, key_{key}, previous_{previous} {} void StorageChangeDelta::revert(IntraBlockState& state) noexcept { state.storage_[address_].current[key_] = previous_; } StorageWipeDelta::StorageWipeDelta(const evmc::address& address, Storage storage) noexcept : address_{address}, storage_{std::move(storage)} {} void StorageWipeDelta::revert(IntraBlockState& state) noexcept { state.storage_[address_] = storage_; } StorageCreateDelta::StorageCreateDelta(const evmc::address& address) noexcept : address_{address} {} void StorageCreateDelta::revert(IntraBlockState& state) noexcept { state.storage_.erase(address_); } StorageAccessDelta::StorageAccessDelta(const evmc::address& address, const evmc::bytes32& key) noexcept : address_{address}, key_{key} {} void StorageAccessDelta::revert(IntraBlockState& state) noexcept { state.accessed_storage_keys_[address_].erase(key_); } AccountAccessDelta::AccountAccessDelta(const evmc::address& address) noexcept : address_{address} {} void AccountAccessDelta::revert(IntraBlockState& state) noexcept { state.accessed_addresses_.erase(address_); } TransientStorageChangeDelta::TransientStorageChangeDelta(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& previous) noexcept : address_{address}, key_{key}, previous_{previous} {} void TransientStorageChangeDelta::revert(IntraBlockState& state) noexcept { state.transient_storage_[address_][key_] = previous_; } } // namespace silkworm::state ================================================ FILE: silkworm/core/state/delta.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { class IntraBlockState; namespace state { // Delta is a revertible change made to IntraBlockState. class Delta { public: Delta(const Delta&) = delete; Delta& operator=(const Delta&) = delete; virtual ~Delta() = default; virtual void revert(IntraBlockState& state) noexcept = 0; protected: Delta() = default; }; // Account created. class CreateDelta : public Delta { public: explicit CreateDelta(const evmc::address& address) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; }; // Account updated. class UpdateDelta : public Delta { public: UpdateDelta(const evmc::address& address, const Object& previous) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; Object previous_; }; // Account balance updated. // UpdateBalanceDelta is a special case of the more general UpdateDelta. It occupies less memory than UpdateDelta. class UpdateBalanceDelta : public Delta { public: UpdateBalanceDelta(const evmc::address& address, const intx::uint256& previous) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; intx::uint256 previous_; }; // Account recorded for self-destruction. class SuicideDelta : public Delta { public: explicit SuicideDelta(const evmc::address& address) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; }; // Account touched. class TouchDelta : public Delta { public: explicit TouchDelta(const evmc::address& address) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; }; // Storage value changed. class StorageChangeDelta : public Delta { public: StorageChangeDelta(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& previous) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; evmc::bytes32 key_; evmc::bytes32 previous_; }; // Entire storage deleted. class StorageWipeDelta : public Delta { public: StorageWipeDelta(const evmc::address& address, Storage storage) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; Storage storage_; }; // Storage created. class StorageCreateDelta : public Delta { public: explicit StorageCreateDelta(const evmc::address& address) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; }; // Storage accessed (see EIP-2929). class StorageAccessDelta : public Delta { public: StorageAccessDelta(const evmc::address& address, const evmc::bytes32& key) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; evmc::bytes32 key_; }; // Account accessed (see EIP-2929). class AccountAccessDelta : public Delta { public: explicit AccountAccessDelta(const evmc::address& address) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; }; /// Transient storage add/modify/delete delta. class TransientStorageChangeDelta : public Delta { public: TransientStorageChangeDelta(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& previous) noexcept; void revert(IntraBlockState& state) noexcept override; private: evmc::address address_; evmc::bytes32 key_; evmc::bytes32 previous_; }; } // namespace state } // namespace silkworm ================================================ FILE: silkworm/core/state/in_memory_state.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "in_memory_state.hpp" #include #include #include #include #include #include #include #include namespace silkworm { std::optional InMemoryState::read_account(const evmc::address& address) const noexcept { auto it{accounts_.find(address)}; if (it == accounts_.end()) { return std::nullopt; } return it->second; } ByteView InMemoryState::read_code(const evmc::address& /*address*/, const evmc::bytes32& code_hash) const noexcept { auto it{code_.find(code_hash)}; if (it == code_.end()) { return {}; } return it->second; } evmc::bytes32 InMemoryState::read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept { const auto it1{storage_.find(address)}; if (it1 != storage_.end()) { const auto it2{it1->second.find(incarnation)}; if (it2 != it1->second.end()) { const auto it3{it2->second.find(location)}; if (it3 != it2->second.end()) { return it3->second; } } } return {}; } uint64_t InMemoryState::previous_incarnation(const evmc::address& address) const noexcept { auto it{prev_incarnations_.find(address)}; if (it == prev_incarnations_.end()) { return 0; } return it->second; } std::optional InMemoryState::read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { const auto it1 = headers_.find(block_num); if (it1 != headers_.end()) { const auto it2{it1->second.find(block_hash)}; if (it2 != it1->second.end()) { return it2->second; } } return std::nullopt; } bool InMemoryState::read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept { const auto it1 = bodies_.find(block_num); if (it1 != bodies_.end()) { const auto it2{it1->second.find(block_hash)}; if (it2 != it1->second.end()) { out = it2->second; return true; } } return false; } std::optional InMemoryState::total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { const auto it1 = difficulty_.find(block_num); if (it1 != difficulty_.end()) { const auto it2{it1->second.find(block_hash)}; if (it2 != it1->second.end()) { return it2->second; } } return std::nullopt; } BlockNum InMemoryState::current_canonical_block() const { if (canonical_hashes_.empty()) { return 0; } return canonical_hashes_.rbegin()->first; } std::optional InMemoryState::canonical_hash(BlockNum block_num) const { const auto& ret = canonical_hashes_.find(block_num); if (ret != canonical_hashes_.end()) { return ret->second; } return std::nullopt; } void InMemoryState::insert_block(const Block& block, const evmc::bytes32& hash) { BlockNum block_num = block.header.number; headers_[block_num][hash] = block.header; bodies_[block_num][hash] = block.copy_body(); if (block_num == 0) { difficulty_[block_num][hash] = 0; } else { difficulty_[block_num][hash] = difficulty_[block_num - 1][block.header.parent_hash]; } difficulty_[block_num][hash] += block.header.difficulty; } void InMemoryState::canonize_block(BlockNum block_num, const evmc::bytes32& block_hash) { canonical_hashes_[block_num] = block_hash; } void InMemoryState::decanonize_block(BlockNum block_num) { (void)canonical_hashes_.erase(block_num); } void InMemoryState::insert_receipts(BlockNum, const std::vector&) {} void InMemoryState::insert_call_traces(BlockNum /*block_num*/, const CallTraces& /*traces*/) {} void InMemoryState::begin_block(BlockNum block_num, size_t /*updated_accounts_count*/) { block_num_ = block_num; account_changes_.erase(block_num); storage_changes_.erase(block_num); } void InMemoryState::update_account(const evmc::address& address, std::optional initial, std::optional current) { // Skip update if both initial and final state are non-existent (i.e. contract creation+destruction within the same block) if (!initial && !current) { return; } account_changes_[block_num_][address] = initial; // Store current account or delete it if (current) { accounts_[address] = current.value(); } else { accounts_.erase(address); } // Remember the previous incarnation when an initially existing contract gets deleted, i.e. current is empty or EOA const bool initial_smart{initial && initial->incarnation}; const bool current_deleted_or_eoa{!current || current->incarnation == 0}; if (initial_smart && current_deleted_or_eoa) { prev_incarnations_[address] = initial.value().incarnation; } } void InMemoryState::update_account_code(const evmc::address&, uint64_t, const evmc::bytes32& code_hash, ByteView code) { // Don't overwrite already existing code so that views of it // that were previously returned by read_code() are still valid. code_.try_emplace(code_hash, code); } void InMemoryState::update_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) { storage_changes_[block_num_][address][incarnation][location] = initial; if (is_zero(current)) { storage_[address][incarnation].erase(location); } else { storage_[address][incarnation][location] = current; } } void InMemoryState::unwind_state_changes(BlockNum block_num) { for (const auto& [address, account] : account_changes_[block_num]) { if (account) { accounts_[address] = *account; } else { accounts_.erase(address); } } for (const auto& [address, storage1] : storage_changes_[block_num]) { for (const auto& [incarnation, storage2] : storage1) { for (const auto& [location, value] : storage2) { if (is_zero(value)) { storage_[address][incarnation].erase(location); } else { storage_[address][incarnation][location] = value; } } } } } size_t InMemoryState::storage_size(const evmc::address& address, uint64_t incarnation) const { const auto it1{storage_.find(address)}; if (it1 != storage_.end()) { const auto it2{it1->second.find(incarnation)}; if (it2 != it1->second.end()) { return it2->second.size(); } } return 0; } // https://eth.wiki/fundamentals/patricia-tree#storage-trie evmc::bytes32 InMemoryState::account_storage_root(const evmc::address& address, uint64_t incarnation) const { auto it1{storage_.find(address)}; if (it1 == storage_.end()) { return kEmptyRoot; } auto it2{it1->second.find(incarnation)}; if (it2 == it1->second.end() || it2->second.empty()) { return kEmptyRoot; } const auto& storage{it2->second}; std::map storage_rlp; Bytes buffer; for (const auto& [location, value] : storage) { ethash::hash256 hash{keccak256(location.bytes)}; buffer.clear(); rlp::encode(buffer, zeroless_view(value.bytes)); storage_rlp[to_bytes32(hash.bytes)] = buffer; } trie::HashBuilder hb; for (const auto& [hash, rlp] : storage_rlp) { hb.add_leaf(trie::unpack_nibbles(hash.bytes), rlp); } return hb.root_hash(); } evmc::bytes32 InMemoryState::state_root_hash() const { if (accounts_.empty()) { return kEmptyRoot; } std::map account_rlp; for (const auto& [address, account] : accounts_) { ethash::hash256 hash{keccak256(address.bytes)}; evmc::bytes32 storage_root{account_storage_root(address, account.incarnation)}; account_rlp[to_bytes32(hash.bytes)] = account.rlp(storage_root); } trie::HashBuilder hb; for (const auto& [hash, rlp] : account_rlp) { hb.add_leaf(trie::unpack_nibbles(hash.bytes), rlp); } return hb.root_hash(); } } // namespace silkworm ================================================ FILE: silkworm/core/state/in_memory_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { //! InMemoryState holds the entire state in memory. class InMemoryState : public State { public: // address -> initial value using AccountChanges = FlatHashMap>; // address -> incarnation -> location -> initial value using StorageChanges = FlatHashMap>>; // address -> incarnation -> location -> value using Storage = FlatHashMap>>; std::optional read_account(const evmc::address& address) const noexcept override; ByteView read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept override; evmc::bytes32 read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept override; uint64_t previous_incarnation(const evmc::address& address) const noexcept override; std::optional read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; [[nodiscard]] bool read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept override; std::optional total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; evmc::bytes32 state_root_hash() const override; BlockNum current_canonical_block() const override; std::optional canonical_hash(BlockNum block_num) const override; void insert_block(const Block& block, const evmc::bytes32& hash) override; void canonize_block(BlockNum block_num, const evmc::bytes32& block_hash) override; void decanonize_block(BlockNum block_num) override; void insert_receipts(BlockNum block_num, const std::vector& receipts) override; void insert_call_traces(BlockNum block_num, const CallTraces& traces) override; void begin_block(BlockNum block_num, size_t updated_accounts_count) override; void update_account(const evmc::address& address, std::optional initial, std::optional current) override; void update_account_code(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& code_hash, ByteView code) override; void update_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) override; void unwind_state_changes(BlockNum block_num) override; const FlatHashMap& account_changes() const { return account_changes_; } const FlatHashMap& accounts() const { return accounts_; } size_t storage_size(const evmc::address& address, uint64_t incarnation) const; const Storage& storage() const { return storage_; } private: evmc::bytes32 account_storage_root(const evmc::address& address, uint64_t incarnation) const; FlatHashMap accounts_; // hash -> code FlatHashMap code_; FlatHashMap prev_incarnations_; Storage storage_; // block number -> hash -> header std::map> headers_; // block number -> hash -> body std::map> bodies_; // block number -> hash -> total difficulty std::map> difficulty_; std::map canonical_hashes_; FlatHashMap account_changes_; // per block FlatHashMap storage_changes_; // per block BlockNum block_num_{0}; }; } // namespace silkworm ================================================ FILE: silkworm/core/state/intra_block_state.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "intra_block_state.hpp" #include #include #include namespace silkworm { const state::Object* IntraBlockState::get_object(const evmc::address& address) const noexcept { auto it{objects_.find(address)}; if (it != objects_.end()) { return &it->second; } std::optional account{db_.read_account(address)}; if (account == std::nullopt) { return nullptr; } auto& obj{objects_[address]}; obj.initial = *account; obj.current = *account; return &obj; } state::Object* IntraBlockState::get_object(const evmc::address& address) noexcept { const auto& self{*this}; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) return const_cast(self.get_object(address)); } state::Object& IntraBlockState::get_or_create_object(const evmc::address& address) noexcept { auto* obj{get_object(address)}; if (obj == nullptr) { journal_.emplace_back(std::make_unique(address)); obj = &objects_[address]; obj->current = Account{}; } else if (obj->current == std::nullopt) { journal_.emplace_back(std::make_unique(address, *obj)); obj->current = Account{}; } return *obj; } bool IntraBlockState::exists(const evmc::address& address) const noexcept { auto* obj{get_object(address)}; return obj != nullptr && obj->current != std::nullopt; } bool IntraBlockState::is_dead(const evmc::address& address) const noexcept { auto* obj{get_object(address)}; if (obj == nullptr || obj->current == std::nullopt) { return true; } return obj->current->code_hash == kEmptyHash && obj->current->nonce == 0 && obj->current->balance == 0; } void IntraBlockState::create_contract(const evmc::address& address, bool is_code_delegation) noexcept { created_.insert(address); state::Object created{}; created.current = Account{}; std::optional prev_incarnation{}; const state::Object* prev{get_object(address)}; if (prev) { created.initial = prev->initial; if (prev->current) { created.current->balance = prev->current->balance; if (prev->initial) { prev_incarnation = std::max(prev->current->incarnation, prev->initial->incarnation); } else { prev_incarnation = prev->current->incarnation; } } else if (prev->initial) { prev_incarnation = prev->initial->incarnation; } journal_.emplace_back(std::make_unique(address, *prev)); } else { journal_.emplace_back(std::make_unique(address)); } if (!prev_incarnation || prev_incarnation == 0) { prev_incarnation = db_.previous_incarnation(address); } if (prev && prev_incarnation < prev->current->previous_incarnation) { prev_incarnation = prev->current->previous_incarnation; } // EIP-7702 Reincarnation works for accounts which are not delegated designations if (!is_code_delegation && !delegated_designations_.contains(address)) { created.current->incarnation = *prev_incarnation + 1; created.current->previous_incarnation = *prev_incarnation; } objects_[address] = created; auto it{storage_.find(address)}; if (it == storage_.end()) { journal_.emplace_back(std::make_unique(address)); } else { journal_.emplace_back(std::make_unique(address, it->second)); // EIP-7702 Storage cannot be cleared for delegated designations if (!is_code_delegation && !delegated_designations_.contains(address)) { storage_.erase(address); } } } void IntraBlockState::touch(const evmc::address& address) noexcept { const bool inserted{touched_.insert(address).second}; // See Yellow Paper, Appendix K "Anomalies on the Main Network" // and https://github.com/ethereum/EIPs/issues/716 static constexpr evmc::address kRipemdAddress{0x0000000000000000000000000000000000000003_address}; if (inserted && address != kRipemdAddress) { journal_.emplace_back(std::make_unique(address)); } } bool IntraBlockState::record_suicide(const evmc::address& address) noexcept { const bool inserted{self_destructs_.insert(address).second}; if (inserted) { journal_.emplace_back(std::make_unique(address)); } return inserted; } void IntraBlockState::destruct_suicides() { for (const auto& address : self_destructs_) { destruct(address); } } void IntraBlockState::destruct_touched_dead() { for (const auto& address : touched_) { if (is_dead(address)) { destruct(address); } } } bool IntraBlockState::is_self_destructed(const evmc::address& address) const noexcept { return self_destructs_.contains(address); } // Doesn't create a delta since it's called at the end of a transaction, // when we don't need snapshots anymore. void IntraBlockState::destruct(const evmc::address& address) { // EIP-7702 Storage cannot be cleared for delegated designations if (!delegated_designations_.contains(address)) { storage_.erase(address); } auto* obj{get_object(address)}; if (obj) { obj->current.reset(); } } intx::uint256 IntraBlockState::get_balance(const evmc::address& address) const noexcept { auto* obj{get_object(address)}; return obj && obj->current ? obj->current->balance : 0; } void IntraBlockState::set_balance(const evmc::address& address, const intx::uint256& value) noexcept { auto& obj{get_or_create_object(address)}; journal_.emplace_back(std::make_unique(address, obj.current->balance)); obj.current->balance = value; touch(address); } void IntraBlockState::add_to_balance(const evmc::address& address, const intx::uint256& addend) noexcept { auto& obj{get_or_create_object(address)}; journal_.emplace_back(std::make_unique(address, obj.current->balance)); obj.current->balance += addend; touch(address); } void IntraBlockState::subtract_from_balance(const evmc::address& address, const intx::uint256& subtrahend) noexcept { auto& obj{get_or_create_object(address)}; journal_.emplace_back(std::make_unique(address, obj.current->balance)); obj.current->balance -= subtrahend; touch(address); } uint64_t IntraBlockState::get_nonce(const evmc::address& address) const noexcept { auto* obj{get_object(address)}; return obj && obj->current ? obj->current->nonce : 0; } void IntraBlockState::set_nonce(const evmc::address& address, uint64_t nonce) noexcept { auto& obj{get_or_create_object(address)}; journal_.emplace_back(std::make_unique(address, obj)); obj.current->nonce = nonce; touch(address); } ByteView IntraBlockState::get_code(const evmc::address& address) const noexcept { auto* obj{get_object(address)}; if (!obj || !obj->current) { return {}; } const auto& code_hash{obj->current->code_hash}; if (code_hash == kEmptyHash) { return {}; } if (auto it{new_code_.find(code_hash)}; it != new_code_.end()) { return {it->second.data(), it->second.size()}; } if (auto it{existing_code_.find(code_hash)}; it != existing_code_.end()) { return it->second; } ByteView code{db_.read_code(address, code_hash)}; existing_code_[code_hash] = code; return code; } evmc::bytes32 IntraBlockState::get_code_hash(const evmc::address& address) const noexcept { auto* obj{get_object(address)}; return obj && obj->current ? obj->current->code_hash : kEmptyHash; } void IntraBlockState::set_code(const evmc::address& address, ByteView code) noexcept { auto& obj{get_or_create_object(address)}; journal_.emplace_back(std::make_unique(address, obj)); obj.current->code_hash = std::bit_cast(keccak256(code)); if (eip7702::is_code_delegated(code)) { delegated_designations_.insert(address); } // Don't overwrite already existing code so that views of it // that were previously returned by get_code() are still valid. new_code_.try_emplace(obj.current->code_hash, code.begin(), code.end()); touch(address); } evmc_access_status IntraBlockState::access_account(const evmc::address& address) noexcept { const bool cold_read{accessed_addresses_.insert(address).second}; if (cold_read) { journal_.emplace_back(std::make_unique(address)); } return cold_read ? EVMC_ACCESS_COLD : EVMC_ACCESS_WARM; } evmc_access_status IntraBlockState::access_storage(const evmc::address& address, const evmc::bytes32& key) noexcept { const bool cold_read{accessed_storage_keys_[address].insert(key).second}; if (cold_read) { journal_.emplace_back(std::make_unique(address, key)); } return cold_read ? EVMC_ACCESS_COLD : EVMC_ACCESS_WARM; } evmc::bytes32 IntraBlockState::get_current_storage(const evmc::address& address, const evmc::bytes32& key) const noexcept { return get_storage(address, key, /*original=*/false); } evmc::bytes32 IntraBlockState::get_original_storage(const evmc::address& address, const evmc::bytes32& key) const noexcept { return get_storage(address, key, /*original=*/true); } evmc::bytes32 IntraBlockState::get_storage(const evmc::address& address, const evmc::bytes32& key, bool original) const noexcept { auto* obj{get_object(address)}; if (!obj || !obj->current) { return {}; } state::Storage& storage{storage_[address]}; if (!original) { auto it{storage.current.find(key)}; if (it != storage.current.end()) { return it->second; } } auto it{storage.committed.find(key)}; if (it != storage.committed.end()) { return it->second.original; } uint64_t incarnation{obj->current->incarnation}; if (!obj->initial || obj->initial->incarnation != incarnation) { return evmc::bytes32{}; } evmc::bytes32 val{db_.read_storage(address, incarnation, key)}; state::CommittedValue& entry{storage_[address].committed[key]}; entry.initial = val; entry.original = val; return val; } void IntraBlockState::set_storage(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& value) noexcept { evmc::bytes32 prev{get_current_storage(address, key)}; if (prev == value) { return; } storage_[address].current[key] = value; journal_.emplace_back(std::make_unique(address, key, prev)); } evmc::bytes32 IntraBlockState::get_transient_storage(const evmc::address& addr, const evmc::bytes32& key) { return transient_storage_[addr][key]; } void IntraBlockState::set_transient_storage(const evmc::address& addr, const evmc::bytes32& key, const evmc::bytes32& value) { auto& v = transient_storage_[addr][key]; const auto prev = v; v = value; journal_.emplace_back(std::make_unique(addr, key, prev)); } void IntraBlockState::write_to_db(uint64_t block_num) { db_.begin_block(block_num, objects_.size()); for (const auto& [address, storage] : storage_) { // std::cerr << "Writing do db storage: " << hex(address) << std::endl; auto it1{objects_.find(address)}; if (it1 == objects_.end()) { continue; } const state::Object& obj{it1->second}; if (!obj.current) { continue; } for (const auto& [key, val] : storage.committed) { uint64_t incarnation{obj.current->incarnation}; db_.update_storage(address, incarnation, key, val.initial, val.original); } } for (const auto& [address, obj] : objects_) { db_.update_account(address, obj.initial, obj.current); if (!obj.current) { continue; } const auto& code_hash{obj.current->code_hash}; ByteView code_view; if (auto it{new_code_.find(code_hash)}; it != new_code_.end()) { code_view = {it->second.data(), it->second.size()}; } const auto is_code_delegated = eip7702::is_code_delegated(code_view); if (code_hash != kEmptyHash && (!obj.initial || obj.initial->incarnation != obj.current->incarnation || is_code_delegated)) { if (auto it{new_code_.find(code_hash)}; it != new_code_.end()) { db_.update_account_code(address, obj.current->incarnation, code_hash, code_view); } } } } IntraBlockState::Snapshot IntraBlockState::take_snapshot() const noexcept { IntraBlockState::Snapshot snapshot; snapshot.journal_size_ = journal_.size(); snapshot.log_size_ = logs_.size(); return snapshot; } void IntraBlockState::revert_to_snapshot(const IntraBlockState::Snapshot& snapshot) noexcept { for (size_t i = journal_.size(); i > snapshot.journal_size_; --i) { journal_[i - 1]->revert(*this); } journal_.resize(snapshot.journal_size_); logs_.resize(snapshot.log_size_); } void IntraBlockState::finalize_transaction(evmc_revision rev) { destruct_suicides(); if (rev >= EVMC_SPURIOUS_DRAGON) { destruct_touched_dead(); } for (auto& x : storage_) { state::Storage& storage{x.second}; for (const auto& [key, val] : storage.current) { storage.committed[key].original = val; } storage.current.clear(); } } void IntraBlockState::clear_journal_and_substate() { journal_.clear(); // and the substate self_destructs_.clear(); logs_.clear(); touched_.clear(); created_.clear(); // EIP-2929 accessed_addresses_.clear(); accessed_storage_keys_.clear(); transient_storage_.clear(); } void IntraBlockState::add_log(const Log& log) noexcept { logs_.push_back(log); } } // namespace silkworm ================================================ FILE: silkworm/core/state/intra_block_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm { class IntraBlockState { public: class Snapshot { public: // Only movable Snapshot(Snapshot&&) = default; Snapshot& operator=(Snapshot&&) = default; private: friend class IntraBlockState; Snapshot() = default; size_t journal_size_{0}; size_t log_size_{0}; }; // Not copyable nor movable IntraBlockState(const IntraBlockState&) = delete; IntraBlockState& operator=(const IntraBlockState&) = delete; explicit IntraBlockState(State& db) noexcept : db_{db} {} State& db() { return db_; } bool exists(const evmc::address& address) const noexcept; // See EIP-161: State trie clearing (invariant-preserving alternative) bool is_dead(const evmc::address& address) const noexcept; void create_contract(const evmc::address& address, bool is_code_delegation) noexcept; void destruct(const evmc::address& address); bool record_suicide(const evmc::address& address) noexcept; void destruct_suicides(); void destruct_touched_dead(); size_t number_of_self_destructs() const noexcept { return self_destructs_.size(); } bool is_self_destructed(const evmc::address& address) const noexcept; intx::uint256 get_balance(const evmc::address& address) const noexcept; void set_balance(const evmc::address& address, const intx::uint256& value) noexcept; void add_to_balance(const evmc::address& address, const intx::uint256& addend) noexcept; void subtract_from_balance(const evmc::address& address, const intx::uint256& subtrahend) noexcept; void touch(const evmc::address& address) noexcept; uint64_t get_nonce(const evmc::address& address) const noexcept; void set_nonce(const evmc::address& address, uint64_t nonce) noexcept; ByteView get_code(const evmc::address& address) const noexcept; evmc::bytes32 get_code_hash(const evmc::address& address) const noexcept; void set_code(const evmc::address& address, ByteView code) noexcept; evmc_access_status access_account(const evmc::address& address) noexcept; evmc_access_status access_storage(const evmc::address& address, const evmc::bytes32& key) noexcept; evmc::bytes32 get_current_storage(const evmc::address& address, const evmc::bytes32& key) const noexcept; // https://eips.ethereum.org/EIPS/eip-2200 evmc::bytes32 get_original_storage(const evmc::address& address, const evmc::bytes32& key) const noexcept; void set_storage(const evmc::address& address, const evmc::bytes32& key, const evmc::bytes32& value) noexcept; void write_to_db(uint64_t block_num); Snapshot take_snapshot() const noexcept; void revert_to_snapshot(const Snapshot& snapshot) noexcept; void finalize_transaction(evmc_revision rev); // See Section 6.1 "Substate" of the Yellow Paper void clear_journal_and_substate(); void add_log(const Log& log) noexcept; std::vector& logs() noexcept { return logs_; } const std::vector& logs() const noexcept { return logs_; } const FlatHashSet& touched() const noexcept { return touched_; } const FlatHashSet& created() const noexcept { return created_; } evmc::bytes32 get_transient_storage(const evmc::address& address, const evmc::bytes32& key); void set_transient_storage(const evmc::address& addr, const evmc::bytes32& key, const evmc::bytes32& value); private: friend class state::CreateDelta; friend class state::UpdateDelta; friend class state::UpdateBalanceDelta; friend class state::SuicideDelta; friend class state::TouchDelta; friend class state::StorageChangeDelta; friend class state::StorageWipeDelta; friend class state::StorageCreateDelta; friend class state::StorageAccessDelta; friend class state::AccountAccessDelta; friend class state::TransientStorageChangeDelta; friend class StateView; friend class ExecutionProcessor; evmc::bytes32 get_storage(const evmc::address& address, const evmc::bytes32& key, bool original) const noexcept; const state::Object* get_object(const evmc::address& address) const noexcept; state::Object* get_object(const evmc::address& address) noexcept; state::Object& get_or_create_object(const evmc::address& address) noexcept; State& db_; mutable FlatHashMap objects_; mutable FlatHashMap storage_; mutable FlatHashMap existing_code_; FlatHashMap> new_code_; // EIP- 7702 FlatHashSet delegated_designations_; std::vector> journal_; // substate FlatHashSet self_destructs_; std::vector logs_; FlatHashSet touched_; FlatHashSet created_; // required for EIP-6780 // EIP-2929 substate FlatHashSet accessed_addresses_; FlatHashMap> accessed_storage_keys_; FlatHashMap> transient_storage_; }; } // namespace silkworm ================================================ FILE: silkworm/core/state/intra_block_state_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "intra_block_state.hpp" #include #include #include #include #include #include #include "in_memory_state.hpp" namespace silkworm { static RandomNumber rnd_byte{0, UINT8_MAX}; static evmc::address random_address() { evmc::address a; for (uint8_t& byte : a.bytes) { byte = static_cast(rnd_byte.generate_one()); } return a; } static Bytes random_code() { static RandomNumber rnd_len{1, 60}; const size_t len{static_cast(rnd_len.generate_one())}; Bytes code(len, 0); for (size_t i = 0; i < len; ++i) { code[i] = static_cast(rnd_byte.generate_one()); } return code; } // Check that insertion of new codes doesn't invalidate previously returned views of other codes. TEST_CASE("Code view stability") { const size_t n{1000}; // Generate preexisting codes InMemoryState db; std::vector> existing_codes(n); for (size_t i = 0; i < n; ++i) { evmc::address addr{random_address()}; Bytes code(random_code()); existing_codes[i] = {addr, code}; evmc_bytes32 code_hash{std::bit_cast(keccak256(code))}; Account account{.code_hash = code_hash, .incarnation = kDefaultIncarnation}; db.update_account(addr, /*initial=*/std::nullopt, /*current=*/account); db.update_account_code(addr, kDefaultIncarnation, code_hash, code); } IntraBlockState state{db}; std::unordered_map code_views; std::vector> new_codes; // Randomly get a view of an existing code from the state or insert a new code RandomNumber rnd{0, 2 * n - 1}; for (size_t i = 0; i < n; ++i) { const auto x{static_cast(rnd.generate_one())}; if (x < n) { // Get a preexisting code evmc::address addr{existing_codes[x].first}; code_views[addr] = state.get_code(addr); } else if (x < n + new_codes.size()) { // Get a newly inserted code evmc::address addr{new_codes[x - n].first}; code_views[addr] = state.get_code(addr); } else { // Insert a new code evmc::address addr{random_address()}; Bytes code(random_code()); new_codes.emplace_back(addr, code); state.set_code(addr, code); } } // Check that all previously returned code views have correct code hashes for (const auto& cv : code_views) { evmc_bytes32 code_hash{std::bit_cast(keccak256(cv.second))}; CHECK(state.get_code_hash(cv.first) == code_hash); } } } // namespace silkworm ================================================ FILE: silkworm/core/state/object.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::state { struct Object { std::optional initial; std::optional current; }; struct CommittedValue { evmc::bytes32 initial{}; // value at the beginning of the block evmc::bytes32 original{}; // value at the beginning of the transaction; see EIP-2200 }; struct Storage { FlatHashMap committed; FlatHashMap current; }; } // namespace silkworm::state ================================================ FILE: silkworm/core/state/state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { class State : public BlockState { public: State() = default; // Move-only State(State&& other) = default; State& operator=(State&& other) = default; ~State() override = default; /** @name Readers */ //!@{ virtual std::optional read_account(const evmc::address& address) const noexcept = 0; virtual ByteView read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept = 0; virtual evmc::bytes32 read_storage( const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept = 0; /** Previous non-zero incarnation of an account; 0 if none exists. */ virtual uint64_t previous_incarnation(const evmc::address& address) const noexcept = 0; virtual evmc::bytes32 state_root_hash() const = 0; virtual BlockNum current_canonical_block() const = 0; virtual std::optional canonical_hash(BlockNum block_num) const = 0; //!@} virtual void insert_block(const Block& block, const evmc::bytes32& hash) = 0; virtual void canonize_block(BlockNum block_num, const evmc::bytes32& block_hash) = 0; virtual void decanonize_block(BlockNum block_num) = 0; virtual void insert_receipts([[maybe_unused]] BlockNum block_num, [[maybe_unused]] const std::vector& receipts){}; virtual void insert_receipt([[maybe_unused]] const Receipt& receipt, [[maybe_unused]] uint64_t current_log_index, [[maybe_unused]] uint64_t blob_gas_used){}; virtual void insert_call_traces(BlockNum block_num, const CallTraces& traces) = 0; /** @name State changes * Change sets are backward changes of the state, i.e. account/storage values at the beginning of a block. */ //!@{ /** Mark the beginning of a new block. * Must be called prior to calling update_account/update_account_code/update_storage. */ virtual void begin_block(BlockNum block_num, size_t updated_accounts_count) = 0; virtual void update_account(const evmc::address& address, std::optional initial, std::optional current) = 0; virtual void update_account_code(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& code_hash, ByteView code) = 0; virtual void update_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) = 0; virtual void unwind_state_changes(BlockNum block_num) = 0; //!@} }; } // namespace silkworm ================================================ FILE: silkworm/core/test_util/null_stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::test_util { //! Factory function creating one null output stream (all characters are discarded) inline std::ostream& null_stream() { static struct NullBuf : public std::streambuf { int overflow(int c) override { return c; } } null_buf; static struct NullStream : public std::ostream { NullStream() : std::ostream(&null_buf) {} } null_strm; return null_strm; } } // namespace silkworm::test_util ================================================ FILE: silkworm/core/test_util/sample_blocks.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::test_util { using namespace evmc::literals; inline constexpr evmc::bytes32 kSampleBlockHash{0xca39060462327c919e4b08d004b1ba84f59f239ff2fa9f3919f6d4769ba62bfe_bytes32}; inline constexpr evmc::bytes32 kSampleParentHash{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; inline constexpr evmc::bytes32 kSampleOmmersHash{0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d_bytes32}; inline constexpr evmc::address kSampleBeneficiary{0x0715a7794a1dc8e42615f059dd6e406a6594651a_address}; inline constexpr evmc::bytes32 kSampleStateRoot{0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d_bytes32}; inline constexpr evmc::bytes32 kSampleTransactionsRoot{0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e_bytes32}; inline constexpr evmc::bytes32 kSampleReceiptsRoot{0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f_bytes32}; inline constexpr intx::uint256 kSampleDifficulty{1234}; inline constexpr BlockNum kSampleBlockNum = 5u; inline constexpr uint64_t kSampleGasLimit = 1000000u; inline constexpr uint64_t kSampleGasUsed = 1000000u; inline constexpr uint64_t kSampleTimestamp = 5405021u; inline const Bytes kSampleExtraData{*from_hex("0001FF0100")}; inline constexpr evmc::bytes32 kSamplePrevRandao{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; inline constexpr std::array kSampleNonce{0, 0, 0, 0, 0, 0, 0, 255}; inline constexpr uint64_t kSampleBaseFeePerGas = 0x244428u; inline BlockHeader sample_block_header() { return { .parent_hash = kSampleParentHash, .ommers_hash = kSampleOmmersHash, .beneficiary = kSampleBeneficiary, .state_root = kSampleStateRoot, .transactions_root = kSampleTransactionsRoot, .receipts_root = kSampleReceiptsRoot, .difficulty = kSampleDifficulty, .number = kSampleBlockNum, .gas_limit = kSampleGasLimit, .gas_used = kSampleGasUsed, .timestamp = kSampleTimestamp, .extra_data = kSampleExtraData, .prev_randao = kSamplePrevRandao, .nonce = kSampleNonce, .base_fee_per_gas = kSampleBaseFeePerGas, }; } inline Transaction sample_tx0() { Transaction tx; tx.nonce = 172339; tx.max_priority_fee_per_gas = 50 * kGiga; tx.max_fee_per_gas = 50 * kGiga; tx.gas_limit = 90'000; tx.to = 0xe5ef458d37212a06e3f59d40c454e76150ae7c32_address; tx.value = 1'027'501'080 * kGiga; tx.data = {}; SILKWORM_ASSERT(tx.set_v(27)); tx.r = intx::from_string("0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353"); tx.s = intx::from_string("0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804"); return tx; } inline Transaction sample_tx1() { Transaction tx; tx.type = TransactionType::kDynamicFee; tx.nonce = 1; tx.max_priority_fee_per_gas = 5 * kGiga; tx.max_fee_per_gas = 30 * kGiga; tx.gas_limit = 1'000'000; tx.to = {}; tx.value = 0; tx.data = *from_hex("602a6000556101c960015560068060166000396000f3600035600055"); SILKWORM_ASSERT(tx.set_v(37)); tx.r = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); tx.s = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); return tx; } inline constexpr evmc::bytes32 kSampleOmmerParentHash{0xb397a22bb95bf14753ec174f02f99df3f0bdf70d1851cdff813ebf745f5aeb55_bytes32}; inline constexpr evmc::address kSampleOmmerBeneficiary{0x0c729be7c39543c3d549282a40395299d987cec2_address}; inline constexpr evmc::bytes32 kSampleOmmerStateRoot{0xc2bcdfd012534fa0b19ffba5fae6fc81edd390e9b7d5007d1e92e8e835286e9d_bytes32}; inline constexpr intx::uint256 kSampleOmmerDifficulty{12'555'442'155'599}; inline constexpr BlockNum kSampleOmmerBlockNum = 13'000'013; inline constexpr uint64_t kSampleOmmerGasLimit = 3'141'592; inline constexpr uint64_t kSampleOmmerGasUsed = 0; inline constexpr uint64_t kSampleOmmerTimestamp = 1455404305; inline constexpr evmc::bytes32 kSampleOmmerPrevRandao{0xf0a53dfdd6c2f2a661e718ef29092de60d81d45f84044bec7bf4b36630b2bc08_bytes32}; inline constexpr std::array kSampleOmmerNonce{0, 0, 0, 0, 0, 0, 0, 35}; inline BlockHeader sample_ommer0() { BlockHeader ommer; ommer.parent_hash = kSampleOmmerParentHash; ommer.ommers_hash = kEmptyListHash; ommer.beneficiary = kSampleOmmerBeneficiary; ommer.state_root = kSampleOmmerStateRoot; ommer.transactions_root = kEmptyRoot; ommer.receipts_root = kEmptyRoot; ommer.difficulty = kSampleOmmerDifficulty; ommer.number = kSampleOmmerBlockNum; ommer.gas_limit = kSampleOmmerGasLimit; ommer.gas_used = kSampleOmmerGasUsed; ommer.timestamp = kSampleOmmerTimestamp; ommer.prev_randao = kSampleOmmerPrevRandao; ommer.nonce = kSampleOmmerNonce; return ommer; } inline const Transaction kSampleTx0{sample_tx0()}; inline const Transaction kSampleTx1{sample_tx1()}; inline const BlockHeader kSampleOmmer0{sample_ommer0()}; inline constexpr evmc::address kRecipient1{0x40458B394D1C2A9aA095dd169a6EB43a73949fa3_address}; inline constexpr evmc::address kRecipient2{0xEdA2B3743d37a2a5bD4EB018d515DC47B7802EB4_address}; inline const Withdrawal kSampleWithdrawal0{2733, 157233, kRecipient1, 3148401251}; inline const Withdrawal kSampleWithdrawal1{2734, 157234, kRecipient1, 2797715671}; inline const Withdrawal kSampleWithdrawal2{2735, 157235, kRecipient1, 2987093215}; inline const Withdrawal kSampleWithdrawal3{2736, 157236, kRecipient2, 2917273462}; inline BlockBody sample_block_body() { BlockBody body; body.transactions.emplace_back(kSampleTx0); body.transactions.emplace_back(kSampleTx1); body.ommers.emplace_back(kSampleOmmer0); body.withdrawals = std::vector{ kSampleWithdrawal0, kSampleWithdrawal1, kSampleWithdrawal2, kSampleWithdrawal3, }; return body; } inline Block sample_block() { Block block{sample_block_body()}; block.header = sample_block_header(); return block; } inline std::shared_ptr generate_sample_child_blocks(const BlockHeader& parent) { auto block = std::make_shared(); auto parent_hash = parent.hash(); // Random number generator setup std::mt19937 gen(std::random_device{}()); // Mersenne Twister engine with seed std::uniform_int_distribution dis(1, 1'000'000'000); // Distribution range // BlockHeader block->header.number = parent.number + 1; block->header.difficulty = 17'000'000'000 + dis(gen); block->header.parent_hash = parent_hash; block->header.beneficiary = 0xc8ebccc5f5689fa8659d83713341e5ad19349448_address; block->header.state_root = kEmptyRoot; block->header.receipts_root = kEmptyRoot; block->header.gas_limit = 10'000'000; block->header.gas_used = 0; block->header.timestamp = parent.timestamp + 12; block->header.extra_data = {}; /* // BlockBody: transactions block.transactions.resize(1); if (block.header.number % 2 == 0) { block.transactions[0].nonce = 172339; block.transactions[0].max_priority_fee_per_gas = 50 * kGiga; block.transactions[0].max_fee_per_gas = 50 * kGiga; block.transactions[0].gas_limit = 90'000; block.transactions[0].to = 0xe5ef458d37212a06e3f59d40c454e76150ae7c32_address; block.transactions[0].value = 1'027'501'080 * kGiga; block.transactions[0].data = {}; CHECK(block.transactions[0].set_v(27)); block.transactions[0].r = 0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353_u256; block.transactions[0].s = 0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804_u256; } else { block.transactions[0].type = TransactionType::kEip1559; block.transactions[0].nonce = 1; block.transactions[0].max_priority_fee_per_gas = 5 * kGiga; block.transactions[0].max_fee_per_gas = 30 * kGiga; block.transactions[0].gas_limit = 1'000'000; block.transactions[0].to = {}; block.transactions[0].value = 0; block.transactions[0].data = *from_hex("602a6000556101c960015560068060166000396000f3600035600055"); CHECK(block.transactions[0].set_v(37)); block.transactions[0].r = 0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb_u256; block.transactions[0].s = 0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb_u256; } block.header.transactions_root = protocol::compute_transaction_root(block); // BlockBody: ommers block.ommers.resize(1); block.ommers[0].parent_hash = parent_hash; block.ommers[0].ommers_hash = kEmptyListHash; block.ommers[0].beneficiary = 0x0c729be7c39543c3d549282a40395299d987cec2_address; block.ommers[0].state_root = 0xc2bcdfd012534fa0b19ffba5fae6fc81edd390e9b7d5007d1e92e8e835286e9d_bytes32; block.header.ommers_hash = protocol::compute_ommers_hash(block); */ return block; } } // namespace silkworm::test_util ================================================ FILE: silkworm/core/trie/hash_builder.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "hash_builder.hpp" #include #include #include #include #include #include #include #include namespace silkworm::trie { // See "Specification: Compact encoding of hex sequence with optional terminator" // at https://eth.wiki/fundamentals/patricia-tree static Bytes encode_path(ByteView nibbles, bool terminating) { Bytes res(nibbles.size() / 2 + 1, '\0'); const bool odd{static_cast((nibbles.size() & 1u) != 0)}; res[0] = terminating ? 0x20 : 0x00; res[0] += odd ? 0x10 : 0x00; if (odd) { res[0] |= nibbles[0]; nibbles.remove_prefix(1); } for (auto it{std::next(res.begin(), 1)}, end{res.end()}; it != end; ++it) { *it = static_cast((nibbles[0] << 4) + nibbles[1]); nibbles.remove_prefix(2); } return res; } ByteView HashBuilder::leaf_node_rlp(ByteView path, ByteView value) { Bytes encoded_path{encode_path(path, /*terminating=*/true)}; rlp_buffer_.clear(); rlp::Header h{.list = true, .payload_length = rlp::length(encoded_path) + rlp::length(value)}; rlp::encode_header(rlp_buffer_, h); rlp::encode(rlp_buffer_, encoded_path); rlp::encode(rlp_buffer_, value); return rlp_buffer_; } ByteView HashBuilder::extension_node_rlp(ByteView path, ByteView child_ref) { Bytes encoded_path{encode_path(path, /*terminating=*/false)}; rlp_buffer_.clear(); rlp::Header h{.list = true, .payload_length = rlp::length(encoded_path) + child_ref.size()}; rlp::encode_header(rlp_buffer_, h); rlp::encode(rlp_buffer_, encoded_path); rlp_buffer_.append(child_ref); return rlp_buffer_; } static Bytes wrap_hash(std::span hash) { Bytes wrapped(kHashLength + 1, '\0'); wrapped[0] = rlp::kEmptyStringCode + kHashLength; std::memcpy(&wrapped[1], &hash[0], kHashLength); return wrapped; } static Bytes node_ref(ByteView rlp) { if (rlp.size() < kHashLength) { return Bytes{rlp}; } const ethash::hash256 hash{keccak256(rlp)}; return wrap_hash(hash.bytes); } void HashBuilder::add_leaf(Bytes key, ByteView value) { SILKWORM_ASSERT(key > key_); if (!key_.empty()) { gen_struct_step(key_, key); } key_ = std::move(key); value_ = Bytes{value}; } void HashBuilder::add_branch_node(Bytes nibbled_key, const evmc::bytes32& hash, bool is_in_db_trie) { SILKWORM_ASSERT(nibbled_key > key_ || (key_.empty() && nibbled_key.empty())); if (!key_.empty()) { gen_struct_step(key_, nibbled_key); } else if (nibbled_key.empty()) { // known root hash stack_.push_back(wrap_hash(hash.bytes)); } key_ = std::move(nibbled_key); value_ = hash; is_in_db_trie_ = is_in_db_trie; } void HashBuilder::finalize() { if (!key_.empty()) { gen_struct_step(key_, {}); key_.clear(); value_ = Bytes{}; } } evmc::bytes32 HashBuilder::root_hash() { return root_hash(/*auto_finalize=*/true); } evmc::bytes32 HashBuilder::root_hash(bool auto_finalize) { if (auto_finalize) { finalize(); } if (stack_.empty()) { return kEmptyRoot; } const Bytes& node_ref{stack_.back()}; evmc::bytes32 res{}; if (node_ref.size() == kHashLength + 1) { std::memcpy(res.bytes, &node_ref[1], kHashLength); } else { res = std::bit_cast(keccak256(node_ref)); } return res; } // https://github.com/erigontech/erigon/blob/main/docs/programmers_guide/guide.md#generating-the-structural-information-from-the-sequence-of-keys void HashBuilder::gen_struct_step(ByteView current, const ByteView succeeding) { for (bool build_extensions{false};; build_extensions = true) { const bool preceding_exists{!groups_.empty()}; // Calculate the prefix of the smallest prefix group containing current const size_t preceding_len{groups_.empty() ? 0 : groups_.size() - 1}; const size_t common_prefix_len{prefix_length(succeeding, current)}; const size_t len{std::max(preceding_len, common_prefix_len)}; SILKWORM_ASSERT(len < current.size()); // Add the digit immediately following the max common prefix const uint8_t extra_digit{current[len]}; if (groups_.size() <= len) { groups_.resize(len + 1); } groups_[len] |= 1u << extra_digit; if (tree_masks_.size() < current.size()) { tree_masks_.resize(current.size()); hash_masks_.resize(current.size()); } size_t from{len}; if (!succeeding.empty() || preceding_exists) { ++from; } const ByteView short_node_key{current.substr(from)}; if (!build_extensions) { if (const Bytes * leaf_value{std::get_if(&value_)}) { stack_.push_back(node_ref(leaf_node_rlp(short_node_key, *leaf_value))); } else { stack_.push_back(wrap_hash(std::get(value_).bytes)); if (node_collector) { if (is_in_db_trie_) { // keep track of existing records in DB tree_masks_[current.size() - 1] |= 1u << current.back(); } // register myself in parent's bitmaps hash_masks_[current.size() - 1] |= 1u << current.back(); } build_extensions = true; } } if (build_extensions && !short_node_key.empty()) { // extension node if (node_collector && from > 0) { // See node/silkworm/trie/intermediate_hashes.hpp const auto flag{static_cast(1u << current[from - 1])}; // DB trie can't use hash of an extension node hash_masks_[from - 1] &= ~flag; if (tree_masks_[current.size() - 1]) { // Propagate tree_masks flag along the extension node tree_masks_[from - 1] |= flag; } } stack_.back() = node_ref(extension_node_rlp(short_node_key, stack_.back())); hash_masks_.resize(from); tree_masks_.resize(from); } // Check for the optional part if (preceding_len <= common_prefix_len && !succeeding.empty()) { return; } // Close the immediately encompassing prefix group, if needed if (!succeeding.empty() || preceding_exists) { // branch node std::vector child_hashes{branch_ref(groups_[len], hash_masks_[len])}; // See node/silkworm/trie/intermediate_hashes.hpp if (node_collector) { if (len > 0) { hash_masks_[len - 1] |= 1u << current[len - 1]; } const bool store_in_db_trie{tree_masks_[len] || hash_masks_[len]}; if (store_in_db_trie) { if (len > 0) { tree_masks_[len - 1] |= 1u << current[len - 1]; // register myself in parent bitmap } std::vector hashes(child_hashes.size()); for (size_t i{0}; i < child_hashes.size(); ++i) { SILKWORM_ASSERT(child_hashes[i].size() == kHashLength + 1); std::memcpy(hashes[i].bytes, &child_hashes[i][1], kHashLength); } Node node{groups_[len], tree_masks_[len], hash_masks_[len], hashes}; if (len == 0) { node.set_root_hash(root_hash(/*auto_finalize=*/false)); } node_collector(current.substr(0, len), node); } } } groups_.resize(len); tree_masks_.resize(len); hash_masks_.resize(len); if (preceding_len == 0) { return; } // Update current key for the build_extensions iteration current = current.substr(0, preceding_len); while (!groups_.empty() && groups_.back() == 0) { groups_.pop_back(); } } } // Takes children from the stack and replaces them with branch node ref. std::vector HashBuilder::branch_ref(uint16_t state_mask, uint16_t hash_mask) { SILKWORM_ASSERT(is_subset(hash_mask, state_mask)); std::vector child_hashes; child_hashes.reserve(static_cast(std::popcount(hash_mask))); const size_t first_child_idx{stack_.size() - static_cast(std::popcount(state_mask))}; // Length of 1 for the nil value added below rlp::Header h{.list = true, .payload_length = 1}; for (size_t i{first_child_idx}, digit{0}; digit < 16; ++digit) { if (state_mask & (1u << digit)) { h.payload_length += stack_[i++].size(); } else { h.payload_length += 1; } } rlp_buffer_.clear(); rlp::encode_header(rlp_buffer_, h); for (size_t i{first_child_idx}, digit{0}; digit < 16; ++digit) { if (state_mask & (1u << digit)) { if (hash_mask & (1u << digit)) { child_hashes.push_back(stack_[i]); } rlp_buffer_.append(stack_[i++]); } else { rlp_buffer_.push_back(rlp::kEmptyStringCode); } } // branch nodes with values are not supported rlp_buffer_.push_back(rlp::kEmptyStringCode); stack_.resize(first_child_idx + 1); stack_.back() = node_ref(rlp_buffer_); return child_hashes; } void HashBuilder::reset() { key_.clear(); value_ = Bytes(); is_in_db_trie_ = false; groups_.clear(); tree_masks_.clear(); hash_masks_.clear(); stack_.clear(); rlp_buffer_.clear(); } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/hash_builder.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::trie { // Erigon HashCollector2 using NodeCollector = std::function; // Calculates root hash of a Modified Merkle Patricia Trie. // See Appendix D "Modified Merkle Patricia Trie" of the Yellow Paper // and https://eth.wiki/fundamentals/patricia-tree class HashBuilder { public: HashBuilder() = default; // Not copyable nor movable HashBuilder(const HashBuilder&) = delete; HashBuilder& operator=(const HashBuilder&) = delete; //! \details Entries (leaves, nodes) must be added in the strictly increasing lexicographic order (by key). //! Consequently, duplicate keys are not allowed. //! The key should be unpacked, i.e. have one nibble per byte. //! In addition, a leaf key may not be a prefix of another leaf key //! (e.g. leaves with keys 0a0b & 0a0b0005 may not coexist). void add_leaf(Bytes nibbled_key, ByteView value); //! \details Entries (leaves, nodes) must be added in the strictly increasing lexicographic order (by key). //! Consequently, duplicate keys are not allowed. //! The key should be unpacked, i.e. have one nibble per byte. //! Nodes whose RLP is shorter than 32 bytes may not be added. void add_branch_node(Bytes nibbled_key, const evmc::bytes32& hash, bool is_in_db_trie = false); //! \brief Returns the root hash computed on behalf of added entries //! \remarks If no entries in the stack_ the kEmptyRoot is returned evmc::bytes32 root_hash(); //! \brief Pointer to function for collecting nodes in etl. NodeCollector node_collector{nullptr}; //! \brief Resets the builder as newly created void reset(); private: evmc::bytes32 root_hash(bool auto_finalize); void finalize(); // See Erigon GenStructStep void gen_struct_step(ByteView current, ByteView succeeding); std::vector branch_ref(uint16_t state_mask, uint16_t hash_mask); ByteView leaf_node_rlp(ByteView path, ByteView value); ByteView extension_node_rlp(ByteView path, ByteView child_ref); Bytes key_; // unpacked – one nibble per byte std::variant value_; // leaf value or node hash bool is_in_db_trie_{false}; std::vector groups_; std::vector tree_masks_; std::vector hash_masks_; std::vector stack_; // node references: hashes or embedded RLPs Bytes rlp_buffer_; }; } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/hash_builder_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include namespace silkworm::trie { TEST_CASE("Empty trie") { HashBuilder hb; CHECK(to_hex(hb.root_hash()) == to_hex(kEmptyRoot)); } TEST_CASE("HashBuilder1") { const evmc::bytes32 key1{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; const evmc::bytes32 key2{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; const Bytes val1{*from_hex("01")}; const Bytes val2{*from_hex("02")}; HashBuilder hb; hb.add_leaf(unpack_nibbles(key1.bytes), val1); hb.add_leaf(unpack_nibbles(key2.bytes), val2); // even terminating const Bytes encoded_empty_terminating_path{*from_hex("20")}; const Bytes leaf1_payload{encoded_empty_terminating_path + val1}; const Bytes leaf2_payload{encoded_empty_terminating_path + val2}; Bytes branch_payload; branch_payload.push_back(rlp::kEmptyStringCode); // nibble 0 rlp::encode_header(branch_payload, {.list = true, .payload_length = leaf1_payload.size()}); branch_payload.append(leaf1_payload); rlp::encode_header(branch_payload, {.list = true, .payload_length = leaf2_payload.size()}); branch_payload.append(leaf2_payload); // nibbles 3 to 15 plus nil value for (size_t i = {3}; i < 17; ++i) { branch_payload.push_back(rlp::kEmptyStringCode); } Bytes branch_rlp; const rlp::Header branch_head{/*list=*/true, branch_payload.size()}; rlp::encode_header(branch_rlp, branch_head); branch_rlp.append(branch_payload); REQUIRE(branch_rlp.size() < kHashLength); // odd extension const Bytes encoded_path{*from_hex("1000000000000000000000000000000000000000000000000000000000000000")}; Bytes extension_payload; rlp::encode(extension_payload, encoded_path); extension_payload.append(branch_rlp); Bytes extension_rlp; const rlp::Header extension_head{/*list=*/true, extension_payload.size()}; rlp::encode_header(extension_rlp, extension_head); extension_rlp.append(extension_payload); REQUIRE(extension_rlp.size() >= kHashLength); const ethash::hash256 hash{keccak256(extension_rlp)}; const auto root_hash{hb.root_hash()}; CHECK(to_hex(root_hash) == to_hex(hash.bytes)); // Reset hash builder hb.reset(); REQUIRE(hb.root_hash() == kEmptyRoot); } TEST_CASE("HashBuilder2") { // ------------------------------------------------------------------------------------------ // The first entry Bytes key0{*from_hex("646f")}; // "do" Bytes val0{*from_hex("76657262")}; // "verb" // leaf node Bytes rlp0{*from_hex("c98320") + key0 + *from_hex("84") + val0}; ethash::hash256 hash0{keccak256(rlp0)}; HashBuilder hb0; hb0.add_leaf(unpack_nibbles(key0), val0); CHECK(to_hex(hb0.root_hash()) == to_hex(hash0.bytes)); // ------------------------------------------------------------------------------------------ // Add the second entry Bytes key1{*from_hex("676f6f64")}; // "good" Bytes val1{*from_hex("7075707079")}; // "puppy" // leaf node 0 Bytes rlp1_0{*from_hex("c882206f84") + val0}; REQUIRE(rlp1_0.size() < kHashLength); // leaf node 1 Bytes rlp1_1{*from_hex("cb84206f6f6485") + val1}; REQUIRE(rlp1_1.size() < kHashLength); // branch node Bytes rlp1_2{*from_hex("e480808080") + rlp1_0 + *from_hex("8080") + rlp1_1 + *from_hex("808080808080808080")}; REQUIRE(rlp1_2.size() >= kHashLength); evmc::bytes32 hash1_2; std::memcpy(hash1_2.bytes, keccak256(rlp1_2).bytes, kHashLength); // extension node Bytes rlp1{*from_hex("e216a0")}; std::copy_n(hash1_2.bytes, kHashLength, std::back_inserter(rlp1)); ethash::hash256 hash1{keccak256(rlp1)}; HashBuilder hb1; hb1.add_leaf(unpack_nibbles(key0), val0); hb1.add_leaf(unpack_nibbles(key1), val1); CHECK(to_hex(hb1.root_hash()) == to_hex(hash1.bytes)); // ------------------------------------------------------------------------------------------ // Now add the branch node directly HashBuilder hb2; hb2.add_branch_node(*from_hex("06"), hash1_2); CHECK(to_hex(hb2.root_hash()) == to_hex(hash1.bytes)); } /* This test is temporarily commented out while searching for the solution. Note ! HashBuilder should create at least a root node for every tree but apparently when all leaves begin all with the same nibble(s) - very rare - this does not happen. The absence of a root node however does NOT break stage IntermediateHashes as trie cursor, when a root node is not found, instructs higher loop to rebuild the entire tree. I have encountered this edge case only on one contract (below is real data - hashed unfortunately) TEST_CASE("HashBuilder3") { Bytes key_0{ *from_hex("0400000d0e0307060d0404010c0c000c020f04000d080e04050407090003060e070b09050a0e080e0c0a0d0d080a0405020b" "03050a070b090a02080405040300")}; Bytes key_1{ *from_hex("0400050708070f0a01020a0802030e000f020b070603010c0c04010b030b0a080802080b030302010c0a0801010101010f0a" "07050c0d030a0a030b0b050a0c0e")}; Bytes key_2{ *from_hex("040b000a0f010b000d0305050506090a03050705060f0a000c020e0502020405040d020a0f0d0f0807000c010e0501010d0a" "06040e0e0d0c0f000f0b0f04000f")}; Bytes val_0{*from_hex("0360051c896000")}; Bytes val_1{*from_hex("038d7ea4c68000")}; Bytes val_2{*from_hex("2d79883d2000")}; evmc::bytes32 expected_root{ to_bytes32(*from_hex("0xa6952477996e4881392f2f6eb688fc541bebd1c7ab794f295da484d38d363be9"))}; std::vector> entries{}; HashBuilder hb; hb.node_collector = [&entries](ByteView nibbled_key, const trie::Node& node) { Bytes key{nibbled_key}; Bytes value{node.state_mask() ? node.encode_for_storage() : Bytes()}; entries.emplace_back(key, value); }; Bytes rlp_buffer{}; rlp::encode(rlp_buffer, val_0); hb.add_leaf(key_0, rlp_buffer); rlp_buffer.clear(); rlp::encode(rlp_buffer, val_1); hb.add_leaf(key_1, rlp_buffer); rlp_buffer.clear(); rlp::encode(rlp_buffer, val_2); hb.add_leaf(key_2, rlp_buffer); rlp_buffer.clear(); auto computed_root{hb.root_hash()}; REQUIRE(computed_root == expected_root); REQUIRE(entries.size() == 1); REQUIRE(entries[0].first.empty()); } */ TEST_CASE("Known root hash") { const evmc::bytes32 root_hash{0x9fa752911d55c3a1246133fe280785afbdba41f357e9cae1131d5f5b0a078b9c_bytes32}; HashBuilder hb; hb.add_branch_node({}, root_hash); CHECK(to_hex(hb.root_hash()) == to_hex(root_hash.bytes)); } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/nibbles.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "nibbles.hpp" namespace silkworm::trie { Bytes pack_nibbles(ByteView unpacked) { if (unpacked.empty()) { return {}; } size_t pos{unpacked.size() & 1}; Bytes out((unpacked.size() + pos) / 2, '\0'); auto out_it{out.begin()}; while (unpacked.size() > pos) { *out_it++ = static_cast((unpacked[0] << 4) + unpacked[1]); unpacked.remove_prefix(2); } if (pos) { *out_it = static_cast(unpacked[0] << 4); unpacked.remove_prefix(1); } return out; } Bytes unpack_nibbles(ByteView data) { Bytes out(2 * data.size(), '\0'); size_t offset{0}; for (const auto& b : data) { out[offset] = b >> 4; out[offset + 1] = b & 0x0F; offset += 2; } return out; } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/nibbles.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::trie { //! \brief Transforms a string of Nibbles into a string of Bytes //! \def A Nibble's value is [0..16) //! \see Erigon's CompressNibbles Bytes pack_nibbles(ByteView unpacked); //! \brief Transforms a string of bytes into a string of Nibbles //! \def A Nibble's value is [0..16) //! \see Erigon's DecompressNibbles Bytes unpack_nibbles(ByteView data); } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/nibbles_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include namespace silkworm::trie { TEST_CASE("Nibbles") { std::vector> test_cases = { // Bytes -> Nibbles {"", ""}, // {"00", "0000"}, // {"01", "0001"}, // {"0f", "000f"}, // {"f011", "0f000101"}, // {"f111", "0f010101"}, // {"123456789a", "0102030405060708090a"}, // {"123456789f", "0102030405060708090f"}, // {"12345678aa", "01020304050607080a0a"}, // {"123456789abcdeff", "0102030405060708090a0b0c0d0e0f0f"}, // }; for (const auto& test_case : test_cases) { if (test_case.first.empty()) { auto packed{pack_nibbles({})}; REQUIRE(packed.empty()); REQUIRE(unpack_nibbles(packed).empty()); continue; } const auto packed{from_hex(test_case.first)}; const auto unpacked{from_hex(test_case.second)}; REQUIRE((packed.has_value() && unpacked.has_value())); REQUIRE(to_hex(unpack_nibbles(*packed)) == test_case.second); REQUIRE(to_hex(pack_nibbles(*unpacked)) == test_case.first); } // Pack an odd length nibbled key Bytes odd_input{1u, 2u, 3u}; REQUIRE(to_hex(pack_nibbles(odd_input)) == "1230"); } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/node.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node.hpp" #include #include #include #include namespace silkworm::trie { Node::Node(uint16_t state_mask, uint16_t tree_mask, uint16_t hash_mask, std::vector hashes, const std::optional& root_hash) : state_mask_{state_mask}, tree_mask_{tree_mask}, hash_mask_{hash_mask}, hashes_{std::move(hashes)}, root_hash_{root_hash} { SILKWORM_ASSERT(is_subset(tree_mask, state_mask)); SILKWORM_ASSERT(is_subset(hash_mask, state_mask)); SILKWORM_ASSERT(std::cmp_equal(std::popcount(hash_mask_), hashes_.size())); } void Node::set_root_hash(const std::optional& root_hash) { root_hash_ = root_hash; } Bytes Node::encode_for_storage() const { const size_t buf_size{/* 3 masks state/tree/hash 2 bytes each */ 6 + /* root hash */ (root_hash_.has_value() ? kHashLength : 0u) + /* hashes */ hashes_.size() * kHashLength}; Bytes buf(buf_size, '\0'); endian::store_big_u16(&buf[0], state_mask_); endian::store_big_u16(&buf[2], tree_mask_); endian::store_big_u16(&buf[4], hash_mask_); size_t pos{6}; if (root_hash_.has_value()) { std::memcpy(&buf[pos], root_hash_->bytes, kHashLength); pos += kHashLength; } if (!hashes_.empty()) { std::memcpy(&buf[pos], hashes_.data(), hashes_.size() * kHashLength); } return buf; } DecodingResult Node::decode_from_storage(ByteView raw, Node& node) { // At least state/tree/hash masks need to be present if (raw.size() < 6) { return tl::unexpected{DecodingError::kInputTooShort}; } // Beyond the 6th byte the length must be a multiple of kHashLength if ((raw.size() - 6) % kHashLength != 0) { return tl::unexpected{DecodingError::kInvalidHashesLength}; } node.root_hash_.reset(); node.hashes_.clear(); node.state_mask_ = endian::load_big_u16(&raw[0]); node.tree_mask_ = endian::load_big_u16(&raw[2]); node.hash_mask_ = endian::load_big_u16(&raw[4]); if (!is_subset(node.tree_mask_, node.state_mask_) || !is_subset(node.hash_mask_, node.state_mask_)) { return tl::unexpected{DecodingError::kInvalidMasksSubsets}; } raw.remove_prefix(6); size_t expected_num_hashes{static_cast(std::popcount(node.hash_mask_))}; size_t effective_num_hashes{raw.size() / kHashLength}; if (effective_num_hashes < expected_num_hashes) { return tl::unexpected{DecodingError::kInvalidHashesLength}; } size_t delta{effective_num_hashes - expected_num_hashes}; if (delta > 1) { return tl::unexpected{DecodingError::kInvalidHashesLength}; } if (delta == 1) { node.root_hash_.emplace(); std::memcpy(node.root_hash_->bytes, raw.data(), kHashLength); raw.remove_prefix(kHashLength); --effective_num_hashes; } node.hashes_.resize(effective_num_hashes); if (effective_num_hashes) { std::memcpy(node.hashes_.data(), raw.data(), raw.size()); } return {}; } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/node.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::trie { // Used in node/silkworm/trie/intermediate_hashes.hpp // // Presumed invariants: // 1) tree_mask ⊆ state_mask // 2) hash_mask ⊆ state_mask // 3) #hash_mask == #hashes class Node { public: Node() = default; explicit Node(uint16_t state_mask, uint16_t tree_mask, uint16_t hash_mask, std::vector hashes, const std::optional& root_hash = std::nullopt); // copyable Node(const Node& other) = default; Node& operator=(const Node& other) = default; uint16_t state_mask() const { return state_mask_; } uint16_t tree_mask() const { return tree_mask_; } uint16_t hash_mask() const { return hash_mask_; } const std::vector& hashes() const { return hashes_; } const std::optional& root_hash() const { return root_hash_; } void set_root_hash(const std::optional& root_hash); friend bool operator==(const Node&, const Node&) = default; //! \see Erigon's MarshalTrieNodeTyped Bytes encode_for_storage() const; //! \see Erigon's UnmarshalTrieNodeTyped static DecodingResult decode_from_storage(ByteView raw, Node& node); protected: uint16_t state_mask_{0}; // Each bit set indicates parenting of a hashed state uint16_t tree_mask_{0}; // Each bit set indicates parenting of a child uint16_t hash_mask_{0}; // Each bit set indicates ownership of a valid hash std::vector hashes_{}; std::optional root_hash_{std::nullopt}; private: }; inline bool is_subset(uint16_t sub, uint16_t sup) { return (sub & sup) == sub; } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/node_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node.hpp" #include #include #include #include namespace silkworm::trie { using namespace evmc::literals; TEST_CASE("Node marshalling") { Node n{/*state_mask*/ 0xf607, /*tree_mask*/ 0x0005, /*hash_mask*/ 0x4004, /*hashes*/ { 0x90d53cd810cc5d4243766cd4451e7b9d14b736a1148b26b3baac7617f617d321_bytes32, 0xcc35c964dda53ba6c0b87798073a9628dbc9cd26b5cce88eb69655a9c609caf1_bytes32, }, /*root_hash*/ 0xaaaabbbb0006767767776fffffeee44444000005567645600000000eeddddddd_bytes32}; REQUIRE(std::cmp_equal(n.hashes().size(), std::popcount(n.hash_mask()))); Bytes raw{n.encode_for_storage()}; Node from_raw; REQUIRE(Node::decode_from_storage(raw, from_raw)); CHECK(from_raw == n); // An empty decoding Node x; CHECK(!Node::decode_from_storage({}, x)); // Decode from only state_mask raw = *from_hex("0xf607"); CHECK(!Node::decode_from_storage(raw, x)); // Decode with no hashes when hashmask is valued to 2 raw = *from_hex("0xf60700054004"); CHECK(!Node::decode_from_storage(raw, x)); // Decode with bad hash when hashmask is valued 2 raw = *from_hex("0xf60700054004aaaabbbb0006767767776fffffeee4444400000556764560000"); CHECK(!Node::decode_from_storage(raw, x)); // Decode with zero state mask (is subset fails) raw = *from_hex("0x000000054004"); CHECK(!Node::decode_from_storage(raw, x)); // Decode with more hashes than allowed raw = *from_hex( "0xf60700054004aaaabbbb0006767767776fffffeee44444000005567645600000000eeddddddd90d53cd810cc5d4243766cd4451e7b9d" "14b736a1148b26b3baac7617f617d321cc35c964dda53ba6c0b87798073a9628dbc9cd26b5cce88eb69655a9c609caf1cc35c964dda53b" "a6c0b87798073a9628dbc9cd26b5cce88eb69655a9c609caf1"); CHECK(!Node::decode_from_storage(raw, x)); } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/prefix_set.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "prefix_set.hpp" #include #include namespace silkworm::trie { void PrefixSet::insert(ByteView key, bool marker) { insert(Bytes(key), marker); } void PrefixSet::insert(Bytes&& key, bool marker) { keys_.emplace_back(std::move(key), marker); sorted_ = false; } bool PrefixSet::contains(ByteView prefix) { if (keys_.empty()) { return false; } // Key uniqueness and sorting ensure_sorted(); // We optimize for the case when contains() queries are issued with increasing prefixes, // e.g. contains("00"), contains("04"), contains("0b"), contains("0b05"), contains("0c"), contains("0f"), ... // instead of some random order. while (index_ > 0 && keys_[index_].first > prefix) { --index_; } for (size_t max_index{keys_.size() - 1};; ++index_) { const auto& [key, _]{keys_[index_]}; if (key.starts_with(prefix)) { return true; } if (key > prefix || index_ == max_index) { return false; } } } std::pair PrefixSet::contains_and_next_marked(ByteView prefix, size_t invariant_prefix_len) { bool is_contained{contains(prefix)}; ByteView next_created{}; invariant_prefix_len = std::min(invariant_prefix_len, prefix.size()); // Lookup next marked created key for (size_t i{index_}, e{keys_.size()}; i < e; ++i) { auto& item{keys_[i]}; // Check we're in the same invariant part of the prefix if (invariant_prefix_len && std::memcmp(&prefix[0], &item.first[0], invariant_prefix_len) != 0) { break; } if (item.second) { next_created = ByteView(item.first); break; } } return {is_contained, next_created}; } void PrefixSet::ensure_sorted() { if (!sorted_) { std::ranges::sort(keys_); const auto [first, last] = std::ranges::unique(keys_); keys_.erase(first, last); sorted_ = true; } } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/prefix_set.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::trie { /** * A set of "nibbled" byte strings with the following property: * If x ∈ S and x starts with y, then y ∈ S. * Corresponds to RetainList in Erigon. */ class PrefixSet { public: //! \brief Constructs an empty set. PrefixSet() = default; // copyable PrefixSet(const PrefixSet& other) = default; PrefixSet& operator=(const PrefixSet& other) = default; void insert(ByteView key, bool marker = false); void insert(Bytes&& key, bool marker = false); //! \brief Returns whether or not provided prefix is contained in any of the owned keys //! \remarks Doesn't change the set logically, but is not marked const since it's not safe to call this method //! concurrently. \see Erigon's RetainList::Retain bool contains(ByteView prefix); //! \brief Returns the next key with marker==true in the list //! \see Erigon's RetainList::RetainWithMarker //! \param [in] prefix : the prefix to search for //! \param [in] invariant_prefix_len : when searching for next marked the scanned items must begin with this number //! of identical bytes std::pair contains_and_next_marked(ByteView prefix, size_t invariant_prefix_len = 0); size_t size() const { return keys_.size(); } bool empty() const { return keys_.empty(); } void clear() noexcept { keys_.clear(); index_ = 0; sorted_ = false; } private: void ensure_sorted(); std::vector> keys_; // Collection of nibbled keys with marker of newly created size_t index_{0}; // Index of last compared key bool sorted_{false}; // Whether nibbled_keys_ has been unique-ed and sorted }; } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/prefix_set_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "prefix_set.hpp" #include #include #include namespace silkworm::trie { TEST_CASE("Prefix set - no prefix") { PrefixSet ps; REQUIRE(ps.empty()); CHECK(!ps.contains(string_view_to_byte_view(""))); CHECK(!ps.contains(string_view_to_byte_view("a"))); ps.insert(string_view_to_byte_view("abc")); ps.insert(string_view_to_byte_view("fg")); ps.insert(string_view_to_byte_view("abc")); // duplicate ps.insert(string_view_to_byte_view("abd"), true); // next marked as created ps.insert(string_view_to_byte_view("abc")); // duplicate ps.insert(string_view_to_byte_view("ab")); REQUIRE(ps.size() == 6); REQUIRE(!ps.empty()); CHECK(ps.contains(string_view_to_byte_view(""))); CHECK(ps.contains(string_view_to_byte_view("a"))); CHECK(!ps.contains(string_view_to_byte_view("aac"))); CHECK(ps.contains(string_view_to_byte_view("ab"))); CHECK(ps.contains(string_view_to_byte_view("abc"))); auto [contains, next_created]{ps.contains_and_next_marked(string_view_to_byte_view("abc"))}; CHECK(contains); CHECK(next_created == string_view_to_byte_view("abd")); CHECK(!ps.contains(string_view_to_byte_view("abcd"))); CHECK(!ps.contains(string_view_to_byte_view("b"))); CHECK(ps.contains(string_view_to_byte_view("f"))); CHECK(ps.contains(string_view_to_byte_view("fg"))); CHECK(!ps.contains(string_view_to_byte_view("fgk"))); CHECK(!ps.contains(string_view_to_byte_view("fy"))); CHECK(!ps.contains(string_view_to_byte_view("yyz"))); ps.clear(); REQUIRE(ps.empty()); } TEST_CASE("Prefix set - storage prefix") { Bytes prefix1{*from_hex("0x00000c28401f2ddfc4ffb8231a088e59b082343dcf32292deb61832480c3f4f50000000000000001")}; Bytes prefix2{*from_hex("0x00000c28401f2ddfc4ffb8231a088e59b082343dcf32292deb61832480c3f4f50000000000000002")}; PrefixSet ps; std::vector> keys{}; keys.emplace_back("ab", false); keys.emplace_back("abc", false); keys.emplace_back("abd", true); keys.emplace_back("abe", false); keys.emplace_back("abf", true); keys.emplace_back("fg", false); // Populate with first prefix for (const auto& item : keys) { Bytes prefixed{prefix1}; prefixed.append(string_view_to_byte_view(item.first)); ps.insert(prefixed, item.second); } // Populate with second prefix for (const auto& item : keys) { Bytes prefixed{prefix2}; prefixed.append(string_view_to_byte_view(item.first)); ps.insert(prefixed, item.second); } Bytes key1{prefix1}; key1.append(string_view_to_byte_view(keys[0].first)); { auto [contains, next_created]{ps.contains_and_next_marked(key1, prefix1.size())}; REQUIRE(contains); REQUIRE(!next_created.empty()); REQUIRE(std::memcmp(key1.data(), next_created.data(), 40) == 0); } key1.assign(prefix1).append(string_view_to_byte_view(keys.back().first)); { auto [contains, next_created]{ps.contains_and_next_marked(key1, prefix1.size())}; REQUIRE(contains); REQUIRE(next_created.empty()); } } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/vector_root.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::trie { // Lexicographic order for RLP-encoded integers is the same as their natural order, // save for 0, which, due to its RLP encoding, should be placed between 0x7f and 0x80. inline size_t adjust_index_for_rlp(size_t i, size_t len) { if (i > 0x7f) { return i; } if (i == 0x7f || i + 1 == len) { return 0; } return i + 1; } // Trie root hash of RLP-encoded values, the keys are RLP-encoded integers. // See Section 4.3.2. "Holistic Validity" of the Yellow Paper. template Encoder> evmc::bytes32 root_hash(const std::vector& v, const Encoder& value_encoder) { Bytes index_rlp; Bytes value_rlp; HashBuilder hb; for (size_t j{0}; j < v.size(); ++j) { const size_t index{adjust_index_for_rlp(j, v.size())}; index_rlp.clear(); rlp::encode(index_rlp, index); value_rlp.clear(); std::invoke(value_encoder, value_rlp, v[index]); hb.add_leaf(unpack_nibbles(index_rlp), value_rlp); } return hb.root_hash(); } } // namespace silkworm::trie ================================================ FILE: silkworm/core/trie/vector_root_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "vector_root.hpp" #include #include #include #include #include #include namespace silkworm::trie { TEST_CASE("Empty root hash") { static constexpr auto kEncoder = [](Bytes& to, const Transaction& txn) { rlp::encode(to, txn, /*wrap_eip2718_into_string=*/false); }; CHECK(root_hash(std::vector{}, kEncoder) == kEmptyRoot); } TEST_CASE("Hardcoded root hash") { std::vector receipts{ {TransactionType::kLegacy, true, 21'000, {}, {}}, {TransactionType::kLegacy, true, 42'000, {}, {}}, {TransactionType::kLegacy, true, 65'092, {}, {Log{0x8d12a197cb00d4747a1fe03395095ce2a5cc6819_address, {0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567_bytes32}, *from_hex("0x000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000043b2126e7a22e0c288dfb469e3de4d2c097f3ca0000000000000000000000000" "000000000000000000000001195387bce41fd4990000000000000000000000000000000000000" "000000000000000000000000000")}}}, }; for (auto& r : receipts) { r.bloom = logs_bloom(r.logs); } static constexpr auto kEncoder = [](Bytes& to, const Receipt& r) { rlp::encode(to, r); }; CHECK(to_hex(root_hash(receipts, kEncoder)) == "7ea023138ee7d80db04eeec9cf436dc35806b00cc5fe8e5f611fb7cf1b35b177"); } } // namespace silkworm::trie ================================================ FILE: silkworm/core/types/account.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "account.hpp" #include #include namespace silkworm { Bytes Account::rlp(const evmc::bytes32& storage_root) const { rlp::Header h{true, 0}; h.payload_length += rlp::length(nonce); h.payload_length += rlp::length(balance); h.payload_length += kHashLength + 1; h.payload_length += kHashLength + 1; Bytes to; rlp::encode_header(to, h); rlp::encode(to, nonce); rlp::encode(to, balance); rlp::encode(to, storage_root); rlp::encode(to, code_hash); return to; } std::string Account::to_string() const { const auto& account = *this; std::stringstream out; out << "nonce: " << account.nonce; out << " balance: " << "0x" << intx::hex(account.balance); out << " code_hash: 0x" << to_hex(account.code_hash); out << " incarnation: " << account.incarnation; return out.str(); } } // namespace silkworm ================================================ FILE: silkworm/core/types/account.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { // Default incarnation for smart contracts is 1; // contracts that were previously destructed and then re-created will have an incarnation greater than 1. // The incarnation of non-contracts (externally owned accounts) is always 0. inline constexpr uint64_t kDefaultIncarnation{1}; struct Account { uint64_t nonce{0}; intx::uint256 balance; evmc::bytes32 code_hash{kEmptyHash}; uint64_t incarnation{0}; uint64_t previous_incarnation{0}; //! \brief Serialize the account into its Recursive-Length Prefix (RLP) representation Bytes rlp(const evmc::bytes32& storage_root) const; friend bool operator==(const Account&, const Account&) = default; std::string to_string() const; }; } // namespace silkworm ================================================ FILE: silkworm/core/types/address.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "address.hpp" #include #include #include #include namespace silkworm { namespace rlp { void encode(Bytes& to, const evmc::address& address) { encode(to, ByteView{address.bytes}); } DecodingResult decode(ByteView& from, evmc::address& address, Leftover mode) { SILKWORM_ASSERT(from.size() >= std::size(address.bytes)); return decode(from, address.bytes, mode); } size_t length(const evmc::address& address) noexcept { return length(ByteView{address.bytes}); } } // namespace rlp evmc::address create_address(const evmc::address& caller, uint64_t nonce) noexcept { rlp::Header h{true, 1 + kAddressLength}; h.payload_length += rlp::length(nonce); Bytes rlp{}; rlp::encode_header(rlp, h); rlp::encode(rlp, caller); rlp::encode(rlp, nonce); ethash::hash256 hash{keccak256(rlp)}; evmc::address address{}; std::memcpy(address.bytes, hash.bytes + 12, kAddressLength); return address; } evmc::address create2_address(const evmc::address& caller, const evmc::bytes32& salt, uint8_t (&code_hash)[32]) noexcept { static constexpr size_t kN{1 + kAddressLength + 2 * kHashLength}; uint8_t buf[kN]; buf[0] = 0xff; std::memcpy(buf + 1, caller.bytes, kAddressLength); std::memcpy(buf + 1 + kAddressLength, salt.bytes, kHashLength); std::memcpy(buf + 1 + kAddressLength + kHashLength, code_hash, kHashLength); ethash::hash256 hash{ethash::keccak256(buf, kN)}; evmc::address address{}; std::memcpy(address.bytes, hash.bytes + 12, kAddressLength); return address; } evmc::address bytes_to_address(ByteView bytes) { evmc::address out; if (!bytes.empty()) { size_t n{std::min(bytes.size(), kAddressLength)}; std::memcpy(out.bytes + kAddressLength - n, bytes.data(), n); } return out; } evmc::address hex_to_address(std::string_view hex, bool return_zero_on_err) { const std::optional bytes{from_hex(hex)}; if (!bytes) { if (return_zero_on_err) { return evmc::address{}; } abort_due_to_assertion_failure("invalid hex encoding", __FILE__, __LINE__); } return bytes_to_address(*bytes); } std::string address_to_hex(const evmc::address& address) { return to_hex(ByteView{address.bytes}, true); } } // namespace silkworm namespace evmc { std::ostream& operator<<(std::ostream& out, const evmc::address& address) { return out << silkworm::address_to_hex(address); } } // namespace evmc ================================================ FILE: silkworm/core/types/address.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "silkworm/core/common/decoding_result.hpp" namespace silkworm { // Yellow Paper, Section 7 evmc::address create_address(const evmc::address& caller, uint64_t nonce) noexcept; // https://eips.ethereum.org/EIPS/eip-1014 evmc::address create2_address(const evmc::address& caller, const evmc::bytes32& salt, uint8_t (&code_hash)[32]) noexcept; // Converts bytes to evmc::address; input is cropped if necessary. // Short inputs are left-padded with 0s. evmc::address bytes_to_address(ByteView bytes); // Similar to HexToAddress in erigon-lib. // Terminates the program if hex is not a valid hex encoding, unless return_zero_on_err is true. evmc::address hex_to_address(std::string_view hex, bool return_zero_on_err = false); std::string address_to_hex(const evmc::address& address); namespace rlp { void encode(Bytes& to, const evmc::address& address); DecodingResult decode(ByteView& from, evmc::address& address, Leftover mode = Leftover::kProhibit); size_t length(const evmc::address& address) noexcept; } // namespace rlp } // namespace silkworm namespace evmc { std::ostream& operator<<(std::ostream& out, const evmc::address& address); } // namespace evmc ================================================ FILE: silkworm/core/types/address_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "address.hpp" #include namespace silkworm { using namespace evmc::literals; TEST_CASE("Create address") { CHECK(create_address(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, 0) == 0xc669eaad75042be84daaf9b461b0e868b9ac1871_address); } TEST_CASE("Create2 address") { auto init_code_hash{0x574cde0b89679c30a3c3b5c32c3dc25db6e980e912e399d5bbc887cdf3c85b1b_bytes32}; auto salt{0x000000000000000000000000000000000000000000000000000000000004bc00_bytes32}; CHECK(create2_address(0xfbe0afcd7658ba86be41922059dd879c192d4c73_address, salt, init_code_hash.bytes) == 0xd6eeefd603dcbedc00bebf93b4cacdfc8d8f241f_address); } } // namespace silkworm ================================================ FILE: silkworm/core/types/block.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include #include #include #include #include #include namespace silkworm { evmc::bytes32 BlockHeader::hash(bool for_sealing, bool exclude_extra_data_sig) const { Bytes rlp; rlp::encode(rlp, *this, for_sealing, exclude_extra_data_sig); return std::bit_cast(keccak256(rlp)); } ethash::hash256 BlockHeader::boundary() const { using intx::operator""_u256; static const intx::uint320 kDividend = intx::uint320{1} << 256; intx::uint256 result = (difficulty > 1u) ? intx::uint256{kDividend / difficulty} : 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff_u256; return intx::be::store(result); } // Approximates factor*e^(numerator/denominator) using Taylor expansion. // See https://eips.ethereum.org/EIPS/eip-4844#helpers static intx::uint256 fake_exponential(const intx::uint256& factor, const intx::uint256& numerator, const intx::uint256& denominator) { intx::uint256 output{0}; intx::uint256 numerator_accum{factor * denominator}; for (unsigned i{1}; numerator_accum > 0; ++i) { output += numerator_accum; numerator_accum = (numerator_accum * numerator) / (denominator * i); } return output / denominator; } intx::uint256 calc_blob_gas_price(uint64_t excess_blob_gas, evmc_revision revision) { // EIP-7691: Blob throughput increase const auto price_update_fraction = revision >= EVMC_PRAGUE ? protocol::kBlobGasPriceUpdateFractionPrague : protocol::kBlobGasPriceUpdateFraction; return fake_exponential( protocol::kMinBlobGasPrice, excess_blob_gas, price_update_fraction); } std::optional BlockHeader::blob_gas_price() const { if (!excess_blob_gas) { return std::nullopt; } const auto revision = requests_hash ? EVMC_PRAGUE : EVMC_CANCUN; return calc_blob_gas_price(*excess_blob_gas, revision); } namespace rlp { static Header rlp_header(const BlockHeader& header, bool for_sealing = false, bool exclude_extra_data_sig = false) { Header rlp_head{.list = true}; rlp_head.payload_length += kHashLength + 1; // parent_hash rlp_head.payload_length += kHashLength + 1; // ommers_hash rlp_head.payload_length += kAddressLength + 1; // beneficiary rlp_head.payload_length += kHashLength + 1; // state_root rlp_head.payload_length += kHashLength + 1; // transactions_root rlp_head.payload_length += kHashLength + 1; // receipts_root rlp_head.payload_length += kBloomByteLength + length_of_length(kBloomByteLength); // logs_bloom rlp_head.payload_length += length(header.difficulty); // difficulty rlp_head.payload_length += length(header.number); // block height rlp_head.payload_length += length(header.gas_limit); // gas_limit rlp_head.payload_length += length(header.gas_used); // gas_used rlp_head.payload_length += length(header.timestamp); // timestamp if (exclude_extra_data_sig) { const auto extra_data_no_signature = header.extra_data.substr(0, header.extra_data.size() - protocol::kExtraSealSize); rlp_head.payload_length += length(extra_data_no_signature); // extra_data -signature } else { rlp_head.payload_length += length(header.extra_data); // extra_data } if (!for_sealing) { rlp_head.payload_length += kHashLength + 1; // prev_randao rlp_head.payload_length += 8 + 1; // nonce } if (header.base_fee_per_gas) { rlp_head.payload_length += length(*header.base_fee_per_gas); } if (header.withdrawals_root) { rlp_head.payload_length += kHashLength + 1; } if (header.blob_gas_used) { rlp_head.payload_length += length(*header.blob_gas_used); } if (header.excess_blob_gas) { rlp_head.payload_length += length(*header.excess_blob_gas); } if (header.parent_beacon_block_root) { rlp_head.payload_length += kHashLength + 1; } if (header.requests_hash) { rlp_head.payload_length += kHashLength + 1; } return rlp_head; } size_t length(const BlockHeader& header) { const Header rlp_head{rlp_header(header)}; return length_of_length(rlp_head.payload_length) + rlp_head.payload_length; } void encode(Bytes& to, const BlockHeader& header, bool for_sealing, bool exclude_extra_data_sig) { encode_header(to, rlp_header(header, for_sealing, exclude_extra_data_sig)); encode(to, header.parent_hash); encode(to, header.ommers_hash); encode(to, header.beneficiary); encode(to, header.state_root); encode(to, header.transactions_root); encode(to, header.receipts_root); encode(to, header.logs_bloom); encode(to, header.difficulty); encode(to, header.number); encode(to, header.gas_limit); encode(to, header.gas_used); encode(to, header.timestamp); if (exclude_extra_data_sig) { SILKWORM_ASSERT(header.extra_data.size() >= protocol::kExtraSealSize); const ByteView extra_data_no_signature{header.extra_data.data(), header.extra_data.size() - protocol::kExtraSealSize}; encode(to, extra_data_no_signature); } else { encode(to, header.extra_data); } if (!for_sealing) { encode(to, header.prev_randao); encode(to, header.nonce); } if (header.base_fee_per_gas) { encode(to, *header.base_fee_per_gas); } if (header.withdrawals_root) { encode(to, *header.withdrawals_root); } if (header.blob_gas_used) { encode(to, *header.blob_gas_used); } if (header.excess_blob_gas) { encode(to, *header.excess_blob_gas); } if (header.parent_beacon_block_root) { encode(to, *header.parent_beacon_block_root); } if (header.requests_hash) { encode(to, *header.requests_hash); } } DecodingResult decode(ByteView& from, BlockHeader& to, Leftover mode) noexcept { const auto rlp_head{decode_header(from)}; if (!rlp_head) { return tl::unexpected{rlp_head.error()}; } if (!rlp_head->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } const uint64_t leftover{from.size() - rlp_head->payload_length}; if (mode != Leftover::kAllow && leftover) { return tl::unexpected{DecodingError::kInputTooLong}; } if (DecodingResult res{decode_items(from, to.parent_hash.bytes, to.ommers_hash.bytes, to.beneficiary.bytes, to.state_root.bytes, to.transactions_root.bytes, to.receipts_root.bytes, to.logs_bloom, to.difficulty, to.number, to.gas_limit, to.gas_used, to.timestamp, to.extra_data, to.prev_randao.bytes, to.nonce)}; !res) { return res; } if (from.size() > leftover) { to.base_fee_per_gas = 0; if (DecodingResult res{decode(from, *to.base_fee_per_gas, Leftover::kAllow)}; !res) { return res; } } else { to.base_fee_per_gas = std::nullopt; } if (from.size() > leftover) { to.withdrawals_root = evmc::bytes32{}; if (DecodingResult res{decode(from, *to.withdrawals_root, Leftover::kAllow)}; !res) { return res; } } else { to.withdrawals_root = std::nullopt; } if (from.size() > leftover) { to.blob_gas_used = 0; to.excess_blob_gas = 0; to.parent_beacon_block_root = evmc::bytes32{}; if (DecodingResult res{decode_items(from, *to.blob_gas_used, *to.excess_blob_gas, *to.parent_beacon_block_root)}; !res) { return res; } } else { to.blob_gas_used = std::nullopt; to.excess_blob_gas = std::nullopt; to.parent_beacon_block_root = std::nullopt; } if (from.size() > leftover) { to.requests_hash = evmc::bytes32{}; if (DecodingResult res{decode(from, *to.requests_hash, Leftover::kAllow)}; !res) { return res; } } else { to.requests_hash = std::nullopt; } if (from.size() != leftover) { return tl::unexpected{DecodingError::kUnexpectedListElements}; } return {}; } static Header rlp_header_body(const BlockBody& b) { Header rlp_head{.list = true}; rlp_head.payload_length += length(b.transactions); rlp_head.payload_length += length(b.ommers); if (b.withdrawals) { rlp_head.payload_length += length(*b.withdrawals); } return rlp_head; } size_t length(const BlockBody& block_body) { const Header rlp_head{rlp_header_body(block_body)}; return length_of_length(rlp_head.payload_length) + rlp_head.payload_length; } void encode(Bytes& to, const BlockBody& block_body) { encode_header(to, rlp_header_body(block_body)); encode(to, block_body.transactions); encode(to, block_body.ommers); if (block_body.withdrawals) { encode(to, *block_body.withdrawals); } } DecodingResult decode(ByteView& from, BlockBody& to, Leftover mode) noexcept { const auto rlp_head{decode_header(from)}; if (!rlp_head) { return tl::unexpected{rlp_head.error()}; } if (!rlp_head->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } const uint64_t leftover{from.size() - rlp_head->payload_length}; if (mode != Leftover::kAllow && leftover) { return tl::unexpected{DecodingError::kInputTooLong}; } if (DecodingResult res{decode_items(from, to.transactions, to.ommers)}; !res) { return res; } to.withdrawals = std::nullopt; if (from.size() > leftover) { std::vector withdrawals; if (DecodingResult res{decode(from, withdrawals, Leftover::kAllow)}; !res) { return res; } to.withdrawals = withdrawals; } if (from.size() != leftover) { return tl::unexpected{DecodingError::kUnexpectedListElements}; } return {}; } DecodingResult decode(ByteView& from, Block& to, Leftover mode) noexcept { const auto rlp_head{decode_header(from)}; if (!rlp_head) { return tl::unexpected{rlp_head.error()}; } if (!rlp_head->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } const uint64_t leftover{from.size() - rlp_head->payload_length}; if (mode != Leftover::kAllow && leftover) { return tl::unexpected{DecodingError::kInputTooLong}; } if (DecodingResult res{decode_items(from, to.header, to.transactions, to.ommers)}; !res) { return res; } to.withdrawals = std::nullopt; if (from.size() > leftover) { std::vector withdrawals; if (DecodingResult res{decode(from, withdrawals, Leftover::kAllow)}; !res) { return res; } to.withdrawals = withdrawals; } if (from.size() != leftover) { return tl::unexpected{DecodingError::kUnexpectedListElements}; } return {}; } static Header rlp_header(const Block& b) { Header rlp_head{rlp_header_body(b)}; rlp_head.payload_length += length(b.header); return rlp_head; } size_t length(const Block& block) { const Header rlp_head{rlp_header(block)}; return length_of_length(rlp_head.payload_length) + rlp_head.payload_length; } void encode(Bytes& to, const Block& block) { encode_header(to, rlp_header(block)); encode(to, block.header); encode(to, block.transactions); encode(to, block.ommers); if (block.withdrawals) { encode(to, *block.withdrawals); } } } // namespace rlp } // namespace silkworm ================================================ FILE: silkworm/core/types/block.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { using TotalDifficulty = intx::uint256; intx::uint256 calc_blob_gas_price(uint64_t excess_blob_gas, evmc_revision revision); struct BlockHeader { using NonceType = std::array; evmc::bytes32 parent_hash{}; evmc::bytes32 ommers_hash{}; evmc::address beneficiary{}; evmc::bytes32 state_root{}; evmc::bytes32 transactions_root{}; evmc::bytes32 receipts_root{}; Bloom logs_bloom{}; intx::uint256 difficulty{}; uint64_t number{0}; uint64_t gas_limit{0}; uint64_t gas_used{0}; uint64_t timestamp{0}; Bytes extra_data{}; evmc::bytes32 prev_randao{}; // mix hash (digest) prior to EIP-4399 NonceType nonce{}; // Added in London std::optional base_fee_per_gas{std::nullopt}; // EIP-1559 // Added in Shanghai std::optional withdrawals_root{std::nullopt}; // EIP-4895 // Added in Cancun std::optional blob_gas_used{std::nullopt}; // EIP-4844 std::optional excess_blob_gas{std::nullopt}; // EIP-4844 std::optional parent_beacon_block_root{std::nullopt}; // EIP-4788 // Added in Prague std::optional requests_hash{std::nullopt}; // EIP-7685 evmc::bytes32 hash(bool for_sealing = false, bool exclude_extra_data_sig = false) const; //! \brief Calculates header's boundary. This is described by Equation(50) by the Yellow Paper. //! \return A hash of 256 bits with big endian byte order ethash::hash256 boundary() const; //! \see https://eips.ethereum.org/EIPS/eip-4844#gas-accounting std::optional blob_gas_price() const; friend bool operator==(const BlockHeader&, const BlockHeader&) = default; }; struct BlockBody { std::vector transactions; std::vector ommers; std::optional> withdrawals{std::nullopt}; friend bool operator==(const BlockBody&, const BlockBody&) = default; }; struct Block : public BlockBody { BlockHeader header; BlockBody copy_body() const { return *this; // NOLINT(cppcoreguidelines-slicing) } }; struct BlockWithHash { Block block; evmc::bytes32 hash; }; namespace rlp { size_t length(const BlockHeader&); size_t length(const BlockBody&); size_t length(const Block&); void encode(Bytes& to, const BlockBody&); void encode(Bytes& to, const BlockHeader&, bool for_sealing = false, bool exclude_extra_data_sig = false); void encode(Bytes& to, const Block&); DecodingResult decode(ByteView& from, BlockBody& to, Leftover mode = Leftover::kProhibit) noexcept; DecodingResult decode(ByteView& from, BlockHeader& to, Leftover mode = Leftover::kProhibit) noexcept; DecodingResult decode(ByteView& from, Block& to, Leftover mode = Leftover::kProhibit) noexcept; } // namespace rlp } // namespace silkworm ================================================ FILE: silkworm/core/types/block_body_for_storage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include // keep below #include #include namespace silkworm { // See Erigon BodyForStorage struct BlockBodyForStorage { uint64_t base_txn_id{0}; uint64_t txn_count{0}; std::vector ommers; std::optional> withdrawals{std::nullopt}; // EIP-4895 Bytes encode() const; friend bool operator==(const BlockBodyForStorage&, const BlockBodyForStorage&) = default; }; DecodingResult decode_stored_block_body(ByteView& from, BlockBodyForStorage& to); tl::expected decode_stored_block_body(ByteView& from); inline Bytes BlockBodyForStorage::encode() const { rlp::Header header{.list = true, .payload_length = 0}; header.payload_length += rlp::length(base_txn_id); header.payload_length += rlp::length(txn_count); header.payload_length += rlp::length(ommers); if (withdrawals) { header.payload_length += rlp::length(*withdrawals); } Bytes to; rlp::encode_header(to, header); rlp::encode(to, base_txn_id); rlp::encode(to, txn_count); rlp::encode(to, ommers); if (withdrawals) { rlp::encode(to, *withdrawals); } return to; } inline DecodingResult decode_stored_block_body(ByteView& from, BlockBodyForStorage& to) { const auto header{rlp::decode_header(from)}; if (!header) { return tl::unexpected{header.error()}; } if (!header->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } const uint64_t leftover{from.size() - header->payload_length}; if (leftover) { return tl::unexpected{DecodingError::kInputTooLong}; } if (DecodingResult res{rlp::decode_items(from, to.base_txn_id, to.txn_count, to.ommers)}; !res) { return res; } to.withdrawals = std::nullopt; if (from.size() > leftover) { std::vector withdrawals; if (DecodingResult res{rlp::decode(from, withdrawals, rlp::Leftover::kAllow)}; !res) { return res; } to.withdrawals = withdrawals; } if (from.size() != leftover) { return tl::unexpected{DecodingError::kUnexpectedListElements}; } return {}; } inline tl::expected decode_stored_block_body(ByteView& from) { BlockBodyForStorage to; DecodingResult result = decode_stored_block_body(from, to); if (!result) return tl::unexpected{result.error()}; return to; } } // namespace silkworm ================================================ FILE: silkworm/core/types/block_body_for_storage_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block_body_for_storage.hpp" #include namespace silkworm { TEST_CASE("BlockBodyForStorage encoding") { BlockHeader header{ .parent_hash = 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32, .ommers_hash = 0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d_bytes32, .beneficiary = 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address, .state_root = 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d_bytes32, .transactions_root = 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e_bytes32, .receipts_root = 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f_bytes32, .difficulty = 1234, .number = 5, .gas_limit = 1000000, .gas_used = 1000000, .timestamp = 5405021, .extra_data = *from_hex("0001FF0100"), .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .nonce = {0, 0, 0, 0, 0, 0, 0, 255}, .base_fee_per_gas = 0x244428, }; // No withdrawals BlockBodyForStorage body{.base_txn_id = 15, .txn_count = 3, .ommers = {header}}; Bytes encoded{body.encode()}; ByteView view{encoded}; auto decoded = decode_stored_block_body(view); REQUIRE(decoded.has_value()); CHECK(*decoded == body); // With withdrawals body.ommers.clear(); // no uncles after The Merge body.withdrawals = {{ .index = 4, .validator_index = 1568, .address = 0x6295ee1b4f6dd65047762f924ecd367c17eabf8f_address, .amount = 786, }}; encoded = body.encode(); view = encoded; decoded = decode_stored_block_body(view); REQUIRE(decoded.has_value()); CHECK(*decoded == body); } } // namespace silkworm ================================================ FILE: silkworm/core/types/block_id.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { struct BlockId { BlockNum block_num{}; Hash hash; friend bool operator==(const BlockId&, const BlockId&) = default; }; } // namespace silkworm ================================================ FILE: silkworm/core/types/block_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include #include #include namespace silkworm { // Just for literals using namespace intx; TEST_CASE("BlockBody RLP") { // https://etherscan.io/block/3 const char* rlp_hex{ "f90219c0f90215f90212a0d4e56740f876aef8c010b86a40d5f56745a118d090" "6a34e69aec8c0db1cb8fa3a01dcc4de8dec75d7aab85b567b6ccd41ad312451b" "948a7413f0a142fd40d4934794c8ebccc5f5689fa8659d83713341e5ad193494" "48a01e6e030581fd1873b4784280859cd3b3c04aa85520f08c304cf5ee63d393" "5adda056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e3" "63b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5" "e363b421b9010000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "000000000000008503ff80000001821388808455ba42429a5961746573205261" "6e64616c6c202d2045746865724e696e6a61a0f8c94dfe61cf26dcdf8cffeda3" "37cf6a903d65c449d7691a022837f6e2d994598868b769c5451a7aea"}; Bytes rlp_bytes{*from_hex(rlp_hex)}; ByteView in{rlp_bytes}; BlockBody bb{}; REQUIRE(rlp::decode(in, bb)); CHECK(bb.transactions.empty()); REQUIRE(bb.ommers.size() == 1); CHECK(bb.ommers[0].number == 1); CHECK(bb.ommers[0].beneficiary == 0xc8ebccc5f5689fa8659d83713341e5ad19349448_address); CHECK(bb.ommers[0].difficulty == 17'171'480'576); Bytes out{}; rlp::encode(out, bb); CHECK(to_hex(out) == rlp_hex); } TEST_CASE("BlockBody RLP 2") { BlockBody body{}; body.transactions.resize(2); body.transactions[0].nonce = 172339; body.transactions[0].max_priority_fee_per_gas = 50 * kGiga; body.transactions[0].max_fee_per_gas = 50 * kGiga; body.transactions[0].gas_limit = 90'000; body.transactions[0].to = 0xe5ef458d37212a06e3f59d40c454e76150ae7c32_address; body.transactions[0].value = 1'027'501'080 * kGiga; body.transactions[0].data = {}; CHECK(body.transactions[0].set_v(27)); body.transactions[0].r = 0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353_u256; body.transactions[0].s = 0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804_u256; body.transactions[1].type = TransactionType::kDynamicFee; body.transactions[1].nonce = 1; body.transactions[1].max_priority_fee_per_gas = 5 * kGiga; body.transactions[1].max_fee_per_gas = 30 * kGiga; body.transactions[1].gas_limit = 1'000'000; body.transactions[1].to = {}; body.transactions[1].value = 0; body.transactions[1].data = *from_hex("602a6000556101c960015560068060166000396000f3600035600055"); CHECK(body.transactions[1].set_v(37)); body.transactions[1].r = 0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb_u256; body.transactions[1].s = 0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb_u256; body.ommers.resize(1); body.ommers[0].parent_hash = 0xb397a22bb95bf14753ec174f02f99df3f0bdf70d1851cdff813ebf745f5aeb55_bytes32; body.ommers[0].ommers_hash = kEmptyListHash; body.ommers[0].beneficiary = 0x0c729be7c39543c3d549282a40395299d987cec2_address; body.ommers[0].state_root = 0xc2bcdfd012534fa0b19ffba5fae6fc81edd390e9b7d5007d1e92e8e835286e9d_bytes32; body.ommers[0].transactions_root = kEmptyRoot; body.ommers[0].receipts_root = kEmptyRoot; body.ommers[0].difficulty = 12'555'442'155'599; body.ommers[0].number = 13'000'013; body.ommers[0].gas_limit = 3'141'592; body.ommers[0].gas_used = 0; body.ommers[0].timestamp = 1455404305; body.ommers[0].prev_randao = 0xf0a53dfdd6c2f2a661e718ef29092de60d81d45f84044bec7bf4b36630b2bc08_bytes32; body.ommers[0].nonce[7] = 35; Bytes rlp{}; rlp::encode(rlp, body); ByteView view{rlp}; BlockBody decoded{}; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == body); } TEST_CASE("Invalid Block RLP") { // Ethereum EL test RLP_InputList_TooManyElements_HEADER_DECODEINTO_BLOCK_EXTBLOCK_HEADER const char* rlp_hex{ "0xf90260f90207a068a61c4a05db4913009de5666753258eb9306157680dc5da0d93656550c9257ea01dcc4de8dec75d7aab85b567b6cc" "d41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ef1552a40b7165c3cd773806b9e0c1" "65b75356e0314bf0706f279c729f51e017a0b6c9fd1447d0b414a1f05957927746f58ef5a2ebde17db631d460eaf6a93b18da0bc37d797" "53ad738a6dac4921e57392f145d8887476de3f783dfa7edae9283e52b90100000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000008302000001832fefd8825208845509814280a00451dd53d9c09f3cfb627b51d9d80632ed801f6330ee584b" "ffc26caac9b9249f88c7bffe5ebd94cc2ff861f85f800a82c35094095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba098c3a099" "885a281885f487fd37550de16436e8c47874cd213531b10fe751617fa044b6b81011ce57bffcaf610bf728fb8a7237ad261ea2d937423d" "78eb9e137076c0"}; Bytes rlp_bytes{*from_hex(rlp_hex)}; ByteView view{rlp_bytes}; Block block; CHECK(!rlp::decode(view, block)); } TEST_CASE("EIP-2718 Block RLP") { const char* rlp_hex{ "f90319f90211a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd4" "1ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ef1552a40b7165c3cd773806b9e0c165" "b75356e0314bf0706f279c729f51e017a0e6e49996c7ec59f7a23d22b83239a60151512c65613bf84a0d7da336399ebc4aa0cafe75574d" "59780665a97fbfd11365c7545aa8f1abf4e5e12e8243334ef7286bb9010000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000083020000820200832fefd882a410845506eb0796636f6f6c65737420626c6f636b206f6e20636861696ea0bd" "4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff49888a13a5a8c8f2bb1c4f90101f85f800a82c35094095e7bae" "a6a6c7c4c2dfeb977efac326af552d870a801ba09bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094fa08a8f" "ae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b1b89e01f89b01800a8301e24194095e7baea6a6c7c4c2dfeb97" "7efac326af552d878080f838f7940000000000000000000000000000000000000001e1a000000000000000000000000000000000000000" "0000000000000000000000000001a03dbacc8d0259f2508625e97fdfc57cd85fdd16e5821bc2c10bdd1a52649e8335a0476e10695b183a" "87b0aa292a7f4b78ef0c3fbe62aa2c42c84e1d9c3da159ef14c0"}; Bytes rlp_bytes{*from_hex(rlp_hex)}; ByteView view{rlp_bytes}; Block block; REQUIRE(rlp::decode(view, block)); CHECK(view.empty()); REQUIRE(block.transactions.size() == 2); CHECK(block.transactions[0].type == TransactionType::kLegacy); CHECK(block.transactions[0].access_list.empty()); CHECK(block.transactions[1].type == TransactionType::kAccessList); CHECK(block.transactions[1].access_list.size() == 1); } TEST_CASE("EIP-1559 Header RLP") { BlockHeader h{ .number = 13'500'000, .base_fee_per_gas = 2'700'000'000, }; Bytes rlp; rlp::encode(rlp, h); ByteView view{rlp}; BlockHeader decoded; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == h); } TEST_CASE("Cancun Header RLP") { BlockHeader h{ .ommers_hash = kEmptyListHash, .number = 17'000'000, .prev_randao = 0xd01681d2b3acdebff0288a02a1648b3910500961982d5ecdbef064af7c34090b_bytes32, .base_fee_per_gas = 2'700'000'000, .withdrawals_root = 0xbac9348581b0ee244d6eb61076b63c4e4afa70430c804ab0e6a0ab69d9a9d323_bytes32, .blob_gas_used = 456, .excess_blob_gas = 789633, .parent_beacon_block_root = 0x22_bytes32, }; Bytes rlp; rlp::encode(rlp, h); ByteView view{rlp}; BlockHeader decoded; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == h); } TEST_CASE("Prague Header RLP") { BlockHeader h{ .ommers_hash = kEmptyListHash, .number = 17'000'000, .prev_randao = 0xd01681d2b3acdebff0288a02a1648b3910500961982d5ecdbef064af7c34090b_bytes32, .base_fee_per_gas = 2'700'000'000, .withdrawals_root = 0xbac9348581b0ee244d6eb61076b63c4e4afa70430c804ab0e6a0ab69d9a9d323_bytes32, .blob_gas_used = 456, .excess_blob_gas = 789633, .parent_beacon_block_root = 0x22_bytes32, .requests_hash = 0x33_bytes32, }; Bytes rlp; rlp::encode(rlp, h); ByteView view{rlp}; BlockHeader decoded; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == h); } TEST_CASE("Hash header boundary computation") { BlockHeader h; h.difficulty = 0x13009de5666753258eb9306157680dc5da0d_u256; CHECK(to_hex(h.boundary().bytes) == "00000000000000000000000000000000000d78d369778f29e54c2b9e37d107e1"); } TEST_CASE("Hash header boundary computation when we have difficulty with power of 2") { BlockHeader h; h.difficulty = 0x10000000000_u256; CHECK(to_hex(h.boundary().bytes) == "0000000001000000000000000000000000000000000000000000000000000000"); } TEST_CASE("Hash header boundary computation when the difficulty is equal to 0") { BlockHeader h; h.difficulty = 0; CHECK(to_hex(h.boundary().bytes) == "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); } TEST_CASE("Hash of blockHeader") { BlockHeader header{}; CHECK(0xc3bd2d00745c03048a5616146a96f5ff78e54efb9e5b04af208cdaff6f3830ee_bytes32 == header.hash()); } TEST_CASE("seal-Hash of blockHeader") { BlockHeader header{}; std::string extra_data_str = "d883010a0d846765746888676f312e31372e33856c696e7578000000000000002ab85c52944f7ced556a"; extra_data_str.append("389a8044be45c006fca6ab41adf927f05f8c66a5debd68218cc4cf4e578581ca7db3c77efd6bbdabf0d435c5cfa68b5e80aa0798fece01"); header.extra_data = *from_hex(extra_data_str); CHECK(0xa6bb746de2cafea987306daa79ebcaa2f2d68a8e7ce1967623b05cfc913c8995_bytes32 == header.hash(false, true)); } } // namespace silkworm ================================================ FILE: silkworm/core/types/bloom.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bloom.hpp" #include #include namespace silkworm { void m3_2048(Bloom& bloom, ByteView x) { ethash::hash256 hash{keccak256(x)}; for (unsigned i{0}; i < 6; i += 2) { unsigned bit{static_cast(hash.bytes[i + 1] + (hash.bytes[i] << 8)) & 0x7FFu}; bloom[kBloomByteLength - 1 - bit / 8] |= 1 << (bit % 8); } } Bloom logs_bloom(const std::vector& logs) { Bloom bloom{}; // zero initialization for (const Log& log : logs) { m3_2048(bloom, log.address.bytes); for (const auto& topic : log.topics) { m3_2048(bloom, topic.bytes); } } return bloom; } } // namespace silkworm ================================================ FILE: silkworm/core/types/bloom.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm { inline constexpr size_t kBloomByteLength{256}; using Bloom = std::array; //! See Section 4.3.1 "Transaction Receipt" of the Yellow Paper void m3_2048(Bloom& bloom, ByteView x); Bloom logs_bloom(const std::vector& logs); inline void join(Bloom& sum, const Bloom& addend) { for (size_t i{0}; i < kBloomByteLength; ++i) { sum[i] |= addend[i]; } } inline std::string_view to_string(const Bloom& bloom) { return {reinterpret_cast(bloom.data()), bloom.size()}; } } // namespace silkworm ================================================ FILE: silkworm/core/types/bloom_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bloom.hpp" #include #include namespace silkworm { using namespace evmc::literals; TEST_CASE("Hardcoded Bloom") { std::vector logs{ { 0x22341ae42d6dd7384bc8584e50419ea3ac75b83f_address, // address {0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}, // topics }, { 0xe7fb22dfef11920312e4989a3a2b81e2ebf05986_address, // address { 0x7f1fef85c4b037150d3675218e0cdb7cf38fea354759471e309f3354918a442f_bytes32, 0xd85629c7eaae9ea4a10234fed31bc0aeda29b2683ebe0c1882499d272621f6b6_bytes32, }, // topics *from_hex("0x2d690516512020171c1ec870f6ff45398cc8609250326be89915fb538e7b"), // data }, }; Bloom bloom{logs_bloom(logs)}; CHECK(to_hex(bloom) == "000000000000000000810000000000000000000000000000000000020000000000000000000000000000008000" "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000280000000000400000800000004000000000" "000000000000000000000000000000000000000000000000000000000000100000100000000000000000000000" "00000000001400000000000000008000000000000000000000000000000000"); } } // namespace silkworm ================================================ FILE: silkworm/core/types/call_traces.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { struct CallTraces { std::set senders; std::set recipients; }; } // namespace silkworm ================================================ FILE: silkworm/core/types/chain_head.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "block_id.hpp" #include "hash.hpp" namespace silkworm { struct ChainHead { BlockNum block_num{0}; Hash hash; intx::uint256 total_difficulty; friend bool operator==(const ChainHead&, const ChainHead&) = default; }; inline bool operator==(const ChainHead& a, const BlockId& b) { return a.block_num == b.block_num && a.hash == b.hash; } inline bool operator==(const BlockId& a, const ChainHead& b) { return a.block_num == b.block_num && a.hash == b.hash; } inline BlockId to_block_id(const ChainHead& head) { return {.block_num = head.block_num, .hash = head.hash}; } } // namespace silkworm ================================================ FILE: silkworm/core/types/eip_7685_requests.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "eip_7685_requests.hpp" #include #include #include #include #include namespace silkworm { Bytes extract_deposit(const Bytes& data) { const ByteView input{data}; Bytes result; // The format of deposit data is: (bytes, bytes, bytes, bytes, bytes) size_t offset_index = 0; for (size_t i = 0; i < 5; ++i) { SILKWORM_ASSERT(offset_index < input.size()); const ByteView offset_slice = input.substr(offset_index); SILKWORM_ASSERT(offset_slice.size() >= sizeof(intx::uint256)); const auto offset = static_cast(intx::be::unsafe::load(offset_slice.data())); SILKWORM_ASSERT(offset < input.size()); const ByteView size_slice = input.substr(offset); SILKWORM_ASSERT(size_slice.size() >= sizeof(intx::uint256)); const auto size = static_cast(intx::be::unsafe::load(size_slice.data())); if (size > 0) { SILKWORM_ASSERT(offset + 32 + size < input.size()); const auto bytes = input.substr(offset + 32, size); std::ranges::copy(bytes, std::back_inserter(result)); } offset_index += 32; } return result; } void FlatRequests::extract_deposits_from_logs(const std::vector& logs) { // See EIP-6110: Supply validator deposits on chain static constexpr evmc::bytes32 kDepositEventSignatureHash = 0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5_bytes32; for (const auto& log : logs) { const auto is_deposit_event = std::size(log.topics) > 0 && log.topics[0] == kDepositEventSignatureHash; if (log.address == protocol::kDepositContractAddress && is_deposit_event) { auto bytes = extract_deposit(log.data); requests_[magic_enum::enum_integer(FlatRequestType::kDepositRequest)] += bytes; } } } void FlatRequests::add_request(const FlatRequestType type, Bytes data) { auto& buffer = requests_[magic_enum::enum_integer(type)]; std::ranges::move(std::begin(data), std::end(data), std::back_inserter(buffer)); } ByteView FlatRequests::preview_data_by_type(FlatRequestType type) const { return {requests_[magic_enum::enum_integer(type)]}; } Hash FlatRequests::calculate_sha256() const { Bytes intermediate; for (const auto enum_type : magic_enum::enum_values()) { const auto request_type = magic_enum::enum_integer(enum_type); // Include intermediate hashes of non-empty requests only if (!std::empty(requests_[request_type])) { Bytes to_sha; to_sha.push_back(request_type); to_sha.append(requests_[request_type]); intermediate.append(precompile::sha256_run(ByteView{to_sha}).value()); } } const auto final_bytes = precompile::sha256_run(intermediate).value(); return Hash{final_bytes}; } } // namespace silkworm ================================================ FILE: silkworm/core/types/eip_7685_requests.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm { inline static size_t constexpr kBLSKeyLen = 48; inline static size_t constexpr kBLSSignatureLen = 96; using BLSKey = std::array; using BLSSignature = std::array; enum class FlatRequestType : uint8_t { kDepositRequest = 0, kWithdrawalRequest = 1, kConsolidationRequest = 2 }; struct FlatRequests { void extract_deposits_from_logs(const std::vector& logs); void add_request(FlatRequestType type, Bytes data); Hash calculate_sha256() const; ByteView preview_data_by_type(FlatRequestType type) const; private: static constexpr size_t kTypesCount = magic_enum::enum_count(); std::array requests_; }; } // namespace silkworm ================================================ FILE: silkworm/core/types/eip_7685_requests_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "eip_7685_requests.hpp" #include #include #include #include "silkworm/core/protocol/param.hpp" namespace silkworm { using namespace evmc::literals; TEST_CASE("EIP-7585 tests") { SECTION("Decode deposit receipt") { const auto encoded_event = from_hex( "00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000" "000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003054fcd2f87d667cba6cd5641c6ebe081fa0f2ccddac66b88a93f2b" "96110193dcfab55b4a7ef5678b18291f5f820b1a02b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010e476e5493f10afb1406727558873018d000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006002b8929776df9737d2cf6487deabf0f8ecaa1f1af05" "df8663ee539be24c2b806030eaf5a87a64a15ae45752b94f6d8b291051dcc373ed7776dcca66eb2bffe37ead57b580c0c99fbc4830167e2d8c093cf78c6ef76993c7ad39d9b12f8a583b40000000000000000000000000000000000000000000000000000000000000002014d00" "0000000000000000000000000000000000000000000000000000000000") .value(); // Topics is a single-element vector containing hash of deposit event signature const std::vector logs = {Log{.address = protocol::kDepositContractAddress, .topics = {0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5_bytes32}, .data = encoded_event}}; FlatRequests requests; requests.extract_deposits_from_logs(logs); const auto deposit_bytes = requests.preview_data_by_type(FlatRequestType::kDepositRequest); CHECK(deposit_bytes == from_hex("54fcd2f87d667cba6cd5641c6ebe081fa0f2ccddac66b88a93f2b96110193dcfab55b4a7ef5678b18291f5f820b1a02be476e5493f10afb1406727558873018d2002b8929776df9737d2cf6487deabf0f8ecaa1f1af05df8663ee539be24c2b806030eaf5a87a64a15ae45752b94f6d8" "b291051dcc373ed7776dcca66eb2bffe37ead57b580c0c99fbc4830167e2d8c093cf78c6ef76993c7ad39d9b12f8a583b4014d")); } SECTION("Calculate sha256 of requests") { FlatRequests requests; requests.add_request(FlatRequestType::kDepositRequest, from_hex("54fcd2f87d667cba6cd5641c6ebe081fa0f2ccddac66b88a93f2b96110193dcfab55b4a7ef5678b18291f5f820b1a02be476e5493f10afb1406727558873018d2002b8929776df9737d2cf6487deabf0f8ecaa1f1af05df8663ee539be24c2b8" "06030eaf5a87a64a15ae45752b94f6d8b291051dcc373ed7776dcca66eb2bffe37ead57b580c0c99fbc4830167e2d8c093cf78c6ef76993c7ad39d9b12f8a583b4014d") .value()); requests.add_request(FlatRequestType::kWithdrawalRequest, from_hex("54fcd2f87d667cba6cd5641c6ebe081fa0f2ccddac66b88a93f2b96110193dcfab55b4a7ef5678b18291f5f820b1a02be476e5493f10afb1406727558873018d2002b8929776df9737d2cf6487deab").value()); requests.add_request(FlatRequestType::kConsolidationRequest, from_hex("a0f2ccddac66b88a93f2b96110193dcfab55b4a7ef5678b18291f5f820b1a02be476e5493f10afb1406727558873018d2002b89").value()); const auto hash = requests.calculate_sha256(); CHECK(hash == Hash{from_hex("fb11d3d094091e34794c99218a862850a4a85dc1e128ce8c85f2a2bcbcc899ef").value()}); } SECTION("Calculate sha256 of empty requests") { FlatRequests requests; const auto hash = requests.calculate_sha256(); CHECK(hash == Hash{from_hex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855").value()}); } } } // namespace silkworm ================================================ FILE: silkworm/core/types/evmc_bytes32.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evmc_bytes32.hpp" #include #include #include #include namespace silkworm { evmc::bytes32 to_bytes32(ByteView bytes) { evmc::bytes32 out; if (!bytes.empty()) { size_t n{std::min(bytes.size(), kHashLength)}; std::memcpy(out.bytes + kHashLength - n, bytes.data(), n); } return out; } std::string to_hex(const evmc::bytes32& value, bool with_prefix) { return silkworm::to_hex(ByteView{value.bytes}, with_prefix); } } // namespace silkworm namespace silkworm::rlp { void encode(Bytes& to, const evmc::bytes32& value) { silkworm::rlp::encode(to, ByteView{value.bytes}); } size_t length(const evmc::bytes32& value) noexcept { return silkworm::rlp::length(ByteView{value.bytes}); } DecodingResult decode(ByteView& from, evmc::bytes32& to, Leftover mode) noexcept { return silkworm::rlp::decode(from, to.bytes, mode); } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/types/evmc_bytes32.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { // Converts bytes to evmc::bytes32; input is cropped if necessary. // Short inputs are left-padded with 0s. evmc::bytes32 to_bytes32(ByteView bytes); std::string to_hex(const evmc::bytes32& value, bool with_prefix = false); } // namespace silkworm namespace silkworm::rlp { void encode(Bytes& to, const evmc::bytes32& value); size_t length(const evmc::bytes32& value) noexcept; DecodingResult decode(ByteView& from, evmc::bytes32& to, Leftover mode = Leftover::kProhibit) noexcept; } // namespace silkworm::rlp namespace evmc { using silkworm::rlp::encode; using silkworm::rlp::length; } // namespace evmc ================================================ FILE: silkworm/core/types/hash.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm { class Hash : public evmc::bytes32 { public: using evmc::bytes32::bytes32; Hash() = default; explicit Hash(ByteView bv) { std::memcpy(bytes, bv.data(), size()); SILKWORM_ASSERT(bv.size() == size()); } static constexpr size_t size() { return sizeof(evmc::bytes32); } std::string to_hex() const { return silkworm::to_hex(*this); } static std::optional from_hex(const std::string& hex) { return evmc::from_hex(hex); } // conversion to ByteView // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) operator ByteView() const { return ByteView{bytes}; } static_assert(sizeof(evmc::bytes32) == 32); }; using HashAsSpan = std::span; using HashAsArray = const uint8_t (&)[kHashLength]; namespace rlp { inline DecodingResult decode(ByteView& from, Hash& to, Leftover mode = Leftover::kProhibit) { return decode(from, to.bytes, mode); } } // namespace rlp } // namespace silkworm namespace std { template <> struct hash : public std::hash // to use Hash with std::unordered_set/map {}; } // namespace std ================================================ FILE: silkworm/core/types/hash_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "hash.hpp" #include namespace silkworm { using namespace evmc::literals; TEST_CASE("from_hex") { CHECK(Hash::from_hex("foo") == std::nullopt); const evmc::bytes32 hash_value{0x2d690516512020171c1ec870f6ff45398cc8609250326be89915fb538e7b_bytes32}; CHECK(Hash::from_hex("0x2d690516512020171c1ec870f6ff45398cc8609250326be89915fb538e7b") == hash_value); } } // namespace silkworm ================================================ FILE: silkworm/core/types/log.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include namespace silkworm::rlp { static Header header(const Log& l) { Header h; h.list = true; h.payload_length = kAddressLength + 1; h.payload_length += length(l.topics); h.payload_length += length(l.data); return h; } size_t length(const Log& l) { Header h{header(l)}; return length_of_length(h.payload_length) + h.payload_length; } void encode(Bytes& to, const Log& l) { encode_header(to, header(l)); encode(to, l.address); encode(to, l.topics); encode(to, l.data); } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/types/log.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { struct Log { evmc::address address; std::vector topics; Bytes data; }; namespace rlp { size_t length(const Log&); void encode(Bytes& to, const Log&); } // namespace rlp } // namespace silkworm ================================================ FILE: silkworm/core/types/log_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include #include #include #include namespace silkworm { using namespace evmc::literals; TEST_CASE("Log RLP encoding") { Log sample_log1{ 0xea674fdde714fd979de3edf0f56aa9716b898ec8_address, {}, *from_hex("0x010043"), }; std::string_view expected_rlp1{"da94ea674fdde714fd979de3edf0f56aa9716b898ec8c083010043"}; SECTION("own encode method") { Bytes encoded; rlp::encode(encoded, sample_log1); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 CHECK((to_hex(encoded) == expected_rlp1)); } SECTION("variadic struct encode") { Bytes encoded; rlp::encode( encoded, sample_log1.address, sample_log1.topics, sample_log1.data); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 CHECK((to_hex(encoded) == expected_rlp1)); } } } // namespace silkworm ================================================ FILE: silkworm/core/types/receipt.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipt.hpp" #include #include namespace silkworm::rlp { static Header header(const Receipt& r) { Header h; h.list = true; h.payload_length = 1; h.payload_length += length(r.cumulative_gas_used); h.payload_length += length(r.bloom); h.payload_length += length(r.logs); return h; } void encode(Bytes& to, const Receipt& r) { if (r.type != TransactionType::kLegacy) { to.push_back(static_cast(r.type)); } encode_header(to, header(r)); encode(to, r.success); encode(to, r.cumulative_gas_used); encode(to, r.bloom); encode(to, r.logs); } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/types/receipt.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { struct Receipt { TransactionType type{TransactionType::kLegacy}; bool success{false}; uint64_t cumulative_gas_used{0}; Bloom bloom{}; std::vector logs; }; namespace rlp { void encode(Bytes& to, const Receipt&); } } // namespace silkworm ================================================ FILE: silkworm/core/types/transaction.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction.hpp" #include #include #include #include #include #include #include #include #include #include "silkworm/core/crypto/secp256k1n.hpp" #include "y_parity_and_chain_id.hpp" namespace silkworm { std::optional Authorization::recover_authority(const Transaction& txn) const { if (chain_id != 0 && chain_id != txn.chain_id) { return {}; } if (r >= kSecp256k1n || s >= kSecp256k1n) { return {}; } if (s > kSecp256k1Halfn) { return {}; } if (y_parity > 1) { return {}; } Bytes rlp{}; rlp::encode_for_signing(rlp, *this); ethash::hash256 hash{keccak256(rlp)}; uint8_t signature[kHashLength * 2 + 1]; intx::be::unsafe::store(signature, r); intx::be::unsafe::store(signature + kHashLength, s); intx::be::unsafe::store(signature + 2 * kHashLength, y_parity); std::optional recovered_authority = evmc::address{}; static secp256k1_context* context{secp256k1_context_create(SILKWORM_SECP256K1_CONTEXT_FLAGS)}; if (!silkworm_recover_address(recovered_authority->bytes, hash.bytes, signature, y_parity, context)) { recovered_authority = std::nullopt; } return recovered_authority; } intx::uint256 Authorization::v() const { return y_parity_and_chain_id_to_v(y_parity, chain_id); } // https://eips.ethereum.org/EIPS/eip-155 intx::uint256 Transaction::v() const { return y_parity_and_chain_id_to_v(odd_y_parity, chain_id); } // https://eips.ethereum.org/EIPS/eip-155 bool Transaction::set_v(const intx::uint256& v) { const std::optional parity_and_id{v_to_y_parity_and_chain_id(v)}; if (parity_and_id == std::nullopt) { return false; } odd_y_parity = parity_and_id->odd; chain_id = parity_and_id->chain_id; reset(); return true; } evmc::bytes32 Transaction::hash() const { hash_computed_.call_once([this]() { Bytes rlp; rlp::encode(rlp, *this, /*wrap_eip2718_into_string=*/false); cached_hash_ = std::bit_cast(keccak256(rlp)); }); return cached_hash_; } namespace rlp { static Header header(const AccessListEntry& e) { return {.list = true, .payload_length = kAddressLength + 1 + length(e.storage_keys)}; } size_t length(const AccessListEntry& e) { Header h{header(e)}; return length_of_length(h.payload_length) + h.payload_length; } void encode(Bytes& to, const AccessListEntry& e) { encode_header(to, header(e)); encode(to, e.account); encode(to, e.storage_keys); } static Header header(const Authorization& authorization) { Header header{.list = true}; header.payload_length = length(authorization.chain_id); header.payload_length += kAddressLength + 1; // address is kAddressLength and one byte for size prefix header.payload_length += length(authorization.nonce); header.payload_length += length(authorization.y_parity); header.payload_length += length(authorization.r); header.payload_length += length(authorization.s); return header; } size_t length(const Authorization& authorization) { Header h{header(authorization)}; return length_of_length(h.payload_length) + h.payload_length; } void encode(Bytes& to, const Authorization& authorization) { encode_header(to, header(authorization)); encode(to, authorization.chain_id); encode(to, authorization.address); encode(to, authorization.nonce); encode(to, authorization.y_parity); encode(to, authorization.r); encode(to, authorization.s); } void encode_for_signing(Bytes& to, const Authorization& authorization) { Header header{.list = true}; header.payload_length = length(authorization.chain_id); header.payload_length += kAddressLength + 1; // address is kAddressLength and one byte for size prefix header.payload_length += length(authorization.nonce); // See: Eip-7720 Set EOA account code constexpr unsigned char kMagic{0x05}; to.push_back(kMagic); encode_header(to, header); encode(to, authorization.chain_id); encode(to, authorization.address); encode(to, authorization.nonce); } DecodingResult decode(ByteView& from, AccessListEntry& to, Leftover mode) noexcept { return decode(from, mode, to.account.bytes, to.storage_keys); } DecodingResult decode(ByteView& from, Authorization& to, Leftover mode) noexcept { return decode(from, mode, to.chain_id, to.address.bytes, to.nonce, to.y_parity, to.r, to.s); } static Header header_base(const UnsignedTransaction& txn) { Header h{.list = true}; if (txn.type != TransactionType::kLegacy) { h.payload_length += length(txn.chain_id.value_or(0)); } h.payload_length += length(txn.nonce); if (txn.type == TransactionType::kDynamicFee || txn.type == TransactionType::kBlob || txn.type == TransactionType::kSetCode) { h.payload_length += length(txn.max_priority_fee_per_gas); } h.payload_length += length(txn.max_fee_per_gas); h.payload_length += length(txn.gas_limit); h.payload_length += txn.to ? (kAddressLength + 1) : 1; h.payload_length += length(txn.value); h.payload_length += length(txn.data); if (txn.type != TransactionType::kLegacy) { h.payload_length += length(txn.access_list); if (txn.type == TransactionType::kBlob) { h.payload_length += length(txn.max_fee_per_blob_gas); h.payload_length += length(txn.blob_versioned_hashes); } if (txn.type == TransactionType::kSetCode) { h.payload_length += length(txn.authorizations); } } return h; } static Header header(const UnsignedTransaction& txn) { Header h{header_base(txn)}; if (txn.type == TransactionType::kLegacy && txn.chain_id) { h.payload_length += length(*txn.chain_id) + 2; } return h; } static Header header(const Transaction& txn) { Header h{header_base(txn)}; if (txn.type != TransactionType::kLegacy) { h.payload_length += length(txn.odd_y_parity); } else { h.payload_length += length(txn.v()); } h.payload_length += length(txn.r); h.payload_length += length(txn.s); return h; } size_t length(const Transaction& txn, bool wrap_eip2718_into_string) { Header h{header(txn)}; size_t rlp_len{length_of_length(h.payload_length) + h.payload_length}; if (txn.type != TransactionType::kLegacy && wrap_eip2718_into_string) { return length_of_length(rlp_len + 1) + rlp_len + 1; } return rlp_len; } static void legacy_encode_base(Bytes& to, const UnsignedTransaction& txn) { encode(to, txn.nonce); encode(to, txn.max_fee_per_gas); encode(to, txn.gas_limit); if (txn.to) { encode(to, *txn.to); } else { to.push_back(kEmptyStringCode); } encode(to, txn.value); encode(to, txn.data); } static void eip2718_encode_for_signing(Bytes& to, const UnsignedTransaction& txn, const Header h, bool wrap_eip2718_into_string) { if (wrap_eip2718_into_string) { auto rlp_len{static_cast(length_of_length(h.payload_length) + h.payload_length)}; encode_header(to, {false, rlp_len + 1}); } to.push_back(static_cast(txn.type)); encode_header(to, h); encode(to, txn.chain_id.value_or(0)); encode(to, txn.nonce); if (txn.type != TransactionType::kAccessList) { encode(to, txn.max_priority_fee_per_gas); } encode(to, txn.max_fee_per_gas); encode(to, txn.gas_limit); if (txn.to) { encode(to, *txn.to); } else { to.push_back(kEmptyStringCode); } encode(to, txn.value); encode(to, txn.data); encode(to, txn.access_list); if (txn.type == TransactionType::kBlob) { encode(to, txn.max_fee_per_blob_gas); encode(to, txn.blob_versioned_hashes); } if (txn.type == TransactionType::kSetCode) { encode(to, txn.authorizations); } } void encode(Bytes& to, const Transaction& txn, bool wrap_eip2718_into_string) { if (txn.type == TransactionType::kLegacy) { encode_header(to, header(txn)); legacy_encode_base(to, txn); encode(to, txn.v()); encode(to, txn.r); encode(to, txn.s); } else { eip2718_encode_for_signing(to, txn, header(txn), wrap_eip2718_into_string); encode(to, txn.odd_y_parity); encode(to, txn.r); encode(to, txn.s); } } static DecodingResult legacy_decode_items(ByteView& from, Transaction& to) noexcept { if (DecodingResult res{decode_items(from, to.nonce, to.max_priority_fee_per_gas)}; !res) { return res; } to.max_fee_per_gas = to.max_priority_fee_per_gas; if (DecodingResult res{decode(from, to.gas_limit, Leftover::kAllow)}; !res) { return res; } if (from[0] == kEmptyStringCode) { to.to = std::nullopt; from.remove_prefix(1); } else { to.to = evmc::address{}; if (DecodingResult res{decode(from, to.to->bytes, Leftover::kAllow)}; !res) { return res; } } intx::uint256 v; if (DecodingResult res{decode_items(from, to.value, to.data, v)}; !res) { return res; } if (!to.set_v(v)) { return tl::unexpected{DecodingError::kInvalidVInSignature}; } return decode_items(from, to.r, to.s); } static DecodingResult eip2718_decode(ByteView& from, Transaction& to) noexcept { if (to.type != TransactionType::kAccessList && to.type != TransactionType::kDynamicFee && to.type != TransactionType::kBlob && to.type != TransactionType::kSetCode) { return tl::unexpected{DecodingError::kUnsupportedTransactionType}; } const auto h{decode_header(from)}; if (!h) { return tl::unexpected{h.error()}; } if (!h->list) { return tl::unexpected{DecodingError::kUnexpectedString}; } intx::uint256 chain_id; if (DecodingResult res{decode(from, chain_id, Leftover::kAllow)}; !res) { return res; } to.chain_id = chain_id; if (DecodingResult res{decode_items(from, to.nonce, to.max_priority_fee_per_gas)}; !res) { return res; } if (to.type == TransactionType::kAccessList) { to.max_fee_per_gas = to.max_priority_fee_per_gas; } else if (DecodingResult res{decode(from, to.max_fee_per_gas, Leftover::kAllow)}; !res) { return res; } if (DecodingResult res{decode(from, to.gas_limit, Leftover::kAllow)}; !res) { return res; } if (from[0] == kEmptyStringCode) { to.to = std::nullopt; from.remove_prefix(1); } else { to.to = evmc::address{}; if (DecodingResult res{decode(from, to.to->bytes, Leftover::kAllow)}; !res) { return res; } } if (DecodingResult res{decode_items(from, to.value, to.data, to.access_list)}; !res) { return res; } if (to.type != TransactionType::kBlob) { to.max_fee_per_blob_gas = 0; to.blob_versioned_hashes.clear(); } else if (DecodingResult res{decode_items(from, to.max_fee_per_blob_gas, to.blob_versioned_hashes)}; !res) { return res; } if (to.type == TransactionType::kSetCode) { if (DecodingResult res{decode(from, to.authorizations, Leftover::kAllow)}; !res) { return res; } } return decode_items(from, to.odd_y_parity, to.r, to.s); } DecodingResult decode_transaction(ByteView& from, Transaction& to, Eip2718Wrapping accepted_typed_txn_wrapping, Leftover mode) noexcept { to.reset(); if (from.empty()) { return tl::unexpected{DecodingError::kInputTooShort}; } if (0 < from[0] && from[0] < kEmptyStringCode) { // Raw serialization of a typed transaction if (accepted_typed_txn_wrapping == Eip2718Wrapping::kString) { return tl::unexpected{DecodingError::kUnexpectedEip2718Serialization}; } to.type = static_cast(from[0]); from.remove_prefix(1); return eip2718_decode(from, to); } const auto h{decode_header(from)}; if (!h) { return tl::unexpected{h.error()}; } if (h->list) { // Legacy transaction to.type = TransactionType::kLegacy; to.access_list.clear(); to.max_fee_per_blob_gas = 0; to.blob_versioned_hashes.clear(); const uint64_t leftover{from.size() - h->payload_length}; if (mode != Leftover::kAllow && leftover) { return tl::unexpected{DecodingError::kInputTooLong}; } if (DecodingResult res{legacy_decode_items(from, to)}; !res) { return res; } if (from.size() != leftover) { return tl::unexpected{DecodingError::kUnexpectedListElements}; } return {}; } // String-wrapped typed transaction if (accepted_typed_txn_wrapping == Eip2718Wrapping::kNone) { return tl::unexpected{DecodingError::kUnexpectedEip2718Serialization}; } if (h->payload_length == 0) { return tl::unexpected{DecodingError::kInputTooShort}; } to.type = static_cast(from[0]); from.remove_prefix(1); ByteView eip2718_view{from.substr(0, h->payload_length - 1)}; if (DecodingResult res{eip2718_decode(eip2718_view, to)}; !res) { return res; } if (!eip2718_view.empty()) { return tl::unexpected{DecodingError::kUnexpectedListElements}; } from.remove_prefix(h->payload_length - 1); if (mode != Leftover::kAllow && !from.empty()) { return tl::unexpected{DecodingError::kInputTooLong}; } return {}; } DecodingResult decode_transaction_header_and_type(ByteView& from, Header& header, TransactionType& type) noexcept { if (from.empty()) { return tl::unexpected{DecodingError::kInputTooShort}; } const auto header_res{decode_header(from)}; if (!header_res) { return tl::unexpected{header_res.error()}; } header = *header_res; if (header.list) { // Legacy transaction type = TransactionType::kLegacy; return {}; } // String-wrapped typed transaction if (header.payload_length == 0) { return tl::unexpected{DecodingError::kInputTooShort}; } type = static_cast(from[0]); from.remove_prefix(1); return {}; } } // namespace rlp void UnsignedTransaction::encode_for_signing(Bytes& into) const { if (type == TransactionType::kLegacy) { rlp::encode_header(into, rlp::header(*this)); rlp::legacy_encode_base(into, *this); if (chain_id) { rlp::encode(into, *chain_id); rlp::encode(into, 0u); rlp::encode(into, 0u); } } else { rlp::eip2718_encode_for_signing(into, *this, rlp::header(*this), /*wrap_eip2718_into_string=*/false); } } std::optional Transaction::sender() const { sender_recovered_.call_once([this]() { Bytes rlp{}; encode_for_signing(rlp); ethash::hash256 hash{keccak256(rlp)}; uint8_t signature[kHashLength * 2]; intx::be::unsafe::store(signature, r); intx::be::unsafe::store(signature + kHashLength, s); sender_ = evmc::address{}; static secp256k1_context* context{secp256k1_context_create(SILKWORM_SECP256K1_CONTEXT_FLAGS)}; if (!silkworm_recover_address(sender_->bytes, hash.bytes, signature, odd_y_parity, context)) { sender_ = std::nullopt; } }); return sender_; } void Transaction::set_sender(const evmc::address& sender) { sender_recovered_.reset(); sender_recovered_.call_once([&]() { sender_ = sender; }); } void Transaction::reset() { sender_recovered_.reset(); hash_computed_.reset(); } intx::uint512 UnsignedTransaction::maximum_gas_cost() const { // See https://github.com/ethereum/EIPs/pull/3594 intx::uint512 max_gas_cost{intx::umul(intx::uint256{gas_limit}, max_fee_per_gas)}; // and https://eips.ethereum.org/EIPS/eip-4844#gas-accounting max_gas_cost += intx::umul(intx::uint256{total_blob_gas()}, max_fee_per_blob_gas); return max_gas_cost; } intx::uint256 UnsignedTransaction::priority_fee_per_gas(const intx::uint256& base_fee_per_gas) const { SILKWORM_ASSERT(max_fee_per_gas >= base_fee_per_gas); return std::min(max_priority_fee_per_gas, max_fee_per_gas - base_fee_per_gas); } intx::uint256 UnsignedTransaction::effective_gas_price(const intx::uint256& base_fee_per_gas) const { if (type == TransactionType::kSystem) { return 0; } return priority_fee_per_gas(base_fee_per_gas) + base_fee_per_gas; } uint64_t UnsignedTransaction::total_blob_gas() const { return protocol::kGasPerBlob * blob_versioned_hashes.size(); } } // namespace silkworm ================================================ FILE: silkworm/core/types/transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm { // EIP-2930: Optional access lists struct AccessListEntry { evmc::address account{}; std::vector storage_keys{}; friend bool operator==(const AccessListEntry&, const AccessListEntry&) = default; }; class Transaction; // EIP-7702 Authorization struct Authorization { intx::uint256 chain_id; evmc::address address; uint64_t nonce{}; uint8_t y_parity{}; intx::uint256 r; intx::uint256 s; friend bool operator==(const Authorization&, const Authorization&) = default; std::optional recover_authority(const Transaction& txn) const; intx::uint256 v() const; }; namespace eip7702 { // EIP-7702 Set EOA account code constexpr uint8_t kDelegationBytes[] = {0xef, 0x01, 0x00}; constexpr ByteView kDelegationPrefix{kDelegationBytes, std::size(kDelegationBytes)}; constexpr bool is_code_delegated(ByteView code) noexcept { return code.starts_with(kDelegationPrefix); } } // namespace eip7702 // EIP-2718 transaction type // https://github.com/ethereum/eth1.0-specs/tree/master/lists/signature-types enum class TransactionType : uint8_t { kLegacy = 0, kAccessList = 1, // EIP-2930 kDynamicFee = 2, // EIP-1559 kBlob = 3, // EIP-4844 kSetCode = 4, // EIP-7702 // System transactions are used for internal protocol operations like storing parent beacon root (EIP-4788). // They do not pay the base fee. kSystem = 0xff, }; struct UnsignedTransaction { TransactionType type{TransactionType::kLegacy}; std::optional chain_id{std::nullopt}; // nullopt means a pre-EIP-155 transaction uint64_t nonce{0}; intx::uint256 max_priority_fee_per_gas{0}; // EIP-1559 intx::uint256 max_fee_per_gas{0}; uint64_t gas_limit{0}; std::optional to{std::nullopt}; intx::uint256 value{0}; Bytes data{}; std::vector access_list{}; // EIP-2930 // EIP-4844: Shard Blob Transactions intx::uint256 max_fee_per_blob_gas{0}; std::vector blob_versioned_hashes{}; // EIP-7702 std::vector authorizations; //! \brief Maximum possible cost of normal and data (EIP-4844) gas intx::uint512 maximum_gas_cost() const; intx::uint256 priority_fee_per_gas(const intx::uint256& base_fee_per_gas) const; // EIP-1559 intx::uint256 effective_gas_price(const intx::uint256& base_fee_per_gas) const; // EIP-1559 uint64_t total_blob_gas() const; // EIP-4844 void encode_for_signing(Bytes& into) const; friend bool operator==(const UnsignedTransaction&, const UnsignedTransaction&) = default; }; class Transaction : public UnsignedTransaction { public: bool odd_y_parity{false}; intx::uint256 r{0}, s{0}; // signature intx::uint256 v() const; // EIP-155 //! \brief Returns false if v is not acceptable (v != 27 && v != 28 && v < 35, see EIP-155) bool set_v(const intx::uint256& v); //! \brief Sender recovered from the signature. //! \see Yellow Paper, Appendix F "Signing Transactions", //! EIP-2: Homestead Hard-fork Changes and //! EIP-155: Simple replay attack protection. //! If recovery fails std::nullopt is returned. std::optional sender() const; void set_sender(const evmc::address& sender); evmc::bytes32 hash() const; //! Reset the computed values void reset(); private: mutable std::optional sender_{std::nullopt}; mutable ResettableOnceFlag sender_recovered_; // cached value for hash if already computed mutable evmc::bytes32 cached_hash_; mutable ResettableOnceFlag hash_computed_; }; namespace rlp { void encode(Bytes& to, const AccessListEntry&); size_t length(const AccessListEntry&); void encode(Bytes& to, const Authorization&); size_t length(const Authorization&); void encode_for_signing(Bytes& to, const Authorization&); // According to EIP-2718, serialized transactions are prepended with 1 byte containing the type // (0x02 for EIP-1559 transactions); the same goes for receipts. This is true for signing and // transaction root calculation. However, in block body RLP serialized EIP-2718 transactions // are additionally wrapped into an RLP byte array (=string). (Refer to the geth implementation; // EIP-2718 is mute on block RLP.) void encode(Bytes& to, const Transaction& txn, bool wrap_eip2718_into_string = true); size_t length(const Transaction&, bool wrap_eip2718_into_string = true); DecodingResult decode(ByteView& from, AccessListEntry& to, Leftover mode = Leftover::kProhibit) noexcept; enum class Eip2718Wrapping { kNone, // Serialized typed transactions must start with its type byte, e.g. 0x02 kString, // Serialized typed transactions must be additionally wrapped into an RLP string (=byte array) kBoth, // Both options above are accepted }; DecodingResult decode_transaction(ByteView& from, Transaction& to, Eip2718Wrapping accepted_typed_txn_wrapping, Leftover mode = Leftover::kProhibit) noexcept; inline DecodingResult decode(ByteView& from, Transaction& to, Leftover mode = Leftover::kProhibit) noexcept { return decode_transaction(from, to, Eip2718Wrapping::kString, mode); } DecodingResult decode_transaction_header_and_type(ByteView& from, Header& header, TransactionType& type) noexcept; } // namespace rlp } // namespace silkworm ================================================ FILE: silkworm/core/types/transaction_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction.hpp" #include #include #include namespace silkworm { using namespace evmc::literals; static const std::vector kAccessList{ {0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae_address, { 0x0000000000000000000000000000000000000000000000000000000000000003_bytes32, 0x0000000000000000000000000000000000000000000000000000000000000007_bytes32, }}, {0xbb9bc244d798123fde783fcc1c72d3bb8c189413_address, {}}, }; TEST_CASE("Legacy Transaction RLP") { Transaction txn{}; txn.type = TransactionType::kLegacy; txn.chain_id = 1; txn.nonce = 12; txn.max_priority_fee_per_gas = 20000000000; txn.max_fee_per_gas = 20000000000; txn.gas_limit = 21000; txn.to = 0x727fc6a68321b754475c668a6abfb6e9e71c169a_address; txn.value = 10 * kEther; txn.data = *from_hex( "a9059cbb000000000213ed0f886efd100b67c7e4ec0a85a7d20dc9716000000000000000000" "00015af1d78b58c4000"); txn.odd_y_parity = true; txn.r = intx::from_string("0xbe67e0a07db67da8d446f76add590e54b6e92cb6b8f9835aeb67540579a27717"); txn.s = intx::from_string("0x2d690516512020171c1ec870f6ff45398cc8609250326be89915fb538e7bd718"); Bytes encoded{}; rlp::encode(encoded, txn); Transaction decoded; ByteView view{encoded}; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == txn); // Check that non-legacy fields (access_list, max_fee_per_blob_gas, blob_versioned_hashes) and from are cleared decoded.max_priority_fee_per_gas = 17; decoded.max_fee_per_gas = 31; decoded.access_list = kAccessList; decoded.max_fee_per_blob_gas = 123; decoded.blob_versioned_hashes.emplace_back(0xefc552d1df2a6a8e2643912171d040e4de0db43cd53b728c3e4d26952f710be8_bytes32); decoded.set_sender(0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address); view = encoded; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == txn); CHECK_FALSE(decoded.sender()); } TEST_CASE("EIP-2930 Transaction RLP") { Transaction txn{}; txn.type = TransactionType::kAccessList; txn.chain_id = kSepoliaConfig.chain_id; txn.nonce = 7; txn.max_priority_fee_per_gas = 30000000000; txn.max_fee_per_gas = 30000000000; txn.gas_limit = 5748100; txn.to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address; txn.value = 2 * kEther; txn.data = *from_hex("6ebaf477f83e051589c1188bcc6ddccd"); txn.access_list = kAccessList; txn.odd_y_parity = false; txn.r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"); txn.s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4094"); // Raw serialization Bytes encoded_raw; rlp::encode(encoded_raw, txn, /*wrap_eip2718_into_string=*/false); Transaction decoded; ByteView view{encoded_raw}; REQUIRE(rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kNone)); CHECK(view.empty()); CHECK(decoded == txn); view = encoded_raw; CHECK(rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kString) == tl::unexpected{DecodingError::kUnexpectedEip2718Serialization}); view = encoded_raw; REQUIRE(rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kBoth)); CHECK(view.empty()); CHECK(decoded == txn); // Wrap into an RLP string Bytes encoded_wrapped; rlp::encode(encoded_wrapped, txn, /*wrap_eip2718_into_string=*/true); view = encoded_wrapped; CHECK(rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kNone) == tl::unexpected{DecodingError::kUnexpectedEip2718Serialization}); view = encoded_wrapped; REQUIRE(rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kString)); CHECK(view.empty()); CHECK(decoded == txn); view = encoded_wrapped; REQUIRE(rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kBoth)); CHECK(view.empty()); CHECK(decoded == txn); // Check that post-EIP-2930 fields (max_fee_per_blob_gas, blob_versioned_hashes) and from are cleared decoded.max_priority_fee_per_gas = 17; decoded.max_fee_per_gas = 31; decoded.max_fee_per_blob_gas = 123; decoded.blob_versioned_hashes.emplace_back(0xefc552d1df2a6a8e2643912171d040e4de0db43cd53b728c3e4d26952f710be8_bytes32); decoded.set_sender(0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address); view = encoded_wrapped; REQUIRE(rlp::decode(view, decoded)); CHECK(decoded == txn); CHECK(!decoded.sender()); } TEST_CASE("EIP-1559 Transaction RLP") { Transaction txn{}; txn.type = TransactionType::kDynamicFee; txn.chain_id = kSepoliaConfig.chain_id; txn.nonce = 7; txn.max_priority_fee_per_gas = 10000000000; txn.max_fee_per_gas = 30000000000; txn.gas_limit = 5748100; txn.to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address; txn.value = 2 * kEther; txn.data = *from_hex("6ebaf477f83e051589c1188bcc6ddccd"); txn.access_list = kAccessList; txn.odd_y_parity = false; txn.r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"); txn.s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4094"); Bytes encoded{}; rlp::encode(encoded, txn); Transaction decoded; ByteView view{encoded}; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == txn); } TEST_CASE("EIP-4844 Transaction RLP") { Transaction txn{}; txn.type = TransactionType::kBlob; txn.chain_id = kSepoliaConfig.chain_id; txn.nonce = 7; txn.max_priority_fee_per_gas = 10000000000; txn.max_fee_per_gas = 30000000000; txn.gas_limit = 5748100; txn.to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address; txn.data = *from_hex("04f7"); txn.access_list = kAccessList; txn.max_fee_per_blob_gas = 123; txn.blob_versioned_hashes = { 0xc6bdd1de713471bd6cfa62dd8b5a5b42969ed09e26212d3377f3f8426d8ec210_bytes32, 0x8aaeccaf3873d07cef005aca28c39f8a9f8bdb1ec8d79ffc25afc0a4fa2ab736_bytes32, }; txn.odd_y_parity = true; txn.r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"); txn.s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4094"); Bytes encoded{}; rlp::encode(encoded, txn); Transaction decoded; ByteView view{encoded}; REQUIRE(rlp::decode(view, decoded)); CHECK(view.empty()); CHECK(decoded == txn); } TEST_CASE("Recover sender 1") { // https://etherscan.io/tx/0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060 // Block 46147 Transaction txn{}; txn.type = TransactionType::kLegacy; txn.nonce = 0; txn.max_priority_fee_per_gas = 50'000 * kGiga; txn.max_fee_per_gas = 50'000 * kGiga; txn.gas_limit = 21'000; txn.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn.value = 31337; txn.odd_y_parity = true; txn.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); CHECK(txn.sender() == 0xa1e4380a3b1f749673e270229993ee55f35663b4_address); CHECK(txn.hash() == 0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060_bytes32); } TEST_CASE("Recover sender 2") { // https://etherscan.io/tx/0xe17d4d0c4596ea7d5166ad5da600a6fdc49e26e0680135a2f7300eedfd0d8314 // Block 46214 Transaction txn{}; txn.type = TransactionType::kLegacy; txn.nonce = 1; txn.max_priority_fee_per_gas = 50'000 * kGiga; txn.max_fee_per_gas = 50'000 * kGiga; txn.gas_limit = 21'750; txn.to = 0xc9d4035f4a9226d50f79b73aafb5d874a1b6537e_address; txn.value = 31337; txn.data = *from_hex("0x74796d3474406469676978"); txn.odd_y_parity = true; txn.r = intx::from_string("0x1c48defe76d367bb92b4fc0628aca42a4d8037062865635d955673e57eddfbfa"); txn.s = intx::from_string("0x65f766849f97b15f01d0877636fbed0fa4e39f8834896c0354f56ac44dcb50a6"); CHECK(txn.sender() == 0xa1e4380a3b1f749673e270229993ee55f35663b4_address); CHECK(txn.hash() == 0xe17d4d0c4596ea7d5166ad5da600a6fdc49e26e0680135a2f7300eedfd0d8314_bytes32); } TEST_CASE("SetCodeTx parsing with authorizations") { const auto encoded_rlp = *from_hex( "b8ba04f8b70101843b9aca00847735940082520894deadbeefdeadbeefdeadbeefdeadbeefdeadbeef880de0b6b3a76400008a64756d6d7920636f6465c0f879db0194000000000000000000000000000000000000000101806f81dede01940000000000000000000000000000000000000002020182014d8201bcde01940000000000000000000000000000000000000003038082022b82029ade019400000000000000000000000000000000000000040401820309820378808080"); Transaction decoded; ByteView view{encoded_rlp}; const auto status = rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kBoth, rlp::Leftover::kProhibit); REQUIRE(status); CHECK(decoded.type == TransactionType::kSetCode); CHECK(4 == std::size(decoded.authorizations)); CHECK(decoded.authorizations[0].address == 0x0000000000000000000000000000000000000001_address); CHECK(decoded.authorizations[0].nonce == 1); CHECK(decoded.authorizations[0].y_parity == 0); CHECK(decoded.authorizations[1].address == 0x0000000000000000000000000000000000000002_address); CHECK(decoded.authorizations[1].nonce == 2); CHECK(decoded.authorizations[1].y_parity == 1); CHECK(decoded.authorizations[2].address == 0x0000000000000000000000000000000000000003_address); CHECK(decoded.authorizations[2].nonce == 3); CHECK(decoded.authorizations[2].y_parity == 0); CHECK(decoded.authorizations[3].address == 0x0000000000000000000000000000000000000004_address); CHECK(decoded.authorizations[3].nonce == 4); CHECK(decoded.authorizations[3].y_parity == 1); } TEST_CASE("SetCodeTx encoding and decoding") { Transaction txn{}; txn.type = TransactionType::kSetCode; txn.chain_id = kSepoliaConfig.chain_id; txn.nonce = 7; txn.max_priority_fee_per_gas = 30000000000; txn.max_fee_per_gas = 30000000000; txn.gas_limit = 5748100; txn.to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address; txn.value = 2 * kEther; txn.data = *from_hex("6ebaf477f83e051589c1188bcc6ddccd"); txn.odd_y_parity = false; txn.r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"); txn.s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4094"); txn.authorizations.emplace_back(Authorization{ .chain_id = 4, .address = 0x811a752c8cd697e3cb27279c330ed1ada745a8e7_address, .nonce = 10, .y_parity = 26, .r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"), .s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4055"), }); txn.authorizations.emplace_back(Authorization{ .chain_id = 24, .address = 0x9999752c8cd697e3cb27279c330ed1ada745a8e7_address, .nonce = 1999, .y_parity = 22, .r = intx::from_string("0x444241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"), .s = intx::from_string("0x555cc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4055"), }); Bytes encoded{}; rlp::encode(encoded, txn); Transaction decoded; ByteView view{encoded}; auto status = rlp::decode_transaction(view, decoded, rlp::Eip2718Wrapping::kBoth, rlp::Leftover::kProhibit); REQUIRE(status); CHECK(view.empty()); CHECK(decoded == txn); } TEST_CASE("SetCodeTx authorization recover signer") { Authorization authorization{ .chain_id = 7088110746, .address = 0xb47d9c634d50f1600d4df767e9474c25a0303428_address, .nonce = 1, .y_parity = 1, .r = intx::uint256(uint64_t{11238962557009670571U}, uint64_t{14017651393191758745U}, uint64_t{18358999445216475025U}, uint64_t{5549385460848219779U}), .s = intx::uint256(uint64_t{6390522493159340108U}, uint64_t{17630603794136184458U}, uint64_t{14442462445950880280U}, uint64_t{846710983706847255U})}; Transaction txn; txn.chain_id = authorization.chain_id; const auto recovered_authority = authorization.recover_authority(txn); CHECK(recovered_authority.value() == 0x8ED5ABe9DE62dB2F266b06b86203f71e4C1e357f_address); } } // namespace silkworm ================================================ FILE: silkworm/core/types/withdrawal.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "withdrawal.hpp" #include #include #include namespace silkworm::rlp { static Header header(const Withdrawal& w) { Header h{.list = true}; h.payload_length += length(w.index); h.payload_length += length(w.validator_index); h.payload_length += length(w.address); h.payload_length += length(w.amount); return h; } size_t length(const Withdrawal& w) { const Header rlp_head{header(w)}; return length_of_length(rlp_head.payload_length) + rlp_head.payload_length; } void encode(Bytes& to, const Withdrawal& w) { encode_header(to, header(w)); encode(to, w.index); encode(to, w.validator_index); encode(to, w.address); encode(to, w.amount); } DecodingResult decode(ByteView& from, Withdrawal& to, Leftover mode) noexcept { return decode(from, mode, to.index, to.validator_index, to.address.bytes, to.amount); } } // namespace silkworm::rlp ================================================ FILE: silkworm/core/types/withdrawal.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { struct Withdrawal { uint64_t index{0}; uint64_t validator_index{0}; evmc::address address{}; uint64_t amount{0}; // in GWei friend bool operator==(const Withdrawal&, const Withdrawal&) = default; }; namespace rlp { size_t length(const Withdrawal&); void encode(Bytes& to, const Withdrawal&); DecodingResult decode(ByteView& from, Withdrawal& to, Leftover mode = Leftover::kProhibit) noexcept; } // namespace rlp } // namespace silkworm ================================================ FILE: silkworm/core/types/withdrawal_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "withdrawal.hpp" #include #include #include #include namespace silkworm { using namespace evmc::literals; TEST_CASE("Withdrawals hash") { std::vector withdrawals{ { .index = 0, .validator_index = 0, .address = 0x6295ee1b4f6dd65047762f924ecd367c17eabf8f_address, .amount = 1, }}; static constexpr auto kEncoder = [](Bytes& to, const Withdrawal& w) { rlp::encode(to, w); }; CHECK(to_hex(trie::root_hash(withdrawals, kEncoder)) == "82cc6fbe74c41496b382fcdf25216c5af7bdbb5a3929e8f2e61bd6445ab66436"); } } // namespace silkworm ================================================ FILE: silkworm/core/types/y_parity_and_chain_id.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "y_parity_and_chain_id.hpp" namespace silkworm { intx::uint256 y_parity_and_chain_id_to_v(bool odd, const std::optional& chain_id) noexcept { if (chain_id.has_value()) { return chain_id.value() * 2 + 35 + odd; } return odd ? 28 : 27; } std::optional v_to_y_parity_and_chain_id(const intx::uint256& v) noexcept { YParityAndChainId res{}; if (v == 27 || v == 28) { // pre EIP-155 res.odd = v == 28; res.chain_id = std::nullopt; } else if (v < 35) { // EIP-155 implies v >= 35 return std::nullopt; } else { // https://eips.ethereum.org/EIPS/eip-155 // Find chain_id and y_parity ∈ {0, 1} such that // v = chain_id * 2 + 35 + y_parity intx::uint256 w{v - 35}; res.odd = static_cast(w) % 2; res.chain_id.emplace(w >> 1); // w / 2 } return res; } } // namespace silkworm ================================================ FILE: silkworm/core/types/y_parity_and_chain_id.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // See Yellow Paper, Appendix F "Signing Transactions" // and EIP-155: Simple replay attack protection. #include #include namespace silkworm { struct YParityAndChainId { bool odd{false}; std::optional chain_id{std::nullopt}; // EIP-155 }; //! \brief Calculates Y parity from signature's V. //! \param [in] v : signature V //! \return Y parity and eventually chain Id //! \remarks chain_id is always returned unless v ∈ {27, 28} //! \see https://eips.ethereum.org/EIPS/eip-155. std::optional v_to_y_parity_and_chain_id(const intx::uint256& v) noexcept; //! \see https://eips.ethereum.org/EIPS/eip-155 intx::uint256 y_parity_and_chain_id_to_v(bool odd, const std::optional& chain_id) noexcept; } // namespace silkworm ================================================ FILE: silkworm/core/types/y_parity_and_chain_id_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "y_parity_and_chain_id.hpp" #include namespace silkworm { TEST_CASE("EIP-155 v to y parity & chain id ") { CHECK(v_to_y_parity_and_chain_id(0) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(1) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(25) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(26) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(27)->odd == false); CHECK(v_to_y_parity_and_chain_id(27)->chain_id == std::nullopt); CHECK(v_to_y_parity_and_chain_id(28)->odd == true); CHECK(v_to_y_parity_and_chain_id(28)->chain_id == std::nullopt); CHECK(v_to_y_parity_and_chain_id(29) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(30) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(31) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(32) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(33) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(34) == std::nullopt); CHECK(v_to_y_parity_and_chain_id(35)->odd == false); CHECK(v_to_y_parity_and_chain_id(35)->chain_id == 0); CHECK(v_to_y_parity_and_chain_id(36)->odd == true); CHECK(v_to_y_parity_and_chain_id(36)->chain_id == 0); CHECK(v_to_y_parity_and_chain_id(37)->odd == false); CHECK(v_to_y_parity_and_chain_id(37)->chain_id == 1); CHECK(v_to_y_parity_and_chain_id(38)->odd == true); CHECK(v_to_y_parity_and_chain_id(38)->chain_id == 1); CHECK(y_parity_and_chain_id_to_v(false, std::nullopt) == 27); CHECK(y_parity_and_chain_id_to_v(true, std::nullopt) == 28); CHECK(y_parity_and_chain_id_to_v(false, 1) == 37); CHECK(y_parity_and_chain_id_to_v(true, 1) == 38); } } // namespace silkworm ================================================ FILE: silkworm/db/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") add_subdirectory(datastore) find_package(absl REQUIRED) find_package(Boost REQUIRED COMPONENTS headers) find_package(gRPC REQUIRED) find_package(magic_enum REQUIRED) find_package(Microsoft.GSL REQUIRED) find_package(nlohmann_json REQUIRED) find_package(Protobuf REQUIRED) set(LIBS_PUBLIC absl::btree absl::flat_hash_map absl::flat_hash_set absl::strings silkworm_core silkworm_infra silkworm_datastore ) set(LIBS_PRIVATE cborcpp magic_enum::magic_enum Microsoft.GSL::GSL nlohmann_json::nlohmann_json asio-grpc::asio-grpc Boost::headers gRPC::grpc++ protobuf::libprotobuf silkworm_datastore_etl ) silkworm_library( silkworm_db PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) # silkworm_db_cli depends on silkworm_db add_subdirectory(cli) # silkworm_db_test_util depends on silkworm_db add_subdirectory(test_util) target_link_libraries(silkworm_db_test PRIVATE silkworm_db_test_util silkworm_infra_test_util) ================================================ FILE: silkworm/db/access_layer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "access_layer.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::db { using namespace silkworm::datastore::kvdb; using namespace snapshots; using datastore::kvdb::to_slice; std::optional read_schema_version(ROTxn& txn) { auto cursor = txn.ro_cursor(table::kDatabaseInfo); if (!cursor->seek(mdbx::slice{kDbSchemaVersionKey})) { return std::nullopt; } auto data = cursor->current(); SILKWORM_ASSERT(data.value.length() == 12); const auto major = endian::load_big_u32(static_cast(data.value.data())); data.value.remove_prefix(sizeof(uint32_t)); const auto minor = endian::load_big_u32(static_cast(data.value.data())); data.value.remove_prefix(sizeof(uint32_t)); const auto patch = endian::load_big_u32(static_cast(data.value.data())); return VersionBase{major, minor, patch}; } void write_schema_version(RWTxn& txn, const VersionBase& schema_version) { auto old_schema_version{read_schema_version(txn)}; if (old_schema_version.has_value()) { if (schema_version == old_schema_version.value()) { // Simply return. No changes return; } if (schema_version < old_schema_version.value()) { throw std::runtime_error("Cannot downgrade schema version"); } } Bytes value(12, '\0'); endian::store_big_u32(&value[0], schema_version.major); endian::store_big_u32(&value[4], schema_version.minor); endian::store_big_u32(&value[8], schema_version.patch); PooledCursor src(txn, table::kDatabaseInfo); src.upsert(mdbx::slice{kDbSchemaVersionKey}, to_slice(value)); } void write_build_info_block_num(RWTxn& txn, const Bytes& key, BlockNum block_num) { auto cursor = txn.rw_cursor(table::kDatabaseInfo); Bytes value{block_key(block_num)}; cursor->upsert(to_slice(key), to_slice(value)); } std::optional read_header(ROTxn& txn, BlockNum block_num, const evmc::bytes32& hash) { return read_header(txn, block_num, hash.bytes); } std::optional read_header(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength]) { auto key{block_key(block_num, hash)}; return read_header(txn, key); } std::optional read_header(ROTxn& txn, ByteView key) { auto raw_header{read_header_raw(txn, key)}; if (raw_header.empty()) { return std::nullopt; } BlockHeader header; ByteView encoded_header{raw_header.data(), raw_header.size()}; success_or_throw(rlp::decode(encoded_header, header)); return header; } Bytes read_header_raw(ROTxn& txn, ByteView key) { auto cursor = txn.ro_cursor(table::kHeaders); auto data{cursor->find(to_slice(key), false)}; if (!data) { return {}; } return Bytes{from_slice(data.value)}; } std::optional read_header(ROTxn& txn, const evmc::bytes32& hash) { auto block_num = read_block_num(txn, hash); if (!block_num) { return std::nullopt; } return read_header(txn, *block_num, hash.bytes); } bool read_header(ROTxn& txn, const evmc::bytes32& hash, BlockNum block_num, BlockHeader& header) { const Bytes key{block_key(block_num, hash.bytes)}; const auto raw_header{read_header_raw(txn, key)}; if (raw_header.empty()) { return false; } ByteView raw_header_view(raw_header); success_or_throw(rlp::decode(raw_header_view, header)); return true; } std::vector read_headers(ROTxn& txn, BlockNum block_num) { std::vector headers; read_headers(txn, block_num, [&](BlockHeader header) { headers.emplace_back(std::move(header)); }); return headers; } size_t read_headers(ROTxn& txn, BlockNum block_num, std::function process_func) { auto headers_cursor = txn.ro_cursor(table::kHeaders); auto key_prefix{block_key(block_num)}; auto count = cursor_for_prefix( *headers_cursor, key_prefix, [&process_func]([[maybe_unused]] ByteView key, ByteView raw_header) { if (raw_header.empty()) throw std::logic_error("empty header in table Headers"); BlockHeader header; ByteView encoded_header{raw_header.data(), raw_header.size()}; success_or_throw(rlp::decode(encoded_header, header)); process_func(std::move(header)); }, CursorMoveDirection::kForward); return count; } void write_header(RWTxn& txn, const BlockHeader& header, bool with_header_numbers) { write_header_ex(txn, header, with_header_numbers); } evmc::bytes32 write_header_ex(RWTxn& txn, const BlockHeader& header, bool with_header_numbers) { Bytes value{}; rlp::encode(value, header); auto header_hash = std::bit_cast(keccak256(value)); // avoid header.hash() because it re-does rlp encoding auto key{block_key(header.number, header_hash.bytes)}; auto skey = to_slice(key); auto svalue = to_slice(value); auto target = txn.rw_cursor(table::kHeaders); target->upsert(skey, svalue); if (with_header_numbers) { write_header_number(txn, header_hash.bytes, header.number); } return header_hash; } void delete_header(RWTxn& txn, BlockNum block_num, const evmc::bytes32& hash) { auto cursor = txn.rw_cursor(table::kHeaders); auto key = block_key(block_num, hash.bytes); cursor->erase(to_slice(key)); } std::optional read_stored_header_number_after(ROTxn& txn, BlockNum min_block_num) { auto cursor = txn.ro_cursor(table::kHeaders); auto key = block_key(min_block_num); auto result = cursor->lower_bound(to_slice(key), /*throw_notfound=*/false); if (!result) { return std::nullopt; } return block_num_from_key(result.key); } std::optional read_canonical_header(ROTxn& txn, BlockNum block_num) { // also known as read-header-by-number std::optional h = read_canonical_header_hash(txn, block_num); if (!h) { return std::nullopt; // not found } return read_header(txn, block_num, h->bytes); } static Bytes header_numbers_key(evmc::bytes32 hash) { return {hash.bytes, 32}; } std::optional read_block_num(ROTxn& txn, const evmc::bytes32& hash) { auto header_number_cursor = txn.ro_cursor(table::kHeaderNumbers); auto key = header_numbers_key(hash); auto data = header_number_cursor->find(to_slice(key), /*throw_notfound=*/false); if (!data) { return std::nullopt; } if (data.value.length() != sizeof(BlockNum)) { throw std::length_error("Bad block number size " + std::to_string(data.value.length()) + " in db"); } auto block_num = endian::load_big_u64(static_cast(data.value.data())); return block_num; } void write_header_number(RWTxn& txn, const uint8_t (&hash)[kHashLength], const BlockNum block_num) { auto target = txn.rw_cursor(table::kHeaderNumbers); auto value{block_key(block_num)}; target->upsert({hash, kHashLength}, to_slice(value)); } void delete_header_number(RWTxn& txn, const evmc::bytes32& hash) { auto cursor = txn.rw_cursor(table::kHeaderNumbers); auto key = header_numbers_key(hash); cursor->erase(to_slice(key)); } std::optional read_total_difficulty(ROTxn& txn, BlockNum block_num, const evmc::bytes32& hash) { return read_total_difficulty(txn, block_num, hash.bytes); } std::optional read_total_difficulty( ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength]) { auto key{block_key(block_num, hash)}; return read_total_difficulty(txn, key); } std::optional read_total_difficulty(ROTxn& txn, ByteView key) { auto cursor = txn.ro_cursor(table::kDifficulty); auto data{cursor->find(to_slice(key), /*throw_notfound=*/false)}; if (!data) { return std::nullopt; } intx::uint256 td{0}; ByteView data_view{from_slice(data.value)}; success_or_throw(rlp::decode(data_view, td)); return td; } void write_total_difficulty(RWTxn& txn, const Bytes& key, const intx::uint256& total_difficulty) { SILKWORM_ASSERT(key.size() == sizeof(BlockNum) + kHashLength); Bytes value{}; rlp::encode(value, total_difficulty); auto target = txn.rw_cursor(table::kDifficulty); target->upsert(to_slice(key), to_slice(value)); } void write_total_difficulty( RWTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength], const intx::uint256& total_difficulty) { auto key{block_key(block_num, hash)}; write_total_difficulty(txn, key, total_difficulty); } void write_total_difficulty( RWTxn& txn, BlockNum block_num, const evmc::bytes32& hash, const intx::uint256& total_difficulty) { auto key{block_key(block_num, hash.bytes)}; write_total_difficulty(txn, key, total_difficulty); } std::tuple read_canonical_head(ROTxn& txn) { auto cursor = txn.ro_cursor(table::kCanonicalHashes); auto data = cursor->to_last(); if (!data) return {}; if (data.key.length() != sizeof(BlockNum)) { throw std::length_error("Bad block number size " + std::to_string(data.key.length()) + " in db"); } if (data.value.length() != kHashLength) { throw std::length_error("Bad block hash size " + std::to_string(data.value.length()) + " in db"); } evmc::bytes32 hash{}; std::memcpy(hash.bytes, data.value.data(), kHashLength); BlockNum block_num = endian::load_big_u64(static_cast(data.key.data())); return {block_num, hash}; } std::optional read_canonical_header_hash(ROTxn& txn, BlockNum block_num) { auto cursor = txn.ro_cursor(table::kCanonicalHashes); auto key{block_key(block_num)}; auto data{cursor->find(to_slice(key), /*throw_notfound=*/false)}; if (!data) { return std::nullopt; } if (data.value.length() != kHashLength) { throw std::length_error("Bad block hash size " + std::to_string(data.value.length()) + " in db"); } evmc::bytes32 ret{}; std::memcpy(ret.bytes, data.value.data(), kHashLength); return ret; } void write_canonical_header(RWTxn& txn, const BlockHeader& header) { write_canonical_header_hash(txn, header.hash().bytes, header.number); } void write_canonical_header_hash(RWTxn& txn, const uint8_t (&hash)[kHashLength], BlockNum block_num) { auto cursor = txn.rw_cursor(table::kCanonicalHashes); auto key{block_key(block_num)}; cursor->upsert(to_slice(key), to_slice(hash)); } void read_transactions(ROTxn& txn, uint64_t base_id, uint64_t count, std::vector& out) { if (count == 0) { out.clear(); return; } auto cursor = txn.ro_cursor(table::kBlockTransactions); read_transactions(*cursor, base_id, count, out); } void write_transactions(RWTxn& txn, const std::vector& transactions, uint64_t base_id) { if (transactions.empty()) { return; } auto cursor = txn.rw_cursor(table::kBlockTransactions); auto key{block_key(base_id)}; for (const auto& transaction : transactions) { Bytes value{}; rlp::encode(value, transaction); mdbx::slice value_slice{value.data(), value.size()}; cursor->put(to_slice(key), &value_slice, MDBX_APPEND); ++base_id; endian::store_big_u64(key.data(), base_id); } } void read_transactions(ROCursor& txn_table, uint64_t base_id, uint64_t count, std::vector& out) { out.resize(count); if (count == 0) { return; } auto key{block_key(base_id)}; uint64_t i{0}; for (auto data = txn_table.find(to_slice(key), /*throw_notfound=*/false); data.done && i < count; data = txn_table.to_next(/*throw_notfound=*/false), ++i) { ByteView data_view{from_slice(data.value)}; success_or_throw(rlp::decode(data_view, out.at(i))); } SILKWORM_ASSERT(i == count); } static void read_rlp_transactions(ROTxn& txn, uint64_t base_id, uint64_t count, std::vector& rlp_txs) { rlp_txs.resize(count); if (count == 0) { return; } const auto key{block_key(base_id)}; auto cursor = txn.ro_cursor(table::kBlockTransactions); uint64_t i{0}; for (auto data = cursor->find(to_slice(key), /*throw_notfound=*/false); data.done && i < count; data = cursor->to_next(/*throw_notfound=*/false), ++i) { rlp_txs[i] = from_slice(data.value); } SILKWORM_ASSERT(i == count); } void delete_transactions(RWTxn& txn, uint64_t base_id, uint64_t count) { auto cursor = txn.rw_cursor(table::kBlockTransactions); auto first_key = block_key(base_id); auto result = cursor->find(to_slice(first_key), /*throw_notfound=*/false); for (uint64_t i = 0; result && (i < count); result = cursor->to_next(/*throw_notfound=*/false), ++i) { cursor->erase(); } } bool read_block_by_number(ROTxn& txn, BlockNum block_num, bool read_senders, Block& block) { auto canonical_hashes_cursor = txn.ro_cursor(table::kCanonicalHashes); const Bytes key{block_key(block_num)}; const auto data{canonical_hashes_cursor->find(to_slice(key), /*throw_notfound=*/false)}; if (!data) { return false; } if (data.value.length() != kHashLength) { throw std::length_error("Bad block hash size " + std::to_string(data.value.length()) + " in db"); } const auto hash_ptr{static_cast(data.value.data())}; return read_block(txn, std::span{hash_ptr, kHashLength}, block_num, read_senders, block); } bool read_block(ROTxn& txn, const evmc::bytes32& hash, BlockNum block_num, Block& block) { // Read header read_header(txn, hash, block_num, block.header); // Read body return read_body(txn, hash, block_num, block); // read_senders == false } bool read_block( ROTxn& txn, std::span hash, BlockNum block_num, bool read_senders, Block& block) { // Read header const Bytes key{block_key(block_num, hash)}; const auto raw_header{read_header_raw(txn, key)}; if (raw_header.empty()) { return false; } ByteView raw_header_view(raw_header); success_or_throw(rlp::decode(raw_header_view, block.header)); return read_body(txn, key, read_senders, block); } size_t read_blocks(ROTxn& txn, BlockNum block_num, std::function process_func, bool read_senders) { auto bodies_cursor = txn.ro_cursor(table::kBlockBodies); auto key_prefix{block_key(block_num)}; auto count = cursor_for_prefix( *bodies_cursor, key_prefix, [&process_func, &txn, &block_num, &read_senders](ByteView key, ByteView raw_body) { if (raw_body.empty()) throw std::logic_error("empty header in table Headers"); // read block... Block block; // ...ommers auto body = unwrap_or_throw(decode_stored_block_body(raw_body)); std::swap(block.ommers, body.ommers); // ...transactions ensure(body.txn_count > 1, [&]() { return "unexpected txn_count=" + std::to_string(body.txn_count) + " for block_num=" + std::to_string(block_num); }); read_transactions(txn, body.base_txn_id + 1, body.txn_count - 2, block.transactions); // ...senders if (!block.transactions.empty() && read_senders) { Bytes key_bytes{key.data(), key.size()}; // TODO(canepat) avoid unnecessary copy by changing read_senders API parse_senders(txn, key_bytes, block.transactions); } // ...header auto [ref_block_num, hash] = split_block_key(key); const bool present = read_header(txn, hash, ref_block_num, block.header); auto ref_hash = hash; ensure(present, [&]() { return "header not found for body block_num= " + std::to_string(ref_block_num) + ", hash= " + silkworm::to_hex(ref_hash); }); // invoke handler process_func(block); }, CursorMoveDirection::kForward); return count; } bool read_body(ROTxn& txn, const evmc::bytes32& h, BlockNum block_num, BlockBody& body) { return read_body(txn, block_num, h.bytes, /*read_senders=*/false, body); } bool read_body(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength], bool read_senders, BlockBody& out) { auto key{block_key(block_num, hash)}; return read_body(txn, key, read_senders, out); } std::optional read_body_for_storage(ROTxn& txn, const Bytes& key) { auto cursor = txn.ro_cursor(table::kBlockBodies); auto data{cursor->find(to_slice(key), false)}; if (!data) { return std::nullopt; } ByteView data_view{from_slice(data.value)}; auto body{unwrap_or_throw(decode_stored_block_body(data_view))}; return body; } std::optional read_raw_body_for_storage(ROTxn& txn, const Bytes& key) { auto cursor = txn.ro_cursor(table::kBlockBodies); auto data{cursor->find(to_slice(key), false)}; if (!data) { return std::nullopt; } return Bytes{from_slice(data.value)}; } bool read_body(ROTxn& txn, const Bytes& key, bool read_senders, BlockBody& out) { auto body_opt = read_body_for_storage(txn, key); if (!body_opt) { return false; } BlockBodyForStorage& body = *body_opt; std::swap(out.ommers, body.ommers); std::swap(out.withdrawals, body.withdrawals); ensure(body.txn_count > 1, [&]() { return "unexpected txn_count=" + std::to_string(body.txn_count) + " for key=" + to_hex(key); }); read_transactions(txn, body.base_txn_id + 1, body.txn_count - 2, out.transactions); if (!out.transactions.empty() && read_senders) { parse_senders(txn, key, out.transactions); } return true; } bool read_rlp_transactions(ROTxn& txn, BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) { const auto key{block_key(block_num, hash.bytes)}; auto body_opt = read_body_for_storage(txn, key); if (!body_opt) return false; auto& body = *body_opt; ensure(body.txn_count > 1, [&]() { return "unexpected txn_count=" + std::to_string(body.txn_count) + " for key=" + std::to_string(block_num); }); read_rlp_transactions(txn, body.base_txn_id + 1, body.txn_count - 2, rlp_txs); return true; } bool read_body(ROTxn& txn, const evmc::bytes32& hash, BlockBody& body) { auto block_num = read_block_num(txn, hash); if (!block_num) { return false; } return read_body(txn, *block_num, hash.bytes, /*read_senders=*/false, body); } bool read_canonical_body(ROTxn& txn, BlockNum block_num, bool read_senders, BlockBody& body) { auto hash = read_canonical_header_hash(txn, block_num); if (!hash) return false; return read_body(txn, block_num, hash->bytes, read_senders, body); } std::optional read_canonical_body_for_storage(ROTxn& txn, BlockNum block_num) { auto hash = read_canonical_header_hash(txn, block_num); if (!hash) return std::nullopt; return read_body_for_storage(txn, block_key(block_num, hash->bytes)); } std::optional read_raw_canonical_body_for_storage(ROTxn& txn, BlockNum block_num) { auto hash = read_canonical_header_hash(txn, block_num); if (!hash) return std::nullopt; return read_raw_body_for_storage(txn, block_key(block_num, hash->bytes)); } bool read_canonical_block(ROTxn& txn, BlockNum block_num, Block& block) { std::optional h = read_canonical_header_hash(txn, block_num); if (!h) return false; bool present = read_header(txn, *h, block_num, block.header); if (!present) return false; return read_body(txn, *h, block_num, block); } bool has_body(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength]) { auto key{block_key(block_num, hash)}; auto cursor = txn.ro_cursor(table::kBlockBodies); return cursor->find(to_slice(key), false); } bool has_body(ROTxn& txn, BlockNum block_num, const evmc::bytes32& hash) { return has_body(txn, block_num, hash.bytes); } void write_body(RWTxn& txn, const BlockBody& body, const evmc::bytes32& hash, BlockNum block_num) { write_body(txn, body, hash.bytes, block_num); } void write_body(RWTxn& txn, const BlockBody& body, const uint8_t (&hash)[kHashLength], const BlockNum block_num) { BlockBodyForStorage body_for_storage{}; body_for_storage.ommers = body.ommers; body_for_storage.withdrawals = body.withdrawals; body_for_storage.txn_count = body.transactions.size() + 2; body_for_storage.base_txn_id = increment_map_sequence(txn, table::kBlockTransactions.name, body_for_storage.txn_count); Bytes value{body_for_storage.encode()}; auto key{block_key(block_num, hash)}; auto target = txn.rw_cursor(table::kBlockBodies); target->upsert(to_slice(key), to_slice(value)); write_transactions(txn, body.transactions, body_for_storage.base_txn_id + 1); } void write_raw_body(RWTxn& txn, const BlockBody& body, const evmc::bytes32& hash, BlockNum block_num) { BlockBodyForStorage body_for_storage{}; body_for_storage.ommers = body.ommers; body_for_storage.withdrawals = body.withdrawals; body_for_storage.txn_count = body.transactions.size(); body_for_storage.base_txn_id = increment_map_sequence(txn, table::kBlockTransactions.name, body_for_storage.txn_count); Bytes value{body_for_storage.encode()}; auto key{block_key(block_num, hash.bytes)}; auto target = txn.rw_cursor(table::kBlockBodies); target->upsert(to_slice(key), to_slice(value)); write_transactions(txn, body.transactions, body_for_storage.base_txn_id); } void delete_body(RWTxn& txn, const evmc::bytes32& hash, BlockNum block_num) { auto cursor = txn.rw_cursor(table::kBlockBodies); auto key = block_key(block_num, hash.bytes); cursor->erase(to_slice(key)); } static ByteView read_senders_raw(ROTxn& txn, const Bytes& key) { auto cursor = txn.ro_cursor(table::kSenders); auto data{cursor->find(to_slice(key), /*throw_notfound = */ false)}; return data ? from_slice(data.value) : ByteView(); } std::vector read_senders(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength]) { auto key{block_key(block_num, hash)}; return read_senders(txn, key); } std::vector read_senders(ROTxn& txn, const Bytes& key) { std::vector senders{}; auto data_view{read_senders_raw(txn, key)}; if (!data_view.empty()) { SILKWORM_ASSERT(data_view.size() % kAddressLength == 0); senders.resize(data_view.size() / kAddressLength); std::memcpy(senders.data(), data_view.data(), data_view.size()); } return senders; } void parse_senders(ROTxn& txn, const Bytes& key, std::vector& out) { if (out.empty()) { return; } auto data_view{read_senders_raw(txn, key)}; if (!data_view.empty()) { SILKWORM_ASSERT(data_view.size() % kAddressLength == 0); SILKWORM_ASSERT(data_view.size() / kAddressLength == out.size()); auto addresses = reinterpret_cast(data_view.data()); size_t idx{0}; for (auto& transaction : out) { transaction.set_sender(addresses[idx++]); } } else { // Might be empty due to pruning } } void write_senders(RWTxn& txn, const evmc::bytes32& hash, const BlockNum& block_num, const Block& block) { auto key{block_key(block_num, hash.bytes)}; auto target = txn.rw_cursor(table::kSenders); Bytes data; for (const auto& block_txn : block.transactions) { if (const std::optional sender{block_txn.sender()}; sender) { data.append(sender->bytes, kAddressLength); } else { throw std::runtime_error("Missing senders for block " + std::to_string(block_num)); } } target->upsert(to_slice(key), to_slice(data)); } void delete_senders(RWTxn& txn, const evmc::bytes32& hash, const BlockNum& block_num) { auto cursor = txn.rw_cursor(table::kSenders); auto key = block_key(block_num, hash.bytes); cursor->erase(to_slice(key)); } void write_tx_lookup(RWTxn& txn, const Block& block) { auto target = txn.rw_cursor(table::kTxLookup); const auto block_num_bytes = block_key(block.header.number); for (const auto& block_txn : block.transactions) { auto tx_key = block_txn.hash(); target->upsert(to_slice(tx_key), to_slice(block_num_bytes)); } } void write_receipts(RWTxn& txn, const std::vector& receipts, const BlockNum& block_num) { auto target = txn.rw_cursor(table::kBlockReceipts); auto key{block_key(block_num)}; Bytes value{cbor_encode(receipts)}; target->upsert(to_slice(key), to_slice(value)); } std::optional read_code(ROTxn& txn, const evmc::bytes32& code_hash) { auto cursor = txn.ro_cursor(table::kCode); auto key{to_slice(code_hash)}; auto data{cursor->find(key, /*throw_notfound=*/false)}; if (!data) { return std::nullopt; } return from_slice(data.value); } // Erigon FindByHistory for account static std::optional historical_account(ROTxn& txn, const evmc::address& address, BlockNum block_num) { auto cursor = txn.ro_cursor_dup_sort(table::kAccountHistory); const Bytes history_key{account_history_key(address, block_num)}; const auto data{cursor->lower_bound(to_slice(history_key), /*throw_notfound=*/false)}; if (!data || !data.key.starts_with(to_slice(address))) { return std::nullopt; } const auto bitmap{bitmap::parse(data.value)}; const auto change_block{bitmap::seek(bitmap, block_num)}; if (!change_block) { return std::nullopt; } cursor->bind(txn, table::kAccountChangeSet); const Bytes change_set_key{block_key(*change_block)}; return find_value_suffix(*cursor, change_set_key, address.bytes); } // Erigon FindByHistory for storage static std::optional historical_storage(ROTxn& txn, const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, BlockNum block_num) { auto cursor = txn.ro_cursor_dup_sort(table::kStorageHistory); const Bytes history_key{storage_history_key(address, location, block_num)}; const auto data{cursor->lower_bound(to_slice(history_key), /*throw_notfound=*/false)}; if (!data) { return std::nullopt; } const ByteView k{from_slice(data.key)}; SILKWORM_ASSERT(k.size() == kAddressLength + kHashLength + sizeof(BlockNum)); if (k.substr(0, kAddressLength) != ByteView{address} || k.substr(kAddressLength, kHashLength) != ByteView{location}) { return std::nullopt; } const auto bitmap{bitmap::parse(data.value)}; const auto change_block{bitmap::seek(bitmap, block_num)}; if (!change_block) { return std::nullopt; } cursor->bind(txn, table::kStorageChangeSet); const Bytes change_set_key{storage_change_key(*change_block, address, incarnation)}; return find_value_suffix(*cursor, change_set_key, location.bytes); } std::optional read_account(ROTxn& txn, const evmc::address& address, std::optional block_num) { std::optional encoded{block_num.has_value() ? historical_account(txn, address, block_num.value()) : std::nullopt}; if (!encoded.has_value()) { auto state_cursor = txn.ro_cursor_dup_sort(table::kPlainState); if (auto data = state_cursor->find({address.bytes, sizeof(evmc::address)}, /*throw_notfound=*/false); data.done) { encoded.emplace(from_slice(data.value)); } } if (!encoded.has_value() || encoded->empty()) { return std::nullopt; } const auto acc_res = state::AccountCodec::from_encoded_storage(encoded.value()); success_or_throw(acc_res); Account acc{*acc_res}; if (acc.incarnation > 0 && acc.code_hash == kEmptyHash) { // restore code hash auto code_cursor = txn.ro_cursor(table::kPlainCodeHash); auto key{storage_prefix(address, acc.incarnation)}; if (auto data = code_cursor->find(to_slice(key), /*throw_notfound=*/false); data.done && data.value.length() == kHashLength) { std::memcpy(acc.code_hash.bytes, data.value.data(), kHashLength); } } return acc; } evmc::bytes32 read_storage(ROTxn& txn, const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, std::optional block_num) { std::optional val{block_num.has_value() ? historical_storage(txn, address, incarnation, location, block_num.value()) : std::nullopt}; if (!val.has_value()) { auto cursor = txn.ro_cursor_dup_sort(table::kPlainState); auto key{storage_prefix(address, incarnation)}; val = find_value_suffix(*cursor, key, location.bytes); } if (!val.has_value()) { return {}; } evmc::bytes32 res{}; SILKWORM_ASSERT(val->size() <= kHashLength); std::memcpy(res.bytes + kHashLength - val->size(), val->data(), val->size()); return res; } static std::optional historical_previous_incarnation(ROTxn& txn, const evmc::address& address, BlockNum block_num) { std::optional encoded_account{historical_account(txn, address, block_num + 1)}; if (!encoded_account) { return std::nullopt; } const auto acc_result = state::AccountCodec::from_encoded_storage(encoded_account.value()); success_or_throw(acc_result); Account account{*acc_result}; const uint64_t previous_incarnation{account.incarnation > 0 ? account.incarnation - 1 : 0}; return previous_incarnation; } std::optional read_previous_incarnation(ROTxn& txn, const evmc::address& address, std::optional block_num) { if (block_num.has_value()) { return historical_previous_incarnation(txn, address, *block_num); } auto cursor = txn.ro_cursor(table::kIncarnationMap); if (auto data = cursor->find(to_slice(address), /*throw_notfound=*/false); data.done) { SILKWORM_ASSERT(data.value.length() == 8); const uint64_t previous_incarnation{endian::load_big_u64(static_cast(data.value.data()))}; return previous_incarnation; } return std::nullopt; } AccountChanges read_account_changes(ROTxn& txn, BlockNum block_num) { AccountChanges changes; auto cursor = txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto key{block_key(block_num)}; auto data{cursor->find(to_slice(key), /*throw_notfound=*/false)}; while (data) { SILKWORM_ASSERT(data.value.length() >= kAddressLength); evmc::address address; std::memcpy(address.bytes, data.value.data(), kAddressLength); data.value.remove_prefix(kAddressLength); changes[address] = from_slice(data.value); data = cursor->to_current_next_multi(/*throw_notfound=*/false); } return changes; } StorageChanges read_storage_changes(ROTxn& txn, BlockNum block_num) { StorageChanges changes; const Bytes block_prefix{block_key(block_num)}; auto cursor = txn.ro_cursor_dup_sort(table::kStorageChangeSet); auto key_prefix{to_slice(block_prefix)}; auto data{cursor->lower_bound(key_prefix, false)}; while (data) { if (!data.key.starts_with(key_prefix)) { break; } data.key.remove_prefix(key_prefix.length()); SILKWORM_ASSERT(data.key.length() == kPlainStoragePrefixLength); evmc::address address; std::memcpy(address.bytes, data.key.data(), kAddressLength); data.key.remove_prefix(kAddressLength); uint64_t incarnation{endian::load_big_u64(static_cast(data.key.data()))}; SILKWORM_ASSERT(data.value.length() >= kHashLength); evmc::bytes32 location; std::memcpy(location.bytes, data.value.data(), kHashLength); data.value.remove_prefix(kHashLength); changes[address][incarnation][location] = from_slice(data.value); data = cursor->to_next(/*throw_notfound=*/false); } return changes; } std::optional read_chain_config(ROTxn& txn) { auto canonical_hashes_cursor = txn.ro_cursor(table::kCanonicalHashes); auto data{canonical_hashes_cursor->find(to_slice(block_key(0)), /*throw_notfound=*/false)}; if (!data) { return std::nullopt; } const auto key{data.value}; canonical_hashes_cursor->bind(txn, table::kConfig); data = canonical_hashes_cursor->find(key, /*throw_notfound=*/false); if (!data) { return std::nullopt; } // https://github.com/nlohmann/json/issues/2204 const auto json = nlohmann::json::parse(data.value.as_string(), nullptr, false); return ChainConfig::from_json(json); } void update_chain_config(RWTxn& txn, const ChainConfig& config) { auto genesis_hash{read_canonical_header_hash(txn, 0)}; if (!genesis_hash.has_value()) { return; } auto cursor = txn.rw_cursor(table::kConfig); auto config_data{config.to_json().dump()}; cursor->upsert(to_slice(genesis_hash->bytes), mdbx::slice(config_data.data())); } static ByteView head_header_key() { return string_view_to_byte_view(table::kHeadHeaderName); } void write_head_header_hash(RWTxn& txn, const evmc::bytes32& hash) { write_head_header_hash(txn, hash.bytes); } void write_head_header_hash(RWTxn& txn, const uint8_t (&hash)[kHashLength]) { auto target = txn.rw_cursor(table::kHeadHeader); ByteView key = head_header_key(); auto skey = to_slice(key); target->upsert(skey, to_slice(hash)); } std::optional read_head_header_hash(ROTxn& txn) { auto cursor = txn.ro_cursor(table::kHeadHeader); ByteView key = head_header_key(); auto skey = to_slice(key); auto data{cursor->find(skey, /*throw_notfound=*/false)}; if (!data || data.value.length() != kHashLength) { return std::nullopt; } return to_bytes32(from_slice(data.value)); } void write_canonical_hash(RWTxn& txn, BlockNum block_num, const evmc::bytes32& hash) { Bytes key = block_key(block_num); auto skey = to_slice(key); auto svalue = to_slice(hash); auto hashes_cursor = txn.rw_cursor(table::kCanonicalHashes); hashes_cursor->upsert(skey, svalue); } void delete_canonical_hash(RWTxn& txn, BlockNum block_num) { auto hashes_cursor = txn.rw_cursor(table::kCanonicalHashes); Bytes key = block_key(block_num); auto skey = to_slice(key); (void)hashes_cursor->erase(skey); } uint64_t increment_map_sequence(RWTxn& txn, std::string_view map_name, uint64_t increment) { uint64_t current_value{read_map_sequence(txn, map_name)}; if (increment) { auto target = txn.rw_cursor(table::kSequence); mdbx::slice key(map_name); uint64_t new_value{current_value + increment}; // Note ! May overflow Bytes new_data(sizeof(uint64_t), '\0'); endian::store_big_u64(new_data.data(), new_value); target->upsert(key, to_slice(new_data)); } return current_value; } uint64_t read_map_sequence(ROTxn& txn, std::string_view map_name) { auto target = txn.ro_cursor(table::kSequence); mdbx::slice key(map_name); const auto data = target->find(key, /*throw_notfound=*/false); if (!data.done) { return 0; } if (data.value.length() != sizeof(uint64_t)) { throw std::length_error("Bad sequence value in db"); } return endian::load_big_u64(from_slice(data.value).data()); } uint64_t reset_map_sequence(RWTxn& txn, std::string_view map_name, uint64_t new_sequence) { uint64_t current_sequence{read_map_sequence(txn, map_name)}; if (new_sequence != current_sequence) { auto target = txn.rw_cursor(table::kSequence); mdbx::slice key(map_name); Bytes new_sequence_buffer(sizeof(uint64_t), '\0'); endian::store_big_u64(new_sequence_buffer.data(), new_sequence); target->upsert(key, to_slice(new_sequence_buffer)); } return current_sequence; } static constexpr std::string_view kHeadBlockHash = "headBlockHash"; static constexpr std::string_view kSafeBlockHash = "safeBlockHash"; static constexpr std::string_view kFinalizedBlockHash = "finalizedBlockHash"; std::optional read_last_fcu_field(ROTxn& txn, std::string_view field) { auto cursor = txn.ro_cursor(table::kLastForkchoice); Bytes key{field.begin(), field.end()}; auto skey = to_slice(key); auto data{cursor->find(skey, /*throw_notfound=*/false)}; if (!data || data.value.length() != kHashLength) { return std::nullopt; } return to_bytes32(from_slice(data.value)); } void write_last_fcu_field(RWTxn& txn, std::string_view field, const evmc::bytes32& hash) { auto cursor = txn.rw_cursor(table::kLastForkchoice); Bytes key{field.begin(), field.end()}; auto skey = to_slice(key); cursor->upsert(skey, to_slice(hash)); } std::optional read_last_head_block(ROTxn& txn) { return read_last_fcu_field(txn, kHeadBlockHash); } std::optional read_last_safe_block(ROTxn& txn) { return read_last_fcu_field(txn, kSafeBlockHash); } std::optional read_last_finalized_block(ROTxn& txn) { return read_last_fcu_field(txn, kFinalizedBlockHash); } void write_last_head_block(RWTxn& txn, const evmc::bytes32& hash) { write_last_fcu_field(txn, kHeadBlockHash, hash); } void write_last_safe_block(RWTxn& txn, const evmc::bytes32& hash) { write_last_fcu_field(txn, kSafeBlockHash, hash); } void write_last_finalized_block(RWTxn& txn, const evmc::bytes32& hash) { write_last_fcu_field(txn, kFinalizedBlockHash, hash); } std::optional DataModel::read_chain_config() const { return db::read_chain_config(txn_); } std::optional DataModel::read_chain_id() const { const auto chain_config{read_chain_config()}; std::optional chain_id; if (chain_config) { chain_id = chain_config->chain_id; } return chain_id; } BlockNum DataModel::max_block_num() const { // Assume last block is likely on db: first lookup there const auto header_cursor{txn_.ro_cursor(table::kHeaders)}; const auto data = header_cursor->to_last(/*throw_notfound=*/false); if (data.done && data.key.size() >= sizeof(uint64_t)) { ByteView key = from_slice(data.key); ByteView block_num_data = key.substr(0, sizeof(BlockNum)); BlockNum block_num = endian::load_big_u64(block_num_data.data()); if (block_num > 0) { // skip genesis block if present return block_num; } } // If none is found on db, then ask the snapshot repository (if any) for max block return repository_.max_timestamp_available(); } BlockNum DataModel::max_frozen_block_num() const { // Ask the snapshot repository (if any) for max block return repository_.max_timestamp_available(); } std::optional DataModel::read_header(BlockNum block_num, HashAsArray hash) const { return read_header(block_num, Hash(hash)); } std::optional DataModel::read_header(BlockNum block_num, const Hash& hash) const { BlockNum repository_max_block_num = repository_.max_timestamp_available(); if ((repository_max_block_num > 0) && (block_num <= repository_max_block_num)) { auto header = read_header_from_snapshot(block_num); if (header && header->hash() == hash) { // reading using hash avoid this heavy hash calculation return header; } return {}; } return db::read_header(txn_, block_num, hash); } std::optional DataModel::read_header(BlockNum block_num) const { BlockNum repository_max_block_num = repository_.max_timestamp_available(); if ((repository_max_block_num > 0) && (block_num <= repository_max_block_num)) { return read_header_from_snapshot(block_num); } auto hash = db::read_canonical_header_hash(txn_, block_num); return db::read_header(txn_, block_num, *hash); } std::optional DataModel::read_header(const Hash& hash) const { // Assume recent blocks are more probable: first lookup the block header in the db auto block_header{db::read_header(txn_, hash)}; if (block_header) return block_header; // Then search for it in the snapshots (if any) return read_header_from_snapshot(hash); } std::pair, std::optional> DataModel::read_head_header_and_hash() const { auto hash_opt = read_head_header_hash(txn_); if (!hash_opt) return {std::nullopt, std::nullopt}; Hash hash{*hash_opt}; auto header = read_header(hash); return {std::move(header), hash}; } std::optional DataModel::read_block_num(const Hash& hash) const { // Assume recent blocks are more probable: first lookup the block in the db auto block_num = db::read_block_num(txn_, hash); if (block_num) return block_num; // Then search for it in the snapshots (if any) const auto block_header{read_header_from_snapshot(hash)}; if (block_header) { block_num = block_header->number; } return block_num; } std::vector DataModel::read_sibling_headers(BlockNum block_num) const { std::vector sibling_headers; // Read all siblings headers at block_num from db read_headers(txn_, block_num, [&](BlockHeader header) { sibling_headers.push_back(std::move(header)); }); // Read block header at block_num from snapshot (if any) just in case std::optional header = read_header_from_snapshot(block_num); if (header) { sibling_headers.push_back(std::move(*header)); } return sibling_headers; } bool DataModel::read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const { // Assume recent blocks are more probable: first lookup the block body in the db const bool found = db::read_body(txn_, block_num, hash, read_senders, body); if (found) return found; return read_body_from_snapshot(block_num, body); } bool DataModel::read_body(const Hash& hash, BlockNum block_num, BlockBody& body) const { return read_body(block_num, hash.bytes, /*read_senders=*/false, body); } bool DataModel::read_body(const Hash& hash, BlockBody& body) const { const bool found = db::read_body(txn_, hash, body); if (found) return found; // Then search for it in the snapshots (if any) const auto block_header{read_header_from_snapshot(hash)}; if (block_header) { return read_body(block_header->number, hash.bytes, /*read_senders=*/false, body); } return false; } std::optional DataModel::read_canonical_header_hash(BlockNum block_num) const { const auto block_hash = db::read_canonical_header_hash(txn_, block_num); if (block_hash) return block_hash; const auto block_header = read_header_from_snapshot(block_num); if (!block_header) return {}; return block_header->hash(); } std::optional DataModel::read_canonical_header(BlockNum block_num) const { // We don't use DataModel::read_canonical_header_hash here to avoid double read for headers in snapshots const auto canonical_hash{db::read_canonical_header_hash(txn_, block_num)}; if (canonical_hash) { return db::read_header(txn_, block_num, *canonical_hash); } return read_header_from_snapshot(block_num); } bool DataModel::read_canonical_body(BlockNum block_num, BlockBody& body) const { const auto canonical_hash{read_canonical_header_hash(block_num)}; if (!canonical_hash) return {}; return read_body(*canonical_hash, block_num, body); } bool DataModel::read_canonical_block(BlockNum block_num, Block& block) const { const auto canonical_hash = db::read_canonical_header_hash(txn_, block_num); if (canonical_hash) { const bool found = db::read_block(txn_, *canonical_hash, block_num, block); if (found) return found; } return read_block_from_snapshot(block_num, block); } std::optional DataModel::read_transaction_by_txn_idx(BlockNum block_num, uint64_t txn_idx) const { std::vector transactions; // Assume recent blocks are more probable: first lookup the block body in the db if (block_num > max_frozen_block_num() || max_frozen_block_num() == 0) { auto hash = read_canonical_header_hash(block_num); if (!hash) return std::nullopt; const Bytes key{block_key(block_num, hash->bytes)}; auto body_opt = read_body_for_storage(txn_, key); if (body_opt) { BlockBodyForStorage& body = *body_opt; if (2 + txn_idx >= body_opt->txn_count) { return std::nullopt; } read_transactions(txn_, body.base_txn_id + 1 + txn_idx, /*count=*/1, transactions); SILKWORM_ASSERT(!transactions.empty()); return transactions[0]; } } auto stored_body = read_body_for_storage_from_snapshot(block_num); if (!stored_body) return std::nullopt; if (2 + txn_idx >= stored_body->txn_count) { return std::nullopt; } const auto start_txn_id{stored_body->base_txn_id + 1 + txn_idx}; const auto read_ok{read_transactions_from_snapshot(block_num, start_txn_id, /*txn_count=*/1, transactions)}; if (!read_ok) return std::nullopt; SILKWORM_ASSERT(!transactions.empty()); return transactions[0]; } bool DataModel::has_body(BlockNum block_num, HashAsArray hash) const { const bool found = db::has_body(txn_, block_num, hash); if (found) return found; return is_body_in_snapshot(block_num); } bool DataModel::has_body(BlockNum block_num, const Hash& hash) const { return has_body(block_num, hash.bytes); } bool DataModel::read_block(HashAsSpan hash, BlockNum block_num, bool read_senders, Block& block) const { const bool found = db::read_block(txn_, hash, block_num, read_senders, block); if (found) return found; return read_block_from_snapshot(block_num, block); } bool DataModel::read_block(const evmc::bytes32& hash, BlockNum block_num, Block& block) const { const bool found = db::read_block(txn_, hash, block_num, block); if (found) return found; return read_block_from_snapshot(block_num, block); } void DataModel::for_last_n_headers(size_t n, absl::FunctionRef callback) const { const bool throw_notfound{false}; // Try to read N headers from the database size_t read_count{0}; std::optional last_read_block_num_from_db; const auto headers_cursor{txn_.ro_cursor(table::kHeaders)}; auto data = headers_cursor->to_last(throw_notfound); while (data && read_count < n) { // Read header BlockHeader header; ByteView data_view = from_slice(data.value); success_or_throw(rlp::decode(data_view, header)); ++read_count; last_read_block_num_from_db = header.number; // Consume header callback(std::move(header)); // Move backward data = headers_cursor->to_previous(throw_notfound); } if (read_count == n) { return; } BlockNum block_num_in_snapshots = repository_.max_timestamp_available(); // We've reached the first header in db but still need to read more from snapshots if (last_read_block_num_from_db > 0) { ensure(*last_read_block_num_from_db == block_num_in_snapshots + 1, "db and snapshot block numbers are not contiguous"); } while (read_count < n) { auto header{read_header_from_snapshot(block_num_in_snapshots)}; if (!header) return; ++block_num_in_snapshots; ++read_count; // Consume header callback(std::move(*header)); } } bool DataModel::read_block(BlockNum block_num, bool read_senders, Block& block) const { const auto hash = db::read_canonical_header_hash(txn_, block_num); if (hash) { const bool found = db::read_block(txn_, hash->bytes, block_num, read_senders, block); if (found) return found; } return read_block_from_snapshot(block_num, block); } bool DataModel::read_block_from_snapshot(BlockNum block_num, Block& block) const { auto block_header{read_header_from_snapshot(block_num)}; if (!block_header) return false; block.header = std::move(*block_header); return read_body_from_snapshot(block_num, block); } std::optional DataModel::read_header_from_snapshot(BlockNum block_num) const { return HeaderFindByBlockNumQuery{repository_}.exec(block_num); } std::optional DataModel::read_header_from_snapshot(const Hash& hash) const { auto result = HeaderFindByHashQuery{repository_}.exec(hash); if (!result) return std::nullopt; return std::move(result->value); } std::optional DataModel::read_canonical_body_for_storage(BlockNum block_num) const { auto block_body_for_storage = db::read_canonical_body_for_storage(txn_, block_num); if (block_body_for_storage) return block_body_for_storage; return read_body_for_storage_from_snapshot(block_num); } std::optional DataModel::read_raw_canonical_body_for_storage(BlockNum block_num) const { auto block_body_for_storage = db::read_raw_canonical_body_for_storage(txn_, block_num); if (block_body_for_storage) return block_body_for_storage; return read_raw_body_for_storage_from_snapshot(block_num); } std::optional DataModel::read_body_for_storage_from_snapshot(BlockNum block_num) const { return BodyFindByBlockNumQuery{repository_}.exec(block_num); } std::optional DataModel::read_raw_body_for_storage_from_snapshot(BlockNum block_num) const { return RawBodyFindByBlockNumQuery{repository_}.exec(block_num); } bool DataModel::read_body_from_snapshot(BlockNum block_num, BlockBody& body) const { auto stored_body = read_body_for_storage_from_snapshot(block_num); if (!stored_body) return false; // Skip first and last *system transactions* in block body const auto base_txn_id{stored_body->base_txn_id + 1}; const auto txn_count{stored_body->txn_count >= 2 ? stored_body->txn_count - 2 : stored_body->txn_count}; std::vector transactions; const auto read_ok{read_transactions_from_snapshot(block_num, base_txn_id, txn_count, transactions)}; if (!read_ok) return false; body.transactions = std::move(transactions); body.ommers = std::move(stored_body->ommers); body.withdrawals = std::move(stored_body->withdrawals); return true; } bool DataModel::is_body_in_snapshot(BlockNum block_num) const { return BodyFindByBlockNumQuery{repository_}.exec(block_num).has_value(); } bool DataModel::read_transactions_from_snapshot(BlockNum block_num, uint64_t base_txn_id, uint64_t txn_count, std::vector& txs) const { if (txn_count == 0) { return true; } auto txs_opt = TransactionRangeFromIdQuery{repository_}.exec(block_num, base_txn_id, txn_count); if (!txs_opt) return false; txs = std::move(*txs_opt); return true; } bool DataModel::read_rlp_transactions_from_snapshot(BlockNum block_num, std::vector& rlp_txs) const { auto stored_body = BodyFindByBlockNumQuery{repository_}.exec(block_num); if (!stored_body) return false; // Skip first and last *system transactions* in block body const auto base_txn_id{stored_body->base_txn_id + 1}; const auto txn_count{stored_body->txn_count >= 2 ? stored_body->txn_count - 2 : stored_body->txn_count}; if (txn_count == 0) return true; auto txs_opt = TransactionPayloadRlpRangeFromIdQuery{repository_}.exec(block_num, base_txn_id, txn_count); if (!txs_opt) return false; rlp_txs = std::move(*txs_opt); return true; } bool DataModel::read_rlp_transactions(BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) const { bool found = db::read_rlp_transactions(txn_, block_num, hash, rlp_txs); if (found) return true; return read_rlp_transactions_from_snapshot(block_num, rlp_txs); } std::optional> DataModel::read_tx_lookup(const evmc::bytes32& tx_hash) const { auto result = read_tx_lookup_from_db(tx_hash); if (result) { return result; } return read_tx_lookup_from_snapshot(tx_hash); } std::optional> DataModel::read_tx_lookup_from_db(const evmc::bytes32& tx_hash) const { auto cursor = txn_.ro_cursor(table::kTxLookup); const auto data = cursor->find(to_slice(tx_hash), /*throw_notfound=*/false); if (!data) { return std::nullopt; } const ByteView data_value = from_slice(data.value); if (data_value.size() < 2 * sizeof(uint64_t)) { return std::nullopt; } const BlockNum block_num = endian::load_big_u64(data_value.data()); const TxnId txn_id = endian::load_big_u64(data_value.data() + sizeof(uint64_t)); return std::make_pair(block_num, txn_id); } std::optional> DataModel::read_tx_lookup_from_snapshot(const evmc::bytes32& tx_hash) const { TransactionBlockNumByTxnHashQuery query{repository_}; return query.exec(tx_hash); } std::optional DataModel::read_total_difficulty(BlockNum block_num, const evmc::bytes32& hash) const { return db::read_total_difficulty(txn_, block_num, hash); } std::optional DataModel::read_total_difficulty(BlockNum block_num, HashAsArray hash) const { return db::read_total_difficulty(txn_, block_num, hash); } std::optional DataModel::read_total_difficulty(ByteView key) const { return db::read_total_difficulty(txn_, key); } } // namespace silkworm::db ================================================ FILE: silkworm/db/access_layer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // Database Access Layer // See Erigon core/rawdb/accessors_chain.go #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots { class SnapshotRepository; } namespace silkworm::db { using datastore::kvdb::ROTxn; using datastore::kvdb::RWTxn; //! \brief Pulls database schema version std::optional read_schema_version(ROTxn& txn); //! \brief Writes database schema version (throws on downgrade) void write_schema_version(RWTxn& txn, const VersionBase& schema_version); //! \brief Updates database info with build info at provided block_num //! \details Is useful to track whether increasing block numbers have been affected by //! upgrades or downgrades of Silkworm's build void write_build_info_block_num(RWTxn& txn, const Bytes& key, BlockNum block_num); //! \brief Reads a header with the specified key (block number, hash) std::optional read_header(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength]); std::optional read_header(ROTxn& txn, BlockNum block_num, const evmc::bytes32&); std::optional read_header(ROTxn& txn, ByteView key); Bytes read_header_raw(ROTxn& txn, ByteView key); //! \brief Reads a header with the specified hash std::optional read_header(ROTxn& txn, const evmc::bytes32& hash); //! \brief Reads all headers at the specified block_num std::vector read_headers(ROTxn& txn, BlockNum block_num); //! \brief Reads all headers at the specified block_num and pass them to process_func callback size_t read_headers(ROTxn& txn, BlockNum block_num, std::function process_func); //! \brief Reads the canonical head std::tuple read_canonical_head(ROTxn& txn); //! \brief Reads the canonical header from a block number std::optional read_canonical_header(ROTxn& txn, BlockNum block_num); //! \brief Writes given header to table::kHeaders void write_header(RWTxn& txn, const BlockHeader& header, bool with_header_numbers = false); //! \brief Writes given header to table::kHeaders and returns its hash evmc::bytes32 write_header_ex(RWTxn& txn, const BlockHeader& header, bool with_header_numbers); //! \brief Deletes a header from table::kHeaders void delete_header(RWTxn& txn, BlockNum block_num, const evmc::bytes32& hash); //! \brief Finds the first header with a number >= min_block_num in table::kHeaders std::optional read_stored_header_number_after(ROTxn& txn, BlockNum min_block_num); //! \brief Read block number from hash std::optional read_block_num(ROTxn& txn, const evmc::bytes32& hash); //! \brief Writes header hash in table::kHeaderNumbers void write_header_number(RWTxn& txn, const uint8_t (&hash)[kHashLength], BlockNum block_num); //! \brief Deletes a header hash to number entry in table::kHeaderNumbers void delete_header_number(RWTxn& txn, const evmc::bytes32& hash); //! \brief Writes the header hash in table::kCanonicalHashes void write_canonical_header(RWTxn& txn, const BlockHeader& header); //! \brief Reads the header hash in table::kCanonicalHashes std::optional read_canonical_header_hash(ROTxn& txn, BlockNum block_num); //! \brief Writes the header hash in table::kCanonicalHashes void write_canonical_header_hash(RWTxn& txn, const uint8_t (&hash)[kHashLength], BlockNum block_num); //! \brief Read a block body (in an out parameter) returning true on success and false on missing block [[nodiscard]] bool read_body(ROTxn& txn, const Bytes& key, bool read_senders, BlockBody& out); [[nodiscard]] bool read_body( ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength], bool read_senders, BlockBody& out); [[nodiscard]] bool read_body(ROTxn& txn, const evmc::bytes32& hash, BlockNum block_num, BlockBody& body); [[nodiscard]] bool read_body(ROTxn& txn, const evmc::bytes32& hash, BlockBody& body); [[nodiscard]] bool read_canonical_body(ROTxn& txn, BlockNum block_num, bool read_senders, BlockBody& body); std::optional read_body_for_storage(ROTxn& txn, const Bytes& key); std::optional read_canonical_body_for_storage(ROTxn& txn, BlockNum block_num); //! \brief Read the canonical block at specified block_num [[nodiscard]] bool read_canonical_block(ROTxn& txn, BlockNum block_num, Block& block); //! \brief Apply a user defined func to the bodies at specified block_num size_t read_blocks( ROTxn& txn, BlockNum block_num, std::function process_func, bool read_senders = false); //! \brief Check the presence of a block body using block number and hash bool has_body(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength]); bool has_body(ROTxn& txn, BlockNum block_num, const evmc::bytes32& hash); //! \brief Writes block body in table::kBlockBodies void write_body(RWTxn& txn, const BlockBody& body, const evmc::bytes32& hash, BlockNum block_num); void write_body(RWTxn& txn, const BlockBody& body, const uint8_t (&hash)[kHashLength], BlockNum block_num); void write_raw_body(RWTxn& txn, const BlockBody& body, const evmc::bytes32& hash, BlockNum block_num); //! \brief Deletes a block body from table::kBlockBodies void delete_body(RWTxn& txn, const evmc::bytes32& hash, BlockNum block_num); // See Erigon ReadTd std::optional read_total_difficulty(ROTxn& txn, BlockNum, const evmc::bytes32& hash); std::optional read_total_difficulty(ROTxn& txn, BlockNum, const uint8_t (&hash)[kHashLength]); std::optional read_total_difficulty(ROTxn& txn, ByteView key); // See Erigon WriteTd void write_total_difficulty(RWTxn& txn, BlockNum block_num, const evmc::bytes32& hash, const intx::uint256& total_difficulty); void write_total_difficulty( RWTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength], const intx::uint256& total_difficulty); void write_total_difficulty(RWTxn& txn, const Bytes& key, const intx::uint256& total_difficulty); // Reads canonical block; see Erigon ReadBlockByNumber. // Returns true on success and false on missing block. [[nodiscard]] bool read_block_by_number(ROTxn& txn, BlockNum block_num, bool read_senders, Block& block); // Reads a block; see Erigon ReadBlock. // Returns true on success and false on missing block. [[nodiscard]] bool read_block( ROTxn& txn, std::span hash, BlockNum block_num, bool read_senders, Block& block); [[nodiscard]] bool read_block(ROTxn& txn, const evmc::bytes32& hash, BlockNum block_num, Block& block); // See Erigon ReadSenders std::vector read_senders(ROTxn& txn, const Bytes& key); std::vector read_senders(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kHashLength]); //! \brief Fills transactions' senders addresses directly in place void parse_senders(ROTxn& txn, const Bytes& key, std::vector& out); void write_senders(RWTxn& txn, const evmc::bytes32& hash, const BlockNum& block_num, const Block& block); void delete_senders(RWTxn& txn, const evmc::bytes32& hash, const BlockNum& block_num); void write_tx_lookup(RWTxn& txn, const Block& block); void write_receipts(RWTxn& txn, const std::vector& receipts, const BlockNum& block_num); // See Erigon ReadTransactions void read_transactions(ROTxn& txn, uint64_t base_id, uint64_t count, std::vector& out); void read_transactions(datastore::kvdb::ROCursor& txn_table, uint64_t base_id, uint64_t count, std::vector& out); bool read_rlp_transactions(ROTxn& txn, BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs); //! \brief Persist transactions into db's bucket table::kBlockTransactions. //! The key starts from base_id and is incremented by 1 for each transaction. //! \remarks Before calling this ensure you got a proper base_id by incrementing sequence for table::kBlockTransactions. void write_transactions(RWTxn& txn, const std::vector& transactions, uint64_t base_id); //! \brief Delete transactions from table::kBlockTransactions. void delete_transactions(RWTxn& txn, uint64_t base_id, uint64_t count); std::optional read_code(ROTxn& txn, const evmc::bytes32& code_hash); // Reads current or historical (if block_num is specified) account. std::optional read_account( ROTxn& txn, const evmc::address& address, std::optional block_num = std::nullopt); // Reads current or historical (if block_num is specified) storage. evmc::bytes32 read_storage( ROTxn& txn, const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, std::optional block_num = std::nullopt); // Reads current or historical (if block_num is specified) previous incarnation. std::optional read_previous_incarnation( ROTxn& txn, const evmc::address& address, std::optional block_num = std::nullopt); AccountChanges read_account_changes(ROTxn& txn, BlockNum block_num); StorageChanges read_storage_changes(ROTxn& txn, BlockNum block_num); //! \brief Retrieves the chain_id for which database is populated //! \see Erigon chainConfig / chainConfigWithGenesis std::optional read_chain_config(ROTxn& txn); //! \brief Writes / Updates chain config provided genesis has been initialized void update_chain_config(RWTxn& txn, const ChainConfig& config); //! \brief Updates the tip header hash in table::kHeadHeader void write_head_header_hash(RWTxn& txn, const uint8_t (&hash)[kHashLength]); void write_head_header_hash(RWTxn& txn, const evmc::bytes32& hash); //! \brief Reads the tip header hash from table::kHeadHeader std::optional read_head_header_hash(ROTxn& txn); //! \brief Delete a canonical hash associated to a block number void delete_canonical_hash(RWTxn& txn, BlockNum block_num); //! \brief Write canonical hash void write_canonical_hash(RWTxn& txn, BlockNum block_num, const evmc::bytes32& hash); //! \brief Gets/Increments the sequence value for a given map (bucket) //! \param [in] map_name : the name of the map to get a sequence for //! \param [in] increment : the value of increments to add to the sequence. //! \returns The current value of the sequence AND internally increments the value for next call //! \throws std::std::length_error on badly recorded value //! \remarks Initial sequence for any key (also unset) is 0. Changes to sequences are invisible until the transaction is //! committed uint64_t increment_map_sequence(RWTxn& txn, std::string_view map_name, uint64_t increment = 1u); //! \brief Returns the current sequence for a map_name //! \remarks If the key is not present in Sequence bucket the return value is 0 //! \throws std::std::length_error on badly recorded value uint64_t read_map_sequence(ROTxn& txn, std::string_view map_name); //! \brief Reset the sequence value for a given map (bucket) //! \param [in] map_name : the name of the map to reset the sequence for //! \param [in] new_sequence : the value to set the sequence to //! \returns The old value of the sequence //! \throws std::std::length_error on badly recorded value //! \remarks Initial sequence for any key (also unset) is 0. Changes to sequences are invisible until the transaction is //! committed uint64_t reset_map_sequence(RWTxn& txn, std::string_view map_name, uint64_t new_sequence); //! \brief Read the last head block as stated by the last FCU std::optional read_last_head_block(ROTxn& txn); //! \brief Read the last safe block as stated by the last FCU std::optional read_last_safe_block(ROTxn& txn); //! \brief Read the last finalized block as stated by the last FCU std::optional read_last_finalized_block(ROTxn& txn); //! \brief Write the last head block as stated by the last FCU void write_last_head_block(RWTxn& txn, const evmc::bytes32& hash); //! \brief Write the last safe block as stated by the last FCU void write_last_safe_block(RWTxn& txn, const evmc::bytes32& hash); //! \brief Write the last finalized block as stated by the last FCU void write_last_finalized_block(RWTxn& txn, const evmc::bytes32& hash); class DataModel { public: DataModel( ROTxn& txn, const snapshots::SnapshotRepositoryROAccess& repository) : txn_{txn}, repository_{repository} {} //! Retrieve the chain configuration for which database is populated std::optional read_chain_config() const; //! Retrieve the chain unique identifier for which database is populated std::optional read_chain_id() const; //! Get the max block number BlockNum max_block_num() const; //! Get the max block number frozen into snapshots BlockNum max_frozen_block_num() const; //! Read block header with the specified key (block_num, hash) std::optional read_header(BlockNum block_num, HashAsArray hash) const; //! Read block header with the specified key (block_num, hash) std::optional read_header(BlockNum block_num, const Hash& hash) const; //! Read block header with the specified hash std::optional read_header(const Hash& hash) const; //! Read block header with the specified block number std::optional read_header(BlockNum block_num) const; //! Reads the tip header hash from table::kHeadHeader and a corresponding header std::pair, std::optional> read_head_header_and_hash() const; //! Read block number from hash std::optional read_block_num(const Hash& hash) const; //! Read all sibling block headers at specified block_num std::vector read_sibling_headers(BlockNum block_num) const; //! Read block body in output parameter returning true on success and false on missing block [[nodiscard]] bool read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const; [[nodiscard]] bool read_body(const Hash& hash, BlockNum block_num, BlockBody& body) const; [[nodiscard]] bool read_body(const Hash& hash, BlockBody& body) const; std::optional read_canonical_body_for_storage(BlockNum block_num) const; std::optional read_raw_canonical_body_for_storage(BlockNum block_num) const; //! Read block body for storage from the snapshot repository std::optional read_body_for_storage_from_snapshot(BlockNum block_num) const; std::optional read_raw_body_for_storage_from_snapshot(BlockNum block_num) const; //! Read the canonical block header at specified block_num std::optional read_canonical_header_hash(BlockNum block_num) const; //! Read the canonical block header at specified block_num std::optional read_canonical_header(BlockNum block_num) const; //! Read the canonical block body at specified block_num [[nodiscard]] bool read_canonical_body(BlockNum block_num, BlockBody& body) const; //! Read the transaction at index txn_idx within the specified block [[nodiscard]] std::optional read_transaction_by_txn_idx(BlockNum block_num, uint64_t txn_idx) const; //! Read the canonical block at specified block_num [[nodiscard]] bool read_canonical_block(BlockNum block_num, Block& block) const; //! Check the presence of a block body using block number and hash bool has_body(BlockNum block_num, HashAsArray hash) const; bool has_body(BlockNum block_num, const Hash& hash) const; //! Read block returning true on success and false on missing block [[nodiscard]] bool read_block(HashAsSpan hash, BlockNum block_num, bool read_senders, Block& block) const; [[nodiscard]] bool read_block(const evmc::bytes32& hash, BlockNum block_num, Block& block) const; [[nodiscard]] bool read_block(BlockNum block_num, bool read_senders, Block& block) const; //! Read the RLP encoded block transactions at specified block_num [[nodiscard]] bool read_rlp_transactions(BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) const; std::optional> read_tx_lookup(const evmc::bytes32& tx_hash) const; //! Read total difficulty at specified block_num std::optional read_total_difficulty(BlockNum block_num, const evmc::bytes32& hash) const; std::optional read_total_difficulty(BlockNum, HashAsArray hash) const; std::optional read_total_difficulty(ByteView key) const; //! Read all block headers up to limit in reverse order from last, processing each one via a user defined callback void for_last_n_headers(size_t n, absl::FunctionRef callback) const; private: bool read_block_from_snapshot(BlockNum block_num, Block& block) const; std::optional read_header_from_snapshot(BlockNum block_num) const; std::optional read_header_from_snapshot(const Hash& hash) const; bool read_body_from_snapshot(BlockNum block_num, BlockBody& body) const; bool is_body_in_snapshot(BlockNum block_num) const; bool read_rlp_transactions_from_snapshot(BlockNum block_num, std::vector& rlp_txs) const; bool read_transactions_from_snapshot(BlockNum block_num, uint64_t base_txn_id, uint64_t txn_count, std::vector& txs) const; std::optional> read_tx_lookup_from_db(const evmc::bytes32& tx_hash) const; std::optional> read_tx_lookup_from_snapshot(const evmc::bytes32& tx_hash) const; ROTxn& txn_; const snapshots::SnapshotRepositoryROAccess& repository_; }; class DataModelFactory { public: explicit DataModelFactory(DataStoreRef data_store) : func_{[data_store = std::move(data_store)](db::ROTxn& tx) { return db::DataModel{tx, data_store.blocks_repository}; }} {} DataModel operator()(ROTxn& tx) const { return func_(tx); } //! Null factory only for mocks static DataModelFactory null() { return DataModelFactory{}; } private: //! Null factory only for mocks DataModelFactory() : func_{ [](ROTxn&) -> db::DataModel { SILKWORM_ASSERT(false); std::abort(); }, } {} std::function func_; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/access_layer_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "access_layer.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include "test_util/mock_ro_cursor.hpp" #include "test_util/mock_txn.hpp" namespace silkworm { static BlockBody sample_block_body() { BlockBody body; body.transactions.resize(2); body.transactions[0].nonce = 172339; body.transactions[0].max_priority_fee_per_gas = 50 * kGiga; body.transactions[0].max_fee_per_gas = 50 * kGiga; body.transactions[0].gas_limit = 90'000; body.transactions[0].to = 0xe5ef458d37212a06e3f59d40c454e76150ae7c32_address; body.transactions[0].value = 1'027'501'080 * kGiga; body.transactions[0].data = {}; CHECK(body.transactions[0].set_v(27)); body.transactions[0].r = intx::from_string("0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353"); body.transactions[0].s = intx::from_string("0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804"); body.transactions[1].type = TransactionType::kDynamicFee; body.transactions[1].nonce = 1; body.transactions[1].max_priority_fee_per_gas = 5 * kGiga; body.transactions[1].max_fee_per_gas = 30 * kGiga; body.transactions[1].gas_limit = 1'000'000; body.transactions[1].to = {}; body.transactions[1].value = 0; body.transactions[1].data = *from_hex("602a6000556101c960015560068060166000396000f3600035600055"); CHECK(body.transactions[1].set_v(37)); body.transactions[1].r = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); body.transactions[1].s = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); body.ommers.resize(1); body.ommers[0].parent_hash = 0xb397a22bb95bf14753ec174f02f99df3f0bdf70d1851cdff813ebf745f5aeb55_bytes32; body.ommers[0].ommers_hash = kEmptyListHash; body.ommers[0].beneficiary = 0x0c729be7c39543c3d549282a40395299d987cec2_address; body.ommers[0].state_root = 0xc2bcdfd012534fa0b19ffba5fae6fc81edd390e9b7d5007d1e92e8e835286e9d_bytes32; body.ommers[0].transactions_root = kEmptyRoot; body.ommers[0].receipts_root = kEmptyRoot; body.ommers[0].difficulty = 12'555'442'155'599; body.ommers[0].number = 13'000'013; body.ommers[0].gas_limit = 3'141'592; body.ommers[0].gas_used = 0; body.ommers[0].timestamp = 1455404305; body.ommers[0].prev_randao = 0xf0a53dfdd6c2f2a661e718ef29092de60d81d45f84044bec7bf4b36630b2bc08_bytes32; body.ommers[0].nonce[7] = 35; return body; } // https://etherscan.io/block/17035047 static BlockBody block_body_17035047() { constexpr evmc::address kRecipient1{0x40458B394D1C2A9aA095dd169a6EB43a73949fa3_address}; constexpr evmc::address kRecipient2{0xEdA2B3743d37a2a5bD4EB018d515DC47B7802EB4_address}; BlockBody body; body.withdrawals = std::vector{}; body.withdrawals->reserve(16); body.withdrawals->emplace_back(Withdrawal{2733, 157233, kRecipient1, 3148401251}); body.withdrawals->emplace_back(Withdrawal{2734, 157234, kRecipient1, 2797715671}); body.withdrawals->emplace_back(Withdrawal{2735, 157235, kRecipient1, 2987093215}); body.withdrawals->emplace_back(Withdrawal{2736, 157236, kRecipient1, 2917273462}); body.withdrawals->emplace_back(Withdrawal{2737, 157237, kRecipient1, 2873029573}); body.withdrawals->emplace_back(Withdrawal{2738, 157238, kRecipient1, 0316444461}); body.withdrawals->emplace_back(Withdrawal{2739, 157239, kRecipient1, 3076965697}); body.withdrawals->emplace_back(Withdrawal{2740, 157240, kRecipient1, 3264826534}); body.withdrawals->emplace_back(Withdrawal{2741, 157241, kRecipient1, 2959830042}); body.withdrawals->emplace_back(Withdrawal{2742, 157242, kRecipient1, 2858527882}); body.withdrawals->emplace_back(Withdrawal{2743, 157243, kRecipient1, 2972530438}); body.withdrawals->emplace_back(Withdrawal{2744, 157244, kRecipient1, 2897978772}); body.withdrawals->emplace_back(Withdrawal{2745, 157245, kRecipient1, 2946132889}); body.withdrawals->emplace_back(Withdrawal{2746, 157246, kRecipient1, 2918951932}); body.withdrawals->emplace_back(Withdrawal{2747, 157247, kRecipient1, 2902163625}); body.withdrawals->emplace_back(Withdrawal{2748, 157248, kRecipient2, 2846508033}); return body; } } // namespace silkworm namespace silkworm::db { using namespace silkworm::datastore::kvdb; using datastore::kvdb::to_slice; TEST_CASE("Methods cursor_for_each/cursor_for_count", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; ::mdbx::map_handle main_map{1}; auto main_stat{txn->get_map_stat(main_map)}; PooledCursor main_crs{txn, main_map}; std::vector table_names{}; const auto walk_func{[&table_names](ByteView key, ByteView) { table_names.emplace_back(byte_ptr_cast(key.data())); }}; main_crs.to_first(); cursor_for_each(main_crs, walk_func); CHECK(table_names.size() == sizeof(table::kChainDataTables) / sizeof(table::kChainDataTables[0])); CHECK(table_names.size() == main_stat.ms_entries); main_crs.to_first(); size_t max_count = table_names.size() - 1; table_names.clear(); cursor_for_count(main_crs, walk_func, max_count); CHECK(table_names.size() == max_count); } TEST_CASE("VersionBase primitives", "[db][access_layer]") { VersionBase v1{0, 0, 0}; VersionBase v2{0, 0, 1}; VersionBase v3{0, 0, 1}; CHECK(v1 != v2); CHECK(v2 > v1); CHECK(v2 >= v1); CHECK(v1 <= v2); CHECK(v2 == v3); } TEST_CASE("Sequences", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; auto val1{read_map_sequence(txn, table::kBlockTransactions.name)}; CHECK(val1 == 0); auto val2{increment_map_sequence(txn, table::kBlockTransactions.name, 5)}; CHECK(val2 == 0); auto val3{read_map_sequence(txn, table::kBlockTransactions.name)}; CHECK(val3 == 5); auto val4{increment_map_sequence(txn, table::kBlockTransactions.name, 3)}; CHECK(val4 == 5); auto val5{read_map_sequence(txn, table::kBlockTransactions.name)}; CHECK(val5 == 8); context.commit_and_renew_txn(); auto& txn2{context.rw_txn()}; auto val6{read_map_sequence(txn2, table::kBlockTransactions.name)}; CHECK(val6 == 8); // Reset sequence auto val7{reset_map_sequence(txn2, table::kBlockTransactions.name, 19)}; CHECK(val7 == 8); auto val8{read_map_sequence(txn2, table::kBlockTransactions.name)}; CHECK(val8 == 19); // Tamper with sequence Bytes fake_value(sizeof(uint32_t), '\0'); mdbx::slice key(table::kBlockTransactions.name); auto tgt{open_cursor(txn2, table::kSequence)}; tgt.upsert(key, to_slice(fake_value)); bool thrown{false}; try { (void)increment_map_sequence(txn, table::kBlockTransactions.name); } catch (const std::exception& ex) { REQUIRE(std::string(ex.what()) == "Bad sequence value in db"); thrown = true; } CHECK(thrown); } TEST_CASE("Schema Version", "[db][access_layer]") { test_util::TempChainData context(/*with_create_tables=*/false); SECTION("Read/Write") { auto version{read_schema_version(context.rw_txn())}; CHECK(version.has_value() == false); version = VersionBase{3, 0, 0}; CHECK_NOTHROW(write_schema_version(context.rw_txn(), version.value())); context.commit_and_renew_txn(); version = read_schema_version(context.rw_txn()); CHECK(version.has_value() == true); auto version2{read_schema_version(context.rw_txn())}; CHECK(version.value() == version2.value()); version2 = VersionBase{2, 0, 0}; CHECK_THROWS(write_schema_version(context.rw_txn(), version2.value())); version2 = VersionBase{3, 1, 0}; CHECK_NOTHROW(write_schema_version(context.rw_txn(), version2.value())); } SECTION("Incompatible schema") { // Reduce compat schema version constexpr VersionBase kIncompatibleVersion{table::kRequiredSchemaVersion.major - 1, 0, 0}; REQUIRE_NOTHROW(write_schema_version(context.rw_txn(), kIncompatibleVersion)); REQUIRE_THROWS(table::check_or_create_chaindata_tables(context.rw_txn())); } SECTION("Incompatible table") { (void)context.txn().create_map(table::kBlockBodies.name_str(), mdbx::key_mode::reverse, mdbx::value_mode::multi_reverse); REQUIRE_THROWS(table::check_or_create_chaindata_tables(context.rw_txn())); } } TEST_CASE("Storage and Prune Modes", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.txn()}; SECTION("Prune Mode") { BlockAmount block_amount; REQUIRE(block_amount.value() == 0); REQUIRE(block_amount.value_from_head(1'000'000) == 0); // Uninitialized mode PruneMode default_mode{}; CHECK(default_mode.to_string() == "--prune="); // No value in db -> no pruning { auto prune_mode{read_prune_mode(txn)}; CHECK(prune_mode.to_string() == "--prune="); CHECK_NOTHROW(write_prune_mode(txn, prune_mode)); auto db_prune_mode = std::make_unique(read_prune_mode(txn)); REQUIRE(prune_mode == *db_prune_mode); } // Cross-check we have the same value { auto prune_mode = read_prune_mode(txn); CHECK(prune_mode.to_string() == "--prune="); } // Write rubbish to prune mode { auto target{open_cursor(txn, table::kDatabaseInfo)}; std::string db_key{"pruneHistoryType"}; std::string db_value{"random"}; target.upsert(mdbx::slice(db_key), mdbx::slice(db_value)); bool has_thrown{false}; try { (void)read_prune_mode(txn); } catch (const std::runtime_error&) { has_thrown = true; } REQUIRE(has_thrown); db_value = "older"; target.upsert(mdbx::slice(db_key), mdbx::slice(db_value)); } // Provide different combinations of cli arguments std::string prune, expected; PruneDistance older_history, older_receipts, older_senders, older_tx_index, older_call_traces; PruneThreshold before_history, before_receipts, before_senders, before_tx_index, before_call_traces; prune = "hrstc"; expected = "--prune=hrstc"; { auto prune_mode = parse_prune_mode(prune, // older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces); REQUIRE(prune_mode.to_string() == expected); REQUIRE_NOTHROW(write_prune_mode(txn, prune_mode)); prune_mode = read_prune_mode(txn); REQUIRE(prune_mode.to_string() == expected); REQUIRE(prune_mode.history().value_from_head(10) == 0); } prune = "htc"; older_history.emplace(8000); older_senders.emplace(80000); before_receipts.emplace(10000); expected = "--prune=tc --prune.h.older=8000 --prune.r.before=10000 --prune.s.older=80000"; { auto prune_mode = parse_prune_mode(prune, // older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces); REQUIRE(prune_mode.to_string() == expected); REQUIRE_NOTHROW(write_prune_mode(txn, prune_mode)); prune_mode = read_prune_mode(txn); REQUIRE(prune_mode.to_string() == expected); REQUIRE(prune_mode.history() != prune_mode.receipts()); REQUIRE(prune_mode.tx_index() == prune_mode.call_traces()); } prune = "htc"; older_history.emplace(kFullImmutabilityThreshold); older_senders.reset(); before_receipts.emplace(10000); expected = "--prune=htc --prune.r.before=10000"; { auto prune_mode = parse_prune_mode(prune, // older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces); REQUIRE(prune_mode.to_string() == expected); REQUIRE_NOTHROW(write_prune_mode(txn, prune_mode)); prune_mode = read_prune_mode(txn); REQUIRE(prune_mode.to_string() == expected); REQUIRE(prune_mode.receipts().value() == 10000); REQUIRE(prune_mode.history().value() == kFullImmutabilityThreshold); } prune = "hrtc"; older_history.emplace(kFullImmutabilityThreshold + 5); before_receipts.reset(); before_call_traces.emplace(10000); expected = "--prune=rt --prune.h.older=90005 --prune.c.before=10000"; { auto prune_mode = parse_prune_mode(prune, // older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces); REQUIRE(prune_mode.to_string() == expected); REQUIRE_NOTHROW(write_prune_mode(txn, prune_mode)); prune_mode = read_prune_mode(txn); REQUIRE(prune_mode.to_string() == expected); REQUIRE(prune_mode.receipts().value() == kFullImmutabilityThreshold); REQUIRE(prune_mode.tx_index().value() == kFullImmutabilityThreshold); REQUIRE(prune_mode.call_traces().type() == BlockAmount::Type::kBefore); REQUIRE(prune_mode.history().value_from_head(1'000'000) == 909'995); REQUIRE(prune_mode.receipts().value_from_head(1'000'000) == 910'000); REQUIRE(prune_mode.tx_index().value_from_head(1'000'000) == 910'000); REQUIRE(prune_mode.call_traces().type() == BlockAmount::Type::kBefore); REQUIRE(prune_mode.call_traces().value_from_head(1'000'000) == 9'999); } } } TEST_CASE("Stages", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; // Querying a non-existent stage name should throw CHECK_THROWS(stages::read_stage_progress(txn, "NonExistentStage")); // Not valued stage should return 0 CHECK(stages::read_stage_progress(txn, stages::kBlockBodiesKey) == 0); // Value a stage progress and check returned value uint64_t block_num{0}; uint64_t expected_block_num{123456}; CHECK_NOTHROW(stages::write_stage_progress(txn, stages::kBlockBodiesKey, expected_block_num)); CHECK_NOTHROW(block_num = stages::read_stage_progress(txn, stages::kBlockBodiesKey)); CHECK(block_num == expected_block_num); // Write voluntary wrong value in stage Bytes stage_progress(2, 0); auto map{open_cursor(txn, table::kSyncStageProgress)}; CHECK_NOTHROW(txn->upsert(map, mdbx::slice{stages::kBlockBodiesKey}, to_slice(stage_progress))); CHECK_THROWS(block_num = stages::read_stage_progress(txn, stages::kBlockBodiesKey)); // Check "prune_" prefix CHECK_NOTHROW(stages::write_stage_prune_progress(txn, stages::kBlockBodiesKey, expected_block_num)); CHECK_NOTHROW(block_num = stages::read_stage_prune_progress(txn, stages::kBlockBodiesKey)); CHECK(block_num == expected_block_num); CHECK_NOTHROW(stages::write_stage_prune_progress(txn, stages::kBlockBodiesKey, 0)); CHECK(stages::read_stage_prune_progress(txn, stages::kBlockBodiesKey) == 0); } TEST_CASE("Difficulty", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; BlockNum block_num{10}; uint8_t hash[kHashLength]{}; intx::uint256 difficulty{10}; write_total_difficulty(txn, block_num, hash, difficulty); CHECK(read_total_difficulty(txn, block_num, hash) == difficulty); } TEST_CASE("Headers and bodies", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; uint64_t block_num{11'054'435}; BlockHeader header; header.number = block_num; header.beneficiary = 0x09ab1303d3ccaf5f018cd511146b07a240c70294_address; header.gas_limit = 12'451'080; header.gas_used = 12'443'619; Bytes rlp; rlp::encode(rlp, header); ethash::hash256 hash{keccak256(rlp)}; CHECK(!read_header(txn, header.number, hash.bytes)); // Write canonical header hash + header rlp CHECK_NOTHROW(write_canonical_header(txn, header)); CHECK_NOTHROW(write_header(txn, header, /*with_header_numbers=*/true)); // Read back canonical header hash auto db_hash{read_canonical_header_hash(txn, block_num)}; REQUIRE(db_hash.has_value()); REQUIRE(memcmp(hash.bytes, db_hash.value().bytes, sizeof(hash)) == 0); // Read canonical head auto [head_block_num, head_hash] = read_canonical_head(txn); REQUIRE(head_block_num == header.number); REQUIRE(head_hash == header.hash()); // Read non-existent canonical header hash db_hash = read_canonical_header_hash(txn, block_num + 1); REQUIRE(db_hash.has_value() == false); std::optional header_from_db{read_header(txn, header.number, hash.bytes)}; REQUIRE(header_from_db.has_value()); CHECK(*header_from_db == header); SECTION("read_block_by_number") { Block block; bool read_senders{false}; CHECK(!read_block_by_number(txn, block_num, read_senders, block)); BlockBody body{sample_block_body()}; CHECK_NOTHROW(write_body(txn, body, hash.bytes, header.number)); REQUIRE(read_block_by_number(txn, block_num, read_senders, block)); CHECK(block.header == header); CHECK(block.ommers == body.ommers); CHECK(block.transactions == body.transactions); read_senders = true; CHECK_NOTHROW(read_block_by_number(txn, block_num, read_senders, block)); Bytes full_senders{ *from_hex("5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c" "941591b6ca8e8dd05c69efdec02b77c72dac1496")}; REQUIRE(full_senders.size() == 2 * kAddressLength); Bytes key{block_key(header.number, hash.bytes)}; auto sender_table{open_cursor(txn, table::kSenders)}; sender_table.upsert(to_slice(key), to_slice(full_senders)); REQUIRE(read_block_by_number(txn, block_num, read_senders, block)); CHECK(block.header == header); CHECK(block.ommers == body.ommers); CHECK(block.transactions == body.transactions); CHECK(block.transactions[0].sender() == 0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c_address); CHECK(block.transactions[1].sender() == 0x941591b6ca8e8dd05c69efdec02b77c72dac1496_address); auto [b, h] = split_block_key(key); REQUIRE(b == header.number); REQUIRE(h == header.hash()); } SECTION("read_blocks") { BlockBody body{sample_block_body()}; CHECK_NOTHROW(write_body(txn, body, header.hash(), header.number)); size_t count = 0; auto processed = read_blocks( txn, block_num, [&count, &block_num](const Block& block) { REQUIRE(block.header.number == block_num); ++count; }); REQUIRE(processed == 1); REQUIRE(processed == count); BlockBody body2{sample_block_body()}; header.extra_data = string_view_to_byte_view("I'm different"); CHECK_NOTHROW(write_header(txn, header, /*with_header_numbers=*/true)); CHECK_NOTHROW(write_body(txn, body, header.hash(), header.number)); // another body at same block_num BlockBody body3{sample_block_body()}; header.number = header.number + 1; CHECK_NOTHROW(write_header(txn, header, /*with_header_numbers=*/true)); CHECK_NOTHROW(write_body(txn, body, hash.bytes, header.number)); // another body after the prev two count = 0; processed = read_blocks( txn, block_num, [&count, &block_num](const Block& block) { REQUIRE(block.header.number == block_num); ++count; }); REQUIRE(processed == 2); REQUIRE(processed == count); } } TEST_CASE("Storage", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; PooledCursor table{txn, table::kPlainState}; const evmc::address addr{0xb000000000000000000000000000000000000008_address}; const Bytes key{storage_prefix(addr, kDefaultIncarnation)}; const evmc::bytes32 loc1{0x000000000000000000000000000000000000a000000000000000000000000037_bytes32}; const evmc::bytes32 loc2{0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}; const evmc::bytes32 loc3{0xff00000000000000000000000000000000000000000000000000000000000017_bytes32}; const evmc::bytes32 loc4{0x00000000000000000000000000000000000000000000000000000000000f3128_bytes32}; const evmc::bytes32 val1{0x00000000000000000000000000000000000000000000000000000000c9b131a4_bytes32}; const evmc::bytes32 val2{0x000000000000000000000000000000000000000000005666856076ebaf477f07_bytes32}; const evmc::bytes32 val3{0x4400000000000000000000000000000000000000000000000000000000000000_bytes32}; upsert_storage_value(table, key, loc1.bytes, val1.bytes); upsert_storage_value(table, key, loc2.bytes, val2.bytes); upsert_storage_value(table, key, loc3.bytes, val3.bytes); CHECK(read_storage(txn, addr, kDefaultIncarnation, loc1) == val1); CHECK(read_storage(txn, addr, kDefaultIncarnation, loc2) == val2); CHECK(read_storage(txn, addr, kDefaultIncarnation, loc3) == val3); CHECK(read_storage(txn, addr, kDefaultIncarnation, loc4) == evmc::bytes32{}); } TEST_CASE("Account history", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; BlockNum block_num{42}; AccountChanges changes{read_account_changes(txn, block_num)}; CHECK(changes.empty()); const evmc::address account_address{0x63c696931d3d3fd7cd83472febd193488266660d_address}; const Account account{ .nonce = 21, .balance = 1 * kEther, .code_hash = kEmptyHash, .incarnation = 3, }; auto ah_cursor{txn.rw_cursor_dup_sort(table::kAccountHistory)}; auto acs_cursor{txn.rw_cursor_dup_sort(table::kAccountChangeSet)}; // Account change set for block_num Bytes acs_key{block_key(block_num)}; Bytes acs_data{ByteView{account_address}}; acs_data.append(state::AccountCodec::encode_for_storage(account)); acs_cursor->upsert(to_slice(acs_key), to_slice(acs_data)); Bytes ah_key{account_history_key(account_address, UINT64_MAX)}; roaring::Roaring64Map bitmap({block_num}); ah_cursor->upsert(to_slice(ah_key), to_slice(bitmap::to_bytes(bitmap))); std::optional previous_incarnation{read_previous_incarnation(txn, account_address, block_num - 1)}; REQUIRE(previous_incarnation.has_value()); CHECK(*previous_incarnation == account.incarnation - 1); } TEST_CASE("Account changes", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; uint64_t block_num1{42}; uint64_t block_num2{49}; uint64_t block_num3{50}; AccountChanges changes{read_account_changes(txn, block_num1)}; CHECK(changes.empty()); changes = read_account_changes(txn, block_num2); CHECK(changes.empty()); changes = read_account_changes(txn, block_num3); CHECK(changes.empty()); auto addr1{0x63c696931d3d3fd7cd83472febd193488266660d_address}; auto addr2{0xe439698beccd2acfba60eaa7f7b0b073bcebbdf9_address}; auto addr3{0x33564393ab248457df0e265107a86bdaf7b1470b_address}; auto addr4{0xaff7767097705df2dd0cc1c8b69071f6ff044aaa_address}; const char* val1{"c9b131a4"}; const char* val2{"076ebaf477f0"}; const char* val3{""}; const char* val4{"9a31634956ec64b6865a"}; auto table{open_cursor(txn, table::kAccountChangeSet)}; Bytes data1{ByteView{addr1}}; Bytes key1{block_key(block_num1)}; data1.append(*from_hex(val1)); table.upsert(to_slice(key1), to_slice(data1)); Bytes data2{ByteView{addr2}}; data2.append(*from_hex(val2)); table.upsert(to_slice(key1), to_slice(data2)); Bytes data3{ByteView{addr3}}; data3.append(*from_hex(val3)); table.upsert(to_slice(key1), to_slice(data3)); Bytes data4{ByteView{addr4}}; Bytes key2{block_key(block_num2)}; data4.append(*from_hex(val4)); table.upsert(to_slice(key2), to_slice(data4)); changes = read_account_changes(txn, block_num1); REQUIRE(changes.size() == 3); CHECK(to_hex(changes[addr1]) == val1); CHECK(to_hex(changes[addr2]) == val2); CHECK(to_hex(changes[addr3]) == val3); changes = read_account_changes(txn, block_num2); REQUIRE(changes.size() == 1); CHECK(to_hex(changes[addr4]) == val4); changes = read_account_changes(txn, block_num3); CHECK(changes.empty()); } TEST_CASE("Storage changes", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; uint64_t block_num1{42}; uint64_t block_num2{49}; uint64_t block_num3{50}; StorageChanges db_changes{read_storage_changes(txn, block_num1)}; CHECK(db_changes.empty()); db_changes = read_storage_changes(txn, block_num2); CHECK(db_changes.empty()); db_changes = read_storage_changes(txn, block_num3); CHECK(db_changes.empty()); auto addr1{0x63c696931d3d3fd7cd83472febd193488266660d_address}; auto addr2{addr1}; auto addr3{0x33564393ab248457df0e265107a86bdaf7b1470b_address}; auto addr4{0xaff7767097705df2dd0cc1c8b69071f6ff044aaa_address}; auto location1{0xb2559376a79a91a99e2a5b644fe9cafdce005b8ad5359c49645ce225e62e6ba5_bytes32}; auto location2{0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}; auto location3{0x23d623b732046203836a0ec6666856523b7b3ec4bf4290dd0b544aa6fa5e61ea_bytes32}; auto location4{0x0000000000000000000000000000000000000000000000000000000000000017_bytes32}; Bytes val1{*from_hex("c9b131a4")}; Bytes val2{*from_hex("068566685666856076ebaf477f07")}; Bytes val3{}; Bytes val4{*from_hex("9a31634956ec64b6865a")}; uint64_t incarnation1{1}; uint64_t incarnation2{1}; uint64_t incarnation3{3}; uint64_t incarnation4{1}; auto table{open_cursor(txn, table::kStorageChangeSet)}; Bytes data1{ByteView{location1}}; data1.append(val1); auto key1{storage_change_key(block_num1, addr1, incarnation1)}; table.upsert(to_slice(key1), to_slice(data1)); Bytes data2{ByteView{location2}}; data2.append(val2); auto key2{storage_change_key(block_num1, addr2, incarnation2)}; table.upsert(to_slice(key2), to_slice(data2)); Bytes data3{ByteView{location3}}; data3.append(val3); auto key3{storage_change_key(block_num1, addr3, incarnation3)}; table.upsert(to_slice(key3), to_slice(data3)); Bytes data4{ByteView{location4}}; data4.append(val4); auto key4{storage_change_key(block_num3, addr4, incarnation4)}; table.upsert(to_slice(key4), to_slice(data4)); CHECK(txn->get_map_stat(table.map()).ms_entries == 4); StorageChanges expected_changes1; expected_changes1[addr1][incarnation1][location1] = val1; expected_changes1[addr2][incarnation2][location2] = val2; expected_changes1[addr3][incarnation3][location3] = val3; db_changes = read_storage_changes(txn, block_num1); CHECK(db_changes.size() == expected_changes1.size()); CHECK(db_changes == expected_changes1); db_changes = read_storage_changes(txn, block_num2); CHECK(db_changes.empty()); StorageChanges expected_changes3; expected_changes3[addr4][incarnation4][location4] = val4; db_changes = read_storage_changes(txn, block_num3); CHECK(db_changes.size() == expected_changes3.size()); CHECK(db_changes == expected_changes3); } TEST_CASE("Chain config", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; const auto chain_config1{read_chain_config(txn)}; CHECK(chain_config1 == std::nullopt); auto canonical_hashes{open_cursor(txn, table::kCanonicalHashes)}; const Bytes genesis_block_key{block_key(0)}; canonical_hashes.upsert(to_slice(genesis_block_key), to_slice(kSepoliaGenesisHash)); const auto chain_config2{read_chain_config(txn)}; CHECK(chain_config2 == std::nullopt); auto config_table{open_cursor(txn, table::kConfig)}; const std::string sepolia_config_json{kSepoliaConfig.to_json().dump()}; config_table.upsert(to_slice(kSepoliaGenesisHash), mdbx::slice{sepolia_config_json.c_str()}); const auto chain_config3{read_chain_config(txn)}; CHECK(chain_config3 == kSepoliaConfig); } TEST_CASE("Head header", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; REQUIRE(read_head_header_hash(txn) == std::nullopt); REQUIRE_NOTHROW(write_head_header_hash(txn, kSepoliaGenesisHash)); REQUIRE(read_head_header_hash(txn).value() == kSepoliaGenesisHash); } TEST_CASE("Last Fork Choice", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; auto hash1 = 0xb397a22bb95bf14753ec174f02f99df3f0bdf70d1851cdff813ebf745f5aeb55_bytes32; auto hash2 = 0xc2bcdfd012534fa0b19ffba5fae6fc81edd390e9b7d5007d1e92e8e835286e9d_bytes32; auto hash3 = 0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804_bytes32; write_last_head_block(txn, hash1); write_last_safe_block(txn, hash2); write_last_finalized_block(txn, hash3); CHECK(read_last_head_block(txn) == hash1); CHECK(read_last_safe_block(txn) == hash2); CHECK(read_last_finalized_block(txn) == hash3); } TEST_CASE("read rlp encoded transactions", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; uint64_t block_num{11'054'435}; BlockHeader header; header.number = block_num; header.beneficiary = 0x09ab1303d3ccaf5f018cd511146b07a240c70294_address; header.gas_limit = 12'451'080; header.gas_used = 12'443'619; auto hash = header.hash(); BlockBody body{sample_block_body()}; CHECK_NOTHROW(write_body(txn, body, hash.bytes, header.number)); std::vector rlp_transactions; bool found = read_rlp_transactions(txn, header.number, hash, rlp_transactions); REQUIRE(found); REQUIRE(rlp_transactions.size() == body.transactions.size()); for (size_t i = 0; i < rlp_transactions.size(); ++i) { Bytes rlp_tx; CHECK_NOTHROW(rlp::encode(rlp_tx, body.transactions[i])); CHECK(rlp_transactions[i] == rlp_tx); } } TEST_CASE("write and read body w/ withdrawals", "[db][access_layer]") { test_util::TempChainData context; auto& txn{context.rw_txn()}; BlockHeader header; header.number = 17'035'047; header.beneficiary = 0xe688b84b23f322a994A53dbF8E15FA82CDB71127_address; header.gas_limit = 30'000'000; header.gas_used = 0; const auto hash = header.hash(); BlockBody body_in{block_body_17035047()}; CHECK_NOTHROW(write_body(txn, body_in, hash.bytes, header.number)); BlockBody body_out{}; CHECK_NOTHROW(read_body(txn, header.number, hash.bytes, false, body_out)); CHECK(body_out == body_in); } using testing::_; using testing::InvokeWithoutArgs; static void expect_mock_ro_cursor(test_util::MockROTxn& mock_ro_txn, test_util::MockROCursor* mock_ro_cursor) { EXPECT_CALL(mock_ro_txn, ro_cursor(_)) .WillOnce(InvokeWithoutArgs([=]() mutable -> std::unique_ptr { return std::unique_ptr(mock_ro_cursor); })); } struct AccessLayerTest { explicit AccessLayerTest() { expect_mock_ro_cursor(mock_ro_txn, mock_ro_cursor); } test_util::MockROTxn mock_ro_txn; test_util::MockROCursor* mock_ro_cursor = new test_util::MockROCursor; }; static constexpr Hash kBlockHash; // empty but it doesn't matter for the tests static constexpr ::mdbx::slice kValidBlockHashSlice{kBlockHash.bytes, kHashLength}; static constexpr ::mdbx::slice kInvalidBlockHashSlice{kBlockHash.bytes, 30}; static const Bytes kValidEncodedBlockNum{*from_hex("0000000000000002")}; static const Bytes kInvalidEncodedBlockNum{*from_hex("0002")}; TEST_CASE_METHOD(AccessLayerTest, "read_block_num", "[db][access_layer]") { const ::mdbx::slice valid_block_num_slice{kValidEncodedBlockNum}; const ::mdbx::slice invalid_block_num_slice{kInvalidEncodedBlockNum}; SECTION("valid block number") { EXPECT_CALL(*mock_ro_cursor, find(kValidBlockHashSlice, false)) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{kValidBlockHashSlice, valid_block_num_slice, /*.done=*/true}; })); CHECK(read_block_num(mock_ro_txn, kBlockHash) == 2); } SECTION("data not found") { EXPECT_CALL(*mock_ro_cursor, find(kValidBlockHashSlice, false)) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{::mdbx::slice{}, ::mdbx::slice{}, /*.done=*/false}; })); CHECK_FALSE(read_block_num(mock_ro_txn, kBlockHash)); } SECTION("invalid block number value size") { EXPECT_CALL(*mock_ro_cursor, find(kValidBlockHashSlice, false)) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{kValidBlockHashSlice, invalid_block_num_slice, /*.done=*/true}; })); CHECK_THROWS_AS(read_block_num(mock_ro_txn, kBlockHash), std::length_error); } } TEST_CASE_METHOD(AccessLayerTest, "read_canonical_head", "[db][access_layer]") { const ::mdbx::slice valid_block_num_slice{kValidEncodedBlockNum}; const ::mdbx::slice invalid_block_num_slice{kInvalidEncodedBlockNum}; SECTION("valid canonical head") { EXPECT_CALL(*mock_ro_cursor, to_last()) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{valid_block_num_slice, kValidBlockHashSlice, /*.done=*/true}; })); CHECK(read_canonical_head(mock_ro_txn) == std::tuple{2, kBlockHash}); } SECTION("data not found") { EXPECT_CALL(*mock_ro_cursor, to_last()) .WillOnce(InvokeWithoutArgs([]() mutable -> CursorResult { return CursorResult{::mdbx::slice{}, ::mdbx::slice{}, /*.done=*/false}; })); CHECK(read_canonical_head(mock_ro_txn) == std::tuple{}); } SECTION("invalid key size") { EXPECT_CALL(*mock_ro_cursor, to_last()) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{invalid_block_num_slice, kValidBlockHashSlice, /*.done=*/true}; })); CHECK_THROWS_AS(read_canonical_head(mock_ro_txn), std::length_error); } SECTION("invalid value size") { EXPECT_CALL(*mock_ro_cursor, to_last()) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{valid_block_num_slice, kInvalidBlockHashSlice, /*.done=*/true}; })); CHECK_THROWS_AS(read_canonical_head(mock_ro_txn), std::length_error); } } TEST_CASE_METHOD(AccessLayerTest, "read_canonical_header_hash", "[db][access_layer]") { BlockNum block_num{2}; const auto block_num_key{block_key(block_num)}; const ::mdbx::slice block_key_slice{to_slice(block_num_key)}; SECTION("valid canonical header hash") { EXPECT_CALL(*mock_ro_cursor, find(block_key_slice, false)) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{block_key_slice, kValidBlockHashSlice, /*.done=*/true}; })); CHECK(read_canonical_header_hash(mock_ro_txn, block_num) == kBlockHash); } SECTION("data not found") { EXPECT_CALL(*mock_ro_cursor, find(block_key_slice, false)) .WillOnce(InvokeWithoutArgs([]() mutable -> CursorResult { return CursorResult{::mdbx::slice{}, ::mdbx::slice{}, /*.done=*/false}; })); CHECK_FALSE(read_canonical_header_hash(mock_ro_txn, block_num)); } SECTION("invalid value size") { EXPECT_CALL(*mock_ro_cursor, find(block_key_slice, false)) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{block_key_slice, kInvalidBlockHashSlice, /*.done=*/true}; })); CHECK_THROWS_AS(read_canonical_header_hash(mock_ro_txn, block_num), std::length_error); } } TEST_CASE_METHOD(AccessLayerTest, "read_block_by_number", "[db][access_layer]") { BlockNum block_num{2}; const auto block_num_key{block_key(block_num)}; const ::mdbx::slice block_key_slice{to_slice(block_num_key)}; Block block; SECTION("data not found") { EXPECT_CALL(*mock_ro_cursor, find(block_key_slice, false)) .WillOnce(InvokeWithoutArgs([]() mutable -> CursorResult { return CursorResult{::mdbx::slice{}, ::mdbx::slice{}, false}; })); CHECK_FALSE(read_block_by_number(mock_ro_txn, block_num, /*read_senders=*/false, block)); } SECTION("invalid value size") { EXPECT_CALL(*mock_ro_cursor, find(block_key_slice, false)) .WillOnce(InvokeWithoutArgs([=]() mutable -> CursorResult { return CursorResult{block_key_slice, kInvalidBlockHashSlice, true}; })); CHECK_THROWS_AS(read_block_by_number(mock_ro_txn, block_num, /*read_senders=*/false, block), std::length_error); } } } // namespace silkworm::db ================================================ FILE: silkworm/db/bitmap_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include namespace silkworm::datastore::kvdb::bitmap { using namespace silkworm::db; static void cut_everything(roaring::Roaring& bm, uint64_t limit) { while (bm.cardinality() > 0) { const auto original{bm}; const auto left{cut_left(bm, limit)}; CHECK((left & bm).isEmpty()); CHECK((left | bm) == original); const auto left_size{left.getSizeInBytes()}; CHECK(left_size <= limit); if (bm.isEmpty()) { CHECK(left_size > 0); } else { CHECK(left_size > limit - 256); } } } TEST_CASE("Roaring Bitmaps") { SECTION("Operator -=") { // Building from ranges implies [a,b) auto minuend_bitmap{roaring::Roaring64Map(roaring::api::roaring_bitmap_from_range(1, 101, 1))}; auto subtrahend_bitmap{roaring::Roaring64Map(roaring::api::roaring_bitmap_from_range(1, 25, 1))}; minuend_bitmap -= subtrahend_bitmap; REQUIRE(minuend_bitmap.minimum() == 25); REQUIRE(minuend_bitmap.cardinality() == 76); minuend_bitmap = roaring::Roaring64Map(roaring::api::roaring_bitmap_from_range(1, 101, 1)); subtrahend_bitmap = roaring::Roaring64Map(roaring::api::roaring_bitmap_from_range(1, 110, 1)); minuend_bitmap -= subtrahend_bitmap; REQUIRE(minuend_bitmap.isEmpty()); } SECTION("To/From Bytes") { auto original_bitmap{roaring::Roaring64Map(roaring::api::roaring_bitmap_from_range(1, 101, 1))}; Bytes bitmap_data{bitmap::to_bytes(original_bitmap)}; auto loaded_bitmap{bitmap::parse(bitmap_data)}; REQUIRE(original_bitmap == loaded_bitmap); original_bitmap.clear(); REQUIRE(bitmap::to_bytes(original_bitmap).empty()); } SECTION("cut_left1") { for (size_t mdbx_page_size{1_Kibi}; mdbx_page_size < 32_Kibi; mdbx_page_size *= 2) { static const size_t kBitmapChunkLimit{max_value_size_for_leaf_page(mdbx_page_size, 0)}; roaring::Roaring64Map bitmap(roaring::api::roaring_bitmap_from_range(0, 100000, 1)); roaring::Roaring64Map expected(roaring::api::roaring_bitmap_from_range(0, 100000, 1)); roaring::Roaring64Map actual; std::vector bitmap_chunks; while (bitmap.cardinality() != 0) { bitmap_chunks.push_back(cut_left(bitmap, kBitmapChunkLimit)); } for (const auto& chunk : bitmap_chunks) { actual |= chunk; } CHECK(actual == expected); } } SECTION("cut_left2") { roaring::Roaring bm; for (uint64_t j{0}; j < 10'000; j += 20) { bm.addRange(j, j + 10); } SECTION("limit=1024") { cut_everything(bm, 1024); } SECTION("limit=2048") { cut_everything(bm, 2048); } } SECTION("cut_left3") { roaring::Roaring bm; bm.add(1); const uint64_t limit{2048}; const auto lft{cut_left(bm, limit)}; CHECK(lft.getSizeInBytes() > 0); CHECK(lft.cardinality() == 1); CHECK(bm.cardinality() == 0); } } TEST_CASE("Bitmap Index Loader") { test_util::TempChainData context; RWTxn& txn{context.rw_txn()}; const evmc::address address1{0x00000000000000000001_address}; const evmc::address address2{0x00000000000000000002_address}; const evmc::address address3{0x00000000000000000003_address}; // Note range is [min,max) roaring::Roaring64Map roaring1{roaring::api::roaring_bitmap_from_range(1, 20'001, 1)}; roaring::Roaring64Map roaring2{roaring::api::roaring_bitmap_from_range(1, 50'001, 1)}; roaring::Roaring64Map roaring3{roaring::api::roaring_bitmap_from_range(40'000, 50'001, 1)}; absl::btree_map bitmaps{ {Bytes(address1.bytes, kAddressLength), roaring1}, {Bytes(address2.bytes, kAddressLength), roaring2}, {Bytes(address3.bytes, kAddressLength), roaring3}, }; datastore::kvdb::Collector collector(context.dir().temp().path()); IndexLoader bm_loader(table::kLogAddressIndex); IndexLoader::flush_bitmaps_to_etl(bitmaps, &collector, /*flush_count=*/1); REQUIRE(collector.bytes_size()); // Load into LogAddressIndex REQUIRE_NOTHROW(bm_loader.merge_bitmaps(txn, kAddressLength, &collector)); PooledCursor log_addresses(txn, table::kLogAddressIndex); REQUIRE(log_addresses.size() > bitmaps.size()); // Check we have an incomplete shard for each key Bytes key(address1.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); auto data{log_addresses.find(to_slice(key), /*throw_notfound=*/false)}; REQUIRE(data.done); auto loaded_bitmap{bitmap::parse(data.value)}; REQUIRE(loaded_bitmap.maximum() == 20'000); key.assign(address2.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); data = log_addresses.find(to_slice(key), /*throw_notfound=*/false); REQUIRE(data.done); loaded_bitmap = bitmap::parse(data.value); REQUIRE(loaded_bitmap.maximum() == 50'000); key.assign(address3.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); data = log_addresses.find(to_slice(key), /*throw_notfound=*/false); REQUIRE(data.done); loaded_bitmap = bitmap::parse(data.value); REQUIRE(loaded_bitmap.maximum() == 50'000); // Unwind to 30'000 std::map ubm{ {Bytes(address1.bytes, kAddressLength), false}, {Bytes(address2.bytes, kAddressLength), false}, {Bytes(address3.bytes, kAddressLength), false}, }; REQUIRE_NOTHROW(bm_loader.unwind_bitmaps(txn, 30'000, ubm)); // First address stays the same key.assign(address1.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); data = log_addresses.find(to_slice(key), /*throw_notfound=*/false); REQUIRE(data.done); loaded_bitmap = bitmap::parse(data.value); REQUIRE(loaded_bitmap.maximum() == 20'000); // Second address has decreased to 30'000 key.assign(address2.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); data = log_addresses.find(to_slice(key), /*throw_notfound=*/false); REQUIRE(data.done); loaded_bitmap = bitmap::parse(data.value); REQUIRE(loaded_bitmap.maximum() == 30'000); // Third address should be gone key.assign(address3.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); data = log_addresses.find(to_slice(key), /*throw_notfound=*/false); REQUIRE_FALSE(data.done); // Now prune up to 25000 // Note that all blocks <= threshold are removed REQUIRE_NOTHROW(bm_loader.prune_bitmaps(txn, 25'000)); // First address is gone key.assign(address1.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); data = log_addresses.find(to_slice(key), /*throw_notfound=*/false); REQUIRE_FALSE(data.done); // Second address has a new minimum key.assign(address2.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); data = log_addresses.find(to_slice(key), /*throw_notfound=*/false); REQUIRE(data.done); loaded_bitmap = bitmap::parse(data.value); REQUIRE(loaded_bitmap.maximum() == 30'000); REQUIRE(loaded_bitmap.minimum() == 25'001); REQUIRE(bm_loader.get_current_key().empty()); } } // namespace silkworm::datastore::kvdb::bitmap ================================================ FILE: silkworm/db/blocks/blocks_index_builders_factory.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "blocks_index_builders_factory.hpp" #include #include #include #include #include #include #include namespace silkworm::db::blocks { using namespace snapshots; std::vector> BlocksIndexBuildersFactory::index_builders(const SnapshotPath& segment_path) const { auto names = schema_.entity_name_by_path(segment_path); if (!names) { SILKWORM_ASSERT(false); return {}; } datastore::EntityName name = names->second; { if (name == db::blocks::kHeaderSegmentName) return {std::make_shared(HeaderIndex::make(segment_path))}; if (name == db::blocks::kBodySegmentName) return {std::make_shared(BodyIndex::make(segment_path))}; if (name == db::blocks::kTxnSegmentName) { auto bodies_segment_path = segment_path.related_path(std::string{db::blocks::kBodySegmentTag}, db::blocks::kSegmentExtension); if (!bodies_segment_path.exists()) return {}; return { std::make_shared(TransactionIndex::make(bodies_segment_path, segment_path)), std::make_shared(TransactionToBlockIndex::make(bodies_segment_path, segment_path)), }; } SILKWORM_ASSERT(false); return {}; } } SnapshotPathList BlocksIndexBuildersFactory::index_dependency_paths(const SnapshotPath& index_path) const { auto names = schema_.entity_name_by_path(index_path); if (!names) { SILKWORM_ASSERT(false); std::abort(); } datastore::EntityName name = names->second; datastore::EntityName segment_name = [name]() -> datastore::EntityName { if (name == db::blocks::kIdxHeaderHashName) return db::blocks::kHeaderSegmentName; if (name == db::blocks::kIdxBodyNumberName) return db::blocks::kBodySegmentName; if (name == db::blocks::kIdxTxnHashName) return db::blocks::kTxnSegmentName; if (name == db::blocks::kIdxTxnHash2BlockName) return db::blocks::kTxnSegmentName; SILKWORM_ASSERT(false); std::abort(); }(); auto& segment_tag = schema_.entities().at(Schema::kDefaultEntityName)->files().at(segment_name)->tag(); SnapshotPath snapshot_path = index_path.related_path(segment_tag, db::blocks::kSegmentExtension); return {snapshot_path}; } } // namespace silkworm::db::blocks ================================================ FILE: silkworm/db/blocks/blocks_index_builders_factory.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db::blocks { class BlocksIndexBuildersFactory : public snapshots::IndexBuildersFactory { public: explicit BlocksIndexBuildersFactory(snapshots::Schema::RepositoryDef schema) : schema_{std::move(schema)} {} ~BlocksIndexBuildersFactory() override = default; std::vector> index_builders(const snapshots::SnapshotPath& segment_path) const override; snapshots::SnapshotPathList index_dependency_paths(const snapshots::SnapshotPath& index_path) const override; private: snapshots::Schema::RepositoryDef schema_; }; } // namespace silkworm::db::blocks ================================================ FILE: silkworm/db/blocks/bodies/body_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "body_index.hpp" #include namespace silkworm::snapshots { Bytes BodyIndex::KeyFactory::make(ByteView /*key_data*/, uint64_t i) { Bytes uint64_buffer; seg::varint::encode(uint64_buffer, i); return uint64_buffer; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/bodies/body_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "../schema_config.hpp" #include "../step_block_num_converter.hpp" namespace silkworm::snapshots { class BodyIndex { public: static IndexBuilder make(SnapshotPath segment_path, std::optional segment_region = std::nullopt) { auto descriptor = make_descriptor(segment_path); auto query = std::make_unique(std::move(segment_path), segment_region); return IndexBuilder{std::move(descriptor), std::move(query)}; } struct KeyFactory : IndexKeyFactory { ~KeyFactory() override = default; Bytes make(ByteView key_data, uint64_t i) override; }; private: static IndexDescriptor make_descriptor(const SnapshotPath& segment_path) { auto step_converter = db::blocks::kStepToBlockNumConverter; return { .index_file = segment_path.related_path_ext(db::blocks::kIdxExtension), .key_factory = std::make_unique(), .base_data_id = step_converter.timestamp_from_step(segment_path.step_range().start), }; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/bodies/body_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../schema_config.hpp" #include "body_segment.hpp" namespace silkworm::snapshots { using BodyFindByBlockNumSegmentQuery = FindByIdSegmentQuery; using RawBodyFindByBlockNumSegmentQuery = FindByIdSegmentQuery, db::blocks::kBodySegmentAndIdxNames>; struct BodyFindByBlockNumQuery : public FindByTimestampMapQuery { using FindByTimestampMapQuery::FindByTimestampMapQuery; std::optional exec(BlockNum block_num) { return FindByTimestampMapQuery::exec(block_num, block_num); } }; struct RawBodyFindByBlockNumQuery : public FindByTimestampMapQuery { using FindByTimestampMapQuery::FindByTimestampMapQuery; std::optional exec(BlockNum block_num) { return FindByTimestampMapQuery::exec(block_num, block_num); } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/bodies/body_segment.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "body_segment.hpp" #include namespace silkworm::snapshots { void encode_word_from_body(Bytes& word, const BlockBodyForStorage& body) { word = body.encode(); } void decode_word_into_body(ByteView word, BlockBodyForStorage& body) { const auto result = decode_stored_block_body(word, body); success_or_throw(result, "decode_word_into_body: decode_stored_block_body error"); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/bodies/body_segment.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::snapshots { void encode_word_from_body(Bytes& word, const BlockBodyForStorage& body); void decode_word_into_body(ByteView word, BlockBodyForStorage& body); struct BodySegmentWordEncoder : public Encoder { BlockBodyForStorage value; Bytes word; ~BodySegmentWordEncoder() override = default; ByteView encode_word() override { word.clear(); encode_word_from_body(word, value); return word; } }; static_assert(EncoderConcept); struct BodySegmentWordDecoder : public Decoder { BlockBodyForStorage value; ~BodySegmentWordDecoder() override = default; void decode_word(Word& word) override { decode_word_into_body(word, value); } }; static_assert(DecoderConcept); using BodySegmentReader = segment::SegmentReader; using BodySegmentWriter = segment::SegmentWriter; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/bodies/body_segment_collation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "body_segment_collation.hpp" #include #include #include #include "body_segment.hpp" namespace silkworm::db { using namespace silkworm::datastore::kvdb; using namespace datastore; void BodySegmentCollation::copy(ROTxn& txn, const SegmentCollationCommand& command, snapshots::segment::SegmentFileWriter& file_writer) const { BlockNumRange range = command.range; uint64_t base_txn_id = command.base_txn_id; snapshots::BodySegmentWriter writer{file_writer}; auto out = writer.out(); for (BlockNum i = range.start; i < range.end; ++i) { auto value_opt = read_canonical_body_for_storage(txn, i); if (!value_opt) throw std::runtime_error{"BodySegmentCollation::copy missing body for block " + std::to_string(i)}; BlockBodyForStorage& value = *value_opt; // remap to sequential values without gaps (see txnum.go) value.base_txn_id = base_txn_id; base_txn_id += value.txn_count; *out++ = value; } } void BodySegmentCollation::prune(RWTxn& txn, BlockNumRange range) const { for (BlockNum i = range.start, count = 1; i < range.end; ++i, ++count) { auto hash_opt = read_canonical_header_hash(txn, i); if (!hash_opt) continue; auto hash = *hash_opt; delete_body(txn, hash, i); if ((count > 10000) && ((count % 10000) == 0)) { SILK_DEBUG_M("BodySegmentCollation") << "cleaned up until block " << i; } } } } // namespace silkworm::db ================================================ FILE: silkworm/db/blocks/bodies/body_segment_collation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::db { class BodySegmentCollation : public datastore::SegmentCollation { public: ~BodySegmentCollation() override = default; void copy(datastore::kvdb::ROTxn& txn, const datastore::SegmentCollationCommand& command, snapshots::segment::SegmentFileWriter& file_writer) const override; void prune(datastore::kvdb::RWTxn& txn, BlockNumRange range) const override; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/blocks/bodies/body_txs_amount_query.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "body_txs_amount_query.hpp" #include #include "body_segment.hpp" namespace silkworm::snapshots { BodyTxsAmountSegmentQuery::Result BodyTxsAmountSegmentQuery::exec() { size_t body_count = segment_.item_count(); if (body_count == 0) { throw std::runtime_error("BodyTxsAmountSegmentQuery empty body snapshot: " + segment_.path().path().string()); } BodySegmentReader reader{segment_}; auto it = reader.begin(); uint64_t first_tx_id = it->base_txn_id; it += body_count - 1; auto& last_body = *it; uint64_t end_tx_id = last_body.base_txn_id + last_body.txn_count; uint64_t count = end_tx_id - first_tx_id; return Result{ first_tx_id, count, }; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/bodies/body_txs_amount_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::snapshots { class BodyTxsAmountSegmentQuery { public: struct Result { uint64_t first_tx_id{}; uint64_t count{}; }; explicit BodyTxsAmountSegmentQuery(const segment::SegmentFileReader& segment) : segment_(segment) {} Result exec(); private: const segment::SegmentFileReader& segment_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/bodies/body_txs_amount_query_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "body_txs_amount_query.hpp" #include #include #include #include #include #include namespace silkworm::snapshots { TEST_CASE("BodyTxsAmountSegmentQuery") { TemporaryDirectory tmp_dir; test_util::SampleBodySnapshotFile snapshot_file{tmp_dir.path()}; segment::SegmentFileReader snapshot{snapshot_file.path(), db::blocks::kStepToBlockNumConverter}; BodyTxsAmountSegmentQuery query{snapshot}; auto result = query.exec(); CHECK(result.first_tx_id == 7'341'262); CHECK(result.count == 12); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/headers/header_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "header_index.hpp" #include #include namespace silkworm::snapshots { Bytes HeaderIndex::KeyFactory::make(ByteView key_data, uint64_t i) { auto word = key_data; ensure(!word.empty(), [&]() { return "HeaderIndex: word empty i=" + std::to_string(i); }); const uint8_t first_hash_byte{word[0]}; const ByteView rlp_encoded_header{word.data() + 1, word.size() - 1}; const ethash::hash256 hash = keccak256(rlp_encoded_header); ensure(hash.bytes[0] == first_hash_byte, [&]() { return "HeaderIndex: invalid prefix=" + to_hex(first_hash_byte) + " hash=" + to_hex(hash.bytes); }); return Bytes{ByteView{hash.bytes}}; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/headers/header_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "../schema_config.hpp" #include "../step_block_num_converter.hpp" namespace silkworm::snapshots { class HeaderIndex { public: static IndexBuilder make(SnapshotPath segment_path, std::optional segment_region = std::nullopt) { auto descriptor = make_descriptor(segment_path); auto query = std::make_unique(std::move(segment_path), segment_region); return IndexBuilder{std::move(descriptor), std::move(query)}; } struct KeyFactory : IndexKeyFactory { ~KeyFactory() override = default; Bytes make(ByteView key_data, uint64_t i) override; }; private: static IndexDescriptor make_descriptor(const SnapshotPath& segment_path) { auto step_converter = db::blocks::kStepToBlockNumConverter; return { .index_file = segment_path.related_path_ext(db::blocks::kIdxExtension), .key_factory = std::make_unique(), .base_data_id = step_converter.timestamp_from_step(segment_path.step_range().start), }; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/headers/header_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../schema_config.hpp" #include "header_segment.hpp" namespace silkworm::snapshots { using HeaderFindByBlockNumSegmentQuery = FindByIdSegmentQuery; struct HeaderFindByBlockNumQuery : public FindByTimestampMapQuery { using FindByTimestampMapQuery::FindByTimestampMapQuery; std::optional exec(BlockNum block_num) { return FindByTimestampMapQuery::exec(block_num, block_num); } }; using HeaderFindByHashSegmentQuery = FindByHashSegmentQuery; using HeaderFindByHashQuery = FindMapQuery; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/headers/header_segment.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "header_segment.hpp" #include #include #include "../step_block_num_converter.hpp" namespace silkworm::snapshots { void encode_word_from_header(Bytes& word, const BlockHeader& header) { auto hash = header.hash(); word.push_back(hash.bytes[0]); rlp::encode(word, header); } void decode_word_into_header(ByteView word, BlockHeader& header) { // First byte in data is first byte of header hash. ensure(!word.empty(), [&]() { return "decode_word_into_header: first hash byte missing"; }); // Skip hash first byte to obtain encoded header RLP data ByteView encoded_header{word.data() + 1, word.size() - 1}; const auto decode_result = rlp::decode(encoded_header, header); success_or_throw(decode_result, "decode_word_into_header: rlp::decode error"); } void check_sanity_of_header_with_metadata( const BlockHeader& header, datastore::StepRange step_range, const datastore::StepToTimestampConverter& step_converter) { auto block_num_range = step_converter.timestamp_range_from_step_range(step_range); BlockNum block_from = block_num_range.start; BlockNum block_to = block_num_range.end; ensure((header.number >= block_from) && (header.number < block_to), [&]() { return "check_sanity_of_header_with_metadata: header.number=" + std::to_string(header.number) + " outside of range [" + std::to_string(block_from) + ", " + std::to_string(block_to) + ")"; }); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/headers/header_segment.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::snapshots { void encode_word_from_header(Bytes& word, const BlockHeader& header); void decode_word_into_header(ByteView word, BlockHeader& header); void check_sanity_of_header_with_metadata( const BlockHeader& header, datastore::StepRange step_range, const datastore::StepToTimestampConverter& step_converter); struct HeaderSegmentWordEncoder : public Encoder { BlockHeader value; Bytes word; ~HeaderSegmentWordEncoder() override = default; ByteView encode_word() override { word.clear(); encode_word_from_header(word, value); return word; } }; static_assert(EncoderConcept); struct HeaderSegmentWordDecoder : public Decoder { BlockHeader value; ~HeaderSegmentWordDecoder() override = default; void decode_word(Word& word) override { decode_word_into_header(word, value); } void check_sanity_with_metadata(const SnapshotPath& path, const datastore::StepToTimestampConverter& step_converter) override { check_sanity_of_header_with_metadata(value, path.step_range(), step_converter); } }; static_assert(DecoderConcept); using HeaderSegmentReader = segment::SegmentReader; using HeaderSegmentWriter = segment::SegmentWriter; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/headers/header_segment_collation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "header_segment_collation.hpp" #include #include #include #include "header_segment.hpp" namespace silkworm::db { using namespace silkworm::datastore::kvdb; using namespace datastore; void HeaderSegmentCollation::copy(ROTxn& txn, const SegmentCollationCommand& command, snapshots::segment::SegmentFileWriter& file_writer) const { BlockNumRange range = command.range; snapshots::HeaderSegmentWriter writer{file_writer}; auto out = writer.out(); for (BlockNum i = range.start; i < range.end; ++i) { auto value_opt = read_canonical_header(txn, i); if (!value_opt) throw std::runtime_error{"HeaderSegmentCollation::copy missing header for block " + std::to_string(i)}; *out++ = *value_opt; } } void HeaderSegmentCollation::prune(RWTxn& txn, BlockNumRange range) const { for (BlockNum i = range.start, count = 1; i < range.end; ++i, ++count) { auto hash_opt = read_canonical_header_hash(txn, i); if (!hash_opt) continue; auto& hash = *hash_opt; delete_header(txn, i, hash); if ((count > 10000) && ((count % 10000) == 0)) { SILK_DEBUG_M("HeaderSegmentCollation") << "cleaned up until block " << i; } } } } // namespace silkworm::db ================================================ FILE: silkworm/db/blocks/headers/header_segment_collation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::db { class HeaderSegmentCollation : public datastore::SegmentCollation { public: ~HeaderSegmentCollation() override = default; void copy(datastore::kvdb::ROTxn& txn, const datastore::SegmentCollationCommand& command, snapshots::segment::SegmentFileWriter& file_writer) const override; void prune(datastore::kvdb::RWTxn& txn, BlockNumRange range) const override; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/blocks/schema_config.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "schema_config.hpp" #include "blocks_index_builders_factory.hpp" #include "step_block_num_converter.hpp" namespace silkworm::db::blocks { snapshots::Schema::RepositoryDef make_blocks_repository_schema() { snapshots::Schema::RepositoryDef repository_schema; repository_schema.index_salt_file_name("salt-blocks.txt"); repository_schema.step_size(kStepSizeForBlockSnapshots); snapshots::Schema::EntityDef& schema = repository_schema.default_entity(); schema.segment(kHeaderSegmentName) .tag(kHeaderSegmentTag) .file_ext(kSegmentExtension); schema.accessor_index(kIdxHeaderHashName) .tag(kIdxHeaderHashTag) .file_ext(kIdxExtension); schema.segment(kBodySegmentName) .tag(kBodySegmentTag) .file_ext(kSegmentExtension); schema.accessor_index(kIdxBodyNumberName) .tag(kIdxBodyNumberTag) .file_ext(kIdxExtension); schema.segment(kTxnSegmentName) .tag(kTxnSegmentTag) .file_ext(kSegmentExtension); schema.accessor_index(kIdxTxnHashName) .tag(kIdxTxnHashTag) .file_ext(kIdxExtension); schema.accessor_index(kIdxTxnHash2BlockName) .tag(kIdxTxnHash2BlockTag) .file_ext(kIdxExtension); return repository_schema; } std::unique_ptr make_blocks_index_builders_factory() { return std::make_unique(make_blocks_repository_schema()); } snapshots::SnapshotRepository make_blocks_repository( std::filesystem::path dir_path, bool open, std::optional index_salt) { auto schema = make_blocks_repository_schema(); return snapshots::SnapshotRepository{ kBlocksRepositoryName, std::move(dir_path), open, schema, index_salt, make_blocks_index_builders_factory(), }; } } // namespace silkworm::db::blocks ================================================ FILE: silkworm/db/blocks/schema_config.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../datastore/common/entity_name.hpp" #include "../datastore/snapshots/index_builders_factory.hpp" #include "../datastore/snapshots/schema.hpp" #include "../datastore/snapshots/snapshot_repository.hpp" namespace silkworm::db::blocks { inline const datastore::EntityName kBlocksRepositoryName{"Blocks"}; inline constexpr std::string_view kSegmentExtension{".seg"}; inline constexpr std::string_view kIdxExtension{".idx"}; snapshots::Schema::RepositoryDef make_blocks_repository_schema(); std::unique_ptr make_blocks_index_builders_factory(); snapshots::SnapshotRepository make_blocks_repository( std::filesystem::path dir_path, bool open = true, std::optional index_salt = std::nullopt); inline const datastore::EntityName kHeaderSegmentName{"headers"}; inline constexpr std::string_view kHeaderSegmentTag{"headers"}; //! Index header_hash -> block_num -> headers_segment_offset inline const datastore::EntityName kIdxHeaderHashName{"headers.idx"}; inline constexpr std::string_view kIdxHeaderHashTag = kHeaderSegmentTag; inline const snapshots::SegmentAndAccessorIndexNames kHeaderSegmentAndIdxNames{ snapshots::Schema::kDefaultEntityName, kHeaderSegmentName, kIdxHeaderHashName, }; inline const datastore::EntityName kBodySegmentName{"bodies"}; inline constexpr std::string_view kBodySegmentTag{"bodies"}; //! Index block_num -> bodies_segment_offset inline const datastore::EntityName kIdxBodyNumberName{"bodies.idx"}; inline constexpr std::string_view kIdxBodyNumberTag = kBodySegmentTag; inline const snapshots::SegmentAndAccessorIndexNames kBodySegmentAndIdxNames{ snapshots::Schema::kDefaultEntityName, kBodySegmentName, kIdxBodyNumberName, }; inline const datastore::EntityName kTxnSegmentName{"transactions"}; inline constexpr std::string_view kTxnSegmentTag{"transactions"}; //! Index transaction_hash -> txn_id -> transactions_segment_offset inline const datastore::EntityName kIdxTxnHashName{"transactions.idx"}; inline constexpr std::string_view kIdxTxnHashTag = kTxnSegmentTag; inline const snapshots::SegmentAndAccessorIndexNames kTxnSegmentAndIdxNames{ snapshots::Schema::kDefaultEntityName, kTxnSegmentName, kIdxTxnHashName, }; //! Index transaction_hash -> block_num inline const datastore::EntityName kIdxTxnHash2BlockName{"transactions-to-block.idx"}; inline constexpr std::string_view kIdxTxnHash2BlockTag{"transactions-to-block"}; struct BundleDataRef { const snapshots::SnapshotBundleData& data; const snapshots::SnapshotBundleEntityData& entity_data() const { return data.entities.at(snapshots::Schema::kDefaultEntityName); } const snapshots::segment::SegmentFileReader& header_segment() const { return entity_data().segments.at(kHeaderSegmentName); } const snapshots::rec_split::AccessorIndex& idx_header_hash() const { return entity_data().accessor_indexes.at(kIdxHeaderHashName); } const snapshots::segment::SegmentFileReader& body_segment() const { return entity_data().segments.at(kBodySegmentName); } const snapshots::rec_split::AccessorIndex& idx_body_number() const { return entity_data().accessor_indexes.at(kIdxBodyNumberName); } const snapshots::segment::SegmentFileReader& txn_segment() const { return entity_data().segments.at(kTxnSegmentName); } const snapshots::rec_split::AccessorIndex& idx_txn_hash() const { return entity_data().accessor_indexes.at(kIdxTxnHashName); } const snapshots::rec_split::AccessorIndex& idx_txn_hash_2_block() const { return entity_data().accessor_indexes.at(kIdxTxnHash2BlockName); } }; } // namespace silkworm::db::blocks ================================================ FILE: silkworm/db/blocks/step_block_num_converter.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::db::blocks { //! Scale factor to convert from-to block number values in block snapshot file names inline constexpr size_t kStepSizeForBlockSnapshots = 1'000; inline constexpr datastore::StepToTimestampConverter kStepToBlockNumConverter{kStepSizeForBlockSnapshots}; } // namespace silkworm::db::blocks ================================================ FILE: silkworm/db/blocks/transactions/txn_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txn_index.hpp" #include #include #include "silkworm/db/blocks/step_block_num_converter.hpp" #include "txn_segment_word_codec.hpp" namespace silkworm::snapshots { Bytes TransactionKeyFactory::make(ByteView key_data, uint64_t i) { return Bytes{tx_buffer_hash(key_data, first_tx_id_ + i)}; } std::pair TransactionIndex::compute_txs_amount( SnapshotPath bodies_segment_path, std::optional bodies_segment_region) { segment::SegmentFileReader body_segment{std::move(bodies_segment_path), db::blocks::kStepToBlockNumConverter, bodies_segment_region}; auto result = BodyTxsAmountSegmentQuery{body_segment}.exec(); return {result.first_tx_id, result.count}; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txn_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "../schema_config.hpp" namespace silkworm::snapshots { struct TransactionKeyFactory : IndexKeyFactory { explicit TransactionKeyFactory(uint64_t first_tx_id) : first_tx_id_(first_tx_id) {} ~TransactionKeyFactory() override = default; Bytes make(ByteView key_data, uint64_t i) override; private: uint64_t first_tx_id_; }; class TransactionIndex { public: static IndexBuilder make( SnapshotPath bodies_segment_path, SnapshotPath segment_path) { return make( std::move(bodies_segment_path), std::nullopt, std::move(segment_path), std::nullopt); } static IndexBuilder make( SnapshotPath bodies_segment_path, std::optional bodies_segment_region, SnapshotPath segment_path, std::optional segment_region) { auto txs_amount = compute_txs_amount(std::move(bodies_segment_path), bodies_segment_region); auto descriptor = make_descriptor(segment_path, txs_amount.first); auto query = std::make_unique(std::move(segment_path), segment_region); return IndexBuilder{std::move(descriptor), std::move(query)}; } static std::pair compute_txs_amount( SnapshotPath bodies_segment_path, std::optional bodies_segment_region); private: static IndexDescriptor make_descriptor(const SnapshotPath& segment_path, uint64_t first_tx_id) { return { .index_file = segment_path.related_path_ext(db::blocks::kIdxExtension), .key_factory = std::make_unique(first_tx_id), .base_data_id = first_tx_id, .less_false_positives = true, .etl_buffer_size = datastore::etl::kOptimalBufferSize / 2, }; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txn_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "../schema_config.hpp" #include "txn_segment.hpp" namespace silkworm::snapshots { using TransactionFindByIdSegmentQuery = FindByIdSegmentQuery; using TransactionFindByHashSegmentQuery = FindByHashSegmentQuery; using TransactionRangeFromIdSegmentQuery = RangeFromIdSegmentQuery; using TransactionRangeFromIdQuery = FindByTimestampMapQuery; using TransactionPayloadRlpRangeFromIdSegmentQuery = RangeFromIdSegmentQuery, db::blocks::kTxnSegmentAndIdxNames>; using TransactionPayloadRlpRangeFromIdQuery = FindByTimestampMapQuery; class TransactionBlockNumByTxnHashSegmentQuery { public: TransactionBlockNumByTxnHashSegmentQuery( const rec_split::AccessorIndex& index, TransactionFindByHashSegmentQuery cross_check_query) : index_(index), cross_check_query_(cross_check_query) {} explicit TransactionBlockNumByTxnHashSegmentQuery( const SnapshotBundle& bundle) : TransactionBlockNumByTxnHashSegmentQuery{ make(db::blocks::BundleDataRef{*bundle})} {} std::optional> exec(const Hash& hash) { // Lookup the entire txn to check that the retrieved txn hash matches (no way to know if key exists in MPHF) const auto cross_check_result = cross_check_query_.exec(hash); const auto result = cross_check_result ? index_.lookup_by_key(hash) : std::nullopt; if (!result) return std::nullopt; return std::pair{*result, cross_check_result->timestamp}; } static TransactionBlockNumByTxnHashSegmentQuery make(db::blocks::BundleDataRef bundle) { TransactionFindByHashSegmentQuery cross_check_query{ SegmentAndAccessorIndex{ bundle.txn_segment(), bundle.idx_txn_hash(), }, }; return {bundle.idx_txn_hash_2_block(), cross_check_query}; } private: const rec_split::AccessorIndex& index_; TransactionFindByHashSegmentQuery cross_check_query_; }; using TransactionBlockNumByTxnHashQuery = FindMapQuery; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txn_segment.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "txn_segment_word_codec.hpp" namespace silkworm::snapshots { using TransactionSegmentReader = segment::SegmentReader; using TransactionSegmentWriter = segment::SegmentWriter; template using TransactionSegmentPayloadRlpReader = segment::SegmentReader>; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txn_segment_collation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txn_segment_collation.hpp" #include #include #include #include "txn_segment.hpp" namespace silkworm::db { using namespace silkworm::datastore::kvdb; using namespace datastore; void TransactionSegmentCollation::copy(ROTxn& txn, const SegmentCollationCommand& command, snapshots::segment::SegmentFileWriter& file_writer) const { BlockNumRange range = command.range; snapshots::TransactionSegmentWriter writer{file_writer}; auto out = writer.out(); auto system_tx = snapshots::empty_system_tx(); for (BlockNum i = range.start; i < range.end; ++i) { BlockBody body; bool found = read_canonical_body(txn, i, /* read_senders = */ true, body); if (!found) throw std::runtime_error{"TransactionSegmentCollation::copy missing body for block " + std::to_string(i)}; *out++ = system_tx; for (auto& value : body.transactions) { *out++ = value; } *out++ = system_tx; } } void TransactionSegmentCollation::prune(RWTxn& txn, BlockNumRange range) const { for (BlockNum i = range.start, count = 1; i < range.end; ++i, ++count) { auto hash_opt = read_canonical_header_hash(txn, i); if (!hash_opt) continue; auto hash = *hash_opt; delete_senders(txn, hash, i); auto body_opt = read_canonical_body_for_storage(txn, i); if (body_opt) { auto& body = *body_opt; delete_transactions(txn, body.base_txn_id + 1, body.txn_count - 2); } if ((count > 10000) && ((count % 10000) == 0)) { SILK_DEBUG_M("TransactionSegmentCollation") << "cleaned up until block " << i; } } } } // namespace silkworm::db ================================================ FILE: silkworm/db/blocks/transactions/txn_segment_collation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::db { class TransactionSegmentCollation : public datastore::SegmentCollation { public: ~TransactionSegmentCollation() override = default; void copy(datastore::kvdb::ROTxn& txn, const datastore::SegmentCollationCommand& command, snapshots::segment::SegmentFileWriter& file_writer) const override; void prune(datastore::kvdb::RWTxn& txn, BlockNumRange range) const override; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/blocks/transactions/txn_segment_word_codec.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txn_segment_word_codec.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots { TransactionSegmentWord slice_tx_data(ByteView buffer) { // Skip first byte of tx hash plus sender address length for transaction decoding constexpr int kTxRlpDataOffset{1 + kAddressLength}; if (buffer.size() < kTxRlpDataOffset) { std::stringstream error; error << "slice_tx_data too short record: " << std::to_string(buffer.size()); throw std::runtime_error{error.str()}; } uint8_t first_hash_byte = buffer[0]; ByteView senders_data = buffer.substr(1, kAddressLength); ByteView tx_rlp = buffer.substr(kTxRlpDataOffset); return TransactionSegmentWord{ first_hash_byte, senders_data, tx_rlp, }; } ByteView slice_tx_payload(ByteView tx_rlp) { ByteView tx_envelope = tx_rlp; rlp::Header tx_header; TransactionType tx_type{}; const auto decode_result = rlp::decode_transaction_header_and_type(tx_envelope, tx_header, tx_type); if (!decode_result) { std::stringstream error; error << "slice_tx_payload cannot decode tx envelope: " << to_hex(tx_rlp) << " error: " << magic_enum::enum_name(decode_result.error()); throw std::runtime_error{error.str()}; } if (tx_type == TransactionType::kLegacy) return tx_rlp; if (tx_rlp.size() < tx_header.payload_length) { std::stringstream error; error << " slice_tx_payload cannot decode tx payload: " << to_hex(tx_rlp) << " too short: " << tx_rlp.size() << " payload_length: " << tx_header.payload_length; throw std::runtime_error{error.str()}; } const size_t tx_payload_offset = tx_rlp.size() - tx_header.payload_length; return tx_rlp.substr(tx_payload_offset); } Transaction empty_system_tx() { static Transaction tx; tx.type = TransactionType::kSystem; tx.set_sender(protocol::kSystemAddress); return tx; } void encode_word_from_tx(Bytes& word, const Transaction& tx) { if (tx.type == TransactionType::kSystem) { // empty word return; } auto hash = tx.hash(); word.push_back(hash.bytes[0]); evmc::address sender = tx.sender().value_or(evmc::address{}); word.append(sender.bytes, kAddressLength); rlp::encode(word, tx); } void decode_word_into_tx(ByteView word, Transaction& tx) { if (word.empty()) { tx = empty_system_tx(); return; } auto [_, senders_data, tx_rlp] = slice_tx_data(word); const auto result = rlp::decode(tx_rlp, tx); success_or_throw(result, "decode_word_into_tx: rlp::decode error"); // Must happen after rlp::decode because it resets sender tx.set_sender(bytes_to_address(senders_data)); } Hash tx_buffer_hash(ByteView tx_buffer, uint64_t tx_id) { Hash tx_hash; const bool is_system_tx{tx_buffer.empty()}; if (is_system_tx) { // system-txs: hash:pad32(txnID) endian::store_big_u64(tx_hash.bytes, tx_id); return tx_hash; } auto [_1, _2, tx_envelope] = slice_tx_data(tx_buffer); const ByteView tx_payload = slice_tx_payload(tx_envelope); const auto h256{keccak256(tx_payload)}; std::copy(std::begin(h256.bytes), std::begin(h256.bytes) + kHashLength, std::begin(tx_hash.bytes)); if (tx_id % 100'000 == 0) { SILK_DEBUG << "tx_buffer_hash:" << " header.payload_length: " << tx_payload.size() << " tx_id: " << tx_id; } SILK_TRACE << "tx_buffer_hash:" << " tx_id: " << tx_id << " payload: " << to_hex(tx_payload) << " h256: " << to_hex(h256.bytes, kHashLength); return tx_hash; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txn_segment_word_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::snapshots { struct TransactionSegmentWord { uint8_t first_hash_byte{}; ByteView senders_data; ByteView tx_rlp; }; TransactionSegmentWord slice_tx_data(ByteView buffer); ByteView slice_tx_payload(ByteView tx_rlp); Hash tx_buffer_hash(ByteView tx_buffer, uint64_t tx_id); //! Encode transaction as a snapshot word. Format is: tx_hash_1byte + sender_address_20byte + tx_rlp_bytes void encode_word_from_tx(Bytes& word, const Transaction& tx); //! Decode transaction from snapshot word. Format is: tx_hash_1byte + sender_address_20byte + tx_rlp_bytes void decode_word_into_tx(ByteView word, Transaction& tx); Transaction empty_system_tx(); struct TransactionSegmentWordEncoder : public Encoder { Transaction value; Bytes word; ~TransactionSegmentWordEncoder() override = default; ByteView encode_word() override { word.clear(); encode_word_from_tx(word, value); return word; } }; static_assert(EncoderConcept); struct TransactionSegmentWordDecoder : public Decoder { Transaction value; ~TransactionSegmentWordDecoder() override = default; void decode_word(Word& word) override { decode_word_into_tx(word, value); } }; static_assert(DecoderConcept); template struct TransactionSegmentWordPayloadRlpDecoder : public Decoder { TBytes value; ~TransactionSegmentWordPayloadRlpDecoder() override = default; void decode_word(Word& word) override { const ByteView word_view = word; if (word_view.empty()) { value = TBytes{}; return; } auto data = slice_tx_data(word_view); value = slice_tx_payload(data.tx_rlp); } }; static_assert(DecoderConcept>); } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txn_to_block_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txn_to_block_index.hpp" #include "txs_and_bodies_query.hpp" namespace silkworm::snapshots { static IndexInputDataQuery::Iterator::value_type query_entry(TxsAndBodiesSegmentQuery::Iterator& it) { return { .key_data = it->tx_buffer, .value = it->block_num, }; } IndexInputDataQuery::Iterator TransactionToBlockIndexInputDataQuery::begin() { auto impl_it = std::make_shared(query_.begin()); return IndexInputDataQuery::Iterator{this, impl_it, query_entry(*impl_it)}; } IndexInputDataQuery::Iterator TransactionToBlockIndexInputDataQuery::end() { auto impl_it = std::make_shared(query_.end()); return IndexInputDataQuery::Iterator{this, impl_it, query_entry(*impl_it)}; } size_t TransactionToBlockIndexInputDataQuery::keys_count() { return query_.expected_tx_count(); } std::pair, IndexInputDataQuery::Iterator::value_type> TransactionToBlockIndexInputDataQuery::next_iterator(std::shared_ptr it_impl) { auto& it_impl_ref = *reinterpret_cast(it_impl.get()); ++it_impl_ref; return {it_impl, query_entry(it_impl_ref)}; } bool TransactionToBlockIndexInputDataQuery::equal_iterators( std::shared_ptr lhs_it_impl, std::shared_ptr rhs_it_impl) const { auto lhs = reinterpret_cast(lhs_it_impl.get()); auto rhs = reinterpret_cast(rhs_it_impl.get()); return (*lhs == *rhs); } IndexBuilder TransactionToBlockIndex::make( SnapshotPath bodies_segment_path, std::optional bodies_segment_region, SnapshotPath segment_path, std::optional segment_region, BlockNum first_block_num) { auto txs_amount = TransactionIndex::compute_txs_amount(bodies_segment_path, bodies_segment_region); const uint64_t first_tx_id = txs_amount.first; const uint64_t expected_tx_count = txs_amount.second; auto descriptor = make_descriptor(segment_path, first_block_num, first_tx_id); TxsAndBodiesSegmentQuery data_query{ std::move(segment_path), segment_region, std::move(bodies_segment_path), bodies_segment_region, first_block_num, first_tx_id, expected_tx_count, }; auto query = std::make_unique(std::move(data_query)); return IndexBuilder{std::move(descriptor), std::move(query)}; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txn_to_block_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "../schema_config.hpp" #include "../step_block_num_converter.hpp" #include "txn_index.hpp" #include "txs_and_bodies_query.hpp" namespace silkworm::snapshots { class TransactionToBlockIndexInputDataQuery : public IndexInputDataQuery { public: explicit TransactionToBlockIndexInputDataQuery(TxsAndBodiesSegmentQuery query) : query_(std::move(query)) {} Iterator begin() override; Iterator end() override; size_t keys_count() override; std::pair, Iterator::value_type> next_iterator(std::shared_ptr it_impl) override; bool equal_iterators(std::shared_ptr lhs_it_impl, std::shared_ptr rhs_it_impl) const override; private: TxsAndBodiesSegmentQuery query_; }; class TransactionToBlockIndex { public: static IndexBuilder make( SnapshotPath bodies_segment_path, SnapshotPath segment_path) { auto step_converter = db::blocks::kStepToBlockNumConverter; BlockNum first_block_num = step_converter.timestamp_from_step(segment_path.step_range().start); return make( std::move(bodies_segment_path), std::nullopt, std::move(segment_path), std::nullopt, first_block_num); } static IndexBuilder make( SnapshotPath bodies_segment_path, SnapshotPath segment_path, BlockNum first_block_num) { return make( std::move(bodies_segment_path), std::nullopt, std::move(segment_path), std::nullopt, first_block_num); } static IndexBuilder make( SnapshotPath bodies_segment_path, std::optional bodies_segment_region, SnapshotPath segment_path, std::optional segment_region) { auto step_converter = db::blocks::kStepToBlockNumConverter; BlockNum first_block_num = step_converter.timestamp_from_step(segment_path.step_range().start); return make( std::move(bodies_segment_path), bodies_segment_region, std::move(segment_path), segment_region, first_block_num); } static IndexBuilder make( SnapshotPath bodies_segment_path, std::optional bodies_segment_region, SnapshotPath segment_path, std::optional segment_region, BlockNum first_block_num); private: static IndexDescriptor make_descriptor(const SnapshotPath& segment_path, BlockNum first_block_num, uint64_t first_tx_id) { return { .index_file = segment_path.related_path(std::string{db::blocks::kIdxTxnHash2BlockTag}, db::blocks::kIdxExtension), .key_factory = std::make_unique(first_tx_id), .base_data_id = first_block_num, .double_enum_index = false, .etl_buffer_size = datastore::etl::kOptimalBufferSize / 2, }; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txs_and_bodies_query.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txs_and_bodies_query.hpp" #include #include #include #include namespace silkworm::snapshots { TxsAndBodiesSegmentQuery::Iterator::Iterator( std::shared_ptr txs_decoder, seg::Decompressor::Iterator tx_it, std::shared_ptr bodies_decoder, seg::Decompressor::Iterator body_it, BlockNum first_block_num, uint64_t first_tx_id, uint64_t expected_tx_count, std::string log_title) : txs_decoder_(std::move(txs_decoder)), tx_it_(std::move(tx_it)), bodies_decoder_(std::move(bodies_decoder)), body_it_(std::move(body_it)), first_tx_id_(first_tx_id), expected_tx_count_(expected_tx_count), log_title_(std::move(log_title)) { value_.block_num = first_block_num; value_.body_rlp = *body_it_; if (!value_.body_rlp.empty()) { decode_body_rlp(value_.body_rlp, value_.body); } value_.tx_buffer = *tx_it_; } void TxsAndBodiesSegmentQuery::Iterator::skip_bodies_until_tx_id(uint64_t tx_id) { while (!(tx_id < value_.body.base_txn_id + value_.body.txn_count)) { ++body_it_; if (body_it_ == bodies_decoder_->end()) { throw std::runtime_error{log_title_ + " not enough bodies"}; } ++value_.block_num; value_.body_rlp = *body_it_; decode_body_rlp(value_.body_rlp, value_.body); } } TxsAndBodiesSegmentQuery::Iterator& TxsAndBodiesSegmentQuery::Iterator::operator++() { // check if already at the end if (!txs_decoder_) { return *this; } ++tx_it_; ++i_; if (tx_it_ != txs_decoder_->end()) { value_.tx_buffer = *tx_it_; skip_bodies_until_tx_id(first_tx_id_ + i_); } else { if (i_ != expected_tx_count_) { std::stringstream error; error << log_title_ << " tx count mismatch: expected=" + std::to_string(expected_tx_count_) << " got=" << std::to_string(i_); throw std::runtime_error{error.str()}; } // reset to match the end iterator body_it_ = bodies_decoder_->end(); txs_decoder_.reset(); bodies_decoder_.reset(); value_ = {}; value_.block_num = std::numeric_limits::max(); } return *this; } bool operator==(const TxsAndBodiesSegmentQuery::Iterator& lhs, const TxsAndBodiesSegmentQuery::Iterator& rhs) { return (lhs.txs_decoder_ == rhs.txs_decoder_) && (!lhs.txs_decoder_ || (lhs.tx_it_ == rhs.tx_it_)) && (lhs.bodies_decoder_ == rhs.bodies_decoder_) && (!lhs.bodies_decoder_ || (lhs.body_it_ == rhs.body_it_)); } void TxsAndBodiesSegmentQuery::Iterator::decode_body_rlp(ByteView body_rlp, BlockBodyForStorage& body) { auto decode_result = decode_stored_block_body(body_rlp, body); if (!decode_result) { std::stringstream error; error << log_title_ << " cannot decode block " << value_.block_num << " body: " << to_hex(body_rlp) << " i: " << i_ << " error: " << magic_enum::enum_name(decode_result.error()); throw std::runtime_error{error.str()}; } } TxsAndBodiesSegmentQuery::Iterator TxsAndBodiesSegmentQuery::begin() const { std::string log_title = "TxsAndBodiesSegmentQuery for: " + txs_segment_path_.path().string(); auto txs_decoder = std::make_shared(txs_segment_path_.path(), txs_segment_region_); const auto tx_count = txs_decoder->words_count(); if (tx_count != expected_tx_count_) { std::stringstream error; error << log_title << " tx count mismatch: expected=" << std::to_string(expected_tx_count_) << " got=" << std::to_string(tx_count); throw std::runtime_error{error.str()}; } auto bodies_decoder = std::make_shared(bodies_segment_path_.path(), bodies_segment_region_); TxsAndBodiesSegmentQuery::Iterator it{ txs_decoder, txs_decoder->begin(), bodies_decoder, bodies_decoder->begin(), first_block_num_, first_tx_id_, expected_tx_count_, log_title, }; if (it->body_rlp.empty()) { throw std::runtime_error{log_title + " no bodies"}; } return it; } TxsAndBodiesSegmentQuery::Iterator TxsAndBodiesSegmentQuery::end() const { return Iterator{ {}, seg::Decompressor::Iterator::make_end(), {}, seg::Decompressor::Iterator::make_end(), std::numeric_limits::max(), first_tx_id_, expected_tx_count_, "TxsAndBodiesSegmentQuery::end", }; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/blocks/transactions/txs_and_bodies_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots { class TxsAndBodiesSegmentQuery { public: class Iterator { public: Iterator( std::shared_ptr txs_decoder, seg::Decompressor::Iterator tx_it, std::shared_ptr bodies_decoder, seg::Decompressor::Iterator body_it, BlockNum first_block_num, uint64_t first_tx_id, uint64_t expected_tx_count, std::string log_title); // NOLINTNEXTLINE(readability-identifier-naming) struct value_type { BlockNum block_num{}; ByteView body_rlp; BlockBodyForStorage body; ByteView tx_buffer; }; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; reference operator*() { return value_; } pointer operator->() { return &value_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++(); friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs); private: void skip_bodies_until_tx_id(uint64_t tx_id); void decode_body_rlp(ByteView body_rlp, BlockBodyForStorage& body); std::shared_ptr txs_decoder_; seg::Decompressor::Iterator tx_it_; std::shared_ptr bodies_decoder_; seg::Decompressor::Iterator body_it_; uint64_t i_{}; value_type value_; uint64_t first_tx_id_; uint64_t expected_tx_count_; std::string log_title_; }; static_assert(std::input_or_output_iterator); TxsAndBodiesSegmentQuery( SnapshotPath txs_segment_path, std::optional txs_segment_region, SnapshotPath bodies_segment_path, std::optional bodies_segment_region, BlockNum first_block_num, uint64_t first_tx_id, uint64_t expected_tx_count) : txs_segment_path_(std::move(txs_segment_path)), txs_segment_region_(txs_segment_region), bodies_segment_path_(std::move(bodies_segment_path)), bodies_segment_region_(bodies_segment_region), first_block_num_(first_block_num), first_tx_id_(first_tx_id), expected_tx_count_(expected_tx_count) {} Iterator begin() const; Iterator end() const; uint64_t expected_tx_count() const { return expected_tx_count_; } private: SnapshotPath txs_segment_path_; std::optional txs_segment_region_; SnapshotPath bodies_segment_path_; std::optional bodies_segment_region_; BlockNum first_block_num_; uint64_t first_tx_id_; uint64_t expected_tx_count_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/buffer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "buffer.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::db { using datastore::kvdb::to_slice; template size_t flat_hash_map_memory_size(size_t capacity) { return sizeof(std::pair) * capacity; } static size_t flat_hash_map_capacity_for_size(size_t size, size_t current_capacity) { // if the desired size is less than the growth threshold, the current capacity is enough if (size * uint64_t{32} <= current_capacity * uint64_t{25}) { return current_capacity; } // otherwise the capacity needs to double up return current_capacity * 2; } template size_t flat_hash_map_memory_size_after_inserts(const TFlatHashMap& map, size_t inserts_count) { size_t capacity_after_inserts = flat_hash_map_capacity_for_size(map.size() + inserts_count, map.capacity()); return flat_hash_map_memory_size(capacity_after_inserts); } void Buffer::begin_block(uint64_t block_num, size_t updated_accounts_count) { if (current_batch_state_size() > memory_limit_) { throw MemoryLimitError(); } if (flat_hash_map_memory_size_after_inserts(accounts_, updated_accounts_count) > memory_limit_) { throw MemoryLimitError(); } block_num_ = block_num; changed_storage_.clear(); } void Buffer::update_account(const evmc::address& address, std::optional initial, std::optional current) { // Skip update if both initial and final state are non-existent (i.e. contract creation+destruction within the same block) if (!initial && !current) { // Only to perfectly match Erigon state batch size (Erigon does count any account w/ old=new=empty value). batch_state_size_ += kAddressLength; return; } const bool equal{current == initial}; const bool account_deleted{!current.has_value()}; if (equal && !account_deleted && !changed_storage_.contains(address)) { // Follows the Erigon logic when to populate account changes. // See (ChangeSetWriter)UpdateAccountData & DeleteAccount. return; } if (block_num_ >= prune_history_threshold_) { Bytes encoded_initial{}; if (initial) { bool omit_code_hash{!account_deleted}; encoded_initial = state::AccountCodec::encode_for_storage(*initial, omit_code_hash); } block_account_changes_[block_num_].insert_or_assign(address, encoded_initial); } size_t encoding_length_for_storage = current ? state::AccountCodec::encoding_length_for_storage(*current) : 0; if (equal) { batch_state_size_ += kAddressLength + encoding_length_for_storage; return; } auto it{accounts_.find(address)}; if (it != accounts_.end()) { batch_state_size_ -= it->second.has_value() ? state::AccountCodec::encoding_length_for_storage(*it->second) : 0; batch_state_size_ += encoding_length_for_storage; it->second = current; } else { batch_state_size_ += kAddressLength + encoding_length_for_storage; accounts_[address] = current; } const bool initial_smart_now_deleted{account_deleted && initial->incarnation}; const bool initial_smart_now_eoa{!account_deleted && current->incarnation == 0 && initial && initial->incarnation}; if (initial_smart_now_deleted || initial_smart_now_eoa) { if (incarnations_.insert_or_assign(address, initial->incarnation).second) { batch_state_size_ += kAddressLength + kIncarnationLength; } } } void Buffer::update_account_code(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& code_hash, ByteView code) { // Don't overwrite existing code so that views of it that were previously returned by read_code are still valid const auto [inserted_or_existing_it, inserted] = hash_to_code_.try_emplace(code_hash, code); if (inserted) { batch_state_size_ += kHashLength + code.size(); } else { batch_state_size_ += code.size() - inserted_or_existing_it->second.size(); } if (storage_prefix_to_code_hash_.insert_or_assign(storage_prefix(address, incarnation), code_hash).second) { batch_state_size_ += kPlainStoragePrefixLength + kHashLength; } } void Buffer::update_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) { if (current == initial) { return; } if (block_num_ >= prune_history_threshold_) { changed_storage_.insert(address); ByteView initial_val{zeroless_view(initial.bytes)}; block_storage_changes_[block_num_][address][incarnation].insert_or_assign(location, initial_val); } // Iterator in insert_or_assign return value "is pointing at the element that was inserted or updated" // so we cannot use it to determine the old value size: we need to use initial instead const auto [_, inserted] = storage_[address][incarnation].insert_or_assign(location, current); ByteView current_val{zeroless_view(current.bytes)}; if (inserted) { batch_state_size_ += kPlainStoragePrefixLength + kHashLength + current_val.size(); } else { batch_state_size_ += current_val.size() - zeroless_view(initial.bytes).size(); } } void Buffer::write_history_to_db(bool write_change_sets) { size_t written_size{0}; size_t total_written_size{0}; bool should_trace{log::test_verbosity(log::Level::kTrace)}; StopWatch sw; sw.start(); if (!block_account_changes_.empty() && write_change_sets) { auto account_change_table{open_cursor(txn_, table::kAccountChangeSet)}; Bytes change_key(sizeof(BlockNum), '\0'); Bytes change_value(kAddressLength + 128 /* see comment*/, '\0'); // Max size of encoded value is 85. We allocate - once - some byte more for safety // and avoid reallocation or resizing in the loop for (const auto& [block_num, account_changes] : block_account_changes_) { endian::store_big_u64(change_key.data(), block_num); written_size += sizeof(BlockNum); for (const auto& [address, account_encoded] : account_changes) { std::memcpy(&change_value[0], address.bytes, kAddressLength); std::memcpy(&change_value[kAddressLength], account_encoded.data(), account_encoded.size()); mdbx::slice k{to_slice(change_key)}; mdbx::slice v{change_value.data(), kAddressLength + account_encoded.size()}; mdbx::error::success_or_throw(account_change_table.put(k, &v, MDBX_APPENDDUP)); written_size += kAddressLength + account_encoded.size(); } } total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Append Account Changes", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } written_size = 0; } block_account_changes_.clear(); if (!block_storage_changes_.empty() && write_change_sets) { Bytes change_key(sizeof(BlockNum) + kPlainStoragePrefixLength, '\0'); Bytes change_value(kHashLength + 128, '\0'); // Se comment above (account changes) for explanation about 128 auto storage_change_table{open_cursor(txn_, table::kStorageChangeSet)}; for (const auto& [block_num, storage_changes] : block_storage_changes_) { endian::store_big_u64(&change_key[0], block_num); written_size += sizeof(BlockNum); for (const auto& [address, incarnations_locations_values] : storage_changes) { std::memcpy(&change_key[sizeof(BlockNum)], address.bytes, kAddressLength); written_size += kAddressLength; for (const auto& [incarnation, locations_values] : incarnations_locations_values) { endian::store_big_u64(&change_key[sizeof(BlockNum) + kAddressLength], incarnation); written_size += kIncarnationLength; for (const auto& [location, value] : locations_values) { std::memcpy(&change_value[0], location.bytes, kHashLength); std::memcpy(&change_value[kHashLength], value.data(), value.size()); mdbx::slice change_value_slice{change_value.data(), kHashLength + value.size()}; mdbx::error::success_or_throw( storage_change_table.put(to_slice(change_key), &change_value_slice, MDBX_APPENDDUP)); written_size += kLocationLength + value.size(); } } } } total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Append Storage Changes", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } written_size = 0; } block_storage_changes_.clear(); if (!receipts_.empty()) { auto receipt_table{open_cursor(txn_, table::kBlockReceipts)}; for (const auto& [block_key, receipts] : receipts_) { auto k{to_slice(block_key)}; auto v{to_slice(receipts)}; mdbx::error::success_or_throw(receipt_table.put(k, &v, MDBX_APPEND)); written_size += k.length() + v.length(); } receipts_.clear(); total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Append Receipts", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } written_size = 0; } if (!logs_.empty()) { auto log_table{open_cursor(txn_, table::kLogs)}; for (const auto& [log_key, value] : logs_) { auto k{to_slice(log_key)}; auto v{to_slice(value)}; mdbx::error::success_or_throw(log_table.put(k, &v, MDBX_APPEND)); written_size += k.length() + v.length(); } logs_.clear(); total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Append Logs", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } written_size = 0; } if (!call_traces_.empty()) { Bytes call_traces_key(sizeof(BlockNum), '\0'); auto call_traces_cursor{txn_.rw_cursor_dup_sort(table::kCallTraceSet)}; for (const auto& [block_num, account_and_flags_set] : call_traces_) { endian::store_big_u64(call_traces_key.data(), block_num); written_size += sizeof(BlockNum); for (const auto& account_and_flags : account_and_flags_set) { auto account_and_flags_slice{to_slice(account_and_flags)}; mdbx::error::success_or_throw( call_traces_cursor->put(to_slice(call_traces_key), &account_and_flags_slice, MDBX_APPENDDUP)); written_size += account_and_flags_slice.size(); } } call_traces_.clear(); total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Append Call Traces", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } } auto [finish_time, _]{sw.stop()}; if (should_trace) [[unlikely]] { log::Trace("Flushed history", {"size", human_size(total_written_size), "in", StopWatch::format(sw.since_start(finish_time))}); } } void Buffer::write_state_to_db() { /* * ENSURE PlainState updates are Last !!! * Also ensure to clear unneeded memory data ASAP to let the OS cache * to store more database pages for longer */ size_t written_size{0}; size_t total_written_size{0}; bool should_trace{log::test_verbosity(log::Level::kTrace)}; StopWatch sw; sw.start(); if (!incarnations_.empty()) { auto incarnation_table{open_cursor(txn_, table::kIncarnationMap)}; Bytes data(kIncarnationLength, '\0'); for (const auto& [address, incarnation] : incarnations_) { endian::store_big_u64(&data[0], incarnation); incarnation_table.upsert(to_slice(address), to_slice(data)); written_size += kAddressLength + kIncarnationLength; } incarnations_.clear(); total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Incarnations updated", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } written_size = 0; } if (!hash_to_code_.empty()) { auto code_table{open_cursor(txn_, table::kCode)}; for (const auto& entry : hash_to_code_) { code_table.upsert(to_slice(entry.first), to_slice(entry.second)); written_size += kHashLength + entry.second.size(); } hash_to_code_.clear(); total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Code updated", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } written_size = 0; } if (!storage_prefix_to_code_hash_.empty()) { auto code_hash_table{open_cursor(txn_, table::kPlainCodeHash)}; for (const auto& entry : storage_prefix_to_code_hash_) { code_hash_table.upsert(to_slice(entry.first), to_slice(entry.second)); written_size += kAddressLength + kIncarnationLength + kHashLength; } storage_prefix_to_code_hash_.clear(); total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Code Hashes updated", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } written_size = 0; } // Extract sorted index of unique addresses before inserting into the DB absl::btree_set addresses; for (auto& x : accounts_) { addresses.insert(x.first); } for (auto& x : storage_) { addresses.insert(x.first); } if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Sorted addresses", {"in", StopWatch::format(duration)}); } auto state_table = txn_.rw_cursor_dup_sort(table::kPlainState); for (const auto& address : addresses) { if (auto it{accounts_.find(address)}; it != accounts_.end()) { auto key{to_slice(address)}; state_table->erase(key, /*whole_multivalue=*/true); // PlainState is multivalue if (it->second.has_value()) { Bytes encoded = state::AccountCodec::encode_for_storage(*it->second); state_table->upsert(key, to_slice(encoded)); written_size += kAddressLength + encoded.size(); } accounts_.erase(it); } if (auto it{storage_.find(address)}; it != storage_.end()) { for (const auto& [incarnation, contract_storage] : it->second) { Bytes prefix{storage_prefix(address, incarnation)}; // Extract sorted set of storage locations to insert ordered data into the DB absl::btree_set storage_locations; for (auto& storage_entry : contract_storage) { storage_locations.insert(storage_entry.first); } for (const auto& location : storage_locations) { if (auto storage_it{contract_storage.find(location)}; storage_it != contract_storage.end()) { const auto& value{storage_it->second}; upsert_storage_value(*state_table, prefix, location.bytes, value.bytes); written_size += prefix.size() + kLocationLength + zeroless_view(value.bytes).size(); } } } storage_.erase(it); } } total_written_size += written_size; if (should_trace) [[unlikely]] { auto [_, duration]{sw.lap()}; log::Trace("Updated accounts and storage", {"size", human_size(written_size), "in", StopWatch::format(duration)}); } batch_state_size_ = 0; auto [time_point, _]{sw.stop()}; log::Info("Flushed state", {"size", human_size(total_written_size), "in", StopWatch::format(sw.since_start(time_point))}); } void Buffer::write_to_db(bool write_change_sets) { write_history_to_db(write_change_sets); // This should be very last to be written so updated pages // have higher chances not to be evicted from RAM write_state_to_db(); } // Erigon WriteReceipts in core/rawdb/accessors_chain.go void Buffer::insert_receipts(uint64_t block_num, const std::vector& receipts) { for (uint32_t i{0}; i < receipts.size(); ++i) { if (receipts[i].logs.empty()) { continue; } Bytes key{log_key(block_num, i)}; Bytes value{cbor_encode(receipts[i].logs)}; logs_.insert_or_assign(key, value); } Bytes key{block_key(block_num)}; Bytes value{cbor_encode(receipts)}; receipts_[key] = value; } void Buffer::insert_call_traces(BlockNum block_num, const CallTraces& traces) { // Collect and sort all unique accounts touched by the call trace (no duplicates) absl::btree_set touched_accounts; for (const auto& sender : traces.senders) { touched_accounts.insert(sender); } for (const auto& recipient : traces.recipients) { touched_accounts.insert(recipient); } if (!touched_accounts.empty()) { absl::btree_set values; for (const auto& account : touched_accounts) { Bytes value(kAddressLength + 1, '\0'); std::memcpy(value.data(), account.bytes, kAddressLength); if (traces.senders.contains(account)) { value[kAddressLength] |= 1; } if (traces.recipients.contains(account)) { value[kAddressLength] |= 2; } values.insert(std::move(value)); } call_traces_.emplace(block_num, values); } } evmc::bytes32 Buffer::state_root_hash() const { throw std::runtime_error(std::string(__FUNCTION__).append(" not yet implemented")); } uint64_t Buffer::current_canonical_block() const { throw std::runtime_error(std::string(__FUNCTION__).append(" not yet implemented")); } std::optional Buffer::canonical_hash(uint64_t) const { throw std::runtime_error(std::string(__FUNCTION__).append(" not yet implemented")); } void Buffer::canonize_block(uint64_t, const evmc::bytes32&) { throw std::runtime_error(std::string(__FUNCTION__).append(" not yet implemented")); } void Buffer::decanonize_block(uint64_t) { throw std::runtime_error(std::string(__FUNCTION__).append(" not yet implemented")); } void Buffer::insert_block(const Block& block, const evmc::bytes32& hash) { uint64_t block_num{block.header.number}; Bytes key{block_key(block_num, hash.bytes)}; headers_[key] = block.header; bodies_[key] = block.copy_body(); if (block_num == 0) { difficulty_[key] = 0; } else { std::optional parent_difficulty{total_difficulty(block_num - 1, block.header.parent_hash)}; difficulty_[key] = parent_difficulty.value_or(0); } difficulty_[key] += block.header.difficulty; } std::optional Buffer::total_difficulty(uint64_t block_num, const evmc::bytes32& block_hash) const noexcept { Bytes key{block_key(block_num, block_hash.bytes)}; if (auto it{difficulty_.find(key)}; it != difficulty_.end()) { return it->second; } return db::read_total_difficulty(txn_, key); } std::optional Buffer::read_header(uint64_t block_num, const evmc::bytes32& block_hash) const noexcept { Bytes key{block_key(block_num, block_hash.bytes)}; if (auto it{headers_.find(key)}; it != headers_.end()) { return it->second; } return data_model_->read_header(block_num, Hash{block_hash.bytes}); } bool Buffer::read_body(uint64_t block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept { Bytes key{block_key(block_num, block_hash.bytes)}; if (auto it{bodies_.find(key)}; it != bodies_.end()) { out = it->second; return true; } return data_model_->read_body(block_num, block_hash.bytes, /*read_senders=*/false, out); } std::optional Buffer::read_account(const evmc::address& address) const noexcept { if (auto it{accounts_.find(address)}; it != accounts_.end()) { return it->second; } auto db_account{db::read_account(txn_, address, historical_block_)}; return db_account; } ByteView Buffer::read_code(const evmc::address& /*address*/, const evmc::bytes32& code_hash) const noexcept { if (auto it{hash_to_code_.find(code_hash)}; it != hash_to_code_.end()) { return it->second; } std::optional code{db::read_code(txn_, code_hash)}; ByteView empty; return code.value_or(empty); } evmc::bytes32 Buffer::read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept { if (auto it1{storage_.find(address)}; it1 != storage_.end()) { if (auto it2{it1->second.find(incarnation)}; it2 != it1->second.end()) { if (auto it3{it2->second.find(location)}; it3 != it2->second.end()) { return it3->second; } } } auto db_storage{db::read_storage(txn_, address, incarnation, location, historical_block_)}; return db_storage; } uint64_t Buffer::previous_incarnation(const evmc::address& address) const noexcept { if (auto it{incarnations_.find(address)}; it != incarnations_.end()) { return it->second; } std::optional incarnation{db::read_previous_incarnation(txn_, address, historical_block_)}; return incarnation.value_or(0); } void Buffer::unwind_state_changes(uint64_t) { throw std::runtime_error(std::string(__FUNCTION__).append(" not yet implemented")); } } // namespace silkworm::db ================================================ FILE: silkworm/db/buffer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::db { struct BufferDataModel { virtual ~BufferDataModel() = default; virtual std::optional read_header(BlockNum block_num, const Hash& block_hash) const = 0; [[nodiscard]] virtual bool read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const = 0; }; class BufferROTxDataModel : public BufferDataModel { public: explicit BufferROTxDataModel(ROTxn& tx) : tx_{tx} {} ~BufferROTxDataModel() override = default; std::optional read_header(BlockNum block_num, const Hash& block_hash) const override { return db::read_header(tx_, block_num, block_hash); } [[nodiscard]] bool read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const override { return db::read_body(tx_, block_num, hash, read_senders, body); } private: ROTxn& tx_; }; class BufferFullDataModel : public BufferDataModel { public: explicit BufferFullDataModel(DataModel data_model) : data_model_{data_model} {} ~BufferFullDataModel() override = default; std::optional read_header(BlockNum block_num, const Hash& block_hash) const override { return data_model_.read_header(block_num, block_hash); } [[nodiscard]] bool read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const override { return data_model_.read_body(block_num, hash, read_senders, body); } private: DataModel data_model_; }; class Buffer : public State { public: explicit Buffer( RWTxn& txn, std::unique_ptr data_model) : txn_{txn}, data_model_{std::move(data_model)} {} /** @name Settings */ //!@{ void set_prune_history_threshold(BlockNum prune_history_threshold) { prune_history_threshold_ = prune_history_threshold; } void set_historical_block(BlockNum historical_block) { historical_block_ = historical_block; } void set_memory_limit(size_t memory_limit) { memory_limit_ = memory_limit; } //!@} /** @name Readers */ //!@{ std::optional read_account(const evmc::address& address) const noexcept override; ByteView read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept override; evmc::bytes32 read_storage( const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept override; /** Previous non-zero incarnation of an account; 0 if none exists. */ uint64_t previous_incarnation(const evmc::address& address) const noexcept override; std::optional read_header( uint64_t block_num, const evmc::bytes32& block_hash) const noexcept override; [[nodiscard]] bool read_body( uint64_t block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept override; std::optional total_difficulty( uint64_t block_num, const evmc::bytes32& block_hash) const noexcept override; evmc::bytes32 state_root_hash() const override; uint64_t current_canonical_block() const override; std::optional canonical_hash(uint64_t block_num) const override; //!@} void insert_block(const Block& block, const evmc::bytes32& hash) override; void canonize_block(uint64_t block_num, const evmc::bytes32& block_hash) override; void decanonize_block(uint64_t block_num) override; void insert_receipts(uint64_t block_num, const std::vector& receipts) override; void insert_call_traces(BlockNum block_num, const CallTraces& traces) override; /** @name State changes * Change sets are backward changes of the state, i.e. account/storage values at the beginning of a block. */ //!@{ /** Mark the beginning of a new block. * Must be called prior to calling update_account/update_account_code/update_storage. */ void begin_block(uint64_t block_num, size_t updated_accounts_count) override; void update_account(const evmc::address& address, std::optional initial, std::optional current) override; void update_account_code(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& code_hash, ByteView code) override; void update_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) override; void unwind_state_changes(uint64_t block_num) override; //!@} //! Account (backward) changes per block const absl::btree_map& account_changes() const { return block_account_changes_; } //! Storage (backward) changes per block const absl::btree_map& storage_changes() const { return block_storage_changes_; } //! \brief Approximate size of accrued state in bytes. size_t current_batch_state_size() const noexcept { return batch_state_size_; } //! \brief Persists *all* accrued contents into db //! \remarks write_history_to_db is implicitly called //! @param write_change_sets flag indicating if state changes should be written or not (default: true) void write_to_db(bool write_change_sets = true); //! \brief Persist *history* accrued contents into db //! @param write_change_sets flag indicating if state changes should be written or not (default: true) void write_history_to_db(bool write_change_sets = true); //! \brief Persists *state* accrued contents into db void write_state_to_db(); class MemoryLimitError : public std::runtime_error { public: MemoryLimitError() : std::runtime_error("db::Buffer::MemoryLimitError") {} }; private: RWTxn& txn_; std::unique_ptr data_model_; // Settings uint64_t prune_history_threshold_{0}; std::optional historical_block_; size_t memory_limit_{std::numeric_limits::max()}; absl::btree_map headers_; absl::btree_map bodies_; absl::btree_map difficulty_; // State mutable absl::flat_hash_map> accounts_; // address -> incarnation -> location -> value using Storage = absl::flat_hash_map; using StorageByIncarnation = absl::btree_map; mutable absl::flat_hash_map storage_; absl::btree_map incarnations_; absl::btree_map hash_to_code_; absl::btree_map storage_prefix_to_code_hash_; // History and changesets absl::btree_map block_account_changes_; // per block absl::btree_map block_storage_changes_; // per block absl::btree_map receipts_; absl::btree_map logs_; absl::btree_map> call_traces_; // Accounts in memory data for state mutable size_t batch_state_size_{0}; // Current block stuff uint64_t block_num_{0}; absl::flat_hash_set changed_storage_; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/buffer_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include "state/account_codec.hpp" namespace silkworm::db { TEST_CASE("Buffer storage", "[silkworm][db][buffer]") { db::test_util::TempChainData context; auto& txn{context.rw_txn()}; const evmc::address address{0xbe00000000000000000000000000000000000000_address}; const Bytes key{storage_prefix(address, kDefaultIncarnation)}; const evmc::bytes32 location_a{0x0000000000000000000000000000000000000000000000000000000000000013_bytes32}; const evmc::bytes32 value_a1{0x000000000000000000000000000000000000000000000000000000000000006b_bytes32}; const evmc::bytes32 value_a2{0x0000000000000000000000000000000000000000000000000000000000000085_bytes32}; const evmc::bytes32 value_a3{0x0000000000000000000000000000000000000000000000000000000000000095_bytes32}; const evmc::bytes32 value_nil{0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}; const evmc::bytes32 location_b{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; const evmc::bytes32 value_b{0x0000000000000000000000000000000000000000000000000000000000000132_bytes32}; const evmc::bytes32 location_c{0x0000000000000000000000000000000000000000000000000000000000000003_bytes32}; auto state = txn.rw_cursor_dup_sort(table::kPlainState); upsert_storage_value(*state, key, location_a.bytes, value_a1.bytes); upsert_storage_value(*state, key, location_b.bytes, value_b.bytes); Buffer buffer{txn, std::make_unique(txn)}; SECTION("Reads storage by address and location") { CHECK(buffer.read_storage(address, kDefaultIncarnation, location_a) == value_a1); CHECK(buffer.read_storage(address, kDefaultIncarnation, location_b) == value_b); } SECTION("Updates storage by address and location") { // Update only location A buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a1, /*current=*/value_a2); REQUIRE(buffer.storage_changes().empty() == false); buffer.write_to_db(); // Location A should have the new value const std::optional db_value_a{find_value_suffix(*state, key, location_a.bytes)}; REQUIRE(db_value_a.has_value()); CHECK(db_value_a == zeroless_view(value_a2.bytes)); // Location B should not change const std::optional db_value_b{find_value_suffix(*state, key, location_b.bytes)}; REQUIRE(db_value_b.has_value()); CHECK(db_value_b == zeroless_view(value_b.bytes)); } SECTION("Keeps track of storage changes") { // Update location A buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a1, /*current=*/value_a2); buffer.write_to_db(); // Update again location A buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a2, /*current=*/value_a3); REQUIRE(buffer.storage_changes().empty() == false); // Ask state buffer to not write change sets buffer.write_to_db(/*write_change_sets=*/false); // Location A should have the previous value of old value in state changes, i.e. value_a1 const auto storage_changes{read_storage_changes(txn, 0)}; REQUIRE(storage_changes.size() == 1); const auto& [changed_address, changed_map] = *storage_changes.begin(); CHECK(changed_address == address); REQUIRE(changed_map.size() == 1); const auto& [changed_incarnation, changed_storage] = *changed_map.begin(); CHECK(changed_incarnation == kDefaultIncarnation); REQUIRE(changed_storage.size() == 1); const auto& [changed_location, changed_value] = *changed_storage.begin(); CHECK(changed_location == location_a); CHECK(changed_value == zeroless_view(value_a1.bytes)); } SECTION("Multiple storage changes in a single block saves one storage change entry") { buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a1, /*current=*/value_a2); buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a2, /*current=*/value_a3); REQUIRE(buffer.storage_changes().empty() == false); buffer.write_to_db(); const auto storage_changes{read_storage_changes(txn, 0)}; REQUIRE(storage_changes.size() == 1); const auto& [changed_address, changed_map] = *storage_changes.begin(); CHECK(changed_address == address); REQUIRE(changed_map.size() == 1); const auto& [changed_incarnation, changed_storage] = *changed_map.begin(); CHECK(changed_incarnation == kDefaultIncarnation); REQUIRE(changed_storage.size() == 1); const auto& [changed_location_a, changed_value_a] = *changed_storage.find(location_a); CHECK(changed_location_a == location_a); CHECK(changed_value_a == zeroless_view(value_a2.bytes)); } SECTION("Multiple storage changes in different blocks cause multiple storage changes") { buffer.begin_block(1, 1); buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a1, /*current=*/value_nil); buffer.write_to_db(); buffer.begin_block(2, 1); buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_nil, /*current=*/value_a3); buffer.write_to_db(); buffer.begin_block(3, 1); buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a3, /*current=*/value_a2); buffer.write_to_db(); const auto storage_changes1{read_storage_changes(txn, 1)}; REQUIRE(storage_changes1.size() == 1); const auto storage_changes2{read_storage_changes(txn, 2)}; REQUIRE(storage_changes2.size() == 1); const auto storage_changes3{read_storage_changes(txn, 3)}; REQUIRE(storage_changes3.size() == 1); const std::optional db_value_a2{find_value_suffix(*state, key, location_a.bytes)}; REQUIRE(db_value_a2.has_value()); CHECK(db_value_a2 == zeroless_view(value_a2.bytes)); } SECTION("Deletes storage by address and location") { // Delete location A buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a1, /*current=*/value_nil); // Buffer value set to nil auto current_value_a1{buffer.read_storage(address, kDefaultIncarnation, location_a)}; CHECK(current_value_a1 == value_nil); // Not deleted from the db yet const std::optional db_value_a1{find_value_suffix(*state, key, location_a.bytes)}; CHECK(db_value_a1.has_value()); CHECK(db_value_a1 == zeroless_view(value_a1.bytes)); buffer.write_to_db(); // Buffer reads the value from the db auto current_value_a2{buffer.read_storage(address, kDefaultIncarnation, location_a)}; CHECK(current_value_a2 == value_nil); // Location A should be deleted const std::optional db_value_a2{find_value_suffix(*state, key, location_a.bytes)}; CHECK(!db_value_a2.has_value()); // Location B should not change const std::optional db_value_b{find_value_suffix(*state, key, location_b.bytes)}; REQUIRE(db_value_b.has_value()); CHECK(db_value_b == zeroless_view(value_b.bytes)); } SECTION("Can re-set value after deletion") { // Buffer only buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a1, /*current=*/value_nil); // Buffer value set to nil auto current_value_a1{buffer.read_storage(address, kDefaultIncarnation, location_a)}; CHECK(current_value_a1 == value_nil); buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_nil, /*current=*/value_a2); auto current_value_a2{buffer.read_storage(address, kDefaultIncarnation, location_a)}; CHECK(current_value_a2 == value_a2); } SECTION("Sets new value") { buffer.update_storage(address, kDefaultIncarnation, location_c, /*initial=*/{}, /*current=*/value_a1); auto current_value_a1{buffer.read_storage(address, kDefaultIncarnation, location_c)}; CHECK(current_value_a1 == value_a1); buffer.write_to_db(); const std::optional db_value_c1{find_value_suffix(*state, key, location_c.bytes)}; REQUIRE(db_value_c1.has_value()); CHECK(db_value_c1 == zeroless_view(value_a1.bytes)); auto current_value_a2{buffer.read_storage(address, kDefaultIncarnation, location_c)}; CHECK(current_value_a2 == value_a1); } SECTION("Setting to nil deletes the value") { buffer.update_storage(address, kDefaultIncarnation, location_a, /*initial=*/value_a1, /*current=*/{}); auto current_value_a1{buffer.read_storage(address, kDefaultIncarnation, location_a)}; CHECK(current_value_a1 == value_nil); buffer.write_to_db(); const std::optional db_value_a1{find_value_suffix(*state, key, location_a.bytes)}; CHECK(!db_value_a1.has_value()); auto current_value_a2{buffer.read_storage(address, kDefaultIncarnation, location_a)}; CHECK(current_value_a2 == value_nil); } } TEST_CASE("Buffer account", "[silkworm][db][buffer]") { using datastore::kvdb::from_slice; db::test_util::TempChainData context; auto& txn{context.rw_txn()}; SECTION("New EOA account") { const evmc::address address{0xbe00000000000000000000000000000000000000_address}; state::AccountEncodable current_account; current_account.balance = kEther; Buffer buffer{txn, std::make_unique(txn)}; buffer.begin_block(1, 1); buffer.update_account(address, /*initial=*/std::nullopt, current_account); REQUIRE(!buffer.account_changes().empty()); // Current state batch: current account address + current account encoding CHECK(buffer.current_batch_state_size() == kAddressLength + current_account.encoding_length_for_storage()); REQUIRE_NOTHROW(buffer.write_to_db()); auto account_changeset{open_cursor(txn, table::kAccountChangeSet)}; REQUIRE(txn->get_map_stat(account_changeset.map()).ms_entries == 1); auto data{account_changeset.to_first()}; auto data_key_view{from_slice(data.key)}; auto data_value_view{from_slice(data.value)}; auto changeset_blocknum{endian::load_big_u64(data_key_view.data())}; REQUIRE(changeset_blocknum == 1); auto changeset_address{bytes_to_address(data_value_view)}; REQUIRE(changeset_address == address); data_value_view.remove_prefix(kAddressLength); REQUIRE(data_value_view.empty()); } SECTION("Changed EOA account") { const evmc::address address{0xbe00000000000000000000000000000000000000_address}; Account initial_account; initial_account.nonce = 1; initial_account.balance = 0; state::AccountEncodable current_account; current_account.nonce = 2; current_account.balance = kEther; Buffer buffer{txn, std::make_unique(txn)}; buffer.begin_block(1, 1); buffer.update_account(address, /*initial=*/initial_account, current_account); REQUIRE(!buffer.account_changes().empty()); // Current state batch: current account address + current account encoding CHECK(buffer.current_batch_state_size() == kAddressLength + current_account.encoding_length_for_storage()); REQUIRE_NOTHROW(buffer.write_to_db()); auto account_changeset{open_cursor(txn, table::kAccountChangeSet)}; REQUIRE(txn->get_map_stat(account_changeset.map()).ms_entries == 1); auto data{account_changeset.to_first()}; auto data_key_view{from_slice(data.key)}; auto data_value_view{from_slice(data.value)}; auto changeset_blocknum{endian::load_big_u64(data_key_view.data())}; REQUIRE(changeset_blocknum == 1); auto changeset_address{bytes_to_address(data_value_view)}; REQUIRE(changeset_address == address); data_value_view.remove_prefix(kAddressLength); REQUIRE(!data_value_view.empty()); auto previous_account = state::AccountCodec::from_encoded_storage(data_value_view); CHECK(previous_account == initial_account); } SECTION("Delete contract account") { const evmc::address address{0xbe00000000000000000000000000000000000000_address}; Account account; account.incarnation = kDefaultIncarnation; account.code_hash = to_bytes32(keccak256(address.bytes).bytes); // Just a fake hash Buffer buffer{txn, std::make_unique(txn)}; buffer.begin_block(1, 1); buffer.update_account(address, /*initial=*/account, /*current=*/std::nullopt); REQUIRE(!buffer.account_changes().empty()); // Current state batch: initial account for delete + (initial account + incarnation) for incarnation CHECK(buffer.current_batch_state_size() == kAddressLength + (kAddressLength + kIncarnationLength)); REQUIRE_NOTHROW(buffer.write_to_db()); auto incarnations{open_cursor(txn, table::kIncarnationMap)}; REQUIRE_NOTHROW(incarnations.to_first()); auto data{incarnations.current()}; REQUIRE(std::memcmp(data.key.data(), address.bytes, kAddressLength) == 0); REQUIRE(endian::load_big_u64(from_slice(data.value).data()) == account.incarnation); } SECTION("Delete contract account and recreate as EOA") { const evmc::address address{0xbe00000000000000000000000000000000000000_address}; Account account; account.incarnation = kDefaultIncarnation; account.code_hash = to_bytes32(keccak256(address.bytes).bytes); // Just a fake hash // Block 1: create contract account Buffer buffer{txn, std::make_unique(txn)}; buffer.begin_block(1, 1); buffer.update_account(address, /*initial=*/std::nullopt, /*current=*/account); REQUIRE(!buffer.account_changes().empty()); REQUIRE_NOTHROW(buffer.write_to_db()); // Block 2 : destroy contract and recreate account as EOA buffer.begin_block(2, 1); Account eoa; eoa.balance = kEther; buffer.update_account(address, /*initial=*/account, /*current=*/eoa); REQUIRE(!buffer.account_changes().empty()); REQUIRE_NOTHROW(buffer.write_to_db()); auto incarnations{open_cursor(txn, table::kIncarnationMap)}; REQUIRE_NOTHROW(incarnations.to_first()); auto data{incarnations.current()}; CHECK(std::memcmp(data.key.data(), address.bytes, kAddressLength) == 0); CHECK(endian::load_big_u64(from_slice(data.value).data()) == account.incarnation); } SECTION("Change EOA account w/ new value equal to old one") { const evmc::address address{0xbe00000000000000000000000000000000000000_address}; Account initial_account; initial_account.nonce = 2; initial_account.balance = kEther; Account current_account; current_account.nonce = 2; current_account.balance = kEther; Buffer buffer{txn, std::make_unique(txn)}; buffer.begin_block(1, 1); buffer.update_account(address, /*initial=*/initial_account, current_account); REQUIRE(buffer.account_changes().empty()); // No change in current state batch CHECK(buffer.current_batch_state_size() == 0); REQUIRE_NOTHROW(buffer.write_to_db()); auto account_changeset{open_cursor(txn, table::kAccountChangeSet)}; REQUIRE(txn->get_map_stat(account_changeset.map()).ms_entries == 0); } } } // namespace silkworm::db ================================================ FILE: silkworm/db/capi/component.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::db::capi { struct Component { silkworm::snapshots::SnapshotRepository blocks_repository; silkworm::snapshots::SnapshotRepository state_repository_latest; silkworm::snapshots::SnapshotRepository state_repository_historical; std::unique_ptr chaindata; silkworm::snapshots::QueryCaches query_caches; DataStoreRef data_store() { SILKWORM_ASSERT(chaindata); return DataStoreRef{ chaindata->ref(), blocks_repository, state_repository_latest, state_repository_historical, query_caches, }; } DataModelFactory data_model_factory() { return DataModelFactory{data_store()}; } }; } // namespace silkworm::db::capi ================================================ FILE: silkworm/db/capi/db.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "db.h" #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::db; using namespace silkworm::snapshots; static MemoryMappedRegion make_region(const SilkwormMemoryMappedFile& mmf) { return {mmf.memory_address, mmf.memory_length}; } class InvalidSnapshotPathException : public std::runtime_error { public: explicit InvalidSnapshotPathException(const std::string& invalid_path) : std::runtime_error{"invalid snapshot path: " + invalid_path} {} }; static SnapshotPath parse_snapshot_path(const char* file_path) { if (file_path) { const auto snapshot_path = SnapshotPath::parse(file_path); if (snapshot_path) { return *snapshot_path; } } throw InvalidSnapshotPathException{file_path ? file_path : ""}; } static void build_inverted_index_bundle_data( const SilkwormInvertedIndexSnapshot& snapshot, const Schema::EntityDef& entity_def, const datastore::StepToTimestampConverter& step_converter, SnapshotBundleEntityData& data) { data.kv_segments.emplace( Schema::kInvIdxKVSegmentName, segment::KVSegmentFileReader{ parse_snapshot_path(snapshot.segment.file_path), step_converter, entity_def.kv_segment(Schema::kInvIdxKVSegmentName).compression_kind(), make_region(snapshot.segment), }); data.accessor_indexes.emplace( Schema::kInvIdxAccessorIndexName, rec_split::AccessorIndex{ parse_snapshot_path(snapshot.accessor_index.file_path), make_region(snapshot.accessor_index), }); } static snapshots::SnapshotBundleEntityData build_inverted_index_bundle_data( const SilkwormInvertedIndexSnapshot& snapshot, const Schema::EntityDef& entity_def, const datastore::StepToTimestampConverter& step_converter) { SnapshotBundleEntityData data; build_inverted_index_bundle_data(snapshot, entity_def, step_converter, data); return data; } static snapshots::SnapshotBundleEntityData build_domain_bundle_data( const SilkwormDomainSnapshot& snapshot, const Schema::EntityDef& entity_def, const datastore::StepToTimestampConverter& step_converter, uint32_t index_salt) { SnapshotBundleEntityData data; data.kv_segments.emplace( Schema::kDomainKVSegmentName, segment::KVSegmentFileReader{ parse_snapshot_path(snapshot.segment.file_path), step_converter, entity_def.kv_segment(Schema::kDomainKVSegmentName).compression_kind(), make_region(snapshot.segment), }); data.existence_indexes.emplace( Schema::kDomainExistenceIndexName, bloom_filter::BloomFilter{ parse_snapshot_path(snapshot.existence_index.file_path).path(), KeyHasher{index_salt}, }); data.btree_indexes.emplace( Schema::kDomainBTreeIndexName, btree::BTreeIndex{ parse_snapshot_path(snapshot.btree_index.file_path).path(), make_region(snapshot.btree_index), }); if (snapshot.has_accessor_index) { data.accessor_indexes.emplace( Schema::kDomainAccessorIndexName, rec_split::AccessorIndex{ parse_snapshot_path(snapshot.accessor_index.file_path), make_region(snapshot.accessor_index), }); } return data; } static snapshots::SnapshotBundleEntityData build_history_bundle_data( const SilkwormHistorySnapshot& snapshot, const Schema::EntityDef& entity_def, const datastore::StepToTimestampConverter& step_converter) { SnapshotBundleEntityData data; data.segments.emplace( Schema::kHistorySegmentName, segment::SegmentFileReader{ parse_snapshot_path(snapshot.segment.file_path), step_converter, make_region(snapshot.segment), }); data.accessor_indexes.emplace( Schema::kHistoryAccessorIndexName, rec_split::AccessorIndex{ parse_snapshot_path(snapshot.accessor_index.file_path), make_region(snapshot.accessor_index), }); build_inverted_index_bundle_data(snapshot.inverted_index, entity_def, step_converter, data); return data; } static snapshots::SnapshotBundle build_state_snapshot_bundle_latest( const SilkwormStateSnapshotBundleLatest* bundle, const Schema::RepositoryDef& schema, uint32_t salt) { SnapshotBundleData bundle_data; datastore::StepToTimestampConverter step_converter = schema.make_step_converter(); bundle_data.entities.emplace( db::state::kDomainNameAccounts, build_domain_bundle_data(bundle->accounts, schema.domain(db::state::kDomainNameAccounts), step_converter, salt)); bundle_data.entities.emplace( db::state::kDomainNameStorage, build_domain_bundle_data(bundle->storage, schema.domain(db::state::kDomainNameStorage), step_converter, salt)); bundle_data.entities.emplace( db::state::kDomainNameCode, build_domain_bundle_data(bundle->code, schema.domain(db::state::kDomainNameCode), step_converter, salt)); // TODO(canepat): enable after fixing .kvi configuration with IndexList-like implementation // bundle_data.entities.emplace( // db::state::kDomainNameCommitment, // build_domain_bundle_data(bundle->commitment, schema.domain(db::state::kDomainNameCommitment), step_converter, salt)); bundle_data.entities.emplace( db::state::kDomainNameReceipts, build_domain_bundle_data(bundle->receipts, schema.domain(db::state::kDomainNameReceipts), step_converter, salt)); return SnapshotBundle{ parse_snapshot_path(bundle->accounts.segment.file_path).step_range(), std::move(bundle_data), }; } static snapshots::SnapshotBundle build_state_snapshot_bundle_historical( const SilkwormStateSnapshotBundleHistorical* bundle, const Schema::RepositoryDef& schema) { SnapshotBundleData bundle_data; datastore::StepToTimestampConverter step_converter = schema.make_step_converter(); bundle_data.entities.emplace( db::state::kDomainNameAccounts, build_history_bundle_data(bundle->accounts, schema.history(db::state::kDomainNameAccounts), step_converter)); bundle_data.entities.emplace( db::state::kDomainNameStorage, build_history_bundle_data(bundle->storage, schema.history(db::state::kDomainNameStorage), step_converter)); bundle_data.entities.emplace( db::state::kDomainNameCode, build_history_bundle_data(bundle->code, schema.history(db::state::kDomainNameCode), step_converter)); bundle_data.entities.emplace( db::state::kDomainNameReceipts, build_history_bundle_data(bundle->receipts, schema.history(db::state::kDomainNameReceipts), step_converter)); bundle_data.entities.emplace( db::state::kInvIdxNameLogAddress, build_inverted_index_bundle_data(bundle->log_addresses, schema.inverted_index(db::state::kInvIdxNameLogAddress), step_converter)); bundle_data.entities.emplace( db::state::kInvIdxNameLogTopics, build_inverted_index_bundle_data(bundle->log_topics, schema.inverted_index(db::state::kInvIdxNameLogTopics), step_converter)); bundle_data.entities.emplace( db::state::kInvIdxNameTracesFrom, build_inverted_index_bundle_data(bundle->traces_from, schema.inverted_index(db::state::kInvIdxNameTracesFrom), step_converter)); bundle_data.entities.emplace( db::state::kInvIdxNameTracesTo, build_inverted_index_bundle_data(bundle->traces_to, schema.inverted_index(db::state::kInvIdxNameTracesTo), step_converter)); return SnapshotBundle{ parse_snapshot_path(bundle->accounts.segment.file_path).step_range(), std::move(bundle_data), }; } SILKWORM_EXPORT int silkworm_build_recsplit_indexes(SilkwormHandle handle, struct SilkwormMemoryMappedFile* segments[], size_t len) SILKWORM_NOEXCEPT { constexpr int kNeededIndexesToBuildInParallel = 2; if (!handle) { return SILKWORM_INVALID_HANDLE; } auto schema = db::blocks::make_blocks_repository_schema(); std::vector> needed_indexes; for (size_t i = 0; i < len; ++i) { struct SilkwormMemoryMappedFile* segment = segments[i]; if (!segment) { return SILKWORM_INVALID_SNAPSHOT; } auto segment_region = make_region(*segment); const auto snapshot_path = snapshots::SnapshotPath::parse(segment->file_path); if (!snapshot_path) { return SILKWORM_INVALID_PATH; } auto names = schema.entity_name_by_path(*snapshot_path); if (!names) { return SILKWORM_INVALID_PATH; } datastore::EntityName name = names->second; { if (name == db::blocks::kHeaderSegmentName) { auto index = std::make_shared(snapshots::HeaderIndex::make(*snapshot_path, segment_region)); needed_indexes.push_back(index); } else if (name == db::blocks::kBodySegmentName) { auto index = std::make_shared(snapshots::BodyIndex::make(*snapshot_path, segment_region)); needed_indexes.push_back(index); } else if (name == db::blocks::kTxnSegmentName) { auto bodies_segment_path = snapshot_path->related_path(std::string{db::blocks::kBodySegmentTag}, db::blocks::kSegmentExtension); auto bodies_file = std::find_if(segments, segments + len, [&](SilkwormMemoryMappedFile* file) -> bool { return snapshots::SnapshotPath::parse(file->file_path) == bodies_segment_path; }); if (bodies_file < segments + len) { auto bodies_segment_region = make_region(**bodies_file); auto index = std::make_shared(snapshots::TransactionIndex::make( bodies_segment_path, bodies_segment_region, *snapshot_path, segment_region)); needed_indexes.push_back(index); index = std::make_shared(snapshots::TransactionToBlockIndex::make( bodies_segment_path, bodies_segment_region, *snapshot_path, segment_region)); needed_indexes.push_back(index); } } else { SILKWORM_ASSERT(false); } } } if (needed_indexes.size() < kNeededIndexesToBuildInParallel) { // sequential build for (const auto& index : needed_indexes) { index->build(); } } else { // parallel build ThreadPool workers; // Create worker tasks for missing indexes for (const auto& index : needed_indexes) { workers.push_task([=]() { try { SILK_INFO << "Build index: " << index->path().filename() << " start"; index->build(); SILK_INFO << "Build index: " << index->path().filename() << " end"; } catch (const std::exception& ex) { SILK_CRIT << "Build index: " << index->path().filename() << " failed [" << ex.what() << "]"; } }); } // Wait for all missing indexes to be built or stop request while (workers.get_tasks_total()) { std::this_thread::sleep_for(std::chrono::seconds(1)); } // Wait for any already-started-but-unfinished work in case of stop request workers.pause(); workers.wait_for_tasks(); } return SILKWORM_OK; } static snapshots::SnapshotBundle build_blocks_snapshot_bundle( const SilkwormBlocksSnapshotBundle* bundle, const Schema::RepositoryDef& schema) { snapshots::SnapshotBundleEntityData data; datastore::StepToTimestampConverter step_converter = schema.make_step_converter(); data.segments.emplace( db::blocks::kHeaderSegmentName, snapshots::segment::SegmentFileReader{ parse_snapshot_path(bundle->headers.segment.file_path), step_converter, make_region(bundle->headers.segment), }); data.accessor_indexes.emplace( db::blocks::kIdxHeaderHashName, snapshots::rec_split::AccessorIndex{ parse_snapshot_path(bundle->headers.header_hash_index.file_path), make_region(bundle->headers.header_hash_index), }); data.segments.emplace( db::blocks::kBodySegmentName, snapshots::segment::SegmentFileReader{ parse_snapshot_path(bundle->bodies.segment.file_path), step_converter, make_region(bundle->bodies.segment), }); data.accessor_indexes.emplace( db::blocks::kIdxBodyNumberName, snapshots::rec_split::AccessorIndex{ parse_snapshot_path(bundle->bodies.block_num_index.file_path), make_region(bundle->bodies.block_num_index), }); data.segments.emplace( db::blocks::kTxnSegmentName, snapshots::segment::SegmentFileReader{ parse_snapshot_path(bundle->transactions.segment.file_path), step_converter, make_region(bundle->transactions.segment), }); data.accessor_indexes.emplace( db::blocks::kIdxTxnHashName, snapshots::rec_split::AccessorIndex{ parse_snapshot_path(bundle->transactions.tx_hash_index.file_path), make_region(bundle->transactions.tx_hash_index), }); data.accessor_indexes.emplace( db::blocks::kIdxTxnHash2BlockName, snapshots::rec_split::AccessorIndex{ parse_snapshot_path(bundle->transactions.tx_hash_2_block_index.file_path), make_region(bundle->transactions.tx_hash_2_block_index), }); snapshots::SnapshotBundleData bundle_data; bundle_data.entities.emplace(snapshots::Schema::kDefaultEntityName, std::move(data)); return snapshots::SnapshotBundle{ parse_snapshot_path(bundle->headers.segment.file_path).step_range(), std::move(bundle_data), }; } SILKWORM_EXPORT int silkworm_add_blocks_snapshot_bundle( SilkwormHandle handle, const SilkwormBlocksSnapshotBundle* bundle) SILKWORM_NOEXCEPT { try { if (!handle || !handle->db) { return SILKWORM_INVALID_HANDLE; } if (!bundle) { return SILKWORM_INVALID_SNAPSHOT; } auto& repository = handle->db->blocks_repository; repository.add_snapshot_bundle(build_blocks_snapshot_bundle(bundle, repository.schema())); return SILKWORM_OK; } catch (const InvalidSnapshotPathException&) { return SILKWORM_INVALID_PATH; } catch (...) { return SILKWORM_INTERNAL_ERROR; } } SILKWORM_EXPORT int silkworm_add_state_snapshot_bundle_latest( SilkwormHandle handle, const SilkwormStateSnapshotBundleLatest* bundle) SILKWORM_NOEXCEPT { try { if (!handle || !handle->db) { return SILKWORM_INVALID_HANDLE; } if (!bundle) { return SILKWORM_INVALID_SNAPSHOT; } auto& repository = handle->db->state_repository_latest; if (!repository.index_salt()) { return SILKWORM_INTERNAL_ERROR; } repository.add_snapshot_bundle(build_state_snapshot_bundle_latest(bundle, repository.schema(), *repository.index_salt())); return SILKWORM_OK; } catch (const InvalidSnapshotPathException&) { return SILKWORM_INVALID_PATH; } catch (...) { return SILKWORM_INTERNAL_ERROR; } } SILKWORM_EXPORT int silkworm_add_state_snapshot_bundle_historical( SilkwormHandle handle, const SilkwormStateSnapshotBundleHistorical* bundle) SILKWORM_NOEXCEPT { try { if (!handle || !handle->db) { return SILKWORM_INVALID_HANDLE; } if (!bundle) { return SILKWORM_INVALID_SNAPSHOT; } auto& repository = handle->db->state_repository_historical; repository.add_snapshot_bundle(build_state_snapshot_bundle_historical(bundle, repository.schema())); return SILKWORM_OK; } catch (const InvalidSnapshotPathException&) { return SILKWORM_INVALID_PATH; } catch (...) { return SILKWORM_INTERNAL_ERROR; } } SILKWORM_EXPORT const char* silkworm_libmdbx_version() SILKWORM_NOEXCEPT { return datastore::kvdb::libmdbx_version(); } ================================================ FILE: silkworm/db/capi/db.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_DB_CAPI_H_ #define SILKWORM_DB_CAPI_H_ #ifdef SILKWORM_CAPI_COMPONENT #include #else #include "preamble.h" #endif #if __cplusplus extern "C" { #endif typedef struct MDBX_env MDBX_env; typedef struct MDBX_txn MDBX_txn; struct SilkwormMemoryMappedFile { const char* file_path; uint8_t* memory_address; uint64_t memory_length; }; struct SilkwormHeadersSnapshot { struct SilkwormMemoryMappedFile segment; struct SilkwormMemoryMappedFile header_hash_index; }; struct SilkwormBodiesSnapshot { struct SilkwormMemoryMappedFile segment; struct SilkwormMemoryMappedFile block_num_index; }; struct SilkwormTransactionsSnapshot { struct SilkwormMemoryMappedFile segment; struct SilkwormMemoryMappedFile tx_hash_index; struct SilkwormMemoryMappedFile tx_hash_2_block_index; }; struct SilkwormBlocksSnapshotBundle { struct SilkwormHeadersSnapshot headers; struct SilkwormBodiesSnapshot bodies; struct SilkwormTransactionsSnapshot transactions; }; struct SilkwormInvertedIndexSnapshot { struct SilkwormMemoryMappedFile segment; // .ef struct SilkwormMemoryMappedFile accessor_index; // .efi }; struct SilkwormHistorySnapshot { struct SilkwormMemoryMappedFile segment; // .v struct SilkwormMemoryMappedFile accessor_index; // .vi struct SilkwormInvertedIndexSnapshot inverted_index; }; struct SilkwormDomainSnapshot { struct SilkwormMemoryMappedFile segment; // .kv struct SilkwormMemoryMappedFile existence_index; // .kvei struct SilkwormMemoryMappedFile btree_index; // .bt bool has_accessor_index; struct SilkwormMemoryMappedFile accessor_index; // .kvi }; struct SilkwormStateSnapshotBundleLatest { struct SilkwormDomainSnapshot accounts; struct SilkwormDomainSnapshot storage; struct SilkwormDomainSnapshot code; struct SilkwormDomainSnapshot commitment; struct SilkwormDomainSnapshot receipts; }; struct SilkwormStateSnapshotBundleHistorical { struct SilkwormHistorySnapshot accounts; struct SilkwormHistorySnapshot storage; struct SilkwormHistorySnapshot code; struct SilkwormHistorySnapshot receipts; struct SilkwormInvertedIndexSnapshot log_addresses; struct SilkwormInvertedIndexSnapshot log_topics; struct SilkwormInvertedIndexSnapshot traces_from; struct SilkwormInvertedIndexSnapshot traces_to; }; /** * \brief Build a set of indexes for the given snapshots. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] segments An array of segment files to index. * \param[in] len The number of segment files. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure on some or all indexes. */ SILKWORM_EXPORT int silkworm_build_recsplit_indexes(SilkwormHandle handle, struct SilkwormMemoryMappedFile* segments[], size_t len) SILKWORM_NOEXCEPT; /** * \brief Notify Silkworm about a new *block* snapshot bundle to use. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] bundle A *block* snapshot bundle to use. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_add_blocks_snapshot_bundle(SilkwormHandle handle, const struct SilkwormBlocksSnapshotBundle* bundle) SILKWORM_NOEXCEPT; /** * \brief Notify Silkworm about a new *latest state* snapshot bundle to use. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] bundle A *latest state* snapshot bundle to use. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_add_state_snapshot_bundle_latest(SilkwormHandle handle, const struct SilkwormStateSnapshotBundleLatest* bundle) SILKWORM_NOEXCEPT; /** * \brief Notify Silkworm about a new *historical state* snapshot bundle to use. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. * \param[in] bundle A *historical state* snapshot bundle to use. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_add_state_snapshot_bundle_historical(SilkwormHandle handle, const struct SilkwormStateSnapshotBundleHistorical* bundle) SILKWORM_NOEXCEPT; /** * \brief Get libmdbx version for compatibility checks. * \return A string in git describe format. */ SILKWORM_EXPORT const char* silkworm_libmdbx_version(void) SILKWORM_NOEXCEPT; #if __cplusplus } #endif #endif // SILKWORM_DB_CAPI_H_ ================================================ FILE: silkworm/db/chain/chain_storage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::db::chain { //! ChainStorage represents the storage for blockchain primary data, namely: chain configuration, block headers, //! bodies and transactions. class ChainStorage { public: virtual ~ChainStorage() = default; //! Read the current chain configuration parameters virtual Task read_chain_config() const = 0; //! Get the max block number virtual Task max_block_num() const = 0; //! Read block number from hash virtual Task> read_block_num(const Hash& hash) const = 0; //! Read block returning true on success and false on missing block virtual Task read_block(HashAsSpan hash, BlockNum block_num, bool read_senders, Block& block) const = 0; virtual Task read_block(const Hash& hash, BlockNum block_num, Block& block) const = 0; virtual Task read_block(const Hash& hash, Block& block) const = 0; //! Read canonical block by number returning true on success and false on missing block virtual Task read_block(BlockNum block_num, bool read_senders, Block& block) const = 0; //! Read block header with the specified key (block_num, hash) virtual Task> read_header(BlockNum block_num, HashAsArray hash) const = 0; //! Read block header with the specified key (block_num, hash) virtual Task> read_header(BlockNum block_num, const Hash& hash) const = 0; //! Read block header with the specified hash virtual Task> read_header(const Hash& hash) const = 0; //! Read all sibling block headers at specified block_num virtual Task> read_sibling_headers(BlockNum block_num) const = 0; //! Read block body in output parameter returning true on success and false on missing block virtual Task read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const = 0; virtual Task read_body(const Hash& hash, BlockNum block_num, BlockBody& body) const = 0; virtual Task read_body(const Hash& hash, BlockBody& body) const = 0; //! Read the canonical block hash at specified block_num virtual Task> read_canonical_header_hash(BlockNum block_num) const = 0; //! Read the canonical block header at specified block_num virtual Task> read_canonical_header(BlockNum block_num) const = 0; //! Read the canonical block body at specified block_num virtual Task read_canonical_body(BlockNum block_num, BlockBody& body) const = 0; //! Read the raw storage serialization for the canonical block body at specified block_num virtual Task> read_raw_canonical_body_for_storage(BlockNum block_num) const = 0; //! Read the canonical block at specified block_num virtual Task read_canonical_block(BlockNum block_num, Block& block) const = 0; //! Check the presence of a block body using block number and hash virtual Task has_body(BlockNum block_num, HashAsArray hash) const = 0; virtual Task has_body(BlockNum block_num, const Hash& hash) const = 0; //! Read the RLP encoded block transactions at specified block_num virtual Task read_rlp_transactions(BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) const = 0; virtual Task read_rlp_transaction(const evmc::bytes32& txn_hash, Bytes& rlp_tx) const = 0; //! Read total difficulty for block specified by hash and number virtual Task> read_total_difficulty(const Hash& block_hash, BlockNum block_num) const = 0; virtual Task>> read_block_num_by_transaction_hash(const evmc::bytes32& transaction_hash) const = 0; virtual Task> read_transaction_by_idx_in_block(BlockNum block_num, uint64_t txn_idx) const = 0; virtual Task, std::optional>> read_head_header_and_hash() const = 0; }; } // namespace silkworm::db::chain ================================================ FILE: silkworm/db/chain/local_chain_storage.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "local_chain_storage.hpp" #include #include namespace silkworm::db::chain { LocalChainStorage::LocalChainStorage(db::DataModel data_model, const ChainConfig& chain_config) : data_model_{data_model}, chain_config_{chain_config} {} Task LocalChainStorage::read_chain_config() const { co_return chain_config_; } Task LocalChainStorage::max_block_num() const { co_return data_model_.max_block_num(); } Task> LocalChainStorage::read_block_num(const Hash& hash) const { co_return data_model_.read_block_num(hash); } Task LocalChainStorage::read_block(HashAsSpan hash, BlockNum block_num, bool read_senders, Block& block) const { co_return data_model_.read_block(hash, block_num, read_senders, block); } Task LocalChainStorage::read_block(const Hash& hash, BlockNum block_num, Block& block) const { co_return data_model_.read_block(hash, block_num, block); } Task LocalChainStorage::read_block(const Hash& hash, Block& block) const { const auto block_num = co_await read_block_num(hash); if (!block_num) { co_return false; } co_return co_await read_block(hash, *block_num, block); } Task LocalChainStorage::read_block(BlockNum block_num, bool read_senders, Block& block) const { co_return data_model_.read_block(block_num, read_senders, block); } Task> LocalChainStorage::read_header(BlockNum block_num, HashAsArray hash) const { co_return data_model_.read_header(block_num, hash); } Task> LocalChainStorage::read_header(BlockNum block_num, const Hash& hash) const { co_return data_model_.read_header(block_num, hash); } Task> LocalChainStorage::read_header(const Hash& hash) const { co_return data_model_.read_header(hash); } Task> LocalChainStorage::read_sibling_headers(BlockNum block_num) const { co_return data_model_.read_sibling_headers(block_num); } Task LocalChainStorage::read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const { co_return data_model_.read_body(block_num, hash, read_senders, body); } Task LocalChainStorage::read_body(const Hash& hash, BlockNum block_num, BlockBody& body) const { co_return data_model_.read_body(hash, block_num, body); } Task LocalChainStorage::read_body(const Hash& hash, BlockBody& body) const { co_return data_model_.read_body(hash, body); } Task> LocalChainStorage::read_canonical_header_hash(BlockNum block_num) const { co_return data_model_.read_canonical_header_hash(block_num); } Task> LocalChainStorage::read_canonical_header(BlockNum block_num) const { co_return data_model_.read_canonical_header(block_num); } Task LocalChainStorage::read_canonical_body(BlockNum block_num, BlockBody& body) const { co_return data_model_.read_canonical_body(block_num, body); } Task> LocalChainStorage::read_raw_canonical_body_for_storage(BlockNum block_num) const { co_return data_model_.read_raw_canonical_body_for_storage(block_num); } Task LocalChainStorage::read_canonical_block(BlockNum block_num, Block& block) const { co_return data_model_.read_canonical_block(block_num, block); } Task LocalChainStorage::has_body(BlockNum block_num, HashAsArray hash) const { co_return data_model_.has_body(block_num, hash); } Task LocalChainStorage::has_body(BlockNum block_num, const Hash& hash) const { co_return data_model_.has_body(block_num, hash); } Task LocalChainStorage::read_rlp_transactions(BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) const { co_return data_model_.read_rlp_transactions(block_num, hash, rlp_txs); } Task LocalChainStorage::read_rlp_transaction(const evmc::bytes32& txn_hash, Bytes& rlp_tx) const { auto result = data_model_.read_tx_lookup(txn_hash); if (!result) { co_return false; } auto block_hash = data_model_.read_canonical_header_hash(result->first); if (!block_hash) { co_return false; } std::vector rlp_txs; if (!co_await read_rlp_transactions(result->first, *block_hash, rlp_txs)) { co_return false; } for (const auto& rlp : rlp_txs) { if (std::bit_cast(keccak256(rlp)) == txn_hash) { rlp_tx = rlp; co_return true; } } co_return false; } Task> LocalChainStorage::read_total_difficulty(const Hash& hash, BlockNum block_num) const { co_return data_model_.read_total_difficulty(block_num, hash); } Task>> LocalChainStorage::read_block_num_by_transaction_hash(const evmc::bytes32& transaction_hash) const { co_return data_model_.read_tx_lookup(transaction_hash); } Task> LocalChainStorage::read_transaction_by_idx_in_block(BlockNum block_num, uint64_t txn_idx) const { co_return data_model_.read_transaction_by_txn_idx(block_num, txn_idx); } Task, std::optional>> LocalChainStorage::read_head_header_and_hash() const { co_return data_model_.read_head_header_and_hash(); } } // namespace silkworm::db::chain ================================================ FILE: silkworm/db/chain/local_chain_storage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "chain_storage.hpp" namespace silkworm::db::chain { //! LocalChainStorage must be used when blockchain data is local with respect to the running component, i.e. it is //! in local database (accessed via MDBX API) or local snapshot files (accessed via custom snapshot API) class LocalChainStorage : public ChainStorage { public: LocalChainStorage(db::DataModel data_model, const ChainConfig& chain_config); ~LocalChainStorage() override = default; Task read_chain_config() const override; Task max_block_num() const override; Task> read_block_num(const Hash& hash) const override; Task read_block(HashAsSpan hash, BlockNum block_num, bool read_senders, Block& block) const override; Task read_block(const Hash& hash, BlockNum block_num, Block& block) const override; Task read_block(const Hash& hash, Block& block) const override; Task read_block(BlockNum block_num, bool read_senders, Block& block) const override; Task> read_header(BlockNum block_num, HashAsArray hash) const override; Task> read_header(BlockNum block_num, const Hash& hash) const override; Task> read_header(const Hash& hash) const override; Task> read_sibling_headers(BlockNum block_num) const override; Task read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const override; Task read_body(const Hash& hash, BlockNum block_num, BlockBody& body) const override; Task read_body(const Hash& hash, BlockBody& body) const override; Task> read_canonical_header_hash(BlockNum block_num) const override; Task> read_canonical_header(BlockNum block_num) const override; Task read_canonical_body(BlockNum block_num, BlockBody& body) const override; Task> read_raw_canonical_body_for_storage(BlockNum block_num) const override; Task read_canonical_block(BlockNum block_num, Block& block) const override; Task has_body(BlockNum block_num, HashAsArray hash) const override; Task has_body(BlockNum block_num, const Hash& hash) const override; Task read_rlp_transactions(BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) const override; Task read_rlp_transaction(const evmc::bytes32& txn_hash, Bytes& rlp_tx) const override; Task> read_total_difficulty(const Hash& block_hash, BlockNum block_num) const override; Task>> read_block_num_by_transaction_hash(const evmc::bytes32& transaction_hash) const override; Task> read_transaction_by_idx_in_block(BlockNum block_num, uint64_t txn_idx) const override; Task, std::optional>> read_head_header_and_hash() const override; private: db::DataModel data_model_; const ChainConfig& chain_config_; }; } // namespace silkworm::db::chain ================================================ FILE: silkworm/db/chain/providers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "chain_storage.hpp" namespace silkworm::db::chain { using BlockProvider = std::function(BlockNum, HashAsSpan, bool, Block&)>; using BlockNumFromTxnHashProvider = std::function>>(HashAsSpan)>; using BlockNumFromBlockHashProvider = std::function>(HashAsSpan)>; using CanonicalBlockHashFromNumberProvider = std::function>(BlockNum)>; using CanonicalBodyForStorageProvider = std::function>(BlockNum)>; struct Providers { BlockProvider block; BlockNumFromTxnHashProvider block_num_from_txn_hash; BlockNumFromBlockHashProvider block_num_from_hash; CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number; CanonicalBodyForStorageProvider canonical_body_for_storage; }; inline CanonicalBodyForStorageProvider canonical_body_provider_from_chain_storage(const ChainStorage& chain_storage) { return db::chain::CanonicalBodyForStorageProvider{ [&chain_storage](BlockNum block_num) -> Task> { co_return co_await chain_storage.read_raw_canonical_body_for_storage(block_num); }}; } } // namespace silkworm::db::chain ================================================ FILE: silkworm/db/chain/remote_chain_storage.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_chain_storage.hpp" #include #include #include #include #include #include #include namespace silkworm::db::chain { RemoteChainStorage::RemoteChainStorage(kv::api::Transaction& tx, Providers providers) : tx_{tx}, providers_{std::move(providers)} {} Task RemoteChainStorage::read_chain_config() const { const auto genesis_block_hash{co_await providers_.canonical_block_hash_from_number(kEarliestBlockNum)}; if (!genesis_block_hash) { throw std::runtime_error{"cannot read genesis block hash in read_chain_config"}; } SILK_DEBUG << "rawdb::read_chain_config genesis_block_hash: " << to_hex(genesis_block_hash->bytes); const ByteView genesis_block_hash_bytes{genesis_block_hash->bytes, kHashLength}; const auto data{co_await tx_.get_one(db::table::kConfigName, genesis_block_hash_bytes)}; if (data.empty()) { throw std::invalid_argument{"empty chain config data in read_chain_config"}; } SILK_DEBUG << "rawdb::read_chain_config chain config data: " << data.c_str(); const auto json_config = nlohmann::json::parse(data.begin(), data.end()); SILK_TRACE << "rawdb::read_chain_config chain config JSON: " << json_config.dump(); std::optional chain_config = ChainConfig::from_json(json_config); if (!chain_config) { throw std::runtime_error{"invalid chain config JSON in read_chain_config"}; } chain_config->genesis_hash = *genesis_block_hash; co_return *chain_config; } Task RemoteChainStorage::max_block_num() const { throw std::logic_error{"RemoteChainStorage::max_block_num not implemented"}; } Task> RemoteChainStorage::read_block_num(const Hash& hash) const { co_return co_await providers_.block_num_from_hash(hash.bytes); } Task RemoteChainStorage::read_block(HashAsSpan hash, BlockNum block_num, bool read_senders, Block& block) const { co_return co_await providers_.block(block_num, hash, read_senders, block); } Task RemoteChainStorage::read_block(const Hash& hash, BlockNum block_num, Block& block) const { co_return co_await providers_.block(block_num, hash.bytes, /*.read_senders=*/false, block); } Task RemoteChainStorage::read_block(const Hash& hash, Block& block) const { const auto block_num = co_await providers_.block_num_from_hash(hash.bytes); if (!block_num) { co_return false; } co_return co_await providers_.block(*block_num, hash.bytes, /*.read_senders=*/false, block); } Task RemoteChainStorage::read_block(BlockNum block_num, bool read_senders, Block& block) const { const auto hash = co_await providers_.canonical_block_hash_from_number(block_num); if (!hash) { co_return false; } co_return co_await providers_.block(block_num, hash->bytes, read_senders, block); } Task> RemoteChainStorage::read_header(BlockNum block_num, HashAsArray hash) const { Block block; const bool success = co_await providers_.block(block_num, hash, /*.read_senders=*/false, block); std::optional header; if (success) { header = std::move(block.header); } co_return header; } Task> RemoteChainStorage::read_header(BlockNum block_num, const Hash& hash) const { co_return co_await read_header(block_num, hash.bytes); } Task> RemoteChainStorage::read_header(const Hash& hash) const { const auto block_num = co_await providers_.block_num_from_hash(hash.bytes); if (!block_num) { co_return std::nullopt; } SILK_DEBUG << "RemoteChainStorage::read_header: " << silkworm::to_hex(hash) << " number: " << *block_num; co_return co_await read_header(*block_num, hash.bytes); } Task> RemoteChainStorage::read_sibling_headers(BlockNum /*block_num*/) const { throw std::logic_error{"RemoteChainStorage::read_sibling_headers not implemented"}; } Task RemoteChainStorage::read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const { Block block; const bool success = co_await providers_.block(block_num, hash, read_senders, block); if (!success) { co_return false; } body.transactions = std::move(block.transactions); body.ommers = std::move(block.ommers); body.withdrawals = std::move(block.withdrawals); co_return true; } Task RemoteChainStorage::read_body(const Hash& hash, BlockNum block_num, BlockBody& body) const { co_return co_await read_body(block_num, hash.bytes, /*.read_senders=*/false, body); } Task RemoteChainStorage::read_body(const Hash& hash, BlockBody& body) const { const auto block_num = co_await providers_.block_num_from_hash(hash.bytes); if (!block_num) { co_return false; } co_return co_await read_body(*block_num, hash.bytes, /*.read_senders=*/false, body); } Task> RemoteChainStorage::read_canonical_header_hash(BlockNum block_num) const { co_return co_await providers_.canonical_block_hash_from_number(block_num); } Task> RemoteChainStorage::read_canonical_header(BlockNum block_num) const { const auto hash = co_await providers_.canonical_block_hash_from_number(block_num); if (!hash) { co_return std::nullopt; } co_return co_await read_header(block_num, *hash); } Task RemoteChainStorage::read_canonical_body(BlockNum block_num, BlockBody& body) const { Block block; const auto hash = co_await providers_.canonical_block_hash_from_number(block_num); if (!hash) { co_return false; } const bool success = co_await providers_.block(block_num, hash->bytes, /*.read_senders=*/false, block); if (!success) { co_return false; } body.transactions = std::move(block.transactions); body.ommers = std::move(block.ommers); body.withdrawals = std::move(block.withdrawals); co_return true; } Task> RemoteChainStorage::read_raw_canonical_body_for_storage(BlockNum block_num) const { co_return co_await providers_.canonical_body_for_storage(block_num); } Task RemoteChainStorage::read_canonical_block(BlockNum block_num, Block& block) const { const auto hash = co_await providers_.canonical_block_hash_from_number(block_num); if (!hash) { co_return false; } const bool success = co_await providers_.block(block_num, hash->bytes, /*.read_senders=*/false, block); if (!success) { co_return false; } co_return true; } Task RemoteChainStorage::has_body(BlockNum block_num, HashAsArray hash) const { BlockBody body; co_return co_await read_body(block_num, hash, /*.read_senders=*/false, body); } Task RemoteChainStorage::has_body(BlockNum block_num, const Hash& hash) const { BlockBody body; co_return co_await read_body(hash, block_num, body); } Task RemoteChainStorage::read_rlp_transactions(BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) const { Block block; const bool success = co_await providers_.block(block_num, hash.bytes, /*.read_senders=*/false, block); if (!success) { co_return false; } rlp_txs.reserve(block.transactions.size()); for (const auto& transaction : block.transactions) { rlp::encode(rlp_txs.emplace_back(), transaction, /*wrap_eip2718_into_string=*/false); } co_return true; } Task RemoteChainStorage::read_rlp_transaction(const evmc::bytes32& txn_hash, Bytes& rlp_tx) const { auto result = co_await providers_.block_num_from_txn_hash(txn_hash.bytes); if (!result) { co_return false; } const auto block_hash = co_await providers_.canonical_block_hash_from_number(result->first); if (!block_hash) { co_return false; } Block block; const bool success = co_await providers_.block(result->first, block_hash->bytes, /*.read_senders=*/false, block); if (!success) { co_return false; } for (const auto& transaction : block.transactions) { Bytes rlp; if (transaction.hash() == txn_hash) { rlp::encode(rlp, transaction, /*wrap_eip2718_into_string=*/false); rlp_tx = rlp; co_return true; } } co_return false; } Task> RemoteChainStorage::read_total_difficulty(const Hash& hash, BlockNum block_num) const { const auto block_key = db::block_key(block_num, hash.bytes); SILK_TRACE << "read_total_difficulty block_key: " << to_hex(block_key); const auto result{co_await tx_.get_one(table::kDifficultyName, block_key)}; if (result.empty()) { co_return std::nullopt; } ByteView value{result}; intx::uint256 total_difficulty{0}; auto decoding_result{rlp::decode(value, total_difficulty)}; if (!decoding_result) { throw std::runtime_error{"cannot RLP-decode total difficulty value in read_total_difficulty"}; } SILK_DEBUG << "read_total_difficulty canonical total difficulty: " << total_difficulty; co_return total_difficulty; } Task>> RemoteChainStorage::read_block_num_by_transaction_hash(const evmc::bytes32& transaction_hash) const { co_return co_await providers_.block_num_from_txn_hash(transaction_hash.bytes); } Task> RemoteChainStorage::read_transaction_by_idx_in_block(BlockNum block_num, uint64_t txn_idx) const { const auto block_hash = co_await read_canonical_header_hash(block_num); if (!block_hash) { co_return std::nullopt; } BlockBody body; if (const bool success = co_await read_body(*block_hash, block_num, body); !success) { co_return std::nullopt; } if (txn_idx >= body.transactions.size()) { co_return std::nullopt; } co_return body.transactions[txn_idx]; } Task, std::optional>> RemoteChainStorage::read_head_header_and_hash() const { const auto value = co_await tx_.get_one(table::kHeadHeaderName, string_view_to_byte_view(table::kHeadHeaderName)); if (value.empty()) { throw std::runtime_error{"empty head header hash value in read_head_header_hash"}; } const auto head_header_hash{to_bytes32(value)}; SILK_DEBUG << "head header hash: " << to_hex(head_header_hash); auto header = co_await read_header(head_header_hash); Hash header_hash{head_header_hash}; co_return std::pair{std::move(header), header_hash}; } } // namespace silkworm::db::chain ================================================ FILE: silkworm/db/chain/remote_chain_storage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "chain_storage.hpp" namespace silkworm::db::chain { //! RemoteChainStorage must be used when blockchain data is remote with respect to the running component, i.e. it is //! in remote database (accessed via gRPC KV I/F) or remote snapshot files (accessed via gRPC ETHBACKEND I/F) class RemoteChainStorage : public ChainStorage { public: RemoteChainStorage(kv::api::Transaction& tx, Providers providers); ~RemoteChainStorage() override = default; Task read_chain_config() const override; Task max_block_num() const override; Task> read_block_num(const Hash& hash) const override; Task read_block(HashAsSpan hash, BlockNum block_num, bool read_senders, Block& block) const override; Task read_block(const Hash& hash, BlockNum block_num, Block& block) const override; Task read_block(const Hash& hash, Block& block) const override; Task read_block(BlockNum block_num, bool read_senders, Block& block) const override; Task> read_header(BlockNum block_num, HashAsArray hash) const override; Task> read_header(BlockNum block_num, const Hash& hash) const override; Task> read_header(const Hash& hash) const override; Task> read_sibling_headers(BlockNum block_num) const override; Task read_body(BlockNum block_num, HashAsArray hash, bool read_senders, BlockBody& body) const override; Task read_body(const Hash& hash, BlockNum block_num, BlockBody& body) const override; Task read_body(const Hash& hash, BlockBody& body) const override; Task> read_canonical_header_hash(BlockNum block_num) const override; Task> read_canonical_header(BlockNum block_num) const override; Task read_canonical_body(BlockNum block_num, BlockBody& body) const override; Task> read_raw_canonical_body_for_storage(BlockNum block_num) const override; Task read_canonical_block(BlockNum block_num, Block& block) const override; Task has_body(BlockNum block_num, HashAsArray hash) const override; Task has_body(BlockNum block_num, const Hash& hash) const override; Task read_rlp_transactions(BlockNum block_num, const evmc::bytes32& hash, std::vector& rlp_txs) const override; Task read_rlp_transaction(const evmc::bytes32& txn_hash, Bytes& rlp_tx) const override; Task> read_total_difficulty(const Hash& block_hash, BlockNum block_num) const override; Task>> read_block_num_by_transaction_hash(const evmc::bytes32& transaction_hash) const override; Task> read_transaction_by_idx_in_block(BlockNum block_num, uint64_t txn_idx) const override; Task, std::optional>> read_head_header_and_hash() const override; protected: Providers& providers() { return providers_; } private: kv::api::Transaction& tx_; Providers providers_; }; } // namespace silkworm::db::chain ================================================ FILE: silkworm/db/chain/remote_chain_storage_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_chain_storage.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::db::chain { using Catch::Matchers::Message; using testing::_; using testing::InvokeWithoutArgs; using testing::Unused; static const evmc::bytes32 kBlockHash{0x439816753229fc0736bf86a5048de4bc9fcdede8c91dadf88c828c76b2281dff_bytes32}; static Bytes kInvalidJsonChainConfig{*from_hex("000102")}; static Bytes kChainConfig{*from_hex( "7b226265726c696e426c6f636b223a31323234343030302c2262797a6" "16e7469756d426c6f636b223a343337303030302c22636861696e4964223a312c22636f6e7374616e74696e6f706c65426c6f636b223a" "373238303030302c2264616f466f726b426c6f636b223a313932303030302c22656970313530426c6f636b223a323436333030302c226" "56970313535426c6f636b223a323637353030302c22657468617368223a7b7d2c22686f6d657374656164426c6f636b223a3131353030" "30302c22697374616e62756c426c6f636b223a393036393030302c226c6f6e646f6e426c6f636b223a31323936353030302c226d75697" "2476c6163696572426c6f636b223a393230303030302c2270657465727362757267426c6f636b223a373238303030307d")}; static chain::Providers make_null_providers() { return { .block = [](BlockNum, HashAsSpan, bool, Block&) -> Task { co_return false; }, .block_num_from_txn_hash = [](HashAsSpan) -> Task>> { co_return std::make_pair(0, 0); }, .block_num_from_hash = [](HashAsSpan) -> Task> { co_return 0; }, .canonical_block_hash_from_number = [](BlockNum) -> Task> { co_return kBlockHash; }, }; } class RemoteChainStorageForTest : public RemoteChainStorage { public: using RemoteChainStorage::providers; using RemoteChainStorage::RemoteChainStorage; }; struct RemoteChainStorageTest : public silkworm::test_util::ContextTestBase { test_util::MockTransaction transaction; RemoteChainStorageForTest storage{transaction, make_null_providers()}; chain::Providers& providers{storage.providers()}; }; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task { co_return Bytes{}; })); CHECK_THROWS_AS(spawn_and_wait(storage.read_chain_config()), std::invalid_argument); } SECTION("invalid JSON chain data") { EXPECT_CALL(transaction, get_one(table::kConfigName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kInvalidJsonChainConfig; })); CHECK_THROWS_AS(spawn_and_wait(storage.read_chain_config()), nlohmann::json::parse_error); } SECTION("valid JSON chain data") { EXPECT_CALL(transaction, get_one(table::kConfigName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kChainConfig; })); const auto chain_config = spawn_and_wait(storage.read_chain_config()); CHECK(chain_config.genesis_hash == 0x439816753229fc0736bf86a5048de4bc9fcdede8c91dadf88c828c76b2281dff_bytes32); CHECK(chain_config.to_json() == R"({ "berlinBlock":12244000, "byzantiumBlock":4370000, "chainId":1, "constantinopleBlock":7280000, "daoForkBlock":1920000, "eip150Block":2463000, "eip155Block":2675000, "ethash":{}, "genesisBlockHash":"0x439816753229fc0736bf86a5048de4bc9fcdede8c91dadf88c828c76b2281dff", "homesteadBlock":1150000, "istanbulBlock":9069000, "londonBlock":12965000, "muirGlacierBlock":9200000, "petersburgBlock":7280000 })"_json); } } #endif // _WIN32 TEST_CASE_METHOD(RemoteChainStorageTest, "read_transaction_by_idx_in_block") { SECTION("not found") { const auto txn = spawn_and_wait(storage.read_transaction_by_idx_in_block(0, 0)); REQUIRE_FALSE(txn); } SECTION("found") { Block block = silkworm::test_util::sample_block(); providers.block = [&](BlockNum, HashAsSpan, bool, Block& b) -> Task { b = block; co_return true; }; const auto txn0 = spawn_and_wait(storage.read_transaction_by_idx_in_block(block.header.number, /*txn_idx=*/0)); REQUIRE(txn0 == silkworm::test_util::kSampleTx0); const auto txn1 = spawn_and_wait(storage.read_transaction_by_idx_in_block(block.header.number, /*txn_idx=*/1)); REQUIRE(txn1 == silkworm::test_util::kSampleTx1); } } } // namespace silkworm::db::chain ================================================ FILE: silkworm/db/chain_data_init.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "chain_data_init.hpp" #include #include #include #include #include #include namespace silkworm::db { ChainConfig chain_data_init(const ChainDataInitSettings& node_settings) { // Output mdbx build info log::Debug( "libmdbx", { "version", mdbx::get_version().git.describe, "build", mdbx::get_build().target, "compiler", mdbx::get_build().compiler, }); auto chaindata_env_config = node_settings.chaindata_env_config; chaindata_env_config.create = !std::filesystem::exists(datastore::kvdb::get_datafile_path(chaindata_env_config.path)); chaindata_env_config.exclusive = true; // Open chaindata environment and check tables are consistent log::Info("Opening database", {"path", chaindata_env_config.path}); mdbx::env_managed chaindata_env = open_env(chaindata_env_config); datastore::kvdb::RWTxnManaged tx(chaindata_env); // Ensures all tables are present table::check_or_create_chaindata_tables(tx); log::Info("Database schema", {"version", read_schema_version(tx)->to_string()}); // Detect the max downloaded header. We need that to detect if we can apply changes in chain config and/or // prune mode const auto header_download_progress{stages::read_stage_progress(tx, stages::kHeadersKey)}; // Check db is initialized with chain config std::optional chain_config; { chain_config = read_chain_config(tx); if (!chain_config.has_value() && node_settings.init_if_empty) { auto source_data{read_genesis_data(node_settings.network_id)}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /* allow_exceptions = */ false); if (genesis_json.is_discarded()) { throw std::runtime_error("Could not initialize db for chain id " + std::to_string(node_settings.network_id) + " : unknown network"); } log::Debug("Priming database", {"network id", std::to_string(node_settings.network_id)}); initialize_genesis(tx, genesis_json, /*allow_exceptions=*/true); tx.commit_and_renew(); chain_config = read_chain_config(tx); } if (!chain_config.has_value()) { throw std::runtime_error("Unable to retrieve chain configuration"); } const ChainId chain_id = chain_config->chain_id; if (chain_id != node_settings.network_id) { throw std::runtime_error("Incompatible network id. Command line expects " + std::to_string(node_settings.network_id) + "; Database has " + std::to_string(chain_id)); } const auto known_chain{kKnownChainConfigs.find(chain_id)}; if (known_chain && **known_chain != *chain_config) { // If loaded config is known we must ensure is up-to-date with hardcoded one // Loop all respective JSON members to find discrepancies auto known_chain_config_json{(*known_chain)->to_json()}; auto active_chain_config_json = chain_config->to_json(); bool new_members_added{false}; bool old_members_changed(false); for (auto& [known_key, known_value] : known_chain_config_json.items()) { if (!active_chain_config_json.contains(known_key)) { // Is this new key a definition of a new fork block or a bomb delay block ? // If so we need to check its new value must be **beyond** the max // header processed. const std::regex block_pattern(R"(Block$)", std::regex_constants::icase); if (std::regex_match(known_key, block_pattern)) { // New forkBlock definition (as well as bomb defusing block) must be "activated" to be relevant. // By "activated" we mean it has to have a value > 0. Code should also take into account // different chain_id(s) if special features are embedded from genesis // All our chain configurations inherit from ChainConfig which necessarily needs to be extended // to allow derivative chains to support new fork blocks if (const auto known_value_activation{known_value.get()}; known_value_activation > 0 && known_value_activation <= header_download_progress) { throw std::runtime_error("Can't apply new chain config key " + known_key + "with value " + std::to_string(known_value_activation) + " as the database has already blocks up to " + std::to_string(header_download_progress)); } } new_members_added = true; continue; } const auto active_value{active_chain_config_json[known_key]}; if (active_value.type_name() != known_value.type_name()) { throw std::runtime_error("Hard-coded chain config key " + known_key + " has type " + std::string(known_value.type_name()) + " whilst persisted config has type " + std::string(active_value.type_name())); } if (known_value.is_number()) { // Check whether activation value has been modified const auto known_value_activation{known_value.get()}; const auto active_value_activation{active_value.get()}; if (known_value_activation != active_value_activation) { const bool must_throw{ // Can't de-activate an already activated fork block (!known_value_activation && active_value_activation && active_value_activation <= header_download_progress) || // Can't activate a fork block BEFORE current block_num (!active_value_activation && known_value_activation && known_value_activation <= header_download_progress) || // Can change activation block_num BEFORE current block_num (known_value_activation && active_value_activation && std::min(known_value_activation, active_value_activation) <= header_download_progress)}; if (must_throw) { throw std::runtime_error("Can't apply modified chain config key " + known_key + " from " + std::to_string(active_value_activation) + " to " + std::to_string(known_value_activation) + " as the database has already headers up to " + std::to_string(header_download_progress)); } old_members_changed = true; } } } if (new_members_added || old_members_changed) { update_chain_config(tx, **known_chain); tx.commit_and_renew(); chain_config = **known_chain; } } // Load genesis_hash chain_config->genesis_hash = read_canonical_header_hash(tx, 0); if (!chain_config->genesis_hash.has_value()) throw std::runtime_error("Could not load genesis hash"); log::Info("Starting Silkworm", {"chain", (known_chain ? std::to_string(chain_id) : "unknown/custom"), "config", chain_config->to_json().dump()}); } // Detect prune-mode and verify is compatible { auto db_prune_mode{read_prune_mode(*tx)}; if (db_prune_mode != node_settings.prune_mode) { // In case we have mismatching modes (cli != db) we prevent // further execution ONLY if we've already synced something if (header_download_progress) { throw std::runtime_error("Can't change prune_mode on already synced data. Expected " + db_prune_mode.to_string() + " got " + node_settings.prune_mode.to_string()); } write_prune_mode(*tx, node_settings.prune_mode); } log::Info("Effective pruning", {"mode", node_settings.prune_mode.to_string()}); } tx.commit_and_stop(); chaindata_env.close(); return std::move(*chain_config); } } // namespace silkworm::db ================================================ FILE: silkworm/db/chain_data_init.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::db { struct ChainDataInitSettings { datastore::kvdb::EnvConfig chaindata_env_config; db::PruneMode prune_mode; ChainId network_id{0}; bool init_if_empty{true}; }; //! \brief Ensure database is ready to take off and consistent with command line arguments ChainConfig chain_data_init(const ChainDataInitSettings& node_settings); } // namespace silkworm::db ================================================ FILE: silkworm/db/chain_head.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "chain_head.hpp" #include #include #include #include namespace silkworm::db { using namespace silkworm::datastore::kvdb; ChainHead read_chain_head(ROTxn& txn) { ChainHead chain_head; BlockNum head_block_num = db::stages::read_stage_progress(txn, db::stages::kBlockBodiesKey); chain_head.block_num = head_block_num; auto head_hash = db::read_canonical_header_hash(txn, head_block_num); if (head_hash) { chain_head.hash = head_hash.value(); } else { SILK_WARN_M("db::ChainHead") << "canonical hash at block_num " << std::to_string(head_block_num) << " not found in db"; return chain_head; } auto head_total_difficulty = db::read_total_difficulty(txn, head_block_num, *head_hash); if (head_total_difficulty) { chain_head.total_difficulty = head_total_difficulty.value(); } else { SILK_WARN_M("db::ChainHead") << "total difficulty of canonical hash at block_num " << std::to_string(head_block_num) << " not found in db"; } return chain_head; } ChainHead read_chain_head(datastore::kvdb::ROAccess db_access) { auto txn = db_access.start_ro_tx(); [[maybe_unused]] auto _ = gsl::finally([&txn] { txn.abort(); }); return read_chain_head(txn); } } // namespace silkworm::db ================================================ FILE: silkworm/db/chain_head.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db { ChainHead read_chain_head(datastore::kvdb::ROTxn& txn); ChainHead read_chain_head(datastore::kvdb::ROAccess db_access); } // namespace silkworm::db ================================================ FILE: silkworm/db/cli/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(absl REQUIRED) find_package(Boost REQUIRED COMPONENTS headers) find_package(CLI11 REQUIRED) find_package(magic_enum REQUIRED) add_library(silkworm_db_cli "db_max_readers_option.cpp" "snapshot_options.cpp") target_link_libraries( silkworm_db_cli PUBLIC CLI11::CLI11 silkworm_snapshots PRIVATE silkworm_datastore_kvdb ) add_executable(check_blockhashes "check_blockhashes.cpp") target_link_libraries(check_blockhashes PRIVATE silkworm_db CLI11::CLI11) add_executable(check_changes "check_changes.cpp") target_link_libraries(check_changes PRIVATE silkworm_db CLI11::CLI11 absl::time) add_executable(check_hashstate "check_hashstate.cpp") target_link_libraries(check_hashstate PRIVATE silkworm_db CLI11::CLI11) add_executable(check_log_indices "check_log_indices.cpp") target_link_libraries(check_log_indices PRIVATE silkworm_db silkworm_infra_cli cborcpp) add_executable(check_senders "check_senders.cpp") target_link_libraries(check_senders PRIVATE silkworm_db silkworm_infra_cli) add_executable(check_tx_lookup "check_tx_lookup.cpp") target_link_libraries(check_tx_lookup PRIVATE silkworm_db CLI11::CLI11) add_executable(scan_txs "scan_txs.cpp") target_link_libraries(scan_txs PRIVATE silkworm_db CLI11::CLI11 absl::time) add_executable(snapshots "snapshots.cpp") target_link_libraries(snapshots PRIVATE silkworm_db silkworm_infra_cli absl::strings magic_enum::magic_enum) add_executable(db_toolbox "db_toolbox.cpp") target_link_libraries(db_toolbox PRIVATE silkworm_db silkworm_infra_cli magic_enum::magic_enum) ================================================ FILE: silkworm/db/cli/check_blockhashes.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include using namespace silkworm; int main(int argc, char* argv[]) { CLI::App app{"Check Blockhashes => BlockNum mapping in database"}; std::string chaindata{DataDirectory{}.chaindata().path().string()}; app.add_option("--chaindata", chaindata, "Path to a database populated by Erigon") ->capture_default_str() ->check(CLI::ExistingDirectory); CLI11_PARSE(app, argc, argv); try { auto data_dir{DataDirectory::from_chaindata(chaindata)}; data_dir.deploy(); datastore::kvdb::EnvConfig db_config{data_dir.chaindata().path().string()}; auto env{datastore::kvdb::open_env(db_config)}; auto txn{env.start_read()}; auto canonical_hashes_table = datastore::kvdb::open_cursor(txn, db::table::kCanonicalHashes); auto blockhashes_table = datastore::kvdb::open_cursor(txn, db::table::kHeaderNumbers); uint32_t scanned_headers{0}; SILK_INFO << "Checking Block Hashes..."; auto canonical_hashes_data{canonical_hashes_table.to_first(/*throw_notfound*/ false)}; StopWatch sw{}; auto start_time{sw.start()}; // Check if each hash has the correct number according to the header table while (canonical_hashes_data) { ByteView hash_data_view{datastore::kvdb::from_slice(canonical_hashes_data.value)}; // Canonical Hash auto block_hashes_data{blockhashes_table.find(canonical_hashes_data.value, /*throw_notfound*/ false)}; if (!block_hashes_data) { uint64_t hash_block_num{ endian::load_big_u64(static_cast(canonical_hashes_data.key.data()))}; SILK_ERROR << "Hash " << to_hex(hash_data_view) << " (block " << hash_block_num << ") not found in " << db::table::kHeaderNumbers.name << " table "; } else if (block_hashes_data.value != canonical_hashes_data.key) { uint64_t hash_block_num = endian::load_big_u64(static_cast(canonical_hashes_data.key.data())); uint64_t block_num = endian::load_big_u64(static_cast(block_hashes_data.value.data())); SILK_ERROR << "Hash " << to_hex(hash_data_view) << " should match block " << hash_block_num << " but got " << block_num; } if (++scanned_headers % 100000 == 0) { auto [_, duration] = sw.lap(); SILK_INFO << "Scanned headers " << scanned_headers << " in " << StopWatch::format(duration); } canonical_hashes_data = canonical_hashes_table.to_next(/*throw_notfound*/ false); } auto [end_time, _] = sw.lap(); SILK_INFO << "Done! " << StopWatch::format(end_time - start_time); } catch (const std::exception& ex) { SILK_ERROR << ex.what(); return -5; } return 0; } ================================================ FILE: silkworm/db/cli/check_changes.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace evmc::literals; using namespace silkworm; // Non-existing accounts only touched by zero-value internal transactions: // e.g. https://etherscan.io/address/0x000000000000000000636f6e736f6c652e6c6f67 static const absl::flat_hash_set kPhantomAccounts{ 0x000000000000000000636f6e736f6c652e6c6f67_address, 0x2386f26fc10000b4e16d0168e52d35cacd2c6185_address, 0x5a719cf3e02c17c876f6d294adb5cb7c6eb47e2f_address, }; static void print_storage_locations(const db::ChangedLocations& changed_locations) { std::cout << "storage:\n"; for (const auto& [location, value] : changed_locations) { std::cout << "\t" << to_hex(location) << " = " << to_hex(value) << "\n"; } } static void print_storage_incarnations(const db::ChangedIncarnations& changed_incarnations) { for (const auto& [incarnation, changed_locations] : changed_incarnations) { std::cout << "incarnation: " << incarnation << "\n"; print_storage_locations(changed_locations); } } static void print_storage_changes(const evmc::address& address, const db::ChangedIncarnations& changed_incarnations) { std::cout << "address: " << address << "\n"; print_storage_incarnations(changed_incarnations); } static void print_all_storage_changes(const db::StorageChanges& s) { for (const auto& [address, changed_incarnations] : s) { print_storage_changes(address, changed_incarnations); } } int main(int argc, char* argv[]) { SignalHandler::init(); CLI::App app{"Execute Ethereum blocks and compare resulting state changes against db"}; std::string chaindata{DataDirectory{}.chaindata().path().string()}; app.add_option("--chaindata", chaindata, "Path to a database populated by Erigon") ->capture_default_str() ->check(CLI::ExistingDirectory); BlockNum from{1}; app.add_option("--from", from, "Start from block number (inclusive)"); BlockNum to{UINT64_MAX}; app.add_option("--to", to, "Check up to block number (inclusive)"); bool full_mismatch_dump{false}; app.add_flag("--full_mismatch_dump", full_mismatch_dump, "Generate full dump on mismatch") ->capture_default_str(); bool continue_after_mismatch{false}; app.add_flag("--continue_after_mismatch", continue_after_mismatch, "Continue to compare after first mismatch") ->capture_default_str(); CLI11_PARSE(app, argc, argv) BlockNum block_num{from}; try { ensure(from > 0, "Invalid input: from must be greater than zero"); absl::Time t1{absl::Now()}; SILK_INFO << "Checking state change sets in " << chaindata; auto data_dir{DataDirectory::from_chaindata(chaindata)}; data_dir.deploy(); datastore::kvdb::EnvConfig db_config{data_dir.chaindata().path().string()}; db::DataStore data_store{ db_config, data_dir.snapshots().path(), }; auto txn = data_store.chaindata().access_rw().start_rw_tx(); auto chain_config{db::read_chain_config(txn)}; if (!chain_config) { throw std::runtime_error("Unable to retrieve chain config"); } db::DataModel access_layer = db::DataModelFactory{data_store.ref()}(txn); AnalysisCache analysis_cache{/*max_size=*/5'000}; std::vector receipts; auto rule_set{protocol::rule_set_factory(*chain_config)}; Block block; for (; block_num <= to; ++block_num) { SILK_TRACE << "Processing block " << block_num; if (!access_layer.read_block(block_num, /*read_senders=*/true, block)) { SILK_ERROR << "Failed reading block " << block_num; break; } db::Buffer buffer{txn, std::make_unique(access_layer)}; buffer.set_historical_block(block_num); ExecutionProcessor processor{block, *rule_set, buffer, *chain_config, true}; processor.evm().analysis_cache = &analysis_cache; if (const ValidationResult res = processor.execute_block(receipts); res != ValidationResult::kOk) { SILK_ERROR << "Failed execution for block " << block_num << " result " << magic_enum::enum_name<>(res); continue; } processor.flush_state(); db::AccountChanges db_account_changes{db::read_account_changes(txn, block_num)}; const auto& block_account_changes{buffer.account_changes()}; if (block_account_changes.contains(block_num)) { const db::AccountChanges& calculated_account_changes{block_account_changes.at(block_num)}; if (calculated_account_changes != db_account_changes) { bool mismatch{false}; for (const auto& e : db_account_changes) { SILK_INFO << "key=" << to_hex(e.first.bytes) << " value=" << to_hex(e.second); if (!calculated_account_changes.contains(e.first)) { if (!kPhantomAccounts.contains(e.first)) { SILK_ERROR << e.first << " is missing"; mismatch = true; } else { SILK_WARN << "Phantom account " << e.first << " skipped"; } } else if (Bytes val{calculated_account_changes.at(e.first)}; val != e.second) { SILK_ERROR << "Value mismatch for " << e.first << ":\n" << to_hex(val) << "\n" << "vs DB\n" << to_hex(e.second); mismatch = true; } } for (const auto& e : calculated_account_changes) { if (!db_account_changes.contains(e.first)) { SILK_ERROR << e.first << " is not in DB"; mismatch = true; } } if (mismatch) { SILK_ERROR << "Account change mismatch for block " << block_num << " 😲"; } } } else { ensure(db_account_changes.empty(), "read account changes are not empty whilst calculated ones are"); } db::StorageChanges db_storage_changes{db::read_storage_changes(txn, block_num)}; db::StorageChanges calculated_storage_changes{}; if (buffer.storage_changes().contains(block_num)) { calculated_storage_changes = buffer.storage_changes().at(block_num); } if (calculated_storage_changes != db_storage_changes) { SILK_ERROR << "Storage change mismatch for block " << block_num << " 😲"; if (full_mismatch_dump) { std::cout << "calculated storage changes:\n"; print_all_storage_changes(calculated_storage_changes); std::cout << "vs\ndb storage changes:\n"; print_all_storage_changes(db_storage_changes); } int mismatch_count{0}; auto calculated_it{calculated_storage_changes.cbegin()}; auto db_it{db_storage_changes.cbegin()}; for (; calculated_it != calculated_storage_changes.cend() && db_it != db_storage_changes.cend(); ++calculated_it, ++db_it) { const auto& calculated_change{*calculated_it}; const auto& stored_change{*db_it}; if (calculated_change != stored_change) { std::cout << "Mismatch number " << mismatch_count + 1 << ") is:\n- calculated change:\n"; print_storage_changes(calculated_change.first, calculated_change.second); std::cout << "- stored change:\n"; print_storage_changes(stored_change.first, stored_change.second); ++mismatch_count; if (!continue_after_mismatch) { SILK_INFO << "Use flag --continue_after_mismatch to see all mismatches for block " << block_num; break; } } } if (continue_after_mismatch) { SILK_ERROR << "Total mismatch count is " << mismatch_count << " for block " << block_num; } } if (SignalHandler::signalled()) { break; } if (block_num % 100'000 == 0) { absl::Time t2{absl::Now()}; SILK_INFO << "Checked blocks up to " << block_num << " in " << absl::ToDoubleSeconds(t2 - t1) << " s"; t1 = t2; } } } catch (const std::exception& ex) { SILK_ERROR << ex.what(); return -5; } SILK_INFO << "State changes for blocks [" << from << "; " << block_num - 1 << "] have been checked"; return 0; } ================================================ FILE: silkworm/db/cli/check_hashstate.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::db; using namespace silkworm::datastore::kvdb; enum Operation { kHashAccount, kHashStorage, kCode, }; std::pair get_tables_for_checking(Operation operation) { switch (operation) { case kHashAccount: return {table::kPlainState, table::kHashedAccounts}; case kHashStorage: return {table::kPlainState, table::kHashedStorage}; default: return {table::kPlainCodeHash, table::kHashedCodeHash}; } } void check(mdbx::txn& txn, Operation operation) { auto [source_config, target_config] = get_tables_for_checking(operation); auto source_table{open_cursor(txn, source_config)}; auto target_table{open_cursor(txn, target_config)}; auto data{source_table.to_first(/*throw_notfound*/ false)}; while (data) { /* Loop as long as we have no errors*/ Bytes mdb_key_as_bytes{from_slice(data.key)}; if (operation == kHashAccount) { // Account if (data.key.length() != kAddressLength) { data = source_table.to_next(false); continue; } auto hash{keccak256(mdb_key_as_bytes)}; ByteView key{hash.bytes}; auto actual_value{target_table.find(to_slice(key))}; if (!actual_value) { SILK_ERROR << "key: " << to_hex(key) << ", does not exist."; return; } if (actual_value.value != data.value) { SILK_ERROR << "Expected: " << to_hex(from_slice(data.value)) << ", Actual: << " << to_hex(from_slice(actual_value.value)); return; } data = source_table.to_next(false); } else if (operation == kHashStorage) { // Storage if (data.key.length() != kAddressLength) { data = source_table.to_next(false); continue; } Bytes key(kHashLength * 2 + kIncarnationLength, '\0'); std::memcpy(&key[0], keccak256(mdb_key_as_bytes.substr(0, kAddressLength)).bytes, kHashLength); std::memcpy(&key[kHashLength], &mdb_key_as_bytes[kAddressLength], kIncarnationLength); std::memcpy(&key[kHashLength + kIncarnationLength], keccak256(mdb_key_as_bytes.substr(kAddressLength + kIncarnationLength)).bytes, kHashLength); auto target_data{target_table.find_multivalue(to_slice(key), data.value, /*throw_notfound*/ false)}; if (!target_data) { SILK_ERROR << "Key: " << to_hex(key) << ", does not exist."; return; } data = source_table.to_next(false); } else { // Code if (data.key.length() != kAddressLength + kIncarnationLength) { data = source_table.to_next(false); continue; } Bytes key(kHashLength + kIncarnationLength, '\0'); std::memcpy(&key[0], keccak256(mdb_key_as_bytes.substr(0, kAddressLength)).bytes, kHashLength); std::memcpy(&key[kHashLength], &mdb_key_as_bytes[kAddressLength], kIncarnationLength); auto actual_value{target_table.find(to_slice(key), /*throw_notfound*/ false)}; if (!actual_value) { SILK_ERROR << "Key: " << to_hex(key) << ", does not exist."; data = source_table.to_next(false); continue; } if (actual_value.value != data.value) { SILK_ERROR << "Expected: " << to_hex(from_slice(data.value)) << ", Actual: << " << to_hex(from_slice(actual_value.value)); return; } data = source_table.to_next(false); } } } int main(int argc, char* argv[]) { CLI::App app{"Check Hashed state"}; std::string chaindata{DataDirectory{}.chaindata().path().string()}; app.add_option("--chaindata", chaindata, "Path to a database populated by Erigon") ->capture_default_str() ->check(CLI::ExistingDirectory); CLI11_PARSE(app, argc, argv); SILK_INFO << "Checking HashState"; try { auto data_dir{DataDirectory::from_chaindata(chaindata)}; data_dir.deploy(); EnvConfig db_config{data_dir.chaindata().path().string()}; auto env{open_env(db_config)}; auto txn{env.start_write()}; SILK_INFO << "Checking Accounts"; check(txn, kHashAccount); SILK_INFO << "Checking Storage"; check(txn, kHashStorage); SILK_INFO << "Checking Code Keys"; check(txn, kCode); SILK_INFO << "All Done!"; } catch (const std::exception& ex) { SILK_ERROR << ex.what(); return -5; } } ================================================ FILE: silkworm/db/cli/check_log_indices.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using Roaring = roaring::Roaring; using namespace silkworm; using namespace silkworm::db; using namespace silkworm::datastore::kvdb; using namespace silkworm::cmd::common; enum class TargetIndex { kLogAddress, kLogTopic, kBoth }; struct Settings { std::string chaindata{DataDirectory{}.chaindata().path().string()}; BlockNum block_from{0}; std::optional block_to; std::optional address; std::optional topic; TargetIndex index{TargetIndex::kBoth}; log::Settings log_settings; }; Settings parse_cli_settings(int argc, char* argv[]) { CLI::App cli{"Check Transaction Logs => Log Indexes mapping in database"}; Settings settings; try { cli.add_option("--chaindata", settings.chaindata, "Path to a database populated by Silkworm") ->capture_default_str() ->check(CLI::ExistingDirectory); cli.add_option("--from", settings.block_from, "First block number to process (inclusive)") ->capture_default_str() ->check(CLI::NonNegativeNumber); cli.add_option("--to", settings.block_to, "Last block number to process (inclusive)") ->capture_default_str() ->check(CLI::NonNegativeNumber); cli.add_option("--address", [&settings](const CLI::results_t& results) { settings.address = hex_to_address(results[0]); return true; }) ->description("Target account address to match (optional)") ->capture_default_str(); cli.add_option("--topic", [&settings](const CLI::results_t& results) { const auto topic_bytes{from_hex(results[0])}; if (!topic_bytes) { SILK_CRIT << "Invalid input for --topic option: " << results[0]; return false; } settings.topic = to_bytes32(*topic_bytes); return true; }) ->description("Target topic to match (optional)") ->capture_default_str(); std::map check_type_mapping{ {"address", TargetIndex::kLogAddress}, {"topic", TargetIndex::kLogTopic}, {"both", TargetIndex::kBoth}, }; cli.add_option("--index", settings.index, "Target index to check consistency for (optional)") ->capture_default_str() ->check(CLI::Range(TargetIndex::kLogAddress, TargetIndex::kBoth)) ->transform(CLI::Transformer(check_type_mapping, CLI::ignore_case)) ->default_val(settings.index); log::Settings log_settings{}; add_logging_options(cli, log_settings); cli.parse(argc, argv); } catch (const CLI::ParseError& pe) { cli.exit(pe); throw; } return settings; } std::string block_num_range_str(const Settings& settings) { std::stringstream stream; log::prepare_for_logging(stream); stream << "[" << settings.block_from << ", "; if (settings.block_to) { stream << *settings.block_to; } else { stream << "latest"; } stream << "]"; return stream.str(); } void trace(const Log& log) { SILK_TRACE << "address: " << log.address << " topics: " << log.topics.size(); int i{0}; for (const auto& t : log.topics) { SILK_TRACE << "topic[" << i << "]: " << to_hex(t); ++i; } } void check_address_index(BlockNum block_num, const evmc::address& log_address, ROCursor* log_address_cursor) { // Transaction log address must be present in LogAddressIndex table const auto log_address_key{db::log_address_key(log_address, block_num)}; const auto log_address_data{log_address_cursor->lower_bound(to_slice(log_address_key), false)}; ensure(log_address_data.done, [&]() { return "LogAddressIndex does not contain key " + to_hex(log_address_key); }); const auto [address_view, address_upper_bound_block] = split_log_address_key(log_address_data.key); const auto& address_view_ref = address_view; ensure(to_hex(address_view) == to_hex(log_address.bytes), [&]() { return "address mismatch in LogAddressIndex table: " + to_hex(address_view_ref); }); ensure(address_upper_bound_block >= block_num, [&]() { return "upper bound mismatch in LogAddressIndex table: " + to_hex(address_view_ref); }); // Retrieved chunk of the address roaring bitmap must contain the transaction log block const auto& log_address_value{log_address_data.value}; const auto address_bitmap_chunk{bitmap::parse32(log_address_value)}; ensure(address_bitmap_chunk.contains(static_cast(block_num)), [&]() { return "address bitmap chunk " + address_bitmap_chunk.toString() + " does not contain block " + std::to_string(block_num); }); } void check_topic_index(BlockNum block_num, const evmc::bytes32& log_topic, ROCursor* log_topic_cursor) { // Each transaction log topic must be present in LogTopicIndex table const auto log_topic_key{db::log_topic_key(log_topic, block_num)}; const auto log_topic_data{log_topic_cursor->lower_bound(to_slice(log_topic_key), false)}; ensure(log_topic_data.done, [&]() { return "LogTopicIndex does not contain key " + to_hex(log_topic_key); }); const auto [topic_view, topic_upper_bound_block] = split_log_topic_key(log_topic_data.key); const auto& topic_view_ref = topic_view; ensure(to_hex(topic_view) == to_hex(log_topic.bytes), [&]() { return "topic mismatch in LogTopicIndex table: " + to_hex(topic_view_ref); }); ensure(topic_upper_bound_block >= block_num, [&]() { return "upper bound mismatch in LogTopicIndex table: " + to_hex(topic_view_ref); }); // Retrieved chunk of the topic roaring bitmap must contain the transaction log block const auto& log_topic_value{log_topic_data.value}; const auto topic_bitmap_chunk{bitmap::parse32(log_topic_value)}; ensure(topic_bitmap_chunk.contains(static_cast(block_num)), [&]() { return "topic bitmap chunk " + topic_bitmap_chunk.toString() + " does not contain block " + std::to_string(block_num); }); } int main(int argc, char* argv[]) { SignalHandler::init(); try { // Parse command-line options and initialize settings Settings settings{parse_cli_settings(argc, argv)}; log::init(settings.log_settings); ensure(!settings.block_to || *settings.block_to >= settings.block_from, "Invalid input: block_from is greater than block_to"); const auto node_name{get_node_name_from_build_info(silkworm_get_buildinfo())}; SILK_INFO << "Build info: " << node_name; // Set up the measurement counters and data structures BlockNum reached_block_num{0}; uint64_t processed_block_nums{0}; uint64_t processed_transaction_count{0}; uint64_t processed_logs_count{0}; uint64_t processed_addresses_count{0}; uint64_t processed_topics_count{0}; // Open the database and create a read-only txn auto data_dir{DataDirectory::from_chaindata(settings.chaindata)}; data_dir.deploy(); EnvConfig db_config{data_dir.chaindata().path().string()}; auto env{open_env(db_config)}; ROTxnManaged txn{env}; auto logs_cursor = txn.ro_cursor(table::kLogs); auto log_address_cursor = txn.ro_cursor(table::kLogAddressIndex); auto log_topic_cursor = txn.ro_cursor(table::kLogTopicIndex); SILK_INFO << "Check transaction log indices for blocks " << block_num_range_str(settings) << " ..."; // Start from the key having block_from as key prefix and iterate over TransactionLog on all blocks up to block_to auto start_key_prefix{block_key(settings.block_from)}; auto logs_data{logs_cursor->lower_bound(to_slice(start_key_prefix), false)}; ensure(logs_data.done, "Nonexistent block range: block_from not found"); while (logs_data.done) { const auto [block_num, tx_id] = split_log_key(logs_data.key); if (settings.block_to && block_num > *settings.block_to) { SILK_INFO << "Target block " << *settings.block_to << " reached"; break; } if (reached_block_num != block_num) { reached_block_num = block_num; ++processed_block_nums; } std::vector transaction_logs; // Decode CBOR value content with *stateful* consumer to build address and topic bitmaps ByteView cbor_encoded_logs{static_cast(logs_data.value.data()), logs_data.value.length()}; const bool cbor_success{cbor_decode(cbor_encoded_logs, transaction_logs)}; ensure(cbor_success, "unexpected CBOR: wrong number of logs"); // Check that every transaction log is mapped into LogAddressIndex and LogTopicIndex tables (if required) for (const auto& log : transaction_logs) { trace(log); if (settings.index != TargetIndex::kLogTopic) { if (log.address == settings.address) { SILK_INFO << "block " << block_num << " tx " << tx_id << " generated log for " << log.address; } check_address_index(block_num, log.address, log_address_cursor.get()); ++processed_addresses_count; } if (settings.index != TargetIndex::kLogAddress) { for (const auto& topic : log.topics) { if (topic == settings.topic) { SILK_INFO << "block " << block_num << " tx " << tx_id << " generated topic " << to_hex(topic.bytes); } check_topic_index(block_num, topic, log_topic_cursor.get()); } processed_topics_count += log.topics.size(); } } processed_logs_count += transaction_logs.size(); ++processed_transaction_count; if (processed_transaction_count % 100'000 == 0) { SILK_INFO << "Scanned transactions " << processed_transaction_count << " processed logs " << processed_logs_count; } if (SignalHandler::signalled()) { break; } // Move to next transaction logs_data = logs_cursor->to_next(false); } SILK_INFO << "LogBuilder: processed blocks " << processed_block_nums << " transactions " << processed_transaction_count << " logs " << processed_logs_count << " addresses " << processed_addresses_count << " topics " << processed_topics_count; SILK_INFO << "Check " << (SignalHandler::signalled() ? "aborted" : "completed"); } catch (const std::exception& ex) { SILK_ERROR << ex.what(); return -1; } return 0; } ================================================ FILE: silkworm/db/cli/check_senders.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::db; using namespace silkworm::datastore::kvdb; using namespace silkworm::cmd::common; int main(int argc, char* argv[]) { SignalHandler::init(); CLI::App app{"Check Block => Senders mapping in database"}; std::string chaindata{DataDirectory{}.chaindata().path().string()}; BlockNum block_from{0}, block_to{0}; app.add_option("--chaindata", chaindata, "Path to a database populated by Silkworm") ->capture_default_str() ->check(CLI::ExistingDirectory); app.add_option("--from", block_from, "First block number to process (inclusive)") ->capture_default_str() ->check(CLI::NonNegativeNumber); app.add_option("--to", block_to, "Last block number to process (inclusive)") ->capture_default_str() ->check(CLI::NonNegativeNumber); log::Settings log_settings{}; add_logging_options(app, log_settings); CLI11_PARSE(app, argc, argv) log::init(log_settings); const auto node_name{get_node_name_from_build_info(silkworm_get_buildinfo())}; SILK_INFO << "Build info: " << node_name; auto data_dir{DataDirectory::from_chaindata(chaindata)}; data_dir.deploy(); EnvConfig db_config{data_dir.chaindata().path().string()}; auto env{open_env(db_config)}; ROTxnManaged txn{env}; auto canonical_hashes_cursor = txn.ro_cursor(table::kCanonicalHashes); auto bodies_cursor = txn.ro_cursor(table::kBlockBodies); auto tx_cursor = txn.ro_cursor(table::kBlockTransactions); auto senders_cursor = txn.ro_cursor(table::kSenders); uint64_t expected_block_num{block_from}; uint64_t processed_senders_count{0}; try { SILK_INFO << "Checking Transaction Senders..."; // Seek at the first block body (if any) Bytes first_block(8, '\0'); endian::store_big_u64(first_block.data(), block_from); const bool block_from_found = bodies_cursor->seek(to_slice(first_block)); if (block_from_found) { SILK_ERROR << "First block " << block_from << " not found in " << table::kBlockBodies.name << " table"; return -1; } // Read one block body at a time until last block is reached or execution is interrupted auto bodies_data = bodies_cursor->current(false); while (bodies_data) { // Decode table key and check expected block number auto block_num = endian::load_big_u64(static_cast(bodies_data.key.data())); if (block_num != expected_block_num) { SILK_ERROR << "Block " << block_num << " does not match expected number " << expected_block_num; break; } // Decode block body data as RLP buffer auto body_rlp{from_slice(bodies_data.value)}; auto body{unwrap_or_throw(decode_stored_block_body(body_rlp))}; // Process block transactions one-by-one SILK_DEBUG << "Processing block: " << block_num << " txn count: " << body.txn_count; if (body.txn_count > 0) { // Retrieve canonical block hash const Bytes canonical_key{block_key(block_num)}; const auto canonical_data{canonical_hashes_cursor->find(to_slice(canonical_key), false)}; if (!canonical_data) { SILK_ERROR << "Block " << block_num << " not found in " << table::kCanonicalHashes.name << " table"; continue; } SILKWORM_ASSERT(canonical_data.value.length() == kHashLength); auto block_hash = to_bytes32({static_cast(canonical_data.value.data()), kHashLength}); SILK_DEBUG << "Block hash: " << to_hex(block_hash); // Read the ordered sequence of block senders (one for each transaction) auto senders_key{block_key(block_num, block_hash.bytes)}; auto senders_data{senders_cursor->find(to_slice(senders_key), /*throw_notfound = */ false)}; if (!senders_data) { SILK_ERROR << "Block " << block_num << " hash " << to_hex(block_hash) << " not found in " << table::kSenders.name << " table"; break; } std::vector senders{}; SILKWORM_ASSERT(senders_data.value.length() % kAddressLength == 0); SILKWORM_ASSERT(senders_data.value.length() / kAddressLength == body.txn_count); senders.resize(senders_data.value.length() / kAddressLength); std::memcpy(senders.data(), senders_data.value.data(), senders_data.value.length()); SILK_DEBUG << "Read senders count: " << senders.size(); Bytes tx_key(8, '\0'); endian::store_big_u64(tx_key.data(), body.base_txn_id); // Read block transactions one at a time std::vector transactions; uint64_t i{0}; auto tx_data{tx_cursor->find(to_slice(tx_key), false)}; for (; i < body.txn_count && tx_data.done; ++i, tx_data = tx_cursor->to_next(false)) { if (!tx_data) { SILK_ERROR << "Block " << block_num << " tx " << i << " not found in " << table::kBlockTransactions.name << " table"; continue; } ByteView transaction_rlp{from_slice(tx_data.value)}; // Decode transaction data as RLP buffer Transaction tx; success_or_throw(rlp::decode(transaction_rlp, tx)); SILKWORM_ASSERT(tx.sender()); // The most important check: i-th stored sender MUST be equal to i-th transaction recomputed sender if (senders[i] != tx.sender()) { SILK_ERROR << "Block " << block_num << " tx " << i << " recovered sender " << senders[i] << " does not match computed sender " << *tx.sender(); } ++processed_senders_count; const auto transaction_hash{keccak256(transaction_rlp)}; SILK_DEBUG << "Tx hash: " << to_hex(transaction_hash.bytes) << " has sender: " << to_hex(senders[i].bytes); } if (i != body.txn_count) { SILK_ERROR << "Block " << block_num << " claims " << body.txn_count << " transactions but only " << i << " read"; } } if (expected_block_num % 100000 == 0) { SILK_INFO << "Scanned blocks " << expected_block_num << " processed senders " << processed_senders_count; } if (expected_block_num == block_to) { SILK_INFO << "Target block " << block_to << " reached"; break; } if (SignalHandler::signalled()) { break; } // Move to next block body ++expected_block_num; bodies_data = bodies_cursor->to_next(false); } SILK_INFO << "Check " << (SignalHandler::signalled() ? "aborted" : "completed"); } catch (const std::exception& ex) { SILK_ERROR << ex.what(); return -1; } return 0; } ================================================ FILE: silkworm/db/cli/check_tx_lookup.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include using namespace silkworm; int main(int argc, char* argv[]) { SignalHandler::init(); CLI::App app{"Check Tx Hashes => BlockNum mapping in database"}; std::string chaindata{DataDirectory{}.chaindata().path().string()}; size_t block_from{0}; app.add_option("--chaindata", chaindata, "Path to a database populated by Erigon") ->capture_default_str() ->check(CLI::ExistingDirectory); app.add_option("--from", block_from, "Initial block number to process (inclusive)") ->capture_default_str() ->check(CLI::Range(1u, UINT32_MAX)); CLI11_PARSE(app, argc, argv) auto data_dir{DataDirectory::from_chaindata(chaindata)}; data_dir.deploy(); datastore::kvdb::EnvConfig db_config{data_dir.chaindata().path().string()}; datastore::etl::Collector collector(data_dir.temp().path().string().c_str(), /* flush size */ 512 * kMebi); auto env{datastore::kvdb::open_env(db_config)}; auto txn{env.start_read()}; auto bodies_table = datastore::kvdb::open_cursor(txn, db::table::kBlockBodies); auto tx_lookup_table = datastore::kvdb::open_cursor(txn, db::table::kTxLookup); auto transactions_table = datastore::kvdb::open_cursor(txn, db::table::kBlockTransactions); uint64_t expected_block_num{0}; try { SILK_INFO << "Checking Transaction Lookups..."; auto bodies_data{bodies_table.to_first(false)}; while (bodies_data) { auto block_num(endian::load_big_u64(static_cast(bodies_data.key.data()))); auto body_rlp{datastore::kvdb::from_slice(bodies_data.value)}; auto body{unwrap_or_throw(decode_stored_block_body(body_rlp))}; if (body.txn_count > 0) { Bytes transaction_key(8, '\0'); endian::store_big_u64(transaction_key.data(), body.base_txn_id); uint64_t i{0}; auto transaction_data{transactions_table.find(datastore::kvdb::to_slice(transaction_key), false)}; for (; i < body.txn_count && transaction_data.done; ++i, transaction_data = transactions_table.to_next(false)) { if (!transaction_data) { SILK_ERROR << "Block " << block_num << " transaction " << i << " not found in " << db::table::kBlockTransactions.name << " table"; continue; } ByteView transaction_rlp{datastore::kvdb::from_slice(transaction_data.value)}; auto transaction_hash{keccak256(transaction_rlp)}; ByteView transaction_view{transaction_hash.bytes}; auto lookup_data{tx_lookup_table.find(datastore::kvdb::to_slice(transaction_view), false)}; if (!lookup_data) { SILK_ERROR << "Block " << block_num << " transaction " << i << " with hash " << to_hex(transaction_view) << " not found in " << db::table::kTxLookup.name << " table"; continue; } // Erigon stores block_num as compact (no leading zeroes) auto lookup_block_value{datastore::kvdb::from_slice(lookup_data.value)}; uint64_t actual_block_num{0}; if (!endian::from_big_compact(lookup_block_value, actual_block_num)) { SILK_ERROR << "Failed to read expected block number from: " << to_hex(lookup_block_value); } else if (actual_block_num != expected_block_num) { SILK_ERROR << "Mismatch: Expected block number for tx with hash: " << to_hex(transaction_view) << " is " << expected_block_num << ", but got: " << actual_block_num; } } if (i != body.txn_count) { SILK_ERROR << "Block " << block_num << " claims " << body.txn_count << " transactions but only " << i << " read"; } } if (expected_block_num % 100000 == 0) { SILK_INFO << "Scanned blocks " << expected_block_num; } if (SignalHandler::signalled()) { break; } ++expected_block_num; bodies_data = bodies_table.to_next(false); } SILK_INFO << "Check " << (SignalHandler::signalled() ? "aborted" : "completed"); } catch (const std::exception& ex) { SILK_ERROR << ex.what(); return -5; } return 0; } ================================================ FILE: silkworm/db/cli/db_max_readers_option.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "db_max_readers_option.hpp" #include namespace silkworm::cmd::common { void add_option_db_max_readers(CLI::App& cli, uint32_t& max_readers) { cli.add_option("--mdbx.max.readers", max_readers, "The maximum number of MDBX readers") ->default_val(silkworm::datastore::kvdb::EnvConfig{}.max_readers) ->check(CLI::Range(1, 32767)); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/db/cli/db_max_readers_option.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::cmd::common { //! \brief Set up option for maximum number of database readers void add_option_db_max_readers(CLI::App& cli, uint32_t& max_readers); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/db/cli/db_toolbox.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace fs = std::filesystem; using namespace silkworm; using namespace silkworm::db; using namespace silkworm::datastore::kvdb; class Progress { public: explicit Progress(uint32_t width) : bar_width_{width}, percent_step_{100u / width} {}; ~Progress() = default; //! Returns current progress percent uint32_t percent() const { if (!max_counter_) { return 100; } if (!current_counter_) { return 0; } return static_cast(current_counter_ * 100 / max_counter_); } void step() { ++current_counter_; } void set_current(size_t count) { current_counter_ = std::max(count, current_counter_); } size_t get_current() const noexcept { return current_counter_; } size_t get_increment_count() const noexcept { return bar_width_ ? (max_counter_ / bar_width_) : 0u; } void reset() { current_counter_ = 0; printed_bar_len_ = 0; } void set_task_count(size_t iterations) { reset(); max_counter_ = iterations; } //! Prints progress ticks std::string print_interval(char c = '.') { uint32_t percentage{std::min(percent(), 100u)}; uint32_t num_chars{percentage / percent_step_}; if (!num_chars) return ""; uint32_t int_chars{num_chars - printed_bar_len_}; if (!int_chars) return ""; std::string ret(int_chars, c); printed_bar_len_ += int_chars; return ret; } [[maybe_unused]] std::string print_progress(char c = '.') const { uint32_t percentage{percent()}; uint32_t num_chars{percentage / percent_step_}; if (!num_chars) { return ""; } std::string ret(num_chars, c); return ret; } private: uint32_t bar_width_; uint32_t percent_step_; size_t max_counter_{0}; size_t current_counter_{0}; uint32_t printed_bar_len_{0}; }; struct DbTableInfo { MDBX_dbi id{0}; std::string name{}; mdbx::txn::map_stat stat; mdbx::map_handle::info info; size_t pages() const noexcept { return stat.ms_branch_pages + stat.ms_leaf_pages + stat.ms_overflow_pages; } size_t size() const noexcept { return pages() * stat.ms_psize; } }; bool operator==(const DbTableInfo& lhs, const DbTableInfo& rhs) { return lhs.name == rhs.name; } using DbComparisonResult = tl::expected; DbComparisonResult compare(const DbTableInfo& lhs, const DbTableInfo& rhs, bool check_layout) { // Skip freelist table because its content depends not only on *which* data you write but also *how* you write it // (i.e. writing the same data w/ different commit policies can lead to different freelist content) if (lhs.name == "FREE_DBI" && rhs.name == "FREE_DBI") { return {}; } if (lhs.name != rhs.name) { return tl::make_unexpected("name mismatch: " + lhs.name + " vs " + rhs.name); } if (lhs.stat.ms_entries != rhs.stat.ms_entries) { return tl::make_unexpected("num records mismatch: " + std::to_string(lhs.stat.ms_entries) + " vs " + std::to_string(rhs.stat.ms_entries)); } if (lhs.stat.ms_psize != rhs.stat.ms_psize) { return tl::make_unexpected("db page mismatch: " + std::to_string(lhs.stat.ms_psize) + " vs " + std::to_string(rhs.stat.ms_psize)); } if (lhs.info.flags != rhs.info.flags) { return tl::make_unexpected("flags mismatch: " + std::to_string(lhs.info.flags) + " vs " + std::to_string(rhs.info.flags)); } if (check_layout) { if (lhs.stat.ms_depth != rhs.stat.ms_depth) { return tl::make_unexpected("btree height mismatch: " + std::to_string(lhs.stat.ms_depth) + " vs " + std::to_string(rhs.stat.ms_depth)); } if (lhs.stat.ms_leaf_pages != rhs.stat.ms_leaf_pages) { return tl::make_unexpected("leaf pages mismatch: " + std::to_string(lhs.stat.ms_leaf_pages) + " vs " + std::to_string(rhs.stat.ms_leaf_pages)); } if (lhs.stat.ms_branch_pages != rhs.stat.ms_branch_pages) { return tl::make_unexpected("branch pages mismatch: " + std::to_string(lhs.stat.ms_branch_pages) + " vs " + std::to_string(rhs.stat.ms_branch_pages)); } if (lhs.stat.ms_overflow_pages != rhs.stat.ms_overflow_pages) { return tl::make_unexpected("overflow pages mismatch: " + std::to_string(lhs.stat.ms_overflow_pages) + " vs " + std::to_string(rhs.stat.ms_overflow_pages)); } } return {}; } struct DbInfo { size_t file_size{0}; size_t page_size{0}; size_t pages{0}; size_t size{0}; std::vector tables{}; }; struct DbFreeEntry { size_t id{0}; size_t pages{0}; size_t size{0}; }; struct DbFreeInfo { size_t pages{0}; size_t size{0}; std::vector entries{}; }; void cursor_for_each(mdbx::cursor& cursor, WalkFuncRef walker) { const bool throw_notfound{false}; auto data = cursor.eof() ? cursor.to_first(throw_notfound) : cursor.current(throw_notfound); while (data) { walker(from_slice(data.key), from_slice(data.value)); data = cursor.move(mdbx::cursor::move_operation::next, throw_notfound); } } static void print_header(const BlockHeader& header) { std::cout << "Header:\nhash=" << to_hex(header.hash()) << "\n" << "parent_hash=" << to_hex(header.parent_hash) << "\n" << "number=" << header.number << "\n" << "beneficiary=" << header.beneficiary << "\n" << "ommers_hash=" << to_hex(header.ommers_hash) << "\n" << "state_root=" << to_hex(header.state_root) << "\n" << "transactions_root=" << to_hex(header.transactions_root) << "\n" << "receipts_root=" << to_hex(header.receipts_root) << "\n" << "withdrawals_root=" << (header.withdrawals_root ? to_hex(*header.withdrawals_root) : "") << "\n" << "beneficiary=" << header.beneficiary << "\n" << "timestamp=" << header.timestamp << "\n" << "nonce=" << to_hex(header.nonce) << "\n" << "prev_randao=" << to_hex(header.prev_randao) << "\n" << "base_fee_per_gas=" << (header.base_fee_per_gas ? intx::to_string(*header.base_fee_per_gas) : "") << "\n" << "difficulty=" << intx::to_string(header.difficulty) << "\n" << "gas_limit=" << header.gas_limit << "\n" << "gas_used=" << header.gas_used << "\n" << "blob_gas_used=" << header.blob_gas_used.value_or(0) << "\n" << "excess_blob_gas=" << header.excess_blob_gas.value_or(0) << "\n" << "logs_bloom=" << to_hex(header.logs_bloom) << "\n" << "extra_data=" << to_hex(header.extra_data) << "\n" << "rlp=" << to_hex([&]() { Bytes b; rlp::encode(b, header); return b; }()) << "\n"; } static void print_body(const BlockBodyForStorage& body) { std::cout << "Body:\nbase_txn_id=" << body.base_txn_id << "\n" << "txn_count=" << body.txn_count << "\n" << "#ommers=" << body.ommers.size() << "\n" << (body.withdrawals ? "#withdrawals=" + std::to_string(body.withdrawals->size()) + "\n" : "") << "rlp=" << to_hex(body.encode()) << "\n"; } bool user_confirmation(const std::string& message = {"Confirm ?"}) { static std::regex pattern{"^([yY])?([nN])?$"}; std::smatch matches; std::string user_input; do { std::cout << "\n" << message << " [y/N] "; std::cin >> user_input; std::cin.clear(); if (std::regex_search(user_input, matches, pattern, std::regex_constants::match_default)) { break; } std::cout << "Unexpected user input: " << user_input << "\n"; } while (true); return matches[2].length() == 0; } void table_get(EnvConfig& config, const std::string& table, const std::optional& k, std::optional block_num) { ensure(k.has_value() || block_num.has_value(), "You must specify either --key or --block"); auto env = open_env(config); auto txn = env.start_read(); ensure(has_map(txn, table), [&table]() { return "Table " + table + " not found"; }); ::mdbx::map_handle table_map = txn.open_map(table); const std::string_view key_identifier = block_num ? "block_key" : "key"; const Bytes key = k.value_or(block_key(*block_num)); ::mdbx::cursor_managed cursor = txn.open_cursor(table_map); const auto result = cursor.find(to_slice(key), /*throw_notfound=*/false); if (!result.done) { std::cout << key_identifier << "=" << to_hex(key) << " not found\n"; return; } ensure(from_slice(result.key) == key, "key mismatch"); const ByteView value = from_slice(result.value); std::cout << key_identifier << "=" << to_hex(key) << " has value: " << to_hex(value); if (const bool is_multi_value = txn.get_handle_info(table_map).flags & MDBX_DUPSORT; is_multi_value) { while (true) { if (const auto move_result = cursor.to_current_next_multi(/*throw_notfound=*/false); move_result.done) { const ByteView next_value = from_slice(move_result.value); std::cout << "," << to_hex(next_value); } else { break; } } } std::cout << "\n"; } void do_clear(EnvConfig& config, bool dry, bool always_yes, const std::vector& table_names, bool drop) { config.readonly = false; if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } auto env{open_env(config)}; auto txn{env.start_write()}; for (const auto& table : table_names) { if (!has_map(txn, table)) { std::cout << "Table " << table << " not found\n"; continue; } mdbx::map_handle table_map{txn.open_map(table)}; size_t rcount{txn.get_map_stat(table_map).ms_entries}; if (!rcount && !drop) { std::cout << " Table " << table << " is already empty. Skipping\n"; continue; } std::cout << "\n" << (drop ? "Dropping" : "Emptying") << " table " << table << " (" << rcount << " records) " << std::flush; if (!always_yes) { if (!user_confirmation()) { std::cout << " Skipped.\n"; continue; } } std::cout << (dry ? "Simulating commit ..." : "Committing ...") << "\n"; if (drop) { txn.drop_map(table_map); } else { txn.clear_map(table_map); } if (dry) { txn.abort(); } else { txn.commit(); } txn = env.start_write(); } } DbFreeInfo get_free_info(::mdbx::txn& txn) { DbFreeInfo ret{}; ::mdbx::map_handle free_map{0}; auto page_size{txn.get_map_stat(free_map).ms_psize}; const auto& collect_func{[&ret, &page_size](ByteView key, ByteView value) { size_t tx_id{0}; std::memcpy(&tx_id, key.data(), sizeof(size_t)); uint32_t page_count{0}; std::memcpy(&page_count, value.data(), sizeof(uint32_t)); size_t total_size = page_count * page_size; ret.pages += page_count; ret.size += total_size; ret.entries.push_back({tx_id, page_count, total_size}); }}; auto free_crs{txn.open_cursor(free_map)}; cursor_for_each(free_crs, collect_func); return ret; } DbInfo get_tables_info(::mdbx::txn& txn) { DbInfo ret{}; DbTableInfo* table{nullptr}; ret.file_size = txn.env().get_info().mi_geo.current; // Get info from the free database ::mdbx::map_handle free_map{0}; auto stat = txn.get_map_stat(free_map); auto info = txn.get_handle_info(free_map); table = new DbTableInfo{free_map.dbi, "FREE_DBI", stat, info}; ret.page_size += table->stat.ms_psize; ret.pages += table->pages(); ret.size += table->size(); ret.tables.push_back(*table); // Get info from the unnamed database ::mdbx::map_handle main_map{1}; stat = txn.get_map_stat(main_map); info = txn.get_handle_info(main_map); table = new DbTableInfo{main_map.dbi, "MAIN_DBI", stat, info}; ret.page_size += table->stat.ms_psize; ret.pages += table->pages(); ret.size += table->size(); ret.tables.push_back(*table); const auto& collect_func{[&ret, &txn](ByteView key, ByteView) { const auto name{std::string(byte_view_to_string_view(key))}; const auto map{txn.open_map(name)}; const auto stat2{txn.get_map_stat(map)}; const auto info2{txn.get_handle_info(map)}; const auto* table2 = new DbTableInfo{map.dbi, std::string{name}, stat2, info2}; ret.page_size += table2->stat.ms_psize; ret.pages += table2->pages(); ret.size += table2->size(); ret.tables.push_back(*table2); }}; // Get all tables from the unnamed database auto main_crs{txn.open_cursor(main_map)}; cursor_for_each(main_crs, collect_func); return ret; } void do_scan(EnvConfig& config) { static std::string fmt_hdr{" %3s %-24s %=50s %13s %13s %13s"}; auto env{open_env(config)}; auto txn{env.start_read()}; auto tables_info{get_tables_info(txn)}; std::cout << "\n Database tables : " << tables_info.tables.size() << "\n\n"; if (!tables_info.tables.empty()) { std::cout << (boost::format(fmt_hdr) % "Dbi" % "Table name" % "Progress" % "Keys" % "Data" % "Total") << "\n"; std::cout << (boost::format(fmt_hdr) % std::string(3, '-') % std::string(24, '-') % std::string(50, '-') % std::string(13, '-') % std::string(13, '-') % std::string(13, '-')) << std::flush; for (DbTableInfo item : tables_info.tables) { mdbx::map_handle tbl_map; std::cout << "\n" << (boost::format(" %3u %-24s ") % item.id % item.name) << std::flush; if (item.id < 2) { tbl_map = mdbx::map_handle(item.id); } else { tbl_map = txn.open_map(item.name); } size_t key_size{0}; size_t data_size{0}; Progress progress{50}; progress.set_task_count(item.stat.ms_entries); size_t batch_size{progress.get_increment_count()}; auto tbl_crs{txn.open_cursor(tbl_map)}; auto result = tbl_crs.to_first(/*throw_notfound =*/false); while (result) { key_size += result.key.size(); data_size += result.value.size(); if (!--batch_size) { if (SignalHandler::signalled()) { break; } progress.set_current(progress.get_current() + progress.get_increment_count()); std::cout << progress.print_interval('.') << std::flush; batch_size = progress.get_increment_count(); } result = tbl_crs.to_next(/*throw_notfound =*/false); } if (!SignalHandler::signalled()) { progress.set_current(item.stat.ms_entries); std::cout << progress.print_interval('.') << std::flush; std::cout << (boost::format(" %13s %13s %13s") % human_size(key_size) % human_size(data_size) % human_size(key_size + data_size)) << std::flush; } else { break; } } } std::cout << "\n" << (SignalHandler::signalled() ? "Aborted" : "Done") << " !\n\n"; txn.commit(); env.close(config.shared); } void do_migrations(EnvConfig& config) { static std::string fmt_hdr{" %-24s"}; static std::string fmt_row{" %-24s"}; auto env{open_env(config)}; auto txn{env.start_read()}; if (!has_map(txn, table::kMigrations.name)) { throw std::runtime_error("Either not a Silkworm db or table " + std::string{table::kMigrations.name} + " not found"); } auto crs{open_cursor(txn, table::kMigrations)}; if (txn.get_map_stat(crs.map()).ms_entries) { std::cout << "\n" << (boost::format(fmt_hdr) % "Migration Name") << "\n"; std::cout << (boost::format(fmt_hdr) % std::string(24, '-')) << "\n"; auto result{crs.to_first(/*throw_notfound =*/false)}; while (result) { std::cout << (boost::format(fmt_row) % result.key.as_string()) << "\n"; result = crs.to_next(/*throw_notfound =*/false); } std::cout << "\n\n"; } else { std::cout << "\n There are no migrations to list\n\n"; } txn.commit(); env.close(config.shared); } void do_tables(EnvConfig& config) { static std::string fmt_hdr{" %3s %-26s %10s %2s %10s %10s %10s %12s %10s %10s"}; static std::string fmt_row{" %3i %-26s %10u %2u %10u %10u %10u %12s %10s %10s"}; auto env{open_env(config)}; auto txn{env.start_read()}; auto db_tables_info{get_tables_info(txn)}; auto db_free_info{get_free_info(txn)}; std::cout << "\n Database tables : " << db_tables_info.tables.size() << "\n"; std::cout << " Effective pruning : " << read_prune_mode(txn).to_string() << "\n" << "\n"; if (!db_tables_info.tables.empty()) { std::cout << (boost::format(fmt_hdr) % "Dbi" % "Table name" % "Records" % "D" % "Branch" % "Leaf" % "Overflow" % "Size" % "Key" % "Value") << "\n"; std::cout << (boost::format(fmt_hdr) % std::string(3, '-') % std::string(26, '-') % std::string(10, '-') % std::string(2, '-') % std::string(10, '-') % std::string(10, '-') % std::string(10, '-') % std::string(12, '-') % std::string(10, '-') % std::string(10, '-')) << "\n"; for (auto& item : db_tables_info.tables) { auto key_mode = magic_enum::enum_name(item.info.key_mode()); auto value_mode = magic_enum::enum_name(item.info.value_mode()); std::cout << (boost::format(fmt_row) % item.id % item.name % item.stat.ms_entries % item.stat.ms_depth % item.stat.ms_branch_pages % item.stat.ms_leaf_pages % item.stat.ms_overflow_pages % human_size(item.size()) % key_mode % value_mode) << "\n"; } } std::cout << "\n" << " Database file size (A) : " << (boost::format("%13s") % human_size(db_tables_info.file_size)) << "\n" << " Data pages count : " << (boost::format("%13u") % db_tables_info.pages) << "\n" << " Data pages size (B) : " << (boost::format("%13s") % human_size(db_tables_info.size)) << "\n" << " Free pages count : " << (boost::format("%13u") % db_free_info.pages) << "\n" << " Free pages size (C) : " << (boost::format("%13s") % human_size(db_free_info.size)) << "\n" << " Reclaimable space : " << (boost::format("%13s") % human_size(db_tables_info.file_size - db_tables_info.size + db_free_info.size)) << " == A - B + C \n\n"; txn.commit(); env.close(config.shared); } void do_freelist(EnvConfig& config, bool detail) { static std::string fmt_hdr{"%9s %9s %12s"}; static std::string fmt_row{"%9u %9u %12s"}; auto env{open_env(config)}; auto txn{env.start_read()}; auto db_free_info{get_free_info(txn)}; if (!db_free_info.entries.empty() && detail) { std::cout << "\n" << (boost::format(fmt_hdr) % "TxId" % "Pages" % "Size") << "\n" << (boost::format(fmt_hdr) % std::string(9, '-') % std::string(9, '-') % std::string(12, '-')) << "\n"; for (auto& item : db_free_info.entries) { std::cout << (boost::format(fmt_row) % item.id % item.pages % human_size(item.size)) << "\n"; } } std::cout << "\n Record count : " << boost::format("%13u") % db_free_info.entries.size() << "\n" << " Free pages count : " << boost::format("%13u") % db_free_info.pages << "\n" << " Free pages size : " << boost::format("%13s") % human_size(db_free_info.size) << "\n\n"; txn.commit(); env.close(config.shared); } void do_schema(EnvConfig& config, bool force_update) { auto env{open_env(config)}; RWTxnManaged txn{env}; auto schema_version{read_schema_version(txn)}; if (!schema_version.has_value()) { throw std::runtime_error("Not a Silkworm db or no schema version found"); } std::cout << "Database schema version: " << schema_version->to_string() << "\n"; if (force_update) { write_schema_version(txn, table::kRequiredSchemaVersion); txn.commit_and_stop(); std::cout << "New database schema version: " << table::kRequiredSchemaVersion.to_string() << "\n"; } } void do_compact(EnvConfig& config, const std::string& work_dir, bool replace, bool nobak) { if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } fs::path work_path{work_dir}; if (work_path.has_filename()) { work_path += fs::path::preferred_separator; } std::error_code ec; fs::create_directories(work_path, ec); if (ec) { throw std::runtime_error("Directory " + work_path.string() + " does not exist and could not be created"); } fs::path target_file_path{work_path / fs::path(kDbDataFileName)}; if (fs::exists(target_file_path)) { throw std::runtime_error("Directory " + work_path.string() + " already contains an " + std::string(kDbDataFileName) + " file"); } auto env{open_env(config)}; // Determine file size of origin db size_t src_filesize{env.get_info().mi_geo.current}; // Ensure target working directory has enough free space // at least the size of origin db auto target_space = fs::space(target_file_path.parent_path()); if (target_space.free <= src_filesize) { throw std::runtime_error("Insufficient disk space on working directory's partition"); } std::cout << "\n Compacting database from " << config.path << "\n into " << target_file_path << "\n Please be patient as there is no progress report ...\n"; env.copy(/*destination*/ target_file_path.string(), /*compactify*/ true, /*forcedynamic*/ true); std::cout << "\n Database compaction " << (SignalHandler::signalled() ? "aborted !" : "completed ...") << "\n"; env.close(); if (!SignalHandler::signalled()) { // Do we have a valid compacted file on disk ? // replace source with target if (!fs::exists(target_file_path)) { throw std::runtime_error("Can't locate compacted database"); } // Do we have to replace original file ? if (replace) { auto source_file_path{get_datafile_path(fs::path(config.path))}; // Create a backup copy before replacing ? if (!nobak) { std::cout << " Creating backup copy of origin database ...\n"; std::string src_file_back{kDbDataFileName}; src_file_back.append(".bak"); fs::path src_path_bak{source_file_path.parent_path() / fs::path{src_file_back}}; if (fs::exists(src_path_bak)) { fs::remove(src_path_bak); } fs::rename(source_file_path, src_path_bak); } std::cout << " Replacing origin database with compacted ...\n"; if (fs::exists(source_file_path)) { fs::remove(source_file_path); } fs::rename(target_file_path, source_file_path); } } } void do_copy(EnvConfig& src_config, const std::string& target_dir, bool create, bool noempty, std::vector& names, std::vector& xnames) { if (!src_config.exclusive) { throw std::runtime_error("Function requires exclusive access to source database"); } fs::path target_path{target_dir}; if (target_path.has_filename()) { target_path += fs::path::preferred_separator; } if (!fs::exists(target_path) || !fs::is_directory(target_path)) { if (!create) { throw std::runtime_error("Directory " + target_path.string() + " does not exist. Try --create"); } std::error_code ec; fs::create_directories(target_path, ec); if (ec) { throw std::runtime_error("Directory " + target_path.string() + " does not exist and could not be created"); } } // Target config EnvConfig tgt_config{target_path.string()}; tgt_config.exclusive = true; fs::path target_file_path{target_path / fs::path(kDbDataFileName)}; if (!fs::exists(target_file_path)) { tgt_config.create = true; } // Source db auto src_env{open_env(src_config)}; auto src_txn{src_env.start_read()}; // Target db auto tgt_env{open_env(tgt_config)}; auto tgt_txn{tgt_env.start_write()}; // Get free info and tables from both source and target environment auto source_db_info = get_tables_info(src_txn); auto target_db_info = get_tables_info(tgt_txn); // Check source db has tables to copy besides the two system tables if (source_db_info.tables.size() < 3) { throw std::runtime_error("Source db has no tables to copy."); } size_t bytes_written{0}; std::cout << boost::format(" %-24s %=50s") % "Table" % "Progress\n"; std::cout << boost::format(" %-24s %=50s") % std::string(24, '-') % std::string(50, '-') << std::flush; // Loop source tables for (auto& src_table : source_db_info.tables) { if (SignalHandler::signalled()) { break; } std::cout << "\n " << boost::format("%-24s ") % src_table.name << std::flush; // Is this a system table ? if (src_table.id < 2) { std::cout << "Skipped (SYSTEM TABLE)" << std::flush; continue; } // Is this table present in the list user has provided ? if (!names.empty()) { auto it = std::ranges::find(names, src_table.name); if (it == names.end()) { std::cout << "Skipped (no match --tables)" << std::flush; continue; } } // Is this table present in the list user has excluded ? if (!xnames.empty()) { auto it = std::ranges::find(xnames, src_table.name); if (it != xnames.end()) { std::cout << "Skipped (match --xtables)" << std::flush; continue; } } // Is table empty ? if (!src_table.stat.ms_entries && noempty) { std::cout << "Skipped (--noempty)" << std::flush; continue; } // Is source table already present in target db ? bool exists_on_target{false}; bool populated_on_target{false}; if (!target_db_info.tables.empty()) { auto it = std::ranges::find_if( target_db_info.tables, [&src_table](DbTableInfo& item) -> bool { return item.name == src_table.name; }); if (it != target_db_info.tables.end()) { exists_on_target = true; populated_on_target = (it->stat.ms_entries > 0); } } // Ready to copy auto src_table_map{src_txn.open_map(src_table.name)}; auto src_table_info{src_txn.get_handle_info(src_table_map)}; // If table does not exist on target create it with same flags as // origin table. Check the info match otherwise. mdbx::map_handle tgt_table_map; if (!exists_on_target) { tgt_table_map = tgt_txn.create_map(src_table.name, src_table_info.key_mode(), src_table_info.value_mode()); } else { tgt_table_map = tgt_txn.open_map(src_table.name); auto tgt_table_info{tgt_txn.get_handle_info(tgt_table_map)}; if (src_table_info.flags != tgt_table_info.flags) { std::cout << "Skipped (source and target have incompatible flags)" << std::flush; continue; } } // Loop source and write into target Progress progress{50}; progress.set_task_count(src_table.stat.ms_entries); size_t batch_size{progress.get_increment_count()}; bool batch_committed{false}; auto src_table_crs{src_txn.open_cursor(src_table_map)}; auto tgt_table_crs{tgt_txn.open_cursor(tgt_table_map)}; MDBX_put_flags_t put_flags{}; if (populated_on_target) { put_flags = MDBX_put_flags_t::MDBX_UPSERT; } else if (src_table_info.flags & MDBX_DUPSORT) { put_flags = MDBX_put_flags_t::MDBX_APPENDDUP; } else { put_flags = MDBX_put_flags_t::MDBX_APPEND; } auto data{src_table_crs.to_first(/*throw_notfound =*/false)}; while (data) { ::mdbx::error::success_or_throw(tgt_table_crs.put(data.key, &data.value, put_flags)); bytes_written += (data.key.length() + data.value.length()); if (bytes_written >= 2_Gibi) { tgt_txn.commit(); tgt_txn = tgt_env.start_write(); tgt_table_crs.renew(tgt_txn); batch_committed = true; bytes_written = 0; } if (!--batch_size) { if (SignalHandler::signalled()) { break; } progress.set_current(progress.get_current() + progress.get_increment_count()); std::cout << progress.print_interval(batch_committed ? 'W' : '.') << std::flush; batch_committed = false; batch_size = progress.get_increment_count(); } data = src_table_crs.to_next(/*throw_notfound =*/false); } // Close all if (SignalHandler::signalled()) { break; } tgt_txn.commit(); tgt_txn = tgt_env.start_write(); batch_committed = true; bytes_written = 0; progress.set_current(src_table.stat.ms_entries); std::cout << progress.print_interval(batch_committed ? 'W' : '.') << std::flush; } std::cout << "\n All done!\n"; } static size_t print_multi_table_diff(ROCursorDupSort* cursor1, ROCursorDupSort* cursor2, bool force_print = false) { size_t diff_count{0}; auto result1{cursor1->to_first()}; auto result2{cursor2->to_first()}; while (result1.done && result2.done) { const auto key1{result1.key}; const auto key2{result2.key}; if (key1 != key2 || force_print) { std::cout << "k1=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << " k2=" << silkworm::to_hex({static_cast(key2.data()), key2.size()}) << "\n"; ++diff_count; } bool first{true}; while (result1.done && result2.done) { const auto& value1{result1.value}; const auto& value2{result2.value}; if (value1 != value2 || force_print) { if (first) { if (key1 == key2 && !force_print) { std::cout << "k1=k2=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << "\n"; } first = false; } const auto v1_hex{silkworm::to_hex({static_cast(value1.data()), value1.size()})}; const auto v2_hex{silkworm::to_hex({static_cast(value2.data()), value2.size()})}; std::cout << "v1=" << v1_hex << " v2=" << v2_hex << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } } result1 = cursor1->to_current_next_multi(/*throw_notfound=*/false); result2 = cursor2->to_current_next_multi(/*throw_notfound=*/false); } while (result1.done) { if (first) { if (key1 == key2 && !force_print) { std::cout << "k1=k2=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << "\n"; } first = false; } const auto& value1{result1.value}; const auto v1_hex{silkworm::to_hex({static_cast(value1.data()), value1.size()})}; std::cout << "v1=" << v1_hex << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } result1 = cursor1->to_current_next_multi(/*throw_notfound=*/false); } while (result2.done) { if (first) { if (key1 == key2 && !force_print) { std::cout << "k1=k2=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << "\n"; } first = false; } const auto& value2{result2.value}; const auto v2_hex{silkworm::to_hex({static_cast(value2.data()), value2.size()})}; std::cout << " v2=" << v2_hex << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } result2 = cursor2->to_current_next_multi(/*throw_notfound=*/false); } result1 = cursor1->to_next(/*throw_notfound=*/false); result2 = cursor2->to_next(/*throw_notfound=*/false); } while (result1.done) { const auto key1{result1.key}; std::cout << "k1=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } result1 = cursor1->to_next(/*throw_notfound=*/false); } while (result2.done) { const auto key2{result2.key}; std::cout << "k2=" << silkworm::to_hex({static_cast(key2.data()), key2.size()}) << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } result2 = cursor2->to_next(/*throw_notfound=*/false); } return diff_count; } static size_t print_single_table_diff(ROCursor* cursor1, ROCursor* cursor2, bool force_print) { size_t diff_count{0}; auto result1{cursor1->to_first()}; auto result2{cursor2->to_first()}; while (result1.done && result2.done) { const auto key1{result1.key}; const auto key2{result2.key}; if (key1 != key2 || force_print) { std::cout << "k1=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << " k2=" << silkworm::to_hex({static_cast(key2.data()), key2.size()}) << "\n"; ++diff_count; } bool first{true}; const auto& value1{result1.value}; const auto& value2{result2.value}; if (value1 != value2 || force_print) { if (first && !force_print) { if (key1 == key2) { std::cout << "k1=k2=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << "\n"; } first = false; } const auto v1_hex{silkworm::to_hex({static_cast(value1.data()), value1.size()})}; const auto v2_hex{silkworm::to_hex({static_cast(value2.data()), value2.size()})}; std::cout << "v1=" << v1_hex << " v2=" << v2_hex << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } } result1 = cursor1->to_next(/*throw_notfound=*/false); result2 = cursor2->to_next(/*throw_notfound=*/false); } while (result1.done) { const auto key1{result1.key}; std::cout << "k1=" << silkworm::to_hex({static_cast(key1.data()), key1.size()}) << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } result1 = cursor1->to_next(/*throw_notfound=*/false); } while (result2.done) { const auto key2{result2.key}; std::cout << "k2=" << silkworm::to_hex({static_cast(key2.data()), key2.size()}) << "\n"; ++diff_count; if (diff_count % 100 == 0) { if (!user_confirmation("Do you need any more diffs?")) { return diff_count; } } result2 = cursor2->to_next(/*throw_notfound=*/false); } return diff_count; } static void print_table_diff(ROTxn& txn1, ROTxn& txn2, const DbTableInfo& table1, const DbTableInfo& table2, bool force_print = false) { ensure(table1.name == table2.name, [&]() { return "name mismatch: " + table1.name + " vs " + table2.name; }); ensure(table1.info.key_mode() == table2.info.key_mode(), [&]() { return "key_mode mismatch: " + std::to_string(static_cast(table1.info.key_mode())) + " vs " + std::to_string(static_cast(table2.info.key_mode())); }); ensure(table1.info.value_mode() == table2.info.value_mode(), [&]() { return "value_mode mismatch: " + std::to_string(static_cast(table1.info.value_mode())) + " vs " + std::to_string(static_cast(table2.info.value_mode())); }); MapConfig table1_config{ .name = table1.name, .key_mode = table1.info.key_mode(), .value_mode = table1.info.value_mode(), }; MapConfig table2_config{ .name = table2.name, .key_mode = table2.info.key_mode(), .value_mode = table2.info.value_mode(), }; if (table1.stat.ms_entries == 0 && table2.stat.ms_entries == 0) { std::cout << "Both tables ( " << table1.name << ", " << table2.name << ") have zero entries, skipping deep check" << "\n"; return; } if (constexpr std::array kIrrelevantTables = { "FREE_DBI"sv, "MAIN_DBI"sv, "DbInfo"sv, }; std::ranges::any_of(kIrrelevantTables, [&table1](const std::string_view table_name) { return table_name == table1.name; })) { std::cout << "Skipping irrelevant table: " << table1.name << "\n"; return; } if (table1_config.value_mode == ::mdbx::value_mode::single) { const auto cursor1{txn1.ro_cursor(table1_config)}; const auto cursor2{txn2.ro_cursor(table2_config)}; const auto diff_count{print_single_table_diff(cursor1.get(), cursor2.get(), force_print)}; if (diff_count == 0) { std::cout << "No diff found for single-value table " << table1_config.name << "\n"; } } else if (table1_config.value_mode == ::mdbx::value_mode::multi) { const auto cursor1{txn1.ro_cursor_dup_sort(table1_config)}; const auto cursor2{txn2.ro_cursor_dup_sort(table2_config)}; const auto diff_count{print_multi_table_diff(cursor1.get(), cursor2.get(), force_print)}; if (diff_count == 0) { std::cout << "No diff found for multi-value table " << table1_config.name << "\n"; } } else { SILK_WARN << "unsupported value mode: " << magic_enum::enum_name(table1_config.value_mode); } } static std::optional find_table(const DbInfo& db_info, std::string_view table) { const auto& db_tables{db_info.tables}; const auto it{std::ranges::find_if(db_tables, [=](const auto& t) { return t.name == table; })}; return it != db_tables.end() ? std::make_optional(*it) : std::nullopt; } static DbComparisonResult compare_db_schema(const DbInfo& db1_info, const DbInfo& db2_info) { const auto& db1_tables{db1_info.tables}; const auto& db2_tables{db2_info.tables}; // Check both databases have the same number of tables if (db1_tables.size() != db2_tables.size()) { return tl::make_unexpected("mismatch in number of tables: db1 has " + std::to_string(db1_tables.size()) + ", db2 has" + std::to_string(db2_tables.size())); } // Check both databases have the same table names for (auto& db1_table : db1_tables) { if (std::ranges::find(db2_tables, db1_table) == db2_tables.end()) { return tl::make_unexpected("db1 table " + db1_table.name + " not present in db2\n"); } } for (auto& db2_table : db2_tables) { if (std::ranges::find(db1_tables, db2_table) == db1_tables.end()) { return tl::make_unexpected("db2 table " + db2_table.name + " not present in db1\n"); } } return {}; } static DbComparisonResult compare_table_content(ROTxn& txn1, ROTxn& txn2, const DbTableInfo& db1_table, const DbTableInfo& db2_table, bool check_layout, bool deep, bool verbose) { // Check both databases have the same stats (e.g. number of records) for the specified table if (const auto result{compare(db1_table, db2_table, check_layout)}; !result || deep) { if (!result) { const std::string error_message{"mismatch in table " + db1_table.name + ": " + result.error()}; if (verbose) { std::cerr << error_message << "\n"; } print_table_diff(txn1, txn2, db1_table, db2_table); return tl::make_unexpected(error_message); } print_table_diff(txn1, txn2, db1_table, db2_table); } return {}; } static DbComparisonResult compare_db_content(ROTxn& txn1, ROTxn& txn2, const DbInfo& db1_info, const DbInfo& db2_info, bool check_layout, bool deep, bool verbose) { const auto& db1_tables{db1_info.tables}; const auto& db2_tables{db2_info.tables}; SILKWORM_ASSERT(db1_tables.size() == db2_tables.size()); // Check both databases have the same content for each table for (size_t i{0}; i < db1_tables.size(); ++i) { if (auto result{compare_table_content(txn1, txn2, db1_tables[i], db2_tables[i], check_layout, deep, verbose)}; !result) { return result; } } return {}; } void compare(EnvConfig& config, const fs::path& target_datadir_path, bool check_layout, bool verbose, bool deep, std::optional table) { ensure(fs::exists(target_datadir_path), [&]() { return "target datadir " + target_datadir_path.string() + " does not exist"; }); ensure(fs::is_directory(target_datadir_path), [&]() { return "target datadir " + target_datadir_path.string() + " must be a folder"; }); DataDirectory target_datadir{target_datadir_path}; EnvConfig target_config{target_datadir.chaindata().path()}; auto source_env{open_env(config)}; ROTxnManaged source_txn{source_env}; const auto source_db_info{get_tables_info(source_txn)}; auto target_env{open_env(target_config)}; ROTxnManaged target_txn{target_env}; const auto target_db_info{get_tables_info(target_txn)}; if (table) { // Check both databases have the specified table const auto db1_table{find_table(source_db_info, *table)}; if (!db1_table) { throw std::runtime_error{"cannot find table " + std::string(*table) + " in db1"}; } const auto db2_table{find_table(target_db_info, *table)}; if (!db2_table) { throw std::runtime_error{"cannot find table " + std::string(*table) + " in db2"}; } // Check both databases have the same content in the specified table if (const auto result{compare_table_content(source_txn, target_txn, *db1_table, *db2_table, check_layout, deep, verbose)}; !result) { throw std::runtime_error{result.error()}; } } else { // Check both databases have the same tables if (const auto result{compare_db_schema(source_db_info, target_db_info)}; !result) { throw std::runtime_error{result.error()}; } // Check both databases have the same content in each table if (const auto result{compare_db_content(source_txn, target_txn, source_db_info, target_db_info, check_layout, deep, verbose)}; !result) { throw std::runtime_error{result.error()}; } } } /** * \brief Initializes a silkworm db. * * Can parse a custom genesis file in json format or import data from known chain configs * * \param data_dir : hold data directory info about db paths * \param json_file : a string representing the path where to load custom json from * \param chain_id : an identifier for a known chain * \param dry : whether to commit data or run in simulation * */ void do_init_genesis(DataDirectory& data_dir, const std::string&& json_file, uint32_t chain_id, bool dry) { // Check datadir does not exist if (data_dir.exists()) { throw std::runtime_error("Provided data directory already exist"); } // Ensure data directory tree is built data_dir.deploy(); // Retrieve source data either from provided json file // or from embedded sources std::string source_data; if (!json_file.empty()) { std::ifstream ifs(json_file); source_data = std::string((std::istreambuf_iterator(ifs)), std::istreambuf_iterator()); } else if (chain_id != 0) { source_data = read_genesis_data(chain_id); } else { throw std::invalid_argument("Either json file or chain_id must be provided"); } // Parse Json data // N.B. = instead of {} initialization due to https://github.com/nlohmann/json/issues/2204 auto genesis_json = nlohmann::json::parse(source_data, nullptr, /* allow_exceptions = */ false); // Prime database EnvConfig config{data_dir.chaindata().path().string(), /*create*/ true}; auto env{open_env(config)}; RWTxnManaged txn{env}; table::check_or_create_chaindata_tables(txn); initialize_genesis(txn, genesis_json, /*allow_exceptions=*/true); // Set schema version VersionBase v{3, 0, 0}; write_schema_version(txn, v); if (!dry) { txn.commit_and_renew(); } else { txn.abort(); } env.close(); } void do_chainconfig(EnvConfig& config) { auto env{open_env(config)}; ROTxnManaged txn{env}; auto chain_config{read_chain_config(txn)}; if (!chain_config.has_value()) { throw std::runtime_error("Not an initialized Silkworm db or unknown/custom chain "); } const auto& chain{chain_config.value()}; std::cout << "\n Chain ID: " << chain.chain_id << "\n Settings (json): \n" << chain.to_json().dump(/*indent=*/2) << "\n\n"; } void print_canonical_blocks(EnvConfig& config, BlockNum from, std::optional to, uint64_t step) { auto env{open_env(config)}; ROTxnManaged txn{env}; // Determine last canonical block number auto canonical_hashes_table{txn.ro_cursor(table::kCanonicalHashes)}; auto last_data{canonical_hashes_table->to_last(/*throw_notfound=*/false)}; ensure(last_data.done, "Table CanonicalHashes is empty"); ensure(last_data.key.size() == sizeof(BlockNum), "Table CanonicalHashes has unexpected key size"); // Use last block as max block if to is missing and perform range checks BlockNum last{block_num_from_key(last_data.key)}; if (to) { ensure(from <= *to, [&]() { return "Block from=" + std::to_string(from) + " must not be greater than to=" + std::to_string(*to); }); ensure(*to <= last, [&]() { return "Block to=" + std::to_string(*to) + " must not be greater than last=" + std::to_string(last); }); } else { ensure(from <= last, [&]() { return "Block from=" + std::to_string(from) + " must not be greater than last=" + std::to_string(last); }); to = last; } // Read the range of block headers and bodies from database auto block_headers_table{txn.ro_cursor(table::kHeaders)}; auto block_bodies_table{txn.ro_cursor(table::kBlockBodies)}; for (BlockNum block_num{from}; block_num <= *to; block_num += step) { // Lookup each canonical block hash from each block number auto block_num_key{block_key(block_num)}; auto ch_data{canonical_hashes_table->find(to_slice(block_num_key), /*throw_notfound=*/false)}; ensure(ch_data.done, [&]() { return "Table CanonicalHashes does not contain key=" + to_hex(block_num_key); }); const auto block_hash{to_bytes32(from_slice(ch_data.value))}; // Read and decode each canonical block header auto block_key{db::block_key(block_num, block_hash.bytes)}; auto bh_data{block_headers_table->find(to_slice(block_key), /*throw_notfound=*/false)}; ensure(bh_data.done, [&]() { return "Table Headers does not contain key=" + to_hex(block_key); }); ByteView block_header_data{from_slice(bh_data.value)}; BlockHeader header; const auto res{rlp::decode(block_header_data, header)}; ensure(res.has_value(), [&]() { return "Cannot decode block header from rlp=" + to_hex(from_slice(bh_data.value)); }); // Read and decode each canonical block body auto bb_data{block_bodies_table->find(to_slice(block_key), /*throw_notfound=*/false)}; if (!bb_data.done) { break; } ByteView block_body_data{from_slice(bb_data.value)}; const auto stored_body{unwrap_or_throw(decode_stored_block_body(block_body_data))}; // Print block information to console std::cout << "\nBlock number=" << block_num << "\n\n"; print_header(header); std::cout << "\n"; print_body(stored_body); std::cout << "\n\n"; } } void print_blocks(EnvConfig& config, BlockNum from, std::optional to, uint64_t step) { auto env{open_env(config)}; ROTxnManaged txn{env}; // Determine last block header number auto block_headers_table{txn.ro_cursor(table::kHeaders)}; auto last_data{block_headers_table->to_last(/*throw_notfound=*/false)}; ensure(last_data.done, "Table Headers is empty"); ensure(last_data.key.size() == sizeof(BlockNum) + kHashLength, "Table Headers has unexpected key size"); // Use last block as max block if to is missing and perform range checks BlockNum last{block_num_from_key(last_data.key)}; if (to) { ensure(from <= *to, [&]() { return "Block from=" + std::to_string(from) + " must not be greater than to=" + std::to_string(*to); }); ensure(*to <= last, [&]() { return "Block to=" + std::to_string(*to) + " must not be greater than last=" + std::to_string(last); }); } else { ensure(from <= last, [&]() { return "Block from=" + std::to_string(from) + " must not be greater than last=" + std::to_string(last); }); to = last; } // Read the range of block headers and bodies from database auto block_bodies_table{txn.ro_cursor(table::kBlockBodies)}; for (BlockNum block_num{from}; block_num <= *to; block_num += step) { // Read and decode each block header auto block_key{db::block_key(block_num)}; auto bh_data{block_headers_table->lower_bound(to_slice(block_key), /*throw_notfound=*/false)}; ensure(bh_data.done, [&]() { return "Table Headers does not contain key=" + to_hex(block_key); }); ByteView block_header_data{from_slice(bh_data.value)}; BlockHeader header; const auto res{rlp::decode(block_header_data, header)}; ensure(res.has_value(), [&]() { return "Cannot decode block header from rlp=" + to_hex(from_slice(bh_data.value)); }); // Read and decode each block body auto bb_data{block_bodies_table->lower_bound(to_slice(block_key), /*throw_notfound=*/false)}; if (!bb_data.done) { break; } ByteView block_body_data{from_slice(bb_data.value)}; const auto stored_body{unwrap_or_throw(decode_stored_block_body(block_body_data))}; // Print block information to console std::cout << "\nBlock number=" << block_num << "\n\n"; print_header(header); std::cout << "\n"; print_body(stored_body); std::cout << "\n\n"; } } void do_first_byte_analysis(EnvConfig& config) { static std::string fmt_hdr{" %-24s %=50s "}; if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } auto env{open_env(config)}; ROTxnManaged txn{env}; std::cout << "\n" << (boost::format(fmt_hdr) % "Table name" % "%") << "\n" << (boost::format(fmt_hdr) % std::string(24, '-') % std::string(50, '-')) << "\n" << (boost::format(" %-24s ") % table::kCode.name) << std::flush; std::unordered_map histogram; auto code_cursor{open_cursor(txn, table::kCode)}; Progress progress{50}; size_t total_entries{txn->get_map_stat(code_cursor.map()).ms_entries}; progress.set_task_count(total_entries); size_t batch_size{progress.get_increment_count()}; code_cursor.to_first(); cursor_for_each(code_cursor, [&histogram, &batch_size, &progress](ByteView, ByteView value) { if (!value.empty()) { uint8_t first_byte{value.at(0)}; ++histogram[first_byte]; } if (!--batch_size) { progress.set_current(progress.get_current() + progress.get_increment_count()); std::cout << progress.print_interval('.') << std::flush; batch_size = progress.get_increment_count(); } }); BlockNum last_block{stages::read_stage_progress(txn, stages::kExecutionKey)}; progress.set_current(total_entries); std::cout << progress.print_interval('.') << "\n"; std::cout << "\n Last block : " << last_block << "\n Contracts : " << total_entries << "\n\n"; // Sort histogram by usage (from most used to less used) std::vector> histogram_sorted; std::ranges::copy(histogram, std::back_inserter>>(histogram_sorted)); std::ranges::sort(histogram_sorted, [](std::pair& a, std::pair& b) -> bool { return a.second == b.second ? a.first < b.first : a.second > b.second; }); if (!histogram_sorted.empty()) { std::cout << (boost::format(" %-4s %8s") % "Byte" % "Count") << "\n" << (boost::format(" %-4s %8s") % std::string(4, '-') % std::string(8, '-')) << "\n"; for (const auto& [byte_code, usage_count] : histogram_sorted) { std::cout << (boost::format(" 0x%02x %8u") % static_cast(byte_code) % usage_count) << "\n"; } } std::cout << "\n\n"; } void do_extract_headers(EnvConfig& config, const std::string& file_name, uint32_t step) { if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } auto env{open_env(config)}; ROTxnManaged txn{env}; // We can store all header hashes into a single byte array given all hashes have same length. // We only need to ensure that the total size of the byte array is a multiple of hash length. // The process is mostly the same we have in genesistool.cpp // Open the output file std::ofstream out_stream{file_name}; out_stream << "/* Generated by Silkworm toolbox's extract headers */\n" << "#include \n" << "#include \n" << "static const uint64_t kPreverifiedHashesMainnetInternal[] = {\n"; BlockNum block_max{stages::read_stage_progress(txn, stages::kHeadersKey)}; BlockNum max_block_num{0}; auto hashes_table{open_cursor(txn, table::kCanonicalHashes)}; for (BlockNum block_num = 0; block_num <= block_max; block_num += step) { auto block_key{db::block_key(block_num)}; auto data{hashes_table.find(to_slice(block_key), false)}; if (!data.done) { break; } const uint64_t* chuncks{reinterpret_cast(from_slice(data.value).data())}; out_stream << " "; for (int i = 0; i < 4; ++i) { std::string hex{to_hex(chuncks[i], true)}; out_stream << hex << ","; } out_stream << "\n"; max_block_num = block_num; } out_stream << "};\n" << "const uint64_t* preverified_hashes_mainnet_data(){return &kPreverifiedHashesMainnetInternal[0];}\n" << "size_t sizeof_preverified_hashes_mainnet_data(){return sizeof(kPreverifiedHashesMainnetInternal);}\n" << "uint64_t preverified_hashes_mainnet_block_num(){return " << max_block_num << "ull;}\n\n"; out_stream.close(); } void do_freeze(EnvConfig& config, const DataDirectory& data_dir, bool keep_blocks) { using namespace concurrency::awaitable_wait_for_one; class StageSchedulerAdapter : public datastore::StageScheduler, public ActiveComponent { public: explicit StageSchedulerAdapter(RWAccess db_access) : db_access_(std::move(db_access)) {} ~StageSchedulerAdapter() override = default; void execution_loop() override { auto work_guard = boost::asio::make_work_guard(ioc_.get_executor()); ioc_.run(); } bool stop() override { ioc_.stop(); return ActiveComponent::stop(); } Task schedule(std::function callback) override { co_await concurrency::spawn_task(ioc_, [this, c = std::move(callback)]() -> Task { auto tx = this->db_access_.start_rw_tx(); c(tx); tx.commit_and_stop(); co_return; }); } private: boost::asio::io_context ioc_; RWAccess db_access_; }; DataStore data_store{ config, data_dir.snapshots().path(), }; StageSchedulerAdapter stage_scheduler{data_store.chaindata().access_rw()}; Freezer freezer{ data_store.chaindata().access_ro(), data_store.ref().blocks_repository, stage_scheduler, data_dir.temp().path(), keep_blocks, }; test_util::TaskRunner runner; runner.run(freezer.exec() || stage_scheduler.async_run("StageSchedulerAdapter")); stage_scheduler.stop(); } int main(int argc, char* argv[]) { SignalHandler::init(); CLI::App app_main("Silkworm db tool"); app_main.get_formatter()->column_width(50); app_main.require_subcommand(1); // At least 1 subcommand is required log::Settings log_settings{}; // Holds logging settings /* * Database options (path required) */ auto db_opts = app_main.add_option_group("Db", "Database options"); db_opts->get_formatter()->column_width(35); auto shared_opt = db_opts->add_flag("--shared", "Open database in shared mode"); auto exclusive_opt = db_opts->add_flag("--exclusive", "Open database in exclusive mode")->excludes(shared_opt); auto db_opts_paths = db_opts->add_option_group("Path", "Database path")->require_option(1); db_opts_paths->get_formatter()->column_width(35); auto chaindata_opt = db_opts_paths->add_option("--chaindata", "Path to directory for mdbx.dat"); auto datadir_opt = db_opts_paths->add_option("--datadir", "Path to data directory")->excludes(chaindata_opt); /* * Common opts and flags */ auto app_yes_opt = app_main.add_flag("-Y,--yes", "Assume yes to all requests of confirmation"); auto app_dry_opt = app_main.add_flag("--dry", "Don't commit to db. Only simulate"); cmd::common::add_logging_options(app_main, log_settings); /* * Subcommands */ // List tables and gives info about storage auto cmd_tables = app_main.add_subcommand("tables", "List db and tables info"); auto cmd_tables_scan_opt = cmd_tables->add_flag("--scan", "Scan real data size (long)"); // List infor of free pages with optional detail auto cmd_freelist = app_main.add_subcommand("freelist", "Print free pages info"); auto freelist_detail_opt = cmd_freelist->add_flag("--detail", "Gives detail for each FREE_DBI record"); // Read db schema auto cmd_schema = app_main.add_subcommand("schema", "Reports schema version of Silkworm database"); auto cmd_schema_force_version_update_opt = cmd_schema->add_flag("--force_version_update", "Force schema version update as required by current Silkworm code. " "Please be aware that this may corrupt or make your database unreadable. " "Do at your own risk."); // List migration keys auto cmd_migrations = app_main.add_subcommand("migrations", "List migrations"); // Get value of table row by provided hex key or computed block key auto cmd_table_get = app_main.add_subcommand("table_get", "Get value provided the named table and the key"); auto cmd_table_get_table_opt = cmd_table_get->add_option("--table", "Name of the table to read value from") ->required(); auto cmd_table_get_key_opt = cmd_table_get->add_option("--key", "The key to lookup as hex string") ->check([&](const std::string& value) -> std::string { const auto hex = silkworm::from_hex(value); if (!hex) return "Value " + value + " is not a valid hex string"; return {}; }); auto cmd_table_get_block_opt = cmd_table_get->add_option("--block", "Block number to compute the block key") ->check(CLI::Range(0u, UINT32_MAX)) ->excludes(cmd_table_get_key_opt); // Clear table tool auto cmd_clear = app_main.add_subcommand("clear", "Empties or drops provided named table(s)"); std::vector cmd_clear_names; cmd_clear->add_option("--names", cmd_clear_names, "Name(s) of table to clear")->required(); auto cmd_clear_drop_opt = cmd_clear->add_flag("--drop", "Drop table instead of emptying it"); // Compact database file auto cmd_compact = app_main.add_subcommand("compact", "Compacts an lmdb database"); auto cmd_compact_workdir_opt = cmd_compact->add_option("--workdir", "Working directory")->required(); auto cmd_compact_replace_opt = cmd_compact->add_flag("--replace", "Replace original file with compacted"); auto cmd_compact_nobak_opt = cmd_compact->add_flag("--nobak", "Don't create a bak copy of original when replacing") ->needs(cmd_compact_replace_opt); // Copy database file or subset of tables auto cmd_copy = app_main.add_subcommand("copy", "Copies an entire Silkworm database or subset of tables") ->excludes(app_dry_opt); auto cmd_copy_targetdir_opt = cmd_copy->add_option("--targetdir", "Target directory")->required(); auto cmd_copy_target_create_opt = cmd_copy->add_flag("--create", "Create target db if not exists"); auto cmd_copy_target_noempty_opt = cmd_copy->add_flag("--noempty", "Skip copy of empty tables"); std::vector cmd_copy_names, cmd_copy_xnames; cmd_copy->add_option("--tables", cmd_copy_names, "Copy only tables matching this list of names") ->capture_default_str(); cmd_copy->add_option("--xtables", cmd_copy_xnames, "Don't copy tables matching this list of names") ->capture_default_str(); // Compare the content of two databases auto cmd_compare = app_main.add_subcommand("compare", "Compare the content of two databases") ->excludes(app_dry_opt); auto cmd_compare_datadir = cmd_compare->add_option("--other_datadir", "Path to other data directory")->required(); auto cmd_compare_verbose = cmd_compare->add_flag("--verbose", "Print verbose output"); auto cmd_compare_check_layout = cmd_compare->add_flag("--check_layout", "Check if B-tree structures match"); auto cmd_compare_deep = cmd_compare->add_flag("--deep", "Run a deep comparison between two databases or tables by comparing keys and values"); std::optional cmd_compare_table; cmd_compare->add_option("--table", cmd_compare_table, "Name of specific table to compare") ->capture_default_str(); // Initialize with genesis tool auto cmd_initgenesis = app_main.add_subcommand("init-genesis", "Initialize a new db with genesis block"); cmd_initgenesis->require_option(1); auto cmd_initgenesis_json_opt = cmd_initgenesis->add_option("--json", "Full path to genesis json file")->check(CLI::ExistingFile); auto cmd_initgenesis_chain_opt = cmd_initgenesis->add_option("--chain", "Name of the chain to initialize") ->excludes(cmd_initgenesis_json_opt) ->transform(CLI::Transformer(kKnownChainNameToId.to_std_map(), CLI::ignore_case)); // Read chain config held in db (if any) auto cmd_chainconfig = app_main.add_subcommand("chain-config", "Prints chain config held in database"); // Print the list of canonical blocks in specified range auto cmd_canonical_blocks = app_main.add_subcommand("canonical_blocks", "Print canonical blocks from database in specified range"); auto cmd_canonical_blocks_from = cmd_canonical_blocks->add_option("--from", "Block number to start with") ->required() ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_canonical_blocks_to = cmd_canonical_blocks->add_option("--to", "Block number to end with") ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_canonical_blocks_step = cmd_canonical_blocks->add_option("--step", "Step every this number of blocks") ->default_val("1") ->check(CLI::Range(1u, UINT32_MAX)); // Print the list of saved blocks in specified range auto cmd_blocks = app_main.add_subcommand("blocks", "Print blocks from database in specified range"); auto cmd_blocks_from = cmd_blocks->add_option("--from", "Block number to start with") ->required() ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_blocks_to = cmd_blocks->add_option("--to", "Block number to end with") ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_blocks_step = cmd_blocks->add_option("--step", "Step every this number of blocks") ->default_val("1") ->check(CLI::Range(1u, UINT32_MAX)); // Do first byte analytics on deployed contract codes auto cmd_first_byte_analysis = app_main.add_subcommand( "first-byte-analysis", "Prints an histogram analysis of first byte for deployed contracts"); // Extract a list of historical headers in given file auto cmd_extract_headers = app_main.add_subcommand( "extract-headers", "Hard-code historical headers, from block zero to the max available"); auto cmd_extract_headers_file_opt = cmd_extract_headers->add_option("--file", "Output file")->required(); auto cmd_extract_headers_step_opt = cmd_extract_headers->add_option("--step", "Step every this number of blocks") ->default_val("100000") ->check(CLI::Range(1u, UINT32_MAX)); // Freeze command auto cmd_freeze = app_main.add_subcommand("freeze", "Migrate data to snapshots"); auto cmd_freeze_keep_blocks_opt = cmd_freeze->add_flag("--snap.keepblocks", "If set, the blocks exported from mdbx to snapshots are kept in mdbx"); /* * Parse arguments and validate */ CLI11_PARSE(app_main, argc, argv) auto data_dir_factory = [&chaindata_opt, &datadir_opt]() -> DataDirectory { if (*chaindata_opt) { fs::path p{chaindata_opt->as()}; return DataDirectory::from_chaindata(p); } fs::path p{datadir_opt->as()}; return DataDirectory(p, false); }; try { log::init(log_settings); // Set origin data_dir DataDirectory data_dir{data_dir_factory()}; if (!*cmd_initgenesis) { if (!data_dir.chaindata().exists() || data_dir.chaindata().is_empty()) { std::cerr << "\n Directory " << data_dir.chaindata().path().string() << " does not exist or is empty\n"; return -1; } auto mdbx_path{get_datafile_path(data_dir.chaindata().path())}; if (!fs::exists(mdbx_path) || !fs::is_regular_file(mdbx_path)) { std::cerr << "\n Directory " << data_dir.chaindata().path().string() << " does not contain " << kDbDataFileName << "\n"; return -1; } } EnvConfig src_config{data_dir.chaindata().path().string()}; src_config.shared = static_cast(*shared_opt); src_config.exclusive = static_cast(*exclusive_opt); // Execute subcommand actions if (*cmd_tables) { if (*cmd_tables_scan_opt) { do_scan(src_config); } else { do_tables(src_config); } } else if (*cmd_freelist) { do_freelist(src_config, static_cast(*freelist_detail_opt)); } else if (*cmd_schema) { do_schema(src_config, static_cast(*cmd_schema_force_version_update_opt)); } else if (*cmd_migrations) { do_migrations(src_config); } else if (*cmd_table_get) { table_get(src_config, cmd_table_get_table_opt->as(), *cmd_table_get_key_opt ? from_hex(cmd_table_get_key_opt->as()) : std::nullopt, *cmd_table_get_block_opt ? cmd_table_get_block_opt->as>() : std::nullopt); } else if (*cmd_clear) { do_clear(src_config, static_cast(*app_dry_opt), static_cast(*app_yes_opt), cmd_clear_names, static_cast(*cmd_clear_drop_opt)); } else if (*cmd_compact) { do_compact(src_config, cmd_compact_workdir_opt->as(), static_cast(*cmd_compact_replace_opt), static_cast(*cmd_compact_nobak_opt)); } else if (*cmd_copy) { do_copy(src_config, cmd_copy_targetdir_opt->as(), static_cast(*cmd_copy_target_create_opt), static_cast(*cmd_copy_target_noempty_opt), cmd_copy_names, cmd_copy_xnames); } else if (*cmd_compare) { compare(src_config, cmd_compare_datadir->as(), cmd_compare_check_layout->as(), cmd_compare_verbose->as(), cmd_compare_deep->as(), cmd_compare_table); } else if (*cmd_initgenesis) { do_init_genesis(data_dir, cmd_initgenesis_json_opt->as(), *cmd_initgenesis_chain_opt ? cmd_initgenesis_chain_opt->as() : 0u, static_cast(*app_dry_opt)); if (*app_dry_opt) { std::cout << "\nGenesis initialization succeeded. Due to --dry flag no data is persisted\n\n"; fs::remove_all(data_dir.path()); } } else if (*cmd_chainconfig) { do_chainconfig(src_config); } else if (*cmd_canonical_blocks) { print_canonical_blocks(src_config, cmd_canonical_blocks_from->as(), cmd_canonical_blocks_to->as>(), cmd_canonical_blocks_step->as()); } else if (*cmd_blocks) { print_blocks(src_config, cmd_blocks_from->as(), cmd_blocks_to->as>(), cmd_blocks_step->as()); } else if (*cmd_first_byte_analysis) { do_first_byte_analysis(src_config); } else if (*cmd_extract_headers) { do_extract_headers(src_config, cmd_extract_headers_file_opt->as(), cmd_extract_headers_step_opt->as()); } else if (*cmd_freeze) { do_freeze(src_config, data_dir, static_cast(*cmd_freeze_keep_blocks_opt)); } return 0; } catch (const std::exception& ex) { std::cerr << "\nError: " << ex.what() << "\n\n"; } catch (...) { std::cerr << "\nUnexpected undefined error\n\n"; } return -1; } ================================================ FILE: silkworm/db/cli/scan_txs.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include int main(int argc, char* argv[]) { CLI::App app{"Executes Ethereum blocks and scans txs for errored txs"}; using namespace silkworm; std::string chaindata{DataDirectory{}.chaindata().path().string()}; app.add_option("--chaindata", chaindata, "Path to a database populated by Erigon") ->capture_default_str() ->check(CLI::ExistingDirectory); uint64_t from{1}; app.add_option("--from", from, "start from block number (inclusive)"); uint64_t to{UINT64_MAX}; app.add_option("--to", to, "check up to block number (exclusive)"); CLI11_PARSE(app, argc, argv) if (from > to) { std::cerr << "--from (" << from << ") must be less than or equal to --to (" << to << ").\n"; return -1; } int rv{0}; // Note: If Erigon is actively syncing its database (syncing), it is important not to create // long-running database reads transactions even though that may make your processing faster. // Uncomment the following line (and comment the line below) only if you're certain Erigon is not // running on the same machine. // std::unique_ptr txn{env->begin_ro_transaction()}; AnalysisCache analysis_cache{/*max_size=*/5'000}; std::vector receipts; try { auto data_dir{DataDirectory::from_chaindata(chaindata)}; data_dir.deploy(); datastore::kvdb::EnvConfig db_config{data_dir.chaindata().path().string()}; auto env{datastore::kvdb::open_env(db_config)}; datastore::kvdb::RWTxnManaged txn{env}; auto chain_config{db::read_chain_config(txn)}; if (!chain_config) { throw std::runtime_error("Unable to retrieve chain config"); } auto rule_set{protocol::rule_set_factory(*chain_config)}; if (!rule_set) { throw std::runtime_error("Unable to retrieve protocol rule set"); } // counters uint64_t n_txs{0}, n_errors{0}; Block block; for (uint64_t block_num{from}; block_num < to; ++block_num) { // Note: See the comment above. You may uncomment that line and comment the next line if you're certain // that Erigon is not syncing on the same machine. If you use a long-running transaction by doing this, and // you're mistaken (Erigon is syncing), the database file may 'grow quickly' as per the LMDB docs. txn->renew_reading(); // Read the block if (!db::read_block_by_number(txn, block_num, /*read_senders=*/true, block)) { break; } db::Buffer buffer{txn, std::make_unique(txn)}; buffer.set_historical_block(block_num); ExecutionProcessor processor{block, *rule_set, buffer, *chain_config, true}; processor.evm().analysis_cache = &analysis_cache; // Execute the block and retrieve the receipts if (const ValidationResult res = processor.execute_block(receipts); res != ValidationResult::kOk) { std::cerr << "Validation error " << static_cast(res) << " at block " << block_num << "\n"; } processor.flush_state(); // There is one receipt per transaction SILKWORM_ASSERT(block.transactions.size() == receipts.size()); // Erigon returns success in the receipt even for pre-Byzantium txs. for (const auto& receipt : receipts) { ++n_txs; n_errors += (!receipt.success); } // Report and reset counters if ((block_num % 50000) == 0) { std::cout << block_num << "," << n_txs << "," << n_errors << "\n"; n_txs = n_errors = 0; } else if ((block_num % 100) == 0) { // report progress std::cerr << block_num << "\r"; std::cerr.flush(); } // Note: If per-block database transaction (txn) is being used, it will go out of scope here // and will be reset. No need to explicitly clean up here. } } catch (std::exception& ex) { std::cout << ex.what() << "\n"; rv = -1; } return rv; } ================================================ FILE: silkworm/db/cli/snapshot_options.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_options.hpp" namespace silkworm::cmd::common { void add_snapshot_options(CLI::App& cli, snapshots::SnapshotSettings& snapshot_settings) { cli.add_flag("--snapshots.enabled", snapshot_settings.enabled) ->description("Flag indicating if usage of snapshots should be enabled or disable") ->capture_default_str(); cli.add_flag("--snapshots.no_downloader", snapshot_settings.no_downloader) ->description("If set, the snapshot downloader is disabled and just already present local snapshots are used") ->capture_default_str(); cli.add_flag("--snapshots.keepblocks", snapshot_settings.keep_blocks) ->description("If set, the blocks exported from mdbx to snapshots are kept in mdbx") ->capture_default_str(); cli.add_flag("--snapshots.stop", snapshot_settings.stop_freezer) ->description("Stop producing new snapshots. Useful to workaround any snapshots-related critical bugs. It will stop moving historical data from DB to new immutable snapshots. DB will grow and may slightly slow-down.") ->capture_default_str(); cli.add_option("--snapshots.repository.path", snapshot_settings.repository_path) ->description("Filesystem path where snapshots will be stored") ->capture_default_str(); // TODO(canepat) add options for the other snapshot settings and for all bittorrent settings cli.add_option("--torrent.verify_on_startup", snapshot_settings.verify_on_startup) ->description( "If set, the snapshot downloader will verify snapshots on startup." " It will not report founded problems but just re-download broken pieces") ->capture_default_str(); cli.add_option("--torrent.download.rate", snapshot_settings.bittorrent_settings.download_rate_limit) ->description("Download rate limit for BitTorrent client in megabytes per seconds") ->capture_default_str(); cli.add_option("--torrent.upload.rate", snapshot_settings.bittorrent_settings.upload_rate_limit) ->description("Upload rate limit for BitTorrent client in megabytes per seconds") ->capture_default_str(); cli.add_option("--torrent.download.slots", snapshot_settings.bittorrent_settings.active_downloads) ->description( "Number of BitTorrent files to download in parallel." " If network has enough seeders, then 1-3 slots are enough, otherwise please increase to 5-7" " (too big value will slow down everything)") ->capture_default_str(); cli.add_flag("--torrent.warn_on_error_alerts", snapshot_settings.bittorrent_settings.warn_on_error_alerts) ->description("Flag indicating if BitTorrent errors must be logged as warnings") ->capture_default_str(); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/db/cli/snapshot_options.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::cmd::common { //! \brief Setup options to populate snapshot settings after cli.parse() void add_snapshot_options(CLI::App& cli, snapshots::SnapshotSettings& snapshot_settings); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/db/cli/snapshots.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::cmd::common; using namespace silkworm::snapshots; using namespace silkworm::snapshots::bittorrent; using namespace silkworm::snapshots::segment; static constexpr int kDefaultPageSize{4 * 1024}; // 4kB static constexpr int kDefaultRepetitions{1}; //! The settings for handling Thorax snapshots customized for this tool struct SnapshotSubcommandSettings { SnapshotSettings settings; std::filesystem::path input_file_path; std::optional segment_file_name; int page_size{kDefaultPageSize}; bool skip_system_txs{false}; std::optional lookup_hash; std::optional lookup_block_num; bool verbose{false}; const std::filesystem::path& repository_path() const { return settings.repository_path; } }; //! The settings for handling BitTorrent protocol customized for this tool struct DownloadSettings { bittorrent::BitTorrentSettings bittorrent_settings; ChainId chain_id{kMainnetConfig.chain_id}; std::string url_seed; bool download_web_seed_torrents{false}; std::optional magnet_uri; }; static const std::filesystem::path kTorrentRepoPath{bittorrent::BitTorrentSettings::kDefaultTorrentRepoPath}; //! The available subcommands in snapshots utility //! \warning reducing the enum base type size as suggested by clang-tidy breaks CLI11 // NOLINTBEGIN(readability-identifier-naming) enum class SnapshotTool { // NOLINT(performance-enum-size) count_bodies, count_headers, create_index, open_index, open_btree_index, open_existence_index, decode_segment, download, lookup_header, lookup_body, lookup_txn, merge, recompress, seg_zip, seg_unzip, sync }; // NOLINTEND(readability-identifier-naming) //! The overall settings for the snapshot toolbox struct SnapshotToolboxSettings { log::Settings log_settings; SnapshotSubcommandSettings snapshot_settings; DownloadSettings download_settings; int repetitions{kDefaultRepetitions}; }; struct HashValidator : public CLI::Validator { explicit HashValidator() { func_ = [&](const std::string& value) -> std::string { const auto hash{Hash::from_hex(value)}; if (!hash) return "Value " + value + " is not a valid 32-byte hash"; return {}; }; } }; struct BlockNumValidator : public CLI::Validator { explicit BlockNumValidator() { func_ = [&](const std::string& value) -> std::string { try { std::stoul(value); } catch (const std::exception& ex) { return "Value " + value + " is not a valid block number: " + ex.what(); } return {}; }; } }; //! Parse the command-line arguments into the snapshot toolbox settings void parse_command_line(int argc, char* argv[], CLI::App& app, SnapshotToolboxSettings& settings) { auto& log_settings = settings.log_settings; auto& snapshot_settings = settings.snapshot_settings; auto& download_settings = settings.download_settings; auto& bittorrent_settings = settings.download_settings.bittorrent_settings; add_logging_options(app, log_settings); std::map commands; for (auto& [tool, name] : magic_enum::enum_entries()) { commands[tool] = app.add_subcommand(std::string{name}); } app.require_subcommand(1); app.add_option("--snapshot_dir", snapshot_settings.settings.repository_path, "Path to snapshot repository") ->capture_default_str(); app.add_option("--repetitions", settings.repetitions, "How many times to repeat the execution") ->capture_default_str() ->check(CLI::Range(1, 100)); app.add_option("--page", snapshot_settings.page_size, "Page size in kB") ->capture_default_str() ->check(CLI::Range(1, 1024)); app.add_flag("--verbose", snapshot_settings.verbose, "Flag indicating if console dump is enabled or not") ->capture_default_str(); for (auto& cmd : {commands[SnapshotTool::lookup_header], commands[SnapshotTool::lookup_body], commands[SnapshotTool::lookup_txn], commands[SnapshotTool::open_index]}) { cmd->add_option("--block", snapshot_settings.lookup_block_num, "Block number to lookup in snapshot files") ->capture_default_str() ->check(BlockNumValidator{}); } for (auto& cmd : {commands[SnapshotTool::lookup_header], commands[SnapshotTool::lookup_body], commands[SnapshotTool::lookup_txn]}) { cmd->add_option("--hash", snapshot_settings.lookup_hash, "Hash to lookup in snapshot files") ->capture_default_str() ->check(HashValidator{}); } for (auto& cmd : {commands[SnapshotTool::download]}) { add_option_chain(*cmd, download_settings.chain_id); cmd->add_option("--torrent_dir", bittorrent_settings.repository_path, "Path to torrent file repository") ->capture_default_str(); cmd->add_option("--magnet", download_settings.magnet_uri, "Magnet link to download") ->capture_default_str(); cmd->add_option("--url_seed", download_settings.url_seed, "URL seed to download from") ->capture_default_str(); cmd->add_flag("--download_web_seed_torrents", download_settings.download_web_seed_torrents, "Flag indicating if torrents got via URL seed should be downloaded") ->capture_default_str(); cmd->add_option("--download_rate_limit", bittorrent_settings.download_rate_limit, "Download rate limit in bytes per second") ->capture_default_str() ->check(CLI::Range(4 * 1024 * 1024, 128 * 1024 * 1024)); cmd->add_option("--upload_rate_limit", bittorrent_settings.upload_rate_limit, "Upload rate limit in bytes per second") ->capture_default_str() ->check(CLI::Range(1 * 1024 * 1024, 32 * 1024 * 1024)); cmd->add_option("--active_downloads", bittorrent_settings.active_downloads, "Max number of downloads active simultaneously") ->capture_default_str() ->check(CLI::Range(3, 20)); } for (auto& cmd : {commands[SnapshotTool::create_index], commands[SnapshotTool::open_index], commands[SnapshotTool::decode_segment]}) { cmd->add_option("--snapshot_file", snapshot_settings.segment_file_name, "Path to snapshot file") ->required() ->capture_default_str(); } for (auto& cmd : {commands[SnapshotTool::count_headers], commands[SnapshotTool::count_bodies], commands[SnapshotTool::lookup_body], commands[SnapshotTool::lookup_header], commands[SnapshotTool::lookup_txn]}) { cmd->add_option("--snapshot_file", snapshot_settings.segment_file_name, "Path to snapshot file") ->capture_default_str(); } for (auto& cmd : {commands[SnapshotTool::open_btree_index], commands[SnapshotTool::open_existence_index]}) { cmd->add_option("--file", snapshot_settings.input_file_path, ".kv file to open with associated .bt file") ->required() ->check(CLI::ExistingFile); } commands[SnapshotTool::recompress] ->add_option("--file", snapshot_settings.input_file_path, ".seg file to decompress and compress again") ->required() ->check(CLI::ExistingFile); commands[SnapshotTool::seg_zip] ->add_option("--file", snapshot_settings.input_file_path, "Raw words file to compress") ->required() ->check(CLI::ExistingFile); commands[SnapshotTool::seg_unzip] ->add_option("--file", snapshot_settings.input_file_path, ".seg file to decompress") ->required() ->check(CLI::ExistingFile); app.parse(argc, argv); bittorrent_settings.repository_path = snapshot_settings.repository_path() / kTorrentRepoPath; snapshot_settings.settings.bittorrent_settings.repository_path = snapshot_settings.repository_path() / kTorrentRepoPath; } //! Convert one duration into another one returning the number of ticks for the latter one //! \param elapsed the duration to convert template auto duration_as(const std::chrono::duration& elapsed) { return std::chrono::duration_cast(elapsed).count(); } //! Convert the given duration into milliseconds //! \param elapsed the duration to convert template auto as_milliseconds(const std::chrono::duration& elapsed) { return duration_as(elapsed); } //! Convert the given duration into seconds //! \param elapsed the duration to convert template auto as_seconds(const std::chrono::duration& elapsed) { return duration_as(elapsed); } void decode_segment(const SnapshotSubcommandSettings& settings, int repetitions) { ensure(settings.segment_file_name.has_value(), "decode_segment: --snapshot_file must be specified"); const auto snapshot_path = SnapshotPath::parse(std::filesystem::path{*settings.segment_file_name}); ensure(snapshot_path.has_value(), "decode_segment: invalid snapshot_file path format"); SILK_INFO << "Decode snapshot: " << snapshot_path->path(); std::chrono::time_point start{std::chrono::steady_clock::now()}; for (int i = 0; i < repetitions; ++i) { SegmentFileReader snapshot{*snapshot_path, db::blocks::kStepToBlockNumConverter}; } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Decode snapshot elapsed: " << as_milliseconds(elapsed) << " msec"; } static SnapshotRepository make_repository(const SnapshotSettings& settings) { return db::blocks::make_blocks_repository(settings.repository_path); } using BodyCounters = std::pair; BodyCounters count_bodies_in_one(const SnapshotSubcommandSettings& settings, const SegmentFileReader& body_segment) { int num_bodies = 0; uint64_t num_txns = 0; constexpr int kFirstItems = 3; constexpr int kStepItems = 50'000; if (settings.verbose) { SILK_INFO << "Printing first " << kFirstItems << " bodies, then every " << kStepItems; } for (const BlockBodyForStorage& b : BodySegmentReader{body_segment}) { // If *system transactions* should not be counted, skip first and last tx in block body const auto base_txn_id{settings.skip_system_txs ? b.base_txn_id + 1 : b.base_txn_id}; const auto txn_count{settings.skip_system_txs && b.txn_count >= 2 ? b.txn_count - 2 : b.txn_count}; if (settings.verbose && (num_bodies < kFirstItems || num_bodies % kStepItems == 0)) { SILK_INFO << "Body number: " << num_bodies << " base_txn_id: " << base_txn_id << " txn_count: " << txn_count << " #ommers: " << b.ommers.size(); } ++num_bodies; num_txns += txn_count; } return {num_bodies, num_txns}; } BodyCounters count_bodies_in_all(const SnapshotSubcommandSettings& settings) { auto repository = make_repository(settings.settings); int num_bodies = 0; uint64_t num_txns = 0; for (const auto& bundle_ptr : repository.view_bundles()) { db::blocks::BundleDataRef bundle{**bundle_ptr}; const auto [body_count, txn_count] = count_bodies_in_one(settings, bundle.body_segment()); num_bodies += body_count; num_txns += txn_count; } return {num_bodies, num_txns}; } void count_bodies(const SnapshotSubcommandSettings& settings, int repetitions) { std::chrono::time_point start{std::chrono::steady_clock::now()}; int num_bodies = 0; uint64_t num_txns = 0; for (int i = 0; i < repetitions; ++i) { if (settings.segment_file_name) { const auto snapshot_path{SnapshotPath::parse(std::filesystem::path{*settings.segment_file_name})}; ensure(snapshot_path.has_value(), "count_bodies: invalid snapshot_file path format"); SegmentFileReader body_segment{*snapshot_path, db::blocks::kStepToBlockNumConverter}; std::tie(num_bodies, num_txns) = count_bodies_in_one(settings, body_segment); } else { std::tie(num_bodies, num_txns) = count_bodies_in_all(settings); } } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "How many bodies: " << num_bodies << " txs: " << num_txns << " duration: " << as_milliseconds(elapsed) << " msec"; } int count_headers_in_one(const SnapshotSubcommandSettings& settings, const SegmentFileReader& header_segment) { int num_headers = 0; constexpr int kFirstItems = 3; constexpr int kStepItems = 50'000; if (settings.verbose) { SILK_INFO << "Printing first " << kFirstItems << " headers, then every " << kStepItems; } for (const BlockHeader& h : HeaderSegmentReader{header_segment}) { ++num_headers; if (settings.verbose && (num_headers < kFirstItems || num_headers % kStepItems == 0)) { SILK_INFO << "Header number: " << h.number << " hash: " << to_hex(h.hash()); } } return num_headers; } int count_headers_in_all(const SnapshotSubcommandSettings& settings) { auto repository = make_repository(settings.settings); int num_headers{0}; for (const auto& bundle_ptr : repository.view_bundles()) { db::blocks::BundleDataRef bundle{**bundle_ptr}; const auto header_count = count_headers_in_one(settings, bundle.header_segment()); num_headers += header_count; } return num_headers; } void count_headers(const SnapshotSubcommandSettings& settings, int repetitions) { std::chrono::time_point start{std::chrono::steady_clock::now()}; int num_headers{0}; for (int i{0}; i < repetitions; ++i) { if (settings.segment_file_name) { const auto snapshot_path{SnapshotPath::parse(std::filesystem::path{*settings.segment_file_name})}; ensure(snapshot_path.has_value(), "count_headers: invalid snapshot_file path format"); SegmentFileReader header_segment{*snapshot_path, db::blocks::kStepToBlockNumConverter}; num_headers = count_headers_in_one(settings, header_segment); } else { num_headers = count_headers_in_all(settings); } } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; const auto duration = static_cast(std::chrono::duration_cast(elapsed).count()); SILK_INFO << "How many headers: " << num_headers << " duration: " << duration << " msec"; } void create_index(const SnapshotSubcommandSettings& settings, int repetitions) { ensure(settings.segment_file_name.has_value(), "create_index: --snapshot_file must be specified"); SILK_INFO << "Create index for snapshot: " << *settings.segment_file_name; std::chrono::time_point start{std::chrono::steady_clock::now()}; auto index_builders_factory = db::blocks::make_blocks_index_builders_factory(); const auto snapshot_path = SnapshotPath::parse(std::filesystem::path{*settings.segment_file_name}); if (snapshot_path) { for (int i{0}; i < repetitions; ++i) { for (auto& builder : index_builders_factory->index_builders(*snapshot_path)) { builder->build(); } } } else { SILK_ERROR << "Invalid snapshot file: " << *settings.segment_file_name; } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Create index elapsed: " << as_milliseconds(elapsed) << " msec"; } void open_index(const SnapshotSubcommandSettings& settings) { ensure(settings.segment_file_name.has_value(), "open_index: --snapshot_file must be specified"); std::filesystem::path segment_file_path{settings.repository_path() / *settings.segment_file_name}; SILK_INFO << "Open index for snapshot: " << segment_file_path; const auto snapshot_path{snapshots::SnapshotPath::parse(segment_file_path)}; ensure(snapshot_path.has_value(), [&]() { return "open_index: invalid snapshot file " + segment_file_path.filename().string(); }); const auto index_path{snapshot_path->related_path_ext(db::blocks::kIdxExtension)}; SILK_INFO << "Index file: " << index_path.path(); std::chrono::time_point start{std::chrono::steady_clock::now()}; rec_split::RecSplitIndex idx{index_path.path()}; SILK_INFO << "Index properties: empty=" << idx.empty() << " base_data_id=" << idx.base_data_id() << " double_enum_index=" << idx.double_enum_index() << " less_false_positives=" << idx.less_false_positives(); if (idx.double_enum_index()) { if (settings.lookup_block_num) { const uint64_t data_id{*settings.lookup_block_num}; auto offset = idx.lookup_by_data_id(data_id); if (offset) { SILK_INFO << "Offset by data id lookup for " << data_id << ": " << *offset; } else { SILK_WARN << "Invalid data id " << data_id; } } else { for (size_t i{0}; i < idx.key_count(); ++i) { if (i % (idx.key_count() / 10) == 0) { SILK_INFO << "Offset by ordinal lookup for " << i << ": " << idx.lookup_by_ordinal({i}) << " [existence filter: " << int{idx.existence_filter()[i]} << "]"; } } } } else { SILK_INFO << "Index does not support 2-layer enum indexing"; } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Open index elapsed: " << as_milliseconds(elapsed) << " msec"; } void open_btree_index(const SnapshotSubcommandSettings& settings) { ensure(!settings.input_file_path.empty(), "open_btree_index: --file must be specified"); ensure(settings.input_file_path.extension() == ".kv", "open_btree_index: --file must be .kv file"); auto kv_segment_path = SnapshotPath::parse(settings.input_file_path); ensure(kv_segment_path.has_value(), "open_btree_index: invalid input file name format"); auto bt_index_path = kv_segment_path->related_path_ext(".bt"); SILK_INFO << "KV file: " << kv_segment_path->path().string() << " BT file: " << bt_index_path.path().string(); std::chrono::time_point start{std::chrono::steady_clock::now()}; segment::KVSegmentFileReader kv_segment{*kv_segment_path, db::state::kStepToTxnIdConverter, seg::CompressionKind::kAll}; btree::BTreeIndex bt_index{bt_index_path.path()}; SILK_INFO << "Starting KV scan and BTreeIndex check, total keys: " << bt_index.key_count(); segment::KVSegmentReader, RawDecoder> reader{kv_segment}; size_t matching_count{0}, key_count{0}; for (auto kv_pair : reader) { ByteView key = kv_pair.first; ByteView value = kv_pair.second; const auto v = bt_index.get(key, kv_segment); SILK_DEBUG << "KV: key=" << to_hex(key) << " value=" << to_hex(value) << " v=" << (v ? to_hex(*v) : ""); ensure(v == value, [&]() { return "open_btree_index: value mismatch for key=" + to_hex(key) + " position=" + std::to_string(key_count); }); if (v == value) { ++matching_count; } ++key_count; if (key_count % 10'000'000 == 0) { SILK_INFO << "BTreeIndex check progress: " << key_count << " different: " << (key_count - matching_count); } } ensure(key_count == bt_index.key_count(), "open_btree_index: total key count does not match"); SILK_INFO << "Open btree index matching: " << matching_count << " different: " << (key_count - matching_count); std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Open btree index elapsed: " << as_milliseconds(elapsed) << " msec"; } void open_existence_index(const SnapshotSubcommandSettings& settings) { ensure(!settings.input_file_path.empty(), "open_existence_index: --file must be specified"); ensure(settings.input_file_path.extension() == ".kv", "open_existence_index: --file must be .kv file"); const auto is_file_for_domain = [](const auto& file_path, auto domain_name) -> bool { return absl::StrContains(file_path.filename().string(), domain_name); }; const bool is_account_file = is_file_for_domain(settings.input_file_path, db::table::kAccountDomain); ensure(is_account_file, "open_existence_index: --file must be an accounts .kv file (e.g. v1-accounts.0-1024.kv)"); std::filesystem::path existence_index_file_path = settings.input_file_path; existence_index_file_path.replace_extension(".kvei"); SILK_INFO << "KV file: " << settings.input_file_path.string() << " KVEI file: " << existence_index_file_path.string(); const auto salt_path = existence_index_file_path.parent_path().parent_path() / "salt-state.txt"; snapshots::IndexSaltFile salt_file{salt_path}; const uint32_t salt = salt_file.load(); SILK_INFO << "Snapshot salt " << salt << " from " << salt_path.filename().string(); std::chrono::time_point start{std::chrono::steady_clock::now()}; seg::Decompressor kv_decompressor{settings.input_file_path}; bloom_filter::BloomFilter existence_index{existence_index_file_path, KeyHasher{salt}}; SILK_INFO << "Starting KV scan and existence index check"; size_t key_count{0}, found_count{0}, nonexistent_count{0}, nonexistent_found_count{0}; bool is_key{true}; Bytes previous_key, key, value; auto kv_iterator = kv_decompressor.begin(); while (kv_iterator != kv_decompressor.end()) { // KV files contain alternated keys and values: k1|v1|...|kN|vN SILKWORM_ASSERT(kv_iterator->holds_bytes()); // kv_decompressor has CompressionKind::kAll auto word = std::move(std::get(*kv_iterator)); if (is_key) { previous_key = key; key = std::move(word); // Check if there's any gap between adjacent keys in KV file: if so, we have nonexistent keys to check const auto previous = intx::from_string(to_hex(previous_key, /*with_prefix=*/true)); const auto current = intx::from_string(to_hex(key, /*with_prefix=*/true)); if (key_count > 0 && current > previous + 1) { // We pick just one nonexistent key for each gap ++nonexistent_count; const intx::uint256 nonexistent = previous + 1; // Prepare the nonexistent key uint8_t full_be[sizeof(intx::uint256)]; intx::be::store(full_be, nonexistent); constexpr ptrdiff_t kSizeDiff = sizeof(intx::uint256) - sizeof(evmc::address); ByteView nonexistent_key = {full_be + kSizeDiff, sizeof(intx::uint256) - kSizeDiff}; SILK_TRACE << "KV: previous_key=" << to_hex(previous_key) << " key=" << to_hex(key) << " nonexistent_key=" << to_hex(nonexistent_key); if (existence_index.contains(nonexistent_key)) { ++nonexistent_found_count; } } ++key_count; } else { value = std::move(word); SILK_DEBUG << "KV: key=" << to_hex(key) << " value=" << to_hex(value); ensure(existence_index.contains(key), [&]() { return "open_existence_index: unexpected not found key=" + to_hex(key) + " position=" + std::to_string(key_count); }); ++found_count; if (key_count % 10'000'000 == 0) { const float false_pos_rate = static_cast(nonexistent_found_count) / static_cast(nonexistent_count); SILK_INFO << "Existence index check progress: " << key_count << " non-existent: " << nonexistent_count << " false positive rate: " << false_pos_rate; } } ++kv_iterator; is_key = !is_key; } ensure(found_count == key_count, [&]() { return "open_existence_index: found count " + std::to_string(found_count) + ", key count " + std::to_string(key_count); }); const float false_pos_rate = static_cast(nonexistent_found_count) / static_cast(nonexistent_count); SILK_INFO << "Open existence index keys: " << key_count << " non-existent: " << nonexistent_count << " false positives: " << false_pos_rate; std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Open existence index elapsed: " << as_milliseconds(elapsed) << " msec"; } static TorrentInfoPtrList download_web_seed(const DownloadSettings& settings) { using namespace silkworm::concurrency::awaitable_wait_for_one; const auto known_config{snapshots::Config::lookup_known_config(settings.chain_id)}; WebSeedClient web_client{/*url_seeds=*/{settings.url_seed}, known_config.preverified_snapshots_as_pairs()}; boost::asio::io_context ioc; TorrentInfoPtrList torrent_info_list; // NOLINTNEXTLINE(cppcoreguidelines-avoid-capturing-lambda-coroutines) auto discover_torrent_and_stop = [&]() -> Task { try { torrent_info_list = co_await web_client.discover_torrents(/*fail_fast=*/true); } catch (const boost::system::system_error& se) { SILK_ERROR << "Cannot discover torrents at " + settings.url_seed + ": " + se.what(); } ioc.stop(); }; boost::asio::co_spawn(ioc, discover_torrent_and_stop() || ShutdownSignal::wait(), boost::asio::use_future); ioc.run(); size_t i{0}; for (const auto& torrent_info : torrent_info_list) { SILK_INFO << i++ << ") name: " << torrent_info->name() << " hash: " << torrent_info->info_hash(); } return torrent_info_list; } static void download_bittorrent(bittorrent::BitTorrentClient& client) { using namespace silkworm::concurrency::awaitable_wait_for_one; SILK_INFO << "Bittorrent download started in repo: " << client.settings().repository_path.string(); boost::asio::io_context ioc; boost::asio::co_spawn(ioc, client.async_run("bit-torrent") || ShutdownSignal::wait(), boost::asio::use_future); ioc.run(); } void download(const DownloadSettings& settings) { std::chrono::time_point start{std::chrono::steady_clock::now()}; if (!settings.url_seed.empty()) { // Download the torrent files via web seeding from settings.url_seed bittorrent::TorrentInfoPtrList web_seed_torrents = download_web_seed(settings); // Optionally download also the target files by using the torrents just downloaded if (settings.download_web_seed_torrents) { bittorrent::BitTorrentClient client{settings.bittorrent_settings}; for (auto it = web_seed_torrents.begin(); it != web_seed_torrents.end(); it = web_seed_torrents.erase(it)) { client.add_torrent_info(*it); } download_bittorrent(client); } } else if (settings.magnet_uri) { // Download the magnet link bittorrent::BitTorrentClient client{settings.bittorrent_settings}; SILK_INFO << "Bittorrent async download started for magnet file: " << *settings.magnet_uri; client.add_magnet_uri(*settings.magnet_uri); download_bittorrent(client); SILK_INFO << "Bittorrent async download completed for magnet file: " << *settings.magnet_uri; } else { SILK_WARN << "No download source. Pass either --url_seed or --magnet"; return; } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Download elapsed: " << as_seconds(elapsed) << " sec"; } static void print_header(const BlockHeader& header, const std::string& filename) { std::cout << "Header found in: " << filename << "\n" << "hash=" << to_hex(header.hash()) << "\n" << "parent_hash=" << to_hex(header.parent_hash) << "\n" << "number=" << header.number << "\n" << "beneficiary=" << header.beneficiary << "\n" << "ommers_hash=" << to_hex(header.ommers_hash) << "\n" << "state_root=" << to_hex(header.state_root) << "\n" << "transactions_root=" << to_hex(header.transactions_root) << "\n" << "receipts_root=" << to_hex(header.receipts_root) << "\n" << "withdrawals_root=" << (header.withdrawals_root ? to_hex(*header.withdrawals_root) : "") << "\n" << "beneficiary=" << header.beneficiary << "\n" << "timestamp=" << header.timestamp << "\n" << "nonce=" << to_hex(header.nonce) << "\n" << "prev_randao=" << to_hex(header.prev_randao) << "\n" << "base_fee_per_gas=" << (header.base_fee_per_gas ? intx::to_string(*header.base_fee_per_gas) : "") << "\n" << "difficulty=" << intx::to_string(header.difficulty) << "\n" << "gas_limit=" << header.gas_limit << "\n" << "gas_used=" << header.gas_used << "\n" << "blob_gas_used=" << header.blob_gas_used.value_or(0) << "\n" << "excess_blob_gas=" << header.excess_blob_gas.value_or(0) << "\n" << "logs_bloom=" << to_hex(header.logs_bloom) << "\n" << "extra_data=" << to_hex(header.extra_data) << "\n" << "rlp=" << to_hex([&]() { Bytes b; rlp::encode(b, header); return b; }()) << "\n"; } void lookup_header_by_hash(const SnapshotSubcommandSettings& settings) { const auto hash{Hash::from_hex(*settings.lookup_hash)}; ensure(hash.has_value(), "lookup_header_by_hash: lookup_hash is not a valid hash"); SILK_INFO << "Lookup header hash: " << hash->to_hex(); std::chrono::time_point start{std::chrono::steady_clock::now()}; std::optional matching_snapshot_path; std::optional matching_header; auto repository = make_repository(settings.settings); for (const auto& bundle_ptr : repository.view_bundles_reverse()) { const auto& bundle = *bundle_ptr; auto segment_and_index = bundle.segment_and_accessor_index(db::blocks::kHeaderSegmentAndIdxNames); auto result = HeaderFindByHashSegmentQuery{segment_and_index}.exec(*hash); if (result) { matching_header = std::move(result->value); matching_snapshot_path = segment_and_index.segment.path(); break; } } if (matching_snapshot_path) { SILK_INFO << "Lookup header hash: " << hash->to_hex() << " found in: " << matching_snapshot_path->filename(); if (matching_header && settings.verbose) { print_header(*matching_header, matching_snapshot_path->filename()); } } else { SILK_WARN << "Lookup header hash: " << hash->to_hex() << " NOT found"; } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup header elapsed: " << as_milliseconds(elapsed) << " msec"; } void lookup_header_by_number(const SnapshotSubcommandSettings& settings) { const auto block_num{*settings.lookup_block_num}; SILK_INFO << "Lookup header number: " << block_num; std::chrono::time_point start{std::chrono::steady_clock::now()}; auto repository = make_repository(settings.settings); const auto [segment_and_index, _] = repository.find_segment(db::blocks::kHeaderSegmentAndIdxNames, block_num); if (segment_and_index) { const auto header = HeaderFindByBlockNumSegmentQuery{*segment_and_index}.exec(block_num); ensure(header.has_value(), [&]() { return "lookup_header_by_number: " + std::to_string(block_num) + " NOT found in " + segment_and_index->segment.path().filename(); }); SILK_INFO << "Lookup header number: " << block_num << " found in: " << segment_and_index->segment.path().filename(); if (settings.verbose) { print_header(*header, segment_and_index->segment.path().filename()); } } else { SILK_WARN << "Lookup header number: " << block_num << " NOT found"; } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup header elapsed: " << as_milliseconds(elapsed) << " msec"; } void lookup_header(const SnapshotSubcommandSettings& settings) { ensure(settings.lookup_hash || settings.lookup_block_num, "lookup_header: either --hash or --block must be used"); if (settings.lookup_hash) { lookup_header_by_hash(settings); } else { lookup_header_by_number(settings); } } static void print_body(const BlockBodyForStorage& body, const std::string& filename) { std::cout << "Body found in: " << filename << "\n" << "base_txn_id=" << body.base_txn_id << "\n" << "txn_count=" << body.txn_count << "\n" << "rlp=" << to_hex(body.encode()) << "\n"; } void lookup_body_in_one(const SnapshotSubcommandSettings& settings, BlockNum block_num, const std::string& file_name) { const auto snapshot_path = SnapshotPath::parse(settings.repository_path() / file_name); ensure(snapshot_path.has_value(), "lookup_body: --snapshot_file is invalid snapshot file"); std::chrono::time_point start{std::chrono::steady_clock::now()}; SegmentFileReader body_segment{*snapshot_path, db::blocks::kStepToBlockNumConverter}; rec_split::AccessorIndex idx_body_number{snapshot_path->related_path_ext(db::blocks::kIdxExtension)}; const auto body = BodyFindByBlockNumSegmentQuery{{body_segment, idx_body_number}}.exec(block_num); if (body) { SILK_INFO << "Lookup body number: " << block_num << " found in: " << body_segment.path().filename(); if (settings.verbose) { print_body(*body, body_segment.path().filename()); } } else { SILK_WARN << "Lookup body number: " << block_num << " NOT found in: " << body_segment.path().filename(); } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup body elapsed: " << duration_as(elapsed) << " usec"; } void lookup_body_in_all(const SnapshotSubcommandSettings& settings, BlockNum block_num) { auto repository = make_repository(settings.settings); std::chrono::time_point start{std::chrono::steady_clock::now()}; const auto [segment_and_index, _] = repository.find_segment(db::blocks::kBodySegmentAndIdxNames, block_num); if (segment_and_index) { const auto body = BodyFindByBlockNumSegmentQuery{*segment_and_index}.exec(block_num); ensure(body.has_value(), [&]() { return "lookup_body: " + std::to_string(block_num) + " NOT found in " + segment_and_index->segment.path().filename(); }); SILK_INFO << "Lookup body number: " << block_num << " found in: " << segment_and_index->segment.path().filename(); if (settings.verbose) { print_body(*body, segment_and_index->segment.path().filename()); } } else { SILK_WARN << "Lookup body number: " << block_num << " NOT found"; } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup header elapsed: " << duration_as(elapsed) << " usec"; } void lookup_body(const SnapshotSubcommandSettings& settings) { ensure(settings.lookup_block_num.has_value(), "lookup_body: --block must be specified"); const auto block_num{*settings.lookup_block_num}; SILK_INFO << "Lookup body number: " << block_num; if (settings.segment_file_name) { lookup_body_in_one(settings, block_num, *settings.segment_file_name); } else { lookup_body_in_all(settings, block_num); } } static void print_txn(const Transaction& txn, const std::string& filename) { std::cout << "Transaction found in: " << filename << "\n" << "hash=" << to_hex(txn.hash()) << "\n" << "type=" << magic_enum::enum_name(txn.type) << "\n" << "from=" << (txn.sender() ? address_to_hex(*txn.sender()) : "") << "\n" << "to=" << (txn.to ? address_to_hex(*txn.to) : "") << "\n" << "chain_id=" << (txn.chain_id ? intx::to_string(*txn.chain_id) : "") << "\n" << "nonce=" << txn.nonce << "\n" << "value=" << intx::to_string(txn.value) << "\n" << "gas_limit=" << txn.gas_limit << "\n" << "max_fee_per_gas=" << intx::to_string(txn.max_fee_per_gas) << "\n" << "max_fee_per_blob_gas=" << intx::to_string(txn.max_fee_per_blob_gas) << "\n" << "max_priority_fee_per_gas=" << intx::to_string(txn.max_priority_fee_per_gas) << "\n" << "odd_y_parity=" << txn.odd_y_parity << "\n" << "v=" << intx::to_string(txn.v()) << "\n" << "r=" << intx::to_string(txn.r) << "\n" << "s=" << intx::to_string(txn.s) << "\n" << "data=" << to_hex(txn.data) << "\n" << "access_list=" << ([&]() { std::string rep{"["}; for (size_t i{0}; i < txn.access_list.size(); ++i) { const auto& access_entry{txn.access_list[i]}; rep.append(address_to_hex(access_entry.account)); rep.append(" : ["); for (size_t j{0}; j < access_entry.storage_keys.size(); ++j) { rep.append(to_hex(access_entry.storage_keys[j].bytes)); if (j != access_entry.storage_keys.size() - 1) rep.append(", "); } if (i != txn.access_list.size() - 1) rep.append("], "); } rep.append("]"); return rep; }()) << "\n" << "blob_versioned_hashes=" << ([&]() { std::string rep{"["}; for (size_t i{0}; i < txn.blob_versioned_hashes.size(); ++i) { rep.append(to_hex(txn.blob_versioned_hashes[i])); if (i != txn.blob_versioned_hashes.size() - 1) rep.append(", "); } rep.append("]"); return rep; }()) << "\n" << "authorizations=" << ([&]() { std::string rep{"["}; for (size_t i{0}; i < txn.authorizations.size(); ++i) { const auto& authorization{txn.authorizations[i]}; rep.append(intx::to_string(authorization.chain_id)); rep.append(address_to_hex(authorization.address)); rep.append(std::to_string(authorization.nonce)); rep.append(std::to_string(authorization.y_parity)); rep.append(intx::to_string(authorization.r)); rep.append(intx::to_string(authorization.s)); if (i != txn.authorizations.size() - 1) rep.append("], "); } rep.append("]"); return rep; }()) << "\n" << "rlp=" << to_hex([&]() { Bytes b; rlp::encode(b, txn); return b; }()) << "\n"; } void lookup_txn_by_hash_in_one(const SnapshotSubcommandSettings& settings, const Hash& hash, const std::string& file_name) { const auto snapshot_path = SnapshotPath::parse(settings.repository_path() / file_name); ensure(snapshot_path.has_value(), "lookup_tx_by_hash_in_one: --snapshot_file is invalid snapshot file"); std::chrono::time_point start{std::chrono::steady_clock::now()}; SegmentFileReader txn_segment{*snapshot_path, db::blocks::kStepToBlockNumConverter}; { rec_split::AccessorIndex idx_txn_hash{snapshot_path->related_path_ext(db::blocks::kIdxExtension)}; const auto result = TransactionFindByHashSegmentQuery{{txn_segment, idx_txn_hash}}.exec(hash); if (result) { SILK_INFO << "Lookup txn hash: " << hash.to_hex() << " found in: " << txn_segment.path().filename(); if (settings.verbose) { print_txn(result->value, txn_segment.path().filename()); } } else { SILK_WARN << "Lookup txn hash: " << hash.to_hex() << " NOT found in: " << txn_segment.path().filename(); } } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup txn elapsed: " << duration_as(elapsed) << " usec"; } void lookup_txn_by_hash_in_all(const SnapshotSubcommandSettings& settings, const Hash& hash) { auto repository = make_repository(settings.settings); std::optional matching_snapshot_path; std::chrono::time_point start{std::chrono::steady_clock::now()}; for (const auto& bundle_ptr : repository.view_bundles_reverse()) { const auto& bundle = *bundle_ptr; auto segment_and_index = bundle.segment_and_accessor_index(db::blocks::kTxnSegmentAndIdxNames); const auto result = TransactionFindByHashSegmentQuery{segment_and_index}.exec(hash); if (result) { matching_snapshot_path = segment_and_index.segment.path(); if (settings.verbose) { print_txn(result->value, matching_snapshot_path->path().filename()); } break; } } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup txn elapsed: " << duration_as(elapsed) << " usec"; if (matching_snapshot_path) { SILK_INFO << "Lookup txn hash: " << hash.to_hex() << " found in: " << matching_snapshot_path->path().filename(); } else { SILK_WARN << "Lookup txn hash: " << hash.to_hex() << " NOT found"; } } void lookup_txn_by_hash(const SnapshotSubcommandSettings& settings, const std::string& lookup_hash) { const auto hash{Hash::from_hex(lookup_hash)}; ensure(hash.has_value(), "lookup_txn_by_hash: lookup_hash is not a valid hash"); SILK_INFO << "Lookup txn hash: " << hash->to_hex(); if (settings.segment_file_name) { lookup_txn_by_hash_in_one(settings, *hash, *settings.segment_file_name); } else { lookup_txn_by_hash_in_all(settings, *hash); } } void lookup_txn_by_id_in_one(const SnapshotSubcommandSettings& settings, uint64_t txn_id, const std::string& file_name) { const auto snapshot_path = SnapshotPath::parse(settings.repository_path() / file_name); ensure(snapshot_path.has_value(), "lookup_txn_by_id_in_one: --snapshot_file is invalid snapshot file"); std::chrono::time_point start{std::chrono::steady_clock::now()}; SegmentFileReader txn_segment{*snapshot_path, db::blocks::kStepToBlockNumConverter}; { rec_split::AccessorIndex idx_txn_hash{snapshot_path->related_path_ext(db::blocks::kIdxExtension)}; const auto transaction = TransactionFindByIdSegmentQuery{{txn_segment, idx_txn_hash}}.exec(txn_id); if (transaction) { SILK_INFO << "Lookup txn ID: " << txn_id << " found in: " << txn_segment.path().filename(); if (settings.verbose) { print_txn(*transaction, txn_segment.path().filename()); } } else { SILK_WARN << "Lookup txn ID: " << txn_id << " NOT found in: " << txn_segment.path().filename(); } } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup txn elapsed: " << duration_as(elapsed) << " usec"; } void lookup_txn_by_id_in_all(const SnapshotSubcommandSettings& settings, uint64_t txn_id) { auto repository = make_repository(settings.settings); std::optional matching_snapshot_path; std::chrono::time_point start{std::chrono::steady_clock::now()}; for (const auto& bundle_ptr : repository.view_bundles_reverse()) { const auto& bundle = *bundle_ptr; auto segment_and_index = bundle.segment_and_accessor_index(db::blocks::kTxnSegmentAndIdxNames); const auto transaction = TransactionFindByIdSegmentQuery{segment_and_index}.exec(txn_id); if (transaction) { matching_snapshot_path = segment_and_index.segment.path(); if (settings.verbose) { print_txn(*transaction, matching_snapshot_path->path().filename()); } break; } } std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Lookup txn elapsed: " << as_milliseconds(elapsed) << " msec"; if (matching_snapshot_path) { SILK_INFO << "Lookup txn ID: " << txn_id << " found in: " << matching_snapshot_path->path().filename(); } else { SILK_WARN << "Lookup txn ID: " << txn_id << " NOT found"; } } void lookup_txn_by_id(const SnapshotSubcommandSettings& settings, uint64_t txn_id) { SILK_INFO << "Lookup txn ID: " << txn_id; if (settings.segment_file_name) { lookup_txn_by_id_in_one(settings, txn_id, *settings.segment_file_name); } else { lookup_txn_by_id_in_all(settings, txn_id); } } void lookup_transaction(const SnapshotSubcommandSettings& settings) { ensure(settings.lookup_hash || settings.lookup_block_num, "lookup_transaction: either --hash or --block must be used"); if (settings.lookup_hash) { lookup_txn_by_hash(settings, *settings.lookup_hash); } else { lookup_txn_by_id(settings, *settings.lookup_block_num); } } void merge(const SnapshotSettings& settings) { auto repository = make_repository(settings); TemporaryDirectory tmp_dir; datastore::SnapshotMerger merger{repository, tmp_dir.path()}; test_util::TaskRunner runner; runner.run(merger.exec()); } void sync(const SnapshotSettings& settings) { class NoopStageSchedulerAdapter : public datastore::StageScheduler { public: explicit NoopStageSchedulerAdapter() = default; ~NoopStageSchedulerAdapter() override = default; Task schedule(std::function /*callback*/) override { co_return; } }; std::chrono::time_point start{std::chrono::steady_clock::now()}; TemporaryDirectory tmp_dir; datastore::kvdb::EnvConfig chaindata_env_config{tmp_dir.path()}; db::DataStore data_store{ chaindata_env_config, settings.repository_path, }; test_util::TaskRunner runner; NoopStageSchedulerAdapter stage_scheduler; db::SnapshotSync snapshot_sync{ settings, kMainnetConfig.chain_id, data_store.ref(), tmp_dir.path(), stage_scheduler, }; runner.run(snapshot_sync.download_snapshots()); std::chrono::duration elapsed{std::chrono::steady_clock::now() - start}; SILK_INFO << "Sync elapsed: " << as_seconds(elapsed) << " sec"; } int main(int argc, char* argv[]) { CLI::App app{"Snapshots toolbox"}; try { SnapshotToolboxSettings settings; parse_command_line(argc, argv, app, settings); // Initialize logging with custom settings log::init(settings.log_settings); const auto pid = boost::this_process::get_id(); SILK_INFO << "Snapshots toolbox starting [pid=" << std::to_string(pid) << "]"; const auto node_name{get_node_name_from_build_info(silkworm_get_buildinfo())}; SILK_INFO << "Snapshots toolbox build info: " << node_name; auto command_name = app.get_subcommands().front()->get_name(); auto tool = magic_enum::enum_cast(command_name).value(); switch (tool) { case SnapshotTool::count_bodies: count_bodies(settings.snapshot_settings, settings.repetitions); break; case SnapshotTool::count_headers: count_headers(settings.snapshot_settings, settings.repetitions); break; case SnapshotTool::create_index: create_index(settings.snapshot_settings, settings.repetitions); break; case SnapshotTool::open_index: open_index(settings.snapshot_settings); break; case SnapshotTool::open_btree_index: open_btree_index(settings.snapshot_settings); break; case SnapshotTool::open_existence_index: open_existence_index(settings.snapshot_settings); break; case SnapshotTool::decode_segment: decode_segment(settings.snapshot_settings, settings.repetitions); break; case SnapshotTool::download: download(settings.download_settings); break; case SnapshotTool::lookup_header: lookup_header(settings.snapshot_settings); break; case SnapshotTool::lookup_body: lookup_body(settings.snapshot_settings); break; case SnapshotTool::lookup_txn: lookup_transaction(settings.snapshot_settings); break; case SnapshotTool::merge: merge(settings.snapshot_settings.settings); break; case SnapshotTool::recompress: snapshot_file_recompress(settings.snapshot_settings.input_file_path); break; case SnapshotTool::seg_zip: seg::seg_zip(settings.snapshot_settings.input_file_path); break; case SnapshotTool::seg_unzip: seg::seg_unzip(settings.snapshot_settings.input_file_path); break; case SnapshotTool::sync: sync(settings.snapshot_settings.settings); break; } SILK_INFO << "Snapshots toolbox exiting [pid=" << std::to_string(pid) << "]"; return 0; } catch (const CLI::ParseError& pe) { return app.exit(pe); } catch (const std::exception& e) { SILK_CRIT << "Snapshots toolbox exiting due to exception: " << e.what(); return -2; } catch (...) { SILK_CRIT << "Snapshots toolbox exiting due to unexpected exception"; return -3; } } ================================================ FILE: silkworm/db/data_store.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "data_store.hpp" namespace silkworm::db { datastore::Schema DataStore::make_schema() { datastore::kvdb::Schema kvdb; kvdb.default_database() = make_chaindata_database_schema(); snapshots::Schema snapshots; snapshots.repository(blocks::kBlocksRepositoryName) = blocks::make_blocks_repository_schema(); snapshots.repository(state::kStateRepositoryNameLatest) = state::make_state_repository_schema_latest(); snapshots.repository(state::kStateRepositoryNameHistorical) = state::make_state_repository_schema_historical(); snapshots.query_caches_schema() = state::make_query_caches_schema(); return { std::move(kvdb), std::move(snapshots), }; } datastore::kvdb::Schema::DatabaseDef DataStore::make_chaindata_database_schema() { return state::make_state_database_schema(); } datastore::kvdb::Database DataStore::make_chaindata_database(mdbx::env_managed chaindata_env) { return { std::move(chaindata_env), make_chaindata_database_schema(), }; } datastore::kvdb::DatabaseUnmanaged DataStore::make_chaindata_database(datastore::kvdb::EnvUnmanaged chaindata_env) { return { std::move(chaindata_env), make_chaindata_database_schema(), }; } datastore::EntityMap> DataStore::make_databases_map( datastore::kvdb::Database chaindata_database) { datastore::EntityMap> databases; databases.emplace(datastore::kvdb::Schema::kDefaultEntityName, std::make_unique(std::move(chaindata_database))); return databases; } datastore::EntityMap> DataStore::make_repositories_map( snapshots::SnapshotRepository blocks_repository, snapshots::SnapshotRepository state_repository_latest, snapshots::SnapshotRepository state_repository_historical) { datastore::EntityMap> repositories; repositories.emplace(blocks::kBlocksRepositoryName, std::make_unique(std::move(blocks_repository))); repositories.emplace(state::kStateRepositoryNameLatest, std::make_unique(std::move(state_repository_latest))); repositories.emplace(state::kStateRepositoryNameHistorical, std::make_unique(std::move(state_repository_historical))); return repositories; } } // namespace silkworm::db ================================================ FILE: silkworm/db/data_store.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "blocks/schema_config.hpp" #include "datastore/data_store.hpp" #include "state/schema_config.hpp" namespace silkworm::db { struct DataStoreRef { datastore::kvdb::DatabaseRef chaindata; state::StateDatabaseRef state_db() const { return {chaindata}; } snapshots::SnapshotRepository& blocks_repository; snapshots::SnapshotRepository& state_repository_latest; snapshots::SnapshotRepository& state_repository_historical; const snapshots::QueryCaches& query_caches; }; class DataStore { DataStore( datastore::kvdb::Database chaindata_database, snapshots::SnapshotRepository blocks_repository, snapshots::SnapshotRepository state_repository_latest, snapshots::SnapshotRepository state_repository_historical) : store_{ make_schema(), make_databases_map(std::move(chaindata_database)), make_repositories_map( std::move(blocks_repository), std::move(state_repository_latest), std::move(state_repository_historical)), blocks_repository.path(), } {} public: explicit DataStore(datastore::DataStore store) : store_{std::move(store)} {} DataStore( mdbx::env_managed chaindata_env, const std::filesystem::path& repository_path) : DataStore{ make_chaindata_database(std::move(chaindata_env)), blocks::make_blocks_repository(repository_path), state::make_state_repository_latest(repository_path), state::make_state_repository_historical(repository_path), } {} DataStore( const datastore::kvdb::EnvConfig& chaindata_env_config, const std::filesystem::path& repository_path) : DataStore{ datastore::kvdb::open_env(chaindata_env_config), repository_path, } {} DataStoreRef ref() const { return { chaindata().ref(), blocks_repository(), state_repository_latest(), state_repository_historical(), store_.query_caches(), }; } datastore::kvdb::Database& chaindata() const { return store_.default_database(); } snapshots::SnapshotRepository& blocks_repository() const { return store_.repository(blocks::kBlocksRepositoryName); } snapshots::SnapshotRepository& state_repository_latest() const { return store_.repository(state::kStateRepositoryNameLatest); } snapshots::SnapshotRepository& state_repository_historical() const { return store_.repository(state::kStateRepositoryNameHistorical); } const snapshots::QueryCaches& query_caches() const { return store_.query_caches(); } static datastore::kvdb::Schema::DatabaseDef make_chaindata_database_schema(); static datastore::kvdb::Database make_chaindata_database(mdbx::env_managed chaindata_env); static datastore::kvdb::DatabaseUnmanaged make_chaindata_database(datastore::kvdb::EnvUnmanaged chaindata_env); private: static datastore::Schema make_schema(); static datastore::EntityMap> make_databases_map( datastore::kvdb::Database chaindata_database); static datastore::EntityMap> make_repositories_map( snapshots::SnapshotRepository blocks_repository, snapshots::SnapshotRepository state_repository_latest, snapshots::SnapshotRepository state_repository_historical); datastore::DataStore store_; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/datastore/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") add_subdirectory(common) add_subdirectory(etl) add_subdirectory(kvdb) add_subdirectory(snapshots) find_package(Boost REQUIRED COMPONENTS headers) # cmake-format: off set(LIBS_PUBLIC Boost::headers silkworm_core silkworm_infra silkworm_datastore_common silkworm_datastore_kvdb silkworm_snapshots ) # cmake-format: on # cmake-format: off set(LIBS_PRIVATE ) # cmake-format: on silkworm_library( silkworm_datastore PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) ================================================ FILE: silkworm/db/datastore/common/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED COMPONENTS flat_hash_map) silkworm_library( silkworm_datastore_common PUBLIC silkworm_core absl::flat_hash_map PRIVATE "" ) ================================================ FILE: silkworm/db/datastore/common/dummy.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // Empty compilation unit just to make datastore_common build under macOS void datastore_common_dummy() {} ================================================ FILE: silkworm/db/datastore/common/entity_name.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "entity_name.hpp" #include #include namespace silkworm::datastore { std::vector EntityName::pool_; std::string_view EntityName::intern(std::string_view name) { auto it = std::ranges::find(pool_, name); if (it != pool_.end()) { return *it; } static constexpr size_t kMaxEntityNames = 64; pool_.reserve(kMaxEntityNames); SILKWORM_ASSERT(pool_.size() < pool_.capacity()); pool_.push_back(std::string{name}); return pool_.back(); } } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/common/entity_name.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::datastore { struct EntityName { const std::string_view name; explicit EntityName(std::string_view name1) : name{intern(name1)} {} friend bool operator==(const EntityName& lhs, const EntityName& rhs) { return lhs.name.data() == rhs.name.data(); } friend bool operator!=(const EntityName& lhs, const EntityName& rhs) { return lhs.name.data() != rhs.name.data(); } friend bool operator<(const EntityName& lhs, const EntityName& rhs) { return lhs.name < rhs.name; } std::string to_string() const { return std::string{name}; } private: static std::string_view intern(std::string_view name); static std::vector pool_; }; template using EntityMap = absl::flat_hash_map>; } // namespace silkworm::datastore namespace std { //! for using EntityName as a key of std::unordered_map template <> struct hash { size_t operator()(const silkworm::datastore::EntityName& value) const noexcept { return reinterpret_cast(value.name.data()); } }; } // namespace std ================================================ FILE: silkworm/db/datastore/common/pair_get.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { template struct PairGetFirst { constexpr const T1& operator()(const std::pair& p) const noexcept { return p.first; } }; template struct PairGetSecond { constexpr const T2& operator()(const std::pair& p) const noexcept { return p.second; } }; }; // namespace silkworm ================================================ FILE: silkworm/db/datastore/common/ranges/caching_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::views { /** * Like views::cache1 in Range-v3 * https://ericniebler.github.io/range-v3/structranges_1_1views_1_1cache1__fn.html * https://stackoverflow.com/questions/67321666/generator-called-twice-in-c20-views-pipeline */ template requires std::movable class CachingView : public std::ranges::view_interface> { public: class Iterator { public: using RangeIterator = std::ranges::iterator_t; using RangeSentinel = std::ranges::sentinel_t; using value_type = typename RangeIterator::value_type; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = typename RangeIterator::difference_type; using reference = value_type&; using pointer = void; Iterator( RangeIterator it, RangeSentinel sentinel) : it_{std::move(it)}, sentinel_{std::move(sentinel)} {} Iterator() requires(std::default_initializable && std::default_initializable) = default; reference operator*() const { if (!cached_value_) { cached_value_.emplace(std::move(*it_)); } return *cached_value_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; cached_value_ = std::nullopt; return *this; } friend bool operator==(const Iterator& it, const std::default_sentinel_t&) { return it.it_ == it.sentinel_; } friend bool operator!=(const Iterator& it, const std::default_sentinel_t&) { return it.it_ != it.sentinel_; } friend bool operator==(const std::default_sentinel_t&, const Iterator& it) { return it.sentinel_ == it.it_; } friend bool operator!=(const std::default_sentinel_t&, const Iterator& it) { return it.sentinel_ != it.it_; } private: RangeIterator it_; RangeSentinel sentinel_; mutable std::optional cached_value_; }; static_assert(std::input_iterator); explicit CachingView(TRange&& range) : range_{std::move(range)} {} CachingView() requires std::default_initializable = default; CachingView(CachingView&&) = default; CachingView& operator=(CachingView&&) noexcept = default; Iterator begin() { return Iterator{std::ranges::begin(range_), std::ranges::end(range_)}; } std::default_sentinel_t end() const { return std::default_sentinel; } private: TRange range_; }; struct CachingViewFactory { template constexpr CachingView operator()(TRange&& range) const { return CachingView{std::forward(range)}; } template friend constexpr CachingView operator|(TRange&& range, const CachingViewFactory& caching) { return caching(std::forward(range)); } }; inline constexpr CachingViewFactory caching; // NOLINT(*-identifier-naming) } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/concat_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include // std::views::concat is present on C++26 #if __cplusplus >= 202601L #define SILKWORM_HAS_BUILTIN_CONCAT_VIEW #endif #ifdef SILKWORM_HAS_BUILTIN_CONCAT_VIEW namespace silkworm::views::concat_view::builtin { template using ConcatView = std::ranges::concat_view; } // namespace silkworm::views::concat_view::builtin #endif namespace silkworm::views::concat_view::fallback { template class ConcatView : public std::ranges::view_interface> { public: class Iterator { public: using Range1Iterator = std::ranges::iterator_t; using Range1Sentinel = std::ranges::sentinel_t; using Range1ReferenceType = std::iter_reference_t; using Range2Iterator = std::ranges::iterator_t; using Range2Sentinel = std::ranges::sentinel_t; using Range2ReferenceType = std::iter_reference_t; using DereferenceType = std::conditional_t, Range1ReferenceType, Range2ReferenceType>; using value_type = std::iter_value_t; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::iter_difference_t; using reference = DereferenceType; using pointer = std::remove_reference_t*; Iterator() = default; Iterator(Range1* range1, Range2* range2) : range1_{range1}, range2_{range2}, it1_{std::ranges::begin(*range1_)}, sentinel1_{std::ranges::end(*range1_)} { if (*it1_ == *sentinel1_) { it1_ = std::nullopt; sentinel1_ = std::nullopt; it2_ = std::ranges::begin(*range2_); sentinel2_ = std::ranges::end(*range2_); if (*it2_ == *sentinel2_) { it2_ = std::nullopt; sentinel2_ = std::nullopt; } } } reference operator*() const { if (it1_) return **it1_; if (it2_) return **it2_; SILKWORM_ASSERT(false); std::abort(); } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { if (it1_) { ++(*it1_); if (*it1_ == *sentinel1_) { it1_ = std::nullopt; sentinel1_ = std::nullopt; it2_ = std::ranges::begin(*range2_); sentinel2_ = std::ranges::end(*range2_); if (*it2_ == *sentinel2_) { it2_ = std::nullopt; sentinel2_ = std::nullopt; } } } else if (it2_) { ++(*it2_); #if defined(__GNUC__) && __GNUC__ < 12 && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" #endif if (*it2_ == *sentinel2_) { #if defined(__GNUC__) && __GNUC__ < 12 && !defined(__clang__) #pragma GCC diagnostic pop #endif it2_ = std::nullopt; sentinel2_ = std::nullopt; } } return *this; } friend bool operator==(const Iterator& it, const std::default_sentinel_t&) { return !it.it1_ && !it.it2_; } friend bool operator!=(const Iterator& it, const std::default_sentinel_t&) { return it.it1_ || it.it2_; } friend bool operator==(const std::default_sentinel_t& s, const Iterator& it) { return it == s; } friend bool operator!=(const std::default_sentinel_t& s, const Iterator& it) { return it != s; } private: Range1* range1_{nullptr}; Range2* range2_{nullptr}; std::optional it1_; std::optional it2_; std::optional sentinel1_; std::optional sentinel2_; }; static_assert(std::input_iterator); ConcatView(Range1 range1, Range2 range2) : range1_{std::move(range1)}, range2_{std::move(range2)} {} ConcatView() = default; ConcatView(ConcatView&&) = default; ConcatView& operator=(ConcatView&&) noexcept = default; Iterator begin() { return Iterator{&range1_, &range2_}; } std::default_sentinel_t end() const { return std::default_sentinel; } private: Range1 range1_; Range2 range2_; }; } // namespace silkworm::views::concat_view::fallback namespace silkworm::views { #ifdef SILKWORM_HAS_BUILTIN_CONCAT_VIEW using silkworm::views::concat_view::builtin::ConcatView; #else using silkworm::views::concat_view::fallback::ConcatView; #endif template ConcatView concat(Range1&& v1, Range2&& v2) { return ConcatView{std::forward(v1), std::forward(v2)}; } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/concat_view_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "concat_view.hpp" #include #include "owning_view.hpp" #include "vector_from_range.hpp" namespace silkworm::views { static_assert(std::ranges::input_range, std::vector>>); static_assert(std::ranges::view, std::vector>>); TEST_CASE("ConcatView") { CHECK(vector_from_range(concat( silkworm::ranges::owning_view(std::vector{1, 2, 3}), silkworm::ranges::owning_view(std::vector{4, 5, 6}))) == std::vector{1, 2, 3, 4, 5, 6}); auto even = [](int x) { return x % 2 == 0; }; auto odd = [](int x) { return x % 2 == 1; }; CHECK(vector_from_range(concat( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(even), silkworm::ranges::owning_view(std::vector{4, 5, 6}) | std::views::filter(odd))) == std::vector{2, 5}); CHECK(vector_from_range(concat( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(odd), silkworm::ranges::owning_view(std::vector{4, 5, 6}) | std::views::filter(even))) == std::vector{1, 3, 4, 6}); CHECK(vector_from_range(concat(std::ranges::empty_view{}, std::ranges::empty_view{})).empty()); CHECK(vector_from_range(concat(silkworm::ranges::owning_view(std::vector{1, 2, 3}), std::ranges::empty_view{})) == std::vector{1, 2, 3}); CHECK(vector_from_range(concat(std::ranges::empty_view{}, silkworm::ranges::owning_view(std::vector{4, 5, 6}))) == std::vector{4, 5, 6}); CHECK(vector_from_range(concat( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::transform([](int v) { return std::vector{v, v, v}; }) | std::views::join, silkworm::ranges::owning_view(std::vector{4, 4, 4}))) == std::vector{1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}); } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/if_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::views { template class IfView : public std::ranges::view_interface> { public: class Iterator { public: using Range1Iterator = std::ranges::iterator_t; using Range1Sentinel = std::ranges::sentinel_t; using Range1ReferenceType = std::iter_reference_t; using Range2Iterator = std::ranges::iterator_t; using Range2Sentinel = std::ranges::sentinel_t; using Range2ReferenceType = std::iter_reference_t; using DereferenceType = std::conditional_t, Range1ReferenceType, Range2ReferenceType>; using value_type = std::iter_value_t; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::iter_difference_t; using reference = DereferenceType; using pointer = std::remove_reference_t*; Iterator() = default; Iterator( std::optional it1, std::optional sentinel1, std::optional it2, std::optional sentinel2) : it1_{std::move(it1)}, sentinel1_{std::move(sentinel1)}, it2_{std::move(it2)}, sentinel2_{std::move(sentinel2)} {} reference operator*() const { if (it1_) return **it1_; if (it2_) return **it2_; SILKWORM_ASSERT(false); std::abort(); } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { if (it1_) ++(*it1_); if (it2_) ++(*it2_); return *this; } friend bool operator==(const Iterator& it, const std::default_sentinel_t&) { return (it.it1_ && (*it.it1_ == *it.sentinel1_)) || (it.it2_ && (*it.it2_ == *it.sentinel2_)); } friend bool operator!=(const Iterator& it, const std::default_sentinel_t& s) { return !(it == s); } friend bool operator==(const std::default_sentinel_t& s, const Iterator& it) { return it == s; } friend bool operator!=(const std::default_sentinel_t& s, const Iterator& it) { return !(it == s); } private: std::optional it1_; std::optional sentinel1_; std::optional it2_; std::optional sentinel2_; }; static_assert(std::input_iterator); IfView(bool cond, Range1 range1, Range2 range2) : cond_{cond}, range1_{std::move(range1)}, range2_{std::move(range2)} {} IfView() = default; IfView(IfView&&) = default; IfView& operator=(IfView&&) noexcept = default; Iterator begin() { if (cond_) { return Iterator{ std::ranges::begin(range1_), std::ranges::end(range1_), std::nullopt, std::nullopt, }; } return Iterator{ std::nullopt, std::nullopt, std::ranges::begin(range2_), std::ranges::end(range2_), }; } std::default_sentinel_t end() const { return std::default_sentinel; } private: bool cond_{false}; Range1 range1_; Range2 range2_; }; template IfView if_view(bool cond, Range1&& v1, Range2&& v2) { return IfView{cond, std::forward(v1), std::forward(v2)}; } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/lazy_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::ranges { template ()))> class LazyView : public std::ranges::view_interface> { public: LazyView() = default; explicit LazyView(TRangeFactory&& range_factory) : range_factory_{std::move(range_factory)} {} LazyView(LazyView&&) = default; LazyView& operator=(LazyView&& other) noexcept { range_factory_ = std::exchange(std::move(other.range_factory_), std::nullopt); range_ = std::exchange(std::move(other.range_), std::nullopt); return *this; }; std::ranges::iterator_t begin() { return std::ranges::begin(range()); } std::ranges::sentinel_t end() { return std::ranges::end(range()); } private: TRange& range() { if (!range_) { range_.emplace(std::invoke(*range_factory_)); } return *range_; } std::optional range_factory_; std::optional range_; }; template LazyView lazy(TRangeFactory&& range_factory) { return LazyView{std::forward(range_factory)}; } } // namespace silkworm::ranges ================================================ FILE: silkworm/db/datastore/common/ranges/merge_compare_func.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::views { struct MergeCompareFunc { template constexpr std::strong_ordering operator()(const T& lhs, const T& rhs) const noexcept { return std::compare_strong_order_fallback(lhs, rhs); } }; } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/merge_many_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include "merge_compare_func.hpp" #include "vector_from_range.hpp" namespace silkworm::views { template < std::ranges::input_range Ranges, std::ranges::input_range Range = std::iter_value_t>, class Comp = MergeCompareFunc, class Proj = std::identity, bool kUnique = false> class MergeManyView : public std::ranges::view_interface> { public: class Iterator { public: using RangeIterator = std::ranges::iterator_t; using RangeSentinel = std::ranges::sentinel_t; using RangeReferenceType = std::iter_reference_t; using DereferenceType = RangeReferenceType; using value_type = std::iter_value_t; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::iter_difference_t; using reference = DereferenceType; using pointer = std::remove_reference_t*; Iterator() = default; Iterator(std::vector& ranges, const Comp* comp, Proj proj) : comp_{comp}, proj_{std::move(proj)} { for (Range& range : ranges) { iterators_.emplace_back(std::ranges::begin(range)); sentinels_.emplace_back(std::ranges::end(range)); } for (size_t i = 0; i < iterators_.size(); i++) { if (!it_ended(i)) { order_.push_back(i); } } std::ranges::make_heap(order_, order_compare_func()); advance(); } reference operator*() const { SILKWORM_ASSERT(current_value_); return *current_value_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { advance(); return *this; } void advance() { if (order_.empty()) { current_value_.reset(); return; } current_value_.emplace(move_it_value(order_.front())); if constexpr (!kUnique) { next(); return; } // grab the current key for duplicate detection const auto& current_key = std::invoke(proj_, *current_value_); // first iteration: increment the current iterator once and restore the order // next iterations: skip duplicate keys and restore the order do { next(); } while ( !order_.empty() && std::is_eq(std::invoke(*comp_, std::invoke(proj_, *iterators_[order_.front()]), current_key))); } friend bool operator==(const Iterator& it, const std::default_sentinel_t&) { return !it.current_value_.has_value(); } friend bool operator!=(const Iterator& it, const std::default_sentinel_t&) { return it.current_value_.has_value(); } friend bool operator==(const std::default_sentinel_t& s, const Iterator& it) { return it == s; } friend bool operator!=(const std::default_sentinel_t& s, const Iterator& it) { return it != s; } private: //! Increment the current iterator once and restore the order void next() { size_t current = order_.front(); ++iterators_[current]; std::ranges::pop_heap(order_, order_compare_func()); order_.pop_back(); if (!it_ended(current)) { order_.push_back(current); std::ranges::push_heap(order_, order_compare_func()); } } bool it_ended(size_t i) const { return iterators_[i] == sentinels_[i]; } bool less(size_t lhs, size_t rhs) const { const RangeIterator& lhs_it = iterators_[lhs]; const RangeIterator& rhs_it = iterators_[rhs]; std::partial_ordering comp_result = std::invoke(*comp_, std::invoke(proj_, *lhs_it), std::invoke(proj_, *rhs_it)); if (std::is_lt(comp_result)) return true; if (std::is_gt(comp_result)) return false; // if equal prefer the smallest index range return lhs < rhs; } auto order_compare_func() const { return [this](size_t lhs, size_t rhs) -> bool { // the order is reversed because the heap puts the largest element at the front // (according to this->order_compare_func() as its "less" predicate), // but the merge sequence is expected to produce the smallest element at the front // (according to this->less() predicate) return this->less(rhs, lhs); }; } value_type move_it_value(size_t i) { return std::ranges::iter_move(iterators_[i]); } std::vector iterators_; std::vector sentinels_; const Comp* comp_{nullptr}; Proj proj_; std::vector order_; mutable std::optional current_value_; }; static_assert(std::input_iterator); MergeManyView( Ranges ranges, Comp comp, Proj proj) : ranges_{vector_from_range(std::move(ranges))}, comp_{std::move(comp)}, proj_{std::move(proj)} {} MergeManyView() = default; MergeManyView(MergeManyView&&) = default; MergeManyView& operator=(MergeManyView&&) noexcept = default; Iterator begin() { return Iterator{ranges_, &comp_, proj_}; } std::default_sentinel_t end() const { return std::default_sentinel; } private: std::vector ranges_; Comp comp_; Proj proj_; }; template < class Ranges, class Range = std::iter_value_t>, class Comp = MergeCompareFunc, class Proj = std::identity> MergeManyView merge_many( Ranges&& ranges, Comp comp = {}, Proj proj = {}) { return MergeManyView{ std::forward(ranges), std::move(comp), std::move(proj), }; } template < class Ranges, class Range = std::iter_value_t>, class Comp = MergeCompareFunc, class Proj = std::identity> MergeManyView merge_unique_many( Ranges&& ranges, Comp comp = {}, Proj proj = {}) { return MergeManyView{ std::forward(ranges), std::move(comp), std::move(proj), }; } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/merge_many_view_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "merge_many_view.hpp" #include #include "owning_view.hpp" #include "vector_from_range.hpp" namespace silkworm::views { static_assert(std::ranges::input_range>>>); static_assert(std::ranges::view>>>); static_assert(std::ranges::view>>>>); template std::vector ranges(TRange r1, TRange r2) { std::vector results; results.emplace_back(std::move(r1)); results.emplace_back(std::move(r2)); return results; } // Skip to avoid Windows error C3889: call to object of class type 'std::ranges::_Begin::_Cpo': no matching call operator found // Unable to reproduce: https://godbolt.org/z/3jd5brKMj #ifndef _WIN32 TEST_CASE("MergeManyView") { CHECK(vector_from_range(merge_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}), silkworm::ranges::owning_view(std::vector{2, 3, 4})))) == std::vector{1, 2, 2, 3, 3, 4}); CHECK(vector_from_range(merge_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7})))) == std::vector{1, 2, 3, 3, 4, 4, 5, 5, 6, 7}); CHECK(vector_from_range(merge_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5, 5, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7})))) == std::vector{1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 7}); CHECK(vector_from_range(merge_many(ranges( silkworm::ranges::owning_view(std::vector{0, 2, 2, 2, 4, 5, 6, 6, 7, 7}), silkworm::ranges::owning_view(std::vector{0, 0, 1, 2, 3, 5, 5, 6, 8, 9})))) == std::vector{0, 0, 0, 1, 2, 2, 2, 2, 3, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 9}); using IntPredicate = std::function; IntPredicate even = [](int x) { return x % 2 == 0; }; IntPredicate odd = [](int x) { return x % 2 == 1; }; CHECK(vector_from_range(merge_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(even), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(odd)))) == std::vector{2, 3}); CHECK(vector_from_range(merge_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(odd), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(even)))) == std::vector{1, 2, 3, 4}); CHECK(vector_from_range(merge_many(ranges(std::vector{}, std::vector{}))).empty()); CHECK(vector_from_range(merge_many(ranges(silkworm::ranges::owning_view(std::vector{1, 2, 3}), silkworm::ranges::owning_view(std::vector{})))) == std::vector{1, 2, 3}); CHECK(vector_from_range(merge_many(ranges(silkworm::ranges::owning_view(std::vector{}), silkworm::ranges::owning_view(std::vector{2, 3, 4})))) == std::vector{2, 3, 4}); using IntToVectorFunc = std::function(int)>; CHECK(vector_from_range(merge_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::transform(IntToVectorFunc{[](int v) { return std::vector{v, v, v}; }}) | std::views::join, silkworm::ranges::owning_view(std::vector{4, 4, 4}) | std::views::transform(IntToVectorFunc{[](int v) { return std::vector{v}; }}) | std::views::join))) == std::vector{1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}); } TEST_CASE("MergeUniqueManyView") { CHECK(vector_from_range(merge_unique_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}), silkworm::ranges::owning_view(std::vector{2, 3, 4})))) == std::vector{1, 2, 3, 4}); CHECK(vector_from_range(merge_unique_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7})))) == std::vector{1, 2, 3, 4, 5, 6, 7}); CHECK(vector_from_range(merge_unique_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5, 5, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7})))) == std::vector{1, 2, 3, 4, 5, 6, 7}); CHECK(vector_from_range(merge_unique_many(ranges( silkworm::ranges::owning_view(std::vector{0, 2, 2, 2, 4, 5, 6, 6, 7, 7}), silkworm::ranges::owning_view(std::vector{0, 0, 1, 2, 3, 5, 5, 6, 8, 9})))) == std::vector{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}); using IntPredicate = std::function; IntPredicate even = [](int x) { return x % 2 == 0; }; IntPredicate odd = [](int x) { return x % 2 == 1; }; CHECK(vector_from_range(merge_unique_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(even), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(odd)))) == std::vector{2, 3}); CHECK(vector_from_range(merge_unique_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(odd), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(even)))) == std::vector{1, 2, 3, 4}); CHECK(vector_from_range(merge_unique_many(ranges(std::vector{}, std::vector{}))).empty()); CHECK(vector_from_range(merge_unique_many(ranges(silkworm::ranges::owning_view(std::vector{1, 2, 3}), silkworm::ranges::owning_view(std::vector{})))) == std::vector{1, 2, 3}); CHECK(vector_from_range(merge_unique_many(ranges(silkworm::ranges::owning_view(std::vector{}), silkworm::ranges::owning_view(std::vector{2, 3, 4})))) == std::vector{2, 3, 4}); using IntToVectorFunc = std::function(int)>; CHECK(vector_from_range(merge_unique_many(ranges( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::transform(IntToVectorFunc{[](int v) { return std::vector{v, v, v}; }}) | std::views::join, silkworm::ranges::owning_view(std::vector{4, 4, 4}) | std::views::transform(IntToVectorFunc{[](int v) { return std::vector{v}; }}) | std::views::join))) == std::vector{1, 2, 3, 4}); } TEST_CASE("MergeUniqueManyView - move results") { auto view = merge_unique_many(ranges( std::vector{"v1"}, std::vector{"v1"})); auto it = view.begin(); { std::string v1 = std::move(*it); CHECK(v1 == "v1"); } CHECK_FALSE(it == view.end()); CHECK(++it == view.end()); } #endif // _WIN32 } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/merge_unique_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include "merge_compare_func.hpp" namespace silkworm::views { template < std::ranges::input_range Range1, std::ranges::input_range Range2, class Comp = MergeCompareFunc, class Proj1 = std::identity, class Proj2 = std::identity> class MergeUniqueView : public std::ranges::view_interface> { public: class Iterator { public: using Range1Iterator = std::ranges::iterator_t; using Range1Sentinel = std::ranges::sentinel_t; using Range1ReferenceType = std::iter_reference_t; using Range2Iterator = std::ranges::iterator_t; using Range2Sentinel = std::ranges::sentinel_t; using Range2ReferenceType = std::iter_reference_t; using DereferenceType = std::conditional_t, Range1ReferenceType, Range2ReferenceType>; using value_type = std::iter_value_t; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::iter_difference_t; using reference = DereferenceType; using pointer = std::remove_reference_t*; Iterator() = default; Iterator( Range1& range1, Range2& range2, const Comp* comp, Proj1 proj1, Proj2 proj2) : it1_{std::ranges::begin(range1)}, sentinel1_{std::ranges::end(range1)}, it2_{std::ranges::begin(range2)}, sentinel2_{std::ranges::end(range2)}, comp_{comp}, proj1_{std::move(proj1)}, proj2_{std::move(proj2)} { advance(); } reference operator*() const { SILKWORM_ASSERT(current_value_); return *current_value_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { advance(); return *this; } void advance() { const char selector = select(it1_ended(), it2_ended()); if (selector == 0) { current_value_.reset(); return; } current_value_.emplace(move_it_value(selector)); // grab the current key for duplicate detection const auto& current_key = std::invoke((selector == 1) ? proj1_ : proj2_, *current_value_); // increment the current iterator once if (selector == 1) { ++it1_; } else { ++it2_; } // skip duplicate keys while (!it1_ended() && std::is_eq(std::invoke(*comp_, std::invoke(proj1_, *it1_), current_key))) { ++it1_; } while (!it2_ended() && std::is_eq(std::invoke(*comp_, std::invoke(proj2_, *it2_), current_key))) { ++it2_; } } friend bool operator==(const Iterator& it, const std::default_sentinel_t&) { return !it.current_value_.has_value(); } friend bool operator!=(const Iterator& it, const std::default_sentinel_t&) { return it.current_value_.has_value(); } friend bool operator==(const std::default_sentinel_t& s, const Iterator& it) { return it == s; } friend bool operator!=(const std::default_sentinel_t& s, const Iterator& it) { return it != s; } private: bool it1_ended() const { return it1_ == sentinel1_; } bool it2_ended() const { return it2_ == sentinel2_; } char select(bool it1_ended, bool it2_ended) const { if (it1_ended && it2_ended) return 0; if (it1_ended) return 2; if (it2_ended) return 1; std::partial_ordering comp_result = std::invoke(*comp_, std::invoke(proj1_, *it1_), std::invoke(proj2_, *it2_)); if (std::is_lt(comp_result)) return 1; if (std::is_gt(comp_result)) return 2; // if equal prefer the first range return 1; } value_type move_it_value(char selector) { switch (selector) { case 1: return std::ranges::iter_move(it1_); case 2: return std::ranges::iter_move(it2_); default: SILKWORM_ASSERT(false); std::abort(); } } Range1Iterator it1_{}; Range1Sentinel sentinel1_{}; Range2Iterator it2_{}; Range2Sentinel sentinel2_{}; const Comp* comp_{nullptr}; Proj1 proj1_; Proj2 proj2_; mutable std::optional current_value_; }; static_assert(std::input_iterator); MergeUniqueView( Range1 range1, Range2 range2, Comp comp, Proj1 proj1, Proj2 proj2) : range1_{std::move(range1)}, range2_{std::move(range2)}, comp_{std::move(comp)}, proj1_{std::move(proj1)}, proj2_{std::move(proj2)} {} MergeUniqueView() = default; MergeUniqueView(MergeUniqueView&&) = default; MergeUniqueView& operator=(MergeUniqueView&&) noexcept = default; Iterator begin() { return Iterator{range1_, range2_, &comp_, proj1_, proj2_}; } std::default_sentinel_t end() const { return std::default_sentinel; } private: Range1 range1_; Range2 range2_; Comp comp_; Proj1 proj1_; Proj2 proj2_; }; template < class Range1, class Range2, class Comp = MergeCompareFunc, class Proj1 = std::identity, class Proj2 = std::identity> MergeUniqueView merge_unique( Range1&& v1, Range2&& v2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) { return MergeUniqueView{ std::forward(v1), std::forward(v2), std::move(comp), std::move(proj1), std::move(proj2), }; } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/merge_unique_view_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "merge_unique_view.hpp" #include #include #include "owning_view.hpp" #include "vector_from_range.hpp" namespace silkworm::views { static_assert(std::ranges::input_range, std::vector>>); static_assert(std::ranges::view, std::vector>>); TEST_CASE("MergeUniqueView") { CHECK(vector_from_range(merge_unique( silkworm::ranges::owning_view(std::vector{1, 2, 3}), silkworm::ranges::owning_view(std::vector{2, 3, 4}))) == std::vector{1, 2, 3, 4}); CHECK(vector_from_range(merge_unique( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7}))) == std::vector{1, 2, 3, 4, 5, 6, 7}); CHECK(vector_from_range(merge_unique( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5, 5, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7}))) == std::vector{1, 2, 3, 4, 5, 6, 7}); CHECK(vector_from_range(merge_unique( silkworm::ranges::owning_view(std::vector{0, 2, 2, 2, 4, 5, 6, 6, 7, 7}), silkworm::ranges::owning_view(std::vector{0, 0, 1, 2, 3, 5, 5, 6, 8, 9}))) == std::vector{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}); auto even = [](int x) { return x % 2 == 0; }; auto odd = [](int x) { return x % 2 == 1; }; CHECK(vector_from_range(merge_unique( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(even), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(odd))) == std::vector{2, 3}); CHECK(vector_from_range(merge_unique( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(odd), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(even))) == std::vector{1, 2, 3, 4}); CHECK(vector_from_range(merge_unique(std::ranges::empty_view{}, std::ranges::empty_view{})).empty()); CHECK(vector_from_range(merge_unique(silkworm::ranges::owning_view(std::vector{1, 2, 3}), std::ranges::empty_view{})) == std::vector{1, 2, 3}); CHECK(vector_from_range(merge_unique(std::ranges::empty_view{}, silkworm::ranges::owning_view(std::vector{2, 3, 4}))) == std::vector{2, 3, 4}); CHECK(vector_from_range(merge_unique( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::transform([](int v) { return std::vector{v, v, v}; }) | std::views::join, silkworm::ranges::owning_view(std::vector{4, 4, 4}))) == std::vector{1, 2, 3, 4}); } TEST_CASE("MergeUniqueView - move results") { auto view = merge_unique( silkworm::ranges::owning_view(std::vector{"v1"}), silkworm::ranges::owning_view(std::vector{"v1"})); auto it = view.begin(); { std::string v1 = std::move(*it); CHECK(v1 == "v1"); } CHECK_FALSE(it == view.end()); CHECK(++it == view.end()); } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/merge_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::views { template < std::ranges::input_range Range1, std::ranges::input_range Range2, class Comp = std::ranges::less, class Proj1 = std::identity, class Proj2 = std::identity> class MergeView : public std::ranges::view_interface> { public: class Iterator { public: using Range1Iterator = std::ranges::iterator_t; using Range1Sentinel = std::ranges::sentinel_t; using Range1ReferenceType = std::iter_reference_t; using Range2Iterator = std::ranges::iterator_t; using Range2Sentinel = std::ranges::sentinel_t; using Range2ReferenceType = std::iter_reference_t; using DereferenceType = std::conditional_t, Range1ReferenceType, Range2ReferenceType>; using value_type = std::iter_value_t; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::iter_difference_t; using reference = DereferenceType; using pointer = std::remove_reference_t*; Iterator() = default; Iterator( Range1& range1, Range2& range2, Comp comp, Proj1 proj1, Proj2 proj2) : it1_{std::ranges::begin(range1)}, sentinel1_{std::ranges::end(range1)}, it2_{std::ranges::begin(range2)}, sentinel2_{std::ranges::end(range2)}, comp_{std::move(comp)}, proj1_{std::move(proj1)}, proj2_{std::move(proj2)}, selector_{select(it1_ended(), it2_ended())} {} reference operator*() const { switch (selector_) { case 1: return *it1_; case 2: return *it2_; default: SILKWORM_ASSERT(false); std::abort(); } } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { switch (selector_) { case 1: ++it1_; break; case 2: ++it2_; break; default: SILKWORM_ASSERT(false); return *this; } selector_ = select(it1_ended(), it2_ended()); return *this; } friend bool operator==(const Iterator& it, const std::default_sentinel_t&) { return !it.selector_; } friend bool operator!=(const Iterator& it, const std::default_sentinel_t&) { return it.selector_; } friend bool operator==(const std::default_sentinel_t& s, const Iterator& it) { return it == s; } friend bool operator!=(const std::default_sentinel_t& s, const Iterator& it) { return it != s; } private: bool it1_ended() const { return it1_ == sentinel1_; } bool it2_ended() const { return it2_ == sentinel2_; } char select(bool it1_ended, bool it2_ended) const { if (it1_ended && it2_ended) return 0; if (it1_ended) return 2; if (it2_ended) return 1; bool is_gte = std::invoke(comp_, std::invoke(proj2_, *it2_), std::invoke(proj1_, *it1_)); return is_gte ? 2 : 1; } Range1Iterator it1_; Range1Sentinel sentinel1_; Range2Iterator it2_; Range2Sentinel sentinel2_; Comp comp_; Proj1 proj1_; Proj2 proj2_; char selector_{0}; }; static_assert(std::input_iterator); MergeView( Range1 range1, Range2 range2, Comp comp, Proj1 proj1, Proj2 proj2) : range1_{std::move(range1)}, range2_{std::move(range2)}, comp_{std::move(comp)}, proj1_{std::move(proj1)}, proj2_{std::move(proj2)} {} MergeView() = default; MergeView(MergeView&&) = default; MergeView& operator=(MergeView&&) noexcept = default; Iterator begin() { return Iterator{range1_, range2_, comp_, proj1_, proj2_}; } std::default_sentinel_t end() const { return std::default_sentinel; } private: Range1 range1_; Range2 range2_; Comp comp_; Proj1 proj1_; Proj2 proj2_; }; template < class Range1, class Range2, class Comp = std::ranges::less, class Proj1 = std::identity, class Proj2 = std::identity> MergeView merge( Range1&& v1, Range2&& v2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) { return MergeView{ std::forward(v1), std::forward(v2), std::move(comp), std::move(proj1), std::move(proj2), }; } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/merge_view_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "merge_view.hpp" #include #include "owning_view.hpp" #include "vector_from_range.hpp" namespace silkworm::views { static_assert(std::ranges::input_range, std::vector>>); static_assert(std::ranges::view, std::vector>>); TEST_CASE("MergeView") { CHECK(vector_from_range(merge( silkworm::ranges::owning_view(std::vector{1, 2, 3}), silkworm::ranges::owning_view(std::vector{2, 3, 4}))) == std::vector{1, 2, 2, 3, 3, 4}); CHECK(vector_from_range(merge( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7}))) == std::vector{1, 2, 3, 3, 4, 4, 5, 5, 6, 7}); CHECK(vector_from_range(merge( silkworm::ranges::owning_view(std::vector{1, 2, 3, 4, 5, 5, 5}), silkworm::ranges::owning_view(std::vector{3, 4, 5, 6, 7}))) == std::vector{1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 7}); CHECK(vector_from_range(merge( silkworm::ranges::owning_view(std::vector{0, 2, 2, 2, 4, 5, 6, 6, 7, 7}), silkworm::ranges::owning_view(std::vector{0, 0, 1, 2, 3, 5, 5, 6, 8, 9}))) == std::vector{0, 0, 0, 1, 2, 2, 2, 2, 3, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 9}); auto even = [](int x) { return x % 2 == 0; }; auto odd = [](int x) { return x % 2 == 1; }; CHECK(vector_from_range(merge( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(even), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(odd))) == std::vector{2, 3}); CHECK(vector_from_range(merge( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::filter(odd), silkworm::ranges::owning_view(std::vector{2, 3, 4}) | std::views::filter(even))) == std::vector{1, 2, 3, 4}); CHECK(vector_from_range(merge(std::ranges::empty_view{}, std::ranges::empty_view{})).empty()); CHECK(vector_from_range(merge(silkworm::ranges::owning_view(std::vector{1, 2, 3}), std::ranges::empty_view{})) == std::vector{1, 2, 3}); CHECK(vector_from_range(merge(std::ranges::empty_view{}, silkworm::ranges::owning_view(std::vector{2, 3, 4}))) == std::vector{2, 3, 4}); CHECK(vector_from_range(merge( silkworm::ranges::owning_view(std::vector{1, 2, 3}) | std::views::transform([](int v) { return std::vector{v, v, v}; }) | std::views::join, silkworm::ranges::owning_view(std::vector{4, 4, 4}))) == std::vector{1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}); } } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/owning_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include // std::ranges::owning_view is not present on GCC < 12.1 // see P2415R2 at https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#status.iso.2020 #if __GNUC__ < 12 && !defined(__clang__) #else #define SILKWORM_HAS_BUILTIN_OWNING_VIEW #endif #ifdef SILKWORM_HAS_BUILTIN_OWNING_VIEW namespace silkworm::ranges::builtin { template using OwningView = std::ranges::owning_view; } // namespace silkworm::ranges::builtin #endif namespace silkworm::ranges::fallback { // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2415r2.html template requires std::movable class OwningView : public std::ranges::view_interface> { public: OwningView() requires std::default_initializable = default; explicit constexpr OwningView(TRange&& range) : range_{std::move(range)} {} OwningView(OwningView&&) = default; OwningView& operator=(OwningView&&) = default; constexpr TRange& base() & noexcept { return range_; } constexpr const TRange& base() const& noexcept { return range_; } constexpr TRange&& base() && noexcept { return std::move(range_); } constexpr const TRange&& base() const&& noexcept { return std::move(range_); } constexpr std::ranges::iterator_t begin() { return std::ranges::begin(range_); } constexpr std::ranges::sentinel_t end() { return std::ranges::end(range_); } constexpr auto begin() const requires std::ranges::range { return std::ranges::begin(range_); } constexpr auto end() const requires std::ranges::range { return std::ranges::end(range_); } constexpr bool empty() requires requires { std::ranges::empty(std::declval()); } { return std::ranges::empty(range_); } constexpr bool empty() const requires requires { std::ranges::empty(std::declval()); } { return std::ranges::empty(range_); } constexpr auto size() requires std::ranges::sized_range { return std::ranges::size(range_); } constexpr auto size() const requires std::ranges::sized_range { return std::ranges::size(range_); } constexpr auto data() requires std::ranges::contiguous_range { return std::ranges::data(range_); } constexpr auto data() const requires std::ranges::contiguous_range { return std::ranges::data(range_); } private: TRange range_; }; } // namespace silkworm::ranges::fallback namespace silkworm::ranges { #ifdef SILKWORM_HAS_BUILTIN_OWNING_VIEW using silkworm::ranges::builtin::OwningView; #else using silkworm::ranges::fallback::OwningView; #endif template OwningView owning_view(TRange&& range) { return OwningView{std::forward(range)}; } } // namespace silkworm::ranges ================================================ FILE: silkworm/db/datastore/common/ranges/unique_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "merge_unique_view.hpp" namespace silkworm::views { template < std::ranges::input_range TRange, class Comp = MergeCompareFunc, class Proj = std::identity> using UniqueView = MergeUniqueView>>, Comp, Proj, Proj>; template struct UniqueViewFactory { template constexpr UniqueView operator()( TRange&& range, Comp comp = {}, Proj proj = {}) const { return UniqueView{std::forward(range), {}, std::move(comp), proj, proj}; } template friend constexpr UniqueView operator|(TRange&& range, const UniqueViewFactory& unique) { return unique(std::forward(range)); } }; template inline constexpr UniqueViewFactory unique; // NOLINT(*-identifier-naming) } // namespace silkworm::views ================================================ FILE: silkworm/db/datastore/common/ranges/vector_from_range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { template >> std::vector vector_from_range(Range&& range) { std::vector results; for (auto&& value : range) { results.emplace_back(std::move(value)); } return results; } template >> std::vector vector_from_range_copy(Range&& range) { std::vector results; std::ranges::copy(range, std::back_inserter(results)); return results; } } // namespace silkworm ================================================ FILE: silkworm/db/datastore/common/step.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::datastore { struct Step { size_t value; constexpr explicit Step(size_t value1) : value(value1) {} friend bool operator==(const Step&, const Step&) = default; bool operator<(const Step& other) const { return this->value < other.value; } bool operator<=(const Step& other) const { return this->value <= other.value; } std::string to_string() const { return std::to_string(value) + "st"; } }; inline constexpr Step kMaxStep{std::numeric_limits::max()}; struct StepRange { Step start; Step end; StepRange(Step start1, Step end1) : start(start1), end(end1) { ensure(start <= end, "StepRange: end before start"); } friend bool operator==(const StepRange&, const StepRange&) = default; bool contains(Step x) const { return (start <= x) && (x < end); } bool contains_range(StepRange range) const { return (start <= range.start) && (range.end <= end); } size_t size() const { return end.value - start.value; } std::string to_string() const { return std::string("[") + start.to_string() + ", " + end.to_string() + ")"; } }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/common/step_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "step.hpp" #include namespace silkworm::datastore { TEST_CASE("Step", "[datastore][common]") { SECTION("Step constructor and value") { Step step{10}; CHECK(step.value == 10); } SECTION("Step comparison operators") { Step step1{10}; Step step2{20}; CHECK(step1 < step2); CHECK(step1 <= step2); CHECK_FALSE(step2 < step1); } SECTION("Step to string") { Step step{100}; CHECK(step.to_string() == "100st"); } } TEST_CASE("StepRange", "[datastore][common]") { StepRange range(Step{10}, Step{20}); SECTION("StepRange constructor") { CHECK(range.start.value == 10); CHECK(range.end.value == 20); } SECTION("StepRange containment") { CHECK(range.contains(Step{15})); CHECK_FALSE(range.contains(Step{25})); } SECTION("StepRange size") { CHECK(range.size() == 10); } SECTION("StepRange to string") { CHECK(range.to_string() == "[10st, 20st)"); } } } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/common/step_timestamp_converter.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "step_timestamp_converter.hpp" #include namespace silkworm::datastore { Step StepToTimestampConverter::step_from_timestamp(Timestamp t) const { if (t == kMaxTimestamp) return kMaxStep; return Step{static_cast(t / step_size)}; } Timestamp StepToTimestampConverter::timestamp_from_step(Step s) const { if (s == kMaxStep) return kMaxTimestamp; return s.value * step_size; } StepRange StepToTimestampConverter::step_range_from_timestamp_range(TimestampRange range) const { if (range.end == kMaxTimestamp) { return StepRange{step_from_timestamp(range.start), kMaxStep}; } ensure(range.end <= kMaxTimestamp - step_size + 1, "step_range_from_timestamp_range: end step overflow"); Step end = step_from_timestamp(range.end + step_size - 1); return StepRange{step_from_timestamp(range.start), end}; } } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/common/step_timestamp_converter.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "step.hpp" #include "timestamp.hpp" namespace silkworm::datastore { struct StepToTimestampConverter { size_t step_size; Step step_from_timestamp(Timestamp t) const; Timestamp timestamp_from_step(Step s) const; StepRange step_range_from_timestamp_range(TimestampRange range) const; TimestampRange timestamp_range_from_step_range(StepRange range) const { return TimestampRange{timestamp_from_step(range.start), timestamp_from_step(range.end)}; } }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/common/step_timestamp_converter_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "step_timestamp_converter.hpp" #include namespace silkworm::datastore { TEST_CASE("StepToTimestampConverter") { static constexpr size_t kStepSize = 1000; StepToTimestampConverter converter{kStepSize}; SECTION("Step to Timestamp and back") { Step step{10}; Timestamp ts = converter.timestamp_from_step(step); CHECK(ts == kStepSize * 10); CHECK(converter.step_from_timestamp(ts) == step); CHECK(converter.timestamp_from_step(Step{0}) == 0); CHECK(converter.timestamp_from_step(Step{500}) == kStepSize * 500); } SECTION("Step limits") { CHECK(converter.step_from_timestamp(kMaxTimestamp) == kMaxStep); CHECK(converter.timestamp_from_step(kMaxStep) == kMaxTimestamp); } SECTION("StepRange to TimestampRange and back") { StepRange range{Step{10}, Step{20}}; const TimestampRange ts_range = converter.timestamp_range_from_step_range(range); CHECK(ts_range == TimestampRange{kStepSize * 10, kStepSize * 20}); CHECK(converter.step_range_from_timestamp_range(ts_range) == range); CHECK(converter.timestamp_range_from_step_range({Step{0}, Step{0}}) == TimestampRange{0, 0}); CHECK(converter.timestamp_range_from_step_range({Step{0}, Step{500}}) == TimestampRange{0, kStepSize * 500}); } SECTION("StepRange limits") { CHECK(converter.step_range_from_timestamp_range({kMaxTimestamp, kMaxTimestamp}) == StepRange{kMaxStep, kMaxStep}); CHECK(converter.timestamp_range_from_step_range({kMaxStep, kMaxStep}) == TimestampRange{kMaxTimestamp, kMaxTimestamp}); CHECK_THROWS(converter.step_range_from_timestamp_range({0, kMaxTimestamp - 1})); } } } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/common/timestamp.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::datastore { using Timestamp = uint64_t; inline constexpr Timestamp kMaxTimestamp = std::numeric_limits::max(); struct TimestampRange { Timestamp start; Timestamp end; TimestampRange(Timestamp start1, Timestamp end1) : start(start1), end(end1) {} friend bool operator==(const TimestampRange&, const TimestampRange&) = default; bool contains(Timestamp value) const { return (start <= value) && (value < end); } auto contains_predicate() const { return [range = *this](Timestamp t) { return range.contains(t); }; }; bool contains_range(TimestampRange range) const { return (start <= range.start) && (range.end <= end); } Timestamp size() const { return end - start; } std::string to_string() const { return std::string("[") + std::to_string(start) + ", " + std::to_string(end) + ")"; } }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/data_migration.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "data_migration.hpp" #include #include #include namespace silkworm::datastore { Task DataMigration::exec() { SILK_DEBUG_M(name()) << "START"; SILK_DEBUG_M(name()) << "pre-cleanup"; co_await cleanup(); auto command = next_command(); if (!command) { SILK_DEBUG_M(name()) << "END noop"; co_return false; } SILK_DEBUG_M(name()) << "migrate " << command->to_string(); auto result = migrate(std::move(command)); SILK_DEBUG_M(name()) << "index"; index(result); SILK_DEBUG_M(name()) << "commit"; commit(result); SILK_DEBUG_M(name()) << "post-cleanup"; co_await cleanup(); SILK_DEBUG_M(name()) << "END"; co_return true; } Task DataMigration::run_loop() { using namespace std::chrono_literals; while (true) { bool has_migrated = co_await exec(); if (!has_migrated) co_await sleep(1min); } } } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/data_migration.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "data_migration_command.hpp" namespace silkworm::datastore { struct DataMigrationResult { virtual ~DataMigrationResult() = default; }; struct DataMigration { virtual ~DataMigration() = default; Task exec(); Task run_loop(); protected: virtual const char* name() const = 0; virtual std::unique_ptr next_command() = 0; virtual std::shared_ptr migrate(std::unique_ptr command) = 0; virtual void index(std::shared_ptr result) = 0; virtual void commit(std::shared_ptr result) = 0; virtual Task cleanup() = 0; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/data_migration_command.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::datastore { struct DataMigrationCommand { virtual ~DataMigrationCommand() = default; virtual std::string to_string() const = 0; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/data_store.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "common/entity_name.hpp" #include "kvdb/database.hpp" #include "schema.hpp" #include "snapshots/query_caches.hpp" #include "snapshots/snapshot_repository.hpp" namespace silkworm::datastore { class DataStore { public: DataStore( Schema schema, EntityMap> databases, EntityMap> repositories, const std::filesystem::path& snapshots_path) : schema_{std::move(schema)}, databases_{std::move(databases)}, repositories_{std::move(repositories)}, query_caches_{schema_.snapshots.query_caches_schema(), snapshots_path} {} const Schema& schema() const { return schema_; } kvdb::Database& default_database() const { return database(kvdb::Schema::kDefaultEntityName); } kvdb::Database& database(const EntityName& name) const { return *databases_.at(name); } snapshots::SnapshotRepository& repository(const EntityName& name) const { return *repositories_.at(name); } const snapshots::QueryCaches& query_caches() const { return query_caches_; } private: Schema schema_; EntityMap> databases_; EntityMap> repositories_; snapshots::QueryCaches query_caches_; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/domain_get_as_of_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "domain_get_latest_query.hpp" #include "history_get_query.hpp" namespace silkworm::datastore { template < kvdb::EncoderConcept TKeyEncoder1, snapshots::EncoderConcept TKeyEncoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2, const snapshots::SegmentAndAccessorIndexNames& history_segment_names> struct DomainGetAsOfQuery { DomainGetAsOfQuery( kvdb::Domain kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository_latest, const snapshots::SnapshotRepositoryROAccess& repository_historical, const snapshots::QueryCaches& query_caches) : query1_{*kvdb_entity.history, tx, repository_historical, query_caches}, query2_{history_segment_names.front(), kvdb_entity, tx, repository_latest, query_caches} {} DomainGetAsOfQuery( const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository_latest, const snapshots::SnapshotRepositoryROAccess& repository_historical, const snapshots::QueryCaches& query_caches) : query1_{database, tx, repository_historical, query_caches}, query2_{history_segment_names.front(), database, tx, repository_latest, query_caches} {} using Key = decltype(TKeyEncoder1::value); using Value = decltype(TValueDecoder1::value); std::optional exec(const Key& key, std::optional timestamp) { if (timestamp) { auto result1 = query1_.exec(key, *timestamp); if (result1) { return result1; } } auto result2 = query2_.exec(key); if (result2) { return std::move(result2->value); } return std::nullopt; } private: HistoryGetQuery query1_; DomainGetLatestQuery query2_; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/domain_get_latest_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "kvdb/database.hpp" #include "kvdb/domain_get_latest_query.hpp" #include "snapshots/domain_get_latest_query.hpp" namespace silkworm::datastore { template < kvdb::EncoderConcept TKeyEncoder1, snapshots::EncoderConcept TKeyEncoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2> struct DomainGetLatestQuery { DomainGetLatestQuery( datastore::EntityName entity_name, kvdb::Domain kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : query1_{tx, kvdb_entity}, query2_{repository, query_caches, entity_name} {} DomainGetLatestQuery( datastore::EntityName entity_name, const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : DomainGetLatestQuery{ entity_name, database.domain(entity_name), tx, repository, query_caches, } {} using Key1 = decltype(TKeyEncoder1::value); using Key2 = decltype(TKeyEncoder2::value); static_assert(std::same_as); using Key = Key1; using Result1 = typename kvdb::DomainGetLatestQuery::Result; using Result2 = typename snapshots::DomainGetLatestQuery::Result; using Result = Result1; std::optional exec(const Key& key) { auto result1 = query1_.exec(key); if (result1) { return result1; } auto result2 = query2_.exec(key); if (result2) { return Result{std::move(result2->value), result2->step}; } return std::nullopt; } private: kvdb::DomainGetLatestQuery query1_; snapshots::DomainGetLatestQuery query2_; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/domain_range_as_of_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "common/ranges/if_view.hpp" #include "common/ranges/merge_unique_view.hpp" #include "domain_range_latest_query.hpp" #include "history_range_by_keys_query.hpp" namespace silkworm::datastore { template < kvdb::EncoderConcept TKeyEncoder1, snapshots::EncoderConcept TKeyEncoder2, kvdb::DecoderConcept TKeyDecoder1, snapshots::DecoderConcept TKeyDecoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2> struct DomainRangeAsOfQuery { DomainRangeAsOfQuery( datastore::EntityName entity_name, kvdb::Domain kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository_latest, const snapshots::SnapshotRepositoryROAccess& repository_historical) : query1_{*kvdb_entity.history, tx, repository_historical}, query2_{entity_name, kvdb_entity, tx, repository_latest} {} DomainRangeAsOfQuery( datastore::EntityName entity_name, const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository_latest, const snapshots::SnapshotRepositoryROAccess& repository_historical) : query1_{entity_name, database, tx, repository_historical}, query2_{entity_name, database, tx, repository_latest} {} using Key = decltype(TKeyEncoder1::value); using ResultItem = typename DomainRangeLatestQuery::ResultItem; auto exec(const Key& key_start, const Key& key_end, std::optional timestamp, bool ascending, bool skip_empty_values) { return silkworm::views::if_view( !timestamp.has_value(), query2_.exec(key_start, key_end, ascending), this->exec(key_start, key_end, timestamp.value_or(0), ascending, skip_empty_values)); } auto exec(const Key& key_start, const Key& key_end, Timestamp timestamp, bool ascending, bool skip_empty_values) { SILKWORM_ASSERT(ascending); // descending is not implemented auto skip_empty_value_predicate = [skip_empty_values](std::pair& kv_pair) { if (!skip_empty_values) return true; return !kv_pair.second.empty(); }; return silkworm::views::merge_unique( query1_.exec(key_start, key_end, timestamp, ascending), query2_.exec(key_start, key_end, ascending), silkworm::views::MergeCompareFunc{}, PairGetFirst{}, PairGetFirst{}) | std::views::filter(std::move(skip_empty_value_predicate)); } private: HistoryRangeByKeysQuery query1_; DomainRangeLatestQuery query2_; }; template < kvdb::EncoderConcept TKeyEncoder1, snapshots::EncoderConcept TKeyEncoder2, kvdb::DecoderConcept TKeyDecoder1, snapshots::DecoderConcept TKeyDecoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2> using DomainRangeAsOfQueryResult = decltype(std::declval>().exec( std::declval::Key&>(), std::declval::Key&>(), std::declval>(), std::declval(), std::declval())); } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/domain_range_latest_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "common/pair_get.hpp" #include "common/ranges/caching_view.hpp" #include "common/ranges/merge_unique_view.hpp" #include "kvdb/database.hpp" #include "kvdb/domain_range_latest_query.hpp" #include "kvdb/raw_codec.hpp" #include "snapshots/common/raw_codec.hpp" #include "snapshots/domain_range_latest_query.hpp" namespace silkworm::datastore { template < kvdb::EncoderConcept TKeyEncoder1, snapshots::EncoderConcept TKeyEncoder2, kvdb::DecoderConcept TKeyDecoder1, snapshots::DecoderConcept TKeyDecoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2> struct DomainRangeLatestQuery { DomainRangeLatestQuery( datastore::EntityName entity_name, kvdb::Domain kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : query1_{tx, std::move(kvdb_entity)}, query2_{repository, entity_name} {} DomainRangeLatestQuery( datastore::EntityName entity_name, const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : DomainRangeLatestQuery{ entity_name, database.domain(entity_name), tx, repository, } {} using Key1 = decltype(TKeyEncoder1::value); using Key2 = decltype(TKeyEncoder2::value); static_assert(std::same_as); using Key = Key1; using Word = snapshots::Decoder::Word; using ResultItemKey1 = decltype(TKeyDecoder1::value); using ResultItemKey2 = decltype(TKeyDecoder2::value); static_assert(std::same_as); using ResultItemKey = ResultItemKey1; using ResultItemValue1 = decltype(TValueDecoder1::value); using ResultItemValue2 = decltype(TValueDecoder2::value); static_assert(std::same_as); using ResultItemValue = ResultItemValue1; using ResultItem = std::pair; static ResultItem decode_kv_pair(std::pair&& kv_pair) { if constexpr (std::same_as>) { return std::move(kv_pair); } TKeyDecoder2 key_decoder; Word key_byte_word{std::move(kv_pair.first)}; key_decoder.decode_word(key_byte_word); ResultItemKey& key = key_decoder.value; TValueDecoder2 value_decoder; Word value_byte_word{std::move(kv_pair.second)}; value_decoder.decode_word(value_byte_word); ResultItemValue& value = value_decoder.value; return ResultItem{std::move(key), std::move(value)}; } static constexpr auto kDecodeKVPairFunc = [](std::pair& kv_pair) -> ResultItem { return decode_kv_pair(std::move(kv_pair)); }; auto exec(const Key& key_start, const Key& key_end, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented return silkworm::views::merge_unique( query1_.exec(key_start, key_end, ascending), query2_.exec(key_start, key_end, ascending), silkworm::views::MergeCompareFunc{}, PairGetFirst{}, PairGetFirst{}) | std::views::transform(kDecodeKVPairFunc) | silkworm::views::caching; } private: kvdb::DomainRangeLatestQuery, kvdb::RawDecoder> query1_; snapshots::DomainRangeLatestQuery, snapshots::RawDecoder> query2_; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/etl/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") silkworm_library( silkworm_datastore_etl PUBLIC silkworm_core PRIVATE silkworm_infra ) ================================================ FILE: silkworm/db/datastore/etl/buffer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "util.hpp" namespace silkworm::datastore::etl { inline constexpr size_t kInitialBufferCapacity = 32768; // In ETL, a buffer must be used stores entries, sort them and write them to file class Buffer { public: // Not copyable nor movable Buffer(const Buffer&) = delete; Buffer& operator=(const Buffer&) = delete; explicit Buffer(size_t optimal_size) : optimal_size_(optimal_size) { buffer_.reserve(kInitialBufferCapacity); } void put(Entry entry) { // Add a new entry to the buffer size_ += entry.size() + sizeof(EntryHeader); buffer_.push_back(std::move(entry)); } void clear() noexcept { // Set the buffer to contain 0 entries buffer_.clear(); size_ = 0; } bool overflows() const noexcept { // Whether accounted size overflows optimal_size_ (i.e. time to flush) return size_ >= optimal_size_; } void sort() { // Sort buffer in increasing order by key comparison std::sort(buffer_.begin(), buffer_.end()); } size_t size() const noexcept { // Actual size of accounted data return size_; } const std::vector& entries() const noexcept { return buffer_; } private: size_t optimal_size_; size_t size_ = 0; std::vector buffer_; // buffer for holding entries }; } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/collector.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "collector.hpp" #include #include #include #include #include #include #include #include namespace silkworm::datastore::etl { namespace fs = std::filesystem; Collector::~Collector() { clear(); // Will ensure all files (if any) have been orderly closed and deleted if (work_path_managed_ && fs::exists(work_path_)) { fs::remove_all(work_path_); } } void Collector::flush_buffer() { if (buffer_.size()) { StopWatch sw(/*auto_start=*/true); buffer_.sort(); /* Build a unique file name to pass FileProvider */ fs::path new_file_path{ work_path_ / fs::path(std::to_string(unique_id_) + "-" + std::to_string(file_providers_.size()) + ".bin")}; file_providers_.emplace_back(new FileProvider(new_file_path.string(), file_providers_.size())); file_providers_.back()->flush(buffer_); buffer_.clear(); const auto [_, duration]{sw.stop()}; log::Debug( "ETL collector flushed file", { "path", std::string(file_providers_.back()->get_file_name()), "size", human_size(file_providers_.back()->get_file_size()), "in", StopWatch::format(duration), }); } } void Collector::collect(Entry entry) { ++size_; bytes_size_ += entry.size(); buffer_.put(std::move(entry)); if (buffer_.overflows()) { flush_buffer(); } } void Collector::collect(Bytes key, Bytes value) { collect(Entry{std::move(key), std::move(value)}); } void Collector::load(const LoadFunc& load_func) { using namespace std::chrono_literals; static constexpr std::chrono::seconds kLogInterval{5s}; // Updates processing key (for log purposes) every this time auto log_time{std::chrono::steady_clock::now()}; // To check if an update of key is needed set_loading_key({}); if (empty()) { return; } if (file_providers_.empty()) { buffer_.sort(); for (const auto& etl_entry : buffer_.entries()) { if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { if (SignalHandler::signalled()) { throw std::runtime_error("Operation cancelled"); } set_loading_key(etl_entry.key); log_time = now + kLogInterval; } load_func(etl_entry); } clear(); return; } // Flush not overflown buffer data to file flush_buffer(); // Define a priority queue based on smallest available key auto key_comparer = [](const std::pair& left, const std::pair& right) { return right.first < left.first; }; std::priority_queue, std::vector>, decltype(key_comparer)> queue( key_comparer); // Read one "record" from each data_provider and let the queue // sort them. On top of the queue the smallest key for (auto& file_provider : file_providers_) { auto item{file_provider->read_entry()}; if (item.has_value()) { queue.push(std::move(*item)); } } // Process the queue from smallest to largest key while (!queue.empty()) { auto& [etl_entry, provider_index]{queue.top()}; // Pick the smallest key by reference auto& file_provider{file_providers_.at(provider_index)}; // and set current file provider if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { if (SignalHandler::signalled()) { throw std::runtime_error("Operation cancelled"); } log_time = now + kLogInterval; set_loading_key(etl_entry.key); } // Process linked pairs load_func(etl_entry); // From the provider which has served the current key // read next "record" auto next{file_provider->read_entry()}; // At this point `current` has been processed. // We can remove it from the queue queue.pop(); // Add next item to the queue only if it has // meaningful data if (next.has_value()) { queue.push(std::move(*next)); } else { file_provider.reset(); } } clear(); } std::filesystem::path Collector::set_work_path(const std::optional& provided_work_path) { fs::path res; // If something provided ensure exists as a directory if (provided_work_path.has_value()) { if (fs::exists(provided_work_path.value()) && !fs::is_directory(provided_work_path.value())) { throw EtlError("Invalid collector directory name"); } res = provided_work_path.value(); } else { // No path provided we need to get a unique temporary directory // to prevent different instances of collector to clash each other // with same filenames res = TemporaryDirectory::get_unique_temporary_path(); } if (res.has_filename()) { res += std::filesystem::path::preferred_separator; } fs::create_directories(res); return res; } } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/collector.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include "buffer.hpp" #include "collector_settings.hpp" #include "file_provider.hpp" #include "util.hpp" // ETL : Extract, Transform, Load // https://en.wikipedia.org/wiki/Extract,_transform,_load namespace silkworm::datastore::etl { inline constexpr size_t kOptimalBufferSize = 256_Mebi; // Function pointer to process data loading using LoadFunc = std::function; // Collects data Extracted from db class Collector { public: // Not copyable nor movable Collector(const Collector&) = delete; Collector& operator=(const Collector&) = delete; explicit Collector( const CollectorSettings& settings) : work_path_managed_{false}, work_path_{settings.work_path}, buffer_{settings.buffer_size} {}; explicit Collector(const std::filesystem::path& work_path, size_t buffer_size = kOptimalBufferSize) : work_path_managed_{false}, work_path_{set_work_path(work_path)}, buffer_{buffer_size} {} explicit Collector(size_t buffer_size = kOptimalBufferSize) : work_path_managed_{true}, work_path_{set_work_path(std::nullopt)}, buffer_{buffer_size} {} ~Collector(); // Store key-value pair in memory or on disk void collect(Entry entry); // Store key & value in memory or on disk void collect(Bytes key, Bytes value); //! \brief Loads and optionally transforms collected entries into db //! \param [in] load_func : Pointer to function transforming collected entries void load(const LoadFunc& load_func); //! \brief Returns the number of actually collected items size_t size() const { return size_; } //! \brief Returns the number of actually collected bytes size_t bytes_size() const { return bytes_size_; } //! \brief Returns whether this instance is empty (i.e. no items) bool empty() const { return size_ == 0; } //! \brief Clears contents of collector and reset void clear() { file_providers_.clear(); buffer_.clear(); size_ = 0; bytes_size_ = 0; } //! \brief Returns the hex representation of current load key (for progress tracking) std::string get_load_key() const { std::scoped_lock lock{mutex_}; return loading_key_; } private: static std::filesystem::path set_work_path(const std::optional& provided_work_path); void flush_buffer(); // Write buffer to file void set_loading_key(ByteView key) { std::scoped_lock lock{mutex_}; loading_key_ = to_hex(key, true); } bool work_path_managed_; std::filesystem::path work_path_; Buffer buffer_; /* * TL;DR; In no way two instances of collector can have * the same unique_id_ * * This id will be unique across the application * No other object will be located at the same address * If this object gets destroyed another object may get * the same address but in such case all dependant files * would be already destroyed too thus keeping file * names uniqueness. */ uintptr_t unique_id_{reinterpret_cast(this)}; std::vector> file_providers_; // Collection of file providers size_t size_{0}; // Count of total collected items size_t bytes_size_{0}; // Count of total collected bytes mutable std::mutex mutex_{}; // To sync loading_key_ std::string loading_key_{}; // Actual load key (for log purposes) }; } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/collector_settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::datastore::etl { struct CollectorSettings { std::filesystem::path work_path; size_t buffer_size{}; }; } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/file_provider.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "file_provider.hpp" #include #include #include namespace silkworm::datastore::etl { namespace fs = std::filesystem; // https://abseil.io/tips/117 FileProvider::FileProvider(std::string file_name, size_t id) : id_{id}, file_name_{std::move(file_name)} {} FileProvider::~FileProvider() { reset(); } void FileProvider::flush(Buffer& buffer) { EntryHeader head{}; // Check we have enough space to store all data auto entries{buffer.entries()}; file_size_ = buffer.size(); fs::path workdir(fs::path(file_name_).parent_path()); if (fs::space(workdir).available < file_size_) { file_size_ = 0; throw EtlError("Insufficient disk space"); } // Open file for output and flush data file_.open(file_name_, std::ios_base::out | std::ios_base::binary | std::ios_base::trunc); if (!file_.is_open()) { reset(); throw EtlError(safe_strerror(errno)); } for (const auto& entry : entries) { head.lengths[0] = static_cast(entry.key.size()); head.lengths[1] = static_cast(entry.value.size()); if (!file_.write(byte_ptr_cast(head.bytes), 8) || !file_.write(byte_ptr_cast(entry.key.data()), static_cast(entry.key.size())) || !file_.write(byte_ptr_cast(entry.value.data()), static_cast(entry.value.size()))) { auto err{errno}; reset(); throw EtlError(safe_strerror(err)); } } // Close file in output mode and reopen for input mode // This is actually not strictly needed but amends an odd behavior on Windows // which prevents correct display of file size if the handle // has not been closed file_.close(); file_.open(file_name_, std::ios_base::in | std::ios_base::binary); if (!file_.is_open()) { auto err{errno}; reset(); throw EtlError(safe_strerror(err)); } } std::optional> FileProvider::read_entry() { EntryHeader head{}; if (!file_.is_open() || !file_size_) { throw EtlError("Invalid file handle"); } if (!file_.read(byte_ptr_cast(head.bytes), 8)) { reset(); return std::nullopt; } Entry entry{Bytes(head.lengths[0], '\0'), Bytes(head.lengths[1], '\0')}; if (!file_.read(byte_ptr_cast(entry.key.data()), head.lengths[0]) || !file_.read(byte_ptr_cast(entry.value.data()), head.lengths[1])) { auto err{errno}; reset(); throw EtlError(safe_strerror(err)); } return std::make_pair(entry, id_); } void FileProvider::reset() { file_size_ = 0; if (file_.is_open()) { file_.close(); fs::remove(file_name_.c_str()); } } std::string FileProvider::get_file_name() const { return file_name_; } size_t FileProvider::get_file_size() const { return file_size_; } } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/file_provider.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "buffer.hpp" #include "util.hpp" namespace silkworm::datastore::etl { /** * Provides an abstraction to flush data to disk * and re-read flushed data sequentially */ class FileProvider { public: FileProvider(std::string file_name, size_t id); ~FileProvider(); void flush(Buffer& buffer); // Write buffer's contents to disk std::optional> read_entry(); // Read next data element from file starting from position 0 void reset(); // Remove the file when eof is met std::string get_file_name() const; size_t get_file_size() const; private: size_t id_; std::fstream file_; // Actual file stream std::string file_name_; // Actual name of file size_t file_size_{0}; // Actual size of written data }; } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/in_memory_collector.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include "collector_settings.hpp" #include "util.hpp" /* * This is a memory-only reduced version of ETL Collector, with compatible interface * It can be used to prototype code that will use the full ETL collector or to do performance comparisons * between a memory-only impl. and a file-based impl. */ namespace silkworm::datastore::etl { // Function pointer to process Load on before Load data into tables using KVLoadFunc = std::function; // An adaptor to use map as a collector storage struct MapStorage : public std::map { void reserve(size_t) {} // does nothing, std::map doesn't need to reserve space void emplace(const Bytes& key, const Bytes& value) { std::map::emplace(key, value); } void emplace(Bytes&& key, Bytes&& value) { std::map::emplace(std::move(key), std::move(value)); } void sort() {} // does nothing, std::map is always sorted }; // An adaptor to use vector as a collector storage struct VectorStorage : public std::vector> { void emplace(const Bytes& key, const Bytes& value) { emplace_back(key, value); } void emplace(Bytes&& key, Bytes&& value) { emplace_back(std::move(key), std::move(value)); } void sort() { std::sort(begin(), end()); } }; // Collects data Extracted from db template class InMemoryCollector { public: // Not copyable nor movable InMemoryCollector(const InMemoryCollector&) = delete; InMemoryCollector& operator=(const InMemoryCollector&) = delete; explicit InMemoryCollector() = default; explicit InMemoryCollector(const CollectorSettings& settings) { entries_.reserve(settings.buffer_size); } explicit InMemoryCollector(const std::filesystem::path&, size_t optimal_size) { entries_.reserve(optimal_size); } explicit InMemoryCollector(size_t optimal_size) { entries_.reserve(optimal_size); } void collect(Entry entry) { ++size_; bytes_size_ += entry.size(); entries_.emplace(std::move(entry.key), std::move(entry.value)); } void collect(Bytes key, Bytes value) { collect(Entry{std::move(key), std::move(value)}); } //! \brief Loads and optionally transforms collected entries into db //! \param [in] load_func : Pointer to function transforming collected entries void load(const KVLoadFunc& load_func) { using namespace std::chrono_literals; [[maybe_unused]] static constexpr std::chrono::seconds kLogInterval{5s}; // Updates processing key (for log purposes) every this time [[maybe_unused]] auto log_time{std::chrono::steady_clock::now()}; // To check if an update of key is needed set_loading_key({}); if (empty()) return; sort_entries(); for (const auto& [key, value] : entries_) { if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { if (SignalHandler::signalled()) { throw std::runtime_error("Operation cancelled"); } set_loading_key(key); log_time = now + kLogInterval; } load_func(key, value); } clear(); } //! \brief Returns the number of actually collected items size_t size() const { return size_; } //! \brief Returns the number of actually collected bytes size_t bytes_size() const { return bytes_size_; } //! \brief Returns whether this instance is empty (i.e. no items) bool empty() const { return size_ == 0; } //! \brief Clears contents of collector and reset void clear() { entries_.clear(); size_ = 0; bytes_size_ = 0; } //! \brief Returns the hex representation of current load key (for progress tracking) std::string get_load_key() const { std::scoped_lock l{mutex_}; return loading_key_; } private: size_t size_{0}; // Count of total collected items size_t bytes_size_{0}; // Count of total collected bytes CollectorStorage entries_; void sort_entries() { entries_.sort(); } // for progress tracking only void set_loading_key(ByteView key) { std::scoped_lock l{mutex_}; loading_key_ = to_hex(key, true); } mutable std::mutex mutex_{}; // To sync loading_key_ std::string loading_key_{}; // Actual load key (for log purposes) }; } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/util.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::datastore::etl { class EtlError : public std::runtime_error { public: using std::runtime_error::runtime_error; }; // Head of each data chunk on file union EntryHeader { uint32_t lengths[2]; uint8_t bytes[8]; }; // A data chunk on file or buffer struct Entry { Entry() = default; Entry(const Entry&) = default; Entry(Entry&&) = default; Entry(Bytes k, Bytes v) : key(std::move(k)), value(std::move(v)) {} Entry& operator=(const Entry&) = default; Entry& operator=(Entry&&) = default; // remove all the above constructors switching to clang version >= 16 Bytes key; Bytes value; size_t size() const noexcept { return key.size() + value.size(); } }; inline bool operator<(const Entry& a, const Entry& b) { auto diff{a.key.compare(b.key)}; if (diff == 0) { return a.value < b.value; } return diff < 0; } } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/etl/util_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include namespace silkworm::datastore::etl { TEST_CASE("ETL Entry comparison") { Entry a{*from_hex("1a"), *from_hex("75")}; Entry b{*from_hex("f7"), *from_hex("4056")}; CHECK(a < b); CHECK(!(b < a)); CHECK(!(a < a)); CHECK(!(b < b)); Entry c{*from_hex("ee48"), *from_hex("75")}; Entry d{*from_hex("ee48"), *from_hex("4056")}; CHECK(!(c < d)); CHECK(d < c); CHECK(!(c < c)); CHECK(!(d < d)); } } // namespace silkworm::datastore::etl ================================================ FILE: silkworm/db/datastore/history_get_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "kvdb/database.hpp" #include "kvdb/history_get_query.hpp" #include "snapshots/history_get_query.hpp" namespace silkworm::datastore { template < kvdb::EncoderConcept TKeyEncoder1, snapshots::EncoderConcept TKeyEncoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2, const snapshots::SegmentAndAccessorIndexNames& segment_names> struct HistoryGetQuery { HistoryGetQuery( kvdb::History kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : query1_{tx, kvdb_entity}, query2_{repository, query_caches} {} HistoryGetQuery( const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : HistoryGetQuery{ database.domain(segment_names.front()).history.value(), tx, repository, query_caches, } {} using Key1 = decltype(TKeyEncoder1::value); using Key2 = decltype(TKeyEncoder2::value); static_assert(std::same_as); using Key = Key1; using Value1 = decltype(TValueDecoder1::value); using Value2 = decltype(TValueDecoder2::value); static_assert(std::same_as); using Value = Value1; std::optional exec(const Key& key, Timestamp timestamp) { auto result1 = query2_.exec(key, timestamp); if (result1) { return result1; } auto result2 = query1_.exec(key, timestamp); if (result2) { return std::move(*result2); } return std::nullopt; } private: kvdb::HistoryGetQuery query1_; snapshots::HistoryGetQuery query2_; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/history_range_by_keys_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "common/pair_get.hpp" #include "common/ranges/caching_view.hpp" #include "common/ranges/merge_unique_view.hpp" #include "kvdb/database.hpp" #include "kvdb/history_range_by_keys_query.hpp" #include "kvdb/raw_codec.hpp" #include "snapshots/common/raw_codec.hpp" #include "snapshots/history_range_by_keys_query.hpp" namespace silkworm::datastore { template < kvdb::EncoderConcept TKeyEncoder1, snapshots::EncoderConcept TKeyEncoder2, kvdb::DecoderConcept TKeyDecoder1, snapshots::DecoderConcept TKeyDecoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2> struct HistoryRangeByKeysQuery { HistoryRangeByKeysQuery( datastore::EntityName entity_name, kvdb::History kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : query1_{tx, std::move(kvdb_entity)}, query2_{repository, entity_name} {} HistoryRangeByKeysQuery( datastore::EntityName entity_name, const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : HistoryRangeByKeysQuery{ entity_name, database.domain(entity_name).history.value(), tx, repository, } {} using Key1 = decltype(TKeyEncoder1::value); using Key2 = decltype(TKeyEncoder2::value); static_assert(std::same_as); using Key = Key1; using ResultItemKey1 = decltype(TKeyDecoder1::value); using ResultItemKey2 = decltype(TKeyDecoder2::value); static_assert(std::same_as); using ResultItemKey = ResultItemKey1; using ResultItemValue1 = decltype(TValueDecoder1::value); using ResultItemValue2 = decltype(TValueDecoder2::value); static_assert(std::same_as); using ResultItemValue = ResultItemValue1; using ResultItem = std::pair; static ResultItem decode_kv_pair(std::pair&& kv_pair) { if constexpr (std::same_as>) { return std::move(kv_pair); } snapshots::Decoder::Word key_word{std::move(kv_pair.first)}; TKeyDecoder2 key_decoder; key_decoder.decode_word(key_word); ResultItemKey& key = key_decoder.value; snapshots::Decoder::Word value_word{std::move(kv_pair.second)}; TValueDecoder2 value_decoder; value_decoder.decode_word(value_word); ResultItemValue& value = value_decoder.value; return ResultItem{std::move(key), std::move(value)}; } static constexpr auto kDecodeKVPairFunc = [](std::pair& kv_pair) -> ResultItem { return decode_kv_pair(std::move(kv_pair)); }; auto exec(const Key& key_start, const Key& key_end, Timestamp timestamp, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented return silkworm::views::merge_unique( query2_.exec(key_start, key_end, timestamp, ascending), query1_.exec(key_start, key_end, timestamp, ascending), silkworm::views::MergeCompareFunc{}, PairGetFirst{}, PairGetFirst{}) | std::views::transform(kDecodeKVPairFunc) | silkworm::views::caching; } private: kvdb::HistoryRangeByKeysQuery, kvdb::RawDecoder> query1_; snapshots::HistoryRangeByKeysQuery, snapshots::RawDecoder> query2_; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/history_range_in_period_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "common/pair_get.hpp" #include "common/ranges/merge_view.hpp" #include "kvdb/database.hpp" #include "kvdb/history_range_in_period_query.hpp" #include "snapshots/history_range_in_period_query.hpp" namespace silkworm::datastore { template < kvdb::DecoderConcept TKeyDecoder1, snapshots::DecoderConcept TKeyDecoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2> struct HistoryRangeInPeriodQuery { HistoryRangeInPeriodQuery( datastore::EntityName entity_name, kvdb::History kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : query1_{tx, kvdb_entity}, query2_{repository, entity_name} {} HistoryRangeInPeriodQuery( datastore::EntityName entity_name, const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : HistoryRangeInPeriodQuery{ entity_name, database.domain(entity_name).history.value(), tx, repository, } {} using Key = decltype(TKeyDecoder1::value); using Value = decltype(TValueDecoder1::value); using ResultItem = std::pair; auto exec(TimestampRange ts_range, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented return silkworm::views::merge( query1_.exec(ts_range, ascending), query2_.exec(ts_range, ascending), std::less{}, PairGetFirst{}, PairGetFirst{}); } private: kvdb::HistoryRangeInPeriodQuery query1_; snapshots::HistoryRangeInPeriodQuery query2_; }; template < kvdb::DecoderConcept TKeyDecoder1, snapshots::DecoderConcept TKeyDecoder2, kvdb::DecoderConcept TValueDecoder1, snapshots::DecoderConcept TValueDecoder2> using HistoryRangeInPeriodQueryResult = decltype(std::declval>().exec( std::declval(), std::declval())); } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/inverted_index_range_by_key_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "common/ranges/concat_view.hpp" #include "common/ranges/if_view.hpp" #include "kvdb/database.hpp" #include "kvdb/inverted_index_range_by_key_query.hpp" #include "snapshots/inverted_index_range_by_key_query.hpp" namespace silkworm::datastore { template struct InvertedIndexRangeByKeyQuery { InvertedIndexRangeByKeyQuery( datastore::EntityName entity_name, kvdb::InvertedIndex kvdb_entity, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : query1_{tx, kvdb_entity}, query2_{repository, entity_name} {} InvertedIndexRangeByKeyQuery( datastore::EntityName entity_name, const kvdb::DatabaseRef& database, kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository) : InvertedIndexRangeByKeyQuery{ entity_name, database.inverted_index(entity_name), tx, repository, } {} using Key1 = decltype(TKeyEncoder1::value); using Key2 = decltype(TKeyEncoder2::value); static_assert(std::same_as); using Key = Key1; auto exec(Key key, TimestampRange ts_range, bool ascending) { return silkworm::views::if_view( ascending, silkworm::views::concat( query2_.exec(key, ts_range, ascending), query1_.exec(key, ts_range, ascending)), silkworm::views::concat( query1_.exec(key, ts_range, ascending), query2_.exec(key, ts_range, ascending))); } private: kvdb::InvertedIndexRangeByKeyQuery query1_; snapshots::InvertedIndexRangeByKeyQuery query2_; }; template using InvertedIndexRangeByKeyQueryResult = decltype(std::declval>().exec( std::declval::Key>(), std::declval(), std::declval())); } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/kvdb/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED) find_package(roaring REQUIRED) silkworm_library( silkworm_datastore_kvdb PUBLIC absl::btree absl::function_ref roaring::roaring mdbx-static silkworm_core silkworm_infra silkworm_datastore_common silkworm_datastore_etl ) target_link_libraries(silkworm_datastore_kvdb_test PRIVATE silkworm_infra_test_util) ================================================ FILE: silkworm/db/datastore/kvdb/big_endian_codec.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "big_endian_codec.hpp" #include namespace silkworm::datastore::kvdb { Slice BigEndianU64Codec::encode() { data.resize(sizeof(uint64_t), 0); endian::store_big_u64(data.data(), value); return to_slice(data); } void BigEndianU64Codec::decode(Slice slice) { SILKWORM_ASSERT(slice.size() >= sizeof(uint64_t)); value = endian::load_big_u64(static_cast(slice.data())); } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/big_endian_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "codec.hpp" namespace silkworm::datastore::kvdb { struct BigEndianU64Codec : public Codec { uint64_t value{0}; Bytes data; BigEndianU64Codec() = default; explicit BigEndianU64Codec(uint64_t value1) : value{value1} {} ~BigEndianU64Codec() override = default; Slice encode() override; void decode(Slice slice) override; }; static_assert(EncoderConcept); static_assert(DecoderConcept); } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/bitmap.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bitmap.hpp" #include #include #include #include #include #include #include "etl_mdbx_collector.hpp" namespace silkworm::datastore::kvdb::bitmap { template Bytes upper_bound_suffix(BlockUpperBound value) { // Cannot use block_key because we need block number serialized in sizeof(BlockUpperBound) bytes Bytes shard_suffix(sizeof(BlockUpperBound), '\0'); intx::be::unsafe::store(&shard_suffix[0], value); return shard_suffix; } template RoaringMap parse_impl(const mdbx::slice& data) { return RoaringMap::readSafe(data.char_ptr(), data.length()); } template RoaringMap parse_impl(const ByteView data) { return RoaringMap::readSafe(byte_ptr_cast(&data[0]), data.size()); } template void remove_range_impl(RoaringMap& bm, uint64_t min, uint64_t max); template <> [[maybe_unused]] void remove_range_impl(roaring::Roaring& bm, uint64_t min, uint64_t max) { roaring::api::roaring_bitmap_remove_range(&bm.roaring, min, max); } template <> [[maybe_unused]] void remove_range_impl(roaring::Roaring64Map& bm, uint64_t min, uint64_t max) { for (uint64_t k = min; k < max; ++k) { bm.remove(k); } } template RoaringMap cut_left_impl(RoaringMap& bm, uint64_t size_limit) { if (bm.getSizeInBytes() <= size_limit) { RoaringMap res = bm; res.runOptimize(); bm = RoaringMap(); return res; } const auto from{bm.minimum()}; const auto min_max{bm.maximum() - bm.minimum()}; const auto cutting_point{binary_find_if(min_max, [&](size_t i) { RoaringMap current_bitmap(roaring::api::roaring_bitmap_from_range(from, from + i + 1, 1)); current_bitmap &= bm; current_bitmap.runOptimize(); return current_bitmap.getSizeInBytes() > size_limit; })}; // no +1 because binary_find_if returns the element which is just above the threshold - but we need <= RoaringMap res(roaring::api::roaring_bitmap_from_range(from, from + cutting_point, 1)); res &= bm; res.runOptimize(); remove_range_impl(bm, from, from + cutting_point); return res; } template void IndexLoader::merge_bitmaps_impl(RWTxn& txn, size_t key_size, datastore::kvdb::Collector* bitmaps_collector) { // Cannot use block_key because we need block number serialized in sizeof(BlockUpperBound) bytes Bytes last_shard_suffix{upper_bound_suffix(std::numeric_limits::max())}; const size_t optimal_shard_size{ max_value_size_for_leaf_page(*txn, key_size + /*shard upper_bound*/ sizeof(BlockUpperBound))}; PooledCursor target(txn, index_config_); datastore::kvdb::LoadFunc load_func{[&last_shard_suffix, &optimal_shard_size]( const datastore::etl::Entry& entry, RWCursorDupSort& index_cursor, MDBX_put_flags_t put_flags) -> void { auto new_bitmap{parse_impl(entry.value)}; // Bitmap being merged // Check whether we have any previous shard to merge with Bytes shard_key{ entry.key .substr(0, entry.key.size() - sizeof(uint16_t)) /* remove etl ordering suffix */ .append(last_shard_suffix)}; /* and append const suffix for last key */ if (auto index_data{index_cursor.find(to_slice(shard_key), /*throw_notfound=*/false)}; index_data.done) { // Merge previous and current bitmap new_bitmap |= parse_impl(index_data.value); index_cursor.erase(); // Delete currently found record as it'll be rewritten } // Consume bitmap splitting in shards while (!new_bitmap.isEmpty()) { auto shard{cut_left_impl(new_bitmap, optimal_shard_size)}; const bool consumed_to_last_chunk{new_bitmap.isEmpty()}; const BlockUpperBound suffix{consumed_to_last_chunk ? std::numeric_limits::max() : shard.maximum()}; intx::be::unsafe::store(&shard_key[shard_key.size() - sizeof(BlockUpperBound)], suffix); Bytes shard_bytes{to_bytes(shard)}; mdbx::slice k{to_slice(shard_key)}; mdbx::slice v{to_slice(shard_bytes)}; mdbx::error::success_or_throw(index_cursor.put(k, &v, put_flags)); } }}; bitmaps_collector->load(target, load_func, target.empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT); bitmaps_collector->clear(); } template void IndexLoader::unwind_bitmaps_impl(RWTxn& txn, BlockNum to, const std::map& keys) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; PooledCursor target(txn, index_config_); for (const auto& [key, created] : keys) { // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { if (SignalHandler::signalled()) { throw std::runtime_error("Operation cancelled"); } std::scoped_lock log_lck{log_mtx_}; current_key_ = abridge(to_hex(key, true), kAddressLength); log_time = now + 5s; } if (created) { // Key was created in the batch we're unwinding // Delete all its history cursor_erase_prefix(target, key); continue; } // Locate previous incomplete shard. There's always one if account has been touched at least once in changeset const Bytes shard_key{key + upper_bound_suffix(std::numeric_limits::max())}; auto index_data{target.find(to_slice(shard_key), false)}; while (index_data) { const auto index_data_key_view{from_slice(index_data.key)}; if (!index_data_key_view.starts_with(key)) { break; } auto db_bitmap{parse_impl(index_data.value)}; if (db_bitmap.maximum() <= to) { break; } while (!db_bitmap.isEmpty() && db_bitmap.maximum() > to) { db_bitmap.remove(db_bitmap.maximum()); } if (db_bitmap.isEmpty()) { // Delete this record and move to previous shard (if any) target.erase(); index_data = target.to_previous(false); continue; } // Replace current record with the new bitmap ensuring is marked as last shard target.erase(); Bytes shard_bytes{to_bytes(db_bitmap)}; target.insert(to_slice(shard_key), to_slice(shard_bytes)); break; } } std::scoped_lock log_lck{log_mtx_}; current_key_.clear(); } void IndexLoader::merge_bitmaps32(RWTxn& txn, size_t key_size, datastore::kvdb::Collector* bitmaps_collector) { merge_bitmaps_impl(txn, key_size, bitmaps_collector); } void IndexLoader::merge_bitmaps(RWTxn& txn, size_t key_size, datastore::kvdb::Collector* bitmaps_collector) { merge_bitmaps_impl(txn, key_size, bitmaps_collector); } void IndexLoader::unwind_bitmaps32(RWTxn& txn, BlockNum to, const std::map& keys) { unwind_bitmaps_impl(txn, to, keys); } void IndexLoader::unwind_bitmaps(RWTxn& txn, BlockNum to, const std::map& keys) { unwind_bitmaps_impl(txn, to, keys); } template void IndexLoader::prune_bitmaps_impl(RWTxn& txn, BlockNum threshold) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; PooledCursor target(txn, index_config_); auto target_data{target.to_first(/*throw_notfound=*/false)}; while (target_data) { const auto data_key_view{from_slice(target_data.key)}; // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { if (SignalHandler::signalled()) { throw std::runtime_error("Operation cancelled"); } std::scoped_lock log_lck{log_mtx_}; current_key_ = abridge(to_hex(data_key_view, true), kAddressLength); log_time = now + 5s; } // Suffix indicates the upper bound of the shard. ensure(data_key_view.size() >= sizeof(BlockUpperBound), [&]() { return "invalid key size " + std::to_string(data_key_view.size()); }); const auto suffix{intx::be::unsafe::load(&data_key_view[data_key_view.size() - sizeof(BlockUpperBound)])}; // If below pruning threshold simply delete the record if (suffix <= threshold) { target.erase(); } else { // Read current bitmap auto bitmap{parse_impl(target_data.value)}; bool shard_shrunk{false}; while (!bitmap.isEmpty() && bitmap.minimum() <= threshold) { bitmap.remove(bitmap.minimum()); shard_shrunk = true; } if (bitmap.isEmpty() || shard_shrunk) { if (!bitmap.isEmpty()) { Bytes new_shard_data{to_bytes(bitmap)}; target.update(to_slice(data_key_view), to_slice(new_shard_data)); } else { target.erase(); } } } target_data = target.to_next(/*throw_notfound=*/false); } std::scoped_lock log_lck{log_mtx_}; current_key_.clear(); } void IndexLoader::prune_bitmaps32(RWTxn& txn, BlockNum threshold) { prune_bitmaps_impl(txn, threshold); } void IndexLoader::prune_bitmaps(RWTxn& txn, BlockNum threshold) { prune_bitmaps_impl(txn, threshold); } template void flush_bitmaps_impl(absl::btree_map& bitmaps, datastore::etl::Collector* collector, uint16_t flush_count) { for (auto& [key, bitmap] : bitmaps) { Bytes etl_key(key.size() + sizeof(uint16_t), '\0'); std::memcpy(&etl_key[0], key.data(), key.size()); endian::store_big_u16(&etl_key[key.size()], flush_count); collector->collect({etl_key, to_bytes(bitmap)}); } bitmaps.clear(); } void IndexLoader::flush_bitmaps_to_etl(absl::btree_map& bitmaps, datastore::etl::Collector* collector, uint16_t flush_count) { flush_bitmaps_impl(bitmaps, collector, flush_count); } void IndexLoader::flush_bitmaps_to_etl(absl::btree_map& bitmaps, datastore::etl::Collector* collector, uint16_t flush_count) { flush_bitmaps_impl(bitmaps, collector, flush_count); } std::optional seek(const roaring::Roaring64Map& bitmap, uint64_t n) { auto it{bitmap.begin()}; if (it.move(n)) { return *it; } return std::nullopt; } roaring::Roaring cut_left(roaring::Roaring& bitmap, uint64_t size_limit) { return cut_left_impl(bitmap, size_limit); } roaring::Roaring64Map cut_left(roaring::Roaring64Map& bitmap, uint64_t size_limit) { return cut_left_impl(bitmap, size_limit); } template Bytes bitmap_to_bytes(RoaringMap& bitmap) { if (!bitmap.isEmpty()) { Bytes ret(bitmap.getSizeInBytes(), '\0'); bitmap.write(byte_ptr_cast(&ret[0])); return ret; } return {}; } Bytes to_bytes(roaring::Roaring64Map& bitmap) { return bitmap_to_bytes(bitmap); } Bytes to_bytes(roaring::Roaring& bitmap) { return bitmap_to_bytes(bitmap); } roaring::Roaring64Map parse(const mdbx::slice& data) { return parse_impl(data); } roaring::Roaring64Map parse(const ByteView data) { return parse_impl(data); } roaring::Roaring parse32(const mdbx::slice& data) { return parse_impl(data); } } // namespace silkworm::datastore::kvdb::bitmap ================================================ FILE: silkworm/db/datastore/kvdb/bitmap.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wold-style-cast" #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wsign-conversion" // ignore a warning on a GCC release build: // "accessing 9223372036854775810 or more bytes at offsets [2, 9223372036854775807] and 1 may overlap up to 9223372036854775813 bytes at offset -3" // here: https://github.com/RoaringBitmap/CRoaring/blob/v1.1.2/cpp/roaring64map.hh#L1589 #if defined(__GNUC__) && !defined(__clang__) #pragma GCC diagnostic ignored "-Wrestrict" #endif #include #pragma GCC diagnostic pop #include #include #include "mdbx.hpp" namespace silkworm::datastore::etl { class Collector; } namespace silkworm::datastore::kvdb { class Collector; } namespace silkworm::datastore::kvdb::bitmap { class IndexLoader { public: explicit IndexLoader(const MapConfig& index_config) : index_config_{index_config} {} //! \brief Merges a list of bitmaps, previously collected, into index table ensuring //! all bitmaps are properly sharded and that last bitmap is marked with an UINT64_MAX upper bound //! \param txn [in] : An MDBX transaction holder //! \param key_size [in] : The actual length of key in the list of bitmap shards (the index) //! \param bitmaps_collector [in] : A pointer to the datastore::etl::collector holding the bitmaps to be merged void merge_bitmaps(RWTxn& txn, size_t key_size, datastore::kvdb::Collector* bitmaps_collector); void merge_bitmaps32(RWTxn& txn, size_t key_size, datastore::kvdb::Collector* bitmaps_collector); //! \brief Provided a list of keys for which the unwind should be applied this removes right values from shards //! \param txn [in] : An MDBX transaction holder //! \param to [in] : The block number we should unwind index to //! \param keys [in] : The keys of index we should unwind void unwind_bitmaps(RWTxn& txn, BlockNum to, const std::map& keys); void unwind_bitmaps32(RWTxn& txn, BlockNum to, const std::map& keys); //! \brief Traverses all the index and for each bitmap removes left values <= threshold //! \param txn [in] : An MDBX transaction holder //! \param threshold [in] : The block number before which bitmaps values need to be pruned void prune_bitmaps(RWTxn& txn, BlockNum threshold); void prune_bitmaps32(RWTxn& txn, BlockNum threshold); //! \brief Returns the hex representation of currently processed key std::string get_current_key() const { std::scoped_lock lock{log_mtx_}; return current_key_; } //! \brief Flushes a collected map of Bitmaps into an datastore::etl::Collector taking care of proper keys sorting for subsequent load //! \param bitmaps [in] : A map of keys and related bitmaps //! \param collector [in] : The collector to flush to //! \param flush_count [in] //! \remark Etl collector will sort and process entries lexicographically (using both key and value) for this reason //! we add flush_count as suffix of key, so we ensure for same account we process entries in the order //! they've been collected. uint16_t maxes 65K flushes static void flush_bitmaps_to_etl(absl::btree_map& bitmaps, datastore::etl::Collector* collector, uint16_t flush_count); static void flush_bitmaps_to_etl(absl::btree_map& bitmaps, datastore::etl::Collector* collector, uint16_t flush_count); private: template void merge_bitmaps_impl(RWTxn& txn, size_t key_size, datastore::kvdb::Collector* bitmaps_collector); template void unwind_bitmaps_impl(RWTxn& txn, BlockNum to, const std::map& keys); template void prune_bitmaps_impl(RWTxn& txn, BlockNum threshold); const MapConfig& index_config_; // The bucket config holding the index of maps mutable std::mutex log_mtx_; // To get progress status std::string current_key_; // Key being processed }; // Return the first value in the bitmap that is not less than (i.e. greater or equal to) n, // or std::nullopt if no such element is found. // See Erigon SeekInBitmap64. std::optional seek(const roaring::Roaring64Map& bitmap, uint64_t n); // Remove from a bitmap and return its biggest left part not exceeding a given size roaring::Roaring64Map cut_left(roaring::Roaring64Map& bitmap, uint64_t size_limit); // Remove from a bitmap and return its biggest left part not exceeding a given size roaring::Roaring cut_left(roaring::Roaring& bitmap, uint64_t size_limit); //! \brief Return bytes of Roaring64Map data Bytes to_bytes(roaring::Roaring64Map& bitmap); //! \brief Return bytes of Roaring data Bytes to_bytes(roaring::Roaring& bitmap); //! \brief Parse 64-bit roaring bitmap from MDBX slice roaring::Roaring64Map parse(const mdbx::slice& data); //! \brief Parse 64-bit roaring bitmap from ByteView roaring::Roaring64Map parse(ByteView data); //! \brief Parse 32-bit roaring bitmap from MDBX slice roaring::Roaring parse32(const mdbx::slice& data); } // namespace silkworm::datastore::kvdb::bitmap ================================================ FILE: silkworm/db/datastore/kvdb/codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "mdbx.hpp" namespace silkworm::datastore::kvdb { struct Encoder { virtual ~Encoder() = default; virtual Slice encode() = 0; }; template concept EncoderConcept = std::derived_from && requires(TEncoder encoder) { encoder.value; }; struct Decoder { virtual ~Decoder() = default; virtual void decode(Slice slice) = 0; }; template concept DecoderConcept = std::derived_from && requires(TDecoder decoder) { decoder.value; }; struct Codec : public Encoder, public Decoder { ~Codec() override = default; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/cursor_iterator.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "cursor_iterator.hpp" #include "raw_codec.hpp" namespace silkworm::datastore::kvdb { void CursorIterator::decode(const CursorResult& result) { if (result) { if (decoders_.first) { decoders_.first->decode(result.key); } if (decoders_.second) { decoders_.second->decode(result.value); } } else { decoders_.first.reset(); decoders_.second.reset(); } } bool operator==(const CursorIterator& lhs, const CursorIterator& rhs) { return (lhs.decoders_ == rhs.decoders_) && ((!lhs.decoders_.first && !lhs.decoders_.second) || (lhs.cursor_ == rhs.cursor_)); } static_assert(std::input_iterator); static_assert(std::input_iterator); static_assert(std::input_iterator, RawDecoder>>); static_assert(std::input_iterator>>); static_assert(std::input_iterator>>); } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/cursor_iterator.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "codec.hpp" #include "mdbx.hpp" namespace silkworm::datastore::kvdb { class CursorMoveIterator { public: using value_type = std::shared_ptr; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; CursorMoveIterator() = default; CursorMoveIterator( std::shared_ptr cursor, MoveOperation move_op) : cursor_{std::move(cursor)}, move_op_{move_op} {} const value_type& operator*() const { return cursor_; } const value_type* operator->() const { return &cursor_; } CursorMoveIterator operator++(int) { return std::exchange(*this, ++CursorMoveIterator{*this}); } CursorMoveIterator& operator++() { if (((move_op_ == MoveOperation::get_current) && cursor_->eof()) || !cursor_->move(move_op_, false)) { cursor_.reset(); } return *this; } friend bool operator!=(const CursorMoveIterator& it, const std::default_sentinel_t&) { return !!it.cursor_; } friend bool operator==(const CursorMoveIterator& it, const std::default_sentinel_t&) { return !it.cursor_; } friend bool operator!=(const std::default_sentinel_t&, const CursorMoveIterator& it) { return !!it.cursor_; } friend bool operator==(const std::default_sentinel_t&, const CursorMoveIterator& it) { return !it.cursor_; } private: std::shared_ptr cursor_; MoveOperation move_op_{MoveOperation::next}; }; class CursorIterator { public: using value_type = std::pair, std::shared_ptr>; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; CursorIterator() = default; CursorIterator( std::shared_ptr cursor, MoveOperation move_op, std::shared_ptr key_decoder, std::shared_ptr value_decoder) : cursor_{std::move(cursor)}, move_op_{move_op}, decoders_{std::move(key_decoder), std::move(value_decoder)} { decode(cursor_->current(false)); } value_type operator*() const { return decoders_; } const value_type* operator->() const { return &decoders_; } CursorIterator operator++(int) { return std::exchange(*this, ++CursorIterator{*this}); } CursorIterator& operator++() { decode(cursor_->move(move_op_, false)); return *this; } friend bool operator!=(const CursorIterator& lhs, const CursorIterator& rhs) = default; friend bool operator==(const CursorIterator& lhs, const CursorIterator& rhs); private: void decode(const CursorResult& result); std::shared_ptr cursor_; MoveOperation move_op_{MoveOperation::next}; value_type decoders_; }; template class CursorKVIterator { public: using value_type_owned = std::pair; using value_type = std::pair; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; CursorKVIterator() = default; explicit CursorKVIterator(CursorIterator it) : it_{std::move(it)} {} static CursorKVIterator make(std::unique_ptr cursor, MoveOperation move_op) { return CursorKVIterator{CursorIterator{std::move(cursor), move_op, std::make_shared(), std::make_shared()}}; } static CursorKVIterator make( std::unique_ptr cursor, MoveOperation move_op, std::function key_decoder_factory, std::function value_decoder_factory) { return CursorKVIterator{CursorIterator{std::move(cursor), move_op, std::make_shared(key_decoder_factory()), std::make_shared(value_decoder_factory())}}; } value_type operator*() const { return value(); } value_type_owned move_value() const { value_type value = this->value(); return {std::move(value.first), std::move(value.second)}; } CursorKVIterator operator++(int) { return std::exchange(*this, ++CursorKVIterator{*this}); } CursorKVIterator& operator++() { ++it_; return *this; } friend bool operator!=(const CursorKVIterator& lhs, const CursorKVIterator& rhs) = default; friend bool operator==(const CursorKVIterator& lhs, const CursorKVIterator& rhs) = default; private: value_type value() const { Decoder& base_key_decoder = *(it_->first); Decoder& base_value_decoder = *(it_->second); // dynamic_cast is safe if TKeyDecoder was used when creating the CursorIterator auto& key_decoder = dynamic_cast(base_key_decoder); // dynamic_cast is safe if TValueDecoder was used when creating the CursorIterator auto& key_value_decoder = dynamic_cast(base_value_decoder); return {key_decoder.value, key_value_decoder.value}; } CursorIterator it_; }; template class CursorKeysIterator { public: using value_type = decltype(TKeyDecoder::value); using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; CursorKeysIterator() = default; explicit CursorKeysIterator(CursorIterator it) : it_{std::move(it)} {} static CursorKeysIterator make(std::unique_ptr cursor, MoveOperation move_op) { return CursorKeysIterator{CursorIterator{std::move(cursor), move_op, std::make_shared(), {}}}; } static CursorKeysIterator make( std::unique_ptr cursor, MoveOperation move_op, std::function key_decoder_factory) { return CursorKeysIterator{CursorIterator{std::move(cursor), move_op, std::make_shared(key_decoder_factory()), {}}}; } reference operator*() const { return value(); } pointer operator->() const { return &value(); } CursorKeysIterator operator++(int) { return std::exchange(*this, ++CursorKeysIterator{*this}); } CursorKeysIterator& operator++() { ++it_; return *this; } friend bool operator!=(const CursorKeysIterator& lhs, const CursorKeysIterator& rhs) = default; friend bool operator==(const CursorKeysIterator& lhs, const CursorKeysIterator& rhs) = default; private: value_type& value() const { Decoder& base_key_decoder = *(it_->first); // dynamic_cast is safe if TKeyDecoder was used when creating the CursorIterator auto& key_decoder = dynamic_cast(base_key_decoder); return key_decoder.value; } CursorIterator it_; }; template class CursorValuesIterator { public: using value_type = decltype(TValueDecoder::value); using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; CursorValuesIterator() = default; explicit CursorValuesIterator(CursorIterator it) : it_{std::move(it)} {} static CursorValuesIterator make(std::unique_ptr cursor, MoveOperation move_op) { return CursorValuesIterator{CursorIterator{std::move(cursor), move_op, {}, std::make_shared()}}; } static CursorValuesIterator make( std::unique_ptr cursor, MoveOperation move_op, std::function value_decoder_factory) { return CursorValuesIterator{CursorIterator{std::move(cursor), move_op, {}, std::make_shared(value_decoder_factory())}}; } reference operator*() const { return value(); } pointer operator->() const { return &value(); } CursorValuesIterator operator++(int) { return std::exchange(*this, ++CursorValuesIterator{*this}); } CursorValuesIterator& operator++() { ++it_; return *this; } friend bool operator!=(const CursorValuesIterator& lhs, const CursorValuesIterator& rhs) = default; friend bool operator==(const CursorValuesIterator& lhs, const CursorValuesIterator& rhs) = default; private: value_type& value() const { Decoder& base_value_decoder = *(it_->second); // dynamic_cast is safe if TValueDecoder was used when creating the CursorIterator auto& value_decoder = dynamic_cast(base_value_decoder); return value_decoder.value; } CursorIterator it_; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/database.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "database.hpp" namespace silkworm::datastore::kvdb { static MapConfig make_table_config(const Schema::TableDef& table) { return MapConfig{ table.name().c_str(), mdbx::key_mode::usual, table.is_multi_value() ? mdbx::value_mode::multi : mdbx::value_mode::single, }; } static EntityMap make_table_configs( const Schema::EntityDef& entity) { EntityMap results; for (auto& [name, def] : entity.tables()) { results.emplace(name, make_table_config(def)); } return results; } DatabaseRef::EntitiesMap make_entities( const Schema::DatabaseDef& schema) { DatabaseRef::EntitiesMap results; for (auto& [name, def] : schema.entities()) { results.emplace(name, make_table_configs(*def)); } return results; } void Database::create_tables() { RWTxnManaged tx = access_rw().start_rw_tx(); for (auto& entity : entities_) { for (auto& entry : entity.second) { MapConfig& map_config = entry.second; tx->create_map(map_config.name_str(), map_config.key_mode, map_config.value_mode); } } tx.commit_and_stop(); } Domain DatabaseRef::domain(datastore::EntityName name) const { auto& entity = entities_.at(name); auto& domain_def = dynamic_cast(*schema_.entities().at(name)); Domain domain{ entity.at(Schema::kDomainValuesName), domain_def.has_large_values(), std::nullopt, }; if (entity.contains(Schema::kHistoryValuesName)) { domain.history.emplace(History{ entity.at(Schema::kHistoryValuesName), domain_def.has_large_values(), inverted_index(name), }); } return domain; } InvertedIndex DatabaseRef::inverted_index(datastore::EntityName name) const { auto& entity = entities_.at(name); return InvertedIndex{ entity.at(Schema::kInvIdxKeysName), entity.at(Schema::kInvIdxIndexName), }; } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/database.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "domain.hpp" #include "inverted_index.hpp" #include "mdbx.hpp" #include "schema.hpp" namespace silkworm::datastore::kvdb { class Database; class DatabaseUnmanaged; class DatabaseRef { public: using EntitiesMap = EntityMap>; ROAccess access_ro() const { return ROAccess{env_}; } RWAccess access_rw() const { return RWAccess{env_}; } Domain domain(datastore::EntityName name) const; InvertedIndex inverted_index(datastore::EntityName name) const; private: // this is private, use Database.ref() or DatabaseUnmanaged.ref() to create DatabaseRef( mdbx::env env, const Schema::DatabaseDef& schema, const EntitiesMap& entities) : env_{std::move(env)}, schema_{schema}, entities_{entities} {} friend class Database; friend class DatabaseUnmanaged; mdbx::env env_; const Schema::DatabaseDef& schema_; const EntitiesMap& entities_; }; DatabaseRef::EntitiesMap make_entities(const Schema::DatabaseDef& schema); class Database { public: Database( mdbx::env_managed env, Schema::DatabaseDef schema) : env_{std::move(env)}, schema_{std::move(schema)}, entities_{make_entities(schema_)} {} ROAccess access_ro() const { return ref().access_ro(); } RWAccess access_rw() const { return ref().access_rw(); } Domain domain(datastore::EntityName name) const { return ref().domain(name); } InvertedIndex inverted_index(datastore::EntityName name) const { return ref().inverted_index(name); } DatabaseRef ref() const { return {env_, schema_, entities_}; } // NOLINT(cppcoreguidelines-slicing) void create_tables(); private: mdbx::env_managed env_; Schema::DatabaseDef schema_; EntityMap> entities_; }; class DatabaseUnmanaged { public: DatabaseUnmanaged( EnvUnmanaged env, Schema::DatabaseDef schema) : env_{std::move(env)}, schema_{std::move(schema)}, entities_{make_entities(schema_)} {} ROAccess access_ro() const { return ref().access_ro(); } RWAccess access_rw() const { return ref().access_rw(); } Domain domain(datastore::EntityName name) const { return ref().domain(name); } InvertedIndex inverted_index(datastore::EntityName name) const { return ref().inverted_index(name); } DatabaseRef ref() const { return {env_, schema_, entities_}; } // NOLINT(cppcoreguidelines-slicing) private: EnvUnmanaged env_; Schema::DatabaseDef schema_; EntityMap> entities_; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "history.hpp" namespace silkworm::datastore::kvdb { struct Domain { const MapConfig& values_table; bool has_large_values; std::optional history; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_codecs.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/step.hpp" #include "big_endian_codec.hpp" #include "kvts_codec.hpp" namespace silkworm::datastore::kvdb { struct InvertedStepCodec : public Codec { Step value{0}; BigEndianU64Codec codec; static constexpr size_t kEncodedSize = sizeof(decltype(BigEndianU64Codec::value)); ~InvertedStepCodec() override = default; Slice encode() override { codec.value = ~value.value; return codec.encode(); } void decode(Slice slice) override { codec.decode(slice); value = Step(~codec.value); } }; static_assert(EncoderConcept); static_assert(DecoderConcept); template using DomainKeyEncoder = KVTSKeyEncoder; template using DomainValueEncoder = KVTSValueEncoder; template using DomainKeyDecoder = KVTSKeyDecoder; template using DomainValueDecoder = KVTSValueDecoder; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_delete_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "domain_put_query.hpp" namespace silkworm::datastore::kvdb { template struct DomainDeleteQuery { RWTxn& tx; Domain entity; using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueEncoder::value); void exec( const Key& key, Timestamp timestamp, const std::optional& prev_value, Step current_step) { if (prev_value) { TValueEncoder prev_value_encoder; prev_value_encoder.value = std::move(*prev_value); Slice prev_value_slice = prev_value_encoder.encode(); RawDecoder prev_value_slice_decoder; prev_value_slice_decoder.decode(prev_value_slice); ByteView prev_value_data = prev_value_slice_decoder.value; DomainPutQuery> query{tx, entity}; query.exec(key, ByteView{}, timestamp, prev_value_data, current_step); } } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_get_latest_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../common/step.hpp" #include "domain.hpp" #include "domain_codecs.hpp" #include "mdbx.hpp" namespace silkworm::datastore::kvdb { template struct DomainGetLatestQuery { ROTxn& tx; Domain entity; using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueDecoder::value); struct Result { Value value; Step step{0}; }; std::optional exec(const Key& key) { DomainKeyEncoder key_encoder{/* has_large_values = */ false}; key_encoder.value.key.value = key; key_encoder.value.timestamp.value = Step{std::numeric_limits::max()}; // we need all 1s here Slice key_slice = key_encoder.encode(); auto db_cursor = tx.ro_cursor(entity.values_table); auto result = entity.has_large_values ? db_cursor->lower_bound(key_slice, false) : db_cursor->find(key_slice, false); if (!result) { return std::nullopt; } DomainKeyDecoder> key_decoder{entity.has_large_values}; key_decoder.decode(result.key); if (key_decoder.value.key.value != from_slice(key_slice)) { return std::nullopt; } DomainValueDecoder> empty_value_decoder{entity.has_large_values}; empty_value_decoder.decode(result.value); if (empty_value_decoder.value.value.value.empty()) { return std::nullopt; } DomainValueDecoder value_decoder{entity.has_large_values}; value_decoder.decode(result.value); Step step = Step(key_decoder.value.timestamp.value.value | value_decoder.value.timestamp.value.value); return Result{std::move(value_decoder.value.value.value), step}; } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_get_latest_query_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "domain_get_latest_query.hpp" #include #include #include "big_endian_codec.hpp" #include "domain_put_latest_query.hpp" #include "query_test.hpp" namespace silkworm::datastore::kvdb { struct DomainPutEntry { uint64_t key{0}; uint64_t value{0}; Step step{0}; }; using DomainGetQuery = DomainGetLatestQuery; using Result = DomainGetQuery::Result; bool operator==(const Result& lhs, const Result& rhs) { return (lhs.value == rhs.value) && (lhs.step == rhs.step); }; TEMPLATE_TEST_CASE("DomainGetLatestQuery", "", DomainDefault, DomainWithLargeValues) { QueryTest test = QueryTest::make(); auto find_in = [&test](const std::vector& data, uint64_t key) -> std::optional { return test.find_in, DomainGetQuery>(data, key); }; auto count = [&test]() -> uint64_t { Domain entity = test.domain(); RWAccess db_access = test.access_rw(); ROTxnManaged tx = db_access.start_ro_tx(); PooledCursor cursor{tx, entity.values_table}; return cursor.get_map_stat().ms_entries; }; SECTION("single entry - correct key") { CHECK(find_in({DomainPutEntry{1, 2, Step{3}}}, 1) == Result{2, Step{3}}); CHECK(count() == 1); } SECTION("single entry - wrong key") { CHECK_FALSE(find_in({DomainPutEntry{1, 2, Step{3}}}, 4).has_value()); CHECK(count() == 1); } SECTION("different steps - different keys") { CHECK(find_in({DomainPutEntry{1, 11, Step{101}}, DomainPutEntry{2, 22, Step{102}}, DomainPutEntry{3, 33, Step{103}}}, 2) == Result{22, Step{102}}); CHECK(count() == 3); } SECTION("ascending steps - same key") { CHECK(find_in({DomainPutEntry{1, 11, Step{101}}, DomainPutEntry{1, 22, Step{102}}, DomainPutEntry{1, 33, Step{103}}}, 1) == Result{33, Step{103}}); CHECK(count() == 3); } SECTION("descending steps - same key") { CHECK(find_in({DomainPutEntry{1, 33, Step{103}}, DomainPutEntry{1, 22, Step{102}}, DomainPutEntry{1, 11, Step{101}}}, 1) == Result{33, Step{103}}); CHECK(count() == 3); } SECTION("same step - different key") { CHECK(find_in({DomainPutEntry{1, 11, Step{100}}, DomainPutEntry{2, 22, Step{100}}, DomainPutEntry{3, 33, Step{100}}}, 2) == Result{22, Step{100}}); CHECK(count() == 3); } SECTION("same step - same key") { CHECK(find_in({DomainPutEntry{1, 11, Step{100}}, DomainPutEntry{1, 22, Step{100}}, DomainPutEntry{1, 33, Step{100}}}, 1) == Result{33, Step{100}}); CHECK(count() == 1); } SECTION("ascending and same steps - same key") { CHECK(find_in({DomainPutEntry{1, 11, Step{101}}, DomainPutEntry{1, 22, Step{102}}, DomainPutEntry{1, 33, Step{103}}, DomainPutEntry{1, 331, Step{103}}}, 1) == Result{331, Step{103}}); CHECK(count() == 3); } SECTION("descending and same steps - same key") { CHECK(find_in({DomainPutEntry{1, 33, Step{103}}, DomainPutEntry{1, 331, Step{103}}, DomainPutEntry{1, 22, Step{102}}, DomainPutEntry{1, 11, Step{101}}}, 1) == Result{331, Step{103}}); CHECK(count() == 3); } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_put_latest_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/step.hpp" #include "domain.hpp" #include "domain_codecs.hpp" #include "mdbx.hpp" namespace silkworm::datastore::kvdb { template struct DomainPutLatestQuery { RWTxn& tx; Domain entity; using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueEncoder::value); void exec(const Key& key, const Value& value, Step step) { DomainKeyEncoder key_encoder{entity.has_large_values}; key_encoder.value.key.value = key; key_encoder.value.timestamp.value = step; Slice key_data = key_encoder.encode(); DomainValueEncoder value_encoder{entity.has_large_values}; value_encoder.value.value.value = value; value_encoder.value.timestamp.value = step; Slice value_data = value_encoder.encode(); if (entity.values_table.value_mode == mdbx::value_mode::multi) { auto cursor = tx.rw_cursor_dup_sort(entity.values_table); // we need to erase an existing value with the same step if any // to find it, first encode a value with the same step and empty data DomainValueEncoder> same_step_value_encoder{entity.has_large_values}; same_step_value_encoder.value.timestamp.value = step; Slice same_step_value = same_step_value_encoder.encode(); CursorResult result = cursor->lower_bound_multivalue(key_data, same_step_value, false); if (result) { // the found value will have the same key, but the step part can be different, // let's decode it ignoring the data part DomainValueDecoder> existing_value_decoder{entity.has_large_values}; existing_value_decoder.decode(result.value); Step existing_value_step = existing_value_decoder.value.timestamp.value; if (existing_value_step == step) { cursor->erase(); } } cursor->upsert(key_data, value_data); } else { tx.rw_cursor(entity.values_table)->upsert(key_data, value_data); } } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_put_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "domain_put_latest_query.hpp" #include "history_delete_query.hpp" #include "history_put_query.hpp" namespace silkworm::datastore::kvdb { template struct DomainPutQuery { RWTxn& tx; Domain entity; using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueEncoder::value); void exec( const Key& key, const Value& value, Timestamp timestamp, const std::optional& prev_value, Step current_step) { DomainPutLatestQuery value_query{tx, entity}; value_query.exec(key, value, current_step); if (entity.history) { if (prev_value) { HistoryPutQuery history_query{tx, *entity.history}; history_query.exec(key, *prev_value, timestamp); } else { HistoryDeleteQuery history_query{tx, *entity.history}; history_query.exec(key, timestamp); } } } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "domain_delete_query.hpp" #include "domain_get_latest_query.hpp" #include "domain_put_latest_query.hpp" #include "domain_put_query.hpp" #include "domain_range_latest_query.hpp" ================================================ FILE: silkworm/db/datastore/kvdb/domain_range_latest_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../common/pair_get.hpp" #include "../common/ranges/caching_view.hpp" #include "../common/ranges/lazy_view.hpp" #include "../common/ranges/unique_view.hpp" #include "cursor_iterator.hpp" #include "domain.hpp" #include "domain_codecs.hpp" #include "mdbx.hpp" #include "raw_codec.hpp" namespace silkworm::datastore::kvdb { template < EncoderConcept TKeyEncoder, DecoderConcept TKeyDecoder, DecoderConcept TValueDecoder> struct DomainRangeLatestQuery { ROTxn& tx; Domain entity; using Key = decltype(TKeyEncoder::value); using ResultItemKey = decltype(TKeyDecoder::value); using ResultItemValue = decltype(TValueDecoder::value); using ResultItem = std::pair; static ResultItem decode_kv_pair(const std::pair& kv_pair) { TKeyDecoder key_decoder; key_decoder.decode(kv_pair.first); ResultItemKey& key = key_decoder.value; TValueDecoder value_decoder; value_decoder.decode(kv_pair.second); ResultItemValue& value = value_decoder.value; return ResultItem{std::move(key), std::move(value)}; } static constexpr auto kDecodeKVPairFunc = [](const std::pair& kv_pair) -> ResultItem { return decode_kv_pair(kv_pair); }; auto exec_with_eager_begin(Bytes key_start, Bytes key_end, bool ascending) { // NOLINT(*-unnecessary-value-param) SILKWORM_ASSERT(ascending); // descending is not implemented using CursorKVIteratorRaw = CursorKVIterator>, DomainValueDecoder>>; CursorKVIteratorRaw begin_it; std::unique_ptr cursor; if (entity.values_table.value_mode == mdbx::value_mode::multi) { cursor = tx.ro_cursor_dup_sort(entity.values_table); } else { cursor = tx.ro_cursor(entity.values_table); } auto result = cursor->lower_bound(to_slice(key_start), false); if (result) { begin_it = CursorKVIteratorRaw::make( std::move(cursor), (entity.values_table.value_mode == mdbx::value_mode::multi) ? MoveOperation::multi_nextkey_firstvalue : MoveOperation::next, [has_large_values = entity.has_large_values]() { return DomainKeyDecoder>{has_large_values}; }, [has_large_values = entity.has_large_values]() { return DomainValueDecoder>{has_large_values}; }); } auto before_key_end_predicate = [key_end = std::move(key_end)](const std::pair& kv_pair) { return key_end.empty() || kv_pair.first < key_end; }; return std::ranges::subrange{std::move(begin_it), CursorKVIteratorRaw{}} | std::views::transform([](auto&& kvts_pair) { return std::pair{kvts_pair.first.key.value, kvts_pair.second.value.value}; }) | silkworm::views::unique> | // filter out duplicate keys when has_large_values std::views::take_while(std::move(before_key_end_predicate)) | std::views::transform(kDecodeKVPairFunc) | silkworm::views::caching; } auto exec(const Key& key_start, const Key& key_end, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented TKeyEncoder key_start_encoder; key_start_encoder.value = key_start; Slice key_start_slice = key_start_encoder.encode(); Bytes key_start_data = Bytes{from_slice(key_start_slice)}; TKeyEncoder key_end_encoder; key_end_encoder.value = key_end; Slice key_end_slice = key_end_encoder.encode(); Bytes key_end_data = Bytes{from_slice(key_end_slice)}; auto exec_func = [query = *this, key_start = std::move(key_start_data), key_end = std::move(key_end_data), ascending]() mutable { return query.exec_with_eager_begin(std::move(key_start), std::move(key_end), ascending); }; return silkworm::ranges::lazy(std::move(exec_func)); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/domain_range_latest_query_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "domain_range_latest_query.hpp" #include #include #include #include "big_endian_codec.hpp" #include "domain_put_latest_query.hpp" #include "query_test.hpp" namespace silkworm::datastore::kvdb { struct DomainPutEntry { uint64_t key{0}; uint64_t value{0}; Step step{0}; }; using DomainRangeQuery = DomainRangeLatestQuery; using Result = std::vector>; TEMPLATE_TEST_CASE("DomainRangeLatestQuery", "", DomainDefault, DomainWithLargeValues) { QueryTest test = QueryTest::make(); auto find_in = [&test](const std::vector& data, uint64_t key_start, uint64_t key_end) -> Result { return test.find_in, DomainRangeQuery>(data, key_start, key_end, /* ascending = */ true); }; SECTION("single entry - correct key") { CHECK(find_in({DomainPutEntry{1, 2, Step{3}}}, 1, 2) == Result{{1, 2}}); } SECTION("single entry - wrong key") { CHECK(find_in({DomainPutEntry{1, 2, Step{3}}}, 4, 5).empty()); } SECTION("same step - different keys") { CHECK(find_in({DomainPutEntry{1, 11, Step{100}}, DomainPutEntry{2, 22, Step{100}}, DomainPutEntry{3, 33, Step{100}}}, 2, 3) == Result{{2, 22}}); } SECTION("different steps - different keys") { CHECK(find_in({DomainPutEntry{1, 11, Step{101}}, DomainPutEntry{2, 22, Step{102}}, DomainPutEntry{3, 33, Step{103}}}, 2, 3) == Result{{2, 22}}); } SECTION("different steps - same key") { CHECK(find_in({DomainPutEntry{1, 11, Step{101}}, DomainPutEntry{1, 22, Step{102}}, DomainPutEntry{1, 33, Step{103}}}, 1, 2) == Result{{1, 33}}); } SECTION("find [1..3] in [2..5]") { CHECK(find_in({DomainPutEntry{2, 22, Step{100}}, DomainPutEntry{3, 33, Step{100}}, DomainPutEntry{4, 44, Step{100}}, DomainPutEntry{5, 55, Step{100}}}, 1, 4) == Result{{2, 22}, {3, 33}}); } SECTION("find [4..6] in [2..5]") { CHECK(find_in({DomainPutEntry{2, 22, Step{100}}, DomainPutEntry{3, 33, Step{100}}, DomainPutEntry{4, 44, Step{100}}, DomainPutEntry{5, 55, Step{100}}}, 4, 7) == Result{{4, 44}, {5, 55}}); } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/etl_mdbx_collector.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "mdbx.hpp" namespace silkworm::datastore::kvdb { // Function pointer to process Load on before Load data into tables using LoadFunc = std::function; class Collector : public datastore::etl::Collector { public: using datastore::etl::Collector::Collector; //! \brief Loads and optionally transforms collected entries into db //! \param [in] target : a cursor opened on target table and owned by caller (can be empty) //! \param [in] load_func : Pointer to function transforming collected entries. If NULL no transform is executed //! \param [in] flags : Optional put flags for append or upsert (default) items void load( RWCursorDupSort& target, const LoadFunc& load_func = {}, MDBX_put_flags_t flags = MDBX_put_flags_t::MDBX_UPSERT) { datastore::etl::LoadFunc base_load_func = [&](const datastore::etl::Entry& etl_entry) { if (load_func) { load_func(etl_entry, target, flags); } else { mdbx::slice k = to_slice(etl_entry.key); if (etl_entry.value.empty()) { target.erase(k); } else { mdbx::slice v = to_slice(etl_entry.value); mdbx::error::success_or_throw(target.put(k, &v, flags)); } } }; this->datastore::etl::Collector::load(base_load_func); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "inverted_index.hpp" namespace silkworm::datastore::kvdb { struct History { const MapConfig& values_table; bool has_large_values; InvertedIndex inverted_index; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_codecs.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/timestamp.hpp" #include "kvts_codec.hpp" #include "timestamp_codec.hpp" namespace silkworm::datastore::kvdb { template using HistoryKeyEncoder = KVTSKeyEncoder; template using HistoryValueEncoder = KVTSValueEncoder; template using HistoryKeyDecoder = KVTSKeyDecoder; template using HistoryValueDecoder = KVTSValueDecoder; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_delete_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "history_put_query.hpp" namespace silkworm::datastore::kvdb { template struct HistoryDeleteQuery { RWTxn& tx; History entity; using Key = decltype(TKeyEncoder::value); void exec(const Key& key, Timestamp timestamp) { HistoryPutQuery> query{tx, entity}; query.exec(key, ByteView{}, timestamp); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_get_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../common/timestamp.hpp" #include "history.hpp" #include "history_codecs.hpp" #include "mdbx.hpp" namespace silkworm::datastore::kvdb { template struct HistoryGetQuery { ROTxn& tx; History entity; using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueDecoder::value); enum class [[nodiscard]] NoValueReason { kNotFound, kDeleted, }; tl::expected exec(const Key& key, Timestamp timestamp) { HistoryKeyEncoder key_encoder{entity.has_large_values}; key_encoder.value.key.value = key; key_encoder.value.timestamp.value = timestamp; Slice key_slice = key_encoder.encode(); CursorResult result{Slice{}, Slice{}, /* done = */ false}; if (entity.has_large_values) { result = tx.ro_cursor(entity.values_table)->lower_bound(key_slice, false); if (result) { HistoryKeyDecoder> key_decoder{entity.has_large_values}; key_decoder.decode(key_slice); ByteView key_data = key_decoder.value.key.value; key_decoder.decode(result.key); ByteView key_data_found = key_decoder.value.key.value; if (key_data_found != key_data) { result = CursorResult{Slice{}, Slice{}, /* done = */ false}; } } } else { HistoryValueEncoder> value_encoder{entity.has_large_values}; value_encoder.value.timestamp.value = timestamp; value_encoder.value.value.value = ByteView{}; Slice value_slice = value_encoder.encode(); result = tx.ro_cursor_dup_sort(entity.values_table)->lower_bound_multivalue(key_slice, value_slice, false); } if (!result) return tl::unexpected{NoValueReason::kNotFound}; HistoryValueDecoder> empty_value_decoder{entity.has_large_values}; empty_value_decoder.decode(result.value); if (empty_value_decoder.value.value.value.empty()) return tl::unexpected{NoValueReason::kDeleted}; HistoryValueDecoder value_decoder{entity.has_large_values}; value_decoder.decode(result.value); return std::move(value_decoder.value.value.value); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_get_query_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "history_get_query.hpp" #include #include #include "big_endian_codec.hpp" #include "history_put_query.hpp" #include "query_test.hpp" namespace silkworm::datastore::kvdb { struct HistoryPutEntry { uint64_t key{0}; uint64_t value{0}; Timestamp timestamp{0}; }; using Entry = HistoryPutEntry; using Result = tl::expected::NoValueReason>; TEMPLATE_TEST_CASE("HistoryGetQuery", "", DomainDefault, DomainWithLargeValues) { QueryTest test = QueryTest::make(); auto find_in = [&test](const std::vector& data, uint64_t key, Timestamp timestamp) -> Result { return test.find_in, HistoryGetQuery>(data, key, timestamp); }; SECTION("single entry - correct key") { CHECK(find_in({Entry{1, 2, 3}}, 1, 3) == 2); } SECTION("single entry - wrong key") { CHECK_FALSE(find_in({Entry{1, 2, 3}}, 4, 3).has_value()); } SECTION("different timestamps - different keys") { CHECK(find_in({Entry{1, 11, 101}, Entry{2, 22, 102}, Entry{3, 33, 103}}, 2, 102) == 22); } SECTION("same timestamp - different keys") { CHECK(find_in({Entry{1, 11, 100}, Entry{2, 22, 100}, Entry{3, 33, 100}}, 2, 100) == 22); } SECTION("ascending timestamps - same key - before first") { CHECK(find_in({Entry{1, 11, 101}, Entry{1, 33, 103}}, 1, 100) == 11); } SECTION("ascending timestamps - same key - first") { CHECK(find_in({Entry{1, 11, 101}, Entry{1, 33, 103}}, 1, 101) == 11); } SECTION("ascending timestamps - same key - gap") { CHECK(find_in({Entry{1, 11, 101}, Entry{1, 33, 103}}, 1, 102) == 33); } SECTION("ascending timestamps - same key - last") { CHECK(find_in({Entry{1, 11, 101}, Entry{1, 33, 103}}, 1, 103) == 33); } SECTION("ascending timestamps - same key - after last") { CHECK_FALSE(find_in({Entry{1, 11, 101}, Entry{1, 33, 103}}, 1, 104).has_value()); } SECTION("descending timestamps - same key - before first") { CHECK(find_in({Entry{1, 33, 103}, Entry{1, 11, 101}}, 1, 100) == 11); } SECTION("descending timestamps - same key - first") { CHECK(find_in({Entry{1, 33, 103}, Entry{1, 11, 101}}, 1, 101) == 11); } SECTION("descending timestamps - same key - gap") { CHECK(find_in({Entry{1, 33, 103}, Entry{1, 11, 101}}, 1, 102) == 33); } SECTION("descending timestamps - same key - last") { CHECK(find_in({Entry{1, 33, 103}, Entry{1, 11, 101}}, 1, 103) == 33); } SECTION("descending timestamps - same key - after last") { CHECK_FALSE(find_in({Entry{1, 33, 103}, Entry{1, 11, 101}}, 1, 104).has_value()); } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_put_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/timestamp.hpp" #include "history.hpp" #include "history_codecs.hpp" #include "inverted_index_put_query.hpp" #include "mdbx.hpp" namespace silkworm::datastore::kvdb { template struct HistoryPutQuery { RWTxn& tx; History entity; using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueEncoder::value); void exec(const Key& key, const Value& value, Timestamp timestamp) { HistoryKeyEncoder key_encoder{entity.has_large_values}; key_encoder.value.key.value = key; key_encoder.value.timestamp.value = timestamp; Slice key_data = key_encoder.encode(); HistoryValueEncoder value_encoder{entity.has_large_values}; value_encoder.value.value.value = value; value_encoder.value.timestamp.value = timestamp; Slice value_data = value_encoder.encode(); tx.rw_cursor(entity.values_table)->upsert(key_data, value_data); InvertedIndexPutQuery inverted_index_query{tx, entity.inverted_index}; inverted_index_query.exec(key, timestamp, false); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "history_delete_query.hpp" #include "history_get_query.hpp" #include "history_put_query.hpp" #include "history_range_in_period_query.hpp" ================================================ FILE: silkworm/db/datastore/kvdb/history_range_by_keys_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../common/pair_get.hpp" #include "../common/ranges/caching_view.hpp" #include "../common/ranges/lazy_view.hpp" #include "../common/ranges/unique_view.hpp" #include "cursor_iterator.hpp" #include "history.hpp" #include "history_codecs.hpp" #include "mdbx.hpp" #include "raw_codec.hpp" namespace silkworm::datastore::kvdb { template < EncoderConcept TKeyEncoder, DecoderConcept TKeyDecoder, DecoderConcept TValueDecoder> struct HistoryRangeByKeysQuery { ROTxn& tx; History entity; using Key = decltype(TKeyEncoder::value); using ResultItemKey = decltype(TKeyDecoder::value); using ResultItemValue = decltype(TValueDecoder::value); using ResultItem = std::pair; template static constexpr bool as_bool_predicate(const T& v) { return !!v; } static ResultItem kv_pair_from_cursor(std::shared_ptr cursor, bool has_large_values) { SILKWORM_ASSERT(cursor); CursorIterator any_it{ std::move(cursor), MoveOperation::next, std::make_shared>(has_large_values), std::make_shared>(has_large_values), }; CursorKVIterator, HistoryValueDecoder> it{std::move(any_it)}; auto kv_pair = *it; ResultItemKey& key = kv_pair.first.key.value; ResultItemValue& value = kv_pair.second.value.value; return std::pair{std::move(key), std::move(value)}; } static auto kv_pair_from_cursor_func(bool has_large_values) { return [=](std::shared_ptr cursor) -> ResultItem { return kv_pair_from_cursor(std::move(cursor), has_large_values); }; } auto exec_with_eager_begin(Bytes key_start, Bytes key_end, Timestamp timestamp, bool ascending) { // NOLINT(*-unnecessary-value-param) SILKWORM_ASSERT(ascending); // descending is not implemented CursorMoveIterator begin_it; std::function(std::shared_ptr)> seek_func; std::unique_ptr begin_cursor; if (entity.values_table.value_mode == mdbx::value_mode::multi) { begin_cursor = tx.ro_cursor_dup_sort(entity.values_table); } else { begin_cursor = tx.ro_cursor(entity.values_table); } if (begin_cursor->lower_bound(to_slice(key_start), false)) { if (entity.has_large_values) { begin_it = CursorMoveIterator{std::move(begin_cursor), MoveOperation::get_current}; seek_func = [timestamp, has_large_values = entity.has_large_values, skip_current_key = std::make_shared()](std::shared_ptr cursor) -> std::shared_ptr { auto result = cursor->current(); SILKWORM_ASSERT(result); HistoryKeyDecoder> key_decoder{has_large_values}; key_decoder.decode(result.key); if (*skip_current_key) { Bytes current_key{key_decoder.value.key.value}; do { result = cursor->to_next(false); if (!result) return {}; key_decoder.decode(result.key); } while (key_decoder.value.key.value == current_key); } HistoryKeyEncoder> seek_key_encoder{has_large_values}; seek_key_encoder.value.key.value = key_decoder.value.key.value; seek_key_encoder.value.timestamp.value = timestamp; Slice seek_key = seek_key_encoder.encode(); result = cursor->lower_bound(seek_key, false); if (result) { key_decoder.decode(result.key); // if we jumped over to the next key, timestamp might be invalid if (key_decoder.value.timestamp.value < timestamp) { *skip_current_key = false; return {}; } *skip_current_key = true; return cursor; } return {}; }; } else { begin_it = CursorMoveIterator{std::move(begin_cursor), MoveOperation::multi_nextkey_firstvalue}; seek_func = [timestamp](const std::shared_ptr& base_cursor) -> std::shared_ptr { auto cursor = base_cursor->clone(); auto result = cursor->current(); SILKWORM_ASSERT(result); TimestampEncoder ts_encoder{timestamp}; result = dynamic_cast(*cursor).lower_bound_multivalue(result.key, ts_encoder.encode(), false); return result ? std::shared_ptr{std::move(cursor)} : std::shared_ptr{}; }; } } auto before_key_end_predicate = [key_end = std::move(key_end)](const std::shared_ptr& cursor) { if (key_end.empty()) return true; auto result = cursor->current(); SILKWORM_ASSERT(result); return from_slice(result.key) < ByteView{key_end}; }; return std::ranges::subrange{std::move(begin_it), std::default_sentinel} | std::views::transform(std::move(seek_func)) | silkworm::views::caching | std::views::filter(as_bool_predicate>) | std::views::take_while(std::move(before_key_end_predicate)) | std::views::transform(kv_pair_from_cursor_func(entity.has_large_values)) | silkworm::views::caching; } auto exec(const Key& key_start, const Key& key_end, Timestamp timestamp, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented TKeyEncoder key_start_encoder; key_start_encoder.value = key_start; Slice key_start_slice = key_start_encoder.encode(); Bytes key_start_data = Bytes{from_slice(key_start_slice)}; TKeyEncoder key_end_encoder; key_end_encoder.value = key_end; Slice key_end_slice = key_end_encoder.encode(); Bytes key_end_data = Bytes{from_slice(key_end_slice)}; auto exec_func = [query = *this, key_start = std::move(key_start_data), key_end = std::move(key_end_data), timestamp, ascending]() mutable { return query.exec_with_eager_begin(std::move(key_start), std::move(key_end), timestamp, ascending); }; return silkworm::ranges::lazy(std::move(exec_func)); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_range_by_keys_query_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "history_range_by_keys_query.hpp" #include #include #include #include "big_endian_codec.hpp" #include "history_put_query.hpp" #include "query_test.hpp" namespace silkworm::datastore::kvdb { struct Entry { uint64_t key{0}; uint64_t value{0}; Timestamp timestamp{0}; }; using HistoryRangeQuery = HistoryRangeByKeysQuery; using Result = std::vector>; TEMPLATE_TEST_CASE("HistoryRangeByKeysQuery", "", DomainDefault, DomainWithLargeValues) { QueryTest test = QueryTest::make(); auto find_in = [&test](const std::vector& data, uint64_t key_start, uint64_t key_end, Timestamp timestamp) -> Result { return test.find_in, HistoryRangeQuery>(data, key_start, key_end, timestamp, /* ascending = */ true); }; SECTION("single entry - correct key") { CHECK(find_in({Entry{1, 2, 3}}, 1, 2, 3) == Result{{1, 2}}); } SECTION("single entry - wrong key") { CHECK(find_in({Entry{1, 2, 3}}, 4, 5, 3).empty()); } SECTION("same timestamp - different keys") { CHECK(find_in({Entry{1, 11, 100}, Entry{2, 22, 100}, Entry{3, 33, 100}}, 2, 3, 100) == Result{{2, 22}}); } SECTION("different timestamps - different keys") { CHECK(find_in({Entry{1, 11, 101}, Entry{2, 22, 102}, Entry{3, 33, 103}}, 2, 3, 100) == Result{{2, 22}}); } SECTION("different timestamps - same key") { CHECK(find_in({Entry{1, 11, 101}, Entry{1, 22, 102}, Entry{1, 33, 103}}, 1, 2, 100) == Result{{1, 11}}); } SECTION("find keys [1..3] in [2..5]") { CHECK(find_in({Entry{2, 22, 100}, Entry{3, 33, 100}, Entry{4, 44, 100}, Entry{5, 55, 100}}, 1, 4, 100) == Result{{2, 22}, {3, 33}}); } SECTION("find keys [4..6] in [2..5]") { CHECK(find_in({Entry{2, 22, 100}, Entry{3, 33, 100}, Entry{4, 44, 100}, Entry{5, 55, 100}}, 4, 7, 100) == Result{{4, 44}, {5, 55}}); } SECTION("find all") { CHECK(find_in({Entry{11, 111, 1}, Entry{22, 222, 2}, Entry{33, 333, 3}}, 0, 100, 0) == Result{{11, 111}, {22, 222}, {33, 333}}); } SECTION("find all in unsorted") { CHECK(find_in({Entry{33, 333, 3}, Entry{22, 222, 2}, Entry{11, 111, 1}}, 0, 100, 0) == Result{{11, 111}, {22, 222}, {33, 333}}); } SECTION("find from timestamp") { CHECK(find_in({Entry{11, 111, 1}, Entry{22, 222, 2}, Entry{33, 333, 3}}, 0, 100, 2) == Result{{22, 222}, {33, 333}}); } SECTION("find none given non-overlapping ts range") { CHECK(find_in({Entry{11, 111, 1}, Entry{22, 222, 2}, Entry{33, 333, 3}}, 0, 100, 10).empty()); } SECTION("find none in empty") { CHECK(find_in({}, 0, 100, 0).empty()); } SECTION("find all - with duplicates") { CHECK(find_in({Entry{11, 111, 1}, Entry{11, 112, 2}, Entry{22, 222, 3}, Entry{22, 223, 4}}, 0, 100, 0) == Result{{11, 111}, {22, 222}}); } SECTION("find all in unsorted - with duplicates") { CHECK(find_in({Entry{22, 223, 4}, Entry{22, 222, 3}, Entry{11, 112, 2}, Entry{11, 111, 1}}, 0, 100, 0) == Result{{11, 111}, {22, 222}}); } SECTION("find from timestamp - with duplicates") { CHECK(find_in({Entry{11, 111, 1}, Entry{11, 112, 2}, Entry{22, 222, 3}, Entry{22, 223, 4}}, 0, 100, 2) == Result{{11, 112}, {22, 222}}); } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_range_in_period_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../common/ranges/caching_view.hpp" #include "../common/ranges/lazy_view.hpp" #include "../common/timestamp.hpp" #include "cursor_iterator.hpp" #include "history.hpp" #include "history_codecs.hpp" #include "mdbx.hpp" #include "raw_codec.hpp" namespace silkworm::datastore::kvdb { template struct HistoryRangeInPeriodQuery { ROTxn& tx; History entity; using Key = decltype(TKeyDecoder::value); using Value = decltype(TValueDecoder::value); using ResultItem = std::pair; template static constexpr bool as_bool_predicate(const T& v) { return !!v; } static ResultItem kv_pair_from_cursor(std::shared_ptr cursor, bool has_large_values) { SILKWORM_ASSERT(cursor); CursorIterator any_it{ std::move(cursor), MoveOperation::next, std::make_shared>(has_large_values), std::make_shared>(has_large_values), }; CursorKVIterator, HistoryValueDecoder> it{std::move(any_it)}; auto kv_pair = *it; Key& key = kv_pair.first.key.value; Value& value = kv_pair.second.value.value; return std::pair{std::move(key), std::move(value)}; } static auto kv_pair_from_cursor_func(bool has_large_values) { return [=](std::shared_ptr cursor) -> ResultItem { return kv_pair_from_cursor(std::move(cursor), has_large_values); }; } auto exec_with_eager_begin(TimestampRange ts_range, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented CursorMoveIterator begin_it; std::function(std::shared_ptr)> seek_func; std::unique_ptr begin_cursor; if (entity.values_table.value_mode == mdbx::value_mode::multi) { begin_cursor = tx.ro_cursor_dup_sort(entity.values_table); } else { begin_cursor = tx.ro_cursor(entity.values_table); } if (begin_cursor->to_first(false)) { if (entity.has_large_values) { begin_it = CursorMoveIterator{std::move(begin_cursor), MoveOperation::get_current}; seek_func = [ts_range, has_large_values = entity.has_large_values, skip_current_key = std::make_shared()](std::shared_ptr cursor) -> std::shared_ptr { auto result = cursor->current(); SILKWORM_ASSERT(result); HistoryKeyDecoder> key_decoder{has_large_values}; key_decoder.decode(result.key); if (*skip_current_key) { Bytes current_key{key_decoder.value.key.value}; do { result = cursor->to_next(false); if (!result) return {}; key_decoder.decode(result.key); } while (key_decoder.value.key.value == current_key); } HistoryKeyEncoder> seek_key_encoder{has_large_values}; seek_key_encoder.value.key.value = key_decoder.value.key.value; seek_key_encoder.value.timestamp.value = ts_range.start; Slice seek_key = seek_key_encoder.encode(); result = cursor->lower_bound(seek_key, false); if (result) { key_decoder.decode(result.key); // if we jumped over to the next key, ts_range.start might be invalid if (key_decoder.value.timestamp.value < ts_range.start) { *skip_current_key = false; return {}; } else if (key_decoder.value.timestamp.value < ts_range.end) { *skip_current_key = true; return cursor; } *skip_current_key = true; return {}; } return {}; }; } else { begin_it = CursorMoveIterator{std::move(begin_cursor), MoveOperation::multi_nextkey_firstvalue}; seek_func = [ts_range, has_large_values = entity.has_large_values](const std::shared_ptr& base_cursor) -> std::shared_ptr { auto cursor = base_cursor->clone(); auto result = cursor->current(); SILKWORM_ASSERT(result); TimestampEncoder ts_range_start_encoder{ts_range.start}; result = dynamic_cast(*cursor).lower_bound_multivalue(result.key, ts_range_start_encoder.encode(), false); if (result) { HistoryValueDecoder> value_decoder{has_large_values}; value_decoder.decode(result.value); if (value_decoder.value.timestamp.value < ts_range.end) { return std::shared_ptr{std::move(cursor)}; } } return {}; }; } } return std::ranges::subrange{std::move(begin_it), std::default_sentinel} | std::views::transform(std::move(seek_func)) | silkworm::views::caching | std::views::filter(as_bool_predicate>) | std::views::transform(kv_pair_from_cursor_func(entity.has_large_values)) | silkworm::views::caching; } auto exec(TimestampRange ts_range, bool ascending) { auto exec_func = [query = *this, ts_range, ascending]() mutable { return query.exec_with_eager_begin(ts_range, ascending); }; return silkworm::ranges::lazy(std::move(exec_func)); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/history_range_in_period_query_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "history_range_in_period_query.hpp" #include #include #include "big_endian_codec.hpp" #include "history_put_query.hpp" #include "query_test.hpp" namespace silkworm::datastore::kvdb { struct HistoryPutEntry { uint64_t key{0}; uint64_t value{0}; Timestamp timestamp{0}; }; using Entry = HistoryPutEntry; using HistoryRangeQuery = HistoryRangeInPeriodQuery; using Result = std::vector>; TEMPLATE_TEST_CASE("HistoryRangeInPeriodQuery", "", DomainDefault, DomainWithLargeValues) { QueryTest test = QueryTest::make(); auto find_in = [&test](const std::vector& data, TimestampRange ts_range) -> Result { return test.find_in, HistoryRangeQuery>(data, ts_range, /* ascending = */ true); }; SECTION("find all") { CHECK(find_in({Entry{11, 111, 1}, Entry{22, 222, 2}, Entry{33, 333, 3}}, {0, 10}) == Result{{11, 111}, {22, 222}, {33, 333}}); } SECTION("find all in unsorted") { CHECK(find_in({Entry{33, 333, 3}, Entry{22, 222, 2}, Entry{11, 111, 1}}, {0, 10}) == Result{{11, 111}, {22, 222}, {33, 333}}); } SECTION("find from timestamp") { CHECK(find_in({Entry{11, 111, 1}, Entry{22, 222, 2}, Entry{33, 333, 3}}, {2, 10}) == Result{{22, 222}, {33, 333}}); } SECTION("find before timestamp") { CHECK(find_in({Entry{11, 111, 1}, Entry{22, 222, 2}, Entry{33, 333, 3}}, {0, 3}) == Result{{11, 111}, {22, 222}}); } SECTION("find none given non-overlapping ts range") { CHECK(find_in({Entry{11, 111, 1}, Entry{22, 222, 2}, Entry{33, 333, 3}}, {10, 20}).empty()); } SECTION("find none in empty") { CHECK(find_in({}, {0, 10}).empty()); } SECTION("find all - with duplicates") { CHECK(find_in({Entry{11, 111, 1}, Entry{11, 112, 2}, Entry{22, 222, 3}, Entry{22, 223, 4}}, {0, 10}) == Result{{11, 111}, {22, 222}}); } SECTION("find all in unsorted - with duplicates") { CHECK(find_in({Entry{22, 223, 4}, Entry{22, 222, 3}, Entry{11, 112, 2}, Entry{11, 111, 1}}, {0, 10}) == Result{{11, 111}, {22, 222}}); } SECTION("find from timestamp - with duplicates") { CHECK(find_in({Entry{11, 111, 1}, Entry{11, 112, 2}, Entry{22, 222, 3}, Entry{22, 223, 4}}, {2, 10}) == Result{{11, 112}, {22, 222}}); } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/inverted_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once namespace silkworm::datastore::kvdb { struct MapConfig; struct InvertedIndex { const MapConfig& keys_table; const MapConfig& index_table; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/inverted_index_put_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/timestamp.hpp" #include "inverted_index.hpp" #include "mdbx.hpp" #include "timestamp_codec.hpp" namespace silkworm::datastore::kvdb { template struct InvertedIndexPutQuery { RWTxn& tx; InvertedIndex entity; using Key = decltype(TKeyEncoder::value); void exec(const Key& key, const Timestamp timestamp, bool with_index_update) { return exec(key, timestamp, with_index_update); } template void exec(const Key& key, const TTimestamp& timestamp, bool with_index_update) { TKeyEncoder key_encoder; key_encoder.value = key; Slice key_slice = key_encoder.encode(); TTimestampEncoder ts_encoder; ts_encoder.value = timestamp; Slice ts_slice = ts_encoder.encode(); tx.rw_cursor(entity.keys_table)->upsert(ts_slice, key_slice); if (with_index_update) { tx.rw_cursor(entity.index_table)->upsert(key_slice, ts_slice); } } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/inverted_index_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "inverted_index_put_query.hpp" #include "inverted_index_range_by_key_query.hpp" ================================================ FILE: silkworm/db/datastore/kvdb/inverted_index_range_by_key_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../common/ranges/lazy_view.hpp" #include "../common/timestamp.hpp" #include "codec.hpp" #include "cursor_iterator.hpp" #include "inverted_index.hpp" #include "mdbx.hpp" #include "timestamp_codec.hpp" namespace silkworm::datastore::kvdb { template struct InvertedIndexRangeByKeyQuery { ROTxn& tx; InvertedIndex entity; using Key = decltype(TKeyEncoder::value); //! A range of timestamps using Timestamps = std::ranges::filter_view< std::ranges::subrange>, decltype(std::declval().contains_predicate())>; CursorValuesIterator begin(Key key, TimestampRange ts_range, bool ascending) { auto cursor = tx.ro_cursor_dup_sort(entity.index_table); TKeyEncoder key_encoder; key_encoder.value = std::move(key); Slice key_data = key_encoder.encode(); TimestampEncoder ts_encoder; ts_encoder.value = ascending ? ts_range.start : ts_range.end; Slice ts_data = ts_encoder.encode(); CursorResult result = cursor->lower_bound_multivalue(key_data, ts_data, false); if (!ascending) { if (result) { result = cursor->to_current_prev_multi(false); } else { result = cursor->find(key_data, false); if (result) { cursor->to_current_last_multi(false); } } } if (result) { MoveOperation move_op = ascending ? MoveOperation::multi_currentkey_nextvalue : MoveOperation::multi_currentkey_prevvalue; auto it = CursorValuesIterator::make(std::move(cursor), move_op); if (ts_range.contains(*it)) { return it; } } return {}; } Timestamps exec_with_eager_begin(Key key, TimestampRange ts_range, bool ascending) { auto begin_it = begin(std::move(key), ts_range, ascending); return std::ranges::subrange{std::move(begin_it), CursorValuesIterator{}} | std::views::filter(ts_range.contains_predicate()); } auto exec(Key key, TimestampRange ts_range, bool ascending) { auto exec_func = [query = *this, key = std::move(key), ts_range, ascending]() mutable { return query.exec_with_eager_begin(std::move(key), ts_range, ascending); }; return silkworm::ranges::lazy(std::move(exec_func)); } }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/inverted_index_range_by_key_query_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "inverted_index_range_by_key_query.hpp" #include #include #include "big_endian_codec.hpp" #include "inverted_index_put_query.hpp" #include "query_test.hpp" namespace silkworm::datastore::kvdb { struct Entry { uint64_t key{0}; Timestamp timestamp{0}; bool with_index_update{true}; }; TEST_CASE("InvertedIndexRangeByKeyQuery") { QueryTest test = QueryTest::make(); auto find_in = [&test](const std::vector& data, uint64_t key, TimestampRange ts_range, bool ascending) -> std::vector { return test.find_in, InvertedIndexRangeByKeyQuery>(data, key, ts_range, ascending); }; SECTION("asc - all") { CHECK(find_in({{1, 1}, {1, 2}, {1, 3}}, 1, TimestampRange{0, 10}, true) == std::vector{1, 2, 3}); } SECTION("asc - all with neighbor keys") { CHECK(find_in({{0, 2}, {1, 1}, {1, 2}, {1, 3}, {2, 2}}, 1, TimestampRange{0, 10}, true) == std::vector{1, 2, 3}); } SECTION("asc - middle") { CHECK(find_in({{1, 1}, {1, 2}, {1, 3}}, 1, TimestampRange{2, 3}, true) == std::vector{2}); } SECTION("asc - middle gap") { CHECK(find_in({{1, 1}, {1, 3}}, 1, TimestampRange{2, 3}, true).empty()); } SECTION("asc - middle to end with neighbor keys") { CHECK(find_in({{0, 2}, {1, 1}, {1, 2}, {1, 3}, {2, 2}}, 1, TimestampRange{2, 10}, true) == std::vector{2, 3}); } SECTION("asc - middle gap to end with neighbor keys") { CHECK(find_in({{0, 2}, {1, 1}, {1, 3}, {2, 2}}, 1, TimestampRange{2, 10}, true) == std::vector{3}); } SECTION("desc - all") { CHECK(find_in({{1, 1}, {1, 2}, {1, 3}}, 1, TimestampRange{0, 10}, false) == std::vector{3, 2, 1}); } SECTION("desc - all with neighbor keys") { CHECK(find_in({{0, 2}, {1, 1}, {1, 2}, {1, 3}, {2, 2}}, 1, TimestampRange{0, 10}, false) == std::vector{3, 2, 1}); } SECTION("desc - middle") { CHECK(find_in({{1, 1}, {1, 2}, {1, 3}}, 1, TimestampRange{2, 3}, false) == std::vector{2}); } SECTION("desc - middle gap") { CHECK(find_in({{1, 1}, {1, 3}}, 1, TimestampRange{2, 3}, false).empty()); } SECTION("desc - middle to start with neighbor keys") { CHECK(find_in({{0, 2}, {1, 1}, {1, 2}, {1, 3}, {2, 2}}, 1, TimestampRange{0, 3}, false) == std::vector{2, 1}); } SECTION("desc - middle gap to start with neighbor keys") { CHECK(find_in({{0, 2}, {1, 1}, {1, 3}, {2, 2}}, 1, TimestampRange{0, 3}, false) == std::vector{1}); } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/kvts_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "codec.hpp" #include "raw_codec.hpp" namespace silkworm::datastore::kvdb { template class KVTSKeyEncoder : public Encoder { public: struct { TEncoder key; TTimestampEncoder timestamp; } value; explicit KVTSKeyEncoder(bool has_large_values) : has_large_values_{has_large_values} {} ~KVTSKeyEncoder() override = default; Slice encode() override { data_.clear(); if (has_large_values_) { // encode as key + timestamp data_.append(from_slice(value.key.encode())); data_.append(from_slice(value.timestamp.encode())); return to_slice(data_); } return value.key.encode(); } private: bool has_large_values_; Bytes data_; }; template class KVTSValueEncoder : public Encoder { public: struct { TEncoder value; TTimestampEncoder timestamp; } value; explicit KVTSValueEncoder(bool has_large_values) : has_large_values_{has_large_values} {} ~KVTSValueEncoder() override = default; Slice encode() override { data_.clear(); if (has_large_values_) { return value.value.encode(); } // encode as timestamp + value data_.append(from_slice(value.timestamp.encode())); data_.append(from_slice(value.value.encode())); return to_slice(data_); } private: bool has_large_values_; Bytes data_; }; static_assert(EncoderConcept, RawEncoder>>); static_assert(EncoderConcept, RawEncoder>>); template class KVTSKeyDecoder : public Decoder { public: struct { TDecoder key; TTimestampDecoder timestamp; } value; explicit KVTSKeyDecoder(bool has_large_values) : has_large_values_{has_large_values} {} ~KVTSKeyDecoder() override = default; void decode(Slice data) override { if (has_large_values_) { // decode as key + timestamp SILKWORM_ASSERT(data.size() >= kEncodedTimestampSize); value.key.decode(to_slice(from_slice(data).substr(0, data.size() - kEncodedTimestampSize))); value.timestamp.decode(to_slice(from_slice(data).substr(data.size() - kEncodedTimestampSize, kEncodedTimestampSize))); } else { value.key.decode(data); } } private: bool has_large_values_; }; template class KVTSValueDecoder : public Decoder { public: struct { TDecoder value; TTimestampDecoder timestamp; } value; explicit KVTSValueDecoder(bool has_large_values) : has_large_values_{has_large_values} {} ~KVTSValueDecoder() override = default; void decode(Slice slice) override { if (has_large_values_) { value.value.decode(slice); } else { // decode as timestamp + value SILKWORM_ASSERT(slice.size() >= kEncodedTimestampSize); value.timestamp.decode(to_slice(from_slice(slice).substr(0, kEncodedTimestampSize))); value.value.decode(to_slice(from_slice(slice).substr(kEncodedTimestampSize))); } } private: bool has_large_values_; }; static_assert(DecoderConcept, RawDecoder, sizeof(uint64_t)>>); static_assert(DecoderConcept, RawDecoder, sizeof(uint64_t)>>); } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/mdbx.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "mdbx.hpp" #include #include namespace silkworm::datastore::kvdb { namespace detail { std::string dump_mdbx_result(const CursorResult& result) { std::string dump{"done="}; dump.append(std::to_string(result.done)); dump.append(" bool(key)="); dump.append(std::to_string(bool{result.key})); dump.append(" bool(value)="); dump.append(std::to_string(bool{result.value})); return dump; } std::string slice_as_hex(const Slice& data) { return ::mdbx::to_hex(data).as_string(); } log::Args log_args_for_commit_latency(const MDBX_commit_latency& commit_latency) { return { "preparation", std::to_string(commit_latency.preparation), "write", std::to_string(commit_latency.write), "sync", std::to_string(commit_latency.sync), "ending", std::to_string(commit_latency.ending), "whole", std::to_string(commit_latency.whole), }; } } // namespace detail //! \brief Returns data of current cursor position or moves it to the beginning or the end of the table based on //! provided direction if the cursor is not positioned. //! \param [in] c : A reference to an open cursor //! \param [in] d : Direction cursor should have \return ::mdbx::cursor::move_result static CursorResult adjust_cursor_position_if_unpositioned( ROCursor& c, CursorMoveDirection d) { // Warning: eof() is not exactly what we need here since it returns true not only for cursors // that are not positioned, but also for those pointing to the end of data. // Unfortunately, there's no MDBX API to differentiate the two. if (c.eof()) { return (d == CursorMoveDirection::kForward) ? c.to_first(/*throw_notfound=*/false) : c.to_last(/*throw_notfound=*/false); } return c.current(/*throw_notfound=*/false); } // Last entry whose key is strictly less than the given key static CursorResult strict_lower_bound(ROCursor& cursor, const ByteView key) { if (!cursor.lower_bound(key, /*throw_notfound=*/false)) { // all DB keys are less than the given key return cursor.to_last(/*throw_notfound=*/false); } // return lower_bound - 1 return cursor.to_previous(/*throw_notfound=*/false); } static mdbx::cursor::move_operation move_operation(CursorMoveDirection direction) { return direction == CursorMoveDirection::kForward ? mdbx::cursor::move_operation::next : mdbx::cursor::move_operation::previous; } ::mdbx::env_managed open_env(const EnvConfig& config) { namespace fs = std::filesystem; if (config.path.empty()) { throw std::invalid_argument("Invalid argument : config.path"); } // Check datafile exists if create is not set fs::path env_path{config.path}; if (env_path.has_filename()) { env_path += std::filesystem::path::preferred_separator; // Remove ambiguity. It has to be a directory } if (!fs::exists(env_path)) { fs::create_directories(env_path); } else if (!fs::is_directory(env_path)) { throw std::runtime_error("Path " + env_path.string() + " is not valid"); } fs::path db_file{get_datafile_path(env_path)}; const size_t db_file_size{fs::exists(db_file) ? fs::file_size(db_file) : 0}; if (!config.create && !db_file_size) { throw std::runtime_error("Unable to locate " + db_file.string() + ", which is required to exist"); } if (config.create && db_file_size) { throw std::runtime_error("File " + db_file.string() + " already exists but create was set"); } // Prevent mapping a file with a smaller map size than the size on disk. // Opening would not fail but only a part of data would be mapped. if (db_file_size > config.max_size) { throw std::runtime_error("Database map size is too small. Min required " + human_size(db_file_size)); } uint32_t flags{MDBX_NOTLS | MDBX_NORDAHEAD | MDBX_COALESCE | MDBX_SYNC_DURABLE}; // Default flags if (config.read_ahead) { flags &= ~MDBX_NORDAHEAD; } if (config.exclusive && config.shared) { throw std::runtime_error("Exclusive conflicts with Shared"); } if (config.create && config.shared) { throw std::runtime_error("Create conflicts with Shared"); } if (config.create && config.readonly) { throw std::runtime_error("Create conflicts with Readonly"); } if (config.readonly) { flags |= MDBX_RDONLY; } if (config.in_memory) { flags |= MDBX_NOMETASYNC; } if (config.exclusive) { flags |= MDBX_EXCLUSIVE; } if (config.shared) { flags |= MDBX_ACCEDE; } if (config.write_map) { flags |= MDBX_WRITEMAP; } ::mdbx::env_managed::create_parameters cp{}; // Default create parameters if (!config.shared) { auto max_map_size = static_cast(config.in_memory ? 128_Mebi : config.max_size); auto growth_size = static_cast(config.in_memory ? 8_Mebi : config.growth_size); cp.geometry.make_dynamic(::mdbx::env::geometry::default_value, max_map_size); cp.geometry.growth_step = growth_size; if (!db_file_size) { cp.geometry.pagesize = static_cast(config.page_size); } } using OP = ::mdbx::env::operate_parameters; OP op{}; // Operational parameters op.mode = OP::mode_from_flags(static_cast(flags)); op.options = OP::options_from_flags(static_cast(flags)); op.durability = OP::durability_from_flags(static_cast(flags)); op.max_maps = config.max_tables; op.max_readers = config.max_readers; ::mdbx::env_managed env{env_path.native(), cp, op, config.shared}; // Read stats to make sure that env is fully functional, // otherwise there's an obscure bug: // mdbx::env::start_read fails with 22 (EINVAL) from fcntl on the mdbx lock file // (see branch debug_mdbx_txn_begin_fcntl_22 for a test case) [[maybe_unused]] auto _ = env.get_stat(); if (!config.shared) { // C++ bindings don't have set_option ::mdbx::error::success_or_throw(::mdbx_env_set_option(env, MDBX_opt_rp_augment_limit, 32_Mebi)); if (!config.readonly) { ::mdbx::error::success_or_throw(::mdbx_env_set_option(env, MDBX_opt_txn_dp_initial, 16_Kibi)); ::mdbx::error::success_or_throw(::mdbx_env_set_option(env, MDBX_opt_dp_reserve_limit, 16_Kibi)); uint64_t dirty_pages_limit{0}; ::mdbx::error::success_or_throw(::mdbx_env_get_option(env, MDBX_opt_txn_dp_limit, &dirty_pages_limit)); ::mdbx::error::success_or_throw(::mdbx_env_set_option(env, MDBX_opt_txn_dp_limit, dirty_pages_limit * 2)); // must be in the range from 12.5% (almost empty) to 50% (half empty) // which corresponds to the range from 8192 and to 32768 in units respectively ::mdbx::error::success_or_throw( ::mdbx_env_set_option(env, MDBX_opt_merge_threshold_16dot16_percent, 32_Kibi)); } } if (!config.in_memory) { env.check_readers(); } return env; } ::mdbx::map_handle open_map(::mdbx::txn& tx, const MapConfig& config) { if (tx.is_readonly()) { return tx.open_map(config.name_str(), config.key_mode, config.value_mode); } return tx.create_map(config.name_str(), config.key_mode, config.value_mode); } ::mdbx::cursor_managed open_cursor(::mdbx::txn& tx, const MapConfig& config) { return tx.open_cursor(open_map(tx, config)); } size_t max_value_size_for_leaf_page(const size_t page_size, const size_t key_size) { /* * On behalf of configured MDBX page size we need to find * the size of each shard best fitting in data page without * causing MDBX to write value in overflow pages. * * Example : * for accounts history index * with shard_key_len == kAddressLength + sizeof(uint64_t) == 28 * with page_size == 4096 * optimal shard size == 2000 * * for storage history index * with shard_key_len == kAddressLength + kHashLength + sizeof(uint64_t) == 20 + 32 + 8 == 60 * with page_size == 4096 * optimal shard size == 1968 * * NOTE !! Keep an eye on MDBX code as PageHeader and Node structs might change */ static constexpr size_t kPageOverheadSize{32ull}; // PageHeader + NodeSize const size_t page_room{page_size - kPageOverheadSize}; const size_t leaf_node_max_room{ ((page_room / 2) & ~1ull /* even number */) - (/* key and value sizes fields */ 2 * sizeof(uint16_t))}; const size_t max_size{leaf_node_max_room - key_size}; return max_size; } size_t max_value_size_for_leaf_page(const mdbx::txn& txn, const size_t key_size) { const size_t page_size{txn.env().get_pagesize()}; return max_value_size_for_leaf_page(page_size, key_size); } std::unique_ptr ROTxn::ro_cursor(const MapConfig& config) { return std::make_unique(*this, config); } std::unique_ptr ROTxn::ro_cursor_dup_sort(const MapConfig& config) { return std::make_unique(*this, config); } std::unique_ptr RWTxn::rw_cursor(const MapConfig& config) { return std::make_unique(*this, config); } std::unique_ptr RWTxn::rw_cursor_dup_sort(const MapConfig& config) { return std::make_unique(*this, config); } void RWTxnManaged::commit_and_renew() { if (!commit_disabled_) { mdbx::env env = db(); managed_txn_.commit(); managed_txn_ = env.start_write(); // renew transaction } } void RWTxnManaged::commit_and_stop() { if (!commit_disabled_) { managed_txn_.commit(); } } thread_local ObjectPool PooledCursor::handles_pool_{}; PooledCursor::PooledCursor() { handle_ = handles_pool_.acquire(); if (!handle_) { handle_ = ::mdbx_cursor_create(nullptr); } } PooledCursor::PooledCursor(ROTxn& txn, ::mdbx::map_handle map) { handle_ = handles_pool_.acquire(); if (!handle_) { handle_ = ::mdbx_cursor_create(nullptr); } bind(txn, map); } PooledCursor::PooledCursor(::mdbx::txn& txn, const MapConfig& config) { handle_ = handles_pool_.acquire(); if (!handle_) { handle_ = ::mdbx_cursor_create(nullptr); } bind(txn, config); } PooledCursor::PooledCursor(PooledCursor&& other) noexcept { std::swap(handle_, other.handle_); } PooledCursor& PooledCursor::operator=(PooledCursor&& other) noexcept { std::swap(handle_, other.handle_); return *this; } PooledCursor::~PooledCursor() { if (handle_) { handles_pool_.add(handle_); } } void PooledCursor::bind(ROTxn& txn, ::mdbx::map_handle map) { if (!handle_) throw std::runtime_error("cannot bind a closed cursor"); // Check cursor is bound to a live transaction if (auto cm_tx{mdbx_cursor_txn(handle_)}; cm_tx) { // If current transaction id does not match cursor's transaction close it and recreate a new one if (txn->id() != mdbx_txn_id(cm_tx)) { close(); handle_ = ::mdbx_cursor_create(nullptr); } } ::mdbx::cursor::bind(*txn, map); } void PooledCursor::bind(::mdbx::txn& txn, const MapConfig& config) { if (!handle_) throw std::runtime_error("cannot bind a closed cursor"); // Check cursor is bound to a live transaction if (auto cm_tx{mdbx_cursor_txn(handle_)}; cm_tx) { // If current transaction id does not match cursor's transaction close it and recreate a new one if (txn.id() != mdbx_txn_id(cm_tx)) { close(); handle_ = ::mdbx_cursor_create(nullptr); } } const auto map{open_map(txn, config)}; ::mdbx::cursor::bind(txn, map); } std::unique_ptr PooledCursor::clone() { auto clone = std::make_unique(); mdbx::error::success_or_throw(::mdbx_cursor_copy(handle_, clone->handle_)); return clone; } void PooledCursor::close() { ::mdbx_cursor_close(handle_); handle_ = nullptr; } MDBX_stat PooledCursor::get_map_stat() const { if (!handle_) { mdbx::error::success_or_throw(EINVAL); } return txn().get_map_stat(map()); } MDBX_db_flags_t PooledCursor::get_map_flags() const { if (!handle_) { mdbx::error::success_or_throw(EINVAL); } return txn().get_handle_info(map()).flags; } bool PooledCursor::is_multi_value() const { return get_map_flags() & MDBX_DUPSORT; } bool PooledCursor::is_dangling() const { return eof() && !on_last(); } size_t PooledCursor::size() const { return get_map_stat().ms_entries; } ::mdbx::map_handle PooledCursor::map() const { return ::mdbx::cursor::map(); } CursorResult PooledCursor::to_first() { return ::mdbx::cursor::to_first(/*throw_notfound =*/true); } CursorResult PooledCursor::to_first(bool throw_notfound) { return ::mdbx::cursor::to_first(throw_notfound); } CursorResult PooledCursor::to_previous() { return ::mdbx::cursor::to_previous(/*throw_notfound =*/true); } CursorResult PooledCursor::to_previous(bool throw_notfound) { return ::mdbx::cursor::to_previous(throw_notfound); } CursorResult PooledCursor::current() const { return ::mdbx::cursor::current(/*throw_notfound =*/true); } CursorResult PooledCursor::current(bool throw_notfound) const { return ::mdbx::cursor::current(throw_notfound); } CursorResult PooledCursor::to_next() { return ::mdbx::cursor::to_next(/*throw_notfound =*/true); } CursorResult PooledCursor::to_next(bool throw_notfound) { return ::mdbx::cursor::to_next(throw_notfound); } CursorResult PooledCursor::to_last() { return ::mdbx::cursor::to_last(/*throw_notfound =*/true); } CursorResult PooledCursor::to_last(bool throw_notfound) { return ::mdbx::cursor::to_last(throw_notfound); } CursorResult PooledCursor::find(const Slice& key) { return ::mdbx::cursor::find(key, /*throw_notfound =*/true); } CursorResult PooledCursor::find(const Slice& key, bool throw_notfound) { return ::mdbx::cursor::find(key, throw_notfound); } CursorResult PooledCursor::lower_bound(const Slice& key) { return ::mdbx::cursor::lower_bound(key, /*throw_notfound =*/true); } CursorResult PooledCursor::lower_bound(const Slice& key, bool throw_notfound) { return ::mdbx::cursor::lower_bound(key, throw_notfound); } MoveResult PooledCursor::move(MoveOperation operation, bool throw_notfound) { return ::mdbx::cursor::move(operation, throw_notfound); } MoveResult PooledCursor::move(MoveOperation operation, const Slice& key, bool throw_notfound) { return ::mdbx::cursor::move(operation, key, throw_notfound); } bool PooledCursor::seek(const Slice& key) { return ::mdbx::cursor::seek(key); } bool PooledCursor::eof() const { return ::mdbx::cursor::eof(); } bool PooledCursor::on_first() const { return ::mdbx::cursor::on_first(); } bool PooledCursor::on_last() const { return ::mdbx::cursor::on_last(); } CursorResult PooledCursor::to_previous_last_multi() { return ::mdbx::cursor::to_previous_last_multi(/*throw_notfound =*/true); } CursorResult PooledCursor::to_previous_last_multi(bool throw_notfound) { return ::mdbx::cursor::to_previous_last_multi(throw_notfound); } CursorResult PooledCursor::to_current_first_multi() { return ::mdbx::cursor::to_current_first_multi(/*throw_notfound =*/true); } CursorResult PooledCursor::to_current_first_multi(bool throw_notfound) { return ::mdbx::cursor::to_current_first_multi(throw_notfound); } CursorResult PooledCursor::to_current_prev_multi() { return ::mdbx::cursor::to_current_prev_multi(/*throw_notfound =*/true); } CursorResult PooledCursor::to_current_prev_multi(bool throw_notfound) { return ::mdbx::cursor::to_current_prev_multi(throw_notfound); } CursorResult PooledCursor::to_current_next_multi() { return ::mdbx::cursor::to_current_next_multi(/*throw_notfound =*/true); } CursorResult PooledCursor::to_current_next_multi(bool throw_notfound) { return ::mdbx::cursor::to_current_next_multi(throw_notfound); } CursorResult PooledCursor::to_current_last_multi() { return ::mdbx::cursor::to_current_last_multi(/*throw_notfound =*/true); } CursorResult PooledCursor::to_current_last_multi(bool throw_notfound) { return ::mdbx::cursor::to_current_last_multi(throw_notfound); } CursorResult PooledCursor::to_next_first_multi() { return ::mdbx::cursor::to_next_first_multi(/*throw_notfound =*/true); } CursorResult PooledCursor::to_next_first_multi(bool throw_notfound) { return ::mdbx::cursor::to_next_first_multi(throw_notfound); } CursorResult PooledCursor::find_multivalue(const Slice& key, const Slice& value) { return ::mdbx::cursor::find_multivalue(key, value, /*throw_notfound =*/true); } CursorResult PooledCursor::find_multivalue(const Slice& key, const Slice& value, bool throw_notfound) { return ::mdbx::cursor::find_multivalue(key, value, throw_notfound); } CursorResult PooledCursor::lower_bound_multivalue(const Slice& key, const Slice& value) { return ::mdbx::cursor::lower_bound_multivalue(key, value, /*throw_notfound =*/false); } CursorResult PooledCursor::lower_bound_multivalue(const Slice& key, const Slice& value, bool throw_notfound) { return ::mdbx::cursor::lower_bound_multivalue(key, value, throw_notfound); } MoveResult PooledCursor::move(MoveOperation operation, const Slice& key, const Slice& value, bool throw_notfound) { return ::mdbx::cursor::move(operation, key, value, throw_notfound); } size_t PooledCursor::count_multivalue() const { return ::mdbx::cursor::count_multivalue(); } MDBX_error_t PooledCursor::put(const Slice& key, Slice* value, MDBX_put_flags_t flags) noexcept { return ::mdbx::cursor::put(key, value, flags); } void PooledCursor::insert(const Slice& key, Slice value) { ::mdbx::cursor::insert(key, value); } void PooledCursor::upsert(const Slice& key, const Slice& value) { ::mdbx::cursor::upsert(key, value); } void PooledCursor::update(const Slice& key, const Slice& value) { ::mdbx::cursor::update(key, value); } void PooledCursor::append(const Slice& key, const Slice& value) { Slice value_out = value; ::mdbx::error::success_or_throw(::mdbx::cursor::put(key, &value_out, MDBX_put_flags_t::MDBX_APPENDDUP)); } bool PooledCursor::erase() { return ::mdbx::cursor::erase(/*whole_multivalue =*/false); } bool PooledCursor::erase(bool whole_multivalue) { return ::mdbx::cursor::erase(whole_multivalue); } bool PooledCursor::erase(const Slice& key) { return ::mdbx::cursor::erase(key, /*whole_multivalue =*/true); } bool PooledCursor::erase(const Slice& key, bool whole_multivalue) { return ::mdbx::cursor::erase(key, whole_multivalue); } bool PooledCursor::erase(const Slice& key, const Slice& value) { return ::mdbx::cursor::erase(key, value); } bool has_map(::mdbx::txn& tx, std::string_view map_name) { try { ::mdbx::map_handle main_map{1}; auto main_cursor{tx.open_cursor(main_map)}; auto found{main_cursor.seek(::mdbx::slice(map_name))}; return found; } catch (const std::exception&) { return false; } } std::vector list_maps(::mdbx::txn& tx, bool throw_notfound) { std::vector map_names; ::mdbx::map_handle main_map{1}; auto main_cursor{tx.open_cursor(main_map)}; for (auto it{main_cursor.to_first(throw_notfound)}; it.done; it = main_cursor.to_next(throw_notfound)) { map_names.push_back(it.key.as_string()); } return map_names; } size_t cursor_for_each(ROCursor& cursor, WalkFuncRef walker, const CursorMoveDirection direction) { size_t ret{0}; auto data{adjust_cursor_position_if_unpositioned(cursor, direction)}; while (data) { ++ret; walker(from_slice(data.key), from_slice(data.value)); data = cursor.move(move_operation(direction), /*throw_notfound=*/false); } return ret; } size_t cursor_for_prefix(ROCursor& cursor, const ByteView prefix, WalkFuncRef walker, CursorMoveDirection direction) { size_t ret{0}; auto data{cursor.lower_bound(prefix, false)}; while (data) { if (!data.key.starts_with(prefix)) { break; } ++ret; walker(from_slice(data.key), from_slice(data.value)); data = cursor.move(move_operation(direction), /*throw_notfound=*/false); } return ret; } size_t cursor_erase_prefix(RWCursor& cursor, const ByteView prefix) { size_t ret{0}; auto data{cursor.lower_bound(prefix, /*throw_notfound=*/false)}; while (data) { if (!data.key.starts_with(prefix)) { break; } ++ret; cursor.erase(); data = cursor.to_next(/*throw_notfound=*/false); } return ret; } size_t cursor_for_count(ROCursor& cursor, WalkFuncRef walker, size_t count, const CursorMoveDirection direction) { size_t ret{0}; auto data{adjust_cursor_position_if_unpositioned(cursor, direction)}; while (count && data.done) { ++ret; --count; walker(from_slice(data.key), from_slice(data.value)); data = cursor.move(move_operation(direction), /*throw_notfound=*/false); } return ret; } size_t cursor_erase(RWCursor& cursor, const ByteView set_key, const CursorMoveDirection direction) { CursorResult data{ direction == CursorMoveDirection::kForward ? cursor.lower_bound(set_key, /*throw_notfound=*/false) : strict_lower_bound(cursor, set_key)}; size_t ret{0}; while (data) { ++ret; cursor.erase(); data = cursor.move(move_operation(direction), /*throw_notfound=*/false); } return ret; } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/mdbx.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wimplicit-fallthrough" #pragma GCC diagnostic ignored "-Wold-style-cast" #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include namespace silkworm::datastore::kvdb { inline constexpr std::string_view kDbDataFileName{"mdbx.dat"}; inline constexpr size_t kMdbxMaxPages{2147483648ull}; using MoveOperation = ::mdbx::cursor::move_operation; using CursorResult = ::mdbx::pair_result; using MoveResult = ::mdbx::cursor::move_result; using Slice = ::mdbx::slice; //! Comparison operator for CursorResult taking care to compare keys and values only *after* //! checking the `done` flag to avoid comparing uninitialized key/value slices inline bool operator==(const CursorResult& lhs, const CursorResult& rhs) noexcept { if (lhs.done != rhs.done) return false; if (lhs.done) { if (lhs.key && rhs.key && lhs.key != rhs.key) { return false; } if (lhs.value && rhs.value) { return lhs.value == rhs.value; } } return true; } namespace detail { struct CursorHandleDeleter { // default deleter for pooled cursors constexpr CursorHandleDeleter() noexcept = default; void operator()(MDBX_cursor* ptr) const noexcept { mdbx_cursor_close(ptr); } }; std::string dump_mdbx_result(const CursorResult& result); std::string slice_as_hex(const Slice& data); } // namespace detail class ROTxn; struct MapConfig; //! \brief Read-only key-value cursor for single-value tables class ROCursor { public: virtual ~ROCursor() = default; //! \brief Reuse current cursor binding it to provided transaction and map configuration virtual void bind(ROTxn& txn, const MapConfig& config) = 0; //! \brief Clone cursor position and state virtual std::unique_ptr clone() = 0; //! \brief Returns the size of the underlying table virtual size_t size() const = 0; //! \brief Returns whether the underlying table is empty bool empty() const { return size() == 0; } //! \brief Flag indicating if table is single-value or multi-value virtual bool is_multi_value() const = 0; //! \brief Flag indicating if cursor has been positioned or not virtual bool is_dangling() const = 0; //! \brief Escape hatch returning the underlying MDBX map handle virtual ::mdbx::map_handle map() const = 0; virtual CursorResult to_first() = 0; virtual CursorResult to_first(bool throw_notfound) = 0; virtual CursorResult to_previous() = 0; virtual CursorResult to_previous(bool throw_notfound) = 0; virtual CursorResult current() const = 0; virtual CursorResult current(bool throw_notfound) const = 0; virtual CursorResult to_next() = 0; virtual CursorResult to_next(bool throw_notfound) = 0; virtual CursorResult to_last() = 0; virtual CursorResult to_last(bool throw_notfound) = 0; virtual CursorResult find(const Slice& key) = 0; virtual CursorResult find(const Slice& key, bool throw_notfound) = 0; virtual CursorResult lower_bound(const Slice& key) = 0; virtual CursorResult lower_bound(const Slice& key, bool throw_notfound) = 0; virtual MoveResult move(MoveOperation operation, bool throw_notfound) = 0; virtual MoveResult move(MoveOperation operation, const Slice& key, bool throw_notfound) = 0; virtual bool seek(const Slice& key) = 0; virtual bool eof() const = 0; virtual bool on_first() const = 0; virtual bool on_last() const = 0; }; //! \brief Read-only key-value cursor for multi-value tables class ROCursorDupSort : public virtual ROCursor { public: ~ROCursorDupSort() override = default; virtual CursorResult to_previous_last_multi() = 0; virtual CursorResult to_previous_last_multi(bool throw_notfound) = 0; virtual CursorResult to_current_first_multi() = 0; virtual CursorResult to_current_first_multi(bool throw_notfound) = 0; virtual CursorResult to_current_prev_multi() = 0; virtual CursorResult to_current_prev_multi(bool throw_notfound) = 0; virtual CursorResult to_current_next_multi() = 0; virtual CursorResult to_current_next_multi(bool throw_notfound) = 0; virtual CursorResult to_current_last_multi() = 0; virtual CursorResult to_current_last_multi(bool throw_notfound) = 0; virtual CursorResult to_next_first_multi() = 0; virtual CursorResult to_next_first_multi(bool throw_notfound) = 0; virtual CursorResult find_multivalue(const Slice& key, const Slice& value) = 0; virtual CursorResult find_multivalue(const Slice& key, const Slice& value, bool throw_notfound) = 0; virtual CursorResult lower_bound_multivalue(const Slice& key, const Slice& value) = 0; virtual CursorResult lower_bound_multivalue(const Slice& key, const Slice& value, bool throw_notfound) = 0; MoveResult move(MoveOperation operation, bool throw_notfound) override = 0; MoveResult move(MoveOperation operation, const Slice& key, bool throw_notfound) override = 0; virtual MoveResult move(MoveOperation operation, const Slice& key, const Slice& value, bool throw_notfound) = 0; virtual size_t count_multivalue() const = 0; }; //! \brief Read-write key-value cursor for single-value tables class RWCursor : public virtual ROCursor { public: ~RWCursor() override = default; virtual MDBX_error_t put(const Slice& key, Slice* value, MDBX_put_flags_t flags) noexcept = 0; virtual void insert(const Slice& key, Slice value) = 0; virtual void upsert(const Slice& key, const Slice& value) = 0; virtual void update(const Slice& key, const Slice& value) = 0; //! \brief Remove single key-value pair at the current cursor position. virtual bool erase() = 0; virtual bool erase(bool whole_multivalue) = 0; //! \brief Seek and remove first value of the given key. //! \return true if the key is found and a value(s) is removed. virtual bool erase(const Slice& key) = 0; virtual bool erase(const Slice& key, bool whole_multivalue) = 0; }; //! \brief Read-write key-value cursor for multi-value tables class RWCursorDupSort : public RWCursor, public ROCursorDupSort { public: ~RWCursorDupSort() override = default; virtual void append(const Slice& key, const Slice& value) = 0; //! \brief Remove all multi-values at the current cursor position. bool erase() override = 0; bool erase(bool whole_multivalue) override = 0; //! \brief Seek and remove whole multi-value of the given key. //! \return true if the key is found and a value(s) is removed. bool erase(const Slice& key) override = 0; bool erase(const Slice& key, bool whole_multivalue) override = 0; //! \brief Seek and remove the particular multi-value entry of the key. //! \return true if the given key-value pair is found and removed virtual bool erase(const Slice& key, const Slice& value) = 0; }; //! \brief Configuration settings for a "map" (aka a table) struct MapConfig { const std::string_view name{}; // Name of the table (is key in MAIN_DBI) const ::mdbx::key_mode key_mode{::mdbx::key_mode::usual}; // Key collation order const ::mdbx::value_mode value_mode{::mdbx::value_mode::single}; // Data Storage Mode std::string name_str() const { return std::string{name}; } }; //! \brief ROTxn represents a read-only transaction. //! It is used in function signatures to clarify that read-only access is sufficient, read-write access is not required. class ROTxn { public: virtual ~ROTxn() = default; // Access to the underling raw mdbx transaction mdbx::txn& operator*() { return txn_ref_; } mdbx::txn* operator->() { return &txn_ref_; } operator mdbx::txn&() { return txn_ref_; } // NOLINT(google-explicit-constructor, hicpp-explicit-conversions) uint64_t id() const { return txn_ref_.id(); } virtual bool is_open() const { return txn_ref_.txn::operator bool(); } virtual mdbx::env db() const { return txn_ref_.env(); } virtual std::unique_ptr ro_cursor(const MapConfig& config); virtual std::unique_ptr ro_cursor_dup_sort(const MapConfig& config); virtual void abort() = 0; protected: explicit ROTxn(::mdbx::txn& txn_ref) : txn_ref_{txn_ref} {} private: ::mdbx::txn& txn_ref_; }; //! \brief ROTxnManaged wraps a *managed* read-only transaction, which means the underlying transaction lifecycle //! is entirely managed by this class. class ROTxnManaged : public ROTxn { public: explicit ROTxnManaged() : ROTxn{managed_txn_} {} explicit ROTxnManaged(mdbx::env& env) : ROTxn{managed_txn_}, managed_txn_{env.start_read()} {} explicit ROTxnManaged(mdbx::env&& env) : ROTxn{managed_txn_}, managed_txn_{std::move(env).start_read()} {} ~ROTxnManaged() override = default; // Not copyable ROTxnManaged(const ROTxnManaged&) = delete; ROTxnManaged& operator=(const ROTxnManaged&) = delete; // Only movable ROTxnManaged(ROTxnManaged&& source) noexcept : ROTxn{managed_txn_}, managed_txn_{std::move(source.managed_txn_)} {} ROTxnManaged& operator=(ROTxnManaged&& other) noexcept { managed_txn_ = std::move(other.managed_txn_); return *this; } void abort() override { managed_txn_.abort(); } protected: explicit ROTxnManaged(mdbx::txn_managed&& source) : ROTxn{managed_txn_}, managed_txn_{std::move(source)} {} mdbx::txn_managed managed_txn_; }; //! \brief ROTxnUnmanaged wraps an *unmanaged* read-only transaction, which means the underlying transaction //! lifecycle is not touched by this class. This implies that this class does not abort the transaction. class ROTxnUnmanaged : public ROTxn, protected ::mdbx::txn { public: explicit ROTxnUnmanaged(MDBX_txn* ptr) : ROTxn{static_cast<::mdbx::txn&>(*this)}, ::mdbx::txn{ptr} {} ~ROTxnUnmanaged() override = default; void abort() override {} }; //! \brief This class wraps a read-write transaction. //! It is used in function signatures to clarify that read-write access is required. //! It supports explicit disable/enable of commit capabilities. //! Disabling commit is useful for running several stages on a handful of blocks atomically. class RWTxn : public ROTxn { public: ~RWTxn() override = default; bool commit_disabled() const { return commit_disabled_; } void disable_commit() { commit_disabled_ = true; } void enable_commit() { commit_disabled_ = false; } virtual std::unique_ptr rw_cursor(const MapConfig& config); virtual std::unique_ptr rw_cursor_dup_sort(const MapConfig& config); virtual void commit_and_renew() = 0; virtual void commit_and_stop() = 0; protected: explicit RWTxn(::mdbx::txn& txn_ref, bool commit_disabled = false) : ROTxn{txn_ref}, commit_disabled_{commit_disabled} {} bool commit_disabled_; }; //! \brief RWTxnManaged wraps a *managed* read-write transaction, which means the underlying transaction lifecycle //! is entirely managed by this class. class RWTxnManaged : public RWTxn { public: explicit RWTxnManaged() : RWTxn{managed_txn_} {} explicit RWTxnManaged(mdbx::env& env) : RWTxn{managed_txn_}, managed_txn_{env.start_write()} {} explicit RWTxnManaged(mdbx::env&& env) : RWTxn{managed_txn_}, managed_txn_{std::move(env).start_write()} {} ~RWTxnManaged() override = default; // Not copyable RWTxnManaged(const RWTxnManaged&) = delete; RWTxnManaged& operator=(const RWTxnManaged&) = delete; // Only movable RWTxnManaged(RWTxnManaged&& source) noexcept : RWTxn{managed_txn_, source.commit_disabled_}, managed_txn_{std::move(source.managed_txn_)} {} RWTxnManaged& operator=(RWTxnManaged&& other) noexcept { commit_disabled_ = other.commit_disabled_; managed_txn_ = std::move(other.managed_txn_); return *this; } void abort() override { managed_txn_.abort(); } void commit_and_renew() override; void commit_and_stop() override; void reopen(mdbx::env& env) { managed_txn_ = env.start_write(); } protected: explicit RWTxnManaged(mdbx::txn_managed&& source) : RWTxn{managed_txn_}, managed_txn_{std::move(source)} {} mdbx::txn_managed managed_txn_; }; //! \brief RWTxnUnmanaged wraps an *unmanaged* read-write transaction, which means the underlying transaction //! lifecycle is not touched by this class: the transaction is neither committed nor aborted. class RWTxnUnmanaged : public RWTxn, protected ::mdbx::txn { public: explicit RWTxnUnmanaged(MDBX_txn* ptr) : RWTxn{static_cast<::mdbx::txn&>(*this)}, ::mdbx::txn{ptr} {} ~RWTxnUnmanaged() override = default; void abort() override { throw std::runtime_error{"RWTxnUnmanaged must not be aborted"}; } void commit_and_renew() override { throw std::runtime_error{"RWTxnUnmanaged must not be committed"}; } void commit_and_stop() override { throw std::runtime_error{"RWTxnUnmanaged must not be committed"}; } }; //! \brief This class create ROTxn(s) on demand, it is used to enforce in some method signatures the type of db access class ROAccess { public: explicit ROAccess(const mdbx::env& env) : env_{env} {} explicit ROAccess(mdbx::env&& env) : env_{std::move(env)} {} ROAccess(const ROAccess&) noexcept = default; ROAccess(ROAccess&&) noexcept = default; ROTxnManaged start_ro_tx() { return ROTxnManaged(env_); } mdbx::env& operator*() { return env_; } protected: mdbx::env env_; }; //! \brief This class create RWTxn(s) on demand, it is used to enforce in some method signatures the type of db access class RWAccess : public ROAccess { public: explicit RWAccess(const mdbx::env& env) : ROAccess{env} {} explicit RWAccess(mdbx::env&& env) : ROAccess{std::move(env)} {} RWAccess(const RWAccess&) noexcept = default; RWAccess(RWAccess&&) noexcept = default; RWTxnManaged start_rw_tx() { return RWTxnManaged(env_); } }; //! \brief Reference to a processing function invoked by cursor_for_each & cursor_for_count on each record using WalkFuncRef = absl::FunctionRef; //! \brief Essential environment settings struct EnvConfig { std::string path{}; bool create{false}; // Whether db file must be created bool readonly{false}; // Whether db should be opened in RO mode bool exclusive{false}; // Whether this process has exclusive access bool in_memory{false}; // Whether this db is in memory bool shared{false}; // Whether this process opens a db already opened by another process bool read_ahead{false}; // Whether to enable mdbx read ahead bool write_map{false}; // Whether to enable mdbx write map size_t page_size{os::page_size()}; // Mdbx page size size_t max_size{4_Tebi}; // Mdbx max map size size_t growth_size{2_Gibi}; // Increment size for each extension uint32_t max_tables{256}; // Default max number of named tables uint32_t max_readers{100}; // Default max number of readers }; //! \brief EnvUnmanaged wraps an *unmanaged* MDBX environment, which means the underlying environment //! lifecycle is not touched by this class. struct EnvUnmanaged : public ::mdbx::env { explicit EnvUnmanaged(MDBX_env* ptr) : ::mdbx::env{ptr} {} }; //! \brief Opens an mdbx environment using the provided environment config //! \param [in] config : A structure containing essential environment settings //! \return A handler to mdbx::env_managed class //! \remarks May throw exceptions ::mdbx::env_managed open_env(const EnvConfig& config); //! \brief Opens an mdbx "map" (aka table) //! \param [in] tx : a reference to a valid mdbx transaction //! \param [in] config : the configuration settings for the map //! \return A handle to the opened map ::mdbx::map_handle open_map(::mdbx::txn& tx, const MapConfig& config); //! \brief Opens a cursor to an mdbx "map" (aka table) //! \param [in] tx : a reference to a valid mdbx transaction //! \param [in] config : the configuration settings for the underlying map //! \return A handle to the opened cursor ::mdbx::cursor_managed open_cursor(::mdbx::txn& tx, const MapConfig& config); //! \brief Computes the max size of single-value data to fit into a leaf data page //! \param [in] page_size : the actually configured MDBX page size //! \param [in] key_size : the known key size to fit in bundle computed value size size_t max_value_size_for_leaf_page(size_t page_size, size_t key_size); //! \brief Computes the max size of single-value data to fit into a leaf data page //! \param [in] txn : the transaction used to derive pagesize from //! \param [in] key_size : the known key size to fit in bundle computed value size size_t max_value_size_for_leaf_page(const ::mdbx::txn& txn, size_t key_size); //! \brief Managed cursor class to access cursor API //! \remarks Unlike ::mdbx::cursor_managed this class withdraws and deposits allocated MDBX_cursor handles in a //! thread-local pool for reuse. This helps avoiding multiple malloc on cursor creation. class PooledCursor : public RWCursorDupSort, protected ::mdbx::cursor { public: explicit PooledCursor(); explicit PooledCursor(ROTxn& txn, ::mdbx::map_handle map); explicit PooledCursor(::mdbx::txn& txn, const MapConfig& config); explicit PooledCursor(ROTxn& txn, const MapConfig& config) : PooledCursor(*txn, config) {} ~PooledCursor() override; PooledCursor(PooledCursor&& other) noexcept; PooledCursor& operator=(PooledCursor&& other) noexcept; PooledCursor(const PooledCursor&) = delete; PooledCursor& operator=(const PooledCursor&) = delete; //! \brief Reuse current cursor binding it to provided transaction and map void bind(ROTxn& txn, ::mdbx::map_handle map); //! \brief Reuse current cursor binding it to provided transaction and map configuration void bind(::mdbx::txn& txn, const MapConfig& config); void bind(ROTxn& txn, const MapConfig& config) override { bind(*txn, config); } std::unique_ptr clone() override; //! \brief Closes cursor causing de-allocation of MDBX_cursor handle //! \remarks After this call the cursor is not reusable and the handle does not return to the cache void close(); //! \brief Returns stat info of underlying dbi MDBX_stat get_map_stat() const; //! \brief Returns flags of underlying dbi MDBX_db_flags_t get_map_flags() const; //! \brief Returns the size of the underlying table size_t size() const override; using ::mdbx::cursor::operator bool; bool is_multi_value() const override; bool is_dangling() const override; ::mdbx::map_handle map() const override; CursorResult to_first() override; CursorResult to_first(bool throw_notfound) override; CursorResult to_previous() override; CursorResult to_previous(bool throw_notfound) override; CursorResult current() const override; CursorResult current(bool throw_notfound) const override; CursorResult to_next() override; CursorResult to_next(bool throw_notfound) override; CursorResult to_last() override; CursorResult to_last(bool throw_notfound) override; CursorResult find(const Slice& key) override; CursorResult find(const Slice& key, bool throw_notfound) override; CursorResult lower_bound(const Slice& key) override; CursorResult lower_bound(const Slice& key, bool throw_notfound) override; MoveResult move(MoveOperation operation, bool throw_notfound) override; MoveResult move(MoveOperation operation, const Slice& key, bool throw_notfound) override; bool seek(const Slice& key) override; bool eof() const override; bool on_first() const override; bool on_last() const override; CursorResult to_previous_last_multi() override; CursorResult to_previous_last_multi(bool throw_notfound) override; CursorResult to_current_first_multi() override; CursorResult to_current_first_multi(bool throw_notfound) override; CursorResult to_current_prev_multi() override; CursorResult to_current_prev_multi(bool throw_notfound) override; CursorResult to_current_next_multi() override; CursorResult to_current_next_multi(bool throw_notfound) override; CursorResult to_current_last_multi() override; CursorResult to_current_last_multi(bool throw_notfound) override; CursorResult to_next_first_multi() override; CursorResult to_next_first_multi(bool throw_notfound) override; CursorResult find_multivalue(const Slice& key, const Slice& value) override; CursorResult find_multivalue(const Slice& key, const Slice& value, bool throw_notfound) override; CursorResult lower_bound_multivalue(const Slice& key, const Slice& value) override; CursorResult lower_bound_multivalue(const Slice& key, const Slice& value, bool throw_notfound) override; MoveResult move(MoveOperation operation, const Slice& key, const Slice& value, bool throw_notfound) override; size_t count_multivalue() const override; MDBX_error_t put(const Slice& key, Slice* value, MDBX_put_flags_t flags) noexcept override; void insert(const Slice& key, Slice value) override; void upsert(const Slice& key, const Slice& value) override; void update(const Slice& key, const Slice& value) override; void append(const Slice& key, const Slice& value) override; bool erase() override; bool erase(bool whole_multivalue) override; bool erase(const Slice& key) override; bool erase(const Slice& key, bool whole_multivalue) override; bool erase(const Slice& key, const Slice& value) override; //! \brief Exposes handles cache static const ObjectPool& handles_cache() { return handles_pool_; } private: static thread_local ObjectPool handles_pool_; }; //! \brief Checks whether a provided map name exists in database //! \param [in] tx : a reference to a valid mdbx transaction //! \param [in] map_name : the name of the map to check for //! \return True / False bool has_map(::mdbx::txn& tx, std::string_view map_name); //! \brief List the names of the existing maps in database //! \param [in] tx : a reference to a valid mdbx transaction //! \return the sequence of map names std::vector list_maps(::mdbx::txn& tx, bool throw_notfound = false); //! \brief Builds the full path to mdbx datafile provided a directory //! \param [in] base_path : a reference to the directory holding the data file //! \return A path with file name inline std::filesystem::path get_datafile_path(const std::filesystem::path& base_path) noexcept { return std::filesystem::path(base_path / std::filesystem::path(kDbDataFileName)); } //! \brief Defines the direction of cursor while looping by cursor_for_each or cursor_for_count enum class CursorMoveDirection : uint8_t { kForward, kReverse }; //! \brief Executes a function on each record reachable by the provided cursor //! \param [in] cursor : A reference to a cursor opened on a map //! \param [in] walker : A reference to a function with the code to execute on records. Note the return value of the //! function may stop the loop //! \param [in] direction : Whether the cursor should navigate records forward (default) or backwards //! \return The overall number of processed records //! \remarks If the provided cursor is *not* positioned on any record it will be moved to either the beginning or the //! end of the table on behalf of the move criteria size_t cursor_for_each(ROCursor& cursor, WalkFuncRef walker, CursorMoveDirection direction = CursorMoveDirection::kForward); //! \brief Executes a function on each record reachable by the provided cursor asserting keys start with provided prefix //! \param [in] cursor : A reference to a cursor opened on a map //! \param [in] prefix : The prefix each key must start with //! \param [in] walker : A reference to a function with the code to execute on records. Note the return value of the //! function may stop the loop //! \param [in] direction : Whether the cursor should navigate records forward (default) or backwards //! \return The overall number of processed records size_t cursor_for_prefix(ROCursor& cursor, ByteView prefix, WalkFuncRef walker, CursorMoveDirection direction = CursorMoveDirection::kForward); //! \brief Executes a function on each record reachable by the provided cursor up to a max number of iterations //! \param [in] cursor : A reference to a cursor opened on a map //! \param [in] walker : A reference to a function with the code to execute on records. Note the return value of the //! function may stop the loop //! \param [in] max_count : Max number of iterations //! \param [in] direction : Whether the cursor should navigate records forward (default) or backwards //! \return The overall number of processed records. Should it not match the value of max_count it means the cursor has //! reached either the end or the beginning of table earlier //! \remarks If the provided cursor is *not* positioned on any record it will be moved to either the beginning or the //! end of the table on behalf of the move criteria size_t cursor_for_count(ROCursor& cursor, WalkFuncRef walker, size_t max_count, CursorMoveDirection direction = CursorMoveDirection::kForward); //! \brief Erases map records by cursor until any record is found //! \param [in] cursor : A reference to a cursor opened on a map //! \param [in] set_key : The key where to set the cursor to. //! \param [in] direction : Whether the cursor should navigate records forward (default) or backwards. //! \return The overall number of erased records //! \remarks When direction is forward all keys greater equal set_key will be deleted. When direction is reverse all //! keys lower than set_key will be deleted. size_t cursor_erase(RWCursor& cursor, ByteView set_key, CursorMoveDirection direction = CursorMoveDirection::kForward); //! \brief Erases all records whose key starts with a prefix //! \param [in] cursor : A reference to a cursor opened on a map //! \param [in] prefix : Delete keys starting with this prefix size_t cursor_erase_prefix(RWCursor& cursor, ByteView prefix); inline Slice to_slice(ByteView value) { return {value.data(), value.size()}; } inline ByteView from_slice(const Slice slice) { return {static_cast(slice.data()), slice.length()}; } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/mdbx_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "mdbx.hpp" #include #include #include namespace silkworm::datastore::kvdb { TEST_CASE("open_env") { // Empty dir std::string empty{}; EnvConfig db_config{empty}; db_config.in_memory = true; REQUIRE_THROWS_AS(open_env(db_config), std::invalid_argument); // Conflicting flags TemporaryDirectory tmp_dir1; DataDirectory data_dir{tmp_dir1.path()}; REQUIRE_NOTHROW(data_dir.deploy()); REQUIRE(data_dir.exists()); db_config.path = data_dir.chaindata().path().string(); db_config.create = true; db_config.shared = true; REQUIRE_THROWS_AS(open_env(db_config), std::runtime_error); // Must open db_config.shared = false; ::mdbx::env_managed env; REQUIRE_NOTHROW(env = open_env(db_config)); // Create in same path not allowed ::mdbx::env_managed env2; REQUIRE_THROWS(env2 = open_env(db_config)); env.close(); // Conflicting flags TemporaryDirectory tmp_dir2; db_config = EnvConfig{tmp_dir2.path().string()}; db_config.create = true; db_config.readonly = true; db_config.in_memory = true; REQUIRE_THROWS_AS(open_env(db_config), std::runtime_error); // Must open db_config.readonly = false; db_config.exclusive = true; REQUIRE_NOTHROW(env = open_env(db_config)); env.close(); } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/mdbx_version.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "mdbx_version.hpp" #include #include #include #include #include "mdbx.hpp" namespace silkworm::datastore::kvdb { const char* libmdbx_version() noexcept { return ::mdbx::get_version().git.describe; } bool is_compatible_mdbx_version(std::string_view their_version, std::string_view our_version, MdbxVersionCheck check) { SILK_TRACE << "is_compatible_mdbx_version their_version: " << their_version << " our_version: " << our_version; bool compatible{false}; switch (check) { case MdbxVersionCheck::kNone: { compatible = true; } break; case MdbxVersionCheck::kExact: { compatible = their_version == our_version; } break; case MdbxVersionCheck::kSemantic: { const std::vector their_version_parts = absl::StrSplit(std::string(their_version), '.'); const std::vector our_version_parts = absl::StrSplit(std::string(our_version), '.'); compatible = (their_version_parts.size() >= 3) && (our_version_parts.size() >= 3) && (their_version_parts[0] == our_version_parts[0]) && (their_version_parts[1] == our_version_parts[1]) && (their_version_parts[2] == our_version_parts[2]); } } return compatible; } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/mdbx_version.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::datastore::kvdb { /** * \brief Get libmdbx version for compatibility checks. * \return A string in git describe format. */ const char* libmdbx_version() noexcept; //! Kind of match to perform between Erigon and Silkworm libmdbx versions enum class MdbxVersionCheck : uint8_t { kNone, /// no check at all kExact, /// git-describe versions must match perfectly kSemantic, /// compare semantic versions ( == ) }; bool is_compatible_mdbx_version(std::string_view their_version, std::string_view our_version, MdbxVersionCheck check); } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/memory_mutation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "memory_mutation.hpp" #include #include #include #include "memory_mutation_cursor.hpp" namespace silkworm::datastore::kvdb { MemoryDatabase::MemoryDatabase(const std::filesystem::path& tmp_dir) { DataDirectory data_dir{tmp_dir}; data_dir.deploy(); EnvConfig memory_config{ .path = data_dir.chaindata().path().string(), .create = true, .exclusive = true, .in_memory = true, .max_size = 512_Mebi, }; memory_env_ = open_env(memory_config); } MemoryDatabase::MemoryDatabase() : MemoryDatabase(TemporaryDirectory::get_unique_temporary_path()) {} ::mdbx::txn_managed MemoryDatabase::start_rw_txn() { return memory_env_.start_write(); } MemoryOverlay::MemoryOverlay( const std::filesystem::path& tmp_dir, ROTxn* txn, std::function(std::string_view map_name)> get_map_config, std::string_view sequence_map_name) : memory_db_(tmp_dir), txn_(txn), get_map_config_(std::move(get_map_config)), sequence_map_name_(sequence_map_name) {} void MemoryOverlay::update_txn(ROTxn* txn) { txn_ = txn; } ::mdbx::txn_managed MemoryOverlay::start_rw_txn() { return memory_db_.start_rw_txn(); } std::optional MemoryOverlay::map_config(std::string_view map_name) { return get_map_config_(map_name); } MapConfig MemoryOverlay::sequence_map_config() { return *map_config(sequence_map_name_); } MemoryMutation::MemoryMutation(MemoryOverlay& overlay) : RWTxnManaged(overlay.start_rw_txn()), overlay_(overlay) { // Initialize sequences const auto sequence_map_config = overlay.sequence_map_config(); PooledCursor cursor{*overlay_.external_txn(), sequence_map_config}; PooledCursor memory_cursor{managed_txn_, sequence_map_config}; for (auto result = cursor.to_first(false); result; result = cursor.to_next(false)) { memory_cursor.put(result.key, &result.value, MDBX_put_flags_t::MDBX_UPSERT); } } MemoryMutation::~MemoryMutation() { rollback(); } void MemoryMutation::reopen() { managed_txn_ = overlay_.start_rw_txn(); } bool MemoryMutation::is_table_cleared(std::string_view table) const { return cleared_tables_.contains(std::string{table}); } bool MemoryMutation::is_entry_deleted(std::string_view table_view, const Slice& key) const { std::string table{table_view}; if (!deleted_entries_.contains(table)) { return false; } const auto& deleted_slices = deleted_entries_.at(table); return deleted_slices.find(key) != deleted_slices.cend(); } bool MemoryMutation::is_dup_deleted(std::string_view table, const Slice& key, const Slice& value) const { auto const deleted_table = deleted_dups_.find(std::string{table}); if (deleted_table == deleted_dups_.end()) { return false; } auto const deleted_key = deleted_table->second.find(key); if (deleted_key == deleted_table->second.end()) { return false; } auto const deleted_value = deleted_key->second.find(value); return deleted_value != deleted_key->second.end(); } bool MemoryMutation::has_map(std::string_view bucket_name) const { return datastore::kvdb::has_map(*overlay_.external_txn(), bucket_name); } void MemoryMutation::update_txn(ROTxn* txn) { overlay_.update_txn(txn); } std::unique_ptr MemoryMutation::ro_cursor(const MapConfig& config) { return make_cursor(config); } std::unique_ptr MemoryMutation::ro_cursor_dup_sort(const MapConfig& config) { return make_cursor(config); } std::unique_ptr MemoryMutation::rw_cursor(const MapConfig& config) { return make_cursor(config); } std::unique_ptr MemoryMutation::rw_cursor_dup_sort(const MapConfig& config) { return make_cursor(config); } bool MemoryMutation::erase(const MapConfig& config, const Slice& key) { deleted_entries_[config.name_str()][key] = true; const auto handle{managed_txn_.open_map(config.name_str(), config.key_mode, config.value_mode)}; return managed_txn_.erase(handle, key); } bool MemoryMutation::erase(const MapConfig& config, const Slice& key, const Slice& value) { deleted_dups_[config.name_str()][key][value] = true; const auto handle{managed_txn_.open_map(config.name_str(), config.key_mode, config.value_mode)}; return managed_txn_.erase(handle, key, value); } void MemoryMutation::upsert(const MapConfig& config, const Slice& key, const Slice& value) { if (static_cast(config.value_mode) & MDBX_db_flags_t::MDBX_DUPSORT) { if (is_dup_deleted(config.name, key, value)) { deleted_dups_[config.name_str()][key].erase(value); } } else { if (is_entry_deleted(config.name_str(), key)) { deleted_entries_[config.name_str()].erase(key); } } const auto handle{managed_txn_.open_map(config.name_str(), config.key_mode, config.value_mode)}; managed_txn_.upsert(handle, key, value); } bool MemoryMutation::clear_table(std::string_view table_view) { std::string table{table_view}; cleared_tables_[table] = true; return managed_txn_.clear_map(table, /*throw_if_absent=*/false); } void MemoryMutation::flush(RWTxn& rw_txn) { reopen(); // Obliterate buckets that need to be deleted for (const auto& [table, _] : cleared_tables_) { rw_txn->clear_map(table); } // Obliterate entries that need to be deleted for (const auto& [table, keys] : this->deleted_entries_) { const auto table_config = overlay_.map_config(table); if (!table_config) { SILK_WARN << "Unknown table " << table << " in memory mutation, ignored"; continue; } const auto map_handle = open_map(rw_txn, *table_config); for (const auto& [key, _] : keys) { rw_txn->erase(map_handle, key); } } // Obliterate dups that need to be deleted for (const auto& [table, keys] : this->deleted_dups_) { const auto table_config = overlay_.map_config(table); if (!table_config) { SILK_WARN << "Unknown table " << table << " in memory mutation, ignored"; continue; } const auto map_handle = open_map(rw_txn, *table_config); for (const auto& [key, vals] : keys) { for (const auto& [val, _] : vals) { rw_txn->erase(map_handle, key, val); } } } // Iterate over each touched bucket and apply changes accordingly const auto tables = list_maps(managed_txn_); for (const auto& table : tables) { const auto table_config = overlay_.map_config(table); if (!table_config) { SILK_WARN << "Unknown table " << table << " in memory mutation, ignored"; continue; } const auto mem_cursor = make_cursor(*table_config); const auto db_cursor = rw_txn.rw_cursor_dup_sort(*table_config); SILK_TRACE << "Apply memory mutation changes for table: " << table_config->name; auto mem_cursor_result = mem_cursor->to_first(/*throw_notfound =*/false); while (mem_cursor_result.done) { const auto& mem_key = mem_cursor_result.key; const auto& mem_value = mem_cursor_result.value; db_cursor->upsert(mem_key, mem_value); SILK_TRACE << "Memory mutation change key: " << mem_key.as_string() << " value: " << mem_value.as_string(); mem_cursor_result = mem_cursor->to_next(/*throw_notfound =*/false); } } rollback(); } void MemoryMutation::rollback() { // Idempotent rollback: abort iff transaction is still alive (i.e. handle is not null) if (managed_txn_) { managed_txn_.abort(); } } std::unique_ptr MemoryMutation::make_cursor(const MapConfig& config) { return std::make_unique(*this, config); } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/memory_mutation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "mdbx.hpp" namespace silkworm::datastore::kvdb { class MemoryDatabase { public: explicit MemoryDatabase(const std::filesystem::path& tmp_dir); MemoryDatabase(); MemoryDatabase(MemoryDatabase&& other) noexcept = default; MemoryDatabase& operator=(MemoryDatabase&&) noexcept = default; ::mdbx::txn_managed start_rw_txn(); private: ::mdbx::env_managed memory_env_; }; class MemoryOverlay { public: MemoryOverlay( const std::filesystem::path& tmp_dir, ROTxn* txn, std::function(std::string_view map_name)> get_map_config, std::string_view sequence_map_name); MemoryOverlay(MemoryOverlay&& other) noexcept = default; MemoryOverlay& operator=(MemoryOverlay&&) noexcept = default; ROTxn* external_txn() const { return txn_; } void update_txn(ROTxn* txn); ::mdbx::txn_managed start_rw_txn(); std::optional map_config(std::string_view map_name); MapConfig sequence_map_config(); private: MemoryDatabase memory_db_; ROTxn* txn_; std::function(std::string_view map_name)> get_map_config_; std::string sequence_map_name_; }; class MemoryMutationCursor; class MemoryMutation : public RWTxnManaged { public: explicit MemoryMutation(MemoryOverlay& overlay); MemoryMutation(MemoryMutation&& other) noexcept = default; MemoryMutation& operator=(MemoryMutation&&) noexcept = delete; ~MemoryMutation() override; bool is_table_cleared(std::string_view table) const; bool is_entry_deleted(std::string_view table_view, const Slice& key) const; bool is_dup_deleted(std::string_view table, const Slice& key, const Slice& value) const; bool has_map(std::string_view bucket_name) const; ROTxn* external_txn() const { return overlay_.external_txn(); } void update_txn(ROTxn* txn); std::unique_ptr ro_cursor(const MapConfig& config) override; std::unique_ptr ro_cursor_dup_sort(const MapConfig& config) override; std::unique_ptr rw_cursor(const MapConfig& config) override; std::unique_ptr rw_cursor_dup_sort(const MapConfig& config) override; bool erase(const MapConfig& config, const Slice& key); bool erase(const MapConfig& config, const Slice& key, const Slice& value); void upsert(const MapConfig& config, const Slice& key, const Slice& value); bool clear_table(std::string_view table_view); void flush(RWTxn& rw_txn); void rollback(); void reopen(); private: std::unique_ptr make_cursor(const MapConfig& config); MemoryOverlay& overlay_; std::map> deleted_entries_; std::map>> deleted_dups_; std::map cleared_tables_; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/memory_mutation_cursor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "memory_mutation_cursor.hpp" #include namespace silkworm::datastore::kvdb { MemoryMutationCursor::MemoryMutationCursor(MemoryMutation& memory_mutation, const MapConfig& config) : memory_mutation_(memory_mutation), config_(config), current_db_entry_({}, {}, false), current_memory_entry_({}, {}, false), current_pair_({}, {}, false) { cursor_ = memory_mutation_.external_txn()->ro_cursor_dup_sort(config); memory_cursor_ = std::make_unique(memory_mutation_, config); } bool MemoryMutationCursor::is_table_cleared() const { return memory_mutation_.is_table_cleared(config_.name_str()); } bool MemoryMutationCursor::is_entry_deleted(const Slice& key, const Slice& value) const { if (is_multi_value()) { return memory_mutation_.is_dup_deleted(config_.name, key, value); } return memory_mutation_.is_entry_deleted(config_.name_str(), key); } void MemoryMutationCursor::bind(ROTxn& txn, const MapConfig& config) { memory_mutation_.update_txn(&txn); cursor_->bind(txn, config); memory_cursor_->bind(txn, config); } std::unique_ptr MemoryMutationCursor::clone() { SILKWORM_ASSERT(false); // not implemented return {}; } ::mdbx::map_handle MemoryMutationCursor::map() const { return memory_cursor_->map(); } size_t MemoryMutationCursor::size() const { return cursor_->size(); } bool MemoryMutationCursor::is_multi_value() const { return cursor_->is_multi_value(); } bool MemoryMutationCursor::is_dangling() const { return cursor_->is_dangling(); } CursorResult MemoryMutationCursor::to_first() { return to_first(/*throw_notfound =*/true); } CursorResult MemoryMutationCursor::to_first(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_first(throw_notfound); } const auto memory_result = memory_cursor_->to_first(false); auto db_result = cursor_->to_first(false); // Basic checks current_db_entry_ = db_result.done ? db_result : CursorResult{{}, {}, false}; current_memory_entry_ = memory_result.done ? memory_result : CursorResult{{}, {}, false}; if (memory_result.done) { const auto mem_key = memory_result.key.as_string(); const auto mem_value = memory_result.value.as_string(); SILK_TRACE << "to_first: memory_result.key=" << mem_key << " memory_result.value=" << mem_value; } if (db_result.done) { const auto db_key = db_result.key.as_string(); const auto db_value = db_result.value.as_string(); SILK_TRACE << "to_first: db_result.key=" << db_key << " db_result.value=" << db_value; } if (db_result.done && db_result.key && is_entry_deleted(db_result.key, db_result.value)) { current_pair_ = current_memory_entry_; current_db_entry_ = CursorResult{{}, {}, true}; is_previous_from_db_ = false; if (!memory_result.done && throw_notfound) { throw_error_notfound(); } return memory_result; } if (!db_result.done || (db_result.done && !db_result.value)) { current_pair_ = current_memory_entry_; is_previous_from_db_ = false; if (!memory_result.done && throw_notfound) { throw_error_notfound(); } return memory_result; } if (!memory_result.done || (memory_result.done && !memory_result.value)) { current_pair_ = current_db_entry_; is_previous_from_db_ = true; if (!db_result.done && throw_notfound) { throw_error_notfound(); } SILK_TRACE << "to_first: db_key=" << db_result.key.as_string() << " db_value=" << db_result.value.as_string(); return db_result; } // Determine which one is first const auto key_diff = Slice::compare_fast(memory_result.key, db_result.key); if (key_diff == 0) { // memory_result.key == db_result.key if (memory_result.value < db_result.value) { current_pair_ = current_memory_entry_; is_previous_from_db_ = false; return memory_result; } current_pair_ = current_db_entry_; is_previous_from_db_ = true; return db_result; } if (key_diff < 0) { // memory_result.key < db_result.key current_pair_ = current_memory_entry_; is_previous_from_db_ = false; return memory_result; } // memory_result.key > db_result.key current_pair_ = current_db_entry_; is_previous_from_db_ = true; return db_result; } CursorResult MemoryMutationCursor::to_previous() { return to_previous(/*throw_notfound =*/true); } CursorResult MemoryMutationCursor::to_previous(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_previous(throw_notfound); } const auto memory_result = memory_cursor_->to_previous(false); auto db_result = cursor_->to_previous(false); db_result = skip_intersection(memory_result, db_result, MoveType::kPrevious); // Basic checks current_db_entry_ = db_result.done ? db_result : CursorResult{{}, {}, false}; current_memory_entry_ = memory_result.done ? memory_result : CursorResult{{}, {}, false}; if (memory_result.done) { const auto mem_key = memory_result.key.as_string(); const auto mem_value = memory_result.value.as_string(); SILK_TRACE << "to_previous: memory_result.key=" << mem_key << " memory_result.value=" << mem_value; } if (db_result.done) { const auto db_key = db_result.key.as_string(); const auto db_value = db_result.value.as_string(); SILK_TRACE << "to_previous: db_result.key=" << db_key << " db_result.value=" << db_value; } if (db_result.done && db_result.key && is_entry_deleted(db_result.key, db_result.value)) { current_pair_ = current_memory_entry_; current_db_entry_ = CursorResult{{}, {}, true}; is_previous_from_db_ = false; if (!memory_result.done && throw_notfound) throw_error_notfound(); return memory_result; } if (!db_result.done || (db_result.done && !db_result.value)) { current_pair_ = current_memory_entry_; is_previous_from_db_ = false; if (!memory_result.done && throw_notfound) throw_error_notfound(); return memory_result; } if (!memory_result.done || (memory_result.done && !memory_result.value)) { current_pair_ = current_db_entry_; is_previous_from_db_ = true; if (!db_result.done && throw_notfound) throw_error_notfound(); SILK_TRACE << "to_previous: db_key=" << db_result.key.as_string() << " db_value=" << db_result.value.as_string(); return db_result; } // Determine which one is previous const auto key_diff = Slice::compare_fast(memory_result.key, db_result.key); if (key_diff == 0) { // memory_result.key == db_result.key if (memory_result.value > db_result.value) { current_pair_ = current_memory_entry_; is_previous_from_db_ = false; return memory_result; } current_pair_ = current_db_entry_; is_previous_from_db_ = true; return db_result; } if (key_diff < 0) { // memory_result.key < db_result.key current_pair_ = current_memory_entry_; is_previous_from_db_ = false; return memory_result; } // memory_result.key > db_result.key current_pair_ = current_db_entry_; is_previous_from_db_ = true; return db_result; } CursorResult MemoryMutationCursor::current() const { return current(/*throw_notfound =*/true); } CursorResult MemoryMutationCursor::current(bool throw_notfound) const { if (is_table_cleared()) { return memory_cursor_->current(throw_notfound); } if (!memory_mutation_.has_map(config_.name_str())) { throw_error_nodata(); } if (!current_pair_.done && throw_notfound) throw_error_notfound(); return current_pair_; } CursorResult MemoryMutationCursor::to_next() { return to_next(/*throw_notfound =*/true); } CursorResult MemoryMutationCursor::to_next(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_next(throw_notfound); } if (is_previous_from_db_) { if (current_memory_entry_ == current_db_entry_) { current_memory_entry_ = memory_cursor_->to_next(false); } const auto db_result = next_on_db(MoveType::kNext, false); const auto result = resolve_priority(current_memory_entry_, db_result, MoveType::kNext); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } if (current_db_entry_ == current_memory_entry_) { current_db_entry_ = cursor_->to_next(false); } const auto memory_result = memory_cursor_->to_next(false); const auto result = resolve_priority(memory_result, current_db_entry_, MoveType::kNext); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } CursorResult MemoryMutationCursor::to_last() { return to_last(/*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::to_last(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_last(throw_notfound); } const auto memory_result = memory_cursor_->to_last(false); auto db_result = cursor_->to_last(false); // Basic checks current_db_entry_ = db_result.done ? db_result : CursorResult{{}, {}, false}; current_memory_entry_ = memory_result.done ? memory_result : CursorResult{{}, {}, false}; if (memory_result.done) { const auto mem_key = memory_result.key.as_string(); const auto mem_value = memory_result.value.as_string(); SILK_TRACE << "to_last: memory_result.key=" << mem_key << " memory_result.value=" << mem_value; } if (db_result.done) { const auto db_key = db_result.key.as_string(); const auto db_value = db_result.value.as_string(); SILK_TRACE << "to_last: db_result.key=" << db_key << " db_result.value=" << db_value; } if (db_result.done && db_result.key && is_entry_deleted(db_result.key, db_result.value)) { current_pair_ = current_memory_entry_; current_db_entry_ = CursorResult{{}, {}, true}; is_previous_from_db_ = false; if (!memory_result.done && throw_notfound) throw_error_notfound(); return memory_result; } if (!db_result.done || (db_result.done && !db_result.value)) { current_pair_ = current_memory_entry_; is_previous_from_db_ = false; if (!memory_result.done && throw_notfound) throw_error_notfound(); return memory_result; } if (!memory_result.done || (memory_result.done && !memory_result.value)) { current_pair_ = current_db_entry_; is_previous_from_db_ = true; if (!db_result.done && throw_notfound) throw_error_notfound(); SILK_TRACE << "to_last: db_key=" << db_result.key.as_string() << " db_value=" << db_result.value.as_string(); return db_result; } // Determine which one is last const auto key_diff = Slice::compare_fast(memory_result.key, db_result.key); if (key_diff == 0) { // memory_result.key == db_result.key if (memory_result.value > db_result.value) { current_pair_ = current_memory_entry_; is_previous_from_db_ = false; return memory_result; } current_pair_ = current_db_entry_; is_previous_from_db_ = true; return db_result; } if (key_diff > 0) { // memory_result.key > db_result.key current_pair_ = current_memory_entry_; is_previous_from_db_ = false; return memory_result; } // memory_result.key < db_result.key current_pair_ = current_db_entry_; is_previous_from_db_ = true; return db_result; } CursorResult MemoryMutationCursor::find(const Slice& key) { return find(key, /*.throw_notfound=*/true); } //! \details mdbx::cursor::find in mdbx C++ bindings has "key_exact" semantics, that is "Position at specified key". //! On the other hand, we need mdbx::cursor::lower_bound semantics i.e. "Position at first key greater than or equal //! to specified key" when comparing and caching memory and database results as required by database overlay. CursorResult MemoryMutationCursor::find(const Slice& key, bool throw_notfound) { if (is_table_cleared()) { // We simply delegate to memory cursor, so we need "key_exact" semantics here return memory_cursor_->find(key, throw_notfound); } // We need to compare and cache memory and db results, so we need "key_lowerbound" semantics hereafter const auto memory_result = memory_cursor_->lower_bound(key, false); SILK_TRACE << "find: memory_result=" << memory_result; auto db_result = cursor_->lower_bound(key, false); if (db_result.key && is_entry_deleted(db_result.key, db_result.value)) { db_result = next_on_db(MoveType::kNext, throw_notfound); } SILK_TRACE << "find: db_result=" << db_result; const auto result = resolve_priority(memory_result, db_result, MoveType::kNone); if (!result.done && throw_notfound) throw_error_notfound(); // In the end, we need to enforce "key_exact" semantics before returning if (result.done && result.key != key) { return CursorResult{{}, {}, false}; } if (!cursor_->is_multi_value() && current_memory_entry_.key == key && current_db_entry_.key == key) { // Choose memory value if both memory and db entries match the specified key return current_memory_entry_; } return result; } CursorResult MemoryMutationCursor::lower_bound(const Slice& key) { return lower_bound(key, /*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::lower_bound(const Slice& key, bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->lower_bound(key, throw_notfound); } const auto memory_result = memory_cursor_->lower_bound(key, false); auto db_result = cursor_->lower_bound(key, false); if (db_result.key && is_entry_deleted(db_result.key, db_result.value)) { db_result = next_on_db(MoveType::kNext, throw_notfound); } const auto result = resolve_priority(memory_result, db_result, MoveType::kNext); if (!result.done && throw_notfound) throw_error_notfound(); return result; } MoveResult MemoryMutationCursor::move(MoveOperation operation, bool throw_notfound) { if (operation != MoveOperation::next && operation != MoveOperation::previous) { throw std::runtime_error{"MemoryMutationCursor::move not implemented for operation=" + std::to_string(operation)}; } if (is_table_cleared()) { return memory_cursor_->move(operation, throw_notfound); } const auto memory_result = memory_cursor_->move(operation, false); auto db_result = cursor_->move(operation, false); if (db_result.key && is_entry_deleted(db_result.key, db_result.value)) { auto result = operation == MoveOperation::next ? next_on_db(MoveType::kNext, throw_notfound) : previous_on_db(MoveType::kPrevious, throw_notfound); std::tie(db_result.done, db_result.key, db_result.value) = std::tuple{result.done, result.key, result.value}; } const auto result = resolve_priority(memory_result, db_result, MoveType::kNext); if (!result.done && throw_notfound) throw_error_notfound(); MoveResult move_result = db_result; move_result.done = result.done; move_result.key = result.key; move_result.value = result.value; return move_result; } MoveResult MemoryMutationCursor::move(MoveOperation /*operation*/, const Slice& /*key*/, bool /*throw_notfound*/) { throw std::runtime_error{"MemoryMutationCursor::move(MoveOperation,const Slice&,bool) not implemented"}; } bool MemoryMutationCursor::seek(const Slice& key) { if (is_table_cleared()) { return memory_cursor_->seek(key); } const auto found_in_memory = memory_cursor_->seek(key); CursorResult memory_result{key, found_in_memory ? memory_cursor_->current().value : mdbx::slice{}, found_in_memory}; bool found_in_db = cursor_->seek(key); if (is_entry_deleted(key, memory_result.value)) { found_in_db = next_on_db(MoveType::kNext, /*throw_notfound=*/false); } CursorResult db_result{key, found_in_db ? cursor_->current().value : mdbx::slice{}, found_in_db}; const auto result = resolve_priority(memory_result, db_result, MoveType::kNext); return result.done; } bool MemoryMutationCursor::eof() const { const auto result = current(/*throw_notfound=*/false); if (result.done) return false; return memory_cursor_->eof() && cursor_->eof(); } bool MemoryMutationCursor::on_first() const { const auto result = current(/*throw_notfound=*/false); if (!result.done) return false; return memory_cursor_->on_first() || cursor_->on_first(); } bool MemoryMutationCursor::on_last() const { const auto result = current(/*throw_notfound=*/false); if (!result.done) return false; return false; } CursorResult MemoryMutationCursor::to_previous_last_multi() { return to_previous_last_multi(/*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::to_previous_last_multi(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_previous_last_multi(throw_notfound); } if (is_previous_from_db_) { const auto db_result = previous_on_db(MoveType::kPreviousNoDup, false); const auto result = resolve_priority(current_memory_entry_, db_result, MoveType::kPreviousNoDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } const auto memory_result = memory_cursor_->to_previous_last_multi(false); const auto result = resolve_priority(memory_result, current_db_entry_, MoveType::kPreviousNoDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } CursorResult MemoryMutationCursor::to_current_first_multi() { return to_current_first_multi(/*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::to_current_first_multi(bool throw_notfound) { return CursorResult{{}, {}, throw_notfound}; } CursorResult MemoryMutationCursor::to_current_prev_multi() { return to_current_prev_multi(/*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::to_current_prev_multi(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_current_prev_multi(throw_notfound); } if (is_previous_from_db_) { const auto db_result = previous_on_db(MoveType::kPreviousDup, false); const auto result = resolve_priority(current_memory_entry_, db_result, MoveType::kPreviousDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } const auto memory_result = memory_cursor_->to_current_prev_multi(false); const auto result = resolve_priority(memory_result, current_db_entry_, MoveType::kPreviousDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } CursorResult MemoryMutationCursor::to_current_next_multi() { return to_current_next_multi(/*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::to_current_next_multi(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_current_next_multi(throw_notfound); } if (is_previous_from_db_) { if (current_memory_entry_ == current_db_entry_) { current_memory_entry_ = memory_cursor_->to_next(false); } const auto db_result = next_on_db(MoveType::kNextDup, false); const auto result = resolve_priority(current_memory_entry_, db_result, MoveType::kNextDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } if (current_db_entry_ == current_memory_entry_) { current_db_entry_ = cursor_->to_next(false); } const auto memory_result = memory_cursor_->to_current_next_multi(false); const auto result = resolve_priority(memory_result, current_db_entry_, MoveType::kNextDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } CursorResult MemoryMutationCursor::to_current_last_multi() { return to_current_last_multi(/*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::to_current_last_multi(bool throw_notfound) { return CursorResult{{}, {}, throw_notfound}; } CursorResult MemoryMutationCursor::to_next_first_multi() { return to_next_first_multi(/*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::to_next_first_multi(bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->to_next_first_multi(throw_notfound); } if (is_previous_from_db_) { const auto db_result = next_on_db(MoveType::kNextNoDup, false); const auto result = resolve_priority(current_memory_entry_, db_result, MoveType::kNextNoDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } const auto memory_result = memory_cursor_->to_next_first_multi(false); const auto result = resolve_priority(memory_result, current_db_entry_, MoveType::kNextNoDup); if (!result.done && throw_notfound) { throw_error_notfound(); } return result; } CursorResult MemoryMutationCursor::find_multivalue(const Slice& key, const Slice& value) { return find_multivalue(key, value, /*.throw_notfound=*/true); } CursorResult MemoryMutationCursor::find_multivalue(const Slice& key, const Slice& value, bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->find_multivalue(key, value, throw_notfound); } const auto memory_result = memory_cursor_->find_multivalue(key, value, false); auto db_result = cursor_->find_multivalue(key, value, false); if (db_result.key && is_entry_deleted(db_result.key, db_result.value)) { db_result = next_on_db(MoveType::kNextDup, throw_notfound); } const auto result = resolve_priority(memory_result, db_result, MoveType::kNextDup); if (!result.done && throw_notfound) throw_error_notfound(); return result; } CursorResult MemoryMutationCursor::lower_bound_multivalue(const Slice& key, const Slice& value) { return lower_bound_multivalue(key, value, /*.throw_notfound=*/false); } CursorResult MemoryMutationCursor::lower_bound_multivalue(const Slice& key, const Slice& value, bool throw_notfound) { if (is_table_cleared()) { return memory_cursor_->lower_bound_multivalue(key, value, throw_notfound); } const auto memory_result = memory_cursor_->lower_bound_multivalue(key, value, false); auto db_result = cursor_->lower_bound_multivalue(key, value, false); if (db_result.key && is_entry_deleted(db_result.key, db_result.value)) { db_result = next_on_db(MoveType::kNextDup, throw_notfound); } const auto result = resolve_priority(memory_result, db_result, MoveType::kNextDup); if (!result.done && throw_notfound) throw_error_notfound(); return result; } MoveResult MemoryMutationCursor::move(MoveOperation /*operation*/, const Slice& /*key*/, const Slice& /*value*/, bool /*throw_notfound*/) { throw std::runtime_error{"MemoryMutationCursor::move(MoveOperation,const Slice&,const Slice&,bool) not implemented"}; } size_t MemoryMutationCursor::count_multivalue() const { size_t count{0}; return count; } MDBX_error_t MemoryMutationCursor::put(const Slice& key, Slice* value, MDBX_put_flags_t flags) noexcept { return memory_mutation_->put(memory_cursor_->map(), key, value, flags); } void MemoryMutationCursor::insert(const Slice& key, Slice value) { ::mdbx::error::success_or_throw(put(key, &value, MDBX_put_flags_t(::mdbx::put_mode::insert_unique))); } void MemoryMutationCursor::upsert(const Slice& key, const Slice& value) { memory_mutation_.upsert(config_, key, value); } void MemoryMutationCursor::update(const Slice& key, const Slice& value) { // Key *MUST* exist to perform update, so const auto result{find(key)}; if (!result.done) { throw_error_notfound(); } // *UPSERT* because we need to insert key in memory if it doesn't exist memory_mutation_.upsert(config_, key, value); } void MemoryMutationCursor::append(const Slice& key, const Slice& value) { Slice value_out = value; ::mdbx::error::success_or_throw(put(key, &value_out, MDBX_put_flags_t::MDBX_APPENDDUP)); } bool MemoryMutationCursor::erase() { return erase(/*whole_multivalue=*/false); } bool MemoryMutationCursor::erase(bool whole_multivalue) { const auto current_result = current(/*throw_notfound=*/false); if (!current_result.done) { return false; } if (whole_multivalue) { return memory_mutation_.erase(config_, current_result.key); } return memory_mutation_.erase(config_, current_result.key, current_result.value); } bool MemoryMutationCursor::erase(const Slice& key) { return erase(key, /*whole_multivalue=*/true); } bool MemoryMutationCursor::erase(const Slice& key, bool whole_multivalue) { const auto find_result = find(key, /*throw_notfound=*/false); if (!find_result.done) { return false; } if (whole_multivalue) { return memory_mutation_.erase(config_, find_result.key); } return memory_mutation_.erase(config_, find_result.key, find_result.value); } bool MemoryMutationCursor::erase(const Slice& key, const Slice& value) { return memory_mutation_.erase(config_, key, value); } CursorResult MemoryMutationCursor::next_on_db(MemoryMutationCursor::MoveType type, bool throw_notfound) { CursorResult result = next_by_type(type, throw_notfound); if (!result.done) return result; while (result.key && result.value && is_entry_deleted(result.key, result.value)) { result = next_by_type(type, throw_notfound); if (!result.done) return result; } return result; } CursorResult MemoryMutationCursor::next_by_type(MemoryMutationCursor::MoveType type, bool throw_notfound) { switch (type) { case MoveType::kNext: { return cursor_->to_next(throw_notfound); } case MoveType::kNextDup: { return cursor_->to_current_next_multi(throw_notfound); } case MoveType::kNextNoDup: { return cursor_->to_next_first_multi(throw_notfound); } default: { // Avoid GCC complaining w/ error: control reaches end of non-void function return CursorResult{{}, {}, false}; } } } CursorResult MemoryMutationCursor::previous_on_db(MemoryMutationCursor::MoveType type, bool throw_notfound) { CursorResult result = previous_by_type(type, throw_notfound); if (!result.done) return result; while (result.key && result.value && is_entry_deleted(result.key, result.value)) { result = previous_by_type(type, throw_notfound); if (!result.done) return result; } return result; } CursorResult MemoryMutationCursor::previous_by_type(MemoryMutationCursor::MoveType type, bool throw_notfound) { switch (type) { case MoveType::kPrevious: { return cursor_->to_previous(throw_notfound); } case MoveType::kPreviousDup: { return cursor_->to_current_prev_multi(throw_notfound); } case MoveType::kPreviousNoDup: { return cursor_->to_previous_last_multi(throw_notfound); } default: { // Avoid GCC complaining w/ error: control reaches end of non-void function return CursorResult{{}, {}, false}; } } } CursorResult MemoryMutationCursor::resolve_priority(CursorResult memory_result, CursorResult db_result, MoveType type) { SILK_TRACE << "resolve_priority: memory_result.done=" << memory_result.done << " db_result.done=" << db_result.done; if (!memory_result.done && !db_result.done) { return CursorResult{{}, {}, false}; } db_result = skip_intersection(memory_result, db_result, type); current_db_entry_ = db_result.done ? db_result : CursorResult{{}, {}, false}; current_memory_entry_ = memory_result.done ? memory_result : CursorResult{{}, {}, false}; SILK_TRACE << "resolve_priority: current_memory_entry_=" << current_memory_entry_ << " current_db_entry_=" << current_db_entry_; if (memory_result.done) { const auto mem_key = memory_result.key.as_string(); const auto mem_value = memory_result.value.as_string(); SILK_TRACE << " memory_result.key=" << mem_key << " memory_result.value=" << mem_value; } if (db_result.done) { const auto db_key = db_result.key.as_string(); const auto db_value = db_result.value.as_string(); SILK_TRACE << " db_result.key=" << db_key << " db_result.value=" << db_value; } if (memory_result.done && db_result.done) { if (memory_result.key == db_result.key) { is_previous_from_db_ = memory_result.value > db_result.value; } else { is_previous_from_db_ = memory_result.key > db_result.key; } } else { // At least one result is KO: so get from db if its result is OK, otherwise from memory anyway is_previous_from_db_ = db_result.done; } if (is_previous_from_db_) { current_pair_ = current_db_entry_; } else { current_pair_ = current_memory_entry_; } return current_pair_; } CursorResult MemoryMutationCursor::skip_intersection(CursorResult memory_result, CursorResult db_result, MoveType type) { CursorResult new_db_result = db_result; // Check for duplicates if (memory_result.done && db_result.done && memory_result.key == db_result.key) { bool skip{false}; if (type == MoveType::kNext || type == MoveType::kPrevious) { skip = !cursor_->is_multi_value() || memory_result.value == db_result.value; } else { skip = memory_result.value == db_result.value; } if (skip) { if (type == MoveType::kNext || type == MoveType::kNextDup || type == MoveType::kNextNoDup) { new_db_result = next_on_db(type, /*.throw_notfound=*/false); } else if (type == MoveType::kPrevious || type == MoveType::kPreviousDup || type == MoveType::kPreviousNoDup) { new_db_result = previous_on_db(type, /*.throw_notfound=*/false); } } } return new_db_result; } void MemoryMutationCursor::throw_error_nodata() { mdbx::error::throw_exception(MDBX_error_t::MDBX_ENODATA); } void MemoryMutationCursor::throw_error_notfound() { mdbx::error::throw_exception(MDBX_error_t::MDBX_NOTFOUND); } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/memory_mutation_cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "mdbx.hpp" #include "memory_mutation.hpp" namespace silkworm::datastore::kvdb { class MemoryMutationCursor : public RWCursorDupSort { public: MemoryMutationCursor(MemoryMutation& memory_mutation, const MapConfig& config); ~MemoryMutationCursor() override = default; bool is_table_cleared() const; bool is_entry_deleted(const Slice& key, const Slice& value) const; void bind(ROTxn& txn, const MapConfig& config) override; std::unique_ptr clone() override; ::mdbx::map_handle map() const override; size_t size() const override; bool is_multi_value() const override; bool is_dangling() const override; CursorResult to_first() override; CursorResult to_first(bool throw_notfound) override; CursorResult to_previous() override; CursorResult to_previous(bool throw_notfound) override; CursorResult current() const override; CursorResult current(bool throw_notfound) const override; CursorResult to_next() override; CursorResult to_next(bool throw_notfound) override; CursorResult to_last() override; CursorResult to_last(bool throw_notfound) override; CursorResult find(const Slice& key) override; CursorResult find(const Slice& key, bool throw_notfound) override; CursorResult lower_bound(const Slice& key) override; CursorResult lower_bound(const Slice& key, bool throw_notfound) override; MoveResult move(MoveOperation operation, bool throw_notfound) override; MoveResult move(MoveOperation operation, const Slice& key, bool throw_notfound) override; bool seek(const Slice& key) override; bool eof() const override; bool on_first() const override; bool on_last() const override; CursorResult to_previous_last_multi() override; CursorResult to_previous_last_multi(bool throw_notfound) override; CursorResult to_current_first_multi() override; CursorResult to_current_first_multi(bool throw_notfound) override; CursorResult to_current_prev_multi() override; CursorResult to_current_prev_multi(bool throw_notfound) override; CursorResult to_current_next_multi() override; CursorResult to_current_next_multi(bool throw_notfound) override; CursorResult to_current_last_multi() override; CursorResult to_current_last_multi(bool throw_notfound) override; CursorResult to_next_first_multi() override; CursorResult to_next_first_multi(bool throw_notfound) override; CursorResult find_multivalue(const Slice& key, const Slice& value) override; CursorResult find_multivalue(const Slice& key, const Slice& value, bool throw_notfound) override; CursorResult lower_bound_multivalue(const Slice& key, const Slice& value) override; CursorResult lower_bound_multivalue(const Slice& key, const Slice& value, bool throw_notfound) override; MoveResult move(MoveOperation operation, const Slice& key, const Slice& value, bool throw_notfound) override; size_t count_multivalue() const override; MDBX_error_t put(const Slice& key, Slice* value, MDBX_put_flags_t flags) noexcept override; void insert(const Slice& key, Slice value) override; void upsert(const Slice& key, const Slice& value) override; void update(const Slice& key, const Slice& value) override; void append(const Slice& key, const Slice& value) override; bool erase() override; bool erase(bool whole_multivalue) override; bool erase(const Slice& key) override; bool erase(const Slice& key, bool whole_multivalue) override; bool erase(const Slice& key, const Slice& value) override; private: static void throw_error_nodata(); static void throw_error_notfound(); enum class MoveType : uint8_t { kNone, kNext, kNextDup, kNextNoDup, kPrevious, kPreviousDup, kPreviousNoDup }; CursorResult resolve_priority(CursorResult memory_result, CursorResult db_result, MoveType type); CursorResult skip_intersection(CursorResult memory_result, CursorResult db_result, MoveType type); CursorResult next_on_db(MoveType type, bool throw_notfound); CursorResult next_by_type(MoveType type, bool throw_notfound); CursorResult previous_on_db(MoveType type, bool throw_notfound); CursorResult previous_by_type(MoveType type, bool throw_notfound); MemoryMutation& memory_mutation_; const MapConfig& config_; std::unique_ptr cursor_; std::unique_ptr memory_cursor_; CursorResult current_db_entry_; CursorResult current_memory_entry_; CursorResult current_pair_; bool is_previous_from_db_{false}; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/memory_mutation_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "memory_mutation.hpp" #include #include namespace silkworm::datastore::kvdb { static const MapConfig kTestMap{"TestTable"}; static const MapConfig kTestMultiMap{"TestMultiTable", mdbx::key_mode::usual, mdbx::value_mode::multi}; static const MapConfig kTestNonexistentMap{"NonexistentTable"}; TEST_CASE("MemoryDatabase", "[silkworm][node][db][memory_mutation]") { const TemporaryDirectory tmp_dir; SECTION("Create a temporary database") { CHECK_NOTHROW(MemoryDatabase{}); CHECK_NOTHROW(MemoryDatabase{tmp_dir.path()}); } SECTION("Create one R/W transaction in a temporary database") { MemoryDatabase overlay{tmp_dir.path()}; ::mdbx::txn_managed rw_txn; CHECK_NOTHROW((rw_txn = overlay.start_rw_txn())); } SECTION("Cannot create more than one R/W transaction in a temporary database") { MemoryDatabase overlay{tmp_dir.path()}; ::mdbx::txn_managed rw_txn; CHECK_NOTHROW((rw_txn = overlay.start_rw_txn())); CHECK_THROWS_AS(overlay.start_rw_txn(), std::exception); } } TEST_CASE("MemoryMutation", "[silkworm][node][db][memory_mutation]") { const TemporaryDirectory tmp_dir; DataDirectory data_dir{tmp_dir.path() / "main_db"}; data_dir.deploy(); EnvConfig main_db_config{ .path = data_dir.chaindata().path().string(), .create = true, .in_memory = true, }; auto main_env{open_env(main_db_config)}; RWTxnManaged main_rw_txn{main_env}; MemoryOverlay overlay{ tmp_dir.path(), &main_rw_txn, [](std::string_view map_name) { if (map_name == kTestMap.name) return kTestMap; if (map_name == kTestMultiMap.name) return kTestMultiMap; return MapConfig{map_name}; }, "Sequence", }; SECTION("Create one memory mutation") { CHECK_NOTHROW(MemoryMutation{overlay}); } SECTION("Check initial values") { MemoryMutation mutation{overlay}; CHECK_NOTHROW(mutation.external_txn() == &main_rw_txn); CHECK_NOTHROW(!mutation.is_table_cleared("TestTable")); CHECK_NOTHROW(!mutation.is_entry_deleted("TestTable", Slice{})); } SECTION("Cannot create two memory mutations") { MemoryMutation mutation{overlay}; CHECK_THROWS_AS(MemoryMutation(overlay), ::mdbx::exception); } SECTION("Rollback an empty mutation") { MemoryMutation mutation{overlay}; CHECK_NOTHROW(mutation.rollback()); } SECTION("Rollback twice an empty mutation") { MemoryMutation mutation{overlay}; CHECK_NOTHROW(mutation.rollback()); CHECK_NOTHROW(mutation.rollback()); } SECTION("Check map presence in empty mutation") { MemoryMutation mutation{overlay}; CHECK_NOTHROW(!mutation.has_map(kTestMap.name)); CHECK_NOTHROW(!mutation.has_map(kTestMultiMap.name)); CHECK_NOTHROW(!mutation.has_map(kTestNonexistentMap.name)); } SECTION("Check map presence in nonempty main db") { MemoryMutation mutation{overlay}; open_map(main_rw_txn, kTestMap); open_map(main_rw_txn, kTestMultiMap); CHECK_NOTHROW(mutation.has_map(kTestMap.name)); CHECK_NOTHROW(mutation.has_map(kTestMultiMap.name)); CHECK_NOTHROW(!mutation.has_map(kTestNonexistentMap.name)); } SECTION("Check map presence in nonempty mutation") { MemoryMutation mutation{overlay}; open_map(mutation, kTestMap); open_map(mutation, kTestMultiMap); CHECK_NOTHROW(mutation.has_map(kTestMap.name)); CHECK_NOTHROW(mutation.has_map(kTestMultiMap.name)); CHECK_NOTHROW(!mutation.has_map(kTestNonexistentMap.name)); } SECTION("Erase key in nonempty mutation") { MemoryMutation mutation{overlay}; open_map(mutation, kTestMap); const auto mutation_cursor = mutation.rw_cursor(kTestMap); mutation_cursor->upsert("key1", "value1"); mutation_cursor->upsert("key2", "value2"); CHECK(mutation_cursor->seek("key1")); CHECK(mutation_cursor->seek("key2")); mutation.erase(kTestMap, "key2"); CHECK(mutation_cursor->seek("key1")); CHECK(!mutation_cursor->seek("key2")); open_map(mutation, kTestMultiMap); const auto mutation_cursor_dupsort = mutation.rw_cursor_dup_sort(kTestMultiMap); mutation_cursor_dupsort->upsert("key1", "value1"); mutation_cursor_dupsort->upsert("key1", "value2"); CHECK(mutation_cursor_dupsort->seek("key1")); mutation.erase(kTestMultiMap, "key1", "value2"); CHECK(mutation_cursor_dupsort->seek("key1")); auto v1 = mutation_cursor_dupsort->find_multivalue("key1", "value1"); CHECK(v1.done); CHECK(v1.key == "key1"); CHECK(v1.value == "value1"); CHECK_THROWS(mutation_cursor_dupsort->find_multivalue("key1", "value2", true)); mutation.erase(kTestMultiMap, "key1", "value1"); CHECK(!mutation_cursor_dupsort->seek("key1")); CHECK_THROWS(mutation_cursor_dupsort->find_multivalue("key1", "value1", true)); CHECK_THROWS(mutation_cursor_dupsort->find_multivalue("key1", "value2", true)); } SECTION("Check for deleted dup entry") { MemoryMutation mutation{overlay}; open_map(mutation, kTestMultiMap); const auto mutation_cursor_dupsort = mutation.rw_cursor_dup_sort(kTestMultiMap); mutation_cursor_dupsort->upsert("key1", "value1"); mutation_cursor_dupsort->upsert("key1", "value2"); CHECK(mutation_cursor_dupsort->seek("key1")); mutation.erase(kTestMultiMap, "key1", "value1"); CHECK(mutation.is_dup_deleted(kTestMultiMap.name, "key1", "value1")); CHECK(!mutation.is_dup_deleted(kTestMultiMap.name, "key1", "value2")); } SECTION("Check for deleted dup entry - persisted in db") { main_rw_txn.rw_cursor_dup_sort(kTestMultiMap)->upsert("key1", "value1"); main_rw_txn.rw_cursor_dup_sort(kTestMultiMap)->upsert("key1", "value2"); main_rw_txn.commit_and_renew(); MemoryMutation mutation{overlay}; open_map(mutation, kTestMultiMap); const auto mutation_cursor_dupsort = mutation.ro_cursor_dup_sort(kTestMultiMap); CHECK(mutation_cursor_dupsort->seek("key1")); mutation.erase(kTestMultiMap, "key1", "value1"); mutation.commit_and_stop(); mutation.flush(main_rw_txn); main_rw_txn.commit_and_renew(); auto cursor2 = main_rw_txn.ro_cursor_dup_sort(kTestMultiMap); CHECK_THROWS(cursor2->find_multivalue("key1", "value1", true)); cursor2->find_multivalue("key1", "value2", true); } SECTION("Deleted dup entry removed after upserting again") { MemoryMutation mutation{overlay}; open_map(mutation, kTestMultiMap); const auto mutation_cursor_dupsort = mutation.rw_cursor_dup_sort(kTestMultiMap); mutation_cursor_dupsort->upsert("key1", "value1"); mutation_cursor_dupsort->upsert("key1", "value2"); mutation.erase(kTestMultiMap, "key1", "value1"); CHECK(mutation.is_dup_deleted(kTestMultiMap.name, "key1", "value1")); CHECK(!mutation.is_dup_deleted(kTestMultiMap.name, "key1", "value2")); mutation_cursor_dupsort->upsert("key1", "value1"); CHECK(!mutation.is_dup_deleted(kTestMultiMap.name, "key1", "value1")); CHECK(!mutation.is_dup_deleted(kTestMultiMap.name, "key1", "value2")); } SECTION("Find dup entry after deletion first value") { MemoryMutation mutation{overlay}; open_map(mutation, kTestMultiMap); const auto mutation_cursor_dupsort = mutation.rw_cursor_dup_sort(kTestMultiMap); mutation_cursor_dupsort->upsert("key1", "value1"); mutation_cursor_dupsort->upsert("key1", "value2"); auto result1a = mutation_cursor_dupsort->find_multivalue("key1", "value1", false); CHECK(result1a.done); CHECK(result1a.key == "key1"); CHECK(result1a.value == "value1"); auto result2a = mutation_cursor_dupsort->find_multivalue("key1", "value2", false); CHECK(result2a.done); CHECK(result2a.key == "key1"); CHECK(result2a.value == "value2"); mutation.erase(kTestMultiMap, "key1", "value1"); auto result1b = mutation_cursor_dupsort->find_multivalue("key1", "value1", false); CHECK(!result1b.done); auto result2b = mutation_cursor_dupsort->find_multivalue("key1", "value2", false); CHECK(result2b.done); CHECK(result2b.key == "key1"); CHECK(result2b.value == "value2"); } SECTION("Find dup entry after deletion second value") { MemoryMutation mutation{overlay}; open_map(mutation, kTestMultiMap); const auto mutation_cursor_dupsort = mutation.rw_cursor_dup_sort(kTestMultiMap); mutation_cursor_dupsort->upsert("key1", "value1"); mutation_cursor_dupsort->upsert("key1", "value2"); auto result1a = mutation_cursor_dupsort->find_multivalue("key1", "value1", false); CHECK(result1a.done); CHECK(result1a.key == "key1"); CHECK(result1a.value == "value1"); auto result2a = mutation_cursor_dupsort->find_multivalue("key1", "value2", false); CHECK(result2a.done); CHECK(result2a.key == "key1"); CHECK(result2a.value == "value2"); mutation.erase(kTestMultiMap, "key1", "value2"); auto result1b = mutation_cursor_dupsort->find_multivalue("key1", "value1", false); CHECK(result1b.done); auto result2b = mutation_cursor_dupsort->find_multivalue("key1", "value2", false); CHECK(!result2b.done); } SECTION("Find dup entry after deletion using another cursor") { MemoryMutation mutation{overlay}; open_map(mutation, kTestMultiMap); const auto mutation_cursor_dupsort1 = mutation.rw_cursor_dup_sort(kTestMultiMap); mutation_cursor_dupsort1->upsert("key1", "value1"); mutation_cursor_dupsort1->upsert("key1", "value2"); auto result1a = mutation_cursor_dupsort1->find_multivalue("key1", "value1", false); CHECK(result1a.done); auto result2a = mutation_cursor_dupsort1->find_multivalue("key1", "value2", false); CHECK(result2a.done); mutation.erase(kTestMultiMap, "key1", "value2"); mutation.commit_and_stop(); mutation.flush(main_rw_txn); mutation.reopen(); const auto mutation_cursor_dupsort2 = mutation.rw_cursor_dup_sort(kTestMultiMap); auto result1b = mutation_cursor_dupsort2->find_multivalue("key1", "value1", false); CHECK(result1b.done); auto result2b = mutation_cursor_dupsort2->find_multivalue("key1", "value2", false); CHECK(!result2b.done); } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/query_test.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../common/ranges/vector_from_range.hpp" #include "database.hpp" #include "domain.hpp" #include "mdbx.hpp" namespace silkworm::datastore::kvdb { // by default has_large_values = false, is_multi_value = true using DomainDefault = std::identity; struct DomainWithLargeValues { Schema::DomainDef& operator()(Schema::DomainDef& domain) const { domain.enable_large_values().values_disable_multi_value(); return domain; } }; enum class EntityKind { kDomain, kHistory, kInvertedIndex, }; class QueryTest { public: QueryTest(EntityName name, Schema::DatabaseDef schema) : name_{std::move(name)}, db_{ open_env(EnvConfig{.path = tmp_dir_.path().string(), .create = true, .in_memory = true}), std::move(schema), } { db_.create_tables(); } Domain domain() const { return db_.domain(name_); } History history() const { return *domain().history; } InvertedIndex inverted_index() const { return domain().history->inverted_index; } ROAccess access_ro() const { return db_.access_ro(); } RWAccess access_rw() const { return db_.access_rw(); } template TDomainConfig> static Schema::DatabaseDef make_schema(EntityName name) { Schema::DatabaseDef schema; TDomainConfig domain_config; [[maybe_unused]] auto _ = domain_config(schema.domain(name)); return schema; } template TDomainConfig> static QueryTest make(EntityName name = EntityName{"Test"}) { return QueryTest{name, make_schema(name)}; } template auto find_in(const std::vector& data, TArgs&&... args) { auto entity = this->entity(); RWAccess db_access = this->access_rw(); { RWTxnManaged tx = db_access.start_rw_tx(); TEntryQuery query{tx, entity}; for (auto& entry : data) { auto& [key, value, ts] = entry; query.exec(key, value, ts); } tx.commit_and_stop(); } ROTxnManaged tx = db_access.start_ro_tx(); TResultQuery query{tx, entity}; auto results = query.exec(std::forward(args)...); if constexpr (std::ranges::input_range) { return vector_from_range(std::move(results)); } else { return results; } } private: template auto entity() { if constexpr (kKind == EntityKind::kDomain) { return domain(); } if constexpr (kKind == EntityKind::kHistory) { return history(); } if constexpr (kKind == EntityKind::kInvertedIndex) { return inverted_index(); } std::abort(); } TemporaryDirectory tmp_dir_; EntityName name_; Database db_; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/raw_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "codec.hpp" namespace silkworm::datastore::kvdb { template concept BytesOrByteViewConcept = std::same_as || std::same_as; template struct RawDecoder : public Decoder { TBytes value; ~RawDecoder() override = default; void decode(Slice slice) override { value = from_slice(slice); } }; static_assert(DecoderConcept>); static_assert(DecoderConcept>); template struct RawEncoder : public Encoder { TBytes value; ~RawEncoder() override = default; Slice encode() override { return to_slice(ByteView{value}); } }; static_assert(EncoderConcept>); static_assert(EncoderConcept>); } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/schema.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "schema.hpp" namespace silkworm::datastore::kvdb { static std::string make_table_name(datastore::EntityName base_name, std::string_view suffix) { return base_name.to_string() + std::string{suffix}; } Schema::DomainDef Schema::DatabaseDef::make_domain_schema(datastore::EntityName name) { Schema::DomainDef schema; schema.table(kDomainValuesName) .name(make_table_name(name, "Vals")) .enable_multi_value(); define_history_schema(name, schema); return schema; } Schema::EntityDef Schema::DatabaseDef::make_history_schema(datastore::EntityName name) { Schema::EntityDef schema; define_history_schema(name, schema); return schema; } void Schema::DatabaseDef::define_history_schema(datastore::EntityName name, EntityDef& schema) { schema.table(kHistoryValuesName) .name(make_table_name(name, "HistoryVals")) .enable_multi_value(); define_inverted_index_schema(name, schema); // update the inverted index table name to have a "HistoryKeys" suffix schema.table(kInvIdxKeysName) .name(make_table_name(name, "HistoryKeys")); } void Schema::DatabaseDef::undefine_history_schema(EntityDef& schema) { schema.undefine(kHistoryValuesName); undefine_inverted_index_schema(schema); } Schema::EntityDef Schema::DatabaseDef::make_inverted_index_schema(datastore::EntityName name) { Schema::EntityDef schema; define_inverted_index_schema(name, schema); return schema; } void Schema::DatabaseDef::define_inverted_index_schema(datastore::EntityName name, EntityDef& schema) { schema.table(kInvIdxKeysName) .name(make_table_name(name, "Keys")) .enable_multi_value(); schema.table(kInvIdxIndexName) .name(make_table_name(name, "Idx")) .enable_multi_value(); } void Schema::DatabaseDef::undefine_inverted_index_schema(EntityDef& schema) { schema.undefine(kInvIdxKeysName); schema.undefine(kInvIdxIndexName); } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/schema.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../common/entity_name.hpp" namespace silkworm::datastore::kvdb { class Schema { public: class TableDef { public: TableDef& name(std::string_view name) { name_ = name; return *this; } TableDef& enable_multi_value() { is_multi_value_ = true; return *this; } TableDef& disable_multi_value() { is_multi_value_ = false; return *this; } const std::string& name() const { return name_.value(); } bool is_multi_value() const { return is_multi_value_; } private: std::optional name_; bool is_multi_value_{false}; }; class EntityDef { public: virtual ~EntityDef() = default; TableDef& table(datastore::EntityName name) { return table_defs_[name]; } EntityDef& undefine(datastore::EntityName name) { table_defs_.erase(name); return *this; } const EntityMap& tables() const { return table_defs_; } private: EntityMap table_defs_; }; class DomainDef : public EntityDef { public: ~DomainDef() override = default; DomainDef& values_disable_multi_value() { table(kDomainValuesName).disable_multi_value(); table(kHistoryValuesName).disable_multi_value(); return *this; } DomainDef& enable_large_values() { has_large_values_ = true; return *this; } DomainDef& without_history() { DatabaseDef::undefine_history_schema(*this); return *this; } bool has_large_values() const { return has_large_values_; } private: bool has_large_values_{false}; }; class DatabaseDef { public: EntityDef& default_entity() { entity_defs_.try_emplace(kDefaultEntityName, std::make_shared()); return *entity_defs_.at(kDefaultEntityName); } DomainDef& domain(datastore::EntityName name) { entity_defs_.try_emplace(name, std::make_shared(make_domain_schema(name))); return dynamic_cast(*entity_defs_.at(name)); } EntityDef& inverted_index(datastore::EntityName name) { entity_defs_.try_emplace(name, std::make_shared(make_inverted_index_schema(name))); return *entity_defs_.at(name); } const EntityMap>& entities() const { return entity_defs_; } private: friend DomainDef; static DomainDef make_domain_schema(datastore::EntityName name); static EntityDef make_history_schema(datastore::EntityName name); static void define_history_schema(datastore::EntityName name, EntityDef& schema); static void undefine_history_schema(EntityDef& schema); static EntityDef make_inverted_index_schema(datastore::EntityName name); static void define_inverted_index_schema(datastore::EntityName name, EntityDef& schema); static void undefine_inverted_index_schema(EntityDef& schema); EntityMap> entity_defs_; }; DatabaseDef& database(datastore::EntityName name) { return database_defs_[name]; } DatabaseDef& default_database() { return database(kDefaultEntityName); } static inline const datastore::EntityName kDefaultEntityName{"_"}; static inline const datastore::EntityName kDomainValuesName{"DomainValues"}; static inline const datastore::EntityName kHistoryValuesName{"HistoryValues"}; static inline const datastore::EntityName kInvIdxKeysName{"InvIdxKeys"}; static inline const datastore::EntityName kInvIdxIndexName{"InvIdxIndex"}; private: EntityMap database_defs_; }; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/kvdb/timestamp_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "big_endian_codec.hpp" namespace silkworm::datastore::kvdb { using TimestampEncoder = BigEndianU64Codec; using TimestampDecoder = BigEndianU64Codec; } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/datastore/schema.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "kvdb/schema.hpp" #include "snapshots/schema.hpp" namespace silkworm::datastore { struct Schema { kvdb::Schema kvdb; snapshots::Schema snapshots; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/segment_collation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "data_migration_command.hpp" #include "kvdb/mdbx.hpp" #include "snapshots/segment/segment_writer.hpp" namespace silkworm::datastore { struct SegmentCollationCommand : public DataMigrationCommand { BlockNumRange range; uint64_t base_txn_id; SegmentCollationCommand(BlockNumRange range1, uint64_t base_txn_id1) : range(range1), base_txn_id(base_txn_id1) {} ~SegmentCollationCommand() override = default; std::string to_string() const override { std::stringstream stream; stream << "SegmentCollationCommand " << range.to_string(); return stream.str(); } }; struct SegmentCollation { virtual ~SegmentCollation() = default; //! Copies data for a block range from db to the snapshot file. virtual void copy(datastore::kvdb::ROTxn& txn, const SegmentCollationCommand& command, snapshots::segment::SegmentFileWriter& file_writer) const = 0; //! Cleans up data for a block range from db after it was copied to the snapshot file. virtual void prune(datastore::kvdb::RWTxn& txn, BlockNumRange range) const = 0; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/snapshot_merger.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_merger.hpp" #include #include #include #include #include #include "snapshots/common/raw_codec.hpp" #include "snapshots/common/snapshot_path.hpp" #include "snapshots/segment/seg/compressor.hpp" #include "snapshots/segment/segment_writer.hpp" #include "snapshots/snapshot_bundle.hpp" namespace silkworm::datastore { using namespace silkworm::snapshots; struct SnapshotMergerCommand : public DataMigrationCommand { BlockNumRange range; explicit SnapshotMergerCommand(BlockNumRange range1) : range(range1) {} ~SnapshotMergerCommand() override = default; std::string to_string() const override { std::stringstream stream; stream << "SnapshotMergerCommand " << range.to_string(); return stream.str(); } }; struct SnapshotMergerResult : public DataMigrationResult { SnapshotBundlePaths bundle_paths; explicit SnapshotMergerResult(SnapshotBundlePaths bundle_paths1) : bundle_paths(std::move(bundle_paths1)) {} ~SnapshotMergerResult() override = default; }; std::unique_ptr SnapshotMerger::next_command() { BlockNum first_block_num = 0; size_t block_count = 0; size_t batch_size = 0; for (auto& bundle_ptr : snapshots_.view_bundles()) { auto& bundle = *bundle_ptr; auto bundle_block_num_range = snapshots_.step_converter().timestamp_range_from_step_range(bundle.step_range()); size_t bundle_block_count = bundle_block_num_range.size(); if (bundle_block_count >= kMaxSnapshotSize) { continue; } if (bundle_block_count != block_count) { first_block_num = bundle_block_num_range.start; block_count = bundle_block_count; batch_size = 0; } ++batch_size; if (batch_size == kBatchSize) { return std::make_unique(BlockNumRange{first_block_num, bundle_block_num_range.end}); } } return {}; } std::shared_ptr SnapshotMerger::migrate(std::unique_ptr command) { auto& merger_command = dynamic_cast(*command); auto range = merger_command.range; StepRange step_range = snapshots_.step_converter().step_range_from_timestamp_range({range.start, range.end}); SnapshotBundlePaths new_bundle{snapshots_.schema(), tmp_dir_path_, step_range}; for (const auto& [name, path] : new_bundle.segment_paths()) { SILK_DEBUG_M("SnapshotMerger") << "merging " << name.to_string() << " range " << range.to_string(); seg::Compressor compressor{path.path(), tmp_dir_path_}; for (auto& bundle_ptr : snapshots_.bundles_in_range(step_range)) { auto& bundle = *bundle_ptr; segment::SegmentReader> reader{bundle.segment(Schema::kDefaultEntityName, name)}; std::copy(reader.begin(), reader.end(), compressor.add_word_iterator()); } seg::Compressor::compress(std::move(compressor)); } return std::make_shared(std::move(new_bundle)); } void SnapshotMerger::index(std::shared_ptr result) { auto& merger_result = dynamic_cast(*result); snapshots_.build_indexes(merger_result.bundle_paths); } static void schedule_bundle_cleanup(SnapshotBundle& bundle) { // NOLINTNEXTLINE(performance-unnecessary-value-param) bundle.on_close([](std::vector files) { for (auto& path : files) { [[maybe_unused]] bool removed = std::filesystem::remove(path); } }); } void SnapshotMerger::commit(std::shared_ptr result) { auto& freezer_result = dynamic_cast(*result); auto& bundle = freezer_result.bundle_paths; auto merged_bundles = snapshots_.bundles_in_range(bundle.step_range()); move_files(bundle.files(), snapshots_.path()); SnapshotBundle final_bundle = snapshots_.open_bundle(bundle.step_range()); snapshots_.replace_snapshot_bundles(std::move(final_bundle)); for (auto& merged_bundle : merged_bundles) { schedule_bundle_cleanup(*merged_bundle); } on_snapshot_merged_signal_(bundle.step_range()); } boost::signals2::scoped_connection SnapshotMerger::on_snapshot_merged(const std::function& callback) { return on_snapshot_merged_signal_.connect(callback); } Task SnapshotMerger::cleanup() { // the cleanup happens when bundle readers stop using them co_return; } } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/snapshot_merger.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "common/step.hpp" #include "data_migration.hpp" #include "snapshots/snapshot_repository.hpp" #include "snapshots/snapshot_size.hpp" namespace silkworm::datastore { class SnapshotMerger : public DataMigration { public: SnapshotMerger( snapshots::SnapshotRepository& snapshots, std::filesystem::path tmp_dir_path) : snapshots_(snapshots), tmp_dir_path_(std::move(tmp_dir_path)) {} boost::signals2::scoped_connection on_snapshot_merged(const std::function& callback); private: static constexpr size_t kBatchSize = 10; static constexpr size_t kMaxSnapshotSize = snapshots::kMaxMergerSnapshotSize; const char* name() const override { return "SnapshotMerger"; } std::unique_ptr next_command() override; std::shared_ptr migrate(std::unique_ptr command) override; void index(std::shared_ptr result) override; void commit(std::shared_ptr result) override; Task cleanup() override; snapshots::SnapshotRepository& snapshots_; std::filesystem::path tmp_dir_path_; boost::signals2::signal on_snapshot_merged_signal_; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/datastore/snapshots/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") add_subdirectory(bittorrent) add_subdirectory(segment/seg) find_package(absl REQUIRED COMPONENTS strings) find_package(Boost REQUIRED COMPONENTS headers url) # headers for signals2 find_package(Microsoft.GSL REQUIRED) find_package(OpenSSL REQUIRED) # cmake-format: off set(LIBS_PRIVATE absl::strings Boost::headers OpenSSL::Crypto silkworm_snapshots_seg ) # cmake-format: on # cmake-format: off set(LIBS_PUBLIC Microsoft.GSL::GSL silkworm_core silkworm_infra silkworm_datastore_common silkworm_bittorrent ) # cmake-format: on silkworm_library( silkworm_snapshots PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) target_link_libraries(silkworm_snapshots_test PRIVATE silkworm_infra_test_util) ================================================ FILE: silkworm/db/datastore/snapshots/basic_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "../common/timestamp.hpp" #include "segment/segment_reader.hpp" #include "segment_and_accessor_index.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { template < DecoderConcept TDecoder, const SegmentAndAccessorIndexNames& segment_names> class BasicSegmentQuery { public: explicit BasicSegmentQuery( const SegmentAndAccessorIndex segment_and_index) : reader_{segment_and_index.segment}, index_{segment_and_index.index} {} explicit BasicSegmentQuery(const SegmentAndAccessorIndexProvider& bundle) : BasicSegmentQuery{bundle.segment_and_accessor_index(segment_names)} {} protected: segment::SegmentReader reader_; const rec_split::AccessorIndex& index_; }; template < DecoderConcept TDecoder, const SegmentAndAccessorIndexNames& segment_names> struct FindByIdSegmentQuery : public BasicSegmentQuery { using BasicSegmentQuery::BasicSegmentQuery; std::optional exec(uint64_t id) { auto offset = this->index_.lookup_by_data_id(id); if (!offset) { return std::nullopt; } return this->reader_.seek_one(*offset); } }; template < EncoderConcept TKeyEncoder, DecoderConcept TValueDecoder, const SegmentAndAccessorIndexNames& segment_names> struct FindByKeySegmentQuery : public BasicSegmentQuery { using BasicSegmentQuery::BasicSegmentQuery; using Key = decltype(TKeyEncoder::value); std::optional exec(const Key& key) { TKeyEncoder key_encoder; key_encoder.value = key; ByteView key_data = key_encoder.encode_word(); auto offset = this->index_.lookup_by_key(key_data); if (!offset) { return std::nullopt; } return this->reader_.seek_one(*offset); } }; template < DecoderConcept TDecoder, const SegmentAndAccessorIndexNames& segment_names> struct FindByHashSegmentQuery : public BasicSegmentQuery { using BasicSegmentQuery::BasicSegmentQuery; using Value = decltype(TDecoder::value); struct Result { Value value; datastore::Timestamp timestamp{0}; }; std::optional exec(const Hash& hash) { const auto data_id = this->index_.lookup_data_id_by_key(hash); if (!data_id) { return std::nullopt; } const auto offset = this->index_.lookup_by_data_id(*data_id); if (!offset) { return std::nullopt; } auto result = this->reader_.seek_one(*offset, ByteView{hash.bytes, 1}); if (!result) return std::nullopt; // We *must* ensure that the retrieved txn hash matches because there is no way to know if key exists in MPHF if (result->hash() != hash) { return std::nullopt; } return Result{std::move(*result), *data_id}; } }; template < DecoderConcept TDecoder, const SegmentAndAccessorIndexNames& segment_names> struct RangeFromIdSegmentQuery : public BasicSegmentQuery { using BasicSegmentQuery::BasicSegmentQuery; std::optional> exec(uint64_t first_id, uint64_t count) { auto offset = this->index_.lookup_by_data_id(first_id); if (!offset) { return std::nullopt; } return this->reader_.read_into_vector(*offset, count); } }; //! Given a TSegmentQuery that returns an optional value, runs it for all bundles and returns the last non-null result. //! Iterating backwards by default is an optimization assuming that results are often found in the most recent snapshots. template struct FindMapQuery { explicit FindMapQuery(const SnapshotRepositoryROAccess& repository) : repository_{repository} {} auto exec(auto&&... args) { for (const auto& bundle_ptr : repository_.view_bundles_reverse()) { TSegmentQuery query{*bundle_ptr}; auto result = query.exec(args...); if (result) { return result; } } // std::nullopt return decltype(std::declval().exec(args...)){}; } protected: const SnapshotRepositoryROAccess& repository_; }; //! Given a timestamp and a TSegmentQuery, runs it for a bundle located by that timestamp. template struct FindByTimestampMapQuery { explicit FindByTimestampMapQuery(const SnapshotRepositoryROAccess& repository) : repository_{repository} {} auto exec(SnapshotRepositoryROAccess::Timestamp t, auto&&... args) { auto bundle_ptr = repository_.find_bundle(t); if (bundle_ptr) { TSegmentQuery query{*bundle_ptr}; return query.exec(args...); } // std::nullopt return decltype(std::declval().exec(args...)){}; } protected: const SnapshotRepositoryROAccess& repository_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED COMPONENTS strings) find_package(Boost REQUIRED COMPONENTS headers url) find_package(GTest REQUIRED) find_package(LibtorrentRasterbar REQUIRED) find_package(magic_enum REQUIRED) # cmake-format: off set(LIBS_PRIVATE absl::strings LibtorrentRasterbar::torrent-rasterbar magic_enum::magic_enum ) # cmake-format: on # cmake-format: off set(LIBS_PUBLIC Boost::headers Boost::url silkworm_core silkworm_infra ) # cmake-format: on silkworm_library( silkworm_bittorrent PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) target_link_libraries(silkworm_bittorrent_test PRIVATE GTest::gmock silkworm_infra_test_util) ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/client.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "client.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "trackers.hpp" namespace silkworm::snapshots::bittorrent { namespace fs = std::filesystem; using namespace std::chrono_literals; std::vector BitTorrentClient::load_file(const fs::path& filename) { if (!std::filesystem::exists(filename)) return {}; std::ifstream input_file_stream{filename, std::ios::binary | std::ios::ate}; input_file_stream.exceptions(std::ios::failbit | std::ios::badbit); std::streamsize file_size = input_file_stream.tellg(); std::vector contents(static_cast(file_size)); input_file_stream.seekg(0); input_file_stream.read(contents.data(), file_size); return contents; } void BitTorrentClient::save_file(const fs::path& filename, const std::vector& data) { SILK_TRACE << "Save #data=" << data.size() << " in file: " << filename; std::ofstream output_file_stream{filename, std::ios::binary | std::ios::trunc}; output_file_stream.exceptions(std::ios::failbit | std::ios::badbit); output_file_stream.write(data.data(), static_cast(data.size())); } BitTorrentClient::BitTorrentClient(BitTorrentSettings settings) : settings_(std::move(settings)), session_file_{settings_.repository_path / fs::path{kSessionFileName}}, resume_dir_{settings_.repository_path / fs::path{kResumeDirName}}, session_{load_or_create_session_parameters()} { SILK_TRACE << "BitTorrentClient::BitTorrentClient start"; auto torrents_params = load_resume_data(); for (auto& params : torrents_params) { session_.async_add_torrent(std::move(params)); } last_save_resume_ = std::chrono::steady_clock::now(); SILK_TRACE << "Torrents #total: " << torrents_params.size(); } BitTorrentClient::~BitTorrentClient() { BitTorrentClient::stop(); } void BitTorrentClient::add_info_hash(std::string_view name, std::string_view info_hash) { add_info_hash(name, info_hash, kBestTrackers); } void BitTorrentClient::add_info_hash(std::string_view name, std::string_view info_hash, std::vector trackers) { lt::sha1_hash sha1_info_hash; lt::aux::from_hex(info_hash, sha1_info_hash.data()); lt::info_hash_t info_hashes{sha1_info_hash}; if (exists_resume_file(info_hashes)) { SILK_TRACE << "Resume file found: " << resume_file_path(info_hashes); return; } lt::add_torrent_params torrent; torrent.name = name; torrent.info_hashes = info_hashes; torrent.save_path = settings_.repository_path.string(); torrent.trackers = std::move(trackers); session_.async_add_torrent(std::move(torrent)); SILK_TRACE << "BitTorrentClient::add_info_hash: " << info_hash << " added"; } void BitTorrentClient::add_torrent_info(std::shared_ptr info) { lt::add_torrent_params torrent; torrent.ti = std::move(info); torrent.save_path = settings_.repository_path.string(); session_.async_add_torrent(std::move(torrent)); SILK_TRACE << "BitTorrentClient::add_torrent_info added"; } bool BitTorrentClient::stop() { SILK_TRACE << "BitTorrentClient::stop start"; bool changed = ActiveComponent::stop(); if (changed) { stop_condition_.notify_one(); } SILK_TRACE << "BitTorrentClient::stop end"; return changed; } lt::session_params BitTorrentClient::load_or_create_session_parameters() const { // Restore session parameters from old session, if any const auto prev_session_data = BitTorrentClient::load_file(session_file_); auto session_params = prev_session_data.empty() ? lt::session_params{} : lt::read_session_params(prev_session_data); // Customize the session settings auto& settings = session_params.settings; settings.set_int(lt::settings_pack::alert_mask, lt::alert_category::error | lt::alert_category::storage | lt::alert_category::status | lt::alert_category::performance_warning); settings.set_int(lt::settings_pack::download_rate_limit, settings_.download_rate_limit * int{1_Mebi}); settings.set_int(lt::settings_pack::upload_rate_limit, settings_.upload_rate_limit * int{1_Mebi}); settings.set_int(lt::settings_pack::active_downloads, settings_.active_downloads); settings.set_int(lt::settings_pack::max_out_request_queue, settings_.max_out_request_queue); settings.set_int(lt::settings_pack::aio_threads, settings_.aio_threads); settings.set_bool(lt::settings_pack::announce_to_all_tiers, settings_.announce_to_all_tiers); settings.set_bool(lt::settings_pack::enable_dht, false); return session_params; } std::vector BitTorrentClient::load_resume_data() const { fs::create_directories(settings_.repository_path); ensure(fs::exists(settings_.repository_path), "BitTorrentClient: repository path does not exist"); ensure(fs::is_directory(settings_.repository_path), "BitTorrentClient: repository path is not a directory"); SILK_TRACE << "Torrent repository folder: " << settings_.repository_path.string(); fs::create_directories(resume_dir_); ensure(fs::exists(resume_dir_), "BitTorrentClient: resume path does not exist"); ensure(fs::is_directory(resume_dir_), "BitTorrentClient: resume path is not a directory"); SILK_TRACE << "Resume folder: " << resume_dir_; std::vector torrents_params; for (const auto& file : fs::directory_iterator{resume_dir_}) { if (!fs::is_regular_file(file.path()) || file.path().extension() != kResumeFileExt) { continue; } SILK_TRACE << "File path: " << file.path() << " name: " << file.path().filename(); const auto resume_data = load_file(file.path().string()); if (!resume_data.empty()) { auto params = lt::read_resume_data(resume_data); params.save_path = settings_.repository_path.string(); torrents_params.push_back(std::move(params)); } } SILK_TRACE << "Torrents #resumed: " << torrents_params.size(); return torrents_params; } void BitTorrentClient::add_magnet_uri(const std::string& magnet_uri) { SILK_TRACE << "Magnet URI from file: " << magnet_uri; auto add_magnet = lt::parse_magnet_uri(magnet_uri); if (exists_resume_file(add_magnet.info_hashes)) { SILK_TRACE << "Resume file found: " << resume_file_path(add_magnet.info_hashes); return; } add_magnet.save_path = settings_.repository_path.string(); session_.async_add_torrent(std::move(add_magnet)); } fs::path BitTorrentClient::resume_file_path(const lt::info_hash_t& info_hashes) const { const lt::sha1_hash torrent_best_hash{info_hashes.get_best()}; auto resume_file_name = to_hex({reinterpret_cast(torrent_best_hash.data()), lt::sha1_hash::size()}); resume_file_name.append(kResumeFileExt); SILK_TRACE << "Resume file name: " << resume_file_name; return resume_dir_ / resume_file_name; } bool BitTorrentClient::exists_resume_file(const lt::info_hash_t& info_hashes) const { return std::filesystem::exists(resume_file_path(info_hashes)); } void BitTorrentClient::execution_loop() { SILK_TRACE << "BitTorrentClient::execution_loop start"; stats_metrics_ = lt::session_stats_metrics(); int poll_count{0}; bool stopped{false}; while (!stopped) { poll_count = poll_count % settings_.number_of_polls_between_stats; request_torrent_updates(!poll_count); process_alerts(); std::unique_lock stop_lock{stop_mutex_}; stopped = stop_condition_.wait_for(stop_lock, settings_.wait_between_alert_polls, [this] { return is_stopping(); }); } SILK_TRACE << "Execution loop completed [stop_condition=" << is_stopping() << "]"; request_save_resume_data(lt::torrent_handle::save_info_dict); while (outstanding_resume_requests_ > 0) { const auto* alert = session_.wait_for_alert(settings_.wait_between_alert_polls); if (alert == nullptr) continue; process_alerts(); } SILK_TRACE << "Resume data saved after execution loop completion"; const auto session_params_data{lt::write_session_params_buf(session_.session_state())}; BitTorrentClient::save_file(session_file_, session_params_data); SILK_TRACE << "Session saved after execution loop completion"; SILK_TRACE << "BitTorrentClient::execution_loop end"; } void BitTorrentClient::recheck_all_finished_torrents() const { int rechecked_count{0}; for (const auto& torrent_handle : session_.get_torrents()) { // NOLINT(readability-use-anyofallof) if (torrent_handle.status().is_finished) { torrent_handle.force_recheck(); ++rechecked_count; } } SILK_INFO << "Recheck finished torrents count=" << rechecked_count; } void BitTorrentClient::request_torrent_updates(bool stats_included) { SILK_TRACE << "BitTorrentClient::request_torrent_updates start"; // Ask the session to post update alerts for our torrents session_.post_torrent_updates(); if (stats_included) { session_.post_session_stats(); } // Save resume data every once in a while if (std::chrono::steady_clock::now() - last_save_resume_ >= settings_.resume_data_save_interval) { request_save_resume_data(lt::torrent_handle::save_info_dict); last_save_resume_ = std::chrono::steady_clock::now(); } SILK_TRACE << "BitTorrentClient::request_torrent_updates end"; } void BitTorrentClient::request_save_resume_data(lt::resume_data_flags_t flags) { SILK_TRACE << "BitTorrentClient::request_save_resume_data start"; const auto if_need_save_resume = [](auto& ts) { return ts.need_save_resume; }; for (const auto& torrent_status : session_.get_torrent_status(if_need_save_resume)) { torrent_status.handle.save_resume_data(flags); ++outstanding_resume_requests_; SILK_TRACE << "Save resume data requested for: " << torrent_status.name; } SILK_TRACE << "BitTorrentClient::request_save_resume_data end"; } void BitTorrentClient::process_alerts() { std::vector session_alerts; session_.pop_alerts(&session_alerts); SILK_TRACE << "Session raised #alerts: " << session_alerts.size(); for (const auto* alert : session_alerts) { handle_alert(alert); } } bool BitTorrentClient::handle_alert(const lt::alert* alert) { bool handled{false}; if (const auto ata = lt::alert_cast(alert)) { if (ata->error) { SILK_ERROR << "Failed to add torrent: " << (ata->params.ti ? ata->params.ti->name() : ata->params.name) << " message: " << ata->error.message(); } else { SILK_TRACE << "Torrent: " << ata->torrent_name() << " added"; ata->handle.save_resume_data(lt::torrent_handle::save_info_dict | lt::torrent_handle::only_if_modified); ++outstanding_resume_requests_; // Notify that torrent file has been added to registered subscribers added_subscription(settings_.repository_path / ata->torrent_name()); } handled = true; } // When we receive the finished alert, we request to save resume data for the torrent if (const auto* tfa = lt::alert_cast(alert)) { const auto& status = tfa->handle.status(); std::tm completed_calendar_time{}; #ifdef _MSC_VER SILKWORM_ASSERT(gmtime_s(&completed_calendar_time, &status.completed_time) == 0); #else SILKWORM_ASSERT(gmtime_r(&status.completed_time, &completed_calendar_time) != nullptr); #endif SILK_TRACE << "Torrent: " << tfa->torrent_name() << " finished download_rate: " << (status.download_rate / 1000) << " kB/s" << " download_payload_rate: " << (status.download_payload_rate / 1000) << " kB/s" << " in " << (status.completed_time - status.added_time) << " sec at " << std::put_time(&completed_calendar_time, "%c %Z"); tfa->handle.save_resume_data(lt::torrent_handle::save_info_dict | lt::torrent_handle::flush_disk_cache); ++outstanding_resume_requests_; // Notify that torrent file has been downloaded to registered subscribers completed_subscription(settings_.repository_path / tfa->torrent_name()); handled = true; } if (const auto* mra = alert_cast(alert)) { SILK_TRACE << "Torrent: " << mra->torrent_name() << " metadata received"; mra->handle.save_resume_data(lt::torrent_handle::save_info_dict); ++outstanding_resume_requests_; handled = true; } // When resume data is ready, we save it to disk if (const auto* rda = lt::alert_cast(alert)) { const auto resume_params_data{lt::write_resume_data_buf(rda->params)}; BitTorrentClient::save_file(resume_file_path(rda->params.info_hashes), resume_params_data); SILK_TRACE << "Torrent: " << rda->torrent_name() << " resume data saved"; --outstanding_resume_requests_; handled = true; } if (const auto fa = lt::alert_cast(alert)) { SILK_TRACE << "Torrent: " << fa->torrent_name() << " save resume data failed [" << (fa->error == lt::errors::resume_data_not_modified ? "not modified" : ("error=" + fa->error.to_string())) << "]"; --outstanding_resume_requests_; handled = true; } // When we receive a state update, report stats if (const auto sta = lt::alert_cast(alert)) { if (!sta->status.empty()) { for (const auto& ts : sta->status) { SILK_TRACE << "Torrent: " << ts.name << " id: " << ts.handle.id() << " state: " << magic_enum::enum_name(ts.state) << " " << (ts.download_payload_rate / 1'000'000) << " MB/s " << (ts.total_done / 1'000'000) << " MB (" << (ts.progress_ppm / 10'000) << "%) downloaded (" << ts.num_peers << " peers)"; } } else { SILK_TRACE << "Empty state update alert:" << sta->message(); } handled = true; } // When we receive any session stats alert, report stats if (const auto ssa = lt::alert_cast(alert)) { stats_subscription(ssa->counters()); handled = true; } // When we receive any error alert, put it out as warning if required (there can be many) if (settings_.warn_on_error_alerts) { if (const auto tea = lt::alert_cast(alert)) { SILK_WARN << "tracker_error_alert: " << alert->message() << " [error=" << tea->error_message() << " reason=" << tea->failure_reason() << "]"; handled = true; } if (const auto sfa = lt::alert_cast(alert)) { SILK_WARN << "scrape_failed_alert: " << alert->message() << " [error=" << sfa->error_message() << " what=" << sfa->what() << "]"; handled = true; } if (const auto sea = lt::alert_cast(alert)) { SILK_WARN << "session_error_alert: " << alert->message() << " [error_code=" << sea->error << " what=" << sea->what() << "]"; handled = true; } if (const auto pea = lt::alert_cast(alert)) { SILK_WARN << "peer_error_alert: " << alert->message() << " [error_code=" << pea->error << " what=" << pea->what() << "]"; handled = true; } if (const auto tea = lt::alert_cast(alert)) { SILK_WARN << "torrent_error_alert: " << alert->message() << " [error_code=" << tea->error << " what=" << tea->what() << "]"; handled = true; } } // When we receive any performance alert, put it out as warning if (const auto pa = lt::alert_cast(alert)) { SILK_WARN << alert->message() << " [warning_code=" << pa->warning_code << "]"; handled = true; } // Finally, if an alert has not been unhandled yet, just log it for debug purposes if (!handled) { SILK_TRACE << alert->message(); } return handled; } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include // Disable warnings raised during compilation of libtorrent #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-compat" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wsign-conversion" #include #include #include #pragma GCC diagnostic pop #include #include "settings.hpp" namespace silkworm::snapshots::bittorrent { //! The BitTorrent protocol client handling multiple torrents *asynchronously* using one thread. //! \details The user code should probably run the `execute_loop` method in a dedicated thread. class BitTorrentClient : public ActiveComponent { public: static constexpr std::string_view kSessionFileName{".session"}; static constexpr std::string_view kResumeDirName{".resume"}; static constexpr std::string_view kResumeFileExt{".resume"}; using FileCallback = void(const std::filesystem::path&); using StatsCallback = void(lt::span counters); explicit BitTorrentClient(BitTorrentSettings settings); ~BitTorrentClient() override; const BitTorrentSettings& settings() const { return settings_; } //! Subscription for torrent added announcements boost::signals2::signal added_subscription; //! Subscription for torrent metrics' announcements boost::signals2::signal stats_subscription; //! Subscription for torrent completion announcements boost::signals2::signal completed_subscription; const std::vector& stats_metrics() const { return stats_metrics_; } //! Add the specified info hash to the download list void add_info_hash(std::string_view name, std::string_view info_hash); //! Add the specified info hash to the download list void add_info_hash(std::string_view name, std::string_view info_hash, std::vector trackers); //! Add the specified torrent info to the download list void add_torrent_info(std::shared_ptr info); //! Add the specified magnet link to the download list void add_magnet_uri(const std::string& magnet_uri); //! Run the client execution loop until it is stopped or has finished downloading and seeding is not required void execution_loop() override; //! Ask the client to stop execution bool stop() override; void recheck_all_finished_torrents() const; protected: static std::vector load_file(const std::filesystem::path& filename); static void save_file(const std::filesystem::path& filename, const std::vector& data); lt::session_params load_or_create_session_parameters() const; std::vector load_resume_data() const; std::filesystem::path resume_file_path(const lt::info_hash_t& info_hashes) const; bool exists_resume_file(const lt::info_hash_t& info_hashes) const; void request_torrent_updates(bool stats_included); void request_save_resume_data(lt::resume_data_flags_t flags); void process_alerts(); bool handle_alert(const lt::alert* alert); private: //! The BitTorrent client configuration parameters BitTorrentSettings settings_; //! The file containing the session state std::filesystem::path session_file_; //! The directory containing the resume state files std::filesystem::path resume_dir_; //! The session statistics std::vector stats_metrics_; //! The number of save resume data requests still outstanding int outstanding_resume_requests_{0}; //! The last time when resume state has been saved std::chrono::steady_clock::time_point last_save_resume_; //! Mutual exclusion access to the stop condition std::mutex stop_mutex_; //! Condition indicating that the client should stop std::condition_variable stop_condition_; protected: //! The BitTorrent client session lt::session session_; }; } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/client_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "client.hpp" #include #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include #include namespace silkworm::snapshots::bittorrent { using namespace std::chrono_literals; //! BitTorrentClient with protected methods exposed for test class BitTorrentClientForTest : public BitTorrentClient { public: using BitTorrentClient::BitTorrentClient; using BitTorrentClient::handle_alert; using BitTorrentClient::load_file; using BitTorrentClient::process_alerts; using BitTorrentClient::request_save_resume_data; using BitTorrentClient::request_torrent_updates; using BitTorrentClient::save_file; lt::torrent_handle add_torrent(lt::add_torrent_params params) { return session_.add_torrent(std::move(params)); } }; class ClientThread { public: explicit ClientThread(BitTorrentClient& client) : thread_([&client]() { client.execution_loop(); }) {} ~ClientThread() { thread_.join(); } private: std::thread thread_; }; //! Generate test data for resume file content //! \details https://github.com/arvidn/libtorrent/blob/RC_2_0/test/test_read_resume.cpp static std::vector test_resume_data() { lt::entry rd; rd["file-format"] = "libtorrent resume file"; rd["file-version"] = 1; rd["info-hash"] = "abcdefghijklmnopqrst"; rd["pieces"] = "\x01\x01\x01\x01\x01\x01"; rd["total_uploaded"] = 1337; rd["total_downloaded"] = 1338; rd["active_time"] = 1339; rd["seeding_time"] = 1340; rd["upload_rate_limit"] = 1343; rd["download_rate_limit"] = 1344; rd["max_connections"] = 1345; rd["max_uploads"] = 1346; rd["seed_mode"] = 0; rd["super_seeding"] = 0; rd["added_time"] = 1347; rd["completed_time"] = 1348; rd["finished_time"] = 1352; rd["last_seen_complete"] = 1353; rd["piece_priority"] = "\x01\x02\x03\x04\x05\x06"; rd["auto_managed"] = 0; rd["sequential_download"] = 0; rd["paused"] = 0; std::vector resume_data; lt::bencode(std::back_inserter(resume_data), rd); return resume_data; } TEST_CASE("BitTorrentClient::load_file", "[silkworm][snapshot][bittorrent]") { TemporaryDirectory tmp_dir; const auto path = tmp_dir.path() / "test.resume"; const auto resume_data = test_resume_data(); BitTorrentClientForTest::save_file(path, resume_data); CHECK(BitTorrentClientForTest::load_file(path) == resume_data); } TEST_CASE("BitTorrentClient::BitTorrentClient", "[silkworm][snapshot][bittorrent]") { TemporaryDirectory tmp_dir; BitTorrentSettings settings; settings.repository_path = tmp_dir.path(); SECTION("default settings") { CHECK_NOTHROW(BitTorrentClient{settings}); } SECTION("one invalid magnet link") { BitTorrentClient client{settings}; // The following magnet link has malformed URL format ("unsupported URL protocol") CHECK_THROWS_AS(client.add_magnet_uri("magnet::?xt=urn:btih:df09957d8a28af3bc5137478885a8003677ca878"), std::runtime_error); } SECTION("nonempty resume dir") { const auto resume_dir_path = settings.repository_path / BitTorrentClient::kResumeDirName; std::filesystem::create_directories(resume_dir_path); const auto ignored_file{resume_dir_path / "a.txt"}; BitTorrentClientForTest::save_file(ignored_file, std::vector{}); const auto empty_resume_file{resume_dir_path / "a.resume"}; BitTorrentClientForTest::save_file(empty_resume_file, std::vector{}); const auto valid_resume_file{resume_dir_path / "83112dec4bec180cff67e01d6345c88c3134fd26.resume"}; std::vector resume_data{test_resume_data()}; BitTorrentClientForTest::save_file(valid_resume_file, resume_data); CHECK_NOTHROW(BitTorrentClient{settings}); } } TEST_CASE("BitTorrentClient::add_info_hash", "[silkworm][snapshot][bittorrent]") { TemporaryDirectory tmp_dir; BitTorrentSettings settings; settings.repository_path = tmp_dir.path(); static constexpr std::string_view kTrackerUrl{"udp://127.0.0.1:1337/announce"}; SECTION("invalid info hash") { BitTorrentClient client{settings}; client.add_info_hash("test.seg", "df09957d8a28af3bc5137478885a8003677ca8", {std::string{kTrackerUrl}}); ClientThread client_thread{client}; CHECK_NOTHROW(client.stop()); } SECTION("valid info hash") { BitTorrentClient client{settings}; client.add_info_hash("test.seg", "df09957d8a28af3bc5137478885a8003677ca878", {std::string{kTrackerUrl}}); ClientThread client_thread{client}; CHECK_NOTHROW(client.stop()); } } TEST_CASE("BitTorrentClient::execute_loop", "[silkworm][snapshot][bittorrent]") { TemporaryDirectory tmp_dir; BitTorrentSettings settings; settings.repository_path = tmp_dir.path(); SECTION("nonempty magnet file") { BitTorrentClient client{settings}; client.add_magnet_uri("magnet:?xt=urn:btih:df09957d8a28af3bc5137478885a8003677ca878"); ClientThread client_thread{client}; CHECK_NOTHROW(client.stop()); } } TEST_CASE("BitTorrentClient::stop", "[silkworm][snapshot][bittorrent]") { TemporaryDirectory tmp_dir; BitTorrentSettings settings; settings.repository_path = tmp_dir.path(); SECTION("before starting") { BitTorrentClient client{settings}; CHECK_NOTHROW(client.stop()); } SECTION("after empty execution loop") { BitTorrentClient client{settings}; ClientThread client_thread{client}; CHECK_NOTHROW(client.stop()); } } TEST_CASE("BitTorrentClient::request_torrent_updates", "[silkworm][snapshot][bittorrent]") { SECTION("trigger save resume data twice") { constexpr std::chrono::seconds kResumeDataSaveInterval{1}; TemporaryDirectory tmp_dir; BitTorrentSettings settings; settings.repository_path = tmp_dir.path(); settings.resume_data_save_interval = kResumeDataSaveInterval; BitTorrentClientForTest client{settings}; CHECK_NOTHROW(client.request_torrent_updates(false)); std::this_thread::sleep_for(kResumeDataSaveInterval); CHECK_NOTHROW(client.request_torrent_updates(false)); } } TEST_CASE("BitTorrentClient::process_alerts", "[silkworm][snapshot][bittorrent]") { SECTION("one empty magnet link") { TemporaryDirectory tmp_dir; BitTorrentSettings settings; settings.repository_path = tmp_dir.path(); BitTorrentClientForTest client{settings}; // The following magnet link is empty client.add_magnet_uri("magnet:?xt=urn:btih:df09957d8a28af3bc5137478885a8003677ca878"); CHECK_NOTHROW(client.process_alerts()); } } TEST_CASE("BitTorrentClient::handle_alert", "[silkworm][snapshot][bittorrent]") { TemporaryDirectory tmp_dir; BitTorrentSettings settings; settings.repository_path = tmp_dir.path(); BitTorrentClientForTest client{settings}; lt::aux::stack_allocator allocator; lt::add_torrent_params params = lt::parse_magnet_uri("magnet:?xt=urn:btih:df09957d8a28af3bc5137478885a8003677ca878"); params.save_path = settings.repository_path.string(); lt::torrent_handle handle = client.add_torrent(params); SECTION("lt::add_torrent_alert is handled") { lt::error_code ec; lt::add_torrent_alert alert{allocator, handle, params, ec}; CHECK_NOTHROW(client.handle_alert(&alert)); } SECTION("lt::torrent_finished_alert is handled") { lt::torrent_finished_alert alert{allocator, handle}; CHECK_NOTHROW(client.handle_alert(&alert)); } SECTION("lt::metadata_received_alert is handled") { lt::metadata_received_alert alert{allocator, handle}; CHECK_NOTHROW(client.handle_alert(&alert)); } SECTION("lt::save_resume_data_alert is handled") { lt::save_resume_data_alert alert{allocator, lt::add_torrent_params{params}, handle}; CHECK_NOTHROW(client.handle_alert(&alert)); } SECTION("lt::save_resume_data_failed_alert is handled") { lt::error_code ec; lt::save_resume_data_failed_alert alert{allocator, handle, ec}; CHECK_NOTHROW(client.handle_alert(&alert)); } SECTION("lt::state_update_alert is handled") { std::vector statuses; lt::state_update_alert alert{allocator, statuses}; CHECK_NOTHROW(client.handle_alert(&alert)); } SECTION("lt::performance_alert is handled") { lt::performance_alert alert{allocator, handle, lt::performance_alert::outstanding_request_limit_reached}; CHECK_NOTHROW(client.handle_alert(&alert)); } SECTION("other alerts are NOT handled") { lt::torrent_removed_alert alert1{allocator, handle, lt::info_hash_t{}, lt::client_data_t{}}; CHECK_NOTHROW(!client.handle_alert(&alert1)); lt::file_completed_alert alert2{allocator, handle, 1}; CHECK_NOTHROW(!client.handle_alert(&alert2)); } SECTION("added_subscription is notified") { std::promise added_promise; auto handle_added = [&](const std::filesystem::path& added_path) { added_promise.set_value(added_path); }; client.added_subscription.connect(handle_added); lt::error_code ec; lt::add_torrent_alert alert{allocator, handle, params, ec}; REQUIRE(client.handle_alert(&alert)); CHECK_NOTHROW(added_promise.get_future().get()); } SECTION("stats_subscription is notified") { std::promise> stats_promise; auto handle_stats = [&](lt::span counters) { stats_promise.set_value(counters); }; client.stats_subscription.connect(handle_stats); lt::session_stats_alert alert{allocator, lt::counters{}}; REQUIRE(client.handle_alert(&alert)); CHECK_NOTHROW(stats_promise.get_future().get()); } SECTION("completed_subscription is notified") { std::promise completed_promise; auto handle_completed = [&](const std::filesystem::path& added_path) { completed_promise.set_value(added_path); }; client.completed_subscription.connect(handle_completed); lt::torrent_finished_alert alert{allocator, handle}; REQUIRE(client.handle_alert(&alert)); CHECK_NOTHROW(completed_promise.get_future().get()); } } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/root_certificates.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // See also: https://github.com/boostorg/beast/blob/develop/example/common/root_certificates.hpp #include #include #include namespace silkworm::snapshots::bittorrent { // Including root certificates is theoretically a bad practice for performing // TLS certificate verification, but doing the right thing can be typically // unfeasible for many reasons (e.g. OpenSSL not async) // Why embedding root certificates is not a terrible idea after all: // https://github.com/boostorg/beast/issues/1534 // https://github.com/djarek/certify/issues/58#issuecomment-589948804 namespace ssl = boost::asio::ssl; namespace detail { //! \brief Return the list of root Certification Authority (CA) certificates inline std::string root_certificates() { std::string cert; cert += "# ISRG Root X1\n" "-----BEGIN CERTIFICATE-----\n" "MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw\n" "TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh\n" "cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4\n" "WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu\n" "ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY\n" "MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc\n" "h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+\n" "0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U\n" "A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW\n" "T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH\n" "B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC\n" "B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv\n" "KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn\n" "OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn\n" "jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw\n" "qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI\n" "rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV\n" "HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq\n" "hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL\n" "ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ\n" "3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK\n" "NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5\n" "ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur\n" "TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC\n" "jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc\n" "oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq\n" "4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA\n" "mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d\n" "emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=\n" "-----END CERTIFICATE-----\n" "\n"; return cert; } } // namespace detail //! \brief Load the root CA certificates into a ssl::context //! \param ctx the SSL context where to load certificates //! \param server_cert optional custom server certificate to append to root certificates //! \throw boost::system::system_error if an error occurs inline void load_root_certificates(ssl::context& ctx, const std::optional& server_cert = {}) { auto cert = detail::root_certificates(); if (server_cert) { cert.append("\n\n"); cert.append(*server_cert); } ctx.add_certificate_authority(boost::asio::buffer(cert.data(), cert.size())); } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/root_certificates_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "root_certificates.hpp" #include #include namespace silkworm::snapshots::bittorrent { TEST_CASE("load_root_certificates", "[db][snapshot][bittorrent]") { ssl::context ssl_ctx{ssl::context::tlsv13_client}; CHECK_NOTHROW(load_root_certificates(ssl_ctx)); } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::snapshots::bittorrent { //! The settings for handling BitTorrent protocol struct BitTorrentSettings { static inline const std::filesystem::path kDefaultTorrentRepoPath{".torrent"}; /* BitTorrentClient configuration settings */ //! Directory path where torrent files will be stored std::filesystem::path repository_path{kDefaultTorrentRepoPath}; //! Time interval between two alert polling loops std::chrono::seconds wait_between_alert_polls{1}; //! The number of alert polls between two contiguous stats requests int number_of_polls_between_stats{30}; //! Time interval between two resume data savings std::chrono::seconds resume_data_save_interval{60}; //! Flag indicating if BitTorrent failure/error alerts should be treated as warnings bool warn_on_error_alerts{false}; /* BitTorrent protocol settings */ int download_rate_limit{64}; // 64MiB int upload_rate_limit{4}; // 4MiB int active_downloads{6}; int max_out_request_queue{6000}; bool announce_to_all_tiers{true}; int aio_threads{32}; }; } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/torrent_file.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "torrent_file.hpp" #include #include #include #include #include #include #include #include #include #include #include "trackers.hpp" namespace silkworm::snapshots::bittorrent { static constexpr int kDefaultPieceSize = static_cast(2_Mebi); TorrentFile::TorrentFile(ByteView data) : params_(lt::load_torrent_buffer(byte_view_to_str_span(data))) { } TorrentFile::TorrentFile(const std::filesystem::path& path) : params_(lt::load_torrent_file(path.string())) { } TorrentFile TorrentFile::from_source_file(const std::filesystem::path& source_file_path, std::time_t creation_date) { lt::file_storage storage; lt::create_flags_t flags = lt::create_torrent::v1_only; lt::add_files(storage, source_file_path.string(), flags); lt::create_torrent torrent{storage, kDefaultPieceSize, flags}; lt::set_piece_hashes(torrent, source_file_path.parent_path().string()); torrent.set_creator("silkworm"); if (creation_date > 0) { torrent.set_creation_date(creation_date); } for (auto& tracker : kBestTrackers) { torrent.add_tracker(tracker, 0); } std::string data; lt::bencode(std::back_inserter(data), torrent.generate()); return TorrentFile{string_view_to_byte_view(data)}; } std::string TorrentFile::info_hash() const { std::stringstream stream; stream << params_.ti->info_hashes().get_best(); return stream.str(); } Bytes TorrentFile::to_bytes() const { std::string data; lt::bencode(std::back_inserter(data), lt::write_torrent_file(params_)); return string_to_bytes(data); } void TorrentFile::save(const std::filesystem::path& path) const { Bytes data = to_bytes(); std::ofstream file{path, std::ios::binary | std::ios::trunc}; file.exceptions(std::ios::failbit | std::ios::badbit); file << byte_view_to_string_view(data); } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/torrent_file.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include // Disable warnings raised during compilation of libtorrent #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include namespace silkworm::snapshots::bittorrent { class TorrentFile { public: explicit TorrentFile(ByteView data); explicit TorrentFile(const std::filesystem::path& path); static TorrentFile from_source_file(const std::filesystem::path& source_file_path, std::time_t creation_date = 0); const lt::add_torrent_params& params() const { return params_; } std::string info_hash() const; Bytes to_bytes() const; void save(const std::filesystem::path& path) const; private: lt::add_torrent_params params_; }; } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/torrent_file_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "torrent_file.hpp" #include #include namespace silkworm::snapshots::bittorrent { // generated using: // xxd -i v1-000000-000500-bodies.seg.torrent unsigned char v1_000000_000500_bodies_seg_torrent[] = { 0x64, 0x31, 0x33, 0x3a, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x6c, 0x6c, 0x34, 0x32, 0x3a, 0x75, 0x64, 0x70, 0x3a, 0x2f, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x72, 0x2e, 0x6f, 0x72, 0x67, 0x3a, 0x31, 0x33, 0x33, 0x37, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x34, 0x36, 0x3a, 0x75, 0x64, 0x70, 0x3a, 0x2f, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x62, 0x69, 0x74, 0x74, 0x6f, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x3a, 0x36, 0x39, 0x36, 0x39, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x34, 0x31, 0x3a, 0x75, 0x64, 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x69, 0x32, 0x70, 0x2e, 0x72, 0x6f, 0x63, 0x6b, 0x73, 0x3a, 0x36, 0x39, 0x36, 0x39, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x34, 0x31, 0x3a, 0x75, 0x64, 0x70, 0x3a, 0x2f, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x74, 0x6f, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x2e, 0x65, 0x75, 0x2e, 0x6f, 0x72, 0x67, 0x3a, 0x34, 0x35, 0x31, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x33, 0x33, 0x3a, 0x75, 0x64, 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x2e, 0x73, 0x74, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x2e, 0x73, 0x69, 0x3a, 0x38, 0x30, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x65, 0x65, 0x31, 0x30, 0x3a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x36, 0x3a, 0x65, 0x72, 0x69, 0x67, 0x6f, 0x6e, 0x31, 0x33, 0x3a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x61, 0x74, 0x65, 0x69, 0x31, 0x37, 0x31, 0x38, 0x39, 0x37, 0x34, 0x33, 0x34, 0x38, 0x65, 0x34, 0x3a, 0x69, 0x6e, 0x66, 0x6f, 0x64, 0x36, 0x3a, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x69, 0x31, 0x30, 0x33, 0x33, 0x33, 0x37, 0x35, 0x30, 0x65, 0x34, 0x3a, 0x6e, 0x61, 0x6d, 0x65, 0x32, 0x37, 0x3a, 0x76, 0x31, 0x2d, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2d, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x2d, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x2e, 0x73, 0x65, 0x67, 0x31, 0x32, 0x3a, 0x70, 0x69, 0x65, 0x63, 0x65, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x69, 0x32, 0x30, 0x39, 0x37, 0x31, 0x35, 0x32, 0x65, 0x36, 0x3a, 0x70, 0x69, 0x65, 0x63, 0x65, 0x73, 0x31, 0x30, 0x30, 0x3a, 0x04, 0xeb, 0x75, 0x01, 0x87, 0xd1, 0x75, 0x8c, 0x58, 0x9a, 0x45, 0x8d, 0x85, 0x50, 0x56, 0x19, 0x0d, 0xf7, 0x83, 0x0c, 0x86, 0x9a, 0x0c, 0x6a, 0x02, 0xc3, 0xce, 0x99, 0x9b, 0x22, 0x60, 0x6b, 0x6f, 0x12, 0x84, 0x55, 0xa4, 0x86, 0xcd, 0x93, 0xd0, 0xf2, 0xb4, 0x44, 0x01, 0x39, 0xcb, 0x15, 0x4c, 0x5e, 0x6c, 0xed, 0x07, 0x74, 0xbe, 0x69, 0x94, 0x9c, 0xbd, 0x84, 0x1f, 0x09, 0x8f, 0x64, 0x7d, 0x76, 0x4c, 0x1c, 0xd2, 0xab, 0xc7, 0x3f, 0xd6, 0x20, 0x8b, 0xa2, 0x60, 0x97, 0x87, 0xec, 0x12, 0x1e, 0x31, 0x72, 0xa2, 0x69, 0x8c, 0xd2, 0x7d, 0x60, 0xbc, 0xf4, 0x2e, 0x2e, 0x2b, 0xb6, 0x2a, 0x85, 0xd4, 0x79, 0x65, 0x65}; unsigned int v1_000000_000500_bodies_seg_torrent_len = 487; #ifdef SILKWORM_TEST_SKIP TEST_CASE("TorrentFile") { SKIP("Needs a valid snapshot file at the kInputFilePath"); static const std::filesystem::path kInputFilePath{"/erigon-data/snapshots/v1-000000-000500-bodies.seg"}; ByteView expected{v1_000000_000500_bodies_seg_torrent, v1_000000_000500_bodies_seg_torrent_len}; // libtorrent reorders "announce-list", "created by" and "creation date" might be different, // so we compare only the part after the "info" key static constexpr char kInfoKeyPrefix[] = "4:infod"; size_t expected_offset = expected.find(byte_ptr_cast(kInfoKeyPrefix)); auto file = TorrentFile::from_source_file(kInputFilePath, 1718974348); Bytes actual = file.to_bytes(); size_t actual_offset = actual.find(byte_ptr_cast(kInfoKeyPrefix)); CHECK(actual.substr(actual_offset) == expected.substr(expected_offset)); } #endif // SILKWORM_TEST_SKIP } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/trackers.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "trackers.hpp" namespace silkworm::snapshots::bittorrent { const std::vector kBestTrackers{ "udp://tracker.opentrackr.org:1337/announce", "udp://tracker.openbittorrent.com:6969/announce", "udp://opentracker.i2p.rocks:6969/announce", "udp://tracker.torrent.eu.org:451/announce", "udp://open.stealth.si:80/announce", }; } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/trackers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::snapshots::bittorrent { extern const std::vector kBestTrackers; } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/web_seed_client.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "web_seed_client.hpp" #include #include #include #include #include #include #include #include // Disable warnings raised during compilation of libtorrent #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-compat" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include #include namespace silkworm::snapshots::bittorrent { using namespace std::literals; namespace system = boost::system; namespace urls = boost::urls; //! HTTP target for Manifest file containing the list of available snapshot files static constexpr std::string_view kManifestTarget{"/manifest.txt"}; //! The BitTorrent file extension for torrent files static constexpr std::string_view kTorrentExtension{".torrent"}; //! Timeout for parallel async download of manifest files in msec static const std::chrono::milliseconds kParallelManifestDownloadTimeout{60'000}; //! Timeout for parallel async download of torrent files in msec static const std::chrono::milliseconds kParallelTorrentDownloadTimeout{120'000}; //! Custom HTTP header fields to include in any request to web servers hosted by Cloudflare static const std::map kCloudflareHeaders{ {"lsjdjwcush6jbnjj3jnjscoscisoc5s", "I%OSJDNFKE783DDHHJD873EFSIVNI7384R78SSJBJBCCJBC32JABBJCBJK45"}, }; WebSeedClient::WebSeedClient( std::vector url_seeds, Whitelist whitelist) : WebSeedClient{ std::make_unique(), std::move(url_seeds), std::move(whitelist), } {} WebSeedClient::WebSeedClient( std::unique_ptr web_session, std::vector url_seeds, Whitelist whitelist) : url_seeds_{std::move(url_seeds)}, whitelist_{std::move(whitelist)}, web_session_{std::move(web_session)} {} Task WebSeedClient::discover_torrents(bool fail_fast) { torrents_by_provider_.clear(); co_await build_list_of_torrents(fail_fast); co_return co_await download_and_filter_all_torrents(); } Task WebSeedClient::build_list_of_torrents(bool fail_fast) { using namespace concurrency::awaitable_wait_for_one; // NOLINTNEXTLINE(cppcoreguidelines-avoid-capturing-lambda-coroutines) auto build_list_of_torrents_factory = [this, fail_fast](size_t index) -> Task { const auto& provider_url = url_seeds_[index]; try { co_await build_list_of_torrents(provider_url); } catch (const std::exception& e) { if (fail_fast) throw; SILK_WARN << "Cannot retrieve the torrent list from: " << provider_url << " what: " << e.what(); } }; // Parallelize async build of the list of torrent files for each provider auto group_task = concurrency::generate_parallel_group_task(url_seeds_.size(), build_list_of_torrents_factory); co_await (std::move(group_task) || concurrency::timeout(kParallelManifestDownloadTimeout)); } Task WebSeedClient::build_list_of_torrents(std::string_view provider_url) { const auto web_url_result = urls::parse_uri(provider_url); if (!web_url_result) { throw system::system_error{web_url_result.error(), "invalid provider URL"}; } const auto response = co_await web_session_->https_get(*web_url_result, kManifestTarget, kCloudflareHeaders); SILK_TRACE << "Web seed manifest downloaded from: " << provider_url; // Parse HTTP response body content as snapshot Manifest containing list of snapshot files TorrentFileList torrent_files; const auto manifest_file_lines = absl::StrSplit(response.body(), '\n'); for (const auto manifest_line : manifest_file_lines) { const auto snapshot_file_name = absl::StripAsciiWhitespace(manifest_line); SILK_TRACE << "WebSeedClient::build_list_of_torrents snapshot_file_name: " << snapshot_file_name; if (snapshot_file_name.empty() || !absl::EndsWith(snapshot_file_name, ".torrent")) { continue; } torrent_files.emplace_back(snapshot_file_name); } torrents_by_provider_.emplace(*web_url_result, std::move(torrent_files)); } Task WebSeedClient::download_and_filter_all_torrents() { TorrentInfoPtrList torrent_infos; for (const auto& [provider_url, torrent_files] : torrents_by_provider_) { SILK_TRACE << "WebSeedClient::download_and_filter_all_torrents from provider_url: " << provider_url; co_await download_from_provider(provider_url, torrent_files, torrent_infos); } co_return torrent_infos; } Task WebSeedClient::download_from_provider(const urls::url& provider_url, const auto& torrent_files, TorrentInfoPtrList& torrent_infos) { using namespace concurrency::awaitable_wait_for_one; // NOLINTNEXTLINE(cppcoreguidelines-avoid-capturing-lambda-coroutines) auto download_and_validate_factory = [this, provider_url, &torrent_files, &torrent_infos](size_t index) -> Task { const auto& torrent_file = torrent_files[index]; urls::url torrent_url{provider_url}; const auto torrent_file_path = torrent_url.set_path(torrent_file).path(); const auto response = co_await web_session_->https_get(provider_url, torrent_file_path, kCloudflareHeaders); SILK_TRACE << "WebSeedClient::download_from_provider received torrent: " << torrent_file; TorrentInfoPtr torrent_info = validate_torrent_file(provider_url, torrent_file, response.body()); SILK_TRACE << "WebSeedClient::download_from_provider validated torrent: " << torrent_file; if (torrent_info) { torrent_infos.emplace(std::move(torrent_info)); } }; // Parallelize async download and validate of torrent files for each provider auto group_task = concurrency::generate_parallel_group_task(torrent_files.size(), download_and_validate_factory); co_await (std::move(group_task) || concurrency::timeout(kParallelTorrentDownloadTimeout)); } TorrentInfoPtr WebSeedClient::validate_torrent_file(const urls::url& provider_url, std::string_view torrent_file_name, std::string_view torrent_content) { lt::error_code ec; auto info{std::make_shared(torrent_content.data(), static_cast(torrent_content.size()), ec)}; if (ec) { throw system::system_error{ec}; } info->add_url_seed(provider_url.c_str()); const lt::sha1_hash torrent_hash{info->info_hashes().get_best()}; std::string_view file_name{torrent_file_name}; file_name.remove_suffix(kTorrentExtension.size()); if (!is_whitelisted(file_name, lt::aux::to_hex(torrent_hash))) { SILK_WARN << "WebSeedClient::validate_torrent_file torrent NOT whitelisted: " << file_name; if (throw_not_whitelisted_) { throw std::runtime_error{".torrent file " + std::string{file_name} + " is not whitelisted"}; } return {}; } return info; } bool WebSeedClient::is_whitelisted(std::string_view file_name, std::string_view torrent_hash) { return std::ranges::any_of(whitelist_, [&](const std::pair& entry) { return (entry.first == file_name) && (entry.second == torrent_hash); }); } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/web_seed_client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include // Disable warnings raised during compilation of libtorrent #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-compat" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include "web_session.hpp" namespace silkworm::snapshots::bittorrent { using TorrentFileList = std::vector; using TorrentsByProvider = std::map; using TorrentInfo = lt::torrent_info; using TorrentInfoPtr = std::shared_ptr; inline auto torrent_info_compare = [](const TorrentInfoPtr& lhs, const TorrentInfoPtr& rhs) { return lhs->name() < rhs->name(); }; using TorrentInfoPtrList = std::set; using Whitelist = std::vector>; class WebSeedClient { public: WebSeedClient( std::vector url_seeds, Whitelist whitelist); WebSeedClient( std::unique_ptr web_session, std::vector url_seeds, Whitelist whitelist); Task discover_torrents(bool fail_fast = false); protected: WebSession& web_session() { return *web_session_; } Task build_list_of_torrents(bool fail_fast); Task build_list_of_torrents(std::string_view provider_url); Task download_and_filter_all_torrents(); Task download_from_provider(const boost::urls::url& provider_url, const auto& torrent_files, TorrentInfoPtrList& torrent_infos); TorrentInfoPtr validate_torrent_file(const boost::urls::url& provider_url, std::string_view torrent_file_name, std::string_view torrent_content); bool is_whitelisted(std::string_view file_name, std::string_view torrent_hash); std::vector url_seeds_; Whitelist whitelist_; std::unique_ptr web_session_; TorrentsByProvider torrents_by_provider_; bool throw_not_whitelisted_{false}; }; } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/web_seed_client_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "web_seed_client.hpp" #include #include #include #include #include #include #include #include namespace silkworm::snapshots::bittorrent { namespace urls = boost::urls; using testing::_; using testing::InvokeWithoutArgs; //! WebSeedClient with protected methods exposed for test class WebSeedClientForTest : public WebSeedClient { public: using WebSeedClient::build_list_of_torrents; using WebSeedClient::download_and_filter_all_torrents; using WebSeedClient::download_from_provider; using WebSeedClient::is_whitelisted; using WebSeedClient::validate_torrent_file; using WebSeedClient::web_session; using WebSeedClient::WebSeedClient; // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved) }; //! Content for manifest file containing one torrent file static constexpr std::string_view kValidManifestContent{ "v1-010000-010500-bodies.seg.torrent\n"}; //! Hexadecimal content for torrent file 'v1-010000-010500-bodies.seg' static constexpr std::string_view kValidTorrentContent{ "6431333a616e6e6f756e63652d6c6973746c6c34323a7564703a2f2f74726163" "6b65722e6f70656e747261636b722e6f72673a313333372f616e6e6f756e6365" "34363a7564703a2f2f747261636b65722e6f70656e626974746f7272656e742e" "636f6d3a363936392f616e6e6f756e636534313a7564703a2f2f6f70656e7472" "61636b65722e6932702e726f636b733a363936392f616e6e6f756e636534313a" "7564703a2f2f747261636b65722e746f7272656e742e65752e6f72673a343531" "2f616e6e6f756e636533333a7564703a2f2f6f70656e2e737465616c74682e73" "693a38302f616e6e6f756e6365656531303a63726561746564206279363a6572" "69676f6e31333a6372656174696f6e2064617465693137313337373930393565" "343a696e666f64363a6c656e67746869323030383332393765343a6e616d6532" "373a76312d3031303030302d3031303530302d626f646965732e73656731323a" "7069656365206c656e677468693230393731353265363a706965636573323030" "3ab9c7251af452c58fa73cc3fff451fc1cf0a1ff426629d3ef68cdc7dd52556b" "7be3f1192b06cad8fab33f829fea37455bfa00938c85bd03066f2b46d912daf0" "3a7b221c47b119f8e64ba40e574e8e0642e5ef9b5e878d60f7ed7737dca3aace" "4fd98b8b83d1f5cced97afeb955f4be33aadab9ea8297899a6e81eaf0613d91a" "85f5e6028eb05726651320c3e2b8070b98aa6052610de5bcc1cacd6b818b02ed" "5f22b6e32a4d3e97d7889eeee487689e4a0116651aecba0609813b273ee92392" "7a9c3103df62ab058f6565"}; static const std::string kValidTorrentContentAscii{test_util::ascii_from_hex(kValidTorrentContent)}; struct WebSessionMock : public WebSession { MOCK_METHOD((Task), https_get, (const urls::url&, std::string_view, const WebSession::HeaderFields&), (const, override)); }; static constexpr std::string_view kErigon2Snapshots{"https://erigon2-v1-snapshots-mainnet.erigon.network"}; static boost::urls::url make_e2_snapshots_provider_url() { return boost::urls::url{kErigon2Snapshots}; } TEST_CASE("WebSeedClient::WebSeedClient", "[db][snapshot][bittorrent]") { WebSeedClientForTest client{{}, {}}; } TEST_CASE("WebSeedClient::discover_torrents", "[db][snapshot][bittorrent]") { test_util::TaskRunner task_runner; static const Whitelist kWhitelist = {{"v1-010000-010500-bodies.seg", "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b"}}; WebSeedClientForTest ws_client{std::make_unique(), {std::string{kErigon2Snapshots}}, kWhitelist}; auto& session = dynamic_cast(ws_client.web_session()); SECTION("empty") { EXPECT_CALL(session, https_get(make_e2_snapshots_provider_url(), _, _)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return WebSession::StringResponse{}; })); TorrentInfoPtrList torrent_info_set = task_runner.run(ws_client.discover_torrents()); CHECK(torrent_info_set.empty()); } SECTION("invalid manifest") { EXPECT_CALL(session, https_get(make_e2_snapshots_provider_url(), _, _)) .WillOnce(InvokeWithoutArgs([]() -> Task { WebSession::StringResponse rsp; rsp.body().assign("\000\001"); co_return rsp; })); TorrentInfoPtrList torrent_info_set = task_runner.run(ws_client.discover_torrents()); CHECK(torrent_info_set.empty()); } SECTION("valid manifest") { EXPECT_CALL(session, https_get(make_e2_snapshots_provider_url(), _, _)) .WillOnce(InvokeWithoutArgs([]() -> Task { WebSession::StringResponse rsp; rsp.body().assign(kValidManifestContent); co_return rsp; })) .WillOnce(InvokeWithoutArgs([]() -> Task { WebSession::StringResponse rsp; rsp.body().assign(kValidTorrentContentAscii); co_return rsp; })); TorrentInfoPtrList torrent_info_set = task_runner.run(ws_client.discover_torrents()); REQUIRE_FALSE(torrent_info_set.empty()); const TorrentInfoPtr torrent_info = *torrent_info_set.begin(); CHECK(torrent_info->name() == "v1-010000-010500-bodies.seg"); CHECK(lt::aux::to_hex(torrent_info->info_hashes().get_best()) == "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b"); } } TEST_CASE("WebSeedClient::validate_torrent_file", "[db][snapshot][bittorrent]") { WebSeedClientForTest client{{std::string{kErigon2Snapshots}}, {{"v1-010000-010500-bodies.seg", "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b"}}}; CHECK(client.validate_torrent_file(make_e2_snapshots_provider_url(), "v1-010000-010500-bodies.seg.torrent", kValidTorrentContentAscii)); CHECK_THROWS_AS(client.validate_torrent_file(make_e2_snapshots_provider_url(), "v1-010000-010500-bodies.seg.torrent", ""), boost::system::system_error); CHECK_THROWS_AS(client.validate_torrent_file(make_e2_snapshots_provider_url(), "v1-010000-010500-bodies.seg.torrent", "AA"), boost::system::system_error); } TEST_CASE("WebSeedClient::is_whitelisted", "[db][snapshot][bittorrent]") { static const Whitelist kWhitelist = { {"v1-010000-010500-bodies.seg", "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b"}, {"v1-010000-010500-headers.seg", "080d0cd1613831820c8f5e48715d68643f48054a"}, {"v1-010000-010500-transactions.seg", "8151bbc8b6635465760af6ebcfd630c9679b31a5"}, }; WebSeedClientForTest client{{std::string{kErigon2Snapshots}}, kWhitelist}; CHECK(client.is_whitelisted("v1-010000-010500-bodies.seg", "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b")); CHECK(client.is_whitelisted("v1-010000-010500-headers.seg", "080d0cd1613831820c8f5e48715d68643f48054a")); CHECK(client.is_whitelisted("v1-010000-010500-transactions.seg", "8151bbc8b6635465760af6ebcfd630c9679b31a5")); CHECK_FALSE(client.is_whitelisted("", "")); CHECK_FALSE(client.is_whitelisted("v1-010000-010500-bodies2.seg", "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b")); // name CHECK_FALSE(client.is_whitelisted("v1-010000-010500-bodies.segment", "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b")); // suffix CHECK_FALSE(client.is_whitelisted("v1-010000-010500-bodies.seg", "442b3f77a2f3c4b9d8a4085d838bdd1b14043f3b")); // hash } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/web_session.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "web_session.hpp" #include #include #include #include #include #include #include #include #include #include #include "root_certificates.hpp" namespace silkworm::snapshots::bittorrent { namespace beast = boost::beast; namespace http = beast::http; namespace net = boost::asio; namespace ssl = net::ssl; namespace urls = boost::urls; //! The timeout for HTTP asynchronous operations static constexpr std::chrono::seconds kHttpTimeoutSecs{30}; WebSession::WebSession(std::optional server_certificate) : server_certificate_(std::move(server_certificate)) {} Task WebSession::https_get(const urls::url& web_url, std::string_view target_file, const HeaderFields& custom_fields) const { // The SSL context which holds root certificate used for verification () ssl::context ssl_ctx{ssl::context::tlsv13_client}; load_root_certificates(ssl_ctx, server_certificate_); ssl_ctx.set_verify_mode(ssl::verify_peer); // Ask to verify the remote server certificate // These objects perform our I/O net::ip::tcp::resolver resolver{co_await net::this_coro::executor}; beast::ssl_stream ssl_stream{co_await net::this_coro::executor, ssl_ctx}; beast::tcp_stream& tcp_stream = beast::get_lowest_layer(ssl_stream); // Set SNI Hostname (many hosts need this to handshake successfully) const std::string host{web_url.host()}; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wold-style-cast" // SSL_set_tlsext_host_name casts to (void*) if (!SSL_set_tlsext_host_name(ssl_stream.native_handle(), host.c_str())) { beast::error_code ec{static_cast(::ERR_get_error()), net::error::get_ssl_category()}; throw beast::system_error{ec, "error setting SNI hostname"}; } #pragma GCC diagnostic pop const std::string port{web_url.has_port() ? web_url.port() : "443"}; // Look up the domain name const auto resolve_results = co_await resolver.async_resolve(host, port, net::use_awaitable); // Make the connection on the IP address we get from a lookup tcp_stream.expires_after(kHttpTimeoutSecs); co_await tcp_stream.async_connect(resolve_results, net::use_awaitable); // Perform the SSL handshake tcp_stream.expires_after(kHttpTimeoutSecs); co_await ssl_stream.async_handshake(ssl::stream_base::client, net::use_awaitable); // Setup the HTTP GET request message http::request req{http::verb::get, target_file, kHttpVersion}; req.set(http::field::host, host); req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING); include_custom_headers(req, custom_fields); SILK_TRACE << "WebSeedClient::http_session HTTP request: " << req; // Send the HTTP request to the remote host tcp_stream.expires_after(kHttpTimeoutSecs); const auto written_bytes = co_await http::async_write(ssl_stream, req, net::use_awaitable); SILK_TRACE << "WebSeedClient::http_session HTTP request written_bytes: " << written_bytes; // This buffer is used for reading beast::flat_buffer data; // Declare a container to hold the response http::response response; // Receive the HTTP response tcp_stream.expires_after(kHttpTimeoutSecs); const auto read_bytes = co_await http::async_read(ssl_stream, data, response, net::use_awaitable); SILK_TRACE << "WebSeedClient::http_session HTTP read_bytes: " << read_bytes << " response: " << response; // Gracefully close the stream try { tcp_stream.expires_after(kHttpTimeoutSecs); co_await ssl_stream.async_shutdown(net::use_awaitable); } catch (const beast::system_error& se) { // Swallow shutdown errors due to misbehaviour of some web servers: // https://github.com/boostorg/beast/issues/38, https://github.com/boostorg/beast/issues/824 if (se.code() != net::error::eof && se.code() != net::ssl::error::stream_truncated) { throw; } } co_return response; } void WebSession::include_custom_headers(EmptyRequest& request, const HeaderFields& custom_fields) { for (const auto [field_name, field_value] : custom_fields) { request.set(field_name, field_value); } } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/web_session.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::snapshots::bittorrent { class WebSession { public: //! \brief Constructor optionally accepting a server certificate to append to root certificates //! \remarks the custom server certificate is used only in tests explicit WebSession(std::optional server_certificate = {}); virtual ~WebSession() = default; using HeaderFields = std::map; using StringResponse = boost::beast::http::response; //! \brief Asynch send a HTTPS GET request for \p target file to \p web_url and receive the response //! \param web_url the URL address of the web server //! \param target_file the relative path of the requested file //! \param custom_fields the custom fields to add to the header of HTTPS requests, if any virtual Task https_get( const boost::urls::url& web_url, std::string_view target_file, const HeaderFields& custom_fields) const; protected: using EmptyRequest = boost::beast::http::request; static void include_custom_headers(EmptyRequest& request, const HeaderFields& custom_fields); //! The HTTP protocol version to use static constexpr int kHttpVersion{11}; std::optional server_certificate_; }; } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bittorrent/web_session_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "web_session.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots::bittorrent { namespace beast = boost::beast; namespace http = beast::http; namespace asio = boost::asio; namespace ssl = boost::asio::ssl; namespace urls = boost::urls; using tcp = boost::asio::ip::tcp; // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // See also: https://github.com/boostorg/beast/blob/develop/example/common/server_certificate.hpp static constexpr std::string_view kServerCert = "-----BEGIN CERTIFICATE-----\n" "MIIDlTCCAn2gAwIBAgIUOLxr3q7Wd/pto1+2MsW4fdRheCIwDQYJKoZIhvcNAQEL\n" "BQAwWjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRQwEgYDVQQHDAtMb3MgQW5n\n" "ZWxlczEOMAwGA1UECgwFQmVhc3QxGDAWBgNVBAMMD3d3dy5leGFtcGxlLmNvbTAe\n" "Fw0yMTA3MDYwMTQ5MjVaFw00ODExMjEwMTQ5MjVaMFoxCzAJBgNVBAYTAlVTMQsw\n" "CQYDVQQIDAJDQTEUMBIGA1UEBwwLTG9zIEFuZ2VsZXMxDjAMBgNVBAoMBUJlYXN0\n" "MRgwFgYDVQQDDA93d3cuZXhhbXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IB\n" "DwAwggEKAoIBAQCz0GwgnxSBhygxBdhTHGx5LDLIJSuIDJ6nMwZFvAjdhLnB/vOT\n" "Lppr5MKxqQHEpYdyDYGD1noBoz4TiIRj5JapChMgx58NLq5QyXkHV/ONT7yi8x05\n" "P41c2F9pBEnUwUxIUG1Cb6AN0cZWF/wSMOZ0w3DoBhnl1sdQfQiS25MTK6x4tATm\n" "Wm9SJc2lsjWptbyIN6hFXLYPXTwnYzCLvv1EK6Ft7tMPc/FcJpd/wYHgl8shDmY7\n" "rV+AiGTxUU35V0AzpJlmvct5aJV/5vSRRLwT9qLZSddE9zy/0rovC5GML6S7BUC4\n" "lIzJ8yxzOzSStBPxvdrOobSSNlRZIlE7gnyNAgMBAAGjUzBRMB0GA1UdDgQWBBR+\n" "dYtY9zmFSw9GYpEXC1iJKHC0/jAfBgNVHSMEGDAWgBR+dYtY9zmFSw9GYpEXC1iJ\n" "KHC0/jAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBzKrsiYywl\n" "RKeB2LbddgSf7ahiQMXCZpAjZeJikIoEmx+AmjQk1bam+M7WfpRAMnCKooU+Utp5\n" "TwtijjnJydkZHFR6UH6oCWm8RsUVxruao/B0UFRlD8q+ZxGd4fGTdLg/ztmA+9oC\n" "EmrcQNdz/KIxJj/fRB3j9GM4lkdaIju47V998Z619E/6pt7GWcAySm1faPB0X4fL\n" "FJ6iYR2r/kJLoppPqL0EE49uwyYQ1dKhXS2hk+IIfA9mBn8eAFb/0435A2fXutds\n" "qhvwIOmAObCzcoKkz3sChbk4ToUTqbC0TmFAXI5Upz1wnADzjpbJrpegCA3pmvhT\n" "7356drqnCGY9\n" "-----END CERTIFICATE-----\n"; //! Load a signed certificate into the ssl context and configure it for use with a server. inline void load_server_certificate(boost::asio::ssl::context& ctx) { static constexpr std::string_view kServerKey = "-----BEGIN PRIVATE KEY-----\n" "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCz0GwgnxSBhygx\n" "BdhTHGx5LDLIJSuIDJ6nMwZFvAjdhLnB/vOTLppr5MKxqQHEpYdyDYGD1noBoz4T\n" "iIRj5JapChMgx58NLq5QyXkHV/ONT7yi8x05P41c2F9pBEnUwUxIUG1Cb6AN0cZW\n" "F/wSMOZ0w3DoBhnl1sdQfQiS25MTK6x4tATmWm9SJc2lsjWptbyIN6hFXLYPXTwn\n" "YzCLvv1EK6Ft7tMPc/FcJpd/wYHgl8shDmY7rV+AiGTxUU35V0AzpJlmvct5aJV/\n" "5vSRRLwT9qLZSddE9zy/0rovC5GML6S7BUC4lIzJ8yxzOzSStBPxvdrOobSSNlRZ\n" "IlE7gnyNAgMBAAECggEAY0RorQmldGx9D7M+XYOPjsWLs1px0cXFwGA20kCgVEp1\n" "kleBeHt93JqJsTKwOzN2tswl9/ZrnIPWPUpcbBlB40ggjzQk5k4jBY50Nk2jsxuV\n" "9A9qzrP7AoqhAYTQjZe42SMtbkPZhEeOyvCqxBAi6csLhcv4eB4+In0kQo7dfvLs\n" "Xu/3WhSsuAWqdD9EGnhD3n+hVTtgiasRe9318/3R9DzP+IokoQGOtXm+1dsfP0mV\n" "8XGzQHBpUtJNn0yi6SC4kGEQuKkX33zORlSnZgT5VBLofNgra0THd7x3atOx1lbr\n" "V0QizvCdBa6j6FwhOQwW8UwgOCnUbWXl/Xn4OaofMQKBgQDdRXSMyys7qUMe4SYM\n" "Mdawj+rjv0Hg98/xORuXKEISh2snJGKEwV7L0vCn468n+sM19z62Axz+lvOUH8Qr\n" "hLkBNqJvtIP+b0ljRjem78K4a4qIqUlpejpRLw6a/+44L76pMJXrYg3zdBfwzfwu\n" "b9NXdwHzWoNuj4v36teGP6xOUwKBgQDQCT52XX96NseNC6HeK5BgWYYjjxmhksHi\n" "stjzPJKySWXZqJpHfXI8qpOd0Sd1FHB+q1s3hand9c+Rxs762OXlqA9Q4i+4qEYZ\n" "qhyRkTsl+2BhgzxmoqGd5gsVT7KV8XqtuHWLmetNEi+7+mGSFf2iNFnonKlvT1JX\n" "4OQZC7ntnwKBgH/ORFmmaFxXkfteFLnqd5UYK5ZMvGKTALrWP4d5q2BEc7HyJC2F\n" "+5lDR9nRezRedS7QlppPBgpPanXeO1LfoHSA+CYJYEwwP3Vl83Mq/Y/EHgp9rXeN\n" "L+4AfjEtLo2pljjnZVDGHETIg6OFdunjkXDtvmSvnUbZBwG11bMnSAEdAoGBAKFw\n" "qwJb6FNFM3JnNoQctnuuvYPWxwM1yjRMqkOIHCczAlD4oFEeLoqZrNhpuP8Ij4wd\n" "GjpqBbpzyVLNP043B6FC3C/edz4Lh+resjDczVPaUZ8aosLbLiREoxE0udfWf2dU\n" "oBNnrMwwcs6jrRga7Kr1iVgUSwBQRAxiP2CYUv7tAoGBAKdPdekPNP/rCnHkKIkj\n" "o13pr+LJ8t+15vVzZNHwPHUWiYXFhG8Ivx7rqLQSPGcuPhNss3bg1RJiZAUvF6fd\n" "e6QS4EZM9dhhlO2FmPQCJMrRVDXaV+9TcJZXCbclQnzzBus9pwZZyw4Anxo0vmir\n" "nOMOU6XI4lO9Xge/QDEN4Y2R\n" "-----END PRIVATE KEY-----\n"; static constexpr std::string_view kDhParameters = "-----BEGIN DH PARAMETERS-----\n" "MIIBCAKCAQEArzQc5mpm0Fs8yahDeySj31JZlwEphUdZ9StM2D8+Fo7TMduGtSi+\n" "/HRWVwHcTFAgrxVdm+dl474mOUqqaz4MpzIb6+6OVfWHbQJmXPepZKyu4LgUPvY/\n" "4q3/iDMjIS0fLOu/bLuObwU5ccZmDgfhmz1GanRlTQOiYRty3FiOATWZBRh6uv4u\n" "tff4A9Bm3V9tLx9S6djq31w31Gl7OQhryodW28kc16t9TvO1BzcV3HjRPwpe701X\n" "oEEZdnZWANkkpR/m/pfgdmGPU66S2sXMHgsliViQWpDCYeehrvFRHEdR9NV+XJfC\n" "QMUk26jPTIVTLfXmmwU0u8vUkpR7LQKkwwIBAg==\n" "-----END DH PARAMETERS-----\n"; ctx.set_password_callback( [](size_t, boost::asio::ssl::context_base::password_purpose) { return "test"; }); ctx.set_options( boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use); ctx.use_certificate_chain( boost::asio::buffer(kServerCert.data(), kServerCert.size())); ctx.use_private_key( boost::asio::buffer(kServerKey.data(), kServerKey.size()), boost::asio::ssl::context::file_format::pem); ctx.use_tmp_dh( boost::asio::buffer(kDhParameters.data(), kDhParameters.size())); } //! \brief Return a reasonable mime type based on the extension of a file. beast::string_view mime_type(beast::string_view path) { using beast::iequals; const auto ext = [&path] { const auto pos = path.rfind("."); if (pos == beast::string_view::npos) { return beast::string_view{}; } return path.substr(pos); }(); if (iequals(ext, ".htm")) return "text/html"; if (iequals(ext, ".html")) return "text/html"; if (iequals(ext, ".php")) return "text/html"; if (iequals(ext, ".css")) return "text/css"; if (iequals(ext, ".txt")) return "text/plain"; if (iequals(ext, ".js")) return "application/javascript"; if (iequals(ext, ".json")) return "application/json"; if (iequals(ext, ".xml")) return "application/xml"; if (iequals(ext, ".swf")) return "application/x-shockwave-flash"; if (iequals(ext, ".flv")) return "video/x-flv"; if (iequals(ext, ".png")) return "image/png"; if (iequals(ext, ".jpe")) return "image/jpeg"; if (iequals(ext, ".jpeg")) return "image/jpeg"; if (iequals(ext, ".jpg")) return "image/jpeg"; if (iequals(ext, ".gif")) return "image/gif"; if (iequals(ext, ".bmp")) return "image/bmp"; if (iequals(ext, ".ico")) return "image/vnd.microsoft.icon"; if (iequals(ext, ".tiff")) return "image/tiff"; if (iequals(ext, ".tif")) return "image/tiff"; if (iequals(ext, ".svg")) return "image/svg+xml"; if (iequals(ext, ".svgz")) return "image/svg+xml"; return "application/text"; } //! \brief Append an HTTP rel-path to a local filesystem path. //! \return The returned path is normalized for the platform. std::string path_cat(beast::string_view base, beast::string_view path) { if (base.empty()) { return std::string(path); } std::string result(base); #ifdef BOOST_MSVC char constexpr kPathSeparator = '\\'; if (result.back() == kPathSeparator) { result.resize(result.size() - 1); } result.append(path.data(), path.size()); for (auto& c : result) { if (c == '/') { c = kPathSeparator; } } #else char constexpr kPathSeparator = '/'; if (result.back() == kPathSeparator) { result.resize(result.size() - 1); } result.append(path.data(), path.size()); #endif return result; } //! \brief Handle a response for the given request. //! \details The concrete type of the response message (which depends on the request) is type-erased in message_generator template http::message_generator handle_request(beast::string_view doc_root, http::request> req) { // Return a bad request response const auto bad_request = [&req](beast::string_view why) { http::response res{http::status::bad_request, req.version()}; res.set(http::field::server, BOOST_BEAST_VERSION_STRING); res.set(http::field::content_type, "text/html"); res.keep_alive(req.keep_alive()); res.body() = std::string(why); res.prepare_payload(); return res; }; // Return a not found response const auto not_found = [&req](beast::string_view target) { http::response res{http::status::not_found, req.version()}; res.set(http::field::server, BOOST_BEAST_VERSION_STRING); res.set(http::field::content_type, "text/html"); res.keep_alive(req.keep_alive()); res.body() = "The resource '" + std::string(target) + "' was not found."; res.prepare_payload(); return res; }; // Return a server error response const auto server_error = [&req](beast::string_view what) { http::response res{http::status::internal_server_error, req.version()}; res.set(http::field::server, BOOST_BEAST_VERSION_STRING); res.set(http::field::content_type, "text/html"); res.keep_alive(req.keep_alive()); res.body() = "An error occurred: '" + std::string(what) + "'"; res.prepare_payload(); return res; }; // Make sure we can handle the method if (req.method() != http::verb::get && req.method() != http::verb::head) { return bad_request("Unknown HTTP-method"); } // Request path must be absolute and not contain ".." if (req.target().empty() || req.target()[0] != '/' || req.target().find("..") != beast::string_view::npos) { return bad_request("Illegal request-target"); } // Build the path to the requested file std::string path = path_cat(doc_root, req.target()); if (req.target().back() == '/') { path.append("index.html"); } // Attempt to open the file beast::error_code ec; http::file_body::value_type body; body.open(path.c_str(), beast::file_mode::scan, ec); // Handle the case where the file doesn't exist if (ec == beast::errc::no_such_file_or_directory) { return not_found(req.target()); } // Handle any unknown error if (ec) { return server_error(ec.message()); } // Cache the size since we need it after the move const auto size = body.size(); // Respond to HEAD request if (req.method() == http::verb::head) { http::response res{http::status::ok, req.version()}; res.set(http::field::server, BOOST_BEAST_VERSION_STRING); res.set(http::field::content_type, mime_type(path)); res.content_length(size); res.keep_alive(req.keep_alive()); return res; } // Respond to GET request http::response res{ std::piecewise_construct, std::make_tuple(std::move(body)), std::make_tuple(http::status::ok, req.version())}; res.set(http::field::server, BOOST_BEAST_VERSION_STRING); res.set(http::field::content_type, mime_type(path)); res.content_length(size); res.keep_alive(req.keep_alive()); return res; } //! \brief Report a failure void fail(beast::error_code ec, char const* what) { // ssl::error::stream_truncated, also known as an SSL "short read", // indicates the peer closed the connection without performing the // required closing handshake (for example, Google does this to // improve performance). Generally this can be a security issue, // but if your communication protocol is self-terminated (as // it is with both HTTP and WebSocket) then you may simply // ignore the lack of close_notify. // // https://github.com/boostorg/beast/issues/38 // // https://security.stackexchange.com/questions/91435/how-to-handle-a-malicious-ssl-tls-shutdown // // When a short read would cut off the end of an HTTP message, // Beast returns the error beast::http::error::partial_message. // Therefore, if we see a short read here, it has occurred // after the message has been completed, so it is safe to ignore it. if (ec == asio::ssl::error::stream_truncated) return; std::cerr << what << ": " << ec.message() << "\n"; } //! \brief Handles an HTTP server connection class Session : public std::enable_shared_from_this { ssl::stream stream_; beast::flat_buffer buffer_; std::shared_ptr doc_root_; http::request req_; public: // Take ownership of the socket explicit Session(tcp::socket&& socket, ssl::context& ctx, std::shared_ptr const& doc_root) : stream_(std::move(socket), ctx), doc_root_(doc_root) {} //! \brief Start the asynchronous operation void run() { // We need to be executing within a strand to perform async operations // on the I/O objects in this session. Although not strictly necessary // for single-threaded contexts, this example code is written to be // thread-safe by default. asio::dispatch(stream_.get_executor(), beast::bind_front_handler(&Session::on_run, shared_from_this())); } void on_run() { // Set the timeout beast::get_lowest_layer(stream_).expires_after(std::chrono::seconds(30)); // Perform the SSL handshake stream_.async_handshake(ssl::stream_base::server, beast::bind_front_handler(&Session::on_handshake, shared_from_this())); } void on_handshake(beast::error_code ec) { if (ec) { fail(ec, "handshake"); return; } do_read(); } void do_read() { // Make the request empty before reading, otherwise the operation behavior is undefined. req_ = {}; // Set the timeout beast::get_lowest_layer(stream_).expires_after(std::chrono::seconds(30)); // Read a request http::async_read(stream_, buffer_, req_, beast::bind_front_handler(&Session::on_read, shared_from_this())); } void on_read(beast::error_code ec, size_t bytes_transferred) { boost::ignore_unused(bytes_transferred); // This means they closed the connection if (ec == http::error::end_of_stream) { do_close(); return; } if (ec) { fail(ec, "read"); return; } // Send the response send_response(handle_request(*doc_root_, std::move(req_))); } void send_response(http::message_generator&& msg) { const bool keep_alive = msg.keep_alive(); // Write the response beast::async_write(stream_, std::move(msg), beast::bind_front_handler(&Session::on_write, this->shared_from_this(), keep_alive)); } void on_write(bool keep_alive, beast::error_code ec, size_t bytes_transferred) { boost::ignore_unused(bytes_transferred); if (ec) { fail(ec, "write"); return; } if (!keep_alive) { // This means we should close the connection, usually because the response indicated the "Connection: close" semantic do_close(); return; } // Read another request do_read(); } void do_close() { // Set the timeout beast::get_lowest_layer(stream_).expires_after(std::chrono::seconds(30)); // Perform the SSL shutdown stream_.async_shutdown(beast::bind_front_handler(&Session::on_shutdown, shared_from_this())); } void on_shutdown(beast::error_code ec) { if (ec) { fail(ec, "shutdown"); return; } // At this point the connection is closed gracefully } }; //! \brief Accepts incoming HTTP connections and launches the sessions class Server : public std::enable_shared_from_this { asio::io_context& ioc_; ssl::context& ssl_ctx_; tcp::acceptor acceptor_; std::shared_ptr doc_root_; public: Server(asio::io_context& ioc, ssl::context& ssl_ctx, const tcp::endpoint& endpoint, const std::shared_ptr& doc_root) : ioc_(ioc), ssl_ctx_(ssl_ctx), acceptor_(ioc), doc_root_(doc_root) { beast::error_code ec; // Open the acceptor acceptor_.open(endpoint.protocol(), ec); if (ec) { fail(ec, "open"); return; } // Allow address reuse acceptor_.set_option(asio::socket_base::reuse_address(true), ec); if (ec) { fail(ec, "set_option"); return; } // Bind to the server address acceptor_.bind(endpoint, ec); if (ec) { fail(ec, "bind"); return; } // Start listening for connections acceptor_.listen(asio::socket_base::max_listen_connections, ec); if (ec) { fail(ec, "listen"); return; } } // Start accepting incoming connections void run() { do_accept(); } private: void do_accept() { // The new connection gets its own strand acceptor_.async_accept(asio::make_strand(ioc_), beast::bind_front_handler(&Server::on_accept, shared_from_this())); } void on_accept(beast::error_code ec, tcp::socket socket) { if (ec) { fail(ec, "accept"); return; // To avoid infinite loop } // Create the session and run it std::make_shared(std::move(socket), ssl_ctx_, doc_root_)->run(); // Accept another connection do_accept(); } }; struct WebSessionTest : public test_util::ContextTestBase { WebSession session{std::string{kServerCert}}; }; TEST_CASE_METHOD(WebSessionTest, "WebSession::https_get", "[db][snapshot][bittorrent]") { const test_util::TemporaryFile empty_manifest{"manifest.txt"}; const auto doc_root = std::make_shared(empty_manifest.path().parent_path().string()); // The SSL context is required and holds the self-signed certificate used by the server ssl::context ssl_ctx{ssl::context::tlsv13}; load_server_certificate(ssl_ctx); // Create and launch an HTTP server supporting SSL connections std::make_shared(ioc_, ssl_ctx, tcp::endpoint{asio::ip::make_address("127.0.0.1"), 12345}, doc_root) ->run(); CHECK(spawn_and_wait(session.https_get(urls::url{"https://127.0.0.1:12345"}, "/manifest.txt", {})).body().empty()); } } // namespace silkworm::snapshots::bittorrent ================================================ FILE: silkworm/db/datastore/snapshots/bloom_filter/bloom_filter.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bloom_filter.hpp" #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots::bloom_filter { using namespace std::numbers; //! The minimum Bloom filter bits count static constexpr size_t kMinimumBitsCount = 2; //! kRotation sets how much to rotate the hash on each filter iteration. //! This is somewhat randomly set to a prime on the lower segment of 64. static constexpr size_t kRotation = 17; static constexpr size_t kRotationOf64 = 64 - kRotation; //! The magic header used in serialization format for version v2 static constexpr std::string_view kMagicHeader{"\0\0\0\0\0\0\0\0v02\n"sv}; uint64_t BloomFilter::optimal_bits_count(uint64_t max_key_count, double p) { return static_cast(std::ceil(-static_cast(max_key_count) * std::log(p) / (ln2 * ln2))); } BloomFilter::BloomFilter( std::filesystem::path path, std::optional data_key_hasher) : BloomFilter{kMinimumBitsCount, new_random_keys()} { if (!std::filesystem::exists(path)) { throw std::runtime_error("index file " + path.filename().string() + " doesn't exist"); } if (std::filesystem::file_size(path) == 0) { throw std::runtime_error("index file " + path.filename().string() + " is empty"); } path_ = std::move(path); std::ifstream file_stream{path_, std::ios::in | std::ios::binary}; file_stream.exceptions(std::ios::failbit | std::ios::badbit); file_stream >> *this; data_key_hasher_ = std::move(data_key_hasher); } BloomFilter::BloomFilter() : BloomFilter{kMinimumBitsCount, new_random_keys()} {} BloomFilter::BloomFilter(uint64_t max_key_count, double p) : BloomFilter{optimal_bits_count(max_key_count, p), new_random_keys()} {} BloomFilter::BloomFilter(uint64_t bits_count, KeyArray keys) : bits_count_(bits_count), keys_(keys), bits_((bits_count + 63) / 64, 0) { ensure_min_bits_count(bits_count); } void BloomFilter::add_hash(uint64_t hash) { for (size_t n = 0; n < kHardCodedK; ++n) { hash = ((hash << kRotation) | (hash >> kRotationOf64)) ^ keys_[n]; const uint64_t i = hash % bits_count_; bits_[i >> 6] |= uint64_t{1} << (i & 0x3F); } ++inserted_count_; } bool BloomFilter::contains_hash(uint64_t hash) const { uint64_t r{1}; for (size_t n = 0; n < kHardCodedK; ++n) { hash = ((hash << kRotation) | (hash >> kRotationOf64)) ^ keys_[n]; const uint64_t i = hash % bits_count_; r &= (bits_[i >> 6] >> (i & 0x3F)) & uint64_t{1}; } return r != 0; } bool BloomFilter::contains(ByteView data_key) const { return contains_hash(data_key_hasher_->hash(data_key)); } void BloomFilter::ensure_min_bits_count(uint64_t bits_count) { if (bits_count < kMinimumBitsCount) { throw std::runtime_error{"number of bits must be >= " + std::to_string(kMinimumBitsCount) + " (was " + std::to_string(bits_count) + ")"}; } } BloomFilter::KeyArray BloomFilter::new_random_keys() { // Reference Go implementation uses a CS-PRNG here for robustness (thus relying on OS-provided sources of randomness) // TODO(canepat) std::random_device is not guaranteed to be a CS-PRNG static std::mt19937_64 generator{std::random_device{}()}; std::uniform_int_distribution distribution; return {distribution(generator), distribution(generator), distribution(generator)}; } //! SHA2-384 hash used for checksum struct SHA384Hash { std::array buffer; }; //! Decorator adding hashing support to the given input stream class HashingInputStream { public: explicit HashingInputStream(std::istream& input_stream) : input_stream_(input_stream), md_ctx_{EVP_MD_CTX_create()} { input_stream_.exceptions(std::ios::failbit | std::ios::badbit); // Set up the digest context to use SHA384 message digest type if (const auto ec = EVP_DigestInit(md_ctx_, EVP_sha384()); !ec) { throw std::runtime_error{"EVP_DigestInit failed with code: " + std::to_string(ec)}; } } ~HashingInputStream() { EVP_MD_CTX_destroy(md_ctx_); } SHA384Hash hash() { SHA384Hash sha384_md{}; // Retrieve the computed digest value and its length from digest context unsigned int md_length = 0; if (const auto ec = EVP_DigestFinal(md_ctx_, sha384_md.buffer.data(), &md_length); !ec) { throw std::runtime_error{"EVP_DigestFinal failed with code: " + std::to_string(ec)}; } if (md_length != sizeof(SHA384Hash)) { throw std::runtime_error{"EVP_DigestFinal unexpected MD length: " + std::to_string(md_length)}; } return sha384_md; } void read(std::span byte_span) { input_stream_.read(reinterpret_cast(byte_span.data()), static_cast(byte_span.size())); // Hash the read byte sequence into the digest context if (const auto ec = EVP_DigestUpdate(md_ctx_, byte_span.data(), byte_span.size()); !ec) { throw std::runtime_error{"EVP_DigestUpdate failed with code: " + std::to_string(ec)}; } } private: //! The input stream to decorate std::istream& input_stream_; //! OpenSSL EnVeloPe Message Digest context EVP_MD_CTX* md_ctx_{nullptr}; }; std::istream& operator>>(std::istream& is, BloomFilter& filter) { HashingInputStream hashing_istream{is}; // Read Magic Header byte sequence Bytes magic_buffer(kMagicHeader.size(), '\0'); hashing_istream.read(magic_buffer); if (magic_buffer != string_view_to_byte_view(kMagicHeader)) { throw std::runtime_error{"incompatible version, wrong magic: " + to_hex(magic_buffer)}; } // Read (K, N, M) triple as Little-Endian 64-bit unsigned integers Bytes uint64_buffer(sizeof(uint64_t), '\0'); hashing_istream.read(uint64_buffer); const auto num_keys = endian::load_little_u64(uint64_buffer.data()); if (num_keys != BloomFilter::kHardCodedK) { throw std::runtime_error{"keys must have length: " + std::to_string(BloomFilter::kHardCodedK)}; } hashing_istream.read(uint64_buffer); const auto inserted_count = endian::load_little_u64(uint64_buffer.data()); filter.inserted_count_ = inserted_count; hashing_istream.read(uint64_buffer); const auto bits_count = endian::load_little_u64(uint64_buffer.data()); BloomFilter::ensure_min_bits_count(bits_count); filter.bits_count_ = bits_count; // Read the filter keys as Little-Endian 64-bit unsigned integers for (auto& key : filter.keys_) { hashing_istream.read(uint64_buffer); key = endian::load_little_u64(uint64_buffer.data()); } // Read the filter bits as Little-Endian 64-bit unsigned integers filter.bits_.resize((bits_count + 63) / 64); for (auto& bit : filter.bits_) { hashing_istream.read(uint64_buffer); bit = endian::load_little_u64(uint64_buffer.data()); } // Read the expected hash checksum from serialized data *not using* the hashing stream Bytes hash_buffer(sizeof(SHA384Hash), '\0'); is.read(reinterpret_cast(hash_buffer.data()), static_cast(hash_buffer.size())); const auto sha384_hash = intx::le::unsafe::load(hash_buffer.data()); // Verify that the computed hash checksum does match the expected one const auto computed_hash = hashing_istream.hash(); if (computed_hash.buffer != sha384_hash.buffer) { throw std::runtime_error{"hash mismatch: got=" + to_hex(computed_hash.buffer) + " expected=" + to_hex(sha384_hash.buffer) + " in file: " + filter.path().string()}; } return is; } } // namespace silkworm::snapshots::bloom_filter ================================================ FILE: silkworm/db/datastore/snapshots/bloom_filter/bloom_filter.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "../common/key_hasher.hpp" namespace silkworm::snapshots::bloom_filter { //! Bloom filter implementation (https://en.wikipedia.org/wiki/Bloom_filter) //! \remark Serialized binary format compatible with: https://github.com/holiman/bloomfilter class BloomFilter { public: explicit BloomFilter( std::filesystem::path path, std::optional data_key_hasher = std::nullopt); BloomFilter(); BloomFilter(uint64_t max_key_count, double p); const std::filesystem::path& path() const { return path_; } uint64_t bits_count() const { return bits_count_; } uint64_t key_count() const { return keys_.size(); } //! Insert an already hashed item to the filter //! \param hash the value to add void add_hash(uint64_t hash); //! Checks if filter contains the give \p hash value //! \param hash the value to check for presence //! \return false means "definitely does not contain value", true means "maybe contains value" bool contains_hash(uint64_t hash) const; bool contains(ByteView data_key) const; friend std::istream& operator>>(std::istream& is, BloomFilter& filter); static uint64_t optimal_bits_count(uint64_t max_key_count, double p); //! The fixed number of keys static constexpr size_t kHardCodedK = 3; private: using KeyArray = std::array; static void ensure_min_bits_count(uint64_t bits_count); static KeyArray new_random_keys(); BloomFilter(uint64_t bits_count, KeyArray keys); //! The index file path std::filesystem::path path_; //! Data key hasher std::optional data_key_hasher_; //! The number of bits that the bitmap should be able to track uint64_t bits_count_; //! The keys used to produce the bitmap entries associated to given hashes KeyArray keys_; //! The bitmap tracking the inserted elements std::vector bits_; //! The number of elements inserted into the filter uint64_t inserted_count_{0}; }; } // namespace silkworm::snapshots::bloom_filter ================================================ FILE: silkworm/db/datastore/snapshots/bloom_filter/bloom_filter_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bloom_filter.hpp" #include #include #include #include #include #include #include #include "../test_util/sample_bloom_filter_data.hpp" namespace silkworm::snapshots::bloom_filter { TEST_CASE("BloomFilter", "[snapshot][index][bloom_filter]") { SECTION("empty") { CHECK_THROWS_AS(BloomFilter(0, 0.01), std::runtime_error); } SECTION("empty file") { TemporaryDirectory tmp_dir; CHECK_THROWS_AS(BloomFilter{tmp_dir.get_unique_temporary_path()}, std::runtime_error); } SECTION("item present") { // Create PRNG to generate pseudo-random hash values static std::mt19937_64 rnd_generator{std::random_device{}()}; std::uniform_int_distribution u32_distribution; BloomFilter filter{10'000'000, 0.01}; CHECK(filter.key_count() == BloomFilter::kHardCodedK); CHECK(filter.bits_count() == BloomFilter::optimal_bits_count(10'000'000, 0.01)); // Generate pseudo-random hash values and add them to the filter std::set added_hashes; for (size_t i = 0; i < 100'000; ++i) { const uint64_t h = u32_distribution(rnd_generator); filter.add_hash(h); added_hashes.insert(h); CHECK(filter.contains_hash(h)); // maybe false positive but never incorrect } // Generate more pseudo-random hash values and if absent from filter assert not added for (size_t i = 0; i < 1'000'000; ++i) { const uint64_t h = u32_distribution(rnd_generator); if (!filter.contains_hash(h)) { // definitely not present CHECK(!added_hashes.contains(h)); } } } SECTION("item present in file") { // Create PRNG to generate pseudo-random hash values static std::mt19937_64 rnd_generator{std::random_device{}()}; std::uniform_int_distribution u32_distribution; // Create sample existence index REQUIRE(!test_util::kValidBloomFilters.empty()); silkworm::test_util::TemporaryFile sample_ei_file; sample_ei_file.write(*from_hex(test_util::kValidBloomFilters[0])); BloomFilter existence_index{sample_ei_file.path()}; CHECK(existence_index.path() == sample_ei_file.path()); for (size_t i = 0; i < 100; ++i) { const uint64_t h = u32_distribution(rnd_generator); existence_index.add_hash(h); CHECK(existence_index.contains_hash(h)); } } } TEST_CASE("BloomFilter: operator>>", "[snapshot][index][bloom_filter]") { BloomFilter filter; for (const auto& [hex_stream, description] : test_util::kInvalidBloomFilters) { SECTION("too short: " + std::string{description}) { const Bytes byte_stream = *from_hex(hex_stream); const std::string byte_stream_as_string{byte_stream.begin(), byte_stream.end()}; std::istringstream input_stream{byte_stream_as_string}; CHECK_THROWS_AS((input_stream >> filter), std::runtime_error); } } for (const auto hex_stream : test_util::kValidBloomFilters) { SECTION("valid: size=" + std::to_string(hex_stream.size())) { const Bytes byte_stream = *from_hex(hex_stream); const std::string byte_stream_as_string{byte_stream.begin(), byte_stream.end()}; std::istringstream input_stream{byte_stream_as_string}; CHECK_NOTHROW((input_stream >> filter)); CHECK(filter.bits_count() == 2); } } } } // namespace silkworm::snapshots::bloom_filter ================================================ FILE: silkworm/db/datastore/snapshots/btree/btree.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "btree.hpp" #include #include #include #include namespace silkworm::snapshots::btree { //! Smallest shard available for scan instead of binary search static constexpr uint64_t kDefaultBtreeStartSkip{4}; BTree::BTree( uint64_t num_nodes, uint64_t fanout, std::span encoded_nodes) : num_nodes_(num_nodes), fanout_{fanout}, cache_{decode_nodes(encoded_nodes)} { } using CompareResult = std::pair; static std::optional compare_key( ByteView key, BTree::DataIndex key_index, const BTree::KeyValueIndex& index) { auto data_key = index.lookup_key(key_index); if (!data_key) { return std::nullopt; } int cmp = ByteView{*data_key}.compare(key); return CompareResult{cmp, std::move(*data_key)}; } BTree::SeekResult BTree::seek(ByteView seek_key, const KeyValueIndex& index) { if (seek_key.empty() && num_nodes_ > 0) { auto kv_pair = index.lookup_key_value(0); if (!kv_pair) { return {/*found=*/false, {}, {}, 0}; } bool found = kv_pair->first == seek_key; return {found, std::move(kv_pair->first), std::move(kv_pair->second), 0}; } auto [_, left_index, right_index] = binary_search_in_cache(seek_key); // left_index == right_index when key is found uint64_t median = 0; while (left_index < right_index) { if (right_index - left_index <= kDefaultBtreeStartSkip) { // found a small range, faster to scan now const auto cmp_result = compare_key(seek_key, left_index, index); if (!cmp_result) { return {/*found=*/false, {}, {}, 0}; } const auto [cmp, key] = *cmp_result; if (cmp == 0) { right_index = left_index; break; } if (cmp < 0) { // found key is greater than seek_key if (left_index + 1 < num_nodes_) { ++left_index; continue; } } right_index = left_index; break; } median = (left_index + right_index) >> 1; const auto cmp_result = compare_key(seek_key, median, index); if (!cmp_result) { return {/*found=*/false, {}, {}, 0}; } const auto [cmp, key] = *cmp_result; if (cmp == 0) { left_index = right_index = median; break; } if (cmp > 0) { right_index = median; } else { left_index = median + 1; } } if (left_index == right_index) { median = left_index; } auto kv_pair = index.lookup_key_value(median); if (!kv_pair) { return {/*found=*/false, {}, {}, 0}; } bool found = kv_pair->first == seek_key; return {found, std::move(kv_pair->first), std::move(kv_pair->second), left_index}; } std::optional BTree::get(ByteView key, const KeyValueIndex& index) { if (key.empty() && num_nodes_ > 0) { auto kv_pair = index.lookup_key_value(0); if (!kv_pair) { return std::nullopt; } bool found = kv_pair->first == key; if (!found) { return std::nullopt; } return std::move(kv_pair->second); } auto [_, left_index, right_index] = binary_search_in_cache(key); // left_index == right_index when key is found while (left_index < right_index) { if (right_index - left_index <= kDefaultBtreeStartSkip) { // found a small range, faster to scan now auto value = index.advance_key_value(left_index, key, right_index - left_index); if (!value) { left_index = right_index; break; } return value; } const uint64_t median = (left_index + right_index) >> 1; const auto lookup_result = index.lookup_key_value(median, key); if (!lookup_result) { return std::nullopt; } const auto [cmp, optional_v] = *lookup_result; if (cmp == 0) { SILKWORM_ASSERT(optional_v); return optional_v; } if (cmp > 0) { right_index = median; } else { // cmp < 0 left_index = median + 1; } } const auto lookup_result = index.lookup_key_value(left_index, key); if (!lookup_result) { return std::nullopt; } const auto [cmp, optional_v] = *lookup_result; if (cmp != 0) { return std::nullopt; } SILKWORM_ASSERT(optional_v); return optional_v; } std::pair BTree::Node::from_encoded_data(std::span encoded_node) { constexpr size_t kEncodedIndexPlusKeyLengthSize{sizeof(uint64_t) + sizeof(uint16_t)}; ensure(encoded_node.size() >= kEncodedIndexPlusKeyLengthSize, "snapshots::index::BTree invalid encoded node size"); const auto key_index = endian::load_big_u64(encoded_node.data()); const auto encoded_key = encoded_node.subspan(sizeof(uint64_t)); const auto key_length = endian::load_big_u16(encoded_key.data()); const auto encoded_size = kEncodedIndexPlusKeyLengthSize + key_length; ensure(encoded_node.size() >= encoded_size, "snapshots::index::BTree invalid encoded node size"); const auto key = encoded_key.subspan(sizeof(uint16_t), key_length); return {Node{key_index, Bytes{key.data(), key.size()}}, encoded_size}; } void BTree::warmup(const KeyValueIndex& index) { if (num_nodes_ == 0) { return; } cache_.reserve(num_nodes_ / fanout_); uint64_t cached_bytes{0}; const size_t step = num_nodes_ < fanout_ ? 1 : fanout_; // cache all keys if less than M for (size_t i{step}; i < num_nodes_; i += step) { const size_t data_index = i - 1; auto cmp_result = compare_key({}, data_index, index); if (!cmp_result) continue; auto [_, key] = *cmp_result; cache_.emplace_back(Node{data_index, Bytes{key}}); cached_bytes += sizeof(Node) + ByteView{key}.size(); } SILK_DEBUG << "BTree::warmup finished M=" << fanout_ << " N=" << num_nodes_ << " cache_size=" << cached_bytes; } BTree::Nodes BTree::decode_nodes(std::span encoded_nodes) { if (encoded_nodes.empty()) return {}; BTree::Nodes nodes; ensure(encoded_nodes.size() >= sizeof(uint64_t), "snapshots::index::BTree invalid encoded list of nodes"); const uint64_t node_count = endian::load_big_u64(encoded_nodes.data()); nodes.reserve(node_count); size_t data_position{sizeof(uint64_t)}; for (size_t n{0}; n < node_count; ++n) { auto [node, node_size] = Node::from_encoded_data(encoded_nodes.subspan(data_position)); nodes.emplace_back(std::move(node)); data_position += node_size; } return nodes; } void BTree::check_against_data_keys(const KeyValueIndex& index) { for (const auto& node : cache_) { const auto cmp_result = compare_key(node.key, node.key_index, index); ensure(cmp_result.has_value(), [&] { return "out-of-bounds key=" + to_hex(node.key) + " data_index=" + std::to_string(node.key_index); }); const auto [cmp, key] = *cmp_result; ensure(cmp == 0, [&]() { return "key mismatch node.key=" + to_hex(node.key) + " key=" + to_hex(key) + " key_index=" + std::to_string(node.key_index); }); } } BTree::BinarySearchResult BTree::binary_search_in_cache(ByteView key) { uint64_t left_index = 0, right_index = num_nodes_; uint64_t left_pos = 0, right_pos = cache_.size(); BTree::Node* node{nullptr}; while (left_pos < right_pos) { uint64_t median_pos = (left_pos + right_pos) >> 1; node = &cache_[median_pos]; const int result = node->key.compare(key); if (result == 0) { return {node, node->key_index, node->key_index}; } if (result > 0) { right_pos = median_pos; right_index = node->key_index; } else { // result < 0 left_pos = median_pos + 1; left_index = node->key_index; } } return {node, left_index, right_index}; } } // namespace silkworm::snapshots::btree ================================================ FILE: silkworm/db/datastore/snapshots/btree/btree.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::snapshots::btree { class BTree { public: using DataIndex = uint64_t; using KeyValue = std::pair; struct KeyValueIndex { virtual ~KeyValueIndex() = default; virtual std::optional lookup_key_value(DataIndex) const = 0; virtual std::optional lookup_key(DataIndex) const = 0; using LookupResult = std::pair>; virtual std::optional lookup_key_value(DataIndex, ByteView) const = 0; virtual std::optional advance_key_value(DataIndex, ByteView, size_t skip_max_count) const = 0; }; struct SeekResult { bool found{false}; BytesOrByteView key; BytesOrByteView value; DataIndex key_index{0}; }; BTree( uint64_t num_nodes, uint64_t fanout, std::span encoded_nodes); //! Build the cache from data using some heuristics void warmup(const KeyValueIndex& index); //! \brief Search and return first key-value pair w/ key greater than or equal to \p seek_key //! \param seek_key the key to look for //! \param index the key-value data sequence //! \verbatim //! - found is true if an exact key match is encountered //! - if seek_key is empty, it tries the first data index //! - if found item.key has \p seek_key as prefix, return found=false and item.key //! - if key is greater than all keys, return found=false and empty key //! \endverbatim SeekResult seek(ByteView seek_key, const KeyValueIndex& index); //! \brief Search and return key equal to the given \p key //! \param key the key to look for //! \param index the key-value data sequence std::optional get(ByteView key, const KeyValueIndex& index); void check_against_data_keys(const KeyValueIndex& index); bool empty() const { return cache_.empty(); } protected: struct Node { DataIndex key_index{0}; Bytes key; static std::pair from_encoded_data(std::span encoded_node); }; using Nodes = std::vector; using BinarySearchResult = std::tuple; static BTree::Nodes decode_nodes(std::span encoded_nodes); BinarySearchResult binary_search_in_cache(ByteView key); //! The total number of nodes in the B-Tree index (most of them are only in file, not in cache) uint64_t num_nodes_; //! The number of children for each node in the B-Tree (often identified as M) uint64_t fanout_; //! The part of B-Tree nodes held in memory Nodes cache_; }; } // namespace silkworm::snapshots::btree ================================================ FILE: silkworm/db/datastore/snapshots/btree/btree_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "btree_index.hpp" #include #include #include #include #include #include "../common/raw_codec.hpp" namespace silkworm::snapshots::btree { static bool is_btree_check_against_data_keys_enabled() { const auto btree_assert_offsets_var = Environment::get("BT_ASSERT_OFFSETS"); return !btree_assert_offsets_var.empty() && (std::stoul(btree_assert_offsets_var) != 0); } BTreeIndex::BTreeIndex( std::filesystem::path index_file_path, std::optional index_region, uint64_t btree_fanout) : file_path_(std::move(index_file_path)) { // Gracefully handle the case of empty index file before memory mapping to avoid error if (std::filesystem::file_size(file_path_) == 0) { throw std::runtime_error("index " + file_path_.filename().string() + " is empty"); } // Either use given memory-mapped region or create a new one memory_file_ = std::make_unique(file_path_, index_region); SILKWORM_ASSERT(memory_file_->size() > 0); const auto memory_mapped_range = memory_file_->region(); // Read encoded Elias-Fano 32-bit list of integers representing data offsets data_offsets_ = std::make_shared(EliasFanoList32::from_encoded_data(memory_mapped_range)); ensure(data_offsets_->size() > 0, "BTreeIndex: invalid zero-length data offsets"); const auto encoded_nodes = memory_mapped_range.subspan(data_offsets_->encoded_data_size()); btree_ = std::make_unique(data_offsets_->size(), btree_fanout, encoded_nodes); } void BTreeIndex::warmup_if_empty_or_check(const KVSegmentReader& kv_segment) { KeyValueIndex index{kv_segment, data_offsets_, file_path_}; if (btree_->empty()) { btree_->warmup(index); } else if (is_btree_check_against_data_keys_enabled()) { btree_->check_against_data_keys(index); } } MemoryMappedRegion BTreeIndex::memory_file_region() const { return memory_file_->region(); } std::optional BTreeIndex::seek(ByteView seek_key, const KVSegmentReader& kv_segment) const { KeyValueIndex index{kv_segment, data_offsets_, file_path_}; auto [found, key, value, data_index] = btree_->seek(seek_key, index); if (ByteView{key}.compare(seek_key) >= 0) { return BTreeIndex::Cursor{ this, std::move(key), std::move(value), data_index, &kv_segment, }; } return std::nullopt; } std::optional BTreeIndex::get(ByteView key, const KVSegmentReader& kv_segment) const { const KeyValueIndex index{kv_segment, data_offsets_, file_path_}; return btree_->get(key, index); } std::optional BTreeIndex::KeyValueIndex::lookup_key_value(DataIndex data_index) const { if (data_index >= data_offsets_->size()) { return std::nullopt; } const auto data_offset = data_offsets_->at(data_index); segment::KVSegmentReader, RawDecoder> reader{kv_segment_}; auto data_it = reader.seek(data_offset); if (data_it == reader.end()) { throw std::runtime_error{"key/value not found data_index=" + std::to_string(data_index) + " for " + file_path_.string()}; } auto kv_pair = *data_it; return BTree::KeyValue{kv_pair.first, kv_pair.second}; } std::optional BTreeIndex::KeyValueIndex::lookup_key(DataIndex data_index) const { if (data_index >= data_offsets_->size()) { return std::nullopt; } const auto data_offset = data_offsets_->at(data_index); segment::KVSegmentKeysReader> reader{kv_segment_}; const auto data_it = reader.seek(data_offset); if (data_it == reader.end()) { throw std::runtime_error{"key not found data_index=" + std::to_string(data_index) + " for " + file_path_.string()}; } return *data_it; } std::optional BTreeIndex::KeyValueIndex::lookup_key_value(DataIndex data_index, ByteView k) const { if (data_index >= data_offsets_->size()) { return std::nullopt; } const auto data_offset = data_offsets_->at(data_index); const auto& decompressor = kv_segment_.decompressor(); auto it = decompressor.seek(data_offset); if (it == decompressor.end() || !it.has_next()) { throw std::runtime_error{"key not found data_index=" + std::to_string(data_index) + " for " + file_path_.string()}; } if (const int key_compare = ByteView{*it}.compare(k); key_compare != 0) { return LookupResult{key_compare, std::nullopt}; } // Key matches: advance and read value ++it; return LookupResult{0, std::move(*it)}; } static seg::Decompressor::Iterator kv_decompressor_seek_to_key( const seg::Decompressor& decompressor, uint64_t offset, ByteView search_key, size_t skip_max_count) { auto it = decompressor.seek(offset, {}); if (it == decompressor.end()) { return it; } if (!it.has_next()) { return decompressor.end(); } Decoder::Word key_word = std::move(*it); size_t skip_count{0}; int cmp = 0; while ((cmp = ByteView{key_word}.compare(search_key)) < 0) { // Skip the value if key is still lower than the target one it.skip(); if (++skip_count == skip_max_count) { return decompressor.end(); } // Go to the next key w/ bound check ++it; if (!it.has_next()) { return decompressor.end(); } key_word = std::move(*it); } if (cmp > 0) { // Target key not found return decompressor.end(); } return it; } std::optional BTreeIndex::KeyValueIndex::advance_key_value(const DataIndex data_index, const ByteView k, const size_t skip_max_count) const { if (data_index >= data_offsets_->size()) { return std::nullopt; } const auto data_offset = data_offsets_->at(data_index); const auto& decompressor = kv_segment_.decompressor(); auto it = kv_decompressor_seek_to_key(decompressor, data_offset, k, skip_max_count); if ((it == decompressor.end()) || !it.has_next()) { return std::nullopt; } ++it; return std::move(*it); } bool BTreeIndex::Cursor::next() { if (data_index_ + 1 >= index_->data_offsets_->size()) { return false; } ++data_index_; KeyValueIndex index{*kv_segment_, index_->data_offsets(), index_->path()}; auto kv = index.lookup_key_value(data_index_); if (!kv) { return false; } value_ = value_type{ std::move(kv->first), std::move(kv->second), }; return true; } } // namespace silkworm::snapshots::btree ================================================ FILE: silkworm/db/datastore/snapshots/btree/btree_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "../elias_fano/elias_fano_list.hpp" #include "../segment/kv_segment_reader.hpp" #include "btree.hpp" namespace silkworm::snapshots::btree { class BTreeIndex { public: static constexpr uint64_t kDefaultFanout{256}; using DataIndex = BTree::DataIndex; using EliasFanoList32 = elias_fano::EliasFanoList32; using KVSegmentReader = segment::KVSegmentFileReader; class Cursor { public: using value_type = std::pair; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; Cursor() = default; ByteView key() const noexcept { return value_.first; } ByteView value() const noexcept { return value_.second; } DataIndex data_index() const noexcept { return data_index_; } bool next(); reference operator*() const { return value_; } pointer operator->() const { return &value_; } Cursor operator++(int) { return std::exchange(*this, ++Cursor{*this}); } Cursor& operator++() { if (!next()) { // reset to the end state *this = {}; } return *this; } friend bool operator!=(const Cursor& it, const std::default_sentinel_t&) { return it.index_ != nullptr; } friend bool operator==(const Cursor& it, const std::default_sentinel_t&) { return it.index_ == nullptr; } friend bool operator!=(const std::default_sentinel_t& s, const Cursor& it) { return it != s; } friend bool operator==(const std::default_sentinel_t& s, const Cursor& it) { return it == s; } private: friend class BTreeIndex; Cursor( const BTreeIndex* index, BytesOrByteView key, BytesOrByteView value, DataIndex data_index, const KVSegmentReader* kv_segment) : index_{index}, value_{std::move(key), std::move(value)}, data_index_{data_index}, kv_segment_{kv_segment} {} const BTreeIndex* index_{nullptr}; mutable value_type value_; DataIndex data_index_{0}; const KVSegmentReader* kv_segment_{nullptr}; }; explicit BTreeIndex( std::filesystem::path index_file_path, std::optional index_region = {}, uint64_t btree_fanout = kDefaultFanout); void warmup_if_empty_or_check(const KVSegmentReader& kv_segment); //! Return the Elias-Fano encoding of the sequence of key offsets or nullptr if not present std::shared_ptr data_offsets() const { return data_offsets_; } //! Return the number of keys included into this index size_t key_count() const { return data_offsets_->size(); }; const std::filesystem::path& path() const { return file_path_; } MemoryMappedRegion memory_file_region() const; //! Seek and return a cursor at position where key >= \p seek_key //! \param seek_key the given key at/after which the cursor must be positioned //! \param kv_segment reader of the key-value data sequence //! \return a cursor positioned at key >= \p seek_key or nullptr //! \details if \p seek_key is empty, first key is returned //! \details if \p seek_key is greater than any other key, std::nullopt is returned std::optional seek(ByteView seek_key, const KVSegmentReader& kv_segment) const; //! Get the value associated to the given key with exact match //! \param key the data key to match exactly //! \param kv_segment reader of the key-value data sequence //! \return the value associated at \p key or std::nullopt if not found std::optional get(ByteView key, const KVSegmentReader& kv_segment) const; private: class KeyValueIndex : public BTree::KeyValueIndex { public: explicit KeyValueIndex( const KVSegmentReader& kv_segment, std::shared_ptr data_offsets, const std::filesystem::path& file_path) : kv_segment_{kv_segment}, data_offsets_{std::move(data_offsets)}, file_path_{file_path} {} ~KeyValueIndex() override = default; std::optional lookup_key_value(DataIndex data_index) const override; std::optional lookup_key(DataIndex data_index) const override; std::optional lookup_key_value(DataIndex, ByteView) const override; std::optional advance_key_value(DataIndex, ByteView, size_t skip_max_count) const override; private: const KVSegmentReader& kv_segment_; std::shared_ptr data_offsets_; const std::filesystem::path& file_path_; }; std::filesystem::path file_path_; std::unique_ptr memory_file_; std::shared_ptr data_offsets_; std::unique_ptr btree_; }; } // namespace silkworm::snapshots::btree ================================================ FILE: silkworm/db/datastore/snapshots/btree/btree_index_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "btree_index.hpp" #include #include #include #include #include #include #include #include "../../common/ranges/vector_from_range.hpp" #include "../common/raw_codec.hpp" #include "../segment/seg/compressor.hpp" namespace silkworm::snapshots::btree { using namespace silkworm::test_util; using elias_fano::EliasFanoList32Builder; using KeyAndValue = std::pair; static SnapshotPath sample_kv_file(const TemporaryDirectory& tmp_dir, const std::vector& kv_pairs) { const auto kv_file_path = *SnapshotPath::parse(tmp_dir.path() / "v1-accounts.0-1024.kv"); seg::Compressor kv_compressor{kv_file_path.path(), tmp_dir.path()}; for (const KeyAndValue& kv_pair : kv_pairs) { kv_compressor.add_word(kv_pair.first, /*is_compressed=*/false); kv_compressor.add_word(kv_pair.second, /*is_compressed=*/false); } seg::Compressor::compress(std::move(kv_compressor)); return kv_file_path; } static std::filesystem::path sample_bt_index_file(const EliasFanoList32Builder& key_offsets) { TemporaryFile index_file; std::stringstream str_stream; str_stream << key_offsets; const std::string stream = str_stream.str(); Bytes ef_bytes{stream.cbegin(), stream.cend()}; index_file.write(ef_bytes); return index_file.path(); } using KvAndBtPaths = std::tuple; static const std::vector& sample_kv_pairs() { static const std::vector kKVPairs{ {*from_hex("0000000000000000000000000000000000000000"), *from_hex("000a0269024e3c8decd159600000")}, {*from_hex("0000000000000000000000000000000000000004"), *from_hex("0008cf2fa48840ba8add0000")}, {*from_hex("0000000000000000000000000000000000000008"), *from_hex("0008146c4643c28ed8200000")}, }; return kKVPairs; } static KvAndBtPaths sample_3_keys_kv_and_bt_files(const TemporaryDirectory& tmp_dir) { // Prepare sample uncompressed KV file containing some key-value pairs const auto kv_file_path = sample_kv_file( tmp_dir, sample_kv_pairs()); // Prepare the BT index for such KV file // Note: key offsets can be computed from KV file layout // 000000000000000600000000000000000000000000000000000000000000000801000215030F030D // 01 // 0000000000000000000000000000000000000000 <- 1st key, offset 0 // 03 // 000A0269024E3C8DECD159600000 // 01 // 0000000000000000000000000000000000000004 <- 2nd key, offset 0 + 20 + 1 + 14 + 1 // 07 // 0008CF2FA48840BA8ADD0000 // 01 // 0000000000000000000000000000000000000008 <- 3rd key, offset 0 + 20 + 1 + 14 + 1 + 20 + 1 + 12 + 1 // 07 // 0008146C4643C28ED8200000 EliasFanoList32Builder encoded_key_offsets{3, 70}; encoded_key_offsets.add_offset(0); encoded_key_offsets.add_offset(0 + 20 + 1 + 14 + 1); encoded_key_offsets.add_offset(0 + 20 + 1 + 14 + 1 + 20 + 1 + 12 + 1); encoded_key_offsets.build(); const auto bt_file_path = sample_bt_index_file(encoded_key_offsets); return {kv_file_path, bt_file_path}; } TEST_CASE("BTreeIndex", "[snapshots][btree]") { TemporaryDirectory tmp_dir; SECTION("empty") { TemporaryFile index_file; index_file.write(Bytes{}); CHECK_THROWS_AS(BTreeIndex(index_file.path()), std::runtime_error); } // Prepare sample uncompressed KV file containing 3 key-value pairs and its BT index file const auto [kv_file_path, bt_file_path] = sample_3_keys_kv_and_bt_files(tmp_dir); // Open the KV and BT index files segment::KVSegmentFileReader kv_segment{kv_file_path, {}, seg::CompressionKind::kNone}; BTreeIndex bt_index{bt_file_path}; bt_index.warmup_if_empty_or_check(kv_segment); REQUIRE(bt_index.key_count() == 3); SECTION("BTreeIndex::get") { // Check that all values retrieved through BT index match size_t key_count{0}; segment::KVSegmentReader, RawDecoder> reader{kv_segment}; for (const auto [key, value] : reader) { const auto v = bt_index.get(key, kv_segment); CHECK(v == value); ++key_count; } CHECK(key_count == bt_index.key_count()); } SECTION("BTreeIndex::seek") { // Seek using exact keys starting from the first one auto index_it = bt_index.seek(ByteView{}, kv_segment); REQUIRE(index_it); REQUIRE(index_it->key() == *from_hex("0000000000000000000000000000000000000000")); REQUIRE(index_it->value() == *from_hex("000a0269024e3c8decd159600000")); REQUIRE(index_it->data_index() == 0); REQUIRE(index_it->next()); REQUIRE(index_it->key() == *from_hex("0000000000000000000000000000000000000004")); REQUIRE(index_it->value() == *from_hex("0008cf2fa48840ba8add0000")); REQUIRE(index_it->data_index() == 1); REQUIRE(index_it->next()); REQUIRE(index_it->key() == *from_hex("0000000000000000000000000000000000000008")); REQUIRE(index_it->value() == *from_hex("0008146c4643c28ed8200000")); REQUIRE(index_it->data_index() == 2); REQUIRE(!index_it->next()); // Seek using lower keys than existing ones index_it = bt_index.seek(*from_hex("0000000000000000000000000000000000000003"), kv_segment); REQUIRE(index_it->key() == *from_hex("0000000000000000000000000000000000000004")); REQUIRE(index_it->value() == *from_hex("0008cf2fa48840ba8add0000")); REQUIRE(index_it->data_index() == 1); index_it = bt_index.seek(*from_hex("0000000000000000000000000000000000000007"), kv_segment); REQUIRE(index_it->key() == *from_hex("0000000000000000000000000000000000000008")); REQUIRE(index_it->value() == *from_hex("0008146c4643c28ed8200000")); REQUIRE(index_it->data_index() == 2); // Seek beyond the last key CHECK(!bt_index.seek(*from_hex("0000000000000000000000000000000000000009"), kv_segment)); CHECK(!bt_index.seek(*from_hex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), kv_segment)); } SECTION("BTreeIndex::seek cursor iteration") { static_assert(std::input_iterator); auto kv_from_refs = [](std::pair kv_refs) -> KeyAndValue { return KeyAndValue{Bytes{kv_refs.first}, Bytes{kv_refs.second}}; }; auto it = bt_index.seek(ByteView{}, kv_segment); REQUIRE(it.has_value()); CHECK(vector_from_range( std::ranges::subrange{std::move(*it), std::default_sentinel} | std::views::transform(kv_from_refs)) == sample_kv_pairs()); } } } // namespace silkworm::snapshots::btree ================================================ FILE: silkworm/db/datastore/snapshots/common/codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::datastore { struct StepToTimestampConverter; } // namespace silkworm::datastore namespace silkworm::snapshots { class SnapshotPath; struct Encoder { virtual ~Encoder() = default; virtual ByteView encode_word() = 0; }; template concept EncoderConcept = std::derived_from && requires(TEncoder encoder) { encoder.value; }; struct Decoder { virtual ~Decoder() = default; using Word = BytesOrByteView; virtual void decode_word(Word& word) = 0; // this allows word to be moved after decoding virtual void decode_word_with_metadata(const SnapshotPath& /*path*/, const datastore::StepToTimestampConverter& /*step_converter*/) {} virtual void check_sanity_with_metadata(const SnapshotPath& /*path*/, const datastore::StepToTimestampConverter& /*step_converter*/) {} }; template concept DecoderConcept = std::derived_from && requires(TDecoder decoder) { decoder.value; }; struct Codec : public Encoder, public Decoder { ~Codec() override = default; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/encoding/murmur_hash3.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // MurmurHash3 was written by Austin Appleby, and is placed in the public // domain. The author hereby disclaims copyright to this source code. #include "murmur_hash3.hpp" #include namespace silkworm::snapshots::encoding { // Platform-specific functions and macros // Microsoft Visual Studio #if defined(_MSC_VER) #define FORCE_INLINE __forceinline #include #define ROTL64(x, y) _rotl64(x, y) #define BIG_CONSTANT(x) (x) // Other compilers #else // defined(_MSC_VER) #define FORCE_INLINE inline __attribute__((always_inline)) inline uint64_t rotl64(uint64_t x, int8_t r) { return (x << r) | (x >> (64 - r)); } #define ROTL64(x, y) rotl64(x, y) #define BIG_CONSTANT(x) (x##LLU) #endif // !defined(_MSC_VER) // Block read - if your platform needs to do endian-swapping or can only // handle aligned reads, do the conversion here FORCE_INLINE uint64_t getblock64(const uint64_t* p, size_t i) { return p[i]; } // Finalization mix - force all bits of a hash block to avalanche FORCE_INLINE uint64_t fmix64(uint64_t k) { k ^= k >> 33; k *= BIG_CONSTANT(0xff51afd7ed558ccd); k ^= k >> 33; k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53); k ^= k >> 33; return k; } void murmur_hash3_x64_128(const void* key, const uint64_t len, const uint32_t seed, void* out) { const auto* data = reinterpret_cast(key); const size_t num_blocks = len / 16; uint64_t h1 = seed; uint64_t h2 = seed; const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5); const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f); //---------- // body const auto* blocks = reinterpret_cast(data); for (size_t i{0}; i < num_blocks; ++i) { uint64_t k1 = getblock64(blocks, i * 2 + 0); uint64_t k2 = getblock64(blocks, i * 2 + 1); k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1; h1 = ROTL64(h1, 27); h1 += h2; h1 = h1 * 5 + 0x52dce729; k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2; h2 = ROTL64(h2, 31); h2 += h1; h2 = h2 * 5 + 0x38495ab5; } //---------- // tail const auto* tail = reinterpret_cast(data + num_blocks * 16); uint64_t k1 = 0; uint64_t k2 = 0; switch (len & 15) { case 15: k2 ^= static_cast(tail[14]) << 48; [[fallthrough]]; case 14: k2 ^= static_cast(tail[13]) << 40; [[fallthrough]]; case 13: k2 ^= static_cast(tail[12]) << 32; [[fallthrough]]; case 12: k2 ^= static_cast(tail[11]) << 24; [[fallthrough]]; case 11: k2 ^= static_cast(tail[10]) << 16; [[fallthrough]]; case 10: k2 ^= static_cast(tail[9]) << 8; [[fallthrough]]; case 9: k2 ^= static_cast(tail[8]) << 0; k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2; [[fallthrough]]; case 8: k1 ^= static_cast(tail[7]) << 56; [[fallthrough]]; case 7: k1 ^= static_cast(tail[6]) << 48; [[fallthrough]]; case 6: k1 ^= static_cast(tail[5]) << 40; [[fallthrough]]; case 5: k1 ^= static_cast(tail[4]) << 32; [[fallthrough]]; case 4: k1 ^= static_cast(tail[3]) << 24; [[fallthrough]]; case 3: k1 ^= static_cast(tail[2]) << 16; [[fallthrough]]; case 2: k1 ^= static_cast(tail[1]) << 8; [[fallthrough]]; case 1: k1 ^= static_cast(tail[0]) << 0; k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1; [[fallthrough]]; default: break; // do nothing } //---------- // finalization h1 ^= len; h2 ^= len; h1 += h2; h2 += h1; h1 = fmix64(h1); h2 = fmix64(h2); h1 += h2; h2 += h1; reinterpret_cast(out)[0] = h1; reinterpret_cast(out)[1] = h2; } } // namespace silkworm::snapshots::encoding ================================================ FILE: silkworm/db/datastore/snapshots/common/encoding/murmur_hash3.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once // MurmurHash3 was written by Austin Appleby, and is placed in the public // domain. The author hereby disclaims copyright to this source code. // Platform-specific functions and macros // Microsoft Visual Studio #if defined(_MSC_VER) && (_MSC_VER < 1600) typedef unsigned char uint8_t; typedef unsigned int uint32_t; typedef unsigned __int64 uint64_t; // Other compilers #else // defined(_MSC_VER) #include #endif // !defined(_MSC_VER) namespace silkworm::snapshots::encoding { void murmur_hash3_x64_128(const void* key, uint64_t len, uint32_t seed, void* out); class Murmur3 { public: explicit Murmur3(uint32_t seed) : seed_(seed) {} void reset_seed(uint32_t seed) noexcept { seed_ = seed; } void hash_x64_128(const void* key, uint64_t len, void* out) const { murmur_hash3_x64_128(key, len, seed_, out); } private: uint32_t seed_; }; } // namespace silkworm::snapshots::encoding ================================================ FILE: silkworm/db/datastore/snapshots/common/encoding/murmur_hash3_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "murmur_hash3.hpp" #include #include #include namespace silkworm::snapshots::encoding { TEST_CASE("murmur_hash3_x64_128", "[silkworm][recsplit][support]") { constexpr size_t kHashBits{128}; constexpr size_t kExpectedVerification{0x6384BA69}; constexpr size_t kHashBytes = kHashBits / 8u; uint8_t* key{new uint8_t[256]}; uint8_t* hashes{new uint8_t[kHashBytes * 256u]}; uint8_t* res{new uint8_t[kHashBytes]}; std::memset(key, 0, 256); std::memset(hashes, 0, kHashBytes * 256); std::memset(res, 0, kHashBytes); // Hash keys of the form {0}, {0,1}, {0,1,2}... up to N=255 using 256-N as the seed for (uint32_t i{0}; i < 256; ++i) { key[i] = static_cast(i); murmur_hash3_x64_128(key, i, 256 - i, &hashes[i * kHashBytes]); } // Then hash the result array murmur_hash3_x64_128(hashes, kHashBytes * 256, 0, res); // The first four bytes of that hash, interpreted as a LE integer, is our verification value const int verification = (res[0] << 0) | (res[1] << 8) | (res[2] << 16) | (res[3] << 24); delete[] key; delete[] hashes; delete[] res; CHECK(verification == kExpectedVerification); } TEST_CASE("Murmur3", "[silkworm][recsplit][support]") { Murmur3 hasher{42}; uint8_t* key{new uint8_t[256]}; uint8_t* hashed{new uint8_t[128]}; CHECK_NOTHROW(hasher.hash_x64_128(key, 128, hashed)); delete[] key; delete[] hashed; } } // namespace silkworm::snapshots::encoding ================================================ FILE: silkworm/db/datastore/snapshots/common/encoding/sequence.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::snapshots::encoding { template using UnsignedIntegralSequence = std::vector; //! Max integer sequence length capped at hard limit to fit in memory inline constexpr size_t kMaxUnsignedIntegralSequenceSize{15 * kMebi}; using Uint32Sequence = UnsignedIntegralSequence; using Uint64Sequence = UnsignedIntegralSequence; template std::ostream& operator<<(std::ostream& os, const UnsignedIntegralSequence& s) { // Serialize the integer sequence size using 8-bytes const uint64_t size = s.size(); Bytes buffer(sizeof(uint64_t), '\0'); endian::store_big_u64(buffer.data(), size); os.write(reinterpret_cast(buffer.data()), sizeof(uint64_t)); // Serialize the integer sequence os.write(reinterpret_cast(s.data()), static_cast(size * sizeof(T))); return os; } template std::istream& operator>>(std::istream& is, UnsignedIntegralSequence& s) { // Deserialize the integer sequence size using 8-bytes Bytes buffer(sizeof(uint64_t), '\0'); is.read(reinterpret_cast(buffer.data()), sizeof(uint64_t)); const uint64_t size = endian::load_big_u64(buffer.data()); ensure(size <= kMaxUnsignedIntegralSequenceSize, [&] { return "decoded sequence size is too big: " + std::to_string(size); }); // Deserialize the integer sequence s.resize(size); is.read(reinterpret_cast(s.data()), static_cast(size * sizeof(T))); return is; } } // namespace silkworm::snapshots::encoding ================================================ FILE: silkworm/db/datastore/snapshots/common/encoding/sequence_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "sequence.hpp" #include #include #include #include #include #include namespace silkworm::snapshots::encoding { TEST_CASE("Uint64Sequence", "[silkworm][snapshots][recsplit][sequence]") { Uint64Sequence output_sequence{0, 11, 21, 31, 41, 51, 61}; std::stringstream ss; ss << output_sequence; Uint64Sequence input_sequence; ss >> input_sequence; CHECK(input_sequence == output_sequence); } TEST_CASE("Uint64Sequence: size too big", "[silkworm][snapshots][recsplit][sequence]") { std::stringstream ss; Bytes invalid_size_buffer(sizeof(uint64_t), '\0'); endian::store_big_u64(invalid_size_buffer.data(), 49287623586282974); ss.write(byte_ptr_cast(invalid_size_buffer.data()), static_cast(invalid_size_buffer.size())); Uint64Sequence input_sequence; CHECK_THROWS_AS((ss >> input_sequence), std::logic_error); } } // namespace silkworm::snapshots::encoding ================================================ FILE: silkworm/db/datastore/snapshots/common/encoding/util.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito, Stefano Marchini and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #if (__x86_64__ || __i386__) #include #endif #include #include #include #include #include #include #include namespace silkworm::snapshots::encoding { using std::memcpy; using std::make_unique; using std::unique_ptr; using std::max; using std::min; using std::uint16_t; using std::uint32_t; using std::uint64_t; using std::uint8_t; /** Static (i.e. computed in compile time) 1 + log2 rounded up. */ constexpr size_t ceil_log2_plus1(size_t n) { return ((n < 2) ? 1 : 1 + ceil_log2_plus1(n / 2)); } // Required by select64 inline constexpr uint8_t kSelectInByte[2048] = { 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 8, 8, 8, 1, 8, 2, 2, 1, 8, 3, 3, 1, 3, 2, 2, 1, 8, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 8, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 8, 6, 6, 1, 6, 2, 2, 1, 6, 3, 3, 1, 3, 2, 2, 1, 6, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 6, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 8, 7, 7, 1, 7, 2, 2, 1, 7, 3, 3, 1, 3, 2, 2, 1, 7, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 7, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 7, 6, 6, 1, 6, 2, 2, 1, 6, 3, 3, 1, 3, 2, 2, 1, 6, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 6, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 8, 8, 8, 8, 8, 8, 8, 2, 8, 8, 8, 3, 8, 3, 3, 2, 8, 8, 8, 4, 8, 4, 4, 2, 8, 4, 4, 3, 4, 3, 3, 2, 8, 8, 8, 5, 8, 5, 5, 2, 8, 5, 5, 3, 5, 3, 3, 2, 8, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 8, 8, 8, 6, 8, 6, 6, 2, 8, 6, 6, 3, 6, 3, 3, 2, 8, 6, 6, 4, 6, 4, 4, 2, 6, 4, 4, 3, 4, 3, 3, 2, 8, 6, 6, 5, 6, 5, 5, 2, 6, 5, 5, 3, 5, 3, 3, 2, 6, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 8, 8, 8, 7, 8, 7, 7, 2, 8, 7, 7, 3, 7, 3, 3, 2, 8, 7, 7, 4, 7, 4, 4, 2, 7, 4, 4, 3, 4, 3, 3, 2, 8, 7, 7, 5, 7, 5, 5, 2, 7, 5, 5, 3, 5, 3, 3, 2, 7, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 8, 7, 7, 6, 7, 6, 6, 2, 7, 6, 6, 3, 6, 3, 3, 2, 7, 6, 6, 4, 6, 4, 4, 2, 6, 4, 4, 3, 4, 3, 3, 2, 7, 6, 6, 5, 6, 5, 5, 2, 6, 5, 5, 3, 5, 3, 3, 2, 6, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 3, 8, 8, 8, 8, 8, 8, 8, 4, 8, 8, 8, 4, 8, 4, 4, 3, 8, 8, 8, 8, 8, 8, 8, 5, 8, 8, 8, 5, 8, 5, 5, 3, 8, 8, 8, 5, 8, 5, 5, 4, 8, 5, 5, 4, 5, 4, 4, 3, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 6, 8, 6, 6, 3, 8, 8, 8, 6, 8, 6, 6, 4, 8, 6, 6, 4, 6, 4, 4, 3, 8, 8, 8, 6, 8, 6, 6, 5, 8, 6, 6, 5, 6, 5, 5, 3, 8, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 3, 8, 8, 8, 7, 8, 7, 7, 4, 8, 7, 7, 4, 7, 4, 4, 3, 8, 8, 8, 7, 8, 7, 7, 5, 8, 7, 7, 5, 7, 5, 5, 3, 8, 7, 7, 5, 7, 5, 5, 4, 7, 5, 5, 4, 5, 4, 4, 3, 8, 8, 8, 7, 8, 7, 7, 6, 8, 7, 7, 6, 7, 6, 6, 3, 8, 7, 7, 6, 7, 6, 6, 4, 7, 6, 6, 4, 6, 4, 4, 3, 8, 7, 7, 6, 7, 6, 6, 5, 7, 6, 6, 5, 6, 5, 5, 3, 7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 5, 8, 8, 8, 8, 8, 8, 8, 5, 8, 8, 8, 5, 8, 5, 5, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 6, 8, 6, 6, 4, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 6, 8, 6, 6, 5, 8, 8, 8, 6, 8, 6, 6, 5, 8, 6, 6, 5, 6, 5, 5, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 4, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 5, 8, 8, 8, 7, 8, 7, 7, 5, 8, 7, 7, 5, 7, 5, 5, 4, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 6, 8, 8, 8, 7, 8, 7, 7, 6, 8, 7, 7, 6, 7, 6, 6, 4, 8, 8, 8, 7, 8, 7, 7, 6, 8, 7, 7, 6, 7, 6, 6, 5, 8, 7, 7, 6, 7, 6, 6, 5, 7, 6, 6, 5, 6, 5, 5, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 6, 8, 6, 6, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 6, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 6, 8, 8, 8, 7, 8, 7, 7, 6, 8, 7, 7, 6, 7, 6, 6, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 8, 7, 8, 7, 7, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7}; /** Find the index of the least significant 1-bit in a word. * @param word binary word. * * The Knuth's ruler function returns the number of trailing 0-bits in `word` starting from the least * significant position. It returns 0 when `word` is 2^0 and it returns 63 when it is 2^63. * * The behavior in zero is undefined. * */ inline int rho(uint64_t word) { return std::countr_zero(word); } /** Find the index of the most significant 1-bit in a word. * @param word binary word. * * The Knuth's lambda function is the dual of the rho function. * * The behavior in zero is undefined. * */ inline int lambda(uint64_t word) { return 63 ^ std::countl_zero(word); } //! Convert the number x which is assumed to be uniformly distributed over the range [0..2^64) to a number that is uniformly //! distributed over the range [0..n), under assumption that n is less than 2^16 inline uint64_t remap16(uint64_t x, uint64_t n) { SILKWORM_ASSERT(n < (1 << 16)); static const int kMaskLen = 48; static const uint64_t kMask = (uint64_t{1} << kMaskLen) - 1; return ((x & kMask) * n) >> kMaskLen; } inline uint64_t remap128(uint64_t x, uint64_t n) { #ifdef __SIZEOF_INT128__ return static_cast((static_cast<__uint128_t>(x) * static_cast<__uint128_t>(n)) >> 64); #else // Less than 2^32 keys return (uint32_t)x * n >> 32; #endif // __SIZEOF_INT128__ } /** Count the number of 1-bits in a word. * @param word binary word. * */ inline uint64_t nu(uint64_t word) { return static_cast(std::popcount(word)); } /** Returns the index of the k-th 1-bit in the 64-bit word x. * @param x 64-bit word. * @param k 0-based rank (`k = 0` returns the position of the first 1-bit). * * Uses the broadword selection algorithm by Vigna [1], improved by Gog and Petri [2] and Vigna [3]. * Facebook's Folly implementation [4]. * * [1] Sebastiano Vigna. Broadword Implementation of Rank/Select Queries. WEA, 2008 * * [2] Simon Gog, Matthias Petri. Optimized succinct data structures for massive data. Softw. Pract. * Exper., 2014 * * [3] Sebastiano Vigna. MG4J 5.2.1. http://mg4j.di.unimi.it/ * * [4] Facebook Folly library: https://github.com/facebook/folly * */ inline uint64_t select64(uint64_t x, uint64_t k) { #ifndef __BMI2__ constexpr uint64_t kOnesStep4 = 0x1111111111111111ULL; constexpr uint64_t kOnesStep8 = 0x0101010101010101ULL; constexpr uint64_t kLAMBDAsStep8 = 0x80ULL * kOnesStep8; auto s = x; s = s - ((s & 0xA * kOnesStep4) >> 1); s = (s & 0x3 * kOnesStep4) + ((s >> 2) & 0x3 * kOnesStep4); s = (s + (s >> 4)) & 0xF * kOnesStep8; uint64_t byte_sums = s * kOnesStep8; uint64_t k_step8 = k * kOnesStep8; uint64_t geq_k_step8 = (((k_step8 | kLAMBDAsStep8) - byte_sums) & kLAMBDAsStep8); uint64_t place = nu(geq_k_step8) * 8; uint64_t byte_rank = k - (((byte_sums << 8) >> place) & uint64_t{0xFF}); return place + kSelectInByte[((x >> place) & 0xFF) | (byte_rank << 8)]; #elif defined(__GNUC__) || defined(__clang__) // GCC and Clang won't inline the intrinsics. uint64_t result = uint64_t{1} << k; asm("pdep %1, %0, %0\n\t" "tzcnt %0, %0" : "+r"(result) : "r"(x)); return result; #else return _tzcnt_u64(_pdep_u64(1ULL << k, x)); #endif } } // namespace silkworm::snapshots::encoding ================================================ FILE: silkworm/db/datastore/snapshots/common/key_hasher.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "key_hasher.hpp" #include #include "../common/encoding/murmur_hash3.hpp" namespace silkworm::snapshots { uint64_t KeyHasher::hash(ByteView key) const { std::array hash = {0, 0}; encoding::Murmur3{salt_}.hash_x64_128(key.data(), key.size(), hash.data()); return hash[0]; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/key_hasher.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::snapshots { class KeyHasher { public: explicit KeyHasher(uint32_t salt) : salt_{salt} {} uint64_t hash(ByteView key) const; private: uint32_t salt_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/key_hasher_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "key_hasher.hpp" #include #include namespace silkworm::snapshots { TEST_CASE("KeyHasher") { CHECK(KeyHasher{0}.hash(*from_hex("CAFEBABE")) == 2809309899937206063u); CHECK(KeyHasher{12345}.hash(*from_hex("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")) == 17810263873480351644u); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/raw_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "codec.hpp" namespace silkworm::snapshots { template concept BytesOrByteViewConcept = std::same_as || std::same_as || std::same_as; template struct RawDecoder : public Decoder { TBytes value; ~RawDecoder() override = default; void decode_word(Word& word) override { if (word.holds_bytes()) { if constexpr (std::same_as) { ensure(false, "RawDecoder should be instead RawDecoder"); } value = std::move(std::get(word)); } else { value = std::get(word); } } }; template <> struct RawDecoder : public Decoder { BytesOrByteView value; ~RawDecoder() override = default; void decode_word(Word& word) override { value = std::move(word); } }; static_assert(DecoderConcept>); static_assert(DecoderConcept>); static_assert(DecoderConcept>); template struct RawEncoder : public Encoder { TBytes value; ~RawEncoder() override = default; ByteView encode_word() override { return value; } }; static_assert(EncoderConcept>); static_assert(EncoderConcept>); } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/snapshot_path.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_path.hpp" #include #include #include #include #include #include namespace silkworm::snapshots { namespace fs = std::filesystem; std::optional SnapshotPath::parse(fs::path path) { auto base_dir = path.parent_path(); return parse(std::move(path), base_dir); } std::optional SnapshotPath::parse( fs::path path, const fs::path& base_dir) { auto filename = path.filename().string(); // example: v1-009960-009970-transactions-to-block.idx static const std::regex kFilenameRegexE2{R"(v(\d)-(\d{6})-(\d{6})-([\w\-]+)\.\w+)"}; // example: v1-commitment.0-1024.kv static const std::regex kFilenameRegexE3{R"(v(\d)-([\w\-]+)\.(\d{1,6})-(\d{1,6})\.\w+)"}; FilenameFormat filename_format = FilenameFormat::kE2; int step_start = 0; int step_end = 0; std::string tag; std::smatch matches; if (std::regex_match(filename, matches, kFilenameRegexE2)) { filename_format = FilenameFormat::kE2; step_start = std::stoi(matches[2]); step_end = std::stoi(matches[3]); tag = matches[4].str(); } else if (std::regex_match(filename, matches, kFilenameRegexE3)) { filename_format = FilenameFormat::kE3; step_start = std::stoi(matches[3]); step_end = std::stoi(matches[4]); tag = matches[2].str(); } else { return std::nullopt; } uint8_t version = static_cast(std::stoi(matches[1])); if (step_start > step_end) { return std::nullopt; } StepRange step_range{ datastore::Step{static_cast(step_start)}, datastore::Step{static_cast(step_end)}, }; std::optional sub_dir_name; if (base_dir == path.parent_path()) { sub_dir_name = std::nullopt; } else if (base_dir == path.parent_path().parent_path()) { sub_dir_name = path.parent_path().filename().string(); } else { return std::nullopt; } return SnapshotPath{ std::move(path), std::move(sub_dir_name), filename_format, version, step_range, std::move(tag), }; } SnapshotPath SnapshotPath::make( const fs::path& base_dir, std::optional sub_dir_name, FilenameFormat filename_format, uint8_t version, StepRange step_range, std::string tag, std::string_view ext) { auto path = base_dir; if (sub_dir_name) { path /= *sub_dir_name; } path /= SnapshotPath::make_filename(filename_format, version, step_range, tag, ext); return SnapshotPath{ std::move(path), std::move(sub_dir_name), filename_format, version, step_range, std::move(tag), }; } fs::path SnapshotPath::make_filename( FilenameFormat format, uint8_t version, StepRange step_range, std::string_view tag, std::string_view ext) { switch (format) { case FilenameFormat::kE2: // example: v1-009960-009970-transactions-to-block.idx return absl::StrFormat( "v%d-%06d-%06d-%s%s", version, step_range.start.value, step_range.end.value, tag, ext); case FilenameFormat::kE3: // example: v1-commitment.0-1024.kv return absl::StrFormat( "v%d-%s.%d-%d%s", version, tag, step_range.start.value, step_range.end.value, ext); default: SILKWORM_ASSERT(false); return {}; } } SnapshotPath SnapshotPath::related_path(std::string tag, std::string_view ext) const { return SnapshotPath::make(base_dir_path(), sub_dir_name_, filename_format_, version_, step_range_, std::move(tag), ext); } SnapshotPath::SnapshotPath( fs::path path, std::optional sub_dir_name, FilenameFormat filename_format, uint8_t version, StepRange step_range, std::string tag) : path_{std::move(path)}, sub_dir_name_{std::move(sub_dir_name)}, filename_format_{filename_format}, version_{version}, step_range_{step_range}, tag_{std::move(tag)} { } bool operator<(const SnapshotPath& lhs, const SnapshotPath& rhs) { if (lhs.version_ != rhs.version_) { return lhs.version_ < rhs.version_; } if (lhs.step_range_.start != rhs.step_range_.start) { return lhs.step_range_.start < rhs.step_range_.start; } if (lhs.step_range_.end != rhs.step_range_.end) { return lhs.step_range_.end < rhs.step_range_.end; } if (lhs.tag_ != rhs.tag_) { return lhs.tag_ < rhs.tag_; } return lhs.path_.extension() < rhs.path_.extension(); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/snapshot_path.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "../../common/step.hpp" namespace silkworm::snapshots { //! The snapshot version 1 aka v1 inline constexpr uint8_t kSnapshotV1{1}; class SnapshotPath { public: using StepRange = datastore::StepRange; enum class FilenameFormat { kE2, kE3, }; static std::optional parse(std::filesystem::path path); static std::optional parse( std::filesystem::path path, const std::filesystem::path& base_dir); static SnapshotPath make( const std::filesystem::path& base_dir, std::optional sub_dir_name, FilenameFormat filename_format, uint8_t version, StepRange step_range, std::string tag, std::string_view ext); std::string filename() const { return path_.filename().string(); } const std::filesystem::path& path() const { return path_; } std::filesystem::path base_dir_path() const { auto dir = path_.parent_path(); return sub_dir_name_ ? dir.parent_path() : dir; } const std::optional& sub_dir_name() const { return sub_dir_name_; } std::string extension() const { return path_.extension().string(); } uint8_t version() const { return version_; } StepRange step_range() const { return step_range_; } const std::string& tag() const { return tag_; } bool exists() const { return std::filesystem::exists(path_); } SnapshotPath related_path(std::string tag, std::string_view ext) const; SnapshotPath related_path_ext(std::string_view ext) const { return related_path(tag_, ext); } friend bool operator<(const SnapshotPath& lhs, const SnapshotPath& rhs); friend bool operator==(const SnapshotPath&, const SnapshotPath&) = default; protected: static std::filesystem::path make_filename( FilenameFormat format, uint8_t version, StepRange step_range, std::string_view tag, std::string_view ext); SnapshotPath( std::filesystem::path path, std::optional sub_dir_name, FilenameFormat filename_format, uint8_t version, StepRange step_range, std::string tag); std::filesystem::path path_; std::optional sub_dir_name_; FilenameFormat filename_format_; uint8_t version_{0}; StepRange step_range_; std::string tag_; }; using SnapshotPathList = std::vector; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/snapshot_path_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_path.hpp" #include #include #include namespace silkworm::snapshots { using namespace datastore; TEST_CASE("SnapshotPath::parse", "[silkworm][node][snapshot]") { SECTION("invalid") { static constexpr std::string_view kInvalidFilenames[]{ "", ".segment", ".seg", "u1-014500-015000-headers.seg", "-014500-015000-headers.seg", "1-014500-015000-headers.seg", "v-014500-015000-headers.seg", "v1014500-015000-headers.seg", "v1-0-015000-headers.seg", "v1--015000-headers.seg", "v1-014500015000-headers.seg", "v1-014500-1-headers.seg", "v1-014500-010000-headers.seg", "v1-014500--headers.seg", "v1-014500-01500a-headers.seg", "v1-014500-015000-.seg", "v1-014500-015000-unknown.seg", "v1-014500-015000headers.seg", "v1-014500-015000-headers.seg.seg", }; for (const auto& filename : kInvalidFilenames) { CHECK_NOTHROW(SnapshotPath::parse(filename) == std::nullopt); } } SECTION("valid") { struct TestExample { std::string filename; StepRange expected_range; std::string expected_tag; }; static const TestExample kExamples[]{ {"v1-014500-015000-headers.seg", {Step{14'500}, Step{15'000}}, "headers"}, {"v1-011500-012000-bodies.seg", {Step{11'500}, Step{12'000}}, "bodies"}, {"v1-018300-018400-transactions.seg", {Step{18'300}, Step{18'400}}, "transactions"}, {"v1-018300-018400-transactions-to-block.idx", {Step{18'300}, Step{18'400}}, "transactions-to-block"}, {"v1-commitment.0-1024.kv", {Step{0}, Step{1'024}}, "commitment"}, {"v1-receipt.64-128.ef", {Step{64}, Step{128}}, "receipt"}, {"v1-storage.1672-1673.vi", {Step{1'672}, Step{1'673}}, "storage"}, }; for (const auto& example : kExamples) { const auto path = SnapshotPath::parse(example.filename); REQUIRE(path); CHECK(path->filename() == example.filename); CHECK(path->version() == 1); CHECK(path->step_range() == example.expected_range); CHECK(path->tag() == example.expected_tag); } } SECTION("directory-E2") { auto path = SnapshotPath::parse("/snapshots/v1-001000-002000-headers.seg"); REQUIRE(path); CHECK(path->base_dir_path() == "/snapshots"); CHECK_FALSE(path->sub_dir_name()); } SECTION("directory-E3") { auto path = SnapshotPath::parse("/snapshots/accessor/v1-storage.5-155.vi", "/snapshots"); REQUIRE(path); CHECK(path->base_dir_path() == "/snapshots"); CHECK(path->sub_dir_name() == "accessor"); } } TEST_CASE("SnapshotPath::make", "[silkworm][node][snapshot]") { CHECK( SnapshotPath::make( "/snapshots", std::nullopt, SnapshotPath::FilenameFormat::kE2, kSnapshotV1, StepRange{Step{1'000}, Step{2'000}}, "headers", ".seg") .path() == "/snapshots/v1-001000-002000-headers.seg"); CHECK( SnapshotPath::make( "/snapshots", "accessor", SnapshotPath::FilenameFormat::kE3, kSnapshotV1, StepRange{Step{5}, Step{155}}, "storage", ".vi") .path() == "/snapshots/accessor/v1-storage.5-155.vi"); } TEST_CASE("StepRange invalid") { CHECK_THROWS_AS((StepRange{Step{1'000}, Step{999}}), std::logic_error); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/util/bitmask_operators.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::snapshots { template requires(std::is_enum_v and requires(T e) { enable_bitmask_operator_or(e); }) constexpr auto operator|(const T lhs, const T rhs) { using underlying = std::underlying_type_t; return static_cast(static_cast(lhs) | static_cast(rhs)); } template requires(std::is_enum_v and requires(T e) { enable_bitmask_operator_and(e); }) constexpr auto operator&(const T lhs, const T rhs) { using underlying = std::underlying_type_t; return static_cast(static_cast(lhs) & static_cast(rhs)); } template requires(std::is_enum_v and requires(T e) { enable_bitmask_operator_not(e); }) constexpr auto operator~(const T t) { using underlying = std::underlying_type_t; return static_cast(~static_cast(t)); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/common/util/iterator/index_range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "list_iterator.hpp" namespace silkworm { struct IndexRange { using value_type = size_t; size_t start_index{0}; size_t end_index{0}; size_t size() const { return end_index - start_index; } size_t operator[](size_t i) const { return i; } using Iterator = ListIterator; Iterator begin() const { return Iterator{*this, start_index}; } Iterator end() const { return Iterator{*this, end_index}; } }; static_assert(IndexedListConcept); } // namespace silkworm ================================================ FILE: silkworm/db/datastore/snapshots/common/util/iterator/iterator_read_into_vector.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { template void iterator_read_into(InputIt it, size_t count, std::vector& out) { std::copy_n(std::make_move_iterator(std::move(it)), count, std::back_inserter(out)); } template std::vector iterator_read_into_vector(InputIt it, size_t count) { std::vector out; out.reserve(count); iterator_read_into(std::move(it), count, out); return out; } } // namespace silkworm ================================================ FILE: silkworm/db/datastore/snapshots/common/util/iterator/list_iterator.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { template concept IndexedListConcept = requires(const TList list) { typename TList::value_type; { list.size() } -> std::same_as; requires requires(size_t i) { { list[i] } -> std::convertible_to; }; }; static_assert(IndexedListConcept>); template class ListIterator { public: using value_type = TValue; using iterator_category [[maybe_unused]] = std::random_access_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type; ListIterator() = default; ListIterator(const TList& list, size_t i) : list_{&list}, i_{i} {} reference operator*() const { return (*list_)[i_]; } pointer operator->() const { return &(**this); } ListIterator operator++(int) { return std::exchange(*this, ++ListIterator{*this}); } ListIterator& operator++() { ++i_; return *this; } ListIterator operator--(int) { return std::exchange(*this, --ListIterator{*this}); } ListIterator& operator--() { --i_; return *this; } ListIterator operator+(size_t count) const { return {*list_, i_ + count}; } ListIterator& operator+=(size_t count) { i_ += count; return *this; } friend ListIterator operator+(size_t count, ListIterator it) { return {*it.list_, count + it.i_}; } reference operator[](size_t count) const { return *(*this + count); } ListIterator operator-(size_t count) const { return {*list_, i_ - count}; } ListIterator& operator-=(size_t count) { i_ -= count; return *this; } difference_type operator-(ListIterator other) const { return static_cast(i_) - static_cast(other.i_); } friend bool operator==(const ListIterator& lhs, const ListIterator& rhs) = default; friend bool operator!=(const ListIterator& lhs, const ListIterator& rhs) = default; friend bool operator<(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ < rhs.i_; } friend bool operator<=(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ <= rhs.i_; } friend bool operator>(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ > rhs.i_; } friend bool operator>=(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ >= rhs.i_; } private: const TList* list_{nullptr}; size_t i_{0}; }; static_assert(std::random_access_iterator>>); } // namespace silkworm ================================================ FILE: silkworm/db/datastore/snapshots/common/util/iterator/map_values_view.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::map_values_view::fallback { template class MapValuesView : public std::ranges::view_interface> { public: class Iterator { public: using value_type = TMapValue; using iterator_category [[maybe_unused]] = std::bidirectional_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = const value_type*; using reference = const value_type&; explicit Iterator(typename TMap::const_iterator it) : it_(it) {} Iterator() = default; reference operator*() const { return it_->second; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator operator--(int) { return std::exchange(*this, --Iterator{*this}); } Iterator& operator--() { --it_; return *this; } friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs) = default; private: typename TMap::const_iterator it_; }; static_assert(std::bidirectional_iterator); explicit MapValuesView(const TMap& map) : begin_(Iterator{map.cbegin()}), end_(Iterator{map.cend()}) {} MapValuesView() = default; Iterator begin() const { return begin_; } Iterator end() const { return end_; } private: Iterator begin_; Iterator end_; }; } // namespace silkworm::map_values_view::fallback namespace silkworm::map_values_view::builtin { template using MapValuesView = std::ranges::values_view>; } // namespace silkworm::map_values_view::builtin namespace silkworm { // std::views::values is not present on clang 15 #if defined(__clang__) && (__clang_major__ <= 15) && !defined(__apple_build_version__) using silkworm::map_values_view::fallback::MapValuesView; #elif defined(__clang__) && (__clang_major__ <= 14) && defined(__apple_build_version__) // clang 15 == Apple clang 14 using silkworm::map_values_view::fallback::MapValuesView; #else using silkworm::map_values_view::builtin::MapValuesView; #endif template MapValuesView> make_map_values_view(const std::map& map) { return MapValuesView>{map}; } template MapValuesView> make_map_values_view(const std::unordered_map& map) { return MapValuesView>{map}; } template MapValuesView> make_map_values_view(const absl::flat_hash_map& map) { return MapValuesView>{map}; } template using MapValuesViewReverse = std::ranges::reverse_view>; } // namespace silkworm ================================================ FILE: silkworm/db/datastore/snapshots/config/chains/amoy.hpp ================================================ /* Generated from amoy.toml using Silkworm embed_toml */ #pragma once #include #include #include "../entry.hpp" namespace silkworm::snapshots { using namespace std::literals; inline constexpr std::array kAmoySnapshots{ Entry{"accessor/v1-accounts.0-16.efi"sv, "9f3cdbb8e9613daae877b093278ff01337b31c1d"sv}, Entry{"accessor/v1-accounts.0-16.vi"sv, "016c3a1927b2f12978fb285a5f3a6d0999165c6d"sv}, Entry{"accessor/v1-accounts.16-24.efi"sv, "3a3c48d86500eec06cc09843be187f1fb5943374"sv}, Entry{"accessor/v1-accounts.16-24.vi"sv, "e9d6af13d66750e5ecb9a7f64d5908270a5ac1d3"sv}, Entry{"accessor/v1-accounts.24-28.efi"sv, "5c7dd9163b344b148fce8ddd2253d6f836209325"sv}, Entry{"accessor/v1-accounts.24-28.vi"sv, "ec8b83f58402a165e8a6d3217b0ac979ebb782b8"sv}, Entry{"accessor/v1-code.0-16.efi"sv, "fc93ec0286e0c1838e79c20934ef2282bdd6f72e"sv}, Entry{"accessor/v1-code.0-16.vi"sv, "4e15af92f3ee418ca903e5922698e9e0517aa00e"sv}, Entry{"accessor/v1-code.16-24.efi"sv, "0cc7422b39db9a35a3b85de848383b4fff4d28dc"sv}, Entry{"accessor/v1-code.16-24.vi"sv, "b16f37fd73efebebf421c3c5bcb0ddf812fafe09"sv}, Entry{"accessor/v1-code.24-28.efi"sv, "a7a8ec8026002c2d8ee14d30c529836302d7ce7e"sv}, Entry{"accessor/v1-code.24-28.vi"sv, "1e3504fb6b8ffaf6dacd25098e8957255ef79c4c"sv}, Entry{"accessor/v1-logaddrs.0-16.efi"sv, "bd9320a826224c474ae28b613de8092cf828223e"sv}, Entry{"accessor/v1-logaddrs.16-24.efi"sv, "8c1d03fafd5b82878ca534d715690574c84b865c"sv}, Entry{"accessor/v1-logaddrs.24-28.efi"sv, "0327b108ceea590221b3f0e5e33bf13a121d0032"sv}, Entry{"accessor/v1-logtopics.0-16.efi"sv, "2200921d17bcec63df9b9f7ddf792ab8f99d8160"sv}, Entry{"accessor/v1-logtopics.16-24.efi"sv, "38693b8d6397b7685d41468ccd2ed32b7f06e88f"sv}, Entry{"accessor/v1-logtopics.24-28.efi"sv, "f58731420e6ecda4e9d2ebff87a8c874f34b6c41"sv}, Entry{"accessor/v1-receipt.0-16.efi"sv, "5547c0830a21af61c8eaca9eaeb27dc10ca3be12"sv}, Entry{"accessor/v1-receipt.0-16.vi"sv, "c86ce7ec8adca9df724d759a08a8066e4bcbeccd"sv}, Entry{"accessor/v1-receipt.16-24.efi"sv, "ded0a0d7b5e68ef1a0fca0b19ca12cc31f22c299"sv}, Entry{"accessor/v1-receipt.16-24.vi"sv, "114e95418035709581e9d3b14c3d77c18731e732"sv}, Entry{"accessor/v1-receipt.24-28.efi"sv, "fcd21e96a0abd9a4cf4cc27963b4510c262eefa8"sv}, Entry{"accessor/v1-receipt.24-28.vi"sv, "5a4a10c3d1d6c1b0697890324480123c67ef5522"sv}, Entry{"accessor/v1-storage.0-16.efi"sv, "097cd25b3f2bc2e205342c7a86ad80a56c3881bf"sv}, Entry{"accessor/v1-storage.0-16.vi"sv, "1a6936c78f46d56ee855b6f1224350c5662a5812"sv}, Entry{"accessor/v1-storage.16-24.efi"sv, "044ec7f7ee6889e0b5398f8bad2a2c759e58c5f6"sv}, Entry{"accessor/v1-storage.16-24.vi"sv, "05679527f917b5c2cf4f55a518cd41a93c2bfae4"sv}, Entry{"accessor/v1-storage.24-28.efi"sv, "a6e2e1a0b390d7d313f6111f18edf491c27e422d"sv}, Entry{"accessor/v1-storage.24-28.vi"sv, "594b040b9432ba489f2257b11ed21aa812cc6c04"sv}, Entry{"accessor/v1-tracesfrom.0-16.efi"sv, "02460f8dc654c5fb90d848b832fb9e505f6b6e2e"sv}, Entry{"accessor/v1-tracesfrom.16-24.efi"sv, "0818fe3ee2c6be0532e50388ba5ae47f4a57a1f6"sv}, Entry{"accessor/v1-tracesfrom.24-28.efi"sv, "5d3a033a601441880ccd6210b189c3c77b723dff"sv}, Entry{"accessor/v1-tracesto.0-16.efi"sv, "3a26077a2899a0bcfa485242a40a41ba3227033f"sv}, Entry{"accessor/v1-tracesto.16-24.efi"sv, "e099882f035a9a8f9732e65b9257334448828342"sv}, Entry{"accessor/v1-tracesto.24-28.efi"sv, "1cfe433489d640bc73dbcf4b80eb87087bbb9c39"sv}, Entry{"domain/v1-accounts.0-16.bt"sv, "cf250bde5400c87208a3b159a1a91d6374b34749"sv}, Entry{"domain/v1-accounts.0-16.kv"sv, "989ffe90f2a48604adc576ec88b117ed08587db8"sv}, Entry{"domain/v1-accounts.0-16.kvei"sv, "b34efb4bcc6638c81efb1b0aaee0838ee38d6091"sv}, Entry{"domain/v1-accounts.16-24.bt"sv, "96842d0acb7a86361b43fa93eee4422db786ae88"sv}, Entry{"domain/v1-accounts.16-24.kv"sv, "8bf25550857c8074fe45c8c1c34e13c3f6fa255a"sv}, Entry{"domain/v1-accounts.16-24.kvei"sv, "536f3e02f44478be7590471c07fbb454586a9906"sv}, Entry{"domain/v1-accounts.24-28.bt"sv, "bb03a4d4e1a63fd3667429d5f255d92c676c404c"sv}, Entry{"domain/v1-accounts.24-28.kv"sv, "744a66fd337b7b5daf42fd89de3fcd6606d0ee09"sv}, Entry{"domain/v1-accounts.24-28.kvei"sv, "bb66efb225ba12995b7a5dd73b0b49f78a9f148d"sv}, Entry{"domain/v1-code.0-16.bt"sv, "e2818b8c3c25f074906632186d5faad5dbd81e46"sv}, Entry{"domain/v1-code.0-16.kv"sv, "3ecbf95513316abfc98672b54c5bf883162af83d"sv}, Entry{"domain/v1-code.0-16.kvei"sv, "bd0f34b8f745ab5e3bb6089bf0e1018cc9c9ba1f"sv}, Entry{"domain/v1-code.16-24.bt"sv, "4b1b2fd61a9d402612577ab6782edbcd59cbf1ed"sv}, Entry{"domain/v1-code.16-24.kv"sv, "f5f8ac328f6324d8a2932cf7683b4dd1690c86d7"sv}, Entry{"domain/v1-code.16-24.kvei"sv, "b35a8f58219d6952438c4fa10d314443088063b5"sv}, Entry{"domain/v1-code.24-28.bt"sv, "83636a01bcb44f7c884258121dcd70241d15d847"sv}, Entry{"domain/v1-code.24-28.kv"sv, "3e0b6d8c2af4637c3776bad95b87c20e4d7ee86f"sv}, Entry{"domain/v1-code.24-28.kvei"sv, "5a8dd0fdb77b73ef8727bcdb375e18650da5a072"sv}, Entry{"domain/v1-commitment.0-16.bt"sv, "4de885f7cd1746ae70e824d1028efc450da8c9e0"sv}, Entry{"domain/v1-commitment.0-16.kv"sv, "e876790a399d919c038ff4da3d1984d2fc6a86a0"sv}, Entry{"domain/v1-commitment.0-16.kvei"sv, "faf248564862b7728a3118e1d461fa35dab8c586"sv}, Entry{"domain/v1-commitment.16-24.bt"sv, "8cff91d5562a224c9c89d2e2439443abc29129d0"sv}, Entry{"domain/v1-commitment.16-24.kv"sv, "5af246d13b057412502f2b0ac096fd05638a3659"sv}, Entry{"domain/v1-commitment.16-24.kvei"sv, "525458d95836b0f16388e755627f7955752d51f0"sv}, Entry{"domain/v1-commitment.24-28.bt"sv, "9b8f2c5a61acef8f9c8d7499cc58dae54ead4fa9"sv}, Entry{"domain/v1-commitment.24-28.kv"sv, "d02b2af7214a4bb6bfb03a42eb0ee5135999f4d9"sv}, Entry{"domain/v1-commitment.24-28.kvei"sv, "41c234b94ac583005efb8568371d58c6b2ad4a7e"sv}, Entry{"domain/v1-receipt.0-16.bt"sv, "89bf2c789633bcebcd506f2126dccdaab0f41762"sv}, Entry{"domain/v1-receipt.0-16.kv"sv, "742b05e641b70f10cae023a982f0f7c54de43c3c"sv}, Entry{"domain/v1-receipt.0-16.kvei"sv, "704e6733c70986fa6962687f2f18e1de4779e7fd"sv}, Entry{"domain/v1-receipt.16-24.bt"sv, "7bb4a8eafdcbdfb8fe2a1ddf5cbc3073b17e7ec6"sv}, Entry{"domain/v1-receipt.16-24.kv"sv, "0df470324320ca833422ea1f2b9a7ca96834d292"sv}, Entry{"domain/v1-receipt.16-24.kvei"sv, "1fc38252cda5f553a7c8f914ce7f664cc7dd6a6d"sv}, Entry{"domain/v1-receipt.24-28.bt"sv, "9ab3bce121d7d8d838a864d7fd812e11f1544e84"sv}, Entry{"domain/v1-receipt.24-28.kv"sv, "12949c9b73525e45ea14795287a1cf96785ad3d4"sv}, Entry{"domain/v1-receipt.24-28.kvei"sv, "097b56e50f1a9aa1af185b0b3cfc0a03bad0e6fb"sv}, Entry{"domain/v1-storage.0-16.bt"sv, "b7bf619d18ef1dac6de64faaf4d5871c44a7a766"sv}, Entry{"domain/v1-storage.0-16.kv"sv, "149d7da54efae7f1bc4e82880d9d344ddc7c772b"sv}, Entry{"domain/v1-storage.0-16.kvei"sv, "4b60d5e12299f89f8a8b4afda31867341c28780a"sv}, Entry{"domain/v1-storage.16-24.bt"sv, "e6812d6519e4f5307e589289149f5abbfc17f8d4"sv}, Entry{"domain/v1-storage.16-24.kv"sv, "810341b15a20ec6224ebbf941eb0dc353df344a0"sv}, Entry{"domain/v1-storage.16-24.kvei"sv, "8e79a1c8a4b64b403dd3094adcc8b94036cb828c"sv}, Entry{"domain/v1-storage.24-28.bt"sv, "5c163eeff9c3564e774d41c02b3cd511a3e5ec61"sv}, Entry{"domain/v1-storage.24-28.kv"sv, "1e194d39b61ed549fd717edb4233666ae4596d45"sv}, Entry{"domain/v1-storage.24-28.kvei"sv, "9ae71acc639c32d1e20878c2f851f6b304aa4b80"sv}, Entry{"history/v1-accounts.0-16.v"sv, "950bfacbe354c818fc796b458e22203ba92ce328"sv}, Entry{"history/v1-accounts.16-24.v"sv, "753deb296542bc4129962a4201768c58ed65c991"sv}, Entry{"history/v1-accounts.24-28.v"sv, "d90e89411a6fcc6c9ee9ddc2a977f9d5c788efa8"sv}, Entry{"history/v1-code.0-16.v"sv, "4eff27aa97e840672c0bce230b2a54e9000eea10"sv}, Entry{"history/v1-code.16-24.v"sv, "96057993315b58dd96c14075b7acac53bb19990c"sv}, Entry{"history/v1-code.24-28.v"sv, "61f51e7d44d0defe5369734fe15d681dadb8a83b"sv}, Entry{"history/v1-receipt.0-16.v"sv, "6771379dad89abe82f40e3aa3e5930c3b0a35f61"sv}, Entry{"history/v1-receipt.16-24.v"sv, "c312e44d229fbafec407eeb63c0306390185d2a4"sv}, Entry{"history/v1-receipt.24-28.v"sv, "079350564f93231ee1e03a8186d8c02a0a992e02"sv}, Entry{"history/v1-storage.0-16.v"sv, "fd16fb68241a6a049f711eec2500a05ff94f9113"sv}, Entry{"history/v1-storage.16-24.v"sv, "78334d5493a88288960c48076e826ade1fd9f206"sv}, Entry{"history/v1-storage.24-28.v"sv, "63bacde0ff1b8d098dfc7d94099fdfc27dedb108"sv}, Entry{"idx/v1-accounts.0-16.ef"sv, "b3e89c406772db676a51d81dcfc0fab7c4584bc4"sv}, Entry{"idx/v1-accounts.16-24.ef"sv, "820d55cc81f38749ce06ff82d4eb89db8d48bbb2"sv}, Entry{"idx/v1-accounts.24-28.ef"sv, "fee1f9e3e8690f03a421fb1711f38eda6c33cc4b"sv}, Entry{"idx/v1-code.0-16.ef"sv, "426f3450dd718bd709fb32a75b44bfe9426c163c"sv}, Entry{"idx/v1-code.16-24.ef"sv, "baed48b4d48d9aa9689dbba6db79be08a7a1344a"sv}, Entry{"idx/v1-code.24-28.ef"sv, "c076d98734bef89b81ebf3a3d40cd211b6586dce"sv}, Entry{"idx/v1-logaddrs.0-16.ef"sv, "75b2efd60ce11438473b34ca458c80b2da5a76f0"sv}, Entry{"idx/v1-logaddrs.16-24.ef"sv, "3f947a789bfbfa5c18549f3daf69c927417bf6e1"sv}, Entry{"idx/v1-logaddrs.24-28.ef"sv, "e4e7b2056b97555f3414262d1e22825ae14281d8"sv}, Entry{"idx/v1-logtopics.0-16.ef"sv, "e8e47425f92b3425dd73914e9356fd8cafeb84ad"sv}, Entry{"idx/v1-logtopics.16-24.ef"sv, "81b5479d41a4cbfd939b669eaa3aa45204c26a08"sv}, Entry{"idx/v1-logtopics.24-28.ef"sv, "773dbf5763ff999cdea929ca55242409ae911040"sv}, Entry{"idx/v1-receipt.0-16.ef"sv, "44d307870420a7c8635795e8ada059ec982c784f"sv}, Entry{"idx/v1-receipt.16-24.ef"sv, "50c5b7ac9a3d4c572860735eb3dd21703d7d4f5b"sv}, Entry{"idx/v1-receipt.24-28.ef"sv, "9cb120af389bd2055fe3d35fadef9d8b7fcb3d14"sv}, Entry{"idx/v1-storage.0-16.ef"sv, "b86190eccdd687667d8f8344826cbf26fe571c53"sv}, Entry{"idx/v1-storage.16-24.ef"sv, "a80e87896584b63de4621d9c5bb7ca37f5cfe6b3"sv}, Entry{"idx/v1-storage.24-28.ef"sv, "385520e2d7e0488fcbf8cfda65fa527f7ccd98f9"sv}, Entry{"idx/v1-tracesfrom.0-16.ef"sv, "662cce614ec9e96914c86674774066635c927333"sv}, Entry{"idx/v1-tracesfrom.16-24.ef"sv, "d3a0c3454199f65e300ab2c7f5faf28790c2f9cf"sv}, Entry{"idx/v1-tracesfrom.24-28.ef"sv, "b3d635a54a3e4320b8b2027cd09178e2a843662c"sv}, Entry{"idx/v1-tracesto.0-16.ef"sv, "49de6940aa53b384b6d50c3c67f575d1a63f5192"sv}, Entry{"idx/v1-tracesto.16-24.ef"sv, "21abbb4bd6bb2ff9fa2a66a7debf7229e5c3c937"sv}, Entry{"idx/v1-tracesto.24-28.ef"sv, "484bd9d21129a0344c8c4d9c654e44fc0f22348d"sv}, Entry{"salt-blocks.txt"sv, "ad8707b6e85f95d87a60558ab371b3543d3528e9"sv}, Entry{"salt-state.txt"sv, "0113ec56c7c0d72783dbb5738becffa9c4c43d69"sv}, Entry{"v1-000000-000100-bodies.idx"sv, "f5c7a1d285239d61845b2f79e587aa204d2b59fb"sv}, Entry{"v1-000000-000100-bodies.seg"sv, "9509e8d6aa7f3aca0d034fd2325ba1d6429dc37f"sv}, Entry{"v1-000000-000100-borevents.idx"sv, "2ae198b20da381db293f1326b58765132c1b072c"sv}, Entry{"v1-000000-000100-borevents.seg"sv, "96054c8a3da41bd4d663e6646b13cdb1a4ccfd30"sv}, Entry{"v1-000000-000100-borspans.idx"sv, "0b4d1d53c1e8b710bbe57157e4eff1eb7894d10b"sv}, Entry{"v1-000000-000100-borspans.seg"sv, "f12174da112272d1c708a3720d26b2aff2002240"sv}, Entry{"v1-000000-000100-headers.idx"sv, "e66965b0415a539ec496ee932db1f000f34e4a14"sv}, Entry{"v1-000000-000100-headers.seg"sv, "28699071a613058bb0b9ffc7221d111796f46c63"sv}, Entry{"v1-000000-000100-transactions-to-block.idx"sv, "30258e7096ff480b4348e14a01e09e47f153d284"sv}, Entry{"v1-000000-000100-transactions.idx"sv, "9a4422b2339cdbf3b2a3cf86179cce5ec2909cd5"sv}, Entry{"v1-000000-000100-transactions.seg"sv, "a8a38dc298dea8d791f4b2c6e2634747b81ae709"sv}, Entry{"v1-000100-000200-bodies.idx"sv, "5e21af9819d70b2d80e0b7e68e55c361af17eb0e"sv}, Entry{"v1-000100-000200-bodies.seg"sv, "f7ecd2b80c82144096ff214779c3719157c607b9"sv}, Entry{"v1-000100-000200-borevents.idx"sv, "0b83a7424019eb08d0e6690d4a10ec7a4e83ffb1"sv}, Entry{"v1-000100-000200-borevents.seg"sv, "7a07f4169e3de06f6422cd629789348ec9388b61"sv}, Entry{"v1-000100-000200-borspans.idx"sv, "6b6216e3a5994262f396db43bc5c4f930e9722a3"sv}, Entry{"v1-000100-000200-borspans.seg"sv, "799b5c39cc9f90c0dc46d0c412da24643b9bbf7a"sv}, Entry{"v1-000100-000200-headers.idx"sv, "361181bd7daddb8455c17a72771cc08d97649ff4"sv}, Entry{"v1-000100-000200-headers.seg"sv, "fe3eb2d411391bc8d11d3ba4ab8fb1c210b715be"sv}, Entry{"v1-000100-000200-transactions-to-block.idx"sv, "1b29b001a89efc5e86bdf7025dc6019373cf449b"sv}, Entry{"v1-000100-000200-transactions.idx"sv, "e50150ef258f4ac2e55b470d09371d339447b4f7"sv}, Entry{"v1-000100-000200-transactions.seg"sv, "b59f2482f505e4422602a2b913a12e7393eb6a08"sv}, Entry{"v1-000200-000300-bodies.idx"sv, "92b2b2ceb71757d03fb1f3fa5894890095d5ca86"sv}, Entry{"v1-000200-000300-bodies.seg"sv, "6b93d79d4b0124d07553c9d75101eded72810867"sv}, Entry{"v1-000200-000300-borevents.idx"sv, "3681ea18431ebabc3967bc7ead6bd10ba5f12318"sv}, Entry{"v1-000200-000300-borevents.seg"sv, "42e5ef161725b409ffce3ac87cf8712874b57192"sv}, Entry{"v1-000200-000300-borspans.idx"sv, "425342e5593b0a4b957bca3e891e1c79a36ad05d"sv}, Entry{"v1-000200-000300-borspans.seg"sv, "c245570a4f4beb181669ea643405f52f52f7c6c2"sv}, Entry{"v1-000200-000300-headers.idx"sv, "97cfa34eb1a37886625636815a53b37c98c41902"sv}, Entry{"v1-000200-000300-headers.seg"sv, "914438775fef84fe945cc2e61716aec4f7bbe9e9"sv}, Entry{"v1-000200-000300-transactions-to-block.idx"sv, "84e2b58d39a6321b9e02df8f59ea4f75c9f9e64e"sv}, Entry{"v1-000200-000300-transactions.idx"sv, "e12b9d7c7e13b15d91e918eb473067ff59f49129"sv}, Entry{"v1-000200-000300-transactions.seg"sv, "c43a8e58953a1880a63619c9a6b75a5e2c69b00e"sv}, Entry{"v1-000300-000400-bodies.idx"sv, "306e9c207692ce06acbf814bd0f0dafaa5dcff66"sv}, Entry{"v1-000300-000400-bodies.seg"sv, "bc2c3953a2f0471bd73ca66e1aea832cf37fc6c9"sv}, Entry{"v1-000300-000400-borevents.idx"sv, "b9954d191022244f763d207e093f98c72e9f45ab"sv}, Entry{"v1-000300-000400-borevents.seg"sv, "bd35c22eeb17d4c5c955d439a9321485108d53e6"sv}, Entry{"v1-000300-000400-borspans.idx"sv, "20f0306ac7442eeabb64fe40fd096ea20c324172"sv}, Entry{"v1-000300-000400-borspans.seg"sv, "2b5e5d103511c7e31ed5506e36cfbe82b2dd98ca"sv}, Entry{"v1-000300-000400-headers.idx"sv, "d8de523d615957fee7997e59fb3338780b0d8d41"sv}, Entry{"v1-000300-000400-headers.seg"sv, "ea90b92e5d3c899a156a2f589d76208ca43121ad"sv}, Entry{"v1-000300-000400-transactions-to-block.idx"sv, "33685f7c28c20d19c5e80bac7c31008d70987616"sv}, Entry{"v1-000300-000400-transactions.idx"sv, "791147f853a6fc9a4f469ebc9d2a695050cfc0a2"sv}, Entry{"v1-000300-000400-transactions.seg"sv, "396ffa0ea2870fa0d637c870b3b5f81d935bc3eb"sv}, Entry{"v1-000400-000500-bodies.idx"sv, "273ff9ad9a06d0270e84c5b2ff3b050699552e09"sv}, Entry{"v1-000400-000500-bodies.seg"sv, "34b3e58c7470b4271617fa1c587477e82ffdcd04"sv}, Entry{"v1-000400-000500-borevents.idx"sv, "6b9ed14ae1bd98d369dc88cce13d30c4836dbb35"sv}, Entry{"v1-000400-000500-borevents.seg"sv, "b86372cf3b9e5a02d5df5c8112faf629c06b2fc1"sv}, Entry{"v1-000400-000500-borspans.idx"sv, "6174a519a08c1ff0e051a6d13fe9ffc2cd463cad"sv}, Entry{"v1-000400-000500-borspans.seg"sv, "3ce4b444f729fa9ee6c929af387fd2530df00b45"sv}, Entry{"v1-000400-000500-headers.idx"sv, "f40ff1efca816b98e3077b4eefd831961bcf55e0"sv}, Entry{"v1-000400-000500-headers.seg"sv, "43aacbfda8a6140bba7f25a0a17e5f85102a2da7"sv}, Entry{"v1-000400-000500-transactions-to-block.idx"sv, "5515740a15757f8e727dba766a9652a771de241f"sv}, Entry{"v1-000400-000500-transactions.idx"sv, "30b79a99177e3fb04aedf3fd25ebce0deaeb43aa"sv}, Entry{"v1-000400-000500-transactions.seg"sv, "8dd3d6362870b4ff8c5695721d04478c0d09d5c0"sv}, Entry{"v1-000500-000600-bodies.idx"sv, "d2d536f339307bb185253ac43a981863ec95e95e"sv}, Entry{"v1-000500-000600-bodies.seg"sv, "f78261c3b0f4c9c03133b0b347aff690bae2c45a"sv}, Entry{"v1-000500-000600-borevents.idx"sv, "96d4be94817ffa681f3fa7cb1cc23904a58c08d5"sv}, Entry{"v1-000500-000600-borevents.seg"sv, "93137cbb5db32ea49b5c82bf9d2e08180c4efbb4"sv}, Entry{"v1-000500-000600-borspans.idx"sv, "e5cc8a5f1c3fac62e770230cb87f33c4da80d238"sv}, Entry{"v1-000500-000600-borspans.seg"sv, "5955abe9d74dad3be06f155ba42db28e7cfa8789"sv}, Entry{"v1-000500-000600-headers.idx"sv, "93ad6def2e83f305f6d2ace3c8d45fe38ab22e51"sv}, Entry{"v1-000500-000600-headers.seg"sv, "ccb65651d0b4c978853d3f19635d63716b924a18"sv}, Entry{"v1-000500-000600-transactions-to-block.idx"sv, "62490bd9293d0aac509bc7c51f7cf6fdd7de7baf"sv}, Entry{"v1-000500-000600-transactions.idx"sv, "7a4172e9d5de45af61604990e4a16c813f211b99"sv}, Entry{"v1-000500-000600-transactions.seg"sv, "c04951e966e5df6e4ebca2a96afa8b9d6b5dc3b0"sv}, Entry{"v1-000600-000700-bodies.idx"sv, "36ef4c6091e02fb34b1231366b214597befb78db"sv}, Entry{"v1-000600-000700-bodies.seg"sv, "12e6128da443be0be4e4e5d106c59d1cf11dcf6a"sv}, Entry{"v1-000600-000700-borevents.idx"sv, "f39a8b21909527d2842d3cb7a9f2d91119fa9f4a"sv}, Entry{"v1-000600-000700-borevents.seg"sv, "83802f9e5e940cd66b72ea15d34b80fe5e070090"sv}, Entry{"v1-000600-000700-borspans.idx"sv, "da4ccd1c738a113f6a8bc93a69f3284efbad479e"sv}, Entry{"v1-000600-000700-borspans.seg"sv, "e7b58a946177a4da30820961b543bcf945b83790"sv}, Entry{"v1-000600-000700-headers.idx"sv, "72cba1e0b8b5fbe6709edf614b44b32e29e9fdcf"sv}, Entry{"v1-000600-000700-headers.seg"sv, "54592ccb4051d547532a677949f1c846e03b8e81"sv}, Entry{"v1-000600-000700-transactions-to-block.idx"sv, "43a117cc13887bde12a9b439586f2e1cc33d95ea"sv}, Entry{"v1-000600-000700-transactions.idx"sv, "541b720827b296273923b2212401e56baf2bfa6c"sv}, Entry{"v1-000600-000700-transactions.seg"sv, "a706d8c7dfebd688e44ce5ec7de2b9b6f1c58c55"sv}, Entry{"v1-000700-000800-bodies.idx"sv, "edd0b627ba09c154bdac1c68dc2290e7247b5f94"sv}, Entry{"v1-000700-000800-bodies.seg"sv, "20c284dfd409b624f9a02dab20a176e34375e478"sv}, Entry{"v1-000700-000800-borevents.idx"sv, "df5a6d7cde5d2c57120a649dad4a7d933c2dfdef"sv}, Entry{"v1-000700-000800-borevents.seg"sv, "9c79881d18a1e35aecf979a5d3fe3b5398df2a9e"sv}, Entry{"v1-000700-000800-borspans.idx"sv, "fbf2e583b0aa9b8a60936cfe863f4f7657fe3cb5"sv}, Entry{"v1-000700-000800-borspans.seg"sv, "caabe12f49ecd6b05ea52feb5c88a5487763f21b"sv}, Entry{"v1-000700-000800-headers.idx"sv, "4fc0a7146d8e673116a40aad07b0cd90a9704e1e"sv}, Entry{"v1-000700-000800-headers.seg"sv, "74477b9086d74943bcd3afc9e7938920b1ca02d2"sv}, Entry{"v1-000700-000800-transactions-to-block.idx"sv, "67dd00b9ab52ca4ee9bbb71ec14130216a560263"sv}, Entry{"v1-000700-000800-transactions.idx"sv, "7983f197a3b89463f79d92c3e70561a9b6d8a3c4"sv}, Entry{"v1-000700-000800-transactions.seg"sv, "6f42b6456d54a66dfdcb0ee51ce87e0e872fdf26"sv}, Entry{"v1-000800-000900-bodies.idx"sv, "4f3aaa714deb1e19ba0ba6b3727663368d1f8f70"sv}, Entry{"v1-000800-000900-bodies.seg"sv, "ea123986841a7efed740498c4db3b150e1168cae"sv}, Entry{"v1-000800-000900-borevents.idx"sv, "1c3aaaf44bff081839489a9f8423ae14da0c33b3"sv}, Entry{"v1-000800-000900-borevents.seg"sv, "d536746bc144b26d3011b72df48dbdad2155eb7a"sv}, Entry{"v1-000800-000900-borspans.idx"sv, "673bb995687b4ddf9afe048aa04ad0b32cc277ba"sv}, Entry{"v1-000800-000900-borspans.seg"sv, "a28640bc485367148e49b4e333eabd215d2b9ef7"sv}, Entry{"v1-000800-000900-headers.idx"sv, "2aec6315ec0d416b830ba4d3367fbaab5f206b70"sv}, Entry{"v1-000800-000900-headers.seg"sv, "5ed1040eee959192c10746228f25c8876abd8dc2"sv}, Entry{"v1-000800-000900-transactions-to-block.idx"sv, "32f0864adae8f468eacf85b0a4ccc7b44afa0bc0"sv}, Entry{"v1-000800-000900-transactions.idx"sv, "f1e7114aeeb140fa65a602766613c8a0ab279e30"sv}, Entry{"v1-000800-000900-transactions.seg"sv, "147a7147ff2366193767f1fb8d88a29bd78d2b24"sv}, Entry{"v1-000900-001000-bodies.idx"sv, "20b10cae845d6697c79e29edc6a24e0d65017741"sv}, Entry{"v1-000900-001000-bodies.seg"sv, "5480782cdf522f13d1ead6955463287d8c290858"sv}, Entry{"v1-000900-001000-borevents.idx"sv, "d19b4e036663ad25ba54d7d2f812f1f2228d9c79"sv}, Entry{"v1-000900-001000-borevents.seg"sv, "ef2491a86ff9573bc03d6b6f41e0055a8837f59e"sv}, Entry{"v1-000900-001000-borspans.idx"sv, "d4f4a388b3dfc9cd3859464575df39598e9d3469"sv}, Entry{"v1-000900-001000-borspans.seg"sv, "75b3a6aba81a501f1762b4e0dd493b493734b1df"sv}, Entry{"v1-000900-001000-headers.idx"sv, "07389adcc825d5ce3ebc650ea80be48313b57ae5"sv}, Entry{"v1-000900-001000-headers.seg"sv, "bb0514bf7362e95887d105a3e4073c3c40ac6075"sv}, Entry{"v1-000900-001000-transactions-to-block.idx"sv, "0eec3eaff0b33d9d6bdcb89775101e3114444601"sv}, Entry{"v1-000900-001000-transactions.idx"sv, "3a1f83fe453302ff4ea4fb96750846faa0e97db4"sv}, Entry{"v1-000900-001000-transactions.seg"sv, "7ab8040bcebb095d36c08a9bde6a1f585a7ca862"sv}, Entry{"v1-001000-001100-bodies.idx"sv, "0c111d5b84114dc023142f923acb75bbf08138c2"sv}, Entry{"v1-001000-001100-bodies.seg"sv, "b05ff8dd6bdd74ab9b9e8f1740a75a903434023d"sv}, Entry{"v1-001000-001100-borevents.idx"sv, "c3afedff6f519df66dd1957ff1b01c9d5e914c92"sv}, Entry{"v1-001000-001100-borevents.seg"sv, "772466fba17fd13d8da6ed4dd3f141f651abcf9a"sv}, Entry{"v1-001000-001100-borspans.idx"sv, "5982825ffcb8e5c824dcddf7cca5a54e0a6f8b24"sv}, Entry{"v1-001000-001100-borspans.seg"sv, "a3afa5d595167a4b769f4594c6dddc7d3667e89e"sv}, Entry{"v1-001000-001100-headers.idx"sv, "85070dd6c59634aa56e20f41ff5da7c0d82894d6"sv}, Entry{"v1-001000-001100-headers.seg"sv, "5d3e6d8b003c94e1cbdc6bef72fdf815401d91ca"sv}, Entry{"v1-001000-001100-transactions-to-block.idx"sv, "07863112b70c06587066ecea04d34e1d562938f6"sv}, Entry{"v1-001000-001100-transactions.idx"sv, "8f74d4c5febd444be9540e52980284c69e2fbca6"sv}, Entry{"v1-001000-001100-transactions.seg"sv, "c60f1f77e2716c0f7849d169a65b2853b617695b"sv}, Entry{"v1-001100-001200-bodies.idx"sv, "697528c398b82aad875ac1ee630e6a77b32456f3"sv}, Entry{"v1-001100-001200-bodies.seg"sv, "bdfac800ef4c8e672d1658685602a4c585d85395"sv}, Entry{"v1-001100-001200-borevents.idx"sv, "5decfe971a474dddcf3efe9d68cd0f16f12a85ea"sv}, Entry{"v1-001100-001200-borevents.seg"sv, "243d96298544a078d10d3d5873038780cde644ac"sv}, Entry{"v1-001100-001200-borspans.idx"sv, "9c31597dfabd25735daa6bbce09eb5d765d2a5dc"sv}, Entry{"v1-001100-001200-borspans.seg"sv, "253811276e505e3753d9382575d3e3e3c8166dad"sv}, Entry{"v1-001100-001200-headers.idx"sv, "b63009a4c544b47941cb41d41e340896fdc219bb"sv}, Entry{"v1-001100-001200-headers.seg"sv, "bab0832329948f477cc419e8a59615abcdd38d59"sv}, Entry{"v1-001100-001200-transactions-to-block.idx"sv, "fa4bbb014f337b849124ca509eed2271b59562ef"sv}, Entry{"v1-001100-001200-transactions.idx"sv, "9cbee08ea31d0402e9144072482e9b652c779150"sv}, Entry{"v1-001100-001200-transactions.seg"sv, "5a0961b3bc27cc912815a011b4bbc305ce161762"sv}, Entry{"v1-001200-001300-bodies.idx"sv, "e8c89580fe7c3f9275f316253286a1eaea88ee78"sv}, Entry{"v1-001200-001300-bodies.seg"sv, "fed939350d64e144aaf00591d51d55397bea919f"sv}, Entry{"v1-001200-001300-borevents.idx"sv, "c9cfd4bfd0db98c34ae19913dd14e61b44fdc4cd"sv}, Entry{"v1-001200-001300-borevents.seg"sv, "20155923fd6bbe5feef8645b7ff664168fdbcae2"sv}, Entry{"v1-001200-001300-borspans.idx"sv, "680292e50083a39bb21cac7d0c5386dc25d99684"sv}, Entry{"v1-001200-001300-borspans.seg"sv, "343267a64b219ba334d1ef0c1a89c84a11d0afaf"sv}, Entry{"v1-001200-001300-headers.idx"sv, "bb2aaac1c0d49bbb4eacc53eadab9f4f271a5732"sv}, Entry{"v1-001200-001300-headers.seg"sv, "d48368f506298e8329e8dbbedc3076bcf3ac9e3d"sv}, Entry{"v1-001200-001300-transactions-to-block.idx"sv, "26a0664e485be47a25badcc1312d9957438174f8"sv}, Entry{"v1-001200-001300-transactions.idx"sv, "8acb4605e8a3b8f52961d07abcfe1cae6ec619c5"sv}, Entry{"v1-001200-001300-transactions.seg"sv, "31701ffb1395c447eae9389b38656fc67d42d42f"sv}, Entry{"v1-001300-001400-bodies.idx"sv, "105e058de5cc8e992176e8b6e2abaddac6ad31eb"sv}, Entry{"v1-001300-001400-bodies.seg"sv, "32b78aa890059f2001631455acb2144b28002f93"sv}, Entry{"v1-001300-001400-borevents.idx"sv, "66efd867a23f709ad63bc189d880d03d74187f7f"sv}, Entry{"v1-001300-001400-borevents.seg"sv, "1a10176cba07c4b41507724db5582e625364efa3"sv}, Entry{"v1-001300-001400-borspans.idx"sv, "9aec5671f6c868eb751cc3fa73811df2c530f632"sv}, Entry{"v1-001300-001400-borspans.seg"sv, "139110557b502f13277df8e734682c24da45dc6f"sv}, Entry{"v1-001300-001400-headers.idx"sv, "2b6c9900c7fff027b861ac7f1afb94ac2e2acc2e"sv}, Entry{"v1-001300-001400-headers.seg"sv, "c4f5f20988fbe9c0f0f469750087b17c02d4c9b0"sv}, Entry{"v1-001300-001400-transactions-to-block.idx"sv, "9c9b6ef56833e292820dcd46bea831fbbc624205"sv}, Entry{"v1-001300-001400-transactions.idx"sv, "6cfa5b7702906f2a5bdaed0b8101dbdfd147ff5f"sv}, Entry{"v1-001300-001400-transactions.seg"sv, "c3f306f43c7c907cf6b656606b14532b2097e22a"sv}, Entry{"v1-001400-001500-bodies.idx"sv, "815151a0b152dd405995053ece6e105b6f538356"sv}, Entry{"v1-001400-001500-bodies.seg"sv, "709e4f75dcddc81ab416f4b3a2145f9b3872b5c2"sv}, Entry{"v1-001400-001500-borevents.idx"sv, "b396d1aaaa6c7fb07b842f7290cc5e070fc19c9c"sv}, Entry{"v1-001400-001500-borevents.seg"sv, "542a6e33a576c1258f42e204c34cd9306bb2f5ef"sv}, Entry{"v1-001400-001500-borspans.idx"sv, "d0cd2be6632c189da2b28bf7f74e6efa40af4db8"sv}, Entry{"v1-001400-001500-borspans.seg"sv, "be961e4cf8f060261a0536b091e6f32a973bbe57"sv}, Entry{"v1-001400-001500-headers.idx"sv, "f08ec4142ed696d684b27eb4a3c93c0ef855f45d"sv}, Entry{"v1-001400-001500-headers.seg"sv, "dbd953e0e8d281d320c8adc0fa1cbf738ad55950"sv}, Entry{"v1-001400-001500-transactions-to-block.idx"sv, "2629e4cb54ee99c7d38672fe1c13d72fb72c49ea"sv}, Entry{"v1-001400-001500-transactions.idx"sv, "57f859e4fb53cb0d373905b30af34a10a0d5987a"sv}, Entry{"v1-001400-001500-transactions.seg"sv, "982789067a5c0c8d277e0915cded07b0f387756c"sv}, Entry{"v1-001500-001600-bodies.idx"sv, "2a539b0a62a3c405c15514bd0c4e929c58e4c55a"sv}, Entry{"v1-001500-001600-bodies.seg"sv, "6f0c9da60693241d720cbc0b4e1d92e65c3a0185"sv}, Entry{"v1-001500-001600-borevents.idx"sv, "e739af60ee5eb54bf82ecf129a44d95a6c4aed9d"sv}, Entry{"v1-001500-001600-borevents.seg"sv, "235ea149d38f20377255ba0e3f85ed2332af1f91"sv}, Entry{"v1-001500-001600-borspans.idx"sv, "c6a803bc7c216a04dd8aef751a4a48a895594325"sv}, Entry{"v1-001500-001600-borspans.seg"sv, "888bd618ec1f7587acdbf40fbad07e4f3cfe77fb"sv}, Entry{"v1-001500-001600-headers.idx"sv, "8bc9758a51af27e79787f169963404df51696a11"sv}, Entry{"v1-001500-001600-headers.seg"sv, "8a380d956addde8c29fbe0c41e660a3d9ff23da5"sv}, Entry{"v1-001500-001600-transactions-to-block.idx"sv, "8a183b9f53fe575954814e6cb1b5662d04f0d61b"sv}, Entry{"v1-001500-001600-transactions.idx"sv, "638e5431a58c5044852ad2b1e5be00404f7ec03f"sv}, Entry{"v1-001500-001600-transactions.seg"sv, "dcab9e14f08e11fb45def9de05113f4b098a88f8"sv}, Entry{"v1-001600-001700-bodies.idx"sv, "784c2fc29f70ba99aaf07cec495efaf6e0518345"sv}, Entry{"v1-001600-001700-bodies.seg"sv, "cd23265f77c27204c41f74628279d7420785d118"sv}, Entry{"v1-001600-001700-borevents.idx"sv, "11c41f2b3af793807f1c75938b17fcc02d19f386"sv}, Entry{"v1-001600-001700-borevents.seg"sv, "abdb76e6afb892d83b16c0ecb5651fa6c8d3c35d"sv}, Entry{"v1-001600-001700-borspans.idx"sv, "d45352e195addd1f6160fab8e75254a401cd3fdd"sv}, Entry{"v1-001600-001700-borspans.seg"sv, "f209177d8e1a9fe5337fde8d322188ac4f54736a"sv}, Entry{"v1-001600-001700-headers.idx"sv, "4a04956178478ede11d3edd51ba9a3319d2d592d"sv}, Entry{"v1-001600-001700-headers.seg"sv, "d491837a51bf04d25499be16b24727f628a6890a"sv}, Entry{"v1-001600-001700-transactions-to-block.idx"sv, "d34ee8a8d8247c575fd7ccc5680085ef4cf92886"sv}, Entry{"v1-001600-001700-transactions.idx"sv, "4c7f164a45fefe4d0fd897b0b533680e1249e800"sv}, Entry{"v1-001600-001700-transactions.seg"sv, "2f9b6cb7148527259ddacfe13f6c8c2d9f7bd4da"sv}, Entry{"v1-001700-001800-bodies.idx"sv, "5eb0608128d385566ecfdbc4222bb32be907d0c5"sv}, Entry{"v1-001700-001800-bodies.seg"sv, "7179926dc2d8b33e02626ab2377712d4d2ad18cf"sv}, Entry{"v1-001700-001800-borevents.idx"sv, "a989c57ba9332e1e76753f5c8e39ca7b89bd5269"sv}, Entry{"v1-001700-001800-borevents.seg"sv, "39c09355028b791f925db3b7d3f7bfe7fdb225a4"sv}, Entry{"v1-001700-001800-borspans.idx"sv, "dcedc0e24c995dc4eac9f585f9217869eddf58ad"sv}, Entry{"v1-001700-001800-borspans.seg"sv, "a656b69d5b8185b575bf37ba59d6a652197fd5f9"sv}, Entry{"v1-001700-001800-headers.idx"sv, "70b8c836e129a69d71a3559f99aaa83f5db6152c"sv}, Entry{"v1-001700-001800-headers.seg"sv, "69656796294c44ce775eb2a02c471361357750da"sv}, Entry{"v1-001700-001800-transactions-to-block.idx"sv, "1b063658f9bf7b43112de6d09d2df79094ee050d"sv}, Entry{"v1-001700-001800-transactions.idx"sv, "771150a3b3523bd63e3b7477f56b691e1b7f06ad"sv}, Entry{"v1-001700-001800-transactions.seg"sv, "5feb246da89f36e35d0334c28040a1af4f492b83"sv}, Entry{"v1-001800-001900-bodies.idx"sv, "516264f9500eff302c5a9e90a275d34ecd172955"sv}, Entry{"v1-001800-001900-bodies.seg"sv, "53aec9da2f48a15475540ca666d8c4c6494da3df"sv}, Entry{"v1-001800-001900-borevents.idx"sv, "85b1383c8ea07a7144b6d389f4e8b42200152905"sv}, Entry{"v1-001800-001900-borevents.seg"sv, "d2813935239eb3ae6c8e7b03932e9b606881d129"sv}, Entry{"v1-001800-001900-borspans.idx"sv, "b5ab7fc5386759032d90464568ea9e8e761bd262"sv}, Entry{"v1-001800-001900-borspans.seg"sv, "672ef9b7bb899944870829513938a7f85293dde9"sv}, Entry{"v1-001800-001900-headers.idx"sv, "a40caa746b08bd6eef7a1f7940e69a930de60b74"sv}, Entry{"v1-001800-001900-headers.seg"sv, "43394d2cd1c43741a0fba02ebec91347832a26ee"sv}, Entry{"v1-001800-001900-transactions-to-block.idx"sv, "101cdfada3f2c60c2395276c1934ca029fd0fdf5"sv}, Entry{"v1-001800-001900-transactions.idx"sv, "7992e69892fc71679a0bb50d72781f169ba4f51b"sv}, Entry{"v1-001800-001900-transactions.seg"sv, "009b992cb13b48957b768c07f1f4b121dbf36ad2"sv}, Entry{"v1-001900-002000-bodies.idx"sv, "469703aa1247c5ff051d0044bfebbe5046232ab0"sv}, Entry{"v1-001900-002000-bodies.seg"sv, "391dd4b86dd5d3e0d5c2bf724a0b909ecfac9447"sv}, Entry{"v1-001900-002000-borevents.idx"sv, "d231ce05542e89d6b8aecdd704f03efd76a46da2"sv}, Entry{"v1-001900-002000-borevents.seg"sv, "df148605153df9b780b5a0ed00a58f3b1d61f84d"sv}, Entry{"v1-001900-002000-borspans.idx"sv, "cd825398e0da215b93b724921b58749b5b50dbff"sv}, Entry{"v1-001900-002000-borspans.seg"sv, "0df93467d0621334005fd4c7797a596a98c29121"sv}, Entry{"v1-001900-002000-headers.idx"sv, "b8fa8f3b84e459d1e116eccea22e4cdeca91faad"sv}, Entry{"v1-001900-002000-headers.seg"sv, "574a929013f9f0e70c24b161b0aea3c8e8f9ccd0"sv}, Entry{"v1-001900-002000-transactions-to-block.idx"sv, "95a0652c5f8a5cd6a59f5d2198750e9e8d9ae713"sv}, Entry{"v1-001900-002000-transactions.idx"sv, "9dc93d552d746a73bc688fa84c81690096fb6dcf"sv}, Entry{"v1-001900-002000-transactions.seg"sv, "36bafe953a291e34a7c8ec7f8de85705b013d67d"sv}, Entry{"v1-002000-002100-bodies.idx"sv, "944c27693715b0eafc940131c0d364eb4c2ec665"sv}, Entry{"v1-002000-002100-bodies.seg"sv, "47f9db2911ab3fdb1d03c3b43dd80380be7a21a9"sv}, Entry{"v1-002000-002100-borevents.idx"sv, "8ba3a8d3aca33b0bc82fa674e06555376695f1c3"sv}, Entry{"v1-002000-002100-borevents.seg"sv, "32ab46ff2f9f16d75511b3608d996b578292cf5f"sv}, Entry{"v1-002000-002100-borspans.idx"sv, "cafddfc360bbbcea114ddf19fa2894cce4f5d4b1"sv}, Entry{"v1-002000-002100-borspans.seg"sv, "c192f4f427e2989b97ece121af8ae36c032efdb9"sv}, Entry{"v1-002000-002100-headers.idx"sv, "8ccfc7008bcd189ba8146b315f974edb7289a21b"sv}, Entry{"v1-002000-002100-headers.seg"sv, "1e8034a0819f1be115c8941a19d92a9dd36190b4"sv}, Entry{"v1-002000-002100-transactions-to-block.idx"sv, "eba92cb64a401d7c5f44033c6c8c5707212c04f0"sv}, Entry{"v1-002000-002100-transactions.idx"sv, "25ad91545365ab3dc3657d9044f70b1d737fddc0"sv}, Entry{"v1-002000-002100-transactions.seg"sv, "6858d11ecbecd574aa21a247beb2556cc23211db"sv}, Entry{"v1-002100-002200-bodies.idx"sv, "29eabefb9fea2b41070291cfe887124905b6f697"sv}, Entry{"v1-002100-002200-bodies.seg"sv, "b7c4ae8e461dfaf12e73fc9bc159fbd8e65fbfc0"sv}, Entry{"v1-002100-002200-borevents.idx"sv, "815fb7d8350e98bf8ea2d60a9ae40ceecc308371"sv}, Entry{"v1-002100-002200-borevents.seg"sv, "d7dae5bd8606b879c53c86d341aadb18fb798390"sv}, Entry{"v1-002100-002200-borspans.idx"sv, "0052e198eb1cdc8b0ccb87d32c986341bd1d25ac"sv}, Entry{"v1-002100-002200-borspans.seg"sv, "6129107d9115285186f35b381c33dc3f6cb3281a"sv}, Entry{"v1-002100-002200-headers.idx"sv, "4efc8d7e0fe8f31121b589a66333f9be39e4ccd5"sv}, Entry{"v1-002100-002200-headers.seg"sv, "ffae5cb7b9d23914b175d39bbe69dd66b74fc4bd"sv}, Entry{"v1-002100-002200-transactions-to-block.idx"sv, "8a37d32999fb015ae90d70777acfe8ce6b1aee16"sv}, Entry{"v1-002100-002200-transactions.idx"sv, "ff6da7279677ab6f8cdb58bd63b4820b1f5b063f"sv}, Entry{"v1-002100-002200-transactions.seg"sv, "07eb318236689b63ba436aca099a27d6bfe597cc"sv}, Entry{"v1-002200-002300-bodies.idx"sv, "b45be1146a4c61d6086da95fec30c54557a40660"sv}, Entry{"v1-002200-002300-bodies.seg"sv, "0b20b572a9cb9d8b7909cc796535935912d3bd9c"sv}, Entry{"v1-002200-002300-borevents.idx"sv, "9df4c8aa67d16334d1ab1d34a6ea357675aef0a7"sv}, Entry{"v1-002200-002300-borevents.seg"sv, "e5ea29208eabce0dd6571b1b55ff00385682b4a7"sv}, Entry{"v1-002200-002300-borspans.idx"sv, "495bd04a6f2d4de89ab3ea903b39340de0f2eac8"sv}, Entry{"v1-002200-002300-borspans.seg"sv, "185362665aae8fd81a22b6cfb2f357f61540a810"sv}, Entry{"v1-002200-002300-headers.idx"sv, "e4d0c5972afaa93d4f5d56e35a287b1a8a8a26ee"sv}, Entry{"v1-002200-002300-headers.seg"sv, "0d5b34ce21de6d86d329b9a09475b51a32462ff9"sv}, Entry{"v1-002200-002300-transactions-to-block.idx"sv, "f3df85a72843d504e3b500b34ab961a571ce41ad"sv}, Entry{"v1-002200-002300-transactions.idx"sv, "a01454590f033cc04c5984a59804e8784052cdcc"sv}, Entry{"v1-002200-002300-transactions.seg"sv, "df3aed35422147d59cdbf6d6171d4bf4127c7388"sv}, Entry{"v1-002300-002400-bodies.idx"sv, "2bd1a4910b2a8b30667b86b4463f6c20bd1b6f45"sv}, Entry{"v1-002300-002400-bodies.seg"sv, "86691d764bdc60cedf068e6a870a270ce8a49707"sv}, Entry{"v1-002300-002400-borevents.idx"sv, "aac9b876c30bb4d5feb381055a6fa8914d7f347e"sv}, Entry{"v1-002300-002400-borevents.seg"sv, "400751f5cfea0483086d7495a54c48ef9c0f0e31"sv}, Entry{"v1-002300-002400-borspans.idx"sv, "538993cead1824610a6abb88103443528d95793f"sv}, Entry{"v1-002300-002400-borspans.seg"sv, "1703f04a38753bb1a9ecdc5c6f5b778e555e579a"sv}, Entry{"v1-002300-002400-headers.idx"sv, "a92a9853fb674de1ffd3a560cfc7398015f46255"sv}, Entry{"v1-002300-002400-headers.seg"sv, "da4fdb7b590d204f612d2a0dd66e3832439516f3"sv}, Entry{"v1-002300-002400-transactions-to-block.idx"sv, "ceedbc10a6d74ef257276285300847beb2929754"sv}, Entry{"v1-002300-002400-transactions.idx"sv, "b56ec6f3e20b41559f72c2c97cc9b9e761f58354"sv}, Entry{"v1-002300-002400-transactions.seg"sv, "2db42b734dce5705900fa291649ec888e9fb49d0"sv}, Entry{"v1-002400-002500-bodies.idx"sv, "fd4d694ec0299e5a8eec657431766298ac759ae2"sv}, Entry{"v1-002400-002500-bodies.seg"sv, "fd655d40e82282c8f2cc915fff00be47473ffedc"sv}, Entry{"v1-002400-002500-borevents.idx"sv, "b92c9818f04cfc34d97d3cd0042ef2fd409483e3"sv}, Entry{"v1-002400-002500-borevents.seg"sv, "e5ab25e5522f752b2c9f60d473e1cb24d0f8a626"sv}, Entry{"v1-002400-002500-borspans.idx"sv, "2a7d061174ce562749a05f20cccec2f7bc5b7874"sv}, Entry{"v1-002400-002500-borspans.seg"sv, "243916c7611b2e6dc12a1924334f0327c5fb2499"sv}, Entry{"v1-002400-002500-headers.idx"sv, "6ec9ae8902a6f04853d08360ccb7f8f08f99a7c0"sv}, Entry{"v1-002400-002500-headers.seg"sv, "7ee34f4e04c523917146b757eadb887894362615"sv}, Entry{"v1-002400-002500-transactions-to-block.idx"sv, "ee90951cccd47eff657d1a5daba5e0db73577ac7"sv}, Entry{"v1-002400-002500-transactions.idx"sv, "60fa70f29e55f9b2b9fb110c21f4518ef585402b"sv}, Entry{"v1-002400-002500-transactions.seg"sv, "be9dc49a2dc3b700e76db21de7cb2e6f8ed59783"sv}, Entry{"v1-002500-002600-bodies.idx"sv, "fbc8e650b8f8a784d25068959e1ef009c9e7382f"sv}, Entry{"v1-002500-002600-bodies.seg"sv, "ed9754525be8391e27618f67deef1c87d5896580"sv}, Entry{"v1-002500-002600-borevents.idx"sv, "89dce03b37f144e52e26185d0b33322635fdbb20"sv}, Entry{"v1-002500-002600-borevents.seg"sv, "d3218bae3a7ab4e3e15339c326d545ce7005bc00"sv}, Entry{"v1-002500-002600-borspans.idx"sv, "62df775d4714ceef458655388b70d6361386607b"sv}, Entry{"v1-002500-002600-borspans.seg"sv, "159486b13fae9147ef058fe48f905dae41d78bd7"sv}, Entry{"v1-002500-002600-headers.idx"sv, "5316a4af93b8c9253dce692a46f40e1312f75d69"sv}, Entry{"v1-002500-002600-headers.seg"sv, "1ecaa4a49a7f677a506a3bac297655678b277b7c"sv}, Entry{"v1-002500-002600-transactions-to-block.idx"sv, "3f70b2cb79a2a4f756abd1ada2233b968934d7fd"sv}, Entry{"v1-002500-002600-transactions.idx"sv, "40b9b58ddd935519cb283f4b2747661a114d789f"sv}, Entry{"v1-002500-002600-transactions.seg"sv, "83e4977817f493d995b6acb1ae797488b4d4e065"sv}, Entry{"v1-002600-002700-bodies.idx"sv, "d5867ca949ae15afe19df1bc8a217f9ee0ee20bb"sv}, Entry{"v1-002600-002700-bodies.seg"sv, "3382de5dff761ff55626e67a65f9b6b881eb3833"sv}, Entry{"v1-002600-002700-borevents.idx"sv, "8546775bf4ba7d71a03cb453f3b5374172a7f3ca"sv}, Entry{"v1-002600-002700-borevents.seg"sv, "7682c82e4653c26afa990a4ccb7e632d3ac0c7ef"sv}, Entry{"v1-002600-002700-borspans.idx"sv, "cd9e9f6e9b1b977000ef259f43ed47a5d74daacd"sv}, Entry{"v1-002600-002700-borspans.seg"sv, "33fadc2441e8f89daa1ae1d66601c30288f77e1a"sv}, Entry{"v1-002600-002700-headers.idx"sv, "08f2f2ba47b7377790501b7e3dd1e5e1e94f28dc"sv}, Entry{"v1-002600-002700-headers.seg"sv, "e39d50c0735eaf8601cfd3c3777f27792d913e70"sv}, Entry{"v1-002600-002700-transactions-to-block.idx"sv, "8c6908358840a320ee4e5394d960061a46d5e5ca"sv}, Entry{"v1-002600-002700-transactions.idx"sv, "6e52919cb672a6ba3b68b36dee4b8afcc3130946"sv}, Entry{"v1-002600-002700-transactions.seg"sv, "15a1ca7fa2543aec676fd51072ce020e10ab3663"sv}, Entry{"v1-002700-002800-bodies.idx"sv, "b2c9079ee8fe7e8d61cec72e31d9a1b7c7acb3cb"sv}, Entry{"v1-002700-002800-bodies.seg"sv, "ead2e16afd92f4366c3bad9a69c537660c65c1cf"sv}, Entry{"v1-002700-002800-borevents.idx"sv, "6e21df42a74d96b2d7df32a2c2ff38d5baead8a3"sv}, Entry{"v1-002700-002800-borevents.seg"sv, "b2210d08785ca3cef3ed338a1176174cf8044b1a"sv}, Entry{"v1-002700-002800-borspans.idx"sv, "320e44c620fb9ff465d223c62f62b1bf3939b616"sv}, Entry{"v1-002700-002800-borspans.seg"sv, "188622e94f214a4c60bd0487111f3b6449098867"sv}, Entry{"v1-002700-002800-headers.idx"sv, "7231fe2e84bfafbf2e8d5e87de94030281fe9712"sv}, Entry{"v1-002700-002800-headers.seg"sv, "8ded42a82e8f835a470567d22a680252fd5699da"sv}, Entry{"v1-002700-002800-transactions-to-block.idx"sv, "237eee142bed50b555c4ab1c509ac0a909c58b5f"sv}, Entry{"v1-002700-002800-transactions.idx"sv, "645ef5c0593fbf0bb99bc42fda8726aed5d3d58c"sv}, Entry{"v1-002700-002800-transactions.seg"sv, "723bb71ed4d65e8ee7075475539bb94f0fe5ea6d"sv}, Entry{"v1-002800-002900-bodies.idx"sv, "bd23fac0bb60f632dfa6df5747da2f2690842b1e"sv}, Entry{"v1-002800-002900-bodies.seg"sv, "eb70855aedbbb2e272514dc025890bac1b7911ff"sv}, Entry{"v1-002800-002900-borevents.idx"sv, "ad37e25e10972b1ea53f3f6dd4e2d8ac1d899556"sv}, Entry{"v1-002800-002900-borevents.seg"sv, "5de65558026affd46490677edade677083a3357e"sv}, Entry{"v1-002800-002900-borspans.idx"sv, "02bee919b1972c561f488e12e02ab0503bfd03be"sv}, Entry{"v1-002800-002900-borspans.seg"sv, "56efbb2083d921d9c25675d6523d9231dd804829"sv}, Entry{"v1-002800-002900-headers.idx"sv, "3d805589ee97a4846825ff36d2f05ad43b1ae9e5"sv}, Entry{"v1-002800-002900-headers.seg"sv, "7af7033971252557aab88864417a419600632fae"sv}, Entry{"v1-002800-002900-transactions-to-block.idx"sv, "fe1b590ced9d1761b684096332a8211c3b614040"sv}, Entry{"v1-002800-002900-transactions.idx"sv, "02227b6f54db449c202242b7a151dca56540c03f"sv}, Entry{"v1-002800-002900-transactions.seg"sv, "f3ae4c959924213a66f450b3ea24708da4a63326"sv}, Entry{"v1-002900-003000-bodies.idx"sv, "f5c4f08cdcb82eb177e8068e149952b15a487b7c"sv}, Entry{"v1-002900-003000-bodies.seg"sv, "f32ac55fba5668e1f00ca099ec6afcc1286db0c0"sv}, Entry{"v1-002900-003000-borevents.idx"sv, "a758ba38b630beb50847cd571e8df60b8015bea1"sv}, Entry{"v1-002900-003000-borevents.seg"sv, "658286cbe38e00a10ac3d0e0336cfe940c1aebd8"sv}, Entry{"v1-002900-003000-borspans.idx"sv, "6ca0bdedc0b274e3b7fb547844a3e32f1c3d7ab9"sv}, Entry{"v1-002900-003000-borspans.seg"sv, "85dd13b1a9cf7e11b035dc3f6273e8618d4e0a88"sv}, Entry{"v1-002900-003000-headers.idx"sv, "9efd75345153d0c47f18db2db168abcb0818ffa1"sv}, Entry{"v1-002900-003000-headers.seg"sv, "ce911a0a6a36ca954b1219a6c10f20a0e56831c2"sv}, Entry{"v1-002900-003000-transactions-to-block.idx"sv, "8384ba949f097022027c5965a4206ee10bd99a5a"sv}, Entry{"v1-002900-003000-transactions.idx"sv, "ee3da75839d9bc2cec8f35afbad3a7e54764a312"sv}, Entry{"v1-002900-003000-transactions.seg"sv, "adbec4d1f0558c575f8bce3764ae19728abd4c50"sv}, Entry{"v1-003000-003100-bodies.idx"sv, "41a75de5c3b899c562e4816c981d1d73e7f9ad83"sv}, Entry{"v1-003000-003100-bodies.seg"sv, "e8d53c9dcf66bc801f24068e6e1932f9b97a47cc"sv}, Entry{"v1-003000-003100-borevents.idx"sv, "9ca5c2e7c947250362f66e84799fa92956532271"sv}, Entry{"v1-003000-003100-borevents.seg"sv, "df4b996a7c298c71f5119e5b48ba4f46c93d9476"sv}, Entry{"v1-003000-003100-borspans.idx"sv, "fa9549c78a0158425cf4c5e967a6af3c6d50fd3b"sv}, Entry{"v1-003000-003100-borspans.seg"sv, "6dbf8bc256bdf62ff7985af375590dfe537b7951"sv}, Entry{"v1-003000-003100-headers.idx"sv, "6406c275a8cb98fc7977d8335529d6452dd578df"sv}, Entry{"v1-003000-003100-headers.seg"sv, "356aa6026197097f3fb3476c4eae98e0d75e41e7"sv}, Entry{"v1-003000-003100-transactions-to-block.idx"sv, "ef8f24956d6a80d6e16bc2db436bdeaed519e0c0"sv}, Entry{"v1-003000-003100-transactions.idx"sv, "3e65d168aa76f280eaaceeb12106cca1c4e148c1"sv}, Entry{"v1-003000-003100-transactions.seg"sv, "9a9420b3a36683ee2a5a45c46fcfec79b3d135ac"sv}, Entry{"v1-003100-003200-bodies.idx"sv, "40e3507fa18aa7a3bfdeceef9a0696e36f3fd3ac"sv}, Entry{"v1-003100-003200-bodies.seg"sv, "51c2f79f80c4f39584cb022c3f30f24257cdcd79"sv}, Entry{"v1-003100-003200-borevents.idx"sv, "bbd496703446a13f365e6df2e11ca149f765653b"sv}, Entry{"v1-003100-003200-borevents.seg"sv, "a9359a43b0e566581a070874b09cf371c313983e"sv}, Entry{"v1-003100-003200-borspans.idx"sv, "c85aeb7eff4148f731342569e4753cae5ededa63"sv}, Entry{"v1-003100-003200-borspans.seg"sv, "6d02c1dd011b5be2d857e096f4a29576451637c5"sv}, Entry{"v1-003100-003200-headers.idx"sv, "e9d1a527ba87e2af10348e6dd5f38e0884ec14c0"sv}, Entry{"v1-003100-003200-headers.seg"sv, "74eabd2287d37dde4510bed215c61cc3e3ebaedc"sv}, Entry{"v1-003100-003200-transactions-to-block.idx"sv, "5c145230974dc1bcaf9a25e1a31e8d1485e10295"sv}, Entry{"v1-003100-003200-transactions.idx"sv, "3cf155b48b3b94ef253ec4000705de9f2f9dcad2"sv}, Entry{"v1-003100-003200-transactions.seg"sv, "4bffd312720bb6ee325fdbbfb35c955d80507cc9"sv}, Entry{"v1-003200-003300-bodies.idx"sv, "a63b8f8a08a963f182e0ed28c157f6044998ba00"sv}, Entry{"v1-003200-003300-bodies.seg"sv, "4448443641daedf477ac0b5e6acca8775004a4c0"sv}, Entry{"v1-003200-003300-borevents.idx"sv, "ef628bc31fb30c8aa6b6c8eb5683713d1ee193e1"sv}, Entry{"v1-003200-003300-borevents.seg"sv, "bd50cecf042cd1e6836f8150861279400d5bf009"sv}, Entry{"v1-003200-003300-borspans.idx"sv, "5493dd96d6b70cfc7543c820e36bd8a449f98e4e"sv}, Entry{"v1-003200-003300-borspans.seg"sv, "def748a60b3e81f0af9aa8ef230f0715871c1343"sv}, Entry{"v1-003200-003300-headers.idx"sv, "1252aa6238fc320d1bff446d0855c146a2faad44"sv}, Entry{"v1-003200-003300-headers.seg"sv, "364abeccc85c4a3717804e538357c43b33cc35c9"sv}, Entry{"v1-003200-003300-transactions-to-block.idx"sv, "c6a43d388a720d70b8d540223c1a5bfb773e0906"sv}, Entry{"v1-003200-003300-transactions.idx"sv, "2566d8de087f8bd1519c878ef4ce1458b7e38edf"sv}, Entry{"v1-003200-003300-transactions.seg"sv, "ec535e4dba095296415ce9ff36f82f90ae5cfe61"sv}, Entry{"v1-003300-003400-bodies.idx"sv, "3da357f49e867e07cf2c75c04460804f23290bb2"sv}, Entry{"v1-003300-003400-bodies.seg"sv, "62ac8e690d86ece64b520745f88f331411fbe547"sv}, Entry{"v1-003300-003400-borevents.idx"sv, "74d4c6773bc807f31158b976696b6236152aa822"sv}, Entry{"v1-003300-003400-borevents.seg"sv, "af4856fc34add14240340f8fb04b843f146fd91e"sv}, Entry{"v1-003300-003400-borspans.idx"sv, "dae8328c57aafc93fe234475a79552e2fcb63104"sv}, Entry{"v1-003300-003400-borspans.seg"sv, "3b416a0b6c334061878700f990b9eb6260eebdde"sv}, Entry{"v1-003300-003400-headers.idx"sv, "7df7023bbf82a1d2bf643a429529045842cbe878"sv}, Entry{"v1-003300-003400-headers.seg"sv, "1540960f8af77b07ee190b0085a6b9dafbab8c1a"sv}, Entry{"v1-003300-003400-transactions-to-block.idx"sv, "55044e56aec7abb4544861b253533e420cc4c724"sv}, Entry{"v1-003300-003400-transactions.idx"sv, "f56bc887ac2279e4afa7ed34c8f72a0967f9b872"sv}, Entry{"v1-003300-003400-transactions.seg"sv, "15670c90a832f21bffc75c93515c0ecff574a9c4"sv}, Entry{"v1-003400-003500-bodies.idx"sv, "b5f4a15fa1569fc08bf155ea5e6a424b9e81393a"sv}, Entry{"v1-003400-003500-bodies.seg"sv, "db4fb0f5a70bacaa9f54ad42ef2a6c46d67fc30a"sv}, Entry{"v1-003400-003500-borevents.idx"sv, "4ce95ccf9d7135e8461d3eec93c7dbb25d12cb45"sv}, Entry{"v1-003400-003500-borevents.seg"sv, "507b732a189f4331b5f0db01712099c9e16170b4"sv}, Entry{"v1-003400-003500-borspans.idx"sv, "80fb0f6bcbf4ac63586728710c4f53b1ca044253"sv}, Entry{"v1-003400-003500-borspans.seg"sv, "cb1b5cf58e4dd6248c1bf852f419e8d1edb4a1b4"sv}, Entry{"v1-003400-003500-headers.idx"sv, "4f5c3be1d11474bc17155a39bc5b2ca0d6f82a60"sv}, Entry{"v1-003400-003500-headers.seg"sv, "0c19ef7d372f8ce066632b2e4f66ed459d867618"sv}, Entry{"v1-003400-003500-transactions-to-block.idx"sv, "539ba7253d919b41a690c8089899f0cf00dffa4e"sv}, Entry{"v1-003400-003500-transactions.idx"sv, "e308c3cae611fba08c3cfe5c73aca24309a6788d"sv}, Entry{"v1-003400-003500-transactions.seg"sv, "789e3b222c94542dd18c5b164f7f60b5319dc645"sv}, Entry{"v1-003500-003600-bodies.idx"sv, "6cdca515925dff9adc062fca95a704165780f1c7"sv}, Entry{"v1-003500-003600-bodies.seg"sv, "bfbc1dfaf29e87e69f20dc99641fba6c49b4a803"sv}, Entry{"v1-003500-003600-borevents.idx"sv, "5d87c5dc64215017fec4f8531960e61f598ed733"sv}, Entry{"v1-003500-003600-borevents.seg"sv, "9aa629aa0894c0353abd0b3cc84e50be9edd224f"sv}, Entry{"v1-003500-003600-borspans.idx"sv, "6c7be484cf39cdbc19f294dbf18932ee9ac94059"sv}, Entry{"v1-003500-003600-borspans.seg"sv, "27bcf3df51f59b190968cee6abf66a66aa52da44"sv}, Entry{"v1-003500-003600-headers.idx"sv, "6ed955a73b96c68cf091bfd43a5a65932929873b"sv}, Entry{"v1-003500-003600-headers.seg"sv, "c5e42518d91011f5a71e3de947463239a1a8ca88"sv}, Entry{"v1-003500-003600-transactions-to-block.idx"sv, "b4af2c076b5817e6856cec4f5fc110def4ea4607"sv}, Entry{"v1-003500-003600-transactions.idx"sv, "28ea8a77df6c9346f98f14a87822963e3725d834"sv}, Entry{"v1-003500-003600-transactions.seg"sv, "e0bd437bc543c9c2d0c46888ff2ba700af406585"sv}, Entry{"v1-003600-003700-bodies.idx"sv, "aa432f58ff3dfa927b7cac05cb229016dbb2cdb0"sv}, Entry{"v1-003600-003700-bodies.seg"sv, "10c2edac49927ef035b34962495bc465b34758cc"sv}, Entry{"v1-003600-003700-borevents.idx"sv, "88f47df36d057dd1f867ecb6a380c3c069293a31"sv}, Entry{"v1-003600-003700-borevents.seg"sv, "5e6b397482ba2131baa216756029742a6647bcdf"sv}, Entry{"v1-003600-003700-borspans.idx"sv, "bd299d69572ea726d739627c71988f8eaeb5318b"sv}, Entry{"v1-003600-003700-borspans.seg"sv, "38554fac34366fd6d9ff06d8322a6f98f4fe8476"sv}, Entry{"v1-003600-003700-headers.idx"sv, "fbc0430d233b182f43b182ec7bf27f5e68e5b95f"sv}, Entry{"v1-003600-003700-headers.seg"sv, "d995ea53fd4e39dcbe2b30ff200cbceb8bc344f2"sv}, Entry{"v1-003600-003700-transactions-to-block.idx"sv, "894394aa61ad3a58c01355de3664f0d70807aa93"sv}, Entry{"v1-003600-003700-transactions.idx"sv, "76d8c7349d4a383899b1c46fc7a7234a431d6fc9"sv}, Entry{"v1-003600-003700-transactions.seg"sv, "3d72afc172d57936b0055e00de668cd31f04b6e4"sv}, Entry{"v1-003700-003800-bodies.idx"sv, "3165ec5e14c2b7e8be1ff16cc4f0fe4424b71d8d"sv}, Entry{"v1-003700-003800-bodies.seg"sv, "2508a32b325aeec6328de0e8a57138f7407eadf9"sv}, Entry{"v1-003700-003800-borevents.idx"sv, "3727dbb87ef809045334eba52decd2af802d1462"sv}, Entry{"v1-003700-003800-borevents.seg"sv, "900d1b60452ff5042641748fe13ab95e7641394e"sv}, Entry{"v1-003700-003800-borspans.idx"sv, "cb9daa021b47ce174d07ac0a8512ab8e28ddc26b"sv}, Entry{"v1-003700-003800-borspans.seg"sv, "27d01037974eb6e35ed56a12cd0df93d8b1fb99f"sv}, Entry{"v1-003700-003800-headers.idx"sv, "294fe3c3abe938646632341e199cb0636b057521"sv}, Entry{"v1-003700-003800-headers.seg"sv, "fe68c898aafb49bda5b2005f65d36831aa96f0d3"sv}, Entry{"v1-003700-003800-transactions-to-block.idx"sv, "75883080750ee0088f631da0c6459897ae217daa"sv}, Entry{"v1-003700-003800-transactions.idx"sv, "2ec2afd2c6eb26f92c336062b81ecf910e747e9e"sv}, Entry{"v1-003700-003800-transactions.seg"sv, "b5ee949bf99dd139141124ff0bbbf93f1c4eb908"sv}, Entry{"v1-003800-003900-bodies.idx"sv, "45c4f28d797399e90bae06a88cdf240eb7e955cf"sv}, Entry{"v1-003800-003900-bodies.seg"sv, "7b09a3eff8acd79cbff2c4e937bd9c4abd2499f0"sv}, Entry{"v1-003800-003900-borevents.idx"sv, "0bb190bed539bef521043c4b5dafd2cf707ee1f8"sv}, Entry{"v1-003800-003900-borevents.seg"sv, "d65d1844d23b803bb31d126ff4d1143301fc039c"sv}, Entry{"v1-003800-003900-borspans.idx"sv, "e8cd0540e734017e9ae1634013336b694919812f"sv}, Entry{"v1-003800-003900-borspans.seg"sv, "4bf876801756b9c658ee019f6a0b073f68a97c44"sv}, Entry{"v1-003800-003900-headers.idx"sv, "8ceb82ababb836f112aef8199b097aa057266ea0"sv}, Entry{"v1-003800-003900-headers.seg"sv, "7a504e168fa85c60b31fb04ead4a59af3653a852"sv}, Entry{"v1-003800-003900-transactions-to-block.idx"sv, "bf894ea08515aee5e2a9142e34ccd8a81f5042b4"sv}, Entry{"v1-003800-003900-transactions.idx"sv, "92a108ce375c76c57f109dd1dc94502cfa59c1fd"sv}, Entry{"v1-003800-003900-transactions.seg"sv, "f7e848376adfd298a5168907a18bb46074f0e551"sv}, Entry{"v1-003900-004000-bodies.idx"sv, "e4d26c1f6b60f0e4a87f9f188506bcee6089fda9"sv}, Entry{"v1-003900-004000-bodies.seg"sv, "225e96f45e8b09b957e3e2d98690a1658bb39000"sv}, Entry{"v1-003900-004000-borevents.idx"sv, "fe9ee85eec787d8ee7c1b928c71558f5a64a3ef7"sv}, Entry{"v1-003900-004000-borevents.seg"sv, "5a4f59d153a4cef350d375bdd7de3bd024f9f2d7"sv}, Entry{"v1-003900-004000-borspans.idx"sv, "c125d95c59f74ff3e80514317a367e8bf38a4efc"sv}, Entry{"v1-003900-004000-borspans.seg"sv, "bb7fcd40c036e2fd72b1dbb97199fe558f683e0e"sv}, Entry{"v1-003900-004000-headers.idx"sv, "799fabb19e3f58b5deb0cda4e2d4dce1f6235b5f"sv}, Entry{"v1-003900-004000-headers.seg"sv, "f3194de80584d60afd077587e29d7f962bdaa2ba"sv}, Entry{"v1-003900-004000-transactions-to-block.idx"sv, "a7a847d47823fae453a8f87755b43f7f3bbc132f"sv}, Entry{"v1-003900-004000-transactions.idx"sv, "646252ed24cbbbb34f67ec79c463e04ebf924ea6"sv}, Entry{"v1-003900-004000-transactions.seg"sv, "f1e273826a55e2bdc5d1eda5bb644b19f094220b"sv}, Entry{"v1-004000-004100-bodies.idx"sv, "9c236743b16c8dad567c1331edd4426025b572c8"sv}, Entry{"v1-004000-004100-bodies.seg"sv, "c91ff1cd2254bd67ae932b6f1d4ed72ae410f415"sv}, Entry{"v1-004000-004100-borevents.idx"sv, "13cf61f54d4a5df4852c00f6603c324b990f134b"sv}, Entry{"v1-004000-004100-borevents.seg"sv, "18b96ae1c9e28ebe805e0d9f69a96afaadbba7a9"sv}, Entry{"v1-004000-004100-borspans.idx"sv, "b965a7cfd642341dafe93ba43dba4da0ce599ed6"sv}, Entry{"v1-004000-004100-borspans.seg"sv, "46b4cda33498d2fe03f1dd4b44e2907183aaf9ce"sv}, Entry{"v1-004000-004100-headers.idx"sv, "f039946d07b7ff37bd358351603252a973b27a74"sv}, Entry{"v1-004000-004100-headers.seg"sv, "c70fb92b7e24bb7c10051031b9188fbea9fac094"sv}, Entry{"v1-004000-004100-transactions-to-block.idx"sv, "d55379565068ee3da7e6e31c82294f34e1e5619b"sv}, Entry{"v1-004000-004100-transactions.idx"sv, "3707af3b7cc05cdd2731a3eb10071ba45c38904c"sv}, Entry{"v1-004000-004100-transactions.seg"sv, "b4612e2a1d7c827aea595b9a360115a3664fd905"sv}, Entry{"v1-004100-004200-bodies.idx"sv, "5a8f36903abdce2e615c8475b9126e85724e2b7c"sv}, Entry{"v1-004100-004200-bodies.seg"sv, "67c3f8a275861c8432b28ca0ef45b0a1c8b54c5b"sv}, Entry{"v1-004100-004200-borevents.idx"sv, "bd4bf039c96837953d9991a2c5bd25e3af841ce1"sv}, Entry{"v1-004100-004200-borevents.seg"sv, "c28d141a2d0ac2cd8d7a1855936e158be21c468e"sv}, Entry{"v1-004100-004200-borspans.idx"sv, "6292c71aa92bce9bcb0a36e47b8887002619ab71"sv}, Entry{"v1-004100-004200-borspans.seg"sv, "8de195bb773db3c418b4359daad91fdcbed44ea7"sv}, Entry{"v1-004100-004200-headers.idx"sv, "cd4ec134ea362bd6504e4646d1af0a752629e641"sv}, Entry{"v1-004100-004200-headers.seg"sv, "b7b232a0ff3252a763daffe79d0ef7dfb6fbb84d"sv}, Entry{"v1-004100-004200-transactions-to-block.idx"sv, "dd0ab03087f1e78258a9027c87ef6f4cab87eb5a"sv}, Entry{"v1-004100-004200-transactions.idx"sv, "64adf9e67a99f5eb1b913673fcb050d90df38a94"sv}, Entry{"v1-004100-004200-transactions.seg"sv, "42c009f07b052ca282fe6bb8241fb678bd655759"sv}, Entry{"v1-004200-004300-bodies.idx"sv, "1447ade9ee2e720ef0792a50fa492fa05956ea8e"sv}, Entry{"v1-004200-004300-bodies.seg"sv, "ac4482af3b5be322e7ae81162ab75c6c3c3d8a7f"sv}, Entry{"v1-004200-004300-borevents.idx"sv, "69ee56e07be63a67edbf63198af793887e0e9746"sv}, Entry{"v1-004200-004300-borevents.seg"sv, "d01644f5cd6a12c47d10f97c43cb5164a0e636d7"sv}, Entry{"v1-004200-004300-borspans.idx"sv, "ce08e231ab61e54490c8b3c84c13cdf3a8cc1ee8"sv}, Entry{"v1-004200-004300-borspans.seg"sv, "6bf976778131470f15d6f5e4911e1409182ddca3"sv}, Entry{"v1-004200-004300-headers.idx"sv, "1c33d21adcde902e6a0820cbd17c0de160fe4b20"sv}, Entry{"v1-004200-004300-headers.seg"sv, "be594b5f270d217b67c56c60ae689762a4211cc3"sv}, Entry{"v1-004200-004300-transactions-to-block.idx"sv, "879793fda8102dd1a4095c3418962edcc30202a9"sv}, Entry{"v1-004200-004300-transactions.idx"sv, "5f00ac40f032c25d9ad96d8522c08881b13f9eb0"sv}, Entry{"v1-004200-004300-transactions.seg"sv, "81008d2dac15228de04b7b9273233e60f7599e5c"sv}, Entry{"v1-004300-004400-bodies.idx"sv, "342da8efd87a3c5025501e5d3de71fe98f5ee535"sv}, Entry{"v1-004300-004400-bodies.seg"sv, "b702b7454d633ce886a2511aefa0db08472afbcb"sv}, Entry{"v1-004300-004400-borevents.idx"sv, "30eed4afb91b94aaf9e3dc24fcf34d5e0c1e6b57"sv}, Entry{"v1-004300-004400-borevents.seg"sv, "6ca0462a42a05a6c3a9dbdcf5a5ea79d4439604c"sv}, Entry{"v1-004300-004400-borspans.idx"sv, "bcf74125e2e703b40f098130e2ea4bdeaeb965a4"sv}, Entry{"v1-004300-004400-borspans.seg"sv, "7d8f759d0b73fc85ae7ef669ebeefd030cd38b92"sv}, Entry{"v1-004300-004400-headers.idx"sv, "c84953dd864765f1cb354404f391d29bd4d28432"sv}, Entry{"v1-004300-004400-headers.seg"sv, "8e74fb5a69c2c63a15ff67ff8f89df1217b66974"sv}, Entry{"v1-004300-004400-transactions-to-block.idx"sv, "b5687a50e6399332c50e7b899adea11a9531794e"sv}, Entry{"v1-004300-004400-transactions.idx"sv, "94cac7920fde5150ffbb1191bab11ae494dfe22b"sv}, Entry{"v1-004300-004400-transactions.seg"sv, "dfbc74ad945e423d669664acaa7332f7265b9169"sv}, Entry{"v1-004400-004500-bodies.idx"sv, "5975dc3da27fd9cb440cfc51e324968984e0ee1b"sv}, Entry{"v1-004400-004500-bodies.seg"sv, "36ac6ad8928c95f75bd18ba4df9673efae0f3473"sv}, Entry{"v1-004400-004500-borevents.idx"sv, "b7a68652049bafd7829e32f4cdfccbdc25aaa995"sv}, Entry{"v1-004400-004500-borevents.seg"sv, "c7bcffa6179e04cbd4554d54a16571fdeee12dc5"sv}, Entry{"v1-004400-004500-borspans.idx"sv, "4071daa0398f4b7a63e2c5904554bd2cd0e5ace1"sv}, Entry{"v1-004400-004500-borspans.seg"sv, "88aff209b0e4e3a1c62b6b675e32e83a84619353"sv}, Entry{"v1-004400-004500-headers.idx"sv, "4ecc49a9aeab249d2e0b3bf4d3ca8a6bd640e8aa"sv}, Entry{"v1-004400-004500-headers.seg"sv, "7b61d29a8679038d1684156c0ddb1503489f2254"sv}, Entry{"v1-004400-004500-transactions-to-block.idx"sv, "e64b3ef2b95bdd6cb28f0ebe4cfdf9fbbc8f851c"sv}, Entry{"v1-004400-004500-transactions.idx"sv, "ead4683de63b17c04a657c88f285fc4e858f18c9"sv}, Entry{"v1-004400-004500-transactions.seg"sv, "32bef60c38fda4a2315896999a4c371a56939a1d"sv}, Entry{"v1-004500-004600-bodies.idx"sv, "9c2368d272c7d1ca993b564e16ddadb8e6a9fb35"sv}, Entry{"v1-004500-004600-bodies.seg"sv, "8f08269d2823ca522d64e404504a09bf85970687"sv}, Entry{"v1-004500-004600-borevents.idx"sv, "95ddd3ed77403a49e1c888eec9042bc329522c33"sv}, Entry{"v1-004500-004600-borevents.seg"sv, "44d6591cef2e035de96ef8bc229a396419a76017"sv}, Entry{"v1-004500-004600-borspans.idx"sv, "fb2569ee07aca30c42a67aeb01133fb9a58473a5"sv}, Entry{"v1-004500-004600-borspans.seg"sv, "f9acbb28c73e9bcb25f458bfa1b0aff0fca04a37"sv}, Entry{"v1-004500-004600-headers.idx"sv, "099d7a9041e8fb715a6ed313aba1605b861611d8"sv}, Entry{"v1-004500-004600-headers.seg"sv, "64f9fabf13e9a356ef426c703f697aab9a2e378c"sv}, Entry{"v1-004500-004600-transactions-to-block.idx"sv, "c73131febdb4f394c9a7e3027d3f9737736e31b2"sv}, Entry{"v1-004500-004600-transactions.idx"sv, "578fc2d7b13a39e9285690c2f30eec34c9533123"sv}, Entry{"v1-004500-004600-transactions.seg"sv, "e7da3ad9bd7b6f48b4b9f2bf9e8aab85538e3ecd"sv}, Entry{"v1-004600-004700-bodies.idx"sv, "9831a82bb556b7861026ef8a5d28cedd010292d0"sv}, Entry{"v1-004600-004700-bodies.seg"sv, "8021c825b47ccbaa1ed60c46ad7582060ea6c73d"sv}, Entry{"v1-004600-004700-borevents.idx"sv, "4ab2947063eb5c15dbfeca1baa949e38baf539c4"sv}, Entry{"v1-004600-004700-borevents.seg"sv, "5c9c8aea28a9c3727447040934b5daa735d5d4c8"sv}, Entry{"v1-004600-004700-borspans.idx"sv, "d9179746ea6cb47b7ca2d5087b6f503ff0b9b64e"sv}, Entry{"v1-004600-004700-borspans.seg"sv, "dcee30ae19cc5c35d47bf09307f4f327a0d1ac60"sv}, Entry{"v1-004600-004700-headers.idx"sv, "acfbb1b1f77d805923d5a23093862ff52b49f04d"sv}, Entry{"v1-004600-004700-headers.seg"sv, "714b7c97638453bbb43f81deae57b8f34b9b9690"sv}, Entry{"v1-004600-004700-transactions-to-block.idx"sv, "ca1839b0040151a46eeb8827474bcb22f5d150d6"sv}, Entry{"v1-004600-004700-transactions.idx"sv, "e399c7168c2bd64fe2ad3e0b743821b8f66c6b08"sv}, Entry{"v1-004600-004700-transactions.seg"sv, "b65310b1e58737fd5825f8fab5f41131e1d2bd82"sv}, Entry{"v1-004700-004800-bodies.idx"sv, "46e21d5c2d91e425e2d8c8fd5bed6aa60f8a21d2"sv}, Entry{"v1-004700-004800-bodies.seg"sv, "92cf274ec712851096956c66c350e15af36f61da"sv}, Entry{"v1-004700-004800-borevents.idx"sv, "d35ed04213d4911bda1f3a09420e42c499f987c2"sv}, Entry{"v1-004700-004800-borevents.seg"sv, "370540f403ca9925879896dff54b18c30a491347"sv}, Entry{"v1-004700-004800-borspans.idx"sv, "4b705132b7785ab771becf157c875e0fdec85985"sv}, Entry{"v1-004700-004800-borspans.seg"sv, "ccbf3558077986b51491f13bdfd19e2f6d585175"sv}, Entry{"v1-004700-004800-headers.idx"sv, "a6d664790c41ae4004afc5f706bb6f8ca83ff66c"sv}, Entry{"v1-004700-004800-headers.seg"sv, "0f65cd2e0928ddf9ed1ce94afd75c5c4ee8f9940"sv}, Entry{"v1-004700-004800-transactions-to-block.idx"sv, "dc38579c7ae2a5be7c6cb743be80322d9374e2ff"sv}, Entry{"v1-004700-004800-transactions.idx"sv, "3c04656c899e4d8817aae901ac073346f498707b"sv}, Entry{"v1-004700-004800-transactions.seg"sv, "2da82e91d43df6ad5120ba433f7a0d9e8ccbe758"sv}, Entry{"v1-004800-004900-bodies.idx"sv, "04ab5139368da4dc213c827a6222d63cbc2bea61"sv}, Entry{"v1-004800-004900-bodies.seg"sv, "33a5e28796c1a98100c02c9a7a654fba95cde6bd"sv}, Entry{"v1-004800-004900-borevents.idx"sv, "26d6471b9586c265c9d39e910ebc9d976b6e8315"sv}, Entry{"v1-004800-004900-borevents.seg"sv, "cdbc47c345316d168634f47563082697702f1cb0"sv}, Entry{"v1-004800-004900-borspans.idx"sv, "b0fadf3523fcff93fea709752cc92b09ffb065ef"sv}, Entry{"v1-004800-004900-borspans.seg"sv, "2464d4c9ec6ddec8669e593bd7568f81b9a5286f"sv}, Entry{"v1-004800-004900-headers.idx"sv, "f6c159cafa6003e1aa8e89c4e089982b80e86df5"sv}, Entry{"v1-004800-004900-headers.seg"sv, "4c2a0263b0203ef64c6dac605aeed48c22706979"sv}, Entry{"v1-004800-004900-transactions-to-block.idx"sv, "afb1841bbe9b7b591e00972e7664a800db7dbbf7"sv}, Entry{"v1-004800-004900-transactions.idx"sv, "b1dd03a29400e05ed4322b91ea8ddc9872b7b5fb"sv}, Entry{"v1-004800-004900-transactions.seg"sv, "faf241a5304455ac341ec03bb0c3e2dc1a51f101"sv}, Entry{"v1-004900-005000-bodies.idx"sv, "3e6aa2cb1069c5b1fae0d0e2c3ec1e76892f2dd7"sv}, Entry{"v1-004900-005000-bodies.seg"sv, "324bb07e27ebac4cff63db7f91d0ead0cb5f7ecc"sv}, Entry{"v1-004900-005000-borevents.idx"sv, "9675ca6d8e7e578b07844327ef26cb4abf5a81ec"sv}, Entry{"v1-004900-005000-borevents.seg"sv, "fa301a5a68ac9dc64c23f7f11cea58a1d37dc3ae"sv}, Entry{"v1-004900-005000-borspans.idx"sv, "e1e993d257273cd4b3e592bf7667c58c17a7bd69"sv}, Entry{"v1-004900-005000-borspans.seg"sv, "9e376e203ffbfb350af22dded2eeb42f649c59ab"sv}, Entry{"v1-004900-005000-headers.idx"sv, "b3292aa6db8ef69757f7d34ba02391dd3c7b30dc"sv}, Entry{"v1-004900-005000-headers.seg"sv, "2237698e7e074f4c5d20a2cd3cde99e3a4ce7b28"sv}, Entry{"v1-004900-005000-transactions-to-block.idx"sv, "4b3a860a4f838980bf9f950a1a92d16ffd383653"sv}, Entry{"v1-004900-005000-transactions.idx"sv, "093257d0a315900ac23931ce0470efa80885e6e6"sv}, Entry{"v1-004900-005000-transactions.seg"sv, "f846746c2717baf50b6d9dbab12073ae59f7046c"sv}, Entry{"v1-005000-005100-bodies.idx"sv, "a4dfde8586be958b5920ec5012b95fe6032d9b3e"sv}, Entry{"v1-005000-005100-bodies.seg"sv, "216dbd597922cb7c2b5c0da7f6a91cd775467b43"sv}, Entry{"v1-005000-005100-borevents.idx"sv, "ea2c8cc3b1363fa726294c5a332cc52cbebd209a"sv}, Entry{"v1-005000-005100-borevents.seg"sv, "b7e97ab34957b0aff83e4306de77d63a81e52838"sv}, Entry{"v1-005000-005100-borspans.idx"sv, "ab799c3e5bea587b2b5ea557fe45e9f34fb5e378"sv}, Entry{"v1-005000-005100-borspans.seg"sv, "b6ed55b0bcd05a7a9c783ce9025e0b96b52663ea"sv}, Entry{"v1-005000-005100-headers.idx"sv, "587c93638df764990a315eaa29675bc6ede06c70"sv}, Entry{"v1-005000-005100-headers.seg"sv, "f0e749b95a713b58938a154010d25abeffb6f4af"sv}, Entry{"v1-005000-005100-transactions-to-block.idx"sv, "0b0b6677840062327aa4772ddf741b49469b7273"sv}, Entry{"v1-005000-005100-transactions.idx"sv, "89fa2bb7377099c11a944f0942dd83ba892c8c14"sv}, Entry{"v1-005000-005100-transactions.seg"sv, "5decf79ca9fa2299545ce0995c8b97375c8eb7be"sv}, Entry{"v1-005100-005200-bodies.idx"sv, "0a21bf24d943d87c5f8db1322d39a2270e0ddfd3"sv}, Entry{"v1-005100-005200-bodies.seg"sv, "0bbe61e305ff155e294011b17871f1228f62b572"sv}, Entry{"v1-005100-005200-borevents.idx"sv, "9fc5da088519452d69fcedf42e05f89dd519d6bb"sv}, Entry{"v1-005100-005200-borevents.seg"sv, "81cd8af6584cd0f6a8487a50d8db1dc4b7445922"sv}, Entry{"v1-005100-005200-borspans.idx"sv, "d67bc91ecb6fa4fe54f6eb0f0a5826db3a385805"sv}, Entry{"v1-005100-005200-borspans.seg"sv, "925a77630a01cb174eeacba4718606488e65298b"sv}, Entry{"v1-005100-005200-headers.idx"sv, "9509f0babab0262b7d7944a445e10fd0bb38059d"sv}, Entry{"v1-005100-005200-headers.seg"sv, "6fc92783a0fee146c3bf5f65e85912a38d67ff71"sv}, Entry{"v1-005100-005200-transactions-to-block.idx"sv, "db620f48d9ab09f638efc5c9ee3ce187ba124d26"sv}, Entry{"v1-005100-005200-transactions.idx"sv, "82864f45627f40e1cf876993ad39c80cd74a90df"sv}, Entry{"v1-005100-005200-transactions.seg"sv, "f9ebad63dbc73937835038038fef839732e5fe03"sv}, Entry{"v1-005200-005300-bodies.idx"sv, "139782b99540e19c159b9475330843bba61b2a04"sv}, Entry{"v1-005200-005300-bodies.seg"sv, "bc47ff5529d2a944f1af0bf12b71762782b3f4ac"sv}, Entry{"v1-005200-005300-borevents.idx"sv, "0f0491ee951e752f67881f8e56594dc9795ee70e"sv}, Entry{"v1-005200-005300-borevents.seg"sv, "fce981b7c4437774f3a4fccce9c161637d203122"sv}, Entry{"v1-005200-005300-borspans.idx"sv, "75d09f2e17472c248ada6e52624ebb5d6792a1a7"sv}, Entry{"v1-005200-005300-borspans.seg"sv, "fd6c630a467fffefed55d40ed1ea36e3d5b0f68c"sv}, Entry{"v1-005200-005300-headers.idx"sv, "bccacaa943bb6e5e8ecd69d06a61643bce96e9d2"sv}, Entry{"v1-005200-005300-headers.seg"sv, "8d28aba12a1cd9007c59f9e7b1dd4ff877b50116"sv}, Entry{"v1-005200-005300-transactions-to-block.idx"sv, "bfe828e230de3fd3640b51bf78fafb12c8e193ab"sv}, Entry{"v1-005200-005300-transactions.idx"sv, "f14e0fe9fec60881510cf7f06aa7ea1e9d366233"sv}, Entry{"v1-005200-005300-transactions.seg"sv, "72f8e07e23ef8433ad7873ba7a2d85aaa9dbb585"sv}, Entry{"v1-005300-005400-bodies.idx"sv, "e26b55b55390255b3ba32d4d190be288572a3700"sv}, Entry{"v1-005300-005400-bodies.seg"sv, "8d11d49baa4f5795285e452c7e60fc70305167d0"sv}, Entry{"v1-005300-005400-borevents.idx"sv, "a5c32e7e38edfbbf35753168cc0efa8255b9db10"sv}, Entry{"v1-005300-005400-borevents.seg"sv, "d1c8f5cd0cbb0eadedc2f16d4b793c291e1c9101"sv}, Entry{"v1-005300-005400-borspans.idx"sv, "e074410e21d54adca20f769759da2f9ff85be693"sv}, Entry{"v1-005300-005400-borspans.seg"sv, "8b799065d38d21f247f23780cebf0b73f1557732"sv}, Entry{"v1-005300-005400-headers.idx"sv, "986550f7096006c44dbe1833e125b047d6130bf7"sv}, Entry{"v1-005300-005400-headers.seg"sv, "3a1954de44a5eefb1913ddef3c519800a06b4574"sv}, Entry{"v1-005300-005400-transactions-to-block.idx"sv, "194b1b2a5949b3713bcc2a6f2bc1efc6001d2a22"sv}, Entry{"v1-005300-005400-transactions.idx"sv, "7b8ea745bf011ba67ac9a2a09ce615580e58e620"sv}, Entry{"v1-005300-005400-transactions.seg"sv, "47397da1fb0aefe7796dc3a745e0d28364c20221"sv}, Entry{"v1-005400-005500-bodies.idx"sv, "ad8d20f48dd65798857fc1e6d39cf0649f017fec"sv}, Entry{"v1-005400-005500-bodies.seg"sv, "fc4d60fa8fd1af131a681594f6b278a112c3bda0"sv}, Entry{"v1-005400-005500-borevents.idx"sv, "e4b82bbecfa637a52b9e70db871189a2f4f3d725"sv}, Entry{"v1-005400-005500-borevents.seg"sv, "88f1ddea32124381651fa8aa55303cc75fa3bc44"sv}, Entry{"v1-005400-005500-borspans.idx"sv, "8ad3c6afdd828cf4a8521012f4a034ec1a932f04"sv}, Entry{"v1-005400-005500-borspans.seg"sv, "9b962077ffc92f6be1f1c8aad2999ddd009a79e0"sv}, Entry{"v1-005400-005500-headers.idx"sv, "d1e99ce6d9f0da861622411cc8003872990d9d4b"sv}, Entry{"v1-005400-005500-headers.seg"sv, "2ad013bcff0e145f46e0aaf3811d48ea881813f3"sv}, Entry{"v1-005400-005500-transactions-to-block.idx"sv, "6318caf8fcb8c45354e5fea60279873e51e139aa"sv}, Entry{"v1-005400-005500-transactions.idx"sv, "6efcc52ad049dcc29fd26d26793c7401354a11f1"sv}, Entry{"v1-005400-005500-transactions.seg"sv, "08123e365ffa6254ebdd14267a8e670c2a5f5efc"sv}, Entry{"v1-005500-005600-bodies.idx"sv, "ab9076a99441a73928aa634c395895b5bf8c08d2"sv}, Entry{"v1-005500-005600-bodies.seg"sv, "6c1901a00728394c53ada7c696d3b640307ea429"sv}, Entry{"v1-005500-005600-borevents.idx"sv, "eccc06dc056e3e423c4fe9b7b48f94730fa96426"sv}, Entry{"v1-005500-005600-borevents.seg"sv, "d6aae8580afa9604b1bef36beb3c5f7a1dea3d9f"sv}, Entry{"v1-005500-005600-borspans.idx"sv, "022355e007d47ff01a16cfd25296bb3986b0c1b0"sv}, Entry{"v1-005500-005600-borspans.seg"sv, "3d8ad4f3df5abb6f33154abf0b1d54c5068ae296"sv}, Entry{"v1-005500-005600-headers.idx"sv, "4baaa025fd3fadbad548ca798d553c8e853a49a8"sv}, Entry{"v1-005500-005600-headers.seg"sv, "90a04365adc1ffd60abae1322a5b60dea8a23726"sv}, Entry{"v1-005500-005600-transactions-to-block.idx"sv, "555de25ea2112c28ccb1828d6d9732491be031c0"sv}, Entry{"v1-005500-005600-transactions.idx"sv, "f5b7509b2df0942238592389003a10a9ef27310c"sv}, Entry{"v1-005500-005600-transactions.seg"sv, "897b64f9df94880bd164d6ab0ab3b9eb08e36694"sv}, Entry{"v1-005600-005700-bodies.idx"sv, "40b932182950a6f7b11e4be1a73d003287de7f6f"sv}, Entry{"v1-005600-005700-bodies.seg"sv, "bd5d1ffc56149aa7c6ccfc4e093e9f2bacb421e4"sv}, Entry{"v1-005600-005700-borevents.idx"sv, "e040f4b237c9e91ed94a9becd696b3e73d551220"sv}, Entry{"v1-005600-005700-borevents.seg"sv, "a1fd1e67fb8df98eddd0e6f6cbae9619357ca0d5"sv}, Entry{"v1-005600-005700-borspans.idx"sv, "abae3c511d79215c66e881f95b132b7b7a7a984c"sv}, Entry{"v1-005600-005700-borspans.seg"sv, "19aa9aa17ddae170be75e9ad8abbad584a0c4e6d"sv}, Entry{"v1-005600-005700-headers.idx"sv, "045dfb5dc26a0dbce6145a7ccb4ff96a6d0694b8"sv}, Entry{"v1-005600-005700-headers.seg"sv, "fc89e2c40c2fa67cffa16fa1f37eb5aec2e775c7"sv}, Entry{"v1-005600-005700-transactions-to-block.idx"sv, "19f8de60dcd0932522b53a2900f26ea23cefe7e1"sv}, Entry{"v1-005600-005700-transactions.idx"sv, "4d7d60942fab95fec96c912574e2adbb16529241"sv}, Entry{"v1-005600-005700-transactions.seg"sv, "6e02d756ea83b3a230fdd7987970c3b4a2729bfa"sv}, Entry{"v1-005700-005800-bodies.idx"sv, "aad8776a476ca0b1eee7de07651f41a9fe0eba04"sv}, Entry{"v1-005700-005800-bodies.seg"sv, "7ecf19c67f7c42b666732714708e86331bca24e7"sv}, Entry{"v1-005700-005800-borevents.idx"sv, "3b85266885e1d9c828da50cdce7ba5ccb10bf11c"sv}, Entry{"v1-005700-005800-borevents.seg"sv, "dad75874b35124aed1d601522a9c0a00ae9ba0b9"sv}, Entry{"v1-005700-005800-borspans.idx"sv, "f9ad1b60d55f90a114cb6903597ad91c86d8f32e"sv}, Entry{"v1-005700-005800-borspans.seg"sv, "3ce34bf3a1e6fd48864b469e304d12865203f4e2"sv}, Entry{"v1-005700-005800-headers.idx"sv, "44a19779fa425c43b9f633457729901810c6d3b3"sv}, Entry{"v1-005700-005800-headers.seg"sv, "174a4964ef13be0c38ea7f45afc9bbc59019af1f"sv}, Entry{"v1-005700-005800-transactions-to-block.idx"sv, "300f51cb55acaa2221ebf3bb86587f2307d2f6ab"sv}, Entry{"v1-005700-005800-transactions.idx"sv, "c11f8fc512fd5c6622044f9d89c4fcfda8155ac4"sv}, Entry{"v1-005700-005800-transactions.seg"sv, "fc41fc1d735db2262201deab0e0391d1bd720cfd"sv}, Entry{"v1-005800-005900-bodies.idx"sv, "a1b639e78df0d186fc67e9ecc7356ef8424f6afe"sv}, Entry{"v1-005800-005900-bodies.seg"sv, "86081d14ab0437868d7d37bea1c3a32b5a6baae3"sv}, Entry{"v1-005800-005900-borevents.idx"sv, "c6bac303bfc0f336e5c9a325217f17235aa28616"sv}, Entry{"v1-005800-005900-borevents.seg"sv, "6deeeaac7194bfab8df3ace92f8bb49b2a504bd2"sv}, Entry{"v1-005800-005900-borspans.idx"sv, "0debad2851a4d6efd2fa94a36be4c7c22d7a4231"sv}, Entry{"v1-005800-005900-borspans.seg"sv, "6548e56bf1b32ce58ce57307c477f956eb07d424"sv}, Entry{"v1-005800-005900-headers.idx"sv, "b9447a3c3336947768f932cd3a2dd7d647fcdd83"sv}, Entry{"v1-005800-005900-headers.seg"sv, "9e58ab584a64d1420ccbda0f956a050907a20583"sv}, Entry{"v1-005800-005900-transactions-to-block.idx"sv, "9bb62deb0091f9aa0e34ae8d72c6e8008b3f8c27"sv}, Entry{"v1-005800-005900-transactions.idx"sv, "7ea8d93704533ff2d623301dd59596e013ae58f2"sv}, Entry{"v1-005800-005900-transactions.seg"sv, "e0204a0bdd8ac8a9fed3a9975ad697ca9c36742a"sv}, Entry{"v1-005900-006000-bodies.idx"sv, "5a2f8078494c65c4af2c04b3b4e9ecaadf79da14"sv}, Entry{"v1-005900-006000-bodies.seg"sv, "8a68dfd2b05d6bbb52505ec68c7c313bba388fa0"sv}, Entry{"v1-005900-006000-borevents.idx"sv, "00585efee494e7890fc96f4012a70cae54ac33cf"sv}, Entry{"v1-005900-006000-borevents.seg"sv, "e8168ae1f62f8fcb693a82cf148e157dc34e80a0"sv}, Entry{"v1-005900-006000-borspans.idx"sv, "866de141532df7eb56bae185379e7d9d6267f5e9"sv}, Entry{"v1-005900-006000-borspans.seg"sv, "892002a3c96c0ea4787d11fcf7b59ed0bdf26966"sv}, Entry{"v1-005900-006000-headers.idx"sv, "4f05807b4c1ab2449f18ab338df1abe2dd7ac028"sv}, Entry{"v1-005900-006000-headers.seg"sv, "f2535ef883cd9f033082a027a3c8f91713c14aa5"sv}, Entry{"v1-005900-006000-transactions-to-block.idx"sv, "ec92e00892959b0eb6f9cb8525d573796e2c28ca"sv}, Entry{"v1-005900-006000-transactions.idx"sv, "ed7fed1c527680f9a382d962a496f6b81e9e98a0"sv}, Entry{"v1-005900-006000-transactions.seg"sv, "4c3f5eb1e10f653245ce984868f0e16bf2c7f4ab"sv}, Entry{"v1-006000-006100-bodies.idx"sv, "d9c1e24577c98ee73ec75a13af8455c166e8e887"sv}, Entry{"v1-006000-006100-bodies.seg"sv, "b42267ee646ed0c8562ae675b6e104436b8238a1"sv}, Entry{"v1-006000-006100-borevents.idx"sv, "a1b4f00a9b3cb636d9104e15f5daae9b2d3ea24f"sv}, Entry{"v1-006000-006100-borevents.seg"sv, "2cf992499014926563ac992278a7e29f64bd6d39"sv}, Entry{"v1-006000-006100-borspans.idx"sv, "511e49f1410661efbb2aa3733f47c5e7bc8f3cb8"sv}, Entry{"v1-006000-006100-borspans.seg"sv, "81ed3194b1bf42ad1afb32ea3319f535d51badc2"sv}, Entry{"v1-006000-006100-headers.idx"sv, "814e31a74c98571dd4bdc2835df9e6bd5f74a11b"sv}, Entry{"v1-006000-006100-headers.seg"sv, "704cd5a87a43a418a49be57f1bb2d86343ce8cb5"sv}, Entry{"v1-006000-006100-transactions-to-block.idx"sv, "51c674add1e4cd7977bb898fcb8cfad322a38023"sv}, Entry{"v1-006000-006100-transactions.idx"sv, "c1f17262bd70cb4f5b668c22339bc60e0ce57625"sv}, Entry{"v1-006000-006100-transactions.seg"sv, "8d2e7d372432704159affbeff54eb225da3abfa9"sv}, Entry{"v1-006100-006200-bodies.idx"sv, "bce5e92e22e6ee26596fae266789c8f9bcc9819d"sv}, Entry{"v1-006100-006200-bodies.seg"sv, "465da692b93cb7afbe2e53eea021b39fd119a537"sv}, Entry{"v1-006100-006200-borevents.idx"sv, "c50ced41b8072d08bd69ae7276baddac7d9c306f"sv}, Entry{"v1-006100-006200-borevents.seg"sv, "7aa0be8643fb09e8a2f48add68429c36dada37ef"sv}, Entry{"v1-006100-006200-borspans.idx"sv, "5745eea140f17a6d5fc8c4afb960d1512ec0e3fe"sv}, Entry{"v1-006100-006200-borspans.seg"sv, "9d8f692ee36864e824d828e22389d98db803e761"sv}, Entry{"v1-006100-006200-headers.idx"sv, "780cbfaf7ecbef4c9e6403a7f3b3674e0fff3f40"sv}, Entry{"v1-006100-006200-headers.seg"sv, "ccdf15dcc1243c06949e624e6c036abf28d8a160"sv}, Entry{"v1-006100-006200-transactions-to-block.idx"sv, "d3c0bcd9cc8859d8ac3a044a09c0bb6737608131"sv}, Entry{"v1-006100-006200-transactions.idx"sv, "8bca24a88c2eec61a635d85ae19a7113a5cfb682"sv}, Entry{"v1-006100-006200-transactions.seg"sv, "37de5e2675c3caff5702525dc2965fd870e1fe62"sv}, Entry{"v1-006200-006300-bodies.idx"sv, "79a0081deeac60b86561f462575d861e2159a1b8"sv}, Entry{"v1-006200-006300-bodies.seg"sv, "ecde139cfd6a7203402348cec6f94af0fac2ddbd"sv}, Entry{"v1-006200-006300-borevents.idx"sv, "a8f7110b69af75da679bdcf363664afa1ebf23ef"sv}, Entry{"v1-006200-006300-borevents.seg"sv, "70612c08b2a2045e1c50d6a101a2079bd7b1058f"sv}, Entry{"v1-006200-006300-borspans.idx"sv, "80e448bfdbf1a122af2c66d388fbd7dc4b119ee3"sv}, Entry{"v1-006200-006300-borspans.seg"sv, "5f090697cf745fc8d83a82943197bad52dc61424"sv}, Entry{"v1-006200-006300-headers.idx"sv, "09d2d3a35d20064ebb4f4d4c4fab76337ac9c224"sv}, Entry{"v1-006200-006300-headers.seg"sv, "8c382dbdeabbce47a1c11748617ebf4b9b33d32b"sv}, Entry{"v1-006200-006300-transactions-to-block.idx"sv, "06b1d5d2b2ff1bbdb518be38b023da763b90c63d"sv}, Entry{"v1-006200-006300-transactions.idx"sv, "48cbb99c6e13092873020eea3231c8fa903a78f0"sv}, Entry{"v1-006200-006300-transactions.seg"sv, "56322914fdf91251f68c17ef80d39e95e945b798"sv}, Entry{"v1-006300-006400-bodies.idx"sv, "604afffd47dc8a2021e3c5b1f4419bb5899bb43e"sv}, Entry{"v1-006300-006400-bodies.seg"sv, "f5d9a6f70862f4a35f8dc2e210b6125c4b0fd8e6"sv}, Entry{"v1-006300-006400-borevents.idx"sv, "5f7b510f359219105feeeeef7b1ed39635cbf7c7"sv}, Entry{"v1-006300-006400-borevents.seg"sv, "dd3dfb61c5205f6f9859559ab8a2bb4504e612f2"sv}, Entry{"v1-006300-006400-borspans.idx"sv, "12677ad1b02ed2641e646189b21d52272e7ae6c3"sv}, Entry{"v1-006300-006400-borspans.seg"sv, "1b42688f68302d34c622746dc83d6e0857aeb0fb"sv}, Entry{"v1-006300-006400-headers.idx"sv, "e845a525b7e064ddbb20b8314a876d94421b9c18"sv}, Entry{"v1-006300-006400-headers.seg"sv, "388592af25ea550f9900759de7b702eee098e4db"sv}, Entry{"v1-006300-006400-transactions-to-block.idx"sv, "d945813700cd2b28a699e666b0a12adfafa63c9b"sv}, Entry{"v1-006300-006400-transactions.idx"sv, "f8c83a59ac8036e164472e2f4ba2afa3f349ec4e"sv}, Entry{"v1-006300-006400-transactions.seg"sv, "56a7f69cdd5c446da6e78dca3ad9a4a723fa5232"sv}, Entry{"v1-006400-006500-bodies.idx"sv, "9e84f7b3d90eed9d5e3d577b0e75a58fc1230e69"sv}, Entry{"v1-006400-006500-bodies.seg"sv, "4ae08a1b547f6b6cae9df2b4f4d8bc88376333ce"sv}, Entry{"v1-006400-006500-borevents.idx"sv, "7f41f90cdc81231cc4ec48f86899d983bbfc5651"sv}, Entry{"v1-006400-006500-borevents.seg"sv, "f0ce1d2265e8a7ff59ea319e2302a3a754b3d68d"sv}, Entry{"v1-006400-006500-borspans.idx"sv, "e9f6ce4a316155e4b2cf4291f7ff03df7d91eb6a"sv}, Entry{"v1-006400-006500-borspans.seg"sv, "577c928cfe7de6101b2379596d4911105ebd19e2"sv}, Entry{"v1-006400-006500-headers.idx"sv, "bb90ae50ccb45813eeff604494cb3af394563730"sv}, Entry{"v1-006400-006500-headers.seg"sv, "f58a2535ee0499c7b52c2e4f1274426be19a5df0"sv}, Entry{"v1-006400-006500-transactions-to-block.idx"sv, "f69d87ec504a5c1440e68cb78357bec0ec7665dc"sv}, Entry{"v1-006400-006500-transactions.idx"sv, "39122a6d5498a8eb9b54497cbbe06ac217445a65"sv}, Entry{"v1-006400-006500-transactions.seg"sv, "875b27112de6e075f39530cdc227b619104917f1"sv}, Entry{"v1-006500-006600-bodies.idx"sv, "e74733ffb5de4321dd223abd7a44f30d22acf960"sv}, Entry{"v1-006500-006600-bodies.seg"sv, "eb0601cd97608c47dbfe390708490bc462d705a0"sv}, Entry{"v1-006500-006600-borevents.idx"sv, "ebeb35c55b372f71d9d9968e20fa25128b20682d"sv}, Entry{"v1-006500-006600-borevents.seg"sv, "2642ae32233928b267623a16d00fb160173a6e10"sv}, Entry{"v1-006500-006600-borspans.idx"sv, "18dba8e2be8e2a0e0b8c912f0f9cce89e8cc7608"sv}, Entry{"v1-006500-006600-borspans.seg"sv, "adbd53b6e6949f3d8fd76a5e866a6c4cbb2ad582"sv}, Entry{"v1-006500-006600-headers.idx"sv, "b1acb92bf0808e8e7f062e2f1878d30634fbee6c"sv}, Entry{"v1-006500-006600-headers.seg"sv, "6448c4824e24edb463f3f25a37752fac03f166f1"sv}, Entry{"v1-006500-006600-transactions-to-block.idx"sv, "a626dc40f2e667a8c492646a18dcf79ebcfe92d9"sv}, Entry{"v1-006500-006600-transactions.idx"sv, "f6052ceadef48a2650dca5ba4300c59249da41b9"sv}, Entry{"v1-006500-006600-transactions.seg"sv, "5dbd0ac962ecb38e517179d477d0592b9f368e68"sv}, Entry{"v1-006600-006700-bodies.idx"sv, "6827bc150c85d4537f905ea693dfd7d656599635"sv}, Entry{"v1-006600-006700-bodies.seg"sv, "07a0a37df88e56ead750ffc44e8ff4d010006df8"sv}, Entry{"v1-006600-006700-borevents.idx"sv, "336d354d1b29c242faef2114a2adbb831cbaf591"sv}, Entry{"v1-006600-006700-borevents.seg"sv, "8b65f88d3ef8c20b9eafcb847ad564fc40d178eb"sv}, Entry{"v1-006600-006700-borspans.idx"sv, "1ddd002574679cb4b18c39ee97a884cef9348d0d"sv}, Entry{"v1-006600-006700-borspans.seg"sv, "fba95fa2b4e8ec9b471bc8a0163b3567f92f59c2"sv}, Entry{"v1-006600-006700-headers.idx"sv, "1177ba371939fbfacc46f90cff1d486e2e8ce2b2"sv}, Entry{"v1-006600-006700-headers.seg"sv, "aeecc3bc645b6f608b79de2a6c64555cb2110f6d"sv}, Entry{"v1-006600-006700-transactions-to-block.idx"sv, "b05ed47c4f320a55afc23676302409c6e54ae5cc"sv}, Entry{"v1-006600-006700-transactions.idx"sv, "b1f6fea94e872852959108e972d608d31ebd3795"sv}, Entry{"v1-006600-006700-transactions.seg"sv, "f0856c26ea598152f8e7ec99523dc91a695208b3"sv}, Entry{"v1-006700-006800-bodies.idx"sv, "3d8417fe3a2987bbb860ad132ad7eff8c9c30696"sv}, Entry{"v1-006700-006800-bodies.seg"sv, "b3c520f3da028bd04fafc2f81c117ed45ea86e8d"sv}, Entry{"v1-006700-006800-borevents.idx"sv, "b735a71bb26e889793889e58207572f532fba9bf"sv}, Entry{"v1-006700-006800-borevents.seg"sv, "e6c33427a44602688476d8d9d85ec72cf17a9ad6"sv}, Entry{"v1-006700-006800-borspans.idx"sv, "53df9617df8d6740b03bd4b403e7ed9c9ff67a08"sv}, Entry{"v1-006700-006800-borspans.seg"sv, "f13b8ff3743ebc56701eb2a153dc258ea21c3da2"sv}, Entry{"v1-006700-006800-headers.idx"sv, "031e3d6fd385eee6a4f0d97ae087733900f43b6d"sv}, Entry{"v1-006700-006800-headers.seg"sv, "2db3cbdb359471329f888c2b62c1cd3c6dbd9598"sv}, Entry{"v1-006700-006800-transactions-to-block.idx"sv, "69d0dd84250f4f58499ad105036fbdf3db215edd"sv}, Entry{"v1-006700-006800-transactions.idx"sv, "cca9ef310d4a325892a6d43356d3490d6481353c"sv}, Entry{"v1-006700-006800-transactions.seg"sv, "3f5e24d4ac327d11f7090b414feb9a76360545e1"sv}, Entry{"v1-006800-006900-bodies.idx"sv, "1a4aa581086f7566a74ede0232d60e2a420f91d6"sv}, Entry{"v1-006800-006900-bodies.seg"sv, "4cd676d8d895afe3bea246f4514c23dbd7284235"sv}, Entry{"v1-006800-006900-borevents.idx"sv, "273686f9844d7f3d2542bd01dc1351725f0e8bf2"sv}, Entry{"v1-006800-006900-borevents.seg"sv, "61c3d2d08f27d0a8e0342642d845d9f8ec90df24"sv}, Entry{"v1-006800-006900-borspans.idx"sv, "170d71a08c8120a85e9497d12dd51285324ee781"sv}, Entry{"v1-006800-006900-borspans.seg"sv, "a224923225acc5ce87960dce4ca7915fa39cf078"sv}, Entry{"v1-006800-006900-headers.idx"sv, "5971d4046cd5c2af4c4a2f42f1901f5eac763245"sv}, Entry{"v1-006800-006900-headers.seg"sv, "1b0159412c3665763f387cc7be3b2111656f1006"sv}, Entry{"v1-006800-006900-transactions-to-block.idx"sv, "4cf61a6cf158c9066eb68bafb5cee3c9ce85688a"sv}, Entry{"v1-006800-006900-transactions.idx"sv, "45b2aafc5318cf02cb94690f5f621113c720145f"sv}, Entry{"v1-006800-006900-transactions.seg"sv, "590dd5ee8e039e7b65018d8fe9f3fe5baed6b9d3"sv}, Entry{"v1-006900-007000-bodies.idx"sv, "98be7bc7a9dad636601d664435c18f7a2843b870"sv}, Entry{"v1-006900-007000-bodies.seg"sv, "a87df771017448690d4a40d868994e3d8e9e39b9"sv}, Entry{"v1-006900-007000-borevents.idx"sv, "8e448612b0ce1208a8106b2e252edcbf0d4a45b7"sv}, Entry{"v1-006900-007000-borevents.seg"sv, "1a43e362a04356980837df437ade8bc9ffba1ed9"sv}, Entry{"v1-006900-007000-borspans.idx"sv, "e43237ba3bd230cefcd9e85b4b9458815604b17f"sv}, Entry{"v1-006900-007000-borspans.seg"sv, "93ef00c069dad52b6d944b0d9e68e518937f5581"sv}, Entry{"v1-006900-007000-headers.idx"sv, "4f129ac20f4b1bbcd9c6dc938935bf770f938402"sv}, Entry{"v1-006900-007000-headers.seg"sv, "e0801ee517282acb8f345472d86c9969c58ec292"sv}, Entry{"v1-006900-007000-transactions-to-block.idx"sv, "58b811b29f114b6b54a131ef6228058c47ed5dba"sv}, Entry{"v1-006900-007000-transactions.idx"sv, "f976315e2c0e3e4bd64dd7bf4c1766652f17570c"sv}, Entry{"v1-006900-007000-transactions.seg"sv, "3df55c7e1bfae1365dc3223de208f80a7989caa0"sv}, Entry{"v1-007000-007100-bodies.idx"sv, "b7afbe7e504fdd261dc45004357b92c80cf2554d"sv}, Entry{"v1-007000-007100-bodies.seg"sv, "bb973da06b56f1941c52f96e9793a9d31f526eab"sv}, Entry{"v1-007000-007100-borevents.idx"sv, "313bb9dc1d513b86ceafafee9e04bb9757699a76"sv}, Entry{"v1-007000-007100-borevents.seg"sv, "eeef9a2e3e3ac828374ed717c5d8a1b264b4e1a8"sv}, Entry{"v1-007000-007100-borspans.idx"sv, "8cfc68c21430fe6b6a37301c0df80cf5e62dea20"sv}, Entry{"v1-007000-007100-borspans.seg"sv, "d3883c548691000098676246710d71d491f5ca80"sv}, Entry{"v1-007000-007100-headers.idx"sv, "cb64ecbf35e9a10db6735743cff0b38ea3186a43"sv}, Entry{"v1-007000-007100-headers.seg"sv, "5b18513becc3558784223a63c615ff3286b1faf9"sv}, Entry{"v1-007000-007100-transactions-to-block.idx"sv, "e24db6a66b5cc2535cacc6de9febeeadf631d2ba"sv}, Entry{"v1-007000-007100-transactions.idx"sv, "d8b953f72310de5c2055def4820a74561b8cfee8"sv}, Entry{"v1-007000-007100-transactions.seg"sv, "5d85d7698711fb34380ea84b0a4e0b54b6b9aab4"sv}, Entry{"v1-007100-007200-bodies.idx"sv, "7c74e79792257561e0646ea15a983e0bb087d205"sv}, Entry{"v1-007100-007200-bodies.seg"sv, "657f7f1cacdbae7acc39d0c10b0ad9bb67c016fc"sv}, Entry{"v1-007100-007200-borevents.idx"sv, "0f3d9e5261244f9f2180704ce235dfcadd40e21a"sv}, Entry{"v1-007100-007200-borevents.seg"sv, "e73819621d55178bfa7b1e10ed22616466dbf02b"sv}, Entry{"v1-007100-007200-borspans.idx"sv, "a52fba979d273ab8c6e54c98cd072707cdd32ce4"sv}, Entry{"v1-007100-007200-borspans.seg"sv, "21182fa9222e1bbdd57af0e5770cae1d60977f47"sv}, Entry{"v1-007100-007200-headers.idx"sv, "fd04b16aec4bc5f5f376075836734f1f1280ac36"sv}, Entry{"v1-007100-007200-headers.seg"sv, "cb804a8aefe763d505ae4d9b99b1797c6afb66b6"sv}, Entry{"v1-007100-007200-transactions-to-block.idx"sv, "eefe50a7f1648c37510b1158ba0437bf11adc76d"sv}, Entry{"v1-007100-007200-transactions.idx"sv, "52826b04d301cd3aa3471b47304b25cce94d4456"sv}, Entry{"v1-007100-007200-transactions.seg"sv, "0a5689864aedf77de40934251c0e8aa7bad173b9"sv}, Entry{"v1-007200-007300-bodies.idx"sv, "222ca2e6f43e34f56548f2edd72f95aa8a7a1249"sv}, Entry{"v1-007200-007300-bodies.seg"sv, "d5653ebafdcc2c6e98a0ae64d17fd2541c28c24b"sv}, Entry{"v1-007200-007300-borevents.idx"sv, "e57ad0d85facbd4394f0f335bbe96e343e7c7e3b"sv}, Entry{"v1-007200-007300-borevents.seg"sv, "6c7cc9a860eea5259f8ab2eb8384267ead3556d0"sv}, Entry{"v1-007200-007300-borspans.idx"sv, "f06a2ba183b61339eea9342a0225e5f5a048a903"sv}, Entry{"v1-007200-007300-borspans.seg"sv, "99268d15e8092d0677a69e9923a35e8db6e63f9a"sv}, Entry{"v1-007200-007300-headers.idx"sv, "c9ffc215e155b1b18c5f97f74dc58fc11f060294"sv}, Entry{"v1-007200-007300-headers.seg"sv, "75c0fc999c3cbd8acad4be872bc65af2f6d236d3"sv}, Entry{"v1-007200-007300-transactions-to-block.idx"sv, "ccbb5c5f96e024c1b9ee6ca2b3a3fc10d30d55f6"sv}, Entry{"v1-007200-007300-transactions.idx"sv, "3a533722a3e85dfba5c1516369536d872a10ab93"sv}, Entry{"v1-007200-007300-transactions.seg"sv, "95fe5c4f5814c5ddbf704facc3d390bf70b39e65"sv}, Entry{"v1-007300-007400-bodies.idx"sv, "20c2ad72881cd6d8bd70268010695eef38469e9b"sv}, Entry{"v1-007300-007400-bodies.seg"sv, "3eb5704d94a910e1772643e685eb36df21a8d0dc"sv}, Entry{"v1-007300-007400-borevents.idx"sv, "42ccd54c6fda7e8e296f74f5e403744a47446bc5"sv}, Entry{"v1-007300-007400-borevents.seg"sv, "09c5ff2cae6cc2f6fd23f3908dda15e6662996e4"sv}, Entry{"v1-007300-007400-borspans.idx"sv, "0d0754a3697d1a71160749148a1bd2a5be42b07e"sv}, Entry{"v1-007300-007400-borspans.seg"sv, "0dd30d5048cc2281124717dad3003d2436844d28"sv}, Entry{"v1-007300-007400-headers.idx"sv, "ad56e8445397d6d3c7772c52d0fc9ae35dcde7f8"sv}, Entry{"v1-007300-007400-headers.seg"sv, "803dbe4e7d146a0372bb30b0e65352c60fb99dfe"sv}, Entry{"v1-007300-007400-transactions-to-block.idx"sv, "44f11a6f1a9b0224d1c23abcf123d7f0931cccb6"sv}, Entry{"v1-007300-007400-transactions.idx"sv, "a198d303dff5f975c33077ba8847bcf2c23471d0"sv}, Entry{"v1-007300-007400-transactions.seg"sv, "52124b229aa743ccef1990dc018fa60ad8c9d5c5"sv}, Entry{"v1-007400-007500-bodies.idx"sv, "73bb54e5cbf6a9d73f7e03a154a1081218e09449"sv}, Entry{"v1-007400-007500-bodies.seg"sv, "1f94bc246ad894b0f9b4b570b247275ca8e51813"sv}, Entry{"v1-007400-007500-borevents.idx"sv, "be3309aa6eecceba0afbedc6ad4bdbe4815f97f6"sv}, Entry{"v1-007400-007500-borevents.seg"sv, "2b05e126e7373191051ddccc1caf89cbe35604a6"sv}, Entry{"v1-007400-007500-borspans.idx"sv, "1c030b19ac03aff8c490479d5441b74f5e29397f"sv}, Entry{"v1-007400-007500-borspans.seg"sv, "55707e5897ebacc8449c9aa6203a8b648fb35b6a"sv}, Entry{"v1-007400-007500-headers.idx"sv, "c946c657841b478ec869e43a62c9be6223ccb54d"sv}, Entry{"v1-007400-007500-headers.seg"sv, "04ec9e19ef5e379c96bc5601f2c3abb9777548a5"sv}, Entry{"v1-007400-007500-transactions-to-block.idx"sv, "99ebf00bc5f52540992f871db73f172f3243154b"sv}, Entry{"v1-007400-007500-transactions.idx"sv, "21aa4c039c6a6b9988366bf65633abbc6d087db1"sv}, Entry{"v1-007400-007500-transactions.seg"sv, "54bba693e6f4c427390787bb07fb0248b0e6d0fa"sv}, Entry{"v1-007500-007600-bodies.idx"sv, "dfc17d4523745f85bf926957d9574f89eccf5cf8"sv}, Entry{"v1-007500-007600-bodies.seg"sv, "95f14680ca199c9ee04157445c67d5974b7428c1"sv}, Entry{"v1-007500-007600-borevents.idx"sv, "519293064f35a0cc71c78c782c670af3417d2fd0"sv}, Entry{"v1-007500-007600-borevents.seg"sv, "bec7590956f8bc2c3c2a624637ae420b64a1520d"sv}, Entry{"v1-007500-007600-borspans.idx"sv, "b74738d47c3cd0d832309beeed293df1d43e0e45"sv}, Entry{"v1-007500-007600-borspans.seg"sv, "8127ecbe2fa283a2a5caaec6411cd6264c780f6a"sv}, Entry{"v1-007500-007600-headers.idx"sv, "85b2e75fb2d09c5fdc7ab2ed3172594cc8043dae"sv}, Entry{"v1-007500-007600-headers.seg"sv, "a1027a170c6c8fd54591f90ab19241dd53443466"sv}, Entry{"v1-007500-007600-transactions-to-block.idx"sv, "7bc08f070ebc294356bd22894426b5c84197b216"sv}, Entry{"v1-007500-007600-transactions.idx"sv, "3c71f549fd1afd30fe9615bea7aee9d3726fa674"sv}, Entry{"v1-007500-007600-transactions.seg"sv, "94cb4123051a95ab3304dfaebc1e83acbef24e3c"sv}, Entry{"v1-007600-007700-bodies.idx"sv, "0a77a7eea02c37e7a452ad52f7f40b21207a98f4"sv}, Entry{"v1-007600-007700-bodies.seg"sv, "1cbf7c6e8b466952f9e086a47d1730caf86865c4"sv}, Entry{"v1-007600-007700-borevents.idx"sv, "18936e094b389f5a078152b1d9608073bcfdec7a"sv}, Entry{"v1-007600-007700-borevents.seg"sv, "3167e2c74c8b3f74fa9808cd107764949debfcdf"sv}, Entry{"v1-007600-007700-borspans.idx"sv, "4ae34b6718cef723015b63f5335386b3b0b993d6"sv}, Entry{"v1-007600-007700-borspans.seg"sv, "16451bd04b677a6625fe16adbd311d120e26829a"sv}, Entry{"v1-007600-007700-headers.idx"sv, "94845cb9ea41dd55fc1e9efc60cddcbeea4fd5e1"sv}, Entry{"v1-007600-007700-headers.seg"sv, "79e5d26bcdf80efe9771dccc504024086e98ce3a"sv}, Entry{"v1-007600-007700-transactions-to-block.idx"sv, "853f437070f5798bb4765694bf012dac9802ccaf"sv}, Entry{"v1-007600-007700-transactions.idx"sv, "ffe5b5296217e27d9d28c8963077e6e3cf2dec17"sv}, Entry{"v1-007600-007700-transactions.seg"sv, "72d1a1961b6db6f0f6e01c871cf821be19aadb39"sv}, Entry{"v1-007700-007800-bodies.idx"sv, "22a3563b86380428bd6210ff3fd58bb68caf56e9"sv}, Entry{"v1-007700-007800-bodies.seg"sv, "75357045932fcc32a21d095117f11eb1ace50a09"sv}, Entry{"v1-007700-007800-borevents.idx"sv, "1dc6ba36ada25a0d5ff60f26b46e666d3e71497a"sv}, Entry{"v1-007700-007800-borevents.seg"sv, "9815e6a3b6772cce8728e894f32cdfab6085a76f"sv}, Entry{"v1-007700-007800-borspans.idx"sv, "cd1d0c2f219cbc1a662dcab9be2654e520215a10"sv}, Entry{"v1-007700-007800-borspans.seg"sv, "21e4b2435f175fc6f366f661ffc77ecba96beca9"sv}, Entry{"v1-007700-007800-headers.idx"sv, "15b572216c22c8cf8fead4b47dc4d1f5024fa954"sv}, Entry{"v1-007700-007800-headers.seg"sv, "f0eab48d64e6fd68c7f4a5ae4c2c3473a12b8c97"sv}, Entry{"v1-007700-007800-transactions-to-block.idx"sv, "08e63fa3806e901ffc64e61a05dba12adfce997b"sv}, Entry{"v1-007700-007800-transactions.idx"sv, "28ef0095505ea0dab6a585c68b934364cc312c01"sv}, Entry{"v1-007700-007800-transactions.seg"sv, "7739b7195e10b173f76d478ab97bbda31799f37e"sv}, Entry{"v1-007800-007900-bodies.idx"sv, "5a641922b37dd6a7e66a57464abf875c286b6da9"sv}, Entry{"v1-007800-007900-bodies.seg"sv, "4c2acaedb6a4d457340f7469fd162e9337590ef9"sv}, Entry{"v1-007800-007900-borevents.idx"sv, "dc3d1b892dbc684fe75c2a864e8e101ddd257f8b"sv}, Entry{"v1-007800-007900-borevents.seg"sv, "4c0e396c54d816e160d94562790efa7177845df8"sv}, Entry{"v1-007800-007900-borspans.idx"sv, "2957a02ffc97f0bf2bed6cef078d41c06993cc88"sv}, Entry{"v1-007800-007900-borspans.seg"sv, "73a22b79a15fd092d444966f11d19e20fc7a657f"sv}, Entry{"v1-007800-007900-headers.idx"sv, "6d973443608f9219e71d6568a7f1301a580b6793"sv}, Entry{"v1-007800-007900-headers.seg"sv, "9f0d25ef8f32dfd478eea895cf968d866e529cfc"sv}, Entry{"v1-007800-007900-transactions-to-block.idx"sv, "af00750f1d18997745f86f00cd0787050e339172"sv}, Entry{"v1-007800-007900-transactions.idx"sv, "fab6d146264f56d568e1f24423fc536fc8620dcb"sv}, Entry{"v1-007800-007900-transactions.seg"sv, "8bad2f608ef44464ee2b9df4b537b60ffcea09ad"sv}, Entry{"v1-007900-008000-bodies.idx"sv, "a8a481255898a67827e350e0f7c71867e59357b9"sv}, Entry{"v1-007900-008000-bodies.seg"sv, "25f1ef8402c1127ca677963fbb9ea426ecd073f6"sv}, Entry{"v1-007900-008000-borevents.idx"sv, "a41aafffb3a9d730717aeed167561e7c0b97c06e"sv}, Entry{"v1-007900-008000-borevents.seg"sv, "8906d0fc873d25d72942cf7e3cf8f171102b6818"sv}, Entry{"v1-007900-008000-borspans.idx"sv, "62b1aec752cdda63f6cfeb98bd31fdbb72ed3ab6"sv}, Entry{"v1-007900-008000-borspans.seg"sv, "af897026c24db1454befdf62d5763a3a7ac1e7ea"sv}, Entry{"v1-007900-008000-headers.idx"sv, "46ac9a9b9a71e243c808d161e1554bcbf7c2652c"sv}, Entry{"v1-007900-008000-headers.seg"sv, "758c901cf62c0732e6f86a7cbcbd45c8679b6e1c"sv}, Entry{"v1-007900-008000-transactions-to-block.idx"sv, "0525e1a78b6ea278abe559073a716f9420c5fc24"sv}, Entry{"v1-007900-008000-transactions.idx"sv, "4918cb45ce707ae2e41b76b4a9ff7f7cd6e0cb3e"sv}, Entry{"v1-007900-008000-transactions.seg"sv, "683c6bf0fcc22de827559a8a86c5d05366997e59"sv}, Entry{"v1-008000-008100-bodies.idx"sv, "68f3bf80bd6c6d65d2eee0387bdffbf2831fda3d"sv}, Entry{"v1-008000-008100-bodies.seg"sv, "ed4fc831957ace339494cdafa5db9daadffcdd89"sv}, Entry{"v1-008000-008100-borevents.idx"sv, "6f9092f11d8c7e765cf7e50f13a142605282ae02"sv}, Entry{"v1-008000-008100-borevents.seg"sv, "6f3db72a5706d731f9c57f503d8d353d199e9077"sv}, Entry{"v1-008000-008100-borspans.idx"sv, "a8e6bb49f3456e96e12cbb6bf76bbc6c02991bb8"sv}, Entry{"v1-008000-008100-borspans.seg"sv, "0541538a9957a2fc0df1f47c42bc47dfdc1f7d66"sv}, Entry{"v1-008000-008100-headers.idx"sv, "90ff96eaa783cb733ef0873f29f84475918da75f"sv}, Entry{"v1-008000-008100-headers.seg"sv, "aa79839a02be09fa0808a0a4396296ca05fa6d19"sv}, Entry{"v1-008000-008100-transactions-to-block.idx"sv, "06b7e2e656321b379c4466edd174ef6e253a28d0"sv}, Entry{"v1-008000-008100-transactions.idx"sv, "16300406740a88b34323906ada99ae777fdb01c6"sv}, Entry{"v1-008000-008100-transactions.seg"sv, "0109649cbd37c0547bbf80f769f039117da031fd"sv}, Entry{"v1-008100-008200-bodies.idx"sv, "9a1e5e9fc30fe7aebdd768cfedf08ecf5c9f87a2"sv}, Entry{"v1-008100-008200-bodies.seg"sv, "45286593dbbdcc52bbe162ca55b9be62194bed53"sv}, Entry{"v1-008100-008200-borevents.idx"sv, "a95e6565756a62ae461b03e5ac55f7a596b1b14d"sv}, Entry{"v1-008100-008200-borevents.seg"sv, "3814d444353b5884595b140ee44a4b6757511413"sv}, Entry{"v1-008100-008200-borspans.idx"sv, "6abfc549482cf0c58c95b5f2102d57b2b5052dae"sv}, Entry{"v1-008100-008200-borspans.seg"sv, "5db1c445b2b45f4dfa22cf15e79bea4b43079c8f"sv}, Entry{"v1-008100-008200-headers.idx"sv, "d4432444206586eeef3bc1a2e355da515f460001"sv}, Entry{"v1-008100-008200-headers.seg"sv, "3ae32bafd4a72a63f2108fee945827c996e423cc"sv}, Entry{"v1-008100-008200-transactions-to-block.idx"sv, "f9b75cf3770408ed42749a01948dbfa0a278de4b"sv}, Entry{"v1-008100-008200-transactions.idx"sv, "01241883f9665717208a2d97beb51e7e779b57f6"sv}, Entry{"v1-008100-008200-transactions.seg"sv, "ecb417afe211b071898b41d36a9b5fe4be014a08"sv}, Entry{"v1-008200-008300-bodies.idx"sv, "b19f3423bf5e47fc5b86c551c570384483ec2f01"sv}, Entry{"v1-008200-008300-bodies.seg"sv, "9d660ef1650bc325a1dff892c227a42dbc92dc55"sv}, Entry{"v1-008200-008300-borevents.idx"sv, "8ec2909879298e71c3e01ab838d92f862f117bf2"sv}, Entry{"v1-008200-008300-borevents.seg"sv, "3932cfed651a6b66cd0c7b6a782684dd344750ac"sv}, Entry{"v1-008200-008300-borspans.idx"sv, "de02ecf00d7ef3664e1de78c50e2bbaf1db1f296"sv}, Entry{"v1-008200-008300-borspans.seg"sv, "961ee2931d6d1bb76a44ccc2cefb2348a0ae3b70"sv}, Entry{"v1-008200-008300-headers.idx"sv, "46fe2c685dc3062bf82372f013f398999379cefb"sv}, Entry{"v1-008200-008300-headers.seg"sv, "37d60ca4d4ee0760fe79249525ba42b1070295e1"sv}, Entry{"v1-008200-008300-transactions-to-block.idx"sv, "ce022d4a4ee43aea0b4eeeec248684edd8fe3d4a"sv}, Entry{"v1-008200-008300-transactions.idx"sv, "9d3907c4f00828c7a36fef67f2de01f88ca63500"sv}, Entry{"v1-008200-008300-transactions.seg"sv, "eebf1b5df62ec14150f5feca23b68d2af8b01502"sv}, Entry{"v1-008300-008400-bodies.idx"sv, "44a67c2c4823b1ede812c7dcc68c55b5e03d0a14"sv}, Entry{"v1-008300-008400-bodies.seg"sv, "c76ceea2b320a3e9accdcabb645ce909e4363e0b"sv}, Entry{"v1-008300-008400-borevents.idx"sv, "00e4e0f555635dae5378f676d7f88c11107f0c12"sv}, Entry{"v1-008300-008400-borevents.seg"sv, "bfe4407e359183c6e7547f6cccc6423606278a46"sv}, Entry{"v1-008300-008400-borspans.idx"sv, "85b709060f1e34d76b8170508088961cdf2a068a"sv}, Entry{"v1-008300-008400-borspans.seg"sv, "27f1ae799c71509aad0cffdf034e9a8e830fd60f"sv}, Entry{"v1-008300-008400-headers.idx"sv, "f68a67c28757b6e394e6c689b3ab38149eb7ed69"sv}, Entry{"v1-008300-008400-headers.seg"sv, "074cc344dd0d9cf032178b53bc645641c7932915"sv}, Entry{"v1-008300-008400-transactions-to-block.idx"sv, "b38334403b501ad490d69790e703d0b898f9d1d2"sv}, Entry{"v1-008300-008400-transactions.idx"sv, "2f1c0473558b5865219c9edd3623dbe118b3d642"sv}, Entry{"v1-008300-008400-transactions.seg"sv, "e15e721e2b4f003d8e3c89081c97c003eeb3a54b"sv}, Entry{"v1-008400-008500-bodies.idx"sv, "c9f085ad4c45c4c9f545001d59ef1b2afbf194f9"sv}, Entry{"v1-008400-008500-bodies.seg"sv, "dd8d09a7e372f50f26f56ef1c5f682458d3aeab8"sv}, Entry{"v1-008400-008500-borevents.idx"sv, "48139f07693be8eb2f31da07c2aaa3f292d438a4"sv}, Entry{"v1-008400-008500-borevents.seg"sv, "51b682a3bd6983f4c026d815ba093bce4c1a9710"sv}, Entry{"v1-008400-008500-borspans.idx"sv, "630f1fe7dd792fde2472e6b74ce6a3bf005ff1bd"sv}, Entry{"v1-008400-008500-borspans.seg"sv, "1a83a951c9a6782896218ff7e5987c6d2e2a3c9d"sv}, Entry{"v1-008400-008500-headers.idx"sv, "7708f92c2d38c69f006f6e247c95fd7744400a11"sv}, Entry{"v1-008400-008500-headers.seg"sv, "2f3aec23f2bf79dad1751f5e03c00f0845f9b3dd"sv}, Entry{"v1-008400-008500-transactions-to-block.idx"sv, "23d6403ec8ecbbb1c77214802b781a03b471fd04"sv}, Entry{"v1-008400-008500-transactions.idx"sv, "96343c3d707c2060cd779d209a1d4d1ef6f98285"sv}, Entry{"v1-008400-008500-transactions.seg"sv, "2359a92c8bc0292223a7ca462f759d8ee5e6df87"sv}, Entry{"v1-008500-008600-bodies.idx"sv, "db9d3146bc631aa1def38608287eece4fef808fc"sv}, Entry{"v1-008500-008600-bodies.seg"sv, "bdfb5a18a73df9d23e0d014b334f8a94a2661f8c"sv}, Entry{"v1-008500-008600-borevents.idx"sv, "3980789a77cd07341712cbbd25f5e315f3ed2a06"sv}, Entry{"v1-008500-008600-borevents.seg"sv, "9e706ce59b204a83f869f5c83f2ad0acc99f8ba9"sv}, Entry{"v1-008500-008600-borspans.idx"sv, "556c52b7e2666b122d4a2be50b0333d456208c2f"sv}, Entry{"v1-008500-008600-borspans.seg"sv, "a4367bf58dcf57cf54c6e8a2cc6b46653e1e3a96"sv}, Entry{"v1-008500-008600-headers.idx"sv, "f3fc686b316be18699f132655c99afe7dee27036"sv}, Entry{"v1-008500-008600-headers.seg"sv, "480faf73d70727dc3d95a18c9b06699e429d6332"sv}, Entry{"v1-008500-008600-transactions-to-block.idx"sv, "b8d678fd4c30162e8819d940fd0de394f08c880d"sv}, Entry{"v1-008500-008600-transactions.idx"sv, "8b2f75978ab82a0edc2c6fb4afaf9d427d6ed51b"sv}, Entry{"v1-008500-008600-transactions.seg"sv, "a9bd683588713de48489e092321a0fbe6177530e"sv}, Entry{"v1-008600-008700-bodies.idx"sv, "03b71e63671ae93a948454a6d196e9e4ed0ff72f"sv}, Entry{"v1-008600-008700-bodies.seg"sv, "7dab7314bc95c20464b77a627f4dec581f4a85b7"sv}, Entry{"v1-008600-008700-borevents.idx"sv, "cd759b340884a7cc298f477426daea9436eccde4"sv}, Entry{"v1-008600-008700-borevents.seg"sv, "9259835531f8be081033172bcb52e96148b2ccb8"sv}, Entry{"v1-008600-008700-borspans.idx"sv, "3ec1f63233b4225f2da97933c81d46a750ae0f1c"sv}, Entry{"v1-008600-008700-borspans.seg"sv, "cd3c96bb5a01a71d618644cf78a74c9dfadc3607"sv}, Entry{"v1-008600-008700-headers.idx"sv, "facb2b7bc2947e1334a5b02323969bd43e8fb80a"sv}, Entry{"v1-008600-008700-headers.seg"sv, "29b24a7cec91181d957837e76b3ec1cf7d345a5e"sv}, Entry{"v1-008600-008700-transactions-to-block.idx"sv, "67b439a31cd7262f85c44ff31cb2ab08bd34a439"sv}, Entry{"v1-008600-008700-transactions.idx"sv, "50d71f4625d9c4ae065c3163685db4ed2cfaac6a"sv}, Entry{"v1-008600-008700-transactions.seg"sv, "b528b02987797c067a59b308a3e2e2d58fefa4a0"sv}, Entry{"v1-008700-008800-bodies.idx"sv, "1f605dc47dfa92f6907dda5f1ccc6bb54ed531f5"sv}, Entry{"v1-008700-008800-bodies.seg"sv, "fc1e3b2e70bfb8d26a692ee529d024953ad91af1"sv}, Entry{"v1-008700-008800-borevents.idx"sv, "a73368d27a734e2b2f46b460664048d61b8930f6"sv}, Entry{"v1-008700-008800-borevents.seg"sv, "a2dd69622ed0a60b23d54d9f09cd1951646c5f7e"sv}, Entry{"v1-008700-008800-borspans.idx"sv, "ce5e067a044692d5a5c838c9ea2d6fb94092bb3f"sv}, Entry{"v1-008700-008800-borspans.seg"sv, "1093bad7c38d8169334b1716926968f01a501d18"sv}, Entry{"v1-008700-008800-headers.idx"sv, "d9343c119a79066deccf4936e3719698a61030d0"sv}, Entry{"v1-008700-008800-headers.seg"sv, "f5024a77de02ae79f4a1120958ac340b97d0f1ee"sv}, Entry{"v1-008700-008800-transactions-to-block.idx"sv, "6436db17d97a8b363221d550e96052f938399a1f"sv}, Entry{"v1-008700-008800-transactions.idx"sv, "b77b83182026a3f235c12b272a3a57c98d17b572"sv}, Entry{"v1-008700-008800-transactions.seg"sv, "d9c0ca9e4e6017e3d4a7b0ea512c1f65da3672d3"sv}, Entry{"v1-008800-008900-bodies.idx"sv, "fadbd3f95a68ab9c3660f3b4d370c3b20d0c8ee8"sv}, Entry{"v1-008800-008900-bodies.seg"sv, "0fa803365df87b506bad5c8136d494d81b2125ab"sv}, Entry{"v1-008800-008900-borevents.idx"sv, "21f7d52c8ce161802d43ccf00c349c892eaa9638"sv}, Entry{"v1-008800-008900-borevents.seg"sv, "5324becae2b7809bc34ccfa59bbae98c9322691a"sv}, Entry{"v1-008800-008900-borspans.idx"sv, "dc2e01963b7caa97f0eb0326ab627c900a2e8854"sv}, Entry{"v1-008800-008900-borspans.seg"sv, "ed600647ada24148545327ebd672af309c5d1378"sv}, Entry{"v1-008800-008900-headers.idx"sv, "d4d19e107443eb06cbeb06e145bf3bfd983de373"sv}, Entry{"v1-008800-008900-headers.seg"sv, "55e4210a7752fd67d5af57fd4a1cf867de9d61ce"sv}, Entry{"v1-008800-008900-transactions-to-block.idx"sv, "9be742bd829d68c777cbbaa9a923d7e4f2c65311"sv}, Entry{"v1-008800-008900-transactions.idx"sv, "6aab3923fa9cfe37cf854f1fc459b0dbdfcb252a"sv}, Entry{"v1-008800-008900-transactions.seg"sv, "7f9520b3cef7b4cf640a9f598212639c643e1266"sv}, Entry{"v1-008900-009000-bodies.idx"sv, "0ba2211f22e7da56f3f45bc2bd4114fe7ba44600"sv}, Entry{"v1-008900-009000-bodies.seg"sv, "5132a5f8391e04b664c48c4b401155f8816301e3"sv}, Entry{"v1-008900-009000-borevents.idx"sv, "510c3a5989a87fc4687f5b4fe7446bd04e376d94"sv}, Entry{"v1-008900-009000-borevents.seg"sv, "7917f49d7154b26e658ae9349ff23754b824c351"sv}, Entry{"v1-008900-009000-borspans.idx"sv, "2e59f3422b50d87f984863d6d0d4911b0aa327a8"sv}, Entry{"v1-008900-009000-borspans.seg"sv, "b5fb99de8805d4135ae69c189ffb78e9a79f2954"sv}, Entry{"v1-008900-009000-headers.idx"sv, "9cc057108654442cf0f1da202da2c6250ac867a8"sv}, Entry{"v1-008900-009000-headers.seg"sv, "8c25744a66218c9fddb9401ce5084116f204ff67"sv}, Entry{"v1-008900-009000-transactions-to-block.idx"sv, "d5a03ad6af6c5837489bc4ea8b52fd15c94c9e6f"sv}, Entry{"v1-008900-009000-transactions.idx"sv, "5d305af93bdf8ac71344839423d68758c00ac122"sv}, Entry{"v1-008900-009000-transactions.seg"sv, "2e34349eb7a66a1c91b02b3f4d4f626025f2d92e"sv}, Entry{"v1-009000-009100-bodies.idx"sv, "6d365145d11b1e68e5ec4eca117de000c8350aac"sv}, Entry{"v1-009000-009100-bodies.seg"sv, "5bebc6b5a28dc43e4cf192a149ebe7d8dee9a6ef"sv}, Entry{"v1-009000-009100-borevents.idx"sv, "793a2ae10df881c07789cb67aad5ed8fe584c9e8"sv}, Entry{"v1-009000-009100-borevents.seg"sv, "f8e61fa511216df4e67f9c06bd5ff98b3ed9c70f"sv}, Entry{"v1-009000-009100-borspans.idx"sv, "d0580196f8eb1f824f9e136fd62b33a70ac5b144"sv}, Entry{"v1-009000-009100-borspans.seg"sv, "bc68608b4910e479b78244b210cb22e2be9cb1d1"sv}, Entry{"v1-009000-009100-headers.idx"sv, "8cc17802c0a0a0440aac09963a893d126635c87f"sv}, Entry{"v1-009000-009100-headers.seg"sv, "b883617069e2f4f7aa58e7a8a89390e62ea2077c"sv}, Entry{"v1-009000-009100-transactions-to-block.idx"sv, "620f79ae8c749e4a0ad1e6136d61d45ce98b96aa"sv}, Entry{"v1-009000-009100-transactions.idx"sv, "63824abf96d754d50c9af26f04fa426fd08a70ee"sv}, Entry{"v1-009000-009100-transactions.seg"sv, "d7dda9cda2a016125d15d0103d0864ab795bc911"sv}, Entry{"v1-009100-009200-bodies.idx"sv, "76882a2ef0cc296f57ac738f74411c748df90ae9"sv}, Entry{"v1-009100-009200-bodies.seg"sv, "79467d16865ef4b57b0908e93f0c83912bc98905"sv}, Entry{"v1-009100-009200-borevents.idx"sv, "08b371ba44d6378d7d7b3c6cb2bfcad2cadf0862"sv}, Entry{"v1-009100-009200-borevents.seg"sv, "6423f1a2683d317af66b115d807a9936803fcf37"sv}, Entry{"v1-009100-009200-borspans.idx"sv, "2f41c7cb9045e0b6fd2dbba0100b369f01033037"sv}, Entry{"v1-009100-009200-borspans.seg"sv, "bb1fa5ee0abe3f42b9ac326f7b81c622e27a025b"sv}, Entry{"v1-009100-009200-headers.idx"sv, "abcc6ba227072e4567dc37f71b3d947adeb63390"sv}, Entry{"v1-009100-009200-headers.seg"sv, "293586240ddd7e675f9d53a140fd7f740760af6d"sv}, Entry{"v1-009100-009200-transactions-to-block.idx"sv, "a15526cd4a4497ad455a7b0f3450d612a9fe7e95"sv}, Entry{"v1-009100-009200-transactions.idx"sv, "fb8a5d82c681af46ba734c2a5b44ba67b01d68ee"sv}, Entry{"v1-009100-009200-transactions.seg"sv, "4cf9efba3fc2841f3089ddab52e14f848fb4f389"sv}, Entry{"v1-009200-009300-bodies.idx"sv, "03b4155c6c50753c0d239cd965be8e6c12c4e037"sv}, Entry{"v1-009200-009300-bodies.seg"sv, "39e17914c75f65cb509bfb55fe68ad912e29f44e"sv}, Entry{"v1-009200-009300-borevents.idx"sv, "b1df1bbedbf55bc1a45bb681557aebf2565495d0"sv}, Entry{"v1-009200-009300-borevents.seg"sv, "cc7d18464d37a81efe8e3e224b3c53228a33c108"sv}, Entry{"v1-009200-009300-borspans.idx"sv, "162689357d71ed8602089c8f92519cbdd6d7b2b9"sv}, Entry{"v1-009200-009300-borspans.seg"sv, "033af2c3d8ba519893c5a6e3c276520759c42703"sv}, Entry{"v1-009200-009300-headers.idx"sv, "70a686fcf20b681558801be567d8305fef3f2bbc"sv}, Entry{"v1-009200-009300-headers.seg"sv, "b781d7da7c59fbbf97702aa4949ae20d25c06ac0"sv}, Entry{"v1-009200-009300-transactions-to-block.idx"sv, "19948bd84582d7ecc56160f1580399fb667d064f"sv}, Entry{"v1-009200-009300-transactions.idx"sv, "b76356ed158cad242fc08dd7ff08a2f77ce6048b"sv}, Entry{"v1-009200-009300-transactions.seg"sv, "b9abfba2944eebcc9d1b4d02b11392e56ea27c6d"sv}, Entry{"v1-009300-009400-bodies.idx"sv, "3d35ab96710592c947044b4b845efafa3d2e171c"sv}, Entry{"v1-009300-009400-bodies.seg"sv, "1dce15f1b8f1ed057ae2a3001a421624e61c9ccc"sv}, Entry{"v1-009300-009400-borevents.idx"sv, "59ae81d057993cc4c710c32d860b237eed000d9b"sv}, Entry{"v1-009300-009400-borevents.seg"sv, "f5cbffa8de2af0bbb5151f87a7be92aa451b9910"sv}, Entry{"v1-009300-009400-borspans.idx"sv, "4a184c3e19f41600d59bca987909984dd15bbd2a"sv}, Entry{"v1-009300-009400-borspans.seg"sv, "39ddbede7d0993459d4092962f87a20f6f6a83ab"sv}, Entry{"v1-009300-009400-headers.idx"sv, "8a76af818fe9cd686e7d623d514fad9fc6c49e56"sv}, Entry{"v1-009300-009400-headers.seg"sv, "175c731bb17d44f375b230201623e76dc4161d04"sv}, Entry{"v1-009300-009400-transactions-to-block.idx"sv, "d476e7fa31ff856f4373b8bddc610386dc9a1838"sv}, Entry{"v1-009300-009400-transactions.idx"sv, "2a0fa8e9beeccaab5f92561d6db44a605a9dcbcc"sv}, Entry{"v1-009300-009400-transactions.seg"sv, "703d5d8068a63146c5e60cab458a4e926753cc22"sv}, Entry{"v1-009400-009500-bodies.idx"sv, "a644ddce89ac258525a6c707ac44614320d5b2cf"sv}, Entry{"v1-009400-009500-bodies.seg"sv, "bcfe4496986981a2d244bf86fccbbef268873590"sv}, Entry{"v1-009400-009500-borevents.idx"sv, "bc0a742378d2c1db8e9cb5d8f866488be42b0cdc"sv}, Entry{"v1-009400-009500-borevents.seg"sv, "71dee0bbffefde2df8f2be54c7da528aedf12651"sv}, Entry{"v1-009400-009500-borspans.idx"sv, "41a584c0b93e74354827b51edc457ebcb88a24e7"sv}, Entry{"v1-009400-009500-borspans.seg"sv, "6b7368926c9ffe59dc0b243b6e4a73360f61f594"sv}, Entry{"v1-009400-009500-headers.idx"sv, "6ec01402bdbcc544a6084839bacd3d267d34431c"sv}, Entry{"v1-009400-009500-headers.seg"sv, "f91856ec2e6aa60c308bf0a737b1fc2658104c9f"sv}, Entry{"v1-009400-009500-transactions-to-block.idx"sv, "63a49866e1d9b139dbca9ca1024b5fede075ff5a"sv}, Entry{"v1-009400-009500-transactions.idx"sv, "0c2a2c0d81a9e1aa9b48cd55bc9511c089973a20"sv}, Entry{"v1-009400-009500-transactions.seg"sv, "c0387aa4d070e0955b033480559f53c7f630672e"sv}, Entry{"v1-009500-009600-bodies.idx"sv, "88c2eb29d35b6b30d9c9571dc7feb61ed9591ae2"sv}, Entry{"v1-009500-009600-bodies.seg"sv, "68e58f4236dffa752eebbfd9f51a0ff716cf7330"sv}, Entry{"v1-009500-009600-borevents.idx"sv, "0b80a541afe640280f0e9b1af0db3ed4330023c4"sv}, Entry{"v1-009500-009600-borevents.seg"sv, "2b25d105e8b261c9370efa694a5b95a726bceb90"sv}, Entry{"v1-009500-009600-borspans.idx"sv, "4e482cfb2120813515f71c793753daab6f4fa464"sv}, Entry{"v1-009500-009600-borspans.seg"sv, "5698dc31cf8f30ff0c47407a850992a1ddc548b0"sv}, Entry{"v1-009500-009600-headers.idx"sv, "8badab5f5051807b2fc327ab28c708de81ae9cb5"sv}, Entry{"v1-009500-009600-headers.seg"sv, "6f089be8e1fac8011d53e56cb895a4f7aeb10c7e"sv}, Entry{"v1-009500-009600-transactions-to-block.idx"sv, "2e88c3783d757ee748586f1b5bcdd051fd5eda8b"sv}, Entry{"v1-009500-009600-transactions.idx"sv, "959772c8d5a7573f14d8bc4c77878066d10d8c1d"sv}, Entry{"v1-009500-009600-transactions.seg"sv, "beb5776b5d0a64267f9be964f28891e100b71440"sv}, Entry{"v1-009600-009700-bodies.idx"sv, "c249ca877487b34b3b68c7872f65cf8e1c5b8363"sv}, Entry{"v1-009600-009700-bodies.seg"sv, "83594bcb920ff692b8503347dcd3332de31cd15c"sv}, Entry{"v1-009600-009700-borevents.idx"sv, "4bc6ed8cf5f4f5d61c73f5dcc2c84db17680b1a8"sv}, Entry{"v1-009600-009700-borevents.seg"sv, "58db6e6065afd4dbcaa1858766053843a2875c6c"sv}, Entry{"v1-009600-009700-borspans.idx"sv, "bde2b7c077dff2c649218bd9c64b1f4fedad53dd"sv}, Entry{"v1-009600-009700-borspans.seg"sv, "53fd9196d87e144c2b26c30a3abdecd5ff44d03d"sv}, Entry{"v1-009600-009700-headers.idx"sv, "b36fd08df11757133ba0a43e40bb6398068fd90f"sv}, Entry{"v1-009600-009700-headers.seg"sv, "403215fd97497d3f73c8ace44dcb4c2deea7886b"sv}, Entry{"v1-009600-009700-transactions-to-block.idx"sv, "b9ff37715c00b00d24f1599f8c75db79313fce49"sv}, Entry{"v1-009600-009700-transactions.idx"sv, "80adcc9767e8139e8107db99199deb6794115c92"sv}, Entry{"v1-009600-009700-transactions.seg"sv, "9bef4b24d8f21fce5da4729d918d90d9da739505"sv}, Entry{"v1-009700-009800-bodies.idx"sv, "6674910bda75ca8dd95976a76e97cd30f02a08c5"sv}, Entry{"v1-009700-009800-bodies.seg"sv, "5eb6744799cfb8287170d4a56f3120573d955682"sv}, Entry{"v1-009700-009800-borevents.idx"sv, "f86cac6c9af7aebfcf5ee94a67d05acebbeb9f5c"sv}, Entry{"v1-009700-009800-borevents.seg"sv, "266df3c003dc443f2c429212692d6c15dedb6222"sv}, Entry{"v1-009700-009800-borspans.idx"sv, "be87c3ed040bb48c650822e824f05ebea0029f45"sv}, Entry{"v1-009700-009800-borspans.seg"sv, "dca67da60979e364dfc2e8c43a71efabaf3af524"sv}, Entry{"v1-009700-009800-headers.idx"sv, "f7234e05b38678d3c92e6ef8968648f05001fe25"sv}, Entry{"v1-009700-009800-headers.seg"sv, "25980d61767b32e983a061999f98efdefb1d67ae"sv}, Entry{"v1-009700-009800-transactions-to-block.idx"sv, "ef937a147142e7d733fccb406c547f1f38a7d49d"sv}, Entry{"v1-009700-009800-transactions.idx"sv, "319bcfaf597ffafbb0d6b1387790da3c7751907b"sv}, Entry{"v1-009700-009800-transactions.seg"sv, "e357f4f7096a8db360790a496e469055e7138e77"sv}, Entry{"v1-009800-009900-bodies.idx"sv, "950bc9a56a20f4d5ef94769041e551dfca1dd107"sv}, Entry{"v1-009800-009900-bodies.seg"sv, "3484af40a975d68db6f51ce6dda67b526d5a6e11"sv}, Entry{"v1-009800-009900-borevents.idx"sv, "ae8fc37f43d4f0388b2ec7a0f4f5328031840386"sv}, Entry{"v1-009800-009900-borevents.seg"sv, "7cf90ac6ffb22ce0afe2375acdecdb983ee98edd"sv}, Entry{"v1-009800-009900-borspans.idx"sv, "120b4406094411d985ed95f2902540c26a4112c2"sv}, Entry{"v1-009800-009900-borspans.seg"sv, "93584c592c798b85fe0373e46f7b8f6807d79b08"sv}, Entry{"v1-009800-009900-headers.idx"sv, "c257e9494de434772e935ff9ebe5be9b7c5e8d31"sv}, Entry{"v1-009800-009900-headers.seg"sv, "42d21ba93439e518d1452f355c9c6fc9f1460dd7"sv}, Entry{"v1-009800-009900-transactions-to-block.idx"sv, "a5ec0ca182049ba466a0a750280f0e64f06c5669"sv}, Entry{"v1-009800-009900-transactions.idx"sv, "f02615b3fdd7b8a532199b64f3cc1692da15c62e"sv}, Entry{"v1-009800-009900-transactions.seg"sv, "a957c7e56a48e1fbd5fae0db06c3ecaa12b4dd32"sv}, Entry{"v1-009900-010000-bodies.idx"sv, "529ac34a9ddf0b7866eb016fdb60eff3badaa305"sv}, Entry{"v1-009900-010000-bodies.seg"sv, "0487f4de7f8c31eb455e9c774c1816630f9a2cbb"sv}, Entry{"v1-009900-010000-borevents.idx"sv, "9ef4f70822639eec2c0f3e835fdb21fc1cb30b6c"sv}, Entry{"v1-009900-010000-borevents.seg"sv, "815f2e25c1dec37ab9166884403088da2878d163"sv}, Entry{"v1-009900-010000-borspans.idx"sv, "8a001e84bf0b6b46a0929fbff8a75a283db97ef8"sv}, Entry{"v1-009900-010000-borspans.seg"sv, "1f452a165dac0efaa63081d4b56eee9167fe1247"sv}, Entry{"v1-009900-010000-headers.idx"sv, "17e6711fa67b9554cfc03633b351a7b617cf8f34"sv}, Entry{"v1-009900-010000-headers.seg"sv, "8f7ce8106189bc5fa6c2aced9de28c3b38d77c85"sv}, Entry{"v1-009900-010000-transactions-to-block.idx"sv, "b68446512385c8c24c44c3b139ecbc9c0a0afa93"sv}, Entry{"v1-009900-010000-transactions.idx"sv, "9cf0a2216ffc13b597ccb2311cd6e65c4e5982c1"sv}, Entry{"v1-009900-010000-transactions.seg"sv, "fe41c0181d03163ef40007688e97e747ad8b00ad"sv}, Entry{"v1-010000-010100-bodies.idx"sv, "931b25ed89550f2c4ba810807da46a99b71f8749"sv}, Entry{"v1-010000-010100-bodies.seg"sv, "6d8eb455f8a476f1790ef1dbb63e7787412bbc2f"sv}, Entry{"v1-010000-010100-borevents.idx"sv, "9f3f1c88e3a916fd37951ae3b866cc18ab49711b"sv}, Entry{"v1-010000-010100-borevents.seg"sv, "2b47bd1e217115ecd21f16a0c8db2097065986ab"sv}, Entry{"v1-010000-010100-borspans.idx"sv, "6149654891f279b4b5ed452a5749ef4ea33c3d76"sv}, Entry{"v1-010000-010100-borspans.seg"sv, "eb189db0f8d425d9c3112dfa7b2ac6f4a92bb9c0"sv}, Entry{"v1-010000-010100-headers.idx"sv, "655effad2c7103167c6921bf4b90b7b1c5ec37ed"sv}, Entry{"v1-010000-010100-headers.seg"sv, "74e8d0ea0b6a1b05e7040aa28c5e6ba676df2ff1"sv}, Entry{"v1-010000-010100-transactions-to-block.idx"sv, "e41659a0d4b0cef855889b9acb149a58f72dd242"sv}, Entry{"v1-010000-010100-transactions.idx"sv, "c430a2d6c04a35cd09e83ba8c18d2e275b30e8c2"sv}, Entry{"v1-010000-010100-transactions.seg"sv, "e2c47e3f1139cca912de3675b84971356decf7e0"sv}, Entry{"v1-010100-010200-bodies.idx"sv, "afeb9c56d2cb9674ae7e775def153f22f0c439d1"sv}, Entry{"v1-010100-010200-bodies.seg"sv, "99dd918fb1d73d87107131a8efbe51fc78a7719f"sv}, Entry{"v1-010100-010200-borevents.idx"sv, "78c2254da2cac5ad7dc6359e1ee8eee43e2ca68d"sv}, Entry{"v1-010100-010200-borevents.seg"sv, "6e714ed5bf8bec4317315bfb10d376613edde44b"sv}, Entry{"v1-010100-010200-borspans.idx"sv, "6221ee821b53b8c89365799dd29fdf52e9a7dc16"sv}, Entry{"v1-010100-010200-borspans.seg"sv, "06923c36cb7562f54ed338dfd5aba37e6cd9220b"sv}, Entry{"v1-010100-010200-headers.idx"sv, "6cf6b7d530341e00a9fd3ebbced9f79fe2a26417"sv}, Entry{"v1-010100-010200-headers.seg"sv, "daf78306085c2cf0e90b0955a7e55701aba7ebc6"sv}, Entry{"v1-010100-010200-transactions-to-block.idx"sv, "eba438af9bae47851a26be234eef8f67c858e6fb"sv}, Entry{"v1-010100-010200-transactions.idx"sv, "2f00cc94891db4e7bf66afc7c3345770ce645c2f"sv}, Entry{"v1-010100-010200-transactions.seg"sv, "446268a44c7a40401c147f73b61b54c233e1259e"sv}, Entry{"v1-010200-010300-bodies.idx"sv, "80b1f8f95fe347837686f5364be6337e74b2ffb3"sv}, Entry{"v1-010200-010300-bodies.seg"sv, "70079f63e84670a8ca746e6dc49ab149492e5803"sv}, Entry{"v1-010200-010300-borevents.idx"sv, "276dfac88fcb02cd46cce98344afcea0a2db8836"sv}, Entry{"v1-010200-010300-borevents.seg"sv, "ea43373c8101b9b1f30619b9570d7ccf4ae3152f"sv}, Entry{"v1-010200-010300-borspans.idx"sv, "9464db226f376a1a63a8e198c53f44ffbf68d016"sv}, Entry{"v1-010200-010300-borspans.seg"sv, "874e4f1f615ec94ef5b51d9b78763d32de68673b"sv}, Entry{"v1-010200-010300-headers.idx"sv, "a6ff21b61c1c0468e4714ef360e3fa2228a67bfc"sv}, Entry{"v1-010200-010300-headers.seg"sv, "86199e87378ae407db19bd88b262f4fb0c69f6c1"sv}, Entry{"v1-010200-010300-transactions-to-block.idx"sv, "2338ab6007d1f1da5be3a3d8e9752a670f8561d3"sv}, Entry{"v1-010200-010300-transactions.idx"sv, "b0a4ea38c10c3a0547ad59d83d89ea9c3fb7b554"sv}, Entry{"v1-010200-010300-transactions.seg"sv, "6fdb5de1f609fd134d787f81effe3cdb915ffdc9"sv}, Entry{"v1-010300-010400-bodies.idx"sv, "376991147ffdabd654a42cc4b83104bf7709c2a8"sv}, Entry{"v1-010300-010400-bodies.seg"sv, "f55247cd210aea653e5fa576e2e84edaf4438258"sv}, Entry{"v1-010300-010400-borevents.idx"sv, "1370f3b4c8065ad291aaad0720cbb45cc8fef774"sv}, Entry{"v1-010300-010400-borevents.seg"sv, "169a153166d33bb1eedca1ec3d2822c6b1558b90"sv}, Entry{"v1-010300-010400-borspans.idx"sv, "7e55bf1df1bb2d0bc6c22f997e0411bc14dc2df0"sv}, Entry{"v1-010300-010400-borspans.seg"sv, "4ac4285a9a0776cc0ef904d16c28ef4bda9098d4"sv}, Entry{"v1-010300-010400-headers.idx"sv, "85d23d0b4a7e3d6dc00f46919dc760d8dd5461ec"sv}, Entry{"v1-010300-010400-headers.seg"sv, "7d3cc519f7b71e867494cf1bf7aad93b4a50adc1"sv}, Entry{"v1-010300-010400-transactions-to-block.idx"sv, "0eeb62e2f37e08057774862b938fb3f8ea87a777"sv}, Entry{"v1-010300-010400-transactions.idx"sv, "61ea2d897700c66ce8ef6e9331fb75c0d10d2c4a"sv}, Entry{"v1-010300-010400-transactions.seg"sv, "6327a248dc7f2fb37e6ce24e3d8435e3a234d928"sv}, Entry{"v1-010400-010500-bodies.idx"sv, "80c7b22e1f18ffee494a9334f135122385e7d103"sv}, Entry{"v1-010400-010500-bodies.seg"sv, "6ba7fba0128751746de49a7521d4cfab9083df34"sv}, Entry{"v1-010400-010500-borevents.idx"sv, "2fff963c4c4234a738865b1cf5ff85d08de3c189"sv}, Entry{"v1-010400-010500-borevents.seg"sv, "b5f2f78128c57c16310e657bf8aa78980e9715e8"sv}, Entry{"v1-010400-010500-borspans.idx"sv, "83493d4df8b23f073861c763c60e31c1d060326b"sv}, Entry{"v1-010400-010500-borspans.seg"sv, "07e444b9538ddb0e07e3754d40cf16cff86c054c"sv}, Entry{"v1-010400-010500-headers.idx"sv, "e6e0b1a32b424698e6c7f398bfe475f1c5c59001"sv}, Entry{"v1-010400-010500-headers.seg"sv, "95eccc57205aecdb12d2b845e49ea863179bb8f7"sv}, Entry{"v1-010400-010500-transactions-to-block.idx"sv, "cfeda186840fb552649c6a0731538324243438a5"sv}, Entry{"v1-010400-010500-transactions.idx"sv, "bd8365e1749911969021cc950d4ac6833253917c"sv}, Entry{"v1-010400-010500-transactions.seg"sv, "3320cf6c06ff2d8f8c6adbc1344997a496f584da"sv}, Entry{"v1-010500-010600-bodies.idx"sv, "e69e74ba7e95527c8d775961e5b199d833dd2397"sv}, Entry{"v1-010500-010600-bodies.seg"sv, "8d2c142d10206484f7abb037da5cd62ba1fcc5df"sv}, Entry{"v1-010500-010600-borevents.idx"sv, "7ad29adeed078b95a021259e3ded64b4c1c720cd"sv}, Entry{"v1-010500-010600-borevents.seg"sv, "72d0241975c4df41f1a3c25a56d61179fd4320eb"sv}, Entry{"v1-010500-010600-borspans.idx"sv, "70e6aec1ba8a6d7990f2e5d932c6a488b43d25cf"sv}, Entry{"v1-010500-010600-borspans.seg"sv, "f4ee67e1cfdb2ce1f1160367e67630045bc5b896"sv}, Entry{"v1-010500-010600-headers.idx"sv, "9234808bf8202efa57099488eb4bc2084e214d56"sv}, Entry{"v1-010500-010600-headers.seg"sv, "24d97b45533e08e1d863e8189f5fc4ec3a2369ec"sv}, Entry{"v1-010500-010600-transactions-to-block.idx"sv, "7f2f78ac5424b6c79986380d0a37ee0760b693db"sv}, Entry{"v1-010500-010600-transactions.idx"sv, "2511d794e06eaa45d6ce8d9ba5457fa6a5affd05"sv}, Entry{"v1-010500-010600-transactions.seg"sv, "1ace2bc38485887756f6475b2154dc0f48f54645"sv}, Entry{"v1-010600-010700-bodies.idx"sv, "51605b99bdce5ce34d7bc1dc1aa24d1d409260fc"sv}, Entry{"v1-010600-010700-bodies.seg"sv, "548eca97dd63402d3e39bc23abf3b39d20a94358"sv}, Entry{"v1-010600-010700-borevents.idx"sv, "de13d3714df49801785de0b3988282d68c936bed"sv}, Entry{"v1-010600-010700-borevents.seg"sv, "b27faf66ce825bb55b61547abb77714a492b291d"sv}, Entry{"v1-010600-010700-borspans.idx"sv, "1415cf1f9ca511dd20080e733118e9f44967f974"sv}, Entry{"v1-010600-010700-borspans.seg"sv, "f18b87fd0a72dee4ed3be02b8d12e3fadd80f2e8"sv}, Entry{"v1-010600-010700-headers.idx"sv, "12582c8f5cbe5c21566fa99318b42bd6c715dbb1"sv}, Entry{"v1-010600-010700-headers.seg"sv, "48f20c801c0e99b8247f8175b904f09e7a1c6e86"sv}, Entry{"v1-010600-010700-transactions-to-block.idx"sv, "40854a90bc5d9809051996ef4be2f7e4de3a2de4"sv}, Entry{"v1-010600-010700-transactions.idx"sv, "7a5e0fe34626eb012cef9391fb58f089fec7d6c5"sv}, Entry{"v1-010600-010700-transactions.seg"sv, "293f12190ae5ae2d8f46ca739fd11f36c438479e"sv}, Entry{"v1-010700-010800-bodies.idx"sv, "97000a13efb55a53c82851593e1db12e4a9872ce"sv}, Entry{"v1-010700-010800-bodies.seg"sv, "1856cdc0bb6be1bad9caffdc5e149d488f67b8cc"sv}, Entry{"v1-010700-010800-borevents.idx"sv, "6806c4a2f72e5c18cb7056058e5f8a4e2a7ba23c"sv}, Entry{"v1-010700-010800-borevents.seg"sv, "b007a4919169ad9c09d45a3f255da0c0e501109f"sv}, Entry{"v1-010700-010800-borspans.idx"sv, "c2cf35e282d0a4e587692e4a1bb8cff862b7f516"sv}, Entry{"v1-010700-010800-borspans.seg"sv, "7bc82fb6263f574003c131b4f24890b07bfebaa5"sv}, Entry{"v1-010700-010800-headers.idx"sv, "a2ad68aab8b2a48bd370ef6717662b78cc57e011"sv}, Entry{"v1-010700-010800-headers.seg"sv, "365143a4f53a8db9e8643831aca07faa85e3fa68"sv}, Entry{"v1-010700-010800-transactions-to-block.idx"sv, "f450252a9584e5fa8efc58e62b21546987aadb85"sv}, Entry{"v1-010700-010800-transactions.idx"sv, "1f8c7ac3d874a239024d6076d5591cf2dd298e46"sv}, Entry{"v1-010700-010800-transactions.seg"sv, "0eb02d5ac0ac36e3491acdffdc366cab5e3a0f0b"sv}, Entry{"v1-010800-010900-bodies.idx"sv, "d0592c1506db3ca20be1395929f8e87e6a9ef4a2"sv}, Entry{"v1-010800-010900-bodies.seg"sv, "5ad4eb72b1fc564e1eb850a06f0527c486e5013d"sv}, Entry{"v1-010800-010900-borevents.idx"sv, "3481a3a8c494bb48ffb271d716c8e1d01c589f7c"sv}, Entry{"v1-010800-010900-borevents.seg"sv, "9d6209186f49097a4613d0975d0a718d691db550"sv}, Entry{"v1-010800-010900-borspans.idx"sv, "e273df13cd15e5233c686f66e4e86a6024fba4db"sv}, Entry{"v1-010800-010900-borspans.seg"sv, "74127ea10ca7324f254c8fdec7507a4cfdb1cb2b"sv}, Entry{"v1-010800-010900-headers.idx"sv, "d5039277446f72310191a6ac21368e142638c2ad"sv}, Entry{"v1-010800-010900-headers.seg"sv, "144f26ebd143fffc429db04c8dfdb02d10821953"sv}, Entry{"v1-010800-010900-transactions-to-block.idx"sv, "b7ca419523fa2f0673d2dd975cd2628933457087"sv}, Entry{"v1-010800-010900-transactions.idx"sv, "3a2c0b5140223c150d6c702521a782711b5c8ec2"sv}, Entry{"v1-010800-010900-transactions.seg"sv, "abd95c64a6e48d45ec9cb8d2d6d82bb13346b07f"sv}, Entry{"v1-010900-011000-bodies.idx"sv, "1e773dc164087a06e41dfafebe275b7c65df35d4"sv}, Entry{"v1-010900-011000-bodies.seg"sv, "0022362778fc00095264baa3f227054cd45394fd"sv}, Entry{"v1-010900-011000-borevents.idx"sv, "94445fcaf2c0f346f25b873af6a81920d624a308"sv}, Entry{"v1-010900-011000-borevents.seg"sv, "dd58878cf7c09ae859b98ba5b1afd7c5e960407a"sv}, Entry{"v1-010900-011000-borspans.idx"sv, "80ae63b99afbc7f16e9e47812d509be27c7e6cf3"sv}, Entry{"v1-010900-011000-borspans.seg"sv, "3f77bb8070e42feb545a35b751eca98646a6ccd1"sv}, Entry{"v1-010900-011000-headers.idx"sv, "00d032ec91429500e9d58d74d0948bfc3eb4a791"sv}, Entry{"v1-010900-011000-headers.seg"sv, "069b42fa1105adfa35f8aef6503f385f69507db5"sv}, Entry{"v1-010900-011000-transactions-to-block.idx"sv, "e6de9453dcc8d8c67560e64ccd7f185b90daf80e"sv}, Entry{"v1-010900-011000-transactions.idx"sv, "3f76f591e8e8fd18d32336e0b670730730a95144"sv}, Entry{"v1-010900-011000-transactions.seg"sv, "f1ee2ac55dd5b4238238fadb27e886ffa88113af"sv}, Entry{"v1-011000-011100-bodies.idx"sv, "7a143793ae58e8cb385d06cb027a77a4704536e3"sv}, Entry{"v1-011000-011100-bodies.seg"sv, "5ad49562dcb4c1acc3674234ab49d0dd49635fab"sv}, Entry{"v1-011000-011100-borevents.idx"sv, "8c137970831b3b275a9463291b06d223f1179e8e"sv}, Entry{"v1-011000-011100-borevents.seg"sv, "8f1b2ae1f9a9934ea9974c2e98fd8276c1d4080f"sv}, Entry{"v1-011000-011100-borspans.idx"sv, "1621a8d669261416ed866daf2596341f864be874"sv}, Entry{"v1-011000-011100-borspans.seg"sv, "f76c410fa137cfe8209b8b7c1360616bb72e67b9"sv}, Entry{"v1-011000-011100-headers.idx"sv, "4d5d6494f73072612b575570bf0ff5e73317ab29"sv}, Entry{"v1-011000-011100-headers.seg"sv, "05c474b8f53a38fa6e05fe882ff45dacb3765fb9"sv}, Entry{"v1-011000-011100-transactions-to-block.idx"sv, "2e697217ba6611a7eadb262bb72a1c5fae0851f8"sv}, Entry{"v1-011000-011100-transactions.idx"sv, "12a63b698797b9505708b81199ba5579a8e85c7d"sv}, Entry{"v1-011000-011100-transactions.seg"sv, "cbd2130d9fe2c84a6696d9eb46336df5fff34c18"sv}, Entry{"v1-011100-011200-bodies.idx"sv, "fb4d3e9a00dc6f95f204cb29822d16c47b8d760c"sv}, Entry{"v1-011100-011200-bodies.seg"sv, "7e16f4eac3400e77778cc0e6ddcff8a5679fe8a8"sv}, Entry{"v1-011100-011200-borevents.idx"sv, "834b82c9c8e7283fb9062711c41c382198733266"sv}, Entry{"v1-011100-011200-borevents.seg"sv, "86ad1eb1b2816e17497aff468cdc42859035a174"sv}, Entry{"v1-011100-011200-borspans.idx"sv, "16640181a054011623d5085e510eecc7bb62614c"sv}, Entry{"v1-011100-011200-borspans.seg"sv, "c19f4d1358fb0bf4e9d46ce6210256005a451587"sv}, Entry{"v1-011100-011200-headers.idx"sv, "83f883ffbe6c3b7401ff60436ee763c8df2078c2"sv}, Entry{"v1-011100-011200-headers.seg"sv, "c94626cb4562ff587f1dbc120707d04eb3d7df0b"sv}, Entry{"v1-011100-011200-transactions-to-block.idx"sv, "d4aa221dbc03d822210c64e7036d087647b32a5a"sv}, Entry{"v1-011100-011200-transactions.idx"sv, "7501df56ab6f23de0b82405ffc6e6a4c605f4fe6"sv}, Entry{"v1-011100-011200-transactions.seg"sv, "bd6d2586409321707912c47cffd04ba29df987ae"sv}, Entry{"v1-011200-011300-bodies.idx"sv, "1c6493856fb74a79468f34bc143c1b60b0465000"sv}, Entry{"v1-011200-011300-bodies.seg"sv, "f8adea2e41f050bcdfb9b04cd14c34d40350746f"sv}, Entry{"v1-011200-011300-borevents.idx"sv, "6fde8ff7eaf69f6c1dafde1f4650b32ccfb6195c"sv}, Entry{"v1-011200-011300-borevents.seg"sv, "413d3769c056eb8e5b66c6c96e2ea211b200411c"sv}, Entry{"v1-011200-011300-borspans.idx"sv, "fa9c40ceac5b53060e023f1e2bb018ec894c4def"sv}, Entry{"v1-011200-011300-borspans.seg"sv, "3f33976e55abb51641c0b9ee819acc72d3c44ee0"sv}, Entry{"v1-011200-011300-headers.idx"sv, "011eddac62229cb7e8b46f017e044b98f70f7c77"sv}, Entry{"v1-011200-011300-headers.seg"sv, "59105d8fbd77ff2d76c9ea9b85575d25ae938ec4"sv}, Entry{"v1-011200-011300-transactions-to-block.idx"sv, "b1a2d9df52a82903881db7327269ffd0ce287689"sv}, Entry{"v1-011200-011300-transactions.idx"sv, "849767228e36dba8db162b0ca2ae3e4fe31604a6"sv}, Entry{"v1-011200-011300-transactions.seg"sv, "7a46676e63ec4ad840117af73dd1fd93d21d68f5"sv}, Entry{"v1-011300-011400-bodies.idx"sv, "6b6a8f2cda0dcaa8dfb0e8e07f9795f15835cfe1"sv}, Entry{"v1-011300-011400-bodies.seg"sv, "bb2c29d2cf329c746bba638eddeac37cab5b181b"sv}, Entry{"v1-011300-011400-borevents.idx"sv, "95a43c009843f676495187dfb462d056beed533a"sv}, Entry{"v1-011300-011400-borevents.seg"sv, "9659ca0ad3fe59272cf7bf9726532c43b4995932"sv}, Entry{"v1-011300-011400-borspans.idx"sv, "fb5e586d4d430e716823e384ec70706202510578"sv}, Entry{"v1-011300-011400-borspans.seg"sv, "f7a4a57d331212208421ff7c549faac93d1e5af7"sv}, Entry{"v1-011300-011400-headers.idx"sv, "c4203e21fc21dee767793e043c7a61bd61c0de6a"sv}, Entry{"v1-011300-011400-headers.seg"sv, "fd8e13a9b8a8681adaca5addb5d3c278a6425067"sv}, Entry{"v1-011300-011400-transactions-to-block.idx"sv, "147fd6c84d2680d532c634fcfa4c7f9910d1a8e3"sv}, Entry{"v1-011300-011400-transactions.idx"sv, "46a74ecfcc102abde4f7435e1c7b0c2549c88102"sv}, Entry{"v1-011300-011400-transactions.seg"sv, "05497b6d7bd3b81881ee24c44c709f42fa1fd721"sv}, Entry{"v1-011400-011500-bodies.idx"sv, "91db7676126d349e4e6c262eecc2c45254abc740"sv}, Entry{"v1-011400-011500-bodies.seg"sv, "3a7ce6c338e4899fa4e9fe78771f4a602f0fdef9"sv}, Entry{"v1-011400-011500-borevents.idx"sv, "48a6a38a588c8b4b8f2df1eaeaa93c6291f9cbd8"sv}, Entry{"v1-011400-011500-borevents.seg"sv, "cc0c3f1f526bc2b306c36c4bc7945918a3e44239"sv}, Entry{"v1-011400-011500-borspans.idx"sv, "e32b7182eceb3f9e880bbba54a13fd8b8fcff6d0"sv}, Entry{"v1-011400-011500-borspans.seg"sv, "4930c888ec9f0743774397b4fd0b289296a487ea"sv}, Entry{"v1-011400-011500-headers.idx"sv, "07c0f0332e24f8fe9702bdb2492f35d2cba53b76"sv}, Entry{"v1-011400-011500-headers.seg"sv, "b9ba333b7ea0454fff82a2d4b5d888ebc745c5b5"sv}, Entry{"v1-011400-011500-transactions-to-block.idx"sv, "c17abf9bd25e2742e470117a9a90bdca32630d06"sv}, Entry{"v1-011400-011500-transactions.idx"sv, "3426d3cb37718ddff9ce2bb55f4b73454aa65886"sv}, Entry{"v1-011400-011500-transactions.seg"sv, "2e36f59f4f3f5836834932facf8f4020f48af9bb"sv}, Entry{"v1-011500-011600-bodies.idx"sv, "3f5e90353eb8c4913fe21a6afaded8f10e3b3772"sv}, Entry{"v1-011500-011600-bodies.seg"sv, "aaea97748cd06653a341c186b422efd3f2e7d1da"sv}, Entry{"v1-011500-011600-borevents.idx"sv, "af43e169f0c88d1a82f9681d160080f706e92881"sv}, Entry{"v1-011500-011600-borevents.seg"sv, "e7b7036617ae7a4895524726b0f156c65615b9ef"sv}, Entry{"v1-011500-011600-borspans.idx"sv, "4174960302dde941123ee7c378c7438c0252fa3b"sv}, Entry{"v1-011500-011600-borspans.seg"sv, "4f0d2e054302ff135761041615053df5b8d05469"sv}, Entry{"v1-011500-011600-headers.idx"sv, "8ce42d02c3004937868101f724188916bbe1c0b2"sv}, Entry{"v1-011500-011600-headers.seg"sv, "490e94a8d4e94e34f41a93b23881323d566346ed"sv}, Entry{"v1-011500-011600-transactions-to-block.idx"sv, "bc993a37210e2892cad408ad9e5d37c4ab9682db"sv}, Entry{"v1-011500-011600-transactions.idx"sv, "5051be5857b656cfae9430a7a53e0eb9d5cdddc0"sv}, Entry{"v1-011500-011600-transactions.seg"sv, "46a82cb0da6f92c3a6a8e919d269545d7a80e65e"sv}, Entry{"v1-011600-011700-bodies.idx"sv, "e32bab0a49499ef014cbadc386ccf0cddf441db6"sv}, Entry{"v1-011600-011700-bodies.seg"sv, "c0758f6d4401644bbb19a013d5c276ba698efa1f"sv}, Entry{"v1-011600-011700-borevents.idx"sv, "eacb84d79e6825dc4ac806b6fd70c5e23b84c8aa"sv}, Entry{"v1-011600-011700-borevents.seg"sv, "4be28f27d7344f48682c3ed34538247b02860705"sv}, Entry{"v1-011600-011700-borspans.idx"sv, "4da7f861eca98ccb0d3c252d4dcea9fd67678521"sv}, Entry{"v1-011600-011700-borspans.seg"sv, "244b5bf36c7dd890b81ae3369d41433fa815d3c1"sv}, Entry{"v1-011600-011700-headers.idx"sv, "083237a50d2ae8957d761f71c5a8d38dd6717399"sv}, Entry{"v1-011600-011700-headers.seg"sv, "69c31da4366f150a9db2024582e29a02f2239e22"sv}, Entry{"v1-011600-011700-transactions-to-block.idx"sv, "346ff79317d87a56f393abb98aae47a4d3a8f723"sv}, Entry{"v1-011600-011700-transactions.idx"sv, "e6c2e338871f0d266449d498a19ab6513d6d6ba0"sv}, Entry{"v1-011600-011700-transactions.seg"sv, "d59c40447dd980c6c4e8387e45adf1e8d697ac53"sv}, Entry{"v1-011700-011800-bodies.idx"sv, "fbf8a8bf5f31cf1e68482d78d515e81c74c80287"sv}, Entry{"v1-011700-011800-bodies.seg"sv, "3e8123ec2272a3f6ab4f7f9695e9de96fd7aca1e"sv}, Entry{"v1-011700-011800-borevents.idx"sv, "99b8c2269bcb325b8e9ec66ea66184de3b9d7aad"sv}, Entry{"v1-011700-011800-borevents.seg"sv, "8cb97d3eec1248701916b428d550f5f52b9bc21e"sv}, Entry{"v1-011700-011800-borspans.idx"sv, "2446df54be49228fe6c979851994ee4d183308d5"sv}, Entry{"v1-011700-011800-borspans.seg"sv, "a1eff5c0b84a85de2db70e58f7600745e57f8636"sv}, Entry{"v1-011700-011800-headers.idx"sv, "7d7bbb20eb27f5d803e168216c5299babf91c409"sv}, Entry{"v1-011700-011800-headers.seg"sv, "44e9247d30a24c4de8c1473a2c47e35b50098314"sv}, Entry{"v1-011700-011800-transactions-to-block.idx"sv, "77cdc57f63f63d7fb18eb8a064ef3004742187d8"sv}, Entry{"v1-011700-011800-transactions.idx"sv, "ea384b90cd9a08836d4f7f8203e1102aadd3e872"sv}, Entry{"v1-011700-011800-transactions.seg"sv, "3ff5b723f0f48da3451e78c7a94b4fcdef954bb0"sv}, Entry{"v1-011800-011900-bodies.idx"sv, "c04e4517cb498176419d1b4722102aa4555ed7f3"sv}, Entry{"v1-011800-011900-bodies.seg"sv, "e34f3cf3c211bbe40b05d2c8412aeac6a72c89d7"sv}, Entry{"v1-011800-011900-borevents.idx"sv, "1c82b00ae9671ae5c3b9759a515f382abc28bafb"sv}, Entry{"v1-011800-011900-borevents.seg"sv, "659e426ba7435308da44041631119f35e47a2f71"sv}, Entry{"v1-011800-011900-borspans.idx"sv, "a92e04014ac09f5d803b945158b54d77b3c6ca55"sv}, Entry{"v1-011800-011900-borspans.seg"sv, "3d96f61e5adfd886920f8462784217df527cfe5f"sv}, Entry{"v1-011800-011900-headers.idx"sv, "42d58903541d71c8e8d30282ecc325086e297e38"sv}, Entry{"v1-011800-011900-headers.seg"sv, "e336bbb2d4317e3d4ce1288c0c29ad6d2700fce6"sv}, Entry{"v1-011800-011900-transactions-to-block.idx"sv, "bf21edaf153dbe427b481579bda7a9a8c8ebfd83"sv}, Entry{"v1-011800-011900-transactions.idx"sv, "5b22b73e0e906e55616f95da7b330eebffd4dffd"sv}, Entry{"v1-011800-011900-transactions.seg"sv, "fda31da5e472ece9c8fc83e6f7636bd5c9a78324"sv}, Entry{"v1-011900-012000-bodies.idx"sv, "da4d83667eb8654777a567d1485d559e96a20043"sv}, Entry{"v1-011900-012000-bodies.seg"sv, "be2340c994d12cc1b131a73f346993ab4c2e5f97"sv}, Entry{"v1-011900-012000-borevents.idx"sv, "2e68000e9216f74e77ef8a597ae8314a7c5f9d02"sv}, Entry{"v1-011900-012000-borevents.seg"sv, "940535d258fbbc421b5db5c45cc21ded934df3a5"sv}, Entry{"v1-011900-012000-borspans.idx"sv, "4bc5e2b276281abc716902918c7598bbc31330e7"sv}, Entry{"v1-011900-012000-borspans.seg"sv, "6fe073861fc9baea5e626ad45c6da28a17818d84"sv}, Entry{"v1-011900-012000-headers.idx"sv, "7b48ef441c4f8b722943f7dac11d98d495c58d80"sv}, Entry{"v1-011900-012000-headers.seg"sv, "8e609a80a63e7a8b1024185ff8815b7c5911ad0b"sv}, Entry{"v1-011900-012000-transactions-to-block.idx"sv, "e6ef2ec048b48d6377c18387dd2ac5b2b6120ffa"sv}, Entry{"v1-011900-012000-transactions.idx"sv, "f7f9a9bde5c3b319a92179a6c8f763af203b6402"sv}, Entry{"v1-011900-012000-transactions.seg"sv, "d4a760e168c4659040feb5b90fa138877f718856"sv}, Entry{"v1-012000-012100-bodies.idx"sv, "df377ff25fe8415f2f9d91ae89b0dd9e00765608"sv}, Entry{"v1-012000-012100-bodies.seg"sv, "020903df14867d0a31a5e4947cdd7556585a64e1"sv}, Entry{"v1-012000-012100-borevents.idx"sv, "dad055b053346472fffb318f80e743dfb53edae5"sv}, Entry{"v1-012000-012100-borevents.seg"sv, "368a6f52854435c8073013b425854b4955712a13"sv}, Entry{"v1-012000-012100-borspans.idx"sv, "e90ca01481e40309edb1523bfefcebbd2e15d2ef"sv}, Entry{"v1-012000-012100-borspans.seg"sv, "9b0ee98f0db8081368a911014218457ed6a053cb"sv}, Entry{"v1-012000-012100-headers.idx"sv, "6c1307c3da5171be3d5dd255b2aba617ebca6599"sv}, Entry{"v1-012000-012100-headers.seg"sv, "68ea1d84759b689650ce1dfc7a56bd4395055f02"sv}, Entry{"v1-012000-012100-transactions-to-block.idx"sv, "8ab66b3f8fe1266834ce241690e4314ecebad12e"sv}, Entry{"v1-012000-012100-transactions.idx"sv, "042d1b94ee33acf0b1f5970dfb293944f55f87ae"sv}, Entry{"v1-012000-012100-transactions.seg"sv, "26786546a8aa62872ff96c5d9b61fca2385975df"sv}, Entry{"v1-012100-012200-bodies.idx"sv, "9941c32d2ca3c0c9bc0d30bf9014e39a98c5a3f3"sv}, Entry{"v1-012100-012200-bodies.seg"sv, "dba8c48669e3d46c5e5a41585b3869b51ce234c1"sv}, Entry{"v1-012100-012200-borevents.idx"sv, "46bf05344a8616b723882abe04a2d3a3c20e634e"sv}, Entry{"v1-012100-012200-borevents.seg"sv, "d7638e660e0b121a54b08fc3ab207d9a1ecbe3d7"sv}, Entry{"v1-012100-012200-borspans.idx"sv, "150e090fe0c76667809593ec03d70404682f2466"sv}, Entry{"v1-012100-012200-borspans.seg"sv, "acf5b18ef38420e36925f5efa9afa4ddb1c72170"sv}, Entry{"v1-012100-012200-headers.idx"sv, "4a3e3d4905441c12bf699204db6fbae39642da17"sv}, Entry{"v1-012100-012200-headers.seg"sv, "1c264578bca4f2be1a3a2e9d692284d3409f68bd"sv}, Entry{"v1-012100-012200-transactions-to-block.idx"sv, "c17d806a1251efda1ce18b59e09ad339605e3501"sv}, Entry{"v1-012100-012200-transactions.idx"sv, "3f795add5c759dd718150e7fc76e565a537ee0f4"sv}, Entry{"v1-012100-012200-transactions.seg"sv, "6d6778bc271d049b69fbe622f9601ba314b4ffc1"sv}, Entry{"v1-012200-012300-bodies.idx"sv, "1e2c3682e5b67e34f661860c8d211c8cdc3ac975"sv}, Entry{"v1-012200-012300-bodies.seg"sv, "cf69c900c13efcb7969134aca30bebb6c9aa9ba7"sv}, Entry{"v1-012200-012300-borevents.idx"sv, "8c3543911298dc06074a5592d3facfd605cf8969"sv}, Entry{"v1-012200-012300-borevents.seg"sv, "9dea1f9463e0f2b7fa97c7a0742d42c32d93be52"sv}, Entry{"v1-012200-012300-borspans.idx"sv, "6d605a4c0ed6890732070ec0a557e72087d66663"sv}, Entry{"v1-012200-012300-borspans.seg"sv, "70daed450adf1b141aa0f4a4e5602409ae3090ab"sv}, Entry{"v1-012200-012300-headers.idx"sv, "14fbc4d2c88fc09ec617344a028b9625059a548a"sv}, Entry{"v1-012200-012300-headers.seg"sv, "4ee689aec5d2fe49d31de42bcd16e95ddf746607"sv}, Entry{"v1-012200-012300-transactions-to-block.idx"sv, "eef275e6f1a3ab61fc018cfc8790a494ccd8c88f"sv}, Entry{"v1-012200-012300-transactions.idx"sv, "bf326044b6ea297f2745697b8dee32ea217a65ed"sv}, Entry{"v1-012200-012300-transactions.seg"sv, "1b451d0484c199183930d053ac5c3fbb908ad811"sv}, Entry{"v1-012300-012400-bodies.idx"sv, "2203a12b1fbef72dfc90145358784f40e5331564"sv}, Entry{"v1-012300-012400-bodies.seg"sv, "b207b92922fd3ccff1eff40dd8d66e950b524bda"sv}, Entry{"v1-012300-012400-borevents.idx"sv, "f088643bed650f92074e3c6ac0de2fcd8a9f69f9"sv}, Entry{"v1-012300-012400-borevents.seg"sv, "5494eb2bd1f9b522f5102106e14d89e7405b0dd8"sv}, Entry{"v1-012300-012400-borspans.idx"sv, "39df7b378f3f74ba494a229689e0de0b66e238cb"sv}, Entry{"v1-012300-012400-borspans.seg"sv, "a092162033d9771ea20dfd2716483f98173e1838"sv}, Entry{"v1-012300-012400-headers.idx"sv, "501c7b5f3c01997c44055ed42b9f4e174551092f"sv}, Entry{"v1-012300-012400-headers.seg"sv, "09950512eca3fc50935d9ba02bd781b95498e86b"sv}, Entry{"v1-012300-012400-transactions-to-block.idx"sv, "20b54a4e00b24e86619e7f7e53585812908f61ba"sv}, Entry{"v1-012300-012400-transactions.idx"sv, "15edef49603013083a46b3c3f19487f380201512"sv}, Entry{"v1-012300-012400-transactions.seg"sv, "465b6df1ed9367774280cbe59575d68254fafa28"sv}, Entry{"v1-012400-012410-bodies.idx"sv, "0defc4dd2ac0d4204ac8ee41292784359e0056c7"sv}, Entry{"v1-012400-012410-borevents.idx"sv, "cd0072498a44531ff536583e52765a13def860fe"sv}, Entry{"v1-012400-012410-borspans.idx"sv, "d598fbc3a3b74d7466e68f8939878dc712baad64"sv}, Entry{"v1-012400-012410-headers.idx"sv, "ebcba439abb81fa2b099e62a6d42b1bb36b0b3aa"sv}, Entry{"v1-012400-012410-transactions-to-block.idx"sv, "4a506f4f60730e20999e6e5cc6bac8676b0c79bb"sv}, Entry{"v1-012400-012410-transactions.idx"sv, "d7bd783ebcd2835740162183c64fde1032c91ad2"sv}, Entry{"v1-012400-012500-bodies.idx"sv, "39d15c6f2c1095b5d1424e4b5316de6c779123f8"sv}, Entry{"v1-012400-012500-bodies.seg"sv, "38e6dc8191538be302b023adc5d0d4287b355544"sv}, Entry{"v1-012400-012500-borevents.idx"sv, "0d91ee4320c30f48783adb8f48fc32f4c3b5017d"sv}, Entry{"v1-012400-012500-borevents.seg"sv, "16caf2515d75638a8df2fefa499165b8cd57f281"sv}, Entry{"v1-012400-012500-borspans.idx"sv, "068e9fe026f1ccd8cdb446c39d83e8a024aeb24f"sv}, Entry{"v1-012400-012500-borspans.seg"sv, "e86dff614bfe0bd62cb7bd15337f3a341dfa437d"sv}, Entry{"v1-012400-012500-headers.idx"sv, "7ee2c0693411fd61d3a86a0e9cc2cdb0d7e70d0e"sv}, Entry{"v1-012400-012500-headers.seg"sv, "39c0eea16579aa0f612b8f7dfca5206e945c5315"sv}, Entry{"v1-012400-012500-transactions-to-block.idx"sv, "ed27e50bfe0d7486308f5967f47029388aa1a5eb"sv}, Entry{"v1-012400-012500-transactions.idx"sv, "9648a864b33c47f92c43c0b9de88478dcd727db8"sv}, Entry{"v1-012400-012500-transactions.seg"sv, "6d03370b56f76ad8fc77b2a4918a214b7afeebf7"sv}, Entry{"v1-012410-012420-bodies.idx"sv, "5641adaa4d738ae9b7d6f73fb3e77c2244e5f172"sv}, Entry{"v1-012410-012420-borevents.idx"sv, "cfd5e922fce439bacf683860374f0fe54e8e5cc9"sv}, Entry{"v1-012410-012420-borspans.idx"sv, "0e36c4908f1f4976f0853c8d5b6ccfaf538c969a"sv}, Entry{"v1-012410-012420-headers.idx"sv, "43044fa708d8e72c888b51d59862a7b0ed74ae22"sv}, Entry{"v1-012410-012420-transactions-to-block.idx"sv, "7f5c30e343481b60012f46876d12f7bb7801fdbb"sv}, Entry{"v1-012410-012420-transactions.idx"sv, "e940aae5efaac27a6c09b9074957f259b79a74b7"sv}, Entry{"v1-012420-012421-bodies.idx"sv, "0348209352514680a14e52544ab88592fca61a0d"sv}, Entry{"v1-012420-012421-borevents.idx"sv, "012daf147baecc065750973786e1ea92ec252d38"sv}, Entry{"v1-012420-012421-borspans.idx"sv, "d3a997f27da56698d7280b5bb5f9cfce26054558"sv}, Entry{"v1-012420-012421-headers.idx"sv, "d8d9089a8b9bec1a54bf8596068f89c5fe14cf7c"sv}, Entry{"v1-012420-012421-transactions-to-block.idx"sv, "91e61d870f238c22160602e7443001e0dba59b44"sv}, Entry{"v1-012420-012421-transactions.idx"sv, "68745e0796510cbadae02aefe899bc5bd121b4b0"sv}, Entry{"v1-012421-012422-bodies.idx"sv, "e46782a9812ddbeb90b8d1e5fb0a6b3efa9c8248"sv}, Entry{"v1-012421-012422-borevents.idx"sv, "272904576c77418cb0bdd31951a713c8814d99ea"sv}, Entry{"v1-012421-012422-borspans.idx"sv, "59cd30d21944cb2e46d39e644c74685b0628a075"sv}, Entry{"v1-012421-012422-headers.idx"sv, "0b3de629085832f136fb355ea6fa868297a2dae9"sv}, Entry{"v1-012421-012422-transactions-to-block.idx"sv, "0eb2e9c1d97d9a9eff1f75fd4a727a0ff0e04be9"sv}, Entry{"v1-012421-012422-transactions.idx"sv, "e4a43e8519fc6bc8cf8c53f1c2b7d5d86134f91c"sv}, Entry{"v1-012422-012423-bodies.idx"sv, "0d38dff733e95270b21590e838f6774d7f4cd9d0"sv}, Entry{"v1-012422-012423-borevents.idx"sv, "973de86380221bc5f249f7ccdeaf99c8051eaf5f"sv}, Entry{"v1-012422-012423-borspans.idx"sv, "324bbdd430f7fa471ed3d5acff6a656fc792e54a"sv}, Entry{"v1-012422-012423-headers.idx"sv, "c2a5a2148be8ec70d7f5a16edae52721c31cee9c"sv}, Entry{"v1-012422-012423-transactions-to-block.idx"sv, "d5e7719b09786a846403f581f5924190a835c9a0"sv}, Entry{"v1-012422-012423-transactions.idx"sv, "4ea512d78aac44e309b41b55142aff2a5e392d34"sv}, Entry{"v1-012423-012424-bodies.idx"sv, "c915e6b3d7eca2ff4de983bac3445d79f17d6687"sv}, Entry{"v1-012423-012424-borevents.idx"sv, "84977426ae1a3c37dd0a6e90149d1682a21c1867"sv}, Entry{"v1-012423-012424-borspans.idx"sv, "895603d85b5244a33162c109d2db412a06578c1c"sv}, Entry{"v1-012423-012424-headers.idx"sv, "3f154a8c32269c542cb0c7368633a345a2622a3e"sv}, Entry{"v1-012423-012424-transactions-to-block.idx"sv, "52014d441853f76b36ba89e37aeb2ef6cab17221"sv}, Entry{"v1-012423-012424-transactions.idx"sv, "66df1d61bd1486830610d3cb424b84165322506f"sv}, Entry{"v1-012424-012425-bodies.idx"sv, "34302e6f10472b375aacf52ff4a21fd4861b63e6"sv}, Entry{"v1-012424-012425-borevents.idx"sv, "6508db605c8ca1ff2560798a6d4d99ec40b3eaed"sv}, Entry{"v1-012424-012425-borspans.idx"sv, "f7730a2894a461a85d2d0a0d85db63dd9eb1caab"sv}, Entry{"v1-012424-012425-headers.idx"sv, "94772de6b7f712860b187cc96a243966a78cf733"sv}, Entry{"v1-012424-012425-transactions-to-block.idx"sv, "dd6930996b2289bd3864886d6dbb990e00877c10"sv}, Entry{"v1-012424-012425-transactions.idx"sv, "89dcf4881fcfb2550d8d05a582049a1ca08a237f"sv}, Entry{"v1-012425-012426-bodies.idx"sv, "8cda459c7b56c2e27135bf01d3a76e2c44ba5e75"sv}, Entry{"v1-012425-012426-borevents.idx"sv, "80a0de79e1ccda73212aea95d9dba36704c1ea90"sv}, Entry{"v1-012425-012426-borspans.idx"sv, "00aabc24266c991c4a86927a04dca4e6a4e6179e"sv}, Entry{"v1-012425-012426-headers.idx"sv, "f293b9900a0e268bf441cdb455b3b6b164af46b8"sv}, Entry{"v1-012425-012426-transactions-to-block.idx"sv, "7565f12399714c44d1027da464fe5613ca955ff7"sv}, Entry{"v1-012425-012426-transactions.idx"sv, "446236bf18932ec2b62a46bec5c981f14fdf98a5"sv}, Entry{"v1-012426-012427-bodies.idx"sv, "db4ee6c37906f2ba595c5795845c4ec1f48b2838"sv}, Entry{"v1-012426-012427-borevents.idx"sv, "9cbeed0daf3e39755a5e4302478fb949e21a32a9"sv}, Entry{"v1-012426-012427-borspans.idx"sv, "8d2d31eaae12acc657a051f553db125c0c34f3d2"sv}, Entry{"v1-012426-012427-headers.idx"sv, "79ab2397eb0fe0fa78b09f8efc6c7bd491ed3429"sv}, Entry{"v1-012426-012427-transactions-to-block.idx"sv, "a87f5bb8471e0870148be6493f952f7843bc06ca"sv}, Entry{"v1-012426-012427-transactions.idx"sv, "131ab1b133d40f3dffc0eee199de0498d5711e5b"sv}, Entry{"v1-012427-012428-bodies.idx"sv, "18e9a4bb2c0e4549f9b22384a339305f9edbe9c4"sv}, Entry{"v1-012427-012428-borevents.idx"sv, "e4944fda985f782b3ff4357ec9ff96398e8f549e"sv}, Entry{"v1-012427-012428-borspans.idx"sv, "ea89546d51aa75c082b81f75b5ee5814a457981f"sv}, Entry{"v1-012427-012428-headers.idx"sv, "f0eab2bfe81067a837d925bd552d2c2efd43a32f"sv}, Entry{"v1-012427-012428-transactions-to-block.idx"sv, "4f1bc42377c35f1fcbc72f37fe652262461f405e"sv}, Entry{"v1-012427-012428-transactions.idx"sv, "90722dab6a7d894e23f0078531af5183944b6a0c"sv}, Entry{"v1-012428-012429-bodies.idx"sv, "c32a72c257119a0c5d6ca10a11ab5a583726e40a"sv}, Entry{"v1-012428-012429-borevents.idx"sv, "ea308bd9ba67bfbeffa057148b8d3bfcb225f957"sv}, Entry{"v1-012428-012429-borspans.idx"sv, "37143d54259a7c48ba20d523b83112922718ecf6"sv}, Entry{"v1-012428-012429-headers.idx"sv, "fecf6911b7cbfea70993bb0a65fe1acf1ba6b819"sv}, Entry{"v1-012428-012429-transactions-to-block.idx"sv, "c66d0a47ac9263ff3363128c0cae3272747ec8ee"sv}, Entry{"v1-012428-012429-transactions.idx"sv, "788d813794ede634400cf27539046ad424e41869"sv}, Entry{"v1-012500-012600-bodies.idx"sv, "717ebb266e53ef1b9eef79edf321a8a323a7da34"sv}, Entry{"v1-012500-012600-bodies.seg"sv, "3e7c220424af0ee23390dc74af0dfada319d8cfa"sv}, Entry{"v1-012500-012600-borevents.idx"sv, "18b376142791e3129bc4d875b061571d41bc5ccb"sv}, Entry{"v1-012500-012600-borevents.seg"sv, "117949fc3d751b9189f6e1ff42794031ece5a1dc"sv}, Entry{"v1-012500-012600-borspans.idx"sv, "59676fe7e03aa51d35ad93fca78c3a18f88ea4e1"sv}, Entry{"v1-012500-012600-borspans.seg"sv, "10e413d7530c0b83f09118b9e18670d3745ebadd"sv}, Entry{"v1-012500-012600-headers.idx"sv, "c20a878ef5ebb837237230a56373fb740a51d4f9"sv}, Entry{"v1-012500-012600-headers.seg"sv, "1105c641647e6eec4f5e0989591b3cf79cd40e07"sv}, Entry{"v1-012500-012600-transactions-to-block.idx"sv, "666f2e9ff60ac1ce0745e7de42eefa210141ce83"sv}, Entry{"v1-012500-012600-transactions.idx"sv, "e9488ce105be0d003a014348421209488706cf22"sv}, Entry{"v1-012500-012600-transactions.seg"sv, "e203f1fb6e5e75bc65a191844a53e19171001a6f"sv}, Entry{"v1-012600-012700-bodies.idx"sv, "4b6c4cf07408de0f2ff19e5d0c98c837756e8ee6"sv}, Entry{"v1-012600-012700-bodies.seg"sv, "986c156d971f198d9962d7e4d1906e293d776aef"sv}, Entry{"v1-012600-012700-borevents.idx"sv, "1e7c77fb46df0044ff73708b7b93399832139bae"sv}, Entry{"v1-012600-012700-borevents.seg"sv, "d077633e12bcab56e26939adcb8329c7b3c427ec"sv}, Entry{"v1-012600-012700-borspans.idx"sv, "eb191d0e41ba09ecbd1aa3c79238146fd2e90597"sv}, Entry{"v1-012600-012700-borspans.seg"sv, "6ed978452b83004d7b0d105c293d6eb549a1db8b"sv}, Entry{"v1-012600-012700-headers.idx"sv, "c66643ae2dfe58fd8bf21ca47c3639fd44534b47"sv}, Entry{"v1-012600-012700-headers.seg"sv, "efe206a1b27597e92b703846a80536a56b1fa304"sv}, Entry{"v1-012600-012700-transactions-to-block.idx"sv, "4d5b89b57b9090b7ee80ff39712e94d433a3032b"sv}, Entry{"v1-012600-012700-transactions.idx"sv, "b20c19939995488e7bb2987a8edb68e470be5bb7"sv}, Entry{"v1-012600-012700-transactions.seg"sv, "4a7f6d80f26db1ad450f816c1fc54b0a21ec73ce"sv}, Entry{"v1-012700-012800-bodies.idx"sv, "5aea110afbcfd51243e7033441127bf8b0d44adf"sv}, Entry{"v1-012700-012800-bodies.seg"sv, "b7e9a9777297f218ab14b9b40c263bad8d88ffc0"sv}, Entry{"v1-012700-012800-borevents.idx"sv, "dc0fca51b32996ba11c12ff2f9aecce2c0fbcd24"sv}, Entry{"v1-012700-012800-borevents.seg"sv, "36896659c9749d866e02c36a55311c58b453d25d"sv}, Entry{"v1-012700-012800-borspans.idx"sv, "34eed8baeb292fe25c6a1250a8bb84b5fa032f6d"sv}, Entry{"v1-012700-012800-borspans.seg"sv, "bc8ff01716105f3cefba9a9ab160477a520525df"sv}, Entry{"v1-012700-012800-headers.idx"sv, "2ef23e3a853bd2d81abd6d1f95ec372b2936883d"sv}, Entry{"v1-012700-012800-headers.seg"sv, "7b6aaa1b4e67e8cbf260eedccb38dd2d7e6810b2"sv}, Entry{"v1-012700-012800-transactions-to-block.idx"sv, "59e978fde28c4afd16e333d5eccb498e8907e019"sv}, Entry{"v1-012700-012800-transactions.idx"sv, "cdd77def220f51f8fee87b13c6c973e95e2be49f"sv}, Entry{"v1-012700-012800-transactions.seg"sv, "ea72b1742be6404eb161057d8e780444274068f9"sv}, Entry{"v1-012800-012900-bodies.idx"sv, "46e3946278e0ae1f4de774558d3d4e40c2c474be"sv}, Entry{"v1-012800-012900-bodies.seg"sv, "0a721b59a59dcd573ad2e542a939cb9f10f0856a"sv}, Entry{"v1-012800-012900-borevents.idx"sv, "a00d8d5abaa5b7100b35dc3a6c4a3f5ee35c3ee1"sv}, Entry{"v1-012800-012900-borevents.seg"sv, "8a61c58a4c3046aa3bf3c0c64eb063ccd45585f4"sv}, Entry{"v1-012800-012900-borspans.idx"sv, "78be7c4656b6c415f7966d0cd34759096f6126e2"sv}, Entry{"v1-012800-012900-borspans.seg"sv, "2cc19155a6c8b4b149ec1d57b6941f61fe28948a"sv}, Entry{"v1-012800-012900-headers.idx"sv, "96870d2ab2631d7d97f305aca8dc560018e1a0b7"sv}, Entry{"v1-012800-012900-headers.seg"sv, "44b0048465f57bf2599027192eea409ab23d6f78"sv}, Entry{"v1-012800-012900-transactions-to-block.idx"sv, "a6437fa2c7d958f86cf44669f127d89df15155e0"sv}, Entry{"v1-012800-012900-transactions.idx"sv, "0ed33aa174fb3c70e286a9d736c0d38ffc33b60a"sv}, Entry{"v1-012800-012900-transactions.seg"sv, "6014076e03d3b31af2a575a20ecbab4f2ac8bf6c"sv}, Entry{"v1-012900-013000-bodies.idx"sv, "462565f801bcc0551cec757e5cbc518f88c221d9"sv}, Entry{"v1-012900-013000-bodies.seg"sv, "29825544fcc9c3d2ecaed85b99b842f2559ac6dd"sv}, Entry{"v1-012900-013000-borevents.idx"sv, "b49141588459508e5e152a68fdf1b2728a46182d"sv}, Entry{"v1-012900-013000-borevents.seg"sv, "6f1f5175e50b6d246161ccea613b5372afc9e205"sv}, Entry{"v1-012900-013000-borspans.idx"sv, "b0bb09023a5714053ebac80a8ae1f887ced93d15"sv}, Entry{"v1-012900-013000-borspans.seg"sv, "554c489746bab4992292161d2e9c799390a76a09"sv}, Entry{"v1-012900-013000-headers.idx"sv, "c2ea00b61783da4fd89b28243749e2544a29c072"sv}, Entry{"v1-012900-013000-headers.seg"sv, "d5e51935adb18c1889eefc436e0ba3db212103c2"sv}, Entry{"v1-012900-013000-transactions-to-block.idx"sv, "702b4bfc716d5331cf94727f8e74e44fcbf95ccb"sv}, Entry{"v1-012900-013000-transactions.idx"sv, "39a7185cb1a1286f14233e1bff8bb29ed1fab8b9"sv}, Entry{"v1-012900-013000-transactions.seg"sv, "6461b30824ad5c6f0a66a82073fbd62e696704e9"sv}, Entry{"v1-013000-013100-bodies.idx"sv, "0372fef48659c72bd792f9da3da1c7b14bb21c76"sv}, Entry{"v1-013000-013100-bodies.seg"sv, "4d6190664e6f6fc13a0c7f29793b9c12c970f551"sv}, Entry{"v1-013000-013100-borevents.idx"sv, "71dedb2755993c3378e450326bf0d749d524bbb9"sv}, Entry{"v1-013000-013100-borevents.seg"sv, "9b0e08871c6630783eb03efec9cf5e200d25556c"sv}, Entry{"v1-013000-013100-borspans.idx"sv, "772bd49afb52bb68b16036ce57b3b63e9cac4bc3"sv}, Entry{"v1-013000-013100-borspans.seg"sv, "def6b622bc282f277dc7e3c48a6f3822c114552a"sv}, Entry{"v1-013000-013100-headers.idx"sv, "47c2b1f20b6ec1f4a78493f0aa73f55375741b1c"sv}, Entry{"v1-013000-013100-headers.seg"sv, "aab34d4d10482c2c07e8ad66f0b0eca5b8a4b758"sv}, Entry{"v1-013000-013100-transactions-to-block.idx"sv, "bc23e2017012330da7c8136202cf0961ec62d263"sv}, Entry{"v1-013000-013100-transactions.idx"sv, "6f71d1560f92038e5f533a90f67f5dbd9e915b20"sv}, Entry{"v1-013000-013100-transactions.seg"sv, "c401177338a287dce25dd138a423d81520555168"sv}, Entry{"v1-013100-013200-bodies.idx"sv, "2fcd5b71cd0df8e496965a32cf8bb6739b9b9f40"sv}, Entry{"v1-013100-013200-bodies.seg"sv, "012557ced7152c58f71122d5d3f21cf1f74bfe5c"sv}, Entry{"v1-013100-013200-borevents.idx"sv, "6be70f2c7d88492b0bb3f8d9e823f1e17227567f"sv}, Entry{"v1-013100-013200-borevents.seg"sv, "0d1e1b492aec9239462c3bc777b19c497ca904c0"sv}, Entry{"v1-013100-013200-borspans.idx"sv, "55b765714840c4b475efa7a557aa4d1e34d1c9ef"sv}, Entry{"v1-013100-013200-borspans.seg"sv, "645d1c09b99a8c3f6fc7f4edc6fec779e2ef1bb6"sv}, Entry{"v1-013100-013200-headers.idx"sv, "ce0177fd7959e819f3dedecfbcb6529564c29a99"sv}, Entry{"v1-013100-013200-headers.seg"sv, "65b457784378be6135eac95dba0605d2af25031f"sv}, Entry{"v1-013100-013200-transactions-to-block.idx"sv, "022b1dec516e06dd8c7fcfd85f3028ee7da96431"sv}, Entry{"v1-013100-013200-transactions.idx"sv, "d00a6f03d0f614f64f6ab033ed4e28bc4cc6e42b"sv}, Entry{"v1-013100-013200-transactions.seg"sv, "9af73798af01923cba80fbd09675b43d7d3364bf"sv}, Entry{"v1-013200-013300-bodies.idx"sv, "d095af86aa394e162369b6277e8ea15697c81bd1"sv}, Entry{"v1-013200-013300-bodies.seg"sv, "ab87123f3cddb3d41e809f6431638349e535e7e7"sv}, Entry{"v1-013200-013300-borevents.idx"sv, "e0d39876e11cadda0500ebf044c60a4134771292"sv}, Entry{"v1-013200-013300-borevents.seg"sv, "05ec824e8a56911050f5298022e500f9de76a9e4"sv}, Entry{"v1-013200-013300-borspans.idx"sv, "79ee70f73d376286cb43f3cfa2ac9d5bb3962261"sv}, Entry{"v1-013200-013300-borspans.seg"sv, "3c6999a98664f6dce1bec91641e9f15f0412ae18"sv}, Entry{"v1-013200-013300-headers.idx"sv, "c5ab4b86c1e6eced0fde73f1bd9539222e6e252d"sv}, Entry{"v1-013200-013300-headers.seg"sv, "98884eb2f2bd72b1730cfbc089356c43f53a8f83"sv}, Entry{"v1-013200-013300-transactions-to-block.idx"sv, "f2b9fbfaa445dd2ace299a596b419b0379d2b67c"sv}, Entry{"v1-013200-013300-transactions.idx"sv, "d68e23fceaa0c14a9127c1dd2e6890f784ec8d82"sv}, Entry{"v1-013200-013300-transactions.seg"sv, "63ac214f3cc4238423c713c26c8e96ece96d57b5"sv}, Entry{"v1-013300-013400-bodies.idx"sv, "00555b4fa20a4ab3cad3d9be5d81b168cd5623b5"sv}, Entry{"v1-013300-013400-bodies.seg"sv, "f72797b76fbe3748079d7e3ff806c10c8c26b381"sv}, Entry{"v1-013300-013400-borevents.idx"sv, "1b64ffbf0b46284b3d3baf29a5e1795334eb9d6b"sv}, Entry{"v1-013300-013400-borevents.seg"sv, "af86e56eddc49d692c405d0260a1c75bd12236f6"sv}, Entry{"v1-013300-013400-borspans.idx"sv, "c07b32241f4656f75debf6c399c4843120809454"sv}, Entry{"v1-013300-013400-borspans.seg"sv, "8ca895c7ac729e51ed49fcb1063e4bdf22223b63"sv}, Entry{"v1-013300-013400-headers.idx"sv, "5ac66cb7d2addd5d7c7fce900f9537935d6d9108"sv}, Entry{"v1-013300-013400-headers.seg"sv, "eb5bf27ff2f557ae53cd024cbe04bbcb0c6219ac"sv}, Entry{"v1-013300-013400-transactions-to-block.idx"sv, "64fead5e217f8257fe313814ccb632ac225fd4a8"sv}, Entry{"v1-013300-013400-transactions.idx"sv, "6d6fcae12fe33053a0238fa1b69a62072ce29522"sv}, Entry{"v1-013300-013400-transactions.seg"sv, "1c739fa98444c96419fa65a2b10c7a25906ef80a"sv}, Entry{"v1-013400-013410-bodies.idx"sv, "329d4618bd5e514597554b0d8e485d892ce47e91"sv}, Entry{"v1-013400-013410-bodies.seg"sv, "0160ff53f7353738eb1d8afc799d9957c5a48515"sv}, Entry{"v1-013400-013410-borevents.idx"sv, "4d33e45ddd5f3d72f52eeea3b34c00502e97674d"sv}, Entry{"v1-013400-013410-borevents.seg"sv, "0d4be47535ea5bd37fae8384538292b9b897330e"sv}, Entry{"v1-013400-013410-borspans.idx"sv, "7a672de15968538031ceb11fbfe380c760aceb43"sv}, Entry{"v1-013400-013410-borspans.seg"sv, "31a3dc107dbd6508c71bec09ec6fd661a97d625c"sv}, Entry{"v1-013400-013410-headers.idx"sv, "ef84804ff95a5d649ca936012c91de7f86e87f95"sv}, Entry{"v1-013400-013410-headers.seg"sv, "e1a8a5f1fc372fb25cda1054e6e839b6aa8d85de"sv}, Entry{"v1-013400-013410-transactions-to-block.idx"sv, "181a2a7993033c11698eea8a9820f7eba59c1c0c"sv}, Entry{"v1-013400-013410-transactions.idx"sv, "f14baa0647ce8ad891291901ebac8f60d5a565ea"sv}, Entry{"v1-013400-013410-transactions.seg"sv, "b0bc93cc35774fe08169e95f9f5d17729616f8c5"sv}, Entry{"v1-013410-013420-bodies.idx"sv, "41ae00222d747cf35b577db7028667bc9816a630"sv}, Entry{"v1-013410-013420-bodies.seg"sv, "5680ce6cf256607da92112dccc7d2364da4d310d"sv}, Entry{"v1-013410-013420-borevents.idx"sv, "11cea9df5f45cd37526fd3cb4b645926c7b83c09"sv}, Entry{"v1-013410-013420-borevents.seg"sv, "1404bc8f4c80e0c9f409a268153f7aca3aa9955f"sv}, Entry{"v1-013410-013420-borspans.idx"sv, "894d5ec674245cf8d975c01adc8df1ec51c7fc35"sv}, Entry{"v1-013410-013420-borspans.seg"sv, "5fed0aefe37dab9b25e6ffcfd99a9836a893250e"sv}, Entry{"v1-013410-013420-headers.idx"sv, "981c69caac24508e874dc4786be1557514f0a319"sv}, Entry{"v1-013410-013420-headers.seg"sv, "67a300cefcc25b654373022cd6d0e0a283f7394e"sv}, Entry{"v1-013410-013420-transactions-to-block.idx"sv, "b30aad5580fd8a4bacff19133d304b5628978336"sv}, Entry{"v1-013410-013420-transactions.idx"sv, "b747f9073e273bae25afe2af2ced80d916695766"sv}, Entry{"v1-013410-013420-transactions.seg"sv, "e9a3526dd903a498a4abf025666b7413104f55c4"sv}, Entry{"v1-013420-013430-bodies.idx"sv, "aced89fc0f954524e968482b4593ace62cd630df"sv}, Entry{"v1-013420-013430-bodies.seg"sv, "cbd284989e8573f7d2e34d42fcc72310f8f23c5b"sv}, Entry{"v1-013420-013430-borevents.idx"sv, "f7663592b9a21f06cb50ff0e8345e78fa0d03581"sv}, Entry{"v1-013420-013430-borevents.seg"sv, "4ca4cc05a721c93da85d7759a9b691b2e4f84d34"sv}, Entry{"v1-013420-013430-borspans.idx"sv, "08cde78ccfcc4558d3f66561e42bf60ce2408310"sv}, Entry{"v1-013420-013430-borspans.seg"sv, "d9f25f7971e5af3b46a50512f20e8b6d0e1fb586"sv}, Entry{"v1-013420-013430-headers.idx"sv, "90e1e5a941995bd654cd65d4ae307ec73c019b5a"sv}, Entry{"v1-013420-013430-headers.seg"sv, "46614480cca433baef9fb5554b6b33f045697140"sv}, Entry{"v1-013420-013430-transactions-to-block.idx"sv, "fc8bc89194f7f601a3eb573239adf5821639a12c"sv}, Entry{"v1-013420-013430-transactions.idx"sv, "16d18c27a2d856f6e0bc1b9127c44772ea0e6af6"sv}, Entry{"v1-013420-013430-transactions.seg"sv, "55116e2a1f96dc6801448ca9aa9db18d71728810"sv}, Entry{"v1-013430-013440-bodies.idx"sv, "6d4babc841b445a69c755e002a0665e7dac38165"sv}, Entry{"v1-013430-013440-bodies.seg"sv, "dad78782569ea14cf7fb04b84853254045bc90c2"sv}, Entry{"v1-013430-013440-borevents.idx"sv, "7feb6147e2bc4fa5ed1f6dca7593e77374091032"sv}, Entry{"v1-013430-013440-borevents.seg"sv, "d3163ad4d15c7463d10ccbbd3a0a59dfce16e7cb"sv}, Entry{"v1-013430-013440-borspans.idx"sv, "8088b5b6b44adf722093dc1e6af7a4a7036116c0"sv}, Entry{"v1-013430-013440-borspans.seg"sv, "3900fc14de2b420471b2066b2310ad7f3bcef1c6"sv}, Entry{"v1-013430-013440-headers.idx"sv, "55ad997c96b86aa241b6c193f293d42e8735709c"sv}, Entry{"v1-013430-013440-headers.seg"sv, "448384ab5c05f771360dde25fb4e6311ab33a080"sv}, Entry{"v1-013430-013440-transactions-to-block.idx"sv, "d912a44c22644d908760d27f3592cdb98fe3f9f6"sv}, Entry{"v1-013430-013440-transactions.idx"sv, "f3382b4d8facc9ecb253480fa803149d819dafbc"sv}, Entry{"v1-013430-013440-transactions.seg"sv, "575857ea88da35ee11685051e78e27c3898c12ad"sv}, Entry{"v1-013440-013441-bodies.idx"sv, "2a164331504c6085f6124ff10434e08b9e05de31"sv}, Entry{"v1-013440-013441-bodies.seg"sv, "ee6e3d4f4da1e33ae9ff08d9847f1fb5b425dd36"sv}, Entry{"v1-013440-013441-borevents.idx"sv, "2fc94c2313e4c157a8b660dfda6956f1cdfdc345"sv}, Entry{"v1-013440-013441-borevents.seg"sv, "7b1e78385f28139fbe0a6bcadfbf70fc56b95eeb"sv}, Entry{"v1-013440-013441-borspans.idx"sv, "065d2571247772f9b9766f5323c70d6e2341c1ed"sv}, Entry{"v1-013440-013441-borspans.seg"sv, "40e36815520217be118aba3669ce0adb536602a4"sv}, Entry{"v1-013440-013441-headers.idx"sv, "fc95d3c062af72e7929bc19f2d1a033bf9e6ad38"sv}, Entry{"v1-013440-013441-headers.seg"sv, "4738ee6511020d3115589172ce10c5e6fda8f923"sv}, Entry{"v1-013440-013441-transactions-to-block.idx"sv, "83121044a6e3625ae4aed38e06b52047468094ef"sv}, Entry{"v1-013440-013441-transactions.idx"sv, "805999acc018e86c8d3aee6923a7cf2fe80dda80"sv}, Entry{"v1-013440-013441-transactions.seg"sv, "47491a8646a79fe80f16c2f6c82a23074f244829"sv}, Entry{"v1-013441-013442-bodies.idx"sv, "87723c53c84a0acd6010ba9319492fc8855c0011"sv}, Entry{"v1-013441-013442-bodies.seg"sv, "d907b2d7361b6e022ceaa6c3c0ad3c979a33fcbc"sv}, Entry{"v1-013441-013442-borevents.idx"sv, "4262257005ab59dc535c5fd5912ae0b1d8bcfa73"sv}, Entry{"v1-013441-013442-borevents.seg"sv, "e1c2877476ea219957c59feb27e7972a0debe691"sv}, Entry{"v1-013441-013442-borspans.idx"sv, "077947841baf26d61345945b4b23f645c053d801"sv}, Entry{"v1-013441-013442-borspans.seg"sv, "404fc69d11e5f897f86637f4f91a837d680ad435"sv}, Entry{"v1-013441-013442-headers.idx"sv, "e1fddda8adbad31b8a0d556341d3fc48039a556c"sv}, Entry{"v1-013441-013442-headers.seg"sv, "b73bf663085adbb3462b6a567f51b1789fb10784"sv}, Entry{"v1-013441-013442-transactions-to-block.idx"sv, "94bc1a067bc988c0ee54bdb035d7420762022add"sv}, Entry{"v1-013441-013442-transactions.idx"sv, "7ed80b4399bfaadfa1b0e95701a55edf3776accd"sv}, Entry{"v1-013441-013442-transactions.seg"sv, "5c9b323fb8b3e082ad8779510b14f380e2714106"sv}, Entry{"v1-013442-013443-bodies.idx"sv, "59027d25d6b0ed95fd3277230b52eb48fc656a23"sv}, Entry{"v1-013442-013443-bodies.seg"sv, "d5f94647e67c47b756195d0b8ffc186a3fe7ba18"sv}, Entry{"v1-013442-013443-borevents.idx"sv, "b555f643437cb3f57cd45f584a6ccb0c5f1dd20b"sv}, Entry{"v1-013442-013443-borevents.seg"sv, "269e3f567fbf08474e22c49555b8b379d3360dd6"sv}, Entry{"v1-013442-013443-borspans.idx"sv, "e62d45b80c6dc592a0462d1e08edbfecfca72a75"sv}, Entry{"v1-013442-013443-borspans.seg"sv, "13c6ea436cf80f07c0c7d9a10e5578a14b5490d5"sv}, Entry{"v1-013442-013443-headers.idx"sv, "bf70cc27daacb44279215bad8d9b4d71e8f8278b"sv}, Entry{"v1-013442-013443-headers.seg"sv, "55f34ca1cafc2dcded141a811b0c9fe278b5468b"sv}, Entry{"v1-013442-013443-transactions-to-block.idx"sv, "14e526b82361abfacfe845bf7e43e3f265b5680b"sv}, Entry{"v1-013442-013443-transactions.idx"sv, "7b857e50abccd64c182b8ff8954ff580deab4834"sv}, Entry{"v1-013442-013443-transactions.seg"sv, "e6a73788e9eb362c4ef601cc8354e3ff54b41ff8"sv}, Entry{"v1-013443-013444-bodies.idx"sv, "c8654c8761de765707e4d2eb069c4b80bb8e1475"sv}, Entry{"v1-013443-013444-bodies.seg"sv, "ea1989971b3177004a46d4cece07bc02d09fbf89"sv}, Entry{"v1-013443-013444-borevents.idx"sv, "9498f78d6cfb93aa27fb9e73158b6829b1c7d56f"sv}, Entry{"v1-013443-013444-borevents.seg"sv, "4fcedc7fdba5b398c147c86f2f852c881372ab93"sv}, Entry{"v1-013443-013444-borspans.idx"sv, "1f8467ae762fbbdca7558788cde33110ba35519c"sv}, Entry{"v1-013443-013444-borspans.seg"sv, "a5d486aa1dbcf79aceedea0972b8d0ba47e45695"sv}, Entry{"v1-013443-013444-headers.idx"sv, "3eac9eb3b53e5f084e24c5db7b67e5ffc223ce14"sv}, Entry{"v1-013443-013444-headers.seg"sv, "613c5843d37246cdea9ace2a0d2fb2cdf618304e"sv}, Entry{"v1-013443-013444-transactions-to-block.idx"sv, "2fede24fa23fb14434522b9bd84a8cecd5d623a0"sv}, Entry{"v1-013443-013444-transactions.idx"sv, "90549bca8a0ed166c7851455db513fc54daf421a"sv}, Entry{"v1-013443-013444-transactions.seg"sv, "4851295fdbf1745cabb34bbc931cb75c8095f2a1"sv}, Entry{"v1-013444-013445-bodies.idx"sv, "5a5174791f7435c306c5131c623063bb03359859"sv}, Entry{"v1-013444-013445-bodies.seg"sv, "a375cef2bb68f4f300c6176c293f8b13c38a2ac3"sv}, Entry{"v1-013444-013445-borevents.idx"sv, "d59e493c222b3363e3ff2a1fbec0bdd6185e3e09"sv}, Entry{"v1-013444-013445-borevents.seg"sv, "6065b2975ceb7fbdc0334af66d09cf984aa34424"sv}, Entry{"v1-013444-013445-borspans.idx"sv, "3d2ce5804901a0bee2f3fead345e4112b1d2c6ee"sv}, Entry{"v1-013444-013445-borspans.seg"sv, "3b4e873a0d4b68ccfadeb5734bc686b80702bed4"sv}, Entry{"v1-013444-013445-headers.idx"sv, "fb5f8cadd2e179fe6a946a18a03ccbdd65a2e0fc"sv}, Entry{"v1-013444-013445-headers.seg"sv, "444c6ea9a0e0825bc0b250e42a1753a2760e0d18"sv}, Entry{"v1-013444-013445-transactions-to-block.idx"sv, "1e6261979327ce5a75108ed725fc4b19ee63eec0"sv}, Entry{"v1-013444-013445-transactions.idx"sv, "077ec7b172fa40ffb6a85a6825332a0f1c6e2dd7"sv}, Entry{"v1-013444-013445-transactions.seg"sv, "e23a54a380485c707485b7b5c8084d2b665b1a98"sv}, }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/chains/bor_mainnet.hpp ================================================ /* Generated from bor-mainnet.toml using Silkworm embed_toml */ #pragma once #include #include #include "../entry.hpp" namespace silkworm::snapshots { using namespace std::literals; inline constexpr std::array kBorMainnetSnapshots{ Entry{"accessor/v1-accounts.0-64.efi"sv, "21ccfc07c3914d033a018fc9b2cbc94d81cc5d5e"sv}, Entry{"accessor/v1-accounts.0-64.vi"sv, "5dad87a30db8655c4e65ad24bff2aec321f8bf70"sv}, Entry{"accessor/v1-accounts.1024-1088.efi"sv, "bbf87305d724f0e985c987c18fb248d6aa62b84d"sv}, Entry{"accessor/v1-accounts.1024-1088.vi"sv, "a76b999c35df7dd32f3f415bff6557980688d11b"sv}, Entry{"accessor/v1-accounts.1088-1152.efi"sv, "4fd73159ff5a1a4441a7a73915786e64bbfcf98c"sv}, Entry{"accessor/v1-accounts.1088-1152.vi"sv, "5758a609245bef2294bfd22f96a9bcd6e9931d41"sv}, Entry{"accessor/v1-accounts.1152-1216.efi"sv, "f171b8d6fb394eeea58102fed45f2a12bf5a1404"sv}, Entry{"accessor/v1-accounts.1152-1216.vi"sv, "da6d63c038cea269f1e8d7a1251b97a10ef2d754"sv}, Entry{"accessor/v1-accounts.1216-1280.efi"sv, "04fb9d55332f814283a48900d3a0a4231b205129"sv}, Entry{"accessor/v1-accounts.1216-1280.vi"sv, "6dacc9d41c38fbc1562d5582d82e06748ced66f4"sv}, Entry{"accessor/v1-accounts.128-192.efi"sv, "1802373829abdfdac58224a0c387cb6df90eca06"sv}, Entry{"accessor/v1-accounts.128-192.vi"sv, "61747c4d687accb779c0521497f77b6df50c6efb"sv}, Entry{"accessor/v1-accounts.1280-1344.efi"sv, "07380c0c4ccde87ddc98c2408104b9c776ba3c70"sv}, Entry{"accessor/v1-accounts.1280-1344.vi"sv, "b19f618b956c9a192313ca577bc8ac2ed8c489ec"sv}, Entry{"accessor/v1-accounts.1344-1408.efi"sv, "0bfabc277b83ea44d4d8ba2a8fc64313c015e39a"sv}, Entry{"accessor/v1-accounts.1344-1408.vi"sv, "62b0350e6c969d9fe51f2f40e81268004515eecb"sv}, Entry{"accessor/v1-accounts.1408-1472.efi"sv, "847f8ee0f1bbc24a33640b3148b29c89774fffff"sv}, Entry{"accessor/v1-accounts.1408-1472.vi"sv, "ce11b9d886a5b1b4c3cb3f82ac34ded1e29b07ce"sv}, Entry{"accessor/v1-accounts.1472-1536.efi"sv, "b3728b8d0e5cfc62a28d5a28e0326477c7f8349d"sv}, Entry{"accessor/v1-accounts.1472-1536.vi"sv, "aacef72521a98a7827ad49cbeebc231f2730459a"sv}, Entry{"accessor/v1-accounts.1536-1600.efi"sv, "f4b43a1ab203e0ee3f450817a79adca992db355d"sv}, Entry{"accessor/v1-accounts.1536-1600.vi"sv, "0f4acd87ce8b54fafdd3ff6cee6dbf74d205e5c7"sv}, Entry{"accessor/v1-accounts.1600-1664.efi"sv, "35510f3da9c5ae660c22648d17bb1fb867a77072"sv}, Entry{"accessor/v1-accounts.1600-1664.vi"sv, "6c6011df4e689c5ca503e1e4f90a644e322e3342"sv}, Entry{"accessor/v1-accounts.1664-1728.efi"sv, "77f9734a2bcba6f25318a9ce18e5c41c849745c4"sv}, Entry{"accessor/v1-accounts.1664-1728.vi"sv, "6b22dc24aeb803e02e2c35b05b70e4aa971a6ab6"sv}, Entry{"accessor/v1-accounts.1728-1792.efi"sv, "a0f87257d73277a8ffaa74a4dc937954bfc3ec52"sv}, Entry{"accessor/v1-accounts.1728-1792.vi"sv, "99745ca86fb5573cd7e13c45288b0065d5fbe91b"sv}, Entry{"accessor/v1-accounts.1792-1856.efi"sv, "a32dae8820b3ebc7d10cbcc60f930f5ec147df10"sv}, Entry{"accessor/v1-accounts.1792-1856.vi"sv, "05e114f6f3058d30c3d74256b9003b1055e1e472"sv}, Entry{"accessor/v1-accounts.1856-1920.efi"sv, "e4ac86373ac11cf05d45d198f16d72e99d18e4c0"sv}, Entry{"accessor/v1-accounts.1856-1920.vi"sv, "25f94050ccb34cc672f224c0f3bc3b51659314ac"sv}, Entry{"accessor/v1-accounts.192-256.efi"sv, "8fea1803e700f582419d61aaa787f95548478f91"sv}, Entry{"accessor/v1-accounts.192-256.vi"sv, "d8eea05d90be2fb4b1ea622df00954dd7b67b215"sv}, Entry{"accessor/v1-accounts.1920-1984.efi"sv, "7a2c936660376b748fbcf7d6ce136bba9017e0a6"sv}, Entry{"accessor/v1-accounts.1920-1984.vi"sv, "56c105c026c16c23560e01f5e6a379e83d86fc06"sv}, Entry{"accessor/v1-accounts.1984-2048.efi"sv, "b405dfeafc14f4c136eed6b432d8b744e654faf7"sv}, Entry{"accessor/v1-accounts.1984-2048.vi"sv, "53f557864f7776be3af7677f8ea46746f14e5af8"sv}, Entry{"accessor/v1-accounts.2048-2112.efi"sv, "11b1f26fe0043dd42d1630e018689c9b270d5568"sv}, Entry{"accessor/v1-accounts.2048-2112.vi"sv, "c5670d057bb64aa0494b415a0d3608fb79898f4f"sv}, Entry{"accessor/v1-accounts.2112-2176.efi"sv, "868fa8b12518ef974361ea8c044164dbbb4e30d1"sv}, Entry{"accessor/v1-accounts.2112-2176.vi"sv, "d93ac04e381094d49e24a7f61883b1388efe0121"sv}, Entry{"accessor/v1-accounts.2176-2240.efi"sv, "e6dae1943b73e03333c878410ebc22e5e00ee032"sv}, Entry{"accessor/v1-accounts.2176-2240.vi"sv, "32ae1e7cecc0ae668c9aceecf1632e7518faa474"sv}, Entry{"accessor/v1-accounts.2240-2304.efi"sv, "6f4443147124c76aa2570fa71153f86fc7d572b6"sv}, Entry{"accessor/v1-accounts.2240-2304.vi"sv, "b393cd9bdbf759d87f04c8c610f9b9edf6a10d24"sv}, Entry{"accessor/v1-accounts.2304-2368.efi"sv, "592b37624c9777ec3aaf2f2f37397743eefac6be"sv}, Entry{"accessor/v1-accounts.2304-2368.vi"sv, "aea561bb82a03327dfc7667566af4d4b00221a11"sv}, Entry{"accessor/v1-accounts.2368-2432.efi"sv, "0d0bacecbe9b63f359f698c307bc4fce38f95340"sv}, Entry{"accessor/v1-accounts.2368-2432.vi"sv, "e386009e5cf1f77979c8ba910699547b6aa9b773"sv}, Entry{"accessor/v1-accounts.2432-2496.efi"sv, "9d629f5827ff2157047466f599b8c842cac84223"sv}, Entry{"accessor/v1-accounts.2432-2496.vi"sv, "72f9bce23027d48b44895f6ab7e0c4ebd803d189"sv}, Entry{"accessor/v1-accounts.2496-2560.efi"sv, "6ae19f9a6e8d86db5847f679a4f416becfbcecd7"sv}, Entry{"accessor/v1-accounts.2496-2560.vi"sv, "ba7c9edb11d1c96a9f7b75abae36501c0ffdd952"sv}, Entry{"accessor/v1-accounts.256-320.efi"sv, "7ceb7219cdb4c578a97bce2977832b6c74bea04e"sv}, Entry{"accessor/v1-accounts.256-320.vi"sv, "113b140200b46679ac73cf81c2d9939cd1ea0084"sv}, Entry{"accessor/v1-accounts.2560-2624.efi"sv, "7ed7c509a06f020e79bc93999e59dec81db8abb4"sv}, Entry{"accessor/v1-accounts.2560-2624.vi"sv, "0cab0cf907b633fdcaa02771717c19afa637b018"sv}, Entry{"accessor/v1-accounts.2624-2688.efi"sv, "11a9476feee9e22095d7c53c9a4db5c7b752c812"sv}, Entry{"accessor/v1-accounts.2624-2688.vi"sv, "fd6107a96cf7788158ecd69dd7b2c4afccc3226d"sv}, Entry{"accessor/v1-accounts.2688-2752.efi"sv, "1d4f78018ae3a0227fc4d580685594fc75215a30"sv}, Entry{"accessor/v1-accounts.2688-2752.vi"sv, "a5f9ed5f772a24f3dee183005d3cefbc8bc4bbca"sv}, Entry{"accessor/v1-accounts.2752-2816.efi"sv, "d77d5d61896bfa30f2e8daae2e75f8043800401c"sv}, Entry{"accessor/v1-accounts.2752-2816.vi"sv, "babf437ae24b8034f60fbc223c7dfd15b8f24b34"sv}, Entry{"accessor/v1-accounts.2816-2880.efi"sv, "548c35d83b251cb77ab2976b93ce2fc2b65759a5"sv}, Entry{"accessor/v1-accounts.2816-2880.vi"sv, "fe5e4c8b52247097239722303ef11f08093cc26c"sv}, Entry{"accessor/v1-accounts.2848-2856.efi"sv, "ce93b74d4d150d4f51acd5621af1f77b12b465c4"sv}, Entry{"accessor/v1-accounts.2848-2856.vi"sv, "f5f05fc8e714400393f82903c682f25ac37bac6a"sv}, Entry{"accessor/v1-accounts.2856-2860.efi"sv, "0d5655a1011d28177fb76d93f8996fc9b7bee16c"sv}, Entry{"accessor/v1-accounts.2856-2860.vi"sv, "6850ce99a21f50e79308b9277138d0736c80abb3"sv}, Entry{"accessor/v1-accounts.2880-2912.efi"sv, "d159a8f27450630dd0841f76e807d425acdf6f5a"sv}, Entry{"accessor/v1-accounts.2880-2912.vi"sv, "b691761fe33233daa9066713984563a25fb601b3"sv}, Entry{"accessor/v1-accounts.2912-2928.efi"sv, "720afe8cc12f869cd039baa58b3182b4dcd25053"sv}, Entry{"accessor/v1-accounts.2912-2928.vi"sv, "d7f2b7fba89a5bd6ef060677f594636c00960a55"sv}, Entry{"accessor/v1-accounts.2928-2936.efi"sv, "704618ccebe8e0450c6c50ca9b3d0dd3bd6fdb83"sv}, Entry{"accessor/v1-accounts.2928-2936.vi"sv, "b7e938b17deb9453ad8458b2169314852d209315"sv}, Entry{"accessor/v1-accounts.2936-2940.efi"sv, "8281b0dbe9803633c9f76787762104cffcc9e455"sv}, Entry{"accessor/v1-accounts.2936-2940.vi"sv, "d4d3f596648230e3f21a0ccf7e474aab5a9aa630"sv}, Entry{"accessor/v1-accounts.320-384.efi"sv, "87dab7f4bd080ce55d12d63682baa4dffa041785"sv}, Entry{"accessor/v1-accounts.320-384.vi"sv, "1e24584aac474bf2a701aa18eff0cc651b499d45"sv}, Entry{"accessor/v1-accounts.384-448.efi"sv, "2e0d76d3392112875e7147d59726b0e538e44d7c"sv}, Entry{"accessor/v1-accounts.384-448.vi"sv, "a7280499f7e0cac36d776ab5da89b915c5528d99"sv}, Entry{"accessor/v1-accounts.448-512.efi"sv, "34f723e70922a12b5aeabbb884538e2842cc857e"sv}, Entry{"accessor/v1-accounts.448-512.vi"sv, "94fc96b2c5169c4c9dae40b7949630f03bf3d1d4"sv}, Entry{"accessor/v1-accounts.512-576.efi"sv, "c365d051fb03482672138875220f10ff9189658e"sv}, Entry{"accessor/v1-accounts.512-576.vi"sv, "87b60267c146e661b9a7597f95bc141762c2f26c"sv}, Entry{"accessor/v1-accounts.576-640.efi"sv, "3c8410f14318e3b5be87b5f0c0fe0dc62fd63149"sv}, Entry{"accessor/v1-accounts.576-640.vi"sv, "b76aa07d6511ef85d195c7f4c54bd41fe5fd27d5"sv}, Entry{"accessor/v1-accounts.64-128.efi"sv, "2f005c9efe53d2bd575a2a0063dbd0b4bd04d9e2"sv}, Entry{"accessor/v1-accounts.64-128.vi"sv, "95c04817eddf50342491907add425fa0aa3a54d8"sv}, Entry{"accessor/v1-accounts.640-704.efi"sv, "765fdc344c9ea9e200130571cbc8e02d47310941"sv}, Entry{"accessor/v1-accounts.640-704.vi"sv, "093da622e0971490100a0ecc136f4caf58c03059"sv}, Entry{"accessor/v1-accounts.704-768.efi"sv, "c1593f2df495882eb51b0c5b479db526d11933b0"sv}, Entry{"accessor/v1-accounts.704-768.vi"sv, "148a5f11dceff56c41f2d4c4612e778ed5bbc9aa"sv}, Entry{"accessor/v1-accounts.768-832.efi"sv, "d087bbaf352c7f5d7d5ae2d5856357b165e51c87"sv}, Entry{"accessor/v1-accounts.768-832.vi"sv, "ded6717bb05cacbffaff99e4cab85b998e6c5e7e"sv}, Entry{"accessor/v1-accounts.832-896.efi"sv, "71fb815e1a469dd9f1974aad0db1b858d6c1e891"sv}, Entry{"accessor/v1-accounts.832-896.vi"sv, "5d36c732c0b52bb863b59d6adf3b4dfcb5616837"sv}, Entry{"accessor/v1-accounts.896-960.efi"sv, "cb0b3243d5ebc2b172e16907bbb8d9e9aad2e905"sv}, Entry{"accessor/v1-accounts.896-960.vi"sv, "25b282634655874c14a3d8f0c0f29c94ab18dbd4"sv}, Entry{"accessor/v1-accounts.960-1024.efi"sv, "aa466cd96d7e97ffb7367f5defd76325ec315cea"sv}, Entry{"accessor/v1-accounts.960-1024.vi"sv, "b8d6b91ec047a4b4ca36ed926a7909a5fec9a80a"sv}, Entry{"accessor/v1-code.0-64.efi"sv, "0f4037e36e84bf5e401ce6fdece65b43011f572d"sv}, Entry{"accessor/v1-code.0-64.vi"sv, "09b123e49e142aad634d7de767dd55811e0e7964"sv}, Entry{"accessor/v1-code.1024-1088.efi"sv, "ba1443e8693da5f7178ae1698a0757db80525b27"sv}, Entry{"accessor/v1-code.1024-1088.vi"sv, "ff3ed597c23adfd2258eb32b719e93ef2b369662"sv}, Entry{"accessor/v1-code.1088-1152.efi"sv, "5160e35bc2543618827f9f9130fd9b042477c5ea"sv}, Entry{"accessor/v1-code.1088-1152.vi"sv, "2f261fd07ea7585791d2a9b397d7d1fe47628df4"sv}, Entry{"accessor/v1-code.1152-1216.efi"sv, "e88c979b34b5848614b0b487dd8e95e13f21a071"sv}, Entry{"accessor/v1-code.1152-1216.vi"sv, "a87198e3c21c1b203b5befbd91fe10f645b01e7d"sv}, Entry{"accessor/v1-code.1216-1280.efi"sv, "896ea0203bb1079e3b3489f9eb4a0862056cbc3a"sv}, Entry{"accessor/v1-code.1216-1280.vi"sv, "f9049334d0ad64779661839abbd2bf3d468a4c7c"sv}, Entry{"accessor/v1-code.128-192.efi"sv, "3ca677ae2c9a9404989ffacd466286d3710bc3e3"sv}, Entry{"accessor/v1-code.128-192.vi"sv, "a861f8eeb298d90242630a61e2d12fcc5859e435"sv}, Entry{"accessor/v1-code.1280-1344.efi"sv, "00ff7000c26097a838f818d72c8a6050eb781474"sv}, Entry{"accessor/v1-code.1280-1344.vi"sv, "8c936b8e184f77ad251d4387ee0550641687bf3e"sv}, Entry{"accessor/v1-code.1344-1408.efi"sv, "cd963d210d5beb658bbde89f3ca10bfb06419d62"sv}, Entry{"accessor/v1-code.1344-1408.vi"sv, "3340afe595ce2c911faaf2d64a00e38eb973a359"sv}, Entry{"accessor/v1-code.1408-1472.efi"sv, "bccd5452c927f56f20bd9fc51b33d943b3b716e5"sv}, Entry{"accessor/v1-code.1408-1472.vi"sv, "cfc5a59d3dd338511601e100b3653157d03a32e4"sv}, Entry{"accessor/v1-code.1472-1536.efi"sv, "2ad37deb27d71fbafc4e816c23cadfe85ba8b71b"sv}, Entry{"accessor/v1-code.1472-1536.vi"sv, "e09e28ca9eed3fe73c2816fc905a028fa277f5d7"sv}, Entry{"accessor/v1-code.1536-1600.efi"sv, "6628efedb25c171cf3e4fd87d9696b0a76ed0e57"sv}, Entry{"accessor/v1-code.1536-1600.vi"sv, "04e80adf0b6184ae7c34937d7b1ebf11e97c7d7d"sv}, Entry{"accessor/v1-code.1600-1664.efi"sv, "f6ec1f60137224e1063d20f8f0025a4300d284c3"sv}, Entry{"accessor/v1-code.1600-1664.vi"sv, "8490c2d61be73280c349a2bf02d9137b332abeb5"sv}, Entry{"accessor/v1-code.1664-1728.efi"sv, "d33a2239501c2fda709d9b4819bfc143080770d7"sv}, Entry{"accessor/v1-code.1664-1728.vi"sv, "12b8b48efcba0609a27a316ecf9010e9a6858cb2"sv}, Entry{"accessor/v1-code.1728-1792.efi"sv, "130e9b715e64c260921033866d6942fe8c70561b"sv}, Entry{"accessor/v1-code.1728-1792.vi"sv, "5fd66b0accfcf8559b4aa0574f6ed48e3cb59393"sv}, Entry{"accessor/v1-code.1792-1856.efi"sv, "6bb276edd37390e718cca25eadf4568d92574dad"sv}, Entry{"accessor/v1-code.1792-1856.vi"sv, "9f98aa718bfe800c342ce57c3f888a4f36dc3ea9"sv}, Entry{"accessor/v1-code.1856-1920.efi"sv, "9b5ec3304ffd648044d88c9a6fa9a36623e320f4"sv}, Entry{"accessor/v1-code.1856-1920.vi"sv, "59ca32d58f32077f4ed2a49aa81394e7d26c2b8c"sv}, Entry{"accessor/v1-code.192-256.efi"sv, "aa233be5d302989c8263f973cbf956590274c7ce"sv}, Entry{"accessor/v1-code.192-256.vi"sv, "f570e76ea71160883da7f6d936dcffce16fffb1d"sv}, Entry{"accessor/v1-code.1920-1984.efi"sv, "9199fc79ca1130fae8efad3d565f00180438a5fd"sv}, Entry{"accessor/v1-code.1920-1984.vi"sv, "fed93a81ce77d1e66c9c288b09cefd709eec1466"sv}, Entry{"accessor/v1-code.1984-2048.efi"sv, "ca6b56fea44a1cf229195361c9e260ac4ff875c4"sv}, Entry{"accessor/v1-code.1984-2048.vi"sv, "f21c46643fa5111fcebcef24a74ebb2f9320f5a4"sv}, Entry{"accessor/v1-code.2048-2112.efi"sv, "ea309c636fedec44b59112a0071ad5c0f6ab0a3a"sv}, Entry{"accessor/v1-code.2048-2112.vi"sv, "9fe180ef8b94413b67fe2658e1cbcea47c8550b2"sv}, Entry{"accessor/v1-code.2112-2176.efi"sv, "93603626df5ad030271538ef5f77617df8fe23f8"sv}, Entry{"accessor/v1-code.2112-2176.vi"sv, "848204dd924f8aa0a74115e6ebd70840af274d2b"sv}, Entry{"accessor/v1-code.2176-2240.efi"sv, "75abc0dc713d99f5fcce45f69517c7eb14da47a4"sv}, Entry{"accessor/v1-code.2176-2240.vi"sv, "ee10fef3a98f8ba65aac523b479a8eef602f0cf9"sv}, Entry{"accessor/v1-code.2240-2304.efi"sv, "27fd419d6c3ae76c3658e65472c717f54a25cf0c"sv}, Entry{"accessor/v1-code.2240-2304.vi"sv, "1b1a9557b5d17f98f8a69f981d20e6d4aed9dcc9"sv}, Entry{"accessor/v1-code.2304-2368.efi"sv, "d41fba259e4fb90c73f9f1d8b94e11cf863d3db7"sv}, Entry{"accessor/v1-code.2304-2368.vi"sv, "d468fb040191392d29aab676126a19359cb0c7fd"sv}, Entry{"accessor/v1-code.2368-2432.efi"sv, "c9718066537b5bb4c2af7a285d6e16a8248e899f"sv}, Entry{"accessor/v1-code.2368-2432.vi"sv, "9a87ea54f855433ad71878137dd7903b7380e8b6"sv}, Entry{"accessor/v1-code.2432-2496.efi"sv, "fe998cf70d10c354de6450533932700f9ea161d2"sv}, Entry{"accessor/v1-code.2432-2496.vi"sv, "f513af82a299564d68b4612f92a7906eb79c9bb6"sv}, Entry{"accessor/v1-code.2496-2560.efi"sv, "6371ab88d157db2689e2e23e6abdd660b9db9ee9"sv}, Entry{"accessor/v1-code.2496-2560.vi"sv, "9532cb3d69b1c47ecc2aaa9186e0662835487fb4"sv}, Entry{"accessor/v1-code.256-320.efi"sv, "4d6faa023b491e7a011d55edf56fc729434067fd"sv}, Entry{"accessor/v1-code.256-320.vi"sv, "2213c21285177e0c8bed280e91da476eac645cff"sv}, Entry{"accessor/v1-code.2560-2624.efi"sv, "13e0a99390dc08fb7c19b84f5053f718f0fa8b01"sv}, Entry{"accessor/v1-code.2560-2624.vi"sv, "0dd3ba8ebbdb508627cb3eab2095651eb6d4db5a"sv}, Entry{"accessor/v1-code.2624-2688.efi"sv, "f8fb15febced2f22d831ab4017bc55e27e826214"sv}, Entry{"accessor/v1-code.2624-2688.vi"sv, "9c81f3337bde3047c3324b83723eece3edc3a92d"sv}, Entry{"accessor/v1-code.2688-2752.efi"sv, "7c6c7c413ee82344a61d1078ccd5193079e74301"sv}, Entry{"accessor/v1-code.2688-2752.vi"sv, "68f9e26c388e6779b2080c49d7ba7ed1d309cf3c"sv}, Entry{"accessor/v1-code.2752-2816.efi"sv, "ebbc5b2392355279cab58c0fb312d56d65558ee2"sv}, Entry{"accessor/v1-code.2752-2816.vi"sv, "4f8182806eca1bc23edc9d31266cb38076daa308"sv}, Entry{"accessor/v1-code.2816-2880.efi"sv, "04ad0b91f039608fd590e575f57b8389772640ae"sv}, Entry{"accessor/v1-code.2816-2880.vi"sv, "40f6f431cd87b9c801e630a08c0eed1d953e6ee0"sv}, Entry{"accessor/v1-code.2848-2856.efi"sv, "25eed843d1c5df85277d1716ea859e08aa267d44"sv}, Entry{"accessor/v1-code.2848-2856.vi"sv, "ef47d700e108442efb2b3a6d4b0450ec1226fd6b"sv}, Entry{"accessor/v1-code.2856-2860.efi"sv, "131bd4ba0b3ae386018d64816630ec82978ea964"sv}, Entry{"accessor/v1-code.2856-2860.vi"sv, "7968a306e9f2a7378509201ffd9015cd07b64bdd"sv}, Entry{"accessor/v1-code.2880-2912.efi"sv, "1e2341b7d2cea7aff8d285e5529f3c5acf5780b4"sv}, Entry{"accessor/v1-code.2880-2912.vi"sv, "fcb4c3fd7dfcbbaccb261b1b65acec758ea671bc"sv}, Entry{"accessor/v1-code.2912-2928.efi"sv, "186cceb648887580f095ed70d77ccd19baf436d7"sv}, Entry{"accessor/v1-code.2912-2928.vi"sv, "bd4b0b634dbd51e6d602f3026023c0be88636f20"sv}, Entry{"accessor/v1-code.2928-2936.efi"sv, "1b1ccc95a19607af42ab027151ffe1da385c6fd7"sv}, Entry{"accessor/v1-code.2928-2936.vi"sv, "33e91a08e4d25f14873e0774c344477ee129b2e0"sv}, Entry{"accessor/v1-code.2936-2940.efi"sv, "722eb07264a38a05f16f52a9e8c0d0813002a4a2"sv}, Entry{"accessor/v1-code.2936-2940.vi"sv, "86e0a71fcdc3b4bf5e461d7d7a4fddec001c8b07"sv}, Entry{"accessor/v1-code.320-384.efi"sv, "376e3a4ffaaef7fe5d56dc8d4a6444c6845271a9"sv}, Entry{"accessor/v1-code.320-384.vi"sv, "87abde5b6b644b111591148267112404c6db7cd4"sv}, Entry{"accessor/v1-code.384-448.efi"sv, "5182cbbf7c002fef7578d88532216b7524a4b862"sv}, Entry{"accessor/v1-code.384-448.vi"sv, "495041f47a83567faa755d612c16380b1408d6c9"sv}, Entry{"accessor/v1-code.448-512.efi"sv, "6f73c991bb1e6e5b4ab3c0f298f7fefafb08294e"sv}, Entry{"accessor/v1-code.448-512.vi"sv, "20742588e7821d9f285ec806594cd1c3f81347dd"sv}, Entry{"accessor/v1-code.512-576.efi"sv, "8cd2abce64e6629687faeda0e34f56170ebb4de5"sv}, Entry{"accessor/v1-code.512-576.vi"sv, "4dec2f586764185b8e1bd104c729743c4714d3b8"sv}, Entry{"accessor/v1-code.576-640.efi"sv, "55e4278e3f25b0f0bc93d95a35746962837b1ef8"sv}, Entry{"accessor/v1-code.576-640.vi"sv, "9312c85a68b63419e27ec981c016079f380e1b33"sv}, Entry{"accessor/v1-code.64-128.efi"sv, "f7d084fc65ca81f1e840a5afe74701a1be5d6bc3"sv}, Entry{"accessor/v1-code.64-128.vi"sv, "d4d161a98cd0852c3d3af50b5cdced5ebb68d974"sv}, Entry{"accessor/v1-code.640-704.efi"sv, "61e91d59888eaa50024a9f05f2c3316cb5be40e3"sv}, Entry{"accessor/v1-code.640-704.vi"sv, "ce95c02496a642fce60b410f4d9f920bbbc026be"sv}, Entry{"accessor/v1-code.704-768.efi"sv, "d09b00cc6731c528081b4e45ba2b86c42d035640"sv}, Entry{"accessor/v1-code.704-768.vi"sv, "6b7b0b49f0a81a9dae838d5cfdab0482b0172911"sv}, Entry{"accessor/v1-code.768-832.efi"sv, "258cb7489db4178e420bb3e2667bfa0d2ae64d3f"sv}, Entry{"accessor/v1-code.768-832.vi"sv, "2592b330509770e3f5b7e9e912a5e3d9f7582f7e"sv}, Entry{"accessor/v1-code.832-896.efi"sv, "831e18434dcfd2d9ae362d07dfd4fc07ec5cbaf0"sv}, Entry{"accessor/v1-code.832-896.vi"sv, "58c7a95a1714b388726dcc37aa27c26bcf55dcd6"sv}, Entry{"accessor/v1-code.896-960.efi"sv, "a88ab33d26ccf2fb085bb8db8c92798271b86869"sv}, Entry{"accessor/v1-code.896-960.vi"sv, "bdfa39488b68c540f360be735b5adaf39f9291b4"sv}, Entry{"accessor/v1-code.960-1024.efi"sv, "3f026fd38946074f83049088b4148c271177669a"sv}, Entry{"accessor/v1-code.960-1024.vi"sv, "fdbb9cacb8af26c2f9e10c30c215f0f411ab1000"sv}, Entry{"accessor/v1-logaddrs.0-64.efi"sv, "b65ddb19d41877f53e70475283215eb18663f527"sv}, Entry{"accessor/v1-logaddrs.1024-1088.efi"sv, "5d98d9467c67c0fbe54250024d8f54ef676ab51b"sv}, Entry{"accessor/v1-logaddrs.1088-1152.efi"sv, "401e2b8aae2fc8f6fd20949c79e037c66a0a02fb"sv}, Entry{"accessor/v1-logaddrs.1152-1216.efi"sv, "0b8c5496f5232b4f79d3521289f410bbdf2c4ff5"sv}, Entry{"accessor/v1-logaddrs.1216-1280.efi"sv, "da96ace8905c47acc89fa63fa4146e32a08be043"sv}, Entry{"accessor/v1-logaddrs.128-192.efi"sv, "5ed7552ccd06a969d374a1e789c0f68251d32fe1"sv}, Entry{"accessor/v1-logaddrs.1280-1344.efi"sv, "77f07d66f1094c7073db4430e73cdda6d384e80d"sv}, Entry{"accessor/v1-logaddrs.1344-1408.efi"sv, "1f373d492fb50d70179bd45857100a23a389b31f"sv}, Entry{"accessor/v1-logaddrs.1408-1472.efi"sv, "9d4b266853b7541a90a6d737b3b28521ac1173cb"sv}, Entry{"accessor/v1-logaddrs.1472-1536.efi"sv, "c4323f00a57516046bea0fa8abd52d20da5372cc"sv}, Entry{"accessor/v1-logaddrs.1536-1600.efi"sv, "0b52e9498ec005158dc655d3cf768cdfcfbe288d"sv}, Entry{"accessor/v1-logaddrs.1600-1664.efi"sv, "638cd6456cd5b245f3ce6286992205c120720360"sv}, Entry{"accessor/v1-logaddrs.1664-1728.efi"sv, "8d5f1bfd333854d03906deb58972be9051bb02a2"sv}, Entry{"accessor/v1-logaddrs.1728-1792.efi"sv, "65a97681f6af0e93c83206adf1de3f4ab33d38a0"sv}, Entry{"accessor/v1-logaddrs.1792-1856.efi"sv, "2aa042d231b18071bf51d65f4e6aecd507226d47"sv}, Entry{"accessor/v1-logaddrs.1856-1920.efi"sv, "286518b76cdf50c4e775ab10435351535ef618fb"sv}, Entry{"accessor/v1-logaddrs.192-256.efi"sv, "a11bff168e506b63f6951569967c6b91250d8269"sv}, Entry{"accessor/v1-logaddrs.1920-1984.efi"sv, "2fd77f70cefe7774a8400e8d09bddd57738b721b"sv}, Entry{"accessor/v1-logaddrs.1984-2048.efi"sv, "faa6a02d28e84ebb9e6a3537b7c900ff20982df6"sv}, Entry{"accessor/v1-logaddrs.2048-2112.efi"sv, "6334e484446d52c0e1dff8fe043dcb50b1b4b387"sv}, Entry{"accessor/v1-logaddrs.2112-2176.efi"sv, "fc463d51afdf0cf8f3d81e5c1d300065bd73b6ba"sv}, Entry{"accessor/v1-logaddrs.2176-2240.efi"sv, "1fdf33d231200657ce0bb909e0e3e3ff2b54fb37"sv}, Entry{"accessor/v1-logaddrs.2240-2304.efi"sv, "56f8933a5fd79a16c282c411f9fd005795a73bda"sv}, Entry{"accessor/v1-logaddrs.2304-2368.efi"sv, "d8cdb2013841b2d71b6e5b641acd1b4c97cc17f4"sv}, Entry{"accessor/v1-logaddrs.2368-2432.efi"sv, "477002490620dd1578cd7e2401896ff8220074e1"sv}, Entry{"accessor/v1-logaddrs.2432-2496.efi"sv, "d394a2f1f0f3dc3ef0b7a9105d5c66f4da2a945d"sv}, Entry{"accessor/v1-logaddrs.2496-2560.efi"sv, "394b1afde413442dff9bfc6bf9f18ac2de83c06f"sv}, Entry{"accessor/v1-logaddrs.256-320.efi"sv, "ea57cb2cf79796f2b99674c4fe0e688eb906976c"sv}, Entry{"accessor/v1-logaddrs.2560-2624.efi"sv, "2ec76a99a96bf94019c4bde9188b3657a8adf776"sv}, Entry{"accessor/v1-logaddrs.2624-2688.efi"sv, "e482946ec13ed5b42abad92fa9807b9afc81ddc5"sv}, Entry{"accessor/v1-logaddrs.2688-2752.efi"sv, "f6f2813a6cecbf0bd07d84f4035b72c2a2a7ab32"sv}, Entry{"accessor/v1-logaddrs.2752-2816.efi"sv, "d92f6e51a6e248aad451c7505f667979e0c111b3"sv}, Entry{"accessor/v1-logaddrs.2816-2880.efi"sv, "3478ecf3e4138f92824d9b3af9ac3e4ff15fe243"sv}, Entry{"accessor/v1-logaddrs.2848-2856.efi"sv, "a158c60b54165b8197310cc13d7c8aec99131883"sv}, Entry{"accessor/v1-logaddrs.2856-2860.efi"sv, "516e24b33c705d966a3dad260b7b1c861a4643d2"sv}, Entry{"accessor/v1-logaddrs.2880-2912.efi"sv, "6190be0ae3062b29e8c89460b75a996b4ed202d4"sv}, Entry{"accessor/v1-logaddrs.2912-2928.efi"sv, "c7518d96c58e1ad63c48ecb86d2319bc8eee0a7f"sv}, Entry{"accessor/v1-logaddrs.2928-2936.efi"sv, "7ac66641c0ea20f42a0baf7aed942fd4d512900e"sv}, Entry{"accessor/v1-logaddrs.2936-2940.efi"sv, "0dc79f025f82a250e2835680356344dda1033013"sv}, Entry{"accessor/v1-logaddrs.320-384.efi"sv, "c15e8d0365a0c2550c59e467918c3e22554556ef"sv}, Entry{"accessor/v1-logaddrs.384-448.efi"sv, "a44447a40f45b7f01457aa8bcfb82c8e9703e91f"sv}, Entry{"accessor/v1-logaddrs.448-512.efi"sv, "3ce20b161b04c7fbc2d60d1b90f03301a0fd952c"sv}, Entry{"accessor/v1-logaddrs.512-576.efi"sv, "2ea690244ed544bc658ccf61a3fac81f6630199b"sv}, Entry{"accessor/v1-logaddrs.576-640.efi"sv, "d075d4fa99667ac25e1cea60528f49a4b5e8a030"sv}, Entry{"accessor/v1-logaddrs.64-128.efi"sv, "e033147dd9b31b1ebeea2df9106a4d729eda4951"sv}, Entry{"accessor/v1-logaddrs.640-704.efi"sv, "79cd80b62d084773198212e1e15f4106c5ddaf34"sv}, Entry{"accessor/v1-logaddrs.704-768.efi"sv, "2d1b7a48316c6e877319d57a7b2f797b28f6cc37"sv}, Entry{"accessor/v1-logaddrs.768-832.efi"sv, "bc6a14ef680c456f1a2e0ac9af8d924dc0f9f1f0"sv}, Entry{"accessor/v1-logaddrs.832-896.efi"sv, "b514afdcc10e5866d739f367b74320b801d5df12"sv}, Entry{"accessor/v1-logaddrs.896-960.efi"sv, "7d7525ad8ec2339486fdf055054181e00f46d84a"sv}, Entry{"accessor/v1-logaddrs.960-1024.efi"sv, "48093f98ab8d0ce2dfbc7641c4b1887693b18292"sv}, Entry{"accessor/v1-logtopics.0-64.efi"sv, "1a0cd634ee4ae5942f4f2026f12d016cb96b1d88"sv}, Entry{"accessor/v1-logtopics.1024-1088.efi"sv, "98633b1c857c13d8ed30b5b17abf2851f01e7236"sv}, Entry{"accessor/v1-logtopics.1088-1152.efi"sv, "2f0dc18923988f99cb03bf6b818cdd81d4daaa52"sv}, Entry{"accessor/v1-logtopics.1152-1216.efi"sv, "842927e1e21cc65838928b275814f95f25ebbade"sv}, Entry{"accessor/v1-logtopics.1216-1280.efi"sv, "d85e89c2e672aa241864d373c1d2bed375557530"sv}, Entry{"accessor/v1-logtopics.128-192.efi"sv, "4c7cad6f4b8bf16591e69fd3b1aea4c6f87f0d32"sv}, Entry{"accessor/v1-logtopics.1280-1344.efi"sv, "274a7041844625fe0b92e3b4d16600c01f7da6a3"sv}, Entry{"accessor/v1-logtopics.1344-1408.efi"sv, "007c56cad903dd0273787ce9e9b82b94609a47c1"sv}, Entry{"accessor/v1-logtopics.1408-1472.efi"sv, "f2398375d859b7bc72ab35dd0b24cc7865a161b6"sv}, Entry{"accessor/v1-logtopics.1472-1536.efi"sv, "a5934392ef29b3aa42a3f9211b0c936999901682"sv}, Entry{"accessor/v1-logtopics.1536-1600.efi"sv, "cb10e405c5b6ff61bed4593e4248807b9c2e9d46"sv}, Entry{"accessor/v1-logtopics.1600-1664.efi"sv, "18a0900356d8582fb1099883e4e99bf22a97bd93"sv}, Entry{"accessor/v1-logtopics.1664-1728.efi"sv, "189a77668e02b576c00e29acb62da6b9cbbc2a73"sv}, Entry{"accessor/v1-logtopics.1728-1792.efi"sv, "bb1eee7a4dbae76f7c73d738e763517f54f45416"sv}, Entry{"accessor/v1-logtopics.1792-1856.efi"sv, "2c7c570402db1f22e64e6b4e1680d36bb057fb60"sv}, Entry{"accessor/v1-logtopics.1856-1920.efi"sv, "d3d1358966505d5c2dd9354b75d8831a196797a8"sv}, Entry{"accessor/v1-logtopics.192-256.efi"sv, "660fa4b4b60b424cd21bce4f8bd989414dacff9b"sv}, Entry{"accessor/v1-logtopics.1920-1984.efi"sv, "b741ceb3dc6e245daf25aff8fbcb57c3fef37a6b"sv}, Entry{"accessor/v1-logtopics.1984-2048.efi"sv, "81ab4f3cfdb06a9e52a58cedd45f9e5e85f16f9b"sv}, Entry{"accessor/v1-logtopics.2048-2112.efi"sv, "d61056ed49102d830799b79f393cc4a8e2f0e877"sv}, Entry{"accessor/v1-logtopics.2112-2176.efi"sv, "189df4eb0e72ea2de37e36aaeb45c2ffb8d6b3d8"sv}, Entry{"accessor/v1-logtopics.2176-2240.efi"sv, "66842107a7b38283976099911724f1154040c838"sv}, Entry{"accessor/v1-logtopics.2240-2304.efi"sv, "66bc5e0ba3fd01e4bb497bb3aa356b652b333cd7"sv}, Entry{"accessor/v1-logtopics.2304-2368.efi"sv, "687b23ce458edce09b31a2271d680a813a8a56ff"sv}, Entry{"accessor/v1-logtopics.2368-2432.efi"sv, "ad9f5c6cba5dd717f1d2f5a532ef0be61e5dd6b1"sv}, Entry{"accessor/v1-logtopics.2432-2496.efi"sv, "965a88caef4329b7d83296a8ac9172ac21941aea"sv}, Entry{"accessor/v1-logtopics.2496-2560.efi"sv, "d82153dac1ac933d27103c300c52599d63173ed1"sv}, Entry{"accessor/v1-logtopics.256-320.efi"sv, "3f654a329ceb57ad156d6018560e345e71007abf"sv}, Entry{"accessor/v1-logtopics.2560-2624.efi"sv, "cd83d434069f82aa8697aec6f48be3e58a6e372f"sv}, Entry{"accessor/v1-logtopics.2624-2688.efi"sv, "500777abfbd54a092ef72547418a260ff662a870"sv}, Entry{"accessor/v1-logtopics.2688-2752.efi"sv, "63dce14edf4d9a600337fb845f2f8c8da7291e65"sv}, Entry{"accessor/v1-logtopics.2752-2816.efi"sv, "3aa51ebbbdd0f1dc80b2840d89a16ceb94537326"sv}, Entry{"accessor/v1-logtopics.2816-2880.efi"sv, "ae58fb46f6401e8893c8f968def1acac06ce62e4"sv}, Entry{"accessor/v1-logtopics.2848-2856.efi"sv, "fac202d46718c4ef577e302eb5ab9536f64b2480"sv}, Entry{"accessor/v1-logtopics.2856-2860.efi"sv, "3d82b62613096f5207e11c78b74916c3e58c902e"sv}, Entry{"accessor/v1-logtopics.2880-2912.efi"sv, "26e2e47a43042f2f227b3ccd531d9869f90d9bc0"sv}, Entry{"accessor/v1-logtopics.2912-2928.efi"sv, "01d5b92aad0675b2fef6bc53c0d8e5f46e4365b5"sv}, Entry{"accessor/v1-logtopics.2928-2936.efi"sv, "bfed6326301ab935f48bb39c54d46b6689817467"sv}, Entry{"accessor/v1-logtopics.2936-2940.efi"sv, "14ec3376ad2b8460f91ab8f568778524bcd5550e"sv}, Entry{"accessor/v1-logtopics.320-384.efi"sv, "c68f7f499941a5cd8ea6c32e8f71a06aac1b610b"sv}, Entry{"accessor/v1-logtopics.384-448.efi"sv, "06eb2cff77373c525a2fb422353f828b7fff1c55"sv}, Entry{"accessor/v1-logtopics.448-512.efi"sv, "7cecbb1bb5c28940a3f844699b2a13c1ad84fad9"sv}, Entry{"accessor/v1-logtopics.512-576.efi"sv, "91e75fb83be17543c51a5a88ee377df91b488b5c"sv}, Entry{"accessor/v1-logtopics.576-640.efi"sv, "5f53bc327091aa9f8846e6e7961b7d9ae81ca3ad"sv}, Entry{"accessor/v1-logtopics.64-128.efi"sv, "240177221ae16c9474933651a0a2aaeb028d916f"sv}, Entry{"accessor/v1-logtopics.640-704.efi"sv, "871f13d7dd3b7c30d6d113f29fe7249163101776"sv}, Entry{"accessor/v1-logtopics.704-768.efi"sv, "c2e4e74572f456d1d3531b6fc27d6ec2bef2d1a5"sv}, Entry{"accessor/v1-logtopics.768-832.efi"sv, "e8a242304e87a3dd2067ba0314b2c13d8fae68a0"sv}, Entry{"accessor/v1-logtopics.832-896.efi"sv, "30c5c92de3a46fd208c072460d37622f69971fbf"sv}, Entry{"accessor/v1-logtopics.896-960.efi"sv, "93d34170c6da5c283a1610494df34fedf06681c6"sv}, Entry{"accessor/v1-logtopics.960-1024.efi"sv, "ccb96bcc446cc07cc7562368890b5393bdb632e8"sv}, Entry{"accessor/v1-receipt.0-64.efi"sv, "6c31a83b2ea1811d713907120a2393d1693f7894"sv}, Entry{"accessor/v1-receipt.0-64.vi"sv, "660fb96f783af05ff257f461da790893a7d126e2"sv}, Entry{"accessor/v1-receipt.1024-1088.efi"sv, "d89e2f5674124eda3cef41c7300f9ecae235aabd"sv}, Entry{"accessor/v1-receipt.1024-1088.vi"sv, "eb07d5ebf1a44254c7b490b6ae9d07ea0d88b89e"sv}, Entry{"accessor/v1-receipt.1088-1152.efi"sv, "8d9794dfa3daaccef2ec1d2c2ca852fbe681ae8c"sv}, Entry{"accessor/v1-receipt.1088-1152.vi"sv, "a6086d028a50aeaa6cb239cbc4501c8af31bd901"sv}, Entry{"accessor/v1-receipt.1152-1216.efi"sv, "d0ca651966092c8aa6c5153729b2e4a5735a5937"sv}, Entry{"accessor/v1-receipt.1152-1216.vi"sv, "eec0f5af8e19771e93d72738be91302e20b9de5a"sv}, Entry{"accessor/v1-receipt.1216-1280.efi"sv, "1ae060a13fa5394f0edab753c2456dae5289a4b9"sv}, Entry{"accessor/v1-receipt.1216-1280.vi"sv, "b7e2341217005974f1df1c333ebc9e0d7ab4a964"sv}, Entry{"accessor/v1-receipt.128-192.efi"sv, "f8085d08c5f4995a0abde55bbf6d0537e95b52b8"sv}, Entry{"accessor/v1-receipt.128-192.vi"sv, "882f1c3fc12a9e7e4024c32bc059edf810793310"sv}, Entry{"accessor/v1-receipt.1280-1344.efi"sv, "dbc3a1cdaa5fd371470e2dae023a0f892542bc0d"sv}, Entry{"accessor/v1-receipt.1280-1344.vi"sv, "6cc3434f195c5f798b5b1f5a17ef781a1b38cfdb"sv}, Entry{"accessor/v1-receipt.1344-1408.efi"sv, "36785c1867e0d1183b89433141f6cae8a0978c93"sv}, Entry{"accessor/v1-receipt.1344-1408.vi"sv, "30edaa85acd8fb5c8a11ed4b600cc05a32fd1b60"sv}, Entry{"accessor/v1-receipt.1408-1472.efi"sv, "c304a1e16d9be2ab0a8334434cc0f425a4a8f6ef"sv}, Entry{"accessor/v1-receipt.1408-1472.vi"sv, "1ee69ef4099e4546e83f92c293a811785e467c95"sv}, Entry{"accessor/v1-receipt.1472-1536.efi"sv, "7bf015134c1559199c5ecee860f036b7aa6292e2"sv}, Entry{"accessor/v1-receipt.1472-1536.vi"sv, "e8bc7d95373016181356d075758ab665df38af79"sv}, Entry{"accessor/v1-receipt.1536-1600.efi"sv, "6f8aa9526dbf2914855c2faed3fae3004b0474e8"sv}, Entry{"accessor/v1-receipt.1536-1600.vi"sv, "235d127f90c7e9702de6518fe3b5ae03ff51eac5"sv}, Entry{"accessor/v1-receipt.1600-1664.efi"sv, "6b7b355ecf79cc461fe307863d7acc2d54f03143"sv}, Entry{"accessor/v1-receipt.1600-1664.vi"sv, "dbd3e30125ac9540a326e88ad720bd5771ea747b"sv}, Entry{"accessor/v1-receipt.1664-1728.efi"sv, "b564c102af112c6fd6a11d9c894aba715ef40b5a"sv}, Entry{"accessor/v1-receipt.1664-1728.vi"sv, "3b34a4316cea692b97bd84347c0dc2fc65266fb3"sv}, Entry{"accessor/v1-receipt.1728-1792.efi"sv, "ea39e55b1224ba328c2a3a55dc9ef5e4bcb31751"sv}, Entry{"accessor/v1-receipt.1728-1792.vi"sv, "9661e4bcafc30aba3e25025adc45e5cb535592e8"sv}, Entry{"accessor/v1-receipt.1792-1856.efi"sv, "d024bca66dc0cead2d3b4f187a3ec6bd2e8624c4"sv}, Entry{"accessor/v1-receipt.1792-1856.vi"sv, "a6d81ba0d3e8569ce19866df24ecf675fba22d1b"sv}, Entry{"accessor/v1-receipt.1856-1920.efi"sv, "7105d19596bc05b2b007b11ac5e275af7ab27cdb"sv}, Entry{"accessor/v1-receipt.1856-1920.vi"sv, "dba703d3d65ad910e1f4a61e396a97a98b4ec606"sv}, Entry{"accessor/v1-receipt.192-256.efi"sv, "f52f8080169c4f583dbc42e52772fdd0a86513f3"sv}, Entry{"accessor/v1-receipt.192-256.vi"sv, "0085d120b3eb4a21e930b8e71271f7254b0c10ae"sv}, Entry{"accessor/v1-receipt.1920-1984.efi"sv, "775050154332e1994ee8205fe0b0aaedef247f16"sv}, Entry{"accessor/v1-receipt.1920-1984.vi"sv, "c6b0a97cb7a98a4f9dfb62b860f0f7adb2e76f29"sv}, Entry{"accessor/v1-receipt.1984-2048.efi"sv, "481475ea863946d004b7c0b10faabaff874bbd2b"sv}, Entry{"accessor/v1-receipt.1984-2048.vi"sv, "2f04fdc0327a3a02ddee648188f90dbab1845f1e"sv}, Entry{"accessor/v1-receipt.2048-2112.efi"sv, "46e8f1b6ddd1d5a605cbf4134d114c1b15464473"sv}, Entry{"accessor/v1-receipt.2048-2112.vi"sv, "0513fb2baad18d07ce592a6e5a4185a217b73174"sv}, Entry{"accessor/v1-receipt.2112-2176.efi"sv, "cea131647aeb1bade02a7c6cc763267ae32e92c9"sv}, Entry{"accessor/v1-receipt.2112-2176.vi"sv, "f8d8f9fe7f2953e070bc66da25f9f8b8fe508312"sv}, Entry{"accessor/v1-receipt.2176-2240.efi"sv, "7244699b03e81a85ba18ea433c6cadfe16d0fd62"sv}, Entry{"accessor/v1-receipt.2176-2240.vi"sv, "2f3f065b581a64728fdf8865f40c26dcdae365cb"sv}, Entry{"accessor/v1-receipt.2240-2304.efi"sv, "44dae74c8744167ed9ab7c7a74b8ef5dfacff364"sv}, Entry{"accessor/v1-receipt.2240-2304.vi"sv, "fa89703576b50b9011a2a332130c19e3af260cf5"sv}, Entry{"accessor/v1-receipt.2304-2368.efi"sv, "34535b8604660135310f7cf30afac54ac66e661f"sv}, Entry{"accessor/v1-receipt.2304-2368.vi"sv, "2bc4fcf988391834edf199affc9fb998af50d8e9"sv}, Entry{"accessor/v1-receipt.2368-2432.efi"sv, "aa9111724d24c1efd11ef0f473221597e23893d2"sv}, Entry{"accessor/v1-receipt.2368-2432.vi"sv, "7ed23e4b514339f3cb1954d7ce9f73acaf3d7dd9"sv}, Entry{"accessor/v1-receipt.2432-2496.efi"sv, "0266f198e19b5f2566df9559de9874c4fe59ceec"sv}, Entry{"accessor/v1-receipt.2432-2496.vi"sv, "bee6054293a80ccc771689ce51d288aade06bc34"sv}, Entry{"accessor/v1-receipt.2496-2560.efi"sv, "ee28c878eb04a3b3115340fdb65042a4b8e93fcc"sv}, Entry{"accessor/v1-receipt.2496-2560.vi"sv, "2db699780dac80185d639a3015a91fa4a4b59773"sv}, Entry{"accessor/v1-receipt.256-320.efi"sv, "ec3669fd65630353e6e5148a071f6ac8e57a3451"sv}, Entry{"accessor/v1-receipt.256-320.vi"sv, "f840150301161e5f019b631e013fab252b516618"sv}, Entry{"accessor/v1-receipt.2560-2624.efi"sv, "7a8c8116ac418afdd47513863ea2e21e0c88c69c"sv}, Entry{"accessor/v1-receipt.2560-2624.vi"sv, "e25f1d8e215ece8574e0a6b9621a3f2eb97b66d9"sv}, Entry{"accessor/v1-receipt.2624-2688.efi"sv, "8ef541998e84a213cc151cb97a7e557f71df4b2b"sv}, Entry{"accessor/v1-receipt.2624-2688.vi"sv, "e103f86d5a72a0751f617675af07ba85f2dbca78"sv}, Entry{"accessor/v1-receipt.2688-2752.efi"sv, "724c0e22554287a07c2573d684d516e0300473b0"sv}, Entry{"accessor/v1-receipt.2688-2752.vi"sv, "1f16995c585164fd622c1432fdf25d1c174a7916"sv}, Entry{"accessor/v1-receipt.2752-2816.efi"sv, "e75433411f0f3af24bb376ca622959d81bdcfcb8"sv}, Entry{"accessor/v1-receipt.2752-2816.vi"sv, "4dfcb164c686e3b9f63e4479f084bb1fd4d45770"sv}, Entry{"accessor/v1-receipt.2816-2880.efi"sv, "92a4e2ddcaf7785cc009ed286e52768d6f821fe4"sv}, Entry{"accessor/v1-receipt.2816-2880.vi"sv, "878b00c5ef492671d9ef18ef1831185d4be86e51"sv}, Entry{"accessor/v1-receipt.2880-2912.efi"sv, "26280ca2b8d1072e0a37c05e567d666a9be94846"sv}, Entry{"accessor/v1-receipt.2880-2912.vi"sv, "b3b19b8ff85f61cf87361ad251df8fd36235203d"sv}, Entry{"accessor/v1-receipt.2912-2928.efi"sv, "a7c68fe1840ccd06e1eb5ff8ce13019362a1ab5b"sv}, Entry{"accessor/v1-receipt.2912-2928.vi"sv, "1a3369182a216a5b7b9551d4da2925df56245a1d"sv}, Entry{"accessor/v1-receipt.2928-2936.efi"sv, "799a11aef199cffca5b3ad2602e7c98409fc41dd"sv}, Entry{"accessor/v1-receipt.2928-2936.vi"sv, "13fc60a008b0af80248ff29568c48afecc6a7cf4"sv}, Entry{"accessor/v1-receipt.2936-2940.efi"sv, "7ab01ed4a78c98ef9bdf265137dc23b3b6287c11"sv}, Entry{"accessor/v1-receipt.2936-2940.vi"sv, "053e0871497ce925007d86fed424045872cd943a"sv}, Entry{"accessor/v1-receipt.320-384.efi"sv, "f3eb6b5208a2e17148ac32a2f3fb96e5a405332d"sv}, Entry{"accessor/v1-receipt.320-384.vi"sv, "e09c3cb384de5ff0a0596336324a05dde35dfdcf"sv}, Entry{"accessor/v1-receipt.384-448.efi"sv, "b0ccd7cb309e1a08415085b10065b9938d202df3"sv}, Entry{"accessor/v1-receipt.384-448.vi"sv, "d5dafae8ddcbd9ed2dae1f53cce08fafea63819c"sv}, Entry{"accessor/v1-receipt.448-512.efi"sv, "38c6349c96e6d3a9ac71aaba06a6a4d355cf3435"sv}, Entry{"accessor/v1-receipt.448-512.vi"sv, "e1ed6d09fa5e2347210d32b0f8e449a2295f8e05"sv}, Entry{"accessor/v1-receipt.512-576.efi"sv, "dcb7133db262dd1c9e705b3edb79721a14fd8b97"sv}, Entry{"accessor/v1-receipt.512-576.vi"sv, "5e32b258ca5195044872632b794ae556c419a56c"sv}, Entry{"accessor/v1-receipt.576-640.efi"sv, "b411f5500e97af1c3ef168b09502b9c09bfbca77"sv}, Entry{"accessor/v1-receipt.576-640.vi"sv, "5723e897a30bd79b9b59b8478345593895917b5e"sv}, Entry{"accessor/v1-receipt.64-128.efi"sv, "94e22fcb54b436c8baf45c027e0e6ba8be31ddb9"sv}, Entry{"accessor/v1-receipt.64-128.vi"sv, "dbd5d534b64bfc72554b8e6e52afc70db034c969"sv}, Entry{"accessor/v1-receipt.640-704.efi"sv, "9178f27115c403a5b834b02127d29ad01c1e364b"sv}, Entry{"accessor/v1-receipt.640-704.vi"sv, "f67994553f2d20a171959b8c5687487bf07bcf6a"sv}, Entry{"accessor/v1-receipt.704-768.efi"sv, "04518849130170f709b2e4c1c424dfe176c3ba3f"sv}, Entry{"accessor/v1-receipt.704-768.vi"sv, "c430d2a52605c35a311981fd69f2d36ab811224e"sv}, Entry{"accessor/v1-receipt.768-832.efi"sv, "2e18935c2dd5909836befa8b8cc0b826e4763753"sv}, Entry{"accessor/v1-receipt.768-832.vi"sv, "39d45f7208ce3788816ae279130234b4b5ef9ec6"sv}, Entry{"accessor/v1-receipt.832-896.efi"sv, "c52705af32cebfabaf092080f6ccfb1d1fdebdd3"sv}, Entry{"accessor/v1-receipt.832-896.vi"sv, "f4ad8c766a21b966a0ceea29affb17171194edcc"sv}, Entry{"accessor/v1-receipt.896-960.efi"sv, "edbf5f7ab06ecd94df7844af3646f23dfe4635a0"sv}, Entry{"accessor/v1-receipt.896-960.vi"sv, "fe7e8130f9df2af170d16cb7beced36924554b72"sv}, Entry{"accessor/v1-receipt.960-1024.efi"sv, "95292bfd3c97269d71975a9122580e3268b6ebda"sv}, Entry{"accessor/v1-receipt.960-1024.vi"sv, "6939e8695c914f663e8658499422e00b9c46086f"sv}, Entry{"accessor/v1-storage.0-64.efi"sv, "409ddbd48100b37516a84b1701393edbf1fbd38b"sv}, Entry{"accessor/v1-storage.0-64.vi"sv, "10add3d7404cfb1e6b9c738e458c3af96af342f7"sv}, Entry{"accessor/v1-storage.1024-1088.efi"sv, "7cc2f5d176c579e025d3bef408409a43c0ba0f36"sv}, Entry{"accessor/v1-storage.1024-1088.vi"sv, "d9581a448423740a5aa6d092c06c27527b35c923"sv}, Entry{"accessor/v1-storage.1088-1152.efi"sv, "cb85d896724330ecb6dd04634eb664580e151c58"sv}, Entry{"accessor/v1-storage.1088-1152.vi"sv, "e0c8f819f6f036625323e9e6fb70300b00c9d560"sv}, Entry{"accessor/v1-storage.1152-1216.efi"sv, "75be5345525872bd904878f9b0d16469ef25696f"sv}, Entry{"accessor/v1-storage.1152-1216.vi"sv, "be8349bdd24dbb88fcc1a42f0d293a520062fdce"sv}, Entry{"accessor/v1-storage.1216-1280.efi"sv, "67e8a53970b53ce96afcf73901ced3655d4591d1"sv}, Entry{"accessor/v1-storage.1216-1280.vi"sv, "713d6474c0c60663f785bf4eaea684315c0c30dd"sv}, Entry{"accessor/v1-storage.128-192.efi"sv, "2692c968f2996a0e2a23adeb150ab8e0d5b3e3a7"sv}, Entry{"accessor/v1-storage.128-192.vi"sv, "9cb7ce26a99a5680f834af5c39f297461914bbd2"sv}, Entry{"accessor/v1-storage.1280-1344.efi"sv, "e532fdc76e51f2d2d78f392ec640c75c38bd0603"sv}, Entry{"accessor/v1-storage.1280-1344.vi"sv, "4beef2b44b48db43828bfe08342e0aa6a9c4c6a2"sv}, Entry{"accessor/v1-storage.1344-1408.efi"sv, "cba51c17152bfa4019aa02e12ab709183e1b1013"sv}, Entry{"accessor/v1-storage.1344-1408.vi"sv, "f10e35e9bbae7c95c22d8a443b8d7694d9951595"sv}, Entry{"accessor/v1-storage.1408-1472.efi"sv, "cd683c1ca3c0314868a1342eb525f79a4a0104a9"sv}, Entry{"accessor/v1-storage.1408-1472.vi"sv, "161fa9eff345be72513e8d03018077f74971ee2e"sv}, Entry{"accessor/v1-storage.1472-1536.efi"sv, "be330645c0fd07564b16d5598f2025e081b00190"sv}, Entry{"accessor/v1-storage.1472-1536.vi"sv, "2f92d35dce85a3cc6cf8cd5a66b54e631b92252f"sv}, Entry{"accessor/v1-storage.1536-1600.efi"sv, "c9787a1e8f53831612702e2fbcfdb27c7cece691"sv}, Entry{"accessor/v1-storage.1536-1600.vi"sv, "a889659b54eefdccf2c9d01bfcb876e3bb6c1973"sv}, Entry{"accessor/v1-storage.1600-1664.efi"sv, "9341e47b8bf08ff538402fa9181f0c103d3f72ea"sv}, Entry{"accessor/v1-storage.1600-1664.vi"sv, "049b9e64ba9e51b708c8125bab074fd3692bb541"sv}, Entry{"accessor/v1-storage.1664-1728.efi"sv, "99fb99e59e326b2a52c8add76e8ccefb7e2af8a9"sv}, Entry{"accessor/v1-storage.1664-1728.vi"sv, "165f48efc34f59afe27009318f26a7491887fcb7"sv}, Entry{"accessor/v1-storage.1728-1792.efi"sv, "a52e63b7683b3260e91eda310b64a31933b97a67"sv}, Entry{"accessor/v1-storage.1728-1792.vi"sv, "a9ba2dae72c67fb99d95d4b50512d728fa4f7389"sv}, Entry{"accessor/v1-storage.1792-1856.efi"sv, "35d666a1959a74b7fd30ed732db00efc95aaffeb"sv}, Entry{"accessor/v1-storage.1792-1856.vi"sv, "0c2e7c86eeffb5c055539cfc96324bb6e944da87"sv}, Entry{"accessor/v1-storage.1856-1920.efi"sv, "645a29fd1916d67e089aaf228ff4bfb9a2af9bb0"sv}, Entry{"accessor/v1-storage.1856-1920.vi"sv, "db46aa21a4f8aa93ace33449796dfb5d141b6d23"sv}, Entry{"accessor/v1-storage.192-256.efi"sv, "2644eda6d32adcdc5a327da15d18a6e089abb860"sv}, Entry{"accessor/v1-storage.192-256.vi"sv, "aafe56a8024a7c4ebdfc7caf9b460c205663543e"sv}, Entry{"accessor/v1-storage.1920-1984.efi"sv, "969cd78efd268338861a2794740fa7f0f5132976"sv}, Entry{"accessor/v1-storage.1920-1984.vi"sv, "e0ed8c8e139fdbe0c5f7e7196f4cd8184f61039d"sv}, Entry{"accessor/v1-storage.1984-2048.efi"sv, "6696b552811eb3dbf5b7b6d24a854cc2012a71b2"sv}, Entry{"accessor/v1-storage.1984-2048.vi"sv, "5c23085ab5e8ed8bccdcb433104e95c87b1603f9"sv}, Entry{"accessor/v1-storage.2048-2112.efi"sv, "3673a2fc52ae7f897fb4b914c396df3713af2cbe"sv}, Entry{"accessor/v1-storage.2048-2112.vi"sv, "1b3acc46ca56595d0b15cb11502709fbb3ab776b"sv}, Entry{"accessor/v1-storage.2112-2176.efi"sv, "42f65058120228b85e40f0f6ca96dae723c0fd2c"sv}, Entry{"accessor/v1-storage.2112-2176.vi"sv, "a1c27861d07f707cb5d25e31dc3116ff3c8ed836"sv}, Entry{"accessor/v1-storage.2176-2240.efi"sv, "fb61c9c584fff9cc372d06c8d2568db9d840e0ba"sv}, Entry{"accessor/v1-storage.2176-2240.vi"sv, "f3400b77f083fa5dc84b43c90ea43d37547780c0"sv}, Entry{"accessor/v1-storage.2240-2304.efi"sv, "3e91cda8ca0cdbfbf93428c92fa36cf8f8bc5522"sv}, Entry{"accessor/v1-storage.2240-2304.vi"sv, "f6b9e23145f75aff5da1456323db418ae0b67621"sv}, Entry{"accessor/v1-storage.2304-2368.efi"sv, "3e4e787ce0021b9eae8e88c26b75480e53a3d59f"sv}, Entry{"accessor/v1-storage.2304-2368.vi"sv, "864c9082ba6124351a6ee53134073b68fe8be4ba"sv}, Entry{"accessor/v1-storage.2368-2432.efi"sv, "e4f0fa554a4884d621a789188bdffcb9f51b1e7b"sv}, Entry{"accessor/v1-storage.2368-2432.vi"sv, "65d350fe318313e24d3b8de7fb714a12dee67dd6"sv}, Entry{"accessor/v1-storage.2432-2496.efi"sv, "aa6ac2118f346b0abd9412f6fb733993ff4ff936"sv}, Entry{"accessor/v1-storage.2432-2496.vi"sv, "12edf64ea19d47009be53cee8b802e00ea6788fd"sv}, Entry{"accessor/v1-storage.2496-2560.efi"sv, "4966be434b2e3993f60c2881b6a430cd74a1aea8"sv}, Entry{"accessor/v1-storage.2496-2560.vi"sv, "19e6b136b0adab0ab07c76b42031995754e1a761"sv}, Entry{"accessor/v1-storage.256-320.efi"sv, "cd22b9050e9a7ab60fb466eea316c01c68459b68"sv}, Entry{"accessor/v1-storage.256-320.vi"sv, "d3c235523c6d3dd2c55adf83683179661607e887"sv}, Entry{"accessor/v1-storage.2560-2624.efi"sv, "97a0ed5b5b4c724354a08c38848ce56954de0f74"sv}, Entry{"accessor/v1-storage.2560-2624.vi"sv, "c17fad66071ad54b9d17248fa4ba167e1ba593b4"sv}, Entry{"accessor/v1-storage.2624-2688.efi"sv, "b434c2e225440ac8271828b02ac4a9686635bc1f"sv}, Entry{"accessor/v1-storage.2624-2688.vi"sv, "c9edc98239ba772eb365b3af12cac03b25560d5c"sv}, Entry{"accessor/v1-storage.2688-2752.efi"sv, "0aaf48939fc605e45a8e8a7a96a40f1f3d510ffc"sv}, Entry{"accessor/v1-storage.2688-2752.vi"sv, "497459cbec356c0a166d16059e303f93602fe2a4"sv}, Entry{"accessor/v1-storage.2752-2816.efi"sv, "cb87b2810203b432327ec1c2774f8d0ce51279dc"sv}, Entry{"accessor/v1-storage.2752-2816.vi"sv, "23382d9c256711b551711af60166b5c6017e99fe"sv}, Entry{"accessor/v1-storage.2816-2880.efi"sv, "0289b9eaa804e8a429f674e84f77d947fbd6e221"sv}, Entry{"accessor/v1-storage.2816-2880.vi"sv, "56480ebcb0acd02584fb14bd0f1347e5e40274e5"sv}, Entry{"accessor/v1-storage.2848-2856.efi"sv, "ad5a20a81a58a72b45da6040bea52c15da8cb05a"sv}, Entry{"accessor/v1-storage.2848-2856.vi"sv, "0ba55eb3bf62239fb04e791c0c1bc3015ffe0768"sv}, Entry{"accessor/v1-storage.2856-2860.efi"sv, "9cb49189c9ce7878a7f06005a61ca1d928cf293f"sv}, Entry{"accessor/v1-storage.2856-2860.vi"sv, "b512e0019acd878de2615a8b73e060c624c04318"sv}, Entry{"accessor/v1-storage.2880-2912.efi"sv, "6f1f4fda0f780c8ed9379ba0c601892c418bb14d"sv}, Entry{"accessor/v1-storage.2880-2912.vi"sv, "e7afee90a390675febd12e569d6cb8bd78e1334c"sv}, Entry{"accessor/v1-storage.2912-2928.efi"sv, "ba838a01d7ae40469de56d0dee4eef4cd9291674"sv}, Entry{"accessor/v1-storage.2912-2928.vi"sv, "b777518d85c56af7b457556b64d85bc32c194941"sv}, Entry{"accessor/v1-storage.2928-2936.efi"sv, "ff2d412750ed195fbdde26078d5a92dab9a28608"sv}, Entry{"accessor/v1-storage.2928-2936.vi"sv, "691d85ba331090d567f63530aa5949dbe62abae3"sv}, Entry{"accessor/v1-storage.2936-2940.efi"sv, "82c9e0cd1b9218788b812940500f4266fd7f81b6"sv}, Entry{"accessor/v1-storage.2936-2940.vi"sv, "5a6857714f886e9b49f3d78f5cafa1ec0a98474c"sv}, Entry{"accessor/v1-storage.320-384.efi"sv, "080bf234410831c3e69c58f02324cf168731ee29"sv}, Entry{"accessor/v1-storage.320-384.vi"sv, "4f445d6e7562fc925eeea03020b0d19b0644cf40"sv}, Entry{"accessor/v1-storage.384-448.efi"sv, "1f115c3ad2dd536811d5d519b0837b993cc5c572"sv}, Entry{"accessor/v1-storage.384-448.vi"sv, "108be83327a34477aee5307003a0c28fe97c9aab"sv}, Entry{"accessor/v1-storage.448-512.efi"sv, "652340346d49c14718e5e32ea0ae14d37c7ca0bd"sv}, Entry{"accessor/v1-storage.448-512.vi"sv, "d2523b8e8dd871a17221e275f54170ac22e1af68"sv}, Entry{"accessor/v1-storage.512-576.efi"sv, "e27ca26c90c295b75c87748d01c743259b7861fe"sv}, Entry{"accessor/v1-storage.512-576.vi"sv, "22757100fb599cd02538f6c0570b177ac44a24ba"sv}, Entry{"accessor/v1-storage.576-640.efi"sv, "44234fa1d3c3c1fbaaa4b970203942ef88f251af"sv}, Entry{"accessor/v1-storage.576-640.vi"sv, "9ab1e46adaf49e9246fd2c2af21f820a81004a7b"sv}, Entry{"accessor/v1-storage.64-128.efi"sv, "36387ff67eed9a4ca3e8514e5e067ac5c8bdbc91"sv}, Entry{"accessor/v1-storage.64-128.vi"sv, "d45db9ddef10625a6b8a7a361171d4370503a329"sv}, Entry{"accessor/v1-storage.640-704.efi"sv, "e4b7b86ccc8a8bdfc8577a95dbe85aa3715e93fe"sv}, Entry{"accessor/v1-storage.640-704.vi"sv, "0a59bff6bbbd885b79043eaac085b2e33a9b2e47"sv}, Entry{"accessor/v1-storage.704-768.efi"sv, "a4d0da77670208f79f78595432047a64299ebd24"sv}, Entry{"accessor/v1-storage.704-768.vi"sv, "bf8f0308a454be8fc0a6f3bc88d1f36ec7bd54d4"sv}, Entry{"accessor/v1-storage.768-832.efi"sv, "e9edb68f225a502ba5df6b8fa353abba1226c68e"sv}, Entry{"accessor/v1-storage.768-832.vi"sv, "ffce9ea53a3ce9e47470162e87ffc457dfefa5ee"sv}, Entry{"accessor/v1-storage.832-896.efi"sv, "71e3409e417e657904bc83fb94322269a1020972"sv}, Entry{"accessor/v1-storage.832-896.vi"sv, "f1b9a0487f77029963d3bfdb4478a3a5f7b0e5af"sv}, Entry{"accessor/v1-storage.896-960.efi"sv, "81f63ba7cb5d459329421440462697b81218d1c2"sv}, Entry{"accessor/v1-storage.896-960.vi"sv, "b969f8d7a15aa103541d7412b090c1e92fc0b937"sv}, Entry{"accessor/v1-storage.960-1024.efi"sv, "72f7d212f9233b0d1b88b75b0bcef1177c4956cb"sv}, Entry{"accessor/v1-storage.960-1024.vi"sv, "c726a1a8470063a618968feaf8a30b87d6bcd055"sv}, Entry{"accessor/v1-tracesfrom.0-64.efi"sv, "952fc867e13b74aebca3bc2c8b7c3b49496972b6"sv}, Entry{"accessor/v1-tracesfrom.1024-1088.efi"sv, "8e6d83f5b45bad223d2c5852c953418024cdedd4"sv}, Entry{"accessor/v1-tracesfrom.1088-1152.efi"sv, "8dba7a5bb49baa69ce5199cb4d022f7acda97e79"sv}, Entry{"accessor/v1-tracesfrom.1152-1216.efi"sv, "6edb7a06f36917d421557c641a12f30911044cc3"sv}, Entry{"accessor/v1-tracesfrom.1216-1280.efi"sv, "e7dddf6ed0b4e6936c23c6a7d400acc64e905abe"sv}, Entry{"accessor/v1-tracesfrom.128-192.efi"sv, "3c4b943c4e179d708193145d07507b836334a608"sv}, Entry{"accessor/v1-tracesfrom.1280-1344.efi"sv, "d119be63bec8766040b68f3c20606b3bf7468652"sv}, Entry{"accessor/v1-tracesfrom.1344-1408.efi"sv, "f3ae6b34f0960db806bd51e7218d0c95d32456b6"sv}, Entry{"accessor/v1-tracesfrom.1408-1472.efi"sv, "fdc862a9e4664da2d0ef7bfac95dae4bccb1dba9"sv}, Entry{"accessor/v1-tracesfrom.1472-1536.efi"sv, "dea209b3b45bd04148ed01ee1f95d881654effb0"sv}, Entry{"accessor/v1-tracesfrom.1536-1600.efi"sv, "e6069593ab4983211c140ce9742bbd333e94a3a3"sv}, Entry{"accessor/v1-tracesfrom.1600-1664.efi"sv, "64d1e3fc0771a63f9412d8a17eec8cdc89e0be28"sv}, Entry{"accessor/v1-tracesfrom.1664-1728.efi"sv, "fae44d716a7a0d92b287daa06bea01d7cbd06e53"sv}, Entry{"accessor/v1-tracesfrom.1728-1792.efi"sv, "8392cba5c96dfcff9eb8e551c2c834edc2a42256"sv}, Entry{"accessor/v1-tracesfrom.1792-1856.efi"sv, "4225dc4d8c4b30d666ce9fb5deee99e06935dc60"sv}, Entry{"accessor/v1-tracesfrom.1856-1920.efi"sv, "6098e47250e880b115b3e8911f3a8af99b8a5345"sv}, Entry{"accessor/v1-tracesfrom.192-256.efi"sv, "c5f20239fc47a091aa3a8f3deab724d11649be16"sv}, Entry{"accessor/v1-tracesfrom.1920-1984.efi"sv, "bdca650dd73d943dab67edbd13925995929d5d8c"sv}, Entry{"accessor/v1-tracesfrom.1984-2048.efi"sv, "635f0d9ff993eeffe2e3cda2130fb45ddeef2797"sv}, Entry{"accessor/v1-tracesfrom.2048-2112.efi"sv, "4b6ab38150cd0a1571aa9fb46391f7bc2f6f4243"sv}, Entry{"accessor/v1-tracesfrom.2112-2176.efi"sv, "d48cb81691adbfd09d7722043d159df23ad892b3"sv}, Entry{"accessor/v1-tracesfrom.2176-2240.efi"sv, "b3b7ce7dddc83091a3a2b4bc551c573e272ffa48"sv}, Entry{"accessor/v1-tracesfrom.2240-2304.efi"sv, "4647eaa70c5224ee67b4bfbc4aa23d49338ae0e6"sv}, Entry{"accessor/v1-tracesfrom.2304-2368.efi"sv, "2475948825d8ffd41d320710ad6c3b95f06c3776"sv}, Entry{"accessor/v1-tracesfrom.2368-2432.efi"sv, "3ba59df118a3522a7fde716cde3f3bac01f0ffb8"sv}, Entry{"accessor/v1-tracesfrom.2432-2496.efi"sv, "2a235d8fee6a31ae6284b11744ba90303d19f5c3"sv}, Entry{"accessor/v1-tracesfrom.2496-2560.efi"sv, "61435dc90767fc76ef58f98c71067d932c7c8051"sv}, Entry{"accessor/v1-tracesfrom.256-320.efi"sv, "bb4c08a701cea3de0a2db3cda3f32a399e9f692a"sv}, Entry{"accessor/v1-tracesfrom.2560-2624.efi"sv, "860be4e39b885f9f3d49277034e7c64d67f68be3"sv}, Entry{"accessor/v1-tracesfrom.2624-2688.efi"sv, "9076cb16eaafa0cbce401cfd233ef7fa5def9625"sv}, Entry{"accessor/v1-tracesfrom.2688-2752.efi"sv, "1aee29470f25e6781f2f128b6a04525dda71276c"sv}, Entry{"accessor/v1-tracesfrom.2752-2816.efi"sv, "f202e176312fb4ee5166c54e640bed2d9cb1d5e4"sv}, Entry{"accessor/v1-tracesfrom.2816-2880.efi"sv, "2bf3a1aca03bea2d7805b24ae1ca33fca4bc1982"sv}, Entry{"accessor/v1-tracesfrom.2848-2856.efi"sv, "d68144662e660366d3e0c39a9ff8487e5895098a"sv}, Entry{"accessor/v1-tracesfrom.2856-2860.efi"sv, "a14f1d64e9c0f3376f4ce59102d358373a2d6b3b"sv}, Entry{"accessor/v1-tracesfrom.2880-2912.efi"sv, "4d87728e286ed0e9aee759fc421f6fbf4d4df154"sv}, Entry{"accessor/v1-tracesfrom.2912-2928.efi"sv, "21edffdf2a3ec09dbfea8301393ceb5dd412079f"sv}, Entry{"accessor/v1-tracesfrom.2928-2936.efi"sv, "cf4898dae74a77cd17982924df5b5912548e5317"sv}, Entry{"accessor/v1-tracesfrom.2936-2940.efi"sv, "ca29914a613686588c5d327bf86ba5d4775acecb"sv}, Entry{"accessor/v1-tracesfrom.320-384.efi"sv, "3c3df85daf3ea8459235750bdc240e27a9183874"sv}, Entry{"accessor/v1-tracesfrom.384-448.efi"sv, "49d6e3f94ded1bca046052aff0342d40a8046d71"sv}, Entry{"accessor/v1-tracesfrom.448-512.efi"sv, "40aeee38504872c79089e58d0f37a4683d6a3188"sv}, Entry{"accessor/v1-tracesfrom.512-576.efi"sv, "818d0f725f1b0629d5970f0f3e0565ba7efd4143"sv}, Entry{"accessor/v1-tracesfrom.576-640.efi"sv, "3ec867a3768088181b87ec8e6466beff7bde3114"sv}, Entry{"accessor/v1-tracesfrom.64-128.efi"sv, "6f640cda242455641bbd1d318e839c3e6884d8ec"sv}, Entry{"accessor/v1-tracesfrom.640-704.efi"sv, "fbb2eb875f8198f94665afa569c3c7181c9c70fc"sv}, Entry{"accessor/v1-tracesfrom.704-768.efi"sv, "17901a5f677e27bdbaa0bf2ba723f3195690d800"sv}, Entry{"accessor/v1-tracesfrom.768-832.efi"sv, "c1bd0241bd85dc4dcd67d755249ec79efaff2074"sv}, Entry{"accessor/v1-tracesfrom.832-896.efi"sv, "ca2ea13a19300b995c762a2fda79d783ddd2e46b"sv}, Entry{"accessor/v1-tracesfrom.896-960.efi"sv, "d534f5e06182a50bb1d68f0c7a31fb21794e12e6"sv}, Entry{"accessor/v1-tracesfrom.960-1024.efi"sv, "e441c34940fa51655486584522ea56d5a6a57d20"sv}, Entry{"accessor/v1-tracesto.0-64.efi"sv, "0321b034d75289983c765c9cbc9a4ffa09ac7874"sv}, Entry{"accessor/v1-tracesto.1024-1088.efi"sv, "32646e9f20e2e07a1f14a32276149181e033b07e"sv}, Entry{"accessor/v1-tracesto.1088-1152.efi"sv, "15b7b1e4439d85aea931ffcbf306a94dae76d684"sv}, Entry{"accessor/v1-tracesto.1152-1216.efi"sv, "472d5c672319df3512fe96bfb7996c15e48de686"sv}, Entry{"accessor/v1-tracesto.1216-1280.efi"sv, "10752479ba2a3189cc55fb87d5415a7e0abd2ed7"sv}, Entry{"accessor/v1-tracesto.128-192.efi"sv, "52d9647665c7d27eb73806155454aee9085c0bce"sv}, Entry{"accessor/v1-tracesto.1280-1344.efi"sv, "2a4c05a7fc7ad90d5cd9b6770bfafad300bcf0b8"sv}, Entry{"accessor/v1-tracesto.1344-1408.efi"sv, "56838f3ba75dcae5fc3afbf3f216ae94bfc7eb36"sv}, Entry{"accessor/v1-tracesto.1408-1472.efi"sv, "a812fdc8bd75319cce8e73dc6d70a1fc08da095a"sv}, Entry{"accessor/v1-tracesto.1472-1536.efi"sv, "58e5819d93004f4375acc249b758112b1fd83f6a"sv}, Entry{"accessor/v1-tracesto.1536-1600.efi"sv, "2a7390b3c930689540123c94e16fe761c491ac03"sv}, Entry{"accessor/v1-tracesto.1600-1664.efi"sv, "3c2936e92bf6e42a1f03aa0ea3d74b1466836c36"sv}, Entry{"accessor/v1-tracesto.1664-1728.efi"sv, "d60aaccd573127b025322333869bf299365bdd3c"sv}, Entry{"accessor/v1-tracesto.1728-1792.efi"sv, "771c01340d56a24f03baed5b2f58fcba15102c38"sv}, Entry{"accessor/v1-tracesto.1792-1856.efi"sv, "39686884dba6d3ffc0140fe16472376153599ea2"sv}, Entry{"accessor/v1-tracesto.1856-1920.efi"sv, "da576ff016dc5dea45f024758ad4482a49bbcb62"sv}, Entry{"accessor/v1-tracesto.192-256.efi"sv, "44961408e25c569974d83c2bc9cfdceb3b0bba61"sv}, Entry{"accessor/v1-tracesto.1920-1984.efi"sv, "9fb1952f0c765947e15e26eeffd7ec021027be43"sv}, Entry{"accessor/v1-tracesto.1984-2048.efi"sv, "7bf168cdc02490c9c0736b10b8169053fe1752e8"sv}, Entry{"accessor/v1-tracesto.2048-2112.efi"sv, "ec89b9e1eb6af8356d62bf8506d54d0da04f0609"sv}, Entry{"accessor/v1-tracesto.2112-2176.efi"sv, "8d2dfea33406a022e54b03ab39d099e15947338a"sv}, Entry{"accessor/v1-tracesto.2176-2240.efi"sv, "c09da4e48e5cd72e4354841914729a0fa366fd95"sv}, Entry{"accessor/v1-tracesto.2240-2304.efi"sv, "a546765e9d52002089c7fded56635b7e60e7cba0"sv}, Entry{"accessor/v1-tracesto.2304-2368.efi"sv, "5de0af3c664a041f99f8e8ccaae12601bf47d736"sv}, Entry{"accessor/v1-tracesto.2368-2432.efi"sv, "568def22128f5e097489cf43b58f1ee969e42d5a"sv}, Entry{"accessor/v1-tracesto.2432-2496.efi"sv, "82665bc721983977e5184c0c4bf7b1f3d20be44b"sv}, Entry{"accessor/v1-tracesto.2496-2560.efi"sv, "564e1db84616ca4fd2e8cff1fdd468bf0435af8a"sv}, Entry{"accessor/v1-tracesto.256-320.efi"sv, "56128d6fdd72e528874b840352ab1ce9af91ed86"sv}, Entry{"accessor/v1-tracesto.2560-2624.efi"sv, "7a8bed28ad913a07c78335cc520a958fbdeccd0d"sv}, Entry{"accessor/v1-tracesto.2624-2688.efi"sv, "0eb5e301a5e234b31470a14e0326e9e130be076e"sv}, Entry{"accessor/v1-tracesto.2688-2752.efi"sv, "db67f3687fa98618f266c780e072a2505e5dde7d"sv}, Entry{"accessor/v1-tracesto.2752-2816.efi"sv, "0afabcc93adffc9c018b19931de64d80938e7649"sv}, Entry{"accessor/v1-tracesto.2816-2880.efi"sv, "11fedba13a96c851d2f6b38846d43befd98fdb44"sv}, Entry{"accessor/v1-tracesto.2848-2856.efi"sv, "b0da413021a79d99a27a4d926ab21ec766e4384d"sv}, Entry{"accessor/v1-tracesto.2856-2860.efi"sv, "a919b7f9c45f3cdef4af83c3d8ca73f0506dbc1a"sv}, Entry{"accessor/v1-tracesto.2880-2912.efi"sv, "caf43262c71294c19ff99c2ccd21f32933bd488d"sv}, Entry{"accessor/v1-tracesto.2912-2928.efi"sv, "f142b2bdbf4e9122dd7d1abe892bc7e50a07439c"sv}, Entry{"accessor/v1-tracesto.2928-2936.efi"sv, "bb250f80b1725dab91bdbafcfca4df2c8cca7b30"sv}, Entry{"accessor/v1-tracesto.2936-2940.efi"sv, "e938621be1e0c867bad9c62308762625e21e176a"sv}, Entry{"accessor/v1-tracesto.320-384.efi"sv, "ab2b2d8c518a5acb63764ad834f416f23e76ee8f"sv}, Entry{"accessor/v1-tracesto.384-448.efi"sv, "151fa21e102913cf42a683724fe1242c7cacafb8"sv}, Entry{"accessor/v1-tracesto.448-512.efi"sv, "be88eb958e0d61d6ffa267bf0e1e08521facbf63"sv}, Entry{"accessor/v1-tracesto.512-576.efi"sv, "a5e41a454622d5203aa84c81bd61d3b7c3a41c19"sv}, Entry{"accessor/v1-tracesto.576-640.efi"sv, "0c65bc23b3407cc847af13ec8fa359681403c493"sv}, Entry{"accessor/v1-tracesto.64-128.efi"sv, "893d87630a509a48df4fc6e8d9f303a66078130f"sv}, Entry{"accessor/v1-tracesto.640-704.efi"sv, "c32954acca2cf44fc5476f398e0349d848a1039f"sv}, Entry{"accessor/v1-tracesto.704-768.efi"sv, "eba83c1c3d12f76e0e6fd85bc96b8db1f1bb405a"sv}, Entry{"accessor/v1-tracesto.768-832.efi"sv, "350e49dd1335529301c872e83401eca6fcd689d9"sv}, Entry{"accessor/v1-tracesto.832-896.efi"sv, "1c6d6d7178633649f61463c6a6e9a06b5f44a37e"sv}, Entry{"accessor/v1-tracesto.896-960.efi"sv, "a636b7c9ace6d1e3ad0dba7239bf3e8064f5787b"sv}, Entry{"accessor/v1-tracesto.960-1024.efi"sv, "86c773b753d002f932d1441bde02337758a71d1d"sv}, Entry{"domain/v1-accounts.0-2048.bt"sv, "8a46a2447ed3547de27884eedde65f3f3c90de3a"sv}, Entry{"domain/v1-accounts.0-2048.kv"sv, "16f3c0474241877eeda3a46b245eea8b77a88bd5"sv}, Entry{"domain/v1-accounts.0-2048.kvei"sv, "e8652018e780cec58db0ec24f5c2520252d4fa81"sv}, Entry{"domain/v1-accounts.2048-2560.bt"sv, "e6813b199149ec5a094f084e2d65dfb93895b1b0"sv}, Entry{"domain/v1-accounts.2048-2560.kv"sv, "b6ab28dd3cc0681a5e51fda9c8fd4069f638ee85"sv}, Entry{"domain/v1-accounts.2048-2560.kvei"sv, "dac32d03b453814ff4b49f8882c83f8d449bce24"sv}, Entry{"domain/v1-accounts.2560-2816.bt"sv, "0266e4675d54888b0aa6ae059ab9c58b16c4e824"sv}, Entry{"domain/v1-accounts.2560-2816.kv"sv, "ae02293fdc60aafd94772800b52a2b6219b10dbf"sv}, Entry{"domain/v1-accounts.2560-2816.kvei"sv, "d1e90d9a776540ba067c8c2135bd0a3ce9ff29a2"sv}, Entry{"domain/v1-accounts.2816-2880.bt"sv, "bb40025742ffe40602ee05c98d3b5563ef5588e4"sv}, Entry{"domain/v1-accounts.2816-2880.kv"sv, "d2ac8cab398eca38491fc26e911b619547d73357"sv}, Entry{"domain/v1-accounts.2816-2880.kvei"sv, "8b830c8a419c47c978b86f35be6f8a651f710b53"sv}, Entry{"domain/v1-accounts.2880-2912.bt"sv, "811063dadf555eb6590f0858797ae856bc0c67dd"sv}, Entry{"domain/v1-accounts.2880-2912.kv"sv, "61601f8b57e2a26ec6cc54a3ed30f3951db6d66f"sv}, Entry{"domain/v1-accounts.2880-2912.kvei"sv, "90650f6da51d47c02aaafdf9404a561593033a7a"sv}, Entry{"domain/v1-accounts.2912-2928.bt"sv, "8f60275c69681e7d76edf0315fde2f3ae4262b44"sv}, Entry{"domain/v1-accounts.2912-2928.kv"sv, "2513ba28a23d1e7487d1d320f32eb3e8eec746f3"sv}, Entry{"domain/v1-accounts.2912-2928.kvei"sv, "27a684008508b0bfd6027d1da1be6d1085610cac"sv}, Entry{"domain/v1-accounts.2928-2936.bt"sv, "4a7f4a5c21e6a39fc5d81b17406d0a8b81212e35"sv}, Entry{"domain/v1-accounts.2928-2936.kv"sv, "bd604ae832c3b8df571765a88da0af3669b28398"sv}, Entry{"domain/v1-accounts.2928-2936.kvei"sv, "d48ef94fcb1acfeeabe1d71b9a47c170b944080a"sv}, Entry{"domain/v1-accounts.2936-2940.bt"sv, "59232bbb452f29e1841c1fcab4ff393ab19416c1"sv}, Entry{"domain/v1-accounts.2936-2940.kv"sv, "0bea741aeaaec92dfa150609ae139e50dd9225af"sv}, Entry{"domain/v1-accounts.2936-2940.kvei"sv, "15e4c8ba697c915212553c5f14a59d0e44384e6d"sv}, Entry{"domain/v1-code.0-2048.bt"sv, "4c615c52d87c2c4c7ee3d7201aff2a9c3cd68f28"sv}, Entry{"domain/v1-code.0-2048.kv"sv, "75341a9a7375bf2db88e8fcab555a9f0f66b7478"sv}, Entry{"domain/v1-code.0-2048.kvei"sv, "f6040910b243df5138cca9c6c8587c56fa7142d4"sv}, Entry{"domain/v1-code.2048-2560.bt"sv, "ac29729c5558b881b46a621afd8dc0769e5faeb6"sv}, Entry{"domain/v1-code.2048-2560.kv"sv, "a064181a7377bfaa3633510a94827555f29ba70e"sv}, Entry{"domain/v1-code.2048-2560.kvei"sv, "a128b3144f939d2659a911768fe0ad5f4840aea9"sv}, Entry{"domain/v1-code.2560-2816.bt"sv, "73653c43125a28a125e6687ce49a66f2fd660af0"sv}, Entry{"domain/v1-code.2560-2816.kv"sv, "0e653a4fc4c5c70d9a0b404b93f702a0c78f0d71"sv}, Entry{"domain/v1-code.2560-2816.kvei"sv, "aa4a00c2b93d7b236f03e64d9544a54dce787edd"sv}, Entry{"domain/v1-code.2816-2880.bt"sv, "c170d17765565d844fb23a14812b3164c37d3da7"sv}, Entry{"domain/v1-code.2816-2880.kv"sv, "320186285c648b231de9d28538742048f2fb2a77"sv}, Entry{"domain/v1-code.2816-2880.kvei"sv, "e4d7793f8ef1e9f134568456255c706def8e1023"sv}, Entry{"domain/v1-code.2880-2912.bt"sv, "cd8f17cde603ab0fac3e51932f20181e18f8e005"sv}, Entry{"domain/v1-code.2880-2912.kv"sv, "8491dad881eacfc27af72217bc5f1d898a84fa4e"sv}, Entry{"domain/v1-code.2880-2912.kvei"sv, "e71fa779950b9c754707e9ee1dc473c80db475f4"sv}, Entry{"domain/v1-code.2912-2928.bt"sv, "3825838ce73d57acb9da95cf47a58c5293ff4308"sv}, Entry{"domain/v1-code.2912-2928.kv"sv, "7e83ffebd4abd7d29ace0c919c5c652fe9fda468"sv}, Entry{"domain/v1-code.2912-2928.kvei"sv, "8335d9c8dc25e8992415b5608b80f3d007ef82c3"sv}, Entry{"domain/v1-code.2928-2936.bt"sv, "159a21457b753501386bfaf487e1fdabfa13474c"sv}, Entry{"domain/v1-code.2928-2936.kv"sv, "bd6f5f5e31dad942ef41393307914fd51b313909"sv}, Entry{"domain/v1-code.2928-2936.kvei"sv, "fca76567b0f86387b2eb834963d875c703cb93f8"sv}, Entry{"domain/v1-code.2936-2940.bt"sv, "5ae629ed2d85fe82dc53b32bb2628661a1be91e0"sv}, Entry{"domain/v1-code.2936-2940.kv"sv, "6b312a9fcaa30f7f3746aaa57e67adc0d918af86"sv}, Entry{"domain/v1-code.2936-2940.kvei"sv, "56e3a17dad564e84de251742077692c4d65e2245"sv}, Entry{"domain/v1-commitment.0-2048.bt"sv, "fcb680792d2a58589b2c3804723fd32888759200"sv}, Entry{"domain/v1-commitment.0-2048.kv"sv, "18a5e62df11ca488104d92e625e751c551ca332d"sv}, Entry{"domain/v1-commitment.0-2048.kvei"sv, "dcaf3a603ecd00e360df3669e57b1afb54620f06"sv}, Entry{"domain/v1-commitment.2048-2560.bt"sv, "4143be8f23fcb33197704a39d92d30bc696ee9c8"sv}, Entry{"domain/v1-commitment.2048-2560.kv"sv, "0b6f416b0736df6ad5f4972262d64a36c6f3d3ee"sv}, Entry{"domain/v1-commitment.2048-2560.kvei"sv, "c3a6661dd185a9d53ecbcce90e8434992094798a"sv}, Entry{"domain/v1-commitment.2560-2816.bt"sv, "087979cd694bf2b80801d4ba174725e16f65446d"sv}, Entry{"domain/v1-commitment.2560-2816.kv"sv, "c8db30112d9e2289748aa2be29600bc9c8e455c9"sv}, Entry{"domain/v1-commitment.2560-2816.kvei"sv, "e1c5a92feedc2101267e0558e9831b09357aa4ef"sv}, Entry{"domain/v1-commitment.2816-2880.bt"sv, "75b547e64f9cc3bf41027bedeaabb94d7560b1f3"sv}, Entry{"domain/v1-commitment.2816-2880.kv"sv, "3ffa81006d0d3c45caebd56fc7a19f24a43b9894"sv}, Entry{"domain/v1-commitment.2816-2880.kvei"sv, "76f55fb01fc05d188fa71000f4ae1b08d2d16170"sv}, Entry{"domain/v1-commitment.2880-2912.bt"sv, "a3ccd4600177e344fa4b786eb0acf95b94f49d84"sv}, Entry{"domain/v1-commitment.2880-2912.kv"sv, "8d5cbe005c6980d3a2735f12f2f7787b293a9cca"sv}, Entry{"domain/v1-commitment.2880-2912.kvei"sv, "2cff31dddfb309d298cfa2a35db708cff49c1248"sv}, Entry{"domain/v1-commitment.2912-2928.bt"sv, "f7d5e373c0dcd7be09b9d1e9e4bc1dc45482438a"sv}, Entry{"domain/v1-commitment.2912-2928.kv"sv, "e0a45b369dedfad69500276960acf5dc36e099cb"sv}, Entry{"domain/v1-commitment.2912-2928.kvei"sv, "8f6663ba1bcaf158b61f8cb7653a707168c037f3"sv}, Entry{"domain/v1-commitment.2928-2936.bt"sv, "ca15b7b73fc033f1ff2e771de0752fac1649d742"sv}, Entry{"domain/v1-commitment.2928-2936.kv"sv, "77f72434e9d28958f8bc2d0bd839de8488a4a4f6"sv}, Entry{"domain/v1-commitment.2928-2936.kvei"sv, "35c77cc11bc0a28ad15b3147fe7f773f32e39178"sv}, Entry{"domain/v1-commitment.2936-2940.bt"sv, "19db8b5ee6c7358f7ab274280393e7be85d5a349"sv}, Entry{"domain/v1-commitment.2936-2940.kv"sv, "e599476435aaa18eaf1b02f2d79f921c5dddeaad"sv}, Entry{"domain/v1-commitment.2936-2940.kvei"sv, "a802adeb25b8bcc5edfb11dacd7a421829f427bc"sv}, Entry{"domain/v1-receipt.0-2048.bt"sv, "a06accd5423c2c5b9e33e5ad64468d32f8bede6e"sv}, Entry{"domain/v1-receipt.0-2048.kv"sv, "bf1ec769afced675a3534d64aae076507f0deb98"sv}, Entry{"domain/v1-receipt.0-2048.kvei"sv, "b0b82f7ed97bec3c1def0f8f140b746f8a3fc8f7"sv}, Entry{"domain/v1-receipt.2048-2560.bt"sv, "254a30a54383ad5590f6bfa93f34cf9cb0a8f946"sv}, Entry{"domain/v1-receipt.2048-2560.kv"sv, "9a0ac8b8acd7c57fbb3fe9d18979e3d1a3151bb1"sv}, Entry{"domain/v1-receipt.2048-2560.kvei"sv, "5486f04e8d1a6644a557ec266ae77fb0924a54ea"sv}, Entry{"domain/v1-receipt.2560-2816.bt"sv, "4f8b62e458a9f50725507e9c0ae0f0fede2c1060"sv}, Entry{"domain/v1-receipt.2560-2816.kv"sv, "dddea7b5b022d13cda4ce0f03e15dbf517de1e8e"sv}, Entry{"domain/v1-receipt.2560-2816.kvei"sv, "9e35127d79d3d2c2e706e12fbe6adcd5027f466c"sv}, Entry{"domain/v1-receipt.2816-2880.bt"sv, "82350baa6d78f1adab5145401ebb67f2997d37fa"sv}, Entry{"domain/v1-receipt.2816-2880.kv"sv, "44edc24e33852e5c397239bf21a34aac40b4cbe2"sv}, Entry{"domain/v1-receipt.2816-2880.kvei"sv, "824d4be0f1311d4eaa5a293c26b8030fcde076c2"sv}, Entry{"domain/v1-receipt.2880-2912.bt"sv, "db16380668655e1a7cdef5d65b97fdbbe4bb6a43"sv}, Entry{"domain/v1-receipt.2880-2912.kv"sv, "7698a547ba9566bf130898ded5ae94a2691eb6b3"sv}, Entry{"domain/v1-receipt.2880-2912.kvei"sv, "86d04beb2f9d7be78501728c5c8f7203d1860607"sv}, Entry{"domain/v1-receipt.2912-2928.bt"sv, "2183f1fa81181fc25124ee843cfb84dccd05310f"sv}, Entry{"domain/v1-receipt.2912-2928.kv"sv, "9940c929116c1cf103626800eb20a21e6fbe6883"sv}, Entry{"domain/v1-receipt.2912-2928.kvei"sv, "da8922ac62ecb206d2959f94a0b047f58f096209"sv}, Entry{"domain/v1-receipt.2928-2936.bt"sv, "b369fb715bcd835868e766b5234e7cc5b4891c8d"sv}, Entry{"domain/v1-receipt.2928-2936.kv"sv, "c8d4e8de35e94d2ce2856d690d0544f4840e8b23"sv}, Entry{"domain/v1-receipt.2928-2936.kvei"sv, "4b0be002df38dae546337defc600cebc0615526b"sv}, Entry{"domain/v1-receipt.2936-2940.bt"sv, "4144e177269aeb4e6ce32200604cd7afcc75a240"sv}, Entry{"domain/v1-receipt.2936-2940.kv"sv, "2f78250a8c48850eeb75c80d31c5d59ebaedb868"sv}, Entry{"domain/v1-receipt.2936-2940.kvei"sv, "c1f3f6f724a3f3358e07ca61655713afc82fac0c"sv}, Entry{"domain/v1-storage.0-2048.bt"sv, "6edfe576bb9968aab9fae4987599ec00766f2f88"sv}, Entry{"domain/v1-storage.0-2048.kv"sv, "69e8bef0d9bf1edc76eee9a7dc8b72670fd7eb8b"sv}, Entry{"domain/v1-storage.0-2048.kvei"sv, "7557541b46e651efa3d81a678f23143184321db0"sv}, Entry{"domain/v1-storage.2048-2560.bt"sv, "396ffa0b616b8722b8637d9b5b6e42f419a05e3f"sv}, Entry{"domain/v1-storage.2048-2560.kv"sv, "5325d9d4623bbd57fede620e9016a866c2bc626f"sv}, Entry{"domain/v1-storage.2048-2560.kvei"sv, "42db737624c089dab4760358700fda44112d0872"sv}, Entry{"domain/v1-storage.2560-2816.bt"sv, "5e4bec604fa18735ed12d677cb03c554bd125841"sv}, Entry{"domain/v1-storage.2560-2816.kv"sv, "2d307f285ece57e9af8fd2f3f8fae55d526a85cd"sv}, Entry{"domain/v1-storage.2560-2816.kvei"sv, "0b7ca16ae3c9003abbd6d35ac2d0f6fefdb54089"sv}, Entry{"domain/v1-storage.2816-2880.bt"sv, "e7abdb521c2cc8a441c27f7141bad1d858f0d5d2"sv}, Entry{"domain/v1-storage.2816-2880.kv"sv, "8565401660f15cdc91bdaf3cca5641ce6f97060f"sv}, Entry{"domain/v1-storage.2816-2880.kvei"sv, "7815ff7bf56bb3caf5a4cd189f9d798f3f1a4cab"sv}, Entry{"domain/v1-storage.2880-2912.bt"sv, "f48467eb3417e451978f5009f33b22254e1b8d27"sv}, Entry{"domain/v1-storage.2880-2912.kv"sv, "b2d855b82e8fad5a9b7317981d17e74756bed85d"sv}, Entry{"domain/v1-storage.2880-2912.kvei"sv, "91e3418bcffd6a50c77bab31d2465e0327a16d22"sv}, Entry{"domain/v1-storage.2912-2928.bt"sv, "1f88c868a7613b6fa95dbb313417a9a4f28ea4ff"sv}, Entry{"domain/v1-storage.2912-2928.kv"sv, "22027ad55adc51c4a650f77daaf9cbe72a2ee3c5"sv}, Entry{"domain/v1-storage.2912-2928.kvei"sv, "05b794bcf5f2f19a79281e445de027c633c1b1f6"sv}, Entry{"domain/v1-storage.2928-2936.bt"sv, "4a801512538e52d9ba013aba9412eb603e82ea20"sv}, Entry{"domain/v1-storage.2928-2936.kv"sv, "8b8955e167243fceda6379a1ef3b7eabde8e732b"sv}, Entry{"domain/v1-storage.2928-2936.kvei"sv, "d5f8f20a172fb279c8ca8b0935a51842779c3e05"sv}, Entry{"domain/v1-storage.2936-2940.bt"sv, "b32e3dcff1b191393267d8e709df4b5dbc585d66"sv}, Entry{"domain/v1-storage.2936-2940.kv"sv, "b3cac707006f8b0c74b654c143174e8262ee080b"sv}, Entry{"domain/v1-storage.2936-2940.kvei"sv, "7b264695464bfd5e73307a53cbb0b6aa802115fd"sv}, Entry{"history/v1-accounts.0-64.v"sv, "fc4574bb130a34e173b408c05da1e57992bf7896"sv}, Entry{"history/v1-accounts.1024-1088.v"sv, "9750768b5e52565675aca2556815f7f95f9173c5"sv}, Entry{"history/v1-accounts.1088-1152.v"sv, "920af356edf2c3c7adc4bb4ce01c7747367c56e7"sv}, Entry{"history/v1-accounts.1152-1216.v"sv, "b1bb358f7897f5d18f926daf1db11fe81d4c3590"sv}, Entry{"history/v1-accounts.1216-1280.v"sv, "0b1880de2dc999ff9045a03b2cb7bcb060e320fc"sv}, Entry{"history/v1-accounts.128-192.v"sv, "12695ff6d17ca7b087b8a7f3f79bc727bc82f051"sv}, Entry{"history/v1-accounts.1280-1344.v"sv, "4395d57d33b72335cf749b94b981f5bc91374dd7"sv}, Entry{"history/v1-accounts.1344-1408.v"sv, "07350f605c5611b3160ad41d7fed62a5070eee05"sv}, Entry{"history/v1-accounts.1408-1472.v"sv, "7d88438ae9f1248b5155cdb001d6edba3294d93a"sv}, Entry{"history/v1-accounts.1472-1536.v"sv, "1e06b95f4e661c7b953a6373dd7b9db735def2f1"sv}, Entry{"history/v1-accounts.1536-1600.v"sv, "9819f0a6d3263440243315fb0042e04f39bfb9fc"sv}, Entry{"history/v1-accounts.1600-1664.v"sv, "c6d67f4cf41bbceafd9313d3655e5155ab16818a"sv}, Entry{"history/v1-accounts.1664-1728.v"sv, "cf5aca15ad9afd92e425d4c53bcbb3d3286b5355"sv}, Entry{"history/v1-accounts.1728-1792.v"sv, "becfd68f94bd4d62e74e6a2aab8a713d7cc01c6b"sv}, Entry{"history/v1-accounts.1792-1856.v"sv, "1896c6ccf3371a43228ac5eabd1b1ccff44c4f4f"sv}, Entry{"history/v1-accounts.1856-1920.v"sv, "b1be93493f6b40b3dd1619ec8e7518bfa37748ca"sv}, Entry{"history/v1-accounts.192-256.v"sv, "540c13a2edabca170bea2ceb6e35c965d0c4ffab"sv}, Entry{"history/v1-accounts.1920-1984.v"sv, "ab7c7acebbef1400ba08ea70cb18f54df8210e6c"sv}, Entry{"history/v1-accounts.1984-2048.v"sv, "db50ee0fad0db2d88e9f2d719f7169284bf5b6c7"sv}, Entry{"history/v1-accounts.2048-2112.v"sv, "e4c4edfc181b406bc4b3b80d3b41077ff69eff1c"sv}, Entry{"history/v1-accounts.2112-2176.v"sv, "a2e7af3cc64843d46b22445d87701fd49796c1d1"sv}, Entry{"history/v1-accounts.2176-2240.v"sv, "c7e29121615f2f56636448c3257bb70eb68c271e"sv}, Entry{"history/v1-accounts.2240-2304.v"sv, "b12f11b75c7f43193cc73e49ba976355a2c5cc51"sv}, Entry{"history/v1-accounts.2304-2368.v"sv, "edf0e14139fa0cff191cd4cf9e9bcc471dd40ed0"sv}, Entry{"history/v1-accounts.2368-2432.v"sv, "5c437085a4cc42bb392285a8d0fe5ac1df358cd8"sv}, Entry{"history/v1-accounts.2432-2496.v"sv, "d2c6b7a2f407c7918b558beae89ffefd867e2f8e"sv}, Entry{"history/v1-accounts.2496-2560.v"sv, "8568db473c062f0f11f3caac35c9caf5128b77c3"sv}, Entry{"history/v1-accounts.256-320.v"sv, "810c043b7d4c6c37bd12a2e89fdae06ccbabebf7"sv}, Entry{"history/v1-accounts.2560-2624.v"sv, "b7259bff033ba8744b5024f0d2a92a4ee5bb0315"sv}, Entry{"history/v1-accounts.2624-2688.v"sv, "fdef75214776d560b51479cc1d28974324207c67"sv}, Entry{"history/v1-accounts.2688-2752.v"sv, "fbe6a3a701cda8ff6adfc4a8b33f9e1bb2b1781b"sv}, Entry{"history/v1-accounts.2752-2816.v"sv, "0dbadfe3d4fd6b788009c9d1d2c5bf7a01afe6be"sv}, Entry{"history/v1-accounts.2816-2880.v"sv, "9f487f5eebc2cae3deabafd81e68a3e0b16a23ff"sv}, Entry{"history/v1-accounts.2880-2912.v"sv, "46f409916a1eb6c3541a67e3572efa672907c43f"sv}, Entry{"history/v1-accounts.2912-2928.v"sv, "391e8b3578a49ef703b1b38d448508e201250714"sv}, Entry{"history/v1-accounts.2928-2936.v"sv, "387969d674ee6b26edebd91f21c1e6614742a7cf"sv}, Entry{"history/v1-accounts.2936-2940.v"sv, "c5e138cac75515a806016d78b84a138fbed54996"sv}, Entry{"history/v1-accounts.320-384.v"sv, "1bc0d64bc73a8d95be3225c5659502ab2ba0ad32"sv}, Entry{"history/v1-accounts.384-448.v"sv, "9bb6be0c63343bd00538a345a73ca4ac3730f0ce"sv}, Entry{"history/v1-accounts.448-512.v"sv, "cd3e78813f1ab17b2705b49bc92eeb1ba06820e0"sv}, Entry{"history/v1-accounts.512-576.v"sv, "e3effa73993121faca3a70fbc5bd0c151bb5e1e9"sv}, Entry{"history/v1-accounts.576-640.v"sv, "4a91c67697d1e28e4b749a9140aab0f59628a6fe"sv}, Entry{"history/v1-accounts.64-128.v"sv, "8a074a9e90374b6fcb15ca5f97bdad8ce0871d6e"sv}, Entry{"history/v1-accounts.640-704.v"sv, "2ae93d883df8c93dc1c8f42732d39a710211f041"sv}, Entry{"history/v1-accounts.704-768.v"sv, "ba9cc53f71c7013e3b3ca2181820b40decfd561a"sv}, Entry{"history/v1-accounts.768-832.v"sv, "8e7e6ea87c878f48e723d2194e3148e7a2a9898a"sv}, Entry{"history/v1-accounts.832-896.v"sv, "6ce566dc559c15a464b0a87abef290275367f52b"sv}, Entry{"history/v1-accounts.896-960.v"sv, "68624f1a6b069257e8c1148738e1bba2280dfd33"sv}, Entry{"history/v1-accounts.960-1024.v"sv, "8cfe25caff2bf9dacb016c34bbe8fc5017ba58f2"sv}, Entry{"history/v1-code.0-64.v"sv, "7428ee125da8cddea2a4e6b35fc0f684d573b706"sv}, Entry{"history/v1-code.1024-1088.v"sv, "1061d33c288adf57efa262325cdd51238b07e13d"sv}, Entry{"history/v1-code.1088-1152.v"sv, "a016ca489c4ae5db44d120dc2207900fb8774085"sv}, Entry{"history/v1-code.1152-1216.v"sv, "717f319f5ad24bf89f18886158f3323088308c95"sv}, Entry{"history/v1-code.1216-1280.v"sv, "894be1f53ef05849f1c5534c038474e0c0d8f85f"sv}, Entry{"history/v1-code.128-192.v"sv, "a6725eb0e174e90134642704a3db0d56ed484bc9"sv}, Entry{"history/v1-code.1280-1344.v"sv, "39d0d4a2580089d96194655bab876372926c8394"sv}, Entry{"history/v1-code.1344-1408.v"sv, "8021acf8480516a92669161fab510304be6ac799"sv}, Entry{"history/v1-code.1408-1472.v"sv, "57f6a57a56863ebefb8b7e5d0deaf336df1bbfbb"sv}, Entry{"history/v1-code.1472-1536.v"sv, "5ca271293360562685260a5bb56dc921010978d7"sv}, Entry{"history/v1-code.1536-1600.v"sv, "4e7ecde1f58c799f8862eb962e18abffd744421f"sv}, Entry{"history/v1-code.1600-1664.v"sv, "321ef68ba54b79fee3f925163ce60fad62d96577"sv}, Entry{"history/v1-code.1664-1728.v"sv, "0412a8ce7342707a4fb4c5295a30231abdc13dc0"sv}, Entry{"history/v1-code.1728-1792.v"sv, "483272f96d76be32628b5ac7a83303fdf87893a9"sv}, Entry{"history/v1-code.1792-1856.v"sv, "36a64a0ab35bb00d3fb691cac8903d43b84ea290"sv}, Entry{"history/v1-code.1856-1920.v"sv, "f5bb8cd6f436c5f355e1319ef37d2efd7cfc7c5a"sv}, Entry{"history/v1-code.192-256.v"sv, "83c79ffe9bcb43894d4a086d88264f00612d92cc"sv}, Entry{"history/v1-code.1920-1984.v"sv, "fdef90ea38187c0bb5504cbb39b3c8594bfb2c0d"sv}, Entry{"history/v1-code.1984-2048.v"sv, "46659b1df37a6da2b04bbae4ad313c2a29880246"sv}, Entry{"history/v1-code.2048-2112.v"sv, "484080981b7227336db95eda05f36253e8dc5108"sv}, Entry{"history/v1-code.2112-2176.v"sv, "a2df97a097996bffa9e9736bd956ac465d869491"sv}, Entry{"history/v1-code.2176-2240.v"sv, "cbd9d1babdba8ca14e141d2f333b35f410b209a7"sv}, Entry{"history/v1-code.2240-2304.v"sv, "d23b6b450c259f0310fb8353e3eafd78f21170cc"sv}, Entry{"history/v1-code.2304-2368.v"sv, "8ddb5588a90f2f9568782f1e5053c0c73aaf20dc"sv}, Entry{"history/v1-code.2368-2432.v"sv, "d81207fcc84bad9448c5a22a412d9fc82c3a4d68"sv}, Entry{"history/v1-code.2432-2496.v"sv, "47d0915bfaf9aecbc0031d80135e2aab3f550487"sv}, Entry{"history/v1-code.2496-2560.v"sv, "c64372fd0291a85dca4b4951bcc81134dfa1cbf5"sv}, Entry{"history/v1-code.256-320.v"sv, "3089c6d1b40b50a1160a9ab8f2372758a6648a2c"sv}, Entry{"history/v1-code.2560-2624.v"sv, "304fda2ef83bcead63f163b39a9ec204a04a8246"sv}, Entry{"history/v1-code.2624-2688.v"sv, "503d377cd326bed28c4a6a73fd83da4c13798f25"sv}, Entry{"history/v1-code.2688-2752.v"sv, "1db72e1fafc1896b2bd8904acc94eb19c78bae71"sv}, Entry{"history/v1-code.2752-2816.v"sv, "a36db7534aa1433f2cc361bfd6a26e1467a0395e"sv}, Entry{"history/v1-code.2816-2880.v"sv, "f0806003eeba683b9dddacb455b56b517cc92575"sv}, Entry{"history/v1-code.2880-2912.v"sv, "458a9ebdba258dc7955460374534d17632ec641b"sv}, Entry{"history/v1-code.2912-2928.v"sv, "0f6c6f2b0f7919fa02527e6c0ecb8fb1eda06b4e"sv}, Entry{"history/v1-code.2928-2936.v"sv, "34d08971f9dd08323bdda6e098838bf89270d231"sv}, Entry{"history/v1-code.2936-2940.v"sv, "8d432e4e8e3dd9ba0022d6ebe85f1058b808c0da"sv}, Entry{"history/v1-code.320-384.v"sv, "201018a9b643c60a66838d0ffcbbb46b48659bb8"sv}, Entry{"history/v1-code.384-448.v"sv, "8fc6aa74406aefad9f10986d8161a5aff9e3fd7e"sv}, Entry{"history/v1-code.448-512.v"sv, "085d281292dea1e6bc3fba1b55bda5ad6309ce78"sv}, Entry{"history/v1-code.512-576.v"sv, "f9938f5efb7b85ad86275b1bd611380a08c9417b"sv}, Entry{"history/v1-code.576-640.v"sv, "a16747a6e3b0e67b1c8f0337405ed5873d6ef968"sv}, Entry{"history/v1-code.64-128.v"sv, "9bd477139c759735d53314676832a9dce71ceea9"sv}, Entry{"history/v1-code.640-704.v"sv, "08270d68753c1ba6418e3865a3dd1200851285a0"sv}, Entry{"history/v1-code.704-768.v"sv, "a0ccf05362bd52fad698aeb35713a741e9c664db"sv}, Entry{"history/v1-code.768-832.v"sv, "a004c71f4b5897d769755d317c30d8d710814480"sv}, Entry{"history/v1-code.832-896.v"sv, "1832736b0d71d8ae7e3af4b3e002c7de001606ad"sv}, Entry{"history/v1-code.896-960.v"sv, "c3bf7c9ff51909cb3b788ab75d76a14f1dafd6fa"sv}, Entry{"history/v1-code.960-1024.v"sv, "1b057a1af0d31e8cc76aa35f9afa4dfa0b96c9a3"sv}, Entry{"history/v1-receipt.0-64.v"sv, "700306c82b936fddb5d1cbe79cdb94d29314c41e"sv}, Entry{"history/v1-receipt.1024-1088.v"sv, "5af5e50ec0f28bf4005adb439f696075ffbd5ddb"sv}, Entry{"history/v1-receipt.1088-1152.v"sv, "b683ac8f941d9a8646a0bcdee724a2ce766ea3e3"sv}, Entry{"history/v1-receipt.1152-1216.v"sv, "67a8455d9ea92f06e3bd377664a3907341484460"sv}, Entry{"history/v1-receipt.1216-1280.v"sv, "21e72c712a259212f4b1f2a77066f33acd2f2bb8"sv}, Entry{"history/v1-receipt.128-192.v"sv, "783be7af5c9ec1441d25d3481d6a2bfa97a0bf7d"sv}, Entry{"history/v1-receipt.1280-1344.v"sv, "92909e3777fb0924c6c874d16154d86927843072"sv}, Entry{"history/v1-receipt.1344-1408.v"sv, "4d21395e77559b9c1704a39a50f75f58d98da281"sv}, Entry{"history/v1-receipt.1408-1472.v"sv, "775bf759b8a23c2997cdd7facb8b9f1faca89463"sv}, Entry{"history/v1-receipt.1472-1536.v"sv, "6b1db7c4d2622eed1847a3f1363b507302c734fc"sv}, Entry{"history/v1-receipt.1536-1600.v"sv, "86762431f8dc5c57965ba92175bb501812949d04"sv}, Entry{"history/v1-receipt.1600-1664.v"sv, "e80d85508e5bb1ed777c5ab715cea5d425379bd2"sv}, Entry{"history/v1-receipt.1664-1728.v"sv, "427aef25c41ed3a4cb2f5aa3bfea1f3e1ee25305"sv}, Entry{"history/v1-receipt.1728-1792.v"sv, "91f7a70c0d1904bd0c975cea40cd4f150578d8b6"sv}, Entry{"history/v1-receipt.1792-1856.v"sv, "c979454a0de5c515b61be9c5ecb4265b893bdf0d"sv}, Entry{"history/v1-receipt.1856-1920.v"sv, "e7f11bedc434dd23c256767880f11d7efd8ebbcc"sv}, Entry{"history/v1-receipt.192-256.v"sv, "e22eb380a231eba9f8982e5d218bc1b54c05de26"sv}, Entry{"history/v1-receipt.1920-1984.v"sv, "0622b2c8aa96a39eda09e2d82829c3c3f1e65245"sv}, Entry{"history/v1-receipt.1984-2048.v"sv, "b8f2e3cf806532cd8a5b3c3201dabaf93e8d5252"sv}, Entry{"history/v1-receipt.2048-2112.v"sv, "68bd4dce699e956b891238ed8a19cd0d1e6ab3a1"sv}, Entry{"history/v1-receipt.2112-2176.v"sv, "ed834f8fd7412cd1c3b1a944bd9219a9966432ef"sv}, Entry{"history/v1-receipt.2176-2240.v"sv, "162e36f411541ccad71da05a5afeda91cfe73370"sv}, Entry{"history/v1-receipt.2240-2304.v"sv, "6c0a098ee9fe33c264685bd564343d8f3bc6433d"sv}, Entry{"history/v1-receipt.2304-2368.v"sv, "5aa6e63a3ac9c35c7ab93e44f8a8314a1366953f"sv}, Entry{"history/v1-receipt.2368-2432.v"sv, "ffae9d3baae64f4a90560f952f7cf493b81b9b67"sv}, Entry{"history/v1-receipt.2432-2496.v"sv, "7834f090da93f273ffaf9f3d9370f4a0450aebe5"sv}, Entry{"history/v1-receipt.2496-2560.v"sv, "04113bfb5e9e9fc7deb05a8f427666e9bce72886"sv}, Entry{"history/v1-receipt.256-320.v"sv, "3fa791d304ef0ff5bf59af0780e8d6b174d50f90"sv}, Entry{"history/v1-receipt.2560-2624.v"sv, "b095c2dc2572a8cb691fffe722177b188e48b58c"sv}, Entry{"history/v1-receipt.2624-2688.v"sv, "e58784dcc16103d7b1cb5caba4a31633a18b41ec"sv}, Entry{"history/v1-receipt.2688-2752.v"sv, "7f169aff4109268dc3e6d9ec43a1dd69d827c048"sv}, Entry{"history/v1-receipt.2752-2816.v"sv, "6dae675823977710c123805482ddee115aba7f0d"sv}, Entry{"history/v1-receipt.2816-2880.v"sv, "a60dc53b359d11c4e19d537c53d2fc294fcdbdd7"sv}, Entry{"history/v1-receipt.2880-2912.v"sv, "e08ec931eba3ca3a09fa47fb9e389f5889787aed"sv}, Entry{"history/v1-receipt.2912-2928.v"sv, "e4ed004c5fd61c37b1570c1d885842339007ecb4"sv}, Entry{"history/v1-receipt.2928-2936.v"sv, "9b46489af9a14735b015997b7616d8860813754b"sv}, Entry{"history/v1-receipt.2936-2940.v"sv, "e8b93b54acad211f1314c9a25bcf5dc5628dd7b7"sv}, Entry{"history/v1-receipt.320-384.v"sv, "60cdd157ed44add188dd44152c817036682c7445"sv}, Entry{"history/v1-receipt.384-448.v"sv, "a76c0ea72942de4c027b116866fc1d27d588e9a6"sv}, Entry{"history/v1-receipt.448-512.v"sv, "cbfee6d384d1c6a01511c96fffb4c669f558bbb9"sv}, Entry{"history/v1-receipt.512-576.v"sv, "bf44da792352c76183d3717d3fcb262243af3e1c"sv}, Entry{"history/v1-receipt.576-640.v"sv, "8d1c700d65024e9a8061af7bb8069607288b4318"sv}, Entry{"history/v1-receipt.64-128.v"sv, "d7c75cd1fbc7c19280ade4ff97ed666713bfe7ed"sv}, Entry{"history/v1-receipt.640-704.v"sv, "deadb4d94599f5585cc3a25d7f53c4e6afd33e25"sv}, Entry{"history/v1-receipt.704-768.v"sv, "6cd5f777827360665c9f9cde9c788e26776d4efa"sv}, Entry{"history/v1-receipt.768-832.v"sv, "1d77d0701af27d65a8b15a6a09126486850217ab"sv}, Entry{"history/v1-receipt.832-896.v"sv, "c133af97f0cd7f4c5751583adfd3041d495811ad"sv}, Entry{"history/v1-receipt.896-960.v"sv, "66004032c8cff666fd07907882fd2a8113a32ccb"sv}, Entry{"history/v1-receipt.960-1024.v"sv, "c1db7fb69d8d40949306f69d27ab7eecc36d996d"sv}, Entry{"history/v1-storage.0-64.v"sv, "884501287e07eeb6db2f55d5d8c8b66cc00fa84b"sv}, Entry{"history/v1-storage.1024-1088.v"sv, "03cd150f910a89fe61949de75c5535c0e93cb668"sv}, Entry{"history/v1-storage.1088-1152.v"sv, "98ff2ee7254cd15b2eca67232a42c76751aded3d"sv}, Entry{"history/v1-storage.1152-1216.v"sv, "e172e66b9eb51ceeaddf043e56207394a763de29"sv}, Entry{"history/v1-storage.1216-1280.v"sv, "85cfcb768efe0e41c95892aced72bec6562b045f"sv}, Entry{"history/v1-storage.128-192.v"sv, "dba21c28959698067e47d120ba42eb057bc42af2"sv}, Entry{"history/v1-storage.1280-1344.v"sv, "9fd2336d7df75720bed60c885f3a6f2ed8d0c70f"sv}, Entry{"history/v1-storage.1344-1408.v"sv, "111be0afbfbd03c79e976a0a7ba34039726542a0"sv}, Entry{"history/v1-storage.1408-1472.v"sv, "b6418fcda64094b89b857302510575fe93c67a8f"sv}, Entry{"history/v1-storage.1472-1536.v"sv, "f73c994e17ee6b4d02a2f1c5eeb26397b5c3f3cb"sv}, Entry{"history/v1-storage.1536-1600.v"sv, "e2abc60105bb997c46825f6e5471237dee55d601"sv}, Entry{"history/v1-storage.1600-1664.v"sv, "3aa79bdd6ce52be8f158ec9f3c37b9e045a119fa"sv}, Entry{"history/v1-storage.1664-1728.v"sv, "821ca415eb79e322e7e4160fdf8c774e359b3153"sv}, Entry{"history/v1-storage.1728-1792.v"sv, "cfa484482fecf9577a0d8c3bbd189a36924738f0"sv}, Entry{"history/v1-storage.1792-1856.v"sv, "e3a8f9b8babc2e939fda71bece25916ad2fe7fbb"sv}, Entry{"history/v1-storage.1856-1920.v"sv, "5e33b48700d3e1b8e40c0ec50cc92112d6e1074b"sv}, Entry{"history/v1-storage.192-256.v"sv, "c3652670bbe7de5d786549c67f3e42425ee79f82"sv}, Entry{"history/v1-storage.1920-1984.v"sv, "3181c7bf89a950d6205a9d2c5a47ff956f5e57c8"sv}, Entry{"history/v1-storage.1984-2048.v"sv, "13ca2184bf74bee6b89a2b44eb4b3b13cca43467"sv}, Entry{"history/v1-storage.2048-2112.v"sv, "cd70bff657a63bfa2479956c3008275e967315e2"sv}, Entry{"history/v1-storage.2112-2176.v"sv, "e0aedd62f357a8633a5256784e194d367a97e10b"sv}, Entry{"history/v1-storage.2176-2240.v"sv, "7a62629d80c50fda4e70750c69cc8dfb5714b25b"sv}, Entry{"history/v1-storage.2240-2304.v"sv, "0e3271ba58b94935ef7563acfcddec94adae507a"sv}, Entry{"history/v1-storage.2304-2368.v"sv, "c61b303f180b47478104090022529b57996489ba"sv}, Entry{"history/v1-storage.2368-2432.v"sv, "8d3b14b0063d955e24a7db49e55b6f53f1986a4b"sv}, Entry{"history/v1-storage.2432-2496.v"sv, "9bd66538b1ac47a1df605785885bca651e31b160"sv}, Entry{"history/v1-storage.2496-2560.v"sv, "55d8231228ffd80d7f6d256f1c010b7414d088b4"sv}, Entry{"history/v1-storage.256-320.v"sv, "ee7ecdb4eccd4a0f0ea096a4736c114c991c551a"sv}, Entry{"history/v1-storage.2560-2624.v"sv, "fa314368282097cf45d9f3b40a521f4879d3c489"sv}, Entry{"history/v1-storage.2624-2688.v"sv, "49dd74e7631e6ca1ba65918eb8acf2a04ff0155b"sv}, Entry{"history/v1-storage.2688-2752.v"sv, "873772267399ce268d1921575b7b8e0873ffd613"sv}, Entry{"history/v1-storage.2752-2816.v"sv, "45d598eb7c20e8c3f9b32ffc1bbde56078acef93"sv}, Entry{"history/v1-storage.2816-2880.v"sv, "8113077570fe38b5ec5dac27a5f32e78fc645b2b"sv}, Entry{"history/v1-storage.2880-2912.v"sv, "7a7f2f604ddb97d0f7c8b279e8bc952aa5714820"sv}, Entry{"history/v1-storage.2912-2928.v"sv, "e8f67a2f1f8b30ef341ece6f02545815d3049699"sv}, Entry{"history/v1-storage.2928-2936.v"sv, "27c927719e559433cf8b0efb9c89bbac16bbfe2e"sv}, Entry{"history/v1-storage.2936-2940.v"sv, "9237e9f552402511b1900d64b997f2d76989d5e3"sv}, Entry{"history/v1-storage.320-384.v"sv, "51fcd8c98e2e20ff45b502174e108fa786f8e5a7"sv}, Entry{"history/v1-storage.384-448.v"sv, "41668452718b3ca4ec3ac20576513f07b3d6a665"sv}, Entry{"history/v1-storage.448-512.v"sv, "21d2fded468be9ada81b698700660a4ecfa391f0"sv}, Entry{"history/v1-storage.512-576.v"sv, "25dff7ed31d860eb4c3592fe425112d6b503803b"sv}, Entry{"history/v1-storage.576-640.v"sv, "c4edb9e731724ad08539f9ade5b1c51a48adfac8"sv}, Entry{"history/v1-storage.64-128.v"sv, "2b75f4296202c6f6989db02091eb19aa158cd14b"sv}, Entry{"history/v1-storage.640-704.v"sv, "723d4f932919b8cd8f2c80fa2630d3b1b3477f25"sv}, Entry{"history/v1-storage.704-768.v"sv, "62f6ec15d6e02a423df17b832a0b1aedf1c95fed"sv}, Entry{"history/v1-storage.768-832.v"sv, "cf0a47fd22921795c4abb6ce9f5c2869768a0aa7"sv}, Entry{"history/v1-storage.832-896.v"sv, "43808a610ec129830f6f1a08d65d0857830c5ea2"sv}, Entry{"history/v1-storage.896-960.v"sv, "05512c46e4dc5dcb07f6119033eb944d959f9838"sv}, Entry{"history/v1-storage.960-1024.v"sv, "586b025058f99ca623079b24b2b305bbce529675"sv}, Entry{"idx/v1-accounts.0-64.ef"sv, "940726142566814f7bdcbd731482782a8a79f785"sv}, Entry{"idx/v1-accounts.1024-1088.ef"sv, "e5e0a3f636d46a3e4858d0a4caa4ac48899a1b47"sv}, Entry{"idx/v1-accounts.1088-1152.ef"sv, "ceebec0a304191a2c50fd601f5879f616caf3a99"sv}, Entry{"idx/v1-accounts.1152-1216.ef"sv, "e78ae1071b56156f3daafaf24183e5924a1ebb12"sv}, Entry{"idx/v1-accounts.1216-1280.ef"sv, "9788721c35a2a8bf628c4197aa8222e780345830"sv}, Entry{"idx/v1-accounts.128-192.ef"sv, "20ce077037aa582e98d2d80d8acf2e4904776637"sv}, Entry{"idx/v1-accounts.1280-1344.ef"sv, "beab94e09a0e279862936346ec40673e83059f1d"sv}, Entry{"idx/v1-accounts.1344-1408.ef"sv, "ef8460737a28df86ab1107df2eccccd5da2066b6"sv}, Entry{"idx/v1-accounts.1408-1472.ef"sv, "d04be6409520e89ec7d7a314fdbf09bfa136de33"sv}, Entry{"idx/v1-accounts.1472-1536.ef"sv, "587246ef7e3e56d47cf36d4564a4d147f0339523"sv}, Entry{"idx/v1-accounts.1536-1600.ef"sv, "7d0f3332ce4d16a71a333c4cd4ccf2cb1a81f404"sv}, Entry{"idx/v1-accounts.1600-1664.ef"sv, "390ff3e24d479f16f7c7c5ed88f64551079ae069"sv}, Entry{"idx/v1-accounts.1664-1728.ef"sv, "a9f75de6d289efc8306752e00fe3f7956af7c44d"sv}, Entry{"idx/v1-accounts.1728-1792.ef"sv, "3fbcf61eae431fb9e1f68c78640f5aaed7f59a5b"sv}, Entry{"idx/v1-accounts.1792-1856.ef"sv, "35ce2fb27043a44c760d2116a22a9f33a0d1e673"sv}, Entry{"idx/v1-accounts.1856-1920.ef"sv, "13026e9465a283d7bcd7f41e3b18386da4d0f1cf"sv}, Entry{"idx/v1-accounts.192-256.ef"sv, "7eb4c2a9dc24ba60111424192f6a6565e8396b2f"sv}, Entry{"idx/v1-accounts.1920-1984.ef"sv, "c409712c176477ed6f82ba6ec657ee2757227291"sv}, Entry{"idx/v1-accounts.1984-2048.ef"sv, "faf258bbfef983ea85dfed1becae4052a81a5a36"sv}, Entry{"idx/v1-accounts.2048-2112.ef"sv, "4f5fed4a1c64f36d98989b251599e90e5e568ee3"sv}, Entry{"idx/v1-accounts.2112-2176.ef"sv, "42241ca446be0553dea8ec43e15525c293e68d7b"sv}, Entry{"idx/v1-accounts.2176-2240.ef"sv, "9acbfb7d35cef45540e3d169498b71ab9ebb5c9c"sv}, Entry{"idx/v1-accounts.2240-2304.ef"sv, "e0815e0b1daa200008d8c926062917577f3f865f"sv}, Entry{"idx/v1-accounts.2304-2368.ef"sv, "d8127ff93756abdd5f3f13418745326a226347a1"sv}, Entry{"idx/v1-accounts.2368-2432.ef"sv, "457872f7e8d28dec614464e7fb52d2042783e2ff"sv}, Entry{"idx/v1-accounts.2432-2496.ef"sv, "1722c3bb1933116b6f19454b005f879cc9a3db58"sv}, Entry{"idx/v1-accounts.2496-2560.ef"sv, "f5f662eb566f56a39b53fe20f3041551d88a89fa"sv}, Entry{"idx/v1-accounts.256-320.ef"sv, "3a253f8acbcc0262cf3b503e2648f95f65d0e3bc"sv}, Entry{"idx/v1-accounts.2560-2624.ef"sv, "9958f01c85da478ce2016e40dc1dea7fc3040333"sv}, Entry{"idx/v1-accounts.2624-2688.ef"sv, "0bbffc1e58f3b584d4749d3ee5a5c3d51c3bf449"sv}, Entry{"idx/v1-accounts.2688-2752.ef"sv, "5162965f840bdab59aa334bf3644c7571562be3d"sv}, Entry{"idx/v1-accounts.2752-2816.ef"sv, "3d20af6ed9e278f7d5f9c8bb5774604c0e3a644b"sv}, Entry{"idx/v1-accounts.2816-2880.ef"sv, "70b184512dd5da86a6511e4f46a628e9156e138d"sv}, Entry{"idx/v1-accounts.2880-2912.ef"sv, "8b8c06f9143c63dc1943fccc264b44fe221c2038"sv}, Entry{"idx/v1-accounts.2912-2928.ef"sv, "e03d6b50e3d5330579e71460a17fb824225bfdee"sv}, Entry{"idx/v1-accounts.2928-2936.ef"sv, "73182b5ec96a24139a5cc2f8ad7dc3dced06873b"sv}, Entry{"idx/v1-accounts.2936-2940.ef"sv, "abf631588f80147e903a22aa404006ea196b0ce8"sv}, Entry{"idx/v1-accounts.320-384.ef"sv, "59be20e016c065ec041c7ea64b52682a775ed239"sv}, Entry{"idx/v1-accounts.384-448.ef"sv, "7e28bfd39e440caa10c293e7a8fc35c584bad22c"sv}, Entry{"idx/v1-accounts.448-512.ef"sv, "c9b040387181ce1182275b1f4684d5a6cd564ce7"sv}, Entry{"idx/v1-accounts.512-576.ef"sv, "b0c29cbe6dbffc6a6d066584414005189a8b80f2"sv}, Entry{"idx/v1-accounts.576-640.ef"sv, "34b473d98c4d468639f279cd44d8a7698515f0b3"sv}, Entry{"idx/v1-accounts.64-128.ef"sv, "c856e0429c906866dc37f12c3743a3396448379c"sv}, Entry{"idx/v1-accounts.640-704.ef"sv, "45ba44ab475b12b1802a80adc0e0650889080b84"sv}, Entry{"idx/v1-accounts.704-768.ef"sv, "16b18f08e513a5bf81e7f24d05e17207daf093c5"sv}, Entry{"idx/v1-accounts.768-832.ef"sv, "4e848124a42df1f067608a66df91effba21f41a2"sv}, Entry{"idx/v1-accounts.832-896.ef"sv, "b8b2dbf27fa0da3e394de2909312fd0974a6d981"sv}, Entry{"idx/v1-accounts.896-960.ef"sv, "86ad760910f74a7500303791e0889f90d75899c9"sv}, Entry{"idx/v1-accounts.960-1024.ef"sv, "6c635ec02f9c8da150780799ae3052ccd3601e0e"sv}, Entry{"idx/v1-code.0-64.ef"sv, "439865105a3b180538b71c0cd5fd9003565caf4c"sv}, Entry{"idx/v1-code.1024-1088.ef"sv, "97139543ec9ade152a7469975b509b41134ca9c7"sv}, Entry{"idx/v1-code.1088-1152.ef"sv, "b60d0926ebe732b7e253dce83967ed7e23accae2"sv}, Entry{"idx/v1-code.1152-1216.ef"sv, "706ee4fcd6aaf6444b4f5be618a927bb8d64162a"sv}, Entry{"idx/v1-code.1216-1280.ef"sv, "5210279629b069fd7c33a692e55c5c00b322455e"sv}, Entry{"idx/v1-code.128-192.ef"sv, "b85d78e2c06e9af77b18f1b0e9693d3eadd7bfe5"sv}, Entry{"idx/v1-code.1280-1344.ef"sv, "a9c44286fb149cf09f74d456d9a79b709dc186e8"sv}, Entry{"idx/v1-code.1344-1408.ef"sv, "abb9c502043ac48bfffc175300841c64285ef7bd"sv}, Entry{"idx/v1-code.1408-1472.ef"sv, "93e855a17695fdcef0e2361e16e522523aac248b"sv}, Entry{"idx/v1-code.1472-1536.ef"sv, "3016d8231135e3c0d087aabdc741c62cc7b4df15"sv}, Entry{"idx/v1-code.1536-1600.ef"sv, "42218a889827925cf5e1b94314ae53d19214a07d"sv}, Entry{"idx/v1-code.1600-1664.ef"sv, "30a0f37790627b376c3c03dc836ee5efb2591178"sv}, Entry{"idx/v1-code.1664-1728.ef"sv, "d46f25d96b3ada88fd2798c9bb7874e2e155441c"sv}, Entry{"idx/v1-code.1728-1792.ef"sv, "8aabac99dcf275c10692b46fb80ebb1692a08bbb"sv}, Entry{"idx/v1-code.1792-1856.ef"sv, "c26a876781816471f646d352953d29703fc32188"sv}, Entry{"idx/v1-code.1856-1920.ef"sv, "af3e3154b3de66f1505182028a56b364bdb4003f"sv}, Entry{"idx/v1-code.192-256.ef"sv, "4ff0ea2b37618ea2563c0b64e3f2f5f6909ed9fd"sv}, Entry{"idx/v1-code.1920-1984.ef"sv, "c923d3c51b6bc66b9e352bd4affcc73e90a84580"sv}, Entry{"idx/v1-code.1984-2048.ef"sv, "4d62e90eb3e7dc519f05b69ebecfdd1bb9670321"sv}, Entry{"idx/v1-code.2048-2112.ef"sv, "97969523cbcf4b020ebdef8fbb4a64d164e97b4e"sv}, Entry{"idx/v1-code.2112-2176.ef"sv, "c68691e8b4d32c8205ce64a6c50234b8177d7c06"sv}, Entry{"idx/v1-code.2176-2240.ef"sv, "23d428a962c8391cdc5d8d2d1d185c08f1539f37"sv}, Entry{"idx/v1-code.2240-2304.ef"sv, "a4cdc1098b6104cf0351679571848b587b8ed348"sv}, Entry{"idx/v1-code.2304-2368.ef"sv, "fca5490b05c03996d6972b1dec27aec8aa90a64d"sv}, Entry{"idx/v1-code.2368-2432.ef"sv, "19d999206dd6ad20e990086c88676bd6aba39dbc"sv}, Entry{"idx/v1-code.2432-2496.ef"sv, "554ed8ac296e0e8d2fa05fa1d5ff5f41439ee680"sv}, Entry{"idx/v1-code.2496-2560.ef"sv, "efc462f86a9f26cab88688213c616ba57274a7ed"sv}, Entry{"idx/v1-code.256-320.ef"sv, "b374ea63b35e6d1120c234543facce793bf2a58d"sv}, Entry{"idx/v1-code.2560-2624.ef"sv, "8fda3269c896b349d26433a0b2b4bb9eda98732b"sv}, Entry{"idx/v1-code.2624-2688.ef"sv, "7492887dd731579f9d286ac0792d59eaeaa5e45f"sv}, Entry{"idx/v1-code.2688-2752.ef"sv, "f79157ff396799b1dfc908c5ceabd502b9965499"sv}, Entry{"idx/v1-code.2752-2816.ef"sv, "96a14dc4ef99759ef9f52704c24fbdf9ec864386"sv}, Entry{"idx/v1-code.2816-2880.ef"sv, "84d46164de1dd8abe51bb38027d4ea73617a1b89"sv}, Entry{"idx/v1-code.2880-2912.ef"sv, "f2ab563d53d25d4d213dabe77c46deadd69657a2"sv}, Entry{"idx/v1-code.2912-2928.ef"sv, "c8fcdb106acd32183162c0073fb07e85ae00ad0c"sv}, Entry{"idx/v1-code.2928-2936.ef"sv, "7c926d6fe4406f8be331e54adb6ff54936d889a2"sv}, Entry{"idx/v1-code.2936-2940.ef"sv, "6968d10d7eb8813f02fa08466c0905e067b3937b"sv}, Entry{"idx/v1-code.320-384.ef"sv, "7ce24cc7ef38b93194268841329bcce6d35e23e3"sv}, Entry{"idx/v1-code.384-448.ef"sv, "110b3ffcf8fabe570015ac878d44f44135c7f662"sv}, Entry{"idx/v1-code.448-512.ef"sv, "513a81952f9c5c256ab9b22e8807403fe3de44d6"sv}, Entry{"idx/v1-code.512-576.ef"sv, "1e0028273c70f15e3756d12e0d23d9aac4b0751e"sv}, Entry{"idx/v1-code.576-640.ef"sv, "5ca090f89280e047a200d9559a9ba58ac6e5866d"sv}, Entry{"idx/v1-code.64-128.ef"sv, "724fe62b5898d2b5bfc3d503f332efbf3c65d852"sv}, Entry{"idx/v1-code.640-704.ef"sv, "83a792ed0c2e609bc01ffee84436a86f11b8f0e3"sv}, Entry{"idx/v1-code.704-768.ef"sv, "a62c9da1584a56cda6170aa20e93b0a462226af0"sv}, Entry{"idx/v1-code.768-832.ef"sv, "0a92600310fd16d8c9d5903ab11d79c24382e91d"sv}, Entry{"idx/v1-code.832-896.ef"sv, "7682aeff818fe84d62e39bcab37d25eef6662628"sv}, Entry{"idx/v1-code.896-960.ef"sv, "aaa9412b842c41d472a2c32435946222a7c79a2a"sv}, Entry{"idx/v1-code.960-1024.ef"sv, "7c5a7adfc3f5b0f7211d021e76b50bed3fc7c8d3"sv}, Entry{"idx/v1-logaddrs.0-64.ef"sv, "ba00fe17737433bb16a19d23752c82ef1d6930c6"sv}, Entry{"idx/v1-logaddrs.1024-1088.ef"sv, "005ddbbd5fa15735c928a9a29a577f0c320edb5b"sv}, Entry{"idx/v1-logaddrs.1088-1152.ef"sv, "539c516b004044978b8727e191cab6f63a805358"sv}, Entry{"idx/v1-logaddrs.1152-1216.ef"sv, "3610c01d43a81d34cb1255befa6eee34b2b22655"sv}, Entry{"idx/v1-logaddrs.1216-1280.ef"sv, "7dec41298ffe64c869cbb851acc37b2901b452ed"sv}, Entry{"idx/v1-logaddrs.128-192.ef"sv, "a6410932dfb4189b00aa719ab5dd83445c6a654e"sv}, Entry{"idx/v1-logaddrs.1280-1344.ef"sv, "b02cc00a8570e120ea807a5f5a5be65538e09c24"sv}, Entry{"idx/v1-logaddrs.1344-1408.ef"sv, "68148c52f0192c861493738ed20e8d0484d4ec15"sv}, Entry{"idx/v1-logaddrs.1408-1472.ef"sv, "a6f77a01dda44cb58d1a0be14dc1e1d32e8bfdf8"sv}, Entry{"idx/v1-logaddrs.1472-1536.ef"sv, "8ed78120b4d16e78460adc040a64ea67f09516e5"sv}, Entry{"idx/v1-logaddrs.1536-1600.ef"sv, "a446d6b316954392c9c07fd2469c7dbab9b2440d"sv}, Entry{"idx/v1-logaddrs.1600-1664.ef"sv, "79f13e06abbc1480bbb593bf4f0c4655bc897add"sv}, Entry{"idx/v1-logaddrs.1664-1728.ef"sv, "50694d49ffc283ea8c0b5e93a921b8202d205db3"sv}, Entry{"idx/v1-logaddrs.1728-1792.ef"sv, "27533dbba95beaaea8c45c827dae2328cdbf9608"sv}, Entry{"idx/v1-logaddrs.1792-1856.ef"sv, "dac0544ffbbb01d72409db0794941f50f798dcd8"sv}, Entry{"idx/v1-logaddrs.1856-1920.ef"sv, "613dc7bf2a663cd10f323b3151815df4a2446565"sv}, Entry{"idx/v1-logaddrs.192-256.ef"sv, "217dbc7cb92b2719d6011c620c086f3d1ca8a27c"sv}, Entry{"idx/v1-logaddrs.1920-1984.ef"sv, "2e0ad9213a266242f1e0104ccc16c49e8dfc8562"sv}, Entry{"idx/v1-logaddrs.1984-2048.ef"sv, "470c77b57280d28c10cd5548ad46f121a7928264"sv}, Entry{"idx/v1-logaddrs.2048-2112.ef"sv, "2181709818f098f006a6100d3bc798f83daa6f23"sv}, Entry{"idx/v1-logaddrs.2112-2176.ef"sv, "b06ad31452c727b8788c0653aab7d928eeccc115"sv}, Entry{"idx/v1-logaddrs.2176-2240.ef"sv, "fca3b6811351de2b87b5d4f4a10b2489da32cfea"sv}, Entry{"idx/v1-logaddrs.2240-2304.ef"sv, "f27f2b73f73b552f3558783039c303db06dd97e8"sv}, Entry{"idx/v1-logaddrs.2304-2368.ef"sv, "e542eb8d40b588b91abd254a46751936eae95a5f"sv}, Entry{"idx/v1-logaddrs.2368-2432.ef"sv, "cd4166d712bef33cfd1b15d08743d74acd54dcf2"sv}, Entry{"idx/v1-logaddrs.2432-2496.ef"sv, "e8dcf04550f73bc80d374e9e1bce5fc4fa7267f2"sv}, Entry{"idx/v1-logaddrs.2496-2560.ef"sv, "6ba833d137d3a6fd215c8dbf7dc220d805d65095"sv}, Entry{"idx/v1-logaddrs.256-320.ef"sv, "46f0ea2cc0ca01149b71a731aea0c32c35701659"sv}, Entry{"idx/v1-logaddrs.2560-2624.ef"sv, "110a9b29731a262c83a8e1bc0944340ec757b8ce"sv}, Entry{"idx/v1-logaddrs.2624-2688.ef"sv, "50dda84c0dacbb69fe98f8a57650fbcf9943467b"sv}, Entry{"idx/v1-logaddrs.2688-2752.ef"sv, "733937955b82466f9166f9f7c1d801f9398e0755"sv}, Entry{"idx/v1-logaddrs.2752-2816.ef"sv, "766c56e1000d38146c88b0d38d541a77015b7bbf"sv}, Entry{"idx/v1-logaddrs.2816-2880.ef"sv, "1f11d9c98797a866eefed0771dbc1fa52eef0b70"sv}, Entry{"idx/v1-logaddrs.2880-2912.ef"sv, "077c90cfd650bbacbc84ffff17534f99db78bd0f"sv}, Entry{"idx/v1-logaddrs.2912-2928.ef"sv, "1649caf8cf9dbdca3ddfb45f696a104b1d902de4"sv}, Entry{"idx/v1-logaddrs.2928-2936.ef"sv, "212b6bcdaf56a1c7d05ec2eb708b645511283793"sv}, Entry{"idx/v1-logaddrs.2936-2940.ef"sv, "0378bdeca97793b46d1fb298eeae255768d00903"sv}, Entry{"idx/v1-logaddrs.320-384.ef"sv, "841fcbd1cdf78f082851a3cdce2af0cdc3766fe0"sv}, Entry{"idx/v1-logaddrs.384-448.ef"sv, "f36d91d98d4a019d36c3d29f8d02ccb25c5798c8"sv}, Entry{"idx/v1-logaddrs.448-512.ef"sv, "d9c87e047b5290719a2b44ba19a8eba248b5564a"sv}, Entry{"idx/v1-logaddrs.512-576.ef"sv, "29d5e640107efe737cd2840130ec7fd55d10a686"sv}, Entry{"idx/v1-logaddrs.576-640.ef"sv, "199b569b809313993e817b90c251137fd2398246"sv}, Entry{"idx/v1-logaddrs.64-128.ef"sv, "f6847e27edf7b7a7384ce62aff97e1b58197720c"sv}, Entry{"idx/v1-logaddrs.640-704.ef"sv, "2fbc31c831887f5591623cb29e7f39527c935de8"sv}, Entry{"idx/v1-logaddrs.704-768.ef"sv, "1fffa3d2f01e4aea589aa77882f371f1e4597469"sv}, Entry{"idx/v1-logaddrs.768-832.ef"sv, "5c059d7a3dc1231e48c742decc2482d7fe90d823"sv}, Entry{"idx/v1-logaddrs.832-896.ef"sv, "54c3ad114a5cea86ead6664cfed336ff1fb26100"sv}, Entry{"idx/v1-logaddrs.896-960.ef"sv, "b2bfc67ee0adfa297bfd0987dc07d4c56e1a3db1"sv}, Entry{"idx/v1-logaddrs.960-1024.ef"sv, "83104a7688024ef6a2260157f7a33d1c677baf1e"sv}, Entry{"idx/v1-logtopics.0-64.ef"sv, "83eceb96bfbcaa961f011a3000d0b528fc98b56e"sv}, Entry{"idx/v1-logtopics.1024-1088.ef"sv, "a19bac61c0f1a1d06941367124b9a212fe00c39c"sv}, Entry{"idx/v1-logtopics.1088-1152.ef"sv, "7fa491505e73b72367c8d65954ff15c7a4cc6214"sv}, Entry{"idx/v1-logtopics.1152-1216.ef"sv, "4fa2077ce36adffda5f1980503481054659b92e0"sv}, Entry{"idx/v1-logtopics.1216-1280.ef"sv, "7668374e4b0f916ec1c479f7e3ed3dd8864d7ebc"sv}, Entry{"idx/v1-logtopics.128-192.ef"sv, "889b570a53106bf402a47d1fcdaa7f929f565688"sv}, Entry{"idx/v1-logtopics.1280-1344.ef"sv, "28ae3a8bd1f927d92e4f6f25d86c5fe426cc44f4"sv}, Entry{"idx/v1-logtopics.1344-1408.ef"sv, "af9122bc58404865b5a43ad0cfe55c3878f9e50c"sv}, Entry{"idx/v1-logtopics.1408-1472.ef"sv, "fd73cde0fc882073665f34387b67150ebf269feb"sv}, Entry{"idx/v1-logtopics.1472-1536.ef"sv, "826fed605d5e87856780f97ead72ec1894427eea"sv}, Entry{"idx/v1-logtopics.1536-1600.ef"sv, "c55abe559e7ae5d132312e9d82a0b03d4cf956ba"sv}, Entry{"idx/v1-logtopics.1600-1664.ef"sv, "7ed57d8ce39480fa67dc718c3f6084d81ee3263f"sv}, Entry{"idx/v1-logtopics.1664-1728.ef"sv, "a01e0322e285ec0bb51ff700c721c8d9e2bd7de0"sv}, Entry{"idx/v1-logtopics.1728-1792.ef"sv, "19837b23a6be0b4abc6e4094512eea81169e7e8c"sv}, Entry{"idx/v1-logtopics.1792-1856.ef"sv, "d65f1f1172a5ea4a1736c5b1ed5b5f0dfb0c4598"sv}, Entry{"idx/v1-logtopics.1856-1920.ef"sv, "4b5d254931654eaa300cb6abaf4bbdd3a9682406"sv}, Entry{"idx/v1-logtopics.192-256.ef"sv, "433b85f8b8b6bdb74642d69167edfc1499708376"sv}, Entry{"idx/v1-logtopics.1920-1984.ef"sv, "d3a7971393c31580819d898cb398d1cfabcdf9a7"sv}, Entry{"idx/v1-logtopics.1984-2048.ef"sv, "030f6ddb0691a8df15bcb00598fdab80447b019a"sv}, Entry{"idx/v1-logtopics.2048-2112.ef"sv, "582ca3270baa4361dccd02e1c075b69cc8e4251f"sv}, Entry{"idx/v1-logtopics.2112-2176.ef"sv, "4c6898fd78a6d9bb4fa7eee4a1391adb088a94f4"sv}, Entry{"idx/v1-logtopics.2176-2240.ef"sv, "4c67dbced605180d9d2b9b68f1da2a5188880f6d"sv}, Entry{"idx/v1-logtopics.2240-2304.ef"sv, "b10671b0be658c635a4d447cdb8b76aa36db8231"sv}, Entry{"idx/v1-logtopics.2304-2368.ef"sv, "58cec5d40e6bf4181e218e3221fb2a57711f80dd"sv}, Entry{"idx/v1-logtopics.2368-2432.ef"sv, "9d37bcb050cf3f32df46337aa4fb460a695e4e16"sv}, Entry{"idx/v1-logtopics.2432-2496.ef"sv, "ebfb7916599bdda89e993c279f391f2fac944682"sv}, Entry{"idx/v1-logtopics.2496-2560.ef"sv, "dba0bd2d1882810f9208583236aacc53402e2369"sv}, Entry{"idx/v1-logtopics.256-320.ef"sv, "b70024fdd4227497619e7138bc0c92f805e5e367"sv}, Entry{"idx/v1-logtopics.2560-2624.ef"sv, "a520410800e1b2fea4e05a0d372e85148c949dd7"sv}, Entry{"idx/v1-logtopics.2624-2688.ef"sv, "4b9a64e09677be8aed810e6afb62d50d31ff71ab"sv}, Entry{"idx/v1-logtopics.2688-2752.ef"sv, "ca544c65c14831ec269adaaaee9a82e602b585c1"sv}, Entry{"idx/v1-logtopics.2752-2816.ef"sv, "f0ce73dc7311c2e7f3f4952fd8c828fca0c48cb4"sv}, Entry{"idx/v1-logtopics.2816-2880.ef"sv, "91460a69f4144ff621e8c9ccf5352a5f8de441e2"sv}, Entry{"idx/v1-logtopics.2880-2912.ef"sv, "34fb574c0091fba1591bddcfcd572c0a7e047971"sv}, Entry{"idx/v1-logtopics.2912-2928.ef"sv, "6c2523e6ed3c4ce464687a7dd5954ee06257db64"sv}, Entry{"idx/v1-logtopics.2928-2936.ef"sv, "b0ebcd242bacecb24c91eb549db90fd072684b37"sv}, Entry{"idx/v1-logtopics.2936-2940.ef"sv, "956e153e65102d4cf1777937e22d4944976acd25"sv}, Entry{"idx/v1-logtopics.320-384.ef"sv, "6361afbfd43f2951e82d07c835ef0b81efb19fa6"sv}, Entry{"idx/v1-logtopics.384-448.ef"sv, "7e86c9a41194581a57cf2a3ae82e17c33c888a57"sv}, Entry{"idx/v1-logtopics.448-512.ef"sv, "f7a81fc97e77ab4f677d80b5bdabc5c27ac22787"sv}, Entry{"idx/v1-logtopics.512-576.ef"sv, "adf572e6ce1522b345ac3fde40f861dfc20cd3c8"sv}, Entry{"idx/v1-logtopics.576-640.ef"sv, "8a7923165cfe7ae44cae4f8de0d7b115ae2be569"sv}, Entry{"idx/v1-logtopics.64-128.ef"sv, "e21b5739d5ebf931a71bb5467828afcd3af487f2"sv}, Entry{"idx/v1-logtopics.640-704.ef"sv, "3b71c4f3d651a1d3a477b5746ce556447a97d9fc"sv}, Entry{"idx/v1-logtopics.704-768.ef"sv, "0fb7ba5339d3f11e8517e9df35ff79f4eeb9ab80"sv}, Entry{"idx/v1-logtopics.768-832.ef"sv, "6462d918ff81deb0ce38cc955c3cc491280dec5f"sv}, Entry{"idx/v1-logtopics.832-896.ef"sv, "270dc857d62fa06de63f753cb280806eaaf3152c"sv}, Entry{"idx/v1-logtopics.896-960.ef"sv, "e0b1b998e0ba1d98d10298727841578d37312f70"sv}, Entry{"idx/v1-logtopics.960-1024.ef"sv, "4355eba66405f74634278d3633df8fc4b024be95"sv}, Entry{"idx/v1-receipt.0-64.ef"sv, "9f846b1b9e9abf2264b9603bb7fd57b1ce99e996"sv}, Entry{"idx/v1-receipt.1024-1088.ef"sv, "731278979d521b75c105580425cf50ac2eb4773b"sv}, Entry{"idx/v1-receipt.1088-1152.ef"sv, "0299ac1fed016c80f5413c04c2852465cfbfedad"sv}, Entry{"idx/v1-receipt.1152-1216.ef"sv, "c94f59224444db645d39435ca2311defa3a945db"sv}, Entry{"idx/v1-receipt.1216-1280.ef"sv, "82b8c4a12544d3827d8636362c3655f890b34bcd"sv}, Entry{"idx/v1-receipt.128-192.ef"sv, "e21fa91759914ec652718e049b9e95f16bb30604"sv}, Entry{"idx/v1-receipt.1280-1344.ef"sv, "57af0a392fa2a3d16442affd67cbf13e54425332"sv}, Entry{"idx/v1-receipt.1344-1408.ef"sv, "40a1f929d98a371e42b2daf6dcc86266c8c3d0a8"sv}, Entry{"idx/v1-receipt.1408-1472.ef"sv, "d7cb59687188519f2349bc03ac3e728413758346"sv}, Entry{"idx/v1-receipt.1472-1536.ef"sv, "3e8b504289fd7f9ee3ed961e61585040fc5f7f56"sv}, Entry{"idx/v1-receipt.1536-1600.ef"sv, "3743bb0b5cfaa6dc54409a1c58da26f503c47184"sv}, Entry{"idx/v1-receipt.1600-1664.ef"sv, "1ae5c5452ba5ebebd45b766f8485d2a7d58ed32c"sv}, Entry{"idx/v1-receipt.1664-1728.ef"sv, "a0c1e9d87ae637df30c163a4597610122f22cb51"sv}, Entry{"idx/v1-receipt.1728-1792.ef"sv, "1ffc12fd8cf6c0ae20902af2ea0d4560da8416da"sv}, Entry{"idx/v1-receipt.1792-1856.ef"sv, "c510af6cfdb6e0e70f446a5ec8db3d6b1758236d"sv}, Entry{"idx/v1-receipt.1856-1920.ef"sv, "800bb820c913847813b0965551ffbdcd1c4d2729"sv}, Entry{"idx/v1-receipt.192-256.ef"sv, "2eeaee6ebe636d8336703eaf02a4f76b55bfeb7a"sv}, Entry{"idx/v1-receipt.1920-1984.ef"sv, "4c49a8dc9a1861426492fbc6e8eaf7f224260ca7"sv}, Entry{"idx/v1-receipt.1984-2048.ef"sv, "4c3fa00d35c99bbd720d0161afb43826ab34cff5"sv}, Entry{"idx/v1-receipt.2048-2112.ef"sv, "240db090493ce11e5e356d9f8c9a16e8058d0f9d"sv}, Entry{"idx/v1-receipt.2112-2176.ef"sv, "52ad063848dee9a7d867db7082f26c8d7fce8730"sv}, Entry{"idx/v1-receipt.2176-2240.ef"sv, "f18045de3dc01e7bc5f2b836e183858436ac9aa0"sv}, Entry{"idx/v1-receipt.2240-2304.ef"sv, "c8bd637c896ff57a22446369f17f5406d4eb223d"sv}, Entry{"idx/v1-receipt.2304-2368.ef"sv, "33ee5eef15d119a603a93e659a44b35960204965"sv}, Entry{"idx/v1-receipt.2368-2432.ef"sv, "88020d4223bdcca064a1cb6ffc1fc1ed88fef1d1"sv}, Entry{"idx/v1-receipt.2432-2496.ef"sv, "0305c6cf76b9f358e032fbd9200fc896f26a9fb9"sv}, Entry{"idx/v1-receipt.2496-2560.ef"sv, "4f1ae34c3a6136e37ebd036a434b148f3efc66c0"sv}, Entry{"idx/v1-receipt.256-320.ef"sv, "62ea7f10aca1344e2c274e79e8e1df5a0cf34809"sv}, Entry{"idx/v1-receipt.2560-2624.ef"sv, "e1de6a3762a95c8d9d6487420660733b051f0b23"sv}, Entry{"idx/v1-receipt.2624-2688.ef"sv, "af4013f30cf3801595d094b8ba24fee43e5203be"sv}, Entry{"idx/v1-receipt.2688-2752.ef"sv, "ff07dd7adf88a5c9ac1515d4d933c77b7f4cd7a7"sv}, Entry{"idx/v1-receipt.2752-2816.ef"sv, "b1f8b1a28157d35cd91b7f50191bbeed7551e463"sv}, Entry{"idx/v1-receipt.2816-2880.ef"sv, "ce0e7ed3fbf58f81671a0bd7e4b60770f7cc0aff"sv}, Entry{"idx/v1-receipt.2880-2912.ef"sv, "e4b0c0f8ede3caf4f9801c1a4ad2e9b918095daf"sv}, Entry{"idx/v1-receipt.2912-2928.ef"sv, "cd28f2dfbb550aec0ba8c45ba273078474381ee2"sv}, Entry{"idx/v1-receipt.2928-2936.ef"sv, "e2080ea5598fb46a4908584147ffdbd2633bf3e7"sv}, Entry{"idx/v1-receipt.2936-2940.ef"sv, "6754595912b41b83a91cfc3dcf41bbf23ef1860c"sv}, Entry{"idx/v1-receipt.320-384.ef"sv, "54268c676ee1afb01699ff540104c0fe0bd68c30"sv}, Entry{"idx/v1-receipt.384-448.ef"sv, "59fc9242af8be1d675f2fc581e727fd9c3356198"sv}, Entry{"idx/v1-receipt.448-512.ef"sv, "bb903324df00dd018fb78f46886d37290b48ae3e"sv}, Entry{"idx/v1-receipt.512-576.ef"sv, "dd4cc0c5f434dc6851c0a796c69439dc854eff51"sv}, Entry{"idx/v1-receipt.576-640.ef"sv, "2ed5491a3962c165af31020ef77893355c29935d"sv}, Entry{"idx/v1-receipt.64-128.ef"sv, "fe072a4d68e50486c4f5e9208e0a2f21c14b1637"sv}, Entry{"idx/v1-receipt.640-704.ef"sv, "44e38d0c526e2e5b5a0207ccedc0bb08debda524"sv}, Entry{"idx/v1-receipt.704-768.ef"sv, "469d00d7ba7e6ba8b56b2deb3d28b569e7648e63"sv}, Entry{"idx/v1-receipt.768-832.ef"sv, "4b10c23df2927d8312066f08dd8eff276eeff2e8"sv}, Entry{"idx/v1-receipt.832-896.ef"sv, "11b8cd04f6ec75ad47a553ce07d4a4521bbbf8f6"sv}, Entry{"idx/v1-receipt.896-960.ef"sv, "e3b7e49490fcfd575a708973e924d91ab1544067"sv}, Entry{"idx/v1-receipt.960-1024.ef"sv, "651fde4121a413793fc6e019ff1d2a88ede8072b"sv}, Entry{"idx/v1-storage.0-64.ef"sv, "2bde71bcae1180954faa4375b66279281752fb65"sv}, Entry{"idx/v1-storage.1024-1088.ef"sv, "bbb9bfbec63e4a778b0e94f7ca44a1bd4b018884"sv}, Entry{"idx/v1-storage.1088-1152.ef"sv, "78042a649fd34d66a09ccb30c725324688b03523"sv}, Entry{"idx/v1-storage.1152-1216.ef"sv, "d2706bcf59276380d4ee8c11d3d883816a96a55b"sv}, Entry{"idx/v1-storage.1216-1280.ef"sv, "680dade055aa558998b2c4bab51d48aa9156f612"sv}, Entry{"idx/v1-storage.128-192.ef"sv, "a814caa7af430f62d2c652ca2c29d420c2f124da"sv}, Entry{"idx/v1-storage.1280-1344.ef"sv, "b3da91188307ec534ad4e09bfb748e0e782d773a"sv}, Entry{"idx/v1-storage.1344-1408.ef"sv, "9124016cb7971127f3382ff1bed983e1b6f46711"sv}, Entry{"idx/v1-storage.1408-1472.ef"sv, "42e679f60515a164a86f829e825393075b9ba3af"sv}, Entry{"idx/v1-storage.1472-1536.ef"sv, "186f385162ef146cc4589f4dcf571fd45b0ed716"sv}, Entry{"idx/v1-storage.1536-1600.ef"sv, "f2af9352e51326d44fa823c52c90f916f64a5d5b"sv}, Entry{"idx/v1-storage.1600-1664.ef"sv, "ae68e412c7e38a44692a9448058e3c09ae099176"sv}, Entry{"idx/v1-storage.1664-1728.ef"sv, "076dd912c6620cf363929255505d8da8619780b5"sv}, Entry{"idx/v1-storage.1728-1792.ef"sv, "6adc2ab8ae3bf622d27ecd271c6709b6d018be5a"sv}, Entry{"idx/v1-storage.1792-1856.ef"sv, "1c986eb85b3808f7bd0a22b4afe3cc8db70aaab0"sv}, Entry{"idx/v1-storage.1856-1920.ef"sv, "99dac80e5b37d229655789056e78c2f6b56785b9"sv}, Entry{"idx/v1-storage.192-256.ef"sv, "1e90ad30e725aedc3a8238604f9952460eea837f"sv}, Entry{"idx/v1-storage.1920-1984.ef"sv, "23dd46a1b22dba2518b396fa4802830cf4622780"sv}, Entry{"idx/v1-storage.1984-2048.ef"sv, "e9546d7764496dcdcdd2073795b9fab444c8e32d"sv}, Entry{"idx/v1-storage.2048-2112.ef"sv, "bae64e0803cb8ea372535922107ecf4b80677a40"sv}, Entry{"idx/v1-storage.2112-2176.ef"sv, "5c4cedae746a9e876abf6891529cf3d1dff1b571"sv}, Entry{"idx/v1-storage.2176-2240.ef"sv, "cffd6c2dabca821b9a26d78eed099db7873f8b12"sv}, Entry{"idx/v1-storage.2240-2304.ef"sv, "4a0a370ed333f527660f095c8a32ce5fd2fdf32b"sv}, Entry{"idx/v1-storage.2304-2368.ef"sv, "f6324c39c4f399c6c34a8fb3fb9dd6b508b01e88"sv}, Entry{"idx/v1-storage.2368-2432.ef"sv, "cc68f753f790015461f09640e69380eaa79b48ee"sv}, Entry{"idx/v1-storage.2432-2496.ef"sv, "5060a7d10c45dd753a5cae518f74c3a273708da3"sv}, Entry{"idx/v1-storage.2496-2560.ef"sv, "c8c98d04dbef6453102f28aaf59ad24770b20680"sv}, Entry{"idx/v1-storage.256-320.ef"sv, "91088120691be3569896fb4641c8c313917f0cc5"sv}, Entry{"idx/v1-storage.2560-2624.ef"sv, "2cdd13d471fc858e6683e185177aedebfe499f9b"sv}, Entry{"idx/v1-storage.2624-2688.ef"sv, "56ae6617feee98fe09294ae0f66830b088534059"sv}, Entry{"idx/v1-storage.2688-2752.ef"sv, "24345fd6dab810202c5351abf58aaaa427eaf3eb"sv}, Entry{"idx/v1-storage.2752-2816.ef"sv, "52ecaf45444af26089c9b91effed42edbd5b844a"sv}, Entry{"idx/v1-storage.2816-2880.ef"sv, "378ea02cf21d8ef3ce9d4b1ecba39baf7483825a"sv}, Entry{"idx/v1-storage.2880-2912.ef"sv, "8164abdcca2015495c3e7a6a5fc820a285fbae9c"sv}, Entry{"idx/v1-storage.2912-2928.ef"sv, "2a544a26a056539b0efd0a45e336a0684fcf6adc"sv}, Entry{"idx/v1-storage.2928-2936.ef"sv, "c36690670d076e0052d0419931faa65aaa2dcac3"sv}, Entry{"idx/v1-storage.2936-2940.ef"sv, "b6cb346e98b32e6184566948a46cad287d7df541"sv}, Entry{"idx/v1-storage.320-384.ef"sv, "ed234194309ca20ea3bc9f3b73e60a8323180410"sv}, Entry{"idx/v1-storage.384-448.ef"sv, "afaff6ac187aa50d7058a091f2f7e6c873295027"sv}, Entry{"idx/v1-storage.448-512.ef"sv, "507ca266171dfd932788dfc656100c57163c6736"sv}, Entry{"idx/v1-storage.512-576.ef"sv, "4a2c7dc31c60ec5e726c69f9ec9d8ed1a084d0f8"sv}, Entry{"idx/v1-storage.576-640.ef"sv, "cad95caf676d49020cc2c72a4348f5cc5363e50c"sv}, Entry{"idx/v1-storage.64-128.ef"sv, "82b1d496e4c58a161de28787e46eee2a496348b8"sv}, Entry{"idx/v1-storage.640-704.ef"sv, "8ee0e31c03428c4966567c228196bc8aca8628d4"sv}, Entry{"idx/v1-storage.704-768.ef"sv, "24bd578c02ea2b71597387f2c208e61cc73a976b"sv}, Entry{"idx/v1-storage.768-832.ef"sv, "21756bb594c64520f509b82a1d971fd1e765ed43"sv}, Entry{"idx/v1-storage.832-896.ef"sv, "78cd330db5170045c41f7551c82287266d1c4f96"sv}, Entry{"idx/v1-storage.896-960.ef"sv, "b78241a7eb596202c8e7c84d1c1b3eeb7a53aa94"sv}, Entry{"idx/v1-storage.960-1024.ef"sv, "f9589f6911b951951278d41ed53e9416348ed61b"sv}, Entry{"idx/v1-tracesfrom.0-64.ef"sv, "a7b1d66c3b24321ba9107c4c24b6ff356772ba02"sv}, Entry{"idx/v1-tracesfrom.1024-1088.ef"sv, "6188a3d4cc15a202fc12acbaed99aae0e7c7bb5e"sv}, Entry{"idx/v1-tracesfrom.1088-1152.ef"sv, "32a533489ddbbf555b7c564ec4f66bae8d777626"sv}, Entry{"idx/v1-tracesfrom.1152-1216.ef"sv, "123bb10a7aac668ec59161ffce8bc1a78b7504b5"sv}, Entry{"idx/v1-tracesfrom.1216-1280.ef"sv, "cdc9b4e223a86d2e895c3a73e1135a52cc2b7de4"sv}, Entry{"idx/v1-tracesfrom.128-192.ef"sv, "ee973efb70a2b0319515975854aa1623cf86b153"sv}, Entry{"idx/v1-tracesfrom.1280-1344.ef"sv, "feb1542853445c72ca3a0594b9f144c0e7d006b8"sv}, Entry{"idx/v1-tracesfrom.1344-1408.ef"sv, "bd9843b32295cc1c4b86c3bf3dc1cf6ef73b03ea"sv}, Entry{"idx/v1-tracesfrom.1408-1472.ef"sv, "d504ada3a4e3ab439de515dfe654165f01927e8b"sv}, Entry{"idx/v1-tracesfrom.1472-1536.ef"sv, "050b1206b790dd2934233853e13d467986a24818"sv}, Entry{"idx/v1-tracesfrom.1536-1600.ef"sv, "bb8879a17a0d8540cf4329f949d23c4e707c61e4"sv}, Entry{"idx/v1-tracesfrom.1600-1664.ef"sv, "e625dcf1b020c787174b156bb87c235f8dc937c8"sv}, Entry{"idx/v1-tracesfrom.1664-1728.ef"sv, "941614ddb912f3436d89905823da240ba4ab278d"sv}, Entry{"idx/v1-tracesfrom.1728-1792.ef"sv, "77cdefb904ac7189f176eb53c1f75f35ecfbab31"sv}, Entry{"idx/v1-tracesfrom.1792-1856.ef"sv, "6fa424b1886dce7ce4c92226910de9a045674055"sv}, Entry{"idx/v1-tracesfrom.1856-1920.ef"sv, "3cb18422ba799a7e9a9141a29cb7431992e60756"sv}, Entry{"idx/v1-tracesfrom.192-256.ef"sv, "39e1d3e45c4a71bc2563684bf95a070b7e3ed81e"sv}, Entry{"idx/v1-tracesfrom.1920-1984.ef"sv, "4411d6c664a53cd20b50deb4f957df1378d9d083"sv}, Entry{"idx/v1-tracesfrom.1984-2048.ef"sv, "03b5eb38ddec0ec8c3931c68c69d50cf04809b55"sv}, Entry{"idx/v1-tracesfrom.2048-2112.ef"sv, "66f8b14226a47e553a70418fa00b2083738cd029"sv}, Entry{"idx/v1-tracesfrom.2112-2176.ef"sv, "c305bd70dbca17abcb00a9431de56bd2d376d169"sv}, Entry{"idx/v1-tracesfrom.2176-2240.ef"sv, "a8eee2ea3e7899b21f599b1d588e170d328121a7"sv}, Entry{"idx/v1-tracesfrom.2240-2304.ef"sv, "2ca5f732abcbe95cdd367c9823fe188f24d7d13d"sv}, Entry{"idx/v1-tracesfrom.2304-2368.ef"sv, "3b485516d2b01cc30109160021f3782bf2b0b4b7"sv}, Entry{"idx/v1-tracesfrom.2368-2432.ef"sv, "0f8b1d74bd8befc3bc8c2bbe549cadf86713df4b"sv}, Entry{"idx/v1-tracesfrom.2432-2496.ef"sv, "185e4c232c7145499f72ab7aacecc36ff3a090e5"sv}, Entry{"idx/v1-tracesfrom.2496-2560.ef"sv, "d499de874710bc08132a257344220b30a27c0d95"sv}, Entry{"idx/v1-tracesfrom.256-320.ef"sv, "5e2ad6c14f399913bebf3ab4db8c583d9ecb9f58"sv}, Entry{"idx/v1-tracesfrom.2560-2624.ef"sv, "2664bccc80e032cb369570dc41e8bbcc6b7f1049"sv}, Entry{"idx/v1-tracesfrom.2624-2688.ef"sv, "33a759fdbd766dd6548c030ec29110fcb6647357"sv}, Entry{"idx/v1-tracesfrom.2688-2752.ef"sv, "3239670b7f87f7447baab7997e9fdcf6b2d03f28"sv}, Entry{"idx/v1-tracesfrom.2752-2816.ef"sv, "3ebf6cc26fd16ec147dc3b98e7d3af8f8ffb8e2b"sv}, Entry{"idx/v1-tracesfrom.2816-2880.ef"sv, "24f995c8e0513b5d898ce6ca6299eabe26fb5a97"sv}, Entry{"idx/v1-tracesfrom.2880-2912.ef"sv, "0427b1da26a9e6fcd559db7e83680647bd00edc9"sv}, Entry{"idx/v1-tracesfrom.2912-2928.ef"sv, "5ae3ec4ee2a133dc5347ae06135bb10d52f7c7a9"sv}, Entry{"idx/v1-tracesfrom.2928-2936.ef"sv, "ea8da6e6f9ef9fb0d0d6dfc898ad2f0b449f4f43"sv}, Entry{"idx/v1-tracesfrom.2936-2940.ef"sv, "b10b6d04e5f606ddb066a314d19163239f946120"sv}, Entry{"idx/v1-tracesfrom.320-384.ef"sv, "08cd4885ff1f3a5284bd375b0ef0800b83b264cc"sv}, Entry{"idx/v1-tracesfrom.384-448.ef"sv, "1bd4d650ddde1cf0059cc302032ae858fba98599"sv}, Entry{"idx/v1-tracesfrom.448-512.ef"sv, "994295bec4baf619fa17f86e5f06b4c8d5b7c8d0"sv}, Entry{"idx/v1-tracesfrom.512-576.ef"sv, "ec7fddda33a3a6cdc1be4304fb9d3484492d6b71"sv}, Entry{"idx/v1-tracesfrom.576-640.ef"sv, "f0a28695cab0bba840a602c313909ebdb231c912"sv}, Entry{"idx/v1-tracesfrom.64-128.ef"sv, "fe758eb5370aa0dae8f757ffcded37ad4ad62edb"sv}, Entry{"idx/v1-tracesfrom.640-704.ef"sv, "a32684e521fc11b6d2661b66c195136e71ecfb59"sv}, Entry{"idx/v1-tracesfrom.704-768.ef"sv, "eaf1bbb4e80692c6af312b670edf4a9fb4bf4588"sv}, Entry{"idx/v1-tracesfrom.768-832.ef"sv, "f79f58c3e5a34d67a4144060fafc5a0b77e10ce5"sv}, Entry{"idx/v1-tracesfrom.832-896.ef"sv, "3abb3601866c1479d7a054933ca37e6ac098e5fa"sv}, Entry{"idx/v1-tracesfrom.896-960.ef"sv, "0263e101ee7ca56ae0a96a6787ca9b4b5aae0e89"sv}, Entry{"idx/v1-tracesfrom.960-1024.ef"sv, "4c34623c08bc9288666b9f315f8c48602b056c06"sv}, Entry{"idx/v1-tracesto.0-64.ef"sv, "1a12e8443c84de25301a777c60451dd9df3b0d61"sv}, Entry{"idx/v1-tracesto.1024-1088.ef"sv, "ce5f6f46ee518f432d08f99730260b65150f3fe3"sv}, Entry{"idx/v1-tracesto.1088-1152.ef"sv, "6d1c15b304ec25a5f13c183580bf665a9a60e829"sv}, Entry{"idx/v1-tracesto.1152-1216.ef"sv, "02c08ebd97d8c04955e8fc93556f6bdc20bfb5e2"sv}, Entry{"idx/v1-tracesto.1216-1280.ef"sv, "c2b4c79a5201e48b88374995a0c2187b1a05d071"sv}, Entry{"idx/v1-tracesto.128-192.ef"sv, "5114d28e761985f42efb3772f503efd8b5117e1d"sv}, Entry{"idx/v1-tracesto.1280-1344.ef"sv, "30c880d89950d998fc00661e259cb4b52ddd41c2"sv}, Entry{"idx/v1-tracesto.1344-1408.ef"sv, "432715d76f0c2719362d3857efe70e8c7beb7b4a"sv}, Entry{"idx/v1-tracesto.1408-1472.ef"sv, "2dfc790581f7a9693c95239d6748d36984c3c5dd"sv}, Entry{"idx/v1-tracesto.1472-1536.ef"sv, "58d0a305beeddcdce3e7d26f747dfc67c119a53b"sv}, Entry{"idx/v1-tracesto.1536-1600.ef"sv, "4f5b1b176fda93741347810e514cd2c709a410c9"sv}, Entry{"idx/v1-tracesto.1600-1664.ef"sv, "f6dc0ff11dfce19f6d6c0031e9ca99b3104637fc"sv}, Entry{"idx/v1-tracesto.1664-1728.ef"sv, "63253d63dcc477a5b849b5621deac3306bcd4158"sv}, Entry{"idx/v1-tracesto.1728-1792.ef"sv, "97c4097af3b6e37d5641f9bf6e13dfa744c898ba"sv}, Entry{"idx/v1-tracesto.1792-1856.ef"sv, "4c3ad622050fdce5b29d27e62fc8d85c8d66aa0f"sv}, Entry{"idx/v1-tracesto.1856-1920.ef"sv, "f64ce2ddd8df878e97e5653379d808745b1b07e3"sv}, Entry{"idx/v1-tracesto.192-256.ef"sv, "c1d555050d69ca3bdec7763b0e1a2ee365091675"sv}, Entry{"idx/v1-tracesto.1920-1984.ef"sv, "ac18e20a7c3659c3f95d91636d2eacd2364f107a"sv}, Entry{"idx/v1-tracesto.1984-2048.ef"sv, "37a57293917ae334dfbd80611014ac8ccb5742c2"sv}, Entry{"idx/v1-tracesto.2048-2112.ef"sv, "f6e8300b0243c3b378522dc3fcb7d4c779e0a6aa"sv}, Entry{"idx/v1-tracesto.2112-2176.ef"sv, "023f7fd4bdb2a72ad6c925248442127f482b0659"sv}, Entry{"idx/v1-tracesto.2176-2240.ef"sv, "fe4510f20fb65349400f295102539b07748f744a"sv}, Entry{"idx/v1-tracesto.2240-2304.ef"sv, "6c31aa05c83180d9ec7d078dffbf560ec9d3d91c"sv}, Entry{"idx/v1-tracesto.2304-2368.ef"sv, "e33943119a5499e6a334e264809d0398543f06d2"sv}, Entry{"idx/v1-tracesto.2368-2432.ef"sv, "df23077c951f2142729c68e8c4fddf5138deba95"sv}, Entry{"idx/v1-tracesto.2432-2496.ef"sv, "3d60818da1a5dc0e39e9915e59127015a99f43f6"sv}, Entry{"idx/v1-tracesto.2496-2560.ef"sv, "673c49e4c5bfafe7d48c800b1e6a6672c31e7853"sv}, Entry{"idx/v1-tracesto.256-320.ef"sv, "a210156377b98b75fe1534130f0c26727212efc2"sv}, Entry{"idx/v1-tracesto.2560-2624.ef"sv, "2fa5b2e78b5c5a27428cfa42df856a81b5d863d6"sv}, Entry{"idx/v1-tracesto.2624-2688.ef"sv, "d972a29051e2f66f279b4075b0694e80a76df832"sv}, Entry{"idx/v1-tracesto.2688-2752.ef"sv, "536d99c18bec73777140c2facbf0274c2812032a"sv}, Entry{"idx/v1-tracesto.2752-2816.ef"sv, "4af6e3aeaf6fe7f8c3f9373a746d4a2bf720324c"sv}, Entry{"idx/v1-tracesto.2816-2880.ef"sv, "6ad7dfb2f58b26faac909838e239ecef7235969a"sv}, Entry{"idx/v1-tracesto.2880-2912.ef"sv, "5918193fc72b32993ac234475b36387c01d502fb"sv}, Entry{"idx/v1-tracesto.2912-2928.ef"sv, "fc7f7a4d570f7b1105efbe0c50e221943ed3bce2"sv}, Entry{"idx/v1-tracesto.2928-2936.ef"sv, "dbeb7cb8cf15a13e54ba78e319131cc21ce3ceab"sv}, Entry{"idx/v1-tracesto.2936-2940.ef"sv, "d4693587e34fbeffa87477dfb2f7732bb035c15b"sv}, Entry{"idx/v1-tracesto.320-384.ef"sv, "35caede16cab4db615de2cc015e8ec5248190ae9"sv}, Entry{"idx/v1-tracesto.384-448.ef"sv, "ff62c415cb67510808d27eb082b2427aa17d42d0"sv}, Entry{"idx/v1-tracesto.448-512.ef"sv, "d2f1739545cb3db839698555955218a0b63503c8"sv}, Entry{"idx/v1-tracesto.512-576.ef"sv, "e2010d8af89f71cd020a9dbfe4e1439f7517efa6"sv}, Entry{"idx/v1-tracesto.576-640.ef"sv, "be45e56073c0697777d34f25055bc6049ed8338e"sv}, Entry{"idx/v1-tracesto.64-128.ef"sv, "5d17c03fa9a9c5e023aa6087fa86185058921e66"sv}, Entry{"idx/v1-tracesto.640-704.ef"sv, "6c876cb727a76770bcf9b94313cf603ffc60dcb1"sv}, Entry{"idx/v1-tracesto.704-768.ef"sv, "33d36547c79f55deecf6fe2fe02fa2e2ce2e7ca6"sv}, Entry{"idx/v1-tracesto.768-832.ef"sv, "40e7b699ca643d73d29ecc995f168e6a6bf06b26"sv}, Entry{"idx/v1-tracesto.832-896.ef"sv, "01a9e501d06d5225ee544c9f51159d15b23cba13"sv}, Entry{"idx/v1-tracesto.896-960.ef"sv, "2693a31fc7661f1e01240787a693e9c622062b90"sv}, Entry{"idx/v1-tracesto.960-1024.ef"sv, "1abb54c1cb89fb444a1066e688f78d358dbea5df"sv}, Entry{"manifest.txt"sv, "ef209051f75007c0017fb9fc4d0a881816b80555"sv}, Entry{"salt-blocks.txt"sv, "eb3c88866986745db8052845882e9dae296cb36c"sv}, Entry{"salt-state.txt"sv, "0113ec56c7c0d72783dbb5738becffa9c4c43d69"sv}, Entry{"v1-000000-000500-bodies.idx"sv, "fd52e4fc391aacbaaa07779562c3d0c6a3d4d90f"sv}, Entry{"v1-000000-000500-bodies.seg"sv, "b781a72f47f1b0777bdb97a2c43000799e51eee5"sv}, Entry{"v1-000000-000500-borevents.idx"sv, "c27c276d006498024ce150858bbbf82c7ce577e1"sv}, Entry{"v1-000000-000500-borevents.seg"sv, "b4fc88cc529cbad18b2de522d868ea26fac0212c"sv}, Entry{"v1-000000-000500-borspans.idx"sv, "e44f1f1965065b8d740b5080d6d6d1eaa2797189"sv}, Entry{"v1-000000-000500-borspans.seg"sv, "a055796bbc4ed8065d29ad504234a0b339ef07a3"sv}, Entry{"v1-000000-000500-headers.idx"sv, "c504b93e3c61b1e51f7054971ef16e2cc61fc3ad"sv}, Entry{"v1-000000-000500-headers.seg"sv, "d60f9ea8dd7c454d72021ea70c2c391eb05aa400"sv}, Entry{"v1-000000-000500-transactions-to-block.idx"sv, "57e1508131add66f913e2706764851c959d35092"sv}, Entry{"v1-000000-000500-transactions.idx"sv, "79a6dc48d68658794a52c27e1e6f52cac8cd3ea8"sv}, Entry{"v1-000000-000500-transactions.seg"sv, "f0e539ba7c9b99f3bffd21563faa865eba859177"sv}, Entry{"v1-000500-001000-bodies.idx"sv, "a2c3f986faa6a124358bb516336e283979a5f25b"sv}, Entry{"v1-000500-001000-bodies.seg"sv, "30347acc350001aefd166b92700b4ef2299eb984"sv}, Entry{"v1-000500-001000-borevents.idx"sv, "7b1f23bad0e411943be7a0fd1a55792b8132886b"sv}, Entry{"v1-000500-001000-borevents.seg"sv, "a43cb25edb3869a8c216349ccc51a73ec1edba5b"sv}, Entry{"v1-000500-001000-borspans.idx"sv, "239d3e5a13275638afa5287e27ad6ceb7d32c8eb"sv}, Entry{"v1-000500-001000-borspans.seg"sv, "a25591ba4a8d2460489c6ff66a16fd7fdaab9c5c"sv}, Entry{"v1-000500-001000-headers.idx"sv, "4bb5f3948536d0bc7c45cbc3527c32e595fd0755"sv}, Entry{"v1-000500-001000-headers.seg"sv, "d2f65a7c8e24650557d4a3dd6b0e2f4a426351a4"sv}, Entry{"v1-000500-001000-transactions-to-block.idx"sv, "1285c9e314cdadbb7c28296b2453d6e99f85263a"sv}, Entry{"v1-000500-001000-transactions.idx"sv, "963b6dfe0eb62b74b5464e0cbcf3086bd693c727"sv}, Entry{"v1-000500-001000-transactions.seg"sv, "c8460cf751c8c695f3b678c96b59dd93d83a6e7c"sv}, Entry{"v1-001000-001500-bodies.idx"sv, "1519c8e85bbf844e9247b81a31be39961f48c2d0"sv}, Entry{"v1-001000-001500-bodies.seg"sv, "d66b6894a4fb84ff9853615deb363068e89146a7"sv}, Entry{"v1-001000-001500-borevents.idx"sv, "5c4796653985252654c3c917333c737f59eeef8b"sv}, Entry{"v1-001000-001500-borevents.seg"sv, "1c5714d582787afdc1aa52f723b75c9fda97a1d3"sv}, Entry{"v1-001000-001500-borspans.idx"sv, "2015bdd37c229fa6ca05ef33c7824873d20e579f"sv}, Entry{"v1-001000-001500-borspans.seg"sv, "113249217dd18d15a2c2b19859022e60cb564daf"sv}, Entry{"v1-001000-001500-headers.idx"sv, "84116ef9bfa8981b07fc7ed17bddd25d5f316b14"sv}, Entry{"v1-001000-001500-headers.seg"sv, "f8e9752b2ddfe46f404457a65ecf21f8f00b42bf"sv}, Entry{"v1-001000-001500-transactions-to-block.idx"sv, "2d15c1d08a2f3fbf7def645275d100dab55c0944"sv}, Entry{"v1-001000-001500-transactions.idx"sv, "826d27b51132ffab32c39dba7cc5cd310b578c33"sv}, Entry{"v1-001000-001500-transactions.seg"sv, "76b4fa35c6805dbb5be2eb6ed74b2576ce26d09a"sv}, Entry{"v1-001500-002000-bodies.idx"sv, "be939b1d23ee025c934d3b8c109f0b11ccbd3ac4"sv}, Entry{"v1-001500-002000-bodies.seg"sv, "d953717e8bd3f44bf09da955d9152c7e6e503d07"sv}, Entry{"v1-001500-002000-borevents.idx"sv, "50e37c6ecb99911a802804c3e57598b398bfa6d4"sv}, Entry{"v1-001500-002000-borevents.seg"sv, "766374851b068c37764a75ff376dd731ae808d29"sv}, Entry{"v1-001500-002000-borspans.idx"sv, "927939f41eb801d7d112a892220e1d1ae83d4160"sv}, Entry{"v1-001500-002000-borspans.seg"sv, "fd6b1aea94421d25a29c491674bc28a71d9448e2"sv}, Entry{"v1-001500-002000-headers.idx"sv, "7fecd10e1476cbb33bddf5e32f9d9667c17d900d"sv}, Entry{"v1-001500-002000-headers.seg"sv, "60307e9f95c10905a010e344193d8462c85bf204"sv}, Entry{"v1-001500-002000-transactions-to-block.idx"sv, "ebe0f7f73498acf9e7b27e58efc5c53495f42e8f"sv}, Entry{"v1-001500-002000-transactions.idx"sv, "c1175e22525dd486fc67240be0293f9a9ea2b4dc"sv}, Entry{"v1-001500-002000-transactions.seg"sv, "2f074aea66fd57da75f3ba16279491e9e3bed5e3"sv}, Entry{"v1-002000-002500-bodies.idx"sv, "93aeadafaf0afdcd291fe63f6bd7b66c8e7ca484"sv}, Entry{"v1-002000-002500-bodies.seg"sv, "fbb3f479670bb30b788dbb115f6b208cf2d667be"sv}, Entry{"v1-002000-002500-borevents.idx"sv, "a121554634200cc31a9ed828b911fc367f907a1c"sv}, Entry{"v1-002000-002500-borevents.seg"sv, "dc219d794d141750d883af229d5ea01cb33f0f82"sv}, Entry{"v1-002000-002500-borspans.idx"sv, "5ab4864da85afa18c36c59def001248d0b19a4c3"sv}, Entry{"v1-002000-002500-borspans.seg"sv, "fc0b1f718bb49a2fd97dee820783fd56a0d0b207"sv}, Entry{"v1-002000-002500-headers.idx"sv, "044438ad2dd2a0e7b8cdb53a4355ccac313d01c7"sv}, Entry{"v1-002000-002500-headers.seg"sv, "c538276047055bd6cfe289b14d4ae0411bd45da1"sv}, Entry{"v1-002000-002500-transactions-to-block.idx"sv, "b5630de4b2bcf8855b1ad287cea86699f16b8ccb"sv}, Entry{"v1-002000-002500-transactions.idx"sv, "7ec8af1f464d55cea0e96a0d0c7b7e943c3b732e"sv}, Entry{"v1-002000-002500-transactions.seg"sv, "7b1f54ab59425d6ba37c7c2a72e8a32078bb6e3d"sv}, Entry{"v1-002500-003000-bodies.idx"sv, "10bad4e04016d43fb139b05098ccf67b55038d5c"sv}, Entry{"v1-002500-003000-bodies.seg"sv, "92dae5d2556a8b7e2b59512fcb665943ad2c7bf0"sv}, Entry{"v1-002500-003000-borevents.idx"sv, "020038e78adb3001b1c7f589d6ba27be22185ffb"sv}, Entry{"v1-002500-003000-borevents.seg"sv, "9ac4c2ed561b48594daf8b61bc27e0e489d866e3"sv}, Entry{"v1-002500-003000-borspans.idx"sv, "90726b3c0c2bac668212b8fadd0235dad93939e7"sv}, Entry{"v1-002500-003000-borspans.seg"sv, "835832aa2106db09ed98df84f7141c2151af8f24"sv}, Entry{"v1-002500-003000-headers.idx"sv, "83723533b91874d92b04636e808cc5b66def6fdf"sv}, Entry{"v1-002500-003000-headers.seg"sv, "f756d162d2613bdbd733464b31e1ae49399c4530"sv}, Entry{"v1-002500-003000-transactions-to-block.idx"sv, "2d0dacc92cd193a05bd600fcd35d0ccb54976134"sv}, Entry{"v1-002500-003000-transactions.idx"sv, "268c9bdf49b27f08ac369e6c72fcdf42218a525f"sv}, Entry{"v1-002500-003000-transactions.seg"sv, "cc9fb351f3b2b2403f885987c5db7df92f72d848"sv}, Entry{"v1-003000-003500-bodies.idx"sv, "9491aa4301a43829c607f3711a18563ea26a0acd"sv}, Entry{"v1-003000-003500-bodies.seg"sv, "156afac0fed2a5b47f887be044467f2f4ed03a45"sv}, Entry{"v1-003000-003500-borevents.idx"sv, "e7addfbfafa47a438292a6e7a445cd529b9e50fe"sv}, Entry{"v1-003000-003500-borevents.seg"sv, "97c950649d39e59a31e3a3b4ec1ee11ea773f82a"sv}, Entry{"v1-003000-003500-borspans.idx"sv, "84e5acaa672fd26f7b77896abdc95ed5384bb6ae"sv}, Entry{"v1-003000-003500-borspans.seg"sv, "9db4367aca83626673d96c49d0626833751e1c2a"sv}, Entry{"v1-003000-003500-headers.idx"sv, "f84648e07e70797601daf3a408dacea33200124f"sv}, Entry{"v1-003000-003500-headers.seg"sv, "662b7a837cfa231a1cb7f7ff9c9e08fab78c87a5"sv}, Entry{"v1-003000-003500-transactions-to-block.idx"sv, "bba8b0f654fa24a88bea11d25049d41bf939637a"sv}, Entry{"v1-003000-003500-transactions.idx"sv, "52201ddaa7aaca495be4b790a6a1aeabe1a5f975"sv}, Entry{"v1-003000-003500-transactions.seg"sv, "65807a0aafb08391480ff8f2f8bc42de0fd1d39e"sv}, Entry{"v1-003500-004000-bodies.idx"sv, "785afe48502daea2fa01112056a6c91d2b9ac24f"sv}, Entry{"v1-003500-004000-bodies.seg"sv, "0f8175eeb07c9c041268826b8387539fc9eb0bdb"sv}, Entry{"v1-003500-004000-borevents.idx"sv, "d391a35d3b715cd5d380fcb930553042504d1cff"sv}, Entry{"v1-003500-004000-borevents.seg"sv, "1c25f2d2072daf969493addf33d48254a5d4902a"sv}, Entry{"v1-003500-004000-borspans.idx"sv, "d1ea8b165fa3529a539d3f33025495eaa039c92e"sv}, Entry{"v1-003500-004000-borspans.seg"sv, "017f3bca75e337459864da5b31b3fef04a9d4824"sv}, Entry{"v1-003500-004000-headers.idx"sv, "106d8fd794c09833379dcdf60b40fdaf9f4e4cd3"sv}, Entry{"v1-003500-004000-headers.seg"sv, "3743642a273df954a1673600ac8fbd3233cc4869"sv}, Entry{"v1-003500-004000-transactions-to-block.idx"sv, "d3ade30e8128c26be00c3c3b3e4c125e15d52bd9"sv}, Entry{"v1-003500-004000-transactions.idx"sv, "a8160aac771e3ff5219a17e20bd66f5ae3490601"sv}, Entry{"v1-003500-004000-transactions.seg"sv, "6e40c528f737513f08e53c76d8ab38c8fe7959cc"sv}, Entry{"v1-004000-004500-bodies.idx"sv, "dfb549ca6200829a6fb9712b75561170e3366fd9"sv}, Entry{"v1-004000-004500-bodies.seg"sv, "9d80b15818ea53d55f464fff2909d0cde876dec3"sv}, Entry{"v1-004000-004500-borevents.idx"sv, "b5c2115f34f72471992e8c2aea2f9e531b247c22"sv}, Entry{"v1-004000-004500-borevents.seg"sv, "6ea973a214dfb03e8f9512df544d6022efde895b"sv}, Entry{"v1-004000-004500-borspans.idx"sv, "028f8605ca52cf5586823f260bf0fedfc9d05b03"sv}, Entry{"v1-004000-004500-borspans.seg"sv, "c60aa43cfc689cdfebdfa6d2edcce26d1963dad6"sv}, Entry{"v1-004000-004500-headers.idx"sv, "9f2c3e6ea8311f431fa0be4c87666584fee17664"sv}, Entry{"v1-004000-004500-headers.seg"sv, "15427217785843c314d34d21e1192a81df9ce6de"sv}, Entry{"v1-004000-004500-transactions-to-block.idx"sv, "a5aa67741cecbd9c45c965f2075a4fe8ccbc1213"sv}, Entry{"v1-004000-004500-transactions.idx"sv, "e71a55bc349613c0e09b563d4efe58c44aeaca7c"sv}, Entry{"v1-004000-004500-transactions.seg"sv, "8089d33222b02c46a5d8059e6be01b25b8c75af3"sv}, Entry{"v1-004500-005000-bodies.idx"sv, "62754409a0ac316fe373cbc7a21355d4423b4fd9"sv}, Entry{"v1-004500-005000-bodies.seg"sv, "6573054f5a287bc75fdf94bb5eb43365369375d1"sv}, Entry{"v1-004500-005000-borevents.idx"sv, "1684f3bb17c8c38569359f54cd9f50db5d43b2a8"sv}, Entry{"v1-004500-005000-borevents.seg"sv, "76824d1a6674906f15f2135705964a893c60447f"sv}, Entry{"v1-004500-005000-borspans.idx"sv, "424f4b826e4f40747d2df3545362c5ff2fbcbd1b"sv}, Entry{"v1-004500-005000-borspans.seg"sv, "bae076575555f9ec8a332803d6c300dbc43cb63a"sv}, Entry{"v1-004500-005000-headers.idx"sv, "8f6d616d6a9a54ceec7120810e5be161a5f964d5"sv}, Entry{"v1-004500-005000-headers.seg"sv, "bd2bfa2b0d8a85a08983bbbdfa64f85a8d76ec69"sv}, Entry{"v1-004500-005000-transactions-to-block.idx"sv, "66a7009c91373008e464c87f10c85436627898bc"sv}, Entry{"v1-004500-005000-transactions.idx"sv, "8e14c15892c611785395e0824762b5551cfc5726"sv}, Entry{"v1-004500-005000-transactions.seg"sv, "43f375601a55e80ce77e0519e5ad21dcf6638ce4"sv}, Entry{"v1-005000-005500-bodies.idx"sv, "971672dbf295718d88ca3237f57cb523162d94ba"sv}, Entry{"v1-005000-005500-bodies.seg"sv, "a12014de41455fd28514f85a14abaf9e0bd1d80c"sv}, Entry{"v1-005000-005500-borevents.idx"sv, "fde5fb71331f636a0558550393647271f7ee0585"sv}, Entry{"v1-005000-005500-borevents.seg"sv, "a68bf2057a2d98b3605c12aeb5916c0fce4da88a"sv}, Entry{"v1-005000-005500-borspans.idx"sv, "6596748913d1c79d76fcedc724781dc5a6bf474b"sv}, Entry{"v1-005000-005500-borspans.seg"sv, "62715616cac820dea24d0a67fd66a9ac6d6a25c6"sv}, Entry{"v1-005000-005500-headers.idx"sv, "10164d73ad666ff50f095fc9a2da8f846a2028f5"sv}, Entry{"v1-005000-005500-headers.seg"sv, "de1eca7b7804fca5cb1bcc7d39205e63025ee9e9"sv}, Entry{"v1-005000-005500-transactions-to-block.idx"sv, "ad94352a6308287d9e8a0ff9f955e94bf6cae086"sv}, Entry{"v1-005000-005500-transactions.idx"sv, "4aadaac37f9c008855e4881f79f1f976e4dd4ed3"sv}, Entry{"v1-005000-005500-transactions.seg"sv, "fbed644f94faff1d22a185a7f718902f3ea59519"sv}, Entry{"v1-005500-006000-bodies.idx"sv, "6d52355ec4dbbbea0802a3d40b52dea12c9d3999"sv}, Entry{"v1-005500-006000-bodies.seg"sv, "221dcec5f4c83bb4d6e115bc3d54c518fbc9ab54"sv}, Entry{"v1-005500-006000-borevents.idx"sv, "5cc5d3ac2a83639ffb39cfc9d37cd406b11fdd33"sv}, Entry{"v1-005500-006000-borevents.seg"sv, "bae597bd85d9af6c459863be84dcdca5c9871b82"sv}, Entry{"v1-005500-006000-borspans.idx"sv, "35afeebdf530c82c3e26827de86b47490981ac9e"sv}, Entry{"v1-005500-006000-borspans.seg"sv, "226cb47c464bf1fc6f661b7688c9735a7bcd7d3b"sv}, Entry{"v1-005500-006000-headers.idx"sv, "6f9713160dcf939790f23be1e7ecdac1e4a743e2"sv}, Entry{"v1-005500-006000-headers.seg"sv, "7164509cf731454ca69667c1c525e49e10c34202"sv}, Entry{"v1-005500-006000-transactions-to-block.idx"sv, "98db3e1475b3a0ded96e643a1a968d099b624eb9"sv}, Entry{"v1-005500-006000-transactions.idx"sv, "5ab7c9a60f7a34513b4930a827e4640c3c4919c8"sv}, Entry{"v1-005500-006000-transactions.seg"sv, "ee2480ea727d524929b3efb6a9dede583073d23a"sv}, Entry{"v1-006000-006500-bodies.idx"sv, "fd9b1307f888246b03905b9725ddd3403131d030"sv}, Entry{"v1-006000-006500-bodies.seg"sv, "7ba36f7425a57b30b8f2ab07287b8d98b14e91d9"sv}, Entry{"v1-006000-006500-borevents.idx"sv, "98bdf537b59ed71da975218fc7979bf8cad90372"sv}, Entry{"v1-006000-006500-borevents.seg"sv, "c23ea21d8b7a1ab3392733ecda55e1eef6227bd2"sv}, Entry{"v1-006000-006500-borspans.idx"sv, "f1ef26e8465d38334afdef441522f0724847b743"sv}, Entry{"v1-006000-006500-borspans.seg"sv, "bc27477c987c1914b5110e18a6ce3dde02331407"sv}, Entry{"v1-006000-006500-headers.idx"sv, "89c4c5d47f784a6d785b432f820b44e7099660a6"sv}, Entry{"v1-006000-006500-headers.seg"sv, "7ea4589bc0a6a4392022d8b80bfc2b7e604d8061"sv}, Entry{"v1-006000-006500-transactions-to-block.idx"sv, "f883ca30e0e9b4a73235c6f63f7e647a32860e38"sv}, Entry{"v1-006000-006500-transactions.idx"sv, "e6158a7139a5ddf260fe492ae9a66167ddc598a7"sv}, Entry{"v1-006000-006500-transactions.seg"sv, "547e4ec9349d01427165e0d8dc982f78d4cd2d56"sv}, Entry{"v1-006500-007000-bodies.idx"sv, "8d11773aa8fa32e33a68a538807ef9e48c548dfe"sv}, Entry{"v1-006500-007000-bodies.seg"sv, "fef860117f982ebc674695b608d560ededeb1a41"sv}, Entry{"v1-006500-007000-borevents.idx"sv, "a5c9aa4c1ed6c4dba0a4c0af4af227ff9a377b1c"sv}, Entry{"v1-006500-007000-borevents.seg"sv, "424d613c036f3565447dea712d969cd47247d58d"sv}, Entry{"v1-006500-007000-borspans.idx"sv, "014adcc0caba11072865cc820de980ccf6e77eec"sv}, Entry{"v1-006500-007000-borspans.seg"sv, "698b14a9ecbbca93e4c72205238d1c3c2cde0159"sv}, Entry{"v1-006500-007000-headers.idx"sv, "67f95a8e00ff2702e8cd0acf67317a8e96f3a33e"sv}, Entry{"v1-006500-007000-headers.seg"sv, "b9e37e290dc3d7cb55ff6c1f9868acbdc64135ad"sv}, Entry{"v1-006500-007000-transactions-to-block.idx"sv, "a097e0e891c5143ce213a84de04c931908cdf131"sv}, Entry{"v1-006500-007000-transactions.idx"sv, "154c546e60f998378fb7a14c9c364b61a149a0ae"sv}, Entry{"v1-006500-007000-transactions.seg"sv, "f27b4b2f6d97b587acf388e687e9cbc75d0bc070"sv}, Entry{"v1-007000-007500-bodies.idx"sv, "e3570ecb0b3aa76bd0f22a014ecdfd88997d51a8"sv}, Entry{"v1-007000-007500-bodies.seg"sv, "3cb022fd53b8256d920b149996e189595d496b8d"sv}, Entry{"v1-007000-007500-borevents.idx"sv, "da9346fd605d75a822470956e0839f0db5cb8119"sv}, Entry{"v1-007000-007500-borevents.seg"sv, "1263c67e67ecdcaad0aa43cedb5ee5673fdbda5c"sv}, Entry{"v1-007000-007500-borspans.idx"sv, "9c82ad3f03ccae6331c8a31b4143481bddde4d65"sv}, Entry{"v1-007000-007500-borspans.seg"sv, "54345674a7517d5a49b7bdf80921ffe3d266f1a7"sv}, Entry{"v1-007000-007500-headers.idx"sv, "8e472d70fad66ac38465d0d36102e57a88643d1e"sv}, Entry{"v1-007000-007500-headers.seg"sv, "29351686cc519239cd91d4ce0a93fa135827ef81"sv}, Entry{"v1-007000-007500-transactions-to-block.idx"sv, "159307efbd67bfe2364d9769aa22224dffc8d53e"sv}, Entry{"v1-007000-007500-transactions.idx"sv, "8fec1e1b4612c5c57fd9a981d0a3b681809d132e"sv}, Entry{"v1-007000-007500-transactions.seg"sv, "f9e2123ed43231336b7425467309625d757380da"sv}, Entry{"v1-007500-008000-bodies.idx"sv, "52f68f6c1d694547e52583f34e9e3172afcf12f5"sv}, Entry{"v1-007500-008000-bodies.seg"sv, "4d7c3a21277a73df9a2e8da1ce877fd1870f15a3"sv}, Entry{"v1-007500-008000-borevents.idx"sv, "1612f30d3eab3479f072cf09fa23750e477f6a45"sv}, Entry{"v1-007500-008000-borevents.seg"sv, "c9fc23a0da8a5dab9e68218a6019174d1fa0e538"sv}, Entry{"v1-007500-008000-borspans.idx"sv, "f8edb65ed583b8478e69eafe4a5f9d831bc66539"sv}, Entry{"v1-007500-008000-borspans.seg"sv, "35dde4bd651182e80be5f59e93f48c82e6f81707"sv}, Entry{"v1-007500-008000-headers.idx"sv, "255dfd1eaeff18a4f6f5d28653a7f46de4bce452"sv}, Entry{"v1-007500-008000-headers.seg"sv, "bf09285db95803bdaa9cfc50e2d5563037e32b6a"sv}, Entry{"v1-007500-008000-transactions-to-block.idx"sv, "7ac287fc04880048ba38218c417f829a1c7c7edb"sv}, Entry{"v1-007500-008000-transactions.idx"sv, "c6728e6e1bb32eaf83d1e9601b10ec0fd9cd82d0"sv}, Entry{"v1-007500-008000-transactions.seg"sv, "1cb6d741ba82fcba7719e14420d1068ac2ffa017"sv}, Entry{"v1-008000-008500-bodies.idx"sv, "9e1db4febc164f8f5df2920c09b457a8284c7591"sv}, Entry{"v1-008000-008500-bodies.seg"sv, "81104b63769d8373b7cce069532e034eb1b8be4e"sv}, Entry{"v1-008000-008500-borevents.idx"sv, "d996fd43bcd10386ccacce5601a2940591c8ae8b"sv}, Entry{"v1-008000-008500-borevents.seg"sv, "32dd954a1b83ab6567df633f3f9a57a0bd731bd1"sv}, Entry{"v1-008000-008500-borspans.idx"sv, "757281eb1eb4dc467ee5b29e89ed73f4c5681012"sv}, Entry{"v1-008000-008500-borspans.seg"sv, "1f8f981ecbe60ca222eff47ae684cc843a83fab9"sv}, Entry{"v1-008000-008500-headers.idx"sv, "3d54eb5e0b9a2bff8380585cdd0d37111dfde296"sv}, Entry{"v1-008000-008500-headers.seg"sv, "27d0e2666fa7a5091ad42c1ff70713db5debbfd1"sv}, Entry{"v1-008000-008500-transactions-to-block.idx"sv, "b34ad82ed8db266da49b57f86bb23d87366c803b"sv}, Entry{"v1-008000-008500-transactions.idx"sv, "0f81011107781c9531919456a5e8c827bfa85386"sv}, Entry{"v1-008000-008500-transactions.seg"sv, "448920f0df04d70749d3e1e7ea88e7fa9de29ab8"sv}, Entry{"v1-008500-009000-bodies.idx"sv, "1f7896a48005d9a7b6b29eea283861e22f679b6a"sv}, Entry{"v1-008500-009000-bodies.seg"sv, "5b7cf152163c117b9b2264f111ca120dc200cccc"sv}, Entry{"v1-008500-009000-borevents.idx"sv, "e7729830bc86335922b266bf2a7bae7fa03f6fe1"sv}, Entry{"v1-008500-009000-borevents.seg"sv, "a2b99488a37eefcb79e65306f17db46ce16480da"sv}, Entry{"v1-008500-009000-borspans.idx"sv, "68bb069d6665262d6eef13f1035df24203232127"sv}, Entry{"v1-008500-009000-borspans.seg"sv, "6bc90bb9d569b878fe41bdb10ff1f7c44a71e1a5"sv}, Entry{"v1-008500-009000-headers.idx"sv, "b6a6c1c6f0744bc149380fec78e94afb63e33dab"sv}, Entry{"v1-008500-009000-headers.seg"sv, "5e89149c261de34a2cee70af4e44ac69c91b49a4"sv}, Entry{"v1-008500-009000-transactions-to-block.idx"sv, "3063e9461a8aecf9f6718cc0413028b3adff5dcb"sv}, Entry{"v1-008500-009000-transactions.idx"sv, "d950aa31d32620e277fa261bdaed99d017cf95a7"sv}, Entry{"v1-008500-009000-transactions.seg"sv, "b0f86dd14eb045e6b300443131f4f1700deb1cbb"sv}, Entry{"v1-009000-009500-bodies.idx"sv, "5be20474002703d19ad1121c2dd52d1265db7318"sv}, Entry{"v1-009000-009500-bodies.seg"sv, "785fdb9c19e3af96de0bd99cf0d96c8056ea4c52"sv}, Entry{"v1-009000-009500-borevents.idx"sv, "103cd0dbcd3c8ab1838c3c7f5b8547d304dbd06a"sv}, Entry{"v1-009000-009500-borevents.seg"sv, "33432badb05c32f187b7fd72a150d6fa3edb82ba"sv}, Entry{"v1-009000-009500-borspans.idx"sv, "bf90bca636d61974ad6efe768852011ae21a0e89"sv}, Entry{"v1-009000-009500-borspans.seg"sv, "dcd263739a4c42e7f75a8a2404fc5a9c4bba80c1"sv}, Entry{"v1-009000-009500-headers.idx"sv, "239ab26556cdb766d14f779d8f13b403b913df39"sv}, Entry{"v1-009000-009500-headers.seg"sv, "2df5e8fac27b5f905c63baead900e8565d71f6dd"sv}, Entry{"v1-009000-009500-transactions-to-block.idx"sv, "669c6084d25d14b496c6cbb32aede4a791192655"sv}, Entry{"v1-009000-009500-transactions.idx"sv, "180bd132235b64c824a701c3b31137e69ee1c443"sv}, Entry{"v1-009000-009500-transactions.seg"sv, "c9a5fb5e17a97547667dff3317a0166b0c36788a"sv}, Entry{"v1-009500-010000-bodies.idx"sv, "c32b65834a269eb9bc9bf60d7658bd0e961bc5f6"sv}, Entry{"v1-009500-010000-bodies.seg"sv, "454b57faf271606d82a282602f126568f5af19c8"sv}, Entry{"v1-009500-010000-borevents.idx"sv, "755336d9bd27fb64857b200a69369a47c664eba5"sv}, Entry{"v1-009500-010000-borevents.seg"sv, "59e8581ebef5419d9e5acfc39c14665c67e6c00b"sv}, Entry{"v1-009500-010000-borspans.idx"sv, "345bda7b5f4a6518d339839ae3a45980aae74b7a"sv}, Entry{"v1-009500-010000-borspans.seg"sv, "fbc2b791a151a232cbcf61d3850ef2d5d91d1dc1"sv}, Entry{"v1-009500-010000-headers.idx"sv, "c7182a3b215af2d835c8b6476e3d10bd257bc9d2"sv}, Entry{"v1-009500-010000-headers.seg"sv, "6e649019558eedf59a740eb5b9f10f2ab8a3b006"sv}, Entry{"v1-009500-010000-transactions-to-block.idx"sv, "feae380bcd19db7ac2575f588296b51ee616302e"sv}, Entry{"v1-009500-010000-transactions.idx"sv, "d91cc03f36e57fad4a685424cdb432bba10036ab"sv}, Entry{"v1-009500-010000-transactions.seg"sv, "3a7bcc9853f8345ce1a423d4cc221428875f728c"sv}, Entry{"v1-010000-010500-bodies.idx"sv, "949eb1c3ba8f9b2bcc5d02c9c66342179a313a85"sv}, Entry{"v1-010000-010500-bodies.seg"sv, "3c6628b682eb7948d48af28cfd104a6cea97680f"sv}, Entry{"v1-010000-010500-borevents.idx"sv, "6c06b68f05ae2ed111871af60bf4760b1ae07a40"sv}, Entry{"v1-010000-010500-borevents.seg"sv, "0de2f6d349d408031f2ab27106165cdaf7b8dfb6"sv}, Entry{"v1-010000-010500-borspans.idx"sv, "9683c10ee569d0bf9af21e97ff1d34c5ddaacfe9"sv}, Entry{"v1-010000-010500-borspans.seg"sv, "9057294e989d6d97ce0b6aaf9d6d2b34aabce699"sv}, Entry{"v1-010000-010500-headers.idx"sv, "0a2fcd92d87e78fb97b4914ca4e763328cc38f3e"sv}, Entry{"v1-010000-010500-headers.seg"sv, "d305caa15982cda320115d055ba076bba35b6923"sv}, Entry{"v1-010000-010500-transactions-to-block.idx"sv, "d8aa6ee22b46468211e532f1f8eddea2ee90319e"sv}, Entry{"v1-010000-010500-transactions.idx"sv, "972ad06d33bf455b9e451cd9bca9c98951e7a540"sv}, Entry{"v1-010000-010500-transactions.seg"sv, "a28b7036bb646599a53d2909fe2e3c2d786c7292"sv}, Entry{"v1-010500-011000-bodies.idx"sv, "490eb33a0e6069ec45d957bc6fb369eff8cb4b3c"sv}, Entry{"v1-010500-011000-bodies.seg"sv, "08e08a6cb27acca4bfc134c199ce54decbd7ecd7"sv}, Entry{"v1-010500-011000-borevents.idx"sv, "8193361db6564bdc93e42738019bd8efd809a023"sv}, Entry{"v1-010500-011000-borevents.seg"sv, "dc6086d6785aabe7809d2c88ff87bd4674fa8e41"sv}, Entry{"v1-010500-011000-borspans.idx"sv, "47049cd0c8af4ce2a082ef887f6e57b1612d1796"sv}, Entry{"v1-010500-011000-borspans.seg"sv, "2c7542953ee4b50ddeb2fe3e833fdc023f4ecf66"sv}, Entry{"v1-010500-011000-headers.idx"sv, "46d8e13d78731d99fc6cc4c97838fe021be33d8c"sv}, Entry{"v1-010500-011000-headers.seg"sv, "0c630f3a665c8f7f3287873be51c7b052f6ed382"sv}, Entry{"v1-010500-011000-transactions-to-block.idx"sv, "463eb111cdc7aefe21bbbd6bcc8a2bd4880d2056"sv}, Entry{"v1-010500-011000-transactions.idx"sv, "c8727b38f07259a835e1be0956edc379967708c5"sv}, Entry{"v1-010500-011000-transactions.seg"sv, "3663d51a793454d878e32367ffe8d250937fa7de"sv}, Entry{"v1-011000-011500-bodies.idx"sv, "c12f967b30caa36baf3dc4f0ae830ecef4c97c99"sv}, Entry{"v1-011000-011500-bodies.seg"sv, "e264600c539e75824b4a6db68c2e9c6bcabaec5d"sv}, Entry{"v1-011000-011500-borevents.idx"sv, "88dee5c1a5d15f926ece84df84f7821ec75f6e2e"sv}, Entry{"v1-011000-011500-borevents.seg"sv, "4cec7cd74c63e4025907a0098b7695afc79e2040"sv}, Entry{"v1-011000-011500-borspans.idx"sv, "c3d85a6b8afcdc0cd871bdaaa6a921d58a15931b"sv}, Entry{"v1-011000-011500-borspans.seg"sv, "e4ce02476484293ee011472304b1fbc75b7681c0"sv}, Entry{"v1-011000-011500-headers.idx"sv, "d8cf86e1551eec6427044f9a8ea7c154a181de36"sv}, Entry{"v1-011000-011500-headers.seg"sv, "1d2c618ba16331abfa3f2a7cbdaf0c43b29e9564"sv}, Entry{"v1-011000-011500-transactions-to-block.idx"sv, "b47c71cf0c6d5f895a9b32916e49543db13c636d"sv}, Entry{"v1-011000-011500-transactions.idx"sv, "71159590fca8fb21e6f4144e9d75badd6d991cc5"sv}, Entry{"v1-011000-011500-transactions.seg"sv, "9fba3b50041677ff47d31ac33a6b1a77ae93898f"sv}, Entry{"v1-011500-012000-bodies.idx"sv, "f99f1454a545a24d92ee951c8a67bb70e2a289f9"sv}, Entry{"v1-011500-012000-bodies.seg"sv, "4b45152173f364fcce859e88d1a4493b179453ad"sv}, Entry{"v1-011500-012000-borevents.idx"sv, "db7d32172eed01fb880afe4460f906920a36c7c6"sv}, Entry{"v1-011500-012000-borevents.seg"sv, "e6eb9e91fe5e9b228960a15c0bfac935c8acea62"sv}, Entry{"v1-011500-012000-borspans.idx"sv, "d075a43011b4320e5c3617b5b1b40dbba38e7400"sv}, Entry{"v1-011500-012000-borspans.seg"sv, "f35ae631ba3de8f81b8d360d8ccfceb06bd95a2b"sv}, Entry{"v1-011500-012000-headers.idx"sv, "16f918b45c148b94ed709c978586fd6759466e04"sv}, Entry{"v1-011500-012000-headers.seg"sv, "1321d571f03d84ac3ccdceb9c3f787cc48b26ff9"sv}, Entry{"v1-011500-012000-transactions-to-block.idx"sv, "ecdeac008ce734ef52d60e75fcd6ef56e840e8d2"sv}, Entry{"v1-011500-012000-transactions.idx"sv, "3e5569149dec95bf25297e01c1a391a463a74d37"sv}, Entry{"v1-011500-012000-transactions.seg"sv, "b1feaa63f8e03c0c8a496fb1d31c9b8e25497b2e"sv}, Entry{"v1-012000-012500-bodies.idx"sv, "b328337648bcbabf28b42d4159bbf24a970e2bb6"sv}, Entry{"v1-012000-012500-bodies.seg"sv, "9f7e0742ddd588f4de5cc70eeda30353cc26b57f"sv}, Entry{"v1-012000-012500-borevents.idx"sv, "c3eb703146bb19610ad1aa94a81f59739b35ebc6"sv}, Entry{"v1-012000-012500-borevents.seg"sv, "aac34ecaf57d8d7510a8707142790c65de9859c5"sv}, Entry{"v1-012000-012500-borspans.idx"sv, "e6ca17dc6bb0e543bb2953034d39aa0772800532"sv}, Entry{"v1-012000-012500-borspans.seg"sv, "2ef4e632dc1b10418c748c50c9a3098d10c3ef33"sv}, Entry{"v1-012000-012500-headers.idx"sv, "6488e72e12d3f4c078c0dbdeaa5d20f307064df7"sv}, Entry{"v1-012000-012500-headers.seg"sv, "c652fd1662da73fbfad36583c9b3624c51ac677a"sv}, Entry{"v1-012000-012500-transactions-to-block.idx"sv, "b8f2a9eae5a53a25ac3a39c81ff63ca28815a512"sv}, Entry{"v1-012000-012500-transactions.idx"sv, "c842c39d50480853f8278a633f720d4868d2a2ae"sv}, Entry{"v1-012000-012500-transactions.seg"sv, "1a2bf8eb4b29f0614497381c5099f243abda992c"sv}, Entry{"v1-012500-013000-bodies.idx"sv, "772dcb05ae4935fc322cf86315826ef09382d9f0"sv}, Entry{"v1-012500-013000-bodies.seg"sv, "da518c45fcd176208a0b6578d348974a309321e8"sv}, Entry{"v1-012500-013000-borevents.idx"sv, "66e4700e67808c695d3b703d3441050ff62aef7d"sv}, Entry{"v1-012500-013000-borevents.seg"sv, "f623dc0f881f6b8a2073ff82530690abc4beefca"sv}, Entry{"v1-012500-013000-borspans.idx"sv, "efdcf39da668a1a7d026f657d1fbff6b5723230b"sv}, Entry{"v1-012500-013000-borspans.seg"sv, "7e0eedd5d7fc4cda8a818aa29fcfd4e3d8c3b089"sv}, Entry{"v1-012500-013000-headers.idx"sv, "8272a82227f49561a62c76f1e2f752c6fe6253dc"sv}, Entry{"v1-012500-013000-headers.seg"sv, "7987ae6703e730a8ee0e7cc4a2ebe6301b46314f"sv}, Entry{"v1-012500-013000-transactions-to-block.idx"sv, "eb5b0e45fe4f42869a411a29794f9017615b53a6"sv}, Entry{"v1-012500-013000-transactions.idx"sv, "fe5a30a3e48618931bdb04aa79009f406440e9bf"sv}, Entry{"v1-012500-013000-transactions.seg"sv, "a3e30a5237b8d95685a60899a10756b5dfedf4b0"sv}, Entry{"v1-013000-013500-bodies.idx"sv, "fe29097fb04d90a1a3c87c9af7e85ff0346c0cfc"sv}, Entry{"v1-013000-013500-bodies.seg"sv, "97552ff5c34fb4b6954b949d2d9d6b2d69c24270"sv}, Entry{"v1-013000-013500-borevents.idx"sv, "78fbf306d784e3c96bbf5d12807fe2ba7c0bb5a9"sv}, Entry{"v1-013000-013500-borevents.seg"sv, "30ffb7c22e87248fb825043ede11d34b9e0d9c6e"sv}, Entry{"v1-013000-013500-borspans.idx"sv, "963a27881637dd860c300d3aa3fe7be080752765"sv}, Entry{"v1-013000-013500-borspans.seg"sv, "4758f8b7613bb769de9847aa1230fc3fae6c418a"sv}, Entry{"v1-013000-013500-headers.idx"sv, "b3018f52b247061556731441ecc6a374bed55768"sv}, Entry{"v1-013000-013500-headers.seg"sv, "4cfd5c3578754832a044d7af1014cf8a30cc12aa"sv}, Entry{"v1-013000-013500-transactions-to-block.idx"sv, "12dcbf6ae839b20477fea8dc560de5fc29864a79"sv}, Entry{"v1-013000-013500-transactions.idx"sv, "750dc71a2fc1d9ae73b7974dc09cbcd872d2b0cb"sv}, Entry{"v1-013000-013500-transactions.seg"sv, "3b43e08275c15a9e6bfaa6b5d1db5f7c7f6ed3e9"sv}, Entry{"v1-013500-014000-bodies.idx"sv, "43f5a2eee5d077b1f9330f5fb2a7f5068795e2fe"sv}, Entry{"v1-013500-014000-bodies.seg"sv, "59ee2dcb100120c8ad35049d7fc1e6f31621d3bd"sv}, Entry{"v1-013500-014000-borevents.idx"sv, "4720b3b287f9f31a84eee87e21a71728f8210118"sv}, Entry{"v1-013500-014000-borevents.seg"sv, "e6d3e17febafbe2af3ed68af8dce4ad6d39ee6d5"sv}, Entry{"v1-013500-014000-borspans.idx"sv, "66b48859fb4d007f729df866ae3dc03226ad9b1f"sv}, Entry{"v1-013500-014000-borspans.seg"sv, "fa064b0e61f985a7aa3371aa58937a63648691d9"sv}, Entry{"v1-013500-014000-headers.idx"sv, "d34f64f73f69451c7fc456d082a6df7a312caa70"sv}, Entry{"v1-013500-014000-headers.seg"sv, "ae39923c6d75659ca2a61f32f62cabe5a54a3b45"sv}, Entry{"v1-013500-014000-transactions-to-block.idx"sv, "ee0dfc855542dc6e0fe4e6067a8b57a637d1cba8"sv}, Entry{"v1-013500-014000-transactions.idx"sv, "a3794ab375ade4cc190c2df992713461e3ef10a1"sv}, Entry{"v1-013500-014000-transactions.seg"sv, "4bb11aedabd7db1435a7218d39ba69cefdfd4132"sv}, Entry{"v1-014000-014500-bodies.idx"sv, "7f0b74cb5c15509a34397f68d6f355da1f5eb02a"sv}, Entry{"v1-014000-014500-bodies.seg"sv, "fc9334dd44d7dd741b41112c529008d211123636"sv}, Entry{"v1-014000-014500-borevents.idx"sv, "3f27191c0627e9901eb27439acd387a49002146f"sv}, Entry{"v1-014000-014500-borevents.seg"sv, "1478c783c9392089d96a8d581bcf7dd599841560"sv}, Entry{"v1-014000-014500-borspans.idx"sv, "23a031243cc8e32dec16697ae23f4342b13a1697"sv}, Entry{"v1-014000-014500-borspans.seg"sv, "a2ef65a586942462764a864265c91a4ad9d4645e"sv}, Entry{"v1-014000-014500-headers.idx"sv, "4267cbb1bb4591ddcd4d81e1d3eeec972432789e"sv}, Entry{"v1-014000-014500-headers.seg"sv, "e2be634b5e96132781e818a5cc21238a4abacbf7"sv}, Entry{"v1-014000-014500-transactions-to-block.idx"sv, "2da0141e94184f53c10f244528098ee217b14424"sv}, Entry{"v1-014000-014500-transactions.idx"sv, "ed45d6251f2bc3ad9194d001f4f9f320e3cbb242"sv}, Entry{"v1-014000-014500-transactions.seg"sv, "505eea5d84a4083a104ee7322068f14a31477540"sv}, Entry{"v1-014500-015000-bodies.idx"sv, "6b40fdef88bcf6559c762b31c42a2a26ddb8ef71"sv}, Entry{"v1-014500-015000-bodies.seg"sv, "7101af646872402d73bd52127970409daaf06318"sv}, Entry{"v1-014500-015000-borevents.idx"sv, "5ebd0abc1fd1b508bc3bd9114c0a387ad84a2bd2"sv}, Entry{"v1-014500-015000-borevents.seg"sv, "a0cdf3c06a714dbb2a494ca725ec69fccad16703"sv}, Entry{"v1-014500-015000-borspans.idx"sv, "0d4d5fb6aabfaabe406ace4a1018ba62efb90da7"sv}, Entry{"v1-014500-015000-borspans.seg"sv, "d096ff8445b2dbfbd26f7f7efaffbd4a216a6701"sv}, Entry{"v1-014500-015000-headers.idx"sv, "8567ef02a40a824ddd3ecb358b93d175fca5127d"sv}, Entry{"v1-014500-015000-headers.seg"sv, "cd26c3a4cc38d6744af672d0f0ff5e6a7c10f6d7"sv}, Entry{"v1-014500-015000-transactions-to-block.idx"sv, "b9ca2e6514b00c81f0acf8d953382fa8ce55ae10"sv}, Entry{"v1-014500-015000-transactions.idx"sv, "afeeddf4afa67799898417431313f1752c225336"sv}, Entry{"v1-014500-015000-transactions.seg"sv, "f9d373fee4698eea3868369c8cb7a66913367cc9"sv}, Entry{"v1-015000-015500-bodies.idx"sv, "e5530c48e2b559a92554de6aea175ed1e93d872a"sv}, Entry{"v1-015000-015500-bodies.seg"sv, "a39623377acf70af14920335e3afcacd5200de79"sv}, Entry{"v1-015000-015500-borevents.idx"sv, "e5608f9ec6f7e456af456bff3728a779948fac1f"sv}, Entry{"v1-015000-015500-borevents.seg"sv, "aee67a8dc6b3cf5a423b73a3c20977d5f3100a6c"sv}, Entry{"v1-015000-015500-borspans.idx"sv, "df9078ef4d9913c5390f5f6286ebd1a86052218c"sv}, Entry{"v1-015000-015500-borspans.seg"sv, "e4c8dc4959f5f8cd28c4c0555ac6cd2658494a71"sv}, Entry{"v1-015000-015500-headers.idx"sv, "30b27647caeade7be6c5c278fd5eb35c2b2f6de4"sv}, Entry{"v1-015000-015500-headers.seg"sv, "4b1ccd312defafbeaac6e9576402949ea3bc70ab"sv}, Entry{"v1-015000-015500-transactions-to-block.idx"sv, "0921f48995821270c7d332c34e07f3366ad7713a"sv}, Entry{"v1-015000-015500-transactions.idx"sv, "326b877fe19270a63cedf19c2c253b4607256431"sv}, Entry{"v1-015000-015500-transactions.seg"sv, "dc892b82ec6091619f51b431ac628e8b2504f772"sv}, Entry{"v1-015500-016000-bodies.idx"sv, "6c51b6973afa4ccb8114e8fd0c3ece8583afca71"sv}, Entry{"v1-015500-016000-bodies.seg"sv, "b05c8434a974cebe964493dd3f3482c124681bcb"sv}, Entry{"v1-015500-016000-borevents.idx"sv, "32e6879a705bdfe61c80530f4221a4375d103bd2"sv}, Entry{"v1-015500-016000-borevents.seg"sv, "a0bd99d2367c43db10b4a089853c2c182f15c3d0"sv}, Entry{"v1-015500-016000-borspans.idx"sv, "1012c5fde6fd131c8b165481848aa32563ec8c4c"sv}, Entry{"v1-015500-016000-borspans.seg"sv, "bac126800559d3c2632ba16bf5566b2d3db46de2"sv}, Entry{"v1-015500-016000-headers.idx"sv, "2f187519efca1fd84648b5dc006bdff57bce1e56"sv}, Entry{"v1-015500-016000-headers.seg"sv, "b4244caa679ae62c1992655042277b1672b5a0f5"sv}, Entry{"v1-015500-016000-transactions-to-block.idx"sv, "3fb0614c857ca5db1dda05f1c446c29d0d8bc6c9"sv}, Entry{"v1-015500-016000-transactions.idx"sv, "6ae8cad3b94c136fada36d3ea53beeb7b9f5c374"sv}, Entry{"v1-015500-016000-transactions.seg"sv, "5f7b86fc2f4064b25b880e1fe8f9ed1fa98e02ad"sv}, Entry{"v1-016000-016500-bodies.idx"sv, "a0eb43dd9cf98f5caeffb9d8cd5cb0056c869a69"sv}, Entry{"v1-016000-016500-bodies.seg"sv, "ab62792929c3f4d59acce83feece8b34223a3053"sv}, Entry{"v1-016000-016500-borevents.idx"sv, "9253f6bdb07669397584dc203d544916b73ce6aa"sv}, Entry{"v1-016000-016500-borevents.seg"sv, "9dffde929379d66fcb84ba758b847a8a8219216a"sv}, Entry{"v1-016000-016500-borspans.idx"sv, "15dd7157e8e585a4ae685f632c8313d8df72fb06"sv}, Entry{"v1-016000-016500-borspans.seg"sv, "f964b2713f95f5e3e5b62f7dac73d6332db1f8e3"sv}, Entry{"v1-016000-016500-headers.idx"sv, "13a7c9e3e3bf38d07567f7881c8845cb1c3c0cf6"sv}, Entry{"v1-016000-016500-headers.seg"sv, "448cc103da453d6524e93826b47cf2992a3e9056"sv}, Entry{"v1-016000-016500-transactions-to-block.idx"sv, "34a430a5fbb5c76ec94ec0bbd0863457bbe9e3c3"sv}, Entry{"v1-016000-016500-transactions.idx"sv, "203f4804fc8a0980ae18e2ea4d939c1850bc16ab"sv}, Entry{"v1-016000-016500-transactions.seg"sv, "684978e03b665da1a37fbc2067757511696debd0"sv}, Entry{"v1-016500-017000-bodies.idx"sv, "eceaca90a19006e728a4d0e3864cea996dddd09f"sv}, Entry{"v1-016500-017000-bodies.seg"sv, "ec5934c84699043218fb4de95206f0398df1f23d"sv}, Entry{"v1-016500-017000-borevents.idx"sv, "38acc1092360878a7293b380d682a652f65fc0c8"sv}, Entry{"v1-016500-017000-borevents.seg"sv, "e6f1399693651f3e9fa01563e93a0b3ce6976976"sv}, Entry{"v1-016500-017000-borspans.idx"sv, "1ef82456e1462e1119f2b457ba78f0cf968baa79"sv}, Entry{"v1-016500-017000-borspans.seg"sv, "6f29ddcf90f8e3dabb039a63a033931940e8b48f"sv}, Entry{"v1-016500-017000-headers.idx"sv, "7d39f155242c5d3a7a428287afd920ef77731eb5"sv}, Entry{"v1-016500-017000-headers.seg"sv, "4308990a7f2d5a95871c125893ac83c9f138397a"sv}, Entry{"v1-016500-017000-transactions-to-block.idx"sv, "487584e8519e53b9b60569b864da1364fa72f3d9"sv}, Entry{"v1-016500-017000-transactions.idx"sv, "67aed62b649f24a61b2f5b544e3a50d526a78378"sv}, Entry{"v1-016500-017000-transactions.seg"sv, "780686c680b718aeb7008854cc24440f297cf6ba"sv}, Entry{"v1-017000-017500-bodies.idx"sv, "957f9c54fd4f748cd30ed4a83c053c659f45d06d"sv}, Entry{"v1-017000-017500-bodies.seg"sv, "1dbb90353693877159589aa1f4ef39986ef1ee0f"sv}, Entry{"v1-017000-017500-borevents.idx"sv, "b49bc076cee58605ab927c1e62e5896c7ba695a1"sv}, Entry{"v1-017000-017500-borevents.seg"sv, "02f9c361bd952eb418b27a2a5c345af8a215bf09"sv}, Entry{"v1-017000-017500-borspans.idx"sv, "3bafc38e5db11b807948adec3b46bdfb2ebc3338"sv}, Entry{"v1-017000-017500-borspans.seg"sv, "04e9c36e805a7f8f7913d36ec0da06b7c2817e19"sv}, Entry{"v1-017000-017500-headers.idx"sv, "575ada7ca23ce9506be29528b5f0319110b030a4"sv}, Entry{"v1-017000-017500-headers.seg"sv, "4cc4131c9daac808c23123973601bcbefcc8bdd9"sv}, Entry{"v1-017000-017500-transactions-to-block.idx"sv, "3aed5cbc04a569135abaceba20906f8359ccd17f"sv}, Entry{"v1-017000-017500-transactions.idx"sv, "4fafd457c96c514def87ad1b6ca9a4433f595a2f"sv}, Entry{"v1-017000-017500-transactions.seg"sv, "9456045815b82ee466309240327049bc4b12ed96"sv}, Entry{"v1-017500-018000-bodies.idx"sv, "f8485685cef4eb4905b4d7077d90d642f9eeb144"sv}, Entry{"v1-017500-018000-bodies.seg"sv, "7b86c6fda7db8988abfe347370a35112a5339635"sv}, Entry{"v1-017500-018000-borevents.idx"sv, "927b4edb3db11cb077d7bc28bad884fe1b02029f"sv}, Entry{"v1-017500-018000-borevents.seg"sv, "a44c82151515a4e1c30cbcf474f6859aec64ef94"sv}, Entry{"v1-017500-018000-borspans.idx"sv, "fdd0f1c113ab9e380db21054cbba7ef40599a5d7"sv}, Entry{"v1-017500-018000-borspans.seg"sv, "35165e7e0f5f8ba298b9a5ab5a554770aaa8be90"sv}, Entry{"v1-017500-018000-headers.idx"sv, "972c54276abd0b709406eb9026c5ef1b447bedf6"sv}, Entry{"v1-017500-018000-headers.seg"sv, "e29ddcb4b5676a3c6eda9168808c583d1629a353"sv}, Entry{"v1-017500-018000-transactions-to-block.idx"sv, "8a5dc2dac1d6f559d4fcbc411ee7598a2580d95f"sv}, Entry{"v1-017500-018000-transactions.idx"sv, "350094f7cf21ef3222e3892de3922908879666c2"sv}, Entry{"v1-017500-018000-transactions.seg"sv, "c41d37047beccc671cb1590bcd19c77eef21795f"sv}, Entry{"v1-018000-018500-bodies.idx"sv, "6c1c50d1908304260f5a9a89a00cbe848ecbd894"sv}, Entry{"v1-018000-018500-bodies.seg"sv, "1b15ab67b29a3ae3cb4ba480d7329e1cb95bb3a6"sv}, Entry{"v1-018000-018500-borevents.idx"sv, "81d458b6be62e94326bf14ed34f4f42bc55434ad"sv}, Entry{"v1-018000-018500-borevents.seg"sv, "99e7db043d69db16d209eeb9940caef172ae4be1"sv}, Entry{"v1-018000-018500-borspans.idx"sv, "bc30259dd6e89687580a5e7e248b929e32f54a80"sv}, Entry{"v1-018000-018500-borspans.seg"sv, "deecf7cd47ad42fb9d9ef962e826860dd535b1ea"sv}, Entry{"v1-018000-018500-headers.idx"sv, "9b7c3d4529a57802d95e6172248fde300d1f4d5b"sv}, Entry{"v1-018000-018500-headers.seg"sv, "b07155a90b0c669734243340a9668d87f2b6e88e"sv}, Entry{"v1-018000-018500-transactions-to-block.idx"sv, "fd2e87583e11ae75d2ef552758610f8c5867fcd1"sv}, Entry{"v1-018000-018500-transactions.idx"sv, "ea41cf7b64e25fa1bc55a2141e9466969a82661c"sv}, Entry{"v1-018000-018500-transactions.seg"sv, "851ed48c87298812419e599e4273e520e11f87b4"sv}, Entry{"v1-018500-019000-bodies.idx"sv, "3e8eca9bec0f78efb36f901a44d65c7b0c03d23f"sv}, Entry{"v1-018500-019000-bodies.seg"sv, "dc7bd190bbe549b43c829123c595a79da7080f40"sv}, Entry{"v1-018500-019000-borevents.idx"sv, "25dbce46cd251d28dfd9a6687a4c90a425604c5c"sv}, Entry{"v1-018500-019000-borevents.seg"sv, "0d08b08f661eae20ac62282993c3cad6c8e9c212"sv}, Entry{"v1-018500-019000-borspans.idx"sv, "61c5124cdbd1882126fe4334a2521e0f5fb2f11a"sv}, Entry{"v1-018500-019000-borspans.seg"sv, "c6b78f815abba05df09ceb04fb8cb0ae4c98a2cd"sv}, Entry{"v1-018500-019000-headers.idx"sv, "dcc4407e6600e1f690a7f983f11a532784d23b19"sv}, Entry{"v1-018500-019000-headers.seg"sv, "51d3988b761218f7eef28cd98073856d58109d8e"sv}, Entry{"v1-018500-019000-transactions-to-block.idx"sv, "5fcd908acd9dd291e4139259d71347ba5c8c6ddb"sv}, Entry{"v1-018500-019000-transactions.idx"sv, "40b6808865cea379c1de5853334c016bce29e4b2"sv}, Entry{"v1-018500-019000-transactions.seg"sv, "32212764dc7a141d7176c2e8618a78414310fb02"sv}, Entry{"v1-019000-019500-bodies.idx"sv, "e7dc0c43b011fbc092bfab708b7a67a950552c66"sv}, Entry{"v1-019000-019500-bodies.seg"sv, "ea3e668d887ad8360d9b47486843239e8ab5b691"sv}, Entry{"v1-019000-019500-borevents.idx"sv, "b7fcdde16225a6b5277d3fd092e3bb12cc5fd84c"sv}, Entry{"v1-019000-019500-borevents.seg"sv, "49902efe80d415f15c4193ae05924293eec64b8e"sv}, Entry{"v1-019000-019500-borspans.idx"sv, "b9d274b8d3f28e667c7e0f446e339f132390e60c"sv}, Entry{"v1-019000-019500-borspans.seg"sv, "12b44abdf342f87b4619962677995f3b92aa6b8e"sv}, Entry{"v1-019000-019500-headers.idx"sv, "fce03f0fa5346b7be3769d45540193c199532f5f"sv}, Entry{"v1-019000-019500-headers.seg"sv, "7ed55581c2944dd9206e3dc778e8fe19ecae45bb"sv}, Entry{"v1-019000-019500-transactions-to-block.idx"sv, "55ebf659a6624e95996043663de5b83808f3eae4"sv}, Entry{"v1-019000-019500-transactions.idx"sv, "92cdad799d5d212bb7b2442aee4d4019477f4d8c"sv}, Entry{"v1-019000-019500-transactions.seg"sv, "ebe8cd5bac08edfa33123e1584b75bc2feaefb29"sv}, Entry{"v1-019500-020000-bodies.idx"sv, "134c59944542869b6be29eb9daa04f722ccacd36"sv}, Entry{"v1-019500-020000-bodies.seg"sv, "2a68d7a223eedcdb8ecc32af457b3552b913afeb"sv}, Entry{"v1-019500-020000-borevents.idx"sv, "ec80d2c37410f35b871b45a36a43050c04b5c77b"sv}, Entry{"v1-019500-020000-borevents.seg"sv, "335acd4f1fbe1e3e685adc10f0b124a3edbd1ce0"sv}, Entry{"v1-019500-020000-borspans.idx"sv, "2fc2ebe4e89202770ebf7c0e6940dc395db99039"sv}, Entry{"v1-019500-020000-borspans.seg"sv, "eb47fa61839dd7b802b8f9dfa4aedb5972766a93"sv}, Entry{"v1-019500-020000-headers.idx"sv, "bbec407c8aac659c97cb4488e82ff1ec81b3bd02"sv}, Entry{"v1-019500-020000-headers.seg"sv, "be1dd4c7f5e774fa7846560ca601077327c31f4b"sv}, Entry{"v1-019500-020000-transactions-to-block.idx"sv, "acfc5d3cfaeb6601a6b2f25ac078092126457aa2"sv}, Entry{"v1-019500-020000-transactions.idx"sv, "928deb5ae8814f16ef4e977790ff5791117036ec"sv}, Entry{"v1-019500-020000-transactions.seg"sv, "e96e88548a7b317909b0dd6b7b13891f5b2b905a"sv}, Entry{"v1-020000-020500-bodies.idx"sv, "988ef01f6027d948c1dfcd9748e71115a0a38ed9"sv}, Entry{"v1-020000-020500-bodies.seg"sv, "0516044f405fe84b0ec503608f123de0a213d86b"sv}, Entry{"v1-020000-020500-borevents.idx"sv, "6b426e2512318c17efa5f8996c8571054e5a6757"sv}, Entry{"v1-020000-020500-borevents.seg"sv, "95799c9a66a1df781f0f66212cda4427047a1bd4"sv}, Entry{"v1-020000-020500-borspans.idx"sv, "ab0ad911f6b45e8ef2d2d1f7a3cc577ea999a909"sv}, Entry{"v1-020000-020500-borspans.seg"sv, "798bdb962fe7edb955ed453194d1f1ce37f3245f"sv}, Entry{"v1-020000-020500-headers.idx"sv, "eaa526583d4a3ad0a3b6816de62dc6d3deb9283a"sv}, Entry{"v1-020000-020500-headers.seg"sv, "489e2dbd4ed67be0619bd2b20a2df04470304e31"sv}, Entry{"v1-020000-020500-transactions-to-block.idx"sv, "6ffb5de8d82183396c62ecac49e7cc2ac2315005"sv}, Entry{"v1-020000-020500-transactions.idx"sv, "87cbbd9eb863fe50ae73a2b7f07ffa2d9c8dd5a1"sv}, Entry{"v1-020000-020500-transactions.seg"sv, "8697ffa65b9867b83c347b961119b474e6244ca0"sv}, Entry{"v1-020500-021000-bodies.idx"sv, "20e483c68bb03d9677dc7c9ee9ad08465d17a6f7"sv}, Entry{"v1-020500-021000-bodies.seg"sv, "48c98a670f807b2bcbf84bb66f8db3575a581191"sv}, Entry{"v1-020500-021000-borevents.idx"sv, "d79eaf2ea9e9cc8c7d699caf7e4dc78a7af37771"sv}, Entry{"v1-020500-021000-borevents.seg"sv, "1e2a3aa7258689d7e9776afd77e533e36ef37e35"sv}, Entry{"v1-020500-021000-borspans.idx"sv, "73828255539511006b858cf97eb01aa3ab4f4ab5"sv}, Entry{"v1-020500-021000-borspans.seg"sv, "75eff4d7d06c669c41fc044c669a56dd96158961"sv}, Entry{"v1-020500-021000-headers.idx"sv, "be8b726d29a1928a0091d4a70b447e0f586f3a9c"sv}, Entry{"v1-020500-021000-headers.seg"sv, "03b14b41269ea0217cf60849de0e9fb87a7de660"sv}, Entry{"v1-020500-021000-transactions-to-block.idx"sv, "e08833fe52975ed9903bd3e9c3f1d1c5f931a033"sv}, Entry{"v1-020500-021000-transactions.idx"sv, "5ae90f48f00deca5add94449befaf1723878bd10"sv}, Entry{"v1-020500-021000-transactions.seg"sv, "2f97687f68b42dbc39efe527db4488940bcd1b02"sv}, Entry{"v1-021000-021500-bodies.idx"sv, "fa73108f71b42ce65b1403339c2a2c4440e23e7c"sv}, Entry{"v1-021000-021500-bodies.seg"sv, "4be3700197ec19e99fcdbfa80b5d73e472ad81aa"sv}, Entry{"v1-021000-021500-borevents.idx"sv, "ec7c4646bf44b4f1e6f20932aa074ce0f783bda0"sv}, Entry{"v1-021000-021500-borevents.seg"sv, "0c7983c46361c9f5e37b7a78e943836a7b13e985"sv}, Entry{"v1-021000-021500-borspans.idx"sv, "7c78c6b58cd494764e4ef1f58cef1a4b5fa5cdcc"sv}, Entry{"v1-021000-021500-borspans.seg"sv, "dac5d4f199b35276f2423d2933112b3885407904"sv}, Entry{"v1-021000-021500-headers.idx"sv, "968026a42f802d71d015366fa583154472e1fed4"sv}, Entry{"v1-021000-021500-headers.seg"sv, "87f2b0a037979e35423927cd92d15d9b261c1e23"sv}, Entry{"v1-021000-021500-transactions-to-block.idx"sv, "62c7aee8e9b3e81fd323f776be00cb92365229d3"sv}, Entry{"v1-021000-021500-transactions.idx"sv, "ca417130602dac84a8d90db1efd55d918323b1f4"sv}, Entry{"v1-021000-021500-transactions.seg"sv, "c2c8e5295aada2dcb41c067d5f3b3135a61fe409"sv}, Entry{"v1-021500-022000-bodies.idx"sv, "6239f0fe89e6518ccf66263ce8fb9bba0f96a585"sv}, Entry{"v1-021500-022000-bodies.seg"sv, "e24c2e53c4ecbada6d7d3920b69d2fb9106c5ab4"sv}, Entry{"v1-021500-022000-borevents.idx"sv, "0792de605d251e83df4e7d1c57eaa7d0249ad3d8"sv}, Entry{"v1-021500-022000-borevents.seg"sv, "5f52673d44dbcc7d5ba75923ba3bda5a21bc375b"sv}, Entry{"v1-021500-022000-borspans.idx"sv, "c60544a03be19af4a053079fd4de1b42e8740a02"sv}, Entry{"v1-021500-022000-borspans.seg"sv, "1fa6b4ce4a47892eb1e141f470b15ee90546e353"sv}, Entry{"v1-021500-022000-headers.idx"sv, "40a09ced34f99fa490dc54d8c4776cb7ed7206e5"sv}, Entry{"v1-021500-022000-headers.seg"sv, "f010d11cc56f91988d11c1885ef049f57f3512d4"sv}, Entry{"v1-021500-022000-transactions-to-block.idx"sv, "154b7b1373361f6e855e5bd7b38de7bdd312abde"sv}, Entry{"v1-021500-022000-transactions.idx"sv, "921f8c4385572cacb2f92334d5cd4c4415accf87"sv}, Entry{"v1-021500-022000-transactions.seg"sv, "cb09e33bf5bc4e50a6ea3b34df17859a6a3b794c"sv}, Entry{"v1-022000-022500-bodies.idx"sv, "b5bed94a6ae32482481104065218640c46e69ef0"sv}, Entry{"v1-022000-022500-bodies.seg"sv, "c57a060c56f9a9becd03d4e4d96c14a471100940"sv}, Entry{"v1-022000-022500-borevents.idx"sv, "00bf40e42d4db4f5044d462aef10b531a79d65e2"sv}, Entry{"v1-022000-022500-borevents.seg"sv, "5f2d6548d90dd3e54077a6bd166d7a7f42899442"sv}, Entry{"v1-022000-022500-borspans.idx"sv, "3e6600104f968a6e03b20a290c8e9e972b02f214"sv}, Entry{"v1-022000-022500-borspans.seg"sv, "1253ff36b03443c73f11bc67b1855d6fe4ab374e"sv}, Entry{"v1-022000-022500-headers.idx"sv, "8dfafb3a2cf019b599dcf26c7fb7ece7998b77f4"sv}, Entry{"v1-022000-022500-headers.seg"sv, "4e94ee20c4d8e6b115ba7d83ad9fe7e336cf4ecd"sv}, Entry{"v1-022000-022500-transactions-to-block.idx"sv, "4b93e9f2028d4f4d268725216fb908c3c27e207e"sv}, Entry{"v1-022000-022500-transactions.idx"sv, "3c3ebf0372a79180dc0c3240156399bc77b66207"sv}, Entry{"v1-022000-022500-transactions.seg"sv, "fc4821570144f2cdede069ad445f81d8709e4e46"sv}, Entry{"v1-022500-023000-bodies.idx"sv, "129d06de96f667e7f83c0df4cc695c26b4aed4a7"sv}, Entry{"v1-022500-023000-bodies.seg"sv, "b90e6a6971d18ebc5866df3fc19ea12ab3e4b20f"sv}, Entry{"v1-022500-023000-borevents.idx"sv, "aa168b6a8b631ddf586d7ff76260c10a2eca2742"sv}, Entry{"v1-022500-023000-borevents.seg"sv, "407383c3d0cc49d878a774921683d796d700be5a"sv}, Entry{"v1-022500-023000-borspans.idx"sv, "34fe4b0392b64e1b9bdf8d9a7892990ee9ed761e"sv}, Entry{"v1-022500-023000-borspans.seg"sv, "a04f63ab5a3b469a2cf82623834c7ffe3085905a"sv}, Entry{"v1-022500-023000-headers.idx"sv, "99490992ee8b8dc627e040453e5912e85dbcbf1e"sv}, Entry{"v1-022500-023000-headers.seg"sv, "ea008a6c0b8c21e4ffcb6bd521db988faf77e1e6"sv}, Entry{"v1-022500-023000-transactions-to-block.idx"sv, "ccab15cfc389b596643a62e083e8047b77b354e7"sv}, Entry{"v1-022500-023000-transactions.idx"sv, "665dadcb6bfc52ff84ba1cfb66d714942f4891e0"sv}, Entry{"v1-022500-023000-transactions.seg"sv, "059d44a055e4b26df581e1600b4cd3da5fe45ccc"sv}, Entry{"v1-023000-023500-bodies.idx"sv, "ddbeac41c6b626dc615b494be049b547d84c45d7"sv}, Entry{"v1-023000-023500-bodies.seg"sv, "c1d797dafbd0eb1888d8b84af880612527b0daca"sv}, Entry{"v1-023000-023500-borevents.idx"sv, "75c11746429df34f1323d12cb30bd7a8de483225"sv}, Entry{"v1-023000-023500-borevents.seg"sv, "8368333ba3c1da13e138d5259a01e9ff8d853946"sv}, Entry{"v1-023000-023500-borspans.idx"sv, "37bd4fc1ff4fe0d575433210864055909d1b6875"sv}, Entry{"v1-023000-023500-borspans.seg"sv, "8bd8d9d45e97dd170599ccd3fe01c73338047678"sv}, Entry{"v1-023000-023500-headers.idx"sv, "2739ad723579f09dcef6039203f216865f968107"sv}, Entry{"v1-023000-023500-headers.seg"sv, "4b3e30f41a707eaa436e8eeedbce63eabe7be0e9"sv}, Entry{"v1-023000-023500-transactions-to-block.idx"sv, "5ca1473c9466ccfbd206e9384e363c2f3ffe091f"sv}, Entry{"v1-023000-023500-transactions.idx"sv, "1616b3366af1d5d4f2774f6579f0ced60743a9b7"sv}, Entry{"v1-023000-023500-transactions.seg"sv, "f5d21a32888ee0a80b692986807463ddafde2ee6"sv}, Entry{"v1-023500-024000-bodies.idx"sv, "426b727dee20164576de7593a0b85fd3fd086e8a"sv}, Entry{"v1-023500-024000-bodies.seg"sv, "7f8351d27d81b4dc0d9350cbc292c9451b389504"sv}, Entry{"v1-023500-024000-borevents.idx"sv, "c454c6d9a3d5240b472b6591f44106be80116850"sv}, Entry{"v1-023500-024000-borevents.seg"sv, "2655b78df1ee079ad22ad7f91a02b0fc4e7e4de0"sv}, Entry{"v1-023500-024000-borspans.idx"sv, "73fead22a4f31c28d926007ca3863f47255d5be0"sv}, Entry{"v1-023500-024000-borspans.seg"sv, "51cc8c2c9749259a4c2e6165272ca6fdecd49ad9"sv}, Entry{"v1-023500-024000-headers.idx"sv, "f3c23da2690dba344bb9083806d303d9f4d3bf05"sv}, Entry{"v1-023500-024000-headers.seg"sv, "cb7817576fed4da5136b032de76d453d3315cbd8"sv}, Entry{"v1-023500-024000-transactions-to-block.idx"sv, "d6afac88f42c23f3ebca03bf97e2292fe3d239a6"sv}, Entry{"v1-023500-024000-transactions.idx"sv, "6632b731c614e63e7ca5edadf37826f14f9b5ac5"sv}, Entry{"v1-023500-024000-transactions.seg"sv, "e37635f1d7325c35335e0d971ff1bf96ccdc0029"sv}, Entry{"v1-024000-024500-bodies.idx"sv, "0ad94fd0b22de04958743962f016da72a941b3ae"sv}, Entry{"v1-024000-024500-bodies.seg"sv, "996f5c5111d2a96ebc6b03dc8f42c840d2258982"sv}, Entry{"v1-024000-024500-borevents.idx"sv, "bc752cb19677207cd63c215adb6bf68a8deb1566"sv}, Entry{"v1-024000-024500-borevents.seg"sv, "6d595b46ba387db4ce5f7ae489fffef5caeb5d88"sv}, Entry{"v1-024000-024500-borspans.idx"sv, "ada9abfc1784b882286c25a90c22bac42862f6f2"sv}, Entry{"v1-024000-024500-borspans.seg"sv, "f99e03333c16728885bcdec87f33b248875c1c96"sv}, Entry{"v1-024000-024500-headers.idx"sv, "303edda036147e141eda30e2efc69b3f5e347bc6"sv}, Entry{"v1-024000-024500-headers.seg"sv, "64b082f309c68c0dafe027f6caeeb8683eda51d2"sv}, Entry{"v1-024000-024500-transactions-to-block.idx"sv, "cc5a516d9b4dd91575d65431ed4efc0a9719de34"sv}, Entry{"v1-024000-024500-transactions.idx"sv, "46fc8e028400c4c56758a7999e8a4f8928947bcd"sv}, Entry{"v1-024000-024500-transactions.seg"sv, "9a0127dbbd1e80004571cd304aef7748ea46ec2a"sv}, Entry{"v1-024500-025000-bodies.idx"sv, "59069c1f89b820cd0805474b63ad383c3dc77c73"sv}, Entry{"v1-024500-025000-bodies.seg"sv, "9f99b7cfabe290336ada1e9fc81ecf8f868510cb"sv}, Entry{"v1-024500-025000-borevents.idx"sv, "af9d8fe6e5326d19199a075cbf068dd5a1556f7c"sv}, Entry{"v1-024500-025000-borevents.seg"sv, "54d6a45e6ba0a08f3c9b20446863ce8cd0b1259e"sv}, Entry{"v1-024500-025000-borspans.idx"sv, "b336cd190b158ece66f604510272906ecaf17920"sv}, Entry{"v1-024500-025000-borspans.seg"sv, "eeb3ef8b12cab2f44cdb091038da5fd00813f943"sv}, Entry{"v1-024500-025000-headers.idx"sv, "c4531540bbca803a011fbd2438be9ec20b07eec7"sv}, Entry{"v1-024500-025000-headers.seg"sv, "ee9fe99a050f0127c52e5bf9f63592f8a3254577"sv}, Entry{"v1-024500-025000-transactions-to-block.idx"sv, "567fdd9f82733fe3c2f340ed29c683119a26101e"sv}, Entry{"v1-024500-025000-transactions.idx"sv, "d9ffc682bb2bed4e1484677c72035761bd02c397"sv}, Entry{"v1-024500-025000-transactions.seg"sv, "4a71c43a3e3fe4835bdc73679278e434adab1182"sv}, Entry{"v1-025000-025500-bodies.idx"sv, "c8f89c0c6c8b555b2266ec2512e481a052042125"sv}, Entry{"v1-025000-025500-bodies.seg"sv, "c4ac8f2c08fa8ffe3c365abfd92c5e7275a42d7c"sv}, Entry{"v1-025000-025500-borevents.idx"sv, "fe58e5120c8c40ca72043dfc06dfbd34934a8c32"sv}, Entry{"v1-025000-025500-borevents.seg"sv, "74041f57d346ea263dc61d729160d7b3c7164d7f"sv}, Entry{"v1-025000-025500-borspans.idx"sv, "99c170e20a6aa13a2ec1bca5b699a22b28b95d23"sv}, Entry{"v1-025000-025500-borspans.seg"sv, "24c8e789a53bc980a9178da0cf99a9d6c89faf72"sv}, Entry{"v1-025000-025500-headers.idx"sv, "e66ca41558ba94540446df0674d254586e32b733"sv}, Entry{"v1-025000-025500-headers.seg"sv, "7a1d6f98b2ba0757bfeb6c803bd09d6c525a5f8d"sv}, Entry{"v1-025000-025500-transactions-to-block.idx"sv, "ff744c916dd3a1e21cfc0ae7ef7376ddc59a3231"sv}, Entry{"v1-025000-025500-transactions.idx"sv, "13c49b88badbfc0546fd8bedbcb08ed46f40e0cb"sv}, Entry{"v1-025000-025500-transactions.seg"sv, "954020629cd2512c0f3cad6aa680bb5f70b31ce8"sv}, Entry{"v1-025500-026000-bodies.idx"sv, "f04483161670e8fe65f322b1f5dbcdf43b9f385c"sv}, Entry{"v1-025500-026000-bodies.seg"sv, "d534a4fec593cdabc8751ae6484148aa1ceae4a0"sv}, Entry{"v1-025500-026000-borevents.idx"sv, "88b0a998ff7299cfea6168481a938472cd2c9f2c"sv}, Entry{"v1-025500-026000-borevents.seg"sv, "72454f49b8e09e1b10495140ef78f39cd97b21d9"sv}, Entry{"v1-025500-026000-borspans.idx"sv, "2dd95f90ab1510e4f028be70b8e0fa7bc5617061"sv}, Entry{"v1-025500-026000-borspans.seg"sv, "fa4745b9342ade2ce3b09ccb55362118798a73a8"sv}, Entry{"v1-025500-026000-headers.idx"sv, "85b18052eb8f825c9506747d559ab4590a661525"sv}, Entry{"v1-025500-026000-headers.seg"sv, "d8a9f8172fdab95cbe59cf52a4a4e50c640d7782"sv}, Entry{"v1-025500-026000-transactions-to-block.idx"sv, "3f22aa43141b089095375c771d8dd4e44e446708"sv}, Entry{"v1-025500-026000-transactions.idx"sv, "49c6901f41e6741ff510baafcbe0b274a098e50c"sv}, Entry{"v1-025500-026000-transactions.seg"sv, "4e3607731ba837616667b48f452b98af0acb5be3"sv}, Entry{"v1-026000-026500-bodies.idx"sv, "a554ce7480815e105b9c69f6b4731fd391e19470"sv}, Entry{"v1-026000-026500-bodies.seg"sv, "2dcb4f1e949920f55863d2e2b8cde1fc89252564"sv}, Entry{"v1-026000-026500-borevents.idx"sv, "f90ad4da8fb7f6907386900ba65289f12a20056a"sv}, Entry{"v1-026000-026500-borevents.seg"sv, "c23db3cf7d6904886ccf1fba2bfd7e524088ede3"sv}, Entry{"v1-026000-026500-borspans.idx"sv, "8de4fd6759b62d42abd481b6a3b7cba5e41c3c86"sv}, Entry{"v1-026000-026500-borspans.seg"sv, "8106694509e33cb64935ee542559510d4e8de29f"sv}, Entry{"v1-026000-026500-headers.idx"sv, "ae4f50faaef8508c9abbbd9bf67298430189b967"sv}, Entry{"v1-026000-026500-headers.seg"sv, "e26fcf1b2a9438baf50813df36d9921f2a8ba7c2"sv}, Entry{"v1-026000-026500-transactions-to-block.idx"sv, "6463901d1ca05b5d8db656da3ddda80b3f49a9d8"sv}, Entry{"v1-026000-026500-transactions.idx"sv, "cd88564241f5f699e0b36d1d164cfaed05f95752"sv}, Entry{"v1-026000-026500-transactions.seg"sv, "448655f9924d32335664ff48c188a9f02484f4ca"sv}, Entry{"v1-026500-027000-bodies.idx"sv, "bfaedb8a0c55f17ccd235fa729956f60a81c3531"sv}, Entry{"v1-026500-027000-bodies.seg"sv, "088d86a11ba6dcdfeda5133172f70916e27090b8"sv}, Entry{"v1-026500-027000-borevents.idx"sv, "839b92940c0747075e20c6ba6e37b8e9596206b7"sv}, Entry{"v1-026500-027000-borevents.seg"sv, "588b55f270cc7720ebad30ac43b8f712cadcb1ab"sv}, Entry{"v1-026500-027000-borspans.idx"sv, "aea1d22722900d1def57a609429d592a5fc86701"sv}, Entry{"v1-026500-027000-borspans.seg"sv, "09af5139c4420b82ae6a9f13dcf81674635805ea"sv}, Entry{"v1-026500-027000-headers.idx"sv, "96ff344d0a6a2bbc7d9c788bc676dad8e67511b6"sv}, Entry{"v1-026500-027000-headers.seg"sv, "d93d7481bc4022df6daf9234250045f398749c2e"sv}, Entry{"v1-026500-027000-transactions-to-block.idx"sv, "f5d741321e7381956c687c545a4f091b38550e1f"sv}, Entry{"v1-026500-027000-transactions.idx"sv, "fa8b32c379c3e2361cb545c7936a816d4a5e69b9"sv}, Entry{"v1-026500-027000-transactions.seg"sv, "4dfe4fde023812b570b27addebc6917ef67b45f5"sv}, Entry{"v1-027000-027500-bodies.idx"sv, "f2740853f4d2b2e1048c7b15d80b4b3ffef159ee"sv}, Entry{"v1-027000-027500-bodies.seg"sv, "773cb60eaae08aeba817c429fcebc66a8f24c30c"sv}, Entry{"v1-027000-027500-borevents.idx"sv, "59f2fc59ab086bc7b67622b9428f8e38b94cab58"sv}, Entry{"v1-027000-027500-borevents.seg"sv, "5fc8291c86f14b3a96c2c9ddb0f9c4c66f93c0a6"sv}, Entry{"v1-027000-027500-borspans.idx"sv, "d3d6d0fafe439c94b123689f057fe064fdaaa450"sv}, Entry{"v1-027000-027500-borspans.seg"sv, "d1b3ca0cf0c2362177a582cd09c0167b941b926d"sv}, Entry{"v1-027000-027500-headers.idx"sv, "06cd30983ffd25168f683b152ebcc12bb90eb9a9"sv}, Entry{"v1-027000-027500-headers.seg"sv, "b7838da9704c2c2fa53e85ff28bc9abb8792b40c"sv}, Entry{"v1-027000-027500-transactions-to-block.idx"sv, "11d0601859d7b30b4852a04fbf1fb26545cd13bd"sv}, Entry{"v1-027000-027500-transactions.idx"sv, "747ff64a0cf2d592891b3c0c227f59479da84836"sv}, Entry{"v1-027000-027500-transactions.seg"sv, "376d13256a4697e29bd08347f4691537f45eba5f"sv}, Entry{"v1-027500-028000-bodies.idx"sv, "e7bacde2fcef7eff0bdf8bcb79c7d113aac1be57"sv}, Entry{"v1-027500-028000-bodies.seg"sv, "28faa4751236cde5fe4f69255d2079dbd7415449"sv}, Entry{"v1-027500-028000-borevents.idx"sv, "97631af75b85f4a4d7477940fe3b687c123af239"sv}, Entry{"v1-027500-028000-borevents.seg"sv, "4c48884e2f2f1562f20a78e9c137a4577c0e8f6d"sv}, Entry{"v1-027500-028000-borspans.idx"sv, "172c6bc237635751722cbe1171d4ae020a1df03a"sv}, Entry{"v1-027500-028000-borspans.seg"sv, "9439ffff8e8185711da0d49d494dd9a7a7635556"sv}, Entry{"v1-027500-028000-headers.idx"sv, "bd45d02ea6ba59f777d949409cde34492012e614"sv}, Entry{"v1-027500-028000-headers.seg"sv, "dcaf769f3c68c4e0849b7ab7f7f9e2a81e6f6f60"sv}, Entry{"v1-027500-028000-transactions-to-block.idx"sv, "2f634138a98f4c3064f2e49f1d221be2ec136d53"sv}, Entry{"v1-027500-028000-transactions.idx"sv, "5aaa86058d9be309703a9790f9c294d5e3b35a43"sv}, Entry{"v1-027500-028000-transactions.seg"sv, "2dbee3e1d7ad41408f2f7a71750c096fb4457e48"sv}, Entry{"v1-028000-028500-bodies.idx"sv, "67067d75ceef93bd63ebadcb8f88793f042d86b7"sv}, Entry{"v1-028000-028500-bodies.seg"sv, "04c4b00348c433baeb78ee325c0e17a6a98700da"sv}, Entry{"v1-028000-028500-borevents.idx"sv, "21f16c7a55094d6bb61b8f59d2d28d95b0174c87"sv}, Entry{"v1-028000-028500-borevents.seg"sv, "a118a3df26cea9dc8295e3a768c687ef9683d432"sv}, Entry{"v1-028000-028500-borspans.idx"sv, "1df0ddf56b1ef194a441141979d724fcd0621c9a"sv}, Entry{"v1-028000-028500-borspans.seg"sv, "35f352740968ea37733972885b25d035a085010d"sv}, Entry{"v1-028000-028500-headers.idx"sv, "f833ce650193198468ca3094c708b6f826bff277"sv}, Entry{"v1-028000-028500-headers.seg"sv, "fc251c57b565ee3632d1f5b1ee474832aec2e521"sv}, Entry{"v1-028000-028500-transactions-to-block.idx"sv, "27a8019c034b9ac519eaa25f73f22b4479d1e818"sv}, Entry{"v1-028000-028500-transactions.idx"sv, "2f65ef623edde5b64b0170488092483d5a0a2a6f"sv}, Entry{"v1-028000-028500-transactions.seg"sv, "9ef7d320952a30c87cbca8fd73397ead84d58548"sv}, Entry{"v1-028500-029000-bodies.idx"sv, "dd41957884533c7b54aad9f99b80c95b492bf606"sv}, Entry{"v1-028500-029000-bodies.seg"sv, "934d76ccee089062ff9f2ecf55357539833dfbe1"sv}, Entry{"v1-028500-029000-borevents.idx"sv, "ce0bcf13633720b29ef50094351e09a3ed4ff80a"sv}, Entry{"v1-028500-029000-borevents.seg"sv, "47bd11e6cf971666c7d0aec992271c0234f06c2b"sv}, Entry{"v1-028500-029000-borspans.idx"sv, "cbf1322446bad09d9bb9495cb6963ad905d3ab93"sv}, Entry{"v1-028500-029000-borspans.seg"sv, "5dc8b8d2a7135f64cddb81e9f0a16f2ec4a07523"sv}, Entry{"v1-028500-029000-headers.idx"sv, "5876f59c29df83ee17b49896a50125394c550b47"sv}, Entry{"v1-028500-029000-headers.seg"sv, "a52c613df081343f203fe4c0bcc2998339bab6c1"sv}, Entry{"v1-028500-029000-transactions-to-block.idx"sv, "4b32c9b0def0a050739a0892f7d1994a0a4c5695"sv}, Entry{"v1-028500-029000-transactions.idx"sv, "fec57017b722d5132de78a2fa3f27fd8bfec8950"sv}, Entry{"v1-028500-029000-transactions.seg"sv, "868ed9ffc70a5c58685b6562693aa83e48325f47"sv}, Entry{"v1-029000-029500-bodies.idx"sv, "19c943aca28474978c9096abfff5a1cdbefa30c5"sv}, Entry{"v1-029000-029500-bodies.seg"sv, "016549077ed3027ea6983508a289af0cf8a5e748"sv}, Entry{"v1-029000-029500-borevents.idx"sv, "a92fb619bdd76afacb003a0ee4a83dfbdbfcbded"sv}, Entry{"v1-029000-029500-borevents.seg"sv, "d8ab09019c3eeeccccdea0f5cbe5292ea011d46f"sv}, Entry{"v1-029000-029500-borspans.idx"sv, "9a96f3e5e8d421b071c61e417f1647521d49a986"sv}, Entry{"v1-029000-029500-borspans.seg"sv, "aba9c260709dc356f7cbbabe1668aaff2fd44a70"sv}, Entry{"v1-029000-029500-headers.idx"sv, "00e8d89cab83a0e4e5997319d212482d7798c2e5"sv}, Entry{"v1-029000-029500-headers.seg"sv, "5c2d112d4b63cae942c8f936e7151d0a6a2ba7a9"sv}, Entry{"v1-029000-029500-transactions-to-block.idx"sv, "829c05715b4b1543c8fc37d643f255de48930417"sv}, Entry{"v1-029000-029500-transactions.idx"sv, "0959947bb0b5e73b458bad12c52361dedd962581"sv}, Entry{"v1-029000-029500-transactions.seg"sv, "fa848e5fd24e0e30ded926861ca206cc9a1aaaae"sv}, Entry{"v1-029500-030000-bodies.idx"sv, "416ed9e67c694634728b9bade99f704ac3274ef8"sv}, Entry{"v1-029500-030000-bodies.seg"sv, "1baec998eb19811e6bfe539b66083d2a307b6a68"sv}, Entry{"v1-029500-030000-borevents.idx"sv, "8e28480cf5f9aeb09c937730c4d72ebef7fcfad0"sv}, Entry{"v1-029500-030000-borevents.seg"sv, "93e61d41f999444596cd89c6f8978ef9b760268e"sv}, Entry{"v1-029500-030000-borspans.idx"sv, "8fda04ac7cdc810ff0e5cbc07893a9943044f3f1"sv}, Entry{"v1-029500-030000-borspans.seg"sv, "f76a92935197c5dbde7acfa68bdf3a0c5dc9a110"sv}, Entry{"v1-029500-030000-headers.idx"sv, "4eabadc9f15e78a448dbc926c6c582b71d2e8722"sv}, Entry{"v1-029500-030000-headers.seg"sv, "ca1ddc659baf88763e199d7996c4d128a9c4024d"sv}, Entry{"v1-029500-030000-transactions-to-block.idx"sv, "324178fac1adafc1a439416efc0eefe725c5f8e2"sv}, Entry{"v1-029500-030000-transactions.idx"sv, "e5fb426de9c3867f76007c8fb72542236e30fdcd"sv}, Entry{"v1-029500-030000-transactions.seg"sv, "60773432d85d21f93217dccc5724daba23107c64"sv}, Entry{"v1-030000-030500-bodies.idx"sv, "7091fd520f10236fc79c93204a072e17cd322835"sv}, Entry{"v1-030000-030500-bodies.seg"sv, "c835bb7c3cc1c7861f185b5d0faf1132d0ec7e1e"sv}, Entry{"v1-030000-030500-borevents.idx"sv, "82ea19f32b74750d1040dfbf0b35eee9f68bccca"sv}, Entry{"v1-030000-030500-borevents.seg"sv, "1ce34d38e23b0f0f916d15159484b5c67551601f"sv}, Entry{"v1-030000-030500-borspans.idx"sv, "b816533c36497ee61f729d73fa31a5d0149fc2b6"sv}, Entry{"v1-030000-030500-borspans.seg"sv, "8fcba71535575c10d2c2f96c4e6036970735fd28"sv}, Entry{"v1-030000-030500-headers.idx"sv, "c38e4c28b53d2a0ea3b3908c9bf3a3d964c021df"sv}, Entry{"v1-030000-030500-headers.seg"sv, "fa6602e456a4c60648a789560cee944c0927ce25"sv}, Entry{"v1-030000-030500-transactions-to-block.idx"sv, "d24d51e63dc4b5e7248abb8e5efb1a3daad2b811"sv}, Entry{"v1-030000-030500-transactions.idx"sv, "03800a94ba36253ca70128eeecfedf8dad3e5081"sv}, Entry{"v1-030000-030500-transactions.seg"sv, "877a497f0a00dd6f9ecae84dd0507ad0847ed785"sv}, Entry{"v1-030500-031000-bodies.idx"sv, "8f4529b7506745d03f070bd32e4ad3bfcdd5c735"sv}, Entry{"v1-030500-031000-bodies.seg"sv, "f10324b605b5a2a6c8da246ac990c6c578ada000"sv}, Entry{"v1-030500-031000-borevents.idx"sv, "523d4f93951946239bdb737a324cde175fa3293b"sv}, Entry{"v1-030500-031000-borevents.seg"sv, "54ee9992a10879e4dfbb79fdc39d7978028b5f91"sv}, Entry{"v1-030500-031000-borspans.idx"sv, "3b080107e503560ca36abba5c359816d388281a0"sv}, Entry{"v1-030500-031000-borspans.seg"sv, "a79b54c6ab0490e6813a88a3e2f97fe73cf1c743"sv}, Entry{"v1-030500-031000-headers.idx"sv, "d2dd92b17d98143b80c9f7cd4206e8c3ce74dc2a"sv}, Entry{"v1-030500-031000-headers.seg"sv, "35d0a2e078076f545644a1928f41f2dbb0607f5f"sv}, Entry{"v1-030500-031000-transactions-to-block.idx"sv, "fcbdf3469be678dc740b50dd3302595cb88cd668"sv}, Entry{"v1-030500-031000-transactions.idx"sv, "6d054f0c96ab4f4876ef5612acef9cbd1110f825"sv}, Entry{"v1-030500-031000-transactions.seg"sv, "d3e704693e0cc687c6129a1e12156cd7dc92f049"sv}, Entry{"v1-031000-031500-bodies.idx"sv, "e715957a64f4116384d8d56dfa3d6b20be8a92ca"sv}, Entry{"v1-031000-031500-bodies.seg"sv, "2fd8ccac1edd4e6e523a0573699a52301863fe9c"sv}, Entry{"v1-031000-031500-borevents.idx"sv, "32e3a24b59cbaae9714a3eb229b729253d50356f"sv}, Entry{"v1-031000-031500-borevents.seg"sv, "4d1b273196ddbd965ed465b2bf59685e536f81be"sv}, Entry{"v1-031000-031500-borspans.idx"sv, "e6eed2c59c6d01ebd26a0a62e3ca80af5ea577f8"sv}, Entry{"v1-031000-031500-borspans.seg"sv, "f10c4da4b18c291452c53dd7b72102afb559c31c"sv}, Entry{"v1-031000-031500-headers.idx"sv, "d3f598e0a4a48e6f4c5c7586960d989b74e27b47"sv}, Entry{"v1-031000-031500-headers.seg"sv, "4bfaeba1c8b9adc7a44895cdfc47b13a39efa8e6"sv}, Entry{"v1-031000-031500-transactions-to-block.idx"sv, "571005aed59fc7a3389fab8899d6d53f82a690e3"sv}, Entry{"v1-031000-031500-transactions.idx"sv, "73c73f1881e905c6fba69cb2d48dcb46846077e2"sv}, Entry{"v1-031000-031500-transactions.seg"sv, "12be4dafc87cc3137082ccfb1c4df908aed6c81e"sv}, Entry{"v1-031500-032000-bodies.idx"sv, "3662f04991e46eea8e25222f7224f81eef247fa1"sv}, Entry{"v1-031500-032000-bodies.seg"sv, "9f201ba951aca51cae7460de39f061cc0cae87b6"sv}, Entry{"v1-031500-032000-borevents.idx"sv, "5396d5e71c25a33aa302670bc4914c2226dfc5d4"sv}, Entry{"v1-031500-032000-borevents.seg"sv, "87e05920f256d645f4ae6dfbef6ed6cdd2d3d612"sv}, Entry{"v1-031500-032000-borspans.idx"sv, "3f8057f88c72bbf70c10151cb28a1ec870412c95"sv}, Entry{"v1-031500-032000-borspans.seg"sv, "bc8032ab094fea7a1595c0adf9939cb75d573e78"sv}, Entry{"v1-031500-032000-headers.idx"sv, "434f1ba4969333354c930825df15de96f18dea38"sv}, Entry{"v1-031500-032000-headers.seg"sv, "aaa63458a7ee7cc310d44123d49e097b484acfa4"sv}, Entry{"v1-031500-032000-transactions-to-block.idx"sv, "fffb80bbbd2042384a5543ad273ac8a1f4801e66"sv}, Entry{"v1-031500-032000-transactions.idx"sv, "fb009667afdf2c039988ef250dce31e42eaf94c3"sv}, Entry{"v1-031500-032000-transactions.seg"sv, "a982014e8bf9abb63c02351ca4899f4d1227b5b2"sv}, Entry{"v1-032000-032500-bodies.idx"sv, "57d51670250ceb153e92ca752734462150a75cf9"sv}, Entry{"v1-032000-032500-bodies.seg"sv, "786b5e1db0a5a6a9c3c60d5aae873ebc8c5b3764"sv}, Entry{"v1-032000-032500-borevents.idx"sv, "97d81a0411e8359c5429a63629887b5b9262eb56"sv}, Entry{"v1-032000-032500-borevents.seg"sv, "18b4adbfde7a51dab9379e1b66919ed444cc0dac"sv}, Entry{"v1-032000-032500-borspans.idx"sv, "cce574edeb52c114261b0539656fd0bf26dd5e21"sv}, Entry{"v1-032000-032500-borspans.seg"sv, "f8a35a98775185e6797b30820e797918d27a276e"sv}, Entry{"v1-032000-032500-headers.idx"sv, "878faa4174424c1b4b811012273922333bca56ba"sv}, Entry{"v1-032000-032500-headers.seg"sv, "2c938d89134a1d165716ff334622634d62a44d0a"sv}, Entry{"v1-032000-032500-transactions-to-block.idx"sv, "c3437e3fa5bbeb9004539a5ec4896942504c63d9"sv}, Entry{"v1-032000-032500-transactions.idx"sv, "5a194e3bd730dec7e7ef697e998cdb7e98895dae"sv}, Entry{"v1-032000-032500-transactions.seg"sv, "802e58cf1f72593112a246413cf47ca95a83596a"sv}, Entry{"v1-032500-033000-bodies.idx"sv, "33eea80504a5190fda37ac9454b9dcbc45ccc33c"sv}, Entry{"v1-032500-033000-bodies.seg"sv, "353d29dea12a3f0ce7838d5117d62eef460b2bf4"sv}, Entry{"v1-032500-033000-borevents.idx"sv, "85231e0f0d80df20f9ff80a645c3956f695aaabe"sv}, Entry{"v1-032500-033000-borevents.seg"sv, "f1ad75127fe1d7ab9d74f051f7271a58d34cb03e"sv}, Entry{"v1-032500-033000-borspans.idx"sv, "efa799927025e314679ae59954ed2b60722191c0"sv}, Entry{"v1-032500-033000-borspans.seg"sv, "690d53e8bace5a591a39ea77ed4d1fb85c3b316e"sv}, Entry{"v1-032500-033000-headers.idx"sv, "8d7de2ea12c75434716cd37504c7672399833188"sv}, Entry{"v1-032500-033000-headers.seg"sv, "f1c2c7c4452578d07db68a54fe6caca9248d8ff1"sv}, Entry{"v1-032500-033000-transactions-to-block.idx"sv, "b6ce07fb8b10f21c058d614be0d7dd2d1793ff50"sv}, Entry{"v1-032500-033000-transactions.idx"sv, "dc830ffc8e5a62bd0e42c9112a1f222e452cf295"sv}, Entry{"v1-032500-033000-transactions.seg"sv, "6bea9e9a0629509afd2781a02064f52a570a34e9"sv}, Entry{"v1-033000-033500-bodies.idx"sv, "eec7f8776a7808bb8a5b527dfbdb8f31b3aa24ff"sv}, Entry{"v1-033000-033500-bodies.seg"sv, "e0fc9471527eae5c485c632819a17b95c75ede0e"sv}, Entry{"v1-033000-033500-borevents.idx"sv, "f24a28a94b4804dd05fa69739c9b4d2dbbf71617"sv}, Entry{"v1-033000-033500-borevents.seg"sv, "a34da080489680ca8a23a6b757e1a849b37c4a12"sv}, Entry{"v1-033000-033500-borspans.idx"sv, "3a0c1b0bee21d1f312c47c98aca22c4301cdd553"sv}, Entry{"v1-033000-033500-borspans.seg"sv, "8b06c201cf335c292ab95f96eb6aa91f162d43dd"sv}, Entry{"v1-033000-033500-headers.idx"sv, "b039dd5766ab4a093714dd6983bb335ebc8d6e0e"sv}, Entry{"v1-033000-033500-headers.seg"sv, "9f0c3f5e48f6acbd2f86fc3cfcca1ab660b6a6df"sv}, Entry{"v1-033000-033500-transactions-to-block.idx"sv, "fcbcc37c5c39e992d0315fb7e7fb67338a6c62de"sv}, Entry{"v1-033000-033500-transactions.idx"sv, "bb1a3e7bfd25289d3f9c64ecbff901d70b4b92d2"sv}, Entry{"v1-033000-033500-transactions.seg"sv, "ac59d0215a174bab35ccd3fe275d73f765c676d2"sv}, Entry{"v1-033500-034000-bodies.idx"sv, "fe55cb864a2abcce4c9c96b4336a173414f6df8c"sv}, Entry{"v1-033500-034000-bodies.seg"sv, "2458c5c063e33887bba29472817cef406d9b4b00"sv}, Entry{"v1-033500-034000-borevents.idx"sv, "3ef8b75ed27f1550d2fddf8292d35dedaaec1af4"sv}, Entry{"v1-033500-034000-borevents.seg"sv, "b06b74b49b9214b9539ba26bcbe94cb89318dc6a"sv}, Entry{"v1-033500-034000-borspans.idx"sv, "d434a818825d3ebe44ae281ac32e52bc831fb6a2"sv}, Entry{"v1-033500-034000-borspans.seg"sv, "569b65c2cf488d9b856592eb9c1d943f5295b0d6"sv}, Entry{"v1-033500-034000-headers.idx"sv, "29af86bcf5635db02d68ec83ababa51d738a99c9"sv}, Entry{"v1-033500-034000-headers.seg"sv, "7a4ffff85d80a406629af1763c2c428cdd142dd8"sv}, Entry{"v1-033500-034000-transactions-to-block.idx"sv, "3e17c9be8355e19deea4be00e02015e1cb16f8a0"sv}, Entry{"v1-033500-034000-transactions.idx"sv, "7b4bd60aabc17e0bfcd9cfa03916f1db12acea14"sv}, Entry{"v1-033500-034000-transactions.seg"sv, "f56c94513904d0068b3e4f9be6f762c4391ee871"sv}, Entry{"v1-034000-034500-bodies.idx"sv, "c2ff6abe0d6f317bb00121ab1b14f341abcf69c6"sv}, Entry{"v1-034000-034500-bodies.seg"sv, "6b5d7a250e77e4a3f38f5334f21f704e250b99ac"sv}, Entry{"v1-034000-034500-borevents.idx"sv, "e3ffc79e27561418e208ea5852df13f33924abf5"sv}, Entry{"v1-034000-034500-borevents.seg"sv, "9c1aaf8c96828613f00c3d063dabd566b8d2ea1a"sv}, Entry{"v1-034000-034500-borspans.idx"sv, "2fec479722ceca5a3623eb596340e16dfa00f913"sv}, Entry{"v1-034000-034500-borspans.seg"sv, "48d3f98e75c388aafaed3489f450e62c973a1fa5"sv}, Entry{"v1-034000-034500-headers.idx"sv, "d33cec8bfcaecff144a6378199b7836040b7fb85"sv}, Entry{"v1-034000-034500-headers.seg"sv, "4f7c134d273add0ac054d5877e0d5c70decdade0"sv}, Entry{"v1-034000-034500-transactions-to-block.idx"sv, "bcd2b6d2243f5347010e18eb75e3d5f186fea2d0"sv}, Entry{"v1-034000-034500-transactions.idx"sv, "c31141f59cdc0467f038f9555b833f2c0eaa7a93"sv}, Entry{"v1-034000-034500-transactions.seg"sv, "85eb8b9f7663c57a027d3ae11c6e9a94442ca805"sv}, Entry{"v1-034500-035000-bodies.idx"sv, "e9d30cde6078fb8337267110e1051485ecb1704a"sv}, Entry{"v1-034500-035000-bodies.seg"sv, "ab976a84d38db3b100e26f44dbe8b263716ed921"sv}, Entry{"v1-034500-035000-borevents.idx"sv, "1bd610bfc8a2439fa87e15a767000964bbec21e7"sv}, Entry{"v1-034500-035000-borevents.seg"sv, "5b4e80e2c15f78ec87e05e6fc10db9bce7facaa9"sv}, Entry{"v1-034500-035000-borspans.idx"sv, "e8d53177feb6a507032890e22dad9b8bff83b303"sv}, Entry{"v1-034500-035000-borspans.seg"sv, "81f81414a71f9dc19d57c45238f44975a9acfa4d"sv}, Entry{"v1-034500-035000-headers.idx"sv, "82b7354ac8d9abf93d5f6fb6ba5a44fb014351a3"sv}, Entry{"v1-034500-035000-headers.seg"sv, "1a78d36927c2aedc8d1e16d6aa20d52e52c7c3a8"sv}, Entry{"v1-034500-035000-transactions-to-block.idx"sv, "22c7f1f9de584626eb737964cd7d939cf6f410b1"sv}, Entry{"v1-034500-035000-transactions.idx"sv, "f2bdd5a6afe65c473f34e20e0b0ead9ab92335cb"sv}, Entry{"v1-034500-035000-transactions.seg"sv, "18390128ecf165358222f6837aca97020a5a3fd7"sv}, Entry{"v1-035000-035500-bodies.idx"sv, "f4a4fd0d60820dec466bd031d068240e36711ce8"sv}, Entry{"v1-035000-035500-bodies.seg"sv, "4a1a93cd748d25ffabcf8c6dc5017fdcc0357216"sv}, Entry{"v1-035000-035500-borevents.idx"sv, "6c4c58731882c0ef077b1173466316d055f2bb8b"sv}, Entry{"v1-035000-035500-borevents.seg"sv, "ff98a2e66255aa2ebb9bce83e494290ccb59b986"sv}, Entry{"v1-035000-035500-borspans.idx"sv, "880627df2c7232d99e0ca804d5c02af1d19d0a42"sv}, Entry{"v1-035000-035500-borspans.seg"sv, "17ca6a06825a01f3bd834b2d8f52b13e7325dfca"sv}, Entry{"v1-035000-035500-headers.idx"sv, "fe97fe9f8ac0f29162f811feb76e7cec0a9a0b44"sv}, Entry{"v1-035000-035500-headers.seg"sv, "5ffcfe61cd35231dc2d10f2cfaa1f3bd8ebce9d1"sv}, Entry{"v1-035000-035500-transactions-to-block.idx"sv, "443c9f79769834d38e5da440acfa56db39c46d08"sv}, Entry{"v1-035000-035500-transactions.idx"sv, "3cbcffebde7a081f59a5d236dcd45947987d5eb7"sv}, Entry{"v1-035000-035500-transactions.seg"sv, "eb0fc03294835812ce2d281119926d979819462b"sv}, Entry{"v1-035500-036000-bodies.idx"sv, "f8b125696aeb8e856aff53d2ebc6644a099bc682"sv}, Entry{"v1-035500-036000-bodies.seg"sv, "096bc73b63da28515a5b37d4d8561ebc3f28cd10"sv}, Entry{"v1-035500-036000-borevents.idx"sv, "9387dc92cfc5424b4453da31a6b89304a202486a"sv}, Entry{"v1-035500-036000-borevents.seg"sv, "263cd9b2e6d79741a050e07df03b79a3319ec172"sv}, Entry{"v1-035500-036000-borspans.idx"sv, "c6ec028e4d3b037b81fde874c2b71f9c38c9ebfc"sv}, Entry{"v1-035500-036000-borspans.seg"sv, "d7ab64323fb302b85dfc9ecbfea73693117234fd"sv}, Entry{"v1-035500-036000-headers.idx"sv, "7810e01bdca4bc8b7eb23e430a8a4e8d0d07aeff"sv}, Entry{"v1-035500-036000-headers.seg"sv, "d4d8668d6d3541e4f7b9a627e8c70f546b96e630"sv}, Entry{"v1-035500-036000-transactions-to-block.idx"sv, "694722b8d9d919e7867955fb433af21aaedc1042"sv}, Entry{"v1-035500-036000-transactions.idx"sv, "85fc27e35d48185a1e0eccb21a22ef112fd7c6ca"sv}, Entry{"v1-035500-036000-transactions.seg"sv, "f9f8fea0415494f1cb61cf8116fe8a94cdc33333"sv}, Entry{"v1-036000-036500-bodies.idx"sv, "002881c81037ffb6e0f4eb449bd9266298714876"sv}, Entry{"v1-036000-036500-bodies.seg"sv, "cdc8eab66742dd30e3ad6a98f5d702f2fb65f4ea"sv}, Entry{"v1-036000-036500-borevents.idx"sv, "8c10738ab84e1799c00fdd18da55f4fec2c5ca69"sv}, Entry{"v1-036000-036500-borevents.seg"sv, "a94773a08ec3cecece742047780354bb5bf30e50"sv}, Entry{"v1-036000-036500-borspans.idx"sv, "be12b9f1a75ef2b2f61747263cfc7f8c72078f48"sv}, Entry{"v1-036000-036500-borspans.seg"sv, "a6aecf279860417384db9968e09835a2774cc0b4"sv}, Entry{"v1-036000-036500-headers.idx"sv, "45294ee3bbf7732e42d034367fce7d4459d2b295"sv}, Entry{"v1-036000-036500-headers.seg"sv, "976ed43398df0dfb8e670044c228e3d79540a365"sv}, Entry{"v1-036000-036500-transactions-to-block.idx"sv, "1d1c95a573a675f3fa2a1b28c6bc1a49028cd2d4"sv}, Entry{"v1-036000-036500-transactions.idx"sv, "7cc9e1fec5f1e497a7b8b4d426ee085e1ba0886a"sv}, Entry{"v1-036000-036500-transactions.seg"sv, "11ee4da90da9a674052458a71bff62b6f828e38a"sv}, Entry{"v1-036500-037000-bodies.idx"sv, "7ab8c20b5af0e8c88d4affee1dd9758292be1b7c"sv}, Entry{"v1-036500-037000-bodies.seg"sv, "bd258c06d4d6eb29cb35e5c237fb3ad208049512"sv}, Entry{"v1-036500-037000-borevents.idx"sv, "36f4e33dd8e9c5d15248742c85c7274d76dcb4a1"sv}, Entry{"v1-036500-037000-borevents.seg"sv, "73326239a643145a961475975215e2b4f807379c"sv}, Entry{"v1-036500-037000-borspans.idx"sv, "cfb03893b08cce2fa9cce53d1f464e15ee307a23"sv}, Entry{"v1-036500-037000-borspans.seg"sv, "1852289c95777500e7bd22cab87a4cc93d0c0d2f"sv}, Entry{"v1-036500-037000-headers.idx"sv, "1526822d063fda2f9f740f6acdf13e73d8df5289"sv}, Entry{"v1-036500-037000-headers.seg"sv, "af404ebf10775f295660a0dca6ee9ff074e752ea"sv}, Entry{"v1-036500-037000-transactions-to-block.idx"sv, "c1f30919b7061495ab74085e776e3e0a837174e4"sv}, Entry{"v1-036500-037000-transactions.idx"sv, "9f8bf2c077718f99457a5a6832b9b8e1905b4eaf"sv}, Entry{"v1-036500-037000-transactions.seg"sv, "1099f99d87e0e4add0c801104f77444e30b88ac8"sv}, Entry{"v1-037000-037500-bodies.idx"sv, "c62c6cf588ecbd4ae869df6b4361d0d352a320e9"sv}, Entry{"v1-037000-037500-bodies.seg"sv, "c76721f6a1ee2bda4f7abe0ea54e329b45095149"sv}, Entry{"v1-037000-037500-borevents.idx"sv, "36238e9adb479487b026697b50a9ba43535329b8"sv}, Entry{"v1-037000-037500-borevents.seg"sv, "629fd7c52865a1727558f2ac2fae727ab00fd3d1"sv}, Entry{"v1-037000-037500-borspans.idx"sv, "cd1a66d309943b47ee883c80597b2f70b7596072"sv}, Entry{"v1-037000-037500-borspans.seg"sv, "5e385ee6b534d56a7342e3310353f9a68dfd3bd3"sv}, Entry{"v1-037000-037500-headers.idx"sv, "2bd03f4e6da4738fc0757fcf4233fcadd90e6e1a"sv}, Entry{"v1-037000-037500-headers.seg"sv, "a6bf2c717c2ccdc0a5d7544b09311c735cd57e3a"sv}, Entry{"v1-037000-037500-transactions-to-block.idx"sv, "2dbe400e5b424d1c83fc188bda5145ed8af2fc74"sv}, Entry{"v1-037000-037500-transactions.idx"sv, "603d1281ea8d0c13f1f9d525f6b7408f803043df"sv}, Entry{"v1-037000-037500-transactions.seg"sv, "3f2a10f6fd2e67cef0d5af2f3f8557618b780189"sv}, Entry{"v1-037500-038000-bodies.idx"sv, "43a82f1cbed1609176170b062d279974ecbfcabe"sv}, Entry{"v1-037500-038000-bodies.seg"sv, "038a599195b6bedfee016336236f91c2be2e51cd"sv}, Entry{"v1-037500-038000-borevents.idx"sv, "72d5d08f55bed2b0b099e667a6116e4a3da91f9c"sv}, Entry{"v1-037500-038000-borevents.seg"sv, "b08f5c16691cd4959ff471b016918d6565fe9bc6"sv}, Entry{"v1-037500-038000-borspans.idx"sv, "7eef3449e2d02c36d1450bf9a6d8f85850dbd6be"sv}, Entry{"v1-037500-038000-borspans.seg"sv, "243e11087429194ed76628b1504ff4576a26b9f1"sv}, Entry{"v1-037500-038000-headers.idx"sv, "891bb202aed0b50bb8960230e0aa3985a08aff56"sv}, Entry{"v1-037500-038000-headers.seg"sv, "35ec02aa0136e87f58d00ed8fb95e012be0d2f33"sv}, Entry{"v1-037500-038000-transactions-to-block.idx"sv, "0bc84dc23260032b1490a62e060bcb38897c0e2e"sv}, Entry{"v1-037500-038000-transactions.idx"sv, "0e509bd186e7102d635c9421ca46a3c39f12a59e"sv}, Entry{"v1-037500-038000-transactions.seg"sv, "2df14b0433bb4a607bb054dc78a3b260b1997837"sv}, Entry{"v1-038000-038500-bodies.idx"sv, "756cfa37d0516183f56ceeb81b7d1dd757d5bc9c"sv}, Entry{"v1-038000-038500-bodies.seg"sv, "9b01d823d956d1d0fb07ca2be8b7a21cbe658067"sv}, Entry{"v1-038000-038500-borevents.idx"sv, "f359a65ae63ed7120454a93756192c84a47697c9"sv}, Entry{"v1-038000-038500-borevents.seg"sv, "2968e5fc01ff1c63897e41de77f83fc323079956"sv}, Entry{"v1-038000-038500-borspans.idx"sv, "4186dde0db57de58a3b442ef1d7a65417819301e"sv}, Entry{"v1-038000-038500-borspans.seg"sv, "5e63d1b93eda594c72b109e222a295ba85096c8c"sv}, Entry{"v1-038000-038500-headers.idx"sv, "ea3ebdbd30582301c6bdfa336b04b9a14c48630d"sv}, Entry{"v1-038000-038500-headers.seg"sv, "a9684c818caf35a0c7b596071e9cb41ba08ae5d0"sv}, Entry{"v1-038000-038500-transactions-to-block.idx"sv, "a6ac54f836754c19eb36563623177c7b124f2bd5"sv}, Entry{"v1-038000-038500-transactions.idx"sv, "c75cb29e250988f9d35bcae2152d23d032670031"sv}, Entry{"v1-038000-038500-transactions.seg"sv, "1f17972b82dcc7c9a3eea912c2cfe051179b0c30"sv}, Entry{"v1-038500-039000-bodies.idx"sv, "72bc44b82abc31281459647cbe5418685a938ebc"sv}, Entry{"v1-038500-039000-bodies.seg"sv, "97d5355e9ee5f2eaff5b59bee07bd3731e00ab6f"sv}, Entry{"v1-038500-039000-borevents.idx"sv, "71ef0f93c3577644e970153b151e9e48dae7a7cc"sv}, Entry{"v1-038500-039000-borevents.seg"sv, "17bbf04184963eb434073d5dde858fc29d3f4d3f"sv}, Entry{"v1-038500-039000-borspans.idx"sv, "5ef5af975a0bdd924ac9820973770b244d05b95c"sv}, Entry{"v1-038500-039000-borspans.seg"sv, "a5aac1d46eb67c8fc1ce32f00f7262be969900a2"sv}, Entry{"v1-038500-039000-headers.idx"sv, "619422492fdc09e7453b2d1480dd6be83f0b766e"sv}, Entry{"v1-038500-039000-headers.seg"sv, "92dc68d896a3cdbd5e1ea5a8962e26a343f613d1"sv}, Entry{"v1-038500-039000-transactions-to-block.idx"sv, "dc353e8081e3cbaea31642f75949c5feb0a4b1cd"sv}, Entry{"v1-038500-039000-transactions.idx"sv, "abacbc3d84b5597cf08b79e024f4e9734228cb83"sv}, Entry{"v1-038500-039000-transactions.seg"sv, "a3ccfadf62df26df7044a8c463c42a75e0f79c83"sv}, Entry{"v1-039000-039500-bodies.idx"sv, "7ca058c6c091f4bfc6a04e4cde74c31db8ed8d86"sv}, Entry{"v1-039000-039500-bodies.seg"sv, "c7907a951738f1e3311e1163f39ef6f6b9e38a50"sv}, Entry{"v1-039000-039500-borevents.idx"sv, "ce281938a7999876c3e4b13e418aeb4c88cb9bde"sv}, Entry{"v1-039000-039500-borevents.seg"sv, "5be4f538540c55e5b4dfcc512f2071305e5c2da3"sv}, Entry{"v1-039000-039500-borspans.idx"sv, "b977b53c0989102ad0dbd9cebf5e0ac0d1170f12"sv}, Entry{"v1-039000-039500-borspans.seg"sv, "7a6acf7062d50b1df394698cf948652f74cf965e"sv}, Entry{"v1-039000-039500-headers.idx"sv, "201bb9529e2c62f74b04496db17b32a114fff674"sv}, Entry{"v1-039000-039500-headers.seg"sv, "509b1210dbcd42a432d4c4c21f05e9f332c2d682"sv}, Entry{"v1-039000-039500-transactions-to-block.idx"sv, "920fb62528e2a32294a9f5e147ea1ab905b482d6"sv}, Entry{"v1-039000-039500-transactions.idx"sv, "2f73a59e41524bcdd7a0b13587dc6a8b2e32a747"sv}, Entry{"v1-039000-039500-transactions.seg"sv, "5ca6e77a007c6b39ce9169c880ac4e9fa9210074"sv}, Entry{"v1-039500-040000-bodies.idx"sv, "ff990dbe7b07835be4085cb0131b0be194a7dc17"sv}, Entry{"v1-039500-040000-bodies.seg"sv, "35f8c816cad50665bfbf13d97d1c48a3ac6693a4"sv}, Entry{"v1-039500-040000-borevents.idx"sv, "5d24bd53b5d1ba8d4e1c89acf79e66cc9783a877"sv}, Entry{"v1-039500-040000-borevents.seg"sv, "516a5536c4910a4877b1d2fa816e71804c401b6d"sv}, Entry{"v1-039500-040000-borspans.idx"sv, "2b9f5bc88eef65942afb0925a7d8bd7ac437fd30"sv}, Entry{"v1-039500-040000-borspans.seg"sv, "79c1bbba7a4076c354a6b4a708c82b7098f89f40"sv}, Entry{"v1-039500-040000-headers.idx"sv, "a1917c3d6f0553dc2955ec91c7009f6cea60f20d"sv}, Entry{"v1-039500-040000-headers.seg"sv, "3df4980a509387aeae946ef5022481a7002defaa"sv}, Entry{"v1-039500-040000-transactions-to-block.idx"sv, "89fa3d79a7e676ee5c613e9426f02e111e3547f0"sv}, Entry{"v1-039500-040000-transactions.idx"sv, "9ed9e5d0c61e09066f58e6b03b73f7f242d3169b"sv}, Entry{"v1-039500-040000-transactions.seg"sv, "f4acfd1d056b05964de3dbf3998cd0f091d3f97f"sv}, Entry{"v1-040000-040500-bodies.idx"sv, "a34b01ca9a17150aa4fe91f45bf10e70a45530b6"sv}, Entry{"v1-040000-040500-bodies.seg"sv, "6b52bdc137b82cbca397dc61eb1608b987dddc97"sv}, Entry{"v1-040000-040500-borevents.idx"sv, "68eadaa97324cb8e01e107a86a17dd13f5d75b33"sv}, Entry{"v1-040000-040500-borevents.seg"sv, "509b881c2ba45103828af4b4a8104dee9de9baf0"sv}, Entry{"v1-040000-040500-borspans.idx"sv, "ab009dc73cdd2371f32efacee6a0f75638242578"sv}, Entry{"v1-040000-040500-borspans.seg"sv, "b697a3baa145337083c6873c84c533f4ddaf33c7"sv}, Entry{"v1-040000-040500-headers.idx"sv, "d1af9eb16202c7a85f494569049ceb78a622f5ff"sv}, Entry{"v1-040000-040500-headers.seg"sv, "09e8a51d6f06290a0b04a10e0f3cd35d228dcfa1"sv}, Entry{"v1-040000-040500-transactions-to-block.idx"sv, "bbb3787a064a72a7deff3832186d9201957b213a"sv}, Entry{"v1-040000-040500-transactions.idx"sv, "52f76179e36544c998974c7f49fdc317536ece35"sv}, Entry{"v1-040000-040500-transactions.seg"sv, "d41057c71c057205acaadf0cb7d9f66bd74785da"sv}, Entry{"v1-040500-041000-bodies.idx"sv, "e23cfdcd315037d849b8ae69e272288972319fe9"sv}, Entry{"v1-040500-041000-bodies.seg"sv, "7e27908cedfd468baaf2488b3329bf3ed822f293"sv}, Entry{"v1-040500-041000-borevents.idx"sv, "0df84627318daafa44244234580f537f06c1c53d"sv}, Entry{"v1-040500-041000-borevents.seg"sv, "283af122738a771edfc4d0cc5b6d083e227235d5"sv}, Entry{"v1-040500-041000-borspans.idx"sv, "7e6dabc31f2f5448634a9661a417715a260ce3a2"sv}, Entry{"v1-040500-041000-borspans.seg"sv, "d89175b7aed9dfa6519ec18e572551ce433e39f0"sv}, Entry{"v1-040500-041000-headers.idx"sv, "6f9a3e37d4d7c89bbd8010c13332862bda8cdf78"sv}, Entry{"v1-040500-041000-headers.seg"sv, "8a7c6f0a26da9e9469b241bee0f3c96a4dc94dc5"sv}, Entry{"v1-040500-041000-transactions-to-block.idx"sv, "4336532320cad32c5c7ac7b888dcad89a142e5a8"sv}, Entry{"v1-040500-041000-transactions.idx"sv, "b78643c2bd216f19ed5839506e7d91964afe9fb4"sv}, Entry{"v1-040500-041000-transactions.seg"sv, "3b31bceee60de93192b5e8809f578fea4be5d324"sv}, Entry{"v1-041000-041500-bodies.idx"sv, "d581f0dcd597f6da9461fabb107421f8c0c6bf18"sv}, Entry{"v1-041000-041500-bodies.seg"sv, "211f2c21235dffcdac2bd63353a08b78c2d82bed"sv}, Entry{"v1-041000-041500-borevents.idx"sv, "13723698eaa0161529c02bdcfea42f21295abd68"sv}, Entry{"v1-041000-041500-borevents.seg"sv, "002b402ca3db2f81d21feda0077a0ad114c395f1"sv}, Entry{"v1-041000-041500-borspans.idx"sv, "7cff759a9597c63b05582694fbb6b6a2304f3e12"sv}, Entry{"v1-041000-041500-borspans.seg"sv, "0d3151f6b69821067324d371eff6ef854c5648e1"sv}, Entry{"v1-041000-041500-headers.idx"sv, "c7e33506a1869e13bd7f3a3acbac4395f36c895c"sv}, Entry{"v1-041000-041500-headers.seg"sv, "2f5c0c0be80586e9e4c95d25eda15c42d053f3a4"sv}, Entry{"v1-041000-041500-transactions-to-block.idx"sv, "18ee0260c496af6fb9b9bb6a5b0c9df2c360c583"sv}, Entry{"v1-041000-041500-transactions.idx"sv, "0801888631edc979b15d452e53bd255bf29b8725"sv}, Entry{"v1-041000-041500-transactions.seg"sv, "81b84c1dd2835664ab3b3fd847bab3b04fc49db3"sv}, Entry{"v1-041500-042000-bodies.idx"sv, "092f43b5f39f3eed8e94a7f26fd2c08925a11f79"sv}, Entry{"v1-041500-042000-bodies.seg"sv, "8797d01495e3cf842f059aa9f7100a74267b817b"sv}, Entry{"v1-041500-042000-borevents.idx"sv, "a5ec7e12009c4ed114f0d979f56440d2980f545c"sv}, Entry{"v1-041500-042000-borevents.seg"sv, "72e54c49832ec91e837c6d8c7fb719e4b252de40"sv}, Entry{"v1-041500-042000-borspans.idx"sv, "fec2fdcbe1a78b2017c9df4bacbc4cb8d14bac71"sv}, Entry{"v1-041500-042000-borspans.seg"sv, "ef6175b96a76129d0d26a02e07fb5d2f8aa7a83d"sv}, Entry{"v1-041500-042000-headers.idx"sv, "d8b320574b358264e563f923638384c83dfdef9d"sv}, Entry{"v1-041500-042000-headers.seg"sv, "257549e4215c530b1a98b807137da4f63a937bc2"sv}, Entry{"v1-041500-042000-transactions-to-block.idx"sv, "18e6f5d3db04e4ca81fe216b57d26dbfab388fc0"sv}, Entry{"v1-041500-042000-transactions.idx"sv, "ae7cb69a48daf2dc1b18e3c4456a8cf6eb0c2e7e"sv}, Entry{"v1-041500-042000-transactions.seg"sv, "47e8197d1f8feb7d92096fb3f797f8a931679b53"sv}, Entry{"v1-042000-042500-bodies.idx"sv, "302397da244712c93cb4601c69c1125ce423797a"sv}, Entry{"v1-042000-042500-bodies.seg"sv, "e32001b5ffe6057cf853bd88e98ad0d026c49492"sv}, Entry{"v1-042000-042500-borevents.idx"sv, "c929daa425664e4d2d992cb024a764ebe2e517bf"sv}, Entry{"v1-042000-042500-borevents.seg"sv, "5910ec62503b1f4340095d4a9d0de7b835e46fad"sv}, Entry{"v1-042000-042500-borspans.idx"sv, "28397fe072d0a3305d339259e771f199dce2a867"sv}, Entry{"v1-042000-042500-borspans.seg"sv, "bb65ee8ef75b219338b063c78090d1ad81888928"sv}, Entry{"v1-042000-042500-headers.idx"sv, "8fbb5cd689b6d992812fbbf8027e241843f195ac"sv}, Entry{"v1-042000-042500-headers.seg"sv, "036ae75fe8f6d7b398d7819c46e23cdc445e4135"sv}, Entry{"v1-042000-042500-transactions-to-block.idx"sv, "0ec5054056379c254a72ccd9b8682bdf987def43"sv}, Entry{"v1-042000-042500-transactions.idx"sv, "1ee435395399cf3395b963413a435ce4d9cf362d"sv}, Entry{"v1-042000-042500-transactions.seg"sv, "ee49b20d86205eb015170609ca4f24b15e2e927e"sv}, Entry{"v1-042500-043000-bodies.idx"sv, "72abe4fc1f57b6efc8a4f93cc854c6db3c8acb65"sv}, Entry{"v1-042500-043000-bodies.seg"sv, "edbb2e3e5683b7dd3a1e995238e808987c2e6dc1"sv}, Entry{"v1-042500-043000-borevents.idx"sv, "328f66a405248425f1e27a1d774faa835cc834e0"sv}, Entry{"v1-042500-043000-borevents.seg"sv, "48bf195b6d056c71a69260152734df7cbb7d9962"sv}, Entry{"v1-042500-043000-borspans.idx"sv, "fdfd273dee25f408c97f4d1029eeb278a055380e"sv}, Entry{"v1-042500-043000-borspans.seg"sv, "920843259db0075918706f77c49855fa17c44558"sv}, Entry{"v1-042500-043000-headers.idx"sv, "beabe5749cef58f5a4d5c351e7e4e00ba5aa7585"sv}, Entry{"v1-042500-043000-headers.seg"sv, "49882d55bfb99a95a9369fe33d26583b671a8746"sv}, Entry{"v1-042500-043000-transactions-to-block.idx"sv, "c267441633ccc9f40c1558af2dca2553412bdea1"sv}, Entry{"v1-042500-043000-transactions.idx"sv, "c5e25322a18d7eb8deb1c2135bd2e77e3c599aec"sv}, Entry{"v1-042500-043000-transactions.seg"sv, "a5212f9edb66da75768d9376912f2592f159f8e8"sv}, Entry{"v1-043000-043500-bodies.idx"sv, "fe1efb6262c6281a542e19b2052a974c2db829cf"sv}, Entry{"v1-043000-043500-bodies.seg"sv, "5c6c37821ddc431be296a8b2524cf37bc10006dd"sv}, Entry{"v1-043000-043500-borevents.idx"sv, "8d4792d9f71be9fa65c6997ddadec876687e52aa"sv}, Entry{"v1-043000-043500-borevents.seg"sv, "097b0ac1072bec731d106e1b28aa21ec79cdfb09"sv}, Entry{"v1-043000-043500-borspans.idx"sv, "55ba62be751dd0f6b019fcb65c7ae35829bdf052"sv}, Entry{"v1-043000-043500-borspans.seg"sv, "5fb2e74d75d2459e94f5e582fa6db167e7da5f5e"sv}, Entry{"v1-043000-043500-headers.idx"sv, "a16a85edb1a08b213a038c9c01082ca4e3c4e905"sv}, Entry{"v1-043000-043500-headers.seg"sv, "8c9746d0ecfceb3df19e21ab8ad04e25ce34744c"sv}, Entry{"v1-043000-043500-transactions-to-block.idx"sv, "c50b248b9b453ce2d81e0842bf6e6ea70454daac"sv}, Entry{"v1-043000-043500-transactions.idx"sv, "f2a39ca385d446585644521a919c03a28f843c84"sv}, Entry{"v1-043000-043500-transactions.seg"sv, "69719163dbf86fcc5544f2e835ee324bc9ef4df7"sv}, Entry{"v1-043500-044000-bodies.idx"sv, "ae548365484db5b92424206ab231c28bacebc3be"sv}, Entry{"v1-043500-044000-bodies.seg"sv, "8c145762b9360b1c0febfbf79a00deb16f03b614"sv}, Entry{"v1-043500-044000-borevents.idx"sv, "648599ff88fb8e949c3fc202b6a23c903b729d7c"sv}, Entry{"v1-043500-044000-borevents.seg"sv, "d8c46b7f60089068e3053cec97867cab70229629"sv}, Entry{"v1-043500-044000-borspans.idx"sv, "cd19aec4875000e942de26d2ee1deea4048b1552"sv}, Entry{"v1-043500-044000-borspans.seg"sv, "08f28fef4613ff5c9a214caeff38bf6990c8826b"sv}, Entry{"v1-043500-044000-headers.idx"sv, "c86950f8038203122378c85202f9fa2406f4f1ba"sv}, Entry{"v1-043500-044000-headers.seg"sv, "049d966f53e9eafc4fe7ca1f1ef1b337334506fc"sv}, Entry{"v1-043500-044000-transactions-to-block.idx"sv, "251e58a34bc8e84eb13f0b5d5218f3aad983ed62"sv}, Entry{"v1-043500-044000-transactions.idx"sv, "dff6c3850870c91f4138c47e07975ff9e743671c"sv}, Entry{"v1-043500-044000-transactions.seg"sv, "7130301f377f2a82a763ec21a598550915ae7dde"sv}, Entry{"v1-044000-044500-bodies.idx"sv, "183b158b53d6e6a263c61e79fbc647e83a91787b"sv}, Entry{"v1-044000-044500-bodies.seg"sv, "dd99af603701ed9d3c843a7051b99c94245dbab5"sv}, Entry{"v1-044000-044500-borevents.idx"sv, "5f3a49d86a0615c0e2c826afee79f6b3e1cdd50c"sv}, Entry{"v1-044000-044500-borevents.seg"sv, "de021359d6b91d983c897c882ad2f534952b6204"sv}, Entry{"v1-044000-044500-borspans.idx"sv, "e082808befe8da0fd3f619bc3b8925cca20b0987"sv}, Entry{"v1-044000-044500-borspans.seg"sv, "16b4552c2445f1650133d830e6cffd1f616fb9a3"sv}, Entry{"v1-044000-044500-headers.idx"sv, "0df36d574a0ed4117516e84d6fde9a0759059550"sv}, Entry{"v1-044000-044500-headers.seg"sv, "fb2c368e5e944885cd29142aa42148ac608f33db"sv}, Entry{"v1-044000-044500-transactions-to-block.idx"sv, "3fa5adaef873756e8fd508b5ca9ac64f6cc302f6"sv}, Entry{"v1-044000-044500-transactions.idx"sv, "2fda81af6eb53a080a765f0f94a95a11840efd2a"sv}, Entry{"v1-044000-044500-transactions.seg"sv, "52b3144ad579fd7a67d40350671aa14173721ac2"sv}, Entry{"v1-044500-045000-bodies.idx"sv, "e08a2ea782648c58517e8ca7f6399d5ab8fe5779"sv}, Entry{"v1-044500-045000-bodies.seg"sv, "61c113041c58e3d1ac15ddde084584e1a0760ba0"sv}, Entry{"v1-044500-045000-borevents.idx"sv, "0c43dba1913ef734611aa8455052b294d19c18f9"sv}, Entry{"v1-044500-045000-borevents.seg"sv, "693d27bd134f413df6c21126536b66fc39c020b1"sv}, Entry{"v1-044500-045000-borspans.idx"sv, "edac450ee6f312bb96f07c113048b781b75d821e"sv}, Entry{"v1-044500-045000-borspans.seg"sv, "6e617641128f4e8b8bdc7f9daeb1126ee58a9c09"sv}, Entry{"v1-044500-045000-headers.idx"sv, "e830d0b4f00c59be0a3d11ba07f088021eb975df"sv}, Entry{"v1-044500-045000-headers.seg"sv, "0b0126ac5837fbe1d3adbc18a6d82de618cc914f"sv}, Entry{"v1-044500-045000-transactions-to-block.idx"sv, "e154798bb3d0d1a338a98f1dd2e6fda3323c260f"sv}, Entry{"v1-044500-045000-transactions.idx"sv, "fd10ac8de72c3e375d999c2c6527ca046f12bec4"sv}, Entry{"v1-044500-045000-transactions.seg"sv, "f0b02c9a5a994aa822a4beb46b6178854c09ccf2"sv}, Entry{"v1-045000-045500-bodies.idx"sv, "af1a27a681042ef1441419e579e5b88685e48cbd"sv}, Entry{"v1-045000-045500-bodies.seg"sv, "248244dd5b60b58d268e1ff3b0585bfbaaad6b85"sv}, Entry{"v1-045000-045500-borevents.idx"sv, "f85f4b74436cb387ad55d6a6de042493fa5e5d55"sv}, Entry{"v1-045000-045500-borevents.seg"sv, "a9933084e43e237cf2105a8fd2dc45599a26ed19"sv}, Entry{"v1-045000-045500-borspans.idx"sv, "1b308f45ff017151e8ffa8711839a552d3c511a6"sv}, Entry{"v1-045000-045500-borspans.seg"sv, "ae40aa774a8ce225d4b3b7a1b77592fc4373048c"sv}, Entry{"v1-045000-045500-headers.idx"sv, "fb7979be8bb7a0f229660421e04ca890b1fb245b"sv}, Entry{"v1-045000-045500-headers.seg"sv, "e8309548160c68557c47a961cf54c47d56da1093"sv}, Entry{"v1-045000-045500-transactions-to-block.idx"sv, "db860da7f24b1f19c405eac82ce544ad60d5e6ed"sv}, Entry{"v1-045000-045500-transactions.idx"sv, "e171556d1d8019170eef9fb426f4f08605b70c44"sv}, Entry{"v1-045000-045500-transactions.seg"sv, "704469896f0591f7cbf55601813cb1e88a88790f"sv}, Entry{"v1-045500-046000-bodies.idx"sv, "82c76f2405828fee37ff0e84253f259b7032d402"sv}, Entry{"v1-045500-046000-bodies.seg"sv, "cca9947dbff5e228e92a748c27a3b7786548b71c"sv}, Entry{"v1-045500-046000-borevents.idx"sv, "b51bd6e63db4eca8d11800e9a5903416af8f2c95"sv}, Entry{"v1-045500-046000-borevents.seg"sv, "c5019b86f7551aa3c3fb98eaecb37c28016bc59f"sv}, Entry{"v1-045500-046000-borspans.idx"sv, "04401e438790f28e48b891b1f89b0c4b8d11e6e9"sv}, Entry{"v1-045500-046000-borspans.seg"sv, "c6135b143f99b5ee7e8941d05a42497e6e32420f"sv}, Entry{"v1-045500-046000-headers.idx"sv, "6675bc8b6a1e2c0f575382cd9a924a1f22b25981"sv}, Entry{"v1-045500-046000-headers.seg"sv, "d8fcebd51f16e0a30c37202ab2f40f471fc20860"sv}, Entry{"v1-045500-046000-transactions-to-block.idx"sv, "325ebef27e2c65b146a49e118f1cb9b3bebe20b2"sv}, Entry{"v1-045500-046000-transactions.idx"sv, "77430a3d28ab5f33288d792bfbb4caa46a9d8945"sv}, Entry{"v1-045500-046000-transactions.seg"sv, "49bce0102c55f03f4848b9fbfca1ae4a033946a9"sv}, Entry{"v1-046000-046500-bodies.idx"sv, "eb404069a5fe36c84c7566b45d932eb3764daa14"sv}, Entry{"v1-046000-046500-bodies.seg"sv, "19e795b0df22454f043453eac14576542b8e7c9e"sv}, Entry{"v1-046000-046500-borevents.idx"sv, "9072193c1e2e8aaecf17da05b32458333c069f7b"sv}, Entry{"v1-046000-046500-borevents.seg"sv, "3afe34074bb9a4de3ad42a38da2e21e8e1425cee"sv}, Entry{"v1-046000-046500-borspans.idx"sv, "30c4c605772640aec8d057325fb6b1152f8bd8e3"sv}, Entry{"v1-046000-046500-borspans.seg"sv, "7e75899f73f2dd3da6611fed0d3ef2285d8a07ad"sv}, Entry{"v1-046000-046500-headers.idx"sv, "8c91dc6f6445f51cab19cfdad81f405e9fce2088"sv}, Entry{"v1-046000-046500-headers.seg"sv, "56fab7a8a022427bf9922f77151744c122423bea"sv}, Entry{"v1-046000-046500-transactions-to-block.idx"sv, "c05eccbf32e2dc50663f8791629b558552eb684c"sv}, Entry{"v1-046000-046500-transactions.idx"sv, "255310c34b23c56351e276328916852184fc69df"sv}, Entry{"v1-046000-046500-transactions.seg"sv, "1555a18a452cacc9b60504473de5aad768e201e1"sv}, Entry{"v1-046500-047000-bodies.idx"sv, "2f895677523fab297e55e167e396fbc6ea09acd8"sv}, Entry{"v1-046500-047000-bodies.seg"sv, "87b0de29954d89cd6990d608e49779924afe4919"sv}, Entry{"v1-046500-047000-borevents.idx"sv, "7be1ac20367c47cd2488d81b8c891c16be749b51"sv}, Entry{"v1-046500-047000-borevents.seg"sv, "0c4d1f3f131a7de53552eafdfca531541b1b221b"sv}, Entry{"v1-046500-047000-borspans.idx"sv, "afcfa060dace610a91466d0fe46ccc455dc34073"sv}, Entry{"v1-046500-047000-borspans.seg"sv, "b4d82ac8f99b5e381004dc83a7facab987c89cc2"sv}, Entry{"v1-046500-047000-headers.idx"sv, "122742ce4b67c654544658084d89a371c97ef8e7"sv}, Entry{"v1-046500-047000-headers.seg"sv, "1f873b213204afb0d0a2215ef8d0b5b3c6085fc5"sv}, Entry{"v1-046500-047000-transactions-to-block.idx"sv, "8810dee91cbc24c9297266c37ff1d96c98519e41"sv}, Entry{"v1-046500-047000-transactions.idx"sv, "ee8c0783a66bb4a5387820df3980578b1bd5ed4b"sv}, Entry{"v1-046500-047000-transactions.seg"sv, "8e79d847fd6f2e48a2bb57c8a448c0f6af216bc3"sv}, Entry{"v1-047000-047500-bodies.idx"sv, "d5bb8bb0d12fbe7f9b6d39985be76d097884bd56"sv}, Entry{"v1-047000-047500-bodies.seg"sv, "ee2650aa6551ab23a770d56bd7aa43d2d6b73b0b"sv}, Entry{"v1-047000-047500-borevents.idx"sv, "3678081b1ff292d163fdfc981c5cc4ff07e2f47f"sv}, Entry{"v1-047000-047500-borevents.seg"sv, "d22289233a230afb11e7607cd1b83071f9024818"sv}, Entry{"v1-047000-047500-borspans.idx"sv, "1ce6463d8b4a2a7543d673a35a4c3fa959cc3fba"sv}, Entry{"v1-047000-047500-borspans.seg"sv, "a5830380fb75d343c37ec5ced44453fb76ca62ac"sv}, Entry{"v1-047000-047500-headers.idx"sv, "96cfa4db5b3265c101ac287fa4ea9754f8be62c8"sv}, Entry{"v1-047000-047500-headers.seg"sv, "2f6c91a720785eee1b4fe668ce1ff61dd7b5b375"sv}, Entry{"v1-047000-047500-transactions-to-block.idx"sv, "aa6523d8304d116c95840d69fd18397ac6c7f1b3"sv}, Entry{"v1-047000-047500-transactions.idx"sv, "1cc60685564d342f22690bfaf94fa030e720aa04"sv}, Entry{"v1-047000-047500-transactions.seg"sv, "a5c13ff478e01a2199383c60dff4ece940d8ae9d"sv}, Entry{"v1-047500-048000-bodies.idx"sv, "12c089324e4210c91f0c14c9302fc01df341c618"sv}, Entry{"v1-047500-048000-bodies.seg"sv, "34260de3b2131070c445d626d50cf1a04b6dfece"sv}, Entry{"v1-047500-048000-borevents.idx"sv, "52e0eb6cee41df4fb34fcab67406950499141da9"sv}, Entry{"v1-047500-048000-borevents.seg"sv, "9509ad945553f324057ba8aaa5aea0b628f98bc4"sv}, Entry{"v1-047500-048000-borspans.idx"sv, "baa111202ae7472117686d4d59c89a821d21f8cf"sv}, Entry{"v1-047500-048000-borspans.seg"sv, "6bf342202037ddba09ab8aed36b6c61d2df21110"sv}, Entry{"v1-047500-048000-headers.idx"sv, "c754c9b6eaad8593581b46fe3069901aef453f05"sv}, Entry{"v1-047500-048000-headers.seg"sv, "e9f49e398987646f147542c0c2950cda3bf70a7e"sv}, Entry{"v1-047500-048000-transactions-to-block.idx"sv, "046edf5beca470f96acbaf0683d0b1c0d4a0b967"sv}, Entry{"v1-047500-048000-transactions.idx"sv, "05744c0d973d1cff5ee5a141f3ed3e141b876419"sv}, Entry{"v1-047500-048000-transactions.seg"sv, "3a9c44e7bb0a7a72a349f005d512350eb35db001"sv}, Entry{"v1-048000-048500-bodies.idx"sv, "fc7b77eb29c3bf34db3dacfcda42e8d279420f2a"sv}, Entry{"v1-048000-048500-bodies.seg"sv, "1469aa8b05c9c195119be5cbf35aaea5a5205719"sv}, Entry{"v1-048000-048500-borevents.idx"sv, "3adf7df34e1544066745ad8ec6f765877a2cd8ad"sv}, Entry{"v1-048000-048500-borevents.seg"sv, "e68b2c09cd11e514b227198758fd1c8c566c9ef8"sv}, Entry{"v1-048000-048500-borspans.idx"sv, "c03f7048ec0785bb56888424ea65d82742d41b93"sv}, Entry{"v1-048000-048500-borspans.seg"sv, "596b4b51b6d9ae6378892c56b947ec26d59a3fe3"sv}, Entry{"v1-048000-048500-headers.idx"sv, "f7815ea2645320ccd8ba059d50b13af7472b9028"sv}, Entry{"v1-048000-048500-headers.seg"sv, "468020cfb6ab66344b32e3388d12a1bb02ccbba5"sv}, Entry{"v1-048000-048500-transactions-to-block.idx"sv, "d5535ad2f1a15767cde29627f0e2a298537b7204"sv}, Entry{"v1-048000-048500-transactions.idx"sv, "a9baff1c9b8c81e2629104ece2328e46432361f5"sv}, Entry{"v1-048000-048500-transactions.seg"sv, "55914181b3c0c4783ab130e0aa6977b7ef1b7a77"sv}, Entry{"v1-048500-049000-bodies.idx"sv, "bc29e6852d838b4087bfb4f7891842f83ed32413"sv}, Entry{"v1-048500-049000-bodies.seg"sv, "1c1331027702bd9dd745b576f42001bba7eab928"sv}, Entry{"v1-048500-049000-borevents.idx"sv, "54b9651f510300a0391e28e72988319f813512d6"sv}, Entry{"v1-048500-049000-borevents.seg"sv, "6e8c5c58e2c51d924057c3c402098744c6995fa5"sv}, Entry{"v1-048500-049000-borspans.idx"sv, "6b9b247cfb4b8bb497679a4621e31e034ce31b77"sv}, Entry{"v1-048500-049000-borspans.seg"sv, "3d4ed2f09e03e77ab974088cb5a37857d2edc313"sv}, Entry{"v1-048500-049000-headers.idx"sv, "20ec0df299c1cfd60db1d3b1fed6422a25e6be16"sv}, Entry{"v1-048500-049000-headers.seg"sv, "7245fdd5ff816c83717513fadd5bbb056f5f00da"sv}, Entry{"v1-048500-049000-transactions-to-block.idx"sv, "5ab2049b59c64a4295adff7bdf01c9bf36abaa0c"sv}, Entry{"v1-048500-049000-transactions.idx"sv, "c2d550769caf28666e9bda6c7fc6444faccb1099"sv}, Entry{"v1-048500-049000-transactions.seg"sv, "39eab0e5ef6ef3fb0bc4bb4a9a78b1e78d864e7f"sv}, Entry{"v1-049000-049500-bodies.idx"sv, "6152e265c009871c25caf55dfd0dfeeaef3d2442"sv}, Entry{"v1-049000-049500-bodies.seg"sv, "8374ce3521cf7af8afcbf9c8933086a96185761f"sv}, Entry{"v1-049000-049500-borevents.idx"sv, "5ff0f730bdf0d252c06e0dff6e8ff0c6ccbc24e7"sv}, Entry{"v1-049000-049500-borevents.seg"sv, "9cb89acae38320a06ea57e451486c2d685ca8e85"sv}, Entry{"v1-049000-049500-borspans.idx"sv, "de6344647f1c136e1b48937f43e728d11adfb937"sv}, Entry{"v1-049000-049500-borspans.seg"sv, "9c8914e25e8e0e19da5fee949a2389276f701324"sv}, Entry{"v1-049000-049500-headers.idx"sv, "64fbd3e1112e834c0ecaafef8b86763ecb3f94e9"sv}, Entry{"v1-049000-049500-headers.seg"sv, "522791c11373ba837740481ec076ce7410059ef0"sv}, Entry{"v1-049000-049500-transactions-to-block.idx"sv, "dba93995a33804e90db37e0be0cbfe67d18dfa10"sv}, Entry{"v1-049000-049500-transactions.idx"sv, "829265168c087664ab5a62ca4769132456fc0a8d"sv}, Entry{"v1-049000-049500-transactions.seg"sv, "b1e6b2fc813f58b6752f62296c113f49c6a35a9e"sv}, Entry{"v1-049500-050000-bodies.idx"sv, "e3c1a3a74db298faa6cac4c98504ee99f077d959"sv}, Entry{"v1-049500-050000-bodies.seg"sv, "6de29ccf899a33dcdc37c69a617ebadd97260ef0"sv}, Entry{"v1-049500-050000-borevents.idx"sv, "7415ad6c68cbdd2a128c29c333a75a82ad469446"sv}, Entry{"v1-049500-050000-borevents.seg"sv, "f9fe8b94235af4c67966a8b42bd6b79f0949e816"sv}, Entry{"v1-049500-050000-borspans.idx"sv, "2ada66739e419592ac3745c2d2cad7758c4dc674"sv}, Entry{"v1-049500-050000-borspans.seg"sv, "a36a77ac1c5c8f77d08b7d3139c96d7211f3e37d"sv}, Entry{"v1-049500-050000-headers.idx"sv, "5e48800150a15a57811c0a1f9a012a05de55183b"sv}, Entry{"v1-049500-050000-headers.seg"sv, "2ff24c6ec7a19d71ae86203a777c4b16951e8bb4"sv}, Entry{"v1-049500-050000-transactions-to-block.idx"sv, "48b0a8bccb2644c230c02809ede1a371f33382e3"sv}, Entry{"v1-049500-050000-transactions.idx"sv, "344bd291e7647fa45e9cf9ce0ba4ffe1a39a263c"sv}, Entry{"v1-049500-050000-transactions.seg"sv, "b409a54a043bc0fd043738a27d501f8f3dcb6912"sv}, Entry{"v1-050000-050500-bodies.idx"sv, "c9444500f5f07d9842cee2f0330644637042ee0c"sv}, Entry{"v1-050000-050500-bodies.seg"sv, "173a02f09a2c9ea778bfd9a23a2e702732ffe372"sv}, Entry{"v1-050000-050500-borevents.idx"sv, "afce853d1e13bfb54d2c782a6cc385ee160d1628"sv}, Entry{"v1-050000-050500-borevents.seg"sv, "5f3badea130ef0a2a5244fc04fcf2343352cfd55"sv}, Entry{"v1-050000-050500-borspans.idx"sv, "4e532f013b853d587e9e4a101b9ceb6c9f3a4521"sv}, Entry{"v1-050000-050500-borspans.seg"sv, "96f270dba74abb0042bd00dd49149d9caca5920e"sv}, Entry{"v1-050000-050500-headers.idx"sv, "4e38a9d3bc8dddad1abcb6e9ead1f277725c3ef9"sv}, Entry{"v1-050000-050500-headers.seg"sv, "1be20af9fa27e0c5741d301f0b3c354c5d9728ad"sv}, Entry{"v1-050000-050500-transactions-to-block.idx"sv, "db30d4f1eeeb263b2fc73b69ebf01ae678f353fb"sv}, Entry{"v1-050000-050500-transactions.idx"sv, "075f159b391750f41416f834c4c4c0a9bd827603"sv}, Entry{"v1-050000-050500-transactions.seg"sv, "a80b1b6f74a082182cdc25180b18c1dbb83e5348"sv}, Entry{"v1-050500-051000-bodies.idx"sv, "0d02611b540178df15c76c98b36904e8e5ecd467"sv}, Entry{"v1-050500-051000-bodies.seg"sv, "6c9427bba85c4da2663fd4f87383d5c55411e709"sv}, Entry{"v1-050500-051000-borevents.idx"sv, "7f7526feed42be15565bb19fb45b9192256ef2e7"sv}, Entry{"v1-050500-051000-borevents.seg"sv, "faee92d0dbcf3367b5ac36fe99eecf1860ca01f9"sv}, Entry{"v1-050500-051000-borspans.idx"sv, "37258a240f90dc9405b44a6e0ad3103224488ced"sv}, Entry{"v1-050500-051000-borspans.seg"sv, "5b250b1f33a7c79131f7b05f2335fbe5489b5f31"sv}, Entry{"v1-050500-051000-headers.idx"sv, "88995c9f56e92a79a8cef954d19981301bfd9e82"sv}, Entry{"v1-050500-051000-headers.seg"sv, "16f000973535c6736f37f88932ee8a291667720d"sv}, Entry{"v1-050500-051000-transactions-to-block.idx"sv, "ad07bba694179499d6ce06be579723af40900893"sv}, Entry{"v1-050500-051000-transactions.idx"sv, "4d92aaafe5cf0653710383ffe554859d5ce825de"sv}, Entry{"v1-050500-051000-transactions.seg"sv, "3bec708259aed82ddf68d9d482b19fe4e3d9ae43"sv}, Entry{"v1-051000-051100-bodies.idx"sv, "9bcad2620c4199e733c364793c1519c2d7c31fc9"sv}, Entry{"v1-051000-051100-bodies.seg"sv, "5cf351ebd6a8fbd10b6078a4559c7ed9675daf9a"sv}, Entry{"v1-051000-051100-borevents.idx"sv, "529436cc413edb19ef766be7045b8847d3943df2"sv}, Entry{"v1-051000-051100-borevents.seg"sv, "0ed96de0a2898eb0c4ad6615955318170fc9fe23"sv}, Entry{"v1-051000-051100-borspans.idx"sv, "c8812286d9c584350bdcb4891a9ac7de47173c15"sv}, Entry{"v1-051000-051100-borspans.seg"sv, "9f319558d803c339db98b7b0bbd45221afc5cebb"sv}, Entry{"v1-051000-051100-headers.idx"sv, "cd89bd2e79ea9a3c2e238a814836a01273a94892"sv}, Entry{"v1-051000-051100-headers.seg"sv, "e1b0f740eef67e52d70d07b5dbf97e42fcaec60b"sv}, Entry{"v1-051000-051100-transactions-to-block.idx"sv, "b5fc46278443ee57123d527a7139ac6c28a1dad5"sv}, Entry{"v1-051000-051100-transactions.idx"sv, "1bbaed94d679d6bd0878c20c8d32c67e9cade720"sv}, Entry{"v1-051000-051100-transactions.seg"sv, "db34489e4e888ef2efdd093ae81c35842d6d9c6a"sv}, Entry{"v1-051100-051200-bodies.idx"sv, "e8d70d90c629c32aa421274853befa88e060dccd"sv}, Entry{"v1-051100-051200-bodies.seg"sv, "90e412324d95be52e26d035f9819f3124ce55f5e"sv}, Entry{"v1-051100-051200-borevents.idx"sv, "17adf8659ced9679446de02ad10b670c5d159cc0"sv}, Entry{"v1-051100-051200-borevents.seg"sv, "c63583540c4d08e8166fd84b21103291ee4be12d"sv}, Entry{"v1-051100-051200-borspans.idx"sv, "1c098c9ccca672ed7333ad5f7308df026dc61f72"sv}, Entry{"v1-051100-051200-borspans.seg"sv, "6d03788143424e0a6edf67d44e07f54fbf184abe"sv}, Entry{"v1-051100-051200-headers.idx"sv, "fd9bc6f528764be5bd4a7fbc048052ed4d31fe30"sv}, Entry{"v1-051100-051200-headers.seg"sv, "c70c72439b34dc2ca86e218666769687ed22df35"sv}, Entry{"v1-051100-051200-transactions-to-block.idx"sv, "8d2b3f4af5ed8380a11f754b2eb1a5728ee80e6b"sv}, Entry{"v1-051100-051200-transactions.idx"sv, "71dbc5b43896e388457e318c760d27b0d2c0a41d"sv}, Entry{"v1-051100-051200-transactions.seg"sv, "2497c31de655d9c1813f45e2d89477acd7372826"sv}, Entry{"v1-051200-051300-bodies.idx"sv, "da4d5483921a8f8b2bd8acd9a2a80be1f3dd0294"sv}, Entry{"v1-051200-051300-bodies.seg"sv, "684df6d870f6f941e96ec05bae93a981f3ab881e"sv}, Entry{"v1-051200-051300-borevents.idx"sv, "bfe327f4b14caca21be581276f954c82ae012464"sv}, Entry{"v1-051200-051300-borevents.seg"sv, "91f605bd3b745a545ca38555f3d89783a6126854"sv}, Entry{"v1-051200-051300-borspans.idx"sv, "392a4518d4cb97b2b430c2c5919296b42553489a"sv}, Entry{"v1-051200-051300-borspans.seg"sv, "ec8cc4a234a57f04f36a55b580f7cf49ddecce1f"sv}, Entry{"v1-051200-051300-headers.idx"sv, "05d7fd9690fc231c1d42b00296d3d31641eb293b"sv}, Entry{"v1-051200-051300-headers.seg"sv, "01c6be0081b0f870ee271b1ab821abcfa354d0ee"sv}, Entry{"v1-051200-051300-transactions-to-block.idx"sv, "bd49577a89015382bb122db87b50f2e04ed37fbd"sv}, Entry{"v1-051200-051300-transactions.idx"sv, "f8bc6f641f789cffdbca7af82e65750f06db3e55"sv}, Entry{"v1-051200-051300-transactions.seg"sv, "1970fdc8d98826958a1b067c0b5c871564610f67"sv}, Entry{"v1-051300-051400-bodies.idx"sv, "6992623166da584d9518b16d23f2621b3c96da59"sv}, Entry{"v1-051300-051400-bodies.seg"sv, "38463bb10fb4e11b3c79a9fcadece4fee1455175"sv}, Entry{"v1-051300-051400-borevents.idx"sv, "88d441306f165237bb312e131367c7aa04ff01fc"sv}, Entry{"v1-051300-051400-borevents.seg"sv, "4e8f6f77b803743cde1a8c6ae2a9ad6ca9e51b73"sv}, Entry{"v1-051300-051400-borspans.idx"sv, "184e47dfd9b09ec24ce34d523ac5662c5cef9028"sv}, Entry{"v1-051300-051400-borspans.seg"sv, "87bf9abb2733180b6da754c7af5fddc410f233df"sv}, Entry{"v1-051300-051400-headers.idx"sv, "50e8565faeae3466dcf05fdfcaa425b3b7067e2b"sv}, Entry{"v1-051300-051400-headers.seg"sv, "78622097544077fac3a71a58bbaeb7d3b82ae98a"sv}, Entry{"v1-051300-051400-transactions-to-block.idx"sv, "f1b4fdcef9ff0d22e7e569a1e5bf22de4716d5d2"sv}, Entry{"v1-051300-051400-transactions.idx"sv, "676c7658047c8e8af1bd887fefe2ef16a26ad2e1"sv}, Entry{"v1-051300-051400-transactions.seg"sv, "a205c7b2ace3b90bdd1964830760ea7e52d34940"sv}, Entry{"v1-051400-051500-bodies.idx"sv, "9892d2666cbde962c767c854be8b9304c053da02"sv}, Entry{"v1-051400-051500-bodies.seg"sv, "4449697efab2fa4f1b7ce8a2c5e94c339bbe98f1"sv}, Entry{"v1-051400-051500-borevents.idx"sv, "cc873316c34cffb65a18ef8210025edddd676773"sv}, Entry{"v1-051400-051500-borevents.seg"sv, "0fcb69a1cf826febfd61bc77e7b3d84149cc2f6b"sv}, Entry{"v1-051400-051500-borspans.idx"sv, "44b0b7d73f75b9854761f224a57f6fcbfad96250"sv}, Entry{"v1-051400-051500-borspans.seg"sv, "9d0d00d03bd314d8758942f58a79df9e8b84b4c1"sv}, Entry{"v1-051400-051500-headers.idx"sv, "e9647dfa0bff3912aa04cee1767f3765b6afa463"sv}, Entry{"v1-051400-051500-headers.seg"sv, "db9d539eb6b1a26746e537457ad4d49bbe5a5c39"sv}, Entry{"v1-051400-051500-transactions-to-block.idx"sv, "69b5ca9fac7012398a95a5346e4cefb6338d7aac"sv}, Entry{"v1-051400-051500-transactions.idx"sv, "4099c1131dd7859de75d9b7f23facd03caefddfd"sv}, Entry{"v1-051400-051500-transactions.seg"sv, "be8c4f28649ec4189348c7c068202124f4f748c7"sv}, Entry{"v1-051500-051600-bodies.idx"sv, "43bddab5ad0e3dbb6f45928b84441badf0c642d3"sv}, Entry{"v1-051500-051600-bodies.seg"sv, "4b50f49b3f8bbdeb1197a86a663766854508e48c"sv}, Entry{"v1-051500-051600-borevents.idx"sv, "c414aa18892f1cc3573eba6f5d9800c7c730305d"sv}, Entry{"v1-051500-051600-borevents.seg"sv, "480a285ace95c17c384eb617659eaf2bf1f3cb48"sv}, Entry{"v1-051500-051600-borspans.idx"sv, "2679b5fd0f48dfde69cf4070707f980d0f819162"sv}, Entry{"v1-051500-051600-borspans.seg"sv, "a05254796653aa38d142031ed6e7fe53b597cd32"sv}, Entry{"v1-051500-051600-headers.idx"sv, "57c6eebf6361ca6ed4984610356ecaadca031fe5"sv}, Entry{"v1-051500-051600-headers.seg"sv, "b0aa6cb3eecd203cedee21618c016c2037c99810"sv}, Entry{"v1-051500-051600-transactions-to-block.idx"sv, "281c474ab3de3cd20c79e63d73167918a5c6b239"sv}, Entry{"v1-051500-051600-transactions.idx"sv, "decdd403b0d6d2681d3855e0d1dfcc809ab437bf"sv}, Entry{"v1-051500-051600-transactions.seg"sv, "bc0f2d03843a192d3a94f96216d9a32959cf6374"sv}, Entry{"v1-051600-051700-bodies.idx"sv, "0330f96f0b5255369a81f012ba53a9a3677aace3"sv}, Entry{"v1-051600-051700-bodies.seg"sv, "5d35892ae25992987f7de37f37e3f032dfc1b4a2"sv}, Entry{"v1-051600-051700-borevents.idx"sv, "4cabaf34146e0cb56c686b06e65c19926f7fd4db"sv}, Entry{"v1-051600-051700-borevents.seg"sv, "159ffdc6f39abde20e84e6070854c431fb300c0e"sv}, Entry{"v1-051600-051700-borspans.idx"sv, "a0cb330f1f84af18663910f720768ae01eeb24b4"sv}, Entry{"v1-051600-051700-borspans.seg"sv, "1e28df58b85bb4d4538e8e46d7841f8a186e2614"sv}, Entry{"v1-051600-051700-headers.idx"sv, "860a87e53af1dfd4e74d01a90e70beff56f653d0"sv}, Entry{"v1-051600-051700-headers.seg"sv, "6dcdf233a93d7af0cfe14a4c4a49a7d39ea5d367"sv}, Entry{"v1-051600-051700-transactions-to-block.idx"sv, "8ac70d831e31c93f80695cc2dabac7db49452c42"sv}, Entry{"v1-051600-051700-transactions.idx"sv, "169e710f72d1c1935f1ff028e320b8dacca0c50c"sv}, Entry{"v1-051600-051700-transactions.seg"sv, "f5c574e4bbe81ad8e05319ab4a186a30690f4e49"sv}, Entry{"v1-051700-051800-bodies.idx"sv, "310813b004260252ef428eaf19a3dc62d199cba1"sv}, Entry{"v1-051700-051800-bodies.seg"sv, "b61590b178c331cd12ecc0e13e2f5c10346b372e"sv}, Entry{"v1-051700-051800-borevents.idx"sv, "59d275bc691496c461ccbda39f95a6847f706099"sv}, Entry{"v1-051700-051800-borevents.seg"sv, "c580026af5fb43abb27414102bda7213c7027b04"sv}, Entry{"v1-051700-051800-borspans.idx"sv, "c45ad92e6bd40bfd14ff30ce1827609bc1e4afd2"sv}, Entry{"v1-051700-051800-borspans.seg"sv, "1ff338e24d98bd6f46f1afe203f15357d6ec79cf"sv}, Entry{"v1-051700-051800-headers.idx"sv, "efdb5d6f1fc0710d8443859449b3f3da3f2a9fae"sv}, Entry{"v1-051700-051800-headers.seg"sv, "a82063d2fac150d54ef282bd7141843a74de700c"sv}, Entry{"v1-051700-051800-transactions-to-block.idx"sv, "df7e99153fa20f398e057edf5cdda01e78087c23"sv}, Entry{"v1-051700-051800-transactions.idx"sv, "d2e3c795c49fedabace58572ae5dded59fca9700"sv}, Entry{"v1-051700-051800-transactions.seg"sv, "3d803287d620035035db2bac4069d8b08475722b"sv}, Entry{"v1-051800-051900-bodies.idx"sv, "f012dd0b539bd71128eda84ee7be585e3c8977b0"sv}, Entry{"v1-051800-051900-bodies.seg"sv, "224b752e2e42e7499d926229d6b038bea793156b"sv}, Entry{"v1-051800-051900-borevents.idx"sv, "62de4e9b3c62d002e92556441be69af40aae352d"sv}, Entry{"v1-051800-051900-borevents.seg"sv, "164b5bc6259f1f620f1ef7b5fd85cc8ac687ba23"sv}, Entry{"v1-051800-051900-borspans.idx"sv, "7aa46da1f8848b7bf1ac03c8cb037ee31b68c91a"sv}, Entry{"v1-051800-051900-borspans.seg"sv, "2ea34f6ffd9df55363b080e0f702614d2646ade2"sv}, Entry{"v1-051800-051900-headers.idx"sv, "70fd96cdecdf4499704f1393f58dde12e8c0f7da"sv}, Entry{"v1-051800-051900-headers.seg"sv, "2730657ac56de3e4a7d31e24edffa2b771473264"sv}, Entry{"v1-051800-051900-transactions-to-block.idx"sv, "e34130e22bd2f51f8cb7fc9b5d7dd72acc718e18"sv}, Entry{"v1-051800-051900-transactions.idx"sv, "86fcd725210c826253d435c0b60684f3dfc7550e"sv}, Entry{"v1-051800-051900-transactions.seg"sv, "be633dc6e24dcd9773bc1902be7d7d47fddba10d"sv}, Entry{"v1-051900-052000-bodies.idx"sv, "54a2e44a05988208f62d818c567e0a3204257842"sv}, Entry{"v1-051900-052000-bodies.seg"sv, "d9e574dc24463fbe7ef9377cf96a80747aaf5499"sv}, Entry{"v1-051900-052000-borevents.idx"sv, "24ca9d602ce53be972e48c1b8255f810958dc71d"sv}, Entry{"v1-051900-052000-borevents.seg"sv, "f6a749156446d85685b29512a60b7a3e677cbef3"sv}, Entry{"v1-051900-052000-borspans.idx"sv, "9b9e4d785b273ed5790e2de2504ca7d6432527e4"sv}, Entry{"v1-051900-052000-borspans.seg"sv, "6688ae52648e568ba7214c6bfb4bda6791d038c1"sv}, Entry{"v1-051900-052000-headers.idx"sv, "d97b3c598f520888eb67244ba28d994998584e65"sv}, Entry{"v1-051900-052000-headers.seg"sv, "bd276f31d9221d74c29eb738efb4a5bff8131756"sv}, Entry{"v1-051900-052000-transactions-to-block.idx"sv, "06dc579208eb594bb6b31edb0654ed45de049c77"sv}, Entry{"v1-051900-052000-transactions.idx"sv, "7f68d9d306ad2b04cf4100466508cf654b16a88a"sv}, Entry{"v1-051900-052000-transactions.seg"sv, "77293b4bab8398f938606abcb866c5b79379d90f"sv}, Entry{"v1-052000-052100-bodies.idx"sv, "7d3445d7ea0addb9b738f0cc85b110069d7a8285"sv}, Entry{"v1-052000-052100-bodies.seg"sv, "040964175d15b43086d44db1cf002e3ae8d79f63"sv}, Entry{"v1-052000-052100-borevents.idx"sv, "8055676f7fa4ce92104f7b63c3b0933c1491b89c"sv}, Entry{"v1-052000-052100-borevents.seg"sv, "fd88ba957e5f780389534e843d214dd67b863438"sv}, Entry{"v1-052000-052100-borspans.idx"sv, "911c2dc2d638ed09d90e289fb538c9f9d6964226"sv}, Entry{"v1-052000-052100-borspans.seg"sv, "d8f78e5e902b6fbe8b10b7c723d37b475df95184"sv}, Entry{"v1-052000-052100-headers.seg"sv, "b8043133dfef77b74484281cf3b49c253c1fda40"sv}, Entry{"v1-052000-052100-transactions-to-block.idx"sv, "5ef78caae98e6d4bd24c2a7c54a86bac65a44d06"sv}, Entry{"v1-052000-052100-transactions.idx"sv, "c2197aea815484775c6d70c8b9a3a6946ace1dfb"sv}, Entry{"v1-052000-052100-transactions.seg"sv, "84b80da1018d56f79aa177b96e13ad9a0e03290f"sv}, Entry{"v1-052100-052200-bodies.idx"sv, "f950e6453bdaac6debc3799856c8502158bd78a5"sv}, Entry{"v1-052100-052200-bodies.seg"sv, "4cdb2be31b650f2b511dd90306158a4f9582fb7e"sv}, Entry{"v1-052100-052200-borevents.idx"sv, "2ded6be2285c4a59be7697165451aae3651dfceb"sv}, Entry{"v1-052100-052200-borevents.seg"sv, "cc2a76ae7d3a487c53b7118092faa60e23ba652b"sv}, Entry{"v1-052100-052200-borspans.idx"sv, "283e182d7209a83bcb97f6bfa71e47043d9dd089"sv}, Entry{"v1-052100-052200-borspans.seg"sv, "bc8edcc7d69ddb7c883ef78bd82ce83f59e2cddd"sv}, Entry{"v1-052100-052200-headers.seg"sv, "44e6deee90417bea09c0271591db6d45ccb197b3"sv}, Entry{"v1-052100-052200-transactions-to-block.idx"sv, "d642eb97a87c250fd9739cf0208f98bffca5ed2b"sv}, Entry{"v1-052100-052200-transactions.idx"sv, "eaa2af1bd9737c0dc1ae57cbfe14309076aa3701"sv}, Entry{"v1-052100-052200-transactions.seg"sv, "69d3d36ebaee82ae1809e897c2e140e920f3f0e9"sv}, Entry{"v1-052200-052300-bodies.idx"sv, "49ca00814eaf757046280f414d3f17b8f0918b64"sv}, Entry{"v1-052200-052300-bodies.seg"sv, "e9a00da1b33e67ecc774666a9a92bcfa6ad16dd7"sv}, Entry{"v1-052200-052300-borevents.idx"sv, "c610c8c4a83dd7dd1b9ee43f9c9f33ca704b4bd7"sv}, Entry{"v1-052200-052300-borevents.seg"sv, "75569199234fa477e9f07e47ff1311ca7174065a"sv}, Entry{"v1-052200-052300-borspans.idx"sv, "0489162577a81bd3b792e340e6cc2876ed177ff6"sv}, Entry{"v1-052200-052300-borspans.seg"sv, "a91659cb0f4a7a37a5adef6773e0760c71d8c81a"sv}, Entry{"v1-052200-052300-headers.seg"sv, "92d4491d84606b0c4fc4c48ff1cb6806a0fe57bc"sv}, Entry{"v1-052200-052300-transactions-to-block.idx"sv, "5fc27ec36262540e4cd90f845c707459e1cde5df"sv}, Entry{"v1-052200-052300-transactions.idx"sv, "a5b9509bfbeb957b06d4ff7cfd66089657cd8e48"sv}, Entry{"v1-052200-052300-transactions.seg"sv, "3a7ce0152586dc8d5e00bc4dc63e436acc109088"sv}, Entry{"v1-052300-052400-bodies.idx"sv, "055f03f5d5319ec068cc5363b8b2d9fcddcb2151"sv}, Entry{"v1-052300-052400-bodies.seg"sv, "1e3a39cf886d418fb4925db01379dc59bce5c732"sv}, Entry{"v1-052300-052400-borevents.idx"sv, "7b6483589b2c3837aeed4c3a1644a70924d390ae"sv}, Entry{"v1-052300-052400-borevents.seg"sv, "b924b535339e4ae6008ee3bcb5fbce36bcc30798"sv}, Entry{"v1-052300-052400-borspans.idx"sv, "2ea79c4366ece35167c621340b156e216f27ab4a"sv}, Entry{"v1-052300-052400-borspans.seg"sv, "f27b1d5687351f2b36a8b62bb39d66b3670036b7"sv}, Entry{"v1-052300-052400-headers.seg"sv, "b212810cc960153b5f618fbfe400fb520f2a9a64"sv}, Entry{"v1-052300-052400-transactions-to-block.idx"sv, "1ac3816a74dd21700e9e4d4f7ec6b0bfb726fcf5"sv}, Entry{"v1-052300-052400-transactions.idx"sv, "eff3eed8355d00634200ffccb32da8342f15df34"sv}, Entry{"v1-052300-052400-transactions.seg"sv, "20e2aac2e54b845194c8b4d06bf626d027b94b66"sv}, Entry{"v1-052400-052500-bodies.idx"sv, "a8da331cf516e3e024a022fad806aa28f74af8de"sv}, Entry{"v1-052400-052500-bodies.seg"sv, "2e969426e06e53a261f01471b92d6c73ec745b70"sv}, Entry{"v1-052400-052500-borevents.idx"sv, "1885cbbff607d5788d3885a6e1735262f9e07f5d"sv}, Entry{"v1-052400-052500-borevents.seg"sv, "e10d01f058bec8e0772ec2356e476e0e3bcf9bdc"sv}, Entry{"v1-052400-052500-borspans.idx"sv, "f0460ab9a7faf4299374bd7b6cdf92f4d0886d4a"sv}, Entry{"v1-052400-052500-borspans.seg"sv, "b3827d016867177ceeec5e5c8555241828df5413"sv}, Entry{"v1-052400-052500-headers.seg"sv, "2f70fc4c4578d861df81933f2ff2954c2dee0781"sv}, Entry{"v1-052400-052500-transactions-to-block.idx"sv, "a9902bbe24d7354817a8884b09b88cd3346129d9"sv}, Entry{"v1-052400-052500-transactions.idx"sv, "b08efb8e86cd508a5e05226a73bbad8f2a12323c"sv}, Entry{"v1-052400-052500-transactions.seg"sv, "f18fe5e870f09cd9e9c1624df5f9dfffef1d15e6"sv}, Entry{"v1-052500-052600-bodies.idx"sv, "8f61df36b8ae2fdbf573576a013bb2d53e72ac40"sv}, Entry{"v1-052500-052600-bodies.seg"sv, "9758668d0d839c0150a9b8504fdefb90348a41e8"sv}, Entry{"v1-052500-052600-borevents.idx"sv, "b9a7e97f239f176bffae086bc5e5313b5afcc2ab"sv}, Entry{"v1-052500-052600-borevents.seg"sv, "c31d62ad49b4b283653c67316aa73d22c531457f"sv}, Entry{"v1-052500-052600-borspans.idx"sv, "9e2aef885a33315b3ce632e0eeb548dcad9473bf"sv}, Entry{"v1-052500-052600-borspans.seg"sv, "a551561997d7273c1b1c8f29a31648961cca5667"sv}, Entry{"v1-052500-052600-headers.seg"sv, "36a028366578fec33ebc6d576572c55dffd61eb9"sv}, Entry{"v1-052500-052600-transactions-to-block.idx"sv, "761cb0e3fc17bbc5fb4a3b73e14078251181e2ed"sv}, Entry{"v1-052500-052600-transactions.idx"sv, "fe4712774619ef00d615a794a69d8ed064008a74"sv}, Entry{"v1-052500-052600-transactions.seg"sv, "c9bdde698f2b1cf571b3d0030a9004e5cbf51c25"sv}, Entry{"v1-052600-052700-bodies.idx"sv, "94864bcffa073c7d7d58b28d90f6e70f2db3d6cc"sv}, Entry{"v1-052600-052700-bodies.seg"sv, "0f2174a85173e8362e1d288b49d9a94eb267fab8"sv}, Entry{"v1-052600-052700-borevents.idx"sv, "0e5d8caedc19c7596a598875ac0da80f61adf8e1"sv}, Entry{"v1-052600-052700-borevents.seg"sv, "486355d0313b41efc457d14ff8ebdb94b45a8ddc"sv}, Entry{"v1-052600-052700-borspans.idx"sv, "77334a9172fd49e0372b9e7e848d3294e4942782"sv}, Entry{"v1-052600-052700-borspans.seg"sv, "878f0329b95c3b0c1e3027a8885dea82346eb45b"sv}, Entry{"v1-052600-052700-headers.seg"sv, "a1b2ab9647939bdbbd916a1fa42f391090ff29ab"sv}, Entry{"v1-052600-052700-transactions-to-block.idx"sv, "30e786d998d2b7c46b7febd2f91d029353245ff3"sv}, Entry{"v1-052600-052700-transactions.idx"sv, "06ab3887c720de4a60444a0e78f83084c514e046"sv}, Entry{"v1-052600-052700-transactions.seg"sv, "6c9cba5bad0c2c379bbfc6b0111651e070d1abac"sv}, Entry{"v1-052700-052800-bodies.idx"sv, "4ac49f494d0b2a77414af6cc72a908f83e27ecaf"sv}, Entry{"v1-052700-052800-bodies.seg"sv, "408ab333af6d99c341594233afe4c781e52db27f"sv}, Entry{"v1-052700-052800-borevents.idx"sv, "763580f9f166f1c3d040894e8f86d10e8c16103f"sv}, Entry{"v1-052700-052800-borevents.seg"sv, "82b378483afa3163e49d0d89678ea2046e360586"sv}, Entry{"v1-052700-052800-borspans.idx"sv, "cef38963ec9b706f47e2a8ac626b087c39c22fac"sv}, Entry{"v1-052700-052800-borspans.seg"sv, "a25684e064fd7383ba2b5e3d08602aec1db92714"sv}, Entry{"v1-052700-052800-headers.seg"sv, "64c3e10bcac7df24295bc14016831d3bce29317d"sv}, Entry{"v1-052700-052800-transactions-to-block.idx"sv, "3d3878dcbf4cbe544c256f09465a3cb477113453"sv}, Entry{"v1-052700-052800-transactions.idx"sv, "4bcf4743179d143271a274e4f83ea74b3ad02155"sv}, Entry{"v1-052700-052800-transactions.seg"sv, "6721eb93af6f6825f58d30fcd8a653b18dbd80f4"sv}, Entry{"v1-052800-052900-bodies.idx"sv, "65f8d3a3a95ae9e6bd3b62a66c5700dce30b119a"sv}, Entry{"v1-052800-052900-bodies.seg"sv, "601f348b8412ea2529a525ea3acdef00e1a2b962"sv}, Entry{"v1-052800-052900-borevents.idx"sv, "73dc95226404c674197322cfaeac2019f7174bf2"sv}, Entry{"v1-052800-052900-borevents.seg"sv, "a708005c778979057e789d997989050178b6f236"sv}, Entry{"v1-052800-052900-borspans.idx"sv, "7be8ce389dc2f477fb3af9314860941ae448c0d7"sv}, Entry{"v1-052800-052900-borspans.seg"sv, "ff2166170a20f4161e95ce51c554b920484424d7"sv}, Entry{"v1-052800-052900-headers.seg"sv, "45197063382da6912a431a02267385c8e53f2026"sv}, Entry{"v1-052800-052900-transactions-to-block.idx"sv, "96d30fd7c002d81ae7bd1462762c08f83a554201"sv}, Entry{"v1-052800-052900-transactions.idx"sv, "9b9233d32880b45c4a3b6e839ca8ddde70a34cda"sv}, Entry{"v1-052800-052900-transactions.seg"sv, "1399b36197eafd9d15dfbaeb9be83485af4cb4f3"sv}, Entry{"v1-052900-053000-bodies.idx"sv, "020ad92da622b0e3c3e98e2cb7b7f0bb199f5418"sv}, Entry{"v1-052900-053000-bodies.seg"sv, "cc9c6b12b57b29bc07a9088fa95618ce5e1a5895"sv}, Entry{"v1-052900-053000-borevents.idx"sv, "e6bccc41a13627b91f9faa1827ee967403a7e7e4"sv}, Entry{"v1-052900-053000-borevents.seg"sv, "403ac29377880d1b6aa52a3ed07626ea67420754"sv}, Entry{"v1-052900-053000-borspans.idx"sv, "dd5b8f911aeeb4750f569a5d6c97c80215a810d4"sv}, Entry{"v1-052900-053000-borspans.seg"sv, "24eec861569a87b21c89a572e41091981c4b58e7"sv}, Entry{"v1-052900-053000-headers.seg"sv, "9d732f94009a43c1a3db0ded756992e2f281592e"sv}, Entry{"v1-052900-053000-transactions-to-block.idx"sv, "7f7a442fbed807221e470db2d3acb0a02eb692de"sv}, Entry{"v1-052900-053000-transactions.idx"sv, "c9e4b00fa22e174bd3042f0c8c16e43c488b1d6f"sv}, Entry{"v1-052900-053000-transactions.seg"sv, "42883c8c89f9f36fee19e112cb45339fa296b572"sv}, Entry{"v1-053000-053100-bodies.idx"sv, "06c2837424efbc379774e53a28b875546c619110"sv}, Entry{"v1-053000-053100-bodies.seg"sv, "0de9335e03772345e605bdaf92001575e81d5ed3"sv}, Entry{"v1-053000-053100-borevents.idx"sv, "017fd0779805cb9b17a10f1f64df19c1ef2a47f4"sv}, Entry{"v1-053000-053100-borevents.seg"sv, "01c6153ea793d9d92fd98aa1ca6a8c34bb21ae6d"sv}, Entry{"v1-053000-053100-borspans.idx"sv, "419d385e5dfcbe7ddae3e93c2ba4cb09a36344db"sv}, Entry{"v1-053000-053100-borspans.seg"sv, "cad029cf71359b7ac0562e816c413aa97aca62a7"sv}, Entry{"v1-053000-053100-headers.seg"sv, "5642b434ce3e0a47c080a0b546b49b17aac52811"sv}, Entry{"v1-053000-053100-transactions-to-block.idx"sv, "8c3580878ed5169b663334bd1b06765b60c10827"sv}, Entry{"v1-053000-053100-transactions.idx"sv, "8bd7e2009b732b6d6e060c20fa454962319eca87"sv}, Entry{"v1-053000-053100-transactions.seg"sv, "6cc64c3b791c6d8dd3306223205b2bda83acd142"sv}, Entry{"v1-053100-053200-bodies.idx"sv, "8cd1f5f7d34ef0e66bf4a26f59856bb14d5dd908"sv}, Entry{"v1-053100-053200-bodies.seg"sv, "53bb61d1a8b047479f0c1ea6d805afd4f9984c27"sv}, Entry{"v1-053100-053200-borevents.idx"sv, "55bdd9b68af6bbc4fa2a42ecee690602b5c8eba3"sv}, Entry{"v1-053100-053200-borevents.seg"sv, "6e5bdecc9ed0b7f005b670567be5779552a9b9a9"sv}, Entry{"v1-053100-053200-borspans.idx"sv, "a20958aa652c171fa6a65f2f237fdec0d072d681"sv}, Entry{"v1-053100-053200-borspans.seg"sv, "2a1e2221cc59d1fa505ec137c042be10269f5c0d"sv}, Entry{"v1-053100-053200-headers.seg"sv, "39e4df3d9cb5c6109a98fb966ba96aca55e7da46"sv}, Entry{"v1-053100-053200-transactions-to-block.idx"sv, "6ec3ff8a8be1abb9d03fe6f4beb7e9895b1286ad"sv}, Entry{"v1-053100-053200-transactions.idx"sv, "7b1d4bacde2801dbf3115910d027d30cb3975e30"sv}, Entry{"v1-053100-053200-transactions.seg"sv, "ed49ebdcd18cdb3f61c35c24db8a0acbd196ac4e"sv}, Entry{"v1-053200-053300-bodies.idx"sv, "adc55dd4563c723d977840b847776c3d8a3b3d8a"sv}, Entry{"v1-053200-053300-bodies.seg"sv, "6ecdd932649e98cbc5c67f13b09045eae11919e1"sv}, Entry{"v1-053200-053300-borevents.idx"sv, "2ef620cbf1358f82df56c5a94c3876fd528ab94e"sv}, Entry{"v1-053200-053300-borevents.seg"sv, "b6f8325b63924cfab82ff6e834201f6b6307b943"sv}, Entry{"v1-053200-053300-borspans.idx"sv, "4d3d6c85ebe9bb31e7dc07db6394d933c8144072"sv}, Entry{"v1-053200-053300-borspans.seg"sv, "7892b6ed86eb928e260819ccf86c5926b423692e"sv}, Entry{"v1-053200-053300-headers.seg"sv, "5905786deb710f285dceb314d7721f1b0d78203e"sv}, Entry{"v1-053200-053300-transactions-to-block.idx"sv, "f283b6bb971de80046973d4e101c7ced69d7bad1"sv}, Entry{"v1-053200-053300-transactions.idx"sv, "4a8e0682cf815e8657554cd9eaa65832556c80d1"sv}, Entry{"v1-053200-053300-transactions.seg"sv, "626180edc612e0a1e9778b3338b8945697fed3f9"sv}, Entry{"v1-053300-053400-bodies.idx"sv, "ec5917311fae125cfa6f4d53dec572e04b3fa275"sv}, Entry{"v1-053300-053400-bodies.seg"sv, "1fea1b9a0b73012f2009e019333eb3c48e55ceeb"sv}, Entry{"v1-053300-053400-borevents.idx"sv, "05caab3c38d36c4d9b112000dabc72100e96b361"sv}, Entry{"v1-053300-053400-borevents.seg"sv, "feed72cbce7225dd29a820588ec02e93354b380b"sv}, Entry{"v1-053300-053400-borspans.idx"sv, "a4aa916a9384953775d010eb404819554f020cce"sv}, Entry{"v1-053300-053400-borspans.seg"sv, "99c3476fdb0bce7e60b61b1e2064511f16be0be8"sv}, Entry{"v1-053300-053400-headers.seg"sv, "c6827b1579be4845a877f9a994c16f87b7ba94fa"sv}, Entry{"v1-053300-053400-transactions-to-block.idx"sv, "59dde49623da2fd7c36ea8c99be1b5fe66c6669b"sv}, Entry{"v1-053300-053400-transactions.idx"sv, "5852d94668ec6dfd46c6481b7624a12a05dd1291"sv}, Entry{"v1-053300-053400-transactions.seg"sv, "b8de4e55c70ca8d2a9df31cc602479f0dea69203"sv}, Entry{"v1-053400-053500-bodies.idx"sv, "cd3a4b61bee6f1d6e835441d7e3747ef77ab24b9"sv}, Entry{"v1-053400-053500-bodies.seg"sv, "f80cd74ee4b613c8b096e375b6438aed683654fa"sv}, Entry{"v1-053400-053500-borevents.idx"sv, "59999badd03b357e948944046427d2eb29991c37"sv}, Entry{"v1-053400-053500-borevents.seg"sv, "9c735fc719e80a64da6d7cdf35102966a1159067"sv}, Entry{"v1-053400-053500-borspans.idx"sv, "e49312a6766b17fb121e23eb762b26150dba5720"sv}, Entry{"v1-053400-053500-borspans.seg"sv, "dd2789ab90e45a06d85c63741a8e105059574aec"sv}, Entry{"v1-053400-053500-headers.seg"sv, "030bf97dbff7783ccb636d5f169578457d5a90ff"sv}, Entry{"v1-053400-053500-transactions-to-block.idx"sv, "30a9c91dd6310af9eba4c74b9188ec7a0ac9e724"sv}, Entry{"v1-053400-053500-transactions.idx"sv, "8961cc15311887cae5ca37ac1299358c94725f15"sv}, Entry{"v1-053400-053500-transactions.seg"sv, "b7c57d9c5821995d7c090c5d8b68668dbd62e0df"sv}, Entry{"v1-053500-053600-bodies.idx"sv, "1454b74767918f9500ac5c005fcf6b62a3cb3bc6"sv}, Entry{"v1-053500-053600-bodies.seg"sv, "01efda3e2455045ef5bebcb981d13b27c6e21c00"sv}, Entry{"v1-053500-053600-borevents.idx"sv, "95bec063499bc9a301a0d32e66d57e0cdaa95b53"sv}, Entry{"v1-053500-053600-borevents.seg"sv, "6e4f6f252ba9c192a191f0e4ef082c70077229f1"sv}, Entry{"v1-053500-053600-borspans.idx"sv, "0b859cbd7804a4deefa543ad220ad94f2cb637a3"sv}, Entry{"v1-053500-053600-borspans.seg"sv, "ecaed05896dcb660349718f2911768067386a93d"sv}, Entry{"v1-053500-053600-headers.seg"sv, "90ce70e6c9f38bcd82be238653e27b6583ffe72d"sv}, Entry{"v1-053500-053600-transactions-to-block.idx"sv, "009463370c3dccc04b28841de4fb74546a4ff1f1"sv}, Entry{"v1-053500-053600-transactions.idx"sv, "4620d72b195147032975fa8c51eb8f1922769888"sv}, Entry{"v1-053500-053600-transactions.seg"sv, "84afdc7ccb0b96b104f2a22c730863a7b5bcb3d9"sv}, Entry{"v1-053600-053700-bodies.idx"sv, "49cfb0e2475c40d809d00dafeb5e13fde8cbaee5"sv}, Entry{"v1-053600-053700-bodies.seg"sv, "49c04e565d6dd38c8af552d938ce8f7927579ddf"sv}, Entry{"v1-053600-053700-borevents.idx"sv, "cf46b53127b06b41fa686e7c47915e694397662a"sv}, Entry{"v1-053600-053700-borevents.seg"sv, "ae2ae018fc157ff4a0a46625fbd82cdf91917e44"sv}, Entry{"v1-053600-053700-borspans.idx"sv, "715a8898694d64ef81adbab0dac7110b8c6a4a7a"sv}, Entry{"v1-053600-053700-borspans.seg"sv, "a0fb63a424ccf3f984aa095051c5c0f5f45990db"sv}, Entry{"v1-053600-053700-headers.seg"sv, "fe7b44a6ca6c292c4742a2bce847f3363d2304a5"sv}, Entry{"v1-053600-053700-transactions-to-block.idx"sv, "30deab169fbb5a160a721c38879bb403479f5003"sv}, Entry{"v1-053600-053700-transactions.idx"sv, "768fac39aaf9ee58c4f76c4ec6f68126d3c92289"sv}, Entry{"v1-053600-053700-transactions.seg"sv, "4a3a8a19921b877343f7d43eae67a1574f570950"sv}, Entry{"v1-053700-053800-bodies.idx"sv, "5c13d5730295eaed6490f60cd0da758f5715920b"sv}, Entry{"v1-053700-053800-bodies.seg"sv, "9bea9136640bc436333292cf0c1c31ed57ec6fe6"sv}, Entry{"v1-053700-053800-borevents.idx"sv, "b6e87cbac4bfcf9a718e5adec052729ebaa0e03c"sv}, Entry{"v1-053700-053800-borevents.seg"sv, "a954a87a2826955d6ad1f6a13aaaf056e6db746f"sv}, Entry{"v1-053700-053800-borspans.idx"sv, "3c2402f53e2e2e82f5aae2cd28205db11e65d4b9"sv}, Entry{"v1-053700-053800-borspans.seg"sv, "fd1bcae1e4e50e91f36fd1124dce28dda4651342"sv}, Entry{"v1-053700-053800-headers.seg"sv, "6e8cc8310082aa9a7cd3b48e47a83e05666142b1"sv}, Entry{"v1-053700-053800-transactions-to-block.idx"sv, "c5583c73f9e96683d9d96f101b8e39500e46b7a7"sv}, Entry{"v1-053700-053800-transactions.idx"sv, "17c6237b5b053e837c9b0db40ccce797e135b578"sv}, Entry{"v1-053700-053800-transactions.seg"sv, "bdae6a6152ce2e89d24a56b6144e5700dac9f1ea"sv}, Entry{"v1-053800-053900-bodies.idx"sv, "46188c2784cb01017cade594627625177d8fb844"sv}, Entry{"v1-053800-053900-bodies.seg"sv, "8477e125f746b17f782417c75a0fbdcd56224c0b"sv}, Entry{"v1-053800-053900-borevents.idx"sv, "eaa795e426432529c4976a80374276be48618ec9"sv}, Entry{"v1-053800-053900-borevents.seg"sv, "a506bd06dacac1000285e308dc69428eaaf768d1"sv}, Entry{"v1-053800-053900-borspans.idx"sv, "a258a307c78ae9d8a731a91d13b6585fa5e9cafd"sv}, Entry{"v1-053800-053900-borspans.seg"sv, "00fdd5b1bbd78b88809da5f9f3e4977d5cc53f5f"sv}, Entry{"v1-053800-053900-headers.seg"sv, "41e2523284e05bc18cadd7e359446e329c253677"sv}, Entry{"v1-053800-053900-transactions-to-block.idx"sv, "4cb8cde327f5f376453f301fe4d8574060f96986"sv}, Entry{"v1-053800-053900-transactions.idx"sv, "38f97a97d90e11baf28575b8fc91092bc54c51d1"sv}, Entry{"v1-053800-053900-transactions.seg"sv, "bf5c98bf3f1a4bc1910868dee66d83c3a95aba19"sv}, Entry{"v1-053900-054000-bodies.idx"sv, "3c5101f44675371d068ee8ea239b492042c2e82d"sv}, Entry{"v1-053900-054000-bodies.seg"sv, "8d9ef8ac1230236cc840df56457621035dd44036"sv}, Entry{"v1-053900-054000-borevents.idx"sv, "19836e33976a06c57e2166881426e475cff6bf19"sv}, Entry{"v1-053900-054000-borevents.seg"sv, "d9299c5e940a768d8c12e36618d05b06585281c4"sv}, Entry{"v1-053900-054000-borspans.idx"sv, "3a3db48a97c883bb405cbef850bf592778b0804a"sv}, Entry{"v1-053900-054000-borspans.seg"sv, "503725d429a5ed6c065a1250eb3ce8243aeb0618"sv}, Entry{"v1-053900-054000-headers.seg"sv, "f57224bc1bd2ff0dbd0a183c2577545e64dd4cb4"sv}, Entry{"v1-053900-054000-transactions-to-block.idx"sv, "c18f757d2c829255929b67c25aa3937621c8c688"sv}, Entry{"v1-053900-054000-transactions.idx"sv, "030b8cf57689c83e9f7ee605de9d76494a172890"sv}, Entry{"v1-053900-054000-transactions.seg"sv, "b8d2b74ea0bb808aa8b54b7b8d9358d662ee0fb6"sv}, Entry{"v1-054000-054100-bodies.idx"sv, "523344f31e2a748844afca55679cc991d055126e"sv}, Entry{"v1-054000-054100-bodies.seg"sv, "02876d35bdfa5227f083410e86b8896922398978"sv}, Entry{"v1-054000-054100-borevents.idx"sv, "e36f691178e8ba4c6dbb0cac8c18c6fc430bb573"sv}, Entry{"v1-054000-054100-borevents.seg"sv, "64b1d867b163bb138f5c4093a7091d0e2de2b99c"sv}, Entry{"v1-054000-054100-borspans.idx"sv, "0f6e64e75bf4032eeb2d57aef15f7e96c43b2d32"sv}, Entry{"v1-054000-054100-borspans.seg"sv, "182ba5ebdd8f980ed56e20398a462d36a48e417e"sv}, Entry{"v1-054000-054100-headers.idx"sv, "a20efd5aca03ebb528215b24ce6aa0c20cc90c55"sv}, Entry{"v1-054000-054100-headers.seg"sv, "05928b21c6aa8934da5c8cf6b2b0a3278d8828f2"sv}, Entry{"v1-054000-054100-transactions-to-block.idx"sv, "a3789f94a2ce048f3003792961254e2b3be34a16"sv}, Entry{"v1-054000-054100-transactions.idx"sv, "8d21e083ea38ab18de99a1ee20d4fab3f84b41c2"sv}, Entry{"v1-054000-054100-transactions.seg"sv, "94b0a1f4f92e841c64a5b793994462f086aaa410"sv}, Entry{"v1-054100-054200-bodies.idx"sv, "1fd6e93ab051ff7b7971c02a3a8bcd6b2c61482d"sv}, Entry{"v1-054100-054200-bodies.seg"sv, "f0ac4c13727f5a5ffef3163254d1c6012de20dfc"sv}, Entry{"v1-054100-054200-borevents.idx"sv, "2e341a847088a52ab77e538418cb7d50518002e6"sv}, Entry{"v1-054100-054200-borevents.seg"sv, "329f611fcb144494bb93fbca4783f66cba3c1c7c"sv}, Entry{"v1-054100-054200-borspans.idx"sv, "a1e5d9d8eadd29064f421a2aa23c5fdaf5ef68f1"sv}, Entry{"v1-054100-054200-borspans.seg"sv, "b07cb6f7153654a2978c6dcce19372b353ad1cbf"sv}, Entry{"v1-054100-054200-headers.idx"sv, "517a7795982774a65c581f1a5af4e77773a2cff1"sv}, Entry{"v1-054100-054200-headers.seg"sv, "a744c495e3d5ef9e9b36e6dc02aed4d5cb3b0383"sv}, Entry{"v1-054100-054200-transactions-to-block.idx"sv, "2e00d0eeb71c6a34ab07ae56ec39228ae7b0dd57"sv}, Entry{"v1-054100-054200-transactions.idx"sv, "4b6cf90b3538207e9e5058f987d6daece0ac7b21"sv}, Entry{"v1-054100-054200-transactions.seg"sv, "b1a36e7ab457af1990ed5df89087515fce1947e4"sv}, Entry{"v1-054200-054300-bodies.idx"sv, "ef04059b958462dca34631f4de2c36e74ba4b195"sv}, Entry{"v1-054200-054300-bodies.seg"sv, "22c822663b7ed7e24f33145eca4c176ee20fcb1f"sv}, Entry{"v1-054200-054300-borevents.idx"sv, "cf8d3905f705177b659b15a09d8bc5196a32bf6b"sv}, Entry{"v1-054200-054300-borevents.seg"sv, "de34b24ca728a942926275d45510ab8a4e955840"sv}, Entry{"v1-054200-054300-borspans.idx"sv, "4a999ba2a701b635542c66d1104a97cd4e678ce1"sv}, Entry{"v1-054200-054300-borspans.seg"sv, "efe8e42b5e47fd9039928b078d8a4892aea848a3"sv}, Entry{"v1-054200-054300-headers.idx"sv, "a0c9200b333ebb7689ef06203ab427c31058c96c"sv}, Entry{"v1-054200-054300-headers.seg"sv, "2b1043ac9735666faf59780142e81c5be7a1b07a"sv}, Entry{"v1-054200-054300-transactions-to-block.idx"sv, "53b7795ff33dfdbfffcb5c6705f2a7ae30b47cd2"sv}, Entry{"v1-054200-054300-transactions.idx"sv, "dc6390be5e58c9af3baca7afe2d8ad281569eee2"sv}, Entry{"v1-054200-054300-transactions.seg"sv, "c0782783c6a5f9e43d456ed1dd2b40d90db38390"sv}, Entry{"v1-054300-054400-bodies.idx"sv, "e566718523396989e726c1ce664b0dc1b4f5a4bd"sv}, Entry{"v1-054300-054400-bodies.seg"sv, "83c8f23cb7b4916b02c8637c711683b52a9f462f"sv}, Entry{"v1-054300-054400-borevents.idx"sv, "b557ccb90b285b1f8cc2fe6e303b93d20349666e"sv}, Entry{"v1-054300-054400-borevents.seg"sv, "bd1360e19bc477a88eae7e6c57f44c6a02284abc"sv}, Entry{"v1-054300-054400-borspans.idx"sv, "d03258e7e7150b92e978477095c25f3037ddeb86"sv}, Entry{"v1-054300-054400-borspans.seg"sv, "cdc8d8d42e1713a5e1986dc88ea3cd267bfd1d24"sv}, Entry{"v1-054300-054400-headers.idx"sv, "33b82ad2c388b7ee93c292f4f89dbfebd27211ee"sv}, Entry{"v1-054300-054400-headers.seg"sv, "403a492c46703ca3c8b8f284a189f68418b635f1"sv}, Entry{"v1-054300-054400-transactions-to-block.idx"sv, "df816c9c5e781d9e3b7a1697763849166d8e222d"sv}, Entry{"v1-054300-054400-transactions.idx"sv, "96914fba22ea2eb77c580fbd258f4831290859b7"sv}, Entry{"v1-054300-054400-transactions.seg"sv, "a453279a1cf2aecc2a2c81dd4153f508569faf22"sv}, Entry{"v1-054400-054500-bodies.idx"sv, "9b2f6c38d29f3e01e116bf6849086a16053c0a36"sv}, Entry{"v1-054400-054500-bodies.seg"sv, "e4ffab8a5e1446d562c0168b2a315ece367adacf"sv}, Entry{"v1-054400-054500-borevents.idx"sv, "eb330b0da84b76f2c8b8df95305a9265a8784961"sv}, Entry{"v1-054400-054500-borevents.seg"sv, "46c54b8c03059353815f09f70cbcf548af1d6465"sv}, Entry{"v1-054400-054500-borspans.idx"sv, "52d71a7f5463f48316c4b4b33e7e5512bc510330"sv}, Entry{"v1-054400-054500-borspans.seg"sv, "f1f948f823d4ead8e65a6e8190c1131ee59fda9a"sv}, Entry{"v1-054400-054500-headers.idx"sv, "36086caef98ef06a272bc9e50feaeffdce6f19c9"sv}, Entry{"v1-054400-054500-headers.seg"sv, "648a11795a7af76174a08c60622b5aaae76a6cf8"sv}, Entry{"v1-054400-054500-transactions-to-block.idx"sv, "73f6ea19f96a80bb93cb4821366b495e84263af8"sv}, Entry{"v1-054400-054500-transactions.idx"sv, "1968c2aa4b631ebdb8f2aed25077bc1dfbe0ad15"sv}, Entry{"v1-054400-054500-transactions.seg"sv, "e5dcf761ad3195c5cae23accdee5a3396051740f"sv}, Entry{"v1-054500-054600-bodies.idx"sv, "b9ecb59d5f75f80225b3a8d74826a4b85a93e0f4"sv}, Entry{"v1-054500-054600-bodies.seg"sv, "9d63669efea7e58a7760e5ce5072f5f85f6e868d"sv}, Entry{"v1-054500-054600-borevents.idx"sv, "419da03dd4278d7c622d1d7ad7f2eab07bbb8ba1"sv}, Entry{"v1-054500-054600-borevents.seg"sv, "9c3762b9086a96551c38f4551fe038fc1a489844"sv}, Entry{"v1-054500-054600-borspans.idx"sv, "d9fa184e90144ec225c2fe9b7716d37ee909af7c"sv}, Entry{"v1-054500-054600-borspans.seg"sv, "bde8d86fa29b6000b4f2eb3c0cda6e78b9f62d45"sv}, Entry{"v1-054500-054600-headers.idx"sv, "ae464bc75cb3a55fd2c056f4a45dc75459d0eaf7"sv}, Entry{"v1-054500-054600-headers.seg"sv, "0dbab81aec422268384b5169421a34128676f7a7"sv}, Entry{"v1-054500-054600-transactions-to-block.idx"sv, "2018c852dab9a70c24dcb88bf0a9f41d50374801"sv}, Entry{"v1-054500-054600-transactions.idx"sv, "7d08c89b0e1a9b0853a91df1948c926c221bea7c"sv}, Entry{"v1-054500-054600-transactions.seg"sv, "028aa453a3fe0eaa8b63268ce6c86d6cd2ea0922"sv}, Entry{"v1-054600-054700-bodies.idx"sv, "23ad164a4944cc1abfdb352149e23c280aa2cb92"sv}, Entry{"v1-054600-054700-bodies.seg"sv, "c0f61592bfdb3b36fe690cb47c7f2dc42c99c032"sv}, Entry{"v1-054600-054700-borevents.idx"sv, "48b17d95e99e4ef394883d007ca61961f113324c"sv}, Entry{"v1-054600-054700-borevents.seg"sv, "25582004cf1f360092d2ea66cca95e55980173a9"sv}, Entry{"v1-054600-054700-borspans.idx"sv, "91a9aa5c5e639193ebe3696657a988d74d708616"sv}, Entry{"v1-054600-054700-borspans.seg"sv, "a55444f2fd3f6bf44bc4f29ee423dd10467e0380"sv}, Entry{"v1-054600-054700-headers.idx"sv, "c04ca2d6c3f76e23de6a529223f2e331b2d71dbd"sv}, Entry{"v1-054600-054700-headers.seg"sv, "33324620ec5e00ec853eeab0ad843d464904d3c9"sv}, Entry{"v1-054600-054700-transactions-to-block.idx"sv, "ddf85400e227d0b8d82da7ab6c8781b6ada2f369"sv}, Entry{"v1-054600-054700-transactions.idx"sv, "c1e8713110bd3a3099443e9d4db0dc36a35be670"sv}, Entry{"v1-054600-054700-transactions.seg"sv, "fd5b5afa8a985886843b0581d40728037bdb3673"sv}, Entry{"v1-054700-054800-bodies.idx"sv, "c5bfc0c8f37c9e6d9f8d23af308b2d36519ffbff"sv}, Entry{"v1-054700-054800-bodies.seg"sv, "bffec25daa0df15b4d102dfae72729601c8f9ad0"sv}, Entry{"v1-054700-054800-borevents.idx"sv, "6fd32fdb29fcc3def6021043aedfbbff2c1c45f3"sv}, Entry{"v1-054700-054800-borevents.seg"sv, "3c8815a6c5e387ced403711ab345362b56732ecb"sv}, Entry{"v1-054700-054800-borspans.idx"sv, "63d0f665315107b0f7e7eb234fb0bdfbd5c9624c"sv}, Entry{"v1-054700-054800-borspans.seg"sv, "13c317c3d411fb3fbe3b25db8d293df695912b5d"sv}, Entry{"v1-054700-054800-headers.idx"sv, "e3684b1b7f23a6dd8e841f132c12ec8dd647c13f"sv}, Entry{"v1-054700-054800-headers.seg"sv, "375bb37239471b8c0806cb8d2860b43e12abda8d"sv}, Entry{"v1-054700-054800-transactions-to-block.idx"sv, "9be7cf95b0baa073c1bc39652666acb3656f69c1"sv}, Entry{"v1-054700-054800-transactions.idx"sv, "5aa498aacd55ee48dc84a061231bd2496e2033d6"sv}, Entry{"v1-054700-054800-transactions.seg"sv, "d7cfa32028d19f047baac995e02fd5c472750103"sv}, Entry{"v1-054800-054900-bodies.idx"sv, "dbe993ab0e8b9a4a2c169dce7e02e801e76b5a76"sv}, Entry{"v1-054800-054900-bodies.seg"sv, "332721b9209e82eb8a4893637539c46b4966a461"sv}, Entry{"v1-054800-054900-borevents.idx"sv, "e531dda0186f27d36670f6e7e53fbfe3d9bd8c02"sv}, Entry{"v1-054800-054900-borevents.seg"sv, "ff15e5774d86ed08afe09bd2a3ebba5b144f2572"sv}, Entry{"v1-054800-054900-borspans.idx"sv, "3d338f805b61b689acdcac7e68b967edc8f6c296"sv}, Entry{"v1-054800-054900-borspans.seg"sv, "2c1f09142ce87ae58dc28d203ced81b66a2b04ce"sv}, Entry{"v1-054800-054900-headers.idx"sv, "edc903508495cebee638c67ea377c0eba7d2485d"sv}, Entry{"v1-054800-054900-headers.seg"sv, "7a7d9f9b6d17730d247e4f47630886bdf37098a3"sv}, Entry{"v1-054800-054900-transactions-to-block.idx"sv, "d40cd75624f406b25ff9ea866650f00ca2deeda3"sv}, Entry{"v1-054800-054900-transactions.idx"sv, "ad9c0aef510c23b6b2f657aef5b481498f91339a"sv}, Entry{"v1-054800-054900-transactions.seg"sv, "ec4a61c12943a6eccfc68ac1a4243333febdd6c1"sv}, Entry{"v1-054900-055000-bodies.idx"sv, "ff180423c289800305eb7af32187c8a3439a7c3f"sv}, Entry{"v1-054900-055000-bodies.seg"sv, "7d57305bc15047ad8c80330758f9f705e4f441ad"sv}, Entry{"v1-054900-055000-borevents.idx"sv, "5c3cf99374e67ecbc91163a2a25202dce4f70d6c"sv}, Entry{"v1-054900-055000-borevents.seg"sv, "023a5f31f5cf462a9acdb74acfdefdefec86e87e"sv}, Entry{"v1-054900-055000-borspans.idx"sv, "60f7320d558fb85d9f3aeabe14de55927535610b"sv}, Entry{"v1-054900-055000-borspans.seg"sv, "c8fcaa82443fe0a878336c1d23e7f734d3c46664"sv}, Entry{"v1-054900-055000-headers.idx"sv, "38468edba0a5cb4834504b4d2163901d30036a46"sv}, Entry{"v1-054900-055000-headers.seg"sv, "3309e1549ca29e42504527dd50b30c1edbffa242"sv}, Entry{"v1-054900-055000-transactions-to-block.idx"sv, "6f679379e4e5ad38095cc044b4a04f4fb982f3b2"sv}, Entry{"v1-054900-055000-transactions.idx"sv, "40bff13e34be2c29161975d860aea499e33c5956"sv}, Entry{"v1-054900-055000-transactions.seg"sv, "985090f467ff5d9c09c2aed8e0065cfb9f2c03b8"sv}, Entry{"v1-055000-055100-bodies.idx"sv, "05648887f79227659201a863c9a9f4890550e201"sv}, Entry{"v1-055000-055100-bodies.seg"sv, "394e0a20061f2ed339c4dfa22644761473d0d130"sv}, Entry{"v1-055000-055100-borevents.idx"sv, "0ca30f35570845d280c7ad8b1b5ee05fddc5febd"sv}, Entry{"v1-055000-055100-borevents.seg"sv, "7e9664a94330a6782c97dc27e39fc900c126f5d7"sv}, Entry{"v1-055000-055100-borspans.idx"sv, "09edf959a877e4ce5824194deb318e53e2758fb6"sv}, Entry{"v1-055000-055100-borspans.seg"sv, "ed4a67e2916b926eb4dc705f39c5434aef3c77dd"sv}, Entry{"v1-055000-055100-headers.idx"sv, "adcb5feba140cfa9c321ec9124ed01a9553f5c68"sv}, Entry{"v1-055000-055100-headers.seg"sv, "0019104a1148d8553fb23f0c6c2ac592f1bbb25f"sv}, Entry{"v1-055000-055100-transactions-to-block.idx"sv, "768cdbd931df09df215564f87d557389657af265"sv}, Entry{"v1-055000-055100-transactions.idx"sv, "6a4d85c388a006c142cbfaba6a7d9b4f0adda002"sv}, Entry{"v1-055000-055100-transactions.seg"sv, "4179ac49d00b1bce5e4bb96a11023e958a99af11"sv}, Entry{"v1-055100-055200-bodies.idx"sv, "724bb91312cc6aacf1b8f2c2ce1530d80e9ef5d1"sv}, Entry{"v1-055100-055200-bodies.seg"sv, "47a4548e224f25abec8bf874fa2c3c1ba0122e04"sv}, Entry{"v1-055100-055200-borevents.idx"sv, "db80ea720cce548491673df7b0a416b80006c5e7"sv}, Entry{"v1-055100-055200-borevents.seg"sv, "1f920398b44f359f6d27f4d1071ae97e8703859b"sv}, Entry{"v1-055100-055200-borspans.idx"sv, "ac7355308a87af80b990d322bb9b5e2a3e7d9efa"sv}, Entry{"v1-055100-055200-borspans.seg"sv, "3a18a3a105b8e51e4ab263673b3dac745a1a1a35"sv}, Entry{"v1-055100-055200-headers.idx"sv, "3e458b3a89b000d36c88336f470456f6d1dcf639"sv}, Entry{"v1-055100-055200-headers.seg"sv, "0fc69402e90ca5975fdae9a9d05025e76a3ad32f"sv}, Entry{"v1-055100-055200-transactions-to-block.idx"sv, "e28976bd2be1fe7c1c1baca9832cbea748fd3e26"sv}, Entry{"v1-055100-055200-transactions.idx"sv, "246091d36521f95b8c254a9820777e32e9a1aa71"sv}, Entry{"v1-055100-055200-transactions.seg"sv, "207355b4368abf521dcd2c4dc8007a057ff8b5d5"sv}, Entry{"v1-055200-055300-bodies.idx"sv, "4981bfaac3058ef7b8d7081885dfa45f6e0ba450"sv}, Entry{"v1-055200-055300-bodies.seg"sv, "912b3417e499296663e73e970cd8926bb8bec9b0"sv}, Entry{"v1-055200-055300-borevents.idx"sv, "81b7d9bed18c977afe11faade1b8d377f876616f"sv}, Entry{"v1-055200-055300-borevents.seg"sv, "31c5a94bdc0fc9b39e0c28f77cbfea5ceec34f59"sv}, Entry{"v1-055200-055300-borspans.idx"sv, "4ff916a255c4cf91eea0ebddfb3339ec5c57c930"sv}, Entry{"v1-055200-055300-borspans.seg"sv, "b0095208480d3ea31907267d5162c07824a72a33"sv}, Entry{"v1-055200-055300-headers.idx"sv, "95e345e0827b63197657730a7967abf2a0650ca1"sv}, Entry{"v1-055200-055300-headers.seg"sv, "08346a1c591298fcb07bc1ba2937ef46831e79d1"sv}, Entry{"v1-055200-055300-transactions-to-block.idx"sv, "89896b024a8396d26afc12cf19f80ed73a7e9215"sv}, Entry{"v1-055200-055300-transactions.idx"sv, "ff38632915cf52ebd603f0a39bc00eb9c0157deb"sv}, Entry{"v1-055200-055300-transactions.seg"sv, "04255275a34ff36843299530e543798d53e2d0e1"sv}, Entry{"v1-055300-055400-bodies.idx"sv, "512e499614491c301fd130253005ce20b0b2250f"sv}, Entry{"v1-055300-055400-bodies.seg"sv, "6cb60f11c673841345f682bb7bd840d971d229e3"sv}, Entry{"v1-055300-055400-borevents.idx"sv, "f4c05db86a0e305791aae4e1cfb565817e6a0cbf"sv}, Entry{"v1-055300-055400-borevents.seg"sv, "3aec635d0093023944469957da684ee59f748fff"sv}, Entry{"v1-055300-055400-borspans.idx"sv, "54ac54f77a6b07bf52fa1e1308019e7562bf714e"sv}, Entry{"v1-055300-055400-borspans.seg"sv, "8f3fe108f6f89d002915f1b12bd5cebfd10cb929"sv}, Entry{"v1-055300-055400-headers.idx"sv, "0ad13bbf347fe474ff3e6b85aab8e80619d00803"sv}, Entry{"v1-055300-055400-headers.seg"sv, "fabaa0c1fa1ab021c538ae10a46ed969d1cc7032"sv}, Entry{"v1-055300-055400-transactions-to-block.idx"sv, "6d786ed6f0d74df5366ce32087d3353a75ef7f15"sv}, Entry{"v1-055300-055400-transactions.idx"sv, "a64d6d2915f750677869c43638327ef13cb2277b"sv}, Entry{"v1-055300-055400-transactions.seg"sv, "093bcc1ff03c60ca636f609e513b1d5af0838783"sv}, Entry{"v1-055400-055500-bodies.idx"sv, "7fa45540d5c67d47019e856ef46716e2a2551c30"sv}, Entry{"v1-055400-055500-bodies.seg"sv, "e6ecf7122387f5e5e2f79824c37956bd2e6b6205"sv}, Entry{"v1-055400-055500-borevents.idx"sv, "ad8f595eb3366bcfa423dd06c223bec9019bff19"sv}, Entry{"v1-055400-055500-borevents.seg"sv, "42a93fcf56a4b99b35e11fb371529ffad313668e"sv}, Entry{"v1-055400-055500-borspans.idx"sv, "d7a84727d039eb171e90aafad13706e902277322"sv}, Entry{"v1-055400-055500-borspans.seg"sv, "7fb532997a0cfc71af0899f2617673af941dff6e"sv}, Entry{"v1-055400-055500-headers.idx"sv, "e136438535251c6134d7140d6df32f20ae70c548"sv}, Entry{"v1-055400-055500-headers.seg"sv, "19bdb4ec75d186a2abda01ca72c90422c1bcb577"sv}, Entry{"v1-055400-055500-transactions-to-block.idx"sv, "2be94be77a68598ee315958d81e22c52c12479cd"sv}, Entry{"v1-055400-055500-transactions.idx"sv, "47682a09d98ff9cb40b2402e8ab941cc45063d40"sv}, Entry{"v1-055400-055500-transactions.seg"sv, "1db5266925ef2a4a35a5548470210bf106d157af"sv}, Entry{"v1-055500-055600-bodies.idx"sv, "b7aacb806483e18bd48d1c83b702f7b47bebeba1"sv}, Entry{"v1-055500-055600-bodies.seg"sv, "131ae57953a4a75ab5c29d4bdc95179270c76155"sv}, Entry{"v1-055500-055600-borevents.idx"sv, "af1711225a1cbc821acf3ffce8154abd6e30cd59"sv}, Entry{"v1-055500-055600-borevents.seg"sv, "fec4e6b770647d00974b0c49167263ff35228bda"sv}, Entry{"v1-055500-055600-borspans.idx"sv, "8ff308e788d5e429844e756148cd26fcc5e3ec03"sv}, Entry{"v1-055500-055600-borspans.seg"sv, "1e2f4a485a636f48579d636311d4a17c65f4d818"sv}, Entry{"v1-055500-055600-headers.idx"sv, "f8e8b084ed4264524e3cee7483718ce91b545bbc"sv}, Entry{"v1-055500-055600-headers.seg"sv, "7642fce51f2bee19ae412b0d384517233a8886f2"sv}, Entry{"v1-055500-055600-transactions-to-block.idx"sv, "de4ee5648849c6fe866d020c02d67d106917aa82"sv}, Entry{"v1-055500-055600-transactions.idx"sv, "0263ee4e2ea0a926661dce9de6aacfc64c27b9d1"sv}, Entry{"v1-055500-055600-transactions.seg"sv, "1092f9586fdb4f182f631df39ced8d05e052812c"sv}, Entry{"v1-055600-055700-bodies.idx"sv, "54097a941da9524d42d615da63d93689dc8ef305"sv}, Entry{"v1-055600-055700-bodies.seg"sv, "b5ac42a424195f58abf0b2748a558178444206de"sv}, Entry{"v1-055600-055700-borevents.idx"sv, "2cb2cad49b1621919c0f9f8b5d5b21067296f9c1"sv}, Entry{"v1-055600-055700-borevents.seg"sv, "a20192cca83db49b56b5a5631869ad2cf01568bb"sv}, Entry{"v1-055600-055700-borspans.idx"sv, "3fd1e95634a52578ab3c2108d1f35334e8087757"sv}, Entry{"v1-055600-055700-borspans.seg"sv, "466da8c8a6aa273a8e2b3ebc3b7db313d4ce2d2c"sv}, Entry{"v1-055600-055700-headers.idx"sv, "adf7b90812a81973f1f9353642dcaf475630fa21"sv}, Entry{"v1-055600-055700-headers.seg"sv, "d582fa24b5930a672dcfd834a4baa1fc378df6f4"sv}, Entry{"v1-055600-055700-transactions-to-block.idx"sv, "a72edc2c6e51a68b9453bdd0d5a9992026c06547"sv}, Entry{"v1-055600-055700-transactions.idx"sv, "aebb5c5d060461a2b1290a95cb128dcccf96559f"sv}, Entry{"v1-055600-055700-transactions.seg"sv, "904115ea65340e5115977d1b48c9acf57678eda7"sv}, Entry{"v1-055700-055800-bodies.idx"sv, "ad71427a3431271ae76af579ed527d7fb764921c"sv}, Entry{"v1-055700-055800-bodies.seg"sv, "69c7a78a916cbc9844f30937a6d130dd2d88d0d6"sv}, Entry{"v1-055700-055800-borevents.idx"sv, "ef7402221bd1d5fa375d1d87e55781d939a27cd2"sv}, Entry{"v1-055700-055800-borevents.seg"sv, "2039ad0a1405e0f6565db1ba2a6835c967fc3dcb"sv}, Entry{"v1-055700-055800-borspans.idx"sv, "d31e1d79865e68adb56a610c4d17088708be2f49"sv}, Entry{"v1-055700-055800-borspans.seg"sv, "425da6d5cefb95734ebc30fa5c6fd321d840b5f2"sv}, Entry{"v1-055700-055800-headers.idx"sv, "7acf32a5bcef353a8a0a43f718eb26acf35d800f"sv}, Entry{"v1-055700-055800-headers.seg"sv, "0f51d9d5bacf49902145d3352332357856fa227c"sv}, Entry{"v1-055700-055800-transactions-to-block.idx"sv, "69d564a97af7c514b751606e37da4784c8a12e72"sv}, Entry{"v1-055700-055800-transactions.idx"sv, "cece71abd15d67940429957a5bc58e2a5c9544ac"sv}, Entry{"v1-055700-055800-transactions.seg"sv, "e039e1d00a6571da24975e476f3b77465248eae9"sv}, Entry{"v1-055800-055900-bodies.idx"sv, "41bef23f8c355fa1f42aba9f915a9d83720982b6"sv}, Entry{"v1-055800-055900-bodies.seg"sv, "b5a0ac9cb5ef0760c193f8ab5c0fc9f9961806cd"sv}, Entry{"v1-055800-055900-borevents.idx"sv, "963659683c4904ba859f3cde5c8a654a514ba792"sv}, Entry{"v1-055800-055900-borevents.seg"sv, "525a231fc2f39ffdffc03514a93b3b3ff10d9965"sv}, Entry{"v1-055800-055900-borspans.idx"sv, "fe572ca7b07c2d9264e70dab45c8696ff1a8c1aa"sv}, Entry{"v1-055800-055900-borspans.seg"sv, "1358c9409c790623c03220f7190a78c25e5e2003"sv}, Entry{"v1-055800-055900-headers.idx"sv, "08d884ef6c42a5faf343e54e7b832ca3fdd86d1c"sv}, Entry{"v1-055800-055900-headers.seg"sv, "11280849f832c5d57303dadcaf0446e7a03cc093"sv}, Entry{"v1-055800-055900-transactions-to-block.idx"sv, "5c25da45b5d7cd88b44c21f5f008d34e76ef193c"sv}, Entry{"v1-055800-055900-transactions.idx"sv, "837cc6b260e13f34d3262700d0a1eed3cbb66499"sv}, Entry{"v1-055800-055900-transactions.seg"sv, "233a76922f8b293a74c72914b9eda3d3bb1785d2"sv}, Entry{"v1-055900-056000-bodies.idx"sv, "71f17fec01fce66f331aa7167cf36c9b7427ea11"sv}, Entry{"v1-055900-056000-bodies.seg"sv, "9298d52192d0fbc3029f0aecc9a1492bbe2e45bd"sv}, Entry{"v1-055900-056000-borevents.idx"sv, "96d0f561c6e8639ac00c4d15f020364e7e83e7ff"sv}, Entry{"v1-055900-056000-borevents.seg"sv, "a420d7e35bb02adf2b9a66559bbb542b1cce4986"sv}, Entry{"v1-055900-056000-borspans.idx"sv, "2815f3edfbbface6369b5074b457b21b19f88c7a"sv}, Entry{"v1-055900-056000-borspans.seg"sv, "c359b38a6a92c6cf4e479db087ef8df89dbc382a"sv}, Entry{"v1-055900-056000-headers.idx"sv, "091dbc5ba069b0d8b6bc85da4bfe4cc26d606b78"sv}, Entry{"v1-055900-056000-headers.seg"sv, "b363539a6354a9e28639100b14a7a2e4a047b972"sv}, Entry{"v1-055900-056000-transactions-to-block.idx"sv, "8aea6f2cd759480ed20b31f7fe0d58b52a670a82"sv}, Entry{"v1-055900-056000-transactions.idx"sv, "4e123e389e151ae87dace3f3580eba4d4eac1c92"sv}, Entry{"v1-055900-056000-transactions.seg"sv, "3f3fbe6dbea0728561df1e25c0869f8362e3e3e8"sv}, Entry{"v1-056000-056100-bodies.idx"sv, "65716664e4cdd3b2f955eaa3c657ec81a358dafc"sv}, Entry{"v1-056000-056100-bodies.seg"sv, "4554147738eb84b31609514c1aea77e3b9e2f0d8"sv}, Entry{"v1-056000-056100-borevents.idx"sv, "130bbf2d8fa1acb0d1a8448a41db48ba411a184e"sv}, Entry{"v1-056000-056100-borevents.seg"sv, "56cf06d4461abdede02cf6f24be033651980eeab"sv}, Entry{"v1-056000-056100-borspans.idx"sv, "1655c24264b91b18d1e8bc330fadf7bcaf72feb6"sv}, Entry{"v1-056000-056100-borspans.seg"sv, "df64a5aea705e375db686fcd6742b75b074fe983"sv}, Entry{"v1-056000-056100-headers.idx"sv, "a65a31388d043ba4286a0d017e4ac3b81d0d9fc4"sv}, Entry{"v1-056000-056100-headers.seg"sv, "cba554fd9b9dfa01a3243e728482b1f7cccb9f61"sv}, Entry{"v1-056000-056100-transactions-to-block.idx"sv, "c3ef639a64deb61af6ac2f51e0ba3b7e4ee4e1ef"sv}, Entry{"v1-056000-056100-transactions.idx"sv, "ccc49d2d7b8721dfa61e5a71b49e52c66800a34e"sv}, Entry{"v1-056000-056100-transactions.seg"sv, "0dfd681164a8974db5bbc5b1381c47e67e3bc477"sv}, Entry{"v1-056100-056200-bodies.idx"sv, "c0a42bc2100080078ad70d65aeeb56f6a0b430e3"sv}, Entry{"v1-056100-056200-bodies.seg"sv, "59057d5963014f1ad46ff58e0ec7737e363b17cf"sv}, Entry{"v1-056100-056200-borevents.idx"sv, "76a70764b7be93d9eff2061bd73f60ca0b29ce94"sv}, Entry{"v1-056100-056200-borevents.seg"sv, "371911d292ff66fd5605614f21fa1a0a5bc3fba7"sv}, Entry{"v1-056100-056200-borspans.idx"sv, "d60922ca7ed88742f066177f8e48abcd31aba924"sv}, Entry{"v1-056100-056200-borspans.seg"sv, "1d467495f28e4d124cd07ee1a891b0d88a93ca94"sv}, Entry{"v1-056100-056200-headers.idx"sv, "a51e06b055344842595548a565382376b8749f1c"sv}, Entry{"v1-056100-056200-headers.seg"sv, "0eadb2d449b05099b5aad27e0ea45c649abaa3f1"sv}, Entry{"v1-056100-056200-transactions-to-block.idx"sv, "1457dd879fa1413677bdf3cb3f36eb76c92d65eb"sv}, Entry{"v1-056100-056200-transactions.idx"sv, "e23ef75e6e707a60c160e2cd24853e09b54da966"sv}, Entry{"v1-056100-056200-transactions.seg"sv, "3293ebe56a6a03f16b2c0e66f773e2f6cabfec87"sv}, Entry{"v1-056200-056300-bodies.idx"sv, "67cef094f28def7f0a57b96f25c627ec89659bf0"sv}, Entry{"v1-056200-056300-bodies.seg"sv, "2778e8612ab4e25062109af8f9689288c2268504"sv}, Entry{"v1-056200-056300-borevents.idx"sv, "506b228fb909b7a2f6ae6ac5cce786ec18d34e46"sv}, Entry{"v1-056200-056300-borevents.seg"sv, "d1b89c11b6a1d61f159d44f160f04a9427ba2af7"sv}, Entry{"v1-056200-056300-borspans.idx"sv, "d0aa6f675e557141708dec556fd1111d0ffb7503"sv}, Entry{"v1-056200-056300-borspans.seg"sv, "25e01c3186c0e4266022cc4dbb03fcb225791767"sv}, Entry{"v1-056200-056300-headers.idx"sv, "899d1f9f26ac28bb52c33e1a590c287422ebc16c"sv}, Entry{"v1-056200-056300-headers.seg"sv, "8fc446ffa8f12450115f4ef529c19718c0808a42"sv}, Entry{"v1-056200-056300-transactions-to-block.idx"sv, "612cdb93ba98a320007d137bb2cd3ec7ca9abffd"sv}, Entry{"v1-056200-056300-transactions.idx"sv, "08b740a2bb720b130f02b709729c793b3adaba99"sv}, Entry{"v1-056200-056300-transactions.seg"sv, "f37fce76760a8fd8a54e459a2d26e0a78d3eede4"sv}, Entry{"v1-056300-056400-bodies.idx"sv, "5d366c2b8f7c56f261fc5c8e4ed5c8b9adac890d"sv}, Entry{"v1-056300-056400-bodies.seg"sv, "7d2e42cc35e5bff4ccbe39e9fa972fe7a4e153b1"sv}, Entry{"v1-056300-056400-borevents.idx"sv, "899951070c37e5435871e1ca2edc912f61738098"sv}, Entry{"v1-056300-056400-borevents.seg"sv, "0ccffd6bd9221016fd9967b11bc334c0de841196"sv}, Entry{"v1-056300-056400-borspans.idx"sv, "4e387352db6e9e63a3dcf9ccc9bb374f586fd428"sv}, Entry{"v1-056300-056400-borspans.seg"sv, "20d988f8643014d0529b477a9f45cbc4c536ed80"sv}, Entry{"v1-056300-056400-headers.idx"sv, "79b6718e60c68dbc7b8df8c38340774bac9e1a2b"sv}, Entry{"v1-056300-056400-headers.seg"sv, "e2e350cf9d7054dd0f8535013a7d5f78bfec4a3c"sv}, Entry{"v1-056300-056400-transactions-to-block.idx"sv, "44e18b64f2aff34eea1f4151fbefdced77f229f4"sv}, Entry{"v1-056300-056400-transactions.idx"sv, "67e4d87b375a8420af93f445e57d6816bff81065"sv}, Entry{"v1-056300-056400-transactions.seg"sv, "687e26eebd5a56c5ac15bd3cf2b6ee2609376e1e"sv}, Entry{"v1-056400-056500-bodies.idx"sv, "30defbd5472b61f14899420867ebc596fdeba7dd"sv}, Entry{"v1-056400-056500-bodies.seg"sv, "7430cc12d2f6e6e088b39c0a8fe10ff3b739af81"sv}, Entry{"v1-056400-056500-borevents.idx"sv, "13971b642bcec012641d246890b954ae329dd944"sv}, Entry{"v1-056400-056500-borevents.seg"sv, "73d52d355b036d064d9b6e3f461eeff2a0badef0"sv}, Entry{"v1-056400-056500-borspans.idx"sv, "4c5833056222c421d0aa2d126581302ccc1d7fbc"sv}, Entry{"v1-056400-056500-borspans.seg"sv, "40369d2b05024c55e677cec2ec8529f5bdcb7d77"sv}, Entry{"v1-056400-056500-headers.idx"sv, "acb377ba3eef7ac09ad2f5542db07c8c376ef363"sv}, Entry{"v1-056400-056500-headers.seg"sv, "ec0525e5ef7eceb95a16a7c19556e35e55c62144"sv}, Entry{"v1-056400-056500-transactions-to-block.idx"sv, "caa1f19858fcf70995e446a62f7a44b4bec1d766"sv}, Entry{"v1-056400-056500-transactions.idx"sv, "08dade927537a855626686de2238ede37199510e"sv}, Entry{"v1-056400-056500-transactions.seg"sv, "adde0dd46e8adf776aee7659f27eebecd928e440"sv}, Entry{"v1-056500-056600-bodies.idx"sv, "59d6e2866ee8a2f9decdbbb0ddda73f320f3846b"sv}, Entry{"v1-056500-056600-bodies.seg"sv, "ebffa586e558cb7674d0b45c491cdded0f5578ef"sv}, Entry{"v1-056500-056600-borevents.idx"sv, "09bd532136ce528646a764ffd3745661e1019816"sv}, Entry{"v1-056500-056600-borevents.seg"sv, "6023558dd0bc5f2ef27ae464f58d41bcae4ef942"sv}, Entry{"v1-056500-056600-borspans.idx"sv, "867574688fc3bfe17861603811e9b7bbced308c8"sv}, Entry{"v1-056500-056600-borspans.seg"sv, "a95053e69ee167cb836687f387bb79f28b37aca7"sv}, Entry{"v1-056500-056600-headers.idx"sv, "2ff1affa31447a979e66da33a2470992babc2c68"sv}, Entry{"v1-056500-056600-headers.seg"sv, "d7de57fc447bcfc038d0b6f9d620ba8ddfff7f0c"sv}, Entry{"v1-056500-056600-transactions-to-block.idx"sv, "aa1d74b2a549b6ca2c1919a4c2c001048551d23d"sv}, Entry{"v1-056500-056600-transactions.idx"sv, "902c35265dab4d07d8724438ca6e58e02823a5bd"sv}, Entry{"v1-056500-056600-transactions.seg"sv, "9e958ca5c82309e21c3bb2c471ecb46ee92482b2"sv}, Entry{"v1-056600-056700-bodies.idx"sv, "ef82dfc29efa0091b88856bafeaab0a324a0d644"sv}, Entry{"v1-056600-056700-bodies.seg"sv, "a7eededd365d2489291e0226352122b8a8261ce6"sv}, Entry{"v1-056600-056700-borevents.idx"sv, "2705b3550806795c9d8ba0317ee4571d02dfd9b6"sv}, Entry{"v1-056600-056700-borevents.seg"sv, "6fc95c8503c1e6b4ceaf185d82a5a0c25ec238c9"sv}, Entry{"v1-056600-056700-borspans.idx"sv, "06dd3ea878977b8f5105ba32ff9871cc5ac90e1f"sv}, Entry{"v1-056600-056700-borspans.seg"sv, "33cca39aa908a2c50571750baed38f283f4bf18d"sv}, Entry{"v1-056600-056700-headers.idx"sv, "3b25c27206a04ec653305131e8fdb07cd8bce636"sv}, Entry{"v1-056600-056700-headers.seg"sv, "a6d22eef8005ad77a019bf1d0029eb3ffefb02b2"sv}, Entry{"v1-056600-056700-transactions-to-block.idx"sv, "d976fa2326b22b67b3ae00ebb94004e7ee4678bd"sv}, Entry{"v1-056600-056700-transactions.idx"sv, "bde68be6687d715b69fc3a21747c656f77d22737"sv}, Entry{"v1-056600-056700-transactions.seg"sv, "fbe47fce42f29ce329ffbcd193f8b7d66fed3cd8"sv}, Entry{"v1-056700-056800-bodies.idx"sv, "76db1d33ebea1f220966a25adbe671ba9ec53608"sv}, Entry{"v1-056700-056800-bodies.seg"sv, "5280124f1703957fd6e2e607e88f28fd9c5e23c5"sv}, Entry{"v1-056700-056800-borevents.idx"sv, "2f23eb08452c3a53336ca70aa75bfe8f474faf99"sv}, Entry{"v1-056700-056800-borevents.seg"sv, "4c82dfda27e9e1860f54f15222018a113db6ac9c"sv}, Entry{"v1-056700-056800-borspans.idx"sv, "cb590867c0dbe6b424a8d79cc82992abc43e3d6b"sv}, Entry{"v1-056700-056800-borspans.seg"sv, "33a80fd7849e3c7eef1262fd61cc0e7c8de6ed05"sv}, Entry{"v1-056700-056800-headers.idx"sv, "724a17eba12f96c4b3c30bf536691c203c1d067f"sv}, Entry{"v1-056700-056800-headers.seg"sv, "d25130b60cfd65de5467d85637b3f7c5afbfbde7"sv}, Entry{"v1-056700-056800-transactions-to-block.idx"sv, "769f98a566abfb1fd568f63e220c54eb623e64d0"sv}, Entry{"v1-056700-056800-transactions.idx"sv, "23f6123c1c9910461b9f64007a8dee17d9117ff3"sv}, Entry{"v1-056700-056800-transactions.seg"sv, "1cd514a7732fb80e8d466e8f30d021e4e6bf2dfc"sv}, Entry{"v1-056800-056900-bodies.idx"sv, "0dc76f8cb427e6c8160013090c580f2ed96cee79"sv}, Entry{"v1-056800-056900-bodies.seg"sv, "12eef876b3787a79c0e398c17ce6bb4f9d3c9f55"sv}, Entry{"v1-056800-056900-borevents.idx"sv, "2375c6e26b78239a9f96ae22a6c2113e12d60660"sv}, Entry{"v1-056800-056900-borevents.seg"sv, "bd67062de162965172a19e271361171b7154f999"sv}, Entry{"v1-056800-056900-borspans.idx"sv, "c3171d4ccaf57c0a9f05b1971cec22657ce24d43"sv}, Entry{"v1-056800-056900-borspans.seg"sv, "0c2fd35c8d22c0d3535eee2438cdd5d2550ce154"sv}, Entry{"v1-056800-056900-headers.idx"sv, "173399b80f545800306bc15ef4057bd731099109"sv}, Entry{"v1-056800-056900-headers.seg"sv, "280cbf7526860b252d45cc3e968fb602467dec56"sv}, Entry{"v1-056800-056900-transactions-to-block.idx"sv, "9079ace0cb213bc4cf5e60f49c7e1aec59a16a93"sv}, Entry{"v1-056800-056900-transactions.idx"sv, "7b7002b7a865b163235c3f6e3905f7b54adb3dc8"sv}, Entry{"v1-056800-056900-transactions.seg"sv, "cf6424a830f17d6ede9306ab2b583fbe25cdb956"sv}, Entry{"v1-056900-057000-bodies.idx"sv, "96a5e755dabe4ef1c40156147780a947fe9301df"sv}, Entry{"v1-056900-057000-bodies.seg"sv, "f83fac8981682e7c41550fd78f7ef05d67b342d7"sv}, Entry{"v1-056900-057000-borevents.idx"sv, "34de55af0a8b04f470598b7814960f5ca9552de2"sv}, Entry{"v1-056900-057000-borevents.seg"sv, "5f06ee99f3350714728535ab039ff71ab06ff2a5"sv}, Entry{"v1-056900-057000-borspans.idx"sv, "99ef24615a6e9a36902f30ada744d50704dd5dad"sv}, Entry{"v1-056900-057000-borspans.seg"sv, "3da972950c2f2fc2f5c70bd54b341737030aa143"sv}, Entry{"v1-056900-057000-headers.idx"sv, "95e33fc42c1f751e94b197184ab08cbae6266fa4"sv}, Entry{"v1-056900-057000-headers.seg"sv, "69c9e6f482fd1a1ec972fc15dcba21180d214153"sv}, Entry{"v1-056900-057000-transactions-to-block.idx"sv, "d29d6caad5231a8b2324ef5bde32427fcab70ab1"sv}, Entry{"v1-056900-057000-transactions.idx"sv, "277aa94a5013d29afb8abb05da7d411bb366c2bc"sv}, Entry{"v1-056900-057000-transactions.seg"sv, "af086df2133bced451a3e78cd8156b066e1f6174"sv}, Entry{"v1-057000-057100-bodies.idx"sv, "2e2bb60e709040c309ff08859596bc424bc45244"sv}, Entry{"v1-057000-057100-bodies.seg"sv, "616341b5339a5cd31198f0b5d9daadc3fa4d05e3"sv}, Entry{"v1-057000-057100-borevents.idx"sv, "5f9c9c56409d7c666440b8e9f9ecd5660152f110"sv}, Entry{"v1-057000-057100-borevents.seg"sv, "0c4ec627ec9ac7af1025cbca691248ba591264a1"sv}, Entry{"v1-057000-057100-borspans.idx"sv, "911d9893be656e7569a992f1e30b5a98a7ac95d4"sv}, Entry{"v1-057000-057100-borspans.seg"sv, "47f62d1b6d7783d7cf06e5f6ed26fd3c527e1e28"sv}, Entry{"v1-057000-057100-headers.idx"sv, "08098171ff64106dc2d2e9c3f9a1722251f17572"sv}, Entry{"v1-057000-057100-headers.seg"sv, "27fe4dcbc095249524a654d1c35499ce632ab447"sv}, Entry{"v1-057000-057100-transactions-to-block.idx"sv, "006c370eadce26eb47db307ed5b2593acf1e49ad"sv}, Entry{"v1-057000-057100-transactions.idx"sv, "8d8c7442c79dabc9cf60c9936eed6303a3ff2a9c"sv}, Entry{"v1-057000-057100-transactions.seg"sv, "4875d2130a6a1471e5a394514870a0b62eb93a94"sv}, Entry{"v1-057100-057200-bodies.idx"sv, "b2d9e9b82b269aa39811cd31e053c80eee9546c0"sv}, Entry{"v1-057100-057200-bodies.seg"sv, "6a9f1c7715dc6c365bd5cc61e0025a549916f06e"sv}, Entry{"v1-057100-057200-borevents.idx"sv, "c1bd3b2a2ee5f52732977d27dfc4c76b31f80df3"sv}, Entry{"v1-057100-057200-borevents.seg"sv, "9e73b21e1a56b3399d582cfba055efdb9d85eb1a"sv}, Entry{"v1-057100-057200-borspans.idx"sv, "fe12e18e3cd46f087f3a5e5af3086e0c9b5becb7"sv}, Entry{"v1-057100-057200-borspans.seg"sv, "e9339a45f728cb77a4a7c49d90bbd483f0e8d9f5"sv}, Entry{"v1-057100-057200-headers.idx"sv, "51bab725d7611b7ccc6c44f27adfeddf0456538d"sv}, Entry{"v1-057100-057200-headers.seg"sv, "bdf7af415ad75f1167a66d563e264aa332c06d84"sv}, Entry{"v1-057100-057200-transactions-to-block.idx"sv, "a6568e26de7008e9bc1b94ca75cc2dd4394f8908"sv}, Entry{"v1-057100-057200-transactions.idx"sv, "7ed8616e6a8631147c3a5f32715e16d64cbcd805"sv}, Entry{"v1-057100-057200-transactions.seg"sv, "cd55f44b1cc3277fcaae9d86a7225f3fb3120dee"sv}, Entry{"v1-057200-057300-bodies.idx"sv, "258895ec3705bd9c0ecfdfc995cb7318d9a99534"sv}, Entry{"v1-057200-057300-bodies.seg"sv, "7205a84f0a14064c9ddd6297895667ced3db7406"sv}, Entry{"v1-057200-057300-borevents.idx"sv, "baabc8cdcc589da72c574eb2a040c13a78f86f30"sv}, Entry{"v1-057200-057300-borevents.seg"sv, "0e5cce5f81c797bf271a5f9141d5d0404451439c"sv}, Entry{"v1-057200-057300-borspans.idx"sv, "6234e526e8693436ae2c2523dd6c32a6eafb4476"sv}, Entry{"v1-057200-057300-borspans.seg"sv, "3de290cd5e3be3b547fa80f44262956f842b69e1"sv}, Entry{"v1-057200-057300-headers.idx"sv, "d9c55a15877c4c7d5d9790caadff402835b1b712"sv}, Entry{"v1-057200-057300-headers.seg"sv, "afbf732284fb0ba0087f08804ebe39056ba82fc5"sv}, Entry{"v1-057200-057300-transactions-to-block.idx"sv, "ae90718b8589ac5a0433f23d1afa7dbfa7cdbd75"sv}, Entry{"v1-057200-057300-transactions.idx"sv, "32522d4d4b09724813160648aff74fb4656dd48e"sv}, Entry{"v1-057200-057300-transactions.seg"sv, "9683441983b48adfa3288ce3c6d3f9a520f7562c"sv}, Entry{"v1-057300-057400-bodies.idx"sv, "2a58e1eb9eb9964373d92f87d33eb88de096cf0f"sv}, Entry{"v1-057300-057400-bodies.seg"sv, "af794e0c51f5ea4f9118d75cce441f8736b623ac"sv}, Entry{"v1-057300-057400-borevents.idx"sv, "75ca9b36a17c33a164d598e2697ddadb13106322"sv}, Entry{"v1-057300-057400-borevents.seg"sv, "087ce7c847b85de2eb3fa7d017f096bd2db9ef27"sv}, Entry{"v1-057300-057400-borspans.idx"sv, "c546aeeef6613aeee31333c3bd3d9db706c8bdb0"sv}, Entry{"v1-057300-057400-borspans.seg"sv, "f0d03b485a65dcfefa53b2f5a8eb18314f31d1b8"sv}, Entry{"v1-057300-057400-headers.idx"sv, "cb458f784988350edc24701220ed3322695eeacd"sv}, Entry{"v1-057300-057400-headers.seg"sv, "34430e8072e516ddcb4d05c498bc7edb1ea318a9"sv}, Entry{"v1-057300-057400-transactions-to-block.idx"sv, "4e7b8b2d6b1f80abdd5cf039978499adbff13ca9"sv}, Entry{"v1-057300-057400-transactions.idx"sv, "b71e8f7a834fc9599752bc7b5bcb1aff84229475"sv}, Entry{"v1-057300-057400-transactions.seg"sv, "41d913aa16c98bb9c032f0af82133e703212da7c"sv}, Entry{"v1-057400-057500-bodies.idx"sv, "e9fe1f03325b2193d819364d65fc7b3de654a2f1"sv}, Entry{"v1-057400-057500-bodies.seg"sv, "6e88be10abb6bcfefbba3ee376ffd1644ab77624"sv}, Entry{"v1-057400-057500-borevents.idx"sv, "f7b0173acb9a987b17acdb0909cc2e20d2b231ac"sv}, Entry{"v1-057400-057500-borevents.seg"sv, "6379052f99fbe23d968afb9d48c3bfdd7673e594"sv}, Entry{"v1-057400-057500-borspans.idx"sv, "7625768b3ee4f2763d2130036025f68308996fd3"sv}, Entry{"v1-057400-057500-borspans.seg"sv, "106207977d48e22721a1ac3c7d56851f8ac86046"sv}, Entry{"v1-057400-057500-headers.idx"sv, "bc6abcaca6dda7794727ccc20a2ddb1e81910c93"sv}, Entry{"v1-057400-057500-headers.seg"sv, "8fc70abc251fa216b63e0dcce546c8ebf3656921"sv}, Entry{"v1-057400-057500-transactions-to-block.idx"sv, "d7ae329bca15b18b193ddaea80a320bcba00fc39"sv}, Entry{"v1-057400-057500-transactions.idx"sv, "1a4f84433ef699c2a0c77edd9dead8ad3b55f48f"sv}, Entry{"v1-057400-057500-transactions.seg"sv, "0bca4ad6a2b073c955e7c810fc42db89369b0a71"sv}, Entry{"v1-057500-057600-bodies.idx"sv, "b843a1abf230d824fcb72113d8053a0f42fcc029"sv}, Entry{"v1-057500-057600-bodies.seg"sv, "34de2c1c05fe2b63654b2e2e028a749ba4f2b9e3"sv}, Entry{"v1-057500-057600-borevents.idx"sv, "a8ef31ea906d85acbd638aa9c2dd831e87a7d264"sv}, Entry{"v1-057500-057600-borevents.seg"sv, "0b548370865b44b5bdae32c4c100ffdb6d31a829"sv}, Entry{"v1-057500-057600-borspans.idx"sv, "9741aa8b0a08cb95dd8273132a7e4bc8993150ea"sv}, Entry{"v1-057500-057600-borspans.seg"sv, "a3350f8449ef80835058af4f4d2a134d9615d580"sv}, Entry{"v1-057500-057600-headers.idx"sv, "6fb72c7639e10a290e91a4601f7650337d89f6a2"sv}, Entry{"v1-057500-057600-headers.seg"sv, "26ec376ac17505cbcf73b497329f267d2e61ca6c"sv}, Entry{"v1-057500-057600-transactions-to-block.idx"sv, "03d3b62fdc8b25a23e2cbd4e794aad5719d7cbc3"sv}, Entry{"v1-057500-057600-transactions.idx"sv, "ba4535c7801e5acb905726bb82e154ea6961bb4f"sv}, Entry{"v1-057500-057600-transactions.seg"sv, "3bd78d8e068315c26559858814fce5179b139736"sv}, Entry{"v1-057600-057700-bodies.idx"sv, "981e1a3feac6e02bc4756bb0a8b23ae91372a81d"sv}, Entry{"v1-057600-057700-bodies.seg"sv, "e384e22cccd16ac7b57065b7c46b15be21b0e080"sv}, Entry{"v1-057600-057700-borevents.idx"sv, "1d507fff4e6247f7407192186482d6e95bd15e9b"sv}, Entry{"v1-057600-057700-borevents.seg"sv, "6fb52afb79ab6fdd3dc164d3da5e1c1b98ca87da"sv}, Entry{"v1-057600-057700-borspans.idx"sv, "af6c0730498896bf0b59b150762c496a9756373b"sv}, Entry{"v1-057600-057700-borspans.seg"sv, "54437519c71a6c88c292486b90c7beabbbde35e3"sv}, Entry{"v1-057600-057700-headers.idx"sv, "89681a3c024c2d8c658c46cfb631180a0dc97d28"sv}, Entry{"v1-057600-057700-headers.seg"sv, "dea481f83f475d365f4f55b566d93812e9c197f0"sv}, Entry{"v1-057600-057700-transactions-to-block.idx"sv, "de36ed0316700331130c4f43ad3d566d3c3e9f99"sv}, Entry{"v1-057600-057700-transactions.idx"sv, "aaba1b240c19c49d17678cf3367701005d8a95ac"sv}, Entry{"v1-057600-057700-transactions.seg"sv, "51ce3ebe4e0407043d6dc98286c3deb191f8db67"sv}, Entry{"v1-057700-057800-bodies.idx"sv, "fc9ab545eb57d6e9625ca67df69f06c7d2f91640"sv}, Entry{"v1-057700-057800-bodies.seg"sv, "e72eb598e5543dafb18026d3a0cac7db44c4f7ec"sv}, Entry{"v1-057700-057800-borevents.idx"sv, "80e6031d51f09d1d9cfb29e28116ff186259c145"sv}, Entry{"v1-057700-057800-borevents.seg"sv, "d02b73163605542693a1b07a70b79656a70788ea"sv}, Entry{"v1-057700-057800-borspans.idx"sv, "f8ed7c7b2f89e41cb34c7fa70593435df7f96d8f"sv}, Entry{"v1-057700-057800-borspans.seg"sv, "7af95b167da2f145b7a1a2813550f5c3d36357e8"sv}, Entry{"v1-057700-057800-headers.idx"sv, "6dbe464dab4db66f88f60641389bcb993d9fd3ee"sv}, Entry{"v1-057700-057800-headers.seg"sv, "8ed4cd22d3fa2f8be13e341686d00c5fe6ce35dd"sv}, Entry{"v1-057700-057800-transactions-to-block.idx"sv, "5b05e030bf9b4bbce5c7825ce223990a1fe568ae"sv}, Entry{"v1-057700-057800-transactions.idx"sv, "a677065ebdf31ef691b7dc40aeccfade7d5a63e4"sv}, Entry{"v1-057700-057800-transactions.seg"sv, "06a5cdf8b46c70e32c876d993d974b3025b5b283"sv}, Entry{"v1-057800-057900-bodies.idx"sv, "d092aaa9ae0ac24d1c728c56d552c9641bfebcd8"sv}, Entry{"v1-057800-057900-bodies.seg"sv, "d562e7ef04f88d5f746f8d0138a477740c57f466"sv}, Entry{"v1-057800-057900-borevents.idx"sv, "5164773ff7e72efb938e69ff660efb33d2ebcf2b"sv}, Entry{"v1-057800-057900-borevents.seg"sv, "cb3d6fafb07f346d9e50ac69d4f95dab5da09895"sv}, Entry{"v1-057800-057900-borspans.idx"sv, "8279addb8f94b6416fe20de18e7e592d8e56a46a"sv}, Entry{"v1-057800-057900-borspans.seg"sv, "51541b3f82a0c91cdfd64626e690c10dff3e21f6"sv}, Entry{"v1-057800-057900-headers.idx"sv, "6c8981b64a133f4490c23daadcc050ae05948666"sv}, Entry{"v1-057800-057900-headers.seg"sv, "52ddd3d5ef470be494a489485677c0fa23c4f2b5"sv}, Entry{"v1-057800-057900-transactions-to-block.idx"sv, "755582ef53d4d5254a4fd1325e5dd0198b282b00"sv}, Entry{"v1-057800-057900-transactions.idx"sv, "8da0052ce8d63210773aa6e9994124c31255ecfb"sv}, Entry{"v1-057800-057900-transactions.seg"sv, "76f56c57009041982a21d9d382f6caaed9cb03b9"sv}, Entry{"v1-057900-058000-bodies.idx"sv, "a5087a9260f2640a2c885ee2bd902d276f6895b3"sv}, Entry{"v1-057900-058000-bodies.seg"sv, "1d23129e8fe4e1de0354854e2f987d95d7688eca"sv}, Entry{"v1-057900-058000-borevents.idx"sv, "63ba1b0825c126b66e6d93ea6423a08f7463b93f"sv}, Entry{"v1-057900-058000-borevents.seg"sv, "24521bbf1cfb7b35e25af0f2404a8707877dad80"sv}, Entry{"v1-057900-058000-borspans.idx"sv, "7467e7da03cf31792222423e1b8ce7da90fd4ad1"sv}, Entry{"v1-057900-058000-borspans.seg"sv, "91604a74fa1836fd215d75faaa0a801c815f2b9c"sv}, Entry{"v1-057900-058000-headers.idx"sv, "3b8e7ba7a905ceee806986f97a893fc0d5fb879b"sv}, Entry{"v1-057900-058000-headers.seg"sv, "a7bbef04bc1acd1b6ea0dc9192d281968ce53862"sv}, Entry{"v1-057900-058000-transactions-to-block.idx"sv, "0459df7f529089d19496076f5b38eb76bedc3679"sv}, Entry{"v1-057900-058000-transactions.idx"sv, "95539ed82907164b59ee5e3edeb6c6b19dfd83a4"sv}, Entry{"v1-057900-058000-transactions.seg"sv, "d1951839c26ac450e19f2f9bc1757effbca3041e"sv}, Entry{"v1-058000-058100-bodies.idx"sv, "257285521710c561dec55909272ade9ba3b6c30f"sv}, Entry{"v1-058000-058100-bodies.seg"sv, "aa58007b60b03efec595e5e25f65aaa63497611b"sv}, Entry{"v1-058000-058100-borevents.idx"sv, "a26bb05ab800f7e13712167893062b201bfb8254"sv}, Entry{"v1-058000-058100-borevents.seg"sv, "d394e0d04aa916495b3f61c687bd8b90730c225e"sv}, Entry{"v1-058000-058100-borspans.idx"sv, "6500526a428e9dc8346ae8284a59da833ec63cad"sv}, Entry{"v1-058000-058100-borspans.seg"sv, "272099bcdf4d969fb3ca6717ed099d00f6fb36b9"sv}, Entry{"v1-058000-058100-headers.idx"sv, "cba1378e21e4b20aff49bdc168493997362d594f"sv}, Entry{"v1-058000-058100-headers.seg"sv, "c82df8a05ee324e6eda7e41bfd372d1880319e74"sv}, Entry{"v1-058000-058100-transactions-to-block.idx"sv, "8146d2d1a6ac4726be2112280fdbf01b52c9300f"sv}, Entry{"v1-058000-058100-transactions.idx"sv, "b1758420962b303ce7cc219f50156a955a31a9b0"sv}, Entry{"v1-058000-058100-transactions.seg"sv, "be1c0a47e17f42673af0ef9edd7bbc80dff3c7d7"sv}, Entry{"v1-058100-058200-bodies.idx"sv, "6e62c60c4f545eac9da8a00287eb835a5d8e1479"sv}, Entry{"v1-058100-058200-bodies.seg"sv, "c6e80127b64eabaae9189d00ae7452caa47b5245"sv}, Entry{"v1-058100-058200-borevents.idx"sv, "cb0b12c84c524c0945ad70059b76b5c27120446d"sv}, Entry{"v1-058100-058200-borevents.seg"sv, "fd009015ce01db7e15cbf174d9a32b996a4eb01b"sv}, Entry{"v1-058100-058200-borspans.idx"sv, "2db722a0550556f117bdb62369b88b725074cc8b"sv}, Entry{"v1-058100-058200-borspans.seg"sv, "e699102cb66d58bdf850d648e1201dfb8bb8cc4e"sv}, Entry{"v1-058100-058200-headers.idx"sv, "d4f00c8fd030187b4c4870445f3350c9ba5a3ce7"sv}, Entry{"v1-058100-058200-headers.seg"sv, "e2dee24f1ebd3f300839cbf0cfaba5c76689445d"sv}, Entry{"v1-058100-058200-transactions-to-block.idx"sv, "c3639eb30a90337ed67f2ba9526f5a2785b162fe"sv}, Entry{"v1-058100-058200-transactions.idx"sv, "5975bc2f7665b8d612250c80cf9e15322570c945"sv}, Entry{"v1-058100-058200-transactions.seg"sv, "5aa668aa593b25c66e097c241426651864635b2b"sv}, Entry{"v1-058200-058300-bodies.idx"sv, "13cf3e79258b0ca735941455cf9fdac385fc1acc"sv}, Entry{"v1-058200-058300-bodies.seg"sv, "6b17437df6c177c15c2c3314cf0144d42970d443"sv}, Entry{"v1-058200-058300-borevents.idx"sv, "e8a7303750da2365b089ef252aee889a968a9783"sv}, Entry{"v1-058200-058300-borevents.seg"sv, "2cfe62b499000d3d19fe4de9c8b23e0e26abd3df"sv}, Entry{"v1-058200-058300-borspans.idx"sv, "b6e5c05038ca910d8d2311dde6213997558e9b45"sv}, Entry{"v1-058200-058300-borspans.seg"sv, "bea8853c0c76f84bcf80694540ee1fe0bf75bf94"sv}, Entry{"v1-058200-058300-headers.idx"sv, "08cae4291dbb396bcbb63b6817e7f74e330da86e"sv}, Entry{"v1-058200-058300-headers.seg"sv, "3728d590888173eea4703bd6033e07162ba1596f"sv}, Entry{"v1-058200-058300-transactions-to-block.idx"sv, "9215936bc134e007c477cc043141e5fa058b08bc"sv}, Entry{"v1-058200-058300-transactions.idx"sv, "566229c2b6abedce08c23b492c160fb043143c36"sv}, Entry{"v1-058200-058300-transactions.seg"sv, "528b0bf3932dea8c181b6286290c04155449a39c"sv}, Entry{"v1-058300-058400-bodies.idx"sv, "59af6f38557b6fbb8d945c91a4e9d6bcfe394440"sv}, Entry{"v1-058300-058400-bodies.seg"sv, "0c481ba6eed6812cfcdcfba9bab183900f72c11c"sv}, Entry{"v1-058300-058400-borevents.idx"sv, "cd48fe68dc0a650cc305de3c2e31207d3f6ba6d0"sv}, Entry{"v1-058300-058400-borevents.seg"sv, "f7bfc7eda07104073a2ca8edb29833a41cee1b3d"sv}, Entry{"v1-058300-058400-borspans.idx"sv, "b19be952591ac5b1ac267d3fd15024b4ba550426"sv}, Entry{"v1-058300-058400-borspans.seg"sv, "962c554a87e245c41e7641047068f2e9132f5591"sv}, Entry{"v1-058300-058400-headers.idx"sv, "a97b104790935ad4c8d9859f6bce2c1c5621074f"sv}, Entry{"v1-058300-058400-headers.seg"sv, "11564716cf9e6d3e1c53a6b19f4814f7daa04e99"sv}, Entry{"v1-058300-058400-transactions-to-block.idx"sv, "0c10a236f1631d2290800822fbcc9bb350e76dba"sv}, Entry{"v1-058300-058400-transactions.idx"sv, "0d6f669e6f4bed7cba98fccb5e38cd3fbc0d6dc2"sv}, Entry{"v1-058300-058400-transactions.seg"sv, "1f6c95b2cbc608a813963201591b201686b9bd40"sv}, Entry{"v1-058400-058500-bodies.idx"sv, "1db87d9b78f81f2946a0caa40ff78b28e744dd9d"sv}, Entry{"v1-058400-058500-bodies.seg"sv, "6ed57fe8fa891ac405c26302a52f7f84d6949aa1"sv}, Entry{"v1-058400-058500-borevents.idx"sv, "5976e9339bc752865e63d3c2b7e29df1233056f0"sv}, Entry{"v1-058400-058500-borevents.seg"sv, "57e12c3e5a235be858c23e79a2895e7bc7a74b7a"sv}, Entry{"v1-058400-058500-borspans.idx"sv, "5a7101716af33da6bca9751e96a7f8a7b0360b0a"sv}, Entry{"v1-058400-058500-borspans.seg"sv, "0d006d780c3df53ba490e1eb6100158a1b0b2623"sv}, Entry{"v1-058400-058500-headers.idx"sv, "9aa0542683b11eae4cac175edc1a65b023ce84ac"sv}, Entry{"v1-058400-058500-headers.seg"sv, "06c27d60c1cefbb4bc16e30b49192126ca08f42d"sv}, Entry{"v1-058400-058500-transactions-to-block.idx"sv, "87c79e47aac508e15f6edeb22bb7ea2d5ea48480"sv}, Entry{"v1-058400-058500-transactions.idx"sv, "80de934fff4b9499b2108093f0cda86fa04379d3"sv}, Entry{"v1-058400-058500-transactions.seg"sv, "d5821c9b9672c2fcfd4854069a70d66102ba57ee"sv}, Entry{"v1-058500-058600-bodies.idx"sv, "4f7d04e1c04d70bffdb7e44e5a0a9582e42c090a"sv}, Entry{"v1-058500-058600-bodies.seg"sv, "9e0e03b895b2ca03cba68737865cf8944508eabf"sv}, Entry{"v1-058500-058600-borevents.idx"sv, "eb15a66bfb0981939be0464b95b010e273201487"sv}, Entry{"v1-058500-058600-borevents.seg"sv, "df20303adcb53664833e8bf6efc671770c40e83c"sv}, Entry{"v1-058500-058600-borspans.idx"sv, "c589eaec8dda47ff4a325516dbddb70c61078fb9"sv}, Entry{"v1-058500-058600-borspans.seg"sv, "cdc21b366b16865e941d3f482b98b5b9cace3536"sv}, Entry{"v1-058500-058600-headers.idx"sv, "32b331ed0b0dd509af75216c4e870ca6a5249402"sv}, Entry{"v1-058500-058600-headers.seg"sv, "b3a22ad63f7a8ea104cf8a1ea01da0dff0e9a6e0"sv}, Entry{"v1-058500-058600-transactions-to-block.idx"sv, "91382ca3b3abc8f38a1e1c248ed17e42eb44de43"sv}, Entry{"v1-058500-058600-transactions.idx"sv, "50cb5c3d35f903a72026979cb5ba853d641f8731"sv}, Entry{"v1-058500-058600-transactions.seg"sv, "0280d9ffe709e5742cc7715af2cea009ff51792b"sv}, Entry{"v1-058600-058700-bodies.idx"sv, "e1f38111283514e5254ef40d24112b2251acdfa2"sv}, Entry{"v1-058600-058700-bodies.seg"sv, "4581c63f456ea120c2c40d6e332b2d7ad58d7d5b"sv}, Entry{"v1-058600-058700-borevents.idx"sv, "b65e1c96a51ade5c2b278257f44d3c24674d09e4"sv}, Entry{"v1-058600-058700-borevents.seg"sv, "f1b4c9ef6a15c23dd2cb1670c630d7a8fc3afcfa"sv}, Entry{"v1-058600-058700-borspans.idx"sv, "51b6c8fc46a05ef2d5506c9976aeceac48271763"sv}, Entry{"v1-058600-058700-borspans.seg"sv, "9aeb94ed5f9c474d7e984f55abd954b55ad0a272"sv}, Entry{"v1-058600-058700-headers.idx"sv, "a16154d0a5c5635abdf7295a2b5b01236cfececf"sv}, Entry{"v1-058600-058700-headers.seg"sv, "627ffd6044ff3503e6486a28c8b8cad84ec02ae8"sv}, Entry{"v1-058600-058700-transactions-to-block.idx"sv, "814de13ba90aebf65a83515d148e2ec94e0ebe39"sv}, Entry{"v1-058600-058700-transactions.idx"sv, "fb5e0f30f965c55c189fbb5b6e786ed978f94541"sv}, Entry{"v1-058600-058700-transactions.seg"sv, "71485edd11fc0ef33fadc1f3d33b87944a30dc97"sv}, Entry{"v1-058700-058800-bodies.idx"sv, "0fa9547781273044d473dfd25ce331e5a729a274"sv}, Entry{"v1-058700-058800-bodies.seg"sv, "ca5eb700d0c43147748d47ea1f6bf0a4f2ce42e9"sv}, Entry{"v1-058700-058800-borevents.idx"sv, "65153dd2152ba7acba25569c6830d687900a1ea6"sv}, Entry{"v1-058700-058800-borevents.seg"sv, "7dc3ab4eb7551b5fe8f6f900db19952d6dd4fd79"sv}, Entry{"v1-058700-058800-borspans.idx"sv, "d27da8bb12d6408fff21d90be5b76e3d7cd69776"sv}, Entry{"v1-058700-058800-borspans.seg"sv, "fa424599608d3c600d27dc916993a85498331915"sv}, Entry{"v1-058700-058800-headers.idx"sv, "5410c990e3a01ee06bc1aedf344fc7369ee63e27"sv}, Entry{"v1-058700-058800-headers.seg"sv, "4f401db121d2ddb735eae9049c2b44c2b157a383"sv}, Entry{"v1-058700-058800-transactions-to-block.idx"sv, "7f9b03a4b411a576ee78dbc035e553c39b3b3780"sv}, Entry{"v1-058700-058800-transactions.idx"sv, "830651149b50b020905d447c955912575eb277f4"sv}, Entry{"v1-058700-058800-transactions.seg"sv, "f5ceafe2e439f87ab38d43ba4f1c50cf8519188e"sv}, Entry{"v1-058800-058900-bodies.idx"sv, "5c1837097ac8482e307306f6c1f2eeca8694d9e9"sv}, Entry{"v1-058800-058900-bodies.seg"sv, "c10f9691e5ebaa0707136b691c8ba67a5c2751af"sv}, Entry{"v1-058800-058900-borevents.idx"sv, "2fddb66066075ace186cfadcf99251fbbeddd327"sv}, Entry{"v1-058800-058900-borevents.seg"sv, "6c9e3b040b43b172133aebb77ec8b3016415dd1e"sv}, Entry{"v1-058800-058900-borspans.idx"sv, "ab81c25d210e6dbaec4ad5c8dbeb15257c40c515"sv}, Entry{"v1-058800-058900-borspans.seg"sv, "9078431b9ab8e1c4a19f52153eb25d4fe4d1020d"sv}, Entry{"v1-058800-058900-headers.idx"sv, "c82fe553ee62d66d9850bb1c00a112b954450ef2"sv}, Entry{"v1-058800-058900-headers.seg"sv, "59d2a22c30ff3f4d04ab26d9e4b3e9e14496a5bc"sv}, Entry{"v1-058800-058900-transactions-to-block.idx"sv, "08f2b86336ebf9656fa5e2360db23b8e172aed59"sv}, Entry{"v1-058800-058900-transactions.idx"sv, "a6e7b760cd654ec9d75c44d1c36cff5f56b38d01"sv}, Entry{"v1-058800-058900-transactions.seg"sv, "4d783622ccce41d193cbc6bb46fc4c8804ba6c05"sv}, Entry{"v1-058900-059000-bodies.idx"sv, "8ba304b847998dddb2b56510e0a2524119220e35"sv}, Entry{"v1-058900-059000-bodies.seg"sv, "3fd8e2baee209edb2c3603399353c5c2c6f0c651"sv}, Entry{"v1-058900-059000-borevents.idx"sv, "ed0316896afe5c372753954b53d7cd15869a4eda"sv}, Entry{"v1-058900-059000-borevents.seg"sv, "9ee36c6b8d8b9ce7fbea43ebc2244248f82f48c6"sv}, Entry{"v1-058900-059000-borspans.idx"sv, "f823dfb5710362a5b14c6b4258aa296c1db0b911"sv}, Entry{"v1-058900-059000-borspans.seg"sv, "b9e88bc03318f250de0d7095af6bbff786085a75"sv}, Entry{"v1-058900-059000-headers.idx"sv, "cfdbe6bf206eb9397bfe99128f88542f3af7aa17"sv}, Entry{"v1-058900-059000-headers.seg"sv, "d7720a79d4008bc971013c96150a5547cf8497b6"sv}, Entry{"v1-058900-059000-transactions-to-block.idx"sv, "dbb3a665d5e5b2db60bc02086780b8afeb5cabd8"sv}, Entry{"v1-058900-059000-transactions.idx"sv, "c98df77314c4715893ca7af08137e39d71e1c5d7"sv}, Entry{"v1-058900-059000-transactions.seg"sv, "18d8a4f92f9cabc7cb819af02b1439a613c040f1"sv}, Entry{"v1-059000-059100-bodies.idx"sv, "d9878b0adfc2769f41e66dc7c5477e133419acd4"sv}, Entry{"v1-059000-059100-bodies.seg"sv, "880c0159204d983d3f706a8501ee9d6780b7bfa2"sv}, Entry{"v1-059000-059100-borevents.idx"sv, "0bb27706c365d8974bd84790e053206b3ef9c392"sv}, Entry{"v1-059000-059100-borevents.seg"sv, "2ebd366624ef01a6db3329b68459b369c25927c2"sv}, Entry{"v1-059000-059100-borspans.idx"sv, "81859bf5357c5aca10c01a507b04a7af116430f9"sv}, Entry{"v1-059000-059100-borspans.seg"sv, "a2a9d3dd9b01ba4edddbed09ca293b1aaf228298"sv}, Entry{"v1-059000-059100-headers.idx"sv, "0406c076dfb680c9b504acb33d653bcd77f2125b"sv}, Entry{"v1-059000-059100-headers.seg"sv, "45e2c63449ed091ddff2e93ddf92245da38c36a3"sv}, Entry{"v1-059000-059100-transactions-to-block.idx"sv, "9aaadb7e3b423557f20c1a0993e35d700342e5d5"sv}, Entry{"v1-059000-059100-transactions.idx"sv, "32ca5a69d9b618055ea1feb168e7a2384679cf6d"sv}, Entry{"v1-059000-059100-transactions.seg"sv, "4cfc467749817926e94cd78aa13fd56b0dcb6dfc"sv}, Entry{"v1-059100-059200-bodies.idx"sv, "e4c57dd87837ebe60376645cfef655f50b96cd4e"sv}, Entry{"v1-059100-059200-bodies.seg"sv, "defbcee7d946a3ea625b959f8782c84d998e3db9"sv}, Entry{"v1-059100-059200-borevents.idx"sv, "9adde4e20d551ee92b58cd8fb67a15a19f84b378"sv}, Entry{"v1-059100-059200-borevents.seg"sv, "124e1d3244444e6e7738865e542844b17f5d585e"sv}, Entry{"v1-059100-059200-borspans.idx"sv, "cfe980ca07a4b71d74b9f5f523eb7c8dff6c37a9"sv}, Entry{"v1-059100-059200-borspans.seg"sv, "5f0338391f4afd30c9faa0e1f4a35d12d828c303"sv}, Entry{"v1-059100-059200-headers.idx"sv, "5ce03fb2d2b856be260e41daca20f67057fb7769"sv}, Entry{"v1-059100-059200-headers.seg"sv, "d834297426f91e3dac95de642e44d97c166cca82"sv}, Entry{"v1-059100-059200-transactions-to-block.idx"sv, "e038d13fe3fa3e07e1183ad66af477fc499f6803"sv}, Entry{"v1-059100-059200-transactions.idx"sv, "92d19cecb89777960024a177258520ac7baeb88f"sv}, Entry{"v1-059100-059200-transactions.seg"sv, "c8eb35e4150d10f5518f687168db2f8e3ef46ea2"sv}, Entry{"v1-059200-059300-bodies.idx"sv, "9c6cb304d9ea46e81d9b84340be6d7d2be2a7942"sv}, Entry{"v1-059200-059300-bodies.seg"sv, "b8bef04afc417a9d4d30ea7335e9e697b92f9e2d"sv}, Entry{"v1-059200-059300-borevents.idx"sv, "fac616ff83e2049d5c2571761c160725e94b1c44"sv}, Entry{"v1-059200-059300-borevents.seg"sv, "cec22bf541c0a0a22eaee44bced9920a8226453b"sv}, Entry{"v1-059200-059300-borspans.idx"sv, "a58df38ddf2723e2cb8ddb8880e2fd57f10d04a7"sv}, Entry{"v1-059200-059300-borspans.seg"sv, "21892826aff79995c06ac398753748f490143be1"sv}, Entry{"v1-059200-059300-headers.idx"sv, "363217317f32a3eb5c106db2a5737c6945b5a356"sv}, Entry{"v1-059200-059300-headers.seg"sv, "e355bba046651777772ddceca5ec900a22fc1322"sv}, Entry{"v1-059200-059300-transactions-to-block.idx"sv, "8e7833e5529785da611b28dd56dfc7083729e40b"sv}, Entry{"v1-059200-059300-transactions.idx"sv, "6473b68bb0d83ab7d77f892f89516a447eec988a"sv}, Entry{"v1-059200-059300-transactions.seg"sv, "e788194ebc06f866def3c17762df3de5d4b928e1"sv}, Entry{"v1-059300-059400-bodies.idx"sv, "cb5d0cf766526c7b5a76ae8d90617e31ab1f8189"sv}, Entry{"v1-059300-059400-bodies.seg"sv, "285c41212e7afa1f47e3778e0c4f9ec2e5adbfd8"sv}, Entry{"v1-059300-059400-borevents.idx"sv, "5701ff6e70b92ddbe5abbd8649648cb3c16790ea"sv}, Entry{"v1-059300-059400-borevents.seg"sv, "e5fe573f2a5e0d8851ddcad43eadc908922b4e09"sv}, Entry{"v1-059300-059400-borspans.idx"sv, "6f24656bb787a016f3cbb12deeb8e7d4108b20ae"sv}, Entry{"v1-059300-059400-borspans.seg"sv, "7d9e64aa6d11585d1c9acdf2438a3e956cd3f174"sv}, Entry{"v1-059300-059400-headers.idx"sv, "20fe2bf25fa6036fa9c5b00da5b752ee319f1e15"sv}, Entry{"v1-059300-059400-headers.seg"sv, "ffddeec6f831193271aebafa35b7d0852abc1e26"sv}, Entry{"v1-059300-059400-transactions-to-block.idx"sv, "59131ded19fb04e1dc45cb68a4ed386f8e5596ee"sv}, Entry{"v1-059300-059400-transactions.idx"sv, "10c525cf9c876ace048dd3760c5711bd65b25914"sv}, Entry{"v1-059300-059400-transactions.seg"sv, "29f6532139b4e37f004a2d1d914d9175f3a83cbd"sv}, Entry{"v1-059400-059500-bodies.idx"sv, "31e1ed3944ca296b5a5535bacd469ded4b53be9e"sv}, Entry{"v1-059400-059500-bodies.seg"sv, "16c84629bc9b99ed8df96b321b63c4bd2dae6401"sv}, Entry{"v1-059400-059500-borevents.idx"sv, "301ce88d6d71e3920f6126fd7e1589a430c4d92b"sv}, Entry{"v1-059400-059500-borevents.seg"sv, "e1f55910e2ea4fdc5a9519ea4cf81c65137c5a78"sv}, Entry{"v1-059400-059500-borspans.idx"sv, "1852b18c075f279836eb93885f65cb65a582294d"sv}, Entry{"v1-059400-059500-borspans.seg"sv, "a0a3228893482e07c237f42a3797faa704a2d5cb"sv}, Entry{"v1-059400-059500-headers.idx"sv, "14e931f00d62fd9a70ce21e1276beec9f5680bc7"sv}, Entry{"v1-059400-059500-headers.seg"sv, "ffbf135e82120f11de804f897f02b1e05ad5b530"sv}, Entry{"v1-059400-059500-transactions-to-block.idx"sv, "e8940135ad4088885ed16d01df0b310e44ccce32"sv}, Entry{"v1-059400-059500-transactions.idx"sv, "8127a4013cfe5badb63ed4fd99808f914d5fbdbc"sv}, Entry{"v1-059400-059500-transactions.seg"sv, "212133f54b202bd1d0ffc2f1f4f2f3a34c6cd2c9"sv}, Entry{"v1-059500-059600-bodies.idx"sv, "c0577beb984e77e86125d136726420c218cdf02b"sv}, Entry{"v1-059500-059600-bodies.seg"sv, "cf364e5611dbe76a7b102f1bb6783f1142af3a7c"sv}, Entry{"v1-059500-059600-borevents.idx"sv, "93789498a84a9f0fdfc9dc7c4d64d4b059151858"sv}, Entry{"v1-059500-059600-borevents.seg"sv, "23bcee8caee832e7e90e7db317993cb77a704814"sv}, Entry{"v1-059500-059600-borspans.idx"sv, "9ab171b19068a788f5be1ea57808abf058df04f9"sv}, Entry{"v1-059500-059600-borspans.seg"sv, "3445f7a2429e02194dae5e789a0629f61a94df1e"sv}, Entry{"v1-059500-059600-headers.idx"sv, "1816eba3a90af3082b079366dca53565aef4c58b"sv}, Entry{"v1-059500-059600-headers.seg"sv, "0d3f4a25be4ce3f8ecbc599bcf44103b65645a32"sv}, Entry{"v1-059500-059600-transactions-to-block.idx"sv, "74d0a983ed939baf4551501a7145a28f3f49f3cc"sv}, Entry{"v1-059500-059600-transactions.idx"sv, "80983131788055b21a6b353e51ca1680ecf8b49f"sv}, Entry{"v1-059500-059600-transactions.seg"sv, "486ed10f5d467d80318c302cfbfdf452f77baca5"sv}, Entry{"v1-059600-059700-bodies.idx"sv, "0217af2b524d1e1ebbf461d20859342f688f64b7"sv}, Entry{"v1-059600-059700-bodies.seg"sv, "fbc3ed3345a65eda60bd23fa14fb5436c042b393"sv}, Entry{"v1-059600-059700-borevents.idx"sv, "f61f688e23f499dff1f3d4b6a0ec8ea14b75fee5"sv}, Entry{"v1-059600-059700-borevents.seg"sv, "235de762da58230963dfd46c2a7c3eccd0f529d5"sv}, Entry{"v1-059600-059700-borspans.idx"sv, "6ce8eb1539fa38fd7944667c0b891c271150b7c1"sv}, Entry{"v1-059600-059700-borspans.seg"sv, "ae38df90e782ff2b1edc0314fad913801f7cebdb"sv}, Entry{"v1-059600-059700-headers.idx"sv, "6346607a5260cb1723c8fc4338aca57391472b9b"sv}, Entry{"v1-059600-059700-headers.seg"sv, "a595df4c38fc4c654d7a8aec6c9543d9da965f75"sv}, Entry{"v1-059600-059700-transactions-to-block.idx"sv, "9d40b15e08a0df665508e935248c7cf59bb3f420"sv}, Entry{"v1-059600-059700-transactions.idx"sv, "2c3d171c255101eff736c79d3070e105d8d7972a"sv}, Entry{"v1-059600-059700-transactions.seg"sv, "a1b0adb4f97798e72f219e84357385e0d7022097"sv}, Entry{"v1-059700-059800-bodies.idx"sv, "7a084d5efa7ef6174d327624e76c9f3148c360e7"sv}, Entry{"v1-059700-059800-bodies.seg"sv, "d0fa0249064150aa2647b6ce11e2a00b3dfca65d"sv}, Entry{"v1-059700-059800-borevents.idx"sv, "f87dd5c85e2ea08e138d71840d27632533b18cf2"sv}, Entry{"v1-059700-059800-borevents.seg"sv, "4e644e27110475b0c3338a0e1a907224dc1f73c8"sv}, Entry{"v1-059700-059800-borspans.idx"sv, "861b8756e97fb1b3d8092c68781b982c9a2c56ac"sv}, Entry{"v1-059700-059800-borspans.seg"sv, "7c4143cfa7a16a07b99afdc35bf33edd4f156971"sv}, Entry{"v1-059700-059800-headers.idx"sv, "7b97793e41aabdef777e4a0b5b2e32823098c193"sv}, Entry{"v1-059700-059800-headers.seg"sv, "92d2f64c2379e666c9d383508f5dfdee7a014341"sv}, Entry{"v1-059700-059800-transactions-to-block.idx"sv, "e2b5b0d7a1719e5f0e44d7eceb5e4e4844759f6b"sv}, Entry{"v1-059700-059800-transactions.idx"sv, "87099f862f8f039a050be531a3b5802b4bbf7dc1"sv}, Entry{"v1-059700-059800-transactions.seg"sv, "c51a19bc2b041a9ffe745092317ce5d1654ff7f8"sv}, Entry{"v1-059800-059900-bodies.idx"sv, "fc14c557a06031dc54fe879fa3f3407722eb6c40"sv}, Entry{"v1-059800-059900-bodies.seg"sv, "f5165fad4a8d49ca623528b7d7cc3025b4e62652"sv}, Entry{"v1-059800-059900-borevents.idx"sv, "8dbc9f90ba1869b9311e8ed78859f3c8e0d28132"sv}, Entry{"v1-059800-059900-borevents.seg"sv, "8fc0c7fe0044f90a02e4b278c038b2b40f0138d7"sv}, Entry{"v1-059800-059900-borspans.idx"sv, "dc693e8a9e16787546ea545e025da64aea9a2a16"sv}, Entry{"v1-059800-059900-borspans.seg"sv, "b643fa23b4e503228430ff8e1f452defe0346947"sv}, Entry{"v1-059800-059900-headers.idx"sv, "80b2d3d529b47ee6e2f893c3ddc7d626b8ee839e"sv}, Entry{"v1-059800-059900-headers.seg"sv, "6693dc418eb5783e3c3d35e9646c2bf418dbb423"sv}, Entry{"v1-059800-059900-transactions-to-block.idx"sv, "83209b54311a564e9f5522f5125ce8de76f2562f"sv}, Entry{"v1-059800-059900-transactions.idx"sv, "3b651ec0d564924a9d95cc13f2a6eb332da12ad0"sv}, Entry{"v1-059800-059900-transactions.seg"sv, "35d9d7f449bf511b20e74bdf24495566cce7f494"sv}, Entry{"v1-059900-060000-bodies.idx"sv, "e7263805662e63b850ef3989dc1c21cf3209a38b"sv}, Entry{"v1-059900-060000-bodies.seg"sv, "e97f226bb6f4e56fa29978c8fb56a66f0615e9b2"sv}, Entry{"v1-059900-060000-borevents.idx"sv, "261299aa5c1ade54d2b741f861508dc8126a712d"sv}, Entry{"v1-059900-060000-borevents.seg"sv, "af6682a1b434f3ff1aad971af51b9d14957d6352"sv}, Entry{"v1-059900-060000-borspans.idx"sv, "1f41839a74a72db38106894beed88bfeb9499722"sv}, Entry{"v1-059900-060000-borspans.seg"sv, "caf2a17cc46666e6cea82894329afa5ef14b108d"sv}, Entry{"v1-059900-060000-headers.idx"sv, "6aabc620a862922078354d8fcb267ec15b5bfc61"sv}, Entry{"v1-059900-060000-headers.seg"sv, "645a2b8f342f3f57521f4d69dfacfa5fdc488bd4"sv}, Entry{"v1-059900-060000-transactions-to-block.idx"sv, "e540ec066378c267e7d0ed23443a426c25199345"sv}, Entry{"v1-059900-060000-transactions.idx"sv, "ddf3f3df8fd92234ca7ca8da29712fc87b84a3a2"sv}, Entry{"v1-059900-060000-transactions.seg"sv, "fb50b399b1ae078d8f34503a165702e7fde2cfff"sv}, Entry{"v1-060000-060100-bodies.idx"sv, "7badc4f9dd474435ff6f93b13860e8b5055a1314"sv}, Entry{"v1-060000-060100-bodies.seg"sv, "975488f143734ac13556c07d79911ed1983faab6"sv}, Entry{"v1-060000-060100-borevents.idx"sv, "4ee12ce1cb1089253713c1193b97051830deca78"sv}, Entry{"v1-060000-060100-borevents.seg"sv, "c0a600c25e9c444056320b93cff36d7eb4b01511"sv}, Entry{"v1-060000-060100-borspans.idx"sv, "605f2938750ec004eada04e0c756d4fcfe551ce4"sv}, Entry{"v1-060000-060100-borspans.seg"sv, "7f7d9365a4d16a5fabc467af72f361998fead796"sv}, Entry{"v1-060000-060100-headers.idx"sv, "035f2f86c0aa9a6218ab4f52ea8159beae81d435"sv}, Entry{"v1-060000-060100-headers.seg"sv, "176a32cefa7456ab472ed53a0b82ba56ec9ebac4"sv}, Entry{"v1-060000-060100-transactions-to-block.idx"sv, "d7981e8da98c705cfe54110ea5fffe8fb46bf434"sv}, Entry{"v1-060000-060100-transactions.idx"sv, "1fe519010422af28f298805b66137f99560230fc"sv}, Entry{"v1-060000-060100-transactions.seg"sv, "843d01e710466aa4357d2fc3a2f0fad332cf78d9"sv}, Entry{"v1-060100-060200-bodies.idx"sv, "269bb67b1e12ef7269e8b0bdfe1a96ace32fae4b"sv}, Entry{"v1-060100-060200-bodies.seg"sv, "d3024b90b23012a29c693a4ca51087f1403bc062"sv}, Entry{"v1-060100-060200-borevents.idx"sv, "f97626b03f807e14d6e17b86eb65c8f1833635f2"sv}, Entry{"v1-060100-060200-borevents.seg"sv, "f06d516533cb2f4f8b72a728e3c757543095ac98"sv}, Entry{"v1-060100-060200-borspans.idx"sv, "7e866d318baf87d138ed7e5539b371c79333c6c9"sv}, Entry{"v1-060100-060200-borspans.seg"sv, "5eabcf7fc8b3727a729ab43a30f094ade8d9e879"sv}, Entry{"v1-060100-060200-headers.idx"sv, "fc2b16ab6505d199ec2ee42dc5b236fcf3de8bfc"sv}, Entry{"v1-060100-060200-headers.seg"sv, "1cbff43b21d43fbf72d7ca26416b380948983ebd"sv}, Entry{"v1-060100-060200-transactions-to-block.idx"sv, "27726a10ddeb7aa8eecc287a853bd5923680ab34"sv}, Entry{"v1-060100-060200-transactions.idx"sv, "91c2aef205e326aabb4dea57579a868ee89c2073"sv}, Entry{"v1-060100-060200-transactions.seg"sv, "42318ef9dc1c4742901f22d79a3b7e3a7ea93237"sv}, Entry{"v1-060200-060300-bodies.idx"sv, "d44d27b6ca24e325d450dd67ff5edad4749d9588"sv}, Entry{"v1-060200-060300-bodies.seg"sv, "d0754fe403f8359ab0b3f6aed5bd810fa3232f0d"sv}, Entry{"v1-060200-060300-borevents.idx"sv, "56dc155dbc1ee4b57dc94529221ea868f6f8419c"sv}, Entry{"v1-060200-060300-borevents.seg"sv, "1b7ce27f7f4b1ed59b6e92826933a12c3ea211ff"sv}, Entry{"v1-060200-060300-borspans.idx"sv, "aa07dce1b919c0e5a408ec639d3480ec94df9644"sv}, Entry{"v1-060200-060300-borspans.seg"sv, "2ca80128d0b4e1f1e77025133bc061a5b66e8570"sv}, Entry{"v1-060200-060300-headers.idx"sv, "2be57de0f89e10fdbe41898c1988fabdffa34c79"sv}, Entry{"v1-060200-060300-headers.seg"sv, "716c17ddf3f2991b6665fa3b31eaf3b2a5da4ba1"sv}, Entry{"v1-060200-060300-transactions-to-block.idx"sv, "2eddb7d9843ba4176ede654db7ec9edd4e8985bb"sv}, Entry{"v1-060200-060300-transactions.idx"sv, "1f3afc4c138b816d1d836a5d74223210f3581879"sv}, Entry{"v1-060200-060300-transactions.seg"sv, "14a5c8a4dd2440a9d4f780b70e016b8c0dd4254d"sv}, Entry{"v1-060300-060400-bodies.idx"sv, "c0e28b829b7889f44f0239eed9304ebe5dade038"sv}, Entry{"v1-060300-060400-bodies.seg"sv, "6d9b8dd9eb66b555d8ea367c90b978017d4f7740"sv}, Entry{"v1-060300-060400-borevents.idx"sv, "4e625a4408ba5042c7232d7a794713429e9f1193"sv}, Entry{"v1-060300-060400-borevents.seg"sv, "bc0e87ae741ed136826083ccd4b4b0b8425e6227"sv}, Entry{"v1-060300-060400-borspans.idx"sv, "ebf3120429d7c84f1cc40402cdf6599f0836651c"sv}, Entry{"v1-060300-060400-borspans.seg"sv, "6bbe7c8d1bb7fb6a212d0e61993386b787319789"sv}, Entry{"v1-060300-060400-headers.idx"sv, "88577507ac0b57ea573d109a014aefbede634eee"sv}, Entry{"v1-060300-060400-headers.seg"sv, "55571e77301eafeb3f00cf236546e8c3bc7ecdc5"sv}, Entry{"v1-060300-060400-transactions-to-block.idx"sv, "bec668c731623a8c55580b74648d32c79e1f0dfe"sv}, Entry{"v1-060300-060400-transactions.idx"sv, "49722b121853244726bb52ba00d61e864409ae70"sv}, Entry{"v1-060300-060400-transactions.seg"sv, "3f417715ebb418baa9f462a3d977663aef1c417b"sv}, Entry{"v1-060400-060500-bodies.idx"sv, "69f390672e44f12b0f38fcc4eda6aee40eaa4f0c"sv}, Entry{"v1-060400-060500-bodies.seg"sv, "af7a33e71df6a6261c7c7e10e80c8887a0f192d5"sv}, Entry{"v1-060400-060500-borevents.idx"sv, "457fa50007f30ef3357b790e40fbb7dbab3c2cde"sv}, Entry{"v1-060400-060500-borevents.seg"sv, "101d30cd8e4a1dda7a18ab4d6452586df80227e2"sv}, Entry{"v1-060400-060500-borspans.idx"sv, "1f40ded39e98f062a3571ea69447da68efd118de"sv}, Entry{"v1-060400-060500-borspans.seg"sv, "c241af423c981d529d7bc0e0809223d3818f5e62"sv}, Entry{"v1-060400-060500-headers.idx"sv, "5f5af23bc998e9e604f4d6742d7a610fa9b698bf"sv}, Entry{"v1-060400-060500-headers.seg"sv, "bf0431d9ce67ab3ffd90d3fd4b298d8779e2e1a3"sv}, Entry{"v1-060400-060500-transactions-to-block.idx"sv, "b1b95256c79ae998de51a57234773a5b04ca844c"sv}, Entry{"v1-060400-060500-transactions.idx"sv, "c9cf235be06dcc93f70609c9e8daf63379e197c0"sv}, Entry{"v1-060400-060500-transactions.seg"sv, "bcfb2e2c499163250707e55e7ebb5cf5351fe4fc"sv}, Entry{"v1-060500-060600-bodies.idx"sv, "05a37394752578ccae45a437d399cac14efb6293"sv}, Entry{"v1-060500-060600-bodies.seg"sv, "a7aeca1b1488f4734dd269b025fa6dd4947ab5a3"sv}, Entry{"v1-060500-060600-borevents.idx"sv, "6864a32176632087c98dded6e22b745f90b6001d"sv}, Entry{"v1-060500-060600-borevents.seg"sv, "e0936be59c642172b5c36e979ea8b2b6a2e4c6e0"sv}, Entry{"v1-060500-060600-borspans.idx"sv, "5db2d832831bb108ef705ce47fca4eb1a5975329"sv}, Entry{"v1-060500-060600-borspans.seg"sv, "276e62b795b406641fa202f7a4664960ced468ec"sv}, Entry{"v1-060500-060600-headers.idx"sv, "ac281ebd8e211e5ec85c8b684fbee9a4e832ce2d"sv}, Entry{"v1-060500-060600-headers.seg"sv, "9f09762610624efe100c8356668a1e6a4cdffa79"sv}, Entry{"v1-060500-060600-transactions-to-block.idx"sv, "1c73aa88becbce4bd9972cc74ad215df86de3101"sv}, Entry{"v1-060500-060600-transactions.idx"sv, "e4d8e4f22456026bee85b6666f104c2391eba478"sv}, Entry{"v1-060500-060600-transactions.seg"sv, "d4b59ddea8b0fc2137b58fc1ab94b3a720811779"sv}, Entry{"v1-060600-060700-bodies.idx"sv, "a9dee84fece7bcdf48b5534cfd29f6cf40e54fb0"sv}, Entry{"v1-060600-060700-bodies.seg"sv, "324887d0c1cd3436ae9fd0c77e41d0365270221f"sv}, Entry{"v1-060600-060700-borevents.idx"sv, "26bfef1853f3f6c8206a31508a8f8d0bc442b74b"sv}, Entry{"v1-060600-060700-borevents.seg"sv, "912cf7becafd1e6be10a09650b51c12e71d5eb69"sv}, Entry{"v1-060600-060700-borspans.idx"sv, "f1ddb6d3d83708cf134adc446fd66d4267123e8f"sv}, Entry{"v1-060600-060700-borspans.seg"sv, "82e94531b384a23748962d4c3907d06af40edb36"sv}, Entry{"v1-060600-060700-headers.idx"sv, "61b85a122a40c5af7d3d856f9ac2f6edf6d09137"sv}, Entry{"v1-060600-060700-headers.seg"sv, "2c87de8abed73b0d3907b2d87f32cead7cefb7a9"sv}, Entry{"v1-060600-060700-transactions-to-block.idx"sv, "f5fc5391e820b5d0f741221819724aa516f62540"sv}, Entry{"v1-060600-060700-transactions.idx"sv, "62a4688f59bb07a3fefef9f6d706dfd1a3a6fb78"sv}, Entry{"v1-060600-060700-transactions.seg"sv, "0a8348d898d562f5148af520e191123f3f9e1e1f"sv}, Entry{"v1-060700-060800-bodies.idx"sv, "fd742a1154503f6916f4616d061a53a1b1db8efb"sv}, Entry{"v1-060700-060800-bodies.seg"sv, "d19e51e3b074b0713a1d50087cb3c1e2342c1239"sv}, Entry{"v1-060700-060800-borevents.idx"sv, "96eb31ae5e3863b5a930bff92ed5ebdd4da92c45"sv}, Entry{"v1-060700-060800-borevents.seg"sv, "882722a61743c77aeba13797f6d6d698e6d7c8b2"sv}, Entry{"v1-060700-060800-borspans.idx"sv, "a09eb1346aaeb3139e1208a3c91d982bf91236ce"sv}, Entry{"v1-060700-060800-borspans.seg"sv, "f0fc39cc673cfe4453f1684b33c6d96a34cdccc2"sv}, Entry{"v1-060700-060800-headers.idx"sv, "bbe46f3449a6c6e755ac9c3c1cd95e159813b900"sv}, Entry{"v1-060700-060800-headers.seg"sv, "f6413d36c5691cfe979f3632965cf1cc2da5bc6b"sv}, Entry{"v1-060700-060800-transactions-to-block.idx"sv, "846c5da2609e01542f3c52d4580209600f30c042"sv}, Entry{"v1-060700-060800-transactions.idx"sv, "6678b9bf63aedf9c3da43d5c072a83759414dd41"sv}, Entry{"v1-060700-060800-transactions.seg"sv, "4c1804616bab582c7f6830667d8126c3f386ad03"sv}, Entry{"v1-060800-060900-bodies.idx"sv, "a249cc0241b47d1156967ef77a8d7b7779c0e263"sv}, Entry{"v1-060800-060900-bodies.seg"sv, "ca21d4325689a7b2cce415ccf0658b6298259f3b"sv}, Entry{"v1-060800-060900-borevents.idx"sv, "6d09fe8c64a3a2c1777640a1320e31ede21de44f"sv}, Entry{"v1-060800-060900-borevents.seg"sv, "a4a4e50a6f624ea52fec91a110000d1b1a35ba33"sv}, Entry{"v1-060800-060900-borspans.idx"sv, "8382df33b8982855e9c4f986f1c49960092a9e36"sv}, Entry{"v1-060800-060900-borspans.seg"sv, "6a6dec5fec99bc24621addb0b0667f270d149953"sv}, Entry{"v1-060800-060900-headers.idx"sv, "31a8123d880094c88af7eb584aaac7ca1a2ad457"sv}, Entry{"v1-060800-060900-headers.seg"sv, "b136ed0a2907f39c6787c000ca43c67912fa9ce1"sv}, Entry{"v1-060800-060900-transactions-to-block.idx"sv, "daaab945849287bcd81a47d2150640040580c308"sv}, Entry{"v1-060800-060900-transactions.idx"sv, "d9ab73848c5eaab285a86a6b71135f53351cebce"sv}, Entry{"v1-060800-060900-transactions.seg"sv, "b8d1e9d97b0629c159afdb69df62c8be82fba6db"sv}, Entry{"v1-060900-061000-bodies.idx"sv, "b752ff8dbc60075bbbe9ff818972715506c53ffa"sv}, Entry{"v1-060900-061000-bodies.seg"sv, "41cac84c81ef89de08447d2a46975824bda6b841"sv}, Entry{"v1-060900-061000-borevents.idx"sv, "8fd18604a849549066c3e41aaa95aaa7e4ac94fa"sv}, Entry{"v1-060900-061000-borevents.seg"sv, "e05529274d4ab8a29c58d81dd8ff5184d84fcb61"sv}, Entry{"v1-060900-061000-borspans.idx"sv, "c80605aa608893bfa139120f29d2f402ce70c5e2"sv}, Entry{"v1-060900-061000-borspans.seg"sv, "18b0678a3f1e1ff078e08d850eb0af234d1bc9b2"sv}, Entry{"v1-060900-061000-headers.idx"sv, "3101c2f4317b3025e2740e553159504abe441832"sv}, Entry{"v1-060900-061000-headers.seg"sv, "bac67758fa4fc2fbd8a4ee810aa038c4b33d7e26"sv}, Entry{"v1-060900-061000-transactions-to-block.idx"sv, "84e2cf578ca0216624cfa649de6b40ac498fe31c"sv}, Entry{"v1-060900-061000-transactions.idx"sv, "1966f8a0791315d21383bc7cb06a3e21fe8fc332"sv}, Entry{"v1-060900-061000-transactions.seg"sv, "897cac5dd13e5d9cf8abbde8bba737b44900370a"sv}, Entry{"v1-061000-061100-bodies.idx"sv, "91d3f295a9666b4d1880853b2efb4ff4839a2b67"sv}, Entry{"v1-061000-061100-bodies.seg"sv, "bb17e1e85d72363526a1d332da84488a27b0fbc7"sv}, Entry{"v1-061000-061100-borevents.idx"sv, "9c8b3759c28510d06a340bf07a99fbe50ae1e898"sv}, Entry{"v1-061000-061100-borevents.seg"sv, "697fbbe6f777f6f8daff6767bf47d238e719b79a"sv}, Entry{"v1-061000-061100-borspans.idx"sv, "7981a4005e749bc5bf623d904c3e0788c5f6eab1"sv}, Entry{"v1-061000-061100-borspans.seg"sv, "1dcbf74fbe166ee568d92b8ddb98b004e8e0cc9d"sv}, Entry{"v1-061000-061100-headers.idx"sv, "8b17cab3b4e1df334410e028037b79835c04637e"sv}, Entry{"v1-061000-061100-headers.seg"sv, "5ba280b92f641c85c7d9f054e7a2e2de3247a6a9"sv}, Entry{"v1-061000-061100-transactions-to-block.idx"sv, "c6042141a70807e4448c53874361bd772131c688"sv}, Entry{"v1-061000-061100-transactions.idx"sv, "6bfb2cd8efc495b75b41bed6de8f209e44d9e075"sv}, Entry{"v1-061000-061100-transactions.seg"sv, "a49dfdc06deb7d91a150214808c4311abe32f6a5"sv}, Entry{"v1-061100-061200-bodies.idx"sv, "5089974262734308c51010011d3bfd89d6269c60"sv}, Entry{"v1-061100-061200-bodies.seg"sv, "1d04974b270a83bcd756328acfaead63e4702b50"sv}, Entry{"v1-061100-061200-borevents.idx"sv, "abfac675d771da29280117eef9677b9761a0e9c7"sv}, Entry{"v1-061100-061200-borevents.seg"sv, "09d7523dfbc092eb23685e924ee2cad6567a466b"sv}, Entry{"v1-061100-061200-borspans.idx"sv, "33b94c852be24e7775f3d6853d1b9651fa422f66"sv}, Entry{"v1-061100-061200-borspans.seg"sv, "e9f3bd615acbd7ec82a46eef344f1b615b4302ed"sv}, Entry{"v1-061100-061200-headers.idx"sv, "b10123d58e7e2e554cebd6dbb2b63c659a64d209"sv}, Entry{"v1-061100-061200-headers.seg"sv, "2f3661ebbfc5d302f7e43d55ca4a166a2e46859f"sv}, Entry{"v1-061100-061200-transactions-to-block.idx"sv, "1f107f2c87cf2a1d2e80a9ba4a17753d43b16f34"sv}, Entry{"v1-061100-061200-transactions.idx"sv, "caa14e199e641b40ab3e42c7e07c9bc319846744"sv}, Entry{"v1-061100-061200-transactions.seg"sv, "d23d46e0872351cab9d515408bca049a2015a73b"sv}, Entry{"v1-061200-061300-bodies.idx"sv, "6469b56e59b2f3620f8922f5a76454beca7292f4"sv}, Entry{"v1-061200-061300-bodies.seg"sv, "a73fdfa27d84ecf2e027b05df7438b65288e80c5"sv}, Entry{"v1-061200-061300-borevents.idx"sv, "ed6c5f92052a0b02c900c0278e476887af288d29"sv}, Entry{"v1-061200-061300-borevents.seg"sv, "ec20af618cd7b396911adf48534f29c2052df834"sv}, Entry{"v1-061200-061300-borspans.idx"sv, "3a426255baaf361916c4762599aa6af60d69472c"sv}, Entry{"v1-061200-061300-borspans.seg"sv, "ede80e57cc5604091a45d39344d571ded06713fa"sv}, Entry{"v1-061200-061300-headers.idx"sv, "cfb507b6945c6e6e2effbfd814da750f3e5a68cb"sv}, Entry{"v1-061200-061300-headers.seg"sv, "a930306fc48481a99e05209d72c5a3d28bbbeb13"sv}, Entry{"v1-061200-061300-transactions-to-block.idx"sv, "09e31a06e9c617bb7397fb76f0988194b5d9a520"sv}, Entry{"v1-061200-061300-transactions.idx"sv, "037495d503d8b7cc47117c7101a3be063f81cf78"sv}, Entry{"v1-061200-061300-transactions.seg"sv, "ced725ddfeb5112230add8f661a0ca9816285c70"sv}, Entry{"v1-061300-061400-bodies.idx"sv, "60cb75814bea8ae4420cf6f4967883965b52c2c7"sv}, Entry{"v1-061300-061400-bodies.seg"sv, "5ac80ecdec635836c4b24f992da1deca048f9d83"sv}, Entry{"v1-061300-061400-borevents.idx"sv, "7d9f4e37ebb78b07a87189131cdd564bd9c76280"sv}, Entry{"v1-061300-061400-borevents.seg"sv, "d851ea3e4a027744bd384e8f8584a5db2bf60f0a"sv}, Entry{"v1-061300-061400-borspans.idx"sv, "97f35c6b6e82e6fe129e97f11d97288eed8d1fcc"sv}, Entry{"v1-061300-061400-borspans.seg"sv, "dbd43e095f45d03c1ea65d3bdf11f6f68940d110"sv}, Entry{"v1-061300-061400-headers.idx"sv, "da04d58ab3ea404f1abf666fecd9a189abd95f3b"sv}, Entry{"v1-061300-061400-headers.seg"sv, "551911cbd3890fd58bebb972ca5435dea4c4aa87"sv}, Entry{"v1-061300-061400-transactions-to-block.idx"sv, "d6bb63a1f96c18694a8fad90570ca5330fb1a913"sv}, Entry{"v1-061300-061400-transactions.idx"sv, "aa27e4fec1af7da4a8615873f4bf0628fc5cd4ab"sv}, Entry{"v1-061300-061400-transactions.seg"sv, "4238ab3b2d26b008b2af6e3d641de74cbdab7814"sv}, Entry{"v1-061400-061500-bodies.idx"sv, "9714e448405830b4ea15b0c8d503293e93693b02"sv}, Entry{"v1-061400-061500-bodies.seg"sv, "b6f1963d67169e76fc5dd05f6c0b0e1bda59b0c3"sv}, Entry{"v1-061400-061500-borevents.idx"sv, "28a40f06108ab38271efdbfca038f29f5fb41e87"sv}, Entry{"v1-061400-061500-borevents.seg"sv, "63188587fb8bdc57d5364fcc34a28e34c3550ce0"sv}, Entry{"v1-061400-061500-borspans.idx"sv, "942827ce59146e0468d1b174d092a8e6b4946379"sv}, Entry{"v1-061400-061500-borspans.seg"sv, "627d265cb3bbff462902ede0184a86d8f4c7650c"sv}, Entry{"v1-061400-061500-headers.idx"sv, "c88044a341bcea76050534d0084dbc6839ef076c"sv}, Entry{"v1-061400-061500-headers.seg"sv, "c5e611f3be18a6a382abccbc6c4a88e77f626eaf"sv}, Entry{"v1-061400-061500-transactions-to-block.idx"sv, "102d4e01af653cc27c22b470f4b4f8f41e68ea7c"sv}, Entry{"v1-061400-061500-transactions.idx"sv, "bed0aced61d32d709f4faee949127e5baa1a0491"sv}, Entry{"v1-061400-061500-transactions.seg"sv, "e15ad290b0d1ab409a0da5bb7df0c268685c96c7"sv}, Entry{"v1-061500-061600-bodies.idx"sv, "a5a1aa8167d749930e2e17020ff3873246534539"sv}, Entry{"v1-061500-061600-bodies.seg"sv, "93def4e4bc4ffad500a099a58bf4e4d8a3bd871d"sv}, Entry{"v1-061500-061600-borevents.idx"sv, "2a14e1cbfff2c5b2da472f07f6fa3320fa653c4d"sv}, Entry{"v1-061500-061600-borevents.seg"sv, "a460660817e7ed27d618b1eee863e7923b97c0a0"sv}, Entry{"v1-061500-061600-borspans.idx"sv, "afabad46bd6276d0096553f6213865f38937a6af"sv}, Entry{"v1-061500-061600-borspans.seg"sv, "4174e06354ba2a0d2257e3537f11f4f4b873c2a8"sv}, Entry{"v1-061500-061600-headers.idx"sv, "c424084d587d3d2ff7dea10850ae870c19607a4c"sv}, Entry{"v1-061500-061600-headers.seg"sv, "82e928e1ad04496d4914f961a2203af8b1b12d1d"sv}, Entry{"v1-061500-061600-transactions-to-block.idx"sv, "585a2cdc016cf85e17b43c8af76ba473e22e6c69"sv}, Entry{"v1-061500-061600-transactions.idx"sv, "cb303be46243e8ce961834859223c7673fa2ba15"sv}, Entry{"v1-061500-061600-transactions.seg"sv, "303819b92df856b1abdacf4b831e0fc0c11ac6c1"sv}, Entry{"v1-061600-061700-bodies.idx"sv, "204f1ce8b305f623b71f185aa16463c367446993"sv}, Entry{"v1-061600-061700-bodies.seg"sv, "4e66bd3a36b1f9eb511eaa89f4cb39078a641f5d"sv}, Entry{"v1-061600-061700-borevents.idx"sv, "664a5f9bb191f3bfba8976b1e8d5cc8de3671c63"sv}, Entry{"v1-061600-061700-borevents.seg"sv, "8aa78e2fa6308ef9ca97c698180a8d45718b3b6d"sv}, Entry{"v1-061600-061700-borspans.idx"sv, "9c7b31a0f49c31f8b671c5a8c2ad364a310f0515"sv}, Entry{"v1-061600-061700-borspans.seg"sv, "5caf6501962f320dc68c982f0873c1a45229baf6"sv}, Entry{"v1-061600-061700-headers.idx"sv, "393a25a605433e36788b2f68eef5dd02f05319c7"sv}, Entry{"v1-061600-061700-headers.seg"sv, "d85011d97350033b5480601768c1b07f4918da64"sv}, Entry{"v1-061600-061700-transactions-to-block.idx"sv, "44b88cd5bc363123457fc0335f17fe0d051b78ad"sv}, Entry{"v1-061600-061700-transactions.idx"sv, "9dacc81d0631dd1e40339067d82b260c238e9748"sv}, Entry{"v1-061600-061700-transactions.seg"sv, "80a81b5cff135996b7be16eabfccd75c5da2697d"sv}, Entry{"v1-061700-061800-bodies.idx"sv, "afea24a12fe3ef238b44afc24a3912126905f8b3"sv}, Entry{"v1-061700-061800-bodies.seg"sv, "22019358ebe7f5e3b79c1d4a2da5881e8cd120bb"sv}, Entry{"v1-061700-061800-borevents.idx"sv, "b26816376779a6c358574e8c9e984ce3b509d910"sv}, Entry{"v1-061700-061800-borevents.seg"sv, "c821016c59d1f7a969ee0b7b720e194c735e3879"sv}, Entry{"v1-061700-061800-borspans.idx"sv, "295df569ccefaf03ebde6c10b76563befa5f22b0"sv}, Entry{"v1-061700-061800-borspans.seg"sv, "bbf60a713345b447bbc74c7ad6a14a43e718ec31"sv}, Entry{"v1-061700-061800-headers.idx"sv, "d565143889e994a6b58fc637e75e824671af4211"sv}, Entry{"v1-061700-061800-headers.seg"sv, "aef166ac14bc06f19ffba721ab32191096a18665"sv}, Entry{"v1-061700-061800-transactions-to-block.idx"sv, "a23021c4046a5187bcf069e6eca4ebda20999742"sv}, Entry{"v1-061700-061800-transactions.idx"sv, "055395a168f0ad4c2bbd31fc7163b6ea685d15ed"sv}, Entry{"v1-061700-061800-transactions.seg"sv, "db9ffbd765dcb36cc2ff8c409ec560d419c8bc03"sv}, Entry{"v1-061800-061900-bodies.idx"sv, "f1b847503bf5ec7fc4958dcdc3f175edecc64f6e"sv}, Entry{"v1-061800-061900-bodies.seg"sv, "ef1cdad12adf8862d9f3740e93afc6bc412665a6"sv}, Entry{"v1-061800-061900-borevents.idx"sv, "902495b1de483775556fdeac925dfaf50497980d"sv}, Entry{"v1-061800-061900-borevents.seg"sv, "b67ed0f3f6bda527cd23d8eeb78926134761d433"sv}, Entry{"v1-061800-061900-borspans.idx"sv, "59f98d52caf2b6ab65600d0521d68ef1ae98d648"sv}, Entry{"v1-061800-061900-borspans.seg"sv, "66f8ff228626c7250dc2762ad1dcd09f44263975"sv}, Entry{"v1-061800-061900-headers.idx"sv, "7d38f3ee18d7e2287b0c37ad59b25dcbaf7e1ffe"sv}, Entry{"v1-061800-061900-headers.seg"sv, "9433275848ed04fcf600f68a7dfdef7a811f0567"sv}, Entry{"v1-061800-061900-transactions-to-block.idx"sv, "bec617cabf5a5f441639c90598d929b31f9e40d8"sv}, Entry{"v1-061800-061900-transactions.idx"sv, "387f8b1271b2264c17241ada2d5d5ba2566b858e"sv}, Entry{"v1-061800-061900-transactions.seg"sv, "14dd8b0d2749a30544b31078dbd1ac5941b538ff"sv}, Entry{"v1-061900-062000-bodies.idx"sv, "8b4de8c38009ce9b9f4feb9a10d6b16f5c814fd9"sv}, Entry{"v1-061900-062000-bodies.seg"sv, "7c9ce13385f3c1073b10ad63ea9c6b3f352e84f5"sv}, Entry{"v1-061900-062000-borevents.idx"sv, "cd05da86393f593ed03785fadce22ef0fc3559d3"sv}, Entry{"v1-061900-062000-borevents.seg"sv, "fc7dfb6885b7383eece309a5e08eeaf1bdd53dec"sv}, Entry{"v1-061900-062000-borspans.idx"sv, "aa1f7c9a76e6ff922d3495a5902ce886b6be4d9c"sv}, Entry{"v1-061900-062000-borspans.seg"sv, "e7e04d682ebce962c32e791ffb3a9c5bdb86cb1c"sv}, Entry{"v1-061900-062000-headers.idx"sv, "582d9c78ccbdd8ad8ce6e2fc175c37bc965bc617"sv}, Entry{"v1-061900-062000-headers.seg"sv, "c21bc2dc73b2ec55419cd56d3743b459d8475b0f"sv}, Entry{"v1-061900-062000-transactions-to-block.idx"sv, "df4a3b2ff6d864f46da657b33cb9e665d6c9eb2f"sv}, Entry{"v1-061900-062000-transactions.idx"sv, "ccb302f915e91df9000b7d0ee84673033d2721ef"sv}, Entry{"v1-061900-062000-transactions.seg"sv, "bdf9abb2a02ccd59f7b902d346c9a80cb8e9fda7"sv}, Entry{"v1-062000-062100-bodies.idx"sv, "91a85ede5ffae0891c9c8777777adf6570d5b376"sv}, Entry{"v1-062000-062100-bodies.seg"sv, "9ba069b44f940e59370698776b672b378c52b94f"sv}, Entry{"v1-062000-062100-borevents.idx"sv, "097e5a07dcb2b2125e77268355781db4f4dd4bc4"sv}, Entry{"v1-062000-062100-borevents.seg"sv, "6427d62b2174321ad086d9665fa8b864eca87ba8"sv}, Entry{"v1-062000-062100-borspans.idx"sv, "8e96853e0e101fcffff8c2a7fa455c2f18ab35fb"sv}, Entry{"v1-062000-062100-borspans.seg"sv, "ee061de552dbff6e7758d77d1c7ed03920ea5f78"sv}, Entry{"v1-062000-062100-headers.idx"sv, "cd2e4a944ec75d7b13744e40c132af16c9a68902"sv}, Entry{"v1-062000-062100-headers.seg"sv, "412a4f1bd34a090aa3eea812dd11156883a60fd3"sv}, Entry{"v1-062000-062100-transactions-to-block.idx"sv, "e39afbb68457f15fffcb3799e83aeecb7842ee62"sv}, Entry{"v1-062000-062100-transactions.idx"sv, "f75e3ef8019cffdc2e1fc34855b83229faf8f6df"sv}, Entry{"v1-062000-062100-transactions.seg"sv, "b592273686cb32aee842dc69a9865abc8de03de3"sv}, Entry{"v1-062100-062200-bodies.idx"sv, "5af1c91a3f9678d079f3c3baeb2ef32e36f09a7f"sv}, Entry{"v1-062100-062200-bodies.seg"sv, "96a9c5c8274c4d86a02857414dd30b5fafe6aeaf"sv}, Entry{"v1-062100-062200-borevents.idx"sv, "0719fcfaeee2891a1c5880ab26d2377a8a0f49de"sv}, Entry{"v1-062100-062200-borevents.seg"sv, "f46cadf0e2e8549042db64eb768108fd06c14101"sv}, Entry{"v1-062100-062200-borspans.idx"sv, "41658e6e4e034e7e4772f46058a20060db730770"sv}, Entry{"v1-062100-062200-borspans.seg"sv, "c9d8995fc9dff3b2f58a46fe1ed90056a141b25f"sv}, Entry{"v1-062100-062200-headers.idx"sv, "6f6a3a769f8eef43d9a5faf418f310fcca964f89"sv}, Entry{"v1-062100-062200-headers.seg"sv, "3fa6917eb70c127bf24a4545bea84fbab3ddddac"sv}, Entry{"v1-062100-062200-transactions-to-block.idx"sv, "d256760c8b92c94bf7c3c92d06c38bae4929501e"sv}, Entry{"v1-062100-062200-transactions.idx"sv, "5d7d4318b113ed0cfccb3382aa37ac87516b49ea"sv}, Entry{"v1-062100-062200-transactions.seg"sv, "a7ec03765a65747343ccc53de0ef0b8549574e7c"sv}, Entry{"v1-062200-062300-bodies.idx"sv, "b5c2b063e11b38e1c1fe53faa955c068a1835525"sv}, Entry{"v1-062200-062300-bodies.seg"sv, "c75dbbdf974c431a95c29089dc3fdd35aac3dc62"sv}, Entry{"v1-062200-062300-borevents.idx"sv, "26d689521554bea434415cad20a8670f2188691d"sv}, Entry{"v1-062200-062300-borevents.seg"sv, "589f088a13159c9772e912eabb25ebb297950d47"sv}, Entry{"v1-062200-062300-borspans.idx"sv, "64dde2e36ce75e15e6749652edf035350ea50070"sv}, Entry{"v1-062200-062300-borspans.seg"sv, "ea0e8262f69deda819e0ec817aab327fadee6546"sv}, Entry{"v1-062200-062300-headers.idx"sv, "3352a0fb20c45d87d21ba3f57965668f5a57dcea"sv}, Entry{"v1-062200-062300-headers.seg"sv, "f0f7dfa5540b5966eb02dc81030ed644b361431e"sv}, Entry{"v1-062200-062300-transactions-to-block.idx"sv, "c5253b79873d8594c68c960b742139edbb4249d8"sv}, Entry{"v1-062200-062300-transactions.idx"sv, "24abb6136ddc1f5d3ea6d6859b48ccee02811fdf"sv}, Entry{"v1-062200-062300-transactions.seg"sv, "78e965d35c778d6df04628b5f85aeea9f6fe9851"sv}, Entry{"v1-062300-062400-bodies.idx"sv, "77bc73e3f8a50fe2fca11b1d3a73258b116d7549"sv}, Entry{"v1-062300-062400-bodies.seg"sv, "8a163febdd600982b3c79c578ace2ac53341748c"sv}, Entry{"v1-062300-062400-borevents.idx"sv, "c5897e5bf50e3bdcaea047a98129ea163cc6a890"sv}, Entry{"v1-062300-062400-borevents.seg"sv, "b52279f11cd178bf27e05048ae9f298eac47c276"sv}, Entry{"v1-062300-062400-borspans.idx"sv, "224bbb6dbcac8998e8fcc31bb9ade6210348172c"sv}, Entry{"v1-062300-062400-borspans.seg"sv, "85021f9c6216ad6cdb7529734e8c0439eb553fd3"sv}, Entry{"v1-062300-062400-headers.idx"sv, "543068dfb86a2eb66d7e50fb9e914e993f7f4b2f"sv}, Entry{"v1-062300-062400-headers.seg"sv, "03c94785af375e6de077756f6e73141b1ea2c211"sv}, Entry{"v1-062300-062400-transactions-to-block.idx"sv, "d48f94dd79f32560fa9d23f2de765883f4e039a2"sv}, Entry{"v1-062300-062400-transactions.idx"sv, "0807ea626aa199ba3d96e2213f202ca74b5ef4fe"sv}, Entry{"v1-062300-062400-transactions.seg"sv, "ffda559a9d2ccfe41a7616cf854e6dd2e3f8b63d"sv}, Entry{"v1-062400-062410-bodies.idx"sv, "180075c6b1d7cb79be7337a17ddd21056a2ec8cb"sv}, Entry{"v1-062400-062410-bodies.seg"sv, "daa28c7d9ba16c4c3f9d3b39feb3240e969d0c15"sv}, Entry{"v1-062400-062410-borevents.idx"sv, "067ca927828fdb1c00d03669a528571e8fcf85f6"sv}, Entry{"v1-062400-062410-borevents.seg"sv, "82061c94a2182d11c1a5f213fbc987a88d839d40"sv}, Entry{"v1-062400-062410-borspans.idx"sv, "b284028297d94db9bfab9de4bdca479443dc7ea6"sv}, Entry{"v1-062400-062410-borspans.seg"sv, "bfb7e4dcd5fffa677dd3b7dc2564ffe2df337d5c"sv}, Entry{"v1-062400-062410-headers.idx"sv, "bc1679fa45878354cbf7746c451a285de5c88546"sv}, Entry{"v1-062400-062410-headers.seg"sv, "fa67d775e23ec2370a6d7cd139626e0f10331b24"sv}, Entry{"v1-062400-062410-transactions-to-block.idx"sv, "1c1ec143a586e886a4184094b765c6fb30ab06bd"sv}, Entry{"v1-062400-062410-transactions.idx"sv, "42d206a2573fe66b743c3eea76d79b644027a2b7"sv}, Entry{"v1-062400-062410-transactions.seg"sv, "7767ea41f69d92873fc8885e7a73804c5fdd1052"sv}, Entry{"v1-062410-062420-bodies.idx"sv, "31107edf8d424324ee36df2b007e69bd0b413a5a"sv}, Entry{"v1-062410-062420-bodies.seg"sv, "26fc9e63fa207520a33b57e3776e2b40a63da5b2"sv}, Entry{"v1-062410-062420-borevents.idx"sv, "fc247886acb605558cf2bf55f7d3bbc98717d92f"sv}, Entry{"v1-062410-062420-borevents.seg"sv, "48749de5dba5d49a4d9f8b87a6b09a53ce93bd8b"sv}, Entry{"v1-062410-062420-borspans.idx"sv, "76d45df42c422cee340761545ee7d5424c6967e3"sv}, Entry{"v1-062410-062420-borspans.seg"sv, "c1e6cf1ab88e664959359bcedc9815de07b21d12"sv}, Entry{"v1-062410-062420-headers.idx"sv, "dcf28ddd8691a249d0141c9c34c20e9ef6632eb6"sv}, Entry{"v1-062410-062420-headers.seg"sv, "1c04c89120b191e1d1e7d1c3783e9b37f5f5ae4c"sv}, Entry{"v1-062410-062420-transactions-to-block.idx"sv, "e81a4a5d98c4c0a9682ba047ea97c41b0f27870c"sv}, Entry{"v1-062410-062420-transactions.idx"sv, "2cf3e3a540348c20dbd20f4a577c09b66b8f233c"sv}, Entry{"v1-062410-062420-transactions.seg"sv, "e504ffbd01dc969213658a4d008343ed447c0f11"sv}, Entry{"v1-062420-062430-bodies.idx"sv, "af149daf31db7a7aeb6ce3db197ee6712218da59"sv}, Entry{"v1-062420-062430-bodies.seg"sv, "04fede274f2e76c1387b5262be75b4927f1b5805"sv}, Entry{"v1-062420-062430-borevents.idx"sv, "715d02c204d90dbb3da014542f992897856a1657"sv}, Entry{"v1-062420-062430-borevents.seg"sv, "3ebaad82fb6e56c92c42d3d431e4458996ab4e53"sv}, Entry{"v1-062420-062430-borspans.idx"sv, "77c008ec12a92571909a578bc58e98fe1c9f8b5a"sv}, Entry{"v1-062420-062430-borspans.seg"sv, "18a24f46fd04efc134432fa2ddc93916cc15b79c"sv}, Entry{"v1-062420-062430-headers.idx"sv, "efe2ff6820b7f2dfc84c68ca56cb70268ba313c3"sv}, Entry{"v1-062420-062430-headers.seg"sv, "be64574d14e467bda55cb5907e75e02c8bcac5fe"sv}, Entry{"v1-062420-062430-transactions-to-block.idx"sv, "3f8fdd916de50a676644457f67045a234f88758c"sv}, Entry{"v1-062420-062430-transactions.idx"sv, "f1c8eb0c087d5c0ca3b86e029ae2ca35d50cca3e"sv}, Entry{"v1-062420-062430-transactions.seg"sv, "77038ac5287bfd5c97ddc66ec4cd4476eb0d4638"sv}, Entry{"v1-062430-062440-bodies.idx"sv, "abfaf093b5ca15c15f943ff7b5307277cacc058f"sv}, Entry{"v1-062430-062440-bodies.seg"sv, "0f03c5b4257078d30cb10f3b8f2628da33ce9269"sv}, Entry{"v1-062430-062440-borevents.idx"sv, "dd8b304be31b0f42c34df75770d769457e5f0ce1"sv}, Entry{"v1-062430-062440-borevents.seg"sv, "d316462d4365814e0cfb1511c75bbe0f2a75e37d"sv}, Entry{"v1-062430-062440-borspans.idx"sv, "4cc345168953099771b4a81e57351078ea185e27"sv}, Entry{"v1-062430-062440-borspans.seg"sv, "cdd59d678a306f7d0c8dd11c443136601962b670"sv}, Entry{"v1-062430-062440-headers.idx"sv, "aeb5b8cd9dd7f2b8c1d4670f65903e4f6e8bd791"sv}, Entry{"v1-062430-062440-headers.seg"sv, "073815bf04d86d9f9f736a6e8c1a46068bf2b8c1"sv}, Entry{"v1-062430-062440-transactions-to-block.idx"sv, "56deb69a28b938ef7a7e9048a5598af531e3720e"sv}, Entry{"v1-062430-062440-transactions.idx"sv, "ee8887358d7031bb3dbc90ea19b78e622f7f9ee6"sv}, Entry{"v1-062430-062440-transactions.seg"sv, "bb881fd29ce5ae8ae6e61245ee00d3dc54da25a1"sv}, Entry{"v1-062440-062441-bodies.idx"sv, "f348f40bb0c82aafb22160fc84f187269be2ca1f"sv}, Entry{"v1-062440-062441-bodies.seg"sv, "6c0a17021cd0043c6816dd388d46c7b2633e79da"sv}, Entry{"v1-062440-062441-borevents.idx"sv, "5664ac705783e9e5b2c129e23729d45bb5b446ed"sv}, Entry{"v1-062440-062441-borevents.seg"sv, "1e6d9fa7ea9579732f77c48d436f86ba0440ff49"sv}, Entry{"v1-062440-062441-borspans.idx"sv, "65aa2e0754eb0da3e6b0ca4922e452e33c6a32b7"sv}, Entry{"v1-062440-062441-borspans.seg"sv, "d6c5c34c69b2d5c4b30bf7a5eee63ba8ddc26c8c"sv}, Entry{"v1-062440-062441-headers.idx"sv, "715429d615dbec0b3afe281ca3d07cc689748e0b"sv}, Entry{"v1-062440-062441-headers.seg"sv, "63f15cb71aeb0cef853b1222ebcd25b63c737aca"sv}, Entry{"v1-062440-062441-transactions-to-block.idx"sv, "ebe8c2af8b232f4fa73cbf7361ab4eeebdd02547"sv}, Entry{"v1-062440-062441-transactions.idx"sv, "b7356cb686747d5e8ab2897cd2036bfc944e1fa0"sv}, Entry{"v1-062440-062441-transactions.seg"sv, "4281ec2a8376ad42c9a78e95ebb89eb2290f3ba0"sv}, Entry{"v1-062441-062442-bodies.idx"sv, "be92a5267afb9c02ff3df3ab2b148661f4eded8f"sv}, Entry{"v1-062441-062442-bodies.seg"sv, "8a1f97c504ea13fe557dfec9829c9606fa533854"sv}, Entry{"v1-062441-062442-borevents.idx"sv, "87239059287d98a18d9766afa74406b67c4b28b1"sv}, Entry{"v1-062441-062442-borevents.seg"sv, "5144baa67ee1489b8a5e151761609e260d8e1df3"sv}, Entry{"v1-062441-062442-borspans.idx"sv, "4f8f41eba8814ea96cd3e50f5fb01ec91ecd83d0"sv}, Entry{"v1-062441-062442-borspans.seg"sv, "39fed1520af7d56d5cddf0104069edd0d325c2b9"sv}, Entry{"v1-062441-062442-headers.idx"sv, "3d1ddb684daa221483171b8f67c54d1209ea1f36"sv}, Entry{"v1-062441-062442-headers.seg"sv, "fcaf2a16967b6a6cc7478131a0eb28b7b42d20dd"sv}, Entry{"v1-062441-062442-transactions-to-block.idx"sv, "c6a5eba7042bfb3efc8b945a696762ac9af2accd"sv}, Entry{"v1-062441-062442-transactions.idx"sv, "e239049e9d682953f1268b58ea9872311fb9604e"sv}, Entry{"v1-062441-062442-transactions.seg"sv, "d711fb7c00f0e8b7f75037d18ee9d694016aaa66"sv}, Entry{"v1-062442-062443-bodies.idx"sv, "d295b333820b0d882146bf1f09a3f88e85c2d21c"sv}, Entry{"v1-062442-062443-bodies.seg"sv, "23da1563a599feaaefc124a719811daf87e9eb2c"sv}, Entry{"v1-062442-062443-borevents.idx"sv, "347aabf6db19656d42e9a606c3964bf967e4ff73"sv}, Entry{"v1-062442-062443-borevents.seg"sv, "0551a849025f07d8cee26449b6734f6e35a87104"sv}, Entry{"v1-062442-062443-borspans.idx"sv, "59ea345bd09cd5cee0cb1024dce7ccb82ccc9847"sv}, Entry{"v1-062442-062443-borspans.seg"sv, "d9a67c7ffa7db6dbd60408b943c4afc9e4e7cb3c"sv}, Entry{"v1-062442-062443-headers.idx"sv, "ccbc5a151f333b06d18699b8a974161e0c31d039"sv}, Entry{"v1-062442-062443-headers.seg"sv, "ff76f5847008ecedbcdc5c29ccd96badfb40c8ff"sv}, Entry{"v1-062442-062443-transactions-to-block.idx"sv, "4842e0f83df0322e5b1826063383343628488d58"sv}, Entry{"v1-062442-062443-transactions.idx"sv, "69cb1565c012c36f6c0807f8d1ebe8040cefed36"sv}, Entry{"v1-062442-062443-transactions.seg"sv, "5275cd5b06be8e8629d67680e2eb7d7ad6b2c05f"sv}, Entry{"v1-062443-062444-bodies.idx"sv, "78c4de490c02048b2e7ee5ee2b1e377d98d04ac2"sv}, Entry{"v1-062443-062444-bodies.seg"sv, "688a0e2106859ec2d7eb9d6953cfd71df4692975"sv}, Entry{"v1-062443-062444-borevents.idx"sv, "c3fd156acad82516afa13d77a0b03acdbca7ae9b"sv}, Entry{"v1-062443-062444-borevents.seg"sv, "a8b6ad3bab5f8eafdd00f5252c59bdbc4cecc54d"sv}, Entry{"v1-062443-062444-borspans.idx"sv, "7229f92dbd8c71c0c5a2bb25e8ce28b6177fea4a"sv}, Entry{"v1-062443-062444-borspans.seg"sv, "99fe7fe1789fac6371fc814a5ccb46eb2c3f9bb4"sv}, Entry{"v1-062443-062444-headers.idx"sv, "aa53b31873363ba748255354f13275823ba3b534"sv}, Entry{"v1-062443-062444-headers.seg"sv, "bfc70ea0ede33e7b83e22be9b95ee346b2ca11b2"sv}, Entry{"v1-062443-062444-transactions-to-block.idx"sv, "797945f15c58595b650e454872d5a5000b73ab60"sv}, Entry{"v1-062443-062444-transactions.idx"sv, "21cc61f3f890ca47696a981892e49f6ecc611fcb"sv}, Entry{"v1-062443-062444-transactions.seg"sv, "4b74782959cda364a658d64b3427360ad177e160"sv}, Entry{"v1-062444-062445-bodies.idx"sv, "53d38898c5880769cce21e2bc99b99b337e5a680"sv}, Entry{"v1-062444-062445-bodies.seg"sv, "4e285a8b2b7fa94a399f588f55a72c5a361f64d9"sv}, Entry{"v1-062444-062445-borevents.idx"sv, "1850851a5f2434f1eb02be17ec39e652cde1960b"sv}, Entry{"v1-062444-062445-borevents.seg"sv, "742fcba1c78d5c43edd71d407380275df0abd2c0"sv}, Entry{"v1-062444-062445-borspans.idx"sv, "41898e8380fec5be38feb17273259530cc25859d"sv}, Entry{"v1-062444-062445-borspans.seg"sv, "a5b0506c5f443ed6cf6034638558c1899920ec32"sv}, Entry{"v1-062444-062445-headers.idx"sv, "17ba8d317d44a0ea95c0d7106185c9fbe402f1ea"sv}, Entry{"v1-062444-062445-headers.seg"sv, "b324f11b5e43a11785ab7510f2b00bb28279595b"sv}, Entry{"v1-062444-062445-transactions-to-block.idx"sv, "f48e5f84ac2be445b828af41c458678a6e092650"sv}, Entry{"v1-062444-062445-transactions.idx"sv, "80413bf0378f00f34592a9fdfa9280c0f227afa6"sv}, Entry{"v1-062444-062445-transactions.seg"sv, "458e3d44a4561911746f2c0a9b3f37d1d5328397"sv}, }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/chains/holesky.hpp ================================================ /* Generated from holesky.toml using Silkworm embed_toml */ #pragma once #include #include #include "../entry.hpp" namespace silkworm::snapshots { using namespace std::literals; inline constexpr std::array kHoleskySnapshots{ Entry{"accessor/v1-accounts.0-64.efi"sv, "49a676185187acbaeb78fc9eff08a781b8086baf"sv}, Entry{"accessor/v1-accounts.0-64.vi"sv, "b80ddbc31871c358f72de107ba3321eb4faa1f02"sv}, Entry{"accessor/v1-code.0-64.efi"sv, "19075e972a09c48c90d1c61587b038b6eaa7896d"sv}, Entry{"accessor/v1-code.0-64.vi"sv, "48acf0d21bfca12fb391690725eec60b87c92f8a"sv}, Entry{"accessor/v1-logaddrs.0-64.efi"sv, "389bced28d01929aa4339bcb965a0170e01c2b82"sv}, Entry{"accessor/v1-logtopics.0-64.efi"sv, "cbfe6839a716e5f3195d770cd127574b997441bb"sv}, Entry{"accessor/v1-receipt.0-64.efi"sv, "a210c217353f7507ce6fdae113330812eedcec53"sv}, Entry{"accessor/v1-receipt.0-64.vi"sv, "114fc95bc4c33a24bd12f2f21d74ad01bd337aeb"sv}, Entry{"accessor/v1-storage.0-64.efi"sv, "681514f318e12003ac785b4569043a7c307ba2eb"sv}, Entry{"accessor/v1-storage.0-64.vi"sv, "142bf3068339f81dc95b57ef77ecce20464eab18"sv}, Entry{"accessor/v1-tracesfrom.0-64.efi"sv, "6ce8597a924f44924310d53558221481a947d8ba"sv}, Entry{"accessor/v1-tracesto.0-64.efi"sv, "4cc37f4f026f691270b126a1fb0dc66086aa41c1"sv}, Entry{"domain/v1-accounts.0-64.bt"sv, "920c183ba941a26b159dcd356ab51f35a7f586fb"sv}, Entry{"domain/v1-accounts.0-64.kv"sv, "74436bdac97ea7728e89ba0ee338e06b5468760b"sv}, Entry{"domain/v1-accounts.0-64.kvei"sv, "e3500f0334e7841c59c9faac663b86c2cd4b58ce"sv}, Entry{"domain/v1-code.0-64.bt"sv, "5d8c5f333add8f9346b8dcb91dafedc080d4bcb2"sv}, Entry{"domain/v1-code.0-64.kv"sv, "f60be7ff12fecef80b1e8026136224c46adf562a"sv}, Entry{"domain/v1-code.0-64.kvei"sv, "128cbfedc3a7e260fa74d7d82231a60a97ffd4f2"sv}, Entry{"domain/v1-commitment.0-64.bt"sv, "6dea7ec4ba93a25a7330c66522f4d130a579258d"sv}, Entry{"domain/v1-commitment.0-64.kv"sv, "d6ae56146fd720c8b33943d683d338405d6b66ff"sv}, Entry{"domain/v1-commitment.0-64.kvei"sv, "976826f7b507cd38249d7a5d106d02a9024ddfd8"sv}, Entry{"domain/v1-receipt.0-64.bt"sv, "f81e5d9d8a1c2a8703c56f38ab568189be4ace1c"sv}, Entry{"domain/v1-receipt.0-64.kv"sv, "87f38d7d6dff1a2eff5edd737e2b74c09b335610"sv}, Entry{"domain/v1-receipt.0-64.kvei"sv, "55d2a00d13f5a931500a79cc7e7989ec1c1a632c"sv}, Entry{"domain/v1-storage.0-64.bt"sv, "f1f7cf95eb57a5d88dd37d3681ab046ee9ac6415"sv}, Entry{"domain/v1-storage.0-64.kv"sv, "57a297b3a7c8e5d06151bf37e673fc22b9190dec"sv}, Entry{"domain/v1-storage.0-64.kvei"sv, "77f5532392458db7e919ab4b0e4c20aed58f3e2e"sv}, Entry{"history/v1-accounts.0-64.v"sv, "fddb2f72952dcfa2cb385b03192b336eee1b3cb5"sv}, Entry{"history/v1-code.0-64.v"sv, "c4aaca5a20a1b7d79bd0aea213b40cc704b8046a"sv}, Entry{"history/v1-receipt.0-64.v"sv, "e85ded3919849b95db3c14715603471970bb1952"sv}, Entry{"history/v1-storage.0-64.v"sv, "973aec1f89deb6b6a21efa6459aeaed178411783"sv}, Entry{"idx/v1-accounts.0-64.ef"sv, "d12a8cb302482c356067c43da329aec11a8440d4"sv}, Entry{"idx/v1-code.0-64.ef"sv, "5d6649a4c94b42651f49d1aeb10784ffa6c138cf"sv}, Entry{"idx/v1-logaddrs.0-64.ef"sv, "35484e8595323974f2b73114bcd9ec8a17ba7e11"sv}, Entry{"idx/v1-logtopics.0-64.ef"sv, "cfa462c85cfb9ad2bae6f5d467600b818f5e6c55"sv}, Entry{"idx/v1-receipt.0-64.ef"sv, "5f1ebda8a93d81eae2055128c4a6a96622331a04"sv}, Entry{"idx/v1-receipt.40-41.ef"sv, "4d06e7a825b5560fc95f6cd94ed326b2bc8991bf"sv}, Entry{"idx/v1-storage.0-64.ef"sv, "1d5acb9ff64fb7721581479e457d32ce87b9d3f2"sv}, Entry{"idx/v1-tracesfrom.0-64.ef"sv, "00803ec9c6eb333d632fb6716fc35e99c8b85a1a"sv}, Entry{"idx/v1-tracesto.0-64.ef"sv, "0f4961104b97f48ddc94ee381524eeca43054c15"sv}, Entry{"salt-blocks.txt"sv, "de6d558e79c68a43d54eadd0456473ce8dd864f6"sv}, Entry{"salt-state.txt"sv, "0113ec56c7c0d72783dbb5738becffa9c4c43d69"sv}, Entry{"v1-000000-000100-bodies.idx"sv, "cbd1d0d89809f19535e6e95d6432aa024dcd1a19"sv}, Entry{"v1-000000-000100-bodies.seg"sv, "d5d88d8ebd77a4f5e69920c95d75ebe55262a347"sv}, Entry{"v1-000000-000100-headers.idx"sv, "bbbe779600014e20b21ee96e5158274a1f2ab983"sv}, Entry{"v1-000000-000100-headers.seg"sv, "ac07075a0d7be59ded0ed2eee21572cedde6ac19"sv}, Entry{"v1-000000-000100-transactions-to-block.idx"sv, "47f536ea7c7a1fd2fc243e4b8ac8c0521bbf2ed8"sv}, Entry{"v1-000000-000100-transactions.idx"sv, "30195a5a1311986c6265d3397def200191c5dfde"sv}, Entry{"v1-000000-000100-transactions.seg"sv, "669596f738149744d6bfb8b1e46ee3d6635ffc60"sv}, Entry{"v1-000100-000200-bodies.idx"sv, "e35eec85d9ca467ffe7fc36a71b8ffd309cbdb2d"sv}, Entry{"v1-000100-000200-bodies.seg"sv, "712732817cfa73b02e773ff74fb2e8778117f25a"sv}, Entry{"v1-000100-000200-headers.idx"sv, "41a9a6e9d38db96bc4c000c91844a5038ccd1362"sv}, Entry{"v1-000100-000200-headers.seg"sv, "4521f1599d1013500dad951bee2820a1c4773b50"sv}, Entry{"v1-000100-000200-transactions-to-block.idx"sv, "44720c434c1abf739f82ccbf09d2693d85bd4a82"sv}, Entry{"v1-000100-000200-transactions.idx"sv, "f9b4fcadbb7128f98d8560e7e6c91f7e238eb295"sv}, Entry{"v1-000100-000200-transactions.seg"sv, "d2c929758dad93c7dc1b355985b78d16d2b97f90"sv}, Entry{"v1-000200-000300-bodies.idx"sv, "db83298ff226551519ab5272624ba93b9b8f82de"sv}, Entry{"v1-000200-000300-bodies.seg"sv, "5b53df86bab1d8e008564d43e6076c3693fd6b74"sv}, Entry{"v1-000200-000300-headers.idx"sv, "26fe03c338e2ca1cfe6f06d4e7145e2d2c64a839"sv}, Entry{"v1-000200-000300-headers.seg"sv, "e198df9318bd7aec9e23d40edf949d323fd99fd6"sv}, Entry{"v1-000200-000300-transactions-to-block.idx"sv, "de6ffaa7594ac0b6787ce07d0da23a8108b727e8"sv}, Entry{"v1-000200-000300-transactions.idx"sv, "5483fd72285f025b4148e434b26185ddba198be6"sv}, Entry{"v1-000200-000300-transactions.seg"sv, "ce28ba0f8ff305b1f037b69c8a3705f3bfa8f756"sv}, Entry{"v1-000300-000400-bodies.idx"sv, "1ae1acdecaa1d38226d99bb65fa3309f715ffd77"sv}, Entry{"v1-000300-000400-bodies.seg"sv, "e1a023692589106ffaf483770354145f5f25146c"sv}, Entry{"v1-000300-000400-headers.idx"sv, "41c2eca5a4cf98b0b9dedc60cc5d1c36b259911b"sv}, Entry{"v1-000300-000400-headers.seg"sv, "b5d99e121975ab4cbcde3a106090db4026f1509e"sv}, Entry{"v1-000300-000400-transactions-to-block.idx"sv, "671195b64192bd7829a2476a64b96226ccb8a1b4"sv}, Entry{"v1-000300-000400-transactions.idx"sv, "5429631789fda14bbb434e59e73f0641d9e2f1e4"sv}, Entry{"v1-000300-000400-transactions.seg"sv, "77b8884b7c09d5dadf0a7c3410c1ee265b29ab6f"sv}, Entry{"v1-000400-000500-bodies.idx"sv, "60ad39b25e9c262d1761bc434523e6ab4c1e88f7"sv}, Entry{"v1-000400-000500-bodies.seg"sv, "d8443f942f5b8671012594761fb916f817ec1f6c"sv}, Entry{"v1-000400-000500-headers.idx"sv, "aec06c1c6632d407428e736751744e6d35ded07e"sv}, Entry{"v1-000400-000500-headers.seg"sv, "ec695209520d936caa489b7b62974ddbda93bef6"sv}, Entry{"v1-000400-000500-transactions-to-block.idx"sv, "37a227352a887ff3a5b409f73601c85446f4ca24"sv}, Entry{"v1-000400-000500-transactions.idx"sv, "bac5b547858d85a6a2764992f6c5ce256005307b"sv}, Entry{"v1-000400-000500-transactions.seg"sv, "753e4de0f535e9177f4463dfc9ec259b76f6671c"sv}, Entry{"v1-000500-000600-bodies.idx"sv, "658137b8911c7c246df37f5d14bebc36896d7342"sv}, Entry{"v1-000500-000600-bodies.seg"sv, "118f6d96ad69b125c48168adc707bf4a509f9cc3"sv}, Entry{"v1-000500-000600-headers.idx"sv, "3314b0d326d7f6f2bad9d17b59f9eb209e5083ad"sv}, Entry{"v1-000500-000600-headers.seg"sv, "44adad9a7dfcf6c36ce80f061260f52c74d28d7b"sv}, Entry{"v1-000500-000600-transactions-to-block.idx"sv, "45a7c754d0f6ed6f4a6f644771a11cab053101af"sv}, Entry{"v1-000500-000600-transactions.idx"sv, "fded959ac856da32169e9a306749e6763c91fac0"sv}, Entry{"v1-000500-000600-transactions.seg"sv, "7eab2cf5b134bf8f8593dffde99fffa974d4bbc0"sv}, Entry{"v1-000600-000700-bodies.idx"sv, "9738e770a091378871a49139f5031baed09f057c"sv}, Entry{"v1-000600-000700-bodies.seg"sv, "81fba6deb46fcd6756891e85167f2196d3dfdee5"sv}, Entry{"v1-000600-000700-headers.idx"sv, "92d14e88e44fc585151c16b1ca9b69f3313066fa"sv}, Entry{"v1-000600-000700-headers.seg"sv, "8b2dd9ffc76ef207e95c8d0c0b096ff1f5a11270"sv}, Entry{"v1-000600-000700-transactions-to-block.idx"sv, "e6189feb03a88bfe6126344ddd8f5c085b0d1348"sv}, Entry{"v1-000600-000700-transactions.idx"sv, "c73e912325bfed32b1011430ae6267e676897c06"sv}, Entry{"v1-000600-000700-transactions.seg"sv, "0c7e967dde87bec801b4cc57ffe4d7f4d06f504c"sv}, Entry{"v1-000700-000800-bodies.idx"sv, "a99388071bf7a27fdf1ac290e8a4c1c2e629f7ed"sv}, Entry{"v1-000700-000800-bodies.seg"sv, "37080cf1bf946613a9d460bb315f8099f76989a6"sv}, Entry{"v1-000700-000800-headers.idx"sv, "2c669b1cba96a4b236c2b09aa732d1fc5dac0508"sv}, Entry{"v1-000700-000800-headers.seg"sv, "5a5593aaddcf7c8b98b695d792fedf8bdf194211"sv}, Entry{"v1-000700-000800-transactions-to-block.idx"sv, "fd992d631c14b880a73995f6c069fdf6df1364a4"sv}, Entry{"v1-000700-000800-transactions.idx"sv, "f4f011225982c6f2c53a97a6bba7f30a791d7f26"sv}, Entry{"v1-000700-000800-transactions.seg"sv, "6e8d3c819d6acc8c561a8e67a629ce68c3d74719"sv}, Entry{"v1-000800-000900-bodies.idx"sv, "efe23aff0764860a1ba4cc0f433931012eaf1c86"sv}, Entry{"v1-000800-000900-bodies.seg"sv, "72c4f8e912565951f499806e6e4db509090fa0aa"sv}, Entry{"v1-000800-000900-headers.idx"sv, "d64ea9b1b1d3fe380b0ee1cc3a68e4e51e99b2c9"sv}, Entry{"v1-000800-000900-headers.seg"sv, "5e9d7279b56c719fffee07588f1a1f672ec65168"sv}, Entry{"v1-000800-000900-transactions-to-block.idx"sv, "1695628699ab084aceb000791d52d768f4e2575a"sv}, Entry{"v1-000800-000900-transactions.idx"sv, "d90fd36e94d0b923bd12b92442163885154ae68e"sv}, Entry{"v1-000800-000900-transactions.seg"sv, "90fedae8fd4ac79b1eefc1bf128189580d7d1d54"sv}, Entry{"v1-000900-001000-bodies.idx"sv, "2474c864619963112017b95a16d0c59ab7bdb0ae"sv}, Entry{"v1-000900-001000-bodies.seg"sv, "67ac596a62074ad5ed79e807e85c2f08cd22ef69"sv}, Entry{"v1-000900-001000-headers.idx"sv, "bd8b6b7f9fdddd180136e2c97dc271b52a996c54"sv}, Entry{"v1-000900-001000-headers.seg"sv, "2ad8b86cb6c534fe5a9bff49aedfba92ce3f26e8"sv}, Entry{"v1-000900-001000-transactions-to-block.idx"sv, "e6112b74dd3ded0fc41c84dea9f76ce710ac34c3"sv}, Entry{"v1-000900-001000-transactions.idx"sv, "025fe9d8d91f988e372008fc262c06e1daa13120"sv}, Entry{"v1-000900-001000-transactions.seg"sv, "97ecc39af0ec1ae3f659f3cb9fe9d7b2fc8167b6"sv}, Entry{"v1-000950-000960-blobsidecars.seg"sv, "3245acf6de1575d223de71686ba3b44400d9eb95"sv}, Entry{"v1-000950-000960-blocksidecars.idx"sv, "c88f08e1807712fb39ac8e543c9e15ffdcae437d"sv}, Entry{"v1-000960-000970-blobsidecars.seg"sv, "07a540fa91a7a16207cc74330262c9c011bf7b01"sv}, Entry{"v1-000960-000970-blocksidecars.idx"sv, "2e790a62f6ec4b60694cb73b711deb904000e320"sv}, Entry{"v1-000970-000980-blobsidecars.seg"sv, "07d4aaf2de70d7eefaadbe74a1bdbe917809be9b"sv}, Entry{"v1-000970-000980-blocksidecars.idx"sv, "b7b6e4923ee164c136687d2816f01314527827b3"sv}, Entry{"v1-000980-000990-blobsidecars.seg"sv, "8d6c14703ea0bff30691bf14fbd1c475b4614cf1"sv}, Entry{"v1-000980-000990-blocksidecars.idx"sv, "ab34d7ee7b93ffab2f4f006c1f1294f307610774"sv}, Entry{"v1-000990-001000-blobsidecars.seg"sv, "ae5a9c150ae7d5a1f06730576cd221deac030437"sv}, Entry{"v1-000990-001000-blocksidecars.idx"sv, "9305765a823ec9888b311c04b24070f644fbd210"sv}, Entry{"v1-001000-001010-blobsidecars.seg"sv, "bff304a50230f3ae2527bf1d3e1b26c477149067"sv}, Entry{"v1-001000-001010-blocksidecars.idx"sv, "4148f86d2f3034ed607d46b28aa4b300b6429c13"sv}, Entry{"v1-001000-001100-bodies.idx"sv, "d484e5f8b4d43ca93a77931d59fa6edf5723342f"sv}, Entry{"v1-001000-001100-bodies.seg"sv, "5e90a7367e039cf78083a1995829c3c420268c14"sv}, Entry{"v1-001000-001100-headers.idx"sv, "e026a2cb6326d32a0a2a4dc718e5ecb06ada0e45"sv}, Entry{"v1-001000-001100-headers.seg"sv, "d54c32c3356bcb9d2ef837da267678a51437637e"sv}, Entry{"v1-001000-001100-transactions-to-block.idx"sv, "f253187f304bc5a4cb697775918ab4c5ddaebd8c"sv}, Entry{"v1-001000-001100-transactions.idx"sv, "522c214d230f17f858a1ac3a9eb11642bcfb49d8"sv}, Entry{"v1-001000-001100-transactions.seg"sv, "a3c0ab1e28b87ad763051366422281b283fbead1"sv}, Entry{"v1-001010-001020-blobsidecars.seg"sv, "0a220011969d7455493fa8c735e528857f8772cc"sv}, Entry{"v1-001010-001020-blocksidecars.idx"sv, "35820d6334d77c1c84240124e7f8c3b84e50d042"sv}, Entry{"v1-001020-001030-blobsidecars.seg"sv, "3928f4de0a14497d1ca51c1d3b9c0a712172e7c6"sv}, Entry{"v1-001020-001030-blocksidecars.idx"sv, "54686c432d8f9690befa9852f5fac253460b0985"sv}, Entry{"v1-001030-001040-blobsidecars.seg"sv, "df53b528d89a3da3d910c043d6ad0a52ed2240eb"sv}, Entry{"v1-001030-001040-blocksidecars.idx"sv, "daf127fdd5d3714571083e2abd57ee1a39b11989"sv}, Entry{"v1-001040-001050-blobsidecars.seg"sv, "fef46dc087263da54485716147ca32154698e209"sv}, Entry{"v1-001040-001050-blocksidecars.idx"sv, "adf0e14dacd5a0e10b26f4d15d3ea939933f31ed"sv}, Entry{"v1-001050-001060-blobsidecars.seg"sv, "06cc467b812027e9e481e4c27f3b87f192374c0d"sv}, Entry{"v1-001050-001060-blocksidecars.idx"sv, "54be1b1fbc1d995e7592950e0e2ae86cdd45d928"sv}, Entry{"v1-001060-001070-blobsidecars.seg"sv, "03f08de66d3503ecaaeb735bcd387da3d2c314db"sv}, Entry{"v1-001060-001070-blocksidecars.idx"sv, "56709cb1d19ee49b29e1631d0999c115b145f953"sv}, Entry{"v1-001070-001080-blobsidecars.seg"sv, "9b8dbcf4a17375b45f4d2a98db04f5ae08c906b8"sv}, Entry{"v1-001070-001080-blocksidecars.idx"sv, "4526d4aaa3e0c4ef82e961fa9c790fdc6392b277"sv}, Entry{"v1-001080-001090-blobsidecars.seg"sv, "e574e25eb76635eae5c52e992402a2f5a5803a0c"sv}, Entry{"v1-001080-001090-blocksidecars.idx"sv, "a0ee4f7bf662126d69ee5db7415a1cca5056517d"sv}, Entry{"v1-001090-001100-blobsidecars.seg"sv, "7e9b465400875c872f3f09e1b6a1f0181e0dded7"sv}, Entry{"v1-001090-001100-blocksidecars.idx"sv, "1e66d7dee3ca8a506ba35631020a36fd26418d1c"sv}, Entry{"v1-001100-001110-blobsidecars.seg"sv, "bd7f27b036b453ba05dbcff1d99ea6403f6fba59"sv}, Entry{"v1-001100-001110-blocksidecars.idx"sv, "4a8f8de57e8fabe7e389542edadc471dd191e4b0"sv}, Entry{"v1-001100-001200-bodies.idx"sv, "1b80bd9697e5eda094a4b538cbf913a09cf54e2a"sv}, Entry{"v1-001100-001200-bodies.seg"sv, "0507b34158db060c0fc5b3d305cc83a0efe486fd"sv}, Entry{"v1-001100-001200-headers.idx"sv, "49755c8458dd93ffd6c21c155f91de4a1d1ada40"sv}, Entry{"v1-001100-001200-headers.seg"sv, "5a604d60153de12ba2a59aefdcb232a78ce1d0ca"sv}, Entry{"v1-001100-001200-transactions-to-block.idx"sv, "cb5c4bbb7e3d208922029a52ae07363ec7437738"sv}, Entry{"v1-001100-001200-transactions.idx"sv, "613d390962ae07493e86deb3d3d46aee527ae0fc"sv}, Entry{"v1-001100-001200-transactions.seg"sv, "733e456da820bcd7cf0549eb77204f63fd1fe5ad"sv}, Entry{"v1-001110-001120-blobsidecars.seg"sv, "1ec2c31f6a1df3bd1e53d7fbad1a79d168b6692c"sv}, Entry{"v1-001110-001120-blocksidecars.idx"sv, "e5dee863034c467323df75882876cf5332ae8b59"sv}, Entry{"v1-001120-001130-blobsidecars.seg"sv, "898afc5259735635bbdd7430d29ee978d5493933"sv}, Entry{"v1-001120-001130-blocksidecars.idx"sv, "9bf30e4d366900a16ccc9a95f5d0c1f31b882ed6"sv}, Entry{"v1-001130-001140-blobsidecars.seg"sv, "cc188588da835622dd2537376079ddfbfba8d16e"sv}, Entry{"v1-001130-001140-blocksidecars.idx"sv, "89d86ae1bf4e70f67dbed3f9c0df32c675de3ccb"sv}, Entry{"v1-001140-001150-blobsidecars.seg"sv, "158f28b0636442ff00e6950d104f8b31d4cb35a6"sv}, Entry{"v1-001140-001150-blocksidecars.idx"sv, "949eac6d27ff4c751bd30198e41874ad5b030984"sv}, Entry{"v1-001150-001160-blobsidecars.seg"sv, "0c652b5c50429cfa59a1afa240eaee646bdc13c6"sv}, Entry{"v1-001150-001160-blocksidecars.idx"sv, "4ecc47bf2de361024da106c288bbd390a59e7318"sv}, Entry{"v1-001160-001170-blobsidecars.seg"sv, "2e3e453e874676873ac7795e0e5d1caea286bcf1"sv}, Entry{"v1-001160-001170-blocksidecars.idx"sv, "af061498f9a7a7fb98f7b509afe38e990d1f322c"sv}, Entry{"v1-001170-001180-blobsidecars.seg"sv, "6671835ca7e6acea83a06355b4b2472ea3b8572b"sv}, Entry{"v1-001170-001180-blocksidecars.idx"sv, "ba72dce9d8e98c071ebd0847cb5ef38cb538f83c"sv}, Entry{"v1-001180-001190-blobsidecars.seg"sv, "39f12ef10bbc104f5ea6ebb287e295b0860d2424"sv}, Entry{"v1-001180-001190-blocksidecars.idx"sv, "1d318e1b0fc24076e683c1ab379f3c41316797a4"sv}, Entry{"v1-001190-001200-blobsidecars.seg"sv, "c9c00aed38c15a81e32369c7c1781c7970691d9c"sv}, Entry{"v1-001190-001200-blocksidecars.idx"sv, "0d92f262b79446624fac9073d6adb9a0d96da763"sv}, Entry{"v1-001200-001210-blobsidecars.seg"sv, "4401428054b5b846f9af592760ee3f4fd6273064"sv}, Entry{"v1-001200-001210-blocksidecars.idx"sv, "41647b72b8038983290d3dc8d06651950d49dac2"sv}, Entry{"v1-001200-001300-bodies.idx"sv, "beb953f5f6818275d58bffc66ba52557069aa775"sv}, Entry{"v1-001200-001300-bodies.seg"sv, "35099ff69ff5844d182cec6aa382480f38e6313f"sv}, Entry{"v1-001200-001300-headers.idx"sv, "499008f76d3a974da06279ff698509c5a2f792bc"sv}, Entry{"v1-001200-001300-headers.seg"sv, "d6bb9f376cf17ff4f49812b3f00ef6bd02a0feb8"sv}, Entry{"v1-001200-001300-transactions-to-block.idx"sv, "cde14ab5bcb9bd0610a0d8d36f0b44e5940eeea3"sv}, Entry{"v1-001200-001300-transactions.idx"sv, "7b5728ed87399ea210c9aefb759a5e485f031daa"sv}, Entry{"v1-001200-001300-transactions.seg"sv, "dc018f1493254b0376292dd7cdc23c23ae8123f7"sv}, Entry{"v1-001210-001220-blobsidecars.seg"sv, "6e175b70e203c924fd87803948e4306f2a6ff0f6"sv}, Entry{"v1-001210-001220-blocksidecars.idx"sv, "bddb107daf1d188234f428844c6084eaf4bbd14c"sv}, Entry{"v1-001220-001230-blobsidecars.seg"sv, "c12ff1508637e6d6716113daf0a3f255cc562e18"sv}, Entry{"v1-001220-001230-blocksidecars.idx"sv, "8453e12bee7bad1d7f1da87102c18a845040d520"sv}, Entry{"v1-001230-001240-blobsidecars.seg"sv, "59985d91e7f4a38f66866a6296ac03feca40b476"sv}, Entry{"v1-001230-001240-blocksidecars.idx"sv, "6f1edcdd7dd751ca6d763d1289fc404d8c58c554"sv}, Entry{"v1-001240-001250-blobsidecars.seg"sv, "ffedae1df522f2b7f8023b990bae9803d36e89a3"sv}, Entry{"v1-001240-001250-blocksidecars.idx"sv, "714fd4f75a8e5db05e842976f2813bb2a45c1c8b"sv}, Entry{"v1-001250-001260-blobsidecars.seg"sv, "0aa3aa55b4be190e6f4ce51c88c9d5f7edd24c62"sv}, Entry{"v1-001250-001260-blocksidecars.idx"sv, "c41621e2b79dc88686a25265d1479e0714f94622"sv}, Entry{"v1-001260-001270-blobsidecars.seg"sv, "31c709a5cc0ee725fa484c85ac0df39f3222cc07"sv}, Entry{"v1-001260-001270-blocksidecars.idx"sv, "ed64132ded52d45bba6d4cdfd6480d5316fa00b8"sv}, Entry{"v1-001270-001280-blobsidecars.seg"sv, "33d10a0fc7149e8591b38fc2c8a295995b669fdd"sv}, Entry{"v1-001270-001280-blocksidecars.idx"sv, "659b8769b562ec77afda647abd30a26f6d13f1a9"sv}, Entry{"v1-001280-001290-blobsidecars.seg"sv, "1b998d433064b6cec9359b52aa1ab901f4a09b9f"sv}, Entry{"v1-001280-001290-blocksidecars.idx"sv, "efb80b8b3072c3f64a0f4fa63bc4f3c67cb693c2"sv}, Entry{"v1-001290-001300-blobsidecars.seg"sv, "21a7b06ac44296691963380de942b498e0c9ceb8"sv}, Entry{"v1-001290-001300-blocksidecars.idx"sv, "9f122218c13a81edd34605a95b02b65868e8c8d7"sv}, Entry{"v1-001300-001310-blobsidecars.seg"sv, "20ade2c21d6e7b222f4f049e17023e28c5ee9920"sv}, Entry{"v1-001300-001310-blocksidecars.idx"sv, "d9845ec804276a60ed833508adb66f78754f90f9"sv}, Entry{"v1-001300-001400-bodies.idx"sv, "67bcd6280c407872052f3ff167ab412e9b5413ad"sv}, Entry{"v1-001300-001400-bodies.seg"sv, "3e4e2dd1b7e3e336d69b716e0d11e292623d2f0e"sv}, Entry{"v1-001300-001400-headers.idx"sv, "7b8c5ee9fb02a9392f0ac6cd4f71f336b629f12d"sv}, Entry{"v1-001300-001400-headers.seg"sv, "85365cdb838c151c2d796b2d1ec048637b170eb1"sv}, Entry{"v1-001300-001400-transactions-to-block.idx"sv, "9a6db0e64345f30aa960567368c6fd44f69e786d"sv}, Entry{"v1-001300-001400-transactions.idx"sv, "767cd11a4aad3214634a9015431462ac4c82523b"sv}, Entry{"v1-001300-001400-transactions.seg"sv, "f5a81bfb552501975047859ffc47992be6ae0089"sv}, Entry{"v1-001310-001320-blobsidecars.seg"sv, "1899da9f4051d7482b51f1bedf8a1b58467c99dd"sv}, Entry{"v1-001310-001320-blocksidecars.idx"sv, "6ef5ccd2d7eaac9d48dcbedde786913de60e6358"sv}, Entry{"v1-001320-001330-blobsidecars.seg"sv, "9ecd1df2e8b860237ce77d28001d013d2a2e8d5d"sv}, Entry{"v1-001320-001330-blocksidecars.idx"sv, "a2c33e5b69cb468849cc61afd43f8a2fe5619ee4"sv}, Entry{"v1-001330-001340-blobsidecars.seg"sv, "1634d0a747e2854ee237f03968dd5d1d72d3c9b4"sv}, Entry{"v1-001330-001340-blocksidecars.idx"sv, "16dc5412d5f7727131f2f011e13daae3b6517464"sv}, Entry{"v1-001340-001350-blobsidecars.seg"sv, "e2e957962a1794a2c321e437bbee81b99e3f70d6"sv}, Entry{"v1-001340-001350-blocksidecars.idx"sv, "47049f850bd43508f23b89ed20ed406c8a2090c3"sv}, Entry{"v1-001350-001360-blobsidecars.seg"sv, "77fbf361cf615f1c3975fa60876d36b376893b1f"sv}, Entry{"v1-001350-001360-blocksidecars.idx"sv, "64cc4db56a0f2acc4908641418f958cdbdd93ec9"sv}, Entry{"v1-001360-001370-blobsidecars.seg"sv, "182bc4e93b96628cb8acef8f9a581191a662e9ab"sv}, Entry{"v1-001360-001370-blocksidecars.idx"sv, "a6239e96ccde1e7c4c0559a8b42b583ad1aed39d"sv}, Entry{"v1-001370-001380-blobsidecars.seg"sv, "efc0ccb98dccade3ec3a215aaad4009810ca6455"sv}, Entry{"v1-001370-001380-blocksidecars.idx"sv, "9ef98fd1bf85d835857611c6cf0619a76fdd103f"sv}, Entry{"v1-001380-001390-blobsidecars.seg"sv, "faf8dea5b0c4259383dfb5f7df58c5c776b32f40"sv}, Entry{"v1-001380-001390-blocksidecars.idx"sv, "1b4efa692083017ad046e3559e6b7233551d402e"sv}, Entry{"v1-001390-001400-blobsidecars.seg"sv, "8fd98a6e55eefb46f3bb329be97604224adc6908"sv}, Entry{"v1-001390-001400-blocksidecars.idx"sv, "b34308a184a0ad3e43869ee80035ddad0a61b63a"sv}, Entry{"v1-001400-001410-blobsidecars.seg"sv, "a057046f8bb0a7ffc574f185a65da6d41f9cc24b"sv}, Entry{"v1-001400-001410-blocksidecars.idx"sv, "65d03e37f171b79a568bfed97215e32951231981"sv}, Entry{"v1-001400-001500-bodies.idx"sv, "00e795b2ed7b1a178860b28fcf6e0811fb78f18e"sv}, Entry{"v1-001400-001500-bodies.seg"sv, "c9745722091016f28806c69343b2dfaa936a4e44"sv}, Entry{"v1-001400-001500-headers.idx"sv, "cba0d434cd0b2dc286e81e33ab33a0592890cfe8"sv}, Entry{"v1-001400-001500-headers.seg"sv, "be6f194916251bdd93b06992374f2595cf287cd2"sv}, Entry{"v1-001400-001500-transactions-to-block.idx"sv, "3c15492c868196b8b9811f083636f0ebcd93bd45"sv}, Entry{"v1-001400-001500-transactions.idx"sv, "7559fad3c74ac634a0dfec8190759560e66b53ec"sv}, Entry{"v1-001400-001500-transactions.seg"sv, "26487c4fca2eb8626cff875c00c24c64f7760c26"sv}, Entry{"v1-001410-001420-blobsidecars.seg"sv, "98aa777767b47a6bc104628db2934301312c5c55"sv}, Entry{"v1-001410-001420-blocksidecars.idx"sv, "8acf515f27e79ac98b8bea25c800e70523ac0e2d"sv}, Entry{"v1-001420-001430-blobsidecars.seg"sv, "c64547caeeb2e58180d4576af6335f09c010681b"sv}, Entry{"v1-001420-001430-blocksidecars.idx"sv, "d0ae1e0d1a42fb9c65eff9c550f4ce5f94a5d1cc"sv}, Entry{"v1-001430-001440-blobsidecars.seg"sv, "e2e3b40981aea29642deb894e5cf36291d6398af"sv}, Entry{"v1-001430-001440-blocksidecars.idx"sv, "299feef716c5415cc8862605a42dd4b165e6d878"sv}, Entry{"v1-001440-001450-blobsidecars.seg"sv, "5d7e801a2b82914b1bea84b53ba35f1fd0cb4f23"sv}, Entry{"v1-001440-001450-blocksidecars.idx"sv, "3c4668e62d15eb4493097199bfec1a4fb27f53bc"sv}, Entry{"v1-001450-001460-blobsidecars.seg"sv, "566b3b85268c15223c257722ac98c7d38bd8b8f5"sv}, Entry{"v1-001450-001460-blocksidecars.idx"sv, "c2d9160e19db064393ac8441e607ad6dc30f82b8"sv}, Entry{"v1-001460-001470-blobsidecars.seg"sv, "fcd6d556d05baaac91a0fa1cb55e635911fa2a43"sv}, Entry{"v1-001460-001470-blocksidecars.idx"sv, "2a692ac8e040dda7e085bd82d39df43b74cf2eac"sv}, Entry{"v1-001470-001480-blobsidecars.seg"sv, "6eb122b33484583a98af8236cb3a798b0918f588"sv}, Entry{"v1-001470-001480-blocksidecars.idx"sv, "c7ea92ef4b33526563d73b4b9ce0e7ce684ae037"sv}, Entry{"v1-001480-001490-blobsidecars.seg"sv, "04fd3b2e5e1215c26b0c37088690d9c1966aaf42"sv}, Entry{"v1-001480-001490-blocksidecars.idx"sv, "c2ace1b5d18cd2392bf71aa614a534473fa2d8ce"sv}, Entry{"v1-001490-001500-blobsidecars.seg"sv, "61121a4b8d6dfb989012ea95d71ef5115803b90b"sv}, Entry{"v1-001490-001500-blocksidecars.idx"sv, "675aad14f78765f236c423893c0f58d91955a8b6"sv}, Entry{"v1-001500-001510-blobsidecars.seg"sv, "f3366ba67f9756e877b01274bb0d756c1d19289d"sv}, Entry{"v1-001500-001510-blocksidecars.idx"sv, "529100b5a4681d34e24c5e59865abac46286426d"sv}, Entry{"v1-001500-001600-bodies.idx"sv, "c37f5320391a39f6d6abe4ab35a43ffa313caa28"sv}, Entry{"v1-001500-001600-bodies.seg"sv, "4628113073bf631798db28f30a0b88f3b11ed88f"sv}, Entry{"v1-001500-001600-headers.idx"sv, "b5e65f3d597b834d2cfe1e1481388c9a7346e40f"sv}, Entry{"v1-001500-001600-headers.seg"sv, "317c7e2fd58acac11ad461652a76cbd32744c8e5"sv}, Entry{"v1-001500-001600-transactions-to-block.idx"sv, "002bd18956948c57e728bb3f005e80d33cbc04a6"sv}, Entry{"v1-001500-001600-transactions.idx"sv, "2216508b58f8f271f9a6255525954e03b8ba9067"sv}, Entry{"v1-001500-001600-transactions.seg"sv, "8bba6b32f480c6565eefcece81121fc63499dd5b"sv}, Entry{"v1-001510-001520-blobsidecars.seg"sv, "70a72d30a7d4cf253358040c54de53248d06280d"sv}, Entry{"v1-001510-001520-blocksidecars.idx"sv, "31a4258429cbc8186afefbaf7f5b6c57dec4421d"sv}, Entry{"v1-001520-001530-blobsidecars.seg"sv, "803b972cdf8d13a7143ca6f5610b218cddc8f1fb"sv}, Entry{"v1-001520-001530-blocksidecars.idx"sv, "63a938a6031778263ebc0bca34291b403e6c315b"sv}, Entry{"v1-001530-001540-blobsidecars.seg"sv, "48106016825142eacc8512a13a22e144eb9b50c7"sv}, Entry{"v1-001530-001540-blocksidecars.idx"sv, "e9f8c6cc2e70b4757d39a69351886e071753336d"sv}, Entry{"v1-001540-001550-blobsidecars.seg"sv, "081196b276c7d9e8f7ae0a9445e546d4e4bc27ae"sv}, Entry{"v1-001540-001550-blocksidecars.idx"sv, "6466e7a46031ed8b3e65c26d19fc30fe47b7aae0"sv}, Entry{"v1-001550-001560-blobsidecars.seg"sv, "4acfe7bcd4e34a3a2060dca06444f9567a2219f2"sv}, Entry{"v1-001550-001560-blocksidecars.idx"sv, "842b9558437c031daced7b9dfd36eb5ec825db24"sv}, Entry{"v1-001560-001570-blobsidecars.seg"sv, "854a122722d15b9ed6331bd8f49e778e75bf0da7"sv}, Entry{"v1-001560-001570-blocksidecars.idx"sv, "09288f775c73ffc7234e019b3f9c000090f74b96"sv}, Entry{"v1-001570-001580-blobsidecars.seg"sv, "5aa37325fb1eddd1915bd13fc755ac1e09844594"sv}, Entry{"v1-001570-001580-blocksidecars.idx"sv, "f0c27f63406b7cc7eda5428264c69e7bee6a3527"sv}, Entry{"v1-001580-001590-blobsidecars.seg"sv, "751bae1b80755495997dc346115a567d4a297171"sv}, Entry{"v1-001580-001590-blocksidecars.idx"sv, "987f6469691b5aec99e27bbaecea88e1b3956f91"sv}, Entry{"v1-001590-001600-blobsidecars.seg"sv, "b8d2b662aba32362c1482c1ee7345170bee1056c"sv}, Entry{"v1-001590-001600-blocksidecars.idx"sv, "015de4b10c498ffb91ecfb5a1138945382d3358a"sv}, Entry{"v1-001600-001610-blobsidecars.seg"sv, "65e811744df0859e5ad26124a51f89a73e52f64f"sv}, Entry{"v1-001600-001610-blocksidecars.idx"sv, "b8c3df47ca4e5dbd24b2c37352404c5a7b3dd8cd"sv}, Entry{"v1-001600-001700-bodies.idx"sv, "a9203fd627e0adaec89f0f4b47f0dd7291940831"sv}, Entry{"v1-001600-001700-bodies.seg"sv, "03ec457b8dabe3b55cba1b52d15f91c248f26040"sv}, Entry{"v1-001600-001700-headers.idx"sv, "cc8396cd38ae6528fad28f70b39e9b8651a359f3"sv}, Entry{"v1-001600-001700-headers.seg"sv, "4a7cd44e7a5aa08c67c42ef6c23e177e22c684d4"sv}, Entry{"v1-001600-001700-transactions-to-block.idx"sv, "7790b80e5a6b3727b024f39a2cccabc127cb68b8"sv}, Entry{"v1-001600-001700-transactions.idx"sv, "95783f2d0a424c2e2ff2b7dc2879205ef8b82b3f"sv}, Entry{"v1-001600-001700-transactions.seg"sv, "d5d935c112f29f3f3219a0b66f78e81c49d41796"sv}, Entry{"v1-001610-001620-blobsidecars.seg"sv, "ac22ea2ab04faf520ee9c4de02a52eb7fd9bcaae"sv}, Entry{"v1-001610-001620-blocksidecars.idx"sv, "402857fbfe7ac9bd5758969ab12234d9269f1844"sv}, Entry{"v1-001620-001630-blobsidecars.seg"sv, "12f5bf9da79587fa33979f7ba3e198a3177544d7"sv}, Entry{"v1-001620-001630-blocksidecars.idx"sv, "0feaf4534be894cb1467a7afe965866a3f4d8225"sv}, Entry{"v1-001630-001640-blobsidecars.seg"sv, "bf5ab1e9d3d662b2bb8cb89e8f278a4fd974cca4"sv}, Entry{"v1-001630-001640-blocksidecars.idx"sv, "000f4010810013fe5868f306e52fca548c40de8b"sv}, Entry{"v1-001640-001650-blobsidecars.seg"sv, "2fd6b78c81c0b0c360a753d2039ae4fe88d520e2"sv}, Entry{"v1-001640-001650-blocksidecars.idx"sv, "f051a61539c1539f91df3cefa2ed48d210eb93fe"sv}, Entry{"v1-001650-001660-blobsidecars.seg"sv, "f508a5c450910d65b5593e7b1cafb97092d50af9"sv}, Entry{"v1-001650-001660-blocksidecars.idx"sv, "c075abb6785032f23b30e6080c75d195248242e4"sv}, Entry{"v1-001660-001670-blobsidecars.seg"sv, "4abdc600caa380beaf62e0096a35e0b5162e6a7c"sv}, Entry{"v1-001660-001670-blocksidecars.idx"sv, "78543c0721cce32a1648e4aeb4dff8cb7f078003"sv}, Entry{"v1-001670-001680-blobsidecars.seg"sv, "e328fc047bafe4ddfa2e1030aee1023518a98b72"sv}, Entry{"v1-001670-001680-blocksidecars.idx"sv, "f9ce3aca1ce19340fcbed6ec9150b02075978d0b"sv}, Entry{"v1-001680-001690-blobsidecars.seg"sv, "2a1170a41c8490fe8373a8c4ecdbcbe2760f6fab"sv}, Entry{"v1-001680-001690-blocksidecars.idx"sv, "2587d51de3f801f37678f4acc618d528c9d6d13d"sv}, Entry{"v1-001690-001700-blobsidecars.seg"sv, "f73258e54a1f20c57239ab96ce1ab2450b73127f"sv}, Entry{"v1-001690-001700-blocksidecars.idx"sv, "63b5f8695efbb68a7df183ac5a1cc7a7c3228fcd"sv}, Entry{"v1-001700-001710-blobsidecars.seg"sv, "22429d41323038ce5016e3311fd1088bb4d79657"sv}, Entry{"v1-001700-001710-blocksidecars.idx"sv, "90b652a70405ebe1f65687273a46fb6e4ffece27"sv}, Entry{"v1-001700-001800-bodies.idx"sv, "5f7e3fc20cca4fc4f529b3172baed0bbb8997c9d"sv}, Entry{"v1-001700-001800-bodies.seg"sv, "a60706480aebeb074067c364d537ef4c3f12b8c8"sv}, Entry{"v1-001700-001800-headers.idx"sv, "64ed787317371b8435db8cc7e130daf44bdfa6d2"sv}, Entry{"v1-001700-001800-headers.seg"sv, "f684e5f652cad679e98cca9dc5becdce3ace9827"sv}, Entry{"v1-001700-001800-transactions-to-block.idx"sv, "9299c9f5a71840f1878c06851b572abcf0746b1b"sv}, Entry{"v1-001700-001800-transactions.idx"sv, "524e573ee482e578218e2e42f70356e637a96707"sv}, Entry{"v1-001700-001800-transactions.seg"sv, "00c0b965c4c572b8175e40bc0435d2226adc329f"sv}, Entry{"v1-001710-001720-blobsidecars.seg"sv, "407120866f674a61d519db35bc594da9d9bf2c13"sv}, Entry{"v1-001710-001720-blocksidecars.idx"sv, "1cd7e9114bd5304f2abb30a106577ee5950c30ed"sv}, Entry{"v1-001720-001730-blobsidecars.seg"sv, "557b8c72ef855853be889992c1ce78292b967234"sv}, Entry{"v1-001720-001730-blocksidecars.idx"sv, "2fe3615f053fe121864ecb045495d1636c3fdc64"sv}, Entry{"v1-001730-001740-blobsidecars.seg"sv, "a47c9203eadec742307ba1c802c9e37ff81ea1e3"sv}, Entry{"v1-001730-001740-blocksidecars.idx"sv, "8307ab45dfc4b8ec881d246309dcbd82da280086"sv}, Entry{"v1-001740-001750-blobsidecars.seg"sv, "d0b7b0dc966742bee9139b72eb97701cf291e83c"sv}, Entry{"v1-001740-001750-blocksidecars.idx"sv, "342d8acb3d607953f735017e6f19f0af46e66823"sv}, Entry{"v1-001750-001760-blobsidecars.seg"sv, "77a01604a79bd75ca7223cc82a7a5e297eb04d36"sv}, Entry{"v1-001750-001760-blocksidecars.idx"sv, "a6e5db54e4d07ee4ce6d70523373355c6c27e687"sv}, Entry{"v1-001760-001770-blobsidecars.seg"sv, "27e8d751a3899be11cfb6febeda00bc8b44805ca"sv}, Entry{"v1-001760-001770-blocksidecars.idx"sv, "2f3b643e2c475abad3dcc31921f4ce7f51eb82eb"sv}, Entry{"v1-001770-001780-blobsidecars.seg"sv, "0aba172b0d9d8e55372ad6bae0a3c108f164ee7e"sv}, Entry{"v1-001770-001780-blocksidecars.idx"sv, "a5cbefb346432f047cedc72fb0610d050dc318e1"sv}, Entry{"v1-001780-001790-blobsidecars.seg"sv, "6e4b99b00aa70bf87ab78b4b36a3af1f493e31bc"sv}, Entry{"v1-001780-001790-blocksidecars.idx"sv, "25ccab354aa4dfcdd92fdc9d70bbe52d1836ae8c"sv}, Entry{"v1-001790-001800-blobsidecars.seg"sv, "07dfdb0aa00fd67c30ce7096a6811b682d45fa8d"sv}, Entry{"v1-001790-001800-blocksidecars.idx"sv, "22598a3afaa0e38e4bdb8a6e79a46236b96c947f"sv}, Entry{"v1-001800-001810-blobsidecars.seg"sv, "d568ceb44b4969dce2d48d5b92ab4f1f8e41f944"sv}, Entry{"v1-001800-001810-blocksidecars.idx"sv, "24749414093b65d3bfeaf3a3c0e7ba087fb603d0"sv}, Entry{"v1-001800-001900-bodies.idx"sv, "52ffe04e152c6ffdbc7f45f2eafd508d6244f034"sv}, Entry{"v1-001800-001900-bodies.seg"sv, "248aa2abb567edcd88efe57427be32142da10b81"sv}, Entry{"v1-001800-001900-headers.idx"sv, "e237a4505db28200235461bbc12b6498f2b75c55"sv}, Entry{"v1-001800-001900-headers.seg"sv, "5d746f42c6a8603b0b830d67b4da569ccfa5db4f"sv}, Entry{"v1-001800-001900-transactions-to-block.idx"sv, "0865307e512b15d93a8364bf61513c6e1168c1c3"sv}, Entry{"v1-001800-001900-transactions.idx"sv, "3d1bf9c627abc704742752dccda422be8282ef0b"sv}, Entry{"v1-001800-001900-transactions.seg"sv, "f957645610b6a0b8848a292f26c6862224638f01"sv}, Entry{"v1-001810-001820-blobsidecars.seg"sv, "5c7ee12991ee47280dc859d9dcb854909ce87a6e"sv}, Entry{"v1-001810-001820-blocksidecars.idx"sv, "e52014d32736f76b0b2b25bd8993b2f2651faff0"sv}, Entry{"v1-001820-001830-blobsidecars.seg"sv, "f376ebc2c93af1e16501ce6c01e882020646d0fb"sv}, Entry{"v1-001820-001830-blocksidecars.idx"sv, "8b8572c8e6a7822d1f365a9ca6cea0fd0cc915f4"sv}, Entry{"v1-001830-001840-blobsidecars.seg"sv, "0553b6880ae898ce57388c1f1971760cd36cfbd1"sv}, Entry{"v1-001830-001840-blocksidecars.idx"sv, "41462e6542ae4630cdad290c3983a027d92fa8d5"sv}, Entry{"v1-001840-001850-blobsidecars.seg"sv, "87ce6ced26660c83970ff87bc2bfce457314f1e7"sv}, Entry{"v1-001840-001850-blocksidecars.idx"sv, "60fcc5e559d02ab09200a6e6a13aa7d637b7b7de"sv}, Entry{"v1-001850-001860-blobsidecars.seg"sv, "85ebd95b1e3e048163d6efc6fe92cad33db1d5c7"sv}, Entry{"v1-001850-001860-blocksidecars.idx"sv, "22ef90247dde6469a831893e162819ef62dab32b"sv}, Entry{"v1-001860-001870-blobsidecars.seg"sv, "4507d4a3e84e7433af538095988788345471d334"sv}, Entry{"v1-001860-001870-blocksidecars.idx"sv, "350a50dac241419a7432166d3858d54cc9cb8af5"sv}, Entry{"v1-001870-001880-blobsidecars.seg"sv, "b15ae59f13794adf627211b4bdba44dd51fd519f"sv}, Entry{"v1-001870-001880-blocksidecars.idx"sv, "42c3a52ac717658c4cb97b9674b9bcc205e25b59"sv}, Entry{"v1-001880-001890-blobsidecars.seg"sv, "3c5cb389234e1e352bf02004b0a58793e688a111"sv}, Entry{"v1-001880-001890-blocksidecars.idx"sv, "9c6b9e78b327274eeaa403a05a51edc27378bea1"sv}, Entry{"v1-001890-001900-blobsidecars.seg"sv, "8c3a48eb8fce67dba5b8d9c6baacf5a9ccd1c649"sv}, Entry{"v1-001890-001900-blocksidecars.idx"sv, "99a689f104b4595072dbecf2661f8f18f00cd489"sv}, Entry{"v1-001900-001910-blobsidecars.seg"sv, "0db6e4301483fedc4cbe3d4451eb604c7802396b"sv}, Entry{"v1-001900-001910-blocksidecars.idx"sv, "f974a17ef0b1b1533abc807b9a560c3bd8ac0796"sv}, Entry{"v1-001900-002000-bodies.idx"sv, "93ec4ba41ff56a3ca750609e0043e5e731ae1eb6"sv}, Entry{"v1-001900-002000-bodies.seg"sv, "74115971a97963f322b9d08251d86c27080ab021"sv}, Entry{"v1-001900-002000-headers.idx"sv, "eb9c38a6e4e94cfdef22b0b20ac08ad15edae154"sv}, Entry{"v1-001900-002000-headers.seg"sv, "d209c9f4194efb564164d30610e9506c0b75d8ca"sv}, Entry{"v1-001900-002000-transactions-to-block.idx"sv, "96497400be1ab6254269c1480f9b99c14de2a424"sv}, Entry{"v1-001900-002000-transactions.idx"sv, "ca22939c98f92e3026e477b723d4cb17dcf16346"sv}, Entry{"v1-001900-002000-transactions.seg"sv, "4980897c027d56009b072892a35a8eafe34b6e76"sv}, Entry{"v1-001910-001920-blobsidecars.seg"sv, "d0141bfbc0401c6c65bd9c8c48d8c36e05cdfcdd"sv}, Entry{"v1-001910-001920-blocksidecars.idx"sv, "e74b16ad9979bd083eb2f7397d923188a61ef6e4"sv}, Entry{"v1-001920-001930-blobsidecars.seg"sv, "f951c9238832bf9283e042b2c4cb91b22bda8056"sv}, Entry{"v1-001920-001930-blocksidecars.idx"sv, "ae36364e6a82e43116ecd20123fea27e5155fd3e"sv}, Entry{"v1-001930-001940-blobsidecars.seg"sv, "c2f59d7d9667a2b2b069fce937f645af6d6ce7a7"sv}, Entry{"v1-001930-001940-blocksidecars.idx"sv, "d3cf1470590696e6bc8fbb8a86934446512a04e5"sv}, Entry{"v1-001940-001950-blobsidecars.seg"sv, "28632e4ea84e7113f7673171e88f45ce6e8fb55b"sv}, Entry{"v1-001940-001950-blocksidecars.idx"sv, "96c2361b589adbbb9fe5682834948548a8021323"sv}, Entry{"v1-001950-001960-blobsidecars.seg"sv, "ed1e977473552d1c227856bcc9ac9c610386ad86"sv}, Entry{"v1-001950-001960-blocksidecars.idx"sv, "4e229d412a61b176086b33edd6d614869e13f06d"sv}, Entry{"v1-001960-001970-blobsidecars.seg"sv, "726394f5a9c3b53a8d38ebf49eca3f366adf0ce0"sv}, Entry{"v1-001960-001970-blocksidecars.idx"sv, "c00ae191725dbd75dbfa1c987eab84ef9a9566c6"sv}, Entry{"v1-001970-001980-blobsidecars.seg"sv, "137a114e532f0e5c1b3c0886a46c7ca267cd948c"sv}, Entry{"v1-001970-001980-blocksidecars.idx"sv, "5cc18a7873b4e4b3f0b94a093ce6fcdf75bac490"sv}, Entry{"v1-001980-001990-blobsidecars.seg"sv, "ba4cd1713ed8555cd37dab2a153ff22b57565ce9"sv}, Entry{"v1-001980-001990-blocksidecars.idx"sv, "49d7f037d4a51a89e6ad745d58955dfb1b6e9f73"sv}, Entry{"v1-001990-002000-blobsidecars.seg"sv, "9135274139ce6075eeac2e82491569bcd328851f"sv}, Entry{"v1-001990-002000-blocksidecars.idx"sv, "b97e68cb4dfa6f6f31895d780bf29a7cf25fef32"sv}, Entry{"v1-002000-002010-blobsidecars.seg"sv, "b2d4453a84bde583691dee97ad6eecdbbd7d2661"sv}, Entry{"v1-002000-002010-blocksidecars.idx"sv, "e6862c62b7c134860944b51fc419207ea83cbca8"sv}, Entry{"v1-002000-002100-bodies.idx"sv, "3be3d3b83b59b0219ff0d23b6811c252d0145783"sv}, Entry{"v1-002000-002100-bodies.seg"sv, "c915fe040e44ef9fc5bd59e8af19341100607b46"sv}, Entry{"v1-002000-002100-headers.idx"sv, "b24e5d482fa26e97224a277f545121709ae31c87"sv}, Entry{"v1-002000-002100-headers.seg"sv, "b8d2f9ee1355b74fb9711f70ff3ac0b92feaebdb"sv}, Entry{"v1-002000-002100-transactions-to-block.idx"sv, "491f80c3e7e68eb585d11944d14e670f37b3d09c"sv}, Entry{"v1-002000-002100-transactions.idx"sv, "f977d3faa1527adfc0b264f832f19d2f786ce88b"sv}, Entry{"v1-002000-002100-transactions.seg"sv, "f4e3acee1c0cd1d9836a11ae2e2bf1e4eeedc220"sv}, Entry{"v1-002010-002020-blobsidecars.seg"sv, "9236334db56c8c279c374a461a8863c001fe7584"sv}, Entry{"v1-002010-002020-blocksidecars.idx"sv, "222807c2725c2a629d67939e58a422bf98f4095d"sv}, Entry{"v1-002020-002030-blobsidecars.seg"sv, "c9aee6e8ef2d3e54002bd8688ee4c691e75b9d78"sv}, Entry{"v1-002020-002030-blocksidecars.idx"sv, "5d7ec2aebd9ef5e90cba024ef1271d8ddc2d0730"sv}, Entry{"v1-002030-002040-blobsidecars.seg"sv, "94cc08ca2d2d46814174cf5ade4092e21264ed0e"sv}, Entry{"v1-002030-002040-blocksidecars.idx"sv, "654075f996632e8aaa2dea7e1ecf6e389b184324"sv}, Entry{"v1-002040-002050-blobsidecars.seg"sv, "432bc86f89c413184fc7956a5722d56d3f76921f"sv}, Entry{"v1-002040-002050-blocksidecars.idx"sv, "95be00122506c03676b86d034671256eab785e52"sv}, Entry{"v1-002050-002060-blobsidecars.seg"sv, "fa099f704efc48c5ee983eca9c8f6293bfc2dfee"sv}, Entry{"v1-002050-002060-blocksidecars.idx"sv, "ba1d9ee32c9bdca1a11cd9df984b133ebcb630c3"sv}, Entry{"v1-002060-002070-blobsidecars.seg"sv, "170b1e8f983f9caee89527ad57e132d0d50c0dc2"sv}, Entry{"v1-002060-002070-blocksidecars.idx"sv, "80ff041373188bec5f8a839290631a0b7fdf4500"sv}, Entry{"v1-002070-002080-blobsidecars.seg"sv, "01beb4eaf4f3aaa9bac88833be1a5a14b7a8b752"sv}, Entry{"v1-002070-002080-blocksidecars.idx"sv, "240600cf2e4076cfef7af09fafde37a2f676ec8a"sv}, Entry{"v1-002080-002090-blobsidecars.seg"sv, "ac748e70cd6954c600404c9f4799621e64234355"sv}, Entry{"v1-002080-002090-blocksidecars.idx"sv, "f7ea161ec14e7106df8fd7b8d996bf1c4178bfca"sv}, Entry{"v1-002090-002100-blobsidecars.seg"sv, "acaaeda3796853cc2d238eaeae51eec081fb4747"sv}, Entry{"v1-002090-002100-blocksidecars.idx"sv, "dc54f1c0661b782eee1b84f9f7e19a09a1f21aea"sv}, Entry{"v1-002100-002110-blobsidecars.seg"sv, "09576cbd93c06bcaf3cf5dbb347be083d7109232"sv}, Entry{"v1-002100-002110-blocksidecars.idx"sv, "0405c22ca155529c201dea1f0b2e1f2f3199cafc"sv}, Entry{"v1-002100-002200-bodies.idx"sv, "90d8ae16d05aee3da7aa9c949cc02c0b63ad5eeb"sv}, Entry{"v1-002100-002200-bodies.seg"sv, "cc96d5b937daf3f770399315948c38816fc6efd6"sv}, Entry{"v1-002100-002200-headers.idx"sv, "f38dfd4ede41ccb5adc7a514c9dbeae69bcae5d0"sv}, Entry{"v1-002100-002200-headers.seg"sv, "0215e809aefda812a98f94e0fa96627196c28efb"sv}, Entry{"v1-002100-002200-transactions-to-block.idx"sv, "a80892ea568ecfb0a1dd8651ed1e06b69f2047f1"sv}, Entry{"v1-002100-002200-transactions.idx"sv, "15a5d42c9ad7886ec83172bae46f628ba6d51d5a"sv}, Entry{"v1-002100-002200-transactions.seg"sv, "67ca397b63625ba1685f1684644fc8ac0b6af4f2"sv}, Entry{"v1-002110-002120-blobsidecars.seg"sv, "cdaa0b5ee3584dd98ca14f1ad2d17c563729c754"sv}, Entry{"v1-002110-002120-blocksidecars.idx"sv, "657a0a68120c3852ab9f95dd78beb609c866e370"sv}, Entry{"v1-002120-002130-blobsidecars.seg"sv, "ee9b14bb602cd76825ac283b13fe64f4f7dd8642"sv}, Entry{"v1-002120-002130-blocksidecars.idx"sv, "feca894fd9fd1d306a88a4a7f90b5c83c3fb110e"sv}, Entry{"v1-002130-002140-blobsidecars.seg"sv, "d41c3ed21ede5fb45d248c3e42113a7e3db2fea4"sv}, Entry{"v1-002130-002140-blocksidecars.idx"sv, "e278302d5dc5b77964d273cb81a2eb6d87043f8a"sv}, Entry{"v1-002140-002150-blobsidecars.seg"sv, "d53ef4ffb5d3ade7c00ea8caf53060bfe5cc4649"sv}, Entry{"v1-002140-002150-blocksidecars.idx"sv, "578b763e65798ec9bd9eb3ed33ae4519eb77c03f"sv}, Entry{"v1-002150-002160-blobsidecars.seg"sv, "b154bf2230289c3de1aecb067cb55b25694bcf55"sv}, Entry{"v1-002150-002160-blocksidecars.idx"sv, "8e29d4cad01dcd6b5ad6502b6765dedf2284dd18"sv}, Entry{"v1-002160-002170-blobsidecars.seg"sv, "90837d459f03a927cf9118969745d32bc792b5b3"sv}, Entry{"v1-002160-002170-blocksidecars.idx"sv, "5029e394fa772f5a8e601cd83b3bfe3b2f99704f"sv}, Entry{"v1-002170-002180-blobsidecars.seg"sv, "95b28e89da60575c0a8049fafee6da4bc64a4812"sv}, Entry{"v1-002170-002180-blocksidecars.idx"sv, "2619ab145c73ade9071d896f054db7bc5937fdbe"sv}, Entry{"v1-002180-002190-blobsidecars.seg"sv, "21bf0b844d01818bbc8730ca56e78c12099657d0"sv}, Entry{"v1-002180-002190-blocksidecars.idx"sv, "3634c88fcb8d2c7126df913eb75bcd40e636d461"sv}, Entry{"v1-002190-002200-blobsidecars.seg"sv, "4671a741598aa7d472df2c6097bde0ee8f476bcd"sv}, Entry{"v1-002190-002200-blocksidecars.idx"sv, "2d7c0da60a4790d581a55129052a95a13554e80e"sv}, Entry{"v1-002200-002210-blobsidecars.seg"sv, "72f77cc0d25b97fbd5e3423465215cff088c6293"sv}, Entry{"v1-002200-002210-blocksidecars.idx"sv, "e073e8b2dec39fd47d332bfaf1fca6003ad2cb31"sv}, Entry{"v1-002200-002300-bodies.idx"sv, "52b6912e0b60b5aa3ed65baea3ded11ecfd1488c"sv}, Entry{"v1-002200-002300-bodies.seg"sv, "01fdf3da7f39a6ae076c21f0dcd70a8bbd3c347c"sv}, Entry{"v1-002200-002300-headers.idx"sv, "25873d71ee17f6a9558a9aaa820e07fd3fc88714"sv}, Entry{"v1-002200-002300-headers.seg"sv, "03f83526dc58e818634d1af45d6cc2a57bbdacbd"sv}, Entry{"v1-002200-002300-transactions-to-block.idx"sv, "93289fce1dccdda409152050f59cb40f6f1930b4"sv}, Entry{"v1-002200-002300-transactions.idx"sv, "a0f58cc64785f9efa5b03cd05444f4add7da1f5d"sv}, Entry{"v1-002200-002300-transactions.seg"sv, "447de75e05547a7e8b72327da4414f3cbe903c36"sv}, Entry{"v1-002210-002220-blobsidecars.seg"sv, "dccf62ae4cb7b7d7869ae71829bf526bd3f3dbb4"sv}, Entry{"v1-002210-002220-blocksidecars.idx"sv, "71ae81d6ae2498ac48036f28b3bdf82cde2bd8d2"sv}, Entry{"v1-002220-002230-blobsidecars.seg"sv, "b242d24fabb8bc8ba3186a157e36ecb37321e7f3"sv}, Entry{"v1-002220-002230-blocksidecars.idx"sv, "8c38c5439288def68809309573d6a9563347e75b"sv}, Entry{"v1-002230-002240-blobsidecars.seg"sv, "01579458e5c96c59a835458f74f53e22f81ffbc3"sv}, Entry{"v1-002230-002240-blocksidecars.idx"sv, "a6d2aa2f2feb6c5e8199e2b3dd287ef81c4ab882"sv}, Entry{"v1-002240-002250-blobsidecars.seg"sv, "89466afe95e55b25b4bbc32ffff97c04937f36f4"sv}, Entry{"v1-002240-002250-blocksidecars.idx"sv, "9f85b6d80175f65d9358c22202beba272866d34b"sv}, Entry{"v1-002250-002260-blobsidecars.seg"sv, "bfff6ca2b1c6e16c65bd72e0d96f382a28c56780"sv}, Entry{"v1-002250-002260-blocksidecars.idx"sv, "443d2df24456b7642dfcf56da74da1efaee31d4f"sv}, Entry{"v1-002260-002270-blobsidecars.seg"sv, "23f4d107492686b5a71df5963a19ba6b872100e6"sv}, Entry{"v1-002260-002270-blocksidecars.idx"sv, "ebe25401e3c8e9cf8a26def4646db71efa8b572e"sv}, Entry{"v1-002270-002280-blobsidecars.seg"sv, "dc240a0321fb194e101bad625973cf5f7606d0f0"sv}, Entry{"v1-002270-002280-blocksidecars.idx"sv, "c086166db76235d511eabc85e88d6d7e5386ab46"sv}, Entry{"v1-002280-002290-blobsidecars.seg"sv, "04af18182894eda39f95935f9693d3ce387670bb"sv}, Entry{"v1-002280-002290-blocksidecars.idx"sv, "619c59f9dccec52b027b299d985036040fe57eb3"sv}, Entry{"v1-002290-002300-blobsidecars.seg"sv, "da0683dc29a1fd725f3d28c4451d54a95466bfbd"sv}, Entry{"v1-002290-002300-blocksidecars.idx"sv, "2f0608e7dedcd22a8fbdbfa2e8c5ea82012ea57e"sv}, Entry{"v1-002300-002310-blobsidecars.seg"sv, "43ba028b3c2bfc2206cfffa34fbd1d088354a167"sv}, Entry{"v1-002300-002310-blocksidecars.idx"sv, "5de42e8cfb1d6bb06e6e08a625f67aa2fef05cf1"sv}, Entry{"v1-002300-002400-bodies.idx"sv, "5a295bbe7a857c3ba95b178cb48d9e9936de9a1b"sv}, Entry{"v1-002300-002400-bodies.seg"sv, "6284ec7fde8f9cf83a2df4e2171637e273fe348c"sv}, Entry{"v1-002300-002400-headers.idx"sv, "d3488eb2c31f973c74c45e09a4a6a7f3581bc348"sv}, Entry{"v1-002300-002400-headers.seg"sv, "79011778229d359eb39d8f621999eb2603b317e3"sv}, Entry{"v1-002300-002400-transactions-to-block.idx"sv, "d000890ed04c693ab672e27885527f080873d0bb"sv}, Entry{"v1-002300-002400-transactions.idx"sv, "5890c3c8ecca5f8d26b44ca97e51dc79e1a3dae5"sv}, Entry{"v1-002300-002400-transactions.seg"sv, "6eeebadecd08c30bec95784c3433cfeacda85068"sv}, Entry{"v1-002310-002320-blobsidecars.seg"sv, "5a0a6c7d24d00aca9f9a64f61059b053846afa01"sv}, Entry{"v1-002310-002320-blocksidecars.idx"sv, "5350cf907d05ec77345a1ff16c6e9bea7fda117d"sv}, Entry{"v1-002320-002330-blobsidecars.seg"sv, "e2f1cbd29843b75bc8f742b47284e37ad044857f"sv}, Entry{"v1-002320-002330-blocksidecars.idx"sv, "83e721a5209d8041bf1a813d70954da53443186e"sv}, Entry{"v1-002330-002340-blobsidecars.seg"sv, "9ebb2b545ea1bd0dd08419e1f96a48541b744b3d"sv}, Entry{"v1-002330-002340-blocksidecars.idx"sv, "b7f3b4f7b06af14d2c563f05033a322b6f764ce0"sv}, Entry{"v1-002340-002350-blobsidecars.seg"sv, "d18a75315d196775a3f5dce4b6aff79ed48a74cb"sv}, Entry{"v1-002340-002350-blocksidecars.idx"sv, "3b5837de91047c3a42ec1989e126882431cf2c40"sv}, Entry{"v1-002350-002360-blobsidecars.seg"sv, "1ce062d14906dd4d024ede6d217ca47cc6fbd6e7"sv}, Entry{"v1-002350-002360-blocksidecars.idx"sv, "0b60c9188c4fb4accc782d2552976412b6bb856e"sv}, Entry{"v1-002360-002370-blobsidecars.seg"sv, "f471ae10546db3606d9f706f45c888665b6bdb21"sv}, Entry{"v1-002360-002370-blocksidecars.idx"sv, "78a73b116b8abfd228c0fb24b97b897dff982651"sv}, Entry{"v1-002370-002380-blobsidecars.seg"sv, "f87d0468bad88a9a6258cee794f1e68584f7c9de"sv}, Entry{"v1-002370-002380-blocksidecars.idx"sv, "d4e61a5331b696dbe166bc3171b754456ee8324f"sv}, Entry{"v1-002380-002390-blobsidecars.seg"sv, "3f608b830cf46218b75e6c50cac0a26e5a40218a"sv}, Entry{"v1-002380-002390-blocksidecars.idx"sv, "c2029cb335ee7d25cee385e762f82d089eb35709"sv}, Entry{"v1-002390-002400-blobsidecars.seg"sv, "21b25b62713b260fc73f4a50e3a1428625d53722"sv}, Entry{"v1-002390-002400-blocksidecars.idx"sv, "d8aadd3c8271d7484187ea2b37bc3c9dd985a95a"sv}, Entry{"v1-002400-002410-blobsidecars.seg"sv, "b68d063a8fa15e9f8c5ba2645303b02802cfd4cd"sv}, Entry{"v1-002400-002410-blocksidecars.idx"sv, "e3146a4c56f4323c1082d5f8e630fb3d9fb8b081"sv}, Entry{"v1-002400-002500-bodies.idx"sv, "0b1c6bb94fab95a667a4391d1521d70f0f731ffd"sv}, Entry{"v1-002400-002500-bodies.seg"sv, "c5072b8e44ca755ce58cbd5045e374160be69218"sv}, Entry{"v1-002400-002500-headers.idx"sv, "39a5f5cc66f52a1d97b7af1c731bcc0bd8dee605"sv}, Entry{"v1-002400-002500-headers.seg"sv, "96c17ee413b6330f7d248d711e7bd87050fa3194"sv}, Entry{"v1-002400-002500-transactions-to-block.idx"sv, "c9f14df60a95dabc88ba91c9c4ab3719c5b6a57b"sv}, Entry{"v1-002400-002500-transactions.idx"sv, "04322269a2e3b00695e64bf896a1b6ef1a058e73"sv}, Entry{"v1-002400-002500-transactions.seg"sv, "d1f996f389ef93881f1a5d749addda42c03cce28"sv}, Entry{"v1-002410-002420-blobsidecars.seg"sv, "a6bb077a7988928a4287c02cea0b6f396bc6c269"sv}, Entry{"v1-002410-002420-blocksidecars.idx"sv, "5234656ac34090921bc1e0a968b122f5d08dfa97"sv}, Entry{"v1-002420-002430-blobsidecars.seg"sv, "c8dc8eae7869bf7ec07c4349e4d07e9a31645c82"sv}, Entry{"v1-002420-002430-blocksidecars.idx"sv, "7e55641c167fe0c067cc85e89e43fbb605e9f890"sv}, Entry{"v1-002430-002440-blobsidecars.seg"sv, "5008d8b14c4e3aa7e2058e2b18167f1fac7d6113"sv}, Entry{"v1-002430-002440-blocksidecars.idx"sv, "dc44d8905fa6f5e46a177757bbae7f4104364e15"sv}, Entry{"v1-002440-002450-blobsidecars.seg"sv, "9bcb30bca5b85881b5a49e9727d479f9c6b0fbeb"sv}, Entry{"v1-002440-002450-blocksidecars.idx"sv, "7203fec0101cd57e69e061d985771c96c4da90e9"sv}, Entry{"v1-002450-002460-blobsidecars.seg"sv, "6a8444b00e31adcdb2f8d208cf3113ec5a4950f2"sv}, Entry{"v1-002450-002460-blocksidecars.idx"sv, "1b34fe7418451dee77d9d8ce1e97cd04458af130"sv}, Entry{"v1-002460-002470-blobsidecars.seg"sv, "bd0e440697c61de7d376fed41be710ea7a803c26"sv}, Entry{"v1-002460-002470-blocksidecars.idx"sv, "bf4132f1c7ed4880c3109a229ab4ab06e20ff8af"sv}, Entry{"v1-002470-002480-blobsidecars.seg"sv, "eb383cb8b605996877a28497c636e14a12fdfab5"sv}, Entry{"v1-002470-002480-blocksidecars.idx"sv, "cbad90ccf04347a2824b3425da39d8a39dc23868"sv}, Entry{"v1-002480-002490-blobsidecars.seg"sv, "bb66b9b9ec52b1aa82f138469ee48c3c370af2e6"sv}, Entry{"v1-002480-002490-blocksidecars.idx"sv, "74f93473e3508f71939903ab0972efd208f52df1"sv}, Entry{"v1-002490-002500-blobsidecars.seg"sv, "982361e2c68c99f55fb7702a550ce00fecee977a"sv}, Entry{"v1-002490-002500-blocksidecars.idx"sv, "cc842fa9e37976fd639a44c02ae8d6a3e218f777"sv}, Entry{"v1-002500-002510-blobsidecars.seg"sv, "d88a048ec8f005461fde6864c169303d1a0abca4"sv}, Entry{"v1-002500-002510-blocksidecars.idx"sv, "8b30ed6c2d4cf2d74c54e7808db840c64730c72f"sv}, Entry{"v1-002500-002510-bodies.idx"sv, "2e0123477f74f27618478ffa286effa1e3d3891d"sv}, Entry{"v1-002500-002510-bodies.seg"sv, "c299ade944d81cd4dd11d5dbad55674292417865"sv}, Entry{"v1-002500-002510-headers.idx"sv, "e1a1e9852d520448a7dea25dc4182b34307466a8"sv}, Entry{"v1-002500-002510-headers.seg"sv, "b362ac0b3ef19f8e1f70473d269c507b545253d4"sv}, Entry{"v1-002500-002510-transactions-to-block.idx"sv, "a4445f233534a5e5494f67f134bf23659373aff2"sv}, Entry{"v1-002500-002510-transactions.idx"sv, "380be592ea95ff5cf8d310ef62dd84901fc2d392"sv}, Entry{"v1-002500-002510-transactions.seg"sv, "1a736c0349b85358a9c1fae4b822c8dfa41c4608"sv}, Entry{"v1-002510-002520-blobsidecars.seg"sv, "6cf083801c7adebdbf9c08bbde7e00d923b59d41"sv}, Entry{"v1-002510-002520-blocksidecars.idx"sv, "9de27a2d9365026c0b97b1fc1379cd5595ff092f"sv}, Entry{"v1-002510-002520-bodies.idx"sv, "7c281600a7408e063302b51293f983e2dd4f6b64"sv}, Entry{"v1-002510-002520-bodies.seg"sv, "97eebd91c3b92731e29880db60cdf259e382073f"sv}, Entry{"v1-002510-002520-headers.idx"sv, "237bd53b45e650897edef98aeda0dbf7a22ff26c"sv}, Entry{"v1-002510-002520-headers.seg"sv, "edd6269ed39e02a8ea24f85f65dc959bd749eb86"sv}, Entry{"v1-002510-002520-transactions-to-block.idx"sv, "292b0f4eea441af15c198ff2e154bb83afca6d4b"sv}, Entry{"v1-002510-002520-transactions.idx"sv, "97c8318ce84040b198b341cb075c1738f65870dc"sv}, Entry{"v1-002510-002520-transactions.seg"sv, "f5a2585b6d78e987b2e7698488d42387d55ea917"sv}, Entry{"v1-002520-002530-blobsidecars.seg"sv, "5fc55a086972a7948cd8b6b95f888e3229f8de42"sv}, Entry{"v1-002520-002530-blocksidecars.idx"sv, "e7d2edd40158dd1d35b7da21ba2ae5524ae353cd"sv}, Entry{"v1-002520-002530-bodies.idx"sv, "af74eb86f4cd773df77792bf07fe2ce987c90322"sv}, Entry{"v1-002520-002530-bodies.seg"sv, "42a0c97ee749080f07d4c053ef11599b1f656bc6"sv}, Entry{"v1-002520-002530-headers.idx"sv, "240b22956b43b00deb03d293dc89b765b18ab85a"sv}, Entry{"v1-002520-002530-headers.seg"sv, "57ce0a46cce3f5bab3a07beda1be2a29f626f26a"sv}, Entry{"v1-002520-002530-transactions-to-block.idx"sv, "317be7887ac1a2632eb80dec36db71d558503939"sv}, Entry{"v1-002520-002530-transactions.idx"sv, "aeec2207a3cf83af97049e1631a5991e8d94b028"sv}, Entry{"v1-002520-002530-transactions.seg"sv, "abb144ed8d37ad1211a271b97a8b64642541a3b6"sv}, Entry{"v1-002530-002540-blobsidecars.seg"sv, "c7a2e96ebb0f147fbe47e6e0bab54dfc90d89f4a"sv}, Entry{"v1-002530-002540-blocksidecars.idx"sv, "bb2966a8ab95d83f4cd405d3c39be95807f5e951"sv}, Entry{"v1-002530-002540-bodies.idx"sv, "e1da1f3b94c5e7c1e3532cc117a25305c6c04dc6"sv}, Entry{"v1-002530-002540-bodies.seg"sv, "9a68049531cb6e14f30213bafbcd16a4681eb64f"sv}, Entry{"v1-002530-002540-headers.idx"sv, "38a51f11d9c72ce009964d794a0b2beb66252a92"sv}, Entry{"v1-002530-002540-headers.seg"sv, "f2e224a57e27e093e47285df13309b46ef7289ed"sv}, Entry{"v1-002530-002540-transactions-to-block.idx"sv, "842709befb5525ba6f07a6260706b69bca61ed0b"sv}, Entry{"v1-002530-002540-transactions.idx"sv, "c0b3b03e315d117e1ad0d710c16289e786e39596"sv}, Entry{"v1-002530-002540-transactions.seg"sv, "67248816cc443554046c9d161652dc1ec68a8a8b"sv}, Entry{"v1-002540-002550-blobsidecars.seg"sv, "025d980f366b4912e1599afcc04a655564d1b83f"sv}, Entry{"v1-002540-002550-blocksidecars.idx"sv, "74ee3ba7a40fa9ff6291a57dcccbf03997ce1730"sv}, Entry{"v1-002540-002550-bodies.idx"sv, "6e8ed12acdf843a682af4daf33b48daf044eccf2"sv}, Entry{"v1-002540-002550-bodies.seg"sv, "a5cd3f10eae9ffd2226e52ce999b736dcdec641d"sv}, Entry{"v1-002540-002550-headers.idx"sv, "1654bb965e9ca213049f618127c3bf25cb44b106"sv}, Entry{"v1-002540-002550-headers.seg"sv, "3e3b714c5948c4af24193474e2de05e333ed0027"sv}, Entry{"v1-002540-002550-transactions-to-block.idx"sv, "923ed3fc54223e77d197b077b5bef556f4619d0b"sv}, Entry{"v1-002540-002550-transactions.idx"sv, "9abb3b44ea2fb4eb634751ecf117fd80bad21693"sv}, Entry{"v1-002540-002550-transactions.seg"sv, "78eb8dca6343581b9986ea169f218a4aee3435f6"sv}, Entry{"v1-002550-002560-blobsidecars.seg"sv, "1023c7381fd569ad901ce564727435ba2e535687"sv}, Entry{"v1-002550-002560-blocksidecars.idx"sv, "ddda9e5f607cebe29a555015c219ad131f5471b5"sv}, Entry{"v1-002550-002560-bodies.idx"sv, "e9ff6ef989522faebfe7ca0ef1df3acc1670e219"sv}, Entry{"v1-002550-002560-bodies.seg"sv, "30a8204cdc4c82235e88fb733a64e6eb4fd8d0d2"sv}, Entry{"v1-002550-002560-headers.idx"sv, "6425640bdfa90b3afc3b88ee0279783083556601"sv}, Entry{"v1-002550-002560-headers.seg"sv, "302b1690c48090e7f18afa80286bca11499ffdf2"sv}, Entry{"v1-002550-002560-transactions-to-block.idx"sv, "e091cac58ad39c2e8331d4dedbd459a32a5fc40f"sv}, Entry{"v1-002550-002560-transactions.idx"sv, "20b671ccba0d9da70f47ed1fdde0202fa1a84812"sv}, Entry{"v1-002550-002560-transactions.seg"sv, "ea25c2505a24cee28aaf4cd26f8b602088d6a8e4"sv}, Entry{"v1-002560-002570-blobsidecars.seg"sv, "072ce51b161a6f5889c1851e703caf9d0364c0a7"sv}, Entry{"v1-002560-002570-blocksidecars.idx"sv, "bd30890effd4dc696a8a4ccd5193dd6ce72f4349"sv}, Entry{"v1-002560-002570-bodies.idx"sv, "725f3d4da51d41cfdb9384d97e90a8071d6cffdb"sv}, Entry{"v1-002560-002570-bodies.seg"sv, "3265bbd2873ad0bf1ca7509144dd321c1890c2a0"sv}, Entry{"v1-002560-002570-headers.idx"sv, "3915deec631df7851c85a2ac5bc4913062de115c"sv}, Entry{"v1-002560-002570-headers.seg"sv, "edb5c7b1b9d133af2f1d8129cc9e6539f5a11e85"sv}, Entry{"v1-002560-002570-transactions-to-block.idx"sv, "3adcf24ecc43dde8e53d64fe5c489f16d21e4725"sv}, Entry{"v1-002560-002570-transactions.idx"sv, "e6626f7f812872d7df7cfdc57f8127570d0daec4"sv}, Entry{"v1-002560-002570-transactions.seg"sv, "f153f3c33c529f2a5bab37ab21c915664dc85bfb"sv}, Entry{"v1-002570-002571-bodies.idx"sv, "050d52a0e04e5f7164e70a72c6ebcba343bdef29"sv}, Entry{"v1-002570-002571-bodies.seg"sv, "2aa0755764e96e213389c79f53497ac704189214"sv}, Entry{"v1-002570-002571-headers.idx"sv, "9107f591ade0e3761451c87f696d635fbe0bcde3"sv}, Entry{"v1-002570-002571-headers.seg"sv, "3c3ea8a2a9728826d7d129f5b3f485389a6208a7"sv}, Entry{"v1-002570-002571-transactions-to-block.idx"sv, "6cde163c77b73d8fa407883d37b229e0a91b5715"sv}, Entry{"v1-002570-002571-transactions.idx"sv, "adfaf554b06c4643ac355ff1f35cff6f842e4367"sv}, Entry{"v1-002570-002571-transactions.seg"sv, "32405e5a10d6c08ff734f634e328c42c5f9ed2e4"sv}, Entry{"v1-002570-002580-blobsidecars.seg"sv, "c9139f2b36d623441bb0fb3052e80353937a044d"sv}, Entry{"v1-002570-002580-blocksidecars.idx"sv, "110914af8da26827801eba79b2bf3e30a9ce2262"sv}, Entry{"v1-002571-002572-bodies.idx"sv, "daf0278161ff67bce377be704aa0f692d13cac0e"sv}, Entry{"v1-002571-002572-bodies.seg"sv, "a2bf677bb7d672ed0092081607061a62c9e2910e"sv}, Entry{"v1-002571-002572-headers.idx"sv, "cfb3c1fff73dc23ac2a0330e2c526edc5389283f"sv}, Entry{"v1-002571-002572-headers.seg"sv, "4f35bd9752a237bc7f5afae2231c6494e2705906"sv}, Entry{"v1-002571-002572-transactions-to-block.idx"sv, "a61b0b18f37c96c6a867dbf1134e3ba0d9c0a873"sv}, Entry{"v1-002571-002572-transactions.idx"sv, "8cb830190d86038f5b27f9045c53b20a3a1d15a6"sv}, Entry{"v1-002571-002572-transactions.seg"sv, "cbc7e0fb750c9887f415a5848b490cab66d0de90"sv}, Entry{"v1-002572-002573-bodies.idx"sv, "c9bf49d45334965afbac786604ea83d39c71ce5a"sv}, Entry{"v1-002572-002573-bodies.seg"sv, "dfbd1be2813579d59cf76da98bbc73a2610d8154"sv}, Entry{"v1-002572-002573-headers.idx"sv, "6cbee892a675159ef1c4f4d2f8baca4e81c4c53a"sv}, Entry{"v1-002572-002573-headers.seg"sv, "e9c467bc614d75d9bfe1c714049f2f50fe567beb"sv}, Entry{"v1-002572-002573-transactions-to-block.idx"sv, "1341a378f0f7d6daa7f75be7bf3cdf27e158dcfd"sv}, Entry{"v1-002572-002573-transactions.idx"sv, "a7ea1b4befe4651ec59dd8434e5a2f4fd37f7cac"sv}, Entry{"v1-002572-002573-transactions.seg"sv, "7267a785415859ed7e492f521fc3476dcc34ea88"sv}, Entry{"v1-002573-002574-bodies.idx"sv, "d0cb3410fd2c9ffe05a1b2457ec7173dc69849d9"sv}, Entry{"v1-002573-002574-bodies.seg"sv, "36ff49ad2d171499082d34786fec26dd4d03e747"sv}, Entry{"v1-002573-002574-headers.idx"sv, "37065ff9eaa5931fabd60dfb74447e3964876b12"sv}, Entry{"v1-002573-002574-headers.seg"sv, "a1374974d08cdc0d138ae8a8cd83a29e1e7bd5e5"sv}, Entry{"v1-002573-002574-transactions-to-block.idx"sv, "6d13aadc89ffc0f09b6cfcdce0bfab23a9154b00"sv}, Entry{"v1-002573-002574-transactions.idx"sv, "e97476e183d9269539129a4abfb65ecf0294b5c7"sv}, Entry{"v1-002573-002574-transactions.seg"sv, "2858ff5236b046beae222234acbbdfe940e24fc8"sv}, Entry{"v1-002574-002575-bodies.idx"sv, "a077fbf7d63a5b077f9b4e0d4720b9024c9b93ed"sv}, Entry{"v1-002574-002575-bodies.seg"sv, "26c6c2910f57ba86ccd202e63416dea6f5b3a1e7"sv}, Entry{"v1-002574-002575-headers.idx"sv, "50e56e39d2fb22d040876730c72255e69ec19525"sv}, Entry{"v1-002574-002575-headers.seg"sv, "3be771e9d0b56846dd388ea8c52727d75c517689"sv}, Entry{"v1-002574-002575-transactions-to-block.idx"sv, "f42abf9d5e078f1f3f3aaedd413e6f1a41f3747d"sv}, Entry{"v1-002574-002575-transactions.idx"sv, "0d0d7ed609b2b04f138fbf56ddb498b532e1d59f"sv}, Entry{"v1-002574-002575-transactions.seg"sv, "93a8a8a928771fa9b1e068afb3fd98b05c53c316"sv}, Entry{"v1-002575-002576-bodies.idx"sv, "57ed0b0efde0cf4d229d56d7007fc63de9e98321"sv}, Entry{"v1-002575-002576-bodies.seg"sv, "9fecec97245ef87bbeaaca37b1daa98b77389704"sv}, Entry{"v1-002575-002576-headers.idx"sv, "5747b777763ef055fff41922b2137103b675a8c8"sv}, Entry{"v1-002575-002576-headers.seg"sv, "ac21a4bd80ee944c34569ffcafbdf3978fe28ce7"sv}, Entry{"v1-002575-002576-transactions-to-block.idx"sv, "9ddaaab8421570fa990208735a51d3a426fcebc2"sv}, Entry{"v1-002575-002576-transactions.idx"sv, "7e9f5e2eb27f72a018625afb8ea9022b190d53a1"sv}, Entry{"v1-002575-002576-transactions.seg"sv, "8b92058681aa572ffa1862272b546339f96cd643"sv}, Entry{"v1-002576-002577-bodies.idx"sv, "97b6d24eddaba6ba799929cd6fff815f86a324c7"sv}, Entry{"v1-002576-002577-bodies.seg"sv, "d026a01fa05c909dbffce4cc8ec2b53b7d7e56eb"sv}, Entry{"v1-002576-002577-headers.idx"sv, "b8383baa18119d0c85f4a6b28ec73b3b4b2c678a"sv}, Entry{"v1-002576-002577-headers.seg"sv, "184b04b16e0d4e2d71a2c84aae98391defc3d999"sv}, Entry{"v1-002576-002577-transactions-to-block.idx"sv, "16852f2476d6f7dbde58a5dcf0b38d5a466bf789"sv}, Entry{"v1-002576-002577-transactions.idx"sv, "da0136e5f526f381357c461c2bc0f8613c8cc5e1"sv}, Entry{"v1-002576-002577-transactions.seg"sv, "9bdc93d660b6dbdee5c05727b918356a2fe9883c"sv}, Entry{"v1-002580-002590-blobsidecars.seg"sv, "d55e727653d7dec01c48b19dce7316d9bf704e96"sv}, Entry{"v1-002580-002590-blocksidecars.idx"sv, "4bf8655882470bb49c0288b5da33d191e1849efd"sv}, Entry{"v1-002590-002600-blobsidecars.seg"sv, "f624ce8e0617372e4c20a1e7d774b97410d41a0f"sv}, Entry{"v1-002590-002600-blocksidecars.idx"sv, "41f61c376f58f3acacbbb7525ecfe839d93a784b"sv}, Entry{"v1-002600-002610-blobsidecars.seg"sv, "b962b80a353c09b32ed816a2d280e18b0a641e26"sv}, Entry{"v1-002600-002610-blocksidecars.idx"sv, "e94feeef9291722898500b6963b7dd165e6aa9b9"sv}, Entry{"v1-002610-002620-blobsidecars.seg"sv, "4720439c2de3a7a1259949a8355f8b8673a361f6"sv}, Entry{"v1-002610-002620-blocksidecars.idx"sv, "30e00db4db7d92f3a98686f7d9c7ee0c8f791b9d"sv}, Entry{"v1-002620-002630-blobsidecars.seg"sv, "09666839bb4038150f3623bff2dfc57e337177dd"sv}, Entry{"v1-002620-002630-blocksidecars.idx"sv, "9791b4bbfd89a7c79367da82ba79e62a0bd76b87"sv}, Entry{"v1-002630-002640-blobsidecars.seg"sv, "e023b5cbc1ea204fbaf07ac8863236f13b5f3052"sv}, Entry{"v1-002630-002640-blocksidecars.idx"sv, "e6d94799b9317bda73b410d82130fd4524b372c9"sv}, Entry{"v1-002640-002650-blobsidecars.seg"sv, "b71e45c40b0a8818f5390867119fdce2079c12e9"sv}, Entry{"v1-002640-002650-blocksidecars.idx"sv, "a1910885a7ad60a1086230889b7ae3bb0d8bf68c"sv}, Entry{"v1-002650-002660-blobsidecars.seg"sv, "3e336c87c0eab07d6b5e0e051f3415317aa5c710"sv}, Entry{"v1-002650-002660-blocksidecars.idx"sv, "b58675d5f47713b5daf00c0cad044008c029879b"sv}, Entry{"v1-002660-002670-blobsidecars.seg"sv, "8f076ea9e00ba7f0fffbce6a2d75a8fcebd7a559"sv}, Entry{"v1-002660-002670-blocksidecars.idx"sv, "5702cb0694921ef0fff527de4edfe71bb27b9cb0"sv}, Entry{"v1-002670-002680-blobsidecars.seg"sv, "bd86d7969b5453a27921c3337388e2eab8a3b672"sv}, Entry{"v1-002670-002680-blocksidecars.idx"sv, "509164b43ce2ff90525a09318bb12f3df430599f"sv}, Entry{"v1-002680-002690-blobsidecars.seg"sv, "f4ad4e066b10d7e0207f84ce8ad32328e2e4ce7d"sv}, Entry{"v1-002680-002690-blocksidecars.idx"sv, "1833d0e19e6a7f469ff38a54ccebe54ad9ff4ee8"sv}, Entry{"v1-002690-002700-blobsidecars.seg"sv, "987db287aa326db555edc8e7c4ec6b75c06edeb3"sv}, Entry{"v1-002690-002700-blocksidecars.idx"sv, "a47a2168c65fd7037813b214f77b44ee1c6d8f4c"sv}, Entry{"v1-002700-002710-blobsidecars.seg"sv, "db1caf088faad6055edef48202fdf07dbbf694d9"sv}, Entry{"v1-002700-002710-blocksidecars.idx"sv, "8e259f2fef0b0613db333d04e0e7cb55d876a48b"sv}, Entry{"v1-002710-002720-blobsidecars.seg"sv, "b8078eef892430408c78c406be12086f44535076"sv}, Entry{"v1-002710-002720-blocksidecars.idx"sv, "684d7386a7b21e9054e1481394a94f39c8d1fa1a"sv}, Entry{"v1-002720-002730-blobsidecars.seg"sv, "858750dd454f29351d647867eb3f206e6a092435"sv}, Entry{"v1-002720-002730-blocksidecars.idx"sv, "c0c18429efebea56b2c1277967ca12980cbb238d"sv}, Entry{"v1-002730-002740-blobsidecars.seg"sv, "a8a28e0420d400ca720dfc7b3da201d0703ed0fc"sv}, Entry{"v1-002730-002740-blocksidecars.idx"sv, "5089ab3b2835d575fd066e07ac5e756e9ee17103"sv}, Entry{"v1-002740-002750-blobsidecars.seg"sv, "9c2ae965aa2393bd1d6574c35d9f0ea7f6d5960a"sv}, Entry{"v1-002740-002750-blocksidecars.idx"sv, "1f4607aadcaaca6622667c77d3fc3f971f2b24c8"sv}, Entry{"v1-002750-002760-blobsidecars.seg"sv, "326d0aba65b7d5a1ac16949a1e338791d8f0bf77"sv}, Entry{"v1-002750-002760-blocksidecars.idx"sv, "e9db3bf44ec6a9fddc08a851e3234e2fb768fc3f"sv}, Entry{"v1-002760-002770-blobsidecars.seg"sv, "819f26885c9a27b4bcda5b27e5585d64b273ca91"sv}, Entry{"v1-002760-002770-blocksidecars.idx"sv, "759df5bb0ef5f181b5cb4b8e3bc23fa8229ceb60"sv}, }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/chains/mainnet.hpp ================================================ /* Generated from mainnet.toml using Silkworm embed_toml */ #pragma once #include #include #include "../entry.hpp" namespace silkworm::snapshots { using namespace std::literals; inline constexpr std::array kMainnetSnapshots{ Entry{"accessor/v1-accounts.0-64.efi"sv, "c18623d88b0993912010cf2fbfaf18a6b5006790"sv}, Entry{"accessor/v1-accounts.0-64.vi"sv, "1f089966af59190d2fbdfe3bbd07defb8f8e96ec"sv}, Entry{"accessor/v1-accounts.1024-1088.efi"sv, "3d0afd20587c3fc3d90b08a8ef832fb4e8b1c5c9"sv}, Entry{"accessor/v1-accounts.1024-1088.vi"sv, "ab4dfe5125fd079977eeb4006cb5a835773e2ced"sv}, Entry{"accessor/v1-accounts.1088-1152.efi"sv, "d9ebc97e63933a9c78e4f118d3e5de3634fb8822"sv}, Entry{"accessor/v1-accounts.1088-1152.vi"sv, "53c8ed419f9e04eb1005a90b65ddeab8ed36630c"sv}, Entry{"accessor/v1-accounts.1152-1216.efi"sv, "beb3570a7bcad0718f4d82605a52a118478e3dfe"sv}, Entry{"accessor/v1-accounts.1152-1216.vi"sv, "3c3b76433169d9697782a014b75f0125aded2d3e"sv}, Entry{"accessor/v1-accounts.1216-1280.efi"sv, "d8f3e5da19a19d72e773fafad5b4443b86659c27"sv}, Entry{"accessor/v1-accounts.1216-1280.vi"sv, "9ff95c16d36443a409830fc2c040fb96099be1f1"sv}, Entry{"accessor/v1-accounts.128-192.efi"sv, "e910622a11c13113dac701a130f602af1ff6a1ae"sv}, Entry{"accessor/v1-accounts.128-192.vi"sv, "ae2857626f5fa0145f49bbdbe3d0a092c4227c10"sv}, Entry{"accessor/v1-accounts.1280-1344.efi"sv, "3218790a05d4eac0f5392b71f316b0d2ab862612"sv}, Entry{"accessor/v1-accounts.1280-1344.vi"sv, "b541489a30b2390a6b7cc709503539f8fc73e1a0"sv}, Entry{"accessor/v1-accounts.1344-1408.efi"sv, "a5fbdfece946b0ee9426cca069a12a1c1c4102d2"sv}, Entry{"accessor/v1-accounts.1344-1408.vi"sv, "71dec23d90c1a713176e4201d6a539a67b426df5"sv}, Entry{"accessor/v1-accounts.1408-1472.efi"sv, "34d276bfab80dc55a700e424c447ebee7a2e3876"sv}, Entry{"accessor/v1-accounts.1408-1472.vi"sv, "3351a0f9e47d09f9893db02924e424a3e331eb8f"sv}, Entry{"accessor/v1-accounts.1472-1536.efi"sv, "1a01c29f3a69da870d4a09350cd4741e3e8f5905"sv}, Entry{"accessor/v1-accounts.1472-1536.vi"sv, "f9389917f133037c0cbfabfa416a4ef2b1c5b8f4"sv}, Entry{"accessor/v1-accounts.1536-1600.efi"sv, "971a9ee40cd6355b9f22d1ecfe1433ce5d9bcfa4"sv}, Entry{"accessor/v1-accounts.1536-1600.vi"sv, "814ca9c16c602d80aeaf3ae1c7747ad3d8923132"sv}, Entry{"accessor/v1-accounts.1600-1632.efi"sv, "371002b4a4121c604d9c0374cb295861b185fd8f"sv}, Entry{"accessor/v1-accounts.1600-1632.vi"sv, "904499be1097f88638be41ff6bcd46eda3cb4dee"sv}, Entry{"accessor/v1-accounts.1632-1648.efi"sv, "dbd0980f173e0bc0daa683cd15f3d76643910ec2"sv}, Entry{"accessor/v1-accounts.1632-1648.vi"sv, "8fda67d418d971b267e40be96e3c7218f2a9983d"sv}, Entry{"accessor/v1-accounts.1648-1656.efi"sv, "31e8da609731d9ed6068cf8156547a3438edbc53"sv}, Entry{"accessor/v1-accounts.1648-1656.vi"sv, "edd209624dc7ac91e812e8e3a635f3796f80c19a"sv}, Entry{"accessor/v1-accounts.1656-1660.efi"sv, "3a6de37102309c84757901c1dcb4d316596651c1"sv}, Entry{"accessor/v1-accounts.1656-1660.vi"sv, "596b98067809f02c87ce7cc8845ffa2d2101141a"sv}, Entry{"accessor/v1-accounts.192-256.efi"sv, "5250b74e25dcb35ca3736e1dcc5bd7bf5b9da18f"sv}, Entry{"accessor/v1-accounts.192-256.vi"sv, "6e0c55335783922581fbca009a1e08cde7e4f30f"sv}, Entry{"accessor/v1-accounts.256-320.efi"sv, "7d91415757edbe0c397bea22a69d9a327052db0c"sv}, Entry{"accessor/v1-accounts.256-320.vi"sv, "918a21d878b2afb02016c8c0368d1c5dc0be541d"sv}, Entry{"accessor/v1-accounts.320-384.efi"sv, "e80efbaa583116af168dff463665391518014051"sv}, Entry{"accessor/v1-accounts.320-384.vi"sv, "1b2ec6736f5d515c5755bef372731c3b04b2fb80"sv}, Entry{"accessor/v1-accounts.384-448.efi"sv, "25d950fe6db556af5b4796be0212277f2c973ac7"sv}, Entry{"accessor/v1-accounts.384-448.vi"sv, "5a60d87a808dbbd0f184372b363d3d1925dcbd18"sv}, Entry{"accessor/v1-accounts.448-512.efi"sv, "2793a0297674514c4002f91f657b05f1aac102b7"sv}, Entry{"accessor/v1-accounts.448-512.vi"sv, "b167d74750a7d2c3af8de5d68fed820fe6224e8d"sv}, Entry{"accessor/v1-accounts.512-576.efi"sv, "0dc18ff51659428a2ecee6b9e1e7a80de677cf27"sv}, Entry{"accessor/v1-accounts.512-576.vi"sv, "6d0755d4e1140a69a1924185a0874288c0bbd28f"sv}, Entry{"accessor/v1-accounts.576-640.efi"sv, "736d9827a996f70a2e5e9f70c841feb70886bb67"sv}, Entry{"accessor/v1-accounts.576-640.vi"sv, "41debc96a7c426626340d7f72095bce11bbfc2cc"sv}, Entry{"accessor/v1-accounts.64-128.efi"sv, "07fcac369b9739cdb4c589ad48e423a1863c1b6e"sv}, Entry{"accessor/v1-accounts.64-128.vi"sv, "b3343cc64a9a99dfd8ae3a7aede523e053a87dd4"sv}, Entry{"accessor/v1-accounts.640-704.efi"sv, "f69ecf1037b2456036919c0af345b0cdbc85971b"sv}, Entry{"accessor/v1-accounts.640-704.vi"sv, "6b68637f57800ff7f6edd42e54012082e1ae4d58"sv}, Entry{"accessor/v1-accounts.704-768.efi"sv, "633d58c6ed95a1d2e1581fb7fc4bb7935a4145c0"sv}, Entry{"accessor/v1-accounts.704-768.vi"sv, "f889eec19418ee5d3cdc3e5684d80bc6e30e64ea"sv}, Entry{"accessor/v1-accounts.768-832.efi"sv, "6f6bfeff1d829274bd0495422ac12ccd39509199"sv}, Entry{"accessor/v1-accounts.768-832.vi"sv, "b74db7eb5951fbc16752dfdaf4b8258b5fee41d5"sv}, Entry{"accessor/v1-accounts.832-896.efi"sv, "4019b333e7317688de5cbf2a6cb98f12068305cc"sv}, Entry{"accessor/v1-accounts.832-896.vi"sv, "ad146d844aa9aef5e584df176b524c0ec4d4a2f6"sv}, Entry{"accessor/v1-accounts.896-960.efi"sv, "44cb11f464b7689e11c32445ae3e9ff1c58b0722"sv}, Entry{"accessor/v1-accounts.896-960.vi"sv, "e97d2f098f51e0fc741426255f4390448b5bf3c0"sv}, Entry{"accessor/v1-accounts.960-1024.efi"sv, "8a8d763fac76126012b482634214c19306c15712"sv}, Entry{"accessor/v1-accounts.960-1024.vi"sv, "631dd611dbf6c0976744935265664c48d9942e37"sv}, Entry{"accessor/v1-code.0-64.efi"sv, "2c6c4ae22f7cfa463e3e0b65ea5939438b5bc72c"sv}, Entry{"accessor/v1-code.0-64.vi"sv, "15e63393359d42ec40fd0a081b9aab026615e837"sv}, Entry{"accessor/v1-code.1024-1088.efi"sv, "1b65226abdf547a697618188b0dbce970be462d3"sv}, Entry{"accessor/v1-code.1024-1088.vi"sv, "14f3b3e14046603b195968bb0c94ba78514af71f"sv}, Entry{"accessor/v1-code.1088-1152.efi"sv, "b9b5bb75ed6128f8df6d19338f2c992abdddabdd"sv}, Entry{"accessor/v1-code.1088-1152.vi"sv, "382f3ec9029b343c16912984a9f2e1a2cd7ee628"sv}, Entry{"accessor/v1-code.1152-1216.efi"sv, "aabf19bafc05e763a73de6837095b1bcb8f8a95e"sv}, Entry{"accessor/v1-code.1152-1216.vi"sv, "341bf5362c9b681cbe544e5ab619a16f02fea266"sv}, Entry{"accessor/v1-code.1216-1280.efi"sv, "5a0db84a54c68333f51ea10eaa1f66a03e51e3fa"sv}, Entry{"accessor/v1-code.1216-1280.vi"sv, "e1312d81464eb6d9c932e3e34ab895f42d1088ac"sv}, Entry{"accessor/v1-code.128-192.efi"sv, "5f4897fed762746902632ff5350f7d168b9952dd"sv}, Entry{"accessor/v1-code.128-192.vi"sv, "1c39d04ff45bf4f7b0fc61ace2518de1e3d64c2b"sv}, Entry{"accessor/v1-code.1280-1344.efi"sv, "f179df9a0c231a889cda837e5da20df4d0e9109b"sv}, Entry{"accessor/v1-code.1280-1344.vi"sv, "a58ae0454375d42132525ab30e689f9c625a9472"sv}, Entry{"accessor/v1-code.1344-1408.efi"sv, "db25bc66580c8be9f34893df16ca2221e5198e02"sv}, Entry{"accessor/v1-code.1344-1408.vi"sv, "dd54d307bc370d2080ca64d1cc1e65e016cfc516"sv}, Entry{"accessor/v1-code.1408-1472.efi"sv, "bdfdb7490e9dc55732934dd53240fe591f107763"sv}, Entry{"accessor/v1-code.1408-1472.vi"sv, "4f6eff00a223ac76366cfd245096ae9ee33e663e"sv}, Entry{"accessor/v1-code.1472-1536.efi"sv, "2d8e75c4641993a69e7f5e31242522eb494f99e4"sv}, Entry{"accessor/v1-code.1472-1536.vi"sv, "c809afd94c80909e60eb1e27f945254f582c8984"sv}, Entry{"accessor/v1-code.1536-1600.efi"sv, "55a7dfa4991df18aa694dd9150db760a0b164a6e"sv}, Entry{"accessor/v1-code.1536-1600.vi"sv, "d781adb4081dd8dd63a2a6a604d55b5fda02f1bd"sv}, Entry{"accessor/v1-code.1600-1632.efi"sv, "d6e65ed778d7193a7a0194e06b57d80feb991bdd"sv}, Entry{"accessor/v1-code.1600-1632.vi"sv, "b314def014ceb33b6c589cea0fadb09e417f6f85"sv}, Entry{"accessor/v1-code.1632-1648.efi"sv, "6eb1d905c961032bdc1f8f42a42548dce99622aa"sv}, Entry{"accessor/v1-code.1632-1648.vi"sv, "45c391094db828503cf5085ee7566d2fc7c5a197"sv}, Entry{"accessor/v1-code.1648-1656.efi"sv, "5094307228243c5d79670889bb7ba9426c65e4c4"sv}, Entry{"accessor/v1-code.1648-1656.vi"sv, "478ad82a95ea06eb6ecd7dd249db4277bd49d0f8"sv}, Entry{"accessor/v1-code.1656-1660.efi"sv, "33a7e79c906a12da2213de9895ea737012cd967d"sv}, Entry{"accessor/v1-code.1656-1660.vi"sv, "677fd51d9132b95e62bd187b1677355f5d826f65"sv}, Entry{"accessor/v1-code.192-256.efi"sv, "f0368a0cc391ec006ea6d9c91b5fecfeecb53d59"sv}, Entry{"accessor/v1-code.192-256.vi"sv, "a0423fb43b7298d3cdcefb76d848ada5a159a1d3"sv}, Entry{"accessor/v1-code.256-320.efi"sv, "d0b42fd0bb429d8c9c3c988464a69ecc23267230"sv}, Entry{"accessor/v1-code.256-320.vi"sv, "9b228ab6482b70a54ef7a3e1e27a34cf3d1c9d5f"sv}, Entry{"accessor/v1-code.320-384.efi"sv, "4e69f3f1fa18aae842d7c38447a8ec589a3b24a2"sv}, Entry{"accessor/v1-code.320-384.vi"sv, "3aa22b453d0d5d90378837bba9d2ed62286f135d"sv}, Entry{"accessor/v1-code.384-448.efi"sv, "612b0604ff07f7e7ae057431df69b95d31cf521f"sv}, Entry{"accessor/v1-code.384-448.vi"sv, "69075712dbff65cdfe23657dcddb5c9bcf1568e5"sv}, Entry{"accessor/v1-code.448-512.efi"sv, "a5968f5ac0dedcf4621a306e5d3800010fe8f52e"sv}, Entry{"accessor/v1-code.448-512.vi"sv, "5c1f189641bebc20984486683343edcd1ce970ca"sv}, Entry{"accessor/v1-code.512-576.efi"sv, "61220b53b978ceb71cb50d52ad942e18f57ac3be"sv}, Entry{"accessor/v1-code.512-576.vi"sv, "efeb61b9a7f4202212b0aeb13a9fac91cf8482ab"sv}, Entry{"accessor/v1-code.576-640.efi"sv, "f7713935f7074c6aa65da3f778f334342e5926dc"sv}, Entry{"accessor/v1-code.576-640.vi"sv, "0b09e10e9db00ac4d2ed022da31dc091b91a6492"sv}, Entry{"accessor/v1-code.64-128.efi"sv, "5754fc3d30a0c8257e42fecdb1c789f422c56184"sv}, Entry{"accessor/v1-code.64-128.vi"sv, "f323e641afc4f810a05920c97d3bfd8757b165e3"sv}, Entry{"accessor/v1-code.640-704.efi"sv, "9913652f018bf7535d347da00fd62bed408a59e8"sv}, Entry{"accessor/v1-code.640-704.vi"sv, "dd9859a08141fdb0cdd0768f07ef1b31bfbe8f92"sv}, Entry{"accessor/v1-code.704-768.efi"sv, "ad3283a3973e3cb28cbe5a363083b2f5c3a604d8"sv}, Entry{"accessor/v1-code.704-768.vi"sv, "3925fe0bdeeb8b937d1c04a58bd949915b56229e"sv}, Entry{"accessor/v1-code.768-832.efi"sv, "b991f45c04e1865f0e4e27802c98d6b54c1284b9"sv}, Entry{"accessor/v1-code.768-832.vi"sv, "9be863123211e36450ab39cda30efc5f3992efbc"sv}, Entry{"accessor/v1-code.832-896.efi"sv, "4c970803d7a9e487a3a43ba7dbc2d468042455ed"sv}, Entry{"accessor/v1-code.832-896.vi"sv, "ff54352d1e475d78c6ff7290345b8f66d834a2c1"sv}, Entry{"accessor/v1-code.896-960.efi"sv, "a0052fe180a7603f1d99fdb5d394507cf234d295"sv}, Entry{"accessor/v1-code.896-960.vi"sv, "27315aa874a21711fcd3fa142e2f8411923d5616"sv}, Entry{"accessor/v1-code.960-1024.efi"sv, "742fbe76026edf8a32a622aaad116fe670452c0e"sv}, Entry{"accessor/v1-code.960-1024.vi"sv, "04dc634145f8b24333797aa1c84362bcbc22243a"sv}, Entry{"accessor/v1-logaddrs.0-64.efi"sv, "30c923e99f22857418196329a269c0fe7207e25e"sv}, Entry{"accessor/v1-logaddrs.1024-1088.efi"sv, "eec79d5cb7da67b17fa57e968199b608472ea70b"sv}, Entry{"accessor/v1-logaddrs.1088-1152.efi"sv, "4262a22a3fd45993435a662f2e4ccc1e523729c0"sv}, Entry{"accessor/v1-logaddrs.1152-1216.efi"sv, "38613e09d7346f0585ec7af978d8dea7224fa86c"sv}, Entry{"accessor/v1-logaddrs.1216-1280.efi"sv, "0a41b5fcd6cbfaf63a17af43bb2ea75c86fb0c09"sv}, Entry{"accessor/v1-logaddrs.128-192.efi"sv, "dad95a99f15d534c2af661128b24bb548d9912c3"sv}, Entry{"accessor/v1-logaddrs.1280-1344.efi"sv, "7c54012f5d26613bebc54c953077e80c1c1eb179"sv}, Entry{"accessor/v1-logaddrs.1344-1408.efi"sv, "9aa5f9275aef50fc9e06569e5993c6496560992c"sv}, Entry{"accessor/v1-logaddrs.1408-1472.efi"sv, "42465871b5f6444ffb9534ec18b94d2710b757ac"sv}, Entry{"accessor/v1-logaddrs.1472-1536.efi"sv, "21ca2e88f9038553ef92fd61c062ce9cb197e251"sv}, Entry{"accessor/v1-logaddrs.1536-1600.efi"sv, "468996833ab9e9627eaf47e64c53a53bede91b38"sv}, Entry{"accessor/v1-logaddrs.1600-1632.efi"sv, "810c71e31dd4b22695e402debe7c6b5b36ceea08"sv}, Entry{"accessor/v1-logaddrs.1632-1648.efi"sv, "b4eaed11d4a3b00a46246668f4cc285d1c947beb"sv}, Entry{"accessor/v1-logaddrs.1648-1656.efi"sv, "c9267d4b209e1cb5c5f8d7f940c2e6bdbab9a86f"sv}, Entry{"accessor/v1-logaddrs.1656-1660.efi"sv, "a9ea4f7079b528a212412818720e9410fb193775"sv}, Entry{"accessor/v1-logaddrs.192-256.efi"sv, "2b36adb4912fb7a5cc154337edd5cd29627ad1bd"sv}, Entry{"accessor/v1-logaddrs.256-320.efi"sv, "d47283216568422ca67bcc5da38600e2ebd1f744"sv}, Entry{"accessor/v1-logaddrs.320-384.efi"sv, "b79f2902cb3a163dc326a9aa02f369c289169672"sv}, Entry{"accessor/v1-logaddrs.384-448.efi"sv, "fc8d0137202f8d3ba1c194baec4aed2b80e64ea9"sv}, Entry{"accessor/v1-logaddrs.448-512.efi"sv, "281e754288dded1e02fa6f65aa954c835260abd7"sv}, Entry{"accessor/v1-logaddrs.512-576.efi"sv, "6005379d7c0f7143c3a288cbce4b78de4b66898b"sv}, Entry{"accessor/v1-logaddrs.576-640.efi"sv, "9d4d70c94d5d10cac6bcbb79ebcc1ff67deb0736"sv}, Entry{"accessor/v1-logaddrs.64-128.efi"sv, "51b1deee0e62e3a1206ef9efaeb82a31a8fd0f01"sv}, Entry{"accessor/v1-logaddrs.640-704.efi"sv, "21c7beb1859418a6de72000f5c083d701319d7e7"sv}, Entry{"accessor/v1-logaddrs.704-768.efi"sv, "fc30e315f1899491188a9fae250a959f00c9ebab"sv}, Entry{"accessor/v1-logaddrs.768-832.efi"sv, "db065e39caaea105248d85a78956c43d3ce4842b"sv}, Entry{"accessor/v1-logaddrs.832-896.efi"sv, "c5da6819da626257bd18993974884c34b91862f8"sv}, Entry{"accessor/v1-logaddrs.896-960.efi"sv, "6bf22bf942b44bca18fe3cc4f2f20c2cf7f08e6b"sv}, Entry{"accessor/v1-logaddrs.960-1024.efi"sv, "364a367e89a696b1f8cc491560f6fca164c6b99d"sv}, Entry{"accessor/v1-logtopics.0-64.efi"sv, "0add5ffcdbcbf9eb6f10cf3fea62f3fa6f460ae2"sv}, Entry{"accessor/v1-logtopics.1024-1088.efi"sv, "7fdf5e3014ab4d75a7518d52a4815aa8c9b4b9d4"sv}, Entry{"accessor/v1-logtopics.1088-1152.efi"sv, "f1ec564d7c23130e468941a806fbacd8dbb8660b"sv}, Entry{"accessor/v1-logtopics.1152-1216.efi"sv, "5aaf0230bb8f9a78afa14f43c35e9ae44c7faa96"sv}, Entry{"accessor/v1-logtopics.1216-1280.efi"sv, "29b66d70e7f635cda7b4f8e5a65e05507ce78304"sv}, Entry{"accessor/v1-logtopics.128-192.efi"sv, "7f501c55a5c380e7ccde8512342a73f447d416fe"sv}, Entry{"accessor/v1-logtopics.1280-1344.efi"sv, "50fea29b3adc6ef5f91b9478b7cf5b1afea630b3"sv}, Entry{"accessor/v1-logtopics.1344-1408.efi"sv, "9410e92a161eab2e6dc72d8de79115093e9f0f30"sv}, Entry{"accessor/v1-logtopics.1408-1472.efi"sv, "61e87e8bfa32bf6050b7dc0bc47435009462f60d"sv}, Entry{"accessor/v1-logtopics.1472-1536.efi"sv, "9863974ca68cbf7f484d2aad83773489e1c2b061"sv}, Entry{"accessor/v1-logtopics.1536-1600.efi"sv, "d14597fdac304eb48468638eaa78c21e0e6e6088"sv}, Entry{"accessor/v1-logtopics.1600-1632.efi"sv, "37adee9b80d72f497b4a93ee8f645fef03d1527c"sv}, Entry{"accessor/v1-logtopics.1632-1648.efi"sv, "1e38e0f36332ea9a9b46cdfc0cc1a47cf244cd39"sv}, Entry{"accessor/v1-logtopics.1648-1656.efi"sv, "7f164db3e43353c416749c336655c3f9e9700b88"sv}, Entry{"accessor/v1-logtopics.1656-1660.efi"sv, "c6c0fee272ff9b26c99762358b78139cb75bf690"sv}, Entry{"accessor/v1-logtopics.192-256.efi"sv, "28db865ab28d0a993405b28db5de2ae71a109459"sv}, Entry{"accessor/v1-logtopics.256-320.efi"sv, "54bb195f553743f11fa4dd1963eafcb3a699e653"sv}, Entry{"accessor/v1-logtopics.320-384.efi"sv, "2904dfee33b3a44910fcb70cfe65f42f17e88706"sv}, Entry{"accessor/v1-logtopics.384-448.efi"sv, "3a53dfe7b6b1d671c5536dce2726b90afc940112"sv}, Entry{"accessor/v1-logtopics.448-512.efi"sv, "c163d30e0284a83fa3417f22f1a05224f9c0d5bb"sv}, Entry{"accessor/v1-logtopics.512-576.efi"sv, "f253ab7cbe5b5e8a2b2ca02c492bea8b242f55b9"sv}, Entry{"accessor/v1-logtopics.576-640.efi"sv, "1c43aa242774b50b0a4ebf2cbafa3b66c78592f4"sv}, Entry{"accessor/v1-logtopics.64-128.efi"sv, "6afe90b6091d1266d526b677e6f66d5306dc3745"sv}, Entry{"accessor/v1-logtopics.640-704.efi"sv, "122c1f575d726884297ae403fca39c551c930675"sv}, Entry{"accessor/v1-logtopics.704-768.efi"sv, "b7a2bb785b2a9c14eadafb856da2eb60ad4e4a2a"sv}, Entry{"accessor/v1-logtopics.768-832.efi"sv, "71e66da3899704457247abdbddb55491aa1c85ba"sv}, Entry{"accessor/v1-logtopics.832-896.efi"sv, "7aec40a0d4e1d740ee52ff2bb4399785c19231ac"sv}, Entry{"accessor/v1-logtopics.896-960.efi"sv, "886159d15cfc18f912e02c055587374c4250bfb8"sv}, Entry{"accessor/v1-logtopics.960-1024.efi"sv, "fe520fcd15ed800a6fafcf45b46b0534b231e7b2"sv}, Entry{"accessor/v1-receipt.0-64.efi"sv, "2587a97f673f0627e9f792022ea6a909fd5ccf26"sv}, Entry{"accessor/v1-receipt.0-64.vi"sv, "3912d7d5470d879d726b02ff27686149f9fd5202"sv}, Entry{"accessor/v1-receipt.1024-1088.efi"sv, "62c82d3ecee15afd33dc58edb658f0372f5b1e9f"sv}, Entry{"accessor/v1-receipt.1024-1088.vi"sv, "2086ca0bb92b8fc004c982f4377e4b692ee73eda"sv}, Entry{"accessor/v1-receipt.1088-1152.efi"sv, "5ad6f7acd9aef4936fe0b5355c320d3cbd391da8"sv}, Entry{"accessor/v1-receipt.1088-1152.vi"sv, "198563afc602dd56ac1074c65ba0e1197d05fa55"sv}, Entry{"accessor/v1-receipt.1152-1216.efi"sv, "8d242737b9dc615d8a3936c46e0dd2ec695c5b80"sv}, Entry{"accessor/v1-receipt.1152-1216.vi"sv, "64132234ae42ff41097e76e3000988e5757ddf83"sv}, Entry{"accessor/v1-receipt.1216-1280.efi"sv, "5b5d371fe784592ccdbc837ba1a712e83ed08981"sv}, Entry{"accessor/v1-receipt.1216-1280.vi"sv, "4c11fc10263061cdb8037216b2f4a3549870a2c8"sv}, Entry{"accessor/v1-receipt.128-192.efi"sv, "d066a3ac10cf802543172a414dc672038366d90f"sv}, Entry{"accessor/v1-receipt.128-192.vi"sv, "8b5ee07fa65cd1e065f26319f5c9f50cd11a8955"sv}, Entry{"accessor/v1-receipt.1280-1344.efi"sv, "677143de2eb80eef1e4c9fd10f1689e5d30b2a57"sv}, Entry{"accessor/v1-receipt.1280-1344.vi"sv, "9d3f27fcacee0a0c8c74837a76c78fb2d54a151e"sv}, Entry{"accessor/v1-receipt.1344-1408.efi"sv, "cc82efb891f321b8ef51e1bffd1728d961989d12"sv}, Entry{"accessor/v1-receipt.1344-1408.vi"sv, "a2ad336b63fec3d8819ddb27954c2d8f0b2548c7"sv}, Entry{"accessor/v1-receipt.1408-1472.efi"sv, "ad8521c0b896126e736ffb3eb1c94c378beb765f"sv}, Entry{"accessor/v1-receipt.1408-1472.vi"sv, "7add46c504ac9cb56614d5b84866dd621b08324d"sv}, Entry{"accessor/v1-receipt.1472-1536.efi"sv, "b9dcece765cdf2065a7f73a05b36b168ffb06171"sv}, Entry{"accessor/v1-receipt.1472-1536.vi"sv, "04b8b4f74dfdb18e2891f643d8ce34bb2c4e9dd2"sv}, Entry{"accessor/v1-receipt.1536-1552.efi"sv, "ff6c08e3efbc5de8666d32b21a617c6270e94807"sv}, Entry{"accessor/v1-receipt.1536-1552.vi"sv, "4458475b42122d953d4464e9a74b09f678fadf09"sv}, Entry{"accessor/v1-receipt.1552-1554.efi"sv, "f59ba5df632eb9107b51e52a2e89855ac494c45a"sv}, Entry{"accessor/v1-receipt.1552-1554.vi"sv, "a6e92a677963cc608d174cb3e87b9f5b0df1921b"sv}, Entry{"accessor/v1-receipt.1554-1555.efi"sv, "296d10fdb3d5738a655e7eee2cd068210e80f1bb"sv}, Entry{"accessor/v1-receipt.1554-1555.vi"sv, "ba55184346a98fb3fd03488fb89ba7e36632140b"sv}, Entry{"accessor/v1-receipt.1632-1648.efi"sv, "a0af74cdfe69a55beee6ea29b6eed7c2ba1d2f89"sv}, Entry{"accessor/v1-receipt.1632-1648.vi"sv, "a081b17f12df87c70de4a017963b337933d7e284"sv}, Entry{"accessor/v1-receipt.1648-1656.efi"sv, "78c0daf50d63f51d2f499bfb34f475c27c97e8b0"sv}, Entry{"accessor/v1-receipt.1648-1656.vi"sv, "575942fceb32cdb6036f5e466544ea12b88bf63d"sv}, Entry{"accessor/v1-receipt.1656-1660.efi"sv, "a244660965e45e39deaf89ad6d2b4e03d5d4d56c"sv}, Entry{"accessor/v1-receipt.1656-1660.vi"sv, "fe1f3c76dd3d0eb6b5a3e12c99d30903ad8b303d"sv}, Entry{"accessor/v1-receipt.192-256.efi"sv, "427ec825c785c7955c998eb2df3a0a422a935333"sv}, Entry{"accessor/v1-receipt.192-256.vi"sv, "5cd000abc04d82119c6491142f81dde7e65a1a47"sv}, Entry{"accessor/v1-receipt.256-320.efi"sv, "c8b7701caa801f2ce0c73eda7e3a8b609ef0458f"sv}, Entry{"accessor/v1-receipt.256-320.vi"sv, "c673ec7007ce3d3b80a927a8e5b6d53525ad338f"sv}, Entry{"accessor/v1-receipt.320-384.efi"sv, "345ced914bff4ebae0a3bd397f96028c7fef3096"sv}, Entry{"accessor/v1-receipt.320-384.vi"sv, "1c8b963c35a808a2af00cb48c08ae7dbb11655fe"sv}, Entry{"accessor/v1-receipt.384-448.efi"sv, "eb1038dfe2875e125f31cae0a9ce641c3303d80a"sv}, Entry{"accessor/v1-receipt.384-448.vi"sv, "ca9974d1d6ff7c518cb57e27bb63d3dad88faa5d"sv}, Entry{"accessor/v1-receipt.448-512.efi"sv, "fcacca301f2b116a7a67c35568ec6fa97a264751"sv}, Entry{"accessor/v1-receipt.448-512.vi"sv, "248d5647ee66832236a261f661b210421ed55d5b"sv}, Entry{"accessor/v1-receipt.512-576.efi"sv, "86050438c1c8b759e8a1fefe756507accb13959c"sv}, Entry{"accessor/v1-receipt.512-576.vi"sv, "f3bf123c6742e1c19c052162eb2f69b9a3c809a0"sv}, Entry{"accessor/v1-receipt.576-640.efi"sv, "d9e78de52eaea8c7ef1e2f64f88073f5787dcbda"sv}, Entry{"accessor/v1-receipt.576-640.vi"sv, "08a8cc33261f285b1f55fa0765f2a0cdbabb5608"sv}, Entry{"accessor/v1-receipt.64-128.efi"sv, "a934ad1e8212390e6f5d80a32530eec8b960de95"sv}, Entry{"accessor/v1-receipt.64-128.vi"sv, "fb6355afc200050e65aa8c7166593e8ccbf9c34d"sv}, Entry{"accessor/v1-receipt.640-704.efi"sv, "97f45eaeb92dbf26e26f06b408769dea5532bf7a"sv}, Entry{"accessor/v1-receipt.640-704.vi"sv, "1751aa959ddb0f24c484eae779dfdd24ba771021"sv}, Entry{"accessor/v1-receipt.704-768.efi"sv, "dd5dbf8120988c4ea910974f7658c8d288f118a3"sv}, Entry{"accessor/v1-receipt.704-768.vi"sv, "8d3180fe0b258b0870a5cd4dcfaa451976df3c4c"sv}, Entry{"accessor/v1-receipt.768-832.efi"sv, "6dc926b6472f89dc6fb99390a90252ff973d4bda"sv}, Entry{"accessor/v1-receipt.768-832.vi"sv, "37cddf99b28d6baa8947b36fcb0a141332dbedb5"sv}, Entry{"accessor/v1-receipt.832-896.efi"sv, "25aa779aefc7727c026016e1a625a2f504b2700a"sv}, Entry{"accessor/v1-receipt.832-896.vi"sv, "6bb11b7f15e931c5e23bcdd867443b81a735ffe2"sv}, Entry{"accessor/v1-receipt.896-960.efi"sv, "8fa79d50abfb3431bcbc24ee391f21f3c88bd746"sv}, Entry{"accessor/v1-receipt.896-960.vi"sv, "709ca6511d13aaf16100017886edf6190c6f19fc"sv}, Entry{"accessor/v1-receipt.960-1024.efi"sv, "33380488d15e9130fa9394d0da0f6eb345e5394f"sv}, Entry{"accessor/v1-receipt.960-1024.vi"sv, "e2a928d9a846a33602633cad1670307fa8df00ea"sv}, Entry{"accessor/v1-storage.0-64.efi"sv, "1c358be9659b9191112d1acb948341bcd834b089"sv}, Entry{"accessor/v1-storage.0-64.vi"sv, "709574cd6eb48e1b3486e428780b000e402a5d76"sv}, Entry{"accessor/v1-storage.1024-1088.efi"sv, "077802e38717ccbce9f3fd32f48e927c3f7f48b7"sv}, Entry{"accessor/v1-storage.1024-1088.vi"sv, "4d3aa39de3c79da9d4f384b2cffbee0776fd8341"sv}, Entry{"accessor/v1-storage.1088-1152.efi"sv, "2ca391a29d92f7fc7e0aad6262e5bc180fa5d8b5"sv}, Entry{"accessor/v1-storage.1088-1152.vi"sv, "82c1ddaeccf3d71b538bb4668f2bd3b0350dd3fb"sv}, Entry{"accessor/v1-storage.1152-1216.efi"sv, "6743011f0a09ef1558fd205c29cfbede4b161555"sv}, Entry{"accessor/v1-storage.1152-1216.vi"sv, "94a8d6c9a7b5996f88903beb00c968498562faf2"sv}, Entry{"accessor/v1-storage.1216-1280.efi"sv, "f08debee23f0b0bffca20ff4ab47b900af400cd9"sv}, Entry{"accessor/v1-storage.1216-1280.vi"sv, "045a9701aab1bb0efbf80d05a31e6b0cae76fb1b"sv}, Entry{"accessor/v1-storage.128-192.efi"sv, "232d9f71374261cecccd1c5efe038aca7bcae01b"sv}, Entry{"accessor/v1-storage.128-192.vi"sv, "daa62ea88c3bbdd894c4aff9a5d35aa500b7ac57"sv}, Entry{"accessor/v1-storage.1280-1344.efi"sv, "097dd94d5b30a14f27926493f5a728d88b4e1c1a"sv}, Entry{"accessor/v1-storage.1280-1344.vi"sv, "80ffd6cfc24f8f92564fc2ce8349764bf60922f7"sv}, Entry{"accessor/v1-storage.1344-1408.efi"sv, "ae2430824a08899d1dc13377e55ed314f9df7145"sv}, Entry{"accessor/v1-storage.1344-1408.vi"sv, "c6ccdf81675b9c8574fc7ad9203e72793cf48955"sv}, Entry{"accessor/v1-storage.1408-1472.efi"sv, "76770756a4ebf0b2898549a3c5473cab128df024"sv}, Entry{"accessor/v1-storage.1408-1472.vi"sv, "7b4b3621b53e10022c588a5f2f95029cae6da79a"sv}, Entry{"accessor/v1-storage.1472-1536.efi"sv, "ccd2d71072a3b326f61d65a65dbb6b74a0e3cae7"sv}, Entry{"accessor/v1-storage.1472-1536.vi"sv, "f388e439152261abd016bdf86683ab2f1536068d"sv}, Entry{"accessor/v1-storage.1536-1600.efi"sv, "6881a440cd4a254f433d01e4ae6691069b864c80"sv}, Entry{"accessor/v1-storage.1536-1600.vi"sv, "cc64a2e9a8c40601263009da22229680b205ecbf"sv}, Entry{"accessor/v1-storage.1600-1632.efi"sv, "470157497c9b191e1627814c8df539d0445c0732"sv}, Entry{"accessor/v1-storage.1600-1632.vi"sv, "f6853b90c4147007f923b0a579d75237c5cda75e"sv}, Entry{"accessor/v1-storage.1632-1648.efi"sv, "e9a82ea9b0274b474b81a21a89aa242ea66aebc8"sv}, Entry{"accessor/v1-storage.1632-1648.vi"sv, "92654ddf6c4eeb9f8c1960a81933bb312a721309"sv}, Entry{"accessor/v1-storage.1648-1656.efi"sv, "1818ff1341d3bd4372f2e7d7f8ad2518b592350e"sv}, Entry{"accessor/v1-storage.1648-1656.vi"sv, "8642b4923965caf9365a75c15c328877ce44399e"sv}, Entry{"accessor/v1-storage.1656-1660.efi"sv, "b917ea4e9e8e1779b94b8f6794090b62607eaf10"sv}, Entry{"accessor/v1-storage.1656-1660.vi"sv, "ec4f3f9585b98cebf7be8ca679c21d168acf71ae"sv}, Entry{"accessor/v1-storage.192-256.efi"sv, "778dab2a9e2a64d360e3e77506026605c2130a2e"sv}, Entry{"accessor/v1-storage.192-256.vi"sv, "05046abbd3579a2cc0911d9c8ed86ff49853dc40"sv}, Entry{"accessor/v1-storage.256-320.efi"sv, "32984c33db94b1c0bcde9f2f61f44ffbee7376b3"sv}, Entry{"accessor/v1-storage.256-320.vi"sv, "5f4bf04ca982b576e1ef206ab72248e47cb64505"sv}, Entry{"accessor/v1-storage.320-384.efi"sv, "c9021076540f54082b9ac34d4d74a914c4f253b3"sv}, Entry{"accessor/v1-storage.320-384.vi"sv, "efc65945b2816e4f07c527f249974dda9fcace0a"sv}, Entry{"accessor/v1-storage.384-448.efi"sv, "4a72f31ae8a2e8ab62ebc17c5f566c23df884acf"sv}, Entry{"accessor/v1-storage.384-448.vi"sv, "2bf5b1a9055287b50a46f42de9824b64ea89f8f3"sv}, Entry{"accessor/v1-storage.448-512.efi"sv, "ac663eb0133f1733215d8b9566b80be9c71a7ee0"sv}, Entry{"accessor/v1-storage.448-512.vi"sv, "afa30b69507a6b8494d33aae2e5f1a18d625be79"sv}, Entry{"accessor/v1-storage.512-576.efi"sv, "e2b1e614b9709a3f5f7deedb304c44c6f2285a73"sv}, Entry{"accessor/v1-storage.512-576.vi"sv, "1178ea05d32b1392a6d8a6395a85f5d9c73f7c2f"sv}, Entry{"accessor/v1-storage.576-640.efi"sv, "61327c986c9afffc3378a886cb03b09d2430922d"sv}, Entry{"accessor/v1-storage.576-640.vi"sv, "b99b19233be7047b4d4fc784aad4a3790a754810"sv}, Entry{"accessor/v1-storage.64-128.efi"sv, "84f6b1beb5c307acefc83fc54427056d74ec5bb5"sv}, Entry{"accessor/v1-storage.64-128.vi"sv, "9c932dae5b047c662b9a2c80dce3c0285734bc3e"sv}, Entry{"accessor/v1-storage.640-704.efi"sv, "5faec34506001901074e42089a7247f6f518a8e4"sv}, Entry{"accessor/v1-storage.640-704.vi"sv, "84767549084453e738b0feb4aa91066d707a90d0"sv}, Entry{"accessor/v1-storage.704-768.efi"sv, "4c9a1ad74bba37fe17ab27887d18b30245b1852e"sv}, Entry{"accessor/v1-storage.704-768.vi"sv, "72d6ad60e277201fd431865bf0c9f569ef3fa11c"sv}, Entry{"accessor/v1-storage.768-832.efi"sv, "aefe603080b7f70207da64872cd4f7d7f772b365"sv}, Entry{"accessor/v1-storage.768-832.vi"sv, "9c2d9bbe0bf07882a24d020c8baab748928853ce"sv}, Entry{"accessor/v1-storage.832-896.efi"sv, "88bedfa6902dd04e0b7130d21a8b6892f81c783d"sv}, Entry{"accessor/v1-storage.832-896.vi"sv, "41337a84956eed97ca73ac11e41d20e4805cfdb4"sv}, Entry{"accessor/v1-storage.896-960.efi"sv, "04d2f0d4f8279b73f00b573a1bbf8af46c2c1af2"sv}, Entry{"accessor/v1-storage.896-960.vi"sv, "12237a36e6c7fe1b66c1d0aefe4c1c209f6e870e"sv}, Entry{"accessor/v1-storage.960-1024.efi"sv, "2e20eae910e80ebfd616c865211b32248c8dd2d1"sv}, Entry{"accessor/v1-storage.960-1024.vi"sv, "18918e577a8a12664a5e27cc3d5bba8339f59a3a"sv}, Entry{"accessor/v1-tracesfrom.0-64.efi"sv, "c7c84f20b56e435595948d368e2e4ef17230d393"sv}, Entry{"accessor/v1-tracesfrom.1024-1088.efi"sv, "e92c92eaf0f0b941fff122c57e4a540089b5529e"sv}, Entry{"accessor/v1-tracesfrom.1088-1152.efi"sv, "f058992e4f768608d2b62f6a78fdb10dcd1a1e06"sv}, Entry{"accessor/v1-tracesfrom.1152-1216.efi"sv, "f8aba95c9b8378e8695ac19a1c4d96c5f326786c"sv}, Entry{"accessor/v1-tracesfrom.1216-1280.efi"sv, "672874875488630cf9280db70469e670335f1c59"sv}, Entry{"accessor/v1-tracesfrom.128-192.efi"sv, "b96ace7c77a8fa3a6bb1c2802a969cb85ca03a50"sv}, Entry{"accessor/v1-tracesfrom.1280-1344.efi"sv, "7476db28a8b9102b6c354ddbc55721fe0e5c92a4"sv}, Entry{"accessor/v1-tracesfrom.1344-1408.efi"sv, "5f9a756686d03ad4c484d21ac846eee1f8604a2c"sv}, Entry{"accessor/v1-tracesfrom.1408-1472.efi"sv, "6c0bd5340e8e42ac49bc45b189ead492c4d3d31c"sv}, Entry{"accessor/v1-tracesfrom.1472-1536.efi"sv, "45b68794d3ef18406904e2597493a2f1e373b34a"sv}, Entry{"accessor/v1-tracesfrom.1536-1600.efi"sv, "af2f43e107c4182a41f72173647633719da227a5"sv}, Entry{"accessor/v1-tracesfrom.1600-1632.efi"sv, "707e146639048ad6dfe61c19f2c750c80f775dde"sv}, Entry{"accessor/v1-tracesfrom.1632-1648.efi"sv, "8c39e69d1d0f904dfdb76287f775cab8e940d8a8"sv}, Entry{"accessor/v1-tracesfrom.1648-1656.efi"sv, "99e0862994ae65a2cf7012e6b062f17851fc71bb"sv}, Entry{"accessor/v1-tracesfrom.1656-1660.efi"sv, "dd81e7b7cc3fcd56e16fc2afbb8f79d59bbdbd1d"sv}, Entry{"accessor/v1-tracesfrom.192-256.efi"sv, "13b875cf4c0d166c66c9528c9011339500275924"sv}, Entry{"accessor/v1-tracesfrom.256-320.efi"sv, "f4f0b1e2af1142bded6bff1d180b1c85320b8eb6"sv}, Entry{"accessor/v1-tracesfrom.320-384.efi"sv, "6b374a197038bf5571d046d079c57d587dd84a83"sv}, Entry{"accessor/v1-tracesfrom.384-448.efi"sv, "e1ccb2c6cf0328fde4430a13536df1b0ce006661"sv}, Entry{"accessor/v1-tracesfrom.448-512.efi"sv, "b4487e93b53b618c00e25229b352dfc2a186e8d3"sv}, Entry{"accessor/v1-tracesfrom.512-576.efi"sv, "3ec5f03d59c39ffb49c0943e4381523a88c25ca8"sv}, Entry{"accessor/v1-tracesfrom.576-640.efi"sv, "df02d35cd472bb471310b21d007e73f6c05e66fd"sv}, Entry{"accessor/v1-tracesfrom.64-128.efi"sv, "3cc84e77dd8bac898adfcafea7e3cf8c08546f8c"sv}, Entry{"accessor/v1-tracesfrom.640-704.efi"sv, "fb0d1f2a32545ee024d785c45adc0f5773af5a11"sv}, Entry{"accessor/v1-tracesfrom.704-768.efi"sv, "726281d53d2718f8370e1955500c3e9ce82beb2c"sv}, Entry{"accessor/v1-tracesfrom.768-832.efi"sv, "63e0967ecb6f11f19f81c01cfc510f62f236cf3a"sv}, Entry{"accessor/v1-tracesfrom.832-896.efi"sv, "dd8beeefcc5c4a98165af0ab27de3d7b58977a19"sv}, Entry{"accessor/v1-tracesfrom.896-960.efi"sv, "6865bd12123a91c094cbe71c4ecca221736596a3"sv}, Entry{"accessor/v1-tracesfrom.960-1024.efi"sv, "f41812b05de78563c134b36f93daa61d02d15caf"sv}, Entry{"accessor/v1-tracesto.0-64.efi"sv, "cb8f8771dfe8ee1a2b0aa5133da53633a7266b6e"sv}, Entry{"accessor/v1-tracesto.1024-1088.efi"sv, "011c00c02000205a17892664d053fc9d4e3efe20"sv}, Entry{"accessor/v1-tracesto.1088-1152.efi"sv, "426f34afed3d69e5347d4e237d5ccf6b426f1cac"sv}, Entry{"accessor/v1-tracesto.1152-1216.efi"sv, "7b6d00761dab4678240917bab682d7d06b80a76d"sv}, Entry{"accessor/v1-tracesto.1216-1280.efi"sv, "c6df52f606398a9bca43d5f5f06a79d507e22900"sv}, Entry{"accessor/v1-tracesto.128-192.efi"sv, "813e0bda7e83eec755d89eb5a2724ee134bc3eb5"sv}, Entry{"accessor/v1-tracesto.1280-1344.efi"sv, "2bc921ebaf1f1a6ec3e608628c1923ce796f3479"sv}, Entry{"accessor/v1-tracesto.1344-1408.efi"sv, "2e8112c3b33fa9bf34dda40647a3c51f3325722e"sv}, Entry{"accessor/v1-tracesto.1408-1472.efi"sv, "b90572bc30a8acfec37b6444394092fbc7dcbb69"sv}, Entry{"accessor/v1-tracesto.1472-1536.efi"sv, "d0fcd1573ded7d34092df3d736fa4134f9691f88"sv}, Entry{"accessor/v1-tracesto.1536-1600.efi"sv, "97d01359e10c8ae0e711d1b46eed31084da9e446"sv}, Entry{"accessor/v1-tracesto.1600-1632.efi"sv, "91094ba0a011b4bfbebadfa1f1058d1d695d4036"sv}, Entry{"accessor/v1-tracesto.1632-1648.efi"sv, "7656ff04b4b35157c80dd2f50f9b25d9e65a881c"sv}, Entry{"accessor/v1-tracesto.1648-1656.efi"sv, "ce8a70b71247b6dc73f621dc3d9275c50b6b7eb5"sv}, Entry{"accessor/v1-tracesto.1656-1660.efi"sv, "0581a374525d4ccc6858f29c7bfc4fa75dae2b97"sv}, Entry{"accessor/v1-tracesto.192-256.efi"sv, "77c4e74375841574c142bac6aaff9935eaa0c84b"sv}, Entry{"accessor/v1-tracesto.256-320.efi"sv, "5f90765a393e398bf18001ca69f0bab7300e127d"sv}, Entry{"accessor/v1-tracesto.320-384.efi"sv, "6b44aea6ea7d9f9039a1f261a240e2e2ac4b6078"sv}, Entry{"accessor/v1-tracesto.384-448.efi"sv, "7f95cd43fc6f173a54e6cee4002310dcbbb2d2a5"sv}, Entry{"accessor/v1-tracesto.448-512.efi"sv, "3ca9d8743680f3f1bef5d38eedd7660b10a9e50d"sv}, Entry{"accessor/v1-tracesto.512-576.efi"sv, "cd04c510017b0735e044a197ed7a1d84763e8fd8"sv}, Entry{"accessor/v1-tracesto.576-640.efi"sv, "9692b96c7edc4aea87fe28b0032b3cce13aa2fdf"sv}, Entry{"accessor/v1-tracesto.64-128.efi"sv, "b5ed650e16b7b2f92dff66be09ea95a45127c5bf"sv}, Entry{"accessor/v1-tracesto.640-704.efi"sv, "865f7df23ae762c3dc04cead870879e5c5789529"sv}, Entry{"accessor/v1-tracesto.704-768.efi"sv, "d5178085e70d734a3597fec3aa73d494562b8912"sv}, Entry{"accessor/v1-tracesto.768-832.efi"sv, "e0a4857a66444b8bfc70d0f17369a20a515a9d25"sv}, Entry{"accessor/v1-tracesto.832-896.efi"sv, "017ed685042b5fc8eec147e80753c59dce11ae48"sv}, Entry{"accessor/v1-tracesto.896-960.efi"sv, "fac4a5411a1af632c9047f31b82e5cf1db880767"sv}, Entry{"accessor/v1-tracesto.960-1024.efi"sv, "af14b5cb4acb040daa27be3b3d603156b6d51017"sv}, Entry{"domain/v1-accounts.0-1024.bt"sv, "cfa2a23c2fdcc6a0d3d1c1f604e6b4774300a9f1"sv}, Entry{"domain/v1-accounts.0-1024.kv"sv, "8bbe22b7ffbb7531fc34c5bc0ca58fcf2de6843a"sv}, Entry{"domain/v1-accounts.0-1024.kvei"sv, "0963196bf3bf2b6c962cbdd6d1b1fc7c85b90f43"sv}, Entry{"domain/v1-accounts.1024-1536.bt"sv, "39f59c2f2b64bc432bcddc1fcd981687559dda59"sv}, Entry{"domain/v1-accounts.1024-1536.kv"sv, "b75650a07a685f6e6df3781951a61bc6eee20c22"sv}, Entry{"domain/v1-accounts.1024-1536.kvei"sv, "db6830348be637b02e2d02fcd5078c1c9272a80e"sv}, Entry{"domain/v1-accounts.1536-1600.bt"sv, "baa9095f200bf332078df0aea6004bf7d5fdba3f"sv}, Entry{"domain/v1-accounts.1536-1600.kv"sv, "b29586a13490c282200db39c0c6d0edf030c7aaf"sv}, Entry{"domain/v1-accounts.1536-1600.kvei"sv, "346432a1b3963db392f05bf4f891e3472f184fcc"sv}, Entry{"domain/v1-accounts.1600-1632.bt"sv, "0454cf29f2e4f527c76aab0b058e5c79713c2ed7"sv}, Entry{"domain/v1-accounts.1600-1632.kv"sv, "86577963be8756c9e040e42af1356a9d8725d16b"sv}, Entry{"domain/v1-accounts.1600-1632.kvei"sv, "f60e43b8a14aa1f594cd42a1a70e9d1bc13ee39c"sv}, Entry{"domain/v1-accounts.1632-1648.bt"sv, "ff4792a9cc4abea47a0501b64556093962b112d6"sv}, Entry{"domain/v1-accounts.1632-1648.kv"sv, "445ef98d4a0614e304bc9303d7b8cf43e3bc2215"sv}, Entry{"domain/v1-accounts.1632-1648.kvei"sv, "1bf64a9f5b6ef4382c4a463a4115cbd1fdbc6826"sv}, Entry{"domain/v1-accounts.1648-1656.bt"sv, "5746fac19a32961f8fb37b129d06bc52c8f5698f"sv}, Entry{"domain/v1-accounts.1648-1656.kv"sv, "f9c9e150ea82d42fe9b4d65c6363aef7bb65045a"sv}, Entry{"domain/v1-accounts.1648-1656.kvei"sv, "34e38f43e12200999df875d996f374a3f45d8615"sv}, Entry{"domain/v1-accounts.1656-1660.bt"sv, "f76879f4860a92d3a414d5909749952523f206fc"sv}, Entry{"domain/v1-accounts.1656-1660.kv"sv, "ea2016ebe1a810893ed6c81e77976245fcbf60e8"sv}, Entry{"domain/v1-accounts.1656-1660.kvei"sv, "3dd2d9d07e0d6fa84850d9b04645d7f78f4488bc"sv}, Entry{"domain/v1-code.0-1024.bt"sv, "144163f30b34bbdb56d4cca09406064874413faa"sv}, Entry{"domain/v1-code.0-1024.kv"sv, "4db69e01336545ac6384fe5c94240af610d65783"sv}, Entry{"domain/v1-code.0-1024.kvei"sv, "6087473d01eecf346435a94e692ecc6cb6639628"sv}, Entry{"domain/v1-code.1024-1536.bt"sv, "2b1779724de5ef16de11572b2414d3d21031e858"sv}, Entry{"domain/v1-code.1024-1536.kv"sv, "3884fbb46fda965fa8d100809a4cb12db6baa4af"sv}, Entry{"domain/v1-code.1024-1536.kvei"sv, "075f02b33d350bcc7c3b8feef3e76d7957fedd58"sv}, Entry{"domain/v1-code.1536-1600.bt"sv, "f6eaae45fb83f41b1f5068e97fe39518f435466e"sv}, Entry{"domain/v1-code.1536-1600.kv"sv, "bfcafa8cc91bf75643ff9d8d92bf5b0e7a02dd42"sv}, Entry{"domain/v1-code.1536-1600.kvei"sv, "0e904c79b93eda4cbe56ef36fcd2376aa8ca231d"sv}, Entry{"domain/v1-code.1600-1632.bt"sv, "2dd856c6afff576dd336794abbc1f92a82f3efe3"sv}, Entry{"domain/v1-code.1600-1632.kv"sv, "a9ecd059cde2d235bb629dc58efd65fce615a010"sv}, Entry{"domain/v1-code.1600-1632.kvei"sv, "19711e32ec1be51694cdbef374aaf2502d741d42"sv}, Entry{"domain/v1-code.1632-1648.bt"sv, "8a65867001c5f6a19a131c8a032bd616ff830520"sv}, Entry{"domain/v1-code.1632-1648.kv"sv, "a5cac685cd437efcce0d7900bf694749426d11b4"sv}, Entry{"domain/v1-code.1632-1648.kvei"sv, "fa0145bca97a02b1704eb2030eea37745943164a"sv}, Entry{"domain/v1-code.1648-1656.bt"sv, "c527e20920ee6f1b72c1ac9ac507421990e13781"sv}, Entry{"domain/v1-code.1648-1656.kv"sv, "95cc864713e65c8ad78d323f2444a59148936d97"sv}, Entry{"domain/v1-code.1648-1656.kvei"sv, "0062b6a1658b0719ad298d394e7fe03000c3d576"sv}, Entry{"domain/v1-code.1656-1660.bt"sv, "6816cbba872dc07ba5b70a48f2738be1d7e02ed6"sv}, Entry{"domain/v1-code.1656-1660.kv"sv, "c2b59079a758f031634c2e0cc498924b2cfcaa1c"sv}, Entry{"domain/v1-code.1656-1660.kvei"sv, "0721c8b6c14ededdfff73ea676577540ba97a165"sv}, Entry{"domain/v1-commitment.0-1024.bt"sv, "42bc266fbd927f590ce46734da4f8ba07cf50f8d"sv}, Entry{"domain/v1-commitment.0-1024.kv"sv, "c2193bde00469b9e910f1e3e2b8e19f271e4d134"sv}, Entry{"domain/v1-commitment.0-1024.kvei"sv, "c297f35863e4f94df2f667fc205105b345078fc5"sv}, Entry{"domain/v1-commitment.1024-1536.bt"sv, "850559907a34b40c2d40813439153f5a2c2a9a5c"sv}, Entry{"domain/v1-commitment.1024-1536.kv"sv, "010a283bca95f2210041166633856db5148c9999"sv}, Entry{"domain/v1-commitment.1024-1536.kvei"sv, "add1f634380ffa97f1f9e497e9baa3afcc227008"sv}, Entry{"domain/v1-commitment.1536-1600.bt"sv, "0aaee09251800828a210e839cc66cb534d345146"sv}, Entry{"domain/v1-commitment.1536-1600.kv"sv, "b784e42c325026aaf5aaa929bb8aa25fcf912d6e"sv}, Entry{"domain/v1-commitment.1536-1600.kvei"sv, "8e89da1957edf81fedcf6ef5d71ac045d7da6372"sv}, Entry{"domain/v1-commitment.1600-1632.bt"sv, "2f90e0e7340bc3bb71b2b7121700ca4097a04eae"sv}, Entry{"domain/v1-commitment.1600-1632.kv"sv, "af8a762f704ae9f5fb18aa2c69614a86f32fadb0"sv}, Entry{"domain/v1-commitment.1600-1632.kvei"sv, "33146b424ccf91e3a86b4a20bd976c093c8a8d66"sv}, Entry{"domain/v1-commitment.1632-1648.bt"sv, "872f0f3b60c7496bc631e94e1d0439dce7ee23c9"sv}, Entry{"domain/v1-commitment.1632-1648.kv"sv, "84db7d3a7124296822efcd59832c8d8db82a4aa1"sv}, Entry{"domain/v1-commitment.1632-1648.kvei"sv, "2e5f72db8659943cf6e303ecb83c4e09fff3fee0"sv}, Entry{"domain/v1-commitment.1648-1656.bt"sv, "b87907ef205b301eb6d59b0a720f76dcf0523959"sv}, Entry{"domain/v1-commitment.1648-1656.kv"sv, "4eac8bdfd9f38ba5f49347c14d83192b5cfc4aee"sv}, Entry{"domain/v1-commitment.1648-1656.kvei"sv, "8ee77c37219e2ac8261489a54bd952f1fbb1ab59"sv}, Entry{"domain/v1-commitment.1656-1660.bt"sv, "78ee8bfeb00ddf41ba517053195be070c4ab791a"sv}, Entry{"domain/v1-commitment.1656-1660.kv"sv, "d6f0069822d37a078c509e6cec945838cb40814d"sv}, Entry{"domain/v1-commitment.1656-1660.kvei"sv, "4e82eb152e7282e9ff0f8e2ef959ba790c6b71a1"sv}, Entry{"domain/v1-receipt.0-1024.bt"sv, "5c3a0627b9f1517aa998c3e8c126e5e6b3ce7665"sv}, Entry{"domain/v1-receipt.0-1024.kv"sv, "5eed351ef984645049e6cdbfe5c83503db3ac3f4"sv}, Entry{"domain/v1-receipt.0-1024.kvei"sv, "5d442031fc6909c53c2da69531e00a810840c12a"sv}, Entry{"domain/v1-receipt.1024-1536.bt"sv, "719e2ec7e16a8f607f66403e1958c23d71a6256f"sv}, Entry{"domain/v1-receipt.1024-1536.kv"sv, "069498be27f2d88d2cdf3e5995cc44bd3b4bd1ca"sv}, Entry{"domain/v1-receipt.1024-1536.kvei"sv, "262645336f96ce09f3ac5785aa1b98bffcbb328c"sv}, Entry{"domain/v1-receipt.1536-1552.bt"sv, "0f309dcfb76b7d6b49b4405c39bed930c9d0d4f3"sv}, Entry{"domain/v1-receipt.1536-1552.kv"sv, "2b1a81dd9d4891a5f9c2234ef556118af0d074e6"sv}, Entry{"domain/v1-receipt.1536-1552.kvei"sv, "02a8e4a220a6ab187e0bf74e3b0232727323ad26"sv}, Entry{"domain/v1-receipt.1552-1554.bt"sv, "f5f008e2fe8c6499c9e5e7dbcbb8e6d4967c8afa"sv}, Entry{"domain/v1-receipt.1552-1554.kv"sv, "376e1ff65bc078de4ecd21203314af25a557949d"sv}, Entry{"domain/v1-receipt.1552-1554.kvei"sv, "c0d391aa571c16660aa922bb44fcc7e04076747a"sv}, Entry{"domain/v1-receipt.1554-1555.bt"sv, "d8fd32231004b15c3e45341fc248b664a12aacea"sv}, Entry{"domain/v1-receipt.1554-1555.kv"sv, "6631abd1309a03c4aa58823eb80f3b2e2442233b"sv}, Entry{"domain/v1-receipt.1554-1555.kvei"sv, "418843d2c1388df50602b7c3808e0d8124ce60d5"sv}, Entry{"domain/v1-receipt.1632-1648.bt"sv, "07f13134df8c75808685617207dcf70a84789503"sv}, Entry{"domain/v1-receipt.1632-1648.kv"sv, "5deac15de85943b5c5b1872bd0e823d37728f91e"sv}, Entry{"domain/v1-receipt.1632-1648.kvei"sv, "92adc1ee5c0266e431b8849c60ae7448d5bb8780"sv}, Entry{"domain/v1-receipt.1648-1656.bt"sv, "80719a7c4f5ec98ba8906daa875cd33634f5a8bf"sv}, Entry{"domain/v1-receipt.1648-1656.kv"sv, "41db8669ef4078e9d58f7e6bcb955472490d4d60"sv}, Entry{"domain/v1-receipt.1648-1656.kvei"sv, "fece440226e44cc0ee631c1b9d73d698f472e24f"sv}, Entry{"domain/v1-receipt.1656-1660.bt"sv, "1cc566cd4da1447fa42ab52987effa72f21340bc"sv}, Entry{"domain/v1-receipt.1656-1660.kv"sv, "660dc419136ed5b89cb2340be465fdaefc98bb12"sv}, Entry{"domain/v1-receipt.1656-1660.kvei"sv, "5f91fead7b3bb2b4ba4de8297848853cc8858967"sv}, Entry{"domain/v1-storage.0-1024.bt"sv, "84b3cd2ab0be41179fb92d94a573311e34d996e8"sv}, Entry{"domain/v1-storage.0-1024.kv"sv, "b01fd2c9bdfbe1ffa16db0f4871ed3eea85816b3"sv}, Entry{"domain/v1-storage.0-1024.kvei"sv, "f62ec238ff307a2c54b52411bc0bb95a85b67a62"sv}, Entry{"domain/v1-storage.1024-1536.bt"sv, "a4fa0863de6cd3ecfcea89ab2e344c663776d66b"sv}, Entry{"domain/v1-storage.1024-1536.kv"sv, "d97d030ae9ba703ce4279c78e9ad726570741e53"sv}, Entry{"domain/v1-storage.1024-1536.kvei"sv, "397a748dbd2337b9aa166f15e4af46b08f4cc9fe"sv}, Entry{"domain/v1-storage.1536-1600.bt"sv, "214b8b768c71e7437ec262c0cd20dbf3b825181f"sv}, Entry{"domain/v1-storage.1536-1600.kv"sv, "d820f4eff128c3e5d8bb592ce66bd823627dc93b"sv}, Entry{"domain/v1-storage.1536-1600.kvei"sv, "09bf9fcf9852c6927ac84caceef209e57f6748b0"sv}, Entry{"domain/v1-storage.1600-1632.bt"sv, "d2bf9e96b3589f5642742b0bf40b1d674318cbcb"sv}, Entry{"domain/v1-storage.1600-1632.kv"sv, "27a1bc4fda6f75beb7e384cd29e9eee3598b517e"sv}, Entry{"domain/v1-storage.1600-1632.kvei"sv, "5fe4b9b60753ea0012cfa3b49bd60eb6f339533f"sv}, Entry{"domain/v1-storage.1632-1648.bt"sv, "7e735a2617bc9abf4bfe97cbcdd1280a282da791"sv}, Entry{"domain/v1-storage.1632-1648.kv"sv, "59e2523d5e146c0a0439120b083349d9ef411442"sv}, Entry{"domain/v1-storage.1632-1648.kvei"sv, "078f29afb17be19375dc86ed71f90c311742b587"sv}, Entry{"domain/v1-storage.1648-1656.bt"sv, "9afe9972b5bb424d298031aafe319bf3e9df34a9"sv}, Entry{"domain/v1-storage.1648-1656.kv"sv, "915c9e5435e728168a31614851a52a7edbf3e158"sv}, Entry{"domain/v1-storage.1648-1656.kvei"sv, "1633ca0b3e134cc72146362709cca6bdc70b9cae"sv}, Entry{"domain/v1-storage.1656-1660.bt"sv, "eb9f95c0941216d881ff59acda8fa0f750a67323"sv}, Entry{"domain/v1-storage.1656-1660.kv"sv, "8638004750f6266e400447e087ac0673cb9c3e8c"sv}, Entry{"domain/v1-storage.1656-1660.kvei"sv, "378b89eddab3501acad066f475c1d742b3be3f71"sv}, Entry{"history/v1-accounts.0-64.v"sv, "238eb7b044f929d76957bc09e969ee20082cbb5a"sv}, Entry{"history/v1-accounts.1024-1088.v"sv, "689f9920430f39bf038de812b828914139d77e9d"sv}, Entry{"history/v1-accounts.1088-1152.v"sv, "d560fed1b26a82c4dccc4fcae20ea16b873d1018"sv}, Entry{"history/v1-accounts.1152-1216.v"sv, "2c5cf27d8975e5aab0169bdb3868bdb6536820aa"sv}, Entry{"history/v1-accounts.1216-1280.v"sv, "025071d713f48be0edcd260587492bd8cad0d75d"sv}, Entry{"history/v1-accounts.128-192.v"sv, "244f849535f61a2d036a85daa2123d95190ff23f"sv}, Entry{"history/v1-accounts.1280-1344.v"sv, "f7dc7fdb8d04002873b7f82fd444b0a3714f10c7"sv}, Entry{"history/v1-accounts.1344-1408.v"sv, "6ec1d2a75133b1475075f2f3372981960424acbc"sv}, Entry{"history/v1-accounts.1408-1472.v"sv, "768faa91d5a44bb268c6067826fb7616b1d54f22"sv}, Entry{"history/v1-accounts.1472-1536.v"sv, "65ee1a574c475466cf1c4c26a1f73a02d36c590d"sv}, Entry{"history/v1-accounts.1536-1600.v"sv, "8ed5a46bc24dde168dd1c1f01b1d5eb589466597"sv}, Entry{"history/v1-accounts.1600-1632.v"sv, "57b900836b5a9848d84e79874e4f4694a7b0f40a"sv}, Entry{"history/v1-accounts.1632-1648.v"sv, "1c849c0f0f84cd4cb0251f8357279ef3d4f43409"sv}, Entry{"history/v1-accounts.1648-1656.v"sv, "66cf318545308b7b5ddae4bfc885a4b4dbc49c73"sv}, Entry{"history/v1-accounts.1656-1660.v"sv, "3dea74ae3d63c94ae9f8d43679cd53b53ba28b2e"sv}, Entry{"history/v1-accounts.192-256.v"sv, "7f79d974e236f0cfb3f325e2a007256e6e2f16af"sv}, Entry{"history/v1-accounts.256-320.v"sv, "6c7eba40888ed6e86eb1dd611b139a7eea24a5c1"sv}, Entry{"history/v1-accounts.320-384.v"sv, "73ced8c3c2baf0f050d688c643fe6dfe36043841"sv}, Entry{"history/v1-accounts.384-448.v"sv, "f031409a8d3a7ccad561cddcfd00632157e39482"sv}, Entry{"history/v1-accounts.448-512.v"sv, "fc49f08619a2ebad8f6cd83044243a8ae9b07551"sv}, Entry{"history/v1-accounts.512-576.v"sv, "62365feac294ebf2d4138bffc7738a44b42878cf"sv}, Entry{"history/v1-accounts.576-640.v"sv, "a45259b363efb7eca2be12837382a5c8cecaf887"sv}, Entry{"history/v1-accounts.64-128.v"sv, "a87e6ca5cb83a29d0900a4080157f9a1b4dc02a0"sv}, Entry{"history/v1-accounts.640-704.v"sv, "04fb74e29d9787389c5455d6cde3e4ca61afdd8f"sv}, Entry{"history/v1-accounts.704-768.v"sv, "5fd326e0f33f8bb939532417906de5b04856b0c4"sv}, Entry{"history/v1-accounts.768-832.v"sv, "98d5b8c68c6dedb452ec19d6d506f63f9b9f0b7e"sv}, Entry{"history/v1-accounts.832-896.v"sv, "36b680d7058d1d40f0e65e84b56acd7709714457"sv}, Entry{"history/v1-accounts.896-960.v"sv, "7ddcfd02c2c3f24a9f3b16cd8420acfaf1d876b9"sv}, Entry{"history/v1-accounts.960-1024.v"sv, "35c570fde1cf8d80189e307782bfab04a5f31030"sv}, Entry{"history/v1-code.0-64.v"sv, "f1c8ff82b84110d4f864043d49facb1db644dff1"sv}, Entry{"history/v1-code.1024-1088.v"sv, "7be11820a4475a051e44b99b7d8df3e517ecf654"sv}, Entry{"history/v1-code.1088-1152.v"sv, "190c317440b37dcc3908e135c0f8a443defbdc5a"sv}, Entry{"history/v1-code.1152-1216.v"sv, "414134e50f28a32f4ec384cf7cee3b3ed7f4281e"sv}, Entry{"history/v1-code.1216-1280.v"sv, "47e5b1254618d13f8fea0327a9b1d2591681cc77"sv}, Entry{"history/v1-code.128-192.v"sv, "fb85825aa3c2f7b190aedf890e7258fd9b5a3b48"sv}, Entry{"history/v1-code.1280-1344.v"sv, "39a091bf95f40dd9179b0e53dc1f084aceb15e9f"sv}, Entry{"history/v1-code.1344-1408.v"sv, "2a496054f64471bcce51a9c6fb2738b30b95f452"sv}, Entry{"history/v1-code.1408-1472.v"sv, "e400b9c35773b391499e0baab0b6cdd864dc9c73"sv}, Entry{"history/v1-code.1472-1536.v"sv, "13deac039e87cbef09714cc452ca843d5cc34477"sv}, Entry{"history/v1-code.1536-1600.v"sv, "53a9953733c3698c43948b5da38351021513b64d"sv}, Entry{"history/v1-code.1600-1632.v"sv, "97bd49bc25aec70713fbb2e44d90b22bc58bb627"sv}, Entry{"history/v1-code.1632-1648.v"sv, "41855c4c8b30bbeebcea9e30123441056f869b60"sv}, Entry{"history/v1-code.1648-1656.v"sv, "75deed36da11418533cd52affd7081e249b0163f"sv}, Entry{"history/v1-code.1656-1660.v"sv, "71f93ec6145b108d4b8eecc5908a9850ab2418e4"sv}, Entry{"history/v1-code.192-256.v"sv, "b3643c80d6549a3e6096ab076f91084c4abeec92"sv}, Entry{"history/v1-code.256-320.v"sv, "cd33eddafb456ec8b0f484359fa298fd51cbd6ce"sv}, Entry{"history/v1-code.320-384.v"sv, "9b0048617155a6b56801fb0b7454c22a2ebd76fe"sv}, Entry{"history/v1-code.384-448.v"sv, "2c38de98bdfdcfe38c941d369f10fff0601f1e35"sv}, Entry{"history/v1-code.448-512.v"sv, "9858bfe5dad920aa66bf6585fff6fcda79a47d1a"sv}, Entry{"history/v1-code.512-576.v"sv, "e0f6adcceb0592b78b522b51dc62f5279ab952b7"sv}, Entry{"history/v1-code.576-640.v"sv, "0bd2f810d353b588ee9b76b79741613d7bb58490"sv}, Entry{"history/v1-code.64-128.v"sv, "74a83564f4cd17c2c0f01e9deec6cb1a87fcf8ef"sv}, Entry{"history/v1-code.640-704.v"sv, "668affe5d8dc993a7afcd65be77fce92b017e9e2"sv}, Entry{"history/v1-code.704-768.v"sv, "7be81d45675e16e1e3bddd7d66137055d43ae243"sv}, Entry{"history/v1-code.768-832.v"sv, "5c33b5f8f7a4d10c9185039d92c36f9bf11d5248"sv}, Entry{"history/v1-code.832-896.v"sv, "c2b0a634134c149807fa12cc634a178b227df236"sv}, Entry{"history/v1-code.896-960.v"sv, "d250a1b1c432148f7f615da6e27009420b5656d0"sv}, Entry{"history/v1-code.960-1024.v"sv, "a119228232e165ce90b5d3e2378d8cd8fd73cc0e"sv}, Entry{"history/v1-receipt.0-64.v"sv, "3e4edfb8da57bf414b2e3421d169017eab0cce10"sv}, Entry{"history/v1-receipt.1024-1088.v"sv, "8e1d5d576550f2628c18a44896eb192bbe554887"sv}, Entry{"history/v1-receipt.1088-1152.v"sv, "8105f0374ed7388ef6fe0eeabc17683fb4bcc210"sv}, Entry{"history/v1-receipt.1152-1216.v"sv, "178143e416540e30a5887762ee0110e75e11b422"sv}, Entry{"history/v1-receipt.1216-1280.v"sv, "ccfd10114af53390e1a5b31a14caad021b67d29a"sv}, Entry{"history/v1-receipt.128-192.v"sv, "6fa6a9a64c9ff2f3b668beae356f6a65aa37205d"sv}, Entry{"history/v1-receipt.1280-1344.v"sv, "dd833ea484e545f4fcef87efb7b2b2935ce0cb3c"sv}, Entry{"history/v1-receipt.1344-1408.v"sv, "27a3229af9e0968e1e3a6d43b7b0c0cfc49c2761"sv}, Entry{"history/v1-receipt.1408-1472.v"sv, "e9d1726d4bf4419dd580041afd827fd1d709b958"sv}, Entry{"history/v1-receipt.1472-1536.v"sv, "3a6397a2efa8744db1b7376aa757979153eccf8c"sv}, Entry{"history/v1-receipt.1536-1552.v"sv, "0bfee7865f9d62e411c3cd9f942ea19a3d0854b5"sv}, Entry{"history/v1-receipt.1552-1554.v"sv, "675155f1efe30548537a253a6dd3ce48a7f6407e"sv}, Entry{"history/v1-receipt.1554-1555.v"sv, "ed90a85a8a25c9d8a5fc69a682e7e67c5fcad157"sv}, Entry{"history/v1-receipt.1632-1648.v"sv, "af64ddc97f1dc00b494073631e9a101fd78afeb3"sv}, Entry{"history/v1-receipt.1648-1656.v"sv, "8b984bd2ac74db3cdb6a34dd156510ad8baa6350"sv}, Entry{"history/v1-receipt.1656-1660.v"sv, "7bd05a2fadeaf6382d5d5f6553f075da1022604e"sv}, Entry{"history/v1-receipt.192-256.v"sv, "53e382b9e81706476bc3604ffdcac2e0c8d1cdf4"sv}, Entry{"history/v1-receipt.256-320.v"sv, "f29677bf406757031f2d4b2ef9d71d57cf0b2933"sv}, Entry{"history/v1-receipt.320-384.v"sv, "f5d4e7e91de27362343061781151ebc015da6396"sv}, Entry{"history/v1-receipt.384-448.v"sv, "ff438eb1d51398555961c4591b6be25eb4339be5"sv}, Entry{"history/v1-receipt.448-512.v"sv, "a1aa399e0f1dee3523667fb03f78ac8547cc20c4"sv}, Entry{"history/v1-receipt.512-576.v"sv, "9103806dfb6b13c91b699e833040b691e2a20e1b"sv}, Entry{"history/v1-receipt.576-640.v"sv, "e5412a3ddbdf8b5e1183743e8220d748a9d545db"sv}, Entry{"history/v1-receipt.64-128.v"sv, "be1b74fd4d94c7485ed48d793b8c5c8b590e82e4"sv}, Entry{"history/v1-receipt.640-704.v"sv, "65cfd79ae296303c5d11947bcb042b0a034b0168"sv}, Entry{"history/v1-receipt.704-768.v"sv, "7382d0938a955052c65d3070040ce78d2f95a5f7"sv}, Entry{"history/v1-receipt.768-832.v"sv, "a9e018541bd3159d3e05cc18a6df2077fa3ad941"sv}, Entry{"history/v1-receipt.832-896.v"sv, "343ed8e2fa1fe8455b7a5c89e5cd88e749408cac"sv}, Entry{"history/v1-receipt.896-960.v"sv, "4025f9e42ee5fb4c023a25a265d864f037d4c54a"sv}, Entry{"history/v1-receipt.960-1024.v"sv, "1651062b0ee16a47023ada6e43a65cae8c45ab77"sv}, Entry{"history/v1-storage.0-64.v"sv, "d52273d4b29c558038b03090e34329f2648bdd61"sv}, Entry{"history/v1-storage.1024-1088.v"sv, "c5640e01a9ed734e0193e04fec76dfc7109f47cf"sv}, Entry{"history/v1-storage.1088-1152.v"sv, "03157334b45b4c216434f750835f5985836cdeb3"sv}, Entry{"history/v1-storage.1152-1216.v"sv, "73ba4a6a5e9aa3240067ac096d2f790c67a4c64f"sv}, Entry{"history/v1-storage.1216-1280.v"sv, "11711d2ba1735648619256eab715e57665c60165"sv}, Entry{"history/v1-storage.128-192.v"sv, "0bbcbb21bd8ea441dce6acb67407336c13bda87c"sv}, Entry{"history/v1-storage.1280-1344.v"sv, "4c5cb3667930cea7c08d5baf14af0fa622fec6fd"sv}, Entry{"history/v1-storage.1344-1408.v"sv, "7c8587b334df7bbfe144d0deb59955418a1c8a84"sv}, Entry{"history/v1-storage.1408-1472.v"sv, "7949f62781a3656c2232a7dde4b2ca7182b2bbee"sv}, Entry{"history/v1-storage.1472-1536.v"sv, "784cf9fbdaa12b3c2ac497aa78f18bb11e54f614"sv}, Entry{"history/v1-storage.1536-1600.v"sv, "eae544eb5b9a6bb9369f9bcddc0e3216a2fee32f"sv}, Entry{"history/v1-storage.1600-1632.v"sv, "3e148dced8f6e58a40a75f9ba43ed7f43a0befe3"sv}, Entry{"history/v1-storage.1632-1648.v"sv, "371a6e221a216fbc8f28f0115d0d477a566020be"sv}, Entry{"history/v1-storage.1648-1656.v"sv, "dbf42578e40902763a04a7c6e4d0f593e0e75a6a"sv}, Entry{"history/v1-storage.1656-1660.v"sv, "509635edd6bb68c3c139b4f18db7ba3317e96963"sv}, Entry{"history/v1-storage.192-256.v"sv, "63cd68b6e772eeb1e92c8c3abed55a2ac3e96d0b"sv}, Entry{"history/v1-storage.256-320.v"sv, "4499c3cebdb95a72f134c6237170e8a2d1dc24b0"sv}, Entry{"history/v1-storage.320-384.v"sv, "5638a6eae0cee599beb08cbad394ada84cb04cca"sv}, Entry{"history/v1-storage.384-448.v"sv, "b607e0e4e044f81d07efa3d1ee6a073a2ad349d3"sv}, Entry{"history/v1-storage.448-512.v"sv, "48849f56f8175eea7312a9bb29d005ce53b424ac"sv}, Entry{"history/v1-storage.512-576.v"sv, "30df2150554a28a137d769779a290804370d45f9"sv}, Entry{"history/v1-storage.576-640.v"sv, "ee9a5011426b31f08f023c2020d629bde3b3329e"sv}, Entry{"history/v1-storage.64-128.v"sv, "4841f932c35c1c3f1c16d6d91f8e7f39583e7482"sv}, Entry{"history/v1-storage.640-704.v"sv, "b500086db2b5b2e436f8af828c2631c327aeb05c"sv}, Entry{"history/v1-storage.704-768.v"sv, "e0ffdfb71475c2b64bb7315754028e4a24041aca"sv}, Entry{"history/v1-storage.768-832.v"sv, "d4f8919bd130885f27311a6778d2203709383389"sv}, Entry{"history/v1-storage.832-896.v"sv, "96689d2a9c134c3e2045ad5354fd644659076a87"sv}, Entry{"history/v1-storage.896-960.v"sv, "6dde5d72e7d08920c33ea8d9a7f87f7ad15d63a5"sv}, Entry{"history/v1-storage.960-1024.v"sv, "c20f38d745355aef181584b7a0d0b28c850cdef2"sv}, Entry{"idx/v1-accounts.0-64.ef"sv, "01f0b65aff19c4ab70c44c9363a619974070d495"sv}, Entry{"idx/v1-accounts.1024-1088.ef"sv, "ed29b0f20f24c9c2722e0fe418986d945b09858f"sv}, Entry{"idx/v1-accounts.1088-1152.ef"sv, "e4824c650d7d5b60bbc7664962ce9ffae11d968c"sv}, Entry{"idx/v1-accounts.1152-1216.ef"sv, "c53dcbed3a7d4b1e3777334214017b796dbf5338"sv}, Entry{"idx/v1-accounts.1216-1280.ef"sv, "e80a84079d354ca7bd4c7576d627f11d1551c606"sv}, Entry{"idx/v1-accounts.128-192.ef"sv, "ba9b9d3051346da4d8dc2cf091e450f25053d8b5"sv}, Entry{"idx/v1-accounts.1280-1344.ef"sv, "0ddd6884a9fd6a80ec3c318ef55299764bb6119a"sv}, Entry{"idx/v1-accounts.1344-1408.ef"sv, "cab42ffb8073cb58a63cf5525399c8b44f28e9ec"sv}, Entry{"idx/v1-accounts.1408-1472.ef"sv, "4aa5e45dc0ecae1a059c615a794f508d196370b5"sv}, Entry{"idx/v1-accounts.1472-1536.ef"sv, "49e0c6224229be5dfcbbb6f9d39f8e58f5d2b395"sv}, Entry{"idx/v1-accounts.1536-1600.ef"sv, "b58ae91fc504f0829f7a468ce49eb4c06a801078"sv}, Entry{"idx/v1-accounts.1600-1632.ef"sv, "f7712fc9f00988fe173370f8b89b26363b30b4cd"sv}, Entry{"idx/v1-accounts.1632-1648.ef"sv, "0a939c97c062f7d3f508bbbc21db07478a7100d7"sv}, Entry{"idx/v1-accounts.1648-1656.ef"sv, "73c26043c045f054881761a5822c32c86ec014b0"sv}, Entry{"idx/v1-accounts.1656-1660.ef"sv, "835db78ed37358859729ae8880f71f40b036b4b7"sv}, Entry{"idx/v1-accounts.192-256.ef"sv, "6d56558aa79bc82874b24c9f03748accdedb7b2e"sv}, Entry{"idx/v1-accounts.256-320.ef"sv, "c536fe08e46979ba16c3b03501a25b7d9e73d71b"sv}, Entry{"idx/v1-accounts.320-384.ef"sv, "449d7da06dfd9fe49a9e8b1e08352730236b3fc7"sv}, Entry{"idx/v1-accounts.384-448.ef"sv, "7cf68945ffb3de33b6fcb0243dde01d03701b394"sv}, Entry{"idx/v1-accounts.448-512.ef"sv, "eaf38032b7dac1062d45306f750547ea9dc412ff"sv}, Entry{"idx/v1-accounts.512-576.ef"sv, "109c13f6f6c0e8334175a20ee3e1bbea9cfaf8b5"sv}, Entry{"idx/v1-accounts.576-640.ef"sv, "ad0f10c7f61a112bcd04c247a0cf9287c6eec09a"sv}, Entry{"idx/v1-accounts.64-128.ef"sv, "c9d574852dbdb55de851fb4dc87baab7d426e3c6"sv}, Entry{"idx/v1-accounts.640-704.ef"sv, "d3e80cba9a66137983e2479094308e388ac4c210"sv}, Entry{"idx/v1-accounts.704-768.ef"sv, "6a2e351d3938eb2632ed7d97315aed88a977751e"sv}, Entry{"idx/v1-accounts.768-832.ef"sv, "819c7d87b637414077af14af6389e98e3deaeee6"sv}, Entry{"idx/v1-accounts.832-896.ef"sv, "43cdac17731d2986f16efeb286da8a3ceadf9c09"sv}, Entry{"idx/v1-accounts.896-960.ef"sv, "2067a13a33ca155d3f310334621760c55b37792d"sv}, Entry{"idx/v1-accounts.960-1024.ef"sv, "bd85a3ae889bb452e694f1a8e6eeb497b17b3820"sv}, Entry{"idx/v1-code.0-64.ef"sv, "290821b312fff0b2cf3212642e409e80d47bc817"sv}, Entry{"idx/v1-code.1024-1088.ef"sv, "94d6196e0ba92dc340bd1b2359fc1c60939c24ba"sv}, Entry{"idx/v1-code.1088-1152.ef"sv, "09eb3dff7ed64b0f4e2e0e9a77f715135253d4eb"sv}, Entry{"idx/v1-code.1152-1216.ef"sv, "ae017f8e00af973a91d979b1215f11977f2ee84e"sv}, Entry{"idx/v1-code.1216-1280.ef"sv, "b0b1d6737920a24949be668d3ed1b48f449d9b1f"sv}, Entry{"idx/v1-code.128-192.ef"sv, "ffad1a7e3401aa296f17615d85c810fabca87746"sv}, Entry{"idx/v1-code.1280-1344.ef"sv, "89f24e12536e768cf288636d8d82c95b9a10a334"sv}, Entry{"idx/v1-code.1344-1408.ef"sv, "6ad8cd4abb30b825689e40ca87f65cafe2860a83"sv}, Entry{"idx/v1-code.1408-1472.ef"sv, "04247044f6576b32a79795747540ae972f97f5eb"sv}, Entry{"idx/v1-code.1472-1536.ef"sv, "5d537ea2e0232035b4d05ab52d6310fa339f74af"sv}, Entry{"idx/v1-code.1536-1600.ef"sv, "1c849b74a67bf1d70bc5ebfeeb6a3909b56fee21"sv}, Entry{"idx/v1-code.1600-1632.ef"sv, "6ff114b55211fa1216d2705192bb3e48315b09ea"sv}, Entry{"idx/v1-code.1632-1648.ef"sv, "cf2da9562e7d5d94830a40c908839bb6da623d8a"sv}, Entry{"idx/v1-code.1648-1656.ef"sv, "947cbc2cae7192b4caec4f367b629a28ec10fb71"sv}, Entry{"idx/v1-code.1656-1660.ef"sv, "b0a525921b42c3a76cc344a8da7f86b707639d04"sv}, Entry{"idx/v1-code.192-256.ef"sv, "eeb5b609ef006d06d160290d37763c6cf16ce672"sv}, Entry{"idx/v1-code.256-320.ef"sv, "38d851385e57ec017d86abe85234e7fd31de8a90"sv}, Entry{"idx/v1-code.320-384.ef"sv, "ba7c28eaa2bd16fd1b033f67f811a0e81a57d27f"sv}, Entry{"idx/v1-code.384-448.ef"sv, "adb91cd7635e1751bb5c7a7e2d3559742f01d7a9"sv}, Entry{"idx/v1-code.448-512.ef"sv, "818627137edccca3f896f0bbba7c8015feff1042"sv}, Entry{"idx/v1-code.512-576.ef"sv, "80f0c6975c43cc551278b2c95a05eb227db3dd64"sv}, Entry{"idx/v1-code.576-640.ef"sv, "a6e2c98512c0c5b03d5244c418a68facbf830555"sv}, Entry{"idx/v1-code.64-128.ef"sv, "b790b27be6ae62c6ff329fc0af232f26d5de110b"sv}, Entry{"idx/v1-code.640-704.ef"sv, "0b7149086004746cb1d16857d9b89b05df721e85"sv}, Entry{"idx/v1-code.704-768.ef"sv, "2f080a49adb7a134866c2caf63c76a277ac2b53b"sv}, Entry{"idx/v1-code.768-832.ef"sv, "4a10731c09d9a4d1e210fd81bcb5f42be7ec1bf7"sv}, Entry{"idx/v1-code.832-896.ef"sv, "c1677e940449cc58944c01b83939731ca1c9863b"sv}, Entry{"idx/v1-code.896-960.ef"sv, "91127a1293b8ccc530350ed9e85d5c9772e62980"sv}, Entry{"idx/v1-code.960-1024.ef"sv, "03ad9e12f082e1ac045d97981866a2dd1075b545"sv}, Entry{"idx/v1-logaddrs.0-64.ef"sv, "85c5d62280326c94dec0d3f419edac1e404b7467"sv}, Entry{"idx/v1-logaddrs.1024-1088.ef"sv, "9b6b81274de8b79368fd5a8e1ca082947c9575ab"sv}, Entry{"idx/v1-logaddrs.1088-1152.ef"sv, "173795f7d78717258371812a140e85ff5627f524"sv}, Entry{"idx/v1-logaddrs.1152-1216.ef"sv, "1a7c83454f0695f1836c789544778aab9ef964a0"sv}, Entry{"idx/v1-logaddrs.1216-1280.ef"sv, "b333f5c084e04195d1bbaf42af4f245efe4dd890"sv}, Entry{"idx/v1-logaddrs.128-192.ef"sv, "8fac75d0cf68a6e9a810894d77dd5129ef1d7ac5"sv}, Entry{"idx/v1-logaddrs.1280-1344.ef"sv, "f08c546a64ed8922630a5bece5ec2d934b86ca6a"sv}, Entry{"idx/v1-logaddrs.1344-1408.ef"sv, "9d9941b076af4079a9b43a9afc11034c9c4b029d"sv}, Entry{"idx/v1-logaddrs.1408-1472.ef"sv, "d5dc02ae800a1708ee95f153d93ce0082e2146f9"sv}, Entry{"idx/v1-logaddrs.1472-1536.ef"sv, "274e40abebf0f49716c52a0f2ded55e3d28bb878"sv}, Entry{"idx/v1-logaddrs.1536-1600.ef"sv, "bc63cee0a4929a30b5aedb57bfa4eb7f37428dfb"sv}, Entry{"idx/v1-logaddrs.1600-1632.ef"sv, "52aff1796a43b221722cbdb368f2c9793537c00a"sv}, Entry{"idx/v1-logaddrs.1632-1648.ef"sv, "a2d3e599e84306e9241634d03821025e007bc76c"sv}, Entry{"idx/v1-logaddrs.1648-1656.ef"sv, "14a8cfc66ecbb07f9bcdcfa3b89532d06d577d77"sv}, Entry{"idx/v1-logaddrs.1656-1660.ef"sv, "63baa208fb6e3b91281cae2d8caad2eb6fb87b93"sv}, Entry{"idx/v1-logaddrs.192-256.ef"sv, "efae338bada835fc624861fc1292535700ed2404"sv}, Entry{"idx/v1-logaddrs.256-320.ef"sv, "940b438e43547792b60bff2bdda1bb10985913e6"sv}, Entry{"idx/v1-logaddrs.320-384.ef"sv, "3f9f7257e37320c37c796c723f3a63151e9d7239"sv}, Entry{"idx/v1-logaddrs.384-448.ef"sv, "6b056c9e53945af740489ad112b17bdee0d58387"sv}, Entry{"idx/v1-logaddrs.448-512.ef"sv, "efd9aadd379e0eca182e21225b7fca6b606025f5"sv}, Entry{"idx/v1-logaddrs.512-576.ef"sv, "cbb3ee257ffee666b73a5f1af18ae45f95d330d1"sv}, Entry{"idx/v1-logaddrs.576-640.ef"sv, "96019ed19c341e7ef3cb6d5608bb038b6b655562"sv}, Entry{"idx/v1-logaddrs.64-128.ef"sv, "23251b1bdd36bb110241ec963570a1b898828791"sv}, Entry{"idx/v1-logaddrs.640-704.ef"sv, "772d94ac3467fcf31b3421a39e73eb4e3307490c"sv}, Entry{"idx/v1-logaddrs.704-768.ef"sv, "6fec44fce80e4eee738e2712812ac768440f316e"sv}, Entry{"idx/v1-logaddrs.768-832.ef"sv, "e40869791988f396d699b39d201cde279f4b6999"sv}, Entry{"idx/v1-logaddrs.832-896.ef"sv, "e1852c197d05bff5fd715810053feb81dde37447"sv}, Entry{"idx/v1-logaddrs.896-960.ef"sv, "4066bfc97315c04e3812e0cd05b4c30001ffc69a"sv}, Entry{"idx/v1-logaddrs.960-1024.ef"sv, "114628db33ff3958ce89cc75dcb47c3a092cb05c"sv}, Entry{"idx/v1-logtopics.0-64.ef"sv, "f791704e38c818f2705b75136a941af2aea46f15"sv}, Entry{"idx/v1-logtopics.1024-1088.ef"sv, "a93f9547dbf5cb5e8683b73dc6c0d1cebfd1597f"sv}, Entry{"idx/v1-logtopics.1088-1152.ef"sv, "77d8c25f082e432f772fe27dff8f95e9e9f0233b"sv}, Entry{"idx/v1-logtopics.1152-1216.ef"sv, "9f40de46f984b5ba435eb109561a56261111a6e3"sv}, Entry{"idx/v1-logtopics.1216-1280.ef"sv, "702474d515e79e9426ddb07b9a6a89b3f3e4e290"sv}, Entry{"idx/v1-logtopics.128-192.ef"sv, "2144bd54a5e3a33798a0559e39bd20a3735bda7e"sv}, Entry{"idx/v1-logtopics.1280-1344.ef"sv, "88fbbc31fcbcfe88e629fb071cee474f50f2ddb6"sv}, Entry{"idx/v1-logtopics.1344-1408.ef"sv, "4d8a519f04b05c75736b55a35cc7572a7dbe666a"sv}, Entry{"idx/v1-logtopics.1408-1472.ef"sv, "cce728dd34fb65191eacec7040c471071c45b739"sv}, Entry{"idx/v1-logtopics.1472-1536.ef"sv, "f9eba80ef4a2af721a0dd70b7b525aca9d70d6f4"sv}, Entry{"idx/v1-logtopics.1536-1600.ef"sv, "2407f5e821cd3dda3a4e9f3a87e21b4a6b8f3389"sv}, Entry{"idx/v1-logtopics.1600-1632.ef"sv, "97f61f1989b5d892ee61bab3134d7e9af71bfe1f"sv}, Entry{"idx/v1-logtopics.1632-1648.ef"sv, "b4ee369425adc930759b949c17f0100fa03b2823"sv}, Entry{"idx/v1-logtopics.1648-1656.ef"sv, "7f548356d2ba86c5839499295345b4b1b5570383"sv}, Entry{"idx/v1-logtopics.1656-1660.ef"sv, "b4809a9edb6c2df29a1c007f2ea95d39758ab11d"sv}, Entry{"idx/v1-logtopics.192-256.ef"sv, "ed322f6e270e7c6a5e61afd5e7ba2420ecafe88d"sv}, Entry{"idx/v1-logtopics.256-320.ef"sv, "c80196a17151eb6d0873bf471ad11bd7630904e6"sv}, Entry{"idx/v1-logtopics.320-384.ef"sv, "74b28b77953b37d109ab59028876e8ede09bf1f7"sv}, Entry{"idx/v1-logtopics.384-448.ef"sv, "ca4279e7d37970aa67043e36061a3d4649b30962"sv}, Entry{"idx/v1-logtopics.448-512.ef"sv, "b5e2ef2e508218497296ddf817946aaacce76e6e"sv}, Entry{"idx/v1-logtopics.512-576.ef"sv, "71cc9b01c07aadcf9392b1e22c7175c29b18095b"sv}, Entry{"idx/v1-logtopics.576-640.ef"sv, "46695a39afa34f4c8a6d72aab3868bd9ceedaef6"sv}, Entry{"idx/v1-logtopics.64-128.ef"sv, "3220fcad3a8556482b3e830162f9726912027c39"sv}, Entry{"idx/v1-logtopics.640-704.ef"sv, "66c1aa29cef41fa6e540e5427a599b19fb05ef9f"sv}, Entry{"idx/v1-logtopics.704-768.ef"sv, "3aafd5328deb0608648d329cc530cb2813c839ea"sv}, Entry{"idx/v1-logtopics.768-832.ef"sv, "b3eeb8129655e61ffbe166856d31995b6e4b02e5"sv}, Entry{"idx/v1-logtopics.832-896.ef"sv, "3365df750f88631e73e12cf9c7b32e7bf8c3d318"sv}, Entry{"idx/v1-logtopics.896-960.ef"sv, "5662a76f840a9f78e0b67352a45f1d30b835504e"sv}, Entry{"idx/v1-logtopics.960-1024.ef"sv, "abb3e622943f455340a15749f33010cd86613a49"sv}, Entry{"idx/v1-receipt.0-64.ef"sv, "f1eea5dfe54bf8ae38c772c5f7b8aad3c8f8da9c"sv}, Entry{"idx/v1-receipt.1024-1088.ef"sv, "17c62ae1dc9c558fa38c4f37777b0614a6c462f1"sv}, Entry{"idx/v1-receipt.1088-1152.ef"sv, "68d56555e8b3926c6db9868befbb9810bcc39f38"sv}, Entry{"idx/v1-receipt.1152-1216.ef"sv, "5107b53a4847b0a0794e51266d1ac0493cd8695c"sv}, Entry{"idx/v1-receipt.1216-1280.ef"sv, "8d6f1e30253facbdf42f1cb559b88b55e318e5f8"sv}, Entry{"idx/v1-receipt.128-192.ef"sv, "014c6bc192db9b70753cefe85df19a16fb6dcfa1"sv}, Entry{"idx/v1-receipt.1280-1344.ef"sv, "7054c7aa8b4559e628df15b8643c9d09d1d8c5dc"sv}, Entry{"idx/v1-receipt.1344-1408.ef"sv, "38d5d00c628a8540d5127b5bd134787fcb2e71f0"sv}, Entry{"idx/v1-receipt.1408-1472.ef"sv, "eb3396932b6495058938677ac996b22be0196da1"sv}, Entry{"idx/v1-receipt.1472-1536.ef"sv, "b995a43d69e88223ab77253bd73cc22e02579861"sv}, Entry{"idx/v1-receipt.1536-1552.ef"sv, "78ab02f8776cc18d0eb6c40c9cf33c197e53186e"sv}, Entry{"idx/v1-receipt.1552-1554.ef"sv, "50679cc78e88a6c472cce8cf726b61896fb164cb"sv}, Entry{"idx/v1-receipt.1554-1555.ef"sv, "b930d6bc23a18a0bc46c545e9aa9c7b3f428a7cc"sv}, Entry{"idx/v1-receipt.1632-1648.ef"sv, "a73dd96a1539375c03e7d9a44e1b033e9dc9e2c2"sv}, Entry{"idx/v1-receipt.1648-1656.ef"sv, "62f884188157a51bec337c1f1cf3f86f97e29ec1"sv}, Entry{"idx/v1-receipt.1656-1660.ef"sv, "cbe1fd3f8909c85b801468c86dcaa679f46dae00"sv}, Entry{"idx/v1-receipt.192-256.ef"sv, "c468d8a2c8a89d1e800fa9f76c3ce6930b8db2a0"sv}, Entry{"idx/v1-receipt.256-320.ef"sv, "461e4b563f54001a913cc503a86d0ef250c90701"sv}, Entry{"idx/v1-receipt.320-384.ef"sv, "78be3474a94af20e317098f058efc06964824d67"sv}, Entry{"idx/v1-receipt.384-448.ef"sv, "14bd492cb6616513c5c9c6c136f406dfc7d09e0b"sv}, Entry{"idx/v1-receipt.448-512.ef"sv, "3da7e814355d2272056ae73265011abbf77bfe6c"sv}, Entry{"idx/v1-receipt.512-576.ef"sv, "e0b610bab70ffa15a59d35ab9184039a7f13d903"sv}, Entry{"idx/v1-receipt.576-640.ef"sv, "65fbc2f024089e5ed3e50c983dc713a76219acd0"sv}, Entry{"idx/v1-receipt.64-128.ef"sv, "4e13cba2ce9e0fb67addd5fda966a287aa5ca325"sv}, Entry{"idx/v1-receipt.640-704.ef"sv, "52265fa23c19eca734ea60d589ef13e934425fdb"sv}, Entry{"idx/v1-receipt.704-768.ef"sv, "c8b5610cfaf9049b9bb9fadf66b288d0ebf58b91"sv}, Entry{"idx/v1-receipt.768-832.ef"sv, "b17aec3572de3a9daed1b3c98654cf0bf9e8f8e1"sv}, Entry{"idx/v1-receipt.832-896.ef"sv, "4c2cd7cf43bd0a150c0e0d8be516212b7a97f56c"sv}, Entry{"idx/v1-receipt.896-960.ef"sv, "94978efd0ad52eb961fadca77f306ff99f1e25ad"sv}, Entry{"idx/v1-receipt.960-1024.ef"sv, "09ede8239aeb356b4d5c48fd6e6a7958ba321f93"sv}, Entry{"idx/v1-storage.0-64.ef"sv, "7e486007152b032e9a0c9f5468fa6c912a479f44"sv}, Entry{"idx/v1-storage.1024-1088.ef"sv, "a61bbd952c54ed38978b7ec9b343f079d5c1385f"sv}, Entry{"idx/v1-storage.1088-1152.ef"sv, "d50fa209e86ce4331ccac3b9514223a9f1045b4b"sv}, Entry{"idx/v1-storage.1152-1216.ef"sv, "2e1d57e06872612243120141e5d79c60edde6e62"sv}, Entry{"idx/v1-storage.1216-1280.ef"sv, "badecb3e29b6f88c0d296195474c24e523e84acd"sv}, Entry{"idx/v1-storage.128-192.ef"sv, "d0ef1389b9ba4bca881f60a3ca4e02037ef96ab3"sv}, Entry{"idx/v1-storage.1280-1344.ef"sv, "958e3e45ea5fecfe039e20c3e41297008f976442"sv}, Entry{"idx/v1-storage.1344-1408.ef"sv, "4a47731f29610fc54a1d234d44e79d0443a49683"sv}, Entry{"idx/v1-storage.1408-1472.ef"sv, "8b4081acc836639f7a13f823f75ac81d8130a462"sv}, Entry{"idx/v1-storage.1472-1536.ef"sv, "8352ee24ba2347c452b1723e97333161814bbb46"sv}, Entry{"idx/v1-storage.1536-1600.ef"sv, "17f59d7762122487289ba2f7f6bfa913ea9c2063"sv}, Entry{"idx/v1-storage.1600-1632.ef"sv, "7b9efd403f7b1c61e3cd35284f285399289cb3a7"sv}, Entry{"idx/v1-storage.1632-1648.ef"sv, "bcfd1f27501c11ae9ec8dc7c253320f3b9fabb0e"sv}, Entry{"idx/v1-storage.1648-1656.ef"sv, "5c7fcc04741b19f5c0681ab85eec49615b24b597"sv}, Entry{"idx/v1-storage.1656-1660.ef"sv, "42b23f668d159e637989935675fa3f0685fed201"sv}, Entry{"idx/v1-storage.192-256.ef"sv, "61923d98e59442057361c44790b426e064427051"sv}, Entry{"idx/v1-storage.256-320.ef"sv, "91b652dec0ab3395a9c1ea5633986cc596098ba5"sv}, Entry{"idx/v1-storage.320-384.ef"sv, "a2e37e0253798b45eb13ad29c00222d0d07d15a5"sv}, Entry{"idx/v1-storage.384-448.ef"sv, "49d11e561755102216ca109c5ed1457a56b08abe"sv}, Entry{"idx/v1-storage.448-512.ef"sv, "c03d4898c3552ef59bf09fa9c2c9f7dcc679f0b7"sv}, Entry{"idx/v1-storage.512-576.ef"sv, "8612035d9e9dc658c2dcd7b72e97bda8cb657079"sv}, Entry{"idx/v1-storage.576-640.ef"sv, "9d698f70e2bfa027e8af538579b2c90e27ce6bf7"sv}, Entry{"idx/v1-storage.64-128.ef"sv, "474c557e0233e5a0a188f71038ecc5343a4a36b2"sv}, Entry{"idx/v1-storage.640-704.ef"sv, "df3f88e213d9bd0c90440d5acb42dd0b9ca5965e"sv}, Entry{"idx/v1-storage.704-768.ef"sv, "4fd81b5bbb18b91d981d79a3d3c36554f6694f76"sv}, Entry{"idx/v1-storage.768-832.ef"sv, "16c9c49d5a4c055dae38f5bd6dddc8a95ce9587b"sv}, Entry{"idx/v1-storage.832-896.ef"sv, "dd02b4f2387edd3e1d84d1c2ce871e879809d167"sv}, Entry{"idx/v1-storage.896-960.ef"sv, "2dcdaa4e477dee31dc4dec479e36eb56f677c576"sv}, Entry{"idx/v1-storage.960-1024.ef"sv, "5f3896377a957166367e57796c979ce570bdf609"sv}, Entry{"idx/v1-tracesfrom.0-64.ef"sv, "6709d13f48581ea3dde79d46fd88271d0e4cd254"sv}, Entry{"idx/v1-tracesfrom.1024-1088.ef"sv, "fabd366d9a62d48d51c6705b200d14e34a90c404"sv}, Entry{"idx/v1-tracesfrom.1088-1152.ef"sv, "3150b638a3bfe3ed390ddf834ac27bca791657e4"sv}, Entry{"idx/v1-tracesfrom.1152-1216.ef"sv, "afbb7e0fa28f3825cec454abbc2f49279fe6c4a1"sv}, Entry{"idx/v1-tracesfrom.1216-1280.ef"sv, "438b75ac71d2f90756b22657f848d7c5706c158d"sv}, Entry{"idx/v1-tracesfrom.128-192.ef"sv, "3b53f1f35edff16c3fa9a8177da69ebfb1590122"sv}, Entry{"idx/v1-tracesfrom.1280-1344.ef"sv, "7a07da4b17ccf7353a76adf68ee52bc2a2356149"sv}, Entry{"idx/v1-tracesfrom.1344-1408.ef"sv, "56a9ab59de10c74ba74c3e20161d113107358f2b"sv}, Entry{"idx/v1-tracesfrom.1408-1472.ef"sv, "2e558c1e7f5298d52dd2d42c706c9fa74fd1d008"sv}, Entry{"idx/v1-tracesfrom.1472-1536.ef"sv, "84ac6cb794944223834543f980342b640db1ae7d"sv}, Entry{"idx/v1-tracesfrom.1536-1600.ef"sv, "89620978c874ed92046538bee4a9a15588e6eb7c"sv}, Entry{"idx/v1-tracesfrom.1600-1632.ef"sv, "4ed1013055589e0bcd61b95ea310d080577bbd20"sv}, Entry{"idx/v1-tracesfrom.1632-1648.ef"sv, "2c7bece99bbdf682465cfbb603e54d96f46128a2"sv}, Entry{"idx/v1-tracesfrom.1648-1656.ef"sv, "4e458fdec2e22a29550806ee6b1768857b85d9c7"sv}, Entry{"idx/v1-tracesfrom.1656-1660.ef"sv, "240ae99744caced38d39347c157b8c97109a839f"sv}, Entry{"idx/v1-tracesfrom.192-256.ef"sv, "4a1f76209185e0cbded04fd37e2fefffaaf88c18"sv}, Entry{"idx/v1-tracesfrom.256-320.ef"sv, "e3fd93feb085edd29a6627f01d100cba9b82bde9"sv}, Entry{"idx/v1-tracesfrom.320-384.ef"sv, "45ff076be364fd1c10ce7cc439652941eeb85e6e"sv}, Entry{"idx/v1-tracesfrom.384-448.ef"sv, "a0b181f7197412f4873f2b4a9ccce705dc4fc138"sv}, Entry{"idx/v1-tracesfrom.448-512.ef"sv, "c9772cedac098b6eaa017e069f3afa37c1a3ceb1"sv}, Entry{"idx/v1-tracesfrom.512-576.ef"sv, "dd82757a3f390ec97a0cfcc7c73117b8c749955d"sv}, Entry{"idx/v1-tracesfrom.576-640.ef"sv, "b32a87da2c4be4b610c80ec2c2934425ee92ecc7"sv}, Entry{"idx/v1-tracesfrom.64-128.ef"sv, "4fa59d87c285ccaa19efcbe56813c42b57ef8513"sv}, Entry{"idx/v1-tracesfrom.640-704.ef"sv, "fd413dd0521d8c9a296e7d69ca7885f75fd596b4"sv}, Entry{"idx/v1-tracesfrom.704-768.ef"sv, "6a95f3fcd8fc59873d98138b557d20977205f557"sv}, Entry{"idx/v1-tracesfrom.768-832.ef"sv, "9b95eda3e7e1572260e00e7d13911516624ff1ad"sv}, Entry{"idx/v1-tracesfrom.832-896.ef"sv, "39fd513052f76db34d64982d0d7fc6b5799ef7fb"sv}, Entry{"idx/v1-tracesfrom.896-960.ef"sv, "b0d5211e603f1680243a1c03fe9e5ec5df074260"sv}, Entry{"idx/v1-tracesfrom.960-1024.ef"sv, "5588a6e3b5badc62823e7c932a31f4bee4bf84b1"sv}, Entry{"idx/v1-tracesto.0-64.ef"sv, "8c5e9c59d895f1a2ceda868f2c12019f0d707fd8"sv}, Entry{"idx/v1-tracesto.1024-1088.ef"sv, "47aa182294a10454ae4ee90d4654b207bfbbc77b"sv}, Entry{"idx/v1-tracesto.1088-1152.ef"sv, "48d6161f629ca48192628fc4a9b02bcafa2320ed"sv}, Entry{"idx/v1-tracesto.1152-1216.ef"sv, "f75e0706df90dbaa674ac0e2bfe7c327a062d480"sv}, Entry{"idx/v1-tracesto.1216-1280.ef"sv, "231c765586c64a6851587117e466f6634022cf3b"sv}, Entry{"idx/v1-tracesto.128-192.ef"sv, "ca0636a7efed09a6ae6f0da9f0471a4a934def20"sv}, Entry{"idx/v1-tracesto.1280-1344.ef"sv, "441ff831eb4132fe1da19bc8d6eef08ad8d9b3d5"sv}, Entry{"idx/v1-tracesto.1344-1408.ef"sv, "ad2ab269cb089027f276f18473fd664a58529b73"sv}, Entry{"idx/v1-tracesto.1408-1472.ef"sv, "30d53d0dc20678119990a2559034471f04be810c"sv}, Entry{"idx/v1-tracesto.1472-1536.ef"sv, "495a1e16cb1bf2e9858ab7e4c2562a96c2f823d1"sv}, Entry{"idx/v1-tracesto.1536-1600.ef"sv, "cb95c0fcdcbd65a78c9feb501b0b32beda5912bb"sv}, Entry{"idx/v1-tracesto.1600-1632.ef"sv, "3cc8c2d1a8b02048094679be7ab802d598f3879c"sv}, Entry{"idx/v1-tracesto.1632-1648.ef"sv, "ef552d3cc4ffce1d93287c2b0772f57e24f59632"sv}, Entry{"idx/v1-tracesto.1648-1656.ef"sv, "a417b7e009bbb9febc745e273ea7673e1cb05b2a"sv}, Entry{"idx/v1-tracesto.1656-1660.ef"sv, "585218688e4e92befd77eba2d153053a76b90d7a"sv}, Entry{"idx/v1-tracesto.192-256.ef"sv, "21f6a7a79bebd2adea446ca880d06391fcc7899e"sv}, Entry{"idx/v1-tracesto.256-320.ef"sv, "66c91f6111d04dc512328a530a9a50aa3a4b4102"sv}, Entry{"idx/v1-tracesto.320-384.ef"sv, "74d4382f9c23fdd36cb3524e19a45cf6308db794"sv}, Entry{"idx/v1-tracesto.384-448.ef"sv, "3a2ee49fc961741ddac06c6b60ff35ca8f1df438"sv}, Entry{"idx/v1-tracesto.448-512.ef"sv, "73c100a40529de6fbb77d6fbd0d1e42e28d89311"sv}, Entry{"idx/v1-tracesto.512-576.ef"sv, "4143e5a5a36fc0046ac415367177b71076a1ea2f"sv}, Entry{"idx/v1-tracesto.576-640.ef"sv, "ed06126b6370778b37ff85a6fd5385ecea63d4b8"sv}, Entry{"idx/v1-tracesto.64-128.ef"sv, "d94bdc7e1001fd808e3d571920a4696e71b456a2"sv}, Entry{"idx/v1-tracesto.640-704.ef"sv, "d9db2d827a99ba1ca2c5fcca8ac33cde1d0d3e57"sv}, Entry{"idx/v1-tracesto.704-768.ef"sv, "1b83d1e49909577fd441f56a25842e8032341a15"sv}, Entry{"idx/v1-tracesto.768-832.ef"sv, "0c4f3eaa9fba83477ac05a112576bd6dfc1c5e40"sv}, Entry{"idx/v1-tracesto.832-896.ef"sv, "e10287ef08c0ecceccd511866efa5abde7f046a9"sv}, Entry{"idx/v1-tracesto.896-960.ef"sv, "96ab89b6f25478798105cebac85caccb41de8048"sv}, Entry{"idx/v1-tracesto.960-1024.ef"sv, "c71f8cab4614843025c7df1f7314cec045230406"sv}, Entry{"salt-blocks.txt"sv, "90eb3df952f2d604d27656b0b60494cd26bfd6f8"sv}, Entry{"salt-state.txt"sv, "0113ec56c7c0d72783dbb5738becffa9c4c43d69"sv}, Entry{"v1-000000-000500-bodies.idx"sv, "2ee5a6d2692fbec47830fa25890ee7c0c98e8ab4"sv}, Entry{"v1-000000-000500-bodies.seg"sv, "e9b5c5d1885ee3c6ab6005919e511e1e04c7e34e"sv}, Entry{"v1-000000-000500-headers.idx"sv, "61661072961b5d2a1cb60f3816f4643020da74f0"sv}, Entry{"v1-000000-000500-headers.seg"sv, "df09957d8a28af3bc5137478885a8003677ca878"sv}, Entry{"v1-000000-000500-transactions-to-block.idx"sv, "6b89a7915d9f2701ef9b366ccd8b4f5067e52a96"sv}, Entry{"v1-000000-000500-transactions.idx"sv, "3833de5680e671075d8a6162be02f8b6618c27ef"sv}, Entry{"v1-000000-000500-transactions.seg"sv, "e09738e15b7a383e361d936f75f10cec8c236931"sv}, Entry{"v1-000500-001000-bodies.idx"sv, "a86634a9082abb37139d577af6a8e133169faf6e"sv}, Entry{"v1-000500-001000-bodies.seg"sv, "f8c4ad66b12b977ac849daf4df67f60a3c30faa1"sv}, Entry{"v1-000500-001000-headers.idx"sv, "e489fd246e28d2a92a8dfc211f5616398c09b435"sv}, Entry{"v1-000500-001000-headers.seg"sv, "8466be869eacd28a9d696cb6a4f3210fbc2f59ac"sv}, Entry{"v1-000500-001000-transactions-to-block.idx"sv, "23b57be3255a36f304ba9df8810beee4a9195a56"sv}, Entry{"v1-000500-001000-transactions.idx"sv, "ee2d5b1235d1e7265ab9ae46f2f0b19740b30e0f"sv}, Entry{"v1-000500-001000-transactions.seg"sv, "faa10ef4b04991b5662b94b4d06dc5d133b751c8"sv}, Entry{"v1-001000-001500-bodies.idx"sv, "d329266e4212430a51ee3ae2a9070ea56f4564b5"sv}, Entry{"v1-001000-001500-bodies.seg"sv, "4a70af715d3492060c7e929552bba1cb971b0f74"sv}, Entry{"v1-001000-001500-headers.idx"sv, "2ad8baf4dcd244b52235592c2a2d2c40aa375af8"sv}, Entry{"v1-001000-001500-headers.seg"sv, "65db8110d48269960643d786d54b8869d2a5797c"sv}, Entry{"v1-001000-001500-transactions-to-block.idx"sv, "4bdcef2b3ea80fcacc0e49614f64c4f1850d6116"sv}, Entry{"v1-001000-001500-transactions.idx"sv, "741ef5031078ed01710ee7f342e0220f257d5b10"sv}, Entry{"v1-001000-001500-transactions.seg"sv, "428b487da06acebecfb593b02679075cefcdb1df"sv}, Entry{"v1-001500-002000-bodies.idx"sv, "27ed168be79d8462cfc858a58fb668dbd7ecb887"sv}, Entry{"v1-001500-002000-bodies.seg"sv, "897caefe9460895b16afd153e02acf452cd714a8"sv}, Entry{"v1-001500-002000-headers.idx"sv, "57e3bf37aea1ba25f617311d50a3c9c2aa063477"sv}, Entry{"v1-001500-002000-headers.seg"sv, "ceca70d9989be409fb7e2911b505ec8196496f2c"sv}, Entry{"v1-001500-002000-transactions-to-block.idx"sv, "872c1083b62d89f199b7f203531ecb15571929d4"sv}, Entry{"v1-001500-002000-transactions.idx"sv, "696552e45e2951026820134ccc6d9ac53a7e0b75"sv}, Entry{"v1-001500-002000-transactions.seg"sv, "b6878d67baafec49613279faf86f389bfcd086e1"sv}, Entry{"v1-002000-002500-bodies.idx"sv, "955cf8f38787e0fa34459e4b42079f8d59f427d5"sv}, Entry{"v1-002000-002500-bodies.seg"sv, "499c675cd0c286d5df1a0355faf816bf41dd3cc2"sv}, Entry{"v1-002000-002500-headers.idx"sv, "219c2a91dd4881ae8721db1efc7bde7b18299958"sv}, Entry{"v1-002000-002500-headers.seg"sv, "42db5b7dbe2dbba76a64ebf9b6196356b00d7eb2"sv}, Entry{"v1-002000-002500-transactions-to-block.idx"sv, "0fb035067d3c03e1664f2604b2bff8fe19ea5453"sv}, Entry{"v1-002000-002500-transactions.idx"sv, "a5ebf2ecb4e9bcc9979a7a17651918c68ecfbcf6"sv}, Entry{"v1-002000-002500-transactions.seg"sv, "2de566b9b6d976c1ec98b3d69953eb7a7de2e5df"sv}, Entry{"v1-002500-003000-bodies.idx"sv, "c411fbfa83b8ca4cf28c58356dd5041a36ed05c6"sv}, Entry{"v1-002500-003000-bodies.seg"sv, "89a1f445d3e37f819b6126b7d6bcc5fc91e7724d"sv}, Entry{"v1-002500-003000-headers.idx"sv, "647800aed65c5f2d0694b2c3b8daa775efe7a1d4"sv}, Entry{"v1-002500-003000-headers.seg"sv, "45a4855f8f9875cad0114bbae1b43256c13046d6"sv}, Entry{"v1-002500-003000-transactions-to-block.idx"sv, "bb7983a054c735a8498006acb6b5c2bc5bde2e60"sv}, Entry{"v1-002500-003000-transactions.idx"sv, "fcdacc1d8160b2aa2f305a9f06ddf576cadd128a"sv}, Entry{"v1-002500-003000-transactions.seg"sv, "e33b75cf5e67c0f5a0ed86b5b54d1d8a8dc7ef20"sv}, Entry{"v1-003000-003500-bodies.idx"sv, "d2a4fb9281b4ae120873e96bdfeb7077d061ecfd"sv}, Entry{"v1-003000-003500-bodies.seg"sv, "26a48d04562e05ce7b13ed80d2854b53eeb59433"sv}, Entry{"v1-003000-003500-headers.idx"sv, "d2e8806d7d0af06d6826846fbfebd6d0ece15ed9"sv}, Entry{"v1-003000-003500-headers.seg"sv, "dab50721a2f3c9b7b46f7b09289d0ffab3e27231"sv}, Entry{"v1-003000-003500-transactions-to-block.idx"sv, "a0846ce9379f5ec88bf74fd7914756fbbe7d31c5"sv}, Entry{"v1-003000-003500-transactions.idx"sv, "f563a5f747fcbe442b324fc41042d21455c11324"sv}, Entry{"v1-003000-003500-transactions.seg"sv, "8f5882f6ac1a52d416d3a2e452b0142aafc5dec7"sv}, Entry{"v1-003500-004000-bodies.idx"sv, "3d05686f9bacbbb4c3b8305c49659d6f30a4dfb6"sv}, Entry{"v1-003500-004000-bodies.seg"sv, "d50672c7b4027a148042ce9a65840b0dc1c8502b"sv}, Entry{"v1-003500-004000-headers.idx"sv, "62fd842ab5233e9b31e60bf04a081ebe4b8e14a5"sv}, Entry{"v1-003500-004000-headers.seg"sv, "6853c5998ab333f84acb66d899ddb7eec440b398"sv}, Entry{"v1-003500-004000-transactions-to-block.idx"sv, "d659ccb5730aa2cb5bd9da68a27d969e03a0104c"sv}, Entry{"v1-003500-004000-transactions.idx"sv, "dbeda751566fb608f4e7927b6f46500e7cdcdd96"sv}, Entry{"v1-003500-004000-transactions.seg"sv, "dcf6f2e91558cdf4611e88166b40eab3bcb3d5aa"sv}, Entry{"v1-004000-004500-bodies.idx"sv, "eb0b81a3dae73eb552314b9b04ad79ebae29c441"sv}, Entry{"v1-004000-004500-bodies.seg"sv, "446762ef18d352e6377abac6dd589e0c1e266a83"sv}, Entry{"v1-004000-004500-headers.idx"sv, "bf1d6aa57d5e67ed79093a1a1ae799fd20eb51e3"sv}, Entry{"v1-004000-004500-headers.seg"sv, "109a2c4c92809f633e5ce324d715b376cd4bfdf8"sv}, Entry{"v1-004000-004500-transactions-to-block.idx"sv, "298b00708d4ac3867606412d431b07d21f18a77f"sv}, Entry{"v1-004000-004500-transactions.idx"sv, "08c7632408aee33797744524cf0b1e6261114080"sv}, Entry{"v1-004000-004500-transactions.seg"sv, "49ee44897d360612553352474bb99b8681bbff51"sv}, Entry{"v1-004500-005000-bodies.idx"sv, "b1eb5b1ea9f48f1c73fbdcaad08a3d093760a9e2"sv}, Entry{"v1-004500-005000-bodies.seg"sv, "5777d2a832a3752ee9d4e3bb142ae9202cd612c6"sv}, Entry{"v1-004500-005000-headers.idx"sv, "df516d2d8b86d7fec9da5d5e7db38aeb31ec50f2"sv}, Entry{"v1-004500-005000-headers.seg"sv, "a5d5c1661391e36886fe7606aed188af70285150"sv}, Entry{"v1-004500-005000-transactions-to-block.idx"sv, "6b77d06a17d4e22309898f9bfd3edbfb4dcba68e"sv}, Entry{"v1-004500-005000-transactions.idx"sv, "53f63c6e2001f0c2e82f187e51fe9e6243668357"sv}, Entry{"v1-004500-005000-transactions.seg"sv, "476e2ceb18806fd8cbac5d6ee49406413cc592b1"sv}, Entry{"v1-005000-005500-bodies.idx"sv, "9e8ac9b8eff597c450edbff1883d2a0822cf7c4c"sv}, Entry{"v1-005000-005500-bodies.seg"sv, "59e0ed98ee7150d43e0f7bb351e27a104255a223"sv}, Entry{"v1-005000-005500-headers.idx"sv, "b91ffc0d3eea97a85f99caa6fc2a99a4cd372716"sv}, Entry{"v1-005000-005500-headers.seg"sv, "d2313be592d4f25b6415528b9cf70ee4f5203773"sv}, Entry{"v1-005000-005500-transactions-to-block.idx"sv, "0919b96192d02f28c71b4484e6ccf8004ff9f692"sv}, Entry{"v1-005000-005500-transactions.idx"sv, "a83bf2b0177911d5f13eab0d5cd46be3f44f2711"sv}, Entry{"v1-005000-005500-transactions.seg"sv, "b720df4a2ec1ab0de97820ea6ee362edd90d3a33"sv}, Entry{"v1-005500-006000-bodies.idx"sv, "83cef14c1aeb252e0951f4c356790b3524464c96"sv}, Entry{"v1-005500-006000-bodies.seg"sv, "869c1e5f784605f1833aec97efb55fb7891bf91a"sv}, Entry{"v1-005500-006000-headers.idx"sv, "da7d7988054b97efa22ccb57bcffba7cec82d4d0"sv}, Entry{"v1-005500-006000-headers.seg"sv, "4921eeff91f01741fb1594e4fbc47e51394bed6a"sv}, Entry{"v1-005500-006000-transactions-to-block.idx"sv, "adce03a5ec260b3fc3530495a23a3124f4732769"sv}, Entry{"v1-005500-006000-transactions.idx"sv, "7c3218d3c02d06ca21e59c34fba85821fee876b1"sv}, Entry{"v1-005500-006000-transactions.seg"sv, "3d5e444439871c6266dc647c2422dd2aacc0e047"sv}, Entry{"v1-006000-006500-bodies.idx"sv, "d8739cc92967de3db39324fc08d09caafd43ffdf"sv}, Entry{"v1-006000-006500-bodies.seg"sv, "06dab7a47e7dfb3ad33c647499857ef657ac0aab"sv}, Entry{"v1-006000-006500-headers.idx"sv, "73601413edfee904704a065988ed54b859454811"sv}, Entry{"v1-006000-006500-headers.seg"sv, "a59e6441cd40ac90bf878b83bbda702183cbe3ea"sv}, Entry{"v1-006000-006500-transactions-to-block.idx"sv, "49efc4952950283c4f3a1055ab52e602c54ffb38"sv}, Entry{"v1-006000-006500-transactions.idx"sv, "ed5abf0f2039351a41e97ca1e532b656d0359438"sv}, Entry{"v1-006000-006500-transactions.seg"sv, "de524904cd159ab5417fec904c88819795c14d36"sv}, Entry{"v1-006500-007000-bodies.idx"sv, "8b5a45838510c3e6317903242732422ab2c235a5"sv}, Entry{"v1-006500-007000-bodies.seg"sv, "6202303558b39e5dddc5c21af4c9d2ac3792e764"sv}, Entry{"v1-006500-007000-headers.idx"sv, "7f17264119285cd831bd9f87ac00fc6551aa265a"sv}, Entry{"v1-006500-007000-headers.seg"sv, "3dd6b74f686de95a0f19bfeb64cbfdc776b9e4c2"sv}, Entry{"v1-006500-007000-transactions-to-block.idx"sv, "4b4df21fec91b4dcdf36a78a95d04ad740bc97d6"sv}, Entry{"v1-006500-007000-transactions.idx"sv, "8ffd4a467d668b6742e17f986ce061ca3040202a"sv}, Entry{"v1-006500-007000-transactions.seg"sv, "719e8eebbdb0b68e810ee7166ab7175ff659ffea"sv}, Entry{"v1-007000-007500-bodies.idx"sv, "fe8a10f6ef07a2a55e839424b7cffb2b2793d0c0"sv}, Entry{"v1-007000-007500-bodies.seg"sv, "62dbfc3cec6280465e79129d2e3182c633d7cf36"sv}, Entry{"v1-007000-007500-headers.idx"sv, "8dc616aff0a235f4c601d280cbd16d8dc28c27f7"sv}, Entry{"v1-007000-007500-headers.seg"sv, "804f47a8eb72b04496953d603a0c0a9c67f0cae5"sv}, Entry{"v1-007000-007500-transactions-to-block.idx"sv, "a619fdb8415d13874a070fa35905ac1a8961b04b"sv}, Entry{"v1-007000-007500-transactions.idx"sv, "0b5c770ecfb041b035451ae56a5ce1aadc366a06"sv}, Entry{"v1-007000-007500-transactions.seg"sv, "2d4f373b9b6654594abc801ed0293b6ec3d03c02"sv}, Entry{"v1-007500-008000-bodies.idx"sv, "445c58d1cd8668daec34bf1dd5f0ab864249a4e1"sv}, Entry{"v1-007500-008000-bodies.seg"sv, "b6fbc12d16fe54146bef2e73655f15ace4da7225"sv}, Entry{"v1-007500-008000-headers.idx"sv, "713a1db1b6d6130ce42b3b1773f5727293f099f9"sv}, Entry{"v1-007500-008000-headers.seg"sv, "7e02a143182993188624a16c19ae627afd8edac7"sv}, Entry{"v1-007500-008000-transactions-to-block.idx"sv, "add83b70120a92daf77c3ad7762b5620c9ef2e72"sv}, Entry{"v1-007500-008000-transactions.idx"sv, "2757db3d5a4bb5540d09f0900c15ac91e5eadc94"sv}, Entry{"v1-007500-008000-transactions.seg"sv, "0adaf50d8a593de39c7b4be85ccf3bbc230ce8c2"sv}, Entry{"v1-008000-008500-bodies.idx"sv, "8b8b6ba459f92965aec73f877f584ebdd584532d"sv}, Entry{"v1-008000-008500-bodies.seg"sv, "5d32423845e14d48d3c51bd0b3da59c768120011"sv}, Entry{"v1-008000-008500-headers.idx"sv, "709491973223504673658cd9ac85f1905db27f90"sv}, Entry{"v1-008000-008500-headers.seg"sv, "9e6fa6ccb89c1352e2339737f1220ac4fc8958a9"sv}, Entry{"v1-008000-008500-transactions-to-block.idx"sv, "cfb1d5a033ede37edb1b769b7a68a66f2129f541"sv}, Entry{"v1-008000-008500-transactions.idx"sv, "c1b597ba858bd79935151ca95dc221c7043aaa1f"sv}, Entry{"v1-008000-008500-transactions.seg"sv, "8ef52661507584bbe03a4877a117c63b4b4ba6cd"sv}, Entry{"v1-008500-009000-bodies.idx"sv, "0302d29d099bfcb9a0f0cce38d41713846ef8b5a"sv}, Entry{"v1-008500-009000-bodies.seg"sv, "85f1bbfc7d3e692ff3ee8aafcebd1b908d6977f2"sv}, Entry{"v1-008500-009000-headers.idx"sv, "da0fdc3bcbabd6c83898e61ac24f747bcaa6bf18"sv}, Entry{"v1-008500-009000-headers.seg"sv, "aaba6138899994b343a5d5e6005ffed01991c420"sv}, Entry{"v1-008500-009000-transactions-to-block.idx"sv, "7adbc586b8f3115610d6e8db7b2c23f1106c7c2f"sv}, Entry{"v1-008500-009000-transactions.idx"sv, "e170f526c46a55b81182f841361ea2d1740582bf"sv}, Entry{"v1-008500-009000-transactions.seg"sv, "57ec9fcd24a94d6c10bb1c691e051c125d0ea80a"sv}, Entry{"v1-008620-008630-blobsidecars.seg"sv, "51be6aab2fc9ec68806cd06c4e756ff69a2b20a0"sv}, Entry{"v1-008620-008630-blocksidecars.idx"sv, "6cfa58eb60e6f5006acdad50f62c6e50113fcf51"sv}, Entry{"v1-008630-008640-blobsidecars.seg"sv, "33bfd902acc83fc2aed7aeed13efa06e5a362a1a"sv}, Entry{"v1-008630-008640-blocksidecars.idx"sv, "eed3659040a1b379891fd74d4d43e2f3908609c9"sv}, Entry{"v1-008640-008650-blobsidecars.seg"sv, "ab6907436c45513aa22bf7b93247095e0947b33e"sv}, Entry{"v1-008640-008650-blocksidecars.idx"sv, "5e159cc412f170612dea682c0f4bc159967082b6"sv}, Entry{"v1-008650-008660-blobsidecars.seg"sv, "8c47da4e4b7fbb08ce5b4dd95d21ab3a84438cda"sv}, Entry{"v1-008650-008660-blocksidecars.idx"sv, "330d8d1f42aa4073b2b32393ec1ddd3c2f72ac7e"sv}, Entry{"v1-008660-008670-blobsidecars.seg"sv, "02bcc59eb2b332bef57ca857fa2e60a7bcd6456f"sv}, Entry{"v1-008660-008670-blocksidecars.idx"sv, "23270f7525004b22735be74c72deba55fe04af48"sv}, Entry{"v1-008670-008680-blobsidecars.seg"sv, "920ffdda6f5e7eccd783456a34a764f5e7b731aa"sv}, Entry{"v1-008670-008680-blocksidecars.idx"sv, "72f05a402b71bf210887178e2df283eefc208d85"sv}, Entry{"v1-008680-008690-blobsidecars.seg"sv, "eec03ef575eb0e18a5020496c385e169b931d26c"sv}, Entry{"v1-008680-008690-blocksidecars.idx"sv, "0f76c2736c0bfafc448f38597682dfb0883fb803"sv}, Entry{"v1-008690-008700-blobsidecars.seg"sv, "1ae43c27cad87b976295c714d9b4f8a53320ac25"sv}, Entry{"v1-008690-008700-blocksidecars.idx"sv, "8583f5cd00f1b31b8c4cd30735e8fbb7dc812cb0"sv}, Entry{"v1-008700-008710-blobsidecars.seg"sv, "03bd217d795c63a5876fc742d5c313b0473089c2"sv}, Entry{"v1-008700-008710-blocksidecars.idx"sv, "c07a4f2f9ef1df6a2fb77e3127b39f7dd933c0c1"sv}, Entry{"v1-008710-008720-blobsidecars.seg"sv, "7eb81213deb4e5ada90cf307017b7e2146763d4e"sv}, Entry{"v1-008710-008720-blocksidecars.idx"sv, "8c3554a1999bdabcaae5f8f356976f457b93cac6"sv}, Entry{"v1-008720-008730-blobsidecars.seg"sv, "f9ef739ac14ed1da1cc3e38394e4c7b9876820cf"sv}, Entry{"v1-008720-008730-blocksidecars.idx"sv, "3636170abddac5a1fc19a08b05594cbb7a5c753e"sv}, Entry{"v1-008730-008740-blobsidecars.seg"sv, "0a7b94c13eadd20b02055aa5e9aee39e0988fb90"sv}, Entry{"v1-008730-008740-blocksidecars.idx"sv, "65861d60fe88db79dcc92a9139f256ecf9435979"sv}, Entry{"v1-008740-008750-blobsidecars.seg"sv, "80865ee92934668d7357f835eab75b2a9f62b3a8"sv}, Entry{"v1-008740-008750-blocksidecars.idx"sv, "56c0b4f9ea4a92d6856cdd7bfc26a843cd2844f3"sv}, Entry{"v1-008750-008760-blobsidecars.seg"sv, "15935572acdcd212df94c545a21491ac9e9ef9f2"sv}, Entry{"v1-008750-008760-blocksidecars.idx"sv, "a5466b0f806264b9c5cfcb39e232dc7b625f5f6d"sv}, Entry{"v1-008760-008770-blobsidecars.seg"sv, "bebb4f50db0efaf729cf024bac3676b53fe17f0e"sv}, Entry{"v1-008760-008770-blocksidecars.idx"sv, "82407d30ec5725afd7d8748d4d0006eb284c808b"sv}, Entry{"v1-008770-008780-blobsidecars.seg"sv, "c28595b803f2613a400ddf43d7733f95a147bc64"sv}, Entry{"v1-008770-008780-blocksidecars.idx"sv, "e95cd9a1caab7098aff63fdf00b4adc1adc81352"sv}, Entry{"v1-008780-008790-blobsidecars.seg"sv, "b632e9b62b38e47de1519372ec1e6a510600d1ad"sv}, Entry{"v1-008780-008790-blocksidecars.idx"sv, "0f6adf77da313c39749429ed68cfc16098b80463"sv}, Entry{"v1-008790-008800-blobsidecars.seg"sv, "c14c96dc2efad51ae77276488e327c4b9da53c38"sv}, Entry{"v1-008790-008800-blocksidecars.idx"sv, "305e4f581f68271ba0d51c553283c91a865c45e1"sv}, Entry{"v1-008800-008810-blobsidecars.seg"sv, "5b50eb6373e9c1d6637b9a95088dbc47410c50ee"sv}, Entry{"v1-008800-008810-blocksidecars.idx"sv, "6d75831e3244dff64cc1317a4d577bc3cd5436d2"sv}, Entry{"v1-008810-008820-blobsidecars.seg"sv, "46814ecfd3e5927807047af35bb488c9dcc5f779"sv}, Entry{"v1-008810-008820-blocksidecars.idx"sv, "e396078bac9477946090c77702c2729a3ca2fd3f"sv}, Entry{"v1-008820-008830-blobsidecars.seg"sv, "5862b4a9757dd1bbf7e7f277bba93ed5151344e9"sv}, Entry{"v1-008820-008830-blocksidecars.idx"sv, "36ed2711c7be8d182b4d5efe3752a678720f74a7"sv}, Entry{"v1-008830-008840-blobsidecars.seg"sv, "0301ede1e44bc6fd6e6db2f4fd18789a96afd2d8"sv}, Entry{"v1-008830-008840-blocksidecars.idx"sv, "caafdd52d44e38cdb6e07809a6a54878cc5a75c2"sv}, Entry{"v1-008840-008850-blobsidecars.seg"sv, "effa2792e9a17ccc40bed3318fc1c3fd72fce95e"sv}, Entry{"v1-008840-008850-blocksidecars.idx"sv, "49e35c0a80fa659a734f495a414eeb282bde3080"sv}, Entry{"v1-008850-008860-blobsidecars.seg"sv, "033429a1eff85c9080fca96341ae68cf999d2127"sv}, Entry{"v1-008850-008860-blocksidecars.idx"sv, "581d8c68b485e10e27ae1bfca0e093cfa8d85533"sv}, Entry{"v1-008860-008870-blobsidecars.seg"sv, "bf83f68c0cc44c4cab0a504df05178dc7e79b1d3"sv}, Entry{"v1-008860-008870-blocksidecars.idx"sv, "8f04d0cc58464f5d41129fddcef52a4501a330f6"sv}, Entry{"v1-008870-008880-blobsidecars.seg"sv, "cdac865926a028d5df56c791fe00c0e14095eb9a"sv}, Entry{"v1-008870-008880-blocksidecars.idx"sv, "acb4b64df58b649215a53b4486d1ac75c281e94b"sv}, Entry{"v1-008880-008890-blobsidecars.seg"sv, "a1aecf6f8c18d3d0271c16f733282e5ba748ae08"sv}, Entry{"v1-008880-008890-blocksidecars.idx"sv, "dac7904bf96465912a03c1b2812acde5467f0e9e"sv}, Entry{"v1-008890-008900-blobsidecars.seg"sv, "d33297f9a382178498eecedd14b8bb9a22d00cc2"sv}, Entry{"v1-008890-008900-blocksidecars.idx"sv, "9ffac4c48976ee5d34e03959f7b6eeaaca08b56c"sv}, Entry{"v1-008900-008910-blobsidecars.seg"sv, "79a4f580b02b67e03db09c08466a44b0e9b964ad"sv}, Entry{"v1-008900-008910-blocksidecars.idx"sv, "05a0dbf5d9f9c9c3a7dd43d9cd4c82b977a9873d"sv}, Entry{"v1-008910-008920-blobsidecars.seg"sv, "7571546582ef5760eaf4945859cd744cbf7fb27a"sv}, Entry{"v1-008910-008920-blocksidecars.idx"sv, "7a83e5994625368c96514508d2419409428cea1e"sv}, Entry{"v1-008920-008930-blobsidecars.seg"sv, "82cd56be2350e3b9f82c175c86b69e1e98ca0a0f"sv}, Entry{"v1-008920-008930-blocksidecars.idx"sv, "8116114acd34e4f7e505ea16815a30c2260befbb"sv}, Entry{"v1-008930-008940-blobsidecars.seg"sv, "e103de0475747b34e6a7389d25190caee8ee693a"sv}, Entry{"v1-008930-008940-blocksidecars.idx"sv, "a4f7463fbeac1f4757c3bf71d2f37b4d9d02ba75"sv}, Entry{"v1-008940-008950-blobsidecars.seg"sv, "01e39faeea5c8b0d5b4d65242f3787c8e6313be7"sv}, Entry{"v1-008940-008950-blocksidecars.idx"sv, "e9a1bb860c7424f1d22fc7fcb0214a1ddd04b85f"sv}, Entry{"v1-008950-008960-blobsidecars.seg"sv, "ef98b79580ec0bc379f768e8d0da2595814e5323"sv}, Entry{"v1-008950-008960-blocksidecars.idx"sv, "b5811db6c60b5b1105b18692b8b7713411fd148c"sv}, Entry{"v1-008960-008970-blobsidecars.seg"sv, "5013ab80695adac8b62a861e769cbd51ff49046c"sv}, Entry{"v1-008960-008970-blocksidecars.idx"sv, "56e6529625a3aaabfd57a532df236d3c3605df12"sv}, Entry{"v1-008970-008980-blobsidecars.seg"sv, "6ccaf294c9b5fe2c5bae77fdf52e26e3b7224fee"sv}, Entry{"v1-008970-008980-blocksidecars.idx"sv, "922800533575e73c5757a5f7a07b8eaab8b5fe31"sv}, Entry{"v1-008980-008990-blobsidecars.seg"sv, "f7c21fd1bb81d28c2f37a1275d2d77989234be7a"sv}, Entry{"v1-008980-008990-blocksidecars.idx"sv, "927e15f8e90a2ea8f44634c7efff55408694d501"sv}, Entry{"v1-008990-009000-blobsidecars.seg"sv, "8d4647d1a6f96144e026d3b5107f61e72d106867"sv}, Entry{"v1-008990-009000-blocksidecars.idx"sv, "98db43fc23a7563d68bb0daa1168ca17f1f1b16c"sv}, Entry{"v1-009000-009010-blobsidecars.seg"sv, "3d46a95efc214528e3d9b53c8dab125703f787d0"sv}, Entry{"v1-009000-009010-blocksidecars.idx"sv, "0ea2a860917bdde97360f6c8c47d6a7127a2396c"sv}, Entry{"v1-009000-009500-bodies.idx"sv, "64604a9795b73020faa845c2e8a030f3ac8b8926"sv}, Entry{"v1-009000-009500-bodies.seg"sv, "5eb8f215c2d356d413fa882c7f8dd4cad5c3c981"sv}, Entry{"v1-009000-009500-headers.idx"sv, "642bb5774161aaf4204d3b6437c5395b9cb0f33e"sv}, Entry{"v1-009000-009500-headers.seg"sv, "d67688a59fdd7c3549393783f4c09eb3865729a6"sv}, Entry{"v1-009000-009500-transactions-to-block.idx"sv, "7e56ee19ad1323df353b928ec5a5c4703f2cb679"sv}, Entry{"v1-009000-009500-transactions.idx"sv, "bda490eb25126064f0b82c25d74c1e2b833eb795"sv}, Entry{"v1-009000-009500-transactions.seg"sv, "ae1c52bb5af403f55acf24e07cef7b4eca553e5c"sv}, Entry{"v1-009010-009020-blobsidecars.seg"sv, "3d102674161a73957c37ac5488232c878b7be397"sv}, Entry{"v1-009010-009020-blocksidecars.idx"sv, "e03260ff0dc91368789aab4214c57f233edac695"sv}, Entry{"v1-009020-009030-blobsidecars.seg"sv, "41ba13afa27d08840d2317926bc020d58fac3b49"sv}, Entry{"v1-009020-009030-blocksidecars.idx"sv, "95dec37e06eb07fd41ded0b0d329723df3aea883"sv}, Entry{"v1-009030-009040-blobsidecars.seg"sv, "25161eb5c854e2ddcf61811a788131a245d2b88e"sv}, Entry{"v1-009030-009040-blocksidecars.idx"sv, "d8d5e7c884efd0e0cf1e3cdc22e1a0b83cfe34b8"sv}, Entry{"v1-009040-009050-blobsidecars.seg"sv, "e7117c3025827803dc36e3bf52ed38b0774884a8"sv}, Entry{"v1-009040-009050-blocksidecars.idx"sv, "54fe8b08613d84b947b2048a493c72d134406c1a"sv}, Entry{"v1-009050-009060-blobsidecars.seg"sv, "e3c4eed153c1794cb148e69b34a3a15ea707d59a"sv}, Entry{"v1-009050-009060-blocksidecars.idx"sv, "f24a71ff40e0f2a4521becbfe9b4e1ad8f73a56a"sv}, Entry{"v1-009060-009070-blobsidecars.seg"sv, "cc5e57b3a77a47ead7d6f73a2e7a7a943d188468"sv}, Entry{"v1-009060-009070-blocksidecars.idx"sv, "5ea8f478269ca8c455c5556a344187ccb790121f"sv}, Entry{"v1-009070-009080-blobsidecars.seg"sv, "3565be1b6ec7a8a25bb57d5a0d6fc842430844e2"sv}, Entry{"v1-009070-009080-blocksidecars.idx"sv, "2ec3a1057ff50837e5476c7716b962293919c8ba"sv}, Entry{"v1-009080-009090-blobsidecars.seg"sv, "b2069bce2a967667c839a01425f379d75b6a48da"sv}, Entry{"v1-009080-009090-blocksidecars.idx"sv, "279d3b17656cb79bd5a419518b4289979c1caf53"sv}, Entry{"v1-009090-009100-blobsidecars.seg"sv, "7d376602d51caf0d29ad36e0cabddf6b1ba7333c"sv}, Entry{"v1-009090-009100-blocksidecars.idx"sv, "ee3261975b64ee87392c9c303f1a387ee5136d8b"sv}, Entry{"v1-009100-009110-blobsidecars.seg"sv, "3abc26a589a8afba10a62493ac076e3c4fe7c8e7"sv}, Entry{"v1-009100-009110-blocksidecars.idx"sv, "c743a13d6462ea898501ff66443ac9af6c2df1f6"sv}, Entry{"v1-009110-009120-blobsidecars.seg"sv, "91eb8ddaa7ffec1cb7aa4c010dcd0ce5d991fef8"sv}, Entry{"v1-009110-009120-blocksidecars.idx"sv, "b46ceba23e8dea1997ad84ef5535a5bf980b0926"sv}, Entry{"v1-009120-009130-blobsidecars.seg"sv, "bd7d90dc380793f5f864f91f8e53ac6a09341cf9"sv}, Entry{"v1-009120-009130-blocksidecars.idx"sv, "6dd985e455ee12b759f722a6231855180b9fa1e3"sv}, Entry{"v1-009130-009140-blobsidecars.seg"sv, "4e7849d6b9ee820881c7bdc9499097a078b5ff88"sv}, Entry{"v1-009130-009140-blocksidecars.idx"sv, "62c455e382db553c82234c54a232d530f5b7977e"sv}, Entry{"v1-009140-009150-blobsidecars.seg"sv, "77514bd42cd3c7156cd4d5d6571f20746cf0d466"sv}, Entry{"v1-009140-009150-blocksidecars.idx"sv, "142d267095e5af8ba0e90deb3696ee049ba68918"sv}, Entry{"v1-009150-009160-blobsidecars.seg"sv, "4b09777421571c494f8b1f8ff80eb7d053663148"sv}, Entry{"v1-009150-009160-blocksidecars.idx"sv, "f881aab6c2d2f84fc62b24737bc3608a9b85405d"sv}, Entry{"v1-009160-009170-blobsidecars.seg"sv, "b8641dfe4e0a122edc4b6cf6695fac0be4936b7b"sv}, Entry{"v1-009160-009170-blocksidecars.idx"sv, "2c77d32e19762a420f367acb3a6a0e6e5d33c7ef"sv}, Entry{"v1-009170-009180-blobsidecars.seg"sv, "746a7e38026b47083a500b8b8aad00c6678fbf13"sv}, Entry{"v1-009170-009180-blocksidecars.idx"sv, "69fbaf394593cb832d20d5f4528fc22585391d73"sv}, Entry{"v1-009180-009190-blobsidecars.seg"sv, "1fd4011724f9014e368bf92f2394762a6cce78db"sv}, Entry{"v1-009180-009190-blocksidecars.idx"sv, "bef28c7afd6f71210503116715f9637212c03ddb"sv}, Entry{"v1-009190-009200-blobsidecars.seg"sv, "d0424b58d3053eb1f322bcdd7cbe1254be8640d2"sv}, Entry{"v1-009190-009200-blocksidecars.idx"sv, "2707fe89241c58e27c9590b00c4f9deb4b1da811"sv}, Entry{"v1-009200-009210-blobsidecars.seg"sv, "8be8f88b2c3a373199844d48bdad7bafdd79f839"sv}, Entry{"v1-009200-009210-blocksidecars.idx"sv, "7c1183481c27e334680d9311b1fe7d198994901a"sv}, Entry{"v1-009210-009220-blobsidecars.seg"sv, "61ffb13b43908544bcde196c12f8eea64bb5e194"sv}, Entry{"v1-009210-009220-blocksidecars.idx"sv, "0fb5766efa95e6d61247108a0c91279eb5fbb1d4"sv}, Entry{"v1-009220-009230-blobsidecars.seg"sv, "7d0b049588bec1af8f072b010ba1ba44a7f27c0a"sv}, Entry{"v1-009220-009230-blocksidecars.idx"sv, "f909fcc313d755daddf79c95a177607b8f438aad"sv}, Entry{"v1-009230-009240-blobsidecars.seg"sv, "21109009eccbac97e7aeacf335e6905ae9f5706a"sv}, Entry{"v1-009230-009240-blocksidecars.idx"sv, "d8592423b0f2e11e5de715f9a4e027d90250d0c5"sv}, Entry{"v1-009240-009250-blobsidecars.seg"sv, "99d0264f4926b39e56f5afecbe2554d2463abf2d"sv}, Entry{"v1-009240-009250-blocksidecars.idx"sv, "17a2e5b5d8b8506f487fe99240ba0fbc62a9a152"sv}, Entry{"v1-009250-009260-blobsidecars.seg"sv, "a0cd3558955d775014a4a696b0b41730238a7eeb"sv}, Entry{"v1-009250-009260-blocksidecars.idx"sv, "e346050696670b3b40f6cf2e9c0516f986fd553f"sv}, Entry{"v1-009260-009270-blobsidecars.seg"sv, "aaa5370081e1a23f5eef863c8dd87d60782d3710"sv}, Entry{"v1-009260-009270-blocksidecars.idx"sv, "7c3ab9a6371a4bb4ecf1b2a2605779234669eefb"sv}, Entry{"v1-009270-009280-blobsidecars.seg"sv, "c05491ea1f7ff7921e0836e04ecf63280d3f5848"sv}, Entry{"v1-009270-009280-blocksidecars.idx"sv, "8f9a134c30e46444207ab9d88ffb0b212dfb0407"sv}, Entry{"v1-009280-009290-blobsidecars.seg"sv, "3b0e2930d19375aef49c5acfb390a08660de9940"sv}, Entry{"v1-009280-009290-blocksidecars.idx"sv, "3cb6589dd7bdedb3c825d149e1d50f0152cf8780"sv}, Entry{"v1-009290-009300-blobsidecars.seg"sv, "c55f025bc50510afc09778863a033a68450144a1"sv}, Entry{"v1-009290-009300-blocksidecars.idx"sv, "278a577e8a87cf344048777adf336f620b8d1a1d"sv}, Entry{"v1-009300-009310-blobsidecars.seg"sv, "534b6d53c8c81994c37ac870483ace6d584ca3ab"sv}, Entry{"v1-009300-009310-blocksidecars.idx"sv, "8a6da343d4f1081d051a433bcf416f522ce8e4c7"sv}, Entry{"v1-009310-009320-blobsidecars.seg"sv, "5b10bfc15a7c46425f28d7b03a806593ff8be0e6"sv}, Entry{"v1-009310-009320-blocksidecars.idx"sv, "92b6ec405d20d663095212036afbee451b486446"sv}, Entry{"v1-009320-009330-blobsidecars.seg"sv, "3646a62e1d5d4132c0ef5c2813ba620e38cedd09"sv}, Entry{"v1-009320-009330-blocksidecars.idx"sv, "f8f18fdf0251481e00dc1bf097e611e6eafe538f"sv}, Entry{"v1-009330-009340-blobsidecars.seg"sv, "48c8c781c16717ee7dcb7268faf80d72cdc75929"sv}, Entry{"v1-009330-009340-blocksidecars.idx"sv, "580bf7b32cf2e63bf00fc6de0ce19d2e396c6b3e"sv}, Entry{"v1-009340-009350-blobsidecars.seg"sv, "539f1abe9b44c6ece35a212aa4fe92a4e57d89fa"sv}, Entry{"v1-009340-009350-blocksidecars.idx"sv, "a4f452d6ec98bce98f6275fcc771562433fe0c61"sv}, Entry{"v1-009350-009360-blobsidecars.seg"sv, "33249967c09dcfe614c09bb24c0493b95f8f5b2e"sv}, Entry{"v1-009350-009360-blocksidecars.idx"sv, "972953187c0a81b0998602436d3e987e5fe890ba"sv}, Entry{"v1-009360-009370-blobsidecars.seg"sv, "596accf82dba2ccca68d5d61c27da9b6ddc3b4a6"sv}, Entry{"v1-009360-009370-blocksidecars.idx"sv, "5c2cf273da316f87ff4da270cb302bd17e448c82"sv}, Entry{"v1-009370-009380-blobsidecars.seg"sv, "2d4836098e95a00e17eac5f5ed89f422928d7fc1"sv}, Entry{"v1-009370-009380-blocksidecars.idx"sv, "047981e6106870da8b087e819ab7c79056b808a7"sv}, Entry{"v1-009380-009390-blobsidecars.seg"sv, "0b90beab6837f36df3dfa3570a1f55769d0aebea"sv}, Entry{"v1-009380-009390-blocksidecars.idx"sv, "b1e467b86eca765a4744812da9c4881ada001113"sv}, Entry{"v1-009390-009400-blobsidecars.seg"sv, "d53650cddb01a7a5398250abed504ae520a32be2"sv}, Entry{"v1-009390-009400-blocksidecars.idx"sv, "71b0ed755e0f511416f1f685d7c2ff1310080c50"sv}, Entry{"v1-009400-009410-blobsidecars.seg"sv, "17df29f83d2d8e5243fa958a699406ec41c23a5a"sv}, Entry{"v1-009400-009410-blocksidecars.idx"sv, "7c811b9885015a77ec2084c4fa90a80cf8cb4f3b"sv}, Entry{"v1-009410-009420-blobsidecars.seg"sv, "6a435ed533d8ade4faffbc2447081077cf0808f9"sv}, Entry{"v1-009410-009420-blocksidecars.idx"sv, "ecf7659df03b90ca7f2ee5aee99f2c3ad114073d"sv}, Entry{"v1-009420-009430-blobsidecars.seg"sv, "cdd724fad687ca6106929d7e68be61f62fedeb3d"sv}, Entry{"v1-009420-009430-blocksidecars.idx"sv, "fa8899bb208cf77566939c46cfd27e2a8e5f4cc2"sv}, Entry{"v1-009430-009440-blobsidecars.seg"sv, "51e18ca2184892b666e977f4b517c997c97f0bdb"sv}, Entry{"v1-009430-009440-blocksidecars.idx"sv, "a5b494184c5e53487c770cfefbea3bc1b0f7094f"sv}, Entry{"v1-009440-009450-blobsidecars.seg"sv, "e4033c913259c96e47a28ad4777861a81a8ec610"sv}, Entry{"v1-009440-009450-blocksidecars.idx"sv, "9ad7d02ded9a5ccf20215b4bb469944bd8667551"sv}, Entry{"v1-009450-009460-blobsidecars.seg"sv, "ae4cd8561715ff93496b1ae24d88bdc9a51ce2f2"sv}, Entry{"v1-009450-009460-blocksidecars.idx"sv, "21139aaa9f84a96c2ea12245b73a00a572bd4786"sv}, Entry{"v1-009460-009470-blobsidecars.seg"sv, "23551655fc9a89b3936c470ba3990d859169a7ec"sv}, Entry{"v1-009460-009470-blocksidecars.idx"sv, "e108fedd15869755d3439af257f0d5199b5455b0"sv}, Entry{"v1-009470-009480-blobsidecars.seg"sv, "c4874edb283c895ec30f7f8e89de5aca0800dc10"sv}, Entry{"v1-009470-009480-blocksidecars.idx"sv, "5950e1873a9bd6c84e519f5042c57ab364ca331c"sv}, Entry{"v1-009480-009490-blobsidecars.seg"sv, "075085a45b245f5036999a291b904cf36fdae6f7"sv}, Entry{"v1-009480-009490-blocksidecars.idx"sv, "7be98a80936255eb8c256c54bb9825b85a7491c5"sv}, Entry{"v1-009490-009500-blobsidecars.seg"sv, "2fe930695b816af56e17ada8809070cbfabd2d01"sv}, Entry{"v1-009490-009500-blocksidecars.idx"sv, "297f4bf70d9014008df3ac61bea4d384452f295a"sv}, Entry{"v1-009500-009510-blobsidecars.seg"sv, "8eaeddeb9428e6cb143876f0dc6d984e8b1b4daf"sv}, Entry{"v1-009500-009510-blocksidecars.idx"sv, "36d44de7dc95b5f7e9b5bfc825b12e67c7ff5e23"sv}, Entry{"v1-009500-010000-bodies.idx"sv, "597dad663287413ea4d1fea23ab00a9a20dcdb8a"sv}, Entry{"v1-009500-010000-bodies.seg"sv, "906304871357a0ab3964a03958124102a26630ad"sv}, Entry{"v1-009500-010000-headers.idx"sv, "e322ec0d6c99d3eaaccf1857d7fb054594cb8a37"sv}, Entry{"v1-009500-010000-headers.seg"sv, "ee94b0da4de2140cd44a4a45dfe762d5e62eb0b8"sv}, Entry{"v1-009500-010000-transactions-to-block.idx"sv, "2a0df72dcc9c6bff6da7db05002a58f9bbd921db"sv}, Entry{"v1-009500-010000-transactions.idx"sv, "8d994affdbe3fa5e238b62dfc245f9edba325a2e"sv}, Entry{"v1-009500-010000-transactions.seg"sv, "195ff94c642a9144ae6d550880d8884830b555e4"sv}, Entry{"v1-009510-009520-blobsidecars.seg"sv, "27509022ec8eca13c778e6e277a9204db94be6b1"sv}, Entry{"v1-009510-009520-blocksidecars.idx"sv, "abe8d1700cd6122e3313dbd1e2b04b160e99c0e0"sv}, Entry{"v1-009520-009530-blobsidecars.seg"sv, "fb113f7d3640c4354042331b6973136ee0eef6e3"sv}, Entry{"v1-009520-009530-blocksidecars.idx"sv, "6a667133c8dae0672d855461e0006f53b605ac47"sv}, Entry{"v1-009530-009540-blobsidecars.seg"sv, "d1d281798bcaeea7a4d840d54112f0e45eba6dd1"sv}, Entry{"v1-009530-009540-blocksidecars.idx"sv, "bdebafa00e63eed2976c090416a9497c4a021f2e"sv}, Entry{"v1-009540-009550-blobsidecars.seg"sv, "06a679b1aea474ee933e786fa705bd99d1b30c77"sv}, Entry{"v1-009540-009550-blocksidecars.idx"sv, "9cecc77fb5efe78347d011258eeb46a711f36910"sv}, Entry{"v1-009550-009560-blobsidecars.seg"sv, "8e368e123348bdb151e0714e7d6471cb01ac7a84"sv}, Entry{"v1-009550-009560-blocksidecars.idx"sv, "346e685917944b57c65813a0a3981dd9f18569f0"sv}, Entry{"v1-009560-009570-blobsidecars.seg"sv, "841ff92d84b0dee951e7edae2f21e6369d5107f1"sv}, Entry{"v1-009560-009570-blocksidecars.idx"sv, "980a792312e7d70e0d78e38c6f1b79e266f91a52"sv}, Entry{"v1-009570-009580-blobsidecars.seg"sv, "84292b7adb084cf940e3cc28672b08538d7b09a1"sv}, Entry{"v1-009570-009580-blocksidecars.idx"sv, "888c7dc7f5ebbd2293493f516116591fca5f0558"sv}, Entry{"v1-009580-009590-blobsidecars.seg"sv, "94f0abdaf7783cd97802fa553c66d7a4490cd3f2"sv}, Entry{"v1-009580-009590-blocksidecars.idx"sv, "e6a9d0b250d13896f726cdac55b1384e8e97bc3d"sv}, Entry{"v1-009590-009600-blobsidecars.seg"sv, "37b3f81251ff28c0babfdc45682a70c280fef840"sv}, Entry{"v1-009590-009600-blocksidecars.idx"sv, "e32506dc4f30733835eae31c91b88dc0486d917e"sv}, Entry{"v1-009600-009610-blobsidecars.seg"sv, "51e9b899a540a3a95a0a248648bd3aa75430f34a"sv}, Entry{"v1-009600-009610-blocksidecars.idx"sv, "864959cf74e0292b3924dd52d72d41535a6c1414"sv}, Entry{"v1-009610-009620-blobsidecars.seg"sv, "2c1146f0733feb6753e3f817f802942012754a37"sv}, Entry{"v1-009610-009620-blocksidecars.idx"sv, "d5e2b65ef88c2582ec612e0728e7599f06539894"sv}, Entry{"v1-009620-009630-blobsidecars.seg"sv, "446728d012950154ec7c0696f963770c4b1890c3"sv}, Entry{"v1-009620-009630-blocksidecars.idx"sv, "a8d9eeae2334ab3efdbde35ab793c3e04bb8be36"sv}, Entry{"v1-009630-009640-blobsidecars.seg"sv, "2d1401d483652a0c2e44fff28ccfdb6704a99d73"sv}, Entry{"v1-009630-009640-blocksidecars.idx"sv, "5012d046148554f21f6b351700b1b8dfe68ff67b"sv}, Entry{"v1-009640-009650-blobsidecars.seg"sv, "a380d27d175cae7faba4eda2494105466e43eb90"sv}, Entry{"v1-009640-009650-blocksidecars.idx"sv, "84b10cae5d5cb1c469cc47555a8d3bc83fe17c08"sv}, Entry{"v1-009650-009660-blobsidecars.seg"sv, "8201cbce918715adb7b83aa3bbb633c3cdc3cf90"sv}, Entry{"v1-009650-009660-blocksidecars.idx"sv, "04c611ab169562da3704e58d271c5234ec261506"sv}, Entry{"v1-009660-009670-blobsidecars.seg"sv, "6991d0e2ce3c808830a0ace4d53ad34e36bec415"sv}, Entry{"v1-009660-009670-blocksidecars.idx"sv, "8f696d06be256a63f68ba625f1b557c71c6352c5"sv}, Entry{"v1-009670-009680-blobsidecars.seg"sv, "305be944c0e1f60195a6eef11bab536dee19c54d"sv}, Entry{"v1-009670-009680-blocksidecars.idx"sv, "c1554177218430f3b4f50ba452fe8e6ef9668555"sv}, Entry{"v1-009680-009690-blobsidecars.seg"sv, "21cecf98ad13f55ac1f2a8ec11353c6dbf1543bd"sv}, Entry{"v1-009680-009690-blocksidecars.idx"sv, "1522f4224f1d3aeb7cdabc10aedd8bc548c949aa"sv}, Entry{"v1-009690-009700-blobsidecars.seg"sv, "2d5b84aea7b08d785f8e5bce5213b8d6a0fcece6"sv}, Entry{"v1-009690-009700-blocksidecars.idx"sv, "43964147d8f0c4a3559c2c9d067a3f8ea49dc922"sv}, Entry{"v1-009700-009710-blobsidecars.seg"sv, "057f6040dc84f103afee6d508036b4eed82dc443"sv}, Entry{"v1-009700-009710-blocksidecars.idx"sv, "fd0bd8d6284d93e10e795edea19ab31aab798d7b"sv}, Entry{"v1-009710-009720-blobsidecars.seg"sv, "cbfc9e6980132a6c3866b0434216972197eaae5c"sv}, Entry{"v1-009710-009720-blocksidecars.idx"sv, "0840a739955d8c77fbd0f6c1fc488e9d3187ac41"sv}, Entry{"v1-009720-009730-blobsidecars.seg"sv, "4eca922b8807830f3e496048f7b163f6d2f4e333"sv}, Entry{"v1-009720-009730-blocksidecars.idx"sv, "b876361220d2ced75b9d3ff7674b59b1eab37b24"sv}, Entry{"v1-009730-009740-blobsidecars.seg"sv, "a72892b68491915140f99f9e764bf4989c26879e"sv}, Entry{"v1-009730-009740-blocksidecars.idx"sv, "fe0aa5497d97a1d631af428bc611430bcc4a2103"sv}, Entry{"v1-009740-009750-blobsidecars.seg"sv, "618a7eadfdc5f1f42f493dd2e32755731427a4c0"sv}, Entry{"v1-009740-009750-blocksidecars.idx"sv, "4fd41b21719e765cbc1a053a3f885d822a96b756"sv}, Entry{"v1-009750-009760-blobsidecars.seg"sv, "dae5073d46ba11317e49877dadd8ffc8c0439ab5"sv}, Entry{"v1-009750-009760-blocksidecars.idx"sv, "c1b6eef2a54898c481b79f538f599f92d151a3e4"sv}, Entry{"v1-009760-009770-blobsidecars.seg"sv, "d63acd939a9cd228fb913f56a6db1082d3455deb"sv}, Entry{"v1-009760-009770-blocksidecars.idx"sv, "a07b80c8b6bf919a756545534473c23cefe89e84"sv}, Entry{"v1-009770-009780-blobsidecars.seg"sv, "505d62ca7c1cf4fa4e5d8afb7d87b1e2b742c034"sv}, Entry{"v1-009770-009780-blocksidecars.idx"sv, "c9ddbb7270f19248ee62761a14ecb76f5a63fb93"sv}, Entry{"v1-009780-009790-blobsidecars.seg"sv, "8062a758ef3b61a31e1dd309c2e584d78127cc8c"sv}, Entry{"v1-009780-009790-blocksidecars.idx"sv, "674afb2cff33188458a6629b5db63a17f57c016f"sv}, Entry{"v1-009790-009800-blobsidecars.seg"sv, "96f7eaf149415349bb14ad278b248b268a618a9d"sv}, Entry{"v1-009790-009800-blocksidecars.idx"sv, "09ac1a6f6b5038cf921056f4470740230acd6c1c"sv}, Entry{"v1-009800-009810-blobsidecars.seg"sv, "484f0bc4d474b8536ed6625d4fb58bbfe1370166"sv}, Entry{"v1-009800-009810-blocksidecars.idx"sv, "9b855cdeb54a73335213c434c2c43dade1c7a795"sv}, Entry{"v1-009810-009820-blobsidecars.seg"sv, "ac7d41b2eeb81e5d606f73b73177337bff1381fd"sv}, Entry{"v1-009810-009820-blocksidecars.idx"sv, "fb9274631c5db4835f672672cc8bb8c149dcb3c4"sv}, Entry{"v1-009820-009830-blobsidecars.seg"sv, "732d54a62d1a225aa6a4a467706d09f00d8cfa89"sv}, Entry{"v1-009820-009830-blocksidecars.idx"sv, "10a485f63c4d6128251d81840229097e31ce4bae"sv}, Entry{"v1-009830-009840-blobsidecars.seg"sv, "c75fafa484be9341a88fa67fc5ee04a94fb3f46e"sv}, Entry{"v1-009830-009840-blocksidecars.idx"sv, "9c1c82574b7a0b53bf72b6c0f67843de9f1f14ee"sv}, Entry{"v1-009840-009850-blobsidecars.seg"sv, "c1a96dd715cfa29356535f791182dd1b22d5be51"sv}, Entry{"v1-009840-009850-blocksidecars.idx"sv, "022b521e88577cfe9652f30b35e6cec04f5449ce"sv}, Entry{"v1-009850-009860-blobsidecars.seg"sv, "0091620ed26005a9a37f412909af848718da7eee"sv}, Entry{"v1-009850-009860-blocksidecars.idx"sv, "8f6426d9aa112e4b649160fd611dc33b284b0462"sv}, Entry{"v1-009860-009870-blobsidecars.seg"sv, "52166fe9b2c4013c3a6d67769f35aa24e36fa12f"sv}, Entry{"v1-009860-009870-blocksidecars.idx"sv, "2513206e1042b104946ea6c32d774dc92d353d7e"sv}, Entry{"v1-009870-009880-blobsidecars.seg"sv, "35bb4acf22bcf09839425ef966e81f43fcb65ee3"sv}, Entry{"v1-009870-009880-blocksidecars.idx"sv, "adc3d728e4042493618ef34d45d94651004a1a1e"sv}, Entry{"v1-009880-009890-blobsidecars.seg"sv, "a9134452fe5a78639a825b20a113f7f56e260562"sv}, Entry{"v1-009880-009890-blocksidecars.idx"sv, "0987cd96799edec4b90c9d6607c613ae627831af"sv}, Entry{"v1-009890-009900-blobsidecars.seg"sv, "65685ea9cd845b0bd8807a8796cb6ddfedffbc1d"sv}, Entry{"v1-009890-009900-blocksidecars.idx"sv, "89d148c0e1229bf83a8edd8b6d7799b3159790e8"sv}, Entry{"v1-009900-009910-blobsidecars.seg"sv, "19d90b7b4cc58b3a2c75efe49a9af0d8872334df"sv}, Entry{"v1-009900-009910-blocksidecars.idx"sv, "ea1754683bf8aaf4738b0ada92c4ec5adf7fb8f5"sv}, Entry{"v1-009910-009920-blobsidecars.seg"sv, "453844059c9002fbaa159ee8a5cc13b7d8844091"sv}, Entry{"v1-009910-009920-blocksidecars.idx"sv, "bfd51f577b5ca5f6119f57ecaafad03597e634fa"sv}, Entry{"v1-009920-009930-blobsidecars.seg"sv, "9adcc2c7073ad4a034aab56bc57b93177b421e8a"sv}, Entry{"v1-009920-009930-blocksidecars.idx"sv, "42bb7051c0c5707ac3862a8b2cee65ad2426a283"sv}, Entry{"v1-009930-009940-blobsidecars.seg"sv, "cf4cd07553c985c5dea2354017804c395353c989"sv}, Entry{"v1-009930-009940-blocksidecars.idx"sv, "cfe0cd76e0de2e9895de810093deae0e3fa710a1"sv}, Entry{"v1-009940-009950-blobsidecars.seg"sv, "e7f5f3e6ad73fd1b94c9cd400ded37cf92aa4718"sv}, Entry{"v1-009940-009950-blocksidecars.idx"sv, "0a41c61172c432cdefdcad01fd88ac42666bad24"sv}, Entry{"v1-009950-009960-blobsidecars.seg"sv, "061a0d7781cb52cdf7e073a728d4c76c401c8df0"sv}, Entry{"v1-009950-009960-blocksidecars.idx"sv, "d7052eed38edc7acffd5b26e351d45b176577ef5"sv}, Entry{"v1-009960-009970-blobsidecars.seg"sv, "fcd93bffdda33bb9c837384a06d8c09ec4f99932"sv}, Entry{"v1-009960-009970-blocksidecars.idx"sv, "cb9fcfa272957965e7d8c2d18a5f644948bf0f7c"sv}, Entry{"v1-009970-009980-blobsidecars.seg"sv, "6820436ce2aa8fd2797e6c48a0de89040c1d45b5"sv}, Entry{"v1-009970-009980-blocksidecars.idx"sv, "3688c20bba020b29d02f9702a3128dbb36c366f3"sv}, Entry{"v1-009980-009990-blobsidecars.seg"sv, "70274aef77c24022fe3a5cb7478d9d5a877815c0"sv}, Entry{"v1-009980-009990-blocksidecars.idx"sv, "81055e4f548cfcdbef073e22fb748b0f535b2121"sv}, Entry{"v1-009990-010000-blobsidecars.seg"sv, "b66496c6c8255b7fa32a9a176e6dc3e04ea3ea3f"sv}, Entry{"v1-009990-010000-blocksidecars.idx"sv, "a4fa54ba8a768847f00bf6bcea3cac2d9fcf2aff"sv}, Entry{"v1-010000-010010-blobsidecars.seg"sv, "51c11187b8ef781e94b0926adc2ee807745111b9"sv}, Entry{"v1-010000-010010-blocksidecars.idx"sv, "e5ee12cf40c5e44b043ee15ebc018d9ed206534e"sv}, Entry{"v1-010000-010500-bodies.idx"sv, "c5b5c69801a81f09be4414bc785693b82e2d9c24"sv}, Entry{"v1-010000-010500-bodies.seg"sv, "542b3f77a2f3c4b9d8a4085d838bdd1b14043f3b"sv}, Entry{"v1-010000-010500-headers.idx"sv, "3e8eb31d2a84fdbaed9eb438efe2f94125c2c215"sv}, Entry{"v1-010000-010500-headers.seg"sv, "080d0cd1613831820c8f5e48715d68643f48054a"sv}, Entry{"v1-010000-010500-transactions-to-block.idx"sv, "b5164e95945a5b9a7b9ad267986af5e3ac4fa21f"sv}, Entry{"v1-010000-010500-transactions.idx"sv, "90fc68a4a9275ed4d1e68e771cde18922db0234e"sv}, Entry{"v1-010000-010500-transactions.seg"sv, "8151bbc8b6635465760af6ebcfd630c9679b31a5"sv}, Entry{"v1-010010-010020-blobsidecars.seg"sv, "e9c7573b98153ac2bf30700aa175cee27a4daced"sv}, Entry{"v1-010010-010020-blocksidecars.idx"sv, "0430a88c173ebd1950de44e83d3079ec77f9c556"sv}, Entry{"v1-010020-010030-blobsidecars.seg"sv, "f4ef19d2bc99070de1c5d8a12d13514ff03056f5"sv}, Entry{"v1-010020-010030-blocksidecars.idx"sv, "7518468d26e659e344c594db4cd03f3f96eaa97f"sv}, Entry{"v1-010030-010040-blobsidecars.seg"sv, "a5974c97486fa50a48a708a16d266c5395ee4dff"sv}, Entry{"v1-010030-010040-blocksidecars.idx"sv, "7efe86634c1b4f2878cfc7f733e5ed3f8c1ad0bb"sv}, Entry{"v1-010040-010050-blobsidecars.seg"sv, "17dab88ab78b4356e37b71c6f9f3e7a7ead0153c"sv}, Entry{"v1-010040-010050-blocksidecars.idx"sv, "e8ea0433c595b417936938343c4fcae07b2cd38d"sv}, Entry{"v1-010050-010060-blobsidecars.seg"sv, "12fa7d9759903763d8d9ed0f2a652bbc28e23a59"sv}, Entry{"v1-010050-010060-blocksidecars.idx"sv, "40cf743a5036beef00650a80dea16d1c0b1c3a60"sv}, Entry{"v1-010060-010070-blobsidecars.seg"sv, "15e36a76138e871a956962f156d2cef164eecea7"sv}, Entry{"v1-010060-010070-blocksidecars.idx"sv, "3eb5f45fe886f20a7df35589e9b3a80b8b314597"sv}, Entry{"v1-010070-010080-blobsidecars.seg"sv, "8ee0745ed938033db09a850091819fa238c40c90"sv}, Entry{"v1-010070-010080-blocksidecars.idx"sv, "4a5a9fc8253d889e6b931f3a16f130d82d1924fc"sv}, Entry{"v1-010080-010090-blobsidecars.seg"sv, "4cdc51d96dc48dee011a58db3e560753b9b14927"sv}, Entry{"v1-010080-010090-blocksidecars.idx"sv, "b816f31eb8897780f057d996171f15164fc045e3"sv}, Entry{"v1-010090-010100-blobsidecars.seg"sv, "34f035f3eb97dad08c6ee0b19901c532d49acf70"sv}, Entry{"v1-010090-010100-blocksidecars.idx"sv, "8cd47f6881095ae3f928a4f158defc5dd0fdb5f0"sv}, Entry{"v1-010100-010110-blobsidecars.seg"sv, "9519ae32a90c20f95439a881ddcfffd1ad56436b"sv}, Entry{"v1-010100-010110-blocksidecars.idx"sv, "aa98da28a274a4462bcdd779e0bba45aeb8ab000"sv}, Entry{"v1-010110-010120-blobsidecars.seg"sv, "573b63420fc22fc6d2913493f66443cf6841cb91"sv}, Entry{"v1-010110-010120-blocksidecars.idx"sv, "6ac5492255ed56b802ae78f500e598ab260cc1c8"sv}, Entry{"v1-010120-010130-blobsidecars.seg"sv, "d2b673f78a64f3014040e1e26ebd0914085ba54a"sv}, Entry{"v1-010120-010130-blocksidecars.idx"sv, "beacfcaf77ba8c9881949bbcb4525fb18a3cb7ff"sv}, Entry{"v1-010130-010140-blobsidecars.seg"sv, "0dd944e6fa121939063e4a481543498145fca0d0"sv}, Entry{"v1-010130-010140-blocksidecars.idx"sv, "8eab96b2fae44c3d749e6a2b5d9c0fe1db2cfb81"sv}, Entry{"v1-010140-010150-blobsidecars.seg"sv, "318cc3cf324bf1dabac0dc481021852801e6dc95"sv}, Entry{"v1-010140-010150-blocksidecars.idx"sv, "d0bed06e981cc3601a7b0934ff27176a9618e9f3"sv}, Entry{"v1-010150-010160-blobsidecars.seg"sv, "dfa1e03207174386d53ec27f8b72af05f9b92ca0"sv}, Entry{"v1-010150-010160-blocksidecars.idx"sv, "77000d6c8f42ce16b107348681dc2c0d4f2e2151"sv}, Entry{"v1-010160-010170-blobsidecars.seg"sv, "464a654947909326c3845b295506034d9b28bbe5"sv}, Entry{"v1-010160-010170-blocksidecars.idx"sv, "12aacd80f6b50d09fd09dc3c21beff88a956e5b5"sv}, Entry{"v1-010170-010180-blobsidecars.seg"sv, "3bd8a011fbb560937113622a78f2d82477a96fb1"sv}, Entry{"v1-010170-010180-blocksidecars.idx"sv, "3a9ba5cca6b7854b02e9b1e49c129718780e1234"sv}, Entry{"v1-010180-010190-blobsidecars.seg"sv, "365cbfd303ce331d36d60459ecf18b1d2b2db4a9"sv}, Entry{"v1-010180-010190-blocksidecars.idx"sv, "a8185d58a9c00c863338f430cdc026d70fb7eb30"sv}, Entry{"v1-010500-011000-bodies.idx"sv, "356b9d3947b135f1f86771e0c1aeea4deffbdab9"sv}, Entry{"v1-010500-011000-bodies.seg"sv, "cb3baf683df08747eb02b270f57d594851928f4e"sv}, Entry{"v1-010500-011000-headers.idx"sv, "4c075729af495a1760405be1e6eab0af6ed54d69"sv}, Entry{"v1-010500-011000-headers.seg"sv, "ccbc5f4aaf791b0fa681efaadd3737d9bc53607a"sv}, Entry{"v1-010500-011000-transactions-to-block.idx"sv, "315d9a7069b867771f38af92ab7b4726fc6f5a10"sv}, Entry{"v1-010500-011000-transactions.idx"sv, "c5559f6d3bc250090c8a56b53bbfe5f1c7ef16c7"sv}, Entry{"v1-010500-011000-transactions.seg"sv, "8750bb15269d56a2a16706c0e90644477b50b452"sv}, Entry{"v1-011000-011500-bodies.idx"sv, "0afbc44bcb0c603e7224de7c9c6d1feeadbc220b"sv}, Entry{"v1-011000-011500-bodies.seg"sv, "90590f137f033fa129b12866812360da76a0d65a"sv}, Entry{"v1-011000-011500-headers.idx"sv, "86de406af4ebeb4cbc944e9e2683bc1e117d89f3"sv}, Entry{"v1-011000-011500-headers.seg"sv, "44f38bd08de04fc7bec20aa180dc930ed2da9a42"sv}, Entry{"v1-011000-011500-transactions-to-block.idx"sv, "0a2a4baf145309593dc6ee963f407d92dd3850a9"sv}, Entry{"v1-011000-011500-transactions.idx"sv, "50ee0d87855c94f02fba001190fb30534a7d708e"sv}, Entry{"v1-011000-011500-transactions.seg"sv, "2ed90299cd70a8743e2b8a5671d703fce0e236b9"sv}, Entry{"v1-011500-012000-bodies.idx"sv, "e2f8914def322ad0c72058ce31bb477a75440b19"sv}, Entry{"v1-011500-012000-bodies.seg"sv, "27a68b31b6f80b5c31d2c25d78ec8fb03b59a306"sv}, Entry{"v1-011500-012000-headers.idx"sv, "bc3ea1b5a7732033479c2ad5224132a82e41acce"sv}, Entry{"v1-011500-012000-headers.seg"sv, "5f55cc701448909a2823dbc73e1e9efb8f96fce7"sv}, Entry{"v1-011500-012000-transactions-to-block.idx"sv, "1f691f8579d02e077d3ef8c0bf883f9879b54f0c"sv}, Entry{"v1-011500-012000-transactions.idx"sv, "b94afaae098f5829ce3b070f61f3f0a1b707567a"sv}, Entry{"v1-011500-012000-transactions.seg"sv, "c449b4d7911ade04641e57cecbcbbf3135ce6ff9"sv}, Entry{"v1-012000-012500-bodies.idx"sv, "1a319fc568ad41e4e212ab1a1ae9e661e0de0321"sv}, Entry{"v1-012000-012500-bodies.seg"sv, "ff3b96c7f030c7463c937a1dca41478bf6da65cb"sv}, Entry{"v1-012000-012500-headers.idx"sv, "d666d77d2bf7c7326ffa45b87b830848a015f444"sv}, Entry{"v1-012000-012500-headers.seg"sv, "2bc52f9c15eae0dac9f9c3f6d168e117267285f3"sv}, Entry{"v1-012000-012500-transactions-to-block.idx"sv, "9bd1be12bdea721882496e85d1f121af08a7a670"sv}, Entry{"v1-012000-012500-transactions.idx"sv, "f1fc3cdbad9fecbe60e3ad417d979c19d2220172"sv}, Entry{"v1-012000-012500-transactions.seg"sv, "cf5168f951f1bff0a2d593fd8074691d2cc18513"sv}, Entry{"v1-012500-013000-bodies.idx"sv, "788a4e194b4b077989d9fec4fe5577cbcb1e82ea"sv}, Entry{"v1-012500-013000-bodies.seg"sv, "0f8a0d28428314d4eee35428b9180ee95869a478"sv}, Entry{"v1-012500-013000-headers.idx"sv, "e9a976ec21cdb5bba479f2a2db920b70f281121b"sv}, Entry{"v1-012500-013000-headers.seg"sv, "6cd181dc478b456b0993b1e08e316d8249bc1a41"sv}, Entry{"v1-012500-013000-transactions-to-block.idx"sv, "4ac75e048a5f078624f1ea802df22e957d5d3d2d"sv}, Entry{"v1-012500-013000-transactions.idx"sv, "6226cdcf6afcf8e0c92d517e9981bd587d5a9220"sv}, Entry{"v1-012500-013000-transactions.seg"sv, "3dd8e17042e84c62aa917d07d121fce84a6a1477"sv}, Entry{"v1-013000-013500-bodies.idx"sv, "d3a0b6edd85452192c06e2ec23c7e15e79265130"sv}, Entry{"v1-013000-013500-bodies.seg"sv, "22929bd3952d4aab454a90400e11b66a32ac82d2"sv}, Entry{"v1-013000-013500-headers.idx"sv, "f68c605c9d4619989ac50ede51eae0836e1270b3"sv}, Entry{"v1-013000-013500-headers.seg"sv, "4ea8db1b2afe382c8fa667d052918ec389be0eb7"sv}, Entry{"v1-013000-013500-transactions-to-block.idx"sv, "c8114d93ff84875d8db888b1be5520dc78fd2847"sv}, Entry{"v1-013000-013500-transactions.idx"sv, "b58ada2da059179e3bcb1b6488d1c1b4a5124a3b"sv}, Entry{"v1-013000-013500-transactions.seg"sv, "bda4de72b0b4727c8eaf2e943970c14d07824bf0"sv}, Entry{"v1-013500-014000-bodies.idx"sv, "54990770bbbb40420a9bfe460ad7386c818c2b17"sv}, Entry{"v1-013500-014000-bodies.seg"sv, "45ee58d19f98b58e057327ca9d1ec3d43f3e3278"sv}, Entry{"v1-013500-014000-headers.idx"sv, "3f33a2d0b6900fc676400ad7ec731181d963faff"sv}, Entry{"v1-013500-014000-headers.seg"sv, "3e6b59878079bb5847e379c018937a49280a95aa"sv}, Entry{"v1-013500-014000-transactions-to-block.idx"sv, "75c6d0fcf6d410e5e8d2391d1529a693a4e00047"sv}, Entry{"v1-013500-014000-transactions.idx"sv, "ca91aad849b61caba90427c9b32b0dc9c566aa40"sv}, Entry{"v1-013500-014000-transactions.seg"sv, "a769a66274112809ce75870b440d60c5ccc1fdf3"sv}, Entry{"v1-014000-014500-bodies.idx"sv, "9897ce200dde6885392b1f7ee0b466155a2e70e2"sv}, Entry{"v1-014000-014500-bodies.seg"sv, "70a8b050d1a4abd8424cb8c94d22fff6e58b3fd9"sv}, Entry{"v1-014000-014500-headers.idx"sv, "d0f636059349c9da7b407e122cea9078dcdeb01a"sv}, Entry{"v1-014000-014500-headers.seg"sv, "fa45e222c6a01f6090d968cf93d105947dab72cd"sv}, Entry{"v1-014000-014500-transactions-to-block.idx"sv, "3c0cb12caabe2769bb58b716a70c9df0ab59c76c"sv}, Entry{"v1-014000-014500-transactions.idx"sv, "221deecb17f9a914962aed7b4e446023abd0cf20"sv}, Entry{"v1-014000-014500-transactions.seg"sv, "90d9b1aea87a5f86b40613bd2935e812f183b7e7"sv}, Entry{"v1-014500-015000-bodies.idx"sv, "6e469470d16b87672dc3943cbb8f765c26c98e7c"sv}, Entry{"v1-014500-015000-bodies.seg"sv, "ee52f47d12eed45f7be6f1946e44e72902305a20"sv}, Entry{"v1-014500-015000-headers.idx"sv, "df74abaa5e020926add485fb78450568361ec55b"sv}, Entry{"v1-014500-015000-headers.seg"sv, "5ebc904e2b37f8626e5b853a556b2a70a6f7fd11"sv}, Entry{"v1-014500-015000-transactions-to-block.idx"sv, "7c7b21065bf09d7dfd8032238f6509989052f3fa"sv}, Entry{"v1-014500-015000-transactions.idx"sv, "04b80d3e1a7665aeda512ac0848566cc3cd234ab"sv}, Entry{"v1-014500-015000-transactions.seg"sv, "ab2a3f331beb1665f23dede6042e5bb69e16328b"sv}, Entry{"v1-015000-015500-bodies.idx"sv, "a77a36d1ff2be06166bd8192529b8d8ade4cf237"sv}, Entry{"v1-015000-015500-bodies.seg"sv, "7255de209286291b92536dc39011bbc412b0a768"sv}, Entry{"v1-015000-015500-headers.idx"sv, "de7f2ca37cb0c11eefea6b123cea85ba8f85180e"sv}, Entry{"v1-015000-015500-headers.seg"sv, "e0ab74758b5900442fe9e6f49570748145e95345"sv}, Entry{"v1-015000-015500-transactions-to-block.idx"sv, "1f8817dd48b1e36e9ea65876f555bda70591c8ba"sv}, Entry{"v1-015000-015500-transactions.idx"sv, "39a8d799c2af2170f0b960a14ae23a6ee47c2c79"sv}, Entry{"v1-015000-015500-transactions.seg"sv, "287e852f07da9e43ef4076abc81d38767755bcd8"sv}, Entry{"v1-015500-016000-bodies.idx"sv, "8367e2a9909aeaba8a2162d279ed7f0bbe35c4b5"sv}, Entry{"v1-015500-016000-bodies.seg"sv, "12ded631880b051c700abb700d4b48155e68b08e"sv}, Entry{"v1-015500-016000-headers.idx"sv, "6c9a5f13b877c402fce42a66d902efa62d1384cf"sv}, Entry{"v1-015500-016000-headers.seg"sv, "a6515b9a2b610ed91170a5ee1abeb0169c1ac840"sv}, Entry{"v1-015500-016000-transactions-to-block.idx"sv, "95006fab6fe31c6b045a7b105dc75a25e36b85f8"sv}, Entry{"v1-015500-016000-transactions.idx"sv, "61cb1f2aa78b476d301503ceda5ba5a895143510"sv}, Entry{"v1-015500-016000-transactions.seg"sv, "86de5302fde21256c37addda075ba2198eddf5dd"sv}, Entry{"v1-016000-016500-bodies.idx"sv, "66e83d60a46f8725915bbb46bd789b0093648a7d"sv}, Entry{"v1-016000-016500-bodies.seg"sv, "910ed8afd69ce09e1543487825f3a90f755f79df"sv}, Entry{"v1-016000-016500-headers.idx"sv, "eb0f4dbae88c8bed3a20aaaab0e788f48632988d"sv}, Entry{"v1-016000-016500-headers.seg"sv, "f36bf33b159d320624c04d0c57f72492dd30288c"sv}, Entry{"v1-016000-016500-transactions-to-block.idx"sv, "2a61b938daa327ba779ec10f6d4a7ceb64b29dfc"sv}, Entry{"v1-016000-016500-transactions.idx"sv, "7a4a43166dc359db7e731537117e5f3963dd724a"sv}, Entry{"v1-016000-016500-transactions.seg"sv, "c07c0324970f409a9faa47ce106b770c6cd7b851"sv}, Entry{"v1-016500-017000-bodies.idx"sv, "86f2d4b0ecd2fdb6029b9832eb26bc229b0db6ce"sv}, Entry{"v1-016500-017000-bodies.seg"sv, "d098d8f7c9d3fdcff92feabe01cdc2f27f539c76"sv}, Entry{"v1-016500-017000-headers.idx"sv, "de258c700d4a2d8e307669da9c331d24e0a3b371"sv}, Entry{"v1-016500-017000-headers.seg"sv, "6ddbaead0348a4cfe2ce08fd312eb2772a2f1920"sv}, Entry{"v1-016500-017000-transactions-to-block.idx"sv, "a745e414326102ecb216ba41432a873f0de55bad"sv}, Entry{"v1-016500-017000-transactions.idx"sv, "c15a2aee9842298ab157bdfff6deaf8e2cc6c1c7"sv}, Entry{"v1-016500-017000-transactions.seg"sv, "77ef7146bb34a66de867be42cbdfd754efa11c59"sv}, Entry{"v1-017000-017500-bodies.idx"sv, "e6c50339cc86e982ce980592c69b23ace18b4b6d"sv}, Entry{"v1-017000-017500-bodies.seg"sv, "0e0ea3be565df0821c70a78bfa6cbe135a67e64b"sv}, Entry{"v1-017000-017500-headers.idx"sv, "68139269b68d072cbebdce43145529564f575dd7"sv}, Entry{"v1-017000-017500-headers.seg"sv, "2ceb3f71e7e6d577426b93f31d3a71749015f6d6"sv}, Entry{"v1-017000-017500-transactions-to-block.idx"sv, "f58d21e9ac4c0db4626c96cc03d35c240d419514"sv}, Entry{"v1-017000-017500-transactions.idx"sv, "15caa7efd81d2ff35be3f979801246fb9132a131"sv}, Entry{"v1-017000-017500-transactions.seg"sv, "56cdc16b2c5bba702eba6be79c04db138bd36867"sv}, Entry{"v1-017500-018000-bodies.idx"sv, "41dd00a30088158bbaed19bf2c8d9171e0af00f6"sv}, Entry{"v1-017500-018000-bodies.seg"sv, "b725c77a8afdf536b0b72966b2dee1c1e2d88e0c"sv}, Entry{"v1-017500-018000-headers.idx"sv, "02fa63fcda965d1dc29dc20bd8b0a29256acd06e"sv}, Entry{"v1-017500-018000-headers.seg"sv, "c301e34bb6926cc1a4082290c272c918d9db65fa"sv}, Entry{"v1-017500-018000-transactions-to-block.idx"sv, "a3b139d69beedb5075a347b8aef078981c0a2f4b"sv}, Entry{"v1-017500-018000-transactions.idx"sv, "c663b1cb8c17721e024e5c5c6c588799c46b9c7b"sv}, Entry{"v1-017500-018000-transactions.seg"sv, "51c68ca7c337b2e8dbe1d17da256f3f0fbd30d89"sv}, Entry{"v1-018000-018100-bodies.idx"sv, "c91af9e6554b1d0fb944487f093ca15f0e659ac6"sv}, Entry{"v1-018000-018100-bodies.seg"sv, "17693397d915b4aac755f11e54306e8966ce1c40"sv}, Entry{"v1-018000-018100-headers.idx"sv, "d5bb905ffd03600fde57eb2c57a2e2c5393b6b48"sv}, Entry{"v1-018000-018100-headers.seg"sv, "ac43980d51fc3c48c4b0a0e267b720d1b04a831a"sv}, Entry{"v1-018000-018100-transactions-to-block.idx"sv, "7504e827d73ba95b49966f462ffc9067da0ebb5f"sv}, Entry{"v1-018000-018100-transactions.idx"sv, "8ade8aa91e2a69f356e7c639828c87ab1ef05c4e"sv}, Entry{"v1-018000-018100-transactions.seg"sv, "2e68310ad71d4e0a5573407295efde9f06cfa239"sv}, Entry{"v1-018100-018200-bodies.idx"sv, "e55f174f72c5623c2b7f5ab584c5b6c89a250ba9"sv}, Entry{"v1-018100-018200-bodies.seg"sv, "9ba1712859a78aaabd934686c1b3934358ac88ff"sv}, Entry{"v1-018100-018200-headers.idx"sv, "cf454fb1f17142594d7c0b9a26e9dce35a7ff832"sv}, Entry{"v1-018100-018200-headers.seg"sv, "f29e1a5965327c1a0182268096087c69b28ca9c1"sv}, Entry{"v1-018100-018200-transactions-to-block.idx"sv, "c90131c74c093b6952a6e9da6d62dd946eabb595"sv}, Entry{"v1-018100-018200-transactions.idx"sv, "3a8d391e0f8982bcae0278ef4365302cc11fdef0"sv}, Entry{"v1-018100-018200-transactions.seg"sv, "d1752df016afccab8d37863c676fa17b7ea0e1b4"sv}, Entry{"v1-018200-018300-bodies.idx"sv, "4c8ca7c873c8e841ff0716f0cfe440baab27806c"sv}, Entry{"v1-018200-018300-bodies.seg"sv, "6cd5dbd8a51bc687362f178be3bb1a0700ca1151"sv}, Entry{"v1-018200-018300-headers.idx"sv, "8902b330cbbc497f47f6c7a238cb3fe30eab1e10"sv}, Entry{"v1-018200-018300-headers.seg"sv, "6113b8d4d4dfdf12a7a8cdd6ea62312838a321bc"sv}, Entry{"v1-018200-018300-transactions-to-block.idx"sv, "6850e2e8377e8b4efc486072a4377fa1151b66b4"sv}, Entry{"v1-018200-018300-transactions.idx"sv, "1140e51728101ad066c1df48e93e95b66e62fad6"sv}, Entry{"v1-018200-018300-transactions.seg"sv, "499d4bfcf772ec24fd467ad14941508f586c1f58"sv}, Entry{"v1-018300-018400-bodies.idx"sv, "159aa7da11f989fbc4fdd72ff09e5d7bada4ec54"sv}, Entry{"v1-018300-018400-bodies.seg"sv, "44f4bb367c2794872ac62dd8637ef408572713a0"sv}, Entry{"v1-018300-018400-headers.idx"sv, "45720ce2dea04e5c009ced10c8ea48cb331ce130"sv}, Entry{"v1-018300-018400-headers.seg"sv, "0a1501312ba5b76b7a53207216c648aff9b32e41"sv}, Entry{"v1-018300-018400-transactions-to-block.idx"sv, "9dd2449a2d9c4efddabf4ab9f116250bb8f4ee28"sv}, Entry{"v1-018300-018400-transactions.idx"sv, "4146eb975dc5058659d9abec85db47df74d2fcc9"sv}, Entry{"v1-018300-018400-transactions.seg"sv, "a1f1a9e6e116dfbc062b591fcd6c66d1209ee596"sv}, Entry{"v1-018400-018500-bodies.idx"sv, "a9199bf0580c09a529c4ee32dede9b0c71cec908"sv}, Entry{"v1-018400-018500-bodies.seg"sv, "416a2274d0101e56c9e47b2e3bc5a6469de5df54"sv}, Entry{"v1-018400-018500-headers.idx"sv, "85cc4667fd07dc78f26409ffc0cfeedff185e92d"sv}, Entry{"v1-018400-018500-headers.seg"sv, "8cc90b650f634077d484e8a9b5f2b4dfe70a8096"sv}, Entry{"v1-018400-018500-transactions-to-block.idx"sv, "4f0a54a3094acc3846d612bf34115cfc87114df8"sv}, Entry{"v1-018400-018500-transactions.idx"sv, "843faa27676e3e677080b89f52c4457c4847b97f"sv}, Entry{"v1-018400-018500-transactions.seg"sv, "8fdabce1324895b1a9732572fab28d9d2cb3ee48"sv}, Entry{"v1-018500-018600-bodies.idx"sv, "575646f94a1d18213224de55b8f85f7efc3029a7"sv}, Entry{"v1-018500-018600-bodies.seg"sv, "7c4c95a98046e56ce0045a550c551592693d281c"sv}, Entry{"v1-018500-018600-headers.idx"sv, "4568033c46972c8d819594b182a52fb18eb06bb9"sv}, Entry{"v1-018500-018600-headers.seg"sv, "32e665c9379b86bdf8d00196a81ff6ac7925e56c"sv}, Entry{"v1-018500-018600-transactions-to-block.idx"sv, "1c3241dc2b32b5c7aa52913793a448856d6e6f88"sv}, Entry{"v1-018500-018600-transactions.idx"sv, "df28507072568458df09ee5c65b05f80136a48e5"sv}, Entry{"v1-018500-018600-transactions.seg"sv, "c1549a553b7b4681fe50107fe134ac4b3009800d"sv}, Entry{"v1-018600-018700-bodies.idx"sv, "2f709da7db5150b9de17a2970d69622ede067f78"sv}, Entry{"v1-018600-018700-bodies.seg"sv, "c10c7138967149cea4a9da9eb779e0a71f223ead"sv}, Entry{"v1-018600-018700-headers.idx"sv, "b8dfd5500b467a0b88905a60edc7d2e96ee95eb5"sv}, Entry{"v1-018600-018700-headers.seg"sv, "29adbaf276e8dc064638c4789407da7707e0ddbe"sv}, Entry{"v1-018600-018700-transactions-to-block.idx"sv, "a679fa070b39575d95f92a3c10f7f6ae9f68b28b"sv}, Entry{"v1-018600-018700-transactions.idx"sv, "9734c045fe970c3b4c1782e731db1c1acaf45c00"sv}, Entry{"v1-018600-018700-transactions.seg"sv, "1b6ae2b81b0318091a49c5efd860d87106532b35"sv}, Entry{"v1-018700-018800-bodies.idx"sv, "70e9c1b7ab412b98c633dc7d3f2c959177b80f0b"sv}, Entry{"v1-018700-018800-bodies.seg"sv, "2a008a1054c43fd6df76e6845d04d54d7cd2ba60"sv}, Entry{"v1-018700-018800-headers.idx"sv, "67e4612809a6a2d088e643886201f860ee1eb310"sv}, Entry{"v1-018700-018800-headers.seg"sv, "0dbbde72ebefd2c8292955c6080ab46274db403f"sv}, Entry{"v1-018700-018800-transactions-to-block.idx"sv, "c7516daad0f9761810392bd709f9c0a4e840c233"sv}, Entry{"v1-018700-018800-transactions.idx"sv, "1900c7a24bb0abc793ff604d20ef9da9c528a722"sv}, Entry{"v1-018700-018800-transactions.seg"sv, "fd7f0debd08acf5bd0a2b22e081dfeb5b764fefe"sv}, Entry{"v1-018800-018900-bodies.idx"sv, "41c42199d0e96620bfb59b885ae35da5adece434"sv}, Entry{"v1-018800-018900-bodies.seg"sv, "93ce47fc00a0d834d98080157d4f25cb8ce58fa9"sv}, Entry{"v1-018800-018900-headers.idx"sv, "6554e85a1c12dfa54529567ce2cdee95a0053224"sv}, Entry{"v1-018800-018900-headers.seg"sv, "5a1bbe8ff503a20e8e3d37faa59e35a12ca25dbc"sv}, Entry{"v1-018800-018900-transactions-to-block.idx"sv, "bab01fc2462719e2699004ed46af95a6ef6f9a24"sv}, Entry{"v1-018800-018900-transactions.idx"sv, "2eb4b5c4228e28cdcbd3b03fee14aac0ba978516"sv}, Entry{"v1-018800-018900-transactions.seg"sv, "96f41ef304fa764526d786faaf2bc0f12c7beb90"sv}, Entry{"v1-018900-019000-bodies.idx"sv, "ec3b33e3361c227be287cf43adf7c7e283128b7c"sv}, Entry{"v1-018900-019000-bodies.seg"sv, "c94c56736466d2bdbee5c88d7bf027d3681c9110"sv}, Entry{"v1-018900-019000-headers.idx"sv, "74ec4a580b10d001668d760288abf3a10d735b1d"sv}, Entry{"v1-018900-019000-headers.seg"sv, "1982993b5f96b2a1f3864596771166efa7a6188b"sv}, Entry{"v1-018900-019000-transactions-to-block.idx"sv, "26934d94a9a0fc98bc0b542e5f5db90b16c792ed"sv}, Entry{"v1-018900-019000-transactions.idx"sv, "9f06ad09091118d7cc28615c4373f9f08299577b"sv}, Entry{"v1-018900-019000-transactions.seg"sv, "cf8a0b6865fdde716698b5974e7e98f7ff4774b1"sv}, Entry{"v1-019000-019100-bodies.idx"sv, "0d39e950141730deef28dedd2e7d6c85242ced86"sv}, Entry{"v1-019000-019100-bodies.seg"sv, "2ce8570e9ca7243bd3382caaa7f572736c8acff7"sv}, Entry{"v1-019000-019100-headers.idx"sv, "773d43e883de57bb701f00c083bd32a3f506fd6c"sv}, Entry{"v1-019000-019100-headers.seg"sv, "03fad91a0392def71a9a97a4e601e293890584e1"sv}, Entry{"v1-019000-019100-transactions-to-block.idx"sv, "2c93a75f4543479ca31a3c3f0b3802b9835ba650"sv}, Entry{"v1-019000-019100-transactions.idx"sv, "93af24af322f7f81e0a5fa2785bc6c4265e93e8e"sv}, Entry{"v1-019000-019100-transactions.seg"sv, "df879e1cb4d115ce807259a20272a26f2b7663fe"sv}, Entry{"v1-019100-019200-bodies.idx"sv, "9dbb97afd8d12071cca468956c7fbe0710019998"sv}, Entry{"v1-019100-019200-bodies.seg"sv, "56ac1a38b737bfe39f96a89fe520e9e491225a7a"sv}, Entry{"v1-019100-019200-headers.idx"sv, "ca062073efc280bfb2892068e4e085a693cf2d27"sv}, Entry{"v1-019100-019200-headers.seg"sv, "139bc8efbfa6b78fef6e20725cc3bb32a444c707"sv}, Entry{"v1-019100-019200-transactions-to-block.idx"sv, "7b35932d449bb6c151ac0a6be88356b37f1548be"sv}, Entry{"v1-019100-019200-transactions.idx"sv, "0f87ae9f20fa095020a06f76a1034fbe03c7e02b"sv}, Entry{"v1-019100-019200-transactions.seg"sv, "f220320ec937426d4b6cb83d7d6971156b14e0cf"sv}, Entry{"v1-019200-019300-bodies.idx"sv, "f4d66360aaff399b2f39202c7e9379892be2b143"sv}, Entry{"v1-019200-019300-bodies.seg"sv, "03f32d0afc8dfe0ffece4e4ede669ca659694f07"sv}, Entry{"v1-019200-019300-headers.idx"sv, "7085d5b9b819fed5c978be3f5ae581a7da37ed60"sv}, Entry{"v1-019200-019300-headers.seg"sv, "0313df1fa5f78277a5da7b14f4a80854f53228ea"sv}, Entry{"v1-019200-019300-transactions-to-block.idx"sv, "10925f69df9b992069cea84784b58e3df764e7bc"sv}, Entry{"v1-019200-019300-transactions.idx"sv, "4f76ff467b4016c3ad54e8c066731a02d5485f4a"sv}, Entry{"v1-019200-019300-transactions.seg"sv, "97c6e6109c927dbb9174eb29fe91254d727dced2"sv}, Entry{"v1-019300-019400-bodies.idx"sv, "d0d741a8f59ec69d7b51d7c2cecd49f7a1855385"sv}, Entry{"v1-019300-019400-bodies.seg"sv, "756186a7c16da7677299b16fe9f047644779e80f"sv}, Entry{"v1-019300-019400-headers.idx"sv, "0b2482896cb85398016b8525137e9955174f677e"sv}, Entry{"v1-019300-019400-headers.seg"sv, "c8869efc2a92384f1449f35da0571dd37f621de1"sv}, Entry{"v1-019300-019400-transactions-to-block.idx"sv, "2a702a7718a8ba5de1865d83357a915a66df45e5"sv}, Entry{"v1-019300-019400-transactions.idx"sv, "6e6316567c6c7fb0a20e10afa9f345f2cdff7d62"sv}, Entry{"v1-019300-019400-transactions.seg"sv, "d62fbe4751f7678f0596b1e1ad69bec89aefe513"sv}, Entry{"v1-019400-019500-bodies.idx"sv, "7988187bb33bdaf90f3b547dcab2cbe029aa118c"sv}, Entry{"v1-019400-019500-bodies.seg"sv, "7983a1e24e70b46f71e291cd773327ed458042d7"sv}, Entry{"v1-019400-019500-headers.idx"sv, "b380c66ebc55dcde12277507faa163e1ef84b9c5"sv}, Entry{"v1-019400-019500-headers.seg"sv, "69e8d80b22e358718f729ccb791d13840efdb0bb"sv}, Entry{"v1-019400-019500-transactions-to-block.idx"sv, "b5518d38cd64b8d0eb383ff7786895af3943b37d"sv}, Entry{"v1-019400-019500-transactions.idx"sv, "f4bd5b6531e6761df7be49ff555e78ce4ce1feb3"sv}, Entry{"v1-019400-019500-transactions.seg"sv, "2efd4ee537d968de3b1ec09c89a7154be7659f5e"sv}, Entry{"v1-019500-019600-bodies.idx"sv, "a3e610de32aa7550bedb241225555479c648330a"sv}, Entry{"v1-019500-019600-bodies.seg"sv, "a90e02a7f88815b1aa3eb27547bf94266d66d711"sv}, Entry{"v1-019500-019600-headers.idx"sv, "d1cb66b586890617d0e7291969990946aebf6acf"sv}, Entry{"v1-019500-019600-headers.seg"sv, "c32e47c1f26e6a9571c0eb3b18a034a95903b8b2"sv}, Entry{"v1-019500-019600-transactions-to-block.idx"sv, "4ac2607b5daf1480f9c1c6d2020c1927bd1a6cc6"sv}, Entry{"v1-019500-019600-transactions.idx"sv, "af102415c3ca606b2b7c249ad8c5a97557ec8e5e"sv}, Entry{"v1-019500-019600-transactions.seg"sv, "4c2de3f422c43b6efc17fdc8e21c8c81afbe99df"sv}, Entry{"v1-019600-019700-bodies.idx"sv, "0089cc9914d05e9cfaabe880c564771852f141db"sv}, Entry{"v1-019600-019700-bodies.seg"sv, "dd302751f3f6037431a7bef5b1ebc51a0a2c472a"sv}, Entry{"v1-019600-019700-headers.idx"sv, "96c15623264530f4bc7b9f368c1cd3c94cf5a80e"sv}, Entry{"v1-019600-019700-headers.seg"sv, "9d8f51c12d9ad321ae5f05374e5e68a49e900e4d"sv}, Entry{"v1-019600-019700-transactions-to-block.idx"sv, "f0aa12645338d1f33b01fb8f1f829f24acf8440e"sv}, Entry{"v1-019600-019700-transactions.idx"sv, "9b7462619e1f99b73fb349f5cc4f8ba9e1a36ca7"sv}, Entry{"v1-019600-019700-transactions.seg"sv, "1c1d3d460e0766563db209c2266034218126ebc2"sv}, Entry{"v1-019700-019800-bodies.idx"sv, "6024f9bf93e134bcc620f5c52ad9f6f0ccabdb86"sv}, Entry{"v1-019700-019800-bodies.seg"sv, "7b3a023cad40fdd513643f93e1cfd1384b4380b6"sv}, Entry{"v1-019700-019800-headers.idx"sv, "82ffc30e978824c3f3086d8ed552638cc6b7da6e"sv}, Entry{"v1-019700-019800-headers.seg"sv, "b157c6c5838951d0c7046c08e7bd19c83f0a38ef"sv}, Entry{"v1-019700-019800-transactions-to-block.idx"sv, "8f4693ceba715ac4f837f82923902843c2004766"sv}, Entry{"v1-019700-019800-transactions.idx"sv, "1aae6653a6d0dfe42665b60aa44ff0fd9260546c"sv}, Entry{"v1-019700-019800-transactions.seg"sv, "3870ab9007979f9e013eb455812f0e35138b6967"sv}, Entry{"v1-019800-019900-bodies.idx"sv, "8ecf2a2466c785a2708099d1b9fbb006e2207369"sv}, Entry{"v1-019800-019900-bodies.seg"sv, "d092d754d2e35ceed2e6210968d8a7184dee6cc6"sv}, Entry{"v1-019800-019900-headers.idx"sv, "0668f2bcbd3bdf9b4ab7e9a490e7567259f67e4a"sv}, Entry{"v1-019800-019900-headers.seg"sv, "a20122bf68b7a47e1d94b677a9e887b685984fd4"sv}, Entry{"v1-019800-019900-transactions-to-block.idx"sv, "01ab1cee814926ab325b8a30895b2b6a153e8376"sv}, Entry{"v1-019800-019900-transactions.idx"sv, "66a308ead1b15cba2f3e5217f1b8cd9bfa7e2efd"sv}, Entry{"v1-019800-019900-transactions.seg"sv, "90cce9cab98ea9789d28bb5bc9b1dd2b125257d5"sv}, Entry{"v1-019900-020000-bodies.idx"sv, "2ab5fd867aa96f6e8fd13d074cf1139d508d09e3"sv}, Entry{"v1-019900-020000-bodies.seg"sv, "4d025aa70c359c6f951c77feac65d5b22f79a4f7"sv}, Entry{"v1-019900-020000-headers.idx"sv, "84e572f3cac8463d902ba88dbb5f3fda007b1e39"sv}, Entry{"v1-019900-020000-headers.seg"sv, "9261fbbb91673d3718140dde9e139b20f41ecd2c"sv}, Entry{"v1-019900-020000-transactions-to-block.idx"sv, "ce64a3a1f40ba35082a9130b80d528fd6f2911e6"sv}, Entry{"v1-019900-020000-transactions.idx"sv, "3c5156dcb62919d0983ded8d59ed39a622a74a6e"sv}, Entry{"v1-019900-020000-transactions.seg"sv, "6989c2fc9ab845fa56272fc9f99808dda8c65615"sv}, Entry{"v1-020000-020100-bodies.idx"sv, "9ce4b26c25a73a64d69a07cd0aba756628832c7f"sv}, Entry{"v1-020000-020100-bodies.seg"sv, "3f43f94f628f873d59f8c002015562588c6e4daf"sv}, Entry{"v1-020000-020100-headers.idx"sv, "176f1352c0a5bea39032bf4520bcaed300c744f6"sv}, Entry{"v1-020000-020100-headers.seg"sv, "e93fc539e2609e3f9284598a69bebe804df23cd0"sv}, Entry{"v1-020000-020100-transactions-to-block.idx"sv, "22143e73bdc307b47e851afb327bbaf6c65b2086"sv}, Entry{"v1-020000-020100-transactions.idx"sv, "c337e61e781f65c770ab2197d8398b957ec1340d"sv}, Entry{"v1-020000-020100-transactions.seg"sv, "314d16dbbbc2c5d9fbf74ad8d002e349a44d57a0"sv}, Entry{"v1-020100-020200-bodies.idx"sv, "9520e63f5db1f147407116b8d4f63eb93e693364"sv}, Entry{"v1-020100-020200-bodies.seg"sv, "9ffa1c08e331f816160fd2ec9caa8d7f7aa51a6e"sv}, Entry{"v1-020100-020200-headers.idx"sv, "c0a207c9a7de1ffc5b57393869d1f172c5aec6a6"sv}, Entry{"v1-020100-020200-headers.seg"sv, "0ef443f6288bb7f972864ddc04798aa777f44c1f"sv}, Entry{"v1-020100-020200-transactions-to-block.idx"sv, "4be1f87728043a1d939808baedfa405f4646cd6b"sv}, Entry{"v1-020100-020200-transactions.idx"sv, "44d82877bdc001e18ef351bd4e5ad82f84d3f779"sv}, Entry{"v1-020100-020200-transactions.seg"sv, "62f5a186c986aa400ab5a46da27b800dfc14ebd4"sv}, Entry{"v1-020200-020300-bodies.idx"sv, "c6ccbf200e72d270d9a2343b066d52494aa0244b"sv}, Entry{"v1-020200-020300-bodies.seg"sv, "93afefb34746b89da76d1cabf5390825171f949d"sv}, Entry{"v1-020200-020300-headers.idx"sv, "09ca610c5b2821412f80b1285ce1d3a1e0c9c068"sv}, Entry{"v1-020200-020300-headers.seg"sv, "b85bf94c8e1070f0df7a0c078765d3e8be931fdf"sv}, Entry{"v1-020200-020300-transactions-to-block.idx"sv, "54fe1b49ee74bb98031fd81db9ebb241364914e3"sv}, Entry{"v1-020200-020300-transactions.idx"sv, "ba210554df4d78e702dc2d96bee194a9083df74a"sv}, Entry{"v1-020200-020300-transactions.seg"sv, "0fe145e9dd2204541b46d2bcb10e7372cf37b5fb"sv}, Entry{"v1-020300-020400-bodies.idx"sv, "308f345c4544c115f8213c2b4a4149246335bd88"sv}, Entry{"v1-020300-020400-bodies.seg"sv, "aa637f0ee48cfc6924a0c6c73c0974fd9b9c5edf"sv}, Entry{"v1-020300-020400-headers.idx"sv, "d271ff9cdd3af1b59736cfb286136ca49ba99cdd"sv}, Entry{"v1-020300-020400-headers.seg"sv, "50f6b9e39e4a0f8d7c579e736316cddcbbaafd2c"sv}, Entry{"v1-020300-020400-transactions-to-block.idx"sv, "9d6cc719cb7fb5049e5a797ad6e11ac7f82607b7"sv}, Entry{"v1-020300-020400-transactions.idx"sv, "3f90ad5d275a2af32d3700dccf9f9ff6c7971dc4"sv}, Entry{"v1-020300-020400-transactions.seg"sv, "c95782cfc168038aacc76a2a09bccd9428c33e05"sv}, Entry{"v1-020400-020500-bodies.idx"sv, "74fc240e76403fd743866341c7d6ffd293b79c78"sv}, Entry{"v1-020400-020500-bodies.seg"sv, "ade2ea1091e31511ad1478e09cabbfb62c9738f6"sv}, Entry{"v1-020400-020500-headers.idx"sv, "361fe11ad9a31b8a37fc0b239af7e75de2c481a9"sv}, Entry{"v1-020400-020500-headers.seg"sv, "ca2c43003869ba21d198cf47afb6fc32fd33c6b9"sv}, Entry{"v1-020400-020500-transactions-to-block.idx"sv, "1bec2e140558c90c336fda1e5b62667e33efbbb8"sv}, Entry{"v1-020400-020500-transactions.idx"sv, "81e181e43b9bada3b82dd46879510baf6cf8e15a"sv}, Entry{"v1-020400-020500-transactions.seg"sv, "4fd4e94516d4cf3054950944514c75f754c86b09"sv}, Entry{"v1-020500-020600-bodies.idx"sv, "6f141b1e85dc0b78a2842a18860847c05fb2b9dc"sv}, Entry{"v1-020500-020600-bodies.seg"sv, "48d95b1210860ae203c7524efe368bdd2a9884e7"sv}, Entry{"v1-020500-020600-headers.idx"sv, "e1900596326fe0ca03246b031595f580d6d5abaa"sv}, Entry{"v1-020500-020600-headers.seg"sv, "dee7a58d14efd1e6ef94302441336f136b703ef6"sv}, Entry{"v1-020500-020600-transactions-to-block.idx"sv, "724444b1c7a47786db64d43954ac1646f85338db"sv}, Entry{"v1-020500-020600-transactions.idx"sv, "a7ed82ec5abe408093a3068db3699ff7dad8ae5d"sv}, Entry{"v1-020500-020600-transactions.seg"sv, "c45eaa0db16a525f77467c9ec0bfc3a5bd2add3a"sv}, Entry{"v1-020600-020700-bodies.idx"sv, "165b5b7ca9d8c69f2bf6c9c9df3aaeff4e2ff188"sv}, Entry{"v1-020600-020700-bodies.seg"sv, "dfda6e7033830f22cb6dcd58f065b6d2958b2fe7"sv}, Entry{"v1-020600-020700-headers.idx"sv, "895c983d1204351979190d3f93aa49ba0de37ed1"sv}, Entry{"v1-020600-020700-headers.seg"sv, "b417f8742ce9f13b4d7d63fe78e073e9cd0d2406"sv}, Entry{"v1-020600-020700-transactions-to-block.idx"sv, "f68d5e4a0a350a3ad4a49f32d119493826b2397a"sv}, Entry{"v1-020600-020700-transactions.idx"sv, "ace929e6b53098a829a4b0d9e99c5e2ed14670c2"sv}, Entry{"v1-020600-020700-transactions.seg"sv, "df2152933722968b99a8de067dcbdd3e481c854a"sv}, Entry{"v1-020700-020800-bodies.idx"sv, "dc640091f9b2febd280edab6f5351b2951452cee"sv}, Entry{"v1-020700-020800-bodies.seg"sv, "e89752cfa93e29af1d9b98c2485cccb76e5006d0"sv}, Entry{"v1-020700-020800-headers.idx"sv, "78b30904e5c5f59d22947dca0748a5b7b4a63489"sv}, Entry{"v1-020700-020800-headers.seg"sv, "0e7c00fa4efd752dc461448ae48f2691fea50c19"sv}, Entry{"v1-020700-020800-transactions-to-block.idx"sv, "d214d91355f1474a643a5cac9c4316d787ddd241"sv}, Entry{"v1-020700-020800-transactions.idx"sv, "bda365b36ef84b116c9544d9c87072bb705cd692"sv}, Entry{"v1-020700-020800-transactions.seg"sv, "f0820e9d091a5fe448033ea6b1401fed82324a21"sv}, Entry{"v1-020800-020900-bodies.idx"sv, "8d00c0b6ba0d312739f62d75a8500ac346021b01"sv}, Entry{"v1-020800-020900-bodies.seg"sv, "ae9b32a6b12bd9746397d3b7db60dee5a05d9430"sv}, Entry{"v1-020800-020900-headers.idx"sv, "a1d211d231fe303bda9c229c8607f1ba6bf85c84"sv}, Entry{"v1-020800-020900-headers.seg"sv, "4f521cea74950541108cbf0479fcee7336a79b82"sv}, Entry{"v1-020800-020900-transactions-to-block.idx"sv, "fc1b9fa9f1872a509072444ff0e05732eec4a30c"sv}, Entry{"v1-020800-020900-transactions.idx"sv, "6bfcc5339ed727f42789cf4793153a1d8b185044"sv}, Entry{"v1-020800-020900-transactions.seg"sv, "4216041a3f0321d109ee449018d94a8a5ee2ddb7"sv}, Entry{"v1-020900-021000-bodies.idx"sv, "f983fd78345da39050416a2d37ce779beca3743c"sv}, Entry{"v1-020900-021000-bodies.seg"sv, "82cecc2d10dcef3360f0e7f3e2f02c49ec39edd8"sv}, Entry{"v1-020900-021000-headers.idx"sv, "b05cbc6a9faa9ef8eff1e1922d1daea1f341160f"sv}, Entry{"v1-020900-021000-headers.seg"sv, "3a66fda9d69a7e6d6f35021f17b1535d92605c0b"sv}, Entry{"v1-020900-021000-transactions-to-block.idx"sv, "68eaf2c4f456d9869a9955670fd3522f8f739994"sv}, Entry{"v1-020900-021000-transactions.idx"sv, "f8184f6a7634314ee08f769100fc3c4cff5d17ce"sv}, Entry{"v1-020900-021000-transactions.seg"sv, "4374725519920a20d9e18f3ad6a8e0aa75561a0a"sv}, Entry{"v1-021000-021010-bodies.idx"sv, "808fd02eeb0b6376edb5e923cc8c0a59a669e87b"sv}, Entry{"v1-021000-021010-bodies.seg"sv, "c39b010db9a6d491948f6d083b60bf4c371c5a5a"sv}, Entry{"v1-021000-021010-headers.idx"sv, "3e1a87317dedf987a8092dda6dd7b73cb13553ce"sv}, Entry{"v1-021000-021010-headers.seg"sv, "03360353987fb1d06dfd0678368b16d0b18bc983"sv}, Entry{"v1-021000-021010-transactions-to-block.idx"sv, "8022f832ff03713566a2d9cf0490a2f49dcf950a"sv}, Entry{"v1-021000-021010-transactions.idx"sv, "16426b40985ff3564def26bc7af6044219851f74"sv}, Entry{"v1-021000-021010-transactions.seg"sv, "e013a24c5ade0e0773f2cfdfbd21fe5876870199"sv}, Entry{"v1-021010-021011-bodies.idx"sv, "2678fd40e39bcee36ec457dd496317b0827cd561"sv}, Entry{"v1-021010-021011-bodies.seg"sv, "6dd51b30f7fdd3e39fa0f7be3d82412d28a72196"sv}, Entry{"v1-021010-021011-headers.idx"sv, "e4e1ad95bd508e0c31b8bb804ccfbf22a88bdaeb"sv}, Entry{"v1-021010-021011-headers.seg"sv, "2a2f021846eca0b33171bc64a2ca7cc1ec07d621"sv}, Entry{"v1-021010-021011-transactions-to-block.idx"sv, "5628ac21e58a244e5af64b68e9c80f3ebd18a42a"sv}, Entry{"v1-021010-021011-transactions.idx"sv, "5fd3f2dd536195e482cd8a54c220dae71e421d89"sv}, Entry{"v1-021010-021011-transactions.seg"sv, "b991fda3362ebd15d91f76a563f479caa1b3b6e8"sv}, Entry{"v1-021011-021012-bodies.idx"sv, "90c70e95115b19bdd50e53366d536414a31914fa"sv}, Entry{"v1-021011-021012-bodies.seg"sv, "6a415c5d0da739a5d8f60b1c4558c7c8191866a3"sv}, Entry{"v1-021011-021012-headers.idx"sv, "2f34b6d28515f62b1c248c5a1b9aa028304e458d"sv}, Entry{"v1-021011-021012-headers.seg"sv, "2b73a5b8d0e23105dd02b3bbd61e850ff93a7210"sv}, Entry{"v1-021011-021012-transactions-to-block.idx"sv, "38ccbb139f0131ea5a566b09fd57e5c2e07db999"sv}, Entry{"v1-021011-021012-transactions.idx"sv, "2ea45edcd1436425bafe8b6d545ee9e18d3d2ac4"sv}, Entry{"v1-021011-021012-transactions.seg"sv, "7c1e4ac2e5846060d3f4bd6f14dbf6fd1904f6d1"sv}, Entry{"v1-021012-021013-bodies.idx"sv, "4a08705983fef7821b9111c9a73b604036bbc9e2"sv}, Entry{"v1-021012-021013-bodies.seg"sv, "62d7b5f376c7be2fabb64240e28997d10322c5e8"sv}, Entry{"v1-021012-021013-headers.idx"sv, "ddaec80beb3fc2cc7d707d0c001b5d8a5d7f819d"sv}, Entry{"v1-021012-021013-headers.seg"sv, "70659317d14e3c165d6aa32dc0f1bd77f870612e"sv}, Entry{"v1-021012-021013-transactions-to-block.idx"sv, "e3d5c49784a91262e25606879b9d01d8039da180"sv}, Entry{"v1-021012-021013-transactions.idx"sv, "c35b083850170a9a7ea7140ba5fca5dbf67d41e8"sv}, Entry{"v1-021012-021013-transactions.seg"sv, "01a5c1a35698fa2726a8be3aaa8002a63568dc1b"sv}, }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/chains/sepolia.hpp ================================================ /* Generated from sepolia.toml using Silkworm embed_toml */ #pragma once #include #include #include "../entry.hpp" namespace silkworm::snapshots { using namespace std::literals; inline constexpr std::array kSepoliaSnapshots{ Entry{"accessor/v1-accounts.0-64.efi"sv, "2bb3a43fa5b3101ed7398ee38561576af20ba0f7"sv}, Entry{"accessor/v1-accounts.0-64.vi"sv, "4a0a5b3175b473ec62e4d648576dc46e03c37c46"sv}, Entry{"accessor/v1-accounts.128-192.efi"sv, "5ef169dd8415cd035597d29405df4f693243c62d"sv}, Entry{"accessor/v1-accounts.128-192.vi"sv, "379f36d58cf99d75d73328ef154ca375cfdf73c7"sv}, Entry{"accessor/v1-accounts.192-208.efi"sv, "0ae1fb2f45c2071548891ae299521352dd614f19"sv}, Entry{"accessor/v1-accounts.192-208.vi"sv, "29f849fc0e0fbe303794f1190fb5fe40bd5e0142"sv}, Entry{"accessor/v1-accounts.208-209.efi"sv, "47737a0fd90d77d2cd7eb89d11cba53856b592f5"sv}, Entry{"accessor/v1-accounts.208-209.vi"sv, "d142fc8cff6ee916239e9b0307a55d56b05fb6e8"sv}, Entry{"accessor/v1-accounts.64-128.efi"sv, "a53229ca7ec9b6db6376d8b85197bcd9c53daaa5"sv}, Entry{"accessor/v1-accounts.64-128.vi"sv, "c979e2b9bbed46ed8b41cfbb8f290841ac2e09dd"sv}, Entry{"accessor/v1-code.0-64.efi"sv, "28ddea8c270898fa8588cfa5f222c76e5602e895"sv}, Entry{"accessor/v1-code.0-64.vi"sv, "dce0937597f2997d42de48d8dd354069a02f46c6"sv}, Entry{"accessor/v1-code.128-192.efi"sv, "02b37286a48a4d8ce75e719b5478d34e226a29e2"sv}, Entry{"accessor/v1-code.128-192.vi"sv, "0ab5fe774c7b2264d9870477cd33ef385eff095e"sv}, Entry{"accessor/v1-code.192-208.efi"sv, "e0497466b14eafed864265ec3f4ab3087ac44fef"sv}, Entry{"accessor/v1-code.192-208.vi"sv, "5282583c683c3c36821f5e50fb2e41b451fb775a"sv}, Entry{"accessor/v1-code.208-209.efi"sv, "1bdc1dc6b8c479167670bbaaeee341c6ff2d6ad1"sv}, Entry{"accessor/v1-code.208-209.vi"sv, "a4c4248578c62b9caa890da05512d90344142f80"sv}, Entry{"accessor/v1-code.64-128.efi"sv, "91efabed02d48e786a0df6c4272d46f2e144b743"sv}, Entry{"accessor/v1-code.64-128.vi"sv, "2b1e7ef62762e584c893dede43bc2fa81bddf1f5"sv}, Entry{"accessor/v1-logaddrs.0-64.efi"sv, "5bbf9fa85e546d554b8d921e0912958a1793cf54"sv}, Entry{"accessor/v1-logaddrs.128-192.efi"sv, "1dc6513d2f3410fe8c58f41de39c09b2c2e98f67"sv}, Entry{"accessor/v1-logaddrs.192-208.efi"sv, "60212435de03041b2c3d7ba2a312fbbe2d139d87"sv}, Entry{"accessor/v1-logaddrs.208-209.efi"sv, "2f197e352075153790dc3f8ccfe2168f08840fd2"sv}, Entry{"accessor/v1-logaddrs.64-128.efi"sv, "a154e7791c341f1f89d2f0f0c2b010df79a77aeb"sv}, Entry{"accessor/v1-logtopics.0-64.efi"sv, "a8cc203775ad1406ceaed58f5a1ab4f6c1880681"sv}, Entry{"accessor/v1-logtopics.128-192.efi"sv, "11515f388b895dc75ea2f5973c930113b532ff8d"sv}, Entry{"accessor/v1-logtopics.192-208.efi"sv, "6fca549e9ecb798c8ccbb0d4e78714a15fdebb15"sv}, Entry{"accessor/v1-logtopics.208-209.efi"sv, "39bb4ada7e5b76d834b8c9cd9151e7bd4a9071f4"sv}, Entry{"accessor/v1-logtopics.64-128.efi"sv, "623a7d6d87c9f98629d394beafd14d364e063241"sv}, Entry{"accessor/v1-receipt.0-64.efi"sv, "40535bc2a15259edb1332922e7054e4d3d513bb6"sv}, Entry{"accessor/v1-receipt.0-64.vi"sv, "61b868921f354009c80afdec2d5031157ef8fe68"sv}, Entry{"accessor/v1-receipt.128-144.efi"sv, "0445b8313b2b6076655fdf26decb04b1dbc54b55"sv}, Entry{"accessor/v1-receipt.128-144.vi"sv, "b81dc44cb12fda4e2c02fc9f4fa382cddfd87888"sv}, Entry{"accessor/v1-receipt.144-148.efi"sv, "ba10eb6ca799cb79b84f68d66b2b8e8fce84aa79"sv}, Entry{"accessor/v1-receipt.144-148.vi"sv, "0c680ea977adecf5d12a3f157b54e74feb820005"sv}, Entry{"accessor/v1-receipt.148-150.efi"sv, "7fd75ce3a9a9c55a78c321999600ec7fa37f87c9"sv}, Entry{"accessor/v1-receipt.148-150.vi"sv, "102b4b7c44f6ab4e1ee58264e6fd0516fba60ba6"sv}, Entry{"accessor/v1-receipt.150-151.efi"sv, "d882c6a78690814fc0e0ae89172098ab40873a45"sv}, Entry{"accessor/v1-receipt.150-151.vi"sv, "cfe500c241bfbfbb4e22a6a8680a0f1a91b904d0"sv}, Entry{"accessor/v1-receipt.192-208.efi"sv, "be866876cb23339fc2f7a2e4f04cd9418d903157"sv}, Entry{"accessor/v1-receipt.192-208.vi"sv, "be0603a70c62d820c73cf8c1b2eeba4e4eac406c"sv}, Entry{"accessor/v1-receipt.208-209.efi"sv, "6f308d357c55b0757acce34e7284df0315eb4d24"sv}, Entry{"accessor/v1-receipt.208-209.vi"sv, "5205c99b26d44b93e75652a6c5612104260a1b48"sv}, Entry{"accessor/v1-receipt.64-128.efi"sv, "63f92b1cc979abc4788dece35d2972d513e93b94"sv}, Entry{"accessor/v1-receipt.64-128.vi"sv, "ddc72fe23640cebe0369d9e75bf67f58a2ae16de"sv}, Entry{"accessor/v1-storage.0-64.efi"sv, "d7728bced602d33298b3f6e80f55de24802acac0"sv}, Entry{"accessor/v1-storage.0-64.vi"sv, "a290170dcef3b8e25a48dc1f143a27f274d78a8c"sv}, Entry{"accessor/v1-storage.128-192.efi"sv, "ffa75cc4c3b387cc4d7066485f3d0bed8170e91a"sv}, Entry{"accessor/v1-storage.128-192.vi"sv, "0922cc9d8aff262220326ce391e89c77a159eac6"sv}, Entry{"accessor/v1-storage.192-208.efi"sv, "8c991b57a6f522dd6d153d37bf61b513e3bd87ac"sv}, Entry{"accessor/v1-storage.192-208.vi"sv, "6e3faa721e2118e7f7a1bf4fc9da4656aa0f10b7"sv}, Entry{"accessor/v1-storage.208-209.efi"sv, "115fe66792a97b79e1d1d1a74de7de99b6665298"sv}, Entry{"accessor/v1-storage.208-209.vi"sv, "2aed2ed07d8006d4dd10110fc133a503ec582846"sv}, Entry{"accessor/v1-storage.64-128.efi"sv, "cd5333fd5f9d986762088f82a3c323139a4d6d50"sv}, Entry{"accessor/v1-storage.64-128.vi"sv, "80d2fcacab75a8abbde695ed9ea7d254e59fb20d"sv}, Entry{"accessor/v1-tracesfrom.0-64.efi"sv, "3dcf74d9b123cda38e3f45cb8adf9aed24c4b5b7"sv}, Entry{"accessor/v1-tracesfrom.128-192.efi"sv, "f1ee549ae5218268b3ddccd5d21d269c7ea41091"sv}, Entry{"accessor/v1-tracesfrom.192-208.efi"sv, "337339476140ac9742aa9dbd5e9902e1360d6ebe"sv}, Entry{"accessor/v1-tracesfrom.208-209.efi"sv, "d85f429ac7bf46cb57704c58c84af64e99fd7501"sv}, Entry{"accessor/v1-tracesfrom.64-128.efi"sv, "92f528d860a99bf78f0423eac06b6ad2a3fd2f60"sv}, Entry{"accessor/v1-tracesto.0-64.efi"sv, "6dda6d95257d4c32831190bd3afb276d8f7faf0f"sv}, Entry{"accessor/v1-tracesto.128-192.efi"sv, "d3a0e3e0d590c52dacb236e77396eb453eec5f39"sv}, Entry{"accessor/v1-tracesto.192-208.efi"sv, "98fe8b94826d5620c6dd2211b888c529cd488201"sv}, Entry{"accessor/v1-tracesto.208-209.efi"sv, "acab4293276e46797d82e5636c86b2e9d3740de9"sv}, Entry{"accessor/v1-tracesto.64-128.efi"sv, "a9580725e3b528bdf0243118fcb0585cbacd9763"sv}, Entry{"domain/v1-accounts.0-128.bt"sv, "ffea2bf2f107ba518a6d321cd3384d507b4ac0f6"sv}, Entry{"domain/v1-accounts.0-128.kv"sv, "91d3c4da59971be9ed13b2ce7178d6936a386073"sv}, Entry{"domain/v1-accounts.0-128.kvei"sv, "69b7ccfe75ad69b3976f09536c6aa566abd5a6c4"sv}, Entry{"domain/v1-accounts.128-192.bt"sv, "66165b72aa68448ffe16a11dac874a2432b3bb20"sv}, Entry{"domain/v1-accounts.128-192.kv"sv, "f12afeef74979ee48d0bbc7058a59cef22282b68"sv}, Entry{"domain/v1-accounts.128-192.kvei"sv, "2b0c26f5b25d4c080e8f50828c25928a7ea66571"sv}, Entry{"domain/v1-accounts.192-208.bt"sv, "0f7300bf27484436d6b6b3cf260db1273f4aff45"sv}, Entry{"domain/v1-accounts.192-208.kv"sv, "6d3203952faf0f2c37d1eff79f24bc040a787c8f"sv}, Entry{"domain/v1-accounts.192-208.kvei"sv, "6c8782162742ab859baa565bb8ddf5b336f8f896"sv}, Entry{"domain/v1-accounts.208-209.bt"sv, "d3faf208429e84e7154aba066a2aeb87ad5a3f2e"sv}, Entry{"domain/v1-accounts.208-209.kv"sv, "12c51f61b27f8b61f552bcc382bb6a7c9122abd2"sv}, Entry{"domain/v1-accounts.208-209.kvei"sv, "dac303fa16abe879d45ddcd5d8420d0b4d60f067"sv}, Entry{"domain/v1-code.0-128.bt"sv, "972d2e6c5d1f535311c9c2fdeea288d9dd6e56a6"sv}, Entry{"domain/v1-code.0-128.kv"sv, "acec4c4c338589691ea2d72dc48e29336bb8dc65"sv}, Entry{"domain/v1-code.0-128.kvei"sv, "9c037ac849e2e07b503102ef7f9abadb0c5d9eac"sv}, Entry{"domain/v1-code.128-192.bt"sv, "9b40492f239fc62d2c2b6b18d34eac848ca6b88c"sv}, Entry{"domain/v1-code.128-192.kv"sv, "006d829d172514da4676ebe5d71d63e51b8a9534"sv}, Entry{"domain/v1-code.128-192.kvei"sv, "eb2ee34e56d21d0ba6bde670aeb2650046830d15"sv}, Entry{"domain/v1-code.192-208.bt"sv, "47747d6f13f36bc6f185d5aacae2b670d3386ce6"sv}, Entry{"domain/v1-code.192-208.kv"sv, "8559fda64bd0f42feb039d69da15b3e7451ca1a9"sv}, Entry{"domain/v1-code.192-208.kvei"sv, "c2b811507f38afc70083f2c599d05ea7518126af"sv}, Entry{"domain/v1-code.208-209.bt"sv, "a7afa37547dd244ebc6f323cdc01f38a55bf3ccc"sv}, Entry{"domain/v1-code.208-209.kv"sv, "3d12754ac22df00625b7d55d56d0f8dac9584b8c"sv}, Entry{"domain/v1-code.208-209.kvei"sv, "e3d511045a398d57438a2d594dc9b22dae791a74"sv}, Entry{"domain/v1-commitment.0-128.bt"sv, "889da94ccd2f85c66bdfdc9c7a1558dc7a15c404"sv}, Entry{"domain/v1-commitment.0-128.kv"sv, "a91d2f63cf41706208429833e53c56e4b2bfea61"sv}, Entry{"domain/v1-commitment.0-128.kvei"sv, "b1a397e29f2a5476de2600360b5780b0f8b919b5"sv}, Entry{"domain/v1-commitment.128-192.bt"sv, "2352250db136151048dd9a08ac3aa83d69ee4038"sv}, Entry{"domain/v1-commitment.128-192.kv"sv, "36804837e2220afeb28c6c479049633aac8ff585"sv}, Entry{"domain/v1-commitment.128-192.kvei"sv, "fa1d375a90970c0d69ee63319d2572707e2d7ffd"sv}, Entry{"domain/v1-commitment.192-208.bt"sv, "c77ca641f3573ca2808c48d83fee47c38ee9c1ab"sv}, Entry{"domain/v1-commitment.192-208.kv"sv, "02584a73915c0e5606f469dcad29fdb10126535e"sv}, Entry{"domain/v1-commitment.192-208.kvei"sv, "7509c83eb578ada458a3c915e0544514826c4eb5"sv}, Entry{"domain/v1-commitment.208-209.bt"sv, "4d1056b63b63f98fe9ffff1c401f45bae349e3ce"sv}, Entry{"domain/v1-commitment.208-209.kv"sv, "c624c6133f3b66108cd911ca7323ea9f1229404b"sv}, Entry{"domain/v1-commitment.208-209.kvei"sv, "43907dc41a4bb7f161d4a031f68668eed2f39caa"sv}, Entry{"domain/v1-receipt.0-128.bt"sv, "ea916431aa4b8776dca4402cc2b1f5bd715399da"sv}, Entry{"domain/v1-receipt.0-128.kv"sv, "21aa470862f9756cdd44a9854ba19c750008d490"sv}, Entry{"domain/v1-receipt.0-128.kvei"sv, "0257137eb098393ce8e600a2f5946afc24ade297"sv}, Entry{"domain/v1-receipt.128-144.bt"sv, "128e3294178a5fca409b35cee5f24d20e49c1716"sv}, Entry{"domain/v1-receipt.128-144.kv"sv, "04902b2ffbb682daed9a88e73ee7138a97d65cfb"sv}, Entry{"domain/v1-receipt.128-144.kvei"sv, "54ddbc9bd8fb503e1bbe4d310ac922d5d12b7fe0"sv}, Entry{"domain/v1-receipt.144-148.bt"sv, "76d6f505d0039940812d55666f89f2ecacd51ea9"sv}, Entry{"domain/v1-receipt.144-148.kv"sv, "6c40e022e9ec45e63a0284e49996298b77b270d3"sv}, Entry{"domain/v1-receipt.144-148.kvei"sv, "1817b8161ac981bef0e5a404b81314a91393d523"sv}, Entry{"domain/v1-receipt.148-150.bt"sv, "d9d1f3a12feee23d461922f8e92486137afae9ac"sv}, Entry{"domain/v1-receipt.148-150.kv"sv, "552edef94728269822703dc63deba599f95999f5"sv}, Entry{"domain/v1-receipt.148-150.kvei"sv, "ad722490d4270c19c0fb114c9e1677f4a21d301d"sv}, Entry{"domain/v1-receipt.150-151.bt"sv, "17e0fa9138c0e6d35bf773caadd64669d310a171"sv}, Entry{"domain/v1-receipt.150-151.kv"sv, "2e08d1b844b614a602b026031a7270bcdbb955b3"sv}, Entry{"domain/v1-receipt.150-151.kvei"sv, "9ff2e6ec37e3c03a0cfa02e855fbcfc6dc2a1db3"sv}, Entry{"domain/v1-receipt.192-208.bt"sv, "315e8ecf2b2ec23b2998b60772241c92e7b5dd3b"sv}, Entry{"domain/v1-receipt.192-208.kv"sv, "70164d16d4f1636e881f869f4592982079868c0e"sv}, Entry{"domain/v1-receipt.192-208.kvei"sv, "a00f948cd58ac641ad17e9263c7337fa59a4ca7c"sv}, Entry{"domain/v1-receipt.208-209.bt"sv, "6eb5b3c3db932772674f55bb94ca6651407d3743"sv}, Entry{"domain/v1-receipt.208-209.kv"sv, "91ea79b3e5967cf092691a6d4556f75209426e52"sv}, Entry{"domain/v1-receipt.208-209.kvei"sv, "46f641eecb9659958772d4b7dcd5e914b28acb7d"sv}, Entry{"domain/v1-storage.0-128.bt"sv, "3d5909b8e7fbfa32560646ee269a338a6e3dd5bb"sv}, Entry{"domain/v1-storage.0-128.kv"sv, "a610d253849c89ce1b399c5a582d00f0e20c0826"sv}, Entry{"domain/v1-storage.0-128.kvei"sv, "c8843acf94f379852ac6affdfc10de64ce900703"sv}, Entry{"domain/v1-storage.128-192.bt"sv, "e325fadda8e7b8cd3cd21af6072dc2c5bee9a754"sv}, Entry{"domain/v1-storage.128-192.kv"sv, "e2d6a40f35b1e2bc1665cf3f416cc498d3cdd6c3"sv}, Entry{"domain/v1-storage.128-192.kvei"sv, "66af97ae522d9e984a84377542b500fdad574a3c"sv}, Entry{"domain/v1-storage.192-208.bt"sv, "fba860b058be9fc6b632904ccf5589c5784f6623"sv}, Entry{"domain/v1-storage.192-208.kv"sv, "13e5f0fe0151388727f09188a9ab61bea7594512"sv}, Entry{"domain/v1-storage.192-208.kvei"sv, "8fdc3da05d3638e3b41eefa4a806f037e561c199"sv}, Entry{"domain/v1-storage.208-209.bt"sv, "7db133b8c32432b07ccf692bf897565b248ea1c7"sv}, Entry{"domain/v1-storage.208-209.kv"sv, "be8a6537fbfde6e65f09ec8d7f809febd07667e2"sv}, Entry{"domain/v1-storage.208-209.kvei"sv, "5deed3ea3873da9ba2833c9d80647ff779519ac4"sv}, Entry{"history/v1-accounts.0-64.v"sv, "c6c4c734ad14942c0d74960693629c9b519631b8"sv}, Entry{"history/v1-accounts.128-192.v"sv, "ed25f822a421898c08fd6a10df3296d52be8a3f0"sv}, Entry{"history/v1-accounts.192-208.v"sv, "12c42305ae1e6cc3db2937d5a728831ab6b92ea7"sv}, Entry{"history/v1-accounts.208-209.v"sv, "2ea3115cd37a7600782c3ff3e5940cf904957aaf"sv}, Entry{"history/v1-accounts.64-128.v"sv, "978c1545f5e61e2b401787cc74e89f6b99f909fa"sv}, Entry{"history/v1-code.0-64.v"sv, "dad552cff411d1b77b67411b5be17af6debc64d6"sv}, Entry{"history/v1-code.128-192.v"sv, "4b2f867ecdf9da5e7cd6fff04750745710e707d8"sv}, Entry{"history/v1-code.192-208.v"sv, "8f0ed2171640d52212b2fcaced0b605a1790a18d"sv}, Entry{"history/v1-code.208-209.v"sv, "01fad8e4db226da39832b8774a9c8cf06ca84846"sv}, Entry{"history/v1-code.64-128.v"sv, "b6ce720f321bbdf023c0945d946c582d8291de41"sv}, Entry{"history/v1-receipt.0-64.v"sv, "4dd6c9b4996a8a145002d0e74a510486a563560a"sv}, Entry{"history/v1-receipt.128-144.v"sv, "9348b1dc7a7d2bbd1018bc2d47be2cb7a60632f3"sv}, Entry{"history/v1-receipt.144-148.v"sv, "461622c38d908451228849aeebbc12ada1500f11"sv}, Entry{"history/v1-receipt.148-150.v"sv, "47eb7e07e4ff709821a81027f31ecabad00b378e"sv}, Entry{"history/v1-receipt.150-151.v"sv, "97c098980739c1e261ee8e0eca33fc9bb7a447ed"sv}, Entry{"history/v1-receipt.192-208.v"sv, "6fb69e9d49256aaf674a1ff40b7e8de6b24e282c"sv}, Entry{"history/v1-receipt.208-209.v"sv, "838e7578e157f69d9384af55941beabaca18d003"sv}, Entry{"history/v1-receipt.64-128.v"sv, "51c2fa52257a28e8d78bbd2d2684f0024ae138f3"sv}, Entry{"history/v1-storage.0-64.v"sv, "8278e9f6f6e8da717e0a63b2ab4755a6ff5e64a8"sv}, Entry{"history/v1-storage.128-192.v"sv, "79299fd366d48be3e719955019f01ca3f75c769d"sv}, Entry{"history/v1-storage.192-208.v"sv, "1ebe0f250bd56abfbdb3a2970955f86324e8766c"sv}, Entry{"history/v1-storage.208-209.v"sv, "76948f8074ee2e858f906934cbb8650ddf56250d"sv}, Entry{"history/v1-storage.64-128.v"sv, "b1a51dc8062ad7994f65c820b213f1e8aa183674"sv}, Entry{"idx/v1-accounts.0-64.ef"sv, "69d91d090a3d4fdbffe46298dda0d659f6318c58"sv}, Entry{"idx/v1-accounts.128-192.ef"sv, "a9f6a98a2cd8f989cf100cdcdd9b9d10a3dfd089"sv}, Entry{"idx/v1-accounts.192-208.ef"sv, "af7425373780b27a8531dc6e9aa0b0773bdcfa99"sv}, Entry{"idx/v1-accounts.208-209.ef"sv, "55c42b592fa7d49300e0621d7047ece7a02d1367"sv}, Entry{"idx/v1-accounts.64-128.ef"sv, "76f9997b845d98c8e70c60559a1184ccb6103379"sv}, Entry{"idx/v1-code.0-64.ef"sv, "0be7b238c4f4ec875e3592814e70ed96b828ae4d"sv}, Entry{"idx/v1-code.128-192.ef"sv, "e723ac2efc3080a09e653ce7b6c1c926c76f7c46"sv}, Entry{"idx/v1-code.192-208.ef"sv, "2537aee0d38454ad418baf6ee59b4b8f2ba00b22"sv}, Entry{"idx/v1-code.208-209.ef"sv, "42d2e50cea584cffd5d7ec2825903b34dffe6b96"sv}, Entry{"idx/v1-code.64-128.ef"sv, "05ca760941d749f5f6173b51453ac3db6eac9967"sv}, Entry{"idx/v1-logaddrs.0-64.ef"sv, "4d1c8a0f19eef678ec5018cdbd5b0001e7eb8736"sv}, Entry{"idx/v1-logaddrs.128-192.ef"sv, "09b4b15c84ccd053f822cfa0a7ca1bca4725d42e"sv}, Entry{"idx/v1-logaddrs.192-208.ef"sv, "1bf64d7289d5d572bdba7f8d012fc724d3bbf8e3"sv}, Entry{"idx/v1-logaddrs.208-209.ef"sv, "01477811948a6b0c7b72fd0deeb4ade4f6eada0d"sv}, Entry{"idx/v1-logaddrs.64-128.ef"sv, "07690af318c9d060b698ebc82aec7fdfd263c71b"sv}, Entry{"idx/v1-logtopics.0-64.ef"sv, "7272dcf283cdb22eba5d172b20a892438135f2ae"sv}, Entry{"idx/v1-logtopics.128-192.ef"sv, "211df368c6f817a28c0adc90ca1a58e1f242c3de"sv}, Entry{"idx/v1-logtopics.192-208.ef"sv, "2557d60ee7d0d0aabc369163381836d4fc64e276"sv}, Entry{"idx/v1-logtopics.208-209.ef"sv, "70b8e372382f5ddd23e156ccf31a169f6218c3cd"sv}, Entry{"idx/v1-logtopics.64-128.ef"sv, "c941ba45db9dbec6ffa6559f69802d2b00e7dbaf"sv}, Entry{"idx/v1-receipt.0-64.ef"sv, "76dd2f24458bfcb1deac00598837e08a0692f7df"sv}, Entry{"idx/v1-receipt.128-144.ef"sv, "2386e41c6332255a4f528618172d7be1c6cdd051"sv}, Entry{"idx/v1-receipt.144-148.ef"sv, "a717047aeae49c1b428dd910667a6c520346fc72"sv}, Entry{"idx/v1-receipt.148-150.ef"sv, "1f2e881abb50f72a5e7066efc3d9ac3f05ffc4eb"sv}, Entry{"idx/v1-receipt.150-151.ef"sv, "676166afd5e2622cb62d57ace992f4d7881be1b7"sv}, Entry{"idx/v1-receipt.192-208.ef"sv, "adb802094ce8037b37dd1db7fccd1fabff0ac094"sv}, Entry{"idx/v1-receipt.208-209.ef"sv, "091d76fc98b037aad7d3a0e089b23e3846d3d1b8"sv}, Entry{"idx/v1-receipt.64-128.ef"sv, "4dbfb1b7f6c8fe3b071c97fa19ef48f5a09c3847"sv}, Entry{"idx/v1-storage.0-64.ef"sv, "b4ee6b4d97c79e4aabf08f63834936bf819ad636"sv}, Entry{"idx/v1-storage.128-192.ef"sv, "4005815008efddd4b85d79ae943011a613f03477"sv}, Entry{"idx/v1-storage.192-208.ef"sv, "9b8d5b056fe0d68ea1effc27023eba9a7d2f0670"sv}, Entry{"idx/v1-storage.208-209.ef"sv, "dafc9182f123c26c04ad930c9c5787a075f197e8"sv}, Entry{"idx/v1-storage.64-128.ef"sv, "cf324031e46f69f40223d9152bb4baa18e1a019d"sv}, Entry{"idx/v1-tracesfrom.0-64.ef"sv, "b7e1a1063450b2612f41e2c13534cfb88ca13856"sv}, Entry{"idx/v1-tracesfrom.128-192.ef"sv, "0861508205acd54fee4a1ef4cbe4bfa405d51e46"sv}, Entry{"idx/v1-tracesfrom.192-208.ef"sv, "8aa9f1f34d2fb288a7ed5236de241b2f975e6f27"sv}, Entry{"idx/v1-tracesfrom.208-209.ef"sv, "74b92a2083355ef0b76592a7549471680b0d8963"sv}, Entry{"idx/v1-tracesfrom.64-128.ef"sv, "089d047b8825184136b68eb0b3b31797d8acd331"sv}, Entry{"idx/v1-tracesto.0-64.ef"sv, "46c469b50213dbd5509818dc338b20fa615be90e"sv}, Entry{"idx/v1-tracesto.128-192.ef"sv, "9b80909adf1440ca6482e255453daf9caeb064c1"sv}, Entry{"idx/v1-tracesto.192-208.ef"sv, "388327457fe40b1bccc4af5e732675cd28877f70"sv}, Entry{"idx/v1-tracesto.208-209.ef"sv, "6a3009c2e66d6420829f1833bd6a098a95dfe926"sv}, Entry{"idx/v1-tracesto.64-128.ef"sv, "c905e993eb4ad910f95c54c07880633ccb2c86fb"sv}, Entry{"salt-blocks.txt"sv, "51f5e036ffe71e573dfc75f74d839be921c0b90c"sv}, Entry{"salt-state.txt"sv, "0113ec56c7c0d72783dbb5738becffa9c4c43d69"sv}, Entry{"v1-000000-000500-bodies.idx"sv, "2282d9304648011618d305143ac704219db94394"sv}, Entry{"v1-000000-000500-bodies.seg"sv, "b3a879e769292f526282cf92398d892fac090198"sv}, Entry{"v1-000000-000500-headers.idx"sv, "09bb24c7beaf52bf1bb2729d7326e5163c0d6294"sv}, Entry{"v1-000000-000500-headers.seg"sv, "f075eb8e04b861d798a148267193c1b892079edd"sv}, Entry{"v1-000000-000500-transactions-to-block.idx"sv, "b34fb7761daa3f0b091156928877be5a4db25876"sv}, Entry{"v1-000000-000500-transactions.idx"sv, "a1e5418a9f1a163c3f5dc62bc70f7ad53ab6645f"sv}, Entry{"v1-000000-000500-transactions.seg"sv, "4997c8090aa2ae0318d944793b3f5296fbda0c9c"sv}, Entry{"v1-000500-001000-bodies.idx"sv, "555f5d66ba89afbbb76208825b985347f9fe413e"sv}, Entry{"v1-000500-001000-bodies.seg"sv, "89a2178a144a1b31f214d0581d6fd41e59a754f7"sv}, Entry{"v1-000500-001000-headers.idx"sv, "9271fefc137fe1769c8d37bd5d19529767ad9647"sv}, Entry{"v1-000500-001000-headers.seg"sv, "d56ed3aa099a55b76b376158b3697cb1fca28e5a"sv}, Entry{"v1-000500-001000-transactions-to-block.idx"sv, "4587c9930ae927758d8a81044cb434a7641bb66b"sv}, Entry{"v1-000500-001000-transactions.idx"sv, "036863c5946d48b2472a89aba4500c5bcb066304"sv}, Entry{"v1-000500-001000-transactions.seg"sv, "fe5a676ab478e627524c7f0de4e44602606aee14"sv}, Entry{"v1-001000-001500-bodies.idx"sv, "5fb0df34b50a2616e355e8608684f49261ab1094"sv}, Entry{"v1-001000-001500-bodies.seg"sv, "11bb53b7f03b136a9d4d634276ad6ed32995a8d4"sv}, Entry{"v1-001000-001500-headers.idx"sv, "1c1a08c662a46e5d6e1977db312139c1fe08237c"sv}, Entry{"v1-001000-001500-headers.seg"sv, "eb66d00561e93660d93be0bcf680d31dc74ced21"sv}, Entry{"v1-001000-001500-transactions-to-block.idx"sv, "d1c63a0065e57a2330123bedc04d30a220807f3b"sv}, Entry{"v1-001000-001500-transactions.idx"sv, "efdd9b994071e8e33bbec8096d363a0344592e38"sv}, Entry{"v1-001000-001500-transactions.seg"sv, "3208e92fd7dca663f66f944b34a843942bec9ec2"sv}, Entry{"v1-001500-002000-bodies.idx"sv, "9ba32e15defabed017e6efe95a5ba14de45d4626"sv}, Entry{"v1-001500-002000-bodies.seg"sv, "0c5fbe5edb6a402faa30af253bde6138d3e5d7a4"sv}, Entry{"v1-001500-002000-headers.idx"sv, "0995cf2055feef279e72262c515a8be0eb93720c"sv}, Entry{"v1-001500-002000-headers.seg"sv, "f52bab195f716f4cf6ca49101f6631ad2825d241"sv}, Entry{"v1-001500-002000-transactions-to-block.idx"sv, "ca31d048538982b31030f01a83bbadb8c2746d50"sv}, Entry{"v1-001500-002000-transactions.idx"sv, "b426b9474e5e64135741469a12d3a797f1504acb"sv}, Entry{"v1-001500-002000-transactions.seg"sv, "7158cfa8f3fe976a454a3123aa6d757e961077a6"sv}, Entry{"v1-002000-002500-bodies.idx"sv, "697ae006e1ca2b32af4e0769ab181e77fe961e3a"sv}, Entry{"v1-002000-002500-bodies.seg"sv, "aab1a99ea892cb5b1c6523d65f964f93d8940a47"sv}, Entry{"v1-002000-002500-headers.idx"sv, "55257b226e289304c60a69ef3c207141cb68fc18"sv}, Entry{"v1-002000-002500-headers.seg"sv, "4c1f4a3d3c2bfc6e46a0387d1ac9d69b20da4ade"sv}, Entry{"v1-002000-002500-transactions-to-block.idx"sv, "32f168cbbd3655ca97157ac5edc433b89f8ea197"sv}, Entry{"v1-002000-002500-transactions.idx"sv, "a32a9b1abd546fa59a2189aa0fd68dc3bf58dd31"sv}, Entry{"v1-002000-002500-transactions.seg"sv, "5ae5f1ee3d55ad1ba509f1ee664198433d4c66eb"sv}, Entry{"v1-002500-003000-bodies.idx"sv, "4762c76715ad852ab0689dcd0b91f97f3d1da43d"sv}, Entry{"v1-002500-003000-bodies.seg"sv, "8fc7d7f69bbfcb5fad7f0501a63773a9913793b6"sv}, Entry{"v1-002500-003000-headers.idx"sv, "fefca7d8cdfaafa5c2120b1e9f842fe7313247c2"sv}, Entry{"v1-002500-003000-headers.seg"sv, "4f7cae1bb69144d395c615592e10b9111902dcd2"sv}, Entry{"v1-002500-003000-transactions-to-block.idx"sv, "b534fb05cc2ce34a51606bc48de5e3434710966e"sv}, Entry{"v1-002500-003000-transactions.idx"sv, "228e7d9b406f426ff8031bf176f7d1b91b6961ce"sv}, Entry{"v1-002500-003000-transactions.seg"sv, "e45775eb22161d421b7944bff60ead29e7996018"sv}, Entry{"v1-003000-003500-bodies.idx"sv, "7c8924de30a23ecd665050e480fe4296370dc6e1"sv}, Entry{"v1-003000-003500-bodies.seg"sv, "d5b6ccc71e9d34b2e9b365b53474d9408d4800d3"sv}, Entry{"v1-003000-003500-headers.idx"sv, "01a31461ca3c1569e26226b9f60003c84f4e7bc0"sv}, Entry{"v1-003000-003500-headers.seg"sv, "38ce699a49502e74b3836f2a81cc1d4af6004d3e"sv}, Entry{"v1-003000-003500-transactions-to-block.idx"sv, "345064b0cd0eac632736e01e97ed1df13e7b3257"sv}, Entry{"v1-003000-003500-transactions.idx"sv, "f909cc7337c70ece24f7d4a21df0fcc40a1b6edf"sv}, Entry{"v1-003000-003500-transactions.seg"sv, "481d97f137b79b254bf1517835fef3623a75852d"sv}, Entry{"v1-003500-004000-bodies.idx"sv, "e1a070797052bb13af51dbfcd58a1336d4d11220"sv}, Entry{"v1-003500-004000-bodies.seg"sv, "879d6c45d2e192eb575598594b191c56041216f0"sv}, Entry{"v1-003500-004000-headers.idx"sv, "5d4440025290d5afeae1fc222e5a4c533e4bb89a"sv}, Entry{"v1-003500-004000-headers.seg"sv, "1b7157fe9443890d5ca03519fd3f34fa314c1bc9"sv}, Entry{"v1-003500-004000-transactions-to-block.idx"sv, "cb1191f6a74d3a326549159e9413a8378678bdab"sv}, Entry{"v1-003500-004000-transactions.idx"sv, "a1714e2b48b3f8db8637a4ccef080dde466929a5"sv}, Entry{"v1-003500-004000-transactions.seg"sv, "128d16656c8eb3d389c044d91de589849dc00b75"sv}, Entry{"v1-004000-004100-bodies.idx"sv, "74d1bd0a4ec27f3ac005b8dfc28459a7f904d706"sv}, Entry{"v1-004000-004100-bodies.seg"sv, "85fb1077520f9a01f204e560a58934a1eadab068"sv}, Entry{"v1-004000-004100-headers.idx"sv, "5d04c2968f71a8be34a6b82b1564022fcee63615"sv}, Entry{"v1-004000-004100-headers.seg"sv, "666161b3400737a68e5e5ffa73383de68bf35e50"sv}, Entry{"v1-004000-004100-transactions-to-block.idx"sv, "2f7cd8730f6b4452110f080edc70631f66a4dba7"sv}, Entry{"v1-004000-004100-transactions.idx"sv, "e004352b1774dfde5e1c22ac3d29a179635c7f0b"sv}, Entry{"v1-004000-004100-transactions.seg"sv, "4bd8a4a57d03a8ed59f37d79f14909cc3d88eed2"sv}, Entry{"v1-004100-004200-bodies.idx"sv, "04e2268b4fa046296b828cc82780349996c35d90"sv}, Entry{"v1-004100-004200-bodies.seg"sv, "feb479f543739f50e2a67323339d43159951fa60"sv}, Entry{"v1-004100-004200-headers.idx"sv, "7c313e12a19bc502772cce29fa787ce152356621"sv}, Entry{"v1-004100-004200-headers.seg"sv, "da60163b61a704aab0ea61d7a059422cba074090"sv}, Entry{"v1-004100-004200-transactions-to-block.idx"sv, "4a90fe99e37deb9f2bcfc950fe2044c17b3de213"sv}, Entry{"v1-004100-004200-transactions.idx"sv, "479c6765a242ea4191fdfed02897f136f41a4858"sv}, Entry{"v1-004100-004200-transactions.seg"sv, "aa6bdc801179a54d7c3fa355f914711fd66737c9"sv}, Entry{"v1-004200-004300-bodies.idx"sv, "65131728b6ada80c7d04835ef598730533094d2f"sv}, Entry{"v1-004200-004300-bodies.seg"sv, "a369c0a9f2c7de78ac6b2d40cac31422d76551b1"sv}, Entry{"v1-004200-004300-headers.idx"sv, "8963afb9fe25ad84cf07bf24588550638f53d8aa"sv}, Entry{"v1-004200-004300-headers.seg"sv, "1e343760b4fc3c539401321303a22744d35ece3a"sv}, Entry{"v1-004200-004300-transactions-to-block.idx"sv, "339f9477fc29c6bc3df529da07a74012e6b17808"sv}, Entry{"v1-004200-004300-transactions.idx"sv, "52cdabbb14b60378d18a091260a25ddd2c8495fb"sv}, Entry{"v1-004200-004300-transactions.seg"sv, "505e90c03d6c101027eedf96dcc76a05bbdfbf8d"sv}, Entry{"v1-004240-004250-blobsidecars.seg"sv, "932565c11e6f1aec5512c024a630c4074fcba778"sv}, Entry{"v1-004240-004250-blocksidecars.idx"sv, "93864946ae26d98d78fdc649011ac770b2e8a50c"sv}, Entry{"v1-004250-004260-blobsidecars.seg"sv, "3a3037e15d6cd6a899879d878a3e0dc13ac53944"sv}, Entry{"v1-004250-004260-blocksidecars.idx"sv, "08b93f3f8b06470b7249742482e3c42bf2dec7e1"sv}, Entry{"v1-004260-004270-blobsidecars.seg"sv, "295bd34fd8951b7f39df2eda6451847508e6700b"sv}, Entry{"v1-004260-004270-blocksidecars.idx"sv, "0ef6593fe4ec24fa6895467cd4674d94c5879ee3"sv}, Entry{"v1-004270-004280-blobsidecars.seg"sv, "f1c9870e78f47f3b8387e2b533f2ab23cce64444"sv}, Entry{"v1-004270-004280-blocksidecars.idx"sv, "d9999f92bb7878a67477e8bfb9833bc658a9f382"sv}, Entry{"v1-004280-004290-blobsidecars.seg"sv, "330426fe350f3b171bba9b409e4544402f7f4ffe"sv}, Entry{"v1-004280-004290-blocksidecars.idx"sv, "d98a9eb10c715fee2871fa9e64a0dd1c9c6df62b"sv}, Entry{"v1-004290-004300-blobsidecars.seg"sv, "370bb4a67b3f346999b6068b2a2613f316566dae"sv}, Entry{"v1-004290-004300-blocksidecars.idx"sv, "5ba0fb575fcff8bacc706b9ce964b64034b1fff6"sv}, Entry{"v1-004300-004310-blobsidecars.seg"sv, "96e16985496bf8884e9b1698d86f2cc482cba82f"sv}, Entry{"v1-004300-004310-blocksidecars.idx"sv, "ace123366bf7840ab13466c338a09156ea45fc44"sv}, Entry{"v1-004300-004400-bodies.idx"sv, "c4abc7f40239157b0b38154f057d845be076916e"sv}, Entry{"v1-004300-004400-bodies.seg"sv, "d5c5c578daee8fc936cf70fce13f77a1d1050e6f"sv}, Entry{"v1-004300-004400-headers.idx"sv, "f9e3b493d0bfdf3b8fe44e37c364f4d589e26410"sv}, Entry{"v1-004300-004400-headers.seg"sv, "26aa6e50402c1f67d6b1ac11381ca4b2acb6a2de"sv}, Entry{"v1-004300-004400-transactions-to-block.idx"sv, "26361b740924c3020179d91a434d96d9ae8c6cb0"sv}, Entry{"v1-004300-004400-transactions.idx"sv, "6ef53a828e71c788953068cfff9607a7729b3c21"sv}, Entry{"v1-004300-004400-transactions.seg"sv, "e8c2c2b0d4e3c2f997241f6bbc9fef19a8d42a40"sv}, Entry{"v1-004310-004320-blobsidecars.seg"sv, "f5d09e7d58b1003928adfb42af74c97abaedef9d"sv}, Entry{"v1-004310-004320-blocksidecars.idx"sv, "b77264f58062bc3efeeb984b5a2e5b495cf20ce1"sv}, Entry{"v1-004320-004330-blobsidecars.seg"sv, "27090f24065acd45db3f11c1b1913e900d0a83fb"sv}, Entry{"v1-004320-004330-blocksidecars.idx"sv, "7a6ddb3d6ab3fbf00de14f9388664995cc556d1c"sv}, Entry{"v1-004330-004340-blobsidecars.seg"sv, "38a536d326956897482fdae3f83f57c4c983ad66"sv}, Entry{"v1-004330-004340-blocksidecars.idx"sv, "1251270fd2d51230c4a271f30d840ecd6c5a3a9e"sv}, Entry{"v1-004340-004350-blobsidecars.seg"sv, "81bd0b8d9256c59165d5ebfb82adc8a9fff1101b"sv}, Entry{"v1-004340-004350-blocksidecars.idx"sv, "454301da7210afde6c83d2aebadee2d8bdcd81d3"sv}, Entry{"v1-004350-004360-blobsidecars.seg"sv, "4d121c87d938ce0acbeadaabcb88b7656f226f4f"sv}, Entry{"v1-004350-004360-blocksidecars.idx"sv, "ec524c4e0e1c5ed9accb28d2a0acfb7fb599bd06"sv}, Entry{"v1-004360-004370-blobsidecars.seg"sv, "950a1eddd8df4a0129793eb006551a97d4a95841"sv}, Entry{"v1-004360-004370-blocksidecars.idx"sv, "a80e94d7210bf2fedaa627856eb03cc5f73f6aca"sv}, Entry{"v1-004370-004380-blobsidecars.seg"sv, "94796ad9dde5aa051b558e1996467ddbe03b6120"sv}, Entry{"v1-004370-004380-blocksidecars.idx"sv, "16aa0c7af63db164ff7656ebb45162d14494f1b1"sv}, Entry{"v1-004380-004390-blobsidecars.seg"sv, "f5b723f395c23813f01939117274a19838e059ba"sv}, Entry{"v1-004380-004390-blocksidecars.idx"sv, "31e091ed782469da06d212a84da90a11414171b7"sv}, Entry{"v1-004390-004400-blobsidecars.seg"sv, "28301540240702edd3975db4a174bbe5085227c6"sv}, Entry{"v1-004390-004400-blocksidecars.idx"sv, "9924876b468c4ae3a1692d03786f2130e8787e58"sv}, Entry{"v1-004400-004410-blobsidecars.seg"sv, "ad531a5124ec39c3a69db1b7eef15aaa5abadd4b"sv}, Entry{"v1-004400-004410-blocksidecars.idx"sv, "51a1346e30ce256dec1d05cae438444568368b85"sv}, Entry{"v1-004400-004500-bodies.idx"sv, "7a2b11ce1bb2a072ab83862ee196103a746ffd7c"sv}, Entry{"v1-004400-004500-bodies.seg"sv, "687bdf10d04411c1a382bb64cc7e55c7d3152da0"sv}, Entry{"v1-004400-004500-headers.idx"sv, "6799485e7c6fd7f00d42436944c14250860a82f1"sv}, Entry{"v1-004400-004500-headers.seg"sv, "32ff1c042109ab6cbecc5d45672ef0b3b756b981"sv}, Entry{"v1-004400-004500-transactions-to-block.idx"sv, "b146ef2a21e6e5dc316ccdfcba47eafd4d673371"sv}, Entry{"v1-004400-004500-transactions.idx"sv, "b2d25a1c7314c7f85a8284a51356a805423367e9"sv}, Entry{"v1-004400-004500-transactions.seg"sv, "dbc42a8cd7dd7940b94ba23d24170c05b70ee208"sv}, Entry{"v1-004410-004420-blobsidecars.seg"sv, "c339294ad4cc3ffeb3954b047f37dffd3618d9bd"sv}, Entry{"v1-004410-004420-blocksidecars.idx"sv, "97ee64d77df95359ef9559dddb9aa2542c1e42e8"sv}, Entry{"v1-004420-004430-blobsidecars.seg"sv, "406ad71e8087c8768b7e30903040ef92a7ecc19a"sv}, Entry{"v1-004420-004430-blocksidecars.idx"sv, "0db5cb63b49c3350e745c00935f36b3ae83df3bf"sv}, Entry{"v1-004430-004440-blobsidecars.seg"sv, "361856512c650c7cdf811a7c352e006a3a326034"sv}, Entry{"v1-004430-004440-blocksidecars.idx"sv, "4ceb262a69716793e223e4f0b8e90437810b7527"sv}, Entry{"v1-004440-004450-blobsidecars.seg"sv, "e283c696a20e38ca7632fb106c6eae30576fbb12"sv}, Entry{"v1-004440-004450-blocksidecars.idx"sv, "d5cc5701308645613e8831c390268829666276b2"sv}, Entry{"v1-004450-004460-blobsidecars.seg"sv, "ad12d384923b5e597eaa55a8786879cd3b2ab5af"sv}, Entry{"v1-004450-004460-blocksidecars.idx"sv, "c65308a7fe43b9a184f94c38152dbf92ff98149a"sv}, Entry{"v1-004460-004470-blobsidecars.seg"sv, "8a96aafe31838380da944b1a0cea496480a40f94"sv}, Entry{"v1-004460-004470-blocksidecars.idx"sv, "85cdaacb79a599b3ff9c36f8512211d330ea7c44"sv}, Entry{"v1-004470-004480-blobsidecars.seg"sv, "7f2333a5c9f6e8a3ab9a73474703f37bb5cb3df1"sv}, Entry{"v1-004470-004480-blocksidecars.idx"sv, "3b3a868fcdf0f5505ea1f5f2fabce22301719a86"sv}, Entry{"v1-004480-004490-blobsidecars.seg"sv, "4a4fbbe6440b6bed08cc414853ed923133ea649b"sv}, Entry{"v1-004480-004490-blocksidecars.idx"sv, "c3ff01892a0e94d1364f64155cc8dd937f3ff374"sv}, Entry{"v1-004490-004500-blobsidecars.seg"sv, "ede78e02abf6ce0987034e1d4b7ed9135bab42eb"sv}, Entry{"v1-004490-004500-blocksidecars.idx"sv, "2347bd3bf2af21759f7ecb074b30cba53b714a84"sv}, Entry{"v1-004500-004510-blobsidecars.seg"sv, "bc800b60cf75180b801f93879dc9f9ea192f3ac6"sv}, Entry{"v1-004500-004510-blocksidecars.idx"sv, "94e853739ba074b23e7b77135de9bd15f4defcb5"sv}, Entry{"v1-004500-004600-bodies.idx"sv, "1f644d4d3eb4c099e8ed49b7f65131c449022cd0"sv}, Entry{"v1-004500-004600-bodies.seg"sv, "582cbf228966ffc9ce49fbf7a1e377d154f1488d"sv}, Entry{"v1-004500-004600-headers.idx"sv, "74223d628610a077e578d4838daa2a4848fcabe8"sv}, Entry{"v1-004500-004600-headers.seg"sv, "36bf6a68823cd2776e61372da976c8b113eb55dd"sv}, Entry{"v1-004500-004600-transactions-to-block.idx"sv, "cc5f69a9b85f09fb24da0f6d79928f7d1750b55f"sv}, Entry{"v1-004500-004600-transactions.idx"sv, "4a9d3a22c0007e482e0a6104a979987b88aae593"sv}, Entry{"v1-004500-004600-transactions.seg"sv, "2995e2ef297ae670de2c28736823444c8fd4182e"sv}, Entry{"v1-004510-004520-blobsidecars.seg"sv, "57e4bbc1fcdce855cd545198b59cb47f4b066b3d"sv}, Entry{"v1-004510-004520-blocksidecars.idx"sv, "b5bdb1e6224135b7e0020e7f30fe7ca9780880d0"sv}, Entry{"v1-004520-004530-blobsidecars.seg"sv, "4f1927e9b6aee07c88db9071ac1aa44d5918ff16"sv}, Entry{"v1-004520-004530-blocksidecars.idx"sv, "c7bf84fa991c8bb471ca82d8435ffec680e03207"sv}, Entry{"v1-004530-004540-blobsidecars.seg"sv, "ca335da69ba0f14293741c4b04c0dd3f9a27a80f"sv}, Entry{"v1-004530-004540-blocksidecars.idx"sv, "1bb59fae7f3f035b3bc74bd920b901eec4f81219"sv}, Entry{"v1-004540-004550-blobsidecars.seg"sv, "3fde582e123a5671b87897bfbd0bea3875957132"sv}, Entry{"v1-004540-004550-blocksidecars.idx"sv, "3c3e4fdb80dfdf3f29270c07636907e89962fc72"sv}, Entry{"v1-004550-004560-blobsidecars.seg"sv, "1d4a9cd3069f218d3a3ea434b49f81177893ae96"sv}, Entry{"v1-004550-004560-blocksidecars.idx"sv, "c7c6b0c051180292bb137af1cf6d30c88b13aaf1"sv}, Entry{"v1-004560-004570-blobsidecars.seg"sv, "ed795204deabfbda553b35ac92d9641fb4e0069d"sv}, Entry{"v1-004560-004570-blocksidecars.idx"sv, "24903759ef5b631f8450a97867732e6aad51bbfe"sv}, Entry{"v1-004570-004580-blobsidecars.seg"sv, "9e584f5ed9443ad243b0c211537488f5ab827477"sv}, Entry{"v1-004570-004580-blocksidecars.idx"sv, "56c94b154a4fbed29cc500312ffc2c3c66e8653f"sv}, Entry{"v1-004580-004590-blobsidecars.seg"sv, "991e20f24093976c1d5ca2ea17a5b223f927f975"sv}, Entry{"v1-004580-004590-blocksidecars.idx"sv, "d330ff913de7ce471a8863dcffaddb7773c0965a"sv}, Entry{"v1-004590-004600-blobsidecars.seg"sv, "fd65084c3e744d25bc83c7a5ab8a5502d290105a"sv}, Entry{"v1-004590-004600-blocksidecars.idx"sv, "8778ee252e3bda6face3d162e1863d69b81d6051"sv}, Entry{"v1-004600-004610-blobsidecars.seg"sv, "28aba447c1f5a69213ef6730235cd8d509907aef"sv}, Entry{"v1-004600-004610-blocksidecars.idx"sv, "504ce285e4b56f5555abaa6b3a5bdedaff906bc8"sv}, Entry{"v1-004600-004700-bodies.idx"sv, "f310d261c1e6336e3225657008154b498ff185ec"sv}, Entry{"v1-004600-004700-bodies.seg"sv, "d7744bba4e6db9e321aa30b1896877a15e771891"sv}, Entry{"v1-004600-004700-headers.idx"sv, "a4f5a84d5715f97b20b5672cea0bc36fa49bf945"sv}, Entry{"v1-004600-004700-headers.seg"sv, "ea54ea2744647bfa303c5923a2fcd4f55ad0d44f"sv}, Entry{"v1-004600-004700-transactions-to-block.idx"sv, "50f80bfc231c67165bfe13841368c18f2a0aefe7"sv}, Entry{"v1-004600-004700-transactions.idx"sv, "91080fbdf35d8fe4e99ab70c14c7a400886699f6"sv}, Entry{"v1-004600-004700-transactions.seg"sv, "6b2bec9f25e99987be9efccbaf89f5467d216b6c"sv}, Entry{"v1-004610-004620-blobsidecars.seg"sv, "c6f4fead6665c59123ed575eff83fac3835a4ae9"sv}, Entry{"v1-004610-004620-blocksidecars.idx"sv, "43d122bcca7bc08d5f15a15bcb57301f9e7356b2"sv}, Entry{"v1-004620-004630-blobsidecars.seg"sv, "3bc3002651ec92fe42a2020944228bf8bd49845c"sv}, Entry{"v1-004620-004630-blocksidecars.idx"sv, "4e1afbd08be98e56affe14f4699816503ad1e72e"sv}, Entry{"v1-004630-004640-blobsidecars.seg"sv, "e28762597aca5fe11c87507f30c9164f54bb0432"sv}, Entry{"v1-004630-004640-blocksidecars.idx"sv, "e1fa45dda2795a8bb23d8a2c8c811017dec0db14"sv}, Entry{"v1-004640-004650-blobsidecars.seg"sv, "5f2dbe6f2e8b227c59c2d2661ad4d50ccc2f3ebd"sv}, Entry{"v1-004640-004650-blocksidecars.idx"sv, "0cd635d5aac31452930312dae10247123f88eafa"sv}, Entry{"v1-004650-004660-blobsidecars.seg"sv, "a616f0556d7cf1677e9c5f3d72a57666d7d6d15a"sv}, Entry{"v1-004650-004660-blocksidecars.idx"sv, "c46c6535f6c64e68b31b9702d2a592709cc21f1b"sv}, Entry{"v1-004660-004670-blobsidecars.seg"sv, "7da01253aa2e2ed2f7c48bb4b864f4febaaac332"sv}, Entry{"v1-004660-004670-blocksidecars.idx"sv, "34d7781b0bfaa3d8bff0b25d166a3a6d325f4743"sv}, Entry{"v1-004670-004680-blobsidecars.seg"sv, "a13a44fef41d8b04f891a4b8a0e8d55c4a8c3bc4"sv}, Entry{"v1-004670-004680-blocksidecars.idx"sv, "cc89938c9f7c8e553bc8dd10b2b0159b72e42472"sv}, Entry{"v1-004680-004690-blobsidecars.seg"sv, "36abffd3f53d8b332b5b865eec09d62391086664"sv}, Entry{"v1-004680-004690-blocksidecars.idx"sv, "ddd3583c74143d14fbba3cbd5378c6a6fa646f19"sv}, Entry{"v1-004690-004700-blobsidecars.seg"sv, "e63422077e7c913a6fc444cf4d1223cc3f80a71c"sv}, Entry{"v1-004690-004700-blocksidecars.idx"sv, "6c8a7f1c7f9d35bc2c879a6212f1d5569809c7eb"sv}, Entry{"v1-004700-004710-blobsidecars.seg"sv, "a73a477f1b8c82613d0c74aaff64c5b6fa32702b"sv}, Entry{"v1-004700-004710-blocksidecars.idx"sv, "d608b61a187898d8ac6748c12904c7cb57792c2e"sv}, Entry{"v1-004700-004800-bodies.idx"sv, "3d751c7c7721292a92364c07d429e616486aaf9f"sv}, Entry{"v1-004700-004800-bodies.seg"sv, "cc5eb7b85874ea849c1801b5f8872960e10d44c3"sv}, Entry{"v1-004700-004800-headers.idx"sv, "c83380a5548c0ec027bad2a776ea12c3570095d2"sv}, Entry{"v1-004700-004800-headers.seg"sv, "2a6b826cbdd2fb2f6d36d6ddafa5a2380f33690d"sv}, Entry{"v1-004700-004800-transactions-to-block.idx"sv, "174dad4271c220ab2df37da0b971e3f5524af78c"sv}, Entry{"v1-004700-004800-transactions.idx"sv, "50f95f69fefa23d79fe77ff693fc7543f5cde201"sv}, Entry{"v1-004700-004800-transactions.seg"sv, "238a6d5db83cfb3bcb6181d84045618653e5033b"sv}, Entry{"v1-004710-004720-blobsidecars.seg"sv, "d5e80e5f0c4951aa1c9a4e569e430d446ce5ca75"sv}, Entry{"v1-004710-004720-blocksidecars.idx"sv, "ca626dfeef86068d5dfec4680733283887b2ac87"sv}, Entry{"v1-004720-004730-blobsidecars.seg"sv, "320884e90da237d74b4844babbbc11c6292b91df"sv}, Entry{"v1-004720-004730-blocksidecars.idx"sv, "2266f85c4020bbc4c69d5e407e179cd215700e26"sv}, Entry{"v1-004730-004740-blobsidecars.seg"sv, "454c27dfcc0bb58c01c908811996d363bf5882fe"sv}, Entry{"v1-004730-004740-blocksidecars.idx"sv, "e0cd0ed1fbf463cc9c4c253d70d909cfb721ed3d"sv}, Entry{"v1-004740-004750-blobsidecars.seg"sv, "0d7b161c8665adee4cab3d2e043338c6b7c6b1b7"sv}, Entry{"v1-004740-004750-blocksidecars.idx"sv, "32fc5da15300401ab4d3e099c564db63620222c2"sv}, Entry{"v1-004750-004760-blobsidecars.seg"sv, "6c56fefa9cb6172919a4c1c7c75aa9f14b6edf37"sv}, Entry{"v1-004750-004760-blocksidecars.idx"sv, "a2a1a340edc709755f35aa9434a7a27500bbad84"sv}, Entry{"v1-004760-004770-blobsidecars.seg"sv, "11bf885db76d4a0483422fea597df34258905fad"sv}, Entry{"v1-004760-004770-blocksidecars.idx"sv, "ad581f6a87e283f9d06878a08acc68375c3d15af"sv}, Entry{"v1-004770-004780-blobsidecars.seg"sv, "e31e317987ba4ca35a293cdfd1fcfcef2aa28019"sv}, Entry{"v1-004770-004780-blocksidecars.idx"sv, "a36f6af8c72b2db9571b4bda6a0a88afb2000e1b"sv}, Entry{"v1-004780-004790-blobsidecars.seg"sv, "2a22a47076b5cc8fb032452d6162b9452d4b50d0"sv}, Entry{"v1-004780-004790-blocksidecars.idx"sv, "e688d7b6f518378f87389c2d6aa0371ec907c2de"sv}, Entry{"v1-004790-004800-blobsidecars.seg"sv, "de4943abc39a0327d2fdabb35b7c7bb61fba1544"sv}, Entry{"v1-004790-004800-blocksidecars.idx"sv, "ac909a7c6e535660f8cd6d1ce3e6ebc807b06702"sv}, Entry{"v1-004800-004810-blobsidecars.seg"sv, "b839e601eb0e77472081c45f18ba939fc3f2b58a"sv}, Entry{"v1-004800-004810-blocksidecars.idx"sv, "1d54b3f1cca928c1cd575bf9de5cbca6c471b175"sv}, Entry{"v1-004800-004900-bodies.idx"sv, "7589ea816a744eb4d7401c8bdf4a18ba2476e612"sv}, Entry{"v1-004800-004900-bodies.seg"sv, "e29c713d4b9f22dd06b5400bb0f9725b79d02b42"sv}, Entry{"v1-004800-004900-headers.idx"sv, "4b704d77f16c6089223692560b4a08fdc1c51a73"sv}, Entry{"v1-004800-004900-headers.seg"sv, "f091fe2e72910066bfef8f39631964f8140a4b8c"sv}, Entry{"v1-004800-004900-transactions-to-block.idx"sv, "bc14946a0cd34e8d6105c5c25ba87db89192d3d4"sv}, Entry{"v1-004800-004900-transactions.idx"sv, "fe6131afe8a2f3c1dbd6c76c85e3664f64a00a69"sv}, Entry{"v1-004800-004900-transactions.seg"sv, "7aac99eea22cf393cc426cf80cd107a79d7258b1"sv}, Entry{"v1-004810-004820-blobsidecars.seg"sv, "bb74aa1ae28bfbb1cfa8b2614c7deafd5f5306e2"sv}, Entry{"v1-004810-004820-blocksidecars.idx"sv, "b28b1a1e8b86149f071e09865addd573d4738bca"sv}, Entry{"v1-004820-004830-blobsidecars.seg"sv, "c56f13f261848a69df0dccf34d620735b6b626ac"sv}, Entry{"v1-004820-004830-blocksidecars.idx"sv, "07c7761e4ae4546b1134cce034bfeb17511a4068"sv}, Entry{"v1-004830-004840-blobsidecars.seg"sv, "4c2c2ac9f08f1d413481999b6202ae1b7c6fd06a"sv}, Entry{"v1-004830-004840-blocksidecars.idx"sv, "d74f6a768ff922e32723607d4a973a228a703dce"sv}, Entry{"v1-004840-004850-blobsidecars.seg"sv, "7242b3a94b3114f83dbd7c63f5bc10a8d0960b5f"sv}, Entry{"v1-004840-004850-blocksidecars.idx"sv, "938e09f36f4a6fa4ceb936dd9171f23023081c42"sv}, Entry{"v1-004850-004860-blobsidecars.seg"sv, "0162cb2646f9ff094ae76f9bc5b6d8125f9b06d9"sv}, Entry{"v1-004850-004860-blocksidecars.idx"sv, "f66861c35c5b079f156036bc0bc297a241f222f9"sv}, Entry{"v1-004860-004870-blobsidecars.seg"sv, "37e9c3ba369465d4bb73853b8c20d938803165d0"sv}, Entry{"v1-004860-004870-blocksidecars.idx"sv, "c4797b5f8da150674e1af3a9d40befead9d8e8e9"sv}, Entry{"v1-004870-004880-blobsidecars.seg"sv, "d27b06926c86e568b7ef5ef7b16d57ba4b763283"sv}, Entry{"v1-004870-004880-blocksidecars.idx"sv, "f7a8689ca3b19d72a85773f9683ec3eb6b753527"sv}, Entry{"v1-004880-004890-blobsidecars.seg"sv, "c487684198e00383ac63d6badc9a9aaf9d8eafe1"sv}, Entry{"v1-004880-004890-blocksidecars.idx"sv, "ab252c8adbe2697c75f02043e9426c1d874eb738"sv}, Entry{"v1-004890-004900-blobsidecars.seg"sv, "145393f460bdc199cc009406d0a8f515858a4f37"sv}, Entry{"v1-004890-004900-blocksidecars.idx"sv, "285a3b758132ee82402dc2c027fcbddfe7ddb7af"sv}, Entry{"v1-004900-004910-blobsidecars.seg"sv, "52a85f17d7e53699f0e929597a4a1cdf7a5c22fa"sv}, Entry{"v1-004900-004910-blocksidecars.idx"sv, "0aaadbfc46f167ff98e5458dcdd0f12e8dded320"sv}, Entry{"v1-004900-005000-bodies.idx"sv, "2355c693bdb3a0e1dc2b4e418e89a987164849ae"sv}, Entry{"v1-004900-005000-bodies.seg"sv, "dbfff071b837d4410fa890ffc716b78a95a775ea"sv}, Entry{"v1-004900-005000-headers.idx"sv, "9d7d815a30991f9e94b060945f5a234305c312c4"sv}, Entry{"v1-004900-005000-headers.seg"sv, "993cee85a67d1106e6bcc40af758413ec4cb6498"sv}, Entry{"v1-004900-005000-transactions-to-block.idx"sv, "aeff16dbc1843d950a04975309a6fd076eef3541"sv}, Entry{"v1-004900-005000-transactions.idx"sv, "5a292b2e5904ae21440672d000832c0bf6f3805d"sv}, Entry{"v1-004900-005000-transactions.seg"sv, "06c1bd87f228a671948122a4c7284d909cb13542"sv}, Entry{"v1-004910-004920-blobsidecars.seg"sv, "a828da786e1a5da3c158f3a4fb295a7caaf1403c"sv}, Entry{"v1-004910-004920-blocksidecars.idx"sv, "cee85abcda0af763daebacb8bc907e420261e5d5"sv}, Entry{"v1-004920-004930-blobsidecars.seg"sv, "7bb44c0ccd3d89d0ac5eacfcce347200d8e55ea6"sv}, Entry{"v1-004920-004930-blocksidecars.idx"sv, "7d212e4b08ae49b2ebaa6b9fda400391384d48a0"sv}, Entry{"v1-004930-004940-blobsidecars.seg"sv, "859ee0e55f9f68c6ff603f252c1fc47a8720576f"sv}, Entry{"v1-004930-004940-blocksidecars.idx"sv, "afffeb119680b696fecd93a56c8b623b8b40bd95"sv}, Entry{"v1-004940-004950-blobsidecars.seg"sv, "d676d48c1cba4491172fa5a7bd78e807fb5adc60"sv}, Entry{"v1-004940-004950-blocksidecars.idx"sv, "c142f25a30839419ceca2e2af3d1b10bfd04e7aa"sv}, Entry{"v1-004950-004960-blobsidecars.seg"sv, "fe1639b93c2de13990b9eb510de70d8ac56d1368"sv}, Entry{"v1-004950-004960-blocksidecars.idx"sv, "5bc58f98af409142c99c0c8498dd45c41be293f8"sv}, Entry{"v1-004960-004970-blobsidecars.seg"sv, "072180011f2e62d70e4e540b0f494df7071404b2"sv}, Entry{"v1-004960-004970-blocksidecars.idx"sv, "b15610c9cad54caea94bac56c066e744ca9e8add"sv}, Entry{"v1-004970-004980-blobsidecars.seg"sv, "997caf2a7050e21e2186b16e14e17c4dd73f2514"sv}, Entry{"v1-004970-004980-blocksidecars.idx"sv, "021953b31aea48582cfec92382040310e729a13f"sv}, Entry{"v1-004980-004990-blobsidecars.seg"sv, "1731187a900b85aa9a8401067ac0f70fe95cbf6f"sv}, Entry{"v1-004980-004990-blocksidecars.idx"sv, "45c3f37b40b573f9326c587fbcbc2a55269fca1b"sv}, Entry{"v1-004990-005000-blobsidecars.seg"sv, "edf866fd062902eb61e0f3c12f8a3db79c9b7adf"sv}, Entry{"v1-004990-005000-blocksidecars.idx"sv, "5d628ea29dc238d866669895c201dddf580f60ba"sv}, Entry{"v1-005000-005010-blobsidecars.seg"sv, "fccc093fc094c503763b6c85433ce033ee30a98b"sv}, Entry{"v1-005000-005010-blocksidecars.idx"sv, "e2dbb8e0cd789009f842bb484039c9a6ec7c9240"sv}, Entry{"v1-005000-005100-bodies.idx"sv, "06b951204ef4b3002ffa91185c34228fe875ea66"sv}, Entry{"v1-005000-005100-bodies.seg"sv, "2f100cb72e878aa78081ffbff9e21552b1d29070"sv}, Entry{"v1-005000-005100-headers.idx"sv, "fe14e4e15384d839d9dd36fffd02201c4e511dd0"sv}, Entry{"v1-005000-005100-headers.seg"sv, "7f79e789d107b519534d1ecafb1c05ca147d321a"sv}, Entry{"v1-005000-005100-transactions-to-block.idx"sv, "2d97c887d0e9ca9f4e481953c6d717aaf405fb6e"sv}, Entry{"v1-005000-005100-transactions.idx"sv, "8ad2bf49a37cf8fedf6c123bdfb613c58be40dde"sv}, Entry{"v1-005000-005100-transactions.seg"sv, "9f755c43a73e87ff34c205502457c4ad4088f3c7"sv}, Entry{"v1-005010-005020-blobsidecars.seg"sv, "d242896ef69ab11ca872adbcf65d8da291996181"sv}, Entry{"v1-005010-005020-blocksidecars.idx"sv, "d97413fe825008c69cbc124895d5ae303353b479"sv}, Entry{"v1-005020-005030-blobsidecars.seg"sv, "07798cfceb94c4588f856d857dc5ee071961462e"sv}, Entry{"v1-005020-005030-blocksidecars.idx"sv, "801dc419744c8ab72852a6d9c017cbbda07381cf"sv}, Entry{"v1-005030-005040-blobsidecars.seg"sv, "1a32e84ff514461680c04f24e94cea96d5f155bc"sv}, Entry{"v1-005030-005040-blocksidecars.idx"sv, "81dc4bc9d0a47dffff151def1a766a225579d8eb"sv}, Entry{"v1-005040-005050-blobsidecars.seg"sv, "6d2d0e97cce4e87babecca6c3c4082c749cf7f0a"sv}, Entry{"v1-005040-005050-blocksidecars.idx"sv, "b1c58c42c9c9fb81ef48fc12d7f4679fede8b8fb"sv}, Entry{"v1-005050-005060-blobsidecars.seg"sv, "8601c715ef2347d564a081b45d9b1b8c413e4d57"sv}, Entry{"v1-005050-005060-blocksidecars.idx"sv, "0b822071819f20a504a31ec2f3c3af58a5d5a725"sv}, Entry{"v1-005060-005070-blobsidecars.seg"sv, "6ca9d25ddc36ac840800bff636fc08a921fda3ec"sv}, Entry{"v1-005060-005070-blocksidecars.idx"sv, "eb6e1361e2c5e192d04c9a01b46736d4225d45d7"sv}, Entry{"v1-005070-005080-blobsidecars.seg"sv, "78c2c16ce90bd784e061e5f8f69e5a5df7994d73"sv}, Entry{"v1-005070-005080-blocksidecars.idx"sv, "e5b3dc49815ef21d1515eb2d845a0aac2c62c23d"sv}, Entry{"v1-005080-005090-blobsidecars.seg"sv, "8a0e8cc4508f37bb8675dd527fb3428ff74dc160"sv}, Entry{"v1-005080-005090-blocksidecars.idx"sv, "97f4ef34e50429a29a05321cc1d4dd9d35fd715a"sv}, Entry{"v1-005090-005100-blobsidecars.seg"sv, "edf09dbf45ed4e299d8870feabfdfb8869855c43"sv}, Entry{"v1-005090-005100-blocksidecars.idx"sv, "fc166a08fdc997784672b9826f11e98955620807"sv}, Entry{"v1-005100-005110-blobsidecars.seg"sv, "48380d2369f44e6fec608e50d016e9043bdc3e87"sv}, Entry{"v1-005100-005110-blocksidecars.idx"sv, "4505448cb1253bcbcd81ce68d46cc0e08ca06c7f"sv}, Entry{"v1-005100-005200-bodies.idx"sv, "7fb92371264d8b70f1edb408e99108010e7fc99c"sv}, Entry{"v1-005100-005200-bodies.seg"sv, "b3cc6a07e2bf564ffc7c74fa5f0691a744604bad"sv}, Entry{"v1-005100-005200-headers.idx"sv, "c870cc1ae68afeb2d7e9cf005be667fcc3dca806"sv}, Entry{"v1-005100-005200-headers.seg"sv, "80f226d93b6dd56e03acc2a1a87197535e022ee2"sv}, Entry{"v1-005100-005200-transactions-to-block.idx"sv, "97cf2b0111314a07e4aad1e8cebbc88356a6a725"sv}, Entry{"v1-005100-005200-transactions.idx"sv, "463517b99718817a4b2e91ebbe1c58e82b675a3b"sv}, Entry{"v1-005100-005200-transactions.seg"sv, "313b5fa0319e2198dd11df0139434fc6c537d9d6"sv}, Entry{"v1-005110-005120-blobsidecars.seg"sv, "77628903f58c1a511967f3291a7f83870aba4104"sv}, Entry{"v1-005110-005120-blocksidecars.idx"sv, "2d9c7ba34c55ed6b4a262d2c2cd088e9461a2032"sv}, Entry{"v1-005120-005130-blobsidecars.seg"sv, "855c84def10b957fd64999107b23898759fd41aa"sv}, Entry{"v1-005120-005130-blocksidecars.idx"sv, "673f705a221c10ba6065aa2b18ef656c49dc2733"sv}, Entry{"v1-005130-005140-blobsidecars.seg"sv, "79ca7f87216efe3122ac394722576514a83ba3dc"sv}, Entry{"v1-005130-005140-blocksidecars.idx"sv, "dafc662fcc9e96dca2ce7b0844b0bb7362df9543"sv}, Entry{"v1-005140-005150-blobsidecars.seg"sv, "be199a2c89a221062f06891555422a87134fc41a"sv}, Entry{"v1-005140-005150-blocksidecars.idx"sv, "608dbce83d1d36ee20147df73512fcbb75ac092a"sv}, Entry{"v1-005150-005160-blobsidecars.seg"sv, "89fe347715a4ba3ec3d958d3027e9b8d68c81b4e"sv}, Entry{"v1-005150-005160-blocksidecars.idx"sv, "a17f18d25a769a99e63e24609f8c62c988f73ca5"sv}, Entry{"v1-005160-005170-blobsidecars.seg"sv, "4d877dc3789bbb74000f8ba8fe4d95ce708070d6"sv}, Entry{"v1-005160-005170-blocksidecars.idx"sv, "1594fcd08e8155d48e5dd8da96ff927522ffc797"sv}, Entry{"v1-005170-005180-blobsidecars.seg"sv, "67933a4e6ad8f68694ce473deb6765bbcc1b4339"sv}, Entry{"v1-005170-005180-blocksidecars.idx"sv, "a828d929262398e0a1b49a3e7ccdaf9392c8f076"sv}, Entry{"v1-005180-005190-blobsidecars.seg"sv, "fd6346a10dba2c2250be0ae8cb40b7efd6f95714"sv}, Entry{"v1-005180-005190-blocksidecars.idx"sv, "8605f672014800c96ec4c9d91c45cc1befc8d3ec"sv}, Entry{"v1-005190-005200-blobsidecars.seg"sv, "1bc5719b7741ab8b1568bee8554019350b93fdcd"sv}, Entry{"v1-005190-005200-blocksidecars.idx"sv, "66c0b4f10f998fe835759aa699703837a560b511"sv}, Entry{"v1-005200-005210-blobsidecars.seg"sv, "f633eb93e0884c9290382c64168695acf797321c"sv}, Entry{"v1-005200-005210-blocksidecars.idx"sv, "7fde510545df77c6cc8e4b6093f8df8065f3f66d"sv}, Entry{"v1-005200-005300-bodies.idx"sv, "735833bc998a889ec9f5928cb24a54a0975dc5be"sv}, Entry{"v1-005200-005300-bodies.seg"sv, "540958e1f624fa61d657c74d7532362d25dabced"sv}, Entry{"v1-005200-005300-headers.idx"sv, "0b1a8552e3a96f29d4b90489c975a017d4862e6e"sv}, Entry{"v1-005200-005300-headers.seg"sv, "5f4a1eebd951b5f3001bc857e58ba22fc164c668"sv}, Entry{"v1-005200-005300-transactions-to-block.idx"sv, "3879511c3f226845f3943666a9dc110ee7f8d423"sv}, Entry{"v1-005200-005300-transactions.idx"sv, "d42f0dddce3ed06e04324035597638ce92821778"sv}, Entry{"v1-005200-005300-transactions.seg"sv, "df8fdf11cc166ab20b08d73ea0fc44e0f9719129"sv}, Entry{"v1-005210-005220-blobsidecars.seg"sv, "c168dbde0b00e4bfd833e013eb808d68f9e12a65"sv}, Entry{"v1-005210-005220-blocksidecars.idx"sv, "f756acde0e643fe0473efa9f84dcb3913c180a16"sv}, Entry{"v1-005220-005230-blobsidecars.seg"sv, "c70395412435d7cf6079cc51d2af93876e20305f"sv}, Entry{"v1-005220-005230-blocksidecars.idx"sv, "1a8e9c58e06364c081006a8db5224c5c459b17f0"sv}, Entry{"v1-005230-005240-blobsidecars.seg"sv, "d2560564cea48158d56dc59fe4ef384f187b29df"sv}, Entry{"v1-005230-005240-blocksidecars.idx"sv, "13c5ba9e39325eeeff3b298d0afa287a0198fdc5"sv}, Entry{"v1-005240-005250-blobsidecars.seg"sv, "8b8c7ad1ec1b68da1a73e8a453e542cdba8334ce"sv}, Entry{"v1-005240-005250-blocksidecars.idx"sv, "e9e3b5a079aaa732b3074904efaa59c2732afe91"sv}, Entry{"v1-005250-005260-blobsidecars.seg"sv, "1821aacc01a68fc2a75a3af04a43c321e5dd0adb"sv}, Entry{"v1-005250-005260-blocksidecars.idx"sv, "ab569057526a5e2c1e502c466f6d52e2c9abb67c"sv}, Entry{"v1-005260-005270-blobsidecars.seg"sv, "7868b3b2afa61432122ce82213eebf63db76e5a9"sv}, Entry{"v1-005260-005270-blocksidecars.idx"sv, "5639668591a0620aced0d3aaf00214237d2007a9"sv}, Entry{"v1-005270-005280-blobsidecars.seg"sv, "ebedccb5c74d3574a348e4807b0159125f945907"sv}, Entry{"v1-005270-005280-blocksidecars.idx"sv, "0656c67c2c6cb728bd6836d7b3367324e78fbf6a"sv}, Entry{"v1-005280-005290-blobsidecars.seg"sv, "104b40fd0bb0ac811d6d2a62acb789cb64364053"sv}, Entry{"v1-005280-005290-blocksidecars.idx"sv, "779195b55264ddc5c9363c6ce314d75ee301744e"sv}, Entry{"v1-005290-005300-blobsidecars.seg"sv, "437e432c0e2b79c3752815fe929ed1690f1a2bb4"sv}, Entry{"v1-005290-005300-blocksidecars.idx"sv, "3110477a4a41b5a507ba63c6852b4a59d9ebeefc"sv}, Entry{"v1-005300-005310-blobsidecars.seg"sv, "fcb6d88f7529fda07bf1d3dc95eafb6824eef61d"sv}, Entry{"v1-005300-005310-blocksidecars.idx"sv, "9ce273ac149da4a94c390995c3b37bf81cccc042"sv}, Entry{"v1-005300-005400-bodies.idx"sv, "ca34b287dca9d59f9eb261df0a4be63c521c3a95"sv}, Entry{"v1-005300-005400-bodies.seg"sv, "5da90b2d1a4570af43361f7e6097701a2beb4356"sv}, Entry{"v1-005300-005400-headers.idx"sv, "ed3727804c69bf349a6cbff667ca243b194ac36c"sv}, Entry{"v1-005300-005400-headers.seg"sv, "f5f2f89b984427de8b74ae15aef1aba309725fbd"sv}, Entry{"v1-005300-005400-transactions-to-block.idx"sv, "a786f4730a39c3c6a8f7578c9039c5cb38d37850"sv}, Entry{"v1-005300-005400-transactions.idx"sv, "23459bc76450ff9d8e534a8f7e636e711c059c4c"sv}, Entry{"v1-005300-005400-transactions.seg"sv, "31381d60552f269d088b77c9a86926c8d04e0f17"sv}, Entry{"v1-005310-005320-blobsidecars.seg"sv, "aba5a104500ad5bbace3fb2604d4fc60df80032c"sv}, Entry{"v1-005310-005320-blocksidecars.idx"sv, "17723bff6cdb04e737a5c50a40843e230965130a"sv}, Entry{"v1-005320-005330-blobsidecars.seg"sv, "8f7960c5a79b0a4919376ad916aac15ab1918b12"sv}, Entry{"v1-005320-005330-blocksidecars.idx"sv, "d994218332b8eaf1edfeb5f089de59c6321bcdeb"sv}, Entry{"v1-005330-005340-blobsidecars.seg"sv, "23033f9d46dfca2057271ba945d163c8e30d6bf8"sv}, Entry{"v1-005330-005340-blocksidecars.idx"sv, "766667b00b72bb3507349f7dfdd3331838e065ee"sv}, Entry{"v1-005340-005350-blobsidecars.seg"sv, "70b15da5eaddd40ba75f5932975d9dd56671732e"sv}, Entry{"v1-005340-005350-blocksidecars.idx"sv, "3c0a4e27e44913cf14d17d1db5ea8d91f8d6b28f"sv}, Entry{"v1-005350-005360-blobsidecars.seg"sv, "109e95a5b635d6673ec272a35244f126e82741a4"sv}, Entry{"v1-005350-005360-blocksidecars.idx"sv, "bea1fd914360daab434d59333a1ca021286b7225"sv}, Entry{"v1-005360-005370-blobsidecars.seg"sv, "b46a677ce42a65cb359374adcf8f5f0358d7b4d2"sv}, Entry{"v1-005360-005370-blocksidecars.idx"sv, "c88e7ccfdeb07dcfe05247e6f590530390a45809"sv}, Entry{"v1-005370-005380-blobsidecars.seg"sv, "0193fb5a2d6e85857246d92e77eb8075c472a186"sv}, Entry{"v1-005370-005380-blocksidecars.idx"sv, "f7861d2b948b526f0acc9849e27c00358a28bd6c"sv}, Entry{"v1-005380-005390-blobsidecars.seg"sv, "3f96d54642f5e8ae3cf7f9c9998b9914b8e54581"sv}, Entry{"v1-005380-005390-blocksidecars.idx"sv, "518c4aed1ccaac9d9af78eb975aa74b7d52fe6b1"sv}, Entry{"v1-005390-005400-blobsidecars.seg"sv, "97e708dc29acc31aced3e20388113e40db7334e3"sv}, Entry{"v1-005390-005400-blocksidecars.idx"sv, "129b492ee7d80eea71da5c03351ae0381d104c80"sv}, Entry{"v1-005400-005410-blobsidecars.seg"sv, "03c303778712f257e5fb13ad0c4deb84405aae7b"sv}, Entry{"v1-005400-005410-blocksidecars.idx"sv, "6444f740dc1002a2b07667a23d64e52222275f9b"sv}, Entry{"v1-005400-005500-bodies.idx"sv, "c34639f486edc49126fbfdcb90f9ad630e61c3c6"sv}, Entry{"v1-005400-005500-bodies.seg"sv, "bb33aa41ba08a3a4d5c02411f30f6d32ac597fe7"sv}, Entry{"v1-005400-005500-headers.idx"sv, "0286c60be3804a69df9aa613eb901c4bca9461bd"sv}, Entry{"v1-005400-005500-headers.seg"sv, "f5d28ff5498addd4bd514f45cc3297eab17f2d91"sv}, Entry{"v1-005400-005500-transactions-to-block.idx"sv, "9438da849b24882587362206a784e2452c57cbc1"sv}, Entry{"v1-005400-005500-transactions.idx"sv, "b7a743e9cd875075f7c21ee4aba34a09ec2b815e"sv}, Entry{"v1-005400-005500-transactions.seg"sv, "6146d197a9f757ca93fe9feb0a5eb6e16d35cc38"sv}, Entry{"v1-005410-005420-blobsidecars.seg"sv, "0c5ca935edd9d33701e1ac4d69ef5f7bda954d0a"sv}, Entry{"v1-005410-005420-blocksidecars.idx"sv, "4e73a0f2326db0d92fedb5074ff6e36b5c356b83"sv}, Entry{"v1-005420-005430-blobsidecars.seg"sv, "ae625d1ed89c1b7560fb2195c48a6330ccedd0f1"sv}, Entry{"v1-005420-005430-blocksidecars.idx"sv, "d08f6a44f9c256e95e836859bf550a84c98efe1c"sv}, Entry{"v1-005430-005440-blobsidecars.seg"sv, "58163d65dcc94affecde7570a2eaceeb67be2490"sv}, Entry{"v1-005430-005440-blocksidecars.idx"sv, "1851ae6f0cd4b84f0cdaf5a8286c9406ccdd8d0a"sv}, Entry{"v1-005440-005450-blobsidecars.seg"sv, "1b6f8ac5b382edd074832bfbd41817c7b7c75c63"sv}, Entry{"v1-005440-005450-blocksidecars.idx"sv, "45ea3ff378487f1a226398fa82fbffb98101bdba"sv}, Entry{"v1-005450-005460-blobsidecars.seg"sv, "06c69ca5680e3a25d57ec80ac0ba911254d27025"sv}, Entry{"v1-005450-005460-blocksidecars.idx"sv, "954ba2b672168d561783b4145f8a11720b600b04"sv}, Entry{"v1-005460-005470-blobsidecars.seg"sv, "9144006437ab5ddd3f61c159963e000589c5fa0d"sv}, Entry{"v1-005460-005470-blocksidecars.idx"sv, "43fba5924d892f040d55b397ed13cd5703c22cdf"sv}, Entry{"v1-005470-005480-blobsidecars.seg"sv, "adc80792677ae79f42948b6280e7d0b4970875f2"sv}, Entry{"v1-005470-005480-blocksidecars.idx"sv, "f359f407dc8007da25a2935d0bdb013c0788396d"sv}, Entry{"v1-005480-005490-blobsidecars.seg"sv, "44ea32769b585a0ecd6fb916fcaa72bc2215f37e"sv}, Entry{"v1-005480-005490-blocksidecars.idx"sv, "08491d92bdcbd49288607603eeef0dfc66aa9465"sv}, Entry{"v1-005490-005500-blobsidecars.seg"sv, "6dcf83529ba10ef7177aef824cadeb26360ff5e1"sv}, Entry{"v1-005490-005500-blocksidecars.idx"sv, "32d3ab061de4cc75d2dd2d08973dee26eebde333"sv}, Entry{"v1-005500-005510-blobsidecars.seg"sv, "a943873cbeeb0a08e65cb111288ed9ee023445f4"sv}, Entry{"v1-005500-005510-blocksidecars.idx"sv, "44f558509d8bc41a0840489ed0c4615f67f657d1"sv}, Entry{"v1-005500-005600-bodies.idx"sv, "6eeaea644b874db51bbd0a55043a4f8287ddfc13"sv}, Entry{"v1-005500-005600-bodies.seg"sv, "d283cbf5762b8d89c939f9d84269eca30db8ec6e"sv}, Entry{"v1-005500-005600-headers.idx"sv, "eff790085c0fe9a65f4ed675221a8175c96f2896"sv}, Entry{"v1-005500-005600-headers.seg"sv, "472b35fa295957d17f2ad397097f9e0633b5a5f2"sv}, Entry{"v1-005500-005600-transactions-to-block.idx"sv, "6bf9f8eeaa7adfe8d13503ef1dbd893b15e24d95"sv}, Entry{"v1-005500-005600-transactions.idx"sv, "68064fdb62be575ce23eedf7d0395aac82eb0a1d"sv}, Entry{"v1-005500-005600-transactions.seg"sv, "26529cee6b067529521e3bca6113fb2116a0ce40"sv}, Entry{"v1-005510-005520-blobsidecars.seg"sv, "115ba8db7868461541fac87e0a93ba57f7d0b77f"sv}, Entry{"v1-005510-005520-blocksidecars.idx"sv, "acfca00dac4090aada3a2c451be40c019a0ddabe"sv}, Entry{"v1-005520-005530-blobsidecars.seg"sv, "af4bf828e9999044eb4f08a6cebb6efb1092a554"sv}, Entry{"v1-005520-005530-blocksidecars.idx"sv, "b125abbb8cc0d5b824fb1d35ab7881c74fac2eb8"sv}, Entry{"v1-005530-005540-blobsidecars.seg"sv, "a8f8b172776f02242cce4cb3ec66b7fd4bde391b"sv}, Entry{"v1-005530-005540-blocksidecars.idx"sv, "6ab4c8cc758db621e7ede4bfc0422a97fa5cb24c"sv}, Entry{"v1-005540-005550-blobsidecars.seg"sv, "c60120c3d01af84b1a785844d345375495d6ed80"sv}, Entry{"v1-005540-005550-blocksidecars.idx"sv, "fd79426081db990bed8f8325f0d8810779d33055"sv}, Entry{"v1-005550-005560-blobsidecars.seg"sv, "9811e4c019590671dca38dd15ed7b219f6a8652e"sv}, Entry{"v1-005550-005560-blocksidecars.idx"sv, "28e2a1ca0fbd62e161f5e5c8a288916d8d91c0f7"sv}, Entry{"v1-005560-005570-blobsidecars.seg"sv, "fc6f785f4087c6b5449bc49d8471644c12b3c213"sv}, Entry{"v1-005560-005570-blocksidecars.idx"sv, "65427a7b5a3e5067a65156ecc8604d5e9bfce33c"sv}, Entry{"v1-005570-005580-blobsidecars.seg"sv, "52d871c022aebfec6269e002574106e1456304f8"sv}, Entry{"v1-005570-005580-blocksidecars.idx"sv, "b03422bfd39def6309034b383068fb1334304db3"sv}, Entry{"v1-005580-005590-blobsidecars.seg"sv, "01ee8dbac6b60a89020259e53a9180279dfee1dc"sv}, Entry{"v1-005580-005590-blocksidecars.idx"sv, "23e5de590178544a8b35d890cf1c88bc062294f8"sv}, Entry{"v1-005590-005600-blobsidecars.seg"sv, "981b6d653413eb77d56976fa223d90d5f5600a0f"sv}, Entry{"v1-005590-005600-blocksidecars.idx"sv, "17c9deaebc237a96678142891a089f5d6ffea990"sv}, Entry{"v1-005600-005610-blobsidecars.seg"sv, "f4154de990cbd7be939994f2208dc9660a051a29"sv}, Entry{"v1-005600-005610-blocksidecars.idx"sv, "1ad0160c28d4e03f6bee61444814376c9449a4cd"sv}, Entry{"v1-005600-005700-bodies.idx"sv, "e43086ce0dc928be6089b0c3dc0badff93a7c8ce"sv}, Entry{"v1-005600-005700-bodies.seg"sv, "f409ed08f159dc0701a2b6a1602a8f2ba042e2df"sv}, Entry{"v1-005600-005700-headers.idx"sv, "0cf8a65c89f246acaa2f62ce19d9b82b524e69f2"sv}, Entry{"v1-005600-005700-headers.seg"sv, "d6aa0f0908c6692c1b73bcf6664217184e986c52"sv}, Entry{"v1-005600-005700-transactions-to-block.idx"sv, "b9a3f727f99cfcbf59b62a433c8b0c56d199de77"sv}, Entry{"v1-005600-005700-transactions.idx"sv, "e00ea7e201fc6fe08d2d644a63b50cc48723cdec"sv}, Entry{"v1-005600-005700-transactions.seg"sv, "9a26c1a919798532b6023f00f6f14a353992342e"sv}, Entry{"v1-005610-005620-blobsidecars.seg"sv, "0966661664b2dbb0c2056014e9188d038da27fcb"sv}, Entry{"v1-005610-005620-blocksidecars.idx"sv, "5b3e23e66a52b7a26fd8c5b04b00bd7b9ba2344c"sv}, Entry{"v1-005620-005630-blobsidecars.seg"sv, "82f261c0b7b5303d25d68f5bbe290e48cb4f3d29"sv}, Entry{"v1-005620-005630-blocksidecars.idx"sv, "fbd37b04245d6fa540f44b058f11a7c66805033a"sv}, Entry{"v1-005630-005640-blobsidecars.seg"sv, "21adbd9fa8045579722bfd225e93a08cf234fab7"sv}, Entry{"v1-005630-005640-blocksidecars.idx"sv, "99d72fdc2771a17ccde209c34600a05619efcd76"sv}, Entry{"v1-005640-005650-blobsidecars.seg"sv, "240a10da42dd87acd2cf704f92adee312e33696d"sv}, Entry{"v1-005640-005650-blocksidecars.idx"sv, "555627a232fc47d81180268960dea3af2ffeb599"sv}, Entry{"v1-005650-005660-blobsidecars.seg"sv, "5bb8c020fa7c594133d7baf9bbe26ea66dc6e070"sv}, Entry{"v1-005650-005660-blocksidecars.idx"sv, "d9ca05ebd73fa5a9d2619166201e40d421010b62"sv}, Entry{"v1-005660-005670-blobsidecars.seg"sv, "4a255853704c89ac41c0d717e6fd4543e2573ab9"sv}, Entry{"v1-005660-005670-blocksidecars.idx"sv, "221b34cf3672527785272dbb9e4156d650910143"sv}, Entry{"v1-005670-005680-blobsidecars.seg"sv, "a29b367beccfc60da763ea981847ea92cf84fed3"sv}, Entry{"v1-005670-005680-blocksidecars.idx"sv, "d0eab0be1d91af3346b20df873f888a9fea50c75"sv}, Entry{"v1-005680-005690-blobsidecars.seg"sv, "70b3d86d192907e31f05fbe50a47a928da2eefca"sv}, Entry{"v1-005680-005690-blocksidecars.idx"sv, "c68d82812ba72dc8b20e9ad87ac552bd08403c9c"sv}, Entry{"v1-005690-005700-blobsidecars.seg"sv, "760b909dd7b7dfda66a288baf7d94ee576713ba8"sv}, Entry{"v1-005690-005700-blocksidecars.idx"sv, "45d2a03dd54a650121c0d0441820b63061e6a468"sv}, Entry{"v1-005700-005710-blobsidecars.seg"sv, "92d521ed3b77ab29678f5a84cbfb5e59372c2e3e"sv}, Entry{"v1-005700-005710-blocksidecars.idx"sv, "7ebd2782623729f46cde0b7d4353be2f9ce7c7a3"sv}, Entry{"v1-005700-005800-bodies.idx"sv, "94377392ce2529f374359ccefa5348b544d9dfa8"sv}, Entry{"v1-005700-005800-bodies.seg"sv, "c9779e0f0763e421779f3b9dd157bda70f4421ae"sv}, Entry{"v1-005700-005800-headers.idx"sv, "d99466e94c762a7688dbdc58bd7934cbe284664f"sv}, Entry{"v1-005700-005800-headers.seg"sv, "5e934acceffbb42816dd9eabc138963e270cc1cc"sv}, Entry{"v1-005700-005800-transactions-to-block.idx"sv, "9a2512e5512f3b5c3e14bcfbd8ee0d91f28d098b"sv}, Entry{"v1-005700-005800-transactions.idx"sv, "c5927d4030fb120f0527516f1595808360ca336b"sv}, Entry{"v1-005700-005800-transactions.seg"sv, "a48b442d0f6001bf78e5fd4b575172e79b9b904a"sv}, Entry{"v1-005710-005720-blobsidecars.seg"sv, "69abae604c4f8dbee0818c6e4f06e20d34e1107c"sv}, Entry{"v1-005710-005720-blocksidecars.idx"sv, "d49c98c12a2a67f4f7edc4876c85822411014c55"sv}, Entry{"v1-005720-005730-blobsidecars.seg"sv, "78e559cb1397b87453bf7e81584fd3d72318337a"sv}, Entry{"v1-005720-005730-blocksidecars.idx"sv, "2f8d1db585c1e5e23ffbc6c518254d21a5cc536c"sv}, Entry{"v1-005730-005740-blobsidecars.seg"sv, "aee3fc2576fc4abe17041cbcef7ebdbdc5ebab63"sv}, Entry{"v1-005730-005740-blocksidecars.idx"sv, "e36a55a13be50638202d16958193ede4cd3e09df"sv}, Entry{"v1-005740-005750-blobsidecars.seg"sv, "fd4ea51f9e2efc17a7bccb86c0ef99742c5f53df"sv}, Entry{"v1-005740-005750-blocksidecars.idx"sv, "fe1ed985c027216d03dc76f233ccd8652a6cc9f9"sv}, Entry{"v1-005750-005760-blobsidecars.seg"sv, "c3dd86ae3e24aff758e362dcdbaeb93651cdba82"sv}, Entry{"v1-005750-005760-blocksidecars.idx"sv, "404682916a2220bc124ab860f88f2f242a9ea9ab"sv}, Entry{"v1-005760-005770-blobsidecars.seg"sv, "73b4c450961adc043ee0f06a59777583b3a68158"sv}, Entry{"v1-005760-005770-blocksidecars.idx"sv, "85290a2bb3be9b694c02edd81b8d54938f038c21"sv}, Entry{"v1-005770-005780-blobsidecars.seg"sv, "1f5d1dbae720b8e01a46b1af2ef922a987a1a133"sv}, Entry{"v1-005770-005780-blocksidecars.idx"sv, "57bcc500b1e976cd32d0fc43f845d0dd8579fea5"sv}, Entry{"v1-005780-005790-blobsidecars.seg"sv, "4c5ca181a5456b05ca1c0a3b44a775809de42b56"sv}, Entry{"v1-005780-005790-blocksidecars.idx"sv, "576f0f7050874c77ea65dfc29f69bcd244825420"sv}, Entry{"v1-005790-005800-blobsidecars.seg"sv, "499532cce90fa9d3dc79369de82593c3be4a8f0b"sv}, Entry{"v1-005790-005800-blocksidecars.idx"sv, "b9d5bb3ca8596d289b3457243c8148f1c1021897"sv}, Entry{"v1-005800-005810-blobsidecars.seg"sv, "114ee61009a375acd65ab4d382c01b590c1c4e73"sv}, Entry{"v1-005800-005810-blocksidecars.idx"sv, "879980068e043987d062534bfb953350626bba3a"sv}, Entry{"v1-005800-005900-bodies.idx"sv, "41b15de34c5c9d50a07fe62abbf29bcb930b6d91"sv}, Entry{"v1-005800-005900-bodies.seg"sv, "b1232c6d509f0aef35de6ae23c52d66815f137e2"sv}, Entry{"v1-005800-005900-headers.idx"sv, "e42cace1cf486604e0915c4eaaa19f4ac96ed130"sv}, Entry{"v1-005800-005900-headers.seg"sv, "dec4c218fe9d5df742ea100e9609a484d46aea9c"sv}, Entry{"v1-005800-005900-transactions-to-block.idx"sv, "7d52efbbdefe13df90ef57244bcc5d90361ccd4f"sv}, Entry{"v1-005800-005900-transactions.idx"sv, "bd8425379b3e01f762e2d4f61827077f38dc9105"sv}, Entry{"v1-005800-005900-transactions.seg"sv, "7364a6e77cc075395ff47dd00c47c517463c302b"sv}, Entry{"v1-005810-005820-blobsidecars.seg"sv, "296ab9d2dec09784dbbf609ee4d3e0fa67809a0d"sv}, Entry{"v1-005810-005820-blocksidecars.idx"sv, "5b1db99b702701c1e170b02d1b20a8a6047ffbf8"sv}, Entry{"v1-005820-005830-blobsidecars.seg"sv, "506a8346bcd51e5b27e10af453aa73f299693ba7"sv}, Entry{"v1-005820-005830-blocksidecars.idx"sv, "c75faee42e61b2ef6a34ccce59ac0db14f26c6bc"sv}, Entry{"v1-005830-005840-blobsidecars.seg"sv, "42c7cf3b679178feee3b23ce56927a5f8cb3d50f"sv}, Entry{"v1-005830-005840-blocksidecars.idx"sv, "d3c60929a98e38a09d253987c92c6d81233af601"sv}, Entry{"v1-005840-005850-blobsidecars.seg"sv, "ab5b55bfd82c47dfd4f48fac4d6b6f003f5513f3"sv}, Entry{"v1-005840-005850-blocksidecars.idx"sv, "7f27ffd5dc39af6f18d4b5f2138e73676b595cf1"sv}, Entry{"v1-005850-005860-blobsidecars.seg"sv, "9da0f7e1bffcd20b6e7e5e2639845114fb22a208"sv}, Entry{"v1-005850-005860-blocksidecars.idx"sv, "38be6928bfa3ee95e505b025ceb1e507ad78ed88"sv}, Entry{"v1-005860-005870-blobsidecars.seg"sv, "19b65fb172903b65768ea77778c2b22443962605"sv}, Entry{"v1-005860-005870-blocksidecars.idx"sv, "1a2d8ca43191289e6f1db9788f66c02626a9bad9"sv}, Entry{"v1-005870-005880-blobsidecars.seg"sv, "c5a3e829a6f5ba55090e919ad68c9c63a1ea68f5"sv}, Entry{"v1-005870-005880-blocksidecars.idx"sv, "4082c8c0636424aa2faaa646bdb1cc1805e15568"sv}, Entry{"v1-005880-005890-blobsidecars.seg"sv, "a04494b662d966636b38bb230592fc87b62c344b"sv}, Entry{"v1-005880-005890-blocksidecars.idx"sv, "17065e90e4ea417d6fe16a37536624debcaf772e"sv}, Entry{"v1-005890-005900-blobsidecars.seg"sv, "04b74fd02fe767529767681556c0d7e5dd466405"sv}, Entry{"v1-005890-005900-blocksidecars.idx"sv, "2d3b41e03bdbd3f7cdb4cc993e6a48bc4f0beceb"sv}, Entry{"v1-005900-005910-blobsidecars.seg"sv, "d36c36a566497d26db3383019908196424eb6c8b"sv}, Entry{"v1-005900-005910-blocksidecars.idx"sv, "741cefcf8e064e57310837d125d7e4507f659171"sv}, Entry{"v1-005900-006000-bodies.idx"sv, "444a6b7b4a2606b10da45c0861dd27a1e4587f5e"sv}, Entry{"v1-005900-006000-bodies.seg"sv, "d8d0fd31c9c01a896699e3dd29c727e0299608f4"sv}, Entry{"v1-005900-006000-headers.idx"sv, "06ab6ca36ed608d28324a0c787e992326d5d08ad"sv}, Entry{"v1-005900-006000-headers.seg"sv, "08f16b22d5797afd5853109968c0da91ae78f2a6"sv}, Entry{"v1-005900-006000-transactions-to-block.idx"sv, "e63e676d7fb5ee925e0f90e9383335b4b56ef72a"sv}, Entry{"v1-005900-006000-transactions.idx"sv, "275575db31fadd1954ad68b457adb9acee1e009a"sv}, Entry{"v1-005900-006000-transactions.seg"sv, "09e70163e8db9f4596bfff1c6c896081ec9832cc"sv}, Entry{"v1-005910-005920-blobsidecars.seg"sv, "9569fcfe9fc9b32ee00c88dc545171d5924e2a2e"sv}, Entry{"v1-005910-005920-blocksidecars.idx"sv, "0f829967108367a3e467c5d469c07dbea3c079c8"sv}, Entry{"v1-005920-005930-blobsidecars.seg"sv, "2fa376b7ebdbb8e11b996b1a0d3be0b4522d6a11"sv}, Entry{"v1-005920-005930-blocksidecars.idx"sv, "4fa363fc577cfcae5dd2b04ffca057e937b58660"sv}, Entry{"v1-005930-005940-blobsidecars.seg"sv, "cb6de5c4b95b956de623761dcb4b1d38f6349d54"sv}, Entry{"v1-005930-005940-blocksidecars.idx"sv, "5d2139387c4495ef196f55357ddb5b607c464745"sv}, Entry{"v1-005940-005950-blobsidecars.seg"sv, "0176b312601ded64a4965728e86af1f28ff40e43"sv}, Entry{"v1-005940-005950-blocksidecars.idx"sv, "14d81a2aab8c7f824c6473dcef7199f362b8daf4"sv}, Entry{"v1-005950-005960-blobsidecars.seg"sv, "6524493209cd04daa208fd056d04b59a04dbb090"sv}, Entry{"v1-005950-005960-blocksidecars.idx"sv, "8d85fbc3bfedcb5f62560f00e5f1a25be1854f46"sv}, Entry{"v1-005960-005970-blobsidecars.seg"sv, "c4015a92490beebed3e19349b650b25d36ae6eff"sv}, Entry{"v1-005960-005970-blocksidecars.idx"sv, "f70d087599de7291f1793a876cb21c9081d68733"sv}, Entry{"v1-005970-005980-blobsidecars.seg"sv, "cfc30d5a51965acbc5ac7033ab086ca153b9b002"sv}, Entry{"v1-005970-005980-blocksidecars.idx"sv, "98d8732578f7a8d62cdd63ea7f53abb8921f56f1"sv}, Entry{"v1-005980-005990-blobsidecars.seg"sv, "22e181f397c1447221dcbe5377edfc19f8fc4276"sv}, Entry{"v1-005980-005990-blocksidecars.idx"sv, "0048ecd71da2368664dd67ea3545eaab42ccb111"sv}, Entry{"v1-005990-006000-blobsidecars.seg"sv, "f54296e5cb570ff68e88aab0c68a13ce84398774"sv}, Entry{"v1-005990-006000-blocksidecars.idx"sv, "e2935893074065cc37d2efd5b478ed7b6bc36323"sv}, Entry{"v1-006000-006010-blobsidecars.seg"sv, "0a51c7bf00c3d394a3417ba1d2dc5a2cc55ef3a7"sv}, Entry{"v1-006000-006010-blocksidecars.idx"sv, "2b10ac63a184a271ddb87adec3811f8e4843c302"sv}, Entry{"v1-006000-006100-bodies.idx"sv, "5d90d6baf896c4b9dbfa0544ad62f192b79b3689"sv}, Entry{"v1-006000-006100-bodies.seg"sv, "981972a5c6109879b8190b5eaab15266203290c7"sv}, Entry{"v1-006000-006100-headers.idx"sv, "568bc8fb46f40673f8b279b15335d48cd2ccd87c"sv}, Entry{"v1-006000-006100-headers.seg"sv, "a2d4d663ef27409ae893bc0c469b39198aeb8b3c"sv}, Entry{"v1-006000-006100-transactions-to-block.idx"sv, "f06e505936e0974dee16e10e3f8731dbf55386c6"sv}, Entry{"v1-006000-006100-transactions.idx"sv, "3792c57a0cf1d34ce34c25efbcfde667144cd353"sv}, Entry{"v1-006000-006100-transactions.seg"sv, "47077c05ac0c2a2754d464ac7621fa6715256c72"sv}, Entry{"v1-006010-006020-blobsidecars.seg"sv, "9d5ea52bd169c22889baa58b530cd868142cf0f8"sv}, Entry{"v1-006010-006020-blocksidecars.idx"sv, "e69891bf9ee46349b38010017781320672ae76bd"sv}, Entry{"v1-006020-006030-blobsidecars.seg"sv, "23c0a9886b65ab3e9bff269659435fbcfb9111ed"sv}, Entry{"v1-006020-006030-blocksidecars.idx"sv, "157f46be96f87ca0cd6bab6e135a2bd06ddff6cd"sv}, Entry{"v1-006030-006040-blobsidecars.seg"sv, "384f1cb2f3d3e8aa2a72ecf049037c47136f0496"sv}, Entry{"v1-006030-006040-blocksidecars.idx"sv, "befa606ac017d255d2cbded8ee06fc7fb2dd22ee"sv}, Entry{"v1-006040-006050-blobsidecars.seg"sv, "490325b7cad1ff630b21f4cfa9ff174d612d56f3"sv}, Entry{"v1-006040-006050-blocksidecars.idx"sv, "a6a344fd5c217796814542050d20b72790e7f862"sv}, Entry{"v1-006050-006060-blobsidecars.seg"sv, "6b3dec2c16dbb4771386570ada9c03262d7d6c6e"sv}, Entry{"v1-006050-006060-blocksidecars.idx"sv, "53fcedf052660aa6b8c8697309e405e039a89b5a"sv}, Entry{"v1-006060-006070-blobsidecars.seg"sv, "273241b249a9d2980e24f230b42f788da29ea284"sv}, Entry{"v1-006060-006070-blocksidecars.idx"sv, "424821df4a55f15af38d170e8af8dbf53f06d478"sv}, Entry{"v1-006070-006080-blobsidecars.seg"sv, "d322d5e8b7c9136daa5e83208dd1523e7cf6f3e3"sv}, Entry{"v1-006070-006080-blocksidecars.idx"sv, "9c0afa155f9c28703d3937b4dbb748f052338956"sv}, Entry{"v1-006080-006090-blobsidecars.seg"sv, "9b9e280776d70a5a284a6c0a16f6351d04d137d2"sv}, Entry{"v1-006080-006090-blocksidecars.idx"sv, "d5b4ca7f37017fb54f10bf65e833dcbe80dd67d9"sv}, Entry{"v1-006090-006100-blobsidecars.seg"sv, "e1c63a4a311240fb1e28cc7acbb62ed1aba3b9d1"sv}, Entry{"v1-006090-006100-blocksidecars.idx"sv, "79244b7e1325bd4c0d0339c25780ca7b0fbfda8d"sv}, Entry{"v1-006100-006110-blobsidecars.seg"sv, "1b2a6b5a6f1c5b5bd5ec9b4ba4ada0d461a8d3b2"sv}, Entry{"v1-006100-006110-blocksidecars.idx"sv, "5540991ac23c9f0ad675db207368684c0c29f717"sv}, Entry{"v1-006100-006200-bodies.idx"sv, "407759d97e2c2168dd1e004924885384eec4e5f9"sv}, Entry{"v1-006100-006200-bodies.seg"sv, "6b34bb98ef00ef28a750420021b3d3e635eade21"sv}, Entry{"v1-006100-006200-headers.idx"sv, "81c50337013b27ccfcb313f5149822d98fd386ff"sv}, Entry{"v1-006100-006200-headers.seg"sv, "68ba7976e25b96b1af44c9a8ff42d5a8e87bdfbd"sv}, Entry{"v1-006100-006200-transactions-to-block.idx"sv, "b2943d68be27672930119b07dd0b8026d39135e9"sv}, Entry{"v1-006100-006200-transactions.idx"sv, "77e059a090ba326fde013ca13a1cfb6019a65d43"sv}, Entry{"v1-006100-006200-transactions.seg"sv, "349940e41edb3c9692fbc58690778f3eb321cd33"sv}, Entry{"v1-006200-006300-bodies.idx"sv, "f84c6abcbde985b283f81a6c7b7a9a7929d23bc6"sv}, Entry{"v1-006200-006300-bodies.seg"sv, "77e909010dfa8b632437a9edbefe2bce8380bf86"sv}, Entry{"v1-006200-006300-headers.idx"sv, "85c7b9f19a72cbebd16d24b707a4a73f3e9a8bb9"sv}, Entry{"v1-006200-006300-headers.seg"sv, "ce6205a07fa643329a8587a5e3fe82dc9f1f6526"sv}, Entry{"v1-006200-006300-transactions-to-block.idx"sv, "0c83abbe55d209cb1e1d114d7772d40e484b6395"sv}, Entry{"v1-006200-006300-transactions.idx"sv, "2e3945d1da2f2371fa57c7420318543cee53fc28"sv}, Entry{"v1-006200-006300-transactions.seg"sv, "92797aa73c354fa4b528daba4efe98d2abb5f00b"sv}, Entry{"v1-006300-006400-bodies.idx"sv, "5491bce7d52fd5bca129ae3bca469d05c9d07cda"sv}, Entry{"v1-006300-006400-bodies.seg"sv, "f1ea81a913493591754248dedc3ab7a9e39eb33b"sv}, Entry{"v1-006300-006400-headers.idx"sv, "ba7e27791d14c9599cfb084b47cb97fc9d26fc49"sv}, Entry{"v1-006300-006400-headers.seg"sv, "8e343fdce18e005247de94e0d0d1afabfa7bb07b"sv}, Entry{"v1-006300-006400-transactions-to-block.idx"sv, "3c283f6823e85163127d58c172730c9602076470"sv}, Entry{"v1-006300-006400-transactions.idx"sv, "47dafdfd337c9c4372f6efa1e6b4609174a99598"sv}, Entry{"v1-006300-006400-transactions.seg"sv, "478ae1b27bc76fd03d710ad53fcf57e7439a391a"sv}, Entry{"v1-006400-006500-bodies.idx"sv, "6c6b0f563743847d0159e45d74e14760f4640a33"sv}, Entry{"v1-006400-006500-bodies.seg"sv, "324eb95c95dccdc10f36e48630ce33583c427223"sv}, Entry{"v1-006400-006500-headers.idx"sv, "ba0f183bd7aa12fe8a2cb6368b4a3ffd36881c33"sv}, Entry{"v1-006400-006500-headers.seg"sv, "756b5255533e6cf6eaabf51ee2c373de47ebd528"sv}, Entry{"v1-006400-006500-transactions-to-block.idx"sv, "69ccb6b66f168a1d48ddf8c130850e177f862237"sv}, Entry{"v1-006400-006500-transactions.idx"sv, "d591e93ceacb7d2ec412c038d12b86f8acd99c36"sv}, Entry{"v1-006400-006500-transactions.seg"sv, "8478ef64f421b13e225a7b03ee249e2a79fe19f9"sv}, Entry{"v1-006500-006600-bodies.idx"sv, "a5caf190af5569380e9c5403082a90db8585a986"sv}, Entry{"v1-006500-006600-bodies.seg"sv, "90f4d36d7b690293279c295cdba0b6d6c61e0c2f"sv}, Entry{"v1-006500-006600-headers.idx"sv, "4ee6ba8e2139862add5036083bca6f5855dec016"sv}, Entry{"v1-006500-006600-headers.seg"sv, "79d85676167710c8d15fa6f41e2f72217281ff81"sv}, Entry{"v1-006500-006600-transactions-to-block.idx"sv, "fddc84135cf83c8f5d5819669affa1a38a61b41c"sv}, Entry{"v1-006500-006600-transactions.idx"sv, "1ec858eec47edafa3a5f422473254dd234c6198a"sv}, Entry{"v1-006500-006600-transactions.seg"sv, "b8e85559c2aa6451bb76d83937021383e80d8b17"sv}, Entry{"v1-006600-006700-bodies.idx"sv, "c051a96de51958487aa1b2c5f57a05faf5bd2e9b"sv}, Entry{"v1-006600-006700-bodies.seg"sv, "ca08875678a8bbd2d43016e80b515be58fc1f332"sv}, Entry{"v1-006600-006700-headers.idx"sv, "020821e00cf23b9062a8b5b79fb18c9e3d11f963"sv}, Entry{"v1-006600-006700-headers.seg"sv, "cb2bc3a7c87ee7725b384888841b3d1b9b5eb4a2"sv}, Entry{"v1-006600-006700-transactions-to-block.idx"sv, "40ad3c183307c632eb84e8012392293defabf7a8"sv}, Entry{"v1-006600-006700-transactions.idx"sv, "fbf848fd162dc4ce3a4cdddc80f829dbed74f4c4"sv}, Entry{"v1-006600-006700-transactions.seg"sv, "2fd2b362a3969eb614fd720f4f5b22d96d03b76a"sv}, Entry{"v1-006700-006800-bodies.idx"sv, "c50d88dd2074f82d2d1b505a67287d2c9bfe0ee0"sv}, Entry{"v1-006700-006800-bodies.seg"sv, "985ec76af3e9cc06fa75c5d7c01b95c8d3e12b6c"sv}, Entry{"v1-006700-006800-headers.idx"sv, "3efee50a8ff4ba41246caace4a2d82663ceaea51"sv}, Entry{"v1-006700-006800-headers.seg"sv, "0ff347950039fa7891a64a770e7df873e4ff976d"sv}, Entry{"v1-006700-006800-transactions-to-block.idx"sv, "a9754b519587a7f52719b27ddcc8134450c5249a"sv}, Entry{"v1-006700-006800-transactions.idx"sv, "3e20b458ec6bdfb2b464388379e5b3905966edc4"sv}, Entry{"v1-006700-006800-transactions.seg"sv, "b2405156649f6bbc529741d166fa4b4e12af665f"sv}, Entry{"v1-006800-006900-bodies.idx"sv, "572ec278b8eceef6653674c6d17ce6497455467c"sv}, Entry{"v1-006800-006900-bodies.seg"sv, "b943b7a72d20cdc67b9d7657251da43b0e61588b"sv}, Entry{"v1-006800-006900-headers.idx"sv, "acdfffa1f772d8a24c7d78d17bb928842896852a"sv}, Entry{"v1-006800-006900-headers.seg"sv, "b53a2ae9bd055070cde10a7c2fcc4a05beafe2bd"sv}, Entry{"v1-006800-006900-transactions-to-block.idx"sv, "7d570005d62b6ae3094276d7bd285f0379444837"sv}, Entry{"v1-006800-006900-transactions.idx"sv, "85d92a68f91b1c655f48c173b340ea046975f2ea"sv}, Entry{"v1-006800-006900-transactions.seg"sv, "dfd273dfcf893c2e57ee11337d3fc563112fa65e"sv}, Entry{"v1-006900-006910-bodies.idx"sv, "da85a8442a78eb339e30b0e3b89a54be65eca3cd"sv}, Entry{"v1-006900-006910-bodies.seg"sv, "09ccdb6985e94248cbd41d77cc22165b970ea86f"sv}, Entry{"v1-006900-006910-headers.idx"sv, "ada385b40968203f177f0f50161944cab52d953a"sv}, Entry{"v1-006900-006910-headers.seg"sv, "99e2007c8c857f262ed89a7e5d4e62aa98c56b6c"sv}, Entry{"v1-006900-006910-transactions-to-block.idx"sv, "59c7627968cd3167336c66c91f4cad2d49d47b3c"sv}, Entry{"v1-006900-006910-transactions.idx"sv, "fc4147bd9b0f04b8073761a3e8fc5ff8fe28ab70"sv}, Entry{"v1-006900-006910-transactions.seg"sv, "800afc79802033ff29d33d66a1f53f1ebc69f3b7"sv}, Entry{"v1-006910-006911-bodies.idx"sv, "442f3679da40e4321344a62e47bcbeefea82e2d1"sv}, Entry{"v1-006910-006911-bodies.seg"sv, "f1dd5ed12064803664bf22cb556a522eec36e03a"sv}, Entry{"v1-006910-006911-headers.idx"sv, "13f6b00a3125a0cf62213f4bf9d5a080c57b61fb"sv}, Entry{"v1-006910-006911-headers.seg"sv, "1cf84303bf8914c3077fc06edc3fd7b5f862162a"sv}, Entry{"v1-006910-006911-transactions-to-block.idx"sv, "1d22ca065b56811fd9fa260e6779532f78783c0d"sv}, Entry{"v1-006910-006911-transactions.idx"sv, "118e2dfd6ba5d5a5b802afb2a05eadeb25ef6068"sv}, Entry{"v1-006910-006911-transactions.seg"sv, "e3c37d2fa8ce17f50a1ecda9c06fe1925deb9ce3"sv}, Entry{"v1-006911-006912-bodies.idx"sv, "84042f2aa6119fd5a3b26b2636b76562f726d8d1"sv}, Entry{"v1-006911-006912-bodies.seg"sv, "dce00b79a5b9cb77f358a04dc5fba01c1c146593"sv}, Entry{"v1-006911-006912-headers.idx"sv, "9dafaaf8316fe0b1534def0fd1524f8fe2e4ae2c"sv}, Entry{"v1-006911-006912-headers.seg"sv, "69442533e1ae9ad61ab6aab804640844772c684b"sv}, Entry{"v1-006911-006912-transactions-to-block.idx"sv, "a5e5b00c4a2839af91bf68d6c7e410e48f850c72"sv}, Entry{"v1-006911-006912-transactions.idx"sv, "c33f6228a4c237ee8e2d0a567d46de1829e97c7e"sv}, Entry{"v1-006911-006912-transactions.seg"sv, "11637717e1b5d06e58a48bf8113a1ef83ce42b55"sv}, Entry{"v1-006912-006913-bodies.idx"sv, "f258b6daffdb4f5627e643d88df3e06c793db5aa"sv}, Entry{"v1-006912-006913-bodies.seg"sv, "d1ef71b6e5088438b86be51bed5254bedf377de3"sv}, Entry{"v1-006912-006913-headers.idx"sv, "5d019333b019dec7302031af9ef487681c40903d"sv}, Entry{"v1-006912-006913-headers.seg"sv, "712ce8d01bc24e562dce89e57dd7c4d2d97bed79"sv}, Entry{"v1-006912-006913-transactions-to-block.idx"sv, "9acfae0a91ea2355db5c740a239c2dec9c3767b8"sv}, Entry{"v1-006912-006913-transactions.idx"sv, "070bf21079908d56213963220fb4a6935bc3ede9"sv}, Entry{"v1-006912-006913-transactions.seg"sv, "2b4e208320b308c688548e85d67367b4e2689c8c"sv}, Entry{"v1-006913-006914-bodies.idx"sv, "4d3fae3f0c76cb49d3fc2f2788526d6ca2819252"sv}, Entry{"v1-006913-006914-bodies.seg"sv, "1923af9fec6288b35104a6da4f87b4e3bf9f1bc1"sv}, Entry{"v1-006913-006914-headers.idx"sv, "efedc6860cc084a8e0514e244dfb841f8b1b3418"sv}, Entry{"v1-006913-006914-headers.seg"sv, "7a127bd45a1dde9cdd562d55c656c69e3b1b549e"sv}, Entry{"v1-006913-006914-transactions-to-block.idx"sv, "1eaf88db4471b184751160f1daef939eb66ef83b"sv}, Entry{"v1-006913-006914-transactions.idx"sv, "903db37fbfb9d2d7447c7a8edea6702228a4ddb7"sv}, Entry{"v1-006913-006914-transactions.seg"sv, "d20b217f9c259be75701ae122cbf952301f363c4"sv}, Entry{"v1-006914-006915-bodies.idx"sv, "0943e6e2655f155791059eec2abeccce764b24f2"sv}, Entry{"v1-006914-006915-bodies.seg"sv, "69c8fa656ab974997f4c424517dfff5fcbbb3973"sv}, Entry{"v1-006914-006915-headers.idx"sv, "1fc51d46c3cfb7285c2fcd233dfc7a223b4b8411"sv}, Entry{"v1-006914-006915-headers.seg"sv, "c91d4e3bdc14fe488fbf0f6692a0af194c2bef85"sv}, Entry{"v1-006914-006915-transactions-to-block.idx"sv, "150167720e4264665c8551063833486b59010743"sv}, Entry{"v1-006914-006915-transactions.idx"sv, "639762cf258869afe88482f0c39e9f3fd5a8471b"sv}, Entry{"v1-006914-006915-transactions.seg"sv, "42b6ad71ee2af8462d5550bb945ed6564df06936"sv}, }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/config.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "config.hpp" #include #include #include #include "chains/amoy.hpp" #include "chains/bor_mainnet.hpp" #include "chains/holesky.hpp" #include "chains/mainnet.hpp" #include "chains/sepolia.hpp" namespace silkworm::snapshots { inline constexpr SmallMap> kKnownConfigGeneratedEntries{ {*kKnownChainNameToId.find("mainnet"), {kMainnetSnapshots.data(), kMainnetSnapshots.size()}}, {*kKnownChainNameToId.find("sepolia"), {kSepoliaSnapshots.data(), kSepoliaSnapshots.size()}}, {*kKnownChainNameToId.find("holesky"), {kHoleskySnapshots.data(), kHoleskySnapshots.size()}}, {*kKnownChainNameToId.find("bor-mainnet"), {kBorMainnetSnapshots.data(), kBorMainnetSnapshots.size()}}, {*kKnownChainNameToId.find("amoy"), {kAmoySnapshots.data(), kAmoySnapshots.size()}}, }; Config Config::lookup_known_config( ChainId chain_id, std::optional> include_filter_opt) { const auto entries_ptr = kKnownConfigGeneratedEntries.find(chain_id); if (!entries_ptr) { return Config{PreverifiedList{}}; } PreverifiedList entries(entries_ptr->begin(), entries_ptr->end()); entries = remove_unsupported_entries(entries); if (include_filter_opt) { auto& include_filter = *include_filter_opt; std::erase_if(entries, [&](const Entry& entry) { return !include_filter(entry.file_name); }); } return Config{std::move(entries)}; } PreverifiedList Config::remove_unsupported_entries(const PreverifiedList& entries) { static constexpr std::array kUnsupportedSnapshotNameTokens = { "/"sv, ".txt"sv, "beaconblocks"sv, "blobsidecars"sv, }; PreverifiedList results = entries; // erase file names containing any of the unsupported tokens std::erase_if(results, [&](const Entry& entry) { return std::ranges::any_of(kUnsupportedSnapshotNameTokens, [&entry](std::string_view token) { // NOLINTNEXTLINE(abseil-string-find-str-contains) return entry.file_name.find(token) != std::string_view::npos; }); }); return results; } PreverifiedListOfPairs Config::preverified_snapshots_as_pairs() const { PreverifiedListOfPairs entries; for (const Entry& entry : entries_) { entries.emplace_back(entry.file_name, entry.torrent_hash); } return entries; } bool Config::contains_file_name(std::string_view file_name) const { return std::ranges::any_of(entries_, [&](const Entry& entry) { return entry.file_name == file_name; }); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/config.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "entry.hpp" namespace silkworm::snapshots { using PreverifiedList = std::vector; using PreverifiedListOfPairs = std::vector>; class Config { public: static Config lookup_known_config( ChainId chain_id, std::optional> include_filter_opt = std::nullopt); explicit Config(PreverifiedList entries) : entries_(std::move(entries)) {} const PreverifiedList& preverified_snapshots() const { return entries_; } PreverifiedListOfPairs preverified_snapshots_as_pairs() const; bool contains_file_name(std::string_view file_name) const; private: static PreverifiedList remove_unsupported_entries(const PreverifiedList& entries); PreverifiedList entries_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/config_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "config.hpp" #include #include namespace silkworm::snapshots { TEST_CASE("Config::lookup_known_config", "[silkworm][snapshot][config]") { SECTION("nonexistent") { const auto cfg = Config::lookup_known_config(0); CHECK(cfg.preverified_snapshots().empty()); } SECTION("mainnet") { const auto cfg = Config::lookup_known_config(1); CHECK_FALSE(cfg.preverified_snapshots().empty()); } } TEST_CASE("Config", "[silkworm][snapshot][config]") { SECTION("empty") { Config cfg{{}}; CHECK(cfg.preverified_snapshots().empty()); } SECTION("non-empty") { PreverifiedList preverified{ {"v1-000000-000500-bodies.seg", "e9b5c5d1885ee3c6ab6005919e511e1e04c7e34e"}, {"v1-000000-000500-headers.seg", "df09957d8a28af3bc5137478885a8003677ca878"}, {"v1-000000-000500-transactions.seg", "92bb09068baa8eab9d5ad5e69c1eecd404a82258"}, {"v1-014000-014500-bodies.seg", "70a8b050d1a4abd8424cb8c94d22fff6e58b3fd9"}, {"v1-014000-014500-headers.seg", "fa45e222c6a01f6090d968cf93d105947dab72cd"}, {"v1-014000-014500-transactions.seg", "ee3c18488a1d74969c5e75b16f5adceac5dbcd15"}, }; Config cfg{preverified}; CHECK(cfg.preverified_snapshots().size() == preverified.size()); } } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/config/entry.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::snapshots { struct Entry { std::string_view file_name; std::string_view torrent_hash; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/domain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "bloom_filter/bloom_filter.hpp" #include "btree/btree_index.hpp" #include "rec_split/accessor_index.hpp" #include "segment/kv_segment_reader.hpp" namespace silkworm::snapshots { struct Domain { const segment::KVSegmentFileReader& kv_segment; const rec_split::AccessorIndex* accessor_index{nullptr}; const bloom_filter::BloomFilter& existence_index; const btree::BTreeIndex& btree_index; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/domain_get_latest_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/step.hpp" #include "common/codec.hpp" #include "common/raw_codec.hpp" #include "domain.hpp" #include "query_cache.hpp" #include "query_caches.hpp" #include "segment/kv_segment_reader.hpp" #include "snapshot_bundle.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { template struct DomainGetLatestSegmentQuery { explicit DomainGetLatestSegmentQuery(Domain entity) : entity_{std::move(entity)} {} DomainGetLatestSegmentQuery( const SnapshotBundle& bundle, datastore::EntityName entity_name) : DomainGetLatestSegmentQuery(bundle.domain(entity_name)) {} using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueDecoder::value); using Word = typename TValueDecoder::Word; std::optional exec(const Key& key) { TKeyEncoder key_encoder; key_encoder.value = key; ByteView key_data = key_encoder.encode_word(); std::optional value_data = exec_raw(key_data); if (!value_data) { return std::nullopt; } TValueDecoder value_decoder; value_decoder.decode_word(*value_data); return std::move(value_decoder.value); } std::optional exec_raw(const ByteView key) { if (!entity_.existence_index.contains(key)) { return std::nullopt; } return entity_.btree_index.get(key, entity_.kv_segment); } private: Domain entity_; }; struct DomainGetLatestQueryRawNoCache { const SnapshotRepositoryROAccess& repository; datastore::EntityName entity_name; struct Result { Decoder::Word value; datastore::Step step{0}; }; std::optional exec(ByteView key_data) { for (auto& bundle_ptr : repository.view_bundles_reverse()) { const SnapshotBundle& bundle = *bundle_ptr; DomainGetLatestSegmentQuery, RawDecoder> query{bundle, entity_name}; std::optional value_data = query.exec_raw(key_data); if (value_data) { return Result{std::move(*value_data), bundle.step_range().end}; } } return std::nullopt; } }; struct DomainGetLatestQueryRawWithCache { using Result = DomainGetLatestQueryRawNoCache::Result; using CacheType = QueryCache>; static inline const datastore::EntityName kName{"DomainGetLatestQueryRawWithCache"}; DomainGetLatestQueryRawWithCache( const SnapshotRepositoryROAccess& repository, const QueryCaches& query_caches, datastore::EntityName entity_name) : query_{repository, entity_name}, cache_{query_caches.cache(kName, entity_name).get()} {} std::optional exec(ByteView key_data) { if (!cache_) { return query_.exec(key_data); } std::optional> cached_result; uint64_t cache_key{0}; std::tie(cached_result, cache_key) = cache_->get(key_data); if (cached_result) { return std::move(*cached_result); } std::optional result = query_.exec(key_data); cache_->put(cache_key, result); return result; } private: DomainGetLatestQueryRawNoCache query_; CacheType* cache_; }; template struct DomainGetLatestQuery { DomainGetLatestQuery( const SnapshotRepositoryROAccess& repository, const QueryCaches& query_caches, datastore::EntityName entity_name) : query_{repository, query_caches, entity_name} {} using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueDecoder::value); struct Result { Value value; datastore::Step step{0}; }; std::optional exec(const Key& key) { TKeyEncoder key_encoder; key_encoder.value = key; ByteView key_data = key_encoder.encode_word(); auto value_data = query_.exec(key_data); if (!value_data) return std::nullopt; TValueDecoder value_decoder; value_decoder.decode_word(value_data->value); return Result{std::move(value_decoder.value), value_data->step}; } private: DomainGetLatestQueryRawWithCache query_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/domain_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "domain_get_latest_query.hpp" #include "domain_range_latest_query.hpp" ================================================ FILE: silkworm/db/datastore/snapshots/domain_range_latest_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "../common/entity_name.hpp" #include "../common/pair_get.hpp" #include "../common/ranges/caching_view.hpp" #include "../common/ranges/lazy_view.hpp" #include "../common/ranges/merge_many_view.hpp" #include "../common/ranges/owning_view.hpp" #include "common/codec.hpp" #include "domain.hpp" #include "snapshot_bundle.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { struct DomainRangeLatestSegmentQuery { explicit DomainRangeLatestSegmentQuery(Domain entity) : entity_{std::move(entity)} {} explicit DomainRangeLatestSegmentQuery( const SnapshotBundle& bundle, datastore::EntityName entity_name) : entity_{bundle.domain(entity_name)} {} using ResultItem = btree::BTreeIndex::Cursor::value_type; auto exec_with_eager_begin(Bytes key_start, Bytes key_end, bool ascending) { // NOLINT(*-unnecessary-value-param) SILKWORM_ASSERT(ascending); // descending is not implemented auto begin_it = entity_.btree_index.seek(key_start, entity_.kv_segment).value_or(btree::BTreeIndex::Cursor{}); return std::ranges::subrange{std::move(begin_it), std::default_sentinel} | std::views::take_while([key_end = std::move(key_end)](const auto& kv_pair) { return key_end.empty() || ByteView{kv_pair.first} < key_end; }); } auto exec(Bytes key_start, Bytes key_end, bool ascending) { auto exec_func = [query = *this, key_start = std::move(key_start), key_end = std::move(key_end), ascending]() mutable { return query.exec_with_eager_begin(std::move(key_start), std::move(key_end), ascending); }; return silkworm::ranges::lazy(std::move(exec_func)); } private: Domain entity_; }; template < EncoderConcept TKeyEncoder, DecoderConcept TKeyDecoder, DecoderConcept TValueDecoder> struct DomainRangeLatestQuery { const SnapshotRepositoryROAccess& repository; datastore::EntityName entity_name; using Key = decltype(TKeyEncoder::value); using ResultItemKey = decltype(TKeyDecoder::value); using ResultItemValue = decltype(TValueDecoder::value); using ResultItem = std::pair; using Word = Decoder::Word; static ResultItem decode_kv_pair(std::pair&& kv_pair) { if constexpr (std::same_as>) { return std::move(kv_pair); } TKeyDecoder key_decoder; key_decoder.decode_word(kv_pair.first); ResultItemKey& key = key_decoder.value; TValueDecoder value_decoder; value_decoder.decode_word(kv_pair.second); ResultItemValue& value = value_decoder.value; return ResultItem{std::move(key), std::move(value)}; } static constexpr auto kDecodeKVPairFunc = [](std::pair& kv_pair) -> ResultItem { return decode_kv_pair(std::move(kv_pair)); }; auto exec(const Key& key_start, const Key& key_end, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented TKeyEncoder key_start_encoder; key_start_encoder.value = key_start; ByteView key_start_data = key_start_encoder.encode_word(); TKeyEncoder key_end_encoder; key_end_encoder.value = key_end; ByteView key_end_data = key_end_encoder.encode_word(); auto results_in_bundle = [entity_name1 = this->entity_name, key_start_data = Bytes{key_start_data}, key_end_data = Bytes{key_end_data}, ascending](const std::shared_ptr& bundle_ptr) { const SnapshotBundle& bundle = *bundle_ptr; DomainRangeLatestSegmentQuery query{bundle, entity_name1}; return query.exec(key_start_data, key_end_data, ascending); }; auto bundle_results = silkworm::ranges::owning_view(repository.view_bundles_reverse()) | std::views::transform(std::move(results_in_bundle)); auto results = silkworm::views::merge_unique_many( std::move(bundle_results), silkworm::views::MergeCompareFunc{}, PairGetFirst{}); return silkworm::ranges::owning_view(std::move(results)) | std::views::filter([](const auto& kv_pair) { return !ByteView{kv_pair.second}.empty(); }) | std::views::transform(kDecodeKVPairFunc) | silkworm::views::caching; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/README.md ================================================ Elias-Fano encoding is a high bits / low bits representation of a monotonically increasing sequence of N > 0 natural numbers x[i] 0 <= x[0] <= x[1] <= ... <= x[N-2] <= x[N-1] <= U where U > 0 is an upper bound on the last value. EliasFano algorithm overview https://www.antoniomallia.it/sorted-integers-compression-with-elias-fano-encoding.html P. Elias. Efficient storage and retrieval by content and address of static files. J. ACM, 21(2):246–260, 1974. Partitioned Elias-Fano Indexes http://groups.di.unipi.it/~ottavian/files/elias_fano_sigir14.pdf ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/double_elias_fano_list.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #include "double_elias_fano_list.hpp" #include #include #include #include #include #include "../common/encoding/util.hpp" #include "elias_fano_common.hpp" namespace silkworm::snapshots::elias_fano { void DoubleEliasFanoList16::build(const Uint64Sequence& cum_keys, const Uint64Sequence& position) { SILKWORM_ASSERT(cum_keys.size() == position.size()); num_buckets_ = cum_keys.size() - 1; position_min_delta_ = std::numeric_limits::max(); cum_keys_min_delta_ = std::numeric_limits::max(); for (size_t i{1}; i <= num_buckets_; ++i) { SILKWORM_ASSERT(cum_keys[i] >= cum_keys[i - 1]); SILKWORM_ASSERT(position[i] >= position[i - 1]); const uint64_t n_keys_delta = cum_keys[i] - cum_keys[i - 1]; cum_keys_min_delta_ = std::min(cum_keys_min_delta_, n_keys_delta); const uint64_t bucket_bits = position[i] - position[i - 1]; position_min_delta_ = std::min(position_min_delta_, bucket_bits); } u_position_ = position[num_buckets_] - num_buckets_ * position_min_delta_ + 1; // Largest possible encoding of the cumulated positions u_cum_keys_ = cum_keys[num_buckets_] - num_buckets_ * cum_keys_min_delta_ + 1; // Largest possible encoding of the cumulated keys const auto [words_cum_keys, words_position] = derive_fields(); for (uint64_t i{0}, cum_delta{0}, bit_delta{0}; i <= num_buckets_; ++i, cum_delta += cum_keys_min_delta_, bit_delta += position_min_delta_) { if (l_cum_keys_ != 0) { set_bits(lower_bits_, i * (l_cum_keys_ + l_position_), l_cum_keys_, (cum_keys[i] - cum_delta) & lower_bits_mask_cum_keys_); } set(upper_bits_cum_keys_, ((cum_keys[i] - cum_delta) >> l_cum_keys_) + i); if (l_position_ != 0) { set_bits(lower_bits_, i * (l_cum_keys_ + l_position_) + l_cum_keys_, l_position_, (position[i] - bit_delta) & lower_bits_mask_position_); } set(upper_bits_position_, ((position[i] - bit_delta) >> l_position_) + i); } // iterate over the 64-bit words in the cumulative keys vector, c iterates over bits in the cumulative keys' words // last_super_q is the largest multiple of 2^14 (4096) which is no larger than c // (c / kSuperQ) is the index of the current 4096 block of bits // super_q_size is how many words is required to encode one block of 4096 bits. It is 17 words which is 1088 bits for (uint64_t i{0}, c{0}, last_super_q{0}; i < words_cum_keys; ++i) { for (uint64_t b{0}; b < 64; ++b) { if (upper_bits_cum_keys_[i] & uint64_t{1} << b) { if ((c & kSuperQMask) == 0) { /* When c is multiple of 2^14 (4096) */ jump_[(c / kSuperQ) * (kSuperQSize16 * 2)] = last_super_q = i * 64 + b; } if ((c & kQMask) == 0) { /* When c is multiple of 2^8 (256) */ // offset can be either 0, 256, 512, ..., up to 4096-256 const uint64_t offset = i * 64 + b - last_super_q; // offset needs to be encoded as 16-bit integer, therefore the following check SILKWORM_ASSERT(offset < (1 << 16)); // c % superQ is the bit index inside the group of 4096 bits const uint64_t jump_super_q = (c / kSuperQ) * (kSuperQSize16 * 2); const uint64_t jump_inside_super_q = 2 * (c % kSuperQ) / kQ; const uint64_t idx64 = jump_super_q + 2 + (jump_inside_super_q >> 2); const uint64_t shift = 16 * (jump_inside_super_q % 4); const uint64_t mask = uint64_t{0xffff} << shift; jump_[idx64] = (jump_[idx64] & ~mask) | (offset << shift); } ++c; } } } for (uint64_t i{0}, c{0}, last_super_q{0}; i < words_position; ++i) { for (uint64_t b = 0; b < 64; ++b) { if (upper_bits_position_[i] & uint64_t{1} << b) { if ((c & kSuperQMask) == 0) { jump_[(c / kSuperQ) * (kSuperQSize16 * 2) + 1] = last_super_q = i * 64 + b; } if ((c & kQMask) == 0) { const uint64_t offset = i * 64 + b - last_super_q; SILKWORM_ASSERT(offset < (1 << 16)); const uint64_t jump_super_q = (c / kSuperQ) * (kSuperQSize16 * 2); const uint64_t jump_inside_super_q = 2 * (c % kSuperQ) / kQ + 1; const uint64_t idx64 = jump_super_q + 2 + (jump_inside_super_q >> 2); const uint64_t shift = 16 * (jump_inside_super_q % 4); const uint64_t mask = uint64_t{0xffff} << shift; jump_[idx64] = (jump_[idx64] & ~mask) | (offset << shift); } ++c; } } } } void DoubleEliasFanoList16::get2(const uint64_t i, uint64_t& cum_keys, uint64_t& position) const { uint64_t window_cum_keys{0}, select_cum_keys{0}, curr_word_cum_keys{0}, lower{0}, cum_delta{0}; get(i, cum_keys, position, window_cum_keys, select_cum_keys, curr_word_cum_keys, lower, cum_delta); } void DoubleEliasFanoList16::get3(const uint64_t i, uint64_t& cum_keys, uint64_t& cum_keys_next, uint64_t& position) const { uint64_t window_cum_keys{0}, select_cum_keys{0}, curr_word_cum_keys{0}, lower{0}, cum_delta{0}; get(i, cum_keys, position, window_cum_keys, select_cum_keys, curr_word_cum_keys, lower, cum_delta); window_cum_keys &= (uint64_t{0xffffffffffffffff} << select_cum_keys) << 1; while (window_cum_keys == 0) { ++curr_word_cum_keys; window_cum_keys = upper_bits_cum_keys_[curr_word_cum_keys]; } lower >>= l_position_; cum_keys_next = ((curr_word_cum_keys * 64 + static_cast(encoding::rho(window_cum_keys)) - i - 1) << l_cum_keys_ | (lower & lower_bits_mask_cum_keys_)) + cum_delta + cum_keys_min_delta_; } std::pair DoubleEliasFanoList16::derive_fields() { l_position_ = u_position_ / (num_buckets_ + 1) == 0 ? 0 : 63 ^ static_cast(std::countl_zero(u_position_ / (num_buckets_ + 1))); l_cum_keys_ = u_cum_keys_ / (num_buckets_ + 1) == 0 ? 0 : 63 ^ static_cast(std::countl_zero(u_cum_keys_ / (num_buckets_ + 1))); SILKWORM_ASSERT(l_cum_keys_ * 2 + l_position_ <= 56); lower_bits_mask_cum_keys_ = (1UL << l_cum_keys_) - 1; lower_bits_mask_position_ = (1UL << l_position_) - 1; const uint64_t words_lower_bits = lower_bits_size_words(); const uint64_t words_cum_keys = cum_keys_size_words(); const uint64_t words_position = position_size_words(); const uint64_t jump_words = jump_size_words(); const uint64_t total_words = words_lower_bits + words_cum_keys + words_position + jump_words; data_.resize(total_words); auto first = data_.data(); lower_bits_ = std::span{first, first + words_lower_bits}; first += words_lower_bits; upper_bits_cum_keys_ = std::span{first, first + words_cum_keys}; first += words_cum_keys; upper_bits_position_ = std::span{first, first + words_position}; first += words_position; jump_ = std::span{first, first + jump_words}; return {words_cum_keys, words_position}; } void DoubleEliasFanoList16::get( const uint64_t i, uint64_t& cum_keys, uint64_t& position, uint64_t& window_cum_keys, uint64_t& select_cum_keys, uint64_t& curr_word_cum_keys, uint64_t& lower, uint64_t& cum_delta) const { const uint64_t pos_lower = i * (l_cum_keys_ + l_position_); uint64_t idx64 = pos_lower / 64; uint64_t shift = pos_lower % 64; lower = lower_bits_[idx64] >> shift; if (shift > 0) { lower |= lower_bits_[idx64 + 1] << (64 - shift); } const uint64_t jump_super_q = (i / kSuperQ) * kSuperQSize16 * 2; const uint64_t jump_inside_super_q = (i % kSuperQ) / kQ; uint64_t idx16 = 4 * (jump_super_q + 2) + 2 * jump_inside_super_q; idx64 = idx16 / 4; shift = 16 * (idx16 % 4); uint64_t mask = uint64_t{0xffff} << shift; const uint64_t jump_cum_keys = jump_[jump_super_q] + ((jump_[idx64] & mask) >> shift); ++idx16; idx64 = idx16 / 4; shift = 16 * (idx16 % 4); mask = uint64_t{0xffff} << shift; const uint64_t jump_position = jump_[jump_super_q + 1] + ((jump_[idx64] & mask) >> shift); curr_word_cum_keys = jump_cum_keys / 64; uint64_t curr_word_position = jump_position / 64; window_cum_keys = upper_bits_cum_keys_[curr_word_cum_keys] & (uint64_t{0xffffffffffffffff} << (jump_cum_keys % 64)); uint64_t window_position = upper_bits_position_[curr_word_position] & (uint64_t{0xffffffffffffffff} << (jump_position % 64)); uint64_t delta_cum_keys = i & kQMask; uint64_t delta_position = i & kQMask; for (auto bit_count{std::popcount(window_cum_keys)}; static_cast(bit_count) <= delta_cum_keys; bit_count = std::popcount(window_cum_keys)) { ++curr_word_cum_keys; window_cum_keys = upper_bits_cum_keys_[curr_word_cum_keys]; delta_cum_keys -= static_cast(bit_count); } for (auto bit_count{std::popcount(window_position)}; static_cast(bit_count) <= delta_position; bit_count = std::popcount(window_position)) { ++curr_word_position; window_position = upper_bits_position_[curr_word_position]; delta_position -= static_cast(bit_count); } select_cum_keys = encoding::select64(window_cum_keys, delta_cum_keys); cum_delta = i * cum_keys_min_delta_; cum_keys = ((curr_word_cum_keys * 64 + select_cum_keys - i) << l_cum_keys_ | (lower & lower_bits_mask_cum_keys_)) + cum_delta; lower >>= l_cum_keys_; const uint64_t select_position = encoding::select64(window_position, delta_position); const uint64_t bit_delta = i * position_min_delta_; position = ((curr_word_position * 64 + select_position - i) << l_position_ | (lower & lower_bits_mask_position_)) + bit_delta; } size_t DoubleEliasFanoList16::jump_size_words() const { // Compute whole blocks size_t size = ((num_buckets_ + 1) / kSuperQ) * kSuperQSize16 * 2; // Compute partial block (if any) if ((num_buckets_ + 1) % kSuperQ != 0) { size += (1 + (((num_buckets_ + 1) % kSuperQ + kQ - 1) / kQ + 3) / 4) * 2; } return size; } std::ostream& operator<<(std::ostream& os, const DoubleEliasFanoList16& ef) { Bytes uint64_buffer(8, '\0'); endian::store_big_u64(uint64_buffer.data(), ef.num_buckets_); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); endian::store_big_u64(uint64_buffer.data(), ef.u_cum_keys_); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); endian::store_big_u64(uint64_buffer.data(), ef.u_position_); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); endian::store_big_u64(uint64_buffer.data(), ef.cum_keys_min_delta_); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); endian::store_big_u64(uint64_buffer.data(), ef.position_min_delta_); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); // Erigon does not write data size here os.write(reinterpret_cast(ef.data_.data()), static_cast(ef.data_.size() * sizeof(uint64_t))); return os; } std::istream& operator>>(std::istream& is, DoubleEliasFanoList16& ef) { Bytes uint64_buffer(8, '\0'); is.read(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); ef.num_buckets_ = endian::load_big_u64(uint64_buffer.data()); is.read(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); ef.u_cum_keys_ = endian::load_big_u64(uint64_buffer.data()); is.read(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); ef.u_position_ = endian::load_big_u64(uint64_buffer.data()); is.read(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); ef.cum_keys_min_delta_ = endian::load_big_u64(uint64_buffer.data()); is.read(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); ef.position_min_delta_ = endian::load_big_u64(uint64_buffer.data()); ef.l_position_ = ef.u_position_ / (ef.num_buckets_ + 1) == 0 ? 0 : static_cast(encoding::lambda(ef.u_position_ / (ef.num_buckets_ + 1))); ef.l_cum_keys_ = ef.u_cum_keys_ / (ef.num_buckets_ + 1) == 0 ? 0 : static_cast(encoding::lambda(ef.u_cum_keys_ / (ef.num_buckets_ + 1))); SILKWORM_ASSERT(ef.l_cum_keys_ * 2 + ef.l_position_ <= 56); ef.lower_bits_mask_cum_keys_ = (1UL << ef.l_cum_keys_) - 1; ef.lower_bits_mask_position_ = (1UL << ef.l_position_) - 1; // Erigon assumes that data fills up the stream until the end size_t read_count{0}; while (!is.eof()) { ef.data_.resize(read_count + 1); is.read(reinterpret_cast(ef.data_.data() + read_count), sizeof(uint64_t)); ++read_count; } if (!ef.data_.empty()) { ef.data_.pop_back(); } ef.derive_fields(); return is; } } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/double_elias_fano_list.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #include #include #include #include #include "../common/encoding/sequence.hpp" namespace silkworm::snapshots::elias_fano { //! 16-bit Double Elias-Fano list that used to encode *two* monotone non-decreasing sequences in RecSplit class DoubleEliasFanoList16 { public: using Uint64Sequence = encoding::Uint64Sequence; DoubleEliasFanoList16() = default; const Uint64Sequence& data() const { return data_; } uint64_t num_buckets() const { return num_buckets_; } void build(const Uint64Sequence& cum_keys, const Uint64Sequence& position); void get2(uint64_t i, uint64_t& cum_keys, uint64_t& position) const; void get3(uint64_t i, uint64_t& cum_keys, uint64_t& cum_keys_next, uint64_t& position) const; private: std::pair derive_fields(); void get( uint64_t i, uint64_t& cum_keys, uint64_t& position, uint64_t& window_cum_keys, uint64_t& select_cum_keys, uint64_t& curr_word_cum_keys, uint64_t& lower, uint64_t& cum_delta) const; Uint64Sequence data_; std::span lower_bits_; std::span upper_bits_position_; std::span upper_bits_cum_keys_; std::span jump_; uint64_t lower_bits_mask_cum_keys_{0}; uint64_t lower_bits_mask_position_{0}; //! Number of buckets uint64_t num_buckets_{0}; uint64_t u_cum_keys_{0}, u_position_{0}; uint64_t l_position_{0}, l_cum_keys_{0}; //! Minimum delta between successive cumulative keys uint64_t cum_keys_min_delta_{0}; //! Minimum delta between successive positions uint64_t position_min_delta_{0}; size_t lower_bits_size_words() const { return ((num_buckets_ + 1) * (l_cum_keys_ + l_position_) + 63) / 64 + 1; } size_t cum_keys_size_words() const { return (num_buckets_ + 1 + (u_cum_keys_ >> l_cum_keys_) + 63) / 64; } size_t position_size_words() const { return (num_buckets_ + 1 + (u_position_ >> l_position_) + 63) / 64; } size_t jump_size_words() const; friend std::ostream& operator<<(std::ostream& os, const DoubleEliasFanoList16& ef); friend std::istream& operator>>(std::istream& is, DoubleEliasFanoList16& ef); }; } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/double_elias_fano_list_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "double_elias_fano_list.hpp" #include #include #include #include #include namespace silkworm::snapshots::elias_fano { using silkworm::snapshots::encoding::Uint64Sequence; TEST_CASE("DoubleEliasFanoList16", "[silkworm][recsplit][elias_fano]") { DoubleEliasFanoList16 double_ef_list; std::vector cum_keys{1, 1, 2, 6, 7, 11, 13, 20}; std::vector position{1, 2, 5, 5, 6, 7, 9, 9}; double_ef_list.build(cum_keys, position); CHECK(double_ef_list.num_buckets() == cum_keys.size() - 1); for (uint64_t i{0}; i < double_ef_list.num_buckets(); ++i) { uint64_t x{0}, x2{0}, y{0}; double_ef_list.get3(i, x, x2, y); CHECK(x == cum_keys[i]); CHECK(x2 == cum_keys[i + 1]); CHECK(y == position[i]); double_ef_list.get2(i, x, y); CHECK(x == cum_keys[i]); CHECK(y == position[i]); } CHECK(double_ef_list.data() == Uint64Sequence{0x73, 0x0, 0x214cb, 0x1958a, 0x0, 0x1, 0x0, 0x0}); std::stringstream str_stream; str_stream << double_ef_list; const std::string stream = str_stream.str(); CHECK(Bytes{stream.cbegin(), stream.cend()} == *from_hex("0000000000000007" // num_buckets "0000000000000015" // u_cum_keys "000000000000000a" // u_position "0000000000000000" // cum_keys_min_delta "0000000000000000" // position_min_delta "73000000000000000000000000000000cb140200000000008a95010000000000" "0000000000000000010000000000000000000000000000000000000000000000")); } } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/elias_fano_common.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #include #include namespace silkworm::snapshots::elias_fano { //! Log2Q = Log2(Quantum) inline constexpr uint64_t kLog2q = 8; //! Q = Quantum inline constexpr uint64_t kQ = 1 << kLog2q; // 256 //! QMask = Quantum Mask inline constexpr uint64_t kQMask = kQ - 1; //! SuperQ = Super Quantum inline constexpr uint64_t kSuperQ = 1 << 14; // 16384 //! SuperQMask = SuperQuantum Mask inline constexpr uint64_t kSuperQMask = kSuperQ - 1; inline constexpr uint64_t kQPerSuperQ = kSuperQ / kQ; inline constexpr uint64_t kSuperQSize16 = 1 + kQPerSuperQ / 4; inline constexpr uint64_t kSuperQSize32 = 1 + kQPerSuperQ / 2; template static void set(std::span bits, const uint64_t pos) { bits[pos / 64] |= uint64_t{1} << (pos % 64); } //! This assumes that bits are set in monotonic order, so that we can skip the masking for the second word template static void set_bits(std::span bits, const uint64_t start, const uint64_t width, const uint64_t value) { const uint64_t shift = start & 63; const uint64_t mask = ((uint64_t{1} << width) - 1) << shift; const size_t idx64 = start >> 6; bits[idx64] = (bits[idx64] & ~mask) | (value << shift); if (shift + width > 64) { // Change two 64-bit words bits[idx64 + 1] = value >> (64 - shift); } } using silkworm::snapshots::encoding::Uint64Sequence; } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/elias_fano_list.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #include "elias_fano_list.hpp" #include #include #include #include #include #include #include "../common/encoding/util.hpp" #include "../common/util/iterator/index_range.hpp" #include "elias_fano_common.hpp" namespace silkworm::snapshots::elias_fano { EliasFanoList32 EliasFanoList32::from_encoded_data(BytesOrByteView encoded_data_holder) { std::span encoded_data{ByteView{encoded_data_holder}}; const uint64_t data_offset = kCountLength + kULength; ensure(encoded_data.size() >= data_offset, "EliasFanoList32::from_encoded_data data too short"); const uint64_t last = endian::load_big_u64(encoded_data.data()); const uint64_t u = endian::load_big_u64(encoded_data.subspan(kCountLength).data()); return EliasFanoList32{last + 1, u - 1, data_offset, std::move(encoded_data_holder)}; } EliasFanoList32 EliasFanoList32::from_encoded_data(std::span encoded_data) { return from_encoded_data(BytesOrByteView{ByteView{encoded_data}}); } EliasFanoList32 EliasFanoList32::from_encoded_data(ByteView encoded_data) { return from_encoded_data(BytesOrByteView{encoded_data}); } EliasFanoList32 EliasFanoList32::from_encoded_data(Bytes encoded_data) { return from_encoded_data(BytesOrByteView{std::move(encoded_data)}); } EliasFanoList32::EliasFanoList32( uint64_t count, uint64_t max_value, uint64_t data_offset, BytesOrByteView data_holder) : count_{count}, u_{max_value + 1}, data_offset_{data_offset}, total_words_{EliasFanoList32::total_words(count, max_value)}, data_holder_{std::move(data_holder)} { SILKWORM_ASSERT(EliasFanoList32::total_words(count, max_value) * sizeof(uint64_t) + data_offset <= ByteView{data_holder_}.size()); derive_fields(); } uint64_t EliasFanoList32::at(size_t i) const { uint64_t lower = i * l_; size_t idx64 = lower / 64; uint64_t shift = lower % 64; SILKWORM_ASSERT(idx64 < lower_bits_.size()); lower = lower_bits_[idx64] >> shift; if (shift > 0) { SILKWORM_ASSERT(idx64 + 1 < lower_bits_.size()); lower |= lower_bits_[idx64 + 1] << (64 - shift); } const uint64_t value = ((upper(i) << l_) | (lower & lower_bits_mask_)); return value; } uint64_t EliasFanoList32::upper(uint64_t i) const { const uint64_t jump_super_q = (i / kSuperQ) * kSuperQSize32; const uint64_t jump_inside_super_q = (i % kSuperQ) / kQ; const uint64_t idx64 = jump_super_q + 1 + (jump_inside_super_q >> 1); const uint64_t shift = 32 * (jump_inside_super_q % 2); const uint64_t mask = uint64_t{0xffffffff} << shift; SILKWORM_ASSERT(jump_super_q < jump_.size()); SILKWORM_ASSERT(idx64 < jump_.size()); const uint64_t jump = jump_[jump_super_q] + ((jump_[idx64] & mask) >> shift); uint64_t current_word = jump / 64; SILKWORM_ASSERT(current_word < upper_bits_.size()); uint64_t window = upper_bits_[current_word] & (0xffffffffffffffff << (jump % 64)); uint64_t d = i & kQMask; for (auto bit_count{std::popcount(window)}; static_cast(bit_count) <= d; bit_count = std::popcount(window)) { ++current_word; SILKWORM_ASSERT(current_word < upper_bits_.size()); window = upper_bits_[current_word]; d -= static_cast(bit_count); } const uint64_t sel = encoding::select64(window, d); const uint64_t value = current_word * 64 + sel - i; return value; } std::optional> EliasFanoList32::seek([[maybe_unused]] uint64_t v, bool reverse) const { if (count_ == 0) { return std::nullopt; } uint64_t min = this->min(); uint64_t max = this->max(); if (v == 0) { if (!reverse || (min == 0)) return std::pair{0, min}; return std::nullopt; } size_t last = count_ - 1; if (v == max) { return std::pair{last, max}; } if (v > max) { if (reverse) return std::pair{last, max}; return std::nullopt; } uint64_t hi = v >> l_; IndexRange index_range{0, count_}; IndexRange::Iterator start_it = std::ranges::partition_point(index_range, [reverse, last, hi, this](size_t i) -> bool { return reverse ? (upper(last - i) > hi) : (upper(i) < hi); }); for (size_t j = *start_it; j < count_; j++) { size_t idx = reverse ? last - j : j; uint64_t val = at(idx); if (reverse ? (val <= v) : (val >= v)) { return std::pair{idx, val}; } } return std::nullopt; } std::ostream& operator<<(std::ostream& os, const EliasFanoList32& ef) { Bytes uint64_buffer(8, '\0'); endian::store_big_u64(uint64_buffer.data(), ef.count_ - 1); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); SILK_DEBUG << "[index] written EF code count: " << ef.count_ - 1; endian::store_big_u64(uint64_buffer.data(), ef.u_); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); SILK_DEBUG << "[index] written EF upper: " << ef.u_; auto data = ef.data(); os.write(reinterpret_cast(data.data()), static_cast(data.size() * sizeof(uint64_t))); return os; } uint64_t EliasFanoList32::total_words(uint64_t count, uint64_t max_value) { ensure(count > 0, "EliasFanoList32 size is zero"); const uint64_t u = max_value + 1; const uint64_t l = (u / count == 0) ? 0 : (63 ^ static_cast(std::countl_zero(u / count))); const uint64_t words_lower_bits = (count * l + 63) / 64 + 1; const uint64_t words_upper_bits = (count + (u >> l) + 63) / 64; const uint64_t jump_words = jump_size_words(count); const uint64_t total_words = words_lower_bits + words_upper_bits + jump_words; return total_words; } uint64_t EliasFanoList32::jump_size_words(uint64_t count) { uint64_t size = (count / kSuperQ) * kSuperQSize32; // Whole blocks if (count % kSuperQ != 0) { size += 1 + ((count % kSuperQ + kQ - 1) / kQ + 3) / 2; // Partial block } return size; } uint64_t EliasFanoList32::derive_fields() { ensure(count_ > 0, "EliasFanoList32 size is zero"); l_ = (u_ / count_ == 0) ? 0 : (63 ^ static_cast(std::countl_zero(u_ / count_))); lower_bits_mask_ = (uint64_t{1} << l_) - 1; uint64_t words_lower_bits = (count_ * l_ + 63) / 64 + 1; uint64_t words_upper_bits = (count_ + (u_ >> l_) + 63) / 64; uint64_t jump_words = jump_size_words(count_); uint64_t total_words = words_lower_bits + words_upper_bits + jump_words; auto data = this->data(); lower_bits_ = data.subspan(0, words_lower_bits); upper_bits_ = data.subspan(words_lower_bits, words_upper_bits); jump_ = data.subspan(words_lower_bits + words_upper_bits, jump_words); return total_words; } EliasFanoList32Builder::EliasFanoList32Builder(uint64_t count, uint64_t max_value) : count_{count}, u_{max_value + 1} { derive_fields(); } void EliasFanoList32Builder::add_offset(uint64_t offset) { if (l_ != 0) { set_bits(lower_bits_, i_ * l_, l_, offset & lower_bits_mask_); } set(upper_bits_, (offset >> l_) + i_); ++i_; } void EliasFanoList32Builder::build() { for (uint64_t i{0}, c{0}, last_super_q{0}; i < upper_bits_.size(); ++i) { for (uint64_t b{0}; b < 64; ++b) { if ((upper_bits_[i] & (uint64_t{1} << b)) != 0) { if ((c & kSuperQMask) == 0) { /* When c is multiple of 2^14 (4096) */ jump_[(c / kSuperQ) * kSuperQSize32] = last_super_q = i * 64 + b; } if ((c & kQMask) == 0) { /* When c is multiple of 2^8 (256) */ // offset can be either 0, 256, 512, ..., up to 4096-256 const uint64_t offset = i * 64 + b - last_super_q; // offset needs to be encoded as 16-bit integer, therefore the following check SILKWORM_ASSERT(offset < (uint64_t{1} << 32)); // c % superQ is the bit index inside the group of 4096 bits const uint64_t jump_super_q = (c / kSuperQ) * kSuperQSize32; const uint64_t jump_inside_super_q = (c % kSuperQ) / kQ; const uint64_t idx64 = jump_super_q + 1 + (jump_inside_super_q >> 1); const uint64_t shift = 32 * (jump_inside_super_q % 2); const uint64_t mask = uint64_t{0xffffffff} << shift; jump_[idx64] = (jump_[idx64] & ~mask) | (offset << shift); } ++c; } } } } uint64_t EliasFanoList32Builder::derive_fields() { ensure(count_ > 0, "EliasFanoList32Builder size is zero"); l_ = (u_ / count_ == 0) ? 0 : (63 ^ static_cast(std::countl_zero(u_ / count_))); lower_bits_mask_ = (uint64_t{1} << l_) - 1; uint64_t words_lower_bits = (count_ * l_ + 63) / 64 + 1; uint64_t words_upper_bits = (count_ + (u_ >> l_) + 63) / 64; uint64_t jump_words = EliasFanoList32::jump_size_words(count_); uint64_t total_words = words_lower_bits + words_upper_bits + jump_words; data_.resize(total_words); lower_bits_ = std::span{data_.data(), words_lower_bits}; upper_bits_ = std::span{data_.data() + words_lower_bits, words_upper_bits}; jump_ = std::span{data_.data() + words_lower_bits + words_upper_bits, jump_words}; return total_words; } std::ostream& operator<<(std::ostream& os, const EliasFanoList32Builder& ef) { Bytes uint64_buffer(8, '\0'); endian::store_big_u64(uint64_buffer.data(), ef.count_ - 1); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); SILK_DEBUG << "[index] written EF code count: " << ef.count_ - 1; endian::store_big_u64(uint64_buffer.data(), ef.u_); os.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); SILK_DEBUG << "[index] written EF upper: " << ef.u_; os.write(reinterpret_cast(ef.data_.data()), static_cast(ef.data_.size() * sizeof(uint64_t))); return os; } } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/elias_fano_list.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #include #include #include #include #include #include #include "../common/encoding/sequence.hpp" #include "../common/util/iterator/list_iterator.hpp" namespace silkworm::snapshots::elias_fano { //! 32-bit Elias-Fano (EF) list reader that can be used to decode one monotone non-decreasing sequence class EliasFanoList32 { public: using value_type = uint64_t; //! Create a new 32-bit EF list from the given encoded data (i.e. data plus data header) static EliasFanoList32 from_encoded_data(BytesOrByteView encoded_data_holder); //! Create a new 32-bit EF list from the given encoded data (i.e. data plus data header) static EliasFanoList32 from_encoded_data(std::span encoded_data); //! Create a new 32-bit EF list from the given encoded data (i.e. data plus data header) static EliasFanoList32 from_encoded_data(ByteView encoded_data); //! Create a new 32-bit EF list from the given encoded data (i.e. data plus data header) //! @warning using this factory method will hold a copy of encoded data in data_holder_ static EliasFanoList32 from_encoded_data(Bytes encoded_data); //! Create a new 32-bit EF list from an existing data sequence //! \param count //! \param max_value //! \param data_offset offset in the data_holder to the data sequence //! \param data_holder the data (portion exceeding the total words will be ignored) EliasFanoList32( uint64_t count, uint64_t max_value, uint64_t data_offset, BytesOrByteView data_holder); size_t size() const { return count_; } uint64_t max() const { return u_ - 1; } uint64_t min() const { return at(0); } std::span data() const { const uint64_t* data = reinterpret_cast(ByteView{data_holder_}.data() + data_offset_); return {data, total_words_}; } size_t encoded_data_size() const { return kCountLength + kULength + total_words_ * sizeof(uint64_t); } uint64_t at(size_t i) const; uint64_t operator[](size_t i) const { return at(i); } //! Find the first index where at(i) >= value if reverse = false. //! Find the last index where at(i) <= value if reverse = true. //! \return (i, value) or nullopt if not found std::optional> seek(uint64_t value, bool reverse = false) const; friend std::ostream& operator<<(std::ostream& os, const EliasFanoList32& ef); bool operator==(const EliasFanoList32& other) const { return (count_ == other.count_) && (u_ == other.u_) && std::ranges::equal(data(), other.data()); } static uint64_t total_words(uint64_t count, uint64_t max_value); static uint64_t jump_size_words(uint64_t count); using Iterator = ListIterator; Iterator begin() const { return Iterator{*this, 0}; } Iterator end() const { return Iterator{*this, size()}; } private: uint64_t upper(uint64_t i) const; uint64_t derive_fields(); static constexpr size_t kCountLength{sizeof(uint64_t)}; static constexpr size_t kULength{sizeof(uint64_t)}; std::span lower_bits_{}; std::span upper_bits_{}; std::span jump_{}; uint64_t lower_bits_mask_{0}; uint64_t count_{0}; //! The strict upper bound on the EF data points, i.e. max + 1 uint64_t u_{0}; uint64_t l_{0}; uint64_t data_offset_{0}; uint64_t total_words_{0}; //! The EF encoded data sequence BytesOrByteView data_holder_{}; }; //! 32-bit Elias-Fano (EF) list writer that can be used to encode one monotone non-decreasing sequence class EliasFanoList32Builder { public: using Uint64Sequence = silkworm::snapshots::encoding::Uint64Sequence; //! Create an empty new 32-bit EF list prepared for the given sequence size and max value EliasFanoList32Builder(uint64_t count, uint64_t max_value); friend std::ostream& operator<<(std::ostream& os, const EliasFanoList32Builder& ef); bool operator==(const EliasFanoList32Builder& other) const { return (count_ == other.count_) && (u_ == other.u_) && (data_ == other.data_); } EliasFanoList32 as_view() const { const auto max_value = u_ - 1; return EliasFanoList32{ count_, max_value, 0, BytesOrByteView{ByteView{reinterpret_cast(data_.data()), EliasFanoList32::total_words(count_, max_value) * sizeof(uint64_t)}}, }; }; size_t size() const { return count_; } void add_offset(uint64_t offset); void push_back(uint64_t offset) { add_offset(offset); } void build(); private: uint64_t derive_fields(); std::span lower_bits_{}; std::span upper_bits_{}; std::span jump_{}; uint64_t lower_bits_mask_{0}; uint64_t count_{0}; //! The strict upper bound on the EF data points, i.e. max + 1 uint64_t u_{0}; uint64_t l_{0}; uint64_t i_{0}; Uint64Sequence data_; }; } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/elias_fano_list_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "elias_fano_list.hpp" #include #include #include #include #include #include #include #include namespace silkworm::snapshots::elias_fano { using silkworm::snapshots::encoding::Uint64Sequence; struct EliasFanoList32Test { std::vector offsets; uint64_t expected_u; Uint64Sequence expected_data; }; static std::string le_hex(uint64_t value) { uint8_t full_be[sizeof(uint64_t)]; endian::store_little_u64(full_be, value); return to_hex(full_be); } static std::string be_hex(uint64_t value) { uint8_t full_be[sizeof(uint64_t)]; endian::store_big_u64(full_be, value); return to_hex(full_be); } static std::string hex(const Uint64Sequence& value_sequence) { std::string hex; for (const auto value : value_sequence) { hex += le_hex(value); } return hex; } static std::string to_expected_hex(uint64_t count, uint64_t u, const Uint64Sequence& data) { return be_hex(count) + be_hex(u) + hex(data); } static std::vector generate_contiguous_offsets(uint64_t count) { std::vector offsets; offsets.reserve(count); for (size_t i{0}; i < count; ++i) { offsets.push_back(i); } return offsets; } static EliasFanoList32Builder make_list(const std::vector& offsets) { const uint64_t max_offset = *std::max_element(offsets.cbegin(), offsets.cend()); EliasFanoList32Builder list{offsets.size(), max_offset}; for (uint64_t offset : offsets) { list.add_offset(offset); } list.build(); return list; } TEST_CASE("EliasFanoList32", "[silkworm][recsplit][elias_fano]") { std::vector ef_test_vector{ // Test Pattern 1 { {1, 4, 6, 8, 10, 14, 16, 19, 22, 34, 37, 39, 41, 43, 48, 51, 54, 58, 62}, // offsets 0x3f, // u {0xbc81, 0x0, 0x24945540952a9, 0x0, 0x0, 0x0}, // data }, // Test Pattern 2 { {1, 4, 14'800'000'000'000'000}, // offsets 0x0034948586ad0001, // u {18'014'398'509'481'985, 12'465'963'768'561'532'928u, 76842374, 0, 35, 0, 0, 0}, // data }, // Test Pattern 3 [mask uint32 overflow (i>256)] { generate_contiguous_offsets(260), // offsets 260, // u {0, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 0x5555555555555555, 85, 0, 0x20000000000, 0}, // data }, }; for (const auto& ef_test : ef_test_vector) { // Encode monotone ascending integer sequence using Elias-Fano representation const uint64_t max_offset = *std::max_element(ef_test.offsets.cbegin(), ef_test.offsets.cend()); EliasFanoList32Builder ef_list_builder = make_list(ef_test.offsets); EliasFanoList32 ef_list = ef_list_builder.as_view(); CHECK(ef_list.min() == ef_test.offsets.at(0)); CHECK(ef_list.max() == max_offset); CHECK(ef_list.size() == ef_test.offsets.size()); for (uint64_t i{0}; i < ef_test.offsets.size(); ++i) { const uint64_t x = ef_list.at(i); CHECK(x == ef_test.offsets[i]); } CHECK(std::ranges::equal(ef_list.data(), ef_test.expected_data)); std::stringstream str_stream; str_stream << ef_list; const std::string stream = str_stream.str(); Bytes ef_bytes{stream.cbegin(), stream.cend()}; CHECK(to_hex(ef_bytes) == to_expected_hex(ef_test.offsets.size() - 1, ef_test.expected_u, ef_test.expected_data)); // Decode monotone ascending integer sequence from Elias-Fano representation and compare with original EliasFanoList32 ef_list_copy = EliasFanoList32::from_encoded_data(ef_bytes); for (uint64_t i{0}; i < ef_test.offsets.size(); ++i) { const uint64_t x = ef_list_copy.at(i); CHECK(x == ef_test.offsets[i]); } } } static_assert(IndexedListConcept); static_assert(std::ranges::random_access_range); TEST_CASE("EliasFanoList32::seek", "[silkworm][recsplit][elias_fano]") { using SeekResult = std::pair; std::vector offsets = {1, 4, 6, 8, 10, 14, 16, 19, 22, 34, 37, 39, 41, 43, 48, 51, 54, 58, 62}; EliasFanoList32Builder ef_list_builder = make_list(offsets); EliasFanoList32 ef_list = ef_list_builder.as_view(); // seek forward CHECK(ef_list.seek(0) == SeekResult{0, 1}); CHECK(ef_list.seek(1) == SeekResult{0, 1}); CHECK(ef_list.seek(2) == SeekResult{1, 4}); CHECK(ef_list.seek(4) == SeekResult{1, 4}); CHECK(ef_list.seek(20) == SeekResult{8, 22}); CHECK(ef_list.seek(62) == SeekResult{offsets.size() - 1, 62}); CHECK_FALSE(ef_list.seek(70).has_value()); // seek reverse CHECK_FALSE(ef_list.seek(0, true).has_value()); CHECK(ef_list.seek(1, true) == SeekResult{0, 1}); CHECK(ef_list.seek(2, true) == SeekResult{0, 1}); CHECK(ef_list.seek(4, true) == SeekResult{1, 4}); CHECK(ef_list.seek(20, true) == SeekResult{7, 19}); CHECK(ef_list.seek(62, true) == SeekResult{offsets.size() - 1, 62}); CHECK(ef_list.seek(70, true) == SeekResult{offsets.size() - 1, 62}); } TEST_CASE("EliasFanoList32::from_encoded_data") { EliasFanoList32Builder expected_list{3, 3}; expected_list.add_offset(1); expected_list.add_offset(2); expected_list.add_offset(3); expected_list.build(); std::stringstream expected_list_stream; expected_list_stream << expected_list; const Bytes expected_list_bytes = string_to_bytes(expected_list_stream.str()); CHECK(EliasFanoList32::from_encoded_data(expected_list_bytes) == expected_list.as_view()); } } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/elias_fano/list_iterator.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::snapshots::elias_fano { template concept IndexedListConcept = requires(const TList list) { typename TList::value_type; { list.size() } -> std::same_as; requires requires(size_t i) { { list[i] } -> std::convertible_to; }; }; static_assert(IndexedListConcept>); template class ListIterator { public: using value_type = TValue; using iterator_category [[maybe_unused]] = std::random_access_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type; ListIterator() = default; ListIterator(const TList& list, size_t i) : list_{&list}, i_{i} {} reference operator*() const { return (*list_)[i_]; } pointer operator->() const { return &(**this); } ListIterator operator++(int) { return std::exchange(*this, ++ListIterator{*this}); } ListIterator& operator++() { ++i_; return *this; } ListIterator operator--(int) { return std::exchange(*this, --ListIterator{*this}); } ListIterator& operator--() { --i_; return *this; } ListIterator operator+(size_t count) const { return {*list_, i_ + count}; } ListIterator& operator+=(size_t count) { i_ += count; return *this; } friend ListIterator operator+(size_t count, ListIterator it) { return {*it.list_, count + it.i_}; } reference operator[](size_t count) const { return *(*this + count); } ListIterator operator-(size_t count) const { return {*list_, i_ - count}; } ListIterator& operator-=(size_t count) { i_ -= count; return *this; } difference_type operator-(ListIterator other) const { return static_cast(i_) - static_cast(other.i_); } friend bool operator==(const ListIterator& lhs, const ListIterator& rhs) = default; friend bool operator!=(const ListIterator& lhs, const ListIterator& rhs) = default; friend bool operator<(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ < rhs.i_; } friend bool operator<=(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ <= rhs.i_; } friend bool operator>(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ > rhs.i_; } friend bool operator>=(const ListIterator& lhs, const ListIterator& rhs) { return lhs.i_ >= rhs.i_; } private: const TList* list_{nullptr}; size_t i_{0}; }; static_assert(std::random_access_iterator>>); } // namespace silkworm::snapshots::elias_fano ================================================ FILE: silkworm/db/datastore/snapshots/history.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "history_accessor_index.hpp" #include "inverted_index.hpp" #include "rec_split/accessor_index.hpp" #include "segment/segment_reader.hpp" #include "segment_and_accessor_index.hpp" namespace silkworm::snapshots { struct History { const segment::SegmentFileReader& segment; const rec_split::AccessorIndex& accessor_index; InvertedIndex inverted_index; template static HistoryAccessorIndexKeyEncoder make_accessor_index_key_encoder() { return HistoryAccessorIndexKeyEncoder{}; } SegmentAndAccessorIndex segment_and_index() const { return {segment, accessor_index}; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/history_accessor_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../common/timestamp.hpp" #include "common/codec.hpp" #include "common/raw_codec.hpp" namespace silkworm::snapshots { template struct HistoryAccessorIndexKeyEncoder : public snapshots::Encoder { struct Value { datastore::Timestamp timestamp{0}; decltype(TIIKeyEncoder::value) inverted_index_key; } value; Bytes word; TIIKeyEncoder inverted_index_key_encoder; ~HistoryAccessorIndexKeyEncoder() override = default; ByteView encode_word() override { word.clear(); word.append(sizeof(datastore::Timestamp), 0); endian::store_big_u64(word.data(), value.timestamp); inverted_index_key_encoder.value = std::move(value.inverted_index_key); word += inverted_index_key_encoder.encode_word(); return word; } }; static_assert(snapshots::EncoderConcept>>); } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/history_get_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/timestamp.hpp" #include "basic_queries.hpp" #include "common/codec.hpp" #include "common/raw_codec.hpp" #include "inverted_index_seek_query.hpp" #include "query_caches.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { template < EncoderConcept TKeyEncoder, DecoderConcept TValueDecoder, const SegmentAndAccessorIndexNames& segment_names> struct HistoryGetQuery { HistoryGetQuery( const SnapshotRepositoryROAccess& repository, const QueryCaches& query_caches) : timestamp_query_{ repository, [](const SnapshotBundle& bundle) { return bundle.history(segment_names.front()).inverted_index; }, query_caches.cache(InvertedIndexSeekQueryRawWithCache::kName, segment_names.front()).get(), }, value_query_{repository} {} using Key = decltype(TKeyEncoder::value); using Value = decltype(TValueDecoder::value); using AccessorIndexKey = typename HistoryAccessorIndexKeyEncoder::Value; std::optional exec(const Key& key, datastore::Timestamp timestamp) { auto result = timestamp_query_.exec(key, timestamp); return result ? value_query_.exec(*result, AccessorIndexKey{*result, key}) : std::nullopt; } private: InvertedIndexSeekQuery timestamp_query_; FindByTimestampMapQuery, TValueDecoder, segment_names>> value_query_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/history_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "history_get_query.hpp" #include "history_range_in_period_query.hpp" ================================================ FILE: silkworm/db/datastore/snapshots/history_range_by_keys_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "../common/entity_name.hpp" #include "../common/pair_get.hpp" #include "../common/ranges/caching_view.hpp" #include "../common/ranges/lazy_view.hpp" #include "../common/ranges/merge_many_view.hpp" #include "../common/ranges/owning_view.hpp" #include "common/codec.hpp" #include "history.hpp" #include "inverted_index_lower_bound_key_offset_segment_query.hpp" #include "snapshot_bundle.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { struct HistoryRangeByKeysSegmentQuery { explicit HistoryRangeByKeysSegmentQuery(History entity) : entity_{std::move(entity)} {} explicit HistoryRangeByKeysSegmentQuery( const SnapshotBundle& bundle, datastore::EntityName entity_name) : entity_{bundle.history(entity_name)} {} using ResultItem = std::pair; using AccessorIndexKeyEncoder = HistoryAccessorIndexKeyEncoder>; std::optional lookup_kv_pair( datastore::Timestamp timestamp, bool ascending, Bytes key_data, const InvertedIndexTimestampList& key_timestamps) const { SILKWORM_ASSERT(ascending); // descending is not implemented // find the first key timestamp within the ts_range auto ts_opt = key_timestamps.seek(timestamp); if (!ts_opt) return std::nullopt; datastore::Timestamp ts = ts_opt->second; // query history value using the timestamp and key_data static const SegmentAndAccessorIndexNames kDummySegmentNames{datastore::EntityName{{}}, datastore::EntityName{{}}, datastore::EntityName{{}}}; FindByKeySegmentQuery, kDummySegmentNames> value_query{entity_.segment_and_index()}; auto value_opt = value_query.exec(AccessorIndexKeyEncoder::Value{ts, key_data}); if (!value_opt) return std::nullopt; return std::pair{std::move(key_data), std::move(*value_opt)}; } auto exec_with_eager_begin(Bytes key_start, Bytes key_end, datastore::Timestamp timestamp, bool ascending) { // NOLINT(*-unnecessary-value-param) SILKWORM_ASSERT(ascending); // descending is not implemented InvertedIndexLowerBoundKeyOffsetSegmentQuery lower_bound_query{entity_.inverted_index}; std::optional offset = lower_bound_query.exec(key_start); auto ii_reader = entity_.inverted_index.kv_segment_reader>(); auto begin_it = offset ? ii_reader.seek(*offset) : ii_reader.end(); auto lookup_kv_pair_func = [query = *this, timestamp, ascending](std::pair&& ii_entry) { return query.lookup_kv_pair(timestamp, ascending, std::move(ii_entry.first), ii_entry.second); }; return std::ranges::subrange{std::move(begin_it), ii_reader.end()} | std::views::take_while([key_end = std::move(key_end)](auto&& ii_entry) { return key_end.empty() || ii_entry.first < key_end; }) | std::views::transform(std::move(lookup_kv_pair_func)) | silkworm::views::caching | std::views::filter([](const std::optional& result_opt) { return result_opt.has_value(); }) | std::views::transform([](std::optional& result_opt) -> ResultItem { return std::move(*result_opt); }) | silkworm::views::caching; } auto exec(Bytes key_start, Bytes key_end, datastore::Timestamp timestamp, bool ascending) { auto exec_func = [query = *this, key_start = std::move(key_start), key_end = std::move(key_end), timestamp, ascending]() mutable { return query.exec_with_eager_begin(std::move(key_start), std::move(key_end), timestamp, ascending); }; return silkworm::ranges::lazy(std::move(exec_func)); } private: History entity_; }; template < EncoderConcept TKeyEncoder, DecoderConcept TKeyDecoder, DecoderConcept TValueDecoder> struct HistoryRangeByKeysQuery { const SnapshotRepositoryROAccess& repository; datastore::EntityName entity_name; using Key = decltype(TKeyEncoder::value); using ResultItemKey = decltype(TKeyDecoder::value); using ResultItemValue = decltype(TValueDecoder::value); using ResultItem = std::pair; static ResultItem decode_kv_pair(std::pair&& kv_pair) { if constexpr (std::same_as>) { return std::move(kv_pair); } Decoder::Word key_word{std::move(kv_pair.first)}; TKeyDecoder key_decoder; key_decoder.decode_word(key_word); ResultItemKey& key = key_decoder.value; Decoder::Word value_word{std::move(kv_pair.second)}; TValueDecoder value_decoder; value_decoder.decode_word(value_word); ResultItemValue& value = value_decoder.value; return ResultItem{std::move(key), std::move(value)}; } static constexpr auto kDecodeKVPairFunc = [](std::pair& kv_pair) -> ResultItem { return decode_kv_pair(std::move(kv_pair)); }; auto exec(const Key& key_start, const Key& key_end, datastore::Timestamp timestamp, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented TKeyEncoder key_start_encoder; key_start_encoder.value = key_start; ByteView key_start_data = key_start_encoder.encode_word(); TKeyEncoder key_end_encoder; key_end_encoder.value = key_end; ByteView key_end_data = key_end_encoder.encode_word(); auto results_in_bundle = [entity_name1 = this->entity_name, key_start_data = Bytes{key_start_data}, key_end_data = Bytes{key_end_data}, timestamp, ascending](const std::shared_ptr& bundle_ptr) { const SnapshotBundle& bundle = *bundle_ptr; HistoryRangeByKeysSegmentQuery query{bundle, entity_name1}; return query.exec(key_start_data, key_end_data, timestamp, ascending); }; auto bundle_results = silkworm::ranges::owning_view(repository.bundles_intersecting_range(datastore::TimestampRange{timestamp, datastore::kMaxTimestamp}, ascending)) | std::views::transform(std::move(results_in_bundle)); auto results = silkworm::views::merge_unique_many( std::move(bundle_results), silkworm::views::MergeCompareFunc{}, PairGetFirst{}); return silkworm::ranges::owning_view(std::move(results)) | std::views::transform(kDecodeKVPairFunc) | silkworm::views::caching; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/history_range_in_period_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../common/entity_name.hpp" #include "../common/ranges/caching_view.hpp" #include "../common/ranges/merge_many_view.hpp" #include "../common/ranges/owning_view.hpp" #include "../common/timestamp.hpp" #include "common/raw_codec.hpp" #include "history.hpp" #include "history_accessor_index.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { template struct HistoryRangeInPeriodSegmentQuery { explicit HistoryRangeInPeriodSegmentQuery(History entity) : entity_{entity} {} HistoryRangeInPeriodSegmentQuery(const SnapshotBundle& bundle, datastore::EntityName entity_name) : entity_{bundle.history(entity_name)} {} using Key = decltype(TKeyDecoder::value); using Value = decltype(TValueDecoder::value); using ResultItem = std::pair; using Word = snapshots::Decoder::Word; using AccessorIndexKeyEncoder = HistoryAccessorIndexKeyEncoder>; std::optional lookup_kv_pair( datastore::TimestampRange ts_range, bool ascending, Bytes key_data, const InvertedIndexTimestampList& key_timestamps) const { SILKWORM_ASSERT(ascending); // descending is not implemented // find the first key timestamp within the ts_range auto ts_opt = key_timestamps.seek(ts_range.start); if (!ts_opt) return std::nullopt; datastore::Timestamp ts = ts_opt->second; if (ts >= ts_range.end) return std::nullopt; // query history value using the timestamp and key_data static const SegmentAndAccessorIndexNames kDummySegmentNames{datastore::EntityName{{}}, datastore::EntityName{{}}, datastore::EntityName{{}}}; FindByKeySegmentQuery value_query{entity_.segment_and_index()}; auto value_opt = value_query.exec(AccessorIndexKeyEncoder::Value{ts, key_data}); if (!value_opt) return std::nullopt; // return the key-value pair TKeyDecoder key_decoder; Word key_data_word{std::move(key_data)}; key_decoder.decode_word(key_data_word); return ResultItem{std::move(key_decoder.value), std::move(*value_opt)}; } auto exec(datastore::TimestampRange ts_range, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented auto lookup_kv_pair_func = [query = *this, ts_range, ascending](std::pair&& ii_entry) { return query.lookup_kv_pair(ts_range, ascending, std::move(ii_entry.first), ii_entry.second); }; auto ii_reader = entity_.inverted_index.kv_segment_reader>(); return silkworm::ranges::owning_view(std::move(ii_reader)) | std::views::transform(std::move(lookup_kv_pair_func)) | silkworm::views::caching | std::views::filter([](const std::optional& result_opt) { return result_opt.has_value(); }) | std::views::transform([](std::optional& result_opt) -> ResultItem { return std::move(*result_opt); }) | silkworm::views::caching; } private: History entity_; }; template struct HistoryRangeInPeriodQuery { HistoryRangeInPeriodQuery( const SnapshotRepositoryROAccess& repository, datastore::EntityName entity_name) : repository_{repository}, entity_name_{std::move(entity_name)} {} using Key = decltype(TKeyDecoder::value); using Value = decltype(TValueDecoder::value); using ResultItem = std::pair; auto exec(datastore::TimestampRange ts_range, bool ascending) { SILKWORM_ASSERT(ascending); // descending is not implemented auto results_in_bundle = [entity_name = entity_name_, ts_range, ascending](const std::shared_ptr& bundle) { HistoryRangeInPeriodSegmentQuery query{*bundle, entity_name}; return query.exec(ts_range, ascending); }; auto bundle_results = silkworm::ranges::owning_view(repository_.bundles_intersecting_range(ts_range, ascending)) | std::views::transform(std::move(results_in_bundle)); return silkworm::views::merge_many( std::move(bundle_results), silkworm::views::MergeCompareFunc{}, PairGetFirst{}); } private: const SnapshotRepositoryROAccess& repository_; datastore::EntityName entity_name_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/index_builder.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "index_builder.hpp" #include #include "rec_split/rec_split.hpp" #include "rec_split/rec_split_seq.hpp" namespace silkworm::snapshots { using RecSplitSettings = rec_split::RecSplitSettings; using RecSplit8 = rec_split::RecSplit8; IndexInputDataQuery::Iterator& IndexInputDataQuery::Iterator::operator++() { auto next = query_->next_iterator(impl_); impl_ = next.first; entry_ = next.second; return *this; } bool operator==(const IndexInputDataQuery::Iterator& lhs, const IndexInputDataQuery::Iterator& rhs) { return (lhs.query_ == rhs.query_) && lhs.query_->equal_iterators(lhs.impl_, rhs.impl_); } static IndexInputDataQuery::Iterator::value_type decompressor_index_query_entry(seg::Decompressor::Iterator& it) { return { .key_data = *it, .value = it.current_word_offset(), }; } IndexInputDataQuery::Iterator DecompressorIndexInputDataQuery::begin() { auto decompressor = std::make_shared(segment_path_.path(), segment_region_); auto impl_it = std::make_shared(IteratorImpl{decompressor, decompressor->begin()}); return IndexInputDataQuery::Iterator{this, impl_it, decompressor_index_query_entry(impl_it->it)}; } IndexInputDataQuery::Iterator DecompressorIndexInputDataQuery::end() { auto impl_it = std::make_shared(IteratorImpl{{}, seg::Decompressor::Iterator::make_end()}); return IndexInputDataQuery::Iterator{this, impl_it, decompressor_index_query_entry(impl_it->it)}; } size_t DecompressorIndexInputDataQuery::keys_count() { seg::Decompressor decompressor{segment_path_.path(), segment_region_}; return decompressor.words_count(); } std::pair, IndexInputDataQuery::Iterator::value_type> DecompressorIndexInputDataQuery::next_iterator(std::shared_ptr it_impl) { auto& it_impl_ref = *reinterpret_cast(it_impl.get()); // check if not already at the end if (it_impl_ref.decompressor) { ++it_impl_ref.it; if (it_impl_ref.it == it_impl_ref.decompressor->end()) { it_impl_ref.decompressor.reset(); } } return {it_impl, decompressor_index_query_entry(it_impl_ref.it)}; } bool DecompressorIndexInputDataQuery::equal_iterators( std::shared_ptr lhs_it_impl, std::shared_ptr rhs_it_impl) const { auto lhs = reinterpret_cast(lhs_it_impl.get()); auto rhs = reinterpret_cast(rhs_it_impl.get()); return (lhs->decompressor == rhs->decompressor) && (!lhs->decompressor || (lhs->it == rhs->it)); } void IndexBuilder::build() { SILK_TRACE << "IndexBuilder::build path: " << descriptor_.index_file.path() << " start"; RecSplitSettings rec_split_settings{ .keys_count = query_->keys_count(), .bucket_size = kBucketSize, .index_path = descriptor_.index_file.path(), .base_data_id = descriptor_.base_data_id, .double_enum_index = descriptor_.double_enum_index, .less_false_positives = descriptor_.less_false_positives, }; RecSplit8 rec_split1{rec_split_settings, rec_split::seq_build_strategy(descriptor_.etl_buffer_size)}; rec_split1.build_without_collisions([&](RecSplit8& rec_split) { uint64_t i{0}; for (auto& entry : *query_) { auto key = descriptor_.key_factory ? descriptor_.key_factory->make(entry.key_data, i) : Bytes{entry.key_data}; rec_split.add_key(key, entry.value); ++i; } }); SILK_TRACE << "IndexBuilder::build path: " << descriptor_.index_file.path() << " end"; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/index_builder.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "common/snapshot_path.hpp" #include "segment/seg/decompressor.hpp" namespace silkworm::snapshots { struct IndexKeyFactory { virtual ~IndexKeyFactory() = default; virtual Bytes make(ByteView key_data, uint64_t i) = 0; }; struct IndexDescriptor { SnapshotPath index_file; std::unique_ptr key_factory; uint64_t base_data_id{}; bool double_enum_index{true}; bool less_false_positives{}; size_t etl_buffer_size{datastore::etl::kOptimalBufferSize}; }; struct IndexInputDataQuery { class Iterator { public: // NOLINTNEXTLINE(readability-identifier-naming) struct value_type { ByteView key_data; uint64_t value{}; }; Iterator(IndexInputDataQuery* query, std::shared_ptr impl, value_type entry) : query_(query), impl_(std::move(impl)), entry_(entry) {} using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; reference operator*() { return entry_; } pointer operator->() { return &entry_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++(); friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs); private: IndexInputDataQuery* query_; std::shared_ptr impl_; value_type entry_; }; static_assert(std::input_or_output_iterator); virtual ~IndexInputDataQuery() = default; virtual Iterator begin() = 0; virtual Iterator end() = 0; virtual size_t keys_count() = 0; virtual std::pair, Iterator::value_type> next_iterator(std::shared_ptr it_impl) = 0; virtual bool equal_iterators(std::shared_ptr lhs_it_impl, std::shared_ptr rhs_it_impl) const = 0; }; class DecompressorIndexInputDataQuery : public IndexInputDataQuery { public: explicit DecompressorIndexInputDataQuery( SnapshotPath segment_path, std::optional segment_region = std::nullopt) : segment_path_(std::move(segment_path)), segment_region_(segment_region) {} Iterator begin() override; Iterator end() override; size_t keys_count() override; std::pair, Iterator::value_type> next_iterator(std::shared_ptr it_impl) override; bool equal_iterators(std::shared_ptr lhs_it_impl, std::shared_ptr rhs_it_impl) const override; private: struct IteratorImpl { std::shared_ptr decompressor; seg::Decompressor::Iterator it; }; SnapshotPath segment_path_; std::optional segment_region_; }; struct IndexBuilder { IndexBuilder( IndexDescriptor descriptor, std::unique_ptr query) : descriptor_(std::move(descriptor)), query_(std::move(query)) {} virtual ~IndexBuilder() = default; IndexBuilder(IndexBuilder&&) = default; IndexBuilder& operator=(IndexBuilder&&) = default; void set_base_data_id(uint64_t id) { descriptor_.base_data_id = id; } void build(); const SnapshotPath& path() const { return descriptor_.index_file; } private: static constexpr size_t kBucketSize{2'000}; IndexDescriptor descriptor_; std::unique_ptr query_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/index_builders_factory.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "index_builders_factory.hpp" namespace silkworm::snapshots { std::vector> IndexBuildersFactory::index_builders(const SnapshotPathList& segment_paths) const { std::vector> all_builders; for (const auto& path : segment_paths) { auto builders = index_builders(path); all_builders.insert(all_builders.end(), builders.begin(), builders.end()); } return all_builders; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/index_builders_factory.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "common/snapshot_path.hpp" #include "index_builder.hpp" namespace silkworm::snapshots { struct IndexBuildersFactory { virtual ~IndexBuildersFactory() = default; virtual std::vector> index_builders(const SnapshotPath& segment_path) const = 0; std::vector> index_builders(const SnapshotPathList& segment_paths) const; virtual SnapshotPathList index_dependency_paths(const SnapshotPath& index_path) const = 0; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/index_salt_file.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "index_salt_file.hpp" #include #include #include namespace silkworm::snapshots { using namespace std; uint32_t IndexSaltFile::load() const { Bytes data(sizeof(uint32_t), 0); ifstream file{path_, std::ios::binary}; file.exceptions(ios::failbit | ios::badbit); file.read(byte_ptr_cast(data.data()), static_cast(data.size())); return endian::load_big_u32(data.data()); } void IndexSaltFile::save(uint32_t value) const { Bytes data(sizeof(uint32_t), 0); endian::store_big_u32(data.data(), value); ofstream file{path_, std::ios::binary | std::ios::trunc}; file.exceptions(ios::failbit | ios::badbit); file.write(byte_ptr_cast(data.data()), static_cast(data.size())); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/index_salt_file.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::snapshots { class IndexSaltFile { public: explicit IndexSaltFile(std::filesystem::path path) : path_{std::move(path)} {} uint32_t load() const; void save(uint32_t value) const; bool exists() const { return std::filesystem::exists(path_); } private: std::filesystem::path path_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "inverted_index_ts_list_codec.hpp" #include "rec_split/accessor_index.hpp" #include "segment/kv_segment_reader.hpp" namespace silkworm::snapshots { struct InvertedIndex { const segment::KVSegmentFileReader& kv_segment; const rec_split::AccessorIndex& accessor_index; template segment::KVSegmentReader kv_segment_reader() { return segment::KVSegmentReader{kv_segment}; } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_find_by_key_segment_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../common/ranges/if_view.hpp" #include "../common/ranges/owning_view.hpp" #include "../common/timestamp.hpp" #include "common/raw_codec.hpp" #include "elias_fano/elias_fano_list.hpp" #include "inverted_index.hpp" #include "snapshot_bundle.hpp" namespace silkworm::snapshots { inline auto timestamp_range_filter(InvertedIndexTimestampList list, datastore::TimestampRange ts_range, bool ascending) { using Iterator = InvertedIndexTimestampList::Iterator; size_t start = 0; size_t end = list.size(); if (ascending) { auto start_opt = list.seek(ts_range.start, /*reverse=*/false); start = start_opt ? start_opt->first : end; } else if (ts_range.size() > 0) { auto last_opt = list.seek(ts_range.end - 1, /*reverse=*/true); end = last_opt ? last_opt->first + 1 : start; } else { start = end; } auto range_from_list = [ts_range, ascending, start, end](const InvertedIndexTimestampList& list1) { auto list_range = [&list1, start, end]() { return std::ranges::subrange{Iterator{list1, start}, Iterator{list1, end}}; }; return silkworm::views::if_view( ascending, list_range() | std::views::all | std::views::take_while([ts_range](uint64_t ts) { return ts < ts_range.end; }), list_range() | std::views::reverse | std::views::take_while([ts_range](uint64_t ts) { return ts >= ts_range.start; })); }; return std::ranges::single_view{std::move(list)} | std::views::transform(std::move(range_from_list)) | std::views::join; } template struct InvertedIndexFindByKeySegmentQuery { explicit InvertedIndexFindByKeySegmentQuery( InvertedIndex entity) : entity_{entity} {} explicit InvertedIndexFindByKeySegmentQuery( const SnapshotBundle& bundle, datastore::EntityName entity_name) : entity_{bundle.inverted_index(entity_name)} {} using Key = decltype(TKeyEncoder::value); std::optional exec(Key key) { TKeyEncoder key_encoder; key_encoder.value = std::move(key); ByteView key_data = key_encoder.encode_word(); return exec_raw(key_data); } std::optional exec_raw(ByteView key_data) { auto offset = entity_.accessor_index.lookup_by_key(key_data); if (!offset) { return std::nullopt; } auto reader = entity_.kv_segment_reader>(); std::optional> result = reader.seek_one(*offset); // ensure that the found key matches to avoid lookup_by_key false positives if (result && (result->first == key_data)) { return std::move(result->second); } return std::nullopt; } auto exec_filter(Key key, datastore::TimestampRange ts_range, bool ascending) { return timestamp_range_filter(exec(std::move(key)).value_or(InvertedIndexTimestampList{}), ts_range, ascending); } private: InvertedIndex entity_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_lower_bound_key_offset_segment_query.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "inverted_index_lower_bound_key_offset_segment_query.hpp" #include #include #include "common/raw_codec.hpp" #include "common/util/iterator/index_range.hpp" namespace silkworm::snapshots { std::optional InvertedIndexLowerBoundKeyOffsetSegmentQuery::exec(ByteView key) { size_t count = entity.kv_segment.item_count(); IndexRange index_range{0, count}; IndexRange::Iterator it = std::lower_bound(index_range.begin(), index_range.end(), key, [this](size_t i, ByteView target_key) { std::optional offset = entity.accessor_index.lookup_by_data_id(entity.accessor_index.base_data_id() + i); SILKWORM_ASSERT(offset); if (!offset) return true; std::optional key_opt = segment::KVSegmentKeysReader>{entity.kv_segment}.seek_one(*offset); if (!key_opt) return true; return *key_opt < target_key; }); if (*it < count) { return entity.accessor_index.lookup_by_data_id(entity.accessor_index.base_data_id() + *it); } return std::nullopt; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_lower_bound_key_offset_segment_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "inverted_index.hpp" namespace silkworm::snapshots { struct InvertedIndexLowerBoundKeyOffsetSegmentQuery { InvertedIndex entity; std::optional exec(ByteView key); }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_queries.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "inverted_index_range_by_key_query.hpp" ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_range_by_key_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../common/entity_name.hpp" #include "../common/ranges/owning_view.hpp" #include "../common/timestamp.hpp" #include "inverted_index_find_by_key_segment_query.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { template struct InvertedIndexRangeByKeyQuery { explicit InvertedIndexRangeByKeyQuery( const SnapshotRepositoryROAccess& repository, datastore::EntityName entity_name) : repository_{repository}, entity_name_{std::move(entity_name)} {} using Key = decltype(TKeyEncoder::value); auto exec(Key key, datastore::TimestampRange ts_range, bool ascending) { auto timestamps_in_bundle = [entity_name = entity_name_, key = std::move(key), ts_range, ascending](const std::shared_ptr& bundle) { InvertedIndexFindByKeySegmentQuery query{*bundle, entity_name}; return query.exec_filter(key, ts_range, ascending); }; return silkworm::ranges::owning_view(repository_.bundles_intersecting_range(ts_range, ascending)) | std::views::transform(std::move(timestamps_in_bundle)) | std::views::join; } private: const SnapshotRepositoryROAccess& repository_; datastore::EntityName entity_name_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_seek_query.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../common/timestamp.hpp" #include "common/codec.hpp" #include "inverted_index.hpp" #include "inverted_index_find_by_key_segment_query.hpp" #include "snapshot_bundle.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { template struct InvertedIndexSeekSegmentQuery { explicit InvertedIndexSeekSegmentQuery(InvertedIndex entity) : query_{std::move(entity)} {} using Key = decltype(TKeyEncoder::value); std::optional exec(Key key, datastore::Timestamp timestamp) { TKeyEncoder key_encoder; key_encoder.value = std::move(key); ByteView key_data = key_encoder.encode_word(); return exec_raw(key_data, timestamp); } std::optional exec_raw(ByteView key, datastore::Timestamp timestamp) { auto list_opt = query_.exec_raw(key); if (!list_opt) { return std::nullopt; } InvertedIndexTimestampList& list = *list_opt; const auto seek_result = list.seek(timestamp); if (seek_result) { return seek_result->second; } return std::nullopt; } private: InvertedIndexFindByKeySegmentQuery query_; }; struct InvertedIndexSeekQueryRawNoCache { const SnapshotRepositoryROAccess& repository_; std::function entity_provider_; std::optional exec(ByteView key_data, datastore::Timestamp timestamp) { datastore::TimestampRange ts_range{timestamp, repository_.max_timestamp_available() + 1}; for (auto& bundle_ptr : repository_.bundles_intersecting_range(ts_range, /*ascending=*/true)) { const SnapshotBundle& bundle = *bundle_ptr; InvertedIndexSeekSegmentQuery> query{entity_provider_(bundle)}; std::optional result = query.exec_raw(key_data, timestamp); if (result) { return result; } } return std::nullopt; } }; struct InvertedIndexSeekQueryRawWithCache { struct InvertedIndexSeekCacheData { datastore::Timestamp requested; std::optional found; }; using CacheType = QueryCache; static inline const datastore::EntityName kName{"InvertedIndexSeekQueryRawWithCache"}; InvertedIndexSeekQueryRawWithCache( const SnapshotRepositoryROAccess& repository, std::function entity_provider, CacheType* cache) : query_{repository, std::move(entity_provider)}, cache_{cache} {} std::optional exec(ByteView key_data, datastore::Timestamp timestamp) { if (!cache_) { return query_.exec(key_data, timestamp); } std::optional cached_data; uint64_t cache_key{0}; std::tie(cached_data, cache_key) = cache_->get(key_data); if (cached_data && (cached_data->requested <= timestamp)) { if (!cached_data->found) { // hit in cache but value not found return std::nullopt; } if (timestamp <= *cached_data->found) { return cached_data->found; } } std::optional result = query_.exec(key_data, timestamp); bool found_equal = result && (*result == timestamp); if (!found_equal) { cache_->put(cache_key, {.requested = timestamp, .found = result}); } return result; } private: InvertedIndexSeekQueryRawNoCache query_; CacheType* cache_; }; template struct InvertedIndexSeekQuery { InvertedIndexSeekQuery( const SnapshotRepositoryROAccess& repository, std::function entity_provider, InvertedIndexSeekQueryRawWithCache::CacheType* cache) : query_{repository, std::move(entity_provider), cache} {} using Key = decltype(TKeyEncoder::value); std::optional exec(Key key, datastore::Timestamp timestamp) { TKeyEncoder key_encoder; key_encoder.value = std::move(key); ByteView key_data = key_encoder.encode_word(); return query_.exec(key_data, timestamp); } private: InvertedIndexSeekQueryRawWithCache query_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_ts_list.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "inverted_index_ts_list.hpp" namespace silkworm::snapshots { size_t InvertedIndexTimestampList::size() const { switch (static_cast(list_.index())) { case Alternative::kEmpty: return 0; case Alternative::kEliasFano: return ef_list().size(); case Alternative::kSimple: return simple_list().size; default: SILKWORM_ASSERT(false); } } InvertedIndexTimestampList::value_type InvertedIndexTimestampList::SimpleList::at(size_t i) const { auto values = reinterpret_cast(ByteView{data}.data() + offset); return base_timestamp + values[i]; } InvertedIndexTimestampList::value_type InvertedIndexTimestampList::at(size_t i) const { switch (static_cast(list_.index())) { case Alternative::kEmpty: SILKWORM_ASSERT(false); return 0; case Alternative::kEliasFano: return ef_list().at(i); case Alternative::kSimple: return simple_list().at(i); default: SILKWORM_ASSERT(false); return 0; } } std::optional InvertedIndexTimestampList::SimpleList::seek(value_type value, bool reverse) const { const auto& list = *this; if (!reverse) { for (size_t i = 0; i < list.size; ++i) { value_type current_value = at(i); if (current_value >= value) return SeekResult{i, current_value}; } return std::nullopt; } else { // NOLINT(readability-else-after-return) for (size_t j = 0; j < list.size; ++j) { size_t i = list.size - 1 - j; value_type current_value = at(i); if (current_value <= value) return SeekResult{i, current_value}; } return std::nullopt; } } std::optional InvertedIndexTimestampList::seek(value_type value, bool reverse) const { switch (static_cast(list_.index())) { case Alternative::kEmpty: return std::nullopt; case Alternative::kEliasFano: return ef_list().seek(value, reverse); case Alternative::kSimple: return simple_list().seek(value, reverse); default: SILKWORM_ASSERT(false); return std::nullopt; } } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_ts_list.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "../common/timestamp.hpp" #include "elias_fano/elias_fano_list.hpp" namespace silkworm::snapshots { class InvertedIndexTimestampList { public: using value_type = datastore::Timestamp; InvertedIndexTimestampList() : list_{std::monostate{}} {} explicit InvertedIndexTimestampList(elias_fano::EliasFanoList32 list) : list_{std::move(list)} {} using SeekResult = std::pair; struct SimpleList { BytesOrByteView data; value_type base_timestamp; size_t offset; size_t size; value_type at(size_t i) const; value_type operator[](size_t i) const { return at(i); } std::optional seek(value_type value, bool reverse) const; }; InvertedIndexTimestampList(BytesOrByteView data, value_type base_timestamp, size_t offset, size_t size) : list_{ SimpleList{ std::move(data), base_timestamp, offset, size, }, } { SILKWORM_ASSERT(ByteView{data}.size() >= offset + size * sizeof(uint32_t)); } size_t size() const; value_type at(size_t i) const; value_type operator[](size_t i) const { return at(i); } //! Find the first index where at(i) >= value if reverse = false. //! Find the last index where at(i) <= value if reverse = true. //! \return (i, value) or nullopt if not found std::optional seek(value_type value, bool reverse = false) const; using Iterator = ListIterator; Iterator begin() const { return Iterator{*this, 0}; } Iterator end() const { return Iterator{*this, size()}; } private: enum class Alternative : size_t { kEmpty, kEliasFano, kSimple, }; const elias_fano::EliasFanoList32& ef_list() const { return std::get(list_); } const SimpleList& simple_list() const { return std::get(list_); } std::variant list_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_ts_list_codec.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "inverted_index_ts_list_codec.hpp" namespace silkworm::snapshots { static_assert(snapshots::DecoderConcept); static constexpr uint8_t kNonV1EncodingMask = 0b10000000; static constexpr uint8_t kSimpleEncodingSizeMask = 0b00001111; static constexpr uint8_t kSimpleEncodingMaxByte = 0b10001111; void InvertedIndexTimestampListDecoder::decode_word(Word& word) { ByteView data{word}; if (data.empty()) { value = {}; } else if ((data[0] & kNonV1EncodingMask) == 0) { auto list = elias_fano::EliasFanoList32::from_encoded_data(std::move(word)); value = InvertedIndexTimestampList{std::move(list)}; } else if ((data[0] | kSimpleEncodingSizeMask) == kSimpleEncodingMaxByte) { value = InvertedIndexTimestampList{ std::move(word), base_timestamp, 1, static_cast(data[0] & kSimpleEncodingSizeMask) + 1, }; } else { throw std::runtime_error{"InvertedIndexTimestampListDecoder: unsupported encoding"}; } } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/inverted_index_ts_list_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../common/step_timestamp_converter.hpp" #include "common/codec.hpp" #include "common/snapshot_path.hpp" #include "inverted_index_ts_list.hpp" namespace silkworm::snapshots { struct InvertedIndexTimestampListDecoder : public snapshots::Decoder { InvertedIndexTimestampList value; datastore::Timestamp base_timestamp{0}; ~InvertedIndexTimestampListDecoder() override = default; void decode_word(Word& word) override; void decode_word_with_metadata(const SnapshotPath& path, const datastore::StepToTimestampConverter& step_converter) override { base_timestamp = step_converter.timestamp_from_step(path.step_range().start); } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/query_cache.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "common/key_hasher.hpp" namespace silkworm::snapshots { template class QueryCache { public: QueryCache(size_t size, KeyHasher key_hasher) : cache_{size, /* thread_safe = */ true}, key_hasher_{std::move(key_hasher)} {} void put(uint64_t cache_key, const Value& value) { cache_.put(cache_key, value); } std::optional get(uint64_t cache_key) { return cache_.get_as_copy(cache_key); } std::pair, uint64_t> get(ByteView key) { const uint64_t cache_key = key_hasher_.hash(key); return {get(cache_key), cache_key}; } void clear() noexcept { cache_.clear(); } private: LruCache cache_; KeyHasher key_hasher_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/query_caches.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "query_caches.hpp" #include #include "domain_get_latest_query.hpp" #include "index_salt_file.hpp" #include "inverted_index_seek_query.hpp" namespace silkworm::snapshots { void QueryCaches::register_caches(const QueryCachesSchema& schema) { uint32_t salt = index_salt_.value_or(RandomNumber{}.generate_one()); KeyHasher key_hasher{salt}; register_caches( schema, DomainGetLatestQueryRawWithCache::kName, std::function{[key_hasher](size_t cache_size) { return std::make_shared(cache_size, key_hasher); }}); register_caches( schema, InvertedIndexSeekQueryRawWithCache::kName, std::function{[key_hasher](size_t cache_size) { return std::make_shared(cache_size, key_hasher); }}); } std::optional QueryCaches::load_index_salt(const std::filesystem::path& snapshots_path) const { IndexSaltFile file{snapshots_path / schema_.index_salt_file_name()}; return file.exists() ? file.load() : std::optional{}; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/query_caches.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "../common/entity_name.hpp" #include "query_caches_schema.hpp" namespace silkworm::snapshots { class QueryCaches { public: explicit QueryCaches( QueryCachesSchema schema, const std::filesystem::path& snapshots_path, std::optional index_salt = std::nullopt) : schema_{std::move(schema)} { index_salt_ = index_salt ? index_salt : load_index_salt(snapshots_path); register_caches(schema_); } template std::shared_ptr cache(datastore::EntityName query_name, datastore::EntityName entity_name) const { if (caches_.contains(query_name)) { auto& caches = caches_.at(query_name); if (caches.contains(entity_name)) { std::shared_ptr cache = caches.at(entity_name); return std::static_pointer_cast(std::move(cache)); } } return {}; } private: template void add_cache(datastore::EntityName query_name, datastore::EntityName entity_name, std::shared_ptr cache) { caches_.try_emplace(query_name, decltype(caches_)::mapped_type{}); caches_.at(query_name).emplace(entity_name, std::shared_ptr{cache}); } template void register_caches(const QueryCachesSchema& schema, datastore::EntityName query_name, std::function(size_t)> cache_factory) { size_t cache_size = schema.cache_size(query_name); for (auto& [entity_name, _] : schema.entities()) { add_cache(query_name, entity_name, cache_factory(cache_size)); } } void register_caches(const QueryCachesSchema& schema); std::optional load_index_salt(const std::filesystem::path& snapshots_path) const; QueryCachesSchema schema_; std::optional index_salt_; datastore::EntityMap>> caches_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/query_caches_schema.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../common/entity_name.hpp" namespace silkworm::snapshots { class QueryCachesSchema { public: QueryCachesSchema& enable(datastore::EntityName entity_name) { entities_[entity_name] = true; return *this; } QueryCachesSchema& cache_size(datastore::EntityName query_name, size_t size) { cache_sizes_[query_name] = size; return *this; } QueryCachesSchema& index_salt_file_name(std::string_view value) { index_salt_file_name_ = value; return *this; } const datastore::EntityMap& entities() const { return entities_; } bool is_enabled(datastore::EntityName entity_name) const { return entities_.contains(entity_name); } size_t cache_size(datastore::EntityName query_name) const { return cache_sizes_.at(query_name); } const std::string& index_salt_file_name() const { return index_salt_file_name_.value(); } private: datastore::EntityMap entities_; datastore::EntityMap cache_sizes_; std::optional index_salt_file_name_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/accessor_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../common/snapshot_path.hpp" #include "rec_split.hpp" namespace silkworm::snapshots::rec_split { class AccessorIndex : private RecSplitIndex { public: explicit AccessorIndex( SnapshotPath path, std::optional region = std::nullopt) : RecSplitIndex{path.path(), region}, path_{std::move(path)} { } using RecSplitIndex::lookup_by_data_id; using RecSplitIndex::lookup_by_key; using RecSplitIndex::lookup_data_id_by_key; using RecSplitIndex::base_data_id; using RecSplitIndex::memory_file_region; const SnapshotPath& path() const { return path_; } const std::filesystem::path& fs_path() const { return path_.path(); } private: SnapshotPath path_; }; } // namespace silkworm::snapshots::rec_split ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/golomb_rice.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #include #include #include #include #include #include #include "../common/encoding/sequence.hpp" #include "../common/encoding/util.hpp" namespace silkworm::snapshots::rec_split { //! Storage for Golomb-Rice codes of a RecSplit bucket. class GolombRiceVector { public: using Uint32Sequence = encoding::Uint32Sequence; using Uint64Sequence = encoding::Uint64Sequence; class Builder { public: static constexpr size_t kDefaultAllocatedWords{16}; Builder() : Builder(kDefaultAllocatedWords) {} explicit Builder(const size_t allocated_words) : data_(allocated_words) {} void append_fixed(const uint64_t v, const uint64_t log2golomb) { if (log2golomb == 0) return; const uint64_t lower_bits = v & ((uint64_t{1} << log2golomb) - 1); size_t used_bits = bit_count_ & 63; data_.resize((bit_count_ + log2golomb + 63) / 64); uint64_t* append_ptr = data_.data() + bit_count_ / 64; uint64_t cur_word = *append_ptr; cur_word |= lower_bits << used_bits; if (used_bits + log2golomb > 64) { *(append_ptr++) = cur_word; cur_word = lower_bits >> (64 - used_bits); } *append_ptr = cur_word; bit_count_ += log2golomb; } void append_unary_all(const Uint32Sequence& unary) { size_t bit_inc = 0; for (const auto u : unary) { // Each number u uses u+1 bits for its unary representation bit_inc += u + 1; } data_.resize((bit_count_ + bit_inc + 63) / 64); for (const auto u : unary) { bit_count_ += u; uint64_t* append_ptr = data_.data() + bit_count_ / 64; *append_ptr |= uint64_t{1} << (bit_count_ & 63); ++bit_count_; } } uint64_t get_bits() const { return bit_count_; } GolombRiceVector build() { data_.resize(data_.size()); return GolombRiceVector{std::move(data_)}; } void append_unary(uint32_t unary) { unaries_.push_back(unary); } void append_collected_unaries() { append_unary_all(unaries_); unaries_.clear(); } private: Uint64Sequence data_; size_t bit_count_{0}; Uint32Sequence unaries_; }; class LazyBuilder { public: static constexpr size_t kDefaultAllocatedWords{16}; LazyBuilder() : LazyBuilder(kDefaultAllocatedWords) {} explicit LazyBuilder(const size_t allocated_words) { fixeds_.reserve(allocated_words); unaries_.reserve(allocated_words); } void append_fixed(const uint64_t v, const uint64_t log2golomb) { fixeds_.emplace_back(v, log2golomb); } void append_unary(uint32_t unary) { unaries_.push_back(unary); } void append_to(Builder& real_builder) { for (const auto& [v, log2golomb] : fixeds_) { real_builder.append_fixed(v, log2golomb); } real_builder.append_unary_all(unaries_); } void clear() { fixeds_.clear(); unaries_.clear(); } private: std::vector> fixeds_; Uint32Sequence unaries_; }; GolombRiceVector() = default; explicit GolombRiceVector(std::vector input_data) : data_(std::move(input_data)) {} size_t size() const { return data_.size(); } class Reader { public: explicit Reader(const Uint64Sequence& input_data) : data_(input_data) {} uint64_t read_next(const uint64_t log2golomb) { uint64_t result = 0; if (curr_window_unary_ == 0) { result += valid_lower_bits_unary_; curr_window_unary_ = *(curr_ptr_unary_++); valid_lower_bits_unary_ = 64; while (curr_window_unary_ == 0) { [[unlikely]] result += 64; curr_window_unary_ = *(curr_ptr_unary_++); } } const auto pos = static_cast(encoding::rho(curr_window_unary_)); curr_window_unary_ >>= pos; curr_window_unary_ >>= 1; valid_lower_bits_unary_ -= pos + 1; result += pos; result <<= log2golomb; size_t idx64 = curr_fixed_offset_ >> 6; uint64_t shift = curr_fixed_offset_ & 63; uint64_t fixed = data_[idx64] >> shift; if (shift + log2golomb > 64) { fixed |= data_[idx64 + 1] << (64 - shift); } result |= fixed & ((uint64_t{1} << log2golomb) - 1); curr_fixed_offset_ += log2golomb; return result; } void skip_subtree(const size_t nodes, const size_t fixed_len) { SILKWORM_ASSERT(nodes > 0); size_t missing = nodes, cnt = 0; while ((cnt = static_cast(encoding::nu(curr_window_unary_))) < missing) { curr_window_unary_ = *(curr_ptr_unary_++); missing -= cnt; valid_lower_bits_unary_ = 64; } cnt = encoding::select64(curr_window_unary_, missing - 1); curr_window_unary_ >>= cnt; curr_window_unary_ >>= 1; valid_lower_bits_unary_ -= cnt + 1; curr_fixed_offset_ += fixed_len; } void read_reset(const size_t bit_pos, const size_t unary_offset) { curr_fixed_offset_ = bit_pos; size_t unary_pos = bit_pos + unary_offset; curr_ptr_unary_ = data_.data() + unary_pos / 64; curr_window_unary_ = *(curr_ptr_unary_++) >> (unary_pos & 63); valid_lower_bits_unary_ = 64 - (unary_pos & 63); } private: const Uint64Sequence& data_; size_t curr_fixed_offset_{0}; uint64_t curr_window_unary_{0}; uint64_t const* curr_ptr_unary_{nullptr}; size_t valid_lower_bits_unary_{0}; }; Reader reader() const { return Reader{data_}; } private: encoding::Uint64Sequence data_; friend std::ostream& operator<<(std::ostream& os, const GolombRiceVector& rbv) { using namespace encoding; os << rbv.data_; return os; } friend std::istream& operator>>(std::istream& is, GolombRiceVector& rbv) { using namespace encoding; is >> rbv.data_; return is; } }; } // namespace silkworm::snapshots::rec_split ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/golomb_rice_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "golomb_rice.hpp" #include #include #include #include namespace silkworm::snapshots::rec_split { using silkworm::snapshots::encoding::Uint32Sequence; using silkworm::snapshots::encoding::Uint64Sequence; static constexpr size_t kGolombRiceTestNumKeys{128}; static constexpr size_t kGolombRiceTestNumTrees{1'000}; static Uint64Sequence generate_keys() { static RandomNumber rnd(32, 64); Uint64Sequence keys; for (size_t i = 0; i < kGolombRiceTestNumKeys; ++i) { keys.push_back(rnd.generate_one()); } return keys; } static GolombRiceVector build_vector(const Uint64Sequence& keys, uint64_t golomb_param) { GolombRiceVector::Builder builder; for (size_t t{0}; t < kGolombRiceTestNumTrees; ++t) { Uint32Sequence unary; for (uint64_t k : keys) { builder.append_fixed(k, golomb_param); unary.push_back(static_cast(k >> golomb_param)); } builder.append_unary_all(unary); } return builder.build(); } static void test_trees(GolombRiceVector& v, const Uint64Sequence& keys, uint64_t golomb_param, size_t tree_offset) { GolombRiceVector::Reader r = v.reader(); for (size_t t{0}; t < kGolombRiceTestNumTrees; ++t) { r.read_reset(t * tree_offset, golomb_param * keys.size()); for (uint64_t expected_key : keys) { uint64_t k = r.read_next(golomb_param); CHECK(k == expected_key); } } } TEST_CASE("GolombRiceVector", "[silkworm][recsplit][golomb_rice]") { const std::vector golomb_params{0, 1, 2, 3, 4, 5, 6}; for (size_t i{0}; i < golomb_params.size(); ++i) { SECTION("trees " + std::to_string(i)) { const uint64_t golomb_param = golomb_params[i]; Uint64Sequence keys = generate_keys(); GolombRiceVector v = build_vector(keys, golomb_param); size_t tree_offset{0}; for (uint64_t k : keys) { tree_offset += 1 + (k >> golomb_param) + golomb_param; } test_trees(v, keys, golomb_param, tree_offset); } } } } // namespace silkworm::snapshots::rec_split ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/rec_split.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rec_split.hpp" namespace silkworm::snapshots::rec_split { template <> const size_t RecSplit8::kLowerAggregationBound = RecSplit8::SplitStrategy::kLowerAggregationBound; template <> const size_t RecSplit8::kUpperAggregationBound = RecSplit8::SplitStrategy::kUpperAggregationBound; template <> const std::array RecSplit8::kMemo = RecSplit8::fill_golomb_rice(); } // namespace silkworm::snapshots::rec_split ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/rec_split.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../common/encoding/murmur_hash3.hpp" #include "../common/util/bitmask_operators.hpp" #include "../elias_fano/double_elias_fano_list.hpp" #include "../elias_fano/elias_fano_list.hpp" #include "golomb_rice.hpp" #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" namespace silkworm::snapshots::rec_split { using namespace std::chrono; using encoding::remap16, encoding::remap128; //! Assumed *maximum* size of a bucket. Works with high probability up to average bucket size ~2000 inline constexpr int kMaxBucketSize = 3000; //! Assumed *maximum* size of splitting tree leaves inline constexpr int kMaxLeafSize = 24; //! Assumed *maximum* size of splitting tree fanout inline constexpr int kMaxFanout = 32; //! Starting seed at given distance from the root (extracted at random) inline constexpr std::array kStartSeed = { 0x106393c187cae21a, 0x6453cec3f7376937, 0x643e521ddbd2be98, 0x3740c6412f6572cb, 0x717d47562f1ce470, 0x4cd6eb4c63befb7c, 0x9bfd8c5e18c8da73, 0x082f20e10092a9a3, 0x2ada2ce68d21defc, 0xe33cb4f3e7c6466b, 0x3980be458c509c59, 0xc466fd9584828e8c, 0x45f0aabe1a61ede6, 0xf6e7b8b33ad9b98d, 0x4ef95e25f4b4983d, 0x81175195173b92d3, 0x4e50927d8dd15978, 0x1ea2099d1fafae7f, 0x425c8a06fbaaa815, 0xcd4216006c74052a}; //! David Stafford's (http://zimbry.blogspot.com/2011/09/better-bit-mixingsuccinct::-improving-on.html) //! 13th variant of the 64-bit finalizer function in Austin Appleby's MurmurHash3 (https://github.com/aappleby/smhasher) //! @param z a 64-bit integer //! @return a 64-bit integer obtained by mixing the bits of `z` uint64_t inline remix(uint64_t z) { z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; z = (z ^ (z >> 27)) * 0x94d049bb133111eb; return z ^ (z >> 31); } //! 128-bit hash used in the construction of RecSplit (first of all keys are hashed using MurmurHash3) //! Moreover, it is possible to build and query RecSplit instances using 128-bit random hashes (mainly for test purposes) struct Hash128 { uint64_t first; // The high 64-bit hash half uint64_t second; // The low 64-bit hash half bool operator<(const Hash128& o) const { return first < o.first || second < o.second; } }; // Optimal Golomb-Rice parameters for leaves inline constexpr uint8_t kBijMemo[] = {0, 0, 0, 1, 3, 4, 5, 7, 8, 10, 11, 12, 14, 15, 16, 18, 19, 21, 22, 23, 25, 26, 28, 29, 30}; //! The splitting strategy of Recsplit algorithm is embedded into the generation code, which uses only the public fields template class SplittingStrategy { static_assert(1 <= LEAF_SIZE && LEAF_SIZE <= kMaxLeafSize); public: //! The lower bound for primary (lower) key aggregation static constexpr size_t kLowerAggregationBound = LEAF_SIZE * std::max(size_t{2}, math::int_ceil(0.35 * LEAF_SIZE + 0.5)); //! The lower bound for secondary (upper) key aggregation static constexpr size_t kUpperAggregationBound = kLowerAggregationBound * (LEAF_SIZE < 7 ? size_t{2} : math::int_ceil(0.21 * LEAF_SIZE + 0.9)); static std::pair split_params(const size_t m) { size_t fanout{0}, unit{0}; if (m > kUpperAggregationBound) { // High-level aggregation (fanout 2) unit = kUpperAggregationBound * (static_cast((m + 1) / 2 + kUpperAggregationBound - 1) / kUpperAggregationBound); fanout = 2; } else if (m > kLowerAggregationBound) { // Second-level aggregation unit = kLowerAggregationBound; fanout = static_cast(m + kLowerAggregationBound - 1) / kLowerAggregationBound; } else { // First-level aggregation unit = LEAF_SIZE; fanout = static_cast(m + LEAF_SIZE - 1) / LEAF_SIZE; } return {fanout, unit}; } }; //! Size in bytes of 1st fixed metadata header fields in RecSplit-encoded file inline constexpr size_t kBaseDataIdLength = sizeof(uint64_t); inline constexpr size_t kKeyCountLength = sizeof(uint64_t); inline constexpr size_t kBytesPerRecordLength = sizeof(uint8_t); //! Size in bytes of 1st fixed metadata header in RecSplit-encoded file inline constexpr size_t kFirstMetadataHeaderLength = kBaseDataIdLength + kKeyCountLength + kBytesPerRecordLength; //! Size in bytes of 2nd fixed metadata header fields in RecSplit-encoded file inline constexpr size_t kBucketCountLength = sizeof(uint64_t); inline constexpr size_t kBucketSizeLength = sizeof(uint16_t); inline constexpr size_t kLeafSizeLength = sizeof(uint16_t); inline constexpr size_t kSaltSizeLength = sizeof(uint32_t); inline constexpr size_t kStartSeedSizeLength = sizeof(uint8_t); inline constexpr size_t kFeaturesFlagLength = sizeof(uint8_t); inline constexpr size_t kGolombParamSizeLength = sizeof(uint32_t); // Erigon writes 4-instead-of-2 bytes inline constexpr size_t kEliasFano32CountLength = sizeof(uint64_t); inline constexpr size_t kEliasFano32ULength = sizeof(uint64_t); inline constexpr size_t kExistenceFilterSizeLength = sizeof(uint64_t); //! Size in bytes of 2nd fixed metadata header in RecSplit-encoded file inline constexpr size_t kSecondMetadataHeaderLength = kBucketCountLength + kBucketSizeLength + kLeafSizeLength + kSaltSizeLength + kStartSeedSizeLength; //! Parameters for modified Recursive splitting (RecSplit) algorithm. struct RecSplitSettings { size_t keys_count; // The total number of keys in the RecSplit uint16_t bucket_size; // The number of keys in each bucket (except probably last one) std::filesystem::path index_path; // The path of the generated RecSplit index file uint64_t base_data_id; // Application-specific base data ID written in index header bool double_enum_index{true}; // Flag indicating if 2-layer index is required bool less_false_positives{false}; // Flag indicating if existence filter to reduce false-positives is required }; enum class RecSplitFeatures : uint8_t { kNone = 0b0, // no specific feature kEnums = 0b1, // 2-layer index with PHT pointing to enumeration and enumeration pointing to offsets kLessFalsePositives = 0b10, // reduce false-positives to 1/256=0.4% at the cost of 1byte per key }; consteval void enable_bitmask_operator_and(RecSplitFeatures); consteval void enable_bitmask_operator_or(RecSplitFeatures); consteval void enable_bitmask_operator_not(RecSplitFeatures); inline constexpr std::array kSupportedFeatures{RecSplitFeatures::kEnums, RecSplitFeatures::kLessFalsePositives}; //! Recursive splitting (RecSplit) is an efficient algorithm to identify minimal perfect hash functions. //! The template parameter LEAF_SIZE decides how large a leaf will be. Larger leaves imply slower construction, but less //! space and faster evaluation //! @tparam LEAF_SIZE the size of a leaf, typical value range from 6 to 8 for fast small maps or up to 16 for very compact functions template class RecSplit { public: using SplitStrategy = SplittingStrategy; using GolombRiceBuilder = GolombRiceVector::Builder; using EliasFano = elias_fano::EliasFanoList32; using EliasFanoBuilder = elias_fano::EliasFanoList32Builder; using DoubleEliasFano = elias_fano::DoubleEliasFanoList16; using Murmur3 = encoding::Murmur3; //! The base class for RecSplit building strategies struct BuildingStrategy { virtual ~BuildingStrategy() = default; virtual void setup(const RecSplitSettings& settings, size_t bucket_count) = 0; virtual void add_key(uint64_t bucket_id, uint64_t bucket_key, uint64_t offset) = 0; virtual bool build_mph_index( std::ofstream& index_output_stream, GolombRiceVector& golomb_rice_codes, uint16_t& golomb_param_max_index, DoubleEliasFano& double_ef_index, uint8_t bytes_per_record) = 0; virtual void build_enum_index(std::unique_ptr& ef_offsets) = 0; virtual void clear() = 0; virtual uint64_t keys_added() = 0; virtual uint64_t max_offset() = 0; void add_to_existence_filter(uint8_t key_fingerprint) { existence_filter_stream_ << key_fingerprint; } void flush_existence_filter(Bytes& uint64_buffer, std::ofstream& index_output_stream) { existence_filter_stream_.flush(); existence_filter_stream_.seekg(0, std::ios::beg); endian::store_big_u64(uint64_buffer.data(), keys_added()); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); index_output_stream << existence_filter_stream_.rdbuf(); } protected: BuildingStrategy() : existence_filter_stream_{TemporaryDirectory::get_unique_temporary_path(), std::ios::binary | std::ios::out | std::ios::in | std::ios::app} {} private: //! Serialization for the existence filter (1-byte per key positional presence hint) std::fstream existence_filter_stream_; }; struct SequentialBuildingStrategy; struct ParallelBuildingStrategy; explicit RecSplit(const RecSplitSettings& settings, std::unique_ptr bs, uint32_t salt = 0) : bucket_size_(settings.bucket_size), key_count_(settings.keys_count), bucket_count_((key_count_ + bucket_size_ - 1) / bucket_size_), base_data_id_(settings.base_data_id), index_path_(settings.index_path), double_enum_index_(settings.double_enum_index), less_false_positives_(settings.less_false_positives), building_strategy_(std::move(bs)) { building_strategy_->setup(settings, bucket_count_); // Generate random salt for murmur3 hash std::random_device rand_dev; std::mt19937 rand_gen32{rand_dev()}; salt_ = salt != 0 ? salt : static_cast(rand_gen32()); hasher_ = std::make_unique(salt_); } explicit RecSplit(std::filesystem::path index_path, std::optional index_region = {}) : index_path_{index_path}, encoded_file_{std::make_optional(std::move(index_path), index_region)} { SILK_TRACE << "RecSplit encoded file path: " << encoded_file_->path(); check_minimum_length(kFirstMetadataHeaderLength); const auto address = encoded_file_->region().data(); encoded_file_->advise_sequential(); // Read fixed metadata header fields from RecSplit-encoded file base_data_id_ = endian::load_big_u64(address); key_count_ = endian::load_big_u64(address + kBaseDataIdLength); bytes_per_record_ = address[kBaseDataIdLength + kKeyCountLength]; record_mask_ = (uint64_t{1} << (8 * bytes_per_record_)) - 1; SILK_TRACE << "Base data ID: " << base_data_id_ << " key count: " << key_count_ << " bytes per record: " << bytes_per_record_ << " record mask: " << record_mask_; // Compute offset for variable metadata header fields uint64_t offset = kFirstMetadataHeaderLength + key_count_ * bytes_per_record_; check_minimum_length(offset + kSecondMetadataHeaderLength); // Read offset-based metadata fields bucket_count_ = endian::load_big_u64(address + offset); offset += kBucketCountLength; bucket_size_ = endian::load_big_u16(address + offset); offset += kBucketSizeLength; const uint16_t leaf_size = endian::load_big_u16(address + offset); SILKWORM_ASSERT(leaf_size == LEAF_SIZE); offset += kLeafSizeLength; // Read salt salt_ = endian::load_big_u32(address + offset); offset += kSaltSizeLength; hasher_ = std::make_unique(salt_); // Read start seed const uint8_t start_seed_length = (address + offset)[0]; offset += kStartSeedSizeLength; SILKWORM_ASSERT(start_seed_length == kStartSeed.size()); check_minimum_length(offset + start_seed_length * sizeof(uint64_t)); std::array start_seed{}; for (size_t i{0}; i < start_seed_length; ++i) { start_seed[i] = endian::load_big_u64(address + offset); offset += sizeof(uint64_t); } SILKWORM_ASSERT(start_seed == kStartSeed); // Read features flag (see RecSplitFeatures) check_minimum_length(offset + kFeaturesFlagLength); const RecSplitFeatures features{(address + offset)[0]}; check_supported_features(features); double_enum_index_ = (features & RecSplitFeatures::kEnums) != RecSplitFeatures::kNone; less_false_positives_ = (features & RecSplitFeatures::kLessFalsePositives) != RecSplitFeatures::kNone; offset += kFeaturesFlagLength; if (double_enum_index_ && key_count_ > 0) { check_minimum_length(offset + kEliasFano32CountLength + kEliasFano32ULength); // Read Elias-Fano index for offsets auto ef_offsets = EliasFano::from_encoded_data(encoded_file_->region().subspan(offset)); offset += ef_offsets.encoded_data_size(); ef_offsets_ = std::make_unique(std::move(ef_offsets)); if (less_false_positives_) { // Read 1-byte-per-key existence filter used to reduce false positives const uint64_t filter_size = endian::load_big_u64(address + offset); offset += kExistenceFilterSizeLength; if (filter_size != key_count_) { throw std::runtime_error{ "Incompatible index format: existence filter length " + std::to_string(filter_size) + " != key count " + std::to_string(key_count_)}; } std::span filter_data{address + offset, filter_size}; existence_filter_.resize(filter_size); std::copy(filter_data.begin(), filter_data.end(), existence_filter_.data()); offset += filter_size; } } // Read the number of Golomb-Rice code params check_minimum_length(offset + kGolombParamSizeLength); const uint16_t golomb_param_size = endian::load_big_u16(address + offset); golomb_param_max_index_ = golomb_param_size - 1; offset += kGolombParamSizeLength; MemoryMappedInputStream mmis{encoded_file_->region().subspan(offset)}; // Read Golomb-Rice codes mmis >> golomb_rice_codes_; offset += sizeof(uint64_t) + golomb_rice_codes_.size() * sizeof(uint64_t); // Read double Elias-Fano code for bucket cumulative keys and bit positions mmis >> double_ef_index_; offset += 5 * sizeof(uint64_t) + double_ef_index_.data().size() * sizeof(uint64_t); SILKWORM_ASSERT(offset == encoded_file_->size()); encoded_file_->advise_random(); // Prevent any new key addition built_ = true; } RecSplit(RecSplit&&) = default; RecSplit& operator=(RecSplit&&) noexcept = default; void add_key(const Hash128& key_hash, uint64_t offset) { if (built_) { throw std::logic_error{"cannot add key after perfect hash function has been built"}; } uint64_t bucket_id = hash128_to_bucket(key_hash); auto bucket_key = key_hash.second; building_strategy_->add_key(bucket_id, bucket_key, offset); // Write first byte for each hashed key into the existence filter (if any) if (less_false_positives_) { building_strategy_->add_to_existence_filter(static_cast(key_hash.first)); } } void add_key(ByteView key, uint64_t offset) { if (built_) { throw std::logic_error{"cannot add key after perfect hash function has been built"}; } const auto key_hash = murmur_hash_3(key); add_key(key_hash, offset); } void add_key(const std::string& key, uint64_t offset) { add_key(string_view_to_byte_view(key), offset); } //! Build the MPHF using the RecSplit algorithm and save the resulting index file //! \warning duplicate keys will cause this method to never return [[nodiscard]] bool build() { if (built_) { throw std::logic_error{"perfect hash function already built"}; } if (building_strategy_->keys_added() != key_count_) { throw std::logic_error{"keys expected: " + std::to_string(key_count_) + " added: " + std::to_string(building_strategy_->keys_added())}; } const auto tmp_index_path{std::filesystem::path{index_path_}.concat(".tmp")}; std::ofstream index_output_stream{tmp_index_path, std::ios::binary}; SILK_TRACE << "[index] creating temporary index file: " << tmp_index_path.string(); // Write minimal app-specific data ID in the index file Bytes uint64_buffer(8, '\0'); endian::store_big_u64(uint64_buffer.data(), base_data_id_); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); SILK_TRACE << "[index] written base data ID: " << base_data_id_; // Write number of keys endian::store_big_u64(uint64_buffer.data(), building_strategy_->keys_added()); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); SILK_TRACE << "[index] written number of keys: " << building_strategy_->keys_added(); // Write number of bytes per index record bytes_per_record_ = gsl::narrow((std::bit_width(building_strategy_->max_offset()) + 7) / 8); index_output_stream.write(reinterpret_cast(&bytes_per_record_), sizeof(uint8_t)); SILK_TRACE << "[index] written bytes per record: " << int{bytes_per_record_}; SILK_TRACE << "[index] calculating file=" << index_path_.string(); // Compute Minimal Perfect Hash Function using RecSplit algorithm and write table: mph-output -> ordinal const bool collision = building_strategy_->build_mph_index(index_output_stream, golomb_rice_codes_, golomb_param_max_index_, double_ef_index_, bytes_per_record_); if (collision) return true; // Compute optional additional table: ordinal -> offset if (double_enum_index_) { building_strategy_->build_enum_index(ef_offsets_builder_); } built_ = true; // Write out bucket count, bucket size, leaf size endian::store_big_u64(uint64_buffer.data(), bucket_count_); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); SILK_TRACE << "[index] written bucket count: " << bucket_count_; endian::store_big_u16(uint64_buffer.data(), bucket_size_); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint16_t)); SILK_TRACE << "[index] written bucket size: " << bucket_size_; endian::store_big_u16(uint64_buffer.data(), LEAF_SIZE); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint16_t)); SILK_TRACE << "[index] written leaf size: " << LEAF_SIZE; // Write out salt endian::store_big_u32(uint64_buffer.data(), salt_); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint32_t)); SILK_TRACE << "[index] written murmur3 salt: " << salt_ << " [" << to_hex(uint64_buffer) << "]"; // Write out start seeds constexpr uint8_t kStartSeedLength = kStartSeed.size(); index_output_stream.write(reinterpret_cast(&kStartSeedLength), sizeof(uint8_t)); SILK_TRACE << "[index] written start seed length: " << int{kStartSeedLength}; for (const uint64_t s : kStartSeed) { endian::store_big_u64(uint64_buffer.data(), s); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint64_t)); } SILK_TRACE << "[index] written start seed: first=" << kStartSeed[0] << " last=" << kStartSeed[kStartSeed.size() - 1]; // Write out the features flag RecSplitFeatures features{RecSplitFeatures::kNone}; if (double_enum_index_) { features = features | RecSplitFeatures::kEnums; if (less_false_positives_) { features = features | RecSplitFeatures::kLessFalsePositives; } } const auto features_flag = static_cast(features); index_output_stream.write(reinterpret_cast(&features_flag), sizeof(uint8_t)); // Write out Elias-Fano code for offsets (if any) if (double_enum_index_) { index_output_stream << *ef_offsets_builder_; SILK_TRACE << "[index] written EF code for offsets [size: " << ef_offsets_builder_->size() << "]"; // Write out existence filter (if any) if (less_false_positives_) { building_strategy_->flush_existence_filter(uint64_buffer, index_output_stream); } } // Write out the number of Golomb-Rice codes used i.e. the max index used plus one endian::store_big_u16(uint64_buffer.data(), golomb_param_max_index_ + 1); // Erigon writes 4-instead-of-2 bytes here: 2 spurious come from previous buffer content, i.e. last seed value index_output_stream.write(reinterpret_cast(uint64_buffer.data()), sizeof(uint32_t)); SILK_TRACE << "[index] written GR params count: " << golomb_param_max_index_ + 1 << " code size: " << golomb_rice_codes_.size(); // Write out Golomb-Rice code index_output_stream << golomb_rice_codes_; // Write out Elias-Fano code for bucket cumulative keys and bit positions index_output_stream << double_ef_index_; index_output_stream.close(); SILK_TRACE << "[index] renaming " << tmp_index_path.string() << " as " << index_path_.string(); std::filesystem::rename(tmp_index_path, index_path_); return false; } void build_without_collisions(absl::FunctionRef&)> populate) { for (uint64_t iteration = 0; iteration < 10; ++iteration) { populate(*this); SILK_TRACE << "RecSplit::build..." << " iteration=" << iteration; bool collision_detected = build(); SILK_TRACE << "RecSplit::build done" << " iteration=" << iteration; if (collision_detected) { SILK_DEBUG << "RecSplit::build collision"; reset_new_salt(); } else { return; } } throw std::runtime_error{"RecSplit::build_without_collisions: abort after max iterations"}; } void reset_new_salt() { built_ = false; building_strategy_->clear(); ++salt_; hasher_->reset_seed(salt_); } //! Check if the given bucket hash is present as i-th element in the index //! \return true if hash is present as i-th element, false otherwise bool has(const Hash128& hash, size_t i) const { if (less_false_positives_ && i < existence_filter_.size()) { return existence_filter_.at(i) == static_cast(hash.first); } // If existence filter not applicable, default is true: MPHF has no presence indicator return true; } //! Return the value associated with the given 128-bit bucket hash //! \param hash a 128-bit bucket hash //! \return the associated value size_t operator()(const Hash128& hash) const { ensure(built_, "RecSplit: perfect hash function not built yet"); ensure(key_count_ > 0, "RecSplit: invalid lookup with zero keys, use empty() to guard"); if (key_count_ == 1) { return 0; } const size_t bucket = hash128_to_bucket(hash); uint64_t cum_keys{0}, cum_keys_next{0}, bit_pos{0}; double_ef_index_.get3(bucket, cum_keys, cum_keys_next, bit_pos); // Number of keys in this bucket size_t m = cum_keys_next - cum_keys; auto reader = golomb_rice_codes_.reader(); reader.read_reset(bit_pos, skip_bits(m)); int level = 0; while (m > kUpperAggregationBound) { // fanout = 2 const auto d = reader.read_next(golomb_param(m, kMemo)); const size_t hmod = remap16(remix(hash.second + d + kStartSeed[level]), m); const size_t split = ((static_cast((m + 1) / 2 + kUpperAggregationBound - 1) / kUpperAggregationBound)) * kUpperAggregationBound; if (hmod < split) { m = split; } else { reader.skip_subtree(skip_nodes(split), skip_bits(split)); m -= split; cum_keys += split; } ++level; } if (m > kLowerAggregationBound) { const auto d = reader.read_next(golomb_param(m, kMemo)); const size_t hmod = remap16(remix(hash.second + d + kStartSeed[level]), m); const int part = static_cast(hmod) / kLowerAggregationBound; m = std::min(kLowerAggregationBound, m - part * kLowerAggregationBound); cum_keys += kLowerAggregationBound * part; if (part) reader.skip_subtree(skip_nodes(kLowerAggregationBound) * part, skip_bits(kLowerAggregationBound) * part); ++level; } if (m > LEAF_SIZE) { const auto d = reader.read_next(golomb_param(m, kMemo)); const size_t hmod = remap16(remix(hash.second + d + kStartSeed[level]), m); const int part = static_cast(hmod) / LEAF_SIZE; m = std::min(LEAF_SIZE, m - part * LEAF_SIZE); cum_keys += LEAF_SIZE * part; if (part) reader.skip_subtree(part, skip_bits(LEAF_SIZE) * part); ++level; } const auto b = reader.read_next(golomb_param(m, kMemo)); return cum_keys + remap16(remix(hash.second + b + kStartSeed[level]), m); } //! Return the value associated with the given key within the MPHF mapping size_t operator()(ByteView key) const { return operator()(murmur_hash_3(key)); } //! Return the value associated with the given key within the MPHF mapping size_t operator()(const std::string& key) const { return operator()(string_view_to_byte_view(key)); } /** * If RecSplitFeatures::kEnums (double_enum_index_) is enabled * Ordinal is an index of an item from the [0, key_count()) interval. * It is output of MPHF mapping, and input to the EF mapping: * - MPHF(key) = ordinal; * - EF(ordinal) = value (offset); * It can be converted to "data id" using base_data_id(): * data_id = base_data_id + ordinal * * If RecSplitFeatures::kEnums (double_enum_index_) is disabled * Ordinal is just the value (offset) output of MPHF mapping: * - MPHF(key) = value (offset) = ordinal; * In this case base_data_id() is not applicable. */ struct Ordinal { uint64_t value{0}; }; //! Return the value associated with the given key within the index std::optional lookup_ordinal_by_key(const std::string& key) const { return lookup_ordinal_by_key(string_view_to_byte_view(key)); } //! Return the value associated with the given key within the index std::optional lookup_ordinal_by_key(ByteView key) const { const Hash128& hashed_key{murmur_hash_3(key)}; const auto record = operator()(hashed_key); const auto position = 1 + 8 + bytes_per_record_ * (record + 1); const auto region = encoded_file_->region(); ensure(position + sizeof(uint64_t) < region.size(), [&]() { return "position: " + std::to_string(position) + " plus 8 exceeds file length"; }); const auto value = endian::load_big_u64(region.data() + position) & record_mask_; if (less_false_positives_ && (value < existence_filter_.size()) && (existence_filter_.at(value) != static_cast(hashed_key.first))) { return std::nullopt; } return Ordinal{value}; } //! Return the offset of the i-th element in the index. Perfect hash table lookup is not performed, //! only access to the Elias-Fano structure containing all offsets size_t lookup_by_ordinal(Ordinal ord) const { SILKWORM_ASSERT(double_enum_index_); return ef_offsets_->at(ord.value); } std::optional lookup_data_id_by_key(ByteView key) const { SILKWORM_ASSERT(double_enum_index_); auto ord = lookup_ordinal_by_key(key); return ord ? std::optional{ord->value + base_data_id()} : std::nullopt; } std::optional lookup_by_data_id(uint64_t data_id) const { // check if data_id is not out of range uint64_t min = base_data_id(); uint64_t max = min + key_count() - 1; if ((data_id < min) || (data_id > max)) { return std::nullopt; } return lookup_by_ordinal(Ordinal{data_id - base_data_id()}); } std::optional lookup_by_key(ByteView key) const { auto ord = lookup_ordinal_by_key(key); if (!ord) return std::nullopt; return double_enum_index_ ? lookup_by_ordinal(*ord) : ord->value; } //! Return the number of keys used to build the RecSplit instance size_t key_count() const { return key_count_; } bool empty() const { return key_count_ == 0; } uint64_t base_data_id() const { return base_data_id_; } uint64_t record_mask() const { return record_mask_; } uint64_t bucket_count() const { return bucket_count_; } uint16_t bucket_size() const { return bucket_size_; } bool double_enum_index() const { return double_enum_index_; } bool less_false_positives() const { return less_false_positives_; } //! Return the presence filter for the index. It can be empty if less false-positives feature is not enabled std::vector existence_filter() const { return existence_filter_; } size_t file_size() const { return std::filesystem::file_size(index_path_); } std::filesystem::file_time_type last_write_time() const { return std::filesystem::last_write_time(index_path_); } MemoryMappedRegion memory_file_region() const { return encoded_file_ ? encoded_file_->region() : MemoryMappedRegion{}; } private: static size_t skip_bits(size_t m) { return kMemo[m] & 0xFFFF; } static size_t skip_nodes(size_t m) { return (kMemo[m] >> 16) & 0x7FF; } static uint64_t golomb_param( const size_t m, const std::array& memo) { return memo[m] >> 27; } static uint64_t golomb_param_with_max_calculation( const size_t m, const std::array& memo, uint16_t& golomb_param_max_index) { if (m > golomb_param_max_index) golomb_param_max_index = gsl::narrow(m); return golomb_param(m, memo); } //! Generate the precomputed table of 32-bit values holding the Golomb-Rice code of a splitting (upper 5 bits), //! the number of nodes in the associated subtree (following 11 bits) and the sum of the Golomb-Rice code lengths //! in the same subtree (lower 16 bits) static constexpr void precompute_golomb_rice(const int m, std::array* memo) { std::array k{0}; const auto [fanout, unit] = SplitStrategy::split_params(m); k[fanout - 1] = m; for (size_t i{0}; i < fanout - 1; ++i) { k[i] = unit; k[fanout - 1] -= k[i]; } double sqrt_prod = 1; for (size_t i{0}; i < fanout; ++i) { sqrt_prod *= sqrt(k[i]); } const double p = sqrt(m) / (pow(2 * std::numbers::pi, (static_cast(fanout) - 1.) * 0.5) * sqrt_prod); std::integral auto golomb_rice_length = math::int_ceil(log2(-std::log((sqrt(5) + 1) * 0.5) / log1p(-p))); // log2 Golomb modulus SILKWORM_ASSERT(golomb_rice_length <= 0x1F); // Golomb-Rice code, stored in the 5 upper bits (*memo)[m] = golomb_rice_length << 27; for (size_t i{0}; i < fanout; ++i) { golomb_rice_length += (*memo)[k[i]] & 0xFFFF; } SILKWORM_ASSERT(golomb_rice_length <= 0xFFFF); // Sum of Golomb-Rice code lengths in the subtree, stored in the lower 16 bits (*memo)[m] |= golomb_rice_length; uint32_t nodes = 1; for (size_t i{0}; i < fanout; ++i) { nodes += ((*memo)[k[i]] >> 16) & 0x7FF; } SILKWORM_ASSERT(LEAF_SIZE < 3 || nodes <= 0x7FF); // Number of nodes in the subtree, stored in the middle 11 bits (*memo)[m] |= nodes << 16; } static constexpr std::array fill_golomb_rice() { std::array memo{0}; size_t s{0}; for (; s <= LEAF_SIZE; ++s) { memo[s] = kBijMemo[s] << 27 | (s > 1) << 16 | kBijMemo[s]; } for (; s < kMaxBucketSize; ++s) { precompute_golomb_rice(static_cast(s), &memo); } return memo; } //! Apply the RecSplit algorithm to the given bucket template static void recsplit(std::vector& keys, std::vector& offsets, std::vector& buffer_keys, // temporary buffer for keys std::vector& buffer_offsets, // temporary buffer for offsets GRBuilder& gr_builder, std::ostream& index_ofs, uint16_t& golomb_param_max_index, uint8_t bytes_per_record) { recsplit(/*.level=*/0, keys, offsets, buffer_keys, buffer_offsets, /*.start=*/0, /*.end=*/keys.size(), gr_builder, index_ofs, golomb_param_max_index, bytes_per_record); } template static void recsplit(int level, // NOLINT std::vector& keys, std::vector& offsets, // aka values std::vector& buffer_keys, // temporary buffer for keys std::vector& buffer_offsets, // temporary buffer for offsets size_t start, size_t end, GRBuilder& gr_builder, std::ostream& index_ofs, uint16_t& golomb_param_max_index, uint8_t bytes_per_record) { uint64_t salt = kStartSeed[level]; const size_t m = end - start; SILKWORM_ASSERT(m > 1); if (m <= LEAF_SIZE) { // No need to build aggregation levels - just find bijection SILK_TRACE << "[index] recsplit level " << level << ", m=" << m << " < leaf size, just find bijection"; if (level == 7) { SILK_TRACE << "[index] recsplit m: " << m << " salt: " << salt << " start: " << start << " bucket[start]=" << keys[start]; for (size_t j = 0; j < m; ++j) { SILK_TRACE << "[index] buffer m: " << m << " start: " << start << " j: " << j << " bucket[start + j]=" << keys[start + j]; } } while (true) { uint32_t mask{0}; bool fail{false}; for (uint16_t i{0}; !fail && i < m; ++i) { uint32_t bit = uint32_t{1} << remap16(remix(keys[start + i] + salt), m); if ((mask & bit) != 0) { fail = true; } else { mask |= bit; } } if (!fail) break; ++salt; } for (size_t i{0}; i < m; ++i) { size_t j = remap16(remix(keys[start + i] + salt), m); buffer_offsets[j] = offsets[start + i]; } Bytes uint64_buffer(8, '\0'); for (size_t i{0}; i < m; ++i) { endian::store_big_u64(uint64_buffer.data(), buffer_offsets[i]); index_ofs.write(reinterpret_cast(uint64_buffer.data() + (8 - bytes_per_record)), bytes_per_record); if (level == 0) { SILK_TRACE << "[index] written offset: " << buffer_offsets[i]; } } salt -= kStartSeed[level]; const auto log2golomb = golomb_param_with_max_calculation(m, kMemo, golomb_param_max_index); gr_builder.append_fixed(salt, log2golomb); gr_builder.append_unary(static_cast(salt >> log2golomb)); } else { const auto [fanout, unit] = SplitStrategy::split_params(m); SILK_TRACE << "[index] recsplit level " << level << ", m=" << m << " > leaf size, fanout=" << fanout << " unit=" << unit; SILKWORM_ASSERT(fanout <= kLowerAggregationBound); std::vector count(fanout, 0); // temporary counters of key remapped occurrences while (true) { std::fill(count.begin(), count.end(), 0); for (size_t i{0}; i < m; ++i) { ++count[static_cast(remap16(remix(keys[start + i] + salt), m)) / unit]; } bool broken{false}; for (size_t i = 0; i < fanout - 1; ++i) { broken = broken || (count[i] != unit); } if (!broken) break; ++salt; } for (size_t i{0}, c{0}; i < fanout; ++i, c += unit) { count[i] = c; } for (size_t i{0}; i < m; ++i) { auto j = static_cast(remap16(remix(keys[start + i] + salt), m)) / unit; buffer_keys[count[j]] = keys[start + i]; buffer_offsets[count[j]] = offsets[start + i]; ++count[j]; } std::copy(buffer_keys.data(), buffer_keys.data() + m, keys.data() + start); std::copy(buffer_offsets.data(), buffer_offsets.data() + m, offsets.data() + start); salt -= kStartSeed[level]; const auto log2golomb = golomb_param_with_max_calculation(m, kMemo, golomb_param_max_index); gr_builder.append_fixed(salt, log2golomb); gr_builder.append_unary(static_cast(salt >> log2golomb)); size_t i{0}; for (; i < m - unit; i += unit) { recsplit(level + 1, keys, offsets, buffer_keys, buffer_offsets, start + i, start + i + unit, gr_builder, index_ofs, golomb_param_max_index, bytes_per_record); } if (m - i > 1) { recsplit(level + 1, keys, offsets, buffer_keys, buffer_offsets, start + i, end, gr_builder, index_ofs, golomb_param_max_index, bytes_per_record); } else if (m - i == 1) { Bytes uint64_buffer(8, '\0'); endian::store_big_u64(uint64_buffer.data(), offsets[start + i]); index_ofs.write(reinterpret_cast(uint64_buffer.data() + (8 - bytes_per_record)), bytes_per_record); if (level == 0) { SILK_TRACE << "[index] written offset: " << offsets[start + i]; } } } } Hash128 murmur_hash_3(ByteView data) const { Hash128 h{}; hasher_->hash_x64_128(data.data(), data.size(), &h); return h; } //! Maps a 128-bit to a bucket using the first 64-bit half uint64_t hash128_to_bucket(const Hash128& hash) const { return remap128(hash.first, bucket_count_); } void check_minimum_length(size_t minimum_length) { if (encoded_file_ && encoded_file_->size() < minimum_length) { throw std::runtime_error("index " + encoded_file_->path().filename().string() + " is too short: " + std::to_string(encoded_file_->size()) + " < " + std::to_string(minimum_length)); } } void check_supported_features(RecSplitFeatures features) { for (const auto supported_feature : kSupportedFeatures) { features = features & ~supported_feature; } if (RecSplitFeatures{features} != RecSplitFeatures::kNone) { throw std::runtime_error("index " + encoded_file_->path().filename().string() + " has unsupported features: " + std::to_string(static_cast(features))); } } friend std::ostream& operator<<(std::ostream& os, const RecSplit& rs) { size_t leaf_size = LEAF_SIZE; os.write(reinterpret_cast(&leaf_size), sizeof(leaf_size)); os.write(reinterpret_cast(&rs.bucket_size_), sizeof(rs.bucket_size_)); os.write(reinterpret_cast(&rs.key_count_), sizeof(rs.key_count_)); os << rs.golomb_rice_codes_; os << rs.double_ef_index_; return os; } friend std::istream& operator>>(std::istream& is, RecSplit& rs) { size_t leaf_size{0}; is.read(reinterpret_cast(&leaf_size), sizeof(leaf_size)); SILKWORM_ASSERT(leaf_size == LEAF_SIZE); is.read(reinterpret_cast(&rs.bucket_size_), sizeof(rs.bucket_size_)); is.read(reinterpret_cast(&rs.key_count_), sizeof(rs.key_count_)); rs.bucket_count_ = std::max(size_t{1}, (rs.key_count_ + rs.bucket_size_ - 1) / rs.bucket_size_); is >> rs.golomb_rice_codes_; is >> rs.double_ef_index_; return is; } static const size_t kLowerAggregationBound; static const size_t kUpperAggregationBound; //! The max index used in Golomb parameter array uint16_t golomb_param_max_index_{0}; //! For each bucket size, the Golomb-Rice parameter (upper 8 bits) and the number of bits to //! skip in the fixed part of the tree (lower 24 bits). static const std::array kMemo; //! The size in bytes of each Recsplit bucket (possibly except the last one) uint16_t bucket_size_; //! The number of keys for this Recsplit algorithm instance size_t key_count_; //! The number of buckets for this Recsplit algorithm instance size_t bucket_count_; //! The Golomb-Rice (GR) codes of splitting and bijection indices GolombRiceVector golomb_rice_codes_; //! Double Elias-Fano (EF) index for bucket cumulative keys and bit positions DoubleEliasFano double_ef_index_; //! Helper to encode the sequences of key offsets in the single EF code std::unique_ptr ef_offsets_; std::unique_ptr ef_offsets_builder_; //! Minimal app-specific ID of entries in this index - helps understanding what data stored in given shard - persistent field uint64_t base_data_id_; //! The path of the index file generated std::filesystem::path index_path_; //! Number of bytes used per index record uint8_t bytes_per_record_{0}; //! The bitmask to be used to interpret record data uint64_t record_mask_{0}; //! Flag indicating if two-level index "recsplit -> enum" + "enum -> offset" is enabled or not bool double_enum_index_{true}; //! Flag indicating if less false-positives feature is enabled or not bool less_false_positives_{false}; //! The 1-byte per key positional existence filter used to have less false-positives std::vector existence_filter_; //! Flag indicating that the MPHF has been built and no more keys can be added bool built_{false}; //! The offset collector for Elias-Fano encoding of "enum -> offset" index std::vector offsets_; //! Seed for Murmur3 hash used for converting keys to 64-bit values and assigning to buckets uint32_t salt_{0}; //! Murmur3 hash factory std::unique_ptr hasher_; //! The memory-mapped RecSplit-encoded file when opening existing index for read std::optional encoded_file_; std::unique_ptr building_strategy_; }; inline constexpr size_t kLeafSize = 8; using RecSplit8 = RecSplit; template <> const std::array RecSplit8::kMemo; using RecSplitIndex = RecSplit8; } // namespace silkworm::snapshots::rec_split #pragma GCC diagnostic pop ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/rec_split_par.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #if defined(__clang__) #pragma GCC diagnostic ignored "-Winvalid-constexpr" #endif /* defined(__clang__) */ #pragma GCC diagnostic ignored "-Wsign-compare" #include #include "rec_split.hpp" // Check if the vector contains duplicates without altering the original vector order // Used here to check the keys vector (whose elements are related to the elements of values vector at the same index) template bool contains_duplicate(const std::vector& items) { // Create an index vector std::vector indices(items.size()); for (size_t i = 0; i < items.size(); ++i) { indices[i] = i; } // Sort the index vector based on the items std::sort(indices.begin(), indices.end(), [&items](int i1, int i2) { return items[i1] < items[i2]; }); // Check for duplicates using the sorted index vector for (size_t i = 1; i < indices.size(); ++i) { if (items[indices[i]] == items[indices[i - 1]]) { return true; } } return false; // No duplicate found } namespace silkworm::snapshots::rec_split { //! The recsplit parallel building strategy template struct RecSplit::ParallelBuildingStrategy : public BuildingStrategy { explicit ParallelBuildingStrategy(ThreadPool& tp) : thread_pool_{tp} { } protected: class Bucket { public: explicit Bucket(size_t bucket_size) { keys_.reserve(bucket_size); values_.reserve(bucket_size); } Bucket(const Bucket&) = delete; Bucket(Bucket&&) noexcept = default; void clear() { keys_.clear(); values_.clear(); gr_builder_.clear(); index_ofs_.clear(); } private: friend class RecSplit; //! 64-bit fingerprints of keys in the current bucket accumulated before the recsplit is performed for that bucket std::vector keys_; // mike: current_bucket_; -> keys_ //! Index offsets for the current bucket std::vector values_; // mike: current_bucket_offsets_; -> values_ //! Helper to build GR codes of splitting and bijection indices, local to current bucket GolombRiceVector::LazyBuilder gr_builder_; //! The local max index used in Golomb parameter array uint16_t golomb_param_max_index_{0}; //! Helper index output stream std::stringstream index_ofs_{std::ios::in | std::ios::out | std::ios::binary}; }; void setup(const RecSplitSettings& settings, size_t bucket_count) override { double_enum_index_ = settings.double_enum_index; bucket_count_ = bucket_count; // Prepare buckets buckets_.reserve(bucket_count); for (int i = 0; i < bucket_count; ++i) { buckets_.emplace_back(settings.bucket_size); } if (double_enum_index_) { offsets_.reserve(settings.keys_count); } } void add_key(uint64_t bucket_id, uint64_t bucket_key, uint64_t offset) override { ensure(bucket_id < buckets_.size(), "bucket_id out of range"); if (keys_added_ % 100'000 == 0) { SILK_TRACE << "[index] add key hash: bucket_id=" << bucket_id << " bucket_key=" << bucket_key << " offset=" << offset; } max_offset_ = std::max(max_offset_, offset); Bucket& bucket = buckets_[bucket_id]; if (double_enum_index_) { offsets_.push_back(offset); auto current_key_count = keys_added_; bucket.keys_.emplace_back(bucket_key); bucket.values_.emplace_back(current_key_count); } else { bucket.keys_.emplace_back(bucket_key); bucket.values_.emplace_back(offset); } ++keys_added_; } bool build_mph_index( std::ofstream& index_output_stream, GolombRiceVector& golomb_rice_codes, uint16_t& golomb_param_max_index, DoubleEliasFano& double_ef_index, uint8_t bytes_per_record) override { // Find splitting trees for each bucket std::atomic_bool collision{false}; for (auto& bucket : buckets_) { thread_pool_.push_task([&]() noexcept(false) { if (collision) return; // skip work if collision detected bool local_collision = recsplit_bucket(bucket, bytes_per_record); if (local_collision) collision = true; }); } thread_pool_.wait_for_tasks(); if (collision) { SILK_WARN << "[index] collision detected"; return true; } // Store prefix sums of bucket sizes and bit positions std::vector bucket_size_accumulator(this->bucket_count_ + 1); // accumulator for size of every bucket std::vector bucket_position_accumulator(this->bucket_count_ + 1); // accumulator for position of every bucket in the encoding of the hash function bucket_size_accumulator[0] = bucket_position_accumulator[0] = 0; for (size_t i = 0; i < bucket_count_; ++i) { bucket_size_accumulator[i + 1] = bucket_size_accumulator[i] + buckets_[i].keys_.size(); // auto* underlying_buffer = buckets_[i].index_ofs_.rdbuf(); // if (!is_empty(underlying_buffer)) // index_output_stream << underlying_buffer; char byte{0}; while (buckets_[i].index_ofs_.get(byte)) { // maybe it is better to avoid this and use a buffer in place of index_ofs_ index_output_stream.put(byte); } // index_output_stream << buckets_[i].index_ofs_.rdbuf(); // better but fails when rdbuf() is empty if (buckets_[i].keys_.size() > 1) { buckets_[i].gr_builder_.append_to(gr_builder_); } bucket_position_accumulator[i + 1] = gr_builder_.get_bits(); SILKWORM_ASSERT(bucket_size_accumulator[i + 1] >= bucket_size_accumulator[i]); SILKWORM_ASSERT(bucket_position_accumulator[i + 1] >= bucket_position_accumulator[i]); golomb_param_max_index = std::max(golomb_param_max_index, buckets_[i].golomb_param_max_index_); } gr_builder_.append_fixed(1, 1); // Sentinel (avoids checking for parts of size 1) // Concatenate the representation of each bucket golomb_rice_codes = gr_builder_.build(); // Construct double Elias-Fano index for bucket cumulative keys and bit positions std::vector cumulative_keys{bucket_size_accumulator.begin(), bucket_size_accumulator.end()}; std::vector positions(bucket_position_accumulator.begin(), bucket_position_accumulator.end()); double_ef_index.build(cumulative_keys, positions); return false; // no collision } void build_enum_index(std::unique_ptr& ef_offsets) override { // Build Elias-Fano index for offsets (if any) std::sort(offsets_.begin(), offsets_.end()); ef_offsets = std::make_unique(keys_added_, max_offset_); for (auto offset : offsets_) { ef_offsets->add_offset(offset); } ef_offsets->build(); } //! Compute and store the splittings and bijections of the current bucket // It would be better to make this function a member of Bucket static bool recsplit_bucket(Bucket& bucket, uint8_t bytes_per_record) { // Sets of size 0 and 1 are not further processed, just write them to index if (bucket.keys_.size() > 1) { if (contains_duplicate(bucket.keys_)) { SILK_TRACE << "collision detected"; return true; } std::vector buffer_keys; // temporary buffer for keys std::vector buffer_offsets; // temporary buffer for offsets buffer_keys.resize(bucket.keys_.size()); buffer_offsets.resize(bucket.values_.size()); RecSplit::recsplit( bucket.keys_, bucket.values_, buffer_keys, buffer_offsets, bucket.gr_builder_, bucket.index_ofs_, bucket.golomb_param_max_index_, bytes_per_record); } else { for (const auto offset : bucket.values_) { Bytes uint64_buffer(8, '\0'); endian::store_big_u64(uint64_buffer.data(), offset); bucket.index_ofs_.write(reinterpret_cast(uint64_buffer.data()), 8); SILK_TRACE << "[index] written offset: " << offset; } } return false; } void clear() override { offsets_.clear(); for (auto& bucket : buckets_) { bucket.clear(); } keys_added_ = 0; max_offset_ = 0; } uint64_t keys_added() override { return keys_added_; } uint64_t max_offset() override { return max_offset_; } //! The thread pool used for parallel processing ThreadPool& thread_pool_; //! Flag indicating if two-level index "recsplit -> enum" + "enum -> offset" is required bool double_enum_index_{false}; //! Maximum value of offset used to decide how many bytes to use for Elias-Fano encoding uint64_t max_offset_{0}; //! The number of keys currently added uint64_t keys_added_{0}; //! The number of buckets for this Recsplit algorithm instance size_t bucket_count_{0}; //! The buckets of the RecSplit algorithm std::vector buckets_; //! The offset collector for Elias-Fano encoding of "enum -> offset" index std::vector offsets_; //! Helper to build GR codes of splitting and bijection indices GolombRiceBuilder gr_builder_; }; inline auto par_build_strategy(ThreadPool& tp) { return std::make_unique(tp); } /* Example usage: RecSplit8 recsplit{RecSplitSettings{}, par_build_strategy(thread_pool)}; auto collision = recsplit.build(); */ } // namespace silkworm::snapshots::rec_split #pragma GCC diagnostic pop ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/rec_split_par_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rec_split_par.hpp" #include // for std::setw and std::setfill #include #include #include #include #include "test_util/xoroshiro128pp.hpp" namespace silkworm::snapshots::rec_split { using silkworm::test_util::TemporaryFile; using test_util::next_pseudo_random; // Exclude tests from Windows build due to access issues with files in OS temporary dir #ifndef _WIN32 //! Make the MPHF predictable just for testing static constexpr int kTestSalt{1}; TEST_CASE("RecSplit8-Par: key_count=0", "[silkworm][node][recsplit]") { TemporaryFile index_file; ThreadPool thread_pool{2}; RecSplitSettings settings{ .keys_count = 0, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs{settings, par_build_strategy(thread_pool), /*.salt=*/kTestSalt}; CHECK_THROWS_AS(rs.build(), std::logic_error); CHECK_THROWS_AS(rs("first_key"), std::logic_error); } TEST_CASE("RecSplit8-Par: key_count=1", "[silkworm][node][recsplit]") { TemporaryFile index_file; ThreadPool thread_pool{2}; RecSplitSettings settings{ .keys_count = 1, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs{settings, par_build_strategy(thread_pool), /*.salt=*/kTestSalt}; CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK_NOTHROW(rs.build()); CHECK_NOTHROW(rs("first_key")); } TEST_CASE("RecSplit8-Par key_count=2", "[silkworm][node][recsplit]") { TemporaryFile index_file; ThreadPool thread_pool{2}; RecSplitSettings settings{ .keys_count = 2, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs{settings, par_build_strategy(thread_pool), /*.salt=*/kTestSalt}; SECTION("keys") { CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK_THROWS_AS(rs.build(), std::logic_error); CHECK_THROWS_AS(rs("first_key"), std::logic_error); CHECK_NOTHROW(rs.add_key("second_key", 0)); CHECK(rs.build() == false /*collision_detected*/); CHECK_NOTHROW(rs("first_key")); CHECK_NOTHROW(rs("second_key")); } SECTION("duplicated keys") { CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK(rs.build() == true /*collision_detected*/); } } template static void check_bijection(RS& rec_split, const std::vector& keys) { // RecSplit implements a MPHF K={k1...kN} -> V={0..N-1} so we must check all codomain is exhausted std::vector recsplit_values(keys.size()); // Fill the codomain values w/ zero, so we can easily check if a value is already used or not std::fill(recsplit_values.begin(), recsplit_values.end(), 0); uint64_t i{0}; for (const auto& k : keys) { uint64_t v = rec_split(k); // Value associated to key in RecSplit must be unique (perfect: no collision) CHECK(recsplit_values[v] == 0); // Mark the value as used in codomain recsplit_values[v] = ++i; } // All codomain values must be used (minimal: rank(K) == rank(V)) for (const auto& v : recsplit_values) { CHECK(v != 0); } } static constexpr int kTestLeaf{4}; using RecSplit4 = RecSplit; template <> const size_t RecSplit4::kLowerAggregationBound; template <> const size_t RecSplit4::kUpperAggregationBound; template <> const std::array RecSplit4::kMemo; auto par_build_strategy_4(ThreadPool& tp) { return std::make_unique(tp); } TEST_CASE("RecSplit4-Par: keys=1000 buckets=128", "[silkworm][node][recsplit]") { TemporaryFile index_file; ThreadPool thread_pool{2}; constexpr int kTestNumKeys{1'000}; constexpr int kTestBucketSize{128}; std::vector hashed_keys; for (size_t i{0}; i < kTestNumKeys; ++i) { hashed_keys.push_back({next_pseudo_random(), next_pseudo_random()}); } RecSplitSettings settings{ .keys_count = hashed_keys.size(), .bucket_size = kTestBucketSize, .index_path = index_file.path(), .base_data_id = 0}; RecSplit4 rs{settings, par_build_strategy_4(thread_pool), /*.salt=*/kTestSalt}; SECTION("random_hash128 KO: not built") { for (const auto& hk : hashed_keys) { rs.add_key(hk, 0); } // RecSplit not built implies operator() must raise an exception for (const auto& hk : hashed_keys) { CHECK_THROWS_AS(rs(hk), std::logic_error); } } SECTION("random_hash128 OK") { for (const auto& hk : hashed_keys) { rs.add_key(hk, 0); } CHECK(rs.build() == false /*collision_detected*/); check_bijection(rs, hashed_keys); } } TEST_CASE("RecSplit4-Par: multiple keys-buckets", "[silkworm][node][recsplit]") { TemporaryFile index_file; ThreadPool thread_pool{2}; struct RecSplitParams { size_t key_count{0}; uint16_t bucket_size{0}; }; std::vector recsplit_params_sequence{ {1'000, 128}, {5'000, 512}, {10'000, 1024}, {20'000, 2048}, {40'000, 2048}, }; for (const auto [key_count, bucket_size] : recsplit_params_sequence) { SECTION("random_hash128 OK [" + std::to_string(key_count) + "-" + std::to_string(bucket_size) + "]") { // NOLINT std::vector hashed_keys; for (size_t i{0}; i < key_count; ++i) { hashed_keys.push_back({next_pseudo_random(), next_pseudo_random()}); } RecSplitSettings settings{ .keys_count = key_count, .bucket_size = bucket_size, .index_path = index_file.path(), .base_data_id = 0}; RecSplit4 rs{settings, par_build_strategy_4(thread_pool), /*.salt=*/kTestSalt}; for (const auto& hk : hashed_keys) { rs.add_key(hk, 0); } CHECK(rs.build() == false /*collision_detected*/); check_bijection(rs, hashed_keys); RecSplit4 rs_index{index_file.path()}; CHECK(rs.base_data_id() == settings.base_data_id); CHECK(rs.key_count() == settings.keys_count); CHECK(rs.empty() == !settings.keys_count); CHECK(rs.record_mask() == 0); CHECK(rs.bucket_count() == (settings.keys_count + settings.bucket_size - 1) / settings.bucket_size); CHECK(rs.bucket_size() == settings.bucket_size); check_bijection(rs_index, hashed_keys); } } } #ifdef SILKWORM_TEST_SKIP TEST_CASE("RecSplit8-Par: index lookup", "[silkworm][node][recsplit]") { TemporaryFile index_file; ThreadPool thread_pool{2}; RecSplitSettings settings{ .keys_count = 100, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0, .double_enum_index = false}; RecSplit8 rs1{settings, par_build_strategy(thread_pool), /*.salt=*/kTestSalt}; for (size_t i{0}; i < settings.keys_count; ++i) { rs1.add_key("key " + std::to_string(i), i * 17); } CHECK(rs1.build() == false /*collision_detected*/); RecSplit8 rs2{settings.index_path}; for (size_t i{0}; i < settings.keys_count; ++i) { const std::string key{"key " + std::to_string(i)}; CHECK(rs2.lookup(key) == RecSplit8::LookupResult{i * 17, true}); } } #endif // SILKWORM_TEST_SKIP #ifdef SILKWORM_TEST_SKIP TEST_CASE("RecSplit8-Par: double index lookup", "[silkworm][node][recsplit]") { TemporaryFile index_file; ThreadPool thread_pool{2}; RecSplitSettings settings{ .keys_count = 100, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs1{settings, par_build_strategy(thread_pool), /*.salt=*/kTestSalt}; for (size_t i{0}; i < settings.keys_count; ++i) { rs1.add_key("key " + std::to_string(i), i * 17); } CHECK(rs1.build() == false /*collision_detected*/); RecSplit8 rs2{settings.index_path}; for (size_t i{0}; i < settings.keys_count; ++i) { const auto enumeration_index = rs2.lookup_ordinal_by_key("key " + std::to_string(i)); REQUIRE(enumeration_index); CHECK(enumeration_index == i); CHECK(rs2.lookup_by_ordinal(enumeration_index) == i * 17); } } #endif #endif // _WIN32 } // namespace silkworm::snapshots::rec_split ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/rec_split_seq.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* * Sux: Succinct data structures * * Copyright (C) 2019-2020 Emmanuel Esposito and Sebastiano Vigna * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 3, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. * * Under Section 7 of GPL version 3, you are granted additional permissions * described in the GCC Runtime Library Exception, version 3.1, as published by * the Free Software Foundation. * * You should have received a copy of the GNU General Public License and a copy of * the GCC Runtime Library Exception along with this program; see the files * COPYING3 and COPYING.RUNTIME respectively. If not, see * . */ #pragma once #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #if defined(__clang__) #pragma GCC diagnostic ignored "-Winvalid-constexpr" #endif /* defined(__clang__) */ #pragma GCC diagnostic ignored "-Wsign-compare" #include #include "rec_split.hpp" namespace silkworm::snapshots::rec_split { //! The recsplit sequential building strategy template struct RecSplit::SequentialBuildingStrategy : public BuildingStrategy { explicit SequentialBuildingStrategy(size_t etl_optimal_size) : etl_optimal_size_{etl_optimal_size} {} protected: void setup(const RecSplitSettings& settings, size_t bucket_count) override { offset_collector_ = std::make_unique(etl_optimal_size_); bucket_collector_ = std::make_unique(etl_optimal_size_); bucket_size_accumulator_.reserve(bucket_count + 1); bucket_position_accumulator_.reserve(bucket_count + 1); bucket_size_accumulator_.resize(1); // Start with 0 as bucket accumulated size bucket_position_accumulator_.resize(1); // Start with 0 as bucket accumulated position current_bucket_.reserve(settings.bucket_size); current_bucket_offsets_.reserve(settings.bucket_size); double_enum_index_ = settings.double_enum_index; } void add_key(uint64_t bucket_id, uint64_t bucket_key, uint64_t offset) override { if (keys_added_ % 100'000 == 0) { SILK_DEBUG << "[index] add key hash: bucket_id=" << bucket_id << " bucket_key=" << bucket_key << " offset=" << offset; } max_offset_ = std::max(max_offset_, offset); Bytes collector_key(16, '\0'); endian::store_big_u64(collector_key.data(), bucket_id); endian::store_big_u64(collector_key.data() + sizeof(uint64_t), bucket_key); Bytes offset_key(8, '\0'); endian::store_big_u64(offset_key.data(), offset); if (double_enum_index_) { offset_collector_->collect(offset_key, {}); Bytes current_key_count(8, '\0'); endian::store_big_u64(current_key_count.data(), keys_added_); bucket_collector_->collect(collector_key, current_key_count); } else { bucket_collector_->collect(collector_key, offset_key); } ++keys_added_; } bool build_mph_index( std::ofstream& index_output_stream, GolombRiceVector& golomb_rice_codes, uint16_t& golomb_param_max_index, DoubleEliasFano& double_ef_index, uint8_t bytes_per_record) override { current_bucket_id_ = std::numeric_limits::max(); // To make sure 0 bucket is detected [[maybe_unused]] auto _ = gsl::finally([&]() { bucket_collector_->clear(); }); // We use an exception for collision error condition because ETL currently does not support loading errors // TODO(canepat) refactor ETL to support errors in LoadFunc and propagate them to caller to get rid of CollisionError struct CollisionError : public std::runtime_error { explicit CollisionError(uint64_t bucket_id) : runtime_error("collision"), bucket_id(bucket_id) {} uint64_t bucket_id; }; try { // Not passing any cursor is a valid use-case for ETL when DB modification is not expected bucket_collector_->load([&](const datastore::etl::Entry& entry) { // k is the big-endian encoding of the bucket number and the v is the key that is assigned into that bucket const uint64_t bucket_id = endian::load_big_u64(entry.key.data()); SILK_TRACE << "[index] processing bucket_id=" << bucket_id; if (current_bucket_id_ != bucket_id) { if (current_bucket_id_ != std::numeric_limits::max()) { bool collision = recsplit_current_bucket(index_output_stream, golomb_param_max_index, bytes_per_record); if (collision) throw CollisionError{bucket_id}; } current_bucket_id_ = bucket_id; } current_bucket_.emplace_back(endian::load_big_u64(entry.key.data() + sizeof(uint64_t))); current_bucket_offsets_.emplace_back(endian::load_big_u64(entry.value.data())); }); } catch (const CollisionError& error) { SILK_WARN << "[index] collision detected for bucket=" << error.bucket_id; return true; } if (!current_bucket_.empty()) { bool collision_detected = recsplit_current_bucket(index_output_stream, golomb_param_max_index, bytes_per_record); if (collision_detected) return true; } gr_builder_.append_fixed(1, 1); // Sentinel (avoids checking for parts of size 1) // Concatenate the representation of each bucket golomb_rice_codes = gr_builder_.build(); // Construct double Elias-Fano index for bucket cumulative keys and bit positions std::vector cumulative_keys{bucket_size_accumulator_.begin(), bucket_size_accumulator_.end()}; std::vector positions(bucket_position_accumulator_.begin(), bucket_position_accumulator_.end()); double_ef_index.build(cumulative_keys, positions); return false; // no collision } void build_enum_index(std::unique_ptr& ef_offsets) override { // Build Elias-Fano index for offsets (if any) ef_offsets = std::make_unique(keys_added_, max_offset_); offset_collector_->load([&](const datastore::etl::Entry& entry) { const uint64_t offset = endian::load_big_u64(entry.key.data()); ef_offsets->add_offset(offset); }); ef_offsets->build(); } //! Compute and store the splittings and bijections of the current bucket bool recsplit_current_bucket(std::ofstream& index_output_stream, uint16_t& golomb_param_max_index, uint8_t bytes_per_record) { // Extend bucket size accumulator to accommodate current bucket index + 1 while (bucket_size_accumulator_.size() <= (current_bucket_id_ + 1)) { bucket_size_accumulator_.push_back(bucket_size_accumulator_.back()); } bucket_size_accumulator_.back() += current_bucket_.size(); SILKWORM_ASSERT(bucket_size_accumulator_.back() >= bucket_size_accumulator_[current_bucket_id_]); // Sets of size 0 and 1 are not further processed, just write them to index if (current_bucket_.size() > 1) { for (size_t i{1}; i < current_bucket_.size(); ++i) { if (current_bucket_[i] == current_bucket_[i - 1]) { SILK_TRACE << "collision detected key=" << current_bucket_[i - 1]; return true; } } buffer_bucket_.reserve(current_bucket_.size()); buffer_offsets_.reserve(current_bucket_offsets_.size()); buffer_bucket_.resize(current_bucket_.size()); buffer_offsets_.resize(current_bucket_.size()); RecSplit::recsplit( current_bucket_, current_bucket_offsets_, buffer_bucket_, buffer_offsets_, gr_builder_, index_output_stream, golomb_param_max_index, bytes_per_record); gr_builder_.append_collected_unaries(); } else { for (const auto offset : current_bucket_offsets_) { Bytes uint64_buffer(8, '\0'); endian::store_big_u64(uint64_buffer.data(), offset); index_output_stream.write(reinterpret_cast(uint64_buffer.data()), 8); SILK_TRACE << "[index] written offset: " << offset; } } // Extend bucket position accumulator to accommodate current bucket index + 1 while (bucket_position_accumulator_.size() <= current_bucket_id_ + 1) { bucket_position_accumulator_.push_back(bucket_position_accumulator_.back()); } bucket_position_accumulator_.back() = gr_builder_.get_bits(); SILKWORM_ASSERT(bucket_position_accumulator_.back() >= bucket_position_accumulator_[current_bucket_id_]); // Clear for the next bucket current_bucket_.clear(); current_bucket_offsets_.clear(); buffer_bucket_.clear(); buffer_offsets_.clear(); return false; } void clear() override { bucket_collector_->clear(); offset_collector_->clear(); current_bucket_.clear(); current_bucket_offsets_.clear(); bucket_size_accumulator_.resize(1); bucket_position_accumulator_.resize(1); keys_added_ = 0; max_offset_ = 0; } uint64_t keys_added() override { return keys_added_; } uint64_t max_offset() override { return max_offset_; } private: // Optimal size for offset and bucket ETL collectors size_t etl_optimal_size_{datastore::etl::kOptimalBufferSize}; //! Flag indicating if two-level index "recsplit -> enum" + "enum -> offset" is required bool double_enum_index_{false}; //! Maximum value of offset used to decide how many bytes to use for Elias-Fano encoding uint64_t max_offset_{0}; //! The number of keys currently added uint64_t keys_added_{0}; //! Identifier of the current bucket being accumulated uint64_t current_bucket_id_{0}; //! 64-bit fingerprints of keys in the current bucket accumulated before the recsplit is performed for that bucket std::vector current_bucket_; //! Index offsets for the current bucket std::vector current_bucket_offsets_; //! The ETL collector sorting keys by offset std::unique_ptr offset_collector_{}; //! The ETL collector sorting keys by bucket std::unique_ptr bucket_collector_{}; //! Accumulator for size of every bucket std::vector bucket_size_accumulator_; //! Accumulator for position of every bucket in the encoding of the hash function std::vector bucket_position_accumulator_; //! Temporary buffer for current bucket std::vector buffer_bucket_; //! Temporary buffer for current offsets std::vector buffer_offsets_; //! Helper to build GR codes of splitting and bijection indices GolombRiceBuilder gr_builder_; }; inline auto seq_build_strategy(size_t etl_buffer_size = datastore::etl::kOptimalBufferSize) { return std::make_unique(etl_buffer_size); } /* Example usage: RecSplit8 recsplit{RecSplitSettings{}, seq_build_strategy(datastore::etl::kOptimalBufferSize)}; auto collision = recsplit.build(); */ } // namespace silkworm::snapshots::rec_split #pragma GCC diagnostic pop ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/rec_split_seq_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rec_split_seq.hpp" #include #include // for std::setw and std::setfill #include #include #include #include #include #include "test_util/xoroshiro128pp.hpp" namespace silkworm::snapshots::rec_split { using silkworm::test_util::TemporaryFile; using test_util::next_pseudo_random; // Exclude tests from Windows build due to access issues with files in OS temporary dir #ifndef _WIN32 //! Make the MPHF predictable just for testing static constexpr int kTestSalt{1}; TEST_CASE("RecSplit8: key_count=0", "[silkworm][snapshots][recsplit]") { TemporaryFile index_file; RecSplitSettings settings{ .keys_count = 0, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs{settings, seq_build_strategy(), /*.salt=*/kTestSalt}; CHECK_THROWS_AS(rs.build(), std::logic_error); CHECK_THROWS_AS(rs("first_key"), std::logic_error); } TEST_CASE("RecSplit8: key_count=1", "[silkworm][snapshots][recsplit]") { TemporaryFile index_file; RecSplitSettings settings{ .keys_count = 1, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs{settings, seq_build_strategy(), /*.salt=*/kTestSalt}; CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK_NOTHROW(rs.build()); CHECK_NOTHROW(rs("first_key")); } TEST_CASE("RecSplit8: key_count=2", "[silkworm][snapshots][recsplit]") { TemporaryFile index_file; RecSplitSettings settings{ .keys_count = 2, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs{settings, seq_build_strategy(), /*.salt=*/kTestSalt}; SECTION("keys") { CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK_THROWS_AS(rs.build(), std::logic_error); CHECK_THROWS_AS(rs("first_key"), std::logic_error); CHECK_NOTHROW(rs.add_key("second_key", 0)); CHECK(rs.build() == false /*collision_detected*/); CHECK_NOTHROW(rs("first_key")); CHECK_NOTHROW(rs("second_key")); } SECTION("duplicated keys") { CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK_NOTHROW(rs.add_key("first_key", 0)); CHECK(rs.build() == true /*collision_detected*/); } } template static void check_bijection(RS& rec_split, const std::vector& keys) { // RecSplit implements a MPHF K={k1...kN} -> V={0..N-1} so we must check all codomain is exhausted std::vector recsplit_values(keys.size()); // Fill the codomain values w/ zero, so we can easily check if a value is already used or not std::fill(recsplit_values.begin(), recsplit_values.end(), 0); uint64_t i{0}; for (const auto& k : keys) { uint64_t v = rec_split(k); // Value associated to key in RecSplit must be unique (perfect: no collision) CHECK(recsplit_values[v] == 0); // Mark the value as used in codomain recsplit_values[v] = ++i; } // All codomain values must be used (minimal: rank(K) == rank(V)) for (const auto& v : recsplit_values) { CHECK(v != 0); } } static constexpr int kTestLeaf{4}; using RecSplit4 = RecSplit; template <> const size_t RecSplit4::kLowerAggregationBound = RecSplit4::SplitStrategy::kLowerAggregationBound; template <> const size_t RecSplit4::kUpperAggregationBound = RecSplit4::SplitStrategy::kUpperAggregationBound; template <> const std::array RecSplit4::kMemo = RecSplit4::fill_golomb_rice(); using RecSplit4 = RecSplit; auto seq_build_strategy_4() { return std::make_unique(datastore::etl::kOptimalBufferSize); } TEST_CASE("RecSplit4: keys=1000 buckets=128", "[silkworm][snapshots][recsplit]") { TemporaryFile index_file; constexpr int kTestNumKeys{1'000}; constexpr int kTestBucketSize{128}; std::vector hashed_keys; for (size_t i{0}; i < kTestNumKeys; ++i) { hashed_keys.push_back({next_pseudo_random(), next_pseudo_random()}); } RecSplitSettings settings{ .keys_count = hashed_keys.size(), .bucket_size = kTestBucketSize, .index_path = index_file.path(), .base_data_id = 0}; RecSplit4 rs{settings, seq_build_strategy_4(), /*.salt=*/kTestSalt}; SECTION("random_hash128 KO: not built") { for (const auto& hk : hashed_keys) { rs.add_key(hk, 0); } // RecSplit not built implies operator() must raise an exception for (const auto& hk : hashed_keys) { CHECK_THROWS_AS(rs(hk), std::logic_error); } } SECTION("random_hash128 OK") { for (const auto& hk : hashed_keys) { rs.add_key(hk, 0); } CHECK(rs.build() == false /*collision_detected*/); check_bijection(rs, hashed_keys); } } TEST_CASE("RecSplit4: multiple keys-buckets", "[silkworm][snapshots][recsplit]") { TemporaryFile index_file; struct RecSplitParams { size_t key_count{0}; uint16_t bucket_size{0}; }; std::vector recsplit_params_sequence{ {1'000, 128}, {5'000, 512}, {10'000, 1024}, {20'000, 2048}, {40'000, 2048}, }; for (const auto [key_count, bucket_size] : recsplit_params_sequence) { SECTION("random_hash128 OK [" + std::to_string(key_count) + "-" + std::to_string(bucket_size) + "]") { // NOLINT std::vector hashed_keys; for (size_t i{0}; i < key_count; ++i) { hashed_keys.push_back({next_pseudo_random(), next_pseudo_random()}); } RecSplitSettings settings{ .keys_count = key_count, .bucket_size = bucket_size, .index_path = index_file.path(), .base_data_id = 0}; RecSplit4 rs{settings, seq_build_strategy_4(), /*.salt=*/kTestSalt}; for (const auto& hk : hashed_keys) { rs.add_key(hk, 0); } CHECK(rs.build() == false /*collision_detected*/); check_bijection(rs, hashed_keys); RecSplit4 rs_index{index_file.path()}; CHECK(rs.base_data_id() == settings.base_data_id); CHECK(rs.key_count() == settings.keys_count); CHECK(rs.empty() == !settings.keys_count); CHECK(rs.record_mask() == 0); CHECK(rs.bucket_count() == (settings.keys_count + settings.bucket_size - 1) / settings.bucket_size); CHECK(rs.bucket_size() == settings.bucket_size); check_bijection(rs_index, hashed_keys); } } } #ifdef SILKWORM_TEST_SKIP TEST_CASE("RecSplit8: index lookup", "[silkworm][snapshots][recsplit]") { TemporaryFile index_file; RecSplitSettings settings{ .keys_count = 100, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0, .double_enum_index = false}; RecSplit8 rs1{settings, seq_build_strategy(), /*.salt=*/kTestSalt}; for (size_t i{0}; i < settings.keys_count; ++i) { rs1.add_key("key " + std::to_string(i), i * 17); } CHECK(rs1.build() == false /*collision_detected*/); RecSplit8 rs2{settings.index_path}; for (size_t i{0}; i < settings.keys_count; ++i) { const std::string key{"key " + std::to_string(i)}; CHECK((rs2.lookup(key) == RecSplit8::LookupResult{i * 17, true})); } } #endif // SILKWORM_TEST_SKIP #ifdef SILKWORM_TEST_SKIP TEST_CASE("RecSplit8: double index lookup", "[silkworm][snapshots][recsplit]") { TemporaryFile index_file; RecSplitSettings settings{ .keys_count = 100, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs1{settings, seq_build_strategy(), /*.salt=*/kTestSalt}; for (size_t i{0}; i < settings.keys_count; ++i) { rs1.add_key("key " + std::to_string(i), i * 17); } CHECK(rs1.build() == false /*collision_detected*/); RecSplit8 rs2{settings.index_path}; for (size_t i{0}; i < settings.keys_count; ++i) { const auto enumeration_index = rs2.lookup_ordinal_by_key("key " + std::to_string(i)); REQUIRE(enumeration_index); CHECK(enumeration_index == i); CHECK(rs2.lookup_by_ordinal(enumeration_index) == i * 17); } } #endif // SILKWORM_TEST_SKIP #ifdef SILKWORM_TEST_SKIP TEST_CASE("RecSplit8: unsupported feature", "[silkworm][snapshots][recsplit]") { // Generate valid RecSplit index TemporaryFile index_file; RecSplitSettings settings{ .keys_count = 100, .bucket_size = 10, .index_path = index_file.path(), .base_data_id = 0}; RecSplit8 rs1{settings, seq_build_strategy(), /*.salt=*/kTestSalt}; for (size_t i{0}; i < settings.keys_count; ++i) { rs1.add_key("key " + std::to_string(i), i * 17); } CHECK(rs1.build() == false /*collision_detected*/); // Purposely alter the index file to insert an unsupported feature value std::ifstream input{index_file.path(), std::ios::binary}; std::vector buffer{std::istreambuf_iterator(input), {}}; static constexpr size_t kFeatureFlagOffset = 394; static constexpr unsigned char kInvalidFeatureValue = 250; buffer[kFeatureFlagOffset] = kInvalidFeatureValue; std::ofstream output{index_file.path(), std::ios::binary}; for (const auto b : buffer) { output << b; } output.close(); CHECK_THROWS_AS(RecSplit8{index_file.path()}, std::runtime_error); } #endif // SILKWORM_TEST_SKIP #endif // _WIN32 } // namespace silkworm::snapshots::rec_split ================================================ FILE: silkworm/db/datastore/snapshots/rec_split/test_util/xoroshiro128pp.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 /* Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org) To the extent possible under law, the author has dedicated all copyright and related and neighboring rights to this software to the public domain worldwide. This software is distributed without any warranty. See . */ #pragma once #include namespace silkworm::snapshots::rec_split::test_util { inline uint64_t rotl(const uint64_t x, int k) { return (x << k) | (x >> (64 - k)); } inline uint64_t next_pseudo_random() { static uint64_t s[2] = {0x333e2c3815b27604, 0x47ed6e7691d8f09f}; const uint64_t s0 = s[0]; uint64_t s1 = s[1]; const uint64_t result = rotl(s0 + s1, 17) + s0; s1 ^= s0; s[0] = rotl(s0, 49) ^ s1 ^ (s1 << 21); // a, b s[1] = rotl(s1, 28); // c return result; } } // namespace silkworm::snapshots::rec_split::test_util ================================================ FILE: silkworm/db/datastore/snapshots/schema.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "schema.hpp" #include #include namespace silkworm::snapshots { SnapshotPath Schema::SnapshotFileDef::make_path( const std::filesystem::path& dir_path, datastore::StepRange range) const { auto filename_format = sub_dir_name() ? SnapshotPath::FilenameFormat::kE3 : SnapshotPath::FilenameFormat::kE2; return SnapshotPath::make(dir_path, sub_dir_name(), filename_format, kSnapshotV1, range, tag(), file_ext()); } Schema::EntityDef& Schema::EntityDef::tag_override(std::string_view tag) { for (auto& entry : file_defs_) { entry.second->tag(tag); } return *this; } std::vector Schema::EntityDef::file_extensions() const { std::set results; for (const auto& entry : files()) results.insert(entry.second->file_ext()); return std::vector{results.begin(), results.end()}; } std::vector Schema::RepositoryDef::file_extensions() const { std::set results; for (const auto& entry : entities()) for (const auto& file_ext : entry.second->file_extensions()) results.insert(file_ext); return std::vector{results.begin(), results.end()}; } std::optional Schema::EntityDef::entity_name_by_path(const SnapshotPath& path) const { for (const auto& [name, def] : files()) { if (def->make_path(path.base_dir_path(), path.step_range()) == path) { return name; } } return std::nullopt; } std::optional> Schema::RepositoryDef::entity_name_by_path(const SnapshotPath& path) const { for (const auto& [entity_name, def] : entities()) { auto name = def->entity_name_by_path(path); if (name) { return std::make_pair(entity_name, *name); } } return std::nullopt; } static std::string name2tag(datastore::EntityName name) { auto tag = name.to_string(); for (char& c : tag) c = static_cast(std::tolower(c)); return tag; } Schema::DomainDef Schema::RepositoryDef::make_domain_schema(datastore::EntityName name) { Schema::DomainDef schema; schema.kv_segment(kDomainKVSegmentName) .compression_kind(seg::CompressionKind::kNone) .sub_dir_name(kDomainKVSegmentSubDirName) .tag(name2tag(name)) .file_ext(kDomainKVSegmentFileExt); schema.existence_index(kDomainExistenceIndexName) .sub_dir_name(kDomainExistenceIndexSubDirName) .tag(name2tag(name)) .file_ext(kDomainExistenceIndexFileExt); schema.btree_index(kDomainBTreeIndexName) .sub_dir_name(kDomainBTreeIndexSubDirName) .tag(name2tag(name)) .file_ext(kDomainBTreeIndexFileExt); return schema; } Schema::DomainDef& Schema::DomainDef::with_accessor_index() { accessor_index(kDomainAccessorIndexName) .sub_dir_name(kDomainAccessorIndexSubDirName) .tag(kv_segment(kDomainKVSegmentName).tag()) .file_ext(kDomainAccessorIndexFileExt); return *this; } Schema::EntityDef Schema::RepositoryDef::make_history_schema(datastore::EntityName name) { Schema::EntityDef schema; define_history_schema(name, schema); return schema; } void Schema::RepositoryDef::define_history_schema(datastore::EntityName name, EntityDef& schema) { schema.segment(kHistorySegmentName) .compression_enabled(false) .sub_dir_name(kHistorySegmentSubDirName) .tag(name2tag(name)) .file_ext(kHistorySegmentFileExt); schema.accessor_index(kHistoryAccessorIndexName) .sub_dir_name(kHistoryAccessorIndexSubDirName) .tag(name2tag(name)) .file_ext(kHistoryAccessorIndexFileExt); define_inverted_index_schema(name, schema); } void Schema::RepositoryDef::undefine_history_schema(EntityDef& schema) { schema.undefine(kHistorySegmentName); schema.undefine(kHistoryAccessorIndexName); undefine_inverted_index_schema(schema); } Schema::EntityDef Schema::RepositoryDef::make_inverted_index_schema(datastore::EntityName name) { Schema::EntityDef schema; define_inverted_index_schema(name, schema); return schema; } void Schema::RepositoryDef::define_inverted_index_schema(datastore::EntityName name, EntityDef& schema) { schema.kv_segment(kInvIdxKVSegmentName) .compression_kind(seg::CompressionKind::kNone) .sub_dir_name(kInvIdxKVSegmentSubDirName) .tag(name2tag(name)) .file_ext(kInvIdxKVSegmentFileExt); schema.accessor_index(kInvIdxAccessorIndexName) .sub_dir_name(kInvIdxAccessorIndexSubDirName) .tag(name2tag(name)) .file_ext(kInvIdxAccessorIndexFileExt); } void Schema::RepositoryDef::undefine_inverted_index_schema(EntityDef& schema) { schema.undefine(kInvIdxKVSegmentName); schema.undefine(kInvIdxAccessorIndexName); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/schema.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../common/entity_name.hpp" #include "../common/step_timestamp_converter.hpp" #include "common/snapshot_path.hpp" #include "query_caches_schema.hpp" #include "segment/seg/compression_kind.hpp" namespace silkworm::snapshots { class Schema { public: class SnapshotFileDef { public: enum class Format { kSegment, kKVSegment, kAccessorIndex, kExistenceIndex, kBTreeIndex, }; explicit SnapshotFileDef(Format format) : format_{format} {} virtual ~SnapshotFileDef() = default; SnapshotFileDef& sub_dir_name(std::string_view name) { sub_dir_name_ = name; return *this; } SnapshotFileDef& tag(std::string_view tag) { tag_ = tag; return *this; } SnapshotFileDef& file_ext(std::string_view ext) { file_ext_ = ext; return *this; } SnapshotPath make_path(const std::filesystem::path& dir_path, datastore::StepRange range) const; Format format() const { return format_; } const std::optional& sub_dir_name() const { return sub_dir_name_; } const std::string& tag() const { return tag_.value(); } const std::string& file_ext() const { return file_ext_.value(); } private: Format format_; std::optional sub_dir_name_; std::optional tag_; std::optional file_ext_; }; class SegmentDef : public SnapshotFileDef { public: explicit SegmentDef() : SnapshotFileDef{SnapshotFileDef::Format::kSegment} {} ~SegmentDef() override = default; SegmentDef& compression_enabled(bool value) { compression_enabled_ = value; return *this; } bool compression_enabled() const { return compression_enabled_; } private: bool compression_enabled_{true}; }; class KVSegmentDef : public SnapshotFileDef { public: explicit KVSegmentDef() : SnapshotFileDef{SnapshotFileDef::Format::kKVSegment} {} ~KVSegmentDef() override = default; KVSegmentDef& compression_kind(seg::CompressionKind compression_kind) { compression_kind_ = compression_kind; return *this; } seg::CompressionKind compression_kind() const { return *compression_kind_; } private: std::optional compression_kind_; }; class EntityDef { public: virtual ~EntityDef() = default; const KVSegmentDef& kv_segment(datastore::EntityName name) const { return dynamic_cast(*file_defs_.at(name)); } SegmentDef& segment(datastore::EntityName name) { file_defs_.try_emplace(name, std::make_shared()); return dynamic_cast(*file_defs_.at(name)); } KVSegmentDef& kv_segment(datastore::EntityName name) { file_defs_.try_emplace(name, std::make_shared()); return dynamic_cast(*file_defs_.at(name)); } SnapshotFileDef& accessor_index(datastore::EntityName name) { file_defs_.try_emplace(name, std::make_shared(SnapshotFileDef::Format::kAccessorIndex)); return *file_defs_.at(name); } SnapshotFileDef& existence_index(datastore::EntityName name) { file_defs_.try_emplace(name, std::make_shared(SnapshotFileDef::Format::kExistenceIndex)); return *file_defs_.at(name); } SnapshotFileDef& btree_index(datastore::EntityName name) { file_defs_.try_emplace(name, std::make_shared(SnapshotFileDef::Format::kBTreeIndex)); return *file_defs_.at(name); } EntityDef& undefine(datastore::EntityName name) { file_defs_.erase(name); return *this; } EntityDef& tag_override(std::string_view tag); const datastore::EntityMap>& files() const { return file_defs_; } std::vector file_extensions() const; std::optional entity_name_by_path(const SnapshotPath& path) const; private: datastore::EntityMap> file_defs_; }; class DomainDef : public EntityDef { public: ~DomainDef() override = default; DomainDef& kv_segment_compression_kind(seg::CompressionKind compression_kind) { kv_segment(kDomainKVSegmentName).compression_kind(compression_kind); return *this; } DomainDef& with_accessor_index(); }; class RepositoryDef { public: EntityDef& default_entity() { entity_defs_.try_emplace(kDefaultEntityName, std::make_shared()); return *entity_defs_.at(kDefaultEntityName); } DomainDef& domain(datastore::EntityName name) { entity_defs_.try_emplace(name, std::make_shared(make_domain_schema(name))); return dynamic_cast(*entity_defs_.at(name)); } const DomainDef& domain(datastore::EntityName name) const { return dynamic_cast(*entity_defs_.at(name)); } EntityDef& history(datastore::EntityName name) { entity_defs_.try_emplace(name, std::make_shared(make_history_schema(name))); return *entity_defs_.at(name); } const EntityDef& history(datastore::EntityName name) const { return *entity_defs_.at(name); } EntityDef& inverted_index(datastore::EntityName name) { entity_defs_.try_emplace(name, std::make_shared(make_inverted_index_schema(name))); return *entity_defs_.at(name); } const EntityDef& inverted_index(datastore::EntityName name) const { return *entity_defs_.at(name); } RepositoryDef& index_salt_file_name(std::string_view value) { index_salt_file_name_ = value; return *this; } RepositoryDef& step_size(size_t value) { step_size_ = value; return *this; } const datastore::EntityMap>& entities() const { return entity_defs_; } std::vector file_extensions() const; std::optional> entity_name_by_path(const SnapshotPath& path) const; const std::string& index_salt_file_name() const { return index_salt_file_name_.value(); } size_t step_size() const { return step_size_.value(); } datastore::StepToTimestampConverter make_step_converter() const { return datastore::StepToTimestampConverter{step_size()}; } private: friend DomainDef; static DomainDef make_domain_schema(datastore::EntityName name); static EntityDef make_history_schema(datastore::EntityName name); static void define_history_schema(datastore::EntityName name, EntityDef& schema); static void undefine_history_schema(EntityDef& schema); static EntityDef make_inverted_index_schema(datastore::EntityName name); static void define_inverted_index_schema(datastore::EntityName name, EntityDef& schema); static void undefine_inverted_index_schema(EntityDef& schema); datastore::EntityMap> entity_defs_; std::optional index_salt_file_name_; std::optional step_size_; }; RepositoryDef& repository(datastore::EntityName name) { return repository_defs_[name]; } QueryCachesSchema& query_caches_schema() { return query_caches_schema_; } static inline const datastore::EntityName kDefaultEntityName{"_"}; static inline const datastore::EntityName kDomainKVSegmentName{"DomainKVSegment"}; static constexpr std::string_view kDomainKVSegmentSubDirName{"domain"}; static constexpr std::string_view kDomainKVSegmentFileExt{".kv"}; static inline const datastore::EntityName kDomainAccessorIndexName{"DomainAccessorIndex"}; static constexpr std::string_view kDomainAccessorIndexSubDirName{"domain"}; static constexpr std::string_view kDomainAccessorIndexFileExt{".kvi"}; static inline const datastore::EntityName kDomainExistenceIndexName{"DomainExistenceIndex"}; static constexpr std::string_view kDomainExistenceIndexSubDirName{"domain"}; static constexpr std::string_view kDomainExistenceIndexFileExt{".kvei"}; static inline const datastore::EntityName kDomainBTreeIndexName{"DomainBTreeIndex"}; static constexpr std::string_view kDomainBTreeIndexSubDirName{"domain"}; static constexpr std::string_view kDomainBTreeIndexFileExt{".bt"}; static inline const datastore::EntityName kHistorySegmentName{"HistorySegment"}; static constexpr std::string_view kHistorySegmentSubDirName{"history"}; static constexpr std::string_view kHistorySegmentFileExt{".v"}; static inline const datastore::EntityName kHistoryAccessorIndexName{"HistoryAccessorIndex"}; static constexpr std::string_view kHistoryAccessorIndexSubDirName{"accessor"}; static constexpr std::string_view kHistoryAccessorIndexFileExt{".vi"}; static inline const datastore::EntityName kInvIdxKVSegmentName{"InvIdxKVSegment"}; static constexpr std::string_view kInvIdxKVSegmentSubDirName{"idx"}; static constexpr std::string_view kInvIdxKVSegmentFileExt{".ef"}; static inline const datastore::EntityName kInvIdxAccessorIndexName{"InvIdxAccessorIndex"}; static constexpr std::string_view kInvIdxAccessorIndexSubDirName{"accessor"}; static constexpr std::string_view kInvIdxAccessorIndexFileExt{".efi"}; private: datastore::EntityMap repository_defs_; QueryCachesSchema query_caches_schema_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/segment/kv_segment_reader.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "kv_segment_reader.hpp" #include #include namespace silkworm::snapshots::segment { KVSegmentFileReader::KVSegmentFileReader( SnapshotPath path, datastore::StepToTimestampConverter step_converter, seg::CompressionKind compression_kind, std::optional segment_region) : path_(std::move(path)), step_converter_{std::move(step_converter)}, decompressor_{path_.path(), segment_region, compression_kind} { } MemoryMappedRegion KVSegmentFileReader::memory_file_region() const { return decompressor_.memory_file().region(); } KVSegmentFileReader::Iterator& KVSegmentFileReader::Iterator::operator++() { for (auto& decoder : std::array{decoders_.first, decoders_.second}) { bool has_next = it_.has_next(); if (decoder) { ++it_; } else { it_.skip(); } if (has_next) { if (decoder) { if (path_) { decoder->decode_word_with_metadata(*path_, step_converter_); } decoder->decode_word(*it_); if (path_) { decoder->check_sanity_with_metadata(*path_, step_converter_); } } } else { decoders_.first.reset(); decoders_.second.reset(); break; } } return *this; } KVSegmentFileReader::Iterator& KVSegmentFileReader::Iterator::operator+=(size_t count) { count *= 2; while ((count > 2) && it_.has_next()) { it_.skip(); --count; } if (count >= 2) { ++*this; } return *this; } bool operator==(const KVSegmentFileReader::Iterator& lhs, const KVSegmentFileReader::Iterator& rhs) { return (lhs.decoders_ == rhs.decoders_) && ((!lhs.decoders_.first && !lhs.decoders_.second) || (lhs.it_ == rhs.it_)); } KVSegmentFileReader::Iterator KVSegmentFileReader::begin(std::shared_ptr key_decoder, std::shared_ptr value_decoder) const { SILKWORM_ASSERT(key_decoder || value_decoder); auto it = decompressor_.begin(); if (it == decompressor_.end()) { return end(); } if (!it.has_next()) { return end(); } if (key_decoder) { key_decoder->decode_word_with_metadata(path_, step_converter_); key_decoder->decode_word(*it); key_decoder->check_sanity_with_metadata(path_, step_converter_); } if (value_decoder) { ++it; value_decoder->decode_word_with_metadata(path_, step_converter_); value_decoder->decode_word(*it); value_decoder->check_sanity_with_metadata(path_, step_converter_); } else { it.skip(); } return KVSegmentFileReader::Iterator{std::move(it), std::move(key_decoder), std::move(value_decoder), path(), step_converter_}; } KVSegmentFileReader::Iterator KVSegmentFileReader::end() const { return KVSegmentFileReader::Iterator{decompressor_.end(), {}, {}, path(), step_converter_}; } KVSegmentFileReader::Iterator KVSegmentFileReader::seek( uint64_t offset, std::optional check_prefix, std::shared_ptr key_decoder, std::shared_ptr value_decoder) const { SILKWORM_ASSERT(key_decoder || value_decoder); auto it = decompressor_.seek(offset, check_prefix.value_or(ByteView{})); if (it == decompressor_.end()) { return end(); } if (!it.has_next()) { return end(); } if (key_decoder) { key_decoder->decode_word_with_metadata(path_, step_converter_); try { key_decoder->decode_word(*it); } catch (...) { return end(); } key_decoder->check_sanity_with_metadata(path_, step_converter_); } if (value_decoder) { ++it; value_decoder->decode_word_with_metadata(path_, step_converter_); value_decoder->decode_word(*it); value_decoder->check_sanity_with_metadata(path_, step_converter_); } else { it.skip(); } return KVSegmentFileReader::Iterator{std::move(it), std::move(key_decoder), std::move(value_decoder), path(), step_converter_}; } } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/kv_segment_reader.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../../common/step_timestamp_converter.hpp" #include "../common/codec.hpp" #include "../common/snapshot_path.hpp" #include "seg/decompressor.hpp" namespace silkworm::snapshots::segment { class KVSegmentFileReader { public: class Iterator { public: using value_type = std::pair, std::shared_ptr>; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; Iterator( seg::Decompressor::Iterator it, std::shared_ptr key_decoder, std::shared_ptr value_decoder, SnapshotPath path, datastore::StepToTimestampConverter step_converter) : it_(std::move(it)), decoders_(std::move(key_decoder), std::move(value_decoder)), path_(std::move(path)), step_converter_(std::move(step_converter)) {} Iterator() : it_{seg::Decompressor::Iterator::make_end()}, decoders_{{}, {}}, path_{std::nullopt}, step_converter_{} {} value_type operator*() const { return decoders_; } const value_type* operator->() const { return &decoders_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++(); Iterator& operator+=(size_t count); friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs); private: seg::Decompressor::Iterator it_; value_type decoders_; std::optional path_; datastore::StepToTimestampConverter step_converter_; }; static_assert(std::input_iterator); static_assert(std::sentinel_for); static inline const size_t kPageSize{os::page_size()}; explicit KVSegmentFileReader( SnapshotPath path, datastore::StepToTimestampConverter step_converter, seg::CompressionKind compression_kind, std::optional segment_region = std::nullopt); KVSegmentFileReader(KVSegmentFileReader&&) = default; KVSegmentFileReader& operator=(KVSegmentFileReader&&) = default; const SnapshotPath& path() const { return path_; } const std::filesystem::path& fs_path() const { return path_.path(); } bool empty() const { return item_count() == 0; } size_t item_count() const { return decompressor_.words_count() / 2; } MemoryMappedRegion memory_file_region() const; Iterator begin(std::shared_ptr key_decoder, std::shared_ptr value_decoder) const; Iterator end() const; Iterator seek( uint64_t offset, std::optional check_prefix, std::shared_ptr key_decoder, std::shared_ptr value_decoder) const; const seg::Decompressor& decompressor() const { return decompressor_; } private: //! The path of the segment file for this snapshot SnapshotPath path_; datastore::StepToTimestampConverter step_converter_; seg::Decompressor decompressor_; }; template class KVSegmentReader { public: class Iterator { public: using value_type_owned = std::pair; using value_type = std::pair; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; explicit Iterator(KVSegmentFileReader::Iterator it) : it_(std::move(it)) {} Iterator() = default; value_type operator*() const { return value(); } value_type_owned move_value() const { value_type value = this->value(); return {std::move(value.first), std::move(value.second)}; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator& operator+=(size_t count) { it_ += count; return *this; } friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs) = default; private: value_type value() const { Decoder& base_key_decoder = *(it_->first); Decoder& base_value_decoder = *(it_->second); // dynamic_cast is safe because TKeyDecoder was used when creating the Iterator auto& key_decoder = dynamic_cast(base_key_decoder); // dynamic_cast is safe because TValueDecoder was used when creating the Iterator auto& key_value_decoder = dynamic_cast(base_value_decoder); return {key_decoder.value, key_value_decoder.value}; } KVSegmentFileReader::Iterator it_; }; static_assert(std::input_iterator); static_assert(std::sentinel_for); using KeyDecoderType = TKeyDecoder; using ValueDecoderType = TValueDecoder; explicit KVSegmentReader(const KVSegmentFileReader& reader) : reader_{&reader} {} Iterator begin() const { return Iterator{reader_->begin(std::make_shared(), std::make_shared())}; } Iterator end() const { return Iterator{reader_->end()}; } Iterator seek(uint64_t offset) const { return Iterator{reader_->seek(offset, std::nullopt, std::make_shared(), std::make_shared())}; } std::optional seek_one(uint64_t offset) const { auto it = seek(offset); return (it != end()) ? std::optional{it.move_value()} : std::nullopt; } const SnapshotPath& path() const { return reader_->path(); } private: const KVSegmentFileReader* reader_; }; template class KVSegmentKeysReader { public: class Iterator { public: using value_type = decltype(TKeyDecoder::value); using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; explicit Iterator(KVSegmentFileReader::Iterator it) : it_(std::move(it)) {} Iterator() = default; reference operator*() const { return value(); } pointer operator->() const { return &value(); } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator& operator+=(size_t count) { it_ += count; return *this; } friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs) = default; private: value_type& value() const { Decoder& base_key_decoder = *(it_->first); // dynamic_cast is safe because TKeyDecoder was used when creating the Iterator auto& key_decoder = dynamic_cast(base_key_decoder); return key_decoder.value; } KVSegmentFileReader::Iterator it_; }; static_assert(std::input_iterator); static_assert(std::sentinel_for); using KeyDecoderType = TKeyDecoder; explicit KVSegmentKeysReader(const KVSegmentFileReader& reader) : reader_{&reader} {} Iterator begin() const { return Iterator{reader_->begin(std::make_shared(), {})}; } Iterator end() const { return Iterator{reader_->end()}; } Iterator seek(uint64_t offset) const { return Iterator{reader_->seek(offset, std::nullopt, std::make_shared(), {})}; } std::optional seek_one(uint64_t offset) const { auto it = seek(offset); return (it != end()) ? std::optional{std::move(*it)} : std::nullopt; } const SnapshotPath& path() const { return reader_->path(); } private: const KVSegmentFileReader* reader_; }; template class KVSegmentValuesReader { public: class Iterator { public: using value_type = decltype(TValueDecoder::value); using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; explicit Iterator(KVSegmentFileReader::Iterator it) : it_(std::move(it)) {} Iterator() = default; reference operator*() const { return value(); } pointer operator->() const { return &value(); } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator& operator+=(size_t count) { it_ += count; return *this; } friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs) = default; private: value_type& value() const { Decoder& base_value_decoder = *(it_->second); // dynamic_cast is safe because TValueDecoder was used when creating the Iterator auto& value_decoder = dynamic_cast(base_value_decoder); return value_decoder.value; } KVSegmentFileReader::Iterator it_; }; static_assert(std::input_iterator); static_assert(std::sentinel_for); using ValueDecoderType = TValueDecoder; explicit KVSegmentValuesReader(const KVSegmentFileReader& reader) : reader_{&reader} {} Iterator begin() const { return Iterator{reader_->begin({}, std::make_shared())}; } Iterator end() const { return Iterator{reader_->end()}; } Iterator seek(uint64_t offset) const { return Iterator{reader_->seek(offset, std::nullopt, {}, std::make_shared())}; } std::optional seek_one(uint64_t offset) const { auto it = seek(offset); return (it != end()) ? std::optional{std::move(*it)} : std::nullopt; } const SnapshotPath& path() const { return reader_->path(); } private: const KVSegmentFileReader* reader_; }; template concept KVSegmentReaderConcept = std::same_as> || std::derived_from>; template concept KVSegmentKeysReaderConcept = std::same_as> || std::derived_from>; template concept KVSegmentValuesReaderConcept = std::same_as> || std::derived_from>; } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/kv_segment_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include "../test_util/string_codec.hpp" #include "kv_segment_reader.hpp" #include "kv_segment_writer.hpp" namespace silkworm::snapshots::segment { struct CharCodec : public Codec { char value{}; Bytes word; ~CharCodec() override = default; ByteView encode_word() override { word.clear(); word.push_back(*byte_ptr_cast(&value)); return word; } void decode_word(Word& input_word) override { const ByteView input_word_view = input_word; if (input_word_view.empty()) { throw std::runtime_error{"CharCodec failed to decode"}; } value = *byte_ptr_cast(input_word_view.data()); } }; static_assert(std::ranges::input_range>); static_assert(std::movable>); static_assert(std::ranges::input_range>); static_assert(std::movable>); static_assert(std::ranges::input_range>); static_assert(std::movable>); TEST_CASE("KVSegmentFile") { using namespace datastore; TemporaryDirectory tmp_dir; auto path = SnapshotPath::make(tmp_dir.path(), std::nullopt, SnapshotPath::FilenameFormat::kE2, kSnapshotV1, StepRange{Step{0}, Step{1}}, "headers", ".seg"); static constexpr seg::CompressionKind kCompressionKind = seg::CompressionKind::kKeys; std::vector> entries = { {"first", 'x'}, {"second", 'y'}, {"third", 'z'}, }; KVSegmentFileWriter file_writer{path, kCompressionKind, tmp_dir.path()}; KVSegmentWriter writer{file_writer}; auto out = writer.out(); for (auto& entry : entries) { *out++ = entry; } KVSegmentFileWriter::flush(std::move(file_writer)); KVSegmentFileReader file_reader{path, {}, kCompressionKind}; KVSegmentReader reader{file_reader}; for (std::pair entry : reader) { CHECK(entry.first == entries[0].first); CHECK(entry.second == entries[0].second); entries.erase(entries.begin()); } CHECK(entries.empty()); } } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/kv_segment_writer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "kv_segment_writer.hpp" namespace silkworm::snapshots::segment { KVSegmentFileWriter::KVSegmentFileWriter( SnapshotPath path, seg::CompressionKind compression_kind, const std::filesystem::path& tmp_dir_path) : path_{std::move(path)}, compressor_{path_.path(), tmp_dir_path, compression_kind} { } KVSegmentFileWriter::Iterator& KVSegmentFileWriter::Iterator::operator=( const KVSegmentFileWriter::Iterator::value_type& value) { *it_++ = value.first->encode_word(); *it_++ = value.second->encode_word(); return *this; } KVSegmentFileWriter::Iterator KVSegmentFileWriter::out( std::shared_ptr key_encoder, std::shared_ptr value_encoder) { return KVSegmentFileWriter::Iterator{ compressor_.add_word_iterator(), std::move(key_encoder), std::move(value_encoder), }; } void KVSegmentFileWriter::flush(KVSegmentFileWriter writer) { seg::Compressor::compress(std::move(writer.compressor_)); } } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/kv_segment_writer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "../common/codec.hpp" #include "../common/snapshot_path.hpp" #include "seg/compressor.hpp" namespace silkworm::snapshots::segment { class KVSegmentFileWriter { public: class Iterator { public: using value_type = std::pair, std::shared_ptr>; using iterator_category [[maybe_unused]] = std::output_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = void; using reference = void; Iterator( seg::Compressor::Iterator it, std::shared_ptr key_encoder, std::shared_ptr value_encoder) : it_{it}, encoders_{std::move(key_encoder), std::move(value_encoder)} {} Iterator& operator*() { return *this; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { /* noop */ return *this; } Iterator& operator=(const value_type& value); std::shared_ptr key_encoder() const { return encoders_.first; } std::shared_ptr value_encoder() const { return encoders_.second; } private: seg::Compressor::Iterator it_; value_type encoders_; }; static_assert(std::output_iterator); KVSegmentFileWriter( SnapshotPath path, seg::CompressionKind compression_kind, const std::filesystem::path& tmp_dir_path); KVSegmentFileWriter(KVSegmentFileWriter&&) = default; KVSegmentFileWriter& operator=(KVSegmentFileWriter&&) = default; SnapshotPath path() const { return path_; } Iterator out( std::shared_ptr key_encoder, std::shared_ptr value_encoder); static void flush(KVSegmentFileWriter writer); private: SnapshotPath path_; seg::Compressor compressor_; }; template class KVSegmentWriter { public: class Iterator { public: using value_type = std::pair; using iterator_category [[maybe_unused]] = std::output_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = void; using reference = void; explicit Iterator(KVSegmentFileWriter::Iterator it) : it_(std::move(it)) {} Iterator& operator*() { return *this; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator& operator=(value_type value) { *it_ = set_value(std::move(value)); return *this; } private: KVSegmentFileWriter::Iterator::value_type set_value(value_type value) { Encoder& base_key_encoder = *it_.key_encoder(); Encoder& base_value_encoder = *it_.value_encoder(); // dynamic_cast is safe because TKeyEncoder was used when creating the Iterator auto& key_encoder = dynamic_cast(base_key_encoder); key_encoder.value = std::move(value.first); // dynamic_cast is safe because TValueEncoder was used when creating the Iterator auto& value_encoder = dynamic_cast(base_value_encoder); value_encoder.value = std::move(value.second); return {it_.key_encoder(), it_.value_encoder()}; } KVSegmentFileWriter::Iterator it_; }; static_assert(std::output_iterator); using KeyEncoderType = TKeyEncoder; using ValueEncoderType = TValueEncoder; explicit KVSegmentWriter(KVSegmentFileWriter& writer) : writer_(writer) {} Iterator out() { return Iterator{writer_.out(std::make_shared(), std::make_shared())}; } private: KVSegmentFileWriter& writer_; }; template concept KVSegmentWriterConcept = std::same_as> || std::derived_from>; } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") # circular_buffer, iostreams (for fsync) find_package(Boost REQUIRED COMPONENTS headers iostreams) silkworm_library( silkworm_snapshots_seg PUBLIC silkworm_core silkworm_infra PRIVATE Boost::headers Boost::iostreams sais_lite silkworm_datastore_etl ) ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/common/varint.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "varint.hpp" namespace silkworm::snapshots::seg::varint { static constexpr size_t kMaxVarintBytes = 10; static constexpr uint8_t kByteMask = 0b01111111; static constexpr uint8_t kContMask = 0b10000000; static constexpr uint8_t kByteMaskBits = 7; ByteView encode(Bytes& out, uint64_t value) { out.reserve(kMaxVarintBytes); out.resize(0); uint8_t cont_mask{}; do { cont_mask = (value > kByteMask) ? kContMask : 0; out.push_back((static_cast(value) & kByteMask) | cont_mask); value >>= kByteMaskBits; } while (cont_mask); return out; } std::optional decode(ByteView& data) { uint64_t value = 0; size_t i{}, offset{}; bool found_last = false; for (i = 0, offset = 0; (i < data.size()) && (i < kMaxVarintBytes) && !found_last; ++i, offset += kByteMaskBits) { value |= static_cast(data[i] & kByteMask) << offset; if (data[i] <= kByteMask) { found_last = true; } } if (found_last) { data.remove_prefix(i); return value; } return std::nullopt; } std::optional read(Bytes& out, absl::FunctionRef get_char) { out.reserve(kMaxVarintBytes); out.resize(0); bool found_last = false; do { auto c = static_cast(get_char()); out.push_back(c); found_last = !(c & kContMask); } while ((out.size() < kMaxVarintBytes) && !found_last); if (found_last) { return out; } return std::nullopt; } } // namespace silkworm::snapshots::seg::varint ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/common/varint.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::snapshots::seg::varint { ByteView encode(Bytes& out, uint64_t value); std::optional decode(ByteView& data); std::optional read(Bytes& out, absl::FunctionRef get_char); } // namespace silkworm::snapshots::seg::varint ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/common/varint_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "varint.hpp" #include #include #include namespace silkworm::snapshots::seg { TEST_CASE("varint") { Bytes buffer; std::vector examples = { 0, 1, 2, 127, 128, 150, 256, std::numeric_limits::max(), std::numeric_limits::max(), }; for (uint64_t example : examples) { ByteView encoded = varint::encode(buffer, example); CHECK(varint::decode(encoded) == example); } } TEST_CASE("varint.size") { Bytes buffer; ByteView encoded; encoded = varint::encode(buffer, 150); CHECK(encoded.size() == 2); encoded = buffer; varint::decode(encoded); CHECK(encoded.size() == buffer.size() - 2); encoded = varint::encode(buffer, 2048383); CHECK(encoded.size() == 3); encoded = buffer; varint::decode(encoded); CHECK(encoded.size() == buffer.size() - 3); } TEST_CASE("varint.too_long") { Bytes buffer; ByteView encoded; encoded = varint::encode(buffer, std::numeric_limits::max()); CHECK(encoded.size() == buffer.size()); buffer[buffer.size() - 1] = 0xFF; CHECK_FALSE(varint::decode(encoded).has_value()); CHECK(encoded.size() == buffer.size()); encoded = varint::encode(buffer, 150); CHECK(encoded.size() == 2); encoded.remove_suffix(1); CHECK_FALSE(varint::decode(encoded).has_value()); CHECK(encoded.size() == 1); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compression_kind.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../common/util/bitmask_operators.hpp" namespace silkworm::snapshots::seg { enum class CompressionKind : uint8_t { kNone = 0b0, kKeys = 0b1, kValues = 0b10, kAll = 0b11, }; consteval void enable_bitmask_operator_and(CompressionKind); consteval void enable_bitmask_operator_or(CompressionKind); consteval void enable_bitmask_operator_not(CompressionKind); } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/bit_stream.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bit_stream.hpp" #include namespace silkworm::snapshots::seg { void BitStream::write(uint64_t code, uint8_t code_bits) { while (code_bits > 0) { uint8_t bits_used = (output_bits_ + code_bits > 8) ? (8 - output_bits_) : code_bits; uint64_t mask = (uint64_t{1} << bits_used) - 1; output_byte_ |= static_cast((code & mask) << output_bits_); code >>= bits_used; code_bits -= bits_used; output_bits_ += bits_used; if (output_bits_ == 8) { flush(); } } } BitStream::~BitStream() { flush(); } void BitStream::flush() { if (output_bits_ > 0) { byte_writer_(output_byte_); output_bits_ = 0; output_byte_ = 0; } } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/bit_stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::snapshots::seg { class BitStream { public: explicit BitStream(std::function byte_writer) : byte_writer_(std::move(byte_writer)) {} ~BitStream(); void write(uint64_t code, uint8_t code_bits); void flush(); private: std::function byte_writer_; uint8_t output_bits_{}; uint8_t output_byte_{}; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/bit_stream_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bit_stream.hpp" #include #include #include #include namespace silkworm::snapshots::seg { struct ByteWriter { Bytes storage; std::function func; ByteWriter() { func = [this](uint8_t b) { this->write(b); }; } void write(uint8_t b) { storage.push_back(b); } // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) operator std::function() const { return func; } }; TEST_CASE("BitStream.zero_bits") { ByteWriter writer; { BitStream stream{writer}; stream.write(1, 0); } CHECK(writer.storage.empty()); } TEST_CASE("BitStream.one_bit") { ByteWriter writer; { BitStream stream{writer}; stream.write(1, 1); } CHECK(writer.storage == Bytes{1}); } TEST_CASE("BitStream.few_bits") { ByteWriter writer; { BitStream stream{writer}; stream.write(0b101, 3); } CHECK(writer.storage == Bytes{0b101}); } TEST_CASE("BitStream.one_byte") { ByteWriter writer; { BitStream stream{writer}; stream.write(0xFF, 8); } CHECK(writer.storage == Bytes{0xFF}); } TEST_CASE("BitStream.some_nibbles") { ByteWriter writer; { BitStream stream{writer}; stream.write(0b0011, 4); stream.write(0b1100, 4); stream.write(0b1001, 4); } CHECK(writer.storage == Bytes{0b11000011, 0b00001001}); } TEST_CASE("BitStream.some_bits") { ByteWriter writer; { BitStream stream{writer}; stream.write(0b000, 3); stream.write(0b1111111, 7); stream.write(0b00, 2); stream.write(0b1111, 4); } CHECK(writer.storage == Bytes{0b11111000, 0b11110011}); } TEST_CASE("BitStream.int64") { ByteWriter writer; { BitStream stream{writer}; stream.write(std::numeric_limits::max(), 64); } CHECK(writer.storage == Bytes(8, 0xFF)); } TEST_CASE("BitStream.int63") { ByteWriter writer; { BitStream stream{writer}; stream.write(std::numeric_limits::max(), 63); } CHECK(writer.storage == Bytes(7, 0xFF) + Bytes{0b1111111}); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/huffman_code.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "huffman_code.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots::seg { using namespace std; struct HuffmanTreeLeaf { size_t symbol_index{}; uint64_t code{}; uint8_t code_bits{1}; }; struct HuffmanTreeNode { unique_ptr> n0; unique_ptr> n1; uint64_t uses{}; uint64_t tie_breaker{}; bool operator<(const HuffmanTreeNode& node2) const { const HuffmanTreeNode& node1 = *this; return (node1.uses != node2.uses) ? (node1.uses > node2.uses) : (node1.tie_breaker > node2.tie_breaker); } }; using Leaf = HuffmanTreeLeaf; using Node = HuffmanTreeNode; class HuffmanTree { public: explicit HuffmanTree(const vector& symbol_uses) : root_(build(symbol_uses)) {} void dfs_visit_leaves(absl::FunctionRef visit) { HuffmanTree::dfs_visit_leaves(root_, visit); } private: static Node build(const vector& symbol_uses); static void bump_leaves_code(Node& node, bool inc); static void dfs_visit_leaves(Node& node, absl::FunctionRef visit); Node root_; }; Node HuffmanTree::build(const vector& symbol_uses) { vector queue; less<> comparator; uint64_t tie_breaker = 0; size_t i = 0; while (queue.size() + (symbol_uses.size() - i) > 1) { Node node{ .tie_breaker = tie_breaker, }; // Take n0 from the heap if (!queue.empty() && ((i >= symbol_uses.size()) || (queue[0].uses < symbol_uses[i]))) { ranges::pop_heap(queue, comparator); node.n0 = make_unique>(std::move(queue.back())); queue.pop_back(); node.uses += get(*node.n0).uses; bump_leaves_code(get(*node.n0), false); } // Take n0 from the list else { Leaf leaf{i, 0}; node.n0 = make_unique>(leaf); node.uses += symbol_uses[i]; ++i; } // Take n1 from the heap if (!queue.empty() && ((i >= symbol_uses.size()) || (queue[0].uses < symbol_uses[i]))) { ranges::pop_heap(queue, comparator); node.n1 = make_unique>(std::move(queue.back())); queue.pop_back(); node.uses += get(*node.n1).uses; bump_leaves_code(get(*node.n1), true); } // Take n1 from the list else { Leaf leaf{i, 1}; node.n1 = make_unique>(leaf); node.uses += symbol_uses[i]; ++i; } queue.push_back(std::move(node)); ranges::push_heap(queue, comparator); ++tie_breaker; } Node root; if (!queue.empty()) { root = std::move(queue[0]); } return root; } void HuffmanTree::bump_leaves_code(Node& node, bool inc) { dfs_visit_leaves(node, [inc](Leaf& leaf) { leaf.code <<= 1; leaf.code += inc ? 1 : 0; ++leaf.code_bits; }); } void HuffmanTree::dfs_visit_leaves(Node& node, absl::FunctionRef visit) { if (node.n0) { auto leaf = get_if(node.n0.get()); if (leaf) { visit(*leaf); } else { dfs_visit_leaves(get(*node.n0), visit); } } if (node.n1) { auto leaf = get_if(node.n1.get()); if (leaf) { visit(*leaf); } else { dfs_visit_leaves(get(*node.n1), visit); } } } std::vector huffman_code_table(const std::vector& symbol_uses) { HuffmanTree tree{symbol_uses}; std::vector table; table.resize(symbol_uses.size()); tree.dfs_visit_leaves([&table](Leaf& leaf) { table[leaf.symbol_index] = HuffmanSymbolCode{ .code = leaf.code, .code_bits = leaf.code_bits, }; }); return table; } static uint64_t reverse_bytes64(uint64_t x) { #if __cplusplus >= 202302L return std::byteswap(x); #elif defined(_MSC_VER) return _byteswap_uint64(x); #else return __builtin_bswap64(x); #endif } static uint64_t reverse_bits64(uint64_t x) { // every even bit (01010101...) constexpr uint64_t kMask1 = 0x5555555555555555; // every even bit pair (00110011...) constexpr uint64_t kMask2 = 0x3333333333333333; // every even nibble (00001111...) constexpr uint64_t kMask4 = 0x0F0F0F0F0F0F0F0F; // reverse bits in each byte x = ((x >> 1) & kMask1) | ((x & kMask1) << 1); x = ((x >> 2) & kMask2) | ((x & kMask2) << 2); x = ((x >> 4) & kMask4) | ((x & kMask4) << 4); return reverse_bytes64(x); } std::vector huffman_code_table_order_by_codes( const std::vector& codes) { std::vector order(codes.size()); std::iota(order.begin(), order.end(), 0); std::ranges::sort(order, [&](size_t i, size_t j) { return reverse_bits64(codes[i].code) < reverse_bits64(codes[j].code); }); return order; } std::vector huffman_code_table_order_by_uses_and_codes( const std::vector& symbol_uses, const std::vector& codes) { std::vector order(symbol_uses.size()); std::iota(order.begin(), order.end(), 0); std::ranges::sort(order, [&](size_t i, size_t j) { return (symbol_uses[i] != symbol_uses[j]) ? (symbol_uses[i] < symbol_uses[j]) : (reverse_bits64(codes[i]) < reverse_bits64(codes[j])); }); return order; } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/huffman_code.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::snapshots::seg { struct HuffmanSymbolCode { //! Code of a symbol. Only the lowest code_bits are meaningful. uint64_t code{}; //! The number bits in the symbol code, aka code length, aka depth in the Huffman tree. uint8_t code_bits{}; friend bool operator==(const HuffmanSymbolCode&, const HuffmanSymbolCode&) = default; }; /** * Builds a Huffman code table. * @param symbol_uses Sorted symbol usage frequencies. * @return Huffman codes of each symbol. */ std::vector huffman_code_table(const std::vector& symbol_uses); /** * Produce an ordering of codes by code bits. * This is used as a Huffman table representation for serialization. * If only the symbol code lengths are stored in this order, * then the whole code table can be recovered. * @param codes Huffman codes of each symbol. * @return Reordered indexes of codes. */ std::vector huffman_code_table_order_by_codes( const std::vector& codes); /** * Produce an ordering of codes by symbol frequency and code bits. * This is used to produce a stable order for the huffman_code_table input. * @param symbol_uses Symbol usage frequencies. * @param codes Temporary Huffman codes of each symbol. * @return Reordered indexes of codes. */ std::vector huffman_code_table_order_by_uses_and_codes( const std::vector& symbol_uses, const std::vector& codes); } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/huffman_code_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "huffman_code.hpp" #include namespace silkworm::snapshots::seg { TEST_CASE("huffman_code_table0") { std::vector symbol_uses = {1, 2, 3}; std::vector expected_code_table = { {1, 2}, {3, 2}, {0, 1}, }; auto actual_code_table = huffman_code_table(symbol_uses); CHECK(actual_code_table == expected_code_table); } TEST_CASE("huffman_code_table1") { std::vector symbol_uses = { 1, 11, 11, 11, 11, 11, 11, 11, 11, 11, }; std::vector expected_code_table = { {3, 4}, {11, 4}, {7, 4}, {15, 4}, {0, 3}, {4, 3}, {2, 3}, {6, 3}, {1, 3}, {5, 3}, }; auto actual_code_table = huffman_code_table(symbol_uses); CHECK(actual_code_table == expected_code_table); } TEST_CASE("huffman_code_table2") { std::vector symbol_uses = { 9, 10, 90, 90, 101, 200, 400, }; std::vector expected_code_table = { {3, 5}, {19, 5}, {11, 4}, {7, 4}, {15, 4}, {1, 2}, {0, 1}, }; auto actual_code_table = huffman_code_table(symbol_uses); CHECK(actual_code_table == expected_code_table); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/intermediate_compressed_stream.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "intermediate_compressed_stream.hpp" #include #include "../common/varint.hpp" namespace silkworm::snapshots::seg { using namespace std; IntermediateCompressedStream::IntermediateCompressedStream( const filesystem::path& path, size_t buffer_size) : file_(path, ios::in | ios::out | ios::binary | ios::trunc), stream_(file_) { stream_.exceptions(ios::failbit | ios::badbit); stream_buffer_.reset(new char[buffer_size]); stream_.rdbuf()->pubsetbuf(stream_buffer_.get(), static_cast(buffer_size)); } IntermediateCompressedStream::IntermediateCompressedStream(iostream& stream) : stream_(stream) { stream_.exceptions(ios::failbit | ios::badbit); } void IntermediateCompressedStream::write_varint(size_t value) { stream_ << byte_view_to_string_view(varint::encode(encoded_buf_, value)); } void IntermediateCompressedStream::write_word(const CompressedWord& word) { write_varint(word.raw_length); if (word.raw_length == 0) return; write_varint(word.pattern_positions.size()); for (auto [pattern_pos, pattern_code] : word.pattern_positions) { write_varint(pattern_pos); write_varint(pattern_code); } } void IntermediateCompressedStream::write_uncovered_data(silkworm::ByteView data) { stream_ << byte_view_to_string_view(data); } size_t IntermediateCompressedStream::read_varint() { auto encoded_value = varint::read(encoded_buf_, [this]() -> char { char c = 0; this->stream_.get(c); return c; }); if (!encoded_value) throw runtime_error("IntermediateCompressedStream::read_varint failed to read at " + std::to_string(stream_.tellg())); auto value = varint::decode(*encoded_value); if (!value) throw runtime_error("IntermediateCompressedStream::read_varint failed to parse at " + std::to_string(stream_.tellg())); return *value; } std::optional IntermediateCompressedStream::read_word() { if (stream_.peek() == decltype(file_)::traits_type::eof()) return nullopt; CompressedWord word; word.raw_length = read_varint(); if (word.raw_length == 0) return word; size_t pattern_positions_count = read_varint(); word.pattern_positions.reserve(pattern_positions_count); while (pattern_positions_count > 0) { size_t pattern_pos = read_varint(); size_t pattern_code = read_varint(); word.pattern_positions.emplace_back(pattern_pos, pattern_code); --pattern_positions_count; } return word; } Bytes IntermediateCompressedStream::read_uncovered_data(size_t size) { Bytes data(size, 0); stream_.read(byte_ptr_cast(data.data()), static_cast(data.size())); return data; } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/intermediate_compressed_stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::snapshots::seg { class IntermediateCompressedStream { public: IntermediateCompressedStream(const std::filesystem::path& path, size_t buffer_size); explicit IntermediateCompressedStream(std::iostream& stream); struct CompressedWord { size_t raw_length{}; std::vector> pattern_positions; friend bool operator==(const CompressedWord&, const CompressedWord&) = default; }; void write_word(const CompressedWord& word); void write_uncovered_data(ByteView data); std::optional read_word(); Bytes read_uncovered_data(size_t size); void flush() { stream_.flush(); } void rewind() { stream_.seekg(0); } private: void write_varint(size_t value); size_t read_varint(); std::fstream file_; std::iostream& stream_; std::unique_ptr stream_buffer_; Bytes encoded_buf_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/intermediate_compressed_stream_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "intermediate_compressed_stream.hpp" #include #include namespace silkworm::snapshots::seg { using namespace std; TEST_CASE("IntermediateCompressedStream") { stringstream stream; IntermediateCompressedStream::CompressedWord word1{ .raw_length = 123, .pattern_positions = { {0, 1}, {100, 2}, {200, 1}, {300, 3}, }, }; Bytes word1_uncovered_data = {1, 2, 3}; IntermediateCompressedStream::CompressedWord word2{ .raw_length = 555, .pattern_positions = { {1000, 3}, {2000, 2}, {3000, 1}, }, }; Bytes word2_uncovered_data(100, 42); IntermediateCompressedStream words_out{stream}; words_out.write_word(word1); words_out.write_uncovered_data(word1_uncovered_data); words_out.write_word(word2); words_out.write_uncovered_data(word2_uncovered_data); IntermediateCompressedStream words_in{stream}; CHECK(words_in.read_word() == word1); CHECK(words_in.read_uncovered_data(word1_uncovered_data.size()) == word1_uncovered_data); CHECK(words_in.read_word() == word2); CHECK(words_in.read_uncovered_data(word2_uncovered_data.size()) == word2_uncovered_data); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/lcp_kasai.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "lcp_kasai.hpp" namespace silkworm::snapshots::seg { void lcp_kasai(const uint8_t* data, const int* sa, const int* inv, int* lcp, int n) { struct DataPosComparator { const uint8_t* data; bool has_same_chars(int i, int j) const { return data[i] == data[j]; } } comparator{data}; lcp_kasai(comparator, sa, inv, lcp, n); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/lcp_kasai.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::snapshots::seg { template requires requires(const TDataPosComparator& data, int i, int j) { { data.has_same_chars(i, j) } -> std::same_as; } void lcp_kasai(const TDataPosComparator& data, const int* sa, const int* inv, int* lcp, int n) { int k = 0; // Process all suffixes one by one starting from // first suffix in txt[] for (int i = 0; i < n; ++i) { // If the current suffix is at n-1, then we don’t // have next substring to consider. So lcp is not // defined for this substring, we put zero. if (inv[i] == n - 1) { k = 0; lcp[inv[i]] = 0; continue; } // j contains index of the next substring to // be considered to compare with the present // substring, i.e. next string in suffix array. int j = sa[inv[i] + 1]; // Directly start matching from k-th index as // at-least k-1 characters will match. while ((i + k < n) && (j + k < n) && data.has_same_chars(i + k, j + k)) { ++k; } // lcp for the present suffix. lcp[inv[i]] = k; // Deleting the starting character from the string. if (k > 0) { --k; } } } void lcp_kasai(const uint8_t* data, const int* sa, const int* inv, int* lcp, int n); } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/output_file_transaction.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "output_file_transaction.hpp" #include #include #include #include #include #ifdef _WIN32 #include #else #include #endif namespace silkworm::snapshots::seg { using namespace boost; using namespace std; class OutputFileTransactionImpl { public: OutputFileTransactionImpl(const filesystem::path& path, size_t buffer_size) : path_(path), tmp_path_(make_tmp_path(path)), fd_sink_(tmp_path_.string(), ios::out | ios::binary | ios::trunc), stream_(fd_sink_, static_cast(buffer_size)) { stream_.exceptions(ios::failbit | ios::badbit); } ~OutputFileTransactionImpl() { if (!done_) { stream_.close(); fd_sink_.close(); filesystem::remove(tmp_path_); } } void commit() { fsync(); stream_.close(); fd_sink_.close(); filesystem::rename(tmp_path_, path_); done_ = true; } ostream& stream() { return stream_; } private: static filesystem::path make_tmp_path(const filesystem::path& path) { return path.string() + ".tmp"; } #ifdef _WIN32 static void fsync_native(HANDLE handle) { BOOL ok = FlushFileBuffers(handle); if (!ok) { throw std::runtime_error("fsync_native error: " + std::to_string(GetLastError())); } } #else static void fsync_native(int fd) { int err = ::fsync(fd); if (err) { throw std::runtime_error("fsync_native error: " + std::to_string(errno)); } } #endif void fsync() { SILKWORM_ASSERT(stream_.is_open()); stream_.flush(); fsync_native(fd_sink_.handle()); } filesystem::path path_; filesystem::path tmp_path_; iostreams::file_descriptor_sink fd_sink_; iostreams::stream stream_; bool done_{false}; }; OutputFileTransaction::OutputFileTransaction( const filesystem::path& path, size_t buffer_size) : p_impl_(make_unique(path, buffer_size)) {} OutputFileTransaction::~OutputFileTransaction() { static_assert(true); } void OutputFileTransaction::commit() { p_impl_->commit(); } ostream& OutputFileTransaction::stream() { return p_impl_->stream(); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/output_file_transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::snapshots::seg { class OutputFileTransactionImpl; /** * An output file that is either fully written or deleted. * It opens a temporary file for writing, * and on commit() it fsync-s and renames it to the final file name. * If no commit() happens, the temporary file is deleted as if nothing has happened. */ class OutputFileTransaction { public: OutputFileTransaction( const std::filesystem::path& path, size_t buffer_size); ~OutputFileTransaction(); void commit(); std::ostream& stream(); private: std::unique_ptr p_impl_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/patricia_tree.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "patricia_tree.hpp" #include #include #include #include #include #include #include #include #include #include #include "lcp_kasai.hpp" namespace silkworm::snapshots::seg { struct PatriciaTreeNode { void insert(ByteView key, void* value); void* get(ByteView key); //! Value associated with the key. void* value{}; std::unique_ptr n0; std::unique_ptr n1; uint32_t p0{}; uint32_t p1{}; }; using Node = PatriciaTreeNode; // state represent a position anywhere inside patricia tree // position can be identified by combination of node, and the partitioning // of that node's p0 or p1 into head and tail. // As with p0 and p1, head and tail are encoded as follows: // lowest 5 bits encode the length in bits, and the remaining 27 bits // encode the actual head or tail. // For example, if the position is at the beginning of a node, // head would be zero, and tail would be equal to either p0 or p1, // depending on whether the position corresponds to going left (0) or right (1). struct PatriciaTreePathWalker { explicit PatriciaTreePathWalker(Node* n1) : n(n1) {} void reset(Node* n1) { this->n = n1; this->head = 0; this->tail = 0; } /** * Consumes the next byte of the key * and moves the state to corresponding node of the patricia tree. * @return divergence prefix (0 if there is no divergence) */ uint32_t transition(unsigned char b, bool readonly); void diverge(uint32_t divergence); void insert(void* value); Node* n{}; uint32_t head{}; uint32_t tail{}; }; static uint32_t shift_left(uint32_t x, uint32_t bits) { if (bits >= 32) return 0; return x << bits; } static uint32_t shift_right(uint32_t x, uint32_t bits) { if (bits >= 32) return 0; return x >> bits; } uint32_t PatriciaTreePathWalker::transition(unsigned char b, bool readonly) { PatriciaTreePathWalker* s = this; // bits in b to process uint32_t bits_left = 8; uint32_t b32 = static_cast(b) << 24; while (bits_left > 0) { if (s->head == 0) { // tail has not been determined yet, do it now if ((b32 & 0x80000000) == 0) { s->tail = s->n->p0; } else { s->tail = s->n->p1; } } if (s->tail == 0) { // state positioned at the end of the current node return b32 | bits_left; } uint32_t tail_len = s->tail & 0x1f; // the first bit where b32 and tail are different auto first_diff = static_cast(std::countl_zero(s->tail ^ b32)); if (first_diff < bits_left) { // divergence (where the key being searched and the existing structure of patricia tree becomes incompatible) is within currently supplied byte of the search key, b if (first_diff >= tail_len) { // divergence is within currently supplied byte of the search key, b, but outside the current node bits_left -= tail_len; b32 = shift_left(b32, tail_len); if (((s->head == 0) && ((s->tail & 0x80000000) == 0)) || ((s->head != 0) && ((s->head & 0x80000000) == 0))) { if (s->n->n0 == nullptr) { throw std::runtime_error("PatriciaTreePathWalker::transition: Node n0 is null"); } s->n = s->n->n0.get(); } else { if (s->n->n1 == nullptr) { throw std::runtime_error("PatriciaTreePathWalker::transition: Node n1 is null"); } s->n = s->n->n1.get(); } s->head = 0; s->tail = 0; } else { // divergence is within currently supplied byte of the search key, b, and within the current node bits_left -= first_diff; b32 = shift_left(b32, first_diff); // there is divergence, move head and tail uint32_t mask = ~(shift_left(1, 32 - first_diff) - 1); s->head |= shift_right(s->tail & mask, s->head & 0x1f); s->head += first_diff; s->tail = shift_left(s->tail & 0xffffffe0, first_diff) | (s->tail & 0x1f); s->tail -= first_diff; return b32 | bits_left; } } else if (tail_len < bits_left) { // divergence is outside the currently supplied byte of the search key, b bits_left -= tail_len; b32 = shift_left(b32, tail_len); // switch to the next node if (((s->head == 0) && ((s->tail & 0x80000000) == 0)) || ((s->head != 0) && ((s->head & 0x80000000) == 0))) { if (s->n->n0 == nullptr) { if (readonly) { return b32 | bits_left; } s->n->n0 = std::make_unique(); if ((b32 & 0x80000000) == 0) { s->n->n0->p0 = b32 | bits_left; } else { s->n->n0->p1 = b32 | bits_left; } } s->n = s->n->n0.get(); } else { if (s->n->n1 == nullptr) { if (readonly) { return b32 | bits_left; } s->n->n1 = std::make_unique(); if ((b32 & 0x80000000) == 0) { s->n->n1->p0 = b32 | bits_left; } else { s->n->n1->p1 = b32 | bits_left; } } s->n = s->n->n1.get(); } s->head = 0; s->tail = 0; } else { // key byte is consumed, but stay on the same node uint32_t mask = ~(shift_left(1, 32 - bits_left) - 1); s->head |= shift_right(s->tail & mask, s->head & 0x1f); s->head += bits_left; s->tail = shift_left(s->tail & 0xffffffe0, bits_left) | (s->tail & 0x1f); s->tail -= bits_left; bits_left = 0; if (s->tail == 0) { if ((s->head & 0x80000000) == 0) { if (s->n->n0) { s->n = s->n->n0.get(); s->head = 0; } } else { if (s->n->n1) { s->n = s->n->n1.get(); s->head = 0; } } } } } return 0; } void PatriciaTreePathWalker::diverge(uint32_t divergence) { if (tail == 0) { // try to add to the existing head uint32_t d_len = divergence & 0x1f; uint32_t head_len = head & 0x1f; uint32_t d32 = divergence & 0xffffffe0; if (head_len + d_len > 27) { uint32_t mask = ~(shift_left(1, head_len + 5) - 1); head |= shift_right(d32 & mask, head_len); head += 27 - head_len; if (((head == 0) && ((tail & 0x80000000) == 0)) || ((head != 0) && ((head & 0x80000000) == 0))) { n->p0 = head; n->n0 = std::make_unique(); n = n->n0.get(); } else { n->p1 = head; n->n1 = std::make_unique(); n = n->n1.get(); } head = 0; tail = 0; d32 <<= 27 - head_len; d_len -= (27 - head_len); head_len = 0; } uint32_t mask = ~(shift_left(1, 32 - d_len) - 1); head |= shift_right(d32 & mask, head_len); head += d_len; if (((head == 0) && ((tail & 0x80000000) == 0)) || ((head != 0) && ((head & 0x80000000) == 0))) { n->p0 = head; } else { n->p1 = head; } return; } // create a new node auto dn_ptr = std::make_unique(); Node& dn = *dn_ptr; if ((divergence & 0x80000000) == 0) { dn.p0 = divergence; dn.p1 = tail; if (((head == 0) && ((tail & 0x80000000) == 0)) || ((head != 0) && ((head & 0x80000000) == 0))) { dn.n1 = std::move(n->n0); } else { dn.n1 = std::move(n->n1); } } else { dn.p1 = divergence; dn.p0 = tail; if (((head == 0) && ((tail & 0x80000000) == 0)) || ((head != 0) && ((head & 0x80000000) == 0))) { dn.n0 = std::move(n->n0); } else { dn.n0 = std::move(n->n1); } } if (((head == 0) && ((tail & 0x80000000) == 0)) || ((head != 0) && ((head & 0x80000000) == 0))) { n->n0 = std::move(dn_ptr); n->p0 = head; n = n->n0.get(); } else { n->n1 = std::move(dn_ptr); n->p1 = head; n = n->n1.get(); } head = divergence; tail = 0; } void Node::insert(ByteView key, void* value1) { PatriciaTreePathWalker walker(this); for (unsigned char c : key) { uint32_t divergence = walker.transition(c, /* readonly */ false); if (divergence != 0) { walker.diverge(divergence); } } walker.insert(value1); } void PatriciaTreePathWalker::insert(void* value) { if (tail != 0) { diverge(0); } if (head != 0) { if ((head & 0x80000000) == 0) { n->n0 = std::make_unique(); n = n->n0.get(); } else { n->n1 = std::make_unique(); n = n->n1.get(); } head = 0; } n->value = value; } void* Node::get(ByteView key) { PatriciaTreePathWalker walker(this); for (unsigned char c : key) { uint32_t divergence = walker.transition(c, /* readonly */ true); if (divergence != 0) { return nullptr; } } if (walker.tail != 0) { return nullptr; } return walker.n->value; } class PatriciaTreeImpl { public: void insert(ByteView key, void* value) { root.insert(key, value); } void* get(ByteView key) { return root.get(key); } Node root; }; class PatriciaTreeMatchFinderImpl { public: explicit PatriciaTreeMatchFinderImpl(const PatriciaTreeImpl& tree1) : tree(tree1), node_stack({&(tree.root)}), top(&(tree.root)) {} /** * Consumes next byte of the key, * moves the state to corresponding node of the patricia tree. * @return divergence prefix (0 if there is no divergence) */ uint32_t unfold(unsigned char b); //! Moves the match finder back up the stack by specified number of bits. void fold(size_t bits); const std::vector& find_longest_matches(ByteView data); std::pair current(); const PatriciaTreeImpl& tree; std::vector node_stack; // top of the node stack const Node* top{}; std::vector match_stack; std::vector matches; std::vector sa; std::vector lcp; std::vector inv; uint32_t head_len{}; uint32_t tail_len{}; // 0, 1, or 2 (if side is not determined yet) enum Side : uint8_t { kSide0, kSide1, kSideNotDetermined, } side{kSideNotDetermined}; }; uint32_t PatriciaTreeMatchFinderImpl::unfold(unsigned char b) { // bits in b to process uint32_t bits_left = 8; uint32_t b32 = static_cast(b) << 24; while (bits_left > 0) { if (side == kSideNotDetermined) { // tail has not been determined yet, do it now if ((b32 & 0x80000000) == 0) { side = kSide0; head_len = 0; tail_len = top->p0 & 0x1f; } else { side = kSide1; head_len = 0; tail_len = top->p1 & 0x1f; } if (tail_len == 0) { // state positioned at the end of the current node side = kSideNotDetermined; return b32 | bits_left; } } if (tail_len == 0) { // need to switch to the next node if (side == kSide0) { if (top->n0 == nullptr) { return b32 | bits_left; } node_stack.push_back(top->n0.get()); top = top->n0.get(); } else if (side == kSide1) { if (top->n1 == nullptr) { return b32 | bits_left; } node_stack.push_back(top->n1.get()); top = top->n1.get(); } else { #ifndef NDEBUG SILKWORM_ASSERT(false); #else throw std::runtime_error("PatriciaTreeMatchFinder::unfold: unexpected condition side > 1"); #endif } head_len = 0; side = kSideNotDetermined; } uint32_t tail = 0; if (side == kSide0) { tail = shift_left(top->p0 & 0xffffffe0, head_len); } else if (side == kSide1) { tail = shift_left(top->p1 & 0xffffffe0, head_len); } else { return b32 | bits_left; } // the first bit where b32 and tail are different auto first_diff = static_cast(std::countl_zero(tail ^ b32)); if (first_diff < bits_left) { // divergence (where the key being searched and the existing structure of patricia tree becomes incompatible) is within currently supplied byte of the search key, b if (first_diff >= tail_len) { // divergence is within currently supplied byte of the search key, b, but outside the current node bits_left -= tail_len; b32 = shift_left(b32, tail_len); head_len += tail_len; tail_len = 0; } else { // divergence is within currently supplied byte of the search key, b, and within the current node bits_left -= first_diff; b32 = shift_left(b32, first_diff); // there is divergence, move head and tail tail_len -= first_diff; head_len += first_diff; return b32 | bits_left; } } else if (tail_len < bits_left) { // divergence is outside the currently supplied byte of the search key, b bits_left -= tail_len; b32 = shift_left(b32, tail_len); head_len += tail_len; tail_len = 0; } else { // key byte is consumed, but stay on the same node tail_len -= bits_left; head_len += bits_left; bits_left = 0; b32 = 0; } if (tail_len == 0) { // need to switch to the next node if (side == kSide0) { if (top->n0 == nullptr) { return b32 | bits_left; } node_stack.push_back(top->n0.get()); top = top->n0.get(); } else if (side == kSide1) { if (top->n1 == nullptr) { return b32 | bits_left; } node_stack.push_back(top->n1.get()); top = top->n1.get(); } else { #ifndef NDEBUG SILKWORM_ASSERT(false); #else throw std::runtime_error("PatriciaTreeMatchFinder::unfold: unexpected condition side > 1"); #endif } head_len = 0; side = kSideNotDetermined; } } return 0; } // moves the match finder back up the stack by specified number of bits void PatriciaTreeMatchFinderImpl::fold(size_t bits) { auto bits_left = static_cast(bits); while (bits_left > 0) { if (head_len == bits_left) { head_len = 0; tail_len = 0; side = kSideNotDetermined; bits_left = 0; } else if (head_len >= bits_left) { // folding only affects top node, take bits from end of the head and prepend it to the tail head_len -= bits_left; tail_len += bits_left; bits_left = 0; } else { // folding affects not only top node, remove top node bits_left -= head_len; node_stack.pop_back(); const Node* prev_top = top; top = node_stack.back(); if (top->n0.get() == prev_top) { side = kSide0; head_len = top->p0 & 0x1f; } else if (top->n1.get() == prev_top) { side = kSide1; head_len = top->p1 & 0x1f; } else { #ifndef NDEBUG SILKWORM_ASSERT(false); #else throw std::runtime_error("PatriciaTreeMatchFinder::fold: unexpected condition top prev_top is not a top child"); #endif } tail_len = 0; } } } const std::vector& PatriciaTreeMatchFinderImpl::find_longest_matches(ByteView data) { matches.clear(); if (data.size() < 2) { return matches; } node_stack.clear(); node_stack.push_back(&tree.root); match_stack.clear(); top = &tree.root; side = kSideNotDetermined; tail_len = 0; head_len = 0; size_t n = data.size(); sa.resize(n); if (sais(data.data(), sa.data(), static_cast(n)) != 0) { throw std::runtime_error("PatriciaTreeMatchFinder::find_longest_matches: sais algorithm failed"); } inv.resize(n); for (size_t i = 0; i < n; ++i) { inv[static_cast(sa[i])] = static_cast(i); } lcp.resize(n); lcp_kasai(data.data(), sa.data(), inv.data(), lcp.data(), static_cast(n)); // depth in bits size_t depth = 0; PatriciaTreeMatchFinder::Match* last_match = nullptr; for (size_t i = 0; i < n; ++i) { // lcp[i] is the Longest Common Prefix of suffixes starting from sa[i] and sa[i+1] if (i > 0) { auto lcp1 = static_cast(this->lcp[i - 1]); // lcp[i-1] is the Longest Common Prefix of suffixes starting from sa[i-1] and sa[i] if (depth > 8 * lcp1) { this->fold(depth - 8 * lcp1); depth = 8 * lcp1; while (last_match && (last_match->end - last_match->start > lcp1)) { this->match_stack.pop_back(); if (this->match_stack.empty()) { last_match = nullptr; } else { last_match = &this->match_stack.back(); } } } else { size_t r = depth % 8; if (r > 0) { this->fold(r); depth -= r; } } } auto sa1 = static_cast(this->sa[i]); size_t start = sa1 + depth / 8; for (size_t end = start + 1; end <= n; ++end) { uint32_t d = this->unfold(data[end - 1]); depth += 8 - (d & 0x1f); // divergence found if (d != 0) { break; } if ((this->tail_len != 0) || (this->top->value == nullptr)) { continue; } // this possibly overwrites the previous match for the same start position PatriciaTreeMatchFinder::Match match{ .value = this->top->value, .start = sa1, .end = end, }; this->match_stack.push_back(match); last_match = &this->match_stack.back(); } if (last_match) { PatriciaTreeMatchFinder::Match match{ .value = last_match->value, .start = sa1, .end = sa1 + last_match->end - last_match->start, }; this->matches.push_back(match); } } if (this->matches.size() < 2) { return this->matches; } std::ranges::sort( this->matches, [](const PatriciaTreeMatchFinder::Match& i, const PatriciaTreeMatchFinder::Match& j) { return i.start < j.start; }); size_t last_end = this->matches[0].end; size_t j = 1; for (size_t i = 1; i < this->matches.size(); ++i) { const PatriciaTreeMatchFinder::Match& m = this->matches[i]; if (m.end > last_end) { if (i != j) { this->matches[j] = m; } last_end = m.end; ++j; } } this->matches.resize(j); return this->matches; } std::pair PatriciaTreeMatchFinderImpl::current() { Bytes b; size_t depth = 0; size_t last = node_stack.size() - 1; for (size_t i = 0; i < node_stack.size(); ++i) { const Node* n = node_stack[i]; uint32_t p = 0; if (i < last) { const Node* next = node_stack[i + 1]; if (n->n0.get() == next) { p = n->p0; } else if (n->n1.get() == next) { p = n->p1; } else { #ifndef NDEBUG SILKWORM_ASSERT(false); #else throw std::runtime_error("PatriciaTreeMatchFinder::current: unexpected condition next is not a child of n"); #endif } } else { if (side == kSide0) { p = n->p0; } else if (side == kSide1) { p = n->p1; } p = (p & 0xffffffe0) | head_len; } // add bit by bit while ((p & 0x1f) > 0) { if (depth >= 8 * b.size()) { b.push_back(0); } if (p & 0x80000000) { b[depth / 8] |= uint8_t{1} << (7 - (depth % 8)); } ++depth; p = ((p & 0xffffffe0) << 1) | ((p & 0x1f) - 1); } } return std::make_pair(b, depth); } PatriciaTree::PatriciaTree() : p_impl_(std::make_unique()) {} PatriciaTree::~PatriciaTree() { static_assert(true); } void PatriciaTree::insert(ByteView key, void* value) { p_impl_->insert(key, value); } void* PatriciaTree::get(ByteView key) { return p_impl_->get(key); } PatriciaTreeMatchFinder::PatriciaTreeMatchFinder(const PatriciaTree& tree) : p_impl_(std::make_unique(*tree.p_impl_)) {} PatriciaTreeMatchFinder::~PatriciaTreeMatchFinder() { static_assert(true); } const std::vector& PatriciaTreeMatchFinder::find_longest_matches(ByteView data) { return p_impl_->find_longest_matches(data); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/patricia_tree.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::snapshots::seg { class PatriciaTreeImpl; class PatriciaTreeMatchFinder; class PatriciaTreeMatchFinderImpl; //! Patricia tree for an efficient search of substrings in a list of patterns. class PatriciaTree { public: PatriciaTree(); ~PatriciaTree(); void insert(ByteView key, void* value); void* get(ByteView key); private: std::unique_ptr p_impl_; friend PatriciaTreeMatchFinder; }; class PatriciaTreeMatchFinder { public: struct Match { void* value{}; size_t start{}; size_t end{}; }; explicit PatriciaTreeMatchFinder(const PatriciaTree& tree); ~PatriciaTreeMatchFinder(); //! Takes a word and returns a list of patterns that have a common prefix with the word. const std::vector& find_longest_matches(ByteView data); private: std::unique_ptr p_impl_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/patricia_tree_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "patricia_tree.hpp" #include #include #include namespace silkworm::snapshots::seg { static ByteView operator""_bv(const char* data, size_t size) { return string_view_to_byte_view({data, size}); } static Bytes hex(std::string_view v) { return from_hex(v).value(); } TEST_CASE("PatriciaTreeInserts2") { int ids[] = {1, 2}; Bytes keys[] = {Bytes{0xff}, Bytes{0xed}}; PatriciaTree n; n.insert(keys[0], &ids[0]); n.insert(keys[1], &ids[1]); CHECK(n.get(keys[0]) == &ids[0]); CHECK(n.get(keys[1]) == &ids[1]); } TEST_CASE("PatriciaTreeMatchFinder1") { int ids[] = {1, 2, 3}; PatriciaTree pt; pt.insert("wolf"_bv, &ids[0]); pt.insert("winter"_bv, &ids[1]); pt.insert("wolfs"_bv, &ids[2]); PatriciaTreeMatchFinder mf{pt}; Bytes data("Who lives here in winter, wolfs"_bv); auto& matches = mf.find_longest_matches(data); REQUIRE(matches.size() == 2); CHECK(matches[0].value == &ids[1]); CHECK(matches[0].start == 18); CHECK(matches[0].end == 24); CHECK(matches[1].value == &ids[2]); CHECK(matches[1].start == 26); CHECK(matches[1].end == 31); } TEST_CASE("PatriciaTreeMatchFinder3") { int id = 0; int* v = &id; PatriciaTree pt; pt.insert(hex("00000000000000000000000000000000000000"), v); pt.insert(hex("000000000000000000000000000000000000"), v); pt.insert(hex("0000000000000000000000000000000000"), v); pt.insert(hex("00000000000000000000000000000000"), v); pt.insert(hex("000000000000000000000000000000"), v); pt.insert(hex("0000000000000000000000000000"), v); pt.insert(hex("0100000000000000000000003b30000001000003"), v); pt.insert(hex("0000000000000000003b30000001000003000100"), v); pt.insert(hex("000000000000000000003b300000010000030001"), v); pt.insert(hex("00000000000000000000003b3000000100000300"), v); pt.insert(hex("00000000000000000000000000"), v); pt.insert(hex("00000000000000003b30000001000003000100"), v); pt.insert(hex("000000000000000000000000"), v); pt.insert(hex("000000000000003b30000001000003000100"), v); pt.insert(hex("0000000000003b30000001000003000100"), v); pt.insert(hex("00000000003b30000001000003000100"), v); pt.insert(hex("000000003b30000001000003000100"), v); pt.insert(hex("0000003b30000001000003000100"), v); pt.insert(hex("00003b30000001000003000100"), v); pt.insert(hex("0100000000000000"), v); pt.insert(hex("003b30000001000003000100"), v); pt.insert(hex("3b30000001000003000100"), v); pt.insert(hex("00000000000000003b3000000100000300010000"), v); pt.insert(hex("0100000000000000000000003a30000001000000"), v); pt.insert(hex("000000003a300000010000000000010010000000"), v); pt.insert(hex("00000000003a3000000100000000000100100000"), v); pt.insert(hex("0000000000003a30000001000000000001001000"), v); pt.insert(hex("000000000000003a300000010000000000010010"), v); pt.insert(hex("00000000000000003a3000000100000000000100"), v); pt.insert(hex("0000000000000000003a30000001000000000001"), v); pt.insert(hex("000000000000000000003a300000010000000000"), v); pt.insert(hex("00000000000000000000003a3000000100000000"), v); PatriciaTreeMatchFinder mf(pt); Bytes data(hex("0100000000000000000000003a30000001000000000001001000000044004500")); auto& matches = mf.find_longest_matches(data); std::vector expected_matches = { {v, 0, 20}, {v, 1, 21}, {v, 2, 22}, {v, 3, 23}, {v, 4, 24}, {v, 5, 25}, {v, 6, 26}, {v, 7, 27}, {v, 8, 28}, }; REQUIRE(matches.size() == expected_matches.size()); for (size_t i = 0; i < matches.size(); ++i) { auto& match = matches[i]; auto& expected_match = expected_matches[i]; CHECK(match.value == expected_match.value); CHECK(match.start == expected_match.start); CHECK(match.end == expected_match.end); } } TEST_CASE("PatriciaTreeMatchFinder4") { int id = 0; int* v = &id; PatriciaTree pt; pt.insert(hex("00000000000000000000000000000000000000"), v); PatriciaTreeMatchFinder mf(pt); Bytes data(hex("01")); REQUIRE(mf.find_longest_matches(data).empty()); } TEST_CASE("PatriciaTreeMatchFinder5") { int id = 0; int* v = &id; PatriciaTree pt; pt.insert(hex("0434e37673a8e0aaa536828f0d5b0ddba12fece1"), v); pt.insert(hex("e28e72fcf78647adce1f1252f240bbfaebd63bcc"), v); pt.insert(hex("34e28e72fcf78647adce1f1252f240bbfaebd63b"), v); pt.insert(hex("0434e28e72fcf78647adce1f1252f240bbfaebd6"), v); pt.insert(hex("090bdc64a7e3632cde8f4689f47acfc0760e35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("00090bdc64a7e3632cde8f4689f47acfc0760e35bce43af50d4b1f5973463bde"), v); pt.insert(hex("0000000000"), v); pt.insert(hex("00000000000000000000"), v); pt.insert(hex("000000000000000000000000000000"), v); pt.insert(hex("0000000000000000000000000000"), v); pt.insert(hex("000000000000000000"), v); pt.insert(hex("0000000000000000"), v); pt.insert(hex("00000000000000000000000000"), v); pt.insert(hex("000000000000000000000000"), v); pt.insert(hex("f47acfc0760e35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("e3632cde8f4689f47acfc0760e35bce43af50d4b"), v); pt.insert(hex("de8f4689f47acfc0760e35bce43af50d4b1f5973"), v); pt.insert(hex("dc64a7e3632cde8f4689f47acfc0760e35bce43a"), v); pt.insert(hex("a7e3632cde8f4689f47acfc0760e35bce43af50d"), v); pt.insert(hex("8f4689f47acfc0760e35bce43af50d4b1f597346"), v); pt.insert(hex("89f47acfc0760e35bce43af50d4b1f5973463bde"), v); pt.insert(hex("64a7e3632cde8f4689f47acfc0760e35bce43af5"), v); pt.insert(hex("632cde8f4689f47acfc0760e35bce43af50d4b1f"), v); pt.insert(hex("4689f47acfc0760e35bce43af50d4b1f5973463b"), v); pt.insert(hex("2cde8f4689f47acfc0760e35bce43af50d4b1f59"), v); pt.insert(hex("0bdc64a7e3632cde8f4689f47acfc0760e35bce4"), v); pt.insert(hex("7acfc0760e35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("0000000000000000000000"), v); pt.insert(hex("cfc0760e35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("00000000000000000000000000000000"), v); pt.insert(hex("c0760e35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("0000000000000000000000000000000000000000"), v); pt.insert(hex("00000000000000000000000000000000000000"), v); pt.insert(hex("760e35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("000000000000000000000000000000000000"), v); pt.insert(hex("0e35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("0000000000000000000000000000000000"), v); pt.insert(hex("35bce43af50d4b1f5973463bde62"), v); pt.insert(hex("bce43af50d4b1f5973463bde62"), v); pt.insert(hex("e43af50d4b1f5973463bde62"), v); pt.insert(hex("1090bdc64a7e3632cde8f4689f47acfc0760e35bce43af50d4b1f5973463bde6"), v); pt.insert(hex("3af50d4b1f5973463bde62"), v); pt.insert(hex("f50d4b1f5973463bde62"), v); pt.insert(hex("fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f130193790f769"), v); pt.insert(hex("ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db1"), v); pt.insert(hex("df415bb7ae2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e"), v); pt.insert(hex("d417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f130193790f7698ee4"), v); pt.insert(hex("cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f130193790"), v); pt.insert(hex("c2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f130193790f7"), v); pt.insert(hex("bb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126"), v); pt.insert(hex("b7ae2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7"), v); pt.insert(hex("ae2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dc"), v); pt.insert(hex("6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f1"), v); pt.insert(hex("63ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22d"), v); pt.insert(hex("5f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f13019"), v); pt.insert(hex("5bb7ae2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fc"), v); pt.insert(hex("595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f130"), v); pt.insert(hex("415bb7ae2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28"), v); pt.insert(hex("34df415bb7ae2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d303"), v); pt.insert(hex("2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf2"), v); pt.insert(hex("0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f130193790f7698e"), v); pt.insert(hex("07cbc2fc0fd417d3a29f2962b8badecbf4d3036e28fcd7dcf22db126f1301937"), v); pt.insert(hex("0434df415bb7ae2363ecbb6a595f07cbc2fc0fd417d3a29f2962b8badecbf4d3"), v); pt.insert(hex("0d4b1f5973463bde62"), v); pt.insert(hex("0000000000000000000000000000000000000000000000000000000000000000"), v); pt.insert(hex("fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3adaa9dce4"), v); pt.insert(hex("ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970"), v); pt.insert(hex("df415bb7ae2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198f"), v); pt.insert(hex("d417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3adaa9dce41b48"), v); pt.insert(hex("d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3adaa9dce41b48747f"), v); pt.insert(hex("cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3adaa9"), v); pt.insert(hex("c2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3adaa9dc"), v); pt.insert(hex("bb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bc"), v); pt.insert(hex("b7ae2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0f"), v); pt.insert(hex("ae2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0fed"), v); pt.insert(hex("6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcda"), v); pt.insert(hex("63ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded39"), v); pt.insert(hex("5f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3a"), v); pt.insert(hex("5bb7ae2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd"), v); pt.insert(hex("595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd"), v); pt.insert(hex("415bb7ae2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8"), v); pt.insert(hex("34df415bb7ae2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c19"), v); pt.insert(hex("2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded"), v); pt.insert(hex("17d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3adaa9dce41b4874"), v); pt.insert(hex("0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3adaa9dce41b"), v); pt.insert(hex("07cbc2fc0fd417d37e04bc63768597761b6c198fd8bd0feded3970bcdafd3ada"), v); pt.insert(hex("0434df415bb7ae2363ecbb6a595f07cbc2fc0fd417d37e04bc63768597761b6c"), v); pt.insert(hex("df415bb7ae2363ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("34df415bb7ae2363ecbb6a595f07cbc2fc0fd417"), v); pt.insert(hex("0434df415bb7ae2363ecbb6a595f07cbc2fc0fd4"), v); pt.insert(hex("4b1f5973463bde62"), v); pt.insert(hex("415bb7ae2363ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("5bb7ae2363ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("f4689f47acfc0760e35bce43af50d4b1f5973463"), v); pt.insert(hex("e8f4689f47acfc0760e35bce43af50d4b1f59734"), v); pt.insert(hex("cde8f4689f47acfc0760e35bce43af50d4b1f597"), v); pt.insert(hex("c64a7e3632cde8f4689f47acfc0760e35bce43af"), v); pt.insert(hex("bdc64a7e3632cde8f4689f47acfc0760e35bce43"), v); pt.insert(hex("9f47acfc0760e35bce43af50d4b1f5973463bde6"), v); pt.insert(hex("90bdc64a7e3632cde8f4689f47acfc0760e35bce"), v); pt.insert(hex("7e3632cde8f4689f47acfc0760e35bce43af50d4"), v); pt.insert(hex("689f47acfc0760e35bce43af50d4b1f5973463bd"), v); pt.insert(hex("4a7e3632cde8f4689f47acfc0760e35bce43af50"), v); pt.insert(hex("3632cde8f4689f47acfc0760e35bce43af50d4b1"), v); pt.insert(hex("32cde8f4689f47acfc0760e35bce43af50d4b1f5"), v); pt.insert(hex("b7ae2363ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("47acfc0760e35bce43af50d4b1f5973463bde6"), v); pt.insert(hex("ae2363ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("acfc0760e35bce43af50d4b1f5973463bde6"), v); pt.insert(hex("2363ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("fc0760e35bce43af50d4b1f5973463bde6"), v); pt.insert(hex("63ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("0000000000000000000000000000000000000001"), v); pt.insert(hex("0760e35bce43af50d4b1f5973463bde6"), v); pt.insert(hex("bc63768597761b6c198fd8bd0feded3970bcdafd"), v); pt.insert(hex("97761b6c198fd8bd0feded3970bcdafd3adaa9dc"), v); pt.insert(hex("8fd8bd0feded3970bcdafd3adaa9dce41b48747f"), v); pt.insert(hex("8597761b6c198fd8bd0feded3970bcdafd3adaa9"), v); pt.insert(hex("7e04bc63768597761b6c198fd8bd0feded3970bc"), v); pt.insert(hex("768597761b6c198fd8bd0feded3970bcdafd3ada"), v); pt.insert(hex("761b6c198fd8bd0feded3970bcdafd3adaa9dce4"), v); pt.insert(hex("6c198fd8bd0feded3970bcdafd3adaa9dce41b48"), v); pt.insert(hex("63768597761b6c198fd8bd0feded3970bcdafd3a"), v); pt.insert(hex("1b6c198fd8bd0feded3970bcdafd3adaa9dce41b"), v); pt.insert(hex("198fd8bd0feded3970bcdafd3adaa9dce41b4874"), v); pt.insert(hex("04bc63768597761b6c198fd8bd0feded3970bcda"), v); pt.insert(hex("00000000000000000000000000000000000001"), v); pt.insert(hex("0000000000000000000000000000000000000000000000000000000000000002"), v); pt.insert(hex("ecbb6a595f07cbc2fc0fd417d3"), v); pt.insert(hex("60e35bce43af50d4b1f5973463bde6"), v); pt.insert(hex("d8bd0feded3970bcdafd3adaa9dce41b48747f"), v); pt.insert(hex("000000000000000000000000000000000001"), v); pt.insert(hex("60e3997d5a409c25fe09d77351b6"), v); pt.insert(hex("bd0feded3970bcdafd3adaa9dce41b48747f"), v); Bytes data(hex("9d7d9d7d082073e2920896915d0e0239a7e852d86b26e03a188bc5b947972aeec206d63b6744043493d38e72c5281e78f6b364eacac6fa907ecba1640000000000000000000000000000000000000000000000000000000007bfa482043493d38e72c5281e78f6b364eacac6fa907ecba1640000000000000000000000000000000000000000000000000000000000000011043493d38e72c5281e78f6b364eacac6fa907ecba1640000000000000000000000000000000000000000000000000000000000000002043493d38e72c5281e78f6b364eacac6fa907ecba164000000000000000000000000000000000000000000000000000000000000001e0820a516e4eeef0852f3c4ee0f11237e5e5127ed67a64e43a2f2ebef2d6bc26bb384082073404b8fb6bb42e5a0c9bb7d6253d9d72084bed3991df1efd25512e7f713e796043493d38e72c5281e78f6b364eacac6fa907ecba164000000000000000000000000000000000000000000000000000000000000001f043493d38e72c5281e78f6b364eacac6fa907ecba1640000000000000000000000000000000000000000000000000000000000000012082010db8a472df5096168436e756dbf37edce306a01f4fa7a889f7ad8195e1154a9043493d38e72c5281e78f6b364eacac6fa907ecba1640000000000000000000000000000000000000000000000000000000000000006")); PatriciaTreeMatchFinder mf(pt); auto& matches = mf.find_longest_matches(data); REQUIRE(matches.size() == 88); } TEST_CASE("PatriciaTreeMatchFinder6") { int id = 0; int* v = &id; PatriciaTree pt; pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffff16"), v); pt.insert(hex("600160a060020a03"), v); pt.insert(hex("ffffffffffffffffffffffffffffff16815260200191505060405180910390a1"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff1681"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff168156"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff1681565b"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff168152602001908152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff16815260200190815260200160"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff1681526020019081526020016000"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff168152602001908152602001600020"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff16815260200190815260200160002060"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1681526020019081526020016000206000"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffffff1681526020019081526020"), v); pt.insert(hex("81526020019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff168152"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff16815260"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1681526020"), v); pt.insert(hex("ffffffffffffffffffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffffffff168152602001"), v); pt.insert(hex("526020019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1682"), v); pt.insert(hex("6020019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffff168152602001"), v); pt.insert(hex("8152602001908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffffff168152602001"), v); pt.insert(hex("80806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f16801561"), v); pt.insert(hex("60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f16"), v); pt.insert(hex("5b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f"), v); pt.insert(hex("5180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f168015"), v); pt.insert(hex("405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680"), v); pt.insert(hex("20019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffff168152602001"), v); pt.insert(hex("52602001908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffff1681565b60"), v); pt.insert(hex("019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffff168152602001"), v); pt.insert(hex("1681526020019081526020016000206000"), v); pt.insert(hex("602001908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffff168152602001908152602001600020600050"), v); pt.insert(hex("9081526020016000206000"), v); pt.insert(hex("5050604051849350600080"), v); pt.insert(hex("2001908152602001600020600050"), v); pt.insert(hex("505060405180910390f35b"), v); pt.insert(hex("ffffffffffffffffffffff1682"), v); pt.insert(hex("6000506000600060005054815260200190815260200160002060006101000a81"), v); pt.insert(hex("00506000600060005054815260200190815260200160002060006101000a8154"), v); pt.insert(hex("ffffffffffff1681565b60"), v); pt.insert(hex("ffffff16815260200191505060405180910390a1"), v); pt.insert(hex("ffffffffff168152602001"), v); pt.insert(hex("8281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a4578082"), v); pt.insert(hex("81038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a457808203"), v); pt.insert(hex("6020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a4"), v); pt.insert(hex("60005060003373ffffffffffffffffffffffffffffffffffffffff1681526020"), v); pt.insert(hex("60003373ffffffffffffffffffffffffffffffffffffffff1681526020019081"), v); pt.insert(hex("5060003373ffffffffffffffffffffffffffffffffffffffff16815260200190"), v); pt.insert(hex("3373ffffffffffffffffffffffffffffffffffffffff16815260200190815260"), v); pt.insert(hex("20018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a457"), v); pt.insert(hex("038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a45780820380"), v); pt.insert(hex("018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a45780"), v); pt.insert(hex("005060003373ffffffffffffffffffffffffffffffffffffffff168152602001"), v); pt.insert(hex("003373ffffffffffffffffffffffffffffffffffffffff168152602001908152"), v); pt.insert(hex("01908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffffff16815260200190"), v); pt.insert(hex("ffffffffffffffffffffffff1681526020019081"), v); pt.insert(hex("ffffffffffffffffffffff168152602001908152"), v); pt.insert(hex("ffffffffffffffffffff16815260200190815260"), v); pt.insert(hex("ffffffffffffffffff1681526020019081526020"), v); pt.insert(hex("ffffffffffffffff168152602001908152602001"), v); pt.insert(hex("ffffffffffffff16815260200190815260200160"), v); pt.insert(hex("ffffffffffff1681526020019081526020016000"), v); pt.insert(hex("ffffffffff168152602001908152602001600020"), v); pt.insert(hex("ffffffff16815260200190815260200160002060"), v); pt.insert(hex("ffffff1681526020019081526020016000206000"), v); pt.insert(hex("81526020016000206000"), v); pt.insert(hex("50604051849350600080"), v); pt.insert(hex("ffffffffffffffffffff1682"), v); pt.insert(hex("5060405180910390f35b"), v); pt.insert(hex("168152602001908152602001600020600050"), v); pt.insert(hex("ffff16815260200191505060405180910390a1"), v); pt.insert(hex("67ffffffffffffffff"), v); pt.insert(hex("ffffffffffffffff1682"), v); pt.insert(hex("ffff1681526020019081526020016000206000"), v); pt.insert(hex("6040518082815260200191505060405180910390"), v); pt.insert(hex("ffffffffff1681565b60"), v); pt.insert(hex("908152602001600020600050"), v); pt.insert(hex("8281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390"), v); pt.insert(hex("81038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f3"), v); pt.insert(hex("80806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f150905001925050506040"), v); pt.insert(hex("806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192505050604051"), v); pt.insert(hex("60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f150905001925050"), v); pt.insert(hex("6020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180"), v); pt.insert(hex("5b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250"), v); pt.insert(hex("5180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060"), v); pt.insert(hex("405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192505050"), v); pt.insert(hex("20018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f150905001925050506040518091"), v); pt.insert(hex("038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b"), v); pt.insert(hex("018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192505050604051809103"), v); pt.insert(hex("ffffffff168152602001"), v); pt.insert(hex("5b60405180828152602001915050604051809103"), v); pt.insert(hex("565b604051808281526020019150506040518091"), v); pt.insert(hex("518082815260200191505060405180910390f35b"), v); pt.insert(hex("40518082815260200191505060405180910390f3"), v); pt.insert(hex("ff16815260200191505060405180910390a1"), v); pt.insert(hex("ffffffffffffffffff1682"), v); pt.insert(hex("808281526102cb94909290828280156100d757"), v); pt.insert(hex("ff1681526020019081526020016000206000"), v); pt.insert(hex("526020016000206000"), v); pt.insert(hex("f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f15090509081019060"), v); pt.insert(hex("a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084528284209192849261"), v); pt.insert(hex("90f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190"), v); pt.insert(hex("8252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60"), v); pt.insert(hex("60a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590845282842091928492"), v); pt.insert(hex("602081815260408083206002548452825282208354815467ffffffffffffffff191667ffffffffffffffff919091161781556001848101805491830180548382"), v); pt.insert(hex("600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084528284"), v); pt.insert(hex("600160a060020a0333168252602082815260408084208585528252928390206001018054601f810183900490920260a090810190945260808281529293909190"), v); pt.insert(hex("600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084528284209192"), v); pt.insert(hex("60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("52838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040"), v); pt.insert(hex("52600160a060020a0333168252602082815260408084208585528252928390206001018054601f810183900490920260a0908101909452608082815292939091"), v); pt.insert(hex("526000828152604090208054829081101561000257506000908152602090200154905081565b610315600435600160a060020a03331660009081526020818152"), v); pt.insert(hex("35600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590845282842091"), v); pt.insert(hex("2081815260408083206002548452825282208354815467ffffffffffffffff191667ffffffffffffffff91909116178155600184810180549183018054838255"), v); pt.insert(hex("0435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255908452828420"), v); pt.insert(hex("0160a060020a0333168252602082815260408084208585528252928390206001018054601f810183900490920260a09081019094526080828152929390919082"), v); pt.insert(hex("0160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255908452828420919284"), v); pt.insert(hex("009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("60405180910390f35b"), v); pt.insert(hex("8082815260200191505060405180910390f35b"), v); pt.insert(hex("ffffffffffffff1682"), v); pt.insert(hex("600160a060020a033316600090815261"), v); pt.insert(hex("8152602001600020600050"), v); pt.insert(hex("90600052602060002090"), v); pt.insert(hex("928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160405260"), v); pt.insert(hex("836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782"), v); pt.insert(hex("822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160405260608481526100"), v); pt.insert(hex("820380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080"), v); pt.insert(hex("818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160"), v); pt.insert(hex("8152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285016040"), v); pt.insert(hex("8152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285016040526060"), v); pt.insert(hex("815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020"), v); pt.insert(hex("80822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052606084815261"), v); pt.insert(hex("80820380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c0908490"), v); pt.insert(hex("80519060200190808383829060006004602084601f0104600302600f01f15090"), v); pt.insert(hex("80516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c0908490801561"), v); pt.insert(hex("6101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201919060"), v); pt.insert(hex("604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160405260608481"), v); pt.insert(hex("60243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590"), v); pt.insert(hex("6020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285"), v); pt.insert(hex("6020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201"), v); pt.insert(hex("60200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b"), v); pt.insert(hex("60043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81"), v); pt.insert(hex("6001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de"), v); pt.insert(hex("60006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094"), v); pt.insert(hex("5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c09084"), v); pt.insert(hex("52928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052"), v); pt.insert(hex("52604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052606084"), v); pt.insert(hex("5260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190600052602060002090"), v); pt.insert(hex("516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103"), v); pt.insert(hex("4080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285016040526060848152"), v); pt.insert(hex("3560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185"), v); pt.insert(hex("3560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490"), v); pt.insert(hex("243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004"), v); pt.insert(hex("2090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052606084815261006c"), v); pt.insert(hex("20818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501"), v); pt.insert(hex("20036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191"), v); pt.insert(hex("200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81"), v); pt.insert(hex("1916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190600052602060"), v); pt.insert(hex("16815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201919060005260206000"), v); pt.insert(hex("0a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201919060005260"), v); pt.insert(hex("043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101"), v); pt.insert(hex("0380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c09084908015"), v); pt.insert(hex("036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190"), v); pt.insert(hex("031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020"), v); pt.insert(hex("0191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154"), v); pt.insert(hex("01836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57"), v); pt.insert(hex("01000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000"), v); pt.insert(hex("006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402"), v); pt.insert(hex("000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190600052"), v); pt.insert(hex("ffffffff1681565b60"), v); pt.insert(hex("60006005600a4306101561032f57600190506103"), v); pt.insert(hex("600160a060020a033316600090815260"), v); pt.insert(hex("ffffff168152602001"), v); pt.insert(hex("82815260200191505060405180910390f35b"), v); pt.insert(hex("9060006004602084601f0104600302600f01f150"), v); pt.insert(hex("8383829060006004602084601f0104600302600f"), v); pt.insert(hex("83829060006004602084601f0104600302600f01"), v); pt.insert(hex("829060006004602084601f0104600302600f01f1"), v); pt.insert(hex("808383829060006004602084601f010460030260"), v); pt.insert(hex("60006004602084601f0104600302600f01f15090"), v); pt.insert(hex("815260200191505060405180910390f35b"), v); pt.insert(hex("0000000000000000000000000000"), v); pt.insert(hex("8352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290918301828280"), v); pt.insert(hex("83526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293929091"), v); pt.insert(hex("81810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293"), v); pt.insert(hex("810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392"), v); pt.insert(hex("808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392909183018282"), v); pt.insert(hex("8051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280"), v); pt.insert(hex("60408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095"), v); pt.insert(hex("602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552"), v); pt.insert(hex("60043560408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184"), v); pt.insert(hex("600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392909183018282801561"), v); pt.insert(hex("6000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290918301"), v); pt.insert(hex("6000526020600020"), v); pt.insert(hex("52600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293929091830182828015"), v); pt.insert(hex("526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392909183"), v); pt.insert(hex("51602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085"), v); pt.insert(hex("408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552"), v); pt.insert(hex("3560408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190"), v); pt.insert(hex("2081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292"), v); pt.insert(hex("043560408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401"), v); pt.insert(hex("0183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290"), v); pt.insert(hex("0160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290918301828280156101"), v); pt.insert(hex("00808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293929091830182"), v); pt.insert(hex("0160a060020a033316600090815261"), v); pt.insert(hex("006005600a4306101561032f57600190506103"), v); pt.insert(hex("6020016000206000"), v); pt.insert(hex("000000000000000000"), v); pt.insert(hex("7c01000000000000000000000000000000000000000000000000000000009004"), v); pt.insert(hex("6000357c01000000000000000000000000000000000000000000000000000000"), v); pt.insert(hex("357c010000000000000000000000000000000000000000000000000000000090"), v); pt.insert(hex("0100000000000000000000000000000000000000000000000000000000900480"), v); pt.insert(hex("00357c0100000000000000000000000000000000000000000000000000000000"), v); pt.insert(hex("0000000000000000000000000000000000000000000000000000000090048063"), v); pt.insert(hex("0160a060020a033316600090815260"), v); pt.insert(hex("405180910390f35b"), v); pt.insert(hex("006004602084601f0104600302600f01f15090"), v); pt.insert(hex("52602001600020600050"), v); pt.insert(hex("ffffffffffff1682"), v); pt.insert(hex("600460209081526040808320849055600590"), v); pt.insert(hex("928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190"), v); pt.insert(hex("836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381"), v); pt.insert(hex("822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261"), v); pt.insert(hex("820380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182"), v); pt.insert(hex("818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601"), v); pt.insert(hex("8152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185"), v); pt.insert(hex("8152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096"), v); pt.insert(hex("815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260200191508054"), v); pt.insert(hex("80822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552"), v); pt.insert(hex("80820380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001"), v); pt.insert(hex("806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156104"), v); pt.insert(hex("80516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103"), v); pt.insert(hex("6101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152"), v); pt.insert(hex("604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285"), v); pt.insert(hex("60243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101"), v); pt.insert(hex("6020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502"), v); pt.insert(hex("6020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181"), v); pt.insert(hex("60200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152602001915080548015"), v); pt.insert(hex("60043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6040805160206024803560048181013560"), v); pt.insert(hex("6001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252"), v); pt.insert(hex("60006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004"), v); pt.insert(hex("5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020"), v); pt.insert(hex("52928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501"), v); pt.insert(hex("52604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652"), v); pt.insert(hex("5260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020019150805480"), v); pt.insert(hex("5260200191505060405180910390f35b"), v); pt.insert(hex("516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382"), v); pt.insert(hex("4080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585"), v); pt.insert(hex("3560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81"), v); pt.insert(hex("3560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590"), v); pt.insert(hex("243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185"), v); pt.insert(hex("2090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100"), v); pt.insert(hex("20818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286"), v); pt.insert(hex("20036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154"), v); pt.insert(hex("200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260200191508054801561"), v); pt.insert(hex("1916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020019150"), v); pt.insert(hex("16815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152602001915080"), v); pt.insert(hex("0a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152602001"), v); pt.insert(hex("043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f"), v); pt.insert(hex("0380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281"), v); pt.insert(hex("036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481"), v); pt.insert(hex("031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260200191"), v); pt.insert(hex("0191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020019150805480156104"), v); pt.insert(hex("01836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283"), v); pt.insert(hex("01000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260"), v); pt.insert(hex("006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485"), v); pt.insert(hex("000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020"), v); pt.insert(hex("600052602060002090"), v); pt.insert(hex("820191906000526020600020905b81"), v); pt.insert(hex("00000000000000000000000000"), v); pt.insert(hex("ffffff1681565b60"), v); pt.insert(hex("60a060020a033316600090815261"), v); pt.insert(hex("ffff168152602001"), v); pt.insert(hex("0000000000000000"), v); pt.insert(hex("6004602084601f0104600302600f01f15090"), v); pt.insert(hex("000000000000000000000000"), v); pt.insert(hex("60a060020a033316600090815260"), v); pt.insert(hex("600160a060020a033316"), v); pt.insert(hex("0460209081526040808320849055600590"), v); pt.insert(hex("f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020018083116103c1"), v); pt.insert(hex("9250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001"), v); pt.insert(hex("910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b815481529060010190602001808311"), v); pt.insert(hex("90f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020018083116103"), v); pt.insert(hex("9081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467"), v); pt.insert(hex("900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffff"), v); pt.insert(hex("8252519081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60"), v); pt.insert(hex("81900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ff"), v); pt.insert(hex("80910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020018083"), v); pt.insert(hex("606060405260e060020a60003504630a3b0a4f81146100315780634e71d92d14"), v); pt.insert(hex("6060405260e060020a60003504630a3b0a4f81146100315780634e71d92d1461"), v); pt.insert(hex("60405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020"), v); pt.insert(hex("60200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffffff"), v); pt.insert(hex("52519081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b6002"), v); pt.insert(hex("519081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b600254"), v); pt.insert(hex("5180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001019060200180"), v); pt.insert(hex("5060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001019060"), v); pt.insert(hex("505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b815481529060010190"), v); pt.insert(hex("50505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101"), v); pt.insert(hex("405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b815481529060010190602001"), v); pt.insert(hex("200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffffffff"), v); pt.insert(hex("0390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001019060200180831161"), v); pt.insert(hex("0360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffff"), v); pt.insert(hex("0190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffffffffff"), v); pt.insert(hex("91906000526020600020905b8154815290600101"), v); pt.insert(hex("906000526020600020905b815481529060010190"), v); pt.insert(hex("820191906000526020600020905b815481529060"), v); pt.insert(hex("6020600020905b81548152906001019060200180"), v); pt.insert(hex("60200191505060405180910390f35b"), v); pt.insert(hex("6000526020600020905b81548152906001019060"), v); pt.insert(hex("600020905b815481529060010190602001808311"), v); pt.insert(hex("57820191906000526020600020905b8154815290"), v); pt.insert(hex("526020600020905b815481529060010190602001"), v); pt.insert(hex("20600020905b8154815290600101906020018083"), v); pt.insert(hex("0191906000526020600020905b81548152906001"), v); pt.insert(hex("00526020600020905b8154815290600101906020"), v); pt.insert(hex("0020905b81548152906001019060200180831161"), v); pt.insert(hex("50505060405180910390"), v); pt.insert(hex("57823582600050559160200191906001019061"), v); pt.insert(hex("0191906000526020600020905b81"), v); pt.insert(hex("602001600020600050"), v); pt.insert(hex("a060020a033316600090815261"), v); pt.insert(hex("04602084601f0104600302600f01f15090"), v); pt.insert(hex("ffff168152602001908152602001600020600050"), v); pt.insert(hex("006004602084601f0104600302600f01f1509050"), v); pt.insert(hex("906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b"), v); pt.insert(hex("9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681"), v); pt.insert(hex("81815233600160a060020a031682526001602090815260409283902080549182"), v); pt.insert(hex("6101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("60606040526000357c0100000000000000000000000000000000000000000000"), v); pt.insert(hex("606040526000357c010000000000000000000000000000000000000000000000"), v); pt.insert(hex("6040526000357c01000000000000000000000000000000000000000000000000"), v); pt.insert(hex("565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192"), v); pt.insert(hex("54906101000a900473ffffffffffffffffffffffffffffffffffffffff168156"), v); pt.insert(hex("526000357c010000000000000000000000000000000000000000000000000000"), v); pt.insert(hex("40526000357c0100000000000000000000000000000000000000000000000000"), v); pt.insert(hex("018367ffffffffffffffff16815260200150600360005060003373ffffffffff"), v); pt.insert(hex("20905b81548152906001019060200180831161"), v); pt.insert(hex("0052602060002090"), v); pt.insert(hex("a060020a033316600090815260"), v); pt.insert(hex("9081101561000257"), v); pt.insert(hex("0000000000000000000000"), v); pt.insert(hex("200191505060405180910390f35b"), v); pt.insert(hex("ff168152602001908152602001600020600050"), v); pt.insert(hex("6004602084601f0104600302600f01f1509050"), v); pt.insert(hex("0160a060020a033316"), v); pt.insert(hex("91906000526020600020905b81"), v); pt.insert(hex("602084601f0104600302600f01f15090"), v); pt.insert(hex("546802b5e3af16b187ff"), v); pt.insert(hex("905b81548152906001019060200180831161"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392"), v); pt.insert(hex("ffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290"), v); pt.insert(hex("ffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092"), v); pt.insert(hex("ffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201"), v); pt.insert(hex("ffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191"), v); pt.insert(hex("ffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181"), v); pt.insert(hex("ffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190"), v); pt.insert(hex("ff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084"), v); pt.insert(hex("f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382906000600460208460"), v); pt.insert(hex("f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060"), v); pt.insert(hex("935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795"), v); pt.insert(hex("9250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083"), v); pt.insert(hex("918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302"), v); pt.insert(hex("915080519060200190808383829060006004602084601f0104600302600f01f1"), v); pt.insert(hex("915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182525190819003"), v); pt.insert(hex("910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382906000600460"), v); pt.insert(hex("90f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084"), v); pt.insert(hex("90935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077"), v); pt.insert(hex("9081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f1"), v); pt.insert(hex("90815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035"), v); pt.insert(hex("90808383829060006004602084601f0104600302600f01f15090509081019060"), v); pt.insert(hex("906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffff"), v); pt.insert(hex("90602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040"), v); pt.insert(hex("9060200190808383829060006004602084601f0104600302600f01f150905090"), v); pt.insert(hex("9060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190"), v); pt.insert(hex("9060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183"), v); pt.insert(hex("9060006004602084601f0104600302600f01f150905090810190601f16801561"), v); pt.insert(hex("9060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281"), v); pt.insert(hex("9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673"), v); pt.insert(hex("9050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001"), v); pt.insert(hex("900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffff"), v); pt.insert(hex("900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f15090"), v); pt.insert(hex("84601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151"), v); pt.insert(hex("8383829060006004602084601f0104600302600f01f150905090810190601f16"), v); pt.insert(hex("8383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020"), v); pt.insert(hex("83829060006004602084601f0104600302600f01f150905090810190601f1680"), v); pt.insert(hex("83829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001"), v); pt.insert(hex("838181518152602001915080519060200190808383829060006004602084601f"), v); pt.insert(hex("838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080"), v); pt.insert(hex("836020036101000a031916815260200191505b509250505060405180910390f3"), v); pt.insert(hex("829060006004602084601f0104600302600f01f150905090810190601f168015"), v); pt.insert(hex("829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182"), v); pt.insert(hex("8281038252838181518152602001915080519060200190808383829060006004"), v); pt.insert(hex("82565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284"), v); pt.insert(hex("8252838181518152602001915080519060200190808383829060006004602084"), v); pt.insert(hex("8252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f010460030260"), v); pt.insert(hex("820380516001836020036101000a031916815260200191505b50925050506040"), v); pt.insert(hex("81900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150"), v); pt.insert(hex("8181518152602001915080519060200190808383829060006004602084601f01"), v); pt.insert(hex("8181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051"), v); pt.insert(hex("8152602001915080519060200190808383829060006004602084601f01046003"), v); pt.insert(hex("8152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252"), v); pt.insert(hex("815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594"), v); pt.insert(hex("81518152602001915080519060200190808383829060006004602084601f0104"), v); pt.insert(hex("81518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191"), v); pt.insert(hex("8103825283818151815260200191508051906020019080838382906000600460"), v); pt.insert(hex("80910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004"), v); pt.insert(hex("808383829060006004602084601f0104600302600f01f150905090810190601f"), v); pt.insert(hex("808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060"), v); pt.insert(hex("80820380516001836020036101000a031916815260200191505b509250505060"), v); pt.insert(hex("805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494"), v); pt.insert(hex("8051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f010460"), v); pt.insert(hex("80519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191825251908190036020"), v); pt.insert(hex("8051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750949550"), v); pt.insert(hex("80516001836020036101000a031916815260200191505b509250505060405180"), v); pt.insert(hex("8035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750949550505050505060"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffff"), v); pt.insert(hex("6c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590845282"), v); pt.insert(hex("67ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093"), v); pt.insert(hex("6101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffff"), v); pt.insert(hex("61006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084"), v); pt.insert(hex("60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f01"), v); pt.insert(hex("60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284375094"), v); pt.insert(hex("60405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060"), v); pt.insert(hex("60248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284375094955050505050"), v); pt.insert(hex("602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381"), v); pt.insert(hex("602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437509495505050"), v); pt.insert(hex("6020036101000a031916815260200191505b509250505060405180910390f35b"), v); pt.insert(hex("602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051"), v); pt.insert(hex("602001915080519060200190808383829060006004602084601f010460030260"), v); pt.insert(hex("602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182525190"), v); pt.insert(hex("60200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090"), v); pt.insert(hex("60200190808383829060006004602084601f0104600302600f01f15090509081"), v); pt.insert(hex("60200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f3"), v); pt.insert(hex("6020018281038252838181518152602001915080519060200190808383829060"), v); pt.insert(hex("601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181"), v); pt.insert(hex("600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080"), v); pt.insert(hex("6004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252"), v); pt.insert(hex("600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001"), v); pt.insert(hex("6001836020036101000a031916815260200191505b5092505050604051809103"), v); pt.insert(hex("60010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382"), v); pt.insert(hex("60006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103"), v); pt.insert(hex("6000600050600060016000506000868152602001908152602001600020600050"), v); pt.insert(hex("5b61006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590"), v); pt.insert(hex("5b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f"), v); pt.insert(hex("5b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750"), v); pt.insert(hex("5780820380516001836020036101000a031916815260200191505b5092505050"), v); pt.insert(hex("565b61006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255"), v); pt.insert(hex("565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437"), v); pt.insert(hex("54906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ff"), v); pt.insert(hex("5467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490"), v); pt.insert(hex("5290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590"), v); pt.insert(hex("5283818151815260200191508051906020019080838382906000600460208460"), v); pt.insert(hex("52602001915080519060200190808383829060006004602084601f0104600302"), v); pt.insert(hex("52602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191825251"), v); pt.insert(hex("52519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f"), v); pt.insert(hex("5220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460"), v); pt.insert(hex("51918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f01046003"), v); pt.insert(hex("519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01"), v); pt.insert(hex("519060200190808383829060006004602084601f0104600302600f01f1509050"), v); pt.insert(hex("519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182525190819003602001"), v); pt.insert(hex("518152602001915080519060200190808383829060006004602084601f010460"), v); pt.insert(hex("518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182"), v); pt.insert(hex("5180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083838290600060"), v); pt.insert(hex("51602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284375094955050"), v); pt.insert(hex("516001836020036101000a031916815260200191505b50925050506040518091"), v); pt.insert(hex("509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020"), v); pt.insert(hex("5080519060200190808383829060006004602084601f0104600302600f01f150"), v); pt.insert(hex("5080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360"), v); pt.insert(hex("5060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083838290"), v); pt.insert(hex("505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382"), v); pt.insert(hex("50505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383"), v); pt.insert(hex("50019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190"), v); pt.insert(hex("408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104"), v); pt.insert(hex("408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437509495"), v); pt.insert(hex("405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382906000"), v); pt.insert(hex("248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437509495505050505050"), v); pt.insert(hex("2084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181"), v); pt.insert(hex("20805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044"), v); pt.insert(hex("2060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750949550505050"), v); pt.insert(hex("2002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180"), v); pt.insert(hex("2001915080519060200190808383829060006004602084601f0104600302600f"), v); pt.insert(hex("2001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081"), v); pt.insert(hex("200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f15090509081"), v); pt.insert(hex("200190808383829060006004602084601f0104600302600f01f1509050908101"), v); pt.insert(hex("200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b"), v); pt.insert(hex("2001828103825283818151815260200191508051906020019080838382906000"), v); pt.insert(hex("1f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152"), v); pt.insert(hex("169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401"), v); pt.insert(hex("0f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051"), v); pt.insert(hex("0a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffff"), v); pt.insert(hex("0473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffff"), v); pt.insert(hex("04602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283"), v); pt.insert(hex("04600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020"), v); pt.insert(hex("0390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083838290600060046020"), v); pt.insert(hex("0382528381815181526020019150805190602001908083838290600060046020"), v); pt.insert(hex("0380516001836020036101000a031916815260200191505b5092505050604051"), v); pt.insert(hex("0360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f1509050"), v); pt.insert(hex("0302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191"), v); pt.insert(hex("02808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080"), v); pt.insert(hex("02600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150"), v); pt.insert(hex("01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190"), v); pt.insert(hex("019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080"), v); pt.insert(hex("01915080519060200190808383829060006004602084601f0104600302600f01"), v); pt.insert(hex("01915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191825251908190"), v); pt.insert(hex("0190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f1509050908101"), v); pt.insert(hex("0190808383829060006004602084601f0104600302600f01f150905090810190"), v); pt.insert(hex("0190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60"), v); pt.insert(hex("01836020036101000a031916815260200191505b509250505060405180910390"), v); pt.insert(hex("0182810382528381815181526020019150805190602001908083838290600060"), v); pt.insert(hex("0182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082"), v); pt.insert(hex("0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260"), v); pt.insert(hex("010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280"), v); pt.insert(hex("01000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffff"), v); pt.insert(hex("006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255908452"), v); pt.insert(hex("006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382"), v); pt.insert(hex("0060005060006001600050600086815260200190815260200160002060005060"), v); pt.insert(hex("000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffff"), v); Bytes data = hex( "6060604052361561008a576000357c01000000000000000000000000000000000000000000000000000000009004806301cb3b20146102e357806329dcb0cf14" "6102f057806338af3eed146103115780636e66f6e9146103485780637a3a0e841461037f5780637b3e5e7b146103a0578063a035b1fe146103c1578063dc0d3d" "ff146103e25761008a565b6102e15b60006000600660005060066000508054600101908181548183558181151161011957600202816002028360005260206000" "20918201910161011891906100cf565b808211156101145760006000820160006101000a81549073ffffffffffffffffffffffffffffffffffffffff02191690" "556001820160005060009055506001016100cf565b5090565b5b5050508154811015610002579060005260206000209060020201600091509150338282506000" "0160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908302179055503482825060010160005081905550818150600101600050" "546002600082828250540192505081905550600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffff" "ffffffffffffffffffff166390b98a11336004600050548585506001016000505404604051837c01000000000000000000000000000000000000000000000000" "00000000028152600401808373ffffffffffffffffffffffffffffffffffffffff168152602001828152602001925050506020604051808303816000876161da" "5a03f1156100025750505060405151507fe842aea7a5f1b01049d752008c53c52890b1a6daf660cf39e8eec506112bbdf682825060000160009054906101000a" "900473ffffffffffffffffffffffffffffffffffffffff16838350600101600050546001604051808473ffffffffffffffffffffffffffffffffffffffff1681" "52602001838152602001828152602001935050505060405180910390a15b5050565b005b6102ee6004506104ec565b005b6102fb60045061045e565b60405180" "82815260200191505060405180910390f35b61031c600450610426565b604051808273ffffffffffffffffffffffffffffffffffffffff168152602001915050" "60405180910390f35b610353600450610470565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b" "61038a60045061044c565b6040518082815260200191505060405180910390f35b6103ab600450610455565b6040518082815260200191505060405180910390" "f35b6103cc600450610467565b6040518082815260200191505060405180910390f35b6103f3600480359060200150610496565b604051808373ffffffffffff" "ffffffffffffffffffffffffffff1681526020018281526020019250505060405180910390f35b600060009054906101000a900473ffffffffffffffffffffff" "ffffffffffffffffff1681565b60016000505481565b60026000505481565b60036000505481565b60046000505481565b600560009054906101000a900473ff" "ffffffffffffffffffffffffffffffffffffff1681565b6006600050818154811015610002579060005260206000209060020201600091509050806000016000" "9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16908060010160005054905082565b6000600360005054421015156107fc57600160" "0050546002600050541015156105f357600060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffff" "ffffffffffffffff166000600260005054604051809050600060405180830381858888f19350505050507fe842aea7a5f1b01049d752008c53c52890b1a6daf6" "60cf39e8eec506112bbdf6600060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166002600050546000604051808473ffffffff" "ffffffffffffffffffffffffffffffff168152602001838152602001828152602001935050505060405180910390a16107c1565b7fe842aea7a5f1b01049d752" "008c53c52890b1a6daf660cf39e8eec506112bbdf66000600b600060405180848152602001838152602001828152602001935050505060405180910390a16000" "90505b6006600050548110156107c057600660005081815481101561000257906000526020600020906002020160005060000160009054906101000a900473ff" "ffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1660006006600050838154811015610002579060005260" "20600020906002020160005060010160005054604051809050600060405180830381858888f19350505050507fe842aea7a5f1b01049d752008c53c52890b1a6" "daf660cf39e8eec506112bbdf6600660005082815481101561000257906000526020600020906002020160005060000160009054906101000a900473ffffffff" "ffffffffffffffffffffffffffffffff166006600050838154811015610002579060005260206000209060020201600050600101600050546000604051808473" "ffffffffffffffffffffffffffffffffffffffff168152602001838152602001828152602001935050505060405180910390a15b806001019050805061064256" "5b5b600060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b5b5056"); PatriciaTreeMatchFinder mf(pt); auto& matches = mf.find_longest_matches(data); REQUIRE(matches.size() == 234); } TEST_CASE("PatriciaTreeMatchFinder7") { int id = 0; int* v = &id; PatriciaTree pt; pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffff16"), v); pt.insert(hex("600160a060020a03"), v); pt.insert(hex("ffffffffffffffffffffffffffffff16815260200191505060405180910390a1"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff1681"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff168156"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff1681565b"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff168152602001908152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff16815260200190815260200160"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff1681526020019081526020016000"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff168152602001908152602001600020"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff16815260200190815260200160002060"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1681526020019081526020016000206000"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffffff1681526020019081526020"), v); pt.insert(hex("81526020019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff168152"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff16815260"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1681526020"), v); pt.insert(hex("ffffffffffffffffffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffffffff168152602001"), v); pt.insert(hex("526020019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1682"), v); pt.insert(hex("6020019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffffff168152602001"), v); pt.insert(hex("8152602001908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffffff168152602001"), v); pt.insert(hex("80806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f16801561"), v); pt.insert(hex("60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f16"), v); pt.insert(hex("5b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f"), v); pt.insert(hex("5180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f168015"), v); pt.insert(hex("405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680"), v); pt.insert(hex("20019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffffff168152602001"), v); pt.insert(hex("52602001908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffff1681565b60"), v); pt.insert(hex("019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffff168152602001"), v); pt.insert(hex("1681526020019081526020016000206000"), v); pt.insert(hex("602001908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffff1682"), v); pt.insert(hex("ffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffffffffff1681565b60"), v); pt.insert(hex("ffffffffffff168152602001"), v); pt.insert(hex("ffffffffffffffffffffffffffff168152602001908152602001600020600050"), v); pt.insert(hex("9081526020016000206000"), v); pt.insert(hex("5050604051849350600080"), v); pt.insert(hex("2001908152602001600020600050"), v); pt.insert(hex("505060405180910390f35b"), v); pt.insert(hex("ffffffffffffffffffffff1682"), v); pt.insert(hex("6000506000600060005054815260200190815260200160002060006101000a81"), v); pt.insert(hex("00506000600060005054815260200190815260200160002060006101000a8154"), v); pt.insert(hex("ffffffffffff1681565b60"), v); pt.insert(hex("ffffff16815260200191505060405180910390a1"), v); pt.insert(hex("ffffffffff168152602001"), v); pt.insert(hex("8281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a4578082"), v); pt.insert(hex("81038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a457808203"), v); pt.insert(hex("6020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a4"), v); pt.insert(hex("60005060003373ffffffffffffffffffffffffffffffffffffffff1681526020"), v); pt.insert(hex("60003373ffffffffffffffffffffffffffffffffffffffff1681526020019081"), v); pt.insert(hex("5060003373ffffffffffffffffffffffffffffffffffffffff16815260200190"), v); pt.insert(hex("3373ffffffffffffffffffffffffffffffffffffffff16815260200190815260"), v); pt.insert(hex("20018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a457"), v); pt.insert(hex("038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a45780820380"), v); pt.insert(hex("018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100a45780"), v); pt.insert(hex("005060003373ffffffffffffffffffffffffffffffffffffffff168152602001"), v); pt.insert(hex("003373ffffffffffffffffffffffffffffffffffffffff168152602001908152"), v); pt.insert(hex("01908152602001600020600050"), v); pt.insert(hex("ffffffffffffffffffffffffff16815260200190"), v); pt.insert(hex("ffffffffffffffffffffffff1681526020019081"), v); pt.insert(hex("ffffffffffffffffffffff168152602001908152"), v); pt.insert(hex("ffffffffffffffffffff16815260200190815260"), v); pt.insert(hex("ffffffffffffffffff1681526020019081526020"), v); pt.insert(hex("ffffffffffffffff168152602001908152602001"), v); pt.insert(hex("ffffffffffffff16815260200190815260200160"), v); pt.insert(hex("ffffffffffff1681526020019081526020016000"), v); pt.insert(hex("ffffffffff168152602001908152602001600020"), v); pt.insert(hex("ffffffff16815260200190815260200160002060"), v); pt.insert(hex("ffffff1681526020019081526020016000206000"), v); pt.insert(hex("81526020016000206000"), v); pt.insert(hex("50604051849350600080"), v); pt.insert(hex("ffffffffffffffffffff1682"), v); pt.insert(hex("5060405180910390f35b"), v); pt.insert(hex("168152602001908152602001600020600050"), v); pt.insert(hex("ffff16815260200191505060405180910390a1"), v); pt.insert(hex("67ffffffffffffffff"), v); pt.insert(hex("ffffffffffffffff1682"), v); pt.insert(hex("ffff1681526020019081526020016000206000"), v); pt.insert(hex("6040518082815260200191505060405180910390"), v); pt.insert(hex("ffffffffff1681565b60"), v); pt.insert(hex("908152602001600020600050"), v); pt.insert(hex("8281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390"), v); pt.insert(hex("81038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f3"), v); pt.insert(hex("80806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f150905001925050506040"), v); pt.insert(hex("806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192505050604051"), v); pt.insert(hex("60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f150905001925050"), v); pt.insert(hex("6020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180"), v); pt.insert(hex("5b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250"), v); pt.insert(hex("5180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060"), v); pt.insert(hex("405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192505050"), v); pt.insert(hex("20018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f150905001925050506040518091"), v); pt.insert(hex("038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b"), v); pt.insert(hex("018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192505050604051809103"), v); pt.insert(hex("ffffffff168152602001"), v); pt.insert(hex("5b60405180828152602001915050604051809103"), v); pt.insert(hex("565b604051808281526020019150506040518091"), v); pt.insert(hex("518082815260200191505060405180910390f35b"), v); pt.insert(hex("40518082815260200191505060405180910390f3"), v); pt.insert(hex("ff16815260200191505060405180910390a1"), v); pt.insert(hex("ffffffffffffffffff1682"), v); pt.insert(hex("808281526102cb94909290828280156100d757"), v); pt.insert(hex("ff1681526020019081526020016000206000"), v); pt.insert(hex("526020016000206000"), v); pt.insert(hex("f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f15090509081019060"), v); pt.insert(hex("a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084528284209192849261"), v); pt.insert(hex("90f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190"), v); pt.insert(hex("8252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60"), v); pt.insert(hex("60a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590845282842091928492"), v); pt.insert(hex("602081815260408083206002548452825282208354815467ffffffffffffffff191667ffffffffffffffff919091161781556001848101805491830180548382"), v); pt.insert(hex("600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084528284"), v); pt.insert(hex("600160a060020a0333168252602082815260408084208585528252928390206001018054601f810183900490920260a090810190945260808281529293909190"), v); pt.insert(hex("600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084528284209192"), v); pt.insert(hex("60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("52838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040"), v); pt.insert(hex("52600160a060020a0333168252602082815260408084208585528252928390206001018054601f810183900490920260a0908101909452608082815292939091"), v); pt.insert(hex("526000828152604090208054829081101561000257506000908152602090200154905081565b610315600435600160a060020a03331660009081526020818152"), v); pt.insert(hex("35600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590845282842091"), v); pt.insert(hex("2081815260408083206002548452825282208354815467ffffffffffffffff191667ffffffffffffffff91909116178155600184810180549183018054838255"), v); pt.insert(hex("0435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255908452828420"), v); pt.insert(hex("0160a060020a0333168252602082815260408084208585528252928390206001018054601f810183900490920260a09081019094526080828152929390919082"), v); pt.insert(hex("0160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255908452828420919284"), v); pt.insert(hex("009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("60405180910390f35b"), v); pt.insert(hex("8082815260200191505060405180910390f35b"), v); pt.insert(hex("ffffffffffffff1682"), v); pt.insert(hex("600160a060020a033316600090815261"), v); pt.insert(hex("8152602001600020600050"), v); pt.insert(hex("90600052602060002090"), v); pt.insert(hex("928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160405260"), v); pt.insert(hex("836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782"), v); pt.insert(hex("822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160405260608481526100"), v); pt.insert(hex("820380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080"), v); pt.insert(hex("818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160"), v); pt.insert(hex("8152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285016040"), v); pt.insert(hex("8152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285016040526060"), v); pt.insert(hex("815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020"), v); pt.insert(hex("80822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052606084815261"), v); pt.insert(hex("80820380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c0908490"), v); pt.insert(hex("80519060200190808383829060006004602084601f0104600302600f01f15090"), v); pt.insert(hex("80516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c0908490801561"), v); pt.insert(hex("6101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201919060"), v); pt.insert(hex("604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402850160405260608481"), v); pt.insert(hex("60243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590"), v); pt.insert(hex("6020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285"), v); pt.insert(hex("6020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201"), v); pt.insert(hex("60200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b"), v); pt.insert(hex("60043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81"), v); pt.insert(hex("6001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de"), v); pt.insert(hex("60006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094"), v); pt.insert(hex("5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c09084"), v); pt.insert(hex("52928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052"), v); pt.insert(hex("52604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052606084"), v); pt.insert(hex("5260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190600052602060002090"), v); pt.insert(hex("516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103"), v); pt.insert(hex("4080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490940285016040526060848152"), v); pt.insert(hex("3560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185"), v); pt.insert(hex("3560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f810185900490"), v); pt.insert(hex("243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004"), v); pt.insert(hex("2090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501604052606084815261006c"), v); pt.insert(hex("20818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f81018590049094028501"), v); pt.insert(hex("20036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191"), v); pt.insert(hex("200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81"), v); pt.insert(hex("1916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190600052602060"), v); pt.insert(hex("16815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201919060005260206000"), v); pt.insert(hex("0a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de578201919060005260"), v); pt.insert(hex("043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101"), v); pt.insert(hex("0380516001836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c09084908015"), v); pt.insert(hex("036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190"), v); pt.insert(hex("031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020"), v); pt.insert(hex("0191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154"), v); pt.insert(hex("01836020036101000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57"), v); pt.insert(hex("01000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000"), v); pt.insert(hex("006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6080602060248035600481810135601f8101859004909402"), v); pt.insert(hex("000a031916815260200191505b509250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de5782019190600052"), v); pt.insert(hex("ffffffff1681565b60"), v); pt.insert(hex("60006005600a4306101561032f57600190506103"), v); pt.insert(hex("600160a060020a033316600090815260"), v); pt.insert(hex("ffffff168152602001"), v); pt.insert(hex("82815260200191505060405180910390f35b"), v); pt.insert(hex("9060006004602084601f0104600302600f01f150"), v); pt.insert(hex("8383829060006004602084601f0104600302600f"), v); pt.insert(hex("83829060006004602084601f0104600302600f01"), v); pt.insert(hex("829060006004602084601f0104600302600f01f1"), v); pt.insert(hex("808383829060006004602084601f010460030260"), v); pt.insert(hex("60006004602084601f0104600302600f01f15090"), v); pt.insert(hex("815260200191505060405180910390f35b"), v); pt.insert(hex("0000000000000000000000000000"), v); pt.insert(hex("8352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290918301828280"), v); pt.insert(hex("83526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293929091"), v); pt.insert(hex("81810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293"), v); pt.insert(hex("810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392"), v); pt.insert(hex("808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392909183018282"), v); pt.insert(hex("8051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280"), v); pt.insert(hex("60408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095"), v); pt.insert(hex("602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552"), v); pt.insert(hex("60043560408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184"), v); pt.insert(hex("600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392909183018282801561"), v); pt.insert(hex("6000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290918301"), v); pt.insert(hex("6000526020600020"), v); pt.insert(hex("52600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293929091830182828015"), v); pt.insert(hex("526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552808552929392909183"), v); pt.insert(hex("51602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085"), v); pt.insert(hex("408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401909552"), v); pt.insert(hex("3560408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190"), v); pt.insert(hex("2081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292"), v); pt.insert(hex("043560408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f8201849004840281018401"), v); pt.insert(hex("0183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290"), v); pt.insert(hex("0160a060020a0333168152808252838120858252825283902060010180548451601f820184900484028101840190955280855292939290918301828280156101"), v); pt.insert(hex("00808352600160a060020a0333168152808252838120858252825283902060010180548451601f82018490048402810184019095528085529293929091830182"), v); pt.insert(hex("0160a060020a033316600090815261"), v); pt.insert(hex("006005600a4306101561032f57600190506103"), v); pt.insert(hex("6020016000206000"), v); pt.insert(hex("000000000000000000"), v); pt.insert(hex("7c01000000000000000000000000000000000000000000000000000000009004"), v); pt.insert(hex("6000357c01000000000000000000000000000000000000000000000000000000"), v); pt.insert(hex("357c010000000000000000000000000000000000000000000000000000000090"), v); pt.insert(hex("0100000000000000000000000000000000000000000000000000000000900480"), v); pt.insert(hex("00357c0100000000000000000000000000000000000000000000000000000000"), v); pt.insert(hex("0000000000000000000000000000000000000000000000000000000090048063"), v); pt.insert(hex("0160a060020a033316600090815260"), v); pt.insert(hex("405180910390f35b"), v); pt.insert(hex("006004602084601f0104600302600f01f15090"), v); pt.insert(hex("52602001600020600050"), v); pt.insert(hex("ffffffffffff1682"), v); pt.insert(hex("600460209081526040808320849055600590"), v); pt.insert(hex("928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190"), v); pt.insert(hex("836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381"), v); pt.insert(hex("822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261"), v); pt.insert(hex("820380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182"), v); pt.insert(hex("818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601"), v); pt.insert(hex("8152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185"), v); pt.insert(hex("8152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096"), v); pt.insert(hex("815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260200191508054"), v); pt.insert(hex("80822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552"), v); pt.insert(hex("80820380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001"), v); pt.insert(hex("806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156104"), v); pt.insert(hex("80516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103"), v); pt.insert(hex("6101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152"), v); pt.insert(hex("604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285"), v); pt.insert(hex("60243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101"), v); pt.insert(hex("6020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502"), v); pt.insert(hex("6020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181"), v); pt.insert(hex("60200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152602001915080548015"), v); pt.insert(hex("60043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b6040805160206024803560048181013560"), v); pt.insert(hex("6001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252"), v); pt.insert(hex("60006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004"), v); pt.insert(hex("5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020"), v); pt.insert(hex("52928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501"), v); pt.insert(hex("52604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652"), v); pt.insert(hex("5260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020019150805480"), v); pt.insert(hex("5260200191505060405180910390f35b"), v); pt.insert(hex("516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382"), v); pt.insert(hex("4080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585"), v); pt.insert(hex("3560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81"), v); pt.insert(hex("3560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590"), v); pt.insert(hex("243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185"), v); pt.insert(hex("2090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100"), v); pt.insert(hex("20818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286"), v); pt.insert(hex("20036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154"), v); pt.insert(hex("200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260200191508054801561"), v); pt.insert(hex("1916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020019150"), v); pt.insert(hex("16815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152602001915080"), v); pt.insert(hex("0a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281038252838181548152602001"), v); pt.insert(hex("043560243560006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f"), v); pt.insert(hex("0380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff168152602001806020018281"), v); pt.insert(hex("036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481"), v); pt.insert(hex("031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260200191"), v); pt.insert(hex("0191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020019150805480156104"), v); pt.insert(hex("01836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283"), v); pt.insert(hex("01000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180602001828103825283818154815260"), v); pt.insert(hex("006020818152928152604080822090935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485"), v); pt.insert(hex("000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff1681526020018060200182810382528381815481526020"), v); pt.insert(hex("600052602060002090"), v); pt.insert(hex("820191906000526020600020905b81"), v); pt.insert(hex("00000000000000000000000000"), v); pt.insert(hex("ffffff1681565b60"), v); pt.insert(hex("60a060020a033316600090815261"), v); pt.insert(hex("ffff168152602001"), v); pt.insert(hex("0000000000000000"), v); pt.insert(hex("6004602084601f0104600302600f01f15090"), v); pt.insert(hex("000000000000000000000000"), v); pt.insert(hex("60a060020a033316600090815260"), v); pt.insert(hex("600160a060020a033316"), v); pt.insert(hex("0460209081526040808320849055600590"), v); pt.insert(hex("f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020018083116103c1"), v); pt.insert(hex("9250505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001"), v); pt.insert(hex("910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b815481529060010190602001808311"), v); pt.insert(hex("90f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020018083116103"), v); pt.insert(hex("9081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467"), v); pt.insert(hex("900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffff"), v); pt.insert(hex("8252519081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60"), v); pt.insert(hex("81900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ff"), v); pt.insert(hex("80910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020018083"), v); pt.insert(hex("606060405260e060020a60003504630a3b0a4f81146100315780634e71d92d14"), v); pt.insert(hex("6060405260e060020a60003504630a3b0a4f81146100315780634e71d92d1461"), v); pt.insert(hex("60405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101906020"), v); pt.insert(hex("60200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffffff"), v); pt.insert(hex("52519081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b6002"), v); pt.insert(hex("519081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b600254"), v); pt.insert(hex("5180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001019060200180"), v); pt.insert(hex("5060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001019060"), v); pt.insert(hex("505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b815481529060010190"), v); pt.insert(hex("50505060405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b8154815290600101"), v); pt.insert(hex("405180910390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b815481529060010190602001"), v); pt.insert(hex("200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffffffff"), v); pt.insert(hex("0390f35b606082815260406080908152825460a081905260c090849080156103de57820191906000526020600020905b81548152906001019060200180831161"), v); pt.insert(hex("0360200190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffff"), v); pt.insert(hex("0190f35b60408051600160a060020a03929092168252519081900360200190f35b60408051918252519081900360200190f35b50815b60025467ffffffffffff"), v); pt.insert(hex("91906000526020600020905b8154815290600101"), v); pt.insert(hex("906000526020600020905b815481529060010190"), v); pt.insert(hex("820191906000526020600020905b815481529060"), v); pt.insert(hex("6020600020905b81548152906001019060200180"), v); pt.insert(hex("60200191505060405180910390f35b"), v); pt.insert(hex("6000526020600020905b81548152906001019060"), v); pt.insert(hex("600020905b815481529060010190602001808311"), v); pt.insert(hex("57820191906000526020600020905b8154815290"), v); pt.insert(hex("526020600020905b815481529060010190602001"), v); pt.insert(hex("20600020905b8154815290600101906020018083"), v); pt.insert(hex("0191906000526020600020905b81548152906001"), v); pt.insert(hex("00526020600020905b8154815290600101906020"), v); pt.insert(hex("0020905b81548152906001019060200180831161"), v); pt.insert(hex("50505060405180910390"), v); pt.insert(hex("57823582600050559160200191906001019061"), v); pt.insert(hex("0191906000526020600020905b81"), v); pt.insert(hex("602001600020600050"), v); pt.insert(hex("a060020a033316600090815261"), v); pt.insert(hex("04602084601f0104600302600f01f15090"), v); pt.insert(hex("ffff168152602001908152602001600020600050"), v); pt.insert(hex("006004602084601f0104600302600f01f1509050"), v); pt.insert(hex("906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b"), v); pt.insert(hex("9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681"), v); pt.insert(hex("81815233600160a060020a031682526001602090815260409283902080549182"), v); pt.insert(hex("6101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60"), v); pt.insert(hex("60606040526000357c0100000000000000000000000000000000000000000000"), v); pt.insert(hex("606040526000357c010000000000000000000000000000000000000000000000"), v); pt.insert(hex("6040526000357c01000000000000000000000000000000000000000000000000"), v); pt.insert(hex("565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f15090500192"), v); pt.insert(hex("54906101000a900473ffffffffffffffffffffffffffffffffffffffff168156"), v); pt.insert(hex("526000357c010000000000000000000000000000000000000000000000000000"), v); pt.insert(hex("40526000357c0100000000000000000000000000000000000000000000000000"), v); pt.insert(hex("018367ffffffffffffffff16815260200150600360005060003373ffffffffff"), v); pt.insert(hex("20905b81548152906001019060200180831161"), v); pt.insert(hex("0052602060002090"), v); pt.insert(hex("a060020a033316600090815260"), v); pt.insert(hex("9081101561000257"), v); pt.insert(hex("0000000000000000000000"), v); pt.insert(hex("200191505060405180910390f35b"), v); pt.insert(hex("ff168152602001908152602001600020600050"), v); pt.insert(hex("6004602084601f0104600302600f01f1509050"), v); pt.insert(hex("0160a060020a033316"), v); pt.insert(hex("91906000526020600020905b81"), v); pt.insert(hex("602084601f0104600302600f01f15090"), v); pt.insert(hex("546802b5e3af16b187ff"), v); pt.insert(hex("905b81548152906001019060200180831161"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392"), v); pt.insert(hex("ffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290"), v); pt.insert(hex("ffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092"), v); pt.insert(hex("ffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201"), v); pt.insert(hex("ffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191"), v); pt.insert(hex("ffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181"), v); pt.insert(hex("ffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190"), v); pt.insert(hex("ff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084"), v); pt.insert(hex("f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382906000600460208460"), v); pt.insert(hex("f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060"), v); pt.insert(hex("935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795"), v); pt.insert(hex("9250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083"), v); pt.insert(hex("918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302"), v); pt.insert(hex("915080519060200190808383829060006004602084601f0104600302600f01f1"), v); pt.insert(hex("915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182525190819003"), v); pt.insert(hex("910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382906000600460"), v); pt.insert(hex("90f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084"), v); pt.insert(hex("90935290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077"), v); pt.insert(hex("9081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f1"), v); pt.insert(hex("90815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035"), v); pt.insert(hex("90808383829060006004602084601f0104600302600f01f15090509081019060"), v); pt.insert(hex("906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffff"), v); pt.insert(hex("90602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040"), v); pt.insert(hex("9060200190808383829060006004602084601f0104600302600f01f150905090"), v); pt.insert(hex("9060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190"), v); pt.insert(hex("9060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183"), v); pt.insert(hex("9060006004602084601f0104600302600f01f150905090810190601f16801561"), v); pt.insert(hex("9060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281"), v); pt.insert(hex("9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673"), v); pt.insert(hex("9050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001"), v); pt.insert(hex("900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffff"), v); pt.insert(hex("900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f15090"), v); pt.insert(hex("84601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151"), v); pt.insert(hex("8383829060006004602084601f0104600302600f01f150905090810190601f16"), v); pt.insert(hex("8383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020"), v); pt.insert(hex("83829060006004602084601f0104600302600f01f150905090810190601f1680"), v); pt.insert(hex("83829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001"), v); pt.insert(hex("838181518152602001915080519060200190808383829060006004602084601f"), v); pt.insert(hex("838181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080"), v); pt.insert(hex("836020036101000a031916815260200191505b509250505060405180910390f3"), v); pt.insert(hex("829060006004602084601f0104600302600f01f150905090810190601f168015"), v); pt.insert(hex("829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182"), v); pt.insert(hex("8281038252838181518152602001915080519060200190808383829060006004"), v); pt.insert(hex("82565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284"), v); pt.insert(hex("8252838181518152602001915080519060200190808383829060006004602084"), v); pt.insert(hex("8252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f010460030260"), v); pt.insert(hex("820380516001836020036101000a031916815260200191505b50925050506040"), v); pt.insert(hex("81900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150"), v); pt.insert(hex("8181518152602001915080519060200190808383829060006004602084601f01"), v); pt.insert(hex("8181518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051"), v); pt.insert(hex("8152602001915080519060200190808383829060006004602084601f01046003"), v); pt.insert(hex("8152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252"), v); pt.insert(hex("815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594"), v); pt.insert(hex("81518152602001915080519060200190808383829060006004602084601f0104"), v); pt.insert(hex("81518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191"), v); pt.insert(hex("8103825283818151815260200191508051906020019080838382906000600460"), v); pt.insert(hex("80910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004"), v); pt.insert(hex("808383829060006004602084601f0104600302600f01f150905090810190601f"), v); pt.insert(hex("808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060"), v); pt.insert(hex("80820380516001836020036101000a031916815260200191505b509250505060"), v); pt.insert(hex("805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494"), v); pt.insert(hex("8051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f010460"), v); pt.insert(hex("80519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191825251908190036020"), v); pt.insert(hex("8051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750949550"), v); pt.insert(hex("80516001836020036101000a031916815260200191505b509250505060405180"), v); pt.insert(hex("8035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750949550505050505060"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffff"), v); pt.insert(hex("6c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590845282"), v); pt.insert(hex("67ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093"), v); pt.insert(hex("6101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffff"), v); pt.insert(hex("61006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff191681556001810180548482559084"), v); pt.insert(hex("60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f01"), v); pt.insert(hex("60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284375094"), v); pt.insert(hex("60405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060"), v); pt.insert(hex("60248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284375094955050505050"), v); pt.insert(hex("602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381"), v); pt.insert(hex("602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437509495505050"), v); pt.insert(hex("6020036101000a031916815260200191505b509250505060405180910390f35b"), v); pt.insert(hex("602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051"), v); pt.insert(hex("602001915080519060200190808383829060006004602084601f010460030260"), v); pt.insert(hex("602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182525190"), v); pt.insert(hex("60200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090"), v); pt.insert(hex("60200190808383829060006004602084601f0104600302600f01f15090509081"), v); pt.insert(hex("60200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f3"), v); pt.insert(hex("6020018281038252838181518152602001915080519060200190808383829060"), v); pt.insert(hex("601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181"), v); pt.insert(hex("600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080"), v); pt.insert(hex("6004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252"), v); pt.insert(hex("600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001"), v); pt.insert(hex("6001836020036101000a031916815260200191505b5092505050604051809103"), v); pt.insert(hex("60010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382"), v); pt.insert(hex("60006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103"), v); pt.insert(hex("6000600050600060016000506000868152602001908152602001600020600050"), v); pt.insert(hex("5b61006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff1916815560018101805484825590"), v); pt.insert(hex("5b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f"), v); pt.insert(hex("5b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750"), v); pt.insert(hex("5780820380516001836020036101000a031916815260200191505b5092505050"), v); pt.insert(hex("565b61006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255"), v); pt.insert(hex("565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437"), v); pt.insert(hex("54906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ff"), v); pt.insert(hex("5467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460449490"), v); pt.insert(hex("5290815220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590"), v); pt.insert(hex("5283818151815260200191508051906020019080838382906000600460208460"), v); pt.insert(hex("52602001915080519060200190808383829060006004602084601f0104600302"), v); pt.insert(hex("52602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191825251"), v); pt.insert(hex("52519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f"), v); pt.insert(hex("5220805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100779590359460"), v); pt.insert(hex("51918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f01046003"), v); pt.insert(hex("519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01"), v); pt.insert(hex("519060200190808383829060006004602084601f0104600302600f01f1509050"), v); pt.insert(hex("519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182525190819003602001"), v); pt.insert(hex("518152602001915080519060200190808383829060006004602084601f010460"), v); pt.insert(hex("518152602001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b604080519182"), v); pt.insert(hex("5180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083838290600060"), v); pt.insert(hex("51602060248035600481810135601f81018590048502860185019096528585526100779590359460449490939290920191819084018382808284375094955050"), v); pt.insert(hex("516001836020036101000a031916815260200191505b50925050506040518091"), v); pt.insert(hex("509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020"), v); pt.insert(hex("5080519060200190808383829060006004602084601f0104600302600f01f150"), v); pt.insert(hex("5080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360"), v); pt.insert(hex("5060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083838290"), v); pt.insert(hex("505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382"), v); pt.insert(hex("50505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383"), v); pt.insert(hex("50019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190"), v); pt.insert(hex("408051918252519081900360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104"), v); pt.insert(hex("408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437509495"), v); pt.insert(hex("405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080838382906000"), v); pt.insert(hex("248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280828437509495505050505050"), v); pt.insert(hex("2084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181"), v); pt.insert(hex("20805467ffffffffffffffff169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044"), v); pt.insert(hex("2060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082843750949550505050"), v); pt.insert(hex("2002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180"), v); pt.insert(hex("2001915080519060200190808383829060006004602084601f0104600302600f"), v); pt.insert(hex("2001915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081"), v); pt.insert(hex("200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f15090509081"), v); pt.insert(hex("200190808383829060006004602084601f0104600302600f01f1509050908101"), v); pt.insert(hex("200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b"), v); pt.insert(hex("1f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60405180806020018281038252838181518152"), v); pt.insert(hex("169060010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401"), v); pt.insert(hex("0f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051"), v); pt.insert(hex("0a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffff"), v); pt.insert(hex("0473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffff"), v); pt.insert(hex("04602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283"), v); pt.insert(hex("04600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020"), v); pt.insert(hex("0390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190602001908083838290600060046020"), v); pt.insert(hex("0382528381815181526020019150805190602001908083838290600060046020"), v); pt.insert(hex("0380516001836020036101000a031916815260200191505b5092505050604051"), v); pt.insert(hex("0360200190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f1509050"), v); pt.insert(hex("0302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191"), v); pt.insert(hex("02808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080"), v); pt.insert(hex("02600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150"), v); pt.insert(hex("01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382528381815181526020019150805190"), v); pt.insert(hex("019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260200191508051906020019080"), v); pt.insert(hex("01915080519060200190808383829060006004602084601f0104600302600f01"), v); pt.insert(hex("01915080519060200190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b6040805191825251908190"), v); pt.insert(hex("0190f35b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f1509050908101"), v); pt.insert(hex("0190808383829060006004602084601f0104600302600f01f150905090810190"), v); pt.insert(hex("0190602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b60"), v); pt.insert(hex("01836020036101000a031916815260200191505b509250505060405180910390"), v); pt.insert(hex("0182810382528381815181526020019150805190602001908083838290600060"), v); pt.insert(hex("0182565b60408051602060248035600481810135601f810185900485028601850190965285855261007795903594604494909392909201918190840183828082"), v); pt.insert(hex("0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b6040518080602001828103825283818151815260"), v); pt.insert(hex("010182565b60408051602060248035600481810135601f8101859004850286018501909652858552610077959035946044949093929092019181908401838280"), v); pt.insert(hex("01000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffff"), v); pt.insert(hex("006c600435600160a060020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255908452"), v); pt.insert(hex("006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051808060200182810382"), v); pt.insert(hex("0060005060006001600050600086815260200190815260200160002060005060"), v); pt.insert(hex("000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffff"), v); Bytes data = hex( "606060405236156100615760e060020a60003504630a936fe5811461006357806315853113146100d857806339bfc4a11461010b5780636939cd971461014357" "8063c36948b5146101d3578063de6f24bb14610205578063fe1e3eca146102f5575b005b6040805160208181018352600080835233600160a060020a03168152" "60018252839020805484518184028101840190955280855261036094928301828280156100ce57602002820191906000526020600020905b8160005054815260" "200190600101908083116100b7575b5050505050905090565b6103aa600435602435600160205260008281526040902080548290811015610002575060009081" "52602090200154905081565b6103aa600435600160a060020a03331660009081526020818152604080832084845290915290205467ffffffffffffffff165b91" "9050565b6103bc60043560408051602081810183526000808352600160a060020a0333168152808252838120858252825283902060010180548451601f820184" "900484028101840190955280855292939290918301828280156101c757820191906000526020600020905b8154815290600101906020018083116101aa578290" "03601f168201915b5050505050905061013e565b61042a60043560243560006020818152928152604080822090935290815220805467ffffffffffffffff1690" "60010182565b60408051602060248035600481810135601f81018590048502860185019096528585526100619590359460449490939290920191819084018382" "808284375094955050505050506000600082604051808280519060200190808383829060006004602084601f0104600302600f01f15090910182900390912083" "5467ffffffffffffffff191642178455915160018054828255818652939550926020601f91909101047fb10e2d527612073b26eecdfd717e6a320cf44b4afac2" "b0732d9fcbe2b7fa0cf690810192821561052a579182015b8281111561052a5782518260005055916020019190600101906102d7565b610061600435600160a0" "60020a03331660009081526020818152604080832084845282528220805467ffffffffffffffff19168155600181018054848255908452828420919284926104" "9592601f01919091048101905b80821115610522576000815560010161034c565b60405180806020018281038252838181518152602001915080519060200190" "602002808383829060006004602084601f0104600302600f01f1509050019250505060405180910390f35b60408051918252519081900360200190f35b604051" "80806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f16801561" "041c5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b604051808367ffffffffffffffff16815260200180" "602001828103825283818154815260200191508054801561048557820191906000526020600020905b8154815290600101906020018083116104685782900360" "1f168201915b5050935050505060405180910390f35b505050600090505b600160a060020a033316600090815260016020526040902054811015610526576040" "6000208054839190839081101561000257600091825260209091200154141561051a576001600050600033600160a060020a0316815260200190815260200160" "00206000508181548110156100025760009182526020822001555b60010161049d565b5090565b5050565b5061053692915061034c565b5050600160a060020a" "038416600090815260208181526040808320858452825282208354815467ffffffffffffffff191667ffffffffffffffff919091161781556001848101805491" "8301805483825581875295859020879694959194601f01919091048101929182156105d257600052602060002091601f016020900482015b828111156105d257" "82548255916001019190600101906105b7565b506105de92915061034c565b50505050600160a060020a03841660009081526001602052604090208054839190" "61000256"); PatriciaTreeMatchFinder mf(pt); auto& matches = mf.find_longest_matches(data); REQUIRE(matches.size() == 201); } TEST_CASE("PatriciaTreeMatchFinder8") { int id = 0; int* v = &id; PatriciaTree pt; pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffffff16"), v); pt.insert(hex("60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffffff16"), v); pt.insert(hex("ffffffffffffffff16"), v); pt.insert(hex("ffffffffffffff16"), v); pt.insert(hex("01000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000"), v); pt.insert(hex("81526020019081526020016000208190"), v); pt.insert(hex("81526020019081526020016000206000"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff"), v); pt.insert(hex("ffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16"), v); pt.insert(hex("906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffff"), v); pt.insert(hex("9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673"), v); pt.insert(hex("900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffff"), v); pt.insert(hex("73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffff"), v); pt.insert(hex("6101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffff"), v); pt.insert(hex("54906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ff"), v); pt.insert(hex("0a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffff"), v); pt.insert(hex("0473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffff"), v); pt.insert(hex("01000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffff"), v); pt.insert(hex("000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffff"), v); pt.insert(hex("815260016020526040"), v); pt.insert(hex("526020019081526020016000208190"), v); Bytes data = hex( "60606040523615610103576000357c01000000000000000000000000000000000000000000000000000000009004806311bc5478146103bc578063353d90ec14" "6103dd57806343743d93146103fe5780634faa2d541461041f57806350b44712146104405780635c0ecfad1461047d5780635d80c2781461049e578063602a6c" "a1146104bf578063806b984f146104d85780638b7bcc86146104f9578063a2fb11751461051a578063a457c2ae14610541578063a59d698614610562578063a5" "e01f371461056f578063f000c30914610590578063f18d20be146105b1578063f56f48f2146105be578063f6f0b074146105df578063f961ec87146106005761" "0103565b6103ba5b600060006801639e49bba16280003410151561016e57670e398811bec680003404915081503373ffffffffffffffffffffffffffffffffff" "ffffff166000670e398811bec680003406604051809050600060405180830381858888f1935050505050610281565b6791b77e5e5d9a0000341015156101d057" "670e92596fd62900003404915081503373ffffffffffffffffffffffffffffffffffffffff166000670e92596fd6290000340660405180905060006040518083" "0381858888f1935050505050610280565b674c53ecdc18a600003410151561023257670f43fc2c04ee00003404915081503373ffffffffffffffffffffffffff" "ffffffffffffff166000670f43fc2c04ee00003406604051809050600060405180830381858888f193505050505061027f565b670ff59ee833b3000034049150" "81503373ffffffffffffffffffffffffffffffffffffffff166000670ff59ee833b300003406604051809050600060405180830381858888f19350505050505b" "5b5b6007600050543334604051808481526020018373ffffffffffffffffffffffffffffffffffffffff166c0100000000000000000000000002815260140182" "8152602001935050505060405180910390206007600050819055506103e88260036000505401046103e86003600050540414151561031b574360066000508190" "5550600760005054600a6000508190555042600b600050819055505b600060010260016006600050540140141515610345576001600660005054014060096000" "50819055505b600190505b818160ff161115156103b5573360016000506000600360008181505480929190600101919050558152602001908152602001600020" "60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908302179055505b600181019050805061034a565b5b5050565b005b6103c7" "600450610af4565b6040518082815260200191505060405180910390f35b6103e8600450610b5c565b6040518082815260200191505060405180910390f35b61" "0409600450610b00565b6040518082815260200191505060405180910390f35b61042a600450610a65565b6040518082815260200191505060405180910390f3" "5b610451600480359060200150610b09565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6104" "88600450610ad5565b6040518082815260200191505060405180910390f35b6104a9600450610ade565b6040518082815260200191505060405180910390f35b" "6104d6600480359060200180359060200150610627565b005b6104e3600450610aba565b6040518082815260200191505060405180910390f35b610504600450" "610b65565b6040518082815260200191505060405180910390f35b61052b600480359060200150610b41565b6040518082815260200191505060405180910390f" "35b61054c600450610ac3565b6040518082815260200191505060405180910390f35b61056d600450610838565b005b61057a600450610b6e565b604051808281" "5260200191505060405180910390f35b61059b600450610acc565b6040518082815260200191505060405180910390f35b6105bc60045061094e565b005b6105c" "9600450610aed565b6040518082815260200191505060405180910390f35b6105ea600450610ae7565b6040518082815260200191505060405180910390f35b61" "0611600480359060200150610a96565b6040518082815260200191505060405180910390f35b60006000600060009054906101000a900473fffffffffffffffff" "fffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561068757" "610832565b600860005054846040518082815260200191505060405180910390201415806106b857506000600102600860005054145b156106c257610832565b6" "103e860036000505410806106e457506103e860036000505403600560005054115b156106ee57610832565b83600a600050546040518083815260200182815260" "200192505050604051809103902091506103e86009600050548318600190040660056000505401905060016000506000828152602001908152602001600020600" "09054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166000670de0b6b3a7640000" "6103e802604051809050600060405180830381858888f19350505050507f909c57d5c6ac08245cf2a6de3900e2b868513fa59099b92b27d8db823d92df9c816040" "518082815260200191505060405180910390a180600260005060006004600081815054809291906001019190505581526020019081526020016000206000508190" "55506103e860056000828282505401925050819055506000600b60005081905550826008600050819055505b50505050565b600060006000600b60005054141561" "084f5761094a565b62015180600b60005054420310156108665761094a565b60006001026008600050819055506000915060056000505490505b60036000505481" "1015610916573373ffffffffffffffffffffffffffffffffffffffff166001600050600083815260200190815260200160002060009054906101000a900473ffff" "ffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16141561090857670de0b6b3a76400008201915081505b5b80" "80600101915050610881565b3373ffffffffffffffffffffffffffffffffffffffff16600083604051809050600060405180830381858888f19350505050505b50" "50565b6000600060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ff" "ffffffffffffffffffffffffffffffffffffff161415156109ac57610a62565b670de0b6b3a7640000600560005054600360005054030290507f909c57d5c6ac08" "245cf2a6de3900e2b868513fa59099b92b27d8db823d92df9c813073ffffffffffffffffffffffffffffffffffffffff1631036040518082815260200191505060" "405180910390a13373ffffffffffffffffffffffffffffffffffffffff166000823073ffffffffffffffffffffffffffffffffffffffff16310360405180905060" "0060405180830381858888f19350505050505b50565b60006000600b600050541415610a83576105399050610a9356610a92565b600b6000505442039050610a93" "565b5b90565b6000816040518082815260200191505060405180910390209050610ab5565b919050565b60066000505481565b60076000505481565b6008600050" "5481565b60096000505481565b600a6000505481565b6103e881565b6201518081565b670de0b6b3a764000081565b600b6000505481565b600160005060205280" "600052604060002060009150909054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600260005060205280600052604060002060" "00915090505481565b60036000505481565b60046000505481565b6005600050548156"); PatriciaTreeMatchFinder mf(pt); auto& matches = mf.find_longest_matches(data); REQUIRE(matches.size() == 144); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_aggregator.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "pattern_aggregator.hpp" #include #include #include #include #include namespace silkworm::snapshots::seg { using Pattern = PatternAggregator::Pattern; using namespace std; namespace etl { using namespace silkworm::datastore::etl; } static Bytes big_endian_encode(uint64_t value) { Bytes data(sizeof(uint64_t), 0); endian::store_big_u64(data.data(), value); return data; } static uint64_t big_endian_decode(ByteView encoded) { return endian::load_big_u64(encoded.data()); } static bool operator>(const Pattern& p1, const Pattern& p2) { return (p1.score != p2.score) ? (p1.score > p2.score) : (p1.data > p2.data); } class PatternAggregatorImpl { public: explicit PatternAggregatorImpl(const filesystem::path& etl_work_path) : etl_work_path_(etl_work_path), collector_(make_unique(etl_work_path, datastore::etl::kOptimalBufferSize / 4)) {} void collect_pattern(Pattern pattern) { collector_->collect(std::move(pattern.data), big_endian_encode(pattern.score)); } vector aggregate(); private: /** * The max number of patterns to keep in reserve * while building the sorted list incrementally in order_by_score_and_limit. * Having more than kMaxPatterns patterns in consideration * produces 10% better compression ratio while still keeping RAM usage under control. * see DictReducerSoftLimit in erigon */ static constexpr size_t kMaxPatternsSoftLimit = 1'000'000; // destination = SELECT data, sum(score) FROM source GROUP BY data static void sum_score_group_by_pattern(datastore::etl::Collector& source, datastore::etl::Collector& destination); // SELECT * FROM source ORDER BY score DESC LIMIT kMaxPatterns static vector order_by_score_and_limit(datastore::etl::Collector& source); filesystem::path etl_work_path_; unique_ptr collector_; }; void PatternAggregatorImpl::sum_score_group_by_pattern(datastore::etl::Collector& source, datastore::etl::Collector& destination) { optional pending_pattern_data; uint64_t pending_pattern_score{}; source.load([&](const datastore::etl::Entry& entry) { auto& pattern_data = entry.key; uint64_t pattern_score = big_endian_decode(entry.value); if (pattern_data == pending_pattern_data) { pending_pattern_score += pattern_score; } else { if (pending_pattern_data) { destination.collect(std::move(*pending_pattern_data), big_endian_encode(pending_pattern_score)); } pending_pattern_data = pattern_data; pending_pattern_score = pattern_score; } }); if (pending_pattern_data) { destination.collect(std::move(*pending_pattern_data), big_endian_encode(pending_pattern_score)); } } vector PatternAggregatorImpl::order_by_score_and_limit(datastore::etl::Collector& source) { vector patterns; std::greater<> comparator; source.load([&](const datastore::etl::Entry& entry) { Pattern pattern{ .data = Bytes{entry.key}, .score = big_endian_decode(entry.value), }; patterns.push_back(std::move(pattern)); ranges::push_heap(patterns, comparator); if (patterns.size() > kMaxPatternsSoftLimit) { ranges::pop_heap(patterns, comparator); patterns.pop_back(); } }); ranges::sort(patterns, comparator); if (patterns.size() > PatternAggregator::kMaxPatterns) { patterns.resize(PatternAggregator::kMaxPatterns); } return patterns; } vector PatternAggregatorImpl::aggregate() { datastore::etl::Collector collector{etl_work_path_}; sum_score_group_by_pattern(*collector_, collector); // the original collector_ is not needed anymore, free it collector_.reset(); return order_by_score_and_limit(collector); } PatternAggregator::PatternAggregator(const filesystem::path& etl_work_path) : p_impl_(make_unique(etl_work_path)) {} PatternAggregator::~PatternAggregator() { static_assert(true); } PatternAggregator::PatternAggregator(PatternAggregator&& other) noexcept : p_impl_(std::move(other.p_impl_)) {} PatternAggregator& PatternAggregator::operator=(PatternAggregator&& other) noexcept { p_impl_ = std::move(other.p_impl_); return *this; } void PatternAggregator::collect_pattern(Pattern pattern) { p_impl_->collect_pattern(std::move(pattern)); } vector PatternAggregator::aggregate(PatternAggregator aggregator) { return aggregator.p_impl_->aggregate(); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_aggregator.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::snapshots::seg { class PatternAggregatorImpl; /** * PatternAggregator aggregates top score unique patterns: * SELECT data, sum(score) FROM patterns GROUP BY data * ORDER BY sum(score) DESC LIMIT kMaxPatterns * Since all patterns might take a lot of RAM, the ETL framework is used. */ class PatternAggregator { public: explicit PatternAggregator(const std::filesystem::path& etl_work_path); ~PatternAggregator(); PatternAggregator(PatternAggregator&& other) noexcept; PatternAggregator& operator=(PatternAggregator&& other) noexcept; struct Pattern { Bytes data; uint64_t score{0}; friend bool operator==(const Pattern&, const Pattern&) = default; }; void collect_pattern(Pattern pattern); static std::vector aggregate(PatternAggregator aggregator); static constexpr size_t kMaxPatterns = 64 * 1024; private: std::unique_ptr p_impl_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_aggregator_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "pattern_aggregator.hpp" #include #include #include #include #include namespace silkworm::snapshots::seg { static Bytes operator""_hex(const char* data, size_t size) { return from_hex(std::string_view{data, size}).value(); } TEST_CASE("PatternAggregator") { TemporaryDirectory etl_work_path; PatternAggregator aggregator{etl_work_path.path()}; aggregator.collect_pattern({"CAFE"_hex, 1}); aggregator.collect_pattern({"BABE"_hex, 2}); aggregator.collect_pattern({"FEED"_hex, 3}); aggregator.collect_pattern({"BABE"_hex, 4}); std::vector expected_patterns = { {"BABE"_hex, 6}, {"FEED"_hex, 3}, {"CAFE"_hex, 1}, }; auto actual_patterns = PatternAggregator::aggregate(std::move(aggregator)); CHECK(actual_patterns == expected_patterns); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_covering.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "pattern_covering.hpp" #include #include #include namespace silkworm::snapshots::seg { //! A result of dynamic programming for a certain starting position. struct PatternCoveringSearchDynamicCell { size_t optim_start{}; size_t cover_start{}; int compression{}; uint64_t score{}; size_t pattern_index{}; }; using DynamicCell = PatternCoveringSearchDynamicCell; using Ring = boost::circular_buffer_space_optimized; using Result = PatternCoveringSearch::Result; class PatternCoveringSearchImpl { public: PatternCoveringSearchImpl( const PatriciaTree& patterns_tree, std::function pattern_score_getter) : match_finder_(patterns_tree), pattern_score_getter_(std::move(pattern_score_getter)), cell_ring_(std::numeric_limits::max()) {} const Result& cover_word(ByteView word); private: PatriciaTreeMatchFinder match_finder_; std::function pattern_score_getter_; Ring cell_ring_; std::vector pattern_indexes_; Result result_; }; void Result::clear() { pattern_positions.clear(); uncovered_ranges.clear(); } const Result& PatternCoveringSearchImpl::cover_word(ByteView word) { result_.clear(); auto& matches = match_finder_.find_longest_matches(word); if (matches.empty()) { result_.uncovered_ranges.emplace_back(0, word.size()); return result_; } cell_ring_.clear(); pattern_indexes_.clear(); // This is a linked list of pattern matches indexes organized in pairs: // * each even element is a match index; // * each odd element is an index of the next entry within the list, or zero for a tail entry. // The list starts with a sentinel entry - [0, 0]. auto& patterns = pattern_indexes_; patterns.push_back(0); patterns.push_back(0); const auto& last_match = matches.back(); for (size_t i = last_match.start; i < last_match.end; ++i) { DynamicCell cell{ .optim_start = i + 1, .cover_start = word.size(), }; cell_ring_.push_back(cell); } // Starting from the last match for (size_t i = matches.size(); i > 0; --i) { const auto& match = matches[i - 1]; uint64_t pattern_score = pattern_score_getter_(match.value); auto& first_cell = cell_ring_[0]; int max_compression = first_cell.compression; uint64_t max_score = first_cell.score; DynamicCell max_cell = first_cell; bool max_include = false; for (size_t e = 0; e < cell_ring_.size(); ++e) { auto& cell = cell_ring_[e]; int comp = cell.compression - 4; if (cell.cover_start >= match.end) { comp += static_cast(match.end - match.start); } else { comp += static_cast(cell.cover_start - match.start); } uint64_t score = cell.score + pattern_score; if ((comp > max_compression) || ((comp == max_compression) && (score > max_score))) { max_compression = comp; max_score = score; max_include = true; max_cell = cell; } else if (cell.optim_start > match.end) { cell_ring_.resize(e); break; } } DynamicCell cell{ .optim_start = match.start, .compression = max_compression, .score = max_score, }; if (max_include) { cell.cover_start = match.start; cell.pattern_index = patterns.size(); patterns.push_back(i - 1); patterns.push_back(max_cell.pattern_index); } else { cell.cover_start = max_cell.cover_start; cell.pattern_index = max_cell.pattern_index; } cell_ring_.push_front(cell); } auto& optimal_cell = cell_ring_[0]; size_t last_uncovered = 0; auto& uncovered = result_.uncovered_ranges; for (size_t pattern_index = optimal_cell.pattern_index; pattern_index != 0; pattern_index = patterns[pattern_index + 1]) { size_t match_index = patterns[pattern_index]; auto& match = matches[match_index]; if (match.start > last_uncovered) { uncovered.emplace_back(last_uncovered, match.start); } last_uncovered = match.end; result_.pattern_positions.emplace_back(match.start, match.value); } if (word.size() > last_uncovered) { uncovered.emplace_back(last_uncovered, word.size()); } return result_; } PatternCoveringSearch::PatternCoveringSearch( const PatriciaTree& patterns_tree, const std::function& pattern_score_getter) : p_impl_(std::make_unique(patterns_tree, pattern_score_getter)) {} PatternCoveringSearch::~PatternCoveringSearch() { static_assert(true); } const Result& PatternCoveringSearch::cover_word(ByteView word) { return p_impl_->cover_word(word); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_covering.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "patricia_tree.hpp" namespace silkworm::snapshots::seg { class PatternCoveringSearchImpl; class PatternCoveringSearch { public: PatternCoveringSearch( const PatriciaTree& patterns_tree, const std::function& pattern_score_getter); ~PatternCoveringSearch(); struct Result { /** * Positions of patterns found in a word. * Patterns are represented by their corresponding values in the PatriciaTree. */ std::vector> pattern_positions; /** * Ranges in a word that were not covered by patterns. * Each range has a start and end index. */ std::vector> uncovered_ranges; void clear(); }; /** * Find an optimal covering of a given word with patterns. * Ideally we want a covering that has maximal score and no intersections. */ const Result& cover_word(ByteView word); private: std::unique_ptr p_impl_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_covering_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "pattern_covering.hpp" #include #include #include #include #include "patricia_tree.hpp" namespace silkworm::snapshots::seg { static Bytes operator""_hex(const char* data, size_t size) { return from_hex(std::string_view{data, size}).value(); } TEST_CASE("PatternCoveringSearch1") { // hex pattern & score std::vector> patterns{ {"0x206c6f6e676c6f6e67776f72642031", 165}, {"0x206c6f6e676c6f6e67776f72642032", 165}, {"0x206c6f6e676c6f6e67776f72642033", 165}, {"0x206c6f6e676c6f6e67776f72642034", 165}, {"0x206c6f6e676c6f6e67776f72642035", 165}, {"0x206c6f6e676c6f6e67776f72642036", 165}, {"0x206c6f6e676c6f6e67776f72642037", 165}, {"0x206c6f6e676c6f6e67776f72642038", 165}, {"0x206c6f6e676c6f6e67776f72642039", 165}, {"0x30206c6f6e676c6f6e67776f726420", 150}, {"0x31206c6f6e676c6f6e67776f726420", 150}, {"0x32206c6f6e676c6f6e67776f726420", 150}, {"0x33206c6f6e676c6f6e67776f726420", 150}, {"0x34206c6f6e676c6f6e67776f726420", 150}, {"0x35206c6f6e676c6f6e67776f726420", 150}, {"0x36206c6f6e676c6f6e67776f726420", 150}, {"0x37206c6f6e676c6f6e67776f726420", 150}, {"0x38206c6f6e676c6f6e67776f726420", 150}, {"0x676c6f6e67776f72642031", 121}, {"0x676c6f6e67776f72642032", 121}, {"0x676c6f6e67776f72642033", 121}, {"0x676c6f6e67776f72642034", 121}, {"0x676c6f6e67776f72642035", 121}, {"0x676c6f6e67776f72642036", 121}, {"0x676c6f6e67776f72642037", 121}, {"0x676c6f6e67776f72642038", 121}, {"0x676c6f6e67776f72642039", 121}, {"0x67776f72642031", 77}, {"0x67776f72642032", 77}, {"0x67776f72642033", 77}, {"0x67776f72642034", 77}, {"0x67776f72642035", 77}, {"0x67776f72642036", 77}, {"0x67776f72642037", 77}, {"0x67776f72642038", 77}, {"0x67776f72642039", 77}, {"0x6c6f6e676c6f6e67776f72642031", 154}, {"0x6c6f6e676c6f6e67776f72642032", 154}, {"0x6c6f6e676c6f6e67776f72642033", 154}, {"0x6c6f6e676c6f6e67776f72642034", 154}, {"0x6c6f6e676c6f6e67776f72642035", 154}, {"0x6c6f6e676c6f6e67776f72642036", 154}, {"0x6c6f6e676c6f6e67776f72642037", 154}, {"0x6c6f6e676c6f6e67776f72642038", 154}, {"0x6c6f6e676c6f6e67776f72642039", 154}, {"0x6c6f6e67776f72642031", 110}, {"0x6c6f6e67776f72642032", 110}, {"0x6c6f6e67776f72642033", 110}, {"0x6c6f6e67776f72642034", 110}, {"0x6c6f6e67776f72642035", 110}, {"0x6c6f6e67776f72642036", 110}, {"0x6c6f6e67776f72642037", 110}, {"0x6c6f6e67776f72642038", 110}, {"0x6c6f6e67776f72642039", 110}, {"0x6e676c6f6e67776f72642031", 132}, {"0x6e676c6f6e67776f72642032", 132}, {"0x6e676c6f6e67776f72642033", 132}, {"0x6e676c6f6e67776f72642034", 132}, {"0x6e676c6f6e67776f72642035", 132}, {"0x6e676c6f6e67776f72642036", 132}, {"0x6e676c6f6e67776f72642037", 132}, {"0x6e676c6f6e67776f72642038", 132}, {"0x6e676c6f6e67776f72642039", 132}, {"0x6e67776f72642031", 88}, {"0x6e67776f72642032", 88}, {"0x6e67776f72642033", 88}, {"0x6e67776f72642034", 88}, {"0x6e67776f72642035", 88}, {"0x6e67776f72642036", 88}, {"0x6e67776f72642037", 88}, {"0x6e67776f72642038", 88}, {"0x6e67776f72642039", 88}, {"0x6f6e676c6f6e67776f72642031", 143}, {"0x6f6e676c6f6e67776f72642032", 143}, {"0x6f6e676c6f6e67776f72642033", 143}, {"0x6f6e676c6f6e67776f72642034", 143}, {"0x6f6e676c6f6e67776f72642035", 143}, {"0x6f6e676c6f6e67776f72642036", 143}, {"0x6f6e676c6f6e67776f72642037", 143}, {"0x6f6e676c6f6e67776f72642038", 143}, {"0x6f6e676c6f6e67776f72642039", 143}, {"0x6f6e67776f72642031", 99}, {"0x6f6e67776f72642032", 99}, {"0x6f6e67776f72642033", 99}, {"0x6f6e67776f72642034", 99}, {"0x6f6e67776f72642035", 99}, {"0x6f6e67776f72642036", 99}, {"0x6f6e67776f72642037", 99}, {"0x6f6e67776f72642038", 99}, {"0x6f6e67776f72642039", 99}, {"0x6f72642031", 55}, {"0x6f72642032", 55}, {"0x6f72642033", 55}, {"0x6f72642034", 55}, {"0x6f72642035", 55}, {"0x6f72642036", 55}, {"0x6f72642037", 55}, {"0x6f72642038", 55}, {"0x6f72642039", 55}, {"0x776f72642031", 66}, {"0x776f72642032", 66}, {"0x776f72642033", 66}, {"0x776f72642034", 66}, {"0x776f72642035", 66}, {"0x776f72642036", 66}, {"0x776f72642037", 66}, {"0x776f72642038", 66}, {"0x776f72642039", 66}, }; PatriciaTree patterns_tree; for (auto& pattern : patterns) { patterns_tree.insert(from_hex(pattern.first).value(), &pattern.second); } PatternCoveringSearch search{ patterns_tree, [](void* pattern_score) { return *reinterpret_cast(pattern_score); }}; { auto& result = search.cover_word("0x6c6f6e67"_hex); REQUIRE(result.pattern_positions.empty()); REQUIRE(result.uncovered_ranges.size() == 1); CHECK(result.uncovered_ranges[0].first == 0); CHECK(result.uncovered_ranges[0].second == 4); } { auto& result = search.cover_word("0x776f7264"_hex); REQUIRE(result.pattern_positions.empty()); REQUIRE(result.uncovered_ranges.size() == 1); CHECK(result.uncovered_ranges[0].first == 0); CHECK(result.uncovered_ranges[0].second == 4); } { auto& result = search.cover_word("0x30206c6f6e676c6f6e67776f72642030"_hex); REQUIRE(result.pattern_positions.size() == 1); CHECK(result.pattern_positions[0].first == 0); REQUIRE(result.uncovered_ranges.size() == 1); CHECK(result.uncovered_ranges[0].first == 15); CHECK(result.uncovered_ranges[0].second == 16); } { std::vector words = { "0x31206c6f6e676c6f6e67776f72642031"_hex, "0x32206c6f6e676c6f6e67776f72642032"_hex, "0x33206c6f6e676c6f6e67776f72642033"_hex, "0x34206c6f6e676c6f6e67776f72642034"_hex, }; for (auto& word : words) { auto& result = search.cover_word(word); REQUIRE(result.pattern_positions.size() == 1); CHECK(result.pattern_positions[0].first == 1); REQUIRE(result.uncovered_ranges.size() == 1); CHECK(result.uncovered_ranges[0].first == 0); CHECK(result.uncovered_ranges[0].second == 1); } } { std::vector words = { "0x3130206c6f6e676c6f6e67776f7264203130"_hex, "0x3131206c6f6e676c6f6e67776f7264203131"_hex, "0x3230206c6f6e676c6f6e67776f7264203230"_hex, "0x3231206c6f6e676c6f6e67776f7264203231"_hex, "0x3330206c6f6e676c6f6e67776f7264203330"_hex, "0x3331206c6f6e676c6f6e67776f7264203331"_hex, "0x3938206c6f6e676c6f6e67776f7264203938"_hex, "0x3939206c6f6e676c6f6e67776f7264203939"_hex, }; for (auto& word : words) { auto& result = search.cover_word(word); REQUIRE(result.pattern_positions.size() == 1); CHECK(result.pattern_positions[0].first == 2); REQUIRE(result.uncovered_ranges.size() == 2); CHECK(result.uncovered_ranges[0].first == 0); CHECK(result.uncovered_ranges[0].second == 2); CHECK(result.uncovered_ranges[1].first == 17); CHECK(result.uncovered_ranges[1].second == 18); } } } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_extractor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "pattern_extractor.hpp" #include #include #include #include #include #include "lcp_kasai.hpp" namespace silkworm::snapshots::seg { //! How large one superstring gets before processed. static constexpr size_t kSuperstringLimit = 16_Mebi; //! Minimum pattern length. static constexpr size_t kPatternLenMin = 5; //! Maximum pattern length. static constexpr size_t kPatternLenMax = 128; //! Minimum score of a pattern in a word. static constexpr uint64_t kPatternScoreMin = 1024; Superstring::Superstring() { superstring_.reserve(kSuperstringLimit); } bool Superstring::can_add_word(ByteView word) { size_t extra_size = word.size() * 2 + 2; return superstring_.size() + extra_size <= kSuperstringLimit; } void Superstring::add_word(ByteView word, bool skip_copy) { size_t start = superstring_.size(); superstring_.append(word.size() * 2 + 2, 0); if (skip_copy) return; for (size_t i = 0, s = start; i < word.size(); ++i, s += 2) { superstring_[s] = 1; superstring_[s + 1] = word[i]; } } void Superstring::substr(Bytes& out, size_t pos, size_t count) const { out.resize(count); size_t offset = pos * 2; for (size_t i = 0, s = 1; i < count; ++i, s += 2) { out[i] = superstring_[offset + s]; } } PatternExtractor::PatternExtractor(std::optional pattern_score_min) : pattern_score_min_(pattern_score_min.value_or(kPatternScoreMin)) { pattern_.reserve(kPatternLenMax); } void PatternExtractor::extract_patterns(const Superstring& superstring, absl::FunctionRef collector) { if (superstring.size() == 0) return; auto& lcp = lcp_; auto& sa = sa_; auto& inv = inv_; // Build suffix array sa.resize(superstring.size()); if (sais(superstring.data(), sa.data(), static_cast(superstring.size())) != 0) { throw std::runtime_error("PatternExtractor::extract_patterns: sais algorithm failed"); } // Filter out suffixes that start with odd positions size_t n = sa.size() / 2; std::span filtered(sa.data(), n); size_t j = 0; for (int i : sa) { if ((i & 1) == 0) { filtered[j++] = i >> 1; } } // Create an inverted array inv.resize(n); for (size_t i = 0; i < n; ++i) { inv[static_cast(filtered[i])] = static_cast(i); } lcp.resize(n); lcp_kasai(superstring, filtered.data(), inv.data(), lcp.data(), static_cast(n)); // Walk over LCP array and compute the scores of the strings auto& b = inv; j = 0; for (size_t i = 0; i < n - 1; ++i) { if (lcp[i + 1] >= lcp[i]) { j = i; continue; } bool prev_skipped = false; for (int l = lcp[i]; (l > lcp[i + 1]) && (l >= static_cast(kPatternLenMin)); --l) { if ((l > static_cast(kPatternLenMax)) || ((l > 20) && (l & (l - 1)))) { // is power of 2 prev_skipped = true; continue; } bool is_new = false; while ((j > 0) && (lcp[j - 1] >= l)) { --j; is_new = true; } if (!is_new && !prev_skipped) { break; } size_t window = i - j + 2; std::copy_n(&filtered[j], window, b.begin()); std::ranges::sort(std::span(b.data(), window)); size_t repeats = 1; size_t last_k = 0; for (size_t k = 1; k < window; ++k) { if (b[k] >= b[last_k] + l) { ++repeats; last_k = k; } } if (((l < 8) || (l > 64)) && (repeats < pattern_score_min_)) { prev_skipped = true; continue; } uint64_t score = repeats * static_cast(l); if (score < pattern_score_min_) { prev_skipped = true; continue; } superstring.substr(pattern_, static_cast(filtered[i]), static_cast(l)); collector(pattern_, score); prev_skipped = false; break; } } } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_extractor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::snapshots::seg { /** * Superstring - a chunk of data that is built from the raw data and acts as an input for the pattern extraction phase. * Input words are augmented in pairs of bytes with 1-s and terminated with (0,0) like so: (1,b1),(1,b2)...(1,bN),(0,0). */ class Superstring { public: Superstring(); explicit Superstring(Bytes superstring) : superstring_(std::move(superstring)) {} bool can_add_word(ByteView word); void add_word(ByteView word, bool skip_copy = false); void substr(Bytes& out, size_t pos, size_t count) const; const uint8_t* data() const { return superstring_.data(); } size_t size() const { return superstring_.size(); } void clear() { superstring_.clear(); } bool has_same_chars(int i1, int j1) const { auto i = static_cast(i1); auto j = static_cast(j1); return superstring_[i * 2] && superstring_[j * 2] && (superstring_[i * 2 + 1] == superstring_[j * 2 + 1]); } private: Bytes superstring_; }; class PatternExtractor { public: explicit PatternExtractor(std::optional pattern_score_min = std::nullopt); /** * \brief Extract patterns from a superstring. * \param superstring * \param collector Callback accepting a pattern string and its score. */ void extract_patterns(const Superstring& superstring, absl::FunctionRef collector); private: size_t pattern_score_min_; Bytes pattern_; std::vector lcp_, sa_, inv_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/pattern_extractor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "pattern_extractor.hpp" #include #include #include #include #include namespace silkworm::snapshots::seg { TEST_CASE("PatternExtractor1") { Superstring superstring{from_hex("0x0000016c016f016e016700000177016f01720164000001300120016c016f016e0167016c016f016e01670177016f017201640120013000000000016c016f016e016700000177016f01720164000001310120016c016f016e0167016c016f016e01670177016f017201640120013100000000016c016f016e016700000177016f01720164000001320120016c016f016e0167016c016f016e01670177016f017201640120013200000000016c016f016e016700000177016f01720164000001330120016c016f016e0167016c016f016e01670177016f017201640120013300000000016c016f016e016700000177016f01720164000001340120016c016f016e0167016c016f016e01670177016f017201640120013400000000016c016f016e016700000177016f01720164000001350120016c016f016e0167016c016f016e01670177016f017201640120013500000000016c016f016e016700000177016f01720164000001360120016c016f016e0167016c016f016e01670177016f017201640120013600000000016c016f016e016700000177016f01720164000001370120016c016f016e0167016c016f016e01670177016f017201640120013700000000016c016f016e016700000177016f01720164000001380120016c016f016e0167016c016f016e01670177016f017201640120013800000000016c016f016e016700000177016f01720164000001390120016c016f016e0167016c016f016e01670177016f017201640120013900000000016c016f016e016700000177016f017201640000013101300120016c016f016e0167016c016f016e01670177016f0172016401200131013000000000016c016f016e016700000177016f017201640000013101310120016c016f016e0167016c016f016e01670177016f0172016401200131013100000000016c016f016e016700000177016f017201640000013101320120016c016f016e0167016c016f016e01670177016f0172016401200131013200000000016c016f016e016700000177016f017201640000013101330120016c016f016e0167016c016f016e01670177016f0172016401200131013300000000016c016f016e016700000177016f017201640000013101340120016c016f016e0167016c016f016e01670177016f0172016401200131013400000000016c016f016e016700000177016f017201640000013101350120016c016f016e0167016c016f016e01670177016f0172016401200131013500000000016c016f016e016700000177016f017201640000013101360120016c016f016e0167016c016f016e01670177016f0172016401200131013600000000016c016f016e016700000177016f017201640000013101370120016c016f016e0167016c016f016e01670177016f0172016401200131013700000000016c016f016e016700000177016f017201640000013101380120016c016f016e0167016c016f016e01670177016f0172016401200131013800000000016c016f016e016700000177016f017201640000013101390120016c016f016e0167016c016f016e01670177016f0172016401200131013900000000016c016f016e016700000177016f017201640000013201300120016c016f016e0167016c016f016e01670177016f0172016401200132013000000000016c016f016e016700000177016f017201640000013201310120016c016f016e0167016c016f016e01670177016f0172016401200132013100000000016c016f016e016700000177016f017201640000013201320120016c016f016e0167016c016f016e01670177016f0172016401200132013200000000016c016f016e016700000177016f017201640000013201330120016c016f016e0167016c016f016e01670177016f0172016401200132013300000000016c016f016e016700000177016f017201640000013201340120016c016f016e0167016c016f016e01670177016f0172016401200132013400000000016c016f016e016700000177016f017201640000013201350120016c016f016e0167016c016f016e01670177016f0172016401200132013500000000016c016f016e016700000177016f017201640000013201360120016c016f016e0167016c016f016e01670177016f0172016401200132013600000000016c016f016e016700000177016f017201640000013201370120016c016f016e0167016c016f016e01670177016f0172016401200132013700000000016c016f016e016700000177016f017201640000013201380120016c016f016e0167016c016f016e01670177016f0172016401200132013800000000016c016f016e016700000177016f017201640000013201390120016c016f016e0167016c016f016e01670177016f0172016401200132013900000000016c016f016e016700000177016f017201640000013301300120016c016f016e0167016c016f016e01670177016f0172016401200133013000000000016c016f016e016700000177016f017201640000013301310120016c016f016e0167016c016f016e01670177016f0172016401200133013100000000016c016f016e016700000177016f017201640000013301320120016c016f016e0167016c016f016e01670177016f0172016401200133013200000000016c016f016e016700000177016f017201640000013301330120016c016f016e0167016c016f016e01670177016f0172016401200133013300000000016c016f016e016700000177016f017201640000013301340120016c016f016e0167016c016f016e01670177016f0172016401200133013400000000016c016f016e016700000177016f017201640000013301350120016c016f016e0167016c016f016e01670177016f0172016401200133013500000000016c016f016e016700000177016f017201640000013301360120016c016f016e0167016c016f016e01670177016f0172016401200133013600000000016c016f016e016700000177016f017201640000013301370120016c016f016e0167016c016f016e01670177016f0172016401200133013700000000016c016f016e016700000177016f017201640000013301380120016c016f016e0167016c016f016e01670177016f0172016401200133013800000000016c016f016e016700000177016f017201640000013301390120016c016f016e0167016c016f016e01670177016f0172016401200133013900000000016c016f016e016700000177016f017201640000013401300120016c016f016e0167016c016f016e01670177016f0172016401200134013000000000016c016f016e016700000177016f017201640000013401310120016c016f016e0167016c016f016e01670177016f0172016401200134013100000000016c016f016e016700000177016f017201640000013401320120016c016f016e0167016c016f016e01670177016f0172016401200134013200000000016c016f016e016700000177016f017201640000013401330120016c016f016e0167016c016f016e01670177016f0172016401200134013300000000016c016f016e016700000177016f017201640000013401340120016c016f016e0167016c016f016e01670177016f0172016401200134013400000000016c016f016e016700000177016f017201640000013401350120016c016f016e0167016c016f016e01670177016f0172016401200134013500000000016c016f016e016700000177016f017201640000013401360120016c016f016e0167016c016f016e01670177016f0172016401200134013600000000016c016f016e016700000177016f017201640000013401370120016c016f016e0167016c016f016e01670177016f0172016401200134013700000000016c016f016e016700000177016f017201640000013401380120016c016f016e0167016c016f016e01670177016f0172016401200134013800000000016c016f016e016700000177016f017201640000013401390120016c016f016e0167016c016f016e01670177016f0172016401200134013900000000016c016f016e016700000177016f017201640000013501300120016c016f016e0167016c016f016e01670177016f0172016401200135013000000000016c016f016e016700000177016f017201640000013501310120016c016f016e0167016c016f016e01670177016f0172016401200135013100000000016c016f016e016700000177016f017201640000013501320120016c016f016e0167016c016f016e01670177016f0172016401200135013200000000016c016f016e016700000177016f017201640000013501330120016c016f016e0167016c016f016e01670177016f0172016401200135013300000000016c016f016e016700000177016f017201640000013501340120016c016f016e0167016c016f016e01670177016f0172016401200135013400000000016c016f016e016700000177016f017201640000013501350120016c016f016e0167016c016f016e01670177016f0172016401200135013500000000016c016f016e016700000177016f017201640000013501360120016c016f016e0167016c016f016e01670177016f0172016401200135013600000000016c016f016e016700000177016f017201640000013501370120016c016f016e0167016c016f016e01670177016f0172016401200135013700000000016c016f016e016700000177016f017201640000013501380120016c016f016e0167016c016f016e01670177016f0172016401200135013800000000016c016f016e016700000177016f017201640000013501390120016c016f016e0167016c016f016e01670177016f0172016401200135013900000000016c016f016e016700000177016f017201640000013601300120016c016f016e0167016c016f016e01670177016f0172016401200136013000000000016c016f016e016700000177016f017201640000013601310120016c016f016e0167016c016f016e01670177016f0172016401200136013100000000016c016f016e016700000177016f017201640000013601320120016c016f016e0167016c016f016e01670177016f0172016401200136013200000000016c016f016e016700000177016f017201640000013601330120016c016f016e0167016c016f016e01670177016f0172016401200136013300000000016c016f016e016700000177016f017201640000013601340120016c016f016e0167016c016f016e01670177016f0172016401200136013400000000016c016f016e016700000177016f017201640000013601350120016c016f016e0167016c016f016e01670177016f0172016401200136013500000000016c016f016e016700000177016f017201640000013601360120016c016f016e0167016c016f016e01670177016f0172016401200136013600000000016c016f016e016700000177016f017201640000013601370120016c016f016e0167016c016f016e01670177016f0172016401200136013700000000016c016f016e016700000177016f017201640000013601380120016c016f016e0167016c016f016e01670177016f0172016401200136013800000000016c016f016e016700000177016f017201640000013601390120016c016f016e0167016c016f016e01670177016f0172016401200136013900000000016c016f016e016700000177016f017201640000013701300120016c016f016e0167016c016f016e01670177016f0172016401200137013000000000016c016f016e016700000177016f017201640000013701310120016c016f016e0167016c016f016e01670177016f0172016401200137013100000000016c016f016e016700000177016f017201640000013701320120016c016f016e0167016c016f016e01670177016f0172016401200137013200000000016c016f016e016700000177016f017201640000013701330120016c016f016e0167016c016f016e01670177016f0172016401200137013300000000016c016f016e016700000177016f017201640000013701340120016c016f016e0167016c016f016e01670177016f0172016401200137013400000000016c016f016e016700000177016f017201640000013701350120016c016f016e0167016c016f016e01670177016f0172016401200137013500000000016c016f016e016700000177016f017201640000013701360120016c016f016e0167016c016f016e01670177016f0172016401200137013600000000016c016f016e016700000177016f017201640000013701370120016c016f016e0167016c016f016e01670177016f0172016401200137013700000000016c016f016e016700000177016f017201640000013701380120016c016f016e0167016c016f016e01670177016f0172016401200137013800000000016c016f016e016700000177016f017201640000013701390120016c016f016e0167016c016f016e01670177016f0172016401200137013900000000016c016f016e016700000177016f017201640000013801300120016c016f016e0167016c016f016e01670177016f0172016401200138013000000000016c016f016e016700000177016f017201640000013801310120016c016f016e0167016c016f016e01670177016f0172016401200138013100000000016c016f016e016700000177016f017201640000013801320120016c016f016e0167016c016f016e01670177016f0172016401200138013200000000016c016f016e016700000177016f017201640000013801330120016c016f016e0167016c016f016e01670177016f0172016401200138013300000000016c016f016e016700000177016f017201640000013801340120016c016f016e0167016c016f016e01670177016f0172016401200138013400000000016c016f016e016700000177016f017201640000013801350120016c016f016e0167016c016f016e01670177016f0172016401200138013500000000016c016f016e016700000177016f017201640000013801360120016c016f016e0167016c016f016e01670177016f0172016401200138013600000000016c016f016e016700000177016f017201640000013801370120016c016f016e0167016c016f016e01670177016f0172016401200138013700000000016c016f016e016700000177016f017201640000013801380120016c016f016e0167016c016f016e01670177016f0172016401200138013800000000016c016f016e016700000177016f017201640000013801390120016c016f016e0167016c016f016e01670177016f0172016401200138013900000000016c016f016e016700000177016f017201640000013901300120016c016f016e0167016c016f016e01670177016f0172016401200139013000000000016c016f016e016700000177016f017201640000013901310120016c016f016e0167016c016f016e01670177016f0172016401200139013100000000016c016f016e016700000177016f017201640000013901320120016c016f016e0167016c016f016e01670177016f0172016401200139013200000000016c016f016e016700000177016f017201640000013901330120016c016f016e0167016c016f016e01670177016f0172016401200139013300000000016c016f016e016700000177016f017201640000013901340120016c016f016e0167016c016f016e01670177016f0172016401200139013400000000016c016f016e016700000177016f017201640000013901350120016c016f016e0167016c016f016e01670177016f0172016401200139013500000000016c016f016e016700000177016f017201640000013901360120016c016f016e0167016c016f016e01670177016f0172016401200139013600000000016c016f016e016700000177016f017201640000013901370120016c016f016e0167016c016f016e01670177016f0172016401200139013700000000016c016f016e016700000177016f017201640000013901380120016c016f016e0167016c016f016e01670177016f0172016401200139013800000000016c016f016e016700000177016f017201640000013901390120016c016f016e0167016c016f016e01670177016f017201640120013901390000").value()}; // hex pattern & score std::vector> expected_patterns{ {"0x206c6f6e676c6f6e67776f72642031", 165}, {"0x206c6f6e676c6f6e67776f72642032", 165}, {"0x206c6f6e676c6f6e67776f72642033", 165}, {"0x206c6f6e676c6f6e67776f72642034", 165}, {"0x206c6f6e676c6f6e67776f72642035", 165}, {"0x206c6f6e676c6f6e67776f72642036", 165}, {"0x206c6f6e676c6f6e67776f72642037", 165}, {"0x206c6f6e676c6f6e67776f72642038", 165}, {"0x206c6f6e676c6f6e67776f72642039", 165}, {"0x30206c6f6e676c6f6e67776f726420", 150}, {"0x31206c6f6e676c6f6e67776f726420", 150}, {"0x32206c6f6e676c6f6e67776f726420", 150}, {"0x33206c6f6e676c6f6e67776f726420", 150}, {"0x34206c6f6e676c6f6e67776f726420", 150}, {"0x35206c6f6e676c6f6e67776f726420", 150}, {"0x36206c6f6e676c6f6e67776f726420", 150}, {"0x37206c6f6e676c6f6e67776f726420", 150}, {"0x38206c6f6e676c6f6e67776f726420", 150}, {"0x676c6f6e67776f72642031", 121}, {"0x676c6f6e67776f72642032", 121}, {"0x676c6f6e67776f72642033", 121}, {"0x676c6f6e67776f72642034", 121}, {"0x676c6f6e67776f72642035", 121}, {"0x676c6f6e67776f72642036", 121}, {"0x676c6f6e67776f72642037", 121}, {"0x676c6f6e67776f72642038", 121}, {"0x676c6f6e67776f72642039", 121}, {"0x67776f72642031", 77}, {"0x67776f72642032", 77}, {"0x67776f72642033", 77}, {"0x67776f72642034", 77}, {"0x67776f72642035", 77}, {"0x67776f72642036", 77}, {"0x67776f72642037", 77}, {"0x67776f72642038", 77}, {"0x67776f72642039", 77}, {"0x6c6f6e676c6f6e67776f72642031", 154}, {"0x6c6f6e676c6f6e67776f72642032", 154}, {"0x6c6f6e676c6f6e67776f72642033", 154}, {"0x6c6f6e676c6f6e67776f72642034", 154}, {"0x6c6f6e676c6f6e67776f72642035", 154}, {"0x6c6f6e676c6f6e67776f72642036", 154}, {"0x6c6f6e676c6f6e67776f72642037", 154}, {"0x6c6f6e676c6f6e67776f72642038", 154}, {"0x6c6f6e676c6f6e67776f72642039", 154}, {"0x6c6f6e67776f72642031", 110}, {"0x6c6f6e67776f72642032", 110}, {"0x6c6f6e67776f72642033", 110}, {"0x6c6f6e67776f72642034", 110}, {"0x6c6f6e67776f72642035", 110}, {"0x6c6f6e67776f72642036", 110}, {"0x6c6f6e67776f72642037", 110}, {"0x6c6f6e67776f72642038", 110}, {"0x6c6f6e67776f72642039", 110}, {"0x6e676c6f6e67776f72642031", 132}, {"0x6e676c6f6e67776f72642032", 132}, {"0x6e676c6f6e67776f72642033", 132}, {"0x6e676c6f6e67776f72642034", 132}, {"0x6e676c6f6e67776f72642035", 132}, {"0x6e676c6f6e67776f72642036", 132}, {"0x6e676c6f6e67776f72642037", 132}, {"0x6e676c6f6e67776f72642038", 132}, {"0x6e676c6f6e67776f72642039", 132}, {"0x6e67776f72642031", 88}, {"0x6e67776f72642032", 88}, {"0x6e67776f72642033", 88}, {"0x6e67776f72642034", 88}, {"0x6e67776f72642035", 88}, {"0x6e67776f72642036", 88}, {"0x6e67776f72642037", 88}, {"0x6e67776f72642038", 88}, {"0x6e67776f72642039", 88}, {"0x6f6e676c6f6e67776f72642031", 143}, {"0x6f6e676c6f6e67776f72642032", 143}, {"0x6f6e676c6f6e67776f72642033", 143}, {"0x6f6e676c6f6e67776f72642034", 143}, {"0x6f6e676c6f6e67776f72642035", 143}, {"0x6f6e676c6f6e67776f72642036", 143}, {"0x6f6e676c6f6e67776f72642037", 143}, {"0x6f6e676c6f6e67776f72642038", 143}, {"0x6f6e676c6f6e67776f72642039", 143}, {"0x6f6e67776f72642031", 99}, {"0x6f6e67776f72642032", 99}, {"0x6f6e67776f72642033", 99}, {"0x6f6e67776f72642034", 99}, {"0x6f6e67776f72642035", 99}, {"0x6f6e67776f72642036", 99}, {"0x6f6e67776f72642037", 99}, {"0x6f6e67776f72642038", 99}, {"0x6f6e67776f72642039", 99}, {"0x6f72642031", 55}, {"0x6f72642032", 55}, {"0x6f72642033", 55}, {"0x6f72642034", 55}, {"0x6f72642035", 55}, {"0x6f72642036", 55}, {"0x6f72642037", 55}, {"0x6f72642038", 55}, {"0x6f72642039", 55}, {"0x776f72642031", 66}, {"0x776f72642032", 66}, {"0x776f72642033", 66}, {"0x776f72642034", 66}, {"0x776f72642035", 66}, {"0x776f72642036", 66}, {"0x776f72642037", 66}, {"0x776f72642038", 66}, {"0x776f72642039", 66}, }; PatternExtractor extractor(1); size_t i = 0; extractor.extract_patterns(superstring, [&](ByteView pattern, uint64_t score) -> void { REQUIRE(i < expected_patterns.size()); CHECK(pattern == from_hex(expected_patterns[i].first)); CHECK(score == expected_patterns[i].second); ++i; }); CHECK(i == expected_patterns.size()); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/positions_map.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "positions_map.hpp" namespace silkworm::snapshots::seg { size_t PositionsMap::position(size_t pattern_position, size_t prev_pattern_position) { return pattern_position - prev_pattern_position + 1; } size_t PositionsMap::word_length_position(size_t word_length) { return word_length + 1; } void PositionsMap::update_with_word( size_t raw_word_length, const std::vector>& pattern_positions) { ++uses_[kTerminatorPosition]; // total word count ++uses_[word_length_position(raw_word_length)]; size_t prev_pos = 0; for (auto& pattern_position : pattern_positions) { ++uses_[position(pattern_position.first, prev_pos)]; prev_pos = pattern_position.first; } } std::vector PositionsMap::list_positions() { std::vector result; result.reserve(uses_.size()); for (auto& entry : uses_) result.push_back(static_cast(entry.first)); return result; } std::vector PositionsMap::list_uses() { std::vector result; result.reserve(uses_.size()); for (auto& entry : uses_) result.push_back(entry.second); return result; } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/positions_map.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::snapshots::seg { class PositionsMap { public: void update_with_word( size_t raw_word_length, const std::vector>& pattern_positions); std::vector list_positions(); std::vector list_uses(); static size_t position(size_t pattern_position, size_t prev_pattern_position); static size_t word_length_position(size_t word_length); static constexpr size_t kTerminatorPosition = 0; private: std::map uses_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/raw_words_stream.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "raw_words_stream.hpp" #include #include #include "../common/varint.hpp" namespace silkworm::snapshots::seg { using namespace std; RawWordsStream::RawWordsStream(const filesystem::path& path, OpenMode open_mode, size_t buffer_size) : file_(path, ios::in | ios::out | ios::binary | ((open_mode == OpenMode::kCreate) ? ios::trunc : ios::openmode{})), stream_(file_) { stream_.exceptions(ios::failbit | ios::badbit); stream_buffer_.reset(new char[buffer_size]); stream_.rdbuf()->pubsetbuf(stream_buffer_.get(), static_cast(buffer_size)); } RawWordsStream::RawWordsStream(iostream& stream) : stream_(stream) { stream_.exceptions(ios::failbit | ios::badbit); } void RawWordsStream::write_word(ByteView word, bool is_compressed) { // the length is shifted to store the is_compressed flag size_t length = (word.size() << 1) | (is_compressed ? 0 : 1); stream_ << byte_view_to_string_view(varint::encode(encoded_length_, length)); stream_ << byte_view_to_string_view(word); } std::optional> RawWordsStream::read_word() { if (stream_.peek() == decltype(file_)::traits_type::eof()) return nullopt; auto encoded_length = varint::read(encoded_length_, [this]() -> char { char c = 0; this->stream_.get(c); return c; }); if (!encoded_length) throw runtime_error("RawWordsStream::read_word failed to read length at " + std::to_string(stream_.tellg())); auto length = varint::decode(*encoded_length); if (!length) throw runtime_error("RawWordsStream::read_word failed to parse length at " + std::to_string(stream_.tellg())); bool is_compressed = !(*length & 1); size_t size = *length >> 1; Bytes word(size, 0); stream_.read(byte_ptr_cast(word.data()), static_cast(word.size())); return pair{word, is_compressed}; } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/raw_words_stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::snapshots::seg { class RawWordsStream { public: enum class OpenMode { kCreate, kOpen, }; RawWordsStream(const std::filesystem::path& path, OpenMode open_mode, size_t buffer_size); explicit RawWordsStream(std::iostream& stream); void write_word(ByteView word, bool is_compressed = true); std::optional> read_word(); void flush() { stream_.flush(); } void rewind() { stream_.seekg(0); } private: std::fstream file_; std::iostream& stream_; std::unique_ptr stream_buffer_; Bytes encoded_length_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/raw_words_stream_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "raw_words_stream.hpp" #include #include #include namespace silkworm::snapshots::seg { using namespace std; static ByteView operator""_bv(const char* data, size_t size) { return string_view_to_byte_view({data, size}); } TEST_CASE("RawWordsStream") { stringstream stream; RawWordsStream words_out{stream}; words_out.write_word("hello"_bv); words_out.write_word("world"_bv, false); words_out.write_word("!!!"_bv); RawWordsStream words_in{stream}; CHECK(words_in.read_word() == make_pair(Bytes("hello"_bv), true)); CHECK(words_in.read_word() == make_pair(Bytes("world"_bv), false)); CHECK(words_in.read_word() == make_pair(Bytes("!!!"_bv), true)); CHECK(words_in.read_word() == nullopt); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/seg_stream.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "seg_stream.hpp" #include #include #include #include "../common/varint.hpp" namespace silkworm::snapshots::seg { using namespace std; SegStream::SegStream(const filesystem::path& path) : file_(path, ios::in | ios::out | ios::binary | ios::trunc), stream_(file_), bit_stream_([this](uint8_t b) { stream_.write(byte_ptr_cast(&b), 1); }) { stream_.exceptions(ios::failbit | ios::badbit); } SegStream::SegStream(ostream& stream) : stream_(stream), bit_stream_([this](uint8_t b) { stream_.write(byte_ptr_cast(&b), 1); }) { stream_.exceptions(ios::failbit | ios::badbit); } void SegStream::write_big_endian(size_t value) { encoded_buf_.resize(sizeof(uint64_t)); endian::store_big_u64(encoded_buf_.data(), value); stream_ << byte_view_to_string_view(encoded_buf_); } void SegStream::write_varint(size_t value) { stream_ << byte_view_to_string_view(varint::encode(encoded_buf_, value)); } class ScopedSegHeaderSectionSizeWriter { public: ScopedSegHeaderSectionSizeWriter( ostream& stream, function write_size) : stream_(stream), write_size_(std::move(write_size)) { section_size_offset_ = stream_.tellp(); // write a section size placeholder write_size_(0); section_start_offset_ = stream_.tellp(); } ~ScopedSegHeaderSectionSizeWriter() { // calculate the section size auto section_end_offset = stream_.tellp(); auto section_size = static_cast(section_end_offset - section_start_offset_); // rewind and overwrite the section size stream_.seekp(section_size_offset_); write_size_(section_size); // go back stream_.seekp(section_end_offset); } private: ostream& stream_; function write_size_; ostream::pos_type section_size_offset_; ostream::pos_type section_start_offset_; }; void SegStream::write_header(const Header& header) { write_big_endian(header.words_count); write_big_endian(header.empty_words_count); { ScopedSegHeaderSectionSizeWriter section_size{ stream_, [this](size_t value) { write_big_endian(value); }, }; for (auto& symbol : header.patterns) { write_varint(symbol.code_bits); write_varint(symbol.data.size()); stream_ << byte_view_to_string_view(symbol.data); } } { ScopedSegHeaderSectionSizeWriter section_size{ stream_, [this](size_t value) { write_big_endian(value); }, }; for (auto& symbol : header.positions) { write_varint(symbol.code_bits); write_varint(symbol.data); } } } void SegStream::write_uncovered_data(ByteView data) { stream_ << byte_view_to_string_view(data); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor/seg_stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "bit_stream.hpp" namespace silkworm::snapshots::seg { class SegStream { public: explicit SegStream(const std::filesystem::path& path); explicit SegStream(std::ostream& stream); template struct HuffmanCodeTableSymbol { size_t code_bits{}; TData data{}; }; template using HuffmanCodeTable = std::vector>; struct Header { size_t words_count{}; size_t empty_words_count{}; HuffmanCodeTable patterns; HuffmanCodeTable positions; }; void write_header(const Header& header); BitStream& codes() { return bit_stream_; } void write_uncovered_data(ByteView data); private: void write_big_endian(size_t value); void write_varint(size_t value); Bytes encoded_buf_; std::ofstream file_; std::ostream& stream_; BitStream bit_stream_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "compressor.hpp" #include #include #include #include #include #include #include #include "compressor/bit_stream.hpp" #include "compressor/huffman_code.hpp" #include "compressor/intermediate_compressed_stream.hpp" #include "compressor/output_file_transaction.hpp" #include "compressor/patricia_tree.hpp" #include "compressor/pattern_aggregator.hpp" #include "compressor/pattern_covering.hpp" #include "compressor/pattern_extractor.hpp" #include "compressor/positions_map.hpp" #include "compressor/raw_words_stream.hpp" #include "compressor/seg_stream.hpp" namespace silkworm::snapshots::seg { /** * Pick every kWordSamplingFactor-th word for superstring inclusion. * Also drop superstrings unless their overflowing word is kWordSamplingFactor-th. */ static constexpr size_t kSuperstringSamplingFactor = 4; static constexpr size_t kOutputStreamBufferSize = 1_Mebi; static constexpr size_t kIntermediateStreamBufferSize = kOutputStreamBufferSize * 4; class CompressorImpl { public: CompressorImpl( const std::filesystem::path& path, const std::filesystem::path& tmp_dir_path, CompressionKind compression_kind) : path_(path), compression_kind_(compression_kind), raw_words_file_path_(make_raw_words_file_path(path, tmp_dir_path)), raw_words_(raw_words_file_path_, RawWordsStream::OpenMode::kCreate, kOutputStreamBufferSize), pattern_aggregator_(tmp_dir_path) {} ~CompressorImpl(); void add_word(ByteView word); void add_word(ByteView word, bool is_compressed); void compress(); private: void consume_superstring(const Superstring& superstring); static std::filesystem::path make_raw_words_file_path( const std::filesystem::path& path, const std::filesystem::path& tmp_dir_path) { return tmp_dir_path / (path.filename().string() + ".idt"); } std::filesystem::path intermediate_file_path() const { return path_.string() + ".tmp.tmp"; } bool is_next_word_compressed() const; std::filesystem::path path_; CompressionKind compression_kind_; //! Flag indicating if next word is key (false) or value (true) bool is_next_value_{false}; std::filesystem::path raw_words_file_path_; RawWordsStream raw_words_; Superstring current_superstring_; size_t superstring_sample_cycle_index_{}; PatternExtractor pattern_extractor_; PatternAggregator pattern_aggregator_; }; CompressorImpl::~CompressorImpl() { std::filesystem::remove(raw_words_file_path_); std::filesystem::remove(intermediate_file_path()); } bool CompressorImpl::is_next_word_compressed() const { CompressionKind next_word_compression_kind = is_next_value_ ? CompressionKind::kValues : CompressionKind::kKeys; return (compression_kind_ & next_word_compression_kind) != CompressionKind::kNone; } void CompressorImpl::add_word(ByteView word) { add_word(word, is_next_word_compressed()); is_next_value_ = !is_next_value_; } void CompressorImpl::add_word(ByteView word, bool is_compressed) { if (is_compressed) { if (!current_superstring_.can_add_word(word)) { if (superstring_sample_cycle_index_ == 0) { consume_superstring(current_superstring_); } current_superstring_.clear(); superstring_sample_cycle_index_ = (superstring_sample_cycle_index_ + 1) % kSuperstringSamplingFactor; } current_superstring_.add_word(word, /* skip_copy = */ superstring_sample_cycle_index_); } raw_words_.write_word(word, is_compressed); } void CompressorImpl::consume_superstring(const Superstring& superstring) { pattern_extractor_.extract_patterns(superstring, [this](ByteView pattern, uint64_t score) { pattern_aggregator_.collect_pattern({Bytes{pattern}, score}); }); } template static std::vector vector_reorder(const std::vector& items, const std::vector& order) { std::vector result(items.size()); for (size_t i = 0; i < result.size(); ++i) result[i] = items[order[i]]; return result; } static std::vector invert_order(const std::vector& order) { std::vector result(order.size(), 0); for (size_t i = 0; i < result.size(); ++i) result[order[i]] = i; return result; } void CompressorImpl::compress() { using Pattern = PatternAggregator::Pattern; raw_words_.flush(); consume_superstring(current_superstring_); auto candidate_patterns = PatternAggregator::aggregate(std::move(pattern_aggregator_)); PatriciaTree patterns_patricia_tree; for (auto& pattern : candidate_patterns) { patterns_patricia_tree.insert(pattern.data, &pattern); } PatternCoveringSearch pattern_covering_search{ patterns_patricia_tree, [](void* pattern) { return reinterpret_cast(pattern)->score; }, }; IntermediateCompressedStream intermediate_stream{ intermediate_file_path(), kIntermediateStreamBufferSize, }; IntermediateCompressedStream::CompressedWord compressed_word{}; Bytes word_uncovered_data; // a pattern code for the intermediate file is equal to the index std::vector intermediate_pattern_codes(candidate_patterns.size()); std::iota(intermediate_pattern_codes.begin(), intermediate_pattern_codes.end(), 0); size_t words_count = 0; size_t empty_words_count = 0; std::vector pattern_uses(candidate_patterns.size(), 0); PositionsMap positions_map; raw_words_.rewind(); while (auto entry = raw_words_.read_word()) { auto& [word, is_compressed] = entry.value(); ++words_count; if (word.empty()) ++empty_words_count; compressed_word.raw_length = word.size(); compressed_word.pattern_positions.clear(); if (is_compressed) { auto& result = pattern_covering_search.cover_word(word); for (auto [pattern_pos, pattern_ptr] : result.pattern_positions) { auto pattern = reinterpret_cast(pattern_ptr); auto pattern_index = static_cast(std::distance(&candidate_patterns[0], pattern)); ++pattern_uses[pattern_index]; size_t pattern_code = intermediate_pattern_codes[pattern_index]; compressed_word.pattern_positions.emplace_back(pattern_pos, pattern_code); } word_uncovered_data.clear(); for (auto [start, end] : result.uncovered_ranges) { word_uncovered_data.append( word.cbegin() + static_cast(start), word.cbegin() + static_cast(end)); } intermediate_stream.write_word(compressed_word); intermediate_stream.write_uncovered_data(word_uncovered_data); } else { intermediate_stream.write_word(compressed_word); intermediate_stream.write_uncovered_data(word); } positions_map.update_with_word(compressed_word.raw_length, compressed_word.pattern_positions); } intermediate_stream.flush(); // once we ran pattern_covering_search on all the words, we know which candidate patterns are actually used // let's remove the unused candidate patterns from consideration std::vector patterns; size_t used_patterns_count = 0; // candidate2pattern_index maps candidate patterns indexes to the used patterns indexes std::vector candidate2pattern_index(candidate_patterns.size(), std::numeric_limits::max()); for (size_t i = 0; i < candidate_patterns.size(); ++i) { if (pattern_uses[i] == 0) continue; patterns.emplace_back(std::move(candidate_patterns[i].data)); intermediate_pattern_codes[used_patterns_count] = intermediate_pattern_codes[i]; pattern_uses[used_patterns_count] = pattern_uses[i]; candidate2pattern_index[i] = used_patterns_count; ++used_patterns_count; } intermediate_pattern_codes.resize(used_patterns_count); pattern_uses.resize(used_patterns_count); { // sort patterns and pattern_uses by uses and intermediate codes auto pattern_uses_order = huffman_code_table_order_by_uses_and_codes(pattern_uses, intermediate_pattern_codes); patterns = vector_reorder(patterns, pattern_uses_order); pattern_uses = vector_reorder(pattern_uses, pattern_uses_order); // pattern2code_index maps old pattern indexes to patterns_code_table indexes auto pattern2code_index = invert_order(pattern_uses_order); for (size_t& index : candidate2pattern_index) { if (index < std::numeric_limits::max()) { index = pattern2code_index[index]; } } } auto patterns_code_table = huffman_code_table(pattern_uses); auto patterns_code_table_order = huffman_code_table_order_by_codes(patterns_code_table); // calculate position uses auto positions = positions_map.list_positions(); auto position_uses = positions_map.list_uses(); { // sort positions and position_uses by uses and intermediate codes // an intermediate position code is equal to the position value auto& intermediate_position_codes = positions; auto position_uses_order = huffman_code_table_order_by_uses_and_codes(position_uses, intermediate_position_codes); positions = vector_reorder(positions, position_uses_order); position_uses = vector_reorder(position_uses, position_uses_order); } auto positions_code_table = huffman_code_table(position_uses); auto positions_code_table_order = huffman_code_table_order_by_codes(positions_code_table); SegStream::Header seg_header{ .words_count = words_count, .empty_words_count = empty_words_count, }; for (size_t i : patterns_code_table_order) { uint8_t code_bits = patterns_code_table[i].code_bits; auto& pattern = patterns[i]; seg_header.patterns.push_back(SegStream::HuffmanCodeTableSymbol{ .code_bits = code_bits, .data = pattern, }); } // pos2code maps position values to positions_code_table indexes std::map pos2code_index; auto pos2code = [&](size_t position) -> const HuffmanSymbolCode& { return positions_code_table[pos2code_index[position]]; }; for (size_t i : positions_code_table_order) { uint8_t code_bits = positions_code_table[i].code_bits; auto position = static_cast(positions[i]); seg_header.positions.push_back(SegStream::HuffmanCodeTableSymbol{ .code_bits = code_bits, .data = position, }); pos2code_index[position] = i; } OutputFileTransaction out_file{path_, kOutputStreamBufferSize}; SegStream seg_stream{out_file.stream()}; seg_stream.write_header(seg_header); auto write_code = [&seg_stream](const HuffmanSymbolCode& code) { seg_stream.codes().write(code.code, code.code_bits); }; intermediate_stream.rewind(); while (auto compressed_word1 = intermediate_stream.read_word()) { size_t raw_length = compressed_word1->raw_length; auto& raw_length_code = pos2code(PositionsMap::word_length_position(raw_length)); write_code(raw_length_code); if (raw_length == 0) { seg_stream.codes().flush(); continue; } size_t uncovered_data_size = raw_length; size_t prev_pattern_position = 0; size_t prev_pattern_end = 0; for (auto [pattern_position, candidate_pattern_index] : compressed_word1->pattern_positions) { auto position = PositionsMap::position(pattern_position, prev_pattern_position); auto& position_code = pos2code(position); prev_pattern_position = pattern_position; size_t pattern_index = candidate2pattern_index[candidate_pattern_index]; auto& pattern_code = patterns_code_table[pattern_index]; auto& pattern = patterns[pattern_index]; size_t pattern_end = pattern_position + pattern.size(); // the patterns might overlap (pattern_position < prev_pattern_end), // in this case covered_size is less than the pattern size size_t covered_size = pattern_end - std::max(pattern_position, prev_pattern_end); uncovered_data_size -= covered_size; prev_pattern_end = pattern_end; write_code(position_code); write_code(pattern_code); } auto& terminator_position_code = pos2code(PositionsMap::kTerminatorPosition); write_code(terminator_position_code); seg_stream.codes().flush(); Bytes uncovered_data = intermediate_stream.read_uncovered_data(uncovered_data_size); seg_stream.write_uncovered_data(uncovered_data); } out_file.commit(); } Compressor::Compressor( const std::filesystem::path& path, const std::filesystem::path& tmp_dir_path, CompressionKind compression_kind) : p_impl_{std::make_unique(path, tmp_dir_path, compression_kind)} {} Compressor::~Compressor() { static_assert(true); } Compressor::Compressor(Compressor&& other) noexcept : p_impl_(std::move(other.p_impl_)) {} Compressor& Compressor::operator=(Compressor&& other) noexcept { p_impl_ = std::move(other.p_impl_); return *this; } void Compressor::add_word(ByteView word) { p_impl_->add_word(word); } void Compressor::add_word(ByteView word, bool is_compressed) { p_impl_->add_word(word, is_compressed); } void Compressor::compress(Compressor compressor) { compressor.p_impl_->compress(); } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/compressor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "compression_kind.hpp" namespace silkworm::snapshots::seg { class CompressorImpl; class Compressor { public: Compressor( const std::filesystem::path& path, const std::filesystem::path& tmp_dir_path, CompressionKind compression_kind = CompressionKind::kAll); ~Compressor(); Compressor(Compressor&& other) noexcept; Compressor& operator=(Compressor&& other) noexcept; void add_word(ByteView word); void add_word(ByteView word, bool is_compressed); static void compress(Compressor compressor); using value_type = ByteView; using Iterator = std::back_insert_iterator; void push_back(ByteView word) { add_word(word); } Iterator add_word_iterator() { return std::back_inserter(*this); } private: std::unique_ptr p_impl_; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/decompressor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "decompressor.hpp" #include #include #include #include #include #include #include #include #include #include #include #include "common/varint.hpp" namespace silkworm::snapshots::seg { //! Size in bytes of metadata header fields in compressed file static constexpr size_t kWordsCountSize{sizeof(uint64_t)}; static constexpr size_t kEmptyWordsCountSize{sizeof(uint64_t)}; static constexpr size_t kDictionaryLengthSize{sizeof(uint64_t)}; //! Minimum compressed file size given the metadata header static constexpr size_t kMinimumFileSize = 32; //! Maximum allowed depth in compressed file static constexpr size_t kMaxAllowedDepth = 50; DecodingTable::DecodingTable(size_t max_depth) : max_depth_(max_depth) { bit_length_ = max_depth_ > kMaxTableBitLength ? kMaxTableBitLength : max_depth_; } CodeWord::CodeWord() : CodeWord(0, 0, {}, nullptr, nullptr) {} CodeWord::CodeWord(uint16_t code, uint8_t length, ByteView pattern) : CodeWord(code, length, pattern, nullptr, nullptr) {} CodeWord::CodeWord(uint16_t code, uint8_t length, ByteView pattern, std::unique_ptr table, CodeWord* next) : code_(code), code_length_(length), pattern_(pattern), table_(std::move(table)), next_(next) {} void CodeWord::reset_content(uint16_t code, uint8_t length, ByteView pattern) { code_ = code; code_length_ = length; pattern_ = pattern; table_ = nullptr; } void CodeWord::set_next(CodeWord* next) { next_ = next; } std::ostream& operator<<(std::ostream& out, const PatternTable& pt) { out << pt.to_string(); return out; } std::string PatternTable::to_string() const { const auto& pt = *this; std::stringstream out; out << "Pattern Table:\n"; out << "bit length: " << pt.bit_length_ << "\n"; out << std::setfill('0'); const int bit_len = static_cast(pt.bit_length_); for (size_t i{0}; i < pt.codewords_.size(); ++i) { const auto& cw = pt.codewords_[i]; if (cw) { out << std::dec << std::setw(3) << i << " " << std::hex << std::setw(bit_len) << cw->code() << "\n"; } else { out << std::dec << std::setw(3) << i << " NULL\n"; } } out << std::dec; return out.str(); } //! Build the table of word distances in range (0, 512) for each power of 2 in use except 2^0 //! @details The resulting matrix has distance steps equal to 2^i for each i in (0, 9) i.e. //! 0 -> [] //! 1 -> [2 4 6 8 10 12 ... 508 510] //! 2 -> [4 8 12 16 20 ... 504 508] //! ... //! 7 -> [128 256 384] //! 8 -> [256] //! 9 -> [] //! @return the word distances for power of 2 static PatternTable::WordDistances build_word_distances() { PatternTable::WordDistances word_distances{}; for (size_t i{1}; i < PatternTable::kNumPowers; ++i) { std::vector distances{}; distances.reserve((size_t{1} << (PatternTable::kNumPowers - 1 - i)) - 1); for (int j{1 << i}; 0 < j && j < PatternTable::kMaxPower; j += (1 << i)) { distances.push_back(j); } word_distances[i] = std::move(distances); } return word_distances; } //! Initialize once and for all the word distances in the data for each power of 2 const PatternTable::WordDistances PatternTable::kWordDistances{build_word_distances()}; //! Initialize condensed table threshold for bit length using default value size_t PatternTable::condensed_table_bit_length_threshold_{kDefaultCondensedTableBitLengthThreshold}; void PatternTable::set_condensed_table_bit_length_threshold(size_t condensed_table_bit_length_threshold) { if (condensed_table_bit_length_threshold > kMaxTableBitLength) { throw std::invalid_argument{ "bit length threshold for condensed tables is too big: " + std::to_string(condensed_table_bit_length_threshold) + " max allowed value is: " + std::to_string(kMaxTableBitLength)}; } condensed_table_bit_length_threshold_ = condensed_table_bit_length_threshold; } PatternTable::PatternTable(size_t max_depth) : DecodingTable(max_depth) { if (bit_length_ <= condensed_table_bit_length_threshold_) { codewords_.resize(size_t{1} << bit_length_); } } size_t PatternTable::build_condensed(std::span patterns) { return build_condensed(patterns, max_depth_, 0, 0, 0); } size_t PatternTable::build_condensed(std::span patterns, uint64_t highest_depth, uint16_t code, int bits, uint64_t depth) { SILK_TRACE << "#patterns: " << patterns.size() << " highest_depth: " << highest_depth << " code: " << code << " bits: " << std::bitset(static_cast(bits)) << " depth: " << depth; if (patterns.empty()) { return 0; } const auto first_pattern = patterns.front(); if (depth == first_pattern.depth) { auto codeword = make_unique(code, static_cast(bits), first_pattern.value, nullptr, nullptr); codewords_list_.push_back(std::move(codeword)); insert_word(codewords_list_.back().get()); return 1; } if (bits == kMaxTableBitLength) { auto new_table{std::make_unique(highest_depth)}; auto codeword = make_unique(code, 0, ByteView{}, std::move(new_table), nullptr); codewords_list_.push_back(std::move(codeword)); const auto last_cw = insert_word(codewords_list_.back().get()); return last_cw->table()->build_condensed(patterns, highest_depth, 0, 0, depth); } if (highest_depth == 0) { throw std::runtime_error("cannot build pattern tree: highest_depth reached zero"); } const auto b0 = build_condensed(patterns, highest_depth - 1, code, bits + 1, depth + 1); return b0 + build_condensed(patterns.subspan(b0), highest_depth - 1, static_cast((1 << bits) | code), bits + 1, depth + 1); } CodeWord* PatternTable::insert_word(CodeWord* codeword) { CodeWord* inserted{nullptr}; if (bit_length_ <= condensed_table_bit_length_threshold_) { const size_t code_step = 1 << codeword->code_length(); const size_t code_from = codeword->code(); const size_t code_to = ((bit_length_ != codeword->code_length()) && (codeword->code_length() > 0)) ? code_from | (1 << bit_length_) : code_from + code_step; for (size_t c = code_from; c < code_to; c += code_step) { auto cw = codewords_[c]; if (cw == nullptr) { codewords_[c] = codeword; inserted = codewords_[c]; } else { cw->reset_content(static_cast(c), codeword->code_length(), codeword->pattern()); inserted = cw; } } } else { codeword->set_next(nullptr); if (head_ == nullptr) { codewords_.push_back(codeword); head_ = codewords_.front(); inserted = head_; } else { SILKWORM_ASSERT(!codewords_.empty()); codewords_.push_back(codeword); inserted = codewords_.back(); } } return inserted; } const CodeWord* PatternTable::search_condensed(uint16_t code) const { if (bit_length_ <= condensed_table_bit_length_threshold_) { return codeword(code); } CodeWord* previous{nullptr}; for (auto* current = head_; current != nullptr; previous = current, current = current->next()) { if (current->code() == code) { if (previous != nullptr) { previous->set_next(current->next()); current->set_next(head_); head_ = current; } return current; } const auto distance = code - current->code(); if ((distance & 0x1) != 0) { continue; } if (check_distance(current->code_length(), distance)) { if (previous != nullptr) { previous->set_next(current->next()); current->set_next(head_); head_ = current; } return current; } } return nullptr; } bool PatternTable::check_distance(size_t power, int distance) { const auto& distances = PatternTable::kWordDistances[power]; auto it = std::find_if(distances.cbegin(), distances.cend(), [distance](const int d) { return d == distance; }); return it != distances.cend(); } PositionTable::PositionTable(size_t max_depth) : DecodingTable(max_depth) { positions_.resize(size_t{1} << bit_length_); lengths_.resize(size_t{1} << bit_length_); children_.resize(size_t{1} << bit_length_); } int PositionTable::build(std::span positions) { return build_tree(positions, max_depth_, 0, 0, 0); } int PositionTable::build_tree(std::span positions, uint64_t highest_depth, uint16_t code, int bits, uint64_t depth) { SILK_TRACE << "build_tree #positions: " << positions.size() << " highest_depth: " << highest_depth << " code: " << code << " bits: " << std::bitset(static_cast(bits)) << " depth: " << depth; if (positions.empty()) { return 0; } const auto& first_position = positions.front(); if (depth == first_position.depth) { if (bit_length_ == static_cast(bits)) { positions_[code] = first_position.value; lengths_[code] = static_cast(bits); children_[code] = nullptr; } else { const size_t code_step = 1 << bits; const size_t code_from = code; const size_t code_to = code_from | (1 << bit_length_); for (size_t c = code_from; c < code_to; c += code_step) { positions_[c] = first_position.value; lengths_[c] = static_cast(bits); children_[c] = nullptr; } } return 1; } if (bits == kMaxTableBitLength) { auto child_table{std::make_unique(highest_depth)}; positions_[code] = 0; lengths_[code] = 0; children_[code] = std::move(child_table); return children_[code]->build_tree(positions, highest_depth, 0, 0, depth); } if (highest_depth == 0) { throw std::runtime_error("cannot build position tree: highest_depth reached zero"); } const int b0 = build_tree(positions, highest_depth - 1, code, bits + 1, depth + 1); return b0 + build_tree(positions.subspan(static_cast(b0)), highest_depth - 1, static_cast((1 << bits) | code), bits + 1, depth + 1); } std::ostream& operator<<(std::ostream& out, const PositionTable& pt) { out << pt.to_string(); return out; } std::string PositionTable::to_string() const { const auto& pt = *this; std::stringstream out; out << "Position Table:\n"; out << "bit length: " << pt.bit_length_ << "\n"; out << std::setfill('0'); for (size_t i{0}; i < pt.positions_.size(); ++i) { const uint64_t position = pt.positions_[i]; const uint64_t length = pt.lengths_[i]; out << std::dec << std::setw(3) << i << " position: " << position << " length: " << length; const auto& child = pt.children_[i]; if (child) { out << "child:\n\t\t" << *child << "\n"; } else { out << " child: NULL\n"; } } out << std::dec; return out.str(); } class Decompressor::ReadModeGuard { public: ReadModeGuard( const MemoryMappedFile& file, Decompressor::ReadMode new_mode, Decompressor::ReadMode old_mode) : file_(file), old_mode_(old_mode) { set_mode(new_mode); } virtual ~ReadModeGuard() { set_mode(old_mode_); } private: void set_mode(Decompressor::ReadMode mode) { switch (mode) { case ReadMode::kNormal: file_.advise_normal(); break; case ReadMode::kRandom: file_.advise_random(); break; case ReadMode::kSequential: file_.advise_sequential(); break; } } const MemoryMappedFile& file_; Decompressor::ReadMode old_mode_; }; Decompressor::Decompressor( std::filesystem::path compressed_path, std::optional compressed_region, CompressionKind compression_kind) : compressed_path_{std::move(compressed_path)}, compressed_region_{compressed_region}, compression_kind_{compression_kind}, compressed_file_{compressed_path_, compressed_region_} { const auto compressed_file_size = compressed_file_.size(); if (compressed_file_size < kMinimumFileSize) { throw std::runtime_error("compressed file is too short: " + std::to_string(compressed_file_size)); } const auto address = compressed_file_.region().data(); compressed_file_.advise_sequential(); // Read header from compressed file words_count_ = endian::load_big_u64(address); empty_words_count_ = endian::load_big_u64(address + kWordsCountSize); SILK_TRACE << "Decompress words count: " << words_count_ << " empty words count: " << empty_words_count_; // Read patterns from compressed file const auto pattern_dict_length = endian::load_big_u64(address + kWordsCountSize + kEmptyWordsCountSize); SILK_TRACE << "Decompress pattern dictionary length: " << pattern_dict_length; if (pattern_dict_length > compressed_file_size - kMinimumFileSize) { throw std::runtime_error("invalid pattern_dict_length for compressed file size: " + std::to_string(compressed_file_size)); } const size_t patterns_dict_offset{kWordsCountSize + kEmptyWordsCountSize + kDictionaryLengthSize}; read_patterns(ByteView{address + patterns_dict_offset, pattern_dict_length}); // Read positions from compressed file const auto position_dict_length = endian::load_big_u64(address + patterns_dict_offset + pattern_dict_length); SILK_TRACE << "Decompress position dictionary length: " << position_dict_length; if (position_dict_length > compressed_file_size - pattern_dict_length - kMinimumFileSize) { throw std::runtime_error("invalid position_dict_length for compressed file size: " + std::to_string(compressed_file_size)); } const size_t positions_dict_offset{patterns_dict_offset + pattern_dict_length + kDictionaryLengthSize}; read_positions(ByteView{address + positions_dict_offset, position_dict_length}); // Store the start offset and length of the data words words_start_ = address + positions_dict_offset + position_dict_length; words_length_ = compressed_file_size - (positions_dict_offset + position_dict_length); SILKWORM_ASSERT(address + compressed_file_size == words_start_ + words_length_); SILK_TRACE << "Decompressor words start offset: " << (words_start_ - address) << " words length: " << words_length_ << " total size: " << compressed_file_size; compressed_file_.advise_random(); } Decompressor::Iterator Decompressor::begin() const { auto read_mode_guard = std::make_shared(compressed_file_, ReadMode::kSequential, ReadMode::kRandom); Iterator it{this, std::move(read_mode_guard)}; if (it.has_next()) { ++it; return it; } return end(); } Decompressor::Iterator Decompressor::seek(uint64_t offset, ByteView prefix) const { SILK_TRACE << "Decompressor::seek offset: " << offset; Iterator it = make_iterator(); it.reset(offset); if (!it.has_next()) { return end(); } if (!prefix.empty() && !it.has_prefix(prefix)) { return end(); } try { ++it; return it; } catch (const std::runtime_error& re) { SILK_WARN << "Decompressor::seek invalid offset: " << offset << " what: " << re.what(); return end(); } } void Decompressor::read_patterns(ByteView dict) { ByteView raw_input = dict; std::vector patterns; patterns.reserve(kMaxTablePatterns); uint64_t pattern_highest_depth{0}; auto current_position = [&]() -> size_t { return dict.size() - raw_input.size(); }; while (!raw_input.empty()) { auto pattern_depth_opt = varint::decode(raw_input); if (!pattern_depth_opt) { throw std::runtime_error{"pattern dict is invalid: depth read failed at " + std::to_string(current_position())}; } uint64_t pattern_depth = pattern_depth_opt.value(); if (pattern_depth > kMaxAllowedDepth) { throw std::runtime_error{"pattern dict is invalid: pattern depth " + std::to_string(pattern_depth) + " is greater than max allowed: " + std::to_string(kMaxAllowedDepth)}; } SILK_TRACE << "pattern depth: " << pattern_depth << " coded input position: " << current_position(); if (pattern_depth > pattern_highest_depth) { pattern_highest_depth = pattern_depth; SILK_TRACE << "pattern highest depth: " << pattern_highest_depth; } auto pattern_data_length_opt = varint::decode(raw_input); if (!pattern_data_length_opt) { throw std::runtime_error{"pattern dict is invalid: length read failed at " + std::to_string(current_position())}; } uint64_t pattern_data_length = pattern_data_length_opt.value(); if (pattern_data_length > std::numeric_limits::max()) { throw std::runtime_error{"pattern data length is too long: " + std::to_string(pattern_data_length)}; } SILK_TRACE << "pattern data length: " << pattern_data_length << " coded input position: " << current_position(); if (raw_input.size() < pattern_data_length) { throw std::runtime_error{"pattern dict is invalid: data skip failed at " + std::to_string(current_position())}; } ByteView pattern_data{raw_input.data(), pattern_data_length}; raw_input.remove_prefix(pattern_data_length); SILK_TRACE << "count: " << patterns.size() << " data size: " << pattern_data.size() << " coded input position: " << current_position(); patterns.emplace_back(Pattern{pattern_depth, pattern_data}); } SILK_TRACE << "Pattern count: " << patterns.size() << " highest depth: " << pattern_highest_depth; pattern_dict_ = std::make_unique(pattern_highest_depth); if (!dict.empty()) { pattern_dict_->build_condensed({patterns.data(), patterns.size()}); } SILK_TRACE << "#codewords: " << pattern_dict_->num_codewords(); SILK_TRACE << *pattern_dict_; } void Decompressor::read_positions(ByteView dict) { ByteView raw_input = dict; std::vector positions; positions.reserve(kMaxTablePositions); uint64_t position_highest_depth{0}; auto current_position = [&]() -> size_t { return dict.size() - raw_input.size(); }; while (!raw_input.empty()) { auto position_depth_opt = varint::decode(raw_input); if (!position_depth_opt) { throw std::runtime_error("position dict is invalid: depth read failed at " + std::to_string(current_position())); } uint64_t position_depth = position_depth_opt.value(); if (position_depth > kMaxAllowedDepth) { throw std::runtime_error{"position dict is invalid: position depth " + std::to_string(position_depth) + " is greater than max allowed: " + std::to_string(kMaxAllowedDepth)}; } SILK_TRACE << "position depth: " << position_depth << " coded input position: " << current_position(); if (position_depth > position_highest_depth) { position_highest_depth = position_depth; SILK_TRACE << "position highest depth: " << position_highest_depth; } auto position_opt = varint::decode(raw_input); if (!position_opt) { throw std::runtime_error("position dict is invalid: position read failed at " + std::to_string(current_position())); } uint64_t position = position_opt.value(); if (position > std::numeric_limits::max()) { throw std::runtime_error("position is too long: " + std::to_string(position)); } SILK_TRACE << "count: " << positions.size() << " position: " << position << " coded input position: " << current_position(); positions.emplace_back(Position{position_depth, position}); } SILK_TRACE << "Position count: " << positions.size() << " highest depth: " << position_highest_depth; position_dict_ = std::make_unique(position_highest_depth); if (!dict.empty()) { position_dict_->build({positions.data(), positions.size()}); } SILK_TRACE << "#positions: " << position_dict_->num_positions(); SILK_TRACE << *position_dict_; } Decompressor::Iterator::Iterator( const Decompressor* decoder, std::shared_ptr read_mode_guard) : decoder_(decoder), read_mode_guard_(std::move(read_mode_guard)) {} ByteView Decompressor::Iterator::data() const { return ByteView{decoder_->words_start_, decoder_->words_length_}; } bool Decompressor::Iterator::has_prefix(ByteView prefix) { const auto prefix_size{prefix.size()}; const auto start_offset = word_offset_; [[maybe_unused]] auto _ = gsl::finally([&]() { word_offset_ = start_offset; bit_position_ = 0; }); uint64_t next_data_position = next_position(true); if (next_data_position == 0) { throw std::runtime_error{"invalid zero next position in: " + decoder_->compressed_filename()}; } const auto word_length = --next_data_position; // because when we create HT we do ++ (0 is terminator) SILK_TRACE << "Iterator::has_prefix start_offset=" << start_offset << " word_length=" << word_length; if (word_length == 0 || word_length < prefix_size) { if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } return prefix_size == word_length; } // First pass: we only check the patterns. Only run this loop as far as prefix goes, no need to go any further size_t buffer_position{0}; for (auto pos{next_position(false)}; pos != 0; pos = next_position(false)) { // Positions where to insert patterns are encoded relative to one another buffer_position += pos - 1; const ByteView pattern = next_pattern(); SILK_TRACE << "Iterator::has_prefix data-from-patterns pos=" << pos << " pattern=" << to_hex(pattern); const auto comparison_size{std::min(prefix_size - buffer_position, pattern.size())}; if (buffer_position < prefix_size) { if (prefix.substr(buffer_position, comparison_size) != pattern.substr(0, comparison_size)) { return false; } } } if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } uint64_t post_loop_offset = word_offset_; word_offset_ = start_offset; bit_position_ = 0; // Reset the iterator state (void)next_position(true); // Second pass: we check spaces not covered by the patterns size_t last_uncovered{0}; buffer_position = 0; for (auto pos{next_position(false)}; pos != 0 && last_uncovered < prefix_size; pos = next_position(false)) { // Positions where to insert patterns are encoded relative to one another buffer_position += pos - 1; if (buffer_position > last_uncovered) { const size_t position_diff = buffer_position - last_uncovered; SILK_TRACE << "Iterator::has_prefix other-data pos=" << pos << " last_uncovered=" << last_uncovered << " buffer_position=" << buffer_position << " position_diff=" << position_diff << " data=" << to_hex(ByteView{data().data() + post_loop_offset, position_diff}); const auto comparison_size{std::min(prefix_size - last_uncovered, position_diff)}; if (prefix.substr(last_uncovered, comparison_size) != data().substr(post_loop_offset, comparison_size)) { return false; } post_loop_offset += position_diff; } last_uncovered = buffer_position + next_pattern().size(); } if (prefix_size > last_uncovered && word_length > last_uncovered) { const size_t position_diff = word_length - last_uncovered; SILK_TRACE << "Iterator::has_prefix other-data last_uncovered=" << last_uncovered << " buffer_position=" << buffer_position << " position_diff=" << position_diff << " data=" << to_hex(ByteView{data().data() + post_loop_offset, position_diff}); const auto comparison_size{prefix_size < word_length ? prefix_size - last_uncovered : position_diff}; if (prefix.substr(last_uncovered, comparison_size) != data().substr(post_loop_offset, comparison_size)) { return false; } post_loop_offset += position_diff; } SILK_TRACE << "Iterator::has_prefix word_offset_=" << word_offset_ << "; post_loop_offset=" << post_loop_offset; return true; } uint64_t Decompressor::Iterator::next_compressed(Bytes& buffer) { const auto start_offset = word_offset_; uint64_t word_length = next_position(true); if (word_length == 0) { throw std::runtime_error{"invalid zero word length in: " + decoder_->compressed_filename()}; } --word_length; // because when we create HT we do ++ (0 is terminator) SILK_TRACE << "Iterator::next start_offset=" << start_offset << " word_length=" << word_length; if (word_length == 0) { if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } return word_offset_; } // Track position into buffer where to insert part of the word size_t buffer_offset = buffer.size(); buffer.resize(buffer_offset + word_length); SILK_TRACE << "Iterator::next buffer resized to: " << buffer.size(); // Fill in the patterns size_t buffer_position = buffer_offset; for (auto pos{next_position(false)}; pos != 0; pos = next_position(false)) { // Positions where to insert patterns are encoded relative to one another buffer_position += pos - 1; const ByteView pattern = next_pattern(); SILK_TRACE << "Iterator::next data-from-patterns pos=" << pos << " pattern=" << to_hex(pattern); if (buffer_position > buffer.size()) { return word_offset_; } pattern.copy(buffer.data() + buffer_position, std::min(pattern.size(), buffer.size() - buffer_position)); } if (bit_position_ > 0) { ++word_offset_; } uint64_t post_loop_offset = word_offset_; word_offset_ = start_offset; bit_position_ = 0; // Reset the iterator state (void)next_position(true); // Restore the beginning of buffer buffer_position = buffer_offset; size_t last_uncovered = buffer_offset; // Fill in data which is not the patterns for (auto pos{next_position(false)}; pos != 0; pos = next_position(false)) { // Positions where to insert patterns are encoded relative to one another buffer_position += pos - 1; if (buffer_position > last_uncovered) { size_t position_diff = buffer_position - last_uncovered; SILK_TRACE << "Iterator::next other-data pos=" << pos << " last_uncovered=" << last_uncovered << " buffer_position=" << buffer_position << " position_diff=" << position_diff << " data=" << to_hex(ByteView{data().data() + post_loop_offset, position_diff}); data().copy(buffer.data() + last_uncovered, std::min(position_diff, buffer.size() - last_uncovered), post_loop_offset); post_loop_offset += position_diff; } last_uncovered = buffer_position + next_pattern().size(); } if (buffer_offset + word_length > last_uncovered) { size_t position_diff = buffer_offset + word_length - last_uncovered; SILK_TRACE << "Iterator::next other-data last_uncovered=" << last_uncovered << " buffer_position=" << buffer_position << " position_diff=" << position_diff << " data=" << to_hex(ByteView{data().data() + post_loop_offset, position_diff}); data().copy(buffer.data() + last_uncovered, std::min(position_diff, buffer.size() - last_uncovered), post_loop_offset); post_loop_offset += position_diff; } word_offset_ = post_loop_offset; bit_position_ = 0; SILK_TRACE << "Iterator::next word_offset_=" << word_offset_; return post_loop_offset; } uint64_t Decompressor::Iterator::next_uncompressed(ByteView& buffer_view) { uint64_t word_length = next_position(true); if (word_length == 0) { throw std::runtime_error{"invalid zero word length in: " + decoder_->compressed_filename()}; } --word_length; // because when we create HT we do ++ (0 is terminator) if (word_length == 0) { if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } return word_offset_; } (void)next_position(false); if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } uint64_t word_position = word_offset_; word_offset_ += word_length; buffer_view = data().substr(word_position, word_length); return word_offset_; } uint64_t Decompressor::Iterator::skip_compressed() { uint64_t word_length = next_position(true); if (word_length == 0) { throw std::runtime_error{"invalid zero word length in: " + decoder_->compressed_filename()}; } --word_length; // because when we create HT we do ++ (0 is terminator) if (word_length == 0) { if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } return word_offset_; } size_t uncovered_count{0}; size_t buffer_position{0}; size_t last_uncovered{0}; for (auto pos{next_position(false)}; pos != 0; pos = next_position(false)) { // Positions where to insert are encoded relative to one another buffer_position += pos - 1; if (word_length < buffer_position) { throw std::logic_error{"likely index file is invalid: " + decoder_->compressed_filename()}; } if (buffer_position > last_uncovered) { uncovered_count += buffer_position - last_uncovered; } last_uncovered = buffer_position + next_pattern().size(); } if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } if (word_length > last_uncovered) { uncovered_count += word_length - last_uncovered; } word_offset_ += uncovered_count; return word_offset_; } uint64_t Decompressor::Iterator::skip_uncompressed() { uint64_t word_length = next_position(true); if (word_length == 0) { throw std::runtime_error{"invalid zero word length in: " + decoder_->compressed_filename()}; } --word_length; // because when we create HT we do ++ (0 is terminator) if (word_length == 0) { if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } return word_offset_; } (void)next_position(false); if (bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } word_offset_ += word_length; return word_offset_; } void Decompressor::Iterator::reset(uint64_t data_offset) { is_next_value_ = false; word_offset_ = data_offset; bit_position_ = 0; } ByteView Decompressor::Iterator::next_pattern() { const PatternTable* table = decoder_->pattern_dict_.get(); if (table->bit_length() == 0) { const auto* codeword{table->codeword(0)}; if (codeword == nullptr) { throw std::runtime_error{ "Unexpected missing codeword for code: 0 in snapshot: " + decoder_->compressed_path().string()}; } return codeword->pattern(); } uint8_t length{0}; ByteView pattern{}; while (length == 0) { const uint16_t code = next_code(table->bit_length()); const auto* codeword{table->search_condensed(code)}; if (codeword == nullptr) { throw std::runtime_error{ "Unexpected missing codeword for code: " + std::to_string(code) + " in snapshot: " + decoder_->compressed_path().string()}; } length = codeword->code_length(); if (length == 0) { table = codeword->table(); bit_position_ += 9; // CHAR_BIT + 1 } else { bit_position_ += length; pattern = codeword->pattern(); } word_offset_ += bit_position_ / CHAR_BIT; bit_position_ = bit_position_ % CHAR_BIT; } return pattern; } uint64_t Decompressor::Iterator::next_position(bool clean) { if (clean && bit_position_ > 0) { ++word_offset_; bit_position_ = 0; } SILK_TRACE << "Iterator::next_position word_offset_=" << word_offset_ << " bit_position_=" << int{bit_position_}; const PositionTable* table = decoder_->position_dict_.get(); if (table->bit_length() == 0) { SILK_TRACE << "Iterator::next_position table->position(0)=" << table->position(0); return table->position(0); } uint8_t length{0}; uint64_t position{0}; while (length == 0) { const uint16_t code = next_code(table->bit_length()); length = table->length(code); if (length == 0) { table = table->child(code); bit_position_ += 9; // CHAR_BIT + 1 } else { bit_position_ += length; SILK_TRACE << "Iterator::next_position table->position(code)=" << table->position(code); position = table->position(code); } word_offset_ += bit_position_ / CHAR_BIT; bit_position_ = bit_position_ % CHAR_BIT; } return position; } uint16_t Decompressor::Iterator::next_code(size_t bit_length) { uint16_t code = static_cast(decoder_->words_start_[word_offset_]) >> bit_position_; if (static_cast(CHAR_BIT - bit_position_) < bit_length && word_offset_ + 1 < data_size()) { code |= decoder_->words_start_[word_offset_ + 1] << (CHAR_BIT - bit_position_); } code &= (1 << bit_length) - 1; return code; } bool Decompressor::Iterator::is_next_word_compressed() const { CompressionKind next_word_compression_kind = is_next_value_ ? CompressionKind::kValues : CompressionKind::kKeys; return (decoder_->compression_kind_ & next_word_compression_kind) != CompressionKind::kNone; } Decompressor::Iterator& Decompressor::Iterator::operator++() { if (has_next()) { current_word_offset_ = word_offset_; bool is_next_word_compressed = this->is_next_word_compressed(); is_next_value_ = !is_next_value_; if (is_next_word_compressed) { current_word_ = Bytes{}; next_compressed(std::get(current_word_)); } else { current_word_ = ByteView{}; next_uncompressed(std::get(current_word_)); } } else { *this = make_end(); } return *this; } uint64_t Decompressor::Iterator::skip() { bool is_next_word_compressed = this->is_next_word_compressed(); is_next_value_ = !is_next_value_; return is_next_word_compressed ? skip_compressed() : skip_uncompressed(); } bool operator==(const Decompressor::Iterator& lhs, const Decompressor::Iterator& rhs) { if (lhs.decoder_ == nullptr) { return (rhs.decoder_ == nullptr); } return (lhs.decoder_ == rhs.decoder_) && (lhs.current_word_offset_ == rhs.current_word_offset_) && (lhs.word_offset_ == rhs.word_offset_) && (lhs.bit_position_ == rhs.bit_position_); } Decompressor::Iterator Decompressor::Iterator::make_end() { Iterator it{nullptr, {}}; it.current_word_offset_ = std::numeric_limits::max(); it.word_offset_ = std::numeric_limits::max(); it.bit_position_ = std::numeric_limits::max(); return it; } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/decompressor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include "compression_kind.hpp" namespace silkworm::snapshots::seg { class DecodingTable { public: //! The max bit length for tables (we don't use tables larger than 2^9) static constexpr size_t kMaxTableBitLength{9}; size_t bit_length() const { return bit_length_; } protected: explicit DecodingTable(size_t max_depth); size_t bit_length_{0}; size_t max_depth_; }; class PatternTable; class CodeWord { public: explicit CodeWord(); explicit CodeWord(uint16_t code, uint8_t length, ByteView pattern); explicit CodeWord(uint16_t code, uint8_t length, ByteView pattern, std::unique_ptr table, CodeWord* next); uint16_t code() const { return code_; } uint8_t code_length() const { return code_length_; } ByteView pattern() const { return pattern_; } PatternTable* table() const { return table_.get(); } CodeWord* next() const { return next_; } void reset_content(uint16_t code, uint8_t length, ByteView pattern); void set_next(CodeWord* next); private: //! Code associated to the symbol uint16_t code_{0}; //! Number of bits in the codes uint8_t code_length_{0}; ByteView pattern_; std::unique_ptr table_; CodeWord* next_; }; struct Pattern { uint64_t depth{}; ByteView value; }; class PatternTable : public DecodingTable { public: //! The default bit length threshold after which tables are condensed (default: all NOT condensed) static constexpr size_t kDefaultCondensedTableBitLengthThreshold{kMaxTableBitLength}; static constexpr int kNumPowers{10}; static constexpr int kMaxPower{512}; using WordDistances = std::array, kNumPowers>; //! @brief Set the bit length threshold after which tables will be condensed. //! @attention Condensing reduces size of decompression table but leads to slower reads. //! @details Tables with bit length greater than threshold will be condensed. To disable condensing completely //! set `condensed_table_bit_length_threshold` to 9; to enable condensing for all tables, set it to 0; to //! enable condensing for tables of size greater than 64, set it to 6. static void set_condensed_table_bit_length_threshold(size_t condensed_table_bit_length_threshold); explicit PatternTable(size_t max_depth); const CodeWord* codeword(size_t code) const { return code < codewords_.size() ? codewords_[code] : nullptr; } size_t num_codewords() const { return codewords_.size(); } const CodeWord* search_condensed(uint16_t code) const; size_t build_condensed(std::span patterns); std::string to_string() const; private: static const WordDistances kWordDistances; static size_t condensed_table_bit_length_threshold_; static bool check_distance(size_t power, int distance); size_t build_condensed( std::span patterns, uint64_t highest_depth, uint16_t code, int bits, uint64_t depth); [[maybe_unused]] CodeWord* insert_word(CodeWord* codeword); std::vector codewords_; std::vector> codewords_list_; mutable CodeWord* head_{nullptr}; friend std::ostream& operator<<(std::ostream& out, const PatternTable& pt); }; struct Position { uint64_t depth; uint64_t value; }; class PositionTable : public DecodingTable { public: explicit PositionTable(size_t max_depth); size_t num_positions() const { return positions_.size(); } uint64_t position(size_t code) const { return code < positions_.size() ? positions_[code] : 0; } uint8_t length(size_t code) const { return code < lengths_.size() ? lengths_[code] : 0; } PositionTable* child(size_t code) const { return code < children_.size() ? children_[code].get() : nullptr; } int build(std::span positions); std::string to_string() const; private: int build_tree( std::span positions, uint64_t highest_depth, uint16_t code, int bits, uint64_t depth); std::vector positions_; std::vector lengths_; std::vector> children_; friend std::ostream& operator<<(std::ostream& out, const PositionTable& pt); }; //! Snapshot decoder using modified Condensed Huffman Table (CHT) algorithm class Decompressor { public: //! The max number of patterns in decoding tables static constexpr size_t kMaxTablePatterns{(1 << DecodingTable::kMaxTableBitLength) * 510}; //! The max number of positions in decoding tables static constexpr size_t kMaxTablePositions{(1 << DecodingTable::kMaxTableBitLength) * 100}; enum class ReadMode : uint8_t { kNormal, kRandom, kSequential, }; class ReadModeGuard; //! Read-only access to the file data stream class Iterator { public: Iterator(const Decompressor* decoder, std::shared_ptr read_mode_guard); size_t data_size() const { return decoder_->words_length_; } //! Check if any next word is present in the data stream bool has_next() const { return word_offset_ < decoder_->words_length_; } //! Check if the word at the current offset has the specified prefix (this does not move offset to the next) bool has_prefix(ByteView prefix); //! Extract one *compressed* word from current offset in the file and append it to buffer //! After extracting current word, move at the beginning of the next one //! @return the next word position //! @warning full data copy into buffer happens here uint64_t next_compressed(Bytes& buffer); //! Extract one *uncompressed* word *view* from current offset in the file and return it in buffer view //! After extracting current word, move at the beginning of the next one //! @return the next word position //! @warning no data copy happens here uint64_t next_uncompressed(ByteView& buffer_view); //! Move at the offset of the next *compressed* word skipping current one //! @return the next word position uint64_t skip_compressed(); //! Move at the offset of the next *uncompressed* word skipping current one //! @return the next word position uint64_t skip_uncompressed(); //! Move at the offset of the next word skipping current one using skip() or skip_uncompressed() as necessary //! @return the next word position uint64_t skip(); //! Reset to the specified offset in the data stream void reset(uint64_t data_offset); //! The current word position uint64_t current_word_offset() const { return current_word_offset_; } //! input_iterator concept boilerplate using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using value_type = BytesOrByteView; using pointer = value_type*; using reference = value_type&; reference operator*() { return current_word_; } pointer operator->() { return ¤t_word_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++(); friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs); static Iterator make_end(); private: //! View on the whole data stream. inline ByteView data() const; //! Read the next pattern from the data stream ByteView next_pattern(); //! Read the next position from the data stream uint64_t next_position(bool clean); //! Read next code from the data stream inline uint16_t next_code(size_t bit_length); bool is_next_word_compressed() const; //! The decoder on which iterator works const Decompressor* decoder_; //! Position of current word in the data file uint64_t current_word_offset_{0}; //! Position of the next word uint64_t word_offset_{0}; //! Bit position [0..7] in current word of the data file uint8_t bit_position_{0}; //! Last extracted word value_type current_word_; std::shared_ptr read_mode_guard_; //! Flag indicating if next word is key (false) or value (true) bool is_next_value_{false}; }; static_assert(std::input_or_output_iterator); explicit Decompressor( std::filesystem::path compressed_path, std::optional compressed_region = {}, CompressionKind compression_kind = CompressionKind::kAll); Decompressor(Decompressor&&) = default; Decompressor& operator=(Decompressor&&) = default; const std::filesystem::path& compressed_path() const { return compressed_path_; } std::string compressed_filename() const { return compressed_path_.filename().string(); } uint64_t words_count() const { return words_count_; } uint64_t empty_words_count() const { return empty_words_count_; } std::filesystem::file_time_type last_write_time() const { return compressed_file_.last_write_time(); } const MemoryMappedFile& memory_file() const { return compressed_file_; } //! Get an iterator to the compressed data Iterator make_iterator() const { return Iterator{this, {}}; } //! Begin reading the words, expected to read in sequential order Iterator begin() const; Iterator end() const { return Iterator::make_end(); } //! \brief Return an iterator at a given \p offset optionally starting with a given \p prefix. //! \param offset the offset in the data to place iterator at. If the offset is invalid, returns end() //! \param prefix the prefix which the result should start with //! \details Makes sure that the result starts with a given prefix, otherwise returns end() Iterator seek(uint64_t offset, ByteView prefix = {}) const; private: void read_patterns(ByteView dict); void read_positions(ByteView dict); //! The path to the compressed file std::filesystem::path compressed_path_; //! The memory-mapped region of the compressed file (if already mapped) std::optional compressed_region_; //! The type of compression for this segment CompressionKind compression_kind_; //! The memory-mapped compressed file MemoryMappedFile compressed_file_; //! The number of words in the data uint64_t words_count_{0}; //! The number of *empty* words in the data uint64_t empty_words_count_{0}; //! The table of patterns used to decode the data words std::unique_ptr pattern_dict_; //! The table of positions used to decode the data words std::unique_ptr position_dict_; //! The start offset of the data words uint8_t* words_start_{nullptr}; //! The size in bytes of the data words uint64_t words_length_{0}; }; } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/seg_zip.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "seg_zip.hpp" #include #include #include #include "compressor.hpp" #include "compressor/raw_words_stream.hpp" #include "decompressor.hpp" namespace silkworm::snapshots::seg { void seg_zip(const std::filesystem::path& path) { RawWordsStream words{path, RawWordsStream::OpenMode::kOpen, 1_Mebi}; auto out_path = path; out_path.replace_extension("seg"); TemporaryDirectory tmp_dir; Compressor compressor{out_path, tmp_dir.path()}; while (auto word = words.read_word()) { compressor.add_word(word->first, word->second); } Compressor::compress(std::move(compressor)); } void seg_unzip(const std::filesystem::path& path) { Decompressor decompressor{path}; auto out_path = path; out_path.replace_extension("idt"); RawWordsStream words{out_path, RawWordsStream::OpenMode::kCreate, 1_Mebi}; for (auto& word : decompressor) { words.write_word(word); } } } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/seg/seg_zip.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::snapshots::seg { void seg_zip(const std::filesystem::path& path); void seg_unzip(const std::filesystem::path& path); } // namespace silkworm::snapshots::seg ================================================ FILE: silkworm/db/datastore/snapshots/segment/segment_reader.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "segment_reader.hpp" #include #include #include namespace silkworm::snapshots::segment { SegmentFileReader::SegmentFileReader( SnapshotPath path, datastore::StepToTimestampConverter step_converter, std::optional segment_region, bool is_compressed) : path_(std::move(path)), step_converter_{std::move(step_converter)}, decompressor_{ path_.path(), segment_region, is_compressed ? seg::CompressionKind::kAll : seg::CompressionKind::kNone, } { } MemoryMappedRegion SegmentFileReader::memory_file_region() const { return decompressor_.memory_file().region(); } SegmentFileReader::Iterator& SegmentFileReader::Iterator::operator++() { bool has_next = it_.has_next(); ++it_; if (has_next) { if (path_) { decoder_->decode_word_with_metadata(*path_, step_converter_); } decoder_->decode_word(*it_); if (path_) { decoder_->check_sanity_with_metadata(*path_, step_converter_); } } else { decoder_.reset(); } return *this; } SegmentFileReader::Iterator& SegmentFileReader::Iterator::operator+=(size_t count) { while ((count > 1) && it_.has_next()) { it_.skip(); --count; } if (count > 0) { ++*this; } return *this; } bool operator==(const SegmentFileReader::Iterator& lhs, const SegmentFileReader::Iterator& rhs) { return (lhs.decoder_ == rhs.decoder_) && (!lhs.decoder_ || (lhs.it_ == rhs.it_)); } SegmentFileReader::Iterator SegmentFileReader::begin(std::shared_ptr decoder) const { auto it = decompressor_.begin(); if (it == decompressor_.end()) { return end(); } decoder->decode_word_with_metadata(path_, step_converter_); decoder->decode_word(*it); decoder->check_sanity_with_metadata(path_, step_converter_); return SegmentFileReader::Iterator{std::move(it), std::move(decoder), path(), step_converter_}; } SegmentFileReader::Iterator SegmentFileReader::end() const { return SegmentFileReader::Iterator{decompressor_.end(), {}, path(), step_converter_}; } SegmentFileReader::Iterator SegmentFileReader::seek( uint64_t offset, std::optional check_prefix, std::shared_ptr decoder) const { auto it = decompressor_.seek(offset, check_prefix.value_or(ByteView{})); if (it == decompressor_.end()) { return end(); } decoder->decode_word_with_metadata(path_, step_converter_); try { decoder->decode_word(*it); } catch (...) { return end(); } decoder->check_sanity_with_metadata(path_, step_converter_); return SegmentFileReader::Iterator{std::move(it), std::move(decoder), path(), step_converter_}; } } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/segment_reader.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../../common/step_timestamp_converter.hpp" #include "../common/codec.hpp" #include "../common/snapshot_path.hpp" #include "../common/util/iterator/iterator_read_into_vector.hpp" #include "seg/decompressor.hpp" namespace silkworm::snapshots::segment { /** * SegmentFileReader is a type-safe wrapper on top of a seg::Decompressor. * * The type-safe mechanism is based on Decoder interface. * SegmentFileReader can be bound with any Decoder. * SegmentFileReader is a template-free counterpart of SegmentReader. * Use a SegmentReader for simple type-safe access to the data. * SegmentFileReader can work with an externally owned MemoryMappedRegion if provided, * otherwise the internal seg::Decompressor owns the memory mapped file. */ class SegmentFileReader { public: class Iterator { public: using value_type = std::shared_ptr; using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; Iterator( seg::Decompressor::Iterator it, std::shared_ptr decoder, SnapshotPath path, datastore::StepToTimestampConverter step_converter) : it_(std::move(it)), decoder_(std::move(decoder)), path_(std::move(path)), step_converter_(std::move(step_converter)) {} Iterator() : it_{seg::Decompressor::Iterator::make_end()}, decoder_{}, path_{std::nullopt}, step_converter_{} {} value_type operator*() const { return decoder_; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++(); Iterator& operator+=(size_t count); friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs); private: seg::Decompressor::Iterator it_; std::shared_ptr decoder_; std::optional path_; datastore::StepToTimestampConverter step_converter_; }; static_assert(std::input_iterator); static_assert(std::sentinel_for); static inline const size_t kPageSize{os::page_size()}; explicit SegmentFileReader( SnapshotPath path, datastore::StepToTimestampConverter step_converter, std::optional segment_region = std::nullopt, bool is_compressed = true); SegmentFileReader(SegmentFileReader&&) = default; SegmentFileReader& operator=(SegmentFileReader&&) = default; const SnapshotPath& path() const { return path_; } const std::filesystem::path& fs_path() const { return path_.path(); } bool empty() const { return item_count() == 0; } size_t item_count() const { return decompressor_.words_count(); } MemoryMappedRegion memory_file_region() const; Iterator begin(std::shared_ptr decoder) const; Iterator end() const; Iterator seek(uint64_t offset, std::optional check_prefix, std::shared_ptr decoder) const; private: //! The path of the segment file for this snapshot SnapshotPath path_; datastore::StepToTimestampConverter step_converter_; seg::Decompressor decompressor_; }; template class SegmentReader { public: class Iterator { public: using value_type = decltype(TDecoder::value); using iterator_category [[maybe_unused]] = std::input_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; explicit Iterator(SegmentFileReader::Iterator it) : it_(std::move(it)) {} Iterator() = default; reference operator*() const { return value(); } pointer operator->() const { return &value(); } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator& operator+=(size_t count) { it_ += count; return *this; } friend bool operator!=(const Iterator& lhs, const Iterator& rhs) = default; friend bool operator==(const Iterator& lhs, const Iterator& rhs) = default; private: value_type& value() const { Decoder& base_decoder = **it_; // dynamic_cast is safe because TDecoder was used when creating the Iterator auto& decoder = dynamic_cast(base_decoder); return decoder.value; } SegmentFileReader::Iterator it_; }; static_assert(std::input_iterator); static_assert(std::sentinel_for); using DecoderType = TDecoder; explicit SegmentReader(const SegmentFileReader& reader) : reader_{&reader} {} Iterator begin() const { return Iterator{reader_->begin(std::make_shared())}; } Iterator end() const { return Iterator{reader_->end()}; } Iterator seek(uint64_t offset, std::optional check_prefix = std::nullopt) const { return Iterator{reader_->seek(offset, check_prefix, std::make_shared())}; } std::optional seek_one(uint64_t offset, std::optional check_prefix = std::nullopt) const { auto it = seek(offset, check_prefix); return (it != end()) ? std::optional{std::move(*it)} : std::nullopt; } std::vector read_into_vector(uint64_t offset, size_t count) const { auto it = seek(offset); if (it == end()) { throw std::runtime_error("SegmentReader::read_into_vector: bad offset " + std::to_string(offset)); } return iterator_read_into_vector(std::move(it), count); } const SnapshotPath& path() const { return reader_->path(); } private: const SegmentFileReader* reader_; }; template concept SegmentReaderConcept = std::same_as> || std::derived_from>; } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/segment_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include "../test_util/string_codec.hpp" #include "segment_reader.hpp" #include "segment_writer.hpp" namespace silkworm::snapshots::segment { static_assert(std::ranges::input_range>); static_assert(std::movable>); TEST_CASE("SegmentFile") { using namespace datastore; TemporaryDirectory tmp_dir; auto path = SnapshotPath::make(tmp_dir.path(), std::nullopt, SnapshotPath::FilenameFormat::kE2, kSnapshotV1, StepRange{Step{0}, Step{1}}, "headers", ".seg"); std::vector items = { "first", "second", "third", }; SegmentFileWriter file_writer{path, tmp_dir.path()}; SegmentWriter writer{file_writer}; auto out = writer.out(); for (auto& item : items) { *out++ = item; } SegmentFileWriter::flush(std::move(file_writer)); SegmentFileReader file_reader{path, {}}; SegmentReader reader{file_reader}; for (std::string& item : reader) { CHECK(item == items[0]); items.erase(items.begin()); } CHECK(items.empty()); } } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/segment_writer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "segment_writer.hpp" namespace silkworm::snapshots::segment { SegmentFileWriter::SegmentFileWriter( SnapshotPath path, const std::filesystem::path& tmp_dir_path, bool is_compressed) : path_{std::move(path)}, compressor_{ path_.path(), tmp_dir_path, is_compressed ? seg::CompressionKind::kAll : seg::CompressionKind::kNone, } {} SegmentFileWriter::Iterator& SegmentFileWriter::Iterator::operator=(const SegmentFileWriter::Iterator::value_type& value) { *it_ = value->encode_word(); return *this; } SegmentFileWriter::Iterator SegmentFileWriter::out(std::shared_ptr encoder) { return SegmentFileWriter::Iterator{compressor_.add_word_iterator(), std::move(encoder)}; } void SegmentFileWriter::flush(SegmentFileWriter writer) { seg::Compressor::compress(std::move(writer.compressor_)); } } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment/segment_writer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "../common/codec.hpp" #include "../common/snapshot_path.hpp" #include "seg/compressor.hpp" namespace silkworm::snapshots::segment { class SegmentFileWriter { public: class Iterator { public: using value_type = std::shared_ptr; using iterator_category [[maybe_unused]] = std::output_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = void; using reference = void; Iterator( seg::Compressor::Iterator it, std::shared_ptr encoder) : it_(it), encoder_(std::move(encoder)) {} Iterator& operator*() { return *this; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator& operator=(const value_type& value); std::shared_ptr encoder() const { return encoder_; } private: seg::Compressor::Iterator it_; std::shared_ptr encoder_; }; static_assert(std::output_iterator); explicit SegmentFileWriter( SnapshotPath path, const std::filesystem::path& tmp_dir_path, bool is_compressed = true); SegmentFileWriter(SegmentFileWriter&&) = default; SegmentFileWriter& operator=(SegmentFileWriter&&) = default; SnapshotPath path() const { return path_; } Iterator out(std::shared_ptr encoder); static void flush(SegmentFileWriter writer); private: SnapshotPath path_; seg::Compressor compressor_; }; template class SegmentWriter { public: class Iterator { public: using value_type = decltype(TEncoder::value); using iterator_category [[maybe_unused]] = std::output_iterator_tag; using difference_type = std::ptrdiff_t; using pointer = void; using reference = void; explicit Iterator(SegmentFileWriter::Iterator it) : it_(std::move(it)) {} Iterator& operator*() { return *this; } Iterator operator++(int) { return std::exchange(*this, ++Iterator{*this}); } Iterator& operator++() { ++it_; return *this; } Iterator& operator=(value_type value) { *it_ = set_value(std::move(value)); return *this; } private: SegmentFileWriter::Iterator::value_type set_value(value_type value) { Encoder& base_encoder = *it_.encoder(); // dynamic_cast is safe because TEncoder was used when creating the Iterator auto& encoder = dynamic_cast(base_encoder); encoder.value = std::move(value); return it_.encoder(); } SegmentFileWriter::Iterator it_; }; static_assert(std::output_iterator); using EncoderType = TEncoder; explicit SegmentWriter(SegmentFileWriter& writer) : writer_(writer) {} Iterator out() { return Iterator{writer_.out(std::make_shared())}; } private: SegmentFileWriter& writer_; }; template concept SegmentWriterConcept = std::same_as> || std::derived_from>; } // namespace silkworm::snapshots::segment ================================================ FILE: silkworm/db/datastore/snapshots/segment_and_accessor_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../common/entity_name.hpp" #include "rec_split/accessor_index.hpp" #include "segment/segment_reader.hpp" namespace silkworm::snapshots { struct SegmentAndAccessorIndex { const segment::SegmentFileReader& segment; const rec_split::AccessorIndex& index; }; using SegmentAndAccessorIndexNames = std::array; struct SegmentAndAccessorIndexProvider { virtual ~SegmentAndAccessorIndexProvider() = default; virtual SegmentAndAccessorIndex segment_and_accessor_index( const SegmentAndAccessorIndexNames& names) const = 0; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/snapshot_bundle.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_bundle.hpp" #include namespace silkworm::snapshots { using namespace rec_split; using namespace segment; using namespace datastore; static datastore::EntityMap make_snapshot_paths( Schema::SnapshotFileDef::Format format, const Schema::EntityDef& entity, const std::filesystem::path& dir_path, StepRange range) { datastore::EntityMap results; for (auto& [name, def] : entity.files()) { if (def->format() == format) { auto path = def->make_path(dir_path, range); results.emplace(name, std::move(path)); } } return results; } static datastore::EntityMap open_segments( const Schema::EntityDef& entity, const std::filesystem::path& dir_path, StepRange range, datastore::StepToTimestampConverter step_converter) { datastore::EntityMap results; for (auto& [name, anyDef] : entity.files()) { if (anyDef->format() != Schema::SnapshotFileDef::Format::kSegment) continue; auto& def = dynamic_cast(*anyDef); auto path = def.make_path(dir_path, range); results.emplace(name, SegmentFileReader{std::move(path), step_converter, std::nullopt, def.compression_enabled()}); } return results; } static datastore::EntityMap open_kv_segments( const Schema::EntityDef& entity, const std::filesystem::path& dir_path, StepRange range, datastore::StepToTimestampConverter step_converter) { datastore::EntityMap results; for (auto& [name, anyDef] : entity.files()) { if (anyDef->format() != Schema::SnapshotFileDef::Format::kKVSegment) continue; auto& def = dynamic_cast(*anyDef); auto path = def.make_path(dir_path, range); results.emplace(name, KVSegmentFileReader{std::move(path), step_converter, def.compression_kind()}); } return results; } static datastore::EntityMap open_accessor_indexes( const Schema::EntityDef& entity, const std::filesystem::path& dir_path, StepRange range) { datastore::EntityMap results; for (auto& [name, path] : make_snapshot_paths(Schema::SnapshotFileDef::Format::kAccessorIndex, entity, dir_path, range)) { results.emplace(name, AccessorIndex{path}); } return results; } static datastore::EntityMap open_existence_indexes( const Schema::EntityDef& entity, const std::filesystem::path& dir_path, StepRange range, std::optional salt) { datastore::EntityMap results; for (auto& [name, path] : make_snapshot_paths(Schema::SnapshotFileDef::Format::kExistenceIndex, entity, dir_path, range)) { SILK_TRACE << "make_existence_indexes opens " << name.to_string() << " at " << path.filename(); SILKWORM_ASSERT(salt); results.emplace(name, bloom_filter::BloomFilter{path.path(), KeyHasher{*salt}}); } return results; } static datastore::EntityMap open_btree_indexes( const Schema::EntityDef& entity, const std::filesystem::path& dir_path, StepRange range) { datastore::EntityMap results; for (auto& [name, path] : make_snapshot_paths(Schema::SnapshotFileDef::Format::kBTreeIndex, entity, dir_path, range)) { SILK_TRACE << "make_btree_indexes opens " << name.to_string() << " at " << path.filename(); results.emplace(name, btree::BTreeIndex{path.path()}); } return results; } SnapshotBundleData open_bundle_data( const Schema::RepositoryDef& schema, const std::filesystem::path& dir_path, StepRange step_range, std::optional index_salt) { SnapshotBundleData data; StepToTimestampConverter step_converter = schema.make_step_converter(); for (auto& [name, entity_schema_ptr] : schema.entities()) { auto& entity_schema = *entity_schema_ptr; data.entities.emplace( name, SnapshotBundleEntityData{ open_segments(entity_schema, dir_path, step_range, step_converter), open_kv_segments(entity_schema, dir_path, step_range, step_converter), open_accessor_indexes(entity_schema, dir_path, step_range), open_existence_indexes(entity_schema, dir_path, step_range, index_salt), open_btree_indexes(entity_schema, dir_path, step_range), }); } return data; } SnapshotBundle::~SnapshotBundle() { close(); } void SnapshotBundle::close() { auto files = this->files(); data_.entities.clear(); auto on_close_callback = std::exchange(on_close_callback_, {}); if (on_close_callback) { on_close_callback(std::move(files)); } } const SegmentFileReader& SnapshotBundle::segment( datastore::EntityName entity_name, datastore::EntityName segment_name) const { return data_.entities.at(entity_name).segments.at(segment_name); } const AccessorIndex& SnapshotBundle::accessor_index( datastore::EntityName entity_name, datastore::EntityName index_name) const { return data_.entities.at(entity_name).accessor_indexes.at(index_name); } Domain SnapshotBundle::domain(datastore::EntityName name) const { auto& data = data_.entities.at(name); Domain domain{ data.kv_segments.at(Schema::kDomainKVSegmentName), nullptr, data.existence_indexes.at(Schema::kDomainExistenceIndexName), data.btree_indexes.at(Schema::kDomainBTreeIndexName), }; if (data.accessor_indexes.contains(Schema::kDomainAccessorIndexName)) { domain.accessor_index = &data.accessor_indexes.at(Schema::kDomainAccessorIndexName); } return domain; } History SnapshotBundle::history(datastore::EntityName name) const { auto& data = data_.entities.at(name); return History{ data.segments.at(Schema::kHistorySegmentName), data.accessor_indexes.at(Schema::kHistoryAccessorIndexName), inverted_index(name), }; } InvertedIndex SnapshotBundle::inverted_index(datastore::EntityName name) const { auto& data = data_.entities.at(name); return InvertedIndex{ data.kv_segments.at(Schema::kInvIdxKVSegmentName), data.accessor_indexes.at(Schema::kInvIdxAccessorIndexName), }; } std::vector SnapshotBundle::files() const { std::vector files; for (auto& entity_entry : data_.entities) { auto& data = entity_entry.second; for (const auto& file : make_map_values_view(data.segments)) files.push_back(file.fs_path()); for (const auto& file : make_map_values_view(data.kv_segments)) files.push_back(file.fs_path()); for (const auto& file : make_map_values_view(data.accessor_indexes)) files.push_back(file.fs_path()); for (const auto& file : make_map_values_view(data.existence_indexes)) files.push_back(file.path()); for (const auto& file : make_map_values_view(data.btree_indexes)) files.push_back(file.path()); } return files; } std::vector SnapshotBundle::segment_paths() const { std::vector paths; for (const SegmentFileReader& segment : segments()) { paths.push_back(segment.path()); } return paths; } datastore::EntityMap SnapshotBundlePaths::segment_paths() const { auto& entity = *schema_.entities().at(Schema::kDefaultEntityName); return make_snapshot_paths(Schema::SnapshotFileDef::Format::kSegment, entity, dir_path_, step_range_); } datastore::EntityMap SnapshotBundlePaths::accessor_index_paths() const { auto& entity = *schema_.entities().at(Schema::kDefaultEntityName); return make_snapshot_paths(Schema::SnapshotFileDef::Format::kAccessorIndex, entity, dir_path_, step_range_); } std::vector SnapshotBundlePaths::files() const { std::vector results; for (auto& entity_entry : schema_.entities()) { for (auto& file_entry : entity_entry.second->files()) { auto path = file_entry.second->make_path(dir_path_, step_range_); results.push_back(path.path()); } } return results; } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/snapshot_bundle.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "bloom_filter/bloom_filter.hpp" #include "btree/btree_index.hpp" #include "common/snapshot_path.hpp" #include "common/util/iterator/map_values_view.hpp" #include "domain.hpp" #include "history.hpp" #include "inverted_index.hpp" #include "rec_split/accessor_index.hpp" #include "schema.hpp" #include "segment/kv_segment_reader.hpp" #include "segment/segment_reader.hpp" #include "segment_and_accessor_index.hpp" namespace silkworm::snapshots { struct SnapshotBundleEntityData { datastore::EntityMap segments; datastore::EntityMap kv_segments; datastore::EntityMap accessor_indexes; datastore::EntityMap existence_indexes; datastore::EntityMap btree_indexes; }; struct SnapshotBundleData { datastore::EntityMap entities; }; SnapshotBundleData open_bundle_data( const Schema::RepositoryDef& schema, const std::filesystem::path& dir_path, datastore::StepRange step_range, std::optional index_salt); struct SnapshotBundlePaths { using StepRange = datastore::StepRange; SnapshotBundlePaths( Schema::RepositoryDef schema, std::filesystem::path dir_path, StepRange step_range) : schema_{std::move(schema)}, dir_path_{std::move(dir_path)}, step_range_{step_range} {} StepRange step_range() const { return step_range_; } std::vector files() const; datastore::EntityMap segment_paths() const; datastore::EntityMap accessor_index_paths() const; private: Schema::RepositoryDef schema_; std::filesystem::path dir_path_; StepRange step_range_; }; struct SnapshotBundle : public SegmentAndAccessorIndexProvider { using StepRange = datastore::StepRange; SnapshotBundle(StepRange step_range, SnapshotBundleData data) : step_range_{step_range}, data_{std::move(data)} { } SnapshotBundle( const Schema::RepositoryDef& schema, const std::filesystem::path& dir_path, StepRange range, std::optional index_salt) : SnapshotBundle{ range, open_bundle_data(schema, dir_path, range, index_salt), } {} ~SnapshotBundle() override; SnapshotBundle(SnapshotBundle&&) = default; SnapshotBundle& operator=(SnapshotBundle&&) noexcept = default; auto segments() const { return make_map_values_view(data_.entities.at(Schema::kDefaultEntityName).segments); } const segment::SegmentFileReader& segment( datastore::EntityName entity_name, datastore::EntityName segment_name) const; const rec_split::AccessorIndex& accessor_index( datastore::EntityName entity_name, datastore::EntityName index_name) const; SegmentAndAccessorIndex segment_and_accessor_index( const SegmentAndAccessorIndexNames& names) const override { return { segment(names[0], names[1]), accessor_index(names[0], names[2]), }; } Domain domain(datastore::EntityName name) const; History history(datastore::EntityName name) const; InvertedIndex inverted_index(datastore::EntityName name) const; StepRange step_range() const { return step_range_; } std::vector files() const; std::vector segment_paths() const; void on_close(std::function files)> callback) { on_close_callback_ = std::move(callback); } const SnapshotBundleData& operator*() const { return data_; } const SnapshotBundleData* operator->() const { return &data_; } private: void close(); StepRange step_range_; SnapshotBundleData data_; std::function files)> on_close_callback_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/snapshot_repository.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_repository.hpp" #include #include #include #include #include #include #include #include "index_builders_factory.hpp" #include "index_salt_file.hpp" namespace silkworm::snapshots { namespace fs = std::filesystem; using namespace datastore; SnapshotRepository::SnapshotRepository( datastore::EntityName name, std::filesystem::path dir_path, bool open, Schema::RepositoryDef schema, std::optional index_salt, std::unique_ptr index_builders_factory) : name_(std::move(name)), dir_path_(std::move(dir_path)), schema_(std::move(schema)), step_converter_{schema_.make_step_converter()}, index_salt_(index_salt), index_builders_factory_(std::move(index_builders_factory)), bundles_(std::make_shared()), bundles_mutex_(std::make_unique()) { if (open) reopen_folder(); } void SnapshotRepository::add_snapshot_bundle(SnapshotBundle bundle) { replace_snapshot_bundles(std::move(bundle)); } void SnapshotRepository::replace_snapshot_bundles(SnapshotBundle bundle) { std::scoped_lock lock(*bundles_mutex_); // copy bundles prior to modification auto bundles = std::make_shared(*bundles_); std::erase_if(*bundles, [&](const auto& entry) { const SnapshotBundle& it = *entry.second; return bundle.step_range().contains_range(it.step_range()); }); Step key = bundle.step_range().start; bundles->insert_or_assign(key, std::make_shared(std::move(bundle))); bundles_ = bundles; } size_t SnapshotRepository::bundles_count() const { std::scoped_lock lock(*bundles_mutex_); return bundles_->size(); } Timestamp SnapshotRepository::max_timestamp_available() const { Step end_step = max_end_step(); if (end_step.value == 0) return 0; return step_converter_.timestamp_from_step(end_step) - 1; } Step SnapshotRepository::max_end_step() const { std::scoped_lock lock(*bundles_mutex_); if (bundles_->empty()) return Step{0}; // a bundle with the max block range is last in the sorted bundles map auto& bundle = *bundles_->rbegin()->second; return bundle.step_range().end; } std::pair, std::shared_ptr> SnapshotRepository::find_segment( const SegmentAndAccessorIndexNames& names, Timestamp t) const { auto bundle = find_bundle(t); if (bundle) { return {bundle->segment_and_accessor_index(names), bundle}; } return {std::nullopt, {}}; } std::vector> SnapshotRepository::missing_indexes() const { // TODO: reimplement for state repository SnapshotBundlePaths some_bundle_paths{schema_, path(), {Step{0}, Step{1}}}; auto segment_file_ext = some_bundle_paths.segment_paths().begin()->second.extension(); SnapshotPathList segment_files = get_files(segment_file_ext); auto index_builders = index_builders_factory_->index_builders(segment_files); std::erase_if(index_builders, [&](const auto& builder) { return builder->path().exists(); }); return index_builders; } void SnapshotRepository::reopen_folder() { SILK_INFO << "Reopen " << name_.to_string() << " snapshot repository folder: " << dir_path_.string(); index_salt_ = load_index_salt(); auto file_ranges = list_dir_file_ranges(); if (file_ranges.empty()) return; ThreadPool worker_pool; std::unique_lock lock(*bundles_mutex_); std::vector>> future_complete_bundles; for (const auto& range : file_ranges) { if (range.size() == 0) continue; SnapshotBundlePaths bundle_paths{schema_, dir_path_, range}; // Open iff all bundle paths exist if (std::ranges::all_of(bundle_paths.files(), [](const fs::path& p) { return fs::exists(p); })) { // Schedule each bundle opening on worker pool collecting its future result for completion handling future_complete_bundles.emplace_back(worker_pool.submit([&, range]() -> std::shared_ptr { return std::make_shared(schema_, dir_path_, range, index_salt_); })); } } for (auto& future_bundle_ptr : future_complete_bundles) { std::shared_ptr bundle_ptr = future_bundle_ptr.get(); const auto step_range = bundle_ptr->step_range(); bundles_->insert_or_assign(step_range.start, std::move(bundle_ptr)); } #ifndef NDEBUG // Sanity check: no gap must exist in bundles if (!bundles_->empty()) { Step max_end = bundles_->cbegin()->second->step_range().start; for (const auto& b : *bundles_) { SILKWORM_ASSERT(b.second->step_range().start == max_end); max_end = b.second->step_range().end; } } #endif // NDEBUG lock.unlock(); SILK_INFO << "Total reopened " << name_.to_string() << " snapshot repository bundles: " << bundles_count() << " max available: " + std::to_string(max_timestamp_available()); } SnapshotBundle SnapshotRepository::open_bundle(StepRange range) const { return SnapshotBundle{schema_, dir_path_, range, index_salt_}; } std::shared_ptr SnapshotRepository::find_bundle(Timestamp t) const { return find_bundle(step_converter_.step_from_timestamp(t)); } std::shared_ptr SnapshotRepository::find_bundle(Step step) const { // Search for target segment in reverse order (from the newest segment to the oldest one) for (const auto& bundle_ptr : this->view_bundles_reverse()) { auto& bundle = *bundle_ptr; if (bundle.step_range().contains(step) || ((bundle.step_range().start == step) && (bundle.step_range().size() == 0))) { return bundle_ptr; } } return {}; } std::vector> SnapshotRepository::bundles_in_range(StepRange range) const { std::vector> bundles; for (const auto& bundle : view_bundles()) { if (range.contains_range(bundle->step_range())) { bundles.push_back(bundle); } } return bundles; } std::vector> SnapshotRepository::bundles_intersecting_range(StepRange range, bool ascending) const { if (range.size() == 0) { return {}; } std::vector> bundles; for (const auto& bundle : view_bundles()) { StepRange bundle_range = bundle->step_range(); if (range.contains_range(bundle_range) || bundle_range.contains(range.start) || bundle_range.contains(Step{range.end.value - 1})) { bundles.push_back(bundle); } } if (!ascending) { std::ranges::reverse(bundles); } return bundles; } std::vector> SnapshotRepository::bundles_intersecting_range(TimestampRange range, bool ascending) const { if (range.size() == 0) { return {}; } return bundles_intersecting_range(step_converter_.step_range_from_timestamp_range(range), ascending); } SnapshotPathList SnapshotRepository::get_files(std::string_view ext) const { ensure(fs::exists(dir_path_), [&]() { return "SnapshotRepository: " + dir_path_.string() + " does not exist"; }); ensure(fs::is_directory(dir_path_), [&]() { return "SnapshotRepository: " + dir_path_.string() + " is a not folder"; }); // Load the resulting files w/ desired extension ensuring they are snapshots SnapshotPathList snapshot_files; for (const auto& file : fs::directory_iterator{dir_path_}) { if (!fs::is_regular_file(file.path()) || file.path().extension().string() != ext) { continue; } SILK_TRACE << "Path: " << file.path() << " name: " << file.path().filename(); const auto snapshot_file = SnapshotPath::parse(file); if (snapshot_file) { snapshot_files.push_back(snapshot_file.value()); } else { SILK_TRACE << "unexpected format for file: " << file.path().filename() << ", skipped"; } } // Order snapshot files by version/block-range/type std::ranges::sort(snapshot_files, std::less{}); return snapshot_files; } // Define the datastore::StepRange ordering semantics necessary for SnapshotRepository::list_dir_file_ranges bool SnapshotRepository::StepRangeCompare::operator()(const StepRange& lhs, const StepRange& rhs) const { if (lhs.start != rhs.start) { return lhs.start < rhs.start; } return lhs.size() < rhs.size(); } SnapshotRepository::StepRangeSet SnapshotRepository::list_dir_file_ranges() const { ensure(fs::exists(dir_path_), [&]() { return "SnapshotRepository: " + dir_path_.string() + " does not exist"; }); ensure(fs::is_directory(dir_path_), [&]() { return "SnapshotRepository: " + dir_path_.string() + " is a not folder"; }); auto supported_file_extensions = schema_.file_extensions(); if (supported_file_extensions.empty()) return {}; StepRangeSet results; for (const auto& file : fs::recursive_directory_iterator{dir_path_}) { if (!fs::is_regular_file(file.path())) { continue; } if (std::ranges::find(supported_file_extensions, file.path().extension().string()) == supported_file_extensions.end()) { continue; } const auto path = SnapshotPath::parse(file.path(), dir_path_); if (path) { results.insert(path->step_range()); } } return results; } bool SnapshotRepository::is_stale_index_path(const SnapshotPath& index_path) const { return std::ranges::any_of( index_builders_factory_->index_dependency_paths(index_path), [&](const SnapshotPath& dep_path) { return fs::last_write_time(index_path.path()) < fs::last_write_time(dep_path.path()); }); } SnapshotPathList SnapshotRepository::stale_index_paths() const { SnapshotPathList results; // TODO: reimplement for state repository SnapshotBundlePaths some_bundle_paths{schema_, path(), {Step{0}, Step{1}}}; auto accessor_index_file_ext = some_bundle_paths.accessor_index_paths().begin()->second.extension(); auto all_files = get_files(accessor_index_file_ext); std::ranges::copy_if( all_files, std::back_inserter(results), [this](const SnapshotPath& index_path) { return this->is_stale_index_path(index_path); }); return results; } void SnapshotRepository::remove_stale_indexes() const { for (auto& path : stale_index_paths()) { const bool removed = fs::remove(path.path()); ensure(removed, [&]() { return "SnapshotRepository::remove_stale_indexes: cannot remove index file " + path.path().string(); }); } } std::optional SnapshotRepository::load_index_salt() const { IndexSaltFile file{this->dir_path_ / schema_.index_salt_file_name()}; return file.exists() ? file.load() : std::optional{}; } void SnapshotRepository::build_indexes(const SnapshotBundlePaths& bundle) const { std::vector segment_paths; for (auto& entry : bundle.segment_paths()) segment_paths.push_back(std::move(entry.second)); for (auto& builder : index_builders_factory_->index_builders(segment_paths)) { builder->build(); } } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/snapshot_repository.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include "../common/entity_name.hpp" #include "../common/step_timestamp_converter.hpp" #include "common/snapshot_path.hpp" #include "segment_and_accessor_index.hpp" #include "snapshot_bundle.hpp" #include "snapshot_repository_ro_access.hpp" namespace silkworm::snapshots { struct IndexBuilder; struct IndexBuildersFactory; //! Read-only repository for all snapshot files. //! @details Some simplifications are currently in place: //! - all snapshots of given blocks range must exist (to make such range available) //! - gaps in blocks range are not allowed //! - segments have [from:to) semantic class SnapshotRepository : public SnapshotRepositoryROAccess { public: using Timestamp = datastore::Timestamp; using Step = datastore::Step; using StepRange = datastore::StepRange; SnapshotRepository( datastore::EntityName name, std::filesystem::path dir_path, bool open, Schema::RepositoryDef schema, std::optional index_salt, std::unique_ptr index_builders_factory); SnapshotRepository(SnapshotRepository&&) = default; SnapshotRepository& operator=(SnapshotRepository&&) noexcept = delete; ~SnapshotRepository() override = default; const std::filesystem::path& path() const { return dir_path_; } const Schema::RepositoryDef& schema() const { return schema_; } const datastore::StepToTimestampConverter& step_converter() const { return step_converter_; } void reopen_folder(); //! Opens a detached bundle of snapshot files. Use add_snapshot_bundle or replace_snapshot_bundles to add it. SnapshotBundle open_bundle(StepRange range) const; void add_snapshot_bundle(SnapshotBundle bundle); //! Replace bundles whose ranges are contained within the given bundle void replace_snapshot_bundles(SnapshotBundle bundle); size_t bundles_count() const override; Timestamp max_timestamp_available() const override; std::vector> missing_indexes() const; void remove_stale_indexes() const; const std::optional& index_salt() const { return index_salt_; } void build_indexes(const SnapshotBundlePaths& bundle) const; BundlesView> view_bundles() const override { std::scoped_lock lock(*bundles_mutex_); return BundlesView{make_map_values_view(*bundles_), bundles_}; } BundlesView> view_bundles_reverse() const override { std::scoped_lock lock(*bundles_mutex_); return BundlesView{std::ranges::reverse_view(make_map_values_view(*bundles_)), bundles_}; } std::pair, std::shared_ptr> find_segment( const SegmentAndAccessorIndexNames& names, Timestamp t) const override; std::shared_ptr find_bundle(Timestamp t) const override; std::shared_ptr find_bundle(Step step) const override; std::vector> bundles_in_range(StepRange range) const override; std::vector> bundles_intersecting_range(StepRange range, bool ascending) const override; std::vector> bundles_intersecting_range(TimestampRange range, bool ascending) const override; private: Step max_end_step() const; SnapshotPathList get_files(std::string_view ext) const; struct StepRangeCompare { inline bool operator()(const StepRange& lhs, const StepRange& rhs) const; }; using StepRangeSet = std::set; StepRangeSet list_dir_file_ranges() const; bool is_stale_index_path(const SnapshotPath& index_path) const; SnapshotPathList stale_index_paths() const; std::optional load_index_salt() const; //! The repository entity name datastore::EntityName name_; //! Path to the snapshots directory std::filesystem::path dir_path_; //! Schema Schema::RepositoryDef schema_; //! Converts timestamp units to steps datastore::StepToTimestampConverter step_converter_; //! Index salt std::optional index_salt_; //! Creates index builders std::unique_ptr index_builders_factory_; //! Full snapshot bundles ordered by block_from std::shared_ptr bundles_; std::unique_ptr bundles_mutex_; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/snapshot_repository_ro_access.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "../common/entity_name.hpp" #include "../common/step.hpp" #include "../common/timestamp.hpp" #include "common/util/iterator/map_values_view.hpp" #include "segment_and_accessor_index.hpp" namespace silkworm::snapshots { struct SnapshotBundle; struct SnapshotRepositoryROAccess { using Timestamp = datastore::Timestamp; using TimestampRange = datastore::TimestampRange; using Step = datastore::Step; using StepRange = datastore::StepRange; using Bundles = std::map>; template class BundlesView : public std::ranges::view_interface> { public: BundlesView( TBaseView base_view, std::shared_ptr bundles) : base_view_(std::move(base_view)), bundles_(std::move(bundles)) {} auto begin() const { return base_view_.begin(); } auto end() const { return base_view_.end(); } private: TBaseView base_view_; std::shared_ptr bundles_{}; }; virtual ~SnapshotRepositoryROAccess() = default; virtual size_t bundles_count() const = 0; //! All types of .seg and .idx files are available up to this timestamp virtual Timestamp max_timestamp_available() const = 0; virtual BundlesView> view_bundles() const = 0; virtual BundlesView> view_bundles_reverse() const = 0; virtual std::pair, std::shared_ptr> find_segment( const SegmentAndAccessorIndexNames& names, Timestamp t) const = 0; virtual std::shared_ptr find_bundle(Timestamp t) const = 0; virtual std::shared_ptr find_bundle(Step step) const = 0; //! Bundles fully contained within a given range: range_start <= first_start < last_end <= range_end virtual std::vector> bundles_in_range(StepRange range) const = 0; //! Bundles having some steps within a given range: first_start <= range_start < range_end <= last_end virtual std::vector> bundles_intersecting_range(StepRange range, bool ascending) const = 0; //! Bundles having some timestamps within a given range virtual std::vector> bundles_intersecting_range(TimestampRange range, bool ascending) const = 0; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/snapshot_settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "bittorrent/settings.hpp" namespace silkworm::snapshots { struct SnapshotSettings { std::filesystem::path repository_path{DataDirectory{}.snapshots().path()}; bool enabled{true}; bool no_downloader{false}; bittorrent::BitTorrentSettings bittorrent_settings; // Keep collated data in mdbx bool keep_blocks{false}; // Stop producing new snapshots bool stop_freezer{false}; bool verify_on_startup{false}; bool no_seeding{false}; }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/snapshot_size.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::snapshots { inline constexpr size_t kMaxMergerSnapshotSize = 100'000; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/snapshots/test_util/sample_bloom_filter_data.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::snapshots::test_util { // Legend: MH = magic header, K = key count, N = inserted count, M = bits count inline const std::vector> kInvalidBloomFilters{ {"", "empty"}, {"0000000000000000763032", "MH too short"}, {"00000000000000007630320c", "invalid MH"}, {"00000000000000007630320a", "valid MH but nothing else"}, {"00000000000000007630320a11", "K too short"}, {"00000000000000007630320a0000000000000003", "invalid K"}, {"00000000000000007630320a0300000000000000", "valid MH+K but nothing else"}, {"00000000000000007630320a0300000000000000FF", "invalid N"}, {"00000000000000007630320a030000000000000001000000000000", "valid MH+K+N but nothing else"}, {"00000000000000007630320a030000000000000001000000000000000100000000000000", "invalid M"}, {"00000000000000007630320a030000000000000001000000000000000200000000000000", "valid MH+K+N+M but nothing else"}, {"00000000000000007630320a030000000000000001000000000000000200000000000000" "1F000000000000002F000000000000003F000000000000", "invalid keys"}, {"00000000000000007630320a030000000000000001000000000000000200000000000000" "1F000000000000002F000000000000003F00000000000000", "valid MH+K+N+M+keys but nothing else"}, {"00000000000000007630320a030000000000000001000000000000000200000000000000" "1F000000000000002F000000000000003F00000000000000" "AA0000000000000000", "too few bits"}, {"00000000000000007630320a030000000000000001000000000000000200000000000000" "1F000000000000002F000000000000003F00000000000000" "AA0000000000000000AA0000000000000000AA0000000000000000", "too many bits"}, {"00000000000000007630320a030000000000000001000000000000000200000000000000" "1F000000000000002F000000000000003F00000000000000" "AA00000000000000", "valid MH+K+N+M+keys+bits but nothing else"}, {"00000000000000007630320a030000000000000001000000000000000200000000000000" "1F000000000000002F000000000000003F00000000000000" "AA00000000000000" "110000000000000022000000000000003300000000000000" "440000000000000055000000000000006600000000000000", "invalid hash checksum"}, }; inline const std::vector kValidBloomFilters{ "00000000000000007630320a030000000000000001000000000000000200000000000000" "1F000000000000002F000000000000003F00000000000000" "AA00000000000000" "40c49f795f823d0f20891491ad866e99e3317f5e3876339a5ec76a70b966fe1645f70a67ef21a1243513b7a3f6b1beb4", }; } // namespace silkworm::snapshots::test_util ================================================ FILE: silkworm/db/datastore/snapshots/test_util/string_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../common/codec.hpp" namespace silkworm::snapshots { struct StringCodec : public Codec { std::string value; Bytes word; ~StringCodec() override = default; ByteView encode_word() override { word = string_to_bytes(value); return word; } void decode_word(Word& input_word) override { if (input_word.holds_bytes()) { value = bytes_to_string(std::move(std::get(input_word))); } else { value = byte_view_to_string_view(std::get(input_word)); } } }; } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/datastore/stage_scheduler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "kvdb/mdbx.hpp" namespace silkworm::datastore { struct StageScheduler { virtual ~StageScheduler() = default; //! Schedule a callback to run inside the stage loop. virtual Task schedule(std::function callback) = 0; }; } // namespace silkworm::datastore ================================================ FILE: silkworm/db/db_utils.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "db_utils.hpp" #include #include #include namespace silkworm::db { // Return (block-num, hash) of the header with the biggest total difficulty skipping bad headers // see Erigon's HeadersUnwind method for the implementation std::tuple header_with_biggest_td(datastore::kvdb::ROTxn& txn, const std::set* bad_headers) { BlockNum max_block_num = 0; Hash max_hash; intx::uint256 max_td = 0; auto td_cursor = txn.ro_cursor(db::table::kDifficulty); auto find_max = [bad_headers, &max_block_num, &max_hash, &max_td](ByteView key, ByteView value) { SILKWORM_ASSERT(key.size() == sizeof(BlockNum) + kHashLength); Hash hash{key.substr(sizeof(BlockNum))}; ByteView block_num = key.substr(0, sizeof(BlockNum)); if (bad_headers && bad_headers->contains(hash)) { return; } intx::uint256 td = 0; success_or_throw(rlp::decode(value, td)); if (td > max_td) { max_td = td; max_hash = hash; max_block_num = endian::load_big_u64(block_num.data()); } // TODO: check if we really need to parse all the table }; datastore::kvdb::cursor_for_each(*td_cursor, find_max, datastore::kvdb::CursorMoveDirection::kReverse); return {max_block_num, max_hash}; } } // namespace silkworm::db ================================================ FILE: silkworm/db/db_utils.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::db { //! \brief Return (block-num, hash) of the header with the biggest total difficulty skipping bad headers std::tuple header_with_biggest_td(datastore::kvdb::ROTxn& txn, const std::set* bad_headers = nullptr); } // namespace silkworm::db ================================================ FILE: silkworm/db/db_utils_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "db_utils.hpp" #include #include #include #include #include namespace silkworm::db { using namespace silkworm::datastore::kvdb; TEST_CASE("db access layer addendum") { TemporaryDirectory tmp_dir; EnvConfig db_config{.path = tmp_dir.path().string(), .create = true, .in_memory = true}; auto env = open_env(db_config); RWAccess rw_access{env}; RWTxnManaged tx = rw_access.start_rw_tx(); table::check_or_create_chaindata_tables(tx); uint64_t block_num{11'054'435}; BlockHeader header; header.number = block_num; header.beneficiary = 0x09ab1303d3ccaf5f018cd511146b07a240c70294_address; header.gas_limit = 12'451'080; header.gas_used = 12'443'619; SECTION("read/write header") { CHECK_NOTHROW(write_header(tx, header, false)); auto read_header = db::read_header(tx, header.number, header.hash()); REQUIRE(read_header != std::nullopt); // Warning: this is a limited test, we only test that REQUIRE(read_header->number == header.number); // read and write are implemented in a symmetric way REQUIRE(read_header->beneficiary == header.beneficiary); REQUIRE(read_header->gas_limit == header.gas_limit); REQUIRE(read_header->gas_used == header.gas_used); } SECTION("read/write head header") { auto hash = header.hash(); CHECK_NOTHROW(write_head_header_hash(tx, hash)); auto read_hash = read_head_header_hash(tx); REQUIRE(read_hash != std::nullopt); REQUIRE(read_hash == hash); } SECTION("read/write canonical hash") { CHECK_NOTHROW(write_canonical_hash(tx, header.number, header.hash())); auto read_hash = read_canonical_header_hash(tx, header.number); REQUIRE(read_hash != std::nullopt); // Warning: this is a limited test, we only test that REQUIRE(read_hash == header.hash()); // read and write are implemented in a symmetric way } SECTION("read/write total difficulty") { CHECK_NOTHROW(write_total_difficulty(tx, header.number, header.hash(), 1234)); auto read_td = read_total_difficulty(tx, header.number, header.hash()); REQUIRE(read_td != std::nullopt); // Warning: this is a limited test, we only test that REQUIRE(read_td == 1234); // read and write are implemented in a symmetric way } SECTION("read/write stage progress") { BlockNum stage_progress = 1234; CHECK_NOTHROW(stages::write_stage_progress(tx, stages::kHeadersKey, stage_progress)); BlockNum read_stage_progress = stages::read_stage_progress(tx, stages::kHeadersKey); REQUIRE(read_stage_progress == stage_progress); } SECTION("write/read/delete canonical hash") { REQUIRE_NOTHROW(write_canonical_hash(tx, header.number, header.hash())); REQUIRE_NOTHROW(delete_canonical_hash(tx, header.number)); auto read_hash = read_canonical_header_hash(tx, header.number); REQUIRE(read_hash == std::nullopt); } SECTION("header with biggest td") { CHECK_NOTHROW(write_total_difficulty(tx, header.number, header.hash(), 1234)); ++header.number; CHECK_NOTHROW(write_total_difficulty(tx, header.number, header.hash(), 100'000'001'000'000)); auto expected_max_block_num = header.number; auto expected_max_hash = header.hash(); ++header.number; CHECK_NOTHROW(write_total_difficulty(tx, header.number, header.hash(), 34'000'000'000)); auto [max_block_num, max_hash] = header_with_biggest_td(tx); REQUIRE(max_block_num == expected_max_block_num); REQUIRE(max_hash == expected_max_hash); } SECTION("header with biggest td having bad headers") { std::set bad_headers; CHECK_NOTHROW(write_total_difficulty(tx, header.number, header.hash(), 1234)); ++header.number; CHECK_NOTHROW(write_total_difficulty(tx, header.number, header.hash(), 100'000'001'000'000)); bad_headers.insert(header.hash()); ++header.number; CHECK_NOTHROW(write_total_difficulty(tx, header.number, header.hash(), 34'000'000'000)); auto expected_max_block_num = header.number; auto expected_max_hash = header.hash(); auto [max_block_num, max_hash] = header_with_biggest_td(tx, &bad_headers); REQUIRE(max_block_num == expected_max_block_num); REQUIRE(max_hash == expected_max_hash); } SECTION("read/write body") { BlockBody body{}; // a void body, access_layer already has test on body read/write CHECK_NOTHROW(write_body(tx, body, header.hash(), header.number)); BlockBody read_body{}; bool present = db::read_body(tx, header.hash(), header.number, read_body); REQUIRE(present); REQUIRE(body == read_body); } } } // namespace silkworm::db ================================================ FILE: silkworm/db/etl_collector_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::datastore::kvdb { namespace fs = std::filesystem; using silkworm::datastore::etl::Entry; static std::vector generate_entry_set(size_t size) { std::vector pairs; std::set keys; RandomNumber rnd{0, 200000000}; while (pairs.size() < size) { Bytes key(8, '\0'); endian::store_big_u64(&key[0], rnd.generate_one()); if (keys.contains(key)) { // we want unique keys continue; } keys.insert(key); if (pairs.size() % 100) { Bytes value(8, '\0'); endian::store_big_u64(&value[0], rnd.generate_one()); pairs.emplace_back(key, value); } else { Bytes value; pairs.emplace_back(key, value); } } return pairs; } void run_collector_test(const datastore::kvdb::LoadFunc& load_func, bool do_copy = true) { db::test_util::TempChainData context; // Generate Test Entries auto set{generate_entry_set(1000)}; // 1000 entries in total size_t generated_size{0}; for (const auto& entry : set) { generated_size += entry.size() + /* each flushed record stores also length of key and length of value */ 8; } // expect 10 files datastore::kvdb::Collector collector{context.dir().temp().path(), generated_size / 10}; // Collection for (auto&& entry : set) { if (do_copy) collector.collect(entry); // copy is slower... do only if entry is reused afterwards else collector.collect(std::move(entry)); } // Check whether temporary files were generated CHECK(std::distance(fs::directory_iterator{context.dir().temp().path()}, fs::directory_iterator{}) == 10); CHECK(collector.bytes_size() == (generated_size - 8 * set.size())); // Load data while reading loading key from another thread auto key_reader_thread = std::thread([&collector]() -> void { size_t max_tries{10}; while (--max_tries) { std::this_thread::sleep_for(std::chrono::milliseconds(10)); const auto read_key = collector.get_load_key(); log::Info("Loading ...", {"key", read_key}); } }); datastore::kvdb::PooledCursor to{context.rw_txn(), db::table::kHeaderNumbers}; collector.load(to, load_func); // Check whether temporary files were cleaned CHECK(std::distance(fs::directory_iterator{context.dir().temp().path()}, fs::directory_iterator{}) == 0); key_reader_thread.join(); } TEST_CASE("collect_and_default_load") { run_collector_test(nullptr); } TEST_CASE("collect_and_default_load_move") { run_collector_test(nullptr, false); } TEST_CASE("collect_and_load") { run_collector_test([](const Entry& entry, auto& table, MDBX_put_flags_t) { Bytes key{entry.key}; key.at(0) = 1; table.upsert(datastore::kvdb::to_slice(key), datastore::kvdb::to_slice(entry.value)); }); } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/etl_in_memory_collector_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include "util.hpp" namespace silkworm::datastore::kvdb { // Function pointer to process Load on before Load data into tables using KVLoadFunc = std::function; template class InMemoryCollector : public datastore::etl::InMemoryCollector { public: using datastore::etl::InMemoryCollector::InMemoryCollector; //! \brief Loads and optionally transforms collected entries into db //! \param [in] target : a cursor opened on target table and owned by caller (can be empty) //! \param [in] load_func : Pointer to function transforming collected entries. If NULL no transform is executed //! \param [in] flags : Optional put flags for append or upsert (default) items void load( RWCursorDupSort& target, const KVLoadFunc& load_func = {}, MDBX_put_flags_t flags = MDBX_put_flags_t::MDBX_UPSERT) { datastore::etl::KVLoadFunc base_load_func = [&](const Bytes& key, const Bytes& value) { if (load_func) { load_func(key, value, target, flags); } else { mdbx::slice k{to_slice(key)}; if (value.empty()) { target.erase(k); } else { mdbx::slice v{to_slice(value)}; mdbx::error::success_or_throw(target.put(k, &v, flags)); } } }; this->datastore::etl::InMemoryCollector::load(base_load_func); } }; using datastore::etl::Entry; using datastore::etl::MapStorage; using datastore::etl::VectorStorage; static std::vector generate_entry_set(size_t size) { std::vector pairs; std::set keys; RandomNumber rnd{0, 200000000}; while (pairs.size() < size) { Bytes key(8, '\0'); endian::store_big_u64(&key[0], rnd.generate_one()); if (keys.contains(key)) { // we want unique keys continue; } keys.insert(key); if (pairs.size() % 100) { Bytes value(8, '\0'); endian::store_big_u64(&value[0], rnd.generate_one()); pairs.emplace_back(key, value); } else { Bytes value; pairs.emplace_back(key, value); } } return pairs; } template void run_collector_test(const KVLoadFunc& load_func, bool do_copy = true) { db::test_util::TempChainData context; // Generate Test Entries auto set{generate_entry_set(1000)}; // 1000 entries in total size_t generated_size{0}; for (const auto& entry : set) { generated_size += entry.size(); } // Collection COLLECTOR collector{set.size()}; for (auto&& entry : set) { if (do_copy) collector.collect(entry); // copy is slower... do only if entry is reused afterwards else collector.collect(std::move(entry)); } // Check size CHECK(collector.size() == set.size()); CHECK(collector.bytes_size() == generated_size); // Reading loading key from another thread auto key_reader_thread = std::thread([&collector]() -> void { size_t max_tries{10}; while (--max_tries) { std::this_thread::sleep_for(std::chrono::milliseconds(10)); const auto read_key = collector.get_load_key(); log::Info("Loading ...", {"key", read_key}); } }); // Load data PooledCursor to{context.rw_txn(), db::table::kHeaderNumbers}; collector.load(to, load_func); if (load_func) { size_t found_items{0}; PooledCursor from{context.rw_txn(), db::table::kHeaderNumbers}; auto data = from.to_first(); while (data) { auto key = from_slice(data.key); auto value = from_slice(data.value); ++found_items; // find key in set and compare value auto it = std::find_if(set.begin(), set.end(), [&key](const Entry& entry) { return entry.key == key; }); CHECK(it != set.end()); CHECK(it->value == value); data = from.to_next(/*throw_notfound =*/false); } CHECK(found_items == set.size()); } key_reader_thread.join(); } TEST_CASE("collect_and_default_load_in_memory_map") { run_collector_test>(nullptr); } TEST_CASE("collect_and_default_load_in_memory_vector") { run_collector_test>(nullptr); } TEST_CASE("collect_and_default_load_move_in_memory_map") { run_collector_test>(nullptr, false); } TEST_CASE("collect_and_default_load_move_in_memory_vector") { run_collector_test>(nullptr, false); } TEST_CASE("collect_and_load_in_memory_map") { run_collector_test>([](const Bytes& ekey, const Bytes& evalue, auto& table, MDBX_put_flags_t) { table.upsert(to_slice(ekey), to_slice(evalue)); }); } TEST_CASE("collect_and_load_in_memory_vector") { run_collector_test>([](const Bytes& ekey, const Bytes& evalue, auto& table, MDBX_put_flags_t) { table.upsert(to_slice(ekey), to_slice(evalue)); }); } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/freezer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "freezer.hpp" #include #include #include #include #include #include #include #include "access_layer.hpp" #include "blocks/bodies/body_queries.hpp" #include "blocks/bodies/body_segment_collation.hpp" #include "blocks/headers/header_segment_collation.hpp" #include "blocks/schema_config.hpp" #include "blocks/transactions/txn_segment_collation.hpp" #include "datastore/segment_collation.hpp" #include "datastore/snapshots/common/snapshot_path.hpp" #include "datastore/snapshots/segment/segment_writer.hpp" #include "datastore/snapshots/snapshot_bundle.hpp" #include "prune_mode.hpp" namespace silkworm::db { using namespace silkworm::datastore; using namespace silkworm::snapshots; struct FreezerResult : public DataMigrationResult { SnapshotBundlePaths bundle_paths; explicit FreezerResult(SnapshotBundlePaths bundle_paths1) : bundle_paths(std::move(bundle_paths1)) {} ~FreezerResult() override = default; }; static BlockNum get_tip_num(ROTxn& txn) { auto [num, _] = db::read_canonical_head(txn); return num; } static BlockNum get_first_stored_header_num(ROTxn& txn) { auto num_opt = db::read_stored_header_number_after(txn, 1); return num_opt.value_or(0); } static std::optional get_next_base_txn_id(SnapshotRepository& repository, BlockNum block_num) { auto body = BodyFindByBlockNumQuery{repository}.exec(block_num); if (!body) return std::nullopt; return body->base_txn_id + body->txn_count; } std::unique_ptr Freezer::next_command() { BlockNum last_frozen = snapshots_.max_timestamp_available(); BlockNum start = (last_frozen > 0) ? last_frozen + 1 : 0; BlockNum end = start + kChunkSize; BlockNum tip = [this] { auto db_tx = db_access_.start_ro_tx(); return get_tip_num(db_tx); }(); uint64_t base_txn_id = [this, last_frozen]() -> uint64_t { if (last_frozen == 0) return 0; auto id = get_next_base_txn_id(snapshots_, last_frozen); SILKWORM_ASSERT(id.has_value()); return *id; }(); if (end + kFullImmutabilityThreshold <= tip) { return std::make_unique(SegmentCollationCommand{{start, end}, base_txn_id}); } return {}; } static const SegmentCollation& get_collation(datastore::EntityName name) { static HeaderSegmentCollation header_collation; static BodySegmentCollation body_collation; static TransactionSegmentCollation txn_collation; if (name == blocks::kHeaderSegmentName) return header_collation; if (name == blocks::kBodySegmentName) return body_collation; if (name == blocks::kTxnSegmentName) return txn_collation; SILKWORM_ASSERT(false); throw std::runtime_error("invalid name"); } std::shared_ptr Freezer::migrate(std::unique_ptr command) { auto& freezer_command = dynamic_cast(*command); auto range = freezer_command.range; StepRange step_range = snapshots_.step_converter().step_range_from_timestamp_range({range.start, range.end}); SnapshotBundlePaths bundle{snapshots_.schema(), tmp_dir_path_, step_range}; for (const auto& [name, path] : bundle.segment_paths()) { segment::SegmentFileWriter file_writer{path, tmp_dir_path_}; { auto db_tx = db_access_.start_ro_tx(); auto& freezer = get_collation(name); freezer.copy(db_tx, freezer_command, file_writer); } segment::SegmentFileWriter::flush(std::move(file_writer)); } return std::make_shared(std::move(bundle)); } void Freezer::index(std::shared_ptr result) { auto& freezer_result = dynamic_cast(*result); snapshots_.build_indexes(freezer_result.bundle_paths); } void Freezer::commit(std::shared_ptr result) { auto& freezer_result = dynamic_cast(*result); auto& bundle = freezer_result.bundle_paths; move_files(bundle.files(), snapshots_.path()); SnapshotBundle final_bundle = snapshots_.open_bundle(bundle.step_range()); snapshots_.add_snapshot_bundle(std::move(final_bundle)); } BlockNumRange Freezer::cleanup_range() { BlockNum last_frozen = snapshots_.max_timestamp_available(); BlockNum first_stored_header_num = [this] { auto db_tx = db_access_.start_ro_tx(); return get_first_stored_header_num(db_tx); }(); BlockNum end = (last_frozen > 0) ? last_frozen + 1 : 0; BlockNum start = (first_stored_header_num > 0) ? first_stored_header_num : end; return BlockNumRange{start, end}; } Task Freezer::cleanup() { BlockNumRange range = cleanup_range(); if (range.start >= range.end) co_return; SILK_DEBUG_M(name()) << "cleanup " << range.to_string(); if (keep_blocks_) { SILK_DEBUG_M(name()) << "skipping cleanup"; co_return; } co_await stage_scheduler_.schedule([this, range](RWTxn& db_tx) { this->prune_collations(db_tx, range); }); } void Freezer::prune_collations(RWTxn& db_tx, BlockNumRange range) const { get_collation(blocks::kHeaderSegmentName).prune(db_tx, range); get_collation(blocks::kBodySegmentName).prune(db_tx, range); get_collation(blocks::kTxnSegmentName).prune(db_tx, range); } } // namespace silkworm::db ================================================ FILE: silkworm/db/freezer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "datastore/data_migration.hpp" #include "datastore/kvdb/mdbx.hpp" #include "datastore/snapshots/snapshot_repository.hpp" #include "datastore/stage_scheduler.hpp" namespace silkworm::db { class Freezer : public datastore::DataMigration { public: using DataMigrationCommand = datastore::DataMigrationCommand; using DataMigrationResult = datastore::DataMigrationResult; Freezer( datastore::kvdb::ROAccess db_access, snapshots::SnapshotRepository& snapshots, datastore::StageScheduler& stage_scheduler, std::filesystem::path tmp_dir_path, bool keep_blocks) : db_access_(std::move(db_access)), snapshots_(snapshots), stage_scheduler_(stage_scheduler), tmp_dir_path_(std::move(tmp_dir_path)), keep_blocks_(keep_blocks) {} private: static constexpr size_t kChunkSize = 1000; const char* name() const override { return "Freezer"; } std::unique_ptr next_command() override; std::shared_ptr migrate(std::unique_ptr command) override; void index(std::shared_ptr result) override; void commit(std::shared_ptr result) override; Task cleanup() override; BlockNumRange cleanup_range(); void prune_collations(datastore::kvdb::RWTxn& db_tx, BlockNumRange range) const; datastore::kvdb::ROAccess db_access_; snapshots::SnapshotRepository& snapshots_; datastore::StageScheduler& stage_scheduler_; std::filesystem::path tmp_dir_path_; bool keep_blocks_; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/genesis.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "genesis.hpp" #include #include #include #include #include #include "state/account_codec.hpp" #include "tables.hpp" namespace silkworm::db { using datastore::kvdb::to_slice; std::pair> validate_genesis_json(const nlohmann::json& genesis_json) { std::pair> ret{true, {}}; if (genesis_json.is_discarded()) { ret.second.emplace_back("Invalid json data"); } else { if (!genesis_json.contains("difficulty")) { ret.second.emplace_back("Missing difficulty member"); } else { auto str{genesis_json["difficulty"].get()}; auto bytes = from_hex(str); if (!bytes.has_value()) { ret.second.emplace_back("Member difficulty is not a valid hex"); } } if (!genesis_json.contains("gasLimit")) ret.second.emplace_back("Missing gasLimit member"); if (!genesis_json.contains("timestamp")) ret.second.emplace_back("Missing timestamp member"); if (!genesis_json.contains("config")) { ret.second.emplace_back("Missing config member"); } else { if (!genesis_json["config"].is_object()) { ret.second.emplace_back("Member config is not object"); } else { auto& genesis_config_json{genesis_json["config"]}; const auto chain_config = ChainConfig::from_json(genesis_config_json); if (!chain_config.has_value()) { ret.second.emplace_back("Incomplete / Wrong genesis config member"); } else { if (std::holds_alternative(chain_config->rule_set_config)) { if (!genesis_json.contains("mixHash") || !genesis_json["mixHash"].is_string() || !genesis_json.contains("nonce") || !genesis_json["nonce"].is_string()) { ret.second.emplace_back("Missing mixHash and or nonce member for ethash PoW chain"); } else { auto mixhash = from_hex(genesis_json["mixHash"].get()); if (!mixhash.has_value() || mixhash->size() != kHashLength) { ret.second.emplace_back("mixHash member is not a valid hash hex string"); } auto nonce = from_hex(genesis_json["nonce"].get()); if (!nonce.has_value()) { ret.second.emplace_back("nonce member is not a valid hex string"); } } } } } } if (genesis_json.contains("alloc")) { if (!genesis_json["alloc"].is_object()) { ret.second.emplace_back("alloc member is not object"); } else { // Check for sanity of allocations // NOTE ! There is no need to check for uniqueness of keys as, // being an object, keys are already unique (otherwise parsing of Json fails) for (auto& item : genesis_json["alloc"].items()) { if (!item.value().is_object() || !item.value().contains("balance") || !item.value()["balance"].is_string()) { ret.second.emplace_back("Allocation for " + item.key() + " is badly formatted"); continue; } auto address_bytes{from_hex(item.key())}; if (!address_bytes.has_value() || address_bytes->size() != kAddressLength) { ret.second.emplace_back("Allocation for " + item.key() + " has invalid address"); continue; } try { auto balance_str{item.value()["balance"].get()}; (void)intx::from_string(balance_str); } catch (const std::exception&) { ret.second.emplace_back("Allocation for " + item.key() + " has bad balance"); } } } } } ret.first = ret.second.empty(); return ret; } evmc::bytes32 initialize_genesis_allocations(RWTxn& txn, const nlohmann::json& genesis_json) { InMemoryState state{read_genesis_allocation(genesis_json.at("alloc"))}; write_genesis_allocation_to_db(txn, state); return state.state_root_hash(); } void write_genesis_allocation_to_db(RWTxn& txn, const InMemoryState& genesis_allocation) { auto state_table = txn.rw_cursor_dup_sort(table::kPlainState); auto code_table{open_cursor(txn, table::kCode)}; for (const auto& [address, account] : genesis_allocation.accounts()) { // Store account plain state Bytes encoded = state::AccountCodec::encode_for_storage(account); state_table->upsert(to_slice(address), to_slice(encoded)); // Store code if (account.code_hash != kEmptyHash) { ByteView code{genesis_allocation.read_code(address, account.code_hash)}; code_table.upsert(to_slice(account.code_hash), to_slice(code)); } } for (const auto& [address, incarnations] : genesis_allocation.storage()) { for (const auto& [incarnation, storage] : incarnations) { Bytes prefix{storage_prefix(address, incarnation)}; for (const auto& [location, value] : storage) { upsert_storage_value(*state_table, prefix, location.bytes, value.bytes); } } } } bool initialize_genesis(RWTxn& txn, const nlohmann::json& genesis_json, bool allow_exceptions) { if (!txn->is_readwrite()) { if (!allow_exceptions) { return false; } throw std::runtime_error("Unable to write to db with a RO transaction"); } auto existing_config{read_chain_config(txn)}; if (existing_config.has_value()) { if (!allow_exceptions) { return false; } throw std::runtime_error("This database is already initialized with genesis"); } // Validate json payload auto [valid, errors]{validate_genesis_json(genesis_json)}; if (!valid) { if (!allow_exceptions) { return false; } const char* delim{"\n"}; std::ostringstream imploded; std::copy(errors.begin(), errors.end(), std::ostream_iterator(imploded, delim)); throw std::runtime_error("Invalid genesis json payload. Examine following errors:\n" + imploded.str()); } try { // Allocate accounts const evmc::bytes32 state_root_hash{initialize_genesis_allocations(txn, genesis_json)}; const BlockHeader header{read_genesis_header(genesis_json, state_root_hash)}; auto block_hash{header.hash()}; auto block_hash_key{block_key(header.number, block_hash.bytes)}; write_header(txn, header, /*with_header_numbers=*/true); // Write table::kHeaders and table::kHeaderNumbers write_canonical_header_hash(txn, block_hash.bytes, header.number); // Insert header hash as canonical write_total_difficulty(txn, block_hash_key, header.difficulty); // Write initial difficulty write_body(txn, BlockBody(), block_hash.bytes, header.number); // Write block body (empty) write_head_header_hash(txn, block_hash.bytes); // Update head header in config // TODO(Andrea) verify how receipts are stored (see buffer.cpp) const uint8_t genesis_null_receipts[] = {0xf6}; // <- cbor encoded open_cursor(txn, table::kBlockReceipts) .upsert(to_slice(block_hash_key).safe_middle(0, 8), to_slice(Bytes(genesis_null_receipts, 1))); // Write Chain Settings auto config_data{genesis_json["config"].dump()}; open_cursor(txn, table::kConfig) .upsert(to_slice(block_hash), mdbx::slice{config_data.data()}); return true; } catch (const std::exception&) { if (!allow_exceptions) { return false; } throw; } } } // namespace silkworm::db ================================================ FILE: silkworm/db/genesis.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::db { //! \brief Validates provided genesis json payload //! \param [in] genesis_json : the payload to validate //! \returns A pair of bool and a vector of string errors (if any) std::pair> validate_genesis_json(const nlohmann::json& genesis_json); //! \brief Initializes database with genesis account allocation only from JSON payload //! \param [in] txn : a RW MDBX transaction //! \param [in] genesis_json : the genesis JSON payload //! \returns the state root hash after account allocation evmc::bytes32 initialize_genesis_allocations(RWTxn& txn, const nlohmann::json& genesis_json); void write_genesis_allocation_to_db(RWTxn& txn, const InMemoryState& genesis_allocation); //! \brief Initializes database with genesis from JSON payload //! \param [in] txn : a RW MDBX transaction //! \param [in] genesis_json : the genesis JSON payload //! \param [in] allow_exceptions : whether to throw exceptions on failure(s) //! \returns True/False bool initialize_genesis(RWTxn& txn, const nlohmann::json& genesis_json, bool allow_exceptions); } // namespace silkworm::db ================================================ FILE: silkworm/db/genesis_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "genesis.hpp" #include #include #include #include namespace silkworm::db { TEST_CASE("Database genesis initialization") { db::test_util::TempChainData context; auto& txn{context.rw_txn()}; SECTION("Initialize with Mainnet") { auto source_data{read_genesis_data(kMainnetConfig.chain_id)}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE(initialize_genesis(txn, genesis_json, /*allow_exceptions=*/false)); CHECK(read_chain_config(txn) == kMainnetConfig); } SECTION("Initialize with Sepolia") { auto source_data{read_genesis_data(kSepoliaConfig.chain_id)}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE(initialize_genesis(txn, genesis_json, /*allow_exceptions=*/false)); CHECK(read_chain_config(txn) == kSepoliaConfig); } SECTION("Initialize with Polygon PoS") { auto source_data{read_genesis_data(kBorMainnetConfig.chain_id)}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE(initialize_genesis(txn, genesis_json, /*allow_exceptions=*/false)); CHECK(read_chain_config(txn) == kBorMainnetConfig); } SECTION("Initialize with Amoy") { auto source_data{read_genesis_data(kAmoyConfig.chain_id)}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE(initialize_genesis(txn, genesis_json, /*allow_exceptions=*/false)); CHECK(read_chain_config(txn) == kAmoyConfig); } SECTION("Initialize with invalid Json") { std::string source_data{"{chainId="}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE_THROWS(initialize_genesis(txn, genesis_json, /*allow_exceptions=*/true)); } #if defined(__clang__) && !defined(NDEBUG) // clang has a defect so throw-ing T (a generic exception) is not catch-ed #else SECTION("Initialize with errors in Json payload") { // Base is mainnet auto source_data{read_genesis_data(kMainnetConfig.chain_id)}; nlohmann::json not_hex = "0xgg"; // Remove mandatory members { auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE(genesis_json.is_discarded() == false); auto removed_count = genesis_json.erase("difficulty"); removed_count += genesis_json.erase("gaslimit"); removed_count += genesis_json.erase("timestamp"); removed_count += genesis_json.erase("config"); const auto& [valid, errors]{validate_genesis_json(genesis_json)}; REQUIRE(valid == false); CHECK(errors.size() == removed_count); } // Tamper with hex values { auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE(genesis_json.is_discarded() == false); genesis_json["difficulty"] = not_hex; genesis_json["nonce"] = not_hex; const auto& [valid, errors]{validate_genesis_json(genesis_json)}; REQUIRE(valid == false); CHECK(errors.size() == 2); genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); genesis_json["alloc"]["c951900c341abbb3bafbf7ee2029377071dbc36a"]["balance"] = not_hex; } // Tamper with hex values on allocations { auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); genesis_json["alloc"]["c951900c341abbb3bafbf7ee2029377071dbc36a"]["balance"] = not_hex; genesis_json["alloc"]["c951900c341abbb3bafbf7ee2029377071dbc"]["balance"] = not_hex; const auto& [valid, errors]{validate_genesis_json(genesis_json)}; REQUIRE(valid == false); CHECK(errors.size() == 2); } // Remove chainId from config member { auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); genesis_json["config"].erase("chainId"); const auto& [valid, errors]{validate_genesis_json(genesis_json)}; REQUIRE(valid == false); CHECK(errors.size() == 1); } } #endif // non-clang SECTION("Update chain config") { SECTION("Without genesis block") { // Nothing should happen update_chain_config(txn, kMainnetConfig); datastore::kvdb::PooledCursor config(txn, table::kConfig); REQUIRE(config.empty()); } SECTION("With genesis block") { auto source_data{read_genesis_data(kMainnetConfig.chain_id)}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /*allow_exceptions=*/false); REQUIRE(initialize_genesis(txn, genesis_json, /*allow_exceptions=*/false)); context.commit_and_renew_txn(); CHECK(read_chain_config(txn) == kMainnetConfig); // Now update with sepolia chain config // Yes it should not happen and is wrong - but only needed to test a new update_chain_config(txn, kSepoliaConfig); REQUIRE(read_chain_config(txn) == kSepoliaConfig); } } } } // namespace silkworm::db ================================================ FILE: silkworm/db/kv/api/as_datastore_ts_range.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "as_datastore_ts_range.hpp" #include namespace silkworm::db::kv::api { datastore::TimestampRange as_datastore_ts_range(TimestampRange ts_range, bool reverse) { const auto [from_ts, to_ts] = ts_range; // static_cast automatically handles conversion for all values included -1 => INF... datastore::TimestampRange db_range{static_cast(reverse ? to_ts : from_ts), static_cast(reverse ? from_ts : to_ts)}; // ...but we still need to adjust some corner cases: // [-1, -1) means [StartOfTable, EndOfTable) i.e. [0, INF) // [from, -1) in reverse order means [StartOfTable, from) i.e. [0, from) if (to_ts == kInfinite && (from_ts == kInfinite || reverse)) { db_range.start = 0; } ensure(db_range.start <= db_range.end, [&]() { return "invalid forward range " + db_range.to_string(); }); return db_range; } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/as_datastore_ts_range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../api/endpoint/common.hpp" #include "../api/endpoint/temporal_range.hpp" namespace silkworm::db::kv::api { datastore::TimestampRange as_datastore_ts_range(TimestampRange ts_range, bool reverse); } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/as_datastore_ts_range_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "as_datastore_ts_range.hpp" #include #include #include #include namespace silkworm::db::kv::api { using namespace silkworm::test_util; TEST_CASE("ts_range_from_kv", "[db][kv][api][local_timestamp]") { const Fixtures, std::optional> test_fixtures{ /* ascending order */ {{{0, 20}, /*reverse=*/false}, datastore::TimestampRange{0, 20}}, {{{10, 20}, /*reverse=*/false}, datastore::TimestampRange{10, 20}}, {{{10, -1}, /*reverse=*/false}, datastore::TimestampRange{10, datastore::kMaxTimestamp}}, {{{-1, -1}, /*reverse=*/false}, datastore::TimestampRange{0, datastore::kMaxTimestamp}}, {{{20, 0}, /*reverse=*/false}, std::nullopt}, {{{20, 10}, /*reverse=*/false}, std::nullopt}, {{{-1, 10}, /*reverse=*/false}, std::nullopt}, /* descending order */ {{{20, 0}, /*reverse=*/true}, datastore::TimestampRange{0, 20}}, {{{20, 10}, /*reverse=*/true}, datastore::TimestampRange{10, 20}}, {{{-1, 10}, /*reverse=*/true}, datastore::TimestampRange{10, datastore::kMaxTimestamp}}, {{{-1, -1}, /*reverse=*/true}, datastore::TimestampRange{0, datastore::kMaxTimestamp}}, {{{0, 20}, /*reverse=*/true}, std::nullopt}, {{{10, 20}, /*reverse=*/true}, std::nullopt}, }; for (const auto& [kv_ts_range_and_reverse, expected_db_ts_range] : test_fixtures) { const auto& [kv_ts_range, reverse] = kv_ts_range_and_reverse; const auto convert_ts_range_from_kv = [&]() { return as_datastore_ts_range({kv_ts_range.first, kv_ts_range.second}, reverse); }; if (expected_db_ts_range) { const auto db_ts_range = convert_ts_range_from_kv(); CHECK(db_ts_range.start == expected_db_ts_range->start); CHECK(db_ts_range.end == expected_db_ts_range->end); } else { CHECK_THROWS(convert_ts_range_from_kv()); } } } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/base_transaction.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "base_transaction.hpp" #include #include namespace silkworm::db::kv::api { Task BaseTransaction::get(std::string_view table, ByteView key) { const auto new_cursor = co_await cursor(table); SILK_TRACE << "BaseTransaction::get cursor_id: " << new_cursor->cursor_id(); const auto kv_pair = co_await new_cursor->seek(key); SILK_TRACE << "BaseTransaction::get key: " << kv_pair.key << " value: " << kv_pair.value; co_return kv_pair; } Task BaseTransaction::get_one(std::string_view table, ByteView key) { const auto new_cursor = co_await cursor(table); SILK_TRACE << "BaseTransaction::get_one cursor_id: " << new_cursor->cursor_id(); const auto kv_pair = co_await new_cursor->seek_exact(key); SILK_TRACE << "BaseTransaction::get_one key: " << kv_pair.key << " value: " << kv_pair.value; co_return kv_pair.value; } Task> BaseTransaction::get_both_range(std::string_view table, ByteView key, ByteView subkey) { const auto new_cursor = co_await cursor_dup_sort(table); SILK_TRACE << "BaseTransaction::get_both_range cursor_id: " << new_cursor->cursor_id(); const auto value{co_await new_cursor->seek_both(key, subkey)}; SILK_DEBUG << "BaseTransaction::get_both_range value: " << value << " subkey: " << subkey; if (value.substr(0, subkey.size()) != subkey) { SILK_DEBUG << "BaseTransaction::get_both_range value: " << value << " subkey: " << subkey; co_return std::nullopt; } co_return value.substr(subkey.size()); } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/base_transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "transaction.hpp" namespace silkworm::db::kv::api { class BaseTransaction : public Transaction { public: explicit BaseTransaction(StateCache* state_cache) : state_cache_{state_cache} {} StateCache* state_cache() override { return state_cache_; } bool is_local() const override { return false; } Task get(std::string_view table, ByteView key) override; Task get_one(std::string_view table, ByteView key) override; Task> get_both_range(std::string_view table, ByteView key, ByteView subkey) override; private: StateCache* state_cache_; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "service.hpp" namespace silkworm::db::kv::api { struct Client { virtual ~Client() = default; virtual std::shared_ptr service() = 0; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "endpoint/key_value.hpp" namespace silkworm::db::kv::api { class Cursor { public: Cursor() = default; virtual ~Cursor() = default; Cursor(const Cursor&) = delete; Cursor& operator=(const Cursor&) = delete; virtual uint32_t cursor_id() const = 0; virtual Task open_cursor(std::string_view table_name, bool is_dup_sorted) = 0; virtual Task seek(ByteView key) = 0; virtual Task seek_exact(ByteView key) = 0; virtual Task first() = 0; virtual Task last() = 0; virtual Task next() = 0; virtual Task previous() = 0; virtual Task close_cursor() = 0; }; class CursorDupSort : public Cursor { public: virtual Task seek_both(ByteView key, ByteView value) = 0; virtual Task seek_both_exact(ByteView key, ByteView value) = 0; virtual Task next_dup() = 0; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/direct_client.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "direct_client.hpp" namespace silkworm::db::kv::api { DirectClient::DirectClient(std::shared_ptr direct_service) : direct_service_(std::move(direct_service)) {} std::shared_ptr DirectClient::service() { return direct_service_; } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/direct_client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../api/client.hpp" #include "../api/direct_service.hpp" namespace silkworm::db::kv::api { struct DirectClient : public api::Client { explicit DirectClient(std::shared_ptr direct_service); ~DirectClient() override = default; std::shared_ptr service() override; private: std::shared_ptr direct_service_; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/direct_service.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "direct_service.hpp" #include #include "endpoint/state_changes_call.hpp" #include "local_transaction.hpp" namespace silkworm::db::kv::api { DirectService::DirectService(ServiceRouter router, DataStoreRef data_store, const ChainConfig& chain_config, StateCache* state_cache) : router_{router}, data_store_{std::move(data_store)}, chain_config_{chain_config}, state_cache_{state_cache} {} // rpc Version(google.protobuf.Empty) returns (types.VersionReply); Task DirectService::version() { co_return kCurrentVersion; } // rpc Tx(stream Cursor) returns (stream Pair); Task> DirectService::begin_transaction() { co_return std::make_unique(data_store_, chain_config_, state_cache_); } // rpc StateChanges(StateChangeRequest) returns (stream StateChangeBatch); Task DirectService::state_changes(const api::StateChangeOptions& options, api::StateChangeConsumer consumer) { auto executor = co_await boost::asio::this_coro::executor; api::StateChangesCall call{options, executor}; auto unsubscribe_signal = call.unsubscribe_signal(); [[maybe_unused]] auto _ = gsl::finally([=]() { unsubscribe_signal->notify(); }); co_await router_.state_changes_calls_channel.send(call); auto channel = co_await call.result(); // Loop until stream completed (i.e. no message received) or cancelled exception bool stream_completed{false}; while (!stream_completed) { auto message = co_await channel->receive(); if (!message) { stream_completed = true; } co_await consumer(std::move(message)); } } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/direct_service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "local_transaction.hpp" #include "service.hpp" #include "service_router.hpp" namespace silkworm::db::kv::api { //! Straightforward asynchronous implementation of KV API service relying on \code Domains. //! This is used both client-side by 'direct' (i.e. no-gRPC) implementation and server-side by gRPC server. class DirectService : public Service { public: DirectService(ServiceRouter router, DataStoreRef data_store, const ChainConfig& chain_config, StateCache* state_cache); ~DirectService() override = default; DirectService(const DirectService&) = delete; DirectService& operator=(const DirectService&) = delete; DirectService(DirectService&&) = delete; DirectService& operator=(DirectService&&) = delete; // rpc Version(google.protobuf.Empty) returns (types.VersionReply); Task version() override; // rpc Tx(stream Cursor) returns (stream Pair); Task> begin_transaction() override; // rpc StateChanges(StateChangeRequest) returns (stream StateChangeBatch); Task state_changes(const StateChangeOptions&, StateChangeConsumer) override; private: //! The router to service endpoint implementation ServiceRouter router_; //! The data store DataStoreRef data_store_; //! The chain configuration const ChainConfig& chain_config_; //! The local state cache built upon incoming state changes StateCache* state_cache_; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/direct_service_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "direct_service.hpp" #include #include #include #include #include namespace silkworm::db::kv::api { using namespace silkworm::test_util; using test_util::TestDataStore; struct DirectServiceTest : public test_util::KVTestBase { Task consumer(std::optional change_set) { if (!change_set) co_return; change_set_vector.push_back(*change_set); } TemporaryDirectory tmp_dir; TestDataStore data_store{tmp_dir}; ChainConfig chain_config{kMainnetConfig}; StateChangeChannelPtr channel{std::make_shared(ioc_.get_executor())}; concurrency::Channel state_changes_calls_channel{ioc_.get_executor()}; std::unique_ptr state_cache{std::make_unique()}; DirectService service{ServiceRouter{state_changes_calls_channel}, data_store->ref(), chain_config, state_cache.get()}; std::vector change_set_vector; }; TEST_CASE_METHOD(DirectServiceTest, "state_changes: state change sets", "[db][kv][api][direct_service]") { const std::vector> fixtures{ {}, {StateChangeSet{}}, {StateChangeSet{}, StateChangeSet{}}, {StateChangeSet{}, StateChangeSet{}, StateChangeSet{}}, }; StateChangeOptions options; auto state_changes_future = spawn(service.state_changes(options, [this](auto cs) -> Task { co_await consumer(cs); })); for (const auto& expected_change_sets : fixtures) { SECTION("expected_change_sets size=" + std::to_string(expected_change_sets.size())) { spawn_and_wait([&]() -> Task { auto state_changes_call = co_await state_changes_calls_channel.receive(); state_changes_call.set_result(channel); for (const auto& change_set : expected_change_sets) { co_await channel->send(change_set); } }); spawn(channel->send({})); CHECK_NOTHROW(state_changes_future.get()); CHECK(change_set_vector == expected_change_sets); } } } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/common.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::db::kv::api { //! Database meta-transaction ID (a transaction over mdbx and snapshots) using TxId = uint64_t; using Timestamp = int64_t; using TimestampRange = std::pair; using ListOfBytes = std::vector; using ListOfTimestamp = std::vector; using Domain = uint16_t; using History = std::string_view; using InvertedIndex = std::string_view; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/key_value.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db::kv::api { struct KeyValue { Bytes key; Bytes value; KeyValue() noexcept = default; KeyValue(Bytes k, Bytes v) : key{std::move(k)}, value{std::move(v)} {} // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) KeyValue(Bytes k) : key{std::move(k)} {} // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) KeyValue(std::pair kv_pair) : key{std::move(kv_pair.first)}, value{std::move(kv_pair.second)} {} }; inline bool operator<(const KeyValue& lhs, const KeyValue& rhs) { return lhs.key < rhs.key; } inline bool operator==(const KeyValue& lhs, const KeyValue& rhs) { return lhs.key == rhs.key; } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/paginated_sequence.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "sequence.hpp" #include "temporal_range.hpp" namespace silkworm::db::kv::api { //! Sequence of values produced by pagination using some asynchronous page provider function. template class PaginatedSequence { public: using Page = std::vector; struct PageResult { Page values; std::string next_page_token; }; using PageToken = std::string; using Paginator = std::function(PageToken)>; class Iterator : public StreamIterator { public: using value_type = V; Task has_next() override { co_return it_ != current_.values.cend(); } Task> next() override { if (it_ == current_.values.cend()) { if (!current_.next_page_token.empty()) { current_ = co_await next_page_provider_(std::move(current_.next_page_token)); it_ = current_.values.cbegin(); } } if (it_ == current_.values.cend()) { co_return std::nullopt; } const auto value = *it_; ++it_; co_return value; } Iterator(Paginator& next_page_provider, PageResult current) noexcept : next_page_provider_(next_page_provider), current_(std::move(current)), it_(current_.values.cbegin()) {} Iterator(const Iterator& other) noexcept : next_page_provider_(other.next_page_provider_), current_(other.current_), it_(current_.values.cbegin() + std::distance(other.current_.values.cbegin(), other.it_)) {} Iterator(Iterator&& other) noexcept : next_page_provider_(other.next_page_provider_) { const auto distance = std::distance(other.current_.values.cbegin(), other.it_); current_ = std::move(other.current_); // NOLINT(*-prefer-member-initializer) it_ = current_.values.cbegin() + distance; } private: Paginator& next_page_provider_; PageResult current_; typename Page::const_iterator it_; }; explicit PaginatedSequence(Paginator next_page_provider) noexcept : next_page_provider_(std::move(next_page_provider)) {} Task> operator()() { auto current = co_await next_page_provider_(""); co_return std::make_unique(next_page_provider_, std::move(current)); } private: Paginator next_page_provider_; }; template Task> paginated_to_vector(PaginatedSequence& paginated) { auto it = co_await paginated(); co_return co_await stream_to_vector(it); } //! Sequence of keys and values produced by pagination using some asynchronous page provider function. template class PaginatedSequencePair { public: using KPage = std::vector; using VPage = std::vector; struct PageResult { KPage keys; VPage values; std::string next_page_token; }; using PageToken = std::string; using Paginator = std::function(PageToken)>; using KVPair = std::pair; class Iterator : public StreamIterator { public: using value_type = KVPair; Task has_next() override { const bool has_next_key = key_it_ != current_.keys.cend(); const bool has_next_value = value_it_ != current_.values.cend(); SILKWORM_ASSERT(has_next_key == has_next_value); co_return has_next_key; } Task> next() override { if (key_it_ == current_.keys.cend()) { SILKWORM_ASSERT(value_it_ == current_.values.cend()); if (!current_.next_page_token.empty()) { current_ = co_await next_page_provider_(std::move(current_.next_page_token)); key_it_ = current_.keys.cbegin(); value_it_ = current_.values.cbegin(); } } if (key_it_ == current_.keys.cend()) { SILKWORM_ASSERT(value_it_ == current_.values.cend()); co_return std::nullopt; } const std::pair key_value{std::move(*key_it_), std::move(*value_it_)}; ++key_it_, ++value_it_; co_return key_value; } Iterator(Paginator& next_page_provider, PageResult current) noexcept : next_page_provider_(next_page_provider), current_(std::move(current)), key_it_(current_.keys.cbegin()), value_it_(current_.values.cbegin()) {} Iterator(const Iterator& other) noexcept : next_page_provider_(other.next_page_provider_), current_(other.current_), key_it_(current_.keys.cbegin() + std::distance(other.current_.keys.cbegin(), other.key_it_)), value_it_(current_.values.cbegin() + std::distance(other.current_.values.cbegin(), other.value_it_)) {} Iterator(Iterator&& other) noexcept : next_page_provider_(other.next_page_provider_) { const auto key_distance = std::distance(other.current_.keys.cbegin(), other.key_it_); const auto value_distance = std::distance(other.current_.values.cbegin(), other.value_it_); SILKWORM_ASSERT(key_distance == value_distance); current_ = std::move(other.current_); // NOLINT(*-prefer-member-initializer) key_it_ = current_.keys.cbegin() + key_distance; value_it_ = current_.values.cbegin() + value_distance; } private: Paginator& next_page_provider_; PageResult current_; typename KPage::const_iterator key_it_; typename VPage::const_iterator value_it_; }; explicit PaginatedSequencePair(Paginator next_page_provider) noexcept : next_page_provider_(std::move(next_page_provider)) {} Task> operator()() { auto current = co_await next_page_provider_(""); ensure(current.keys.size() == current.values.size(), "PaginatedSequencePair::begin keys/values size mismatch"); co_return std::make_unique(next_page_provider_, std::move(current)); } private: Paginator next_page_provider_; }; template Task> paginated_to_vector(PaginatedSequencePair& paginated) { std::vector all_values; auto it = co_await paginated(); while (const auto value = co_await it->next()) { all_values.emplace_back(*value); } co_return all_values; } using PaginatedTimestamps = PaginatedSequence; using PaginatedKeysValues = PaginatedSequencePair; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/paginated_sequence_benchmark.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include "paginated_sequence.hpp" namespace silkworm::db::kv::api { using PaginatedUint64 = PaginatedSequence; struct PaginatedSequenceBenchTest : public test_util::ContextTestBase { }; template TSequence make_paginated_sequence(const size_t page_size, const size_t n) { const size_t num_pages = n / page_size + (n % page_size ? 1 : 0); const size_t last_page_size = n % page_size ? n % page_size : page_size; typename TSequence::Paginator paginator = [=](typename TSequence::PageToken) -> Task { static size_t count{0}; const bool has_more = ++count < num_pages; const std::string token = has_more ? "next" : ""; typename TSequence::Page p(has_more ? page_size : last_page_size, 0); co_return typename TSequence::PageResult{std::move(p), token}; }; return TSequence{std::move(paginator)}; } Task paginated_sequence_iteration(PaginatedUint64& paginated) { size_t accumulator{0}; auto it = co_await paginated(); while (const auto value = co_await it->next()) { accumulator += *value; } co_return accumulator; } static void benchmark_paginated_sequence_iteration(benchmark::State& state) { const auto page_size = static_cast(state.range(0)); const auto n = static_cast(state.range(1)); PaginatedSequenceBenchTest test; auto paginated_sequence = make_paginated_sequence(page_size, n); for ([[maybe_unused]] auto _ : state) { const auto result = test.spawn_and_wait(paginated_sequence_iteration(paginated_sequence)); benchmark::DoNotOptimize(result); } } BENCHMARK(benchmark_paginated_sequence_iteration)->Args({100, 1'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({100, 10'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({100, 100'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({1'000, 1'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({1'000, 10'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({1'000, 100'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({10'000, 10'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({10'000, 100'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({10'000, 1'000'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({100'000, 100'001}); BENCHMARK(benchmark_paginated_sequence_iteration)->Args({100'000, 1'000'001}); // Modified version of PaginatedSequence to check performance tradeoffs w/ different impl // - PaginatedSequence::Iterator async next() method (more convenient at call site) // - PaginatedSequence2::Iterator sync operator++ plus async next_page template class PaginatedSequence2 { public: using Page = std::vector; struct PageResult { Page values; std::string next_page_token; }; using PageToken = std::string; using Paginator = std::function(PageToken)>; class Iterator { public: T operator*() { return std::move(*it_); } bool operator++() { ++it_; if (it_ == current_.values.cend()) { if (!current_.next_page_token.empty()) { return true; } it_ = typename Page::const_iterator(); // empty i.e. sentinel value } return false; } Task next_page() { current_ = co_await next_page_provider_(std::move(current_.next_page_token)); it_ = current_.values.cbegin(); } bool operator==(const Iterator& other) const noexcept { return it_ == other.it_; } bool operator!=(const Iterator& other) const noexcept { return !(*this == other); } Iterator(Paginator& next_page_provider, PageResult current) noexcept : next_page_provider_(next_page_provider), current_(std::move(current)), it_{current_.values.cbegin()} {} explicit Iterator(Paginator& next_page_provider) noexcept : next_page_provider_(next_page_provider) {} private: Paginator& next_page_provider_; PageResult current_; typename Page::const_iterator it_; // empty i.e. sentinel value }; explicit PaginatedSequence2(Paginator next_page_provider) noexcept : next_page_provider_(std::move(next_page_provider)) {} Task begin() { auto current = co_await next_page_provider_(""); co_return Iterator{next_page_provider_, std::move(current)}; } Iterator end() noexcept { return Iterator{next_page_provider_}; } private: Paginator next_page_provider_; }; using Paginated2Uint64 = PaginatedSequence2; Task paginated_sequence_2_iteration(Paginated2Uint64& paginated) { size_t accumulator{0}; auto it = co_await paginated.begin(); while (it != paginated.end()) { accumulator += *it; const bool next_page = ++it; if (next_page) { co_await it.next_page(); } } co_return accumulator; } static void benchmark_paginated_sequence_2_iteration(benchmark::State& state) { const auto page_size = static_cast(state.range(0)); const auto n = static_cast(state.range(1)); PaginatedSequenceBenchTest test; auto paginated_sequence = make_paginated_sequence(page_size, n); for ([[maybe_unused]] auto _ : state) { const auto result = test.spawn_and_wait(paginated_sequence_2_iteration(paginated_sequence)); benchmark::DoNotOptimize(result); } } BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({100, 1'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({100, 10'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({100, 100'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({1'000, 1'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({1'000, 10'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({1'000, 100'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({10'000, 10'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({10'000, 100'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({10'000, 1'000'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({100'000, 100'001}); BENCHMARK(benchmark_paginated_sequence_2_iteration)->Args({100'000, 1'000'001}); } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/paginated_sequence_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "paginated_sequence.hpp" #include #include #include #include #include namespace silkworm::db::kv::api { using namespace silkworm::test_util; using PaginatedUint64 = PaginatedSequence; using PaginatorUint64 = PaginatedUint64::Paginator; using PageUint64 = PaginatedUint64::Page; using PageUint64List = std::vector; using PageResultUint64 = PaginatedUint64::PageResult; using PaginatedKV = PaginatedSequencePair; using PaginatorKV = PaginatedKV::Paginator; using PageK = PaginatedKV::KPage; using PageV = PaginatedKV::VPage; using PageResultKV = PaginatedKV::PageResult; struct PaginatedSequenceTest : public test_util::ContextTestBase { }; struct TestPaginatorUint64 { explicit TestPaginatorUint64(const PageUint64List& pages) : pages_(pages) {} Task operator()(std::string /*page_token*/) { if (count_ == 0 && pages_.empty()) { co_return PageResultUint64{}; } if (count_ < pages_.size()) { const auto next_token = (count_ != pages_.size() - 1) ? "next" : ""; PageResultUint64 page_result{pages_[count_], next_token}; ++count_; co_return page_result; } throw std::logic_error{"unexpected call to paginator"}; } private: const PageUint64List& pages_; size_t count_{0}; }; TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_uint64_sequence: empty sequence", "[db][kv][api][paginated_sequence]") { PageUint64List empty; TestPaginatorUint64 paginator{empty}; PaginatedUint64 paginated{paginator}; // We're using this lambda instead of built-in paginated_to_vector just to check Iterator::has_next const auto paginated_it_to_vector = [](auto& ps) -> Task> { auto it = co_await ps(); CHECK(!co_await it->has_next()); co_return co_await stream_to_vector(it); }; CHECK(spawn_and_wait(paginated_it_to_vector(paginated)).empty()); } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_uint64_sequence: non-empty sequence", "[db][kv][api][paginated_sequence]") { const Fixtures> fixtures{ {/*page_list=*/{}, /*expected_sequence=*/{}}, {/*page_list=*/{{1}}, /*expected_sequence=*/{1}}, {/*page_list=*/{{1, 2, 3}}, /*expected_sequence=*/{1, 2, 3}}, {/*page_list=*/{{1, 2, 3}, {4, 5, 6}, {7}}, /*expected_sequence=*/{1, 2, 3, 4, 5, 6, 7}}, }; int i = 0; for (const auto& [page_list, expected_sequence] : fixtures) { SECTION("test vector: " + std::to_string(++i)) { TestPaginatorUint64 paginator{page_list}; PaginatedUint64 paginated{paginator}; CHECK(spawn_and_wait(paginated_to_vector(paginated)) == expected_sequence); } } } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_uint64_sequence: error", "[db][kv][api][paginated_sequence]") { PaginatorUint64 paginator = [](std::string) -> Task { static int count{0}; switch (++count) { case 1: co_return PageResultUint64{PageUint64{1, 2, 3}, "next"}; case 2: co_return PageResultUint64{PageUint64{4, 5, 6}, "next"}; case 3: throw std::runtime_error{"error during pagination"}; default: throw std::logic_error{"unexpected call to paginator"}; } }; PaginatedUint64 paginated{paginator}; CHECK_THROWS_AS(spawn_and_wait(paginated_to_vector(paginated)), std::runtime_error); } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_kv_sequence: empty sequence", "[db][kv][api][paginated_sequence]") { PaginatorKV paginator = [](std::string) -> Task { co_return PageResultKV{}; // has_more=false as default }; PaginatedKV paginated{paginator}; // We're using this lambda instead of built-in paginated_to_vector just to check Iterator::has_next const auto paginated_it_to_vector = [](auto& ps) -> Task> { auto it = co_await ps(); CHECK(!co_await it->has_next()); co_return co_await stream_to_vector(it); }; CHECK(spawn_and_wait(paginated_it_to_vector(paginated)).empty()); } static const Bytes kKey1{*from_hex("0011")}, kKey2{*from_hex("0022")}, kKey3{*from_hex("0033")}; static const Bytes kKey4{*from_hex("0044")}, kKey5{*from_hex("0055")}, kKey6{*from_hex("0066")}; static const Bytes kValue1{*from_hex("FF11")}, kValue2{*from_hex("FF22")}, kValue3{*from_hex("FF33")}; static const Bytes kValue4{*from_hex("FF44")}, kValue5{*from_hex("FF55")}, kValue6{*from_hex("FF66")}; TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_kv_sequence: non-empty sequence", "[db][kv][api][paginated_sequence]") { PaginatorKV paginator = [](std::string) -> Task { static int count{0}; switch (++count) { case 1: co_return PageResultKV{PageK{kKey1, kKey2}, PageV{kValue1, kValue2}, "next"}; case 2: co_return PageResultKV{PageK{kKey3, kKey4}, PageV{kValue3, kValue4}, "next"}; case 3: co_return PageResultKV{PageK{kKey5, kKey6}, PageV{kValue5, kValue6}, ""}; default: throw std::logic_error{"unexpected call to paginator"}; } }; PaginatedKV paginated{paginator}; CHECK(spawn_and_wait(paginated_to_vector(paginated)) == std::vector{{kKey1, kValue1}, {kKey2, kValue2}, {kKey3, kValue3}, {kKey4, kValue4}, {kKey5, kValue5}, {kKey6, kValue6}}); } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_kv_sequence: error", "[db][kv][api][paginated_sequence]") { PaginatorKV paginator = [](std::string) -> Task { static int count{0}; switch (++count) { case 1: co_return PageResultKV{PageK{kKey1, kKey2}, PageV{kValue1, kValue2}, "next"}; case 2: co_return PageResultKV{PageK{kKey3, kKey4}, PageV{kValue3, kValue4}, "next"}; case 3: throw std::runtime_error{"error during pagination"}; default: throw std::logic_error{"unexpected call to paginator"}; } }; PaginatedKV paginated{paginator}; CHECK_THROWS_AS(spawn_and_wait(paginated_to_vector(paginated)), std::runtime_error); } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_uint64_sequence: set_intersection", "[db][kv][api][paginated_sequence]") { const Fixtures, std::vector> fixtures{ {{/*v1=*/{}, /*v2=*/{}}, /*v1_and_v2=*/{}}, // both empty => empty {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{}}, /*v1_and_v2=*/{}}, // one empty => empty {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{{10, 11, 12}, {13}}}, /*v1_and_v2=*/{}}, // disjoint => empty {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{{7, 8, 9}, {10, 11, 12}, {13}}}, /*v1_and_v2=*/{7, 8}}, {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}}, /*v1_and_v2=*/{1, 2, 3, 4, 5, 6, 7, 8}}, }; int i = 0; for (const auto& [v1_v2_pair, expected_intersection_set] : fixtures) { const auto& [v1, v2] = v1_v2_pair; TestPaginatorUint64 paginator1{v1}, paginator2{v2}; PaginatedUint64 paginated1{paginator1}, paginated2{paginator2}; SECTION("test vector " + std::to_string(i)) { const auto async_intersection = [&](PaginatedUint64& ps1, PaginatedUint64& ps2) -> Task> { auto it = set_intersection(co_await ps1(), co_await ps2()); CHECK(co_await it->has_next() == !expected_intersection_set.empty()); co_return co_await stream_to_vector(it); }; CHECK(spawn_and_wait(async_intersection(paginated1, paginated2)) == expected_intersection_set); } ++i; } } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_uint64_sequence: set_union", "[db][kv][api][paginated_sequence]") { const Fixtures, std::vector> fixtures{ /* ASCENDING */ {{/*v1=*/{}, /*v2=*/{}, true}, /*v1_or_v2=*/{}}, {{/*v1=*/{{1}}, /*v2=*/{}, true}, /*v1_or_v2=*/{1}}, {{/*v1=*/{}, /*v2=*/{{1}}, true}, /*v1_or_v2=*/{1}}, {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{}, true}, /*v1_or_v2=*/{1, 2, 3, 4, 5, 6, 7, 8}}, {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{{10, 11, 12}, {13}}, true}, /*v1_or_v2=*/{1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13}}, {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{{7, 8, 9}, {10, 11, 12}, {13}}, true}, /*v1_or_v2=*/{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}}, {{/*v1=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, /*v2=*/{{1, 2, 3}, {4, 5, 6}, {7, 8}}, true}, /*v1_and_v2=*/{1, 2, 3, 4, 5, 6, 7, 8}}, /* DESCENDING */ {{/*v1=*/{}, /*v2=*/{}, false}, /*v1_or_v2=*/{}}, {{/*v1=*/{{1}}, /*v2=*/{}, false}, /*v1_or_v2=*/{1}}, {{/*v1=*/{}, /*v2=*/{{1}}, false}, /*v1_or_v2=*/{1}}, {{/*v1=*/{{8, 7}, {6, 5, 4}, {3, 2, 1}}, /*v2=*/{}, false}, /*v1_or_v2=*/{8, 7, 6, 5, 4, 3, 2, 1}}, {{/*v1=*/{{8, 7}, {6, 5, 4}, {3, 2, 1}}, /*v2=*/{{13}, {12, 11, 10}}, false}, /*v1_or_v2=*/{13, 12, 11, 10, 8, 7, 6, 5, 4, 3, 2, 1}}, }; int i = 0; for (const auto& [v1_v2_ascending, expected_union_set] : fixtures) { const auto& [v1, v2, ascending] = v1_v2_ascending; SECTION("test vector " + std::string{ascending ? "ascending" : "descending"} + ": " + std::to_string(i)) { TestPaginatorUint64 paginator1{v1}, paginator2{v2}; PaginatedUint64 paginated1{paginator1}, paginated2{paginator2}; const auto async_union = [&](PaginatedUint64& ps1, PaginatedUint64& ps2) -> Task> { auto it = set_union(co_await ps1(), co_await ps2(), ascending); CHECK(co_await it->has_next() == !expected_union_set.empty()); co_return co_await stream_to_vector(it); }; CHECK(spawn_and_wait(async_union(paginated1, paginated2)) == expected_union_set); } ++i; } } TEST_CASE_METHOD(PaginatedSequenceTest, "range stream", "[db][kv][api][paginated_sequence]") { const Fixtures, std::vector> fixtures{ {/*from, to=*/{0, 0}, /*expected_sequence=*/{}}, {/*from, to=*/{0, 1}, /*expected_sequence=*/{0}}, {/*from, tot=*/{0, 2}, /*expected_sequence=*/{0, 1}}, {/*from, tot=*/{2, 0}, /*expected_sequence=*/{}}}; int i = 0; for (const auto& [pair, expected_sequence] : fixtures) { SECTION("test range: " + std::to_string(++i)) { auto stream = make_range_stream(pair.first, pair.second); auto sequence = spawn_and_wait(stream_to_vector(stream)); CHECK(sequence == expected_sequence); } } } TEST_CASE_METHOD(PaginatedSequenceTest, "empty iterators", "[db][kv][api][paginated_sequence]") { EmptyIterator empty_it_u64; CHECK_FALSE(spawn_and_wait(empty_it_u64.has_next())); CHECK(spawn_and_wait(empty_it_u64.next()) == std::nullopt); EmptyIterator empty_it_kv; CHECK(spawn_and_wait(empty_it_kv.next()) == std::nullopt); } struct TestPaginatorKV { explicit TestPaginatorKV(const std::vector& k_pages, const std::vector& v_pages) : k_pages_(k_pages), v_pages_(v_pages) { SILKWORM_ASSERT(k_pages_.size() == v_pages_.size()); } Task operator()(std::string /*page_token*/) { if (count_ == 0 && k_pages_.empty()) { co_return PageResultKV{}; } if (count_ < k_pages_.size()) { const auto next_token = (count_ != k_pages_.size() - 1) ? "next" : ""; PageResultKV page_result{k_pages_[count_], v_pages_[count_], next_token}; ++count_; co_return page_result; } throw std::logic_error{"unexpected call to paginator"}; } private: const std::vector& k_pages_; const std::vector& v_pages_; size_t count_{0}; }; using KVPagesPair = std::pair, std::vector>; TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_kv_sequence: set_union", "[db][kv][api][paginated_sequence]") { const Fixtures, std::vector> fixtures{ /* ASCENDING */ {{/*v1=*/{{}, {}}, /*v2=*/{{}, {}}, true}, /*v1_or_v2=*/{}}, {{/*v1=*/{/*k_pages=*/{{kKey1}}, /*v_pages=*/{{kValue1}}}, /*v2=*/{}, true}, /*v1_or_v2=*/{{kKey1, kValue1}}}, {{/*v1=*/{/*k_pages=*/{{kKey1, kKey2}}, /*v_pages=*/{{kValue1, kValue2}}}, /*v2=*/{}, true}, /*v1_or_v2=*/{{kKey1, kValue1}, {kKey2, kValue2}}}, {{/*v1=*/{}, /*v2=*/{/*k_pages=*/{{kKey1, kKey2}}, /*v_pages=*/{{kValue1, kValue2}}}, true}, /*v1_or_v2=*/{{kKey1, kValue1}, {kKey2, kValue2}}}, /* DESCENDING */ {{/*v1=*/{{}, {}}, /*v2=*/{{}, {}}, false}, /*v1_or_v2=*/{}}, {{/*v1=*/{/*k_pages=*/{{kKey1}}, /*v_pages=*/{{kValue1}}}, /*v2=*/{}, false}, /*v1_or_v2=*/{{kKey1, kValue1}}}, {{/*v1=*/{/*k_pages=*/{{kKey2, kKey1}}, /*v_pages=*/{{kValue2, kValue1}}}, /*v2=*/{}, false}, /*v1_or_v2=*/{{kKey2, kValue2}, {kKey1, kValue1}}}, {{/*v1=*/{}, /*v2=*/{/*k_pages=*/{{kKey2, kKey1}}, /*v_pages=*/{{kValue2, kValue1}}}, false}, /*v1_or_v2=*/{{kKey2, kValue2}, {kKey1, kValue1}}}, }; int i = 0; for (const auto& [v1_v2_ascending, expected_union_set] : fixtures) { const auto& [v1, v2, ascending] = v1_v2_ascending; TestPaginatorKV paginator1{v1.first, v1.second}, paginator2{v2.first, v2.second}; PaginatedKV paginated1{paginator1}, paginated2{paginator2}; SECTION("test vector " + std::string{ascending ? "ascending" : "descending"} + ": " + std::to_string(i)) { const auto async_union = [&](PaginatedKV& ps1, PaginatedKV& ps2) -> Task> { auto it = set_union(co_await ps1(), co_await ps2(), ascending); CHECK(co_await it->has_next() == !expected_union_set.empty()); co_return co_await stream_to_vector(it); }; CHECK(spawn_and_wait(async_union(paginated1, paginated2)) == expected_union_set); } ++i; } } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_uint64_sequence: nested intersection", "[db][kv][api][paginated_sequence]") { SECTION("2 null streams") { Stream n1; Stream n2; const auto n1_n2_intersection = set_intersection(std::move(n1), std::move(n2)); CHECK_FALSE(spawn_and_wait(n1_n2_intersection->has_next())); CHECK(spawn_and_wait(n1_n2_intersection->next()) == std::nullopt); } SECTION("2 empty streams") { Stream e1 = std::make_unique>(); Stream e2 = std::make_unique>(); const auto e1_e2_intersection = set_intersection(std::move(e1), std::move(e2)); CHECK_FALSE(spawn_and_wait(e1_e2_intersection->has_next())); CHECK(spawn_and_wait(e1_e2_intersection->next()) == std::nullopt); } SECTION("1 empty stream 1 non-empty stream") { const auto async_union_with_empty = [&](PaginatedUint64& ps) -> Task> { Stream empty = std::make_unique>(); auto stream = co_await ps(); auto intersection_stream = set_intersection(std::move(stream), std::move(empty)); co_return co_await stream_to_vector(intersection_stream); }; PageUint64List v{{1, 2, 3}, {4, 5, 6}, {7, 8}}; TestPaginatorUint64 paginator{v}; PaginatedUint64 paginated{paginator}; CHECK(spawn_and_wait(async_union_with_empty(paginated)).empty()); } SECTION("nesting streams") { const auto nested_intersection = [&](std::vector ps_list) -> Task> { Stream intersection_stream; for (auto& ps : ps_list) { intersection_stream = set_intersection(std::move(intersection_stream), co_await ps()); } co_return co_await stream_to_vector(intersection_stream); }; CHECK(spawn_and_wait(nested_intersection(std::vector{})).empty()); } } TEST_CASE_METHOD(PaginatedSequenceTest, "paginated_uint64_sequence: nested unions", "[db][kv][api][paginated_sequence]") { SECTION("2 null streams") { Stream n1; Stream n2; const auto n1_n2_union = set_union(std::move(n1), std::move(n2)); CHECK_FALSE(spawn_and_wait(n1_n2_union->has_next())); CHECK(spawn_and_wait(n1_n2_union->next()) == std::nullopt); } SECTION("2 empty streams") { Stream e1 = std::make_unique>(); Stream e2 = std::make_unique>(); const auto e1_e2_union = set_union(std::move(e1), std::move(e2)); CHECK_FALSE(spawn_and_wait(e1_e2_union->has_next())); CHECK(spawn_and_wait(e1_e2_union->next()) == std::nullopt); } SECTION("1 empty stream 1 non-empty stream") { const auto async_union_with_empty = [&](PaginatedUint64& ps1) -> Task> { Stream empty = std::make_unique>(); auto stream = co_await ps1(); auto union_stream = set_union(std::move(stream), std::move(empty)); co_return co_await stream_to_vector(union_stream); }; PageUint64List v{{1, 2, 3}, {4, 5, 6}, {7, 8}}; TestPaginatorUint64 paginator{v}; PaginatedUint64 paginated{paginator}; CHECK(spawn_and_wait(async_union_with_empty(paginated)) == std::vector{1, 2, 3, 4, 5, 6, 7, 8}); } SECTION("nesting streams") { const auto nested_union = [&](std::vector ps_list) -> Task> { Stream union_stream; for (auto& ps : ps_list) { union_stream = set_union(std::move(union_stream), co_await ps()); } co_return co_await stream_to_vector(union_stream); }; CHECK(spawn_and_wait(nested_union(std::vector{})).empty()); } } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/sequence.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include "key_value.hpp" namespace silkworm::db::kv::api { template concept Value = std::copyable; //! Definition of asynchronous iterator (a.k.a. stream) template struct StreamIterator { virtual ~StreamIterator() = default; virtual Task has_next() = 0; virtual Task> next() = 0; }; template using Stream = std::unique_ptr>; //! Empty iterator template class EmptyIterator : public StreamIterator { public: using value_type = V; Task has_next() override { co_return false; } Task> next() override { co_return std::nullopt; } }; template using EmptyStream = std::unique_ptr>; template using StreamFactory = std::function>()>; template auto EmptyStreamFactory = []() -> Task> { co_return std::make_unique>(); }; template class StreamReply { public: explicit StreamReply(StreamFactory factory) : factory_(std::move(factory)) {} Task> begin() const { co_return co_await factory_(); } private: StreamFactory factory_; }; template Task> stream_to_vector(const Stream& it) { std::vector all_values; if (!it) { co_return all_values; } while (const auto value = co_await it->next()) { all_values.emplace_back(*value); } co_return all_values; } template Task> stream_to_vector(const StreamReply& reply) { auto it = co_await reply.begin(); co_return co_await stream_to_vector(it); } //! Stream iterator implementing 'intersection' set operation between 2 stream iterators template class IntersectionIterator : public StreamIterator { public: using value_type = V; IntersectionIterator(Stream it1, Stream it2, size_t limit) : it1_(std::move(it1)), it2_(std::move(it2)), limit_(limit) {} Task has_next() override { if (!initialized_) { initialized_ = true; co_await advance(); } co_return limit_ != 0 && next_v1_&& next_v2_; } Task> next() override { if (limit_ == 0) { co_return std::nullopt; } --limit_; if (!initialized_) { initialized_ = true; co_await advance(); } const auto next_v1 = next_v1_; co_await advance(); co_return next_v1; } private: Task> advance() { next_v1_ = co_await it1_->next(); next_v2_ = co_await it2_->next(); while (next_v1_ && next_v2_) { if (*next_v1_ < *next_v2_) { next_v1_ = co_await it1_->next(); continue; } if (*next_v1_ == *next_v2_) { co_return next_v1_; // *next_v2_ and *next_v2_ are equivalent } else { next_v2_ = co_await it2_->next(); continue; } } next_v1_.reset(); next_v2_.reset(); co_return std::nullopt; } bool initialized_{false}; Stream it1_; Stream it2_; std::optional next_v1_; std::optional next_v2_; size_t limit_; }; template Stream set_intersection(Stream it1, Stream it2, size_t limit = std::numeric_limits::max()) { if (!it1 || !it2) { return std::make_unique>(); } return std::make_unique>(std::move(it1), std::move(it2), limit); } //! Stream iterator implementing 'union' set operation between 2 stream iterators template class UnionIterator : public StreamIterator { public: using value_type = V; UnionIterator(Stream it1, Stream it2, bool ascending, size_t limit) : it1_(std::move(it1)), it2_(std::move(it2)), ascending_(ascending), limit_(limit) {} Task has_next() override { co_return limit_ != 0 && (co_await it1_->has_next() || co_await it2_->has_next() || next_v1_ || next_v2_); } Task> next() override { if (limit_ == 0) { co_return std::nullopt; } --limit_; if (!next_v1_ && co_await it1_->has_next()) { next_v1_ = co_await it1_->next(); } if (!next_v2_ && co_await it2_->has_next()) { next_v2_ = co_await it2_->next(); } if (!next_v1_ && !next_v2_) { co_return std::nullopt; } if (next_v1_ && next_v2_) { if ((ascending_ && *next_v1_ < *next_v2_) || (!ascending_ && *next_v1_ > *next_v2_)) { const auto v1 = *next_v1_; next_v1_ = co_await it1_->next(); co_return v1; } else if (*next_v1_ == *next_v2_) { const auto v1 = *next_v1_; next_v1_ = co_await it1_->next(); next_v2_ = co_await it2_->next(); co_return v1; // *v1 and *v2 are equivalent } const auto v2 = *next_v2_; next_v2_ = co_await it2_->next(); co_return v2; } if (next_v1_) { const auto v1 = *next_v1_; next_v1_ = co_await it1_->next(); co_return v1; } const auto v2 = *next_v2_; next_v2_ = co_await it2_->next(); co_return v2; } private: Stream it1_; Stream it2_; std::optional next_v1_; std::optional next_v2_; bool ascending_; size_t limit_; }; template Stream set_union(Stream it1, Stream it2, bool ascending = true, size_t limit = std::numeric_limits::max()) { if (!it1 && !it2) { return std::make_unique>(); } if (!it1) { return it2; } if (!it2) { return it1; } return std::make_unique>(std::move(it1), std::move(it2), ascending, limit); } template class RangeIterator : public StreamIterator { public: using value_type = V; RangeIterator(V from, V to) : current_(from), to_(to) {} Task has_next() override { co_return current_ < to_; } Task> next() override { if (current_ >= to_) { co_return std::nullopt; } co_return current_++; } private: V current_; V to_; }; template Stream make_range_stream(V from, V to) { return std::make_unique>(from, to); } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/state_change.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "common.hpp" namespace silkworm::db::kv::api { struct StateChangeOptions { bool with_storage{false}; bool with_transactions{false}; CancellationToken* cancellation_token{nullptr}; }; enum Action : uint8_t { kStorage, kUpsert, kCode, kUpsertCode, kRemove, }; struct StorageChange { Hash location; Bytes data; }; using StorageChangeSequence = std::vector; struct AccountChange { evmc::address address; uint64_t incarnation{0}; Action change_type{kStorage}; Bytes data; Bytes code; StorageChangeSequence storage_changes; }; using AccountChangeSequence = std::vector; enum Direction : uint8_t { kForward, kUnwind, }; struct StateChange { Direction direction{kForward}; BlockNum block_num{0}; Hash block_hash; AccountChangeSequence account_changes; ListOfBytes rlp_txs; // Enabled using StateChangeOptions::with_transactions=true }; using StateChangeSequence = std::vector; struct StateChangeSet { uint64_t state_version_id{0}; // Unique id of MDBX write transaction where this changes happened uint64_t pending_block_base_fee{0}; // Base fee of the next block to be produced uint64_t block_gas_limit{0}; // Gas limit of the latest block (proxy for the gas limit of the next block to be produced) BlockNum finalized_block{0}; uint64_t pending_blob_fee_per_gas{0}; // Base blob fee for the next block to be produced StateChangeSequence state_changes; }; using StateChangeConsumer = std::function(std::optional)>; inline bool operator==(const StorageChange& lhs, const StorageChange& rhs) { if (lhs.location != rhs.location) return false; if (lhs.data != rhs.data) return false; return true; } inline bool operator==(const AccountChange& lhs, const AccountChange& rhs) { if (lhs.address != rhs.address) return false; if (lhs.incarnation != rhs.incarnation) return false; if (lhs.change_type != rhs.change_type) return false; if (lhs.data != rhs.data) return false; if (lhs.code != rhs.code) return false; if (lhs.storage_changes != rhs.storage_changes) return false; return true; } inline bool operator==(const StateChange& lhs, const StateChange& rhs) { if (lhs.direction != rhs.direction) return false; if (lhs.block_num != rhs.block_num) return false; if (lhs.block_hash != rhs.block_hash) return false; if (lhs.account_changes != rhs.account_changes) return false; if (lhs.rlp_txs != rhs.rlp_txs) return false; return true; } inline bool operator==(const StateChangeSet& lhs, const StateChangeSet& rhs) { if (lhs.state_version_id != rhs.state_version_id) return false; if (lhs.pending_block_base_fee != rhs.pending_block_base_fee) return false; if (lhs.block_gas_limit != rhs.block_gas_limit) return false; if (lhs.finalized_block != rhs.finalized_block) return false; if (lhs.pending_blob_fee_per_gas != rhs.pending_blob_fee_per_gas) return false; if (lhs.state_changes != rhs.state_changes) return false; return true; } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/state_changes_call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "state_change.hpp" namespace silkworm::db::kv::api { using StateChangeChannel = concurrency::Channel>; using StateChangeChannelPtr = std::shared_ptr; class StateChangesCall final { public: using StateChangeChannelPromise = concurrency::AwaitablePromise; StateChangesCall(StateChangeOptions options, const boost::asio::any_io_executor& executor) : options_(options), channel_promise_(std::make_shared(executor)), unsubscribe_signal_(std::make_shared(executor)) {} StateChangesCall() = default; const StateChangeOptions& options() const { return options_; } Task result() { auto future = channel_promise_->get_future(); co_return co_await future.get_async(); } void set_result(StateChangeChannelPtr channel) { channel_promise_->set_value(std::move(channel)); } std::shared_ptr unsubscribe_signal() const { return unsubscribe_signal_; } private: StateChangeOptions options_; std::shared_ptr channel_promise_; std::shared_ptr unsubscribe_signal_; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/state_changes_call_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_changes_call.hpp" #include #include namespace silkworm::db::kv::api { struct StateChangesCallTest : public test_util::KVTestBase { Task> client_receive_one(StateChangesCall& call) const { auto client_channel = co_await call.result(); co_return co_await client_channel->receive(); } Task> client_receive_all_until_closed(StateChangesCall& call) const { auto client_channel = co_await call.result(); std::vector change_set_sequence; while (true) { auto change_set = co_await client_channel->receive(); if (!change_set) break; change_set_sequence.emplace_back(std::move(*change_set)); } co_return change_set_sequence; } StateChangeChannelPtr channel{std::make_shared(ioc_.get_executor())}; }; TEST_CASE_METHOD(StateChangesCallTest, "one state change set", "[db][kv][api][state_changes_call]") { StateChangesCall call{StateChangeOptions{}, ioc_.get_executor()}; call.set_result(channel); auto change_set_future = spawn(client_receive_one(call)); const StateChangeSet empty_change_set{}; spawn(channel->send(empty_change_set)); CHECK(change_set_future.get() == empty_change_set); } TEST_CASE_METHOD(StateChangesCallTest, "many state change sets", "[db][kv][api][state_changes_call]") { StateChangesCall call{StateChangeOptions{}, ioc_.get_executor()}; call.set_result(channel); auto change_set_vector_future = spawn(client_receive_all_until_closed(call)); const std::vector change_set_vector{StateChangeSet{}, StateChangeSet{}, StateChangeSet{}}; for (const auto& change_set : change_set_vector) { spawn(channel->send(change_set)); } spawn(channel->send({})); CHECK(change_set_vector_future.get() == change_set_vector); } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/temporal_point.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "common.hpp" namespace silkworm::db::kv::api { struct PointResult { bool success{false}; Bytes value; }; struct HistoryPointRequest { TxId tx_id{0}; std::string table; Bytes key; Timestamp timestamp{0}; }; using HistoryPointResult = PointResult; struct GetLatestRequest { TxId tx_id{0}; std::string table; Bytes key; Bytes sub_key; // TODO(canepat) we need clang >= 17 to use spaceship operator instead of hand-made operator== below // auto operator<=>(const GetLatestRequest&) const = default; }; inline bool operator==(const GetLatestRequest& lhs, const GetLatestRequest& rhs) { return (lhs.tx_id == rhs.tx_id) && (lhs.table == rhs.table) && (lhs.key == rhs.key) && (lhs.sub_key == rhs.sub_key); } using GetLatestResult = PointResult; struct GetAsOfRequest { TxId tx_id{0}; std::string table; Bytes key; Bytes sub_key; Timestamp timestamp; // TODO(canepat) we need clang >= 17 to use spaceship operator instead of hand-made operator== below // auto operator<=>(const GetAsOfRequest&) const = default; }; inline bool operator==(const GetAsOfRequest& lhs, const GetAsOfRequest& rhs) { return (lhs.tx_id == rhs.tx_id) && (lhs.table == rhs.table) && (lhs.key == rhs.key) && (lhs.sub_key == rhs.sub_key) && (lhs.timestamp == rhs.timestamp); } using GetAsOfResult = PointResult; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/temporal_range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "common.hpp" #include "sequence.hpp" namespace silkworm::db::kv::api { //! Unlimited range size in range queries inline constexpr int64_t kUnlimited{-1}; //! Infinite timestamp value in range queries inline constexpr Timestamp kInfinite{-1}; struct IndexRangeRequest { TxId tx_id{0}; std::string table; Bytes key; Timestamp from_timestamp; Timestamp to_timestamp; bool ascending_order{false}; int64_t limit{kUnlimited}; uint32_t page_size{0}; std::string page_token; }; struct IndexRangeResult { ListOfTimestamp timestamps; std::string next_page_token; }; struct RangeResult { ListOfBytes keys; ListOfBytes values; std::string next_page_token; }; struct HistoryRangeRequest { TxId tx_id{0}; std::string table; Timestamp from_timestamp; Timestamp to_timestamp; bool ascending_order{false}; int64_t limit{kUnlimited}; uint32_t page_size{0}; std::string page_token; // TODO(canepat) we need clang >= 17 to use spaceship operator instead of hand-made operator== below // auto operator<=>(const HistoryRangeRequest&) const = default; }; inline bool operator==(const HistoryRangeRequest& lhs, const HistoryRangeRequest& rhs) { return (lhs.tx_id == rhs.tx_id) && (lhs.table == rhs.table) && (lhs.from_timestamp == rhs.from_timestamp) && (lhs.to_timestamp == rhs.to_timestamp) && (lhs.ascending_order == rhs.ascending_order) && (lhs.limit == rhs.limit) && (lhs.page_size == rhs.page_size) && (lhs.page_token == rhs.page_token); } using HistoryRangeResult = RangeResult; struct DomainRangeRequest { TxId tx_id{0}; std::string table; Bytes from_key; Bytes to_key; std::optional timestamp; // not present means 'latest state' (no history lookup) bool ascending_order{false}; int64_t limit{kUnlimited}; uint32_t page_size{0}; std::string page_token; bool skip_empty_values{false}; }; using DomainRangeResult = RangeResult; using RawKeyValue = std::pair; using TimestampStream = Stream; using KeyValueStream = Stream; using TimestampStreamFactory = StreamFactory; using KeyValueStreamFactory = StreamFactory; using TimestampStreamReply = StreamReply; using KeyValueStreamReply = StreamReply; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/endpoint/version.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::db::kv::api { using Version = std::tuple; //! Current KV API protocol version. inline constexpr Version kCurrentVersion{5, 1, 0}; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/local_cursor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "local_cursor.hpp" #include #include #include #include namespace silkworm::db::kv::api { using namespace silkworm::datastore::kvdb; using datastore::kvdb::detail::slice_as_hex; Task LocalCursor::open_cursor(std::string_view table_name, bool is_dup_sorted) { const auto start_time = clock_time::now(); SILK_DEBUG << "LocalCursor::open_cursor opening new cursor for table: " << table_name; db_cursor_ = PooledCursor{txn_, MapConfig{ .name = table_name, .value_mode = is_dup_sorted ? ::mdbx::value_mode::multi : ::mdbx::value_mode::single}}; SILK_DEBUG << "LocalCursor::open_cursor [" << table_name << "] c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return; } Task LocalCursor::seek(ByteView key) { SILK_DEBUG << "LocalCursor::seek cursor: " << cursor_id_ << " key: " << key; mdbx::slice mdbx_key{key}; const auto result = (key.empty()) ? db_cursor_.to_first(/*throw_notfound=*/false) : db_cursor_.lower_bound(mdbx_key, /*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::seek result: " << detail::dump_mdbx_result(result); if (result) { SILK_DEBUG << "LocalCursor::seek found: key: " << key << " value: " << slice_as_hex(result.value); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } else { SILK_DEBUG << "LocalCursor::seek not found key: " << key; co_return KeyValue{}; } } Task LocalCursor::seek_exact(ByteView key) { SILK_DEBUG << "LocalCursor::seek_exact cursor: " << cursor_id_ << " key: " << key; const bool found = db_cursor_.seek(key); if (found) { const auto result = db_cursor_.current(/*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::seek_exact result: " << detail::dump_mdbx_result(result); if (result) { SILK_DEBUG << "LocalCursor::seek_exact found: key: " << key << " value: " << slice_as_hex(result.value); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } SILK_ERROR << "LocalCursor::seek_exact !result key: " << key; // TODO(canepat) handle properly? } co_return KeyValue{}; } Task LocalCursor::first() { SILK_DEBUG << "LocalCursor::first: " << cursor_id_; const auto result = db_cursor_.to_first(/*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::first result: " << detail::dump_mdbx_result(result); if (!result.done) { co_return KeyValue{}; } SILK_DEBUG << "LocalCursor::first: key: " << slice_as_hex(result.key) << " value: " << slice_as_hex(result.value); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } Task LocalCursor::last() { SILK_DEBUG << "LocalCursor::last: " << cursor_id_; const auto result = db_cursor_.to_last(/*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::last result: " << detail::dump_mdbx_result(result); if (!result.done) { co_return KeyValue{}; } SILK_DEBUG << "LocalCursor::last: key: " << slice_as_hex(result.key) << " value: " << slice_as_hex(result.value); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } Task LocalCursor::next() { SILK_DEBUG << "LocalCursor::next: " << cursor_id_; const auto result = db_cursor_.to_next(/*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::next result: " << detail::dump_mdbx_result(result); if (result) { SILK_DEBUG << "LocalCursor::next: " << " key: " << string_view_to_byte_view(result.key.as_string()) << " value: " << string_view_to_byte_view(result.value.as_string()); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } else { SILK_ERROR << "LocalCursor::next !result"; // TODO(canepat) handle properly? } co_return KeyValue{}; } Task LocalCursor::previous() { SILK_DEBUG << "LocalCursor::previous: " << cursor_id_; const auto result = db_cursor_.to_previous(/*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::previous result: " << detail::dump_mdbx_result(result); if (result) { SILK_DEBUG << "LocalCursor::previous: " << " key: " << string_view_to_byte_view(result.key.as_string()) << " value: " << string_view_to_byte_view(result.value.as_string()); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } else { SILK_ERROR << "LocalCursor::previous !result"; // TODO(canepat) handle properly? } co_return KeyValue{}; } Task LocalCursor::next_dup() { SILK_DEBUG << "LocalCursor::next_dup: " << cursor_id_; const auto result = db_cursor_.to_current_next_multi(/*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::next_dup result: " << detail::dump_mdbx_result(result); if (result) { SILK_DEBUG << "LocalCursor::next_dup: " << " key: " << string_view_to_byte_view(result.key.as_string()) << " value: " << string_view_to_byte_view(result.value.as_string()); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } else { SILK_ERROR << "LocalCursor::next_dup !result"; // TODO(canepat) handle properly? } co_return KeyValue{}; } Task LocalCursor::seek_both(ByteView key, ByteView value) { SILK_DEBUG << "LocalCursor::seek_both cursor: " << cursor_id_ << " key: " << key << " subkey: " << value; const auto result = db_cursor_.lower_bound_multivalue(key, value, /*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::seek_both result: " << detail::dump_mdbx_result(result); if (result) { SILK_DEBUG << "LocalCursor::seek_both key: " << string_view_to_byte_view(result.key.as_string()) << " value: " << string_view_to_byte_view(result.value.as_string()); co_return string_to_bytes(result.value.as_string()); } co_return string_to_bytes(""); } Task LocalCursor::seek_both_exact(ByteView key, ByteView value) { SILK_DEBUG << "LocalCursor::seek_both_exact cursor: " << cursor_id_ << " key: " << key << " subkey: " << value; const auto result = db_cursor_.find_multivalue(key, value, /*throw_notfound=*/false); SILK_DEBUG << "LocalCursor::seek_both_exact result: " << detail::dump_mdbx_result(result); if (result) { SILK_DEBUG << "LocalCursor::seek_both_exact: " << " key: " << string_view_to_byte_view(result.key.as_string()) << " value: " << string_view_to_byte_view(result.value.as_string()); co_return KeyValue{string_to_bytes(result.key.as_string()), string_to_bytes(result.value.as_string())}; } else { SILK_ERROR << "LocalCursor::seek_both_exact !found key: " << key << " subkey:" << value; } co_return KeyValue{}; } Task LocalCursor::close_cursor() { SILK_DEBUG << "LocalCursor::close_cursor c=" << cursor_id_; cursor_id_ = 0; co_return; } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/local_cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "cursor.hpp" namespace silkworm::db::kv::api { class LocalCursor : public CursorDupSort { public: LocalCursor(mdbx::txn& txn, uint32_t cursor_id) : cursor_id_{cursor_id}, txn_{txn} {} uint32_t cursor_id() const override { return cursor_id_; }; Task open_cursor(std::string_view table_name, bool is_dup_sorted) override; Task seek(ByteView key) override; Task seek_exact(ByteView key) override; Task first() override; Task last() override; Task next() override; Task previous() override; Task next_dup() override; Task close_cursor() override; Task seek_both(ByteView key, ByteView value) override; Task seek_both_exact(ByteView key, ByteView value) override; private: uint32_t cursor_id_; datastore::kvdb::PooledCursor db_cursor_; mdbx::txn& txn_; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/local_cursor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "local_cursor.hpp" #include #include #include #include #include #include "../../tables.hpp" namespace silkworm::db::kv::api { using namespace silkworm::test_util; using datastore::kvdb::ROTxnManaged; using silkworm::test_util::ContextTestBase; using test_util::TestDatabaseContext; struct LocalCursorTest : public ContextTestBase { TemporaryDirectory tmp_dir; TestDatabaseContext database{tmp_dir}; static inline uint32_t last_cursor_id{0}; datastore::kvdb::ROAccess chaindata() const { return database.chaindata(); } }; // In all following tests we need to create the MDBX transaction using the io_context scheduler thread, so we simply // wrap the test body into a coroutine lamda run onto the scheduler facility provided by ContextTestBase. TEST_CASE_METHOD(LocalCursorTest, "LocalCursor::open_cursor", "[db][kv][api][local_cursor]") { spawn_and_wait([&]() -> Task { ROTxnManaged txn = chaindata().start_ro_tx(); LocalCursor cursor{txn, ++last_cursor_id}; CHECK_NOTHROW(co_await cursor.open_cursor(table::kHeadersName, /*is_dup_sorted=*/false)); CHECK(cursor.cursor_id() > 0); }); } TEST_CASE_METHOD(LocalCursorTest, "LocalCursor::close_cursor", "[db][kv][api][local_cursor]") { spawn_and_wait([&]() -> Task { ROTxnManaged txn = chaindata().start_ro_tx(); LocalCursor cursor{txn, ++last_cursor_id}; REQUIRE_NOTHROW(co_await cursor.open_cursor(table::kHeadersName, /*is_dup_sorted=*/false)); REQUIRE(cursor.cursor_id() > 0); CHECK_NOTHROW(co_await cursor.close_cursor()); CHECK(cursor.cursor_id() == 0); }); } static auto decode_header(ByteView data_view) { BlockHeader header; return rlp::decode(data_view, header); } TEST_CASE_METHOD(LocalCursorTest, "LocalCursor::first", "[db][kv][api][local_cursor]") { spawn_and_wait([&]() -> Task { ROTxnManaged txn = chaindata().start_ro_tx(); LocalCursor cursor{txn, ++last_cursor_id}; REQUIRE_NOTHROW(co_await cursor.open_cursor(table::kHeadersName, /*is_dup_sorted=*/false)); KeyValue k_and_v{}; CHECK_NOTHROW((k_and_v = co_await cursor.first())); CHECK(k_and_v.key == block_key(0, Hash{0x51181a9927eef038d77a7be22d9555af451cfba4bf4fd02e43ea592c1687eb98_bytes32}.bytes)); CHECK(decode_header(k_and_v.value)); REQUIRE_NOTHROW(co_await cursor.close_cursor()); }); } TEST_CASE_METHOD(LocalCursorTest, "LocalCursor::last", "[db][kv][api][local_cursor]") { spawn_and_wait([&]() -> Task { ROTxnManaged txn = chaindata().start_ro_tx(); LocalCursor cursor{txn, ++last_cursor_id}; REQUIRE_NOTHROW(co_await cursor.open_cursor(table::kHeadersName, /*is_dup_sorted=*/false)); KeyValue k_and_v{}; CHECK_NOTHROW((k_and_v = co_await cursor.last())); CHECK(k_and_v.key == block_key(9, Hash{0x9032fd0afc97b3c5b28fe887051ecb2cc3a3475c102b0aeeaadaebd87d8e1cd3_bytes32}.bytes)); CHECK(decode_header(k_and_v.value)); REQUIRE_NOTHROW(co_await cursor.close_cursor()); }); } TEST_CASE_METHOD(LocalCursorTest, "LocalCursor::next", "[db][kv][api][local_cursor]") { spawn_and_wait([&]() -> Task { ROTxnManaged txn = chaindata().start_ro_tx(); LocalCursor cursor{txn, ++last_cursor_id}; REQUIRE_NOTHROW(co_await cursor.open_cursor(table::kHeadersName, /*is_dup_sorted=*/false)); KeyValue k_and_v{}; CHECK_NOTHROW((k_and_v = co_await cursor.next())); CHECK(k_and_v.key == block_key(0, Hash{0x51181a9927eef038d77a7be22d9555af451cfba4bf4fd02e43ea592c1687eb98_bytes32}.bytes)); CHECK(decode_header(k_and_v.value)); CHECK_NOTHROW((k_and_v = co_await cursor.next())); CHECK(k_and_v.key == block_key(1, Hash{0x7cb4dd3daba1f739d0c1ec7d998b4a2f6fd83019116455afa54ca4f49dfa0ad4_bytes32}.bytes)); CHECK(decode_header(k_and_v.value)); REQUIRE_NOTHROW(co_await cursor.close_cursor()); }); } TEST_CASE_METHOD(LocalCursorTest, "LocalCursor::previous", "[db][kv][api][local_cursor]") { spawn_and_wait([&]() -> Task { ROTxnManaged txn = chaindata().start_ro_tx(); LocalCursor cursor{txn, ++last_cursor_id}; REQUIRE_NOTHROW(co_await cursor.open_cursor(table::kHeadersName, /*is_dup_sorted=*/false)); KeyValue k_and_v{}; CHECK_NOTHROW((k_and_v = co_await cursor.last())); CHECK_NOTHROW((k_and_v = co_await cursor.previous())); CHECK(k_and_v.key == block_key(8, Hash{0x3d50efbbad1818ab34b8d2fd272aa0d149225e7c489b9f955b7758ad7c5918df_bytes32}.bytes)); CHECK(decode_header(k_and_v.value)); CHECK_NOTHROW((k_and_v = co_await cursor.previous())); CHECK(k_and_v.key == block_key(7, Hash{0xa5c7bcf72090b64c6f00fae9897096b7f1593358d4915dc30b4e60f13ce6e301_bytes32}.bytes)); CHECK(decode_header(k_and_v.value)); REQUIRE_NOTHROW(co_await cursor.close_cursor()); }); } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/local_transaction.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "local_transaction.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "as_datastore_ts_range.hpp" namespace silkworm::db::kv::api { using namespace silkworm::datastore; static const std::map kTable2EntityNames{ {table::kAccountDomain, state::kDomainNameAccounts}, {table::kStorageDomain, state::kDomainNameStorage}, {table::kCodeDomain, state::kDomainNameCode}, {table::kCommitmentDomain, state::kDomainNameCommitment}, {table::kReceiptDomain, state::kDomainNameReceipts}, {table::kAccountsHistoryIdx, state::kDomainNameAccounts}, {table::kStorageHistoryIdx, state::kDomainNameStorage}, {table::kCodeHistoryIdx, state::kDomainNameCode}, {table::kCommitmentHistoryIdx, state::kDomainNameCommitment}, {table::kReceiptHistoryIdx, state::kDomainNameReceipts}, {table::kTracesFromIdx, state::kInvIdxNameTracesFrom}, {table::kTracesToIdx, state::kInvIdxNameTracesTo}, {table::kLogAddrIdx, state::kInvIdxNameLogAddress}, {table::kLogTopicIdx, state::kInvIdxNameLogTopics}, }; using RawDomainGetLatestQuery = DomainGetLatestQuery< kvdb::RawEncoder, snapshots::RawEncoder, kvdb::RawDecoder, snapshots::RawDecoder>; template using RawDomainGetAsOfQuery = DomainGetAsOfQuery< kvdb::RawEncoder, snapshots::RawEncoder, kvdb::RawDecoder, snapshots::RawDecoder, history_segment_names>; using AccountsDomainGetAsOfQuery = RawDomainGetAsOfQuery; using StorageDomainGetAsOfQuery = RawDomainGetAsOfQuery; using CodeDomainGetAsOfQuery = RawDomainGetAsOfQuery; using CommitmentDomainGetAsOfQuery = RawDomainGetAsOfQuery; using ReceiptsDomainGetAsOfQuery = RawDomainGetAsOfQuery; template using RawHistoryGetQuery = HistoryGetQuery< kvdb::RawEncoder, snapshots::RawEncoder, kvdb::RawDecoder, snapshots::RawDecoder, history_segment_names>; using AccountsHistoryGetQuery = RawHistoryGetQuery; using StorageHistoryGetQuery = RawHistoryGetQuery; using CodeHistoryGetQuery = RawHistoryGetQuery; using CommitmentHistoryGetQuery = RawHistoryGetQuery; using ReceiptsHistoryGetQuery = RawHistoryGetQuery; using RawInvertedIndexRangeByKeyQuery = InvertedIndexRangeByKeyQuery< kvdb::RawEncoder, snapshots::RawEncoder>; // TODO(canepat) try ByteView using RawInvertedIndexRangeByKeyQueryResult = InvertedIndexRangeByKeyQueryResult< kvdb::RawEncoder, snapshots::RawEncoder>; using RawHistoryRangeInPeriodQuery = HistoryRangeInPeriodQuery< kvdb::RawDecoder, snapshots::RawDecoder, kvdb::RawDecoder, snapshots::RawDecoder>; using RawHistoryRangeInPeriodQueryResult = HistoryRangeInPeriodQueryResult< kvdb::RawDecoder, snapshots::RawDecoder, kvdb::RawDecoder, snapshots::RawDecoder>; using RawDomainRangeAsOfQuery = DomainRangeAsOfQuery< kvdb::RawEncoder, snapshots::RawEncoder, kvdb::RawDecoder, snapshots::RawDecoder, kvdb::RawDecoder, snapshots::RawDecoder>; using RawDomainRangeAsOfQueryResult = DomainRangeAsOfQueryResult< kvdb::RawEncoder, snapshots::RawEncoder, kvdb::RawDecoder, snapshots::RawDecoder, kvdb::RawDecoder, snapshots::RawDecoder>; Task LocalTransaction::open() { co_return; } Task> LocalTransaction::cursor(std::string_view table) { co_return co_await get_cursor(table, false); } Task> LocalTransaction::cursor_dup_sort(std::string_view table) { co_return co_await get_cursor(table, true); } Task LocalTransaction::close() { cursors_.clear(); co_return; } Task> LocalTransaction::get_cursor(std::string_view table_view, bool is_cursor_dup_sort) { std::string table{table_view}; if (is_cursor_dup_sort) { auto cursor_it = dup_cursors_.find(table); if (cursor_it != dup_cursors_.end()) { co_return cursor_it->second; } } else { auto cursor_it = cursors_.find(table); if (cursor_it != cursors_.end()) { co_return cursor_it->second; } } auto cursor = std::make_shared(tx_, ++last_cursor_id_); co_await cursor->open_cursor(table, is_cursor_dup_sort); if (is_cursor_dup_sort) { dup_cursors_[table] = cursor; } else { cursors_[table] = cursor; } co_return cursor; } std::shared_ptr LocalTransaction::make_storage() { // The calling thread *must* be the *same* which created this LocalTransaction instance return std::make_shared( DataModel{tx_, data_store_.blocks_repository}, chain_config_); } Task LocalTransaction::first_txn_num_in_block(BlockNum block_num) { auto canonical_body_for_storage = [this](BlockNum bn) -> Task> { DataModel access_layer{tx_, data_store_.blocks_repository}; co_return access_layer.read_raw_body_for_storage_from_snapshot(bn); }; const auto min_txn_num = co_await txn::min_tx_num(*this, block_num, canonical_body_for_storage); co_return min_txn_num + /*txn_index=*/0; } Task LocalTransaction::get_latest(GetLatestRequest request) { ensure(request.sub_key.empty(), "LocalTransaction::get_latest sub_key support not implemented"); if (!kTable2EntityNames.contains(request.table)) { co_return GetAsOfResult{}; } const EntityName domain_name = kTable2EntityNames.at(request.table); RawDomainGetLatestQuery query{ domain_name, data_store_.chaindata.domain(domain_name), tx_, data_store_.state_repository_latest, data_store_.query_caches, }; auto result = query.exec(request.key); if (!result) { co_return GetLatestResult{}; } co_return GetLatestResult{.success = true, .value = std::move(result->value)}; } Task LocalTransaction::get_as_of(GetAsOfRequest request) { ensure(request.sub_key.empty(), "LocalTransaction::get_as_of sub_key support not implemented"); if (!kTable2EntityNames.contains(request.table)) { co_return GetAsOfResult{}; } const EntityName domain_name = kTable2EntityNames.at(request.table); std::optional value; if (domain_name == state::kDomainNameAccounts) { value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameStorage) { value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameCode) { value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameCommitment) { value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameReceipts) { value = query_domain_as_of(domain_name, request.key, request.timestamp); } if (!value) { co_return GetAsOfResult{}; } co_return GetAsOfResult{.success = true, .value = std::move(*value)}; } Task LocalTransaction::history_seek(HistoryPointRequest request) { if (!kTable2EntityNames.contains(request.table)) { co_return HistoryPointResult{}; } const EntityName domain_name = kTable2EntityNames.at(request.table); const kvdb::Domain domain = data_store_.chaindata.domain(domain_name); if (!domain.history) { co_return HistoryPointResult{}; } const auto timestamp = static_cast(request.timestamp); std::optional value; if (domain_name == state::kDomainNameAccounts) { value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameStorage) { value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameCode) { value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameCommitment) { value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameReceipts) { value = query_history_get(*domain.history, request.key, timestamp); } if (!value) { co_return HistoryPointResult{}; } co_return HistoryPointResult{.success = true, .value = std::move(*value)}; } template requires std::convertible_to>, V> struct RangeStreamIterator : StreamIterator { using RangeIterator = std::ranges::iterator_t; using iterator = RangeIterator; using value_type = V; explicit RangeStreamIterator(Range&& range) : range_(std::move(range)), it_(std::ranges::begin(range_)) {} Task has_next() override { co_return it_ != std::ranges::end(range_); } Task> next() override { if (it_ == std::ranges::end(range_)) { co_return std::nullopt; } const auto value = *it_; ++it_; co_return value; } private: Range range_; RangeIterator it_; }; struct TimestampConverter { Timestamp operator()(datastore::Timestamp ts) const { return static_cast(ts); } }; using TimestampView = std::ranges::take_view< std::ranges::transform_view>; using TimestampViewIterator = decltype(std::declval().begin()); static_assert(std::is_same_v); using TimestampStreamIterator = RangeStreamIterator; Task LocalTransaction::index_range(IndexRangeRequest request) { if (!kTable2EntityNames.contains(request.table)) { co_return TimestampStreamReply{EmptyStreamFactory}; } auto timestamp_stream_factory = [this, request = std::move(request)]() mutable -> Task { const EntityName inverted_index_name = kTable2EntityNames.at(request.table); RawInvertedIndexRangeByKeyQuery query{ inverted_index_name, data_store_.chaindata, tx_, data_store_.state_repository_historical, }; datastore::TimestampRange ts_range = as_datastore_ts_range({request.from_timestamp, request.to_timestamp}, !request.ascending_order); const size_t limit = (request.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(request.limit); auto timestamps = query.exec(request.key, std::move(ts_range), request.ascending_order) | std::views::transform(TimestampConverter{}) | std::views::take(limit); static_assert(std::is_same_v); co_return TimestampStream{std::make_unique(std::move(timestamps))}; }; co_return TimestampStreamReply{std::move(timestamp_stream_factory)}; } using RawHistoryRangeView = std::ranges::take_view; using RawHistoryRangeViewIterator = decltype(std::declval().begin()); static_assert(std::is_same_v); using RawHistoryRangeStreamIterator = RangeStreamIterator; Task LocalTransaction::history_range(HistoryRangeRequest request) { if (!kTable2EntityNames.contains(request.table)) { co_return KeyValueStreamReply{EmptyStreamFactory}; } auto key_value_stream_factory = [this, request = std::move(request)]() mutable -> Task { const EntityName entity_name = kTable2EntityNames.at(request.table); RawHistoryRangeInPeriodQuery query{ entity_name, data_store_.chaindata, tx_, data_store_.state_repository_historical, }; datastore::TimestampRange ts_range = as_datastore_ts_range({request.from_timestamp, request.to_timestamp}, !request.ascending_order); const size_t limit = (request.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(request.limit); auto history_kv = query.exec(ts_range, request.ascending_order) | std::views::take(limit); static_assert(std::is_same_v); co_return KeyValueStream{std::make_unique(std::move(history_kv))}; }; co_return KeyValueStreamReply{std::move(key_value_stream_factory)}; } using RawDomainRangeView = std::ranges::take_view; using RawDomainRangeViewViewIterator = decltype(std::declval().begin()); static_assert(std::is_same_v); using RawDomainRangeStreamIterator = RangeStreamIterator; Task LocalTransaction::range_as_of(DomainRangeRequest request) { if (!kTable2EntityNames.contains(request.table)) { co_return KeyValueStreamReply{EmptyStreamFactory}; } auto key_value_stream_factory = [this, request = std::move(request)]() mutable -> Task { const EntityName entity_name = kTable2EntityNames.at(request.table); RawDomainRangeAsOfQuery query{ entity_name, data_store_.chaindata, tx_, data_store_.state_repository_latest, data_store_.state_repository_historical, }; std::optional timestamp; if (request.timestamp && (*request.timestamp >= 0)) { timestamp = static_cast(*request.timestamp); } const size_t limit = (request.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(request.limit); auto domain_kv = query.exec(request.from_key, request.to_key, timestamp, request.ascending_order, request.skip_empty_values) | std::views::take(limit); static_assert(std::is_same_v); co_return KeyValueStream{std::make_unique(std::move(domain_kv))}; }; co_return KeyValueStreamReply{std::move(key_value_stream_factory)}; } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/local_transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "base_transaction.hpp" #include "cursor.hpp" #include "local_cursor.hpp" namespace silkworm::db::kv::api { class LocalTransaction : public BaseTransaction { public: LocalTransaction(DataStoreRef data_store, const ChainConfig& chain_config, StateCache* state_cache) : BaseTransaction{state_cache}, data_store_{std::move(data_store)}, chain_config_{chain_config}, tx_{data_store_.chaindata.access_ro().start_ro_tx()} {} ~LocalTransaction() override = default; uint64_t tx_id() const override { return tx_id_; } uint64_t view_id() const override { return tx_.id(); } Task open() override; Task> cursor(std::string_view table) override; Task> cursor_dup_sort(std::string_view table) override; bool is_local() const override { return true; } DataStoreRef data_store() const { return data_store_; } std::shared_ptr make_storage() override; Task first_txn_num_in_block(BlockNum block_num) override; Task close() override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=true (ts ignored) Task get_latest(GetLatestRequest request) override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=false (ts used) Task get_as_of(GetAsOfRequest request) override; // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply); Task history_seek(HistoryPointRequest request) override; // rpc IndexRange(IndexRangeReq) returns (IndexRangeReply); Task index_range(IndexRangeRequest request) override; // rpc HistoryRange(HistoryRangeReq) returns (Pairs); Task history_range(HistoryRangeRequest request) override; // rpc RangeAsOf(RangeAsOfReq) returns (Pairs); Task range_as_of(DomainRangeRequest request) override; private: template auto query_domain_as_of(const datastore::EntityName domain_name, ByteView key, Timestamp ts) { DomainGetAsOfQuery query{ data_store_.chaindata.domain(domain_name), tx_, data_store_.state_repository_latest, data_store_.state_repository_historical, data_store_.query_caches, }; return query.exec(key, ts); } template auto query_history_get(datastore::kvdb::History kvdb_entity, ByteView key, datastore::Timestamp ts) { HistoryGetQuery query{ kvdb_entity, tx_, data_store_.state_repository_historical, data_store_.query_caches, }; return query.exec(key, ts); } Task> get_cursor(std::string_view table, bool is_cursor_dup_sort); static inline uint64_t next_tx_id_{0}; std::map> cursors_; std::map> dup_cursors_; DataStoreRef data_store_; const ChainConfig& chain_config_; uint32_t last_cursor_id_{0}; datastore::kvdb::ROTxnManaged tx_; uint64_t tx_id_{++next_tx_id_}; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "endpoint/state_change.hpp" #include "endpoint/temporal_point.hpp" #include "endpoint/temporal_range.hpp" #include "endpoint/version.hpp" #include "transaction.hpp" namespace silkworm::db::kv::api { struct Service { virtual ~Service() = default; // rpc Version(google.protobuf.Empty) returns (types.VersionReply); virtual Task version() = 0; // rpc Tx(stream Cursor) returns (stream Pair); virtual Task> begin_transaction() = 0; // rpc StateChanges(StateChangeRequest) returns (stream StateChangeBatch); virtual Task state_changes(const StateChangeOptions& options, StateChangeConsumer consumer) = 0; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/service_router.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "service_router.hpp" #include namespace silkworm::db::kv::api { using namespace boost::asio; Task StateChangeRunner::run(std::shared_ptr self) { auto run = self->handle_calls(); co_await concurrency::spawn_task(self->strand_, std::move(run)); } StateChangeRunner::StateChangeRunner(const boost::asio::any_io_executor& executor) : state_changes_calls_channel_{executor}, strand_{executor} {} Task StateChangeRunner::handle_calls() { auto executor = co_await boost::asio::this_coro::executor; // Loop until receive() throws a cancelled exception while (true) { auto call = co_await state_changes_calls_channel_.receive(); auto state_changes_channel = std::make_shared(executor); call.set_result(state_changes_channel); } } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/service_router.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "endpoint/state_changes_call.hpp" namespace silkworm::db::kv::api { struct ServiceRouter { concurrency::Channel& state_changes_calls_channel; }; class StateChangeRunner { public: static Task run(std::shared_ptr self); explicit StateChangeRunner(const boost::asio::any_io_executor& executor); template using Channel = concurrency::Channel; Channel& state_changes_calls_channel() { return state_changes_calls_channel_; } private: Task handle_calls(); Channel state_changes_calls_channel_; boost::asio::strand strand_; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/state_cache.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_cache.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::db::kv::api { CoherentStateView::CoherentStateView(StateVersionId version_id, Transaction& tx, CoherentStateCache* cache) : version_id_(version_id), tx_(tx), cache_(cache) {} bool CoherentStateView::empty() const { const auto root_it = cache_->state_view_roots_.find(version_id_); if (root_it == cache_->state_view_roots_.end()) { return true; } const auto& root = root_it->second; return root->cache.empty() && root->code_cache.empty(); } Task> CoherentStateView::get(std::string_view table, Bytes key) { co_return co_await cache_->get(version_id_, table, std::move(key), tx_); } Task> CoherentStateView::get_code(Bytes key) { co_return co_await cache_->get_code(version_id_, std::move(key), tx_); } CoherentStateCache::CoherentStateCache(CoherentCacheConfig config) : config_(config) { if (config.max_views == 0) { throw std::invalid_argument{"unexpected zero max_views"}; } } Task> CoherentStateCache::get_view(Transaction& tx) { const auto version_id = co_await get_db_state_version(tx); if (config_.wait_for_new_block) { co_await wait_for_root_ready(version_id); } co_return std::make_unique(version_id, tx, this); } size_t CoherentStateCache::latest_data_size() { std::shared_lock read_lock{rw_mutex_}; if (latest_state_view_ == nullptr) { return 0; } return static_cast(latest_state_view_->cache.size()); } size_t CoherentStateCache::latest_code_size() { std::shared_lock read_lock{rw_mutex_}; if (latest_state_view_ == nullptr) { return 0; } return static_cast(latest_state_view_->code_cache.size()); } void CoherentStateCache::on_new_block(const api::StateChangeSet& state_changes_set) { const auto& state_changes = state_changes_set.state_changes; if (state_changes.empty()) { SILK_WARN << "Unexpected empty batch received and skipped"; return; } std::scoped_lock write_lock{rw_mutex_}; new_block_wait_count_ = 0; const auto version_id = state_changes_set.state_version_id; CoherentStateRoot* root = advance_root(version_id); for (const auto& state_change : state_changes) { for (const auto& account_change : state_change.account_changes) { switch (account_change.change_type) { case Action::kUpsert: { process_upsert_change(root, version_id, account_change); break; } case Action::kUpsertCode: { process_upsert_change(root, version_id, account_change); process_code_change(root, version_id, account_change); break; } case Action::kRemove: { process_delete_change(root, version_id, account_change); break; } case Action::kStorage: { if (config_.with_storage && !account_change.storage_changes.empty()) { process_storage_change(root, version_id, account_change); } break; } case Action::kCode: { process_code_change(root, version_id, account_change); break; } default: { SILK_ERROR << "Unexpected action: " << magic_enum::enum_name(account_change.change_type) << " skipped"; } } } } state_key_count_ = static_cast(latest_state_view_->cache.size()); code_key_count_ = static_cast(latest_state_view_->code_cache.size()); root->ready = true; root->ready_cond_var.notify_all(); } Task CoherentStateCache::validate_current_root(Transaction& tx) { StateCache::ValidationResult validation_result{.enabled = true}; const StateVersionId current_state_version_id = co_await get_db_state_version(tx); validation_result.latest_state_version_id = current_state_version_id; // If the latest version id in the cache is not the same as the db or one below it // then the cache will be a new one for the next call so return early if (current_state_version_id > latest_state_version_id_) { validation_result.latest_state_behind = true; co_return validation_result; } const auto root = co_await wait_for_root_ready(latest_state_version_id_); bool clear_cache{false}; const auto get_address_domain = [](const auto& key) { return key.size() == kAddressLength ? db::table::kAccountDomain : db::table::kStorageDomain; }; const auto compare_cache = [&](auto& cache, bool is_code) -> Task>> { bool cancelled{false}; std::vector keys; if (cache.empty()) { co_return std::make_pair(cancelled, keys); } auto kv_node = cache.extract(cache.begin()); if (!kv_node.empty()) { co_return std::make_pair(cancelled, keys); } KeyValue kv{kv_node.value()}; const auto domain = is_code ? db::table::kCodeDomain : get_address_domain(kv.key); const GetLatestResult result = co_await tx.get_latest({.table = std::string{domain}, .key = kv.key}); if (!result.success) { co_return std::make_pair(cancelled, keys); } if (result.value != kv.key) { keys.push_back(kv.key); clear_cache = true; } co_return std::make_pair(cancelled, keys); }; auto [cache, code_cache] = clone_caches(root); auto [cancelled_1, keys] = co_await compare_cache(cache, /*is_code=*/false); if (cancelled_1) { validation_result.request_canceled = true; co_return validation_result; } validation_result.state_keys_out_of_sync = std::move(keys); auto [cancelled_2, code_keys] = co_await compare_cache(code_cache, /*is_code=*/true); if (cancelled_2) { validation_result.request_canceled = true; co_return validation_result; } validation_result.code_keys_out_of_sync = std::move(code_keys); if (clear_cache) { clear_caches(root); } validation_result.cache_cleared = true; co_return validation_result; } void CoherentStateCache::process_upsert_change(CoherentStateRoot* root, StateVersionId version_id, const AccountChange& change) { const auto& address = change.address; const auto& data_bytes = change.data; SILK_DEBUG << "CoherentStateCache::process_upsert_change address: " << address << " data: " << data_bytes; const Bytes address_key{address.bytes, kAddressLength}; add({address_key, data_bytes}, root, version_id); } void CoherentStateCache::process_code_change(CoherentStateRoot* root, StateVersionId version_id, const AccountChange& change) { const auto& code_bytes = change.code; const ethash::hash256 code_hash{keccak256(code_bytes)}; const Bytes code_hash_key{code_hash.bytes, kHashLength}; SILK_DEBUG << "CoherentStateCache::process_code_change code_hash_key: " << code_hash_key; add_code({code_hash_key, code_bytes}, root, version_id); } void CoherentStateCache::process_delete_change(CoherentStateRoot* root, StateVersionId version_id, const AccountChange& change) { const auto& address = change.address; SILK_DEBUG << "CoherentStateCache::process_delete_change address: " << address; const Bytes address_key{address.bytes, kAddressLength}; add({address_key, {}}, root, version_id); } void CoherentStateCache::process_storage_change(CoherentStateRoot* root, StateVersionId version_id, const AccountChange& change) { const auto& address = change.address; SILK_DEBUG << "CoherentStateCache::process_storage_change address=" << address; for (const auto& storage_change : change.storage_changes) { const auto& location_hash = storage_change.location; const auto storage_key = composite_storage_key(address, change.incarnation, location_hash.bytes); const auto& value = storage_change.data; SILK_DEBUG << "CoherentStateCache::process_storage_change key=" << storage_key << " value=" << value; add({storage_key, value}, root, version_id); } } bool CoherentStateCache::add(KeyValue&& kv, CoherentStateRoot* root, StateVersionId version_id) { auto [it, inserted] = root->cache.insert(kv); SILK_DEBUG << "Data cache kv.key=" << to_hex(kv.key) << " inserted=" << inserted << " version_id=" << version_id; std::optional replaced; if (!inserted) { replaced = *it; root->cache.erase(it); std::tie(it, inserted) = root->cache.insert(kv); SILKWORM_ASSERT(inserted); } if (latest_state_version_id_ != version_id) { return inserted; } if (replaced) { state_evictions_.remove(*replaced); SILK_DEBUG << "Data evictions removed replaced.key=" << to_hex(replaced->key); } state_evictions_.push_front(std::move(kv)); // Remove the longest unused key-value pair when size exceeded if (state_evictions_.size() > config_.max_state_keys) { const auto oldest = state_evictions_.back(); SILK_DEBUG << "Data cache resize oldest.key=" << to_hex(oldest.key); state_evictions_.pop_back(); const auto num_erased = root->cache.erase(oldest); SILKWORM_ASSERT(num_erased == 1); } return inserted; } bool CoherentStateCache::add_code(KeyValue&& kv, CoherentStateRoot* root, StateVersionId version_id) { auto [it, inserted] = root->code_cache.insert(kv); SILK_DEBUG << "Code cache kv.key=" << to_hex(kv.key) << " inserted=" << inserted << " version_id=" << version_id; std::optional replaced; if (!inserted) { replaced = *it; root->code_cache.erase(it); std::tie(it, inserted) = root->code_cache.insert(kv); SILKWORM_ASSERT(inserted); } if (latest_state_version_id_ != version_id) { return inserted; } if (replaced) { code_evictions_.remove(*replaced); SILK_DEBUG << "Code evictions removed replaced.key=" << to_hex(replaced->key); } code_evictions_.push_front(std::move(kv)); // Remove the longest unused key-value pair when size exceeded if (code_evictions_.size() > config_.max_code_keys) { const auto oldest = code_evictions_.back(); SILK_DEBUG << "Code cache resize oldest.key=" << to_hex(oldest.key); code_evictions_.pop_back(); const auto num_erased = root->code_cache.erase(oldest); SILKWORM_ASSERT(num_erased == 1); } return inserted; } Task> CoherentStateCache::get(StateVersionId version_id, std::string_view table, Bytes key, Transaction& tx) { std::shared_lock read_lock{rw_mutex_}; const auto root_it = state_view_roots_.find(version_id); if (root_it == state_view_roots_.end()) { co_return std::nullopt; } KeyValue kv{std::move(key)}; auto& cache = root_it->second->cache; const auto kv_it = cache.find(kv); if (kv_it != cache.end()) { ++state_hit_count_; SILK_DEBUG << "Hit in state cache key=" << kv.key << " value=" << kv_it->value; if (version_id == latest_state_version_id_) { state_evictions_.remove(kv); state_evictions_.push_front(kv); } co_return kv_it->value; } ++state_miss_count_; const auto domain = kv.key.size() == kAddressLength ? db::table::kAccountDomain : db::table::kStorageDomain; const GetLatestResult result = co_await tx.get_latest({.table = std::string{table}, .key = kv.key}); if (!result.success) { co_return std::nullopt; } const Bytes value = result.value; SILK_DEBUG << "Miss in state cache: lookup in domain " << domain << " key=" << kv.key << " value=" << value; if (value.empty()) { co_return std::nullopt; } read_lock.unlock(); std::scoped_lock write_lock{rw_mutex_}; kv.value = value; add(std::move(kv), root_it->second.get(), version_id); co_return value; } Task> CoherentStateCache::get_code(StateVersionId version_id, Bytes key, Transaction& tx) { std::shared_lock read_lock{rw_mutex_}; const auto root_it = state_view_roots_.find(version_id); if (root_it == state_view_roots_.end()) { co_return std::nullopt; } KeyValue kv{std::move(key)}; auto& code_cache = root_it->second->code_cache; const auto kv_it = code_cache.find(kv); if (kv_it != code_cache.end()) { ++code_hit_count_; SILK_DEBUG << "Hit in code cache key=" << kv.key << " value=" << kv_it->value; if (version_id == latest_state_version_id_) { code_evictions_.remove(kv); code_evictions_.push_front(kv); } co_return kv_it->value; } ++code_miss_count_; const GetLatestResult result = co_await tx.get_latest({.table = std::string{db::table::kCodeDomain}, .key = kv.key}); if (!result.success) { co_return std::nullopt; } const Bytes value = result.value; SILK_DEBUG << "Miss in code cache: lookup in domain Code key=" << kv.key << " value=" << value; if (value.empty()) { co_return std::nullopt; } read_lock.unlock(); std::scoped_lock write_lock{rw_mutex_}; kv.value = value; add_code(std::move(kv), root_it->second.get(), version_id); co_return value; } CoherentStateRoot* CoherentStateCache::get_root(StateVersionId version_id) { const auto root_it = state_view_roots_.find(version_id); if (root_it != state_view_roots_.end()) { SILK_DEBUG << "CoherentStateCache::get_root version_id=" << version_id << " root=" << root_it->second.get() << " found"; return root_it->second.get(); } const auto [new_root_it, _] = state_view_roots_.emplace(version_id, std::make_unique()); SILK_DEBUG << "CoherentStateCache::get_root version_id=" << version_id << " root=" << root_it->second.get() << " created"; return new_root_it->second.get(); } CoherentStateRoot* CoherentStateCache::advance_root(StateVersionId version_id) { CoherentStateRoot* root = get_root(version_id); const auto previous_root_it = state_view_roots_.find(version_id - 1); if (previous_root_it != state_view_roots_.end() && previous_root_it->second->canonical) { SILK_DEBUG << "CoherentStateCache::advance_root canonical view_id-1=" << (version_id - 1) << " found"; root->cache = previous_root_it->second->cache; root->code_cache = previous_root_it->second->code_cache; } else { SILK_DEBUG << "CoherentStateCache::advance_root canonical view_id-1=" << (version_id - 1) << " not found"; state_evictions_.clear(); for (const auto& kv : root->cache) { state_evictions_.push_front(kv); } code_evictions_.clear(); for (const auto& kv : root->code_cache) { code_evictions_.push_front(kv); } } root->canonical = true; evict_roots(version_id); latest_state_version_id_ = version_id; latest_state_view_ = root; state_eviction_count_ = state_evictions_.size(); code_eviction_count_ = code_evictions_.size(); return root; } void CoherentStateCache::evict_roots(StateVersionId next_version_id) { SILK_DEBUG << "CoherentStateCache::evict_roots state_view_roots_.size()=" << state_view_roots_.size(); if (state_view_roots_.size() <= config_.max_views) { return; } if (next_version_id == 0) { // Next version ID is zero with cache not empty => version ID wrapping => clear the cache except for new latest view std::erase_if(state_view_roots_, [&](const auto& item) { auto const& [version_id, _] = item; return version_id != next_version_id; }); return; } // Erase older state views in order not to exceed max_views const auto max_version_id_to_delete = latest_state_version_id_ - config_.max_views + 1; SILK_DEBUG << "CoherentStateCache::evict_roots max_version_id_to_delete=" << max_version_id_to_delete; std::erase_if(state_view_roots_, [&](const auto& item) { auto const& [version_id, _] = item; return version_id <= max_version_id_to_delete; }); } Task CoherentStateCache::wait_for_root_ready(StateVersionId version_id) { using namespace concurrency::awaitable_wait_for_one; CoherentStateRoot* root = get_root(version_id); while (new_block_wait_count_ <= kDefaultMaxWaitCount) { std::unique_lock write_lock{rw_mutex_}; if (root->ready) co_return root; auto ready_waiter = root->ready_cond_var.waiter(); write_lock.unlock(); try { co_await (ready_waiter() || concurrency::timeout(config_.block_wait_duration)); } catch (const concurrency::TimeoutExpiredError&) { write_lock.lock(); ++new_block_wait_count_; write_lock.unlock(); } } co_return root; } Task CoherentStateCache::get_db_state_version(Transaction& tx) const { const Bytes version = co_await tx.get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey)); if (version.empty()) { co_return 0; } co_return endian::load_big_u64(version.data()); } std::pair CoherentStateCache::clone_caches(CoherentStateRoot* root) { std::scoped_lock write_lock{rw_mutex_}; KeyValueSet cache = root->cache; KeyValueSet code_cache = root->code_cache; return {cache, code_cache}; } void CoherentStateCache::clear_caches(CoherentStateRoot* root) { std::scoped_lock write_lock{rw_mutex_}; root->cache.clear(); root->code_cache.clear(); } } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/state_cache.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include "endpoint/key_value.hpp" #include "endpoint/state_change.hpp" #include "transaction.hpp" namespace silkworm::db::kv::api { class StateView { public: virtual ~StateView() = default; virtual bool empty() const = 0; virtual Task> get(std::string_view table, Bytes key) = 0; virtual Task> get_code(Bytes key) = 0; }; using StateVersionId = uint64_t; class StateCache { public: virtual ~StateCache() = default; virtual Task> get_view(Transaction& tx) = 0; virtual void on_new_block(const api::StateChangeSet& state_changes) = 0; virtual size_t latest_data_size() = 0; virtual size_t latest_code_size() = 0; virtual uint64_t state_hit_count() const = 0; virtual uint64_t state_miss_count() const = 0; virtual uint64_t state_key_count() const = 0; virtual uint64_t state_eviction_count() const = 0; virtual uint64_t code_hit_count() const = 0; virtual uint64_t code_miss_count() const = 0; virtual uint64_t code_key_count() const = 0; virtual uint64_t code_eviction_count() const = 0; struct ValidationResult { bool request_canceled{false}; bool enabled{false}; bool latest_state_behind{false}; bool cache_cleared{false}; StateVersionId latest_state_version_id{0}; std::vector state_keys_out_of_sync; std::vector code_keys_out_of_sync; }; virtual Task validate_current_root(Transaction& tx) = 0; }; using KeyValueSet = absl::btree_set; struct CoherentStateRoot { KeyValueSet cache; KeyValueSet code_cache; bool ready{false}; bool canonical{false}; concurrency::AwaitableConditionVariable ready_cond_var; }; inline constexpr uint64_t kDefaultMaxViews = 5ul; inline constexpr uint32_t kDefaultMaxStateKeys = 1'000'000u; inline constexpr uint32_t kDefaultMaxCodeKeys = 10'000u; inline constexpr uint32_t kDefaultMaxWaitCount = 100u; struct CoherentCacheConfig { uint64_t max_views{kDefaultMaxViews}; bool with_storage{true}; bool wait_for_new_block{true}; uint32_t max_state_keys{kDefaultMaxStateKeys}; uint32_t max_code_keys{kDefaultMaxCodeKeys}; std::chrono::milliseconds block_wait_duration{5}; }; class CoherentStateCache; class CoherentStateView : public StateView { public: CoherentStateView(StateVersionId version_id, Transaction& tx, CoherentStateCache* cache); CoherentStateView(const CoherentStateView&) = delete; CoherentStateView& operator=(const CoherentStateView&) = delete; bool empty() const override; Task> get(std::string_view table, Bytes key) override; Task> get_code(Bytes key) override; private: StateVersionId version_id_; Transaction& tx_; CoherentStateCache* cache_; }; class CoherentStateCache : public StateCache { public: explicit CoherentStateCache(CoherentCacheConfig config = {}); CoherentStateCache(const CoherentStateCache&) = delete; CoherentStateCache& operator=(const CoherentStateCache&) = delete; Task> get_view(Transaction& tx) override; void on_new_block(const api::StateChangeSet& state_changes) override; size_t latest_data_size() override; size_t latest_code_size() override; uint64_t state_hit_count() const override { return state_hit_count_; } uint64_t state_miss_count() const override { return state_miss_count_; } uint64_t state_key_count() const override { return state_key_count_; } uint64_t state_eviction_count() const override { return state_eviction_count_; } uint64_t code_hit_count() const override { return code_hit_count_; } uint64_t code_miss_count() const override { return code_miss_count_; } uint64_t code_key_count() const override { return code_key_count_; } uint64_t code_eviction_count() const override { return code_eviction_count_; } Task validate_current_root(Transaction& tx) override; private: friend class CoherentStateView; void process_upsert_change(CoherentStateRoot* root, StateVersionId version_id, const api::AccountChange& change); void process_code_change(CoherentStateRoot* root, StateVersionId version_id, const api::AccountChange& change); void process_delete_change(CoherentStateRoot* root, StateVersionId version_id, const api::AccountChange& change); void process_storage_change(CoherentStateRoot* root, StateVersionId version_id, const api::AccountChange& change); bool add(KeyValue&& kv, CoherentStateRoot* root, StateVersionId version_id); bool add_code(KeyValue&& kv, CoherentStateRoot* root, StateVersionId version_id); Task> get(StateVersionId version_id, std::string_view table, Bytes key, Transaction& tx); Task> get_code(StateVersionId version_id, Bytes key, Transaction& tx); CoherentStateRoot* get_root(StateVersionId version_id); CoherentStateRoot* advance_root(StateVersionId version_id); void evict_roots(StateVersionId next_version_id); Task wait_for_root_ready(StateVersionId version_id); Task get_db_state_version(Transaction& tx) const; std::pair clone_caches(CoherentStateRoot* root); void clear_caches(CoherentStateRoot* root); CoherentCacheConfig config_; std::map> state_view_roots_; StateVersionId latest_state_version_id_{0}; CoherentStateRoot* latest_state_view_{nullptr}; std::list state_evictions_; std::list code_evictions_; std::shared_mutex rw_mutex_; uint32_t new_block_wait_count_{0}; uint64_t state_hit_count_{0}; uint64_t state_miss_count_{0}; uint64_t state_key_count_{0}; uint64_t state_eviction_count_{0}; uint64_t code_hit_count_{0}; uint64_t code_miss_count_{0}; uint64_t code_key_count_{0}; uint64_t code_eviction_count_{0}; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/state_cache_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_cache.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::db::kv::api { using namespace std::chrono_literals; using namespace evmc::literals; // NOLINT(build/namespaces_literals) using testing::_; using testing::InvokeWithoutArgs; static constexpr uint64_t kTestStateVersionId0{3'000'000}; static constexpr uint64_t kTestStateVersionId1{3'000'001}; static constexpr uint64_t kTestStateVersionId2{3'000'002}; static constexpr BlockNum kTestBlockNum{1'000'000}; static constexpr evmc::bytes32 kTestBlockHash{0x8e38b4dbf6b11fcc3b9dee84fb7986e29ca0a02cecd8977c161ff7333329681e_bytes32}; static constexpr evmc::address kTestAddress1{0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6_address}; static constexpr evmc::address kTestAddress2{0x0715a7794a1dc8e42615f059dd6e406a6594651a_address}; static constexpr evmc::address kTestAddress3{0x326c977e6efc84e512bb9c30f76e30c160ed06fb_address}; static constexpr evmc::address kTestAddress4{0x2d3be3b6021606e1af02fccbc6ea5b192e6d412d_address}; static const std::vector kTestAddresses{kTestAddress1, kTestAddress2, kTestAddress3, kTestAddress4}; static constexpr uint64_t kTestIncarnation{3}; static const Bytes kTestAccountData{*from_hex("600035600055")}; static const Bytes kTestStorageData1{*from_hex("600035600055")}; static const Bytes kTestStorageData2{*from_hex("6000356000550055")}; static const std::vector kTestStorageData{kTestStorageData1, kTestStorageData2}; static const Bytes kTestCode1{*from_hex("602a6000556101c960015560068060166000396000f3600035600055")}; static const Bytes kTestCode2{*from_hex("600160010160005500")}; static const Bytes kTestCode3{*from_hex("600260020160005500")}; static const Bytes kTestCode4{*from_hex("60606040526008565b00")}; static const std::vector kTestCodes{kTestCode1, kTestCode2, kTestCode3, kTestCode4}; static const evmc::bytes32 kTestHashedLocation1{0x6677907ab33937e392b9be983b30818f29d594039c9e1e7490bf7b3698888fb1_bytes32}; static const evmc::bytes32 kTestHashedLocation2{0xe046602dcccb1a2f1d176718c8e709a42bba57af2da2379ba7130e2f916c95cd_bytes32}; static const std::vector kTestHashedLocations{kTestHashedLocation1, kTestHashedLocation2}; static const std::vector kTestZeroTxs{}; TEST_CASE("CoherentStateRoot", "[db][kv][api][state_cache]") { SECTION("CoherentStateRoot::CoherentStateRoot") { CoherentStateRoot root; CHECK(root.cache.empty()); CHECK(root.code_cache.empty()); CHECK(!root.ready); CHECK(!root.canonical); } } TEST_CASE("CoherentCacheConfig", "[db][kv][api][state_cache]") { SECTION("CoherentCacheConfig::CoherentCacheConfig") { CoherentCacheConfig config; CHECK(config.max_views == kDefaultMaxViews); CHECK(config.with_storage); CHECK(config.max_state_keys == kDefaultMaxStateKeys); CHECK(config.max_code_keys == kDefaultMaxCodeKeys); } } static StateChangeSet new_batch(StateVersionId version_id, BlockNum block_num, const Hash& block_hash, const ListOfBytes& rlp_txs, bool unwind) { StateChangeSet state_change_set; state_change_set.state_version_id = version_id; state_change_set.state_changes.emplace_back(StateChange{ .direction = unwind ? Direction::kUnwind : Direction::kForward, .block_num = block_num, .block_hash = block_hash, .rlp_txs = rlp_txs, }); return state_change_set; } static StateChangeSet new_batch_with_upsert(StateVersionId version_id, BlockNum block_num, const Hash& block_hash, const ListOfBytes& rlp_txs, bool unwind) { StateChangeSet state_change_set = new_batch(version_id, block_num, block_hash, rlp_txs, unwind); StateChange& latest_change = state_change_set.state_changes[0]; latest_change.account_changes.emplace_back(AccountChange{ .address = kTestAddress1, .incarnation = kTestIncarnation, .change_type = Action::kUpsert, .data = kTestAccountData, }); return state_change_set; } static StateChangeSet new_batch_with_upsert_code(StateVersionId version_id, BlockNum block_num, const Hash& block_hash, const ListOfBytes& rlp_txs, bool unwind, uint64_t num_changes, uint64_t offset = 0) { SILKWORM_ASSERT(num_changes <= kTestAddresses.size()); SILKWORM_ASSERT(num_changes <= kTestCodes.size()); SILKWORM_ASSERT(offset < num_changes); StateChangeSet state_change_set = new_batch(version_id, block_num, block_hash, rlp_txs, unwind); StateChange& latest_change = state_change_set.state_changes[0]; for (auto i{offset}; i < num_changes; ++i) { latest_change.account_changes.emplace_back(AccountChange{ .address = kTestAddresses[i], .incarnation = kTestIncarnation, .change_type = Action::kUpsertCode, .data = kTestAccountData, .code = kTestCodes[i], }); } return state_change_set; } static StateChangeSet new_batch_with_delete(StateVersionId version_id, BlockNum block_num, const Hash& block_hash, const ListOfBytes& rlp_txs, bool unwind) { StateChangeSet state_change_set = new_batch(version_id, block_num, block_hash, rlp_txs, unwind); StateChange& latest_change = state_change_set.state_changes[0]; latest_change.account_changes.emplace_back(AccountChange{ .address = kTestAddress1, .change_type = Action::kRemove, }); return state_change_set; } static StateChangeSet new_batch_with_storage(uint64_t view_id, BlockNum block_num, const Hash& block_hash, const ListOfBytes& tx_rlps, bool unwind, uint64_t num_storage_changes) { SILKWORM_ASSERT(num_storage_changes <= kTestHashedLocations.size()); SILKWORM_ASSERT(num_storage_changes <= kTestStorageData.size()); StateChangeSet state_change_set = new_batch(view_id, block_num, block_hash, tx_rlps, unwind); StateChange& latest_change = state_change_set.state_changes[0]; StorageChangeSequence storage_change_set; for (auto i{0u}; i < num_storage_changes; ++i) { storage_change_set.emplace_back(StorageChange{ .location = kTestHashedLocations[i], .data = kTestStorageData[i], }); } latest_change.account_changes.emplace_back(AccountChange{ .address = kTestAddress1, .incarnation = kTestIncarnation, .change_type = Action::kStorage, .storage_changes = std::move(storage_change_set), }); return state_change_set; } static StateChangeSet new_batch_with_code(uint64_t view_id, BlockNum block_num, const evmc::bytes32& block_hash, const std::vector& tx_rlps, bool unwind, uint64_t num_code_changes) { SILKWORM_ASSERT(num_code_changes <= kTestCodes.size()); StateChangeSet state_change_set = new_batch(view_id, block_num, block_hash, tx_rlps, unwind); StateChange& latest_change = state_change_set.state_changes[0]; for (auto i{0u}; i < num_code_changes; ++i) { latest_change.account_changes.emplace_back(AccountChange{ .address = kTestAddress1, .change_type = Action::kCode, .code = kTestCodes[i], }); } return state_change_set; } static Bytes state_version_id_bytes(StateVersionId version_id) { Bytes version_id_bytes(sizeof(uint64_t), 0); endian::store_big_u64(version_id_bytes.data(), version_id); return version_id_bytes; } struct StateCacheTest : public silkworm::test_util::ContextTestBase { Task> get_upsert(CoherentStateCache& cache, Transaction& txn, const evmc::address& address) { std::unique_ptr view = co_await cache.get_view(txn); if (!view) co_return std::nullopt; const Bytes address_key{address.bytes, kAddressLength}; const auto value = co_await view->get(table::kAccountDomain, address_key); if (!value) co_return std::nullopt; co_return *value; } Task> get_code(CoherentStateCache& cache, Transaction& txn, ByteView code) { std::unique_ptr view = co_await cache.get_view(txn); if (!view) co_return std::nullopt; const ethash::hash256 code_hash{keccak256(code)}; const Bytes code_hash_key{code_hash.bytes, kHashLength}; const auto value = co_await view->get_code(code_hash_key); if (!value) co_return std::nullopt; co_return *value; } }; TEST_CASE_METHOD(StateCacheTest, "CoherentStateCache::CoherentStateCache", "[db][kv][api][state_cache]") { SECTION("default config") { CoherentStateCache cache; CHECK(cache.latest_data_size() == 0); CHECK(cache.latest_code_size() == 0); CHECK(cache.state_hit_count() == 0); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 0); CHECK(cache.state_eviction_count() == 0); } SECTION("wrong config") { CoherentCacheConfig config{0, /*with_storage=*/true, /*wait_for_new_block*/ true, kDefaultMaxStateKeys, kDefaultMaxCodeKeys}; CHECK_THROWS_AS(CoherentStateCache{config}, std::invalid_argument); } } // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task { co_return state_version_id_bytes(kTestStateVersionId0); })); SECTION("no batch") { // Must be empty } SECTION("empty batch") { cache.on_new_block(StateChangeSet{}); } CHECK(cache.latest_data_size() == 0); CHECK(spawn_and_wait(cache.get_view(txn))->empty()); } TEST_CASE_METHOD(StateCacheTest, "CoherentStateCache::get_view one view", "[db][kv][api][state_cache][.]") { CoherentCacheConfig config{.block_wait_duration{1ms}}; // keep the block waiting as short as possible CoherentStateCache cache{config}; test_util::MockTransaction txn; EXPECT_CALL(txn, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillRepeatedly(InvokeWithoutArgs([&]() -> Task { co_return state_version_id_bytes(kTestStateVersionId0); })); SECTION("single upsert change batch => search hit") { cache.on_new_block( new_batch_with_upsert(kTestStateVersionId0, kTestBlockNum + 0, kTestBlockHash, kTestZeroTxs, /*unwind=*/false)); cache.on_new_block( new_batch_with_upsert(kTestStateVersionId1, kTestBlockNum + 1, kTestBlockHash, kTestZeroTxs, /*unwind=*/false)); CHECK(cache.latest_data_size() == 1); CHECK(spawn_and_wait(get_upsert(cache, txn, kTestAddress1)) == kTestAccountData); CHECK(cache.state_hit_count() == 1); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 1); CHECK(cache.state_eviction_count() == 1); } SECTION("single upsert+code change batch => double search hit") { auto batch = new_batch_with_upsert_code( kTestStateVersionId0, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_changes=*/1); cache.on_new_block(batch); CHECK(cache.latest_data_size() == 1); CHECK(cache.latest_code_size() == 1); CHECK(spawn_and_wait(get_upsert(cache, txn, kTestAddress1)) == kTestAccountData); CHECK(cache.state_hit_count() == 1); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 1); CHECK(cache.state_eviction_count() == 0); CHECK(spawn_and_wait(get_code(cache, txn, kTestCode1)) == kTestCode1); CHECK(cache.code_hit_count() == 1); CHECK(cache.code_miss_count() == 0); CHECK(cache.code_key_count() == 1); CHECK(cache.code_eviction_count() == 0); } SECTION("single delete change batch => search hit") { auto batch = new_batch_with_delete( kTestStateVersionId0, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false); cache.on_new_block(batch); CHECK(cache.latest_data_size() == 1); std::unique_ptr view = spawn_and_wait(cache.get_view(txn)); REQUIRE(view); const Bytes address_key{kTestAddress1.bytes, kAddressLength}; const auto value1 = spawn_and_wait(view->get(table::kAccountDomain, address_key)); REQUIRE(value1); CHECK(value1->empty()); CHECK(cache.state_hit_count() == 1); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 1); CHECK(cache.state_eviction_count() == 0); } SECTION("single storage change batch => search hit") { auto batch = new_batch_with_storage( kTestStateVersionId0, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_storage_changes=*/1); cache.on_new_block(batch); CHECK(cache.latest_data_size() == 1); std::unique_ptr view = spawn_and_wait(cache.get_view(txn)); REQUIRE(view); const auto storage_key1 = composite_storage_key(kTestAddress1, kTestIncarnation, kTestHashedLocation1.bytes); const auto value = spawn_and_wait(view->get(table::kStorageDomain, storage_key1)); REQUIRE(value == kTestStorageData1); CHECK(cache.state_hit_count() == 1); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 1); CHECK(cache.state_eviction_count() == 0); } SECTION("single storage change batch => search miss") { auto batch = new_batch_with_storage( kTestStateVersionId0, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_storage_changes=*/1); cache.on_new_block(batch); CHECK(cache.latest_data_size() == 1); EXPECT_CALL(txn, get_latest(_)) .WillOnce(InvokeWithoutArgs([&]() -> Task { co_return GetLatestResult{.success = true, .value = kTestStorageData2}; })); std::unique_ptr view = spawn_and_wait(cache.get_view(txn)); REQUIRE(view); const auto storage_key2 = composite_storage_key(kTestAddress1, kTestIncarnation, kTestHashedLocation2.bytes); const auto value = spawn_and_wait(view->get(table::kStorageDomain, storage_key2)); REQUIRE(value == kTestStorageData2); CHECK(cache.state_hit_count() == 0); CHECK(cache.state_miss_count() == 1); CHECK(cache.state_key_count() == 1); CHECK(cache.state_eviction_count() == 0); } SECTION("double storage change batch => double search hit") { auto batch = new_batch_with_storage( kTestStateVersionId0, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_storage_changes=*/2); cache.on_new_block(batch); CHECK(cache.latest_data_size() == 2); std::unique_ptr view = spawn_and_wait(cache.get_view(txn)); REQUIRE(view); const auto storage_key1 = composite_storage_key(kTestAddress1, kTestIncarnation, kTestHashedLocation1.bytes); const auto value1 = spawn_and_wait(view->get(table::kStorageDomain, storage_key1)); REQUIRE(value1 == kTestStorageData1); const auto storage_key2 = composite_storage_key(kTestAddress1, kTestIncarnation, kTestHashedLocation2.bytes); const auto value2 = spawn_and_wait(view->get(table::kStorageDomain, storage_key2)); REQUIRE(value2 == kTestStorageData2); CHECK(cache.state_hit_count() == 2); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 2); CHECK(cache.state_eviction_count() == 0); } SECTION("single code change batch => search hit") { auto batch = new_batch_with_code( kTestStateVersionId0, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_code_changes=*/1); cache.on_new_block(batch); CHECK(cache.latest_code_size() == 1); std::unique_ptr view = spawn_and_wait(cache.get_view(txn)); REQUIRE(view); const ethash::hash256 code_hash{keccak256(kTestCode1)}; const Bytes code_hash_key{code_hash.bytes, kHashLength}; const auto value = spawn_and_wait(view->get_code(code_hash_key)); REQUIRE(value == kTestCode1); CHECK(cache.code_hit_count() == 1); CHECK(cache.code_miss_count() == 0); CHECK(cache.code_key_count() == 1); CHECK(cache.code_eviction_count() == 0); } } TEST_CASE_METHOD(StateCacheTest, "CoherentStateCache::get_view two views", "[db][kv][api][state_cache]") { CoherentCacheConfig config{.block_wait_duration{1ms}}; // keep the block waiting as short as possible CoherentStateCache cache{config}; test_util::MockTransaction txn1, txn2; EXPECT_CALL(txn1, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillRepeatedly(InvokeWithoutArgs([&]() -> Task { co_return state_version_id_bytes(kTestStateVersionId1); })); EXPECT_CALL(txn2, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillRepeatedly(InvokeWithoutArgs([&]() -> Task { co_return state_version_id_bytes(kTestStateVersionId2); })); SECTION("two single-upsert change batches => two search hits in different views") { auto batch1 = new_batch_with_upsert(kTestStateVersionId1, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false); auto batch2 = new_batch_with_upsert(kTestStateVersionId2, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false); cache.on_new_block(batch1); cache.on_new_block(batch2); CHECK(cache.latest_data_size() == 1); CHECK(spawn_and_wait(get_upsert(cache, txn1, kTestAddress1)) == kTestAccountData); CHECK(cache.state_hit_count() == 1); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 1); CHECK(cache.state_eviction_count() == 1); CHECK(spawn_and_wait(get_upsert(cache, txn2, kTestAddress1)) == kTestAccountData); CHECK(cache.state_hit_count() == 2); CHECK(cache.state_miss_count() == 0); CHECK(cache.state_key_count() == 1); CHECK(cache.state_eviction_count() == 1); } SECTION("two code change batches => two search hits in different views") { auto batch1 = new_batch_with_code(kTestStateVersionId1, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_code_changes=*/1); auto batch2 = new_batch_with_code(kTestStateVersionId2, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_code_changes=*/2); cache.on_new_block(batch1); cache.on_new_block(batch2); CHECK(cache.latest_code_size() == 2); CHECK(spawn_and_wait(get_code(cache, txn1, kTestCode1)) == kTestCode1); CHECK(cache.code_hit_count() == 1); CHECK(cache.code_miss_count() == 0); CHECK(cache.code_key_count() == 2); CHECK(cache.code_eviction_count() == 1); CHECK(spawn_and_wait(get_code(cache, txn2, kTestCode1)) == kTestCode1); CHECK(spawn_and_wait(get_code(cache, txn2, kTestCode2)) == kTestCode2); CHECK(cache.code_hit_count() == 3); CHECK(cache.code_miss_count() == 0); CHECK(cache.code_key_count() == 2); CHECK(cache.code_eviction_count() == 1); } } TEST_CASE_METHOD(StateCacheTest, "CoherentStateCache::on_new_block exceed max views", "[db][kv][api][state_cache]") { const CoherentCacheConfig config{.block_wait_duration{1ms}}; // keep the block waiting as short as possible const auto max_views{config.max_views}; CoherentStateCache cache{config}; // Create as many state views as the maximum allowed number for (uint64_t i{0}; i < max_views; ++i) { cache.on_new_block( new_batch_with_upsert(kTestStateVersionId0 + i, kTestBlockNum + i, kTestBlockHash, kTestZeroTxs, /*unwind=*/false)); test_util::MockTransaction txn; EXPECT_CALL(txn, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillOnce(InvokeWithoutArgs([i]() -> Task { co_return state_version_id_bytes(kTestStateVersionId0 + i); })); CHECK_FALSE(spawn_and_wait(cache.get_view(txn))->empty()); } // Next incoming batch with progressive view ID overflows the state views cache.on_new_block( new_batch_with_upsert(kTestStateVersionId0 + max_views, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false)); test_util::MockTransaction txn; EXPECT_CALL(txn, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillOnce(InvokeWithoutArgs([&]() -> Task { co_return state_version_id_bytes(kTestStateVersionId0 + max_views); })); CHECK_FALSE(spawn_and_wait(cache.get_view(txn))->empty()); // Oldest state view i.e. state view with id=0 should have been erased test_util::MockTransaction txn0; EXPECT_CALL(txn0, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillOnce(InvokeWithoutArgs([&]() -> Task { co_return state_version_id_bytes(kTestStateVersionId0); })); CHECK(spawn_and_wait(cache.get_view(txn0))->empty()); } TEST_CASE_METHOD(StateCacheTest, "CoherentStateCache::on_new_block exceed max keys", "[db][kv][api][state_cache]") { static constexpr uint64_t kMaxKeys = 2u; const CoherentCacheConfig config{ .max_views = kDefaultMaxViews, .with_storage = true, .wait_for_new_block = true, .max_state_keys = kMaxKeys, .max_code_keys = kMaxKeys, .block_wait_duration = 1ms}; CoherentStateCache cache{config}; // Create as many data and code keys as the maximum allowed number cache.on_new_block(new_batch_with_upsert_code(kTestStateVersionId0, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_changes=*/kMaxKeys)); CHECK(cache.state_key_count() == kMaxKeys); CHECK(cache.code_key_count() == kMaxKeys); CHECK(cache.state_eviction_count() == 0); CHECK(cache.code_eviction_count() == 0); // Next incoming batch with *new keys* overflows the data and code keys cache.on_new_block(new_batch_with_upsert_code(kTestStateVersionId1, kTestBlockNum + 1, kTestBlockHash, kTestZeroTxs, /*unwind=*/false, /*num_changes=*/4, /*offset=*/2)); CHECK(cache.state_key_count() == kMaxKeys); CHECK(cache.code_key_count() == kMaxKeys); CHECK(cache.state_eviction_count() == kMaxKeys); CHECK(cache.code_eviction_count() == kMaxKeys); } TEST_CASE_METHOD(StateCacheTest, "CoherentStateCache::on_new_block clear the cache on view ID wrapping", "[db][kv][api][state_cache]") { const CoherentCacheConfig config{.block_wait_duration{1ms}}; // keep the block waiting as short as possible const auto max_views{config.max_views}; CoherentStateCache cache{config}; // Create as many state views as the maximum allowed with versions *up to the max version ID* const uint64_t max_version_id = std::numeric_limits::max(); std::vector wrapping_version_ids{max_version_id - 4, max_version_id - 3, max_version_id - 2, max_version_id - 1, max_version_id}; SILKWORM_ASSERT(wrapping_version_ids.size() == max_views); for (uint64_t i{0}; i < wrapping_version_ids.size(); ++i) { const StateVersionId version_id = wrapping_version_ids[i]; cache.on_new_block( new_batch_with_upsert(version_id, kTestBlockNum + i, kTestBlockHash, kTestZeroTxs, /*unwind=*/false)); test_util::MockTransaction txn; EXPECT_CALL(txn, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillOnce(InvokeWithoutArgs([version_id]() -> Task { co_return state_version_id_bytes(version_id); })); CHECK_FALSE(spawn_and_wait(cache.get_view(txn))->empty()); } // Next incoming batch with progressive version ID overflows the state versions const uint64_t next_version_id = wrapping_version_ids.back() + 1; cache.on_new_block( new_batch_with_upsert(next_version_id, kTestBlockNum, kTestBlockHash, kTestZeroTxs, /*unwind=*/false)); test_util::MockTransaction txn; EXPECT_CALL(txn, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillOnce(InvokeWithoutArgs([next_version_id]() -> Task { co_return state_version_id_bytes(next_version_id); })); CHECK_FALSE(spawn_and_wait(cache.get_view(txn))->empty()); // All previous state views should have been erased for (uint64_t i{0}; i < wrapping_version_ids.size(); ++i) { const StateVersionId old_version_id = wrapping_version_ids[i]; test_util::MockTransaction old_txn; EXPECT_CALL(old_txn, get_one(db::table::kSequenceName, string_view_to_byte_view(kPlainStateVersionKey))) .WillOnce(InvokeWithoutArgs([old_version_id]() -> Task { co_return state_version_id_bytes(old_version_id); })); CHECK(spawn_and_wait(cache.get_view(old_txn))->empty()); } } #endif // _WIN32 } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/api/transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "cursor.hpp" #include "endpoint/key_value.hpp" #include "endpoint/temporal_point.hpp" #include "endpoint/temporal_range.hpp" namespace silkworm::db::kv::api { class StateCache; class Transaction { public: using Walker = std::function; Transaction() = default; Transaction(const Transaction&) = delete; Transaction& operator=(const Transaction&) = delete; virtual ~Transaction() = default; virtual StateCache* state_cache() = 0; virtual uint64_t tx_id() const = 0; virtual uint64_t view_id() const = 0; virtual Task open() = 0; virtual Task> cursor(std::string_view table) = 0; virtual Task> cursor_dup_sort(std::string_view table) = 0; virtual bool is_local() const = 0; virtual std::shared_ptr make_storage() = 0; virtual Task close() = 0; virtual Task get(std::string_view table, ByteView key) = 0; virtual Task get_one(std::string_view table, ByteView key) = 0; virtual Task> get_both_range(std::string_view table, ByteView key, ByteView subkey) = 0; // Temporarily here waiting for a better place virtual Task first_txn_num_in_block(BlockNum block_num) = 0; Task user_txn_id_at(BlockNum block_num, uint32_t txn_index = 0) { const auto base_txn_in_block = co_await first_txn_num_in_block(block_num); co_return base_txn_in_block + 1 + txn_index; // + 1 for system txn in the beginning of block } /** Temporal Point Queries **/ // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=true (ts ignored) virtual Task get_latest(GetLatestRequest request) = 0; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=false (ts used) virtual Task get_as_of(GetAsOfRequest request) = 0; // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply); virtual Task history_seek(HistoryPointRequest request) = 0; /** Temporal Range Queries **/ // rpc IndexRange(IndexRangeReq) returns (IndexRangeReply); virtual Task index_range(IndexRangeRequest request) = 0; // rpc HistoryRange(HistoryRangeReq) returns (Pairs); virtual Task history_range(HistoryRangeRequest request) = 0; // rpc RangeAsOf(RangeAsOfReq) returns (Pairs); virtual Task range_as_of(DomainRangeRequest request) = 0; }; } // namespace silkworm::db::kv::api ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/state_change.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_change.hpp" #include #include #include namespace silkworm::db::kv::grpc::client { namespace proto = ::remote; proto::StateChangeRequest request_from_state_change_options(const api::StateChangeOptions& options) { proto::StateChangeRequest request; request.set_with_storage(options.with_storage); request.set_with_transactions(options.with_transactions); return request; } static api::Action action_from_proto(const proto::Action proto_action) { switch (proto_action) { case proto::Action::UPSERT: { return api::Action::kUpsert; } case proto::Action::UPSERT_CODE: { return api::Action::kUpsertCode; } case proto::Action::REMOVE: { return api::Action::kRemove; } case proto::Action::STORAGE: { return api::Action::kStorage; } case proto::Action::CODE: { return api::Action::kCode; } default: { SILKWORM_ASSERT(false); throw; } } } static api::StorageChangeSequence storage_changes_from_proto(const proto::AccountChange& account_change) { api::StorageChangeSequence storage_change_set; if (account_change.storage_changes_size() == 0) { return storage_change_set; } storage_change_set.reserve(static_cast(account_change.storage_changes_size())); for (const auto& proto_storage_change : account_change.storage_changes()) { storage_change_set.emplace_back(api::StorageChange{ .location = rpc::bytes32_from_h256(proto_storage_change.location()), .data = string_to_bytes(proto_storage_change.data()), }); } return storage_change_set; } static api::AccountChangeSequence account_change_set_from_proto(const proto::StateChange& state_change) { api::AccountChangeSequence account_change_set; if (state_change.changes_size() == 0) { return account_change_set; } account_change_set.reserve(static_cast(state_change.changes_size())); for (const auto& proto_account_change : state_change.changes()) { account_change_set.emplace_back(api::AccountChange{ .address = rpc::address_from_h160(proto_account_change.address()), .incarnation = proto_account_change.incarnation(), .change_type = action_from_proto(proto_account_change.action()), .data = string_to_bytes(proto_account_change.data()), .code = string_to_bytes(proto_account_change.code()), .storage_changes = storage_changes_from_proto(proto_account_change), }); } return account_change_set; } static api::ListOfBytes rlp_txs_from_proto(const proto::StateChange& state_change) { api::ListOfBytes rlp_txs; if (state_change.txs_size() == 0) { return rlp_txs; } rlp_txs.reserve(static_cast(state_change.txs_size())); for (const auto& proto_txn : state_change.txs()) { rpc::deserialize_hex_as_bytes(proto_txn, rlp_txs); } return rlp_txs; } api::StateChangeSet state_change_set_from_batch(const proto::StateChangeBatch& batch) { api::StateChangeSet state_change_set{ .state_version_id = batch.state_version_id(), .pending_block_base_fee = batch.pending_block_base_fee(), .block_gas_limit = batch.block_gas_limit(), .finalized_block = batch.finalized_block(), .pending_blob_fee_per_gas = batch.pending_blob_fee_per_gas(), }; state_change_set.state_changes.reserve(static_cast(batch.change_batch_size())); for (const auto& change : batch.change_batch()) { state_change_set.state_changes.emplace_back(api::StateChange{ .direction = change.direction() == proto::Direction::FORWARD ? api::kForward : api::kUnwind, .block_num = change.block_height(), .block_hash = rpc::bytes32_from_h256(change.block_hash()), .account_changes = account_change_set_from_proto(change), .rlp_txs = rlp_txs_from_proto(change), }); } return state_change_set; } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/state_change.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/state_change.hpp" namespace silkworm::db::kv::grpc::client { ::remote::StateChangeRequest request_from_state_change_options(const api::StateChangeOptions&); api::StateChangeSet state_change_set_from_batch(const ::remote::StateChangeBatch&); } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/temporal_point.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "temporal_point.hpp" #include namespace silkworm::db::kv::grpc::client { namespace proto = ::remote; proto::HistorySeekReq make_history_seek_req(const api::HistoryPointRequest& request) { proto::HistorySeekReq req; req.set_tx_id(request.tx_id); req.set_table(request.table); req.set_k(request.key.data(), request.key.size()); req.set_ts(static_cast(request.timestamp)); return req; } api::HistoryPointResult history_seek_result_from_response(const proto::HistorySeekReply& response) { api::HistoryPointResult result; result.success = response.ok(); result.value = string_to_bytes(response.v()); return result; } proto::GetLatestReq make_get_latest_req(const api::GetLatestRequest& request) { proto::GetLatestReq req; req.set_tx_id(request.tx_id); req.set_table(request.table); req.set_k(request.key.data(), request.key.size()); req.set_latest(true); req.set_k2(request.sub_key.data(), request.sub_key.size()); return req; } api::GetLatestResult get_latest_result_from_response(const proto::GetLatestReply& response) { api::GetLatestResult result; result.success = !response.v().empty(); result.value = string_to_bytes(response.v()); return result; } ::remote::GetLatestReq make_get_as_of_req(const api::GetAsOfRequest& request) { proto::GetLatestReq req; req.set_tx_id(request.tx_id); req.set_table(request.table); req.set_k(request.key.data(), request.key.size()); req.set_ts(static_cast(request.timestamp)); req.set_k2(request.sub_key.data(), request.sub_key.size()); return req; } api::GetAsOfResult get_as_of_result_from_response(const ::remote::GetLatestReply& response) { api::GetAsOfResult result; result.success = response.ok(); result.value = string_to_bytes(response.v()); return result; } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/temporal_point.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/temporal_point.hpp" namespace silkworm::db::kv::grpc::client { ::remote::HistorySeekReq make_history_seek_req(const api::HistoryPointRequest&); api::HistoryPointResult history_seek_result_from_response(const ::remote::HistorySeekReply&); ::remote::GetLatestReq make_get_latest_req(const api::GetLatestRequest&); api::GetLatestResult get_latest_result_from_response(const ::remote::GetLatestReply&); ::remote::GetLatestReq make_get_as_of_req(const api::GetAsOfRequest&); api::GetAsOfResult get_as_of_result_from_response(const ::remote::GetLatestReply&); } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/temporal_point_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "temporal_point.hpp" #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::db::kv::grpc::client { using namespace evmc::literals; using namespace silkworm::db::kv::test_util; using namespace silkworm::test_util; namespace proto = ::remote; TEST_CASE("make_history_seek_req", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_history_point_request(), sample_proto_history_seek_request()}, }; for (const auto& [request, expected_req] : fixtures) { SECTION("request: " + std::to_string(request.tx_id)) { const auto& point_request{make_history_seek_req(request)}; // CHECK(point_request == expected_point_request); // requires operator== in gRPC CHECK(point_request.tx_id() == expected_req.tx_id()); CHECK(point_request.table() == expected_req.table()); CHECK(point_request.k() == expected_req.k()); CHECK(point_request.ts() == expected_req.ts()); } } } TEST_CASE("history_get_result_from_response", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_history_seek_response(), sample_history_point_result()}, }; for (const auto& [response, expected_point_result] : fixtures) { SECTION("ok: " + std::to_string(response.ok())) { const auto& point_result{history_seek_result_from_response(response)}; // CHECK(point_result == expected_point_result); // requires operator== in gRPC CHECK(point_result.success == expected_point_result.success); CHECK(point_result.value == expected_point_result.value); } } } TEST_CASE("make_get_as_of_req", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {sample_get_as_of_request(), sample_proto_get_as_of_request()}, }; for (const auto& [request, expected_req] : fixtures) { SECTION("request: " + std::to_string(request.tx_id)) { const auto& point_request{make_get_as_of_req(request)}; // CHECK(point_request == expected_point_request); // requires operator== in gRPC CHECK(point_request.tx_id() == expected_req.tx_id()); CHECK(point_request.table() == expected_req.table()); CHECK(point_request.k() == expected_req.k()); CHECK(point_request.ts() == expected_req.ts()); CHECK(point_request.latest() == expected_req.latest()); CHECK(point_request.k2() == expected_req.k2()); } } } TEST_CASE("get_as_of_result_from_response", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_get_as_of_response(), sample_get_as_of_result()}, }; for (const auto& [response, expected_point_result] : fixtures) { SECTION("ok: " + std::to_string(response.ok())) { const auto& point_result{get_as_of_result_from_response(response)}; // CHECK(point_result == expected_point_result); // requires operator== in gRPC CHECK(point_result.success == expected_point_result.success); CHECK(point_result.value == expected_point_result.value); } } } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/temporal_range.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "temporal_range.hpp" #include #include namespace silkworm::db::kv::grpc::client { namespace proto = ::remote; proto::IndexRangeReq make_index_range_req(const api::IndexRangeRequest& request) { proto::IndexRangeReq req; req.set_tx_id(request.tx_id); req.set_table(request.table); req.set_k(request.key.data(), request.key.size()); req.set_from_ts(request.from_timestamp); req.set_to_ts(request.to_timestamp); req.set_order_ascend(request.ascending_order); req.set_limit(request.limit); req.set_page_size(static_cast(request.page_size)); req.set_page_token(request.page_token); return req; } api::IndexRangeResult index_range_result_from_response(const proto::IndexRangeReply& response) { api::IndexRangeResult result; for (const auto ts : response.timestamps()) { result.timestamps.push_back(static_cast(ts)); } result.next_page_token = response.next_page_token(); return result; } proto::HistoryRangeReq make_history_range_req(const api::HistoryRangeRequest& request) { proto::HistoryRangeReq req; req.set_tx_id(request.tx_id); req.set_table(request.table); req.set_from_ts(request.from_timestamp); req.set_to_ts(request.to_timestamp); req.set_order_ascend(request.ascending_order); req.set_limit(static_cast(request.limit)); req.set_page_size(static_cast(request.page_size)); req.set_page_token(request.page_token); return req; } api::HistoryRangeResult history_range_result_from_response(const proto::Pairs& response) { api::HistoryRangeResult result; for (const auto& key : response.keys()) { result.keys.emplace_back(string_to_bytes(key)); } for (const auto& value : response.values()) { result.values.emplace_back(string_to_bytes(value)); } result.next_page_token = response.next_page_token(); return result; } ::remote::RangeAsOfReq make_domain_range_req(const api::DomainRangeRequest& request) { ::remote::RangeAsOfReq req; req.set_tx_id(request.tx_id); req.set_table(request.table); req.set_from_key(request.from_key.data(), request.from_key.size()); req.set_to_key(request.to_key.data(), request.to_key.size()); if (request.timestamp) { req.set_ts(static_cast(*request.timestamp)); } else { req.set_latest(true); } req.set_order_ascend(request.ascending_order); req.set_limit(static_cast(request.limit)); req.set_page_size(static_cast(request.page_size)); req.set_page_token(request.page_token); return req; } api::DomainRangeResult domain_range_result_from_response(const ::remote::Pairs& response) { api::DomainRangeResult result; for (const auto& hex_key : response.keys()) { rpc::deserialize_hex_as_bytes(hex_key, result.keys); } for (const auto& hex_value : response.values()) { rpc::deserialize_hex_as_bytes(hex_value, result.values); } result.next_page_token = response.next_page_token(); return result; } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/temporal_range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/temporal_range.hpp" namespace silkworm::db::kv::grpc::client { ::remote::IndexRangeReq make_index_range_req(const api::IndexRangeRequest&); api::IndexRangeResult index_range_result_from_response(const ::remote::IndexRangeReply&); ::remote::HistoryRangeReq make_history_range_req(const api::HistoryRangeRequest&); api::HistoryRangeResult history_range_result_from_response(const ::remote::Pairs&); ::remote::RangeAsOfReq make_domain_range_req(const api::DomainRangeRequest&); api::DomainRangeResult domain_range_result_from_response(const ::remote::Pairs&); } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/endpoint/temporal_range_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "temporal_range.hpp" #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::db::kv::grpc::client { using namespace evmc::literals; using namespace silkworm::db::kv::test_util; using namespace silkworm::test_util; namespace proto = ::remote; TEST_CASE("make_index_range_req", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, default_proto_index_range_request()}, {sample_index_range_request(), sample_proto_index_range_request()}, }; for (const auto& [request, expected_req] : fixtures) { SECTION("request: " + std::to_string(request.tx_id)) { const auto& range_request{make_index_range_req(request)}; // CHECK(range_request == expected_range_request); // requires operator== in gRPC CHECK(range_request.tx_id() == expected_req.tx_id()); CHECK(range_request.table() == expected_req.table()); CHECK(range_request.k() == expected_req.k()); CHECK(range_request.from_ts() == expected_req.from_ts()); CHECK(range_request.to_ts() == expected_req.to_ts()); CHECK(range_request.order_ascend() == expected_req.order_ascend()); CHECK(range_request.limit() == expected_req.limit()); CHECK(range_request.page_size() == expected_req.page_size()); CHECK(range_request.page_token() == expected_req.page_token()); } } } TEST_CASE("index_range_result_from_response", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_index_range_response(), sample_index_range_result()}, }; for (const auto& [response, expected_range_result] : fixtures) { SECTION("response: " + response.next_page_token()) { const auto& range_result{index_range_result_from_response(response)}; // CHECK(range_result == expected_range_result); // requires operator== in gRPC CHECK(range_result.timestamps == expected_range_result.timestamps); CHECK(range_result.next_page_token == expected_range_result.next_page_token); } } } TEST_CASE("make_history_range_req", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, default_proto_history_range_request()}, {sample_history_range_request(), sample_proto_history_range_request()}, }; for (const auto& [request, expected_req] : fixtures) { SECTION("request: " + std::to_string(request.tx_id)) { const auto& range_request{make_history_range_req(request)}; // CHECK(range_request == expected_range_request); // requires operator== in gRPC CHECK(range_request.tx_id() == expected_req.tx_id()); CHECK(range_request.table() == expected_req.table()); CHECK(range_request.from_ts() == expected_req.from_ts()); CHECK(range_request.to_ts() == expected_req.to_ts()); CHECK(range_request.order_ascend() == expected_req.order_ascend()); CHECK(range_request.limit() == expected_req.limit()); CHECK(range_request.page_size() == expected_req.page_size()); CHECK(range_request.page_token() == expected_req.page_token()); } } } TEST_CASE("history_range_result_from_response", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_history_range_response(), sample_history_range_result()}, }; for (const auto& [response, expected_range_result] : fixtures) { SECTION("response: " + response.next_page_token()) { const auto& range_result{history_range_result_from_response(response)}; // CHECK(range_result == expected_range_result); // requires operator== in gRPC CHECK(range_result.keys == expected_range_result.keys); CHECK(range_result.values == expected_range_result.values); CHECK(range_result.next_page_token == expected_range_result.next_page_token); } } } TEST_CASE("make_domain_range_req", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, default_proto_domain_range_request()}, {sample_domain_range_request(), sample_proto_domain_range_request()}, }; for (const auto& [request, expected_req] : fixtures) { SECTION("request: " + std::to_string(request.tx_id)) { const auto& range_request{make_domain_range_req(request)}; // CHECK(range_request == expected_range_request); // requires operator== in gRPC CHECK(range_request.tx_id() == expected_req.tx_id()); CHECK(range_request.table() == expected_req.table()); CHECK(range_request.from_key() == expected_req.from_key()); CHECK(range_request.to_key() == expected_req.to_key()); CHECK(range_request.ts() == expected_req.ts()); CHECK(range_request.order_ascend() == expected_req.order_ascend()); CHECK(range_request.limit() == expected_req.limit()); CHECK(range_request.page_size() == expected_req.page_size()); CHECK(range_request.page_token() == expected_req.page_token()); } } } TEST_CASE("domain_range_result_from_response", "[node][remote][kv][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_domain_range_response(), sample_domain_range_result()}, }; for (const auto& [response, expected_range_result] : fixtures) { SECTION("response: " + response.next_page_token()) { const auto& range_result{domain_range_result_from_response(response)}; // CHECK(range_result == expected_range_result); // requires operator== in gRPC CHECK(range_result.keys == expected_range_result.keys); CHECK(range_result.values == expected_range_result.values); CHECK(range_result.next_page_token == expected_range_result.next_page_token); } } } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_client.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_client.hpp" #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include #include #include #include "endpoint/state_change.hpp" #include "remote_transaction.hpp" namespace silkworm::db::kv::grpc::client { namespace proto = ::remote; using Stub = proto::KV::StubInterface; class RemoteClientImpl final : public api::Service { public: RemoteClientImpl(const rpc::ChannelFactory& channel_factory, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers, rpc::DisconnectHook on_disconnect) : channel_{channel_factory()}, stub_{proto::KV::NewStub(channel_)}, grpc_context_{grpc_context}, state_cache_{state_cache}, providers_{std::move(providers)}, on_disconnect_{std::move(on_disconnect)} {} RemoteClientImpl(std::unique_ptr stub, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers, rpc::DisconnectHook on_disconnect) : stub_{std::move(stub)}, grpc_context_{grpc_context}, state_cache_{state_cache}, providers_{std::move(providers)}, on_disconnect_{std::move(on_disconnect)} {} ~RemoteClientImpl() override = default; RemoteClientImpl(const RemoteClientImpl&) = delete; RemoteClientImpl& operator=(const RemoteClientImpl&) = delete; // rpc Version(google.protobuf.Empty) returns (types.VersionReply); Task version() override { co_return api::kCurrentVersion; } // rpc Tx(stream Cursor) returns (stream Pair); Task> begin_transaction() override { auto tx = std::make_unique(*stub_, grpc_context_, state_cache_, providers_); co_await tx->open(); co_return tx; } // rpc StateChanges(StateChangeRequest) returns (stream StateChangeBatch); Task state_changes(const api::StateChangeOptions& options, api::StateChangeConsumer consumer) override { using StateChangesRpc = boost::asio::use_awaitable_t<>::as_default_on_t>; size_t attempt = 0; while (true) { SILK_TRACE << "State changes RPC attempt=" << attempt; try { proto::StateChangeRequest request = request_from_state_change_options(options); auto rpc = std::make_shared(grpc_context_); if (options.cancellation_token) { const bool cancelled = options.cancellation_token->assign([rpc](boost::asio::cancellation_type /*type*/) { rpc->cancel(); }); if (cancelled) { SILK_TRACE << "State changes RPC cancelled while retrying ptr=" << rpc.get(); throw rpc::GrpcStatusError{::grpc::Status::CANCELLED}; } SILK_TRACE << "State changes RPC cancellation handler registered ptr=" << rpc.get(); } if (!co_await rpc->start(*stub_, request)) { ::grpc::Status status = co_await rpc->finish(); SILK_TRACE << "State changes RPC start failed status=" << status; throw rpc::GrpcStatusError{std::move(status)}; } proto::StateChangeBatch batch; while (co_await rpc->read(batch)) { co_await consumer(state_change_set_from_batch(batch)); } ::grpc::Status status = co_await rpc->finish(); if (!status.ok()) { SILK_TRACE << "State changes RPC finish failed status=" << status; throw rpc::GrpcStatusError{std::move(status)}; } co_return; } catch (const rpc::GrpcStatusError& gse) { const auto error_code = gse.status().error_code(); if (error_code == ::grpc::StatusCode::ABORTED || error_code == ::grpc::StatusCode::CANCELLED) { co_return; } SILK_TRACE << "State changes RPC error occurred status=" << gse.status(); } // Next lines must be here even if logically they belong to catch clause (no co_await within catch block) const auto timeout = rpc::backoff_timeout(attempt++, min_backoff_timeout_.count(), max_backoff_timeout_.count()); co_await sleep(std::chrono::milliseconds(timeout)); } } void set_min_backoff_timeout(const std::chrono::milliseconds& min_backoff_timeout) { min_backoff_timeout_ = min_backoff_timeout; } void set_max_backoff_timeout(const std::chrono::milliseconds& max_backoff_timeout) { max_backoff_timeout_ = max_backoff_timeout; } private: std::shared_ptr<::grpc::Channel> channel_; std::unique_ptr stub_; agrpc::GrpcContext& grpc_context_; api::StateCache* state_cache_; chain::Providers providers_; rpc::DisconnectHook on_disconnect_; std::chrono::milliseconds min_backoff_timeout_{rpc::kDefaultMinBackoffReconnectTimeout}; std::chrono::milliseconds max_backoff_timeout_{rpc::kDefaultMaxBackoffReconnectTimeout}; }; RemoteClient::RemoteClient(const rpc::ChannelFactory& channel_factory, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers, rpc::DisconnectHook on_disconnect) : p_impl_{std::make_shared(channel_factory, grpc_context, state_cache, std::move(providers), std::move(on_disconnect))} {} RemoteClient::RemoteClient(std::unique_ptr stub, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers, rpc::DisconnectHook on_disconnect) : p_impl_{std::make_shared(std::move(stub), grpc_context, state_cache, std::move(providers), std::move(on_disconnect))} {} // Must be here (not in header) because RemoteClientImpl size is necessary for std::unique_ptr in PIMPL idiom RemoteClient::~RemoteClient() = default; std::shared_ptr RemoteClient::service() { return p_impl_; } void RemoteClient::set_min_backoff_timeout(const std::chrono::milliseconds& min_timeout) { p_impl_->set_min_backoff_timeout(min_timeout); } void RemoteClient::set_max_backoff_timeout(const std::chrono::milliseconds& max_timeout) { p_impl_->set_max_backoff_timeout(max_timeout); } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "../../api/client.hpp" #include "../../api/service.hpp" #include "../../api/state_cache.hpp" namespace silkworm::db::kv::grpc::client { class RemoteClientImpl; struct RemoteClient : public api::Client { RemoteClient( const rpc::ChannelFactory& channel_factory, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers, std::function()> on_disconnect = []() -> Task { co_return; }); RemoteClient( std::unique_ptr<::remote::KV::StubInterface> stub, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers, std::function()> on_disconnect = []() -> Task { co_return; }); ~RemoteClient() override; std::shared_ptr service() override; void set_min_backoff_timeout(const std::chrono::milliseconds& min_timeout); void set_max_backoff_timeout(const std::chrono::milliseconds& max_timeout); private: std::shared_ptr p_impl_; }; } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_client_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_client.hpp" #include #include #include #include #include #include "../test_util/sample_protos.hpp" namespace silkworm::db::kv::grpc::client { using namespace silkworm::grpc::test_util; using namespace silkworm::db::kv::test_util; namespace proto = ::remote; using StrictMockKVStub = testing::StrictMock; struct RemoteClientTestRunner : public TestRunner { std::unique_ptr state_cache{std::make_unique()}; // We're not testing blocks here, so we don't care about proper block provider chain::BlockProvider block_provider{ [](BlockNum, HashAsSpan, bool, Block&) -> Task { co_return false; }}; // We're not testing blocks here, so we don't care about proper block-number-from-txn-hash provider chain::BlockNumFromTxnHashProvider block_num_from_txn_hash_provider{ [](HashAsSpan) -> Task>> { co_return std::make_pair(0, 0); }}; chain::BlockNumFromBlockHashProvider block_num_from_block_hash_provider{ [](HashAsSpan) -> Task> { co_return std::nullopt; }}; chain::CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number_provider{ [](BlockNum) -> Task> { co_return 0; }}; protected: RemoteClient make_api_client() override { return RemoteClient{std::move(stub_), grpc_context_, state_cache.get(), {block_provider, block_num_from_txn_hash_provider, block_num_from_block_hash_provider, canonical_block_hash_from_number_provider}}; } }; } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_cursor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_cursor.hpp" #include #include #include #include #include #include namespace silkworm::db::kv::grpc::client { Task RemoteCursor::open_cursor(std::string_view table_name, bool is_dup_sorted) { const auto start_time = clock_time::now(); if (cursor_id_ == 0) { SILK_DEBUG << "RemoteCursor::open_cursor opening new cursor for table: " << table_name; auto open_message = remote::Cursor{}; if (is_dup_sorted) { open_message.set_op(remote::Op::OPEN_DUP_SORT); } else { open_message.set_op(remote::Op::OPEN); } open_message.set_bucket_name(std::string{table_name}); cursor_id_ = (co_await write_and_read(open_message)).cursor_id(); SILK_DEBUG << "RemoteCursor::open_cursor cursor: " << cursor_id_ << " for table: " << table_name; } SILK_DEBUG << "RemoteCursor::open_cursor [" << table_name << "] c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return; } Task RemoteCursor::seek(ByteView key) { const auto start_time = clock_time::now(); SILK_DEBUG << "RemoteCursor::seek cursor: " << cursor_id_ << " key: " << key; auto seek_message = remote::Cursor{}; seek_message.set_op(remote::Op::SEEK); seek_message.set_cursor(cursor_id_); seek_message.set_k(key.data(), key.size()); auto seek_pair = co_await write_and_read(seek_message); auto k = string_to_bytes(seek_pair.k()); auto v = string_to_bytes(seek_pair.v()); SILK_DEBUG << "RemoteCursor::seek k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::seek_exact(ByteView key) { const auto start_time = clock_time::now(); SILK_DEBUG << "RemoteCursor::seek_exact cursor: " << cursor_id_ << " key: " << key; auto seek_message = remote::Cursor{}; seek_message.set_op(remote::Op::SEEK_EXACT); seek_message.set_cursor(cursor_id_); seek_message.set_k(key.data(), key.size()); auto seek_pair = co_await write_and_read(seek_message); auto k = string_to_bytes(seek_pair.k()); auto v = string_to_bytes(seek_pair.v()); SILK_DEBUG << "RemoteCursor::seek_exact k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::first() { const auto start_time = clock_time::now(); auto next_message = remote::Cursor{}; next_message.set_op(remote::Op::FIRST); next_message.set_cursor(cursor_id_); auto first_pair = co_await write_and_read(next_message); auto k = string_to_bytes(first_pair.k()); auto v = string_to_bytes(first_pair.v()); SILK_DEBUG << "RemoteCursor::first k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::last() { const auto start_time = clock_time::now(); auto next_message = remote::Cursor{}; next_message.set_op(remote::Op::LAST); next_message.set_cursor(cursor_id_); auto last_pair = co_await write_and_read(next_message); auto k = string_to_bytes(last_pair.k()); auto v = string_to_bytes(last_pair.v()); SILK_DEBUG << "RemoteCursor::last k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::next() { const auto start_time = clock_time::now(); auto next_message = remote::Cursor{}; next_message.set_op(remote::Op::NEXT); next_message.set_cursor(cursor_id_); auto next_pair = co_await write_and_read(next_message); auto k = string_to_bytes(next_pair.k()); auto v = string_to_bytes(next_pair.v()); SILK_DEBUG << "RemoteCursor::next k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::previous() { const auto start_time = clock_time::now(); auto next_message = remote::Cursor{}; next_message.set_op(remote::Op::PREV); next_message.set_cursor(cursor_id_); auto next_pair = co_await write_and_read(next_message); auto k = string_to_bytes(next_pair.k()); auto v = string_to_bytes(next_pair.v()); SILK_DEBUG << "RemoteCursor::previous k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::next_dup() { const auto start_time = clock_time::now(); auto next_message = remote::Cursor{}; next_message.set_op(remote::Op::NEXT_DUP); next_message.set_cursor(cursor_id_); auto next_pair = co_await write_and_read(next_message); auto k = string_to_bytes(next_pair.k()); auto v = string_to_bytes(next_pair.v()); SILK_DEBUG << "RemoteCursor::next k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::seek_both(ByteView key, ByteView value) { const auto start_time = clock_time::now(); SILK_DEBUG << "RemoteCursor::seek_both cursor: " << cursor_id_ << " key: " << key << " subkey: " << value; auto seek_message = remote::Cursor{}; seek_message.set_op(remote::Op::SEEK_BOTH); seek_message.set_cursor(cursor_id_); seek_message.set_k(key.data(), key.size()); seek_message.set_v(value.data(), value.size()); auto seek_pair = co_await write_and_read(seek_message); const auto k = string_to_bytes(seek_pair.k()); const auto v = string_to_bytes(seek_pair.v()); SILK_DEBUG << "RemoteCursor::seek_both k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return v; } Task RemoteCursor::seek_both_exact(ByteView key, ByteView value) { const auto start_time = clock_time::now(); SILK_DEBUG << "RemoteCursor::seek_both_exact cursor: " << cursor_id_ << " key: " << key << " subkey: " << value; auto seek_message = remote::Cursor{}; seek_message.set_op(remote::Op::SEEK_BOTH_EXACT); seek_message.set_cursor(cursor_id_); seek_message.set_k(key.data(), key.size()); seek_message.set_v(value.data(), value.size()); auto seek_pair = co_await write_and_read(seek_message); auto k = string_to_bytes(seek_pair.k()); auto v = string_to_bytes(seek_pair.v()); SILK_DEBUG << "RemoteCursor::seek_both_exact k: " << k << " v: " << v << " c=" << cursor_id_ << " t=" << clock_time::since(start_time); co_return api::KeyValue{std::move(k), std::move(v)}; } Task RemoteCursor::close_cursor() { const auto start_time = clock_time::now(); const auto cursor_id = cursor_id_; if (cursor_id_ != 0) { SILK_DEBUG << "RemoteCursor::close_cursor closing cursor: " << cursor_id_; auto close_message = remote::Cursor{}; close_message.set_op(remote::Op::CLOSE); close_message.set_cursor(cursor_id_); co_await write_and_read(close_message); SILK_DEBUG << "RemoteCursor::close_cursor cursor: " << cursor_id_; cursor_id_ = 0; } SILK_DEBUG << "RemoteCursor::close_cursor c=" << cursor_id << " t=" << clock_time::since(start_time); co_return; } Task<::remote::Pair> RemoteCursor::write_and_read(const ::remote::Cursor& request) { if (!co_await tx_rpc_.write(request)) { const ::grpc::Status status = co_await tx_rpc_.finish(); SILK_TRACE << "Tx RPC write failed status=" << status; throw boost::system::system_error{rpc::to_system_code(status.error_code())}; } TxRpc::Response kv_pair{}; if (!co_await tx_rpc_.read(kv_pair)) { const ::grpc::Status status = co_await tx_rpc_.finish(); SILK_TRACE << "Tx RPC read failed status=" << status; throw boost::system::system_error{rpc::to_system_code(status.error_code())}; } co_return kv_pair; } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "../../api/cursor.hpp" #include "rpc.hpp" namespace silkworm::db::kv::grpc::client { class RemoteCursor : public api::CursorDupSort { public: explicit RemoteCursor(TxRpc& tx_rpc) : tx_rpc_(tx_rpc) {} uint32_t cursor_id() const override { return cursor_id_; }; Task open_cursor(std::string_view table_name, bool is_dup_sorted) override; Task seek(ByteView key) override; Task seek_exact(ByteView key) override; Task first() override; Task last() override; Task next() override; Task previous() override; Task next_dup() override; Task close_cursor() override; Task seek_both(ByteView key, ByteView value) override; Task seek_both_exact(ByteView key, ByteView value) override; private: Task<::remote::Pair> write_and_read(const ::remote::Cursor& request); TxRpc& tx_rpc_; uint32_t cursor_id_{0}; }; } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_cursor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_cursor.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::db::kv::grpc::client { using testing::_; using testing::AllOf; using testing::Eq; using testing::Expectation; using testing::Property; namespace test = rpc::test; // The following constants must stay as std::string/Bytes because gRPC bindings require std::string static const std::string kPlainStateKey{"e0a2bd4258d2768837baa26a28fe71dc079f84c7"}; static const std::string kPlainStateValue; static const silkworm::Bytes kPlainStateKeyBytes{string_view_to_byte_view(kPlainStateKey)}; static const silkworm::Bytes kPlainStateValueBytes{string_view_to_byte_view(kPlainStateValue)}; static const std::string kAccountChangeSetKey{"0000000000532b9f"}; static const std::string kAccountChangeSetSubkey{"0000000000000000000000000000000000000000"}; static const std::string kAccountChangeSetValue{"020944ed67f28fd50bb8e9"}; static const silkworm::Bytes kAccountChangeSetKeyBytes{string_to_bytes(kAccountChangeSetKey)}; static const silkworm::Bytes kAccountChangeSetSubkeyBytes{string_to_bytes(kAccountChangeSetSubkey)}; static const silkworm::Bytes kAccountChangeSetValueBytes{string_to_bytes(kAccountChangeSetValue)}; class RemoteCursorTest : public test_util::KVTestBase { public: RemoteCursorTest() { // Set the call expectations common to all RemoteCursor tests: // remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // AsyncReaderWriter::Read call succeeds w/ tx_id in Pair ignored EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, remote::Pair{})); } // Execute the test preconditions: start a new Tx RPC and read first incoming message (tx_id) Task<::remote::Pair> start_and_read_tx_id() { if (!co_await tx_rpc_.start(*stub_)) { const auto status = co_await tx_rpc_.finish(); throw boost::system::system_error{rpc::to_system_code(status.error_code())}; } ::remote::Pair tx_id_pair; if (!co_await tx_rpc_.read(tx_id_pair)) { const auto status = co_await tx_rpc_.finish(); throw boost::system::system_error{rpc::to_system_code(status.error_code())}; } co_return tx_id_pair; } protected: RemoteCursor remote_cursor_{tx_rpc_}; private: TxRpc tx_rpc_{grpc_context_}; }; #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::open_cursor", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor on the specified table succeeds EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, open_pair)); // Execute the test: opening a cursor on specified table should succeed and cursor should have expected cursor ID CHECK_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); CHECK(remote_cursor_.cursor_id() == 3); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor on specified table fails EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_failure(grpc_context_)); // 2. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test: opening a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.open_cursor("table1", false)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor on specified table succeeds EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Read call fails EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_failure(grpc_context_)); // 3. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status aborted EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test: opening a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.open_cursor("table1", false)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::close_cursor", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to close cursor w/ specified cursor ID succeeds EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::CLOSE)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, remote::Pair{})); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: closing a cursor should succeed and reset the cursor ID CHECK_NOTHROW(spawn_and_wait(remote_cursor_.close_cursor())); CHECK(remote_cursor_.cursor_id() == 0); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to close cursor w/ specified cursor ID fails EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::CLOSE)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: closing a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.close_cursor()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to close cursor w/ specified cursor ID succeeds EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::CLOSE)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: closing a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.close_cursor()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::seek", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kPlainStateKey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair seek_pair; seek_pair.set_cursor_id(3); seek_pair.set_k(kPlainStateKey); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, seek_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should succeed and return the expected value api::KeyValue kv; CHECK_NOTHROW(kv = spawn_and_wait(remote_cursor_.seek(kPlainStateKeyBytes))); CHECK(kv.key == kPlainStateKeyBytes); CHECK(kv.value == kPlainStateValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID fails Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kPlainStateKey))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek(kPlainStateKeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kPlainStateKey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek(kPlainStateKeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::seek_exact", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_EXACT)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kPlainStateKey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair seek_pair; seek_pair.set_cursor_id(3); seek_pair.set_k(kPlainStateKey); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, seek_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should succeed and return the expected value api::KeyValue kv; CHECK_NOTHROW(kv = spawn_and_wait(remote_cursor_.seek_exact(kPlainStateKeyBytes))); CHECK(kv.key == kPlainStateKeyBytes); CHECK(kv.value == kPlainStateValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID fails Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_EXACT)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kPlainStateKey))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek_exact(kPlainStateKeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_EXACT)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kPlainStateKey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek_exact(kPlainStateKeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::first", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to first w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::FIRST)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair first_pair; first_pair.set_cursor_id(3); first_pair.set_k(kPlainStateKey); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, first_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking first key should succeed and return the expected value api::KeyValue kv; CHECK_NOTHROW(kv = spawn_and_wait(remote_cursor_.first())); CHECK(kv.key == kPlainStateKeyBytes); CHECK(kv.value == kPlainStateValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to first w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::FIRST)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_aborted(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking first key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.first()), boost::system::system_error, test::exception_has_aborted_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to first w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::FIRST)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish fails succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.first()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::last", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to last w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::LAST)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair first_pair; first_pair.set_cursor_id(3); first_pair.set_k(kPlainStateKey); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, first_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking last key should succeed and return the expected value api::KeyValue kv; CHECK_NOTHROW(kv = spawn_and_wait(remote_cursor_.last())); CHECK(kv.key == kPlainStateKeyBytes); CHECK(kv.value == kPlainStateValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to last w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::LAST)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_aborted(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking last key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.last()), boost::system::system_error, test::exception_has_aborted_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to last w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write(AllOf(Property(&remote::Cursor::op, Eq(remote::Op::LAST)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.last()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::next", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek next w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::NEXT)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair next_pair; next_pair.set_cursor_id(3); next_pair.set_k(kPlainStateKey); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, next_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking next key should succeed and return the expected value api::KeyValue kv; CHECK_NOTHROW(kv = spawn_and_wait(remote_cursor_.next())); CHECK(kv.key == kPlainStateKeyBytes); CHECK(kv.value == kPlainStateValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek next w/ specified cursor ID fails Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::NEXT)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking next key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.next()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek next w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::NEXT)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.next()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::next_dup", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN_DUP_SORT)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek next w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::NEXT_DUP)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair next_pair; next_pair.set_cursor_id(3); next_pair.set_k(kPlainStateKey); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, next_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", true))); // Execute the test: seeking next key should succeed and return the expected value api::KeyValue kv; CHECK_NOTHROW(kv = spawn_and_wait(remote_cursor_.next_dup())); CHECK(kv.key == kPlainStateKeyBytes); CHECK(kv.value == kPlainStateValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN_DUP_SORT)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek next w/ specified cursor ID fails Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::NEXT_DUP)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", true))); // Execute the test: seeking next key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.next_dup()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN_DUP_SORT)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek next w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::NEXT_DUP)), Property(&remote::Cursor::cursor, Eq(3))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", true))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.next_dup()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::seek_both", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_BOTH)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kAccountChangeSetKey)), Property(&remote::Cursor::v, Eq(kAccountChangeSetSubkey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair seek_pair; seek_pair.set_cursor_id(3); seek_pair.set_k(kAccountChangeSetKey); seek_pair.set_v(kAccountChangeSetValue); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, seek_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should succeed and return the expected value silkworm::Bytes value; CHECK_NOTHROW(value = spawn_and_wait(remote_cursor_.seek_both(kAccountChangeSetKeyBytes, kAccountChangeSetSubkeyBytes))); CHECK(value == kAccountChangeSetValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_BOTH)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kAccountChangeSetKey)), Property(&remote::Cursor::v, Eq(kAccountChangeSetSubkey))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek_both(kAccountChangeSetKeyBytes, kAccountChangeSetSubkeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_BOTH)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kAccountChangeSetKey)), Property(&remote::Cursor::v, Eq(kAccountChangeSetSubkey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek_both(kAccountChangeSetKeyBytes, kAccountChangeSetSubkeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteCursorTest, "RemoteCursor::seek_both_exact", "[rpc][ethdb][kv][remote_cursor]") { // Execute the test common preconditions: start a new Tx RPC and read first incoming message (tx_id) REQUIRE_NOTHROW(spawn_and_wait(start_and_read_tx_id())); SECTION("success") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_BOTH_EXACT)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kAccountChangeSetKey)), Property(&remote::Cursor::v, Eq(kAccountChangeSetSubkey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read calls succeed setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); remote::Pair seek_pair; seek_pair.set_cursor_id(3); seek_pair.set_k(kAccountChangeSetKey); seek_pair.set_v(kAccountChangeSetValue); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_success_with(grpc_context_, seek_pair)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should succeed and return the expected value api::KeyValue kv; CHECK_NOTHROW(kv = spawn_and_wait(remote_cursor_.seek_both_exact(kAccountChangeSetKeyBytes, kAccountChangeSetSubkeyBytes))); CHECK(kv.key == kAccountChangeSetKeyBytes); CHECK(kv.value == kAccountChangeSetValueBytes); } SECTION("failure in write") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_BOTH_EXACT)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kAccountChangeSetKey)), Property(&remote::Cursor::v, Eq(kAccountChangeSetSubkey))), _)) .After(open) .WillOnce(test::write_failure(grpc_context_)); // 3. AsyncReaderWriter::Read call succeeds setting the specified cursor ID remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)); // 4. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek_both_exact(kAccountChangeSetKeyBytes, kAccountChangeSetSubkeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. AsyncReaderWriter::Write call to open cursor succeeds Expectation open = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::OPEN)), Property(&remote::Cursor::bucket_name, Eq("table1"))), _)) .WillOnce(test::write_success(grpc_context_)); // 2. AsyncReaderWriter::Write call to seek w/ specified cursor ID succeeds Expectation seek = EXPECT_CALL(reader_writer_, Write( AllOf(Property(&remote::Cursor::op, Eq(remote::Op::SEEK_BOTH_EXACT)), Property(&remote::Cursor::cursor, Eq(3)), Property(&remote::Cursor::k, Eq(kAccountChangeSetKey)), Property(&remote::Cursor::v, Eq(kAccountChangeSetSubkey))), _)) .After(open) .WillOnce(test::write_success(grpc_context_)); // 3. AsyncReaderWriter::Read 1st call succeeds setting the specified cursor ID, 2nd fails remote::Pair open_pair; open_pair.set_cursor_id(3); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, open_pair)) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call fails w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: open a new cursor on specified table REQUIRE_NOTHROW(spawn_and_wait(remote_cursor_.open_cursor("table1", false))); // Execute the test: seeking a key should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_cursor_.seek_both_exact(kAccountChangeSetKeyBytes, kAccountChangeSetSubkeyBytes)), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_transaction.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_transaction.hpp" #include #include #include #include #include #include "../../api/endpoint/paginated_sequence.hpp" #include "endpoint/temporal_point.hpp" #include "endpoint/temporal_range.hpp" namespace silkworm::db::kv::grpc::client { namespace proto = ::remote; using Stub = proto::KV::StubInterface; RemoteTransaction::RemoteTransaction( Stub& stub, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers) : BaseTransaction(state_cache), providers_{std::move(providers)}, stub_{stub}, grpc_context_{grpc_context}, tx_rpc_{grpc_context_} {} Task RemoteTransaction::open() { start_called_ = true; if (!co_await tx_rpc_.start(stub_)) { const ::grpc::Status status = co_await tx_rpc_.finish(); SILK_TRACE << "Tx RPC start failed status=" << status; throw boost::system::system_error{rpc::to_system_code(status.error_code())}; } TxRpc::Response tx_id_view_id_pair{}; if (!co_await tx_rpc_.read(tx_id_view_id_pair)) { const ::grpc::Status status = co_await tx_rpc_.finish(); SILK_TRACE << "Tx RPC initial read failed status=" << status; throw boost::system::system_error{rpc::to_system_code(status.error_code())}; } tx_id_ = tx_id_view_id_pair.tx_id(); view_id_ = tx_id_view_id_pair.view_id(); } Task> RemoteTransaction::cursor(std::string_view table) { if (!start_called_) { throw boost::system::system_error{rpc::to_system_code(::grpc::StatusCode::INTERNAL)}; } co_return co_await get_cursor(table, false); } Task> RemoteTransaction::cursor_dup_sort(std::string_view table) { if (!start_called_) { throw boost::system::system_error{rpc::to_system_code(::grpc::StatusCode::INTERNAL)}; } co_return co_await get_cursor(table, true); } Task RemoteTransaction::close() { if (!start_called_) { throw boost::system::system_error{rpc::to_system_code(::grpc::StatusCode::INTERNAL)}; } ::grpc::Status status = co_await tx_rpc_.finish(); if (!status.ok()) { SILK_TRACE << "Tx RPC finish failed status=" << status; throw boost::system::system_error{rpc::to_system_code(status.error_code())}; } cursors_.clear(); tx_id_ = 0; view_id_ = 0; } Task> RemoteTransaction::get_cursor(std::string_view table_view, bool is_cursor_dup_sort) { std::string table{table_view}; if (is_cursor_dup_sort) { const auto cursor_it = dup_cursors_.find(table); if (cursor_it != dup_cursors_.end()) { co_return cursor_it->second; } } else { const auto cursor_it = cursors_.find(table); if (cursor_it != cursors_.end()) { co_return cursor_it->second; } } auto cursor = std::make_shared(tx_rpc_); co_await cursor->open_cursor(table, is_cursor_dup_sort); if (is_cursor_dup_sort) { dup_cursors_[table] = cursor; } else { cursors_[table] = cursor; } co_return cursor; } std::shared_ptr RemoteTransaction::make_storage() { return std::make_shared(*this, providers_); } Task RemoteTransaction::first_txn_num_in_block(BlockNum block_num) { const auto min_txn_num = co_await txn::min_tx_num(*this, block_num, providers_.canonical_body_for_storage); co_return min_txn_num + /*txn_index*/ 0; } Task RemoteTransaction::get_latest(api::GetLatestRequest request) { try { request.tx_id = tx_id_; auto req = make_get_latest_req(request); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetLatest, stub_, std::move(req), grpc_context_); auto result = get_latest_result_from_response(reply); co_return result; } catch (rpc::GrpcStatusError& gse) { SILK_WARN << "KV::GetLatest (latest) RPC failed status=" << gse.status(); throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())}; } } Task RemoteTransaction::get_as_of(api::GetAsOfRequest request) { try { request.tx_id = tx_id_; auto req = make_get_as_of_req(request); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetLatest, stub_, std::move(req), grpc_context_); auto result = get_as_of_result_from_response(reply); co_return result; } catch (rpc::GrpcStatusError& gse) { SILK_WARN << "KV::GetLatest (as_of) RPC failed status=" << gse.status(); throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())}; } } Task RemoteTransaction::history_seek(api::HistoryPointRequest request) { try { request.tx_id = tx_id_; auto req = make_history_seek_req(request); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHistorySeek, stub_, std::move(req), grpc_context_); auto result = history_seek_result_from_response(reply); co_return result; } catch (rpc::GrpcStatusError& gse) { SILK_WARN << "KV::HistorySeek RPC failed status=" << gse.status(); throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())}; } } Task RemoteTransaction::index_range(api::IndexRangeRequest request) { auto paginator = [&, request = std::move(request)](api::PaginatedTimestamps::PageToken page_token) mutable -> Task { request.tx_id = tx_id_; request.page_token = std::move(page_token); auto req = make_index_range_req(request); try { const auto reply = co_await rpc::unary_rpc(&Stub::AsyncIndexRange, stub_, std::move(req), grpc_context_); auto result = index_range_result_from_response(reply); co_return api::PaginatedTimestamps::PageResult{std::move(result.timestamps), std::move(result.next_page_token)}; } catch (rpc::GrpcStatusError& gse) { SILK_WARN << "KV::IndexRange RPC failed status=" << gse.status(); throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())}; } }; co_return api::TimestampStreamReply{api::PaginatedTimestamps{std::move(paginator)}}; } Task RemoteTransaction::history_range(api::HistoryRangeRequest request) { auto paginator = [&, request = std::move(request)](api::PaginatedKeysValues::PageToken page_token) mutable -> Task { request.tx_id = tx_id_; request.page_token = std::move(page_token); auto req = make_history_range_req(request); try { const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHistoryRange, stub_, std::move(req), grpc_context_); auto result = history_range_result_from_response(reply); co_return api::PaginatedKeysValues::PageResult{std::move(result.keys), std::move(result.values), std::move(result.next_page_token)}; } catch (rpc::GrpcStatusError& gse) { SILK_WARN << "KV::HistoryRange RPC failed status=" << gse.status(); throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())}; } }; co_return api::KeyValueStreamReply{api::PaginatedKeysValues{std::move(paginator)}}; } Task RemoteTransaction::range_as_of(api::DomainRangeRequest request) { auto paginator = [&, request = std::move(request)](api::PaginatedKeysValues::PageToken page_token) mutable -> Task { request.tx_id = tx_id_; request.page_token = std::move(page_token); auto req = make_domain_range_req(request); try { const auto reply = co_await rpc::unary_rpc(&Stub::AsyncRangeAsOf, stub_, std::move(req), grpc_context_); auto result = history_range_result_from_response(reply); co_return api::PaginatedKeysValues::PageResult{std::move(result.keys), std::move(result.values), std::move(result.next_page_token)}; } catch (rpc::GrpcStatusError& gse) { SILK_WARN << "KV::RangeAsOf RPC failed status=" << gse.status(); throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())}; } }; co_return api::KeyValueStreamReply{api::PaginatedKeysValues{std::move(paginator)}}; } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #include #pragma GCC diagnostic pop #include #include #include #include #include #include "remote_cursor.hpp" #include "rpc.hpp" namespace silkworm::db::kv::grpc::client { class RemoteTransaction : public api::BaseTransaction { public: RemoteTransaction(::remote::KV::StubInterface& stub, agrpc::GrpcContext& grpc_context, api::StateCache* state_cache, chain::Providers providers); ~RemoteTransaction() override = default; uint64_t tx_id() const override { return tx_id_; } uint64_t view_id() const override { return view_id_; } Task open() override; Task> cursor(std::string_view table) override; Task> cursor_dup_sort(std::string_view table) override; std::shared_ptr make_storage() override; Task first_txn_num_in_block(BlockNum block_num) override; Task close() override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=true (ts ignored) Task get_latest(api::GetLatestRequest request) override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=false (ts used) Task get_as_of(api::GetAsOfRequest request) override; // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply); Task history_seek(api::HistoryPointRequest request) override; // rpc IndexRange(IndexRangeReq) returns (IndexRangeReply); Task index_range(api::IndexRangeRequest request) override; // rpc HistoryRange(HistoryRangeReq) returns (Pairs); Task history_range(api::HistoryRangeRequest request) override; // rpc RangeAsOf(RangeAsOfReq) returns (Pairs); Task range_as_of(api::DomainRangeRequest request) override; private: Task> get_cursor(std::string_view table_view, bool is_cursor_dup_sort); chain::Providers providers_; std::map> cursors_; std::map> dup_cursors_; ::remote::KV::StubInterface& stub_; agrpc::GrpcContext& grpc_context_; //! The wrapped Tx RPC client provided by agrpc TxRpc tx_rpc_; //! Flag indicating if agrpc::ClientRPC<>::start has been called on Tx RPC or not. This is necessary to avoid //! a crash in agrpc if you call agrpc::ClientRPC<>::finish before calling agrpc::ClientRPC<>::start bool start_called_{false}; uint64_t tx_id_{0}; uint64_t view_id_{0}; }; } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/remote_transaction_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_transaction.hpp" #include #include #include #include #include #include #include #include #include #include "../test_util/sample_protos.hpp" namespace silkworm::db::kv::grpc::client { using testing::_; namespace proto = ::remote; namespace test = rpc::test; using PaginatedKV = api::PaginatedSequencePair; class RemoteTransactionTest : public db::test_util::KVTestBase { protected: RemoteTransaction remote_tx_{*stub_, grpc_context_, &state_cache_, chain::Providers{}}; private: api::CoherentStateCache state_cache_; }; static remote::Pair make_fake_tx_created_pair() { remote::Pair pair; pair.set_tx_id(1); pair.set_view_id(4); return pair; } bool ensure_fake_tx_created_tx_id(const RemoteTransaction& remote_tx) { return remote_tx.tx_id() == 1; } bool ensure_fake_tx_created_view_id(const RemoteTransaction& remote_tx) { return remote_tx.view_id() == 4; } #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::open", "[db][kv][grpc][client][remote_transaction]") { SECTION("success") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call succeeds setting the specified transaction ID remote::Pair pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, pair)); // Execute the test: opening a transaction should succeed and transaction should have expected transaction ID CHECK_NOTHROW(spawn_and_wait(remote_tx_.open())); CHECK(ensure_fake_tx_created_tx_id(remote_tx_)); CHECK(ensure_fake_tx_created_view_id(remote_tx_)); } SECTION("failure in request") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call fails expect_request_async_tx(/*ok=*/false); // 2. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 3. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test: opening a transaction should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.open()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in read") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call fails EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_failure(grpc_context_)); // 3. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)).WillOnce(test::writes_done_failure(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test: opening a transaction should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.open()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::close", "[db][kv][grpc][client][remote_transaction]") { SECTION("throw w/o open") { // Execute the test: closing the transaction should throw CHECK_THROWS_AS(spawn_and_wait(remote_tx_.close()), boost::system::system_error); } SECTION("success w/ open w/o cursor in table") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call succeeds w/ expected transaction ID set in pair remote::Pair pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, pair)); // 3. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status OK EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_ok(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected tx_id REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: closing the transaction should succeed and transaction should have zero transaction ID CHECK_NOTHROW(spawn_and_wait(remote_tx_.close())); CHECK(remote_tx_.tx_id() == 0); CHECK(remote_tx_.view_id() == 0); } SECTION("success w/ open w/ cursor in table") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call succeeds w/ expected transaction ID set in pair remote::Pair pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read).Times(2).WillRepeatedly(test::read_success_with(grpc_context_, pair)); // 3. AsyncReaderWriter::Write call succeeds EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 5. AsyncReaderWriter::Finish call succeeds w/ status OK EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_ok(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // open a cursor within such transaction const auto cursor = spawn_and_wait(remote_tx_.cursor("table1")); REQUIRE(cursor != nullptr); // Execute the test: closing the transaction should succeed and transaction should have zero transaction ID CHECK_NOTHROW(spawn_and_wait(remote_tx_.close())); CHECK(remote_tx_.view_id() == 0); } SECTION("failure in write") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call succeeds w/ expected transaction ID set in pair remote::Pair pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, pair)); // 3. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_failure(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: closing the transaction should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.close()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in finish") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call succeeds w/ expected transaction ID set in pair remote::Pair pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, pair)); // 4. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 4. AsyncReaderWriter::Finish call fails EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_error(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: closing the transaction should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.close()), boost::system::system_error, test::exception_has_unknown_grpc_status_code()); } } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::cursor", "[db][kv][grpc][client][remote_transaction]") { SECTION("throw w/o open") { // Execute the test: getting cursor from the transaction should throw CHECK_THROWS_AS(spawn_and_wait(remote_tx_.cursor("table1")), boost::system::system_error); } SECTION("success") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read calls succeed w/ specified transaction and cursor IDs remote::Pair tx_id_pair{make_fake_tx_created_pair()}; tx_id_pair.set_view_id(4); remote::Pair cursor_id_pair; cursor_id_pair.set_cursor_id(0x23); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, tx_id_pair)) .WillOnce(test::read_success_with(grpc_context_, cursor_id_pair)); // 3. AsyncReaderWriter::Write call succeeds EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 5. AsyncReaderWriter::Finish call succeeds w/ status OK EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_ok(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: // 1. opening a cursor should succeed and cursor should have expected cursor ID std::shared_ptr cursor1; CHECK_NOTHROW(cursor1 = spawn_and_wait(remote_tx_.cursor("table1"))); CHECK(cursor1->cursor_id() == 0x23); // 2. opening another cursor on the same table should succeed and cursor should have expected cursor ID std::shared_ptr cursor2; CHECK_NOTHROW(cursor2 = spawn_and_wait(remote_tx_.cursor("table1"))); CHECK(cursor2->cursor_id() == 0x23); // Execute the test postconditions: // close the transaction succeeds CHECK_NOTHROW(spawn_and_wait(remote_tx_.close())); } SECTION("failure in read") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read 1st call succeeds w/ specified transaction ID, 2nd call fails remote::Pair tx_id_pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, tx_id_pair)) .WillOnce(test::read_failure(grpc_context_)); // 3. AsyncReaderWriter::Write call succeeds EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)) .WillOnce(test::writes_done_failure(grpc_context_)) .WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish) .WillOnce(test::finish_streaming_cancelled(grpc_context_)) .WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: opening a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.cursor("table1")), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); // Execute the test postconditions: // close the transaction raises an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.close()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in write") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call succeeds w/ specified transaction ID remote::Pair tx_id_pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, tx_id_pair)); // 3. AsyncReaderWriter::Write call fails EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_failure(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish) .WillOnce(test::finish_streaming_cancelled(grpc_context_)) .WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: opening a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.cursor("table1")), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); // Execute the test postconditions: // close the transaction raises an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.close()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::cursor_dup_sort", "[db][kv][grpc][client][remote_transaction]") { SECTION("throw w/o open") { // Execute the test preconditions: none // Execute the test: getting cursor_dup_sort from the transaction should throw CHECK_THROWS_AS(spawn_and_wait(remote_tx_.cursor_dup_sort("table1")), boost::system::system_error); // Execute the test postconditions: // close the transaction raises an exception CHECK_THROWS_AS(spawn_and_wait(remote_tx_.close()), boost::system::system_error); } SECTION("success") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read calls succeed w/ specified transaction and cursor IDs remote::Pair tx_id_pair{make_fake_tx_created_pair()}; remote::Pair cursor_id_pair; cursor_id_pair.set_cursor_id(0x23); EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, tx_id_pair)) .WillOnce(test::read_success_with(grpc_context_, cursor_id_pair)); // 3. AsyncReaderWriter::Write call succeeds EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 5. AsyncReaderWriter::Finish call succeeds w/ status OK EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_ok(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: // 1. opening a cursor should succeed and cursor should have expected cursor ID std::shared_ptr cursor1; CHECK_NOTHROW(cursor1 = spawn_and_wait(remote_tx_.cursor_dup_sort("table1"))); CHECK(cursor1->cursor_id() == 0x23); // 2. opening another cursor on the same table should succeed and cursor should have expected cursor ID std::shared_ptr cursor2; CHECK_NOTHROW(cursor2 = spawn_and_wait(remote_tx_.cursor_dup_sort("table1"))); CHECK(cursor2->cursor_id() == 0x23); // Execute the test postconditions: // close the transaction succeeds CHECK_NOTHROW(spawn_and_wait(remote_tx_.close())); } SECTION("failure in read") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read 1st call succeeds w/ specified transaction ID, 2nd call fails remote::Pair tx_id_pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, tx_id_pair)) .WillOnce(test::read_failure(grpc_context_)); // 3. AsyncReaderWriter::Write call succeeds EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_success(grpc_context_)); // 4. AsyncReaderWriter::WritesDone call fails EXPECT_CALL(reader_writer_, WritesDone(_)) .WillOnce(test::writes_done_failure(grpc_context_)) .WillOnce(test::writes_done_failure(grpc_context_)); // 5. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish) .WillOnce(test::finish_streaming_cancelled(grpc_context_)) .WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: opening a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.cursor_dup_sort("table1")), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); // Execute the test postconditions: // close the transaction raises an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.close()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } SECTION("failure in write") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read call succeeds w/ specified transaction ID remote::Pair tx_id_pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read).WillOnce(test::read_success_with(grpc_context_, tx_id_pair)); // 3. AsyncReaderWriter::Write call fails EXPECT_CALL(reader_writer_, Write(_, _)).WillOnce(test::write_failure(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status cancelled EXPECT_CALL(reader_writer_, Finish) .WillOnce(test::finish_streaming_cancelled(grpc_context_)) .WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: opening a cursor should raise an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.cursor_dup_sort("table1")), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); // Execute the test postconditions: // close the transaction raises an exception w/ expected gRPC status code CHECK_THROWS_MATCHES(spawn_and_wait(remote_tx_.close()), boost::system::system_error, test::exception_has_cancelled_grpc_status_code()); } } #endif // SILKWORM_SANITIZE TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::get_latest", "[db][kv][grpc][client][remote_transaction]") { using db::kv::test_util::sample_proto_get_latest_response; auto get_latest = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well // Before GCC 13, we must avoid passing api::GetLatestRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 api::GetLatestRequest request; const api::GetLatestResult result = co_await remote_tx_.get_latest(std::move(request)); #else const api::GetLatestResult result = co_await remote_tx_.get_latest(api::GetLatestRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return result; }; rpc::test::StrictMockAsyncResponseReader reader; EXPECT_CALL(*stub_, AsyncGetLatestRaw).WillOnce(testing::Return(&reader)); api::GetLatestResult result; SECTION("call get_latest and get result") { proto::GetLatestReply reply{sample_proto_get_latest_response()}; EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_with(grpc_context_, std::move(reply))); CHECK_NOTHROW((result = spawn_and_wait(get_latest))); CHECK(result.success); CHECK(result.value == from_hex("ff00ff00")); } SECTION("call get_latest and get empty result") { EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_ok(grpc_context_)); CHECK_NOTHROW((result = spawn_and_wait(get_latest))); CHECK_FALSE(result.success); CHECK(result.value.empty()); } SECTION("call get_latest and get error") { EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS(spawn_and_wait(get_latest), boost::system::system_error); } } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::get_as_of", "[db][kv][grpc][client][remote_transaction]") { using db::kv::test_util::sample_proto_get_as_of_response; auto get_as_of = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well // Before GCC 13, we must avoid passing api::GetAsOfRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 api::GetAsOfRequest request; const api::GetAsOfResult result = co_await remote_tx_.get_as_of(std::move(request)); #else const api::GetAsOfResult result = co_await remote_tx_.get_as_of(api::GetAsOfRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return result; }; rpc::test::StrictMockAsyncResponseReader reader; EXPECT_CALL(*stub_, AsyncGetLatestRaw).WillOnce(testing::Return(&reader)); api::GetAsOfResult result; SECTION("call get_as_of and get result") { proto::GetLatestReply reply{sample_proto_get_as_of_response()}; EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_with(grpc_context_, std::move(reply))); CHECK_NOTHROW((result = spawn_and_wait(get_as_of))); CHECK(result.success); CHECK(result.value == from_hex("ff00ff00")); } SECTION("call get_as_of and get empty result") { EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_ok(grpc_context_)); CHECK_NOTHROW((result = spawn_and_wait(get_as_of))); CHECK_FALSE(result.success); CHECK(result.value.empty()); } SECTION("call get_as_of and get error") { EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS(spawn_and_wait(get_as_of), boost::system::system_error); } } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::history_seek", "[db][kv][grpc][client][remote_transaction]") { using db::kv::test_util::sample_proto_history_seek_response; auto history_seek = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well // Before GCC 13, we must avoid passing api::HistoryPointRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 api::HistoryPointRequest request; const api::HistoryPointResult result = co_await remote_tx_.history_seek(std::move(request)); #else const api::HistoryPointResult result = co_await remote_tx_.history_seek(api::HistoryPointRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return result; }; rpc::test::StrictMockAsyncResponseReader reader; EXPECT_CALL(*stub_, AsyncHistorySeekRaw).WillOnce(testing::Return(&reader)); api::HistoryPointResult result; SECTION("call history_seek and get result") { proto::HistorySeekReply reply{sample_proto_history_seek_response()}; EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_with(grpc_context_, std::move(reply))); CHECK_NOTHROW((result = spawn_and_wait(history_seek))); CHECK(result.success); CHECK(result.value == from_hex("ff00ff00")); } SECTION("call history_seek and get empty result") { EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_ok(grpc_context_)); CHECK_NOTHROW((result = spawn_and_wait(history_seek))); CHECK_FALSE(result.success); CHECK(result.value.empty()); } SECTION("call history_seek and get error") { EXPECT_CALL(reader, Finish).WillOnce(rpc::test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS(spawn_and_wait(history_seek), boost::system::system_error); } } static ::remote::IndexRangeReply make_index_range_reply(const api::ListOfTimestamp& timestamps, bool has_more) { proto::IndexRangeReply reply; for (const auto ts : timestamps) { reply.add_timestamps(static_cast(ts)); } reply.set_next_page_token(has_more ? "token" : ""); return reply; } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::index_range", "[db][kv][grpc][client][remote_transaction]") { auto flatten_index_range = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well // Before GCC 13, we must avoid passing api::IndexRangeRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 api::IndexRangeRequest request; auto timestamps = co_await remote_tx_.index_range(std::move(request)); #else auto timestamps = co_await remote_tx_.index_range(api::IndexRangeRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return co_await api::stream_to_vector(timestamps); }; rpc::test::StrictMockAsyncResponseReader reader; SECTION("throw on error") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncIndexRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncIndexRangeRaw).WillOnce(Return(&reader)); // 2. AsyncResponseReader<>::Finish call fails EXPECT_CALL(reader, Finish).WillOnce(test::finish_error_aborted(grpc_context_, proto::IndexRangeReply{})); // Execute the test: trying to *use* index_range lazy result should throw CHECK_THROWS_AS(spawn_and_wait(flatten_index_range), boost::system::system_error); } SECTION("success: empty") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncIndexRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncIndexRangeRaw).WillRepeatedly(Return(&reader)); // 2. AsyncResponseReader<>::Finish call succeeds 3 times EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_index_range_reply({}, /*has_more*/ false))); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_index_range).empty()); } SECTION("success: one page") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncIndexRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncIndexRangeRaw).WillRepeatedly(Return(&reader)); // 2. AsyncResponseReader<>::Finish call succeeds EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_index_range_reply({19}, /*has_more*/ false))); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_index_range) == api::ListOfTimestamp{19}); } SECTION("success: more than one page") { // Set the call expectations: [just once let's do the whole procedure by calling Tx first] // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read calls succeed w/ specified transaction and cursor IDs remote::Pair tx_id_pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, tx_id_pair)); // 3. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status OK EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_ok(grpc_context_)); // 5. remote::KV::StubInterface::AsyncIndexRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncIndexRangeRaw).WillRepeatedly(Return(&reader)); // 6. AsyncResponseReader<>::Finish call succeeds 3 times EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_index_range_reply({1, 2, 3}, /*has_more*/ true))) .WillOnce(test::finish_with(grpc_context_, make_index_range_reply({4, 5, 6}, /*has_more*/ true))) .WillOnce(test::finish_with(grpc_context_, make_index_range_reply({7}, /*has_more*/ false))); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_index_range) == api::ListOfTimestamp{1, 2, 3, 4, 5, 6, 7}); // Execute the test postconditions: // close the transaction succeeds CHECK_NOTHROW(spawn_and_wait(remote_tx_.close())); } } static proto::Pairs make_key_value_range_reply(const std::vector& keys_and_values, bool has_more) { proto::Pairs reply; for (const auto& kv : keys_and_values) { reply.add_keys(bytes_to_string(kv.key)); reply.add_values(bytes_to_string(kv.value)); } reply.set_next_page_token(has_more ? "token" : ""); return reply; } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::history_range", "[db][kv][grpc][client][remote_transaction]") { const api::KeyValue kv1{*from_hex("0011FF0011AA"), *from_hex("0011")}; const api::KeyValue kv2{*from_hex("0011FF0011BB"), *from_hex("0022")}; const api::KeyValue kv3{*from_hex("0011FF0011CC"), *from_hex("0033")}; auto flatten_history_range = [&]() -> Task> { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well // Before GCC 13, we must avoid passing api::HistoryRangeRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 api::HistoryRangeRequest request; auto keys_and_values = co_await remote_tx_.history_range(std::move(request)); #else auto keys_and_values = co_await remote_tx_.history_range(api::HistoryRangeRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return co_await stream_to_vector(keys_and_values); }; rpc::test::StrictMockAsyncResponseReader reader; SECTION("throw on error") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncHistoryRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncHistoryRangeRaw).WillOnce(Return(&reader)); // 2. AsyncResponseReader<>::Finish call fails EXPECT_CALL(reader, Finish).WillOnce(test::finish_error_aborted(grpc_context_, proto::Pairs{})); // Execute the test: trying to *use* index_range lazy result should throw CHECK_THROWS_AS(spawn_and_wait(flatten_history_range), boost::system::system_error); } SECTION("success: empty") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncHistoryRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncHistoryRangeRaw).WillRepeatedly(Return(&reader)); // 2. AsyncResponseReader<>::Finish call succeeds 3 times EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({}, /*has_more*/ false))); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_history_range).empty()); } SECTION("success: one page") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncHistoryRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncHistoryRangeRaw).WillRepeatedly(Return(&reader)); // 2. AsyncResponseReader<>::Finish call succeeds EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv1}, /*has_more*/ false))); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_history_range) == std::vector{kv1}); } SECTION("success: more than one page") { // Set the call expectations: [just once let's do the whole procedure by calling Tx first] // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read calls succeed w/ specified transaction and cursor IDs remote::Pair tx_id_pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, tx_id_pair)); // 3. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status OK EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_ok(grpc_context_)); // 5. remote::KV::StubInterface::AsyncHistoryRangeRaw call succeeds EXPECT_CALL(*stub_, AsyncHistoryRangeRaw).WillRepeatedly(Return(&reader)); // 6. AsyncResponseReader<>::Finish call succeeds 3 times EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv1, kv2}, /*has_more*/ true))) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv2, kv1}, /*has_more*/ true))) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv3}, /*has_more*/ false))); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_history_range) == std::vector{kv1, kv2, kv2, kv1, kv3}); // Execute the test postconditions: // close the transaction succeeds CHECK_NOTHROW(spawn_and_wait(remote_tx_.close())); } } TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::range_as_of", "[db][kv][grpc][client][remote_transaction]") { const api::KeyValue kv1{*from_hex("0011FF0011AA"), *from_hex("0011")}; const api::KeyValue kv2{*from_hex("0011FF0011BB"), *from_hex("0022")}; const api::KeyValue kv3{*from_hex("0011FF0011CC"), *from_hex("0033")}; auto flatten_domain_range = [&]() -> Task> { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well // Before GCC 13, we must avoid passing api::DomainRangeRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 api::DomainRangeRequest request; auto keys_and_values = co_await remote_tx_.range_as_of(std::move(request)); #else auto keys_and_values = co_await remote_tx_.range_as_of(api::DomainRangeRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return co_await stream_to_vector(keys_and_values); }; rpc::test::StrictMockAsyncResponseReader reader; SECTION("throw on error") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncRangeAsOfRaw call succeeds EXPECT_CALL(*stub_, AsyncRangeAsOfRaw).WillOnce(Return(&reader)); // 2. AsyncResponseReader<>::Finish call fails EXPECT_CALL(reader, Finish).WillOnce(test::finish_error_aborted(grpc_context_, proto::Pairs{})); // Execute the test: trying to *use* index_range lazy result should throw CHECK_THROWS_AS(spawn_and_wait(flatten_domain_range), boost::system::system_error); } SECTION("success: empty") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncRangeAsOfRaw call succeeds EXPECT_CALL(*stub_, AsyncRangeAsOfRaw).WillRepeatedly(Return(&reader)); // 2. AsyncResponseReader<>::Finish call succeeds 3 times EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({}, /*has_more*/ false))); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_domain_range).empty()); } SECTION("success: one page") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncRangeAsOfRaw call succeeds EXPECT_CALL(*stub_, AsyncRangeAsOfRaw).WillRepeatedly(Return(&reader)); // 2. AsyncResponseReader<>::Finish call succeeds EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv1}, /*has_more*/ false))); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_domain_range) == std::vector{kv1}); } SECTION("success: more than one page") { // Set the call expectations: [just once let's do the whole procedure by calling Tx first] // 1. remote::KV::StubInterface::PrepareAsyncTxRaw call succeeds expect_request_async_tx(/*ok=*/true); // 2. AsyncReaderWriter::Read calls succeed w/ specified transaction and cursor IDs remote::Pair tx_id_pair{make_fake_tx_created_pair()}; EXPECT_CALL(reader_writer_, Read) .WillOnce(test::read_success_with(grpc_context_, tx_id_pair)); // 3. AsyncReaderWriter::WritesDone call succeeds EXPECT_CALL(reader_writer_, WritesDone).WillOnce(test::writes_done_success(grpc_context_)); // 4. AsyncReaderWriter::Finish call succeeds w/ status OK EXPECT_CALL(reader_writer_, Finish).WillOnce(test::finish_streaming_ok(grpc_context_)); // 5. remote::KV::StubInterface::AsyncRangeAsOfRaw call succeeds EXPECT_CALL(*stub_, AsyncRangeAsOfRaw).WillRepeatedly(Return(&reader)); // 6. AsyncResponseReader<>::Finish call succeeds 3 times EXPECT_CALL(reader, Finish) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv1, kv2}, /*has_more*/ true))) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv2, kv1}, /*has_more*/ true))) .WillOnce(test::finish_with(grpc_context_, make_key_value_range_reply({kv3}, /*has_more*/ false))); // Execute the test preconditions: // open a new transaction w/ expected transaction ID REQUIRE_NOTHROW(spawn_and_wait(remote_tx_.open())); REQUIRE(ensure_fake_tx_created_tx_id(remote_tx_)); REQUIRE(ensure_fake_tx_created_view_id(remote_tx_)); // Execute the test: call index_range and flatten the data matches the expected data CHECK(spawn_and_wait(flatten_domain_range) == std::vector{kv1, kv2, kv2, kv1, kv3}); // Execute the test postconditions: // close the transaction succeeds CHECK_NOTHROW(spawn_and_wait(remote_tx_.close())); } } } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/client/rpc.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include namespace silkworm::db::kv::grpc::client { using TxRpc = boost::asio::use_awaitable_t<>::as_default_on_t>; } // namespace silkworm::db::kv::grpc::client ================================================ FILE: silkworm/db/kv/grpc/server/kv_calls.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "kv_calls.hpp" #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include #include namespace silkworm::db::kv::grpc::server { using boost::asio::as_tuple; using namespace boost::asio::experimental::awaitable_operators; using boost::asio::steady_timer; using boost::asio::use_awaitable; api::Version higher_version_ignoring_patch(api::Version lhs, api::Version rhs) { uint32_t lhs_major = std::get<0>(lhs); uint32_t lhs_minor = std::get<1>(lhs); uint32_t rhs_major = std::get<0>(rhs); uint32_t rhs_minor = std::get<1>(rhs); if (rhs_major > lhs_major) { return rhs; } if (lhs_major > rhs_major) { return lhs; } if (rhs_minor > lhs_minor) { return rhs; } if (lhs_minor > rhs_minor) { return lhs; } return lhs; } types::VersionReply KvVersionCall::response_; void KvVersionCall::fill_predefined_reply() { const auto max_version = higher_version_ignoring_patch(kDbSchemaVersion, api::kCurrentVersion); KvVersionCall::response_.set_major(std::get<0>(max_version)); KvVersionCall::response_.set_minor(std::get<1>(max_version)); KvVersionCall::response_.set_patch(std::get<2>(max_version)); } Task KvVersionCall::operator()() { SILK_TRACE << "KvVersionCall START"; co_await agrpc::finish(responder_, response_, ::grpc::Status::OK); SILK_TRACE << "KvVersionCall END version: " << response_.major() << "." << response_.minor() << "." << response_.patch(); } std::chrono::milliseconds TxCall::max_ttl_duration_{kMaxTxDuration}; void TxCall::set_max_ttl_duration(const std::chrono::milliseconds& max_ttl_duration) { TxCall::max_ttl_duration_ = max_ttl_duration; } Task TxCall::operator()(ROAccess chaindata) { SILK_TRACE << "TxCall peer: " << peer() << " MDBX readers: " << (*chaindata).get_info().mi_numreaders; ::grpc::Status status{::grpc::Status::OK}; try { // Assign a monotonically increasing unique ID to remote transaction const auto tx_id = ++next_tx_id_; // Create a new read-only transaction. read_only_txn_ = chaindata.start_ro_tx(); SILK_DEBUG << "TxCall peer: " << peer() << " started tx: " << tx_id << " view: " << read_only_txn_->id(); // Send an unsolicited message containing the transaction ID and view ID (i.e. MDBX txn ID) remote::Pair tx_id_pair; tx_id_pair.set_tx_id(tx_id); tx_id_pair.set_view_id(read_only_txn_->id()); if (!co_await agrpc::write(responder_, tx_id_pair)) { SILK_WARN << "Tx closed by peer: " << server_context_.peer() << " error: write failed"; co_await agrpc::finish(responder_, ::grpc::Status::OK); co_return; } SILK_DEBUG << "TxCall announcement with txid=" << read_only_txn_->id() << " sent"; // Create guard timers to 1) close idle transactions 2) close and reopen long-lived transactions. boost::asio::steady_timer max_idle_alarm{grpc_context_}, max_ttl_alarm{grpc_context_}; std::chrono::steady_clock::time_point max_idle_deadline{std::chrono::steady_clock::now() + max_idle_duration_}; std::chrono::steady_clock::time_point max_ttl_deadline{std::chrono::steady_clock::now() + max_ttl_duration_}; max_idle_alarm.expires_at(max_idle_deadline); max_ttl_alarm.expires_at(max_ttl_deadline); // Setup read and write streams agrpc::GrpcStream read_stream{grpc_context_}, write_stream{grpc_context_}; remote::Cursor request; read_stream.initiate(agrpc::read, responder_, request); const auto read = [&]() -> Task { try { while (co_await read_stream.next()) { // Handle incoming request from client remote::Pair response{}; handle(&request, response); // Schedule write for response write_stream.initiate(agrpc::write, responder_, std::move(response)); // Reset request and schedule subsequent read request.Clear(); read_stream.initiate(agrpc::read, responder_, request); // Update idle timer deadline every time we receive an incoming request max_idle_deadline += max_idle_duration_; } } catch (const mdbx::exception& e) { const auto error_message = "start tx failed: " + std::string{e.what()}; SILK_ERROR << "Tx peer: " << peer() << " " << error_message; status = ::grpc::Status{::grpc::StatusCode::RESOURCE_EXHAUSTED, error_message}; } catch (const rpc::server::CallException& ce) { status = ce.status(); } catch (const boost::system::system_error& se) { if (se.code() != boost::asio::error::operation_aborted) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, se.what()}; } } catch (const std::exception& exc) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, exc.what()}; } }; const auto write = [&]() -> Task { while (co_await write_stream.next()) { } }; const auto max_idle_timer = [&]() -> Task { while (true) { const auto [ec] = co_await max_idle_alarm.async_wait(as_tuple(use_awaitable)); if (!ec) { const auto error_msg{"no incoming request in " + std::to_string(max_idle_duration_.count()) + " ms"}; SILK_WARN << "Tx idle peer: " << server_context_.peer() << " error: " << error_msg; status = ::grpc::Status{::grpc::StatusCode::DEADLINE_EXCEEDED, error_msg}; break; } } }; const auto max_ttl_timer = [&]() -> Task { while (true) { const auto [ec] = co_await max_ttl_alarm.async_wait(as_tuple(use_awaitable)); if (!ec) { handle_max_ttl_timer_expired(chaindata); max_ttl_deadline += max_ttl_duration_; } } }; co_await (read() || write() || max_idle_timer() || max_ttl_timer()); SILK_DEBUG << "TxCall peer: " << peer() << " read/write loop completed"; } catch (const mdbx::exception& e) { const auto error_message = "start tx failed: " + std::string{e.what()}; SILK_ERROR << "Tx peer: " << peer() << " " << error_message; status = ::grpc::Status{::grpc::StatusCode::RESOURCE_EXHAUSTED, error_message}; } catch (const rpc::server::CallException& ce) { status = ce.status(); } catch (const std::exception& exc) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, exc.what()}; } co_await agrpc::finish(responder_, status); SILK_TRACE << "TxCall END peer: " << peer() << " status: " << status; } void TxCall::handle(const remote::Cursor* request, remote::Pair& response) { SILK_TRACE << "TxCall::handle " << this << " request: " << request << " START"; // Handle separately main use cases: cursor OPEN, cursor CLOSE and any other cursor operation. const auto cursor_op = request->op(); if (cursor_op == remote::Op::OPEN || cursor_op == remote::Op::OPEN_DUP_SORT) { handle_cursor_open(request, response); } else if (cursor_op == remote::Op::CLOSE) { handle_cursor_close(request); } else { handle_cursor_operation(request, response); } SILK_TRACE << "TxCall::handle " << this << " request: " << request << " END"; } void TxCall::handle_cursor_open(const remote::Cursor* request, remote::Pair& response) { const std::string& bucket_name = request->bucket_name(); // Bucket name must be a valid MDBX map name if (!has_map(read_only_txn_, bucket_name)) { const auto err = "unknown bucket: " + request->bucket_name(); SILK_ERROR << "Tx peer: " << peer() << " op=" << remote::Op_Name(request->op()) << " " << err; throw_with_error(::grpc::Status{::grpc::StatusCode::INVALID_ARGUMENT, err}); } // The number of opened cursors shall not exceed the maximum threshold. if (cursors_.size() == kMaxTxCursors) { const auto err = "maximum cursors per txn reached: " + std::to_string(cursors_.size()); SILK_ERROR << "Tx peer: " << peer() << " op=" << remote::Op_Name(request->op()) << " " << err; throw_with_error(::grpc::Status{::grpc::StatusCode::RESOURCE_EXHAUSTED, err}); } // Create a new database cursor tracking also bucket name (needed for reopening). We create a read-only dup-sort // cursor so that it works for both single-value and multi-value tables. const MapConfig map_config{ .name = bucket_name, .value_mode = request->op() == remote::Op::OPEN ? ::mdbx::value_mode::single : ::mdbx::value_mode::multi, }; auto cursor = read_only_txn_.ro_cursor_dup_sort(map_config); const auto [cursor_it, inserted] = cursors_.insert({++last_cursor_id_, TxCursor{std::move(cursor), bucket_name}}); SILKWORM_ASSERT(cursor_it->first == last_cursor_id_); // The assigned cursor ID shall not be already in use (after cursor ID wrapping). if (!inserted) { const auto error_message = "assigned cursor ID already in use: " + std::to_string(last_cursor_id_); SILK_ERROR << "Tx peer: " << peer() << " op=" << remote::Op_Name(request->op()) << " " << error_message; throw_with_error(::grpc::Status{::grpc::StatusCode::ALREADY_EXISTS, error_message}); } // Send the assigned cursor ID back to the client. response.set_cursor_id(cursor_it->first); SILK_DEBUG << "Tx peer: " << peer() << " opened cursor: " << response.cursor_id(); } void TxCall::handle_cursor_operation(const remote::Cursor* request, remote::Pair& response) { const auto cursor_it = cursors_.find(request->cursor()); if (cursor_it == cursors_.end()) { const auto error_message = "unknown cursor: " + std::to_string(request->cursor()); SILK_ERROR << "Tx peer: " << peer() << " op=" << remote::Op_Name(request->op()) << " " << error_message; throw_with_error(::grpc::Status{::grpc::StatusCode::INVALID_ARGUMENT, error_message}); } auto& cursor = cursor_it->second.cursor; try { handle_operation(request, *cursor, response); } catch (const std::exception& exc) { throw_with_internal_error(request, exc); } SILK_TRACE << "TxCall::handle_cursor_operation " << this << " cursor: " << request->cursor(); } void TxCall::handle_cursor_close(const remote::Cursor* request) { const auto cursor_it = cursors_.find(request->cursor()); if (cursor_it == cursors_.end()) { const auto error_message = "unknown cursor: " + std::to_string(request->cursor()); SILK_ERROR << "Tx peer: " << peer() << " op: " << remote::Op_Name(request->op()) << " " << error_message; throw_with_error(::grpc::Status{::grpc::StatusCode::INVALID_ARGUMENT, error_message}); } cursors_.erase(cursor_it); SILK_DEBUG << "Tx peer: " << peer() << " closed cursor: " << request->cursor(); } void TxCall::handle_operation(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response) { SILK_DEBUG << "Tx peer=" << peer() << " op=" << remote::Op_Name(request->op()) << " cursor=" << request->cursor(); switch (request->op()) { case remote::Op::FIRST: { handle_first(cursor, response); } break; case remote::Op::FIRST_DUP: { handle_first_dup(cursor, response); } break; case remote::Op::SEEK: { handle_seek(request, cursor, response); } break; case remote::Op::SEEK_BOTH: { handle_seek_both(request, cursor, response); } break; case remote::Op::SEEK_EXACT: { handle_seek_exact(request, cursor, response); } break; case remote::Op::SEEK_BOTH_EXACT: { handle_seek_both_exact(request, cursor, response); } break; case remote::Op::CURRENT: { handle_current(cursor, response); } break; case remote::Op::LAST: { handle_last(cursor, response); } break; case remote::Op::LAST_DUP: { handle_last_dup(cursor, response); } break; case remote::Op::NEXT: { handle_next(cursor, response); } break; case remote::Op::NEXT_DUP: { handle_next_dup(cursor, response); } break; case remote::Op::NEXT_NO_DUP: { handle_next_no_dup(cursor, response); } break; case remote::Op::PREV: { handle_prev(cursor, response); } break; case remote::Op::PREV_DUP: { handle_prev_dup(cursor, response); } break; case remote::Op::PREV_NO_DUP: { handle_prev_no_dup(cursor, response); } break; default: { std::string error_message{"unhandled operation "}; error_message.append(remote::Op_Name(request->op())); error_message.append(" on cursor: "); error_message.append(std::to_string(request->cursor())); throw_with_internal_error(error_message); } break; } SILK_TRACE << "TxCall::handle_operation " << this << " op=" << remote::Op_Name(request->op()) << " END"; } void TxCall::handle_max_ttl_timer_expired(ROAccess chaindata) { // Save the whole state of the transaction (i.e. all cursor positions) std::vector positions; const bool save_success = save_cursors(positions); if (!save_success) { throw_with_internal_error("cannot save state of cursors"); } SILK_DEBUG << "Tx peer: " << peer() << " #cursors: " << cursors_.size() << " saved"; // Close and reopen to avoid long-lived transactions (resource-consuming for MDBX) read_only_txn_.abort(); read_only_txn_ = chaindata.start_ro_tx(); // Restore the whole state of the transaction (i.e. all cursor positions) const bool restore_success = restore_cursors(positions); if (!restore_success) { throw_with_internal_error("cannot restore state of cursors"); } SILK_DEBUG << "Tx peer: " << peer() << " #cursors: " << cursors_.size() << " restored"; } bool TxCall::save_cursors(std::vector& positions) { for (const auto& [cursor_id, tx_cursor] : cursors_) { if (tx_cursor.cursor->is_dangling()) { // Cursor is open but never used so no position to store, just be sure to reopen it positions.emplace_back(); } else { const auto result = tx_cursor.cursor->current(/*throw_notfound=*/false); SILK_DEBUG << "Tx save cursor: " << cursor_id << " result: " << detail::dump_mdbx_result(result); if (!result) { return false; } mdbx::slice key = result.key; mdbx::slice value = result.value; positions.emplace_back(CursorPosition{key.as_string(), value.as_string()}); } } return true; } bool TxCall::restore_cursors(std::vector& positions) { SILKWORM_ASSERT(positions.size() == cursors_.size()); auto position_iterator = positions.begin(); for (auto& [cursor_id, tx_cursor] : cursors_) { const std::string& bucket_name = tx_cursor.bucket_name; const MapConfig map_config{.name = bucket_name}; // Bind each cursor to the renewed transaction. auto& cursor = tx_cursor.cursor; cursor->bind(read_only_txn_, map_config); const auto& [current_key, current_value] = *position_iterator; ++position_iterator; SILKWORM_ASSERT(current_key.has_value() == current_value.has_value()); if (!current_key && !current_value) { continue; } SILK_DEBUG << "Tx restore cursor " << cursor_id << " current_key: " << *current_key << " current_value: " << *current_value; mdbx::slice key{current_key->c_str()}; // Restore each cursor saved position. if (cursor->is_multi_value()) { /* multi-value table */ mdbx::slice value{current_value->c_str()}; const auto lbm_result = cursor->lower_bound_multivalue(key, value, /*throw_notfound=*/false); SILK_DEBUG << "Tx restore cursor " << cursor_id << " for: " << bucket_name << " lbm_result: " << detail::dump_mdbx_result(lbm_result); // It may happen that key where we stopped disappeared after transaction reopen, then just move to next key if (!lbm_result) { const auto next_result = cursor->to_next(/*throw_notfound=*/false); SILK_DEBUG << "Tx restore cursor " << cursor_id << " for: " << bucket_name << " next_result: " << detail::dump_mdbx_result(next_result); if (!next_result) { return false; } } } else { /* single-value table */ const auto result = (key.empty()) ? cursor->to_first(/*throw_notfound=*/false) : cursor->lower_bound(key, /*throw_notfound=*/false); SILK_DEBUG << "Tx restore cursor " << cursor_id << " for: " << bucket_name << " result: " << detail::dump_mdbx_result(result); if (!result) { return false; } } } return true; } void TxCall::handle_first(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_first " << this << " START"; const auto result = cursor.to_first(/*throw_notfound=*/false); SILK_DEBUG << "Tx FIRST result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_first " << this << " END"; } void TxCall::handle_first_dup(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_first_dup " << this << " START"; const auto result = cursor.to_current_first_multi(/*throw_notfound=*/false); SILK_DEBUG << "Tx FIRST_DUP result: " << detail::dump_mdbx_result(result); // Do not use `operator bool(result)` to avoid MDBX Assertion `!done || (bool(key) && bool(value))' failed if (result.done && result.value) { response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_first_dup " << this << " END"; } void TxCall::handle_seek(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_seek " << this << " START"; mdbx::slice key{request->k()}; const auto result = (key.empty()) ? cursor.to_first(/*throw_notfound=*/false) : cursor.lower_bound(key, /*throw_notfound=*/false); SILK_DEBUG << "Tx SEEK result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_seek " << this << " END"; } void TxCall::handle_seek_both(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_seek_both " << this << " START"; mdbx::slice key{request->k()}; mdbx::slice value{request->v()}; const auto result = cursor.lower_bound_multivalue(key, value, /*throw_notfound=*/false); SILK_DEBUG << "Tx SEEK_BOTH result: " << detail::dump_mdbx_result(result); if (result) { response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_seek_both " << this << " END"; } void TxCall::handle_seek_exact(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_seek_exact " << this << " START"; mdbx::slice key{request->k()}; const bool found = cursor.seek(key); SILK_DEBUG << "Tx SEEK_EXACT found: " << std::boolalpha << found; if (found) { const auto result = cursor.current(/*throw_notfound=*/false); SILK_DEBUG << "Tx SEEK_EXACT result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(request->k()); response.set_v(result.value.as_string()); } } SILK_TRACE << "TxCall::handle_seek_exact " << this << " END"; } void TxCall::handle_seek_both_exact(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_seek_both_exact " << this << " START"; mdbx::slice key{request->k()}; mdbx::slice value{request->v()}; const auto result = cursor.find_multivalue(key, value, /*throw_notfound=*/false); SILK_DEBUG << "Tx SEEK_BOTH_EXACT result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(request->k()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_seek_both_exact " << this << " END"; } void TxCall::handle_current(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_current " << this << " START"; const auto result = cursor.current(/*throw_notfound=*/false); SILK_DEBUG << "Tx CURRENT result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_current " << this << " END"; } void TxCall::handle_last(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_last " << this << " START"; const auto result = cursor.to_last(/*throw_notfound=*/false); SILK_DEBUG << "Tx LAST result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_last " << this << " END"; } void TxCall::handle_last_dup(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_last_dup " << this << " START"; const auto result = cursor.to_current_last_multi(/*throw_notfound=*/false); SILK_DEBUG << "Tx LAST_DUP result: " << detail::dump_mdbx_result(result); // Do not use `operator bool(result)` to avoid MDBX Assertion `!done || (bool(key) && bool(value))' failed if (result.done && result.value) { response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_last_dup " << this << " END"; } void TxCall::handle_next(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_next " << this << " START"; const auto result = cursor.to_next(/*throw_notfound=*/false); SILK_DEBUG << "Tx NEXT result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_next " << this << " END"; } void TxCall::handle_next_dup(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_next_dup " << this << " START"; const auto result = cursor.to_current_next_multi(/*throw_notfound=*/false); SILK_DEBUG << "Tx NEXT_DUP result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_next_dup " << this << " END"; } void TxCall::handle_next_no_dup(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_next_no_dup " << this << " START"; const auto result = cursor.to_next_first_multi(/*throw_notfound=*/false); SILK_DEBUG << "Tx NEXT_NO_DUP result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_next_no_dup " << this << " END"; } void TxCall::handle_prev(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_prev " << this << " START"; const auto result = cursor.to_previous(/*throw_notfound=*/false); SILK_DEBUG << "Tx PREV result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_prev " << this << " END"; } void TxCall::handle_prev_dup(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_prev_dup " << this << " START"; const auto result = cursor.to_current_prev_multi(/*throw_notfound=*/false); SILK_DEBUG << "Tx PREV_DUP result: " << detail::dump_mdbx_result(result); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_prev_dup " << this << " END"; } void TxCall::handle_prev_no_dup(ROCursorDupSort& cursor, remote::Pair& response) { SILK_TRACE << "TxCall::handle_prev_no_dup " << this << " START"; const auto result = cursor.to_previous_last_multi(/*throw_notfound=*/false); if (result) { response.set_k(result.key.as_string()); response.set_v(result.value.as_string()); } SILK_TRACE << "TxCall::handle_prev_no_dup " << this << " END"; } void TxCall::throw_with_internal_error(const remote::Cursor* request, const std::exception& exc) { std::string error_message{"exception: "}; error_message.append(exc.what()); error_message.append(" in "); error_message.append(remote::Op_Name(request->op())); error_message.append(" on cursor: "); error_message.append(std::to_string(request->cursor())); throw_with_error(::grpc::Status{::grpc::StatusCode::INTERNAL, error_message}); } void TxCall::throw_with_internal_error(const std::string& message) { throw_with_error(::grpc::Status{::grpc::StatusCode::INTERNAL, message}); } void TxCall::throw_with_error(::grpc::Status status) { SILK_ERROR << "Tx peer: " << peer() << " " << status.error_message(); throw rpc::server::CallException{std::move(status)}; } Task StateChangesCall::operator()(StateChangeCollection* source) { SILK_TRACE << "StateChangesCall w/ storage: " << request_.with_storage() << " w/ txs: " << request_.with_transactions() << " START"; // Create a never-expiring timer whose cancellation will notify our async waiting is completed auto coroutine_executor = co_await boost::asio::this_coro::executor; auto notifying_timer = steady_timer{coroutine_executor}; std::optional incoming_batch; // Register subscription to receive state change batch notifications StateChangeConsumer state_change_consumer = [&](std::optional batch) { // Make the batch handling logic execute on the scheduler associated to the RPC boost::asio::dispatch(coroutine_executor, [&, batch = std::move(batch)]() { incoming_batch = batch; notifying_timer.cancel(); }); }; StateChangeFilter filter{request_.with_storage(), request_.with_transactions()}; const auto token = source->subscribe(state_change_consumer, filter); // The assigned token ID must be valid. if (!token) { const auto error_message = "assigned consumer token already in use: " + std::to_string(source->last_token()); SILK_ERROR << "StateChanges peer: " << peer() << " subscription failed " << error_message; co_await agrpc::finish(responder_, ::grpc::Status{::grpc::StatusCode::ALREADY_EXISTS, error_message}); co_return; } // Unregister subscription whatever it happens [[maybe_unused]] auto _ = gsl::finally([&]() { source->unsubscribe(*token); }); bool done{false}; while (!done) { // Schedule the notifying timer to expire in the infinite future i.e. never notifying_timer.expires_at(std::chrono::steady_clock::time_point::max()); const auto [ec] = co_await notifying_timer.async_wait(as_tuple(use_awaitable)); if (ec == boost::asio::error::operation_aborted) { // Notifying timer cancelled => incoming batch available if (incoming_batch) { const auto block_num = incoming_batch->change_batch(0).block_height(); SILK_DEBUG << "Sending state change batch for block: " << block_num; const bool write_ok = co_await agrpc::write(responder_, *incoming_batch); SILK_DEBUG << "State change batch for block: " << block_num << " sent [write_ok=" << write_ok << "]"; if (!write_ok) done = true; } else { SILK_DEBUG << "Empty incoming batch notified"; done = true; } } else { throw std::logic_error{"unexpected notifying timer expiration"}; } } SILK_DEBUG << "Closing state change stream server-side"; co_await agrpc::finish(responder_, ::grpc::Status::OK); SILK_DEBUG << "State change stream closed server-side"; SILK_TRACE << "StateChangesCall END"; co_return; } Task SnapshotsCall::operator()() { SILK_TRACE << "SnapshotsCall START"; remote::SnapshotsReply response; // TODO(canepat) implement properly co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "SnapshotsCall END #blocks_files: " << response.blocks_files_size() << " #history_files: " << response.history_files_size(); } Task HistorySeekCall::operator()() { SILK_TRACE << "HistorySeekCall START"; remote::HistorySeekReply response; // TODO(canepat) implement properly co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "HistorySeekCall END ok: " << response.ok() << " value: " << response.v(); } Task GetLatestCall::operator()() { SILK_TRACE << "GetLatestCall START"; remote::GetLatestReply response; // TODO(canepat) implement properly co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "GetLatestCall END ok: " << response.ok() << " value: " << response.v(); } Task IndexRangeCall::operator()() { SILK_TRACE << "IndexRangeCall START"; remote::IndexRangeReply response; // TODO(canepat) implement properly co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "IndexRangeCall END #timestamps: " << response.timestamps_size() << " next_page_token: " << response.next_page_token(); } Task HistoryRangeCall::operator()() { SILK_TRACE << "HistoryRangeCall START"; remote::Pairs response; // TODO(canepat) implement properly co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "HistoryRangeCall END #keys: " << response.keys_size() << " #values: " << response.values_size() << " next_page_token: " << response.next_page_token(); } Task RangeAsOfCall::operator()() { SILK_TRACE << "RangeAsOfCall START"; remote::Pairs response; // TODO(canepat) implement properly co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "RangeAsOfCall END #keys: " << response.keys_size() << " #values: " << response.values_size() << " next_page_token: " << response.next_page_token(); } } // namespace silkworm::db::kv::grpc::server ================================================ FILE: silkworm/db/kv/grpc/server/kv_calls.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../../api/direct_service.hpp" #include "state_change_collection.hpp" // KV API protocol versions // 5.1.0 - first issue namespace silkworm::db::kv::grpc::server { using namespace silkworm::datastore::kvdb; api::Version higher_version_ignoring_patch(api::Version lhs, api::Version rhs); //! Current DB schema version. inline constexpr api::Version kDbSchemaVersion{3, 0, 0}; //! The max life duration for MDBX transactions (long-lived transactions are discouraged). inline constexpr std::chrono::milliseconds kMaxTxDuration{60'000}; //! The max number of opened cursors for each remote transaction (arbitrary limit on this KV implementation). inline constexpr size_t kMaxTxCursors = 100; //! Unary RPC for Version method of 'ethbackend' gRPC protocol. //! rpc Version(google.protobuf.Empty) returns (types.VersionReply); class KvVersionCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; static void fill_predefined_reply(); Task operator()(); private: static types::VersionReply response_; }; //! Bidirectional-streaming RPC for Tx method of 'kv' gRPC protocol. //! rpc Tx(stream Cursor) returns (stream Pair); class TxCall : public rpc::server::BidiStreamingCall { public: using Base::BidiStreamingCall; static void set_max_ttl_duration(const std::chrono::milliseconds& max_ttl_duration); Task operator()(ROAccess chaindata); private: struct TxCursor { std::unique_ptr cursor; std::string bucket_name; }; struct CursorPosition { std::optional current_key; std::optional current_value; }; void handle(const remote::Cursor* request, remote::Pair& response); void handle_cursor_open(const remote::Cursor* request, remote::Pair& response); void handle_cursor_operation(const remote::Cursor* request, remote::Pair& response); void handle_cursor_close(const remote::Cursor* request); void handle_operation(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response); void handle_max_ttl_timer_expired(ROAccess chaindata); bool save_cursors(std::vector& positions); bool restore_cursors(std::vector& positions); void handle_first(ROCursorDupSort& cursor, remote::Pair& response); void handle_first_dup(ROCursorDupSort& cursor, remote::Pair& response); void handle_seek(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response); void handle_seek_both(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response); void handle_seek_exact(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response); void handle_seek_both_exact(const remote::Cursor* request, ROCursorDupSort& cursor, remote::Pair& response); void handle_current(ROCursorDupSort& cursor, remote::Pair& response); void handle_last(ROCursorDupSort& cursor, remote::Pair& response); void handle_last_dup(ROCursorDupSort& cursor, remote::Pair& response); void handle_next(ROCursorDupSort& cursor, remote::Pair& response); void handle_next_dup(ROCursorDupSort& cursor, remote::Pair& response); void handle_next_no_dup(ROCursorDupSort& cursor, remote::Pair& response); void handle_prev(ROCursorDupSort& cursor, remote::Pair& response); void handle_prev_dup(ROCursorDupSort& cursor, remote::Pair& response); void handle_prev_no_dup(ROCursorDupSort& cursor, remote::Pair& response); void throw_with_internal_error(const remote::Cursor* request, const std::exception& exc); void throw_with_internal_error(const std::string& message); void throw_with_error(::grpc::Status status); static std::chrono::milliseconds max_ttl_duration_; static inline uint64_t next_tx_id_{0}; ROTxnManaged read_only_txn_; std::map cursors_; uint32_t last_cursor_id_{0}; }; //! Server-streaming RPC for StateChanges method of 'kv' gRPC protocol. //! rpc StateChanges(StateChangeRequest) returns (stream StateChangeBatch); class StateChangesCall : public rpc::server::ServerStreamingCall { public: using Base::ServerStreamingCall; Task operator()(StateChangeCollection* source); }; //! Unary RPC for Snapshots method of 'kv' gRPC protocol. //! rpc Snapshots(SnapshotsRequest) returns (SnapshotsReply); class SnapshotsCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(); }; //! Unary RPC for HistoryGet method of 'kv' gRPC protocol. //! rpc HistoryGet(HistoryGetReq) returns (HistoryGetReply); class HistorySeekCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(); }; //! Unary RPC for GetLatest method of 'kv' gRPC protocol. //! rpc GetLatest(GetLatestReq) returns (GetLatestReply); class GetLatestCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(); }; //! Unary RPC for IndexRange method of 'kv' gRPC protocol. //! rpc IndexRange(IndexRangeReq) returns (IndexRangeReply); class IndexRangeCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(); }; //! Unary RPC for HistoryRange method of 'kv' gRPC protocol. //! rpc HistoryRange(HistoryRangeReq) returns (Pairs); class HistoryRangeCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(); }; //! Unary RPC for RangeAsOf method of 'kv' gRPC protocol. //! rpc RangeAsOf(RangeAsOfReq) returns (Pairs); class RangeAsOfCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(); }; } // namespace silkworm::db::kv::grpc::server ================================================ FILE: silkworm/db/kv/grpc/server/kv_calls_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "kv_calls.hpp" #include #include #include namespace silkworm::db::kv::grpc::server { TEST_CASE("higher_version_ignoring_patch", "[silkworm][rpc][kv_calls]") { SECTION("lhs.major > rhs.major") { api::Version lhs{2, 0, 0}; api::Version rhs{1, 0, 0}; CHECK(higher_version_ignoring_patch(lhs, rhs) == lhs); } SECTION("rhs.major > lhs.major") { api::Version lhs{2, 0, 0}; api::Version rhs{3, 0, 0}; CHECK(higher_version_ignoring_patch(lhs, rhs) == rhs); } SECTION("lhs.minor > rhs.minor") { api::Version lhs{2, 5, 0}; api::Version rhs{2, 2, 0}; CHECK(higher_version_ignoring_patch(lhs, rhs) == lhs); } SECTION("rhs.minor > lhs.minor") { api::Version lhs{2, 5, 0}; api::Version rhs{2, 6, 0}; CHECK(higher_version_ignoring_patch(lhs, rhs) == rhs); } SECTION("patch not relevant") { api::Version lhs1{2, 5, 0}; api::Version rhs1{2, 5, 0}; CHECK(higher_version_ignoring_patch(lhs1, rhs1) == lhs1); api::Version lhs2{2, 5, 1}; api::Version rhs2{2, 5, 0}; CHECK(higher_version_ignoring_patch(lhs2, rhs2) == lhs2); api::Version lhs3{2, 5, 0}; api::Version rhs3{2, 5, 1}; CHECK(higher_version_ignoring_patch(lhs3, rhs3) == lhs3); } } static const datastore::kvdb::MapConfig kTestMap{"TestTable"}; TEST_CASE("dump_mdbx_result", "[silkworm][rpc][kv_calls]") { using namespace silkworm::datastore::kvdb; TemporaryDirectory tmp_dir; DataDirectory data_dir{tmp_dir.path()}; REQUIRE_NOTHROW(data_dir.deploy()); EnvConfig db_config; db_config.path = data_dir.chaindata().path().string(); db_config.create = true; db_config.in_memory = true; auto database_env = open_env(db_config); auto rw_txn{database_env.start_write()}; open_map(rw_txn, kTestMap); PooledCursor rw_cursor{rw_txn, kTestMap}; rw_cursor.upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor.upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); rw_txn.commit(); auto ro_txn = database_env.start_read(); PooledCursor cursor{ro_txn, kTestMap}; CursorResult result = cursor.to_first(/*throw_notfound=*/false); const auto result_dump = datastore::kvdb::detail::dump_mdbx_result(result); CHECK(result_dump.find(std::to_string(result.done)) != std::string::npos); CHECK(result_dump.find(std::to_string(static_cast(result.key))) != std::string::npos); CHECK(result_dump.find(std::to_string(static_cast(result.value))) != std::string::npos); ro_txn.abort(); } } // namespace silkworm::db::kv::grpc::server ================================================ FILE: silkworm/db/kv/grpc/server/kv_server.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "kv_server.hpp" #include #include #include "kv_calls.hpp" namespace silkworm::db::kv::grpc::server { using rpc::request_repeatedly; KvServer::KvServer( const rpc::ServerSettings& settings, ROAccess chaindata, StateChangeCollection* state_change_source) : Server(settings), chaindata_{std::move(chaindata)}, state_change_source_{state_change_source} { setup_kv_calls(); SILK_INFO << "KvServer created listening on: " << settings.address_uri; } // Register the gRPC services: they must exist for the lifetime of the server built by builder. void KvServer::register_async_services(::grpc::ServerBuilder& builder) { builder.RegisterService(&kv_async_service_); } void KvServer::setup_kv_calls() { KvVersionCall::fill_predefined_reply(); } void KvServer::register_kv_request_calls(agrpc::GrpcContext* grpc_context) { SILK_TRACE << "KvServer::register_kv_request_calls START"; auto service = &kv_async_service_; // Register one requested call repeatedly for each RPC: asio-grpc will take care of re-registration on any incoming call request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestVersion, [](auto&&... args) -> Task { co_await KvVersionCall{std::forward(args)...}(); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestTx, [this, grpc_context](auto&&... args) -> Task { co_await TxCall{*grpc_context, std::forward(args)...}(chaindata_); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestStateChanges, [this](auto&&... args) -> Task { co_await StateChangesCall{std::forward(args)...}(state_change_source_); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestSnapshots, [](auto&&... args) -> Task { co_await SnapshotsCall{std::forward(args)...}(); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestGetLatest, [](auto&&... args) -> Task { co_await GetLatestCall{std::forward(args)...}(); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestHistorySeek, [](auto&&... args) -> Task { co_await HistorySeekCall{std::forward(args)...}(); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestIndexRange, [](auto&&... args) -> Task { co_await IndexRangeCall{std::forward(args)...}(); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestHistoryRange, [](auto&&... args) -> Task { co_await HistoryRangeCall{std::forward(args)...}(); }); request_repeatedly(*grpc_context, service, &remote::KV::AsyncService::RequestRangeAsOf, [](auto&&... args) -> Task { co_await RangeAsOfCall{std::forward(args)...}(); }); SILK_TRACE << "KvServer::register_kv_request_calls END"; } //! Start server-side RPC requests as required by gRPC async model: one RPC per type is requested in advance. void KvServer::register_request_calls() { // Start all server-side RPC requests for each available server context for (size_t i = 0; i < num_contexts(); ++i) { const auto& context = next_context(); auto grpc_context = context.server_grpc_context(); // Register initial requested calls for ETHBACKEND and KV services register_kv_request_calls(grpc_context); } } } // namespace silkworm::db::kv::grpc::server ================================================ FILE: silkworm/db/kv/grpc/server/kv_server.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "state_change_collection.hpp" namespace silkworm::db::kv::grpc::server { class KvServer : public virtual rpc::Server { public: KvServer( const rpc::ServerSettings& settings, datastore::kvdb::ROAccess chaindata, StateChangeCollection* state_change_source); KvServer(const KvServer&) = delete; KvServer& operator=(const KvServer&) = delete; protected: void register_async_services(::grpc::ServerBuilder& builder) override; void register_request_calls() override; private: static void setup_kv_calls(); void register_kv_request_calls(agrpc::GrpcContext* grpc_context); //! \warning The gRPC service must exist for the lifetime of the gRPC server it is registered on. remote::KV::AsyncService kv_async_service_; //! The chain database environment datastore::kvdb::ROAccess chaindata_; //! The collector of state changes acting as source of state change notifications StateChangeCollection* state_change_source_; }; } // namespace silkworm::db::kv::grpc::server ================================================ FILE: silkworm/db/kv/grpc/server/kv_server_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "kv_server.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "kv_calls.hpp" #include "state_change_collection.hpp" using namespace std::chrono_literals; namespace { // Trick suggested by gRPC team to avoid name clashes in multiple test modules using TxStreamPtr = std::unique_ptr>; class KvClient { public: explicit KvClient(remote::KV::StubInterface* stub) : stub_(stub) {} grpc::Status version(types::VersionReply* response) { grpc::ClientContext context; return stub_->Version(&context, google::protobuf::Empty{}, response); } grpc::Status tx(std::vector& requests, std::vector& responses) { grpc::ClientContext context; auto tx_reader_writer = stub_->Tx(&context); tx_reader_writer->Read(&responses.emplace_back()); uint32_t cursor_id{0}; for (auto& req : requests) { if (req.cursor() == 0) { req.set_cursor(cursor_id); } const bool write_ok = tx_reader_writer->Write(req); if (!write_ok) { break; } const bool read_ok = tx_reader_writer->Read(&responses.emplace_back()); if (!read_ok) { responses.pop_back(); break; } if (cursor_id == 0) { cursor_id = responses.back().cursor_id(); } if (req.op() == remote::Op::CLOSE) { cursor_id = 0; } } tx_reader_writer->WritesDone(); return tx_reader_writer->Finish(); } auto tx_start(grpc::ClientContext* context) { return stub_->Tx(context); } auto statechanges_start(grpc::ClientContext* context, const remote::StateChangeRequest& request) { return stub_->StateChanges(context, request); } grpc::Status snapshots(const remote::SnapshotsRequest& request, remote::SnapshotsReply* response) { grpc::ClientContext context; return stub_->Snapshots(&context, request, response); } grpc::Status history_seek(const remote::HistorySeekReq& request, remote::HistorySeekReply* response) { grpc::ClientContext context; return stub_->HistorySeek(&context, request, response); } grpc::Status get_latest(const remote::GetLatestReq& request, remote::GetLatestReply* response) { grpc::ClientContext context; return stub_->GetLatest(&context, request, response); } grpc::Status index_range(const remote::IndexRangeReq& request, remote::IndexRangeReply* response) { grpc::ClientContext context; return stub_->IndexRange(&context, request, response); } grpc::Status history_range(const remote::HistoryRangeReq& request, remote::Pairs* response) { grpc::ClientContext context; return stub_->HistoryRange(&context, request, response); } grpc::Status range_as_of(const remote::RangeAsOfReq& request, remote::Pairs* response) { grpc::ClientContext context; return stub_->RangeAsOf(&context, request, response); } private: remote::KV::StubInterface* stub_; }; class ThreadedKvClient { public: //! It is safe to call this method *only after* join_and_finish() has been called std::vector responses() const { return responses_; } void start_and_consume_statechanges(KvClient client) { // Start StateChanges server-streaming call on calling thread remote::StateChangeRequest request; statechangebatch_reader_ = client.statechanges_start(&context_, request); // We need a dedicated thread to consume the incoming messages because only one (blocking) // Read completion will tell us that server-side subscription really happened. This machinery // is needed just in these all-in-one tests consumer_thread_ = std::thread{[&]() { bool has_more{true}; do { has_more = statechangebatch_reader_->Read(&responses_.emplace_back()); // As soon as the first Read has completed, we know for sure that subscription has occurred std::unique_lock subscribed_lock{subscribed_mutex_}; if (!subscribed_) { subscribed_ = true; subscribed_lock.unlock(); subscribed_condition_.notify_one(); } } while (has_more); // Last response read is void so discard it responses_.pop_back(); }}; } bool wait_one_milli_for_subscription() { std::unique_lock subscribed_lock{subscribed_mutex_}; return subscribed_condition_.wait_for(subscribed_lock, 1ms, [&] { return subscribed_; }); } grpc::Status join_and_finish() { consumer_thread_.join(); return statechangebatch_reader_->Finish(); } private: grpc::ClientContext context_; std::unique_ptr> statechangebatch_reader_; std::thread consumer_thread_; std::mutex subscribed_mutex_; std::condition_variable subscribed_condition_; bool subscribed_{false}; std::vector responses_; }; // TODO(canepat): better copy grpc_pick_unused_port_or_die to generate unused port constexpr std::string_view kTestAddressUri{"localhost:12345"}; static const silkworm::datastore::kvdb::MapConfig kTestMap{"TestTable"}; static const silkworm::datastore::kvdb::MapConfig kTestMultiMap{"TestMultiTable", mdbx::key_mode::usual, mdbx::value_mode::multi}; using namespace silkworm; using StateChangeTokenObserver = std::function)>; class TestableStateChangeCollection : public StateChangeCollection { public: std::optional subscribe(StateChangeConsumer consumer, StateChangeFilter filter) override { const auto token = StateChangeCollection::subscribe(consumer, filter); if (token_observer_) { token_observer_(token); } return token; } void set_token(StateChangeToken next_token) { next_token_ = next_token; } void register_token_observer(StateChangeTokenObserver token_observer) { token_observer_ = std::move(token_observer); } private: StateChangeTokenObserver token_observer_; }; using KvServer = db::kv::grpc::server::KvServer; struct KvEnd2EndTest { explicit KvEnd2EndTest() { log::init(); std::shared_ptr channel = grpc::CreateChannel(std::string{kTestAddressUri}, grpc::InsecureChannelCredentials()); kv_stub = remote::KV::NewStub(channel); kv_client = std::make_unique(kv_stub.get()); srv_config.context_pool_settings.num_contexts = 1; srv_config.address_uri = kTestAddressUri; DataDirectory data_dir{tmp_dir.path()}; REQUIRE_NOTHROW(data_dir.deploy()); db_config = std::make_unique(); db_config->path = data_dir.chaindata().path().string(); db_config->create = true; db_config->in_memory = true; database_env = datastore::kvdb::open_env(*db_config); auto rw_txn{database_env.start_write()}; datastore::kvdb::open_map(rw_txn, kTestMap); datastore::kvdb::open_map(rw_txn, kTestMultiMap); rw_txn.commit(); state_change_collection = std::make_unique(); server = std::make_unique(srv_config, datastore::kvdb::ROAccess{database_env}, state_change_collection.get()); server->build_and_start(); } void fill_tables() { auto rw_txn = database_env.start_write(); datastore::kvdb::PooledCursor rw_cursor1{rw_txn, kTestMap}; rw_cursor1.upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor1.upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); datastore::kvdb::PooledCursor rw_cursor2{rw_txn, kTestMultiMap}; rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"11"}); rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"22"}); rw_cursor2.upsert(mdbx::slice{"BB"}, mdbx::slice{"22"}); rw_txn.commit(); } void alter_tables() { auto rw_txn = database_env.start_write(); datastore::kvdb::PooledCursor rw_cursor1{rw_txn, kTestMap}; rw_cursor1.upsert(mdbx::slice{"CC"}, mdbx::slice{"22"}); datastore::kvdb::PooledCursor rw_cursor2{rw_txn, kTestMultiMap}; rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"33"}); rw_cursor2.upsert(mdbx::slice{"BB"}, mdbx::slice{"33"}); rw_txn.commit(); } ~KvEnd2EndTest() { server->shutdown(); server->join(); } std::unique_ptr kv_stub; std::unique_ptr kv_client; rpc::ServerSettings srv_config; TemporaryDirectory tmp_dir; std::unique_ptr db_config; mdbx::env_managed database_env; std::unique_ptr state_change_collection; std::unique_ptr server; }; } // namespace namespace silkworm::db::kv::grpc::server { // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("KvServer", "[silkworm][node][rpc]") { log::init(); rpc::ServerSettings srv_config; srv_config.address_uri = kTestAddressUri; TemporaryDirectory tmp_dir; DataDirectory data_dir{tmp_dir.path()}; REQUIRE_NOTHROW(data_dir.deploy()); datastore::kvdb::EnvConfig db_config{data_dir.chaindata().path().string()}; db_config.create = true; db_config.in_memory = true; auto chaindata_env = datastore::kvdb::open_env(db_config); ROAccess chaindata{chaindata_env}; auto state_change_source{std::make_unique()}; SECTION("KvServer::KvServer OK: create/destroy server") { KvServer server{srv_config, chaindata, state_change_source.get()}; } SECTION("KvServer::KvServer OK: create/shutdown/destroy server") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.shutdown(); } SECTION("KvServer::build_and_start OK: run server in separate thread") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; server.shutdown(); server_thread.join(); } SECTION("KvServer::build_and_start OK: create/shutdown/run/destroy server") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.shutdown(); server.build_and_start(); } SECTION("KvServer::shutdown OK: shutdown server not running") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.shutdown(); } SECTION("KvServer::shutdown OK: shutdown twice server not running") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.shutdown(); server.shutdown(); } SECTION("KvServer::shutdown OK: shutdown running server") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.build_and_start(); server.shutdown(); server.join(); } SECTION("KvServer::shutdown OK: shutdown twice running server") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.build_and_start(); server.shutdown(); server.shutdown(); server.join(); } SECTION("KvServer::shutdown OK: shutdown running server again after join") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.build_and_start(); server.shutdown(); server.join(); server.shutdown(); } SECTION("KvServer::join OK: shutdown joined server") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; server.shutdown(); server_thread.join(); } SECTION("KvServer::join OK: shutdown joined server and join again") { KvServer server{srv_config, chaindata, state_change_source.get()}; server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; server.shutdown(); server_thread.join(); server.join(); // cannot move before server_thread.join() due to data race in boost::asio::detail::posix_thread } } TEST_CASE_METHOD(KvEnd2EndTest, "KvServer E2E: KV", "[silkworm][node][rpc]") { SECTION("Version: return KV version") { types::VersionReply response; const auto status = kv_client->version(&response); CHECK(status.ok()); CHECK(response.major() == 5); CHECK(response.minor() == 1); CHECK(response.patch() == 0); } SECTION("Tx KO: empty table name") { remote::Cursor open; open.set_op(remote::Op::OPEN); std::vector requests{open}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INVALID_ARGUMENT); CHECK(absl::StrContains(status.error_message(), "unknown bucket")); CHECK(responses.size() == 1); CHECK(responses[0].tx_id() != 0); } SECTION("Tx KO: invalid table name") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name("NonexistentTable"); std::vector requests{open}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INVALID_ARGUMENT); CHECK(absl::StrContains(status.error_message(), "unknown bucket")); CHECK(responses.size() == 1); CHECK(responses[0].tx_id() != 0); } SECTION("Tx KO: missing operation") { remote::Cursor open; open.set_bucket_name(kTestMap.name_str()); std::vector requests{open}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INVALID_ARGUMENT); CHECK(absl::StrContains(status.error_message(), "unknown cursor")); CHECK(responses.size() == 1); CHECK(responses[0].tx_id() != 0); } SECTION("Tx OK: just start then finish") { std::vector requests{}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 1); CHECK(responses[0].tx_id() != 0); } SECTION("Tx OK: cursor opened") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); std::vector requests{open}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); } SECTION("Tx OK: cursor dup_sort opened") { remote::Cursor open_dup_sort; open_dup_sort.set_op(remote::Op::OPEN_DUP_SORT); open_dup_sort.set_bucket_name(kTestMultiMap.name_str()); std::vector requests{open_dup_sort}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); } SECTION("Tx OK: cursor opened then closed") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); std::vector requests{open, close}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 3); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].cursor_id() == 0); } SECTION("Tx OK: cursor dup_sort opened then closed") { remote::Cursor open; open.set_op(remote::Op::OPEN_DUP_SORT); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); std::vector requests{open, close}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 3); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].cursor_id() == 0); } SECTION("Tx KO: cursor opened then unknown") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(12345); std::vector requests{open, close}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INVALID_ARGUMENT); CHECK(absl::StrContains(status.error_message(), "unknown cursor")); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); } SECTION("Tx OK: one FIRST operation on empty table gives empty result") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); std::vector requests{open, first}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 3); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[1].k().empty()); CHECK(responses[1].v().empty()); } SECTION("Tx KO: one NEXT operation on empty table gives empty result") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor next; next.set_op(remote::Op::NEXT); next.set_cursor(0); std::vector requests{open, next}; std::vector responses; const auto status = kv_client->tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 3); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[1].k().empty()); CHECK(responses[1].v().empty()); } SECTION("StateChanges OK: receive streamed state changes") { static constexpr uint64_t kTestPendingBaseFee{10'000}; static constexpr uint64_t kTestGasLimit{10'000'000}; auto* state_change_source = state_change_collection.get(); ThreadedKvClient threaded_kv_client; // Start StateChanges server-streaming call and consume incoming messages on dedicated thread threaded_kv_client.start_and_consume_statechanges(*kv_client); // Keep publishing state changes using the Catch2 thread until at least one has been received BlockNum block_num{0}; bool publishing{true}; while (publishing) { state_change_source->start_new_batch(++block_num, kEmptyHash, std::vector{}, /*unwind=*/false); state_change_source->notify_batch(kTestPendingBaseFee, kTestGasLimit); publishing = !threaded_kv_client.wait_one_milli_for_subscription(); } // After at least one state change has been received, close the server-side RPC stream state_change_source->close(); // then wait for consumer thread termination and get the client-side RPC result const auto status = threaded_kv_client.join_and_finish(); CHECK(status.ok()); CHECK(!threaded_kv_client.responses().empty()); } SECTION("StateChanges OK: multiple concurrent subscriptions") { static constexpr uint64_t kTestPendingBaseFee{10'000}; static constexpr uint64_t kTestGasLimit{10'000'000}; auto* state_change_source = state_change_collection.get(); ThreadedKvClient threaded_kv_client1, threaded_kv_client2; // Start StateChanges server-streaming call and consume incoming messages on dedicated thread threaded_kv_client1.start_and_consume_statechanges(*kv_client); threaded_kv_client2.start_and_consume_statechanges(*kv_client); // Keep publishing state changes using the Catch2 thread until at least one has been received BlockNum block_num{0}; bool publishing{true}; while (publishing) { state_change_source->start_new_batch(++block_num, kEmptyHash, {}, /*unwind=*/false); state_change_source->notify_batch(kTestPendingBaseFee, kTestGasLimit); publishing = !(threaded_kv_client1.wait_one_milli_for_subscription() && threaded_kv_client2.wait_one_milli_for_subscription()); } // After at least one state change has been received, close the server-side RPC stream state_change_source->close(); // then wait for consumer thread termination and get the client-side RPC result const auto status1 = threaded_kv_client1.join_and_finish(); const auto status2 = threaded_kv_client2.join_and_finish(); CHECK(status1.ok()); CHECK(status2.ok()); CHECK(!threaded_kv_client1.responses().empty()); CHECK(!threaded_kv_client2.responses().empty()); } SECTION("StateChanges KO: token already in use") { auto* state_change_source = state_change_collection.get(); std::mutex token_reset_mutex; std::condition_variable token_reset_condition; bool token_reset{false}; state_change_source->register_token_observer([&](std::optional token) { if (token) { // Purposely reset the subscription token state_change_source->set_token(0); std::unique_lock token_reset_lock{token_reset_mutex}; token_reset = true; token_reset_lock.unlock(); token_reset_condition.notify_one(); } }); // Start a StateChanges server-streaming call ::grpc::ClientContext context1; remote::StateChangeRequest request1; auto subscribe_reply_reader1 = kv_client->statechanges_start(&context1, request1); // Wait for token reset condition to happen std::unique_lock token_reset_lock{token_reset_mutex}; token_reset_condition.wait(token_reset_lock, [&] { return token_reset; }); // Start another StateChanges server-streaming call and check it fails ::grpc::ClientContext context2; remote::StateChangeRequest request2; auto subscribe_reply_reader2 = kv_client->statechanges_start(&context2, request2); const auto status2 = subscribe_reply_reader2->Finish(); CHECK(!status2.ok()); CHECK(status2.error_code() == ::grpc::StatusCode::ALREADY_EXISTS); CHECK(absl::StrContains(status2.error_message(), "assigned consumer token already in use")); // Close the server-side RPC stream and check first call completes successfully state_change_source->close(); const auto status1 = subscribe_reply_reader1->Finish(); CHECK(status1.ok()); } SECTION("Snapshots: return snapshot files") { remote::SnapshotsRequest request; remote::SnapshotsReply response; const auto status = kv_client->snapshots(request, &response); CHECK(status.ok()); } SECTION("HistorySeek: return value in target history") { remote::HistorySeekReq request; remote::HistorySeekReply response; const auto status = kv_client->history_seek(request, &response); CHECK(status.ok()); } SECTION("GetLatest: return value in target domain") { remote::GetLatestReq request; remote::GetLatestReply response; const auto status = kv_client->get_latest(request, &response); CHECK(status.ok()); } SECTION("IndexRange: return value in target index range") { remote::IndexRangeReq request; remote::IndexRangeReply response; const auto status = kv_client->index_range(request, &response); CHECK(status.ok()); } SECTION("HistoryRange: return value in target history range") { remote::HistoryRangeReq request; remote::Pairs response; const auto status = kv_client->history_range(request, &response); CHECK(status.ok()); } SECTION("RangeAsOf: return value in target domain range") { remote::RangeAsOfReq request; remote::Pairs response; const auto status = kv_client->range_as_of(request, &response); CHECK(status.ok()); } } #ifndef _WIN32 TEST_CASE("KvServer E2E: trigger server-side write error", "[silkworm][node][rpc]") { { const uint32_t num_txs{1000}; KvEnd2EndTest test; test.fill_tables(); auto kv_client = *test.kv_client; // Start many Tx calls w/o reading responses after writing requests. for (uint32_t i{0}; i < num_txs; ++i) { ::grpc::ClientContext context; auto tx_stream = kv_client.tx_start(&context); remote::Pair response; CHECK(tx_stream->Read(&response)); CHECK(response.tx_id() != 0); remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); CHECK(tx_stream->Write(open)); } } // Server-side life cycle of Tx calls must be OK. } #endif // _WIN32 TEST_CASE("KvServer E2E: Tx max simultaneous readers exceeded", "[silkworm][node][rpc]") { // This check can be improved in Catch2 version 3.3.0 where SKIP is available if (os::max_file_descriptors() < 1024) { bool ok = os::set_max_file_descriptors(1024); if (!ok) { FAIL("insufficient number of process file descriptors, increase to 1024 has failed"); } } KvEnd2EndTest test; test.fill_tables(); auto kv_client = *test.kv_client; // Start and keep open as many Tx calls as the maximum number of readers. std::vector> client_contexts; std::vector tx_streams; for (uint32_t i{0}; i < test.database_env.max_readers(); ++i) { auto& context = client_contexts.emplace_back(std::make_unique<::grpc::ClientContext>()); auto tx_stream = kv_client.tx_start(context.get()); // You must read at least the first unsolicited incoming message (TxID announcement). remote::Pair response; REQUIRE(tx_stream->Read(&response)); REQUIRE(response.tx_id() != 0); tx_streams.push_back(std::move(tx_stream)); } // Now trying to start another Tx call will exceed the maximum number of readers. ::grpc::ClientContext context; const auto failing_tx_stream = kv_client.tx_start(&context); remote::Pair response; REQUIRE(!failing_tx_stream->Read(&response)); // Tx RPC immediately fails for exhaustion, no TxID announcement auto failing_tx_status = failing_tx_stream->Finish(); CHECK(!failing_tx_status.ok()); CHECK(failing_tx_status.error_code() == ::grpc::StatusCode::RESOURCE_EXHAUSTED); CHECK(absl::StrContains(failing_tx_status.error_message(), "start tx failed")); // Dispose all the opened Tx calls. for (const auto& tx_stream : tx_streams) { REQUIRE(tx_stream->WritesDone()); auto status = tx_stream->Finish(); REQUIRE(status.ok()); } } TEST_CASE("KvServer E2E: Tx max opened cursors exceeded", "[silkworm][node][rpc]") { KvEnd2EndTest test; test.fill_tables(); auto kv_client = *test.kv_client; ::grpc::ClientContext context; const auto tx_stream = kv_client.tx_start(&context); // You must read at least the first unsolicited incoming message (TxID announcement). remote::Pair response; REQUIRE(tx_stream->Read(&response)); REQUIRE(response.tx_id() != 0); response.clear_tx_id(); // Open as many cursors as possible expecting successful result. for (uint32_t i{0}; i < kMaxTxCursors; ++i) { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); REQUIRE(tx_stream->Write(open)); response.clear_cursor_id(); REQUIRE(tx_stream->Read(&response)); REQUIRE(response.cursor_id() != 0); } // Try to open one more and get failure from server-side on the stream. remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); REQUIRE(tx_stream->Write(open)); response.clear_cursor_id(); REQUIRE(!tx_stream->Read(&response)); REQUIRE(response.cursor_id() == 0); // Half-close the stream and complete the call checking expected failure. REQUIRE(tx_stream->WritesDone()); auto status = tx_stream->Finish(); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::RESOURCE_EXHAUSTED); CHECK(absl::StrContains(status.error_message(), "maximum cursors per txn")); } class TxIdleTimeoutGuard { public: explicit TxIdleTimeoutGuard(uint8_t t) { TxCall::set_max_idle_duration(std::chrono::milliseconds{t}); } ~TxIdleTimeoutGuard() { TxCall::set_max_idle_duration(rpc::server::kDefaultMaxIdleDuration); } }; TEST_CASE("KvServer E2E: bidirectional idle timeout", "[silkworm][node][rpc]") { TxIdleTimeoutGuard timeout_guard{100}; KvEnd2EndTest test; test.fill_tables(); auto kv_client = *test.kv_client; // This commented test *blocks* starting from gRPC 1.44.0-p0 (works using gRPC 1.38.0-p0) // The reason could be that according to gRPC API spec this is kind of API misuse: it is // *appropriate* to call Finish only after all incoming messages have been read (not the // case here, missing tx ID announcement read) *and* no outgoing messages need to be sent. /*SECTION("Tx KO: immediate finish", "[.]") { ::grpc::ClientContext context; const auto tx_reader_writer = kv_client.tx_start(&context); auto status = tx_reader_writer->Finish(); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::DEADLINE_EXCEEDED); CHECK(absl::StrContains(status.error_message(), "call idle, no incoming request")); }*/ SECTION("Tx KO: finish after first read (w/o WritesDone)") { ::grpc::ClientContext context; const auto tx_reader_writer = kv_client.tx_start(&context); remote::Pair response; CHECK(tx_reader_writer->Read(&response)); CHECK(response.tx_id() != 0); auto status = tx_reader_writer->Finish(); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::DEADLINE_EXCEEDED); CHECK(absl::StrContains(status.error_message(), "no incoming request")); } SECTION("Tx KO: finish after first read and one write/read (w/o WritesDone)") { ::grpc::ClientContext context; const auto tx_reader_writer = kv_client.tx_start(&context); remote::Pair response; CHECK(tx_reader_writer->Read(&response)); CHECK(response.tx_id() != 0); remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); CHECK(tx_reader_writer->Write(open)); response.clear_tx_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.cursor_id() != 0); auto status = tx_reader_writer->Finish(); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::DEADLINE_EXCEEDED); CHECK(absl::StrContains(status.error_message(), "no incoming request")); } } TEST_CASE("KvServer E2E: Tx cursor valid operations", "[silkworm][node][rpc]") { KvEnd2EndTest test; test.fill_tables(); auto kv_client = *test.kv_client; SECTION("Tx OK: one FIRST operation") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: two FIRST operations") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor first1; first1.set_op(remote::Op::FIRST); first1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor first2; first2.set_op(remote::Op::FIRST); first2.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first1, first2, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].k() == "AA"); CHECK(responses[3].v() == "00"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: one LAST operation") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor last; last.set_op(remote::Op::LAST); last.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, last, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: two LAST operations") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor last1; last1.set_op(remote::Op::LAST); last1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor last2; last2.set_op(remote::Op::LAST); last2.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, last1, last2, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].k() == "BB"); CHECK(responses[3].v() == "11"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: one NEXT operation") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor next; next.set_op(remote::Op::NEXT); next.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, next, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: two NEXT operations") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor next1; next1.set_op(remote::Op::NEXT); next1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor next2; next2.set_op(remote::Op::NEXT); next2.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, next1, next2, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].k() == "BB"); CHECK(responses[3].v() == "11"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: two NEXT operations using different cursors") { remote::Cursor open1; open1.set_op(remote::Op::OPEN); open1.set_bucket_name(kTestMap.name_str()); remote::Cursor next1; next1.set_op(remote::Op::NEXT); next1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close1; close1.set_op(remote::Op::CLOSE); close1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor open2; open2.set_op(remote::Op::OPEN); open2.set_bucket_name(kTestMap.name_str()); remote::Cursor next2; next2.set_op(remote::Op::NEXT); next2.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close2; close2.set_op(remote::Op::CLOSE); close2.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open1, next1, close1, open2, next2, close2}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 7); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); CHECK(responses[4].cursor_id() != 0); CHECK(responses[5].k() == "AA"); CHECK(responses[5].v() == "00"); CHECK(responses[6].cursor_id() == 0); } SECTION("Tx OK: one PREV operation") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor prev; prev.set_op(remote::Op::PREV); prev.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, prev, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: two PREV operations") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor prev1; prev1.set_op(remote::Op::PREV); prev1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor prev2; prev2.set_op(remote::Op::PREV); prev2.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, prev1, prev2, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].k() == "AA"); CHECK(responses[3].v() == "00"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: two PREV operations using different cursors") { remote::Cursor open1; open1.set_op(remote::Op::OPEN); open1.set_bucket_name(kTestMap.name_str()); remote::Cursor prev1; prev1.set_op(remote::Op::PREV); prev1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close1; close1.set_op(remote::Op::CLOSE); close1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor open2; open2.set_op(remote::Op::OPEN); open2.set_bucket_name(kTestMap.name_str()); remote::Cursor prev2; prev2.set_op(remote::Op::PREV); prev2.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close2; close2.set_op(remote::Op::CLOSE); close2.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open1, prev1, close1, open2, prev2, close2}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(status.error_message().empty()); CHECK(responses.size() == 7); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].cursor_id() == 0); CHECK(responses[4].cursor_id() != 0); CHECK(responses[5].k() == "BB"); CHECK(responses[5].v() == "11"); CHECK(responses[6].cursor_id() == 0); } SECTION("Tx OK: FIRST + CURRENT operations on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor current; current.set_op(remote::Op::CURRENT); current.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first, current, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].k() == "AA"); CHECK(responses[3].v() == "00"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: LAST + CURRENT operations on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor last; last.set_op(remote::Op::LAST); last.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor current; current.set_op(remote::Op::CURRENT); current.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, last, current, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "22"); CHECK(responses[3].k() == "BB"); CHECK(responses[3].v() == "22"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: FIRST + FIRST_DUP operations on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor first_dup; first_dup.set_op(remote::Op::FIRST_DUP); first_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first, first_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].k().empty()); CHECK(responses[3].v() == "00"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: LAST + FIRST_DUP operations on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor last; last.set_op(remote::Op::LAST); last.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor first_dup; first_dup.set_op(remote::Op::FIRST_DUP); first_dup.set_cursor(0); // automatically assigned by KvClient::tx first_dup.set_k("AA"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, last, first_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "22"); CHECK(responses[3].k().empty()); CHECK(responses[3].v() == "22"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: one FIRST + two NEXT_DUP operations on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor next_dup1; next_dup1.set_op(remote::Op::NEXT_DUP); next_dup1.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor next_dup2; next_dup2.set_op(remote::Op::NEXT_DUP); next_dup2.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first, next_dup1, next_dup2, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 6); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].k() == "AA"); CHECK(responses[3].v() == "11"); CHECK(responses[4].k() == "AA"); CHECK(responses[4].v() == "22"); CHECK(responses[5].cursor_id() == 0); } SECTION("Tx OK: NEXT_DUP operation on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor next_dup; next_dup.set_op(remote::Op::NEXT_DUP); next_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, next_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one PREV_DUP operation on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor prev_dup; prev_dup.set_op(remote::Op::PREV_DUP); prev_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, prev_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one NEXT_DUP operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor next_dup; next_dup.set_op(remote::Op::NEXT_DUP); next_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, next_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one PREV_DUP operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor prev_dup; prev_dup.set_op(remote::Op::PREV_DUP); prev_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, prev_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "22"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one FIRST + one LAST_DUP operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor last_dup; last_dup.set_op(remote::Op::LAST_DUP); last_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first, last_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].k().empty()); CHECK(responses[3].v() == "22"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: one LAST + one LAST_DUP operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor last; last.set_op(remote::Op::LAST); last.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor last_dup; last_dup.set_op(remote::Op::LAST_DUP); last_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, last, last_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 5); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "22"); CHECK(responses[3].k().empty()); CHECK(responses[3].v() == "22"); CHECK(responses[4].cursor_id() == 0); } SECTION("Tx OK: one NEXT_NO_DUP operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor next_no_dup; next_no_dup.set_op(remote::Op::NEXT_NO_DUP); next_no_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, next_no_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one PREV_NO_DUP operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor prev_no_dup; prev_no_dup.set_op(remote::Op::PREV_NO_DUP); prev_no_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, prev_no_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "22"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: SEEK operation w/o key on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek; seek.set_op(remote::Op::SEEK); seek.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: SEEK operation w/ existent key on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek; seek.set_op(remote::Op::SEEK); seek.set_cursor(0); // automatically assigned by KvClient::tx seek.set_k("BB"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: SEEK operation w/ unexisting key on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek; seek.set_op(remote::Op::SEEK); seek.set_cursor(0); // automatically assigned by KvClient::tx seek.set_k("ZZ"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: SEEK_EXACT operation w/o key on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek_exact; seek_exact.set_op(remote::Op::SEEK_EXACT); seek_exact.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: SEEK_EXACT operation w/ existent key on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek_exact; seek_exact.set_op(remote::Op::SEEK_EXACT); seek_exact.set_cursor(0); // automatically assigned by KvClient::tx seek_exact.set_k("BB"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "BB"); CHECK(responses[2].v() == "11"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: SEEK_EXACT operation w/ nonexistent key on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek_exact; seek_exact.set_op(remote::Op::SEEK_EXACT); seek_exact.set_cursor(0); // automatically assigned by KvClient::tx seek_exact.set_k("ZZ"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH w/o key operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both; seek_both.set_op(remote::Op::SEEK_BOTH); seek_both.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH w/ nonexistent key operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both; seek_both.set_op(remote::Op::SEEK_BOTH); seek_both.set_cursor(0); // automatically assigned by KvClient::tx seek_both.set_k("CC"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH w/ existent key operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both; seek_both.set_op(remote::Op::SEEK_BOTH); seek_both.set_cursor(0); // automatically assigned by KvClient::tx seek_both.set_k("AA"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v() == "00"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH w/ existent key+value operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both; seek_both.set_op(remote::Op::SEEK_BOTH); seek_both.set_cursor(0); // automatically assigned by KvClient::tx seek_both.set_k("AA"); seek_both.set_v("22"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v() == "22"); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH_EXACT w/o key operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both_exact; seek_both_exact.set_op(remote::Op::SEEK_BOTH_EXACT); seek_both_exact.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH_EXACT w/ nonexistent key operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both_exact; seek_both_exact.set_op(remote::Op::SEEK_BOTH_EXACT); seek_both_exact.set_cursor(0); // automatically assigned by KvClient::tx seek_both_exact.set_k("CC"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH_EXACT w/ existent key operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both_exact; seek_both_exact.set_op(remote::Op::SEEK_BOTH_EXACT); seek_both_exact.set_cursor(0); // automatically assigned by KvClient::tx seek_both_exact.set_k("AA"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k().empty()); CHECK(responses[2].v().empty()); CHECK(responses[3].cursor_id() == 0); } SECTION("Tx OK: one SEEK_BOTH_EXACT w/ existent key+value operation on multi-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor seek_both_exact; seek_both_exact.set_op(remote::Op::SEEK_BOTH_EXACT); seek_both_exact.set_cursor(0); // automatically assigned by KvClient::tx seek_both_exact.set_k("AA"); seek_both_exact.set_v("22"); remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(status.ok()); CHECK(responses.size() == 4); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); CHECK(responses[2].k() == "AA"); CHECK(responses[2].v() == "22"); CHECK(responses[3].cursor_id() == 0); } } TEST_CASE("KvServer E2E: Tx cursor invalid operations", "[silkworm][node][rpc]") { KvEnd2EndTest test; test.fill_tables(); auto kv_client = *test.kv_client; SECTION("Tx KO: CURRENT operation") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor current; current.set_op(remote::Op::CURRENT); current.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, current, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(absl::StrContains(status.error_message(), "exception: MDBX_ENODATA")); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); } SECTION("Tx KO: FIRST_DUP operation on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor first_dup; first_dup.set_op(remote::Op::FIRST_DUP); first_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first, first_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(absl::StrContains(status.error_message(), "exception: MDBX_INCOMPATIBLE")); CHECK(responses.size() == 3); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); } SECTION("Tx KO: LAST_DUP operation on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor last_dup; last_dup.set_op(remote::Op::LAST_DUP); last_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first, last_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(absl::StrContains(status.error_message(), "exception: MDBX_INCOMPATIBLE")); CHECK(responses.size() == 3); CHECK(responses[0].tx_id() != 0); CHECK(responses[1].cursor_id() != 0); } SECTION("Tx KO: FIRST_DUP operation w/o positioned key") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor first_dup; first_dup.set_op(remote::Op::FIRST_DUP); first_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, first_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(absl::StrContains(status.error_message(), "exception: mdbx")); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); } SECTION("Tx KO: LAST_DUP operation w/o positioned key") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); remote::Cursor last_dup; last_dup.set_op(remote::Op::LAST_DUP); last_dup.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, last_dup, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(absl::StrContains(status.error_message(), "exception: mdbx")); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); } SECTION("Tx KO: SEEK_BOTH operation on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek_both; seek_both.set_op(remote::Op::SEEK_BOTH); seek_both.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(absl::StrContains(status.error_message(), "MDBX_INCOMPATIBLE")); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); } SECTION("Tx KO: SEEK_BOTH_EXACT operation on single-value table") { remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); remote::Cursor seek_both_exact; seek_both_exact.set_op(remote::Op::SEEK_BOTH_EXACT); seek_both_exact.set_cursor(0); // automatically assigned by KvClient::tx remote::Cursor close; close.set_op(remote::Op::CLOSE); close.set_cursor(0); // automatically assigned by KvClient::tx std::vector requests{open, seek_both_exact, close}; std::vector responses; const auto status = kv_client.tx(requests, responses); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(absl::StrContains(status.error_message(), "MDBX_INCOMPATIBLE")); CHECK(responses.size() == 2); CHECK(responses[0].tx_id() != 0); } } class TxMaxTimeToLiveGuard { public: explicit TxMaxTimeToLiveGuard(std::chrono::milliseconds t) { TxCall::set_max_ttl_duration(t); } ~TxMaxTimeToLiveGuard() { TxCall::set_max_ttl_duration(kMaxTxDuration); } }; TEST_CASE("KvServer E2E: bidirectional max TTL duration", "[silkworm][node][rpc]") { KvEnd2EndTest test; test.fill_tables(); auto kv_client = *test.kv_client; static constexpr std::chrono::milliseconds kCustomMaxTimeToLive = 1000ms; TxMaxTimeToLiveGuard ttl_guard{kCustomMaxTimeToLive}; SECTION("Tx: cursor NEXT ops across renew are consecutive") { ::grpc::ClientContext context; const auto tx_reader_writer = kv_client.tx_start(&context); remote::Pair response; CHECK(tx_reader_writer->Read(&response)); CHECK(response.tx_id() != 0); remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); CHECK(tx_reader_writer->Write(open)); response.clear_tx_id(); CHECK(tx_reader_writer->Read(&response)); const auto cursor_id = response.cursor_id(); CHECK(cursor_id != 0); remote::Cursor next1; next1.set_op(remote::Op::NEXT); next1.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(next1)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "00"); std::this_thread::sleep_for(kCustomMaxTimeToLive); remote::Cursor next2; next2.set_op(remote::Op::NEXT); next2.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(next2)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "BB"); CHECK(response.v() == "11"); tx_reader_writer->WritesDone(); auto status = tx_reader_writer->Finish(); CHECK(status.ok()); } SECTION("Tx: cursor NEXT_DUP ops across renew are consecutive") { ::grpc::ClientContext context; const auto tx_reader_writer = kv_client.tx_start(&context); remote::Pair response; CHECK(tx_reader_writer->Read(&response)); CHECK(response.tx_id() != 0); remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); CHECK(tx_reader_writer->Write(open)); response.clear_tx_id(); CHECK(tx_reader_writer->Read(&response)); const auto cursor_id = response.cursor_id(); CHECK(cursor_id != 0); remote::Cursor next_dup1; next_dup1.set_op(remote::Op::NEXT_DUP); next_dup1.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(next_dup1)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "00"); std::this_thread::sleep_for(kCustomMaxTimeToLive); remote::Cursor next_dup2; next_dup2.set_op(remote::Op::NEXT_DUP); next_dup2.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(next_dup2)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "11"); tx_reader_writer->WritesDone(); auto status = tx_reader_writer->Finish(); CHECK(status.ok()); } #ifndef _WIN32 SECTION("Tx: cursor NEXT op after renew sees changes") { ::grpc::ClientContext context; // Start Tx RPC and open one cursor for TestMap table const auto tx_reader_writer = kv_client.tx_start(&context); remote::Pair response; CHECK(tx_reader_writer->Read(&response)); CHECK(response.tx_id() != 0); remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMap.name_str()); CHECK(tx_reader_writer->Write(open)); response.clear_tx_id(); CHECK(tx_reader_writer->Read(&response)); const auto cursor_id = response.cursor_id(); CHECK(cursor_id != 0); // Change database content *after* Tx RPC has been opened test.alter_tables(); // Tx RPC opened *before* database changes won't see them remote::Cursor next1; next1.set_op(remote::Op::NEXT); next1.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(next1)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "00"); CHECK(tx_reader_writer->Write(next1)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "BB"); CHECK(response.v() == "11"); CHECK(tx_reader_writer->Write(next1)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k().empty()); CHECK(response.v().empty()); // Let the max TTL timer expire causing server-side tx renewal std::this_thread::sleep_for(kCustomMaxTimeToLive); // Now the already existing cursor (i.e. same cursor_id) can see the changes remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(first)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "00"); remote::Cursor next2; next2.set_op(remote::Op::NEXT); next2.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(next2)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "BB"); CHECK(response.v() == "11"); CHECK(tx_reader_writer->Write(next2)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "CC"); CHECK(response.v() == "22"); tx_reader_writer->WritesDone(); auto status = tx_reader_writer->Finish(); CHECK(status.ok()); } SECTION("Tx: cursor NEXT_DUP op after renew sees changes") { ::grpc::ClientContext context; // Start Tx RPC and open one cursor for TestMultiMap table const auto tx_reader_writer = kv_client.tx_start(&context); remote::Pair response; CHECK(tx_reader_writer->Read(&response)); CHECK(response.tx_id() != 0); remote::Cursor open; open.set_op(remote::Op::OPEN); open.set_bucket_name(kTestMultiMap.name_str()); CHECK(tx_reader_writer->Write(open)); response.clear_tx_id(); CHECK(tx_reader_writer->Read(&response)); const auto cursor_id = response.cursor_id(); CHECK(cursor_id != 0); // Change database content *after* Tx RPC has been opened test.alter_tables(); // Tx RPC opened *before* database changes won't see them remote::Cursor next_dup; next_dup.set_op(remote::Op::NEXT_DUP); next_dup.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(next_dup)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "00"); CHECK(tx_reader_writer->Write(next_dup)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "11"); CHECK(tx_reader_writer->Write(next_dup)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "22"); CHECK(tx_reader_writer->Write(next_dup)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k().empty()); CHECK(response.v().empty()); // Let the max TTL timer expire causing server-side tx renewal std::this_thread::sleep_for(kCustomMaxTimeToLive); // Now the already existing cursor (i.e. same cursor_id) can see the changes remote::Cursor first; first.set_op(remote::Op::FIRST); first.set_cursor(cursor_id); CHECK(tx_reader_writer->Write(first)); response.clear_cursor_id(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "00"); CHECK(tx_reader_writer->Write(next_dup)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "11"); CHECK(tx_reader_writer->Write(next_dup)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "22"); CHECK(tx_reader_writer->Write(next_dup)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k() == "AA"); CHECK(response.v() == "33"); CHECK(tx_reader_writer->Write(next_dup)); response.clear_k(); response.clear_v(); CHECK(tx_reader_writer->Read(&response)); CHECK(response.k().empty()); CHECK(response.v().empty()); tx_reader_writer->WritesDone(); auto status = tx_reader_writer->Finish(); CHECK(status.ok()); } #endif // _WIN32 } #endif // SILKWORM_SANITIZE } // namespace silkworm::db::kv::grpc::server ================================================ FILE: silkworm/db/kv/grpc/server/state_change_collection.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_change_collection.hpp" #include #include #include #include #include #include namespace silkworm { std::optional StateChangeCollection::subscribe(StateChangeConsumer consumer, StateChangeFilter /*filter*/) { std::scoped_lock consumers_lock{consumers_mutex_}; StateChangeToken token = ++next_token_; const auto [_, inserted] = consumers_.insert({token, consumer}); return inserted ? std::make_optional(token) : std::nullopt; } bool StateChangeCollection::unsubscribe(StateChangeToken token) { std::scoped_lock consumers_lock{consumers_mutex_}; const auto consumer_it = consumers_.erase(token); return consumer_it != 0; } void StateChangeCollection::reset(uint64_t tx_id) { tx_id_ = tx_id; state_changes_.clear_change_batch(); latest_change_ = nullptr; account_change_index_.clear(); storage_change_index_.clear(); } void StateChangeCollection::start_new_batch(BlockNum block_num, const evmc::bytes32& block_hash, const std::vector&& tx_rlps, bool unwind) { SILK_TRACE << "StateChangeCollection::start_new_batch " << this << " block: " << block_num << " unwind:" << unwind << " START"; SILKWORM_ASSERT(latest_change_ == nullptr); latest_change_ = state_changes_.add_change_batch(); latest_change_->set_block_height(block_num); latest_change_->set_allocated_block_hash(rpc::h256_from_bytes32(block_hash).release()); latest_change_->set_direction(unwind ? remote::Direction::UNWIND : remote::Direction::FORWARD); for (auto& tx_rlp : tx_rlps) { latest_change_->add_txs(to_hex(tx_rlp)); } SILK_TRACE << "StateChangeCollection::start_new_batch " << this << " END"; } void StateChangeCollection::change_account(const evmc::address& address, uint64_t incarnation, const Bytes& data) { SILKWORM_ASSERT(latest_change_ != nullptr); const auto& ac_it = account_change_index_.find(address); std::optional index{ac_it != account_change_index_.end() ? std::make_optional(ac_it->second) : std::nullopt}; if (!index.has_value() || incarnation > latest_change_->changes(static_cast(index.value())).incarnation()) { index = latest_change_->changes_size(); latest_change_->add_changes()->set_allocated_address( rpc::h160_from_address(address).release()); // takes ownership account_change_index_[address] = index.value(); } remote::AccountChange* account_change = latest_change_->mutable_changes(static_cast(index.value())); switch (account_change->action()) { case remote::Action::STORAGE: account_change->set_action(remote::Action::UPSERT); break; case remote::Action::CODE: account_change->set_action(remote::Action::UPSERT_CODE); break; case remote::Action::REMOVE: SILK_CRIT << "cannot change deleted account: " << address << " incarnation: " << incarnation; SILKWORM_ASSERT(false); break; default: break; } account_change->set_incarnation(incarnation); account_change->set_data(to_hex(data)); } void StateChangeCollection::change_code(const evmc::address& address, uint64_t incarnation, const Bytes& code) { SILKWORM_ASSERT(latest_change_ != nullptr); const auto& ac_it = account_change_index_.find(address); std::optional index{ac_it != account_change_index_.end() ? std::make_optional(ac_it->second) : std::nullopt}; if (!index.has_value() || incarnation > latest_change_->changes(static_cast(index.value())).incarnation()) { index = latest_change_->changes_size(); remote::AccountChange* account_change = latest_change_->add_changes(); account_change->set_allocated_address(rpc::h160_from_address(address).release()); // takes ownership account_change->set_action(remote::Action::CODE); account_change_index_[address] = index.value(); } remote::AccountChange* account_change = latest_change_->mutable_changes(static_cast(index.value())); switch (account_change->action()) { case remote::Action::STORAGE: account_change->set_action(remote::Action::CODE); break; case remote::Action::UPSERT: account_change->set_action(remote::Action::UPSERT_CODE); break; case remote::Action::REMOVE: SILK_CRIT << "cannot change code for deleted account: " << address << " incarnation: " << incarnation; SILKWORM_ASSERT(false); break; default: break; } account_change->set_incarnation(incarnation); account_change->set_code(to_hex(code)); } void StateChangeCollection::change_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const Bytes& data) { SILKWORM_ASSERT(latest_change_ != nullptr); const auto& ac_it = account_change_index_.find(address); std::optional ac_index{ac_it != account_change_index_.end() ? std::make_optional(ac_it->second) : std::nullopt}; if (!ac_index || incarnation > latest_change_->changes(static_cast(ac_index.value())).incarnation()) { ac_index = latest_change_->changes_size(); remote::AccountChange* account_change = latest_change_->add_changes(); account_change->set_allocated_address(rpc::h160_from_address(address).release()); // takes ownership account_change->set_action(remote::Action::STORAGE); account_change_index_[address] = ac_index.value(); } remote::AccountChange* account_change = latest_change_->mutable_changes(static_cast(ac_index.value())); switch (account_change->action()) { case remote::Action::REMOVE: SILK_CRIT << "cannot change storage for deleted account: " << address << " incarnation: " << incarnation; SILKWORM_ASSERT(false); break; default: break; } account_change->set_incarnation(incarnation); auto& index_by_location = storage_change_index_[address]; // insert if not present const auto& loc_it = index_by_location.find(location); auto loc_index{loc_it != index_by_location.end() ? std::make_optional(loc_it->second) : std::nullopt}; if (!loc_index) { loc_index = account_change->storage_changes_size(); account_change->add_storage_changes(); index_by_location[location] = loc_index.value(); } remote::StorageChange* storage_change = account_change->mutable_storage_changes(static_cast(loc_index.value())); storage_change->set_allocated_location(rpc::h256_from_bytes32(location).release()); // takes ownership storage_change->set_data(to_hex(data)); } void StateChangeCollection::delete_account(const evmc::address& address) { SILKWORM_ASSERT(latest_change_ != nullptr); const auto& ac_it = account_change_index_.find(address); auto index{ac_it != account_change_index_.end() ? std::make_optional(ac_it->second) : std::nullopt}; if (!index.has_value()) { index = latest_change_->changes_size(); latest_change_->add_changes()->set_allocated_address( rpc::h160_from_address(address).release()); // takes ownership account_change_index_[address] = index.value(); } remote::AccountChange* account_change = latest_change_->mutable_changes(static_cast(index.value())); SILKWORM_ASSERT(account_change->action() == remote::Action::STORAGE); // TODO(canepat) check Erigon account_change->set_action(remote::Action::REMOVE); account_change->clear_code(); account_change->clear_data(); account_change->clear_storage_changes(); } void StateChangeCollection::notify_batch(uint64_t pending_base_fee, uint64_t gas_limit) { SILK_TRACE << "StateChangeCollection::notify_batch " << this << " pending_base_fee: " << pending_base_fee << " gas_limit:" << gas_limit << " START"; state_changes_.set_pending_block_base_fee(pending_base_fee); state_changes_.set_block_gas_limit(gas_limit); state_changes_.set_state_version_id(tx_id_); std::scoped_lock consumers_lock{consumers_mutex_}; for (const auto& [_, batch_callback] : consumers_) { // Make a copy of state change batch for every consumer because lifecycle is independent const std::optional frozen_batch = state_changes_; SILK_DEBUG << "Notify callback=" << &batch_callback << " batch=" << &frozen_batch; batch_callback(frozen_batch); SILK_DEBUG << "Notify callback=" << &batch_callback << " done"; } reset(0); SILK_TRACE << "StateChangeCollection::notify_batch " << this << " END"; } void StateChangeCollection::close() { std::scoped_lock consumers_lock{consumers_mutex_}; for (const auto& [_, batch_callback] : consumers_) { SILK_DEBUG << "Notify close to callback=" << &batch_callback; batch_callback(std::nullopt); SILK_DEBUG << "Notify close to callback=" << &batch_callback << " done"; } reset(0); } } // namespace silkworm ================================================ FILE: silkworm/db/kv/grpc/server/state_change_collection.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm { using StateChangeConsumer = std::function)>; struct StateChangeFilter { bool with_storage{false}; bool with_transactions{false}; }; using StateChangeToken = uint32_t; class StateChangeSource { public: virtual ~StateChangeSource() = default; virtual StateChangeToken last_token() const noexcept = 0; virtual std::optional subscribe(StateChangeConsumer consumer, StateChangeFilter filter) = 0; virtual bool unsubscribe(StateChangeToken token) = 0; }; class StateChangeCollection : public StateChangeSource { public: explicit StateChangeCollection() = default; uint64_t tx_id() const { return tx_id_; } StateChangeToken last_token() const noexcept override { return next_token_ - 1; } std::optional subscribe(StateChangeConsumer consumer, StateChangeFilter filter) override; bool unsubscribe(StateChangeToken token) override; void reset(uint64_t tx_id); void start_new_batch(BlockNum block_num, const evmc::bytes32& block_hash, const std::vector&& tx_rlps, bool unwind); void change_account(const evmc::address& address, uint64_t incarnation, const Bytes& data); void change_code(const evmc::address& address, uint64_t incarnation, const Bytes& code); void change_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const Bytes& data); void delete_account(const evmc::address& address); void notify_batch(uint64_t pending_base_fee, uint64_t gas_limit); void close(); protected: //! The token number for the next subscription. StateChangeToken next_token_{0}; private: //! The database transaction ID associated with the state changes. uint64_t tx_id_{0}; //! The current batch of state changes. remote::StateChangeBatch state_changes_; //! The latest state change in the batch. remote::StateChange* latest_change_{nullptr}; //! The mapping between accounts and their change indexes. std::map account_change_index_; //! The mapping between account storage locations and their change indexes. std::map> storage_change_index_; //! The registered batch consumers. std::map consumers_; //! The mutual exclusion protecting access to the registered consumers. std::mutex consumers_mutex_; }; } // namespace silkworm ================================================ FILE: silkworm/db/kv/grpc/server/state_change_collection_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_change_collection.hpp" #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using namespace evmc::literals; static constexpr uint64_t kTestPendingBaseFee{10'000}; static constexpr uint64_t kTestGasLimit{10'000'000}; static constexpr uint64_t kTestDatabaseViewId{55}; static constexpr BlockNum kTestBlockNum{1'000'000}; static constexpr evmc::bytes32 kTestBlockHash{0x8e38b4dbf6b11fcc3b9dee84fb7986e29ca0a02cecd8977c161ff7333329681e_bytes32}; static constexpr evmc::address kTestAddress{0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address}; static constexpr uint64_t kTestIncarnation{3}; static const Bytes kTestData1{*from_hex("600035600055")}; static const Bytes kTestData2{*from_hex("6000356000550055")}; static const Bytes kTestCode1{*from_hex("602a6000556101c960015560068060166000396000f3600035600055")}; static const Bytes kTestCode2{*from_hex("602a5f556101c960015560048060135f395ff35f355f55")}; static const evmc::bytes32 kTestHashedLocation1{0x6677907ab33937e392b9be983b30818f29d594039c9e1e7490bf7b3698888fb1_bytes32}; static const evmc::bytes32 kTestHashedLocation2{0xe046602dcccb1a2f1d176718c8e709a42bba57af2da2379ba7130e2f916c95cd_bytes32}; static const Bytes kTestValue1{*from_hex("0xABCD")}; static const Bytes kTestValue2{*from_hex("0x4321")}; static const Bytes kTestValue3{*from_hex("0x4444")}; inline std::vector sample_rlp_buffers() { auto transactions = test::sample_transactions(); std::vector tx_rlps; for (auto& tx : transactions) { Bytes rlp; rlp::encode(rlp, tx); tx_rlps.push_back(rlp); } return tx_rlps; } TEST_CASE("StateChangeCollection::StateChangeCollection", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; CHECK(scc.tx_id() == 0); CHECK(scc.last_token() + 1 == 0); CHECK_NOTHROW(scc.notify_batch(kTestPendingBaseFee, kTestGasLimit)); } TEST_CASE("StateChangeCollection::subscribe", "[silkworm][rpc][state_change_collection]") { SECTION("OK: register do-nothing consumer") { StateChangeCollection scc; CHECK_NOTHROW(scc.subscribe([&](const auto /*batch*/) {}, StateChangeFilter{})); } SECTION("KO: token already in use") { class TestableStateChangeCollection : public StateChangeCollection { public: void set_token(StateChangeToken next_token) { next_token_ = next_token; } }; TestableStateChangeCollection collection; const auto token1 = collection.subscribe([&](const auto /*batch*/) {}, StateChangeFilter{}); CHECK(token1); collection.set_token(0); const auto token2 = collection.subscribe([&](const auto /*batch*/) {}, StateChangeFilter{}); CHECK(!token2); } } TEST_CASE("StateChangeCollection::notify_batch", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; SECTION("OK: notifies batch w/o changes to single consumer") { uint32_t notification_count{0}; scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->state_version_id() == 0); CHECK(batch->change_batch_size() == 0); ++notification_count; }, StateChangeFilter{}); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); CHECK(notification_count == 1); } SECTION("OK: notifies batch w/o changes to multiple consumers") { uint32_t notification_count1{0}, notification_count2{0}; scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->state_version_id() == 0); CHECK(batch->change_batch_size() == 0); ++notification_count1; }, StateChangeFilter{}); scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->state_version_id() == 0); CHECK(batch->change_batch_size() == 0); ++notification_count2; }, StateChangeFilter{}); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); CHECK((notification_count1 == 1 && notification_count2 == 1)); } } TEST_CASE("StateChangeCollection::reset", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; SECTION("OK: notifies batch w/o changes with expected transaction ID") { REQUIRE(scc.tx_id() == 0); scc.subscribe([&](std::optional batch) { CHECK(batch->state_version_id() == scc.tx_id()); }, StateChangeFilter{}); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); scc.reset(kTestDatabaseViewId); CHECK(scc.tx_id() == kTestDatabaseViewId); scc.subscribe([&](std::optional batch) { CHECK(batch->state_version_id() == scc.tx_id()); }, StateChangeFilter{}); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } } TEST_CASE("StateChangeCollection::start_new_batch", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; SECTION("OK: one new batch in FORWARD direction") { scc.start_new_batch(kTestBlockNum, kTestBlockHash, std::vector{}, /*unwind=*/false); scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->state_version_id() == 0); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); }, StateChangeFilter{}); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: two new batches in FORWARD and UNWIND directions") { scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); static int notifications{0}; if (notifications == 0) { CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); } else if (notifications == 1) { CHECK(batch->state_version_id() == kTestDatabaseViewId); CHECK(state_change.direction() == remote::Direction::UNWIND); } else { CHECK(false); // too many notifications } ++notifications; }, StateChangeFilter{}); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); scc.reset(kTestDatabaseViewId); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/true); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } } TEST_CASE("StateChangeCollection::change_account", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; SECTION("OK: change one account once") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 1); const remote::AccountChange& account_change = state_change.changes(0); CHECK(account_change.storage_changes_size() == 0); CHECK(account_change.data() == to_hex(kTestData1)); CHECK(account_change.code().empty()); CHECK(address_from_h160(account_change.address()) == kTestAddress); CHECK(account_change.incarnation() == kTestIncarnation); CHECK(account_change.action() == remote::Action::UPSERT); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_account(kTestAddress, kTestIncarnation, kTestData1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change one account twice") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 2); const remote::AccountChange& account_change0 = state_change.changes(0); CHECK(account_change0.storage_changes_size() == 0); CHECK(account_change0.data() == to_hex(kTestData1)); CHECK(account_change0.code().empty()); CHECK(address_from_h160(account_change0.address()) == kTestAddress); CHECK(account_change0.incarnation() == kTestIncarnation); CHECK(account_change0.action() == remote::Action::UPSERT); const remote::AccountChange& account_change1 = state_change.changes(1); CHECK(account_change1.storage_changes_size() == 0); CHECK(account_change1.data() == to_hex(kTestData2)); CHECK(account_change1.code().empty()); CHECK(address_from_h160(account_change1.address()) == kTestAddress); CHECK(account_change1.incarnation() == kTestIncarnation + 1); CHECK(account_change1.action() == remote::Action::UPSERT); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_account(kTestAddress, kTestIncarnation, kTestData1); scc.change_account(kTestAddress, kTestIncarnation + 1, kTestData2); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change account after changing code") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 1); const remote::AccountChange& account_change = state_change.changes(0); CHECK(account_change.storage_changes_size() == 0); CHECK(account_change.data() == to_hex(kTestData1)); CHECK(account_change.code() == to_hex(kTestCode1)); CHECK(address_from_h160(account_change.address()) == kTestAddress); CHECK(account_change.incarnation() == kTestIncarnation); CHECK(account_change.action() == remote::Action::UPSERT_CODE); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_code(kTestAddress, kTestIncarnation, kTestCode1); scc.change_account(kTestAddress, kTestIncarnation, kTestData1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } } TEST_CASE("StateChangeCollection::change_code", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; SECTION("OK: change code of one account once") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 1); const remote::AccountChange& account_change = state_change.changes(0); CHECK(account_change.storage_changes_size() == 0); CHECK(account_change.data().empty()); CHECK(account_change.code() == to_hex(kTestCode1)); CHECK(address_from_h160(account_change.address()) == kTestAddress); CHECK(account_change.incarnation() == kTestIncarnation); CHECK(account_change.action() == remote::Action::CODE); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_code(kTestAddress, kTestIncarnation, kTestCode1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change code of one account twice") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 2); const remote::AccountChange& account_change0 = state_change.changes(0); CHECK(account_change0.storage_changes_size() == 0); CHECK(account_change0.data().empty()); CHECK(account_change0.code() == to_hex(kTestCode1)); CHECK(address_from_h160(account_change0.address()) == kTestAddress); CHECK(account_change0.incarnation() == kTestIncarnation); CHECK(account_change0.action() == remote::Action::CODE); const remote::AccountChange& account_change1 = state_change.changes(1); CHECK(account_change1.storage_changes_size() == 0); CHECK(account_change1.data().empty()); CHECK(account_change1.code() == to_hex(kTestCode2)); CHECK(address_from_h160(account_change1.address()) == kTestAddress); CHECK(account_change1.incarnation() == kTestIncarnation + 1); CHECK(account_change1.action() == remote::Action::CODE); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_code(kTestAddress, kTestIncarnation, kTestCode1); scc.change_code(kTestAddress, kTestIncarnation + 1, kTestCode2); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change code after changing storage in new incarnation") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 2); const remote::AccountChange& account_change0 = state_change.changes(0); CHECK(account_change0.data().empty()); CHECK(account_change0.code().empty()); CHECK(address_from_h160(account_change0.address()) == kTestAddress); CHECK(account_change0.incarnation() == kTestIncarnation); CHECK(account_change0.action() == remote::Action::STORAGE); CHECK(account_change0.storage_changes_size() == 1); const remote::StorageChange& storage_change00 = account_change0.storage_changes(0); CHECK(bytes32_from_h256(storage_change00.location()) == kTestHashedLocation1); CHECK(*from_hex(storage_change00.data()) == kTestData1); const remote::AccountChange& account_change1 = state_change.changes(1); CHECK(account_change1.data().empty()); CHECK(account_change1.code() == to_hex(kTestCode1)); CHECK(address_from_h160(account_change1.address()) == kTestAddress); CHECK(account_change1.incarnation() == kTestIncarnation + 1); CHECK(account_change1.action() == remote::Action::CODE); CHECK(account_change1.storage_changes_size() == 0); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_storage(kTestAddress, kTestIncarnation, kTestHashedLocation1, kTestData1); scc.change_code(kTestAddress, kTestIncarnation + 1, kTestCode1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change code after changing storage in same incarnation") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 1); const remote::AccountChange& account_change0 = state_change.changes(0); CHECK(account_change0.data().empty()); CHECK(account_change0.code() == to_hex(kTestCode1)); CHECK(address_from_h160(account_change0.address()) == kTestAddress); CHECK(account_change0.incarnation() == kTestIncarnation); CHECK(account_change0.action() == remote::Action::CODE); CHECK(account_change0.storage_changes_size() == 1); const remote::StorageChange& storage_change00 = account_change0.storage_changes(0); CHECK(bytes32_from_h256(storage_change00.location()) == kTestHashedLocation1); CHECK(*from_hex(storage_change00.data()) == kTestData1); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_storage(kTestAddress, kTestIncarnation, kTestHashedLocation1, kTestData1); scc.change_code(kTestAddress, kTestIncarnation, kTestCode1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change code after changing account in new incarnation") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 2); const remote::AccountChange& account_change0 = state_change.changes(0); CHECK(account_change0.storage_changes_size() == 0); CHECK(account_change0.data() == to_hex(kTestData1)); CHECK(account_change0.code().empty()); CHECK(address_from_h160(account_change0.address()) == kTestAddress); CHECK(account_change0.incarnation() == kTestIncarnation); CHECK(account_change0.action() == remote::Action::UPSERT); CHECK(account_change0.storage_changes_size() == 0); const remote::AccountChange& account_change1 = state_change.changes(1); CHECK(account_change1.data().empty()); CHECK(account_change1.code() == to_hex(kTestCode1)); CHECK(address_from_h160(account_change1.address()) == kTestAddress); CHECK(account_change1.incarnation() == kTestIncarnation + 1); CHECK(account_change1.action() == remote::Action::CODE); CHECK(account_change1.storage_changes_size() == 0); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_account(kTestAddress, kTestIncarnation, kTestData1); scc.change_code(kTestAddress, kTestIncarnation + 1, kTestCode1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change code after changing account in same incarnation") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 1); const remote::AccountChange& account_change0 = state_change.changes(0); CHECK(account_change0.storage_changes_size() == 0); CHECK(account_change0.data() == to_hex(kTestData1)); CHECK(account_change0.code() == to_hex(kTestCode1)); CHECK(address_from_h160(account_change0.address()) == kTestAddress); CHECK(account_change0.incarnation() == kTestIncarnation); CHECK(account_change0.action() == remote::Action::UPSERT_CODE); CHECK(account_change0.storage_changes_size() == 0); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_account(kTestAddress, kTestIncarnation, kTestData1); scc.change_code(kTestAddress, kTestIncarnation, kTestCode1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } } TEST_CASE("StateChangeCollection::change_storage", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; SECTION("OK: change storage of one account once") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 1); const remote::AccountChange& account_change = state_change.changes(0); CHECK(account_change.data().empty()); CHECK(account_change.code().empty()); CHECK(address_from_h160(account_change.address()) == kTestAddress); CHECK(account_change.incarnation() == kTestIncarnation); CHECK(account_change.action() == remote::Action::STORAGE); CHECK(account_change.storage_changes_size() == 1); const remote::StorageChange& storage_change = account_change.storage_changes(0); CHECK(bytes32_from_h256(storage_change.location()) == kTestHashedLocation1); CHECK(*from_hex(storage_change.data()) == kTestData1); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_storage(kTestAddress, kTestIncarnation, kTestHashedLocation1, kTestData1); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } SECTION("OK: change storage of one account twice") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.txs_size() == 2); CHECK(batch->state_version_id() == 0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.changes_size() == 2); const remote::AccountChange& account_change0 = state_change.changes(0); CHECK(account_change0.data().empty()); CHECK(account_change0.code().empty()); CHECK(address_from_h160(account_change0.address()) == kTestAddress); CHECK(account_change0.incarnation() == kTestIncarnation); CHECK(account_change0.action() == remote::Action::STORAGE); CHECK(account_change0.storage_changes_size() == 1); const remote::StorageChange& storage_change00 = account_change0.storage_changes(0); CHECK(bytes32_from_h256(storage_change00.location()) == kTestHashedLocation1); CHECK(*from_hex(storage_change00.data()) == kTestData1); const remote::AccountChange& account_change1 = state_change.changes(1); CHECK(account_change1.data().empty()); CHECK(account_change1.code().empty()); CHECK(address_from_h160(account_change1.address()) == kTestAddress); CHECK(account_change1.incarnation() == kTestIncarnation + 1); CHECK(account_change1.action() == remote::Action::STORAGE); CHECK(account_change1.storage_changes_size() == 1); const remote::StorageChange& storage_change10 = account_change1.storage_changes(0); CHECK(bytes32_from_h256(storage_change10.location()) == kTestHashedLocation2); CHECK(*from_hex(storage_change10.data()) == kTestData2); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.change_storage(kTestAddress, kTestIncarnation, kTestHashedLocation1, kTestData1); scc.change_storage(kTestAddress, kTestIncarnation + 1, kTestHashedLocation2, kTestData2); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } } TEST_CASE("StateChangeCollection::delete_account", "[silkworm][rpc][state_change_collection]") { StateChangeCollection scc; SECTION("OK: delete one account once in forward direction") { scc.subscribe([&](std::optional batch) { CHECK(batch->pending_block_base_fee() == kTestPendingBaseFee); CHECK(batch->block_gas_limit() == kTestGasLimit); CHECK(batch->state_version_id() == 0); CHECK(batch->change_batch_size() == 1); const remote::StateChange& state_change = batch->change_batch(0); CHECK(state_change.direction() == remote::Direction::FORWARD); CHECK(state_change.block_height() == kTestBlockNum); CHECK(bytes32_from_h256(state_change.block_hash()) == kTestBlockHash); CHECK(state_change.changes_size() == 1); const remote::AccountChange& account_change = state_change.changes(0); CHECK(account_change.data().empty()); CHECK(account_change.code().empty()); CHECK(address_from_h160(account_change.address()) == kTestAddress); CHECK(account_change.incarnation() == 0); CHECK(account_change.action() == remote::Action::REMOVE); CHECK(account_change.storage_changes_size() == 0); }, StateChangeFilter{}); scc.start_new_batch(kTestBlockNum, kTestBlockHash, sample_rlp_buffers(), /*unwind=*/false); scc.delete_account(kTestAddress); scc.notify_batch(kTestPendingBaseFee, kTestGasLimit); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/db/kv/grpc/test_util/sample_protos.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "../../api/endpoint/temporal_point.hpp" #include "../../api/endpoint/temporal_range.hpp" namespace silkworm::db::kv::test_util { namespace proto = ::remote; using silkworm::test_util::ascii_from_hex; inline api::HistoryPointRequest sample_history_point_request() { return { .tx_id = 1, .table = "AAA", .key = {0x00, 0x11, 0xff}, .timestamp = 1234567, }; } inline proto::HistorySeekReq sample_proto_history_seek_request() { proto::HistorySeekReq request; request.set_tx_id(1); request.set_table("AAA"); request.set_k(ascii_from_hex("0011ff")); request.set_ts(1234567); return request; } inline proto::HistorySeekReply sample_proto_history_seek_response() { proto::HistorySeekReply response; response.set_ok(true); response.set_v(ascii_from_hex("ff00ff00")); return response; } inline api::HistoryPointResult sample_history_point_result() { return { .success = true, .value = {0xff, 0x00, 0xff, 0x00}, }; } inline api::GetAsOfRequest sample_get_latest_request() { return { .tx_id = 1, .table = "AAA", .key = {0x00, 0x11, 0xff}, .sub_key = {0x00, 0x11, 0x22}, }; } inline api::GetAsOfRequest sample_get_as_of_request() { return { .tx_id = 1, .table = "AAA", .key = {0x00, 0x11, 0xff}, .sub_key = {0x00, 0x11, 0x22}, .timestamp = 1234567, }; } inline proto::GetLatestReq sample_proto_get_latest_request() { proto::GetLatestReq request; request.set_tx_id(1); request.set_table("AAA"); request.set_k(ascii_from_hex("0011ff")); request.set_latest(true); request.set_k2(ascii_from_hex("001122")); return request; } inline proto::GetLatestReq sample_proto_get_as_of_request() { proto::GetLatestReq request; request.set_tx_id(1); request.set_table("AAA"); request.set_k(ascii_from_hex("0011ff")); request.set_ts(1234567); request.set_k2(ascii_from_hex("001122")); return request; } inline proto::GetLatestReply sample_proto_get_latest_response() { proto::GetLatestReply response; response.set_ok(true); response.set_v(ascii_from_hex("ff00ff00")); return response; } inline proto::GetLatestReply sample_proto_get_as_of_response() { proto::GetLatestReply response; response.set_ok(true); response.set_v(ascii_from_hex("ff00ff00")); return response; } inline api::GetLatestResult sample_get_latest_result() { return { .success = true, .value = {0xff, 0x00, 0xff, 0x00}, }; } inline api::GetAsOfResult sample_get_as_of_result() { return { .success = true, .value = {0xff, 0x00, 0xff, 0x00}, }; } inline api::IndexRangeRequest sample_index_range_request() { return { .tx_id = 1, .table = "AAA", .key = {0x00, 0x11, 0xff}, .from_timestamp = 1234567, .to_timestamp = 1234967, .ascending_order = true, .limit = 1'000, .page_size = 100, .page_token = "token1", }; } inline proto::IndexRangeReq default_proto_index_range_request() { proto::IndexRangeReq request; request.set_limit(api::kUnlimited); // default value for type is 0 whilst we're choosing unlimited (-1) in API return request; } inline proto::IndexRangeReq sample_proto_index_range_request() { proto::IndexRangeReq request; request.set_tx_id(1); request.set_table("AAA"); request.set_k(ascii_from_hex("0011ff")); request.set_from_ts(1234567); request.set_to_ts(1234967); request.set_order_ascend(true); request.set_limit(1'000); request.set_page_size(100); request.set_page_token("token1"); return request; } inline proto::IndexRangeReply sample_proto_index_range_response() { proto::IndexRangeReply response; response.set_next_page_token("token2"); response.add_timestamps(1234567); response.add_timestamps(1234568); return response; } inline api::IndexRangeResult sample_index_range_result() { return { .timestamps = {1234567, 1234568}, .next_page_token = "token2", }; } inline api::HistoryRangeRequest sample_history_range_request() { return { .tx_id = 1, .table = "AAA", .from_timestamp = 1234567, .to_timestamp = 1234967, .ascending_order = true, .limit = 1'000, .page_size = 100, .page_token = "token1", }; } inline proto::HistoryRangeReq default_proto_history_range_request() { proto::HistoryRangeReq request; request.set_limit(api::kUnlimited); // default value for type is 0 whilst we're choosing unlimited (-1) in API return request; } inline proto::HistoryRangeReq sample_proto_history_range_request() { proto::HistoryRangeReq request; request.set_tx_id(1); request.set_table("AAA"); request.set_from_ts(1234567); request.set_to_ts(1234967); request.set_order_ascend(true); request.set_limit(1'000); request.set_page_size(100); request.set_page_token("token1"); return request; } inline proto::Pairs sample_proto_history_range_response() { proto::Pairs response; response.add_keys(bytes_to_string(*from_hex("00110011AA"))); response.add_keys(bytes_to_string(*from_hex("00110011BB"))); response.add_values(bytes_to_string(*from_hex("00110011EE"))); response.add_values(bytes_to_string(*from_hex("00110011FF"))); response.set_next_page_token("token2"); return response; } inline api::HistoryRangeResult sample_history_range_result() { return { .keys = {{0x00, 0x11, 0x00, 0x11, 0xAA}, {0x00, 0x11, 0x00, 0x11, 0xBB}}, .values = {{0x00, 0x11, 0x00, 0x11, 0xEE}, {0x00, 0x11, 0x00, 0x11, 0xFF}}, .next_page_token = "token2", }; } inline api::DomainRangeRequest sample_domain_range_request() { return { .tx_id = 1, .table = "AAA", .from_key = {0x00, 0x11, 0xaa}, .to_key = {0x00, 0x11, 0xff}, .timestamp = 180'000'000, .ascending_order = true, .limit = 1'000, .page_size = 100, .page_token = "token7", }; } inline proto::RangeAsOfReq default_proto_domain_range_request() { proto::RangeAsOfReq request; request.set_limit(api::kUnlimited); // default value for type is 0 whilst we're choosing unlimited (-1) in API return request; } inline proto::RangeAsOfReq sample_proto_domain_range_request() { proto::RangeAsOfReq request; request.set_tx_id(1); request.set_table("AAA"); request.set_from_key(ascii_from_hex("0011aa")); request.set_to_key(ascii_from_hex("0011ff")); request.set_ts(180'000'000); request.set_order_ascend(true); request.set_limit(1'000); request.set_page_size(100); request.set_page_token("token7"); return request; } inline proto::Pairs sample_proto_domain_range_response() { proto::Pairs response; response.add_keys("00110011AA"); response.add_keys("00110011BB"); response.add_values("00110011EE"); response.add_values("00110011FF"); response.set_next_page_token("token2"); return response; } inline api::DomainRangeResult sample_domain_range_result() { return { .keys = {{0x00, 0x11, 0x00, 0x11, 0xAA}, {0x00, 0x11, 0x00, 0x11, 0xBB}}, .values = {{0x00, 0x11, 0x00, 0x11, 0xEE}, {0x00, 0x11, 0x00, 0x11, 0xFF}}, .next_page_token = "token2", }; } } // namespace silkworm::db::kv::test_util ================================================ FILE: silkworm/db/kv/state_changes_stream.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_changes_stream.hpp" #include #include #include #include #include namespace silkworm::db::kv { StateChangesStream::StateChangesStream(rpc::ClientContext& context, api::Client& client) : ioc_(*context.ioc()), client_(client), cache_(must_use_shared_service(ioc_)) {} std::future StateChangesStream::open() { return concurrency::spawn_future(ioc_, run()); } void StateChangesStream::close() { cancellation_token_.signal_cancellation(); SILK_TRACE << "Close state changes stream: cancellation emitted"; } Task StateChangesStream::run() { SILK_TRACE << "StateChangesStream::run state stream START"; api::StateChangeOptions options{ .cancellation_token = &cancellation_token_, }; auto kv_service = client_.service(); auto state_change_set_consumer = [&](std::optional change_set) -> Task { if (!change_set) { SILK_TRACE << "State changes stream terminated by server"; co_return; } cache_->on_new_block(*change_set); }; co_await kv_service->state_changes(options, state_change_set_consumer); SILK_TRACE << "StateChangesStream::run state stream END"; } } // namespace silkworm::db::kv ================================================ FILE: silkworm/db/kv/state_changes_stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #ifndef BOOST_ASIO_HAS_BOOST_DATE_TIME #define BOOST_ASIO_HAS_BOOST_DATE_TIME #endif #include #include #include #include #include #include "api/client.hpp" #include "api/state_cache.hpp" #include "grpc/client/rpc.hpp" namespace silkworm::db::kv { //! End-point of the stream of state changes coming from the node Core component class StateChangesStream { public: explicit StateChangesStream(rpc::ClientContext& context, api::Client& client); //! Open up the stream, starting the register-and-receive loop std::future open(); //! Close down the stream, stopping the register-and-receive loop void close(); //! The register-and-receive asynchronous loop Task run(); private: //! Asio execution scheduler running the register-and-receive asynchronous loop boost::asio::io_context& ioc_; //! The entry point as KV API user api::Client& client_; //! The local state cache where the received state changes will be applied api::StateCache* cache_; //! The thread-safe cancellation token for StateChanges KV API CancellationToken cancellation_token_; }; } // namespace silkworm::db::kv ================================================ FILE: silkworm/db/kv/state_changes_stream_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_changes_stream.hpp" #include #if !defined(__APPLE__) || defined(NDEBUG) #include #endif // !defined(__APPLE__) || defined(NDEBUG) #include #include #include #include #include #include #include #include #include #include #if !defined(__APPLE__) || defined(NDEBUG) #include #endif // !defined(__APPLE__) || defined(NDEBUG) #include #if !defined(__APPLE__) || defined(NDEBUG) #include #endif // !defined(__APPLE__) || defined(NDEBUG) #include #include #include #include "grpc/client/remote_client.hpp" namespace silkworm::db::kv { using namespace std::chrono_literals; // NOLINT(build/namespaces) using grpc::client::RemoteClient; using testing::InvokeWithoutArgs; namespace test = rpc::test; #ifndef SILKWORM_SANITIZE struct StateCacheTestBase : public test_util::KVTestBase { StateCacheTestBase() { add_shared_service(ioc_, std::make_shared()); } }; using namespace silkworm::grpc::test_util; namespace proto = ::remote; using StrictMockKVStub = testing::StrictMock; using RemoteClientTestRunner = TestRunner; struct StateChangesStreamTest : public StateCacheTestBase { api::StateChangeChannelPtr channel{std::make_shared(ioc_.get_executor())}; concurrency::Channel state_changes_calls_channel{ioc_.get_executor()}; api::ServiceRouter router{state_changes_calls_channel}; std::unique_ptr state_cache{std::make_unique()}; }; struct DirectStateChangesStreamTest : public StateChangesStreamTest { TemporaryDirectory tmp_dir; test_util::TestDataStore data_store{tmp_dir}; ChainConfig chain_config; std::shared_ptr direct_service{ std::make_shared(router, data_store->ref(), chain_config, state_cache.get())}; api::DirectClient direct_client{direct_service}; StateChangesStream stream{context_, direct_client}; }; struct RemoteStateChangesStreamTest : public StateChangesStreamTest { // We're not testing blocks here, so we don't care about proper block provider chain::BlockProvider block_provider{ [](BlockNum, HashAsSpan, bool, Block&) -> Task { co_return false; }}; // We're not testing blocks here, so we don't care about proper block-number-from-txn-hash provider chain::BlockNumFromTxnHashProvider block_num_from_txn_hash_provider{ [](HashAsSpan) -> Task>> { co_return std::make_pair(0, 0); }}; chain::BlockNumFromBlockHashProvider block_num_from_block_hash_provider{ [](HashAsSpan) -> Task> { co_return std::nullopt; }}; chain::CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number_provider{ [](BlockNum) -> Task> { co_return 0; }}; chain::CanonicalBodyForStorageProvider canonical_body_for_storage_provider{ [](BlockNum) -> Task> { co_return Bytes{}; }}; RemoteClient make_remote_client(auto&& channel_or_stub) { return { std::forward(channel_or_stub), grpc_context_, state_cache.get(), {block_provider, block_num_from_txn_hash_provider, block_num_from_block_hash_provider, canonical_block_hash_from_number_provider}}; } }; static remote::StateChangeBatch make_batch() { static BlockNum block_num{14'000'010}; remote::StateChangeBatch state_changes{}; remote::StateChange* latest_change = state_changes.add_change_batch(); latest_change->set_block_height(++block_num); return state_changes; } TEST_CASE_METHOD(RemoteStateChangesStreamTest, "RemoteStateChangesStreamTest::open", "[db][kv][state_changes_stream]") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncStateChangesRaw call fails immediately expect_request_async_statechanges(/*.ok=*/false); // 2. AsyncReader::Finish call succeeds w/ status cancelled EXPECT_CALL(*statechanges_reader_, Finish).WillOnce(test::finish_streaming_cancelled(grpc_context_)); // Execute the test: opening the stream should succeed until finishes RemoteClient remote_client{make_remote_client(std::move(stub_))}; StateChangesStream stream{context_, remote_client}; std::future run_completed; CHECK_NOTHROW(run_completed = stream.open()); stream.close(); CHECK_NOTHROW(run_completed.get()); } TEST_CASE_METHOD(RemoteStateChangesStreamTest, "RemoteStateChangesStreamTest::run", "[db][kv][state_changes_stream]") { SECTION("stream closed-by-peer") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncStateChangesRaw calls succeed EXPECT_CALL(*stub_, PrepareAsyncStateChangesRaw) .WillOnce(InvokeWithoutArgs([&]() { // 2. AsyncReader::StartCall call succeed EXPECT_CALL(*statechanges_reader_, StartCall) .WillOnce([&](void* tag) { agrpc::process_grpc_tag(grpc_context_, tag, /*.ok=*/true); // 3. AsyncReader::Read 1st/2nd/3rd calls succeed, 4th fails EXPECT_CALL(*statechanges_reader_, Read) .WillOnce(test::read_success_with(grpc_context_, make_batch())) .WillOnce(test::read_success_with(grpc_context_, make_batch())) .WillOnce(test::read_success_with(grpc_context_, make_batch())) .WillOnce(test::read_failure(grpc_context_)); // 4. AsyncReader::Finish call succeeds w/ status aborted EXPECT_CALL(*statechanges_reader_, Finish) .WillOnce(test::finish_streaming_aborted(grpc_context_)); }); return statechanges_reader_ptr_.release(); })); RemoteClient remote_client{make_remote_client(std::move(stub_))}; // remote_client.set_min_backoff_timeout(10ms); // remote_client.set_max_backoff_timeout(100ms); StateChangesStream stream{context_, remote_client}; // Execute the test: running the stream should succeed until finishes CHECK_NOTHROW(spawn_and_wait(stream.run())); } SECTION("failure in first read") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncStateChangesRaw call succeeds expect_request_async_statechanges(/*.ok=*/true); // 2. AsyncReader::Read call fails EXPECT_CALL(*statechanges_reader_, Read).WillOnce(test::read_failure(grpc_context_)); // 3. AsyncReader::Finish call succeeds w/ status aborted EXPECT_CALL(*statechanges_reader_, Finish).WillOnce(test::finish_streaming_aborted(grpc_context_)); RemoteClient remote_client{make_remote_client(std::move(stub_))}; StateChangesStream stream{context_, remote_client}; // Execute the test: running the stream should succeed until finishes CHECK_NOTHROW(spawn_and_wait(stream.run())); } SECTION("failure in second read") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncStateChangesRaw call succeeds expect_request_async_statechanges(/*.ok=*/true); // 2. AsyncReader::Read 1st call succeeds, 2nd call fails EXPECT_CALL(*statechanges_reader_, Read) .WillOnce(test::read_success_with(grpc_context_, make_batch())) .WillOnce(test::read_failure(grpc_context_)); // 3. AsyncReader::Finish call succeeds w/ status aborted EXPECT_CALL(*statechanges_reader_, Finish).WillOnce(test::finish_streaming_aborted(grpc_context_)); RemoteClient remote_client{make_remote_client(std::move(stub_))}; StateChangesStream stream{context_, remote_client}; // Execute the test: running the stream should succeed until finishes CHECK_NOTHROW(spawn_and_wait(stream.run())); } } TEST_CASE_METHOD(RemoteStateChangesStreamTest, "RemoteStateChangesStreamTest::close", "[db][kv][state_changes_stream]") { const auto close_delay = GENERATE(0ms, 1ms, 10ms, 50ms); SECTION("while requesting w/ error every 10ms") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncStateChangesRaw calls succeed EXPECT_CALL(*stub_, PrepareAsyncStateChangesRaw) .WillRepeatedly(InvokeWithoutArgs([&]() { static int counter{0}; if (counter > 0) { // Recreate mocked reader for StateChanges RPC statechanges_reader_ptr_ = std::make_unique(); statechanges_reader_ = statechanges_reader_ptr_.get(); } ++counter; // 2. AsyncReader<>::StartCall call fails EXPECT_CALL(*statechanges_reader_, StartCall) .WillOnce([&](void* tag) { agrpc::process_grpc_tag(grpc_context_, tag, false); // 3. AsyncReader<>::Finish call succeeds w/ status unavailable EXPECT_CALL(*statechanges_reader_, Finish).WillOnce(test::finish_streaming_unavailable(grpc_context_)); }); return statechanges_reader_ptr_.release(); })); RemoteClient remote_client{make_remote_client(std::move(stub_))}; remote_client.set_min_backoff_timeout(5ms); remote_client.set_max_backoff_timeout(10ms); StateChangesStream stream{context_, remote_client}; // Execute the pre-condition: the stream must be running for at least for ms std::future run_result; REQUIRE_NOTHROW(run_result = spawn(stream.run())); if (close_delay > 0ms) { sleep_for(close_delay); } // Execute the test: closing the stream should succeed CHECK_NOTHROW(stream.close()); // Execute the post-condition: the running stream finishes REQUIRE_NOTHROW(run_result.get()); } SECTION("while reading w/ error every 10ms") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncStateChangesRaw calls succeed EXPECT_CALL(*stub_, PrepareAsyncStateChangesRaw) .WillRepeatedly(InvokeWithoutArgs([&]() { static int counter{0}; if (counter > 0) { // Recreate mocked reader for StateChanges RPC statechanges_reader_ptr_ = std::make_unique(); statechanges_reader_ = statechanges_reader_ptr_.get(); } ++counter; // 2. AsyncReader<>::StartCall call succeeds EXPECT_CALL(*statechanges_reader_, StartCall) .WillOnce([&](void* tag) { agrpc::process_grpc_tag(grpc_context_, tag, /*.ok=*/true); // 3. AsyncReader::Read call fails EXPECT_CALL(*statechanges_reader_, Read).WillRepeatedly(test::read_failure(grpc_context_)); // 4. AsyncReader::Finish call succeeds w/ status unavailable EXPECT_CALL(*statechanges_reader_, Finish) .WillRepeatedly(test::finish_streaming_unavailable(grpc_context_)); }); return statechanges_reader_ptr_.release(); })); RemoteClient remote_client{make_remote_client(std::move(stub_))}; remote_client.set_min_backoff_timeout(5ms); remote_client.set_max_backoff_timeout(10ms); StateChangesStream stream{context_, remote_client}; // Execute the pre-condition: the stream must be running at least for ms std::future run_result; REQUIRE_NOTHROW(run_result = spawn(stream.run())); if (close_delay > 0ms) { sleep_for(close_delay); } // Execute the test: closing the stream should succeed CHECK_NOTHROW(stream.close()); // Execute the post-condition: the running stream finishes REQUIRE_NOTHROW(run_result.get()); } } // Skip this test in macOS Debug build because raising signals triggers a suspension in the CLion Debug console #if !defined(__APPLE__) || defined(NDEBUG) TEST_CASE_METHOD(RemoteStateChangesStreamTest, "RemoteStateChangesStreamTest: signals", "[db][kv][state_changes_stream]") { // Skip this test if it is executed *NOT* on a TTY (e.g. CLion Run console) because it gets stuck :-( const bool is_terminal = is_terminal_stdout() && is_terminal_stderr(); if (!is_terminal) { return; // Silently skipped not to be counted explicitly as skipped } const auto signal_delay = GENERATE(0ms, 1ms, 10ms, 50ms); #if defined(_WIN32) const auto signal_number = GENERATE(SIGBREAK, SIGTERM); #else const auto signal_number = GENERATE(SIGQUIT, SIGTERM); #endif // defined(_WIN32) // We need a gRPC channel instance to stimulate the real connection scenario and trigger signal in such context auto make_channel_factory = []() { return ::grpc::CreateChannel("localhost:12345", ::grpc::InsecureChannelCredentials()); }; grpc::client::RemoteClient remote_client{make_remote_client(make_channel_factory)}; remote_client.set_min_backoff_timeout(5ms); remote_client.set_max_backoff_timeout(10ms); StateChangesStream stream{context_, remote_client}; SignalHandler::init([&stream](int) { stream.close(); }, /*silent=*/true); // Execute the pre-condition: the stream must be running at least for ms std::future run_result; REQUIRE_NOTHROW(run_result = spawn(stream.run())); if (signal_delay > 0ms) { sleep_for(signal_delay); } // Execute the test: sending the signal should terminate the running stream w/o throwing exceptions REQUIRE(std::raise(signal_number) == 0); CHECK_NOTHROW(run_result.get()); } #endif // !defined(__APPLE__) || defined(NDEBUG) #endif // SILKWORM_SANITIZE } // namespace silkworm::db::kv ================================================ FILE: silkworm/db/kv/state_reader.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_reader.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::db::kv { StateReader::StateReader(api::Transaction& tx, std::optional txn_id) : tx_(tx), txn_number_(txn_id) {} Task> StateReader::read_account(const evmc::address& address) const { api::PointResult result; if (!txn_number_) { result = co_await latest_from_cache(table::kAccountDomain, db::account_domain_key(address)); } else { db::kv::api::GetAsOfRequest request{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(address), .timestamp = static_cast(*txn_number_), }; result = co_await tx_.get_as_of(std::move(request)); } if (!result.success) { co_return std::nullopt; } // Non-existent account has empty encoded value if (result.value.empty()) { co_return std::nullopt; } const auto account = db::state::AccountCodec::from_encoded_storage_v3(result.value); success_or_throw(account); co_return *account; } Task StateReader::read_storage(const evmc::address& address, uint64_t /* incarnation */, const evmc::bytes32& location_hash) const { api::PointResult result; if (!txn_number_) { result = co_await latest_from_cache(table::kStorageDomain, db::storage_domain_key(address, location_hash)); } else { db::kv::api::GetAsOfRequest request{ .table = std::string{table::kStorageDomain}, .key = db::storage_domain_key(address, location_hash), .timestamp = static_cast(*txn_number_), }; result = co_await tx_.get_as_of(std::move(request)); } if (!result.success) { co_return evmc::bytes32{}; } co_return to_bytes32(result.value); } Task> StateReader::read_code(const evmc::address& address, const evmc::bytes32& code_hash) const { if (code_hash == kEmptyHash) { co_return std::nullopt; } api::PointResult result; if (!txn_number_) { result = co_await latest_code_from_cache(db::code_domain_key(address)); } else { db::kv::api::GetAsOfRequest request{ .table = std::string{table::kCodeDomain}, .key = db::code_domain_key(address), .timestamp = static_cast(*txn_number_), }; result = co_await tx_.get_as_of(std::move(request)); } if (!result.success) { co_return std::nullopt; } co_return result.value; } Task StateReader::latest_from_cache(std::string_view table, Bytes key) const { const auto state_view = co_await tx_.state_cache()->get_view(tx_); auto value = co_await state_view->get(table, std::move(key)); api::PointResult result{.success = value.has_value()}; if (value) { result.value = std::move(*value); } co_return result; } Task StateReader::latest_code_from_cache(Bytes key) const { const auto state_view = co_await tx_.state_cache()->get_view(tx_); auto value = co_await state_view->get_code(std::move(key)); api::PointResult result{.success = value.has_value()}; if (value) { result.value = std::move(*value); } co_return result; } } // namespace silkworm::db::kv ================================================ FILE: silkworm/db/kv/state_reader.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include "version.hpp" namespace silkworm::db::kv { class StateReader { public: StateReader(api::Transaction& tx, std::optional txn_id); StateReader(const StateReader&) = delete; StateReader& operator=(const StateReader&) = delete; Task> read_account(const evmc::address& address) const; Task read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location_hash) const; Task> read_code(const evmc::address& address, const evmc::bytes32& code_hash) const; private: inline Task latest_from_cache(std::string_view table, Bytes key) const; inline Task latest_code_from_cache(Bytes key) const; api::Transaction& tx_; std::optional txn_number_; }; } // namespace silkworm::db::kv ================================================ FILE: silkworm/db/kv/state_reader_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_reader.hpp" #include #include #include #include #include #include #include namespace silkworm::db::kv { using testing::_; using testing::Invoke; using testing::Unused; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); // Execute the test: calling read_account should return no account std::optional account; CHECK_NOTHROW(account = spawn_and_wait(state_reader_.read_account(kZeroAddress))); CHECK(!account); } SECTION("account found in current state") { EXPECT_CALL(transaction_, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = kEncodedAccount}; co_return response; })); // Execute the test: calling read_account should return the expected account std::optional account; CHECK_NOTHROW(account = spawn_and_wait(state_reader_.read_account(kZeroAddress))); CHECK(account); if (account) { CHECK(account->nonce == 2); CHECK(account->balance == 1000); CHECK(account->code_hash == 0xf1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239_bytes32); CHECK(account->incarnation == 5); } } SECTION("account found in history") { EXPECT_CALL(transaction_, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = kEncodedAccount}; co_return response; })); // Execute the test: calling read_account should return expected account std::optional account; CHECK_NOTHROW(account = spawn_and_wait(state_reader_.read_account(kZeroAddress))); CHECK(account); if (account) { CHECK(account->nonce == 2); CHECK(account->balance == 1000); CHECK(account->code_hash == 0xf1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239_bytes32); CHECK(account->incarnation == 5); } } } TEST_CASE_METHOD(StateReaderTest, "StateReader::read_storage") { SECTION("empty storage for history empty and current state empty") { EXPECT_CALL(transaction_, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); // Execute the test: calling read_storage should return empty storage value evmc::bytes32 location; CHECK_NOTHROW(location = spawn_and_wait(state_reader_.read_storage(kZeroAddress, 0, kLocationHash))); CHECK(location == evmc::bytes32{}); } SECTION("storage found in current state") { EXPECT_CALL(transaction_, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = kStorageLocation}; co_return response; })); // Execute the test: calling read_storage should return expected storage location evmc::bytes32 location; CHECK_NOTHROW(location = spawn_and_wait(state_reader_.read_storage(kZeroAddress, 0, kLocationHash))); CHECK(location == to_bytes32(kStorageLocation)); } SECTION("storage found in history") { EXPECT_CALL(transaction_, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = kStorageLocation}; co_return response; })); // Execute the test: calling read_storage should return expected storage location evmc::bytes32 location; CHECK_NOTHROW(location = spawn_and_wait(state_reader_.read_storage(kZeroAddress, 0, kLocationHash))); CHECK(location == to_bytes32(kStorageLocation)); } } TEST_CASE_METHOD(StateReaderTest, "StateReader::read_code") { SECTION("no code for empty code hash") { // Execute the test: calling read_code should return no code for empty hash std::optional code; CHECK_NOTHROW(code = spawn_and_wait(state_reader_.read_code(kZeroAddress, kEmptyHash))); CHECK(!code); } SECTION("empty code found for code hash") { EXPECT_CALL(transaction_, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); // Execute the test: calling read_code should return an empty code std::optional code; CHECK_NOTHROW(code = spawn_and_wait(state_reader_.read_code(kZeroAddress, kCodeHash))); CHECK(code); if (code) { CHECK(code->empty()); } } SECTION("non-empty code found for code hash") { EXPECT_CALL(transaction_, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = kBinaryCode}; co_return response; })); // Execute the test: calling read_code should return a non-empty code std::optional code; CHECK_NOTHROW(code = spawn_and_wait(state_reader_.read_code(kZeroAddress, kCodeHash))); CHECK(code); if (code) { CHECK(to_hex(*code) == to_hex(kBinaryCode)); } } } #endif // !defined(SILKWORM_SANITIZE) && !defined(_WIN32) } // namespace silkworm::db::kv ================================================ FILE: silkworm/db/kv/txn_num.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txn_num.hpp" #include #include #include #include #include #include #include #include "../tables.hpp" namespace silkworm::db::txn { using kv::api::KeyValue; using kv::api::Transaction; static Task> last_tx_num_for_block(const std::shared_ptr& max_tx_num_cursor, BlockNum block_num, chain::CanonicalBodyForStorageProvider canonical_body_for_storage_provider) { const auto block_num_key = block_key(block_num); const auto key_value = co_await max_tx_num_cursor->seek_exact(block_num_key); if (key_value.value.empty()) { SILKWORM_ASSERT(canonical_body_for_storage_provider); auto block_body_data = co_await canonical_body_for_storage_provider(block_num); if (!block_body_data) { co_return std::nullopt; } ByteView block_body_data_view{*block_body_data}; const auto stored_body = unwrap_or_throw(decode_stored_block_body(block_body_data_view)); co_return stored_body.base_txn_id + stored_body.txn_count - 1; } if (key_value.value.size() != sizeof(TxNum)) { throw std::length_error("Bad TxNum value size " + std::to_string(key_value.value.size()) + " in db"); } co_return endian::load_big_u64(key_value.value.data()); } static std::pair kv_to_block_num_and_tx_num(const KeyValue& key_value) { if (key_value.key.empty() || key_value.value.empty()) { return std::make_pair(0, 0); } if (key_value.key.size() != sizeof(BlockNum)) { throw std::length_error("Bad BlockNum key size " + std::to_string(key_value.key.size()) + " in db"); } if (key_value.value.size() != sizeof(TxNum)) { throw std::length_error("Bad TxNum value size " + std::to_string(key_value.value.size()) + " in db"); } return std::make_pair(endian::load_big_u64(key_value.key.data()), endian::load_big_u64(key_value.value.data())); } Task max_tx_num(Transaction& tx, BlockNum block_num, chain::CanonicalBodyForStorageProvider provider) { const auto max_tx_num_cursor = co_await tx.cursor(table::kMaxTxNumName); const std::optional last_tx_num = co_await last_tx_num_for_block(max_tx_num_cursor, block_num, provider); if (!last_tx_num) { const KeyValue key_value = co_await max_tx_num_cursor->last(); if (key_value.value.empty()) { co_return 0; } if (key_value.value.size() != sizeof(TxNum)) { throw std::length_error("Bad TxNum value size " + std::to_string(key_value.value.size()) + " in db"); } co_return endian::load_big_u64(key_value.value.data()); } co_return *last_tx_num; } Task min_tx_num(Transaction& tx, BlockNum block_num, chain::CanonicalBodyForStorageProvider provider) { if (block_num == 0) { co_return 0; } const auto max_tx_num_cursor = co_await tx.cursor(table::kMaxTxNumName); const std::optional last_tx_num = co_await last_tx_num_for_block(max_tx_num_cursor, (block_num - 1), provider); if (!last_tx_num) { const KeyValue key_value = co_await max_tx_num_cursor->last(); if (key_value.value.empty()) { co_return 0; } if (key_value.value.size() != sizeof(TxNum)) { throw std::length_error("Bad TxNum value size " + std::to_string(key_value.value.size()) + " in db"); } co_return endian::load_big_u64(key_value.value.data()); } co_return *last_tx_num + 1; } Task first_tx_num(Transaction& tx) { const auto max_tx_num_cursor = co_await tx.cursor(table::kMaxTxNumName); const auto first_key_value = co_await max_tx_num_cursor->first(); co_return kv_to_block_num_and_tx_num(first_key_value); } Task last_tx_num(Transaction& tx) { const auto max_tx_num_cursor = co_await tx.cursor(table::kMaxTxNumName); const auto last_key_value = co_await max_tx_num_cursor->last(); co_return kv_to_block_num_and_tx_num(last_key_value); } Task> block_num_from_tx_num(kv::api::Transaction& tx, TxNum tx_num, chain::CanonicalBodyForStorageProvider provider) { const auto max_tx_num_cursor = co_await tx.cursor(table::kMaxTxNumName); const auto last_key_value = co_await max_tx_num_cursor->last(); if (last_key_value.value.empty()) { co_return std::nullopt; } if (last_key_value.value.size() != sizeof(TxNum)) { throw std::length_error("Bad TxNum value size " + std::to_string(last_key_value.value.size()) + " in db"); } const auto [last_block_num, _] = kv_to_block_num_and_tx_num(last_key_value); const auto block_num = co_await async_binary_search(last_block_num + 1, [&](size_t i) -> Task { const auto max_tx_num = co_await last_tx_num_for_block(max_tx_num_cursor, i, provider); if (!max_tx_num) { const KeyValue first_key = co_await max_tx_num_cursor->first(); const KeyValue last_key = co_await max_tx_num_cursor->last(); const std::string first_value = first_key.value.empty() ? "0" : std::to_string(endian::load_big_u64(first_key.value.data())); const std::string last_value = last_key.value.empty() ? "0" : std::to_string(endian::load_big_u64(last_key.value.data())); throw std::invalid_argument("Bad txNum: first: " + first_value + " last: " + last_value); } co_return max_tx_num >= tx_num; }); if (block_num > last_block_num) { co_return std::nullopt; } co_return block_num; } Task> TransactionInfoIterator::next() { auto next_id = co_await stream_->next(); if (!next_id) { SILK_DEBUG << "No more values"; co_return std::nullopt; } const auto tnx_id = static_cast(next_id.value()); bool block_changed{false}; if (max_txn_num_ == 0 || (ascending_ && tnx_id > max_txn_num_) || (!ascending_ && tnx_id < min_txn_num_)) { const auto block_num_opt = co_await db::txn::block_num_from_tx_num(tx_, tnx_id, provider_); if (!block_num_opt) { SILK_DEBUG << "No block found for txn_id " << tnx_id; co_return std::nullopt; } block_num_ = block_num_opt.value(); max_txn_num_ = co_await db::txn::max_tx_num(tx_, block_num_, provider_); min_txn_num_ = co_await db::txn::min_tx_num(tx_, block_num_, provider_); block_changed = true; } const TransactionNums txn_nums{ .txn_id = tnx_id, .block_num = block_num_, .txn_index = (tnx_id != min_txn_num_ && tnx_id != max_txn_num_) ? std::make_optional(tnx_id - min_txn_num_ - 1) : std::nullopt, .block_changed = block_changed}; SILK_DEBUG << "txn_id: " << txn_nums.txn_id << ", block_num: " << txn_nums.block_num << ", tnx_index: " << (txn_nums.txn_index ? std::to_string(*txn_nums.txn_index) : "") << ", max_tnx_num: " << max_txn_num_ << ", min_txn_num: " << min_txn_num_; co_return txn_nums; } kv::api::Stream make_txn_nums_stream(kv::api::TimestampStream stream, bool ascending, kv::api::Transaction& tx, db::chain::CanonicalBodyForStorageProvider& provider) { return std::make_unique(std::move(stream), ascending, tx, provider); } } // namespace silkworm::db::txn ================================================ FILE: silkworm/db/kv/txn_num.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "../kv/api/transaction.hpp" namespace silkworm::db::txn { //! TxNum represents the monotonically increasing unique numbering of blockchain transactions in range [0, inf) //! TxNum is contiguous (no holes) and canonical, i.e. universal among all client nodes //! \see txnum.go in Erigon using TxNum = TxnId; //! Return the maximum TxNum in specified \code block_num Task max_tx_num(kv::api::Transaction& tx, BlockNum block_num, chain::CanonicalBodyForStorageProvider provider); //! Return the minimum TxNum in specified \code block_num Task min_tx_num(kv::api::Transaction& tx, BlockNum block_num, chain::CanonicalBodyForStorageProvider provider); using BlockNumAndTxnNumber = std::pair; //! Return the first assigned TxNum Task first_tx_num(kv::api::Transaction& tx); //! Return the last assigned TxNum Task last_tx_num(kv::api::Transaction& tx); //! Return the number of the block with max txn number at least equal to given \code tx_num Task> block_num_from_tx_num(kv::api::Transaction& tx, TxNum tx_num, chain::CanonicalBodyForStorageProvider provider); struct TransactionNums { TxnId txn_id{0}; BlockNum block_num{0}; std::optional txn_index; bool block_changed{false}; }; class TransactionInfoIterator : public kv::api::StreamIterator { public: TransactionInfoIterator(kv::api::TimestampStream stream, bool ascending, kv::api::Transaction& tx, db::chain::CanonicalBodyForStorageProvider& provider) : stream_(std::move(stream)), ascending_(ascending), tx_(tx), provider_(provider) {} Task has_next() override { return stream_->has_next(); } Task> next() override; private: kv::api::TimestampStream stream_; bool ascending_; kv::api::Transaction& tx_; db::chain::CanonicalBodyForStorageProvider& provider_; BlockNum block_num_{0}; TxNum min_txn_num_{0}; TxNum max_txn_num_{0}; }; kv::api::Stream make_txn_nums_stream(kv::api::TimestampStream stream, bool ascending, kv::api::Transaction& tx, db::chain::CanonicalBodyForStorageProvider& provider); } // namespace silkworm::db::txn ================================================ FILE: silkworm/db/kv/txn_num_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txn_num.hpp" #include #include #include #include #include #include #include "../tables.hpp" namespace silkworm::db::txn { using silkworm::test_util::ContextTestBase; using silkworm::test_util::Fixtures; using test_util::MockCursor; using test_util::MockTransaction; using testing::_; using testing::Invoke; using testing::Unused; struct TxNumText : ContextTestBase { MockTransaction transaction; chain::CanonicalBodyForStorageProvider provider; }; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher(); EXPECT_CALL(transaction, cursor(table::kMaxTxNumName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); struct BlockNumAndKeyValue { BlockNum block_num; kv::api::KeyValue key_value; }; const Fixtures fixtures{ {{0, {*from_hex("0000000000000000"), *from_hex("000000000000000A")}}, 10}, {{1, {*from_hex("0000000000000001"), *from_hex("000000000000000F")}}, 15}, }; for (const auto& [block_num_and_kv, expected_max_tx_num] : fixtures) { const auto [block_num, key_value] = block_num_and_kv; SECTION("block_num: " + std::to_string(block_num)) { EXPECT_CALL(*cursor, seek_exact(_)).WillOnce(Invoke([=](Unused) -> Task { co_return key_value; })); CHECK(spawn_and_wait(max_tx_num(transaction, block_num, provider)) == expected_max_tx_num); } } } TEST_CASE_METHOD(TxNumText, "min_tx_num", "[db][txn][tx_num]") { auto cursor = std::make_shared(); struct BlockNumAndKeyValue { BlockNum block_num; kv::api::KeyValue key_value; }; const Fixtures fixtures{ {{0, {*from_hex("0000000000000000"), *from_hex("0000000000000000")}}, 0}, {{1, {*from_hex("0000000000000000"), *from_hex("000000000000000E")}}, 15}, }; for (const auto& [block_num_and_kv, expected_max_tx_num] : fixtures) { const auto [block_num, key_value] = block_num_and_kv; SECTION("block_num: " + std::to_string(block_num)) { if (block_num != 0) { EXPECT_CALL(transaction, cursor(table::kMaxTxNumName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); EXPECT_CALL(*cursor, seek_exact(_)).WillOnce(Invoke([=](Unused) -> Task { co_return key_value; })); } CHECK(spawn_and_wait(min_tx_num(transaction, block_num, provider)) == expected_max_tx_num); } } } TEST_CASE_METHOD(TxNumText, "first_tx_num", "[db][txn][tx_num]") { auto cursor = std::make_shared(); const Fixtures> fixtures{ {{*from_hex(""), *from_hex("")}, BlockNumAndTxnNumber{}}, {{*from_hex("0000000000000000"), *from_hex("0000000000000001")}, BlockNumAndTxnNumber{0, 1}}, {{*from_hex("0000000000000001"), *from_hex("000000000000000E")}, BlockNumAndTxnNumber{1, 14}}, {{*from_hex("00000000000000"), *from_hex("000000000000000E")}, std::nullopt}, // wrong key format {{*from_hex("0000000000000001"), *from_hex("00")}, std::nullopt}, // wrong value format }; for (size_t i{0}; i < fixtures.size(); ++i) { const auto& [key_value, expected_block_and_txn_num] = fixtures[i]; SECTION("sequence: " + std::to_string(i)) { EXPECT_CALL(transaction, cursor(table::kMaxTxNumName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); EXPECT_CALL(*cursor, first()).WillOnce(Invoke([=]() -> Task { co_return key_value; })); if (expected_block_and_txn_num) { CHECK(spawn_and_wait(first_tx_num(transaction)) == *expected_block_and_txn_num); } else { CHECK_THROWS_AS(spawn_and_wait(first_tx_num(transaction)), std::length_error); } } } } TEST_CASE_METHOD(TxNumText, "last_tx_num", "[db][txn][tx_num]") { auto cursor = std::make_shared(); const Fixtures> fixtures{ {{*from_hex(""), *from_hex("")}, BlockNumAndTxnNumber{}}, {{*from_hex("0000000000000000"), *from_hex("0000000000000001")}, BlockNumAndTxnNumber{0, 1}}, {{*from_hex("0000000000000001"), *from_hex("000000000000000E")}, BlockNumAndTxnNumber{1, 14}}, {{*from_hex("00000000000000"), *from_hex("000000000000000E")}, std::nullopt}, // wrong key format {{*from_hex("0000000000000001"), *from_hex("00")}, std::nullopt}, // wrong value format }; for (size_t i{0}; i < fixtures.size(); ++i) { const auto& [key_value, expected_block_and_txn_num] = fixtures[i]; SECTION("sequence: " + std::to_string(i)) { EXPECT_CALL(transaction, cursor(table::kMaxTxNumName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return key_value; })); if (expected_block_and_txn_num) { CHECK(spawn_and_wait(last_tx_num(transaction)) == *expected_block_and_txn_num); } else { CHECK_THROWS_AS(spawn_and_wait(last_tx_num(transaction)), std::length_error); } } } } TEST_CASE_METHOD(TxNumText, "block_num_from_tx_num", "[db][txn][tx_num]") { const auto cursor = std::make_shared(); EXPECT_CALL(transaction, cursor(table::kMaxTxNumName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); SECTION("wrong key format") { // Block 0 is last in MDBX and has max tx num equal to 1 EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return kv::api::KeyValue{*from_hex("01"), *from_hex("0000000000000001")}; })); provider = [](BlockNum) -> Task> { co_return Bytes{}; }; CHECK_THROWS_AS(spawn_and_wait(block_num_from_tx_num(transaction, 0, provider)), std::exception); } SECTION("wrong value format") { // Block 0 is last in MDBX and has max tx num equal to 1 const Bytes block0_key = *from_hex("0000000000000000"); EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return kv::api::KeyValue{block0_key, *from_hex("01")}; })); provider = [](BlockNum) -> Task> { co_return Bytes{}; }; CHECK_THROWS_AS(spawn_and_wait(block_num_from_tx_num(transaction, 0, provider)), std::exception); } SECTION("no_block") { EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return kv::api::KeyValue{*from_hex(""), *from_hex("")}; })); provider = [](BlockNum) -> Task> { co_return Bytes{}; }; CHECK(spawn_and_wait(block_num_from_tx_num(transaction, 0, provider)) == std::nullopt); } SECTION("db_1_block: tx num 0 in block 0") { // Block 0 is last in MDBX and has max tx num equal to 1 const Bytes block0_key = *from_hex("0000000000000000"); EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return kv::api::KeyValue{block0_key, *from_hex("0000000000000001")}; })); EXPECT_CALL(*cursor, seek_exact(ByteView{block0_key})).WillOnce(Invoke([=](Unused) -> Task { co_return kv::api::KeyValue{block0_key, *from_hex("0000000000000001")}; })); provider = [](BlockNum) -> Task> { co_return Bytes{}; }; CHECK(spawn_and_wait(block_num_from_tx_num(transaction, 0, provider)) == 0); } SECTION("db_3_blocks: tx num 1 in block 0") { // Block 2 is last in MDBX and has max tx num equal to 30 const Bytes block2_key = *from_hex("0000000000000002"); EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return kv::api::KeyValue{block2_key, *from_hex("000000000000001E")}; })); // Block 1 is in MDBX and has max tx num equal to 14 const Bytes block1_key = *from_hex("0000000000000001"); EXPECT_CALL(*cursor, seek_exact(ByteView{block1_key})).WillOnce(Invoke([=](Unused) -> Task { co_return kv::api::KeyValue{block1_key, *from_hex("000000000000000E")}; })); // Block 0 is in MDBX and has max tx num equal to 1 const Bytes block0_key = *from_hex("0000000000000000"); EXPECT_CALL(*cursor, seek_exact(ByteView{block0_key})).WillOnce(Invoke([=](Unused) -> Task { co_return kv::api::KeyValue{block0_key, *from_hex("0000000000000001")}; })); provider = [](BlockNum) -> Task> { co_return Bytes{}; }; CHECK(spawn_and_wait(block_num_from_tx_num(transaction, 1, provider)) == 0); } SECTION("db_3_blocks: tx num 14 in block 1") { // Block 2 is last in MDBX and has max tx num equal to 30 const Bytes block2_key = *from_hex("0000000000000002"); EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return kv::api::KeyValue{block2_key, *from_hex("000000000000001E")}; })); // Block 1 is in MDBX and has max tx num equal to 14 const Bytes block1_key = *from_hex("0000000000000001"); EXPECT_CALL(*cursor, seek_exact(ByteView{block1_key})).WillOnce(Invoke([=](Unused) -> Task { co_return kv::api::KeyValue{block1_key, *from_hex("000000000000000E")}; })); // Block 0 is in MDBX and has max tx num equal to 1 const Bytes block0_key = *from_hex("0000000000000000"); EXPECT_CALL(*cursor, seek_exact(ByteView{block0_key})).WillOnce(Invoke([=](Unused) -> Task { co_return kv::api::KeyValue{block0_key, *from_hex("0000000000000001")}; })); provider = [](BlockNum) -> Task> { co_return Bytes{}; }; CHECK(spawn_and_wait(block_num_from_tx_num(transaction, 14, provider)) == 1); } SECTION("db_3_blocks: tx num 15 in block 2") { // Block 2 is last in MDBX and has max tx num equal to 30 const Bytes block2_key = *from_hex("0000000000000002"); EXPECT_CALL(*cursor, last()).WillOnce(Invoke([=]() -> Task { co_return kv::api::KeyValue{block2_key, *from_hex("000000000000001E")}; })); EXPECT_CALL(*cursor, seek_exact(ByteView{block2_key})).WillOnce(Invoke([=](Unused) -> Task { co_return kv::api::KeyValue{block2_key, *from_hex("000000000000001E")}; })); // Block 1 is in MDBX and has max tx num equal to 14 const Bytes block1_key = *from_hex("0000000000000001"); EXPECT_CALL(*cursor, seek_exact(ByteView{block1_key})).WillOnce(Invoke([=](Unused) -> Task { co_return kv::api::KeyValue{block1_key, *from_hex("000000000000000E")}; })); provider = [](BlockNum) -> Task> { co_return Bytes{}; }; CHECK(spawn_and_wait(block_num_from_tx_num(transaction, 15, provider)) == 2); } } #endif // _WIN32 } // namespace silkworm::db::txn ================================================ FILE: silkworm/db/log_cbor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log_cbor.hpp" #include #include #include #include #include #include #include namespace silkworm { Bytes cbor_encode(const std::vector& v) { cbor::output_dynamic output{}; cbor::encoder encoder{output}; encoder.write_array(static_cast(v.size())); for (const Log& l : v) { encoder.write_array(3); encoder.write_bytes(l.address.bytes, kAddressLength); encoder.write_array(static_cast(l.topics.size())); for (const evmc::bytes32& t : l.topics) { encoder.write_bytes(t.bytes, kHashLength); } encoder.write_bytes(l.data.data(), static_cast(l.data.size())); } return Bytes{output.data(), output.size()}; } //! LogCborListener is a *stateful* CBOR consumer suitable for parsing a CBOR-encoded sequence of Logs class LogCborListener : public cbor::listener { private: enum class ProcessingState { kWaitLogs, kWaitLog, kWaitAddress, kWaitTopics, kWaitTopic, kWaitData }; public: explicit LogCborListener(LogCborConsumer& consumer) : consumer_{consumer} {} void on_integer(int) override { ensure(false, "Log CBOR: unexpected format (on_integer called)"); } void on_map(int) override { ensure(false, "Log CBOR: unexpected format (on_map called)"); } void on_string(std::string&) override { ensure(false, "Log CBOR: unexpected format (on_string called)"); } void on_tag(unsigned int) override { ensure(false, "Log CBOR: unexpected format (on_tag called)"); } void on_undefined() override { ensure(false, "Log CBOR: unexpected format (on_undefined called)"); } void on_extra_integer(unsigned long long, int) override { // NOLINT(google-runtime-int) ensure(false, "Log CBOR: unexpected format (on_extra_integer called)"); } void on_bool(bool) override { ensure(false, "Log CBOR: unexpected format (on_bool called)"); } void on_extra_tag(unsigned long long) override { // NOLINT(google-runtime-int) ensure(false, "Log CBOR: unexpected format (on_extra_tag called)"); } void on_float32(float) override { ensure(false, "Log CBOR: unexpected format (on_float32 called)"); } void on_double(double) override { ensure(false, "Log CBOR: unexpected format (on_double called)"); } void on_extra_special(unsigned long long) override { // NOLINT(google-runtime-int) ensure(false, "Log CBOR: unexpected format (on_extra_special called)"); } void on_error(const char* what) override { throw std::runtime_error("Log CBOR: unexpected decoding error: " + std::string{what}); } void on_special(unsigned int) override { ensure(false, "Log CBOR: unexpected format (on_special called)"); } void on_null() override { ensure(false, "Log CBOR: unexpected format (on_null called)"); } void on_bytes(unsigned char* data, int size) override { ensure(size >= 0, "Log CBOR: unexpected format (on_bytes called with negative size)"); const auto data_size{static_cast(size)}; if (state_ == ProcessingState::kWaitAddress) { ensure(data_size == kAddressLength, [&]() { return "Log CBOR: unexpected address size " + std::to_string(data_size); }); consumer_.on_address(std::span{data, data_size}); state_ = ProcessingState::kWaitTopics; } else if (state_ == ProcessingState::kWaitTopic) { ensure(data_size == kHashLength, [&]() { return "Log CBOR: unexpected topic size " + std::to_string(data_size); }); consumer_.on_topic(HashAsSpan{data, data_size}); if (++current_topic_ == current_num_topics_) { state_ = ProcessingState::kWaitData; } } else if (state_ == ProcessingState::kWaitData) { consumer_.on_data(std::span{data, data_size}); state_ = ++current_log_ == current_num_logs_ ? ProcessingState::kWaitLogs : ProcessingState::kWaitLog; } else { ensure(false, "Log CBOR: unexpected format (on_bytes bad state)"); } } void on_array(int size) override { ensure(size >= 0, "Log CBOR: unexpected format (on_array called with negative size)"); const auto array_size{static_cast(size)}; if (state_ == ProcessingState::kWaitLogs) { consumer_.on_num_logs(array_size); state_ = ProcessingState::kWaitLog; current_num_logs_ = array_size; current_log_ = 0; } else if (state_ == ProcessingState::kWaitLog) { ensure(array_size == 3, [&]() { return "Log CBOR: unexpected number of Log fields " + std::to_string(array_size); }); state_ = ProcessingState::kWaitAddress; } else if (state_ == ProcessingState::kWaitTopics) { consumer_.on_num_topics(array_size); state_ = array_size == 0 ? ProcessingState::kWaitData : ProcessingState::kWaitTopic; current_num_topics_ = array_size; current_topic_ = 0; } else { ensure(false, "Log CBOR: unexpected format (on_array bad state)"); } } protected: LogCborConsumer& consumer_; ProcessingState state_{ProcessingState::kWaitLogs}; size_t current_num_logs_{0}; size_t current_log_{0}; size_t current_num_topics_{0}; size_t current_topic_{0}; }; void cbor_decode(ByteView data, LogCborConsumer& consumer) { cbor::input input(data.data(), static_cast(data.size())); LogCborListener listener{consumer}; cbor::decoder decoder(input, listener); decoder.run(); } //! LogBuilder is a CBOR consumer which builds a sequence of Logs from their CBOR representation class LogBuilder : public LogCborConsumer { public: explicit LogBuilder(std::vector& logs) : logs_{logs}, current_log_{} {} bool success() const { return std::cmp_equal(logs_.size(), current_num_logs_); } void on_num_logs(size_t num_logs) override { current_num_logs_ += num_logs; logs_.reserve(num_logs); } void on_address(std::span address_bytes) override { std::memcpy(current_log_.address.bytes, address_bytes.data(), address_bytes.size()); } void on_num_topics(size_t num_topics) override { current_log_.topics.reserve(num_topics); } void on_topic(HashAsSpan topic_bytes) override { evmc::bytes32 topic; std::memcpy(topic.bytes, topic_bytes.data(), topic_bytes.size()); current_log_.topics.emplace_back(topic); } void on_data(std::span data_bytes) override { current_log_.data.resize(data_bytes.size()); std::memcpy(current_log_.data.data(), data_bytes.data(), data_bytes.size()); logs_.emplace_back(std::move(current_log_)); current_log_ = {}; } private: std::vector& logs_; Log current_log_; size_t current_num_logs_{0}; }; bool cbor_decode(ByteView data, std::vector& logs) { LogBuilder builder{logs}; cbor_decode(data, builder); return builder.success(); } } // namespace silkworm ================================================ FILE: silkworm/db/log_cbor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { // Erigon-compatible CBOR encoding for storage. // See core/types/log.go Bytes cbor_encode(const std::vector& v); //! LogCborConsumer is the interface to implement for parsing a CBOR-encoded sequence of Logs struct LogCborConsumer { virtual ~LogCborConsumer() = default; virtual void on_num_logs(size_t num_logs) = 0; virtual void on_address(std::span address_bytes) = 0; virtual void on_num_topics(size_t num_topics) = 0; virtual void on_topic(HashAsSpan topic_bytes) = 0; virtual void on_data(std::span data_bytes) = 0; }; void cbor_decode(ByteView data, LogCborConsumer& consumer); [[nodiscard]] bool cbor_decode(ByteView data, std::vector& logs); } // namespace silkworm ================================================ FILE: silkworm/db/log_cbor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log_cbor.hpp" #include #include namespace silkworm { TEST_CASE("CBOR encoding of empty logs") { std::vector logs{}; Bytes encoded{cbor_encode(logs)}; CHECK(to_hex(encoded) == "80"); } TEST_CASE("CBOR encoding of logs") { auto logs{test::sample_receipts().at(0).logs}; auto encoded{cbor_encode(logs)}; CHECK(to_hex(encoded) == "828354ea674fdde714fd979de3edf0f56aa9716b898ec88043010043835444fd3ab8381cc3d" "14afa7c4af7fd13cdc65026e1825820000000000000000000000000000000000000000000000" "000000000000000dead582000000000000000000000000000000000000000000000000000000" "0000000abba46aabbff780043"); } TEST_CASE("CBOR decoding of empty logs") { static constexpr std::string_view kEmptyEncodedLogs = "80"; std::vector logs{}; CHECK(cbor_decode(*from_hex(kEmptyEncodedLogs), logs)); } TEST_CASE("CBOR decoding of logs") { static constexpr std::string_view kEncoded = "828354ea674fdde714fd979de3edf0f56aa9716b898ec88043010043835444fd3ab8381cc3d" "14afa7c4af7fd13cdc65026e1825820000000000000000000000000000000000000000000000" "000000000000000dead582000000000000000000000000000000000000000000000000000000" "0000000abba46aabbff780043"; std::vector logs{}; CHECK(cbor_decode(*from_hex(kEncoded), logs)); CHECK(logs.size() == 2); if (logs.size() == 2) { CHECK(logs[0].address == 0xea674fdde714fd979de3edf0f56aa9716b898ec8_address); CHECK(logs[0].topics.empty()); CHECK(logs[0].data == *from_hex("010043")); CHECK(logs[1].address == 0x44fd3ab8381cc3d14afa7c4af7fd13cdc65026e1_address); CHECK(logs[1].topics.size() == 2); if (logs[1].topics.size() == 2) { CHECK(logs[1].topics[0] == 0x000000000000000000000000000000000000000000000000000000000000dead_bytes32); CHECK(logs[1].topics[1] == 0x000000000000000000000000000000000000000000000000000000000000abba_bytes32); } CHECK(logs[1].data == *from_hex("aabbff780043")); } } } // namespace silkworm ================================================ FILE: silkworm/db/mdbx_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include static const std::map kGeneticCode{ {"AAA", "Lysine"}, {"AAC", "Asparagine"}, {"AAG", "Lysine"}, {"AAU", "Asparagine"}, {"ACA", "Threonine"}, {"ACC", "Threonine"}, {"ACG", "Threonine"}, {"ACU", "Threonine"}, {"AGA", "Arginine"}, {"AGC", "Serine"}, {"AGG", "Arginine"}, {"AGU", "Serine"}, {"AUA", "Isoleucine"}, {"AUC", "Isoleucine"}, {"AUG", "Methionine"}, {"AUU", "Isoleucine"}, {"CAA", "Glutamine"}, {"CAC", "Histidine"}, {"CAG", "Glutamine"}, {"CAU", "Histidine"}, {"CCA", "Proline"}, {"CCC", "Proline"}, {"CCG", "Proline"}, {"CCU", "Proline"}, {"CGA", "Arginine"}, {"CGC", "Arginine"}, {"CGG", "Arginine"}, {"CGU", "Arginine"}, {"CUA", "Leucine"}, {"CUC", "Leucine"}, {"CUG", "Leucine"}, {"CUU", "Leucine"}, {"GAA", "Glutamic acid"}, {"GAC", "Aspartic acid"}, {"GAG", "Glutamic acid"}, {"GAU", "Aspartic acid"}, {"GCA", "Alanine"}, {"GCC", "Alanine"}, {"GCG", "Alanine"}, {"GCU", "Alanine"}, {"GGA", "Glycine"}, {"GGC", "Glycine"}, {"GGG", "Glycine"}, {"GGU", "Glycine"}, {"GUA", "Valine"}, {"GUC", "Valine"}, {"GUG", "Valine"}, {"GUU", "Valine"}, {"UAA", "Stop"}, {"UAC", "Tyrosine"}, {"UAG", "Stop"}, {"UAU", "Tyrosine"}, {"UCA", "Serine"}, {"UCC", "Serine"}, {"UCG", "Serine"}, {"UCU", "Serine"}, {"UGA", "Stop"}, {"UGC", "Cysteine"}, {"UGG", "Tryptophan"}, {"UGU", "Cysteine"}, {"UUA", "Leucine"}, {"UUC", "Phenylalanine"}, {"UUG", "Leucine"}, {"UUU", "Phenylalanine"}, }; namespace silkworm::datastore::kvdb { using namespace silkworm::db; TEST_CASE("Environment opening") { SECTION("Default page size on creation") { const TemporaryDirectory tmp_dir; EnvConfig db_config{ .path = tmp_dir.path().string(), .create = true, .in_memory = true, }; REQUIRE(db_config.page_size == os::page_size()); const auto env{open_env(db_config)}; CHECK(env.get_pagesize() == db_config.page_size); } SECTION("Non default page size on creation") { const TemporaryDirectory tmp_dir; EnvConfig db_config{ .path = tmp_dir.path().string(), .create = true, .in_memory = true, .page_size = os::page_size() / 2, }; const auto env{open_env(db_config)}; CHECK(env.get_pagesize() == db_config.page_size); } SECTION("Read page size on opening") { const TemporaryDirectory tmp_dir; { EnvConfig db_config{ .path = tmp_dir.path().string(), .create = true, .in_memory = true, .page_size = os::page_size() / 2, }; (void)open_env(db_config); } { // Try to reopen same db with another page size EnvConfig db_config{ .path = tmp_dir.path().string(), .create = false, .in_memory = true, .page_size = os::page_size() * 2, }; const auto env{open_env(db_config)}; CHECK(env.get_pagesize() == os::page_size() / 2); } } } TEST_CASE("Cursor") { const TemporaryDirectory tmp_dir; EnvConfig db_config{.path = tmp_dir.path().string(), .create = true, .in_memory = true}; auto env{open_env(db_config)}; const MapConfig map_config{"GeneticCode"}; { auto rw_txn{env.start_write()}; CHECK(list_maps(rw_txn).empty()); (void)open_map(rw_txn, map_config); rw_txn.commit(); } auto txn{env.start_read()}; const auto& map_names = list_maps(txn); CHECK(map_names.size() == 1); CHECK(map_names[0] == "GeneticCode"); // A bit of explanation here: // Cursors cache may get polluted by previous tests or is empty // in case this is the only test being executed. So we can't rely // on empty() property rather we must evaluate deltas. size_t original_cache_size{PooledCursor::handles_cache().size()}; { PooledCursor cursor1(txn, map_config); if (original_cache_size) { // One handle pulled from cache REQUIRE(PooledCursor::handles_cache().size() == original_cache_size - 1); } else { // A new handle has been created REQUIRE(PooledCursor::handles_cache().size() == original_cache_size); } REQUIRE(cursor1.get_map_stat().ms_entries == 0); } // After destruction of previous cursor cache has increased by one if it was originally empty, otherwise it is // restored to its original size if (!original_cache_size) { REQUIRE(PooledCursor::handles_cache().size() == original_cache_size + 1); } else { REQUIRE(PooledCursor::handles_cache().size() == original_cache_size); } txn.abort(); txn = env.start_write(); PooledCursor broken(txn, {"Test"}); // Force exceed of cache size std::vector cursors; const size_t new_cache_size = original_cache_size + 5; cursors.reserve(new_cache_size); for (size_t i = 0; i < new_cache_size; ++i) { cursors.emplace_back(txn, map_config); } REQUIRE(PooledCursor::handles_cache().empty() == true); cursors.clear(); REQUIRE(PooledCursor::handles_cache().empty() == false); REQUIRE(PooledCursor::handles_cache().size() == new_cache_size); PooledCursor cursor2(PooledCursor(txn, {"test"})); REQUIRE(cursor2.operator bool() == true); PooledCursor cursor3 = std::move(cursor2); // REQUIRE(cursor2.operator bool() == false); REQUIRE(cursor3.operator bool() == true); txn.commit(); // In another thread cursor cache must be empty std::atomic other_thread_size1{0}; std::atomic other_thread_size2{0}; std::thread t([&other_thread_size1, &other_thread_size2, &env]() { auto thread_txn{env.start_write()}; { PooledCursor cursor(thread_txn, {"Test"}); } other_thread_size1 = PooledCursor::handles_cache().size(); // Pull a handle from the pool and close the cursor directly // so is not returned to the pool PooledCursor cursor(thread_txn, {"Test"}); cursor.close(); other_thread_size2 = PooledCursor::handles_cache().size(); }); t.join(); REQUIRE(other_thread_size1 == 1); REQUIRE(other_thread_size2 == 0); } TEST_CASE("ROAccess/RWAccess ::mdbx::env lifecycle") { const TemporaryDirectory tmp_dir; EnvConfig db_config{.path = tmp_dir.path().string(), .create = true, .in_memory = true}; auto env{open_env(db_config)}; SECTION("ROAccess") { std::unique_ptr access; { // Create ROAccess with env_copy lvalue that gets destroyed immediately after ::mdbx::env env_copy{env}; // NOLINT(cppcoreguidelines-slicing) access = std::make_unique(env_copy); } // env is still alive so using access *must* be safe CHECK(access->operator*().get_path() == env.get_path()); } SECTION("RWAccess") { std::unique_ptr access; { // Create RWAccess with env_copy lvalue that gets destroyed immediately after ::mdbx::env env_copy{env}; // NOLINT(cppcoreguidelines-slicing) access = std::make_unique(env_copy); } // env is still alive so using access *must* be safe CHECK(access->operator*().get_path() == env.get_path()); } } TEST_CASE("RWTxn") { const TemporaryDirectory tmp_dir; EnvConfig db_config{.path = tmp_dir.path().string(), .create = true, .in_memory = true}; auto env{open_env(db_config)}; static constexpr std::string_view kTableName{"GeneticCode"}; SECTION("Managed: commit_and_renew") { { auto tx{RWTxnManaged(env)}; PooledCursor table_cursor(*tx, {kTableName}); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } tx.commit_and_renew(); } auto tx{env.start_read()}; PooledCursor table_cursor(tx, {kTableName}); REQUIRE(table_cursor.empty() == false); } SECTION("Managed: commit_and_stop") { { auto tx{RWTxnManaged(env)}; PooledCursor table_cursor(*tx, {kTableName}); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } tx.commit_and_stop(); } auto tx{env.start_read()}; PooledCursor table_cursor(tx, {kTableName}); REQUIRE(table_cursor.empty() == false); } SECTION("External: commit_and_renew") { RWTxnManaged tx{env}; tx.disable_commit(); { (void)tx->create_map(std::string{kTableName}, mdbx::key_mode::usual, mdbx::value_mode::single); tx.commit_and_renew(); // Does not have any effect } tx.abort(); RWTxnManaged tx2{env}; REQUIRE(has_map(tx2, kTableName) == false); } SECTION("External: commit_and_stop") { RWTxnManaged tx{env}; tx.disable_commit(); { (void)tx->create_map(std::string{kTableName}, mdbx::key_mode::usual, mdbx::value_mode::single); tx.commit_and_stop(); // Does not have any effect } tx.abort(); RWTxnManaged tx2{env}; REQUIRE(has_map(tx2, kTableName) == false); } SECTION("Cursor from RWTxn") { auto tx{RWTxnManaged(env)}; PooledCursor table_cursor(tx, {kTableName}); REQUIRE(table_cursor.empty()); REQUIRE_NOTHROW(table_cursor.bind(tx, {kTableName})); table_cursor.close(); REQUIRE_THROWS(table_cursor.bind(tx, {kTableName})); } SECTION("Unmanaged: commit_and_renew") { { ::MDBX_txn* rw_txn{nullptr}; ::mdbx::error::success_or_throw(::mdbx_txn_begin(env, nullptr, MDBX_TXN_READWRITE, &rw_txn)); auto tx{RWTxnUnmanaged(rw_txn)}; PooledCursor table_cursor(*tx, {kTableName}); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } CHECK_THROWS_AS(tx.commit_and_renew(), std::runtime_error); ::mdbx::error::success_or_throw(::mdbx_txn_commit(rw_txn)); } auto ro_txn{env.start_read()}; PooledCursor cursor(ro_txn, {kTableName}); CHECK(cursor.empty() == false); } SECTION("Unmanaged: commit_and_stop") { { ::MDBX_txn* rw_txn{nullptr}; ::mdbx::error::success_or_throw(::mdbx_txn_begin(env, nullptr, MDBX_TXN_READWRITE, &rw_txn)); auto tx{RWTxnUnmanaged(rw_txn)}; PooledCursor table_cursor(*tx, {kTableName}); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } CHECK_THROWS_AS(tx.commit_and_stop(), std::runtime_error); ::mdbx::error::success_or_throw(::mdbx_txn_commit(rw_txn)); } auto ro_txn{env.start_read()}; PooledCursor cursor(ro_txn, {kTableName}); CHECK(cursor.empty() == false); } } TEST_CASE("Cursor walk") { const TemporaryDirectory tmp_dir; EnvConfig db_config{.path = tmp_dir.path().string(), .create = true, .in_memory = true}; auto env{open_env(db_config)}; auto txn{env.start_write()}; static constexpr std::string_view kTableName{"GeneticCode"}; PooledCursor table_cursor(txn, {kTableName}); // A map to collect data std::map data_map; auto save_all_data_map{[&data_map](ByteView key, ByteView value) { data_map.emplace(byte_view_to_string_view(key), byte_view_to_string_view(value)); }}; // A vector to collect data std::vector> data_vec; auto save_all_data_vec{[&data_vec](ByteView key, ByteView value) { data_vec.emplace_back(byte_view_to_string_view(key), byte_view_to_string_view(value)); }}; SECTION("cursor_for_each") { // empty table cursor_for_each(table_cursor, save_all_data_map); REQUIRE(data_map.empty()); REQUIRE(table_cursor.empty() == true); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } REQUIRE(table_cursor.size() == kGeneticCode.size()); REQUIRE(table_cursor.empty() == false); // Rebind cursor so its position is undefined table_cursor.bind(txn, {kTableName}); REQUIRE(table_cursor.eof() == true); // read entire table forward cursor_for_each(table_cursor, save_all_data_map); CHECK(data_map == kGeneticCode); data_map.clear(); // read entire table backwards table_cursor.bind(txn, {kTableName}); cursor_for_each(table_cursor, save_all_data_map, CursorMoveDirection::kReverse); CHECK(data_map == kGeneticCode); data_map.clear(); // Ensure the order is reversed table_cursor.bind(txn, {kTableName}); cursor_for_each(table_cursor, save_all_data_vec, CursorMoveDirection::kReverse); CHECK(data_vec.back().second == kGeneticCode.at("AAA")); // late start table_cursor.find("UUG"); cursor_for_each(table_cursor, save_all_data_map); REQUIRE(data_map.size() == 2); CHECK(data_map.at("UUG") == "Leucine"); CHECK(data_map.at("UUU") == "Phenylalanine"); data_map.clear(); } SECTION("cursor_erase_prefix") { // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } REQUIRE(table_cursor.size() == kGeneticCode.size()); REQUIRE(table_cursor.empty() == false); // Delete all records starting with "AC" Bytes prefix{}; prefix.append({'A', 'C'}); auto erased{cursor_erase_prefix(table_cursor, prefix)}; REQUIRE(erased == 4); REQUIRE(table_cursor.size() == (kGeneticCode.size() - erased)); } SECTION("cursor_for_prefix") { // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } Bytes prefix{}; prefix.assign({'A', 'A'}); auto count{cursor_for_prefix(table_cursor, prefix, [](ByteView, ByteView) { // do nothing })}; REQUIRE(count == 4); } SECTION("cursor_for_count") { // empty table cursor_for_count(table_cursor, save_all_data_map, /*max_count=*/5); REQUIRE(data_map.empty()); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } // read entire table table_cursor.to_first(); cursor_for_count(table_cursor, save_all_data_map, /*max_count=*/100); CHECK(data_map == kGeneticCode); data_map.clear(); // read some first entries table_cursor.to_first(); cursor_for_count(table_cursor, save_all_data_map, /*max_count=*/5); REQUIRE(data_map.size() == 5); CHECK(data_map.at("AAA") == "Lysine"); CHECK(data_map.at("AAC") == "Asparagine"); CHECK(data_map.at("AAG") == "Lysine"); CHECK(data_map.at("AAU") == "Asparagine"); CHECK(data_map.at("ACA") == "Threonine"); data_map.clear(); // late start table_cursor.find("UUA"); cursor_for_count(table_cursor, save_all_data_map, /*max_count=*/3); REQUIRE(data_map.size() == 3); CHECK(data_map.at("UUA") == "Leucine"); CHECK(data_map.at("UUC") == "Phenylalanine"); CHECK(data_map.at("UUG") == "Leucine"); data_map.clear(); // reverse read table_cursor.to_last(); cursor_for_count(table_cursor, save_all_data_map, /*max_count=*/4, CursorMoveDirection::kReverse); REQUIRE(data_map.size() == 4); CHECK(data_map.at("UUA") == "Leucine"); CHECK(data_map.at("UUC") == "Phenylalanine"); CHECK(data_map.at("UUG") == "Leucine"); CHECK(data_map.at("UUU") == "Phenylalanine"); data_map.clear(); // selective save 1 const auto save_some_data{[&data_map](ByteView key, ByteView value) { if (value != string_view_to_byte_view("Threonine")) { data_map.emplace(byte_view_to_string_view(key), byte_view_to_string_view(value)); } }}; table_cursor.to_first(); cursor_for_count(table_cursor, save_some_data, /*max_count=*/3); REQUIRE(data_map.size() == 3); CHECK(data_map.at("AAA") == "Lysine"); CHECK(data_map.at("AAC") == "Asparagine"); CHECK(data_map.at("AAG") == "Lysine"); data_map.clear(); // selective save 2 table_cursor.to_first(); cursor_for_count(table_cursor, save_some_data, /*max_count=*/5); REQUIRE(data_map.size() == 4); CHECK(data_map.at("AAA") == "Lysine"); CHECK(data_map.at("AAC") == "Asparagine"); CHECK(data_map.at("AAG") == "Lysine"); CHECK(data_map.at("AAU") == "Asparagine"); } SECTION("cursor_erase") { // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } // Erase all records in forward order table_cursor.bind(txn, {kTableName}); cursor_erase(table_cursor, {}); REQUIRE(txn.get_map_stat(table_cursor.map()).ms_entries == 0); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } // Erase all records in reverse order Bytes set_key(3, '\0'); set_key[0] = 'X'; set_key[1] = 'X'; set_key[2] = 'X'; table_cursor.bind(txn, {kTableName}); cursor_erase(table_cursor, set_key, CursorMoveDirection::kReverse); REQUIRE(txn.get_map_stat(table_cursor.map()).ms_entries == 0); // populate table for (const auto& [key, value] : kGeneticCode) { table_cursor.upsert(mdbx::slice{key}, mdbx::slice{value}); } // Erase backwards from "CAA" set_key[0] = 'C'; set_key[1] = 'A'; set_key[2] = 'A'; cursor_erase(table_cursor, set_key, CursorMoveDirection::kReverse); cursor_for_each(table_cursor, save_all_data_map); REQUIRE(data_map.begin()->second == "Glutamine"); // Erase forward from "UAA" set_key[0] = 'U'; set_key[1] = 'A'; set_key[2] = 'A'; cursor_erase(table_cursor, set_key, CursorMoveDirection::kForward); data_map.clear(); cursor_for_each(table_cursor, save_all_data_map); REQUIRE(data_map.rbegin()->second == "Valine"); } } //! Compute the maximum free space in an empty MDBX database page //! \warning this may change in future versions of MDBX //! \details see `page_space` function in MDBX core.c static size_t page_space(const mdbx::env& env) { constexpr size_t kPageHeaderSize{20}; // size of MDBX page header (PAGEHDRSZ) const size_t db_page_size{env.get_pagesize()}; return db_page_size - kPageHeaderSize; } static size_t max_multivalue_size_for_leaf_page(const mdbx::txn& txn) { constexpr size_t kDupSortNodes{2}; constexpr size_t kNodeHeaderSize{8}; // size of MDBX node header (NODESIZE) return page_space(txn.env()) / kDupSortNodes - 2 * kNodeHeaderSize; } TEST_CASE("OF pages") { test_util::TempChainData context; RWTxn& txn = context.rw_txn(); SECTION("Single-value map: No overflow") { PooledCursor target(txn, table::kAccountHistory); Bytes key(20, '\0'); Bytes value(max_value_size_for_leaf_page(*txn, key.size()), '\0'); target.insert(to_slice(key), to_slice(value)); txn.commit_and_renew(); target.bind(txn, table::kAccountHistory); auto stats{target.get_map_stat()}; CHECK(stats.ms_overflow_pages == 0); } SECTION("Single-value map: Let's overflow") { PooledCursor target(txn, table::kAccountHistory); Bytes key(20, '\0'); Bytes value(max_value_size_for_leaf_page(*txn, key.size()) + /*any extra value*/ 1, '\0'); target.insert(to_slice(key), to_slice(value)); txn.commit_and_renew(); target.bind(txn, table::kAccountHistory); auto stats{target.get_map_stat()}; CHECK(stats.ms_overflow_pages > 0); } SECTION("Multi-value map: No overflow, value size OK") { PooledCursor target(txn, table::kPlainState); Bytes key(20, '\0'); Bytes value(max_multivalue_size_for_leaf_page(txn), '\0'); target.insert(to_slice(key), to_slice(value)); txn.commit_and_renew(); target.bind(txn, table::kPlainState); auto stats{target.get_map_stat()}; CHECK(stats.ms_overflow_pages == 0); } // Skip the following section in debug as too big data size in multi-value map will assert #ifdef NDEBUG SECTION("Multi-value map: No overflow, error for value too big") { PooledCursor target(txn, table::kPlainState); Bytes key(20, '\0'); Bytes value(max_multivalue_size_for_leaf_page(txn) + /*any extra value*/ 1, '\0'); CHECK_THROWS_AS(target.insert(to_slice(key), to_slice(value)), ::mdbx::exception); } #endif // NDEBUG } static uint64_t get_free_pages(const ::mdbx::env& env) { uint64_t free_pages{0}; // Use threaded execution because MDBX does not allow overlapping txns in same thread std::async([&]() { constexpr MDBX_dbi kFreeDbi{0}; ::mdbx::map_handle free_map{kFreeDbi}; auto ro_txn{env.start_read()}; auto free_cursor{ro_txn.open_cursor(free_map)}; auto data = free_cursor.to_first(false); while (data.done) { size_t tx_id{0}; std::memcpy(&tx_id, from_slice(data.key).data(), sizeof(size_t)); uint32_t tx_free_pages{0}; std::memcpy(&tx_free_pages, from_slice(data.value).data(), sizeof(uint32_t)); free_pages += tx_free_pages; data = free_cursor.to_next(false); } }).get(); return free_pages; } TEST_CASE("Single-value erase+upsert w/ same value increases free pages") { TemporaryDirectory tmp_dir{}; auto data_directory{std::make_unique(tmp_dir.path(), /*create=*/true)}; EnvConfig env_config{ .path = data_directory->chaindata().path().string(), .create = true, .readonly = false, .exclusive = false, .in_memory = true, }; auto env{open_env(env_config)}; constexpr size_t kKeySize{20}; // just to copycat account address size const Bytes key(kKeySize, '\0'); // Initialize the map content w/ one max-size value [scope needed to limit rw_txn lifecycle] { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 0); REQUIRE(code_stats.ms_depth == 0); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 0); REQUIRE(code_stats.ms_overflow_pages == 0); auto code_cursor{rw_txn.open_cursor(code_map)}; Bytes value(max_value_size_for_leaf_page(rw_txn, key.size()), static_cast(10)); code_cursor.insert(to_slice(key), to_slice(value)); // insert or upsert equivalent here code_stats = rw_txn.get_map_stat(code_map); REQUIRE(code_stats.ms_entries == 1); // we have 1 value here REQUIRE(code_stats.ms_depth == 1); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 1); // we have 1 max data value REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 0); // No free pages after initialization } SECTION("upsert same value does not cause any free page") { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_cursor{rw_txn.open_cursor(code_map)}; auto key_slice{to_slice(key)}; Bytes value(max_value_size_for_leaf_page(rw_txn, key.size()), static_cast(10)); auto value_slice{to_slice(value)}; code_cursor.upsert(key_slice, value_slice); auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 1); REQUIRE(code_stats.ms_depth == 1); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 1); REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 0); // no free page produced } SECTION("erase + upsert same value causes two free pages") { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_cursor{rw_txn.open_cursor(code_map)}; auto key_slice{to_slice(key)}; CHECK(code_cursor.erase(key_slice)); Bytes value(max_value_size_for_leaf_page(rw_txn, key.size()), static_cast(10)); auto value_slice{to_slice(value)}; code_cursor.upsert(key_slice, value_slice); auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 1); REQUIRE(code_stats.ms_depth == 1); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 1); REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); // +2 free pages if we erase+upsert w/ same value => bad pattern } SECTION("upsert different value causes two free pages") { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_cursor{rw_txn.open_cursor(code_map)}; auto key_slice{to_slice(key)}; Bytes value(max_value_size_for_leaf_page(rw_txn, key.size()), static_cast(11)); auto value_slice{to_slice(value)}; code_cursor.upsert(key_slice, value_slice); auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 1); // we have 1 value here since table is single-value REQUIRE(code_stats.ms_depth == 1); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 1); // we have 1 max data value REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); // +2 free pages in any case } SECTION("erase + upsert different value causes two free pages") { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_cursor{rw_txn.open_cursor(code_map)}; auto key_slice{to_slice(key)}; CHECK(code_cursor.erase(key_slice, true)); Bytes value(max_value_size_for_leaf_page(rw_txn, key.size()), static_cast(11)); auto value_slice{to_slice(value)}; code_cursor.upsert(key_slice, value_slice); auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 1); REQUIRE(code_stats.ms_depth == 1); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 1); REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); // +2 free pages in any case } SECTION("erase causes two free pages") { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_cursor{rw_txn.open_cursor(code_map)}; auto key_slice{to_slice(key)}; CHECK(code_cursor.erase(key_slice)); auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 0); REQUIRE(code_stats.ms_depth == 0); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 0); REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); // +2 free pages if we erase } SECTION("erase + upsert same value w/ 2 commits causes two free pages") { { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_cursor{rw_txn.open_cursor(code_map)}; auto key_slice{to_slice(key)}; CHECK(code_cursor.erase(key_slice)); auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 0); REQUIRE(code_stats.ms_depth == 0); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 0); REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); } { auto rw_txn{env.start_write()}; auto code_map{open_map(rw_txn, table::kCode)}; auto code_cursor{rw_txn.open_cursor(code_map)}; auto key_slice{to_slice(key)}; Bytes value(max_value_size_for_leaf_page(rw_txn, key.size()), static_cast(10)); auto value_slice{to_slice(value)}; code_cursor.upsert(key_slice, value_slice); auto code_stats{rw_txn.get_map_stat(code_map)}; REQUIRE(code_stats.ms_entries == 1); REQUIRE(code_stats.ms_depth == 1); REQUIRE(code_stats.ms_branch_pages == 0); REQUIRE(code_stats.ms_leaf_pages == 1); REQUIRE(code_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); } } } TEST_CASE("Multi-value erase+upsert w/ same value increases free pages") { TemporaryDirectory tmp_dir{}; auto data_directory{std::make_unique(tmp_dir.path(), /*create=*/true)}; EnvConfig env_config{ .path = data_directory->chaindata().path().string(), .create = true, .readonly = false, .exclusive = false, .in_memory = true, }; auto env{open_env(env_config)}; // We need to split max multi-value data size between key and value constexpr size_t kKeySize{20}; // just to copycat account address size const size_t max_non_initial_value_size{[&env]() { auto ro_txn{env.start_read()}; return max_multivalue_size_for_leaf_page(ro_txn); }()}; const size_t max_first_value_size{max_non_initial_value_size - kKeySize}; // we need to take key size into account once const Bytes key(kKeySize, '\0'); // Initialize the map content w/ one max-size value [scope needed to limit rw_txn lifecycle] { auto rw_txn{env.start_write()}; auto plain_state_map{open_map(rw_txn, table::kPlainState)}; auto plain_state_stats{rw_txn.get_map_stat(plain_state_map)}; REQUIRE(plain_state_stats.ms_entries == 0); REQUIRE(plain_state_stats.ms_depth == 0); REQUIRE(plain_state_stats.ms_branch_pages == 0); REQUIRE(plain_state_stats.ms_leaf_pages == 0); REQUIRE(plain_state_stats.ms_overflow_pages == 0); auto plain_state_cursor{rw_txn.open_cursor(plain_state_map)}; Bytes value(max_first_value_size, static_cast(10)); plain_state_cursor.insert(to_slice(key), to_slice(value)); // insert or upsert equivalent here plain_state_stats = rw_txn.get_map_stat(plain_state_map); REQUIRE(plain_state_stats.ms_entries == 1); // we have 1 value here REQUIRE(plain_state_stats.ms_depth == 1); REQUIRE(plain_state_stats.ms_branch_pages == 0); REQUIRE(plain_state_stats.ms_leaf_pages == 1); REQUIRE(plain_state_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 0); // No free pages after } SECTION("upsert same value does not cause any free page") { auto rw_txn{env.start_write()}; auto plain_state_map{open_map(rw_txn, table::kPlainState)}; auto plain_state_cursor{rw_txn.open_cursor(plain_state_map)}; auto key_slice{to_slice(key)}; Bytes value(max_first_value_size, static_cast(10)); auto value_slice{to_slice(value)}; plain_state_cursor.upsert(key_slice, value_slice); auto plain_state_stats{rw_txn.get_map_stat(plain_state_map)}; REQUIRE(plain_state_stats.ms_entries == 1); REQUIRE(plain_state_stats.ms_depth == 1); REQUIRE(plain_state_stats.ms_branch_pages == 0); REQUIRE(plain_state_stats.ms_leaf_pages == 1); REQUIRE(plain_state_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 0); // no free page produced } SECTION("erase + upsert same value causes two free pages") { auto rw_txn{env.start_write()}; auto plain_state_map{open_map(rw_txn, table::kPlainState)}; auto plain_state_cursor{rw_txn.open_cursor(plain_state_map)}; auto key_slice{to_slice(key)}; CHECK(plain_state_cursor.erase(key_slice, /*whole_multivalue=*/true)); Bytes value(max_first_value_size, static_cast(10)); auto value_slice{to_slice(value)}; plain_state_cursor.upsert(key_slice, value_slice); auto plain_state_stats{rw_txn.get_map_stat(plain_state_map)}; REQUIRE(plain_state_stats.ms_entries == 1); REQUIRE(plain_state_stats.ms_depth == 1); REQUIRE(plain_state_stats.ms_branch_pages == 0); REQUIRE(plain_state_stats.ms_leaf_pages == 1); REQUIRE(plain_state_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); // +2 free pages if we erase+upsert w/ same value => bad pattern } SECTION("upsert different value causes two free pages") { auto rw_txn{env.start_write()}; auto plain_state_map{open_map(rw_txn, table::kPlainState)}; auto plain_state_cursor{rw_txn.open_cursor(plain_state_map)}; auto key_slice{to_slice(key)}; Bytes value(max_non_initial_value_size, static_cast(11)); auto value_slice{to_slice(value)}; plain_state_cursor.upsert(key_slice, value_slice); auto plain_state_stats{rw_txn.get_map_stat(plain_state_map)}; REQUIRE(plain_state_stats.ms_entries == 2); // we have 2 values here since table is multi-value REQUIRE(plain_state_stats.ms_depth == 1); REQUIRE(plain_state_stats.ms_branch_pages == 0); REQUIRE(plain_state_stats.ms_leaf_pages == 2); // we have 2 max data values hence we need 2 pages REQUIRE(plain_state_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); // +2 free pages in any case } SECTION("erase + upsert different value causes two free pages") { auto rw_txn{env.start_write()}; auto plain_state_map{open_map(rw_txn, table::kPlainState)}; auto plain_state_cursor{rw_txn.open_cursor(plain_state_map)}; auto key_slice{to_slice(key)}; CHECK(plain_state_cursor.erase(key_slice, /*whole_multivalue=*/true)); Bytes value(max_first_value_size, static_cast(11)); auto value_slice{to_slice(value)}; plain_state_cursor.upsert(key_slice, value_slice); auto plain_state_stats{rw_txn.get_map_stat(plain_state_map)}; REQUIRE(plain_state_stats.ms_entries == 1); REQUIRE(plain_state_stats.ms_depth == 1); REQUIRE(plain_state_stats.ms_branch_pages == 0); REQUIRE(plain_state_stats.ms_leaf_pages == 1); REQUIRE(plain_state_stats.ms_overflow_pages == 0); rw_txn.commit(); CHECK(get_free_pages(env) == 2); // +2 free pages in any case } } } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/memory_mutation_cursor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include namespace silkworm::datastore::kvdb { using namespace silkworm::db; static mdbx::env_managed create_main_env(EnvConfig& main_db_config) { auto main_env = open_env(main_db_config); RWTxnManaged main_txn{main_env}; table::check_or_create_chaindata_tables(main_txn); open_map(main_txn, table::kCode); open_map(main_txn, table::kAccountChangeSet); main_txn.commit_and_stop(); return main_env; } static void fill_tables(RWTxn& rw_txn) { auto rw_cursor1{rw_txn.rw_cursor(table::kCode)}; rw_cursor1->upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor1->upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); auto rw_cursor2{rw_txn.rw_cursor(table::kAccountChangeSet)}; rw_cursor2->upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor2->upsert(mdbx::slice{"AA"}, mdbx::slice{"11"}); rw_cursor2->upsert(mdbx::slice{"AA"}, mdbx::slice{"22"}); rw_cursor2->upsert(mdbx::slice{"BB"}, mdbx::slice{"22"}); rw_txn.commit_and_renew(); } static void alter_tables(RWTxn& rw_txn) { auto rw_cursor1{rw_txn.rw_cursor(table::kCode)}; rw_cursor1->upsert(mdbx::slice{"CC"}, mdbx::slice{"22"}); auto rw_cursor2{rw_txn.rw_cursor(table::kAccountChangeSet)}; rw_cursor2->upsert(mdbx::slice{"AA"}, mdbx::slice{"33"}); rw_cursor2->upsert(mdbx::slice{"BB"}, mdbx::slice{"33"}); rw_txn.commit_and_renew(); } class MemoryMutationCursorTest { public: explicit MemoryMutationCursorTest() { open_map(mutation, table::kCode); open_map(mutation, table::kAccountChangeSet); mutation.commit_and_renew(); } void fill_main_tables() { fill_tables(main_txn); } void fill_mutation_tables() { fill_tables(mutation); } void alter_main_tables() { alter_tables(main_txn); } void alter_mutation_tables() { alter_tables(mutation); } const TemporaryDirectory tmp_dir; DataDirectory data_dir{tmp_dir.path() / "main_db", true}; EnvConfig main_db_config{ .path = data_dir.chaindata().path().string(), .create = true, .in_memory = true, }; mdbx::env_managed main_env{create_main_env(main_db_config)}; RWTxnManaged main_txn{main_env}; MemoryOverlay overlay{tmp_dir.path(), &main_txn, table::get_map_config, table::kSequenceName}; MemoryMutation mutation{overlay}; }; // Skip in TSAN build due to false positive lock-order-inversion: https://github.com/google/sanitizers/issues/814 #ifndef SILKWORM_SANITIZE static const MapConfig kNonexistentTestMap{"NonexistentTable"}; static const MapConfig kNonexistentTestMultiMap{"NonexistentMultiTable", mdbx::key_mode::usual, mdbx::value_mode::multi}; TEST_CASE("MemoryMutationCursor: initialization", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); SECTION("Empty overlay: Create memory mutation cursor") { // Nonexistent tables CHECK_NOTHROW(MemoryMutationCursor{test1.mutation, kNonexistentTestMap}); CHECK_NOTHROW(MemoryMutationCursor{test1.mutation, kNonexistentTestMultiMap}); // Existent tables CHECK_NOTHROW(MemoryMutationCursor{test1.mutation, table::kCode}); CHECK_NOTHROW(MemoryMutationCursor{test1.mutation, table::kAccountChangeSet}); // Check initial state MemoryMutationCursor mutation_cursor1{test1.mutation, table::kCode}; CHECK(mutation_cursor1.size() == 2); CHECK(!mutation_cursor1.empty()); CHECK(!mutation_cursor1.is_table_cleared()); CHECK(!mutation_cursor1.is_entry_deleted(Slice{}, Slice{})); MemoryMutationCursor mutation_cursor2{test1.mutation, table::kAccountChangeSet}; CHECK(mutation_cursor2.size() == 4); CHECK(!mutation_cursor2.empty()); CHECK(!mutation_cursor2.is_table_cleared()); CHECK(!mutation_cursor2.is_entry_deleted(Slice{}, Slice{})); // Create many cursors std::vector> memory_cursors; for (int i{0}; i < 10; ++i) { CHECK_NOTHROW(memory_cursors.emplace_back(std::make_unique(test1.mutation, table::kCode))); CHECK_NOTHROW(memory_cursors.emplace_back(std::make_unique(test1.mutation, table::kAccountChangeSet))); } // Check predefined tables for (const auto& table : table::kChainDataTables) { MemoryMutationCursor mutation_cursor{test1.mutation, table}; CHECK(has_map(test1.mutation, table.name)); CHECK(!mutation_cursor.is_table_cleared()); CHECK(!mutation_cursor.is_entry_deleted(Slice{}, Slice{})); } } MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); SECTION("Nonempty overlay: Check tables") { for (const auto& table : {table::kCode, table::kAccountChangeSet}) { MemoryMutationCursor mutation_cursor{test2.mutation, table}; CHECK_NOTHROW(mutation_cursor.to_first()); CHECK_NOTHROW(!mutation_cursor.is_table_cleared()); CHECK_NOTHROW(!mutation_cursor.is_entry_deleted(Slice{}, Slice{})); } } } TEST_CASE("MemoryMutationCursor: to_first", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": to_first on nonexistent table: MDBX_NOTFOUND") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.to_first(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor1.to_first(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor1.to_first(/*throw_notfound=*/false)); MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.to_first(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor2.to_first(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.to_first(/*throw_notfound=*/false)); } SECTION(tag + ": to_first on existent table") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; const auto result1 = mutation_cursor1.to_first(); CHECK(result1.done); CHECK(result1.key == "AA"); CHECK(result1.value == "00"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kCode}; const auto result2 = mutation_cursor2.to_first(/*throw_notfound=*/true); CHECK(result2.done); CHECK(result2.key == "AA"); CHECK(result2.value == "00"); MemoryMutationCursor mutation_cursor3{test->mutation, table::kCode}; const auto result3 = mutation_cursor3.to_first(/*throw_notfound=*/false); CHECK(result3.done); CHECK(result3.key == "AA"); CHECK(result3.value == "00"); MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; const auto result4 = mutation_cursor4.to_first(); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "00"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; const auto result5 = mutation_cursor5.to_first(/*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "00"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; const auto result6 = mutation_cursor6.to_first(/*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "00"); } SECTION(tag + ": to_first operation is idempotent") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; const auto result1 = mutation_cursor1.to_first(); CHECK(result1.done); CHECK(result1.key == "AA"); CHECK(result1.value == "00"); const auto result2 = mutation_cursor1.to_first(); CHECK(result2.done); CHECK(result2.key == "AA"); CHECK(result2.value == "00"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kAccountChangeSet}; const auto result3 = mutation_cursor2.to_first(); CHECK(result3.done); CHECK(result3.key == "AA"); CHECK(result3.value == "00"); const auto result4 = mutation_cursor2.to_first(); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "00"); } } } TEST_CASE("MemoryMutationCursor: to_previous", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": to_previous on nonexistent table: MDBX_NOTFOUND") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.to_previous(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor1.to_previous(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor1.to_previous(/*throw_notfound=*/false)); MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.to_previous(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor2.to_previous(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.to_previous(/*throw_notfound=*/false)); } SECTION(tag + ": to_previous on existent table w/ positioning: OK") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_last()); const auto result1 = mutation_cursor1.to_previous(); CHECK(result1.done); CHECK(result1.key == "AA"); CHECK(result1.value == "00"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kCode}; REQUIRE(mutation_cursor2.to_last()); const auto result2 = mutation_cursor2.to_previous(/*throw_notfound=*/true); CHECK(result2.done); CHECK(result2.key == "AA"); CHECK(result2.value == "00"); MemoryMutationCursor mutation_cursor3{test->mutation, table::kCode}; REQUIRE(mutation_cursor3.to_last()); const auto result3 = mutation_cursor3.to_previous(/*throw_notfound=*/false); CHECK(result3.done); CHECK(result3.key == "AA"); CHECK(result3.value == "00"); MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor4.to_last()); const auto result4 = mutation_cursor4.to_previous(); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "22"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor5.to_last()); const auto result5 = mutation_cursor5.to_previous(/*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "22"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor6.to_last()); const auto result6 = mutation_cursor6.to_previous(/*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "22"); } SECTION(tag + ": to_previous multiple operations") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_last(/*throw_notfound=*/false)); const auto result1 = mutation_cursor1.to_previous(/*throw_notfound=*/false); CHECK(result1.done); CHECK(result1.key == "AA"); CHECK(result1.value == "00"); const auto result2 = mutation_cursor1.to_previous(/*throw_notfound=*/false); CHECK(!result2.done); REQUIRE(mutation_cursor1.to_first(/*throw_notfound=*/false)); const auto result3 = mutation_cursor1.to_previous(/*throw_notfound=*/false); CHECK(!result3.done); MemoryMutationCursor mutation_cursor2{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor2.to_last(/*throw_notfound=*/false)); const auto result4 = mutation_cursor2.to_previous(/*throw_notfound=*/false); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "22"); const auto result5 = mutation_cursor2.to_previous(/*throw_notfound=*/false); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "11"); REQUIRE(mutation_cursor2.to_first(/*throw_notfound=*/false)); const auto result6 = mutation_cursor2.to_previous(/*throw_notfound=*/false); CHECK(!result6.done); } } } TEST_CASE("MemoryMutationCursor: to_next", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": to_next on nonexistent table: MDBX_NOTFOUND") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.to_next(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor1.to_next(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor1.to_next(/*throw_notfound=*/false)); MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.to_next(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor2.to_next(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.to_next(/*throw_notfound=*/false)); } SECTION(tag + ": to_next on existent table w/ positioning: OK") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_first()); const auto result1 = mutation_cursor1.to_next(); CHECK(result1.done); CHECK(result1.key == "BB"); CHECK(result1.value == "11"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kCode}; REQUIRE(mutation_cursor2.to_first()); const auto result2 = mutation_cursor2.to_next(/*throw_notfound=*/true); CHECK(result2.done); CHECK(result2.key == "BB"); CHECK(result2.value == "11"); MemoryMutationCursor mutation_cursor3{test->mutation, table::kCode}; REQUIRE(mutation_cursor3.to_first()); const auto result3 = mutation_cursor3.to_next(/*throw_notfound=*/false); CHECK(result3.done); CHECK(result3.key == "BB"); CHECK(result3.value == "11"); MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor4.to_first()); const auto result4 = mutation_cursor4.to_next(); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "11"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor5.to_first()); const auto result5 = mutation_cursor5.to_next(/*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "11"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor6.to_first()); const auto result6 = mutation_cursor6.to_next(/*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "11"); } SECTION(tag + ": to_next multiple operations") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_first(/*throw_notfound=*/false)); const auto result1 = mutation_cursor1.to_next(/*throw_notfound=*/false); CHECK(result1.done); CHECK(result1.key == "BB"); CHECK(result1.value == "11"); } } } TEST_CASE("MemoryMutationCursor: to_current_next_multi", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": to_current_next_multi on nonexistent table: MDBX_NOTFOUND") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.to_current_next_multi(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor1.to_current_next_multi(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor1.to_current_next_multi(/*throw_notfound=*/false)); MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.to_current_next_multi(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor2.to_current_next_multi(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.to_current_next_multi(/*throw_notfound=*/false)); } SECTION(tag + ": to_current_next_multi on existent table w/ positioning: OK") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_first()); const auto result1 = mutation_cursor1.to_current_next_multi(); CHECK(result1.done); CHECK(result1.key == "BB"); CHECK(result1.value == "11"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kCode}; REQUIRE(mutation_cursor2.to_first()); const auto result2 = mutation_cursor2.to_current_next_multi(/*throw_notfound=*/true); CHECK(result2.done); CHECK(result2.key == "BB"); CHECK(result2.value == "11"); MemoryMutationCursor mutation_cursor3{test->mutation, table::kCode}; REQUIRE(mutation_cursor3.to_first()); const auto result3 = mutation_cursor3.to_current_next_multi(/*throw_notfound=*/false); CHECK(result3.done); CHECK(result3.key == "BB"); CHECK(result3.value == "11"); MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor4.to_first()); const auto result4 = mutation_cursor4.to_current_next_multi(); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "11"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor5.to_first()); const auto result5 = mutation_cursor5.to_current_next_multi(/*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "11"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor6.to_first()); const auto result6 = mutation_cursor6.to_current_next_multi(/*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "11"); } SECTION(tag + ": to_current_next_multi multiple operations") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_first(/*throw_notfound=*/false)); const auto result1 = mutation_cursor1.to_current_next_multi(/*throw_notfound=*/false); CHECK(result1.done); CHECK(result1.key == "BB"); CHECK(result1.value == "11"); const auto result2 = mutation_cursor1.to_current_next_multi(/*throw_notfound=*/false); CHECK(!result2.done); REQUIRE(mutation_cursor1.to_last(/*throw_notfound=*/false)); const auto result3 = mutation_cursor1.to_current_next_multi(/*throw_notfound=*/false); CHECK(!result3.done); MemoryMutationCursor mutation_cursor2{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor2.to_first(/*throw_notfound=*/false)); const auto result4 = mutation_cursor2.to_current_next_multi(/*throw_notfound=*/false); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "11"); const auto result5 = mutation_cursor2.to_current_next_multi(/*throw_notfound=*/false); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "22"); const auto result6 = mutation_cursor2.to_current_next_multi(/*throw_notfound=*/false); CHECK(!result6.done); REQUIRE(mutation_cursor2.to_last(/*throw_notfound=*/false)); const auto result7 = mutation_cursor2.to_current_next_multi(/*throw_notfound=*/false); CHECK(!result7.done); } } } TEST_CASE("MemoryMutationCursor: to_last", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": to_last on nonexistent table: MDBX_NOTFOUND") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.to_last(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor1.to_last(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor1.to_last(/*throw_notfound=*/false)); MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.to_last(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor2.to_last(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.to_last(/*throw_notfound=*/false)); } SECTION(tag + ": to_last on existent table: OK") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; const auto result1 = mutation_cursor1.to_last(); CHECK(result1.done); CHECK(result1.key == "BB"); CHECK(result1.value == "11"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kCode}; const auto result2 = mutation_cursor2.to_last(/*throw_notfound=*/true); CHECK(result2.done); CHECK(result2.key == "BB"); CHECK(result2.value == "11"); MemoryMutationCursor mutation_cursor3{test->mutation, table::kCode}; const auto result3 = mutation_cursor3.to_last(/*throw_notfound=*/false); CHECK(result3.done); CHECK(result3.key == "BB"); CHECK(result3.value == "11"); MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; const auto result4 = mutation_cursor4.to_last(); CHECK(result4.done); CHECK(result4.key == "BB"); CHECK(result4.value == "22"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; const auto result5 = mutation_cursor5.to_last(/*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "BB"); CHECK(result5.value == "22"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; const auto result6 = mutation_cursor6.to_last(/*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "BB"); CHECK(result6.value == "22"); } SECTION(tag + ": to_last operation is idempotent") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; const auto result1 = mutation_cursor1.to_last(); CHECK(result1.done); CHECK(result1.key == "BB"); CHECK(result1.value == "11"); const auto result2 = mutation_cursor1.to_last(); CHECK(result2.done); CHECK(result2.key == "BB"); CHECK(result2.value == "11"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kAccountChangeSet}; const auto result3 = mutation_cursor2.to_last(); CHECK(result3.done); CHECK(result3.key == "BB"); CHECK(result3.value == "22"); const auto result4 = mutation_cursor2.to_last(); CHECK(result4.done); CHECK(result4.key == "BB"); CHECK(result4.value == "22"); } } } TEST_CASE("MemoryMutationCursor: current", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": current on nonexistent table: MDBX_NOTFOUND") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.current(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor1.current(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor1.current(/*throw_notfound=*/false)); MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.current(), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor2.current(/*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.current(/*throw_notfound=*/false)); } SECTION(tag + ": current on existent table w/ positioning: OK") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_first()); const auto result1 = mutation_cursor1.current(); CHECK(result1.done); CHECK(result1.key == "AA"); CHECK(result1.value == "00"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kCode}; REQUIRE(mutation_cursor2.to_first()); const auto result2 = mutation_cursor2.current(/*throw_notfound=*/true); CHECK(result2.done); CHECK(result2.key == "AA"); CHECK(result2.value == "00"); MemoryMutationCursor mutation_cursor3{test->mutation, table::kCode}; REQUIRE(mutation_cursor3.to_first()); const auto result3 = mutation_cursor3.current(/*throw_notfound=*/false); CHECK(result3.done); CHECK(result3.key == "AA"); CHECK(result3.value == "00"); MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor4.to_first()); const auto result4 = mutation_cursor4.current(); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "00"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor5.to_first()); const auto result5 = mutation_cursor5.current(/*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "00"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor6.to_first()); const auto result6 = mutation_cursor6.current(/*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "00"); } SECTION(tag + ": current operation is idempotent") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; REQUIRE(mutation_cursor1.to_first()); const auto result1 = mutation_cursor1.current(); CHECK(result1.done); CHECK(result1.key == "AA"); CHECK(result1.value == "00"); const auto result2 = mutation_cursor1.current(); CHECK(result2.done); CHECK(result2.key == "AA"); CHECK(result2.value == "00"); REQUIRE(mutation_cursor1.to_last()); const auto result3 = mutation_cursor1.current(); CHECK(result3.done); CHECK(result3.key == "BB"); CHECK(result3.value == "11"); const auto result4 = mutation_cursor1.current(); CHECK(result4.done); CHECK(result4.key == "BB"); CHECK(result4.value == "11"); MemoryMutationCursor mutation_cursor2{test->mutation, table::kAccountChangeSet}; REQUIRE(mutation_cursor2.to_first()); const auto result5 = mutation_cursor2.current(); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "00"); const auto result6 = mutation_cursor2.current(); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "00"); REQUIRE(mutation_cursor2.to_last()); const auto result7 = mutation_cursor2.current(); CHECK(result7.done); CHECK(result7.key == "BB"); CHECK(result7.value == "22"); const auto result8 = mutation_cursor2.current(); CHECK(result8.done); CHECK(result8.key == "BB"); CHECK(result8.value == "22"); } } } TEST_CASE("MemoryMutationCursor: seek", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": seek on nonexistent table: MDBX_NOTFOUND") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK(!mutation_cursor1.seek("k")); MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK(!mutation_cursor2.seek("k")); } SECTION(tag + ": seek on existent non-empty table: OK") { // Single-value table MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; CHECK(mutation_cursor1.seek("AA")); // existent key (seek saves value in current) const auto result1 = mutation_cursor1.current(); CHECK(result1.done); CHECK(result1.key == "AA"); CHECK(result1.value == "00"); CHECK(mutation_cursor1.seek("BB")); // existent key (seek saves value in current) const auto result2 = mutation_cursor1.current(); CHECK(result2.done); CHECK(result2.key == "BB"); CHECK(result2.value == "11"); CHECK(!mutation_cursor1.seek("CC")); // nonexistent key // Multi-value table MemoryMutationCursor mutation_cursor2{test->mutation, table::kAccountChangeSet}; CHECK(mutation_cursor2.seek("AA")); // existent key (seek saves value in current) const auto result3 = mutation_cursor2.current(); CHECK(result3.done); CHECK(result3.key == "AA"); CHECK(result3.value == "00"); CHECK(mutation_cursor2.seek("BB")); // existent key (seek saves value in current) const auto result4 = mutation_cursor2.current(); CHECK(result4.done); CHECK(result4.key == "BB"); CHECK(result4.value == "22"); } } test1.alter_main_tables(); test2.alter_mutation_tables(); for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": seek after alter: OK") { // Single-value table MemoryMutationCursor mutation_cursor1{test2.mutation, table::kCode}; CHECK(mutation_cursor1.seek("AA")); // existent key CHECK(mutation_cursor1.seek("BB")); // existent key CHECK(mutation_cursor1.seek("CC")); // existent key // Multi-value table MemoryMutationCursor mutation_cursor2{test2.mutation, table::kAccountChangeSet}; CHECK(mutation_cursor2.seek("AA")); // existent key CHECK(mutation_cursor2.seek("BB")); // existent key } } } TEST_CASE("MemoryMutationCursor: lower_bound", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": lower_bound on nonexistent single-value table: mdbx::incompatible_operation") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.lower_bound("k", /*throw_notfound=*/true), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor1.lower_bound("k"), mdbx::not_found); } SECTION(tag + ": lower_bound on nonexistent multi-value table: mdbx::not_found") { MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.lower_bound("k"), mdbx::not_found); CHECK_THROWS_AS(mutation_cursor2.lower_bound("k", /*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.lower_bound("k", /*throw_notfound=*/false)); } SECTION(tag + ": lower_bound on existent multi-value table: OK") { MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; const auto result4 = mutation_cursor4.lower_bound("AA"); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "00"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; const auto result5 = mutation_cursor5.lower_bound("AA", /*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "00"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; const auto result6 = mutation_cursor6.lower_bound("AA", /*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "00"); } SECTION(tag + ": lower_bound multiple operations") { MemoryMutationCursor mutation_cursor{test->mutation, table::kAccountChangeSet}; const auto result4 = mutation_cursor.lower_bound("AA"); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "00"); const auto result5 = mutation_cursor.lower_bound("AA"); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "00"); REQUIRE(mutation_cursor.to_last(/*throw_notfound=*/false)); const auto result6 = mutation_cursor.lower_bound("AA"); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "00"); } } } TEST_CASE("MemoryMutationCursor: lower_bound_multivalue", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; test1.fill_main_tables(); MemoryMutationCursorTest test2; test2.fill_main_tables(); test2.fill_mutation_tables(); std::map mutation_tests = { {"Empty overlay", &test1}, {"Nonempty overlay", &test2}, }; for (const auto& [tag, test] : mutation_tests) { SECTION(tag + ": lower_bound_multivalue on nonexistent single-value table: mdbx::incompatible_operation") { MemoryMutationCursor mutation_cursor1{test->mutation, kNonexistentTestMap}; CHECK_THROWS_AS(mutation_cursor1.lower_bound_multivalue("k", "v", /*throw_notfound=*/true), mdbx::incompatible_operation); CHECK_THROWS_AS(mutation_cursor1.lower_bound_multivalue("k", "v"), mdbx::incompatible_operation); } SECTION(tag + ": lower_bound_multivalue on nonexistent multi-value table: mdbx::not_found") { MemoryMutationCursor mutation_cursor2{test->mutation, kNonexistentTestMultiMap}; CHECK_THROWS_AS(mutation_cursor2.lower_bound_multivalue("k", "v", /*throw_notfound=*/true), mdbx::not_found); CHECK(!mutation_cursor2.lower_bound_multivalue("k", "v", /*throw_notfound=*/false)); CHECK(!mutation_cursor2.lower_bound_multivalue("k", "v")); } SECTION(tag + ": lower_bound_multivalue on existent multi-value table: OK") { MemoryMutationCursor mutation_cursor1{test->mutation, table::kCode}; CHECK_THROWS_AS(mutation_cursor1.lower_bound_multivalue("BB", "11"), mdbx::incompatible_operation); MemoryMutationCursor mutation_cursor4{test->mutation, table::kAccountChangeSet}; const auto result4 = mutation_cursor4.lower_bound_multivalue("AA", "11"); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "11"); MemoryMutationCursor mutation_cursor5{test->mutation, table::kAccountChangeSet}; const auto result5 = mutation_cursor5.lower_bound_multivalue("AA", "11", /*throw_notfound=*/true); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "11"); MemoryMutationCursor mutation_cursor6{test->mutation, table::kAccountChangeSet}; const auto result6 = mutation_cursor6.lower_bound_multivalue("AA", "11", /*throw_notfound=*/false); CHECK(result6.done); CHECK(result6.key == "AA"); CHECK(result6.value == "11"); } SECTION(tag + ": lower_bound_multivalue multiple operations") { MemoryMutationCursor mutation_cursor{test->mutation, table::kAccountChangeSet}; const auto result4 = mutation_cursor.lower_bound_multivalue("AA", "11"); CHECK(result4.done); CHECK(result4.key == "AA"); CHECK(result4.value == "11"); const auto result5 = mutation_cursor.lower_bound_multivalue("AA", "22"); CHECK(result5.done); CHECK(result5.key == "AA"); CHECK(result5.value == "22"); REQUIRE(mutation_cursor.to_last(/*throw_notfound=*/false)); const auto result6 = mutation_cursor.lower_bound_multivalue("AA", "33"); CHECK(!result6.done); } } } TEST_CASE("MemoryMutationCursor: Previous mem->db after find", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; auto rw_db_cursor = test.main_txn.rw_cursor(table::kCode); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1"}); rw_db_cursor->upsert(mdbx::slice{"key2"}, mdbx::slice{"value2"}); test.main_txn.commit_and_renew(); auto rw_mem_cursor = test.mutation.rw_cursor(table::kCode); rw_mem_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3"}); auto db_cursor = test.main_txn.ro_cursor(table::kCode); auto mem_cursor = test.mutation.ro_cursor(table::kCode); auto db_result = db_cursor->find("key3", /*throw_notfound=*/false); CHECK(!db_result.done); auto mem_result = mem_cursor->find("key3", /*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3"); mem_result = mem_cursor->to_previous(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key2"); CHECK(mem_result.value == "value2"); mem_result = mem_cursor->to_previous(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1"); mem_result = mem_cursor->to_previous(/*throw_notfound=*/false); CHECK(!mem_result.done); } TEST_CASE("MemoryMutationCursor: Next db->mem after find", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; auto rw_db_cursor = test.main_txn.rw_cursor(table::kCode); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1"}); rw_db_cursor->upsert(mdbx::slice{"key2"}, mdbx::slice{"value2"}); test.main_txn.commit_and_renew(); auto rw_mem_cursor = test.mutation.rw_cursor(table::kCode); rw_mem_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3"}); auto db_cursor = test.main_txn.ro_cursor(table::kCode); auto mem_cursor = test.mutation.ro_cursor(table::kCode); auto db_result = db_cursor->find("key1", /*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key1"); CHECK(db_result.value == "value1"); auto mem_result = mem_cursor->find("key1", /*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1"); db_result = db_cursor->to_next(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key2"); CHECK(db_result.value == "value2"); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key2"); CHECK(mem_result.value == "value2"); db_result = db_cursor->to_next(/*throw_notfound=*/false); CHECK(!db_result.done); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3"); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(!mem_result.done); } TEST_CASE("MemoryMutationCursor: CursorDupSort Next db->mem->db", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; auto rw_db_cursor = test.main_txn.rw_cursor_dup_sort(table::kAccountChangeSet); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.1"}); rw_db_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.1"}); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.3"}); rw_db_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.3"}); test.main_txn.commit_and_renew(); auto rw_mem_cursor = test.mutation.rw_cursor_dup_sort(table::kAccountChangeSet); rw_mem_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.2"}); auto db_cursor = test.main_txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto mem_cursor = test.mutation.ro_cursor_dup_sort(table::kAccountChangeSet); auto db_result = db_cursor->to_first(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key1"); CHECK(db_result.value == "value1.1"); auto mem_result = mem_cursor->to_first(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1.1"); db_result = db_cursor->to_next(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key1"); CHECK(db_result.value == "value1.3"); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1.2"); db_result = db_cursor->to_next(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key3"); CHECK(db_result.value == "value3.1"); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1.3"); db_result = db_cursor->to_next(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key3"); CHECK(db_result.value == "value3.3"); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3.1"); db_result = db_cursor->to_next(/*throw_notfound=*/false); CHECK(!db_result.done); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3.3"); mem_result = mem_cursor->to_next(/*throw_notfound=*/false); CHECK(!mem_result.done); } TEST_CASE("MemoryMutationCursor: NextDup db->mem->db", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; auto rw_db_cursor = test.main_txn.rw_cursor_dup_sort(table::kAccountChangeSet); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.1"}); rw_db_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.1"}); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.3"}); rw_db_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.3"}); test.main_txn.commit_and_renew(); auto rw_mem_cursor = test.mutation.rw_cursor_dup_sort(table::kAccountChangeSet); rw_mem_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.2"}); test.mutation.commit_and_renew(); auto db_cursor = test.main_txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto mem_cursor = test.mutation.ro_cursor_dup_sort(table::kAccountChangeSet); auto db_result = db_cursor->to_first(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key1"); CHECK(db_result.value == "value1.1"); auto mem_result = mem_cursor->to_first(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1.1"); db_result = db_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key1"); CHECK(db_result.value == "value1.3"); mem_result = mem_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1.2"); db_result = db_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(!db_result.done); mem_result = mem_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key1"); CHECK(mem_result.value == "value1.3"); db_result = db_cursor->to_next_first_multi(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key3"); CHECK(db_result.value == "value3.1"); mem_result = mem_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(!mem_result.done); db_result = db_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key3"); CHECK(db_result.value == "value3.3"); mem_result = mem_cursor->to_next_first_multi(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3.1"); db_result = db_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(!db_result.done); mem_result = mem_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3.3"); mem_result = mem_cursor->to_current_next_multi(/*throw_notfound=*/false); CHECK(!mem_result.done); } TEST_CASE("MemoryMutationCursor: SeekBothExact db->mem->db->mem", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; auto rw_db_cursor = test.main_txn.rw_cursor_dup_sort(table::kAccountChangeSet); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.1"}); rw_db_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.3"}); test.main_txn.commit_and_renew(); auto rw_mem_cursor = test.mutation.rw_cursor_dup_sort(table::kAccountChangeSet); rw_mem_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.1"}); rw_mem_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.3"}); test.mutation.commit_and_renew(); auto db_cursor = test.main_txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto mem_cursor = test.mutation.ro_cursor_dup_sort(table::kAccountChangeSet); auto db_result = db_cursor->find_multivalue("key2", "value1.2", /*throw_notfound=*/false); CHECK(!db_result.done); auto mem_result = mem_cursor->find_multivalue("key2", "value1.2", /*throw_notfound=*/false); CHECK(!mem_result.done); db_result = db_cursor->find_multivalue("key3", "value3.1", /*throw_notfound=*/false); CHECK(!db_result.done); mem_result = mem_cursor->find_multivalue("key3", "value3.1", /*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3.1"); db_result = db_cursor->find_multivalue("key3", "value3.2", /*throw_notfound=*/false); CHECK(!db_result.done); mem_result = mem_cursor->find_multivalue("key3", "value3.2", /*throw_notfound=*/false); CHECK(!mem_result.done); db_result = db_cursor->find_multivalue("key3", "value3.3", /*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "key3"); CHECK(db_result.value == "value3.3"); mem_result = mem_cursor->find_multivalue("key3", "value3.3", /*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3.3"); } TEST_CASE("MemoryMutationCursor: SeekBothRange db->mem->db->mem", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; auto rw_db_cursor = test.main_txn.rw_cursor_dup_sort(table::kAccountChangeSet); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.1"}); rw_db_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.3"}); test.main_txn.commit_and_renew(); auto rw_mem_cursor = test.mutation.rw_cursor_dup_sort(table::kAccountChangeSet); rw_mem_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.1"}); rw_mem_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.3"}); test.mutation.commit_and_renew(); auto db_cursor = test.main_txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto mem_cursor = test.mutation.ro_cursor_dup_sort(table::kAccountChangeSet); // SeekBothRange does exact match of the key, so we find nothing here auto db_result = db_cursor->lower_bound_multivalue("key2", "value1.2"); CHECK(!db_result.done); auto mem_result = mem_cursor->lower_bound_multivalue("key2", "value1.2"); CHECK(!mem_result.done); // SeekBothRange does exact match of the key and range match of the value, so we get last value db_result = db_cursor->lower_bound_multivalue("key3", "value3.2"); CHECK(db_result.done); CHECK(db_result.key == "key3"); CHECK(db_result.value == "value3.3"); mem_result = mem_cursor->lower_bound_multivalue("key3", "value3.2"); CHECK(mem_result.done); CHECK(mem_result.key == "key3"); CHECK(mem_result.value == "value3.3"); } TEST_CASE("MemoryMutationCursor: Delete db->mem->db->mem", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; auto rw_db_cursor = test.main_txn.rw_cursor_dup_sort(table::kHashedAccounts); rw_db_cursor->upsert(mdbx::slice{"key1"}, mdbx::slice{"value1.1"}); rw_db_cursor->upsert(mdbx::slice{"key3"}, mdbx::slice{"value3.3"}); test.main_txn.commit_and_renew(); auto rw_mem_cursor = test.mutation.rw_cursor_dup_sort(table::kHashedAccounts); rw_mem_cursor->upsert("key1", "value1.3"); rw_mem_cursor->upsert("key2", "value2.1"); rw_mem_cursor->upsert("key3", "value3.1"); test.mutation.commit_and_renew(); auto db_cursor = test.main_txn.rw_cursor_dup_sort(table::kHashedAccounts); auto mem_cursor = test.mutation.rw_cursor_dup_sort(table::kHashedAccounts); mem_cursor->erase(mdbx::slice{"key1"}); mem_cursor->erase(mdbx::slice{"key3"}); CHECK(db_cursor->seek("key1")); CHECK(db_cursor->seek("key3")); CHECK(!mem_cursor->seek("key1")); CHECK(mem_cursor->seek("key2")); CHECK(!mem_cursor->seek("key3")); mem_cursor->erase(mdbx::slice{"key2"}); CHECK(!mem_cursor->seek("key2")); } TEST_CASE("MemoryMutationCursor: upsert+flush+to_last", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test; test.fill_main_tables(); const auto rw_mem_cursor = test.mutation.rw_cursor(table::kCode); rw_mem_cursor->upsert("CC", "22"); test.mutation.commit_and_renew(); auto db_cursor = test.main_txn.rw_cursor(table::kCode); auto mem_cursor = test.mutation.rw_cursor(table::kCode); auto db_result = db_cursor->to_last(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "BB"); CHECK(db_result.value == "11"); auto mem_result = mem_cursor->to_last(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "CC"); CHECK(mem_result.value == "22"); test.mutation.commit_and_stop(); test.mutation.flush(test.main_txn); test.main_txn.commit_and_renew(); MemoryMutation mutation{test.overlay}; auto db_ro_cursor = test.main_txn.ro_cursor(table::kCode); auto mem_ro_cursor = mutation.ro_cursor(table::kCode); db_result = db_ro_cursor->to_last(/*throw_notfound=*/false); CHECK(db_result.done); CHECK(db_result.key == "CC"); CHECK(db_result.value == "22"); mem_result = mem_ro_cursor->to_last(/*throw_notfound=*/false); CHECK(mem_result.done); CHECK(mem_result.key == "CC"); CHECK(mem_result.value == "22"); } TEST_CASE("MemoryMutationCursor: upsert value w/ different one", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; SECTION("to_previous") { auto rw_cursor1{test1.main_txn.rw_cursor(table::kCode)}; // non dupsort table rw_cursor1->upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor1->upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); rw_cursor1->upsert(mdbx::slice{"CC"}, mdbx::slice{"22"}); test1.main_txn.commit_and_renew(); MemoryMutationCursor mutation_cursor{test1.mutation, table::kCode}; mutation_cursor.upsert(mdbx::slice{"BB"}, mdbx::slice{"11b"}); // replace (BB,11) with (BB,11b) & memory value > db value // searching the new record auto result = mutation_cursor.find("BB", /*throw_notfound=*/false); CHECK(result.done); CHECK(result.key == "BB"); CHECK(result.value == "11b"); auto next_result = mutation_cursor.to_previous(/*throw_notfound=*/true); CHECK(next_result.done); CHECK(next_result.key == "AA"); CHECK(next_result.value == "00"); } SECTION("to_next") { auto rw_cursor1{test1.main_txn.rw_cursor(table::kCode)}; // non dupsort table rw_cursor1->upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor1->upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); test1.main_txn.commit_and_renew(); MemoryMutationCursor mutation_cursor{test1.mutation, table::kCode}; mutation_cursor.upsert(mdbx::slice{"BB"}, mdbx::slice{"11b"}); // replace (BB,11) with (BB,11b) & memory value > db value // searching the new record auto result = mutation_cursor.find("AA", /*throw_notfound=*/false); CHECK(result.done); auto next_result = mutation_cursor.to_next(/*throw_notfound=*/true); CHECK(next_result.done); CHECK(next_result.key == "BB"); CHECK(next_result.value == "11b"); const auto next_next_result = mutation_cursor.to_next(/*throw_notfound=*/false); CHECK(!next_next_result.done); } } TEST_CASE("MemoryMutationCursor: update value w/ different one", "[silkworm][node][db][memory_mutation]") { MemoryMutationCursorTest test1; SECTION("to_previous") { auto rw_cursor1{test1.main_txn.rw_cursor(table::kCode)}; // non dupsort table rw_cursor1->upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor1->upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); rw_cursor1->upsert(mdbx::slice{"CC"}, mdbx::slice{"22"}); test1.main_txn.commit_and_renew(); MemoryMutationCursor mutation_cursor{test1.mutation, table::kCode}; mutation_cursor.update(mdbx::slice{"BB"}, mdbx::slice{"11b"}); // replace (BB,11) with (BB,11b) & memory value > db value // searching the new record auto result = mutation_cursor.find("BB", /*throw_notfound=*/false); CHECK(result.done); CHECK(result.key == "BB"); CHECK(result.value == "11b"); auto next_result = mutation_cursor.to_previous(/*throw_notfound=*/true); CHECK(next_result.done); CHECK(next_result.key == "AA"); CHECK(next_result.value == "00"); } SECTION("to_next") { auto rw_cursor1{test1.main_txn.rw_cursor(table::kCode)}; // non dupsort table rw_cursor1->upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor1->upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); test1.main_txn.commit_and_renew(); MemoryMutationCursor mutation_cursor{test1.mutation, table::kCode}; mutation_cursor.update(mdbx::slice{"BB"}, mdbx::slice{"11b"}); // replace (BB,11) with (BB,11b) & memory value > db value // searching the new record auto result = mutation_cursor.find("AA", /*throw_notfound=*/false); CHECK(result.done); auto next_result = mutation_cursor.to_next(/*throw_notfound=*/true); CHECK(next_result.done); CHECK(next_result.key == "BB"); CHECK(next_result.value == "11b"); const auto next_next_result = mutation_cursor.to_next(/*throw_notfound=*/false); CHECK(!next_next_result.done); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::datastore::kvdb ================================================ FILE: silkworm/db/prune_mode.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "prune_mode.hpp" #include #include #include namespace silkworm::db { using datastore::kvdb::from_slice; using datastore::kvdb::to_slice; //! \brief Retrieves the proper BlockAmount prune threshold for given key static BlockAmount read_block_amount_for_key(mdbx::cursor& source, std::string_view key) { std::string key_str{key}; auto data{source.find(mdbx::slice(key_str), /*throw_notfound=*/false)}; if (data.done) { // Grab numeric value auto value{endian::load_big_u64(from_slice(data.value).data())}; // Lookup type of pruning (before/older) key_str += "Type"; BlockAmount::Type value_type{BlockAmount::Type::kOlder}; auto data2{source.find(mdbx::slice(key_str), /*throw_notfound=*/false)}; if (data2.done) { if (data2.value.as_string() == "older") { value_type = BlockAmount::Type::kOlder; // For compatibility reasons with Erigon we assume a value == UINT64_MAX means no pruning if (value == UINT64_MAX) { return {}; } } else if (data2.value.as_string() == "before") { value_type = BlockAmount::Type::kBefore; } else { // Something bad has been written throw std::runtime_error("Invalid prune type stored in database : " + data2.value.as_string()); } } return BlockAmount(value_type, value); } return {}; } //! \brief Writes the BlockAmount keys in db static void write_block_amount_for_key(mdbx::cursor& target, std::string_view key, const BlockAmount& block_amount) { std::string db_key{key}; std::string db_type{"older"}; Bytes db_value(sizeof(BlockNum), '\0'); if (!block_amount.enabled()) { endian::store_big_u64(db_value.data(), UINT64_MAX); target.upsert(mdbx::slice(db_key), to_slice(db_value)); db_key += "Type"; target.upsert(mdbx::slice(db_key), mdbx::slice(db_type)); return; } endian::store_big_u64(db_value.data(), block_amount.value()); target.upsert(mdbx::slice(db_key), to_slice(db_value)); db_key += "Type"; db_type = (block_amount.type() == BlockAmount::Type::kOlder ? "older" : "before"); target.upsert(mdbx::slice(db_key), mdbx::slice(db_type)); } void BlockAmount::to_string(std::string& short_form, std::string& long_form, char prefix) const { if (!enabled()) return; if (type() == BlockAmount::Type::kOlder) { if (value() == kFullImmutabilityThreshold) { short_form += prefix; } else { long_form += " --prune."; long_form += prefix; long_form += (".older=" + std::to_string(value())); } } else { long_form += " --prune."; long_form += prefix; long_form += (".before=" + std::to_string(value())); } } BlockNum BlockAmount::value() const { if (!enabled()) { return 0; } switch (type_) { case Type::kOlder: return value_.has_value() ? *value_ : kFullImmutabilityThreshold; case Type::kBefore: return value_.has_value() ? *value_ : 0; default: // Should not happen but this removes a compilation warning throw std::runtime_error("Invalid type"); } } BlockNum BlockAmount::value_from_head(BlockNum stage_head) const { if (!stage_head || !enabled_ || !value_) { return 0; } const BlockNum prune_value{value()}; switch (type_) { case Type::kOlder: // See Erigon prune mode Distance interface if (prune_value >= stage_head) return 0; return stage_head - prune_value; case Type::kBefore: // See Erigon prune mode Before interface if (!prune_value) return 0; return prune_value - 1; default: return 0; // Should not happen } } std::string PruneMode::to_string() const { std::string short_form{"--prune="}; std::string long_form{}; history_.to_string(short_form, long_form, 'h'); receipts_.to_string(short_form, long_form, 'r'); senders_.to_string(short_form, long_form, 's'); tx_index_.to_string(short_form, long_form, 't'); call_traces_.to_string(short_form, long_form, 'c'); return short_form + long_form; } PruneMode read_prune_mode(mdbx::txn& txn) { auto src = datastore::kvdb::open_cursor(txn, table::kDatabaseInfo); auto history{read_block_amount_for_key(src, kPruneModeHistoryKey)}; auto receipts{read_block_amount_for_key(src, kPruneModeReceiptsKey)}; auto senders{read_block_amount_for_key(src, kPruneModeSendersKey)}; auto tx_index{read_block_amount_for_key(src, kPruneModeTxIndexKey)}; auto call_traces{read_block_amount_for_key(src, kPruneModeCallTracesKey)}; return PruneMode{history, receipts, senders, tx_index, call_traces}; } void write_prune_mode(mdbx::txn& txn, const PruneMode& value) { auto target = datastore::kvdb::open_cursor(txn, table::kDatabaseInfo); write_block_amount_for_key(target, kPruneModeHistoryKey, value.history()); write_block_amount_for_key(target, kPruneModeReceiptsKey, value.receipts()); write_block_amount_for_key(target, kPruneModeSendersKey, value.senders()); write_block_amount_for_key(target, kPruneModeTxIndexKey, value.tx_index()); write_block_amount_for_key(target, kPruneModeCallTracesKey, value.call_traces()); } PruneMode parse_prune_mode(const std::string& mode, const PruneDistance& older_history, const PruneDistance& older_receipts, const PruneDistance& older_senders, const PruneDistance& older_tx_index, const PruneDistance& older_call_traces, const PruneThreshold& before_history, const PruneThreshold& before_receipts, const PruneThreshold& before_senders, const PruneThreshold& before_tx_index, const PruneThreshold& before_call_traces) { std::optional history, receipts, senders, tx_index, call_traces; if (!mode.empty() && !(iequals(mode, "default") || iequals(mode, "disabled"))) { for (const auto& c : mode) { switch (c) { case 'h': history = BlockAmount(BlockAmount::Type::kOlder, kFullImmutabilityThreshold); break; case 'r': receipts = BlockAmount(BlockAmount::Type::kOlder, kFullImmutabilityThreshold); break; case 's': senders = BlockAmount(BlockAmount::Type::kOlder, kFullImmutabilityThreshold); break; case 't': tx_index = BlockAmount(BlockAmount::Type::kOlder, kFullImmutabilityThreshold); break; case 'c': call_traces = BlockAmount(BlockAmount::Type::kOlder, kFullImmutabilityThreshold); break; default: throw std::invalid_argument("Invalid mode"); } } } // Apply discrete values for 'older' if provided if (older_history) history = BlockAmount(BlockAmount::Type::kOlder, *older_history); if (older_receipts) receipts = BlockAmount(BlockAmount::Type::kOlder, *older_receipts); if (older_senders) senders = BlockAmount(BlockAmount::Type::kOlder, *older_senders); if (older_tx_index) tx_index = BlockAmount(BlockAmount::Type::kOlder, *older_tx_index); if (older_call_traces) call_traces = BlockAmount(BlockAmount::Type::kOlder, *older_call_traces); // Apply discrete values for 'before' if provided if (before_history) history = BlockAmount(BlockAmount::Type::kBefore, *before_history); if (before_receipts) receipts = BlockAmount(BlockAmount::Type::kBefore, *before_receipts); if (before_senders) senders = BlockAmount(BlockAmount::Type::kBefore, *before_senders); if (before_tx_index) tx_index = BlockAmount(BlockAmount::Type::kBefore, *before_tx_index); if (before_call_traces) call_traces = BlockAmount(BlockAmount::Type::kBefore, *before_call_traces); if (!history) history = BlockAmount(); if (!receipts) receipts = BlockAmount(); if (!senders) senders = BlockAmount(); if (!tx_index) tx_index = BlockAmount(); if (!call_traces) call_traces = BlockAmount(); return PruneMode(*history, *receipts, *senders, *tx_index, *call_traces); } } // namespace silkworm::db ================================================ FILE: silkworm/db/prune_mode.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::db { inline constexpr BlockNum kFullImmutabilityThreshold{90'000}; // TODO(Andrea) Prune mode persistence (as in Erigon) is excessively convoluted // Need refactoring when/if Erigon db compatibility can be broken inline constexpr std::string_view kPruneModeHistoryKey{"pruneHistory"}; inline constexpr std::string_view kPruneModeReceiptsKey{"pruneReceipts"}; inline constexpr std::string_view kPruneModeSendersKey{"pruneSenders"}; inline constexpr std::string_view kPruneModeTxIndexKey{"pruneTxIndex"}; inline constexpr std::string_view kPruneModeCallTracesKey{"pruneCallTraces"}; using PruneDistance = std::optional; // for 'older' type using PruneThreshold = std::optional; // for 'before' type class BlockAmount { public: enum class Type : uint8_t { kOlder, // Prune Data Older than (moving window) kBefore // Prune data before (fixed) }; BlockAmount() = default; explicit BlockAmount(Type type, BlockNum value) : value_{value}, enabled_{true}, type_{type} {} bool enabled() const { return enabled_; } Type type() const { return type_; }; BlockNum value() const; BlockNum value_from_head(BlockNum stage_head) const; void to_string(std::string& short_form, std::string& long_form, char prefix) const; friend bool operator==(const BlockAmount&, const BlockAmount&) = default; private: std::optional value_; bool enabled_{false}; Type type_{Type::kOlder}; }; class PruneMode { public: PruneMode() = default; explicit PruneMode(BlockAmount history, BlockAmount receipts, BlockAmount senders, BlockAmount tx_index, BlockAmount call_traces) : history_{history}, receipts_{receipts}, senders_{senders}, tx_index_{tx_index}, call_traces_{call_traces} {} const BlockAmount& history() const { return history_; } const BlockAmount& receipts() const { return receipts_; } const BlockAmount& senders() const { return senders_; } const BlockAmount& tx_index() const { return tx_index_; } const BlockAmount& call_traces() const { return call_traces_; } std::string to_string() const; friend bool operator==(const PruneMode&, const PruneMode&) = default; private: BlockAmount history_; // Holds the pruning threshold for history BlockAmount receipts_; // Holds the pruning threshold for receipts BlockAmount senders_; // Holds the pruning threshold for senders BlockAmount tx_index_; // Holds the pruning threshold for tx_index BlockAmount call_traces_; // Holds the pruning threshold for call traces }; //! \brief Reads pruning mode from db //! \param [in] txn : a db transaction //! \return A PruneMode struct instance PruneMode read_prune_mode(mdbx::txn& txn); //! \brief Writes prune mode to db //! \param [in] txn : a db transaction //! \param [in] value : the PruneMode to be persisted void write_prune_mode(mdbx::txn& txn, const PruneMode& value); //! \brief Parses prune mode from a string //! \param [in] mode : the string representation of PruneMode PruneMode parse_prune_mode(const std::string& mode, const PruneDistance& older_history, const PruneDistance& older_receipts, const PruneDistance& older_senders, const PruneDistance& older_tx_index, const PruneDistance& older_call_traces, const PruneThreshold& before_history, const PruneThreshold& before_receipts, const PruneThreshold& before_senders, const PruneThreshold& before_tx_index, const PruneThreshold& before_call_traces); } // namespace silkworm::db ================================================ FILE: silkworm/db/receipt_cbor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipt_cbor.hpp" #include #include namespace silkworm { Bytes cbor_encode(const std::vector& v) { cbor::output_dynamic output{}; cbor::encoder encoder{output}; if (v.empty()) { encoder.write_null(); } else { encoder.write_array(static_cast(v.size())); } for (const Receipt& r : v) { encoder.write_array(4); encoder.write_int(static_cast(r.type)); encoder.write_null(); // no PostState encoder.write_int(r.success ? 1u : 0u); encoder.write_int(static_cast(r.cumulative_gas_used)); // NOLINT(google-runtime-int) // Bloom filter and logs are omitted, same as in Erigon } return Bytes{output.data(), output.size()}; } } // namespace silkworm ================================================ FILE: silkworm/db/receipt_cbor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { // Erigon-compatible CBOR encoding for storage. // See core/types/receipt.go and migrations/receipt_cbor.go Bytes cbor_encode(const std::vector& v); } // namespace silkworm ================================================ FILE: silkworm/db/receipt_cbor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipt_cbor.hpp" #include #include #include namespace silkworm { TEST_CASE("CBOR encoding of empty receipts") { std::vector v{}; Bytes encoded{cbor_encode(v)}; CHECK(to_hex(encoded) == "f6"); } TEST_CASE("CBOR encoding of receipts") { auto v{test::sample_receipts()}; auto encoded{cbor_encode(v)}; CHECK(to_hex(encoded) == "828400f6001a0032f05d8402f6011a00beadd0"); } } // namespace silkworm ================================================ FILE: silkworm/db/snapshot_benchmark.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots { namespace test = test_util; using silkworm::test_util::TemporaryFile; static const Bytes kLoremIpsumDict{*from_hex( "000000000000004200000000000000000000000000000000000000000000001e" "010003060409040b040a050d07100716071107050507060c0715070e04080f4c" "6f72656d20300f697073756d20310f646f6c6f72203201736974203307616d65" "74203477636f6e736563746574757220350b61646970697363696e6720360765" "6c697420370173656420387b646f20390d656975736d6f642031300374656d70" "6f7220313177696e6369646964756e74203132017574203133036c61626f7265" "2031340b65740a646f6c6f7265203135056d61676e6120313603616c69717561" "2031370155742031380f656e696d203139016164203230056d696e696d203231" "0376656e69616d2032320f717569732032330d6e6f73747275642032341b6578" "65726369746174696f6e2032350d756c6c616d636f2032360d6c61626f726973" "2032370f6e6973692032380175742032390d616c697175697020333001657820" "333101656120333237636f6d6d6f646f0a636f6e7365717561742033330f4475" "69732033340f6175746520333505697275726520333605646f6c6f7220333701" "696e2033383b726570726568656e646572697420333901696e2034300b766f6c" "7570746174652034310576656c69742034320f657373652034330363696c6c75" "6d20343403646f6c6f726520343501657520343603667567696174203437056e" "756c6c612034385b70617269617475720a4578636570746575722034390f7369" "6e74203530176f636361656361742035310b637570696461746174203532076e" "6f6e2035331770726f6964656e742035340f73756e7420353501696e20353605" "63756c7061203537077175692035380d6f666669636961203539176465736572" "756e74203630036d6f6c6c69742036310f616e696d2036320169642036330765" "73742036340d6c61626f72756d203635")}; static void open_snapshot(benchmark::State& state) { TemporaryFile tmp_file{}; tmp_file.write(kLoremIpsumDict); for ([[maybe_unused]] auto _ : state) { seg::Decompressor decoder{tmp_file.path()}; } } BENCHMARK(open_snapshot); static void build_header_index(benchmark::State& state) { TemporaryDirectory tmp_dir; // These sample snapshot files just contain data for block range [1'500'012, 1'500'013], hence current snapshot // file name format is not sufficient to support them (see checks commented out below) test::SampleHeaderSnapshotFile header_segment{tmp_dir.path()}; for ([[maybe_unused]] auto _ : state) { auto header_index = HeaderIndex::make(header_segment.path()); header_index.set_base_data_id(header_segment.block_num_range().start); header_index.build(); } } BENCHMARK(build_header_index); static void build_body_index(benchmark::State& state) { TemporaryDirectory tmp_dir; // These sample snapshot files just contain data for block range [1'500'012, 1'500'013], hence current snapshot // file name format is not sufficient to support them (see checks commented out below) test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; for ([[maybe_unused]] auto _ : state) { auto body_index = BodyIndex::make(body_segment.path()); body_index.set_base_data_id(body_segment.block_num_range().start); body_index.build(); } } BENCHMARK(build_body_index); static void build_tx_index(benchmark::State& state) { TemporaryDirectory tmp_dir; // These sample snapshot files just contain data for block range [1'500'012, 1'500'013], hence current snapshot // file name format is not sufficient to support them (see checks commented out below) test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; test::SampleTransactionSnapshotFile txn_segment{tmp_dir.path()}; for ([[maybe_unused]] auto _ : state) { auto& body_segment_path = body_segment.path(); auto body_index = snapshots::BodyIndex::make(body_segment_path); body_index.set_base_data_id(body_segment.block_num_range().start); body_index.build(); auto& txn_segment_path = txn_segment.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); tx_index.build(); auto tx_index_hash_to_block = TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment.block_num_range().start); tx_index_hash_to_block.build(); } } BENCHMARK(build_tx_index); static void reopen_folder(benchmark::State& state) { TemporaryDirectory tmp_dir; // These sample snapshot files just contain data for block range [1'500'012, 1'500'013], hence current snapshot // file name format is not sufficient to support them (see checks commented out below) test::SampleHeaderSnapshotFile header_segment{tmp_dir.path()}; test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; test::SampleTransactionSnapshotFile txn_segment{tmp_dir.path()}; auto header_index = HeaderIndex::make(header_segment.path()); header_index.set_base_data_id(header_segment.block_num_range().start); header_index.build(); auto& body_segment_path = body_segment.path(); auto body_index = BodyIndex::make(body_segment_path); body_index.set_base_data_id(body_segment.block_num_range().start); body_index.build(); auto& txn_segment_path = txn_segment.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); tx_index.build(); auto tx_index_hash_to_block = TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment.block_num_range().start); tx_index_hash_to_block.build(); for ([[maybe_unused]] auto _ : state) { [[maybe_unused]] auto repository = db::blocks::make_blocks_repository(tmp_dir.path()); } } BENCHMARK(reopen_folder); } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/snapshot_decompressor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots { using Catch::Matchers::Message; namespace test = test_util; using silkworm::test_util::null_stream; using silkworm::test_util::TemporaryFile; using namespace snapshots::seg; //! DecodingTable exposed for white-box testing class DecodingTableForTest : public DecodingTable { public: explicit DecodingTableForTest(size_t max_depth) : DecodingTable(max_depth) {} size_t max_depth() const { return max_depth_; } }; //! set_condensed_table_bit_length_threshold class SetCondensedTableBitLengthThresholdGuard { public: explicit SetCondensedTableBitLengthThresholdGuard(size_t threshold) { PatternTable::set_condensed_table_bit_length_threshold(threshold); } ~SetCondensedTableBitLengthThresholdGuard() { PatternTable::set_condensed_table_bit_length_threshold(PatternTable::kDefaultCondensedTableBitLengthThreshold); } }; TEST_CASE("DecodingTable::DecodingTable", "[silkworm][node][seg][decompressor]") { std::map> test_params{ {"max depth is 0", {0, 0}}, {"max depth is < kMaxTableBitLength", {DecodingTable::kMaxTableBitLength - 1, DecodingTable::kMaxTableBitLength - 1}}, {"max depth is = kMaxTableBitLength", {DecodingTable::kMaxTableBitLength, DecodingTable::kMaxTableBitLength}}, {"max depth is > kMaxTableBitLength", {DecodingTable::kMaxTableBitLength + 1, DecodingTable::kMaxTableBitLength}}, }; for (const auto& [test_name, test_pair] : test_params) { size_t max_depth = test_pair.first; size_t expected_bit_length = test_pair.second; DecodingTableForTest table{max_depth}; CHECK(table.max_depth() == max_depth); CHECK(table.bit_length() == expected_bit_length); } } TEST_CASE("CodeWord::CodeWord", "[silkworm][node][seg][decompressor]") { std::vector codewords{}; codewords.emplace_back(); codewords.emplace_back(0, 0, ByteView{}); codewords.emplace_back(0, 0, ByteView{}, nullptr, nullptr); for (const auto& cw : codewords) { CHECK(cw.code() == 0); CHECK(cw.code_length() == 0); CHECK(cw.pattern().empty()); CHECK(cw.table() == nullptr); CHECK(cw.next() == nullptr); } } TEST_CASE("CodeWord::reset_content", "[silkworm][node][seg][decompressor]") { CodeWord parent_cw{}; uint16_t old_code{121}; uint8_t old_length{2}; Bytes old_pattern{0x11, 0x00, 0x11}; auto table_ptr = std::make_unique(3); const PatternTable* table = table_ptr.get(); CodeWord cw{old_code, old_length, old_pattern, std::move(table_ptr), &parent_cw}; CHECK(cw.code() == old_code); CHECK(cw.code_length() == old_length); CHECK(cw.pattern() == old_pattern); CHECK(cw.table() == table); CHECK(cw.next() == &parent_cw); uint16_t new_code{111}; uint8_t new_length{1}; Bytes new_pattern{0x00, 0x11, 0x00}; CHECK_NOTHROW(cw.reset_content(new_code, new_length, new_pattern)); CHECK(cw.code() == new_code); CHECK(cw.code_length() == new_length); CHECK(cw.pattern() == new_pattern); CHECK(cw.table() == nullptr); CHECK(cw.next() == &parent_cw); } TEST_CASE("CodeWord::set_next", "[silkworm][node][seg][decompressor]") { CodeWord parent1_cw{}, parent2_cw{}; CodeWord cw{0, 0, Bytes{}, std::make_unique(3), &parent1_cw}; CHECK(cw.next() == &parent1_cw); CHECK_NOTHROW(cw.set_next(&parent2_cw)); CHECK(cw.next() == &parent2_cw); } TEST_CASE("PatternTable::set_condensed_table_bit_length_threshold", "[silkworm][node][seg][decompressor]") { SECTION("condensed_table_bit_length_threshold < kMaxTableBitLength") { CHECK_NOTHROW(SetCondensedTableBitLengthThresholdGuard(PatternTable::kMaxTableBitLength - 1)); } SECTION("condensed_table_bit_length_threshold = kMaxTableBitLength") { CHECK_NOTHROW(SetCondensedTableBitLengthThresholdGuard(PatternTable::kMaxTableBitLength)); } SECTION("condensed_table_bit_length_threshold > kMaxTableBitLength") { CHECK_THROWS_AS(SetCondensedTableBitLengthThresholdGuard(PatternTable::kMaxTableBitLength + 1), std::invalid_argument); } } TEST_CASE("PatternTable::PatternTable", "[silkworm][node][seg][decompressor]") { PatternTable table{0}; CHECK(table.num_codewords() == 1); CHECK(table.codeword(0) == nullptr); CHECK(table.codeword(table.num_codewords()) == nullptr); } TEST_CASE("PatternTable::build_condensed", "[silkworm][node][seg][decompressor]") { std::span patterns0{}; Bytes v1{0x00, 0x11}; std::vector patterns1{{0, v1}}; Bytes v2{0x00, 0x22}; std::vector patterns2{{1, v1}, {2, v2}}; std::map> test_spans{ {"zero patterns", patterns0}, {"one pattern", std::span{patterns1.data(), patterns1.size()}}, {"two patterns", std::span{patterns2.data(), patterns2.size()}}, }; PatternTable table{2}; // max_depth in all patterns for (const auto& [test_name, pattern_span] : test_spans) { SECTION(test_name) { CHECK(table.build_condensed(pattern_span) == pattern_span.size()); } } } TEST_CASE("PatternTable::search_condensed", "[silkworm][node][seg][decompressor]") { PatternTable table1{0}; CHECK(table1.search_condensed(0) == nullptr); PatternTable table2{DecodingTable::kMaxTableBitLength + 1}; CHECK(table2.search_condensed(0) == nullptr); } TEST_CASE("PatternTable::operator<<", "[silkworm][node][seg][decompressor]") { PatternTable table1{0}; CHECK_NOTHROW(null_stream() << table1); SetCondensedTableBitLengthThresholdGuard bit_length_threshold_guard{1}; PatternTable table2{0}; CHECK_NOTHROW(null_stream() << table2); } TEST_CASE("PositionTable::PositionTable", "[silkworm][node][seg][decompressor]") { PositionTable table{0}; CHECK(table.num_positions() == 1); CHECK(table.position(0) == 0); CHECK(table.length(0) == 0); CHECK(table.child(0) == nullptr); CHECK(table.position(table.num_positions()) == 0); CHECK(table.length(table.num_positions()) == 0); CHECK(table.child(table.num_positions()) == nullptr); } TEST_CASE("PositionTable::operator<<", "[silkworm][node][seg][decompressor]") { PositionTable table{0}; CHECK_NOTHROW(null_stream() << table); } static test::TemporarySnapshotFile create_snapshot_file( const TemporaryDirectory& tmp_dir, std::vector patterns, std::vector positions) { test::SnapshotHeader header{ .words_count = 0, .empty_words_count = 0, .patterns = std::move(patterns), .positions = std::move(positions), }; return test::TemporarySnapshotFile{tmp_dir.path(), test::SampleHeaderSnapshotFile::kHeadersSnapshotFileName, header}; } static test::TemporarySnapshotFile create_empty_snapshot_file(const TemporaryDirectory& tmp_dir) { return create_snapshot_file(tmp_dir, {}, {}); } TEST_CASE("Decompressor::Decompressor from memory", "[silkworm][node][seg][decompressor]") { TemporaryDirectory tmp_dir; test::TemporarySnapshotFile tmp_snapshot = create_empty_snapshot_file(tmp_dir); MemoryMappedFile mmf{tmp_snapshot.fs_path()}; Decompressor decoder_from_memory{tmp_snapshot.fs_path(), mmf.region()}; CHECK(decoder_from_memory.compressed_path() == tmp_snapshot.fs_path()); CHECK(decoder_from_memory.words_count() == 0); CHECK(decoder_from_memory.empty_words_count() == 0); } TEST_CASE("Decompressor::open invalid files", "[silkworm][node][seg][decompressor]") { SECTION("empty file") { TemporaryFile tmp_file; CHECK_THROWS_AS((Decompressor{tmp_file.path()}), std::runtime_error); } SECTION("compressed file is too short: 1") { TemporaryFile tmp_file; tmp_file.write(*silkworm::from_hex("0")); CHECK_THROWS_MATCHES((Decompressor{tmp_file.path()}), std::runtime_error, Message("compressed file is too short: 1")); } SECTION("compressed file is too short: 31") { TemporaryFile tmp_file; tmp_file.write(*silkworm::from_hex("0x00000000000000000000000000000000000000000000000000000000000000")); CHECK_THROWS_MATCHES((Decompressor{tmp_file.path()}), std::runtime_error, Message("compressed file is too short: 31")); } SECTION("invalid pattern_dict_length for compressed file size: 32") { TemporaryFile tmp_file1; tmp_file1.write(*silkworm::from_hex("0x000000000000000C000000000000000400000000000000150309000000000000")); CHECK_THROWS_MATCHES((Decompressor{tmp_file1.path()}), std::runtime_error, Message("invalid pattern_dict_length for compressed file size: 32")); TemporaryFile tmp_file2; tmp_file2.write(*silkworm::from_hex("0x0000000000000000000000000000000000000000000000010000000000000000")); CHECK_THROWS_MATCHES((Decompressor{tmp_file2.path()}), std::runtime_error, Message("invalid pattern_dict_length for compressed file size: 32")); } SECTION("invalid pattern_dict_length for compressed file size: 34") { TemporaryFile tmp_file; tmp_file.write(*silkworm::from_hex("0x000000000000000C00000000000000040000000000000016000000000000000003ff")); CHECK_THROWS_MATCHES((Decompressor{tmp_file.path()}), std::runtime_error, Message("invalid pattern_dict_length for compressed file size: 34")); } SECTION("invalid position_dict_length for compressed file size: 34") { TemporaryFile tmp_file1; tmp_file1.write(*silkworm::from_hex("0x000000000000000C0000000000000004000000000000000000000000000000160309")); CHECK_THROWS_MATCHES((Decompressor{tmp_file1.path()}), std::runtime_error, Message("invalid position_dict_length for compressed file size: 34")); TemporaryFile tmp_file2; tmp_file2.write(*silkworm::from_hex("0x000000000000000C00000000000000040000000000000000000000000000001603ff")); CHECK_THROWS_MATCHES((Decompressor{tmp_file2.path()}), std::runtime_error, Message("invalid position_dict_length for compressed file size: 34")); } } TEST_CASE("Decompressor::open valid files", "[silkworm][node][seg][decompressor]") { TemporaryDirectory tmp_dir; std::map header_tests{ { "zero patterns and zero positions", test::SnapshotHeader{}, }, { "one pattern and zero positions", test::SnapshotHeader{ .words_count = 0, .empty_words_count = 0, .patterns = std::vector{{12, {0x11, 0x22}}}, .positions = std::vector{}, }, }, { "zero patterns and one position", test::SnapshotHeader{ .words_count = 0, .empty_words_count = 0, .patterns = std::vector{}, .positions = std::vector{{0, 22}}, }, }, { "one pattern and one position", test::SnapshotHeader{ .words_count = 0, .empty_words_count = 0, .patterns = std::vector{{12, {}}}, .positions = std::vector{{13, 22}}, }, }, { "two patterns and one position", test::SnapshotHeader{ .words_count = 0, .empty_words_count = 0, .patterns = std::vector{{1, {}}, {2, {}}}, .positions = std::vector{{0, 22}}, }, }, }; for (auto& [test_name, header] : header_tests) { SECTION(test_name) { test::TemporarySnapshotFile tmp_snapshot{tmp_dir.path(), test::SampleHeaderSnapshotFile::kHeadersSnapshotFileName, header}; Decompressor decoder{tmp_snapshot.fs_path()}; } } } TEST_CASE("Iterator::Iterator empty data", "[silkworm][node][seg][decompressor]") { TemporaryDirectory tmp_dir; test::TemporarySnapshotFile tmp_snapshot = create_empty_snapshot_file(tmp_dir); Decompressor decoder{tmp_snapshot.fs_path()}; SECTION("init") { CHECK(decoder.compressed_path() == tmp_snapshot.fs_path()); CHECK(decoder.words_count() == 0); CHECK(decoder.empty_words_count() == 0); } SECTION("data_size") { CHECK(decoder.make_iterator().data_size() == 0); } SECTION("has_next") { CHECK_FALSE(decoder.make_iterator().has_next()); } SECTION("next") { Bytes buffer; CHECK_THROWS_AS(decoder.make_iterator().next_compressed(buffer), std::runtime_error); } SECTION("next_uncompressed") { ByteView buffer_view; CHECK_THROWS_AS(decoder.make_iterator().next_uncompressed(buffer_view), std::runtime_error); } SECTION("skip") { CHECK_THROWS_AS(decoder.make_iterator().skip_compressed(), std::runtime_error); } SECTION("skip_uncompressed") { CHECK_THROWS_AS(decoder.make_iterator().skip_uncompressed(), std::runtime_error); } } static const std::string kLoremIpsum{ "Lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et\n" "dolore magna aliqua Ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur\n" "Excepteur sint occaecat cupidatat non proident sunt in culpa qui officia deserunt mollit anim id est laborum"}; static const std::vector kLoremIpsumWords = absl::StrSplit(kLoremIpsum, ' '); static const Bytes kLoremIpsumDict{*from_hex( "000000000000004200000000000000000000000000000000000000000000001e" "010003060409040b040a050d07100716071107050507060c0715070e04080f4c" "6f72656d20300f697073756d20310f646f6c6f72203201736974203307616d65" "74203477636f6e736563746574757220350b61646970697363696e6720360765" "6c697420370173656420387b646f20390d656975736d6f642031300374656d70" "6f7220313177696e6369646964756e74203132017574203133036c61626f7265" "2031340b65740a646f6c6f7265203135056d61676e6120313603616c69717561" "2031370155742031380f656e696d203139016164203230056d696e696d203231" "0376656e69616d2032320f717569732032330d6e6f73747275642032341b6578" "65726369746174696f6e2032350d756c6c616d636f2032360d6c61626f726973" "2032370f6e6973692032380175742032390d616c697175697020333001657820" "333101656120333237636f6d6d6f646f0a636f6e7365717561742033330f4475" "69732033340f6175746520333505697275726520333605646f6c6f7220333701" "696e2033383b726570726568656e646572697420333901696e2034300b766f6c" "7570746174652034310576656c69742034320f657373652034330363696c6c75" "6d20343403646f6c6f726520343501657520343603667567696174203437056e" "756c6c612034385b70617269617475720a4578636570746575722034390f7369" "6e74203530176f636361656361742035310b637570696461746174203532076e" "6f6e2035331770726f6964656e742035340f73756e7420353501696e20353605" "63756c7061203537077175692035380d6f666669636961203539176465736572" "756e74203630036d6f6c6c69742036310f616e696d2036320169642036330765" "73742036340d6c61626f72756d203635")}; TEST_CASE("Decompressor: lorem ipsum next_uncompressed", "[silkworm][node][seg][decompressor]") { TemporaryFile tmp_file{}; tmp_file.write(kLoremIpsumDict); Decompressor decoder{tmp_file.path()}; { size_t i{0}; auto it = decoder.make_iterator(); while (it.has_next() && i < kLoremIpsumWords.size()) { if (i % 2 == 0) { it.skip_uncompressed(); } else { const std::string word_plus_index{kLoremIpsumWords[i] + " " + std::to_string(i)}; const Bytes expected_word{word_plus_index.cbegin(), word_plus_index.cend()}; ByteView decoded_word; it.next_uncompressed(decoded_word); CHECK(decoded_word == expected_word); } ++i; } CHECK_FALSE(it.has_next()); CHECK(i == kLoremIpsumWords.size()); } } TEST_CASE("Decompressor: lorem ipsum next", "[silkworm][node][seg][decompressor]") { TemporaryFile tmp_file{}; tmp_file.write(kLoremIpsumDict); Decompressor decoder{tmp_file.path()}; { size_t i{0}; auto it = decoder.make_iterator(); while (it.has_next() && i < kLoremIpsumWords.size()) { if (i % 2 == 0) { it.skip_compressed(); } else { const std::string word_plus_index{kLoremIpsumWords[i] + " " + std::to_string(i)}; const Bytes expected_word{word_plus_index.cbegin(), word_plus_index.cend()}; Bytes decoded_word; it.next_compressed(decoded_word); CHECK(decoded_word == expected_word); } ++i; } CHECK_FALSE(it.has_next()); CHECK(i == kLoremIpsumWords.size()); } } TEST_CASE("Decompressor: lorem ipsum has_prefix", "[silkworm][node][seg][decompressor]") { TemporaryFile tmp_file{}; tmp_file.write(kLoremIpsumDict); Decompressor decoder{tmp_file.path()}; { size_t i{0}; auto it = decoder.make_iterator(); while (it.has_next() && i < kLoremIpsumWords.size()) { const std::string word_plus_index{kLoremIpsumWords[i] + " " + std::to_string(i)}; const Bytes expected_word{word_plus_index.cbegin(), word_plus_index.cend()}; CHECK(it.has_prefix(expected_word.substr(0, expected_word.size() / 2))); if (!expected_word.empty()) { Bytes modified_word{expected_word}; ++modified_word[expected_word.size() - 1]; CHECK(!it.has_prefix(modified_word)); } it.skip_compressed(); ++i; } CHECK(i == kLoremIpsumWords.size()); } } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/snapshot_index_builder_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots { namespace test = test_util; using namespace Catch::Matchers; TEST_CASE("Index::Index", "[silkworm][snapshot][index]") { TemporaryDirectory tmp_dir; test::TemporarySnapshotFile tmp_snapshot_file{tmp_dir.path(), "v1-014500-015000-headers.seg"}; auto header_index = HeaderIndex::make(tmp_snapshot_file.path()); CHECK_THROWS_AS(header_index.build(), std::logic_error); } // This unit test fails on Windows with error: SIGSEGV - Segmentation violation signal TEST_CASE("BodyIndex::build OK", "[silkworm][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleBodySnapshotFile body_segment_file{tmp_dir.path()}; auto body_index = BodyIndex::make(body_segment_file.path()); body_index.set_base_data_id(body_segment_file.block_num_range().start); CHECK_NOTHROW(body_index.build()); } TEST_CASE("TransactionIndex::build KO: empty snapshot", "[silkworm][snapshot][index]") { TemporaryDirectory tmp_dir; constexpr std::string_view kBodiesSnapshotFileName{"v1-014500-015000-bodies.seg"}; constexpr std::string_view kTransactionsSnapshotFileName{"v1-014500-015000-transactions.seg"}; SECTION("KO: empty body snapshot", "[.]") { test::TemporarySnapshotFile body_segment_file{tmp_dir.path(), kBodiesSnapshotFileName}; test::TemporarySnapshotFile txn_segment_file{tmp_dir.path(), kTransactionsSnapshotFileName}; auto& txn_segment_path = txn_segment_file.path(); auto& body_segment_path = body_segment_file.path(); CHECK_THROWS_WITH(TransactionIndex::make(body_segment_path, txn_segment_path).build(), ContainsSubstring("empty body snapshot")); CHECK_THROWS_WITH(TransactionToBlockIndex::make(body_segment_path, txn_segment_path).build(), ContainsSubstring("empty body snapshot")); } } TEST_CASE("TransactionIndex::build KO: invalid snapshot", "[silkworm][snapshot][index]") { TemporaryDirectory tmp_dir; constexpr std::string_view kTransactionsSnapshotFileName{"v1-015000-015500-transactions.seg"}; SECTION("KO: invalid zero word length") { test::TemporarySnapshotFile body_segment_file{ tmp_dir.path(), "v1-015000-015500-bodies.seg", test::SnapshotHeader{ .words_count = 7, .empty_words_count = 0, .patterns = {}, .positions = {}}, test::SnapshotBody{ *from_hex("0000000000000000")}}; test::TemporarySnapshotFile txn_segment_file{tmp_dir.path(), kTransactionsSnapshotFileName}; auto& txn_segment_path = txn_segment_file.path(); auto& body_segment_path = body_segment_file.path(); CHECK_THROWS_WITH(TransactionIndex::make(body_segment_path, txn_segment_path).build(), StartsWith("invalid zero word length")); CHECK_THROWS_WITH(TransactionToBlockIndex::make(body_segment_path, txn_segment_path).build(), StartsWith("invalid zero word length")); } SECTION("KO: invalid position depth") { test::SampleBodySnapshotFile body_segment_file{ tmp_dir.path(), "000000000000000e000000000000000000000000000000000000000000000004" "c100010801c6837004d980c001c6837004d980c001c6837004d980c001c68370" // {c1, 00} <- c1 instead of 01 "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d901c0"}; auto& body_segment_path = body_segment_file.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; auto& txn_segment_path = txn_segment_file.path(); CHECK_THROWS_WITH(TransactionIndex::make(body_segment_path, txn_segment_path).build(), ContainsSubstring("invalid: position depth")); CHECK_THROWS_WITH(TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start).build(), ContainsSubstring("invalid: position depth")); } SECTION("KO: invalid position value") { test::SampleBodySnapshotFile body_segment_file{ tmp_dir.path(), "000000000000000e000000000000000000000000000000000000000000000004" "01ff010801c6837004d980c001c6837004d980c001c6837004d980c001c68370" // {01, ff} <- ff instead of 00 "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d901c0"}; auto& body_segment_path = body_segment_file.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; auto& txn_segment_path = txn_segment_file.path(); CHECK_THROWS_WITH(TransactionIndex::make(body_segment_path, txn_segment_path).build(), ContainsSubstring("invalid: position read")); CHECK_THROWS_WITH(TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start).build(), ContainsSubstring("invalid: position read")); } SECTION("KO: invalid positions count") { test::SampleBodySnapshotFile body_segment_file{ tmp_dir.path(), "000000000000000e000000000000000000000000000000000000000000000005" // POSITIONS=5 <- 5 instead of 4 "0100010801c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d901c0"}; auto& body_segment_path = body_segment_file.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; auto& txn_segment_path = txn_segment_file.path(); CHECK_THROWS_WITH(TransactionIndex::make(body_segment_path, txn_segment_path).build(), ContainsSubstring("invalid: position read")); CHECK_THROWS_WITH(TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start).build(), ContainsSubstring("invalid: position read")); } SECTION("KO: invalid RLP") { test::SampleBodySnapshotFile body_segment_file{ tmp_dir.path(), "000000000000000e000000000000000000000000000000000000000000000004" "0100010801c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c6837004d980c001c6837004d980c001c68370" "04d980c001c6837004d980c001c7837004d901c0"}; // {01, c7837004d980c0} <- c7 instead of c6 auto& body_segment_path = body_segment_file.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; auto& txn_segment_path = txn_segment_file.path(); CHECK_THROWS_AS(TransactionIndex::make(body_segment_path, txn_segment_path).build(), DecodingException); CHECK_THROWS_AS(TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start).build(), DecodingException); } SECTION("KO: unexpected tx amount") { test::SampleBodySnapshotFile body_segment_file{tmp_dir.path()}; auto& body_segment_path = body_segment_file.path(); test::SampleTransactionSnapshotFile txn_segment_file{ tmp_dir.path(), "000000000000000C" // WC = 12 "0000000000000004" // EWC = 4 "0000000000000000" // PaTS = 0 "0000000000000016" // PoTS = 22 "010004E60304850104E5020487010301048801048401" // PoT = 0x01...01 "0309" "3DE6BF8FE3E608CC04681B3DFC8B2D52AB94C23DB7F86D018504E3B292008252" // Txn position 0 block 1'500'012 START "0894BB9BC244D798123FDE783FCC1C72D3BB8C1894138902292B2AD00B120000" "801CA0F5D7EB932991DC38FB5A3ED2ABCC71C2ABFC098BB2A9A25552ABEC2249" "A6AAF8A055CAD62B0CD8E2B6154F2EA52D308535EF634D9A207571996754A02E" "59DE97C1" // Txn position 0 block 1'500'012 END // 11 txs missing here... }; auto& txn_segment_path = txn_segment_file.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); CHECK_THROWS_WITH(tx_index.build(), StartsWith("keys expected")); auto tx_index_hash_to_block = TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start); CHECK_THROWS_WITH(tx_index_hash_to_block.build(), ContainsSubstring("tx count mismatch")); } } TEST_CASE("TransactionIndex::build OK", "[silkworm][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleBodySnapshotFile body_segment_file{tmp_dir.path()}; auto& body_segment_path = body_segment_file.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; auto& txn_segment_path = txn_segment_file.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); tx_index.build(); auto tx_index_hash_to_block = TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start); tx_index_hash_to_block.build(); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/snapshot_recompress.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include "blocks/bodies/body_segment.hpp" #include "blocks/headers/header_segment.hpp" #include "blocks/schema_config.hpp" #include "blocks/step_block_num_converter.hpp" #include "blocks/transactions/txn_segment.hpp" #include "datastore/snapshots/common/snapshot_path.hpp" namespace silkworm::snapshots { using namespace segment; template void copy_reader_to_writer(const SegmentFileReader& file_reader, SegmentFileWriter& file_writer) { TSegmentReader reader{file_reader}; TSegmentWriter writer{file_writer}; std::copy(reader.begin(), reader.end(), writer.out()); } void snapshot_file_recompress(const std::filesystem::path& path) { auto path_opt = SnapshotPath::parse(path); if (!path_opt) throw std::runtime_error{"bad snapshot path"}; SegmentFileReader file_reader{*path_opt, db::blocks::kStepToBlockNumConverter}; auto out_path = path; out_path.replace_extension("seg2"); TemporaryDirectory tmp_dir; SegmentFileWriter file_writer{*SnapshotPath::parse(out_path), tmp_dir.path()}; auto schema = db::blocks::make_blocks_repository_schema(); auto names = schema.entity_name_by_path(*path_opt); if (!names) throw std::runtime_error{"unsupported snapshot type"}; datastore::EntityName name = names->second; { if (name == db::blocks::kHeaderSegmentName) copy_reader_to_writer(file_reader, file_writer); else if (name == db::blocks::kBodySegmentName) copy_reader_to_writer(file_reader, file_writer); else if (name == db::blocks::kTxnSegmentName) copy_reader_to_writer(file_reader, file_writer); else throw std::runtime_error{"invalid snapshot type"}; } SegmentFileWriter::flush(std::move(file_writer)); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/snapshot_recompress.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::snapshots { void snapshot_file_recompress(const std::filesystem::path& path); } ================================================ FILE: silkworm/db/snapshot_repository_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::snapshots { namespace test = test_util; #define CHECK_FIRST(x) CHECK((x).first) #define CHECK_FALSE_FIRST(x) CHECK_FALSE((x).first) static SnapshotRepository make_repository(std::filesystem::path dir_path) { return db::blocks::make_blocks_repository(std::move(dir_path)); } // NOLINTBEGIN(readability-identifier-naming) struct SnapshotType { static inline const SegmentAndAccessorIndexNames headers{db::blocks::kHeaderSegmentAndIdxNames}; static inline const SegmentAndAccessorIndexNames bodies{db::blocks::kBodySegmentAndIdxNames}; static inline const SegmentAndAccessorIndexNames transactions{db::blocks::kTxnSegmentAndIdxNames}; }; // NOLINTEND(readability-identifier-naming) TEST_CASE("SnapshotRepository::SnapshotRepository", "[silkworm][node][snapshot]") { TemporaryDirectory tmp_dir; CHECK_NOTHROW(make_repository(tmp_dir.path())); } TEST_CASE("SnapshotRepository::reopen_folder.partial_bundle", "[silkworm][node][snapshot]") { TemporaryDirectory tmp_dir; test::TemporarySnapshotFile tmp_snapshot_1{tmp_dir.path(), "v1-014500-015000-headers.seg"}; test::TemporarySnapshotFile tmp_snapshot_2{tmp_dir.path(), "v1-011500-012000-bodies.seg"}; test::TemporarySnapshotFile tmp_snapshot_3{tmp_dir.path(), "v1-015000-015500-transactions.seg"}; auto repository = make_repository(tmp_dir.path()); CHECK(repository.bundles_count() == 0); CHECK(repository.max_timestamp_available() == 0); } TEST_CASE("SnapshotRepository::view", "[silkworm][node][snapshot]") { TemporaryDirectory tmp_dir; SECTION("no snapshots") { auto repository = make_repository(tmp_dir.path()); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 14'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 11'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 15'000'000)); size_t bundles_count = 0; for ([[maybe_unused]] const auto& bundle : repository.view_bundles()) { ++bundles_count; } CHECK(bundles_count == 0); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 14'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 11'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 15'000'000)); } SECTION("partial bundle") { test::TemporarySnapshotFile tmp_snapshot_1{tmp_dir.path(), "v1-014500-015000-headers.seg"}; test::TemporarySnapshotFile tmp_snapshot_2{tmp_dir.path(), "v1-011500-012000-bodies.seg"}; test::TemporarySnapshotFile tmp_snapshot_3{tmp_dir.path(), "v1-015000-015500-transactions.seg"}; auto repository = make_repository(tmp_dir.path()); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 14'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 11'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 15'000'000)); size_t bundles_count = 0; for ([[maybe_unused]] const auto& bundle : repository.view_bundles()) { ++bundles_count; } // empty snapshots are ignored by repository CHECK(bundles_count == 0); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 14'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 11'500'000)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 15'000'000)); } SECTION("non-empty snapshots") { test::SampleHeaderSnapshotFile tmp_snapshot_1{tmp_dir.path()}; test::SampleBodySnapshotFile tmp_snapshot_2{tmp_dir.path()}; test::SampleTransactionSnapshotFile tmp_snapshot_3{tmp_dir.path()}; auto repository = make_repository(tmp_dir.path()); for (auto& index_builder : repository.missing_indexes()) { index_builder->build(); } repository.reopen_folder(); size_t bundles_count = 0; for ([[maybe_unused]] const auto& bundle : repository.view_bundles()) { ++bundles_count; } CHECK(bundles_count == 1); CHECK_FIRST(repository.find_segment(SnapshotType::headers, 1'500'000)); CHECK_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'000)); CHECK_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'000)); bundles_count = 0; for ([[maybe_unused]] const auto& bundle : repository.view_bundles()) { ++bundles_count; } CHECK(bundles_count == 1); } } TEST_CASE("SnapshotRepository::find_segment", "[silkworm][node][snapshot]") { TemporaryDirectory tmp_dir; // These sample snapshot files just contain data for block range [1'500'012, 1'500'013], hence current snapshot // file name format is not sufficient to support them (see checks commented out below) test::SampleHeaderSnapshotFile header_segment{tmp_dir.path()}; test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; test::SampleTransactionSnapshotFile txn_segment{tmp_dir.path()}; auto repository = make_repository(tmp_dir.path()); SECTION("header w/o index") { CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 1'500'011)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 1'500'012)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 1'500'013)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::headers, 1'500'014)); } SECTION("body w/o index") { CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'011)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'012)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'013)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'014)); } SECTION("tx w/o index") { CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'011)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'012)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'013)); CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'014)); } auto header_index = HeaderIndex::make(header_segment.path()); header_index.set_base_data_id(header_segment.block_num_range().start); REQUIRE_NOTHROW(header_index.build()); auto& body_segment_path = body_segment.path(); auto body_index = BodyIndex::make(body_segment_path); body_index.set_base_data_id(body_segment.block_num_range().start); REQUIRE_NOTHROW(body_index.build()); auto& txn_segment_path = txn_segment.path(); REQUIRE_NOTHROW(TransactionIndex::make(body_segment_path, txn_segment_path).build()); REQUIRE_NOTHROW(TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment.block_num_range().start).build()); REQUIRE_NOTHROW(repository.reopen_folder()); SECTION("header w/ index") { CHECK_FIRST(repository.find_segment(SnapshotType::headers, 1'500'011)); CHECK_FIRST(repository.find_segment(SnapshotType::headers, 1'500'012)); CHECK_FIRST(repository.find_segment(SnapshotType::headers, 1'500'013)); CHECK_FIRST(repository.find_segment(SnapshotType::headers, 1'500'014)); } SECTION("body w/ index") { CHECK_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'011)); CHECK_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'012)); CHECK_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'013)); CHECK_FIRST(repository.find_segment(SnapshotType::bodies, 1'500'014)); } SECTION("tx w/ index") { CHECK_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'011)); CHECK_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'012)); CHECK_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'013)); CHECK_FIRST(repository.find_segment(SnapshotType::transactions, 1'500'014)); } SECTION("greater than max_timestamp_available") { CHECK_FALSE_FIRST(repository.find_segment(SnapshotType::bodies, repository.max_timestamp_available() + 1)); } } // Skip to avoid Clang ASAN runtime error: reference binding to misaligned address #ifndef SILKWORM_SANITIZE TEST_CASE("SnapshotRepository::find_block_num", "[silkworm][node][snapshot]") { TemporaryDirectory tmp_dir; // These sample snapshot files just contain data for block range [1'500'012, 1'500'013], hence current snapshot // file name format is not sufficient to support them (see checks commented out below) test::SampleHeaderSnapshotFile header_segment{tmp_dir.path()}; test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; test::SampleTransactionSnapshotFile txn_segment{tmp_dir.path()}; auto header_index = HeaderIndex::make(header_segment.path()); header_index.set_base_data_id(header_segment.block_num_range().start); REQUIRE_NOTHROW(header_index.build()); auto& body_segment_path = body_segment.path(); auto body_index = BodyIndex::make(body_segment_path); body_index.set_base_data_id(body_segment.block_num_range().start); REQUIRE_NOTHROW(body_index.build()); auto& txn_segment_path = txn_segment.path(); REQUIRE_NOTHROW(TransactionIndex::make(body_segment_path, txn_segment_path).build()); REQUIRE_NOTHROW(TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment.block_num_range().start).build()); auto repository = make_repository(tmp_dir.path()); TransactionBlockNumByTxnHashQuery query{repository}; // known block 1'500'012 txn hash auto result = query.exec(silkworm::Hash{from_hex("0x2224c39c930355233f11414e9f216f381c1f6b0c32fc77b192128571c2dc9eb9").value()}); CHECK(result.has_value()); CHECK(result->first == 1'500'012); // known block 1'500'012 txn hash result = query.exec(silkworm::Hash{from_hex("0x3ba9a1f95b96d0a43093b1ade1174133ea88ca395e60fe9fd8144098ff7a441f").value()}); CHECK(result.has_value()); CHECK(result->first == 1'500'013); // unknown txn hash result = query.exec(silkworm::Hash{from_hex("0x0000000000000000000000000000000000000000000000000000000000000000").value()}); // CHECK_FALSE(result.has_value()); // needs correct key check in index } #endif // SILKWORM_SANITIZE static auto move_last_write_time(const std::filesystem::path& p, const std::filesystem::file_time_type::duration& d) { const auto ftime = std::filesystem::last_write_time(p); std::filesystem::last_write_time(p, ftime + d); return std::filesystem::last_write_time(p) - ftime; } TEST_CASE("SnapshotRepository::remove_stale_indexes", "[silkworm][node][snapshot][index]") { using namespace std::chrono_literals; TemporaryDirectory tmp_dir; auto repository = make_repository(tmp_dir.path()); // create a snapshot file test::SampleHeaderSnapshotFile header_segment_file{tmp_dir.path()}; auto& header_segment_path = header_segment_file.path(); // build an index auto index_builder = HeaderIndex::make(header_segment_path); index_builder.set_base_data_id(header_segment_file.block_num_range().start); REQUIRE_NOTHROW(index_builder.build()); auto index_path = index_builder.path().path(); // the index is not stale repository.remove_stale_indexes(); CHECK(std::filesystem::exists(index_path)); // move the snapshot last write time 1 hour to the future to make its index "stale" const auto last_write_time_diff = move_last_write_time(header_segment_path.path(), 1h); CHECK((last_write_time_diff.count() > 0)); // the index is stale repository.remove_stale_indexes(); CHECK_FALSE(std::filesystem::exists(index_path)); } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/snapshot_sync.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_sync.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "blocks/headers/header_segment.hpp" #include "blocks/step_block_num_converter.hpp" #include "datastore/kvdb/etl_mdbx_collector.hpp" #include "datastore/snapshots/bittorrent/torrent_file.hpp" #include "datastore/snapshots/common/snapshot_path.hpp" #include "stages.hpp" namespace silkworm::db { using namespace silkworm::snapshots; //! \warning Hash provider for std::filesystem::path necessary to avoid the following error in Clang + LLVM 16 //! \verbatim //! error: call to implicitly-deleted default constructor of 'std::hash' //! \endverbatim struct PathHasher { auto operator()(const std::filesystem::path& p) const noexcept { return std::filesystem::hash_value(p); } }; static bool snapshot_file_is_fully_merged(std::string_view file_name) { auto step_converter = blocks::kStepToBlockNumConverter; const auto path = SnapshotPath::parse(std::filesystem::path{file_name}); return path.has_value() && (path->extension() == blocks::kSegmentExtension || path->extension() == blocks::kIdxExtension) && (step_converter.timestamp_range_from_step_range(path->step_range()).size() >= kMaxMergerSnapshotSize); } SnapshotSync::SnapshotSync( snapshots::SnapshotSettings settings, ChainId chain_id, db::DataStoreRef data_store, std::filesystem::path tmp_dir_path, datastore::StageScheduler& stage_scheduler) : settings_{std::move(settings)}, snapshots_config_{Config::lookup_known_config(chain_id, snapshot_file_is_fully_merged)}, data_store_{std::move(data_store)}, client_{settings_.bittorrent_settings}, snapshot_freezer_{ data_store_.chaindata.access_ro(), data_store_.blocks_repository, stage_scheduler, tmp_dir_path, settings_.keep_blocks, }, snapshot_merger_{data_store_.blocks_repository, std::move(tmp_dir_path)}, is_stopping_latch_{1} { } Task SnapshotSync::run() { using namespace concurrency::awaitable_wait_for_all; [[maybe_unused]] auto _ = gsl::finally([this]() { this->is_stopping_latch_.count_down(); }); if (!settings_.enabled) { SILK_INFO << "Snapshot sync disabled, no snapshot must be downloaded"; co_return; } if (settings_.no_downloader && settings_.no_seeding) { co_await setup_and_run(); co_return; } try { co_await (setup_and_run() && client_.async_run("bit-torrent")); } catch (const boost::system::system_error& ex) { SILK_ERROR_M("SnapshotSync") << "SnapshotSync::run ex=" << ex.what(); if (ex.code() == boost::system::errc::operation_canceled) { // TODO(canepat) demote to debug after https://github.com/erigontech/silkworm/issues/2333 is solved SILK_WARN_M("SnapshotSync") << "SnapshotSync::run operation_canceled"; } throw; } } Task SnapshotSync::setup_and_run() { using namespace concurrency::awaitable_wait_for_all; co_await setup(); if (settings_.stop_freezer) { co_return; } [[maybe_unused]] auto snapshot_merged_subscription = snapshot_merger_.on_snapshot_merged([this](datastore::StepRange range) { this->seed_frozen_bundle(range); }); co_await ( snapshot_freezer_.run_loop() && snapshot_merger_.run_loop()); } // Raise file descriptor limit per process void raise_fd_limit() { constexpr uint64_t kMaxFileDescriptors{10'240}; const bool set_fd_result = os::set_max_file_descriptors(kMaxFileDescriptors); if (!set_fd_result) { throw std::runtime_error{"Cannot increase max file descriptor up to " + std::to_string(kMaxFileDescriptors)}; } } Task SnapshotSync::setup() { raise_fd_limit(); // Snapshot sync - download chain from peers using snapshot files co_await download_snapshots_if_needed(); blocks_repository().remove_stale_indexes(); co_await build_missing_indexes(); blocks_repository().reopen_folder(); // Update chain and stage progresses in database according to available snapshots datastore::kvdb::RWTxnManaged rw_txn = data_store_.chaindata.access_rw().start_rw_tx(); update_database(rw_txn, blocks_repository().max_timestamp_available(), [this] { return is_stopping_latch_.try_wait(); }); rw_txn.commit_and_stop(); if (!settings_.no_seeding) { seed_frozen_local_snapshots(); } if (settings_.verify_on_startup) { client_.recheck_all_finished_torrents(); } std::scoped_lock lock{setup_done_mutex_}; setup_done_ = true; setup_done_cond_var_.notify_all(); } Task SnapshotSync::wait_for_setup() { std::unique_lock lock{setup_done_mutex_}; if (setup_done_) co_return; auto waiter = setup_done_cond_var_.waiter(); lock.unlock(); co_await waiter(); } Task SnapshotSync::download_snapshots_if_needed() { if (settings_.enabled && !settings_.no_downloader) { co_await download_snapshots(); } } Task SnapshotSync::download_snapshots() { SILK_INFO << "SnapshotSync: downloading missing snapshots if needed"; const auto& snapshot_config = snapshots_config_; if (snapshot_config.preverified_snapshots().empty()) { SILK_ERROR << "SnapshotSync: no preverified snapshots found"; throw std::runtime_error("SnapshotSync: no preverified snapshots found"); } const size_t num_snapshots = snapshot_config.preverified_snapshots().size(); SILK_INFO << "SnapshotSync: download started: [0/" << num_snapshots << "]"; auto log_added = [](const std::filesystem::path& path) { SILK_TRACE << "SnapshotSync: download started for: " << path.filename().string(); }; boost::signals2::scoped_connection added_subscription{client_.added_subscription.connect(log_added)}; size_t completed = 0; auto log_stats = [&](lt::span counters) { // Log progress just once in a while because our BitTorrent notifications rely on alert polling so quite chatty static int notification_count{0}; if (notification_count++ != 30) return; notification_count = 0; SILK_INFO << "SnapshotSync: download progress: [" << completed << "/" << num_snapshots << "]"; if (log::test_verbosity(log::Level::kTrace)) { std::string counters_dump; for (int i{0}; i < counters.size(); ++i) { const auto& stats_metric = client_.stats_metrics().at(static_cast(i)); counters_dump.append(stats_metric.name); counters_dump.append("="); counters_dump.append(std::to_string(counters[i])); if (i != counters.size() - 1) counters_dump.append(", "); } SILK_TRACE << "SnapshotSync: counters dump [" << counters_dump << "]"; } }; boost::signals2::scoped_connection stats_subscription{client_.stats_subscription.connect(log_stats)}; auto executor = co_await boost::asio::this_coro::executor; // make the buffer bigger so that try_send always succeeds in case of duplicate files (see snapshot_set below) concurrency::Channel completed_channel{executor, num_snapshots * 2}; auto log_completed = [&](const std::filesystem::path& path) { completed_channel.try_send(path); }; boost::signals2::scoped_connection completed_subscription{client_.completed_subscription.connect(log_completed)}; for (const auto& preverified_snapshot : snapshot_config.preverified_snapshots()) { SILK_TRACE << "SnapshotSync: download adding info hash for preverified: " << preverified_snapshot.file_name; client_.add_info_hash(preverified_snapshot.file_name, preverified_snapshot.torrent_hash); } // The same snapshot segment may be downloaded multiple times in case of content change over time and // hence notified for completion multiple times. We need to count each snapshot segment just once here std::unordered_set snapshot_set; // Wait for download completion of all snapshots for (completed = 0; completed < num_snapshots; ++completed) { std::filesystem::path snapshot_file; do { snapshot_file = co_await completed_channel.receive(); } while (snapshot_set.contains(snapshot_file)); const auto [_, inserted] = snapshot_set.insert(snapshot_file); SILKWORM_ASSERT(inserted); SILK_INFO << "SnapshotSync: download completed for: " << snapshot_file.filename().string() << " steps " << SnapshotPath::parse(snapshot_file)->step_range().to_string() << " [" << (completed + 1) << "/" << num_snapshots << "]"; } } Task SnapshotSync::build_missing_indexes() { ThreadPool workers; // on errors do not wait for any remaining indexing tasks that were not started (because of not enough threads) [[maybe_unused]] auto _ = gsl::finally([&workers]() { workers.pause(); }); // Determine the missing indexes and build them in parallel const auto missing_indexes = blocks_repository().missing_indexes(); if (missing_indexes.empty()) { co_return; } SILK_INFO << "SnapshotSync: " << missing_indexes.size() << " missing indexes to build"; const size_t total_tasks = missing_indexes.size(); std::atomic_size_t done_tasks; auto executor = co_await boost::asio::this_coro::executor; concurrency::Channel done_channel{executor, total_tasks}; for (const auto& index : missing_indexes) { workers.push_task([&]() { try { SILK_INFO << "SnapshotSync: building index " << index->path().filename() << " ..."; index->build(); ++done_tasks; SILK_INFO << "SnapshotSync: built index " << index->path().filename() << ";" << " progress: " << (done_tasks * 100 / total_tasks) << "% " << done_tasks << " of " << total_tasks << " indexes ready"; done_channel.try_send(done_tasks); } catch (const std::exception& ex) { SILK_CRIT << "SnapshotSync: build index: " << index->path().filename() << " failed [" << ex.what() << "]"; throw; } }); } // Wait for all missing indexes to be built while (done_tasks < total_tasks) { co_await done_channel.receive(); } SILK_INFO << "SnapshotSync: built missing indexes"; } void SnapshotSync::seed_frozen_local_snapshots() { const auto& repository = blocks_repository(); for (auto& bundle_ptr : repository.view_bundles()) { auto& bundle = *bundle_ptr; auto block_num_range = repository.step_converter().timestamp_range_from_step_range(bundle.step_range()); bool is_frozen = block_num_range.size() >= kMaxMergerSnapshotSize; const segment::SegmentFileReader& first_snapshot = *bundle.segments().begin(); // assume that if one snapshot in the bundle is preverified, then all of them are bool is_preverified = snapshots_config_.contains_file_name(first_snapshot.path().filename()); if (is_frozen && !is_preverified) { seed_bundle(bundle); } } } void SnapshotSync::seed_frozen_bundle(datastore::StepRange range) { bool is_frozen = range.size() >= kMaxMergerSnapshotSize; auto bundle = blocks_repository().find_bundle(range.start); if (bundle && (bundle->step_range() == range) && is_frozen) { seed_bundle(*bundle); } } void SnapshotSync::seed_bundle(SnapshotBundle& bundle) { for (auto& path : bundle.segment_paths()) { seed_snapshot(path); } } void SnapshotSync::seed_snapshot(const SnapshotPath& path) { std::filesystem::path torrent_path = std::filesystem::path{path.path()}.concat(".torrent"); auto torrent_file = std::filesystem::exists(torrent_path) ? bittorrent::TorrentFile{torrent_path} : bittorrent::TorrentFile::from_source_file(path.path()); if (!std::filesystem::exists(torrent_path)) { torrent_file.save(torrent_path); } client_.add_info_hash(path.path().filename().string(), torrent_file.info_hash()); } void SnapshotSync::update_database(RWTxn& txn, BlockNum max_block_available, const std::function& is_stopping) { update_block_headers(txn, max_block_available, is_stopping); update_block_bodies(txn, max_block_available); update_block_hashes(txn, max_block_available); update_block_senders(txn, max_block_available); } void SnapshotSync::update_block_headers(RWTxn& txn, BlockNum max_block_available, const std::function& is_stopping) { // Check if Headers stage progress has already reached the max block in snapshots const auto last_progress{stages::read_stage_progress(txn, stages::kHeadersKey)}; if (last_progress >= max_block_available) { return; } SILK_INFO << "SnapshotSync: database update started"; // Iterate on block header snapshots and write header-related tables datastore::kvdb::Collector hash_to_block_num_collector; intx::uint256 total_difficulty{0}; uint64_t block_count{0}; for (const auto& bundle_ptr : blocks_repository().view_bundles()) { db::blocks::BundleDataRef bundle{**bundle_ptr}; for (const BlockHeader& header : HeaderSegmentReader{bundle.header_segment()}) { SILK_TRACE << "SnapshotSync: header number=" << header.number << " hash=" << Hash{header.hash()}.to_hex(); const auto block_num = header.number; if (block_num > max_block_available) continue; const auto block_hash = header.hash(); // Write block header into kDifficulty table total_difficulty += header.difficulty; write_total_difficulty(txn, block_num, block_hash, total_difficulty); // Write block header into kCanonicalHashes table write_canonical_hash(txn, block_num, block_hash); // Collect entries for later loading kHeaderNumbers table Bytes block_hash_bytes{block_hash.bytes, kHashLength}; Bytes encoded_block_num(sizeof(BlockNum), '\0'); endian::store_big_u64(encoded_block_num.data(), block_num); hash_to_block_num_collector.collect({std::move(block_hash_bytes), std::move(encoded_block_num)}); if (++block_count % 1'000'000 == 0) { SILK_INFO << "SnapshotSync: processing block header=" << block_num << " count=" << block_count; if (is_stopping()) return; } } } datastore::kvdb::PooledCursor header_numbers_cursor{txn, table::kHeaderNumbers}; hash_to_block_num_collector.load(header_numbers_cursor); SILK_INFO << "SnapshotSync: database table HeaderNumbers updated"; // Update head block header in kHeadHeader table const auto canonical_hash{read_canonical_header_hash(txn, max_block_available)}; ensure(canonical_hash.has_value(), "SnapshotSync: no canonical head hash found"); write_head_header_hash(txn, *canonical_hash); SILK_INFO << "SnapshotSync: database table HeadHeader updated"; // Update Headers stage progress to the max block in snapshots (w/ STOP_AT_BLOCK support) const auto stop_at_block = Environment::get_stop_at_block(); const BlockNum stage_progress{stop_at_block ? *stop_at_block : max_block_available}; stages::write_stage_progress(txn, stages::kHeadersKey, stage_progress); SILK_INFO << "SnapshotSync: database Headers stage progress updated [" << stage_progress << "]"; } void SnapshotSync::update_block_bodies(RWTxn& txn, BlockNum max_block_available) { // Check if BlockBodies stage progress has already reached the max block in snapshots const auto last_progress{stages::read_stage_progress(txn, stages::kBlockBodiesKey)}; if (last_progress >= max_block_available) { return; } // Reset sequence for kBlockTransactions table const auto [txn_segment, _] = blocks_repository().find_segment(db::blocks::kTxnSegmentAndIdxNames, max_block_available); ensure(txn_segment.has_value(), "SnapshotSync: snapshots max block not found in any snapshot"); const auto last_tx_id = txn_segment->index.base_data_id() + txn_segment->segment.item_count(); reset_map_sequence(txn, table::kBlockTransactions.name, last_tx_id + 1); SILK_INFO << "SnapshotSync: database table BlockTransactions sequence reset"; // Update BlockBodies stage progress to the max block in snapshots (w/ STOP_AT_BLOCK support) const auto stop_at_block = Environment::get_stop_at_block(); const BlockNum stage_progress{stop_at_block ? *stop_at_block : max_block_available}; stages::write_stage_progress(txn, stages::kBlockBodiesKey, stage_progress); SILK_INFO << "SnapshotSync: database BlockBodies stage progress updated [" << stage_progress << "]"; } void SnapshotSync::update_block_hashes(RWTxn& txn, BlockNum max_block_available) { // Check if BlockHashes stage progress has already reached the max block in snapshots const auto last_progress{stages::read_stage_progress(txn, stages::kBlockHashesKey)}; if (last_progress >= max_block_available) { return; } // Update BlockHashes stage progress to the max block in snapshots (w/ STOP_AT_BLOCK support) const auto stop_at_block = Environment::get_stop_at_block(); const BlockNum stage_progress{stop_at_block ? *stop_at_block : max_block_available}; stages::write_stage_progress(txn, stages::kBlockHashesKey, stage_progress); SILK_INFO << "SnapshotSync: database BlockHashes stage progress updated [" << stage_progress << "]"; } void SnapshotSync::update_block_senders(RWTxn& txn, BlockNum max_block_available) { // Check if Senders stage progress has already reached the max block in snapshots const auto last_progress{stages::read_stage_progress(txn, stages::kSendersKey)}; if (last_progress >= max_block_available) { return; } // Update Senders stage progress to the max block in snapshots (w/ STOP_AT_BLOCK support) const auto stop_at_block = Environment::get_stop_at_block(); const BlockNum stage_progress{stop_at_block ? *stop_at_block : max_block_available}; stages::write_stage_progress(txn, stages::kSendersKey, stage_progress); SILK_INFO << "SnapshotSync: database Senders stage progress updated [" << stage_progress << "]"; } } // namespace silkworm::db ================================================ FILE: silkworm/db/snapshot_sync.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include "access_layer.hpp" #include "data_store.hpp" #include "datastore/kvdb/mdbx.hpp" #include "datastore/snapshot_merger.hpp" #include "datastore/snapshots/bittorrent/client.hpp" #include "datastore/snapshots/common/snapshot_path.hpp" #include "datastore/snapshots/config/config.hpp" #include "datastore/snapshots/snapshot_bundle.hpp" #include "datastore/snapshots/snapshot_repository.hpp" #include "datastore/snapshots/snapshot_settings.hpp" #include "datastore/stage_scheduler.hpp" #include "freezer.hpp" namespace silkworm::db { class SnapshotSync { public: SnapshotSync( snapshots::SnapshotSettings settings, ChainId chain_id, db::DataStoreRef data_store, std::filesystem::path tmp_dir_path, datastore::StageScheduler& stage_scheduler); Task run(); Task download_snapshots(); Task wait_for_setup(); protected: Task setup_and_run(); Task setup(); Task download_snapshots_if_needed(); Task build_missing_indexes(); void seed_frozen_local_snapshots(); void seed_frozen_bundle(datastore::StepRange range); void seed_bundle(snapshots::SnapshotBundle& bundle); void seed_snapshot(const snapshots::SnapshotPath& path); void update_database(db::RWTxn& txn, BlockNum max_block_available, const std::function& is_stopping); void update_block_headers(db::RWTxn& txn, BlockNum max_block_available, const std::function& is_stopping); void update_block_bodies(db::RWTxn& txn, BlockNum max_block_available); static void update_block_hashes(db::RWTxn& txn, BlockNum max_block_available); static void update_block_senders(db::RWTxn& txn, BlockNum max_block_available); snapshots::SnapshotRepository& blocks_repository() { return data_store_.blocks_repository; }; snapshots::SnapshotSettings settings_; const snapshots::Config snapshots_config_; db::DataStoreRef data_store_; snapshots::bittorrent::BitTorrentClient client_; db::Freezer snapshot_freezer_; datastore::SnapshotMerger snapshot_merger_; std::latch is_stopping_latch_; std::atomic_bool setup_done_; concurrency::AwaitableConditionVariable setup_done_cond_var_; std::mutex setup_done_mutex_; }; } // namespace silkworm::db ================================================ FILE: silkworm/db/snapshot_sync_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "snapshot_sync.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::db { using namespace snapshots; using namespace silkworm::test_util; struct SettingsOverrides { bool enabled{true}; bool no_downloader{false}; }; class NoopStageSchedulerAdapter : public datastore::StageScheduler { public: explicit NoopStageSchedulerAdapter() = default; ~NoopStageSchedulerAdapter() override = default; Task schedule(std::function /*callback*/) override { co_return; } }; struct SnapshotSyncTest { db::test_util::TempChainDataStore context; TaskRunner runner; NoopStageSchedulerAdapter stage_scheduler; }; struct SnapshotSyncForTest : public SnapshotSync { using SnapshotSync::blocks_repository; using SnapshotSync::build_missing_indexes; using SnapshotSync::download_snapshots_if_needed; using SnapshotSync::update_block_bodies; using SnapshotSync::update_block_hashes; using SnapshotSync::update_block_headers; using SnapshotSync::update_block_senders; using SnapshotSync::update_database; static SnapshotSettings make_settings( const std::filesystem::path& tmp_dir_path, const SettingsOverrides& overrides) { return SnapshotSettings{ .repository_path = tmp_dir_path, .enabled = overrides.enabled, .no_downloader = overrides.no_downloader, .bittorrent_settings = bittorrent::BitTorrentSettings{ .repository_path = tmp_dir_path / bittorrent::BitTorrentSettings::kDefaultTorrentRepoPath, }, }; } explicit SnapshotSyncForTest(SnapshotSyncTest& test, SettingsOverrides overrides = {}) : SnapshotSync{ make_settings(test.context.dir().snapshots().path(), overrides), kMainnetConfig.chain_id, test.context->ref(), test.context.dir().temp().path(), test.stage_scheduler} {} }; TEST_CASE("SnapshotSync::SnapshotSync", "[db][snapshot][sync]") { SnapshotSyncTest test; CHECK_NOTHROW(SnapshotSyncForTest{test}); } TEST_CASE("SnapshotSync::download_and_index_snapshots", "[db][snapshot][sync]") { SnapshotSyncTest test; SECTION("snapshots disabled") { SnapshotSyncForTest sync{test, SettingsOverrides{.enabled = false}}; test.runner.run(sync.download_snapshots_if_needed()); } SECTION("no download, just reopen") { SnapshotSyncForTest sync{test, SettingsOverrides{.no_downloader = true}}; test.runner.run(sync.download_snapshots_if_needed()); } } TEST_CASE("SnapshotSync::update_block_headers", "[db][snapshot][sync]") { SnapshotSyncTest test; SnapshotSyncForTest snapshot_sync{test}; auto tmp_dir_path = test.context.dir().snapshots().path(); // Create a sample Header snapshot+index snapshots::test_util::SampleHeaderSnapshotFile header_segment_file{tmp_dir_path}; auto& header_segment_path = header_segment_file.path(); auto header_index_builder = HeaderIndex::make(header_segment_path); header_index_builder.set_base_data_id(header_segment_file.block_num_range().start); REQUIRE_NOTHROW(header_index_builder.build()); // Create a sample Body snapshot+index snapshots::test_util::SampleBodySnapshotFile body_segment_file{tmp_dir_path}; auto& body_segment_path = body_segment_file.path(); auto body_index_builder = BodyIndex::make(body_segment_path); body_index_builder.set_base_data_id(body_segment_file.block_num_range().start); REQUIRE_NOTHROW(body_index_builder.build()); // Create a sample Transaction snapshot+indexes snapshots::test_util::SampleTransactionSnapshotFile txn_segment_file{tmp_dir_path}; auto& txn_segment_path = txn_segment_file.path(); REQUIRE_NOTHROW(TransactionIndex::make(body_segment_path, txn_segment_path).build()); REQUIRE_NOTHROW(TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start).build()); // Add a sample Snapshot bundle to the repository auto& repository = snapshot_sync.blocks_repository(); auto step_range = repository.step_converter().step_range_from_timestamp_range({snapshots::test_util::kSampleSnapshotBlockRange.start, snapshots::test_util::kSampleSnapshotBlockRange.end}); SnapshotBundle bundle = repository.open_bundle(step_range); repository.add_snapshot_bundle(std::move(bundle)); // Update the block headers in the database according to the repository content auto& tmp_db = test.context; BlockNum max_block_available = header_segment_file.block_num_range().end - 1; auto is_stopping = [] { return false; }; CHECK_NOTHROW(snapshot_sync.update_block_headers(tmp_db.rw_txn(), max_block_available, is_stopping)); // Expect that the database is correctly populated (N.B. cannot check Difficulty table because of sample snapshots) auto block_is_in_header_numbers = [&](Hash block_hash, BlockNum expected_block_num) { const auto block_num = db::read_block_num(tmp_db.rw_txn(), block_hash); return block_num == expected_block_num; }; auto block_is_canonical = [&](BlockNum block_num, Hash expected_block_hash) { const auto canonical_block_hash = db::read_canonical_header_hash(tmp_db.rw_txn(), block_num); return canonical_block_hash == expected_block_hash; }; const Hash block_1500013_hash{0xbef48d7de01f2d7ea1a7e4d1ed401f73d6d0257a364f6770b25ba51a123ac35f_bytes32}; CHECK(block_is_in_header_numbers(block_1500013_hash, 1'500'013)); CHECK(block_is_canonical(1'500'013, block_1500013_hash)); } } // namespace silkworm::db ================================================ FILE: silkworm/db/snapshot_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include "blocks/bodies/body_index.hpp" #include "blocks/bodies/body_queries.hpp" #include "blocks/headers/header_index.hpp" #include "blocks/headers/header_queries.hpp" #include "blocks/step_block_num_converter.hpp" #include "blocks/transactions/txn_index.hpp" #include "blocks/transactions/txn_queries.hpp" #include "blocks/transactions/txn_segment_word_codec.hpp" #include "blocks/transactions/txn_to_block_index.hpp" #include "datastore/snapshots/index_builder.hpp" #include "datastore/snapshots/segment/segment_reader.hpp" #include "test_util/temp_snapshots.hpp" namespace silkworm::snapshots { namespace test = test_util; using namespace rec_split; using namespace segment; static const SnapshotPath kValidHeadersSegmentPath{*SnapshotPath::parse("v1-014500-015000-headers.seg")}; static constexpr datastore::StepToTimestampConverter kStepConverter = db::blocks::kStepToBlockNumConverter; TEST_CASE("Snapshot::open", "[silkworm][node][snapshot][snapshot]") { TemporaryDirectory tmp_dir; test::TemporarySnapshotFile tmp_snapshot_file{tmp_dir.path(), kValidHeadersSegmentPath.filename(), test::SnapshotHeader{}}; SegmentFileReader snapshot{tmp_snapshot_file.path(), kStepConverter}; CHECK(snapshot.path() == tmp_snapshot_file.path()); CHECK(snapshot.fs_path() == tmp_snapshot_file.path().path()); } TEST_CASE("Snapshot::for_each_item", "[silkworm][node][snapshot][snapshot]") { TemporaryDirectory tmp_dir; test::HelloWorldSnapshotFile hello_world_snapshot_file{tmp_dir.path(), kValidHeadersSegmentPath.filename()}; SegmentFileReader tmp_snapshot{hello_world_snapshot_file.path(), kStepConverter}; CHECK(!tmp_snapshot.empty()); CHECK(tmp_snapshot.item_count() == 1); seg::Decompressor decoder{hello_world_snapshot_file.fs_path()}; auto it = decoder.begin(); auto& word = *it; // Using byte_view_to_string_view causes unresolved linker error on Windows build // https://github.com/catchorg/Catch2/issues/2605 CHECK(bytes_to_string(Bytes{word}) == "hello, world"); CHECK(it.current_word_offset() == 0); CHECK(++it == decoder.end()); } // Skip to avoid Clang ASAN runtime error: reference binding to misaligned address #ifndef SILKWORM_SANITIZE // https://etherscan.io/block/1500013 TEST_CASE("HeaderSnapshot::header_by_number OK", "[silkworm][node][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleHeaderSnapshotFile header_segment_file{tmp_dir.path()}; // contains headers for [1'500'012, 1'500'013] auto& header_segment_path = header_segment_file.path(); auto header_index = HeaderIndex::make(header_segment_path); header_index.set_base_data_id(header_segment_file.block_num_range().start); REQUIRE_NOTHROW(header_index.build()); SegmentFileReader header_segment{header_segment_path, kStepConverter}; AccessorIndex idx_header_hash{header_segment_path.related_path_ext(db::blocks::kIdxExtension)}; HeaderFindByBlockNumSegmentQuery header_by_number{{header_segment, idx_header_hash}}; CHECK(!header_by_number.exec(1'500'011)); CHECK(header_by_number.exec(1'500'012)); const auto header = header_by_number.exec(1'500'013); CHECK(header.has_value()); if (header) { CHECK(header->hash() == 0xbef48d7de01f2d7ea1a7e4d1ed401f73d6d0257a364f6770b25ba51a123ac35f_bytes32); CHECK(header->parent_hash == 0x48a486d69a07e99ed6997eb0f9b8795e4e7d07c0ce5b8ee8e139d653fd1b01c3_bytes32); CHECK(header->ommers_hash == 0x7117cfc18ff9765fb04a0c223722d1cfd20a06e5d7a88778f9f66a2207b0638b_bytes32); CHECK(header->beneficiary == 0xea674fdde714fd979de3edf0f56aa9716b898ec8_address); CHECK(header->state_root == 0xac26fc90b79cd9304f03c925208e377d4e6e4b229ede56eb1728851e656791bc_bytes32); CHECK(header->transactions_root == 0xbc18a809c2ab84e0870c0be8de331e3e0498e31b22cdeb95e07f23a5c7f77f40_bytes32); CHECK(header->receipts_root == 0xc856db90a6c30a0264858960231c4a3f78f557ea83ea4d7ec260c691b0850523_bytes32); CHECK(header->logs_bloom == Bloom{}); CHECK(header->difficulty == 0x1fad3d458f3e); CHECK(header->number == 1'500'013); CHECK(header->gas_limit == 4'712'388); CHECK(header->gas_used == 21'000); CHECK(header->timestamp == 1463003399); CHECK(header->extra_data == *from_hex("0xd783010400844765746887676f312e352e31856c696e7578")); CHECK(header->prev_randao == 0x799895e28a837bbdf28b8ecf5fc0e6251398ecb0ffc7ff5bbb457c21b14ce982_bytes32); CHECK(header->nonce == std::array{0x86, 0x98, 0x76, 0x20, 0x12, 0xb4, 0x6f, 0xef}); } CHECK(!header_by_number.exec(1'500'014)); } // https://etherscan.io/block/1500013 TEST_CASE("BodySnapshot::body_by_number OK", "[silkworm][node][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleBodySnapshotFile body_segment_file{tmp_dir.path()}; // contains bodies for [1'500'012, 1'500'013] auto& body_segment_path = body_segment_file.path(); auto body_index = BodyIndex::make(body_segment_path); body_index.set_base_data_id(body_segment_file.block_num_range().start); REQUIRE_NOTHROW(body_index.build()); SegmentFileReader body_segment{body_segment_path, kStepConverter}; AccessorIndex idx_body_number{body_segment_path.related_path_ext(db::blocks::kIdxExtension)}; BodyFindByBlockNumSegmentQuery body_by_number{{body_segment, idx_body_number}}; CHECK(!body_by_number.exec(1'500'011)); CHECK(body_by_number.exec(1'500'012)); const auto body_for_storage = body_by_number.exec(1'500'013); CHECK(body_for_storage.has_value()); if (body_for_storage) { CHECK(body_for_storage->base_txn_id == 7'341'271); CHECK(body_for_storage->txn_count == 2 + 1); // 2 system txs + 1 tx } // CHECK(!body_segment.body_by_number(1'500'014)); // TODO(canepat) assert in EF, should return std::nullopt instead } // https://etherscan.io/block/1500013 TEST_CASE("TransactionSnapshot::txn_by_id OK", "[silkworm][node][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; auto& body_segment_path = body_segment.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; // contains txs for [1'500'012, 1'500'013] auto& txn_segment_path = txn_segment_file.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); CHECK_NOTHROW(tx_index.build()); SegmentFileReader txn_segment{txn_segment_path, kStepConverter}; AccessorIndex idx_txn_hash{txn_segment_path.related_path_ext(db::blocks::kIdxExtension)}; TransactionFindByIdSegmentQuery txn_by_id{{txn_segment, idx_txn_hash}}; const auto transaction = txn_by_id.exec(7'341'272); CHECK(transaction.has_value()); if (transaction) { CHECK(transaction->type == TransactionType::kLegacy); CHECK(transaction->sender() == 0x68795c4aa09d6f4ed3e5deddf8c2ad3049a601da_address); CHECK(transaction->to == 0xe9ae6ec1117bbfeb89302ce7e632597bc595efae_address); } } // https://etherscan.io/block/1500012 TEST_CASE("TransactionSnapshot::block_num_by_txn_hash OK", "[silkworm][node][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; auto& body_segment_path = body_segment.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; // contains txs for [1'500'012, 1'500'013] auto& txn_segment_path = txn_segment_file.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); REQUIRE_NOTHROW(tx_index.build()); auto tx_index_hash_to_block = TransactionToBlockIndex::make(body_segment_path, txn_segment_path, txn_segment_file.block_num_range().start); REQUIRE_NOTHROW(tx_index_hash_to_block.build()); SegmentFileReader txn_segment{txn_segment_path, kStepConverter}; AccessorIndex idx_txn_hash{txn_segment_path.related_path_ext(db::blocks::kIdxExtension)}; TransactionFindByIdSegmentQuery txn_by_id{{txn_segment, idx_txn_hash}}; AccessorIndex idx_txn_hash_2_block{txn_segment_path.related_path(std::string{db::blocks::kIdxTxnHash2BlockTag}, db::blocks::kIdxExtension)}; TransactionBlockNumByTxnHashSegmentQuery block_num_by_txn_hash{idx_txn_hash_2_block, TransactionFindByHashSegmentQuery{{txn_segment, idx_txn_hash}}}; // block 1'500'012: base_txn_id is 7'341'263, txn_count is 7 auto transaction = txn_by_id.exec(7'341'269); // known txn id in block 1'500'012 CHECK(transaction.has_value()); auto result = block_num_by_txn_hash.exec(transaction->hash()); CHECK(result.has_value()); CHECK(result->first == 1'500'012); // block 1'500'013: base_txn_id is 7'341'272, txn_count is 1 transaction = txn_by_id.exec(7'341'272); // known txn id in block 1'500'013 CHECK(transaction.has_value()); result = block_num_by_txn_hash.exec(transaction->hash()); CHECK(result.has_value()); CHECK(result->first == 1'500'013); // transaction hash not present in snapshot (first txn hash in block 1'500'014) result = block_num_by_txn_hash.exec(0xfa496b4cd9748754a28c66690c283ec9429440eb8609998901216908ad1b48eb_bytes32); CHECK_FALSE(result.has_value()); } // https://etherscan.io/block/1500012 TEST_CASE("TransactionSnapshot::txn_range OK", "[silkworm][node][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; auto& body_segment_path = body_segment.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; // contains txs for [1'500'012, 1'500'013] auto& txn_segment_path = txn_segment_file.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); REQUIRE_NOTHROW(tx_index.build()); SegmentFileReader txn_segment{txn_segment_path, kStepConverter}; AccessorIndex idx_txn_hash{txn_segment_path.related_path_ext(db::blocks::kIdxExtension)}; TransactionRangeFromIdSegmentQuery query{{txn_segment, idx_txn_hash}}; // block 1'500'012: base_txn_id is 7'341'263, txn_count is 7 CHECK(query.exec(7'341'263, 0)->empty()); CHECK(query.exec(7'341'263, 7)->size() == 7); // block 1'500'013: base_txn_id is 7'341'272, txn_count is 1 CHECK(query.exec(7'341'272, 0)->empty()); CHECK(query.exec(7'341'272, 1)->size() == 1); // invalid base_txn_id returns empty CHECK_FALSE(query.exec(0, 1)); CHECK_FALSE(query.exec(10'000'000, 1)); CHECK_FALSE(query.exec(7'341'261, 1)); // before the first system tx CHECK_FALSE(query.exec(7'341'274, 1)); // after the last system tx } TEST_CASE("TransactionSnapshot::txn_rlp_range OK", "[silkworm][node][snapshot][index]") { TemporaryDirectory tmp_dir; test::SampleBodySnapshotFile body_segment{tmp_dir.path()}; auto& body_segment_path = body_segment.path(); test::SampleTransactionSnapshotFile txn_segment_file{tmp_dir.path()}; // contains txs for [1'500'012, 1'500'013] auto& txn_segment_path = txn_segment_file.path(); auto tx_index = TransactionIndex::make(body_segment_path, txn_segment_path); REQUIRE_NOTHROW(tx_index.build()); SegmentFileReader txn_segment{txn_segment_path, kStepConverter}; AccessorIndex idx_txn_hash{txn_segment_path.related_path_ext(db::blocks::kIdxExtension)}; TransactionPayloadRlpRangeFromIdSegmentQuery query{{txn_segment, idx_txn_hash}}; // block 1'500'012: base_txn_id is 7'341'263, txn_count is 7 CHECK(query.exec(7'341'263, 0)->empty()); CHECK(query.exec(7'341'263, 7)->size() == 7); // block 1'500'013: base_txn_id is 7'341'272, txn_count is 1 CHECK(query.exec(7'341'272, 0)->empty()); CHECK(query.exec(7'341'272, 1)->size() == 1); // invalid base_txn_id returns empty CHECK_FALSE(query.exec(0, 1)); CHECK_FALSE(query.exec(10'000'000, 1)); CHECK_FALSE(query.exec(7'341'261, 1)); // before the first system tx CHECK_FALSE(query.exec(7'341'274, 1)); // after the last system tx } #endif // SILKWORM_SANITIZE TEST_CASE("slice_tx_payload", "[silkworm][node][snapshot]") { const std::vector access_list{ {0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae_address, { 0x0000000000000000000000000000000000000000000000000000000000000003_bytes32, 0x0000000000000000000000000000000000000000000000000000000000000007_bytes32, }}, {0xbb9bc244d798123fde783fcc1c72d3bb8c189413_address, {}}, }; SECTION("TransactionType: kLegacy") { Transaction txn{}; txn.type = TransactionType::kLegacy; txn.chain_id = 1; txn.nonce = 12; txn.max_priority_fee_per_gas = 20000000000; txn.max_fee_per_gas = 20000000000; txn.gas_limit = 21000; txn.to = 0x727fc6a68321b754475c668a6abfb6e9e71c169a_address; txn.value = 10 * kEther; txn.data = *from_hex( "a9059cbb000000000213ed0f886efd100b67c7e4ec0a85a7d20dc9716000000000000000000" "00015af1d78b58c4000"); txn.odd_y_parity = true; txn.r = intx::from_string("0xbe67e0a07db67da8d446f76add590e54b6e92cb6b8f9835aeb67540579a27717"); txn.s = intx::from_string("0x2d690516512020171c1ec870f6ff45398cc8609250326be89915fb538e7bd718"); Bytes encoded{}; rlp::encode(encoded, txn); Bytes decoded{}; CHECK_NOTHROW(decoded = slice_tx_payload(encoded)); CHECK(decoded == encoded); // no envelope for legacy tx } SECTION("TransactionType: kAccessList") { Transaction txn{}; txn.type = TransactionType::kAccessList; txn.chain_id = kSepoliaConfig.chain_id; txn.nonce = 7; txn.max_priority_fee_per_gas = 30000000000; txn.max_fee_per_gas = 30000000000; txn.gas_limit = 5748100; txn.to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address; txn.value = 2 * kEther; txn.data = *from_hex("6ebaf477f83e051589c1188bcc6ddccd"); txn.access_list = access_list; txn.odd_y_parity = false; txn.r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"); txn.s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4094"); Bytes encoded{}; rlp::encode(encoded, txn); Bytes decoded{}; CHECK_NOTHROW(decoded = slice_tx_payload(encoded)); CHECK(decoded == encoded.substr(2)); // 2-byte envelope for this access-list tx } SECTION("TransactionType: kDynamicFee") { Transaction txn{}; txn.type = TransactionType::kDynamicFee; txn.chain_id = kSepoliaConfig.chain_id; txn.nonce = 7; txn.max_priority_fee_per_gas = 10000000000; txn.max_fee_per_gas = 30000000000; txn.gas_limit = 5748100; txn.to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address; txn.value = 2 * kEther; txn.data = *from_hex("6ebaf477f83e051589c1188bcc6ddccd"); txn.access_list = access_list; txn.odd_y_parity = false; txn.r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"); txn.s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4094"); Bytes encoded{}; rlp::encode(encoded, txn); Bytes decoded{}; CHECK_NOTHROW(decoded = slice_tx_payload(encoded)); CHECK(decoded == encoded.substr(2)); // 2-byte envelope for this dynamic-fee tx } SECTION("TransactionType: kBlob") { Transaction txn{}; txn.type = TransactionType::kBlob; txn.chain_id = kSepoliaConfig.chain_id; txn.nonce = 7; txn.max_priority_fee_per_gas = 10000000000; txn.max_fee_per_gas = 30000000000; txn.gas_limit = 5748100; txn.to = 0x811a752c8cd697e3cb27279c330ed1ada745a8d7_address; txn.data = *from_hex("04f7"); txn.access_list = access_list; txn.max_fee_per_blob_gas = 123; txn.blob_versioned_hashes = { 0xc6bdd1de713471bd6cfa62dd8b5a5b42969ed09e26212d3377f3f8426d8ec210_bytes32, 0x8aaeccaf3873d07cef005aca28c39f8a9f8bdb1ec8d79ffc25afc0a4fa2ab736_bytes32, }; txn.odd_y_parity = true; txn.r = intx::from_string("0x36b241b061a36a32ab7fe86c7aa9eb592dd59018cd0443adc0903590c16b02b0"); txn.s = intx::from_string("0x5edcc541b4741c5cc6dd347c5ed9577ef293a62787b4510465fadbfe39ee4094"); Bytes encoded{}; rlp::encode(encoded, txn); Bytes decoded{}; CHECK_NOTHROW(decoded = slice_tx_payload(encoded)); CHECK(decoded == encoded.substr(3)); // 3-byte envelope for this blob tx } } } // namespace silkworm::snapshots ================================================ FILE: silkworm/db/stage.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage.hpp" #include #include namespace silkworm::stagedsync { using namespace silkworm::db::stages; Stage::Stage(SyncContext* sync_context, std::string_view stage_name) : sync_context_{sync_context}, stage_name_{stage_name} {} BlockNum Stage::get_progress(db::ROTxn& txn) { return read_stage_progress(txn, stage_name_); } BlockNum Stage::get_prune_progress(db::ROTxn& txn) { return read_stage_prune_progress(txn, stage_name_); } void Stage::set_prune_progress(db::RWTxn& txn, BlockNum progress) { write_stage_prune_progress(txn, stage_name_, progress); } void Stage::update_progress(db::RWTxn& txn, BlockNum progress) { write_stage_progress(txn, stage_name_, progress); } void Stage::check_block_sequence(BlockNum actual, BlockNum expected) { if (actual != expected) { const std::string what{"bad block sequence : expected " + std::to_string(expected) + " got " + std::to_string(actual)}; throw StageError(Stage::Result::kBadChainSequence, what); } } void Stage::throw_if_stopping() { if (is_stopping()) throw StageError(Stage::Result::kAborted); } StageError::StageError(Stage::Result err) : err_{magic_enum::enum_integer(err)}, message_{std::string(magic_enum::enum_name(err))} {} StageError::StageError(Stage::Result err, std::string message) : err_{magic_enum::enum_integer(err)}, message_{std::move(message)} {} } // namespace silkworm::stagedsync ================================================ FILE: silkworm/db/stage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::db { using silkworm::datastore::kvdb::MapConfig; using silkworm::datastore::kvdb::ROTxn; using silkworm::datastore::kvdb::RWTxn; } // namespace silkworm::db namespace silkworm::stagedsync { class StageError; //! \brief Holds information across all stages struct SyncContext { SyncContext() = default; ~SyncContext() = default; SyncContext(const SyncContext&) = delete; // not copyable SyncContext& operator=(const SyncContext&) = delete; // not copyable bool is_first_cycle{true}; // true at start-up (fist sync or sync after a long pause) BlockNum target_block_num{0}; std::optional unwind_point; // if valued sync requires an unwind to this point std::optional previous_unwind_point; std::optional bad_block_hash; // valued if we encountered a bad block }; //! \brief Base Stage interface. All stages MUST inherit from this class and MUST override forward / unwind / //! prune class Stage : public Stoppable { public: enum class [[nodiscard]] Result { kSuccess, // valid chain kUnknownProtocolRuleSet, // kBadChainSequence, // kInvalidProgress, // kInvalidBlock, // invalid chain kInvalidTransaction, // kDecodingError, // kWrongFork, // invalid chain: the persisted canonical chain must be changed kWrongStateRoot, // invalid chain kUnexpectedError, // kDbError, // kAborted, // kStoppedByEnv, // valid chain: encountered "STOP_BEFORE_STAGE" env var kUnspecified, }; enum class OperationType { kNone, // Actually no operation running kForward, // Executing Forward kUnwind, // Executing Unwind kPrune, // Executing Prune }; Stage(SyncContext* sync_context, std::string_view stage_name); //! \brief Forward is called when the stage is executed. The main logic of the stage must be here. //! \param [in] txn : A db transaction holder //! \return Result //! \remarks Must be overridden virtual Stage::Result forward(db::RWTxn& txn) = 0; //! \brief Unwind is called when the stage should be unwound. The unwind logic must be here. //! \param [in] txn : A db transaction holder //! \return Result //! \remarks Must be overridden virtual Stage::Result unwind(db::RWTxn& txn) = 0; //! \brief Prune is called when (part of) stage previously persisted data should be deleted. The pruning logic //! must be here. //! \param [in] txn : A db transaction holder //! \return Result virtual Stage::Result prune(db::RWTxn& txn) = 0; //! \brief Returns the actual progress recorded into db BlockNum get_progress(db::ROTxn& txn); //! \brief Returns the actual prune progress recorded into db BlockNum get_prune_progress(db::ROTxn& txn); //! \brief Set the prune progress into db //! \param [in] txn : A R/W db transaction //! \param [in] progress : Block number reached by pruning process void set_prune_progress(db::RWTxn& txn, BlockNum progress); //! \brief Updates current stage progress void update_progress(db::RWTxn& txn, BlockNum progress); //! \brief Sets the prefix for logging lines produced by stage itself void set_log_prefix(const std::string& prefix) { log_prefix_ = prefix; }; //! \brief This function implementation MUST be thread safe as is called asynchronously from ASIO thread virtual std::vector get_log_progress() { return {}; }; //! \brief Returns the key name of the stage instance std::string_view name() const { return stage_name_; } //! \brief Forces an exception if stage has been requested to stop void throw_if_stopping(); protected: // Shared context across stages SyncContext* sync_context_; std::string_view stage_name_; std::atomic operation_{OperationType::kNone}; // To synchronize access by outer sync loop std::mutex sl_mutex_; std::string log_prefix_; //! \brief Throws if actual block != expected block static void check_block_sequence(BlockNum actual, BlockNum expected); }; //! \brief Stage execution exception class StageError : public std::exception { public: explicit StageError(Stage::Result err); explicit StageError(Stage::Result err, std::string message); ~StageError() noexcept override = default; const char* what() const noexcept override { return message_.c_str(); } int err() const noexcept { return err_; } protected: int err_; std::string message_; }; // Throw StageError exception when result indicates a failure inline void success_or_throw(Stage::Result code) { if (code != Stage::Result::kSuccess) { throw StageError(code); } } // Return true if result indicates that an unwind operation is needed inline bool unwind_needed(Stage::Result result) { return (result == Stage::Result::kWrongFork || result == Stage::Result::kInvalidBlock); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/db/stages.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stages.hpp" #include #include namespace silkworm::db::stages { using namespace silkworm::datastore::kvdb; static BlockNum get_stage_data(ROTxn& txn, std::string_view stage_name, const MapConfig& domain, const char* key_prefix = nullptr) { if (!is_known_stage(stage_name)) { throw std::invalid_argument("Unknown stage name " + std::string(stage_name)); } try { auto cursor = txn.ro_cursor(domain); std::string item_key{stage_name}; if (key_prefix) { item_key.insert(0, std::string(key_prefix)); } auto data{cursor->find(mdbx::slice(item_key.c_str()), /*throw_notfound*/ false)}; if (!data) { return 0; } if (data.value.size() != sizeof(uint64_t)) { throw std::length_error("Expected 8 bytes of data got " + std::to_string(data.value.size())); } return endian::load_big_u64(static_cast(data.value.data())); } catch (const mdbx::exception& ex) { std::string what("Error in " + std::string(__FUNCTION__) + " " + std::string(ex.what())); throw std::runtime_error(what); } } static void set_stage_data(RWTxn& txn, std::string_view stage_name, uint64_t block_num, const MapConfig& domain, const char* key_prefix = nullptr) { if (!is_known_stage(stage_name)) { throw std::invalid_argument("Unknown stage name"); } try { std::string item_key{stage_name}; if (key_prefix) { item_key.insert(0, std::string(key_prefix)); } Bytes stage_progress(sizeof(block_num), 0); endian::store_big_u64(stage_progress.data(), block_num); auto target = txn.rw_cursor(domain); mdbx::slice key(item_key.c_str()); mdbx::slice value = datastore::kvdb::to_slice(stage_progress); target->upsert(key, value); } catch (const mdbx::exception& ex) { std::string what("Error in " + std::string(__FUNCTION__) + " " + std::string(ex.what())); throw std::runtime_error(what); } } BlockNum read_stage_progress(ROTxn& txn, std::string_view stage_name) { return get_stage_data(txn, stage_name, silkworm::db::table::kSyncStageProgress); } BlockNum read_stage_prune_progress(ROTxn& txn, std::string_view stage_name) { return get_stage_data(txn, stage_name, silkworm::db::table::kSyncStageProgress, "prune_"); } void write_stage_progress(RWTxn& txn, std::string_view stage_name, BlockNum block_num) { set_stage_data(txn, stage_name, block_num, silkworm::db::table::kSyncStageProgress); } void write_stage_prune_progress(RWTxn& txn, std::string_view stage_name, BlockNum block_num) { set_stage_data(txn, stage_name, block_num, silkworm::db::table::kSyncStageProgress, "prune_"); } bool is_known_stage(std::string_view stage_name) { if (!stage_name.empty()) { for (auto stage : kAllStages) { if (stage == stage_name) { return true; } } } return false; } } // namespace silkworm::db::stages ================================================ FILE: silkworm/db/stages.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include /* List of stages keys stored into SyncStage table */ namespace silkworm::db::stages { using datastore::kvdb::ROTxn; using datastore::kvdb::RWTxn; //! \brief Headers are downloaded, their Proof-Of-Work validity and chaining is verified inline constexpr std::string_view kHeadersKey{"Headers"}; //! \brief Headers Number are written, fills blockHash => number bucket inline constexpr std::string_view kBlockHashesKey{"BlockHashes"}; //! \brief Block bodies are downloaded, TxHash and UncleHash are getting verified inline constexpr std::string_view kBlockBodiesKey{"Bodies"}; //! \brief "From" recovered from signatures inline constexpr std::string_view kSendersKey{"Senders"}; //! \brief Executing each block w/o building a trie inline constexpr std::string_view kExecutionKey{"Execution"}; //! \brief Generate intermediate hashes, calculate the state root hash inline constexpr std::string_view kIntermediateHashesKey{"IntermediateHashes"}; //! \brief Apply Keccak256 to all the keys in the state inline constexpr std::string_view kHashStateKey{"HashState"}; //! \brief Generating history index for accounts inline constexpr std::string_view kHistoryIndexKey{"HistoryIndex"}; //! \brief Generating history index for accounts inline constexpr std::string_view kAccountHistoryIndexKey{"AccountHistoryIndex"}; //! \brief Generating history index for storage inline constexpr std::string_view kStorageHistoryIndexKey{"StorageHistoryIndex"}; //! \brief Generating logs index (from receipts) inline constexpr std::string_view kLogIndexKey{"LogIndex"}; //! \brief Generating call traces index inline constexpr std::string_view kCallTracesKey{"CallTraces"}; //! \brief Generating transactions lookup index inline constexpr std::string_view kTxLookupKey{"TxLookup"}; //! \brief Triggers stage inline constexpr std::string_view kTriggersStageKey{"Triggers"}; //! \brief Nominal stage after all other stages inline constexpr std::string_view kFinishKey{"Finish"}; //! \brief List of all known stages inline constexpr std::string_view kAllStages[]{ kHeadersKey, kBlockHashesKey, kBlockBodiesKey, kSendersKey, kExecutionKey, kIntermediateHashesKey, kHashStateKey, kHistoryIndexKey, kAccountHistoryIndexKey, kStorageHistoryIndexKey, kLogIndexKey, kCallTracesKey, kTxLookupKey, kTriggersStageKey, kFinishKey, }; //! \brief Stages won't log their "start" if segment is below this threshold inline constexpr size_t kSmallBlockSegmentWidth{0}; //! \brief Some stages will use this threshold to determine if worth regen vs incremental inline constexpr size_t kLargeBlockSegmentWorthRegen{100'000}; //! \brief Reads from db the progress (block number) of the provided stage name //! \param [in] txn : a reference to a ro/rw db transaction //! \param [in] stage_name : the name of the requested stage (must be known see kAllStages[]) //! \return The actual chain block number the stage has reached BlockNum read_stage_progress(ROTxn& txn, std::string_view stage_name); //! \brief Reads from db the prune progress (block number) of the provided stage name //! \param [in] txn : a reference to a ro/rw db transaction //! \param [in] stage_name : the name of the requested stage (must be known see kAllStages[]) //! \return The actual chain block number the stage has pruned its data up to //! \remarks A pruned block_num means the prune stage function has run up to this block_num BlockNum read_stage_prune_progress(ROTxn& txn, std::string_view stage_name); //! \brief Writes into db the progress (block number) for the provided stage name //! \param [in] txn : a reference to a rw db transaction //! \param [in] stage_name : the name of the involved stage (must be known see kAllStages[]) //! \param [in] block_num : the actual chain block number the stage must record void write_stage_progress(RWTxn& txn, std::string_view stage_name, BlockNum block_num); //! \brief Writes into db the prune progress (block number) for the provided stage name //! \param [in] txn : a reference to a rw db transaction //! \param [in] stage_name : the name of the involved stage (must be known see kAllStages[]) //! \param [in] block_num : the actual chain block number the stage must record //! \remarks A pruned block_num means the prune stage function has run up to this block_num void write_stage_prune_progress(RWTxn& txn, std::string_view stage_name, BlockNum block_num); //! \brief Whether the provided stage name is known to Silkworm //! \param [in] stage_name : The name of the stage to check for //! \return Whether it exists in kAllStages[] bool is_known_stage(std::string_view stage_name); } // namespace silkworm::db::stages ================================================ FILE: silkworm/db/state/account_codec.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "account_codec.hpp" #include namespace silkworm::db::state { Bytes AccountCodec::encode_for_storage(const Account& account, bool omit_code_hash) { Bytes res(1, '\0'); uint8_t field_set{0}; if (account.nonce != 0) { field_set |= 1; auto be{endian::to_big_compact(account.nonce)}; res.push_back(static_cast(be.size())); res.append(be); } if (account.balance != 0) { field_set |= 2; auto be{endian::to_big_compact(account.balance)}; res.push_back(static_cast(be.size())); res.append(be); } if (account.incarnation != 0) { field_set |= 4; auto be{endian::to_big_compact(account.incarnation)}; res.push_back(static_cast(be.size())); res.append(be); } if (account.code_hash != kEmptyHash && !omit_code_hash) { field_set |= 8; res.push_back(kHashLength); res.append(account.code_hash.bytes, kHashLength); } res[0] = field_set; return res; } size_t AccountCodec::encoding_length_for_storage(const Account& account) { size_t len{1}; if (account.nonce != 0) { auto be{endian::to_big_compact(account.nonce)}; len += 1 + be.size(); } if (account.balance != 0) { auto be{endian::to_big_compact(account.balance)}; len += 1 + be.size(); } if (account.incarnation != 0) { auto be{endian::to_big_compact(account.incarnation)}; len += 1 + be.size(); } if (account.code_hash != kEmptyHash) { len += 1 + kHashLength; } return len; } static tl::expected validate_encoded_head(ByteView& encoded_payload) noexcept { if (encoded_payload.empty()) { return 0; } if (encoded_payload[0] && encoded_payload.size() == 1) { // Must be at least 2 bytes : field_set + len of payload return tl::unexpected{DecodingError::kInputTooShort}; } if (encoded_payload[0] > 15) { // Can only be at max 1 | 2 | 4 | 8 return tl::unexpected{DecodingError::kInvalidFieldset}; } return encoded_payload[0]; } tl::expected AccountCodec::from_encoded_storage(ByteView encoded_payload) noexcept { const tl::expected field_set{validate_encoded_head(encoded_payload)}; if (!field_set) { return tl::unexpected{field_set.error()}; } Account a; if (field_set == 0) { return a; } size_t pos{1}; for (int i{1}; i < 16; i *= 2) { if (*field_set & i) { uint8_t len = encoded_payload[pos++]; if (encoded_payload.size() < pos + len) { return tl::unexpected{DecodingError::kInputTooShort}; } const auto encoded_value{encoded_payload.substr(pos, len)}; switch (i) { case 1: if (DecodingResult res{endian::from_big_compact(encoded_value, a.nonce)}; !res) { return tl::unexpected{res.error()}; } break; case 2: if (DecodingResult res{endian::from_big_compact(encoded_value, a.balance)}; !res) { return tl::unexpected{res.error()}; } break; case 4: if (DecodingResult res{endian::from_big_compact(encoded_value, a.incarnation)}; !res) { return tl::unexpected{res.error()}; } break; case 8: if (len != kHashLength) { return tl::unexpected{DecodingError::kUnexpectedLength}; } std::memcpy(a.code_hash.bytes, &encoded_value[0], kHashLength); break; default: intx::unreachable(); } pos += len; } } return a; } Bytes AccountCodec::encode_for_storage_v3(const Account& account) { Bytes result; auto write = [&result](ByteView field) { result.push_back(static_cast(field.size())); result.append(field); }; write(endian::to_big_compact(account.nonce)); write(endian::to_big_compact(account.balance)); write((account.code_hash != kEmptyHash) ? ByteView{account.code_hash.bytes, kHashLength} : ByteView{}); write(endian::to_big_compact(account.incarnation)); return result; } tl::expected AccountCodec::from_encoded_storage_v3(ByteView encoded_payload) noexcept { auto read = [&encoded_payload]() -> tl::expected { if (encoded_payload.empty()) { return tl::unexpected{DecodingError::kInputTooShort}; } uint8_t len = encoded_payload[0]; encoded_payload.remove_prefix(1); if (encoded_payload.size() < len) { return tl::unexpected{DecodingError::kInputTooShort}; } ByteView field = encoded_payload.substr(0, len); encoded_payload.remove_prefix(len); return field; }; auto read_and_decode = [&read](auto out_ptr, auto decode) -> DecodingResult { auto field = read(); if (!field) return tl::unexpected{field.error()}; if (field->empty()) return {}; return decode(*field, *out_ptr); }; auto decode_hash = [](ByteView data, evmc_bytes32& out_hash) -> DecodingResult { if (data.size() == kHashLength) { std::memcpy(out_hash.bytes, data.data(), kHashLength); return {}; } return tl::unexpected{DecodingError::kUnexpectedLength}; }; Account account; auto result = read_and_decode(&account.nonce, endian::from_big_compact); if (!result) return tl::unexpected{result.error()}; result = read_and_decode(&account.balance, endian::from_big_compact); if (!result) return tl::unexpected{result.error()}; result = read_and_decode(&account.code_hash, decode_hash); if (!result) return tl::unexpected{result.error()}; result = read_and_decode(&account.incarnation, endian::from_big_compact); if (!result) return tl::unexpected{result.error()}; return account; } tl::expected AccountCodec::incarnation_from_encoded_storage(ByteView encoded_payload) noexcept { const tl::expected field_set{validate_encoded_head(encoded_payload)}; if (!field_set) { return tl::unexpected{field_set.error()}; } if (!(*field_set & /*incarnation mask*/ 4)) { return 0; } size_t pos{1}; uint64_t incarnation{0}; for (int i{1}; i < 8; i *= 2) { if (*field_set & i) { uint8_t len = encoded_payload[pos++]; if (encoded_payload.size() < pos + len) { return tl::unexpected{DecodingError::kInputTooShort}; } switch (i) { case 1: case 2: break; case 4: if (DecodingResult res{endian::from_big_compact(encoded_payload.substr(pos, len), incarnation)}; !res) { return tl::unexpected{res.error()}; } return incarnation; default: intx::unreachable(); } pos += len; } } intx::unreachable(); } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/account_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db::state { struct AccountCodec { //! \brief Encode the account into its binary representation for data storage //! \remarks Erigon (*Account)EncodeForStorage static Bytes encode_for_storage(const Account& account, bool omit_code_hash = false); //! \brief Compute the length of the account binary representation for data storage //! \remarks Erigon (*Account)EncodingLengthForStorage static size_t encoding_length_for_storage(const Account& account); //! \brief Decode an Account from its binary representation for data storage static tl::expected from_encoded_storage(ByteView encoded_payload) noexcept; //! \brief Encode the account into its binary representation for data storage in E3 data format static Bytes encode_for_storage_v3(const Account& account); //! \brief Decode an Account from its binary representation for data storage in E3 data format static tl::expected from_encoded_storage_v3(ByteView encoded_payload) noexcept; //! \brief Return an Account Incarnation from its binary representation for data storage //! \remarks Similar to from_encoded_storage but faster as it parses only incarnation static tl::expected incarnation_from_encoded_storage( ByteView encoded_payload) noexcept; }; struct AccountEncodable : public Account { Bytes encode_for_storage(bool omit_code_hash = false) const { return AccountCodec::encode_for_storage(*this, omit_code_hash); } size_t encoding_length_for_storage() const { return AccountCodec::encoding_length_for_storage(*this); } }; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/account_codec_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "account_codec.hpp" #include #include namespace silkworm::db::state { TEST_CASE("Decode account from storage") { SECTION("Correct payload") { const Bytes encoded{*from_hex("0f01020203e8010520f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239")}; const auto decoded = AccountCodec::from_encoded_storage(encoded); REQUIRE(decoded); CHECK(decoded->nonce == 2); CHECK(decoded->balance == 1000); CHECK(decoded->code_hash == 0xf1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239_bytes32); CHECK(decoded->incarnation == 5); CHECK(AccountCodec::encoding_length_for_storage(*decoded) == encoded.size()); CHECK(AccountCodec::encode_for_storage(*decoded) == encoded); } SECTION("Correct payload only incarnation") { const Bytes encoded{*from_hex("0f01020203e8010520f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239")}; const auto incarnation = AccountCodec::incarnation_from_encoded_storage(encoded); CHECK(incarnation == 5); } SECTION("Empty payload") { const Bytes encoded{}; const auto decoded = AccountCodec::from_encoded_storage(encoded); REQUIRE(decoded); CHECK(decoded->nonce == 0); CHECK(decoded->balance == 0); CHECK(decoded->code_hash == kEmptyHash); CHECK(decoded->incarnation == 0); } SECTION("One zero byte payload") { const Bytes encoded{*from_hex("00")}; CHECK(AccountCodec::from_encoded_storage(encoded)); } SECTION("One non-zero byte payload") { const Bytes encoded{*from_hex("04")}; CHECK(AccountCodec::from_encoded_storage(encoded) == tl::unexpected{DecodingError::kInputTooShort}); } SECTION("One >15 byte head plus 1byte") { const Bytes encoded{*from_hex("1e01")}; CHECK(AccountCodec::from_encoded_storage(encoded) == tl::unexpected{DecodingError::kInvalidFieldset}); } SECTION("Too short payload") { const Bytes encoded{*from_hex("0f")}; CHECK(AccountCodec::from_encoded_storage(encoded) == tl::unexpected{DecodingError::kInputTooShort}); } SECTION("Wrong nonce payload") { const Bytes encoded{*from_hex("01020001")}; CHECK(AccountCodec::from_encoded_storage(encoded) == tl::unexpected{DecodingError::kLeadingZero}); } SECTION("Wrong code_hash payload") { const Bytes encoded{*from_hex("0x0805c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4")}; CHECK(AccountCodec::from_encoded_storage(encoded) == tl::unexpected{DecodingError::kUnexpectedLength}); } } TEST_CASE("AccountCodec::encode_for_storage_v3") { CHECK(AccountCodec::encode_for_storage_v3(Account{2, 3, kEmptyRoot, 4}) == *from_hex("010201032056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210104")); CHECK(AccountCodec::encode_for_storage_v3(Account{2, 3, kEmptyHash, 4}) == *from_hex("01020103000104")); CHECK(AccountCodec::encode_for_storage_v3(Account{0, 3, kEmptyHash, 4}) == *from_hex("000103000104")); CHECK(AccountCodec::encode_for_storage_v3(Account{2, 0, kEmptyHash, 4}) == *from_hex("010200000104")); CHECK(AccountCodec::encode_for_storage_v3(Account{2, 3, kEmptyHash, 0}) == *from_hex("010201030000")); } TEST_CASE("AccountCodec::from_encoded_storage_v3") { const auto decode = [](std::string_view payload) -> tl::expected { return AccountCodec::from_encoded_storage_v3(*from_hex(payload)); }; CHECK(decode("010201032056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210104") == Account{2, 3, kEmptyRoot, 4}); CHECK(decode("01020103000104") == Account{2, 3, kEmptyHash, 4}); CHECK(decode("000103000104") == Account{0, 3, kEmptyHash, 4}); CHECK(decode("010200000104") == Account{2, 0, kEmptyHash, 4}); CHECK(decode("010201030000") == Account{2, 3, kEmptyHash, 0}); CHECK(decode("00000000") == Account{}); CHECK(decode("01020203e820f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c92390105") == Account{2, 1000, 0xf1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239_bytes32, 5}); // wrong nonce CHECK(decode("020001") == tl::unexpected{DecodingError::kLeadingZero}); // wrong code hash CHECK(decode("01020203e822f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c92390105") == tl::unexpected{DecodingError::kUnexpectedLength}); SECTION("Too short payloads") { std::vector payloads{ "", "00", "0000", "000000", "0f", "0102", "01020203e8", "0805c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4", }; for (const auto payload : payloads) { CHECK(decode(payload) == tl::unexpected{DecodingError::kInputTooShort}); } } } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/account_codecs.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "account_codec.hpp" #include "silkworm/db/util.hpp" namespace silkworm::db::state { struct AccountKVDBCodec : public datastore::kvdb::Codec { std::optional value; Bytes data; ~AccountKVDBCodec() override = default; datastore::kvdb::Slice encode() override { if (value) { data = AccountCodec::encode_for_storage_v3(*value); } else { data.clear(); } return datastore::kvdb::to_slice(data); } void decode(datastore::kvdb::Slice slice) override { if (!slice.empty()) { value = unwrap_or_throw(AccountCodec::from_encoded_storage_v3(datastore::kvdb::from_slice(slice)), "AccountKVDBCodec failed to decode Account"); } else { value.reset(); } } }; static_assert(datastore::kvdb::EncoderConcept); static_assert(datastore::kvdb::DecoderConcept); struct AccountSnapshotsCodec : public snapshots::Codec { std::optional value; Bytes word; ~AccountSnapshotsCodec() override = default; ByteView encode_word() override { if (value) { word = AccountCodec::encode_for_storage_v3(*value); } else { word.clear(); } return word; } void decode_word(Word& input_word) override { const ByteView input_word_view = input_word; if (!input_word_view.empty()) { value = unwrap_or_throw(AccountCodec::from_encoded_storage_v3(input_word_view), "AccountSnapshotsCodec failed to decode Account"); } else { value.reset(); } } }; static_assert(snapshots::EncoderConcept); static_assert(snapshots::DecoderConcept); } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/account_codecs_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "account_codecs.hpp" #include #include namespace silkworm::db::state { TEST_CASE("AccountKVDBCodec") { using evmc::literals::operator""_address; using datastore::kvdb::to_slice; AccountKVDBCodec codec; SECTION("encode") { CHECK(codec.encode() == to_slice(*from_hex(""))); codec.value = std::nullopt; CHECK(codec.encode() == to_slice(*from_hex(""))); codec.value = Account{}; CHECK(codec.encode() == to_slice(*from_hex("00000000"))); codec.value = {2, 3, kEmptyRoot, 4}; CHECK(codec.encode() == to_slice(*from_hex("010201032056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210104"))); codec.value = {2, 3, kEmptyHash, 4}; CHECK(codec.encode() == to_slice(*from_hex("01020103000104"))); codec.value = {0, 3, kEmptyHash, 4}; CHECK(codec.encode() == to_slice(*from_hex("000103000104"))); codec.value = {2, 0, kEmptyHash, 4}; CHECK(codec.encode() == to_slice(*from_hex("010200000104"))); codec.value = {2, 3, kEmptyHash, 0}; CHECK(codec.encode() == to_slice(*from_hex("010201030000"))); } SECTION("decode") { codec.decode(to_slice(*from_hex(""))); CHECK(!codec.value); codec.decode(to_slice(*from_hex("00000000"))); CHECK(codec.value == Account{}); codec.decode(to_slice(*from_hex("010201032056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210104"))); CHECK(codec.value == Account{2, 3, kEmptyRoot, 4}); codec.decode(to_slice(*from_hex("01020103000104"))); CHECK(codec.value == Account{2, 3, kEmptyHash, 4}); codec.decode(to_slice(*from_hex("000103000104"))); CHECK(codec.value == Account{0, 3, kEmptyHash, 4}); codec.decode(to_slice(*from_hex("010200000104"))); CHECK(codec.value == Account{2, 0, kEmptyHash, 4}); codec.decode(to_slice(*from_hex("010201030000"))); CHECK(codec.value == Account{2, 3, kEmptyHash, 0}); codec.decode(to_slice(*from_hex("01020203e820f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c92390105"))); CHECK(codec.value == Account{2, 1000, 0xf1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239_bytes32, 5}); } } TEST_CASE("AccountSnapshotsCodec") { using evmc::literals::operator""_address; AccountSnapshotsCodec codec; SECTION("encode") { CHECK(codec.encode_word() == *from_hex("")); codec.value = std::nullopt; CHECK(codec.encode_word() == *from_hex("")); codec.value = Account{}; CHECK(codec.encode_word() == *from_hex("00000000")); codec.value = {2, 3, kEmptyRoot, 4}; CHECK(codec.encode_word() == *from_hex("010201032056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210104")); codec.value = {2, 3, kEmptyHash, 4}; CHECK(codec.encode_word() == *from_hex("01020103000104")); codec.value = {0, 3, kEmptyHash, 4}; CHECK(codec.encode_word() == *from_hex("000103000104")); codec.value = {2, 0, kEmptyHash, 4}; CHECK(codec.encode_word() == *from_hex("010200000104")); codec.value = {2, 3, kEmptyHash, 0}; CHECK(codec.encode_word() == *from_hex("010201030000")); } SECTION("decode") { using Word = snapshots::Decoder::Word; Word word1{*from_hex("")}; codec.decode_word(word1); CHECK(!codec.value); Word word2{*from_hex("00000000")}; codec.decode_word(word2); CHECK(codec.value == Account{}); Word word3{*from_hex("010201032056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210104")}; codec.decode_word(word3); CHECK(codec.value == Account{2, 3, kEmptyRoot, 4}); Word word4{*from_hex("01020103000104")}; codec.decode_word(word4); CHECK(codec.value == Account{2, 3, kEmptyHash, 4}); Word word5{*from_hex("000103000104")}; codec.decode_word(word5); CHECK(codec.value == Account{0, 3, kEmptyHash, 4}); Word word6{*from_hex("010200000104")}; codec.decode_word(word6); CHECK(codec.value == Account{2, 0, kEmptyHash, 4}); Word word7{*from_hex("010201030000")}; codec.decode_word(word7); CHECK(codec.value == Account{2, 3, kEmptyHash, 0}); Word word8{*from_hex("01020203e820f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c92390105")}; codec.decode_word(word8); CHECK(codec.value == Account{2, 1000, 0xf1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239_bytes32, 5}); } } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/accounts_domain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "account_codecs.hpp" #include "address_codecs.hpp" #include "schema_config.hpp" namespace silkworm::db::state { using AccountsDomainKVSegmentReader = snapshots::segment::KVSegmentReader; struct AccountsDomainGetLatestQuery : public datastore::DomainGetLatestQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, AccountKVDBCodec, AccountSnapshotsCodec> { AccountsDomainGetLatestQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : datastore::DomainGetLatestQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, AccountKVDBCodec, AccountSnapshotsCodec>{ db::state::kDomainNameAccounts, database.domain(db::state::kDomainNameAccounts), tx, repository, query_caches, } {} }; struct AccountsDomainPutQuery : public datastore::kvdb::DomainPutQuery { AccountsDomainPutQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainPutQuery{ rw_tx, database.domain(db::state::kDomainNameAccounts)} {} }; struct AccountsDomainDeleteQuery : datastore::kvdb::DomainDeleteQuery { AccountsDomainDeleteQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainDeleteQuery{ rw_tx, database.domain(db::state::kDomainNameAccounts)} {} }; using AccountsHistoryGetQuery = datastore::HistoryGetQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, AccountKVDBCodec, AccountSnapshotsCodec, kHistorySegmentAndIdxNamesAccounts>; using AccountsDomainGetAsOfQuery = datastore::DomainGetAsOfQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, AccountKVDBCodec, AccountSnapshotsCodec, kHistorySegmentAndIdxNamesAccounts>; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/address_codecs.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::db::state { struct AddressKVDBCodec : public datastore::kvdb::Codec { evmc::address value; ~AddressKVDBCodec() override = default; datastore::kvdb::Slice encode() override { return {&value.bytes, kAddressLength}; } void decode(datastore::kvdb::Slice slice) override { if (slice.size() < kAddressLength) throw std::runtime_error{"AddressKVDBDecoder failed to decode"}; std::memcpy(value.bytes, slice.data(), kAddressLength); } }; static_assert(datastore::kvdb::EncoderConcept); static_assert(datastore::kvdb::EncoderConcept); using AddressKVDBEncoder = AddressKVDBCodec; using AddressKVDBDecoder = AddressKVDBCodec; struct AddressSnapshotsCodec : public snapshots::Codec { evmc::address value; ~AddressSnapshotsCodec() override = default; ByteView encode_word() override { return ByteView{reinterpret_cast(&value.bytes), kAddressLength}; } void decode_word(Word& word) override { const ByteView word_view = word; if (word_view.size() < kAddressLength) throw std::runtime_error{"AddressSnapshotsDecoder failed to decode"}; std::memcpy(value.bytes, word_view.data(), kAddressLength); } }; static_assert(snapshots::EncoderConcept); static_assert(snapshots::DecoderConcept); using AddressSnapshotsEncoder = AddressSnapshotsCodec; using AddressSnapshotsDecoder = AddressSnapshotsCodec; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/address_codecs_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "address_codecs.hpp" #include #include namespace silkworm::db::state { TEST_CASE("AddressSnapshotsDecoder") { using evmc::literals::operator""_address; AddressSnapshotsDecoder decoder; auto word = BytesOrByteView{*from_hex("0x000000000000000000636f6e736f6c652e6c6f67")}; decoder.decode_word(word); CHECK(decoder.value == 0x000000000000000000636f6e736f6c652e6c6f67_address); BytesOrByteView empty; CHECK_THROWS_AS(decoder.decode_word(empty), std::runtime_error); } TEST_CASE("AddressSnapshotsEncoder") { using evmc::literals::operator""_address; AddressSnapshotsEncoder encoder; encoder.value = 0x000000000000000000636f6e736f6c652e6c6f67_address; CHECK(encoder.encode_word() == *from_hex("0x000000000000000000636f6e736f6c652e6c6f67")); } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/code_domain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "address_codecs.hpp" #include "schema_config.hpp" namespace silkworm::db::state { using CodeDomainKVSegmentReader = snapshots::segment::KVSegmentReader>; struct CodeDomainGetLatestQuery : public datastore::DomainGetLatestQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder> { CodeDomainGetLatestQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : datastore::DomainGetLatestQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder>{ db::state::kDomainNameCode, database.domain(db::state::kDomainNameCode), tx, repository, query_caches, } {} }; struct CodeDomainPutQuery : public datastore::kvdb::DomainPutQuery> { CodeDomainPutQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainPutQuery>{ rw_tx, database.domain(db::state::kDomainNameCode)} {} }; struct CodeDomainDeleteQuery : datastore::kvdb::DomainDeleteQuery> { CodeDomainDeleteQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainDeleteQuery>{ rw_tx, database.domain(db::state::kDomainNameCode)} {} }; using CodeHistoryGetQuery = datastore::HistoryGetQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder, kHistorySegmentAndIdxNamesCode>; using CodeDomainGetAsOfQuery = datastore::DomainGetAsOfQuery< AddressKVDBEncoder, AddressSnapshotsEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder, kHistorySegmentAndIdxNamesCode>; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/commitment_domain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "schema_config.hpp" namespace silkworm::db::state { using CommitmentDomainKVSegmentReader = snapshots::segment::KVSegmentReader, snapshots::RawDecoder>; struct CommitmentDomainGetLatestQuery : public datastore::DomainGetLatestQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder> { CommitmentDomainGetLatestQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : datastore::DomainGetLatestQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder>{ db::state::kDomainNameCommitment, database.domain(db::state::kDomainNameCommitment), tx, repository, query_caches, } {} }; struct CommitmentDomainPutQuery : public datastore::kvdb::DomainPutQuery, datastore::kvdb::RawEncoder> { CommitmentDomainPutQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainPutQuery, datastore::kvdb::RawEncoder>{ rw_tx, database.domain(db::state::kDomainNameCommitment)} {} }; struct CommitmentDomainDeleteQuery : datastore::kvdb::DomainDeleteQuery, datastore::kvdb::RawEncoder> { CommitmentDomainDeleteQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainDeleteQuery, datastore::kvdb::RawEncoder>{ rw_tx, database.domain(db::state::kDomainNameCommitment)} {} }; using CommitmentHistoryGetQuery = datastore::HistoryGetQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder, kHistorySegmentAndIdxNamesCommitment>; using CommitmentDomainGetAsOfQuery = datastore::DomainGetAsOfQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder, kHistorySegmentAndIdxNamesCommitment>; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/hash_decoder.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::db::state { struct HashSnapshotsDecoder : public snapshots::Decoder { Hash value; ~HashSnapshotsDecoder() override = default; void decode_word(Word& word) override { const ByteView word_view = word; if (word_view.size() < kHashLength) throw std::runtime_error{"HashSnapshotsDecoder failed to decode"}; value = Hash{word_view}; } }; static_assert(snapshots::DecoderConcept); } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/hash_decoder_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "hash_decoder.hpp" #include #include namespace silkworm::db::state { TEST_CASE("HashSnapshotsDecoder") { using evmc::literals::operator""_bytes32; HashSnapshotsDecoder decoder; auto word = BytesOrByteView{*from_hex("0xb397a22bb95bf14753ec174f02f99df3f0bdf70d1851cdff813ebf745f5aeb55")}; decoder.decode_word(word); CHECK(decoder.value == 0xb397a22bb95bf14753ec174f02f99df3f0bdf70d1851cdff813ebf745f5aeb55_bytes32); BytesOrByteView empty; CHECK_THROWS_AS(decoder.decode_word(empty), std::runtime_error); } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/log_address_inverted_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "address_codecs.hpp" namespace silkworm::db::state { using LogAddressInvertedIndexKVSegmentReader = snapshots::segment::KVSegmentReader>; using LogAddressesToInvertedIndexPutQuery = datastore::kvdb::InvertedIndexPutQuery; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/log_topics_inverted_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "hash_decoder.hpp" #include "storage_codecs.hpp" namespace silkworm::db::state { using LogTopicsInvertedIndexKVSegmentReader = snapshots::segment::KVSegmentReader>; using LogTopicsToInvertedIndexPutQuery = datastore::kvdb::InvertedIndexPutQuery; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/receipts_domain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include "schema_config.hpp" namespace silkworm::db::state { enum class ReceiptsDomainKey : uint8_t { kCumulativeGasUsedInBlockKey = 0, kCumulativeBlobGasUsedInBlockKey = 1, kFirstLogIndexKey = 2, }; struct ReceiptsDomainKeySnapshotsDecoder : public snapshots::Decoder { ReceiptsDomainKey value{}; ~ReceiptsDomainKeySnapshotsDecoder() override = default; void decode_word(Word& word) override { const ByteView word_view = word; if (word_view.empty()) throw std::runtime_error{"ReceiptsDomainKeySnapshotsDecoder failed to decode an empty word"}; value = static_cast(word_view[0]); } }; static_assert(snapshots::DecoderConcept); struct VarintSnapshotsDecoder : public snapshots::Decoder { uint64_t value{}; ~VarintSnapshotsDecoder() override = default; void decode_word(Word& word) override { ByteView word_view = word; auto value_opt = snapshots::seg::varint::decode(word_view); if (!value_opt) throw std::runtime_error{"VarintSnapshotsDecoder failed to decode"}; value = *value_opt; } }; static_assert(snapshots::DecoderConcept); struct VarintSnapshotEncoder : public snapshots::Encoder { Bytes& output_buffer; uint64_t value{}; VarintSnapshotEncoder(Bytes& output, uint64_t val) : output_buffer(output), value{val} {} ~VarintSnapshotEncoder() override = default; ByteView encode_word() override { return snapshots::seg::varint::encode(output_buffer, value); } }; static_assert(snapshots::EncoderConcept); using ReceiptsDomainKVSegmentReader = snapshots::segment::KVSegmentReader; struct ReceiptsDomainGetLatestQuery : public datastore::DomainGetLatestQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder> { ReceiptsDomainGetLatestQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : datastore::DomainGetLatestQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder>{ db::state::kDomainNameReceipts, database.domain(db::state::kDomainNameReceipts), tx, repository, query_caches, } {} }; struct ReceiptsDomainPutQuery : public datastore::kvdb::DomainPutQuery, datastore::kvdb::RawEncoder> { ReceiptsDomainPutQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainPutQuery, datastore::kvdb::RawEncoder>{ rw_tx, database.domain(db::state::kDomainNameReceipts)} {} }; struct ReceiptsDomainDeleteQuery : datastore::kvdb::DomainDeleteQuery, datastore::kvdb::RawEncoder> { ReceiptsDomainDeleteQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainDeleteQuery, datastore::kvdb::RawEncoder>{ rw_tx, database.domain(db::state::kDomainNameReceipts)} {} }; using ReceiptsHistoryGetQuery = datastore::HistoryGetQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder, kHistorySegmentAndIdxNamesReceipts>; using ReceiptsDomainGetAsOfQuery = datastore::DomainGetAsOfQuery< datastore::kvdb::RawEncoder, snapshots::RawEncoder, datastore::kvdb::RawDecoder, snapshots::RawDecoder, kHistorySegmentAndIdxNamesReceipts>; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/receipts_domain_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipts_domain.hpp" #include namespace silkworm::db::state { TEST_CASE("ReceiptsDomainKeySnapshotsDecoder") { ReceiptsDomainKeySnapshotsDecoder decoder; BytesOrByteView one{Bytes{1}}; decoder.decode_word(one); CHECK(decoder.value == ReceiptsDomainKey::kCumulativeBlobGasUsedInBlockKey); BytesOrByteView empty; CHECK_THROWS_AS(decoder.decode_word(empty), std::runtime_error); } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/schema_config.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "schema_config.hpp" #include #include #include "../datastore/snapshots/domain_get_latest_query.hpp" #include "../datastore/snapshots/inverted_index_seek_query.hpp" #include "state_index_builders_factory.hpp" #include "step_txn_id_converter.hpp" namespace silkworm::db::state { snapshots::Schema::RepositoryDef make_state_repository_schema_latest() { snapshots::Schema::RepositoryDef schema; schema.index_salt_file_name("salt-state.txt"); schema.step_size(kStepSizeForTemporalSnapshots); schema.domain(kDomainNameAccounts) .tag_override(kDomainAccountsTag); schema.domain(kDomainNameStorage) .kv_segment_compression_kind(snapshots::seg::CompressionKind::kKeys); schema.domain(kDomainNameCode) .kv_segment_compression_kind(snapshots::seg::CompressionKind::kValues); // TODO(canepat): enable after fixing .kvi configuration with IndexList-like implementation // schema.domain(kDomainNameCommitment) // .kv_segment_compression_kind(snapshots::seg::CompressionKind::kKeys); schema.domain(kDomainNameReceipts); return schema; } snapshots::Schema::RepositoryDef make_state_repository_schema_historical() { snapshots::Schema::RepositoryDef schema; schema.index_salt_file_name("salt-state.txt"); schema.step_size(kStepSizeForTemporalSnapshots); schema.history(kDomainNameAccounts) .tag_override(kDomainAccountsTag); schema.history(kDomainNameStorage); schema.history(kDomainNameCode) .segment(snapshots::Schema::kHistorySegmentName) .compression_enabled(true); schema.history(kDomainNameReceipts); schema.inverted_index(kInvIdxNameLogAddress) .tag_override(kInvIdxLogAddressTag); schema.inverted_index(kInvIdxNameLogTopics); schema.inverted_index(kInvIdxNameTracesFrom); schema.inverted_index(kInvIdxNameTracesTo); return schema; } datastore::kvdb::Schema::DatabaseDef make_state_database_schema() { datastore::kvdb::Schema::DatabaseDef schema; schema.domain(kDomainNameAccounts); schema.domain(kDomainNameStorage); schema.domain(kDomainNameCode) .enable_large_values() .values_disable_multi_value(); schema.domain(kDomainNameCommitment) .without_history(); schema.domain(kDomainNameReceipts); schema.inverted_index(kInvIdxNameLogAddress); schema.inverted_index(kInvIdxNameLogTopics); schema.inverted_index(kInvIdxNameTracesFrom); schema.inverted_index(kInvIdxNameTracesTo); return schema; } snapshots::QueryCachesSchema make_query_caches_schema() { snapshots::QueryCachesSchema schema; schema.index_salt_file_name("salt-state.txt"); schema.enable(kDomainNameAccounts); schema.enable(kDomainNameStorage); schema.enable(kDomainNameCode); schema.enable(kDomainNameReceipts); static constexpr size_t kDefaultDomainCacheSize = 10'000; static constexpr size_t kDefaultInvertedIndexCacheSize = 4'096; schema.cache_size(snapshots::DomainGetLatestQueryRawWithCache::kName, kDefaultDomainCacheSize); schema.cache_size(snapshots::InvertedIndexSeekQueryRawWithCache::kName, kDefaultInvertedIndexCacheSize); return schema; } static snapshots::SnapshotRepository make_state_repository( datastore::EntityName name, std::filesystem::path dir_path, bool open, const snapshots::Schema::RepositoryDef& schema, std::optional index_salt) { return snapshots::SnapshotRepository{ std::move(name), std::move(dir_path), open, schema, index_salt, std::make_unique(schema), }; } snapshots::SnapshotRepository make_state_repository_latest( std::filesystem::path dir_path, bool open, std::optional index_salt) { return make_state_repository(kStateRepositoryNameLatest, std::move(dir_path), open, make_state_repository_schema_latest(), index_salt); } snapshots::SnapshotRepository make_state_repository_historical( std::filesystem::path dir_path, bool open, std::optional index_salt) { return make_state_repository(kStateRepositoryNameHistorical, std::move(dir_path), open, make_state_repository_schema_historical(), index_salt); } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/schema_config.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "../datastore/common/entity_name.hpp" #include "../datastore/kvdb/database.hpp" #include "../datastore/kvdb/domain.hpp" #include "../datastore/kvdb/inverted_index.hpp" #include "../datastore/kvdb/schema.hpp" #include "../datastore/snapshots/domain.hpp" #include "../datastore/snapshots/index_builders_factory.hpp" #include "../datastore/snapshots/inverted_index.hpp" #include "../datastore/snapshots/query_caches_schema.hpp" #include "../datastore/snapshots/schema.hpp" #include "../datastore/snapshots/snapshot_repository.hpp" namespace silkworm::db::state { inline const datastore::EntityName kStateRepositoryNameLatest{"StateLatest"}; inline const datastore::EntityName kStateRepositoryNameHistorical{"StateHistorical"}; snapshots::Schema::RepositoryDef make_state_repository_schema_latest(); snapshots::Schema::RepositoryDef make_state_repository_schema_historical(); datastore::kvdb::Schema::DatabaseDef make_state_database_schema(); snapshots::QueryCachesSchema make_query_caches_schema(); snapshots::SnapshotRepository make_state_repository_latest( std::filesystem::path dir_path, bool open = true, std::optional index_salt = std::nullopt); snapshots::SnapshotRepository make_state_repository_historical( std::filesystem::path dir_path, bool open = true, std::optional index_salt = std::nullopt); inline const datastore::EntityName kDomainNameAccounts{"Account"}; inline const datastore::EntityName kDomainNameStorage{"Storage"}; inline const datastore::EntityName kDomainNameCode{"Code"}; inline const datastore::EntityName kDomainNameCommitment{"Commitment"}; inline const datastore::EntityName kDomainNameReceipts{"Receipt"}; inline const datastore::EntityName kInvIdxNameLogAddress{"LogAddress"}; inline const datastore::EntityName kInvIdxNameLogTopics{"LogTopics"}; inline const datastore::EntityName kInvIdxNameTracesFrom{"TracesFrom"}; inline const datastore::EntityName kInvIdxNameTracesTo{"TracesTo"}; inline constexpr std::string_view kDomainAccountsTag{"accounts"}; inline constexpr std::string_view kInvIdxLogAddressTag{"logaddrs"}; struct BundleDataRef { const snapshots::SnapshotBundle& bundle; snapshots::Domain accounts_domain() const { return {bundle.domain(kDomainNameAccounts)}; } snapshots::Domain storage_domain() const { return {bundle.domain(kDomainNameStorage)}; } snapshots::Domain code_domain() const { return {bundle.domain(kDomainNameCode)}; } snapshots::Domain commitment_domain() const { return {bundle.domain(kDomainNameCommitment)}; } snapshots::Domain receipts_domain() const { return {bundle.domain(kDomainNameReceipts)}; } snapshots::InvertedIndex log_address_inverted_index() const { return {bundle.inverted_index(kInvIdxNameLogAddress)}; } snapshots::InvertedIndex log_topics_inverted_index() const { return {bundle.inverted_index(kInvIdxNameLogTopics)}; } snapshots::InvertedIndex traces_from_inverted_index() const { return {bundle.inverted_index(kInvIdxNameTracesFrom)}; } snapshots::InvertedIndex traces_to_inverted_index() const { return {bundle.inverted_index(kInvIdxNameTracesTo)}; } }; struct StateDatabaseRef { const datastore::kvdb::DatabaseRef& database; datastore::kvdb::Domain accounts_domain() const { return {database.domain(kDomainNameAccounts)}; } datastore::kvdb::Domain storage_domain() const { return {database.domain(kDomainNameStorage)}; } datastore::kvdb::Domain code_domain() const { return {database.domain(kDomainNameCode)}; } datastore::kvdb::Domain commitment_domain() const { return {database.domain(kDomainNameCommitment)}; } datastore::kvdb::Domain receipts_domain() const { return {database.domain(kDomainNameReceipts)}; } datastore::kvdb::InvertedIndex log_address_inverted_index() const { return {database.inverted_index(kInvIdxNameLogAddress)}; } datastore::kvdb::InvertedIndex log_topics_inverted_index() const { return {database.inverted_index(kInvIdxNameLogTopics)}; } datastore::kvdb::InvertedIndex traces_from_inverted_index() const { return {database.inverted_index(kInvIdxNameTracesFrom)}; } datastore::kvdb::InvertedIndex traces_to_inverted_index() const { return {database.inverted_index(kInvIdxNameTracesTo)}; } }; inline const snapshots::SegmentAndAccessorIndexNames kHistorySegmentAndIdxNamesAccounts{ kDomainNameAccounts, snapshots::Schema::kHistorySegmentName, snapshots::Schema::kHistoryAccessorIndexName, }; inline const snapshots::SegmentAndAccessorIndexNames kHistorySegmentAndIdxNamesStorage{ kDomainNameStorage, snapshots::Schema::kHistorySegmentName, snapshots::Schema::kHistoryAccessorIndexName, }; inline const snapshots::SegmentAndAccessorIndexNames kHistorySegmentAndIdxNamesCode{ kDomainNameCode, snapshots::Schema::kHistorySegmentName, snapshots::Schema::kHistoryAccessorIndexName, }; inline const snapshots::SegmentAndAccessorIndexNames kHistorySegmentAndIdxNamesCommitment{ kDomainNameCommitment, snapshots::Schema::kHistorySegmentName, snapshots::Schema::kHistoryAccessorIndexName, }; inline const snapshots::SegmentAndAccessorIndexNames kHistorySegmentAndIdxNamesReceipts{ kDomainNameReceipts, snapshots::Schema::kHistorySegmentName, snapshots::Schema::kHistoryAccessorIndexName, }; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/state_index_builders_factory.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_index_builders_factory.hpp" namespace silkworm::db::state { using namespace snapshots; std::vector> StateIndexBuildersFactory::index_builders(const SnapshotPath& /*segment_path*/) const { return {}; } SnapshotPathList StateIndexBuildersFactory::index_dependency_paths(const SnapshotPath& /*index_path*/) const { return {}; } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/state_index_builders_factory.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db::state { class StateIndexBuildersFactory : public snapshots::IndexBuildersFactory { public: StateIndexBuildersFactory() = default; explicit StateIndexBuildersFactory(snapshots::Schema::RepositoryDef schema) : schema_{std::move(schema)} {} ~StateIndexBuildersFactory() override = default; std::vector> index_builders(const snapshots::SnapshotPath& segment_path) const override; snapshots::SnapshotPathList index_dependency_paths(const snapshots::SnapshotPath& index_path) const override; private: snapshots::Schema::RepositoryDef schema_; }; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/step_txn_id_converter.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::db::state { //! Scale factor to convert from-to txn id values in temporal snapshot file names inline constexpr size_t kStepSizeForTemporalSnapshots = 1'562'500; // = 100M / 64 inline constexpr datastore::StepToTimestampConverter kStepToTxnIdConverter{kStepSizeForTemporalSnapshots}; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/storage_codecs.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "storage_codecs.hpp" namespace silkworm::db::state { static_assert(sizeof(StorageAddressAndLocation) == kAddressLength + kHashLength); datastore::kvdb::Slice StorageAddressAndLocationKVDBEncoder::encode() { ByteView data{reinterpret_cast(&value), sizeof(StorageAddressAndLocation)}; return datastore::kvdb::to_slice(data); } ByteView StorageAddressAndLocationSnapshotsCodec::encode_word() { return ByteView{reinterpret_cast(&value), sizeof(StorageAddressAndLocation)}; } void StorageAddressAndLocationKVDBEncoder::decode(datastore::kvdb::Slice slice) { codec.address.decode(slice); slice.remove_prefix(kAddressLength); codec.location_hash.decode(slice); value = {codec.address.value, codec.location_hash.value}; } void StorageAddressAndLocationSnapshotsCodec::decode_word(Word& input_word) { codec.address.decode_word(input_word); auto input_word_remaining = input_word.substr(kAddressLength); codec.location_hash.decode_word(input_word_remaining); value = {codec.address.value, codec.location_hash.value}; } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/storage_codecs.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "address_codecs.hpp" namespace silkworm::db::state { struct Bytes32KVDBCodec : public datastore::kvdb::Codec { evmc::bytes32 value; ~Bytes32KVDBCodec() override = default; datastore::kvdb::Slice encode() override { return {&value.bytes, sizeof(value.bytes)}; } void decode(datastore::kvdb::Slice slice) override { SILKWORM_ASSERT(slice.size() >= sizeof(value.bytes)); std::memcpy(value.bytes, slice.data(), sizeof(value.bytes)); } }; static_assert(datastore::kvdb::EncoderConcept); static_assert(datastore::kvdb::DecoderConcept); struct PackedBytes32KVDBCodec : public datastore::kvdb::Codec { evmc::bytes32 value; ~PackedBytes32KVDBCodec() override = default; datastore::kvdb::Slice encode() override { return {silkworm::zeroless_view(value.bytes)}; } void decode(datastore::kvdb::Slice slice) override { SILKWORM_ASSERT(slice.size() <= sizeof(value.bytes)); value = to_bytes32(silkworm::datastore::kvdb::from_slice(slice)); } }; static_assert(datastore::kvdb::EncoderConcept); static_assert(datastore::kvdb::DecoderConcept); struct Bytes32SnapshotsCodec : public snapshots::Codec { evmc::bytes32 value; ~Bytes32SnapshotsCodec() override = default; ByteView encode_word() override { return ByteView{value.bytes}; } void decode_word(Word& word) override { const ByteView word_view = word; if (word_view.size() < sizeof(value.bytes)) throw std::runtime_error{"Bytes32SnapshotsCodec failed to decode"}; std::memcpy(value.bytes, word_view.data(), sizeof(value.bytes)); } }; static_assert(snapshots::EncoderConcept); static_assert(snapshots::DecoderConcept); struct PackedBytes32SnapshotsCodec : public snapshots::Codec { evmc::bytes32 value; ~PackedBytes32SnapshotsCodec() override = default; ByteView encode_word() override { return silkworm::zeroless_view(ByteView{value}); } void decode_word(Word& word) override { const ByteView word_view = word; if (word_view.size() > sizeof(value.bytes)) throw std::runtime_error{"PackedBytes32SnapshotsCodec failed to decode"}; value = silkworm::to_bytes32(word_view); } }; static_assert(snapshots::EncoderConcept); static_assert(snapshots::DecoderConcept); #pragma pack(push) #pragma pack(1) struct StorageAddressAndLocation { evmc::address address; evmc::bytes32 location_hash; }; #pragma pack(pop) struct StorageAddressAndLocationKVDBCodec : public datastore::kvdb::Codec { StorageAddressAndLocation value; struct { AddressKVDBCodec address; Bytes32KVDBCodec location_hash; } codec; ~StorageAddressAndLocationKVDBCodec() override = default; datastore::kvdb::Slice encode() override; void decode(datastore::kvdb::Slice slice) override; }; static_assert(datastore::kvdb::EncoderConcept); static_assert(datastore::kvdb::DecoderConcept); using StorageAddressAndLocationKVDBEncoder = StorageAddressAndLocationKVDBCodec; using StorageAddressAndLocationKVDBDecoder = StorageAddressAndLocationKVDBCodec; struct StorageAddressAndLocationSnapshotsCodec : public snapshots::Codec { StorageAddressAndLocation value; struct { AddressSnapshotsCodec address; Bytes32SnapshotsCodec location_hash; } codec; ~StorageAddressAndLocationSnapshotsCodec() override = default; ByteView encode_word() override; void decode_word(Word& input_word) override; }; static_assert(snapshots::EncoderConcept); static_assert(snapshots::DecoderConcept); } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/storage_codecs_benchmark.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include "storage_codecs.hpp" namespace silkworm::db::state { template static void fill_random_byte_array(uint8_t (&arr)[kSize]) { static RandomNumber random{0, UINT8_MAX}; for (uint8_t& v : arr) { v = static_cast(random.generate_one()); } } static void storage_address_and_location_encoder(benchmark::State& state) { StorageAddressAndLocationSnapshotsCodec encoder; fill_random_byte_array(encoder.value.address.bytes); fill_random_byte_array(encoder.value.location_hash.bytes); for ([[maybe_unused]] auto _ : state) { ByteView word = encoder.encode_word(); [[maybe_unused]] unsigned char sum = std::accumulate(word.begin(), word.end(), static_cast(0)); } } BENCHMARK(storage_address_and_location_encoder); } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/storage_domain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "schema_config.hpp" #include "storage_codecs.hpp" namespace silkworm::db::state { using StorageDomainKVSegmentReader = snapshots::segment::KVSegmentReader; struct StorageDomainGetLatestQuery : public datastore::DomainGetLatestQuery< StorageAddressAndLocationKVDBEncoder, StorageAddressAndLocationSnapshotsCodec, PackedBytes32KVDBCodec, PackedBytes32SnapshotsCodec> { StorageDomainGetLatestQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::ROTxn& tx, const snapshots::SnapshotRepositoryROAccess& repository, const snapshots::QueryCaches& query_caches) : datastore::DomainGetLatestQuery< StorageAddressAndLocationKVDBEncoder, StorageAddressAndLocationSnapshotsCodec, PackedBytes32KVDBCodec, PackedBytes32SnapshotsCodec>{ db::state::kDomainNameStorage, database.domain(db::state::kDomainNameStorage), tx, repository, query_caches, } {} }; struct StorageDomainPutQuery : public datastore::kvdb::DomainPutQuery { StorageDomainPutQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainPutQuery{ rw_tx, database.domain(db::state::kDomainNameStorage)} {} }; struct StorageDomainDeleteQuery : datastore::kvdb::DomainDeleteQuery { StorageDomainDeleteQuery( const datastore::kvdb::DatabaseRef& database, datastore::kvdb::RWTxn& rw_tx) : datastore::kvdb::DomainDeleteQuery{ rw_tx, database.domain(db::state::kDomainNameStorage)} {} }; using StorageHistoryGetQuery = datastore::HistoryGetQuery< StorageAddressAndLocationKVDBEncoder, StorageAddressAndLocationSnapshotsCodec, PackedBytes32KVDBCodec, PackedBytes32SnapshotsCodec, kHistorySegmentAndIdxNamesStorage>; using StorageDomainGetAsOfQuery = datastore::DomainGetAsOfQuery< StorageAddressAndLocationKVDBEncoder, StorageAddressAndLocationSnapshotsCodec, PackedBytes32KVDBCodec, PackedBytes32SnapshotsCodec, kHistorySegmentAndIdxNamesStorage>; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/storage_domain_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "storage_domain.hpp" #include #include namespace silkworm::db::state { using evmc::literals::operator""_address; using evmc::literals::operator""_bytes32; const evmc::bytes32 kFullWord{0x010000000000000000000000000000000000000000005666856076ebaf477f07_bytes32}; const evmc::bytes32 kPartialWord{0x000000000000000000000000000000000000000000005666856076ebaf477f07_bytes32}; const evmc::bytes32 kEmptyWord{0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}; using Word = snapshots::Decoder::Word; TEST_CASE("Bytes32KVDBCodec.full_word") { Bytes32KVDBCodec codec; codec.value = kFullWord; auto slice = codec.encode(); CHECK(slice.size() == 32); Bytes32KVDBCodec codec2; codec2.decode(slice); CHECK(codec2.value == kFullWord); } TEST_CASE("Bytes32KVDBCodec.partial_word") { Bytes32KVDBCodec codec; codec.value = kPartialWord; auto slice = codec.encode(); CHECK(slice.size() == 32); Bytes32KVDBCodec codec2; codec2.decode(slice); CHECK(codec2.value == kPartialWord); } TEST_CASE("Bytes32KVDBCodec.empty_word") { Bytes32KVDBCodec codec; codec.value = kEmptyWord; auto slice = codec.encode(); CHECK(slice.size() == 32); Bytes32KVDBCodec codec2; codec2.decode(slice); CHECK(codec2.value == kEmptyWord); } TEST_CASE("PackedBytes32KVDBCodec.full_word") { PackedBytes32KVDBCodec codec; codec.value = kFullWord; auto slice = codec.encode(); CHECK(slice.size() == 32); PackedBytes32KVDBCodec codec2; codec2.decode(slice); CHECK(codec2.value == kFullWord); } TEST_CASE("PackedBytes32KVDBCodec.partial_word") { PackedBytes32KVDBCodec codec; codec.value = kPartialWord; auto slice = codec.encode(); CHECK(slice.size() == 10); PackedBytes32KVDBCodec codec2; codec2.decode(slice); CHECK(codec2.value == kPartialWord); } TEST_CASE("PackedBytes32KVDBCodec.empty_word") { PackedBytes32KVDBCodec codec; codec.value = kEmptyWord; auto slice = codec.encode(); CHECK(slice.empty()); PackedBytes32KVDBCodec codec2; codec2.decode(slice); CHECK(codec2.value == kEmptyWord); } TEST_CASE("StorageAddressAndLocationKVDBEncoder.encode") { StorageAddressAndLocationKVDBEncoder encoder; encoder.value.address = 0x000000000000000000636f6e736f6c652e6c6f67_address; encoder.value.location_hash = 0x000000000000000000000000000000000000000000005666856076ebaf477f07_bytes32; auto encoded_view = silkworm::datastore::kvdb::from_slice(encoder.encode()); CHECK( encoded_view == *from_hex( "000000000000000000636f6e736f6c652e6c6f67" "000000000000000000000000000000000000000000005666856076ebaf477f07")); } TEST_CASE("Bytes32SnapshotsCodec.full_word") { Bytes32SnapshotsCodec codec; codec.value = kFullWord; auto encoded = codec.encode_word(); CHECK(encoded.size() == 32); Bytes32SnapshotsCodec codec2; Word encoded_bytes{encoded}; codec2.decode_word(encoded_bytes); CHECK(codec2.value == kFullWord); } TEST_CASE("Bytes32SnapshotsCodec.partial_word") { Bytes32SnapshotsCodec codec; codec.value = kPartialWord; auto encoded = codec.encode_word(); CHECK(encoded.size() == 32); Bytes32SnapshotsCodec codec2; Word encoded_bytes{encoded}; codec2.decode_word(encoded_bytes); CHECK(codec2.value == kPartialWord); } TEST_CASE("Bytes32SnapshotsCodec.empty_word") { Bytes32SnapshotsCodec codec; codec.value = kEmptyWord; auto encoded = codec.encode_word(); CHECK(encoded.size() == 32); Bytes32SnapshotsCodec codec2; Word encoded_bytes{encoded}; codec2.decode_word(encoded_bytes); CHECK(codec2.value == kEmptyWord); } TEST_CASE("PackedBytes32SnapshotsCodec.full_word") { PackedBytes32SnapshotsCodec codec; codec.value = kFullWord; auto encoded = codec.encode_word(); CHECK(encoded.size() == 32); PackedBytes32SnapshotsCodec codec2; Word encoded_bytes{encoded}; codec2.decode_word(encoded_bytes); CHECK(codec2.value == kFullWord); } TEST_CASE("PackedBytes32SnapshotsCodec.partial_word") { PackedBytes32SnapshotsCodec codec; codec.value = kPartialWord; auto encoded = codec.encode_word(); CHECK(encoded.size() == 10); PackedBytes32SnapshotsCodec codec2; Word encoded_bytes{encoded}; codec2.decode_word(encoded_bytes); CHECK(codec2.value == kPartialWord); } TEST_CASE("PackedBytes32SnapshotsCodec.empty_word") { PackedBytes32SnapshotsCodec codec; codec.value = kEmptyWord; auto encoded = codec.encode_word(); CHECK(encoded.empty()); PackedBytes32SnapshotsCodec codec2; Word encoded_bytes{encoded}; codec2.decode_word(encoded_bytes); CHECK(codec2.value == kEmptyWord); } TEST_CASE("StorageAddressAndLocationSnapshotsCodec.decode_word") { StorageAddressAndLocationSnapshotsCodec decoder; Word word{*from_hex( "000000000000000000636f6e736f6c652e6c6f67" "000000000000000000000000000000000000000000005666856076ebaf477f07")}; decoder.decode_word(word); CHECK(decoder.value.address == 0x000000000000000000636f6e736f6c652e6c6f67_address); CHECK(decoder.value.location_hash == 0x000000000000000000000000000000000000000000005666856076ebaf477f07_bytes32); Word empty; CHECK_THROWS_AS(decoder.decode_word(empty), std::runtime_error); } TEST_CASE("StorageAddressAndLocationSnapshotsCodec.encode_word") { StorageAddressAndLocationSnapshotsCodec encoder; encoder.value.address = 0x000000000000000000636f6e736f6c652e6c6f67_address; encoder.value.location_hash = 0x000000000000000000000000000000000000000000005666856076ebaf477f07_bytes32; CHECK( encoder.encode_word() == *from_hex( "000000000000000000636f6e736f6c652e6c6f67" "000000000000000000000000000000000000000000005666856076ebaf477f07")); } } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/traces_from_inverted_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "address_codecs.hpp" namespace silkworm::db::state { using TracesFromInvertedIndexKVSegmentReader = snapshots::segment::KVSegmentReader>; using TracesFromInvertedIndexPutQuery = datastore::kvdb::InvertedIndexPutQuery; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/state/traces_to_inverted_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "address_codecs.hpp" namespace silkworm::db::state { using TracesToInvertedIndexKVSegmentReader = snapshots::segment::KVSegmentReader>; using TracesToInvertedIndexPutQuery = datastore::kvdb::InvertedIndexPutQuery; } // namespace silkworm::db::state ================================================ FILE: silkworm/db/tables.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "tables.hpp" #include #include namespace silkworm::db::table { void check_or_create_chaindata_tables(RWTxn& txn) { for (const auto& config : kChainDataTables) { if (has_map(txn, config.name)) { ::mdbx::map_handle table_map = txn->open_map(config.name_str()); auto table_info{txn->get_handle_info(table_map)}; auto table_key_mode{table_info.key_mode()}; auto table_value_mode{table_info.value_mode()}; if (table_key_mode != config.key_mode || table_value_mode != config.value_mode) { throw std::runtime_error("MDBX Table schema incompatible: " + std::string(config.name) + " has incompatible flags."); } continue; } // Create missing table (void)txn->create_map(config.name_str(), config.key_mode, config.value_mode); // Will throw if tx is RO } auto db_schema_version{db::read_schema_version(txn)}; if (!db_schema_version.has_value()) { db::write_schema_version(txn, kRequiredSchemaVersion); } else if (db_schema_version.value() != kRequiredSchemaVersion) { throw std::runtime_error("Incompatible schema version. Expected " + kRequiredSchemaVersion.to_string() + " got " + db_schema_version.value().to_string()); } } std::optional get_map_config(std::string_view map_name) { for (const auto& table_config : kChainDataTables) { if (table_config.name == map_name) { return table_config; } } return std::nullopt; } } // namespace silkworm::db::table ================================================ FILE: silkworm/db/tables.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include /// Part of the compatibility layer with the Erigon DB format. namespace silkworm::db::table { using datastore::kvdb::MapConfig; //! Database schema version for compatibility w/ Erigon //! 5.0 - BlockTransaction table has canonical IDs (txs of non-canonical blocks moved to NonCanonicalTransaction table) //! 6.0 - BlockTransaction table has system-txs before/after each block (absent if block has no system-tx, but sequence increasing) //! 6.1 - BlockTransaction table contains canonical/non-canonical/bad-block transactions; add BadBlockNumber table inline constexpr VersionBase kRequiredSchemaVersion{6, 1, 0}; // Erigon2 latest schema version /* Canonical tables */ //! \details At block N stores value of state of account for block N-1. //! \struct //! \verbatim //! key : block_num_u64 (BE) //! value : address + previous_account (encoded) //! \endverbatim //! \example If block N changed account A from value X to Y. Then: //! \verbatim //! key : block_num_u64 (BE) //! value : address + X //! \endverbatim inline constexpr std::string_view kAccountChangeSetName{"AccountChangeSet"}; inline constexpr MapConfig kAccountChangeSet{kAccountChangeSetName, mdbx::key_mode::usual, mdbx::value_mode::multi}; //! \details Holds the list of blocks in which a specific account has been changed //! \struct //! \verbatim //! key : plain account address (20 bytes) + suffix (BE 64bit unsigned integer) //! value : binary bitmap holding list of blocks including a state change for the account //! \endverbatim //! \remark Each record's key holds a suffix which is a 64bit unsigned integer specifying the "upper bound" limit //! of the list of blocks contained in value part. When this integer is equal to UINT64_MAX it means this //! record holds the last known chunk of blocks which have changed the account. This is due to //! how RoaringBitmap64 work. //! \remark This table/bucket indexes the contents of PlainState (Account record type) therefore honoring the //! same content limits wrt pruning inline constexpr std::string_view kAccountHistoryName{"AccountHistory"}; inline constexpr MapConfig kAccountHistory{kAccountHistoryName}; //! \details Holds block body data //! \struct //! \verbatim //! key : block number (BE 8 bytes) + block header hash (32 bytes) //! value : block body data RLP encoded //! \endverbatim inline constexpr std::string_view kBlockBodiesName{"BlockBody"}; inline constexpr MapConfig kBlockBodies{kBlockBodiesName}; //! \details Stores the binding of *canonical* block number with header hash //! \struct //! \verbatim //! key : block_num_u64 (BE) //! value : header_hash //! \endverbatim inline constexpr std::string_view kCanonicalHashesName{"CanonicalHeader"}; inline constexpr MapConfig kCanonicalHashes{kCanonicalHashesName}; //! \details Stores the headers downloaded from peers //! \struct //! \verbatim //! key : block_num_u64 (BE) + header hash //! value : header RLP encoded //! \endverbatim inline constexpr std::string_view kHeadersName{"Header"}; inline constexpr MapConfig kHeaders{kHeadersName}; //! \details Stores the total difficulty accrued at each block number //! \struct //! \verbatim //! key : block_num_u64 (BE) + header hash //! value : total difficulty (RLP encoded //! \endverbatim inline constexpr std::string_view kDifficultyName{"HeadersTotalDifficulty"}; inline constexpr MapConfig kDifficulty{kDifficultyName}; //! \details Stores the receipts for every canonical block //! \remarks Non canonical blocks' receipts are not stored //! \struct //! \verbatim //! key : block_num_u64 (BE) //! value : receipts (CBOR Encoded) //! \endverbatim inline constexpr std::string_view kBlockReceiptsName{"Receipt"}; inline constexpr MapConfig kBlockReceipts{kBlockReceiptsName}; //! \details Stores the mapping of block number to the set (sorted) of all accounts touched by call traces. //! \struct //! \verbatim //! key : block_num_u64 (BE) //! value : account address + two bits (one for "from" + another for "to") //! \endverbatim inline constexpr std::string_view kCallTraceSetName{"CallTraceSet"}; inline constexpr MapConfig kCallTraceSet{kCallTraceSetName, mdbx::key_mode::usual, mdbx::value_mode::multi}; //! \details Stores the list of blocks in which a specific call sender (i.e. "from") has been traced //! \struct //! \verbatim //! key : address (20 bytes) + suffix (BE 64bit unsigned integer) //! value : binary bitmap holding list of blocks //! \endverbatim //! \remark Each record key holds a suffix which is a 64bit unsigned integer specifying the "upper bound" limit //! of the list of blocks contained in the value part. When this integer is equal to UINT64_MAX, it means this //! record holds the last known chunk of blocks which contain the address as sender for some call. This is due //! to how roaring bitmaps work. inline constexpr std::string_view kCallFromIndexName{"CallFromIndex"}; inline constexpr MapConfig kCallFromIndex{kCallFromIndexName}; //! \details Stores the list of blocks in which a specific call receiver (i.e. "to") has been traced //! \struct //! \verbatim //! key : address (20 bytes) + suffix (BE 64bit unsigned integer) //! value : binary bitmap holding list of blocks //! \endverbatim //! \remark Each record key holds a suffix which is a 64bit unsigned integer specifying the "upper bound" limit //! of the list of blocks contained in the value part. When this integer is equal to UINT64_MAX, it means this //! record holds the last known chunk of blocks which contain the address as receiver for some call. This is due //! to how roaring bitmaps work. inline constexpr std::string_view kCallToIndexName{"CallToIndex"}; inline constexpr MapConfig kCallToIndex{kCallToIndexName}; //! \details Stores contract's code //! \struct //! \verbatim //! key : contract code hash //! value : contract code //! \endverbatim inline constexpr std::string_view kCodeName{"Code"}; inline constexpr MapConfig kCode{kCodeName}; inline constexpr std::string_view kConfigName{"Config"}; inline constexpr MapConfig kConfig{kConfigName}; inline constexpr std::string_view kDatabaseInfoName{"DbInfo"}; inline constexpr MapConfig kDatabaseInfo{kDatabaseInfoName}; inline constexpr std::string_view kBlockTransactionsName{"BlockTransaction"}; inline constexpr MapConfig kBlockTransactions{kBlockTransactionsName}; //! \details Store "current" state for accounts with hashed address key //! \remarks This table stores the same values for PlainState (Account record type) but with hashed key //! \struct //! \verbatim //! key : account address hash (32 bytes) //! value : account encoded for storage //! \endverbatim inline constexpr std::string_view kHashedAccountsName{"HashedAccount"}; inline constexpr MapConfig kHashedAccounts{kHashedAccountsName}; //! \details Store contract code hash for given contract by key hashed address + incarnation //! \remarks This table stores the same values for PlainCodeHash but with hashed key address //! \def "Incarnation" how many times given account was SelfDestruct'ed. //! \struct //! \verbatim //! key : contract address hash (32 bytes) + incarnation (u64 BE) //! value : code hash (32 bytes) //! \endverbatim inline constexpr MapConfig kHashedCodeHash{"HashedCodeHash"}; //! \details Store "current" state for contract storage with hashed address //! \remarks This table stores the same values for PlainState (storage record type) but with hashed key //! \struct //! \verbatim //! key : contract address hash (32 bytes) + incarnation (u64 BE) //! value : storage key hash (32 bytes) + storage value (hash 32 bytes) //! \endverbatim inline constexpr std::string_view kHashedStorageName{"HashedStorage"}; inline constexpr MapConfig kHashedStorage{kHashedStorageName, mdbx::key_mode::usual, mdbx::value_mode::multi}; inline constexpr std::string_view kHeadBlockName{"LastBlock"}; inline constexpr MapConfig kHeadBlock{kHeadBlockName}; //! \details Store last canonical header hash for ease of access and performance //! \remarks This table stores the last record present also in Headers //! \struct //! \verbatim //! key : "LastHeader" as bytes //! value : last header hash (32 bytes) //! \endverbatim inline constexpr std::string_view kHeadHeaderName{"LastHeader"}; inline constexpr MapConfig kHeadHeader{kHeadHeaderName}; inline constexpr std::string_view kHeaderNumbersName{"HeaderNumber"}; inline constexpr MapConfig kHeaderNumbers{kHeaderNumbersName}; //! \details Stores the last incarnation of last contract SelfDestruct //! \struct //! \verbatim //! key : contract address (unhashed 20 bytes) //! value : incarnation (u64 BE) //! \endverbatim inline constexpr std::string_view kIncarnationMapName{"IncarnationMap"}; inline constexpr MapConfig kIncarnationMap{kIncarnationMapName}; //! \details Holds the list of blocks in which a specific log address has been touched //! \struct //! \verbatim //! key : address (20 bytes) + suffix (BE 32bit unsigned integer) //! value : binary bitmap holding list of blocks //! \endverbatim //! \remark Each record's key holds a suffix which is a 32bit unsigned integer specifying the "upper bound" limit //! of the list of blocks contained in value part. When this integer is equal to UINT32_MAX it means this //! record holds the last known chunk of blocks which have changed the account. This is due to //! how roaring bitmaps work. inline constexpr std::string_view kLogAddressIndexName{"LogAddressIndex"}; inline constexpr MapConfig kLogAddressIndex{kLogAddressIndexName}; //! \details Holds the list of blocks in which a specific log topic has been touched //! \struct //! \verbatim //! key : hash (32 bytes) + suffix (BE 32bit unsigned integer) //! value : binary bitmap holding list of blocks //! \endverbatim //! \remark Each record's key holds a suffix which is a 32bit unsigned integer specifying the "upper bound" limit //! of the list of blocks contained in value part. When this integer is equal to UINT32_MAX it means this //! record holds the last known chunk of blocks which have changed the account. This is due to //! how roaring bitmaps work. inline constexpr std::string_view kLogTopicIndexName{"LogTopicIndex"}; inline constexpr MapConfig kLogTopicIndex{kLogTopicIndexName}; //! \details Stores the logs for every transaction in canonical blocks //! \remarks Non canonical blocks' transactions logs are not stored //! \struct //! \verbatim //! key : block_num_u64 (BE) + transaction_index_u32 (BE) //! value : logs of transaction (CBOR Encoded) //! \endverbatim inline constexpr std::string_view kLogsName{"TransactionLog"}; inline constexpr MapConfig kLogs{kLogsName}; inline constexpr std::string_view kMigrationsName{"Migration"}; inline constexpr MapConfig kMigrations{kMigrationsName}; //! \details Store contract code hash for given contract address + incarnation //! \def "Incarnation" how many times given account was SelfDestruct'ed. //! \struct //! \verbatim //! key : contract address (20 bytes) + incarnation (u64 BE) //! value : code hash (32 bytes) //! \endverbatim inline constexpr std::string_view kPlainCodeHashName{"PlainCodeHash"}; inline constexpr MapConfig kPlainCodeHash{kPlainCodeHashName}; //! \details Store "current" state for accounts and storage and is used for block execution //! \def "Incarnation" how many times given account was SelfDestruct'ed. //! \struct //! \verbatim //! Accounts : //! key : address (20 bytes) //! value : account encoded for storage //! Storage : //! key : address (20 bytes) + incarnation (u64 BE) //! value : storage key (32 bytes) + storage value (hash 32 bytes) //! \endverbatim inline constexpr std::string_view kPlainStateName{"PlainState"}; inline constexpr MapConfig kPlainState{kPlainStateName, mdbx::key_mode::usual, mdbx::value_mode::multi}; //! \details Store recovered senders' addresses for each transaction in a block //! \remarks Senders' addresses are not stored in transactions so they must be recovered from the signature //! of the transaction itself //! \struct //! \verbatim //! key : block_num_u64 (BE) + block_hash //! value : array of addresses (each 20 bytes) //! The addresses in array are listed in the same order of the transactions of the block //! \endverbatim inline constexpr std::string_view kSendersName{"TxSender"}; inline constexpr MapConfig kSenders{kSendersName}; //! \details Stores sequence values for different keys //! \remarks Usually keys are table names //! \struct //! \verbatim //! key : a string //! value : last increment generated (u64 BE) //! \endverbatim inline constexpr std::string_view kSequenceName{"Sequence"}; inline constexpr MapConfig kSequence{kSequenceName}; //! \details At block N stores value of state of storage for block N-1. //! \struct //! \verbatim //! key : block_num_u64 (BE) + address + incarnation_u64 (BE) //! value : plain_storage_location (32 bytes) + previous_value (no leading zeros) //! \endverbatim //! \example If block N changed storage from value X to Y. Then: //! \verbatim //! key : block_num_u64 (BE) + address + incarnation_u64 (BE) //! value : plain_storage_location (32 bytes) + X //! \endverbatim inline constexpr std::string_view kStorageChangeSetName{"StorageChangeSet"}; inline constexpr MapConfig kStorageChangeSet{kStorageChangeSetName, mdbx::key_mode::usual, mdbx::value_mode::multi}; //! \details Holds the list of blocks in which a specific storage location has been changed //! \struct //! \verbatim //! key : plain contract account address (20 bytes) + location (32 bytes hash) + suffix (BE 64bit unsigned integer) //! value : binary bitmap holding list of blocks including a state change for the account //! \endverbatim //! \remark Each record's key holds a suffix which is a 64bit unsigned integer specifying the "upper bound" limit //! of the list of blocks contained in value part. When this integer is equal to UINT64_MAX it means this //! record holds the last known chunk of blocks which have changed the account. This is due to //! how RoaringBitmap64 work. //! \remark This table/bucket indexes the contents of PlainState (Account record type) therefore honoring the //! same content limits wrt pruning inline constexpr std::string_view kStorageHistoryName{"StorageHistory"}; inline constexpr MapConfig kStorageHistory{kStorageHistoryName}; //! \details Stores reached progress for each stage //! \struct //! \verbatim //! key : stage name //! value : block_num_u64 (BE) //! \endverbatim inline constexpr std::string_view kSyncStageProgressName{"SyncStage"}; inline constexpr MapConfig kSyncStageProgress{kSyncStageProgressName}; //! \brief Hold the nodes composing the StateRoot //! \verbatim //! key : node key //! value : serialized node value (see core::trie::Node) //! \endverbatim //! \remark The only record with empty key is the root node inline constexpr std::string_view kTrieOfAccountsName{"TrieAccount"}; inline constexpr MapConfig kTrieOfAccounts{kTrieOfAccountsName}; //! \brief Hold the nodes composing the StorageRoot for each contract //! \verbatim //! key : db::kHashedStoragePrefix(40 bytes == hashed address + incarnation) + node key //! value : serialized node value (see core::trie::Node) //! \endverbatim //! \remark Each trie has its own invariant db::kHashedStoragePrefix //! \remark Records with key len == 40 (ie node key == 0) are root nodes inline constexpr std::string_view kTrieOfStorageName{"TrieStorage"}; inline constexpr MapConfig kTrieOfStorage{kTrieOfStorageName}; inline constexpr std::string_view kTxLookupName{"BlockTransactionLookup"}; inline constexpr MapConfig kTxLookup{kTxLookupName}; inline constexpr std::string_view kLastForkchoiceName{"LastForkchoice"}; inline constexpr MapConfig kLastForkchoice{kLastForkchoiceName}; //! \brief Hold the maximum canonical transaction number for each block //! \verbatim //! key: block_num_u64 (BE) //! value: max_tx_num_in_block_u64 (BE) //! \endverbatim //! \details In Erigon3: table MaxTxNum storing TxNum (not TxnID). History/Indices are using TxNum (not TxnID). inline constexpr std::string_view kMaxTxNumName{"MaxTxNum"}; inline constexpr MapConfig kMaxTxNum{kMaxTxNumName}; inline constexpr MapConfig kChainDataTables[]{ kAccountChangeSet, kAccountHistory, kBlockBodies, kBlockReceipts, kCallFromIndex, kCallToIndex, kCallTraceSet, kCanonicalHashes, kHeaders, kDifficulty, kCode, kConfig, kHashedCodeHash, kDatabaseInfo, kBlockTransactions, kHashedAccounts, kHashedStorage, kHeadBlock, kHeadHeader, kHeaderNumbers, kIncarnationMap, kLastForkchoice, kLogAddressIndex, kLogTopicIndex, kLogs, kMaxTxNum, kMigrations, kPlainCodeHash, kPlainState, kSenders, kSequence, kStorageChangeSet, kStorageHistory, kSyncStageProgress, kTrieOfAccounts, kTrieOfStorage, kTxLookup, }; //! \brief Ensures all defined tables are present in db with consistent flags. Should a table not exist it gets created void check_or_create_chaindata_tables(datastore::kvdb::RWTxn& txn); //! \brief Get the table config associated to the table name (if any) std::optional get_map_config(std::string_view map_name); /// Part of the compatibility layer with Erigon snapshot format //! \details Domain storing the account common information inline constexpr std::string_view kAccountDomain{"accounts"}; inline constexpr std::string_view kStorageDomain{"storage"}; inline constexpr std::string_view kCodeDomain{"code"}; inline constexpr std::string_view kCommitmentDomain{"commitment"}; inline constexpr std::string_view kReceiptDomain{"receipt"}; //! \details Inverted Index storing the account common information inline constexpr std::string_view kAccountsHistoryIdx{"AccountsHistoryIdx"}; inline constexpr std::string_view kStorageHistoryIdx{"StorageHistoryIdx"}; inline constexpr std::string_view kCodeHistoryIdx{"CodeHistoryIdx"}; inline constexpr std::string_view kCommitmentHistoryIdx{"CommitmentHistoryIdx"}; inline constexpr std::string_view kReceiptHistoryIdx{"ReceiptHistoryIdx"}; inline constexpr std::string_view kTracesFromIdx{"TracesFromIdx"}; inline constexpr std::string_view kTracesToIdx{"TracesToIdx"}; inline constexpr std::string_view kLogAddrIdx{"LogAddrIdx"}; inline constexpr std::string_view kLogTopicIdx{"LogTopicIdx"}; } // namespace silkworm::db::table ================================================ FILE: silkworm/db/test_util/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(GTest REQUIRED) find_package(nlohmann_json REQUIRED) silkworm_library( silkworm_db_test_util PUBLIC silkworm_core silkworm_infra silkworm_db GTest::gmock PRIVATE nlohmann_json::nlohmann_json ) ================================================ FILE: silkworm/db/test_util/kv_test_base.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include #include namespace silkworm::db::test_util { using testing::Expectation; using testing::Return; class KVTestBase : public silkworm::test_util::ContextTestBase { public: testing::Expectation expect_request_async_tx(bool ok) { return expect_request_async_tx(*stub_, ok); } testing::Expectation expect_request_async_statechanges(bool ok) { return expect_request_async_statechanges(*stub_, ok); } testing::Expectation expect_request_async_tx(remote::MockKVStub& stub, bool ok) { EXPECT_CALL(stub, PrepareAsyncTxRaw).WillOnce(Return(reader_writer_ptr_.release())); return EXPECT_CALL(reader_writer_, StartCall).WillOnce([&, ok](void* tag) { agrpc::process_grpc_tag(grpc_context_, tag, ok); }); } testing::Expectation expect_request_async_statechanges(remote::MockKVStub& stub, bool ok) { EXPECT_CALL(stub, PrepareAsyncStateChangesRaw).WillOnce(Return(statechanges_reader_ptr_.release())); return EXPECT_CALL(*statechanges_reader_, StartCall).WillOnce([&, ok](void* tag) { agrpc::process_grpc_tag(grpc_context_, tag, ok); }); } using StrictMockKVStub = testing::StrictMock; using StrictMockKVTxAsyncReaderWriter = rpc::test::StrictMockAsyncReaderWriter; using StrictMockKVStateChangesAsyncReader = rpc::test::StrictMockAsyncReader; StrictMockKVStub& stub() { return *stub_; } protected: //! Mocked stub of gRPC KV interface std::unique_ptr stub_{std::make_unique()}; //! Mocked reader/writer for Tx bidi streaming RPC of gRPC KV interface std::unique_ptr reader_writer_ptr_{ std::make_unique()}; StrictMockKVTxAsyncReaderWriter& reader_writer_{*reader_writer_ptr_}; //! Mocked reader for StateChanges server streaming RPC of gRPC KV interface std::unique_ptr statechanges_reader_ptr_{ std::make_unique()}; StrictMockKVStateChangesAsyncReader* statechanges_reader_{statechanges_reader_ptr_.get()}; }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/mock_chain_storage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::db::test_util { class MockChainStorage : public chain::ChainStorage { public: MOCK_METHOD((Task), read_chain_config, (), (const, override)); MOCK_METHOD((Task), max_block_num, (), (const, override)); MOCK_METHOD((Task>), read_block_num, (const Hash&), (const, override)); MOCK_METHOD((Task), read_block, (HashAsSpan, BlockNum, bool, silkworm::Block&), (const, override)); MOCK_METHOD((Task), read_block, (const Hash&, BlockNum, silkworm::Block&), (const, override)); MOCK_METHOD((Task), read_block, (const Hash&, silkworm::Block&), (const, override)); MOCK_METHOD((Task), read_block, (BlockNum, bool, silkworm::Block&), (const, override)); MOCK_METHOD((Task>), read_header, (BlockNum, HashAsArray), (const, override)); MOCK_METHOD((Task>), read_header, (BlockNum, const Hash&), (const, override)); MOCK_METHOD((Task>), read_header, (const Hash&), (const, override)); MOCK_METHOD((Task>), read_sibling_headers, (BlockNum), (const, override)); MOCK_METHOD((Task), read_body, (BlockNum, HashAsArray, bool, silkworm::BlockBody&), (const, override)); MOCK_METHOD((Task), read_body, (const Hash&, BlockNum, silkworm::BlockBody&), (const, override)); MOCK_METHOD((Task), read_body, (const Hash&, silkworm::BlockBody&), (const, override)); MOCK_METHOD((Task>), read_canonical_header_hash, (BlockNum), (const, override)); MOCK_METHOD((Task>), read_canonical_header, (BlockNum), (const, override)); MOCK_METHOD((Task), read_canonical_body, (BlockNum, BlockBody&), (const, override)); MOCK_METHOD((Task>), read_raw_canonical_body_for_storage, (BlockNum), (const, override)); MOCK_METHOD((Task), read_canonical_block, (BlockNum, silkworm::Block&), (const, override)); MOCK_METHOD((Task), has_body, (BlockNum, HashAsArray), (const, override)); MOCK_METHOD((Task), has_body, (BlockNum, const Hash&), (const, override)); MOCK_METHOD((Task), read_rlp_transactions, (BlockNum, const evmc::bytes32&, std::vector&), (const, override)); MOCK_METHOD((Task), read_rlp_transaction, (const evmc::bytes32&, Bytes&), (const, override)); MOCK_METHOD((Task>), read_total_difficulty, (const Hash&, BlockNum), (const, override)); MOCK_METHOD((Task>>), read_block_num_by_transaction_hash, (const evmc::bytes32&), (const, override)); MOCK_METHOD((Task>), read_transaction_by_idx_in_block, (BlockNum, uint64_t), (const, override)); MOCK_METHOD((Task, std::optional>>), read_head_header_and_hash, (), (const, override)); }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/mock_cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db::test_util { class MockCursor : public kv::api::Cursor { public: MOCK_METHOD((uint32_t), cursor_id, (), (const)); MOCK_METHOD((Task), open_cursor, (std::string_view table_name, bool is_dup_sorted)); MOCK_METHOD((Task), seek, (ByteView key)); MOCK_METHOD((Task), seek_exact, (ByteView key)); MOCK_METHOD((Task), first, ()); MOCK_METHOD((Task), last, ()); MOCK_METHOD((Task), next, ()); MOCK_METHOD((Task), previous, ()); MOCK_METHOD((Task), close_cursor, ()); }; class MockCursorDupSort : public kv::api::CursorDupSort { public: MOCK_METHOD((uint32_t), cursor_id, (), (const)); MOCK_METHOD((Task), open_cursor, (std::string_view table_name, bool is_dup_sorted)); MOCK_METHOD((Task), seek, (ByteView key)); MOCK_METHOD((Task), seek_exact, (ByteView key)); MOCK_METHOD((Task), first, ()); MOCK_METHOD((Task), last, ()); MOCK_METHOD((Task), next, ()); MOCK_METHOD((Task), previous, ()); MOCK_METHOD((Task), next_dup, ()); MOCK_METHOD((Task), close_cursor, ()); MOCK_METHOD((Task), seek_both, (ByteView, ByteView)); MOCK_METHOD((Task), seek_both_exact, (ByteView, ByteView)); }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/mock_ro_cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db::test_util { class MockROCursor : public datastore::kvdb::ROCursor { public: using CursorResult = datastore::kvdb::CursorResult; using Slice = datastore::kvdb::Slice; MOCK_METHOD((void), bind, (datastore::kvdb::ROTxn&, const datastore::kvdb::MapConfig&), (override)); MOCK_METHOD((std::unique_ptr), clone, (), (override)); MOCK_METHOD((size_t), size, (), (const, override)); MOCK_METHOD((bool), empty, (), (const)); MOCK_METHOD((bool), is_multi_value, (), (const, override)); MOCK_METHOD((bool), is_dangling, (), (const, override)); MOCK_METHOD((::mdbx::map_handle), map, (), (const, override)); MOCK_METHOD((CursorResult), to_first, (), (override)); MOCK_METHOD((CursorResult), to_first, (bool), (override)); MOCK_METHOD((CursorResult), to_previous, (), (override)); MOCK_METHOD((CursorResult), to_previous, (bool), (override)); MOCK_METHOD((CursorResult), current, (), (const, override)); MOCK_METHOD((CursorResult), current, (bool), (const, override)); MOCK_METHOD((CursorResult), to_next, (), (override)); MOCK_METHOD((CursorResult), to_next, (bool), (override)); MOCK_METHOD((CursorResult), to_last, (), (override)); MOCK_METHOD((CursorResult), to_last, (bool), (override)); MOCK_METHOD((CursorResult), find, (const Slice&), (override)); MOCK_METHOD((CursorResult), find, (const Slice&, bool), (override)); MOCK_METHOD((CursorResult), lower_bound, (const Slice&), (override)); MOCK_METHOD((CursorResult), lower_bound, (const Slice&, bool), (override)); MOCK_METHOD((datastore::kvdb::MoveResult), move, (datastore::kvdb::MoveOperation, bool), (override)); MOCK_METHOD((datastore::kvdb::MoveResult), move, (datastore::kvdb::MoveOperation, const Slice&, bool), (override)); MOCK_METHOD((bool), seek, (const Slice&), (override)); MOCK_METHOD((bool), eof, (), (const, override)); MOCK_METHOD((bool), on_first, (), (const, override)); MOCK_METHOD((bool), on_last, (), (const, override)); }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/mock_state_cache.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::db::test_util { class MockStateView : public kv::api::StateView { public: MOCK_METHOD(bool, empty, (), (const, override)); MOCK_METHOD((Task>), get, (std::string_view, Bytes), (override)); MOCK_METHOD((Task>), get_code, (Bytes), (override)); }; class MockStateCache : public kv::api::StateCache { public: Task> get_view(kv::api::Transaction&) override { co_return std::make_unique(); } MOCK_METHOD(void, on_new_block, (const kv::api::StateChangeSet&), (override)); MOCK_METHOD(size_t, latest_data_size, (), (override)); MOCK_METHOD(size_t, latest_code_size, (), (override)); MOCK_METHOD(uint64_t, state_hit_count, (), (const, override)); MOCK_METHOD(uint64_t, state_miss_count, (), (const, override)); MOCK_METHOD(uint64_t, state_key_count, (), (const, override)); MOCK_METHOD(uint64_t, state_eviction_count, (), (const, override)); MOCK_METHOD(uint64_t, code_hit_count, (), (const, override)); MOCK_METHOD(uint64_t, code_miss_count, (), (const, override)); MOCK_METHOD(uint64_t, code_key_count, (), (const, override)); MOCK_METHOD(uint64_t, code_eviction_count, (), (const, override)); MOCK_METHOD(Task, validate_current_root, (kv::api::Transaction&), (override)); }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/mock_transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::db::test_util { class MockTransaction : public kv::api::Transaction { public: kv::api::StateCache* state_cache() override { return &state_cache_; } MOCK_METHOD(uint64_t, tx_id, (), (const, override)); MOCK_METHOD(uint64_t, view_id, (), (const, override)); MOCK_METHOD((Task), open, (), (override)); MOCK_METHOD((Task>), cursor, (std::string_view), (override)); MOCK_METHOD((Task>), cursor_dup_sort, (std::string_view), (override)); bool is_local() const override { return false; } MOCK_METHOD((std::shared_ptr), make_storage, (), (override)); MOCK_METHOD((Task), first_txn_num_in_block, (BlockNum), (override)); MOCK_METHOD((Task), close, (), (override)); MOCK_METHOD((Task), get, (std::string_view, ByteView), (override)); MOCK_METHOD((Task), get_one, (std::string_view, ByteView), (override)); MOCK_METHOD((Task>), get_both_range, (std::string_view, ByteView, ByteView), (override)); MOCK_METHOD((Task), get_latest, (kv::api::GetLatestRequest), (override)); MOCK_METHOD((Task), get_as_of, (kv::api::GetAsOfRequest), (override)); MOCK_METHOD((Task), history_seek, (kv::api::HistoryPointRequest), (override)); MOCK_METHOD((Task), index_range, (kv::api::IndexRangeRequest), (override)); MOCK_METHOD((Task), history_range, (kv::api::HistoryRangeRequest), (override)); MOCK_METHOD((Task), range_as_of, (kv::api::DomainRangeRequest), (override)); private: MockStateCache state_cache_; }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/mock_txn.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::db::test_util { class MockROTxn : public datastore::kvdb::ROTxn { public: explicit MockROTxn() : datastore::kvdb::ROTxn(txn_) {} MOCK_METHOD((bool), is_open, (), (const, override)); MOCK_METHOD((mdbx::env), db, (), (const, override)); MOCK_METHOD((std::unique_ptr), ro_cursor, (const datastore::kvdb::MapConfig&), (override)); MOCK_METHOD((std::unique_ptr), ro_cursor_dup_sort, (const datastore::kvdb::MapConfig&), (override)); MOCK_METHOD((void), abort, (), (override)); private: ::mdbx::txn txn_; }; class MockRwTxn : public datastore::kvdb::RWTxn { public: explicit MockRwTxn() : datastore::kvdb::RWTxn(txn_) {} MOCK_METHOD((bool), is_open, (), (const, override)); MOCK_METHOD((mdbx::env), db, (), (const, override)); MOCK_METHOD((std::unique_ptr), ro_cursor, (const datastore::kvdb::MapConfig&), (override)); MOCK_METHOD((std::unique_ptr), ro_cursor_dup_sort, (const datastore::kvdb::MapConfig&), (override)); MOCK_METHOD((std::unique_ptr), rw_cursor, (const datastore::kvdb::MapConfig&), ()); MOCK_METHOD((std::unique_ptr), rw_cursor_dup_sort, (const datastore::kvdb::MapConfig&), ()); MOCK_METHOD((void), commit, (), ()); MOCK_METHOD((void), abort, (), (override)); MOCK_METHOD((void), commit_and_renew, (), ()); MOCK_METHOD((void), commit_and_stop, (), ()); private: ::mdbx::txn txn_; // silkworm::datastore::kvdb::RWCursor aa; }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/temp_chain_data.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "temp_chain_data.hpp" #include #include #include #include namespace silkworm::db::test_util { using namespace silkworm::datastore::kvdb; TempChainData::TempChainData(bool with_create_tables, bool in_memory) : data_dir_(tmp_dir_.path(), /*create=*/true), chain_config_(kMainnetConfig), chaindata_env_config_(EnvConfig{ .path = data_dir_.chaindata().path().string(), .create = true, .readonly = false, .exclusive = false, .in_memory = in_memory, }) { chain_config_.genesis_hash.emplace(kMainnetGenesisHash); env_ = std::make_unique(open_env(chaindata_env_config_)); txn_ = std::make_unique(chaindata_rw().start_rw_tx()); if (with_create_tables) { db::table::check_or_create_chaindata_tables(*txn_); } } void TempChainData::add_genesis_data() const { bool allow_exceptions = false; auto source_data = read_genesis_data(chain_config().chain_id); auto genesis_json = nlohmann::json::parse(source_data, nullptr, allow_exceptions); db::initialize_genesis(*txn_, genesis_json, allow_exceptions); } } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/temp_chain_data.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::db::test_util { //! \brief TempChainData is a helper resource manager for a temporary directory plus an in-memory database. //! Upon construction, it creates all the necessary data directories and database tables. //! \remarks TempChainData follows the RAII idiom and cleans up its temporary directory upon destruction. class TempChainData { public: explicit TempChainData(bool with_create_tables = true, bool in_memory = true); virtual ~TempChainData() = default; // Not copyable nor movable TempChainData(const TempChainData&) = delete; TempChainData& operator=(const TempChainData&) = delete; const ChainConfig& chain_config() const { return chain_config_; } void add_genesis_data() const; const DataDirectory& dir() const { return data_dir_; } const datastore::kvdb::EnvConfig& chaindata_env_config() const { return chaindata_env_config_; } virtual datastore::kvdb::ROAccess chaindata() const { return datastore::kvdb::ROAccess{*env_}; } virtual datastore::kvdb::RWAccess chaindata_rw() const { return datastore::kvdb::RWAccess{*env_}; } mdbx::txn& txn() const { return *txn_; } db::RWTxn& rw_txn() const { return *txn_; } void commit_txn() const { txn_->commit_and_stop(); } void commit_and_renew_txn() const { txn_->commit_and_renew(); } const db::PruneMode& prune_mode() const { return prune_mode_; } void set_prune_mode(const db::PruneMode& prune_mode) { prune_mode_ = prune_mode; } protected: mdbx::env_managed move_env() { mdbx::env_managed env{std::move(*env_)}; env_.reset(); return env; } TemporaryDirectory tmp_dir_; DataDirectory data_dir_; ChainConfig chain_config_; datastore::kvdb::EnvConfig chaindata_env_config_; std::unique_ptr env_; std::unique_ptr txn_; db::PruneMode prune_mode_; }; class TempChainDataStore : public TempChainData { public: TempChainDataStore() : data_store_{ move_env(), data_dir_.snapshots().path(), } {} ~TempChainDataStore() override { // need to destroy a started RWTxn in the base class before destroying env_managed inside the data_store_ txn_.reset(); } db::DataStore& operator*() { return data_store_; } db::DataStore* operator->() { return &data_store_; } datastore::kvdb::ROAccess chaindata() const override { return data_store_.chaindata().access_ro(); } datastore::kvdb::RWAccess chaindata_rw() const override { return data_store_.chaindata().access_rw(); } db::DataModelFactory data_model_factory() { return db::DataModelFactory{data_store_.ref()}; } private: db::DataStore data_store_; }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/temp_snapshots.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::snapshots::test_util { using snapshots::SnapshotPath; //! Big-endian encoder inline size_t encode_big_endian(uint64_t value, Bytes& output) { const size_t old_size = output.size(); output.resize(old_size + sizeof(uint64_t)); endian::store_big_u64(output.data() + old_size, value); return output.size(); } //! Varint encoder inline size_t encode_varint(uint64_t value, Bytes& output) { Bytes encoded; seg::varint::encode(encoded, value); output.append(encoded); return encoded.size(); } //! Snapshot header encoder struct SnapshotPattern { uint64_t depth; Bytes data; }; struct SnapshotPosition { uint64_t depth; uint64_t value; }; struct SnapshotHeader { uint64_t words_count; uint64_t empty_words_count; std::vector patterns; std::vector positions; void encode(Bytes& output) const { encode_big_endian(words_count, output); encode_big_endian(empty_words_count, output); encode_big_endian(compute_patterns_size(), output); for (const auto& pattern : patterns) { encode_varint(pattern.depth, output); encode_varint(pattern.data.size(), output); output.append(pattern.data.cbegin(), pattern.data.cend()); } encode_big_endian(compute_positions_size(), output); for (const auto& position : positions) { encode_varint(position.depth, output); encode_varint(position.value, output); } } private: uint64_t compute_patterns_size() const { uint64_t patterns_size{0}; Bytes temp_buffer{}; for (const auto& pattern : patterns) { patterns_size += encode_varint(pattern.depth, temp_buffer); patterns_size += encode_varint(pattern.data.size(), temp_buffer); patterns_size += pattern.data.size(); } return patterns_size; } uint64_t compute_positions_size() const { uint64_t positions_size{0}; Bytes temp_buffer{}; for (const auto& position : positions) { positions_size += encode_varint(position.depth, temp_buffer); positions_size += encode_varint(position.value, temp_buffer); } return positions_size; } }; struct SnapshotBody { Bytes data; void encode(Bytes& output) const { output.append(data.cbegin(), data.cend()); } }; //! Temporary snapshot file class TemporarySnapshotFile { public: TemporarySnapshotFile( const std::filesystem::path& tmp_dir, std::string_view filename, const SnapshotHeader& header = {}, const SnapshotBody& body = {}) : TemporarySnapshotFile{ parse_path_or_die(tmp_dir, filename), encode_header_and_body(header, body), } {} TemporarySnapshotFile( const std::filesystem::path& tmp_dir, std::string_view filename, ByteView data) : TemporarySnapshotFile{ parse_path_or_die(tmp_dir, filename), data, } {} TemporarySnapshotFile( SnapshotPath path, ByteView data) : file_{path.path().parent_path(), path.filename()}, path_{std::move(path)} { file_.write(data); } const SnapshotPath& path() const { return path_; } const std::filesystem::path& fs_path() const { return file_.path(); } private: static Bytes encode_header_and_body( const SnapshotHeader& header, const SnapshotBody& body) { Bytes data; header.encode(data); body.encode(data); return data; } static SnapshotPath parse_path_or_die( const std::filesystem::path& tmp_dir, std::string_view filename) { auto path = SnapshotPath::parse(tmp_dir / filename); if (!path) throw std::runtime_error{"TemporarySnapshotFile: invalid snapshot filename: " + std::string{filename}}; return std::move(*path); } silkworm::test_util::TemporaryFile file_; SnapshotPath path_; }; //! HelloWorld snapshot file: it contains just one word: "hello, world" w/o any patterns class HelloWorldSnapshotFile : public TemporarySnapshotFile { public: explicit HelloWorldSnapshotFile(const std::filesystem::path& tmp_dir, const std::string& filename) : TemporarySnapshotFile{tmp_dir, filename, kHeader, kBody} {} private: static inline const SnapshotHeader kHeader{ .words_count = 1, // number of non-empty words .empty_words_count = 0, .patterns = std::vector{}, // zero patterns .positions = std::vector{ {1, 0}, // 1: depth 0: value {1, 13} // 1: depth 13: unencoded data length (including position encoding) }}; static inline const SnapshotBody kBody{ *from_hex("0168656C6C6F2C20776F726C64") // 0x01: position 0x68656C6C6F2C20776F726C64: "hello, world" }; }; // SampleBodySnapshotFile + SampleBodySnapshotFile + SampleTransactionSnapshotFile // Sample snapshot files for mainnet blocks 1'500'013 containing 1 tx: https://etherscan.io/block/1500013 // Legend: // - WC: number of non-empty words // - EWC: number of empty words // - PaT (Pattern Table): encoded table of patterns // - PoT (Position Table): encoded table of positions // - PaTS (PaT Size): size of pattern table in bytes // - PoTS (PoT Size): size of position table in bytes inline const BlockNumRange kSampleSnapshotBlockRange{1'500'012, 1'500'014}; //! Sample Headers snapshot file: it contains the mainnet block headers in range [1'500'012, 1'500'013] //! At least 2 blocks are required because RecSplit key set must have at least *2* keys class SampleHeaderSnapshotFile : public TemporarySnapshotFile { public: static constexpr std::string_view kHeadersSnapshotFileName{"v1-001500-001501-headers.seg"}; //! This ctor lets you pass any snapshot content and is used to produce broken snapshots SampleHeaderSnapshotFile(const std::filesystem::path& tmp_dir, std::string_view hex) : TemporarySnapshotFile{tmp_dir, kHeadersSnapshotFileName, *from_hex(hex)} {} BlockNumRange block_num_range() const { return kSampleSnapshotBlockRange; } //! This ctor captures the correct sample snapshot content once for all explicit SampleHeaderSnapshotFile(const std::filesystem::path& tmp_dir) : SampleHeaderSnapshotFile( tmp_dir, "0000000000000002" // WC = 2 "0000000000000000" // EWC = 0 "0000000000000152" // PaTS = 338 "0320A00000000000000000000000000000000000000000000000000000000000" // PaT = 0x0320... "0000038001B90100000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000034000000000000000000000000000000000000000000000000000" "00000000000000A0000000000000000000000000000000000000000000000000" "0000000000000004200000000000000000000000000000000000000000A00000" "0000000000000000000440000000000000A00000000000000000000000000000" "000000000000000000000000000000000000A000000000000000000000000000" "000000000000000000000001050000000000" "000000000000001A" // PoTS = 26 "04F503044304BF010400048201040F059C040542052605290106" // PoT = 0x04F5... "5068EA5E96F2FFFFFFFFFF7F85CBC2F901F0A000940000808316E36C80808080" // Header 1'500'012 "00880000008628FFFFFFFFFFFF67" "BEF90217A048A486D69A07E99ED6997EB0F9B8795E4E7D07C0CE5B8EE8E139D6" // Header 1'500'013 (Hash 1st byte + RLP) "53FD1B01C3A07117CFC18FF9765FB04A0C223722D1CFD20A06E5D7A88778F9F6" "6A2207B0638B94EA674FDDE714FD979DE3EDF0F56AA9716B898EC8A0AC26FC90" "B79CD9304F03C925208E377D4E6E4B229EDE56EB1728851E656791BCA0BC18A8" "09C2AB84E0870C0BE8DE331E3E0498E31B22CDEB95E07F23A5C7F77F40A0C856" "DB90A6C30A0264858960231C4A3F78F557EA83EA4D7EC260C691B08505230086" "1FAD3D458F3E8316E36D8347E7C4825208845733A90798D78301040084476574" "6887676F312E352E31856C696E7578A0799895E28A837BBDF28B8ECF5FC0E625" "1398ECB0FFC7FF5BBB457C21B14CE982888698762012B46FEF") {} }; //! Sample Bodies snapshot file: it contains the mainnet block bodies in range [1'500'012, 1'500'013] class SampleBodySnapshotFile : public TemporarySnapshotFile { public: static constexpr std::string_view kBodiesSnapshotFileName{"v1-001500-001501-bodies.seg"}; //! This ctor lets you pass any snapshot content and is used to produce broken snapshots SampleBodySnapshotFile(const std::filesystem::path& tmp_dir, std::string_view hex) : TemporarySnapshotFile{tmp_dir, kBodiesSnapshotFileName, *from_hex(hex)} {} BlockNumRange block_num_range() const { return kSampleSnapshotBlockRange; } //! This empty ctor captures the correct sample snapshot content once for all explicit SampleBodySnapshotFile(const std::filesystem::path& tmp_dir) : SampleBodySnapshotFile( tmp_dir, "0000000000000002" // WC = 2 "0000000000000000" // EWC = 0 "0000000000000000" // PaTS = 0 "0000000000000007" // PoTS = 7 "0100020802A404" // PoT = 0x01...04 "01" "C6837004CE09C0" // Body 1'500'012 "03" "F90220837004D703F90218F90215A04930C7E9157B97E6A68AB4D26F4EC99268" // Body 1'500'013 "94635A4A89BBEFECD96D62C83C1D5DA01DCC4DE8DEC75D7AAB85B567B6CCD41A" "D312451B948A7413F0A142FD40D4934794EA674FDDE714FD979DE3EDF0F56AA9" "716B898EC8A0813E0EF24189E66F4A5D5A123DD39D1D1529E48C6F7FE6290E0C" "917EB1717B4FA056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001" "622FB5E363B421A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC0" "01622FB5E363B421B90100000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000861FB1346966098316E36B8347E7C480845733A8DF" "98D783010400844765746887676F312E352E31856C696E7578A028FB78C93A8C" "6BF6B9A353BD3566DE6861EAAC19C0ED1B663CBAAEE0CFE6E70A88C7E9D99815" "48460F") {} }; //! Sample Transactions snapshot file: it contains the mainnet block transactions in range [1'500'012, 1'500'013] class SampleTransactionSnapshotFile : public TemporarySnapshotFile { public: static constexpr std::string_view kTransactionsSnapshotFileName{"v1-001500-001501-transactions.seg"}; //! This ctor lets you pass any snapshot content and is used to produce broken snapshots SampleTransactionSnapshotFile(const std::filesystem::path& tmp_dir, std::string_view hex) : TemporarySnapshotFile{tmp_dir, kTransactionsSnapshotFileName, *from_hex(hex)} {} BlockNumRange block_num_range() const { return kSampleSnapshotBlockRange; } //! This empty ctor captures the correct sample snapshot content once for all explicit SampleTransactionSnapshotFile(const std::filesystem::path& tmp_dir) : SampleTransactionSnapshotFile( tmp_dir, "000000000000000C" // WC = 12 "0000000000000004" // EWC = 4 "0000000000000000" // PaTS = 0 "0000000000000016" // PoTS = 22 "010004E60304850104E5020487010301048801048401" // PoT = 0x01...01 "0309" "3DE6BF8FE3E608CC04681B3DFC8B2D52AB94C23DB7F86D018504E3B292008252" // Txn position 0 block 1'500'012 START "0894BB9BC244D798123FDE783FCC1C72D3BB8C1894138902292B2AD00B120000" "801CA0F5D7EB932991DC38FB5A3ED2ABCC71C2ABFC098BB2A9A25552ABEC2249" "A6AAF8A055CAD62B0CD8E2B6154F2EA52D308535EF634D9A207571996754A02E" "59DE97C1" // Txn position 0 block 1'500'012 END "0F" "0A9C0474E418336FE6779BF5D2875DEA284711E425F86C038504E3B292008255" // Txn position 1 block 1'500'012 START "F094BB9BC244D798123FDE783FCC1C72D3BB8C189413884563918244F4000080" "1CA05FED9736B73FADD09E07BE4836AA45D77D6C1B91F3026E0941F11BF3DE40" "6624A00F1A573F9887A33ED2B515CB0931D827BDB89FA816800ACEE6FB06E618" "70F9DB" // Txn position 1 block 1'500'012 END "07" "134BB96091EE9D802ED039C4D1A5F6216F90F81B01F870830137DE8504A817C8" // Txn position 2 block 1'500'012 START "0083015F90942B9F67024DC91DEBAB6A322D27201F5F80F6B06A8844B1EEC616" "2F0000801CA0B82395812DA2B520E9094FEE335FE7720F76ACE9667884F2C2FA" "6F87E840307FA05C591CE13EEC49BDE11371D0EFE605D2CF97D2053BBDC96213" "14C394B2E9D67E" // Txn position 2 block 1'500'012 END "05" "DBAC4361F56C82ED59D533D45129F407015D84702AF9014C820BA78504A817C8" // Txn position 3 block 1'500'012 START "0083124F809441F274C0023F83391DE4E0733C609DF5A124C3D480B8E490FA33" "7D00000000000000000000000000000000000000000000000000000000000000" "6000000000000000000000000000000000000000000000000000038D7EA4C680" "0000000000000000000000000001A23FD30AABF5AD53BAB3093DCD4948E15CEC" "8000000000000000000000000000000000000000000000000000000000000000" "50040000001981112F120482B107DCFF689E37324FB91E567A3C251D00000000" "00000000001B3C3DC83843E88150721108C66984F528382EAC91CC624D29D5F2" "7ABE6CB8D9E3A73357FAA80518551AC446000000000000000000000000000000" "001BA0A6764120647DFB4C58E4A977778FA3B5464EF0E64D2433E8079098131A" "51F317A0105ACC9977815A9BC8A32A7DF9D0AECA6560A09FE89DC14EE1A06D84" "67016002" // Txn position 3 block 1'500'012 END "01" "A190384D665F5687BE20FA3EFC029939D249F0570CF901CD8260808504A817C8" // Txn position 4 block 1'500'012 START "008307A12094AD62F56A03334B647E55DBDB5B8642C24605A80101B901643ED4" "86790000000000000000000000009C4EA8D25D6150A8ED2848FC745158AAD926" "BF8D000000000000000000000000000000000000000000000000000000005733" "A8EF000000000000000000000000000000000000000000000000000000000000" "00C0000000000000000000000000000000000000000000000000000000000000" "0120000000000000000000000000490C0DD13BFEA5865CA985297CF2BED3F77B" "EB5D000000000000000000000000000000000000000000000000000000000000" "0001000000000000000000000000000000000000000000000000000000000000" "00025D32BF90EAA0D9FEAA1E8B5645E0CE50FD6408E314874BF9959098E76672" "18A5080FC06A25EDAE04D6AA529AF072B5AC8EF4524FEEDBF6CD31C52F24D6A8" "4A22000000000000000000000000000000000000000000000000000000000000" "0001000000000000000000000000000000000000000000000000000000000000" "001C1BA0870CD28E900B59D543EF3590B52C3564A24C32EC503CAE8C7EAD2DDB" "E9B7DAB6A01B13F942E5442F0F60A2E91010F9B0C54D47DDD156AA8D159CAF35" "0CCFC40836" // Txn position 4 block 1'500'012 END "07" "889E6316F44BAEEEE5D41A1070516CC5FA47BAF227F8708218E98504A817C800" // Txn position 5 block 1'500'012 START "8303D090947B09B1AD47A7DB257E56963074FCCD35D5414E948902749EA02452" "5B2800801BA05128DB834E449BD1C8EF49F33088C6E01DAE3C607C1F36494510" "0748F2920B41A059F30995C21D130330C6FAADA406EF7FEFAE898A87792D5540" "6BBE66776F43BF" // Txn position 5 block 1'500'012 END "0F" "223C3AA259C5AC6BC048CAA54EE0F8D4E8FA7AF25FF86C568504A817C8008256" // Txn position 6 block 1'500'012 START "2294FBB1B73C4F0BDA4F67DCA266CE6EF42F520FBB988846DB2BD5D79CE00080" "1CA081F1584E7A96EF0981EC8D906F2FEA9B693AFD3828D7D0707CBEE9248A64" "DDE2A07741C894678B0336812A43234B28AA675A7720AC3EC0403D8943C1D3FF" "9AE5EB" // Txn position 6 block 1'500'012 END "03" "030D" "3B68795C4AA09D6F4ED3E5DEDDF8C2AD3049A601DAF86F828F938504A817C800" // Txn position 0 block 1'500'013 START "83015F9094E9AE6EC1117BBFEB89302CE7E632597BC595EFAE880E61A774F297" "BB80801CA031131812A9B210CF6033E9420478B72F08251D8C7323DD88BD3A18" "0679FA90B5A028A6D676D77923B19506C7AAAE5F1DC2F2244855AABB6672401C" "1B55B0D844FF" // Txn position 0 block 1'500'013 END "03") {} }; //! Sample Accounts KV segment file generated using Erigon aggregator_test.go:generateKV //! with parameters: keySize=52, M=30, valueSize=180, keyCount=10 class SampleAccountsDomainSegmentFile : public TemporarySnapshotFile { public: //! This ctor lets you pass any snapshot content and is used to produce broken snapshots SampleAccountsDomainSegmentFile(const std::filesystem::path& tmp_dir, std::string_view hex) : TemporarySnapshotFile{tmp_dir, "v1-accounts.0-1024.kv", *from_hex(hex)} {} //! This ctor captures the correct sample snapshot content once for all explicit SampleAccountsDomainSegmentFile(const std::filesystem::path& tmp_dir) : SampleAccountsDomainSegmentFile( tmp_dir, "0000000000000014" // WC = 20 "0000000000000000" // EWC = 0 "0000000000000000" // PaTS = 0 "000000000000001a" // PoTS = 26 "01000235054d05ad0105430553057b05170630060e06a1010651010194fdc2fa" "2ffcc041d3ff12045b73c86e4ff95ff662a5eee82abdf44a2d0b75fb180daf48" "a79ee0b10d3946000000000000000007e285ece1511455780875d64ee2d3d0d0" "de6bf8f9b44ce85ff044c6b1f83b8e883bbf857aab99c5b252c7429c32f3a8ae" "b79ef856f659c18f0dcecc77c75e7a81bfde275f67cfe242cf3cc354f3ede2d6" "becc4ea3ae5e88526a9f4a578bcb9ef2d4a65314768d6d299761ea9e4f5aa6ae" "c3fc78c6aae081ac8120011c0cb96ad322d62282295fbfe11e26a433076db5c1" "444c3a34d32a5c4a7ffbe8d181f7ed3b8cfe904f93f8f0000000000000000217" "2e046410f44bc4b0f3f03a0d06820a30f257f8114130015056b55f92a355db76" "5adc8d3df88eb93d527f7f7ec869a75703ba86d4b36110e9a044593c966815d1" "53665300000000000000093ff3e6b0f04035ef9419883e03c08e2d753b08c909" "0aabf175fdb63e8cf9a5f0783704c741c195157626401d949eaa6dbd04d7ade5" "749eab5470bf5e9c18cc79dda4e12efe564ecb8a4019e1c41f2d82170158c6db" "3262670649f3bc97d9a2316735ede682a5dfe6f1a011fbc98ad0fbe790003c01" "e8e9967703af665e9f00000000000000041374aafe8a0d3e0515dd4650cf5117" "2b81248bcb7f969e400b6c5b127768b1c412fae98cf57631cf37033b4b4aba7d" "7ed319ba147249c908ac70d1c406dade0e828eb6ba0dcaa88285543e10213c64" "3fc8603b5860236670babcad0bd7f4c4190e323623a868d1eae1769f40a26631" "431b3bd5215605d2086fead499ac63a4653d12283d56019c3795a98a126d09cf" "cbe36cdcc93788a5409f8b6e42c2dd83aa46611852ad0b5028775c7716900167" "8ac04586c1e3c9342c8b8055c466d886441d259906d69acd894b968ae9f0eb9d" "965ce6a4693c4ebe88150100000000000000031b7e5cda7b6cba6891d616bd68" "6c37b834613ac8baa22c008ffe688352734ae4e3f1217acd5f83270814301867" "b5d06711b238001c7957b27719ce3f3188dfe57deebf6f82595a10f7bb562ca0" "4d5c3d2794290171a420834383661801bb0bfd8e6c140071db1eb2f7a18194f1" "a045a94c078835c75dff2f3e836180baad9e9500000000000000060f98f8c201" "aec254a0e36476b2eeb124fdc6afc1b7d809c5e08b5e0e845aaf9b6c3957e95a" "b4aa8e107cdb873f2dac52017f16c4d5ac8760768a715e4669cb840c25317f9a" "368774e506341afb46503e28e92e51bd7f7d4b53b9023d560000000000000007" "1fbc45ff64bb2bf14d4051a7604b28bad44d98bfe30e54ebc07fa45f62aabe39" "5cc94fa0a0f246b5d28b2e3f6deb2990187058e4bfd2d1640653fc38a30b0f83" "231a965b413b0f26927e0d032e830b732bdeb3094cb1a5fa6dec9f06375ea25f" "e57c2853ea09320ac8803976eacaa095c02f869fd7dc31072475940c3751d562" "83c49e2fefd41df676bdcb5855a0470efd2dab7a72cc5e5f39ff7eea0f433a9f" "e701b6854e05b377241e73a883dd77aff0302c6da8665c42341dda4adaea595a" "b1895f9652489dd2ceb49c24743000000000000000050b662c9c66b878290519" "0f1e1635b63e34878d3f246fadfce344e74ef813090f8030bcd525ac10653ff1" "82e00120f7e1f796fa0fc16ba7bb90be2a33e87c3d60ab628401b6a675bc2ac5" "0cd218c009e21f910f9ddb09a0d059c4cd7d2ca65a2349df7a867dbedd81e9d4" "891619c83c4200000000000000082fcaed9130ab1dd4cc2d8147a15901c720ef" "cd6cea84b6925e607be063716f96ddcdd01d75045c3f000f8a796bce6c512c38" "01aacaeedfad5b5066000000000000000103b8b7c1965d9181251b7c9c9ca520" "5afc16a236a2efcdd2d12d2a79d074a8280ae9439eb0d6aeca0823ae02d67d86" "6ac2c4fe4a725053da119b9d4f515140a2d7239c40b45ac3950d941fc4fe") {} }; //! Sample Accounts existence index file generated using Erigon aggregator_test.go:generateKV class SampleAccountsDomainExistenceIndexFile : public TemporarySnapshotFile { public: //! This ctor lets you pass any snapshot content and is used to produce broken snapshots SampleAccountsDomainExistenceIndexFile(const std::filesystem::path& tmp_dir, std::string_view hex) : TemporarySnapshotFile{tmp_dir, "v1-accounts.0-1024.kvei", *from_hex(hex)} {} //! This ctor captures the correct sample snapshot content once for all explicit SampleAccountsDomainExistenceIndexFile(const std::filesystem::path& tmp_dir) : SampleAccountsDomainExistenceIndexFile( tmp_dir, "00000000000000007630320a03000000000000000a0000000000000060000000" "00000000cc6bab7ea3f92b90703c27812255d1e5c7ffdf994578ee3c428838c0" "009022a78b200087000000005fcb40babe887b416444f783dca9c3826bd676ef" "32c645a280eb7ce40acab41e296fc6b9bafcfa2edd3b2dc83b0994ab") {} }; //! Sample Accounts B-tree index file generated using Erigon aggregator_test.go:generateKV class SampleAccountsDomainBTreeIndexFile : public TemporarySnapshotFile { public: //! This ctor lets you pass any snapshot content and is used to produce broken snapshots SampleAccountsDomainBTreeIndexFile(const std::filesystem::path& tmp_dir, std::string_view hex) : TemporarySnapshotFile{tmp_dir, "v1-accounts.0-1024.bt", *from_hex(hex)} {} //! This ctor captures the correct sample snapshot content once for all explicit SampleAccountsDomainBTreeIndexFile(const std::filesystem::path& tmp_dir) : SampleAccountsDomainBTreeIndexFile( tmp_dir, "000000000000000900000000000004e300cc0b241b9d9f080000000000000000" "2922891400000000000000000000000000000000000000000000000000000000" "0000000000000001000000000000000000340194fdc2fa2ffcc041d3ff12045b" "73c86e4ff95ff662a5eee82abdf44a2d0b75fb180daf48a79ee0b10d39460000" "000000000000") {} }; } // namespace silkworm::snapshots::test_util ================================================ FILE: silkworm/db/test_util/test_database_context.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "test_database_context.hpp" #include #include #include #include #include #include #include namespace silkworm::db::test_util { using namespace silkworm::datastore::kvdb; std::filesystem::path get_tests_dir() { auto working_dir = std::filesystem::current_path(); while (working_dir != "/") { if (std::filesystem::exists(working_dir / "third_party" / "execution-apis")) { return working_dir / "third_party" / "execution-apis" / "tests"; } if (std::filesystem::exists(working_dir / "silkworm" / "third_party" / "execution-apis")) { return working_dir / "silkworm" / "third_party" / "execution-apis" / "tests"; } if (std::filesystem::exists(working_dir / "project" / "third_party" / "execution-apis")) { return working_dir / "project" / "third_party" / "execution-apis" / "tests"; } working_dir = working_dir.parent_path(); } throw std::logic_error("Failed to find tests directory"); } InMemoryState populate_genesis(RWTxn& txn, const std::filesystem::path& tests_dir) { auto genesis_json_path = tests_dir / "genesis.json"; std::ifstream genesis_json_input_file(genesis_json_path); nlohmann::json genesis_json; genesis_json_input_file >> genesis_json; InMemoryState state = read_genesis_allocation(genesis_json.at("alloc")); write_genesis_allocation_to_db(txn, state); BlockHeader header{read_genesis_header(genesis_json, state.state_root_hash())}; BlockBody block_body{ .withdrawals = std::vector{0}, }; // FIX 2: set empty receipts root, should be done in the main code, requires https://github.com/erigontech/silkworm/issues/1348 header.withdrawals_root = kEmptyRoot; auto block_hash{header.hash()}; auto block_hash_key{block_key(header.number, block_hash.bytes)}; write_header(txn, header, /*with_header_numbers=*/true); // Write table::kHeaders and table::kHeaderNumbers write_canonical_header_hash(txn, block_hash.bytes, header.number); // Insert header hash as canonical write_total_difficulty(txn, block_hash_key, header.difficulty); // Write initial difficulty write_body(txn, block_body, block_hash.bytes, header.number); // Write block body (empty) write_head_header_hash(txn, block_hash.bytes); // Update head header in config const uint8_t genesis_null_receipts[] = {0xf6}; // <- cbor encoded open_cursor(txn, table::kBlockReceipts) .upsert(datastore::kvdb::to_slice(block_hash_key).safe_middle(0, 8), datastore::kvdb::to_slice(Bytes(genesis_null_receipts, 1))); // Write Chain Settings auto config_data{genesis_json["config"].dump()}; open_cursor(txn, table::kConfig) .upsert(to_slice(block_hash), mdbx::slice{config_data.data()}); return state; } void populate_blocks(RWTxn& txn, const std::filesystem::path& tests_dir, InMemoryState& state_buffer) { auto rlp_path = tests_dir / "chain.rlp"; std::ifstream file(rlp_path, std::ios::binary); if (!file) { throw std::logic_error("Failed to open the file: " + rlp_path.string()); } std::vector rlps; std::vector line; Bytes rlp_buffer(std::istreambuf_iterator(file), {}); file.close(); ByteView rlp_view{rlp_buffer}; auto chain_config = read_chain_config(txn); if (!chain_config.has_value()) { throw std::logic_error("Failed to read chain config"); } auto rule_set = protocol::rule_set_factory(*chain_config); while (!rlp_view.empty()) { silkworm::Block block; if (!silkworm::rlp::decode(rlp_view, block, silkworm::rlp::Leftover::kAllow)) { throw std::logic_error("Failed to decode RLP file"); } // store original hashes auto block_hash = block.header.hash(); auto block_hash_key = block_key(block.header.number, block_hash.bytes); // FIX 3: populate senders table write_senders(txn, block_hash, block.header.number, block); // FIX 4a: populate tx lookup table and create receipts write_tx_lookup(txn, block); // FIX 4b: populate receipts and logs table std::vector receipts; ExecutionProcessor processor{block, *rule_set, state_buffer, *chain_config, true}; Buffer db_buffer{txn, std::make_unique(txn)}; for (auto& block_txn : block.transactions) { silkworm::Receipt receipt{}; processor.execute_transaction(block_txn, receipt); receipts.emplace_back(receipt); } processor.evm().state().write_to_db(block.header.number); db_buffer.insert_receipts(block.header.number, receipts); db_buffer.write_history_to_db(); // FIX 5: insert system transactions intx::uint256 max_priority_fee_per_gas = block.transactions.empty() ? block.header.base_fee_per_gas.value_or(0) : block.transactions[0].max_priority_fee_per_gas; intx::uint256 max_fee_per_gas = block.transactions.empty() ? block.header.base_fee_per_gas.value_or(0) : block.transactions[0].max_fee_per_gas; silkworm::Transaction system_transaction; system_transaction.max_priority_fee_per_gas = max_priority_fee_per_gas; system_transaction.max_fee_per_gas = max_fee_per_gas; block.transactions.emplace(block.transactions.begin(), system_transaction); block.transactions.emplace_back(system_transaction); write_header(txn, block.header, /*with_header_numbers=*/true); // Write table::kHeaders and table::kHeaderNumbers write_canonical_header_hash(txn, block_hash.bytes, block.header.number); // Insert header hash as canonical // TODO: find how to decode total difficulty // write_total_difficulty(txn, block_hash_key, block.header.difficulty); // Write initial difficulty write_total_difficulty(txn, block_hash_key, 1); // Write initial difficulty write_raw_body(txn, block, block_hash, block.header.number); write_head_header_hash(txn, block_hash.bytes); // Update head header in config write_last_head_block(txn, block_hash); // Update head block in config write_last_safe_block(txn, block_hash); // Update last safe block in config write_last_finalized_block(txn, block_hash); // Update last finalized block in config } } namespace { mdbx::env_managed initialize_test_database(const std::filesystem::path& chaindata_dir_path) { const auto tests_dir = get_tests_dir(); EnvConfig env_config{ .path = chaindata_dir_path.string(), .create = true, .exclusive = true, .in_memory = true, .shared = false, }; auto env = open_env(env_config); RWTxnManaged txn{env}; table::check_or_create_chaindata_tables(txn); auto state_buffer = populate_genesis(txn, tests_dir); populate_blocks(txn, tests_dir, state_buffer); txn.commit_and_stop(); return env; } } // namespace TestDatabaseContext::TestDatabaseContext(const TemporaryDirectory& tmp_dir) : chaindata_dir_path_{DataDirectory{tmp_dir.path()}.chaindata().path()}, env_{std::make_unique(initialize_test_database(chaindata_dir_path_))} {} silkworm::ChainConfig TestDatabaseContext::get_chain_config() const { ROTxnManaged txn = chaindata().start_ro_tx(); auto chain_config = read_chain_config(txn); return chain_config ? *chain_config : silkworm::ChainConfig{}; } } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/test_util/test_database_context.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::db::test_util { std::filesystem::path get_tests_dir(); InMemoryState populate_genesis(db::RWTxn& txn, const std::filesystem::path& tests_dir); void populate_blocks(db::RWTxn& txn, const std::filesystem::path& tests_dir, InMemoryState& state_buffer); class TestDatabaseContext { public: explicit TestDatabaseContext(const TemporaryDirectory& tmp_dir); virtual ~TestDatabaseContext() = default; virtual datastore::kvdb::ROAccess chaindata() const { return datastore::kvdb::ROAccess{*env_}; } virtual datastore::kvdb::RWAccess chaindata_rw() const { return datastore::kvdb::RWAccess{*env_}; } silkworm::ChainConfig get_chain_config() const; const std::filesystem::path& chaindata_dir_path() const { return chaindata_dir_path_; } protected: mdbx::env_managed move_env() { mdbx::env_managed env{std::move(*env_)}; env_.reset(); return env; } std::filesystem::path chaindata_dir_path_; std::unique_ptr env_; }; class TestDataStore : public TestDatabaseContext { public: explicit TestDataStore(const TemporaryDirectory& tmp_dir) : TestDatabaseContext{tmp_dir}, data_store_{ move_env(), DataDirectory{tmp_dir.path(), true}.snapshots().path(), } {} ~TestDataStore() override = default; db::DataStore& operator*() { return data_store_; } db::DataStore* operator->() { return &data_store_; } datastore::kvdb::ROAccess chaindata() const override { return data_store_.chaindata().access_ro(); } datastore::kvdb::RWAccess chaindata_rw() const override { return data_store_.chaindata().access_rw(); } db::DataModelFactory data_model_factory() { return db::DataModelFactory{data_store_.ref()}; } private: db::DataStore data_store_; }; } // namespace silkworm::db::test_util ================================================ FILE: silkworm/db/util.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include #include #include #include #include #include namespace silkworm::db { using datastore::kvdb::from_slice; using datastore::kvdb::to_slice; Bytes storage_prefix(ByteView address, uint64_t incarnation) { SILKWORM_ASSERT(address.size() == kAddressLength || address.size() == kHashLength); Bytes res(address.size() + kIncarnationLength, '\0'); std::memcpy(&res[0], address.data(), address.size()); endian::store_big_u64(&res[address.size()], incarnation); return res; } Bytes storage_prefix(const evmc::address& address, uint64_t incarnation) { return storage_prefix(address.bytes, incarnation); } Bytes composite_storage_key(const evmc::address& address, uint64_t incarnation, HashAsArray hash) { Bytes res(kAddressLength + kIncarnationLength + kHashLength, '\0'); std::memcpy(&res[0], address.bytes, kAddressLength); endian::store_big_u64(&res[kAddressLength], incarnation); std::memcpy(&res[kAddressLength + db::kIncarnationLength], hash, kHashLength); return res; } Bytes block_key(BlockNum block_num) { Bytes key(sizeof(BlockNum), '\0'); endian::store_big_u64(&key[0], block_num); return key; } Bytes block_key(BlockNum block_num, std::span hash) { Bytes key(sizeof(BlockNum) + kHashLength, '\0'); endian::store_big_u64(&key[0], block_num); std::memcpy(&key[8], hash.data(), kHashLength); return key; } std::tuple split_block_key(ByteView key) { SILKWORM_ASSERT(key.size() == sizeof(BlockNum) + kHashLength); ByteView block_num_part = key.substr(0, sizeof(BlockNum)); BlockNum block_num = endian::load_big_u64(block_num_part.data()); ByteView hash_part = key.substr(sizeof(BlockNum)); evmc::bytes32 hash; std::memcpy(hash.bytes, hash_part.data(), hash_part.size()); return {block_num, hash}; } Bytes storage_change_key(BlockNum block_num, const evmc::address& address, uint64_t incarnation) { Bytes res(sizeof(BlockNum) + kPlainStoragePrefixLength, '\0'); endian::store_big_u64(&res[0], block_num); std::memcpy(&res[8], address.bytes, kAddressLength); endian::store_big_u64(&res[8 + kAddressLength], incarnation); return res; } Bytes account_history_key(const evmc::address& address, BlockNum block_num) { Bytes res(kAddressLength + sizeof(BlockNum), '\0'); std::memcpy(&res[0], address.bytes, kAddressLength); endian::store_big_u64(&res[kAddressLength], block_num); return res; } Bytes storage_history_key(const evmc::address& address, const evmc::bytes32& location, BlockNum block_num) { Bytes res(kAddressLength + kHashLength + sizeof(BlockNum), '\0'); std::memcpy(&res[0], address.bytes, kAddressLength); std::memcpy(&res[kAddressLength], location.bytes, kHashLength); endian::store_big_u64(&res[kAddressLength + kHashLength], block_num); return res; } Bytes log_key(BlockNum block_num, uint32_t transaction_id) { Bytes key(sizeof(BlockNum) + sizeof(uint32_t), '\0'); endian::store_big_u64(&key[0], block_num); endian::store_big_u32(&key[8], transaction_id); return key; } Bytes log_address_key(const evmc::address& address, BlockNum block_num) { SILKWORM_ASSERT(block_num <= std::numeric_limits::max()); Bytes key(kAddressLength + sizeof(uint32_t), '\0'); std::memcpy(key.data(), address.bytes, kAddressLength); endian::store_big_u32(key.data() + kAddressLength, static_cast(block_num)); return key; } Bytes log_topic_key(const evmc::bytes32& topic, BlockNum block_num) { SILKWORM_ASSERT(block_num <= std::numeric_limits::max()); Bytes key(kHashLength + sizeof(uint32_t), '\0'); std::memcpy(key.data(), topic.bytes, kHashLength); endian::store_big_u32(key.data() + kHashLength, static_cast(block_num)); return key; } BlockNum block_num_from_key(const mdbx::slice& key) { SILKWORM_ASSERT(key.size() >= sizeof(BlockNum)); ByteView key_view{from_slice(key)}; return endian::load_big_u64(key_view.data()); } std::tuple split_log_key(const mdbx::slice& key) { SILKWORM_ASSERT(key.size() == sizeof(BlockNum) + sizeof(uint32_t)); ByteView key_view{from_slice(key)}; return {endian::load_big_u64(key_view.data()), endian::load_big_u32(key_view.data() + sizeof(BlockNum))}; } std::tuple split_log_address_key(const mdbx::slice& key) { SILKWORM_ASSERT(key.size() == kAddressLength + sizeof(uint32_t)); ByteView key_view{from_slice(key)}; return {key_view.substr(0, kAddressLength), endian::load_big_u32(key_view.data() + kAddressLength)}; } std::tuple split_log_topic_key(const mdbx::slice& key) { SILKWORM_ASSERT(key.size() == kHashLength + sizeof(uint32_t)); ByteView key_view{from_slice(key)}; return {key_view.substr(0, kHashLength), endian::load_big_u32(key_view.data() + kHashLength)}; } std::pair changeset_to_plainstate_format(const ByteView key, ByteView value) { if (key.size() == sizeof(BlockNum)) { if (value.size() < kAddressLength) { throw std::runtime_error("Invalid value length " + std::to_string(value.size()) + " for account changeset in " + std::string(__FUNCTION__)); } // AccountChangeSet const Bytes address{value.substr(0, kAddressLength)}; const Bytes previous_value{value.substr(kAddressLength)}; return {address, previous_value}; } if (key.size() == sizeof(BlockNum) + kPlainStoragePrefixLength) { if (value.size() < kHashLength) { throw std::runtime_error("Invalid value length " + std::to_string(value.size()) + " for storage changeset in " + std::string(__FUNCTION__)); } // StorageChangeSet See storage_change_key Bytes full_key(kPlainStoragePrefixLength + kHashLength, '\0'); std::memcpy(&full_key[0], &key[8], kPlainStoragePrefixLength); std::memcpy(&full_key[kPlainStoragePrefixLength], &value[0], kHashLength); value.remove_prefix(kHashLength); return {full_key, Bytes(value)}; } throw std::runtime_error("Invalid key length " + std::to_string(key.size()) + " in " + std::string(__FUNCTION__)); } std::optional find_value_suffix(datastore::kvdb::ROCursorDupSort& table, ByteView key, ByteView value_prefix) { auto value_prefix_slice{to_slice(value_prefix)}; auto data{table.lower_bound_multivalue(to_slice(key), value_prefix_slice, /*throw_notfound=*/false)}; if (!data || !data.value.starts_with(value_prefix_slice)) { return std::nullopt; } ByteView res{from_slice(data.value)}; res.remove_prefix(value_prefix.size()); return res; } void upsert_storage_value(datastore::kvdb::RWCursorDupSort& state_cursor, ByteView storage_prefix, ByteView location, ByteView new_value) { if (find_value_suffix(state_cursor, storage_prefix, location)) { state_cursor.erase(); } new_value = zeroless_view(new_value); if (!new_value.empty()) { Bytes new_db_value(location.size() + new_value.size(), '\0'); std::memcpy(&new_db_value[0], location.data(), location.size()); std::memcpy(&new_db_value[location.size()], new_value.data(), new_value.size()); state_cursor.upsert(to_slice(storage_prefix), to_slice(new_db_value)); } } Bytes account_domain_key(const evmc::address& address) { return {address.bytes, kAddressLength}; } Bytes storage_domain_key(const evmc::address& address, const evmc::bytes32& location) { Bytes key(kAddressLength + kHashLength, '\0'); std::memcpy(key.data(), address.bytes, kAddressLength); std::memcpy(key.data() + kAddressLength, location.bytes, kHashLength); return key; } Bytes code_domain_key(const evmc::address& address) { return {address.bytes, kAddressLength}; } Bytes topic_domain_key(const evmc::bytes32& topic) { return {topic.bytes, sizeof(topic.bytes)}; } } // namespace silkworm::db ================================================ FILE: silkworm/db/util.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once /* Part of the compatibility layer with the Erigon DB format; see its package dbutils. */ #include #include #include #include #include #include #include #include #include namespace silkworm::db { /* Ancillary entities */ // Used to compare versions of entities (e.g. DbSchema) struct VersionBase { uint32_t major{0}; uint32_t minor{0}; uint32_t patch{0}; std::string to_string() const { return absl::StrCat(major, ".", minor, ".", patch); } // NOLINTNEXTLINE(hicpp-use-nullptr, modernize-use-nullptr) friend auto operator<=>(const VersionBase&, const VersionBase&) = default; }; /* Common Keys */ //! Key for DbInfo bucket storing db schema version inline constexpr std::string_view kDbSchemaVersionKey{"dbVersion"}; //! Key for Sequence bucket storing state version inline constexpr std::string_view kPlainStateVersionKey{"PlainStateVersion"}; inline constexpr size_t kIncarnationLength{8}; inline constexpr size_t kLocationLength{32}; static_assert(kIncarnationLength == sizeof(uint64_t)); static_assert(kLocationLength == sizeof(evmc::bytes32)); inline constexpr size_t kPlainStoragePrefixLength{kAddressLength + kIncarnationLength}; inline constexpr size_t kHashedStoragePrefixLength{kHashLength + kIncarnationLength}; // address -> storage-encoded initial value using AccountChanges = absl::btree_map; // address -> incarnation -> location -> zeroless initial value using ChangedLocations = absl::btree_map; using ChangedIncarnations = absl::btree_map; using StorageChanges = absl::btree_map; // Erigon GenerateStoragePrefix, PlainGenerateStoragePrefix // address can be either plain account address (20 bytes) or hash thereof (32 bytes) Bytes storage_prefix(ByteView address, uint64_t incarnation); Bytes storage_prefix(const evmc::address& address, uint64_t incarnation); Bytes composite_storage_key(const evmc::address& address, uint64_t incarnation, HashAsArray hash); // Erigon EncodeBlockNumber Bytes block_key(BlockNum block_num); // Erigon HeaderKey & BlockBodyKey Bytes block_key(BlockNum block_num, std::span hash); // Split a block key in BlockNum and Hash std::tuple split_block_key(ByteView key); Bytes storage_change_key(BlockNum block_num, const evmc::address& address, uint64_t incarnation); // Erigon IndexChunkKey for account Bytes account_history_key(const evmc::address& address, BlockNum block_num); // Erigon IndexChunkKey for storage Bytes storage_history_key(const evmc::address& address, const evmc::bytes32& location, BlockNum block_num); // Erigon LogKey Bytes log_key(BlockNum block_num, uint32_t transaction_id); //! Encode LogAddressIndex table key for target address Bytes log_address_key(const evmc::address& address, BlockNum block_num); //! Encode LogTopicIndex table key for target topic Bytes log_topic_key(const evmc::bytes32& topic, BlockNum block_num); BlockNum block_num_from_key(const mdbx::slice& key); //! Decode TransactionLog table key into block number and transaction index std::tuple split_log_key(const mdbx::slice& key); //! Decode LogAddressIndex table key into account address and block upper bound std::tuple split_log_address_key(const mdbx::slice& key); //! Decode LogTopicIndex table key into topic hash and block upper bound std::tuple split_log_topic_key(const mdbx::slice& key); //! \brief Converts change set (AccountChangeSet/StorageChangeSet) entry to plain state format. //! \param [in] key : Change set key. //! \param [in] value : Change set value. //! \return Plain state key + previous value of the account or storage. //! \remarks For storage location is returned as the last part of the key, //! while technically in PlainState it's the first part of the value. std::pair changeset_to_plainstate_format(ByteView key, ByteView value); inline mdbx::slice to_slice(const evmc::bytes32& value) { return datastore::kvdb::to_slice(ByteView{value.bytes}); } inline mdbx::slice to_slice(const evmc::address& address) { return datastore::kvdb::to_slice(ByteView{address.bytes}); } // If there exists an entry in a multivalue table with a given key and a value starting with a given prefix, // return the suffix of the value. // Otherwise, return nullopt. std::optional find_value_suffix(datastore::kvdb::ROCursorDupSort& table, ByteView key, ByteView value_prefix); // We can't simply call upsert for storage values because they live in mdbx::value_mode::multi tables void upsert_storage_value(datastore::kvdb::RWCursorDupSort& state_cursor, ByteView storage_prefix, ByteView location, ByteView new_value); //! Build key for account domain given the target address and location Bytes account_domain_key(const evmc::address& address); //! Build key for storage domain given the target address and location Bytes storage_domain_key(const evmc::address& address, const evmc::bytes32& location); //! Build key for code domain given the target address and location Bytes code_domain_key(const evmc::address& address); //! Build key for topic domain given the target topic Bytes topic_domain_key(const evmc::bytes32& topic); } // namespace silkworm::db ================================================ FILE: silkworm/db/util_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include namespace silkworm::db { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; static constexpr evmc::address kZeroAddress = 0x0000000000000000000000000000000000000000_address; static constexpr evmc::bytes32 kZeroHash = 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32; TEST_CASE("all-zero storage prefix", "[core][util]") { const auto address_composite_key{storage_prefix(kZeroAddress, 0)}; CHECK(address_composite_key == Bytes(28, '\0')); const auto location_composite_key{storage_prefix(kZeroHash.bytes, 0)}; CHECK(location_composite_key == Bytes(40, '\0')); } TEST_CASE("non-zero storage prefix for address and incarnation", "[core][util]") { const evmc::address address{0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address}; const uint64_t incarnation{1}; const auto address_composite_key{storage_prefix(address, incarnation)}; CHECK(to_hex(address_composite_key) == "79a4d418f7887dd4d5123a41b6c8c186686ae8cb0000000000000001"); } TEST_CASE("all-zero composite key", "[rpc][core][rawdb][util]") { const auto key{composite_storage_key(kZeroAddress, 0, kZeroHash.bytes)}; CHECK(key == Bytes(60, '\0')); } TEST_CASE("non-zero address composite key", "[rpc][core][rawdb][util]") { const evmc::address address = 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address; const auto key{composite_storage_key(address, 0, kZeroHash.bytes)}; CHECK(key == from_hex("79a4d418f7887dd4d5123a41b6c8c186686ae8cb" "0000000000000000" "0000000000000000000000000000000000000000000000000000000000000000")); } TEST_CASE("non-zero incarnation composite key", "[rpc][core][rawdb][util]") { const auto key{composite_storage_key(kZeroAddress, 37, kZeroHash.bytes)}; CHECK(key == from_hex("0000000000000000000000000000000000000000" "0000000000000025" "0000000000000000000000000000000000000000000000000000000000000000")); } TEST_CASE("non-zero hash composite key", "[rpc][core][rawdb][util]") { const evmc::bytes32 hash = 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32; const auto key{composite_storage_key(kZeroAddress, 0, hash.bytes)}; CHECK(key == from_hex("0000000000000000000000000000000000000000" "0000000000000000" "b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6")); } TEST_CASE("non-zero composite key", "[rpc][core][rawdb][util]") { const evmc::address address = 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address; const evmc::bytes32 hash = 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32; const auto key{composite_storage_key(address, 37, hash.bytes)}; CHECK(key == from_hex("79a4d418f7887dd4d5123a41b6c8c186686ae8cb" "0000000000000025" "b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6")); } TEST_CASE("max incarnation composite key", "[rpc][core][rawdb][util]") { const auto key{composite_storage_key(kZeroAddress, std::numeric_limits::max(), kZeroHash.bytes)}; CHECK(key == from_hex("0000000000000000000000000000000000000000" "ffffffffffffffff" "0000000000000000000000000000000000000000000000000000000000000000")); } } // namespace silkworm::db ================================================ FILE: silkworm/dev/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED) find_package(CLI11 REQUIRED) find_package(nlohmann_json REQUIRED) set(LIBS_PUBLIC "") # cmake-format: off set(LIBS_PRIVATE CLI11::CLI11 absl::time ethash::keccak nlohmann_json::nlohmann_json silkworm_core silkworm_sentry ) # cmake-format: on silkworm_library( silkworm_dev PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) # silkworm_dev_cli depends on silkworm_dev add_subdirectory(cli) ================================================ FILE: silkworm/dev/cli/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(absl REQUIRED) find_package(Boost REQUIRED COMPONENTS headers) find_package(CLI11 REQUIRED) find_package(tomlplusplus REQUIRED) add_executable(embed_toml "embed_toml.cpp") target_link_libraries(embed_toml PRIVATE silkworm_core absl::strings CLI11::CLI11 tomlplusplus::tomlplusplus) add_executable(embed_json "embed_json.cpp") target_link_libraries(embed_json PRIVATE silkworm_core CLI11::CLI11 Boost::headers) add_executable(kzg_g2_uncompress "kzg_g2_uncompress.cpp") target_link_libraries(kzg_g2_uncompress silkworm_core blst::blst) add_executable(state_transition "runner.cpp") target_link_libraries(state_transition PRIVATE silkworm_dev) file(GLOB STATE_TRANSITION_TESTS CONFIGURE_DEPENDS "state_transition_sample*.json") add_custom_command( TARGET state_transition POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${STATE_TRANSITION_TESTS} "${CMAKE_CURRENT_BINARY_DIR}" ) ================================================ FILE: silkworm/dev/cli/embed_json.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include namespace fs = std::filesystem; void to_byte_array(fs::path& in, fs::path& out, const std::string& ns) { std::pair replacements[] = { {std::regex("\n+"), ""}, // New lines {std::regex(" "), " "}, // Double spaces {std::regex(": \""), ":\""}, {std::regex(": \\{"), ":{"}, {std::regex(": \\["), ":["}, {std::regex(": ([0-9]{1,}),"), ":$1,"}}; size_t input_size{fs::file_size(in)}; if (!input_size) { return; } std::vector bytes{}; bytes.reserve(input_size); // Read and process input file std::ifstream in_stream(in.string()); std::string line; while (std::getline(in_stream, line)) { // Remove leading trailing spaces boost::algorithm::trim(line); // Condense (remove the beautification) for (auto& [r, s] : replacements) { line = std::regex_replace(line, r, s); } // Append to byte vector std::transform(line.begin(), line.end(), std::back_inserter(bytes), [](unsigned char c) { return static_cast(c); }); } in_stream.close(); // Write bytes to output file std::string var_name{in.filename().replace_extension("").string()}; std::string const_name{"k" + silkworm::snake_to_camel(var_name)}; std::ofstream out_stream{out.string()}; out_stream << "/* Generated from " << in.filename().string() << " using silkworm embed_json tool */\n"; out_stream << "#include \"" + var_name + ".hpp\"\n"; out_stream << "constexpr char " << const_name << "DataInternal[] = {\n"; auto max{bytes.size()}; auto count{1u}; for (auto& b : bytes) { out_stream << "0x" << std::hex << static_cast(b) << ((count == max) ? "" : ",") << ((count % 16 == 0) ? "\n" : " "); ++count; } out_stream << "};\n"; out_stream << "namespace " + ns + " {\n"; out_stream << "constinit const std::string_view " << const_name << "Json{&" << const_name << "DataInternal[0], sizeof(" << const_name << "DataInternal)};\n"; out_stream << "}\n"; out_stream.close(); } int main(int argc, char* argv[]) { CLI::App app_main("JSON to C++ conversion tool"); std::string input_dir{}; std::string output_dir{}; std::string pattern_prefix{"genesis_"}; std::string ns{"silkworm"}; bool overwrite{false}; app_main.add_option("-i,--input", input_dir, "Input directory for JSON files") ->required() ->check(CLI::ExistingDirectory); app_main.add_option("-o,--output", output_dir, "Output directory for generated C++ source files") ->required() ->check(CLI::ExistingDirectory); app_main.add_option("-p,--pattern_prefix", pattern_prefix, "Regex pattern prefix to use for discovering the files"); app_main.add_option("-n,--namespace", ns, "C++ namespace to use in generated code"); app_main.add_flag("-w,--overwrite", overwrite, "Whether to overwrite existing files"); CLI11_PARSE(app_main, argc, argv) // Get genesis files in input directory const std::string json_file_pattern{"(^" + pattern_prefix + "(.*)?\\.json$)"}; const std::regex pattern{json_file_pattern, std::regex_constants::icase}; fs::path input_path{input_dir}; if (input_path.has_filename()) { input_path += fs::path::preferred_separator; } std::vector input_entries{}; for (const auto& directory_entry : fs::directory_iterator(input_path)) { std::string file_name{directory_entry.path().filename().string()}; if (std::regex_match(file_name, pattern)) { input_entries.push_back(directory_entry); } } if (input_entries.empty()) { std::cerr << "\nNo files matching pattern " + json_file_pattern + " in input directory\n"; return -1; } for (auto& directory_entry : input_entries) { fs::path input_file_path{directory_entry.path()}; fs::path output_file_path{directory_entry.path()}; output_file_path.replace_extension(".cpp"); bool exists{fs::exists(output_file_path)}; bool skip{exists && !overwrite}; std::cout << input_file_path.string() << (skip ? " skipped (already exists)" : " -> " + output_file_path.string()) << "\n"; if (exists && !skip) { fs::remove(output_file_path); } if (!skip) { to_byte_array(input_file_path, output_file_path, ns); } } return 0; } ================================================ FILE: silkworm/dev/cli/embed_toml.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include namespace fs = std::filesystem; int main(int argc, char* argv[]) { // Define the command line options CLI::App app{"Embed files as binary data"}; std::string input_folder, output_folder; bool include_beacon{false}; app.add_option("-i,--input", input_folder, "input folder where to look for files")->required(); app.add_option("-o,--output", output_folder, "output folder where to place generated .hpp files")->required(); app.add_flag("-b,--beacon-blocks", include_beacon, "includes also beacon-chain segments"); // Parse the command line arguments try { app.parse(argc, argv); } catch (const CLI::ParseError& e) { return app.exit(e); } const std::regex hyphen_re{"-"}; // Iterating through all the files in the input folder for (const auto& entry : fs::recursive_directory_iterator(input_folder)) { const fs::path& entry_path = entry.path(); // Skip any file in 'webseed' sub-folder if (entry_path.parent_path().string().ends_with("webseed")) { continue; } // Match only required extension if (entry_path.extension() == ".toml") { std::cout << "Processing TOML file: " << entry_path.string() << "\n"; const auto table = toml::parse_file(entry_path.string()); // Open the output .hpp file fs::path entry_filename = entry.path().stem(); entry_filename.replace_filename(std::regex_replace(entry_filename.string(), hyphen_re, "_")); fs::path output_path = fs::path{output_folder} / entry_filename.replace_extension(".hpp"); std::ofstream output{output_path}; // Write the snapshots as a constexpr std::array std::string snapshot_name = silkworm::snake_to_camel(entry_filename.stem().string()); output << "/* Generated from " << entry.path().filename().string() << " using Silkworm embed_toml */\n\n"; output << "#pragma once\n\n"; output << "#include \n"; output << "#include \n\n"; output << "#include \"../entry.hpp\"\n\n"; output << "namespace silkworm::snapshots {\n\n"; output << "using namespace std::literals;\n\n"; output << "inline constexpr std::array k" << snapshot_name << "Snapshots{\n"; for (auto&& [key, value] : table) { std::string key_str{key.begin(), key.end()}; if (!include_beacon && absl::StrContains(key_str, "beaconblocks")) { continue; } std::string val_str{value.as_string()->get()}; output << " Entry{\"" << key_str << "\"sv, \"" << val_str << "\"sv},\n"; } output << "};\n\n"; output << "} // namespace silkworm::snapshots\n"; } } return 0; } ================================================ FILE: silkworm/dev/cli/kzg_g2_uncompress.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include // TODO(yperbasis) Switch to std::format when Apple Clang has it void print_blst_fp(const blst_fp& fp) { std::cout << "{"; std::cout << "0x" << std::setfill('0') << std::setw(16) << std::hex << fp.l[0] << ", "; std::cout << "0x" << std::setfill('0') << std::setw(16) << std::hex << fp.l[1] << ", "; std::cout << "0x" << std::setfill('0') << std::setw(16) << std::hex << fp.l[2] << ", "; std::cout << "\n "; std::cout << "0x" << std::setfill('0') << std::setw(16) << std::hex << fp.l[3] << ", "; std::cout << "0x" << std::setfill('0') << std::setw(16) << std::hex << fp.l[4] << ", "; std::cout << "0x" << std::setfill('0') << std::setw(16) << std::hex << fp.l[5] << "}"; } int main() { using namespace silkworm; // KZG_SETUP_G2[1], see // https://github.com/ethereum/consensus-specs/blob/dev/presets/mainnet/trusted_setups/trusted_setup_4096.json static const Bytes kKzgSetupG2{*from_hex( "b5bfd7dd8cdeb128843bc287230af38926187075cbfbefa81009a2ce615ac53d2914e5870cb452d2afaaab24f3499f72185cbfee53492714734429b7b38608e23926c911cceceac9a36851477ba4c60b087041de621000edc98edada20c1def2")}; SILKWORM_ASSERT(kKzgSetupG2.size() == 96); blst_p2_affine g2_affine; SILKWORM_ASSERT(blst_p2_uncompress(&g2_affine, kKzgSetupG2.data()) == BLST_SUCCESS); blst_p2 out; blst_p2_from_affine(&out, &g2_affine); // TODO(C++23) std::print std::cout << "{{"; print_blst_fp(out.x.fp[0]); std::cout << ",\n "; print_blst_fp(out.x.fp[1]); std::cout << "}},\n{{"; print_blst_fp(out.y.fp[0]); std::cout << ",\n "; print_blst_fp(out.y.fp[1]); std::cout << "}},\n{{"; print_blst_fp(out.z.fp[0]); std::cout << ",\n "; print_blst_fp(out.z.fp[1]); std::cout << "}}\n"; } ================================================ FILE: silkworm/dev/cli/runner.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include "../state_transition.hpp" void execute_test(const std::string& path, bool terminate_flag, bool diagnostics_flag); using namespace silkworm::cmd::state_transition; namespace fs = std::filesystem; int main(int argc, char* argv[]) { CLI::App app{"Executes Ethereum State Transition tests"}; std::string path = fs::current_path(); app.add_option("path", path, "Path to test file or directory") ->check(CLI::ExistingPath); bool terminate_flag = false; app.add_flag("-t,--terminateOnError", terminate_flag, "Terminate execution on failure"); bool diagnostics_flag = true; app.add_flag("-d,--diagnostics", diagnostics_flag, "Enable extended diagnostics output"); CLI11_PARSE(app, argc, argv) try { if (std::filesystem::is_directory(path)) { for (const auto& test_file : std::filesystem::recursive_directory_iterator(path)) { if (!test_file.is_directory() && test_file.path().extension() == ".json") { execute_test(test_file.path(), terminate_flag, diagnostics_flag); } } } else { execute_test(path, terminate_flag, diagnostics_flag); } } catch (const std::exception& e) { // code to handle exceptions of type std::exception and its derived classes const auto desc = e.what(); std::cerr << "Exception: " << desc << std::endl; } catch (...) { // code to handle any other type of exception std::cerr << "An unknown exception occurred" << std::endl; } } void execute_test(const std::string& path, bool terminate_flag, bool diagnostics_flag) { std::ifstream input_file(path); nlohmann::json base_json; input_file >> base_json; auto state_transition = StateTransition(base_json, terminate_flag, diagnostics_flag); state_transition.run(); } ================================================ FILE: silkworm/dev/cli/state_transition_sample1.json ================================================ { "transactionCollidingWithNonEmptyAccount_init" : { "_info" : { "comment" : "Account with non-empty code attempts to send tx to create a contract", "filling-rpc-server" : "evm version 1.11.4-unstable-e14043db-20230308", "filling-tool-version" : "retesteth-0.3.0-shanghai+commit.fd2c0a83.Linux.g++", "generatedTestHash" : "2302ad062cc3c73dadd07cbdc5cd329e87452493280f2ca315b47d063ac3954e", "lllcversion" : "Version: 0.5.14-develop.2022.7.30+commit.a096d7a9.Linux.g++", "solidity" : "Version: 0.8.17+commit.8df45f5f.Linux.g++", "source" : "src/GeneralStateTestsFiller/stEIP3607/transactionCollidingWithNonEmptyAccount_initFiller.yml", "sourceHash" : "504ed4dad45a35dee016abe8ac646e8850ded61c0d9655f830898a1838e774de" }, "env" : { "currentBaseFee" : "0x0a", "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", "currentDifficulty" : "0x020000", "currentGasLimit" : "0xff112233445566", "currentNumber" : "0x01", "currentRandom" : "0x0000000000000000000000000000000000000000000000000000000000020000", "currentTimestamp" : "0x03e8", "previousHash" : "0x5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6" }, "post" : { "Berlin" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "Byzantium" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "Constantinople" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "ConstantinopleFix" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "EIP150" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "EIP158" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "Frontier" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "Homestead" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "Istanbul" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "London" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "Merge" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ], "Shanghai" : [ { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf84f800a83061a8080830186a0001ca0940546fa422a9310b30cc6b14ecb25996f6f7c56b25b4c4d3ad0f60b56ea7df0a02686b496576a0632b2b9238d6aacb7fa317864b06bb3199b613050c1d8abb42b" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf854800a83061a8080830186a08560206000f31ca0b3090d3211444a7b1530ae2b72bfd606fc5902d2d04bb2390448361b3d198d94a05c69af38472b9a5c913eb413379078dbb3beed941467229da6d47bf5c82d67c0" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf870800a83061a8080830186a0a160008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af1501ca028eb6595001be8a5556ecbecb63b4225d915f175a7a2fc4a33e27a13df864afba072a2fff6753b0cb4db3da46885af5b1cd79ac06ce4190c72992c5bb21d21834e" }, { "expectException" : "SenderNotEOA", "hash" : "0xe4cbd6db8a1703c767c4eb649b108ca6e68039006bf277fdb7398933a6515cad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf86d800a83061a8080830186a09e60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af4501ba0939415f7af45efd937eb2deec568614aaca3196c58cf3912a8c8b7aaa5f65748a04c0046c94a6eedc8a10b75bfb664e442b7665441187333c2fdfe4e3e688dbe51" } ] }, "pre" : { "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba" : { "balance" : "0x00", "code" : "0x", "nonce" : "0x01", "storage" : { } }, "0x6295ee1b4f6dd65047762f924ecd367c17eabf8f" : { "balance" : "0x00", "code" : "0x", "nonce" : "0x00", "storage" : { } }, "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" : { "balance" : "0x0de0b6b3a7640000", "code" : "0x00", "nonce" : "0x00", "storage" : { } }, "0xd0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0" : { "balance" : "0x00", "code" : "0x00", "nonce" : "0x00", "storage" : { } } }, "transaction" : { "data" : [ "0x00", "0x60206000f3", "0x60008060008061271073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af150", "0x60008060008073d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d05af450" ], "gasLimit" : [ "0x061a80" ], "gasPrice" : "0x0a", "nonce" : "0x00", "secretKey" : "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", "sender" : "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "to" : "", "value" : [ "0x0186a0" ] } } } ================================================ FILE: silkworm/dev/cli/state_transition_sample2.json ================================================ { "add" : { "_info" : { "comment" : "Ori Pomerantz qbzzt1@gmail.com", "filling-rpc-server" : "evm version 1.11.4-unstable-e14043db-20230308", "filling-tool-version" : "retesteth-0.3.0-shanghai+commit.fd2c0a83.Linux.g++", "generatedTestHash" : "f486c80e808d34507133961cbd17c5e0f9ec049879dd3f7cc78a9eb55ac63226", "labels" : { "0" : "add_neg1_neg1", "1" : "add_neg1_4", "2" : "add_neg1_1", "3" : "add_0_0", "4" : "add_1_neg1" }, "lllcversion" : "Version: 0.5.14-develop.2022.7.30+commit.a096d7a9.Linux.g++", "solidity" : "Version: 0.8.17+commit.8df45f5f.Linux.g++", "source" : "src/GeneralStateTestsFiller/VMTests/vmArithmeticTest/addFiller.yml", "sourceHash" : "78afea990a2d534831acc4883b9ff6e81d560091942db7234232d68fdbf1c33e" }, "env" : { "currentBaseFee" : "0x0a", "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", "currentDifficulty" : "0x020000", "currentGasLimit" : "0x05f5e100", "currentNumber" : "0x01", "currentRandom" : "0x0000000000000000000000000000000000000000000000000000000000020000", "currentTimestamp" : "0x03e8", "previousHash" : "0x5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6" }, "post" : { "Berlin" : [ { "hash" : "0xb9eda41f4a719d9f2ae332e3954de18bceeeba2248a44110878949384b184888", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000001ba0e8ff56322287185f6afd3422a825b47bf5c1a4ccf0dc0389cdc03f7c1c32b7eaa0776b02f9f5773238d3ff36b74a123f409cd6420908d7855bbe4c8ff63e00d698" }, { "hash" : "0x087e7839e47daed35865a982673e27b82aab8da617a2abf9b853e677f942453e", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000011ba02c5e81a024dd0f6fb773c8787fa46ab5eb55cb73df83562e6ddbe9106a3df7f6a029437b9a23e45bbfce086f2ddaa98b1e9e6914d7e58e2c5a128310042b332f89" }, { "hash" : "0xf4bf0cd7a5634829eb622ab8d85e2e21fc0caa24f584b22f5de5479939e151f1", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000021ba0fc37ad4eb0633eb18f2b7867bacbe994a2ffcbb04a71e394e6e76041f6ce216fa03b1b415a5c386d8de9e16be9fdc188234b80a0dec99922d03c240f2e463053e3" }, { "hash" : "0xf4bf0cd7a5634829eb622ab8d85e2e21fc0caa24f584b22f5de5479939e151f1", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000031ba0f06eb219c5dba98711a9a2678339f64d172bfac289a5c43a0018d3917be8dc2aa0147bd7a6ee30217e63cbddc28b0e72f115da754d8916b87992aa27ed00eb105e" }, { "hash" : "0xf4bf0cd7a5634829eb622ab8d85e2e21fc0caa24f584b22f5de5479939e151f1", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000041ba0c148a101aa54703ff0e949441bdba90b1972a16c338f7f9a24b07f0313cd49d6a028cb82229b8a57e2048761d6fa5060c5b459f000d4e218de1372c1df9cfa171e" } ], "Istanbul" : [ { "hash" : "0x890902aa61ffa7639ef5a249d1c4fbc21d283fcf0060d747d673a95f07bc5d59", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000001ba0e8ff56322287185f6afd3422a825b47bf5c1a4ccf0dc0389cdc03f7c1c32b7eaa0776b02f9f5773238d3ff36b74a123f409cd6420908d7855bbe4c8ff63e00d698" }, { "hash" : "0x2cc4e9be08b4a2a8e45e48c52ca3035a824fd3f4391234bbf4eb56c9915a9570", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000011ba02c5e81a024dd0f6fb773c8787fa46ab5eb55cb73df83562e6ddbe9106a3df7f6a029437b9a23e45bbfce086f2ddaa98b1e9e6914d7e58e2c5a128310042b332f89" }, { "hash" : "0x0daa521697a12d653f03d8746876c82a1ea7f6f81af57715e215e89ecfab3c4a", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000021ba0fc37ad4eb0633eb18f2b7867bacbe994a2ffcbb04a71e394e6e76041f6ce216fa03b1b415a5c386d8de9e16be9fdc188234b80a0dec99922d03c240f2e463053e3" }, { "hash" : "0x0daa521697a12d653f03d8746876c82a1ea7f6f81af57715e215e89ecfab3c4a", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000031ba0f06eb219c5dba98711a9a2678339f64d172bfac289a5c43a0018d3917be8dc2aa0147bd7a6ee30217e63cbddc28b0e72f115da754d8916b87992aa27ed00eb105e" }, { "hash" : "0x0daa521697a12d653f03d8746876c82a1ea7f6f81af57715e215e89ecfab3c4a", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000041ba0c148a101aa54703ff0e949441bdba90b1972a16c338f7f9a24b07f0313cd49d6a028cb82229b8a57e2048761d6fa5060c5b459f000d4e218de1372c1df9cfa171e" } ], "London" : [ { "hash" : "0x6e9dccb57a15e2885ff1193da0db98cbaaac218bf3a0abeb0c3ceff966de2830", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000001ba0e8ff56322287185f6afd3422a825b47bf5c1a4ccf0dc0389cdc03f7c1c32b7eaa0776b02f9f5773238d3ff36b74a123f409cd6420908d7855bbe4c8ff63e00d698" }, { "hash" : "0x1a3420dfb2280397c1b81ff159bd4d6eddc12d7e333e82a01fd4afafad3b2ae4", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000011ba02c5e81a024dd0f6fb773c8787fa46ab5eb55cb73df83562e6ddbe9106a3df7f6a029437b9a23e45bbfce086f2ddaa98b1e9e6914d7e58e2c5a128310042b332f89" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000021ba0fc37ad4eb0633eb18f2b7867bacbe994a2ffcbb04a71e394e6e76041f6ce216fa03b1b415a5c386d8de9e16be9fdc188234b80a0dec99922d03c240f2e463053e3" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000031ba0f06eb219c5dba98711a9a2678339f64d172bfac289a5c43a0018d3917be8dc2aa0147bd7a6ee30217e63cbddc28b0e72f115da754d8916b87992aa27ed00eb105e" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000041ba0c148a101aa54703ff0e949441bdba90b1972a16c338f7f9a24b07f0313cd49d6a028cb82229b8a57e2048761d6fa5060c5b459f000d4e218de1372c1df9cfa171e" } ], "Merge" : [ { "hash" : "0x6e9dccb57a15e2885ff1193da0db98cbaaac218bf3a0abeb0c3ceff966de2830", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000001ba0e8ff56322287185f6afd3422a825b47bf5c1a4ccf0dc0389cdc03f7c1c32b7eaa0776b02f9f5773238d3ff36b74a123f409cd6420908d7855bbe4c8ff63e00d698" }, { "hash" : "0x1a3420dfb2280397c1b81ff159bd4d6eddc12d7e333e82a01fd4afafad3b2ae4", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000011ba02c5e81a024dd0f6fb773c8787fa46ab5eb55cb73df83562e6ddbe9106a3df7f6a029437b9a23e45bbfce086f2ddaa98b1e9e6914d7e58e2c5a128310042b332f89" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000021ba0fc37ad4eb0633eb18f2b7867bacbe994a2ffcbb04a71e394e6e76041f6ce216fa03b1b415a5c386d8de9e16be9fdc188234b80a0dec99922d03c240f2e463053e3" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000031ba0f06eb219c5dba98711a9a2678339f64d172bfac289a5c43a0018d3917be8dc2aa0147bd7a6ee30217e63cbddc28b0e72f115da754d8916b87992aa27ed00eb105e" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000041ba0c148a101aa54703ff0e949441bdba90b1972a16c338f7f9a24b07f0313cd49d6a028cb82229b8a57e2048761d6fa5060c5b459f000d4e218de1372c1df9cfa171e" } ], "Shanghai" : [ { "hash" : "0x6e9dccb57a15e2885ff1193da0db98cbaaac218bf3a0abeb0c3ceff966de2830", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000001ba0e8ff56322287185f6afd3422a825b47bf5c1a4ccf0dc0389cdc03f7c1c32b7eaa0776b02f9f5773238d3ff36b74a123f409cd6420908d7855bbe4c8ff63e00d698" }, { "hash" : "0x1a3420dfb2280397c1b81ff159bd4d6eddc12d7e333e82a01fd4afafad3b2ae4", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000011ba02c5e81a024dd0f6fb773c8787fa46ab5eb55cb73df83562e6ddbe9106a3df7f6a029437b9a23e45bbfce086f2ddaa98b1e9e6914d7e58e2c5a128310042b332f89" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000021ba0fc37ad4eb0633eb18f2b7867bacbe994a2ffcbb04a71e394e6e76041f6ce216fa03b1b415a5c386d8de9e16be9fdc188234b80a0dec99922d03c240f2e463053e3" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000031ba0f06eb219c5dba98711a9a2678339f64d172bfac289a5c43a0018d3917be8dc2aa0147bd7a6ee30217e63cbddc28b0e72f115da754d8916b87992aa27ed00eb105e" }, { "hash" : "0x416be8cb4f40d5a29ed56578cf776c5198e58c181ab3534a1094df5f7f61fb02", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf885800a8404c4b40094cccccccccccccccccccccccccccccccccccccccc01a4693c613900000000000000000000000000000000000000000000000000000000000000041ba0c148a101aa54703ff0e949441bdba90b1972a16c338f7f9a24b07f0313cd49d6a028cb82229b8a57e2048761d6fa5060c5b459f000d4e218de1372c1df9cfa171e" } ] }, "pre" : { "0x0000000000000000000000000000000000000100" : { "balance" : "0x0ba1a9ce0ba1a9ce", "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0160005500", "nonce" : "0x00", "storage" : { } }, "0x0000000000000000000000000000000000000101" : { "balance" : "0x0ba1a9ce0ba1a9ce", "code" : "0x60047fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0160005500", "nonce" : "0x00", "storage" : { } }, "0x0000000000000000000000000000000000000102" : { "balance" : "0x0ba1a9ce0ba1a9ce", "code" : "0x60017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0160005500", "nonce" : "0x00", "storage" : { } }, "0x0000000000000000000000000000000000000103" : { "balance" : "0x0ba1a9ce0ba1a9ce", "code" : "0x600060000160005500", "nonce" : "0x00", "storage" : { } }, "0x0000000000000000000000000000000000000104" : { "balance" : "0x0ba1a9ce0ba1a9ce", "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60010160005500", "nonce" : "0x00", "storage" : { } }, "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" : { "balance" : "0x0ba1a9ce0ba1a9ce", "code" : "0x", "nonce" : "0x00", "storage" : { } }, "0xcccccccccccccccccccccccccccccccccccccccc" : { "balance" : "0x0ba1a9ce0ba1a9ce", "code" : "0x600060006000600060006004356101000162fffffff100", "nonce" : "0x00", "storage" : { } } }, "transaction" : { "data" : [ "0x693c61390000000000000000000000000000000000000000000000000000000000000000", "0x693c61390000000000000000000000000000000000000000000000000000000000000001", "0x693c61390000000000000000000000000000000000000000000000000000000000000002", "0x693c61390000000000000000000000000000000000000000000000000000000000000003", "0x693c61390000000000000000000000000000000000000000000000000000000000000004" ], "gasLimit" : [ "0x04c4b400" ], "gasPrice" : "0x0a", "nonce" : "0x00", "secretKey" : "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", "sender" : "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "to" : "0xcccccccccccccccccccccccccccccccccccccccc", "value" : [ "0x01" ] } } } ================================================ FILE: silkworm/dev/cli/state_transition_sample3.json ================================================ { "sstore_0toX" : { "_info" : { "comment" : "change 0 -> X", "filling-rpc-server" : "evm version 1.11.4-unstable-e14043db-20230308", "filling-tool-version" : "retesteth-0.3.0-shanghai+commit.fd2c0a83.Linux.g++", "generatedTestHash" : "dfbfbf5fef87373626cb57635e652497ddeaaa263de4a86f0146d1ae5e7ba3fa", "lllcversion" : "Version: 0.5.14-develop.2022.7.30+commit.a096d7a9.Linux.g++", "solidity" : "Version: 0.8.17+commit.8df45f5f.Linux.g++", "source" : "src/GeneralStateTestsFiller/stSStoreTest/sstore_0toXFiller.json", "sourceHash" : "cb35aa543dd808a612e3dbe3cb135ee711f1e61ef5b7606c576dc03c4ca66ec7" }, "env" : { "currentBaseFee" : "0x0a", "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", "currentDifficulty" : "0x020000", "currentGasLimit" : "0x989680", "currentNumber" : "0x01", "currentRandom" : "0x0000000000000000000000000000000000000000000000000000000000020000", "currentTimestamp" : "0x03e8", "previousHash" : "0x5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6" }, "post" : { "Berlin" : [ { "hash" : "0x2ec26efa89ee50730f79c843bd4b308091624e6060af0cb8312535bc6ea1f85c", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" }, { "hash" : "0x7b4bcb7f21285f6f37dc3cb84a2a5905f7c143309786ad1168a5077cb1e741f7", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca048c329c318ef294c01fa84b23d32b456522a6e03ace3e1715e96affb23836d60a072adc29e1372f2b4702909f78db64794d9655a6c6f2bac9a46e855583178cc8a" }, { "hash" : "0xf005453c3d92d15d823e265cf035b9296d59088552951f43bb51379882f04fff", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba06bd5d343d3464037c48816eaaccef380c05f0aba404fb61066e28e151630a399a043aa7a51bf793537d8075eaf3c5203219ed193b34450fc769f826f1614fdece5" }, { "hash" : "0x95c0b085e75f13d6ed37894d5225ad463c9797741c3d9a0ab359bc92368998ad", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca035de56c470a52f918a129466e839c256f86cb18839ee9b3c71346cceafd8a940a02b2c24538c4bb8d3e92a85fb91c730a19aa93949211d658f8928480ef238c20a" }, { "hash" : "0xa82f3bbe8aa9e36fcd1a5cba8e0f5c9218193718a558ff76cb86df0af0b6ab6a", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a830f42408001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca02b91928cda056c79e297e94c5101dd0eb6ef8cf0eefeb310c006ce666e17b3cea00b4f9c9e4f32859ca026d38b92ededb4e7bb17f0b6a48ea8ec722665eb945e6e" }, { "hash" : "0x303bccf1cc76882f557b51da03ff0fb514306756771971b3eb01814139e7d12a", "indexes" : { "data" : 0, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca0fad4ae4940524505a78bee34f699dced7a73811fcb24e0fcc28b47b0b927ea72a067752aa14d634516b6662a9f6c1897f5f0b35683689deff4df10ea925eb26fb4" }, { "hash" : "0xefbace0b44d4a2d829972d480522274df2248d48500a148e3ee9ffa382e954e2", "indexes" : { "data" : 1, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba04e95fca435ff01ae5eb30060568a69ff99b2b76e289f6fe9375cd68177b893d7a01d3ce37852be4074aa5c3fdaccda1c20c30822ebc517cb9174fba88a79a1cd78" }, { "hash" : "0xefbace0b44d4a2d829972d480522274df2248d48500a148e3ee9ffa382e954e2", "indexes" : { "data" : 2, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca02dd1ddbcbe6b2a0200b86479ec7fabf4db02be176a1f5891fde66522f465f6c8a063578e4c87563c235a2072f29d5db30b17dc9756172495eeec4854b9b6ed8141" }, { "hash" : "0x72e3f11a62afbf85239b43ca0402dcf47cae37afd80f12329c1fae99b6fef059", "indexes" : { "data" : 3, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca052dbb3017da185f08658817c46e2c7f8080d464f6f15ae2ef22d104747ad5444a0723f3afbe97b9cd317da9429d4a108b09624a211344c554de40324e95fcdc2df" }, { "hash" : "0x95c0d21ee39dca7e60644104babb6c7e2ce9b14420999ee550c8bb63873cb41d", "indexes" : { "data" : 4, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a83061a808001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca05f7a0f7abc76f27c374692b6c09129a7ea4fc8fb72c0c588f534d5dedd149d54a01ab01faa66ddf3c187dadd51ef13be38fcff1afd5e2ba44be8d394919050e69c" }, { "hash" : "0xf1192aced6b570085042bfd6985cedec3996ffe80dd6952b844c9116ef0d2f44", "indexes" : { "data" : 5, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c0dea8139896e3ee724a8197c6af26f8d37815e104703a38f099fdc1fbcc1858a019f912dd5dc0002d242cb80f919c88dc246d46b18f4e232e1a823edcf3b91760" }, { "hash" : "0xf1192aced6b570085042bfd6985cedec3996ffe80dd6952b844c9116ef0d2f44", "indexes" : { "data" : 6, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca060df0b4c80fac15ff33e997835bd24347e422ca2e3151a4c58fa36ad4c97fd0da065434d6ebf15e6feba700b2a9182048028fa2bac2f2e1ffaba5aa9549b1e2cc1" }, { "hash" : "0x2da63abfb3f2c3f693c39032bf8c9caf37d5e1c9d7a9c45844b9ec786158f49f", "indexes" : { "data" : 7, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba08b66929491f74f1d4a49769ec2ab46967233cac053d16b8244feadec525aed5ea061c919679208d0bc70cb044ade54c9a219817c6e34d02c60a7970181692ad174" }, { "hash" : "0x89ae12d6a4b4dc15db1b453a08aead99468e47f525a36e976cfd087130fa2501", "indexes" : { "data" : 8, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0ae03549e6699bf9d143f629a6be56c3ea626e395b938d2f84dbbc4c7c2654358a00e559728e9af818b2eee816e1194161f6bb07581a6a9baafad93d9dc51fe55d0" }, { "hash" : "0xf3927fe4c86429b8a81da1eeef587b415b9716865e6ed91b457b8d80dc46a14e", "indexes" : { "data" : 9, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ba0d877bdaa9762604458029e3708ae750ce90b30efe37c113a8bb021b6371ce291a04ddd0a26127131ccac2e07659129bbb0fdf84593db6da45ce0c8a5e72b7a0fff" }, { "hash" : "0x355727aa957b6afb858d788343095a2b802244b229a7f6cabfbdbac61cd8115d", "indexes" : { "data" : 5, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0eac1392a9a7e844b64e8dc88c53650554c238cf8dc81dd43a445e6fe98e3c9a5a0080c5b33f0699396b7f6653cf338bcc070b5217dee68c8f2df58aee42cad8ec9" }, { "hash" : "0x355727aa957b6afb858d788343095a2b802244b229a7f6cabfbdbac61cd8115d", "indexes" : { "data" : 6, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0d73493cb4d6dacff395116173ff74d6fa921d523c2e644e597a5cf02222cbaefa07d7ad02b311048c6e2283606902f3f47bb6378c00604e76aae46ce483a8f9c9e" }, { "hash" : "0xcc318495395dcb9e9c90dcece8225ed774bf332761f77049eb050a0371596012", "indexes" : { "data" : 7, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0185258bc1c3c16e0711917dd6e12f177530fd66120e82b98434fb733cfb6455ca01798f241fcffdc49ef0d4ddb63d29d00e437abb6415139b14d9bf186992fa75e" }, { "hash" : "0x8cd8f7a32d6f7bc7eeaebe68962ec2f76d7d60b7bff901002cac9420ae437b56", "indexes" : { "data" : 8, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c3b68b2f9a699f9de3cec2b5d7464e8890c5f6b7532a8fde991433602cb46f3ba0115c0f80763fbbf4010da968e10c17e67d1e569f4eb68dc568650716c903f654" }, { "hash" : "0xd2bb5d2c519bde014b73b8a982febf127963ddd1de402b43ee486eeb38d00479", "indexes" : { "data" : 9, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ca028293b1e39a8be424d52122ccfd83fcf8d01651a6e709e0cc2e2e187946f93baa03ef02b1794a48796164a2430ee02cdf219c6a6104ec22d3cc2f28d3cce4db87c" } ], "Istanbul" : [ { "hash" : "0x039accbcd0cb85cc33b8b9362aa7e6a4afb9b3af607a16d601fec46bbc3e0be8", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" }, { "hash" : "0x4488cb2b733bd7406a671ca1d1b3deb2d5a10aadb03212c9a1819ac33612f83b", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca048c329c318ef294c01fa84b23d32b456522a6e03ace3e1715e96affb23836d60a072adc29e1372f2b4702909f78db64794d9655a6c6f2bac9a46e855583178cc8a" }, { "hash" : "0xd537a1a6e8c8db1799ae69a051cbff35bb4bf4c0b349fc6c787a9589ca9d9b41", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba06bd5d343d3464037c48816eaaccef380c05f0aba404fb61066e28e151630a399a043aa7a51bf793537d8075eaf3c5203219ed193b34450fc769f826f1614fdece5" }, { "hash" : "0xe751cd68b7bf467981264f8018e91c05c669883c709210bdd336678e87a8c1d7", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca035de56c470a52f918a129466e839c256f86cb18839ee9b3c71346cceafd8a940a02b2c24538c4bb8d3e92a85fb91c730a19aa93949211d658f8928480ef238c20a" }, { "hash" : "0x301d9aa532c04aff6410cf0555d6df306fa80d1421b70aaa64112dcdf41aa57c", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a830f42408001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca02b91928cda056c79e297e94c5101dd0eb6ef8cf0eefeb310c006ce666e17b3cea00b4f9c9e4f32859ca026d38b92ededb4e7bb17f0b6a48ea8ec722665eb945e6e" }, { "hash" : "0x908ff9f28bc79413e95471c44140ee2fd443c9e5f4e397c481db7943a880350e", "indexes" : { "data" : 0, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca0fad4ae4940524505a78bee34f699dced7a73811fcb24e0fcc28b47b0b927ea72a067752aa14d634516b6662a9f6c1897f5f0b35683689deff4df10ea925eb26fb4" }, { "hash" : "0x913895211ccbbfd4ad63c7b3df55218ca2af36fe6cc76741610a1c2ff194ff08", "indexes" : { "data" : 1, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba04e95fca435ff01ae5eb30060568a69ff99b2b76e289f6fe9375cd68177b893d7a01d3ce37852be4074aa5c3fdaccda1c20c30822ebc517cb9174fba88a79a1cd78" }, { "hash" : "0x913895211ccbbfd4ad63c7b3df55218ca2af36fe6cc76741610a1c2ff194ff08", "indexes" : { "data" : 2, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca02dd1ddbcbe6b2a0200b86479ec7fabf4db02be176a1f5891fde66522f465f6c8a063578e4c87563c235a2072f29d5db30b17dc9756172495eeec4854b9b6ed8141" }, { "hash" : "0xfc8b9b527bc0e811be5c507712d92ca22665539af04e10ea9ff637632d6d5399", "indexes" : { "data" : 3, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca052dbb3017da185f08658817c46e2c7f8080d464f6f15ae2ef22d104747ad5444a0723f3afbe97b9cd317da9429d4a108b09624a211344c554de40324e95fcdc2df" }, { "hash" : "0xd8ba9ec32b7880eca3a6e73497568bbd7924d3c3aa068e6ee724ff6d20831105", "indexes" : { "data" : 4, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a83061a808001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca05f7a0f7abc76f27c374692b6c09129a7ea4fc8fb72c0c588f534d5dedd149d54a01ab01faa66ddf3c187dadd51ef13be38fcff1afd5e2ba44be8d394919050e69c" }, { "hash" : "0xf72a6412bd7d0c00075a12717a823f176b8c246f19d104246bf6a7248c7024e1", "indexes" : { "data" : 5, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c0dea8139896e3ee724a8197c6af26f8d37815e104703a38f099fdc1fbcc1858a019f912dd5dc0002d242cb80f919c88dc246d46b18f4e232e1a823edcf3b91760" }, { "hash" : "0xf72a6412bd7d0c00075a12717a823f176b8c246f19d104246bf6a7248c7024e1", "indexes" : { "data" : 6, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca060df0b4c80fac15ff33e997835bd24347e422ca2e3151a4c58fa36ad4c97fd0da065434d6ebf15e6feba700b2a9182048028fa2bac2f2e1ffaba5aa9549b1e2cc1" }, { "hash" : "0x1fda20a38c8627b5d9530485e3d5da6b1a719413b4141fb3714d1520cdaa78b1", "indexes" : { "data" : 7, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba08b66929491f74f1d4a49769ec2ab46967233cac053d16b8244feadec525aed5ea061c919679208d0bc70cb044ade54c9a219817c6e34d02c60a7970181692ad174" }, { "hash" : "0xdaebc5a97e3eb6ee2156a026a1197743580e50e18a56a6e07133b06dec6cd9ee", "indexes" : { "data" : 8, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0ae03549e6699bf9d143f629a6be56c3ea626e395b938d2f84dbbc4c7c2654358a00e559728e9af818b2eee816e1194161f6bb07581a6a9baafad93d9dc51fe55d0" }, { "hash" : "0x021623b4f38412e6f0ab402641f03fbc7ca72d85eaeb535506bf89fe9d20a5de", "indexes" : { "data" : 9, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ba0d877bdaa9762604458029e3708ae750ce90b30efe37c113a8bb021b6371ce291a04ddd0a26127131ccac2e07659129bbb0fdf84593db6da45ce0c8a5e72b7a0fff" }, { "hash" : "0x6d44a2b99a07ac00fe34263777b33e3935df45084b1fec77cc6fd7dbe4290a06", "indexes" : { "data" : 5, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0eac1392a9a7e844b64e8dc88c53650554c238cf8dc81dd43a445e6fe98e3c9a5a0080c5b33f0699396b7f6653cf338bcc070b5217dee68c8f2df58aee42cad8ec9" }, { "hash" : "0x6d44a2b99a07ac00fe34263777b33e3935df45084b1fec77cc6fd7dbe4290a06", "indexes" : { "data" : 6, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0d73493cb4d6dacff395116173ff74d6fa921d523c2e644e597a5cf02222cbaefa07d7ad02b311048c6e2283606902f3f47bb6378c00604e76aae46ce483a8f9c9e" }, { "hash" : "0x93a5d52c11f9e723c666cd3a2bd7b3723520d9512a25e5040f5a689f4bb6810a", "indexes" : { "data" : 7, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0185258bc1c3c16e0711917dd6e12f177530fd66120e82b98434fb733cfb6455ca01798f241fcffdc49ef0d4ddb63d29d00e437abb6415139b14d9bf186992fa75e" }, { "hash" : "0xc92eef60ad543b1e815d7ffbd89deff54689b68602dfe5aced3779fdd49ebd30", "indexes" : { "data" : 8, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c3b68b2f9a699f9de3cec2b5d7464e8890c5f6b7532a8fde991433602cb46f3ba0115c0f80763fbbf4010da968e10c17e67d1e569f4eb68dc568650716c903f654" }, { "hash" : "0x44707490a19d39639fb9f9118d92b627d7e2fa6d3826fbf6baa637f0cbd0fb45", "indexes" : { "data" : 9, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ca028293b1e39a8be424d52122ccfd83fcf8d01651a6e709e0cc2e2e187946f93baa03ef02b1794a48796164a2430ee02cdf219c6a6104ec22d3cc2f28d3cce4db87c" } ], "London" : [ { "hash" : "0x1d2b5ff1fcd40af03d7a96e30c6e7defd3ac783a85a19bcafd0e4d4af02ed29d", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" }, { "hash" : "0xc15fb82b438f1b2d29d101f895cd8557438d3c5bc68f5c8a6f5d24452312227a", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca048c329c318ef294c01fa84b23d32b456522a6e03ace3e1715e96affb23836d60a072adc29e1372f2b4702909f78db64794d9655a6c6f2bac9a46e855583178cc8a" }, { "hash" : "0x858047eba3bacb4d5b6973ad1d780a96de9f8832b0022547fe608e874e66846a", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba06bd5d343d3464037c48816eaaccef380c05f0aba404fb61066e28e151630a399a043aa7a51bf793537d8075eaf3c5203219ed193b34450fc769f826f1614fdece5" }, { "hash" : "0x8906e4ec94b29e271579e575e231f47e39276c83a5aebacbdfccd47e47406cab", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca035de56c470a52f918a129466e839c256f86cb18839ee9b3c71346cceafd8a940a02b2c24538c4bb8d3e92a85fb91c730a19aa93949211d658f8928480ef238c20a" }, { "hash" : "0x2527b53daec42f7657b3ae5a6611bf68a7eabd95ae1d9ed5d7e2f435c33818f2", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a830f42408001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca02b91928cda056c79e297e94c5101dd0eb6ef8cf0eefeb310c006ce666e17b3cea00b4f9c9e4f32859ca026d38b92ededb4e7bb17f0b6a48ea8ec722665eb945e6e" }, { "hash" : "0x142de48fbcc4b27e1a767d9f1c007b2dc1155d1ebaf047aea72f2df7ac024963", "indexes" : { "data" : 0, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca0fad4ae4940524505a78bee34f699dced7a73811fcb24e0fcc28b47b0b927ea72a067752aa14d634516b6662a9f6c1897f5f0b35683689deff4df10ea925eb26fb4" }, { "hash" : "0x0f43bc94326f2b728a2b3d63edbbdd14132351901076e074dc47bec1aef99a17", "indexes" : { "data" : 1, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba04e95fca435ff01ae5eb30060568a69ff99b2b76e289f6fe9375cd68177b893d7a01d3ce37852be4074aa5c3fdaccda1c20c30822ebc517cb9174fba88a79a1cd78" }, { "hash" : "0x0f43bc94326f2b728a2b3d63edbbdd14132351901076e074dc47bec1aef99a17", "indexes" : { "data" : 2, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca02dd1ddbcbe6b2a0200b86479ec7fabf4db02be176a1f5891fde66522f465f6c8a063578e4c87563c235a2072f29d5db30b17dc9756172495eeec4854b9b6ed8141" }, { "hash" : "0x5c75466d014a5be287f34812765820b18f6cf50c410d042266f114c331261866", "indexes" : { "data" : 3, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca052dbb3017da185f08658817c46e2c7f8080d464f6f15ae2ef22d104747ad5444a0723f3afbe97b9cd317da9429d4a108b09624a211344c554de40324e95fcdc2df" }, { "hash" : "0xed885c9d666aaea5ed7d4fa8df5267e4cb0dd6d8927117a3c36f88310cc2044c", "indexes" : { "data" : 4, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a83061a808001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca05f7a0f7abc76f27c374692b6c09129a7ea4fc8fb72c0c588f534d5dedd149d54a01ab01faa66ddf3c187dadd51ef13be38fcff1afd5e2ba44be8d394919050e69c" }, { "hash" : "0x05038fb9c20e8dbc9fc602a9fb5ce40483eeba528b45e4c3f5cc5953ac89e589", "indexes" : { "data" : 5, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c0dea8139896e3ee724a8197c6af26f8d37815e104703a38f099fdc1fbcc1858a019f912dd5dc0002d242cb80f919c88dc246d46b18f4e232e1a823edcf3b91760" }, { "hash" : "0x05038fb9c20e8dbc9fc602a9fb5ce40483eeba528b45e4c3f5cc5953ac89e589", "indexes" : { "data" : 6, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca060df0b4c80fac15ff33e997835bd24347e422ca2e3151a4c58fa36ad4c97fd0da065434d6ebf15e6feba700b2a9182048028fa2bac2f2e1ffaba5aa9549b1e2cc1" }, { "hash" : "0x4c861c1415488f5be1c23c7cc0ff3feefe6fc520e481a6949db824d1240ce578", "indexes" : { "data" : 7, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba08b66929491f74f1d4a49769ec2ab46967233cac053d16b8244feadec525aed5ea061c919679208d0bc70cb044ade54c9a219817c6e34d02c60a7970181692ad174" }, { "hash" : "0x306ff7d66fad6bfd0d475c8d7a1b2f39d0c6e2ccb595ae82bcb10254f583ad35", "indexes" : { "data" : 8, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0ae03549e6699bf9d143f629a6be56c3ea626e395b938d2f84dbbc4c7c2654358a00e559728e9af818b2eee816e1194161f6bb07581a6a9baafad93d9dc51fe55d0" }, { "hash" : "0xa824a3f2804d725645409aa1ab3c0446fcd4bdf6035b700bb41f102ca56eafad", "indexes" : { "data" : 9, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ba0d877bdaa9762604458029e3708ae750ce90b30efe37c113a8bb021b6371ce291a04ddd0a26127131ccac2e07659129bbb0fdf84593db6da45ce0c8a5e72b7a0fff" }, { "hash" : "0x2a0f95b89972552201ce9b1841ca47f591addbb5435063a552ac7d33a32cf147", "indexes" : { "data" : 5, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0eac1392a9a7e844b64e8dc88c53650554c238cf8dc81dd43a445e6fe98e3c9a5a0080c5b33f0699396b7f6653cf338bcc070b5217dee68c8f2df58aee42cad8ec9" }, { "hash" : "0x2a0f95b89972552201ce9b1841ca47f591addbb5435063a552ac7d33a32cf147", "indexes" : { "data" : 6, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0d73493cb4d6dacff395116173ff74d6fa921d523c2e644e597a5cf02222cbaefa07d7ad02b311048c6e2283606902f3f47bb6378c00604e76aae46ce483a8f9c9e" }, { "hash" : "0x32ea1a403c828269ac5939da14e616cd130616b57a23567a1d089a7435bb082a", "indexes" : { "data" : 7, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0185258bc1c3c16e0711917dd6e12f177530fd66120e82b98434fb733cfb6455ca01798f241fcffdc49ef0d4ddb63d29d00e437abb6415139b14d9bf186992fa75e" }, { "hash" : "0x4b4107773d810cc1d75868867eb27368e031acdba10f4881e3da405631dcc747", "indexes" : { "data" : 8, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c3b68b2f9a699f9de3cec2b5d7464e8890c5f6b7532a8fde991433602cb46f3ba0115c0f80763fbbf4010da968e10c17e67d1e569f4eb68dc568650716c903f654" }, { "hash" : "0x9f517a3faf9cde33b8932195326764c089c95f548a2a397fe5a720b40a9361dc", "indexes" : { "data" : 9, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ca028293b1e39a8be424d52122ccfd83fcf8d01651a6e709e0cc2e2e187946f93baa03ef02b1794a48796164a2430ee02cdf219c6a6104ec22d3cc2f28d3cce4db87c" } ], "Merge" : [ { "hash" : "0x1d2b5ff1fcd40af03d7a96e30c6e7defd3ac783a85a19bcafd0e4d4af02ed29d", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" }, { "hash" : "0xc15fb82b438f1b2d29d101f895cd8557438d3c5bc68f5c8a6f5d24452312227a", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca048c329c318ef294c01fa84b23d32b456522a6e03ace3e1715e96affb23836d60a072adc29e1372f2b4702909f78db64794d9655a6c6f2bac9a46e855583178cc8a" }, { "hash" : "0x858047eba3bacb4d5b6973ad1d780a96de9f8832b0022547fe608e874e66846a", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba06bd5d343d3464037c48816eaaccef380c05f0aba404fb61066e28e151630a399a043aa7a51bf793537d8075eaf3c5203219ed193b34450fc769f826f1614fdece5" }, { "hash" : "0x8906e4ec94b29e271579e575e231f47e39276c83a5aebacbdfccd47e47406cab", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca035de56c470a52f918a129466e839c256f86cb18839ee9b3c71346cceafd8a940a02b2c24538c4bb8d3e92a85fb91c730a19aa93949211d658f8928480ef238c20a" }, { "hash" : "0x2527b53daec42f7657b3ae5a6611bf68a7eabd95ae1d9ed5d7e2f435c33818f2", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a830f42408001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca02b91928cda056c79e297e94c5101dd0eb6ef8cf0eefeb310c006ce666e17b3cea00b4f9c9e4f32859ca026d38b92ededb4e7bb17f0b6a48ea8ec722665eb945e6e" }, { "hash" : "0x142de48fbcc4b27e1a767d9f1c007b2dc1155d1ebaf047aea72f2df7ac024963", "indexes" : { "data" : 0, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca0fad4ae4940524505a78bee34f699dced7a73811fcb24e0fcc28b47b0b927ea72a067752aa14d634516b6662a9f6c1897f5f0b35683689deff4df10ea925eb26fb4" }, { "hash" : "0x0f43bc94326f2b728a2b3d63edbbdd14132351901076e074dc47bec1aef99a17", "indexes" : { "data" : 1, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba04e95fca435ff01ae5eb30060568a69ff99b2b76e289f6fe9375cd68177b893d7a01d3ce37852be4074aa5c3fdaccda1c20c30822ebc517cb9174fba88a79a1cd78" }, { "hash" : "0x0f43bc94326f2b728a2b3d63edbbdd14132351901076e074dc47bec1aef99a17", "indexes" : { "data" : 2, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca02dd1ddbcbe6b2a0200b86479ec7fabf4db02be176a1f5891fde66522f465f6c8a063578e4c87563c235a2072f29d5db30b17dc9756172495eeec4854b9b6ed8141" }, { "hash" : "0x5c75466d014a5be287f34812765820b18f6cf50c410d042266f114c331261866", "indexes" : { "data" : 3, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca052dbb3017da185f08658817c46e2c7f8080d464f6f15ae2ef22d104747ad5444a0723f3afbe97b9cd317da9429d4a108b09624a211344c554de40324e95fcdc2df" }, { "hash" : "0xed885c9d666aaea5ed7d4fa8df5267e4cb0dd6d8927117a3c36f88310cc2044c", "indexes" : { "data" : 4, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a83061a808001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca05f7a0f7abc76f27c374692b6c09129a7ea4fc8fb72c0c588f534d5dedd149d54a01ab01faa66ddf3c187dadd51ef13be38fcff1afd5e2ba44be8d394919050e69c" }, { "hash" : "0x05038fb9c20e8dbc9fc602a9fb5ce40483eeba528b45e4c3f5cc5953ac89e589", "indexes" : { "data" : 5, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c0dea8139896e3ee724a8197c6af26f8d37815e104703a38f099fdc1fbcc1858a019f912dd5dc0002d242cb80f919c88dc246d46b18f4e232e1a823edcf3b91760" }, { "hash" : "0x05038fb9c20e8dbc9fc602a9fb5ce40483eeba528b45e4c3f5cc5953ac89e589", "indexes" : { "data" : 6, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca060df0b4c80fac15ff33e997835bd24347e422ca2e3151a4c58fa36ad4c97fd0da065434d6ebf15e6feba700b2a9182048028fa2bac2f2e1ffaba5aa9549b1e2cc1" }, { "hash" : "0x4c861c1415488f5be1c23c7cc0ff3feefe6fc520e481a6949db824d1240ce578", "indexes" : { "data" : 7, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba08b66929491f74f1d4a49769ec2ab46967233cac053d16b8244feadec525aed5ea061c919679208d0bc70cb044ade54c9a219817c6e34d02c60a7970181692ad174" }, { "hash" : "0x306ff7d66fad6bfd0d475c8d7a1b2f39d0c6e2ccb595ae82bcb10254f583ad35", "indexes" : { "data" : 8, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0ae03549e6699bf9d143f629a6be56c3ea626e395b938d2f84dbbc4c7c2654358a00e559728e9af818b2eee816e1194161f6bb07581a6a9baafad93d9dc51fe55d0" }, { "hash" : "0xa824a3f2804d725645409aa1ab3c0446fcd4bdf6035b700bb41f102ca56eafad", "indexes" : { "data" : 9, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ba0d877bdaa9762604458029e3708ae750ce90b30efe37c113a8bb021b6371ce291a04ddd0a26127131ccac2e07659129bbb0fdf84593db6da45ce0c8a5e72b7a0fff" }, { "hash" : "0x2a0f95b89972552201ce9b1841ca47f591addbb5435063a552ac7d33a32cf147", "indexes" : { "data" : 5, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0eac1392a9a7e844b64e8dc88c53650554c238cf8dc81dd43a445e6fe98e3c9a5a0080c5b33f0699396b7f6653cf338bcc070b5217dee68c8f2df58aee42cad8ec9" }, { "hash" : "0x2a0f95b89972552201ce9b1841ca47f591addbb5435063a552ac7d33a32cf147", "indexes" : { "data" : 6, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0d73493cb4d6dacff395116173ff74d6fa921d523c2e644e597a5cf02222cbaefa07d7ad02b311048c6e2283606902f3f47bb6378c00604e76aae46ce483a8f9c9e" }, { "hash" : "0x32ea1a403c828269ac5939da14e616cd130616b57a23567a1d089a7435bb082a", "indexes" : { "data" : 7, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0185258bc1c3c16e0711917dd6e12f177530fd66120e82b98434fb733cfb6455ca01798f241fcffdc49ef0d4ddb63d29d00e437abb6415139b14d9bf186992fa75e" }, { "hash" : "0x4b4107773d810cc1d75868867eb27368e031acdba10f4881e3da405631dcc747", "indexes" : { "data" : 8, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c3b68b2f9a699f9de3cec2b5d7464e8890c5f6b7532a8fde991433602cb46f3ba0115c0f80763fbbf4010da968e10c17e67d1e569f4eb68dc568650716c903f654" }, { "hash" : "0x9f517a3faf9cde33b8932195326764c089c95f548a2a397fe5a720b40a9361dc", "indexes" : { "data" : 9, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ca028293b1e39a8be424d52122ccfd83fcf8d01651a6e709e0cc2e2e187946f93baa03ef02b1794a48796164a2430ee02cdf219c6a6104ec22d3cc2f28d3cce4db87c" } ], "Shanghai" : [ { "hash" : "0xb76e9b33077dfaceef32f6ca1a549063740f49a77dc935fc26eccb7d50b9a951", "indexes" : { "data" : 0, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" }, { "hash" : "0xea4aa43b591e80a7a3530337d623a69e7010eae2c3d921e58648d809c691bc9f", "indexes" : { "data" : 1, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca048c329c318ef294c01fa84b23d32b456522a6e03ace3e1715e96affb23836d60a072adc29e1372f2b4702909f78db64794d9655a6c6f2bac9a46e855583178cc8a" }, { "hash" : "0x6b3a521c42cb46e8c2972217471f4e8fbe02b91896841684276317f5e2c10890", "indexes" : { "data" : 2, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba06bd5d343d3464037c48816eaaccef380c05f0aba404fb61066e28e151630a399a043aa7a51bf793537d8075eaf3c5203219ed193b34450fc769f826f1614fdece5" }, { "hash" : "0x8285f005afdda715b3df2b65251a54b130b356c18f75a29ec698cf36ed3afd34", "indexes" : { "data" : 3, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca035de56c470a52f918a129466e839c256f86cb18839ee9b3c71346cceafd8a940a02b2c24538c4bb8d3e92a85fb91c730a19aa93949211d658f8928480ef238c20a" }, { "hash" : "0xd639e160e08d8aef72e9bbf71dcb60f5ad0eade42c48473aff05dd39601acef1", "indexes" : { "data" : 4, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a830f42408001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca02b91928cda056c79e297e94c5101dd0eb6ef8cf0eefeb310c006ce666e17b3cea00b4f9c9e4f32859ca026d38b92ededb4e7bb17f0b6a48ea8ec722665eb945e6e" }, { "hash" : "0x3903a81ecc235aa4939acdadd263c4317ec8d18a3f20ebca3895cfe299a99a47", "indexes" : { "data" : 0, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca0fad4ae4940524505a78bee34f699dced7a73811fcb24e0fcc28b47b0b927ea72a067752aa14d634516b6662a9f6c1897f5f0b35683689deff4df10ea925eb26fb4" }, { "hash" : "0xaf85aeb553d6095fbfff819bbd220b921365811000f0e7c7b8b53436dc4be173", "indexes" : { "data" : 1, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf897800a83061a808001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba04e95fca435ff01ae5eb30060568a69ff99b2b76e289f6fe9375cd68177b893d7a01d3ce37852be4074aa5c3fdaccda1c20c30822ebc517cb9174fba88a79a1cd78" }, { "hash" : "0x0f43bc94326f2b728a2b3d63edbbdd14132351901076e074dc47bec1aef99a17", "indexes" : { "data" : 2, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca02dd1ddbcbe6b2a0200b86479ec7fabf4db02be176a1f5891fde66522f465f6c8a063578e4c87563c235a2072f29d5db30b17dc9756172495eeec4854b9b6ed8141" }, { "hash" : "0x5c75466d014a5be287f34812765820b18f6cf50c410d042266f114c331261866", "indexes" : { "data" : 3, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b848600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ca052dbb3017da185f08658817c46e2c7f8080d464f6f15ae2ef22d104747ad5444a0723f3afbe97b9cd317da9429d4a108b09624a211344c554de40324e95fcdc2df" }, { "hash" : "0xed885c9d666aaea5ed7d4fa8df5267e4cb0dd6d8927117a3c36f88310cc2044c", "indexes" : { "data" : 4, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf890800a83061a808001b8436000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe60006000556001600155001ca05f7a0f7abc76f27c374692b6c09129a7ea4fc8fb72c0c588f534d5dedd149d54a01ab01faa66ddf3c187dadd51ef13be38fcff1afd5e2ba44be8d394919050e69c" }, { "hash" : "0x05038fb9c20e8dbc9fc602a9fb5ce40483eeba528b45e4c3f5cc5953ac89e589", "indexes" : { "data" : 5, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c0dea8139896e3ee724a8197c6af26f8d37815e104703a38f099fdc1fbcc1858a019f912dd5dc0002d242cb80f919c88dc246d46b18f4e232e1a823edcf3b91760" }, { "hash" : "0x05038fb9c20e8dbc9fc602a9fb5ce40483eeba528b45e4c3f5cc5953ac89e589", "indexes" : { "data" : 6, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a83061a808001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca060df0b4c80fac15ff33e997835bd24347e422ca2e3151a4c58fa36ad4c97fd0da065434d6ebf15e6feba700b2a9182048028fa2bac2f2e1ffaba5aa9549b1e2cc1" }, { "hash" : "0x05038fb9c20e8dbc9fc602a9fb5ce40483eeba528b45e4c3f5cc5953ac89e589", "indexes" : { "data" : 7, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba08b66929491f74f1d4a49769ec2ab46967233cac053d16b8244feadec525aed5ea061c919679208d0bc70cb044ade54c9a219817c6e34d02c60a7970181692ad174" }, { "hash" : "0x306ff7d66fad6bfd0d475c8d7a1b2f39d0c6e2ccb595ae82bcb10254f583ad35", "indexes" : { "data" : 8, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a83061a808001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0ae03549e6699bf9d143f629a6be56c3ea626e395b938d2f84dbbc4c7c2654358a00e559728e9af818b2eee816e1194161f6bb07581a6a9baafad93d9dc51fe55d0" }, { "hash" : "0xa824a3f2804d725645409aa1ab3c0446fcd4bdf6035b700bb41f102ca56eafad", "indexes" : { "data" : 9, "gas" : 1, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a83061a808001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ba0d877bdaa9762604458029e3708ae750ce90b30efe37c113a8bb021b6371ce291a04ddd0a26127131ccac2e07659129bbb0fdf84593db6da45ce0c8a5e72b7a0fff" }, { "hash" : "0x1ca80e8d58e3775408ad4e88ef7c2d8df35a33c9aff4bdc967bcc545c292b0b3", "indexes" : { "data" : 5, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0eac1392a9a7e844b64e8dc88c53650554c238cf8dc81dd43a445e6fe98e3c9a5a0080c5b33f0699396b7f6653cf338bcc070b5217dee68c8f2df58aee42cad8ec9" }, { "hash" : "0x1ca80e8d58e3775408ad4e88ef7c2d8df35a33c9aff4bdc967bcc545c292b0b3", "indexes" : { "data" : 6, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89d800a830f42408001b8506000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0d73493cb4d6dacff395116173ff74d6fa921d523c2e644e597a5cf02222cbaefa07d7ad02b311048c6e2283606902f3f47bb6378c00604e76aae46ce483a8f9c9e" }, { "hash" : "0xdd22349be44674f96b508e1cf27fadeb64ab2db1b502890765c7c92d7766bc81", "indexes" : { "data" : 7, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ca0185258bc1c3c16e0711917dd6e12f177530fd66120e82b98434fb733cfb6455ca01798f241fcffdc49ef0d4ddb63d29d00e437abb6415139b14d9bf186992fa75e" }, { "hash" : "0xda81dbe3ce7ef0bf7d743c122d6b4398eab36a5b3cec3f32819aa104f9c104ae", "indexes" : { "data" : 8, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf89b800a830f42408001b84e600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd001ba0c3b68b2f9a699f9de3cec2b5d7464e8890c5f6b7532a8fde991433602cb46f3ba0115c0f80763fbbf4010da968e10c17e67d1e569f4eb68dc568650716c903f654" }, { "hash" : "0x0da7c4a3da5f55ca05fc2082ac611270859a231478718729d2f3807ff9f6f07b", "indexes" : { "data" : 9, "gas" : 0, "value" : 0 }, "logs" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes" : "0xf895800a830f42408001b8486000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe60006000556001600155001ca028293b1e39a8be424d52122ccfd83fcf8d01651a6e709e0cc2e2e187946f93baa03ef02b1794a48796164a2430ee02cdf219c6a6104ec22d3cc2f28d3cce4db87c" } ] }, "pre" : { "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" : { "balance" : "0xe8d4a51000", "code" : "0x", "nonce" : "0x00", "storage" : { } }, "0xb000000000000000000000000000000000000000" : { "balance" : "0x00", "code" : "0x600160015500", "nonce" : "0x00", "storage" : { } }, "0xc000000000000000000000000000000000000000" : { "balance" : "0x00", "code" : "0x600160015500", "nonce" : "0x00", "storage" : { } }, "0xdea0000000000000000000000000000000000000" : { "balance" : "0x00", "code" : "0x6001600155600060015560016002556000600255600160035560006003556001600455600060045560016005556000600555600160065560006006556001600755600060075560016008556000600855600160095560006009556001600a556000600a556001600b556000600b556001600c556000600c556001600d556000600d556001600e556000600e556001600f556000600f5560016010556000601055600160015500", "nonce" : "0x00", "storage" : { } } }, "transaction" : { "data" : [ "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x6000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe6000600055600160015500", "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x6000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe6000600055600160015500" ], "gasLimit" : [ "0x0f4240", "0x061a80" ], "gasPrice" : "0x0a", "nonce" : "0x00", "secretKey" : "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", "sender" : "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "to" : "", "value" : [ "0x01" ] } } } ================================================ FILE: silkworm/dev/cli/state_transition_sample4.json ================================================ { "sstore_0toX": { "_info": { "comment": "change 0 -> X", "filling-rpc-server": "evm version 1.11.4-unstable-e14043db-20230308", "filling-tool-version": "retesteth-0.3.0-shanghai+commit.fd2c0a83.Linux.g++", "generatedTestHash": "dfbfbf5fef87373626cb57635e652497ddeaaa263de4a86f0146d1ae5e7ba3fa", "lllcversion": "Version: 0.5.14-develop.2022.7.30+commit.a096d7a9.Linux.g++", "solidity": "Version: 0.8.17+commit.8df45f5f.Linux.g++", "source": "src/GeneralStateTestsFiller/stSStoreTest/sstore_0toXFiller.json", "sourceHash": "cb35aa543dd808a612e3dbe3cb135ee711f1e61ef5b7606c576dc03c4ca66ec7" }, "env": { "currentBaseFee": "0x0a", "currentCoinbase": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba", "currentDifficulty": "0x020000", "currentGasLimit": "0x989680", "currentNumber": "0x01", "currentRandom": "0x0000000000000000000000000000000000000000000000000000000000020000", "currentTimestamp": "0x03e8", "previousHash": "0x5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6" }, "post": { "Berlin": [ { "hash": "0x2ec26efa89ee50730f79c843bd4b308091624e6060af0cb8312535bc6ea1f85c", "indexes": { "data": 0, "gas": 0, "value": 0 }, "logs": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes": "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" } ], "Istanbul": [ { "hash": "0x039accbcd0cb85cc33b8b9362aa7e6a4afb9b3af607a16d601fec46bbc3e0be8", "indexes": { "data": 0, "gas": 0, "value": 0 }, "logs": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes": "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" } ], "London": [ { "hash": "0x1d2b5ff1fcd40af03d7a96e30c6e7defd3ac783a85a19bcafd0e4d4af02ed29d", "indexes": { "data": 0, "gas": 0, "value": 0 }, "logs": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes": "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" } ], "Merge": [ { "hash": "0x1d2b5ff1fcd40af03d7a96e30c6e7defd3ac783a85a19bcafd0e4d4af02ed29d", "indexes": { "data": 0, "gas": 0, "value": 0 }, "logs": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes": "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" } ], "Shanghai": [ { "hash": "0xb76e9b33077dfaceef32f6ca1a549063740f49a77dc935fc26eccb7d50b9a951", "indexes": { "data": 0, "gas": 0, "value": 0 }, "logs": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "txbytes": "0xf897800a830f42408001b84a6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f1001ba085025b2155ddf96b5bcd771cd5701e7fe2cc64b0be4d8681ce279b58b5f038f7a052f992d6e50e3f0484d1b2cdf34f2d3cb852e8102c2a8c959134fd481f2d4feb" } ] }, "pre": { "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b": { "balance": "0xe8d4a51000", "code": "0x", "nonce": "0x00", "storage": { } }, "0xb000000000000000000000000000000000000000": { "balance": "0x00", "code": "0x600160015500", "nonce": "0x00", "storage": { } }, "0xc000000000000000000000000000000000000000": { "balance": "0x00", "code": "0x600160015500", "nonce": "0x00", "storage": { } }, "0xdea0000000000000000000000000000000000000": { "balance": "0x00", "code": "0x6001600155600060015560016002556000600255600160035560006003556001600455600060045560016005556000600555600160065560006006556001600755600060075560016008556000600855600160095560006009556001600a556000600a556001600b556000600b556001600c556000600c556001600d556000600d556001600e556000600e556001600f556000600f5560016010556000601055600160015500", "nonce": "0x00", "storage": { } } }, "transaction": { "data": [ "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f100", "0x6000600b80603860003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f1500000fe6000600055600160015500", "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f1506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x6000600060006000600073b000000000000000000000000000000000000000620493e0f2506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x600060006000600073b000000000000000000000000000000000000000620493e0f4506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x600060006000600073c000000000000000000000000000000000000000620493e0fa506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd00", "0x6000600b80603d60003960006000f5506000600060006000600073dea0000000000000000000000000000000000000620927c0f15060206000fd0000fe6000600055600160015500" ], "gasLimit": [ "0x0f4240", "0x061a80" ], "gasPrice": "0x0a", "nonce": "0x00", "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", "sender": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "to": "", "value": [ "0x01" ] } } } ================================================ FILE: silkworm/dev/expected_state.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "expected_state.hpp" #include #include #include #include #include namespace silkworm::cmd::state_transition { ChainConfig ExpectedState::get_config() const { const auto config_it{test::kNetworkConfig.find(fork_name_)}; if (config_it == test::kNetworkConfig.end()) { std::cout << "unknown network " << fork_name_ << std::endl; throw std::invalid_argument(fork_name_); } const ChainConfig& config{config_it->second}; return config; } std::vector ExpectedState::get_sub_states() { std::vector sub_states; unsigned i = 0; for (auto& tx : state_data_) { ExpectedSubState sub_state; sub_state.stateHash = to_bytes32(from_hex(tx["hash"].get()).value_or(Bytes{})); sub_state.logsHash = to_bytes32(from_hex(tx["logs"].get()).value_or(Bytes{})); sub_state.dataIndex = tx["indexes"]["data"].get(); sub_state.gasIndex = tx["indexes"]["gas"].get(); sub_state.valueIndex = tx["indexes"]["value"].get(); if (tx.contains("expectException")) { sub_state.exceptionExpected = true; sub_state.exceptionMessage = tx["expectException"]; } else { sub_state.exceptionExpected = false; } sub_state.index = i; sub_states.push_back(sub_state); ++i; } return sub_states; } }; // namespace silkworm::cmd::state_transition ================================================ FILE: silkworm/dev/expected_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::cmd::state_transition { class ExpectedSubState { public: unsigned index{}; evmc::bytes32 stateHash; evmc::bytes32 logsHash; uint64_t dataIndex{}; uint64_t gasIndex{}; uint64_t valueIndex{}; bool exceptionExpected{false}; std::string exceptionMessage; }; class ExpectedState { nlohmann::json state_data_; std::string fork_name_; public: ExpectedState( nlohmann::json state_data, std::string fork_name) : state_data_{std::move(state_data)}, fork_name_{std::move(fork_name)} {} ChainConfig get_config() const; std::vector get_sub_states(); std::string fork_name() const { return fork_name_; }; }; }; // namespace silkworm::cmd::state_transition ================================================ FILE: silkworm/dev/state_transition.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_transition.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "expected_state.hpp" namespace silkworm::cmd::state_transition { StateTransition::StateTransition(const std::string& file_path) noexcept { std::ifstream input_file(file_path); nlohmann::json base_json; input_file >> base_json; auto test_object = base_json.begin(); test_name_ = test_object.key(); test_data_ = test_object.value(); } StateTransition::StateTransition(const nlohmann::json& json, const bool terminate_on_error, const bool show_diagnostics) noexcept : terminate_on_error_{terminate_on_error}, show_diagnostics_{show_diagnostics} { auto test_object = json.begin(); test_name_ = test_object.key(); std::cout << test_name_ << ":" << std::endl; test_data_ = test_object.value(); } std::string StateTransition::name() { return test_name_; } std::string StateTransition::get_env(const std::string& key) { return test_data_.at("env").at(key); } bool StateTransition::contains_env(const std::string& key) { return test_data_.at("env").contains(key); } std::vector StateTransition::get_expected_states() { std::vector expected_states; for (const auto& post_state : test_data_.at("post").items()) { nlohmann::json data = post_state.value(); const std::string& key = post_state.key(); expected_states.emplace_back(data, key); } return expected_states; } evmc::address StateTransition::to_evmc_address(const std::string& address) { evmc::address out; if (!address.empty()) { out = hex_to_address(address); } return out; } Block StateTransition::get_block(InMemoryState& state, ChainConfig& chain_config) { auto block = Block(); block.header.beneficiary = to_evmc_address(get_env("currentCoinbase")); block.header.gas_limit = std::stoull(get_env("currentGasLimit"), nullptr, /*base=*/16); block.header.number = std::stoull(get_env("currentNumber"), nullptr, /*base=*/16); block.header.timestamp = std::stoull(get_env("currentTimestamp"), nullptr, /*base=*/16); block.header.parent_hash = to_bytes32(from_hex(get_env("previousHash")).value_or(Bytes{})); if (contains_env("currentRandom")) { block.header.prev_randao = to_bytes32(from_hex(get_env("currentRandom")).value_or(Bytes{})); } const evmc_revision rev{chain_config.revision(block.header.number, block.header.timestamp)}; // set difficulty only for revisions before The Merge // current block difficulty cannot fall below minimum: https://eips.ethereum.org/EIPS/eip-2 static constexpr uint64_t kMinDifficulty{0x20000}; if (!chain_config.terminal_total_difficulty.has_value()) { block.header.difficulty = intx::from_string(get_env("currentDifficulty")); if (block.header.difficulty < kMinDifficulty && rev <= EVMC_LONDON) { block.header.difficulty = kMinDifficulty; } } if (contains_env("currentBaseFee") && rev >= EVMC_LONDON) { block.header.base_fee_per_gas = intx::from_string(get_env("currentBaseFee")); } if (rev >= EVMC_SHANGHAI) { block.withdrawals = std::vector{}; block.header.withdrawals_root = kEmptyRoot; } block.header.transactions_root = protocol::compute_transaction_root(block); block.header.ommers_hash = kEmptyListHash; auto parent_block = Block(); parent_block.header.gas_limit = block.header.gas_limit; parent_block.header.gas_used = parent_block.header.gas_limit / protocol::kElasticityMultiplier; parent_block.header.number = block.header.number - 1; parent_block.header.base_fee_per_gas = block.header.base_fee_per_gas; parent_block.header.ommers_hash = kEmptyListHash; parent_block.header.difficulty = intx::from_string(get_env("currentDifficulty")); state.insert_block(parent_block, block.header.parent_hash); return block; } std::unique_ptr StateTransition::private_key_to_address(const std::string& private_key) { /// Example // private key: 0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8 // public key : 043a514176466fa815ed481ffad09110a2d344f6c9b78c1d14afc351c3a51be33d8072e77939dc03ba44790779b7a1025baf3003f6732430e20cd9b76d953391b3 // address : 0xa94f5374Fce5edBC8E2a8697C15331677e6EbF0B auto private_key_bytes = from_hex(private_key).value(); auto pair = sentry::EccKeyPair(private_key_bytes); uint8_t out[kAddressLength]; auto public_key_hash = keccak256(pair.public_key().serialized()); std::memcpy(out, public_key_hash.bytes + 12, sizeof(out)); return std::make_unique(bytes_to_address(out)); } Transaction StateTransition::get_transaction(const ExpectedSubState& expected_sub_state) { Transaction txn; auto j_transaction = test_data_["transaction"]; txn.nonce = std::stoull(j_transaction.at("nonce").get(), nullptr, 16); txn.set_sender(*private_key_to_address(j_transaction["secretKey"])); const auto to_address = j_transaction.at("to").get(); if (!to_address.empty()) { txn.to = to_evmc_address(to_address); } // std::cout << "from address: " << to_hex(txn.from.value()) << std::endl; if (j_transaction.contains("gasPrice")) { txn.type = TransactionType::kLegacy; txn.max_fee_per_gas = intx::from_string(j_transaction.at("gasPrice").get()); txn.max_priority_fee_per_gas = intx::from_string(j_transaction.at("gasPrice").get()); } else { txn.type = TransactionType::kDynamicFee; txn.max_fee_per_gas = intx::from_string(j_transaction.at("maxFeePerGas").get()); txn.max_priority_fee_per_gas = intx::from_string(j_transaction.at("maxPriorityFeePerGas").get()); } if (expected_sub_state.dataIndex >= j_transaction.at("data").size()) { throw std::runtime_error("data index out of range"); } txn.data = from_hex(j_transaction.at("data").at(expected_sub_state.dataIndex).get()).value(); if (expected_sub_state.gasIndex >= j_transaction.at("gasLimit").size()) { throw std::runtime_error("gas limit index out of range"); } txn.gas_limit = std::stoull(j_transaction.at("gasLimit").at(expected_sub_state.gasIndex).get(), nullptr, 16); if (expected_sub_state.valueIndex >= j_transaction.at("value").size()) { throw std::runtime_error("value index out of range"); } auto value_str = j_transaction.at("value").at(expected_sub_state.valueIndex).get(); // in case of bigint, set max value; compatible with all test cases so far txn.value = (value_str.starts_with("0x:bigint ")) ? std::numeric_limits::max() : intx::from_string(value_str); if (j_transaction.contains("accessLists")) { auto j_access_list = j_transaction.at("accessLists").at(expected_sub_state.dataIndex); for (const auto& j_access_entry : j_access_list.items()) { AccessListEntry entry; entry.account = to_evmc_address(j_access_entry.value().at("address")); for (const auto& j_storage_key : j_access_entry.value().at("storageKeys").items()) { if (j_storage_key.value().is_string()) { auto hex_storage = from_hex(j_storage_key.value().get()); entry.storage_keys.emplace_back(to_bytes32(hex_storage.value())); } } txn.access_list.emplace_back(entry); } if (txn.type == TransactionType::kLegacy) { txn.type = TransactionType::kAccessList; } } return txn; } void StateTransition::validate_transition(const Receipt& receipt, const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const InMemoryState& state) { if (expected_sub_state.exceptionExpected) { if (receipt.success) { print_error_message(expected_state, expected_sub_state, "Failed: Exception expected"); ++failed_count_; } } if (state.state_root_hash() != expected_sub_state.stateHash) { print_error_message(expected_state, expected_sub_state, "Failed: State root hash does not match"); ++failed_count_; } else { Bytes encoded; rlp::encode(encoded, receipt.logs); if (std::bit_cast(keccak256(encoded)) != expected_sub_state.logsHash) { print_error_message(expected_state, expected_sub_state, "Failed: Logs hash does not match"); ++failed_count_; } else { print_diagnostic_message(expected_state, expected_sub_state, "OK"); } } } void StateTransition::print_error_message(const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const std::string& message) { if (terminate_on_error_) { throw std::runtime_error(message); } print_message(expected_state, expected_sub_state, message); } void StateTransition::print_diagnostic_message(const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const std::string& message) { if (show_diagnostics_) { print_message(expected_state, expected_sub_state, message); } } void StateTransition::print_message(const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const std::string& message) { std::cout << "[" << test_name_ << ":" << expected_state.fork_name() << ":" << expected_sub_state.index << "] " << message << std::endl; } /* * This function is used to clean up the state after a failed block execution. * Certain post-processing would be a part of the execute_transaction() function, * but since the validation failed, we need to do it manually. */ void cleanup_error_block(Block& block, ExecutionProcessor& processor, const evmc_revision rev) { if (rev >= EVMC_SHANGHAI) { processor.evm().state().access_account(block.header.beneficiary); } processor.evm().state().add_to_balance(block.header.beneficiary, 0); processor.evm().state().finalize_transaction(rev); processor.evm().state().write_to_db(block.header.number); } void StateTransition::run() { failed_count_ = 0; total_count_ = 0; for (auto& expected_state : get_expected_states()) { for (const auto& expected_sub_state : expected_state.get_sub_states()) { ++total_count_; auto config = expected_state.get_config(); auto rule_set = protocol::rule_set_factory(config); auto state = read_genesis_allocation(test_data_["pre"]); auto block = get_block(state, config); auto txn = get_transaction(expected_sub_state); ExecutionProcessor processor{block, *rule_set, state, config, true}; Receipt receipt; const evmc_revision rev{config.revision(block.header.number, block.header.timestamp)}; auto pre_block_validation = rule_set->pre_validate_block_body(block, state); auto block_validation = rule_set->validate_block_header(block.header, state, true); auto pre_txn_validation = protocol::pre_validate_transaction(txn, rev, config.chain_id, block.header.base_fee_per_gas, block.header.blob_gas_price()); auto txn_validation = protocol::validate_transaction(txn, processor.evm().state(), processor.available_gas()); // std::cout << "pre: " << std::endl; // state->print_state_root_hash(); if (pre_block_validation == ValidationResult::kOk && block_validation == ValidationResult::kOk && pre_txn_validation == ValidationResult::kOk && txn_validation == ValidationResult::kOk) { processor.execute_transaction(txn, receipt); processor.evm().state().write_to_db(block.header.number); } else { cleanup_error_block(block, processor, rev); receipt.success = false; } // std::cout << "post: " << std::endl; // state->print_state_root_hash(); validate_transition(receipt, expected_state, expected_sub_state, state); } } if (show_diagnostics_) { std::cout << "[" << test_name_ << "] " << "Finished total " << total_count_ << ", failed " << failed_count_ << std::endl << std::endl; } } } // namespace silkworm::cmd::state_transition ================================================ FILE: silkworm/dev/state_transition.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "expected_state.hpp" namespace silkworm::cmd::state_transition { class StateTransition { private: nlohmann::json test_data_; std::string test_name_; unsigned total_count_{}; unsigned failed_count_{}; bool terminate_on_error_{false}; bool show_diagnostics_{false}; void print_message(const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const std::string& message); void print_error_message(const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const std::string& message); void print_diagnostic_message(const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const std::string& message); public: explicit StateTransition(const std::string& file_path) noexcept; explicit StateTransition(const nlohmann::json& json, bool terminate_on_error, bool show_diagnostics) noexcept; std::string name(); std::string get_env(const std::string& key); bool contains_env(const std::string& key); std::vector get_expected_states(); static evmc::address to_evmc_address(const std::string& address); Block get_block(InMemoryState& state, ChainConfig& chain_config); std::unique_ptr get_state(); static std::unique_ptr private_key_to_address(const std::string& private_key); Transaction get_transaction(const ExpectedSubState& expected_sub_state); void validate_transition(const Receipt& receipt, const ExpectedState& expected_state, const ExpectedSubState& expected_sub_state, const InMemoryState& state); void run(); }; } // namespace silkworm::cmd::state_transition ================================================ FILE: silkworm/execution/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(gRPC REQUIRED) find_package(GTest REQUIRED) find_package(nlohmann_json REQUIRED) # cmake-format: off set(LIBS_PRIVATE gRPC::grpc++ silkworm_interfaces ) # cmake-format: on # cmake-format: off set(LIBS_PUBLIC asio-grpc::asio-grpc nlohmann_json::nlohmann_json silkworm_core silkworm_infra silkworm_db ) # cmake-format: on silkworm_library( silkworm_execution PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) target_link_libraries(silkworm_execution_test PRIVATE GTest::gmock silkworm_infra_test_util silkworm_db_test_util) ================================================ FILE: silkworm/execution/api/active_direct_service.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "active_direct_service.hpp" #include namespace silkworm::execution::api { ActiveDirectService::ActiveDirectService(ExecutionEngine& exec_engine, boost::asio::io_context& ioc) : DirectService{exec_engine}, ioc_{ioc}, executor_{ioc_.get_executor()} {} void ActiveDirectService::execution_loop() { exec_engine_.open(); boost::asio::executor_work_guard work{executor_}; ioc_.run(); exec_engine_.close(); } bool ActiveDirectService::stop() { ioc_.stop(); return ActiveComponent::stop(); } /** Chain Putters **/ // rpc InsertBlocks(InsertBlocksRequest) returns(InsertionResult); Task ActiveDirectService::insert_blocks(const Blocks& blocks) { return concurrency::spawn_task(executor_, [](auto* self, const auto& bb) { return self->DirectService::insert_blocks(bb); }(this, blocks)); } /** Chain Validation and ForkChoice **/ // rpc ValidateChain(ValidationRequest) returns(ValidationReceipt); Task ActiveDirectService::validate_chain(BlockId block_id) { return concurrency::spawn_task(executor_, [](auto* self, auto block_id1) { return self->DirectService::validate_chain(block_id1); }(this, block_id)); } // rpc UpdateForkChoice(ForkChoice) returns(ForkChoiceReceipt); Task ActiveDirectService::update_fork_choice(const ForkChoice& fork_choice) { return concurrency::spawn_task(executor_, [](auto* self, const auto& choice) { return self->DirectService::update_fork_choice(choice); }(this, fork_choice)); } /** Block Assembly **/ // rpc AssembleBlock(AssembleBlockRequest) returns(AssembleBlockResponse); Task ActiveDirectService::assemble_block(const api::BlockUnderConstruction& block) { return concurrency::spawn_task(executor_, [](auto* self, const auto& b) { return self->DirectService::assemble_block(b); }(this, block)); } // rpc GetAssembledBlock(GetAssembledBlockRequest) returns(GetAssembledBlockResponse); Task ActiveDirectService::get_assembled_block(PayloadId payload_id) { return concurrency::spawn_task(executor_, [](auto* self, auto id) { return self->DirectService::get_assembled_block(id); }(this, payload_id)); } /** Chain Getters **/ // rpc CurrentHeader(google.protobuf.Empty) returns(GetHeaderResponse); Task> ActiveDirectService::current_header() { return concurrency::spawn_task(executor_, [](auto* self) { return self->DirectService::current_header(); }(this)); } // rpc GetTD(GetSegmentRequest) returns(GetTDResponse); Task> ActiveDirectService::get_td(BlockNumOrHash block_num_or_hash) { return concurrency::spawn_task(executor_, [](auto* self, auto num_or_hash) { return self->DirectService::get_td(num_or_hash); }(this, block_num_or_hash)); } // rpc GetHeader(GetSegmentRequest) returns(GetHeaderResponse); Task> ActiveDirectService::get_header(BlockNumOrHash block_num_or_hash) { return concurrency::spawn_task(executor_, [](auto* self, auto num_or_hash) { return self->DirectService::get_header(num_or_hash); }(this, block_num_or_hash)); } // rpc GetBody(GetSegmentRequest) returns(GetBodyResponse); Task> ActiveDirectService::get_body(BlockNumOrHash block_num_or_hash) { return concurrency::spawn_task(executor_, [](auto* self, auto num_or_hash) { return self->DirectService::get_body(num_or_hash); }(this, block_num_or_hash)); } // rpc HasBlock(GetSegmentRequest) returns(HasBlockResponse); Task ActiveDirectService::has_block(BlockNumOrHash block_num_or_hash) { return concurrency::spawn_task(executor_, [](auto* self, auto num_or_hash) { return self->DirectService::has_block(num_or_hash); }(this, block_num_or_hash)); } /** Ranges **/ // rpc GetBodiesByRange(GetBodiesByRangeRequest) returns(GetBodiesBatchResponse); Task ActiveDirectService::get_bodies_by_range(BlockNumRange block_num_range) { return concurrency::spawn_task(executor_, [](auto* self, auto block_num_range1) { return self->DirectService::get_bodies_by_range(block_num_range1); }(this, block_num_range)); } // rpc GetBodiesByHashes(GetBodiesByHashesRequest) returns(GetBodiesBatchResponse); Task ActiveDirectService::get_bodies_by_hashes(const BlockHashes& hashes) { return concurrency::spawn_task(executor_, [](auto* self, const auto& hh) { return self->DirectService::get_bodies_by_hashes(hh); }(this, hashes)); } /** Chain Checkers **/ // rpc IsCanonicalHash(types.H256) returns(IsCanonicalResponse); Task ActiveDirectService::is_canonical_hash(Hash block_hash) { return concurrency::spawn_task(executor_, [](auto* self, auto h) { return self->DirectService::is_canonical_hash(h); }(this, block_hash)); } // rpc GetHeaderHashNumber(types.H256) returns(GetHeaderHashNumberResponse); Task> ActiveDirectService::get_header_hash_number(Hash block_hash) { return concurrency::spawn_task(executor_, [](auto* self, auto h) { return self->DirectService::get_header_hash_number(h); }(this, block_hash)); } // rpc GetForkChoice(google.protobuf.Empty) returns(ForkChoice); Task ActiveDirectService::get_fork_choice() { return concurrency::spawn_task(executor_, [](auto* self) { return self->DirectService::get_fork_choice(); }(this)); } /** Misc **/ // rpc Ready(google.protobuf.Empty) returns(ReadyResponse); Task ActiveDirectService::ready() { return concurrency::spawn_task(executor_, [](auto* self) { return self->DirectService::ready(); }(this)); } // rpc FrozenBlocks(google.protobuf.Empty) returns(FrozenBlocksResponse); Task ActiveDirectService::frozen_blocks() { return concurrency::spawn_task(executor_, [](auto* self) { return self->DirectService::frozen_blocks(); }(this)); } /** Additional non-RPC methods **/ Task ActiveDirectService::get_last_headers(uint64_t n) { return concurrency::spawn_task(executor_, [](auto* self, auto how_many) { return self->DirectService::get_last_headers(how_many); }(this, n)); } Task ActiveDirectService::block_progress() { return concurrency::spawn_task(executor_, [](auto* self) { return self->DirectService::block_progress(); }(this)); } } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/active_direct_service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "direct_service.hpp" #include "execution_engine.hpp" namespace silkworm::execution::api { //! Active DirectService implementation running on one Task executor. class ActiveDirectService : public DirectService, public ActiveComponent { public: ActiveDirectService(ExecutionEngine& exec_engine, boost::asio::io_context& ioc); ~ActiveDirectService() override = default; ActiveDirectService(const ActiveDirectService&) = delete; ActiveDirectService& operator=(const ActiveDirectService&) = delete; ActiveDirectService(ActiveDirectService&&) = delete; ActiveDirectService& operator=(ActiveDirectService&&) = delete; /** Chain Putters **/ // rpc InsertBlocks(InsertBlocksRequest) returns(InsertionResult); Task insert_blocks(const Blocks& blocks) override; /** Chain Validation and ForkChoice **/ // rpc ValidateChain(ValidationRequest) returns(ValidationReceipt); Task validate_chain(BlockId block_id) override; // rpc UpdateForkChoice(ForkChoice) returns(ForkChoiceReceipt); Task update_fork_choice(const ForkChoice& fork_choice) override; /** Block Assembly **/ // rpc AssembleBlock(AssembleBlockRequest) returns(AssembleBlockResponse); Task assemble_block(const BlockUnderConstruction&) override; // rpc GetAssembledBlock(GetAssembledBlockRequest) returns(GetAssembledBlockResponse); Task get_assembled_block(PayloadId id) override; /** Chain Getters **/ // rpc CurrentHeader(google.protobuf.Empty) returns(GetHeaderResponse); Task> current_header() override; // rpc GetTD(GetSegmentRequest) returns(GetTDResponse); Task> get_td(BlockNumOrHash block_num_or_hash) override; // rpc GetHeader(GetSegmentRequest) returns(GetHeaderResponse); Task> get_header(BlockNumOrHash block_num_or_hash) override; // rpc GetBody(GetSegmentRequest) returns(GetBodyResponse); Task> get_body(BlockNumOrHash block_num_or_hash) override; // rpc HasBlock(GetSegmentRequest) returns(HasBlockResponse); Task has_block(BlockNumOrHash block_num_or_hash) override; /** Ranges **/ // rpc GetBodiesByRange(GetBodiesByRangeRequest) returns(GetBodiesBatchResponse); Task get_bodies_by_range(BlockNumRange range) override; // rpc GetBodiesByHashes(GetBodiesByHashesRequest) returns(GetBodiesBatchResponse); Task get_bodies_by_hashes(const BlockHashes& hashes) override; /** Chain Checkers **/ // rpc IsCanonicalHash(types.H256) returns(IsCanonicalResponse); Task is_canonical_hash(Hash block_hash) override; // rpc GetHeaderHashNumber(types.H256) returns(GetHeaderHashNumberResponse); Task> get_header_hash_number(Hash block_hash) override; // rpc GetForkChoice(google.protobuf.Empty) returns(ForkChoice); Task get_fork_choice() override; /** Misc **/ // rpc Ready(google.protobuf.Empty) returns(ReadyResponse); Task ready() override; // rpc FrozenBlocks(google.protobuf.Empty) returns(FrozenBlocksResponse); Task frozen_blocks() override; /** Additional non-RPC methods **/ Task get_last_headers(uint64_t n) override; Task block_progress() override; protected: void execution_loop() override; bool stop() override; private: boost::asio::io_context& ioc_; boost::asio::io_context::executor_type executor_; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "service.hpp" namespace silkworm::execution::api { struct Client { virtual ~Client() = default; virtual std::shared_ptr service() = 0; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/direct_client.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "direct_client.hpp" namespace silkworm::execution::api { DirectClient::DirectClient(std::shared_ptr direct_service) : direct_service_(std::move(direct_service)) {} std::shared_ptr DirectClient::service() { return direct_service_; } } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/direct_client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../api/client.hpp" #include "../api/direct_service.hpp" namespace silkworm::execution::api { struct DirectClient : public api::Client { explicit DirectClient(std::shared_ptr direct_service); ~DirectClient() override = default; std::shared_ptr service() override; private: std::shared_ptr direct_service_; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/direct_service.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "direct_service.hpp" namespace silkworm::execution::api { DirectService::DirectService(ExecutionEngine& exec_engine) : exec_engine_{exec_engine} {} /** Chain Putters **/ // rpc InsertBlocks(InsertBlocksRequest) returns(InsertionResult); Task DirectService::insert_blocks(const Blocks& blocks) { const bool ready_for_insertion{co_await ready()}; if (!ready_for_insertion) { co_return InsertionResult{.status = api::ExecutionStatus::kBusy}; } // TODO(canepat) handle more errors out of insert_blocks (e.g. bad block...) exec_engine_.insert_blocks(blocks); co_return InsertionResult{.status = api::ExecutionStatus::kSuccess}; } /** Chain Validation and ForkChoice **/ // rpc ValidateChain(ValidationRequest) returns(ValidationReceipt); Task DirectService::validate_chain(BlockId block_id) { const auto verification = co_await exec_engine_.verify_chain(block_id.hash); co_return verification; } // rpc UpdateForkChoice(ForkChoice) returns(ForkChoiceReceipt); Task DirectService::update_fork_choice(const ForkChoice& fork_choice) { const auto& head_block_hash{fork_choice.head_block_hash}; const auto& finalized_block_hash{fork_choice.finalized_block_hash}; const auto& safe_block_hash{fork_choice.safe_block_hash}; const bool updated = exec_engine_.notify_fork_choice_update(head_block_hash, finalized_block_hash, safe_block_hash); // BLOCKING, will block the entire io_context thread const auto last_fork_choice = exec_engine_.last_fork_choice(); ForkChoiceResult result{ .status = updated ? api::ExecutionStatus::kSuccess : api::ExecutionStatus::kInvalidForkchoice, .latest_valid_head = last_fork_choice.hash, // TODO(canepat) add support for validation error }; co_return result; } /** Block Assembly **/ // rpc AssembleBlock(AssembleBlockRequest) returns(AssembleBlockResponse); Task DirectService::assemble_block(const api::BlockUnderConstruction&) { // TODO(canepat) not yet supported co_return AssembleBlockResult{}; } // rpc GetAssembledBlock(GetAssembledBlockRequest) returns(GetAssembledBlockResponse); Task DirectService::get_assembled_block(PayloadId) { // TODO(canepat) not yet supported co_return AssembledBlockResult{}; } /** Chain Getters **/ // rpc CurrentHeader(google.protobuf.Empty) returns(GetHeaderResponse); Task> DirectService::current_header() { const auto block_id = exec_engine_.last_finalized_block(); co_return exec_engine_.get_header(block_id.hash); } // rpc GetTD(GetSegmentRequest) returns(GetTDResponse); Task> DirectService::get_td(BlockNumOrHash block_num_or_hash) { if (std::holds_alternative(block_num_or_hash)) { co_return exec_engine_.get_header_td(std::get(block_num_or_hash), std::nullopt); } else { SILKWORM_ASSERT(std::holds_alternative(block_num_or_hash)); const auto block_num{std::get(block_num_or_hash)}; const auto canonical_hash{exec_engine_.get_canonical_hash(block_num)}; if (!canonical_hash) { co_return std::nullopt; } co_return exec_engine_.get_header_td(*canonical_hash, block_num); } } // rpc GetHeader(GetSegmentRequest) returns(GetHeaderResponse); Task> DirectService::get_header(BlockNumOrHash block_num_or_hash) { if (std::holds_alternative(block_num_or_hash)) { co_return exec_engine_.get_header(std::get(block_num_or_hash)); } else { SILKWORM_ASSERT(std::holds_alternative(block_num_or_hash)); const auto block_num{std::get(block_num_or_hash)}; co_return exec_engine_.get_canonical_header(block_num); } } // rpc GetBody(GetSegmentRequest) returns(GetBodyResponse); Task> DirectService::get_body(BlockNumOrHash block_num_or_hash) { if (std::holds_alternative(block_num_or_hash)) { co_return exec_engine_.get_body(std::get(block_num_or_hash)); } else { SILKWORM_ASSERT(std::holds_alternative(block_num_or_hash)); const auto block_num{std::get(block_num_or_hash)}; co_return exec_engine_.get_canonical_body(block_num); } } // rpc HasBlock(GetSegmentRequest) returns(HasBlockResponse); Task DirectService::has_block(BlockNumOrHash block_num_or_hash) { if (std::holds_alternative(block_num_or_hash)) { co_return exec_engine_.get_header(std::get(block_num_or_hash)); } else { SILKWORM_ASSERT(std::holds_alternative(block_num_or_hash)); const auto block_num{std::get(block_num_or_hash)}; const auto canonical_hash{exec_engine_.get_canonical_hash(block_num)}; if (!canonical_hash) { co_return false; } co_return exec_engine_.get_header(*canonical_hash); } } /** Ranges **/ // rpc GetBodiesByRange(GetBodiesByRangeRequest) returns(GetBodiesBatchResponse); Task DirectService::get_bodies_by_range(BlockNumRange block_num_range) { BlockBodies bodies; const auto [start_block_num, end_block_num] = block_num_range; if (start_block_num > end_block_num) { co_return bodies; } bodies.reserve(end_block_num - start_block_num + 1); for (BlockNum block_num = start_block_num; block_num <= end_block_num; ++block_num) { auto block_body{exec_engine_.get_canonical_body(block_num)}; auto block_hash{exec_engine_.get_canonical_hash(block_num)}; if (block_body && block_hash) { bodies.push_back(Body{std::move(*block_body), *block_hash, block_num}); } else { // Add an empty body anyway because we must respond w/ one payload for each number bodies.emplace_back(); } } co_return bodies; } // rpc GetBodiesByHashes(GetBodiesByHashesRequest) returns(GetBodiesBatchResponse); Task DirectService::get_bodies_by_hashes(const BlockHashes& hashes) { BlockBodies bodies; bodies.reserve(hashes.size()); for (const auto& block_hash : hashes) { auto block_body{exec_engine_.get_body(block_hash)}; auto block_num{exec_engine_.get_block_num(block_hash)}; if (block_body && block_num) { bodies.push_back(Body{std::move(*block_body), block_hash, *block_num}); } else { // Add an empty body anyway because we must respond w/ one payload for each hash bodies.emplace_back(); } } co_return bodies; } /** Chain Checkers **/ // rpc IsCanonicalHash(types.H256) returns(IsCanonicalResponse); Task DirectService::is_canonical_hash(Hash block_hash) { co_return exec_engine_.is_canonical(block_hash); } // rpc GetHeaderHashNumber(types.H256) returns(GetHeaderHashNumberResponse); Task> DirectService::get_header_hash_number(Hash block_hash) { co_return exec_engine_.get_block_num(block_hash); } // rpc GetForkChoice(google.protobuf.Empty) returns(ForkChoice); Task DirectService::get_fork_choice() { const auto last_fork_choice_block_id = exec_engine_.last_fork_choice(); const auto last_finalized_block_id = exec_engine_.last_finalized_block(); const auto last_safe_block_id = exec_engine_.last_safe_block(); ForkChoice last_fork_choice{ .head_block_hash = last_fork_choice_block_id.hash, .finalized_block_hash = last_finalized_block_id.hash, .safe_block_hash = last_safe_block_id.hash, }; co_return last_fork_choice; } /** Misc **/ // rpc Ready(google.protobuf.Empty) returns(ReadyResponse); Task DirectService::ready() { // TODO(canepat) use semaphore to sync access to the database wrt block execution co_return true; } // rpc FrozenBlocks(google.protobuf.Empty) returns(FrozenBlocksResponse); Task DirectService::frozen_blocks() { co_return exec_engine_.max_frozen_block_num(); } /** Additional non-RPC methods **/ Task DirectService::get_last_headers(uint64_t n) { co_return exec_engine_.get_last_headers(n); } Task DirectService::block_progress() { co_return exec_engine_.block_progress(); } } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/direct_service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "execution_engine.hpp" #include "service.hpp" namespace silkworm::execution::api { //! Straightforward asynchronous implementation of Execution API service relying on \code ExecutionEngine. //! This is used both client-side by 'direct' (i.e. no-gRPC) implementation and server-side by gRPC server. class DirectService : public Service { public: explicit DirectService(ExecutionEngine& exec_engine); ~DirectService() override = default; DirectService(const DirectService&) = delete; DirectService& operator=(const DirectService&) = delete; DirectService(DirectService&&) = delete; DirectService& operator=(DirectService&&) = delete; /** Chain Putters **/ // rpc InsertBlocks(InsertBlocksRequest) returns(InsertionResult); Task insert_blocks(const Blocks& blocks) override; /** Chain Validation and ForkChoice **/ // rpc ValidateChain(ValidationRequest) returns(ValidationReceipt); Task validate_chain(BlockId block_id) override; // rpc UpdateForkChoice(ForkChoice) returns(ForkChoiceReceipt); Task update_fork_choice(const ForkChoice& fork_choice) override; /** Block Assembly **/ // rpc AssembleBlock(AssembleBlockRequest) returns(AssembleBlockResponse); Task assemble_block(const BlockUnderConstruction&) override; // rpc GetAssembledBlock(GetAssembledBlockRequest) returns(GetAssembledBlockResponse); Task get_assembled_block(PayloadId id) override; /** Chain Getters **/ // rpc CurrentHeader(google.protobuf.Empty) returns(GetHeaderResponse); Task> current_header() override; // rpc GetTD(GetSegmentRequest) returns(GetTDResponse); Task> get_td(BlockNumOrHash block_num_or_hash) override; // rpc GetHeader(GetSegmentRequest) returns(GetHeaderResponse); Task> get_header(BlockNumOrHash block_num_or_hash) override; // rpc GetBody(GetSegmentRequest) returns(GetBodyResponse); Task> get_body(BlockNumOrHash block_num_or_hash) override; // rpc HasBlock(GetSegmentRequest) returns(HasBlockResponse); Task has_block(BlockNumOrHash block_num_or_hash) override; /** Ranges **/ // rpc GetBodiesByRange(GetBodiesByRangeRequest) returns(GetBodiesBatchResponse); Task get_bodies_by_range(BlockNumRange range) override; // rpc GetBodiesByHashes(GetBodiesByHashesRequest) returns(GetBodiesBatchResponse); Task get_bodies_by_hashes(const BlockHashes& hashes) override; /** Chain Checkers **/ // rpc IsCanonicalHash(types.H256) returns(IsCanonicalResponse); Task is_canonical_hash(Hash block_hash) override; // rpc GetHeaderHashNumber(types.H256) returns(GetHeaderHashNumberResponse); Task> get_header_hash_number(Hash block_hash) override; // rpc GetForkChoice(google.protobuf.Empty) returns(ForkChoice); Task get_fork_choice() override; /** Misc **/ // rpc Ready(google.protobuf.Empty) returns(ReadyResponse); Task ready() override; // rpc FrozenBlocks(google.protobuf.Empty) returns(FrozenBlocksResponse); Task frozen_blocks() override; /** Additional non-RPC methods **/ Task get_last_headers(uint64_t n) override; Task block_progress() override; protected: ExecutionEngine& exec_engine_; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/assembly.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::execution::api { using PayloadId = uint64_t; struct BlockUnderConstruction { Hash parent_hash; uint64_t timestamp{0}; evmc::bytes32 prev_randao; evmc::address suggested_fee_recipient; std::optional> withdrawals; std::optional parent_beacon_block_root; }; struct AssembleBlockResult { bool success{false}; PayloadId payload_id{0}; }; using ListOfBytes = std::vector; struct ExecutionPayload { uint32_t version{0}; Hash parent_hash; evmc::address suggested_fee_recipient; Hash state_root; Hash receipts_root; Bloom logs_bloom{}; evmc::bytes32 prev_randao; BlockNum block_num{0}; uint64_t gas_limit{0}; uint64_t gas_used{0}; uint64_t timestamp{0}; Bytes extra_data; intx::uint256 base_fee_per_gas; Hash block_hash; std::vector transactions; std::optional> withdrawals; std::optional blob_gas_used; std::optional excess_blob_gas; }; struct BlobsBundleV1 { ListOfBytes commitments; ListOfBytes blobs; ListOfBytes proofs; }; struct AssembledBlock { ExecutionPayload execution_payload; Hash block_hash; BlobsBundleV1 blobs_bundle; }; struct AssembledBlockResult { bool success{false}; std::optional data; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/block.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::execution::api { struct Body : public BlockBody { Hash block_hash; BlockNum block_num{0}; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/checkers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "status.hpp" namespace silkworm::execution::api { struct ForkChoice { Hash head_block_hash; uint64_t timeout{0}; std::optional finalized_block_hash; std::optional safe_block_hash; }; struct ForkChoiceResult { ExecutionStatus status{ExecutionStatus::kSuccess}; Hash latest_valid_head; std::string validation_error; explicit operator bool() const { return success(status); } }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/getters.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::execution::api { using BlockNumOrHash = std::variant; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/insertion.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "status.hpp" namespace silkworm::execution::api { using Blocks = std::vector>; struct InsertionResult { ExecutionStatus status; explicit operator bool() const { return success(status); } }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "block.hpp" namespace silkworm::execution::api { using BlockHashes = std::vector; using BlockBodies = std::vector; using BlockHeaders = std::vector; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/status.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::execution::api { enum ExecutionStatus : uint8_t { kSuccess, kBadBlock, kTooFarAway, kMissingSegment, kInvalidForkchoice, kBusy, }; inline bool success(ExecutionStatus status) { return status == ExecutionStatus::kSuccess; } } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/endpoint/validation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::execution::api { struct ValidChain { BlockId current_head; }; struct InvalidChain { BlockId unwind_point; std::optional bad_block; std::set bad_headers; }; struct ValidationError { BlockId latest_valid_head; std::string error; }; using ValidationResult = std::variant; using VerificationResult = ValidationResult; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/execution_engine.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "endpoint/validation.hpp" namespace silkworm::execution::api { struct ExecutionEngine { virtual ~ExecutionEngine() = default; virtual void open() = 0; virtual void close() = 0; // actions virtual void insert_blocks(const std::vector>& blocks) = 0; virtual Task verify_chain(Hash head_block_hash) = 0; virtual bool notify_fork_choice_update( Hash head_block_hash, std::optional finalized_block_hash, std::optional safe_block_hash) = 0; // state virtual BlockNum block_progress() const = 0; virtual BlockId last_fork_choice() const = 0; virtual BlockId last_finalized_block() const = 0; virtual BlockId last_safe_block() const = 0; virtual BlockNum max_frozen_block_num() const = 0; // header/body retrieval virtual std::optional get_header(Hash) const = 0; virtual std::optional get_canonical_header(BlockNum) const = 0; virtual std::optional get_canonical_hash(BlockNum) const = 0; virtual std::optional get_body(Hash) const = 0; virtual std::optional get_canonical_body(BlockNum) const = 0; virtual bool is_canonical(Hash) const = 0; virtual std::optional get_block_num(Hash) const = 0; virtual std::vector get_last_headers(uint64_t limit) const = 0; virtual std::optional get_header_td(Hash, std::optional) const = 0; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/api/service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "endpoint/assembly.hpp" #include "endpoint/checkers.hpp" #include "endpoint/getters.hpp" #include "endpoint/insertion.hpp" #include "endpoint/range.hpp" #include "endpoint/validation.hpp" namespace silkworm::execution::api { //! Common Execution API definition for both in-process and out-of-process client/server struct Service { virtual ~Service() = default; /** Chain Putters **/ // rpc InsertBlocks(InsertBlocksRequest) returns(InsertionResult); virtual Task insert_blocks(const Blocks&) = 0; /** Chain Validation and ForkChoice **/ // rpc ValidateChain(ValidationRequest) returns(ValidationReceipt); virtual Task validate_chain(BlockId) = 0; // rpc UpdateForkChoice(ForkChoice) returns(ForkChoiceReceipt); virtual Task update_fork_choice(const ForkChoice&) = 0; /** Block Assembly **/ // rpc AssembleBlock(AssembleBlockRequest) returns(AssembleBlockResponse); virtual Task assemble_block(const api::BlockUnderConstruction&) = 0; // rpc GetAssembledBlock(GetAssembledBlockRequest) returns(GetAssembledBlockResponse); virtual Task get_assembled_block(PayloadId) = 0; /** Chain Getters **/ // rpc CurrentHeader(google.protobuf.Empty) returns(GetHeaderResponse); virtual Task> current_header() = 0; // rpc GetTD(GetSegmentRequest) returns(GetTDResponse); virtual Task> get_td(BlockNumOrHash) = 0; // rpc GetHeader(GetSegmentRequest) returns(GetHeaderResponse); virtual Task> get_header(BlockNumOrHash) = 0; // rpc GetBody(GetSegmentRequest) returns(GetBodyResponse); virtual Task> get_body(BlockNumOrHash) = 0; // rpc HasBlock(GetSegmentRequest) returns(HasBlockResponse); virtual Task has_block(BlockNumOrHash) = 0; /** Ranges **/ // rpc GetBodiesByRange(GetBodiesByRangeRequest) returns(GetBodiesBatchResponse); virtual Task get_bodies_by_range(BlockNumRange) = 0; // rpc GetBodiesByHashes(GetBodiesByHashesRequest) returns(GetBodiesBatchResponse); virtual Task get_bodies_by_hashes(const BlockHashes&) = 0; /** Chain Checkers **/ // rpc IsCanonicalHash(types.H256) returns(IsCanonicalResponse); virtual Task is_canonical_hash(Hash block_hash) = 0; // rpc GetHeaderHashNumber(types.H256) returns(GetHeaderHashNumberResponse); virtual Task> get_header_hash_number(Hash block_hash) = 0; // rpc GetForkChoice(google.protobuf.Empty) returns(ForkChoice); virtual Task get_fork_choice() = 0; /** Misc **/ // rpc Ready(google.protobuf.Empty) returns(ReadyResponse); virtual Task ready() = 0; // rpc FrozenBlocks(google.protobuf.Empty) returns(FrozenBlocksResponse); virtual Task frozen_blocks() = 0; /** Additional non-RPC methods **/ virtual Task get_last_headers(uint64_t n) = 0; virtual Task block_progress() = 0; }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/execution/block_executor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block_executor.hpp" #include #include #include namespace silkworm::execution::block { using namespace std::chrono_literals; BlockExecutor::BlockExecutor(const ChainConfig* chain_config, bool write_receipts, bool write_call_traces, bool write_change_sets) : chain_config_{chain_config}, protocol_rule_set_{protocol::rule_set_factory(*chain_config_)}, write_receipts_{write_receipts}, write_call_traces_{write_call_traces}, write_change_sets_{write_change_sets} {} ValidationResult BlockExecutor::execute_single(const Block& block, db::Buffer& state_buffer, AnalysisCache& analysis_cache) { ExecutionProcessor processor{block, *protocol_rule_set_, state_buffer, *chain_config_, true}; processor.evm().analysis_cache = &analysis_cache; CallTraces traces; CallTracer tracer{traces}; if (write_call_traces_) { processor.evm().add_tracer(tracer); } std::vector receipts; if (const ValidationResult res = processor.execute_block(receipts); res != ValidationResult::kOk) { return res; } processor.flush_state(); if (write_receipts_) { state_buffer.insert_receipts(block.header.number, receipts); } if (write_call_traces_) { state_buffer.insert_call_traces(block.header.number, traces); } state_buffer.write_history_to_db(write_change_sets_); return ValidationResult::kOk; } } // namespace silkworm::execution::block ================================================ FILE: silkworm/execution/block_executor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::execution::block { class BlockExecutor { public: static constexpr size_t kDefaultAnalysisCacheSize{5'000}; BlockExecutor(const ChainConfig* chain_config, bool write_receipts, bool write_call_traces, bool write_change_sets); ValidationResult execute_single(const Block& block, db::Buffer& state_buffer, AnalysisCache& analysis_cache); private: const ChainConfig* chain_config_; protocol::RuleSetPtr protocol_rule_set_; bool write_receipts_; bool write_call_traces_; bool write_change_sets_; }; } // namespace silkworm::execution::block ================================================ FILE: silkworm/execution/domain_state.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "domain_state.hpp" #include #include #include #include #include #include #include "silkworm/db/state/log_address_inverted_index.hpp" #include "silkworm/db/state/log_topics_inverted_index.hpp" #include "silkworm/db/state/receipts_domain.hpp" namespace silkworm::execution { using namespace db::state; using namespace datastore; // TODO: // - implement: state_root_hash, canonize_block, decanonize_block (optional) // - implement insert_call_traces (mandatory) // - add begin_txn method (replacing begin_block?) // - insert_receipts should write to domain receipts table db::state::kDomainNameReceipts // - add buffer saving previous steps for values in accounts, code and storage domains - for updates // - extend transaction to include txn_id, or // - add base_txn_id to block and get_txn_by_id method std::optional DomainState::read_account(const evmc::address& address) const noexcept { AccountsDomainGetLatestQuery query{database_, tx_, latest_state_repository_, query_caches_}; auto result = query.exec(address); if (result) { return std::move(result->value); } return std::nullopt; } ByteView DomainState::read_code(const evmc::address& address, const evmc::bytes32& /*code_hash*/) const noexcept { if (code_.contains(address)) { return code_[address]; // NOLINT(runtime/arrays) } CodeDomainGetLatestQuery query{database_, tx_, latest_state_repository_, query_caches_}; auto result = query.exec(address); if (result) { auto [it, _] = code_.emplace(address, std::move(result->value)); return it->second; } return ByteView{}; } evmc::bytes32 DomainState::read_storage( const evmc::address& address, uint64_t /*incarnation*/, const evmc::bytes32& location) const noexcept { StorageDomainGetLatestQuery query{database_, tx_, latest_state_repository_, query_caches_}; auto result = query.exec({address, location}); if (result) { return std::move(result->value); } return {}; } uint64_t DomainState::previous_incarnation(const evmc::address& address) const noexcept { auto prev_incarnation = db::read_previous_incarnation(tx_, address); return prev_incarnation.value_or(0); } std::optional DomainState::read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { return data_model_.read_header(block_num, block_hash); } bool DomainState::read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept { return data_model_.read_body(block_hash, block_num, out); } std::optional DomainState::total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { return data_model_.read_total_difficulty(block_num, block_hash); } evmc::bytes32 DomainState::state_root_hash() const { // TODO: implement return evmc::bytes32{}; } BlockNum DomainState::current_canonical_block() const { auto head = db::read_canonical_head(tx_); return std::get<0>(head); } std::optional DomainState::canonical_hash(BlockNum block_num) const { return data_model_.read_canonical_header_hash(block_num); } void DomainState::insert_receipt(const Receipt& receipt, uint64_t current_log_index, uint64_t cumulative_blob_gas_used) { ReceiptsDomainPutQuery query{database_, tx_}; // Encode cumulative gas used in block - receipt should already contain txn gas used + block gas used so far { const Bytes gas_used_key{static_cast(ReceiptsDomainKey::kCumulativeGasUsedInBlockKey)}; Bytes encoded_value; VarintSnapshotEncoder encoder{encoded_value, receipt.cumulative_gas_used}; const auto encoded_view = encoder.encode_word(); query.exec(gas_used_key, encoded_view, txn_id_, std::nullopt, current_step()); } // Encode cumulative blob gas used - requires interface extension to include list of executed transactions { const Bytes gas_used_key{static_cast(ReceiptsDomainKey::kCumulativeBlobGasUsedInBlockKey)}; Bytes encoded_value; VarintSnapshotEncoder encoder{encoded_value, cumulative_blob_gas_used}; const auto encoded_view = encoder.encode_word(); query.exec(gas_used_key, encoded_view, txn_id_, std::nullopt, current_step()); } // Log index - this should correspond to actual log index in a block (0 for now) { const Bytes gas_used_key{static_cast(ReceiptsDomainKey::kFirstLogIndexKey)}; Bytes encoded_value; VarintSnapshotEncoder encoder{encoded_value, current_log_index}; const auto encoded_view = encoder.encode_word(); query.exec(gas_used_key, encoded_view, txn_id_, std::nullopt, current_step()); } // Insert log indexes which are part of the receipt insert_log_indexes(receipt); } void DomainState::insert_log_indexes(const Receipt& receipt) const { LogAddressesToInvertedIndexPutQuery log_address_put_query{tx_, database_.inverted_index(kInvIdxNameLogAddress)}; LogTopicsToInvertedIndexPutQuery log_topic_put_query{tx_, database_.inverted_index(kInvIdxNameLogTopics)}; for (const auto& log : receipt.logs) { log_address_put_query.exec(log.address, txn_id_, true); for (const auto& topic : log.topics) { log_topic_put_query.exec(topic, txn_id_, true); } } } datastore::Step DomainState::current_step() const { return kStepToTxnIdConverter.step_from_timestamp(txn_id_); } void DomainState::update_account( const evmc::address& address, std::optional initial, std::optional current) { if (!initial) { AccountsDomainGetLatestQuery query_prev{database_, tx_, latest_state_repository_, query_caches_}; auto result_prev = query_prev.exec(address); if (result_prev) { initial = std::move(result_prev->value); } } if (current) { if (!initial || current->rlp({}) != initial->rlp({})) { AccountsDomainPutQuery query{database_, tx_}; query.exec(address, current, txn_id_, initial, current_step()); } } else { AccountsDomainDeleteQuery query{database_, tx_}; query.exec(address, txn_id_, initial, current_step()); } } void DomainState::update_account_code( const evmc::address& address, uint64_t /*incarnation*/, const evmc::bytes32& /*code_hash*/, ByteView code) { CodeDomainGetLatestQuery query_prev{database_, tx_, latest_state_repository_, query_caches_}; auto result_prev = query_prev.exec(address); std::optional original_code = std::nullopt; if (result_prev) { original_code = std::move(result_prev->value); } CodeDomainPutQuery query{database_, tx_}; query.exec(address, code, txn_id_, original_code, current_step()); code_.insert_or_assign(address, code); } void DomainState::update_storage( const evmc::address& address, uint64_t /*incarnation*/, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) { evmc::bytes32 original_value{}; if (initial == evmc::bytes32{}) { StorageDomainGetLatestQuery query_prev{database_, tx_, latest_state_repository_, query_caches_}; auto result_prev = query_prev.exec({address, location}); if (result_prev) { original_value = std::move(result_prev->value); } } else { original_value = initial; } StorageDomainPutQuery query{database_, tx_}; query.exec({address, location}, current, txn_id_, original_value, current_step()); } } // namespace silkworm::execution ================================================ FILE: silkworm/execution/domain_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution { class DomainState : public State { public: explicit DomainState( TxnId txn_id, datastore::kvdb::RWTxn& tx, datastore::kvdb::DatabaseRef& database, const snapshots::SnapshotRepositoryROAccess& blocks_repository, snapshots::SnapshotRepositoryROAccess& latest_state_repository, const snapshots::QueryCaches& query_caches) : txn_id_{txn_id}, tx_{tx}, database_{database}, latest_state_repository_{latest_state_repository}, query_caches_{query_caches}, data_model_{db::DataModel{tx_, blocks_repository}} {} explicit DomainState( TxnId txn_id, datastore::kvdb::RWTxn& tx, datastore::kvdb::DatabaseRef& database, snapshots::SnapshotRepositoryROAccess& state_repository, snapshots::QueryCaches& query_caches, db::DataModel data_model) : txn_id_{txn_id}, tx_{tx}, database_{database}, latest_state_repository_{state_repository}, query_caches_{query_caches}, data_model_{std::move(data_model)} {} std::optional read_account(const evmc::address& address) const noexcept override; ByteView read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept override; evmc::bytes32 read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept override; uint64_t previous_incarnation(const evmc::address& address) const noexcept override; std::optional read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; bool read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept override; std::optional total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; evmc::bytes32 state_root_hash() const override; BlockNum current_canonical_block() const override; std::optional canonical_hash(BlockNum block_num) const override; void insert_block(const Block& /*block*/, const evmc::bytes32& /*hash*/) override {} void canonize_block(BlockNum /*block_num*/, const evmc::bytes32& /*block_hash*/) override {} void decanonize_block(BlockNum /*block_num*/) override {} void insert_receipt(const Receipt& receipt, uint64_t current_log_index, uint64_t cumulative_blob_gas_used) override; void insert_call_traces(BlockNum /*block_num*/, const CallTraces& /*traces*/) override {} void begin_block(BlockNum /*block_num*/, size_t /*updated_accounts_count*/) override {} void update_account( const evmc::address& address, std::optional initial, std::optional current) override; void update_account_code( const evmc::address& address, uint64_t incarnation, const evmc::bytes32& code_hash, ByteView code) override; void update_storage( const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) override; void unwind_state_changes(BlockNum /*block_num*/) override {} private: datastore::Step current_step() const; void insert_log_indexes(const Receipt& receipt) const; TxnId txn_id_; datastore::kvdb::RWTxn& tx_; datastore::kvdb::DatabaseRef& database_; snapshots::SnapshotRepositoryROAccess& latest_state_repository_; const snapshots::QueryCaches& query_caches_; db::DataModel data_model_; mutable std::unordered_map code_; }; } // namespace silkworm::execution ================================================ FILE: silkworm/execution/domain_state_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "domain_state.hpp" #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution { // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcherchaindata().ref(); DomainState sut{ 1, rw_tx, db_ref, ds_context->blocks_repository(), ds_context->state_repository_latest(), ds_context->query_caches(), }; auto header0_hash = sut.canonical_hash(0); auto header0 = sut.read_header(0, header0_hash.value()); const silkworm::Hash header1_hash{0x7cb4dd3daba1f739d0c1ec7d998b4a2f6fd83019116455afa54ca4f49dfa0ad4_bytes32}; SECTION("reads existing block") { auto header1 = sut.read_header(1, header1_hash); CHECK(header1.has_value()); CHECK(header1->number == 1); CHECK(header1->hash() == header1_hash); CHECK(header1->parent_hash == header0_hash); } SECTION("reads non-existing block") { auto header2 = sut.read_header(2, header1_hash); CHECK_FALSE(header2.has_value()); } SECTION("reads existing block body") { BlockBody body1{}; auto body_read_ok = sut.read_body(1, header1_hash, body1); CHECK(body_read_ok); CHECK(body1.transactions.size() == 1); } SECTION("reads non-existing block body") { BlockBody body2{}; auto body_read_ok = sut.read_body(2, header1_hash, body2); CHECK_FALSE(body_read_ok); } SECTION("reads existing total difficulty") { auto td1 = sut.total_difficulty(1, header1_hash); CHECK(td1.has_value()); CHECK(*td1 == 1); } SECTION("reads head canonical block number") { auto head_block_num = sut.current_canonical_block(); CHECK(head_block_num == 9); } //! Current genesis preloading does not store data to domain tables // SECTION("read_account preloaded block") { // auto account_65 = sut.read_account(0x658bdf435d810c91414ec09147daa6db62406379_address); // CHECK(account_65.has_value()); // CHECK(account_65->balance == intx::uint256{72, 8834426692912283648}); // } // SECTION("read_code preloaded block") { // auto code_aa = sut.read_code( // 0xaa00000000000000000000000000000000000000_address, // 0x39a32aa611e90196e88985d1de5179d967b0cab8d198f6186d5f4d3f073d4fbe_bytes32); // CHECK(code_aa.size() > 0); // CHECK(code_aa == from_hex("0x6042")); // } // SECTION("read_storage preloaded block") { // auto storage_bb_01 = sut.read_storage( // 0xbb00000000000000000000000000000000000000_address, // 0, // 0x0100000000000000000000000000000000000000000000000000000000000000_bytes32); // CHECK(storage_bb_01 == 0x0100000000000000000000000000000000000000000000000000000000000000_bytes32); // } SECTION("update_account") { Account account_66{ .nonce = 8, .balance = 260, .incarnation = kDefaultIncarnation, }; sut.update_account( 0x668bdf435d810c91414ec09147daa6db62406379_address, {}, account_66); auto account_66_read = sut.read_account(0x668bdf435d810c91414ec09147daa6db62406379_address); CHECK(account_66_read.has_value()); CHECK(account_66_read->incarnation == account_66.incarnation); CHECK(account_66_read->nonce == account_66.nonce); CHECK(account_66_read->balance == account_66.balance); } SECTION("update_account with different steps") { Account account_66{ .nonce = 8, .balance = 260, .incarnation = kDefaultIncarnation, }; sut.update_account( 0x668bdf435d810c91414ec09147daa6db62406379_address, {}, account_66); auto account_66_read = sut.read_account(0x668bdf435d810c91414ec09147daa6db62406379_address); CHECK(account_66_read.has_value()); CHECK(account_66_read->incarnation == account_66.incarnation); CHECK(account_66_read->nonce == account_66.nonce); CHECK(account_66_read->balance == account_66.balance); Account account_66_v2{ .nonce = 9, .balance = 261552435, .incarnation = kDefaultIncarnation, }; sut.update_account( 0x668bdf435d810c91414ec09147daa6db62406379_address, account_66, account_66_v2); account_66_read = sut.read_account(0x668bdf435d810c91414ec09147daa6db62406379_address); CHECK(account_66_read.has_value()); CHECK(account_66_read->incarnation == account_66_v2.incarnation); CHECK(account_66_read->nonce == account_66_v2.nonce); CHECK(account_66_read->balance == account_66_v2.balance); auto next_step_txn_id = db::state::kStepSizeForTemporalSnapshots + 1; DomainState sut2{ next_step_txn_id, rw_tx, db_ref, ds_context->blocks_repository(), ds_context->state_repository_latest(), ds_context->query_caches(), }; Account account_66_v3{ .nonce = 10, .balance = 262, .incarnation = kDefaultIncarnation, }; sut2.update_account( 0x668bdf435d810c91414ec09147daa6db62406379_address, account_66_v2, account_66_v3); account_66_read = sut2.read_account(0x668bdf435d810c91414ec09147daa6db62406379_address); CHECK(account_66_read.has_value()); CHECK(account_66_read->incarnation == account_66_v3.incarnation); CHECK(account_66_read->nonce == account_66_v3.nonce); CHECK(account_66_read->balance == account_66_v3.balance); } SECTION("update_account_code") { auto code_66 = *from_hex("0x6042"); auto code_hash_66 = std::bit_cast(keccak256(code_66)); sut.update_account_code( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, code_hash_66, code_66); auto code_66_read = sut.read_code(0x668bdf435d810c91414ec09147daa6db62406379_address, code_hash_66); CHECK(!code_66_read.empty()); CHECK(code_66_read == code_66); } SECTION("update_account_code with different steps") { auto code_66 = *from_hex("0x6042"); auto code_hash_66 = std::bit_cast(keccak256(code_66)); sut.update_account_code( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, code_hash_66, code_66); auto code_66_read = sut.read_code(0x668bdf435d810c91414ec09147daa6db62406379_address, code_hash_66); CHECK(!code_66_read.empty()); CHECK(code_66_read == code_66); code_66 = *from_hex("0x6043"); code_hash_66 = std::bit_cast(keccak256(code_66)); sut.update_account_code( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, code_hash_66, code_66); code_66_read = sut.read_code(0x668bdf435d810c91414ec09147daa6db62406379_address, code_hash_66); CHECK(!code_66_read.empty()); CHECK(code_66_read == code_66); auto next_step_txn_id = db::state::kStepSizeForTemporalSnapshots + 1; DomainState sut2{ next_step_txn_id, rw_tx, db_ref, ds_context->blocks_repository(), ds_context->state_repository_latest(), ds_context->query_caches(), }; code_66 = *from_hex("0x6044"); code_hash_66 = std::bit_cast(keccak256(code_66)); sut2.update_account_code( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, code_hash_66, code_66); code_66_read = sut2.read_code(0x668bdf435d810c91414ec09147daa6db62406379_address, code_hash_66); CHECK(!code_66_read.empty()); CHECK(code_66_read == code_66); } SECTION("update_storage") { sut.update_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32, evmc::bytes32{}, 0x0123_bytes32); auto storage_66_01 = sut.read_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32); CHECK(storage_66_01 == 0x0123_bytes32); } SECTION("update_storage with different steps") { sut.update_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32, evmc::bytes32{}, 0x0123_bytes32); auto storage_66_01 = sut.read_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32); CHECK(storage_66_01 == 0x0123_bytes32); sut.update_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32, 0x0123_bytes32, 0x0124_bytes32); storage_66_01 = sut.read_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32); CHECK(storage_66_01 == 0x0124_bytes32); auto next_step_txn_id = db::state::kStepSizeForTemporalSnapshots + 1; DomainState sut2{ next_step_txn_id, rw_tx, db_ref, ds_context->blocks_repository(), ds_context->state_repository_latest(), ds_context->query_caches(), }; sut2.update_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32, 0x0124_bytes32, 0x0456_bytes32); storage_66_01 = sut2.read_storage( 0x668bdf435d810c91414ec09147daa6db62406379_address, kDefaultIncarnation, 0x0100_bytes32); CHECK(storage_66_01 == 0x0456_bytes32); } } TEST_CASE("DomainState empty overridden methods do nothing", "[execution][domain][state]") { TemporaryDirectory tmp_dir; silkworm::db::test_util::TestDataStore ds_context{tmp_dir}; auto rw_tx = ds_context.chaindata_rw().start_rw_tx(); auto db_ref = ds_context->chaindata().ref(); DomainState sut{ 1, rw_tx, db_ref, ds_context->blocks_repository(), ds_context->state_repository_latest(), ds_context->query_caches(), }; CHECK_NOTHROW(sut.insert_block(Block{}, evmc::bytes32{})); CHECK_NOTHROW(sut.canonize_block(0, evmc::bytes32{})); CHECK_NOTHROW(sut.decanonize_block(0)); CHECK_NOTHROW(sut.insert_call_traces(0, CallTraces{})); CHECK_NOTHROW(sut.begin_block(0, 0)); CHECK_NOTHROW(sut.unwind_state_changes(0)); auto state_root_hash = sut.state_root_hash(); CHECK(state_root_hash == evmc::bytes32{}); } #endif // !defined(SILKWORM_SANITIZE) && !defined(_WIN32) } // namespace silkworm::execution ================================================ FILE: silkworm/execution/grpc/client/endpoint/assembly.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "assembly.hpp" #include #include #include "../../common/block.hpp" namespace silkworm::execution::grpc::client { namespace proto = ::execution; api::ExecutionPayload execution_payload_from_proto(const ::types::ExecutionPayload& payload) { api::ExecutionPayload execution_payload; execution_payload.version = payload.version(); execution_payload.parent_hash = rpc::bytes32_from_h256(payload.parent_hash()); execution_payload.suggested_fee_recipient = rpc::address_from_h160(payload.coinbase()); execution_payload.state_root = rpc::bytes32_from_h256(payload.state_root()); execution_payload.receipts_root = rpc::bytes32_from_h256(payload.receipt_root()); rpc::span_from_h2048(payload.logs_bloom(), execution_payload.logs_bloom); execution_payload.prev_randao = rpc::bytes32_from_h256(payload.prev_randao()); execution_payload.block_num = payload.block_number(); execution_payload.gas_limit = payload.gas_limit(); execution_payload.gas_used = payload.gas_used(); execution_payload.timestamp = payload.timestamp(); std::copy(payload.extra_data().cbegin(), payload.extra_data().cend(), execution_payload.extra_data.begin()); execution_payload.base_fee_per_gas = rpc::uint256_from_h256(payload.base_fee_per_gas()); execution_payload.block_hash = rpc::bytes32_from_h256(payload.block_hash()); execution_payload.transactions.reserve(static_cast(payload.transactions_size())); for (const auto& proto_transaction : payload.transactions()) { execution_payload.transactions.emplace_back(string_view_to_byte_view(proto_transaction)); } if (payload.withdrawals_size() > 0) { std::vector withdrawals; withdrawals.reserve(static_cast(payload.withdrawals_size())); execution_payload.withdrawals = std::move(withdrawals); } for (const auto& proto_withdrawal : payload.withdrawals()) { execution_payload.withdrawals->emplace_back(withdrawal_from_proto_type(proto_withdrawal)); } if (payload.has_blob_gas_used()) { execution_payload.blob_gas_used = payload.blob_gas_used(); } if (payload.has_excess_blob_gas()) { execution_payload.excess_blob_gas = payload.excess_blob_gas(); } return execution_payload; } api::BlobsBundleV1 blobs_bundle_from_proto(const ::types::BlobsBundleV1& bundle) { api::BlobsBundleV1 blobs_bundle; for (int i{0}; i < bundle.commitments_size(); ++i) { deserialize_hex_as_bytes(bundle.commitments(i), blobs_bundle.commitments); } for (int i{0}; i < bundle.blobs_size(); ++i) { deserialize_hex_as_bytes(bundle.blobs(i), blobs_bundle.blobs); } for (int i{0}; i < bundle.proofs_size(); ++i) { deserialize_hex_as_bytes(bundle.proofs(i), blobs_bundle.proofs); } return blobs_bundle; } api::AssembledBlock assembled_from_data(const ::execution::AssembledBlockData& data) { api::ExecutionPayload payload{execution_payload_from_proto(data.execution_payload())}; Hash block_hash{rpc::bytes32_from_h256(data.block_value())}; api::BlobsBundleV1 blobs_bundle{blobs_bundle_from_proto(data.blobs_bundle())}; return {std::move(payload), block_hash, std::move(blobs_bundle)}; } proto::AssembleBlockRequest assemble_request_from_block(const api::BlockUnderConstruction& block) { proto::AssembleBlockRequest request; request.set_timestamp(block.timestamp); request.set_allocated_parent_hash(rpc::h256_from_bytes32(block.parent_hash).release()); request.set_allocated_prev_randao(rpc::h256_from_bytes32(block.prev_randao).release()); if (block.parent_beacon_block_root) { request.set_allocated_parent_beacon_block_root( rpc::h256_from_bytes32(*block.parent_beacon_block_root).release()); } request.set_allocated_suggested_fee_recipient(rpc::h160_from_address(block.suggested_fee_recipient).release()); if (block.withdrawals) { for (const auto& withdrawal : *block.withdrawals) { ::types::Withdrawal* w{request.add_withdrawals()}; serialize_withdrawal(withdrawal, w); } } return request; } api::AssembleBlockResult assemble_result_from_response(const proto::AssembleBlockResponse& response) { api::AssembleBlockResult result{ .success = !response.busy(), .payload_id = response.id(), }; return result; } proto::GetAssembledBlockRequest get_assembled_request_from_payload_id(api::PayloadId payload_id) { proto::GetAssembledBlockRequest request; request.set_id(payload_id); return request; } api::AssembledBlockResult get_assembled_result_from_response(const proto::GetAssembledBlockResponse& response) { api::AssembledBlockResult result{ .success = !response.busy(), }; if (response.has_data()) { result.data = assembled_from_data(response.data()); } return result; } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/assembly.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../../../api/endpoint/assembly.hpp" namespace silkworm::execution::grpc::client { api::ExecutionPayload execution_payload_from_proto(const ::types::ExecutionPayload&); api::BlobsBundleV1 blobs_bundle_from_proto(const ::types::BlobsBundleV1&); api::AssembledBlock assembled_from_data(const ::execution::AssembledBlockData&); ::execution::AssembleBlockRequest assemble_request_from_block(const api::BlockUnderConstruction&); api::AssembleBlockResult assemble_result_from_response(const ::execution::AssembleBlockResponse&); ::execution::GetAssembledBlockRequest get_assembled_request_from_payload_id(api::PayloadId); api::AssembledBlockResult get_assembled_result_from_response(const ::execution::GetAssembledBlockResponse&); } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/checkers.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "checkers.hpp" #include namespace silkworm::execution::grpc::client { ::types::H256 h256_from_block_hash(const Hash& block_hash) { ::types::H256 request; rpc::h256_from_bytes32(block_hash, &request); return request; } std::optional block_num_from_response(const ::execution::GetHeaderHashNumberResponse& reply) { return reply.has_block_number() ? std::make_optional(reply.block_number()) : std::nullopt; } api::ForkChoice fork_choice_from_response(const ::execution::ForkChoice& response) { api::ForkChoice fork_choice{ .head_block_hash = rpc::bytes32_from_h256(response.head_block_hash()), .timeout = response.timeout(), }; if (response.has_finalized_block_hash()) { fork_choice.finalized_block_hash = rpc::bytes32_from_h256(response.finalized_block_hash()); } if (response.has_safe_block_hash()) { fork_choice.safe_block_hash = rpc::bytes32_from_h256(response.safe_block_hash()); } return fork_choice; } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/checkers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "../../../api/endpoint/checkers.hpp" namespace silkworm::execution::grpc::client { ::types::H256 h256_from_block_hash(const Hash& block_hash); std::optional block_num_from_response(const ::execution::GetHeaderHashNumberResponse&); api::ForkChoice fork_choice_from_response(const ::execution::ForkChoice&); } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/checkers_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "checkers.hpp" #include #include #include #include #include #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::execution::grpc::client { using namespace evmc::literals; using namespace silkworm::execution::test_util; using namespace silkworm::test_util; namespace proto = ::execution; static proto::GetHeaderHashNumberResponse sample_response() { proto::GetHeaderHashNumberResponse response; response.set_block_number(kSampleBlockNum); return response; } TEST_CASE("block_num_from_response", "[node][execution][grpc]") { const Fixtures> fixtures{ {{}, std::nullopt}, {sample_response(), kSampleBlockNum}, }; for (const auto& [response, expected_block_num] : fixtures) { SECTION("response: " + std::to_string(response.block_number())) { CHECK(block_num_from_response(response) == expected_block_num); } } } static constexpr evmc::bytes32 kHeadHash{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; static constexpr evmc::bytes32 kFinalizedHash{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; static constexpr evmc::bytes32 kSafeHash{0x0000000000000000000000000000000000000000000000000000000000000003_bytes32}; static constexpr uint64_t kTimeout{100u}; static proto::ForkChoice sample_proto_fork_choice() { proto::ForkChoice fork_choice; fork_choice.set_allocated_head_block_hash(rpc::h256_from_bytes32(kHeadHash).release()); fork_choice.set_timeout(kTimeout); fork_choice.set_allocated_finalized_block_hash(rpc::h256_from_bytes32(kFinalizedHash).release()); fork_choice.set_allocated_safe_block_hash(rpc::h256_from_bytes32(kSafeHash).release()); return fork_choice; } static api::ForkChoice sample_fork_choice() { api::ForkChoice fork_choice{ .head_block_hash = kHeadHash, .timeout = kTimeout, .finalized_block_hash = kFinalizedHash, .safe_block_hash = kSafeHash, }; return fork_choice; } TEST_CASE("fork_choice_from_response", "[node][execution][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_fork_choice(), sample_fork_choice()}, }; for (const auto& [proto_fork_choice, expected_fork_choice] : fixtures) { SECTION("response: " + std::to_string(proto_fork_choice.timeout())) { const auto fork_choice{fork_choice_from_response(proto_fork_choice)}; CHECK(fork_choice.head_block_hash == expected_fork_choice.head_block_hash); CHECK(fork_choice.timeout == expected_fork_choice.timeout); CHECK(fork_choice.finalized_block_hash == expected_fork_choice.finalized_block_hash); CHECK(fork_choice.safe_block_hash == expected_fork_choice.safe_block_hash); } } } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/getters.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "getters.hpp" #include #include "../../common/block.hpp" namespace silkworm::execution::grpc::client { ::execution::GetSegmentRequest request_from_block_num_or_hash(const api::BlockNumOrHash& block_num_or_hash) { ::execution::GetSegmentRequest request; if (std::holds_alternative(block_num_or_hash)) { const auto& block_hash{std::get(block_num_or_hash)}; request.set_allocated_block_hash(rpc::h256_from_bytes32(block_hash).release()); } else { SILKWORM_ASSERT(std::holds_alternative(block_num_or_hash)); const auto block_num{std::get(block_num_or_hash)}; request.set_block_number(block_num); } return request; } std::optional total_difficulty_from_response(const ::execution::GetTDResponse& response) { if (!response.has_td()) { return {}; } return rpc::uint256_from_h256(response.td()); } std::optional header_from_response(const ::execution::GetHeaderResponse& response) { if (!response.has_header()) { return {}; } return header_from_proto(response.header()); } std::optional body_from_response(const ::execution::GetBodyResponse& response) { if (!response.has_body()) { return {}; } return body_from_proto(response.body()); } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/getters.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../../../api/endpoint/getters.hpp" namespace silkworm::execution::grpc::client { ::execution::GetSegmentRequest request_from_block_num_or_hash(const api::BlockNumOrHash&); std::optional total_difficulty_from_response(const ::execution::GetTDResponse&); std::optional header_from_response(const ::execution::GetHeaderResponse&); std::optional body_from_response(const ::execution::GetBodyResponse&); } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/getters_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "getters.hpp" #include #include #include #include #include #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::execution::grpc::client { using namespace evmc::literals; using namespace silkworm::execution::test_util; using namespace silkworm::test_util; namespace proto = ::execution; static api::BlockNumOrHash sample_block_num_or_hash(bool has_number) { if (has_number) { return kSampleBlockNum; } return kSampleBlockHash; } static proto::GetSegmentRequest sample_proto_get_segment_request( std::optional block_num, std::optional hash) { proto::GetSegmentRequest request; if (block_num) { request.set_block_number(*block_num); } if (hash) { request.set_allocated_block_hash(rpc::h256_from_bytes32(*hash).release()); } return request; } TEST_CASE("request_from_block_num_or_hash", "[node][execution][grpc]") { const Fixtures fixtures{ {{}, sample_proto_get_segment_request(0, {})}, // BlockNumOrHash contains 1st variant as default {sample_block_num_or_hash(true), sample_proto_get_segment_request(kSampleBlockNum, {})}, {sample_block_num_or_hash(false), sample_proto_get_segment_request({}, kSampleBlockHash)}, }; for (const auto& [block_num_or_hash, expected_segment_request] : fixtures) { SECTION("block_num_or_hash index: " + std::to_string(block_num_or_hash.index())) { const auto segment_request{request_from_block_num_or_hash(block_num_or_hash)}; // CHECK(segment_request == expected_segment_request); // requires operator== in gRPC generated code CHECK(segment_request.has_block_number() == expected_segment_request.has_block_number()); if (segment_request.has_block_number()) { CHECK(segment_request.block_number() == expected_segment_request.block_number()); } CHECK(segment_request.has_block_hash() == expected_segment_request.has_block_hash()); if (segment_request.has_block_hash()) { CHECK(segment_request.block_hash() == expected_segment_request.block_hash()); } } } } static constexpr TotalDifficulty kTotalDifficulty{1'000'000}; static proto::GetTDResponse sample_td_response(bool has_value) { proto::GetTDResponse response; if (has_value) { response.set_allocated_td(rpc::h256_from_uint256(kTotalDifficulty).release()); } return response; } static std::optional sample_total_difficulty(bool has_value) { return has_value ? std::make_optional(kTotalDifficulty) : std::nullopt; } TEST_CASE("total_difficulty_from_response", "[node][execution][grpc]") { const Fixtures> fixtures{ {sample_td_response(false), sample_total_difficulty(false)}, {sample_td_response(true), sample_total_difficulty(true)}, }; for (const auto& [response, expected_total_difficulty] : fixtures) { SECTION("expected_total_difficulty: " + std::to_string(expected_total_difficulty.has_value())) { const auto total_difficulty{total_difficulty_from_response(response)}; CHECK(total_difficulty == expected_total_difficulty); } } } static proto::GetHeaderResponse sample_get_header_response() { proto::GetHeaderResponse response; sample_proto_header(response.mutable_header()); return response; } TEST_CASE("header_from_response", "[node][execution][grpc]") { const Fixtures> fixtures{ {{}, {}}, {sample_get_header_response(), sample_block_header()}, }; for (const auto& [response, expected_block_header] : fixtures) { SECTION("expected_block_header: " + std::to_string(expected_block_header.has_value())) { const auto block_header{header_from_response(response)}; CHECK(block_header == expected_block_header); } } } static proto::GetBodyResponse sample_get_body_response() { proto::GetBodyResponse response; sample_proto_body(response.mutable_body()); return response; } TEST_CASE("body_from_response", "[node][execution][grpc]") { const Fixtures> fixtures{ {{}, {}}, {sample_get_body_response(), sample_block_body()}, }; for (const auto& [response, expected_block_body] : fixtures) { SECTION("expected_block_body: " + std::to_string(expected_block_body.has_value())) { const auto block_body{body_from_response(response)}; CHECK(block_body == expected_block_body); } } } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/insertion.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "insertion.hpp" #include "../../common/block.hpp" #include "status.hpp" namespace silkworm::execution::grpc::client { namespace proto = ::execution; proto::InsertBlocksRequest insertion_request_from_blocks(const api::Blocks& blocks) { proto::InsertBlocksRequest request; for (const auto& block : blocks) { proto::Block* b = request.add_blocks(); proto::Header* header = b->mutable_header(); proto_from_header(block->header, header); proto::BlockBody* body = b->mutable_body(); proto_from_body(*block, body); } return request; } api::InsertionResult insertion_result_from_response(const proto::InsertionResult& response) { return {.status = execution_status_from_proto(response.result())}; } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/insertion.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../../../api/endpoint/insertion.hpp" namespace silkworm::execution::grpc::client { ::execution::InsertBlocksRequest insertion_request_from_blocks(const api::Blocks&); api::InsertionResult insertion_result_from_response(const ::execution::InsertionResult&); } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/insertion_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "insertion.hpp" #include #include #include #include #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::execution::grpc::client { using namespace evmc::literals; using namespace silkworm::execution::test_util; using namespace silkworm::test_util; namespace proto = ::execution; static api::Blocks sample_blocks() { return {std::make_shared(), std::make_shared(sample_block())}; } static void empty_proto_block(proto::Block* proto_block) { proto_block->mutable_header(); proto_block->mutable_body(); } static proto::InsertBlocksRequest sample_proto_insert_block_request() { proto::InsertBlocksRequest request; empty_proto_block(request.add_blocks()); // first empty block sample_proto_block(request.add_blocks()); return request; } TEST_CASE("insertion_request_from_blocks", "[node][execution][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_blocks(), sample_proto_insert_block_request()}, }; for (const auto& [blocks, expected_insertion_request] : fixtures) { SECTION("blocks size: " + std::to_string(blocks.size())) { const auto insertion_request{insertion_request_from_blocks(blocks)}; // CHECK(insertion_request == expected_insertion_request); // requires operator== in gRPC generated code CHECK(insertion_request.blocks_size() == expected_insertion_request.blocks_size()); if (insertion_request.blocks_size() == expected_insertion_request.blocks_size()) { for (int i{0}; i < insertion_request.blocks_size(); ++i) { const auto& block{insertion_request.blocks(i)}; const auto& expected_block{expected_insertion_request.blocks(i)}; // CHECK(block == expected_block); // requires operator== in gRPC generated code CHECK(block.has_header() == expected_block.has_header()); if (block.has_header()) { const auto& header{block.header()}; const auto& expected_header{expected_block.header()}; CHECK(header.block_number() == expected_header.block_number()); } CHECK(block.has_body() == expected_block.has_body()); } } } } } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/range.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "range.hpp" #include #include "../../common/block.hpp" namespace silkworm::execution::grpc::client { namespace proto = ::execution; proto::GetBodiesByRangeRequest bodies_request_from_block_num_range(BlockNumRange block_num_range) { SILKWORM_ASSERT(block_num_range.start <= block_num_range.end); proto::GetBodiesByRangeRequest request; request.set_start(block_num_range.start); request.set_count(block_num_range.size()); return request; } proto::GetBodiesByHashesRequest bodies_request_from_block_hashes(const api::BlockHashes& block_hashes) { proto::GetBodiesByHashesRequest request; for (const auto& hash : block_hashes) { ::types::H256* h256{request.add_hashes()}; rpc::h256_from_bytes32(hash, h256); } return request; } api::BlockBodies block_bodies_from_response(const proto::GetBodiesBatchResponse& response) { api::BlockBodies bodies; bodies.reserve(static_cast(response.bodies_size())); for (const auto& received_body : response.bodies()) { bodies.emplace_back(body_from_proto(received_body)); } return bodies; } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/range.hpp" namespace silkworm::execution::grpc::client { ::execution::GetBodiesByRangeRequest bodies_request_from_block_num_range(BlockNumRange); ::execution::GetBodiesByHashesRequest bodies_request_from_block_hashes(const api::BlockHashes&); api::BlockBodies block_bodies_from_response(const ::execution::GetBodiesBatchResponse&); } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/status.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "status.hpp" #include namespace silkworm::execution::grpc::client { namespace proto = ::execution; api::ExecutionStatus execution_status_from_proto(const proto::ExecutionStatus& proto_status) { switch (proto_status) { case proto::ExecutionStatus::Success: return api::ExecutionStatus::kSuccess; case proto::ExecutionStatus::BadBlock: return api::ExecutionStatus::kBadBlock; case proto::ExecutionStatus::TooFarAway: return api::ExecutionStatus::kTooFarAway; case proto::ExecutionStatus::MissingSegment: return api::ExecutionStatus::kMissingSegment; case proto::ExecutionStatus::InvalidForkchoice: return api::ExecutionStatus::kInvalidForkchoice; case proto::ExecutionStatus::Busy: return api::ExecutionStatus::kBusy; default: throw std::logic_error{"unsupported ::execution::ExecutionStatus value " + std::to_string(int{proto_status})}; } } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/status.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/status.hpp" namespace silkworm::execution::grpc::client { api::ExecutionStatus execution_status_from_proto(const ::execution::ExecutionStatus&); } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/validation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "validation.hpp" #include #include "status.hpp" namespace silkworm::execution::grpc::client { namespace proto = ::execution; proto::ValidationRequest request_from_block_id(const BlockId& block_id) { proto::ValidationRequest request; request.set_number(block_id.block_num); request.set_allocated_hash(rpc::h256_from_bytes32(block_id.hash).release()); return request; } api::ValidationResult validation_result_from_response(const proto::ValidationReceipt& receipt) { api::ValidationResult result; const Hash latest_valid_head{rpc::bytes32_from_h256(receipt.latest_valid_hash())}; if (receipt.validation_status() == proto::ExecutionStatus::Success) { result = api::ValidChain{ .current_head = BlockId{.hash = latest_valid_head}, }; } else if (receipt.validation_status() == proto::ExecutionStatus::InvalidForkchoice) { result = api::InvalidChain{ .unwind_point = BlockId{.hash = latest_valid_head}, }; } else { result = api::ValidationError{ .latest_valid_head = BlockId{.hash = latest_valid_head}, .error = receipt.validation_error(), }; } return result; } proto::ForkChoice request_from_fork_choice(const api::ForkChoice& fork_choice) { proto::ForkChoice request; request.set_allocated_head_block_hash(rpc::h256_from_bytes32(fork_choice.head_block_hash).release()); request.set_timeout(fork_choice.timeout); if (fork_choice.finalized_block_hash) { request.set_allocated_finalized_block_hash(rpc::h256_from_bytes32(*fork_choice.finalized_block_hash).release()); } if (fork_choice.safe_block_hash) { request.set_allocated_safe_block_hash(rpc::h256_from_bytes32(*fork_choice.safe_block_hash).release()); } return request; } api::ForkChoiceResult fork_choice_result_from_response(const proto::ForkChoiceReceipt& receipt) { return { .status = execution_status_from_proto(receipt.status()), .latest_valid_head = rpc::bytes32_from_h256(receipt.latest_valid_hash()), .validation_error = receipt.validation_error(), }; } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/endpoint/validation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/checkers.hpp" #include "../../../api/endpoint/validation.hpp" namespace silkworm::execution::grpc::client { ::execution::ValidationRequest request_from_block_id(const BlockId&); api::ValidationResult validation_result_from_response(const ::execution::ValidationReceipt&); ::execution::ForkChoice request_from_fork_choice(const api::ForkChoice&); api::ForkChoiceResult fork_choice_result_from_response(const ::execution::ForkChoiceReceipt&); } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/remote_client.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_client.hpp" #include #include #include #include #include "endpoint/assembly.hpp" #include "endpoint/checkers.hpp" #include "endpoint/getters.hpp" #include "endpoint/insertion.hpp" #include "endpoint/range.hpp" #include "endpoint/validation.hpp" namespace silkworm::execution::grpc::client { namespace proto = ::execution; using Stub = proto::Execution::StubInterface; static std::shared_ptr<::grpc::Channel> make_grpc_channel(const std::string& address_uri) { return ::grpc::CreateChannel(address_uri, ::grpc::InsecureChannelCredentials()); } class RemoteClientImpl final : public api::Service { public: explicit RemoteClientImpl(const std::string& address_uri, agrpc::GrpcContext& grpc_context) : channel_{make_grpc_channel(address_uri)}, stub_{proto::Execution::NewStub(channel_)}, grpc_context_{grpc_context} {} ~RemoteClientImpl() override = default; RemoteClientImpl(const RemoteClientImpl&) = delete; RemoteClientImpl& operator=(const RemoteClientImpl&) = delete; /** Chain Putters **/ // rpc InsertBlocks(InsertBlocksRequest) returns(InsertionResult); Task insert_blocks(const api::Blocks& blocks) override { auto request = insertion_request_from_blocks(blocks); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncInsertBlocks, *stub_, std::move(request), grpc_context_); co_return insertion_result_from_response(reply); } /** Chain Validation and ForkChoice **/ // rpc ValidateChain(ValidationRequest) returns(ValidationReceipt); Task validate_chain(BlockId block_id) override { auto request = request_from_block_id(block_id); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncValidateChain, *stub_, std::move(request), grpc_context_); co_return validation_result_from_response(reply); } // rpc UpdateForkChoice(ForkChoice) returns(ForkChoiceReceipt); Task update_fork_choice(const api::ForkChoice& fork_choice) override { auto request = request_from_fork_choice(fork_choice); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncUpdateForkChoice, *stub_, std::move(request), grpc_context_); co_return fork_choice_result_from_response(reply); } /** Block Assembly **/ // rpc AssembleBlock(AssembleBlockRequest) returns(AssembleBlockResponse); Task assemble_block(const api::BlockUnderConstruction& block) override { auto request = assemble_request_from_block(block); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncAssembleBlock, *stub_, std::move(request), grpc_context_); co_return assemble_result_from_response(reply); } // rpc GetAssembledBlock(GetAssembledBlockRequest) returns(GetAssembledBlockResponse); Task get_assembled_block(api::PayloadId id) override { auto request = get_assembled_request_from_payload_id(id); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetAssembledBlock, *stub_, std::move(request), grpc_context_); co_return get_assembled_result_from_response(reply); } /** Chain Getters **/ // rpc CurrentHeader(google.protobuf.Empty) returns(GetHeaderResponse); Task> current_header() override { google::protobuf::Empty request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncCurrentHeader, *stub_, std::move(request), grpc_context_); co_return header_from_response(reply); } // rpc GetTD(GetSegmentRequest) returns(GetTDResponse); Task> get_td(api::BlockNumOrHash block_num_or_hash) override { auto request = request_from_block_num_or_hash(block_num_or_hash); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetTD, *stub_, std::move(request), grpc_context_); co_return total_difficulty_from_response(reply); } // rpc GetHeader(GetSegmentRequest) returns(GetHeaderResponse); Task> get_header(api::BlockNumOrHash block_num_or_hash) override { auto request = request_from_block_num_or_hash(block_num_or_hash); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetHeader, *stub_, std::move(request), grpc_context_); co_return header_from_response(reply); } // rpc GetBody(GetSegmentRequest) returns(GetBodyResponse); Task> get_body(api::BlockNumOrHash block_num_or_hash) override { auto request = request_from_block_num_or_hash(block_num_or_hash); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetBody, *stub_, std::move(request), grpc_context_); co_return body_from_response(reply); } // rpc HasBlock(GetSegmentRequest) returns(HasBlockResponse); Task has_block(api::BlockNumOrHash block_num_or_hash) override { auto request = request_from_block_num_or_hash(block_num_or_hash); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHasBlock, *stub_, std::move(request), grpc_context_); co_return reply.has_block(); } /** Ranges **/ // rpc GetBodiesByRange(GetBodiesByRangeRequest) returns(GetBodiesBatchResponse); Task get_bodies_by_range(BlockNumRange range) override { auto request = bodies_request_from_block_num_range(range); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetBodiesByRange, *stub_, std::move(request), grpc_context_); co_return block_bodies_from_response(reply); } // rpc GetBodiesByHashes(GetBodiesByHashesRequest) returns(GetBodiesBatchResponse); Task get_bodies_by_hashes(const api::BlockHashes& hashes) override { auto request = bodies_request_from_block_hashes(hashes); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetBodiesByHashes, *stub_, std::move(request), grpc_context_); co_return block_bodies_from_response(reply); } /** Chain Checkers **/ // rpc IsCanonicalHash(types.H256) returns(IsCanonicalResponse); Task is_canonical_hash(Hash block_hash) override { auto request = h256_from_block_hash(block_hash); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncIsCanonicalHash, *stub_, std::move(request), grpc_context_); co_return reply.canonical(); } // rpc GetHeaderHashNumber(types.H256) returns(GetHeaderHashNumberResponse); Task> get_header_hash_number(Hash block_hash) override { auto request = h256_from_block_hash(block_hash); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetHeaderHashNumber, *stub_, std::move(request), grpc_context_); co_return block_num_from_response(reply); } // rpc GetForkChoice(google.protobuf.Empty) returns(ForkChoice); Task get_fork_choice() override { google::protobuf::Empty request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetForkChoice, *stub_, std::move(request), grpc_context_); co_return fork_choice_from_response(reply); } /** Misc **/ // rpc Ready(google.protobuf.Empty) returns(ReadyResponse); Task ready() override { google::protobuf::Empty request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncReady, *stub_, std::move(request), grpc_context_); co_return reply.ready(); } // rpc FrozenBlocks(google.protobuf.Empty) returns(FrozenBlocksResponse); Task frozen_blocks() override { google::protobuf::Empty request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncFrozenBlocks, *stub_, std::move(request), grpc_context_); co_return reply.frozen_blocks(); } /** Additional non-RPC methods **/ Task get_last_headers(uint64_t n) override { api::BlockHeaders last_headers; if (n == 0) { co_return last_headers; } last_headers.reserve(n); auto last_finalized_header{co_await current_header()}; if (!last_finalized_header) { co_return last_headers; } BlockNum last_block_num = last_finalized_header->number; last_headers.push_back(std::move(*last_finalized_header)); for (BlockNum block_num = last_block_num - 1; block_num < last_block_num - n; --block_num) { auto header{co_await get_header(block_num)}; if (header) { last_headers.push_back(std::move(*header)); } } co_return last_headers; } Task block_progress() override { // This should return the last header inserted into the database but such RPC does not exist // TODO(canepat) we should either add RPC or get rid of this by refactoring sync const auto last_finalized_header{co_await current_header()}; co_return last_finalized_header->number; } private: std::shared_ptr<::grpc::Channel> channel_; std::unique_ptr stub_; agrpc::GrpcContext& grpc_context_; }; RemoteClient::RemoteClient(const std::string& address_uri, agrpc::GrpcContext& grpc_context) : p_impl_(std::make_shared(address_uri, grpc_context)) {} // Must be here (not in header) because RemoteClientImpl size is necessary for std::unique_ptr in PIMPL idiom RemoteClient::~RemoteClient() = default; std::shared_ptr RemoteClient::service() { return p_impl_; } } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/client/remote_client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../../api/client.hpp" #include "../../api/service.hpp" namespace silkworm::execution::grpc::client { class RemoteClientImpl; struct RemoteClient : public api::Client { RemoteClient(const std::string& address_uri, agrpc::GrpcContext& grpc_context); ~RemoteClient() override; std::shared_ptr service() override; private: std::shared_ptr p_impl_; }; } // namespace silkworm::execution::grpc::client ================================================ FILE: silkworm/execution/grpc/common/block.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include #include #include namespace silkworm::execution::grpc { namespace proto = ::execution; void deserialize_hex_as_bytes(std::string_view hex, std::vector& sequence) { auto blob_bytes{from_hex(hex)}; if (blob_bytes) { sequence.push_back(std::move(*blob_bytes)); } } void header_from_proto(const ::execution::Header& proto_header, BlockHeader& header) { header.parent_hash = rpc::bytes32_from_h256(proto_header.parent_hash()); header.ommers_hash = rpc::bytes32_from_h256(proto_header.ommer_hash()); header.beneficiary = rpc::address_from_h160(proto_header.coinbase()); header.state_root = rpc::bytes32_from_h256(proto_header.state_root()); header.transactions_root = rpc::bytes32_from_h256(proto_header.transaction_hash()); header.receipts_root = rpc::bytes32_from_h256(proto_header.receipt_root()); header.difficulty = rpc::uint256_from_h256(proto_header.difficulty()); header.number = proto_header.block_number(); header.gas_limit = proto_header.gas_limit(); header.gas_used = proto_header.gas_used(); header.timestamp = proto_header.timestamp(); header.prev_randao = rpc::bytes32_from_h256(proto_header.prev_randao()); rpc::span_from_h2048(proto_header.logs_bloom(), header.logs_bloom); endian::store_big_u64(header.nonce.data(), proto_header.nonce()); header.extra_data = string_view_to_byte_view(proto_header.extra_data()); if (proto_header.has_base_fee_per_gas()) { header.base_fee_per_gas = rpc::uint256_from_h256(proto_header.base_fee_per_gas()); } if (proto_header.has_withdrawal_hash()) { header.withdrawals_root = rpc::bytes32_from_h256(proto_header.withdrawal_hash()); } if (proto_header.has_blob_gas_used()) { header.blob_gas_used = proto_header.blob_gas_used(); } if (proto_header.has_excess_blob_gas()) { header.excess_blob_gas = proto_header.excess_blob_gas(); } if (proto_header.has_requests_hash()) { header.requests_hash = rpc::bytes32_from_h256(proto_header.requests_hash()); } } BlockHeader header_from_proto(const proto::Header& proto_header) { BlockHeader header; header_from_proto(proto_header, header); return header; } void body_from_proto(const ::execution::BlockBody& proto_body, BlockBody& body, Hash& block_hash, BlockNum& block_num) { block_hash = rpc::bytes32_from_h256(proto_body.block_hash()); block_num = proto_body.block_number(); body.transactions.reserve(static_cast(proto_body.transactions_size())); for (const auto& received_tx : proto_body.transactions()) { ByteView raw_tx_rlp{string_view_to_byte_view(received_tx)}; Transaction tx; rlp::decode(raw_tx_rlp, tx); body.transactions.push_back(std::move(tx)); } body.ommers.reserve(static_cast(proto_body.uncles_size())); for (const auto& received_ommer : proto_body.uncles()) { body.ommers.emplace_back(header_from_proto(received_ommer)); } if (proto_body.withdrawals_size() > 0) { std::vector withdrawals; withdrawals.reserve(static_cast(proto_body.withdrawals_size())); body.withdrawals = std::move(withdrawals); } for (const auto& received_withdrawal : proto_body.withdrawals()) { body.withdrawals->emplace_back(withdrawal_from_proto_type(received_withdrawal)); } } api::Body body_from_proto(const proto::BlockBody& proto_body) { api::Body body; body_from_proto(proto_body, body, body.block_hash, body.block_num); return body; } void proto_from_header(const BlockHeader& bh, proto::Header* header) { header->set_allocated_parent_hash(rpc::h256_from_bytes32(bh.parent_hash).release()); header->set_allocated_coinbase(rpc::h160_from_address(bh.beneficiary).release()); header->set_allocated_state_root(rpc::h256_from_bytes32(bh.state_root).release()); header->set_allocated_receipt_root(rpc::h256_from_bytes32(bh.receipts_root).release()); header->set_allocated_logs_bloom(rpc::h2048_from_string(to_string(bh.logs_bloom)).release()); header->set_allocated_prev_randao(rpc::h256_from_bytes32(bh.prev_randao).release()); header->set_block_number(bh.number); header->set_gas_limit(bh.gas_limit); header->set_gas_used(bh.gas_used); header->set_timestamp(bh.timestamp); header->set_nonce(endian::load_big_u64(bh.nonce.data())); header->set_allocated_extra_data(new std::string{byte_ptr_cast(bh.extra_data.data()), bh.extra_data.size()}); header->set_allocated_difficulty(rpc::h256_from_uint256(bh.difficulty).release()); header->set_allocated_block_hash(rpc::h256_from_bytes32(bh.hash()).release()); header->set_allocated_ommer_hash(rpc::h256_from_bytes32(bh.ommers_hash).release()); header->set_allocated_transaction_hash(rpc::h256_from_bytes32(bh.transactions_root).release()); if (bh.base_fee_per_gas) { header->set_allocated_base_fee_per_gas(rpc::h256_from_uint256(*bh.base_fee_per_gas).release()); } if (bh.withdrawals_root) { header->set_allocated_withdrawal_hash(rpc::h256_from_bytes32(*bh.withdrawals_root).release()); } if (bh.blob_gas_used) { header->set_blob_gas_used(*bh.blob_gas_used); } if (bh.excess_blob_gas) { header->set_excess_blob_gas(*bh.excess_blob_gas); } if (bh.requests_hash) { header->set_allocated_requests_hash(rpc::h256_from_bytes32(*bh.requests_hash).release()); } } void proto_from_body(const BlockBody& body, const Hash& h, BlockNum n, proto::BlockBody* proto_body) { proto_body->set_allocated_block_hash(rpc::h256_from_bytes32(h).release()); proto_body->set_block_number(n); for (const auto& transaction : body.transactions) { Bytes tx_rlp; rlp::encode(tx_rlp, transaction); proto_body->add_transactions(tx_rlp.data(), tx_rlp.size()); } for (const auto& ommer : body.ommers) { proto::Header* uncle = proto_body->add_uncles(); proto_from_header(ommer, uncle); } if (body.withdrawals) { for (const auto& withdrawal : *body.withdrawals) { ::types::Withdrawal* w = proto_body->add_withdrawals(); serialize_withdrawal(withdrawal, w); } } } void proto_from_body(const api::Body& body, proto::BlockBody* proto_body) { proto_from_body(body, body.block_hash, body.block_num, proto_body); } void proto_from_body(const Block& block, ::execution::BlockBody* proto_body) { proto_from_body(block, block.header.hash(), block.header.number, proto_body); } void serialize_withdrawal(const Withdrawal& withdrawal, ::types::Withdrawal* w) { w->set_index(withdrawal.index); w->set_validator_index(withdrawal.validator_index); w->set_allocated_address(rpc::h160_from_address(withdrawal.address).release()); w->set_amount(withdrawal.amount); } Withdrawal withdrawal_from_proto_type(const ::types::Withdrawal& w) { return { .index = w.index(), .validator_index = w.validator_index(), .address = rpc::address_from_h160(w.address()), .amount = w.amount(), }; } } // namespace silkworm::execution::grpc ================================================ FILE: silkworm/execution/grpc/common/block.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "../../api/endpoint/block.hpp" namespace silkworm::execution::grpc { void deserialize_hex_as_bytes(std::string_view, std::vector&); void header_from_proto(const ::execution::Header&, BlockHeader&); BlockHeader header_from_proto(const ::execution::Header&); void body_from_proto(const ::execution::BlockBody&, BlockBody&, Hash&, BlockNum&); api::Body body_from_proto(const ::execution::BlockBody&); void proto_from_header(const BlockHeader&, ::execution::Header*); void proto_from_body(const api::Body&, ::execution::BlockBody*); void proto_from_body(const Block&, ::execution::BlockBody*); void proto_from_body(const BlockBody&, const Hash&, BlockNum, ::execution::BlockBody*); void serialize_withdrawal(const Withdrawal&, ::types::Withdrawal*); Withdrawal withdrawal_from_proto_type(const ::types::Withdrawal&); } // namespace silkworm::execution::grpc ================================================ FILE: silkworm/execution/grpc/common/block_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include #include #include #include #include "../test_util/sample_protos.hpp" namespace silkworm::execution::grpc { using namespace silkworm::execution::test_util; using namespace silkworm::test_util; namespace proto = ::execution; TEST_CASE("deserialize_hex_as_bytes", "[node][execution][grpc]") { const Fixtures> fixtures{ {"", {Bytes{}}}, {"0x01", {Bytes{0x01}}}, {"0x0102", {Bytes{0x01, 0x02}}}, }; for (const auto& [hex, expected_byte_vector] : fixtures) { SECTION("hex bytes: " + std::to_string(expected_byte_vector.size())) { std::vector bb; CHECK_NOTHROW(deserialize_hex_as_bytes(hex, bb)); CHECK(bb == expected_byte_vector); } } SECTION("invalid hex") { std::vector bb; CHECK_NOTHROW(deserialize_hex_as_bytes("00zz", bb)); CHECK(bb.empty()); } } TEST_CASE("header_from_proto", "[node][execution][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_header(), sample_block_header()}, }; for (const auto& [proto_header, expected_block_header] : fixtures) { SECTION("header: " + std::to_string(proto_header.block_number())) { BlockHeader header; CHECK_NOTHROW(header_from_proto(proto_header, header)); CHECK(header == expected_block_header); CHECK(header_from_proto(proto_header) == expected_block_header); } } } TEST_CASE("convertibility", "[node][execution][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_proto_header(), sample_block_header()}, }; for (const auto& [expected_proto_header, expected_block_header] : fixtures) { SECTION("header: " + std::to_string(expected_proto_header.block_number())) { const BlockHeader header = header_from_proto(expected_proto_header); CHECK(header == expected_block_header); proto::Header proto_header; proto_from_header(header, &proto_header); // CHECK(proto_header == expected_proto_header); // requires operator== for proto::Header CHECK(header_from_proto(proto_header) == expected_block_header); } } } } // namespace silkworm::execution::grpc ================================================ FILE: silkworm/execution/grpc/server/endpoint/assembly.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "assembly.hpp" namespace silkworm::execution::grpc::server { api::BlockUnderConstruction block_from_assemble_request(const ::execution::AssembleBlockRequest&) { // TODO(canepat) implement return {}; } ::execution::AssembleBlockResponse response_from_assemble_result(const api::AssembleBlockResult&) { // TODO(canepat) implement return {}; } api::PayloadId get_assembled_request_from_payload_id(const ::execution::GetAssembledBlockRequest&) { // TODO(canepat) implement return {}; } ::execution::GetAssembledBlockResponse response_from_get_assembled_result(const api::AssembledBlockResult&) { // TODO(canepat) implement return {}; } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/assembly.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../../../api/endpoint/assembly.hpp" namespace silkworm::execution::grpc::server { api::BlockUnderConstruction block_from_assemble_request(const ::execution::AssembleBlockRequest&); ::execution::AssembleBlockResponse response_from_assemble_result(const api::AssembleBlockResult&); api::PayloadId get_assembled_request_from_payload_id(const ::execution::GetAssembledBlockRequest&); ::execution::GetAssembledBlockResponse response_from_get_assembled_result(const api::AssembledBlockResult&); } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/checkers.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "checkers.hpp" namespace silkworm::execution::grpc::server { ::execution::GetHeaderHashNumberResponse response_from_block_num(std::optional block_num) { ::execution::GetHeaderHashNumberResponse response; if (block_num) { response.set_block_number(*block_num); } return response; } ::execution::ForkChoice response_from_fork_choice(const api::ForkChoice& fork_choice) { ::execution::ForkChoice response; response.set_allocated_head_block_hash(rpc::h256_from_bytes32(fork_choice.head_block_hash).release()); response.set_timeout(fork_choice.timeout); if (fork_choice.finalized_block_hash) { response.set_allocated_finalized_block_hash(rpc::h256_from_bytes32(*fork_choice.finalized_block_hash).release()); } if (fork_choice.safe_block_hash) { response.set_allocated_safe_block_hash(rpc::h256_from_bytes32(*fork_choice.safe_block_hash).release()); } return response; } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/checkers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "../../../api/endpoint/checkers.hpp" namespace silkworm::execution::grpc::server { ::execution::GetHeaderHashNumberResponse response_from_block_num(std::optional); ::execution::ForkChoice response_from_fork_choice(const api::ForkChoice&); } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/checkers_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "checkers.hpp" #include #include #include #include #include #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::execution::grpc::server { using namespace evmc::literals; using namespace silkworm::execution::test_util; using namespace silkworm::test_util; namespace proto = ::execution; static proto::GetHeaderHashNumberResponse sample_response() { proto::GetHeaderHashNumberResponse response; response.set_block_number(kSampleBlockNum); return response; } TEST_CASE("response_from_block_num", "[node][execution][grpc]") { const Fixtures, proto::GetHeaderHashNumberResponse> fixtures{ {std::nullopt, {}}, {kSampleBlockNum, sample_response()}, }; for (const auto& [block_num, expected_response] : fixtures) { SECTION("response: " + std::to_string(expected_response.block_number())) { const auto response{response_from_block_num(block_num)}; // CHECK(response == expected_response); // requires operator== in gRPC CHECK(response.has_block_number() == expected_response.has_block_number()); if (response.has_block_number()) { CHECK(response.block_number() == expected_response.block_number()); } } } } static constexpr evmc::bytes32 kHeadHash{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; static constexpr evmc::bytes32 kFinalizedHash{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; static constexpr evmc::bytes32 kSafeHash{0x0000000000000000000000000000000000000000000000000000000000000003_bytes32}; static constexpr uint64_t kTimeout{100u}; static proto::ForkChoice sample_proto_fork_choice() { proto::ForkChoice fork_choice; fork_choice.set_allocated_head_block_hash(rpc::h256_from_bytes32(kHeadHash).release()); fork_choice.set_timeout(kTimeout); fork_choice.set_allocated_finalized_block_hash(rpc::h256_from_bytes32(kFinalizedHash).release()); fork_choice.set_allocated_safe_block_hash(rpc::h256_from_bytes32(kSafeHash).release()); return fork_choice; } static api::ForkChoice sample_fork_choice() { api::ForkChoice fork_choice{ .head_block_hash = kHeadHash, .timeout = kTimeout, .finalized_block_hash = kFinalizedHash, .safe_block_hash = kSafeHash, }; return fork_choice; } TEST_CASE("response_from_fork_choice", "[node][execution][grpc]") { const Fixtures fixtures{ {{}, {}}, {sample_fork_choice(), sample_proto_fork_choice()}, }; for (const auto& [fork_choice, expected_proto_fork_choice] : fixtures) { SECTION("response: " + std::to_string(fork_choice.timeout)) { const auto proto_fork_choice{response_from_fork_choice(fork_choice)}; // CHECK(proto_fork_choice == expected_proto_fork_choice); // requires operator== in gRPC CHECK(proto_fork_choice.head_block_hash() == expected_proto_fork_choice.head_block_hash()); CHECK(proto_fork_choice.timeout() == expected_proto_fork_choice.timeout()); CHECK(proto_fork_choice.has_finalized_block_hash() == expected_proto_fork_choice.has_finalized_block_hash()); CHECK(proto_fork_choice.finalized_block_hash() == expected_proto_fork_choice.finalized_block_hash()); CHECK(proto_fork_choice.has_safe_block_hash() == expected_proto_fork_choice.has_safe_block_hash()); CHECK(proto_fork_choice.safe_block_hash() == expected_proto_fork_choice.safe_block_hash()); } } } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/getters.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "getters.hpp" #include #include "../../common/block.hpp" namespace silkworm::execution::grpc::server { namespace proto = ::execution; api::BlockNumOrHash block_num_or_hash_from_request(const proto::GetSegmentRequest& request) { api::BlockNumOrHash block_num_or_hash; if (request.has_block_number()) { block_num_or_hash = request.block_number(); } else if (request.has_block_hash()) { block_num_or_hash = rpc::bytes32_from_h256(request.block_hash()); } return block_num_or_hash; } proto::GetTDResponse response_from_total_difficulty(const std::optional& total_difficulty) { proto::GetTDResponse response; if (total_difficulty) { response.set_allocated_td(rpc::h256_from_uint256(*total_difficulty).release()); } return response; } proto::GetHeaderResponse response_from_header(const std::optional& header) { proto::GetHeaderResponse response; if (header) { proto::Header* proto_header = response.mutable_header(); proto_from_header(*header, proto_header); } return response; } proto::GetBodyResponse response_from_body(const std::optional& body, const Hash& block_hash, BlockNum block_num) { proto::GetBodyResponse response; if (body) { proto::BlockBody* proto_body = response.mutable_body(); proto_from_body(*body, block_hash, block_num, proto_body); } return response; } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/getters.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../../../api/endpoint/getters.hpp" namespace silkworm::execution::grpc::server { api::BlockNumOrHash block_num_or_hash_from_request(const ::execution::GetSegmentRequest&); ::execution::GetTDResponse response_from_total_difficulty(const std::optional&); ::execution::GetHeaderResponse response_from_header(const std::optional&); ::execution::GetBodyResponse response_from_body(const std::optional&, const Hash&, BlockNum); } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/getters_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "getters.hpp" #include #include #include #include #include #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::execution::grpc::server { using namespace evmc::literals; using namespace silkworm::execution::test_util; using namespace silkworm::test_util; namespace proto = ::execution; static api::BlockNumOrHash sample_block_num_or_hash(bool has_number) { if (has_number) { return kSampleBlockNum; } return kSampleBlockHash; } static proto::GetSegmentRequest sample_proto_get_segment_request( std::optional block_num, std::optional hash) { proto::GetSegmentRequest request; if (block_num) { request.set_block_number(*block_num); } if (hash) { request.set_allocated_block_hash(rpc::h256_from_bytes32(*hash).release()); } return request; } TEST_CASE("block_num_or_hash_from_request", "[node][execution][grpc]") { const Fixtures fixtures{ {sample_proto_get_segment_request({}, {}), {}}, // BlockNumOrHash contains 1st variant as default {sample_proto_get_segment_request(0, {}), {}}, // BlockNumOrHash contains 1st variant as default {sample_proto_get_segment_request(kSampleBlockNum, {}), sample_block_num_or_hash(true)}, {sample_proto_get_segment_request({}, kSampleBlockHash), sample_block_num_or_hash(false)}, }; for (const auto& [segment_request, expected_block_num_or_hash] : fixtures) { SECTION("block_num_or_hash index: " + std::to_string(expected_block_num_or_hash.index())) { const auto block_num_or_hash{block_num_or_hash_from_request(segment_request)}; CHECK(block_num_or_hash == expected_block_num_or_hash); } } } static constexpr TotalDifficulty kTotalDifficulty{1'000'000}; static proto::GetTDResponse sample_td_response(bool has_value) { proto::GetTDResponse response; if (has_value) { response.set_allocated_td(rpc::h256_from_uint256(kTotalDifficulty).release()); } return response; } static std::optional sample_total_difficulty(bool has_value) { return has_value ? std::make_optional(kTotalDifficulty) : std::nullopt; } TEST_CASE("response_from_total_difficulty", "[node][execution][grpc]") { const Fixtures, proto::GetTDResponse> fixtures{ {sample_total_difficulty(false), sample_td_response(false)}, {sample_total_difficulty(true), sample_td_response(true)}, }; for (const auto& [total_difficulty, expected_response] : fixtures) { SECTION("total_difficulty: " + std::to_string(total_difficulty.has_value())) { const auto response{response_from_total_difficulty(total_difficulty)}; // CHECK(response == expected_response); // requires operator== in gRPC CHECK(response.has_td() == expected_response.has_td()); if (response.has_td()) { CHECK(response.td() == expected_response.td()); } } } } static proto::GetHeaderResponse sample_get_header_response() { proto::GetHeaderResponse response; proto::Header* proto_header = response.mutable_header(); sample_proto_header(proto_header); proto_header->set_allocated_block_hash(rpc::h256_from_bytes32(kSampleBlockHash).release()); return response; } TEST_CASE("response_from_header", "[node][execution][grpc]") { const Fixtures, proto::GetHeaderResponse> fixtures{ {{}, {}}, {sample_block_header(), sample_get_header_response()}, }; for (const auto& [block_header, expected_response] : fixtures) { SECTION("block_header: " + std::to_string(block_header.has_value())) { const auto response{response_from_header(block_header)}; // CHECK(response == expected_response); // requires operator== in gRPC generated code CHECK(response.has_header() == expected_response.has_header()); if (response.has_header()) { const auto& header{response.header()}; const auto& expected_header{expected_response.header()}; CHECK(header.block_number() == expected_header.block_number()); CHECK(header.has_block_hash() == expected_header.has_block_hash()); CHECK(header.block_hash() == expected_header.block_hash()); CHECK(header.extra_data() == expected_header.extra_data()); CHECK(header.parent_hash() == expected_header.parent_hash()); } } } } static proto::GetBodyResponse sample_get_body_response() { proto::GetBodyResponse response; sample_proto_body(response.mutable_body()); return response; } TEST_CASE("response_from_body", "[node][execution][grpc]") { const Fixtures, proto::GetBodyResponse> fixtures{ {{}, {}}, {sample_block_body(), sample_get_body_response()}, }; for (const auto& [block_body, expected_response] : fixtures) { SECTION("block_body: " + std::to_string(block_body.has_value())) { const auto response{response_from_body(block_body, kSampleBlockHash, kSampleBlockNum)}; // CHECK(response == expected_response); // requires operator== in gRPC generated code CHECK(response.has_body() == expected_response.has_body()); if (response.has_body()) { const auto& body{response.body()}; const auto& expected_body{expected_response.body()}; CHECK(body.block_hash() == expected_body.block_hash()); CHECK(body.block_number() == expected_body.block_number()); CHECK(body.transactions_size() == expected_body.transactions_size()); CHECK(body.uncles_size() == expected_body.uncles_size()); CHECK(body.withdrawals_size() == expected_body.withdrawals_size()); } } } } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/insertion.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "insertion.hpp" #include "../../common/block.hpp" #include "status.hpp" namespace silkworm::execution::grpc::server { namespace proto = ::execution; std::optional blocks_from_insertion_request(const proto::InsertBlocksRequest& request) { api::Blocks blocks; for (int index{0}; index < request.blocks_size(); ++index) { const auto& request_block{request.blocks(index)}; auto block{std::make_shared()}; header_from_proto(request_block.header(), block->header); Hash block_hash; body_from_proto(request_block.body(), *block, block_hash, block->header.number); if (block->header.hash() != block_hash) { return {}; } blocks.emplace_back(std::move(block)); } return blocks; } proto::InsertionResult response_from_insertion_result(const api::InsertionResult& result) { proto::InsertionResult response; response.set_result(proto_from_execution_status(result.status)); return response; } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/insertion.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../../../api/endpoint/insertion.hpp" namespace silkworm::execution::grpc::server { std::optional blocks_from_insertion_request(const ::execution::InsertBlocksRequest&); ::execution::InsertionResult response_from_insertion_result(const api::InsertionResult& result); } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/insertion_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "insertion.hpp" #include #include #include #include #include #include #include "../../test_util/sample_protos.hpp" namespace silkworm::execution::grpc::server { using namespace evmc::literals; using namespace silkworm::execution::test_util; using namespace silkworm::test_util; namespace proto = ::execution; static api::Blocks sample_blocks() { return {std::make_shared(), std::make_shared(sample_block())}; } static void empty_proto_block(proto::Block* proto_block) { static const evmc::bytes32 kEmptyHeaderHash{BlockHeader{}.hash()}; proto_block->mutable_header()->set_allocated_block_hash(rpc::h256_from_bytes32(kEmptyHeaderHash).release()); proto_block->mutable_body()->set_allocated_block_hash(rpc::h256_from_bytes32(kEmptyHeaderHash).release()); } static proto::InsertBlocksRequest sample_proto_insert_block_request() { proto::InsertBlocksRequest request; empty_proto_block(request.add_blocks()); // first empty block sample_proto_block(request.add_blocks()); return request; } static proto::InsertBlocksRequest sample_bad_proto_insert_block_request() { proto::InsertBlocksRequest request; proto::Block* proto_block = request.add_blocks(); sample_proto_block(proto_block); // Block hash in both header and body set to wrong value (i.e. hash of empty string) proto_block->mutable_header()->set_allocated_block_hash(rpc::h256_from_bytes32(kEmptyHash).release()); proto_block->mutable_body()->set_allocated_block_hash(rpc::h256_from_bytes32(kEmptyHash).release()); return request; } TEST_CASE("blocks_from_insertion_request", "[node][execution][grpc]") { const Fixtures> fixtures{ {{}, api::Blocks{}}, {sample_proto_insert_block_request(), sample_blocks()}, {sample_bad_proto_insert_block_request(), std::nullopt}, }; for (const auto& [insertion_request, expected_blocks] : fixtures) { SECTION("blocks size: " + (expected_blocks ? std::to_string(expected_blocks->size()) : "null")) { const auto blocks{blocks_from_insertion_request(insertion_request)}; REQUIRE(blocks.has_value() == expected_blocks.has_value()); if (blocks) { REQUIRE(blocks->size() == expected_blocks->size()); const size_t block_count{blocks->size()}; for (size_t i{0}; i < block_count; ++i) { const auto& block{blocks->at(i)}; const auto& expected_block{expected_blocks->at(i)}; REQUIRE((block && expected_block)); CHECK(*block == *expected_block); } } } } } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/range.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "range.hpp" #include #include "../../common/block.hpp" namespace silkworm::execution::grpc::server { namespace proto = ::execution; BlockNumRange block_num_range_from_request(const proto::GetBodiesByRangeRequest& request) { return {request.start(), request.start() + request.count()}; } api::BlockHashes block_hashes_from_request(const proto::GetBodiesByHashesRequest& request) { api::BlockHashes hashes; hashes.reserve(static_cast(request.hashes_size())); for (const auto& h256 : request.hashes()) { hashes.emplace_back(rpc::bytes32_from_h256(h256)); } return hashes; } proto::GetBodiesBatchResponse response_from_bodies(const api::BlockBodies& bodies) { proto::GetBodiesBatchResponse response; for (const auto& body : bodies) { proto::BlockBody* proto_body{response.add_bodies()}; proto_from_body(body, proto_body); } return response; } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/range.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/range.hpp" namespace silkworm::execution::grpc::server { BlockNumRange block_num_range_from_request(const ::execution::GetBodiesByRangeRequest&); api::BlockHashes block_hashes_from_request(const ::execution::GetBodiesByHashesRequest&); ::execution::GetBodiesBatchResponse response_from_bodies(const api::BlockBodies&); } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/status.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "status.hpp" #include namespace silkworm::execution::grpc::server { namespace proto = ::execution; ::execution::ExecutionStatus proto_from_execution_status(const api::ExecutionStatus& status) { switch (status) { case api::ExecutionStatus::kSuccess: return proto::ExecutionStatus::Success; case api::ExecutionStatus::kBadBlock: return proto::ExecutionStatus::BadBlock; case api::ExecutionStatus::kTooFarAway: return proto::ExecutionStatus::TooFarAway; case api::ExecutionStatus::kMissingSegment: return proto::ExecutionStatus::MissingSegment; case api::ExecutionStatus::kInvalidForkchoice: return proto::ExecutionStatus::InvalidForkchoice; case api::ExecutionStatus::kBusy: return proto::ExecutionStatus::Busy; default: throw std::logic_error{"unsupported api::ExecutionStatus value " + std::to_string(int{status})}; } } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/status.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/status.hpp" namespace silkworm::execution::grpc::server { ::execution::ExecutionStatus proto_from_execution_status(const api::ExecutionStatus&); } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/validation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "validation.hpp" #include #include "status.hpp" namespace silkworm::execution::grpc::server { namespace proto = ::execution; BlockId block_id_from_request(const proto::ValidationRequest& request) { return { .block_num = request.number(), .hash = rpc::bytes32_from_h256(request.hash()), }; } proto::ValidationReceipt response_from_validation_result(const api::ValidationResult& result) { proto::ValidationReceipt reply; if (std::holds_alternative(result)) { reply.set_validation_status(proto::ExecutionStatus::Success); const auto& valid_chain{std::get(result)}; reply.set_allocated_latest_valid_hash(rpc::h256_from_bytes32(valid_chain.current_head.hash).release()); } else if (std::holds_alternative(result)) { reply.set_validation_status(proto::ExecutionStatus::InvalidForkchoice); const auto& invalid_chain{std::get(result)}; reply.set_allocated_latest_valid_hash(rpc::h256_from_bytes32(invalid_chain.unwind_point.hash).release()); } else if (std::holds_alternative(result)) { // TODO(canepat) extend result to cover ::execution::ExecutionStatus error values reply.set_validation_status(proto::ExecutionStatus::InvalidForkchoice); const auto& validation_error{std::get(result)}; reply.set_validation_error(validation_error.error); } else { throw std::logic_error{"execution::grpc::server::response_from_validation_result unexpected result"}; } return reply; } api::ForkChoice fork_choice_from_request(const proto::ForkChoice& request) { return { .head_block_hash = rpc::bytes32_from_h256(request.head_block_hash()), .timeout = request.timeout(), .finalized_block_hash = rpc::bytes32_from_h256(request.finalized_block_hash()), .safe_block_hash = rpc::bytes32_from_h256(request.safe_block_hash()), }; } proto::ForkChoiceReceipt response_from_fork_choice_result(const api::ForkChoiceResult& result) { proto::ForkChoiceReceipt reply; reply.set_status(proto_from_execution_status(result.status)); reply.set_allocated_latest_valid_hash(rpc::h256_from_bytes32(result.latest_valid_head).release()); reply.set_validation_error(result.validation_error); return reply; } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/endpoint/validation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../../../api/endpoint/checkers.hpp" #include "../../../api/endpoint/status.hpp" #include "../../../api/endpoint/validation.hpp" namespace silkworm::execution::grpc::server { api::ExecutionStatus execution_status_from_proto(const ::execution::ExecutionStatus&); BlockId block_id_from_request(const ::execution::ValidationRequest&); ::execution::ValidationReceipt response_from_validation_result(const api::ValidationResult&); api::ForkChoice fork_choice_from_request(const ::execution::ForkChoice&); ::execution::ForkChoiceReceipt response_from_fork_choice_result(const api::ForkChoiceResult&); } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/server.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server.hpp" #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include #include #include "server_calls.hpp" namespace silkworm::execution::grpc::server { using namespace silkworm::log; using AsyncService = ::execution::Execution::AsyncService; class ServerImpl final : public rpc::Server { public: ServerImpl(rpc::ServerSettings settings, std::shared_ptr service); ServerImpl(const ServerImpl&) = delete; ServerImpl& operator=(const ServerImpl&) = delete; private: void register_async_services(::grpc::ServerBuilder& builder) override; void register_request_calls() override; void register_request_calls(agrpc::GrpcContext* grpc_context); // Register one requested call repeatedly for each RPC: asio-grpc will take care of re-registration on any incoming call template void request_repeatedly(RPC rpc, agrpc::GrpcContext* grpc_context) { auto async_service = &async_service_; auto& service = service_; // Registering repeatedly in asio-grpc will guarantee the RequestHandler lambda lifetime rpc::request_repeatedly(*grpc_context, async_service, rpc, [&service](auto&&... args) -> Task { co_await RequestHandler{std::forward(args)...}(*service); }); } std::shared_ptr service_; AsyncService async_service_; }; ServerImpl::ServerImpl(rpc::ServerSettings settings, std::shared_ptr service) : rpc::Server(std::move(settings)), service_{std::move(service)} { SILK_INFO_M("execution") << "rpc::Server created listening on: " << this->settings().address_uri << " contexts: " << this->settings().context_pool_settings.num_contexts; } // Register the gRPC services: they must exist for the lifetime of the server built by builder. void ServerImpl::register_async_services(::grpc::ServerBuilder& builder) { builder.RegisterService(&async_service_); } //! Start server-side RPC requests as required by gRPC async model: one RPC per type is requested in advance. void ServerImpl::register_request_calls() { for (size_t i = 0; i < num_contexts(); ++i) { const auto& context = next_context(); register_request_calls(context.server_grpc_context()); } } void ServerImpl::register_request_calls(agrpc::GrpcContext* grpc_context) { request_repeatedly(&AsyncService::RequestInsertBlocks, grpc_context); request_repeatedly(&AsyncService::RequestValidateChain, grpc_context); request_repeatedly(&AsyncService::RequestUpdateForkChoice, grpc_context); request_repeatedly(&AsyncService::RequestAssembleBlock, grpc_context); request_repeatedly(&AsyncService::RequestGetAssembledBlock, grpc_context); request_repeatedly(&AsyncService::RequestCurrentHeader, grpc_context); request_repeatedly(&AsyncService::RequestGetTD, grpc_context); request_repeatedly(&AsyncService::RequestGetHeader, grpc_context); request_repeatedly(&AsyncService::RequestGetBody, grpc_context); request_repeatedly(&AsyncService::RequestHasBlock, grpc_context); request_repeatedly(&AsyncService::RequestGetBodiesByRange, grpc_context); request_repeatedly(&AsyncService::RequestGetBodiesByHashes, grpc_context); request_repeatedly(&AsyncService::RequestIsCanonicalHash, grpc_context); request_repeatedly(&AsyncService::RequestGetHeaderHashNumber, grpc_context); request_repeatedly(&AsyncService::RequestGetForkChoice, grpc_context); request_repeatedly(&AsyncService::RequestReady, grpc_context); request_repeatedly(&AsyncService::RequestFrozenBlocks, grpc_context); } Server::Server(rpc::ServerSettings settings, std::shared_ptr service) : p_impl_(std::make_unique(std::move(settings), std::move(service))) {} Server::~Server() { SILK_TRACE_M("execution") << "silkworm::execution::grpc::server::Server::~Server"; } Task Server::async_run(std::optional stack_size) { return p_impl_->async_run("exec-engine", stack_size); } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/server.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "../../api/direct_service.hpp" namespace silkworm::execution::grpc::server { class ServerImpl; class Server final { public: Server(rpc::ServerSettings settings, std::shared_ptr service); ~Server(); Server(const Server&) = delete; Server& operator=(const Server&) = delete; Task async_run(std::optional stack_size = {}); private: std::unique_ptr p_impl_; }; } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/server_calls.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server_calls.hpp" #include #include #include "endpoint/assembly.hpp" #include "endpoint/checkers.hpp" #include "endpoint/getters.hpp" #include "endpoint/insertion.hpp" #include "endpoint/range.hpp" #include "endpoint/status.hpp" #include "endpoint/validation.hpp" namespace silkworm::execution::grpc::server { Task InsertBlocksCall::operator()(api::DirectService& service) { proto::InsertionResult reply; ::grpc::Status status; try { const auto blocks{blocks_from_insertion_request(request_)}; if (blocks) { const api::InsertionResult result = co_await service.insert_blocks(*blocks); reply = response_from_insertion_result(result); } else { reply.set_result(proto_from_execution_status(api::ExecutionStatus::kBadBlock)); } status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task ValidateChainCall::operator()(api::DirectService& service) { proto::ValidationReceipt reply; ::grpc::Status status; try { const auto block_id = block_id_from_request(request_); const api::ValidationResult result = co_await service.validate_chain(block_id); reply = response_from_validation_result(result); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task UpdateForkChoiceCall::operator()(api::DirectService& service) { proto::ForkChoiceReceipt reply; ::grpc::Status status; try { const auto fork_choice{fork_choice_from_request(request_)}; const api::ForkChoiceResult result = co_await service.update_fork_choice(fork_choice); reply = response_from_fork_choice_result(result); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task AssembleBlockCall::operator()(api::DirectService& service) { proto::AssembleBlockResponse reply; ::grpc::Status status; try { const auto block{block_from_assemble_request(request_)}; const api::AssembleBlockResult result = co_await service.assemble_block(block); reply = response_from_assemble_result(result); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetAssembledBlockCall::operator()(api::DirectService& service) { proto::GetAssembledBlockResponse reply; ::grpc::Status status; try { const auto payload_id{get_assembled_request_from_payload_id(request_)}; const api::AssembledBlockResult result = co_await service.get_assembled_block(payload_id); reply = response_from_get_assembled_result(result); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task CurrentHeaderCall::operator()(api::DirectService& service) { proto::GetHeaderResponse reply; ::grpc::Status status; try { const std::optional result = co_await service.current_header(); reply = response_from_header(result); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetTDCall::operator()(api::DirectService& service) { proto::GetTDResponse reply; ::grpc::Status status; try { const auto block_num_or_hash{block_num_or_hash_from_request(request_)}; const std::optional result = co_await service.get_td(block_num_or_hash); reply = response_from_total_difficulty(result); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetHeaderCall::operator()(api::DirectService& service) { proto::GetHeaderResponse reply; ::grpc::Status status; try { const auto block_num_or_hash{block_num_or_hash_from_request(request_)}; const std::optional result = co_await service.get_header(block_num_or_hash); reply = response_from_header(result); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetBodyCall::operator()(api::DirectService& service) { proto::GetBodyResponse reply; ::grpc::Status status; try { const auto block_num_or_hash{block_num_or_hash_from_request(request_)}; const std::optional result = co_await service.get_body(block_num_or_hash); const std::optional header = co_await service.get_header(block_num_or_hash); Hash block_hash{}; BlockNum block_num{0}; if (std::holds_alternative(block_num_or_hash)) { block_hash = std::get(block_num_or_hash); if (header) { block_num = header->number; } } else { block_num = std::get(block_num_or_hash); if (header) { block_hash = header->hash(); } } reply = response_from_body(result, block_hash, block_num); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task HasBlockCall::operator()(api::DirectService& service) { proto::HasBlockResponse reply; ::grpc::Status status; try { const auto block_num_or_hash{block_num_or_hash_from_request(request_)}; const bool has_block = co_await service.has_block(block_num_or_hash); reply.set_has_block(has_block); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetBodiesByRangeCall::operator()(api::DirectService& service) { proto::GetBodiesBatchResponse reply; ::grpc::Status status; try { const auto block_num_range{block_num_range_from_request(request_)}; const auto block_bodies = co_await service.get_bodies_by_range(block_num_range); reply = response_from_bodies(block_bodies); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetBodiesByHashesCall::operator()(api::DirectService& service) { proto::GetBodiesBatchResponse reply; ::grpc::Status status; try { const auto block_hashes{block_hashes_from_request(request_)}; const auto block_bodies = co_await service.get_bodies_by_hashes(block_hashes); reply = response_from_bodies(block_bodies); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task IsCanonicalHashCall::operator()(api::DirectService& service) { proto::IsCanonicalResponse reply; ::grpc::Status status; try { const auto block_hash{rpc::bytes32_from_h256(request_)}; const bool is_canonical = co_await service.is_canonical_hash(block_hash); reply.set_canonical(is_canonical); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetHeaderHashNumberCall::operator()(api::DirectService& service) { proto::GetHeaderHashNumberResponse reply; ::grpc::Status status; try { const auto block_hash{rpc::bytes32_from_h256(request_)}; const auto block_num = co_await service.get_header_hash_number(block_hash); reply = response_from_block_num(block_num); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task GetForkChoiceCall::operator()(api::DirectService& service) { proto::ForkChoice reply; ::grpc::Status status; try { const auto fork_choice = co_await service.get_fork_choice(); reply = response_from_fork_choice(fork_choice); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task ReadyCall::operator()(api::DirectService& service) { proto::ReadyResponse reply; ::grpc::Status status; try { const bool is_ready = co_await service.ready(); reply.set_ready(is_ready); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } Task FrozenBlocksCall::operator()(api::DirectService& service) { proto::FrozenBlocksResponse reply; ::grpc::Status status; try { const uint64_t num_frozen_blocks = co_await service.frozen_blocks(); reply.set_frozen_blocks(num_frozen_blocks); status = ::grpc::Status::OK; } catch (const std::exception& e) { status = ::grpc::Status{::grpc::StatusCode::INTERNAL, e.what()}; } co_await agrpc::finish(responder_, reply, status); } } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/server/server_calls.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include "../../api/direct_service.hpp" namespace silkworm::execution::grpc::server { namespace protobuf = google::protobuf; namespace proto = ::execution; namespace proto_types = ::types; using AsyncService = proto::Execution::AsyncService; // rpc InsertBlocks(InsertBlocksRequest) returns(InsertionResult); class InsertBlocksCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc ValidateChain(ValidationRequest) returns(ValidationReceipt); class ValidateChainCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc UpdateForkChoice(ForkChoice) returns(ForkChoiceReceipt); class UpdateForkChoiceCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc AssembleBlock(AssembleBlockRequest) returns(AssembleBlockResponse); class AssembleBlockCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetAssembledBlock(GetAssembledBlockRequest) returns(GetAssembledBlockResponse); class GetAssembledBlockCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc CurrentHeader(google.protobuf.Empty) returns(GetHeaderResponse); class CurrentHeaderCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetTD(GetSegmentRequest) returns(GetTDResponse); class GetTDCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetHeader(GetSegmentRequest) returns(GetHeaderResponse); class GetHeaderCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetBody(GetSegmentRequest) returns(GetBodyResponse); class GetBodyCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc HasBlock(GetSegmentRequest) returns(HasBlockResponse); class HasBlockCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetBodiesByRange(GetBodiesByRangeRequest) returns(GetBodiesBatchResponse); class GetBodiesByRangeCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetBodiesByHashes(GetBodiesByHashesRequest) returns(GetBodiesBatchResponse); class GetBodiesByHashesCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc IsCanonicalHash(types.H256) returns(IsCanonicalResponse); class IsCanonicalHashCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetHeaderHashNumber(types.H256) returns(GetHeaderHashNumberResponse); class GetHeaderHashNumberCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc GetForkChoice(google.protobuf.Empty) returns(ForkChoice); class GetForkChoiceCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc Ready(google.protobuf.Empty) returns(ReadyResponse); class ReadyCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; // rpc FrozenBlocks(google.protobuf.Empty) returns(FrozenBlocksResponse); class FrozenBlocksCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(api::DirectService& service); }; } // namespace silkworm::execution::grpc::server ================================================ FILE: silkworm/execution/grpc/test_util/sample_protos.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::execution::test_util { using namespace silkworm::test_util; namespace proto = ::execution; inline void sample_proto_header(proto::Header* header) { header->set_allocated_parent_hash(rpc::h256_from_bytes32(kSampleParentHash).release()); header->set_allocated_ommer_hash(rpc::h256_from_bytes32(kSampleOmmersHash).release()); header->set_allocated_coinbase(rpc::h160_from_address(kSampleBeneficiary).release()); header->set_allocated_state_root(rpc::h256_from_bytes32(kSampleStateRoot).release()); header->set_allocated_transaction_hash(rpc::h256_from_bytes32(kSampleTransactionsRoot).release()); header->set_allocated_receipt_root(rpc::h256_from_bytes32(kSampleReceiptsRoot).release()); header->set_allocated_difficulty(rpc::h256_from_uint256(kSampleDifficulty).release()); header->set_block_number(kSampleBlockNum); header->set_gas_limit(kSampleGasLimit); header->set_gas_used(kSampleGasUsed); header->set_timestamp(kSampleTimestamp); header->set_extra_data(byte_ptr_cast(kSampleExtraData.data()), kSampleExtraData.size()); header->set_allocated_prev_randao(rpc::h256_from_bytes32(kSamplePrevRandao).release()); header->set_nonce(endian::load_big_u64(kSampleNonce.data())); header->set_allocated_base_fee_per_gas(rpc::h256_from_uint256(kSampleBaseFeePerGas).release()); } inline proto::Header sample_proto_header() { proto::Header header; sample_proto_header(&header); return header; } inline std::string sample_proto_transaction(ByteView rlp_tx) { return std::string{byte_view_to_string_view(rlp_tx)}; } inline std::string sample_proto_tx0() { Bytes rlp_tx0{}; rlp::encode(rlp_tx0, sample_tx0()); return sample_proto_transaction(rlp_tx0); } inline std::string sample_proto_tx1() { Bytes rlp_tx1{}; rlp::encode(rlp_tx1, sample_tx1()); return sample_proto_transaction(rlp_tx1); } inline void sample_proto_ommer(proto::Header* header) { header->set_allocated_parent_hash(rpc::h256_from_bytes32(kSampleOmmerParentHash).release()); header->set_allocated_ommer_hash(rpc::h256_from_bytes32(kEmptyListHash).release()); header->set_allocated_coinbase(rpc::h160_from_address(kSampleOmmerBeneficiary).release()); header->set_allocated_state_root(rpc::h256_from_bytes32(kSampleOmmerStateRoot).release()); header->set_allocated_transaction_hash(rpc::h256_from_bytes32(kEmptyRoot).release()); header->set_allocated_receipt_root(rpc::h256_from_bytes32(kEmptyRoot).release()); header->set_allocated_difficulty(rpc::h256_from_uint256(kSampleOmmerDifficulty).release()); header->set_block_number(kSampleOmmerBlockNum); header->set_gas_limit(kSampleOmmerGasLimit); header->set_gas_used(kSampleOmmerGasUsed); header->set_timestamp(kSampleOmmerTimestamp); header->set_allocated_prev_randao(rpc::h256_from_bytes32(kSampleOmmerPrevRandao).release()); header->set_nonce(endian::load_big_u64(kSampleOmmerNonce.data())); } inline void sample_proto_withdrawal(::types::Withdrawal* withdrawal, const Withdrawal& w) { withdrawal->set_index(w.index); withdrawal->set_validator_index(w.validator_index); withdrawal->set_allocated_address(rpc::h160_from_address(w.address).release()); withdrawal->set_amount(w.amount); } inline void sample_proto_body(proto::BlockBody* body) { body->set_block_number(kSampleBlockNum); body->set_allocated_block_hash(rpc::h256_from_bytes32(kSampleBlockHash).release()); body->add_transactions(sample_proto_tx0()); body->add_transactions(sample_proto_tx1()); sample_proto_ommer(body->add_uncles()); sample_proto_withdrawal(body->add_withdrawals(), kSampleWithdrawal0); sample_proto_withdrawal(body->add_withdrawals(), kSampleWithdrawal1); sample_proto_withdrawal(body->add_withdrawals(), kSampleWithdrawal2); sample_proto_withdrawal(body->add_withdrawals(), kSampleWithdrawal3); } inline void sample_proto_block(proto::Block* block) { sample_proto_header(block->mutable_header()); sample_proto_body(block->mutable_body()); } } // namespace silkworm::execution::test_util ================================================ FILE: silkworm/execution/local_state.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "local_state.hpp" #include #include #include #include namespace silkworm::execution { using namespace db::state; using namespace datastore; std::optional LocalState::read_account(const evmc::address& address) const noexcept { return query_as_of().exec(address, txn_id_).value_or(std::nullopt); } ByteView LocalState::read_code(const evmc::address& address, const evmc::bytes32& /*code_hash*/) const noexcept { if (code_.contains(address)) { return code_[address]; // NOLINT(runtime/arrays) } auto result = query_as_of().exec(address, txn_id_); if (result) { auto [it, _] = code_.emplace(address, std::move(*result)); return it->second; } return ByteView{}; } evmc::bytes32 LocalState::read_storage(const evmc::address& address, uint64_t /*incarnation*/, const evmc::bytes32& location) const noexcept { auto result = query_as_of().exec({address, location}, txn_id_); return result.value_or(evmc::bytes32{}); } uint64_t LocalState::previous_incarnation(const evmc::address& /*address*/) const noexcept { return 0; } std::optional LocalState::read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { return data_model().read_header(block_num, block_hash); } bool LocalState::read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept { return data_model().read_body(block_hash, block_num, out); } std::optional LocalState::total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { return data_model().read_total_difficulty(block_num, block_hash); } evmc::bytes32 LocalState::state_root_hash() const { return evmc::bytes32{}; } BlockNum LocalState::current_canonical_block() const { // This method should not be called by EVM::execute return 0; } std::optional LocalState::canonical_hash(BlockNum block_num) const { // This method should not be called by EVM::execute return data_model().read_canonical_header_hash(block_num); } } // namespace silkworm::execution ================================================ FILE: silkworm/execution/local_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution { class LocalState : public State { public: explicit LocalState( std::optional txn_id, db::DataStoreRef data_store) : txn_id_{txn_id}, data_store_{std::move(data_store)}, tx_{data_store_.chaindata.access_ro().start_ro_tx()} {} std::optional read_account(const evmc::address& address) const noexcept override; ByteView read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept override; evmc::bytes32 read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept override; uint64_t previous_incarnation(const evmc::address& address) const noexcept override; std::optional read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; bool read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept override; std::optional total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; evmc::bytes32 state_root_hash() const override; BlockNum current_canonical_block() const override; std::optional canonical_hash(BlockNum block_num) const override; void insert_block(const Block& /*block*/, const evmc::bytes32& /*hash*/) override {} void canonize_block(BlockNum /*block_num*/, const evmc::bytes32& /*block_hash*/) override {} void decanonize_block(BlockNum /*block_num*/) override {} void insert_receipts(BlockNum /*block_num*/, const std::vector& /*receipts*/) override {} void insert_call_traces(BlockNum /*block_num*/, const CallTraces& /*traces*/) override {} void begin_block(BlockNum /*block_num*/, size_t /*updated_accounts_count*/) override {} void update_account( const evmc::address& /*address*/, std::optional /*initial*/, std::optional /*current*/) override {} void update_account_code( const evmc::address& /*address*/, uint64_t /*incarnation*/, const evmc::bytes32& /*code_hash*/, ByteView /*code*/) override {} void update_storage( const evmc::address& /*address*/, uint64_t /*incarnation*/, const evmc::bytes32& /*location*/, const evmc::bytes32& /*initial*/, const evmc::bytes32& /*current*/) override {} void unwind_state_changes(BlockNum /*block_num*/) override {} private: db::DataModel data_model() const { return db::DataModelFactory{data_store_}(tx_); } template auto query_as_of() const { return DomainQuery{ data_store_.chaindata, tx_, data_store_.state_repository_latest, data_store_.state_repository_historical, data_store_.query_caches, }; } std::optional txn_id_; db::DataStoreRef data_store_; mutable datastore::kvdb::ROTxnManaged tx_; mutable std::unordered_map code_; }; } // namespace silkworm::execution ================================================ FILE: silkworm/execution/remote_state.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_state.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::execution { Task> AsyncRemoteState::read_account(const evmc::address& address) const noexcept { co_return co_await state_reader_.read_account(address); } Task AsyncRemoteState::read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept { if (code_.contains(code_hash)) { co_return code_[code_hash]; // NOLINT(runtime/arrays) } const auto optional_code{co_await state_reader_.read_code(address, code_hash)}; if (optional_code) { code_[code_hash] = *optional_code; co_return code_[code_hash]; // NOLINT(runtime/arrays) } co_return ByteView{}; } Task AsyncRemoteState::read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept { co_return co_await state_reader_.read_storage(address, incarnation, location); } Task AsyncRemoteState::previous_incarnation(const evmc::address& /*address*/) const noexcept { co_return 0; } Task> AsyncRemoteState::read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { co_return co_await storage_.read_header(block_num, block_hash); } Task AsyncRemoteState::read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& filled_body) const noexcept { co_return co_await storage_.read_body(block_hash, block_num, filled_body); } Task> AsyncRemoteState::total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { co_return co_await storage_.read_total_difficulty(block_hash, block_num); } Task AsyncRemoteState::state_root_hash() const { co_return evmc::bytes32{}; } Task AsyncRemoteState::current_canonical_block() const { // This method should not be called by EVM::execute co_return 0; } Task> AsyncRemoteState::canonical_hash(BlockNum block_num) const { // This method should not be called by EVM::execute co_return co_await storage_.read_canonical_header_hash(block_num); } std::optional RemoteState::read_account(const evmc::address& address) const noexcept { SILK_DEBUG << "RemoteState::read_account address=" << address << " start"; try { std::future> result{boost::asio::co_spawn(executor_, async_state_.read_account(address), boost::asio::use_future)}; const auto optional_account{result.get()}; SILK_DEBUG << "RemoteState::read_account account.nonce=" << (optional_account ? optional_account->nonce : 0) << " end"; return optional_account; } catch (const std::exception& e) { SILK_ERROR << "RemoteState::read_account exception: " << e.what(); return std::nullopt; } } ByteView RemoteState::read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept { SILK_DEBUG << "RemoteState::read_code code_hash=" << to_hex(code_hash) << " start"; try { std::future result{boost::asio::co_spawn(executor_, async_state_.read_code(address, code_hash), boost::asio::use_future)}; const auto code{result.get()}; return code; } catch (const std::exception& e) { SILK_ERROR << "RemoteState::read_code exception: " << e.what(); return ByteView{}; } } evmc::bytes32 RemoteState::read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept { SILK_DEBUG << "RemoteState::read_storage address=" << address << " incarnation=" << incarnation << " location=" << to_hex(location) << " start"; try { std::future result{boost::asio::co_spawn(executor_, async_state_.read_storage(address, incarnation, location), boost::asio::use_future)}; const auto storage_value{result.get()}; SILK_DEBUG << "RemoteState::read_storage storage_value=" << to_hex(storage_value) << " end\n"; return storage_value; } catch (const std::exception& e) { SILK_ERROR << "RemoteState::read_storage exception: " << e.what(); return evmc::bytes32{}; } } uint64_t RemoteState::previous_incarnation(const evmc::address& address) const noexcept { SILK_DEBUG << "RemoteState::previous_incarnation address=" << address; return 0; } std::optional RemoteState::read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { SILK_DEBUG << "RemoteState::read_header block_num=" << block_num << " block_hash=" << to_hex(block_hash); try { std::future> result{boost::asio::co_spawn(executor_, async_state_.read_header(block_num, block_hash), boost::asio::use_future)}; auto optional_header{result.get()}; SILK_DEBUG << "RemoteState::read_header block_num=" << block_num << " block_hash=" << to_hex(block_hash); return optional_header; } catch (const std::exception& e) { SILK_ERROR << "RemoteState::read_header exception: " << e.what(); return std::nullopt; } } bool RemoteState::read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept { SILK_DEBUG << "RemoteState::read_body block_num=" << block_num << " block_hash=" << to_hex(block_hash); try { auto result{boost::asio::co_spawn(executor_, async_state_.read_body(block_num, block_hash, out), boost::asio::use_future)}; SILK_DEBUG << "RemoteState::read_body block_num=" << block_num << " block_hash=" << to_hex(block_hash); return result.get(); } catch (const std::exception& e) { SILK_ERROR << "RemoteState::read_body exception: " << e.what(); return false; } } std::optional RemoteState::total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { SILK_DEBUG << "RemoteState::total_difficulty block_num=" << block_num << " block_hash=" << to_hex(block_hash); try { std::future> result{boost::asio::co_spawn(executor_, async_state_.total_difficulty(block_num, block_hash), boost::asio::use_future)}; const auto optional_total_difficulty{result.get()}; SILK_DEBUG << "RemoteState::total_difficulty block_num=" << block_num << " block_hash=" << to_hex(block_hash); return optional_total_difficulty; } catch (const std::exception& e) { SILK_ERROR << "RemoteState::total_difficulty exception: " << e.what(); return std::nullopt; } } evmc::bytes32 RemoteState::state_root_hash() const { throw std::logic_error{"RemoteState::state_root_hash not yet implemented"}; } BlockNum RemoteState::current_canonical_block() const { throw std::logic_error{"RemoteState::current_canonical_block not yet implemented"}; } std::optional RemoteState::canonical_hash(BlockNum /*block_num*/) const { throw std::logic_error{"RemoteState::canonical_hash not yet implemented"}; } } // namespace silkworm::execution ================================================ FILE: silkworm/execution/remote_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution { class AsyncRemoteState { public: AsyncRemoteState( const db::chain::ChainStorage& storage, db::kv::api::Transaction& tx, std::optional txn_id) : storage_(storage), state_reader_(tx, txn_id) {} Task> read_account(const evmc::address& address) const noexcept; Task read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept; Task read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept; Task previous_incarnation(const evmc::address& address) const noexcept; Task> read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept; Task read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& filled_body) const noexcept; Task> total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept; Task state_root_hash() const; Task current_canonical_block() const; Task> canonical_hash(BlockNum block_num) const; private: mutable std::unordered_map code_; const db::chain::ChainStorage& storage_; db::kv::StateReader state_reader_; }; class RemoteState : public State { public: RemoteState( boost::asio::any_io_executor& executor, db::kv::api::Transaction& tx, const db::chain::ChainStorage& storage, std::optional txn_id) : executor_(executor), async_state_(storage, tx, txn_id) {} std::optional read_account(const evmc::address& address) const noexcept override; ByteView read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept override; evmc::bytes32 read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept override; uint64_t previous_incarnation(const evmc::address& address) const noexcept override; std::optional read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; bool read_body(BlockNum block_num, const evmc::bytes32& block_hash, BlockBody& out) const noexcept override; std::optional total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; evmc::bytes32 state_root_hash() const override; BlockNum current_canonical_block() const override; std::optional canonical_hash(BlockNum block_num) const override; void insert_block(const Block& /*block*/, const evmc::bytes32& /*hash*/) override {} void canonize_block(BlockNum /*block_num*/, const evmc::bytes32& /*block_hash*/) override {} void decanonize_block(BlockNum /*block_num*/) override {} void insert_receipts(BlockNum /*block_num*/, const std::vector& /*receipts*/) override {} void insert_call_traces(BlockNum /*block_num*/, const CallTraces& /*traces*/) override {} void begin_block(BlockNum /*block_num*/, size_t /*updated_accounts_count*/) override {} void update_account( const evmc::address& /*address*/, std::optional /*initial*/, std::optional /*current*/) override {} void update_account_code( const evmc::address& /*address*/, uint64_t /*incarnation*/, const evmc::bytes32& /*code_hash*/, ByteView /*code*/) override {} void update_storage( const evmc::address& /*address*/, uint64_t /*incarnation*/, const evmc::bytes32& /*location*/, const evmc::bytes32& /*initial*/, const evmc::bytes32& /*current*/) override {} void unwind_state_changes(BlockNum /*block_num*/) override {} private: boost::asio::any_io_executor executor_; AsyncRemoteState async_state_; }; } // namespace silkworm::execution ================================================ FILE: silkworm/execution/remote_state_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_state.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution { using testing::_; using testing::Invoke; using testing::InvokeWithoutArgs; using testing::Unused; struct RemoteStateTest : public silkworm::test_util::ContextTestBase { db::test_util::MockTransaction transaction; boost::asio::any_io_executor current_executor{ioc_.get_executor()}; db::test_util::MockChainStorage chain_storage; db::test_util::MockStateCache state_cache; }; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher(); const evmc::address address{0x0715a7794a1dc8e42615f059dd6e406a6594651a_address}; SECTION("read_code for empty hash") { EXPECT_CALL(transaction, get_one(db::table::kCodeName, _)) .WillRepeatedly(InvokeWithoutArgs([]() -> Task { co_return Bytes{}; })); const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const auto code_read{spawn_and_wait(state.read_code(address, kEmptyHash))}; CHECK(code_read.empty()); } SECTION("read_code for non-empty hash") { static const Bytes kCode{*from_hex("0x0608")}; EXPECT_CALL(transaction, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = kCode}; co_return response; })); const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const evmc::bytes32 code_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; const auto code_read{spawn_and_wait(state.read_code(address, code_hash))}; CHECK(code_read == ByteView{kCode}); } SECTION("read_code with empty response from db") { EXPECT_CALL(transaction, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; const evmc::bytes32 code_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; RemoteState state(current_executor, transaction, chain_storage, block_num); const auto code_read = state.read_code(address, code_hash); CHECK(code_read.empty()); ioc_.stop(); ioc_thread.join(); } SECTION("read_storage with empty response from db") { EXPECT_CALL(transaction, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; const evmc::bytes32 location{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; RemoteState remote_state(current_executor, transaction, chain_storage, block_num); const auto storage_read = remote_state.read_storage(address, 0, location); CHECK(storage_read == 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32); ioc_.stop(); ioc_thread.join(); } SECTION("read_account with empty response from db") { EXPECT_CALL(transaction, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; RemoteState remote_state(current_executor, transaction, chain_storage, block_num); const auto account_read = remote_state.read_account(address); CHECK(account_read == std::nullopt); ioc_.stop(); ioc_thread.join(); } SECTION("read_header with empty response from chain storage") { std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; const Hash block_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; EXPECT_CALL(chain_storage, read_header(block_num, block_hash)) .WillOnce(Invoke([](Unused, Unused) -> Task> { co_return std::nullopt; })); RemoteState remote_state(current_executor, transaction, chain_storage, block_num); const auto header_read = remote_state.read_header(block_num, block_hash); CHECK(header_read == std::nullopt); ioc_.stop(); ioc_thread.join(); } SECTION("read_body with empty response from from chain storage") { std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; const Hash block_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; BlockBody body; EXPECT_CALL(chain_storage, read_body(block_hash, block_num, body)) .WillOnce(Invoke([](Unused, Unused, Unused) -> Task { co_return true; })); RemoteState remote_state(current_executor, transaction, chain_storage, block_num); const auto success = remote_state.read_body(block_num, block_hash, body); CHECK(success); CHECK(body == BlockBody{}); ioc_.stop(); ioc_thread.join(); } SECTION("total_difficulty with empty response from db") { std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; const Hash block_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; RemoteState remote_state(current_executor, transaction, chain_storage, block_num); EXPECT_CALL(chain_storage, read_total_difficulty(block_hash, block_num)) .WillOnce(Invoke([](Unused, Unused) -> Task> { co_return std::nullopt; })); const auto total_difficulty = remote_state.total_difficulty(block_num, block_hash); CHECK(total_difficulty == std::nullopt); ioc_.stop(); ioc_thread.join(); } SECTION("previous_incarnation returns ok") { std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; RemoteState remote_state(current_executor, transaction, chain_storage, block_num); const auto prev_incarnation = remote_state.previous_incarnation(address); CHECK(prev_incarnation == 0); ioc_.stop(); ioc_thread.join(); } SECTION("current_canonical_block throws not implemented") { std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; RemoteState remote_state(current_executor, transaction, chain_storage, block_num); CHECK_THROWS_AS(remote_state.current_canonical_block(), std::logic_error); ioc_.stop(); ioc_thread.join(); } SECTION("canonical_hash throws not implemented") { std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; RemoteState remote_state(current_executor, transaction, chain_storage, block_num); CHECK_THROWS_AS(remote_state.canonical_hash(block_num), std::logic_error); ioc_.stop(); ioc_thread.join(); } SECTION("state_root_hash throws not implemented") { std::thread ioc_thread{[&]() { ioc_.run(); }}; const BlockNum block_num = 1'000'000; RemoteState remote_state(current_executor, transaction, chain_storage, block_num); CHECK_THROWS_AS(remote_state.state_root_hash(), std::logic_error); ioc_.stop(); ioc_thread.join(); } SECTION("AsyncRemoteState::read_account for empty response from db") { EXPECT_CALL(transaction, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const auto account_read{spawn_and_wait(state.read_account(address))}; CHECK(account_read == std::nullopt); } SECTION("AsyncRemoteState::read_code with empty response from db") { EXPECT_CALL(transaction, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const evmc::bytes32 code_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; const auto code_read{spawn_and_wait(state.read_code(address, code_hash))}; CHECK(code_read.empty()); } SECTION("AsyncRemoteState::read_storage with empty response from db") { EXPECT_CALL(transaction, get_as_of(_)).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); const evmc::bytes32 location{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const auto storage_read{spawn_and_wait(state.read_storage(address, 0, location))}; CHECK(storage_read == 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32); } SECTION("AsyncRemoteState::previous_incarnation returns ok") { const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const auto prev_incarnation{spawn_and_wait(state.previous_incarnation(address))}; CHECK(prev_incarnation == 0); } SECTION("AsyncRemoteState::state_root_hash returns ok") { const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const auto state_root_hash{spawn_and_wait(state.state_root_hash())}; CHECK(state_root_hash == evmc::bytes32{}); } SECTION("AsyncRemoteState::current_canonical_block returns ok") { const TxnId txn_id = 244087591818874; AsyncRemoteState state{chain_storage, transaction, txn_id}; const auto current_canonical_block{spawn_and_wait(state.current_canonical_block())}; CHECK(current_canonical_block == 0); } SECTION("AsyncRemoteState::total_difficulty with empty response from chain storage") { const TxnId txn_id = 244087591818874; const BlockNum block_num = 1'000'000; AsyncRemoteState state{chain_storage, transaction, txn_id}; const Hash block_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; EXPECT_CALL(chain_storage, read_total_difficulty(block_hash, block_num)) .WillOnce(Invoke([](Unused, Unused) -> Task> { co_return std::nullopt; })); const auto total_difficulty{spawn_and_wait(state.total_difficulty(block_num, block_hash))}; CHECK(total_difficulty == std::nullopt); } SECTION("AsyncRemoteState::read_header with empty response from chain storage") { const TxnId txn_id = 244087591818874; const BlockNum block_num = 1'000'000; AsyncRemoteState state{chain_storage, transaction, txn_id}; const Hash block_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; EXPECT_CALL(chain_storage, read_header(block_num, block_hash)) .WillOnce(Invoke([](Unused, Unused) -> Task> { co_return std::nullopt; })); const auto block_header{spawn_and_wait(state.read_header(block_num, block_hash))}; CHECK(block_header == std::nullopt); } SECTION("AsyncRemoteState::read_body with empty response from from chain storage") { const Hash block_hash{0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}; const TxnId txn_id = 244087591818874; const BlockNum block_num = 1'000'000; AsyncRemoteState state{chain_storage, transaction, txn_id}; BlockBody body; EXPECT_CALL(chain_storage, read_body(block_hash, block_num, body)) .WillOnce(Invoke([](Unused, Unused, Unused) -> Task { co_return true; })); const auto success{spawn_and_wait(state.read_body(block_num, block_hash, body))}; CHECK(success); CHECK(body == BlockBody{}); } SECTION("AsyncRemoteState::canonical_hash for empty response from chain storage") { EXPECT_CALL(transaction, get_one(db::table::kCanonicalHashesName, _)) .WillRepeatedly(InvokeWithoutArgs([=]() -> Task { co_return Bytes{}; })); const TxnId txn_id = 244087591818874; const BlockNum block_num = 1'000'000; EXPECT_CALL(chain_storage, read_canonical_header_hash(block_num)) .WillOnce(Invoke([](Unused) -> Task> { co_return std::nullopt; })); AsyncRemoteState state{chain_storage, transaction, txn_id}; const auto canonical_hash{spawn_and_wait(state.canonical_hash(block_num))}; CHECK(canonical_hash == std::nullopt); } } #endif // _WIN32 // Exclude gRPC tests from sanitizer builds due to data race warnings inside the gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(RemoteStateTest, "RemoteState") { RemoteState remote_state(current_executor, transaction, chain_storage, 0); SECTION("overridden write methods do nothing") { CHECK_NOTHROW(remote_state.insert_block(Block{}, evmc::bytes32{})); CHECK_NOTHROW(remote_state.canonize_block(0, evmc::bytes32{})); CHECK_NOTHROW(remote_state.decanonize_block(0)); CHECK_NOTHROW(remote_state.insert_receipts(0, std::vector{})); CHECK_NOTHROW(remote_state.begin_block(0, 0)); CHECK_NOTHROW(remote_state.update_account(evmc::address{}, std::nullopt, std::nullopt)); CHECK_NOTHROW(remote_state.update_account_code(evmc::address{}, 0, evmc::bytes32{}, ByteView{})); CHECK_NOTHROW(remote_state.update_storage(evmc::address{}, 0, evmc::bytes32{}, evmc::bytes32{}, evmc::bytes32{})); CHECK_NOTHROW(remote_state.unwind_state_changes(0)); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::execution ================================================ FILE: silkworm/execution/state_factory.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "state_factory.hpp" #include #include #include "local_state.hpp" #include "remote_state.hpp" namespace silkworm::execution { std::shared_ptr StateFactory::make( boost::asio::any_io_executor& executor, const db::chain::ChainStorage& storage, std::optional txn_id) const { if (tx.is_local()) { const auto& local_tx = dynamic_cast(tx); return std::make_shared(txn_id, local_tx.data_store()); } else { // NOLINT(readability-else-after-return) return std::make_shared(executor, tx, storage, txn_id); } } } // namespace silkworm::execution ================================================ FILE: silkworm/execution/state_factory.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::execution { struct StateFactory { db::kv::api::Transaction& tx; std::shared_ptr make( boost::asio::any_io_executor& executor, const db::chain::ChainStorage& storage, std::optional txn_id) const; }; } // namespace silkworm::execution ================================================ FILE: silkworm/infra/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED) find_package(Boost REQUIRED COMPONENTS headers container thread) find_package(Catch2 REQUIRED) find_package(gRPC REQUIRED) find_package(GTest REQUIRED) find_package(magic_enum REQUIRED) find_package(spdlog REQUIRED) set(LIBS_PUBLIC silkworm_core silkworm_interfaces absl::log absl::strings asio-grpc::asio-grpc Boost::headers Boost::thread gRPC::grpc++ ) # cmake-format: off set(LIBS_PRIVATE absl::time Boost::container # required for asio-grpc magic_enum::magic_enum spdlog::spdlog silkworm-buildinfo ) # cmake-format: on silkworm_library( silkworm_infra PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) # silkworm_infra_cli depends on silkworm_infra add_subdirectory(cli) # silkworm_infra_test_util depends on silkworm_infra add_subdirectory(test_util) # unit tests target_link_libraries(silkworm_infra_test PRIVATE GTest::gmock silkworm_infra_test_util) ================================================ FILE: silkworm/infra/cli/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(Boost REQUIRED COMPONENTS headers) find_package(CLI11 REQUIRED) set(LIBS_PUBLIC silkworm_core silkworm_infra Boost::headers CLI11::CLI11) # cmake-format: off set(LIBS_PRIVATE silkworm-buildinfo ) # cmake-format: on silkworm_library( silkworm_infra_cli PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) ================================================ FILE: silkworm/infra/cli/common.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "common.hpp" #include #include #include #include "ip_endpoint_option.hpp" namespace silkworm::cmd::common { //! CLI11 validator for an optional directory, checking that the folder exists if specified struct OptionalExistingDirectory : public CLI::detail::ExistingDirectoryValidator { explicit OptionalExistingDirectory() { func_ = [](const std::optional& value) -> std::string { if (!value) return {}; const auto path_result = CLI::detail::check_path(value->string().c_str()); if (path_result == CLI::detail::path_type::nonexistent) { return "Directory does not exist: " + value->string(); } if (path_result == CLI::detail::path_type::file) { return "Directory is actually a file: " + value->string(); } return {}; }; } }; void add_logging_options(CLI::App& cli, log::Settings& log_settings) { std::map level_mapping{ {"critical", log::Level::kCritical}, {"error", log::Level::kError}, {"warning", log::Level::kWarning}, {"info", log::Level::kInfo}, {"debug", log::Level::kDebug}, {"trace", log::Level::kTrace}, }; auto& log_opts = *cli.add_option_group("Log", "Logging options"); log_opts.add_option("--log.verbosity", log_settings.log_verbosity, "Sets log verbosity") ->check(CLI::Range(log::Level::kCritical, log::Level::kTrace)) ->transform(CLI::Transformer(level_mapping, CLI::ignore_case)) ->default_val(log::Level::kInfo); log_opts.add_flag("--log.stdout", log_settings.log_std_out, "Outputs to std::out instead of std::err"); log_opts.add_flag("--log.nocolor", log_settings.log_nocolor, "Disable colors on log lines"); log_opts.add_flag("--log.utc", log_settings.log_utc, "Prints log timings in UTC"); log_opts.add_flag("--log.threads", log_settings.log_threads, "Prints thread ids"); log_opts.add_option("--log.file", log_settings.log_file, "Tee all log lines to given file name"); } void add_option_chain(CLI::App& cli, uint64_t& network_id) { cli.add_option("--chain", network_id, "Name or ID of the network to join (default: \"mainnet\")") ->transform(CLI::Transformer(kKnownChainNameToId.to_std_map(), CLI::ignore_case)); } void add_option_data_dir(CLI::App& cli, std::filesystem::path& data_dir) { cli.add_option("--datadir", data_dir, "The path to the blockchain data directory") ->default_val(DataDirectory::get_default_storage_path().string()); } void add_option_data_dir(CLI::App& cli, std::optional& data_dir) { cli.add_option("--datadir", data_dir, "The path to the blockchain data directory (optional)") ->check(OptionalExistingDirectory{}) ->capture_default_str(); } void add_option_etherbase(CLI::App& cli, std::string& etherbase_address) { cli.add_option("--etherbase", etherbase_address, "The coinbase address as hex string") ->default_val(""); } void add_option_private_api_address(CLI::App& cli, std::string& private_api_address) { add_option_ip_endpoint(cli, "--private.api.addr", private_api_address, "Private API network address to serve remote database interface\n" "An empty string means to not start the listener\n" "Use the endpoint form i.e. ip-address:port\n" "DO NOT EXPOSE TO THE INTERNET"); } void add_option_remote_sentry_addresses(CLI::App& cli, std::vector& addresses, bool is_required) { cli.add_option("--sentry.remote.addr", addresses, "Remote Sentry gRPC API addresses (comma separated): :,:,...") ->delimiter(',') ->required(is_required) ->check(IPEndpointValidator(/*allow_empty=*/false)); } //! \brief Set up parsing of the number of RPC execution contexts (i.e. threading model) void add_option_num_contexts(CLI::App& cli, uint32_t& num_contexts) { cli.add_option("--contexts", num_contexts, "The number of execution contexts") ->default_val(std::thread::hardware_concurrency() / 2); } void add_context_pool_options(CLI::App& cli, concurrency::ContextPoolSettings& settings) { add_option_num_contexts(cli, settings.num_contexts); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/cli/common.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::cmd::common { //! \brief Set up options to populate log settings after cli.parse() void add_logging_options(CLI::App& cli, log::Settings& log_settings); //! \brief Set up option for the network to join void add_option_chain(CLI::App& cli, uint64_t& network_id); //! \brief Set up option for the data directory path void add_option_data_dir(CLI::App& cli, std::filesystem::path& data_dir); //! \brief Set up option for an optional data directory path void add_option_data_dir(CLI::App& cli, std::optional& data_dir); //! \brief Set up option for the node Etherbase address void add_option_etherbase(CLI::App& cli, std::string& etherbase_address); //! \brief Set up option for the IP address of Core private gRPC API void add_option_private_api_address(CLI::App& cli, std::string& private_api_address); //! \brief Set up option for the remote Sentry gRPC API address(es) void add_option_remote_sentry_addresses(CLI::App& cli, std::vector& addresses, bool is_required); //! \brief Set up context pool options void add_context_pool_options(CLI::App& cli, concurrency::ContextPoolSettings& settings); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/cli/human_size_option.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "human_size_option.hpp" #include namespace silkworm::cmd::common { HumanSizeParserValidator::HumanSizeParserValidator(size_t min_size, size_t max_size) { std::string range_desc = "range [" + human_size(min_size) + " - " + human_size(max_size) + "]"; description(range_desc); func_ = [=](const std::string& value) -> std::string { auto parsed_size = parse_size(value); if (!parsed_size) { return std::string("Value " + value + " is not a parseable size"); } if ((parsed_size.value() < min_size) || (parsed_size.value() > max_size)) { return "Value " + value + " not in " + range_desc; } return {}; }; } void add_option_human_size(CLI::App& cli, const std::string& name, size_t& value, size_t min_size, size_t max_size, const std::string& description) { CLI::Option* option = cli.add_option(name, [&value](const CLI::results_t& results) -> bool { auto value_opt = parse_size(results[0]); if (value_opt) { value = *value_opt; } return value_opt.has_value(); }); option->description(description); option->default_str(human_size(value)); option->check(HumanSizeParserValidator{min_size, max_size}); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/cli/human_size_option.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::cmd::common { struct HumanSizeParserValidator : public CLI::Validator { HumanSizeParserValidator(size_t min_size, size_t max_size); }; //! \brief Set up parsing of a human readable bytes size void add_option_human_size(CLI::App& cli, const std::string& name, size_t& value, size_t min_size, size_t max_size, const std::string& description); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/cli/ip_endpoint_option.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ip_endpoint_option.hpp" #include #include #include #include namespace silkworm::cmd::common { IPEndpointValidator::IPEndpointValidator(bool allow_empty) { func_ = [&allow_empty](const std::string& value) -> std::string { if (value.empty() && allow_empty) { return {}; } const std::regex pattern(R"(([\da-fA-F\.\:]*)\:([\d]*))"); std::smatch matches; if (!std::regex_match(value, matches, pattern)) { return "Value " + value + " is not a valid endpoint"; } // Validate IP address boost::system::error_code err; boost::asio::ip::make_address(matches[1], err).to_string(); if (err) { return "Value " + std::string(matches[1]) + " is not a valid ip address"; } // Validate port int port{std::stoi(matches[2])}; if (port < 1 || port > 65535) { return "Value " + std::string(matches[2]) + " is not a valid listening port"; } return {}; }; } void add_option_ip_endpoint(CLI::App& cli, const std::string& name, std::string& address, const std::string& description) { cli.add_option(name, address, description) ->capture_default_str() ->check(IPEndpointValidator(/*allow_empty=*/true)); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/cli/ip_endpoint_option.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::cmd::common { struct IPEndpointValidator : public CLI::Validator { explicit IPEndpointValidator(bool allow_empty = false); }; //! \brief Set up parsing of the specified IP:port endpoint void add_option_ip_endpoint(CLI::App& cli, const std::string& name, std::string& address, const std::string& description); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/cli/shutdown_signal.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "shutdown_signal.hpp" #include #include #include #include #include namespace silkworm::cmd::common { static void log_signal(int signal_number) { std::cout << "\n"; SILK_INFO << "Signal caught, number: " << signal_number; } void ShutdownSignal::cancel() { signals_.cancel(); } void ShutdownSignal::on_signal(std::function callback) { signals_.async_wait([callback = std::move(callback)](const boost::system::error_code& error, int signal_number) { if (error) { if (error != boost::system::errc::operation_canceled) { SILK_ERROR << "ShutdownSignal.on_signal async_wait error: " << error; throw boost::system::system_error(error); } SILK_DEBUG << "ShutdownSignal.on_signal async_wait cancelled"; return; } log_signal(signal_number); callback(signal_number); }); } Task ShutdownSignal::wait_me() { int signal_number = co_await signals_.async_wait(boost::asio::use_awaitable); log_signal(signal_number); co_return signal_number; } Task ShutdownSignal::wait() { auto executor = co_await boost::asio::this_coro::executor; ShutdownSignal signal{executor}; co_return (co_await signal.wait_me()); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/cli/shutdown_signal.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::cmd::common { class ShutdownSignal { public: explicit ShutdownSignal(const boost::asio::any_io_executor& executor) : signals_(executor, SIGINT, SIGTERM) {} void cancel(); using SignalNumber = int; void on_signal(std::function callback); Task wait_me(); static Task wait(); private: boost::asio::signal_set signals_; }; } // namespace silkworm::cmd::common ================================================ FILE: silkworm/infra/common/application_info.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "application_info.hpp" #include namespace silkworm { std::string get_node_name_from_build_info(const buildinfo* info) { std::string node_name = info->project_name; node_name.append("/"); node_name.append(info->git_branch); node_name.append(info->project_version); node_name.append("/"); node_name.append(info->system_name); node_name.append("-"); node_name.append(info->system_processor); node_name.append("_"); node_name.append(info->build_type); node_name.append("/"); node_name.append(info->compiler_id); node_name.append("-"); node_name.append(info->compiler_version); return node_name; } std::string make_client_id_from_build_info(const buildinfo& info) { return std::string(info.project_name) + "/v" + info.project_version + "/" + info.system_name + "-" + info.system_processor + "/" + info.compiler_id + "-" + info.compiler_version; } std::string build_info_to_string(const buildinfo* info) { std::string description{"version: "}; description.append(info->git_branch); description.append(info->project_version); description.append(" build: "); description.append(info->system_name); description.append("-"); description.append(info->system_processor); description.append("_"); description.append(info->build_type); description.append(" compiler: "); description.append(info->compiler_id); description.append("-"); description.append(info->compiler_version); return description; } ApplicationInfo make_application_info(const buildinfo* info) { return { .version = info->project_version, .commit_hash = info->git_commit_hash, .build_description = build_info_to_string(info), .node_name = get_node_name_from_build_info(info), .client_id = make_client_id_from_build_info(*info), }; } log::Args build_info_as_log_args(const buildinfo* info) { return { "version", std::string(info->git_branch) + std::string(info->project_version), "build", std::string(info->system_name) + "-" + std::string(info->system_processor) + " " + std::string(info->build_type), "compiler", std::string(info->compiler_id) + " " + std::string(info->compiler_version), }; } } // namespace silkworm ================================================ FILE: silkworm/infra/common/application_info.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include struct buildinfo; namespace silkworm { //! Application versioning information struct ApplicationInfo { std::string version; // Extracted from version control system std::string commit_hash; // Extracted from version control system std::string build_description; // Containing compiler and platform std::string node_name; // Complete node name with identifier and build info std::string client_id; // P2P RLPx clientId }; //! Assemble the complete node name using the Cable build information std::string get_node_name_from_build_info(const buildinfo* info); //! P2P RLPx clientId from the Cable build information std::string make_client_id_from_build_info(const buildinfo& info); //! Assemble the build description using the Cable build information std::string build_info_to_string(const buildinfo* info); //! Create the application versioning information from the Cable build information ApplicationInfo make_application_info(const buildinfo* info); //! Format the Cable build information as log arguments log::Args build_info_as_log_args(const buildinfo* info); } // namespace silkworm ================================================ FILE: silkworm/infra/common/async_binary_search.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "async_binary_search.hpp" namespace silkworm { Task async_binary_search(size_t n, BinaryPredicate pred) { size_t i{0}; size_t j{n}; while (j > i) { const size_t count{j - i}; const size_t m{i + count / 2}; if (co_await pred(m)) { j = m; } else { i = m + 1; } } co_return i; } } // namespace silkworm ================================================ FILE: silkworm/infra/common/async_binary_search.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { using BinaryPredicate = absl::FunctionRef(size_t)>; Task async_binary_search(size_t n, BinaryPredicate pred); } // namespace silkworm ================================================ FILE: silkworm/infra/common/async_binary_search_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "async_binary_search.hpp" #include #include #include #include namespace silkworm { struct BinarySearchTest : test_util::ContextTestBase { }; struct BinaryTestData { std::vector sequence; size_t value; size_t result; }; std::vector kTestData = { {{}, 0, 0}, {{}, 18, 0}, {{1, 2, 6, 6, 7}, 0, 0}, {{1, 2, 6, 6, 7}, 1, 0}, {{1, 2, 6, 6, 7}, 2, 1}, {{1, 2, 6, 6, 7}, 3, 2}, {{1, 2, 6, 6, 7}, 4, 2}, {{1, 2, 6, 6, 7}, 5, 2}, {{1, 2, 6, 6, 7}, 6, 2}, {{1, 2, 6, 6, 7}, 7, 4}, {{1, 2, 6, 6, 7}, 8, 5}, {{1, 2, 6, 6, 7}, 9, 5}, }; Task binary_search_in_vector(std::vector sequence, size_t value) { co_return co_await async_binary_search(sequence.size(), [&, value](uint64_t i) -> Task { co_return i < sequence.size() && sequence[i] >= value; }); } #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(BinarySearchTest, "binary_search", "[infra][common][binary_search]") { for (size_t i{0}; i < kTestData.size(); ++i) { const auto [s, v, r] = kTestData[i]; SECTION("search" + std::to_string(i)) { CHECK_NOTHROW(spawn_and_wait(binary_search_in_vector(s, v)) == r); } } } #endif // SILKWORM_SANITIZE } // namespace silkworm ================================================ FILE: silkworm/infra/common/binary_search.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "binary_search.hpp" namespace silkworm { size_t binary_find_if(size_t n, absl::FunctionRef f) { size_t i{0}; size_t j{n}; while (j > i) { const size_t count{j - i}; const size_t m{i + count / 2}; if (f(m)) { j = m; } else { i = m + 1; } } return i; } } // namespace silkworm ================================================ FILE: silkworm/infra/common/binary_search.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { // binary_find_if uses binary search to find and return the smallest index i // in [0, n) at which f(i) is true, assuming that on the range [0, n), // f(i) == true implies f(i+1) == true. That is, binary_find_if requires that // f is false for some (possibly empty) prefix of the input range [0, n) // and then true for the (possibly empty) remainder; binary_find_if returns // the first true index. If there is no such index, binary_find_if returns n. // binary_find_if calls f(i) only for i in the range [0, n). // // For a sorted vector vec and some int value, the following should return the same index: // // std::upper_bound(vec.begin(), vec.end(), value) - vec.begin(); // std::find_if(vec.begin(), vec.end(), [&](int x) { return x > value;}) - vec.begin(); // binary_find_if(vec.size(), [&](size_t i) { return vec[i] > value;}); // // N.B. Also similar to golang sort.Search. size_t binary_find_if(size_t n, absl::FunctionRef f); } // namespace silkworm ================================================ FILE: silkworm/infra/common/binary_search_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "binary_search.hpp" #include #include #include #include #include namespace silkworm { static void check_binary_find_if(const std::vector& vec, const int value) { SILKWORM_ASSERT(std::ranges::is_sorted(vec)); const auto res1{std::ranges::upper_bound(vec, value)}; const auto res2{std::ranges::find_if(vec, [&](int x) { return x > value; })}; CHECK(res1 == res2); const auto res3{binary_find_if(vec.size(), [&](size_t i) { return vec[i] > value; })}; CHECK(std::cmp_equal(res1 - vec.begin(), res3)); } TEST_CASE("binary_find_if") { check_binary_find_if({}, 42); check_binary_find_if({0}, -1); check_binary_find_if({0}, 0); check_binary_find_if({0}, 1); check_binary_find_if({1, 3, 3, 5}, 0); check_binary_find_if({1, 3, 3, 5}, 1); check_binary_find_if({1, 3, 3, 5}, 2); check_binary_find_if({1, 3, 3, 5}, 3); check_binary_find_if({1, 3, 3, 5}, 4); check_binary_find_if({1, 3, 3, 5}, 5); check_binary_find_if({1, 3, 3, 5}, 6); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/bounded_buffer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include // Apple Clang does not support std::stop_token yet, so we use boost::thread and its related facilities #include #include #include namespace silkworm { /** * @class BoundedBuffer * @brief A thread-safe bounded buffer implementation. * The bounded_buffer class provides a fixed-size buffer that can be accessed by multiple threads concurrently. * It uses boost::circular_buffer as the underlying container and provides methods for pushing and popping items. * The buffer ensures that it is not full before pushing an item and not empty before popping an item. * The class is designed to be used in a producer-consumer scenario, where one or more threads produce items and * one or more threads consume them. * The class is thread-safe and can be used in a multi-threaded environment. * @tparam T The type of items stored in the buffer. */ template class BoundedBuffer { public: using size_type = typename boost::circular_buffer::size_type; using value_type = typename boost::circular_buffer::value_type; explicit BoundedBuffer(size_type capacity) : capacity_{capacity}, unread_(0), container_(capacity) {} BoundedBuffer(const BoundedBuffer&) = delete; // Disabled copy constructor BoundedBuffer& operator=(const BoundedBuffer&) = delete; // Disabled assign operator void push_front(value_type&& item) { boost::unique_lock lock(mutex_); not_full_.wait(lock, [&] { return is_stopped() || is_not_full(); }); if (is_stopped()) { // If the buffer is stopped, do not push the item return; } container_.push_front(std::move(item)); ++unread_; lock.unlock(); not_empty_.notify_one(); } void peek_back(value_type* item) { boost::unique_lock lock(mutex_); not_empty_.wait(lock, [&] { return is_stopped() || is_not_empty(); }); if (is_stopped()) { // If the buffer is stopped, do not peek the item item = nullptr; return; } *item = container_[unread_ - 1]; lock.unlock(); } void pop_back(value_type* item) { boost::unique_lock lock(mutex_); not_empty_.wait(lock, [&] { return is_stopped() || is_not_empty(); }); if (is_stopped()) { // If the buffer is stopped, do not pop the item item = nullptr; return; } *item = container_[--unread_]; lock.unlock(); not_full_.notify_one(); } void terminate_and_release_all() { boost::unique_lock lock(mutex_); stop_ = true; lock.unlock(); not_empty_.notify_all(); not_full_.notify_all(); } bool is_stopped() const { return stop_; } size_type size() const { return unread_; } size_type capacity() const { return capacity_; } private: bool is_not_empty() const { return unread_ > 0; } bool is_not_full() const { return unread_ < capacity_; } bool stop_{false}; size_type capacity_; size_type unread_; boost::circular_buffer container_; boost::mutex mutex_; boost::condition_variable not_empty_; boost::condition_variable not_full_; }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/bounded_buffer_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bounded_buffer.hpp" #include #include #include namespace silkworm { using namespace std::this_thread; // sleep_for, sleep_until using namespace std::chrono_literals; // ns, us, ms, s, h, etc. double calculate_pi(int depth) { double pi = 0.0; for (int i = 0; i < depth; ++i) { auto numerator = static_cast(((i % 2) * 2) - 1); auto denominator = static_cast((2 * i) - 1); pi += numerator / denominator; } return (pi - 1.0) * 4; } template class Producer { Buffer* container_; int iterations_; bool delay_; public: Producer(Buffer* buffer, int iterations, bool delay) : container_(buffer), iterations_(iterations), delay_(delay) {} void operator()() { sleep_for(10ms); for (int i = 0; i < iterations_; ++i) { if (delay_) { auto pi = calculate_pi(i % 1000); if (pi < 3.14) { sleep_for(1ns); } } container_->push_front("Hello thread " + std::to_string(i)); } } }; template class Consumer { using value_type = typename Buffer::value_type; Buffer* container_; int iterations_; bool delay_; public: Consumer(Buffer* buffer, int iterations, bool delay) : container_(buffer), iterations_(iterations), delay_(delay) {} void operator()() { sleep_for(10ms); for (int i = 0; i < iterations_; ++i) { value_type item; if (delay_) { auto pi = calculate_pi(i % 1000); if (pi < 3.14) { sleep_for(1ns); } } container_->pop_back(&item); } } }; TEST_CASE("BoundedBuffer can initialize") { BoundedBuffer buffer(10); CHECK(buffer.size() == 0); CHECK(buffer.capacity() == 10); } TEST_CASE("BoundedBuffer add and remove") { BoundedBuffer buffer(10); CHECK(buffer.size() == 0); CHECK(buffer.capacity() == 10); buffer.push_front("Hello"); CHECK(buffer.size() == 1); std::string item; buffer.pop_back(&item); CHECK(item == "Hello"); CHECK(buffer.size() == 0); } TEST_CASE("BoundedBuffer waits for an item to be added") { BoundedBuffer buffer(10); buffer.push_front("Hello direct"); std::string item; buffer.pop_back(&item); CHECK(item == "Hello direct"); Producer> producer(&buffer, 1, false); std::thread produce(producer); buffer.pop_back(&item); CHECK(item == "Hello thread 0"); produce.join(); } TEST_CASE("BoundedBuffer waits for an item to be popped") { BoundedBuffer buffer(10); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); buffer.push_front("Hello"); Consumer> consumer(&buffer, 1, false); std::thread consume(consumer); buffer.push_front("Hello"); consume.join(); } TEST_CASE("BoundedBuffer multiple cycles over the buffer with delayed producer") { BoundedBuffer buffer(10); const int iterations = 100000; Producer> producer(&buffer, iterations, true); Consumer> consumer(&buffer, iterations, false); std::thread produce(producer); std::thread consume(consumer); produce.join(); consume.join(); } TEST_CASE("BoundedBuffer multiple cycles over the buffer with delayed consumer") { BoundedBuffer buffer(10); const int iterations = 100000; std::thread produce(Producer>(&buffer, iterations, false)); std::thread consume(Consumer>(&buffer, iterations, true)); produce.join(); consume.join(); } TEST_CASE("BoundedBuffer can terminate producer") { BoundedBuffer buffer(10); const int iterations = 100; std::thread produce(Producer>(&buffer, iterations, true)); buffer.terminate_and_release_all(); produce.join(); } TEST_CASE("BoundedBuffer can terminate consumer") { BoundedBuffer buffer(10); const int iterations = 100; std::thread consume(Consumer>(&buffer, iterations, true)); buffer.terminate_and_release_all(); consume.join(); } TEST_CASE("BoundedBuffer peek does not remove item") { BoundedBuffer buffer(10); buffer.push_front("Hello1"); buffer.push_front("Hello2"); buffer.push_front("Hello3"); buffer.push_front("Hello4"); std::string item; buffer.peek_back(&item); CHECK(item == "Hello1"); CHECK(buffer.size() == 4); buffer.pop_back(&item); CHECK(item == "Hello1"); CHECK(buffer.size() == 3); buffer.peek_back(&item); CHECK(item == "Hello2"); CHECK(buffer.size() == 3); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/clock_time.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "clock_time.hpp" namespace silkworm::clock_time { uint64_t now() { return static_cast( std::chrono::duration_cast( std::chrono::steady_clock::now().time_since_epoch()) .count()); } uint64_t since(uint64_t start) { return now() - start; } } // namespace silkworm::clock_time ================================================ FILE: silkworm/infra/common/clock_time.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::clock_time { uint64_t now(); uint64_t since(uint64_t start); } // namespace silkworm::clock_time ================================================ FILE: silkworm/infra/common/clock_time_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "clock_time.hpp" #include namespace silkworm::clock_time { using std::chrono::duration_cast; using std::chrono::nanoseconds; using std::chrono::steady_clock; TEST_CASE("check current time", "[infra][common][clock_time]") { const auto now_before{duration_cast(steady_clock::now().time_since_epoch()).count()}; const uint64_t now_current{now()}; const auto now_after{duration_cast(steady_clock::now().time_since_epoch()).count()}; CHECK(static_cast(now_before) <= now_current); CHECK(now_current <= static_cast(now_after)); } TEST_CASE("check elapsed time", "[infra][common][clock_time]") { const auto start{now()}; const auto elapsed{since(start)}; const auto end{now()}; const auto window = end - start; CHECK(elapsed <= window); } } // namespace silkworm::clock_time ================================================ FILE: silkworm/infra/common/decoding_exception.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "decoding_exception.hpp" #include namespace silkworm { DecodingException::DecodingException(DecodingError err, const std::string& message) : std::runtime_error{ message.empty() ? "Decoding error : " + std::string{magic_enum::enum_name(err)} : message}, err_{err} {} } // namespace silkworm ================================================ FILE: silkworm/infra/common/decoding_exception.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { class DecodingException : public std::runtime_error { public: explicit DecodingException(DecodingError err, const std::string& message = ""); DecodingError err() const noexcept { return err_; } private: DecodingError err_; }; template inline void success_or_throw(const tl::expected& res, const std::string& error_message = "") { if (!res) { throw DecodingException(res.error(), error_message); } } template inline T unwrap_or_throw(tl::expected res, const std::string& error_message = "") { success_or_throw(res, error_message); return std::move(*res); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/directories.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "directories.hpp" #include #include #include #include namespace silkworm { static std::string random_string(size_t len) { static constexpr std::string_view kAlphaNum{ "0123456789" "abcdefghijklmnopqrstuvwxyz"}; static constexpr size_t kNumberOfCharacters{kAlphaNum.length()}; // yield random numbers up to and including kNumberOfCharacters - 1 RandomNumber rnd{0, kNumberOfCharacters - 1}; std::string s; s.reserve(len); for (size_t i{0}; i < len; ++i) { size_t random_number{rnd.generate_one()}; s += kAlphaNum[random_number]; } return s; } Directory::Directory(const std::filesystem::path& directory_path, bool must_create) { if (directory_path.empty()) { path_ = std::filesystem::current_path(); } else { path_ = directory_path; } if (must_create) { create(); } } bool Directory::is_empty() const { return exists() && std::filesystem::is_empty(path_); } const std::filesystem::path& Directory::path() const { return path_; } void Directory::clear() const { if (!exists()) { return; } for (const auto& item : std::filesystem::directory_iterator(path_)) { std::filesystem::remove_all(item.path()); } } bool Directory::exists() const { return (std::filesystem::exists(path_) && std::filesystem::is_directory(path_)); } void Directory::create() { if (exists()) { return; } std::error_code ec; std::filesystem::create_directories(path_, ec); if (ec) { throw std::invalid_argument("Directory " + path_.string() + " does not exist and could not be created"); } } size_t Directory::size() const { size_t ret{0}; for (const auto& item : std::filesystem::recursive_directory_iterator(path_)) { if (std::filesystem::is_directory(item.path())) { continue; } ret += std::filesystem::file_size(item.path()); } return ret; } DataDirectory DataDirectory::from_chaindata(const std::filesystem::path& chaindata_path) { if (std::filesystem::equivalent(chaindata_path, std::filesystem::current_path())) { throw std::invalid_argument("Chaindata can't be current path"); } if (chaindata_path.empty() || !std::filesystem::exists(chaindata_path) || !std::filesystem::is_directory(chaindata_path)) { throw std::invalid_argument("Bad or not existent chaindata directory"); } //! Ensure we treat path as absolute auto chaindata_path_absolute{std::filesystem::absolute(chaindata_path)}; //! Chaindata must be at least 2 levels deep /* ├───chaindata ├───etl-temp └───nodes ├───eth65 └───eth66 */ if (std::filesystem::equivalent(chaindata_path_absolute, chaindata_path_absolute.root_path())) { throw std::invalid_argument("Chaindata directory can't be root"); } std::string delimiter{std::filesystem::path::preferred_separator}; std::vector tokens{absl::StrSplit(chaindata_path.string(), delimiter)}; if (tokens.empty() || !iequals(tokens.back(), "chaindata")) { throw std::invalid_argument("Not a valid Silkworm chaindata path"); } std::string base_path_str{}; for (size_t i = 0; i < tokens.size() - 1; ++i) { base_path_str += tokens.at(i) + delimiter; } return DataDirectory(base_path_str); } std::filesystem::path silkworm::DataDirectory::get_default_storage_path() { std::string base_dir_str{}; // C++11 guarantees some thread safety for std::getenv const char* env{std::getenv("XDG_DATA_HOME")}; // NOLINT(concurrency-mt-unsafe) if (env) { // Got storage path from docker base_dir_str.assign(env); } else { #ifdef _WIN32 std::string env_name{"APPDATA"}; #else std::string env_name{"HOME"}; #endif env = std::getenv(env_name.c_str()); // NOLINT(concurrency-mt-unsafe) if (!env) { // We don't actually know where to store data // fallback to current directory base_dir_str.assign(std::filesystem::current_path().string()); } else { base_dir_str.assign(env); } } std::filesystem::path base_dir_path{base_dir_str}; #ifdef _WIN32 base_dir_path /= "Silkworm"; #elif __APPLE__ base_dir_path /= "Library"; base_dir_path /= "Silkworm"; #else base_dir_path /= ".local"; base_dir_path /= "share"; base_dir_path /= "silkworm"; #endif if (base_dir_path.has_filename()) { base_dir_path += std::filesystem::path::preferred_separator; } return base_dir_path; } void DataDirectory::deploy() { Directory::create(); chaindata_.create(); nodes_.create(); snapshots_.create(); temp_.create(); temp_.clear(); } std::filesystem::path TemporaryDirectory::get_os_temporary_path() { return std::filesystem::temp_directory_path(); } std::filesystem::path TemporaryDirectory::get_unique_temporary_path(const std::filesystem::path& base_path) { if (base_path.empty()) { throw std::invalid_argument("Temporary base path is empty"); } const auto absolute_base_path{std::filesystem::absolute(base_path)}; if (!std::filesystem::exists(absolute_base_path) || !std::filesystem::is_directory(absolute_base_path)) { throw std::invalid_argument("Path " + absolute_base_path.string() + " does not exist or is not a directory"); } //! Build random paths appending random strings of fixed length to base path for (int i = 0; i < 1000; ++i) { auto new_absolute_base_path{absolute_base_path / random_string(10)}; if (!std::filesystem::exists(new_absolute_base_path)) { return new_absolute_base_path; } } //! We were unable to find a valid unique non-existent path throw std::runtime_error("Unable to find a valid unique non-existent path"); } std::filesystem::path TemporaryDirectory::get_unique_temporary_path() { const auto base_path = TemporaryDirectory::get_os_temporary_path(); return TemporaryDirectory::get_unique_temporary_path(base_path); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/directories.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { //! \brief Directory class acts as a wrapper around common functions and properties of a filesystem directory object class Directory { public: //! Creates an instance of a Directory object provided the path //! \param [in] directory_path : the path of the directory //! \param [in] must_create : whether the directory must be created on filesystem should not exist explicit Directory(const std::filesystem::path& directory_path, bool must_create = false); virtual ~Directory() = default; // Not copyable nor movable Directory(const Directory&) = delete; Directory& operator=(const Directory&) = delete; //! \brief Returns whether this Directory exists on filesystem bool exists() const; //! \brief Returns whether this Directory is empty bool is_empty() const; //! \brief Returns the cumulative size of all contained files and subdirectories size_t size() const; //! \brief Returns the std::filesystem::path of this Directory instance const std::filesystem::path& path() const; //! \brief Removes all contained files and subdirectories virtual void clear() const; //! \brief Creates the directory on filesystem should not exist void create(); protected: std::filesystem::path path_; }; //! \brief TemporaryDirectory is a Directory which is automatically deleted on destructor of the instance. //! The full path of the directory starts from a given path plus the discovery of a unique non-existent sub-path //! through a linear search. Should no initial path be given, TemporaryDirectory is built from the path indicated //! for temporary files storage by host OS environment variables class TemporaryDirectory final : public Directory { public: //! \brief Creates an instance of a TemporaryDirectory from a user provided path //! \param [in] base_path : A path where to append this instance to explicit TemporaryDirectory(const std::filesystem::path& base_path) : Directory(TemporaryDirectory::get_unique_temporary_path(base_path), true) {} //! \brief Creates an instance of a TemporaryDirectory from OS temporary path explicit TemporaryDirectory() : Directory(TemporaryDirectory::get_unique_temporary_path(), true) {} ~TemporaryDirectory() final { Directory::clear(); std::filesystem::remove_all(path_); } //! \brief Returns the path to OS provided temporary storage location static std::filesystem::path get_os_temporary_path(); //! \brief Builds a temporary path from OS provided temporary storage location static std::filesystem::path get_unique_temporary_path(); //! \brief Builds a temporary path from user provided temporary storage location static std::filesystem::path get_unique_temporary_path(const std::filesystem::path& base_path); }; //! \brief DataDirectory wraps the directory tree used by Silkworm as base storage path. //! A typical DataDirectory has at least the following subdirs //! //! ├───chaindata <-- Where main database is stored //! ├───temp <-- Where temporary files are stored (e.g. from etl collector) //! ├───nodes <-- Where database(s) for discovered nodes are stored //! └───snapshots <-- Where snapshot files for blocks/transactions/... are stored class DataDirectory final : public Directory { public: //! \brief Creates an instance of Silkworm's data directory given an initial base path //! \param [in] base_path : the actual path of base directory //! \param [in] create : whether the directory itself and the underlying tree should be created explicit DataDirectory(const std::filesystem::path& base_path, bool create = false) : Directory(base_path, create), chaindata_(base_path / "chaindata", create), forks_(base_path / "forks", create), logs_(base_path / "logs", create), nodes_(base_path / "nodes", create), snapshots_(base_path / "snapshots", create), temp_(base_path / "temp", create) {} //! \brief Creates an instance of Silkworm's data directory starting from default storage path. (each host OS has //! its own) //! \param [in] create : whether the directory itself and the underlying tree should be created explicit DataDirectory(bool create = false) : DataDirectory::DataDirectory(DataDirectory::get_default_storage_path(), create) {} //! \brief Creates an instance of Silkworm's data directory given an initial base path //! \param [in] base_path : a char ptr to base path definition //! \param [in] create : whether the directory itself and the underlying tree should be created explicit DataDirectory(const char* base_path, bool create = false) : DataDirectory::DataDirectory(std::filesystem::path(base_path), create) {} ~DataDirectory() final = default; // Not copyable nor movable DataDirectory(const DataDirectory&) = delete; DataDirectory& operator=(const DataDirectory&) = delete; //! \brief Returns an instance of Silkworm's data directory given an initial chaindata path //! \param chaindata_path //! \return a DataDirectory object static DataDirectory from_chaindata(const std::filesystem::path& chaindata_path); //! \brief Returns the path for default storage as defined by host OS environment variable(s) //! \return std::filesystem::path object static std::filesystem::path get_default_storage_path(); //! \brief Deploys the full tree on filesystem (i.e. missing directories are created). //! Etl directory gets also cleared void deploy(); //! \brief DataDirectory can't be cleared void clear() const final { throw std::runtime_error("Can't clear a DataDirectory"); } //! \brief Returns the "chaindata" directory (where chain database is stored) const Directory& chaindata() const { return chaindata_; } //! \brief Returns the "forks" directory (where forks files are stored) const Directory& forks() const { return forks_; } //! \brief Returns the "logs" directory (where log files are stored) const Directory& logs() const { return logs_; } //! \brief Returns the "nodes" directory (where discovery nodes info are stored) const Directory& nodes() const { return nodes_; } //! \brief Returns the "snapshots" directory (where snapshot files are stored) const Directory& snapshots() const { return snapshots_; } //! \brief Returns the "temp" directory (where temporary files are stored) const Directory& temp() const { return temp_; } private: Directory chaindata_; // Database storage Directory forks_; // Fork files Directory logs_; // Log files Directory nodes_; // Nodes discovery databases Directory snapshots_; // Snapshot files Directory temp_; // Temporary etl files }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/directories_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "directories.hpp" #include #include namespace silkworm { TEST_CASE("DataDirectory::deploy") { { // Open and create a storage path TemporaryDirectory tmp_dir0; DataDirectory data_dir(/*base_path=*/tmp_dir0.path(), /*create=*/true); REQUIRE(data_dir.exists()); REQUIRE_NOTHROW(data_dir.deploy()); REQUIRE_THROWS(data_dir.clear()); // Eventually delete the created paths std::filesystem::remove_all(data_dir.path()); REQUIRE(data_dir.exists() == false); } } TEST_CASE("DataDirectory::from_chaindata") { TemporaryDirectory tmp_dir1; std::filesystem::path fake_path{tmp_dir1.path() / "nonexistentpath"}; std::filesystem::path fake_path_root{fake_path.root_path()}; REQUIRE_THROWS((void)DataDirectory::from_chaindata({})); // Can't be empty REQUIRE_THROWS((void)DataDirectory::from_chaindata(fake_path)); // Does not exist REQUIRE_THROWS((void)DataDirectory::from_chaindata(fake_path_root)); // Can't be root REQUIRE_THROWS((void)DataDirectory::from_chaindata(std::filesystem::current_path())); // Can't be current path std::filesystem::create_directories(fake_path); REQUIRE_THROWS((void)DataDirectory::from_chaindata(fake_path)); // Not a valid chaindata path fake_path /= "chaindata"; REQUIRE_THROWS((void)DataDirectory::from_chaindata(fake_path)); // Valid chaindata path but does not exist yet std::filesystem::create_directories(fake_path); REQUIRE_NOTHROW((void)DataDirectory::from_chaindata(fake_path)); // Valid chaindata path and exist { DataDirectory data_dir{DataDirectory::from_chaindata(fake_path)}; REQUIRE_NOTHROW(data_dir.deploy()); REQUIRE(data_dir.temp().is_empty()); // Drop a file into etl temp { std::string filename{data_dir.temp().path().string() + "/fake.txt"}; std::ofstream f(filename.c_str()); f << "Some fake text" << std::flush; f.close(); } std::filesystem::path etl_subpath{data_dir.temp().path() / "subdir"}; std::filesystem::create_directories(etl_subpath); REQUIRE_FALSE(data_dir.temp().is_empty()); REQUIRE(data_dir.temp().size() != 0); data_dir.temp().clear(); REQUIRE(data_dir.temp().is_empty()); } } } // namespace silkworm ================================================ FILE: silkworm/infra/common/ensure.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { //! Ensure that condition is met, otherwise raise a logic error with string literal message template inline void ensure(bool condition, const char (&message)[N]) { if (!condition) [[unlikely]] { throw std::logic_error(message); } } //! Ensure that condition is met, otherwise raise a logic error with dynamically built message //! Usage: `ensure(condition, [&]() { return "Message: " + get_str(); });` inline void ensure(bool condition, const std::function& message_builder) { if (!condition) [[unlikely]] { throw std::logic_error(message_builder()); } } //! Similar to \code ensure with emphasis on invariant violation template inline void ensure_invariant(bool condition, const char (&message)[N]) { if (!condition) [[unlikely]] { throw std::logic_error("Invariant violation: " + std::string{message}); } } //! Similar to \code ensure with emphasis on invariant violation inline void ensure_invariant(bool condition, const std::function& message_builder) { if (!condition) [[unlikely]] { throw std::logic_error("Invariant violation: " + message_builder()); } } //! Similar to \code ensure with emphasis on pre-condition violation inline void ensure_pre_condition(bool condition, const std::function& message_builder) { if (!condition) [[unlikely]] { throw std::invalid_argument("Pre-condition violation: " + message_builder()); } } //! Similar to \code ensure with emphasis on post-condition violation inline void ensure_post_condition(bool condition, const std::function& message_builder) { if (!condition) [[unlikely]] { throw std::logic_error("Post-condition violation: " + message_builder()); } } } // namespace silkworm ================================================ FILE: silkworm/infra/common/ensure_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ensure.hpp" #include #include namespace silkworm { using Catch::Matchers::Message; TEST_CASE("ensure") { CHECK_NOTHROW(ensure(true, "ignored")); CHECK_THROWS_AS(ensure(false, "error"), std::logic_error); CHECK_THROWS_MATCHES(ensure(false, "condition violation"), std::logic_error, Message("condition violation")); } TEST_CASE("ensure dynamic message") { CHECK_NOTHROW(ensure(true, []() { return "ignored"; })); CHECK_THROWS_AS(ensure(false, []() { return "error"; }), std::logic_error); CHECK_THROWS_MATCHES(ensure(false, []() { return "condition violation"; }), std::logic_error, Message("condition violation")); CHECK_THROWS_MATCHES(ensure(false, []() { return "condition violation " + std::to_string(42); }), std::logic_error, Message("condition violation 42")); } TEST_CASE("ensure_invariant") { CHECK_NOTHROW(ensure_invariant(true, "ignored")); CHECK_THROWS_AS(ensure_invariant(false, "error"), std::logic_error); CHECK_THROWS_MATCHES(ensure_invariant(false, "x"), std::logic_error, Message("Invariant violation: x")); } TEST_CASE("ensure_invariant dynamic message") { CHECK_NOTHROW(ensure_invariant(true, []() { return "ignored"; })); CHECK_THROWS_AS(ensure_invariant(false, []() { return "error"; }), std::logic_error); CHECK_THROWS_MATCHES(ensure_invariant(false, []() { return "x"; }), std::logic_error, Message("Invariant violation: x")); CHECK_THROWS_MATCHES(ensure_invariant(false, []() { return "x " + std::to_string(42); }), std::logic_error, Message("Invariant violation: x 42")); } TEST_CASE("ensure_pre_condition") { CHECK_NOTHROW(ensure_pre_condition(true, []() { return "ignored"; })); CHECK_THROWS_AS(ensure_pre_condition(false, []() { return "error"; }), std::logic_error); CHECK_THROWS_MATCHES(ensure_pre_condition(false, []() { return "x"; }), std::logic_error, Message("Pre-condition violation: x")); CHECK_THROWS_MATCHES(ensure_pre_condition(false, []() { return "x " + std::to_string(42); }), std::logic_error, Message("Pre-condition violation: x 42")); } TEST_CASE("ensure_post_condition") { CHECK_NOTHROW(ensure_post_condition(true, []() { return "ignored"; })); CHECK_THROWS_AS(ensure_post_condition(false, []() { return "error"; }), std::logic_error); CHECK_THROWS_MATCHES(ensure_post_condition(false, []() { return "x"; }), std::logic_error, Message("Post-condition violation: x")); CHECK_THROWS_MATCHES(ensure_post_condition(false, []() { return "x " + std::to_string(42); }), std::logic_error, Message("Post-condition violation: x 42")); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/environment.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "environment.hpp" #include namespace silkworm { std::optional Environment::get_stop_at_block() { std::optional target_block; // User can specify to stop downloading process at some block auto environment = boost::this_process::environment(); auto stop_at_block = environment["STOP_AT_BLOCK"]; if (!stop_at_block.empty()) { target_block = std::stoul(stop_at_block.to_string()); } return target_block; } void Environment::set_stop_at_block(BlockNum block_num) { auto environment = boost::this_process::environment(); environment["STOP_AT_BLOCK"] = std::to_string(block_num); } std::optional Environment::get_start_at_stage() { std::optional stage; // User can specify to start staged execution at some stage auto environment = boost::this_process::environment(); auto start_at_stage = environment["START_AT_STAGE"]; if (!start_at_stage.empty()) { stage = start_at_stage.to_string(); } return stage; } void Environment::set_start_at_stage(std::string_view stage_name) { auto environment = boost::this_process::environment(); environment["START_AT_STAGE"] = std::string{stage_name}; } std::optional Environment::get_stop_before_stage() { std::optional stage; // User can specify to stop staged execution before some stage auto environment = boost::this_process::environment(); auto stop_before_stage = environment["STOP_BEFORE_STAGE"]; if (!stop_before_stage.empty()) { stage = stop_before_stage.to_string(); } return stage; } void Environment::set_stop_before_stage(std::string_view stage_name) { auto environment = boost::this_process::environment(); environment["STOP_BEFORE_STAGE"] = std::string{stage_name}; } bool Environment::are_pre_verified_hashes_disabled() { bool disabled = false; // User can specify to not use the pre-verified hashes and do a full header verification auto environment = boost::this_process::environment(); auto env_var = environment["DISABLE_PRE_VERIFIED_HASHES"]; if (!env_var.empty()) { disabled = std::stoul(env_var.to_string()) != 0; } return disabled; } void Environment::set_pre_verified_hashes_disabled() { auto environment = boost::this_process::environment(); environment["DISABLE_PRE_VERIFIED_HASHES"] = "1"; } std::string Environment::get(std::string_view var_name) { auto environment = boost::this_process::environment(); const auto env_var = environment[std::string{var_name}]; return env_var.to_string(); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/environment.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { class Environment { public: static std::optional get_stop_at_block(); static void set_stop_at_block(BlockNum block_num); static std::optional get_start_at_stage(); static void set_start_at_stage(std::string_view stage_name); static std::optional get_stop_before_stage(); static void set_stop_before_stage(std::string_view stage_name); static bool are_pre_verified_hashes_disabled(); static void set_pre_verified_hashes_disabled(); static std::string get(std::string_view var_name); }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/environment_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "environment.hpp" #include namespace silkworm { TEST_CASE("Environment") { SECTION("set/get stop_at_block") { REQUIRE(!Environment::get_stop_at_block().has_value()); Environment::set_stop_at_block(100); REQUIRE(Environment::get_stop_at_block() == 100); } SECTION("set/get stop_before_stage") { REQUIRE(!Environment::get_stop_before_stage().has_value()); Environment::set_stop_before_stage("stage1"); REQUIRE(Environment::get_stop_before_stage() == "stage1"); } SECTION("set/get are_pre_verified_hashes_disabled") { REQUIRE(!Environment::are_pre_verified_hashes_disabled()); Environment::set_pre_verified_hashes_disabled(); REQUIRE(Environment::are_pre_verified_hashes_disabled()); } SECTION("get env var") { CHECK(Environment::get("UNEXISTING_ENV_VAR").empty()); CHECK_FALSE(Environment::get("PATH").empty()); } } } // namespace silkworm ================================================ FILE: silkworm/infra/common/filesystem.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "filesystem.hpp" namespace silkworm { void move_file(const std::filesystem::path& path, const std::filesystem::path& target_dir_path) { std::filesystem::rename(path, target_dir_path / path.filename()); } void move_files(const std::vector& paths, const std::filesystem::path& target_dir_path) { for (const std::filesystem::path& path : paths) { move_file(path, target_dir_path); } } } // namespace silkworm ================================================ FILE: silkworm/infra/common/filesystem.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { void move_file(const std::filesystem::path& path, const std::filesystem::path& target_dir_path); void move_files(const std::vector& paths, const std::filesystem::path& target_dir_path); } // namespace silkworm ================================================ FILE: silkworm/infra/common/log.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::log { //! The fixed size for thread name in log traces static constexpr size_t kThreadNameFixedSize = 11; static Settings settings_{}; static std::mutex out_mtx{}; static std::unique_ptr file_{nullptr}; static bool is_terminal{false}; thread_local std::string thread_name_{}; static std::optional> absl_log_guard; static std::once_flag absl_log_init_once_flag; void init(const Settings& settings) { settings_ = settings; if (!settings_.log_file.empty()) { tee_file(std::filesystem::path(settings.log_file)); // Forcibly disable colorized output to avoid escape char sequences into log file settings_.log_nocolor = true; } absl::SetMinLogLevel(settings.log_grpc ? absl_min_log_level_from_silkworm(settings.log_verbosity) : absl::LogSeverityAtLeast::kInfinity); absl::SetGlobalVLogLevel(settings.log_grpc ? absl_max_vlog_level_from_silkworm(settings.log_verbosity) : -1); absl::SetStderrThreshold(absl::LogSeverityAtLeast::kInfinity); if (settings.log_grpc) { absl_log_guard.emplace(); } else { absl_log_guard = std::nullopt; } std::call_once(absl_log_init_once_flag, absl::InitializeLog); init_terminal(); is_terminal = settings_.log_std_out ? is_terminal_stdout() : is_terminal_stderr(); settings_.log_nocolor = settings_.log_nocolor || !is_terminal; } void tee_file(const std::filesystem::path& path) { file_ = std::make_unique(path.string(), std::ios::out | std::ios::app); if (!file_->is_open()) { file_.reset(); throw std::runtime_error("Could not open file " + path.string()); } } Level get_verbosity() { return settings_.log_verbosity; } void set_verbosity(Level level) { settings_.log_verbosity = level; } bool test_verbosity(Level level) { return level <= settings_.log_verbosity; } //! Set the current thread name resizing it to a fixed size void set_thread_name(const char* name) { thread_name_ = std::string(name); thread_name_.resize(kThreadNameFixedSize, ' '); } std::string get_thread_name() { if (thread_name_.empty()) { std::stringstream ss; ss << std::this_thread::get_id(); thread_name_ = ss.str(); } return thread_name_; } static std::pair get_level_settings(Level level) { switch (level) { case Level::kTrace: return {"TRACE", kColorCoal}; case Level::kDebug: return {"DEBUG", kBackgroundPurple}; case Level::kInfo: return {" INFO", kColorGreen}; case Level::kWarning: return {" WARN", kColorOrangeHigh}; case Level::kError: return {"ERROR", kColorRed}; case Level::kCritical: return {" CRIT", kBackgroundRed}; default: return {" ", kColorReset}; } } struct SeparateThousands : std::numpunct { char separator; explicit SeparateThousands(char sep) : separator(sep) {} char do_thousands_sep() const override { return separator; } string_type do_grouping() const override { return "\3"; } // groups of 3 digit }; void prepare_for_logging(std::ostream& ss) { if (settings_.log_thousands_sep != 0) { ss.imbue(std::locale(ss.getloc(), new SeparateThousands(settings_.log_thousands_sep))); } } BufferBase::BufferBase(Level level) : should_print_(level <= settings_.log_verbosity) { if (!should_print_) return; if (settings_.log_thousands_sep != 0) { ss_.imbue(std::locale(ss_.getloc(), new SeparateThousands(settings_.log_thousands_sep))); } auto [log_level, color] = get_level_settings(level); // Prefix auto log_tag = settings_.log_trim ? absl::StripAsciiWhitespace(log_level).substr(0, 4) : log_level; std::string_view padding = settings_.log_trim ? "" : " "; ss_ << kColorReset << (settings_.log_trim && !is_terminal ? "[" : padding) << color << log_tag << kColorReset << (settings_.log_trim && !is_terminal ? "] " : padding); // TimeStamp static const absl::TimeZone kTz{settings_.log_utc ? absl::UTCTimeZone() : absl::LocalTimeZone()}; absl::Time now{absl::Now()}; auto log_timezone{settings_.log_timezone ? std::string{" "} + kTz.name() : ""}; ss_ << kColorWhite << "[" << absl::FormatTime("%m-%d|%H:%M:%E3S", now, kTz) << log_timezone << "] " << kColorReset; // ThreadId if (settings_.log_threads) { ss_ << "[" << get_thread_name() << "] "; } } BufferBase::BufferBase(Level level, std::string_view msg, const Args& args) : BufferBase(level) { append(msg, args); } void BufferBase::flush() { if (!should_print_) return; // Pattern to identify colorization static const std::regex kColorPattern("(\\\x1b\\[[0-9;]{1,}m)"); bool colorized{true}; std::string line{ss_.str()}; if (settings_.log_nocolor) { line = std::regex_replace(line, kColorPattern, ""); colorized = false; } std::scoped_lock out_lck{out_mtx}; auto& out = settings_.log_std_out ? std::cout : std::cerr; out << line << '\n'; if (file_ && file_->is_open()) { if (colorized) { line = std::regex_replace(line, kColorPattern, ""); } *file_ << line << '\n'; } } } // namespace silkworm::log ================================================ FILE: silkworm/infra/common/log.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::log { //! \brief Available verbosity levels enum class Level { kNone, // Simple logging line with no severity (e.g. build info) kCritical, // An error there's no way we can recover from kError, // We encountered an error which we might be able to recover from kWarning, // Something happened and user might have the possibility to amend the situation kInfo, // Info messages on regular operations kDebug, // Debug information kTrace // Trace calls to functions }; //! \brief Holds logging configuration struct Settings { //! Whether console logging goes to std::cout or std::cerr (default) bool log_std_out{false}; //! Whether timestamps should be in UTC or imbue local timezone bool log_utc{true}; //! Whether timestamps should include the timezone identifier bool log_timezone{true}; //! Whether to disable colorized output bool log_nocolor{false}; //! Whether to trim log level bool log_trim{false}; //! Whether to print thread ids in log lines bool log_threads{false}; //! Log verbosity level Level log_verbosity{Level::kNone}; //! Log to file std::string log_file; //! Thousands separator char log_thousands_sep{'\''}; //! Include GRPC library internal logs bool log_grpc{true}; }; //! \brief Initializes logging facilities //! \note This function is not thread safe as it's meant to be used at start of process and never called again void init(const Settings& settings = {}); //! \brief Get the current logging verbosity //! \note This function is not thread safe as it's meant to be used in tests Level get_verbosity(); //! \brief Sets logging verbosity //! \note This function is not thread safe as it's meant to be used at start of process and never called again void set_verbosity(Level level); //! \brief Sets the name for this thread when logging traces also threads void set_thread_name(const char* name); //! \brief Returns the currently set name for the thread or the thread id std::string get_thread_name(); //! \brief Checks if provided log level will be effectively printed on behalf of current settings //! \return True / False //! \remarks Some logging operations may implement computations which would be completely wasted if the outcome is not //! printed bool test_verbosity(Level level); //! \brief Sets a file output for log teeing //! \note This function is not thread safe as it's meant to be used at start of process and never called again void tee_file(const std::filesystem::path& path); void prepare_for_logging(std::ostream&); using Args = std::vector; class BufferBase { public: explicit BufferBase(Level level); explicit BufferBase(Level level, std::string_view msg, const Args& args); ~BufferBase() { flush(); } // Accumulators template void append(const T& t) { if (should_print_) ss_ << t; } template BufferBase& operator<<(const T& t) { append(t); return *this; } void append(const Args& args) { append("", args); } BufferBase& operator<<(const Args& args) { append(args); return *this; } protected: void append(std::string_view msg, const Args& args) { if (!should_print_) return; ss_ << std::left << std::setw(41) << std::setfill(' ') << msg; bool left{true}; for (const auto& arg : args) { ss_ << (left ? kColorGreen : kColorWhite) << arg << kColorReset << (left ? "=" : " ") << kColorReset; left = !left; } } void flush(); const bool should_print_; std::stringstream ss_; }; template class LogBuffer : public BufferBase { public: explicit LogBuffer() : BufferBase(level) {} explicit LogBuffer(std::string_view msg, const Args& args = {}) : BufferBase(level, msg, args) {} }; using Trace = LogBuffer; using Debug = LogBuffer; using Info = LogBuffer; using Warning = LogBuffer; using Error = LogBuffer; using Critical = LogBuffer; using Message = LogBuffer; } // namespace silkworm::log #define SILK_LOGBUFFER(level_, ...) \ if (!silkworm::log::test_verbosity(level_)) { \ } else \ silkworm::log::LogBuffer(__VA_ARGS__) #define SILK_TRACE_M(...) SILK_LOGBUFFER(silkworm::log::Level::kTrace, __VA_ARGS__) #define SILK_DEBUG_M(...) SILK_LOGBUFFER(silkworm::log::Level::kDebug, __VA_ARGS__) #define SILK_INFO_M(...) SILK_LOGBUFFER(silkworm::log::Level::kInfo, __VA_ARGS__) #define SILK_WARN_M(...) SILK_LOGBUFFER(silkworm::log::Level::kWarning, __VA_ARGS__) #define SILK_ERROR_M(...) SILK_LOGBUFFER(silkworm::log::Level::kError, __VA_ARGS__) #define SILK_CRIT_M(...) SILK_LOGBUFFER(silkworm::log::Level::kCritical, __VA_ARGS__) #define SILK_LOG_M(...) SILK_LOGBUFFER(silkworm::log::Level::kNone, __VA_ARGS__) #define SILK_TRACE SILK_TRACE_M() #define SILK_DEBUG SILK_DEBUG_M() #define SILK_INFO SILK_INFO_M() #define SILK_WARN SILK_WARN_M() #define SILK_ERROR SILK_ERROR_M() #define SILK_CRIT SILK_CRIT_M() #define SILK_LOG SILK_LOG_M() ================================================ FILE: silkworm/infra/common/log_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include #include #include #include #include namespace silkworm::log { //! Custom LogBuffer just for testing to access buffered content template class LogBufferForTest : public LogBuffer { public: explicit LogBufferForTest() : LogBuffer() {} explicit LogBufferForTest(std::string_view msg, const Args& args) : LogBuffer(msg, args) {} std::string content() const { return LogBuffer::ss_.str(); } }; //! Utility test function enforcing that log buffered content *IS* empty template void check_log_empty() { auto log_buffer = LogBufferForTest(); log_buffer << "test"; CHECK(log_buffer.content().empty()); } //! Utility test function enforcing that log buffered content *IS NOT* empty template void check_log_not_empty() { auto log_buffer = LogBufferForTest(); log_buffer << "test"; CHECK(absl::StrContains(log_buffer.content(), "test")); } //! Build the plain key-value pair static std::string key_value(const std::string& key, const std::string& value) { std::string kv_pair{key}; kv_pair.append("="); kv_pair.append(value); return kv_pair; } //! Build the prettified key-value pair using color scheme static std::string prettified_key_value(const std::string& key, const std::string& value) { std::string kv_pair{kColorGreen}; kv_pair.append(key); kv_pair.append(kColorReset); kv_pair.append("="); kv_pair.append(kColorReset); kv_pair.append(kColorWhite); kv_pair.append(value); return kv_pair; } TEST_CASE("LogBuffer", "[silkworm][common][log]") { // After the test restore verbosity as it was before the test test_util::SetLogVerbosityGuard log_guard{get_verbosity()}; // Temporarily override std::cout and std::cerr with string streams to avoid terminal output std::stringstream string_cout, string_cerr; test_util::StreamSwap cout_swap{std::cout, string_cout}; test_util::StreamSwap cerr_swap{std::cerr, string_cerr}; // Make sure logging facility is initialized Settings settings{.log_verbosity = Level::kInfo}; init(settings); SECTION("LogBuffer stores nothing for verbosity higher than default") { check_log_empty(); check_log_empty(); } SECTION("LogBuffer stores content for verbosity lower than or equal to default") { check_log_not_empty(); check_log_not_empty(); check_log_not_empty(); check_log_not_empty(); check_log_not_empty(); } SECTION("LogBuffer stores nothing for verbosity higher than configured one") { test_util::SetLogVerbosityGuard guard{Level::kWarning}; check_log_empty(); check_log_empty(); check_log_empty(); } SECTION("LogBuffer stores content for verbosity lower than or equal to configured one") { test_util::SetLogVerbosityGuard guard{Level::kWarning}; check_log_not_empty(); check_log_not_empty(); check_log_not_empty(); check_log_not_empty(); } SECTION("Settings enable/disable thread tracing") { // Default thread tracing std::stringstream thread_id_stream; thread_id_stream << std::this_thread::get_id(); auto log_buffer1 = LogBufferForTest(); log_buffer1 << "test"; CHECK(!absl::StrContains(log_buffer1.content(), thread_id_stream.str())); // Enable thread tracing Settings log_settings{.log_verbosity = Level::kInfo}; log_settings.log_threads = true; init(log_settings); auto log_buffer2 = LogBufferForTest(); log_buffer2 << "test"; CHECK(absl::StrContains(log_buffer2.content(), thread_id_stream.str())); // Disable thread tracing log_settings.log_threads = false; init(log_settings); auto log_buffer3 = LogBufferForTest(); log_buffer3 << "test"; CHECK(!absl::StrContains(log_buffer3.content(), thread_id_stream.str())); } SECTION("Settings disables colorized output depending on TTY") { const bool is_terminal = is_terminal_stdout() && is_terminal_stderr(); // Default output is NOT colorized on non-TTY terminal LogBufferForTest{"test0", {"key1", "value1", "key2", "value2"}}; // temporary log object, flush on dtor const auto cerr_output0{string_cerr.str()}; CHECK(absl::StrContains(cerr_output0, "test0")); CHECK(absl::StrContains(cerr_output0, key_value("key1", "value1")) == !is_terminal); CHECK(absl::StrContains(cerr_output0, key_value("key2", "value2")) == !is_terminal); CHECK(absl::StrContains(cerr_output0, prettified_key_value("key1", "value1")) == is_terminal); CHECK(absl::StrContains(cerr_output0, prettified_key_value("key2", "value2")) == is_terminal); // Reset cerr replacement stream string_cerr.str(""); string_cerr.clear(); // Log file setting forcibly disables colors even if explicitly set Settings log_settings2{ .log_nocolor = false, // try to enable colorized output .log_verbosity = Level::kInfo, }; init(log_settings2); LogBufferForTest{"test2", {"key3", "value3", "key4", "value4"}}; // temporary log object, flush on dtor const auto cerr_output2{string_cerr.str()}; CHECK(absl::StrContains(cerr_output2, "test2")); CHECK(absl::StrContains(cerr_output2, key_value("key3", "value3")) == !is_terminal); CHECK(absl::StrContains(cerr_output2, key_value("key4", "value4")) == !is_terminal); CHECK(absl::StrContains(cerr_output2, prettified_key_value("key3", "value3")) == is_terminal); CHECK(absl::StrContains(cerr_output2, prettified_key_value("key4", "value4")) == is_terminal); } SECTION("Settings disable colorized output if log file present") { const auto temp_file{TemporaryDirectory::get_unique_temporary_path()}; // Log file setting forcibly disables colors even if explicitly set Settings log_settings2{ .log_nocolor = false, // try to enable colorized output .log_verbosity = Level::kInfo, .log_file = temp_file.string(), }; init(log_settings2); LogBufferForTest{"test2", {"key3", "value3", "key4", "value4"}}; // temporary log object, flush on dtor const auto cerr_output2{string_cerr.str()}; CHECK(absl::StrContains(cerr_output2, "test2")); CHECK(absl::StrContains(cerr_output2, key_value("key3", "value3"))); CHECK(absl::StrContains(cerr_output2, key_value("key4", "value4"))); CHECK(!absl::StrContains(cerr_output2, prettified_key_value("key3", "value3"))); CHECK(!absl::StrContains(cerr_output2, prettified_key_value("key4", "value4"))); } SECTION("Variable arguments: constructor") { auto log_buffer = LogBufferForTest("test", {"key1", "value1", "key2", "value2"}); CHECK(absl::StrContains(log_buffer.content(), "test")); CHECK(absl::StrContains(log_buffer.content(), prettified_key_value("key1", "value1"))); CHECK(absl::StrContains(log_buffer.content(), prettified_key_value("key2", "value2"))); } SECTION("Variable arguments: accumulators") { auto log_buffer = LogBufferForTest(); log_buffer << "test" << Args{"key1", "value1", "key2", "value2"}; CHECK(absl::StrContains(log_buffer.content(), "test")); CHECK(absl::StrContains(log_buffer.content(), prettified_key_value("key1", "value1"))); CHECK(absl::StrContains(log_buffer.content(), prettified_key_value("key2", "value2"))); } } #ifdef SILKWORM_TEST_SKIP TEST_CASE("SILK_LOGBUFFER", "[silkworm][common][log]") { Settings settings{.log_verbosity = Level::kTrace}; init(settings); log::Trace() << "hello using log::Trace"; log::Debug() << "hello using log::Debug"; log::Info() << "hello using log::Info"; log::Warning() << "hello using log::Warning"; log::Error() << "hello using log::Error"; log::Critical() << "hello using log::Critical"; log::Message() << "hello using log::Message"; log::Trace("log_test") << "hello using log::Trace(\"log_test\")"; log::Debug("log_test") << "hello using log::Debug(\"log_test\")"; log::Info("log_test") << "hello using log::Info(\"log_test\")"; log::Warning("log_test") << "hello using log::Warning(\"log_test\")"; log::Error("log_test") << "hello using log::Error(\"log_test\")"; log::Critical("log_test") << "hello using log::Critical(\"log_test\")"; log::Message("log_test") << "hello using log::Message(\"log_test\")"; SILK_TRACE << "hello using SILK_TRACE"; SILK_DEBUG << "hello using SILK_DEBUG"; SILK_INFO << "hello using SILK_INFO"; SILK_WARN << "hello using SILK_WARN"; SILK_ERROR << "hello using SILK_ERROR"; SILK_CRIT << "hello using SILK_CRIT"; SILK_LOG << "hello using SILK_LOG"; SILK_TRACE_M("log_test") << "hello using SILK_TRACE_M(\"log_test\")"; SILK_DEBUG_M("log_test") << "hello using SILK_DEBUG_M(\"log_test\")"; SILK_INFO_M("log_test") << "hello using SILK_INFO_M(\"log_test\")"; SILK_WARN_M("log_test") << "hello using SILK_WARN_M(\"log_test\")"; SILK_ERROR_M("log_test") << "hello using SILK_ERROR_M(\"log_test\")"; SILK_CRIT_M("log_test") << "hello using SILK_CRIT_M(\"log_test\")"; SILK_LOG_M("log_test") << "hello using SILK_LOG_M(\"log_test\")"; } #endif // SILKWORM_TEST_SKIP } // namespace silkworm::log ================================================ FILE: silkworm/infra/common/measure.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { template class Measure { public: using TimePoint = std::chrono::time_point; using Duration = std::chrono::nanoseconds; Measure() = default; explicit Measure(T value) { set(value); } T get() { return value_; } void set(T value) { value_ = value; timestamp_ = std::chrono::high_resolution_clock::now(); } TimePoint time() { return timestamp_; } private: T value_ = {}; TimePoint timestamp_; }; template class RepeatedMeasure { Measure prev_value_; Measure curr_value_; public: using TimePoint = typename Measure::TimePoint; using Duration = typename Measure::Duration; RepeatedMeasure() = default; explicit RepeatedMeasure(T value) { set(value); } T get() { return curr_value_.get(); } void set(T value) { prev_value_ = curr_value_; curr_value_.set(value); } T delta() { return curr_value_.get() - prev_value_.get(); } Duration high_res_elapsed() { using namespace std::chrono; return duration_cast(curr_value_.time() - prev_value_.time()); } double high_res_throughput() { auto nano_elapsed = static_cast(high_res_elapsed().count()); if (nano_elapsed == 0) nano_elapsed = 1; return static_cast(delta()) / static_cast(nano_elapsed); } template double high_res_throughput() { auto nano_elapsed = static_cast(high_res_elapsed().count()); if (nano_elapsed == 0) nano_elapsed = 1; using conversion = std::ratio_divide; auto res_num = static_cast(delta()) * static_cast(conversion::den); auto res_den = static_cast(nano_elapsed) * static_cast(conversion::num); return res_num / res_den; } std::chrono::seconds elapsed() { using namespace std::chrono; return duration_cast(curr_value_.time() - prev_value_.time()); } auto throughput() { auto secs_elapsed = static_cast(elapsed().count()); if (secs_elapsed == 0) secs_elapsed = 1; return delta() / secs_elapsed; } }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/mem_usage.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "mem_usage.hpp" #include #ifdef __linux__ #include #include #endif #ifdef __APPLE__ #include #include #endif #ifdef _WINDOWS // clang-format off #include #include // clang-format on #endif namespace silkworm::os { // Inspired by: https://stackoverflow.com/questions/372484/how-do-i-programmatically-check-memory-use-in-a-fairly-portable-way-c-c // The amount of memory currently being used by this process, in bytes. // if resident=true it will report the resident set in RAM (if supported on that OS) // otherwise returns the full virtual arena size_t get_mem_usage(bool resident) { #if defined(__linux__) // getrusage doesn't work well on Linux. Try grabbing info directly from the /proc pseudo-filesystem. // Reading from /proc/self/statm gives info on your own process, as one line of numbers that are: // virtual mem program size, resident set size, shared pages, text/code, data/stack, library, dirty pages. // The mem sizes should all be multiplied by the page size. size_t vm_size = 0, rm_size = 0; FILE* file = fopen("/proc/self/statm", "r"); if (file) { size_t vm = 0, rm = 0; // NOLINTNEXTLINE(cert-err34-c) if (fscanf(file, "%zu %zu", &vm, &rm) == 2) { // the first 2 num: vm size, resident set size vm_size = vm * static_cast(getpagesize()); rm_size = rm * static_cast(getpagesize()); } (void)fclose(file); } return (resident ? rm_size : vm_size); #elif defined(__APPLE__) // Inspired by: http://miknight.blogspot.com/2005/11/resident-set-size-in-mac-os-x.html struct task_basic_info t_info {}; mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT; task_info(current_task(), TASK_BASIC_INFO, reinterpret_cast(&t_info), &t_info_count); size_t size = (resident ? t_info.resident_size : t_info.virtual_size); return size; #elif defined(_WINDOWS) static HANDLE phandle{GetCurrentProcess()}; PROCESS_MEMORY_COUNTERS_EX counters; if (K32GetProcessMemoryInfo(phandle, (PROCESS_MEMORY_COUNTERS*)&counters, sizeof(counters))) { return (resident ? counters.WorkingSetSize : counters.PagefileUsage); } #else // Unsupported platform (void)resident; // disable unused-parameter warning return 0; #endif } } // namespace silkworm::os ================================================ FILE: silkworm/infra/common/mem_usage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::os { size_t get_mem_usage(bool resident = true); } ================================================ FILE: silkworm/infra/common/memory_mapped_file.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "memory_mapped_file.hpp" #ifdef _WIN32 #include #else #include #include #include #include #endif #include #include #include #include "ensure.hpp" #include "safe_strerror.hpp" namespace silkworm { MemoryMappedFile::MemoryMappedFile(std::filesystem::path path, std::optional region, bool read_only) : path_(std::move(path)), managed_{!region.has_value()} { ensure(std::filesystem::exists(path_), [&]() { return "MemoryMappedFile: " + path_.string() + " does not exist"; }); ensure(std::filesystem::is_regular_file(path_), [&]() { return "MemoryMappedFile: " + path_.string() + " is not regular file"; }); if (region) { ensure(region->data() != nullptr, "MemoryMappedFile: address is null"); ensure(!region->empty(), "MemoryMappedFile: length is zero"); region_ = *region; } else { map_existing(read_only); } } MemoryMappedFile::~MemoryMappedFile() { close(); } #ifdef _WIN32 void MemoryMappedFile::map_existing(bool read_only) { DWORD desired_access = read_only ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE); DWORD shared_mode = FILE_SHARE_READ | FILE_SHARE_WRITE; FileDescriptor fd = {}; fd = ::CreateFile( path_.string().c_str(), desired_access, shared_mode, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); if (INVALID_HANDLE_VALUE == fd) { throw std::runtime_error{"Failed to create existing file: " + path_.string() + " error: " + std::to_string(GetLastError())}; } [[maybe_unused]] auto _ = gsl::finally([fd]() { if (INVALID_HANDLE_VALUE != fd) ::CloseHandle(fd); }); auto size = std::filesystem::file_size(path_); auto address = static_cast(mmap(fd, size, read_only)); region_ = {address, size}; fd = INVALID_HANDLE_VALUE; } void MemoryMappedFile::advise_normal() const { } void MemoryMappedFile::advise_random() const { } void MemoryMappedFile::advise_sequential() const { } void MemoryMappedFile::advise(int /*advice*/) const { } void* MemoryMappedFile::mmap(FileDescriptor fd, size_t size, bool read_only) { DWORD protection = static_cast(read_only ? PAGE_READONLY : PAGE_READWRITE); mapping_ = ::CreateFileMapping(fd, nullptr, protection, 0, 0, nullptr); // note: no size specified to avoid MapViewOfFile failure if (nullptr == mapping_) { throw std::runtime_error{"CreateFileMapping failed for: " + path_.string() + " error: " + std::to_string(GetLastError())}; } DWORD desired_access = static_cast(read_only ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS); void* memory = (LPTSTR)::MapViewOfFile(mapping_, desired_access, 0, static_cast(0), size); if (memory == nullptr) { throw std::runtime_error{"MapViewOfFile failed for: " + path_.string() + " error: " + std::to_string(GetLastError())}; } return static_cast(memory); } void MemoryMappedFile::unmap() { if (region_.data() != nullptr) { ::UnmapViewOfFile(region_.data()); } } void MemoryMappedFile::close() { if (!managed_) return; if (region_.data()) { unmap(); region_ = {}; managed_ = false; } if (mapping_) { ::CloseHandle(mapping_); mapping_ = nullptr; } if (file_) { ::CloseHandle(file_); file_ = nullptr; } } #else // !_WIN32 void MemoryMappedFile::map_existing(bool read_only) { FileDescriptor fd = ::open(path_.c_str(), read_only ? O_RDONLY : O_RDWR); if (fd == -1) { throw std::runtime_error{"open failed for: " + path_.string() + " error: " + safe_strerror(errno)}; } [[maybe_unused]] auto _ = gsl::finally([fd]() { ::close(fd); }); auto size = std::filesystem::file_size(path_); auto address = static_cast(mmap(fd, size, read_only)); region_ = {address, size}; } void MemoryMappedFile::close() { if (!managed_) return; if (region_.data()) { unmap(); region_ = {}; managed_ = false; } } void MemoryMappedFile::advise_normal() const { advise(MADV_NORMAL); } void MemoryMappedFile::advise_random() const { advise(MADV_RANDOM); } void MemoryMappedFile::advise_sequential() const { advise(MADV_SEQUENTIAL); } void* MemoryMappedFile::mmap(FileDescriptor fd, size_t size, bool read_only) { int flags = MAP_SHARED; const auto address = ::mmap(nullptr, size, read_only ? PROT_READ : (PROT_READ | PROT_WRITE), flags, fd, 0); if (address == MAP_FAILED) { throw std::runtime_error{"mmap failed for: " + path_.string() + " error: " + safe_strerror(errno)}; } return address; } void MemoryMappedFile::unmap() { if (region_.data() != nullptr) { const int result = ::munmap(region_.data(), region_.size()); if (result == -1) { throw std::runtime_error{"munmap failed for: " + path_.string() + " error: " + safe_strerror(errno)}; } } } void MemoryMappedFile::advise(int advice) const { const int result = ::madvise(region_.data(), region_.size(), advice); if (result == -1) { // Ignore not implemented in kernel error because it still works (from Erigon) if (errno != ENOSYS) { throw std::runtime_error{"madvise failed for: " + path_.string() + " error: " + safe_strerror(errno)}; } } } #endif // _WIN32 } // namespace silkworm ================================================ FILE: silkworm/infra/common/memory_mapped_file.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // Portions of the following code and inspiration are taken from Aeron [https://github.com/real-logic/aeron] /* * Copyright 2014-2022 Real Logic Limited. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #ifdef _WIN32 #pragma warning(disable : 4668) #pragma warning(disable : 4710) #pragma warning(disable : 4820) #pragma warning(disable : 5039) #endif #include #include #include #include #include #include #include #include #include #include #ifndef _WIN32 #include #include #include #include #include #include #endif namespace silkworm { #ifdef _WIN32 typedef void* HANDLE; using FileDescriptor = HANDLE; #else using FileDescriptor = int; #endif using MemoryMappedRegion = std::span; class MemoryMappedFile { public: explicit MemoryMappedFile(std::filesystem::path path, std::optional region = {}, bool read_only = true); ~MemoryMappedFile(); // Not copyable MemoryMappedFile(const MemoryMappedFile&) = delete; MemoryMappedFile& operator=(const MemoryMappedFile&) = delete; // Only movable MemoryMappedFile(MemoryMappedFile&& other) noexcept : path_{std::move(other.path_)}, region_{std::exchange(other.region_, {})}, #ifdef _WIN32 file_{std::exchange(other.file_, nullptr)}, mapping_{std::exchange(other.mapping_, nullptr)}, #endif managed_{std::exchange(other.managed_, false)} { } MemoryMappedFile& operator=(MemoryMappedFile&& other) noexcept { path_ = std::move(other.path_); region_ = std::exchange(other.region_, {}); #ifdef _WIN32 file_ = std::exchange(other.file_, nullptr); mapping_ = std::exchange(other.mapping_, nullptr); #endif managed_ = std::exchange(other.managed_, false); return *this; } std::filesystem::path path() const { return path_; } MemoryMappedRegion region() const { return region_; } size_t size() const { return region_.size(); } std::filesystem::file_time_type last_write_time() const { return std::filesystem::last_write_time(path_); } void advise_normal() const; void advise_random() const; void advise_sequential() const; private: void map_existing(bool read_only); void close(); void* mmap(FileDescriptor fd, size_t size, bool read_only); void unmap(); void advise(int advice) const; //! The path to the file std::filesystem::path path_; //! The area mapped in memory MemoryMappedRegion region_; #ifdef _WIN32 HANDLE file_ = nullptr; HANDLE mapping_ = nullptr; #endif //! Flag indicating if memory-mapping is managed internally or not bool managed_; }; struct MemoryMappedStreamBuf : std::streambuf { explicit MemoryMappedStreamBuf(MemoryMappedRegion region) { auto p = reinterpret_cast(region.data()); this->setg(p, p, p + region.size()); } }; struct MemoryMappedInputStream : virtual MemoryMappedStreamBuf, std::istream { explicit MemoryMappedInputStream(MemoryMappedRegion region) : MemoryMappedStreamBuf(region), std::istream(static_cast(this)) {} }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/memory_mapped_file_benchmark.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include "memory_mapped_file.hpp" static constexpr uint64_t k4MiBFileSize{4u * silkworm::kMebi}; static std::filesystem::path create_random_temporary_file(int64_t file_size) { auto tmp_file = silkworm::TemporaryDirectory::get_unique_temporary_path(); std::ofstream tmp_stream{tmp_file, std::ios_base::binary}; silkworm::RandomNumber rnd{0, 255}; for (int64_t i{0u}; i < file_size; ++i) { const auto random_number = static_cast(rnd.generate_one()); tmp_stream.write(&random_number, sizeof(char)); } tmp_stream.close(); return tmp_file; } static void benchmark_checksum_ifstream(benchmark::State& state) { constexpr int kPageSize{1024 * 4}; const auto tmp_file_path = create_random_temporary_file(state.range(0)); for ([[maybe_unused]] auto _ : state) { std::unique_ptr buffer{new char[static_cast(kPageSize)]}; std::ifstream snapshot_stream{tmp_file_path, std::ifstream::binary}; int checksum{0}; size_t count{0}; while (snapshot_stream) { snapshot_stream.read(buffer.get(), kPageSize); for (size_t i{0}; std::cmp_less(i, snapshot_stream.gcount()); ++i, ++count) { const auto byte{static_cast(buffer[i])}; checksum += byte; } } benchmark::DoNotOptimize(checksum); } } BENCHMARK(benchmark_checksum_ifstream)->Arg(k4MiBFileSize); static void benchmark_checksum_memory_mapped_file(benchmark::State& state) { const auto tmp_file_path = create_random_temporary_file(state.range(0)); for ([[maybe_unused]] auto _ : state) { silkworm::MemoryMappedFile mapped_file{tmp_file_path}; mapped_file.advise_sequential(); int checksum{0}; for (auto byte : mapped_file.region()) { checksum += byte; } benchmark::DoNotOptimize(checksum); } } BENCHMARK(benchmark_checksum_memory_mapped_file)->Arg(k4MiBFileSize); ================================================ FILE: silkworm/infra/common/memory_mapped_file_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "memory_mapped_file.hpp" #include #include #include #include #include namespace silkworm { using namespace std::chrono_literals; TEST_CASE("MemoryMappedFile from file", "[silkworm][infra][common][memory_mapped_file]") { SECTION("constructor fails for nonexistent file") { CHECK_THROWS_AS(MemoryMappedFile{"nonexistent.txt"}, std::logic_error); } SECTION("constructor fails for existent empty file") { const auto tmp_file = TemporaryDirectory::get_unique_temporary_path(); std::ofstream tmp_stream{tmp_file, std::ios_base::binary}; tmp_stream.close(); CHECK_THROWS_AS(MemoryMappedFile{tmp_file}, std::runtime_error); } SECTION("constructor succeeds for existent nonempty file") { const auto tmp_file = TemporaryDirectory::get_unique_temporary_path(); std::ofstream tmp_stream{tmp_file, std::ios_base::binary}; tmp_stream.write("\x01", 1); tmp_stream.close(); CHECK_NOTHROW(MemoryMappedFile{tmp_file}); CHECK_NOTHROW(MemoryMappedFile{tmp_file, {}, false}); CHECK_NOTHROW(MemoryMappedFile{tmp_file.string()}); CHECK_NOTHROW(MemoryMappedFile{tmp_file.string(), {}, false}); } const std::string file_content{"\x01\x02\x03"}; const auto tmp_file = TemporaryDirectory::get_unique_temporary_path(); std::ofstream tmp_stream{tmp_file, std::ios_base::binary}; tmp_stream.write(file_content.data(), static_cast(file_content.size())); tmp_stream.close(); MemoryMappedFile mmf{tmp_file}; SECTION("has expected memory address and size") { CHECK(mmf.region().data() != nullptr); CHECK(mmf.size() == file_content.size()); } SECTION("has expected content") { const auto data{mmf.region().data()}; CHECK(data[0] == '\x01'); CHECK(data[1] == '\x02'); CHECK(data[2] == '\x03'); } SECTION("advise_sequential") { CHECK_NOTHROW(mmf.advise_sequential()); } SECTION("advise_random") { CHECK_NOTHROW(mmf.advise_random()); } SECTION("input stream") { MemoryMappedInputStream mmis{mmf.region()}; std::string s; mmis >> s; CHECK(s == file_content); } SECTION("last_write_time") { const auto tmp_path = std::filesystem::temp_directory_path() / "example.bin"; std::ofstream{tmp_path.c_str()}.put('a'); MemoryMappedFile mm_file{tmp_path}; const auto ftime = mm_file.last_write_time(); // Move file write time 1 hour to the future std::filesystem::last_write_time(tmp_path, ftime + 1h); const auto new_ftime = mm_file.last_write_time(); CHECK((new_ftime > ftime)); std::filesystem::remove(tmp_path); } } TEST_CASE("MemoryMappedFile from memory", "[silkworm][infra][common][memory_mapped_file]") { SECTION("constructor fails for null address") { CHECK_THROWS_AS(MemoryMappedFile("", MemoryMappedRegion{}), std::logic_error); } SECTION("constructor fails for zero length") { uint8_t u{0}; CHECK_THROWS_AS(MemoryMappedFile("", MemoryMappedRegion{&u, 0}), std::logic_error); } SECTION("constructor succeeds for existent nonempty file") { const auto tmp_file = TemporaryDirectory::get_unique_temporary_path(); std::ofstream tmp_stream{tmp_file, std::ios_base::binary}; tmp_stream.write("\x01", 1); tmp_stream.close(); MemoryMappedFile mmf_from_file{tmp_file}; CHECK_NOTHROW(MemoryMappedFile(tmp_file, mmf_from_file.region())); } const std::string file_content{"\x01\x02\x03"}; const auto tmp_file = TemporaryDirectory::get_unique_temporary_path(); std::ofstream tmp_stream{tmp_file, std::ios_base::binary}; tmp_stream.write(file_content.data(), static_cast(file_content.size())); tmp_stream.close(); MemoryMappedFile mmf_from_file{tmp_file}; const auto region{mmf_from_file.region()}; MemoryMappedFile mmf{tmp_file, mmf_from_file.region()}; SECTION("has expected memory address and size") { CHECK(mmf.region().data() == region.data()); CHECK(mmf.region().size() == region.size()); } SECTION("has expected content") { const auto data{mmf.region().data()}; CHECK(data[0] == '\x01'); CHECK(data[1] == '\x02'); CHECK(data[2] == '\x03'); } SECTION("advise_sequential") { CHECK_NOTHROW(mmf.advise_sequential()); } SECTION("advise_random") { CHECK_NOTHROW(mmf.advise_random()); } SECTION("input stream") { MemoryMappedInputStream mmis{mmf.region()}; std::string s; mmis >> s; CHECK(s == file_content); } SECTION("last_write_time") { const auto tmp_path = std::filesystem::temp_directory_path() / "example.bin"; std::ofstream{tmp_path.c_str()}.put('a'); MemoryMappedFile mmf_from_path{tmp_path}; MemoryMappedFile mmf_from_memory{tmp_path, mmf_from_file.region()}; const auto ftime = mmf_from_memory.last_write_time(); // Move file write time 1 hour to the future std::filesystem::last_write_time(tmp_path, ftime + 1h); const auto new_ftime = mmf_from_memory.last_write_time(); CHECK((new_ftime > ftime)); std::filesystem::remove(tmp_path); } } } // namespace silkworm ================================================ FILE: silkworm/infra/common/os.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "os.hpp" #if defined(__linux__) || defined(__APPLE__) #include #include #elif defined(_WIN32) #include #include #include #else #pragma message("unsupported platform detected in test/os.cpp") #endif namespace silkworm::os { uint64_t max_file_descriptors() { uint64_t max_descriptors{0}; #if defined(__linux__) || defined(__APPLE__) // Get the current limit rlimit limit{}; const auto result = getrlimit(RLIMIT_NOFILE, &limit); if (result == -1) return 0; // Current max descriptors is *soft* limit (hard limit is max value of soft limit) max_descriptors = limit.rlim_cur; #elif defined(_WIN32) max_descriptors = _getmaxstdio(); #endif return max_descriptors; } bool set_max_file_descriptors(uint64_t max_descriptors) { #if defined(__linux__) || defined(__APPLE__) // Get the current limit rlimit limit{}; const auto get_result = getrlimit(RLIMIT_NOFILE, &limit); if (get_result == -1) return false; // Try to update the *soft* limit (not over the hard limit i.e. max allowance) limit.rlim_cur = max_descriptors < limit.rlim_max ? max_descriptors : limit.rlim_max; const auto set_result = setrlimit(RLIMIT_NOFILE, &limit); return set_result == 0; #elif defined(_WIN32) // Hard limit is hard-coded on Windows static constexpr int kMaxNumFiles = 8'192; // Try to update the *soft* limit (not over the hard limit i.e. max allowance) const int num_max_descriptors = max_descriptors < kMaxNumFiles ? static_cast(max_descriptors) : kMaxNumFiles; const int result = _setmaxstdio(num_max_descriptors); return result == num_max_descriptors; #else (void)max_descriptors; return false; #endif } size_t page_size() noexcept { static auto system_page_size = []() -> size_t { #ifdef _WIN32 SYSTEM_INFO system_info; ::GetSystemInfo(&system_info); return static_cast(system_info.dwPageSize); #else return static_cast(::getpagesize()); #endif // _WIN32 }(); return system_page_size; } } // namespace silkworm::os ================================================ FILE: silkworm/infra/common/os.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include //! Low-level OS utilities namespace silkworm::os { uint64_t max_file_descriptors(); bool set_max_file_descriptors(uint64_t max_descriptors); size_t page_size() noexcept; } // namespace silkworm::os ================================================ FILE: silkworm/infra/common/os_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "os.hpp" #include namespace silkworm::os { TEST_CASE("os::max_file_descriptors", "[silkworm][infra][common][os]") { const auto current_max_descriptors = max_file_descriptors(); CHECK(current_max_descriptors > 0); } TEST_CASE("os::set_max_file_descriptors", "[silkworm][infra][common][os]") { const auto current_max_descriptors = max_file_descriptors(); CHECK(set_max_file_descriptors(current_max_descriptors - 1)); } TEST_CASE("os::page_size", "[silkworm][infra][common][os]") { CHECK(page_size() >= 4096); } } // namespace silkworm::os ================================================ FILE: silkworm/infra/common/safe_strerror.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "safe_strerror.hpp" #include namespace silkworm { std::string safe_strerror(int err_code) { char msg[256]; #if defined(_WIN32) if (strerror_s(msg, sizeof(msg), err_code) != 0) { (void)strncpy_s(msg, "Unknown error", _TRUNCATE); } #else if (strerror_r(err_code, msg, sizeof(msg))) { (void)strncpy(msg, "Unknown error", sizeof(msg)); } #endif msg[sizeof(msg) - 1] = '\0'; return {msg}; } } // namespace silkworm ================================================ FILE: silkworm/infra/common/safe_strerror.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { //! \brief Converts a system error code into its message. //! \remarks Thread-safe version of strerror. std::string safe_strerror(int err_code); } // namespace silkworm ================================================ FILE: silkworm/infra/common/secp256k1_context.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "secp256k1_context.hpp" #include namespace silkworm { const size_t SecP256K1Context::kPublicKeySizeCompressed = 33; const size_t SecP256K1Context::kPublicKeySizeUncompressed = 65; Bytes SecP256K1Context::serialize_public_key(const secp256k1_pubkey* public_key, bool is_compressed) const { size_t data_size = is_compressed ? kPublicKeySizeCompressed : kPublicKeySizeUncompressed; Bytes data(data_size, 0); unsigned int flags = is_compressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED; secp256k1_ec_pubkey_serialize(context_, data.data(), &data_size, public_key, flags); data.resize(data_size); return data; } unsigned int SecP256K1Context::flags(bool allow_verify, bool allow_sign) { unsigned int value = SECP256K1_CONTEXT_NONE; if (allow_verify) { value |= SECP256K1_CONTEXT_VERIFY; } if (allow_sign) { value |= SECP256K1_CONTEXT_SIGN; } return value; } // degenerate hash function that just copies the given X value // see: ecies.GenerateShared in Erigon static int ecdh_hash_function_copy_x( unsigned char* output, const unsigned char* x32, const unsigned char*, void*) { memcpy(output, x32, 32); return 1; }; bool SecP256K1Context::compute_ecdh_secret( Bytes& shared_secret, const secp256k1_pubkey* public_key, const ByteView& private_key) const { return secp256k1_ecdh(context_, shared_secret.data(), public_key, private_key.data(), ecdh_hash_function_copy_x, nullptr); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/secp256k1_context.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm { class SecP256K1Context final { public: explicit SecP256K1Context(bool allow_verify = true, bool allow_sign = false) : context_(secp256k1_context_create(SecP256K1Context::flags(allow_verify, allow_sign))) {} ~SecP256K1Context() { secp256k1_context_destroy(context_); } SecP256K1Context(const SecP256K1Context&) = delete; SecP256K1Context& operator=(const SecP256K1Context&) = delete; // escape hatch secp256k1_context* raw() { return context_; } bool verify_private_key_data(const ByteView& data) const { return secp256k1_ec_seckey_verify(context_, data.data()); } bool create_public_key(secp256k1_pubkey* public_key, const ByteView& private_key) const { return secp256k1_ec_pubkey_create(context_, public_key, private_key.data()); } Bytes serialize_public_key(const secp256k1_pubkey* public_key, bool is_compressed) const; bool parse_public_key(secp256k1_pubkey* public_key, const ByteView& public_key_data) const { return secp256k1_ec_pubkey_parse(context_, public_key, public_key_data.data(), public_key_data.size()); } bool compute_ecdh_secret( Bytes& shared_secret, const secp256k1_pubkey* public_key, const ByteView& private_key) const; bool sign_recoverable(secp256k1_ecdsa_recoverable_signature* signature, ByteView data_hash, ByteView private_key) { if (data_hash.size() != 32) { return false; } return secp256k1_ecdsa_sign_recoverable(context_, signature, data_hash.data(), private_key.data(), nullptr, nullptr); } bool recover_signature_public_key( secp256k1_pubkey* public_key, const secp256k1_ecdsa_recoverable_signature* signature, ByteView data_hash) { if (data_hash.size() != 32) { return false; } return secp256k1_ecdsa_recover(context_, public_key, signature, data_hash.data()); } std::pair serialize_recoverable_signature(const secp256k1_ecdsa_recoverable_signature* signature) { Bytes data(64, 0); int recovery_id{0}; secp256k1_ecdsa_recoverable_signature_serialize_compact(context_, data.data(), &recovery_id, signature); return {data, static_cast(recovery_id)}; } bool parse_recoverable_signature( secp256k1_ecdsa_recoverable_signature* signature, const ByteView& signature_data, uint8_t recovery_id) { if (signature_data.size() != 64) { return false; } return secp256k1_ecdsa_recoverable_signature_parse_compact( context_, signature, signature_data.data(), static_cast(recovery_id)); } bool sign(secp256k1_ecdsa_signature* signature, ByteView data_hash, ByteView private_key) { if (data_hash.size() != 32) { return false; } return secp256k1_ecdsa_sign(context_, signature, data_hash.data(), private_key.data(), nullptr, nullptr); } Bytes serialize_signature(const secp256k1_ecdsa_signature* signature) { Bytes data(64, 0); secp256k1_ecdsa_signature_serialize_compact(context_, data.data(), signature); return data; } bool parse_signature(secp256k1_ecdsa_signature* signature, ByteView signature_data) { if (signature_data.size() != 64) { return false; } return secp256k1_ecdsa_signature_parse_compact(context_, signature, signature_data.data()); } bool verify_signature(const secp256k1_ecdsa_signature* signature, ByteView data_hash, const secp256k1_pubkey* public_key) { if (data_hash.size() != 32) { return false; } return secp256k1_ecdsa_verify(context_, signature, data_hash.data(), public_key); } static const size_t kPublicKeySizeCompressed; static const size_t kPublicKeySizeUncompressed; private: static unsigned int flags(bool allow_verify, bool allow_sign); gsl::owner context_; }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/stopwatch.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stopwatch.hpp" namespace silkworm { StopWatch::TimePoint StopWatch::start(bool with_reset) noexcept { using namespace std::chrono_literals; if (with_reset) { reset(); } if (started_) { return start_time_; } started_ = true; if (start_time_ == TimePoint()) { start_time_ = std::chrono::high_resolution_clock::now(); } if (!laps_.empty()) { auto& [t, d] = laps_.back(); laps_.emplace_back(start_time_, std::chrono::duration_cast(start_time_ - t)); } else { laps_.emplace_back(start_time_, std::chrono::duration_cast(0s)); } return start_time_; } std::pair StopWatch::lap() noexcept { if (!started_ || laps_.empty()) { return {}; } const auto lap_time{std::chrono::high_resolution_clock::now()}; const auto& [t, d] = laps_.back(); laps_.emplace_back(lap_time, std::chrono::duration_cast(lap_time - t)); return laps_.back(); } StopWatch::Duration StopWatch::since_start(const TimePoint& origin) noexcept { if (start_time_ == TimePoint()) { return {}; } return Duration(origin - start_time_); } StopWatch::Duration StopWatch::since_start() noexcept { return since_start(std::chrono::high_resolution_clock::now()); } std::pair StopWatch::stop() noexcept { if (!started_) { return {}; } auto ret{lap()}; started_ = false; return ret; } void StopWatch::reset() noexcept { (void)stop(); start_time_ = TimePoint(); std::vector>().swap(laps_); } std::string StopWatch::format(Duration duration) noexcept { using namespace std::chrono_literals; using days = std::chrono::duration>; std::ostringstream os; char fill = os.fill('0'); if (duration >= 60s) { bool need_space{false}; if (auto d = std::chrono::duration_cast(duration); d.count()) { os << d.count() << "d"; duration -= d; need_space = true; } if (auto h = std::chrono::duration_cast(duration); h.count()) { os << (need_space ? " " : "") << h.count() << "h"; duration -= h; need_space = true; } if (auto m = std::chrono::duration_cast(duration); m.count()) { os << (need_space ? " " : "") << m.count() << "m"; duration -= m; need_space = true; } if (auto s = std::chrono::duration_cast(duration); s.count()) { os << (need_space ? " " : "") << s.count() << "s"; } } else { if (duration >= 1s) { auto s = std::chrono::duration_cast(duration); duration -= s; auto ms = std::chrono::duration_cast(duration); os << s.count(); if (ms.count()) { os << "." << std::setw(3) << ms.count(); } os << "s"; } else if (duration >= 1ms) { auto ms = std::chrono::duration_cast(duration); duration -= ms; auto us = std::chrono::duration_cast(duration); os << ms.count(); if (us.count()) { os << "." << std::setw(3) << us.count(); } os << "ms"; } else if (duration >= 1us) { auto us = std::chrono::duration_cast(duration); os << us.count() << "us"; } } os.fill(fill); return os.str(); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/stopwatch.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm { //! \brief This class mimics the behavior of a stopwatch to measure timings of operations class StopWatch { public: using TimePoint = std::chrono::time_point; using Duration = std::chrono::nanoseconds; static constexpr bool kStart = true; //! \brief Creates a new instance explicit StopWatch(bool auto_start = false) { if (auto_start) start(); }; ~StopWatch() = default; //! \brief Starts the clock //! \return The TimePoint it was started on TimePoint start(bool with_reset = false) noexcept; //! \brief Records a lap time //! \return A pair of TimePoint and Duration std::pair lap() noexcept; //! \brief Computes the duration amongst the start time and the provided timepoint //! \param origin [in] : An origin timepoint //! \return Duration Duration since_start(const TimePoint& origin) noexcept; //! \brief Computes the duration amongst now and the start time //! \return Duration Duration since_start() noexcept; //! \brief Stops the watch //! \return The timepoint of stop and the duration since start (if no laptimes) or the duration from previous //! laptime std::pair stop() noexcept; //! \brief Stops the watch and clears all counters void reset() noexcept; //! \brief Returns the vector of laptimes const std::vector>& laps() const { return laps_; } //! \brief Returns a human readable duration static std::string format(Duration duration) noexcept; explicit operator bool() const noexcept { return started_; } private: bool started_{false}; TimePoint start_time_{}; std::vector> laps_{}; }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/stopwatch_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stopwatch.hpp" #include #include namespace silkworm { TEST_CASE("Stop Watch") { using namespace std::chrono_literals; silkworm::StopWatch sw_autostart(true); REQUIRE(sw_autostart); // Must be started silkworm::StopWatch sw1{}; REQUIRE(!sw1); // Not started auto [lap_time0, duration0] = sw1.lap(); CHECK(duration0.count() == 0); CHECK(lap_time0 == silkworm::StopWatch::TimePoint()); auto start_time = sw1.start(); CHECK(sw1); // Started std::this_thread::sleep_for(std::chrono::milliseconds(5)); auto [lap_time1, duration1] = sw1.lap(); CHECK(duration1.count() >= 5 * 1000); CHECK(start_time < lap_time1); std::this_thread::sleep_for(std::chrono::milliseconds(10)); auto [lap_time2, duration2] = sw1.lap(); CHECK(duration2.count() >= 10 * 1000); CHECK(lap_time1 < lap_time2); auto duration3 = sw1.since_start(lap_time2); CHECK(duration3.count() == (duration1.count() + duration2.count())); CHECK(sw1.laps().size() == 3); // Start + 2 laps for (auto& [t, _] : sw1.laps()) { CHECK(t >= start_time); } CHECK(!sw1.format(duration3).empty()); CHECK(sw1.format(255h + 12min + 14s) == "10d 15h 12m 14s"); CHECK(sw1.format(240h) == "10d"); CHECK(sw1.format(240h + 14s) == "10d 14s"); CHECK(sw1.format(7min + 12s + 120ms) == "7m 12s"); CHECK(sw1.format(1ms) == "1ms"); CHECK(sw1.format(1200ms) == "1.200s"); CHECK(sw1.format(1010us) == "1.010ms"); CHECK(sw1.format(20us) == "20us"); (void)sw1.stop(); (void)sw1.start(/*with_reset=*/true); CHECK(sw1.laps().empty() == false); (void)sw1.stop(); auto [_, duration4]{sw1.stop()}; CHECK(duration4.count() == 0); sw1.reset(); CHECK(sw1.laps().empty()); // No more laps CHECK_FALSE(sw1); // Not started } } // namespace silkworm ================================================ FILE: silkworm/infra/common/terminal.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "terminal.hpp" #include #if defined(_WIN32) #include #include #if !defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING) #define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004 #endif #else #include #endif namespace silkworm { void init_terminal() { #if defined(_WIN32) // Change code page to UTF-8 so log characters are displayed correctly in console // and also support virtual terminal processing for coloring output SetConsoleOutputCP(CP_UTF8); HANDLE output_handle = GetStdHandle(STD_OUTPUT_HANDLE); if (output_handle != INVALID_HANDLE_VALUE) { DWORD mode = 0; if (GetConsoleMode(output_handle, &mode)) { mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING; SetConsoleMode(output_handle, mode); } } #endif } bool is_terminal(int fd) { #if defined(_WIN32) return _isatty(fd); #else return isatty(fd); #endif } static bool is_terminal_stream(FILE* stream) { #if defined(_WIN32) return is_terminal(_fileno(stream)); #else return is_terminal(fileno(stream)); #endif } bool is_terminal_stdout() { return is_terminal_stream(stdout); } bool is_terminal_stderr() { return is_terminal_stream(stderr); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/terminal.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { // Reset sequence inline constexpr std::string_view kColorReset = "\x1b[0m"; // Resets fore color to terminal default // Normal colors inline constexpr std::string_view kColorBlack = "\x1b[30m"; // Black inline constexpr std::string_view kColorCoal = "\x1b[90m"; // Black inline constexpr std::string_view kColorGray = "\x1b[37m"; // White inline constexpr std::string_view kColorWhite = "\x1b[97m"; // White inline constexpr std::string_view kColorMaroon = "\x1b[31m"; // Red inline constexpr std::string_view kColorRed = "\x1b[91m"; // Red inline constexpr std::string_view kColorGreen = "\x1b[32m"; // Green inline constexpr std::string_view kColorLime = "\x1b[92m"; // Green inline constexpr std::string_view kColorOrange = "\x1b[33m"; // Yellow inline constexpr std::string_view kColorYellow = "\x1b[93m"; // Yellow inline constexpr std::string_view kColorNavy = "\x1b[34m"; // Blue inline constexpr std::string_view kColorBlue = "\x1b[94m"; // Blue inline constexpr std::string_view kColorViolet = "\x1b[35m"; // Purple inline constexpr std::string_view kColorPurple = "\x1b[95m"; // Purple inline constexpr std::string_view kColorTeal = "\x1b[36m"; // Cyan inline constexpr std::string_view kColorCyan = "\x1b[96m"; // Cyan // Highlight colors inline constexpr std::string_view kColorBlackHigh = "\x1b[1;30m"; // Black inline constexpr std::string_view kColorCoalHigh = "\x1b[1;90m"; // Black inline constexpr std::string_view kColorGrayHigh = "\x1b[1;37m"; // White inline constexpr std::string_view kColorWhiteHigh = "\x1b[1;97m"; // White inline constexpr std::string_view kColorMaroonHigh = "\x1b[1;31m"; // Red inline constexpr std::string_view kColorRedHigh = "\x1b[1;91m"; // Red inline constexpr std::string_view kColorGreenHigh = "\x1b[1;32m"; // Green inline constexpr std::string_view kColorLimeHigh = "\x1b[1;92m"; // Green inline constexpr std::string_view kColorOrangeHigh = "\x1b[1;33m"; // Yellow inline constexpr std::string_view kColorYellowHigh = "\x1b[1;93m"; // Yellow inline constexpr std::string_view kColorNavyHigh = "\x1b[1;34m"; // Blue inline constexpr std::string_view kColorBlueHigh = "\x1b[1;94m"; // Blue inline constexpr std::string_view kColorVioletHigh = "\x1b[1;35m"; // Purple inline constexpr std::string_view kColorPurpleHigh = "\x1b[1;95m"; // Purple inline constexpr std::string_view kColorTealHigh = "\x1b[1;36m"; // Cyan inline constexpr std::string_view kColorCyanHigh = "\x1b[1;96m"; // Cyan // Background inline constexpr std::string_view kBackgroundBlack = "\x1b[40m"; // Black inline constexpr std::string_view kBackgroundCoal = "\x1b[100m"; // Black inline constexpr std::string_view kBackgroundGray = "\x1b[47m"; // White inline constexpr std::string_view kBackgroundWhite = "\x1b[107m"; // White inline constexpr std::string_view kBackgroundMaroon = "\x1b[41m"; // Red inline constexpr std::string_view kBackgroundRed = "\x1b[101m"; // Red inline constexpr std::string_view kBackgroundGreen = "\x1b[42m"; // Green inline constexpr std::string_view kBackgroundLime = "\x1b[102m"; // Green inline constexpr std::string_view kBackgroundOrange = "\x1b[43m"; // Yellow inline constexpr std::string_view kBackgroundYellow = "\x1b[103m"; // Yellow inline constexpr std::string_view kBackgroundNavy = "\x1b[44m"; // Blue inline constexpr std::string_view kBackgroundBlue = "\x1b[104m"; // Blue inline constexpr std::string_view kBackgroundViolet = "\x1b[45m"; // Purple inline constexpr std::string_view kBackgroundPurple = "\x1b[105m"; // Purple inline constexpr std::string_view kBackgroundTeal = "\x1b[46m"; // Cyan inline constexpr std::string_view kBackgroundCyan = "\x1b[106m"; // Cyan // Underline inline constexpr std::string_view kColorBlackUnderline = "\x1b[4;30m"; // Black inline constexpr std::string_view kColorGrayUnderline = "\x1b[4;37m"; // White inline constexpr std::string_view kColorMaroonUnderline = "\x1b[4;31m"; // Red inline constexpr std::string_view kColorGreenUnderline = "\x1b[4;32m"; // Green inline constexpr std::string_view kColorOrangeUnderline = "\x1b[4;33m"; // Yellow inline constexpr std::string_view kColorNavyUnderline = "\x1b[4;34m"; // Blue inline constexpr std::string_view kColorVioletUnderline = "\x1b[4;35m"; // Purple inline constexpr std::string_view kColorTealUnderline = "\x1b[4;36m"; // Cyan //! \brief Initializes terminal code page to UTF-8 and enables control escape sequences //! \remarks Is actually needed on Windows only void init_terminal(); //! Check if specified file descriptor is a teletype (TTY) terminal bool is_terminal(int fd); //! Check if standard output is a TTY terminal bool is_terminal_stdout(); //! Check if standard error is a TTY terminal bool is_terminal_stderr(); } // namespace silkworm ================================================ FILE: silkworm/infra/common/timer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "timer.hpp" namespace silkworm { //! \brief Implementation of an asynchronous periodic timer relying on boost:asio timer facility //! \warning At least one TimerImpl shared pointer must exist when using it (precondition of shared_from_this()) //! \warning This is achieved by static TimerImpl::create and non-public constructor, subclasses must obey the same rule class TimerImpl : public std::enable_shared_from_this { public: //! Factory method enforcing instances are managed *only* through shared pointers //! \param executor [in] : executor running the timer //! \param interval [in] : length of wait interval (in milliseconds) //! \param callback [in] : the call back function to be called //! \param auto_start [in] : whether to start the timer immediately static std::shared_ptr create(const boost::asio::any_io_executor& executor, uint32_t interval, std::function callback, bool auto_start = true) { auto timer = std::shared_ptr(new TimerImpl{executor, interval, std::move(callback)}); if (auto_start) timer->start(); return timer; } ~TimerImpl() { stop(); } //! \brief Start timer asynchronously. Eventually callback action is executed and timer automatically rescheduled //! for another interval void start() { bool expected_running{false}; if (is_running_.compare_exchange_strong(expected_running, true)) { launch(); } } //! \brief Stop timer and cancel any pending execution. Callback may still be executed *once* if timer gets cancelled //! after expiration but before completion handler dispatching. void stop() { bool expected_running{true}; if (is_running_.compare_exchange_strong(expected_running, false)) { (void)timer_.cancel(); } } //! \brief Cancel next execution of awaiting callback and reschedule for a new interval if still running void reset() { (void)timer_.cancel(); if (is_running_) { launch(); } } protected: //! \brief Not public to force creation only through TimerImpl::create //! \param executor [in] : executor running the timer //! \param interval [in] : length of wait interval (in milliseconds) //! \param call_back [in] : the call back function to be called TimerImpl(const boost::asio::any_io_executor& executor, uint32_t interval, std::function call_back) : interval_(interval), timer_(executor), callback_(std::move(call_back)) { SILKWORM_ASSERT(interval > 0); }; private: //! \brief Launches async timer void launch() { timer_.expires_after(std::chrono::milliseconds(interval_)); // Start the timer and capture it as shared pointer to extend its lifetime to the completion handler invocation (void)timer_.async_wait([self = shared_from_this()](const boost::system::error_code& ec) { if (ec == boost::asio::error::operation_aborted) { // If timer gets cancelled before expiration return; } // If timer gets cancelled after expiration but before completion handler dispatching, we may arrive here if (!ec && self->callback_) { self->callback_(); } if (self->is_running_) { self->launch(); } }); } std::atomic_bool is_running_{false}; const uint32_t interval_; boost::asio::steady_timer timer_; std::function callback_; }; Timer::Timer(const boost::asio::any_io_executor& executor, uint32_t interval, std::function callback, bool auto_start) : p_impl_{TimerImpl::create(executor, interval, std::move(callback), auto_start)} {} Timer::~Timer() { p_impl_->stop(); } void Timer::start() { p_impl_->start(); } void Timer::stop() { p_impl_->stop(); } void Timer::reset() { p_impl_->reset(); } } // namespace silkworm ================================================ FILE: silkworm/infra/common/timer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm { using namespace std::chrono_literals; class TimerImpl; //! \brief Asynchronous periodic timer relying on boost:asio timer facility //! \note This class supports RAII pattern: the Timer destructor will stop the timer //! \warning after stop the timer expiration callback *may* be called once more class Timer { public: //! Create a new periodic timer //! \param executor [in] : executor running the timer //! \param interval [in] : length of wait interval (in milliseconds) //! \param callback [in] : the call back function to be called //! \param auto_start [in] : whether to start the timer immediately Timer(const boost::asio::any_io_executor& executor, uint32_t interval, std::function callback, bool auto_start = true); //! Stop and destroy the timer //! \warning after stop the timer expiration callback *may* be called once more ~Timer(); //! \brief Start the timer asynchronously. Eventually callback gets executed and timer automatically rescheduled //! \details this call is idempotent void start(); //! \brief Stop the timer and cancel any pending expiration //! \details Callback may still be executed *once* if timer gets cancelled after expiration but before completion //! handler dispatching //! \details this call is idempotent void stop(); //! \brief Cancel the next timer expiration and reschedule for a new interval if still running void reset(); private: std::shared_ptr p_impl_; }; } // namespace silkworm ================================================ FILE: silkworm/infra/common/timer_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "timer.hpp" #include #include #include #include #include namespace silkworm { struct TimerTest { static constexpr std::array kIntervals{100, 10, 1}; // milliseconds boost::asio::io_context ioc; }; TEST_CASE_METHOD(TimerTest, "Periodic timer", "[infra][common][timer]") { static constexpr size_t kExpectedExpirations{2}; size_t expired_count{0}; // The lambda capture-list content *must* outlive the scheduler execution loop for (const auto interval : kIntervals) { Timer periodic_timer{ ioc.get_executor(), interval, [&]() -> bool { ++expired_count; // Stop the timer scheduler after multiple expirations if (expired_count == kExpectedExpirations) { ioc.stop(); } return true; }, }; SECTION("Duration " + std::to_string(interval) + "ms : expired") { ioc.run(); // run until timer expires, then the callback will stop us } SECTION("Duration " + std::to_string(interval) + "ms : cancelled") { periodic_timer.stop(); ioc.run(); // may be expired multiple times or not depending on interval } SECTION("Duration " + std::to_string(interval) + "ms : rescheduled") { periodic_timer.reset(); ioc.run(); // may be expired multiple times or not depending on interval } expired_count = 0; } } TEST_CASE_METHOD(TimerTest, "One shot timer", "[infra][common][timer]") { bool timer_expired{false}; // The lambda capture-list content *must* outlive the scheduler execution loop for (const auto interval : kIntervals) { Timer one_shot_timer{ ioc.get_executor(), interval, [&]() -> bool { ioc.stop(); timer_expired = true; return true; }, }; SECTION("Duration " + std::to_string(interval) + "ms: expired") { ioc.run(); // run until timer expires, then the callback will stop us CHECK(timer_expired); } SECTION("Duration " + std::to_string(interval) + "ms: cancelled") { one_shot_timer.stop(); ioc.run(); // may be expired or not depending on interval } SECTION("Duration " + std::to_string(interval) + "ms: rescheduled") { one_shot_timer.reset(); ioc.run(); // may be expired or not depending on interval } timer_expired = false; } } TEST_CASE_METHOD(TimerTest, "Cancellation before expiration", "[infra][common][timer]") { bool timer_expired{false}; // The lambda capture-list content *must* outlive the scheduler execution loop for (const auto interval : kIntervals) { SECTION("Duration " + std::to_string(interval) + "ms") { Timer async_timer{ ioc.get_executor(), interval, [&]() -> bool { timer_expired = true; return true; }, /*auto_start=*/true, }; async_timer.stop(); CHECK_NOTHROW(ioc.run()); CHECK(!timer_expired); } timer_expired = false; } } TEST_CASE_METHOD(TimerTest, "Lifecycle race condition", "[infra][common][timer]") { for (const auto interval : kIntervals) { SECTION("Duration " + std::to_string(interval) + "ms") { { Timer async_timer{ioc.get_executor(), interval, []() -> bool { return true; }}; async_timer.start(); ioc.poll(); // serve just one task async_timer.stop(); } // timer gets deleted here or after callback dispatch CHECK_NOTHROW(ioc.run()); } } } TEST_CASE_METHOD(TimerTest, "Explicit stop not necessary", "[infra][common][timer]") { for (const auto interval : kIntervals) { SECTION("Duration " + std::to_string(interval) + "ms: stopped") { { Timer async_timer{ioc.get_executor(), interval, []() -> bool { return true; }}; async_timer.stop(); } // The timer has been stopped explicitly: the scheduler eventually runs out of work const auto executed_handlers = ioc.run(); // serve all remaining tasks CHECK(executed_handlers > 0); } SECTION("Duration " + std::to_string(interval) + "ms: not stopped") { { Timer async_timer{ioc.get_executor(), interval, []() -> bool { return true; }}; } // The timer has *not* been stopped explicitly, but automatically: the scheduler eventually runs out of work anyway const auto executed_handlers = ioc.run(); // serve all remaining tasks CHECK(executed_handlers > 0); } } } } // namespace silkworm ================================================ FILE: silkworm/infra/common/unix_timestamp.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "unix_timestamp.hpp" namespace silkworm { uint64_t unix_timestamp_from_time_point(std::chrono::time_point time_point) { return static_cast(std::chrono::duration_cast(time_point.time_since_epoch()).count()); } std::chrono::time_point time_point_from_unix_timestamp(uint64_t timestamp) { return std::chrono::time_point{std::chrono::seconds(timestamp)}; } } // namespace silkworm ================================================ FILE: silkworm/infra/common/unix_timestamp.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { uint64_t unix_timestamp_from_time_point(std::chrono::time_point time_point); std::chrono::time_point time_point_from_unix_timestamp(uint64_t timestamp); } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/active_component.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "async_thread.hpp" namespace silkworm { //! Abstract interface for active components i.e. components that have an infinite loop and need a dedicated thread //! to run the loop (if the application has also other things to do). class ActiveComponent : public Stoppable { public: virtual void execution_loop() = 0; //! This adapter method makes ActiveComponent suitable to be used as asynchronous task Task async_run(const char* thread_name, std::optional stack_size = {}) { auto run = [this] { this->execution_loop(); }; auto stop = [this] { this->stop(); }; co_await concurrency::async_thread(std::move(run), std::move(stop), thread_name, stack_size); } }; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/async_thread.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "async_thread.hpp" #include #include #include #include #include #include #include "event_notifier.hpp" namespace silkworm::concurrency { Task async_thread( std::function run, std::function stop, const char* name, std::optional stack_size) { std::exception_ptr run_exception; auto executor = co_await boost::asio::this_coro::executor; EventNotifier thread_finished_notifier{executor}; boost::thread::attributes attributes; if (stack_size) { attributes.set_stack_size(*stack_size); } boost::thread thread{attributes, [run = std::move(run), name = name, &run_exception, &thread_finished_notifier] { log::set_thread_name(name); try { SILK_TRACE << "Async thread [" << name << "] run started"; run(); SILK_TRACE << "Async thread [" << name << "] run completed"; } catch (...) { run_exception = std::current_exception(); } try { thread_finished_notifier.notify(); } catch (const std::exception& ex) { SILK_ERROR << "async_thread thread_finished_notifier.notify exception: " << ex.what(); } }}; try { co_await thread_finished_notifier.wait(); thread.join(); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) { try { stop(); } catch (const std::exception& stop_ex) { SILK_ERROR << "async_thread stop exception: " << stop_ex.what(); throw; } thread.join(); } else { SILK_ERROR << "async_thread thread_finished_notifier.wait system_error: " << ex.what(); throw; } } catch (...) { SILK_CRIT << "async_thread thread_finished_notifier.wait unexpected exception"; throw; } if (run_exception) { std::rethrow_exception(run_exception); } } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/async_thread.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::concurrency { /** * async_thread bridges an async caller code with sync code that requires blocking. * It allows awaiting for a blocking `run` function. * If `run` throws an exception, it is propagated to the caller. * If a returned task is cancelled, the given `stop` function gets called, * and is expected that `run` exits after that. * * @param run thread procedure * @param stop a callback to signal the thread procedure to exit * @param name the name appearing in log traces for the created thread * @param stack_size optional custom stack size for the created thread * @return an task that is pending until the thread finishes */ Task async_thread( std::function run, std::function stop, const char* name, std::optional stack_size = {}); } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/awaitable_condition_variable.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "awaitable_condition_variable.hpp" #include #include #include #include #include "event_notifier.hpp" namespace silkworm::concurrency { class AwaitableConditionVariableImpl { public: std::function()> waiter() { size_t waiter_version{0}; { std::scoped_lock lock(mutex_); waiter_version = version_; } return [this, waiter_version]() -> Task { auto executor = co_await boost::asio::this_coro::executor; decltype(waiters_)::iterator waiter; { std::scoped_lock lock(mutex_); // if notify_all was called while preparing for waiting // we need to wake up to avoid a deadlock if (waiter_version != version_) { co_return; } std::tie(waiter, std::ignore) = waiters_.insert(std::make_unique(executor)); } co_await (*waiter)->wait(); { std::scoped_lock lock(mutex_); waiters_.erase(waiter); } }; } void notify_all() { std::scoped_lock lock(mutex_); ++version_; for (auto& waiter : waiters_) { waiter->notify(); } } private: std::mutex mutex_; std::set> waiters_; size_t version_{0}; }; AwaitableConditionVariable::AwaitableConditionVariable() : p_impl_(std::make_unique()) { } AwaitableConditionVariable::~AwaitableConditionVariable() { [[maybe_unused]] int non_trivial_destructor{0}; // silent clang-tidy } std::function()> AwaitableConditionVariable::waiter() { return p_impl_->waiter(); } void AwaitableConditionVariable::notify_all() { p_impl_->notify_all(); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/awaitable_condition_variable.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "task.hpp" namespace silkworm::concurrency { class AwaitableConditionVariableImpl; /** A simplified condition variable similar to Rust Tokio Notify: https://docs.rs/tokio/1.25.0/tokio/sync/struct.Notify.html It supports multiple waiters unlike EventNotifier. Synchronize waiter()/notify_all() calls with your producer state to avoid a deadlock. It happens if the producer readiness updates right before calling waiter(). Example: // consumers std::unique_lock lock{mutex_}; if (ready_) co_return; auto waiter = cond_var.waiter(); lock.unlock(); co_await waiter(); // producer std::scoped_lock lock{mutex_}; ready_ = true; cond_var.notify_all(); */ class AwaitableConditionVariable { public: AwaitableConditionVariable(); virtual ~AwaitableConditionVariable(); using Waiter = std::function()>; Waiter waiter(); void notify_all(); private: std::unique_ptr p_impl_; }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/awaitable_condition_variable_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "awaitable_condition_variable.hpp" #include #include #include #include namespace silkworm::concurrency { using namespace boost::asio; TEST_CASE("AwaitableConditionVariable.not_blocking_when_notified_before_waiting") { test_util::TaskRunner runner; AwaitableConditionVariable cond_var; auto waiter = cond_var.waiter(); cond_var.notify_all(); runner.run(waiter()); } TEST_CASE("AwaitableConditionVariable.blocks_during_waiting") { using namespace std::chrono_literals; test_util::TaskRunner runner; AwaitableConditionVariable cond_var; auto waiter = cond_var.waiter(); // schedule waiting auto future = runner.spawn_future(waiter()); // run until it blocks while (runner.ioc().poll_one() > 0) { } CHECK(future.wait_for(0s) == std::future_status::timeout); } TEST_CASE("AwaitableConditionVariable.notify_all_awakes_waiter") { test_util::TaskRunner runner; AwaitableConditionVariable cond_var; auto waiter = cond_var.waiter(); // schedule waiting auto future = runner.spawn_future(waiter()); // run until it blocks while (runner.ioc().poll_one() > 0) { } cond_var.notify_all(); runner.poll_context_until_future_is_ready(future); } TEST_CASE("AwaitableConditionVariable.notify_all_awakes_multiple_waiters") { test_util::TaskRunner runner; AwaitableConditionVariable cond_var; auto waiter1 = cond_var.waiter(); auto waiter2 = cond_var.waiter(); auto waiter3 = cond_var.waiter(); // schedule waiting auto future1 = runner.spawn_future(waiter1()); auto future2 = runner.spawn_future(waiter2()); auto future3 = runner.spawn_future(waiter3()); // run until it blocks while (runner.ioc().poll_one() > 0) { } cond_var.notify_all(); runner.poll_context_until_future_is_ready(future1); runner.poll_context_until_future_is_ready(future2); runner.poll_context_until_future_is_ready(future3); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/awaitable_future.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "task.hpp" #include #include #include #include namespace silkworm::concurrency { // An awaitable-friendly future/promise // See also: https://docs.rs/tokio/1.25.0/tokio/sync/oneshot/index.html template class AwaitablePromise; template class AwaitableFuture { public: AwaitableFuture(const AwaitableFuture&) = delete; AwaitableFuture& operator=(const AwaitableFuture&) = delete; AwaitableFuture(AwaitableFuture&&) noexcept = default; AwaitableFuture& operator=(AwaitableFuture&&) noexcept = default; Task get() { try { std::optional result = co_await channel_->async_receive(boost::asio::use_awaitable); co_return std::move(result.value()); } catch (const boost::system::system_error& ex) { close_and_throw_if_cancelled(ex); throw ex; } } Task get_async() { return get(); } private: friend class AwaitablePromise; using AsyncChannel = boost::asio::experimental::concurrent_channel)>; explicit AwaitableFuture(std::shared_ptr channel) : channel_(std::move(channel)) {} void close_and_throw_if_cancelled(const boost::system::system_error& ex) { // Convert channel cancelled into operation cancelled to allow just one catch clause at call site if (ex.code() == boost::asio::experimental::channel_errc::channel_cancelled) { // Close the channel because cancellation state seems to be not detectable at sender side channel_->close(); throw boost::system::system_error{make_error_code(boost::system::errc::operation_canceled)}; } } std::shared_ptr channel_; }; template class AwaitablePromise { using AsyncChannel = typename AwaitableFuture::AsyncChannel; public: explicit AwaitablePromise(const boost::asio::any_io_executor& executor) : channel_(std::make_shared(executor, 1)), subscribed_(std::make_unique()) {} AwaitablePromise(const AwaitablePromise&) = delete; AwaitablePromise& operator=(const AwaitablePromise&) = delete; AwaitablePromise(AwaitablePromise&&) noexcept = default; AwaitablePromise& operator=(AwaitablePromise&&) noexcept = default; bool set_value(T value) { return set(nullptr, std::move(value)); } void set_exception(std::exception_ptr ptr) { set(ptr, std::nullopt); } AwaitableFuture get_future() { bool expected{false}; bool was_unsubscribed = subscribed_->compare_exchange_strong(expected, true); if (!was_unsubscribed) throw std::runtime_error("AwaitablePromise::get_future can't be called multiple times"); return AwaitableFuture(channel_); } class AlreadySatisfiedError : public std::runtime_error { public: AlreadySatisfiedError() : std::runtime_error("AwaitablePromise is already satisfied") {} }; private: bool set(std::exception_ptr ptr, std::optional value) { const bool sent = channel_->try_send(ptr, std::move(value)); // Any send failure when channel has already been closed must not trigger an error if (!sent && channel_->is_open()) { throw AlreadySatisfiedError(); } return sent; } std::shared_ptr channel_; std::unique_ptr subscribed_; }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/awaitable_future_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "awaitable_future.hpp" #include #include #include #include #include #include #include #include #include #include "active_component.hpp" namespace silkworm { namespace asio = boost::asio; using concurrency::AwaitableFuture; using concurrency::AwaitablePromise; auto create_promise_and_set_value(const asio::any_io_executor& executor, int value) { concurrency::AwaitablePromise promise{executor}; promise.set_value(value); return promise.get_future(); } class TestException : public std::runtime_error { public: TestException() : std::runtime_error("TestException") {} }; TEST_CASE("awaitable future") { test_util::TaskRunner runner; AwaitablePromise promise{runner.executor()}; SECTION("trivial use") { auto future = promise.get_future(); promise.set_value(42); auto value = runner.run(future.get()); CHECK(value == 42); } SECTION("variation of the trivial use") { promise.set_value(42); auto future = promise.get_future(); auto value = runner.run(future.get()); CHECK(value == 42); } SECTION("setting exception instead of value") { auto future = promise.get_future(); promise.set_exception(std::make_exception_ptr(TestException())); CHECK_THROWS_AS(runner.run(future.get()), TestException); } SECTION("variation of setting exception instead of value") { auto future = promise.get_future(); try { throw TestException(); } catch (const TestException&) { promise.set_exception(std::current_exception()); } CHECK_THROWS_AS(runner.run(future.get()), TestException); } SECTION("setting value two times fails") { promise.set_value(42); CHECK_THROWS(promise.set_value(43)); } SECTION("setting exception two times fails") { promise.set_exception(std::make_exception_ptr(TestException())); CHECK_THROWS(promise.set_exception(std::make_exception_ptr(TestException()))); } SECTION("returning the future from a function") { auto future = create_promise_and_set_value(runner.executor(), 42); auto value = runner.run(future.get()); CHECK(value == 42); } SECTION("returning the future from a function (variation)") { auto returned_future = [executor = runner.executor()]() { concurrency::AwaitablePromise promise1{executor}; auto future = promise1.get_future(); promise1.set_value(42); return future; }(); auto value = runner.run(returned_future.get()); CHECK(value == 42); } SECTION("writing and reading from different threads") { int value{0}; std::thread concurrent( [&](AwaitableFuture moved_future) { value = runner.run(moved_future.get()); }, promise.get_future()); promise.set_value(42); concurrent.join(); CHECK(value == 42); } SECTION("writing and reading from different threads") { int value{0}; std::thread concurrent( [&](AwaitableFuture moved_future) { value = runner.run(moved_future.get()); }, promise.get_future()); runner.run( [&]() -> Task { promise.set_value(42); co_return; }()); concurrent.join(); CHECK(value == 42); } SECTION("using coroutines in read in the same io_context, write before read") { int value{0}; promise.set_value(42); runner.run( [&]() -> Task { auto future = promise.get_future(); value = co_await future.get(); }()); CHECK(value == 42); } SECTION("variation of using coroutines in the same io_context, write before read") { auto future = promise.get_future(); promise.set_value(42); int value{0}; runner.run( [&]() -> Task { value = co_await future.get(); }()); CHECK(value == 42); } SECTION("moving AwaitableFuture") { auto future = promise.get_future(); int value{0}; auto lambda = [&](AwaitableFuture moved_future) -> Task { value = co_await moved_future.get(); }; promise.set_value(42); runner.run(lambda(std::move(future))); CHECK(value == 42); } SECTION("using coroutine for both read and write, read before write") { asio::io_context& ioc = runner.ioc(); int value{0}; asio::co_spawn( ioc, [&]() -> Task { auto future = promise.get_future(); value = co_await future.get(); ioc.stop(); }, asio::detached); asio::co_spawn( ioc, [&]() -> Task { promise.set_value(42); co_return; }, asio::detached); ioc.run(); CHECK(value == 42); } SECTION("cancellation after read") { asio::io_context& ioc = runner.ioc(); int value{0}; boost::system::error_code code; boost::asio::cancellation_signal cancellation_signal; asio::co_spawn( ioc, [&]() -> Task { auto future = promise.get_future(); try { value = co_await future.get(); } catch (const boost::system::system_error& se) { code = se.code(); } ioc.stop(); }, boost::asio::bind_cancellation_slot(cancellation_signal.slot(), asio::detached)); asio::co_spawn( ioc, [&]() -> Task { cancellation_signal.emit(boost::asio::cancellation_type::all); co_return; }, asio::detached); ioc.run(); CHECK(promise.set_value(42) == false); CHECK(code == boost::system::errc::operation_canceled); } } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/awaitable_wait_for_all.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // // Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #include #include #include #include #include #include #include #include #include #include "parallel_group_utils.hpp" #include "spawn.hpp" namespace silkworm::concurrency::awaitable_wait_for_all { using boost::asio::experimental::wait_for_one_error; template using awaitable = boost::asio::awaitable; template using use_awaitable_t = boost::asio::use_awaitable_t; using boost::asio::deferred; using boost::asio::experimental::make_parallel_group; namespace this_coro { using boost::asio::this_coro::executor; } namespace detail { using boost::asio::experimental::awaitable_operators::detail::awaitable_unwrap; using boost::asio::experimental::awaitable_operators::detail::awaitable_wrap; using boost::asio::experimental::awaitable_operators::detail::widen_variant; } // namespace detail //! Wait for both operations to succeed. /** * If one operations fails, the other is cancelled as the AND-condition can no * longer be satisfied. */ template awaitable operator&&( awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, ex1] = co_await make_parallel_group( co_spawn(ex, std::move(t), deferred), co_spawn(ex, std::move(u), deferred)) .async_wait( wait_for_one_error(), use_awaitable_t{}); rethrow_first_exception_if_any({ex0, ex1}, order); co_return; } //! Wait for both operations to succeed. /** * If one operations fails, the other is cancelled as the AND-condition can no * longer be satisfied. */ template awaitable operator&&( awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, ex1, r1] = co_await make_parallel_group( co_spawn(ex, std::move(t), deferred), co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)) .async_wait( wait_for_one_error(), use_awaitable_t{}); rethrow_first_exception_if_any({ex0, ex1}, order); co_return std::move(detail::awaitable_unwrap(r1)); } //! Wait for both operations to succeed. /** * If one operations fails, the other is cancelled as the AND-condition can no * longer be satisfied. */ template awaitable operator&&( awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1] = co_await make_parallel_group( co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, std::move(u), deferred)) .async_wait( wait_for_one_error(), use_awaitable_t{}); rethrow_first_exception_if_any({ex0, ex1}, order); co_return std::move(detail::awaitable_unwrap(r0)); } //! Wait for both operations to succeed. /** * If one operations fails, the other is cancelled as the AND-condition can no * longer be satisfied. */ template awaitable, Executor> operator&&( awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1, r1] = co_await make_parallel_group( co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)) .async_wait( wait_for_one_error(), use_awaitable_t{}); rethrow_first_exception_if_any({ex0, ex1}, order); co_return std::make_tuple( std::move(detail::awaitable_unwrap(r0)), std::move(detail::awaitable_unwrap(r1))); } //! Wait for both operations to succeed. /** * If one operations fails, the other is cancelled as the AND-condition can no * longer be satisfied. */ template awaitable, Executor> operator&&( awaitable, Executor> t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1, r1] = co_await make_parallel_group( co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, std::move(u), deferred)) .async_wait( wait_for_one_error(), use_awaitable_t{}); rethrow_first_exception_if_any({ex0, ex1}, order); co_return std::move(detail::awaitable_unwrap>(r0)); } //! Wait for both operations to succeed. /** * If one operations fails, the other is cancelled as the AND-condition can no * longer be satisfied. */ template awaitable, Executor> operator&&( awaitable, Executor> t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1, r1] = co_await make_parallel_group( co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)) .async_wait( wait_for_one_error(), use_awaitable_t{}); rethrow_first_exception_if_any({ex0, ex1}, order); co_return std::tuple_cat( std::move(detail::awaitable_unwrap>(r0)), std::make_tuple(std::move(detail::awaitable_unwrap(r1)))); } } // namespace silkworm::concurrency::awaitable_wait_for_all ================================================ FILE: silkworm/infra/concurrency/awaitable_wait_for_one.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // // Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #include #include #include #include #include #include #include #include #include #include #include "spawn.hpp" namespace silkworm::concurrency::awaitable_wait_for_one { using boost::asio::experimental::wait_for_one; template using awaitable = boost::asio::awaitable; template using use_awaitable_t = boost::asio::use_awaitable_t; using boost::asio::deferred; using boost::asio::experimental::make_parallel_group; namespace this_coro { using boost::asio::this_coro::executor; } namespace detail { using boost::asio::experimental::awaitable_operators::detail::awaitable_unwrap; using boost::asio::experimental::awaitable_operators::detail::awaitable_wrap; using boost::asio::experimental::awaitable_operators::detail::widen_variant; } // namespace detail //! Wait for one operation to succeed. /** * If one operations succeeds, the other is cancelled as the OR-condition is * already satisfied. */ template awaitable, Executor> operator||(awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, ex1] = co_await make_parallel_group(co_spawn(ex, std::move(t), deferred), co_spawn(ex, std::move(u), deferred)) .async_wait(wait_for_one(), use_awaitable_t{}); if (order[0] == 0) { if (!ex0) co_return std::variant{std::in_place_index<0>}; std::rethrow_exception(ex0); } else { if (!ex1) co_return std::variant{std::in_place_index<1>}; std::rethrow_exception(ex1); } } //! Wait for one operation to succeed. /** * If one operations succeeds, the other is cancelled as the OR-condition is * already satisfied. */ template awaitable, Executor> operator||(awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, ex1, r1] = co_await make_parallel_group(co_spawn(ex, std::move(t), deferred), co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)) .async_wait(wait_for_one(), use_awaitable_t{}); if (order[0] == 0) { if (!ex0) co_return std::variant{std::in_place_index<0>}; std::rethrow_exception(ex0); } else { if (!ex1) { co_return std::variant{std::in_place_index<1>, std::move(detail::awaitable_unwrap(r1))}; } std::rethrow_exception(ex1); } } //! Wait for one operation to succeed. /** * If one operations succeeds, the other is cancelled as the OR-condition is * already satisfied. */ template awaitable, Executor> operator||(awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1] = co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, std::move(u), deferred)) .async_wait(wait_for_one(), use_awaitable_t{}); if (order[0] == 0) { if (!ex0) { co_return std::variant{std::in_place_index<0>, std::move(detail::awaitable_unwrap(r0))}; } std::rethrow_exception(ex0); } else { if (!ex1) co_return std::variant{std::in_place_index<1>}; std::rethrow_exception(ex1); } } //! Wait for one operation to succeed. /** * If one operations succeeds, the other is cancelled as the OR-condition is * already satisfied. */ template awaitable, Executor> operator||(awaitable t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1, r1] = co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)) .async_wait(wait_for_one(), use_awaitable_t{}); if (order[0] == 0) { if (!ex0) co_return std::variant{std::in_place_index<0>, std::move(detail::awaitable_unwrap(r0))}; std::rethrow_exception(ex0); } else { if (!ex1) co_return std::variant{std::in_place_index<1>, std::move(detail::awaitable_unwrap(r1))}; std::rethrow_exception(ex1); } } //! Wait for one operation to succeed. /** * If one operations succeeds, the other is cancelled as the OR-condition is * already satisfied. */ template awaitable, Executor> operator||(awaitable, Executor> t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1] = co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, std::move(u), deferred)) .async_wait(wait_for_one(), use_awaitable_t{}); using widen = detail::widen_variant; if (order[0] == 0) { if (!ex0) co_return widen::template call<0>(detail::awaitable_unwrap>(r0)); std::rethrow_exception(ex0); } else { if (!ex1) co_return std::variant{std::in_place_index}; std::rethrow_exception(ex1); } } //! Wait for one operation to succeed. /** * If one operations succeeds, the other is cancelled as the OR-condition is * already satisfied. */ template awaitable, Executor> operator||(awaitable, Executor> t, awaitable u) { auto ex = co_await this_coro::executor; auto [order, ex0, r0, ex1, r1] = co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred), co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)) .async_wait(wait_for_one(), use_awaitable_t{}); using widen = detail::widen_variant; if (order[0] == 0) { if (!ex0) co_return widen::template call<0>(detail::awaitable_unwrap>(r0)); std::rethrow_exception(ex0); } else { if (!ex1) { co_return std::variant{std::in_place_index, std::move(detail::awaitable_unwrap(r1))}; } std::rethrow_exception(ex1); } } } // namespace silkworm::concurrency::awaitable_wait_for_one ================================================ FILE: silkworm/infra/concurrency/base_service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm { template using BaseService = boost::asio::detail::execution_context_service_base; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/cancellation_token.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { class CancellationToken { public: bool is_cancelled() const { return cancelled_; } template bool assign(CancellationHandler&& handler) { std::unique_lock lock{cancellation_mutex_}; if (cancelled_) { return true; } cancellation_signal_.slot().assign(std::forward(handler)); lock.unlock(); cancellation_available_.notify_all(); return false; } bool clear() { std::unique_lock lock{cancellation_mutex_}; if (cancelled_) { return false; } cancellation_signal_.slot().clear(); return true; } void signal_cancellation() { std::unique_lock lock{cancellation_mutex_}; cancellation_available_.wait(lock, [&] { return cancellation_signal_.slot().has_handler(); }); cancellation_signal_.emit(boost::asio::cancellation_type::all); cancelled_ = true; } private: //! The mutual exclusion access to the cancellation signal std::mutex cancellation_mutex_; //! The signal used to cancel the register-and-receive stream loop boost::asio::cancellation_signal cancellation_signal_; //! The condition variable signaling that cancellation is possible std::condition_variable cancellation_available_; //! Flag indicating that the stream has been cancelled bool cancelled_{false}; }; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/channel.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "task.hpp" #include #include #include #include #include #include #include namespace silkworm::concurrency { template class Channel { public: explicit Channel(const boost::asio::any_io_executor& executor) : channel_(executor) {} Channel(const boost::asio::any_io_executor& executor, size_t max_buffer_size) : channel_(executor, max_buffer_size) {} Task send(T value) { try { co_await channel_.async_send(boost::system::error_code(), value, boost::asio::use_awaitable); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::asio::experimental::error::channel_cancelled) { throw boost::system::system_error(make_error_code(boost::system::errc::operation_canceled)); } throw; } } bool try_send(T value) { return channel_.try_send(boost::system::error_code(), value); } Task receive() { try { co_return (co_await channel_.async_receive(boost::asio::use_awaitable)); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::asio::experimental::error::channel_cancelled) { throw boost::system::system_error(make_error_code(boost::system::errc::operation_canceled)); } throw; } } std::optional try_receive() { std::optional result; channel_.try_receive([&](const boost::system::error_code& error, T&& value) { if (error == boost::asio::experimental::error::channel_cancelled) { throw boost::system::system_error(make_error_code(boost::system::errc::operation_canceled)); } if (error) { throw boost::system::system_error(error); } result = std::move(value); }); return result; } void close() { channel_.close(); } private: boost::asio::experimental::concurrent_channel channel_; }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/channel_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "channel.hpp" #include #include #include #include #include namespace silkworm::concurrency { using namespace std::chrono_literals; using namespace boost::asio; TEST_CASE("Channel.close_and_send") { test_util::TaskRunner runner; Channel channel{runner.executor()}; channel.close(); // boost::asio::experimental::error::channel_errors::channel_closed CHECK_THROWS_AS(runner.run(channel.send(1)), boost::system::system_error); } TEST_CASE("Channel.close_and_receive") { test_util::TaskRunner runner; Channel channel{runner.executor()}; channel.close(); // boost::asio::experimental::error::channel_errors::channel_closed CHECK_THROWS_AS(runner.run(channel.receive()), boost::system::system_error); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/containers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once /* * Decisions about concurrent containers */ #include namespace silkworm { template using ConcurrentQueue = ThreadSafeQueue; // todo: use a better alternative from a known library (Intel oneTBB concurrent_queue?) } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/context_pool.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "context_pool.hpp" namespace silkworm::concurrency { std::ostream& operator<<(std::ostream& out, const Context& c) { out << c.to_string(); return out; } std::string Context::to_string() const { const auto& c = *this; std::stringstream out; out << "io_context: " << c.ioc() << " id: " << c.id(); return out.str(); } Context::Context(size_t context_id) : context_id_{context_id}, ioc_{std::make_shared()}, work_{boost::asio::make_work_guard(*ioc_)} {} void Context::execute_loop() { SILK_DEBUG << "Context execution loop start [" << std::this_thread::get_id() << "]"; ioc_->run(); SILK_DEBUG << "Context execution loop end [" << std::this_thread::get_id() << "]"; } void Context::stop() { ioc_->stop(); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/context_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::concurrency { //! Asynchronous scheduler running an execution loop. class Context { public: explicit Context(size_t context_id); virtual ~Context() = default; boost::asio::io_context* ioc() const noexcept { return ioc_.get(); } size_t id() const noexcept { return context_id_; } //! Execute the scheduler loop until stopped. virtual void execute_loop(); //! Stop the execution loop. void stop(); std::string to_string() const; protected: //! The unique scheduler identifier. size_t context_id_; //! The asio asynchronous event loop scheduler. std::shared_ptr ioc_; //! The work-tracking executor that keep the asio scheduler running. boost::asio::executor_work_guard work_; }; std::ostream& operator<<(std::ostream& out, const Context& c); //! Pool of \ref Context instances running as separate reactive schedulers. template class ContextPool : public ExecutorPool { using ExceptionHandler = std::function; public: explicit ContextPool(uint32_t num_contexts) : ContextPool{ContextPoolSettings{.num_contexts = num_contexts}} {} explicit ContextPool(ContextPoolSettings settings) { if (settings.num_contexts == 0) { throw std::logic_error("ContextPool size is 0"); } for (size_t i{0}; i < settings.num_contexts; ++i) { add_context(T{i}); } } ~ContextPool() override { SILK_TRACE << "ContextPool::~ContextPool START " << this; stop(); join(); SILK_TRACE << "ContextPool::~ContextPool END " << this; } ContextPool(const ContextPool&) = delete; ContextPool& operator=(const ContextPool&) = delete; //! Start one execution thread for each context. virtual void start() { SILK_TRACE << "ContextPool::start START"; // Create a pool of threads to run all the contexts (each context having 1 thread) for (size_t i{0}; i < contexts_.size(); ++i) { auto& context = contexts_[i]; context_threads_.create_thread([&, i = i]() { log::set_thread_name(("asio_ctx_s" + std::to_string(i)).c_str()); SILK_TRACE << "Thread start context[" << i << "] thread_id: " << std::this_thread::get_id(); try { context.execute_loop(); } catch (const std::exception& ex) { SILK_CRIT << "ContextPool context.execute_loop exception: " << ex.what(); exception_handler_(std::make_exception_ptr(ex)); } catch (...) { SILK_CRIT << "ContextPool context.execute_loop unexpected exception"; exception_handler_(std::current_exception()); } SILK_TRACE << "Thread end context[" << i << "] thread_id: " << std::this_thread::get_id(); }); SILK_TRACE << "ContextPool::start context[" << i << "] started: " << context.ioc(); } SILK_TRACE << "ContextPool::start END"; } //! Wait for termination of all execution threads. //!\warning This will block until \ref stop() is called. void join() { SILK_TRACE << "ContextPool::join START"; // Wait for all threads in the pool to exit. SILK_TRACE << "ContextPool::join joining..."; context_threads_.join(); SILK_TRACE << "ContextPool::join END"; } //! Stop all execution threads. This does *NOT* wait for termination: use \ref join() for that. void stop() { SILK_TRACE << "ContextPool::stop START"; if (!stopped_.exchange(true)) { // Explicitly stop all context runnable components for (size_t i{0}; i < contexts_.size(); ++i) { contexts_[i].stop(); SILK_TRACE << "ContextPool::stop context[" << i << "] stopped: " << contexts_[i].ioc(); } } SILK_TRACE << "ContextPool::stop END"; } //! Run one execution thread for each context waiting for termination of all execution threads. //!\warning This will block until \ref stop() is called. void run() { start(); join(); } size_t size() const { return contexts_.size(); } //! Use a round-robin scheme to choose the next context to use T& next_context() { // Increment the next index first to make sure that different calling threads get different contexts. size_t index = next_index_.fetch_add(1) % contexts_.size(); return contexts_[index]; } boost::asio::io_context& next_ioc() { const auto& context = next_context(); return *context.ioc(); } // ExecutorPool boost::asio::any_io_executor any_executor() override { return this->next_ioc().get_executor(); } ExecutorPool& as_executor_pool() { return *this; } void set_exception_handler(ExceptionHandler exception_handler) { exception_handler_ = std::move(exception_handler); } protected: ContextPool() = default; //! Add a new \ref T to the pool. const T& add_context(T&& context) { const auto num_contexts = contexts_.size(); contexts_.emplace_back(std::move(context)); SILK_TRACE << "ContextPool::add_context context[" << num_contexts << "] " << contexts_[num_contexts]; return contexts_[num_contexts]; } static void termination_handler(std::exception_ptr) { std::terminate(); } //! The pool of execution contexts. std::vector contexts_; //! The pool of threads running the execution contexts. boost::asio::detail::thread_group context_threads_; //! The index for obtaining next context to use (round-robin). std::atomic_size_t next_index_{0}; //! Flag indicating if pool has been stopped. std::atomic_bool stopped_{false}; //! Exception handler invoked on execution loop abnormal termination ExceptionHandler exception_handler_{termination_handler}; }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/context_pool_settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::concurrency { //! Default number of threads to use for I/O tasks inline const uint32_t kDefaultNumContexts{std::thread::hardware_concurrency() / 2}; //! The configuration settings for \refitem ContextPool struct ContextPoolSettings { uint32_t num_contexts{kDefaultNumContexts}; // The number of execution contexts to activate }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/context_pool_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "context_pool.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::concurrency { // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("Context", "[silkworm][concurrency][server_context]") { Context ctx{0}; SECTION("ServerContext") { CHECK(ctx.ioc() != nullptr); } SECTION("execute_loop") { boost::asio::executor_work_guard work = boost::asio::make_work_guard(*ctx.ioc()); std::atomic_bool context_thread_failed{false}; std::thread context_thread{[&]() { try { ctx.execute_loop(); } catch (...) { context_thread_failed = true; } }}; ctx.stop(); context_thread.join(); CHECK(!context_thread_failed); } SECTION("stop") { boost::asio::executor_work_guard work = boost::asio::make_work_guard(*ctx.ioc()); std::thread context_thread{[&]() { ctx.execute_loop(); }}; CHECK(!ctx.ioc()->stopped()); ctx.stop(); CHECK(ctx.ioc()->stopped()); context_thread.join(); ctx.stop(); CHECK(ctx.ioc()->stopped()); } SECTION("print") { CHECK_NOTHROW(test_util::null_stream() << ctx); } } TEST_CASE("ContextPool", "[silkworm][concurrency][Context]") { SECTION("ContextPool OK") { ContextPool context_pool{2}; CHECK(context_pool.size() == 2); } SECTION("ContextPool KO") { CHECK_THROWS_AS(ContextPool{0}, std::logic_error); } SECTION("next_context") { ContextPool context_pool{2}; auto& context1 = context_pool.next_context(); CHECK(context1.ioc() != nullptr); auto& context2 = context_pool.next_context(); CHECK(context2.ioc() != nullptr); } SECTION("next_ioc") { ContextPool context_pool{2}; auto& context1 = context_pool.next_context(); auto& context2 = context_pool.next_context(); CHECK(&context_pool.next_ioc() == context1.ioc()); CHECK(&context_pool.next_ioc() == context2.ioc()); } SECTION("start/stop w/ contexts") { ContextPool context_pool{2}; CHECK_NOTHROW(context_pool.start()); CHECK_NOTHROW(context_pool.stop()); } SECTION("join") { ContextPool context_pool{2}; context_pool.start(); std::thread joining_thread{[&]() { context_pool.join(); }}; context_pool.stop(); CHECK_NOTHROW(joining_thread.join()); } SECTION("join after stop") { ContextPool context_pool{2}; context_pool.start(); context_pool.stop(); CHECK_NOTHROW(context_pool.join()); } SECTION("start/stop/join w/ task enqueued") { ContextPool context_pool{2}; concurrency::spawn_future(context_pool.any_executor(), [&]() -> Task { co_await sleep(std::chrono::milliseconds(1'000)); }); context_pool.start(); context_pool.stop(); CHECK_NOTHROW(context_pool.join()); } SECTION("start/destroy w/ task enqueued") { ContextPool context_pool{2}; concurrency::spawn_future(context_pool.any_executor(), [&]() -> Task { co_await sleep(std::chrono::milliseconds(1'000)); }); context_pool.start(); } SECTION("stop/start w/ contexts") { ContextPool context_pool{2}; CHECK_NOTHROW(context_pool.stop()); CHECK_NOTHROW(context_pool.start()); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/coroutine.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #if __has_include() #include #include #elif __has_include() #include namespace std { template using coroutine_handle = std::experimental::coroutine_handle; using suspend_always = std::experimental::suspend_always; using suspend_never = std::experimental::suspend_never; } // namespace std #else #error "no coroutines support" #endif // __has_include() ================================================ FILE: silkworm/infra/concurrency/coroutine_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "coroutine.hpp" #include #include #include #include #include namespace silkworm::concurrency { using namespace boost::asio; Task coroutine_return_123() { co_return 123; } TEST_CASE("check configuration", "[silkworm][infra][concurrency]") { #if __has_include() #ifdef BOOST_ASIO_HAS_CO_AWAIT CHECK(true); #else CHECK(false); #endif // BOOST_ASIO_HAS_CO_AWAIT #ifdef BOOST_ASIO_HAS_STD_COROUTINE CHECK(true); #else CHECK(false); #endif // BOOST_ASIO_HAS_STD_COROUTINE #endif // __has_include() CHECK(&typeid(std::coroutine_handle) != nullptr); CHECK(&typeid(std::suspend_always) != nullptr); CHECK(&typeid(std::suspend_never) != nullptr); } TEST_CASE("coroutine co_return", "[silkworm][infra][concurrency]") { io_context ioc; auto task = co_spawn( ioc, coroutine_return_123(), boost::asio::use_future); size_t work_count{0}; do { work_count = ioc.poll_one(); } while (work_count > 0); CHECK(task.get() == 123); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/event_notifier.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "task.hpp" #include #include "channel.hpp" namespace silkworm::concurrency { // A simplified condition variable similar to Rust Tokio Notify: // https://docs.rs/tokio/1.25.0/tokio/sync/struct.Notify.html // Only one waiter is supported. class EventNotifier { public: explicit EventNotifier(const boost::asio::any_io_executor& executor) : channel_(executor, 1) {} Task wait() { co_await channel_.receive(); } void notify() { channel_.try_send({}); } private: Channel channel_; }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/executor_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::concurrency { struct ExecutorPool { virtual ~ExecutorPool() = default; virtual boost::asio::any_io_executor any_executor() = 0; }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/parallel_group_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include using namespace boost::asio; using namespace boost::asio::experimental; using namespace silkworm::concurrency; using namespace std::chrono_literals; awaitable my_sleep(std::chrono::milliseconds duration) { auto executor = co_await this_coro::executor; steady_timer timer(executor); timer.expires_after(duration); co_await timer.async_wait(use_awaitable); } awaitable noop() { co_return; } awaitable throw_op() { co_await my_sleep(1ms); throw std::runtime_error("throw_op"); } awaitable spawn_throw_op(strand& strand) { co_await spawn_task(strand, throw_op()); } awaitable spawn_noop_loop(strand& strand) { while (true) { co_await spawn_task(strand, noop()); } } awaitable co_spawn_cancellation_handler_bug() { using namespace awaitable_wait_for_all; auto executor = co_await boost::asio::this_coro::executor; auto strand = make_strand(executor); try { co_await (my_sleep(1s) && spawn_throw_op(strand) && spawn_noop_loop(strand)); } catch (std::runtime_error&) { } } TEST_CASE("parallel_group.co_spawn_cancellation_handler_bug") { io_context ioc; spawn_future(ioc, co_spawn_cancellation_handler_bug()); ioc.run(); } ================================================ FILE: silkworm/infra/concurrency/parallel_group_utils.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "parallel_group_utils.hpp" #include #include #include #include #include #include #include #include namespace silkworm::concurrency { using namespace boost::asio; using namespace boost::asio::experimental; static bool is_operation_cancelled_error(const std::exception_ptr& ex_ptr) { try { std::rethrow_exception(ex_ptr); } catch (const boost::system::system_error& e) { return (e.code() == boost::system::errc::operation_canceled); } catch (...) { return false; } } void rethrow_first_exception_if_any( const std::array& exceptions, const std::array& order) { const auto& ex0 = exceptions[0]; const auto& ex1 = exceptions[1]; // no exceptions if (!ex0 && !ex1) { return; } // only 1 exception if (!ex0) { std::rethrow_exception(ex1); } if (!ex1) { std::rethrow_exception(ex0); } // 2 exceptions, but one of them is an expected operation_canceled caused by aborting a pending branch if (is_operation_cancelled_error(ex0)) { std::rethrow_exception(ex1); } if (is_operation_cancelled_error(ex1)) { std::rethrow_exception(ex0); } // 2 unexpected exceptions // This is possible if operation_canceled is handled inside a pending operation, // but the catch block throws a different error. // ex0 was first if (order[0] == 0) { try { std::rethrow_exception(ex1); } catch (const std::runtime_error& ex1_ref) { try { std::rethrow_exception(ex0); } catch (...) { std::throw_with_nested(ex1_ref); } } } // ex1 was first else { try { std::rethrow_exception(ex0); } catch (const std::runtime_error& ex0_ref) { try { std::rethrow_exception(ex1); } catch (...) { std::throw_with_nested(ex0_ref); } } } } void rethrow_first_exception_if_any( const std::vector& exceptions, const std::vector& order) { std::exception_ptr first_cancelled_exception; for (size_t i : order) { const auto& ex = exceptions[i]; if (ex) { if (!is_operation_cancelled_error(ex)) { std::rethrow_exception(ex); } else if (!first_cancelled_exception) { first_cancelled_exception = ex; } } } if (first_cancelled_exception) { std::rethrow_exception(first_cancelled_exception); } } Task generate_parallel_group_task(size_t count, absl::FunctionRef(size_t)> task_factory) { if (count == 0) { co_return; } auto executor = co_await this_coro::executor; using OperationType = decltype(co_spawn(executor, ([]() -> Task { co_return; })(), deferred)); std::vector operations; operations.reserve(count); for (size_t i = 0; i < count; ++i) { operations.push_back(co_spawn(executor, task_factory(i), deferred)); } auto group = make_parallel_group(std::move(operations)); // std::vector order; // std::vector exceptions; auto [order, exceptions] = co_await group.async_wait(wait_for_one_error(), use_awaitable); rethrow_first_exception_if_any(exceptions, order); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/parallel_group_utils.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "task.hpp" #include namespace silkworm::concurrency { /** * Given 2 exceptions rethrows the one which happened first that was unexpected. * * "Unexpected" can be anything except boost::system::errc::operation_canceled. * If all exceptions are operation_canceled, throws one to propagate cancellation. * Does not throw with no exceptions (if all exception_ptr are null). */ void rethrow_first_exception_if_any( const std::array& exceptions, const std::array& order); /** * Given some exceptions rethrows the one which happened first that was unexpected. * * "Unexpected" can be anything except boost::system::errc::operation_canceled. * If all exceptions are operation_canceled, throws one to propagate cancellation. * Does not throw with no exceptions (if all exception_ptr are null). */ void rethrow_first_exception_if_any( const std::vector& exceptions, const std::vector& order); /** * Build a ranged `parallel_group` task consisting of `count` subtasks produced by `task_factory`: * [task_factory(0), task_factory(1), ... task_factory(count - 1)]. * If one of the subtasks throws, the rest are cancelled and the exception is rethrown. */ Task generate_parallel_group_task(size_t count, absl::FunctionRef(size_t)> task_factory); } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/private_service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm { template class PrivateService : public BaseService> { public: explicit PrivateService(boost::asio::execution_context& owner) : BaseService(owner) {} void shutdown() override { unique_.reset(); } //! Explicitly *take ownership* of \code std::unique_ptr to enforce isolation void set_unique(std::unique_ptr unique) { unique_ = std::move(unique); } T* ptr() { return unique_.get(); } private: std::unique_ptr unique_; }; template void add_private_service(boost::asio::execution_context& context, std::unique_ptr unique) { if (!has_service>(context)) { make_service>(context); } use_service>(context).set_unique(std::move(unique)); } template T* use_private_service(boost::asio::execution_context& context) { if (!has_service>(context)) { return nullptr; } return use_service>(context).ptr(); } template T* must_use_private_service(boost::asio::execution_context& context) { if (!has_service>(context)) { throw std::logic_error{"unregistered private service: " + std::string{typeid(T).name()}}; } return use_service>(context).ptr(); } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/private_service_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "private_service.hpp" #include #include namespace silkworm { TEST_CASE("PrivateService", "[silkworm][infra][concurrency][services]") { struct Integer { explicit Integer(int value) : value_(value) {} int value() const { return value_; } private: int value_{0}; }; boost::asio::io_context ioc; SECTION("register service") { CHECK(!use_private_service(ioc)); CHECK_THROWS_AS(must_use_private_service(ioc), std::logic_error); CHECK_NOTHROW(add_private_service(ioc, std::make_unique(1))); CHECK(use_private_service(ioc)->value() == 1); CHECK(must_use_private_service(ioc)->value() == 1); } SECTION("register service twice") { CHECK(!use_private_service(ioc)); CHECK_THROWS_AS(must_use_private_service(ioc), std::logic_error); CHECK_NOTHROW(add_private_service(ioc, std::make_unique(1))); CHECK(use_private_service(ioc)->value() == 1); CHECK(must_use_private_service(ioc)->value() == 1); CHECK_NOTHROW(add_private_service(ioc, std::make_unique(2))); CHECK(use_private_service(ioc)->value() == 2); CHECK(must_use_private_service(ioc)->value() == 2); } SECTION("register and lookup with same type") { class A {}; class B : public A {}; CHECK(!use_private_service(ioc)); CHECK(!use_private_service(ioc)); CHECK_THROWS_AS(must_use_private_service(ioc), std::logic_error); CHECK_THROWS_AS(must_use_private_service(ioc), std::logic_error); CHECK_NOTHROW(add_private_service(ioc, std::make_unique())); CHECK(!use_private_service(ioc)); CHECK_THROWS_AS(must_use_private_service(ioc), std::logic_error); CHECK(use_private_service(ioc)); CHECK(must_use_private_service(ioc)); CHECK_NOTHROW(add_private_service(ioc, std::make_unique())); CHECK(use_private_service(ioc)); CHECK(must_use_private_service(ioc)); } } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/shared_service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { template class SharedService : public BaseService> { public: explicit SharedService(boost::asio::execution_context& owner) : BaseService(owner) {} void shutdown() override { shared_.reset(); } //! Explicitly make a *copy* of \code std::shared_ptr to be thread-safe void set_shared(std::shared_ptr shared) { shared_ = std::move(shared); } T* ptr() { return shared_.get(); } private: std::shared_ptr shared_; }; template void add_shared_service(boost::asio::execution_context& context, std::shared_ptr shared) { if (!has_service>(context)) { make_service>(context); } use_service>(context).set_shared(std::move(shared)); } template T* use_shared_service(boost::asio::execution_context& context) { if (!has_service>(context)) { return nullptr; } return use_service>(context).ptr(); } template T* must_use_shared_service(boost::asio::execution_context& context) { if (!has_service>(context)) { throw std::logic_error{"unregistered shared service: " + std::string{typeid(T).name()}}; } return use_service>(context).ptr(); } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/shared_service_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "shared_service.hpp" #include #include namespace silkworm { TEST_CASE("SharedService", "[silkworm][infra][concurrency][services]") { struct Integer { explicit Integer(int value) : value_(value) {} int value() const { return value_; } private: int value_{0}; }; boost::asio::io_context ioc1; boost::asio::io_context ioc2; SECTION("register service") { CHECK(!use_shared_service(ioc1)); CHECK(!use_shared_service(ioc2)); CHECK_THROWS_AS(must_use_shared_service(ioc1), std::logic_error); CHECK_THROWS_AS(must_use_shared_service(ioc2), std::logic_error); auto shared_integer = std::make_shared(1); CHECK_NOTHROW(add_shared_service(ioc1, shared_integer)); CHECK_NOTHROW(add_shared_service(ioc2, shared_integer)); CHECK(use_shared_service(ioc1)->value() == 1); CHECK(use_shared_service(ioc2)->value() == 1); CHECK(must_use_shared_service(ioc1)->value() == 1); CHECK(must_use_shared_service(ioc2)->value() == 1); } SECTION("register service twice") { CHECK(!use_shared_service(ioc1)); CHECK(!use_shared_service(ioc2)); CHECK_THROWS_AS(must_use_shared_service(ioc1), std::logic_error); CHECK_THROWS_AS(must_use_shared_service(ioc2), std::logic_error); auto shared_integer_1 = std::make_shared(1); auto shared_integer_2 = std::make_shared(2); CHECK_NOTHROW(add_shared_service(ioc1, shared_integer_1)); CHECK_NOTHROW(add_shared_service(ioc2, shared_integer_1)); CHECK(use_shared_service(ioc1)->value() == 1); CHECK(use_shared_service(ioc2)->value() == 1); CHECK(must_use_shared_service(ioc1)->value() == 1); CHECK(must_use_shared_service(ioc2)->value() == 1); CHECK_NOTHROW(add_shared_service(ioc1, shared_integer_2)); CHECK_NOTHROW(add_shared_service(ioc2, shared_integer_2)); CHECK(use_shared_service(ioc1)->value() == 2); CHECK(use_shared_service(ioc2)->value() == 2); CHECK(must_use_shared_service(ioc1)->value() == 2); CHECK(must_use_shared_service(ioc2)->value() == 2); } } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/signal_handler.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "signal_handler.hpp" #include #include #include #include #include namespace silkworm { static const char* sig_name(int sig_code) { switch (sig_code) { case SIGSEGV: return "SIGSEGV"; #if defined(__linux__) || defined(__APPLE__) case SIGBUS: return "SIGBUS"; case SIGSYS: return "SIGSYS"; #endif case SIGFPE: return "SIGFPE"; case SIGILL: return "SIGILL"; #if defined(__linux__) || defined(__APPLE__) case SIGTRAP: return "SIGTRAP"; #endif #if defined(SIGBREAK) case SIGBREAK: return "SIGBREAK"; #endif #if defined(__linux__) || defined(__APPLE__) case SIGQUIT: return "SIGQUIT"; #if defined(SIGSTP) case SIGSTP: return "SIGSTP"; #endif case SIGSTOP: return "SIGSTOP"; case SIGKILL: return "SIGKILL"; #endif case SIGABRT: return "SIGABRT"; #if defined(SIGABRT_COMPAT) case SIGABRT_COMPAT: return "SIGABRT_COMPAT"; #endif case SIGINT: return "SIGINT"; case SIGTERM: return "SIGTERM"; #if defined(__linux__) || defined(__APPLE__) case SIGVTALRM: return "SIGVTALRM"; case SIGXFSZ: return "SIGXFZS"; case SIGXCPU: return "SIGXCPU"; case SIGHUP: return "SIGHUP"; case SIGALRM: return "SIGALRM"; case SIGUSR1: return "SIGUSR1"; case SIGUSR2: return "SIGUSR2"; #endif default: return "Unknown"; } } inline constexpr int kHandleableCodes[] { #if defined(SIGBREAK) SIGBREAK, // Windows keyboard CTRL+Break #endif #if defined(__linux__) || defined(__APPLE__) SIGQUIT, // CTRL+\ (like CTRL+C but also generates a coredump) SIGTSTP, // CTRL+Z to interrupt a process #endif SIGINT, // Keyboard CTRL+C SIGTERM // Termination request (kill/killall default) }; std::atomic_uint32_t SignalHandler::sig_count_{0}; std::atomic_int SignalHandler::sig_code_{0}; std::atomic_bool SignalHandler::signalled_{false}; std::function SignalHandler::custom_handler_; bool SignalHandler::silent_{false}; using SignalHandlerFunc = void (*)(int); std::map previous_signal_handlers; static SignalHandlerFunc register_signal_action(const int sig_code, SignalHandlerFunc handler_func) { #ifdef _WIN32 return signal(sig_code, handler_func); #else struct sigaction sa {}; sa.sa_handler = handler_func; sa.sa_flags = SA_ONSTACK; sigfillset(&sa.sa_mask); struct sigaction previous_sa {}; const int result = ::sigaction(sig_code, &sa, &previous_sa); if (result == -1) { return SIG_ERR; } return previous_sa.sa_handler; #endif // _WIN32 } void SignalHandler::init(std::function custom_handler, bool silent) { for (const int sig_code : kHandleableCodes) { // Register our signal handler and remember the existing ones auto previous_handler{register_signal_action(sig_code, &SignalHandler::handle)}; if (previous_handler != SIG_ERR) { previous_signal_handlers[sig_code] = previous_handler; } } custom_handler_ = std::move(custom_handler); silent_ = silent; } void SignalHandler::handle(int sig_code) { bool expected{false}; if (signalled_.compare_exchange_strong(expected, true)) { sig_code_ = sig_code; if (!silent_) { (void)std::fputs("\nGot ", stderr); (void)std::fputs(sig_name(sig_code), stderr); (void)std::fputs(". Shutting down ...\n", stderr); } } uint32_t sig_count = ++sig_count_; if (sig_count >= 10) { std::abort(); } if (sig_count > 1 && !silent_) { (void)std::fputs("Already shutting down. Interrupt more to panic. ", stderr); char digit_with_endl[3]; digit_with_endl[0] = static_cast('0' + (10 - sig_count)); digit_with_endl[1] = '\n'; digit_with_endl[2] = '\0'; (void)std::fputs(digit_with_endl, stderr); } if (custom_handler_) { custom_handler_(sig_code); } if (register_signal_action(sig_code, &SignalHandler::handle) == SIG_ERR) { // Re-enable the hook (void)std::fputs("Failed to re-enable signal hook :(", stderr); } } void SignalHandler::reset() { signalled_ = false; sig_count_ = 0; // Restore any previous signal handlers for (const int sig_code : kHandleableCodes) { if (previous_signal_handlers.contains(sig_code)) { if (register_signal_action(sig_code, previous_signal_handlers[sig_code]) == SIG_ERR) { (void)std::fputs("Failed to restore previous signal handlers :(", stderr); } } } } void SignalHandler::throw_if_signalled() { if (!signalled()) { return; } throw std::runtime_error(sig_name(sig_code_)); } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/signal_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { //! \brief Handler for system signals using static storage class SignalHandler { public: //! Register its own signal handling hook (previous handlers are saved) static void init(std::function custom_handler = {}, bool silent = false); //! Handle incoming signal static void handle(int sig_code); //! Whether any signal has been intercepted or not static bool signalled() { return signalled_; } //! Reset to un-signalled state (restore previous signal handlers) static void reset(); //! Throw std::runtime_error if in signalled state static void throw_if_signalled(); private: //! Last signal code which raised the signalled state static std::atomic_int sig_code_; //! Number of signals intercepted static std::atomic_uint32_t sig_count_; //! Whether a signal has been intercepted static std::atomic_bool signalled_; //! Custom handling static std::function custom_handler_; //! Flag indicating if signal handler can write on standard streams or not static bool silent_; }; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/signal_handler_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include namespace silkworm { #if !defined(__APPLE__) || defined(NDEBUG) static const std::vector kSignalNumbers{SIGINT, SIGTERM}; TEST_CASE("SignalHandler") { for (const auto sig_number : kSignalNumbers) { SECTION("signal number: " + std::to_string(sig_number)) { SignalHandler::init({}, /*silent=*/true); REQUIRE(std::raise(sig_number) == 0); CHECK(SignalHandler::signalled()); SignalHandler::reset(); CHECK_FALSE(SignalHandler::signalled()); } } } TEST_CASE("SignalHandler: custom handler") { for (const auto sig_number : kSignalNumbers) { SECTION("signal number: " + std::to_string(sig_number)) { auto custom_handler = [sig_number](int sig_code) { CHECK(sig_code == sig_number); }; SignalHandler::init(custom_handler, /*silent=*/true); REQUIRE(std::raise(sig_number) == 0); CHECK(SignalHandler::signalled()); SignalHandler::reset(); CHECK_FALSE(SignalHandler::signalled()); } } } #endif // !defined(__APPLE__) || defined(NDEBUG) } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/sleep.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "sleep.hpp" #include #include #include namespace silkworm { using namespace boost::asio; Task sleep(std::chrono::milliseconds duration) { auto executor = co_await this_coro::executor; steady_timer timer(executor); timer.expires_after(duration); co_await timer.async_wait(use_awaitable); } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/sleep.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { Task sleep(std::chrono::milliseconds duration); } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/spawn.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::concurrency { template concept AsioExecutor = boost::asio::is_executor::value || boost::asio::execution::is_executor::value; template concept AsioExecutionContext = std::is_convertible_v; template auto spawn_task(const Executor& ex, F&& f) { return boost::asio::co_spawn(ex, std::forward(f), boost::asio::use_awaitable); } template auto spawn_task(ExecutionContext& ctx, F&& f) { return boost::asio::co_spawn(ctx, std::forward(f), boost::asio::use_awaitable); } template auto spawn_future(const Executor& ex, F&& f) { return boost::asio::co_spawn(ex, std::forward(f), boost::asio::use_future); } template auto spawn_future(ExecutionContext& ctx, F&& f) { return boost::asio::co_spawn(ctx, std::forward(f), boost::asio::use_future); } template auto spawn_future_and_wait(const Executor& ex, F&& f) { return spawn_future(ex, std::forward(f)).get(); } template auto spawn_future_and_wait(ExecutionContext& ctx, F&& f) { return spawn_future(ctx, std::forward(f)).get(); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/spawn_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "spawn.hpp" #include #include #include #include #include #include #include #include namespace silkworm::concurrency { namespace asio = boost::asio; Task dummy_task() { auto executor = co_await asio::this_coro::executor; asio::steady_timer timer{executor}; timer.expires_after(std::chrono::milliseconds(1)); co_await timer.async_wait(asio::use_awaitable); } class DummyEngine { asio::io_context& ioc_; public: explicit DummyEngine(asio::io_context& ioc) : ioc_{ioc} {} static Task do_work() { co_return 42; } asio::io_context& get_executor() { return ioc_; } }; struct SpawnTest { SpawnTest() { ioc_thread = std::thread{[this]() { ioc.run(); }}; } ~SpawnTest() { ioc.stop(); if (ioc_thread.joinable()) { ioc_thread.join(); } } asio::io_context ioc; asio::executor_work_guard work_guard{ioc.get_executor()}; std::thread ioc_thread; }; TEST_CASE_METHOD(SpawnTest, "spawn_and_wait") { SECTION("wait for function") { CHECK_NOTHROW(spawn_future_and_wait(ioc, dummy_task())); } SECTION("wait for method") { DummyEngine engine{ioc}; CHECK(spawn_future_and_wait(engine.get_executor(), DummyEngine::do_work()) == 42); } } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/stoppable.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { //! \brief Components implementing stop-ability should derive from this class Stoppable { public: //! \brief Sets a stop request for instance; //! \return True if the stop request has been triggered otherwise false (i.e. was already stopping) virtual bool stop() { bool expected{false}; return stopping_.compare_exchange_strong(expected, true); } //! \brief Whether a stop request has been issued bool is_stopping() { return stopping_.load() || SignalHandler::signalled(); } virtual ~Stoppable() = default; private: std::atomic_bool stopping_{false}; }; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/stoppable_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include namespace silkworm { TEST_CASE("Stoppable") { silkworm::Stoppable stoppable{}; REQUIRE(stoppable.is_stopping() == false); REQUIRE(stoppable.stop() == true); REQUIRE(stoppable.stop() == false); REQUIRE(stoppable.is_stopping() == true); } } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/task.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include /// Use just \silkworm as namespace here to make these definitions available everywhere /// So that we can write Task foo(); instead of concurrency::Task foo(); namespace silkworm { //! Asynchronous task returned by any coroutine, i.e. asynchronous operation template using Task = boost::asio::awaitable; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/task_group.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "task_group.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::concurrency { using namespace boost::asio; void TaskGroup::spawn(const any_io_executor& executor, Task task) { std::scoped_lock lock(mutex_); if (is_closed_) { throw SpawnAfterCloseError(); } if (tasks_.size() == max_tasks_) { throw MaxTasksReachedError(max_tasks_); } auto task_id = ++last_task_id_; auto [it, ok] = tasks_.emplace( std::piecewise_construct, std::forward_as_tuple(task_id), std::forward_as_tuple()); SILKWORM_ASSERT(ok); auto cancellation_slot = it->second.slot(); auto completion = [this, task_id](const std::exception_ptr& ex_ptr) { this->on_complete(task_id, ex_ptr); }; co_spawn(executor, std::move(task), bind_cancellation_slot(cancellation_slot, completion)); } Task TaskGroup::wait() { // wait until cancelled or a task throws an exception std::exception_ptr ex_ptr; try { ex_ptr = co_await exceptions_.receive(); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) { ex_ptr = std::current_exception(); } else { SILK_ERROR << "TaskGroup::wait system_error: " << ex.what(); throw; } } co_await this_coro::reset_cancellation_state(); close(); // wait for all tasks completions while (!is_completed()) { auto [completed_task_id, result_ex_ptr] = co_await completions_.receive(); { std::scoped_lock lock(mutex_); tasks_.erase(completed_task_id); } if (result_ex_ptr) { ex_ptr = result_ex_ptr; } } std::rethrow_exception(ex_ptr); } void TaskGroup::close() { std::scoped_lock lock(mutex_); is_closed_ = true; for (auto& [task_id, canceller] : tasks_) { canceller.emit(cancellation_type::all); } } static bool is_operation_cancelled_error(const std::exception_ptr& ex_ptr) { try { std::rethrow_exception(ex_ptr); } catch (const boost::system::system_error& e) { return (e.code() == boost::system::errc::operation_canceled); } catch (...) { return false; } } void TaskGroup::on_complete(size_t task_id, const std::exception_ptr& ex_ptr) { bool is_cancelled = ex_ptr && is_operation_cancelled_error(ex_ptr); std::scoped_lock lock(mutex_); if (is_closed_) { // if a task threw during cancellation - rethrow from wait() auto result_ex_ptr = (ex_ptr && !is_cancelled) ? ex_ptr : std::exception_ptr{}; const bool ok = completions_.try_send({task_id, result_ex_ptr}); if (!ok) { throw std::runtime_error("TaskGroup::on_complete: completions queue is full, unexpected max_tasks limit breach"); } } else { tasks_.erase(task_id); // if a task threw - rethrow from wait() if (ex_ptr && !is_cancelled) { exceptions_.try_send(ex_ptr); } } } bool TaskGroup::is_completed() { std::scoped_lock lock(mutex_); return is_closed_ && tasks_.empty(); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/task_group.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "task.hpp" #include #include #include namespace silkworm::concurrency { /** * TaskGroup is a limited version of a dynamic parallel_group (which asio lacks). * * The parallel_group (and awaitable_wait_for_all/awaitable_wait_for_one that are built on top of it) * supports "structured concurrency" approach for a fixed set of tasks. * If the number of tasks is not fixed, the only asio option is to use co_spawn(asio::detached), * but this violates the "structured concurrency" principle. * * TaskGroup works similarly to co_spawn(asio::detached), but keeps track of the spawned tasks. * When cancellation starts, TaskGroup gracefully cancels the tasks. * * Example: * * \code * * TaskGroup task_group{executor, 10}; * * Task run_server() { * co_await (accept_connections() && task_group.wait()); * } * * Task accept_connections() { * auto connection = accept(); * if (num_clients < 10) { * ++num_clients; * task_group.spawn(executor, handle_connection(std::move(connection))); * } * } * * \endcode * * \see https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/ */ class TaskGroup { public: TaskGroup(const boost::asio::any_io_executor& executor, size_t max_tasks) : max_tasks_(max_tasks), completions_(executor, max_tasks), exceptions_(executor, 1) {} TaskGroup(const TaskGroup&) = delete; TaskGroup& operator=(const TaskGroup&) = delete; class SpawnAfterCloseError : public std::runtime_error { public: SpawnAfterCloseError() : std::runtime_error("TaskGroup can't spawn after it was closed") {} }; class MaxTasksReachedError : public std::runtime_error { public: explicit MaxTasksReachedError(size_t max_tasks) : std::runtime_error("TaskGroup can't spawn more than " + std::to_string(max_tasks) + " tasks") {} }; //! Similar to co_spawn, but also adds the task to this group until it completes. void spawn(const boost::asio::any_io_executor& executor, Task task); //! Waits until a cancellation signal. then cancels all pending tasks, and waits for them to complete. Task wait(); private: void close(); void on_complete(size_t task_id, const std::exception_ptr& ex_ptr); bool is_completed(); std::mutex mutex_; bool is_closed_{false}; size_t last_task_id_{0}; std::map tasks_; size_t max_tasks_{0}; concurrency::Channel> completions_; concurrency::Channel exceptions_; }; } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/task_group_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "task_group.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::concurrency { using namespace boost::asio; using namespace std::chrono_literals; using namespace awaitable_wait_for_all; static Task async_ok() { co_await this_coro::executor; } class TestException : public std::runtime_error { public: TestException() : std::runtime_error("TestException") {} }; static Task async_throw() { co_await this_coro::executor; throw TestException(); } static Task wait_until_cancelled(bool& is_cancelled) { try { auto executor = co_await this_coro::executor; steady_timer timer(executor); timer.expires_after(1h); co_await timer.async_wait(use_awaitable); } catch (const boost::system::system_error&) { is_cancelled = true; } } static Task sleep(std::chrono::milliseconds duration) { auto executor = co_await this_coro::executor; steady_timer timer(executor); timer.expires_after(duration); co_await timer.async_wait(use_awaitable); } TEST_CASE("TaskGroup.0") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 0}; CHECK_THROWS_AS(runner.run(group.wait() && async_throw()), TestException); } TEST_CASE("TaskGroup.1") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 1}; group.spawn(executor, async_ok()); CHECK_THROWS_AS(runner.run(group.wait() && async_throw()), TestException); } TEST_CASE("TaskGroup.1.wait_until_cancelled") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 1}; bool is_cancelled = false; group.spawn(executor, wait_until_cancelled(is_cancelled)); CHECK_THROWS_AS(runner.run(group.wait() && async_throw()), TestException); CHECK(is_cancelled); } TEST_CASE("TaskGroup.some.wait_until_cancelled") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 3}; std::array is_cancelled{}; group.spawn(executor, wait_until_cancelled(is_cancelled[0])); group.spawn(executor, wait_until_cancelled(is_cancelled[1])); group.spawn(executor, wait_until_cancelled(is_cancelled[2])); CHECK_THROWS_AS(runner.run(group.wait() && async_throw()), TestException); CHECK(is_cancelled[0]); CHECK(is_cancelled[1]); CHECK(is_cancelled[2]); } TEST_CASE("TaskGroup.some.mix") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 6}; std::array is_cancelled{}; group.spawn(executor, async_ok()); group.spawn(executor, wait_until_cancelled(is_cancelled[0])); group.spawn(executor, async_ok()); group.spawn(executor, wait_until_cancelled(is_cancelled[1])); group.spawn(executor, async_ok()); group.spawn(executor, wait_until_cancelled(is_cancelled[2])); CHECK_THROWS_AS(runner.run(group.wait() && async_throw()), TestException); CHECK(is_cancelled[0]); CHECK(is_cancelled[1]); CHECK(is_cancelled[2]); } TEST_CASE("TaskGroup.spawn_after_close") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 1}; CHECK_THROWS_AS(runner.run(group.wait() && async_throw()), TestException); CHECK_THROWS_AS(group.spawn(executor, async_ok()), TaskGroup::SpawnAfterCloseError); } TEST_CASE("TaskGroup.task_exception_is_rethrown") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 1}; group.spawn(executor, async_throw()); auto test = [&]() -> Task { try { co_await group.wait(); co_return false; } catch (const TestException&) { co_return true; } }; CHECK(runner.run(test())); } TEST_CASE("TaskGroup.task_cancelled_exception_is_ignored") { using namespace awaitable_wait_for_one; test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 1}; auto task = [&]() -> Task { co_await boost::asio::this_coro::executor; throw boost::system::system_error(make_error_code(boost::system::errc::operation_canceled)); }; group.spawn(executor, task()); CHECK_NOTHROW(runner.run(group.wait() || sleep(1ms))); } TEST_CASE("TaskGroup.task_exception_during_cancellation_is_rethrown") { test_util::TaskRunner runner; auto executor = runner.executor(); TaskGroup group{executor, 2}; auto task = [&]() -> Task { bool is_cancelled = false; co_await wait_until_cancelled(is_cancelled); if (is_cancelled) { throw std::runtime_error("exception_during_cancellation"); } }; group.spawn(executor, task()); group.spawn(executor, async_throw()); auto test = [&]() -> Task { try { co_await group.wait(); co_return false; } catch (const TestException&) { co_return false; } catch (const std::runtime_error& ex) { co_return (ex.what() == std::string_view{"exception_during_cancellation"}); } }; CHECK(runner.run(test())); } TEST_CASE("TaskGroup.avoid_max_tasks_limit_breach") { log::init(log::Settings{ .log_std_out = true, .log_nocolor = true, .log_threads = true, .log_verbosity = log::Level::kInfo, }); test_util::TaskRunner runner; auto executor = runner.executor(); const size_t max_tasks = 10; TaskGroup group{executor, max_tasks}; auto task = [&]() -> Task { bool is_cancelled = false; co_await wait_until_cancelled(is_cancelled); if (is_cancelled) { throw std::runtime_error("exception_during_cancellation"); } }; // Spawn max_tasks tasks for (size_t i = 0; i < max_tasks; ++i) { REQUIRE_NOTHROW(group.spawn(executor, task())); } // Trying to spawn one more *must* trigger MaxTasksReachedError exception CHECK_THROWS_AS(group.spawn(executor, task()), TaskGroup::MaxTasksReachedError); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/thread_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include // std::atomic #include // std::condition_variable #include // std::current_exception #include // std::bind, std::function, std::invoke #include // std::future, std::promise #include // std::make_shared, std::make_unique, std::shared_ptr, std::unique_ptr #include // std::mutex, std::scoped_lock, std::unique_lock #include // std::queue #include // std::thread::hardware_concurrency #include // std::decay_t, std::invoke_result_t, std::is_void_v #include // std::forward, std::move, std::swap #include // boost::thread namespace silkworm { /** * @brief A fast, lightweight, and easy-to-use C++17 thread pool. */ class ThreadPool { public: // ============================ // Constructors and destructors // ============================ /** * @brief Construct a new thread pool. * * @param thread_count The number of threads to use. The default value is the total number of hardware threads * available, as reported by the implementation. This is usually determined by the number of cores in the CPU. * If a core is hyper-threaded, it will count as two threads. * @param stack_size The stack size to set for each created thread. If the argument is zero, the default OS value * will be used instead. */ explicit ThreadPool(unsigned thread_count = std::thread::hardware_concurrency(), size_t stack_size = 0) : thread_count_(thread_count ? thread_count : 1), threads_(std::make_unique(thread_count_)) { create_threads(stack_size); } // Not copyable nor movable ThreadPool(const ThreadPool&) = delete; ThreadPool& operator=(const ThreadPool&) = delete; /** * @brief Destruct the thread pool. Waits for all tasks to complete, then destroys all threads. Note that * if the pool is paused, then any tasks still in the queue will never be executed. */ ~ThreadPool() { wait_for_tasks(); destroy_threads(); } // ======================= // Public member functions // ======================= /** * @brief Get the total number of unfinished tasks: either still in the queue, or running in a thread. * * @return The total number of tasks. */ size_t get_tasks_total() const { return tasks_total_; } /** * @brief Get the number of threads in the pool. * * @return The number of threads. */ unsigned get_thread_count() const { return thread_count_; } /** * @brief Check whether the pool is currently paused. * * @return true if the pool is paused, false if it is not paused. */ bool is_paused() const { return paused_; } /** * @brief Pause the pool. The workers will temporarily stop retrieving new tasks out of the queue, * although any tasks already executed will keep running until they are finished. */ void pause() { paused_ = true; } /** * @brief Push a function with zero or more arguments, but no return value, into the task queue. Does not return * a future, so the user must use wait_for_tasks() or some other method to ensure that the task finishes executing, * otherwise bad things will happen. * * @tparam F The type of the function. * @tparam A The types of the arguments. * @param task The function to push. * @param args The zero or more arguments to pass to the function. Note that if the task is a class member function, * the first argument must be a pointer to the object, i.e. &object (or this), followed by the actual arguments. */ template void push_task(F&& task, A&&... args) { // NOLINTNEXTLINE(modernize-avoid-bind) std::function task_function = std::bind(std::forward(task), std::forward(args)...); { const std::scoped_lock tasks_lock(tasks_mutex_); tasks_.push(task_function); ++tasks_total_; } task_available_cv_.notify_one(); } /** * @brief Submit a function with zero or more arguments into the task queue. If the function has a return value, * get a future for the eventual returned value. If the function has no return value, get an std::future * which can be used to wait until the task finishes. * * @tparam F The type of the function. * @tparam A The types of the zero or more arguments to pass to the function. * @tparam R The return type of the function (can be void). * @param task The function to submit. * @param args The zero or more arguments to pass to the function. Note that if the task is a class member function, * the first argument must be a pointer to the object, i.e. &object (or this), followed by the actual arguments. * @return A future to be used later to wait for the function to finish executing and/or obtain its returned value * if it has one. */ template , std::decay_t...>> [[nodiscard]] std::future submit(F&& task, A&&... args) { // NOLINTNEXTLINE(modernize-avoid-bind) std::function task_function = std::bind(std::forward(task), std::forward(args)...); std::shared_ptr> task_promise = std::make_shared>(); push_task( [task_function, task_promise] { try { if constexpr (std::is_void_v) { std::invoke(task_function); task_promise->set_value(); } else { task_promise->set_value(std::invoke(task_function)); } } catch (...) { try { task_promise->set_exception(std::current_exception()); } catch (...) { } } }); return task_promise->get_future(); } /** * @brief Unpause the pool. The workers will resume retrieving new tasks out of the queue. */ void unpause() { paused_ = false; } /** * @brief Wait for tasks to be completed. Normally, this function waits for all tasks, both those that are currently * running in the threads and those that are still waiting in the queue. However, if the pool is paused, this * function only waits for the currently running tasks (otherwise it would wait forever). Note: To wait for just one * specific task, use submit() instead, and call the wait() member function of the generated future. */ void wait_for_tasks() { if (!waiting_) { waiting_ = true; std::unique_lock tasks_lock(tasks_mutex_); task_done_cv_.wait(tasks_lock, [this] { return (tasks_total_ == (paused_ ? tasks_.size() : 0)); }); waiting_ = false; } } private: // ======================== // Private member functions // ======================== /** * @brief Create the threads in the pool and assign a worker to each thread. * @param stack_size The stack size of created threads. 0 means default OS value. */ void create_threads(size_t stack_size) { running_ = true; boost::thread::attributes attrs; if (stack_size) { attrs.set_stack_size(stack_size); } for (unsigned i = 0; i < thread_count_; ++i) { threads_[i] = boost::thread(attrs, [this] { worker(); }); } } /** * @brief Destroy the threads in the pool. */ void destroy_threads() { running_ = false; { const std::scoped_lock tasks_lock(tasks_mutex_); task_available_cv_.notify_all(); } for (unsigned i = 0; i < thread_count_; ++i) { threads_[i].join(); } } /** * @brief A worker function to be assigned to each thread in the pool. Waits until it is notified by push_task() * that a task is available, and then retrieves the task from the queue and executes it. Once the task finishes, * the worker notifies wait_for_tasks() in case it is waiting. */ void worker() { while (running_) { std::function task; std::unique_lock tasks_lock(tasks_mutex_); task_available_cv_.wait(tasks_lock, [this] { return !tasks_.empty() || !running_; }); if (running_ && !paused_) { task = std::move(tasks_.front()); tasks_.pop(); tasks_lock.unlock(); task(); tasks_lock.lock(); --tasks_total_; if (waiting_) task_done_cv_.notify_one(); } } } // ============ // Private data // ============ /** * @brief An atomic variable indicating whether the workers should pause. When set to true, the workers temporarily * stop retrieving new tasks out of the queue, although any tasks already executed will keep running until they are * finished. When set to false again, the workers resume retrieving tasks. */ std::atomic paused_ = false; /** * @brief An atomic variable indicating to the workers to keep running. When set to false, the workers permanently * stop working. */ std::atomic running_ = false; /** * @brief A condition variable used to notify worker() that a new task has become available. */ std::condition_variable task_available_cv_ = {}; /** * @brief A condition variable used to notify wait_for_tasks() that a tasks is done. */ std::condition_variable task_done_cv_ = {}; /** * @brief A queue of tasks to be executed by the threads. */ std::queue> tasks_ = {}; /** * @brief An atomic variable to keep track of the total number of unfinished tasks - either still in the queue, * or running in a thread. */ std::atomic tasks_total_ = 0; /** * @brief A mutex to synchronize access to the task queue by different threads. */ mutable std::mutex tasks_mutex_ = {}; /** * @brief The number of threads in the pool. */ unsigned thread_count_ = 0; /** * @brief A smart pointer to manage the memory allocated for the threads. */ std::unique_ptr threads_ = nullptr; /** * @brief An atomic variable indicating that wait_for_tasks() is active and expects to be notified whenever a task * is done. */ std::atomic waiting_ = false; }; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/thread_safe_queue.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { template > class container = std::deque> class ThreadSafeQueue { private: container queue_; mutable std::mutex mutex_; std::condition_variable condition_variable_; public: void push(T const& data) { { std::unique_lock lock(mutex_); queue_.push_back(data); } // lock.unlock(); condition_variable_.notify_one(); } void push(T&& data) { { std::unique_lock lock(mutex_); queue_.push_back(std::move(data)); } // lock.unlock(); condition_variable_.notify_one(); } bool empty() const { std::unique_lock lock(mutex_); return queue_.empty(); } size_t size() const { std::unique_lock lock(mutex_); return queue_.size(); } bool try_pop(T& popped_value) { std::unique_lock lock(mutex_); if (queue_.empty()) { return false; } popped_value = queue_.front(); queue_.pop_front(); return true; } void wait_and_pop(T& popped_value) { std::unique_lock lock(mutex_); condition_variable_.wait(lock, [this] { return !queue_.empty(); }); popped_value = queue_.front(); queue_.pop_front(); } template bool timed_wait_and_pop(T& popped_value, Duration const& wait_duration) { std::unique_lock lock(mutex_); if (!condition_variable_.wait_for(lock, wait_duration, [this] { return !queue_.empty(); })) { return false; } popped_value = queue_.front(); queue_.pop_front(); return true; } }; } // namespace silkworm ================================================ FILE: silkworm/infra/concurrency/timeout.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "timeout.hpp" #include #include #include #include #include #include namespace silkworm::concurrency { Task timeout( std::chrono::milliseconds duration, const char* source_file_path, int source_file_line) { auto executor = co_await boost::asio::this_coro::executor; boost::asio::steady_timer timer(executor); timer.expires_after(duration); try { co_await timer.async_wait(boost::asio::use_awaitable); } catch (const boost::system::system_error& ex) { // if the timeout is cancelled before expiration - it is not an error if (ex.code() == boost::system::errc::operation_canceled) { co_return; } throw; } if (source_file_path) { SILK_TRACE << "TimeoutExpiredError in " << source_file_path << ":" << source_file_line; } throw TimeoutExpiredError(); } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/concurrency/timeout.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::concurrency { Task timeout( std::chrono::milliseconds duration, const char* source_file_path = nullptr, int source_file_line = 0); class TimeoutExpiredError : public std::runtime_error { public: TimeoutExpiredError() : std::runtime_error("Timeout has expired") {} }; } // namespace silkworm::concurrency #define SILK_CONCURRENCY_TIMEOUT(duration) ::silkworm::concurrency::timeout(duration, __FILE__, __LINE__) ================================================ FILE: silkworm/infra/concurrency/timeout_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "timeout.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::concurrency { using namespace std::chrono_literals; using namespace boost::asio; class TestException : public std::runtime_error { public: TestException() : std::runtime_error("TestException") {} }; template Task async_value(T value) { co_await this_coro::executor; co_return value; } Task async_ok() { return async_value(true); } Task async_throw() { co_await this_coro::executor; throw TestException(); } Task short_timeout() { co_await timeout(1ms); } Task simple_timeout() { co_await timeout(1h); } Task wait_until_cancelled() { auto executor = co_await this_coro::executor; steady_timer timer(executor); timer.expires_after(1h); co_await timer.async_wait(use_awaitable); } class BadCancelException : public std::runtime_error { public: BadCancelException() : std::runtime_error("BadCancelException") {} }; Task wait_until_cancelled_bad() { try { auto executor = co_await this_coro::executor; steady_timer timer(executor); timer.expires_after(1h); co_await timer.async_wait(use_awaitable); } catch (const boost::system::system_error&) { throw BadCancelException(); } } template TResult run(Task task) { test_util::TaskRunner runner; return runner.run(std::move(task)); } TEST_CASE("Timeout.value") { CHECK(run(async_value(123)) == 123); } TEST_CASE("Timeout.ok") { CHECK(run(async_ok())); } TEST_CASE("Timeout.throw") { CHECK_THROWS_AS(run(async_throw()), TestException); } TEST_CASE("Timeout.timeout") { CHECK_THROWS_AS(run(short_timeout()), TimeoutExpiredError); } TEST_CASE("Timeout.boost_wait_for_one.throw_or_timeout") { using namespace boost::asio::experimental::awaitable_operators; CHECK_THROWS_AS(run(async_throw() || short_timeout()), multiple_exceptions); } TEST_CASE("Timeout.boost_wait_for_one.timeout_or_throw") { using namespace boost::asio::experimental::awaitable_operators; CHECK_THROWS_AS(run(short_timeout() || async_throw()), multiple_exceptions); } TEST_CASE("Timeout.boost_wait_for_all.cancel_and_throw") { using namespace boost::asio::experimental::awaitable_operators; CHECK_THROWS_AS(run(wait_until_cancelled() && async_throw()), multiple_exceptions); } TEST_CASE("Timeout.boost_wait_for_all.throw_and_cancel") { using namespace boost::asio::experimental::awaitable_operators; CHECK_THROWS_AS(run(async_throw() && wait_until_cancelled()), multiple_exceptions); } TEST_CASE("Timeout.wait_for_one.ok_or_value") { using namespace awaitable_wait_for_one; auto result = run(async_ok() || async_value(123)); CHECK(std::get(result)); } TEST_CASE("Timeout.wait_for_one.value_or_ok") { using namespace awaitable_wait_for_one; auto result = run(async_value(123) || async_ok()); CHECK(std::get(result) == 123); } TEST_CASE("Timeout.wait_for_one.ok_or_timeout") { using namespace awaitable_wait_for_one; auto result = run(async_ok() || simple_timeout()); CHECK(std::get(result)); } TEST_CASE("Timeout.wait_for_one.timeout_or_ok") { using namespace awaitable_wait_for_one; auto result = run(simple_timeout() || async_ok()); CHECK(std::get(result)); } TEST_CASE("Timeout.wait_for_one.throw_or_timeout") { using namespace awaitable_wait_for_one; CHECK_THROWS_AS(run(async_throw() || simple_timeout()), TestException); } TEST_CASE("Timeout.wait_for_one.timeout_or_throw") { using namespace awaitable_wait_for_one; CHECK_THROWS_AS(run(simple_timeout() || async_throw()), TestException); } TEST_CASE("Timeout.wait_for_one.cancel_and_throw") { using namespace awaitable_wait_for_one; CHECK_THROWS_AS(run(wait_until_cancelled() || async_throw()), TestException); } TEST_CASE("Timeout.wait_for_one.throw_and_cancel") { using namespace awaitable_wait_for_one; CHECK_THROWS_AS(run(async_throw() || wait_until_cancelled()), TestException); } TEST_CASE("Timeout.wait_for_all.ok_and_value") { using namespace awaitable_wait_for_all; auto [ok, value] = run(async_ok() && async_value(123)); CHECK(ok); CHECK(value == 123); } TEST_CASE("Timeout.wait_for_all.value_and_ok") { using namespace awaitable_wait_for_all; auto [value, ok] = run(async_value(123) && async_ok()); CHECK(value == 123); CHECK(ok); } TEST_CASE("Timeout.wait_for_all.ok_and_throw") { using namespace awaitable_wait_for_all; CHECK_THROWS_AS(run(async_ok() && async_throw()), TestException); } TEST_CASE("Timeout.wait_for_all.throw_and_ok") { using namespace awaitable_wait_for_all; CHECK_THROWS_AS(run(async_throw() && async_ok()), TestException); } TEST_CASE("Timeout.wait_for_all.timeout_and_throw") { using namespace awaitable_wait_for_all; CHECK_THROWS_AS(run(simple_timeout() && async_throw()), TestException); } TEST_CASE("Timeout.wait_for_all.throw_and_timeout") { using namespace awaitable_wait_for_all; CHECK_THROWS_AS(run(async_throw() && simple_timeout()), TestException); } TEST_CASE("Timeout.wait_for_all.cancel_and_throw") { using namespace awaitable_wait_for_all; CHECK_THROWS_AS(run(wait_until_cancelled() && async_throw()), TestException); } TEST_CASE("Timeout.wait_for_all.throw_and_cancel") { using namespace awaitable_wait_for_all; CHECK_THROWS_AS(run(async_throw() && wait_until_cancelled()), TestException); } TEST_CASE("Timeout.wait_for_all.bad_cancel_and_throw") { using namespace awaitable_wait_for_all; try { run(wait_until_cancelled_bad() && async_throw()); CHECK(false); } catch (const std::exception& ex) { CHECK(std::string(ex.what()) == "BadCancelException"); CHECK_THROWS_AS(std::rethrow_if_nested(ex), TestException); } } TEST_CASE("Timeout.wait_for_all.throw_and_bad_cancel") { using namespace awaitable_wait_for_all; try { run(async_throw() && wait_until_cancelled_bad()); CHECK(false); } catch (const std::exception& ex) { CHECK(std::string(ex.what()) == "BadCancelException"); CHECK_THROWS_AS(std::rethrow_if_nested(ex), TestException); } } } // namespace silkworm::concurrency ================================================ FILE: silkworm/infra/grpc/client/call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #include #include #pragma GCC diagnostic pop #include #include #include #include #include "reconnect.hpp" namespace silkworm::rpc { class GrpcStatusError : public std::runtime_error { public: explicit GrpcStatusError(grpc::Status status) : std::runtime_error(status.error_message()), status_(std::move(status)) {} const grpc::Status& status() const { return status_; } private: grpc::Status status_; }; template Task unary_rpc( agrpc::detail::ClientUnaryRequest> rpc, Stub& stub, Request request, agrpc::GrpcContext& grpc_context, boost::asio::cancellation_slot* cancellation_slot = nullptr) { grpc::ClientContext client_context; client_context.set_deadline(std::chrono::system_clock::now() + std::chrono::seconds(120)); if (cancellation_slot) { cancellation_slot->assign([&client_context](boost::asio::cancellation_type /*type*/) { client_context.TryCancel(); }); } auto task_executor = co_await boost::asio::this_coro::executor; std::unique_ptr> reader = agrpc::request(rpc, stub, client_context, request, grpc_context); Response reply; grpc::Status status; co_await agrpc::finish(reader, reply, status, boost::asio::bind_executor(grpc_context, boost::asio::use_awaitable)); co_await boost::asio::dispatch(boost::asio::bind_executor(task_executor, boost::asio::use_awaitable)); if (!status.ok()) { throw GrpcStatusError(std::move(status)); } co_return reply; } template Task server_streaming_rpc( agrpc::detail::PrepareAsyncClientServerStreamingRequest> rpc, std::unique_ptr& stub, Request request, agrpc::GrpcContext& grpc_context, std::function(Response)> consumer, boost::asio::cancellation_slot* cancellation_slot = nullptr) { grpc::ClientContext client_context; if (cancellation_slot) { cancellation_slot->assign([&client_context](boost::asio::cancellation_type /*type*/) { client_context.TryCancel(); }); } auto task_executor = co_await boost::asio::this_coro::executor; std::unique_ptr> reader; bool ok = co_await agrpc::request( rpc, stub, client_context, std::move(request), reader, boost::asio::bind_executor(grpc_context, boost::asio::use_awaitable)); co_await boost::asio::dispatch(boost::asio::bind_executor(task_executor, boost::asio::use_awaitable)); while (ok) { Response response; ok = co_await agrpc::read(reader, response, boost::asio::bind_executor(grpc_context, boost::asio::use_awaitable)); co_await boost::asio::dispatch(boost::asio::bind_executor(task_executor, boost::asio::use_awaitable)); if (ok) { co_await consumer(std::move(response)); } } grpc::Status status; co_await agrpc::finish(reader, status, boost::asio::bind_executor(grpc_context, boost::asio::use_awaitable)); co_await boost::asio::dispatch(boost::asio::bind_executor(task_executor, boost::asio::use_awaitable)); if (!status.ok()) { throw GrpcStatusError(std::move(status)); } } using DisconnectHook = std::function()>; template Task unary_rpc_with_retries( agrpc::detail::ClientUnaryRequest> rpc, Stub& stub, Request request, agrpc::GrpcContext& grpc_context, DisconnectHook& on_disconnect, grpc::Channel& channel, std::string log_prefix, int64_t min_msec = kDefaultMinBackoffReconnectTimeout, int64_t max_msec = kDefaultMaxBackoffReconnectTimeout) { // loop until a successful return or cancellation while (true) { try { co_return (co_await unary_rpc(rpc, stub, request, grpc_context)); } catch (const GrpcStatusError& ex) { if (is_disconnect_error(ex.status(), channel)) { SILK_WARN_M(log_prefix) << "GRPC unary call failed: " << ex.what(); } else { throw; } } co_await on_disconnect(); if (channel.GetState(false) != GRPC_CHANNEL_READY) { co_await reconnect_channel(channel, log_prefix, min_msec, max_msec); } } } template Task server_streaming_rpc_with_retries( agrpc::detail::PrepareAsyncClientServerStreamingRequest> rpc, std::unique_ptr& stub, Request request, agrpc::GrpcContext& grpc_context, DisconnectHook& on_disconnect, grpc::Channel& channel, std::string log_prefix, std::function(Response)> consumer, boost::asio::cancellation_slot* cancellation_signal = nullptr, int64_t min_backoff_timeout_msec = kDefaultMinBackoffReconnectTimeout, int64_t max_backoff_timeout_msec = kDefaultMaxBackoffReconnectTimeout) { // loop until a successful return or cancellation while (true) { try { co_await server_streaming_rpc(rpc, stub, request, grpc_context, consumer, cancellation_signal); break; } catch (const GrpcStatusError& ex) { if (is_disconnect_error(ex.status(), channel)) { SILK_WARN_M(log_prefix) << "GRPC server-streaming call failed: " << ex.what(); } else { throw; } } co_await on_disconnect(); if (channel.GetState(false) != GRPC_CHANNEL_READY) { co_await reconnect_channel(channel, log_prefix, min_backoff_timeout_msec, max_backoff_timeout_msec); } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/client/call_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using testing::Return; using namespace silkworm::grpc::test_util; namespace proto = ::remote; class CallTest : public silkworm::test_util::ContextTestBase { public: //! Check that before *and* after calling unary_rpc utility function we're executing on the same asio::io_context thread. //! This is a widespread threading assumption for our production code (e.g. rpcdaemon) but needs special handling because //! asio-grpc library functions currently used in unary_rpc do complete handlers on GrpcContext service thread template Task check_unary_grpc_threading( agrpc::detail::ClientUnaryRequest> rpc, std::unique_ptr& stub, Request request, agrpc::GrpcContext& grpc_context) { const auto this_thread_id{std::this_thread::get_id()}; CHECK(ioc_.get_executor().running_in_this_thread()); const auto response = co_await unary_rpc(rpc, *stub, request, grpc_context); CHECK(ioc_.get_executor().running_in_this_thread()); CHECK(this_thread_id == std::this_thread::get_id()); co_return response; } //! Same check as above but for agrpc::ClientRPC<>::request, which does not require dispatching to asio::io_context executor //! because it does guarantee to complete handlers on the calling executor: https://github.com/erigontech/silkrpc/issues/439 Task<::types::VersionReply> check_unary_agrpc_client_threading( proto::KV::StubInterface& stub, google::protobuf::Empty request, agrpc::GrpcContext& grpc_context) { ::grpc::ClientContext client_context; client_context.set_deadline(std::chrono::system_clock::now() + std::chrono::seconds(10)); using RPC = boost::asio::use_awaitable_t<>::as_default_on_t>; RPC::Response response; const auto this_thread_id{std::this_thread::get_id()}; CHECK(ioc_.get_executor().running_in_this_thread()); ::grpc::Status status = co_await RPC::request(grpc_context, stub, client_context, request, response); CHECK(ioc_.get_executor().running_in_this_thread()); CHECK(this_thread_id == std::this_thread::get_id()); if (!status.ok()) { throw GrpcStatusError(std::move(status)); } co_return response; } using StrictMockKVStub = testing::StrictMock; using StrictMockKVVersionAsyncResponseReader = rpc::test::StrictMockAsyncResponseReader<::types::VersionReply>; protected: //! Mocked stub of gRPC KV interface std::unique_ptr stub_{std::make_unique()}; //! Mocked reader for Version unary RPC of gRPC KV interface std::unique_ptr version_reader_ptr_{ std::make_unique()}; StrictMockKVVersionAsyncResponseReader& version_reader_{*version_reader_ptr_}; }; TEST_CASE_METHOD(CallTest, "Unary gRPC threading: unary_rpc", "[grpc][client]") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncVersionRaw call succeeds EXPECT_CALL(*stub_, AsyncVersionRaw).WillOnce(Return(version_reader_ptr_.get())); // 2. AsyncResponseReader::Finish call succeeds w/ status OK EXPECT_CALL(version_reader_, Finish).WillOnce(test::finish_ok(grpc_context_)); // Trick necessary because expectations require MockKVStub, whilst production code wants remote::KV::StubInterface std::unique_ptr stub{std::move(stub_)}; // Execute the test: check threading assumptions during async Version RPC execution spawn_and_wait(check_unary_grpc_threading(&proto::KV::StubInterface::AsyncVersion, stub, google::protobuf::Empty{}, grpc_context_)); } TEST_CASE_METHOD(CallTest, "Unary gRPC threading: agrpc::ClientRPC", "[grpc][client]") { // Set the call expectations: // 1. remote::KV::StubInterface::PrepareAsyncVersionRaw call succeeds EXPECT_CALL(*stub_, PrepareAsyncVersionRaw).WillOnce(Return(version_reader_ptr_.get())); // 2. AsyncResponseReader::StartCall call succeeds EXPECT_CALL(version_reader_, StartCall).WillOnce([&]() {}); // 3. AsyncResponseReader::Finish call succeeds w/ status OK EXPECT_CALL(version_reader_, Finish).WillOnce(test::finish_ok(grpc_context_)); // Execute the test: check threading assumptions during async Version RPC execution spawn_and_wait(check_unary_agrpc_client_threading(*stub_, google::protobuf::Empty{}, grpc_context_)); } TEST_CASE_METHOD(CallTest, "Unary gRPC cancelling: unary_rpc", "[grpc][client]") { // Set the call expectations: // 1. remote::KV::StubInterface::AsyncVersionRaw call succeeds EXPECT_CALL(*stub_, AsyncVersionRaw).WillOnce(Return(version_reader_ptr_.get())); // 2. AsyncResponseReader::Finish call fails w/ status CANCELLED boost::asio::cancellation_signal cancellation_signal; auto cancellation_slot = cancellation_signal.slot(); // Trick: we use Finish as a hook to signal cancellation, but then we must trigger tag by hand anyway // Better solution possible with agrpc::ClientRPC: use StartCall as a hook to signal cancellation EXPECT_CALL(version_reader_, Finish).WillOnce([&](auto&&, ::grpc::Status* status, void* tag) { cancellation_signal.emit(boost::asio::cancellation_type::all); *status = ::grpc::Status::CANCELLED; agrpc::process_grpc_tag(grpc_context_, tag, /*ok=*/true); }); // Trick necessary because expectations require MockKVStub, whilst production code wants remote::KV::StubInterface std::unique_ptr stub{std::move(stub_)}; // Execute the test: start and then cancel async Version RPC execution auto version_reply = spawn(unary_rpc(&proto::KV::StubInterface::AsyncVersion, *stub, google::protobuf::Empty{}, grpc_context_, &cancellation_slot)); CHECK_THROWS_AS(version_reply.get(), GrpcStatusError); } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/client/client_context_pool.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "client_context_pool.hpp" #include #include #include namespace silkworm::rpc { using namespace concurrency; ClientContext::ClientContext(size_t context_id) : Context{context_id}, grpc_context_{std::make_unique()}, grpc_context_work_{boost::asio::make_work_guard(grpc_context_->get_executor())} {} void ClientContext::destroy_grpc_context() { grpc_context_work_.reset(); grpc_context_.reset(); } void ClientContext::execute_loop() { SILK_DEBUG << "ClientContext execution loop start [" << std::this_thread::get_id() << "]"; std::thread grpc_context_thread{[context_id = context_id_, grpc_context = grpc_context_]() { log::set_thread_name(("grpc_ctx_s" + std::to_string(context_id)).c_str()); grpc_context->run_completion_queue(); }}; std::exception_ptr run_exception; try { ioc_->run(); } catch (...) { run_exception = std::current_exception(); } grpc_context_work_.reset(); grpc_context_->stop(); grpc_context_thread.join(); if (run_exception) { std::rethrow_exception(run_exception); } SILK_DEBUG << "ClientContext execution loop end [" << std::this_thread::get_id() << "]"; } ClientContextPool::~ClientContextPool() { stop(); // must be called to simplify exposed API, no problem because idempotent join(); // must be called to simplify exposed API, no problem because idempotent // Ensure *all* agrpc::GrpcContext get destroyed BEFORE any boost::asio::io_context is destroyed to avoid triggering // undefined behavior when dispatching calls from i-th agrpc::GrpcContext to j-th boost::asio::io_context w/ i != j for (auto& context : contexts_) { context.destroy_grpc_context(); } } void ClientContextPool::start() { // Cannot restart because ::grpc::CompletionQueue inside agrpc::GrpcContext cannot be reused if (stopped_) { throw std::logic_error("cannot restart context pool, create another one"); } ContextPool::start(); } agrpc::GrpcContext& ClientContextPool::any_grpc_context() { return *next_context().grpc_context(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/client/client_context_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include #include #include namespace silkworm::rpc { using ChannelFactory = std::function()>; //! Asynchronous client scheduler running an execution loop w/ integrated gRPC client. class ClientContext : public concurrency::Context { public: explicit ClientContext(size_t context_id); agrpc::GrpcContext* grpc_context() const noexcept { return grpc_context_.get(); } //! Execute the scheduler loop until stopped. void execute_loop() override; private: void destroy_grpc_context(); //! The asio-grpc asynchronous event scheduler. std::shared_ptr grpc_context_; //! The work-tracking executor that keep the asio-grpc scheduler running. boost::asio::executor_work_guard grpc_context_work_; friend class ClientContextPool; }; //! Pool of \ref ClientContext instances running as separate reactive schedulers. //! \warning currently cannot start/stop more than once because ::grpc::CompletionQueue cannot be used after shutdown class ClientContextPool : public concurrency::ContextPool, public GrpcContextPool { public: using concurrency::ContextPool::ContextPool; ~ClientContextPool() override; ClientContextPool(const ClientContextPool&) = delete; ClientContextPool& operator=(const ClientContextPool&) = delete; void start() override; agrpc::GrpcContext& any_grpc_context() override; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/client/client_context_pool_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "client_context_pool.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("ClientContext", "[silkworm][infra][grpc][client][client_context]") { { ClientContext context{0}; SECTION("Context::Context") { CHECK_NOTHROW(context.ioc() != nullptr); CHECK_NOTHROW(context.grpc_context() != nullptr); } SECTION("Context::execute_loop") { std::atomic_bool processed{false}; auto* ioc = context.ioc(); boost::asio::post(*ioc, [&]() { processed = true; context.stop(); }); auto context_thread = std::thread([&]() { context.execute_loop(); }); CHECK_NOTHROW(context_thread.join()); CHECK(processed); } SECTION("Context::stop") { std::atomic_bool processed{false}; auto* ioc = context.ioc(); boost::asio::post(*ioc, [&]() { processed = true; }); auto context_thread = std::thread([&]() { context.execute_loop(); }); CHECK_NOTHROW(context.stop()); CHECK_NOTHROW(context_thread.join()); } SECTION("print") { CHECK_NOTHROW(test_util::null_stream() << context); } } } TEST_CASE("ClientContextPool: create context pool", "[silkworm][infra][grpc][client][client_context]") { SECTION("reject size 0") { CHECK_THROWS_AS((ClientContextPool{0}), std::logic_error); } SECTION("accept size 1") { ClientContextPool cp{1}; CHECK(&cp.next_context() == &cp.next_context()); CHECK(&cp.next_ioc() == &cp.next_ioc()); } SECTION("accept size greater than 1") { ClientContextPool cp{3}; const auto& context1 = cp.next_context(); const auto& context2 = cp.next_context(); const auto& context3 = cp.next_context(); const auto& context4 = cp.next_context(); const auto& context5 = cp.next_context(); const auto& context6 = cp.next_context(); CHECK(&context1 == &context4); CHECK(&context2 == &context5); CHECK(&context3 == &context6); const auto& ioc1 = cp.next_ioc(); const auto& ioc2 = cp.next_ioc(); const auto& ioc3 = cp.next_ioc(); const auto& ioc4 = cp.next_ioc(); const auto& ioc5 = cp.next_ioc(); const auto& ioc6 = cp.next_ioc(); CHECK(&ioc1 == &ioc4); CHECK(&ioc2 == &ioc5); CHECK(&ioc3 == &ioc6); } } TEST_CASE("ClientContextPool: start context pool", "[silkworm][infra][grpc][client][client_context]") { SECTION("running 1 thread") { ClientContextPool cp{1}; cp.start(); cp.stop(); cp.join(); } SECTION("running 3 thread") { ClientContextPool cp{3}; cp.start(); cp.stop(); cp.join(); } } TEST_CASE("ClientContextPool: run context pool", "[silkworm][infra][grpc][client][client_context]") { SECTION("running 1 thread") { ClientContextPool cp{1}; auto context_pool_thread = std::thread([&]() { cp.run(); }); boost::asio::post(cp.next_ioc(), [&]() { cp.stop(); }); CHECK_NOTHROW(context_pool_thread.join()); } SECTION("running 3 thread") { ClientContextPool cp{3}; auto context_pool_thread = std::thread([&]() { cp.run(); }); boost::asio::post(cp.next_ioc(), [&]() { cp.stop(); }); CHECK_NOTHROW(context_pool_thread.join()); } SECTION("multiple runners require multiple pools") { ClientContextPool cp1{3}; ClientContextPool cp2{3}; auto context_pool_thread1 = std::thread([&]() { cp1.run(); }); auto context_pool_thread2 = std::thread([&]() { cp2.run(); }); boost::asio::post(cp1.next_ioc(), [&]() { cp1.stop(); }); boost::asio::post(cp2.next_ioc(), [&]() { cp2.stop(); }); CHECK_NOTHROW(context_pool_thread1.join()); CHECK_NOTHROW(context_pool_thread2.join()); } } TEST_CASE("ClientContextPool: stop context pool", "[silkworm][infra][grpc][client][client_context]") { SECTION("not yet running") { ClientContextPool cp{3}; CHECK_NOTHROW(cp.stop()); } SECTION("already stopped") { ClientContextPool cp{3}; cp.start(); cp.stop(); CHECK_NOTHROW(cp.stop()); cp.join(); } SECTION("already stopped after run in dedicated thread") { ClientContextPool cp{3}; auto context_pool_thread = std::thread([&]() { cp.run(); }); boost::asio::post(cp.next_ioc(), [&]() { cp.stop(); }); boost::asio::post(cp.next_ioc(), [&]() { cp.stop(); }); context_pool_thread.join(); boost::asio::post(cp.next_ioc(), [&]() { cp.stop(); }); } } TEST_CASE("ClientContextPool: cannot restart context pool", "[silkworm][infra][grpc][client][client_context]") { SECTION("running 1 thread") { ClientContextPool cp{1}; cp.start(); cp.stop(); cp.join(); CHECK_THROWS_AS(cp.start(), std::logic_error); } SECTION("running 3 thread") { ClientContextPool cp{3}; auto context_pool_thread = std::thread([&]() { cp.run(); }); boost::asio::post(cp.next_ioc(), [&]() { cp.stop(); }); CHECK_NOTHROW(context_pool_thread.join()); CHECK_THROWS_AS(cp.start(), std::logic_error); } } TEST_CASE("ClientContextPool: handle loop exception", "[silkworm][infra][grpc][client][client_context]") { ClientContextPool cp{3}; std::exception_ptr run_exception; cp.set_exception_handler([&](std::exception_ptr eptr) { run_exception = eptr; // In case of any loop exception in any thread, close down the pool cp.stop(); }); auto context_pool_thread = std::thread([&]() { cp.run(); }); boost::asio::post(cp.next_ioc(), [&]() { throw std::logic_error{"unexpected"}; }); CHECK_NOTHROW(context_pool_thread.join()); CHECK(bool(run_exception)); } TEST_CASE("ClientContextPool: start/stop/join w/ tasks enqueued") { using StubInterface = ::remote::KV::StubInterface; auto channel = ::grpc::CreateChannel("localhost:9090", grpc::InsecureChannelCredentials()); std::unique_ptr stub = ::remote::KV::NewStub(channel); ClientContextPool context_pool{5}; SECTION("no dispatch interleaving: i-th GrpcContext notifies i-th asio::io_context") { for (size_t i = 0; i < context_pool.size(); ++i) { const auto& context = context_pool.next_context(); concurrency::spawn_future(*context.ioc(), [&]() -> Task { co_await unary_rpc(&StubInterface::AsyncVersion, *stub, ::google::protobuf::Empty{}, *context.grpc_context()); }); } } SECTION("dispatch interleaving: (i+1)-th GrpcContext notifies i-th asio::io_context") { // Check that dispatching calls from i-th agrpc::GrpcContext to j-th boost::asio::io_context w/ i != j works // This test executed in tight loop of 10'000 iterations triggered a segmentation fault in ~ClientContextPool // https://github.com/boostorg/asio/blob/boost-1.83.0/include/boost/asio/detail/impl/scheduler.ipp#L373 for (size_t i = 0; i < context_pool.size(); ++i) { concurrency::spawn_future(context_pool.any_executor(), [&]() -> Task { auto& grpc_context = context_pool.any_grpc_context(); co_await unary_rpc(&StubInterface::AsyncVersion, *stub, ::google::protobuf::Empty{}, grpc_context); }); } } context_pool.start(); context_pool.stop(); CHECK_NOTHROW(context_pool.join()); } TEST_CASE("ClientContextPool: start/destroy w/ tasks enqueued") { using StubInterface = ::remote::KV::StubInterface; auto channel = ::grpc::CreateChannel("localhost:9090", grpc::InsecureChannelCredentials()); std::unique_ptr stub = ::remote::KV::NewStub(channel); ClientContextPool context_pool{5}; SECTION("no dispatch interleaving: i-th GrpcContext notifies i-th asio::io_context") { for (size_t i = 0; i < context_pool.size(); ++i) { const auto& context = context_pool.next_context(); concurrency::spawn_future(*context.ioc(), [&]() -> Task { co_await unary_rpc(&StubInterface::AsyncVersion, *stub, ::google::protobuf::Empty{}, *context.grpc_context()); }); } } SECTION("dispatch interleaving: (i+1)-th GrpcContext notifies i-th asio::io_context") { // Check that dispatching calls from i-th agrpc::GrpcContext to j-th boost::asio::io_context w/ i != j works // This test executed in tight loop of 10'000 iterations triggered a segmentation fault in ~ClientContextPool // https://github.com/boostorg/asio/blob/boost-1.83.0/include/boost/asio/detail/impl/scheduler.ipp#L373 for (size_t i = 0; i < context_pool.size(); ++i) { concurrency::spawn_future(context_pool.any_executor(), [&]() -> Task { auto& grpc_context = context_pool.any_grpc_context(); co_await unary_rpc(&StubInterface::AsyncVersion, *stub, ::google::protobuf::Empty{}, grpc_context); }); } } context_pool.start(); // We do not call ClientContextPool::stop and ClientContextPool::join explicitly here, which is a valid API usage // ~ClientContextPool must call them in order to allow this scenario (they're idempotent methods) } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/client/dispatcher.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::detail { template class ExecutorDispatcher { public: // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) ExecutorDispatcher(Executor executor) : executor_{std::move(executor)} {} template void dispatch(CompletionToken&& token, Args&&... args) { boost::asio::dispatch( boost::asio::bind_executor(executor_, boost::asio::append(std::forward(token), std::forward(args)...))); } private: Executor executor_; }; struct InlineDispatcher { template void dispatch(CompletionToken&& token, Args&&... args) { std::forward(token)(std::forward(args)...); } }; } // namespace silkworm::detail ================================================ FILE: silkworm/infra/grpc/client/error.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "error.hpp" #include class GrpcErrorCategory : public std::error_category { public: const char* name() const noexcept override; std::string message(int ev) const override; void set_error(std::string error_message) { error_message_ = std::move(error_message); } private: std::string error_message_; }; const char* GrpcErrorCategory::name() const noexcept { return "grpc"; } std::string GrpcErrorCategory::message(int /*ev*/) const { return error_message_; } std::error_code make_error_code(int error_code, std::string error_message) { thread_local GrpcErrorCategory tls_error_category{}; tls_error_category.set_error(std::move(error_message)); return {error_code, tls_error_category}; } ================================================ FILE: silkworm/infra/grpc/client/error.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include std::error_code make_error_code(int error_code, std::string error_message); ================================================ FILE: silkworm/infra/grpc/client/error_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "error.hpp" #include namespace silkworm { TEST_CASE("make error code with empty message", "[rpc][grpc][error]") { std::error_code error_code{make_error_code(123, "")}; CHECK(error_code.value() == 123); CHECK(error_code.message().empty()); CHECK(error_code.category().name() == std::string("grpc")); } TEST_CASE("make error code with non-empty message", "[rpc][grpc][error]") { std::error_code error_code{make_error_code(-123, "undefined error")}; CHECK(error_code.value() == -123); CHECK(error_code.message() == "undefined error"); CHECK(error_code.category().name() == std::string("grpc")); } } // namespace silkworm ================================================ FILE: silkworm/infra/grpc/client/reconnect.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "reconnect.hpp" #include #include #include namespace silkworm::rpc { bool is_disconnect_error(const grpc::Status& status, grpc::Channel& channel) { auto code = status.error_code(); return (code == grpc::StatusCode::UNAVAILABLE) || ((code == grpc::StatusCode::DEADLINE_EXCEEDED) && (channel.GetState(false) != GRPC_CHANNEL_READY) && (channel.GetState(false) != GRPC_CHANNEL_SHUTDOWN)); } // min_sec, min_sec*2, min_sec*4, ... max_sec, max_sec, ... int64_t backoff_timeout(size_t attempt, int64_t min_msec, int64_t max_msec) { if (attempt >= 20) return max_msec; return std::min(min_msec << attempt, max_msec); } Task reconnect_channel(grpc::Channel& channel, std::string log_prefix, int64_t min_msec, int64_t max_msec) { bool is_stopped = false; std::function run = [&] { bool is_connected = false; size_t attempt = 0; while (!is_connected && !is_stopped && (channel.GetState(false) != GRPC_CHANNEL_SHUTDOWN)) { SILK_INFO_M(log_prefix) << "Reconnecting gRPC channel..."; auto timeout = backoff_timeout(attempt++, min_msec, max_msec); auto deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_millis(timeout, GPR_TIMESPAN)); is_connected = channel.WaitForConnected(deadline); } }; std::function stop = [&] { is_stopped = true; }; co_await concurrency::async_thread(std::move(run), std::move(stop), "channel-rec"); } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/client/reconnect.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc { bool is_disconnect_error(const grpc::Status& status, grpc::Channel& channel); inline constexpr int64_t kDefaultMinBackoffReconnectTimeout{5'000}; inline constexpr int64_t kDefaultMaxBackoffReconnectTimeout{600'000}; //! Compute next timeout as truncated exponential backoff starting from min up to max //! \details Return values: min_msec, min_msec*2, min_msec*4, ... max_msec, max_msec, ... int64_t backoff_timeout(size_t attempt, int64_t min_msec, int64_t max_msec); Task reconnect_channel(grpc::Channel& channel, std::string log_prefix, int64_t min_msec = kDefaultMinBackoffReconnectTimeout, int64_t max_msec = kDefaultMaxBackoffReconnectTimeout); } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/bytes.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc { inline void deserialize_hex_as_bytes(std::string_view hex, std::vector& sequence) { auto bytes{from_hex(hex)}; if (bytes) { sequence.push_back(std::move(*bytes)); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/completion_tag.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::rpc { //! The callback to activate reading each event from the gRPC completion queue. using TagProcessor = std::function; //! This represents the completion event (better known as TAG in gRPC) of any async operation. //! By packing the tag information this way, each tag knows how to process itself. struct CompletionTag { TagProcessor* processor{nullptr}; // The function to be called to process incoming event bool ok{false}; // The result of tag processing as indicated by gRPC library (name consistent with gRPC examples) }; } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/conversion.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "conversion.hpp" // operator== overloading is *NOT* present in gRPC generated sources namespace types { bool operator==(const H2048& lhs, const H2048& rhs) { return lhs.hi() == rhs.hi() && lhs.lo() == rhs.lo(); } bool operator==(const H1024& lhs, const H1024& rhs) { return lhs.hi() == rhs.hi() && lhs.lo() == rhs.lo(); } bool operator==(const H512& lhs, const H512& rhs) { return lhs.hi() == rhs.hi() && lhs.lo() == rhs.lo(); } bool operator==(const H256& lhs, const H256& rhs) { return lhs.hi() == rhs.hi() && lhs.lo() == rhs.lo(); } bool operator==(const H160& lhs, const H160& rhs) { return lhs.hi() == rhs.hi() && lhs.lo() == rhs.lo(); } bool operator==(const H128& lhs, const H128& rhs) { return lhs.hi() == rhs.hi() && lhs.lo() == rhs.lo(); } } // namespace types namespace silkworm::rpc { constexpr uint64_t lo_lo(const intx::uint256& x) { return x[0]; } constexpr uint64_t lo_hi(const intx::uint256& x) { return x[1]; } constexpr uint64_t hi_lo(const intx::uint256& x) { return x[2]; } constexpr uint64_t hi_hi(const intx::uint256& x) { return x[3]; } std::string string_from_h2048(const ::types::H2048& orig) { const auto& hi_hi = orig.hi().hi(); const auto& hi_lo = orig.hi().lo(); const auto& lo_hi = orig.lo().hi(); const auto& lo_lo = orig.lo().lo(); std::string dest(256, 0); dest.append(string_from_h512(hi_hi)); dest.append(string_from_h512(hi_lo)); dest.append(string_from_h512(lo_hi)); dest.append(string_from_h512(lo_lo)); return dest; } Bytes bytes_from_h2048(const ::types::H2048& h2048) { Bytes bytes(256, '\0'); const auto& hi{h2048.hi()}; const auto& lo{h2048.lo()}; std::memcpy(&bytes[0], bytes_from_h1024(hi).data(), 128); std::memcpy(&bytes[128], bytes_from_h1024(lo).data(), 128); return bytes; } void span_from_h2048(const ::types::H2048& h2048, ByteSpan<256> bytes) { const auto& hi{h2048.hi()}; const auto& lo{h2048.lo()}; span_from_h1024(hi, bytes.subspan<0, 128>()); span_from_h1024(lo, bytes.subspan<128, 128>()); } Bytes bytes_from_h1024(const ::types::H1024& h1024) { Bytes bytes(128, '\0'); const auto& hi{h1024.hi()}; const auto& lo{h1024.lo()}; std::memcpy(&bytes[0], bytes_from_h512(hi).data(), 64); std::memcpy(&bytes[64], bytes_from_h512(lo).data(), 64); return bytes; } void span_from_h1024(const ::types::H1024& h1024, ByteSpan<128> bytes) { const auto& hi{h1024.hi()}; const auto& lo{h1024.lo()}; span_from_h512(hi, bytes.subspan<0, 64>()); span_from_h512(lo, bytes.subspan<64, 64>()); } std::string string_from_h512(const types::H512& orig) { uint64_t hi_hi_hi = orig.hi().hi().hi(); uint64_t hi_hi_lo = orig.hi().hi().lo(); uint64_t hi_lo_hi = orig.hi().lo().hi(); uint64_t hi_lo_lo = orig.hi().lo().lo(); uint64_t lo_hi_hi = orig.lo().hi().hi(); uint64_t lo_hi_lo = orig.lo().hi().lo(); uint64_t lo_lo_hi = orig.lo().lo().hi(); uint64_t lo_lo_lo = orig.lo().lo().lo(); std::string dest(64, 0); auto data = reinterpret_cast(dest.data()); endian::store_big_u64(data + 0, hi_hi_hi); endian::store_big_u64(data + 8, hi_hi_lo); endian::store_big_u64(data + 16, hi_lo_hi); endian::store_big_u64(data + 24, hi_lo_lo); endian::store_big_u64(data + 32, lo_hi_hi); endian::store_big_u64(data + 40, lo_hi_lo); endian::store_big_u64(data + 48, lo_lo_hi); endian::store_big_u64(data + 56, lo_lo_lo); return dest; } Bytes bytes_from_h512(const ::types::H512& h512) { Bytes bytes(64, '\0'); const auto& hi{h512.hi()}; const auto& lo{h512.lo()}; std::memcpy(&bytes[0], bytes_from_h256(hi).data(), 32); std::memcpy(&bytes[32], bytes_from_h256(lo).data(), 32); return bytes; } void span_from_h512(const ::types::H512& h512, ByteSpan<64> bytes) { const auto& hi{h512.hi()}; const auto& lo{h512.lo()}; span_from_h256(hi, bytes.subspan<0, 32>()); span_from_h256(lo, bytes.subspan<32, 32>()); } evmc::bytes32 bytes32_from_h256(const ::types::H256& orig) { uint64_t hi_hi = orig.hi().hi(); uint64_t hi_lo = orig.hi().lo(); uint64_t lo_hi = orig.lo().hi(); uint64_t lo_lo = orig.lo().lo(); evmc::bytes32 dest; endian::store_big_u64(dest.bytes + 0, hi_hi); endian::store_big_u64(dest.bytes + 8, hi_lo); endian::store_big_u64(dest.bytes + 16, lo_hi); endian::store_big_u64(dest.bytes + 24, lo_lo); return dest; } Bytes bytes_from_h256(const ::types::H256& h256) { silkworm::Bytes bytes(32, '\0'); const auto& hi{h256.hi()}; const auto& lo{h256.lo()}; std::memcpy(&bytes[0], bytes_from_h128(hi).data(), 16); std::memcpy(&bytes[16], bytes_from_h128(lo).data(), 16); return bytes; } void span_from_h256(const ::types::H256& h256, ByteSpan<32> bytes) { const auto& hi{h256.hi()}; const auto& lo{h256.lo()}; span_from_h128(hi, bytes.subspan<0, 16>()); span_from_h128(lo, bytes.subspan<16, 16>()); } intx::uint256 uint256_from_h256(const ::types::H256& orig) { uint64_t hi_hi = orig.hi().hi(); uint64_t hi_lo = orig.hi().lo(); uint64_t lo_hi = orig.lo().hi(); uint64_t lo_lo = orig.lo().lo(); return {lo_lo, lo_hi, hi_lo, hi_hi}; } evmc::address address_from_h160(const ::types::H160& orig) { uint64_t hi_hi = orig.hi().hi(); uint64_t hi_lo = orig.hi().lo(); uint32_t lo = orig.lo(); evmc::address dest; endian::store_big_u64(dest.bytes + 0, hi_hi); endian::store_big_u64(dest.bytes + 8, hi_lo); endian::store_big_u32(dest.bytes + 16, lo); return dest; } Bytes bytes_from_h128(const ::types::H128& h128) { Bytes bytes(16, '\0'); endian::store_big_u64(&bytes[0], h128.hi()); endian::store_big_u64(&bytes[8], h128.lo()); return bytes; } void span_from_h128(const ::types::H128& h128, ByteSpan<16> bytes) { endian::store_big_u64(&bytes[0], h128.hi()); endian::store_big_u64(&bytes[8], h128.lo()); } std::unique_ptr<::types::H2048> h2048_from_string(std::string_view orig) { auto lo_lo = h512_from_string(orig); auto lo_hi = h512_from_string(orig.substr(64)); auto hi_lo = h512_from_string(orig.substr(128)); auto hi_hi = h512_from_string(orig.substr(192)); auto hi = std::make_unique<::types::H1024>(); auto lo = std::make_unique<::types::H1024>(); hi->set_allocated_hi(hi_hi.release()); hi->set_allocated_lo(hi_lo.release()); lo->set_allocated_hi(lo_hi.release()); lo->set_allocated_lo(lo_lo.release()); auto dest = std::make_unique<::types::H2048>(); dest->set_allocated_hi(hi.release()); // takes ownership dest->set_allocated_lo(lo.release()); // takes ownership return dest; } std::unique_ptr<::types::H2048> h2048_from_bytes(ByteView bytes) { auto dest = std::make_unique<::types::H2048>(); auto hi{h1024_from_bytes({bytes.data(), 128}).release()}; auto lo{h1024_from_bytes({bytes.data() + 128, 128}).release()}; dest->set_allocated_hi(hi); // takes ownership dest->set_allocated_lo(lo); // takes ownership return dest; } std::unique_ptr<::types::H1024> h1024_from_bytes(ByteView bytes) { auto dest = std::make_unique<::types::H1024>(); auto hi{h512_from_bytes({bytes.data(), 64}).release()}; auto lo{h512_from_bytes({bytes.data() + 64, 64}).release()}; dest->set_allocated_hi(hi); // takes ownership dest->set_allocated_lo(lo); // takes ownership return dest; } std::unique_ptr<::types::H512> h512_from_string(std::string_view orig) { Bytes bytes(64, 0); uint8_t* data = bytes.data(); std::memcpy(data, orig.data(), orig.size() < 64 ? orig.size() : 64); auto hi_hi = std::make_unique<::types::H128>(); auto hi_lo = std::make_unique<::types::H128>(); auto lo_hi = std::make_unique<::types::H128>(); auto lo_lo = std::make_unique<::types::H128>(); hi_hi->set_hi(endian::load_big_u64(data + 0)); hi_hi->set_lo(endian::load_big_u64(data + 8)); hi_lo->set_hi(endian::load_big_u64(data + 16)); hi_lo->set_lo(endian::load_big_u64(data + 24)); lo_hi->set_hi(endian::load_big_u64(data + 32)); lo_hi->set_lo(endian::load_big_u64(data + 40)); lo_lo->set_hi(endian::load_big_u64(data + 48)); lo_lo->set_lo(endian::load_big_u64(data + 56)); auto hi = std::make_unique<::types::H256>(); auto lo = std::make_unique<::types::H256>(); hi->set_allocated_hi(hi_hi.release()); // takes ownership hi->set_allocated_lo(hi_lo.release()); // takes ownership lo->set_allocated_hi(lo_hi.release()); // takes ownership lo->set_allocated_lo(lo_lo.release()); // takes ownership auto dest = std::make_unique<::types::H512>(); dest->set_allocated_hi(hi.release()); // takes ownership dest->set_allocated_lo(lo.release()); // takes ownership return dest; } std::unique_ptr<::types::H512> h512_from_bytes(ByteView bytes) { auto dest = std::make_unique<::types::H512>(); auto hi{h256_from_bytes({bytes.data(), 32}).release()}; auto lo{h256_from_bytes({bytes.data() + 32, 32}).release()}; dest->set_allocated_hi(hi); // takes ownership dest->set_allocated_lo(lo); // takes ownership return dest; } void h256_from_bytes32(const evmc::bytes32& orig, ::types::H256* dest) { auto hi = std::make_unique<::types::H128>(); auto lo = std::make_unique<::types::H128>(); hi->set_hi(endian::load_big_u64(orig.bytes + 0)); hi->set_lo(endian::load_big_u64(orig.bytes + 8)); lo->set_hi(endian::load_big_u64(orig.bytes + 16)); lo->set_lo(endian::load_big_u64(orig.bytes + 24)); dest->set_allocated_hi(hi.release()); // takes ownership dest->set_allocated_lo(lo.release()); // takes ownership } std::unique_ptr<::types::H256> h256_from_bytes32(const evmc::bytes32& orig) { auto dest = std::make_unique<::types::H256>(); h256_from_bytes32(orig, dest.get()); return dest; } std::unique_ptr<::types::H256> h256_from_uint256(const intx::uint256& orig) { auto dest = std::make_unique<::types::H256>(); auto hi = std::make_unique<::types::H128>(); auto lo = std::make_unique<::types::H128>(); hi->set_hi(hi_hi(orig)); hi->set_lo(hi_lo(orig)); lo->set_hi(lo_hi(orig)); lo->set_lo(lo_lo(orig)); dest->set_allocated_hi(hi.release()); // takes ownership dest->set_allocated_lo(lo.release()); // takes ownership return dest; } std::unique_ptr<::types::H256> h256_from_bytes(ByteView bytes) { auto dest = std::make_unique<::types::H256>(); auto hi{h128_from_bytes({bytes.data(), 16}).release()}; auto lo{h128_from_bytes({bytes.data() + 16, 16}).release()}; dest->set_allocated_hi(hi); // takes ownership dest->set_allocated_lo(lo); // takes ownership return dest; } std::unique_ptr<::types::H160> h160_from_address(const evmc::address& orig) { auto hi = std::make_unique<::types::H128>(); hi->set_hi(endian::load_big_u64(orig.bytes)); hi->set_lo(endian::load_big_u64(orig.bytes + 8)); auto dest = std::make_unique<::types::H160>(); dest->set_allocated_hi(hi.release()); // takes ownership dest->set_lo(endian::load_big_u32(orig.bytes + 16)); return dest; } std::unique_ptr<::types::H128> h128_from_bytes(ByteView bytes) { auto dest = std::make_unique<::types::H128>(); dest->set_hi(endian::load_big_u64(bytes.data())); dest->set_lo(endian::load_big_u64(bytes.data() + 8)); return dest; } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/conversion.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include // operator== overloading is *NOT* present in gRPC generated sources namespace types { bool operator==(const H2048& lhs, const H2048& rhs); bool operator==(const H1024& lhs, const H1024& rhs); bool operator==(const H512& lhs, const H512& rhs); bool operator==(const H256& lhs, const H256& rhs); bool operator==(const H160& lhs, const H160& rhs); bool operator==(const H128& lhs, const H128& rhs); } // namespace types namespace silkworm::rpc { //! Convert internal gRPC H2048 type instance to std::string. std::string string_from_h2048(const ::types::H2048& orig); //! Convert internal gRPC H2048 type instance to Bytes. Bytes bytes_from_h2048(const ::types::H2048& h2048); //! Convert internal gRPC H2048 type instance into provided fixed-size ByteSpan. void span_from_h2048(const ::types::H2048& h2048, ByteSpan<256> bytes); //! Convert internal gRPC H1024 type instance to Bytes. Bytes bytes_from_h1024(const ::types::H1024& h1024); //! Convert internal gRPC H1024 type instance into provided fixed-size ByteSpan. void span_from_h1024(const ::types::H1024& h1024, ByteSpan<128> bytes); //! Convert internal gRPC H512 type instance to std::string. std::string string_from_h512(const ::types::H512& orig); //! Convert internal gRPC H512 type instance to Bytes. Bytes bytes_from_h512(const ::types::H512& h512); //! Convert internal gRPC H512 type instance into provided fixed-size ByteSpan. void span_from_h512(const ::types::H512& h512, ByteSpan<64> bytes); //! Convert internal gRPC H256 type instance to evmc::bytes32. evmc::bytes32 bytes32_from_h256(const ::types::H256& orig); //! Convert internal gRPC H256 type instance to intx::uint256. intx::uint256 uint256_from_h256(const ::types::H256& orig); //! Convert internal gRPC H256 type instance to Bytes. Bytes bytes_from_h256(const ::types::H256& h256); //! Convert internal gRPC H256 type instance into provided fixed-size ByteSpan. void span_from_h256(const ::types::H256& h256, ByteSpan<32> bytes); //! Convert internal gRPC H160 type instance to evmc::address. evmc::address address_from_h160(const ::types::H160& orig); //! Convert internal gRPC H128 type instance to Bytes. Bytes bytes_from_h128(const ::types::H128& h128); //! Convert internal gRPC H128 type instance into provided fixed-size ByteSpan. void span_from_h128(const ::types::H128& h128, ByteSpan<16> bytes); //! Convert std::string_view to internal gRPC H2048 type instance. std::unique_ptr<::types::H2048> h2048_from_string(std::string_view orig); //! Convert ByteView to internal gRPC H2048 type instance. std::unique_ptr<::types::H2048> h2048_from_bytes(ByteView bytes); //! Convert ByteView to internal gRPC H1024 type instance. std::unique_ptr<::types::H1024> h1024_from_bytes(ByteView bytes); //! Convert evmc::address to internal gRPC H512 type instance. std::unique_ptr<::types::H512> h512_from_string(std::string_view orig); //! Convert ByteView to internal gRPC H512 type instance. std::unique_ptr<::types::H512> h512_from_bytes(ByteView bytes); //! Convert evmc::bytes32 to internal gRPC H256 type instance. void h256_from_bytes32(const evmc::bytes32& orig, ::types::H256* dest); //! Convert evmc::bytes32 to internal gRPC H256 type instance. std::unique_ptr<::types::H256> h256_from_bytes32(const evmc::bytes32& orig); //! Convert intx::uint256 to internal gRPC H256 type instance. std::unique_ptr<::types::H256> h256_from_uint256(const intx::uint256& orig); //! Convert ByteView to internal gRPC H256 type instance. std::unique_ptr<::types::H256> h256_from_bytes(ByteView bytes); //! Convert evmc::address to internal gRPC H160 type instance. std::unique_ptr<::types::H160> h160_from_address(const evmc::address& orig); //! Convert ByteView to internal gRPC H128 type instance. std::unique_ptr<::types::H128> h128_from_bytes(ByteView bytes); } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/conversion_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "conversion.hpp" #include #include #include #include // operator== overloading is *NOT* present in gRPC generated sources namespace types { TEST_CASE("H2048::operator==", "[rpc][conversion]") { CHECK(types::H2048{} == types::H2048{}); } TEST_CASE("H1024::operator==", "[rpc][conversion]") { CHECK(types::H1024{} == types::H1024{}); } TEST_CASE("H512::operator==", "[rpc][conversion]") { CHECK(types::H512{} == types::H512{}); } TEST_CASE("H256::operator==", "[rpc][conversion]") { CHECK(types::H256{} == types::H256{}); } TEST_CASE("H160::operator==", "[rpc][conversion]") { CHECK(types::H160{} == types::H160{}); } TEST_CASE("H128::operator==", "[rpc][conversion]") { CHECK(types::H128{} == types::H128{}); } } // namespace types namespace silkworm::rpc { using namespace evmc::literals; static Bytes kSampleH512Bytes{*from_hex( "000000000000007f0000000000000007000000000000006f0000000000000006" "000000000000002f0000000000000002000000000000001f0000000000000001")}; static std::unique_ptr sample_h512() { auto hi_hi = new types::H128(); auto hi_lo = new types::H128(); auto lo_hi = new types::H128(); auto lo_lo = new types::H128(); hi_hi->set_hi(0x7F); hi_hi->set_lo(0x07); hi_lo->set_hi(0x6F); hi_lo->set_lo(0x06); lo_hi->set_hi(0x2F); lo_hi->set_lo(0x02); lo_lo->set_hi(0x1F); lo_lo->set_lo(0x01); auto hi = new types::H256{}; auto lo = new types::H256{}; hi->set_allocated_hi(hi_hi); hi->set_allocated_lo(hi_lo); lo->set_allocated_hi(lo_hi); lo->set_allocated_lo(lo_lo); auto h512_ptr = std::make_unique(); h512_ptr->set_allocated_hi(hi); h512_ptr->set_allocated_lo(lo); return h512_ptr; } TEST_CASE("string_from_h512", "[rpc][conversion]") { SECTION("empty H512", "[rpc][conversion]") { std::string zeros(64, 0); CHECK(string_from_h512(types::H512{}) == zeros); } SECTION("non-empty H512", "[rpc][conversion]") { auto h512_ptr = sample_h512(); const std::string& s = string_from_h512(*h512_ptr); CHECK(s.size() == 64); CHECK(Bytes{reinterpret_cast(s.data()), s.size()} == kSampleH512Bytes); } } TEST_CASE("span_from_h512", "[rpc][conversion]") { SECTION("empty H512", "[rpc][conversion]") { std::array zeros{}; std::array uint8_array{}; span_from_h512(types::H512{}, uint8_array); CHECK(uint8_array == zeros); } SECTION("non-empty H512", "[rpc][conversion]") { auto h512_ptr = sample_h512(); std::array uint8_array{}; span_from_h512(*h512_ptr, uint8_array); CHECK(Bytes{uint8_array.data(), uint8_array.size()} == kSampleH512Bytes); } } static constexpr evmc::bytes32 kSampleBytes32 = 0x000000000000007f0000000000000007000000000000006f0000000000000006_bytes32; static std::unique_ptr sample_h256() { auto hi = new types::H128(); auto lo = new types::H128(); hi->set_hi(0x7F); hi->set_lo(0x07); lo->set_hi(0x6F); lo->set_lo(0x06); auto h256_ptr = std::make_unique(); h256_ptr->set_allocated_hi(hi); h256_ptr->set_allocated_lo(lo); return h256_ptr; } TEST_CASE("bytes32_from_h256", "[rpc][conversion]") { SECTION("empty H256", "[rpc][conversion]") { CHECK_NOTHROW(bytes32_from_h256(types::H256{}) == evmc::bytes32{}); } SECTION("non-empty H256", "[rpc][conversion]") { auto h256_ptr = sample_h256(); CHECK(bytes32_from_h256(*h256_ptr) == kSampleBytes32); } } TEST_CASE("span_from_h256", "[rpc][conversion]") { SECTION("empty H256", "[rpc][conversion]") { evmc::bytes32 bytes32; span_from_h256(types::H256{}, bytes32.bytes); CHECK_NOTHROW(bytes32 == evmc::bytes32{}); } SECTION("non-empty H256", "[rpc][conversion]") { auto h256_ptr = sample_h256(); evmc::bytes32 bytes32; span_from_h256(*h256_ptr, bytes32.bytes); CHECK(bytes32 == kSampleBytes32); } } TEST_CASE("address_from_h160", "[rpc][conversion]") { SECTION("empty H160", "[rpc][conversion]") { CHECK_NOTHROW(address_from_h160(types::H160{}) == evmc::address{}); } SECTION("non-empty H160", "[rpc][conversion]") { auto hi = new types::H128(); hi->set_lo(0x07); hi->set_hi(0x7F); auto h160_ptr = std::make_unique(); h160_ptr->set_lo(0xFF); h160_ptr->set_allocated_hi(hi); CHECK(address_from_h160(*h160_ptr) == 0x000000000000007f0000000000000007000000ff_address); } } static const Bytes kSampleBytes16 = *from_hex("0x000000000000007f0000000000000007"); static std::unique_ptr sample_h128() { auto h128_ptr = std::make_unique<::types::H128>(); h128_ptr->set_lo(0x07); h128_ptr->set_hi(0x7F); return h128_ptr; } TEST_CASE("bytes_from_h128", "[rpc][conversion]") { SECTION("empty H128", "[rpc][conversion]") { Bytes zeros(16, 0); CHECK(bytes_from_h128(::types::H128{}) == zeros); } SECTION("non-empty H128", "[rpc][conversion]") { auto h128_ptr = sample_h128(); CHECK(bytes_from_h128(*h128_ptr) == kSampleBytes16); } } TEST_CASE("span_from_h128", "[rpc][conversion]") { SECTION("empty H128", "[rpc][conversion]") { std::array zeros{}; std::array uint8_array{}; span_from_h128(::types::H128{}, uint8_array); CHECK(uint8_array == zeros); } SECTION("non-empty H128", "[rpc][conversion]") { auto h128_ptr = sample_h128(); std::array uint8_array{}; span_from_h128(*h128_ptr, uint8_array); CHECK(Bytes{uint8_array.data(), uint8_array.size()} == kSampleBytes16); } } TEST_CASE("convertibility", "[rpc][conversion]") { SECTION("H512<->string", "[rpc][conversion]") { auto h512_ptr1 = sample_h512(); const std::string& s1 = string_from_h512(*h512_ptr1); auto h512_ptr2 = h512_from_string(s1); CHECK(*h512_ptr1 == *h512_ptr2); const auto& s2 = string_from_h512(*h512_ptr2); CHECK(s1 == s2); std::array a1{}; span_from_h512(*h512_ptr1, a1); const Bytes b1{bytes_from_h512(*h512_ptr1)}; CHECK(Bytes{a1.data(), a1.size()} == b1); } SECTION("H256<->bytes32", "[rpc][conversion]") { auto h256_ptr1 = sample_h256(); const auto& hash1 = bytes32_from_h256(*h256_ptr1); auto h256_ptr2 = h256_from_bytes32(hash1); CHECK(*h256_ptr1 == *h256_ptr2); const auto& hash2 = bytes32_from_h256(*h256_ptr2); CHECK(hash1 == hash2); evmc::bytes32 hash3; span_from_h256(*h256_ptr1, hash3.bytes); CHECK(hash1 == hash3); } SECTION("H160<->address", "[rpc][conversion]") { auto hi = new types::H128(); hi->set_hi(0x7F); auto h160_ptr1 = std::make_unique(); h160_ptr1->set_lo(0xFF); h160_ptr1->set_allocated_hi(hi); const auto& address1 = address_from_h160(*h160_ptr1); auto h160_ptr2 = h160_from_address(address1); CHECK(*h160_ptr1 == *h160_ptr2); const auto& address2 = address_from_h160(*h160_ptr2); CHECK(address1 == address2); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/errors.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "errors.hpp" #include namespace silkworm::rpc { // avoid GCC non-virtual-dtor warning #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wnon-virtual-dtor" // NOLINTNEXTLINE(cppcoreguidelines-virtual-class-destructor) class GrpcStatusCodeErrorCategory final : public boost::system::error_category { public: const char* name() const noexcept override { return "rpc::GrpcStatusCodeErrorCategory"; }; std::string message(int ev) const override { switch (static_cast<::grpc::StatusCode>(ev)) { case ::grpc::StatusCode::CANCELLED: return "the operation was cancelled (typically by the caller)"; case ::grpc::StatusCode::UNKNOWN: return "unknown error"; case ::grpc::StatusCode::INVALID_ARGUMENT: return "client specified an invalid argument"; case ::grpc::StatusCode::DEADLINE_EXCEEDED: return "deadline expired before operation could complete"; case ::grpc::StatusCode::NOT_FOUND: return "some requested entity was not found"; case ::grpc::StatusCode::ALREADY_EXISTS: return "some entity that we attempted to create already exists"; case ::grpc::StatusCode::PERMISSION_DENIED: return "the caller does not have permission to execute the specified operation"; case ::grpc::StatusCode::UNAUTHENTICATED: return "the request does not have valid authentication credentials for the operation"; case ::grpc::StatusCode::RESOURCE_EXHAUSTED: return "some resource has been exhausted"; case ::grpc::StatusCode::FAILED_PRECONDITION: return "operation was rejected because the system is not in a state required for the operation execution"; case ::grpc::StatusCode::ABORTED: return "the operation was aborted"; case ::grpc::StatusCode::OUT_OF_RANGE: return "operation was attempted past the valid range"; case ::grpc::StatusCode::UNIMPLEMENTED: return "operation is not implemented or not supported/enabled in this service"; case ::grpc::StatusCode::INTERNAL: return "internal error"; case ::grpc::StatusCode::UNAVAILABLE: return "the service is currently unavailable"; case ::grpc::StatusCode::DATA_LOSS: return "unrecoverable data loss or corruption"; default: return "unexpected error occurred"; } } static GrpcStatusCodeErrorCategory instance; }; #pragma GCC diagnostic pop GrpcStatusCodeErrorCategory GrpcStatusCodeErrorCategory::instance; boost::system::error_code to_system_code(::grpc::StatusCode status_code) { return {static_cast(status_code), GrpcStatusCodeErrorCategory::instance}; } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/errors.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { //! \details To raise a boost::system::system_error exception: //! \code throw boost::system::system_error{rpc::to_system_code(grpc_status_code)}; boost::system::error_code to_system_code(::grpc::StatusCode); } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/grpc_context_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::rpc { struct GrpcContextPool { virtual ~GrpcContextPool() = default; virtual agrpc::GrpcContext& any_grpc_context() = 0; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/util.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace grpc { // operator== overloading for grpc::Status is *NOT* present in gRPC library inline bool operator==(const Status& lhs, const Status& rhs) { return lhs.error_code() == rhs.error_code() && lhs.error_message() == rhs.error_message() && lhs.error_details() == rhs.error_details(); } inline std::string status_to_string(const Status& status) { std::stringstream out; out << "status=" << (status.ok() ? "OK" : "KO"); if (!status.ok()) { out << " error_code=" << status.error_code() << " error_message=" << status.error_message() << " error_details=" << status.error_details(); } return out.str(); } // operator<< overloading for grpc::Status is *NOT* present in gRPC library inline std::ostream& operator<<(std::ostream& out, const Status& status) { out << status_to_string(status); return out; } } // namespace grpc namespace silkworm::log { inline absl::LogSeverityAtLeast absl_min_log_level_from_silkworm(Level level) { switch (level) { case Level::kNone: return absl::LogSeverityAtLeast::kInfinity; case Level::kCritical: return absl::LogSeverityAtLeast::kFatal; case Level::kError: return absl::LogSeverityAtLeast::kError; case Level::kWarning: return absl::LogSeverityAtLeast::kWarning; case Level::kInfo: case Level::kDebug: case Level::kTrace: return absl::LogSeverityAtLeast::kInfo; } SILKWORM_ASSERT(false); return absl::LogSeverityAtLeast::kInfinity; } inline int absl_max_vlog_level_from_silkworm(Level level) { switch (level) { case Level::kNone: return -1; case Level::kCritical: case Level::kError: case Level::kWarning: case Level::kInfo: return 0; case Level::kDebug: return 2; case Level::kTrace: return 4; } SILKWORM_ASSERT(false); return -1; } inline Level level_from_absl(absl::LogSeverity severity, int verbosity) { if (verbosity >= 4) return Level::kTrace; if (verbosity >= 2) return Level::kDebug; switch (severity) { case absl::LogSeverity::kInfo: return Level::kInfo; case absl::LogSeverity::kWarning: return Level::kWarning; case absl::LogSeverity::kError: return Level::kError; case absl::LogSeverity::kFatal: return Level::kCritical; } return Level::kNone; } //! Define a gRPC logging function delegating to Silkworm logging facility. struct AbseilToSilkwormLogSink : public absl::LogSink { ~AbseilToSilkwormLogSink() override = default; void Send(const absl::LogEntry& entry) override { Level level = level_from_absl(entry.log_severity(), entry.verbosity()); if (test_verbosity(level)) { auto text_message = entry.text_message(); BufferBase log{level, {text_message.data(), text_message.size()}, {}}; } } }; struct AbseilToVoidLogSink : public absl::LogSink { ~AbseilToVoidLogSink() override = default; void Send(const absl::LogEntry&) override {} }; //! Utility to configure absl::LogSink using RAII for an instance lifetime. template class AbseilLogGuard { public: explicit AbseilLogGuard() { absl::AddLogSink(&sink_); } ~AbseilLogGuard() { absl::RemoveLogSink(&sink_); } const TLogSink& sink() const { return sink_; } private: TLogSink sink_; }; } // namespace silkworm::log ================================================ FILE: silkworm/infra/grpc/common/util_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include #include #include #include namespace silkworm::rpc { // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("print grpc::Status", "[silkworm][rpc][util]") { CHECK_NOTHROW(test_util::null_stream() << grpc::Status::OK); CHECK_NOTHROW(test_util::null_stream() << grpc::Status::CANCELLED); } TEST_CASE("compare grpc::Status", "[silkworm][rpc][util]") { CHECK(grpc::Status::OK == grpc::Status::OK); CHECK(!(grpc::Status::OK == grpc::Status::CANCELLED)); grpc::Status status1{grpc::StatusCode::INTERNAL, "error"}; grpc::Status status2{grpc::StatusCode::INTERNAL, "err"}; CHECK(!(status1 == status2)); grpc::Status status3{grpc::StatusCode::INTERNAL, "error", "details"}; grpc::Status status4{grpc::StatusCode::INTERNAL, "error", ""}; CHECK(!(status3 == status4)); } #ifdef SILKWORM_TEST_SKIP TEST_CASE("AbseilLogGuard", "[silkworm][rpc][util]") { struct TestLogSink : public absl::LogSink { bool message_sent{}; ~TestLogSink() override = default; void Send(const absl::LogEntry&) override { message_sent = true; } }; log::Settings settings{ .log_nocolor = true, .log_verbosity = log::Level::kInfo, }; log::init(settings); log::AbseilLogGuard log_guard; CHECK_FALSE(log_guard.sink().message_sent); ABSL_LOG(INFO) << "message for TestLogSink"; CHECK(log_guard.sink().message_sent); } #endif // SILKWORM_TEST_SKIP #ifdef SILKWORM_TEST_SKIP TEST_CASE("AbseilToSilkwormLogSink", "[silkworm][rpc][util]") { log::Settings settings{ .log_nocolor = true, .log_verbosity = log::Level::kTrace, }; log::init(settings); // ABSL_LOG(FATAL) << "ABSL_LOG(FATAL)"; ABSL_LOG(ERROR) << "ABSL_LOG(ERROR) @ Level::kError"; ABSL_LOG(WARNING) << "ABSL_LOG(WARN) @ Level::kWarn"; ABSL_LOG(INFO) << "ABSL_LOG(INFO) @ Level::kInfo"; ABSL_VLOG(2) << "ABSL_VLOG(2) @ Level::kDebug"; ABSL_VLOG(4) << "ABSL_VLOG(4) @ Level::kTrace"; } #endif // SILKWORM_TEST_SKIP #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/version.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "version.hpp" #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const ProtocolVersion& v) { out << v.to_string(); return out; } std::string ProtocolVersion::to_string() const { const auto& v = *this; std::stringstream out; out << v.major << "." << v.minor << "." << v.patch; return out.str(); } template ProtocolVersionResult wait_for_protocol_check(const std::unique_ptr& stub, const ProtocolVersion& version, const std::string& name) { grpc::ClientContext context; context.set_wait_for_ready(true); types::VersionReply version_reply; const auto status = stub->Version(&context, google::protobuf::Empty{}, &version_reply); if (!status.ok()) { return ProtocolVersionResult{false, name + " incompatible interface: " + status.error_message() + " [" + status.error_details() + "]"}; } ProtocolVersion server_version{version_reply.major(), version_reply.minor(), version_reply.patch()}; std::stringstream vv_stream; vv_stream << "client=" << version << " server=" << server_version; if (version.major != server_version.major) { // NOLINT(bugprone-branch-clone) return ProtocolVersionResult{false, name + " incompatible interface: " + vv_stream.str()}; } if (version.minor != server_version.minor) { return ProtocolVersionResult{false, name + " incompatible interface: " + vv_stream.str()}; } return ProtocolVersionResult{true, name + " compatible interface: " + vv_stream.str()}; } template struct NewStubFactory final { std::unique_ptr operator()(const std::shared_ptr& channel, const grpc::StubOptions& options = grpc::StubOptions()) { return std::invoke(Func, channel, options); } }; ProtocolVersionResult wait_for_kv_protocol_check(const std::unique_ptr<::remote::KV::StubInterface>& stub) { return wait_for_protocol_check(stub, kKvServiceApiVersion, "KV"); } ProtocolVersionResult wait_for_kv_protocol_check(const std::shared_ptr& channel) { NewStubFactory<::remote::KV::NewStub, ::remote::KV::StubInterface> new_stub_factory; return wait_for_protocol_check(new_stub_factory(channel), kKvServiceApiVersion, "KV"); } ProtocolVersionResult wait_for_ethbackend_protocol_check(const std::unique_ptr<::remote::ETHBACKEND::StubInterface>& stub) { return wait_for_protocol_check(stub, kEthBackEndServiceApiVersion, "ETHBACKEND"); } ProtocolVersionResult wait_for_ethbackend_protocol_check(const std::shared_ptr& channel) { NewStubFactory<::remote::ETHBACKEND::NewStub, ::remote::ETHBACKEND::StubInterface> new_stub_factory; return wait_for_protocol_check(new_stub_factory(channel), kEthBackEndServiceApiVersion, "ETHBACKEND"); } ProtocolVersionResult wait_for_mining_protocol_check(const std::unique_ptr<::txpool::Mining::StubInterface>& stub) { return wait_for_protocol_check(stub, kMiningServiceApiVersion, "MINING"); } ProtocolVersionResult wait_for_mining_protocol_check(const std::shared_ptr& channel) { NewStubFactory<::txpool::Mining::NewStub, ::txpool::Mining::StubInterface> new_stub_factory; return wait_for_protocol_check(new_stub_factory(channel), kMiningServiceApiVersion, "MINING"); } ProtocolVersionResult wait_for_txpool_protocol_check(const std::unique_ptr<::txpool::Txpool::StubInterface>& stub) { return wait_for_protocol_check(stub, kTxPoolServiceApiVersion, "TXPOOL"); } ProtocolVersionResult wait_for_txpool_protocol_check(const std::shared_ptr& channel) { NewStubFactory<::txpool::Txpool::NewStub, ::txpool::Txpool::StubInterface> new_stub_factory; return wait_for_protocol_check(new_stub_factory(channel), kTxPoolServiceApiVersion, "TXPOOL"); } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/version.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { struct ProtocolVersion { uint32_t major; uint32_t minor; uint32_t patch; std::string to_string() const; }; inline constexpr ProtocolVersion kKvServiceApiVersion{7, 0, 0}; inline constexpr ProtocolVersion kEthBackEndServiceApiVersion{3, 3, 0}; inline constexpr ProtocolVersion kMiningServiceApiVersion{1, 0, 0}; inline constexpr ProtocolVersion kTxPoolServiceApiVersion{1, 0, 0}; std::ostream& operator<<(std::ostream& out, const ProtocolVersion& v); struct ProtocolVersionResult { bool compatible; std::string result; }; ProtocolVersionResult wait_for_kv_protocol_check(const std::unique_ptr<::remote::KV::StubInterface>& stub); ProtocolVersionResult wait_for_kv_protocol_check(const std::shared_ptr& channel); ProtocolVersionResult wait_for_ethbackend_protocol_check(const std::unique_ptr<::remote::ETHBACKEND::StubInterface>& stub); ProtocolVersionResult wait_for_ethbackend_protocol_check(const std::shared_ptr& channel); ProtocolVersionResult wait_for_mining_protocol_check(const std::unique_ptr<::txpool::Mining::StubInterface>& stub); ProtocolVersionResult wait_for_mining_protocol_check(const std::shared_ptr& channel); ProtocolVersionResult wait_for_txpool_protocol_check(const std::unique_ptr<::txpool::Txpool::StubInterface>& stub); ProtocolVersionResult wait_for_txpool_protocol_check(const std::shared_ptr& channel); } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/common/version_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "version.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../test_util/interfaces/ethbackend_mock_fix24351.grpc.pb.h" #include "../test_util/interfaces/kv_mock_fix24351.grpc.pb.h" #include "../test_util/interfaces/mining_mock_fix24351.grpc.pb.h" #include "../test_util/interfaces/txpool_mock_fix24351.grpc.pb.h" namespace silkworm::rpc { using testing::_; using testing::DoAll; using testing::Return; using testing::SetArgPointee; #ifndef SILKWORM_SANITIZE TEST_CASE("write protocol version to ostream", "[rpc][protocol][version]") { const ProtocolVersion v{1, 0, 0}; CHECK_NOTHROW(silkworm::test_util::null_stream() << v); } TEST_CASE("ETHBACKEND protocol version error", "[rpc][protocol][wait_for_ethbackend_protocol_check]") { std::unique_ptr<::remote::ETHBACKEND::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockETHBACKENDStub>()}; EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockETHBACKENDStub*>(stub.get()), Version(_, _, _)).WillOnce(Return(grpc::Status::CANCELLED)); const auto version_result{wait_for_ethbackend_protocol_check(stub)}; CHECK(version_result.compatible == false); CHECK(absl::StrContains(version_result.result, "incompatible")); } TEST_CASE("ETHBACKEND protocol version major mismatch", "[rpc][protocol][wait_for_ethbackend_protocol_check]") { std::unique_ptr<::remote::ETHBACKEND::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockETHBACKENDStub>()}; types::VersionReply reply; reply.set_major(1); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockETHBACKENDStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result1{wait_for_ethbackend_protocol_check(stub)}; CHECK(version_result1.compatible == false); CHECK(absl::StrContains(version_result1.result, "incompatible")); reply.set_major(3); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockETHBACKENDStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result2{wait_for_ethbackend_protocol_check(stub)}; CHECK(version_result2.compatible == false); CHECK(absl::StrContains(version_result2.result, "incompatible")); } TEST_CASE("ETHBACKEND protocol version minor mismatch", "[rpc][protocol][wait_for_ethbackend_protocol_check]") { std::unique_ptr<::remote::ETHBACKEND::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockETHBACKENDStub>()}; types::VersionReply reply; reply.set_major(2); reply.set_minor(2); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockETHBACKENDStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result1{wait_for_ethbackend_protocol_check(stub)}; CHECK(version_result1.compatible == false); CHECK(absl::StrContains(version_result1.result, "incompatible")); reply.set_minor(4); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockETHBACKENDStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result2{wait_for_ethbackend_protocol_check(stub)}; CHECK(version_result2.compatible == false); CHECK(absl::StrContains(version_result2.result, "incompatible")); } TEST_CASE("ETHBACKEND protocol version match", "[rpc][protocol][wait_for_ethbackend_protocol_check]") { std::unique_ptr<::remote::ETHBACKEND::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockETHBACKENDStub>()}; types::VersionReply reply; reply.set_major(3); reply.set_minor(3); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockETHBACKENDStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result{wait_for_ethbackend_protocol_check(stub)}; CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } TEST_CASE("ETHBACKEND protocol version with server stub", "[rpc][protocol][wait_for_ethbackend_protocol_check]") { class TestService : public ::remote::ETHBACKEND::Service { public: ::grpc::Status Version(::grpc::ServerContext*, const ::google::protobuf::Empty*, ::types::VersionReply* response) override { response->set_major(3); response->set_minor(3); response->set_patch(0); return ::grpc::Status::OK; } }; TestService service; std::ostringstream server_address; server_address << "localhost:" << 12345; // TODO(canepat): grpc_pick_unused_port_or_die grpc::ServerBuilder builder; builder.AddListeningPort(server_address.str(), grpc::InsecureServerCredentials()); builder.RegisterService(&service); const auto server_ptr = builder.BuildAndStart(); const auto channel = grpc::CreateChannel(server_address.str(), grpc::InsecureChannelCredentials()); const auto version_result{wait_for_ethbackend_protocol_check(channel)}; server_ptr->Shutdown(); CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } TEST_CASE("KV protocol version error", "[rpc][protocol][wait_for_kv_protocol_check]") { std::unique_ptr<::remote::KV::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockKVStub>()}; EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockKVStub*>(stub.get()), Version(_, _, _)).WillOnce(Return(grpc::Status::CANCELLED)); const auto version_result{wait_for_kv_protocol_check(stub)}; CHECK(version_result.compatible == false); CHECK(absl::StrContains(version_result.result, "incompatible")); } TEST_CASE("KV protocol version major mismatch", "[rpc][protocol][wait_for_kv_protocol_check]") { std::unique_ptr<::remote::KV::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockKVStub>()}; types::VersionReply reply; reply.set_major(kKvServiceApiVersion.major - 1); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockKVStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result1{wait_for_kv_protocol_check(stub)}; CHECK(version_result1.compatible == false); CHECK(absl::StrContains(version_result1.result, "incompatible")); reply.set_major(kKvServiceApiVersion.major + 1); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockKVStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result2{wait_for_kv_protocol_check(stub)}; CHECK(version_result2.compatible == false); CHECK(absl::StrContains(version_result2.result, "incompatible")); } TEST_CASE("KV protocol version minor mismatch", "[rpc][protocol][wait_for_kv_protocol_check]") { std::unique_ptr<::remote::KV::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockKVStub>()}; types::VersionReply reply; reply.set_major(kKvServiceApiVersion.major); // Major is unchanged reply.set_minor(kKvServiceApiVersion.minor + 1); // Minor is different EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockKVStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result{wait_for_kv_protocol_check(stub)}; CHECK(version_result.compatible == false); CHECK(absl::StrContains(version_result.result, "incompatible")); } TEST_CASE("KV protocol version match", "[rpc][protocol][wait_for_kv_protocol_check]") { std::unique_ptr<::remote::KV::StubInterface> stub{std::make_unique<::remote::FixIssue24351_MockKVStub>()}; types::VersionReply reply; reply.set_major(7); reply.set_minor(0); EXPECT_CALL(*dynamic_cast<::remote::FixIssue24351_MockKVStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result{wait_for_kv_protocol_check(stub)}; CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } TEST_CASE("KV protocol version with server stub", "[rpc][protocol][wait_for_kv_protocol_check]") { class TestService : public ::remote::KV::Service { public: ::grpc::Status Version(::grpc::ServerContext*, const ::google::protobuf::Empty*, ::types::VersionReply* response) override { response->set_major(7); response->set_minor(0); response->set_patch(0); return ::grpc::Status::OK; } }; TestService service; std::ostringstream server_address; server_address << "localhost:" << 12345; // TODO(canepat): grpc_pick_unused_port_or_die grpc::ServerBuilder builder; builder.AddListeningPort(server_address.str(), grpc::InsecureServerCredentials()); builder.RegisterService(&service); const auto server_ptr = builder.BuildAndStart(); const auto channel = grpc::CreateChannel(server_address.str(), grpc::InsecureChannelCredentials()); const auto version_result{wait_for_kv_protocol_check(channel)}; server_ptr->Shutdown(); CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } TEST_CASE("MINING protocol version error", "[rpc][protocol][wait_for_mining_protocol_check]") { std::unique_ptr<::txpool::Mining::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockMiningStub>()}; EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockMiningStub*>(stub.get()), Version(_, _, _)).WillOnce(Return(grpc::Status::CANCELLED)); const auto version_result{wait_for_mining_protocol_check(stub)}; CHECK(version_result.compatible == false); CHECK(absl::StrContains(version_result.result, "incompatible")); } TEST_CASE("MINING protocol version major mismatch", "[rpc][protocol][wait_for_mining_protocol_check]") { std::unique_ptr<::txpool::Mining::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockMiningStub>()}; types::VersionReply reply; reply.set_major(0); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockMiningStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result1{wait_for_mining_protocol_check(stub)}; CHECK(version_result1.compatible == false); CHECK(absl::StrContains(version_result1.result, "incompatible")); reply.set_major(2); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockMiningStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result2{wait_for_mining_protocol_check(stub)}; CHECK(version_result2.compatible == false); CHECK(absl::StrContains(version_result2.result, "incompatible")); } TEST_CASE("MINING protocol version minor mismatch", "[rpc][protocol][wait_for_mining_protocol_check]") { std::unique_ptr<::txpool::Mining::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockMiningStub>()}; types::VersionReply reply; reply.set_major(1); reply.set_minor(1); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockMiningStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result{wait_for_mining_protocol_check(stub)}; CHECK(version_result.compatible == false); CHECK(absl::StrContains(version_result.result, "incompatible")); } TEST_CASE("MINING protocol version match", "[rpc][protocol][wait_for_mining_protocol_check]") { std::unique_ptr<::txpool::Mining::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockMiningStub>()}; types::VersionReply reply; reply.set_major(1); reply.set_minor(0); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockMiningStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result{wait_for_mining_protocol_check(stub)}; CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } TEST_CASE("MINING protocol version with server stub", "[rpc][protocol][wait_for_mining_protocol_check]") { class TestService : public ::txpool::Mining::Service { public: ::grpc::Status Version(::grpc::ServerContext*, const ::google::protobuf::Empty*, ::types::VersionReply* response) override { response->set_major(1); response->set_minor(0); response->set_patch(0); return ::grpc::Status::OK; } }; TestService service; std::ostringstream server_address; server_address << "localhost:" << 12345; // TODO(canepat): grpc_pick_unused_port_or_die grpc::ServerBuilder builder; builder.AddListeningPort(server_address.str(), grpc::InsecureServerCredentials()); builder.RegisterService(&service); const auto server_ptr = builder.BuildAndStart(); const auto channel = grpc::CreateChannel(server_address.str(), grpc::InsecureChannelCredentials()); const auto version_result{wait_for_mining_protocol_check(channel)}; server_ptr->Shutdown(); CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } TEST_CASE("TXPOOL protocol version error", "[rpc][protocol][wait_for_txpool_protocol_check]") { std::unique_ptr<::txpool::Txpool::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockTxpoolStub>()}; EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockTxpoolStub*>(stub.get()), Version(_, _, _)).WillOnce(Return(grpc::Status::CANCELLED)); const auto version_result{wait_for_txpool_protocol_check(stub)}; CHECK(version_result.compatible == false); CHECK(absl::StrContains(version_result.result, "incompatible")); } TEST_CASE("TXPOOL protocol version major mismatch", "[rpc][protocol][wait_for_txpool_protocol_check]") { std::unique_ptr<::txpool::Txpool::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockTxpoolStub>()}; types::VersionReply reply; reply.set_major(0); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockTxpoolStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result1{wait_for_txpool_protocol_check(stub)}; CHECK(version_result1.compatible == false); CHECK(absl::StrContains(version_result1.result, "incompatible")); reply.set_major(2); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockTxpoolStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result2{wait_for_txpool_protocol_check(stub)}; CHECK(version_result2.compatible == false); CHECK(absl::StrContains(version_result2.result, "incompatible")); } TEST_CASE("TXPOOL protocol version minor mismatch", "[rpc][protocol][wait_for_txpool_protocol_check]") { std::unique_ptr<::txpool::Txpool::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockTxpoolStub>()}; types::VersionReply reply; reply.set_major(1); reply.set_minor(1); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockTxpoolStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result{wait_for_txpool_protocol_check(stub)}; CHECK(version_result.compatible == false); CHECK(absl::StrContains(version_result.result, "incompatible")); } TEST_CASE("TXPOOL protocol version match", "[rpc][protocol][wait_for_txpool_protocol_check]") { std::unique_ptr<::txpool::Txpool::StubInterface> stub{std::make_unique<::txpool::FixIssue24351_MockTxpoolStub>()}; types::VersionReply reply; reply.set_major(1); reply.set_minor(0); EXPECT_CALL(*dynamic_cast<::txpool::FixIssue24351_MockTxpoolStub*>(stub.get()), Version(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(reply), Return(grpc::Status::OK))); const auto version_result{wait_for_txpool_protocol_check(stub)}; CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } TEST_CASE("TXPOOL protocol version with server stub", "[rpc][protocol][wait_for_txpool_protocol_check]") { class TestService : public ::txpool::Txpool::Service { public: ::grpc::Status Version(::grpc::ServerContext*, const ::google::protobuf::Empty*, ::types::VersionReply* response) override { response->set_major(1); response->set_minor(0); response->set_patch(0); return ::grpc::Status::OK; } }; TestService service; std::ostringstream server_address; server_address << "localhost:" << 12345; // TODO(canepat): grpc_pick_unused_port_or_die grpc::ServerBuilder builder; builder.AddListeningPort(server_address.str(), grpc::InsecureServerCredentials()); builder.RegisterService(&service); const auto server_ptr = builder.BuildAndStart(); const auto channel = grpc::CreateChannel(server_address.str(), grpc::InsecureChannelCredentials()); const auto version_result{wait_for_txpool_protocol_check(channel)}; server_ptr->Shutdown(); CHECK(version_result.compatible == true); CHECK(!absl::StrContains(version_result.result, "incompatible")); CHECK(absl::StrContains(version_result.result, "compatible")); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include #include namespace silkworm::rpc { //! Register a server-side RPC repeatedly: whenever a client request is accepted, another waiting RPC is started template void request_repeatedly(agrpc::GrpcContext& grpc_context, const AsyncService& service, RPC rpc, RequestHandler&& handler) { agrpc::repeatedly_request(rpc, *service, boost::asio::bind_executor(grpc_context, std::forward(handler))); } namespace server { //! The max idle interval to protect from clients which don't send any requests. constexpr std::chrono::milliseconds kDefaultMaxIdleDuration{30'000}; //! This represents the server-side base gRPC call. class Call { public: //! Returns the number of outstanding RPC instances. static int64_t instance_count() { return instance_count_; } //! Returns the number of total RPC instances. static uint64_t total_count() { return total_count_; } explicit Call(grpc::ServerContext& server_context) : server_context_(server_context) { ++instance_count_; ++total_count_; SILK_TRACE << "Call::Call [" << this << "] instances: " << instance_count() << " total: " << total_count(); } ~Call() { --instance_count_; SILK_TRACE << "Call::~Call [" << this << "] instances: " << instance_count() << " total: " << total_count(); } //! Returns a unique identifier of the RPC client for this call. std::string peer() const { return server_context_.peer(); } protected: //! Used to access the options and current status of the RPC. grpc::ServerContext& server_context_; private: //! Keep track of the total outstanding RPC calls (intentionally signed to spot underflow). static inline std::atomic_int64_t instance_count_{0}; //! Keep track of the total RPC calls. static inline std::atomic_uint64_t total_count_{0}; }; //! This represents any unary RPC (i.e. one-client-request, one-server-response). template class UnaryCall : public Call { public: using Base = UnaryCall; using Responder = grpc::ServerAsyncResponseWriter; UnaryCall(grpc::ServerContext& server_context, Request& request, Responder& responder) : Call(server_context), request_(request), responder_(responder) {} protected: Request& request_; Responder& responder_; }; //! This represents any server-streaming RPC (i.e. one-client-request, many-server-responses). template class ServerStreamingCall : public Call { public: using Base = ServerStreamingCall; using Responder = grpc::ServerAsyncWriter; ServerStreamingCall(grpc::ServerContext& server_context, Request& request, Responder& responder) : Call(server_context), request_(request), responder_(responder) {} protected: Request& request_; Responder& responder_; }; //! This represents any bidirectional-streaming RPC (i.e. many-client-requests, many-server-responses). template class BidiStreamingCall : public Call { public: using Base = BidiStreamingCall; using Responder = grpc::ServerAsyncReaderWriter; static void set_max_idle_duration(const std::chrono::milliseconds& max_idle_duration) { max_idle_duration_ = max_idle_duration; } BidiStreamingCall(agrpc::GrpcContext& grpc_context, grpc::ServerContext& server_context, Responder& responder) : Call(server_context), responder_(responder), grpc_context_(grpc_context) {} protected: static inline std::chrono::milliseconds max_idle_duration_{kDefaultMaxIdleDuration}; Responder& responder_; agrpc::GrpcContext& grpc_context_; }; class CallException : public std::runtime_error { public: explicit CallException(grpc::Status status) : std::runtime_error(status.error_message()), status_(std::move(status)) {} grpc::Status status() const { return status_; } private: grpc::Status status_; }; } // namespace server } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/call_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call.hpp" #include #include namespace silkworm::rpc { TEST_CASE("BaseRpc", "[silkworm][rpc][call][.]") { class FakeRpc : public server::Call { public: explicit FakeRpc(grpc::ServerContext& server_context) : server::Call(server_context) {} }; grpc::ServerContext server_context; SECTION("count live instances") { REQUIRE(FakeRpc::instance_count() == 0); { FakeRpc rpc1{server_context}; CHECK(FakeRpc::instance_count() == 1); } REQUIRE(FakeRpc::instance_count() == 0); { FakeRpc rpc1{server_context}; CHECK(FakeRpc::instance_count() == 1); FakeRpc rpc2{server_context}; CHECK(FakeRpc::instance_count() == 2); } REQUIRE(FakeRpc::instance_count() == 0); } SECTION("count total instances") { FakeRpc rpc{server_context}; CHECK(FakeRpc::total_count() > 0); } SECTION("peer") { FakeRpc rpc{server_context}; CHECK(rpc.peer().empty()); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include "silkworm/infra/grpc/server/server_callbacks.hpp" namespace silkworm::rpc { //! Base RPC server able to serve incoming requests for gRPC \ref AsyncService instances. class Server { public: //! Build a ready-to-start RPC server according to specified configuration. explicit Server(ServerSettings settings) : settings_{std::move(settings)} {} /** * No need to explicitly shut down the server because this destructor takes care. * Use \ref shutdown() if you want explicit control over termination before destruction. */ virtual ~Server() { SILK_TRACE << "Server::~Server " << this << " START"; shutdown(); SILK_TRACE << "Server::~Server " << this << " END"; } Server(const Server&) = delete; Server& operator=(const Server&) = delete; //! Build the RPC server according to its configuration. void build_and_start() { SILK_TRACE << "Server::build_and_start " << this << " START"; if (shutdown_) { SILK_TRACE << "Server::build_and_start " << this << " already shut down END"; return; } grpc::ServerBuilder builder; // Disable SO_REUSEPORT socket option to obtain "address already in use" on Windows. builder.AddChannelArgument(GRPC_ARG_ALLOW_REUSEPORT, 0); // Add the local endpoint to bind the RPC server to (selected_port will be set *after* BuildAndStart call). int selected_port{0}; builder.AddListeningPort(settings_.address_uri, settings_.credentials, &selected_port); context_pool_ = std::make_unique(settings_.context_pool_settings, builder); // gRPC async model requires the server to register the RPC services first. SILK_TRACE << "Server " << this << " registering async services"; register_async_services(builder); server_ = builder.BuildAndStart(); if (server_ == nullptr) { std::string error_msg = "cannot start gRPC server at " + settings_.address_uri; if (ServerGlobalCallbacks::check_and_clear_bad_port_error()) { error_msg += " (port already in use)"; } SILK_ERROR << "Server " << this << " BuildAndStart failed [" << settings_.address_uri << "]"; throw std::runtime_error(error_msg); } // gRPC async model requires the server to register one request call for each RPC in advance. SILK_TRACE << "Server " << this << " registering request calls"; register_request_calls(); // Start the server execution: the context pool will spawn the context threads. SILK_TRACE << "Server " << this << " starting execution loop"; context_pool_->start(); SILK_TRACE << "Server::build_and_start " << this << " END"; } //! Join the RPC server execution loop and block until \ref shutdown() is called on this Server instance. void join() { SILK_TRACE << "Server::join " << this << " START"; if (context_pool_) { context_pool_->join(); } SILK_TRACE << "Server::join " << this << " END"; } //! Stop this Server instance forever. Any subsequent call to \ref build_and_start() has no effect. void shutdown() { SILK_TRACE << "Server::shutdown " << this << " START"; if (shutdown_) { SILK_TRACE << "Server::shutdown " << this << " already shut down END"; return; } shutdown_ = true; SILK_TRACE << "Server::shutdown " << this << " shutting down server immediately"; // Order matters here: 1) shutdown the server (immediate deadline) if (server_) { server_->Shutdown(gpr_time_0(GPR_CLOCK_REALTIME)); server_->Wait(); } SILK_TRACE << "Server::shutdown " << this << " stopping context pool"; // Order matters here: 2) shutdown and drain the queues if (context_pool_) { context_pool_->stop(); } SILK_TRACE << "Server::shutdown " << this << " END"; } Task async_run(const char* thread_name, std::optional stack_size = {}) { auto run = [this] { this->build_and_start(); this->join(); }; auto stop = [this] { this->shutdown(); }; co_await concurrency::async_thread(std::move(run), std::move(stop), thread_name, stack_size); } //! Returns the number of server contexts. size_t num_contexts() const { return context_pool_ ? context_pool_->size() : 0; } //! Get the next server context in round-robin scheme. ServerContext const& next_context() { SILKWORM_ASSERT(context_pool_); return context_pool_->next_context(); } //! Get the next server scheduler in round-robin scheme. boost::asio::io_context& next_ioc() { SILKWORM_ASSERT(context_pool_); return context_pool_->next_ioc(); } protected: //! Subclasses must override this method to register gRPC RPC services into the server. virtual void register_async_services(grpc::ServerBuilder& builder) = 0; //! Subclasses must override this method to register initial server-side RPC requests. virtual void register_request_calls() = 0; const ServerSettings& settings() const { return settings_; } private: //! The server configuration options. ServerSettings settings_; //! The gRPC server instance tied to this Server lifetime. std::unique_ptr server_; //! The global callbacks are shared between all instances of Servers static inline const ServerGlobalCallbacks kGlobalCallbacks; //! Pool of server schedulers used to run the execution loops. std::unique_ptr context_pool_; bool shutdown_{false}; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server_callbacks.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc { class ServerGlobalCallbacks { public: ServerGlobalCallbacks() { // NOTE: Despite its documentation, SetGlobalCallbacks() does take the ownership // of the object pointer. So we just "new" and let underlying GRPC manage its lifetime. static std::once_flag callback_init_flag; std::call_once(callback_init_flag, []() { grpc::Server::SetGlobalCallbacks(new Callbacks()); }); } static bool check_and_clear_bad_port_error() { return bad_port_error.exchange(false); } private: static inline std::atomic bad_port_error{false}; class Callbacks final : public grpc::Server::GlobalCallbacks { public: Callbacks() = default; ~Callbacks() override = default; void PreSynchronousRequest(grpc::ServerContext*) override{}; void PostSynchronousRequest(grpc::ServerContext*) override{}; void AddPort(grpc::Server*, const std::string&, grpc::ServerCredentials*, int port) override { if (port == 0) { ServerGlobalCallbacks::bad_port_error.store(true, std::memory_order_release); } } }; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server_context_pool.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server_context_pool.hpp" #include #include #include namespace silkworm::rpc { using namespace concurrency; static std::string build_thread_name(const char name_tag[11], size_t id) { return {name_tag + std::to_string(id)}; } ServerContext::ServerContext(size_t context_id, ServerCompletionQueuePtr queue) : Context{context_id}, server_grpc_context_{std::make_unique(std::move(queue))}, client_grpc_context_{std::make_unique()}, server_grpc_context_work_{boost::asio::make_work_guard(server_grpc_context_->get_executor())}, client_grpc_context_work_{boost::asio::make_work_guard(client_grpc_context_->get_executor())} {} void ServerContext::execute_loop() { SILK_TRACE << "ServerContext execution loop start [" << std::this_thread::get_id() << "]"; std::thread server_grpc_context_thread{[&]() { log::set_thread_name(build_thread_name("grpc_ctx_s", id()).c_str()); SILK_TRACE << "Server GrpcContext execution loop start [" << std::this_thread::get_id() << "]"; server_grpc_context_->run(); SILK_TRACE << "Server GrpcContext execution loop end [" << std::this_thread::get_id() << "]"; }}; std::thread client_grpc_context_thread{[&]() { log::set_thread_name(build_thread_name("grpc_ctx_c", id()).c_str()); SILK_TRACE << "Client GrpcContext execution loop start [" << std::this_thread::get_id() << "]"; client_grpc_context_->run_completion_queue(); SILK_TRACE << "Client GrpcContext execution loop end [" << std::this_thread::get_id() << "]"; }}; std::exception_ptr run_exception; try { ioc()->run(); } catch (...) { run_exception = std::current_exception(); } server_grpc_context_work_.reset(); client_grpc_context_work_.reset(); server_grpc_context_->stop(); client_grpc_context_->stop(); server_grpc_context_thread.join(); client_grpc_context_thread.join(); if (run_exception) { std::rethrow_exception(run_exception); } SILK_TRACE << "ServerContext execution loop end [" << std::this_thread::get_id() << "]"; } ServerContextPool::ServerContextPool( concurrency::ContextPoolSettings settings, grpc::ServerBuilder& server_builder) { if (settings.num_contexts == 0) { throw std::logic_error("ServerContextPool size is 0"); } for (size_t i{0}; i < settings.num_contexts; ++i) { add_context(ServerContext{i, server_builder.AddCompletionQueue()}); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server_context_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include namespace silkworm::rpc { using ServerCompletionQueuePtr = std::unique_ptr<::grpc::ServerCompletionQueue>; //! Asynchronous server scheduler running an execution loop w/ integrated gRPC server. class ServerContext : public concurrency::Context { public: ServerContext(size_t context_id, ServerCompletionQueuePtr server_queue); agrpc::GrpcContext* server_grpc_context() const noexcept { return server_grpc_context_.get(); } agrpc::GrpcContext* client_grpc_context() const noexcept { return client_grpc_context_.get(); } //! Execute the scheduler loop until stopped. void execute_loop() override; private: //! The asio-grpc asynchronous event schedulers. std::unique_ptr server_grpc_context_; std::unique_ptr client_grpc_context_; //! The work-tracking executors that keep the asio-grpc scheduler running. boost::asio::executor_work_guard server_grpc_context_work_; boost::asio::executor_work_guard client_grpc_context_work_; }; //! Pool of \ref ServerContext instances running as separate reactive schedulers. class ServerContextPool : public concurrency::ContextPool { public: ServerContextPool( concurrency::ContextPoolSettings settings, grpc::ServerBuilder& server_builder); ServerContextPool(const ServerContextPool&) = delete; ServerContextPool& operator=(const ServerContextPool&) = delete; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server_context_pool_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server_context_pool.hpp" #include #include #include #include #include #include #include #include namespace silkworm::rpc { using namespace concurrency; // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("ServerContext", "[silkworm][infra][grpc][server][server_context]") { grpc::ServerBuilder builder; std::unique_ptr scq = builder.AddCompletionQueue(); grpc::ServerCompletionQueue* scq_ptr = scq.get(); ServerContext server_context{0, std::move(scq)}; SECTION("ServerContext") { CHECK(server_context.server_grpc_context() != nullptr); CHECK(server_context.client_grpc_context() != nullptr); CHECK(server_context.ioc() != nullptr); CHECK(server_context.server_grpc_context()->get_completion_queue() == scq_ptr); CHECK(server_context.client_grpc_context()->get_completion_queue() != nullptr); } SECTION("execute_loop") { boost::asio::executor_work_guard work = boost::asio::make_work_guard(*server_context.ioc()); std::atomic_bool context_thread_failed{false}; std::thread context_thread{[&]() { try { server_context.execute_loop(); } catch (...) { context_thread_failed = true; } }}; server_context.stop(); context_thread.join(); CHECK(!context_thread_failed); } SECTION("stop") { boost::asio::executor_work_guard work = boost::asio::make_work_guard(*server_context.ioc()); std::thread context_thread{[&]() { server_context.execute_loop(); }}; CHECK(!server_context.ioc()->stopped()); server_context.stop(); CHECK(server_context.ioc()->stopped()); context_thread.join(); server_context.stop(); CHECK(server_context.ioc()->stopped()); } SECTION("print") { CHECK_NOTHROW(test_util::null_stream() << server_context); } } TEST_CASE("ServerContextPool", "[silkworm][infra][grpc][server][server_context]") { grpc::ServerBuilder builder; SECTION("ServerContextPool OK") { ServerContextPool server_context_pool{{2}, builder}; CHECK(server_context_pool.size() == 2); } SECTION("ServerContextPool KO") { CHECK_THROWS_AS((ServerContextPool{concurrency::ContextPoolSettings{0}, builder}), std::logic_error); } SECTION("next_context") { ServerContextPool server_context_pool{{2}, builder}; auto& context1 = server_context_pool.next_context(); auto& context2 = server_context_pool.next_context(); CHECK(&server_context_pool.next_context() == &context1); CHECK(&server_context_pool.next_context() == &context2); } SECTION("next_ioc") { ServerContextPool server_context_pool{{2}, builder}; auto& context1 = server_context_pool.next_context(); CHECK(context1.ioc() != nullptr); auto& context2 = server_context_pool.next_context(); CHECK(context2.ioc() != nullptr); CHECK(&server_context_pool.next_ioc() == context1.ioc()); CHECK(&server_context_pool.next_ioc() == context2.ioc()); } SECTION("start/stop w/ contexts") { ServerContextPool server_context_pool{{2}, builder}; CHECK_NOTHROW(server_context_pool.start()); CHECK_NOTHROW(server_context_pool.stop()); } SECTION("join") { ServerContextPool server_context_pool{{2}, builder}; server_context_pool.start(); std::thread joining_thread{[&]() { server_context_pool.join(); }}; server_context_pool.stop(); CHECK_NOTHROW(joining_thread.join()); } SECTION("join after stop") { ServerContextPool server_context_pool{{2}, builder}; server_context_pool.start(); server_context_pool.stop(); CHECK_NOTHROW(server_context_pool.join()); } } TEST_CASE("ServerContextPool: handle loop exception", "[silkworm][infra][grpc][client][client_context]") { grpc::ServerBuilder builder; ServerContextPool cp{{3}, builder}; std::exception_ptr run_exception; cp.set_exception_handler([&](std::exception_ptr eptr) { run_exception = eptr; // In case of any loop exception in any thread, close down the pool cp.stop(); }); auto context_pool_thread = std::thread([&]() { cp.run(); }); boost::asio::post(cp.next_ioc(), [&]() { throw std::logic_error{"unexpected"}; }); CHECK_NOTHROW(context_pool_thread.join()); CHECK(bool(run_exception)); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server_settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc { inline constexpr std::string_view kDefaultAddressUri{"localhost:9090"}; //! Configuration settings for private (i.e. internal) API gRPC server struct ServerSettings { //! gRPC private API bind address (IP:port) std::string address_uri{kDefaultAddressUri}; //! gRPC private API credentials std::shared_ptr credentials{grpc::InsecureServerCredentials()}; //! Configuration for gRPC server execution pool concurrency::ContextPoolSettings context_pool_settings; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server_settings_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server_settings.hpp" #include #include #include namespace silkworm::rpc { // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("ServerConfig::ServerConfig", "[silkworm][rpc][server_settings]") { ServerSettings config; CHECK(config.address_uri == std::string{kDefaultAddressUri}); CHECK(config.context_pool_settings.num_contexts > 0); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/server/server_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server.hpp" #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { namespace { // Trick suggested by gRPC team to avoid name clashes in multiple test modules class MockService : public grpc::Service {}; class EmptyServer : public Server { public: explicit EmptyServer(const ServerSettings& settings) : Server(settings) {} protected: void register_async_services(grpc::ServerBuilder& builder) override { builder.RegisterService(&mock_async_service_); } void register_request_calls() override {} private: MockService mock_async_service_; }; } // namespace // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE // TODO(canepat): better copy grpc_pick_unused_port_or_die to generate unused port static constexpr std::string_view kTestAddressUri{"localhost:12345"}; TEST_CASE("Barebone gRPC Server", "[silkworm][node][rpc]") { grpc::ServerBuilder builder; // Add *at least one non-empty* ServerCompletionQueue (otherwise: ASAN SIGSEGV error in Shutdown) std::unique_ptr cq = builder.AddCompletionQueue(); auto alarm = std::make_unique(); alarm->Set(cq.get(), gpr_now(GPR_CLOCK_MONOTONIC), reinterpret_cast(0)); // Build and start the gRPC server std::unique_ptr server = builder.BuildAndStart(); // First, shutdown the gRPC server server->Shutdown(); // Then, shutdown and drain the ServerCompletionQueue cq->Shutdown(); void* tag{nullptr}; bool ok{false}; CHECK(cq->Next(&tag, &ok) == true); CHECK(tag == reinterpret_cast(0)); CHECK(cq->Next(&tag, &ok) == false); } TEST_CASE("Server::Server", "[silkworm][node][rpc]") { SECTION("OK: create an empty Server", "[silkworm][node][rpc]") { ServerSettings settings; settings.address_uri = kTestAddressUri; EmptyServer server{settings}; } } TEST_CASE("Server::build_and_start", "[silkworm][node][rpc]") { // TODO(canepat): use GMock class TestServer : public EmptyServer { public: explicit TestServer(const ServerSettings& settings) : EmptyServer(settings) {} bool register_async_services_called() const { return register_async_services_called_; } bool register_request_calls_called() const { return register_request_calls_called_; } protected: void register_async_services(grpc::ServerBuilder& /*builder*/) override { register_async_services_called_ = true; } void register_request_calls() override { register_request_calls_called_ = true; } private: bool register_async_services_called_{false}; bool register_request_calls_called_{false}; }; log::init(); SECTION("KO: Address already in use", "[silkworm][node][rpc]") { ServerSettings settings; settings.address_uri = kTestAddressUri; TestServer server1{settings}; server1.build_and_start(); TestServer server2{settings}; CHECK_THROWS_AS(server2.build_and_start(), std::runtime_error); server1.shutdown(); } SECTION("KO: Name or service not known", "[silkworm][node][rpc]") { ServerSettings settings; settings.address_uri = "local:12345"; // "localhost@12345" core dumped in gRPC 1.44.0-p0 (SIGSEGV) EmptyServer server{settings}; CHECK_THROWS_AS(server.build_and_start(), std::runtime_error); } SECTION("OK: accept requests called", "[silkworm][node][rpc]") { ServerSettings settings; settings.address_uri = kTestAddressUri; TestServer server{settings}; CHECK_NOTHROW(server.build_and_start()); CHECK(server.register_async_services_called()); CHECK(server.register_request_calls_called()); } } TEST_CASE("Server::shutdown", "[silkworm][node][rpc]") { ServerSettings settings; settings.address_uri = kTestAddressUri; EmptyServer server{settings}; SECTION("OK: build_and_start/shutdown", "[silkworm][node][rpc]") { server.build_and_start(); CHECK_NOTHROW(server.shutdown()); } SECTION("OK: build_and_start/shutdown/shutdown", "[silkworm][node][rpc]") { server.build_and_start(); CHECK_NOTHROW(server.shutdown()); CHECK_NOTHROW(server.shutdown()); } } TEST_CASE("Server::join", "[silkworm][node][rpc]") { ServerSettings settings; settings.address_uri = kTestAddressUri; EmptyServer server{settings}; SECTION("OK: build_and_start/join/shutdown", "[silkworm][node][rpc]") { server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; CHECK_NOTHROW(server.shutdown()); server_thread.join(); } SECTION("OK: build_and_start/join/shutdown/shutdown", "[silkworm][node][rpc]") { server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; CHECK_NOTHROW(server.shutdown()); CHECK_NOTHROW(server.shutdown()); server_thread.join(); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/infra/grpc/test_util/grpc_actions.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #include #pragma GCC diagnostic pop #include namespace silkworm::rpc::test { inline auto finish_with_status(agrpc::GrpcContext& grpc_context, const ::grpc::Status& status, bool ok) { return [&grpc_context, status, ok](auto&&, ::grpc::Status* status_ptr, void* tag) { *status_ptr = status; agrpc::process_grpc_tag(grpc_context, tag, ok); }; } inline auto finish_ok(agrpc::GrpcContext& grpc_context) { return finish_with_status(grpc_context, ::grpc::Status::OK, /*ok=*/true); } inline auto finish_cancelled(agrpc::GrpcContext& grpc_context) { return finish_with_status(grpc_context, ::grpc::Status::CANCELLED, /*ok=*/true); } template auto finish_with(agrpc::GrpcContext& grpc_context, Reply&& reply) { return [&grpc_context, reply = std::forward(reply)](auto* reply_ptr, ::grpc::Status* status, void* tag) mutable { *reply_ptr = std::move(reply); finish_with_status(grpc_context, ::grpc::Status::OK, /*ok=*/true)(reply_ptr, status, tag); }; } inline auto finish_error(agrpc::GrpcContext& grpc_context, const ::grpc::Status& status) { return finish_with_status(grpc_context, status, /*ok=*/false); } template auto finish_error(agrpc::GrpcContext& grpc_context, ::grpc::Status&& status, Reply&& reply) { return [&grpc_context, status = std::move(status), reply = std::forward(reply)](auto* reply_ptr, ::grpc::Status* status_ptr, void* tag) mutable { *reply_ptr = std::move(reply); finish_with_status(grpc_context, status, /*ok=*/false)(reply_ptr, status_ptr, tag); }; } template auto finish_error_aborted(agrpc::GrpcContext& grpc_context, Reply&& reply) { return finish_error(grpc_context, ::grpc::Status{::grpc::StatusCode::ABORTED, "internal failure"}, std::forward(reply)); } template auto finish_error_cancelled(agrpc::GrpcContext& grpc_context, Reply&& reply) { return finish_error(grpc_context, ::grpc::Status::CANCELLED, std::forward(reply)); } inline auto finish_streaming_with_status(agrpc::GrpcContext& grpc_context, const ::grpc::Status& status, bool ok) { return [&grpc_context, status, ok](::grpc::Status* status_ptr, void* tag) { *status_ptr = status; agrpc::process_grpc_tag(grpc_context, tag, ok); }; } inline auto finish_streaming_ok(agrpc::GrpcContext& grpc_context) { return finish_streaming_with_status(grpc_context, ::grpc::Status::OK, /*ok=*/true); } inline auto finish_streaming_cancelled(agrpc::GrpcContext& grpc_context) { return finish_streaming_with_status(grpc_context, ::grpc::Status::CANCELLED, /*ok=*/true); } inline auto finish_streaming_aborted(agrpc::GrpcContext& grpc_context) { return finish_streaming_with_status(grpc_context, ::grpc::Status{::grpc::StatusCode::ABORTED, ""}, /*ok=*/true); } inline auto finish_streaming_unavailable(agrpc::GrpcContext& grpc_context) { return finish_streaming_with_status(grpc_context, ::grpc::Status{::grpc::StatusCode::UNAVAILABLE, ""}, /*ok=*/true); } inline auto finish_streaming_error(agrpc::GrpcContext& grpc_context) { return finish_streaming_with_status(grpc_context, ::grpc::Status{::grpc::StatusCode::UNKNOWN, ""}, /*ok=*/false); } inline auto write(agrpc::GrpcContext& grpc_context, bool ok) { return [&grpc_context, ok](auto&&, void* tag) { agrpc::process_grpc_tag(grpc_context, tag, ok); }; } inline auto write_success(agrpc::GrpcContext& grpc_context) { return write(grpc_context, true); } inline auto write_failure(agrpc::GrpcContext& grpc_context) { return write(grpc_context, false); } inline auto writes_done(agrpc::GrpcContext& grpc_context, bool ok) { return [&grpc_context, ok](void* tag) { agrpc::process_grpc_tag(grpc_context, tag, ok); }; } inline auto writes_done_success(agrpc::GrpcContext& grpc_context) { return writes_done(grpc_context, true); } inline auto writes_done_failure(agrpc::GrpcContext& grpc_context) { return writes_done(grpc_context, false); } template auto read_success_with(agrpc::GrpcContext& grpc_context, Reply&& reply) { return [&grpc_context, reply = std::forward(reply)](auto* reply_ptr, void* tag) mutable { *reply_ptr = std::move(reply); agrpc::process_grpc_tag(grpc_context, tag, /*ok=*/true); }; } inline auto read_failure(agrpc::GrpcContext& grpc_context) { return [&grpc_context](auto*, void* tag) { agrpc::process_grpc_tag(grpc_context, tag, /*ok=*/false); }; } } // namespace silkworm::rpc::test ================================================ FILE: silkworm/infra/grpc/test_util/grpc_matcher.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc::test { inline auto exception_has_grpc_status_code(::grpc::StatusCode status_code) { return Catch::Matchers::Predicate( [status_code](auto& e) { return std::error_code(e.code()).value() == status_code; }); } inline auto exception_has_aborted_grpc_status_code() { return test::exception_has_grpc_status_code(::grpc::StatusCode::ABORTED); } inline auto exception_has_cancelled_grpc_status_code() { return test::exception_has_grpc_status_code(::grpc::StatusCode::CANCELLED); } inline auto exception_has_unknown_grpc_status_code() { return test::exception_has_grpc_status_code(::grpc::StatusCode::UNKNOWN); } } // namespace silkworm::rpc::test ================================================ FILE: silkworm/infra/grpc/test_util/grpc_responder.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc::test { template class MockAsyncResponseReader : public ::grpc::ClientAsyncResponseReaderInterface { public: MOCK_METHOD(void, StartCall, (), (override)); MOCK_METHOD(void, ReadInitialMetadata, (void*), (override)); MOCK_METHOD(void, Finish, (Reply*, ::grpc::Status*, void*), (override)); }; template using StrictMockAsyncResponseReader = testing::StrictMock>; template class MockAsyncReader : public ::grpc::ClientAsyncReaderInterface { public: MOCK_METHOD(void, StartCall, (void*), (override)); MOCK_METHOD(void, ReadInitialMetadata, (void*), (override)); MOCK_METHOD(void, Read, (Reply*, void*), (override)); MOCK_METHOD(void, Finish, (::grpc::Status*, void*), (override)); }; template using StrictMockAsyncReader = testing::StrictMock>; template class MockAsyncReaderWriter : public ::grpc::ClientAsyncReaderWriterInterface { public: MOCK_METHOD(void, StartCall, (void*), (override)); MOCK_METHOD(void, ReadInitialMetadata, (void*), (override)); MOCK_METHOD(void, Read, (Reply*, void*), (override)); MOCK_METHOD(void, Write, (const Request&, void*), (override)); MOCK_METHOD(void, WritesDone, (void*), (override)); MOCK_METHOD(void, Finish, (::grpc::Status*, void*), (override)); // gMock does not support mocking overloaded methods at runtime, but you can delegate from one another void Write(const Request& r, ::grpc::WriteOptions, void* tag) override { Write(r, tag); } }; template using StrictMockAsyncReaderWriter = testing::StrictMock>; } // namespace silkworm::rpc::test ================================================ FILE: silkworm/infra/grpc/test_util/interfaces/ethbackend_mock_fix24351.grpc.pb.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // Manually created to overcome grpcpp issue 24351 (https://github.com/grpc/grpc/issues/24351) #include namespace remote { class FixIssue24351_MockETHBACKENDStub : public MockETHBACKENDStub { public: MOCK_METHOD3(AsyncEtherbase, ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>*(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncEtherbase, ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>*(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncNetVersion, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>*(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncNetVersion, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>*(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncProtocolVersion, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>*(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncProtocolVersion, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>*(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncClientVersion, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>*(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncClientVersion, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>*(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(Subscribe, ::grpc::ClientReaderInterface< ::remote::SubscribeReply>*(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request)); MOCK_METHOD4(AsyncSubscribe, ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>*(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncSubscribe, ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>*(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq)); }; } // namespace remote ================================================ FILE: silkworm/infra/grpc/test_util/interfaces/kv_mock_fix24351.grpc.pb.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // Manually created to overcome grpcpp issue 24351 (https://github.com/grpc/grpc/issues/24351) #include namespace remote { class FixIssue24351_MockKVStub : public remote::MockKVStub { public: MOCK_METHOD3(AsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD1(Tx, ::grpc::ClientReaderWriterInterface< ::remote::Cursor, ::remote::Pair>*(::grpc::ClientContext* context)); MOCK_METHOD3(AsyncTx, ::grpc::ClientAsyncReaderWriterInterface<::remote::Cursor, ::remote::Pair>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD2(PrepareAsyncTx, ::grpc::ClientAsyncReaderWriterInterface<::remote::Cursor, ::remote::Pair>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(ReceiveStateChanges, ::grpc::ClientReaderInterface< ::remote::StateChange>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request)); MOCK_METHOD4(AsyncReceiveStateChanges, ::grpc::ClientAsyncReaderInterface< ::remote::StateChange>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncReceiveStateChanges, ::grpc::ClientAsyncReaderInterface< ::remote::StateChange>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncGetLatest, ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>*(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetLatest, ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>*(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncHistorySeek, ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>*(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHistorySeek, ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>*(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncIndexRange, ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>*(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncIndexRange, ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>*(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncHistoryRange, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHistoryRange, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncRangeAsOf, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncRangeAsOf, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq)); }; } // namespace remote ================================================ FILE: silkworm/infra/grpc/test_util/interfaces/mining_mock_fix24351.grpc.pb.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // Manually created to overcome grpcpp issue 24351 (https://github.com/grpc/grpc/issues/24351) #include namespace txpool { class FixIssue24351_MockMiningStub : public MockMiningStub { public: MOCK_METHOD3(AsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD4(AsyncOnPendingBlock, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncOnPendingBlock, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD4(AsyncOnMinedBlock, ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD2(OnPendingLogs, ::grpc::ClientReaderInterface< ::txpool::OnPendingLogsReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request)); MOCK_METHOD4(AsyncOnPendingLogs, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncOnPendingLogs, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncGetWork, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>*(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetWork, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>*(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncSubmitWork, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>*(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSubmitWork, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>*(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncSubmitHashRate, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>*(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSubmitHashRate, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>*(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncHashRate, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>*(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHashRate, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>*(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncMining, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>*(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncMining, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>*(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq)); }; } // namespace txpool ================================================ FILE: silkworm/infra/grpc/test_util/interfaces/txpool_mock_fix24351.grpc.pb.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // Manually created to overcome grpcpp issue 24351 (https://github.com/grpc/grpc/issues/24351) #include namespace txpool { class FixIssue24351_MockTxpoolStub : public MockTxpoolStub { public: MOCK_METHOD3(AsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersion, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncFindUnknown, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>*(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncFindUnknown, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>*(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncAdd, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>*(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncAdd, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>*(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AsyncTransactions, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>*(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncTransactions, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>*(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(OnAdd, ::grpc::ClientReaderInterface< ::txpool::OnAddReply>*(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request)); MOCK_METHOD4(AsyncOnAdd, ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>*(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncOnAdd, ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>*(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq)); }; } // namespace txpool ================================================ FILE: silkworm/infra/grpc/test_util/test_runner.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include "../../test_util/task_runner.hpp" namespace silkworm::grpc::test_util { using namespace silkworm::test_util; /** * A helper to run gRPC calls on boost::asio::io_context + agrpc::GrpcContext in tests */ template class TestRunner : public TaskRunner { public: TestRunner() : grpc_context_work_{boost::asio::make_work_guard(grpc_context_.get_executor())} {} template auto run_service_method(Args&&... args) { GrpcApiClient api = make_api_client(); auto service = api.service(); return run((service.get()->*method)(std::forward(args)...)); } protected: agrpc::GrpcContext grpc_context_; boost::asio::executor_work_guard grpc_context_work_; std::unique_ptr stub_{std::make_unique()}; void restart_ioc() override { TaskRunner::restart_ioc(); grpc_context_.reset(); } void poll_ioc_once() override { TaskRunner::poll_ioc_once(); grpc_context_.poll_completion_queue(); } virtual GrpcApiClient make_api_client() = 0; }; } // namespace silkworm::grpc::test_util ================================================ FILE: silkworm/infra/test_util/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(Boost REQUIRED COMPONENTS headers) silkworm_library( silkworm_infra_test_util PUBLIC silkworm_infra Boost::headers PRIVATE "" ) ================================================ FILE: silkworm/infra/test_util/context_test_base.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "context_test_base.hpp" namespace silkworm::test_util { ContextTestBase::ContextTestBase() : context_{0}, ioc_{*context_.ioc()}, grpc_context_{*context_.grpc_context()}, context_thread_{[&]() { context_.execute_loop(); }} {} ContextTestBase::~ContextTestBase() { context_.stop(); if (context_thread_.joinable()) { context_thread_.join(); } } } // namespace silkworm::test_util ================================================ FILE: silkworm/infra/test_util/context_test_base.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::test_util { class ContextTestBase { public: ContextTestBase(); template auto spawn(AwaitableOrFunction&& awaitable) { return concurrency::spawn_future(ioc_, std::forward(awaitable)); } template auto spawn_and_wait(AwaitableOrFunction&& awaitable) { return spawn(std::forward(awaitable)).get(); } static void sleep_for(std::chrono::milliseconds sleep_time_ms) { std::this_thread::sleep_for(sleep_time_ms); } ~ContextTestBase(); agrpc::GrpcContext& grpc_context() { return grpc_context_; } protected: rpc::ClientContext context_; boost::asio::io_context& ioc_; agrpc::GrpcContext& grpc_context_; std::thread context_thread_; }; } // namespace silkworm::test_util ================================================ FILE: silkworm/infra/test_util/fixture.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::test_util { //! Test fixtures are predefined data sets that you initialize before running your tests template using Fixture = std::pair; template using Fixtures = std::vector>; } // namespace silkworm::test_util ================================================ FILE: silkworm/infra/test_util/hex.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "hex.hpp" #include #include #include #include #include namespace silkworm::test_util { std::string ascii_from_hex(std::string_view hex) { const std::optional bytes{from_hex(hex)}; if (!bytes) { throw std::runtime_error{"ascii_from_hex"}; } return std::string{byte_view_to_string_view(*bytes)}; } } // namespace silkworm::test_util ================================================ FILE: silkworm/infra/test_util/hex.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::test_util { std::string ascii_from_hex(std::string_view hex); } // namespace silkworm::test_util ================================================ FILE: silkworm/infra/test_util/log.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::test_util { //! Utility class using RAII to change the log verbosity level (necessary to make tests work in shuffled order) class SetLogVerbosityGuard { public: explicit SetLogVerbosityGuard(log::Level new_level) : current_level_(log::get_verbosity()) { set_verbosity(new_level); } ~SetLogVerbosityGuard() { log::set_verbosity(current_level_); } private: log::Level current_level_; }; //! Utility class using RAII to swap the underlying buffers of the provided streams class StreamSwap { public: StreamSwap(std::ostream& o1, std::ostream& o2) : buffer_(o1.rdbuf()), stream_(o1) { o1.rdbuf(o2.rdbuf()); } ~StreamSwap() { stream_.rdbuf(buffer_); } private: std::streambuf* buffer_; std::ostream& stream_; }; } // namespace silkworm::test_util ================================================ FILE: silkworm/infra/test_util/task_runner.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::test_util { /** * A helper to run Task-s on io_context in tests */ class TaskRunner { public: TaskRunner() = default; virtual ~TaskRunner() = default; //! Run task to completion template TResult run(Task task) { auto future = spawn_future(std::move(task)); poll_context_until_future_is_ready(future); return future.get(); } //! co_spawn with use_future template std::future spawn_future(Task task) { return co_spawn(ioc_, std::move(task), boost::asio::use_future); } //! Poll until the spawned future completes template void poll_context_until_future_is_ready(std::future& future) { using namespace std::chrono_literals; restart_ioc(); while (future.wait_for(0s) != std::future_status::ready) { poll_ioc_once(); } } boost::asio::io_context& ioc() { return ioc_; } boost::asio::any_io_executor executor() { return ioc_.get_executor(); } protected: virtual void restart_ioc() { ioc_.restart(); } virtual void poll_ioc_once() { ioc_.poll_one(); } boost::asio::io_context ioc_; }; } // namespace silkworm::test_util ================================================ FILE: silkworm/infra/test_util/temporary_file.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::test_util { //! Temporary file flushing data after any insertion class TemporaryFile { public: TemporaryFile() : TemporaryFile{TemporaryDirectory::get_unique_temporary_path(), std::monostate{}} {} explicit TemporaryFile(const std::string& filename) : TemporaryFile{TemporaryDirectory::get_os_temporary_path() / filename, std::monostate{}} {} TemporaryFile(const std::filesystem::path& tmp_dir, const std::string& filename) : TemporaryFile{tmp_dir / filename, std::monostate{}} {} ~TemporaryFile() { stream_.close(); } const std::filesystem::path& path() const noexcept { return path_; } void write(ByteView bv) { stream_.write(reinterpret_cast(bv.data()), static_cast(bv.size())); stream_.flush(); } private: TemporaryFile(std::filesystem::path path, std::monostate /*sentinel*/) : path_{std::move(path)}, stream_{path_, std::ios::binary} { stream_.exceptions(std::ios::failbit | std::ios::badbit); } std::filesystem::path path_; std::ofstream stream_; }; } // namespace silkworm::test_util ================================================ FILE: silkworm/interfaces/.gitignore ================================================ /execution /p2psentry /remote /txpool /types ================================================ FILE: silkworm/interfaces/27.0/execution/execution.grpc.pb.cc ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: execution/execution.proto #include "execution/execution.pb.h" #include "execution/execution.grpc.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace execution { static const char* Execution_method_names[] = { "/execution.Execution/InsertBlocks", "/execution.Execution/ValidateChain", "/execution.Execution/UpdateForkChoice", "/execution.Execution/AssembleBlock", "/execution.Execution/GetAssembledBlock", "/execution.Execution/CurrentHeader", "/execution.Execution/GetTD", "/execution.Execution/GetHeader", "/execution.Execution/GetBody", "/execution.Execution/HasBlock", "/execution.Execution/GetBodiesByRange", "/execution.Execution/GetBodiesByHashes", "/execution.Execution/IsCanonicalHash", "/execution.Execution/GetHeaderHashNumber", "/execution.Execution/GetForkChoice", "/execution.Execution/Ready", "/execution.Execution/FrozenBlocks", }; std::unique_ptr< Execution::Stub> Execution::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< Execution::Stub> stub(new Execution::Stub(channel, options)); return stub; } Execution::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_InsertBlocks_(Execution_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_ValidateChain_(Execution_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_UpdateForkChoice_(Execution_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_AssembleBlock_(Execution_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetAssembledBlock_(Execution_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_CurrentHeader_(Execution_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetTD_(Execution_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetHeader_(Execution_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetBody_(Execution_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_HasBlock_(Execution_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetBodiesByRange_(Execution_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetBodiesByHashes_(Execution_method_names[11], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_IsCanonicalHash_(Execution_method_names[12], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetHeaderHashNumber_(Execution_method_names[13], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetForkChoice_(Execution_method_names[14], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Ready_(Execution_method_names[15], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_FrozenBlocks_(Execution_method_names[16], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status Execution::Stub::InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::execution::InsertionResult* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::InsertBlocksRequest, ::execution::InsertionResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_InsertBlocks_, context, request, response); } void Execution::Stub::async::InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::InsertBlocksRequest, ::execution::InsertionResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_InsertBlocks_, context, request, response, std::move(f)); } void Execution::Stub::async::InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_InsertBlocks_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>* Execution::Stub::PrepareAsyncInsertBlocksRaw(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::InsertionResult, ::execution::InsertBlocksRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_InsertBlocks_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>* Execution::Stub::AsyncInsertBlocksRaw(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncInsertBlocksRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::execution::ValidationReceipt* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::ValidationRequest, ::execution::ValidationReceipt, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ValidateChain_, context, request, response); } void Execution::Stub::async::ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::ValidationRequest, ::execution::ValidationReceipt, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ValidateChain_, context, request, response, std::move(f)); } void Execution::Stub::async::ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ValidateChain_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>* Execution::Stub::PrepareAsyncValidateChainRaw(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::ValidationReceipt, ::execution::ValidationRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ValidateChain_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>* Execution::Stub::AsyncValidateChainRaw(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncValidateChainRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::execution::ForkChoiceReceipt* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::ForkChoice, ::execution::ForkChoiceReceipt, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UpdateForkChoice_, context, request, response); } void Execution::Stub::async::UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::ForkChoice, ::execution::ForkChoiceReceipt, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdateForkChoice_, context, request, response, std::move(f)); } void Execution::Stub::async::UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdateForkChoice_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>* Execution::Stub::PrepareAsyncUpdateForkChoiceRaw(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::ForkChoiceReceipt, ::execution::ForkChoice, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UpdateForkChoice_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>* Execution::Stub::AsyncUpdateForkChoiceRaw(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncUpdateForkChoiceRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::execution::AssembleBlockResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AssembleBlock_, context, request, response); } void Execution::Stub::async::AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AssembleBlock_, context, request, response, std::move(f)); } void Execution::Stub::async::AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AssembleBlock_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>* Execution::Stub::PrepareAsyncAssembleBlockRaw(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::AssembleBlockResponse, ::execution::AssembleBlockRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AssembleBlock_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>* Execution::Stub::AsyncAssembleBlockRaw(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncAssembleBlockRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::execution::GetAssembledBlockResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetAssembledBlock_, context, request, response); } void Execution::Stub::async::GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetAssembledBlock_, context, request, response, std::move(f)); } void Execution::Stub::async::GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetAssembledBlock_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>* Execution::Stub::PrepareAsyncGetAssembledBlockRaw(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetAssembledBlockResponse, ::execution::GetAssembledBlockRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetAssembledBlock_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>* Execution::Stub::AsyncGetAssembledBlockRaw(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetAssembledBlockRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::GetHeaderResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::execution::GetHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CurrentHeader_, context, request, response); } void Execution::Stub::async::CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::execution::GetHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CurrentHeader_, context, request, response, std::move(f)); } void Execution::Stub::async::CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CurrentHeader_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* Execution::Stub::PrepareAsyncCurrentHeaderRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetHeaderResponse, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CurrentHeader_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* Execution::Stub::AsyncCurrentHeaderRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncCurrentHeaderRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetTDResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::GetSegmentRequest, ::execution::GetTDResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetTD_, context, request, response); } void Execution::Stub::async::GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::GetSegmentRequest, ::execution::GetTDResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTD_, context, request, response, std::move(f)); } void Execution::Stub::async::GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTD_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>* Execution::Stub::PrepareAsyncGetTDRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetTDResponse, ::execution::GetSegmentRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetTD_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>* Execution::Stub::AsyncGetTDRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetTDRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetHeaderResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::GetSegmentRequest, ::execution::GetHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetHeader_, context, request, response); } void Execution::Stub::async::GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::GetSegmentRequest, ::execution::GetHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetHeader_, context, request, response, std::move(f)); } void Execution::Stub::async::GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetHeader_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* Execution::Stub::PrepareAsyncGetHeaderRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetHeaderResponse, ::execution::GetSegmentRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetHeader_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* Execution::Stub::AsyncGetHeaderRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetHeaderRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetBodyResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::GetSegmentRequest, ::execution::GetBodyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetBody_, context, request, response); } void Execution::Stub::async::GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::GetSegmentRequest, ::execution::GetBodyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBody_, context, request, response, std::move(f)); } void Execution::Stub::async::GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBody_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>* Execution::Stub::PrepareAsyncGetBodyRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetBodyResponse, ::execution::GetSegmentRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetBody_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>* Execution::Stub::AsyncGetBodyRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetBodyRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::HasBlockResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::GetSegmentRequest, ::execution::HasBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HasBlock_, context, request, response); } void Execution::Stub::async::HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::GetSegmentRequest, ::execution::HasBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HasBlock_, context, request, response, std::move(f)); } void Execution::Stub::async::HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HasBlock_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>* Execution::Stub::PrepareAsyncHasBlockRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::HasBlockResponse, ::execution::GetSegmentRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HasBlock_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>* Execution::Stub::AsyncHasBlockRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncHasBlockRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::execution::GetBodiesBatchResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetBodiesByRange_, context, request, response); } void Execution::Stub::async::GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBodiesByRange_, context, request, response, std::move(f)); } void Execution::Stub::async::GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBodiesByRange_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* Execution::Stub::PrepareAsyncGetBodiesByRangeRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetBodiesBatchResponse, ::execution::GetBodiesByRangeRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetBodiesByRange_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* Execution::Stub::AsyncGetBodiesByRangeRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetBodiesByRangeRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::execution::GetBodiesBatchResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetBodiesByHashes_, context, request, response); } void Execution::Stub::async::GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBodiesByHashes_, context, request, response, std::move(f)); } void Execution::Stub::async::GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBodiesByHashes_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* Execution::Stub::PrepareAsyncGetBodiesByHashesRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetBodiesBatchResponse, ::execution::GetBodiesByHashesRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetBodiesByHashes_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* Execution::Stub::AsyncGetBodiesByHashesRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetBodiesByHashesRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256& request, ::execution::IsCanonicalResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::types::H256, ::execution::IsCanonicalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_IsCanonicalHash_, context, request, response); } void Execution::Stub::async::IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::types::H256, ::execution::IsCanonicalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_IsCanonicalHash_, context, request, response, std::move(f)); } void Execution::Stub::async::IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_IsCanonicalHash_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>* Execution::Stub::PrepareAsyncIsCanonicalHashRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::IsCanonicalResponse, ::types::H256, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_IsCanonicalHash_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>* Execution::Stub::AsyncIsCanonicalHashRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncIsCanonicalHashRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256& request, ::execution::GetHeaderHashNumberResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::types::H256, ::execution::GetHeaderHashNumberResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetHeaderHashNumber_, context, request, response); } void Execution::Stub::async::GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::types::H256, ::execution::GetHeaderHashNumberResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetHeaderHashNumber_, context, request, response, std::move(f)); } void Execution::Stub::async::GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetHeaderHashNumber_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>* Execution::Stub::PrepareAsyncGetHeaderHashNumberRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::GetHeaderHashNumberResponse, ::types::H256, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetHeaderHashNumber_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>* Execution::Stub::AsyncGetHeaderHashNumberRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetHeaderHashNumberRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ForkChoice* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::execution::ForkChoice, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetForkChoice_, context, request, response); } void Execution::Stub::async::GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::execution::ForkChoice, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetForkChoice_, context, request, response, std::move(f)); } void Execution::Stub::async::GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetForkChoice_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>* Execution::Stub::PrepareAsyncGetForkChoiceRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::ForkChoice, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetForkChoice_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>* Execution::Stub::AsyncGetForkChoiceRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetForkChoiceRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ReadyResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::execution::ReadyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Ready_, context, request, response); } void Execution::Stub::async::Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::execution::ReadyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Ready_, context, request, response, std::move(f)); } void Execution::Stub::async::Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Ready_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>* Execution::Stub::PrepareAsyncReadyRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::ReadyResponse, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Ready_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>* Execution::Stub::AsyncReadyRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncReadyRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Execution::Stub::FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::FrozenBlocksResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::execution::FrozenBlocksResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_FrozenBlocks_, context, request, response); } void Execution::Stub::async::FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::execution::FrozenBlocksResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FrozenBlocks_, context, request, response, std::move(f)); } void Execution::Stub::async::FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FrozenBlocks_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>* Execution::Stub::PrepareAsyncFrozenBlocksRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::execution::FrozenBlocksResponse, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_FrozenBlocks_, context, request); } ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>* Execution::Stub::AsyncFrozenBlocksRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncFrozenBlocksRaw(context, request, cq); result->StartCall(); return result; } Execution::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::InsertBlocksRequest, ::execution::InsertionResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::InsertBlocksRequest* req, ::execution::InsertionResult* resp) { return service->InsertBlocks(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::ValidationRequest, ::execution::ValidationReceipt, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::ValidationRequest* req, ::execution::ValidationReceipt* resp) { return service->ValidateChain(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::ForkChoice, ::execution::ForkChoiceReceipt, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::ForkChoice* req, ::execution::ForkChoiceReceipt* resp) { return service->UpdateForkChoice(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::AssembleBlockRequest* req, ::execution::AssembleBlockResponse* resp) { return service->AssembleBlock(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::GetAssembledBlockRequest* req, ::execution::GetAssembledBlockResponse* resp) { return service->GetAssembledBlock(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::google::protobuf::Empty, ::execution::GetHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::execution::GetHeaderResponse* resp) { return service->CurrentHeader(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::GetSegmentRequest, ::execution::GetTDResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::GetSegmentRequest* req, ::execution::GetTDResponse* resp) { return service->GetTD(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::GetSegmentRequest, ::execution::GetHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::GetSegmentRequest* req, ::execution::GetHeaderResponse* resp) { return service->GetHeader(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::GetSegmentRequest, ::execution::GetBodyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::GetSegmentRequest* req, ::execution::GetBodyResponse* resp) { return service->GetBody(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::GetSegmentRequest, ::execution::HasBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::GetSegmentRequest* req, ::execution::HasBlockResponse* resp) { return service->HasBlock(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[10], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::GetBodiesByRangeRequest* req, ::execution::GetBodiesBatchResponse* resp) { return service->GetBodiesByRange(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::execution::GetBodiesByHashesRequest* req, ::execution::GetBodiesBatchResponse* resp) { return service->GetBodiesByHashes(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[12], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::types::H256, ::execution::IsCanonicalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::types::H256* req, ::execution::IsCanonicalResponse* resp) { return service->IsCanonicalHash(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[13], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::types::H256, ::execution::GetHeaderHashNumberResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::types::H256* req, ::execution::GetHeaderHashNumberResponse* resp) { return service->GetHeaderHashNumber(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[14], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::google::protobuf::Empty, ::execution::ForkChoice, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::execution::ForkChoice* resp) { return service->GetForkChoice(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[15], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::google::protobuf::Empty, ::execution::ReadyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::execution::ReadyResponse* resp) { return service->Ready(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Execution_method_names[16], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Execution::Service, ::google::protobuf::Empty, ::execution::FrozenBlocksResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Execution::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::execution::FrozenBlocksResponse* resp) { return service->FrozenBlocks(ctx, req, resp); }, this))); } Execution::Service::~Service() { } ::grpc::Status Execution::Service::InsertBlocks(::grpc::ServerContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::ValidateChain(::grpc::ServerContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::UpdateForkChoice(::grpc::ServerContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::AssembleBlock(::grpc::ServerContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetAssembledBlock(::grpc::ServerContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::CurrentHeader(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetTD(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetHeader(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetBody(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::HasBlock(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetBodiesByRange(::grpc::ServerContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetBodiesByHashes(::grpc::ServerContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::IsCanonicalHash(::grpc::ServerContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetHeaderHashNumber(::grpc::ServerContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::GetForkChoice(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::Ready(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Execution::Service::FrozenBlocks(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } } // namespace execution ================================================ FILE: silkworm/interfaces/27.0/execution/execution.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: execution/execution.proto #ifndef GRPC_execution_2fexecution_2eproto__INCLUDED #define GRPC_execution_2fexecution_2eproto__INCLUDED #include "execution/execution.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace execution { class Execution final { public: static constexpr char const* service_full_name() { return "execution.Execution"; } class StubInterface { public: virtual ~StubInterface() {} // Chain Putters. virtual ::grpc::Status InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::execution::InsertionResult* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>> AsyncInsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>>(AsyncInsertBlocksRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>> PrepareAsyncInsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>>(PrepareAsyncInsertBlocksRaw(context, request, cq)); } // Chain Validation and ForkChoice. virtual ::grpc::Status ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::execution::ValidationReceipt* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>> AsyncValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>>(AsyncValidateChainRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>> PrepareAsyncValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>>(PrepareAsyncValidateChainRaw(context, request, cq)); } virtual ::grpc::Status UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::execution::ForkChoiceReceipt* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>> AsyncUpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>>(AsyncUpdateForkChoiceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>> PrepareAsyncUpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>>(PrepareAsyncUpdateForkChoiceRaw(context, request, cq)); } // Block Assembly // EAGAIN design here, AssembleBlock initiates the asynchronous request, and GetAssembleBlock just return it if ready. virtual ::grpc::Status AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::execution::AssembleBlockResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>> AsyncAssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>>(AsyncAssembleBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>> PrepareAsyncAssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>>(PrepareAsyncAssembleBlockRaw(context, request, cq)); } virtual ::grpc::Status GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::execution::GetAssembledBlockResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>> AsyncGetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>>(AsyncGetAssembledBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>> PrepareAsyncGetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>>(PrepareAsyncGetAssembledBlockRaw(context, request, cq)); } // Chain Getters. virtual ::grpc::Status CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::GetHeaderResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>> AsyncCurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>>(AsyncCurrentHeaderRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>> PrepareAsyncCurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>>(PrepareAsyncCurrentHeaderRaw(context, request, cq)); } virtual ::grpc::Status GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetTDResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>> AsyncGetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>>(AsyncGetTDRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>> PrepareAsyncGetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>>(PrepareAsyncGetTDRaw(context, request, cq)); } virtual ::grpc::Status GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetHeaderResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>> AsyncGetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>>(AsyncGetHeaderRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>> PrepareAsyncGetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>>(PrepareAsyncGetHeaderRaw(context, request, cq)); } virtual ::grpc::Status GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetBodyResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>> AsyncGetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>>(AsyncGetBodyRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>> PrepareAsyncGetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>>(PrepareAsyncGetBodyRaw(context, request, cq)); } virtual ::grpc::Status HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::HasBlockResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>> AsyncHasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>>(AsyncHasBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>> PrepareAsyncHasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>>(PrepareAsyncHasBlockRaw(context, request, cq)); } // Ranges virtual ::grpc::Status GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::execution::GetBodiesBatchResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>> AsyncGetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>>(AsyncGetBodiesByRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>> PrepareAsyncGetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>>(PrepareAsyncGetBodiesByRangeRaw(context, request, cq)); } virtual ::grpc::Status GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::execution::GetBodiesBatchResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>> AsyncGetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>>(AsyncGetBodiesByHashesRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>> PrepareAsyncGetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>>(PrepareAsyncGetBodiesByHashesRaw(context, request, cq)); } // Chain checkers virtual ::grpc::Status IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256& request, ::execution::IsCanonicalResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>> AsyncIsCanonicalHash(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>>(AsyncIsCanonicalHashRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>> PrepareAsyncIsCanonicalHash(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>>(PrepareAsyncIsCanonicalHashRaw(context, request, cq)); } virtual ::grpc::Status GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256& request, ::execution::GetHeaderHashNumberResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>> AsyncGetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>>(AsyncGetHeaderHashNumberRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>> PrepareAsyncGetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>>(PrepareAsyncGetHeaderHashNumberRaw(context, request, cq)); } virtual ::grpc::Status GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ForkChoice* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>> AsyncGetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>>(AsyncGetForkChoiceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>> PrepareAsyncGetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>>(PrepareAsyncGetForkChoiceRaw(context, request, cq)); } // Misc // We want to figure out whether we processed snapshots and cleanup sync cycles. virtual ::grpc::Status Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ReadyResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>> AsyncReady(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>>(AsyncReadyRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>> PrepareAsyncReady(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>>(PrepareAsyncReadyRaw(context, request, cq)); } // Frozen blocks are how many blocks are in snapshots .seg files. virtual ::grpc::Status FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::FrozenBlocksResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>> AsyncFrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>>(AsyncFrozenBlocksRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>> PrepareAsyncFrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>>(PrepareAsyncFrozenBlocksRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} // Chain Putters. virtual void InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response, std::function) = 0; virtual void InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Chain Validation and ForkChoice. virtual void ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response, std::function) = 0; virtual void ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response, std::function) = 0; virtual void UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Block Assembly // EAGAIN design here, AssembleBlock initiates the asynchronous request, and GetAssembleBlock just return it if ready. virtual void AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response, std::function) = 0; virtual void AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response, std::function) = 0; virtual void GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Chain Getters. virtual void CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response, std::function) = 0; virtual void CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response, std::function) = 0; virtual void GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response, std::function) = 0; virtual void GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response, std::function) = 0; virtual void GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response, std::function) = 0; virtual void HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Ranges virtual void GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response, std::function) = 0; virtual void GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response, std::function) = 0; virtual void GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Chain checkers virtual void IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response, std::function) = 0; virtual void IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response, std::function) = 0; virtual void GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response, std::function) = 0; virtual void GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Misc // We want to figure out whether we processed snapshots and cleanup sync cycles. virtual void Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response, std::function) = 0; virtual void Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Frozen blocks are how many blocks are in snapshots .seg files. virtual void FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response, std::function) = 0; virtual void FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>* AsyncInsertBlocksRaw(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>* PrepareAsyncInsertBlocksRaw(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>* AsyncValidateChainRaw(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>* PrepareAsyncValidateChainRaw(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>* AsyncUpdateForkChoiceRaw(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>* PrepareAsyncUpdateForkChoiceRaw(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>* AsyncAssembleBlockRaw(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>* PrepareAsyncAssembleBlockRaw(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>* AsyncGetAssembledBlockRaw(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>* PrepareAsyncGetAssembledBlockRaw(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>* AsyncCurrentHeaderRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>* PrepareAsyncCurrentHeaderRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>* AsyncGetTDRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>* PrepareAsyncGetTDRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>* AsyncGetHeaderRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>* PrepareAsyncGetHeaderRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>* AsyncGetBodyRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>* PrepareAsyncGetBodyRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>* AsyncHasBlockRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>* PrepareAsyncHasBlockRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>* AsyncGetBodiesByRangeRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>* PrepareAsyncGetBodiesByRangeRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>* AsyncGetBodiesByHashesRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>* PrepareAsyncGetBodiesByHashesRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>* AsyncIsCanonicalHashRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>* PrepareAsyncIsCanonicalHashRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>* AsyncGetHeaderHashNumberRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>* PrepareAsyncGetHeaderHashNumberRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>* AsyncGetForkChoiceRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>* PrepareAsyncGetForkChoiceRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>* AsyncReadyRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>* PrepareAsyncReadyRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>* AsyncFrozenBlocksRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>* PrepareAsyncFrozenBlocksRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::execution::InsertionResult* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>> AsyncInsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>>(AsyncInsertBlocksRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>> PrepareAsyncInsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>>(PrepareAsyncInsertBlocksRaw(context, request, cq)); } ::grpc::Status ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::execution::ValidationReceipt* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>> AsyncValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>>(AsyncValidateChainRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>> PrepareAsyncValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>>(PrepareAsyncValidateChainRaw(context, request, cq)); } ::grpc::Status UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::execution::ForkChoiceReceipt* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>> AsyncUpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>>(AsyncUpdateForkChoiceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>> PrepareAsyncUpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>>(PrepareAsyncUpdateForkChoiceRaw(context, request, cq)); } ::grpc::Status AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::execution::AssembleBlockResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>> AsyncAssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>>(AsyncAssembleBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>> PrepareAsyncAssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>>(PrepareAsyncAssembleBlockRaw(context, request, cq)); } ::grpc::Status GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::execution::GetAssembledBlockResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>> AsyncGetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>>(AsyncGetAssembledBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>> PrepareAsyncGetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>>(PrepareAsyncGetAssembledBlockRaw(context, request, cq)); } ::grpc::Status CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::GetHeaderResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>> AsyncCurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>>(AsyncCurrentHeaderRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>> PrepareAsyncCurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>>(PrepareAsyncCurrentHeaderRaw(context, request, cq)); } ::grpc::Status GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetTDResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>> AsyncGetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>>(AsyncGetTDRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>> PrepareAsyncGetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>>(PrepareAsyncGetTDRaw(context, request, cq)); } ::grpc::Status GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetHeaderResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>> AsyncGetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>>(AsyncGetHeaderRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>> PrepareAsyncGetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>>(PrepareAsyncGetHeaderRaw(context, request, cq)); } ::grpc::Status GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetBodyResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>> AsyncGetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>>(AsyncGetBodyRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>> PrepareAsyncGetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>>(PrepareAsyncGetBodyRaw(context, request, cq)); } ::grpc::Status HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::HasBlockResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>> AsyncHasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>>(AsyncHasBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>> PrepareAsyncHasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>>(PrepareAsyncHasBlockRaw(context, request, cq)); } ::grpc::Status GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::execution::GetBodiesBatchResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>> AsyncGetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>>(AsyncGetBodiesByRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>> PrepareAsyncGetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>>(PrepareAsyncGetBodiesByRangeRaw(context, request, cq)); } ::grpc::Status GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::execution::GetBodiesBatchResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>> AsyncGetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>>(AsyncGetBodiesByHashesRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>> PrepareAsyncGetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>>(PrepareAsyncGetBodiesByHashesRaw(context, request, cq)); } ::grpc::Status IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256& request, ::execution::IsCanonicalResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>> AsyncIsCanonicalHash(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>>(AsyncIsCanonicalHashRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>> PrepareAsyncIsCanonicalHash(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>>(PrepareAsyncIsCanonicalHashRaw(context, request, cq)); } ::grpc::Status GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256& request, ::execution::GetHeaderHashNumberResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>> AsyncGetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>>(AsyncGetHeaderHashNumberRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>> PrepareAsyncGetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>>(PrepareAsyncGetHeaderHashNumberRaw(context, request, cq)); } ::grpc::Status GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ForkChoice* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>> AsyncGetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>>(AsyncGetForkChoiceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>> PrepareAsyncGetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>>(PrepareAsyncGetForkChoiceRaw(context, request, cq)); } ::grpc::Status Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ReadyResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>> AsyncReady(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>>(AsyncReadyRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>> PrepareAsyncReady(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>>(PrepareAsyncReadyRaw(context, request, cq)); } ::grpc::Status FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::FrozenBlocksResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>> AsyncFrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>>(AsyncFrozenBlocksRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>> PrepareAsyncFrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>>(PrepareAsyncFrozenBlocksRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response, std::function) override; void InsertBlocks(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response, ::grpc::ClientUnaryReactor* reactor) override; void ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response, std::function) override; void ValidateChain(::grpc::ClientContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response, ::grpc::ClientUnaryReactor* reactor) override; void UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response, std::function) override; void UpdateForkChoice(::grpc::ClientContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response, ::grpc::ClientUnaryReactor* reactor) override; void AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response, std::function) override; void AssembleBlock(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response, std::function) override; void GetAssembledBlock(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response, std::function) override; void CurrentHeader(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response, std::function) override; void GetTD(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response, std::function) override; void GetHeader(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response, std::function) override; void GetBody(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response, std::function) override; void HasBlock(::grpc::ClientContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response, std::function) override; void GetBodiesByRange(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response, std::function) override; void GetBodiesByHashes(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response, std::function) override; void IsCanonicalHash(::grpc::ClientContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response, std::function) override; void GetHeaderHashNumber(::grpc::ClientContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response, std::function) override; void GetForkChoice(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response, ::grpc::ClientUnaryReactor* reactor) override; void Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response, std::function) override; void Ready(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response, std::function) override; void FrozenBlocks(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>* AsyncInsertBlocksRaw(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::InsertionResult>* PrepareAsyncInsertBlocksRaw(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>* AsyncValidateChainRaw(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ValidationReceipt>* PrepareAsyncValidateChainRaw(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>* AsyncUpdateForkChoiceRaw(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ForkChoiceReceipt>* PrepareAsyncUpdateForkChoiceRaw(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>* AsyncAssembleBlockRaw(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::AssembleBlockResponse>* PrepareAsyncAssembleBlockRaw(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>* AsyncGetAssembledBlockRaw(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetAssembledBlockResponse>* PrepareAsyncGetAssembledBlockRaw(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* AsyncCurrentHeaderRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* PrepareAsyncCurrentHeaderRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>* AsyncGetTDRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetTDResponse>* PrepareAsyncGetTDRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* AsyncGetHeaderRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderResponse>* PrepareAsyncGetHeaderRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>* AsyncGetBodyRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetBodyResponse>* PrepareAsyncGetBodyRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>* AsyncHasBlockRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::HasBlockResponse>* PrepareAsyncHasBlockRaw(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* AsyncGetBodiesByRangeRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* PrepareAsyncGetBodiesByRangeRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* AsyncGetBodiesByHashesRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetBodiesBatchResponse>* PrepareAsyncGetBodiesByHashesRaw(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>* AsyncIsCanonicalHashRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::IsCanonicalResponse>* PrepareAsyncIsCanonicalHashRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>* AsyncGetHeaderHashNumberRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::GetHeaderHashNumberResponse>* PrepareAsyncGetHeaderHashNumberRaw(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>* AsyncGetForkChoiceRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ForkChoice>* PrepareAsyncGetForkChoiceRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>* AsyncReadyRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::ReadyResponse>* PrepareAsyncReadyRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>* AsyncFrozenBlocksRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::execution::FrozenBlocksResponse>* PrepareAsyncFrozenBlocksRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_InsertBlocks_; const ::grpc::internal::RpcMethod rpcmethod_ValidateChain_; const ::grpc::internal::RpcMethod rpcmethod_UpdateForkChoice_; const ::grpc::internal::RpcMethod rpcmethod_AssembleBlock_; const ::grpc::internal::RpcMethod rpcmethod_GetAssembledBlock_; const ::grpc::internal::RpcMethod rpcmethod_CurrentHeader_; const ::grpc::internal::RpcMethod rpcmethod_GetTD_; const ::grpc::internal::RpcMethod rpcmethod_GetHeader_; const ::grpc::internal::RpcMethod rpcmethod_GetBody_; const ::grpc::internal::RpcMethod rpcmethod_HasBlock_; const ::grpc::internal::RpcMethod rpcmethod_GetBodiesByRange_; const ::grpc::internal::RpcMethod rpcmethod_GetBodiesByHashes_; const ::grpc::internal::RpcMethod rpcmethod_IsCanonicalHash_; const ::grpc::internal::RpcMethod rpcmethod_GetHeaderHashNumber_; const ::grpc::internal::RpcMethod rpcmethod_GetForkChoice_; const ::grpc::internal::RpcMethod rpcmethod_Ready_; const ::grpc::internal::RpcMethod rpcmethod_FrozenBlocks_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // Chain Putters. virtual ::grpc::Status InsertBlocks(::grpc::ServerContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response); // Chain Validation and ForkChoice. virtual ::grpc::Status ValidateChain(::grpc::ServerContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response); virtual ::grpc::Status UpdateForkChoice(::grpc::ServerContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response); // Block Assembly // EAGAIN design here, AssembleBlock initiates the asynchronous request, and GetAssembleBlock just return it if ready. virtual ::grpc::Status AssembleBlock(::grpc::ServerContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response); virtual ::grpc::Status GetAssembledBlock(::grpc::ServerContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response); // Chain Getters. virtual ::grpc::Status CurrentHeader(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response); virtual ::grpc::Status GetTD(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response); virtual ::grpc::Status GetHeader(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response); virtual ::grpc::Status GetBody(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response); virtual ::grpc::Status HasBlock(::grpc::ServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response); // Ranges virtual ::grpc::Status GetBodiesByRange(::grpc::ServerContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response); virtual ::grpc::Status GetBodiesByHashes(::grpc::ServerContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response); // Chain checkers virtual ::grpc::Status IsCanonicalHash(::grpc::ServerContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response); virtual ::grpc::Status GetHeaderHashNumber(::grpc::ServerContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response); virtual ::grpc::Status GetForkChoice(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response); // Misc // We want to figure out whether we processed snapshots and cleanup sync cycles. virtual ::grpc::Status Ready(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response); // Frozen blocks are how many blocks are in snapshots .seg files. virtual ::grpc::Status FrozenBlocks(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response); }; template class WithAsyncMethod_InsertBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_InsertBlocks() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_InsertBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status InsertBlocks(::grpc::ServerContext* /*context*/, const ::execution::InsertBlocksRequest* /*request*/, ::execution::InsertionResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestInsertBlocks(::grpc::ServerContext* context, ::execution::InsertBlocksRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::InsertionResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_ValidateChain : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_ValidateChain() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_ValidateChain() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ValidateChain(::grpc::ServerContext* /*context*/, const ::execution::ValidationRequest* /*request*/, ::execution::ValidationReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestValidateChain(::grpc::ServerContext* context, ::execution::ValidationRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::ValidationReceipt>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_UpdateForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_UpdateForkChoice() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_UpdateForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status UpdateForkChoice(::grpc::ServerContext* /*context*/, const ::execution::ForkChoice* /*request*/, ::execution::ForkChoiceReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestUpdateForkChoice(::grpc::ServerContext* context, ::execution::ForkChoice* request, ::grpc::ServerAsyncResponseWriter< ::execution::ForkChoiceReceipt>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_AssembleBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_AssembleBlock() { ::grpc::Service::MarkMethodAsync(3); } ~WithAsyncMethod_AssembleBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AssembleBlock(::grpc::ServerContext* /*context*/, const ::execution::AssembleBlockRequest* /*request*/, ::execution::AssembleBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAssembleBlock(::grpc::ServerContext* context, ::execution::AssembleBlockRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::AssembleBlockResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetAssembledBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetAssembledBlock() { ::grpc::Service::MarkMethodAsync(4); } ~WithAsyncMethod_GetAssembledBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetAssembledBlock(::grpc::ServerContext* /*context*/, const ::execution::GetAssembledBlockRequest* /*request*/, ::execution::GetAssembledBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetAssembledBlock(::grpc::ServerContext* context, ::execution::GetAssembledBlockRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetAssembledBlockResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_CurrentHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CurrentHeader() { ::grpc::Service::MarkMethodAsync(5); } ~WithAsyncMethod_CurrentHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CurrentHeader(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCurrentHeader(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetHeaderResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetTD : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetTD() { ::grpc::Service::MarkMethodAsync(6); } ~WithAsyncMethod_GetTD() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetTD(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetTDResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetTD(::grpc::ServerContext* context, ::execution::GetSegmentRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetTDResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetHeader() { ::grpc::Service::MarkMethodAsync(7); } ~WithAsyncMethod_GetHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeader(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetHeader(::grpc::ServerContext* context, ::execution::GetSegmentRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetHeaderResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetBody : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetBody() { ::grpc::Service::MarkMethodAsync(8); } ~WithAsyncMethod_GetBody() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBody(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetBodyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetBody(::grpc::ServerContext* context, ::execution::GetSegmentRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetBodyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_HasBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HasBlock() { ::grpc::Service::MarkMethodAsync(9); } ~WithAsyncMethod_HasBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HasBlock(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::HasBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHasBlock(::grpc::ServerContext* context, ::execution::GetSegmentRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::HasBlockResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetBodiesByRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetBodiesByRange() { ::grpc::Service::MarkMethodAsync(10); } ~WithAsyncMethod_GetBodiesByRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByRange(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByRangeRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetBodiesByRange(::grpc::ServerContext* context, ::execution::GetBodiesByRangeRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetBodiesBatchResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetBodiesByHashes : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetBodiesByHashes() { ::grpc::Service::MarkMethodAsync(11); } ~WithAsyncMethod_GetBodiesByHashes() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByHashes(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByHashesRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetBodiesByHashes(::grpc::ServerContext* context, ::execution::GetBodiesByHashesRequest* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetBodiesBatchResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_IsCanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_IsCanonicalHash() { ::grpc::Service::MarkMethodAsync(12); } ~WithAsyncMethod_IsCanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IsCanonicalHash(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::IsCanonicalResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestIsCanonicalHash(::grpc::ServerContext* context, ::types::H256* request, ::grpc::ServerAsyncResponseWriter< ::execution::IsCanonicalResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetHeaderHashNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetHeaderHashNumber() { ::grpc::Service::MarkMethodAsync(13); } ~WithAsyncMethod_GetHeaderHashNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeaderHashNumber(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::GetHeaderHashNumberResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetHeaderHashNumber(::grpc::ServerContext* context, ::types::H256* request, ::grpc::ServerAsyncResponseWriter< ::execution::GetHeaderHashNumberResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetForkChoice() { ::grpc::Service::MarkMethodAsync(14); } ~WithAsyncMethod_GetForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetForkChoice(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ForkChoice* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetForkChoice(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::execution::ForkChoice>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Ready : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Ready() { ::grpc::Service::MarkMethodAsync(15); } ~WithAsyncMethod_Ready() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Ready(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ReadyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestReady(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::execution::ReadyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(15, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_FrozenBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_FrozenBlocks() { ::grpc::Service::MarkMethodAsync(16); } ~WithAsyncMethod_FrozenBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FrozenBlocks(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::FrozenBlocksResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFrozenBlocks(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::execution::FrozenBlocksResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(16, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_InsertBlocks > > > > > > > > > > > > > > > > AsyncService; template class WithCallbackMethod_InsertBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_InsertBlocks() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::execution::InsertBlocksRequest, ::execution::InsertionResult>( [this]( ::grpc::CallbackServerContext* context, const ::execution::InsertBlocksRequest* request, ::execution::InsertionResult* response) { return this->InsertBlocks(context, request, response); }));} void SetMessageAllocatorFor_InsertBlocks( ::grpc::MessageAllocator< ::execution::InsertBlocksRequest, ::execution::InsertionResult>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::InsertBlocksRequest, ::execution::InsertionResult>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_InsertBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status InsertBlocks(::grpc::ServerContext* /*context*/, const ::execution::InsertBlocksRequest* /*request*/, ::execution::InsertionResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* InsertBlocks( ::grpc::CallbackServerContext* /*context*/, const ::execution::InsertBlocksRequest* /*request*/, ::execution::InsertionResult* /*response*/) { return nullptr; } }; template class WithCallbackMethod_ValidateChain : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_ValidateChain() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::execution::ValidationRequest, ::execution::ValidationReceipt>( [this]( ::grpc::CallbackServerContext* context, const ::execution::ValidationRequest* request, ::execution::ValidationReceipt* response) { return this->ValidateChain(context, request, response); }));} void SetMessageAllocatorFor_ValidateChain( ::grpc::MessageAllocator< ::execution::ValidationRequest, ::execution::ValidationReceipt>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::ValidationRequest, ::execution::ValidationReceipt>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_ValidateChain() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ValidateChain(::grpc::ServerContext* /*context*/, const ::execution::ValidationRequest* /*request*/, ::execution::ValidationReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* ValidateChain( ::grpc::CallbackServerContext* /*context*/, const ::execution::ValidationRequest* /*request*/, ::execution::ValidationReceipt* /*response*/) { return nullptr; } }; template class WithCallbackMethod_UpdateForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_UpdateForkChoice() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::execution::ForkChoice, ::execution::ForkChoiceReceipt>( [this]( ::grpc::CallbackServerContext* context, const ::execution::ForkChoice* request, ::execution::ForkChoiceReceipt* response) { return this->UpdateForkChoice(context, request, response); }));} void SetMessageAllocatorFor_UpdateForkChoice( ::grpc::MessageAllocator< ::execution::ForkChoice, ::execution::ForkChoiceReceipt>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::ForkChoice, ::execution::ForkChoiceReceipt>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_UpdateForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status UpdateForkChoice(::grpc::ServerContext* /*context*/, const ::execution::ForkChoice* /*request*/, ::execution::ForkChoiceReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* UpdateForkChoice( ::grpc::CallbackServerContext* /*context*/, const ::execution::ForkChoice* /*request*/, ::execution::ForkChoiceReceipt* /*response*/) { return nullptr; } }; template class WithCallbackMethod_AssembleBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_AssembleBlock() { ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::AssembleBlockRequest* request, ::execution::AssembleBlockResponse* response) { return this->AssembleBlock(context, request, response); }));} void SetMessageAllocatorFor_AssembleBlock( ::grpc::MessageAllocator< ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_AssembleBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AssembleBlock(::grpc::ServerContext* /*context*/, const ::execution::AssembleBlockRequest* /*request*/, ::execution::AssembleBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* AssembleBlock( ::grpc::CallbackServerContext* /*context*/, const ::execution::AssembleBlockRequest* /*request*/, ::execution::AssembleBlockResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetAssembledBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetAssembledBlock() { ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::GetAssembledBlockRequest* request, ::execution::GetAssembledBlockResponse* response) { return this->GetAssembledBlock(context, request, response); }));} void SetMessageAllocatorFor_GetAssembledBlock( ::grpc::MessageAllocator< ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetAssembledBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetAssembledBlock(::grpc::ServerContext* /*context*/, const ::execution::GetAssembledBlockRequest* /*request*/, ::execution::GetAssembledBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetAssembledBlock( ::grpc::CallbackServerContext* /*context*/, const ::execution::GetAssembledBlockRequest* /*request*/, ::execution::GetAssembledBlockResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_CurrentHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_CurrentHeader() { ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::GetHeaderResponse>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::execution::GetHeaderResponse* response) { return this->CurrentHeader(context, request, response); }));} void SetMessageAllocatorFor_CurrentHeader( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::execution::GetHeaderResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::GetHeaderResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_CurrentHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CurrentHeader(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CurrentHeader( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::GetHeaderResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetTD : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetTD() { ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetTDResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetTDResponse* response) { return this->GetTD(context, request, response); }));} void SetMessageAllocatorFor_GetTD( ::grpc::MessageAllocator< ::execution::GetSegmentRequest, ::execution::GetTDResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetTDResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetTD() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetTD(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetTDResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetTD( ::grpc::CallbackServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetTDResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetHeader() { ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetHeaderResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetHeaderResponse* response) { return this->GetHeader(context, request, response); }));} void SetMessageAllocatorFor_GetHeader( ::grpc::MessageAllocator< ::execution::GetSegmentRequest, ::execution::GetHeaderResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetHeaderResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeader(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetHeader( ::grpc::CallbackServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetHeaderResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetBody : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetBody() { ::grpc::Service::MarkMethodCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetBodyResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::GetBodyResponse* response) { return this->GetBody(context, request, response); }));} void SetMessageAllocatorFor_GetBody( ::grpc::MessageAllocator< ::execution::GetSegmentRequest, ::execution::GetBodyResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(8); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetBodyResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetBody() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBody(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetBodyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetBody( ::grpc::CallbackServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetBodyResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_HasBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_HasBlock() { ::grpc::Service::MarkMethodCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::HasBlockResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::GetSegmentRequest* request, ::execution::HasBlockResponse* response) { return this->HasBlock(context, request, response); }));} void SetMessageAllocatorFor_HasBlock( ::grpc::MessageAllocator< ::execution::GetSegmentRequest, ::execution::HasBlockResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(9); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::GetSegmentRequest, ::execution::HasBlockResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_HasBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HasBlock(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::HasBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HasBlock( ::grpc::CallbackServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::HasBlockResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetBodiesByRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetBodiesByRange() { ::grpc::Service::MarkMethodCallback(10, new ::grpc::internal::CallbackUnaryHandler< ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::GetBodiesByRangeRequest* request, ::execution::GetBodiesBatchResponse* response) { return this->GetBodiesByRange(context, request, response); }));} void SetMessageAllocatorFor_GetBodiesByRange( ::grpc::MessageAllocator< ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(10); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetBodiesByRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByRange(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByRangeRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetBodiesByRange( ::grpc::CallbackServerContext* /*context*/, const ::execution::GetBodiesByRangeRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetBodiesByHashes : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetBodiesByHashes() { ::grpc::Service::MarkMethodCallback(11, new ::grpc::internal::CallbackUnaryHandler< ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse>( [this]( ::grpc::CallbackServerContext* context, const ::execution::GetBodiesByHashesRequest* request, ::execution::GetBodiesBatchResponse* response) { return this->GetBodiesByHashes(context, request, response); }));} void SetMessageAllocatorFor_GetBodiesByHashes( ::grpc::MessageAllocator< ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(11); static_cast<::grpc::internal::CallbackUnaryHandler< ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetBodiesByHashes() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByHashes(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByHashesRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetBodiesByHashes( ::grpc::CallbackServerContext* /*context*/, const ::execution::GetBodiesByHashesRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_IsCanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_IsCanonicalHash() { ::grpc::Service::MarkMethodCallback(12, new ::grpc::internal::CallbackUnaryHandler< ::types::H256, ::execution::IsCanonicalResponse>( [this]( ::grpc::CallbackServerContext* context, const ::types::H256* request, ::execution::IsCanonicalResponse* response) { return this->IsCanonicalHash(context, request, response); }));} void SetMessageAllocatorFor_IsCanonicalHash( ::grpc::MessageAllocator< ::types::H256, ::execution::IsCanonicalResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(12); static_cast<::grpc::internal::CallbackUnaryHandler< ::types::H256, ::execution::IsCanonicalResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_IsCanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IsCanonicalHash(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::IsCanonicalResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* IsCanonicalHash( ::grpc::CallbackServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::IsCanonicalResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetHeaderHashNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetHeaderHashNumber() { ::grpc::Service::MarkMethodCallback(13, new ::grpc::internal::CallbackUnaryHandler< ::types::H256, ::execution::GetHeaderHashNumberResponse>( [this]( ::grpc::CallbackServerContext* context, const ::types::H256* request, ::execution::GetHeaderHashNumberResponse* response) { return this->GetHeaderHashNumber(context, request, response); }));} void SetMessageAllocatorFor_GetHeaderHashNumber( ::grpc::MessageAllocator< ::types::H256, ::execution::GetHeaderHashNumberResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(13); static_cast<::grpc::internal::CallbackUnaryHandler< ::types::H256, ::execution::GetHeaderHashNumberResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetHeaderHashNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeaderHashNumber(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::GetHeaderHashNumberResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetHeaderHashNumber( ::grpc::CallbackServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::GetHeaderHashNumberResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetForkChoice() { ::grpc::Service::MarkMethodCallback(14, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::ForkChoice>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::execution::ForkChoice* response) { return this->GetForkChoice(context, request, response); }));} void SetMessageAllocatorFor_GetForkChoice( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::execution::ForkChoice>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(14); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::ForkChoice>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetForkChoice(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ForkChoice* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetForkChoice( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ForkChoice* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Ready : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Ready() { ::grpc::Service::MarkMethodCallback(15, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::ReadyResponse>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::execution::ReadyResponse* response) { return this->Ready(context, request, response); }));} void SetMessageAllocatorFor_Ready( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::execution::ReadyResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(15); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::ReadyResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Ready() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Ready(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ReadyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Ready( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ReadyResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_FrozenBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_FrozenBlocks() { ::grpc::Service::MarkMethodCallback(16, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::FrozenBlocksResponse>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::execution::FrozenBlocksResponse* response) { return this->FrozenBlocks(context, request, response); }));} void SetMessageAllocatorFor_FrozenBlocks( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::execution::FrozenBlocksResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(16); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::execution::FrozenBlocksResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_FrozenBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FrozenBlocks(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::FrozenBlocksResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* FrozenBlocks( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::FrozenBlocksResponse* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_InsertBlocks > > > > > > > > > > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_InsertBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_InsertBlocks() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_InsertBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status InsertBlocks(::grpc::ServerContext* /*context*/, const ::execution::InsertBlocksRequest* /*request*/, ::execution::InsertionResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_ValidateChain : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_ValidateChain() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_ValidateChain() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ValidateChain(::grpc::ServerContext* /*context*/, const ::execution::ValidationRequest* /*request*/, ::execution::ValidationReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_UpdateForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_UpdateForkChoice() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_UpdateForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status UpdateForkChoice(::grpc::ServerContext* /*context*/, const ::execution::ForkChoice* /*request*/, ::execution::ForkChoiceReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_AssembleBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_AssembleBlock() { ::grpc::Service::MarkMethodGeneric(3); } ~WithGenericMethod_AssembleBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AssembleBlock(::grpc::ServerContext* /*context*/, const ::execution::AssembleBlockRequest* /*request*/, ::execution::AssembleBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetAssembledBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetAssembledBlock() { ::grpc::Service::MarkMethodGeneric(4); } ~WithGenericMethod_GetAssembledBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetAssembledBlock(::grpc::ServerContext* /*context*/, const ::execution::GetAssembledBlockRequest* /*request*/, ::execution::GetAssembledBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_CurrentHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CurrentHeader() { ::grpc::Service::MarkMethodGeneric(5); } ~WithGenericMethod_CurrentHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CurrentHeader(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetTD : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetTD() { ::grpc::Service::MarkMethodGeneric(6); } ~WithGenericMethod_GetTD() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetTD(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetTDResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetHeader() { ::grpc::Service::MarkMethodGeneric(7); } ~WithGenericMethod_GetHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeader(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetBody : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetBody() { ::grpc::Service::MarkMethodGeneric(8); } ~WithGenericMethod_GetBody() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBody(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetBodyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_HasBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HasBlock() { ::grpc::Service::MarkMethodGeneric(9); } ~WithGenericMethod_HasBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HasBlock(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::HasBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetBodiesByRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetBodiesByRange() { ::grpc::Service::MarkMethodGeneric(10); } ~WithGenericMethod_GetBodiesByRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByRange(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByRangeRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetBodiesByHashes : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetBodiesByHashes() { ::grpc::Service::MarkMethodGeneric(11); } ~WithGenericMethod_GetBodiesByHashes() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByHashes(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByHashesRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_IsCanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_IsCanonicalHash() { ::grpc::Service::MarkMethodGeneric(12); } ~WithGenericMethod_IsCanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IsCanonicalHash(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::IsCanonicalResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetHeaderHashNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetHeaderHashNumber() { ::grpc::Service::MarkMethodGeneric(13); } ~WithGenericMethod_GetHeaderHashNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeaderHashNumber(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::GetHeaderHashNumberResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetForkChoice() { ::grpc::Service::MarkMethodGeneric(14); } ~WithGenericMethod_GetForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetForkChoice(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ForkChoice* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Ready : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Ready() { ::grpc::Service::MarkMethodGeneric(15); } ~WithGenericMethod_Ready() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Ready(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ReadyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_FrozenBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_FrozenBlocks() { ::grpc::Service::MarkMethodGeneric(16); } ~WithGenericMethod_FrozenBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FrozenBlocks(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::FrozenBlocksResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_InsertBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_InsertBlocks() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_InsertBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status InsertBlocks(::grpc::ServerContext* /*context*/, const ::execution::InsertBlocksRequest* /*request*/, ::execution::InsertionResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestInsertBlocks(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_ValidateChain : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_ValidateChain() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_ValidateChain() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ValidateChain(::grpc::ServerContext* /*context*/, const ::execution::ValidationRequest* /*request*/, ::execution::ValidationReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestValidateChain(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_UpdateForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_UpdateForkChoice() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_UpdateForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status UpdateForkChoice(::grpc::ServerContext* /*context*/, const ::execution::ForkChoice* /*request*/, ::execution::ForkChoiceReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestUpdateForkChoice(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_AssembleBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_AssembleBlock() { ::grpc::Service::MarkMethodRaw(3); } ~WithRawMethod_AssembleBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AssembleBlock(::grpc::ServerContext* /*context*/, const ::execution::AssembleBlockRequest* /*request*/, ::execution::AssembleBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAssembleBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetAssembledBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetAssembledBlock() { ::grpc::Service::MarkMethodRaw(4); } ~WithRawMethod_GetAssembledBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetAssembledBlock(::grpc::ServerContext* /*context*/, const ::execution::GetAssembledBlockRequest* /*request*/, ::execution::GetAssembledBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetAssembledBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_CurrentHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CurrentHeader() { ::grpc::Service::MarkMethodRaw(5); } ~WithRawMethod_CurrentHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CurrentHeader(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCurrentHeader(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetTD : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetTD() { ::grpc::Service::MarkMethodRaw(6); } ~WithRawMethod_GetTD() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetTD(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetTDResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetTD(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetHeader() { ::grpc::Service::MarkMethodRaw(7); } ~WithRawMethod_GetHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeader(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetHeader(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetBody : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetBody() { ::grpc::Service::MarkMethodRaw(8); } ~WithRawMethod_GetBody() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBody(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetBodyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetBody(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_HasBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HasBlock() { ::grpc::Service::MarkMethodRaw(9); } ~WithRawMethod_HasBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HasBlock(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::HasBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHasBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetBodiesByRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetBodiesByRange() { ::grpc::Service::MarkMethodRaw(10); } ~WithRawMethod_GetBodiesByRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByRange(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByRangeRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetBodiesByRange(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetBodiesByHashes : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetBodiesByHashes() { ::grpc::Service::MarkMethodRaw(11); } ~WithRawMethod_GetBodiesByHashes() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByHashes(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByHashesRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetBodiesByHashes(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_IsCanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_IsCanonicalHash() { ::grpc::Service::MarkMethodRaw(12); } ~WithRawMethod_IsCanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IsCanonicalHash(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::IsCanonicalResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestIsCanonicalHash(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetHeaderHashNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetHeaderHashNumber() { ::grpc::Service::MarkMethodRaw(13); } ~WithRawMethod_GetHeaderHashNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeaderHashNumber(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::GetHeaderHashNumberResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetHeaderHashNumber(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetForkChoice() { ::grpc::Service::MarkMethodRaw(14); } ~WithRawMethod_GetForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetForkChoice(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ForkChoice* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetForkChoice(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Ready : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Ready() { ::grpc::Service::MarkMethodRaw(15); } ~WithRawMethod_Ready() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Ready(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ReadyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestReady(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(15, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_FrozenBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_FrozenBlocks() { ::grpc::Service::MarkMethodRaw(16); } ~WithRawMethod_FrozenBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FrozenBlocks(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::FrozenBlocksResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFrozenBlocks(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(16, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_InsertBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_InsertBlocks() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->InsertBlocks(context, request, response); })); } ~WithRawCallbackMethod_InsertBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status InsertBlocks(::grpc::ServerContext* /*context*/, const ::execution::InsertBlocksRequest* /*request*/, ::execution::InsertionResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* InsertBlocks( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_ValidateChain : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_ValidateChain() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ValidateChain(context, request, response); })); } ~WithRawCallbackMethod_ValidateChain() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ValidateChain(::grpc::ServerContext* /*context*/, const ::execution::ValidationRequest* /*request*/, ::execution::ValidationReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* ValidateChain( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_UpdateForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_UpdateForkChoice() { ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->UpdateForkChoice(context, request, response); })); } ~WithRawCallbackMethod_UpdateForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status UpdateForkChoice(::grpc::ServerContext* /*context*/, const ::execution::ForkChoice* /*request*/, ::execution::ForkChoiceReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* UpdateForkChoice( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_AssembleBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_AssembleBlock() { ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AssembleBlock(context, request, response); })); } ~WithRawCallbackMethod_AssembleBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AssembleBlock(::grpc::ServerContext* /*context*/, const ::execution::AssembleBlockRequest* /*request*/, ::execution::AssembleBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* AssembleBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetAssembledBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetAssembledBlock() { ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetAssembledBlock(context, request, response); })); } ~WithRawCallbackMethod_GetAssembledBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetAssembledBlock(::grpc::ServerContext* /*context*/, const ::execution::GetAssembledBlockRequest* /*request*/, ::execution::GetAssembledBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetAssembledBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_CurrentHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_CurrentHeader() { ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->CurrentHeader(context, request, response); })); } ~WithRawCallbackMethod_CurrentHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CurrentHeader(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CurrentHeader( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetTD : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetTD() { ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetTD(context, request, response); })); } ~WithRawCallbackMethod_GetTD() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetTD(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetTDResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetTD( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetHeader() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetHeader(context, request, response); })); } ~WithRawCallbackMethod_GetHeader() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeader(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetHeader( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetBody : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetBody() { ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetBody(context, request, response); })); } ~WithRawCallbackMethod_GetBody() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBody(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetBodyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetBody( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_HasBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_HasBlock() { ::grpc::Service::MarkMethodRawCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->HasBlock(context, request, response); })); } ~WithRawCallbackMethod_HasBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HasBlock(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::HasBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HasBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetBodiesByRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetBodiesByRange() { ::grpc::Service::MarkMethodRawCallback(10, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetBodiesByRange(context, request, response); })); } ~WithRawCallbackMethod_GetBodiesByRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByRange(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByRangeRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetBodiesByRange( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetBodiesByHashes : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetBodiesByHashes() { ::grpc::Service::MarkMethodRawCallback(11, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetBodiesByHashes(context, request, response); })); } ~WithRawCallbackMethod_GetBodiesByHashes() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetBodiesByHashes(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByHashesRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetBodiesByHashes( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_IsCanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_IsCanonicalHash() { ::grpc::Service::MarkMethodRawCallback(12, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->IsCanonicalHash(context, request, response); })); } ~WithRawCallbackMethod_IsCanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IsCanonicalHash(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::IsCanonicalResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* IsCanonicalHash( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetHeaderHashNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetHeaderHashNumber() { ::grpc::Service::MarkMethodRawCallback(13, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetHeaderHashNumber(context, request, response); })); } ~WithRawCallbackMethod_GetHeaderHashNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetHeaderHashNumber(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::GetHeaderHashNumberResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetHeaderHashNumber( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetForkChoice() { ::grpc::Service::MarkMethodRawCallback(14, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetForkChoice(context, request, response); })); } ~WithRawCallbackMethod_GetForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetForkChoice(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ForkChoice* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetForkChoice( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Ready : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Ready() { ::grpc::Service::MarkMethodRawCallback(15, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Ready(context, request, response); })); } ~WithRawCallbackMethod_Ready() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Ready(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ReadyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Ready( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_FrozenBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_FrozenBlocks() { ::grpc::Service::MarkMethodRawCallback(16, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->FrozenBlocks(context, request, response); })); } ~WithRawCallbackMethod_FrozenBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FrozenBlocks(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::FrozenBlocksResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* FrozenBlocks( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_InsertBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_InsertBlocks() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::execution::InsertBlocksRequest, ::execution::InsertionResult>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::InsertBlocksRequest, ::execution::InsertionResult>* streamer) { return this->StreamedInsertBlocks(context, streamer); })); } ~WithStreamedUnaryMethod_InsertBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status InsertBlocks(::grpc::ServerContext* /*context*/, const ::execution::InsertBlocksRequest* /*request*/, ::execution::InsertionResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedInsertBlocks(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::InsertBlocksRequest,::execution::InsertionResult>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_ValidateChain : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_ValidateChain() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler< ::execution::ValidationRequest, ::execution::ValidationReceipt>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::ValidationRequest, ::execution::ValidationReceipt>* streamer) { return this->StreamedValidateChain(context, streamer); })); } ~WithStreamedUnaryMethod_ValidateChain() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status ValidateChain(::grpc::ServerContext* /*context*/, const ::execution::ValidationRequest* /*request*/, ::execution::ValidationReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedValidateChain(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::ValidationRequest,::execution::ValidationReceipt>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_UpdateForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_UpdateForkChoice() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::StreamedUnaryHandler< ::execution::ForkChoice, ::execution::ForkChoiceReceipt>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::ForkChoice, ::execution::ForkChoiceReceipt>* streamer) { return this->StreamedUpdateForkChoice(context, streamer); })); } ~WithStreamedUnaryMethod_UpdateForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status UpdateForkChoice(::grpc::ServerContext* /*context*/, const ::execution::ForkChoice* /*request*/, ::execution::ForkChoiceReceipt* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedUpdateForkChoice(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::ForkChoice,::execution::ForkChoiceReceipt>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_AssembleBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_AssembleBlock() { ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler< ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::AssembleBlockRequest, ::execution::AssembleBlockResponse>* streamer) { return this->StreamedAssembleBlock(context, streamer); })); } ~WithStreamedUnaryMethod_AssembleBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status AssembleBlock(::grpc::ServerContext* /*context*/, const ::execution::AssembleBlockRequest* /*request*/, ::execution::AssembleBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedAssembleBlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::AssembleBlockRequest,::execution::AssembleBlockResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetAssembledBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetAssembledBlock() { ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler< ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetAssembledBlockRequest, ::execution::GetAssembledBlockResponse>* streamer) { return this->StreamedGetAssembledBlock(context, streamer); })); } ~WithStreamedUnaryMethod_GetAssembledBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetAssembledBlock(::grpc::ServerContext* /*context*/, const ::execution::GetAssembledBlockRequest* /*request*/, ::execution::GetAssembledBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetAssembledBlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetAssembledBlockRequest,::execution::GetAssembledBlockResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_CurrentHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CurrentHeader() { ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::execution::GetHeaderResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::execution::GetHeaderResponse>* streamer) { return this->StreamedCurrentHeader(context, streamer); })); } ~WithStreamedUnaryMethod_CurrentHeader() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status CurrentHeader(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedCurrentHeader(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::execution::GetHeaderResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetTD : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetTD() { ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::StreamedUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetTDResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest, ::execution::GetTDResponse>* streamer) { return this->StreamedGetTD(context, streamer); })); } ~WithStreamedUnaryMethod_GetTD() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetTD(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetTDResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetTD(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest,::execution::GetTDResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetHeader : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetHeader() { ::grpc::Service::MarkMethodStreamed(7, new ::grpc::internal::StreamedUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetHeaderResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest, ::execution::GetHeaderResponse>* streamer) { return this->StreamedGetHeader(context, streamer); })); } ~WithStreamedUnaryMethod_GetHeader() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetHeader(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetHeaderResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetHeader(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest,::execution::GetHeaderResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetBody : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetBody() { ::grpc::Service::MarkMethodStreamed(8, new ::grpc::internal::StreamedUnaryHandler< ::execution::GetSegmentRequest, ::execution::GetBodyResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest, ::execution::GetBodyResponse>* streamer) { return this->StreamedGetBody(context, streamer); })); } ~WithStreamedUnaryMethod_GetBody() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetBody(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::GetBodyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetBody(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest,::execution::GetBodyResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HasBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HasBlock() { ::grpc::Service::MarkMethodStreamed(9, new ::grpc::internal::StreamedUnaryHandler< ::execution::GetSegmentRequest, ::execution::HasBlockResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest, ::execution::HasBlockResponse>* streamer) { return this->StreamedHasBlock(context, streamer); })); } ~WithStreamedUnaryMethod_HasBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status HasBlock(::grpc::ServerContext* /*context*/, const ::execution::GetSegmentRequest* /*request*/, ::execution::HasBlockResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedHasBlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetSegmentRequest,::execution::HasBlockResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetBodiesByRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetBodiesByRange() { ::grpc::Service::MarkMethodStreamed(10, new ::grpc::internal::StreamedUnaryHandler< ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetBodiesByRangeRequest, ::execution::GetBodiesBatchResponse>* streamer) { return this->StreamedGetBodiesByRange(context, streamer); })); } ~WithStreamedUnaryMethod_GetBodiesByRange() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetBodiesByRange(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByRangeRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetBodiesByRange(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetBodiesByRangeRequest,::execution::GetBodiesBatchResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetBodiesByHashes : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetBodiesByHashes() { ::grpc::Service::MarkMethodStreamed(11, new ::grpc::internal::StreamedUnaryHandler< ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetBodiesByHashesRequest, ::execution::GetBodiesBatchResponse>* streamer) { return this->StreamedGetBodiesByHashes(context, streamer); })); } ~WithStreamedUnaryMethod_GetBodiesByHashes() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetBodiesByHashes(::grpc::ServerContext* /*context*/, const ::execution::GetBodiesByHashesRequest* /*request*/, ::execution::GetBodiesBatchResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetBodiesByHashes(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::execution::GetBodiesByHashesRequest,::execution::GetBodiesBatchResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_IsCanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_IsCanonicalHash() { ::grpc::Service::MarkMethodStreamed(12, new ::grpc::internal::StreamedUnaryHandler< ::types::H256, ::execution::IsCanonicalResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::types::H256, ::execution::IsCanonicalResponse>* streamer) { return this->StreamedIsCanonicalHash(context, streamer); })); } ~WithStreamedUnaryMethod_IsCanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status IsCanonicalHash(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::IsCanonicalResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedIsCanonicalHash(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::types::H256,::execution::IsCanonicalResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetHeaderHashNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetHeaderHashNumber() { ::grpc::Service::MarkMethodStreamed(13, new ::grpc::internal::StreamedUnaryHandler< ::types::H256, ::execution::GetHeaderHashNumberResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::types::H256, ::execution::GetHeaderHashNumberResponse>* streamer) { return this->StreamedGetHeaderHashNumber(context, streamer); })); } ~WithStreamedUnaryMethod_GetHeaderHashNumber() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetHeaderHashNumber(::grpc::ServerContext* /*context*/, const ::types::H256* /*request*/, ::execution::GetHeaderHashNumberResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetHeaderHashNumber(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::types::H256,::execution::GetHeaderHashNumberResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetForkChoice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetForkChoice() { ::grpc::Service::MarkMethodStreamed(14, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::execution::ForkChoice>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::execution::ForkChoice>* streamer) { return this->StreamedGetForkChoice(context, streamer); })); } ~WithStreamedUnaryMethod_GetForkChoice() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetForkChoice(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ForkChoice* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetForkChoice(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::execution::ForkChoice>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Ready : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Ready() { ::grpc::Service::MarkMethodStreamed(15, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::execution::ReadyResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::execution::ReadyResponse>* streamer) { return this->StreamedReady(context, streamer); })); } ~WithStreamedUnaryMethod_Ready() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Ready(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::ReadyResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedReady(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::execution::ReadyResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_FrozenBlocks : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_FrozenBlocks() { ::grpc::Service::MarkMethodStreamed(16, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::execution::FrozenBlocksResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::execution::FrozenBlocksResponse>* streamer) { return this->StreamedFrozenBlocks(context, streamer); })); } ~WithStreamedUnaryMethod_FrozenBlocks() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status FrozenBlocks(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::execution::FrozenBlocksResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedFrozenBlocks(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::execution::FrozenBlocksResponse>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_InsertBlocks > > > > > > > > > > > > > > > > StreamedUnaryService; typedef Service SplitStreamedService; typedef WithStreamedUnaryMethod_InsertBlocks > > > > > > > > > > > > > > > > StreamedService; }; } // namespace execution #endif // GRPC_execution_2fexecution_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/execution/execution.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: execution/execution.proto // Protobuf C++ Version: 5.27.0 #include "execution/execution.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace execution { inline constexpr ReadyResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : ready_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR ReadyResponse::ReadyResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ReadyResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR ReadyResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ReadyResponseDefaultTypeInternal() {} union { ReadyResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReadyResponseDefaultTypeInternal _ReadyResponse_default_instance_; inline constexpr IsCanonicalResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : canonical_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR IsCanonicalResponse::IsCanonicalResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct IsCanonicalResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR IsCanonicalResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~IsCanonicalResponseDefaultTypeInternal() {} union { IsCanonicalResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IsCanonicalResponseDefaultTypeInternal _IsCanonicalResponse_default_instance_; inline constexpr InsertionResult::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : result_{static_cast< ::execution::ExecutionStatus >(0)}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR InsertionResult::InsertionResult(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct InsertionResultDefaultTypeInternal { PROTOBUF_CONSTEXPR InsertionResultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~InsertionResultDefaultTypeInternal() {} union { InsertionResult _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InsertionResultDefaultTypeInternal _InsertionResult_default_instance_; inline constexpr HasBlockResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : has_block_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR HasBlockResponse::HasBlockResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HasBlockResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR HasBlockResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HasBlockResponseDefaultTypeInternal() {} union { HasBlockResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HasBlockResponseDefaultTypeInternal _HasBlockResponse_default_instance_; inline constexpr GetHeaderHashNumberResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, block_number_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR GetHeaderHashNumberResponse::GetHeaderHashNumberResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetHeaderHashNumberResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR GetHeaderHashNumberResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetHeaderHashNumberResponseDefaultTypeInternal() {} union { GetHeaderHashNumberResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetHeaderHashNumberResponseDefaultTypeInternal _GetHeaderHashNumberResponse_default_instance_; inline constexpr GetBodiesByRangeRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : start_{::uint64_t{0u}}, count_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR GetBodiesByRangeRequest::GetBodiesByRangeRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetBodiesByRangeRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR GetBodiesByRangeRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetBodiesByRangeRequestDefaultTypeInternal() {} union { GetBodiesByRangeRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetBodiesByRangeRequestDefaultTypeInternal _GetBodiesByRangeRequest_default_instance_; inline constexpr GetAssembledBlockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : id_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR GetAssembledBlockRequest::GetAssembledBlockRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetAssembledBlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR GetAssembledBlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetAssembledBlockRequestDefaultTypeInternal() {} union { GetAssembledBlockRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetAssembledBlockRequestDefaultTypeInternal _GetAssembledBlockRequest_default_instance_; inline constexpr FrozenBlocksResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : frozen_blocks_{::uint64_t{0u}}, has_gap_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR FrozenBlocksResponse::FrozenBlocksResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct FrozenBlocksResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR FrozenBlocksResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~FrozenBlocksResponseDefaultTypeInternal() {} union { FrozenBlocksResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FrozenBlocksResponseDefaultTypeInternal _FrozenBlocksResponse_default_instance_; inline constexpr AssembleBlockResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : id_{::uint64_t{0u}}, busy_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR AssembleBlockResponse::AssembleBlockResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AssembleBlockResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR AssembleBlockResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AssembleBlockResponseDefaultTypeInternal() {} union { AssembleBlockResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AssembleBlockResponseDefaultTypeInternal _AssembleBlockResponse_default_instance_; inline constexpr ValidationRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hash_{nullptr}, number_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR ValidationRequest::ValidationRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ValidationRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ValidationRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ValidationRequestDefaultTypeInternal() {} union { ValidationRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValidationRequestDefaultTypeInternal _ValidationRequest_default_instance_; inline constexpr ValidationReceipt::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, validation_error_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), latest_valid_hash_{nullptr}, validation_status_{static_cast< ::execution::ExecutionStatus >(0)} {} template PROTOBUF_CONSTEXPR ValidationReceipt::ValidationReceipt(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ValidationReceiptDefaultTypeInternal { PROTOBUF_CONSTEXPR ValidationReceiptDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ValidationReceiptDefaultTypeInternal() {} union { ValidationReceipt _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValidationReceiptDefaultTypeInternal _ValidationReceipt_default_instance_; inline constexpr GetTDResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, td_{nullptr} {} template PROTOBUF_CONSTEXPR GetTDResponse::GetTDResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetTDResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR GetTDResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetTDResponseDefaultTypeInternal() {} union { GetTDResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTDResponseDefaultTypeInternal _GetTDResponse_default_instance_; inline constexpr GetSegmentRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, block_hash_{nullptr}, block_number_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR GetSegmentRequest::GetSegmentRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetSegmentRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR GetSegmentRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetSegmentRequestDefaultTypeInternal() {} union { GetSegmentRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSegmentRequestDefaultTypeInternal _GetSegmentRequest_default_instance_; inline constexpr GetBodiesByHashesRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : hashes_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR GetBodiesByHashesRequest::GetBodiesByHashesRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetBodiesByHashesRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR GetBodiesByHashesRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetBodiesByHashesRequestDefaultTypeInternal() {} union { GetBodiesByHashesRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetBodiesByHashesRequestDefaultTypeInternal _GetBodiesByHashesRequest_default_instance_; inline constexpr ForkChoiceReceipt::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, validation_error_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), latest_valid_hash_{nullptr}, status_{static_cast< ::execution::ExecutionStatus >(0)} {} template PROTOBUF_CONSTEXPR ForkChoiceReceipt::ForkChoiceReceipt(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ForkChoiceReceiptDefaultTypeInternal { PROTOBUF_CONSTEXPR ForkChoiceReceiptDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ForkChoiceReceiptDefaultTypeInternal() {} union { ForkChoiceReceipt _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ForkChoiceReceiptDefaultTypeInternal _ForkChoiceReceipt_default_instance_; inline constexpr ForkChoice::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, head_block_hash_{nullptr}, finalized_block_hash_{nullptr}, safe_block_hash_{nullptr}, timeout_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR ForkChoice::ForkChoice(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ForkChoiceDefaultTypeInternal { PROTOBUF_CONSTEXPR ForkChoiceDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ForkChoiceDefaultTypeInternal() {} union { ForkChoice _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ForkChoiceDefaultTypeInternal _ForkChoice_default_instance_; inline constexpr AssembleBlockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, withdrawals_{}, parent_hash_{nullptr}, prev_randao_{nullptr}, suggested_fee_recipient_{nullptr}, parent_beacon_block_root_{nullptr}, timestamp_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR AssembleBlockRequest::AssembleBlockRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AssembleBlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR AssembleBlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AssembleBlockRequestDefaultTypeInternal() {} union { AssembleBlockRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AssembleBlockRequestDefaultTypeInternal _AssembleBlockRequest_default_instance_; inline constexpr Header::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, extra_data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), aura_seal_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), parent_hash_{nullptr}, coinbase_{nullptr}, state_root_{nullptr}, receipt_root_{nullptr}, logs_bloom_{nullptr}, prev_randao_{nullptr}, difficulty_{nullptr}, block_hash_{nullptr}, ommer_hash_{nullptr}, transaction_hash_{nullptr}, base_fee_per_gas_{nullptr}, withdrawal_hash_{nullptr}, parent_beacon_block_root_{nullptr}, requests_hash_{nullptr}, block_number_{::uint64_t{0u}}, gas_limit_{::uint64_t{0u}}, gas_used_{::uint64_t{0u}}, timestamp_{::uint64_t{0u}}, nonce_{::uint64_t{0u}}, blob_gas_used_{::uint64_t{0u}}, excess_blob_gas_{::uint64_t{0u}}, aura_step_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR Header::Header(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HeaderDefaultTypeInternal { PROTOBUF_CONSTEXPR HeaderDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HeaderDefaultTypeInternal() {} union { Header _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeaderDefaultTypeInternal _Header_default_instance_; inline constexpr GetHeaderResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, header_{nullptr} {} template PROTOBUF_CONSTEXPR GetHeaderResponse::GetHeaderResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetHeaderResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR GetHeaderResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetHeaderResponseDefaultTypeInternal() {} union { GetHeaderResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetHeaderResponseDefaultTypeInternal _GetHeaderResponse_default_instance_; inline constexpr BlockBody::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, transactions_{}, uncles_{}, withdrawals_{}, block_hash_{nullptr}, block_number_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR BlockBody::BlockBody(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BlockBodyDefaultTypeInternal { PROTOBUF_CONSTEXPR BlockBodyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BlockBodyDefaultTypeInternal() {} union { BlockBody _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockBodyDefaultTypeInternal _BlockBody_default_instance_; inline constexpr AssembledBlockData::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, execution_payload_{nullptr}, block_value_{nullptr}, blobs_bundle_{nullptr}, requests_{nullptr} {} template PROTOBUF_CONSTEXPR AssembledBlockData::AssembledBlockData(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AssembledBlockDataDefaultTypeInternal { PROTOBUF_CONSTEXPR AssembledBlockDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AssembledBlockDataDefaultTypeInternal() {} union { AssembledBlockData _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AssembledBlockDataDefaultTypeInternal _AssembledBlockData_default_instance_; inline constexpr GetBodyResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, body_{nullptr} {} template PROTOBUF_CONSTEXPR GetBodyResponse::GetBodyResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetBodyResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR GetBodyResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetBodyResponseDefaultTypeInternal() {} union { GetBodyResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetBodyResponseDefaultTypeInternal _GetBodyResponse_default_instance_; inline constexpr GetBodiesBatchResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : bodies_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR GetBodiesBatchResponse::GetBodiesBatchResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetBodiesBatchResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR GetBodiesBatchResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetBodiesBatchResponseDefaultTypeInternal() {} union { GetBodiesBatchResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetBodiesBatchResponseDefaultTypeInternal _GetBodiesBatchResponse_default_instance_; inline constexpr GetAssembledBlockResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, data_{nullptr}, busy_{false} {} template PROTOBUF_CONSTEXPR GetAssembledBlockResponse::GetAssembledBlockResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetAssembledBlockResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR GetAssembledBlockResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetAssembledBlockResponseDefaultTypeInternal() {} union { GetAssembledBlockResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetAssembledBlockResponseDefaultTypeInternal _GetAssembledBlockResponse_default_instance_; inline constexpr Block::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, header_{nullptr}, body_{nullptr} {} template PROTOBUF_CONSTEXPR Block::Block(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BlockDefaultTypeInternal { PROTOBUF_CONSTEXPR BlockDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BlockDefaultTypeInternal() {} union { Block _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockDefaultTypeInternal _Block_default_instance_; inline constexpr InsertBlocksRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : blocks_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR InsertBlocksRequest::InsertBlocksRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct InsertBlocksRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR InsertBlocksRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~InsertBlocksRequestDefaultTypeInternal() {} union { InsertBlocksRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InsertBlocksRequestDefaultTypeInternal _InsertBlocksRequest_default_instance_; } // namespace execution static const ::_pb::EnumDescriptor* file_level_enum_descriptors_execution_2fexecution_2eproto[1]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_execution_2fexecution_2eproto = nullptr; const ::uint32_t TableStruct_execution_2fexecution_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { PROTOBUF_FIELD_OFFSET(::execution::ForkChoiceReceipt, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoiceReceipt, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::ForkChoiceReceipt, _impl_.status_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoiceReceipt, _impl_.latest_valid_hash_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoiceReceipt, _impl_.validation_error_), ~0u, 0, ~0u, PROTOBUF_FIELD_OFFSET(::execution::ValidationReceipt, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::ValidationReceipt, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::ValidationReceipt, _impl_.validation_status_), PROTOBUF_FIELD_OFFSET(::execution::ValidationReceipt, _impl_.latest_valid_hash_), PROTOBUF_FIELD_OFFSET(::execution::ValidationReceipt, _impl_.validation_error_), ~0u, 0, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::IsCanonicalResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::IsCanonicalResponse, _impl_.canonical_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::Header, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.parent_hash_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.coinbase_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.state_root_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.receipt_root_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.logs_bloom_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.prev_randao_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.gas_limit_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.gas_used_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.timestamp_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.nonce_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.extra_data_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.difficulty_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.block_hash_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.ommer_hash_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.transaction_hash_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.base_fee_per_gas_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.withdrawal_hash_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.blob_gas_used_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.excess_blob_gas_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.parent_beacon_block_root_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.requests_hash_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.aura_step_), PROTOBUF_FIELD_OFFSET(::execution::Header, _impl_.aura_seal_), 1, 2, 3, 4, 5, 6, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 7, 8, 9, 10, 11, 12, 15, 16, 13, 14, 17, 0, PROTOBUF_FIELD_OFFSET(::execution::BlockBody, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::BlockBody, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::BlockBody, _impl_.block_hash_), PROTOBUF_FIELD_OFFSET(::execution::BlockBody, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::execution::BlockBody, _impl_.transactions_), PROTOBUF_FIELD_OFFSET(::execution::BlockBody, _impl_.uncles_), PROTOBUF_FIELD_OFFSET(::execution::BlockBody, _impl_.withdrawals_), 0, ~0u, ~0u, ~0u, ~0u, PROTOBUF_FIELD_OFFSET(::execution::Block, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::Block, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::Block, _impl_.header_), PROTOBUF_FIELD_OFFSET(::execution::Block, _impl_.body_), 0, 1, PROTOBUF_FIELD_OFFSET(::execution::GetHeaderResponse, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::GetHeaderResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetHeaderResponse, _impl_.header_), 0, PROTOBUF_FIELD_OFFSET(::execution::GetTDResponse, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::GetTDResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetTDResponse, _impl_.td_), 0, PROTOBUF_FIELD_OFFSET(::execution::GetBodyResponse, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::GetBodyResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetBodyResponse, _impl_.body_), 0, PROTOBUF_FIELD_OFFSET(::execution::GetHeaderHashNumberResponse, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::GetHeaderHashNumberResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetHeaderHashNumberResponse, _impl_.block_number_), 0, PROTOBUF_FIELD_OFFSET(::execution::GetSegmentRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::GetSegmentRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetSegmentRequest, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::execution::GetSegmentRequest, _impl_.block_hash_), 1, 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::InsertBlocksRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::InsertBlocksRequest, _impl_.blocks_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoice, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoice, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::ForkChoice, _impl_.head_block_hash_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoice, _impl_.timeout_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoice, _impl_.finalized_block_hash_), PROTOBUF_FIELD_OFFSET(::execution::ForkChoice, _impl_.safe_block_hash_), 0, ~0u, 1, 2, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::InsertionResult, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::InsertionResult, _impl_.result_), PROTOBUF_FIELD_OFFSET(::execution::ValidationRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::ValidationRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::ValidationRequest, _impl_.hash_), PROTOBUF_FIELD_OFFSET(::execution::ValidationRequest, _impl_.number_), 0, ~0u, PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _impl_.parent_hash_), PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _impl_.timestamp_), PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _impl_.prev_randao_), PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _impl_.suggested_fee_recipient_), PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _impl_.withdrawals_), PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockRequest, _impl_.parent_beacon_block_root_), 0, ~0u, 1, 2, ~0u, 3, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockResponse, _impl_.id_), PROTOBUF_FIELD_OFFSET(::execution::AssembleBlockResponse, _impl_.busy_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::GetAssembledBlockRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetAssembledBlockRequest, _impl_.id_), PROTOBUF_FIELD_OFFSET(::execution::AssembledBlockData, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::AssembledBlockData, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::AssembledBlockData, _impl_.execution_payload_), PROTOBUF_FIELD_OFFSET(::execution::AssembledBlockData, _impl_.block_value_), PROTOBUF_FIELD_OFFSET(::execution::AssembledBlockData, _impl_.blobs_bundle_), PROTOBUF_FIELD_OFFSET(::execution::AssembledBlockData, _impl_.requests_), 0, 1, 2, 3, PROTOBUF_FIELD_OFFSET(::execution::GetAssembledBlockResponse, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::execution::GetAssembledBlockResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetAssembledBlockResponse, _impl_.data_), PROTOBUF_FIELD_OFFSET(::execution::GetAssembledBlockResponse, _impl_.busy_), 0, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::GetBodiesBatchResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetBodiesBatchResponse, _impl_.bodies_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::GetBodiesByHashesRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetBodiesByHashesRequest, _impl_.hashes_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::GetBodiesByRangeRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::GetBodiesByRangeRequest, _impl_.start_), PROTOBUF_FIELD_OFFSET(::execution::GetBodiesByRangeRequest, _impl_.count_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::ReadyResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::ReadyResponse, _impl_.ready_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::FrozenBlocksResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::FrozenBlocksResponse, _impl_.frozen_blocks_), PROTOBUF_FIELD_OFFSET(::execution::FrozenBlocksResponse, _impl_.has_gap_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::execution::HasBlockResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::execution::HasBlockResponse, _impl_.has_block_), }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, 11, -1, sizeof(::execution::ForkChoiceReceipt)}, {14, 25, -1, sizeof(::execution::ValidationReceipt)}, {28, -1, -1, sizeof(::execution::IsCanonicalResponse)}, {37, 69, -1, sizeof(::execution::Header)}, {93, 106, -1, sizeof(::execution::BlockBody)}, {111, 121, -1, sizeof(::execution::Block)}, {123, 132, -1, sizeof(::execution::GetHeaderResponse)}, {133, 142, -1, sizeof(::execution::GetTDResponse)}, {143, 152, -1, sizeof(::execution::GetBodyResponse)}, {153, 162, -1, sizeof(::execution::GetHeaderHashNumberResponse)}, {163, 173, -1, sizeof(::execution::GetSegmentRequest)}, {175, -1, -1, sizeof(::execution::InsertBlocksRequest)}, {184, 196, -1, sizeof(::execution::ForkChoice)}, {200, -1, -1, sizeof(::execution::InsertionResult)}, {209, 219, -1, sizeof(::execution::ValidationRequest)}, {221, 235, -1, sizeof(::execution::AssembleBlockRequest)}, {241, -1, -1, sizeof(::execution::AssembleBlockResponse)}, {251, -1, -1, sizeof(::execution::GetAssembledBlockRequest)}, {260, 272, -1, sizeof(::execution::AssembledBlockData)}, {276, 286, -1, sizeof(::execution::GetAssembledBlockResponse)}, {288, -1, -1, sizeof(::execution::GetBodiesBatchResponse)}, {297, -1, -1, sizeof(::execution::GetBodiesByHashesRequest)}, {306, -1, -1, sizeof(::execution::GetBodiesByRangeRequest)}, {316, -1, -1, sizeof(::execution::ReadyResponse)}, {325, -1, -1, sizeof(::execution::FrozenBlocksResponse)}, {335, -1, -1, sizeof(::execution::HasBlockResponse)}, }; static const ::_pb::Message* const file_default_instances[] = { &::execution::_ForkChoiceReceipt_default_instance_._instance, &::execution::_ValidationReceipt_default_instance_._instance, &::execution::_IsCanonicalResponse_default_instance_._instance, &::execution::_Header_default_instance_._instance, &::execution::_BlockBody_default_instance_._instance, &::execution::_Block_default_instance_._instance, &::execution::_GetHeaderResponse_default_instance_._instance, &::execution::_GetTDResponse_default_instance_._instance, &::execution::_GetBodyResponse_default_instance_._instance, &::execution::_GetHeaderHashNumberResponse_default_instance_._instance, &::execution::_GetSegmentRequest_default_instance_._instance, &::execution::_InsertBlocksRequest_default_instance_._instance, &::execution::_ForkChoice_default_instance_._instance, &::execution::_InsertionResult_default_instance_._instance, &::execution::_ValidationRequest_default_instance_._instance, &::execution::_AssembleBlockRequest_default_instance_._instance, &::execution::_AssembleBlockResponse_default_instance_._instance, &::execution::_GetAssembledBlockRequest_default_instance_._instance, &::execution::_AssembledBlockData_default_instance_._instance, &::execution::_GetAssembledBlockResponse_default_instance_._instance, &::execution::_GetBodiesBatchResponse_default_instance_._instance, &::execution::_GetBodiesByHashesRequest_default_instance_._instance, &::execution::_GetBodiesByRangeRequest_default_instance_._instance, &::execution::_ReadyResponse_default_instance_._instance, &::execution::_FrozenBlocksResponse_default_instance_._instance, &::execution::_HasBlockResponse_default_instance_._instance, }; const char descriptor_table_protodef_execution_2fexecution_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\031execution/execution.proto\022\texecution\032\033" "google/protobuf/empty.proto\032\021types/types" ".proto\"\201\001\n\021ForkChoiceReceipt\022*\n\006status\030\001" " \001(\0162\032.execution.ExecutionStatus\022&\n\021late" "st_valid_hash\030\002 \001(\0132\013.types.H256\022\030\n\020vali" "dation_error\030\003 \001(\t\"\214\001\n\021ValidationReceipt" "\0225\n\021validation_status\030\001 \001(\0162\032.execution." "ExecutionStatus\022&\n\021latest_valid_hash\030\002 \001" "(\0132\013.types.H256\022\030\n\020validation_error\030\003 \001(" "\t\"(\n\023IsCanonicalResponse\022\021\n\tcanonical\030\001 " "\001(\010\"\204\007\n\006Header\022 \n\013parent_hash\030\001 \001(\0132\013.ty" "pes.H256\022\035\n\010coinbase\030\002 \001(\0132\013.types.H160\022" "\037\n\nstate_root\030\003 \001(\0132\013.types.H256\022!\n\014rece" "ipt_root\030\004 \001(\0132\013.types.H256\022 \n\nlogs_bloo" "m\030\005 \001(\0132\014.types.H2048\022 \n\013prev_randao\030\006 \001" "(\0132\013.types.H256\022\024\n\014block_number\030\007 \001(\004\022\021\n" "\tgas_limit\030\010 \001(\004\022\020\n\010gas_used\030\t \001(\004\022\021\n\tti" "mestamp\030\n \001(\004\022\r\n\005nonce\030\013 \001(\004\022\022\n\nextra_da" "ta\030\014 \001(\014\022\037\n\ndifficulty\030\r \001(\0132\013.types.H25" "6\022\037\n\nblock_hash\030\016 \001(\0132\013.types.H256\022\037\n\nom" "mer_hash\030\017 \001(\0132\013.types.H256\022%\n\020transacti" "on_hash\030\020 \001(\0132\013.types.H256\022*\n\020base_fee_p" "er_gas\030\021 \001(\0132\013.types.H256H\000\210\001\001\022)\n\017withdr" "awal_hash\030\022 \001(\0132\013.types.H256H\001\210\001\001\022\032\n\rblo" "b_gas_used\030\023 \001(\004H\002\210\001\001\022\034\n\017excess_blob_gas" "\030\024 \001(\004H\003\210\001\001\0222\n\030parent_beacon_block_root\030" "\025 \001(\0132\013.types.H256H\004\210\001\001\022\'\n\rrequests_hash" "\030\026 \001(\0132\013.types.H256H\005\210\001\001\022\026\n\taura_step\030\027 " "\001(\004H\006\210\001\001\022\026\n\taura_seal\030\030 \001(\014H\007\210\001\001B\023\n\021_bas" "e_fee_per_gasB\022\n\020_withdrawal_hashB\020\n\016_bl" "ob_gas_usedB\022\n\020_excess_blob_gasB\033\n\031_pare" "nt_beacon_block_rootB\020\n\016_requests_hashB\014" "\n\n_aura_stepB\014\n\n_aura_seal\"\243\001\n\tBlockBody" "\022\037\n\nblock_hash\030\001 \001(\0132\013.types.H256\022\024\n\014blo" "ck_number\030\002 \001(\004\022\024\n\014transactions\030\003 \003(\014\022!\n" "\006uncles\030\004 \003(\0132\021.execution.Header\022&\n\013with" "drawals\030\005 \003(\0132\021.types.Withdrawal\"N\n\005Bloc" "k\022!\n\006header\030\001 \001(\0132\021.execution.Header\022\"\n\004" "body\030\002 \001(\0132\024.execution.BlockBody\"F\n\021GetH" "eaderResponse\022&\n\006header\030\001 \001(\0132\021.executio" "n.HeaderH\000\210\001\001B\t\n\007_header\"4\n\rGetTDRespons" "e\022\034\n\002td\030\001 \001(\0132\013.types.H256H\000\210\001\001B\005\n\003_td\"C" "\n\017GetBodyResponse\022\'\n\004body\030\001 \001(\0132\024.execut" "ion.BlockBodyH\000\210\001\001B\007\n\005_body\"I\n\033GetHeader" "HashNumberResponse\022\031\n\014block_number\030\001 \001(\004" "H\000\210\001\001B\017\n\r_block_number\"t\n\021GetSegmentRequ" "est\022\031\n\014block_number\030\001 \001(\004H\000\210\001\001\022$\n\nblock_" "hash\030\002 \001(\0132\013.types.H256H\001\210\001\001B\017\n\r_block_n" "umberB\r\n\013_block_hash\"7\n\023InsertBlocksRequ" "est\022 \n\006blocks\030\001 \003(\0132\020.execution.Block\"\313\001" "\n\nForkChoice\022$\n\017head_block_hash\030\001 \001(\0132\013." "types.H256\022\017\n\007timeout\030\002 \001(\004\022.\n\024finalized" "_block_hash\030\003 \001(\0132\013.types.H256H\000\210\001\001\022)\n\017s" "afe_block_hash\030\004 \001(\0132\013.types.H256H\001\210\001\001B\027" "\n\025_finalized_block_hashB\022\n\020_safe_block_h" "ash\"=\n\017InsertionResult\022*\n\006result\030\001 \001(\0162\032" ".execution.ExecutionStatus\">\n\021Validation" "Request\022\031\n\004hash\030\001 \001(\0132\013.types.H256\022\016\n\006nu" "mber\030\002 \001(\004\"\224\002\n\024AssembleBlockRequest\022 \n\013p" "arent_hash\030\001 \001(\0132\013.types.H256\022\021\n\ttimesta" "mp\030\002 \001(\004\022 \n\013prev_randao\030\003 \001(\0132\013.types.H2" "56\022,\n\027suggested_fee_recipient\030\004 \001(\0132\013.ty" "pes.H160\022&\n\013withdrawals\030\005 \003(\0132\021.types.Wi" "thdrawal\0222\n\030parent_beacon_block_root\030\006 \001" "(\0132\013.types.H256H\000\210\001\001B\033\n\031_parent_beacon_b" "lock_root\"1\n\025AssembleBlockResponse\022\n\n\002id" "\030\001 \001(\004\022\014\n\004busy\030\002 \001(\010\"&\n\030GetAssembledBloc" "kRequest\022\n\n\002id\030\001 \001(\004\"\277\001\n\022AssembledBlockD" "ata\0222\n\021execution_payload\030\001 \001(\0132\027.types.E" "xecutionPayload\022 \n\013block_value\030\002 \001(\0132\013.t" "ypes.H256\022*\n\014blobs_bundle\030\003 \001(\0132\024.types." "BlobsBundleV1\022\'\n\010requests\030\004 \001(\0132\025.types." "RequestsBundle\"d\n\031GetAssembledBlockRespo" "nse\0220\n\004data\030\001 \001(\0132\035.execution.AssembledB" "lockDataH\000\210\001\001\022\014\n\004busy\030\002 \001(\010B\007\n\005_data\">\n\026" "GetBodiesBatchResponse\022$\n\006bodies\030\001 \003(\0132\024" ".execution.BlockBody\"7\n\030GetBodiesByHashe" "sRequest\022\033\n\006hashes\030\001 \003(\0132\013.types.H256\"7\n" "\027GetBodiesByRangeRequest\022\r\n\005start\030\001 \001(\004\022" "\r\n\005count\030\002 \001(\004\"\036\n\rReadyResponse\022\r\n\005ready" "\030\001 \001(\010\">\n\024FrozenBlocksResponse\022\025\n\rfrozen" "_blocks\030\001 \001(\004\022\017\n\007has_gap\030\002 \001(\010\"%\n\020HasBlo" "ckResponse\022\021\n\thas_block\030\001 \001(\010*q\n\017Executi" "onStatus\022\013\n\007Success\020\000\022\014\n\010BadBlock\020\001\022\016\n\nT" "ooFarAway\020\002\022\022\n\016MissingSegment\020\003\022\025\n\021Inval" "idForkchoice\020\004\022\010\n\004Busy\020\0052\206\n\n\tExecution\022J" "\n\014InsertBlocks\022\036.execution.InsertBlocksR" "equest\032\032.execution.InsertionResult\022K\n\rVa" "lidateChain\022\034.execution.ValidationReques" "t\032\034.execution.ValidationReceipt\022G\n\020Updat" "eForkChoice\022\025.execution.ForkChoice\032\034.exe" "cution.ForkChoiceReceipt\022R\n\rAssembleBloc" "k\022\037.execution.AssembleBlockRequest\032 .exe" "cution.AssembleBlockResponse\022^\n\021GetAssem" "bledBlock\022#.execution.GetAssembledBlockR" "equest\032$.execution.GetAssembledBlockResp" "onse\022E\n\rCurrentHeader\022\026.google.protobuf." "Empty\032\034.execution.GetHeaderResponse\022\?\n\005G" "etTD\022\034.execution.GetSegmentRequest\032\030.exe" "cution.GetTDResponse\022G\n\tGetHeader\022\034.exec" "ution.GetSegmentRequest\032\034.execution.GetH" "eaderResponse\022C\n\007GetBody\022\034.execution.Get" "SegmentRequest\032\032.execution.GetBodyRespon" "se\022E\n\010HasBlock\022\034.execution.GetSegmentReq" "uest\032\033.execution.HasBlockResponse\022Y\n\020Get" "BodiesByRange\022\".execution.GetBodiesByRan" "geRequest\032!.execution.GetBodiesBatchResp" "onse\022[\n\021GetBodiesByHashes\022#.execution.Ge" "tBodiesByHashesRequest\032!.execution.GetBo" "diesBatchResponse\022>\n\017IsCanonicalHash\022\013.t" "ypes.H256\032\036.execution.IsCanonicalRespons" "e\022J\n\023GetHeaderHashNumber\022\013.types.H256\032&." "execution.GetHeaderHashNumberResponse\022>\n" "\rGetForkChoice\022\026.google.protobuf.Empty\032\025" ".execution.ForkChoice\0229\n\005Ready\022\026.google." "protobuf.Empty\032\030.execution.ReadyResponse" "\022G\n\014FrozenBlocks\022\026.google.protobuf.Empty" "\032\037.execution.FrozenBlocksResponseB\034Z\032./e" "xecution;executionprotob\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_execution_2fexecution_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_types_2ftypes_2eproto, }; static ::absl::once_flag descriptor_table_execution_2fexecution_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_execution_2fexecution_2eproto = { false, false, 4751, descriptor_table_protodef_execution_2fexecution_2eproto, "execution/execution.proto", &descriptor_table_execution_2fexecution_2eproto_once, descriptor_table_execution_2fexecution_2eproto_deps, 2, 26, schemas, file_default_instances, TableStruct_execution_2fexecution_2eproto::offsets, file_level_enum_descriptors_execution_2fexecution_2eproto, file_level_service_descriptors_execution_2fexecution_2eproto, }; namespace execution { const ::google::protobuf::EnumDescriptor* ExecutionStatus_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_execution_2fexecution_2eproto); return file_level_enum_descriptors_execution_2fexecution_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t ExecutionStatus_internal_data_[] = { 393216u, 0u, }; bool ExecutionStatus_IsValid(int value) { return 0 <= value && value <= 5; } // =================================================================== class ForkChoiceReceipt::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_._has_bits_); }; void ForkChoiceReceipt::clear_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.latest_valid_hash_ != nullptr) _impl_.latest_valid_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } ForkChoiceReceipt::ForkChoiceReceipt(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.ForkChoiceReceipt) } inline PROTOBUF_NDEBUG_INLINE ForkChoiceReceipt::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::ForkChoiceReceipt& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, validation_error_(arena, from.validation_error_) {} ForkChoiceReceipt::ForkChoiceReceipt( ::google::protobuf::Arena* arena, const ForkChoiceReceipt& from) : ::google::protobuf::Message(arena) { ForkChoiceReceipt* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.latest_valid_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.latest_valid_hash_) : nullptr; _impl_.status_ = from._impl_.status_; // @@protoc_insertion_point(copy_constructor:execution.ForkChoiceReceipt) } inline PROTOBUF_NDEBUG_INLINE ForkChoiceReceipt::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, validation_error_(arena) {} inline void ForkChoiceReceipt::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, latest_valid_hash_), 0, offsetof(Impl_, status_) - offsetof(Impl_, latest_valid_hash_) + sizeof(Impl_::status_)); } ForkChoiceReceipt::~ForkChoiceReceipt() { // @@protoc_insertion_point(destructor:execution.ForkChoiceReceipt) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ForkChoiceReceipt::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.validation_error_.Destroy(); delete _impl_.latest_valid_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ForkChoiceReceipt::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_._cached_size_), false, }, &ForkChoiceReceipt::MergeImpl, &ForkChoiceReceipt::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 1, 52, 2> ForkChoiceReceipt::_table_ = { { PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_ForkChoiceReceipt_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::ForkChoiceReceipt>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .execution.ExecutionStatus status = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ForkChoiceReceipt, _impl_.status_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.status_)}}, // .types.H256 latest_valid_hash = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.latest_valid_hash_)}}, // string validation_error = 3; {::_pbi::TcParser::FastUS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.validation_error_)}}, }}, {{ 65535, 65535 }}, {{ // .execution.ExecutionStatus status = 1; {PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.status_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // .types.H256 latest_valid_hash = 2; {PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.latest_valid_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // string validation_error = 3; {PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.validation_error_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ "\33\0\0\20\0\0\0\0" "execution.ForkChoiceReceipt" "validation_error" }}, }; PROTOBUF_NOINLINE void ForkChoiceReceipt::Clear() { // @@protoc_insertion_point(message_clear_start:execution.ForkChoiceReceipt) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.validation_error_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.latest_valid_hash_ != nullptr); _impl_.latest_valid_hash_->Clear(); } _impl_.status_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ForkChoiceReceipt::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.ForkChoiceReceipt) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .execution.ExecutionStatus status = 1; if (this->_internal_status() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_status(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H256 latest_valid_hash = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.latest_valid_hash_, _impl_.latest_valid_hash_->GetCachedSize(), target, stream); } // string validation_error = 3; if (!this->_internal_validation_error().empty()) { const std::string& _s = this->_internal_validation_error(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "execution.ForkChoiceReceipt.validation_error"); target = stream->WriteStringMaybeAliased(3, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.ForkChoiceReceipt) return target; } ::size_t ForkChoiceReceipt::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.ForkChoiceReceipt) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string validation_error = 3; if (!this->_internal_validation_error().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_validation_error()); } // .types.H256 latest_valid_hash = 2; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.latest_valid_hash_); } // .execution.ExecutionStatus status = 1; if (this->_internal_status() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ForkChoiceReceipt::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.ForkChoiceReceipt) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_validation_error().empty()) { _this->_internal_set_validation_error(from._internal_validation_error()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.latest_valid_hash_ != nullptr); if (_this->_impl_.latest_valid_hash_ == nullptr) { _this->_impl_.latest_valid_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.latest_valid_hash_); } else { _this->_impl_.latest_valid_hash_->MergeFrom(*from._impl_.latest_valid_hash_); } } if (from._internal_status() != 0) { _this->_impl_.status_ = from._impl_.status_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ForkChoiceReceipt::CopyFrom(const ForkChoiceReceipt& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.ForkChoiceReceipt) if (&from == this) return; Clear(); MergeFrom(from); } void ForkChoiceReceipt::InternalSwap(ForkChoiceReceipt* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.validation_error_, &other->_impl_.validation_error_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.status_) + sizeof(ForkChoiceReceipt::_impl_.status_) - PROTOBUF_FIELD_OFFSET(ForkChoiceReceipt, _impl_.latest_valid_hash_)>( reinterpret_cast(&_impl_.latest_valid_hash_), reinterpret_cast(&other->_impl_.latest_valid_hash_)); } ::google::protobuf::Metadata ForkChoiceReceipt::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ValidationReceipt::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_._has_bits_); }; void ValidationReceipt::clear_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.latest_valid_hash_ != nullptr) _impl_.latest_valid_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } ValidationReceipt::ValidationReceipt(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.ValidationReceipt) } inline PROTOBUF_NDEBUG_INLINE ValidationReceipt::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::ValidationReceipt& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, validation_error_(arena, from.validation_error_) {} ValidationReceipt::ValidationReceipt( ::google::protobuf::Arena* arena, const ValidationReceipt& from) : ::google::protobuf::Message(arena) { ValidationReceipt* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.latest_valid_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.latest_valid_hash_) : nullptr; _impl_.validation_status_ = from._impl_.validation_status_; // @@protoc_insertion_point(copy_constructor:execution.ValidationReceipt) } inline PROTOBUF_NDEBUG_INLINE ValidationReceipt::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, validation_error_(arena) {} inline void ValidationReceipt::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, latest_valid_hash_), 0, offsetof(Impl_, validation_status_) - offsetof(Impl_, latest_valid_hash_) + sizeof(Impl_::validation_status_)); } ValidationReceipt::~ValidationReceipt() { // @@protoc_insertion_point(destructor:execution.ValidationReceipt) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ValidationReceipt::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.validation_error_.Destroy(); delete _impl_.latest_valid_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ValidationReceipt::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_._cached_size_), false, }, &ValidationReceipt::MergeImpl, &ValidationReceipt::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 1, 52, 2> ValidationReceipt::_table_ = { { PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_ValidationReceipt_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::ValidationReceipt>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .execution.ExecutionStatus validation_status = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ValidationReceipt, _impl_.validation_status_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.validation_status_)}}, // .types.H256 latest_valid_hash = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.latest_valid_hash_)}}, // string validation_error = 3; {::_pbi::TcParser::FastUS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.validation_error_)}}, }}, {{ 65535, 65535 }}, {{ // .execution.ExecutionStatus validation_status = 1; {PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.validation_status_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // .types.H256 latest_valid_hash = 2; {PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.latest_valid_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // string validation_error = 3; {PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.validation_error_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ "\33\0\0\20\0\0\0\0" "execution.ValidationReceipt" "validation_error" }}, }; PROTOBUF_NOINLINE void ValidationReceipt::Clear() { // @@protoc_insertion_point(message_clear_start:execution.ValidationReceipt) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.validation_error_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.latest_valid_hash_ != nullptr); _impl_.latest_valid_hash_->Clear(); } _impl_.validation_status_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ValidationReceipt::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.ValidationReceipt) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .execution.ExecutionStatus validation_status = 1; if (this->_internal_validation_status() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_validation_status(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H256 latest_valid_hash = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.latest_valid_hash_, _impl_.latest_valid_hash_->GetCachedSize(), target, stream); } // string validation_error = 3; if (!this->_internal_validation_error().empty()) { const std::string& _s = this->_internal_validation_error(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "execution.ValidationReceipt.validation_error"); target = stream->WriteStringMaybeAliased(3, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.ValidationReceipt) return target; } ::size_t ValidationReceipt::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.ValidationReceipt) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string validation_error = 3; if (!this->_internal_validation_error().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_validation_error()); } // .types.H256 latest_valid_hash = 2; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.latest_valid_hash_); } // .execution.ExecutionStatus validation_status = 1; if (this->_internal_validation_status() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_validation_status()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ValidationReceipt::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.ValidationReceipt) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_validation_error().empty()) { _this->_internal_set_validation_error(from._internal_validation_error()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.latest_valid_hash_ != nullptr); if (_this->_impl_.latest_valid_hash_ == nullptr) { _this->_impl_.latest_valid_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.latest_valid_hash_); } else { _this->_impl_.latest_valid_hash_->MergeFrom(*from._impl_.latest_valid_hash_); } } if (from._internal_validation_status() != 0) { _this->_impl_.validation_status_ = from._impl_.validation_status_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ValidationReceipt::CopyFrom(const ValidationReceipt& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.ValidationReceipt) if (&from == this) return; Clear(); MergeFrom(from); } void ValidationReceipt::InternalSwap(ValidationReceipt* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.validation_error_, &other->_impl_.validation_error_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.validation_status_) + sizeof(ValidationReceipt::_impl_.validation_status_) - PROTOBUF_FIELD_OFFSET(ValidationReceipt, _impl_.latest_valid_hash_)>( reinterpret_cast(&_impl_.latest_valid_hash_), reinterpret_cast(&other->_impl_.latest_valid_hash_)); } ::google::protobuf::Metadata ValidationReceipt::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class IsCanonicalResponse::_Internal { public: }; IsCanonicalResponse::IsCanonicalResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.IsCanonicalResponse) } IsCanonicalResponse::IsCanonicalResponse( ::google::protobuf::Arena* arena, const IsCanonicalResponse& from) : IsCanonicalResponse(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE IsCanonicalResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void IsCanonicalResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.canonical_ = {}; } IsCanonicalResponse::~IsCanonicalResponse() { // @@protoc_insertion_point(destructor:execution.IsCanonicalResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void IsCanonicalResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* IsCanonicalResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(IsCanonicalResponse, _impl_._cached_size_), false, }, &IsCanonicalResponse::MergeImpl, &IsCanonicalResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IsCanonicalResponse::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_IsCanonicalResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::IsCanonicalResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool canonical = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(IsCanonicalResponse, _impl_.canonical_)}}, }}, {{ 65535, 65535 }}, {{ // bool canonical = 1; {PROTOBUF_FIELD_OFFSET(IsCanonicalResponse, _impl_.canonical_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void IsCanonicalResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.IsCanonicalResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.canonical_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* IsCanonicalResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.IsCanonicalResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool canonical = 1; if (this->_internal_canonical() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_canonical(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.IsCanonicalResponse) return target; } ::size_t IsCanonicalResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.IsCanonicalResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool canonical = 1; if (this->_internal_canonical() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void IsCanonicalResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.IsCanonicalResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_canonical() != 0) { _this->_impl_.canonical_ = from._impl_.canonical_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void IsCanonicalResponse::CopyFrom(const IsCanonicalResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.IsCanonicalResponse) if (&from == this) return; Clear(); MergeFrom(from); } void IsCanonicalResponse::InternalSwap(IsCanonicalResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.canonical_, other->_impl_.canonical_); } ::google::protobuf::Metadata IsCanonicalResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Header::_Internal { public: using HasBits = decltype(std::declval
()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(Header, _impl_._has_bits_); }; void Header::clear_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_hash_ != nullptr) _impl_.parent_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } void Header::clear_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.coinbase_ != nullptr) _impl_.coinbase_->Clear(); _impl_._has_bits_[0] &= ~0x00000004u; } void Header::clear_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.state_root_ != nullptr) _impl_.state_root_->Clear(); _impl_._has_bits_[0] &= ~0x00000008u; } void Header::clear_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.receipt_root_ != nullptr) _impl_.receipt_root_->Clear(); _impl_._has_bits_[0] &= ~0x00000010u; } void Header::clear_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.logs_bloom_ != nullptr) _impl_.logs_bloom_->Clear(); _impl_._has_bits_[0] &= ~0x00000020u; } void Header::clear_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.prev_randao_ != nullptr) _impl_.prev_randao_->Clear(); _impl_._has_bits_[0] &= ~0x00000040u; } void Header::clear_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.difficulty_ != nullptr) _impl_.difficulty_->Clear(); _impl_._has_bits_[0] &= ~0x00000080u; } void Header::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000100u; } void Header::clear_ommer_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.ommer_hash_ != nullptr) _impl_.ommer_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000200u; } void Header::clear_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.transaction_hash_ != nullptr) _impl_.transaction_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000400u; } void Header::clear_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.base_fee_per_gas_ != nullptr) _impl_.base_fee_per_gas_->Clear(); _impl_._has_bits_[0] &= ~0x00000800u; } void Header::clear_withdrawal_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.withdrawal_hash_ != nullptr) _impl_.withdrawal_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00001000u; } void Header::clear_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_beacon_block_root_ != nullptr) _impl_.parent_beacon_block_root_->Clear(); _impl_._has_bits_[0] &= ~0x00002000u; } void Header::clear_requests_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.requests_hash_ != nullptr) _impl_.requests_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00004000u; } Header::Header(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.Header) } inline PROTOBUF_NDEBUG_INLINE Header::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::Header& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, extra_data_(arena, from.extra_data_), aura_seal_(arena, from.aura_seal_) {} Header::Header( ::google::protobuf::Arena* arena, const Header& from) : ::google::protobuf::Message(arena) { Header* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.parent_hash_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.parent_hash_) : nullptr; _impl_.coinbase_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.coinbase_) : nullptr; _impl_.state_root_ = (cached_has_bits & 0x00000008u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.state_root_) : nullptr; _impl_.receipt_root_ = (cached_has_bits & 0x00000010u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.receipt_root_) : nullptr; _impl_.logs_bloom_ = (cached_has_bits & 0x00000020u) ? ::google::protobuf::Message::CopyConstruct<::types::H2048>( arena, *from._impl_.logs_bloom_) : nullptr; _impl_.prev_randao_ = (cached_has_bits & 0x00000040u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.prev_randao_) : nullptr; _impl_.difficulty_ = (cached_has_bits & 0x00000080u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.difficulty_) : nullptr; _impl_.block_hash_ = (cached_has_bits & 0x00000100u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; _impl_.ommer_hash_ = (cached_has_bits & 0x00000200u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.ommer_hash_) : nullptr; _impl_.transaction_hash_ = (cached_has_bits & 0x00000400u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.transaction_hash_) : nullptr; _impl_.base_fee_per_gas_ = (cached_has_bits & 0x00000800u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.base_fee_per_gas_) : nullptr; _impl_.withdrawal_hash_ = (cached_has_bits & 0x00001000u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.withdrawal_hash_) : nullptr; _impl_.parent_beacon_block_root_ = (cached_has_bits & 0x00002000u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.parent_beacon_block_root_) : nullptr; _impl_.requests_hash_ = (cached_has_bits & 0x00004000u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.requests_hash_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, block_number_), reinterpret_cast(&from._impl_) + offsetof(Impl_, block_number_), offsetof(Impl_, aura_step_) - offsetof(Impl_, block_number_) + sizeof(Impl_::aura_step_)); // @@protoc_insertion_point(copy_constructor:execution.Header) } inline PROTOBUF_NDEBUG_INLINE Header::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, extra_data_(arena), aura_seal_(arena) {} inline void Header::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, parent_hash_), 0, offsetof(Impl_, aura_step_) - offsetof(Impl_, parent_hash_) + sizeof(Impl_::aura_step_)); } Header::~Header() { // @@protoc_insertion_point(destructor:execution.Header) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Header::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.extra_data_.Destroy(); _impl_.aura_seal_.Destroy(); delete _impl_.parent_hash_; delete _impl_.coinbase_; delete _impl_.state_root_; delete _impl_.receipt_root_; delete _impl_.logs_bloom_; delete _impl_.prev_randao_; delete _impl_.difficulty_; delete _impl_.block_hash_; delete _impl_.ommer_hash_; delete _impl_.transaction_hash_; delete _impl_.base_fee_per_gas_; delete _impl_.withdrawal_hash_; delete _impl_.parent_beacon_block_root_; delete _impl_.requests_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Header::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Header, _impl_._cached_size_), false, }, &Header::MergeImpl, &Header::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<5, 24, 14, 0, 2> Header::_table_ = { { PROTOBUF_FIELD_OFFSET(Header, _impl_._has_bits_), 0, // no _extensions_ 24, 248, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4278190080, // skipmap offsetof(decltype(_table_), field_entries), 24, // num_field_entries 14, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_Header_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::Header>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .types.H256 parent_hash = 1; {::_pbi::TcParser::FastMtS1, {10, 1, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.parent_hash_)}}, // .types.H160 coinbase = 2; {::_pbi::TcParser::FastMtS1, {18, 2, 1, PROTOBUF_FIELD_OFFSET(Header, _impl_.coinbase_)}}, // .types.H256 state_root = 3; {::_pbi::TcParser::FastMtS1, {26, 3, 2, PROTOBUF_FIELD_OFFSET(Header, _impl_.state_root_)}}, // .types.H256 receipt_root = 4; {::_pbi::TcParser::FastMtS1, {34, 4, 3, PROTOBUF_FIELD_OFFSET(Header, _impl_.receipt_root_)}}, // .types.H2048 logs_bloom = 5; {::_pbi::TcParser::FastMtS1, {42, 5, 4, PROTOBUF_FIELD_OFFSET(Header, _impl_.logs_bloom_)}}, // .types.H256 prev_randao = 6; {::_pbi::TcParser::FastMtS1, {50, 6, 5, PROTOBUF_FIELD_OFFSET(Header, _impl_.prev_randao_)}}, // uint64 block_number = 7; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Header, _impl_.block_number_), 63>(), {56, 63, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.block_number_)}}, // uint64 gas_limit = 8; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Header, _impl_.gas_limit_), 63>(), {64, 63, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.gas_limit_)}}, // uint64 gas_used = 9; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Header, _impl_.gas_used_), 63>(), {72, 63, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.gas_used_)}}, // uint64 timestamp = 10; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Header, _impl_.timestamp_), 63>(), {80, 63, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.timestamp_)}}, // uint64 nonce = 11; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Header, _impl_.nonce_), 63>(), {88, 63, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.nonce_)}}, // bytes extra_data = 12; {::_pbi::TcParser::FastBS1, {98, 63, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.extra_data_)}}, // .types.H256 difficulty = 13; {::_pbi::TcParser::FastMtS1, {106, 7, 6, PROTOBUF_FIELD_OFFSET(Header, _impl_.difficulty_)}}, // .types.H256 block_hash = 14; {::_pbi::TcParser::FastMtS1, {114, 8, 7, PROTOBUF_FIELD_OFFSET(Header, _impl_.block_hash_)}}, // .types.H256 ommer_hash = 15; {::_pbi::TcParser::FastMtS1, {122, 9, 8, PROTOBUF_FIELD_OFFSET(Header, _impl_.ommer_hash_)}}, // .types.H256 transaction_hash = 16; {::_pbi::TcParser::FastMtS2, {386, 10, 9, PROTOBUF_FIELD_OFFSET(Header, _impl_.transaction_hash_)}}, // optional .types.H256 base_fee_per_gas = 17; {::_pbi::TcParser::FastMtS2, {394, 11, 10, PROTOBUF_FIELD_OFFSET(Header, _impl_.base_fee_per_gas_)}}, // optional .types.H256 withdrawal_hash = 18; {::_pbi::TcParser::FastMtS2, {402, 12, 11, PROTOBUF_FIELD_OFFSET(Header, _impl_.withdrawal_hash_)}}, // optional uint64 blob_gas_used = 19; {::_pbi::TcParser::FastV64S2, {408, 15, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.blob_gas_used_)}}, // optional uint64 excess_blob_gas = 20; {::_pbi::TcParser::FastV64S2, {416, 16, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.excess_blob_gas_)}}, // optional .types.H256 parent_beacon_block_root = 21; {::_pbi::TcParser::FastMtS2, {426, 13, 12, PROTOBUF_FIELD_OFFSET(Header, _impl_.parent_beacon_block_root_)}}, // optional .types.H256 requests_hash = 22; {::_pbi::TcParser::FastMtS2, {434, 14, 13, PROTOBUF_FIELD_OFFSET(Header, _impl_.requests_hash_)}}, // optional uint64 aura_step = 23; {::_pbi::TcParser::FastV64S2, {440, 17, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.aura_step_)}}, // optional bytes aura_seal = 24; {::_pbi::TcParser::FastBS2, {450, 0, 0, PROTOBUF_FIELD_OFFSET(Header, _impl_.aura_seal_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 parent_hash = 1; {PROTOBUF_FIELD_OFFSET(Header, _impl_.parent_hash_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H160 coinbase = 2; {PROTOBUF_FIELD_OFFSET(Header, _impl_.coinbase_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 state_root = 3; {PROTOBUF_FIELD_OFFSET(Header, _impl_.state_root_), _Internal::kHasBitsOffset + 3, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 receipt_root = 4; {PROTOBUF_FIELD_OFFSET(Header, _impl_.receipt_root_), _Internal::kHasBitsOffset + 4, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H2048 logs_bloom = 5; {PROTOBUF_FIELD_OFFSET(Header, _impl_.logs_bloom_), _Internal::kHasBitsOffset + 5, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 prev_randao = 6; {PROTOBUF_FIELD_OFFSET(Header, _impl_.prev_randao_), _Internal::kHasBitsOffset + 6, 5, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 block_number = 7; {PROTOBUF_FIELD_OFFSET(Header, _impl_.block_number_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 gas_limit = 8; {PROTOBUF_FIELD_OFFSET(Header, _impl_.gas_limit_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 gas_used = 9; {PROTOBUF_FIELD_OFFSET(Header, _impl_.gas_used_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 timestamp = 10; {PROTOBUF_FIELD_OFFSET(Header, _impl_.timestamp_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 nonce = 11; {PROTOBUF_FIELD_OFFSET(Header, _impl_.nonce_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bytes extra_data = 12; {PROTOBUF_FIELD_OFFSET(Header, _impl_.extra_data_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // .types.H256 difficulty = 13; {PROTOBUF_FIELD_OFFSET(Header, _impl_.difficulty_), _Internal::kHasBitsOffset + 7, 6, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 block_hash = 14; {PROTOBUF_FIELD_OFFSET(Header, _impl_.block_hash_), _Internal::kHasBitsOffset + 8, 7, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 ommer_hash = 15; {PROTOBUF_FIELD_OFFSET(Header, _impl_.ommer_hash_), _Internal::kHasBitsOffset + 9, 8, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 transaction_hash = 16; {PROTOBUF_FIELD_OFFSET(Header, _impl_.transaction_hash_), _Internal::kHasBitsOffset + 10, 9, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // optional .types.H256 base_fee_per_gas = 17; {PROTOBUF_FIELD_OFFSET(Header, _impl_.base_fee_per_gas_), _Internal::kHasBitsOffset + 11, 10, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // optional .types.H256 withdrawal_hash = 18; {PROTOBUF_FIELD_OFFSET(Header, _impl_.withdrawal_hash_), _Internal::kHasBitsOffset + 12, 11, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // optional uint64 blob_gas_used = 19; {PROTOBUF_FIELD_OFFSET(Header, _impl_.blob_gas_used_), _Internal::kHasBitsOffset + 15, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // optional uint64 excess_blob_gas = 20; {PROTOBUF_FIELD_OFFSET(Header, _impl_.excess_blob_gas_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // optional .types.H256 parent_beacon_block_root = 21; {PROTOBUF_FIELD_OFFSET(Header, _impl_.parent_beacon_block_root_), _Internal::kHasBitsOffset + 13, 12, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // optional .types.H256 requests_hash = 22; {PROTOBUF_FIELD_OFFSET(Header, _impl_.requests_hash_), _Internal::kHasBitsOffset + 14, 13, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // optional uint64 aura_step = 23; {PROTOBUF_FIELD_OFFSET(Header, _impl_.aura_step_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // optional bytes aura_seal = 24; {PROTOBUF_FIELD_OFFSET(Header, _impl_.aura_seal_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H160>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H2048>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void Header::Clear() { // @@protoc_insertion_point(message_clear_start:execution.Header) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.extra_data_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _impl_.aura_seal_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.parent_hash_ != nullptr); _impl_.parent_hash_->Clear(); } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(_impl_.coinbase_ != nullptr); _impl_.coinbase_->Clear(); } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(_impl_.state_root_ != nullptr); _impl_.state_root_->Clear(); } if (cached_has_bits & 0x00000010u) { ABSL_DCHECK(_impl_.receipt_root_ != nullptr); _impl_.receipt_root_->Clear(); } if (cached_has_bits & 0x00000020u) { ABSL_DCHECK(_impl_.logs_bloom_ != nullptr); _impl_.logs_bloom_->Clear(); } if (cached_has_bits & 0x00000040u) { ABSL_DCHECK(_impl_.prev_randao_ != nullptr); _impl_.prev_randao_->Clear(); } if (cached_has_bits & 0x00000080u) { ABSL_DCHECK(_impl_.difficulty_ != nullptr); _impl_.difficulty_->Clear(); } } if (cached_has_bits & 0x00007f00u) { if (cached_has_bits & 0x00000100u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } if (cached_has_bits & 0x00000200u) { ABSL_DCHECK(_impl_.ommer_hash_ != nullptr); _impl_.ommer_hash_->Clear(); } if (cached_has_bits & 0x00000400u) { ABSL_DCHECK(_impl_.transaction_hash_ != nullptr); _impl_.transaction_hash_->Clear(); } if (cached_has_bits & 0x00000800u) { ABSL_DCHECK(_impl_.base_fee_per_gas_ != nullptr); _impl_.base_fee_per_gas_->Clear(); } if (cached_has_bits & 0x00001000u) { ABSL_DCHECK(_impl_.withdrawal_hash_ != nullptr); _impl_.withdrawal_hash_->Clear(); } if (cached_has_bits & 0x00002000u) { ABSL_DCHECK(_impl_.parent_beacon_block_root_ != nullptr); _impl_.parent_beacon_block_root_->Clear(); } if (cached_has_bits & 0x00004000u) { ABSL_DCHECK(_impl_.requests_hash_ != nullptr); _impl_.requests_hash_->Clear(); } } ::memset(&_impl_.block_number_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.nonce_) - reinterpret_cast(&_impl_.block_number_)) + sizeof(_impl_.nonce_)); _impl_.blob_gas_used_ = ::uint64_t{0u}; if (cached_has_bits & 0x00030000u) { ::memset(&_impl_.excess_blob_gas_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.aura_step_) - reinterpret_cast(&_impl_.excess_blob_gas_)) + sizeof(_impl_.aura_step_)); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Header::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.Header) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 parent_hash = 1; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.parent_hash_, _impl_.parent_hash_->GetCachedSize(), target, stream); } // .types.H160 coinbase = 2; if (cached_has_bits & 0x00000004u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.coinbase_, _impl_.coinbase_->GetCachedSize(), target, stream); } // .types.H256 state_root = 3; if (cached_has_bits & 0x00000008u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.state_root_, _impl_.state_root_->GetCachedSize(), target, stream); } // .types.H256 receipt_root = 4; if (cached_has_bits & 0x00000010u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, *_impl_.receipt_root_, _impl_.receipt_root_->GetCachedSize(), target, stream); } // .types.H2048 logs_bloom = 5; if (cached_has_bits & 0x00000020u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 5, *_impl_.logs_bloom_, _impl_.logs_bloom_->GetCachedSize(), target, stream); } // .types.H256 prev_randao = 6; if (cached_has_bits & 0x00000040u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 6, *_impl_.prev_randao_, _impl_.prev_randao_->GetCachedSize(), target, stream); } // uint64 block_number = 7; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 7, this->_internal_block_number(), target); } // uint64 gas_limit = 8; if (this->_internal_gas_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 8, this->_internal_gas_limit(), target); } // uint64 gas_used = 9; if (this->_internal_gas_used() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 9, this->_internal_gas_used(), target); } // uint64 timestamp = 10; if (this->_internal_timestamp() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 10, this->_internal_timestamp(), target); } // uint64 nonce = 11; if (this->_internal_nonce() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 11, this->_internal_nonce(), target); } // bytes extra_data = 12; if (!this->_internal_extra_data().empty()) { const std::string& _s = this->_internal_extra_data(); target = stream->WriteBytesMaybeAliased(12, _s, target); } // .types.H256 difficulty = 13; if (cached_has_bits & 0x00000080u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 13, *_impl_.difficulty_, _impl_.difficulty_->GetCachedSize(), target, stream); } // .types.H256 block_hash = 14; if (cached_has_bits & 0x00000100u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 14, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } // .types.H256 ommer_hash = 15; if (cached_has_bits & 0x00000200u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 15, *_impl_.ommer_hash_, _impl_.ommer_hash_->GetCachedSize(), target, stream); } // .types.H256 transaction_hash = 16; if (cached_has_bits & 0x00000400u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 16, *_impl_.transaction_hash_, _impl_.transaction_hash_->GetCachedSize(), target, stream); } // optional .types.H256 base_fee_per_gas = 17; if (cached_has_bits & 0x00000800u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 17, *_impl_.base_fee_per_gas_, _impl_.base_fee_per_gas_->GetCachedSize(), target, stream); } // optional .types.H256 withdrawal_hash = 18; if (cached_has_bits & 0x00001000u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 18, *_impl_.withdrawal_hash_, _impl_.withdrawal_hash_->GetCachedSize(), target, stream); } // optional uint64 blob_gas_used = 19; if (cached_has_bits & 0x00008000u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 19, this->_internal_blob_gas_used(), target); } // optional uint64 excess_blob_gas = 20; if (cached_has_bits & 0x00010000u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 20, this->_internal_excess_blob_gas(), target); } // optional .types.H256 parent_beacon_block_root = 21; if (cached_has_bits & 0x00002000u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 21, *_impl_.parent_beacon_block_root_, _impl_.parent_beacon_block_root_->GetCachedSize(), target, stream); } // optional .types.H256 requests_hash = 22; if (cached_has_bits & 0x00004000u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 22, *_impl_.requests_hash_, _impl_.requests_hash_->GetCachedSize(), target, stream); } // optional uint64 aura_step = 23; if (cached_has_bits & 0x00020000u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 23, this->_internal_aura_step(), target); } // optional bytes aura_seal = 24; if (cached_has_bits & 0x00000001u) { const std::string& _s = this->_internal_aura_seal(); target = stream->WriteBytesMaybeAliased(24, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.Header) return target; } ::size_t Header::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.Header) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes extra_data = 12; if (!this->_internal_extra_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_extra_data()); } cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional bytes aura_seal = 24; if (cached_has_bits & 0x00000001u) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_aura_seal()); } // .types.H256 parent_hash = 1; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.parent_hash_); } // .types.H160 coinbase = 2; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.coinbase_); } // .types.H256 state_root = 3; if (cached_has_bits & 0x00000008u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.state_root_); } // .types.H256 receipt_root = 4; if (cached_has_bits & 0x00000010u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.receipt_root_); } // .types.H2048 logs_bloom = 5; if (cached_has_bits & 0x00000020u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.logs_bloom_); } // .types.H256 prev_randao = 6; if (cached_has_bits & 0x00000040u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.prev_randao_); } // .types.H256 difficulty = 13; if (cached_has_bits & 0x00000080u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.difficulty_); } } if (cached_has_bits & 0x00007f00u) { // .types.H256 block_hash = 14; if (cached_has_bits & 0x00000100u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } // .types.H256 ommer_hash = 15; if (cached_has_bits & 0x00000200u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.ommer_hash_); } // .types.H256 transaction_hash = 16; if (cached_has_bits & 0x00000400u) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.transaction_hash_); } // optional .types.H256 base_fee_per_gas = 17; if (cached_has_bits & 0x00000800u) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.base_fee_per_gas_); } // optional .types.H256 withdrawal_hash = 18; if (cached_has_bits & 0x00001000u) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.withdrawal_hash_); } // optional .types.H256 parent_beacon_block_root = 21; if (cached_has_bits & 0x00002000u) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.parent_beacon_block_root_); } // optional .types.H256 requests_hash = 22; if (cached_has_bits & 0x00004000u) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.requests_hash_); } } // uint64 block_number = 7; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } // uint64 gas_limit = 8; if (this->_internal_gas_limit() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_gas_limit()); } // uint64 gas_used = 9; if (this->_internal_gas_used() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_gas_used()); } // uint64 timestamp = 10; if (this->_internal_timestamp() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_timestamp()); } // uint64 nonce = 11; if (this->_internal_nonce() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_nonce()); } // optional uint64 blob_gas_used = 19; if (cached_has_bits & 0x00008000u) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this->_internal_blob_gas_used()); } if (cached_has_bits & 0x00030000u) { // optional uint64 excess_blob_gas = 20; if (cached_has_bits & 0x00010000u) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this->_internal_excess_blob_gas()); } // optional uint64 aura_step = 23; if (cached_has_bits & 0x00020000u) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this->_internal_aura_step()); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Header::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.Header) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_extra_data().empty()) { _this->_internal_set_extra_data(from._internal_extra_data()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _this->_internal_set_aura_seal(from._internal_aura_seal()); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.parent_hash_ != nullptr); if (_this->_impl_.parent_hash_ == nullptr) { _this->_impl_.parent_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.parent_hash_); } else { _this->_impl_.parent_hash_->MergeFrom(*from._impl_.parent_hash_); } } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(from._impl_.coinbase_ != nullptr); if (_this->_impl_.coinbase_ == nullptr) { _this->_impl_.coinbase_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.coinbase_); } else { _this->_impl_.coinbase_->MergeFrom(*from._impl_.coinbase_); } } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(from._impl_.state_root_ != nullptr); if (_this->_impl_.state_root_ == nullptr) { _this->_impl_.state_root_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.state_root_); } else { _this->_impl_.state_root_->MergeFrom(*from._impl_.state_root_); } } if (cached_has_bits & 0x00000010u) { ABSL_DCHECK(from._impl_.receipt_root_ != nullptr); if (_this->_impl_.receipt_root_ == nullptr) { _this->_impl_.receipt_root_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.receipt_root_); } else { _this->_impl_.receipt_root_->MergeFrom(*from._impl_.receipt_root_); } } if (cached_has_bits & 0x00000020u) { ABSL_DCHECK(from._impl_.logs_bloom_ != nullptr); if (_this->_impl_.logs_bloom_ == nullptr) { _this->_impl_.logs_bloom_ = ::google::protobuf::Message::CopyConstruct<::types::H2048>(arena, *from._impl_.logs_bloom_); } else { _this->_impl_.logs_bloom_->MergeFrom(*from._impl_.logs_bloom_); } } if (cached_has_bits & 0x00000040u) { ABSL_DCHECK(from._impl_.prev_randao_ != nullptr); if (_this->_impl_.prev_randao_ == nullptr) { _this->_impl_.prev_randao_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.prev_randao_); } else { _this->_impl_.prev_randao_->MergeFrom(*from._impl_.prev_randao_); } } if (cached_has_bits & 0x00000080u) { ABSL_DCHECK(from._impl_.difficulty_ != nullptr); if (_this->_impl_.difficulty_ == nullptr) { _this->_impl_.difficulty_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.difficulty_); } else { _this->_impl_.difficulty_->MergeFrom(*from._impl_.difficulty_); } } } if (cached_has_bits & 0x00007f00u) { if (cached_has_bits & 0x00000100u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } if (cached_has_bits & 0x00000200u) { ABSL_DCHECK(from._impl_.ommer_hash_ != nullptr); if (_this->_impl_.ommer_hash_ == nullptr) { _this->_impl_.ommer_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.ommer_hash_); } else { _this->_impl_.ommer_hash_->MergeFrom(*from._impl_.ommer_hash_); } } if (cached_has_bits & 0x00000400u) { ABSL_DCHECK(from._impl_.transaction_hash_ != nullptr); if (_this->_impl_.transaction_hash_ == nullptr) { _this->_impl_.transaction_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.transaction_hash_); } else { _this->_impl_.transaction_hash_->MergeFrom(*from._impl_.transaction_hash_); } } if (cached_has_bits & 0x00000800u) { ABSL_DCHECK(from._impl_.base_fee_per_gas_ != nullptr); if (_this->_impl_.base_fee_per_gas_ == nullptr) { _this->_impl_.base_fee_per_gas_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.base_fee_per_gas_); } else { _this->_impl_.base_fee_per_gas_->MergeFrom(*from._impl_.base_fee_per_gas_); } } if (cached_has_bits & 0x00001000u) { ABSL_DCHECK(from._impl_.withdrawal_hash_ != nullptr); if (_this->_impl_.withdrawal_hash_ == nullptr) { _this->_impl_.withdrawal_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.withdrawal_hash_); } else { _this->_impl_.withdrawal_hash_->MergeFrom(*from._impl_.withdrawal_hash_); } } if (cached_has_bits & 0x00002000u) { ABSL_DCHECK(from._impl_.parent_beacon_block_root_ != nullptr); if (_this->_impl_.parent_beacon_block_root_ == nullptr) { _this->_impl_.parent_beacon_block_root_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.parent_beacon_block_root_); } else { _this->_impl_.parent_beacon_block_root_->MergeFrom(*from._impl_.parent_beacon_block_root_); } } if (cached_has_bits & 0x00004000u) { ABSL_DCHECK(from._impl_.requests_hash_ != nullptr); if (_this->_impl_.requests_hash_ == nullptr) { _this->_impl_.requests_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.requests_hash_); } else { _this->_impl_.requests_hash_->MergeFrom(*from._impl_.requests_hash_); } } } if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } if (from._internal_gas_limit() != 0) { _this->_impl_.gas_limit_ = from._impl_.gas_limit_; } if (from._internal_gas_used() != 0) { _this->_impl_.gas_used_ = from._impl_.gas_used_; } if (from._internal_timestamp() != 0) { _this->_impl_.timestamp_ = from._impl_.timestamp_; } if (from._internal_nonce() != 0) { _this->_impl_.nonce_ = from._impl_.nonce_; } if (cached_has_bits & 0x00008000u) { _this->_impl_.blob_gas_used_ = from._impl_.blob_gas_used_; } if (cached_has_bits & 0x00030000u) { if (cached_has_bits & 0x00010000u) { _this->_impl_.excess_blob_gas_ = from._impl_.excess_blob_gas_; } if (cached_has_bits & 0x00020000u) { _this->_impl_.aura_step_ = from._impl_.aura_step_; } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Header::CopyFrom(const Header& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.Header) if (&from == this) return; Clear(); MergeFrom(from); } void Header::InternalSwap(Header* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.extra_data_, &other->_impl_.extra_data_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.aura_seal_, &other->_impl_.aura_seal_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(Header, _impl_.aura_step_) + sizeof(Header::_impl_.aura_step_) - PROTOBUF_FIELD_OFFSET(Header, _impl_.parent_hash_)>( reinterpret_cast(&_impl_.parent_hash_), reinterpret_cast(&other->_impl_.parent_hash_)); } ::google::protobuf::Metadata Header::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BlockBody::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(BlockBody, _impl_._has_bits_); }; void BlockBody::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } void BlockBody::clear_withdrawals() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.withdrawals_.Clear(); } BlockBody::BlockBody(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.BlockBody) } inline PROTOBUF_NDEBUG_INLINE BlockBody::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::BlockBody& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, transactions_{visibility, arena, from.transactions_}, uncles_{visibility, arena, from.uncles_}, withdrawals_{visibility, arena, from.withdrawals_} {} BlockBody::BlockBody( ::google::protobuf::Arena* arena, const BlockBody& from) : ::google::protobuf::Message(arena) { BlockBody* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.block_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; _impl_.block_number_ = from._impl_.block_number_; // @@protoc_insertion_point(copy_constructor:execution.BlockBody) } inline PROTOBUF_NDEBUG_INLINE BlockBody::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, transactions_{visibility, arena}, uncles_{visibility, arena}, withdrawals_{visibility, arena} {} inline void BlockBody::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, block_hash_), 0, offsetof(Impl_, block_number_) - offsetof(Impl_, block_hash_) + sizeof(Impl_::block_number_)); } BlockBody::~BlockBody() { // @@protoc_insertion_point(destructor:execution.BlockBody) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BlockBody::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.block_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BlockBody::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BlockBody, _impl_._cached_size_), false, }, &BlockBody::MergeImpl, &BlockBody::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 5, 3, 0, 2> BlockBody::_table_ = { { PROTOBUF_FIELD_OFFSET(BlockBody, _impl_._has_bits_), 0, // no _extensions_ 5, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967264, // skipmap offsetof(decltype(_table_), field_entries), 5, // num_field_entries 3, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_BlockBody_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::BlockBody>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .types.H256 block_hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.block_hash_)}}, // uint64 block_number = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(BlockBody, _impl_.block_number_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.block_number_)}}, // repeated bytes transactions = 3; {::_pbi::TcParser::FastBR1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.transactions_)}}, // repeated .execution.Header uncles = 4; {::_pbi::TcParser::FastMtR1, {34, 63, 1, PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.uncles_)}}, // repeated .types.Withdrawal withdrawals = 5; {::_pbi::TcParser::FastMtR1, {42, 63, 2, PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.withdrawals_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 block_hash = 1; {PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.block_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 block_number = 2; {PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.block_number_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // repeated bytes transactions = 3; {PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.transactions_), -1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, // repeated .execution.Header uncles = 4; {PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.uncles_), -1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, // repeated .types.Withdrawal withdrawals = 5; {PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.withdrawals_), -1, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::execution::Header>()}, {::_pbi::TcParser::GetTable<::types::Withdrawal>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void BlockBody::Clear() { // @@protoc_insertion_point(message_clear_start:execution.BlockBody) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.transactions_.Clear(); _impl_.uncles_.Clear(); _impl_.withdrawals_.Clear(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } _impl_.block_number_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BlockBody::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.BlockBody) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 block_hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } // uint64 block_number = 2; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_block_number(), target); } // repeated bytes transactions = 3; for (int i = 0, n = this->_internal_transactions_size(); i < n; ++i) { const auto& s = this->_internal_transactions().Get(i); target = stream->WriteBytes(3, s, target); } // repeated .execution.Header uncles = 4; for (unsigned i = 0, n = static_cast( this->_internal_uncles_size()); i < n; i++) { const auto& repfield = this->_internal_uncles().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, repfield, repfield.GetCachedSize(), target, stream); } // repeated .types.Withdrawal withdrawals = 5; for (unsigned i = 0, n = static_cast( this->_internal_withdrawals_size()); i < n; i++) { const auto& repfield = this->_internal_withdrawals().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 5, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.BlockBody) return target; } ::size_t BlockBody::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.BlockBody) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes transactions = 3; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_transactions().size()); for (int i = 0, n = _internal_transactions().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_transactions().Get(i)); } // repeated .execution.Header uncles = 4; total_size += 1UL * this->_internal_uncles_size(); for (const auto& msg : this->_internal_uncles()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // repeated .types.Withdrawal withdrawals = 5; total_size += 1UL * this->_internal_withdrawals_size(); for (const auto& msg : this->_internal_withdrawals()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // .types.H256 block_hash = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } // uint64 block_number = 2; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BlockBody::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.BlockBody) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_transactions()->MergeFrom(from._internal_transactions()); _this->_internal_mutable_uncles()->MergeFrom( from._internal_uncles()); _this->_internal_mutable_withdrawals()->MergeFrom( from._internal_withdrawals()); cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BlockBody::CopyFrom(const BlockBody& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.BlockBody) if (&from == this) return; Clear(); MergeFrom(from); } void BlockBody::InternalSwap(BlockBody* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.transactions_.InternalSwap(&other->_impl_.transactions_); _impl_.uncles_.InternalSwap(&other->_impl_.uncles_); _impl_.withdrawals_.InternalSwap(&other->_impl_.withdrawals_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.block_number_) + sizeof(BlockBody::_impl_.block_number_) - PROTOBUF_FIELD_OFFSET(BlockBody, _impl_.block_hash_)>( reinterpret_cast(&_impl_.block_hash_), reinterpret_cast(&other->_impl_.block_hash_)); } ::google::protobuf::Metadata BlockBody::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Block::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(Block, _impl_._has_bits_); }; Block::Block(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.Block) } inline PROTOBUF_NDEBUG_INLINE Block::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::Block& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} Block::Block( ::google::protobuf::Arena* arena, const Block& from) : ::google::protobuf::Message(arena) { Block* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.header_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::execution::Header>( arena, *from._impl_.header_) : nullptr; _impl_.body_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::execution::BlockBody>( arena, *from._impl_.body_) : nullptr; // @@protoc_insertion_point(copy_constructor:execution.Block) } inline PROTOBUF_NDEBUG_INLINE Block::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void Block::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, header_), 0, offsetof(Impl_, body_) - offsetof(Impl_, header_) + sizeof(Impl_::body_)); } Block::~Block() { // @@protoc_insertion_point(destructor:execution.Block) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Block::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.header_; delete _impl_.body_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Block::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Block, _impl_._cached_size_), false, }, &Block::MergeImpl, &Block::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 2, 0, 2> Block::_table_ = { { PROTOBUF_FIELD_OFFSET(Block, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_Block_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::Block>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .execution.BlockBody body = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(Block, _impl_.body_)}}, // .execution.Header header = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(Block, _impl_.header_)}}, }}, {{ 65535, 65535 }}, {{ // .execution.Header header = 1; {PROTOBUF_FIELD_OFFSET(Block, _impl_.header_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .execution.BlockBody body = 2; {PROTOBUF_FIELD_OFFSET(Block, _impl_.body_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::execution::Header>()}, {::_pbi::TcParser::GetTable<::execution::BlockBody>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void Block::Clear() { // @@protoc_insertion_point(message_clear_start:execution.Block) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.header_ != nullptr); _impl_.header_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.body_ != nullptr); _impl_.body_->Clear(); } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Block::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.Block) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .execution.Header header = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.header_, _impl_.header_->GetCachedSize(), target, stream); } // .execution.BlockBody body = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.body_, _impl_.body_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.Block) return target; } ::size_t Block::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.Block) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { // .execution.Header header = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.header_); } // .execution.BlockBody body = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.body_); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Block::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.Block) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.header_ != nullptr); if (_this->_impl_.header_ == nullptr) { _this->_impl_.header_ = ::google::protobuf::Message::CopyConstruct<::execution::Header>(arena, *from._impl_.header_); } else { _this->_impl_.header_->MergeFrom(*from._impl_.header_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.body_ != nullptr); if (_this->_impl_.body_ == nullptr) { _this->_impl_.body_ = ::google::protobuf::Message::CopyConstruct<::execution::BlockBody>(arena, *from._impl_.body_); } else { _this->_impl_.body_->MergeFrom(*from._impl_.body_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Block::CopyFrom(const Block& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.Block) if (&from == this) return; Clear(); MergeFrom(from); } void Block::InternalSwap(Block* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(Block, _impl_.body_) + sizeof(Block::_impl_.body_) - PROTOBUF_FIELD_OFFSET(Block, _impl_.header_)>( reinterpret_cast(&_impl_.header_), reinterpret_cast(&other->_impl_.header_)); } ::google::protobuf::Metadata Block::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetHeaderResponse::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(GetHeaderResponse, _impl_._has_bits_); }; GetHeaderResponse::GetHeaderResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetHeaderResponse) } inline PROTOBUF_NDEBUG_INLINE GetHeaderResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::GetHeaderResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} GetHeaderResponse::GetHeaderResponse( ::google::protobuf::Arena* arena, const GetHeaderResponse& from) : ::google::protobuf::Message(arena) { GetHeaderResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.header_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::execution::Header>( arena, *from._impl_.header_) : nullptr; // @@protoc_insertion_point(copy_constructor:execution.GetHeaderResponse) } inline PROTOBUF_NDEBUG_INLINE GetHeaderResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetHeaderResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.header_ = {}; } GetHeaderResponse::~GetHeaderResponse() { // @@protoc_insertion_point(destructor:execution.GetHeaderResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetHeaderResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.header_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetHeaderResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetHeaderResponse, _impl_._cached_size_), false, }, &GetHeaderResponse::MergeImpl, &GetHeaderResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> GetHeaderResponse::_table_ = { { PROTOBUF_FIELD_OFFSET(GetHeaderResponse, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_GetHeaderResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetHeaderResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional .execution.Header header = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(GetHeaderResponse, _impl_.header_)}}, }}, {{ 65535, 65535 }}, {{ // optional .execution.Header header = 1; {PROTOBUF_FIELD_OFFSET(GetHeaderResponse, _impl_.header_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::execution::Header>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void GetHeaderResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetHeaderResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.header_ != nullptr); _impl_.header_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetHeaderResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetHeaderResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional .execution.Header header = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.header_, _impl_.header_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetHeaderResponse) return target; } ::size_t GetHeaderResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetHeaderResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .execution.Header header = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.header_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetHeaderResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetHeaderResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.header_ != nullptr); if (_this->_impl_.header_ == nullptr) { _this->_impl_.header_ = ::google::protobuf::Message::CopyConstruct<::execution::Header>(arena, *from._impl_.header_); } else { _this->_impl_.header_->MergeFrom(*from._impl_.header_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetHeaderResponse::CopyFrom(const GetHeaderResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetHeaderResponse) if (&from == this) return; Clear(); MergeFrom(from); } void GetHeaderResponse::InternalSwap(GetHeaderResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.header_, other->_impl_.header_); } ::google::protobuf::Metadata GetHeaderResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetTDResponse::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(GetTDResponse, _impl_._has_bits_); }; void GetTDResponse::clear_td() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.td_ != nullptr) _impl_.td_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } GetTDResponse::GetTDResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetTDResponse) } inline PROTOBUF_NDEBUG_INLINE GetTDResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::GetTDResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} GetTDResponse::GetTDResponse( ::google::protobuf::Arena* arena, const GetTDResponse& from) : ::google::protobuf::Message(arena) { GetTDResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.td_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.td_) : nullptr; // @@protoc_insertion_point(copy_constructor:execution.GetTDResponse) } inline PROTOBUF_NDEBUG_INLINE GetTDResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetTDResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.td_ = {}; } GetTDResponse::~GetTDResponse() { // @@protoc_insertion_point(destructor:execution.GetTDResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetTDResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.td_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetTDResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetTDResponse, _impl_._cached_size_), false, }, &GetTDResponse::MergeImpl, &GetTDResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> GetTDResponse::_table_ = { { PROTOBUF_FIELD_OFFSET(GetTDResponse, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_GetTDResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetTDResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional .types.H256 td = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(GetTDResponse, _impl_.td_)}}, }}, {{ 65535, 65535 }}, {{ // optional .types.H256 td = 1; {PROTOBUF_FIELD_OFFSET(GetTDResponse, _impl_.td_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void GetTDResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetTDResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.td_ != nullptr); _impl_.td_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetTDResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetTDResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional .types.H256 td = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.td_, _impl_.td_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetTDResponse) return target; } ::size_t GetTDResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetTDResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .types.H256 td = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.td_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetTDResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetTDResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.td_ != nullptr); if (_this->_impl_.td_ == nullptr) { _this->_impl_.td_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.td_); } else { _this->_impl_.td_->MergeFrom(*from._impl_.td_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetTDResponse::CopyFrom(const GetTDResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetTDResponse) if (&from == this) return; Clear(); MergeFrom(from); } void GetTDResponse::InternalSwap(GetTDResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.td_, other->_impl_.td_); } ::google::protobuf::Metadata GetTDResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetBodyResponse::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(GetBodyResponse, _impl_._has_bits_); }; GetBodyResponse::GetBodyResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetBodyResponse) } inline PROTOBUF_NDEBUG_INLINE GetBodyResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::GetBodyResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} GetBodyResponse::GetBodyResponse( ::google::protobuf::Arena* arena, const GetBodyResponse& from) : ::google::protobuf::Message(arena) { GetBodyResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.body_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::execution::BlockBody>( arena, *from._impl_.body_) : nullptr; // @@protoc_insertion_point(copy_constructor:execution.GetBodyResponse) } inline PROTOBUF_NDEBUG_INLINE GetBodyResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetBodyResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.body_ = {}; } GetBodyResponse::~GetBodyResponse() { // @@protoc_insertion_point(destructor:execution.GetBodyResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetBodyResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.body_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetBodyResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetBodyResponse, _impl_._cached_size_), false, }, &GetBodyResponse::MergeImpl, &GetBodyResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> GetBodyResponse::_table_ = { { PROTOBUF_FIELD_OFFSET(GetBodyResponse, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_GetBodyResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetBodyResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional .execution.BlockBody body = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(GetBodyResponse, _impl_.body_)}}, }}, {{ 65535, 65535 }}, {{ // optional .execution.BlockBody body = 1; {PROTOBUF_FIELD_OFFSET(GetBodyResponse, _impl_.body_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::execution::BlockBody>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void GetBodyResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetBodyResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.body_ != nullptr); _impl_.body_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetBodyResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetBodyResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional .execution.BlockBody body = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.body_, _impl_.body_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetBodyResponse) return target; } ::size_t GetBodyResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetBodyResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .execution.BlockBody body = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.body_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetBodyResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetBodyResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.body_ != nullptr); if (_this->_impl_.body_ == nullptr) { _this->_impl_.body_ = ::google::protobuf::Message::CopyConstruct<::execution::BlockBody>(arena, *from._impl_.body_); } else { _this->_impl_.body_->MergeFrom(*from._impl_.body_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetBodyResponse::CopyFrom(const GetBodyResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetBodyResponse) if (&from == this) return; Clear(); MergeFrom(from); } void GetBodyResponse::InternalSwap(GetBodyResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.body_, other->_impl_.body_); } ::google::protobuf::Metadata GetBodyResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetHeaderHashNumberResponse::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(GetHeaderHashNumberResponse, _impl_._has_bits_); }; GetHeaderHashNumberResponse::GetHeaderHashNumberResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetHeaderHashNumberResponse) } GetHeaderHashNumberResponse::GetHeaderHashNumberResponse( ::google::protobuf::Arena* arena, const GetHeaderHashNumberResponse& from) : GetHeaderHashNumberResponse(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE GetHeaderHashNumberResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetHeaderHashNumberResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.block_number_ = {}; } GetHeaderHashNumberResponse::~GetHeaderHashNumberResponse() { // @@protoc_insertion_point(destructor:execution.GetHeaderHashNumberResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetHeaderHashNumberResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetHeaderHashNumberResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetHeaderHashNumberResponse, _impl_._cached_size_), false, }, &GetHeaderHashNumberResponse::MergeImpl, &GetHeaderHashNumberResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> GetHeaderHashNumberResponse::_table_ = { { PROTOBUF_FIELD_OFFSET(GetHeaderHashNumberResponse, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_GetHeaderHashNumberResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetHeaderHashNumberResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional uint64 block_number = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(GetHeaderHashNumberResponse, _impl_.block_number_), 0>(), {8, 0, 0, PROTOBUF_FIELD_OFFSET(GetHeaderHashNumberResponse, _impl_.block_number_)}}, }}, {{ 65535, 65535 }}, {{ // optional uint64 block_number = 1; {PROTOBUF_FIELD_OFFSET(GetHeaderHashNumberResponse, _impl_.block_number_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void GetHeaderHashNumberResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetHeaderHashNumberResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.block_number_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetHeaderHashNumberResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetHeaderHashNumberResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional uint64 block_number = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_block_number(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetHeaderHashNumberResponse) return target; } ::size_t GetHeaderHashNumberResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetHeaderHashNumberResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional uint64 block_number = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetHeaderHashNumberResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetHeaderHashNumberResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { _this->_impl_.block_number_ = from._impl_.block_number_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetHeaderHashNumberResponse::CopyFrom(const GetHeaderHashNumberResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetHeaderHashNumberResponse) if (&from == this) return; Clear(); MergeFrom(from); } void GetHeaderHashNumberResponse::InternalSwap(GetHeaderHashNumberResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.block_number_, other->_impl_.block_number_); } ::google::protobuf::Metadata GetHeaderHashNumberResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetSegmentRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_._has_bits_); }; void GetSegmentRequest::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } GetSegmentRequest::GetSegmentRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetSegmentRequest) } inline PROTOBUF_NDEBUG_INLINE GetSegmentRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::GetSegmentRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} GetSegmentRequest::GetSegmentRequest( ::google::protobuf::Arena* arena, const GetSegmentRequest& from) : ::google::protobuf::Message(arena) { GetSegmentRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.block_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; _impl_.block_number_ = from._impl_.block_number_; // @@protoc_insertion_point(copy_constructor:execution.GetSegmentRequest) } inline PROTOBUF_NDEBUG_INLINE GetSegmentRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetSegmentRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, block_hash_), 0, offsetof(Impl_, block_number_) - offsetof(Impl_, block_hash_) + sizeof(Impl_::block_number_)); } GetSegmentRequest::~GetSegmentRequest() { // @@protoc_insertion_point(destructor:execution.GetSegmentRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetSegmentRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.block_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetSegmentRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_._cached_size_), false, }, &GetSegmentRequest::MergeImpl, &GetSegmentRequest::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> GetSegmentRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_GetSegmentRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetSegmentRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional .types.H256 block_hash = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_.block_hash_)}}, // optional uint64 block_number = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(GetSegmentRequest, _impl_.block_number_), 1>(), {8, 1, 0, PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_.block_number_)}}, }}, {{ 65535, 65535 }}, {{ // optional uint64 block_number = 1; {PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_.block_number_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // optional .types.H256 block_hash = 2; {PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_.block_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void GetSegmentRequest::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetSegmentRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } _impl_.block_number_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetSegmentRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetSegmentRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional uint64 block_number = 1; if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_block_number(), target); } // optional .types.H256 block_hash = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetSegmentRequest) return target; } ::size_t GetSegmentRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetSegmentRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { // optional .types.H256 block_hash = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } // optional uint64 block_number = 1; if (cached_has_bits & 0x00000002u) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetSegmentRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetSegmentRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } if (cached_has_bits & 0x00000002u) { _this->_impl_.block_number_ = from._impl_.block_number_; } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetSegmentRequest::CopyFrom(const GetSegmentRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetSegmentRequest) if (&from == this) return; Clear(); MergeFrom(from); } void GetSegmentRequest::InternalSwap(GetSegmentRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_.block_number_) + sizeof(GetSegmentRequest::_impl_.block_number_) - PROTOBUF_FIELD_OFFSET(GetSegmentRequest, _impl_.block_hash_)>( reinterpret_cast(&_impl_.block_hash_), reinterpret_cast(&other->_impl_.block_hash_)); } ::google::protobuf::Metadata GetSegmentRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class InsertBlocksRequest::_Internal { public: }; InsertBlocksRequest::InsertBlocksRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.InsertBlocksRequest) } inline PROTOBUF_NDEBUG_INLINE InsertBlocksRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::InsertBlocksRequest& from_msg) : blocks_{visibility, arena, from.blocks_}, _cached_size_{0} {} InsertBlocksRequest::InsertBlocksRequest( ::google::protobuf::Arena* arena, const InsertBlocksRequest& from) : ::google::protobuf::Message(arena) { InsertBlocksRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:execution.InsertBlocksRequest) } inline PROTOBUF_NDEBUG_INLINE InsertBlocksRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : blocks_{visibility, arena}, _cached_size_{0} {} inline void InsertBlocksRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } InsertBlocksRequest::~InsertBlocksRequest() { // @@protoc_insertion_point(destructor:execution.InsertBlocksRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void InsertBlocksRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* InsertBlocksRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(InsertBlocksRequest, _impl_._cached_size_), false, }, &InsertBlocksRequest::MergeImpl, &InsertBlocksRequest::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> InsertBlocksRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_InsertBlocksRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::InsertBlocksRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .execution.Block blocks = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(InsertBlocksRequest, _impl_.blocks_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .execution.Block blocks = 1; {PROTOBUF_FIELD_OFFSET(InsertBlocksRequest, _impl_.blocks_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::execution::Block>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void InsertBlocksRequest::Clear() { // @@protoc_insertion_point(message_clear_start:execution.InsertBlocksRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.blocks_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* InsertBlocksRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.InsertBlocksRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .execution.Block blocks = 1; for (unsigned i = 0, n = static_cast( this->_internal_blocks_size()); i < n; i++) { const auto& repfield = this->_internal_blocks().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.InsertBlocksRequest) return target; } ::size_t InsertBlocksRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.InsertBlocksRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .execution.Block blocks = 1; total_size += 1UL * this->_internal_blocks_size(); for (const auto& msg : this->_internal_blocks()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void InsertBlocksRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.InsertBlocksRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_blocks()->MergeFrom( from._internal_blocks()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void InsertBlocksRequest::CopyFrom(const InsertBlocksRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.InsertBlocksRequest) if (&from == this) return; Clear(); MergeFrom(from); } void InsertBlocksRequest::InternalSwap(InsertBlocksRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.blocks_.InternalSwap(&other->_impl_.blocks_); } ::google::protobuf::Metadata InsertBlocksRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ForkChoice::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_._has_bits_); }; void ForkChoice::clear_head_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.head_block_hash_ != nullptr) _impl_.head_block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } void ForkChoice::clear_finalized_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.finalized_block_hash_ != nullptr) _impl_.finalized_block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } void ForkChoice::clear_safe_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.safe_block_hash_ != nullptr) _impl_.safe_block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000004u; } ForkChoice::ForkChoice(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.ForkChoice) } inline PROTOBUF_NDEBUG_INLINE ForkChoice::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::ForkChoice& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} ForkChoice::ForkChoice( ::google::protobuf::Arena* arena, const ForkChoice& from) : ::google::protobuf::Message(arena) { ForkChoice* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.head_block_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.head_block_hash_) : nullptr; _impl_.finalized_block_hash_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.finalized_block_hash_) : nullptr; _impl_.safe_block_hash_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.safe_block_hash_) : nullptr; _impl_.timeout_ = from._impl_.timeout_; // @@protoc_insertion_point(copy_constructor:execution.ForkChoice) } inline PROTOBUF_NDEBUG_INLINE ForkChoice::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void ForkChoice::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, head_block_hash_), 0, offsetof(Impl_, timeout_) - offsetof(Impl_, head_block_hash_) + sizeof(Impl_::timeout_)); } ForkChoice::~ForkChoice() { // @@protoc_insertion_point(destructor:execution.ForkChoice) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ForkChoice::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.head_block_hash_; delete _impl_.finalized_block_hash_; delete _impl_.safe_block_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ForkChoice::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_._cached_size_), false, }, &ForkChoice::MergeImpl, &ForkChoice::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 4, 3, 0, 2> ForkChoice::_table_ = { { PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_._has_bits_), 0, // no _extensions_ 4, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967280, // skipmap offsetof(decltype(_table_), field_entries), 4, // num_field_entries 3, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_ForkChoice_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::ForkChoice>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional .types.H256 safe_block_hash = 4; {::_pbi::TcParser::FastMtS1, {34, 2, 2, PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.safe_block_hash_)}}, // .types.H256 head_block_hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.head_block_hash_)}}, // uint64 timeout = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ForkChoice, _impl_.timeout_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.timeout_)}}, // optional .types.H256 finalized_block_hash = 3; {::_pbi::TcParser::FastMtS1, {26, 1, 1, PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.finalized_block_hash_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 head_block_hash = 1; {PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.head_block_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 timeout = 2; {PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.timeout_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // optional .types.H256 finalized_block_hash = 3; {PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.finalized_block_hash_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // optional .types.H256 safe_block_hash = 4; {PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.safe_block_hash_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void ForkChoice::Clear() { // @@protoc_insertion_point(message_clear_start:execution.ForkChoice) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.head_block_hash_ != nullptr); _impl_.head_block_hash_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.finalized_block_hash_ != nullptr); _impl_.finalized_block_hash_->Clear(); } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(_impl_.safe_block_hash_ != nullptr); _impl_.safe_block_hash_->Clear(); } } _impl_.timeout_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ForkChoice::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.ForkChoice) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 head_block_hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.head_block_hash_, _impl_.head_block_hash_->GetCachedSize(), target, stream); } // uint64 timeout = 2; if (this->_internal_timeout() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_timeout(), target); } // optional .types.H256 finalized_block_hash = 3; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.finalized_block_hash_, _impl_.finalized_block_hash_->GetCachedSize(), target, stream); } // optional .types.H256 safe_block_hash = 4; if (cached_has_bits & 0x00000004u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, *_impl_.safe_block_hash_, _impl_.safe_block_hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.ForkChoice) return target; } ::size_t ForkChoice::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.ForkChoice) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { // .types.H256 head_block_hash = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.head_block_hash_); } // optional .types.H256 finalized_block_hash = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.finalized_block_hash_); } // optional .types.H256 safe_block_hash = 4; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.safe_block_hash_); } } // uint64 timeout = 2; if (this->_internal_timeout() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_timeout()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ForkChoice::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.ForkChoice) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.head_block_hash_ != nullptr); if (_this->_impl_.head_block_hash_ == nullptr) { _this->_impl_.head_block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.head_block_hash_); } else { _this->_impl_.head_block_hash_->MergeFrom(*from._impl_.head_block_hash_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.finalized_block_hash_ != nullptr); if (_this->_impl_.finalized_block_hash_ == nullptr) { _this->_impl_.finalized_block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.finalized_block_hash_); } else { _this->_impl_.finalized_block_hash_->MergeFrom(*from._impl_.finalized_block_hash_); } } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(from._impl_.safe_block_hash_ != nullptr); if (_this->_impl_.safe_block_hash_ == nullptr) { _this->_impl_.safe_block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.safe_block_hash_); } else { _this->_impl_.safe_block_hash_->MergeFrom(*from._impl_.safe_block_hash_); } } } if (from._internal_timeout() != 0) { _this->_impl_.timeout_ = from._impl_.timeout_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ForkChoice::CopyFrom(const ForkChoice& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.ForkChoice) if (&from == this) return; Clear(); MergeFrom(from); } void ForkChoice::InternalSwap(ForkChoice* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.timeout_) + sizeof(ForkChoice::_impl_.timeout_) - PROTOBUF_FIELD_OFFSET(ForkChoice, _impl_.head_block_hash_)>( reinterpret_cast(&_impl_.head_block_hash_), reinterpret_cast(&other->_impl_.head_block_hash_)); } ::google::protobuf::Metadata ForkChoice::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class InsertionResult::_Internal { public: }; InsertionResult::InsertionResult(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.InsertionResult) } InsertionResult::InsertionResult( ::google::protobuf::Arena* arena, const InsertionResult& from) : InsertionResult(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE InsertionResult::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void InsertionResult::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.result_ = {}; } InsertionResult::~InsertionResult() { // @@protoc_insertion_point(destructor:execution.InsertionResult) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void InsertionResult::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* InsertionResult::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(InsertionResult, _impl_._cached_size_), false, }, &InsertionResult::MergeImpl, &InsertionResult::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> InsertionResult::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_InsertionResult_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::InsertionResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .execution.ExecutionStatus result = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(InsertionResult, _impl_.result_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(InsertionResult, _impl_.result_)}}, }}, {{ 65535, 65535 }}, {{ // .execution.ExecutionStatus result = 1; {PROTOBUF_FIELD_OFFSET(InsertionResult, _impl_.result_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void InsertionResult::Clear() { // @@protoc_insertion_point(message_clear_start:execution.InsertionResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.result_ = 0; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* InsertionResult::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.InsertionResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .execution.ExecutionStatus result = 1; if (this->_internal_result() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_result(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.InsertionResult) return target; } ::size_t InsertionResult::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.InsertionResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .execution.ExecutionStatus result = 1; if (this->_internal_result() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_result()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void InsertionResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.InsertionResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_result() != 0) { _this->_impl_.result_ = from._impl_.result_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void InsertionResult::CopyFrom(const InsertionResult& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.InsertionResult) if (&from == this) return; Clear(); MergeFrom(from); } void InsertionResult::InternalSwap(InsertionResult* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.result_, other->_impl_.result_); } ::google::protobuf::Metadata InsertionResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ValidationRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_._has_bits_); }; void ValidationRequest::clear_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hash_ != nullptr) _impl_.hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } ValidationRequest::ValidationRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.ValidationRequest) } inline PROTOBUF_NDEBUG_INLINE ValidationRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::ValidationRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} ValidationRequest::ValidationRequest( ::google::protobuf::Arena* arena, const ValidationRequest& from) : ::google::protobuf::Message(arena) { ValidationRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.hash_) : nullptr; _impl_.number_ = from._impl_.number_; // @@protoc_insertion_point(copy_constructor:execution.ValidationRequest) } inline PROTOBUF_NDEBUG_INLINE ValidationRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void ValidationRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, hash_), 0, offsetof(Impl_, number_) - offsetof(Impl_, hash_) + sizeof(Impl_::number_)); } ValidationRequest::~ValidationRequest() { // @@protoc_insertion_point(destructor:execution.ValidationRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ValidationRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ValidationRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_._cached_size_), false, }, &ValidationRequest::MergeImpl, &ValidationRequest::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> ValidationRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_ValidationRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::ValidationRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 number = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ValidationRequest, _impl_.number_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_.number_)}}, // .types.H256 hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_.hash_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 hash = 1; {PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_.hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 number = 2; {PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_.number_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void ValidationRequest::Clear() { // @@protoc_insertion_point(message_clear_start:execution.ValidationRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hash_ != nullptr); _impl_.hash_->Clear(); } _impl_.number_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ValidationRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.ValidationRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hash_, _impl_.hash_->GetCachedSize(), target, stream); } // uint64 number = 2; if (this->_internal_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_number(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.ValidationRequest) return target; } ::size_t ValidationRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.ValidationRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H256 hash = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hash_); } // uint64 number = 2; if (this->_internal_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ValidationRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.ValidationRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hash_ != nullptr); if (_this->_impl_.hash_ == nullptr) { _this->_impl_.hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.hash_); } else { _this->_impl_.hash_->MergeFrom(*from._impl_.hash_); } } if (from._internal_number() != 0) { _this->_impl_.number_ = from._impl_.number_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ValidationRequest::CopyFrom(const ValidationRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.ValidationRequest) if (&from == this) return; Clear(); MergeFrom(from); } void ValidationRequest::InternalSwap(ValidationRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_.number_) + sizeof(ValidationRequest::_impl_.number_) - PROTOBUF_FIELD_OFFSET(ValidationRequest, _impl_.hash_)>( reinterpret_cast(&_impl_.hash_), reinterpret_cast(&other->_impl_.hash_)); } ::google::protobuf::Metadata ValidationRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AssembleBlockRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_._has_bits_); }; void AssembleBlockRequest::clear_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_hash_ != nullptr) _impl_.parent_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } void AssembleBlockRequest::clear_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.prev_randao_ != nullptr) _impl_.prev_randao_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } void AssembleBlockRequest::clear_suggested_fee_recipient() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.suggested_fee_recipient_ != nullptr) _impl_.suggested_fee_recipient_->Clear(); _impl_._has_bits_[0] &= ~0x00000004u; } void AssembleBlockRequest::clear_withdrawals() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.withdrawals_.Clear(); } void AssembleBlockRequest::clear_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_beacon_block_root_ != nullptr) _impl_.parent_beacon_block_root_->Clear(); _impl_._has_bits_[0] &= ~0x00000008u; } AssembleBlockRequest::AssembleBlockRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.AssembleBlockRequest) } inline PROTOBUF_NDEBUG_INLINE AssembleBlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::AssembleBlockRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, withdrawals_{visibility, arena, from.withdrawals_} {} AssembleBlockRequest::AssembleBlockRequest( ::google::protobuf::Arena* arena, const AssembleBlockRequest& from) : ::google::protobuf::Message(arena) { AssembleBlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.parent_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.parent_hash_) : nullptr; _impl_.prev_randao_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.prev_randao_) : nullptr; _impl_.suggested_fee_recipient_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.suggested_fee_recipient_) : nullptr; _impl_.parent_beacon_block_root_ = (cached_has_bits & 0x00000008u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.parent_beacon_block_root_) : nullptr; _impl_.timestamp_ = from._impl_.timestamp_; // @@protoc_insertion_point(copy_constructor:execution.AssembleBlockRequest) } inline PROTOBUF_NDEBUG_INLINE AssembleBlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, withdrawals_{visibility, arena} {} inline void AssembleBlockRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, parent_hash_), 0, offsetof(Impl_, timestamp_) - offsetof(Impl_, parent_hash_) + sizeof(Impl_::timestamp_)); } AssembleBlockRequest::~AssembleBlockRequest() { // @@protoc_insertion_point(destructor:execution.AssembleBlockRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AssembleBlockRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.parent_hash_; delete _impl_.prev_randao_; delete _impl_.suggested_fee_recipient_; delete _impl_.parent_beacon_block_root_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AssembleBlockRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_._cached_size_), false, }, &AssembleBlockRequest::MergeImpl, &AssembleBlockRequest::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 6, 5, 0, 2> AssembleBlockRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_._has_bits_), 0, // no _extensions_ 6, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967232, // skipmap offsetof(decltype(_table_), field_entries), 6, // num_field_entries 5, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_AssembleBlockRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::AssembleBlockRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .types.H256 parent_hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.parent_hash_)}}, // uint64 timestamp = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(AssembleBlockRequest, _impl_.timestamp_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.timestamp_)}}, // .types.H256 prev_randao = 3; {::_pbi::TcParser::FastMtS1, {26, 1, 1, PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.prev_randao_)}}, // .types.H160 suggested_fee_recipient = 4; {::_pbi::TcParser::FastMtS1, {34, 2, 2, PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.suggested_fee_recipient_)}}, // repeated .types.Withdrawal withdrawals = 5; {::_pbi::TcParser::FastMtR1, {42, 63, 3, PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.withdrawals_)}}, // optional .types.H256 parent_beacon_block_root = 6; {::_pbi::TcParser::FastMtS1, {50, 3, 4, PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.parent_beacon_block_root_)}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 parent_hash = 1; {PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.parent_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 timestamp = 2; {PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.timestamp_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .types.H256 prev_randao = 3; {PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.prev_randao_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H160 suggested_fee_recipient = 4; {PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.suggested_fee_recipient_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // repeated .types.Withdrawal withdrawals = 5; {PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.withdrawals_), -1, 3, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, // optional .types.H256 parent_beacon_block_root = 6; {PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.parent_beacon_block_root_), _Internal::kHasBitsOffset + 3, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H160>()}, {::_pbi::TcParser::GetTable<::types::Withdrawal>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void AssembleBlockRequest::Clear() { // @@protoc_insertion_point(message_clear_start:execution.AssembleBlockRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.withdrawals_.Clear(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.parent_hash_ != nullptr); _impl_.parent_hash_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.prev_randao_ != nullptr); _impl_.prev_randao_->Clear(); } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(_impl_.suggested_fee_recipient_ != nullptr); _impl_.suggested_fee_recipient_->Clear(); } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(_impl_.parent_beacon_block_root_ != nullptr); _impl_.parent_beacon_block_root_->Clear(); } } _impl_.timestamp_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AssembleBlockRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.AssembleBlockRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 parent_hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.parent_hash_, _impl_.parent_hash_->GetCachedSize(), target, stream); } // uint64 timestamp = 2; if (this->_internal_timestamp() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_timestamp(), target); } // .types.H256 prev_randao = 3; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.prev_randao_, _impl_.prev_randao_->GetCachedSize(), target, stream); } // .types.H160 suggested_fee_recipient = 4; if (cached_has_bits & 0x00000004u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, *_impl_.suggested_fee_recipient_, _impl_.suggested_fee_recipient_->GetCachedSize(), target, stream); } // repeated .types.Withdrawal withdrawals = 5; for (unsigned i = 0, n = static_cast( this->_internal_withdrawals_size()); i < n; i++) { const auto& repfield = this->_internal_withdrawals().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 5, repfield, repfield.GetCachedSize(), target, stream); } // optional .types.H256 parent_beacon_block_root = 6; if (cached_has_bits & 0x00000008u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 6, *_impl_.parent_beacon_block_root_, _impl_.parent_beacon_block_root_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.AssembleBlockRequest) return target; } ::size_t AssembleBlockRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.AssembleBlockRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.Withdrawal withdrawals = 5; total_size += 1UL * this->_internal_withdrawals_size(); for (const auto& msg : this->_internal_withdrawals()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // .types.H256 parent_hash = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.parent_hash_); } // .types.H256 prev_randao = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.prev_randao_); } // .types.H160 suggested_fee_recipient = 4; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.suggested_fee_recipient_); } // optional .types.H256 parent_beacon_block_root = 6; if (cached_has_bits & 0x00000008u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.parent_beacon_block_root_); } } // uint64 timestamp = 2; if (this->_internal_timestamp() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_timestamp()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AssembleBlockRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.AssembleBlockRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_withdrawals()->MergeFrom( from._internal_withdrawals()); cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.parent_hash_ != nullptr); if (_this->_impl_.parent_hash_ == nullptr) { _this->_impl_.parent_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.parent_hash_); } else { _this->_impl_.parent_hash_->MergeFrom(*from._impl_.parent_hash_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.prev_randao_ != nullptr); if (_this->_impl_.prev_randao_ == nullptr) { _this->_impl_.prev_randao_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.prev_randao_); } else { _this->_impl_.prev_randao_->MergeFrom(*from._impl_.prev_randao_); } } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(from._impl_.suggested_fee_recipient_ != nullptr); if (_this->_impl_.suggested_fee_recipient_ == nullptr) { _this->_impl_.suggested_fee_recipient_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.suggested_fee_recipient_); } else { _this->_impl_.suggested_fee_recipient_->MergeFrom(*from._impl_.suggested_fee_recipient_); } } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(from._impl_.parent_beacon_block_root_ != nullptr); if (_this->_impl_.parent_beacon_block_root_ == nullptr) { _this->_impl_.parent_beacon_block_root_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.parent_beacon_block_root_); } else { _this->_impl_.parent_beacon_block_root_->MergeFrom(*from._impl_.parent_beacon_block_root_); } } } if (from._internal_timestamp() != 0) { _this->_impl_.timestamp_ = from._impl_.timestamp_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AssembleBlockRequest::CopyFrom(const AssembleBlockRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.AssembleBlockRequest) if (&from == this) return; Clear(); MergeFrom(from); } void AssembleBlockRequest::InternalSwap(AssembleBlockRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.withdrawals_.InternalSwap(&other->_impl_.withdrawals_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.timestamp_) + sizeof(AssembleBlockRequest::_impl_.timestamp_) - PROTOBUF_FIELD_OFFSET(AssembleBlockRequest, _impl_.parent_hash_)>( reinterpret_cast(&_impl_.parent_hash_), reinterpret_cast(&other->_impl_.parent_hash_)); } ::google::protobuf::Metadata AssembleBlockRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AssembleBlockResponse::_Internal { public: }; AssembleBlockResponse::AssembleBlockResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.AssembleBlockResponse) } AssembleBlockResponse::AssembleBlockResponse( ::google::protobuf::Arena* arena, const AssembleBlockResponse& from) : AssembleBlockResponse(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE AssembleBlockResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void AssembleBlockResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, id_), 0, offsetof(Impl_, busy_) - offsetof(Impl_, id_) + sizeof(Impl_::busy_)); } AssembleBlockResponse::~AssembleBlockResponse() { // @@protoc_insertion_point(destructor:execution.AssembleBlockResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AssembleBlockResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AssembleBlockResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AssembleBlockResponse, _impl_._cached_size_), false, }, &AssembleBlockResponse::MergeImpl, &AssembleBlockResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> AssembleBlockResponse::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AssembleBlockResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::AssembleBlockResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool busy = 2; {::_pbi::TcParser::SingularVarintNoZag1(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(AssembleBlockResponse, _impl_.busy_)}}, // uint64 id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(AssembleBlockResponse, _impl_.id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(AssembleBlockResponse, _impl_.id_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 id = 1; {PROTOBUF_FIELD_OFFSET(AssembleBlockResponse, _impl_.id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bool busy = 2; {PROTOBUF_FIELD_OFFSET(AssembleBlockResponse, _impl_.busy_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void AssembleBlockResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.AssembleBlockResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.busy_) - reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.busy_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AssembleBlockResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.AssembleBlockResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_id(), target); } // bool busy = 2; if (this->_internal_busy() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 2, this->_internal_busy(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.AssembleBlockResponse) return target; } ::size_t AssembleBlockResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.AssembleBlockResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 id = 1; if (this->_internal_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_id()); } // bool busy = 2; if (this->_internal_busy() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AssembleBlockResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.AssembleBlockResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_id() != 0) { _this->_impl_.id_ = from._impl_.id_; } if (from._internal_busy() != 0) { _this->_impl_.busy_ = from._impl_.busy_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AssembleBlockResponse::CopyFrom(const AssembleBlockResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.AssembleBlockResponse) if (&from == this) return; Clear(); MergeFrom(from); } void AssembleBlockResponse::InternalSwap(AssembleBlockResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(AssembleBlockResponse, _impl_.busy_) + sizeof(AssembleBlockResponse::_impl_.busy_) - PROTOBUF_FIELD_OFFSET(AssembleBlockResponse, _impl_.id_)>( reinterpret_cast(&_impl_.id_), reinterpret_cast(&other->_impl_.id_)); } ::google::protobuf::Metadata AssembleBlockResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetAssembledBlockRequest::_Internal { public: }; GetAssembledBlockRequest::GetAssembledBlockRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetAssembledBlockRequest) } GetAssembledBlockRequest::GetAssembledBlockRequest( ::google::protobuf::Arena* arena, const GetAssembledBlockRequest& from) : GetAssembledBlockRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE GetAssembledBlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetAssembledBlockRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.id_ = {}; } GetAssembledBlockRequest::~GetAssembledBlockRequest() { // @@protoc_insertion_point(destructor:execution.GetAssembledBlockRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetAssembledBlockRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetAssembledBlockRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetAssembledBlockRequest, _impl_._cached_size_), false, }, &GetAssembledBlockRequest::MergeImpl, &GetAssembledBlockRequest::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> GetAssembledBlockRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_GetAssembledBlockRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetAssembledBlockRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(GetAssembledBlockRequest, _impl_.id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(GetAssembledBlockRequest, _impl_.id_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 id = 1; {PROTOBUF_FIELD_OFFSET(GetAssembledBlockRequest, _impl_.id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void GetAssembledBlockRequest::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetAssembledBlockRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.id_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetAssembledBlockRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetAssembledBlockRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_id(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetAssembledBlockRequest) return target; } ::size_t GetAssembledBlockRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetAssembledBlockRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_id()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetAssembledBlockRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetAssembledBlockRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_id() != 0) { _this->_impl_.id_ = from._impl_.id_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetAssembledBlockRequest::CopyFrom(const GetAssembledBlockRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetAssembledBlockRequest) if (&from == this) return; Clear(); MergeFrom(from); } void GetAssembledBlockRequest::InternalSwap(GetAssembledBlockRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.id_, other->_impl_.id_); } ::google::protobuf::Metadata GetAssembledBlockRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AssembledBlockData::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_._has_bits_); }; void AssembledBlockData::clear_execution_payload() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.execution_payload_ != nullptr) _impl_.execution_payload_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } void AssembledBlockData::clear_block_value() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_value_ != nullptr) _impl_.block_value_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } void AssembledBlockData::clear_blobs_bundle() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.blobs_bundle_ != nullptr) _impl_.blobs_bundle_->Clear(); _impl_._has_bits_[0] &= ~0x00000004u; } void AssembledBlockData::clear_requests() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.requests_ != nullptr) _impl_.requests_->Clear(); _impl_._has_bits_[0] &= ~0x00000008u; } AssembledBlockData::AssembledBlockData(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.AssembledBlockData) } inline PROTOBUF_NDEBUG_INLINE AssembledBlockData::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::AssembledBlockData& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} AssembledBlockData::AssembledBlockData( ::google::protobuf::Arena* arena, const AssembledBlockData& from) : ::google::protobuf::Message(arena) { AssembledBlockData* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.execution_payload_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::ExecutionPayload>( arena, *from._impl_.execution_payload_) : nullptr; _impl_.block_value_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_value_) : nullptr; _impl_.blobs_bundle_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::types::BlobsBundleV1>( arena, *from._impl_.blobs_bundle_) : nullptr; _impl_.requests_ = (cached_has_bits & 0x00000008u) ? ::google::protobuf::Message::CopyConstruct<::types::RequestsBundle>( arena, *from._impl_.requests_) : nullptr; // @@protoc_insertion_point(copy_constructor:execution.AssembledBlockData) } inline PROTOBUF_NDEBUG_INLINE AssembledBlockData::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void AssembledBlockData::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, execution_payload_), 0, offsetof(Impl_, requests_) - offsetof(Impl_, execution_payload_) + sizeof(Impl_::requests_)); } AssembledBlockData::~AssembledBlockData() { // @@protoc_insertion_point(destructor:execution.AssembledBlockData) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AssembledBlockData::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.execution_payload_; delete _impl_.block_value_; delete _impl_.blobs_bundle_; delete _impl_.requests_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AssembledBlockData::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_._cached_size_), false, }, &AssembledBlockData::MergeImpl, &AssembledBlockData::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 4, 4, 0, 2> AssembledBlockData::_table_ = { { PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_._has_bits_), 0, // no _extensions_ 4, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967280, // skipmap offsetof(decltype(_table_), field_entries), 4, // num_field_entries 4, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_AssembledBlockData_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::AssembledBlockData>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.RequestsBundle requests = 4; {::_pbi::TcParser::FastMtS1, {34, 3, 3, PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.requests_)}}, // .types.ExecutionPayload execution_payload = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.execution_payload_)}}, // .types.H256 block_value = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.block_value_)}}, // .types.BlobsBundleV1 blobs_bundle = 3; {::_pbi::TcParser::FastMtS1, {26, 2, 2, PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.blobs_bundle_)}}, }}, {{ 65535, 65535 }}, {{ // .types.ExecutionPayload execution_payload = 1; {PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.execution_payload_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 block_value = 2; {PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.block_value_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.BlobsBundleV1 blobs_bundle = 3; {PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.blobs_bundle_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.RequestsBundle requests = 4; {PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.requests_), _Internal::kHasBitsOffset + 3, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::ExecutionPayload>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::BlobsBundleV1>()}, {::_pbi::TcParser::GetTable<::types::RequestsBundle>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void AssembledBlockData::Clear() { // @@protoc_insertion_point(message_clear_start:execution.AssembledBlockData) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.execution_payload_ != nullptr); _impl_.execution_payload_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.block_value_ != nullptr); _impl_.block_value_->Clear(); } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(_impl_.blobs_bundle_ != nullptr); _impl_.blobs_bundle_->Clear(); } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(_impl_.requests_ != nullptr); _impl_.requests_->Clear(); } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AssembledBlockData::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.AssembledBlockData) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.ExecutionPayload execution_payload = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.execution_payload_, _impl_.execution_payload_->GetCachedSize(), target, stream); } // .types.H256 block_value = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.block_value_, _impl_.block_value_->GetCachedSize(), target, stream); } // .types.BlobsBundleV1 blobs_bundle = 3; if (cached_has_bits & 0x00000004u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.blobs_bundle_, _impl_.blobs_bundle_->GetCachedSize(), target, stream); } // .types.RequestsBundle requests = 4; if (cached_has_bits & 0x00000008u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, *_impl_.requests_, _impl_.requests_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.AssembledBlockData) return target; } ::size_t AssembledBlockData::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.AssembledBlockData) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { // .types.ExecutionPayload execution_payload = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.execution_payload_); } // .types.H256 block_value = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_value_); } // .types.BlobsBundleV1 blobs_bundle = 3; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.blobs_bundle_); } // .types.RequestsBundle requests = 4; if (cached_has_bits & 0x00000008u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.requests_); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AssembledBlockData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.AssembledBlockData) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.execution_payload_ != nullptr); if (_this->_impl_.execution_payload_ == nullptr) { _this->_impl_.execution_payload_ = ::google::protobuf::Message::CopyConstruct<::types::ExecutionPayload>(arena, *from._impl_.execution_payload_); } else { _this->_impl_.execution_payload_->MergeFrom(*from._impl_.execution_payload_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.block_value_ != nullptr); if (_this->_impl_.block_value_ == nullptr) { _this->_impl_.block_value_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_value_); } else { _this->_impl_.block_value_->MergeFrom(*from._impl_.block_value_); } } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(from._impl_.blobs_bundle_ != nullptr); if (_this->_impl_.blobs_bundle_ == nullptr) { _this->_impl_.blobs_bundle_ = ::google::protobuf::Message::CopyConstruct<::types::BlobsBundleV1>(arena, *from._impl_.blobs_bundle_); } else { _this->_impl_.blobs_bundle_->MergeFrom(*from._impl_.blobs_bundle_); } } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(from._impl_.requests_ != nullptr); if (_this->_impl_.requests_ == nullptr) { _this->_impl_.requests_ = ::google::protobuf::Message::CopyConstruct<::types::RequestsBundle>(arena, *from._impl_.requests_); } else { _this->_impl_.requests_->MergeFrom(*from._impl_.requests_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AssembledBlockData::CopyFrom(const AssembledBlockData& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.AssembledBlockData) if (&from == this) return; Clear(); MergeFrom(from); } void AssembledBlockData::InternalSwap(AssembledBlockData* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.requests_) + sizeof(AssembledBlockData::_impl_.requests_) - PROTOBUF_FIELD_OFFSET(AssembledBlockData, _impl_.execution_payload_)>( reinterpret_cast(&_impl_.execution_payload_), reinterpret_cast(&other->_impl_.execution_payload_)); } ::google::protobuf::Metadata AssembledBlockData::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetAssembledBlockResponse::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_._has_bits_); }; GetAssembledBlockResponse::GetAssembledBlockResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetAssembledBlockResponse) } inline PROTOBUF_NDEBUG_INLINE GetAssembledBlockResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::GetAssembledBlockResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} GetAssembledBlockResponse::GetAssembledBlockResponse( ::google::protobuf::Arena* arena, const GetAssembledBlockResponse& from) : ::google::protobuf::Message(arena) { GetAssembledBlockResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.data_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::execution::AssembledBlockData>( arena, *from._impl_.data_) : nullptr; _impl_.busy_ = from._impl_.busy_; // @@protoc_insertion_point(copy_constructor:execution.GetAssembledBlockResponse) } inline PROTOBUF_NDEBUG_INLINE GetAssembledBlockResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetAssembledBlockResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, busy_) - offsetof(Impl_, data_) + sizeof(Impl_::busy_)); } GetAssembledBlockResponse::~GetAssembledBlockResponse() { // @@protoc_insertion_point(destructor:execution.GetAssembledBlockResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetAssembledBlockResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.data_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetAssembledBlockResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_._cached_size_), false, }, &GetAssembledBlockResponse::MergeImpl, &GetAssembledBlockResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> GetAssembledBlockResponse::_table_ = { { PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_GetAssembledBlockResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetAssembledBlockResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool busy = 2; {::_pbi::TcParser::SingularVarintNoZag1(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_.busy_)}}, // optional .execution.AssembledBlockData data = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_.data_)}}, }}, {{ 65535, 65535 }}, {{ // optional .execution.AssembledBlockData data = 1; {PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_.data_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bool busy = 2; {PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_.busy_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, {{ {::_pbi::TcParser::GetTable<::execution::AssembledBlockData>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void GetAssembledBlockResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetAssembledBlockResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.data_ != nullptr); _impl_.data_->Clear(); } _impl_.busy_ = false; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetAssembledBlockResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetAssembledBlockResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional .execution.AssembledBlockData data = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.data_, _impl_.data_->GetCachedSize(), target, stream); } // bool busy = 2; if (this->_internal_busy() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 2, this->_internal_busy(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetAssembledBlockResponse) return target; } ::size_t GetAssembledBlockResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetAssembledBlockResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // optional .execution.AssembledBlockData data = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.data_); } // bool busy = 2; if (this->_internal_busy() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetAssembledBlockResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetAssembledBlockResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.data_ != nullptr); if (_this->_impl_.data_ == nullptr) { _this->_impl_.data_ = ::google::protobuf::Message::CopyConstruct<::execution::AssembledBlockData>(arena, *from._impl_.data_); } else { _this->_impl_.data_->MergeFrom(*from._impl_.data_); } } if (from._internal_busy() != 0) { _this->_impl_.busy_ = from._impl_.busy_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetAssembledBlockResponse::CopyFrom(const GetAssembledBlockResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetAssembledBlockResponse) if (&from == this) return; Clear(); MergeFrom(from); } void GetAssembledBlockResponse::InternalSwap(GetAssembledBlockResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_.busy_) + sizeof(GetAssembledBlockResponse::_impl_.busy_) - PROTOBUF_FIELD_OFFSET(GetAssembledBlockResponse, _impl_.data_)>( reinterpret_cast(&_impl_.data_), reinterpret_cast(&other->_impl_.data_)); } ::google::protobuf::Metadata GetAssembledBlockResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetBodiesBatchResponse::_Internal { public: }; GetBodiesBatchResponse::GetBodiesBatchResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetBodiesBatchResponse) } inline PROTOBUF_NDEBUG_INLINE GetBodiesBatchResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::GetBodiesBatchResponse& from_msg) : bodies_{visibility, arena, from.bodies_}, _cached_size_{0} {} GetBodiesBatchResponse::GetBodiesBatchResponse( ::google::protobuf::Arena* arena, const GetBodiesBatchResponse& from) : ::google::protobuf::Message(arena) { GetBodiesBatchResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:execution.GetBodiesBatchResponse) } inline PROTOBUF_NDEBUG_INLINE GetBodiesBatchResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : bodies_{visibility, arena}, _cached_size_{0} {} inline void GetBodiesBatchResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } GetBodiesBatchResponse::~GetBodiesBatchResponse() { // @@protoc_insertion_point(destructor:execution.GetBodiesBatchResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetBodiesBatchResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetBodiesBatchResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetBodiesBatchResponse, _impl_._cached_size_), false, }, &GetBodiesBatchResponse::MergeImpl, &GetBodiesBatchResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> GetBodiesBatchResponse::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_GetBodiesBatchResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetBodiesBatchResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .execution.BlockBody bodies = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetBodiesBatchResponse, _impl_.bodies_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .execution.BlockBody bodies = 1; {PROTOBUF_FIELD_OFFSET(GetBodiesBatchResponse, _impl_.bodies_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::execution::BlockBody>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void GetBodiesBatchResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetBodiesBatchResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.bodies_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetBodiesBatchResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetBodiesBatchResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .execution.BlockBody bodies = 1; for (unsigned i = 0, n = static_cast( this->_internal_bodies_size()); i < n; i++) { const auto& repfield = this->_internal_bodies().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetBodiesBatchResponse) return target; } ::size_t GetBodiesBatchResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetBodiesBatchResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .execution.BlockBody bodies = 1; total_size += 1UL * this->_internal_bodies_size(); for (const auto& msg : this->_internal_bodies()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetBodiesBatchResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetBodiesBatchResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_bodies()->MergeFrom( from._internal_bodies()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetBodiesBatchResponse::CopyFrom(const GetBodiesBatchResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetBodiesBatchResponse) if (&from == this) return; Clear(); MergeFrom(from); } void GetBodiesBatchResponse::InternalSwap(GetBodiesBatchResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.bodies_.InternalSwap(&other->_impl_.bodies_); } ::google::protobuf::Metadata GetBodiesBatchResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetBodiesByHashesRequest::_Internal { public: }; void GetBodiesByHashesRequest::clear_hashes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hashes_.Clear(); } GetBodiesByHashesRequest::GetBodiesByHashesRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetBodiesByHashesRequest) } inline PROTOBUF_NDEBUG_INLINE GetBodiesByHashesRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::execution::GetBodiesByHashesRequest& from_msg) : hashes_{visibility, arena, from.hashes_}, _cached_size_{0} {} GetBodiesByHashesRequest::GetBodiesByHashesRequest( ::google::protobuf::Arena* arena, const GetBodiesByHashesRequest& from) : ::google::protobuf::Message(arena) { GetBodiesByHashesRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:execution.GetBodiesByHashesRequest) } inline PROTOBUF_NDEBUG_INLINE GetBodiesByHashesRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : hashes_{visibility, arena}, _cached_size_{0} {} inline void GetBodiesByHashesRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } GetBodiesByHashesRequest::~GetBodiesByHashesRequest() { // @@protoc_insertion_point(destructor:execution.GetBodiesByHashesRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetBodiesByHashesRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetBodiesByHashesRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetBodiesByHashesRequest, _impl_._cached_size_), false, }, &GetBodiesByHashesRequest::MergeImpl, &GetBodiesByHashesRequest::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> GetBodiesByHashesRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_GetBodiesByHashesRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetBodiesByHashesRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.H256 hashes = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetBodiesByHashesRequest, _impl_.hashes_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.H256 hashes = 1; {PROTOBUF_FIELD_OFFSET(GetBodiesByHashesRequest, _impl_.hashes_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void GetBodiesByHashesRequest::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetBodiesByHashesRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.hashes_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetBodiesByHashesRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetBodiesByHashesRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.H256 hashes = 1; for (unsigned i = 0, n = static_cast( this->_internal_hashes_size()); i < n; i++) { const auto& repfield = this->_internal_hashes().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetBodiesByHashesRequest) return target; } ::size_t GetBodiesByHashesRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetBodiesByHashesRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.H256 hashes = 1; total_size += 1UL * this->_internal_hashes_size(); for (const auto& msg : this->_internal_hashes()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetBodiesByHashesRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetBodiesByHashesRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_hashes()->MergeFrom( from._internal_hashes()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetBodiesByHashesRequest::CopyFrom(const GetBodiesByHashesRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetBodiesByHashesRequest) if (&from == this) return; Clear(); MergeFrom(from); } void GetBodiesByHashesRequest::InternalSwap(GetBodiesByHashesRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.hashes_.InternalSwap(&other->_impl_.hashes_); } ::google::protobuf::Metadata GetBodiesByHashesRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetBodiesByRangeRequest::_Internal { public: }; GetBodiesByRangeRequest::GetBodiesByRangeRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.GetBodiesByRangeRequest) } GetBodiesByRangeRequest::GetBodiesByRangeRequest( ::google::protobuf::Arena* arena, const GetBodiesByRangeRequest& from) : GetBodiesByRangeRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE GetBodiesByRangeRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void GetBodiesByRangeRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, start_), 0, offsetof(Impl_, count_) - offsetof(Impl_, start_) + sizeof(Impl_::count_)); } GetBodiesByRangeRequest::~GetBodiesByRangeRequest() { // @@protoc_insertion_point(destructor:execution.GetBodiesByRangeRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetBodiesByRangeRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetBodiesByRangeRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetBodiesByRangeRequest, _impl_._cached_size_), false, }, &GetBodiesByRangeRequest::MergeImpl, &GetBodiesByRangeRequest::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> GetBodiesByRangeRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_GetBodiesByRangeRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::GetBodiesByRangeRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 count = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(GetBodiesByRangeRequest, _impl_.count_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(GetBodiesByRangeRequest, _impl_.count_)}}, // uint64 start = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(GetBodiesByRangeRequest, _impl_.start_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(GetBodiesByRangeRequest, _impl_.start_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 start = 1; {PROTOBUF_FIELD_OFFSET(GetBodiesByRangeRequest, _impl_.start_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 count = 2; {PROTOBUF_FIELD_OFFSET(GetBodiesByRangeRequest, _impl_.count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void GetBodiesByRangeRequest::Clear() { // @@protoc_insertion_point(message_clear_start:execution.GetBodiesByRangeRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.start_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.count_) - reinterpret_cast(&_impl_.start_)) + sizeof(_impl_.count_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetBodiesByRangeRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.GetBodiesByRangeRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 start = 1; if (this->_internal_start() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_start(), target); } // uint64 count = 2; if (this->_internal_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_count(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.GetBodiesByRangeRequest) return target; } ::size_t GetBodiesByRangeRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.GetBodiesByRangeRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 start = 1; if (this->_internal_start() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_start()); } // uint64 count = 2; if (this->_internal_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_count()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetBodiesByRangeRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.GetBodiesByRangeRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_start() != 0) { _this->_impl_.start_ = from._impl_.start_; } if (from._internal_count() != 0) { _this->_impl_.count_ = from._impl_.count_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetBodiesByRangeRequest::CopyFrom(const GetBodiesByRangeRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.GetBodiesByRangeRequest) if (&from == this) return; Clear(); MergeFrom(from); } void GetBodiesByRangeRequest::InternalSwap(GetBodiesByRangeRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(GetBodiesByRangeRequest, _impl_.count_) + sizeof(GetBodiesByRangeRequest::_impl_.count_) - PROTOBUF_FIELD_OFFSET(GetBodiesByRangeRequest, _impl_.start_)>( reinterpret_cast(&_impl_.start_), reinterpret_cast(&other->_impl_.start_)); } ::google::protobuf::Metadata GetBodiesByRangeRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ReadyResponse::_Internal { public: }; ReadyResponse::ReadyResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.ReadyResponse) } ReadyResponse::ReadyResponse( ::google::protobuf::Arena* arena, const ReadyResponse& from) : ReadyResponse(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE ReadyResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void ReadyResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.ready_ = {}; } ReadyResponse::~ReadyResponse() { // @@protoc_insertion_point(destructor:execution.ReadyResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ReadyResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ReadyResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ReadyResponse, _impl_._cached_size_), false, }, &ReadyResponse::MergeImpl, &ReadyResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> ReadyResponse::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_ReadyResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::ReadyResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool ready = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(ReadyResponse, _impl_.ready_)}}, }}, {{ 65535, 65535 }}, {{ // bool ready = 1; {PROTOBUF_FIELD_OFFSET(ReadyResponse, _impl_.ready_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void ReadyResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.ReadyResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.ready_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ReadyResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.ReadyResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool ready = 1; if (this->_internal_ready() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_ready(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.ReadyResponse) return target; } ::size_t ReadyResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.ReadyResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool ready = 1; if (this->_internal_ready() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ReadyResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.ReadyResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_ready() != 0) { _this->_impl_.ready_ = from._impl_.ready_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ReadyResponse::CopyFrom(const ReadyResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.ReadyResponse) if (&from == this) return; Clear(); MergeFrom(from); } void ReadyResponse::InternalSwap(ReadyResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.ready_, other->_impl_.ready_); } ::google::protobuf::Metadata ReadyResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class FrozenBlocksResponse::_Internal { public: }; FrozenBlocksResponse::FrozenBlocksResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.FrozenBlocksResponse) } FrozenBlocksResponse::FrozenBlocksResponse( ::google::protobuf::Arena* arena, const FrozenBlocksResponse& from) : FrozenBlocksResponse(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE FrozenBlocksResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void FrozenBlocksResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, frozen_blocks_), 0, offsetof(Impl_, has_gap_) - offsetof(Impl_, frozen_blocks_) + sizeof(Impl_::has_gap_)); } FrozenBlocksResponse::~FrozenBlocksResponse() { // @@protoc_insertion_point(destructor:execution.FrozenBlocksResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void FrozenBlocksResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* FrozenBlocksResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(FrozenBlocksResponse, _impl_._cached_size_), false, }, &FrozenBlocksResponse::MergeImpl, &FrozenBlocksResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> FrozenBlocksResponse::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_FrozenBlocksResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::FrozenBlocksResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool has_gap = 2; {::_pbi::TcParser::SingularVarintNoZag1(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(FrozenBlocksResponse, _impl_.has_gap_)}}, // uint64 frozen_blocks = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(FrozenBlocksResponse, _impl_.frozen_blocks_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(FrozenBlocksResponse, _impl_.frozen_blocks_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 frozen_blocks = 1; {PROTOBUF_FIELD_OFFSET(FrozenBlocksResponse, _impl_.frozen_blocks_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bool has_gap = 2; {PROTOBUF_FIELD_OFFSET(FrozenBlocksResponse, _impl_.has_gap_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void FrozenBlocksResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.FrozenBlocksResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.frozen_blocks_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.has_gap_) - reinterpret_cast(&_impl_.frozen_blocks_)) + sizeof(_impl_.has_gap_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* FrozenBlocksResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.FrozenBlocksResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 frozen_blocks = 1; if (this->_internal_frozen_blocks() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_frozen_blocks(), target); } // bool has_gap = 2; if (this->_internal_has_gap() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 2, this->_internal_has_gap(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.FrozenBlocksResponse) return target; } ::size_t FrozenBlocksResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.FrozenBlocksResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 frozen_blocks = 1; if (this->_internal_frozen_blocks() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_frozen_blocks()); } // bool has_gap = 2; if (this->_internal_has_gap() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void FrozenBlocksResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.FrozenBlocksResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_frozen_blocks() != 0) { _this->_impl_.frozen_blocks_ = from._impl_.frozen_blocks_; } if (from._internal_has_gap() != 0) { _this->_impl_.has_gap_ = from._impl_.has_gap_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void FrozenBlocksResponse::CopyFrom(const FrozenBlocksResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.FrozenBlocksResponse) if (&from == this) return; Clear(); MergeFrom(from); } void FrozenBlocksResponse::InternalSwap(FrozenBlocksResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(FrozenBlocksResponse, _impl_.has_gap_) + sizeof(FrozenBlocksResponse::_impl_.has_gap_) - PROTOBUF_FIELD_OFFSET(FrozenBlocksResponse, _impl_.frozen_blocks_)>( reinterpret_cast(&_impl_.frozen_blocks_), reinterpret_cast(&other->_impl_.frozen_blocks_)); } ::google::protobuf::Metadata FrozenBlocksResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HasBlockResponse::_Internal { public: }; HasBlockResponse::HasBlockResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:execution.HasBlockResponse) } HasBlockResponse::HasBlockResponse( ::google::protobuf::Arena* arena, const HasBlockResponse& from) : HasBlockResponse(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE HasBlockResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void HasBlockResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.has_block_ = {}; } HasBlockResponse::~HasBlockResponse() { // @@protoc_insertion_point(destructor:execution.HasBlockResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HasBlockResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HasBlockResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HasBlockResponse, _impl_._cached_size_), false, }, &HasBlockResponse::MergeImpl, &HasBlockResponse::kDescriptorMethods, &descriptor_table_execution_2fexecution_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> HasBlockResponse::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HasBlockResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::execution::HasBlockResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool has_block = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(HasBlockResponse, _impl_.has_block_)}}, }}, {{ 65535, 65535 }}, {{ // bool has_block = 1; {PROTOBUF_FIELD_OFFSET(HasBlockResponse, _impl_.has_block_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void HasBlockResponse::Clear() { // @@protoc_insertion_point(message_clear_start:execution.HasBlockResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.has_block_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HasBlockResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:execution.HasBlockResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool has_block = 1; if (this->_internal_has_block() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_has_block(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:execution.HasBlockResponse) return target; } ::size_t HasBlockResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:execution.HasBlockResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool has_block = 1; if (this->_internal_has_block() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HasBlockResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:execution.HasBlockResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_has_block() != 0) { _this->_impl_.has_block_ = from._impl_.has_block_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HasBlockResponse::CopyFrom(const HasBlockResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:execution.HasBlockResponse) if (&from == this) return; Clear(); MergeFrom(from); } void HasBlockResponse::InternalSwap(HasBlockResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.has_block_, other->_impl_.has_block_); } ::google::protobuf::Metadata HasBlockResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace execution namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_execution_2fexecution_2eproto), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/execution/execution.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: execution/execution.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_execution_2fexecution_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_execution_2fexecution_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" #include "types/types.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_execution_2fexecution_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_execution_2fexecution_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_execution_2fexecution_2eproto; namespace execution { class AssembleBlockRequest; struct AssembleBlockRequestDefaultTypeInternal; extern AssembleBlockRequestDefaultTypeInternal _AssembleBlockRequest_default_instance_; class AssembleBlockResponse; struct AssembleBlockResponseDefaultTypeInternal; extern AssembleBlockResponseDefaultTypeInternal _AssembleBlockResponse_default_instance_; class AssembledBlockData; struct AssembledBlockDataDefaultTypeInternal; extern AssembledBlockDataDefaultTypeInternal _AssembledBlockData_default_instance_; class Block; struct BlockDefaultTypeInternal; extern BlockDefaultTypeInternal _Block_default_instance_; class BlockBody; struct BlockBodyDefaultTypeInternal; extern BlockBodyDefaultTypeInternal _BlockBody_default_instance_; class ForkChoice; struct ForkChoiceDefaultTypeInternal; extern ForkChoiceDefaultTypeInternal _ForkChoice_default_instance_; class ForkChoiceReceipt; struct ForkChoiceReceiptDefaultTypeInternal; extern ForkChoiceReceiptDefaultTypeInternal _ForkChoiceReceipt_default_instance_; class FrozenBlocksResponse; struct FrozenBlocksResponseDefaultTypeInternal; extern FrozenBlocksResponseDefaultTypeInternal _FrozenBlocksResponse_default_instance_; class GetAssembledBlockRequest; struct GetAssembledBlockRequestDefaultTypeInternal; extern GetAssembledBlockRequestDefaultTypeInternal _GetAssembledBlockRequest_default_instance_; class GetAssembledBlockResponse; struct GetAssembledBlockResponseDefaultTypeInternal; extern GetAssembledBlockResponseDefaultTypeInternal _GetAssembledBlockResponse_default_instance_; class GetBodiesBatchResponse; struct GetBodiesBatchResponseDefaultTypeInternal; extern GetBodiesBatchResponseDefaultTypeInternal _GetBodiesBatchResponse_default_instance_; class GetBodiesByHashesRequest; struct GetBodiesByHashesRequestDefaultTypeInternal; extern GetBodiesByHashesRequestDefaultTypeInternal _GetBodiesByHashesRequest_default_instance_; class GetBodiesByRangeRequest; struct GetBodiesByRangeRequestDefaultTypeInternal; extern GetBodiesByRangeRequestDefaultTypeInternal _GetBodiesByRangeRequest_default_instance_; class GetBodyResponse; struct GetBodyResponseDefaultTypeInternal; extern GetBodyResponseDefaultTypeInternal _GetBodyResponse_default_instance_; class GetHeaderHashNumberResponse; struct GetHeaderHashNumberResponseDefaultTypeInternal; extern GetHeaderHashNumberResponseDefaultTypeInternal _GetHeaderHashNumberResponse_default_instance_; class GetHeaderResponse; struct GetHeaderResponseDefaultTypeInternal; extern GetHeaderResponseDefaultTypeInternal _GetHeaderResponse_default_instance_; class GetSegmentRequest; struct GetSegmentRequestDefaultTypeInternal; extern GetSegmentRequestDefaultTypeInternal _GetSegmentRequest_default_instance_; class GetTDResponse; struct GetTDResponseDefaultTypeInternal; extern GetTDResponseDefaultTypeInternal _GetTDResponse_default_instance_; class HasBlockResponse; struct HasBlockResponseDefaultTypeInternal; extern HasBlockResponseDefaultTypeInternal _HasBlockResponse_default_instance_; class Header; struct HeaderDefaultTypeInternal; extern HeaderDefaultTypeInternal _Header_default_instance_; class InsertBlocksRequest; struct InsertBlocksRequestDefaultTypeInternal; extern InsertBlocksRequestDefaultTypeInternal _InsertBlocksRequest_default_instance_; class InsertionResult; struct InsertionResultDefaultTypeInternal; extern InsertionResultDefaultTypeInternal _InsertionResult_default_instance_; class IsCanonicalResponse; struct IsCanonicalResponseDefaultTypeInternal; extern IsCanonicalResponseDefaultTypeInternal _IsCanonicalResponse_default_instance_; class ReadyResponse; struct ReadyResponseDefaultTypeInternal; extern ReadyResponseDefaultTypeInternal _ReadyResponse_default_instance_; class ValidationReceipt; struct ValidationReceiptDefaultTypeInternal; extern ValidationReceiptDefaultTypeInternal _ValidationReceipt_default_instance_; class ValidationRequest; struct ValidationRequestDefaultTypeInternal; extern ValidationRequestDefaultTypeInternal _ValidationRequest_default_instance_; } // namespace execution namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace execution { enum ExecutionStatus : int { Success = 0, BadBlock = 1, TooFarAway = 2, MissingSegment = 3, InvalidForkchoice = 4, Busy = 5, ExecutionStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), ExecutionStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool ExecutionStatus_IsValid(int value); extern const uint32_t ExecutionStatus_internal_data_[]; constexpr ExecutionStatus ExecutionStatus_MIN = static_cast(0); constexpr ExecutionStatus ExecutionStatus_MAX = static_cast(5); constexpr int ExecutionStatus_ARRAYSIZE = 5 + 1; const ::google::protobuf::EnumDescriptor* ExecutionStatus_descriptor(); template const std::string& ExecutionStatus_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to ExecutionStatus_Name()."); return ExecutionStatus_Name(static_cast(value)); } template <> inline const std::string& ExecutionStatus_Name(ExecutionStatus value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool ExecutionStatus_Parse(absl::string_view name, ExecutionStatus* value) { return ::google::protobuf::internal::ParseNamedEnum( ExecutionStatus_descriptor(), name, value); } // =================================================================== // ------------------------------------------------------------------- class ReadyResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.ReadyResponse) */ { public: inline ReadyResponse() : ReadyResponse(nullptr) {} ~ReadyResponse() override; template explicit PROTOBUF_CONSTEXPR ReadyResponse( ::google::protobuf::internal::ConstantInitialized); inline ReadyResponse(const ReadyResponse& from) : ReadyResponse(nullptr, from) {} inline ReadyResponse(ReadyResponse&& from) noexcept : ReadyResponse(nullptr, std::move(from)) {} inline ReadyResponse& operator=(const ReadyResponse& from) { CopyFrom(from); return *this; } inline ReadyResponse& operator=(ReadyResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ReadyResponse& default_instance() { return *internal_default_instance(); } static inline const ReadyResponse* internal_default_instance() { return reinterpret_cast( &_ReadyResponse_default_instance_); } static constexpr int kIndexInFileMessages = 23; friend void swap(ReadyResponse& a, ReadyResponse& b) { a.Swap(&b); } inline void Swap(ReadyResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ReadyResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ReadyResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ReadyResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ReadyResponse& from) { ReadyResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ReadyResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.ReadyResponse"; } protected: explicit ReadyResponse(::google::protobuf::Arena* arena); ReadyResponse(::google::protobuf::Arena* arena, const ReadyResponse& from); ReadyResponse(::google::protobuf::Arena* arena, ReadyResponse&& from) noexcept : ReadyResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kReadyFieldNumber = 1, }; // bool ready = 1; void clear_ready() ; bool ready() const; void set_ready(bool value); private: bool _internal_ready() const; void _internal_set_ready(bool value); public: // @@protoc_insertion_point(class_scope:execution.ReadyResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ReadyResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ReadyResponse& from_msg); bool ready_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class IsCanonicalResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.IsCanonicalResponse) */ { public: inline IsCanonicalResponse() : IsCanonicalResponse(nullptr) {} ~IsCanonicalResponse() override; template explicit PROTOBUF_CONSTEXPR IsCanonicalResponse( ::google::protobuf::internal::ConstantInitialized); inline IsCanonicalResponse(const IsCanonicalResponse& from) : IsCanonicalResponse(nullptr, from) {} inline IsCanonicalResponse(IsCanonicalResponse&& from) noexcept : IsCanonicalResponse(nullptr, std::move(from)) {} inline IsCanonicalResponse& operator=(const IsCanonicalResponse& from) { CopyFrom(from); return *this; } inline IsCanonicalResponse& operator=(IsCanonicalResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const IsCanonicalResponse& default_instance() { return *internal_default_instance(); } static inline const IsCanonicalResponse* internal_default_instance() { return reinterpret_cast( &_IsCanonicalResponse_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(IsCanonicalResponse& a, IsCanonicalResponse& b) { a.Swap(&b); } inline void Swap(IsCanonicalResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IsCanonicalResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IsCanonicalResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const IsCanonicalResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const IsCanonicalResponse& from) { IsCanonicalResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(IsCanonicalResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.IsCanonicalResponse"; } protected: explicit IsCanonicalResponse(::google::protobuf::Arena* arena); IsCanonicalResponse(::google::protobuf::Arena* arena, const IsCanonicalResponse& from); IsCanonicalResponse(::google::protobuf::Arena* arena, IsCanonicalResponse&& from) noexcept : IsCanonicalResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCanonicalFieldNumber = 1, }; // bool canonical = 1; void clear_canonical() ; bool canonical() const; void set_canonical(bool value); private: bool _internal_canonical() const; void _internal_set_canonical(bool value); public: // @@protoc_insertion_point(class_scope:execution.IsCanonicalResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_IsCanonicalResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const IsCanonicalResponse& from_msg); bool canonical_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class InsertionResult final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.InsertionResult) */ { public: inline InsertionResult() : InsertionResult(nullptr) {} ~InsertionResult() override; template explicit PROTOBUF_CONSTEXPR InsertionResult( ::google::protobuf::internal::ConstantInitialized); inline InsertionResult(const InsertionResult& from) : InsertionResult(nullptr, from) {} inline InsertionResult(InsertionResult&& from) noexcept : InsertionResult(nullptr, std::move(from)) {} inline InsertionResult& operator=(const InsertionResult& from) { CopyFrom(from); return *this; } inline InsertionResult& operator=(InsertionResult&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const InsertionResult& default_instance() { return *internal_default_instance(); } static inline const InsertionResult* internal_default_instance() { return reinterpret_cast( &_InsertionResult_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(InsertionResult& a, InsertionResult& b) { a.Swap(&b); } inline void Swap(InsertionResult* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(InsertionResult* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- InsertionResult* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const InsertionResult& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const InsertionResult& from) { InsertionResult::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(InsertionResult* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.InsertionResult"; } protected: explicit InsertionResult(::google::protobuf::Arena* arena); InsertionResult(::google::protobuf::Arena* arena, const InsertionResult& from); InsertionResult(::google::protobuf::Arena* arena, InsertionResult&& from) noexcept : InsertionResult(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kResultFieldNumber = 1, }; // .execution.ExecutionStatus result = 1; void clear_result() ; ::execution::ExecutionStatus result() const; void set_result(::execution::ExecutionStatus value); private: ::execution::ExecutionStatus _internal_result() const; void _internal_set_result(::execution::ExecutionStatus value); public: // @@protoc_insertion_point(class_scope:execution.InsertionResult) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_InsertionResult_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const InsertionResult& from_msg); int result_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class HasBlockResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.HasBlockResponse) */ { public: inline HasBlockResponse() : HasBlockResponse(nullptr) {} ~HasBlockResponse() override; template explicit PROTOBUF_CONSTEXPR HasBlockResponse( ::google::protobuf::internal::ConstantInitialized); inline HasBlockResponse(const HasBlockResponse& from) : HasBlockResponse(nullptr, from) {} inline HasBlockResponse(HasBlockResponse&& from) noexcept : HasBlockResponse(nullptr, std::move(from)) {} inline HasBlockResponse& operator=(const HasBlockResponse& from) { CopyFrom(from); return *this; } inline HasBlockResponse& operator=(HasBlockResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HasBlockResponse& default_instance() { return *internal_default_instance(); } static inline const HasBlockResponse* internal_default_instance() { return reinterpret_cast( &_HasBlockResponse_default_instance_); } static constexpr int kIndexInFileMessages = 25; friend void swap(HasBlockResponse& a, HasBlockResponse& b) { a.Swap(&b); } inline void Swap(HasBlockResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HasBlockResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HasBlockResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HasBlockResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HasBlockResponse& from) { HasBlockResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HasBlockResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.HasBlockResponse"; } protected: explicit HasBlockResponse(::google::protobuf::Arena* arena); HasBlockResponse(::google::protobuf::Arena* arena, const HasBlockResponse& from); HasBlockResponse(::google::protobuf::Arena* arena, HasBlockResponse&& from) noexcept : HasBlockResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHasBlockFieldNumber = 1, }; // bool has_block = 1; void clear_has_block() ; bool has_block() const; void set_has_block(bool value); private: bool _internal_has_block() const; void _internal_set_has_block(bool value); public: // @@protoc_insertion_point(class_scope:execution.HasBlockResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HasBlockResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HasBlockResponse& from_msg); bool has_block_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetHeaderHashNumberResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetHeaderHashNumberResponse) */ { public: inline GetHeaderHashNumberResponse() : GetHeaderHashNumberResponse(nullptr) {} ~GetHeaderHashNumberResponse() override; template explicit PROTOBUF_CONSTEXPR GetHeaderHashNumberResponse( ::google::protobuf::internal::ConstantInitialized); inline GetHeaderHashNumberResponse(const GetHeaderHashNumberResponse& from) : GetHeaderHashNumberResponse(nullptr, from) {} inline GetHeaderHashNumberResponse(GetHeaderHashNumberResponse&& from) noexcept : GetHeaderHashNumberResponse(nullptr, std::move(from)) {} inline GetHeaderHashNumberResponse& operator=(const GetHeaderHashNumberResponse& from) { CopyFrom(from); return *this; } inline GetHeaderHashNumberResponse& operator=(GetHeaderHashNumberResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetHeaderHashNumberResponse& default_instance() { return *internal_default_instance(); } static inline const GetHeaderHashNumberResponse* internal_default_instance() { return reinterpret_cast( &_GetHeaderHashNumberResponse_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(GetHeaderHashNumberResponse& a, GetHeaderHashNumberResponse& b) { a.Swap(&b); } inline void Swap(GetHeaderHashNumberResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetHeaderHashNumberResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetHeaderHashNumberResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetHeaderHashNumberResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetHeaderHashNumberResponse& from) { GetHeaderHashNumberResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetHeaderHashNumberResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetHeaderHashNumberResponse"; } protected: explicit GetHeaderHashNumberResponse(::google::protobuf::Arena* arena); GetHeaderHashNumberResponse(::google::protobuf::Arena* arena, const GetHeaderHashNumberResponse& from); GetHeaderHashNumberResponse(::google::protobuf::Arena* arena, GetHeaderHashNumberResponse&& from) noexcept : GetHeaderHashNumberResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockNumberFieldNumber = 1, }; // optional uint64 block_number = 1; bool has_block_number() const; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.GetHeaderHashNumberResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetHeaderHashNumberResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetHeaderHashNumberResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::uint64_t block_number_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetBodiesByRangeRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetBodiesByRangeRequest) */ { public: inline GetBodiesByRangeRequest() : GetBodiesByRangeRequest(nullptr) {} ~GetBodiesByRangeRequest() override; template explicit PROTOBUF_CONSTEXPR GetBodiesByRangeRequest( ::google::protobuf::internal::ConstantInitialized); inline GetBodiesByRangeRequest(const GetBodiesByRangeRequest& from) : GetBodiesByRangeRequest(nullptr, from) {} inline GetBodiesByRangeRequest(GetBodiesByRangeRequest&& from) noexcept : GetBodiesByRangeRequest(nullptr, std::move(from)) {} inline GetBodiesByRangeRequest& operator=(const GetBodiesByRangeRequest& from) { CopyFrom(from); return *this; } inline GetBodiesByRangeRequest& operator=(GetBodiesByRangeRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetBodiesByRangeRequest& default_instance() { return *internal_default_instance(); } static inline const GetBodiesByRangeRequest* internal_default_instance() { return reinterpret_cast( &_GetBodiesByRangeRequest_default_instance_); } static constexpr int kIndexInFileMessages = 22; friend void swap(GetBodiesByRangeRequest& a, GetBodiesByRangeRequest& b) { a.Swap(&b); } inline void Swap(GetBodiesByRangeRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetBodiesByRangeRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetBodiesByRangeRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetBodiesByRangeRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetBodiesByRangeRequest& from) { GetBodiesByRangeRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetBodiesByRangeRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetBodiesByRangeRequest"; } protected: explicit GetBodiesByRangeRequest(::google::protobuf::Arena* arena); GetBodiesByRangeRequest(::google::protobuf::Arena* arena, const GetBodiesByRangeRequest& from); GetBodiesByRangeRequest(::google::protobuf::Arena* arena, GetBodiesByRangeRequest&& from) noexcept : GetBodiesByRangeRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kStartFieldNumber = 1, kCountFieldNumber = 2, }; // uint64 start = 1; void clear_start() ; ::uint64_t start() const; void set_start(::uint64_t value); private: ::uint64_t _internal_start() const; void _internal_set_start(::uint64_t value); public: // uint64 count = 2; void clear_count() ; ::uint64_t count() const; void set_count(::uint64_t value); private: ::uint64_t _internal_count() const; void _internal_set_count(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.GetBodiesByRangeRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetBodiesByRangeRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetBodiesByRangeRequest& from_msg); ::uint64_t start_; ::uint64_t count_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetAssembledBlockRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetAssembledBlockRequest) */ { public: inline GetAssembledBlockRequest() : GetAssembledBlockRequest(nullptr) {} ~GetAssembledBlockRequest() override; template explicit PROTOBUF_CONSTEXPR GetAssembledBlockRequest( ::google::protobuf::internal::ConstantInitialized); inline GetAssembledBlockRequest(const GetAssembledBlockRequest& from) : GetAssembledBlockRequest(nullptr, from) {} inline GetAssembledBlockRequest(GetAssembledBlockRequest&& from) noexcept : GetAssembledBlockRequest(nullptr, std::move(from)) {} inline GetAssembledBlockRequest& operator=(const GetAssembledBlockRequest& from) { CopyFrom(from); return *this; } inline GetAssembledBlockRequest& operator=(GetAssembledBlockRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetAssembledBlockRequest& default_instance() { return *internal_default_instance(); } static inline const GetAssembledBlockRequest* internal_default_instance() { return reinterpret_cast( &_GetAssembledBlockRequest_default_instance_); } static constexpr int kIndexInFileMessages = 17; friend void swap(GetAssembledBlockRequest& a, GetAssembledBlockRequest& b) { a.Swap(&b); } inline void Swap(GetAssembledBlockRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetAssembledBlockRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetAssembledBlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetAssembledBlockRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetAssembledBlockRequest& from) { GetAssembledBlockRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetAssembledBlockRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetAssembledBlockRequest"; } protected: explicit GetAssembledBlockRequest(::google::protobuf::Arena* arena); GetAssembledBlockRequest(::google::protobuf::Arena* arena, const GetAssembledBlockRequest& from); GetAssembledBlockRequest(::google::protobuf::Arena* arena, GetAssembledBlockRequest&& from) noexcept : GetAssembledBlockRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdFieldNumber = 1, }; // uint64 id = 1; void clear_id() ; ::uint64_t id() const; void set_id(::uint64_t value); private: ::uint64_t _internal_id() const; void _internal_set_id(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.GetAssembledBlockRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetAssembledBlockRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetAssembledBlockRequest& from_msg); ::uint64_t id_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class FrozenBlocksResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.FrozenBlocksResponse) */ { public: inline FrozenBlocksResponse() : FrozenBlocksResponse(nullptr) {} ~FrozenBlocksResponse() override; template explicit PROTOBUF_CONSTEXPR FrozenBlocksResponse( ::google::protobuf::internal::ConstantInitialized); inline FrozenBlocksResponse(const FrozenBlocksResponse& from) : FrozenBlocksResponse(nullptr, from) {} inline FrozenBlocksResponse(FrozenBlocksResponse&& from) noexcept : FrozenBlocksResponse(nullptr, std::move(from)) {} inline FrozenBlocksResponse& operator=(const FrozenBlocksResponse& from) { CopyFrom(from); return *this; } inline FrozenBlocksResponse& operator=(FrozenBlocksResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const FrozenBlocksResponse& default_instance() { return *internal_default_instance(); } static inline const FrozenBlocksResponse* internal_default_instance() { return reinterpret_cast( &_FrozenBlocksResponse_default_instance_); } static constexpr int kIndexInFileMessages = 24; friend void swap(FrozenBlocksResponse& a, FrozenBlocksResponse& b) { a.Swap(&b); } inline void Swap(FrozenBlocksResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FrozenBlocksResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FrozenBlocksResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const FrozenBlocksResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const FrozenBlocksResponse& from) { FrozenBlocksResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(FrozenBlocksResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.FrozenBlocksResponse"; } protected: explicit FrozenBlocksResponse(::google::protobuf::Arena* arena); FrozenBlocksResponse(::google::protobuf::Arena* arena, const FrozenBlocksResponse& from); FrozenBlocksResponse(::google::protobuf::Arena* arena, FrozenBlocksResponse&& from) noexcept : FrozenBlocksResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kFrozenBlocksFieldNumber = 1, kHasGapFieldNumber = 2, }; // uint64 frozen_blocks = 1; void clear_frozen_blocks() ; ::uint64_t frozen_blocks() const; void set_frozen_blocks(::uint64_t value); private: ::uint64_t _internal_frozen_blocks() const; void _internal_set_frozen_blocks(::uint64_t value); public: // bool has_gap = 2; void clear_has_gap() ; bool has_gap() const; void set_has_gap(bool value); private: bool _internal_has_gap() const; void _internal_set_has_gap(bool value); public: // @@protoc_insertion_point(class_scope:execution.FrozenBlocksResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_FrozenBlocksResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const FrozenBlocksResponse& from_msg); ::uint64_t frozen_blocks_; bool has_gap_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class AssembleBlockResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.AssembleBlockResponse) */ { public: inline AssembleBlockResponse() : AssembleBlockResponse(nullptr) {} ~AssembleBlockResponse() override; template explicit PROTOBUF_CONSTEXPR AssembleBlockResponse( ::google::protobuf::internal::ConstantInitialized); inline AssembleBlockResponse(const AssembleBlockResponse& from) : AssembleBlockResponse(nullptr, from) {} inline AssembleBlockResponse(AssembleBlockResponse&& from) noexcept : AssembleBlockResponse(nullptr, std::move(from)) {} inline AssembleBlockResponse& operator=(const AssembleBlockResponse& from) { CopyFrom(from); return *this; } inline AssembleBlockResponse& operator=(AssembleBlockResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AssembleBlockResponse& default_instance() { return *internal_default_instance(); } static inline const AssembleBlockResponse* internal_default_instance() { return reinterpret_cast( &_AssembleBlockResponse_default_instance_); } static constexpr int kIndexInFileMessages = 16; friend void swap(AssembleBlockResponse& a, AssembleBlockResponse& b) { a.Swap(&b); } inline void Swap(AssembleBlockResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AssembleBlockResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AssembleBlockResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AssembleBlockResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AssembleBlockResponse& from) { AssembleBlockResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AssembleBlockResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.AssembleBlockResponse"; } protected: explicit AssembleBlockResponse(::google::protobuf::Arena* arena); AssembleBlockResponse(::google::protobuf::Arena* arena, const AssembleBlockResponse& from); AssembleBlockResponse(::google::protobuf::Arena* arena, AssembleBlockResponse&& from) noexcept : AssembleBlockResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdFieldNumber = 1, kBusyFieldNumber = 2, }; // uint64 id = 1; void clear_id() ; ::uint64_t id() const; void set_id(::uint64_t value); private: ::uint64_t _internal_id() const; void _internal_set_id(::uint64_t value); public: // bool busy = 2; void clear_busy() ; bool busy() const; void set_busy(bool value); private: bool _internal_busy() const; void _internal_set_busy(bool value); public: // @@protoc_insertion_point(class_scope:execution.AssembleBlockResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AssembleBlockResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AssembleBlockResponse& from_msg); ::uint64_t id_; bool busy_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class ValidationRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.ValidationRequest) */ { public: inline ValidationRequest() : ValidationRequest(nullptr) {} ~ValidationRequest() override; template explicit PROTOBUF_CONSTEXPR ValidationRequest( ::google::protobuf::internal::ConstantInitialized); inline ValidationRequest(const ValidationRequest& from) : ValidationRequest(nullptr, from) {} inline ValidationRequest(ValidationRequest&& from) noexcept : ValidationRequest(nullptr, std::move(from)) {} inline ValidationRequest& operator=(const ValidationRequest& from) { CopyFrom(from); return *this; } inline ValidationRequest& operator=(ValidationRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ValidationRequest& default_instance() { return *internal_default_instance(); } static inline const ValidationRequest* internal_default_instance() { return reinterpret_cast( &_ValidationRequest_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(ValidationRequest& a, ValidationRequest& b) { a.Swap(&b); } inline void Swap(ValidationRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ValidationRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ValidationRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ValidationRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ValidationRequest& from) { ValidationRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ValidationRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.ValidationRequest"; } protected: explicit ValidationRequest(::google::protobuf::Arena* arena); ValidationRequest(::google::protobuf::Arena* arena, const ValidationRequest& from); ValidationRequest(::google::protobuf::Arena* arena, ValidationRequest&& from) noexcept : ValidationRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashFieldNumber = 1, kNumberFieldNumber = 2, }; // .types.H256 hash = 1; bool has_hash() const; void clear_hash() ; const ::types::H256& hash() const; PROTOBUF_NODISCARD ::types::H256* release_hash(); ::types::H256* mutable_hash(); void set_allocated_hash(::types::H256* value); void unsafe_arena_set_allocated_hash(::types::H256* value); ::types::H256* unsafe_arena_release_hash(); private: const ::types::H256& _internal_hash() const; ::types::H256* _internal_mutable_hash(); public: // uint64 number = 2; void clear_number() ; ::uint64_t number() const; void set_number(::uint64_t value); private: ::uint64_t _internal_number() const; void _internal_set_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.ValidationRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ValidationRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ValidationRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* hash_; ::uint64_t number_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class ValidationReceipt final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.ValidationReceipt) */ { public: inline ValidationReceipt() : ValidationReceipt(nullptr) {} ~ValidationReceipt() override; template explicit PROTOBUF_CONSTEXPR ValidationReceipt( ::google::protobuf::internal::ConstantInitialized); inline ValidationReceipt(const ValidationReceipt& from) : ValidationReceipt(nullptr, from) {} inline ValidationReceipt(ValidationReceipt&& from) noexcept : ValidationReceipt(nullptr, std::move(from)) {} inline ValidationReceipt& operator=(const ValidationReceipt& from) { CopyFrom(from); return *this; } inline ValidationReceipt& operator=(ValidationReceipt&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ValidationReceipt& default_instance() { return *internal_default_instance(); } static inline const ValidationReceipt* internal_default_instance() { return reinterpret_cast( &_ValidationReceipt_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(ValidationReceipt& a, ValidationReceipt& b) { a.Swap(&b); } inline void Swap(ValidationReceipt* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ValidationReceipt* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ValidationReceipt* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ValidationReceipt& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ValidationReceipt& from) { ValidationReceipt::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ValidationReceipt* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.ValidationReceipt"; } protected: explicit ValidationReceipt(::google::protobuf::Arena* arena); ValidationReceipt(::google::protobuf::Arena* arena, const ValidationReceipt& from); ValidationReceipt(::google::protobuf::Arena* arena, ValidationReceipt&& from) noexcept : ValidationReceipt(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kValidationErrorFieldNumber = 3, kLatestValidHashFieldNumber = 2, kValidationStatusFieldNumber = 1, }; // string validation_error = 3; void clear_validation_error() ; const std::string& validation_error() const; template void set_validation_error(Arg_&& arg, Args_... args); std::string* mutable_validation_error(); PROTOBUF_NODISCARD std::string* release_validation_error(); void set_allocated_validation_error(std::string* value); private: const std::string& _internal_validation_error() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_validation_error( const std::string& value); std::string* _internal_mutable_validation_error(); public: // .types.H256 latest_valid_hash = 2; bool has_latest_valid_hash() const; void clear_latest_valid_hash() ; const ::types::H256& latest_valid_hash() const; PROTOBUF_NODISCARD ::types::H256* release_latest_valid_hash(); ::types::H256* mutable_latest_valid_hash(); void set_allocated_latest_valid_hash(::types::H256* value); void unsafe_arena_set_allocated_latest_valid_hash(::types::H256* value); ::types::H256* unsafe_arena_release_latest_valid_hash(); private: const ::types::H256& _internal_latest_valid_hash() const; ::types::H256* _internal_mutable_latest_valid_hash(); public: // .execution.ExecutionStatus validation_status = 1; void clear_validation_status() ; ::execution::ExecutionStatus validation_status() const; void set_validation_status(::execution::ExecutionStatus value); private: ::execution::ExecutionStatus _internal_validation_status() const; void _internal_set_validation_status(::execution::ExecutionStatus value); public: // @@protoc_insertion_point(class_scope:execution.ValidationReceipt) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 1, 52, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ValidationReceipt_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ValidationReceipt& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr validation_error_; ::types::H256* latest_valid_hash_; int validation_status_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetTDResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetTDResponse) */ { public: inline GetTDResponse() : GetTDResponse(nullptr) {} ~GetTDResponse() override; template explicit PROTOBUF_CONSTEXPR GetTDResponse( ::google::protobuf::internal::ConstantInitialized); inline GetTDResponse(const GetTDResponse& from) : GetTDResponse(nullptr, from) {} inline GetTDResponse(GetTDResponse&& from) noexcept : GetTDResponse(nullptr, std::move(from)) {} inline GetTDResponse& operator=(const GetTDResponse& from) { CopyFrom(from); return *this; } inline GetTDResponse& operator=(GetTDResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetTDResponse& default_instance() { return *internal_default_instance(); } static inline const GetTDResponse* internal_default_instance() { return reinterpret_cast( &_GetTDResponse_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(GetTDResponse& a, GetTDResponse& b) { a.Swap(&b); } inline void Swap(GetTDResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetTDResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetTDResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetTDResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetTDResponse& from) { GetTDResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetTDResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetTDResponse"; } protected: explicit GetTDResponse(::google::protobuf::Arena* arena); GetTDResponse(::google::protobuf::Arena* arena, const GetTDResponse& from); GetTDResponse(::google::protobuf::Arena* arena, GetTDResponse&& from) noexcept : GetTDResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTdFieldNumber = 1, }; // optional .types.H256 td = 1; bool has_td() const; void clear_td() ; const ::types::H256& td() const; PROTOBUF_NODISCARD ::types::H256* release_td(); ::types::H256* mutable_td(); void set_allocated_td(::types::H256* value); void unsafe_arena_set_allocated_td(::types::H256* value); ::types::H256* unsafe_arena_release_td(); private: const ::types::H256& _internal_td() const; ::types::H256* _internal_mutable_td(); public: // @@protoc_insertion_point(class_scope:execution.GetTDResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetTDResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetTDResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* td_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetSegmentRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetSegmentRequest) */ { public: inline GetSegmentRequest() : GetSegmentRequest(nullptr) {} ~GetSegmentRequest() override; template explicit PROTOBUF_CONSTEXPR GetSegmentRequest( ::google::protobuf::internal::ConstantInitialized); inline GetSegmentRequest(const GetSegmentRequest& from) : GetSegmentRequest(nullptr, from) {} inline GetSegmentRequest(GetSegmentRequest&& from) noexcept : GetSegmentRequest(nullptr, std::move(from)) {} inline GetSegmentRequest& operator=(const GetSegmentRequest& from) { CopyFrom(from); return *this; } inline GetSegmentRequest& operator=(GetSegmentRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetSegmentRequest& default_instance() { return *internal_default_instance(); } static inline const GetSegmentRequest* internal_default_instance() { return reinterpret_cast( &_GetSegmentRequest_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(GetSegmentRequest& a, GetSegmentRequest& b) { a.Swap(&b); } inline void Swap(GetSegmentRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetSegmentRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetSegmentRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetSegmentRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetSegmentRequest& from) { GetSegmentRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetSegmentRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetSegmentRequest"; } protected: explicit GetSegmentRequest(::google::protobuf::Arena* arena); GetSegmentRequest(::google::protobuf::Arena* arena, const GetSegmentRequest& from); GetSegmentRequest(::google::protobuf::Arena* arena, GetSegmentRequest&& from) noexcept : GetSegmentRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockHashFieldNumber = 2, kBlockNumberFieldNumber = 1, }; // optional .types.H256 block_hash = 2; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // optional uint64 block_number = 1; bool has_block_number() const; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.GetSegmentRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetSegmentRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetSegmentRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* block_hash_; ::uint64_t block_number_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetBodiesByHashesRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetBodiesByHashesRequest) */ { public: inline GetBodiesByHashesRequest() : GetBodiesByHashesRequest(nullptr) {} ~GetBodiesByHashesRequest() override; template explicit PROTOBUF_CONSTEXPR GetBodiesByHashesRequest( ::google::protobuf::internal::ConstantInitialized); inline GetBodiesByHashesRequest(const GetBodiesByHashesRequest& from) : GetBodiesByHashesRequest(nullptr, from) {} inline GetBodiesByHashesRequest(GetBodiesByHashesRequest&& from) noexcept : GetBodiesByHashesRequest(nullptr, std::move(from)) {} inline GetBodiesByHashesRequest& operator=(const GetBodiesByHashesRequest& from) { CopyFrom(from); return *this; } inline GetBodiesByHashesRequest& operator=(GetBodiesByHashesRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetBodiesByHashesRequest& default_instance() { return *internal_default_instance(); } static inline const GetBodiesByHashesRequest* internal_default_instance() { return reinterpret_cast( &_GetBodiesByHashesRequest_default_instance_); } static constexpr int kIndexInFileMessages = 21; friend void swap(GetBodiesByHashesRequest& a, GetBodiesByHashesRequest& b) { a.Swap(&b); } inline void Swap(GetBodiesByHashesRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetBodiesByHashesRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetBodiesByHashesRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetBodiesByHashesRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetBodiesByHashesRequest& from) { GetBodiesByHashesRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetBodiesByHashesRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetBodiesByHashesRequest"; } protected: explicit GetBodiesByHashesRequest(::google::protobuf::Arena* arena); GetBodiesByHashesRequest(::google::protobuf::Arena* arena, const GetBodiesByHashesRequest& from); GetBodiesByHashesRequest(::google::protobuf::Arena* arena, GetBodiesByHashesRequest&& from) noexcept : GetBodiesByHashesRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashesFieldNumber = 1, }; // repeated .types.H256 hashes = 1; int hashes_size() const; private: int _internal_hashes_size() const; public: void clear_hashes() ; ::types::H256* mutable_hashes(int index); ::google::protobuf::RepeatedPtrField<::types::H256>* mutable_hashes(); private: const ::google::protobuf::RepeatedPtrField<::types::H256>& _internal_hashes() const; ::google::protobuf::RepeatedPtrField<::types::H256>* _internal_mutable_hashes(); public: const ::types::H256& hashes(int index) const; ::types::H256* add_hashes(); const ::google::protobuf::RepeatedPtrField<::types::H256>& hashes() const; // @@protoc_insertion_point(class_scope:execution.GetBodiesByHashesRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetBodiesByHashesRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetBodiesByHashesRequest& from_msg); ::google::protobuf::RepeatedPtrField< ::types::H256 > hashes_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class ForkChoiceReceipt final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.ForkChoiceReceipt) */ { public: inline ForkChoiceReceipt() : ForkChoiceReceipt(nullptr) {} ~ForkChoiceReceipt() override; template explicit PROTOBUF_CONSTEXPR ForkChoiceReceipt( ::google::protobuf::internal::ConstantInitialized); inline ForkChoiceReceipt(const ForkChoiceReceipt& from) : ForkChoiceReceipt(nullptr, from) {} inline ForkChoiceReceipt(ForkChoiceReceipt&& from) noexcept : ForkChoiceReceipt(nullptr, std::move(from)) {} inline ForkChoiceReceipt& operator=(const ForkChoiceReceipt& from) { CopyFrom(from); return *this; } inline ForkChoiceReceipt& operator=(ForkChoiceReceipt&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ForkChoiceReceipt& default_instance() { return *internal_default_instance(); } static inline const ForkChoiceReceipt* internal_default_instance() { return reinterpret_cast( &_ForkChoiceReceipt_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(ForkChoiceReceipt& a, ForkChoiceReceipt& b) { a.Swap(&b); } inline void Swap(ForkChoiceReceipt* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ForkChoiceReceipt* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ForkChoiceReceipt* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ForkChoiceReceipt& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ForkChoiceReceipt& from) { ForkChoiceReceipt::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ForkChoiceReceipt* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.ForkChoiceReceipt"; } protected: explicit ForkChoiceReceipt(::google::protobuf::Arena* arena); ForkChoiceReceipt(::google::protobuf::Arena* arena, const ForkChoiceReceipt& from); ForkChoiceReceipt(::google::protobuf::Arena* arena, ForkChoiceReceipt&& from) noexcept : ForkChoiceReceipt(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kValidationErrorFieldNumber = 3, kLatestValidHashFieldNumber = 2, kStatusFieldNumber = 1, }; // string validation_error = 3; void clear_validation_error() ; const std::string& validation_error() const; template void set_validation_error(Arg_&& arg, Args_... args); std::string* mutable_validation_error(); PROTOBUF_NODISCARD std::string* release_validation_error(); void set_allocated_validation_error(std::string* value); private: const std::string& _internal_validation_error() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_validation_error( const std::string& value); std::string* _internal_mutable_validation_error(); public: // .types.H256 latest_valid_hash = 2; bool has_latest_valid_hash() const; void clear_latest_valid_hash() ; const ::types::H256& latest_valid_hash() const; PROTOBUF_NODISCARD ::types::H256* release_latest_valid_hash(); ::types::H256* mutable_latest_valid_hash(); void set_allocated_latest_valid_hash(::types::H256* value); void unsafe_arena_set_allocated_latest_valid_hash(::types::H256* value); ::types::H256* unsafe_arena_release_latest_valid_hash(); private: const ::types::H256& _internal_latest_valid_hash() const; ::types::H256* _internal_mutable_latest_valid_hash(); public: // .execution.ExecutionStatus status = 1; void clear_status() ; ::execution::ExecutionStatus status() const; void set_status(::execution::ExecutionStatus value); private: ::execution::ExecutionStatus _internal_status() const; void _internal_set_status(::execution::ExecutionStatus value); public: // @@protoc_insertion_point(class_scope:execution.ForkChoiceReceipt) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 1, 52, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ForkChoiceReceipt_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ForkChoiceReceipt& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr validation_error_; ::types::H256* latest_valid_hash_; int status_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class ForkChoice final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.ForkChoice) */ { public: inline ForkChoice() : ForkChoice(nullptr) {} ~ForkChoice() override; template explicit PROTOBUF_CONSTEXPR ForkChoice( ::google::protobuf::internal::ConstantInitialized); inline ForkChoice(const ForkChoice& from) : ForkChoice(nullptr, from) {} inline ForkChoice(ForkChoice&& from) noexcept : ForkChoice(nullptr, std::move(from)) {} inline ForkChoice& operator=(const ForkChoice& from) { CopyFrom(from); return *this; } inline ForkChoice& operator=(ForkChoice&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ForkChoice& default_instance() { return *internal_default_instance(); } static inline const ForkChoice* internal_default_instance() { return reinterpret_cast( &_ForkChoice_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(ForkChoice& a, ForkChoice& b) { a.Swap(&b); } inline void Swap(ForkChoice* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ForkChoice* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ForkChoice* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ForkChoice& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ForkChoice& from) { ForkChoice::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ForkChoice* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.ForkChoice"; } protected: explicit ForkChoice(::google::protobuf::Arena* arena); ForkChoice(::google::protobuf::Arena* arena, const ForkChoice& from); ForkChoice(::google::protobuf::Arena* arena, ForkChoice&& from) noexcept : ForkChoice(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHeadBlockHashFieldNumber = 1, kFinalizedBlockHashFieldNumber = 3, kSafeBlockHashFieldNumber = 4, kTimeoutFieldNumber = 2, }; // .types.H256 head_block_hash = 1; bool has_head_block_hash() const; void clear_head_block_hash() ; const ::types::H256& head_block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_head_block_hash(); ::types::H256* mutable_head_block_hash(); void set_allocated_head_block_hash(::types::H256* value); void unsafe_arena_set_allocated_head_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_head_block_hash(); private: const ::types::H256& _internal_head_block_hash() const; ::types::H256* _internal_mutable_head_block_hash(); public: // optional .types.H256 finalized_block_hash = 3; bool has_finalized_block_hash() const; void clear_finalized_block_hash() ; const ::types::H256& finalized_block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_finalized_block_hash(); ::types::H256* mutable_finalized_block_hash(); void set_allocated_finalized_block_hash(::types::H256* value); void unsafe_arena_set_allocated_finalized_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_finalized_block_hash(); private: const ::types::H256& _internal_finalized_block_hash() const; ::types::H256* _internal_mutable_finalized_block_hash(); public: // optional .types.H256 safe_block_hash = 4; bool has_safe_block_hash() const; void clear_safe_block_hash() ; const ::types::H256& safe_block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_safe_block_hash(); ::types::H256* mutable_safe_block_hash(); void set_allocated_safe_block_hash(::types::H256* value); void unsafe_arena_set_allocated_safe_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_safe_block_hash(); private: const ::types::H256& _internal_safe_block_hash() const; ::types::H256* _internal_mutable_safe_block_hash(); public: // uint64 timeout = 2; void clear_timeout() ; ::uint64_t timeout() const; void set_timeout(::uint64_t value); private: ::uint64_t _internal_timeout() const; void _internal_set_timeout(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.ForkChoice) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 4, 3, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ForkChoice_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ForkChoice& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* head_block_hash_; ::types::H256* finalized_block_hash_; ::types::H256* safe_block_hash_; ::uint64_t timeout_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class AssembleBlockRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.AssembleBlockRequest) */ { public: inline AssembleBlockRequest() : AssembleBlockRequest(nullptr) {} ~AssembleBlockRequest() override; template explicit PROTOBUF_CONSTEXPR AssembleBlockRequest( ::google::protobuf::internal::ConstantInitialized); inline AssembleBlockRequest(const AssembleBlockRequest& from) : AssembleBlockRequest(nullptr, from) {} inline AssembleBlockRequest(AssembleBlockRequest&& from) noexcept : AssembleBlockRequest(nullptr, std::move(from)) {} inline AssembleBlockRequest& operator=(const AssembleBlockRequest& from) { CopyFrom(from); return *this; } inline AssembleBlockRequest& operator=(AssembleBlockRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AssembleBlockRequest& default_instance() { return *internal_default_instance(); } static inline const AssembleBlockRequest* internal_default_instance() { return reinterpret_cast( &_AssembleBlockRequest_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(AssembleBlockRequest& a, AssembleBlockRequest& b) { a.Swap(&b); } inline void Swap(AssembleBlockRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AssembleBlockRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AssembleBlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AssembleBlockRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AssembleBlockRequest& from) { AssembleBlockRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AssembleBlockRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.AssembleBlockRequest"; } protected: explicit AssembleBlockRequest(::google::protobuf::Arena* arena); AssembleBlockRequest(::google::protobuf::Arena* arena, const AssembleBlockRequest& from); AssembleBlockRequest(::google::protobuf::Arena* arena, AssembleBlockRequest&& from) noexcept : AssembleBlockRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kWithdrawalsFieldNumber = 5, kParentHashFieldNumber = 1, kPrevRandaoFieldNumber = 3, kSuggestedFeeRecipientFieldNumber = 4, kParentBeaconBlockRootFieldNumber = 6, kTimestampFieldNumber = 2, }; // repeated .types.Withdrawal withdrawals = 5; int withdrawals_size() const; private: int _internal_withdrawals_size() const; public: void clear_withdrawals() ; ::types::Withdrawal* mutable_withdrawals(int index); ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* mutable_withdrawals(); private: const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& _internal_withdrawals() const; ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* _internal_mutable_withdrawals(); public: const ::types::Withdrawal& withdrawals(int index) const; ::types::Withdrawal* add_withdrawals(); const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& withdrawals() const; // .types.H256 parent_hash = 1; bool has_parent_hash() const; void clear_parent_hash() ; const ::types::H256& parent_hash() const; PROTOBUF_NODISCARD ::types::H256* release_parent_hash(); ::types::H256* mutable_parent_hash(); void set_allocated_parent_hash(::types::H256* value); void unsafe_arena_set_allocated_parent_hash(::types::H256* value); ::types::H256* unsafe_arena_release_parent_hash(); private: const ::types::H256& _internal_parent_hash() const; ::types::H256* _internal_mutable_parent_hash(); public: // .types.H256 prev_randao = 3; bool has_prev_randao() const; void clear_prev_randao() ; const ::types::H256& prev_randao() const; PROTOBUF_NODISCARD ::types::H256* release_prev_randao(); ::types::H256* mutable_prev_randao(); void set_allocated_prev_randao(::types::H256* value); void unsafe_arena_set_allocated_prev_randao(::types::H256* value); ::types::H256* unsafe_arena_release_prev_randao(); private: const ::types::H256& _internal_prev_randao() const; ::types::H256* _internal_mutable_prev_randao(); public: // .types.H160 suggested_fee_recipient = 4; bool has_suggested_fee_recipient() const; void clear_suggested_fee_recipient() ; const ::types::H160& suggested_fee_recipient() const; PROTOBUF_NODISCARD ::types::H160* release_suggested_fee_recipient(); ::types::H160* mutable_suggested_fee_recipient(); void set_allocated_suggested_fee_recipient(::types::H160* value); void unsafe_arena_set_allocated_suggested_fee_recipient(::types::H160* value); ::types::H160* unsafe_arena_release_suggested_fee_recipient(); private: const ::types::H160& _internal_suggested_fee_recipient() const; ::types::H160* _internal_mutable_suggested_fee_recipient(); public: // optional .types.H256 parent_beacon_block_root = 6; bool has_parent_beacon_block_root() const; void clear_parent_beacon_block_root() ; const ::types::H256& parent_beacon_block_root() const; PROTOBUF_NODISCARD ::types::H256* release_parent_beacon_block_root(); ::types::H256* mutable_parent_beacon_block_root(); void set_allocated_parent_beacon_block_root(::types::H256* value); void unsafe_arena_set_allocated_parent_beacon_block_root(::types::H256* value); ::types::H256* unsafe_arena_release_parent_beacon_block_root(); private: const ::types::H256& _internal_parent_beacon_block_root() const; ::types::H256* _internal_mutable_parent_beacon_block_root(); public: // uint64 timestamp = 2; void clear_timestamp() ; ::uint64_t timestamp() const; void set_timestamp(::uint64_t value); private: ::uint64_t _internal_timestamp() const; void _internal_set_timestamp(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.AssembleBlockRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 6, 5, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AssembleBlockRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AssembleBlockRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::types::Withdrawal > withdrawals_; ::types::H256* parent_hash_; ::types::H256* prev_randao_; ::types::H160* suggested_fee_recipient_; ::types::H256* parent_beacon_block_root_; ::uint64_t timestamp_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class Header final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.Header) */ { public: inline Header() : Header(nullptr) {} ~Header() override; template explicit PROTOBUF_CONSTEXPR Header( ::google::protobuf::internal::ConstantInitialized); inline Header(const Header& from) : Header(nullptr, from) {} inline Header(Header&& from) noexcept : Header(nullptr, std::move(from)) {} inline Header& operator=(const Header& from) { CopyFrom(from); return *this; } inline Header& operator=(Header&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Header& default_instance() { return *internal_default_instance(); } static inline const Header* internal_default_instance() { return reinterpret_cast( &_Header_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(Header& a, Header& b) { a.Swap(&b); } inline void Swap(Header* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Header* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Header* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct
(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Header& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Header& from) { Header::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Header* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.Header"; } protected: explicit Header(::google::protobuf::Arena* arena); Header(::google::protobuf::Arena* arena, const Header& from); Header(::google::protobuf::Arena* arena, Header&& from) noexcept : Header(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kExtraDataFieldNumber = 12, kAuraSealFieldNumber = 24, kParentHashFieldNumber = 1, kCoinbaseFieldNumber = 2, kStateRootFieldNumber = 3, kReceiptRootFieldNumber = 4, kLogsBloomFieldNumber = 5, kPrevRandaoFieldNumber = 6, kDifficultyFieldNumber = 13, kBlockHashFieldNumber = 14, kOmmerHashFieldNumber = 15, kTransactionHashFieldNumber = 16, kBaseFeePerGasFieldNumber = 17, kWithdrawalHashFieldNumber = 18, kParentBeaconBlockRootFieldNumber = 21, kRequestsHashFieldNumber = 22, kBlockNumberFieldNumber = 7, kGasLimitFieldNumber = 8, kGasUsedFieldNumber = 9, kTimestampFieldNumber = 10, kNonceFieldNumber = 11, kBlobGasUsedFieldNumber = 19, kExcessBlobGasFieldNumber = 20, kAuraStepFieldNumber = 23, }; // bytes extra_data = 12; void clear_extra_data() ; const std::string& extra_data() const; template void set_extra_data(Arg_&& arg, Args_... args); std::string* mutable_extra_data(); PROTOBUF_NODISCARD std::string* release_extra_data(); void set_allocated_extra_data(std::string* value); private: const std::string& _internal_extra_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_extra_data( const std::string& value); std::string* _internal_mutable_extra_data(); public: // optional bytes aura_seal = 24; bool has_aura_seal() const; void clear_aura_seal() ; const std::string& aura_seal() const; template void set_aura_seal(Arg_&& arg, Args_... args); std::string* mutable_aura_seal(); PROTOBUF_NODISCARD std::string* release_aura_seal(); void set_allocated_aura_seal(std::string* value); private: const std::string& _internal_aura_seal() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_aura_seal( const std::string& value); std::string* _internal_mutable_aura_seal(); public: // .types.H256 parent_hash = 1; bool has_parent_hash() const; void clear_parent_hash() ; const ::types::H256& parent_hash() const; PROTOBUF_NODISCARD ::types::H256* release_parent_hash(); ::types::H256* mutable_parent_hash(); void set_allocated_parent_hash(::types::H256* value); void unsafe_arena_set_allocated_parent_hash(::types::H256* value); ::types::H256* unsafe_arena_release_parent_hash(); private: const ::types::H256& _internal_parent_hash() const; ::types::H256* _internal_mutable_parent_hash(); public: // .types.H160 coinbase = 2; bool has_coinbase() const; void clear_coinbase() ; const ::types::H160& coinbase() const; PROTOBUF_NODISCARD ::types::H160* release_coinbase(); ::types::H160* mutable_coinbase(); void set_allocated_coinbase(::types::H160* value); void unsafe_arena_set_allocated_coinbase(::types::H160* value); ::types::H160* unsafe_arena_release_coinbase(); private: const ::types::H160& _internal_coinbase() const; ::types::H160* _internal_mutable_coinbase(); public: // .types.H256 state_root = 3; bool has_state_root() const; void clear_state_root() ; const ::types::H256& state_root() const; PROTOBUF_NODISCARD ::types::H256* release_state_root(); ::types::H256* mutable_state_root(); void set_allocated_state_root(::types::H256* value); void unsafe_arena_set_allocated_state_root(::types::H256* value); ::types::H256* unsafe_arena_release_state_root(); private: const ::types::H256& _internal_state_root() const; ::types::H256* _internal_mutable_state_root(); public: // .types.H256 receipt_root = 4; bool has_receipt_root() const; void clear_receipt_root() ; const ::types::H256& receipt_root() const; PROTOBUF_NODISCARD ::types::H256* release_receipt_root(); ::types::H256* mutable_receipt_root(); void set_allocated_receipt_root(::types::H256* value); void unsafe_arena_set_allocated_receipt_root(::types::H256* value); ::types::H256* unsafe_arena_release_receipt_root(); private: const ::types::H256& _internal_receipt_root() const; ::types::H256* _internal_mutable_receipt_root(); public: // .types.H2048 logs_bloom = 5; bool has_logs_bloom() const; void clear_logs_bloom() ; const ::types::H2048& logs_bloom() const; PROTOBUF_NODISCARD ::types::H2048* release_logs_bloom(); ::types::H2048* mutable_logs_bloom(); void set_allocated_logs_bloom(::types::H2048* value); void unsafe_arena_set_allocated_logs_bloom(::types::H2048* value); ::types::H2048* unsafe_arena_release_logs_bloom(); private: const ::types::H2048& _internal_logs_bloom() const; ::types::H2048* _internal_mutable_logs_bloom(); public: // .types.H256 prev_randao = 6; bool has_prev_randao() const; void clear_prev_randao() ; const ::types::H256& prev_randao() const; PROTOBUF_NODISCARD ::types::H256* release_prev_randao(); ::types::H256* mutable_prev_randao(); void set_allocated_prev_randao(::types::H256* value); void unsafe_arena_set_allocated_prev_randao(::types::H256* value); ::types::H256* unsafe_arena_release_prev_randao(); private: const ::types::H256& _internal_prev_randao() const; ::types::H256* _internal_mutable_prev_randao(); public: // .types.H256 difficulty = 13; bool has_difficulty() const; void clear_difficulty() ; const ::types::H256& difficulty() const; PROTOBUF_NODISCARD ::types::H256* release_difficulty(); ::types::H256* mutable_difficulty(); void set_allocated_difficulty(::types::H256* value); void unsafe_arena_set_allocated_difficulty(::types::H256* value); ::types::H256* unsafe_arena_release_difficulty(); private: const ::types::H256& _internal_difficulty() const; ::types::H256* _internal_mutable_difficulty(); public: // .types.H256 block_hash = 14; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // .types.H256 ommer_hash = 15; bool has_ommer_hash() const; void clear_ommer_hash() ; const ::types::H256& ommer_hash() const; PROTOBUF_NODISCARD ::types::H256* release_ommer_hash(); ::types::H256* mutable_ommer_hash(); void set_allocated_ommer_hash(::types::H256* value); void unsafe_arena_set_allocated_ommer_hash(::types::H256* value); ::types::H256* unsafe_arena_release_ommer_hash(); private: const ::types::H256& _internal_ommer_hash() const; ::types::H256* _internal_mutable_ommer_hash(); public: // .types.H256 transaction_hash = 16; bool has_transaction_hash() const; void clear_transaction_hash() ; const ::types::H256& transaction_hash() const; PROTOBUF_NODISCARD ::types::H256* release_transaction_hash(); ::types::H256* mutable_transaction_hash(); void set_allocated_transaction_hash(::types::H256* value); void unsafe_arena_set_allocated_transaction_hash(::types::H256* value); ::types::H256* unsafe_arena_release_transaction_hash(); private: const ::types::H256& _internal_transaction_hash() const; ::types::H256* _internal_mutable_transaction_hash(); public: // optional .types.H256 base_fee_per_gas = 17; bool has_base_fee_per_gas() const; void clear_base_fee_per_gas() ; const ::types::H256& base_fee_per_gas() const; PROTOBUF_NODISCARD ::types::H256* release_base_fee_per_gas(); ::types::H256* mutable_base_fee_per_gas(); void set_allocated_base_fee_per_gas(::types::H256* value); void unsafe_arena_set_allocated_base_fee_per_gas(::types::H256* value); ::types::H256* unsafe_arena_release_base_fee_per_gas(); private: const ::types::H256& _internal_base_fee_per_gas() const; ::types::H256* _internal_mutable_base_fee_per_gas(); public: // optional .types.H256 withdrawal_hash = 18; bool has_withdrawal_hash() const; void clear_withdrawal_hash() ; const ::types::H256& withdrawal_hash() const; PROTOBUF_NODISCARD ::types::H256* release_withdrawal_hash(); ::types::H256* mutable_withdrawal_hash(); void set_allocated_withdrawal_hash(::types::H256* value); void unsafe_arena_set_allocated_withdrawal_hash(::types::H256* value); ::types::H256* unsafe_arena_release_withdrawal_hash(); private: const ::types::H256& _internal_withdrawal_hash() const; ::types::H256* _internal_mutable_withdrawal_hash(); public: // optional .types.H256 parent_beacon_block_root = 21; bool has_parent_beacon_block_root() const; void clear_parent_beacon_block_root() ; const ::types::H256& parent_beacon_block_root() const; PROTOBUF_NODISCARD ::types::H256* release_parent_beacon_block_root(); ::types::H256* mutable_parent_beacon_block_root(); void set_allocated_parent_beacon_block_root(::types::H256* value); void unsafe_arena_set_allocated_parent_beacon_block_root(::types::H256* value); ::types::H256* unsafe_arena_release_parent_beacon_block_root(); private: const ::types::H256& _internal_parent_beacon_block_root() const; ::types::H256* _internal_mutable_parent_beacon_block_root(); public: // optional .types.H256 requests_hash = 22; bool has_requests_hash() const; void clear_requests_hash() ; const ::types::H256& requests_hash() const; PROTOBUF_NODISCARD ::types::H256* release_requests_hash(); ::types::H256* mutable_requests_hash(); void set_allocated_requests_hash(::types::H256* value); void unsafe_arena_set_allocated_requests_hash(::types::H256* value); ::types::H256* unsafe_arena_release_requests_hash(); private: const ::types::H256& _internal_requests_hash() const; ::types::H256* _internal_mutable_requests_hash(); public: // uint64 block_number = 7; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // uint64 gas_limit = 8; void clear_gas_limit() ; ::uint64_t gas_limit() const; void set_gas_limit(::uint64_t value); private: ::uint64_t _internal_gas_limit() const; void _internal_set_gas_limit(::uint64_t value); public: // uint64 gas_used = 9; void clear_gas_used() ; ::uint64_t gas_used() const; void set_gas_used(::uint64_t value); private: ::uint64_t _internal_gas_used() const; void _internal_set_gas_used(::uint64_t value); public: // uint64 timestamp = 10; void clear_timestamp() ; ::uint64_t timestamp() const; void set_timestamp(::uint64_t value); private: ::uint64_t _internal_timestamp() const; void _internal_set_timestamp(::uint64_t value); public: // uint64 nonce = 11; void clear_nonce() ; ::uint64_t nonce() const; void set_nonce(::uint64_t value); private: ::uint64_t _internal_nonce() const; void _internal_set_nonce(::uint64_t value); public: // optional uint64 blob_gas_used = 19; bool has_blob_gas_used() const; void clear_blob_gas_used() ; ::uint64_t blob_gas_used() const; void set_blob_gas_used(::uint64_t value); private: ::uint64_t _internal_blob_gas_used() const; void _internal_set_blob_gas_used(::uint64_t value); public: // optional uint64 excess_blob_gas = 20; bool has_excess_blob_gas() const; void clear_excess_blob_gas() ; ::uint64_t excess_blob_gas() const; void set_excess_blob_gas(::uint64_t value); private: ::uint64_t _internal_excess_blob_gas() const; void _internal_set_excess_blob_gas(::uint64_t value); public: // optional uint64 aura_step = 23; bool has_aura_step() const; void clear_aura_step() ; ::uint64_t aura_step() const; void set_aura_step(::uint64_t value); private: ::uint64_t _internal_aura_step() const; void _internal_set_aura_step(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.Header) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 5, 24, 14, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Header_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Header& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr extra_data_; ::google::protobuf::internal::ArenaStringPtr aura_seal_; ::types::H256* parent_hash_; ::types::H160* coinbase_; ::types::H256* state_root_; ::types::H256* receipt_root_; ::types::H2048* logs_bloom_; ::types::H256* prev_randao_; ::types::H256* difficulty_; ::types::H256* block_hash_; ::types::H256* ommer_hash_; ::types::H256* transaction_hash_; ::types::H256* base_fee_per_gas_; ::types::H256* withdrawal_hash_; ::types::H256* parent_beacon_block_root_; ::types::H256* requests_hash_; ::uint64_t block_number_; ::uint64_t gas_limit_; ::uint64_t gas_used_; ::uint64_t timestamp_; ::uint64_t nonce_; ::uint64_t blob_gas_used_; ::uint64_t excess_blob_gas_; ::uint64_t aura_step_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetHeaderResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetHeaderResponse) */ { public: inline GetHeaderResponse() : GetHeaderResponse(nullptr) {} ~GetHeaderResponse() override; template explicit PROTOBUF_CONSTEXPR GetHeaderResponse( ::google::protobuf::internal::ConstantInitialized); inline GetHeaderResponse(const GetHeaderResponse& from) : GetHeaderResponse(nullptr, from) {} inline GetHeaderResponse(GetHeaderResponse&& from) noexcept : GetHeaderResponse(nullptr, std::move(from)) {} inline GetHeaderResponse& operator=(const GetHeaderResponse& from) { CopyFrom(from); return *this; } inline GetHeaderResponse& operator=(GetHeaderResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetHeaderResponse& default_instance() { return *internal_default_instance(); } static inline const GetHeaderResponse* internal_default_instance() { return reinterpret_cast( &_GetHeaderResponse_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(GetHeaderResponse& a, GetHeaderResponse& b) { a.Swap(&b); } inline void Swap(GetHeaderResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetHeaderResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetHeaderResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetHeaderResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetHeaderResponse& from) { GetHeaderResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetHeaderResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetHeaderResponse"; } protected: explicit GetHeaderResponse(::google::protobuf::Arena* arena); GetHeaderResponse(::google::protobuf::Arena* arena, const GetHeaderResponse& from); GetHeaderResponse(::google::protobuf::Arena* arena, GetHeaderResponse&& from) noexcept : GetHeaderResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHeaderFieldNumber = 1, }; // optional .execution.Header header = 1; bool has_header() const; void clear_header() ; const ::execution::Header& header() const; PROTOBUF_NODISCARD ::execution::Header* release_header(); ::execution::Header* mutable_header(); void set_allocated_header(::execution::Header* value); void unsafe_arena_set_allocated_header(::execution::Header* value); ::execution::Header* unsafe_arena_release_header(); private: const ::execution::Header& _internal_header() const; ::execution::Header* _internal_mutable_header(); public: // @@protoc_insertion_point(class_scope:execution.GetHeaderResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetHeaderResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetHeaderResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::execution::Header* header_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class BlockBody final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.BlockBody) */ { public: inline BlockBody() : BlockBody(nullptr) {} ~BlockBody() override; template explicit PROTOBUF_CONSTEXPR BlockBody( ::google::protobuf::internal::ConstantInitialized); inline BlockBody(const BlockBody& from) : BlockBody(nullptr, from) {} inline BlockBody(BlockBody&& from) noexcept : BlockBody(nullptr, std::move(from)) {} inline BlockBody& operator=(const BlockBody& from) { CopyFrom(from); return *this; } inline BlockBody& operator=(BlockBody&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BlockBody& default_instance() { return *internal_default_instance(); } static inline const BlockBody* internal_default_instance() { return reinterpret_cast( &_BlockBody_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(BlockBody& a, BlockBody& b) { a.Swap(&b); } inline void Swap(BlockBody* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BlockBody* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BlockBody* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BlockBody& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BlockBody& from) { BlockBody::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BlockBody* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.BlockBody"; } protected: explicit BlockBody(::google::protobuf::Arena* arena); BlockBody(::google::protobuf::Arena* arena, const BlockBody& from); BlockBody(::google::protobuf::Arena* arena, BlockBody&& from) noexcept : BlockBody(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTransactionsFieldNumber = 3, kUnclesFieldNumber = 4, kWithdrawalsFieldNumber = 5, kBlockHashFieldNumber = 1, kBlockNumberFieldNumber = 2, }; // repeated bytes transactions = 3; int transactions_size() const; private: int _internal_transactions_size() const; public: void clear_transactions() ; const std::string& transactions(int index) const; std::string* mutable_transactions(int index); void set_transactions(int index, const std::string& value); void set_transactions(int index, std::string&& value); void set_transactions(int index, const char* value); void set_transactions(int index, const void* value, std::size_t size); void set_transactions(int index, absl::string_view value); std::string* add_transactions(); void add_transactions(const std::string& value); void add_transactions(std::string&& value); void add_transactions(const char* value); void add_transactions(const void* value, std::size_t size); void add_transactions(absl::string_view value); const ::google::protobuf::RepeatedPtrField& transactions() const; ::google::protobuf::RepeatedPtrField* mutable_transactions(); private: const ::google::protobuf::RepeatedPtrField& _internal_transactions() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_transactions(); public: // repeated .execution.Header uncles = 4; int uncles_size() const; private: int _internal_uncles_size() const; public: void clear_uncles() ; ::execution::Header* mutable_uncles(int index); ::google::protobuf::RepeatedPtrField<::execution::Header>* mutable_uncles(); private: const ::google::protobuf::RepeatedPtrField<::execution::Header>& _internal_uncles() const; ::google::protobuf::RepeatedPtrField<::execution::Header>* _internal_mutable_uncles(); public: const ::execution::Header& uncles(int index) const; ::execution::Header* add_uncles(); const ::google::protobuf::RepeatedPtrField<::execution::Header>& uncles() const; // repeated .types.Withdrawal withdrawals = 5; int withdrawals_size() const; private: int _internal_withdrawals_size() const; public: void clear_withdrawals() ; ::types::Withdrawal* mutable_withdrawals(int index); ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* mutable_withdrawals(); private: const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& _internal_withdrawals() const; ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* _internal_mutable_withdrawals(); public: const ::types::Withdrawal& withdrawals(int index) const; ::types::Withdrawal* add_withdrawals(); const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& withdrawals() const; // .types.H256 block_hash = 1; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // uint64 block_number = 2; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:execution.BlockBody) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 5, 3, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BlockBody_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BlockBody& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField transactions_; ::google::protobuf::RepeatedPtrField< ::execution::Header > uncles_; ::google::protobuf::RepeatedPtrField< ::types::Withdrawal > withdrawals_; ::types::H256* block_hash_; ::uint64_t block_number_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class AssembledBlockData final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.AssembledBlockData) */ { public: inline AssembledBlockData() : AssembledBlockData(nullptr) {} ~AssembledBlockData() override; template explicit PROTOBUF_CONSTEXPR AssembledBlockData( ::google::protobuf::internal::ConstantInitialized); inline AssembledBlockData(const AssembledBlockData& from) : AssembledBlockData(nullptr, from) {} inline AssembledBlockData(AssembledBlockData&& from) noexcept : AssembledBlockData(nullptr, std::move(from)) {} inline AssembledBlockData& operator=(const AssembledBlockData& from) { CopyFrom(from); return *this; } inline AssembledBlockData& operator=(AssembledBlockData&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AssembledBlockData& default_instance() { return *internal_default_instance(); } static inline const AssembledBlockData* internal_default_instance() { return reinterpret_cast( &_AssembledBlockData_default_instance_); } static constexpr int kIndexInFileMessages = 18; friend void swap(AssembledBlockData& a, AssembledBlockData& b) { a.Swap(&b); } inline void Swap(AssembledBlockData* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AssembledBlockData* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AssembledBlockData* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AssembledBlockData& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AssembledBlockData& from) { AssembledBlockData::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AssembledBlockData* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.AssembledBlockData"; } protected: explicit AssembledBlockData(::google::protobuf::Arena* arena); AssembledBlockData(::google::protobuf::Arena* arena, const AssembledBlockData& from); AssembledBlockData(::google::protobuf::Arena* arena, AssembledBlockData&& from) noexcept : AssembledBlockData(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kExecutionPayloadFieldNumber = 1, kBlockValueFieldNumber = 2, kBlobsBundleFieldNumber = 3, kRequestsFieldNumber = 4, }; // .types.ExecutionPayload execution_payload = 1; bool has_execution_payload() const; void clear_execution_payload() ; const ::types::ExecutionPayload& execution_payload() const; PROTOBUF_NODISCARD ::types::ExecutionPayload* release_execution_payload(); ::types::ExecutionPayload* mutable_execution_payload(); void set_allocated_execution_payload(::types::ExecutionPayload* value); void unsafe_arena_set_allocated_execution_payload(::types::ExecutionPayload* value); ::types::ExecutionPayload* unsafe_arena_release_execution_payload(); private: const ::types::ExecutionPayload& _internal_execution_payload() const; ::types::ExecutionPayload* _internal_mutable_execution_payload(); public: // .types.H256 block_value = 2; bool has_block_value() const; void clear_block_value() ; const ::types::H256& block_value() const; PROTOBUF_NODISCARD ::types::H256* release_block_value(); ::types::H256* mutable_block_value(); void set_allocated_block_value(::types::H256* value); void unsafe_arena_set_allocated_block_value(::types::H256* value); ::types::H256* unsafe_arena_release_block_value(); private: const ::types::H256& _internal_block_value() const; ::types::H256* _internal_mutable_block_value(); public: // .types.BlobsBundleV1 blobs_bundle = 3; bool has_blobs_bundle() const; void clear_blobs_bundle() ; const ::types::BlobsBundleV1& blobs_bundle() const; PROTOBUF_NODISCARD ::types::BlobsBundleV1* release_blobs_bundle(); ::types::BlobsBundleV1* mutable_blobs_bundle(); void set_allocated_blobs_bundle(::types::BlobsBundleV1* value); void unsafe_arena_set_allocated_blobs_bundle(::types::BlobsBundleV1* value); ::types::BlobsBundleV1* unsafe_arena_release_blobs_bundle(); private: const ::types::BlobsBundleV1& _internal_blobs_bundle() const; ::types::BlobsBundleV1* _internal_mutable_blobs_bundle(); public: // .types.RequestsBundle requests = 4; bool has_requests() const; void clear_requests() ; const ::types::RequestsBundle& requests() const; PROTOBUF_NODISCARD ::types::RequestsBundle* release_requests(); ::types::RequestsBundle* mutable_requests(); void set_allocated_requests(::types::RequestsBundle* value); void unsafe_arena_set_allocated_requests(::types::RequestsBundle* value); ::types::RequestsBundle* unsafe_arena_release_requests(); private: const ::types::RequestsBundle& _internal_requests() const; ::types::RequestsBundle* _internal_mutable_requests(); public: // @@protoc_insertion_point(class_scope:execution.AssembledBlockData) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 4, 4, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AssembledBlockData_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AssembledBlockData& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::ExecutionPayload* execution_payload_; ::types::H256* block_value_; ::types::BlobsBundleV1* blobs_bundle_; ::types::RequestsBundle* requests_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetBodyResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetBodyResponse) */ { public: inline GetBodyResponse() : GetBodyResponse(nullptr) {} ~GetBodyResponse() override; template explicit PROTOBUF_CONSTEXPR GetBodyResponse( ::google::protobuf::internal::ConstantInitialized); inline GetBodyResponse(const GetBodyResponse& from) : GetBodyResponse(nullptr, from) {} inline GetBodyResponse(GetBodyResponse&& from) noexcept : GetBodyResponse(nullptr, std::move(from)) {} inline GetBodyResponse& operator=(const GetBodyResponse& from) { CopyFrom(from); return *this; } inline GetBodyResponse& operator=(GetBodyResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetBodyResponse& default_instance() { return *internal_default_instance(); } static inline const GetBodyResponse* internal_default_instance() { return reinterpret_cast( &_GetBodyResponse_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(GetBodyResponse& a, GetBodyResponse& b) { a.Swap(&b); } inline void Swap(GetBodyResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetBodyResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetBodyResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetBodyResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetBodyResponse& from) { GetBodyResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetBodyResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetBodyResponse"; } protected: explicit GetBodyResponse(::google::protobuf::Arena* arena); GetBodyResponse(::google::protobuf::Arena* arena, const GetBodyResponse& from); GetBodyResponse(::google::protobuf::Arena* arena, GetBodyResponse&& from) noexcept : GetBodyResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBodyFieldNumber = 1, }; // optional .execution.BlockBody body = 1; bool has_body() const; void clear_body() ; const ::execution::BlockBody& body() const; PROTOBUF_NODISCARD ::execution::BlockBody* release_body(); ::execution::BlockBody* mutable_body(); void set_allocated_body(::execution::BlockBody* value); void unsafe_arena_set_allocated_body(::execution::BlockBody* value); ::execution::BlockBody* unsafe_arena_release_body(); private: const ::execution::BlockBody& _internal_body() const; ::execution::BlockBody* _internal_mutable_body(); public: // @@protoc_insertion_point(class_scope:execution.GetBodyResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetBodyResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetBodyResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::execution::BlockBody* body_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetBodiesBatchResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetBodiesBatchResponse) */ { public: inline GetBodiesBatchResponse() : GetBodiesBatchResponse(nullptr) {} ~GetBodiesBatchResponse() override; template explicit PROTOBUF_CONSTEXPR GetBodiesBatchResponse( ::google::protobuf::internal::ConstantInitialized); inline GetBodiesBatchResponse(const GetBodiesBatchResponse& from) : GetBodiesBatchResponse(nullptr, from) {} inline GetBodiesBatchResponse(GetBodiesBatchResponse&& from) noexcept : GetBodiesBatchResponse(nullptr, std::move(from)) {} inline GetBodiesBatchResponse& operator=(const GetBodiesBatchResponse& from) { CopyFrom(from); return *this; } inline GetBodiesBatchResponse& operator=(GetBodiesBatchResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetBodiesBatchResponse& default_instance() { return *internal_default_instance(); } static inline const GetBodiesBatchResponse* internal_default_instance() { return reinterpret_cast( &_GetBodiesBatchResponse_default_instance_); } static constexpr int kIndexInFileMessages = 20; friend void swap(GetBodiesBatchResponse& a, GetBodiesBatchResponse& b) { a.Swap(&b); } inline void Swap(GetBodiesBatchResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetBodiesBatchResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetBodiesBatchResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetBodiesBatchResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetBodiesBatchResponse& from) { GetBodiesBatchResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetBodiesBatchResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetBodiesBatchResponse"; } protected: explicit GetBodiesBatchResponse(::google::protobuf::Arena* arena); GetBodiesBatchResponse(::google::protobuf::Arena* arena, const GetBodiesBatchResponse& from); GetBodiesBatchResponse(::google::protobuf::Arena* arena, GetBodiesBatchResponse&& from) noexcept : GetBodiesBatchResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBodiesFieldNumber = 1, }; // repeated .execution.BlockBody bodies = 1; int bodies_size() const; private: int _internal_bodies_size() const; public: void clear_bodies() ; ::execution::BlockBody* mutable_bodies(int index); ::google::protobuf::RepeatedPtrField<::execution::BlockBody>* mutable_bodies(); private: const ::google::protobuf::RepeatedPtrField<::execution::BlockBody>& _internal_bodies() const; ::google::protobuf::RepeatedPtrField<::execution::BlockBody>* _internal_mutable_bodies(); public: const ::execution::BlockBody& bodies(int index) const; ::execution::BlockBody* add_bodies(); const ::google::protobuf::RepeatedPtrField<::execution::BlockBody>& bodies() const; // @@protoc_insertion_point(class_scope:execution.GetBodiesBatchResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetBodiesBatchResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetBodiesBatchResponse& from_msg); ::google::protobuf::RepeatedPtrField< ::execution::BlockBody > bodies_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class GetAssembledBlockResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.GetAssembledBlockResponse) */ { public: inline GetAssembledBlockResponse() : GetAssembledBlockResponse(nullptr) {} ~GetAssembledBlockResponse() override; template explicit PROTOBUF_CONSTEXPR GetAssembledBlockResponse( ::google::protobuf::internal::ConstantInitialized); inline GetAssembledBlockResponse(const GetAssembledBlockResponse& from) : GetAssembledBlockResponse(nullptr, from) {} inline GetAssembledBlockResponse(GetAssembledBlockResponse&& from) noexcept : GetAssembledBlockResponse(nullptr, std::move(from)) {} inline GetAssembledBlockResponse& operator=(const GetAssembledBlockResponse& from) { CopyFrom(from); return *this; } inline GetAssembledBlockResponse& operator=(GetAssembledBlockResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetAssembledBlockResponse& default_instance() { return *internal_default_instance(); } static inline const GetAssembledBlockResponse* internal_default_instance() { return reinterpret_cast( &_GetAssembledBlockResponse_default_instance_); } static constexpr int kIndexInFileMessages = 19; friend void swap(GetAssembledBlockResponse& a, GetAssembledBlockResponse& b) { a.Swap(&b); } inline void Swap(GetAssembledBlockResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetAssembledBlockResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetAssembledBlockResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetAssembledBlockResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetAssembledBlockResponse& from) { GetAssembledBlockResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetAssembledBlockResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.GetAssembledBlockResponse"; } protected: explicit GetAssembledBlockResponse(::google::protobuf::Arena* arena); GetAssembledBlockResponse(::google::protobuf::Arena* arena, const GetAssembledBlockResponse& from); GetAssembledBlockResponse(::google::protobuf::Arena* arena, GetAssembledBlockResponse&& from) noexcept : GetAssembledBlockResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 1, kBusyFieldNumber = 2, }; // optional .execution.AssembledBlockData data = 1; bool has_data() const; void clear_data() ; const ::execution::AssembledBlockData& data() const; PROTOBUF_NODISCARD ::execution::AssembledBlockData* release_data(); ::execution::AssembledBlockData* mutable_data(); void set_allocated_data(::execution::AssembledBlockData* value); void unsafe_arena_set_allocated_data(::execution::AssembledBlockData* value); ::execution::AssembledBlockData* unsafe_arena_release_data(); private: const ::execution::AssembledBlockData& _internal_data() const; ::execution::AssembledBlockData* _internal_mutable_data(); public: // bool busy = 2; void clear_busy() ; bool busy() const; void set_busy(bool value); private: bool _internal_busy() const; void _internal_set_busy(bool value); public: // @@protoc_insertion_point(class_scope:execution.GetAssembledBlockResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetAssembledBlockResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetAssembledBlockResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::execution::AssembledBlockData* data_; bool busy_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class Block final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.Block) */ { public: inline Block() : Block(nullptr) {} ~Block() override; template explicit PROTOBUF_CONSTEXPR Block( ::google::protobuf::internal::ConstantInitialized); inline Block(const Block& from) : Block(nullptr, from) {} inline Block(Block&& from) noexcept : Block(nullptr, std::move(from)) {} inline Block& operator=(const Block& from) { CopyFrom(from); return *this; } inline Block& operator=(Block&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Block& default_instance() { return *internal_default_instance(); } static inline const Block* internal_default_instance() { return reinterpret_cast( &_Block_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(Block& a, Block& b) { a.Swap(&b); } inline void Swap(Block* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Block* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Block* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Block& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Block& from) { Block::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Block* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.Block"; } protected: explicit Block(::google::protobuf::Arena* arena); Block(::google::protobuf::Arena* arena, const Block& from); Block(::google::protobuf::Arena* arena, Block&& from) noexcept : Block(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHeaderFieldNumber = 1, kBodyFieldNumber = 2, }; // .execution.Header header = 1; bool has_header() const; void clear_header() ; const ::execution::Header& header() const; PROTOBUF_NODISCARD ::execution::Header* release_header(); ::execution::Header* mutable_header(); void set_allocated_header(::execution::Header* value); void unsafe_arena_set_allocated_header(::execution::Header* value); ::execution::Header* unsafe_arena_release_header(); private: const ::execution::Header& _internal_header() const; ::execution::Header* _internal_mutable_header(); public: // .execution.BlockBody body = 2; bool has_body() const; void clear_body() ; const ::execution::BlockBody& body() const; PROTOBUF_NODISCARD ::execution::BlockBody* release_body(); ::execution::BlockBody* mutable_body(); void set_allocated_body(::execution::BlockBody* value); void unsafe_arena_set_allocated_body(::execution::BlockBody* value); ::execution::BlockBody* unsafe_arena_release_body(); private: const ::execution::BlockBody& _internal_body() const; ::execution::BlockBody* _internal_mutable_body(); public: // @@protoc_insertion_point(class_scope:execution.Block) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Block_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Block& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::execution::Header* header_; ::execution::BlockBody* body_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // ------------------------------------------------------------------- class InsertBlocksRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:execution.InsertBlocksRequest) */ { public: inline InsertBlocksRequest() : InsertBlocksRequest(nullptr) {} ~InsertBlocksRequest() override; template explicit PROTOBUF_CONSTEXPR InsertBlocksRequest( ::google::protobuf::internal::ConstantInitialized); inline InsertBlocksRequest(const InsertBlocksRequest& from) : InsertBlocksRequest(nullptr, from) {} inline InsertBlocksRequest(InsertBlocksRequest&& from) noexcept : InsertBlocksRequest(nullptr, std::move(from)) {} inline InsertBlocksRequest& operator=(const InsertBlocksRequest& from) { CopyFrom(from); return *this; } inline InsertBlocksRequest& operator=(InsertBlocksRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const InsertBlocksRequest& default_instance() { return *internal_default_instance(); } static inline const InsertBlocksRequest* internal_default_instance() { return reinterpret_cast( &_InsertBlocksRequest_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(InsertBlocksRequest& a, InsertBlocksRequest& b) { a.Swap(&b); } inline void Swap(InsertBlocksRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(InsertBlocksRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- InsertBlocksRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const InsertBlocksRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const InsertBlocksRequest& from) { InsertBlocksRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(InsertBlocksRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "execution.InsertBlocksRequest"; } protected: explicit InsertBlocksRequest(::google::protobuf::Arena* arena); InsertBlocksRequest(::google::protobuf::Arena* arena, const InsertBlocksRequest& from); InsertBlocksRequest(::google::protobuf::Arena* arena, InsertBlocksRequest&& from) noexcept : InsertBlocksRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlocksFieldNumber = 1, }; // repeated .execution.Block blocks = 1; int blocks_size() const; private: int _internal_blocks_size() const; public: void clear_blocks() ; ::execution::Block* mutable_blocks(int index); ::google::protobuf::RepeatedPtrField<::execution::Block>* mutable_blocks(); private: const ::google::protobuf::RepeatedPtrField<::execution::Block>& _internal_blocks() const; ::google::protobuf::RepeatedPtrField<::execution::Block>* _internal_mutable_blocks(); public: const ::execution::Block& blocks(int index) const; ::execution::Block* add_blocks(); const ::google::protobuf::RepeatedPtrField<::execution::Block>& blocks() const; // @@protoc_insertion_point(class_scope:execution.InsertBlocksRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_InsertBlocksRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const InsertBlocksRequest& from_msg); ::google::protobuf::RepeatedPtrField< ::execution::Block > blocks_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_execution_2fexecution_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // ForkChoiceReceipt // .execution.ExecutionStatus status = 1; inline void ForkChoiceReceipt::clear_status() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.status_ = 0; } inline ::execution::ExecutionStatus ForkChoiceReceipt::status() const { // @@protoc_insertion_point(field_get:execution.ForkChoiceReceipt.status) return _internal_status(); } inline void ForkChoiceReceipt::set_status(::execution::ExecutionStatus value) { _internal_set_status(value); // @@protoc_insertion_point(field_set:execution.ForkChoiceReceipt.status) } inline ::execution::ExecutionStatus ForkChoiceReceipt::_internal_status() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::execution::ExecutionStatus>(_impl_.status_); } inline void ForkChoiceReceipt::_internal_set_status(::execution::ExecutionStatus value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.status_ = value; } // .types.H256 latest_valid_hash = 2; inline bool ForkChoiceReceipt::has_latest_valid_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.latest_valid_hash_ != nullptr); return value; } inline const ::types::H256& ForkChoiceReceipt::_internal_latest_valid_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.latest_valid_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ForkChoiceReceipt::latest_valid_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ForkChoiceReceipt.latest_valid_hash) return _internal_latest_valid_hash(); } inline void ForkChoiceReceipt::unsafe_arena_set_allocated_latest_valid_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.latest_valid_hash_); } _impl_.latest_valid_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.ForkChoiceReceipt.latest_valid_hash) } inline ::types::H256* ForkChoiceReceipt::release_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.latest_valid_hash_; _impl_.latest_valid_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ForkChoiceReceipt::unsafe_arena_release_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ForkChoiceReceipt.latest_valid_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.latest_valid_hash_; _impl_.latest_valid_hash_ = nullptr; return temp; } inline ::types::H256* ForkChoiceReceipt::_internal_mutable_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.latest_valid_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.latest_valid_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.latest_valid_hash_; } inline ::types::H256* ForkChoiceReceipt::mutable_latest_valid_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_latest_valid_hash(); // @@protoc_insertion_point(field_mutable:execution.ForkChoiceReceipt.latest_valid_hash) return _msg; } inline void ForkChoiceReceipt::set_allocated_latest_valid_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.latest_valid_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.latest_valid_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.ForkChoiceReceipt.latest_valid_hash) } // string validation_error = 3; inline void ForkChoiceReceipt::clear_validation_error() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.ClearToEmpty(); } inline const std::string& ForkChoiceReceipt::validation_error() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ForkChoiceReceipt.validation_error) return _internal_validation_error(); } template inline PROTOBUF_ALWAYS_INLINE void ForkChoiceReceipt::set_validation_error(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:execution.ForkChoiceReceipt.validation_error) } inline std::string* ForkChoiceReceipt::mutable_validation_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_validation_error(); // @@protoc_insertion_point(field_mutable:execution.ForkChoiceReceipt.validation_error) return _s; } inline const std::string& ForkChoiceReceipt::_internal_validation_error() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.validation_error_.Get(); } inline void ForkChoiceReceipt::_internal_set_validation_error(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.Set(value, GetArena()); } inline std::string* ForkChoiceReceipt::_internal_mutable_validation_error() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.validation_error_.Mutable( GetArena()); } inline std::string* ForkChoiceReceipt::release_validation_error() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ForkChoiceReceipt.validation_error) return _impl_.validation_error_.Release(); } inline void ForkChoiceReceipt::set_allocated_validation_error(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.validation_error_.IsDefault()) { _impl_.validation_error_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:execution.ForkChoiceReceipt.validation_error) } // ------------------------------------------------------------------- // ValidationReceipt // .execution.ExecutionStatus validation_status = 1; inline void ValidationReceipt::clear_validation_status() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_status_ = 0; } inline ::execution::ExecutionStatus ValidationReceipt::validation_status() const { // @@protoc_insertion_point(field_get:execution.ValidationReceipt.validation_status) return _internal_validation_status(); } inline void ValidationReceipt::set_validation_status(::execution::ExecutionStatus value) { _internal_set_validation_status(value); // @@protoc_insertion_point(field_set:execution.ValidationReceipt.validation_status) } inline ::execution::ExecutionStatus ValidationReceipt::_internal_validation_status() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::execution::ExecutionStatus>(_impl_.validation_status_); } inline void ValidationReceipt::_internal_set_validation_status(::execution::ExecutionStatus value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_status_ = value; } // .types.H256 latest_valid_hash = 2; inline bool ValidationReceipt::has_latest_valid_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.latest_valid_hash_ != nullptr); return value; } inline const ::types::H256& ValidationReceipt::_internal_latest_valid_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.latest_valid_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ValidationReceipt::latest_valid_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ValidationReceipt.latest_valid_hash) return _internal_latest_valid_hash(); } inline void ValidationReceipt::unsafe_arena_set_allocated_latest_valid_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.latest_valid_hash_); } _impl_.latest_valid_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.ValidationReceipt.latest_valid_hash) } inline ::types::H256* ValidationReceipt::release_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.latest_valid_hash_; _impl_.latest_valid_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ValidationReceipt::unsafe_arena_release_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ValidationReceipt.latest_valid_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.latest_valid_hash_; _impl_.latest_valid_hash_ = nullptr; return temp; } inline ::types::H256* ValidationReceipt::_internal_mutable_latest_valid_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.latest_valid_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.latest_valid_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.latest_valid_hash_; } inline ::types::H256* ValidationReceipt::mutable_latest_valid_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_latest_valid_hash(); // @@protoc_insertion_point(field_mutable:execution.ValidationReceipt.latest_valid_hash) return _msg; } inline void ValidationReceipt::set_allocated_latest_valid_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.latest_valid_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.latest_valid_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.ValidationReceipt.latest_valid_hash) } // string validation_error = 3; inline void ValidationReceipt::clear_validation_error() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.ClearToEmpty(); } inline const std::string& ValidationReceipt::validation_error() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ValidationReceipt.validation_error) return _internal_validation_error(); } template inline PROTOBUF_ALWAYS_INLINE void ValidationReceipt::set_validation_error(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:execution.ValidationReceipt.validation_error) } inline std::string* ValidationReceipt::mutable_validation_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_validation_error(); // @@protoc_insertion_point(field_mutable:execution.ValidationReceipt.validation_error) return _s; } inline const std::string& ValidationReceipt::_internal_validation_error() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.validation_error_.Get(); } inline void ValidationReceipt::_internal_set_validation_error(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.Set(value, GetArena()); } inline std::string* ValidationReceipt::_internal_mutable_validation_error() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.validation_error_.Mutable( GetArena()); } inline std::string* ValidationReceipt::release_validation_error() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ValidationReceipt.validation_error) return _impl_.validation_error_.Release(); } inline void ValidationReceipt::set_allocated_validation_error(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validation_error_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.validation_error_.IsDefault()) { _impl_.validation_error_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:execution.ValidationReceipt.validation_error) } // ------------------------------------------------------------------- // IsCanonicalResponse // bool canonical = 1; inline void IsCanonicalResponse::clear_canonical() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.canonical_ = false; } inline bool IsCanonicalResponse::canonical() const { // @@protoc_insertion_point(field_get:execution.IsCanonicalResponse.canonical) return _internal_canonical(); } inline void IsCanonicalResponse::set_canonical(bool value) { _internal_set_canonical(value); // @@protoc_insertion_point(field_set:execution.IsCanonicalResponse.canonical) } inline bool IsCanonicalResponse::_internal_canonical() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.canonical_; } inline void IsCanonicalResponse::_internal_set_canonical(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.canonical_ = value; } // ------------------------------------------------------------------- // Header // .types.H256 parent_hash = 1; inline bool Header::has_parent_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.parent_hash_ != nullptr); return value; } inline const ::types::H256& Header::_internal_parent_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.parent_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::parent_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.parent_hash) return _internal_parent_hash(); } inline void Header::unsafe_arena_set_allocated_parent_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_hash_); } _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.parent_hash) } inline ::types::H256* Header::release_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* released = _impl_.parent_hash_; _impl_.parent_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.parent_hash) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* temp = _impl_.parent_hash_; _impl_.parent_hash_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.parent_hash_; } inline ::types::H256* Header::mutable_parent_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H256* _msg = _internal_mutable_parent_hash(); // @@protoc_insertion_point(field_mutable:execution.Header.parent_hash) return _msg; } inline void Header::set_allocated_parent_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.parent_hash) } // .types.H160 coinbase = 2; inline bool Header::has_coinbase() const { bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || _impl_.coinbase_ != nullptr); return value; } inline const ::types::H160& Header::_internal_coinbase() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.coinbase_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& Header::coinbase() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.coinbase) return _internal_coinbase(); } inline void Header::unsafe_arena_set_allocated_coinbase(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.coinbase_); } _impl_.coinbase_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.coinbase) } inline ::types::H160* Header::release_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000004u; ::types::H160* released = _impl_.coinbase_; _impl_.coinbase_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* Header::unsafe_arena_release_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.coinbase) _impl_._has_bits_[0] &= ~0x00000004u; ::types::H160* temp = _impl_.coinbase_; _impl_.coinbase_ = nullptr; return temp; } inline ::types::H160* Header::_internal_mutable_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.coinbase_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.coinbase_ = reinterpret_cast<::types::H160*>(p); } return _impl_.coinbase_; } inline ::types::H160* Header::mutable_coinbase() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000004u; ::types::H160* _msg = _internal_mutable_coinbase(); // @@protoc_insertion_point(field_mutable:execution.Header.coinbase) return _msg; } inline void Header::set_allocated_coinbase(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.coinbase_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } _impl_.coinbase_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.coinbase) } // .types.H256 state_root = 3; inline bool Header::has_state_root() const { bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || _impl_.state_root_ != nullptr); return value; } inline const ::types::H256& Header::_internal_state_root() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.state_root_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::state_root() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.state_root) return _internal_state_root(); } inline void Header::unsafe_arena_set_allocated_state_root(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.state_root_); } _impl_.state_root_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.state_root) } inline ::types::H256* Header::release_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000008u; ::types::H256* released = _impl_.state_root_; _impl_.state_root_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.state_root) _impl_._has_bits_[0] &= ~0x00000008u; ::types::H256* temp = _impl_.state_root_; _impl_.state_root_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.state_root_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.state_root_ = reinterpret_cast<::types::H256*>(p); } return _impl_.state_root_; } inline ::types::H256* Header::mutable_state_root() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000008u; ::types::H256* _msg = _internal_mutable_state_root(); // @@protoc_insertion_point(field_mutable:execution.Header.state_root) return _msg; } inline void Header::set_allocated_state_root(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.state_root_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } _impl_.state_root_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.state_root) } // .types.H256 receipt_root = 4; inline bool Header::has_receipt_root() const { bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; PROTOBUF_ASSUME(!value || _impl_.receipt_root_ != nullptr); return value; } inline const ::types::H256& Header::_internal_receipt_root() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.receipt_root_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::receipt_root() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.receipt_root) return _internal_receipt_root(); } inline void Header::unsafe_arena_set_allocated_receipt_root(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.receipt_root_); } _impl_.receipt_root_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000010u; } else { _impl_._has_bits_[0] &= ~0x00000010u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.receipt_root) } inline ::types::H256* Header::release_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000010u; ::types::H256* released = _impl_.receipt_root_; _impl_.receipt_root_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.receipt_root) _impl_._has_bits_[0] &= ~0x00000010u; ::types::H256* temp = _impl_.receipt_root_; _impl_.receipt_root_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.receipt_root_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.receipt_root_ = reinterpret_cast<::types::H256*>(p); } return _impl_.receipt_root_; } inline ::types::H256* Header::mutable_receipt_root() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000010u; ::types::H256* _msg = _internal_mutable_receipt_root(); // @@protoc_insertion_point(field_mutable:execution.Header.receipt_root) return _msg; } inline void Header::set_allocated_receipt_root(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.receipt_root_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000010u; } else { _impl_._has_bits_[0] &= ~0x00000010u; } _impl_.receipt_root_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.receipt_root) } // .types.H2048 logs_bloom = 5; inline bool Header::has_logs_bloom() const { bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; PROTOBUF_ASSUME(!value || _impl_.logs_bloom_ != nullptr); return value; } inline const ::types::H2048& Header::_internal_logs_bloom() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H2048* p = _impl_.logs_bloom_; return p != nullptr ? *p : reinterpret_cast(::types::_H2048_default_instance_); } inline const ::types::H2048& Header::logs_bloom() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.logs_bloom) return _internal_logs_bloom(); } inline void Header::unsafe_arena_set_allocated_logs_bloom(::types::H2048* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.logs_bloom_); } _impl_.logs_bloom_ = reinterpret_cast<::types::H2048*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000020u; } else { _impl_._has_bits_[0] &= ~0x00000020u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.logs_bloom) } inline ::types::H2048* Header::release_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000020u; ::types::H2048* released = _impl_.logs_bloom_; _impl_.logs_bloom_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H2048* Header::unsafe_arena_release_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.logs_bloom) _impl_._has_bits_[0] &= ~0x00000020u; ::types::H2048* temp = _impl_.logs_bloom_; _impl_.logs_bloom_ = nullptr; return temp; } inline ::types::H2048* Header::_internal_mutable_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.logs_bloom_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H2048>(GetArena()); _impl_.logs_bloom_ = reinterpret_cast<::types::H2048*>(p); } return _impl_.logs_bloom_; } inline ::types::H2048* Header::mutable_logs_bloom() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000020u; ::types::H2048* _msg = _internal_mutable_logs_bloom(); // @@protoc_insertion_point(field_mutable:execution.Header.logs_bloom) return _msg; } inline void Header::set_allocated_logs_bloom(::types::H2048* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.logs_bloom_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000020u; } else { _impl_._has_bits_[0] &= ~0x00000020u; } _impl_.logs_bloom_ = reinterpret_cast<::types::H2048*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.logs_bloom) } // .types.H256 prev_randao = 6; inline bool Header::has_prev_randao() const { bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; PROTOBUF_ASSUME(!value || _impl_.prev_randao_ != nullptr); return value; } inline const ::types::H256& Header::_internal_prev_randao() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.prev_randao_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::prev_randao() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.prev_randao) return _internal_prev_randao(); } inline void Header::unsafe_arena_set_allocated_prev_randao(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prev_randao_); } _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000040u; } else { _impl_._has_bits_[0] &= ~0x00000040u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.prev_randao) } inline ::types::H256* Header::release_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000040u; ::types::H256* released = _impl_.prev_randao_; _impl_.prev_randao_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.prev_randao) _impl_._has_bits_[0] &= ~0x00000040u; ::types::H256* temp = _impl_.prev_randao_; _impl_.prev_randao_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.prev_randao_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(p); } return _impl_.prev_randao_; } inline ::types::H256* Header::mutable_prev_randao() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000040u; ::types::H256* _msg = _internal_mutable_prev_randao(); // @@protoc_insertion_point(field_mutable:execution.Header.prev_randao) return _msg; } inline void Header::set_allocated_prev_randao(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prev_randao_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000040u; } else { _impl_._has_bits_[0] &= ~0x00000040u; } _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.prev_randao) } // uint64 block_number = 7; inline void Header::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t Header::block_number() const { // @@protoc_insertion_point(field_get:execution.Header.block_number) return _internal_block_number(); } inline void Header::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:execution.Header.block_number) } inline ::uint64_t Header::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void Header::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // uint64 gas_limit = 8; inline void Header::clear_gas_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_limit_ = ::uint64_t{0u}; } inline ::uint64_t Header::gas_limit() const { // @@protoc_insertion_point(field_get:execution.Header.gas_limit) return _internal_gas_limit(); } inline void Header::set_gas_limit(::uint64_t value) { _internal_set_gas_limit(value); // @@protoc_insertion_point(field_set:execution.Header.gas_limit) } inline ::uint64_t Header::_internal_gas_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.gas_limit_; } inline void Header::_internal_set_gas_limit(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_limit_ = value; } // uint64 gas_used = 9; inline void Header::clear_gas_used() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_used_ = ::uint64_t{0u}; } inline ::uint64_t Header::gas_used() const { // @@protoc_insertion_point(field_get:execution.Header.gas_used) return _internal_gas_used(); } inline void Header::set_gas_used(::uint64_t value) { _internal_set_gas_used(value); // @@protoc_insertion_point(field_set:execution.Header.gas_used) } inline ::uint64_t Header::_internal_gas_used() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.gas_used_; } inline void Header::_internal_set_gas_used(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_used_ = value; } // uint64 timestamp = 10; inline void Header::clear_timestamp() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = ::uint64_t{0u}; } inline ::uint64_t Header::timestamp() const { // @@protoc_insertion_point(field_get:execution.Header.timestamp) return _internal_timestamp(); } inline void Header::set_timestamp(::uint64_t value) { _internal_set_timestamp(value); // @@protoc_insertion_point(field_set:execution.Header.timestamp) } inline ::uint64_t Header::_internal_timestamp() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.timestamp_; } inline void Header::_internal_set_timestamp(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = value; } // uint64 nonce = 11; inline void Header::clear_nonce() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nonce_ = ::uint64_t{0u}; } inline ::uint64_t Header::nonce() const { // @@protoc_insertion_point(field_get:execution.Header.nonce) return _internal_nonce(); } inline void Header::set_nonce(::uint64_t value) { _internal_set_nonce(value); // @@protoc_insertion_point(field_set:execution.Header.nonce) } inline ::uint64_t Header::_internal_nonce() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nonce_; } inline void Header::_internal_set_nonce(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nonce_ = value; } // bytes extra_data = 12; inline void Header::clear_extra_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.ClearToEmpty(); } inline const std::string& Header::extra_data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.extra_data) return _internal_extra_data(); } template inline PROTOBUF_ALWAYS_INLINE void Header::set_extra_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:execution.Header.extra_data) } inline std::string* Header::mutable_extra_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_extra_data(); // @@protoc_insertion_point(field_mutable:execution.Header.extra_data) return _s; } inline const std::string& Header::_internal_extra_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.extra_data_.Get(); } inline void Header::_internal_set_extra_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.Set(value, GetArena()); } inline std::string* Header::_internal_mutable_extra_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.extra_data_.Mutable( GetArena()); } inline std::string* Header::release_extra_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.extra_data) return _impl_.extra_data_.Release(); } inline void Header::set_allocated_extra_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.extra_data_.IsDefault()) { _impl_.extra_data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:execution.Header.extra_data) } // .types.H256 difficulty = 13; inline bool Header::has_difficulty() const { bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; PROTOBUF_ASSUME(!value || _impl_.difficulty_ != nullptr); return value; } inline const ::types::H256& Header::_internal_difficulty() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.difficulty_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::difficulty() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.difficulty) return _internal_difficulty(); } inline void Header::unsafe_arena_set_allocated_difficulty(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.difficulty_); } _impl_.difficulty_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000080u; } else { _impl_._has_bits_[0] &= ~0x00000080u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.difficulty) } inline ::types::H256* Header::release_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000080u; ::types::H256* released = _impl_.difficulty_; _impl_.difficulty_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.difficulty) _impl_._has_bits_[0] &= ~0x00000080u; ::types::H256* temp = _impl_.difficulty_; _impl_.difficulty_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.difficulty_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.difficulty_ = reinterpret_cast<::types::H256*>(p); } return _impl_.difficulty_; } inline ::types::H256* Header::mutable_difficulty() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000080u; ::types::H256* _msg = _internal_mutable_difficulty(); // @@protoc_insertion_point(field_mutable:execution.Header.difficulty) return _msg; } inline void Header::set_allocated_difficulty(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.difficulty_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000080u; } else { _impl_._has_bits_[0] &= ~0x00000080u; } _impl_.difficulty_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.difficulty) } // .types.H256 block_hash = 14; inline bool Header::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline const ::types::H256& Header::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.block_hash) return _internal_block_hash(); } inline void Header::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000100u; } else { _impl_._has_bits_[0] &= ~0x00000100u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.block_hash) } inline ::types::H256* Header::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000100u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.block_hash) _impl_._has_bits_[0] &= ~0x00000100u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* Header::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000100u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:execution.Header.block_hash) return _msg; } inline void Header::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000100u; } else { _impl_._has_bits_[0] &= ~0x00000100u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.block_hash) } // .types.H256 ommer_hash = 15; inline bool Header::has_ommer_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; PROTOBUF_ASSUME(!value || _impl_.ommer_hash_ != nullptr); return value; } inline const ::types::H256& Header::_internal_ommer_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.ommer_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::ommer_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.ommer_hash) return _internal_ommer_hash(); } inline void Header::unsafe_arena_set_allocated_ommer_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.ommer_hash_); } _impl_.ommer_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000200u; } else { _impl_._has_bits_[0] &= ~0x00000200u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.ommer_hash) } inline ::types::H256* Header::release_ommer_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000200u; ::types::H256* released = _impl_.ommer_hash_; _impl_.ommer_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_ommer_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.ommer_hash) _impl_._has_bits_[0] &= ~0x00000200u; ::types::H256* temp = _impl_.ommer_hash_; _impl_.ommer_hash_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_ommer_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.ommer_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.ommer_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.ommer_hash_; } inline ::types::H256* Header::mutable_ommer_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000200u; ::types::H256* _msg = _internal_mutable_ommer_hash(); // @@protoc_insertion_point(field_mutable:execution.Header.ommer_hash) return _msg; } inline void Header::set_allocated_ommer_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.ommer_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000200u; } else { _impl_._has_bits_[0] &= ~0x00000200u; } _impl_.ommer_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.ommer_hash) } // .types.H256 transaction_hash = 16; inline bool Header::has_transaction_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; PROTOBUF_ASSUME(!value || _impl_.transaction_hash_ != nullptr); return value; } inline const ::types::H256& Header::_internal_transaction_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.transaction_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::transaction_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.transaction_hash) return _internal_transaction_hash(); } inline void Header::unsafe_arena_set_allocated_transaction_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.transaction_hash_); } _impl_.transaction_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000400u; } else { _impl_._has_bits_[0] &= ~0x00000400u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.transaction_hash) } inline ::types::H256* Header::release_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000400u; ::types::H256* released = _impl_.transaction_hash_; _impl_.transaction_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.transaction_hash) _impl_._has_bits_[0] &= ~0x00000400u; ::types::H256* temp = _impl_.transaction_hash_; _impl_.transaction_hash_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.transaction_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.transaction_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.transaction_hash_; } inline ::types::H256* Header::mutable_transaction_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000400u; ::types::H256* _msg = _internal_mutable_transaction_hash(); // @@protoc_insertion_point(field_mutable:execution.Header.transaction_hash) return _msg; } inline void Header::set_allocated_transaction_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.transaction_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000400u; } else { _impl_._has_bits_[0] &= ~0x00000400u; } _impl_.transaction_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.transaction_hash) } // optional .types.H256 base_fee_per_gas = 17; inline bool Header::has_base_fee_per_gas() const { bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; PROTOBUF_ASSUME(!value || _impl_.base_fee_per_gas_ != nullptr); return value; } inline const ::types::H256& Header::_internal_base_fee_per_gas() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.base_fee_per_gas_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::base_fee_per_gas() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.base_fee_per_gas) return _internal_base_fee_per_gas(); } inline void Header::unsafe_arena_set_allocated_base_fee_per_gas(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.base_fee_per_gas_); } _impl_.base_fee_per_gas_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000800u; } else { _impl_._has_bits_[0] &= ~0x00000800u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.base_fee_per_gas) } inline ::types::H256* Header::release_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000800u; ::types::H256* released = _impl_.base_fee_per_gas_; _impl_.base_fee_per_gas_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.base_fee_per_gas) _impl_._has_bits_[0] &= ~0x00000800u; ::types::H256* temp = _impl_.base_fee_per_gas_; _impl_.base_fee_per_gas_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.base_fee_per_gas_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.base_fee_per_gas_ = reinterpret_cast<::types::H256*>(p); } return _impl_.base_fee_per_gas_; } inline ::types::H256* Header::mutable_base_fee_per_gas() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000800u; ::types::H256* _msg = _internal_mutable_base_fee_per_gas(); // @@protoc_insertion_point(field_mutable:execution.Header.base_fee_per_gas) return _msg; } inline void Header::set_allocated_base_fee_per_gas(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.base_fee_per_gas_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000800u; } else { _impl_._has_bits_[0] &= ~0x00000800u; } _impl_.base_fee_per_gas_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.base_fee_per_gas) } // optional .types.H256 withdrawal_hash = 18; inline bool Header::has_withdrawal_hash() const { bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; PROTOBUF_ASSUME(!value || _impl_.withdrawal_hash_ != nullptr); return value; } inline const ::types::H256& Header::_internal_withdrawal_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.withdrawal_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::withdrawal_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.withdrawal_hash) return _internal_withdrawal_hash(); } inline void Header::unsafe_arena_set_allocated_withdrawal_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.withdrawal_hash_); } _impl_.withdrawal_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00001000u; } else { _impl_._has_bits_[0] &= ~0x00001000u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.withdrawal_hash) } inline ::types::H256* Header::release_withdrawal_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00001000u; ::types::H256* released = _impl_.withdrawal_hash_; _impl_.withdrawal_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_withdrawal_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.withdrawal_hash) _impl_._has_bits_[0] &= ~0x00001000u; ::types::H256* temp = _impl_.withdrawal_hash_; _impl_.withdrawal_hash_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_withdrawal_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.withdrawal_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.withdrawal_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.withdrawal_hash_; } inline ::types::H256* Header::mutable_withdrawal_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00001000u; ::types::H256* _msg = _internal_mutable_withdrawal_hash(); // @@protoc_insertion_point(field_mutable:execution.Header.withdrawal_hash) return _msg; } inline void Header::set_allocated_withdrawal_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.withdrawal_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00001000u; } else { _impl_._has_bits_[0] &= ~0x00001000u; } _impl_.withdrawal_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.withdrawal_hash) } // optional uint64 blob_gas_used = 19; inline bool Header::has_blob_gas_used() const { bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; return value; } inline void Header::clear_blob_gas_used() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blob_gas_used_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00008000u; } inline ::uint64_t Header::blob_gas_used() const { // @@protoc_insertion_point(field_get:execution.Header.blob_gas_used) return _internal_blob_gas_used(); } inline void Header::set_blob_gas_used(::uint64_t value) { _internal_set_blob_gas_used(value); _impl_._has_bits_[0] |= 0x00008000u; // @@protoc_insertion_point(field_set:execution.Header.blob_gas_used) } inline ::uint64_t Header::_internal_blob_gas_used() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.blob_gas_used_; } inline void Header::_internal_set_blob_gas_used(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blob_gas_used_ = value; } // optional uint64 excess_blob_gas = 20; inline bool Header::has_excess_blob_gas() const { bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; return value; } inline void Header::clear_excess_blob_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.excess_blob_gas_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00010000u; } inline ::uint64_t Header::excess_blob_gas() const { // @@protoc_insertion_point(field_get:execution.Header.excess_blob_gas) return _internal_excess_blob_gas(); } inline void Header::set_excess_blob_gas(::uint64_t value) { _internal_set_excess_blob_gas(value); _impl_._has_bits_[0] |= 0x00010000u; // @@protoc_insertion_point(field_set:execution.Header.excess_blob_gas) } inline ::uint64_t Header::_internal_excess_blob_gas() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.excess_blob_gas_; } inline void Header::_internal_set_excess_blob_gas(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.excess_blob_gas_ = value; } // optional .types.H256 parent_beacon_block_root = 21; inline bool Header::has_parent_beacon_block_root() const { bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; PROTOBUF_ASSUME(!value || _impl_.parent_beacon_block_root_ != nullptr); return value; } inline const ::types::H256& Header::_internal_parent_beacon_block_root() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.parent_beacon_block_root_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::parent_beacon_block_root() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.parent_beacon_block_root) return _internal_parent_beacon_block_root(); } inline void Header::unsafe_arena_set_allocated_parent_beacon_block_root(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_beacon_block_root_); } _impl_.parent_beacon_block_root_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00002000u; } else { _impl_._has_bits_[0] &= ~0x00002000u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.parent_beacon_block_root) } inline ::types::H256* Header::release_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00002000u; ::types::H256* released = _impl_.parent_beacon_block_root_; _impl_.parent_beacon_block_root_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.parent_beacon_block_root) _impl_._has_bits_[0] &= ~0x00002000u; ::types::H256* temp = _impl_.parent_beacon_block_root_; _impl_.parent_beacon_block_root_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_beacon_block_root_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.parent_beacon_block_root_ = reinterpret_cast<::types::H256*>(p); } return _impl_.parent_beacon_block_root_; } inline ::types::H256* Header::mutable_parent_beacon_block_root() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00002000u; ::types::H256* _msg = _internal_mutable_parent_beacon_block_root(); // @@protoc_insertion_point(field_mutable:execution.Header.parent_beacon_block_root) return _msg; } inline void Header::set_allocated_parent_beacon_block_root(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_beacon_block_root_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00002000u; } else { _impl_._has_bits_[0] &= ~0x00002000u; } _impl_.parent_beacon_block_root_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.parent_beacon_block_root) } // optional .types.H256 requests_hash = 22; inline bool Header::has_requests_hash() const { bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; PROTOBUF_ASSUME(!value || _impl_.requests_hash_ != nullptr); return value; } inline const ::types::H256& Header::_internal_requests_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.requests_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Header::requests_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.requests_hash) return _internal_requests_hash(); } inline void Header::unsafe_arena_set_allocated_requests_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.requests_hash_); } _impl_.requests_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00004000u; } else { _impl_._has_bits_[0] &= ~0x00004000u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Header.requests_hash) } inline ::types::H256* Header::release_requests_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00004000u; ::types::H256* released = _impl_.requests_hash_; _impl_.requests_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Header::unsafe_arena_release_requests_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.requests_hash) _impl_._has_bits_[0] &= ~0x00004000u; ::types::H256* temp = _impl_.requests_hash_; _impl_.requests_hash_ = nullptr; return temp; } inline ::types::H256* Header::_internal_mutable_requests_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.requests_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.requests_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.requests_hash_; } inline ::types::H256* Header::mutable_requests_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00004000u; ::types::H256* _msg = _internal_mutable_requests_hash(); // @@protoc_insertion_point(field_mutable:execution.Header.requests_hash) return _msg; } inline void Header::set_allocated_requests_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.requests_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00004000u; } else { _impl_._has_bits_[0] &= ~0x00004000u; } _impl_.requests_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Header.requests_hash) } // optional uint64 aura_step = 23; inline bool Header::has_aura_step() const { bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; return value; } inline void Header::clear_aura_step() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.aura_step_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00020000u; } inline ::uint64_t Header::aura_step() const { // @@protoc_insertion_point(field_get:execution.Header.aura_step) return _internal_aura_step(); } inline void Header::set_aura_step(::uint64_t value) { _internal_set_aura_step(value); _impl_._has_bits_[0] |= 0x00020000u; // @@protoc_insertion_point(field_set:execution.Header.aura_step) } inline ::uint64_t Header::_internal_aura_step() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.aura_step_; } inline void Header::_internal_set_aura_step(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.aura_step_ = value; } // optional bytes aura_seal = 24; inline bool Header::has_aura_seal() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; return value; } inline void Header::clear_aura_seal() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.aura_seal_.ClearToEmpty(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const std::string& Header::aura_seal() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Header.aura_seal) return _internal_aura_seal(); } template inline PROTOBUF_ALWAYS_INLINE void Header::set_aura_seal(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] |= 0x00000001u; _impl_.aura_seal_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:execution.Header.aura_seal) } inline std::string* Header::mutable_aura_seal() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_aura_seal(); // @@protoc_insertion_point(field_mutable:execution.Header.aura_seal) return _s; } inline const std::string& Header::_internal_aura_seal() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.aura_seal_.Get(); } inline void Header::_internal_set_aura_seal(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] |= 0x00000001u; _impl_.aura_seal_.Set(value, GetArena()); } inline std::string* Header::_internal_mutable_aura_seal() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] |= 0x00000001u; return _impl_.aura_seal_.Mutable( GetArena()); } inline std::string* Header::release_aura_seal() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Header.aura_seal) if ((_impl_._has_bits_[0] & 0x00000001u) == 0) { return nullptr; } _impl_._has_bits_[0] &= ~0x00000001u; auto* released = _impl_.aura_seal_.Release(); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING _impl_.aura_seal_.Set("", GetArena()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING return released; } inline void Header::set_allocated_aura_seal(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.aura_seal_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.aura_seal_.IsDefault()) { _impl_.aura_seal_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:execution.Header.aura_seal) } // ------------------------------------------------------------------- // BlockBody // .types.H256 block_hash = 1; inline bool BlockBody::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline const ::types::H256& BlockBody::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& BlockBody::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.BlockBody.block_hash) return _internal_block_hash(); } inline void BlockBody::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.BlockBody.block_hash) } inline ::types::H256* BlockBody::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* BlockBody::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.BlockBody.block_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* BlockBody::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* BlockBody::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:execution.BlockBody.block_hash) return _msg; } inline void BlockBody::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.BlockBody.block_hash) } // uint64 block_number = 2; inline void BlockBody::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t BlockBody::block_number() const { // @@protoc_insertion_point(field_get:execution.BlockBody.block_number) return _internal_block_number(); } inline void BlockBody::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:execution.BlockBody.block_number) } inline ::uint64_t BlockBody::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void BlockBody::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // repeated bytes transactions = 3; inline int BlockBody::_internal_transactions_size() const { return _internal_transactions().size(); } inline int BlockBody::transactions_size() const { return _internal_transactions_size(); } inline void BlockBody::clear_transactions() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.transactions_.Clear(); } inline std::string* BlockBody::add_transactions() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_transactions()->Add(); // @@protoc_insertion_point(field_add_mutable:execution.BlockBody.transactions) return _s; } inline const std::string& BlockBody::transactions(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.BlockBody.transactions) return _internal_transactions().Get(index); } inline std::string* BlockBody::mutable_transactions(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:execution.BlockBody.transactions) return _internal_mutable_transactions()->Mutable(index); } inline void BlockBody::set_transactions(int index, const std::string& value) { _internal_mutable_transactions()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:execution.BlockBody.transactions) } inline void BlockBody::set_transactions(int index, std::string&& value) { _internal_mutable_transactions()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:execution.BlockBody.transactions) } inline void BlockBody::set_transactions(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_transactions()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:execution.BlockBody.transactions) } inline void BlockBody::set_transactions(int index, const void* value, std::size_t size) { _internal_mutable_transactions()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:execution.BlockBody.transactions) } inline void BlockBody::set_transactions(int index, absl::string_view value) { _internal_mutable_transactions()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:execution.BlockBody.transactions) } inline void BlockBody::add_transactions(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value); // @@protoc_insertion_point(field_add:execution.BlockBody.transactions) } inline void BlockBody::add_transactions(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add(std::move(value)); // @@protoc_insertion_point(field_add:execution.BlockBody.transactions) } inline void BlockBody::add_transactions(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:execution.BlockBody.transactions) } inline void BlockBody::add_transactions(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:execution.BlockBody.transactions) } inline void BlockBody::add_transactions(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:execution.BlockBody.transactions) } inline const ::google::protobuf::RepeatedPtrField& BlockBody::transactions() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:execution.BlockBody.transactions) return _internal_transactions(); } inline ::google::protobuf::RepeatedPtrField* BlockBody::mutable_transactions() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:execution.BlockBody.transactions) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_transactions(); } inline const ::google::protobuf::RepeatedPtrField& BlockBody::_internal_transactions() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.transactions_; } inline ::google::protobuf::RepeatedPtrField* BlockBody::_internal_mutable_transactions() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.transactions_; } // repeated .execution.Header uncles = 4; inline int BlockBody::_internal_uncles_size() const { return _internal_uncles().size(); } inline int BlockBody::uncles_size() const { return _internal_uncles_size(); } inline void BlockBody::clear_uncles() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uncles_.Clear(); } inline ::execution::Header* BlockBody::mutable_uncles(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:execution.BlockBody.uncles) return _internal_mutable_uncles()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::execution::Header>* BlockBody::mutable_uncles() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:execution.BlockBody.uncles) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_uncles(); } inline const ::execution::Header& BlockBody::uncles(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.BlockBody.uncles) return _internal_uncles().Get(index); } inline ::execution::Header* BlockBody::add_uncles() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::execution::Header* _add = _internal_mutable_uncles()->Add(); // @@protoc_insertion_point(field_add:execution.BlockBody.uncles) return _add; } inline const ::google::protobuf::RepeatedPtrField<::execution::Header>& BlockBody::uncles() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:execution.BlockBody.uncles) return _internal_uncles(); } inline const ::google::protobuf::RepeatedPtrField<::execution::Header>& BlockBody::_internal_uncles() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.uncles_; } inline ::google::protobuf::RepeatedPtrField<::execution::Header>* BlockBody::_internal_mutable_uncles() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.uncles_; } // repeated .types.Withdrawal withdrawals = 5; inline int BlockBody::_internal_withdrawals_size() const { return _internal_withdrawals().size(); } inline int BlockBody::withdrawals_size() const { return _internal_withdrawals_size(); } inline ::types::Withdrawal* BlockBody::mutable_withdrawals(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:execution.BlockBody.withdrawals) return _internal_mutable_withdrawals()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* BlockBody::mutable_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:execution.BlockBody.withdrawals) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_withdrawals(); } inline const ::types::Withdrawal& BlockBody::withdrawals(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.BlockBody.withdrawals) return _internal_withdrawals().Get(index); } inline ::types::Withdrawal* BlockBody::add_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::Withdrawal* _add = _internal_mutable_withdrawals()->Add(); // @@protoc_insertion_point(field_add:execution.BlockBody.withdrawals) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& BlockBody::withdrawals() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:execution.BlockBody.withdrawals) return _internal_withdrawals(); } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& BlockBody::_internal_withdrawals() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.withdrawals_; } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* BlockBody::_internal_mutable_withdrawals() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.withdrawals_; } // ------------------------------------------------------------------- // Block // .execution.Header header = 1; inline bool Block::has_header() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr); return value; } inline void Block::clear_header() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.header_ != nullptr) _impl_.header_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::execution::Header& Block::_internal_header() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::execution::Header* p = _impl_.header_; return p != nullptr ? *p : reinterpret_cast(::execution::_Header_default_instance_); } inline const ::execution::Header& Block::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Block.header) return _internal_header(); } inline void Block::unsafe_arena_set_allocated_header(::execution::Header* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.header_); } _impl_.header_ = reinterpret_cast<::execution::Header*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Block.header) } inline ::execution::Header* Block::release_header() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::execution::Header* released = _impl_.header_; _impl_.header_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::execution::Header* Block::unsafe_arena_release_header() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Block.header) _impl_._has_bits_[0] &= ~0x00000001u; ::execution::Header* temp = _impl_.header_; _impl_.header_ = nullptr; return temp; } inline ::execution::Header* Block::_internal_mutable_header() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.header_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::execution::Header>(GetArena()); _impl_.header_ = reinterpret_cast<::execution::Header*>(p); } return _impl_.header_; } inline ::execution::Header* Block::mutable_header() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::execution::Header* _msg = _internal_mutable_header(); // @@protoc_insertion_point(field_mutable:execution.Block.header) return _msg; } inline void Block::set_allocated_header(::execution::Header* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.header_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.header_ = reinterpret_cast<::execution::Header*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Block.header) } // .execution.BlockBody body = 2; inline bool Block::has_body() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); return value; } inline void Block::clear_body() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ != nullptr) _impl_.body_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } inline const ::execution::BlockBody& Block::_internal_body() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::execution::BlockBody* p = _impl_.body_; return p != nullptr ? *p : reinterpret_cast(::execution::_BlockBody_default_instance_); } inline const ::execution::BlockBody& Block::body() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.Block.body) return _internal_body(); } inline void Block::unsafe_arena_set_allocated_body(::execution::BlockBody* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } _impl_.body_ = reinterpret_cast<::execution::BlockBody*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.Block.body) } inline ::execution::BlockBody* Block::release_body() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::execution::BlockBody* released = _impl_.body_; _impl_.body_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::execution::BlockBody* Block::unsafe_arena_release_body() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.Block.body) _impl_._has_bits_[0] &= ~0x00000002u; ::execution::BlockBody* temp = _impl_.body_; _impl_.body_ = nullptr; return temp; } inline ::execution::BlockBody* Block::_internal_mutable_body() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::execution::BlockBody>(GetArena()); _impl_.body_ = reinterpret_cast<::execution::BlockBody*>(p); } return _impl_.body_; } inline ::execution::BlockBody* Block::mutable_body() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::execution::BlockBody* _msg = _internal_mutable_body(); // @@protoc_insertion_point(field_mutable:execution.Block.body) return _msg; } inline void Block::set_allocated_body(::execution::BlockBody* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.body_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.body_ = reinterpret_cast<::execution::BlockBody*>(value); // @@protoc_insertion_point(field_set_allocated:execution.Block.body) } // ------------------------------------------------------------------- // GetHeaderResponse // optional .execution.Header header = 1; inline bool GetHeaderResponse::has_header() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr); return value; } inline void GetHeaderResponse::clear_header() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.header_ != nullptr) _impl_.header_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::execution::Header& GetHeaderResponse::_internal_header() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::execution::Header* p = _impl_.header_; return p != nullptr ? *p : reinterpret_cast(::execution::_Header_default_instance_); } inline const ::execution::Header& GetHeaderResponse::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.GetHeaderResponse.header) return _internal_header(); } inline void GetHeaderResponse::unsafe_arena_set_allocated_header(::execution::Header* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.header_); } _impl_.header_ = reinterpret_cast<::execution::Header*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.GetHeaderResponse.header) } inline ::execution::Header* GetHeaderResponse::release_header() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::execution::Header* released = _impl_.header_; _impl_.header_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::execution::Header* GetHeaderResponse::unsafe_arena_release_header() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.GetHeaderResponse.header) _impl_._has_bits_[0] &= ~0x00000001u; ::execution::Header* temp = _impl_.header_; _impl_.header_ = nullptr; return temp; } inline ::execution::Header* GetHeaderResponse::_internal_mutable_header() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.header_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::execution::Header>(GetArena()); _impl_.header_ = reinterpret_cast<::execution::Header*>(p); } return _impl_.header_; } inline ::execution::Header* GetHeaderResponse::mutable_header() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::execution::Header* _msg = _internal_mutable_header(); // @@protoc_insertion_point(field_mutable:execution.GetHeaderResponse.header) return _msg; } inline void GetHeaderResponse::set_allocated_header(::execution::Header* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.header_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.header_ = reinterpret_cast<::execution::Header*>(value); // @@protoc_insertion_point(field_set_allocated:execution.GetHeaderResponse.header) } // ------------------------------------------------------------------- // GetTDResponse // optional .types.H256 td = 1; inline bool GetTDResponse::has_td() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.td_ != nullptr); return value; } inline const ::types::H256& GetTDResponse::_internal_td() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.td_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& GetTDResponse::td() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.GetTDResponse.td) return _internal_td(); } inline void GetTDResponse::unsafe_arena_set_allocated_td(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.td_); } _impl_.td_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.GetTDResponse.td) } inline ::types::H256* GetTDResponse::release_td() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.td_; _impl_.td_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* GetTDResponse::unsafe_arena_release_td() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.GetTDResponse.td) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.td_; _impl_.td_ = nullptr; return temp; } inline ::types::H256* GetTDResponse::_internal_mutable_td() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.td_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.td_ = reinterpret_cast<::types::H256*>(p); } return _impl_.td_; } inline ::types::H256* GetTDResponse::mutable_td() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_td(); // @@protoc_insertion_point(field_mutable:execution.GetTDResponse.td) return _msg; } inline void GetTDResponse::set_allocated_td(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.td_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.td_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.GetTDResponse.td) } // ------------------------------------------------------------------- // GetBodyResponse // optional .execution.BlockBody body = 1; inline bool GetBodyResponse::has_body() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); return value; } inline void GetBodyResponse::clear_body() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ != nullptr) _impl_.body_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::execution::BlockBody& GetBodyResponse::_internal_body() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::execution::BlockBody* p = _impl_.body_; return p != nullptr ? *p : reinterpret_cast(::execution::_BlockBody_default_instance_); } inline const ::execution::BlockBody& GetBodyResponse::body() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.GetBodyResponse.body) return _internal_body(); } inline void GetBodyResponse::unsafe_arena_set_allocated_body(::execution::BlockBody* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.body_); } _impl_.body_ = reinterpret_cast<::execution::BlockBody*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.GetBodyResponse.body) } inline ::execution::BlockBody* GetBodyResponse::release_body() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::execution::BlockBody* released = _impl_.body_; _impl_.body_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::execution::BlockBody* GetBodyResponse::unsafe_arena_release_body() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.GetBodyResponse.body) _impl_._has_bits_[0] &= ~0x00000001u; ::execution::BlockBody* temp = _impl_.body_; _impl_.body_ = nullptr; return temp; } inline ::execution::BlockBody* GetBodyResponse::_internal_mutable_body() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.body_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::execution::BlockBody>(GetArena()); _impl_.body_ = reinterpret_cast<::execution::BlockBody*>(p); } return _impl_.body_; } inline ::execution::BlockBody* GetBodyResponse::mutable_body() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::execution::BlockBody* _msg = _internal_mutable_body(); // @@protoc_insertion_point(field_mutable:execution.GetBodyResponse.body) return _msg; } inline void GetBodyResponse::set_allocated_body(::execution::BlockBody* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.body_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.body_ = reinterpret_cast<::execution::BlockBody*>(value); // @@protoc_insertion_point(field_set_allocated:execution.GetBodyResponse.body) } // ------------------------------------------------------------------- // GetHeaderHashNumberResponse // optional uint64 block_number = 1; inline bool GetHeaderHashNumberResponse::has_block_number() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; return value; } inline void GetHeaderHashNumberResponse::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00000001u; } inline ::uint64_t GetHeaderHashNumberResponse::block_number() const { // @@protoc_insertion_point(field_get:execution.GetHeaderHashNumberResponse.block_number) return _internal_block_number(); } inline void GetHeaderHashNumberResponse::set_block_number(::uint64_t value) { _internal_set_block_number(value); _impl_._has_bits_[0] |= 0x00000001u; // @@protoc_insertion_point(field_set:execution.GetHeaderHashNumberResponse.block_number) } inline ::uint64_t GetHeaderHashNumberResponse::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void GetHeaderHashNumberResponse::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // ------------------------------------------------------------------- // GetSegmentRequest // optional uint64 block_number = 1; inline bool GetSegmentRequest::has_block_number() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; return value; } inline void GetSegmentRequest::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00000002u; } inline ::uint64_t GetSegmentRequest::block_number() const { // @@protoc_insertion_point(field_get:execution.GetSegmentRequest.block_number) return _internal_block_number(); } inline void GetSegmentRequest::set_block_number(::uint64_t value) { _internal_set_block_number(value); _impl_._has_bits_[0] |= 0x00000002u; // @@protoc_insertion_point(field_set:execution.GetSegmentRequest.block_number) } inline ::uint64_t GetSegmentRequest::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void GetSegmentRequest::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // optional .types.H256 block_hash = 2; inline bool GetSegmentRequest::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline const ::types::H256& GetSegmentRequest::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& GetSegmentRequest::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.GetSegmentRequest.block_hash) return _internal_block_hash(); } inline void GetSegmentRequest::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.GetSegmentRequest.block_hash) } inline ::types::H256* GetSegmentRequest::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* GetSegmentRequest::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.GetSegmentRequest.block_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* GetSegmentRequest::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* GetSegmentRequest::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:execution.GetSegmentRequest.block_hash) return _msg; } inline void GetSegmentRequest::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.GetSegmentRequest.block_hash) } // ------------------------------------------------------------------- // InsertBlocksRequest // repeated .execution.Block blocks = 1; inline int InsertBlocksRequest::_internal_blocks_size() const { return _internal_blocks().size(); } inline int InsertBlocksRequest::blocks_size() const { return _internal_blocks_size(); } inline void InsertBlocksRequest::clear_blocks() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blocks_.Clear(); } inline ::execution::Block* InsertBlocksRequest::mutable_blocks(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:execution.InsertBlocksRequest.blocks) return _internal_mutable_blocks()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::execution::Block>* InsertBlocksRequest::mutable_blocks() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:execution.InsertBlocksRequest.blocks) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_blocks(); } inline const ::execution::Block& InsertBlocksRequest::blocks(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.InsertBlocksRequest.blocks) return _internal_blocks().Get(index); } inline ::execution::Block* InsertBlocksRequest::add_blocks() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::execution::Block* _add = _internal_mutable_blocks()->Add(); // @@protoc_insertion_point(field_add:execution.InsertBlocksRequest.blocks) return _add; } inline const ::google::protobuf::RepeatedPtrField<::execution::Block>& InsertBlocksRequest::blocks() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:execution.InsertBlocksRequest.blocks) return _internal_blocks(); } inline const ::google::protobuf::RepeatedPtrField<::execution::Block>& InsertBlocksRequest::_internal_blocks() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.blocks_; } inline ::google::protobuf::RepeatedPtrField<::execution::Block>* InsertBlocksRequest::_internal_mutable_blocks() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.blocks_; } // ------------------------------------------------------------------- // ForkChoice // .types.H256 head_block_hash = 1; inline bool ForkChoice::has_head_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.head_block_hash_ != nullptr); return value; } inline const ::types::H256& ForkChoice::_internal_head_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.head_block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ForkChoice::head_block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ForkChoice.head_block_hash) return _internal_head_block_hash(); } inline void ForkChoice::unsafe_arena_set_allocated_head_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.head_block_hash_); } _impl_.head_block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.ForkChoice.head_block_hash) } inline ::types::H256* ForkChoice::release_head_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.head_block_hash_; _impl_.head_block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ForkChoice::unsafe_arena_release_head_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ForkChoice.head_block_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.head_block_hash_; _impl_.head_block_hash_ = nullptr; return temp; } inline ::types::H256* ForkChoice::_internal_mutable_head_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.head_block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.head_block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.head_block_hash_; } inline ::types::H256* ForkChoice::mutable_head_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_head_block_hash(); // @@protoc_insertion_point(field_mutable:execution.ForkChoice.head_block_hash) return _msg; } inline void ForkChoice::set_allocated_head_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.head_block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.head_block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.ForkChoice.head_block_hash) } // uint64 timeout = 2; inline void ForkChoice::clear_timeout() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timeout_ = ::uint64_t{0u}; } inline ::uint64_t ForkChoice::timeout() const { // @@protoc_insertion_point(field_get:execution.ForkChoice.timeout) return _internal_timeout(); } inline void ForkChoice::set_timeout(::uint64_t value) { _internal_set_timeout(value); // @@protoc_insertion_point(field_set:execution.ForkChoice.timeout) } inline ::uint64_t ForkChoice::_internal_timeout() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.timeout_; } inline void ForkChoice::_internal_set_timeout(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timeout_ = value; } // optional .types.H256 finalized_block_hash = 3; inline bool ForkChoice::has_finalized_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.finalized_block_hash_ != nullptr); return value; } inline const ::types::H256& ForkChoice::_internal_finalized_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.finalized_block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ForkChoice::finalized_block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ForkChoice.finalized_block_hash) return _internal_finalized_block_hash(); } inline void ForkChoice::unsafe_arena_set_allocated_finalized_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.finalized_block_hash_); } _impl_.finalized_block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.ForkChoice.finalized_block_hash) } inline ::types::H256* ForkChoice::release_finalized_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* released = _impl_.finalized_block_hash_; _impl_.finalized_block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ForkChoice::unsafe_arena_release_finalized_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ForkChoice.finalized_block_hash) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* temp = _impl_.finalized_block_hash_; _impl_.finalized_block_hash_ = nullptr; return temp; } inline ::types::H256* ForkChoice::_internal_mutable_finalized_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.finalized_block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.finalized_block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.finalized_block_hash_; } inline ::types::H256* ForkChoice::mutable_finalized_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H256* _msg = _internal_mutable_finalized_block_hash(); // @@protoc_insertion_point(field_mutable:execution.ForkChoice.finalized_block_hash) return _msg; } inline void ForkChoice::set_allocated_finalized_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.finalized_block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.finalized_block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.ForkChoice.finalized_block_hash) } // optional .types.H256 safe_block_hash = 4; inline bool ForkChoice::has_safe_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || _impl_.safe_block_hash_ != nullptr); return value; } inline const ::types::H256& ForkChoice::_internal_safe_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.safe_block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ForkChoice::safe_block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ForkChoice.safe_block_hash) return _internal_safe_block_hash(); } inline void ForkChoice::unsafe_arena_set_allocated_safe_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.safe_block_hash_); } _impl_.safe_block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.ForkChoice.safe_block_hash) } inline ::types::H256* ForkChoice::release_safe_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000004u; ::types::H256* released = _impl_.safe_block_hash_; _impl_.safe_block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ForkChoice::unsafe_arena_release_safe_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ForkChoice.safe_block_hash) _impl_._has_bits_[0] &= ~0x00000004u; ::types::H256* temp = _impl_.safe_block_hash_; _impl_.safe_block_hash_ = nullptr; return temp; } inline ::types::H256* ForkChoice::_internal_mutable_safe_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.safe_block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.safe_block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.safe_block_hash_; } inline ::types::H256* ForkChoice::mutable_safe_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000004u; ::types::H256* _msg = _internal_mutable_safe_block_hash(); // @@protoc_insertion_point(field_mutable:execution.ForkChoice.safe_block_hash) return _msg; } inline void ForkChoice::set_allocated_safe_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.safe_block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } _impl_.safe_block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.ForkChoice.safe_block_hash) } // ------------------------------------------------------------------- // InsertionResult // .execution.ExecutionStatus result = 1; inline void InsertionResult::clear_result() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.result_ = 0; } inline ::execution::ExecutionStatus InsertionResult::result() const { // @@protoc_insertion_point(field_get:execution.InsertionResult.result) return _internal_result(); } inline void InsertionResult::set_result(::execution::ExecutionStatus value) { _internal_set_result(value); // @@protoc_insertion_point(field_set:execution.InsertionResult.result) } inline ::execution::ExecutionStatus InsertionResult::_internal_result() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::execution::ExecutionStatus>(_impl_.result_); } inline void InsertionResult::_internal_set_result(::execution::ExecutionStatus value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.result_ = value; } // ------------------------------------------------------------------- // ValidationRequest // .types.H256 hash = 1; inline bool ValidationRequest::has_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hash_ != nullptr); return value; } inline const ::types::H256& ValidationRequest::_internal_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ValidationRequest::hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.ValidationRequest.hash) return _internal_hash(); } inline void ValidationRequest::unsafe_arena_set_allocated_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hash_); } _impl_.hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.ValidationRequest.hash) } inline ::types::H256* ValidationRequest::release_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.hash_; _impl_.hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ValidationRequest::unsafe_arena_release_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.ValidationRequest.hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.hash_; _impl_.hash_ = nullptr; return temp; } inline ::types::H256* ValidationRequest::_internal_mutable_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.hash_; } inline ::types::H256* ValidationRequest::mutable_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_hash(); // @@protoc_insertion_point(field_mutable:execution.ValidationRequest.hash) return _msg; } inline void ValidationRequest::set_allocated_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.ValidationRequest.hash) } // uint64 number = 2; inline void ValidationRequest::clear_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.number_ = ::uint64_t{0u}; } inline ::uint64_t ValidationRequest::number() const { // @@protoc_insertion_point(field_get:execution.ValidationRequest.number) return _internal_number(); } inline void ValidationRequest::set_number(::uint64_t value) { _internal_set_number(value); // @@protoc_insertion_point(field_set:execution.ValidationRequest.number) } inline ::uint64_t ValidationRequest::_internal_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.number_; } inline void ValidationRequest::_internal_set_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.number_ = value; } // ------------------------------------------------------------------- // AssembleBlockRequest // .types.H256 parent_hash = 1; inline bool AssembleBlockRequest::has_parent_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.parent_hash_ != nullptr); return value; } inline const ::types::H256& AssembleBlockRequest::_internal_parent_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.parent_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& AssembleBlockRequest::parent_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembleBlockRequest.parent_hash) return _internal_parent_hash(); } inline void AssembleBlockRequest::unsafe_arena_set_allocated_parent_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_hash_); } _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembleBlockRequest.parent_hash) } inline ::types::H256* AssembleBlockRequest::release_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.parent_hash_; _impl_.parent_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* AssembleBlockRequest::unsafe_arena_release_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembleBlockRequest.parent_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.parent_hash_; _impl_.parent_hash_ = nullptr; return temp; } inline ::types::H256* AssembleBlockRequest::_internal_mutable_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.parent_hash_; } inline ::types::H256* AssembleBlockRequest::mutable_parent_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_parent_hash(); // @@protoc_insertion_point(field_mutable:execution.AssembleBlockRequest.parent_hash) return _msg; } inline void AssembleBlockRequest::set_allocated_parent_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembleBlockRequest.parent_hash) } // uint64 timestamp = 2; inline void AssembleBlockRequest::clear_timestamp() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = ::uint64_t{0u}; } inline ::uint64_t AssembleBlockRequest::timestamp() const { // @@protoc_insertion_point(field_get:execution.AssembleBlockRequest.timestamp) return _internal_timestamp(); } inline void AssembleBlockRequest::set_timestamp(::uint64_t value) { _internal_set_timestamp(value); // @@protoc_insertion_point(field_set:execution.AssembleBlockRequest.timestamp) } inline ::uint64_t AssembleBlockRequest::_internal_timestamp() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.timestamp_; } inline void AssembleBlockRequest::_internal_set_timestamp(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = value; } // .types.H256 prev_randao = 3; inline bool AssembleBlockRequest::has_prev_randao() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.prev_randao_ != nullptr); return value; } inline const ::types::H256& AssembleBlockRequest::_internal_prev_randao() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.prev_randao_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& AssembleBlockRequest::prev_randao() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembleBlockRequest.prev_randao) return _internal_prev_randao(); } inline void AssembleBlockRequest::unsafe_arena_set_allocated_prev_randao(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prev_randao_); } _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembleBlockRequest.prev_randao) } inline ::types::H256* AssembleBlockRequest::release_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* released = _impl_.prev_randao_; _impl_.prev_randao_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* AssembleBlockRequest::unsafe_arena_release_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembleBlockRequest.prev_randao) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* temp = _impl_.prev_randao_; _impl_.prev_randao_ = nullptr; return temp; } inline ::types::H256* AssembleBlockRequest::_internal_mutable_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.prev_randao_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(p); } return _impl_.prev_randao_; } inline ::types::H256* AssembleBlockRequest::mutable_prev_randao() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H256* _msg = _internal_mutable_prev_randao(); // @@protoc_insertion_point(field_mutable:execution.AssembleBlockRequest.prev_randao) return _msg; } inline void AssembleBlockRequest::set_allocated_prev_randao(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prev_randao_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembleBlockRequest.prev_randao) } // .types.H160 suggested_fee_recipient = 4; inline bool AssembleBlockRequest::has_suggested_fee_recipient() const { bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || _impl_.suggested_fee_recipient_ != nullptr); return value; } inline const ::types::H160& AssembleBlockRequest::_internal_suggested_fee_recipient() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.suggested_fee_recipient_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& AssembleBlockRequest::suggested_fee_recipient() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembleBlockRequest.suggested_fee_recipient) return _internal_suggested_fee_recipient(); } inline void AssembleBlockRequest::unsafe_arena_set_allocated_suggested_fee_recipient(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.suggested_fee_recipient_); } _impl_.suggested_fee_recipient_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembleBlockRequest.suggested_fee_recipient) } inline ::types::H160* AssembleBlockRequest::release_suggested_fee_recipient() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000004u; ::types::H160* released = _impl_.suggested_fee_recipient_; _impl_.suggested_fee_recipient_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* AssembleBlockRequest::unsafe_arena_release_suggested_fee_recipient() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembleBlockRequest.suggested_fee_recipient) _impl_._has_bits_[0] &= ~0x00000004u; ::types::H160* temp = _impl_.suggested_fee_recipient_; _impl_.suggested_fee_recipient_ = nullptr; return temp; } inline ::types::H160* AssembleBlockRequest::_internal_mutable_suggested_fee_recipient() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.suggested_fee_recipient_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.suggested_fee_recipient_ = reinterpret_cast<::types::H160*>(p); } return _impl_.suggested_fee_recipient_; } inline ::types::H160* AssembleBlockRequest::mutable_suggested_fee_recipient() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000004u; ::types::H160* _msg = _internal_mutable_suggested_fee_recipient(); // @@protoc_insertion_point(field_mutable:execution.AssembleBlockRequest.suggested_fee_recipient) return _msg; } inline void AssembleBlockRequest::set_allocated_suggested_fee_recipient(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.suggested_fee_recipient_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } _impl_.suggested_fee_recipient_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembleBlockRequest.suggested_fee_recipient) } // repeated .types.Withdrawal withdrawals = 5; inline int AssembleBlockRequest::_internal_withdrawals_size() const { return _internal_withdrawals().size(); } inline int AssembleBlockRequest::withdrawals_size() const { return _internal_withdrawals_size(); } inline ::types::Withdrawal* AssembleBlockRequest::mutable_withdrawals(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:execution.AssembleBlockRequest.withdrawals) return _internal_mutable_withdrawals()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* AssembleBlockRequest::mutable_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:execution.AssembleBlockRequest.withdrawals) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_withdrawals(); } inline const ::types::Withdrawal& AssembleBlockRequest::withdrawals(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembleBlockRequest.withdrawals) return _internal_withdrawals().Get(index); } inline ::types::Withdrawal* AssembleBlockRequest::add_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::Withdrawal* _add = _internal_mutable_withdrawals()->Add(); // @@protoc_insertion_point(field_add:execution.AssembleBlockRequest.withdrawals) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& AssembleBlockRequest::withdrawals() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:execution.AssembleBlockRequest.withdrawals) return _internal_withdrawals(); } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& AssembleBlockRequest::_internal_withdrawals() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.withdrawals_; } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* AssembleBlockRequest::_internal_mutable_withdrawals() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.withdrawals_; } // optional .types.H256 parent_beacon_block_root = 6; inline bool AssembleBlockRequest::has_parent_beacon_block_root() const { bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || _impl_.parent_beacon_block_root_ != nullptr); return value; } inline const ::types::H256& AssembleBlockRequest::_internal_parent_beacon_block_root() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.parent_beacon_block_root_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& AssembleBlockRequest::parent_beacon_block_root() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembleBlockRequest.parent_beacon_block_root) return _internal_parent_beacon_block_root(); } inline void AssembleBlockRequest::unsafe_arena_set_allocated_parent_beacon_block_root(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_beacon_block_root_); } _impl_.parent_beacon_block_root_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembleBlockRequest.parent_beacon_block_root) } inline ::types::H256* AssembleBlockRequest::release_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000008u; ::types::H256* released = _impl_.parent_beacon_block_root_; _impl_.parent_beacon_block_root_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* AssembleBlockRequest::unsafe_arena_release_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembleBlockRequest.parent_beacon_block_root) _impl_._has_bits_[0] &= ~0x00000008u; ::types::H256* temp = _impl_.parent_beacon_block_root_; _impl_.parent_beacon_block_root_ = nullptr; return temp; } inline ::types::H256* AssembleBlockRequest::_internal_mutable_parent_beacon_block_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_beacon_block_root_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.parent_beacon_block_root_ = reinterpret_cast<::types::H256*>(p); } return _impl_.parent_beacon_block_root_; } inline ::types::H256* AssembleBlockRequest::mutable_parent_beacon_block_root() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000008u; ::types::H256* _msg = _internal_mutable_parent_beacon_block_root(); // @@protoc_insertion_point(field_mutable:execution.AssembleBlockRequest.parent_beacon_block_root) return _msg; } inline void AssembleBlockRequest::set_allocated_parent_beacon_block_root(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_beacon_block_root_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } _impl_.parent_beacon_block_root_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembleBlockRequest.parent_beacon_block_root) } // ------------------------------------------------------------------- // AssembleBlockResponse // uint64 id = 1; inline void AssembleBlockResponse::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = ::uint64_t{0u}; } inline ::uint64_t AssembleBlockResponse::id() const { // @@protoc_insertion_point(field_get:execution.AssembleBlockResponse.id) return _internal_id(); } inline void AssembleBlockResponse::set_id(::uint64_t value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:execution.AssembleBlockResponse.id) } inline ::uint64_t AssembleBlockResponse::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_; } inline void AssembleBlockResponse::_internal_set_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = value; } // bool busy = 2; inline void AssembleBlockResponse::clear_busy() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.busy_ = false; } inline bool AssembleBlockResponse::busy() const { // @@protoc_insertion_point(field_get:execution.AssembleBlockResponse.busy) return _internal_busy(); } inline void AssembleBlockResponse::set_busy(bool value) { _internal_set_busy(value); // @@protoc_insertion_point(field_set:execution.AssembleBlockResponse.busy) } inline bool AssembleBlockResponse::_internal_busy() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.busy_; } inline void AssembleBlockResponse::_internal_set_busy(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.busy_ = value; } // ------------------------------------------------------------------- // GetAssembledBlockRequest // uint64 id = 1; inline void GetAssembledBlockRequest::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = ::uint64_t{0u}; } inline ::uint64_t GetAssembledBlockRequest::id() const { // @@protoc_insertion_point(field_get:execution.GetAssembledBlockRequest.id) return _internal_id(); } inline void GetAssembledBlockRequest::set_id(::uint64_t value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:execution.GetAssembledBlockRequest.id) } inline ::uint64_t GetAssembledBlockRequest::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_; } inline void GetAssembledBlockRequest::_internal_set_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = value; } // ------------------------------------------------------------------- // AssembledBlockData // .types.ExecutionPayload execution_payload = 1; inline bool AssembledBlockData::has_execution_payload() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.execution_payload_ != nullptr); return value; } inline const ::types::ExecutionPayload& AssembledBlockData::_internal_execution_payload() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::ExecutionPayload* p = _impl_.execution_payload_; return p != nullptr ? *p : reinterpret_cast(::types::_ExecutionPayload_default_instance_); } inline const ::types::ExecutionPayload& AssembledBlockData::execution_payload() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembledBlockData.execution_payload) return _internal_execution_payload(); } inline void AssembledBlockData::unsafe_arena_set_allocated_execution_payload(::types::ExecutionPayload* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.execution_payload_); } _impl_.execution_payload_ = reinterpret_cast<::types::ExecutionPayload*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembledBlockData.execution_payload) } inline ::types::ExecutionPayload* AssembledBlockData::release_execution_payload() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::ExecutionPayload* released = _impl_.execution_payload_; _impl_.execution_payload_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::ExecutionPayload* AssembledBlockData::unsafe_arena_release_execution_payload() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembledBlockData.execution_payload) _impl_._has_bits_[0] &= ~0x00000001u; ::types::ExecutionPayload* temp = _impl_.execution_payload_; _impl_.execution_payload_ = nullptr; return temp; } inline ::types::ExecutionPayload* AssembledBlockData::_internal_mutable_execution_payload() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.execution_payload_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::ExecutionPayload>(GetArena()); _impl_.execution_payload_ = reinterpret_cast<::types::ExecutionPayload*>(p); } return _impl_.execution_payload_; } inline ::types::ExecutionPayload* AssembledBlockData::mutable_execution_payload() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::ExecutionPayload* _msg = _internal_mutable_execution_payload(); // @@protoc_insertion_point(field_mutable:execution.AssembledBlockData.execution_payload) return _msg; } inline void AssembledBlockData::set_allocated_execution_payload(::types::ExecutionPayload* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.execution_payload_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.execution_payload_ = reinterpret_cast<::types::ExecutionPayload*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembledBlockData.execution_payload) } // .types.H256 block_value = 2; inline bool AssembledBlockData::has_block_value() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_value_ != nullptr); return value; } inline const ::types::H256& AssembledBlockData::_internal_block_value() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_value_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& AssembledBlockData::block_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembledBlockData.block_value) return _internal_block_value(); } inline void AssembledBlockData::unsafe_arena_set_allocated_block_value(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_value_); } _impl_.block_value_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembledBlockData.block_value) } inline ::types::H256* AssembledBlockData::release_block_value() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* released = _impl_.block_value_; _impl_.block_value_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* AssembledBlockData::unsafe_arena_release_block_value() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembledBlockData.block_value) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* temp = _impl_.block_value_; _impl_.block_value_ = nullptr; return temp; } inline ::types::H256* AssembledBlockData::_internal_mutable_block_value() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_value_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_value_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_value_; } inline ::types::H256* AssembledBlockData::mutable_block_value() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H256* _msg = _internal_mutable_block_value(); // @@protoc_insertion_point(field_mutable:execution.AssembledBlockData.block_value) return _msg; } inline void AssembledBlockData::set_allocated_block_value(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_value_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.block_value_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembledBlockData.block_value) } // .types.BlobsBundleV1 blobs_bundle = 3; inline bool AssembledBlockData::has_blobs_bundle() const { bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || _impl_.blobs_bundle_ != nullptr); return value; } inline const ::types::BlobsBundleV1& AssembledBlockData::_internal_blobs_bundle() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::BlobsBundleV1* p = _impl_.blobs_bundle_; return p != nullptr ? *p : reinterpret_cast(::types::_BlobsBundleV1_default_instance_); } inline const ::types::BlobsBundleV1& AssembledBlockData::blobs_bundle() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembledBlockData.blobs_bundle) return _internal_blobs_bundle(); } inline void AssembledBlockData::unsafe_arena_set_allocated_blobs_bundle(::types::BlobsBundleV1* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.blobs_bundle_); } _impl_.blobs_bundle_ = reinterpret_cast<::types::BlobsBundleV1*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembledBlockData.blobs_bundle) } inline ::types::BlobsBundleV1* AssembledBlockData::release_blobs_bundle() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000004u; ::types::BlobsBundleV1* released = _impl_.blobs_bundle_; _impl_.blobs_bundle_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::BlobsBundleV1* AssembledBlockData::unsafe_arena_release_blobs_bundle() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembledBlockData.blobs_bundle) _impl_._has_bits_[0] &= ~0x00000004u; ::types::BlobsBundleV1* temp = _impl_.blobs_bundle_; _impl_.blobs_bundle_ = nullptr; return temp; } inline ::types::BlobsBundleV1* AssembledBlockData::_internal_mutable_blobs_bundle() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.blobs_bundle_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::BlobsBundleV1>(GetArena()); _impl_.blobs_bundle_ = reinterpret_cast<::types::BlobsBundleV1*>(p); } return _impl_.blobs_bundle_; } inline ::types::BlobsBundleV1* AssembledBlockData::mutable_blobs_bundle() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000004u; ::types::BlobsBundleV1* _msg = _internal_mutable_blobs_bundle(); // @@protoc_insertion_point(field_mutable:execution.AssembledBlockData.blobs_bundle) return _msg; } inline void AssembledBlockData::set_allocated_blobs_bundle(::types::BlobsBundleV1* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.blobs_bundle_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } _impl_.blobs_bundle_ = reinterpret_cast<::types::BlobsBundleV1*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembledBlockData.blobs_bundle) } // .types.RequestsBundle requests = 4; inline bool AssembledBlockData::has_requests() const { bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || _impl_.requests_ != nullptr); return value; } inline const ::types::RequestsBundle& AssembledBlockData::_internal_requests() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::RequestsBundle* p = _impl_.requests_; return p != nullptr ? *p : reinterpret_cast(::types::_RequestsBundle_default_instance_); } inline const ::types::RequestsBundle& AssembledBlockData::requests() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.AssembledBlockData.requests) return _internal_requests(); } inline void AssembledBlockData::unsafe_arena_set_allocated_requests(::types::RequestsBundle* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.requests_); } _impl_.requests_ = reinterpret_cast<::types::RequestsBundle*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.AssembledBlockData.requests) } inline ::types::RequestsBundle* AssembledBlockData::release_requests() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000008u; ::types::RequestsBundle* released = _impl_.requests_; _impl_.requests_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::RequestsBundle* AssembledBlockData::unsafe_arena_release_requests() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.AssembledBlockData.requests) _impl_._has_bits_[0] &= ~0x00000008u; ::types::RequestsBundle* temp = _impl_.requests_; _impl_.requests_ = nullptr; return temp; } inline ::types::RequestsBundle* AssembledBlockData::_internal_mutable_requests() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.requests_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::RequestsBundle>(GetArena()); _impl_.requests_ = reinterpret_cast<::types::RequestsBundle*>(p); } return _impl_.requests_; } inline ::types::RequestsBundle* AssembledBlockData::mutable_requests() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000008u; ::types::RequestsBundle* _msg = _internal_mutable_requests(); // @@protoc_insertion_point(field_mutable:execution.AssembledBlockData.requests) return _msg; } inline void AssembledBlockData::set_allocated_requests(::types::RequestsBundle* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.requests_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } _impl_.requests_ = reinterpret_cast<::types::RequestsBundle*>(value); // @@protoc_insertion_point(field_set_allocated:execution.AssembledBlockData.requests) } // ------------------------------------------------------------------- // GetAssembledBlockResponse // optional .execution.AssembledBlockData data = 1; inline bool GetAssembledBlockResponse::has_data() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline void GetAssembledBlockResponse::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::execution::AssembledBlockData& GetAssembledBlockResponse::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::execution::AssembledBlockData* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::execution::_AssembledBlockData_default_instance_); } inline const ::execution::AssembledBlockData& GetAssembledBlockResponse::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.GetAssembledBlockResponse.data) return _internal_data(); } inline void GetAssembledBlockResponse::unsafe_arena_set_allocated_data(::execution::AssembledBlockData* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::execution::AssembledBlockData*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:execution.GetAssembledBlockResponse.data) } inline ::execution::AssembledBlockData* GetAssembledBlockResponse::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::execution::AssembledBlockData* released = _impl_.data_; _impl_.data_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::execution::AssembledBlockData* GetAssembledBlockResponse::unsafe_arena_release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:execution.GetAssembledBlockResponse.data) _impl_._has_bits_[0] &= ~0x00000001u; ::execution::AssembledBlockData* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } inline ::execution::AssembledBlockData* GetAssembledBlockResponse::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::execution::AssembledBlockData>(GetArena()); _impl_.data_ = reinterpret_cast<::execution::AssembledBlockData*>(p); } return _impl_.data_; } inline ::execution::AssembledBlockData* GetAssembledBlockResponse::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::execution::AssembledBlockData* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:execution.GetAssembledBlockResponse.data) return _msg; } inline void GetAssembledBlockResponse::set_allocated_data(::execution::AssembledBlockData* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.data_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.data_ = reinterpret_cast<::execution::AssembledBlockData*>(value); // @@protoc_insertion_point(field_set_allocated:execution.GetAssembledBlockResponse.data) } // bool busy = 2; inline void GetAssembledBlockResponse::clear_busy() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.busy_ = false; } inline bool GetAssembledBlockResponse::busy() const { // @@protoc_insertion_point(field_get:execution.GetAssembledBlockResponse.busy) return _internal_busy(); } inline void GetAssembledBlockResponse::set_busy(bool value) { _internal_set_busy(value); // @@protoc_insertion_point(field_set:execution.GetAssembledBlockResponse.busy) } inline bool GetAssembledBlockResponse::_internal_busy() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.busy_; } inline void GetAssembledBlockResponse::_internal_set_busy(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.busy_ = value; } // ------------------------------------------------------------------- // GetBodiesBatchResponse // repeated .execution.BlockBody bodies = 1; inline int GetBodiesBatchResponse::_internal_bodies_size() const { return _internal_bodies().size(); } inline int GetBodiesBatchResponse::bodies_size() const { return _internal_bodies_size(); } inline void GetBodiesBatchResponse::clear_bodies() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bodies_.Clear(); } inline ::execution::BlockBody* GetBodiesBatchResponse::mutable_bodies(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:execution.GetBodiesBatchResponse.bodies) return _internal_mutable_bodies()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::execution::BlockBody>* GetBodiesBatchResponse::mutable_bodies() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:execution.GetBodiesBatchResponse.bodies) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_bodies(); } inline const ::execution::BlockBody& GetBodiesBatchResponse::bodies(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.GetBodiesBatchResponse.bodies) return _internal_bodies().Get(index); } inline ::execution::BlockBody* GetBodiesBatchResponse::add_bodies() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::execution::BlockBody* _add = _internal_mutable_bodies()->Add(); // @@protoc_insertion_point(field_add:execution.GetBodiesBatchResponse.bodies) return _add; } inline const ::google::protobuf::RepeatedPtrField<::execution::BlockBody>& GetBodiesBatchResponse::bodies() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:execution.GetBodiesBatchResponse.bodies) return _internal_bodies(); } inline const ::google::protobuf::RepeatedPtrField<::execution::BlockBody>& GetBodiesBatchResponse::_internal_bodies() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.bodies_; } inline ::google::protobuf::RepeatedPtrField<::execution::BlockBody>* GetBodiesBatchResponse::_internal_mutable_bodies() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.bodies_; } // ------------------------------------------------------------------- // GetBodiesByHashesRequest // repeated .types.H256 hashes = 1; inline int GetBodiesByHashesRequest::_internal_hashes_size() const { return _internal_hashes().size(); } inline int GetBodiesByHashesRequest::hashes_size() const { return _internal_hashes_size(); } inline ::types::H256* GetBodiesByHashesRequest::mutable_hashes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:execution.GetBodiesByHashesRequest.hashes) return _internal_mutable_hashes()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H256>* GetBodiesByHashesRequest::mutable_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:execution.GetBodiesByHashesRequest.hashes) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_hashes(); } inline const ::types::H256& GetBodiesByHashesRequest::hashes(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:execution.GetBodiesByHashesRequest.hashes) return _internal_hashes().Get(index); } inline ::types::H256* GetBodiesByHashesRequest::add_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H256* _add = _internal_mutable_hashes()->Add(); // @@protoc_insertion_point(field_add:execution.GetBodiesByHashesRequest.hashes) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& GetBodiesByHashesRequest::hashes() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:execution.GetBodiesByHashesRequest.hashes) return _internal_hashes(); } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& GetBodiesByHashesRequest::_internal_hashes() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.hashes_; } inline ::google::protobuf::RepeatedPtrField<::types::H256>* GetBodiesByHashesRequest::_internal_mutable_hashes() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.hashes_; } // ------------------------------------------------------------------- // GetBodiesByRangeRequest // uint64 start = 1; inline void GetBodiesByRangeRequest::clear_start() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.start_ = ::uint64_t{0u}; } inline ::uint64_t GetBodiesByRangeRequest::start() const { // @@protoc_insertion_point(field_get:execution.GetBodiesByRangeRequest.start) return _internal_start(); } inline void GetBodiesByRangeRequest::set_start(::uint64_t value) { _internal_set_start(value); // @@protoc_insertion_point(field_set:execution.GetBodiesByRangeRequest.start) } inline ::uint64_t GetBodiesByRangeRequest::_internal_start() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.start_; } inline void GetBodiesByRangeRequest::_internal_set_start(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.start_ = value; } // uint64 count = 2; inline void GetBodiesByRangeRequest::clear_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = ::uint64_t{0u}; } inline ::uint64_t GetBodiesByRangeRequest::count() const { // @@protoc_insertion_point(field_get:execution.GetBodiesByRangeRequest.count) return _internal_count(); } inline void GetBodiesByRangeRequest::set_count(::uint64_t value) { _internal_set_count(value); // @@protoc_insertion_point(field_set:execution.GetBodiesByRangeRequest.count) } inline ::uint64_t GetBodiesByRangeRequest::_internal_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.count_; } inline void GetBodiesByRangeRequest::_internal_set_count(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = value; } // ------------------------------------------------------------------- // ReadyResponse // bool ready = 1; inline void ReadyResponse::clear_ready() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ready_ = false; } inline bool ReadyResponse::ready() const { // @@protoc_insertion_point(field_get:execution.ReadyResponse.ready) return _internal_ready(); } inline void ReadyResponse::set_ready(bool value) { _internal_set_ready(value); // @@protoc_insertion_point(field_set:execution.ReadyResponse.ready) } inline bool ReadyResponse::_internal_ready() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ready_; } inline void ReadyResponse::_internal_set_ready(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ready_ = value; } // ------------------------------------------------------------------- // FrozenBlocksResponse // uint64 frozen_blocks = 1; inline void FrozenBlocksResponse::clear_frozen_blocks() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.frozen_blocks_ = ::uint64_t{0u}; } inline ::uint64_t FrozenBlocksResponse::frozen_blocks() const { // @@protoc_insertion_point(field_get:execution.FrozenBlocksResponse.frozen_blocks) return _internal_frozen_blocks(); } inline void FrozenBlocksResponse::set_frozen_blocks(::uint64_t value) { _internal_set_frozen_blocks(value); // @@protoc_insertion_point(field_set:execution.FrozenBlocksResponse.frozen_blocks) } inline ::uint64_t FrozenBlocksResponse::_internal_frozen_blocks() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.frozen_blocks_; } inline void FrozenBlocksResponse::_internal_set_frozen_blocks(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.frozen_blocks_ = value; } // bool has_gap = 2; inline void FrozenBlocksResponse::clear_has_gap() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.has_gap_ = false; } inline bool FrozenBlocksResponse::has_gap() const { // @@protoc_insertion_point(field_get:execution.FrozenBlocksResponse.has_gap) return _internal_has_gap(); } inline void FrozenBlocksResponse::set_has_gap(bool value) { _internal_set_has_gap(value); // @@protoc_insertion_point(field_set:execution.FrozenBlocksResponse.has_gap) } inline bool FrozenBlocksResponse::_internal_has_gap() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.has_gap_; } inline void FrozenBlocksResponse::_internal_set_has_gap(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.has_gap_ = value; } // ------------------------------------------------------------------- // HasBlockResponse // bool has_block = 1; inline void HasBlockResponse::clear_has_block() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.has_block_ = false; } inline bool HasBlockResponse::has_block() const { // @@protoc_insertion_point(field_get:execution.HasBlockResponse.has_block) return _internal_has_block(); } inline void HasBlockResponse::set_has_block(bool value) { _internal_set_has_block(value); // @@protoc_insertion_point(field_set:execution.HasBlockResponse.has_block) } inline bool HasBlockResponse::_internal_has_block() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.has_block_; } inline void HasBlockResponse::_internal_set_has_block(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.has_block_ = value; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace execution namespace google { namespace protobuf { template <> struct is_proto_enum<::execution::ExecutionStatus> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::execution::ExecutionStatus>() { return ::execution::ExecutionStatus_descriptor(); } } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_execution_2fexecution_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/27.0/execution/execution_mock.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: execution/execution.proto #ifndef GRPC_MOCK_execution_2fexecution_2eproto__INCLUDED #define GRPC_MOCK_execution_2fexecution_2eproto__INCLUDED #include "execution/execution.pb.h" #include "execution/execution.grpc.pb.h" #include #include #include namespace execution { class MockExecutionStub : public Execution::StubInterface { public: MOCK_METHOD3(InsertBlocks, ::grpc::Status(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::execution::InsertionResult* response)); MOCK_METHOD3(AsyncInsertBlocksRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>*(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncInsertBlocksRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::InsertionResult>*(::grpc::ClientContext* context, const ::execution::InsertBlocksRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(ValidateChain, ::grpc::Status(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::execution::ValidationReceipt* response)); MOCK_METHOD3(AsyncValidateChainRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>*(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncValidateChainRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ValidationReceipt>*(::grpc::ClientContext* context, const ::execution::ValidationRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(UpdateForkChoice, ::grpc::Status(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::execution::ForkChoiceReceipt* response)); MOCK_METHOD3(AsyncUpdateForkChoiceRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>*(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncUpdateForkChoiceRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoiceReceipt>*(::grpc::ClientContext* context, const ::execution::ForkChoice& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AssembleBlock, ::grpc::Status(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::execution::AssembleBlockResponse* response)); MOCK_METHOD3(AsyncAssembleBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>*(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncAssembleBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::AssembleBlockResponse>*(::grpc::ClientContext* context, const ::execution::AssembleBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetAssembledBlock, ::grpc::Status(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::execution::GetAssembledBlockResponse* response)); MOCK_METHOD3(AsyncGetAssembledBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>*(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetAssembledBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetAssembledBlockResponse>*(::grpc::ClientContext* context, const ::execution::GetAssembledBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(CurrentHeader, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::GetHeaderResponse* response)); MOCK_METHOD3(AsyncCurrentHeaderRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncCurrentHeaderRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetTD, ::grpc::Status(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetTDResponse* response)); MOCK_METHOD3(AsyncGetTDRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetTDRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetTDResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetHeader, ::grpc::Status(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetHeaderResponse* response)); MOCK_METHOD3(AsyncGetHeaderRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetHeaderRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetBody, ::grpc::Status(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::GetBodyResponse* response)); MOCK_METHOD3(AsyncGetBodyRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetBodyRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodyResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(HasBlock, ::grpc::Status(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::execution::HasBlockResponse* response)); MOCK_METHOD3(AsyncHasBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHasBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::HasBlockResponse>*(::grpc::ClientContext* context, const ::execution::GetSegmentRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetBodiesByRange, ::grpc::Status(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::execution::GetBodiesBatchResponse* response)); MOCK_METHOD3(AsyncGetBodiesByRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>*(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetBodiesByRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>*(::grpc::ClientContext* context, const ::execution::GetBodiesByRangeRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetBodiesByHashes, ::grpc::Status(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::execution::GetBodiesBatchResponse* response)); MOCK_METHOD3(AsyncGetBodiesByHashesRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>*(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetBodiesByHashesRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetBodiesBatchResponse>*(::grpc::ClientContext* context, const ::execution::GetBodiesByHashesRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(IsCanonicalHash, ::grpc::Status(::grpc::ClientContext* context, const ::types::H256& request, ::execution::IsCanonicalResponse* response)); MOCK_METHOD3(AsyncIsCanonicalHashRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>*(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncIsCanonicalHashRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::IsCanonicalResponse>*(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetHeaderHashNumber, ::grpc::Status(::grpc::ClientContext* context, const ::types::H256& request, ::execution::GetHeaderHashNumberResponse* response)); MOCK_METHOD3(AsyncGetHeaderHashNumberRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>*(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetHeaderHashNumberRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::GetHeaderHashNumberResponse>*(::grpc::ClientContext* context, const ::types::H256& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetForkChoice, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ForkChoice* response)); MOCK_METHOD3(AsyncGetForkChoiceRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetForkChoiceRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ForkChoice>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Ready, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::ReadyResponse* response)); MOCK_METHOD3(AsyncReadyRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncReadyRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::ReadyResponse>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(FrozenBlocks, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::execution::FrozenBlocksResponse* response)); MOCK_METHOD3(AsyncFrozenBlocksRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncFrozenBlocksRaw, ::grpc::ClientAsyncResponseReaderInterface< ::execution::FrozenBlocksResponse>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); }; } // namespace execution #endif // GRPC_MOCK_execution_2fexecution_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/p2psentry/sentry.grpc.pb.cc ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: p2psentry/sentry.proto #include "p2psentry/sentry.pb.h" #include "p2psentry/sentry.grpc.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace sentry { static const char* Sentry_method_names[] = { "/sentry.Sentry/SetStatus", "/sentry.Sentry/PenalizePeer", "/sentry.Sentry/PeerMinBlock", "/sentry.Sentry/HandShake", "/sentry.Sentry/SendMessageByMinBlock", "/sentry.Sentry/SendMessageById", "/sentry.Sentry/SendMessageToRandomPeers", "/sentry.Sentry/SendMessageToAll", "/sentry.Sentry/Messages", "/sentry.Sentry/Peers", "/sentry.Sentry/PeerCount", "/sentry.Sentry/PeerById", "/sentry.Sentry/PeerEvents", "/sentry.Sentry/AddPeer", "/sentry.Sentry/NodeInfo", }; std::unique_ptr< Sentry::Stub> Sentry::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< Sentry::Stub> stub(new Sentry::Stub(channel, options)); return stub; } Sentry::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_SetStatus_(Sentry_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PenalizePeer_(Sentry_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PeerMinBlock_(Sentry_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_HandShake_(Sentry_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_SendMessageByMinBlock_(Sentry_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_SendMessageById_(Sentry_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_SendMessageToRandomPeers_(Sentry_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_SendMessageToAll_(Sentry_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Messages_(Sentry_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_Peers_(Sentry_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PeerCount_(Sentry_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PeerById_(Sentry_method_names[11], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PeerEvents_(Sentry_method_names[12], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_AddPeer_(Sentry_method_names[13], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_NodeInfo_(Sentry_method_names[14], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status Sentry::Stub::SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::sentry::SetStatusReply* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::StatusData, ::sentry::SetStatusReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetStatus_, context, request, response); } void Sentry::Stub::async::SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::StatusData, ::sentry::SetStatusReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetStatus_, context, request, response, std::move(f)); } void Sentry::Stub::async::SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetStatus_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>* Sentry::Stub::PrepareAsyncSetStatusRaw(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::SetStatusReply, ::sentry::StatusData, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetStatus_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>* Sentry::Stub::AsyncSetStatusRaw(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSetStatusRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::google::protobuf::Empty* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::PenalizePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PenalizePeer_, context, request, response); } void Sentry::Stub::async::PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::PenalizePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PenalizePeer_, context, request, response, std::move(f)); } void Sentry::Stub::async::PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PenalizePeer_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* Sentry::Stub::PrepareAsyncPenalizePeerRaw(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::sentry::PenalizePeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PenalizePeer_, context, request); } ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* Sentry::Stub::AsyncPenalizePeerRaw(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPenalizePeerRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::google::protobuf::Empty* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PeerMinBlock_, context, request, response); } void Sentry::Stub::async::PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PeerMinBlock_, context, request, response, std::move(f)); } void Sentry::Stub::async::PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PeerMinBlock_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* Sentry::Stub::PrepareAsyncPeerMinBlockRaw(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::sentry::PeerMinBlockRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PeerMinBlock_, context, request); } ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* Sentry::Stub::AsyncPeerMinBlockRaw(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPeerMinBlockRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::HandShakeReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::sentry::HandShakeReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HandShake_, context, request, response); } void Sentry::Stub::async::HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::sentry::HandShakeReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HandShake_, context, request, response, std::move(f)); } void Sentry::Stub::async::HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HandShake_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>* Sentry::Stub::PrepareAsyncHandShakeRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::HandShakeReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HandShake_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>* Sentry::Stub::AsyncHandShakeRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncHandShakeRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::sentry::SentPeers* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendMessageByMinBlock_, context, request, response); } void Sentry::Stub::async::SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageByMinBlock_, context, request, response, std::move(f)); } void Sentry::Stub::async::SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageByMinBlock_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::PrepareAsyncSendMessageByMinBlockRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::SentPeers, ::sentry::SendMessageByMinBlockRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendMessageByMinBlock_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::AsyncSendMessageByMinBlockRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSendMessageByMinBlockRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::sentry::SentPeers* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::SendMessageByIdRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendMessageById_, context, request, response); } void Sentry::Stub::async::SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::SendMessageByIdRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageById_, context, request, response, std::move(f)); } void Sentry::Stub::async::SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageById_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::PrepareAsyncSendMessageByIdRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::SentPeers, ::sentry::SendMessageByIdRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendMessageById_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::AsyncSendMessageByIdRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSendMessageByIdRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::sentry::SentPeers* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendMessageToRandomPeers_, context, request, response); } void Sentry::Stub::async::SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageToRandomPeers_, context, request, response, std::move(f)); } void Sentry::Stub::async::SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageToRandomPeers_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::PrepareAsyncSendMessageToRandomPeersRaw(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::SentPeers, ::sentry::SendMessageToRandomPeersRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendMessageToRandomPeers_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::AsyncSendMessageToRandomPeersRaw(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSendMessageToRandomPeersRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::sentry::SentPeers* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::OutboundMessageData, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendMessageToAll_, context, request, response); } void Sentry::Stub::async::SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::OutboundMessageData, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageToAll_, context, request, response, std::move(f)); } void Sentry::Stub::async::SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessageToAll_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::PrepareAsyncSendMessageToAllRaw(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::SentPeers, ::sentry::OutboundMessageData, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendMessageToAll_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* Sentry::Stub::AsyncSendMessageToAllRaw(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSendMessageToAllRaw(context, request, cq); result->StartCall(); return result; } ::grpc::ClientReader< ::sentry::InboundMessage>* Sentry::Stub::MessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request) { return ::grpc::internal::ClientReaderFactory< ::sentry::InboundMessage>::Create(channel_.get(), rpcmethod_Messages_, context, request); } void Sentry::Stub::async::Messages(::grpc::ClientContext* context, const ::sentry::MessagesRequest* request, ::grpc::ClientReadReactor< ::sentry::InboundMessage>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::sentry::InboundMessage>::Create(stub_->channel_.get(), stub_->rpcmethod_Messages_, context, request, reactor); } ::grpc::ClientAsyncReader< ::sentry::InboundMessage>* Sentry::Stub::AsyncMessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::sentry::InboundMessage>::Create(channel_.get(), cq, rpcmethod_Messages_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::sentry::InboundMessage>* Sentry::Stub::PrepareAsyncMessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::sentry::InboundMessage>::Create(channel_.get(), cq, rpcmethod_Messages_, context, request, false, nullptr); } ::grpc::Status Sentry::Stub::Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::PeersReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::sentry::PeersReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Peers_, context, request, response); } void Sentry::Stub::async::Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::sentry::PeersReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Peers_, context, request, response, std::move(f)); } void Sentry::Stub::async::Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Peers_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>* Sentry::Stub::PrepareAsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::PeersReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Peers_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>* Sentry::Stub::AsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPeersRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::sentry::PeerCountReply* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::PeerCountRequest, ::sentry::PeerCountReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PeerCount_, context, request, response); } void Sentry::Stub::async::PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::PeerCountRequest, ::sentry::PeerCountReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PeerCount_, context, request, response, std::move(f)); } void Sentry::Stub::async::PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PeerCount_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>* Sentry::Stub::PrepareAsyncPeerCountRaw(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::PeerCountReply, ::sentry::PeerCountRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PeerCount_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>* Sentry::Stub::AsyncPeerCountRaw(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPeerCountRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::sentry::PeerByIdReply* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PeerById_, context, request, response); } void Sentry::Stub::async::PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PeerById_, context, request, response, std::move(f)); } void Sentry::Stub::async::PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PeerById_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>* Sentry::Stub::PrepareAsyncPeerByIdRaw(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::PeerByIdReply, ::sentry::PeerByIdRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PeerById_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>* Sentry::Stub::AsyncPeerByIdRaw(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPeerByIdRaw(context, request, cq); result->StartCall(); return result; } ::grpc::ClientReader< ::sentry::PeerEvent>* Sentry::Stub::PeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request) { return ::grpc::internal::ClientReaderFactory< ::sentry::PeerEvent>::Create(channel_.get(), rpcmethod_PeerEvents_, context, request); } void Sentry::Stub::async::PeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest* request, ::grpc::ClientReadReactor< ::sentry::PeerEvent>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::sentry::PeerEvent>::Create(stub_->channel_.get(), stub_->rpcmethod_PeerEvents_, context, request, reactor); } ::grpc::ClientAsyncReader< ::sentry::PeerEvent>* Sentry::Stub::AsyncPeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::sentry::PeerEvent>::Create(channel_.get(), cq, rpcmethod_PeerEvents_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::sentry::PeerEvent>* Sentry::Stub::PrepareAsyncPeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::sentry::PeerEvent>::Create(channel_.get(), cq, rpcmethod_PeerEvents_, context, request, false, nullptr); } ::grpc::Status Sentry::Stub::AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::sentry::AddPeerReply* response) { return ::grpc::internal::BlockingUnaryCall< ::sentry::AddPeerRequest, ::sentry::AddPeerReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddPeer_, context, request, response); } void Sentry::Stub::async::AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::sentry::AddPeerRequest, ::sentry::AddPeerReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeer_, context, request, response, std::move(f)); } void Sentry::Stub::async::AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeer_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>* Sentry::Stub::PrepareAsyncAddPeerRaw(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::sentry::AddPeerReply, ::sentry::AddPeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddPeer_, context, request); } ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>* Sentry::Stub::AsyncAddPeerRaw(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncAddPeerRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Sentry::Stub::NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::NodeInfoReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::types::NodeInfoReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_NodeInfo_, context, request, response); } void Sentry::Stub::async::NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::types::NodeInfoReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NodeInfo_, context, request, response, std::move(f)); } void Sentry::Stub::async::NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NodeInfo_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>* Sentry::Stub::PrepareAsyncNodeInfoRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::types::NodeInfoReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_NodeInfo_, context, request); } ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>* Sentry::Stub::AsyncNodeInfoRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncNodeInfoRaw(context, request, cq); result->StartCall(); return result; } Sentry::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::StatusData, ::sentry::SetStatusReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::StatusData* req, ::sentry::SetStatusReply* resp) { return service->SetStatus(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::PenalizePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::PenalizePeerRequest* req, ::google::protobuf::Empty* resp) { return service->PenalizePeer(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::PeerMinBlockRequest* req, ::google::protobuf::Empty* resp) { return service->PeerMinBlock(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::google::protobuf::Empty, ::sentry::HandShakeReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::sentry::HandShakeReply* resp) { return service->HandShake(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::SendMessageByMinBlockRequest* req, ::sentry::SentPeers* resp) { return service->SendMessageByMinBlock(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::SendMessageByIdRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::SendMessageByIdRequest* req, ::sentry::SentPeers* resp) { return service->SendMessageById(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::SendMessageToRandomPeersRequest* req, ::sentry::SentPeers* resp) { return service->SendMessageToRandomPeers(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::OutboundMessageData, ::sentry::SentPeers, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::OutboundMessageData* req, ::sentry::SentPeers* resp) { return service->SendMessageToAll(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[8], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< Sentry::Service, ::sentry::MessagesRequest, ::sentry::InboundMessage>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::MessagesRequest* req, ::grpc::ServerWriter<::sentry::InboundMessage>* writer) { return service->Messages(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::google::protobuf::Empty, ::sentry::PeersReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::sentry::PeersReply* resp) { return service->Peers(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[10], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::PeerCountRequest, ::sentry::PeerCountReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::PeerCountRequest* req, ::sentry::PeerCountReply* resp) { return service->PeerCount(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::PeerByIdRequest* req, ::sentry::PeerByIdReply* resp) { return service->PeerById(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[12], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< Sentry::Service, ::sentry::PeerEventsRequest, ::sentry::PeerEvent>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::PeerEventsRequest* req, ::grpc::ServerWriter<::sentry::PeerEvent>* writer) { return service->PeerEvents(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[13], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::sentry::AddPeerRequest, ::sentry::AddPeerReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::sentry::AddPeerRequest* req, ::sentry::AddPeerReply* resp) { return service->AddPeer(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Sentry_method_names[14], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Sentry::Service, ::google::protobuf::Empty, ::types::NodeInfoReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Sentry::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::types::NodeInfoReply* resp) { return service->NodeInfo(ctx, req, resp); }, this))); } Sentry::Service::~Service() { } ::grpc::Status Sentry::Service::SetStatus(::grpc::ServerContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::PenalizePeer(::grpc::ServerContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::PeerMinBlock(::grpc::ServerContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::HandShake(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::SendMessageByMinBlock(::grpc::ServerContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::SendMessageById(::grpc::ServerContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::SendMessageToRandomPeers(::grpc::ServerContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::SendMessageToAll(::grpc::ServerContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::Messages(::grpc::ServerContext* context, const ::sentry::MessagesRequest* request, ::grpc::ServerWriter< ::sentry::InboundMessage>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::Peers(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::PeerCount(::grpc::ServerContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::PeerById(::grpc::ServerContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::PeerEvents(::grpc::ServerContext* context, const ::sentry::PeerEventsRequest* request, ::grpc::ServerWriter< ::sentry::PeerEvent>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::AddPeer(::grpc::ServerContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Sentry::Service::NodeInfo(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } } // namespace sentry ================================================ FILE: silkworm/interfaces/27.0/p2psentry/sentry.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: p2psentry/sentry.proto #ifndef GRPC_p2psentry_2fsentry_2eproto__INCLUDED #define GRPC_p2psentry_2fsentry_2eproto__INCLUDED #include "p2psentry/sentry.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace sentry { class Sentry final { public: static constexpr char const* service_full_name() { return "sentry.Sentry"; } class StubInterface { public: virtual ~StubInterface() {} // SetStatus - force new ETH client state of sentry - network_id, max_block, etc... virtual ::grpc::Status SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::sentry::SetStatusReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>> AsyncSetStatus(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>>(AsyncSetStatusRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>> PrepareAsyncSetStatus(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>>(PrepareAsyncSetStatusRaw(context, request, cq)); } virtual ::grpc::Status PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::google::protobuf::Empty* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncPenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncPenalizePeerRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncPenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncPenalizePeerRaw(context, request, cq)); } virtual ::grpc::Status PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::google::protobuf::Empty* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncPeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncPeerMinBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncPeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncPeerMinBlockRaw(context, request, cq)); } // HandShake - pre-requirement for all Send* methods - returns list of ETH protocol versions, // without knowledge of protocol - impossible encode correct P2P message virtual ::grpc::Status HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::HandShakeReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>> AsyncHandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>>(AsyncHandShakeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>> PrepareAsyncHandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>>(PrepareAsyncHandShakeRaw(context, request, cq)); } virtual ::grpc::Status SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::sentry::SentPeers* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> AsyncSendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(AsyncSendMessageByMinBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> PrepareAsyncSendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(PrepareAsyncSendMessageByMinBlockRaw(context, request, cq)); } virtual ::grpc::Status SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::sentry::SentPeers* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> AsyncSendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(AsyncSendMessageByIdRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> PrepareAsyncSendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(PrepareAsyncSendMessageByIdRaw(context, request, cq)); } virtual ::grpc::Status SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::sentry::SentPeers* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> AsyncSendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(AsyncSendMessageToRandomPeersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> PrepareAsyncSendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(PrepareAsyncSendMessageToRandomPeersRaw(context, request, cq)); } virtual ::grpc::Status SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::sentry::SentPeers* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> AsyncSendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(AsyncSendMessageToAllRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>> PrepareAsyncSendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>>(PrepareAsyncSendMessageToAllRaw(context, request, cq)); } // Subscribe to receive messages. // Calling multiple times with a different set of ids starts separate streams. // It is possible to subscribe to the same set if ids more than once. std::unique_ptr< ::grpc::ClientReaderInterface< ::sentry::InboundMessage>> Messages(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::sentry::InboundMessage>>(MessagesRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>> AsyncMessages(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>>(AsyncMessagesRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>> PrepareAsyncMessages(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>>(PrepareAsyncMessagesRaw(context, request, cq)); } virtual ::grpc::Status Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::PeersReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>> AsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>>(AsyncPeersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>> PrepareAsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>>(PrepareAsyncPeersRaw(context, request, cq)); } virtual ::grpc::Status PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::sentry::PeerCountReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>> AsyncPeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>>(AsyncPeerCountRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>> PrepareAsyncPeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>>(PrepareAsyncPeerCountRaw(context, request, cq)); } virtual ::grpc::Status PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::sentry::PeerByIdReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>> AsyncPeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>>(AsyncPeerByIdRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>> PrepareAsyncPeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>>(PrepareAsyncPeerByIdRaw(context, request, cq)); } // Subscribe to notifications about connected or lost peers. std::unique_ptr< ::grpc::ClientReaderInterface< ::sentry::PeerEvent>> PeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::sentry::PeerEvent>>(PeerEventsRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>> AsyncPeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>>(AsyncPeerEventsRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>> PrepareAsyncPeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>>(PrepareAsyncPeerEventsRaw(context, request, cq)); } virtual ::grpc::Status AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::sentry::AddPeerReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>> AsyncAddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>>(AsyncAddPeerRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>> PrepareAsyncAddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>>(PrepareAsyncAddPeerRaw(context, request, cq)); } // NodeInfo returns a collection of metadata known about the host. virtual ::grpc::Status NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::NodeInfoReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>> AsyncNodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>>(AsyncNodeInfoRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>> PrepareAsyncNodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>>(PrepareAsyncNodeInfoRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} // SetStatus - force new ETH client state of sentry - network_id, max_block, etc... virtual void SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response, std::function) = 0; virtual void SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response, std::function) = 0; virtual void PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response, std::function) = 0; virtual void PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; // HandShake - pre-requirement for all Send* methods - returns list of ETH protocol versions, // without knowledge of protocol - impossible encode correct P2P message virtual void HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response, std::function) = 0; virtual void HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response, std::function) = 0; virtual void SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response, std::function) = 0; virtual void SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response, std::function) = 0; virtual void SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response, std::function) = 0; virtual void SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Subscribe to receive messages. // Calling multiple times with a different set of ids starts separate streams. // It is possible to subscribe to the same set if ids more than once. virtual void Messages(::grpc::ClientContext* context, const ::sentry::MessagesRequest* request, ::grpc::ClientReadReactor< ::sentry::InboundMessage>* reactor) = 0; virtual void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response, std::function) = 0; virtual void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response, std::function) = 0; virtual void PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response, std::function) = 0; virtual void PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Subscribe to notifications about connected or lost peers. virtual void PeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest* request, ::grpc::ClientReadReactor< ::sentry::PeerEvent>* reactor) = 0; virtual void AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response, std::function) = 0; virtual void AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // NodeInfo returns a collection of metadata known about the host. virtual void NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response, std::function) = 0; virtual void NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>* AsyncSetStatusRaw(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>* PrepareAsyncSetStatusRaw(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncPenalizePeerRaw(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncPenalizePeerRaw(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncPeerMinBlockRaw(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncPeerMinBlockRaw(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>* AsyncHandShakeRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>* PrepareAsyncHandShakeRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* AsyncSendMessageByMinBlockRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* PrepareAsyncSendMessageByMinBlockRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* AsyncSendMessageByIdRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* PrepareAsyncSendMessageByIdRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* AsyncSendMessageToRandomPeersRaw(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* PrepareAsyncSendMessageToRandomPeersRaw(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* AsyncSendMessageToAllRaw(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>* PrepareAsyncSendMessageToAllRaw(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::sentry::InboundMessage>* MessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>* AsyncMessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>* PrepareAsyncMessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>* AsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>* PrepareAsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>* AsyncPeerCountRaw(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>* PrepareAsyncPeerCountRaw(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>* AsyncPeerByIdRaw(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>* PrepareAsyncPeerByIdRaw(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::sentry::PeerEvent>* PeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>* AsyncPeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>* PrepareAsyncPeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>* AsyncAddPeerRaw(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>* PrepareAsyncAddPeerRaw(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>* AsyncNodeInfoRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>* PrepareAsyncNodeInfoRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::sentry::SetStatusReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>> AsyncSetStatus(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>>(AsyncSetStatusRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>> PrepareAsyncSetStatus(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>>(PrepareAsyncSetStatusRaw(context, request, cq)); } ::grpc::Status PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::google::protobuf::Empty* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncPenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncPenalizePeerRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncPenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncPenalizePeerRaw(context, request, cq)); } ::grpc::Status PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::google::protobuf::Empty* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncPeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncPeerMinBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncPeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncPeerMinBlockRaw(context, request, cq)); } ::grpc::Status HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::HandShakeReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>> AsyncHandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>>(AsyncHandShakeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>> PrepareAsyncHandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>>(PrepareAsyncHandShakeRaw(context, request, cq)); } ::grpc::Status SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::sentry::SentPeers* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> AsyncSendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(AsyncSendMessageByMinBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> PrepareAsyncSendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(PrepareAsyncSendMessageByMinBlockRaw(context, request, cq)); } ::grpc::Status SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::sentry::SentPeers* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> AsyncSendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(AsyncSendMessageByIdRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> PrepareAsyncSendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(PrepareAsyncSendMessageByIdRaw(context, request, cq)); } ::grpc::Status SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::sentry::SentPeers* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> AsyncSendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(AsyncSendMessageToRandomPeersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> PrepareAsyncSendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(PrepareAsyncSendMessageToRandomPeersRaw(context, request, cq)); } ::grpc::Status SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::sentry::SentPeers* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> AsyncSendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(AsyncSendMessageToAllRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>> PrepareAsyncSendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>>(PrepareAsyncSendMessageToAllRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::sentry::InboundMessage>> Messages(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::sentry::InboundMessage>>(MessagesRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::InboundMessage>> AsyncMessages(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::InboundMessage>>(AsyncMessagesRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::InboundMessage>> PrepareAsyncMessages(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::InboundMessage>>(PrepareAsyncMessagesRaw(context, request, cq)); } ::grpc::Status Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::PeersReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>> AsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>>(AsyncPeersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>> PrepareAsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>>(PrepareAsyncPeersRaw(context, request, cq)); } ::grpc::Status PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::sentry::PeerCountReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>> AsyncPeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>>(AsyncPeerCountRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>> PrepareAsyncPeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>>(PrepareAsyncPeerCountRaw(context, request, cq)); } ::grpc::Status PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::sentry::PeerByIdReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>> AsyncPeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>>(AsyncPeerByIdRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>> PrepareAsyncPeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>>(PrepareAsyncPeerByIdRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::sentry::PeerEvent>> PeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::sentry::PeerEvent>>(PeerEventsRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::PeerEvent>> AsyncPeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::PeerEvent>>(AsyncPeerEventsRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::PeerEvent>> PrepareAsyncPeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::sentry::PeerEvent>>(PrepareAsyncPeerEventsRaw(context, request, cq)); } ::grpc::Status AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::sentry::AddPeerReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>> AsyncAddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>>(AsyncAddPeerRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>> PrepareAsyncAddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>>(PrepareAsyncAddPeerRaw(context, request, cq)); } ::grpc::Status NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::NodeInfoReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>> AsyncNodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>>(AsyncNodeInfoRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>> PrepareAsyncNodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>>(PrepareAsyncNodeInfoRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response, std::function) override; void SetStatus(::grpc::ClientContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response, ::grpc::ClientUnaryReactor* reactor) override; void PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response, std::function) override; void PenalizePeer(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; void PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response, std::function) override; void PeerMinBlock(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; void HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response, std::function) override; void HandShake(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response, ::grpc::ClientUnaryReactor* reactor) override; void SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response, std::function) override; void SendMessageByMinBlock(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) override; void SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response, std::function) override; void SendMessageById(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) override; void SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response, std::function) override; void SendMessageToRandomPeers(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) override; void SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response, std::function) override; void SendMessageToAll(::grpc::ClientContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response, ::grpc::ClientUnaryReactor* reactor) override; void Messages(::grpc::ClientContext* context, const ::sentry::MessagesRequest* request, ::grpc::ClientReadReactor< ::sentry::InboundMessage>* reactor) override; void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response, std::function) override; void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response, ::grpc::ClientUnaryReactor* reactor) override; void PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response, std::function) override; void PeerCount(::grpc::ClientContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response, ::grpc::ClientUnaryReactor* reactor) override; void PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response, std::function) override; void PeerById(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response, ::grpc::ClientUnaryReactor* reactor) override; void PeerEvents(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest* request, ::grpc::ClientReadReactor< ::sentry::PeerEvent>* reactor) override; void AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response, std::function) override; void AddPeer(::grpc::ClientContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response, ::grpc::ClientUnaryReactor* reactor) override; void NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response, std::function) override; void NodeInfo(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>* AsyncSetStatusRaw(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SetStatusReply>* PrepareAsyncSetStatusRaw(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncPenalizePeerRaw(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncPenalizePeerRaw(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncPeerMinBlockRaw(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncPeerMinBlockRaw(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>* AsyncHandShakeRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::HandShakeReply>* PrepareAsyncHandShakeRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* AsyncSendMessageByMinBlockRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* PrepareAsyncSendMessageByMinBlockRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* AsyncSendMessageByIdRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* PrepareAsyncSendMessageByIdRaw(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* AsyncSendMessageToRandomPeersRaw(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* PrepareAsyncSendMessageToRandomPeersRaw(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* AsyncSendMessageToAllRaw(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::SentPeers>* PrepareAsyncSendMessageToAllRaw(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::sentry::InboundMessage>* MessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request) override; ::grpc::ClientAsyncReader< ::sentry::InboundMessage>* AsyncMessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::sentry::InboundMessage>* PrepareAsyncMessagesRaw(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>* AsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::PeersReply>* PrepareAsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>* AsyncPeerCountRaw(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::PeerCountReply>* PrepareAsyncPeerCountRaw(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>* AsyncPeerByIdRaw(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::PeerByIdReply>* PrepareAsyncPeerByIdRaw(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::sentry::PeerEvent>* PeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request) override; ::grpc::ClientAsyncReader< ::sentry::PeerEvent>* AsyncPeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::sentry::PeerEvent>* PrepareAsyncPeerEventsRaw(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>* AsyncAddPeerRaw(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::sentry::AddPeerReply>* PrepareAsyncAddPeerRaw(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>* AsyncNodeInfoRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::NodeInfoReply>* PrepareAsyncNodeInfoRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_SetStatus_; const ::grpc::internal::RpcMethod rpcmethod_PenalizePeer_; const ::grpc::internal::RpcMethod rpcmethod_PeerMinBlock_; const ::grpc::internal::RpcMethod rpcmethod_HandShake_; const ::grpc::internal::RpcMethod rpcmethod_SendMessageByMinBlock_; const ::grpc::internal::RpcMethod rpcmethod_SendMessageById_; const ::grpc::internal::RpcMethod rpcmethod_SendMessageToRandomPeers_; const ::grpc::internal::RpcMethod rpcmethod_SendMessageToAll_; const ::grpc::internal::RpcMethod rpcmethod_Messages_; const ::grpc::internal::RpcMethod rpcmethod_Peers_; const ::grpc::internal::RpcMethod rpcmethod_PeerCount_; const ::grpc::internal::RpcMethod rpcmethod_PeerById_; const ::grpc::internal::RpcMethod rpcmethod_PeerEvents_; const ::grpc::internal::RpcMethod rpcmethod_AddPeer_; const ::grpc::internal::RpcMethod rpcmethod_NodeInfo_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // SetStatus - force new ETH client state of sentry - network_id, max_block, etc... virtual ::grpc::Status SetStatus(::grpc::ServerContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response); virtual ::grpc::Status PenalizePeer(::grpc::ServerContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response); virtual ::grpc::Status PeerMinBlock(::grpc::ServerContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response); // HandShake - pre-requirement for all Send* methods - returns list of ETH protocol versions, // without knowledge of protocol - impossible encode correct P2P message virtual ::grpc::Status HandShake(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response); virtual ::grpc::Status SendMessageByMinBlock(::grpc::ServerContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response); virtual ::grpc::Status SendMessageById(::grpc::ServerContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response); virtual ::grpc::Status SendMessageToRandomPeers(::grpc::ServerContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response); virtual ::grpc::Status SendMessageToAll(::grpc::ServerContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response); // Subscribe to receive messages. // Calling multiple times with a different set of ids starts separate streams. // It is possible to subscribe to the same set if ids more than once. virtual ::grpc::Status Messages(::grpc::ServerContext* context, const ::sentry::MessagesRequest* request, ::grpc::ServerWriter< ::sentry::InboundMessage>* writer); virtual ::grpc::Status Peers(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response); virtual ::grpc::Status PeerCount(::grpc::ServerContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response); virtual ::grpc::Status PeerById(::grpc::ServerContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response); // Subscribe to notifications about connected or lost peers. virtual ::grpc::Status PeerEvents(::grpc::ServerContext* context, const ::sentry::PeerEventsRequest* request, ::grpc::ServerWriter< ::sentry::PeerEvent>* writer); virtual ::grpc::Status AddPeer(::grpc::ServerContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response); // NodeInfo returns a collection of metadata known about the host. virtual ::grpc::Status NodeInfo(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response); }; template class WithAsyncMethod_SetStatus : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SetStatus() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_SetStatus() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SetStatus(::grpc::ServerContext* /*context*/, const ::sentry::StatusData* /*request*/, ::sentry::SetStatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSetStatus(::grpc::ServerContext* context, ::sentry::StatusData* request, ::grpc::ServerAsyncResponseWriter< ::sentry::SetStatusReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_PenalizePeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PenalizePeer() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_PenalizePeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PenalizePeer(::grpc::ServerContext* /*context*/, const ::sentry::PenalizePeerRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPenalizePeer(::grpc::ServerContext* context, ::sentry::PenalizePeerRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_PeerMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PeerMinBlock() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_PeerMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::PeerMinBlockRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerMinBlock(::grpc::ServerContext* context, ::sentry::PeerMinBlockRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_HandShake : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HandShake() { ::grpc::Service::MarkMethodAsync(3); } ~WithAsyncMethod_HandShake() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HandShake(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::HandShakeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHandShake(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::sentry::HandShakeReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SendMessageByMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SendMessageByMinBlock() { ::grpc::Service::MarkMethodAsync(4); } ~WithAsyncMethod_SendMessageByMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageByMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByMinBlockRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageByMinBlock(::grpc::ServerContext* context, ::sentry::SendMessageByMinBlockRequest* request, ::grpc::ServerAsyncResponseWriter< ::sentry::SentPeers>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SendMessageById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SendMessageById() { ::grpc::Service::MarkMethodAsync(5); } ~WithAsyncMethod_SendMessageById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageById(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByIdRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageById(::grpc::ServerContext* context, ::sentry::SendMessageByIdRequest* request, ::grpc::ServerAsyncResponseWriter< ::sentry::SentPeers>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SendMessageToRandomPeers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SendMessageToRandomPeers() { ::grpc::Service::MarkMethodAsync(6); } ~WithAsyncMethod_SendMessageToRandomPeers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToRandomPeers(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageToRandomPeersRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageToRandomPeers(::grpc::ServerContext* context, ::sentry::SendMessageToRandomPeersRequest* request, ::grpc::ServerAsyncResponseWriter< ::sentry::SentPeers>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SendMessageToAll : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SendMessageToAll() { ::grpc::Service::MarkMethodAsync(7); } ~WithAsyncMethod_SendMessageToAll() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToAll(::grpc::ServerContext* /*context*/, const ::sentry::OutboundMessageData* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageToAll(::grpc::ServerContext* context, ::sentry::OutboundMessageData* request, ::grpc::ServerAsyncResponseWriter< ::sentry::SentPeers>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Messages : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Messages() { ::grpc::Service::MarkMethodAsync(8); } ~WithAsyncMethod_Messages() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Messages(::grpc::ServerContext* /*context*/, const ::sentry::MessagesRequest* /*request*/, ::grpc::ServerWriter< ::sentry::InboundMessage>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestMessages(::grpc::ServerContext* context, ::sentry::MessagesRequest* request, ::grpc::ServerAsyncWriter< ::sentry::InboundMessage>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(8, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Peers() { ::grpc::Service::MarkMethodAsync(9); } ~WithAsyncMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeers(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::sentry::PeersReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_PeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PeerCount() { ::grpc::Service::MarkMethodAsync(10); } ~WithAsyncMethod_PeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerCount(::grpc::ServerContext* /*context*/, const ::sentry::PeerCountRequest* /*request*/, ::sentry::PeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerCount(::grpc::ServerContext* context, ::sentry::PeerCountRequest* request, ::grpc::ServerAsyncResponseWriter< ::sentry::PeerCountReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_PeerById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PeerById() { ::grpc::Service::MarkMethodAsync(11); } ~WithAsyncMethod_PeerById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerById(::grpc::ServerContext* /*context*/, const ::sentry::PeerByIdRequest* /*request*/, ::sentry::PeerByIdReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerById(::grpc::ServerContext* context, ::sentry::PeerByIdRequest* request, ::grpc::ServerAsyncResponseWriter< ::sentry::PeerByIdReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_PeerEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PeerEvents() { ::grpc::Service::MarkMethodAsync(12); } ~WithAsyncMethod_PeerEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerEvents(::grpc::ServerContext* /*context*/, const ::sentry::PeerEventsRequest* /*request*/, ::grpc::ServerWriter< ::sentry::PeerEvent>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerEvents(::grpc::ServerContext* context, ::sentry::PeerEventsRequest* request, ::grpc::ServerAsyncWriter< ::sentry::PeerEvent>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(12, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_AddPeer() { ::grpc::Service::MarkMethodAsync(13); } ~WithAsyncMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::sentry::AddPeerRequest* /*request*/, ::sentry::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAddPeer(::grpc::ServerContext* context, ::sentry::AddPeerRequest* request, ::grpc::ServerAsyncResponseWriter< ::sentry::AddPeerReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_NodeInfo() { ::grpc::Service::MarkMethodAsync(14); } ~WithAsyncMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::NodeInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNodeInfo(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::types::NodeInfoReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_SetStatus > > > > > > > > > > > > > > AsyncService; template class WithCallbackMethod_SetStatus : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SetStatus() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::sentry::StatusData, ::sentry::SetStatusReply>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::StatusData* request, ::sentry::SetStatusReply* response) { return this->SetStatus(context, request, response); }));} void SetMessageAllocatorFor_SetStatus( ::grpc::MessageAllocator< ::sentry::StatusData, ::sentry::SetStatusReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::StatusData, ::sentry::SetStatusReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SetStatus() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SetStatus(::grpc::ServerContext* /*context*/, const ::sentry::StatusData* /*request*/, ::sentry::SetStatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SetStatus( ::grpc::CallbackServerContext* /*context*/, const ::sentry::StatusData* /*request*/, ::sentry::SetStatusReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_PenalizePeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_PenalizePeer() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::sentry::PenalizePeerRequest, ::google::protobuf::Empty>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::PenalizePeerRequest* request, ::google::protobuf::Empty* response) { return this->PenalizePeer(context, request, response); }));} void SetMessageAllocatorFor_PenalizePeer( ::grpc::MessageAllocator< ::sentry::PenalizePeerRequest, ::google::protobuf::Empty>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::PenalizePeerRequest, ::google::protobuf::Empty>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_PenalizePeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PenalizePeer(::grpc::ServerContext* /*context*/, const ::sentry::PenalizePeerRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PenalizePeer( ::grpc::CallbackServerContext* /*context*/, const ::sentry::PenalizePeerRequest* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } }; template class WithCallbackMethod_PeerMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_PeerMinBlock() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::PeerMinBlockRequest* request, ::google::protobuf::Empty* response) { return this->PeerMinBlock(context, request, response); }));} void SetMessageAllocatorFor_PeerMinBlock( ::grpc::MessageAllocator< ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_PeerMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::PeerMinBlockRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PeerMinBlock( ::grpc::CallbackServerContext* /*context*/, const ::sentry::PeerMinBlockRequest* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } }; template class WithCallbackMethod_HandShake : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_HandShake() { ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::sentry::HandShakeReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::sentry::HandShakeReply* response) { return this->HandShake(context, request, response); }));} void SetMessageAllocatorFor_HandShake( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::sentry::HandShakeReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::sentry::HandShakeReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_HandShake() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HandShake(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::HandShakeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HandShake( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::HandShakeReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SendMessageByMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SendMessageByMinBlock() { ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::SendMessageByMinBlockRequest* request, ::sentry::SentPeers* response) { return this->SendMessageByMinBlock(context, request, response); }));} void SetMessageAllocatorFor_SendMessageByMinBlock( ::grpc::MessageAllocator< ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SendMessageByMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageByMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByMinBlockRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageByMinBlock( ::grpc::CallbackServerContext* /*context*/, const ::sentry::SendMessageByMinBlockRequest* /*request*/, ::sentry::SentPeers* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SendMessageById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SendMessageById() { ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::sentry::SendMessageByIdRequest, ::sentry::SentPeers>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::SendMessageByIdRequest* request, ::sentry::SentPeers* response) { return this->SendMessageById(context, request, response); }));} void SetMessageAllocatorFor_SendMessageById( ::grpc::MessageAllocator< ::sentry::SendMessageByIdRequest, ::sentry::SentPeers>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::SendMessageByIdRequest, ::sentry::SentPeers>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SendMessageById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageById(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByIdRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageById( ::grpc::CallbackServerContext* /*context*/, const ::sentry::SendMessageByIdRequest* /*request*/, ::sentry::SentPeers* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SendMessageToRandomPeers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SendMessageToRandomPeers() { ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::SendMessageToRandomPeersRequest* request, ::sentry::SentPeers* response) { return this->SendMessageToRandomPeers(context, request, response); }));} void SetMessageAllocatorFor_SendMessageToRandomPeers( ::grpc::MessageAllocator< ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SendMessageToRandomPeers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToRandomPeers(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageToRandomPeersRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageToRandomPeers( ::grpc::CallbackServerContext* /*context*/, const ::sentry::SendMessageToRandomPeersRequest* /*request*/, ::sentry::SentPeers* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SendMessageToAll : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SendMessageToAll() { ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::sentry::OutboundMessageData, ::sentry::SentPeers>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::OutboundMessageData* request, ::sentry::SentPeers* response) { return this->SendMessageToAll(context, request, response); }));} void SetMessageAllocatorFor_SendMessageToAll( ::grpc::MessageAllocator< ::sentry::OutboundMessageData, ::sentry::SentPeers>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::OutboundMessageData, ::sentry::SentPeers>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SendMessageToAll() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToAll(::grpc::ServerContext* /*context*/, const ::sentry::OutboundMessageData* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageToAll( ::grpc::CallbackServerContext* /*context*/, const ::sentry::OutboundMessageData* /*request*/, ::sentry::SentPeers* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Messages : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Messages() { ::grpc::Service::MarkMethodCallback(8, new ::grpc::internal::CallbackServerStreamingHandler< ::sentry::MessagesRequest, ::sentry::InboundMessage>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::MessagesRequest* request) { return this->Messages(context, request); })); } ~WithCallbackMethod_Messages() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Messages(::grpc::ServerContext* /*context*/, const ::sentry::MessagesRequest* /*request*/, ::grpc::ServerWriter< ::sentry::InboundMessage>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::sentry::InboundMessage>* Messages( ::grpc::CallbackServerContext* /*context*/, const ::sentry::MessagesRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Peers() { ::grpc::Service::MarkMethodCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::sentry::PeersReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::sentry::PeersReply* response) { return this->Peers(context, request, response); }));} void SetMessageAllocatorFor_Peers( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::sentry::PeersReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(9); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::sentry::PeersReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Peers( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::PeersReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_PeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_PeerCount() { ::grpc::Service::MarkMethodCallback(10, new ::grpc::internal::CallbackUnaryHandler< ::sentry::PeerCountRequest, ::sentry::PeerCountReply>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::PeerCountRequest* request, ::sentry::PeerCountReply* response) { return this->PeerCount(context, request, response); }));} void SetMessageAllocatorFor_PeerCount( ::grpc::MessageAllocator< ::sentry::PeerCountRequest, ::sentry::PeerCountReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(10); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::PeerCountRequest, ::sentry::PeerCountReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_PeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerCount(::grpc::ServerContext* /*context*/, const ::sentry::PeerCountRequest* /*request*/, ::sentry::PeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PeerCount( ::grpc::CallbackServerContext* /*context*/, const ::sentry::PeerCountRequest* /*request*/, ::sentry::PeerCountReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_PeerById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_PeerById() { ::grpc::Service::MarkMethodCallback(11, new ::grpc::internal::CallbackUnaryHandler< ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::PeerByIdRequest* request, ::sentry::PeerByIdReply* response) { return this->PeerById(context, request, response); }));} void SetMessageAllocatorFor_PeerById( ::grpc::MessageAllocator< ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(11); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_PeerById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerById(::grpc::ServerContext* /*context*/, const ::sentry::PeerByIdRequest* /*request*/, ::sentry::PeerByIdReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PeerById( ::grpc::CallbackServerContext* /*context*/, const ::sentry::PeerByIdRequest* /*request*/, ::sentry::PeerByIdReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_PeerEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_PeerEvents() { ::grpc::Service::MarkMethodCallback(12, new ::grpc::internal::CallbackServerStreamingHandler< ::sentry::PeerEventsRequest, ::sentry::PeerEvent>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::PeerEventsRequest* request) { return this->PeerEvents(context, request); })); } ~WithCallbackMethod_PeerEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerEvents(::grpc::ServerContext* /*context*/, const ::sentry::PeerEventsRequest* /*request*/, ::grpc::ServerWriter< ::sentry::PeerEvent>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::sentry::PeerEvent>* PeerEvents( ::grpc::CallbackServerContext* /*context*/, const ::sentry::PeerEventsRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_AddPeer() { ::grpc::Service::MarkMethodCallback(13, new ::grpc::internal::CallbackUnaryHandler< ::sentry::AddPeerRequest, ::sentry::AddPeerReply>( [this]( ::grpc::CallbackServerContext* context, const ::sentry::AddPeerRequest* request, ::sentry::AddPeerReply* response) { return this->AddPeer(context, request, response); }));} void SetMessageAllocatorFor_AddPeer( ::grpc::MessageAllocator< ::sentry::AddPeerRequest, ::sentry::AddPeerReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(13); static_cast<::grpc::internal::CallbackUnaryHandler< ::sentry::AddPeerRequest, ::sentry::AddPeerReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::sentry::AddPeerRequest* /*request*/, ::sentry::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* AddPeer( ::grpc::CallbackServerContext* /*context*/, const ::sentry::AddPeerRequest* /*request*/, ::sentry::AddPeerReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_NodeInfo() { ::grpc::Service::MarkMethodCallback(14, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::NodeInfoReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::types::NodeInfoReply* response) { return this->NodeInfo(context, request, response); }));} void SetMessageAllocatorFor_NodeInfo( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::types::NodeInfoReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(14); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::NodeInfoReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::NodeInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NodeInfo( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::NodeInfoReply* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_SetStatus > > > > > > > > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_SetStatus : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SetStatus() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_SetStatus() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SetStatus(::grpc::ServerContext* /*context*/, const ::sentry::StatusData* /*request*/, ::sentry::SetStatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_PenalizePeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PenalizePeer() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_PenalizePeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PenalizePeer(::grpc::ServerContext* /*context*/, const ::sentry::PenalizePeerRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_PeerMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PeerMinBlock() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_PeerMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::PeerMinBlockRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_HandShake : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HandShake() { ::grpc::Service::MarkMethodGeneric(3); } ~WithGenericMethod_HandShake() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HandShake(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::HandShakeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SendMessageByMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SendMessageByMinBlock() { ::grpc::Service::MarkMethodGeneric(4); } ~WithGenericMethod_SendMessageByMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageByMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByMinBlockRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SendMessageById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SendMessageById() { ::grpc::Service::MarkMethodGeneric(5); } ~WithGenericMethod_SendMessageById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageById(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByIdRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SendMessageToRandomPeers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SendMessageToRandomPeers() { ::grpc::Service::MarkMethodGeneric(6); } ~WithGenericMethod_SendMessageToRandomPeers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToRandomPeers(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageToRandomPeersRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SendMessageToAll : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SendMessageToAll() { ::grpc::Service::MarkMethodGeneric(7); } ~WithGenericMethod_SendMessageToAll() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToAll(::grpc::ServerContext* /*context*/, const ::sentry::OutboundMessageData* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Messages : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Messages() { ::grpc::Service::MarkMethodGeneric(8); } ~WithGenericMethod_Messages() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Messages(::grpc::ServerContext* /*context*/, const ::sentry::MessagesRequest* /*request*/, ::grpc::ServerWriter< ::sentry::InboundMessage>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Peers() { ::grpc::Service::MarkMethodGeneric(9); } ~WithGenericMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_PeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PeerCount() { ::grpc::Service::MarkMethodGeneric(10); } ~WithGenericMethod_PeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerCount(::grpc::ServerContext* /*context*/, const ::sentry::PeerCountRequest* /*request*/, ::sentry::PeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_PeerById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PeerById() { ::grpc::Service::MarkMethodGeneric(11); } ~WithGenericMethod_PeerById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerById(::grpc::ServerContext* /*context*/, const ::sentry::PeerByIdRequest* /*request*/, ::sentry::PeerByIdReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_PeerEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PeerEvents() { ::grpc::Service::MarkMethodGeneric(12); } ~WithGenericMethod_PeerEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerEvents(::grpc::ServerContext* /*context*/, const ::sentry::PeerEventsRequest* /*request*/, ::grpc::ServerWriter< ::sentry::PeerEvent>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_AddPeer() { ::grpc::Service::MarkMethodGeneric(13); } ~WithGenericMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::sentry::AddPeerRequest* /*request*/, ::sentry::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_NodeInfo() { ::grpc::Service::MarkMethodGeneric(14); } ~WithGenericMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::NodeInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_SetStatus : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SetStatus() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_SetStatus() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SetStatus(::grpc::ServerContext* /*context*/, const ::sentry::StatusData* /*request*/, ::sentry::SetStatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSetStatus(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_PenalizePeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PenalizePeer() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_PenalizePeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PenalizePeer(::grpc::ServerContext* /*context*/, const ::sentry::PenalizePeerRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPenalizePeer(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_PeerMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PeerMinBlock() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_PeerMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::PeerMinBlockRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerMinBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_HandShake : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HandShake() { ::grpc::Service::MarkMethodRaw(3); } ~WithRawMethod_HandShake() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HandShake(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::HandShakeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHandShake(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SendMessageByMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SendMessageByMinBlock() { ::grpc::Service::MarkMethodRaw(4); } ~WithRawMethod_SendMessageByMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageByMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByMinBlockRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageByMinBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SendMessageById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SendMessageById() { ::grpc::Service::MarkMethodRaw(5); } ~WithRawMethod_SendMessageById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageById(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByIdRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageById(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SendMessageToRandomPeers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SendMessageToRandomPeers() { ::grpc::Service::MarkMethodRaw(6); } ~WithRawMethod_SendMessageToRandomPeers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToRandomPeers(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageToRandomPeersRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageToRandomPeers(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SendMessageToAll : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SendMessageToAll() { ::grpc::Service::MarkMethodRaw(7); } ~WithRawMethod_SendMessageToAll() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToAll(::grpc::ServerContext* /*context*/, const ::sentry::OutboundMessageData* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendMessageToAll(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Messages : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Messages() { ::grpc::Service::MarkMethodRaw(8); } ~WithRawMethod_Messages() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Messages(::grpc::ServerContext* /*context*/, const ::sentry::MessagesRequest* /*request*/, ::grpc::ServerWriter< ::sentry::InboundMessage>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestMessages(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(8, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Peers() { ::grpc::Service::MarkMethodRaw(9); } ~WithRawMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeers(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_PeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PeerCount() { ::grpc::Service::MarkMethodRaw(10); } ~WithRawMethod_PeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerCount(::grpc::ServerContext* /*context*/, const ::sentry::PeerCountRequest* /*request*/, ::sentry::PeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerCount(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_PeerById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PeerById() { ::grpc::Service::MarkMethodRaw(11); } ~WithRawMethod_PeerById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerById(::grpc::ServerContext* /*context*/, const ::sentry::PeerByIdRequest* /*request*/, ::sentry::PeerByIdReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerById(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_PeerEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PeerEvents() { ::grpc::Service::MarkMethodRaw(12); } ~WithRawMethod_PeerEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerEvents(::grpc::ServerContext* /*context*/, const ::sentry::PeerEventsRequest* /*request*/, ::grpc::ServerWriter< ::sentry::PeerEvent>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeerEvents(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(12, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_AddPeer() { ::grpc::Service::MarkMethodRaw(13); } ~WithRawMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::sentry::AddPeerRequest* /*request*/, ::sentry::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAddPeer(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_NodeInfo() { ::grpc::Service::MarkMethodRaw(14); } ~WithRawMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::NodeInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNodeInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_SetStatus : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SetStatus() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SetStatus(context, request, response); })); } ~WithRawCallbackMethod_SetStatus() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SetStatus(::grpc::ServerContext* /*context*/, const ::sentry::StatusData* /*request*/, ::sentry::SetStatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SetStatus( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_PenalizePeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_PenalizePeer() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PenalizePeer(context, request, response); })); } ~WithRawCallbackMethod_PenalizePeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PenalizePeer(::grpc::ServerContext* /*context*/, const ::sentry::PenalizePeerRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PenalizePeer( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_PeerMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_PeerMinBlock() { ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PeerMinBlock(context, request, response); })); } ~WithRawCallbackMethod_PeerMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::PeerMinBlockRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PeerMinBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_HandShake : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_HandShake() { ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->HandShake(context, request, response); })); } ~WithRawCallbackMethod_HandShake() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HandShake(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::HandShakeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HandShake( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SendMessageByMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SendMessageByMinBlock() { ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendMessageByMinBlock(context, request, response); })); } ~WithRawCallbackMethod_SendMessageByMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageByMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByMinBlockRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageByMinBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SendMessageById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SendMessageById() { ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendMessageById(context, request, response); })); } ~WithRawCallbackMethod_SendMessageById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageById(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByIdRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageById( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SendMessageToRandomPeers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SendMessageToRandomPeers() { ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendMessageToRandomPeers(context, request, response); })); } ~WithRawCallbackMethod_SendMessageToRandomPeers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToRandomPeers(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageToRandomPeersRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageToRandomPeers( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SendMessageToAll : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SendMessageToAll() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendMessageToAll(context, request, response); })); } ~WithRawCallbackMethod_SendMessageToAll() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendMessageToAll(::grpc::ServerContext* /*context*/, const ::sentry::OutboundMessageData* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendMessageToAll( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Messages : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Messages() { ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->Messages(context, request); })); } ~WithRawCallbackMethod_Messages() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Messages(::grpc::ServerContext* /*context*/, const ::sentry::MessagesRequest* /*request*/, ::grpc::ServerWriter< ::sentry::InboundMessage>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* Messages( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Peers() { ::grpc::Service::MarkMethodRawCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Peers(context, request, response); })); } ~WithRawCallbackMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Peers( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_PeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_PeerCount() { ::grpc::Service::MarkMethodRawCallback(10, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PeerCount(context, request, response); })); } ~WithRawCallbackMethod_PeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerCount(::grpc::ServerContext* /*context*/, const ::sentry::PeerCountRequest* /*request*/, ::sentry::PeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PeerCount( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_PeerById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_PeerById() { ::grpc::Service::MarkMethodRawCallback(11, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PeerById(context, request, response); })); } ~WithRawCallbackMethod_PeerById() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerById(::grpc::ServerContext* /*context*/, const ::sentry::PeerByIdRequest* /*request*/, ::sentry::PeerByIdReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PeerById( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_PeerEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_PeerEvents() { ::grpc::Service::MarkMethodRawCallback(12, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->PeerEvents(context, request); })); } ~WithRawCallbackMethod_PeerEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PeerEvents(::grpc::ServerContext* /*context*/, const ::sentry::PeerEventsRequest* /*request*/, ::grpc::ServerWriter< ::sentry::PeerEvent>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* PeerEvents( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_AddPeer() { ::grpc::Service::MarkMethodRawCallback(13, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AddPeer(context, request, response); })); } ~WithRawCallbackMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::sentry::AddPeerRequest* /*request*/, ::sentry::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* AddPeer( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_NodeInfo() { ::grpc::Service::MarkMethodRawCallback(14, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->NodeInfo(context, request, response); })); } ~WithRawCallbackMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::NodeInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NodeInfo( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_SetStatus : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SetStatus() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::sentry::StatusData, ::sentry::SetStatusReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::StatusData, ::sentry::SetStatusReply>* streamer) { return this->StreamedSetStatus(context, streamer); })); } ~WithStreamedUnaryMethod_SetStatus() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SetStatus(::grpc::ServerContext* /*context*/, const ::sentry::StatusData* /*request*/, ::sentry::SetStatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSetStatus(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::StatusData,::sentry::SetStatusReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_PenalizePeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_PenalizePeer() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler< ::sentry::PenalizePeerRequest, ::google::protobuf::Empty>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PenalizePeerRequest, ::google::protobuf::Empty>* streamer) { return this->StreamedPenalizePeer(context, streamer); })); } ~WithStreamedUnaryMethod_PenalizePeer() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status PenalizePeer(::grpc::ServerContext* /*context*/, const ::sentry::PenalizePeerRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPenalizePeer(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PenalizePeerRequest,::google::protobuf::Empty>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_PeerMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_PeerMinBlock() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::StreamedUnaryHandler< ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PeerMinBlockRequest, ::google::protobuf::Empty>* streamer) { return this->StreamedPeerMinBlock(context, streamer); })); } ~WithStreamedUnaryMethod_PeerMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status PeerMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::PeerMinBlockRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPeerMinBlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PeerMinBlockRequest,::google::protobuf::Empty>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HandShake : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HandShake() { ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::sentry::HandShakeReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::sentry::HandShakeReply>* streamer) { return this->StreamedHandShake(context, streamer); })); } ~WithStreamedUnaryMethod_HandShake() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status HandShake(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::HandShakeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedHandShake(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::sentry::HandShakeReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SendMessageByMinBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SendMessageByMinBlock() { ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler< ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::SendMessageByMinBlockRequest, ::sentry::SentPeers>* streamer) { return this->StreamedSendMessageByMinBlock(context, streamer); })); } ~WithStreamedUnaryMethod_SendMessageByMinBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SendMessageByMinBlock(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByMinBlockRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSendMessageByMinBlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::SendMessageByMinBlockRequest,::sentry::SentPeers>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SendMessageById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SendMessageById() { ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler< ::sentry::SendMessageByIdRequest, ::sentry::SentPeers>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::SendMessageByIdRequest, ::sentry::SentPeers>* streamer) { return this->StreamedSendMessageById(context, streamer); })); } ~WithStreamedUnaryMethod_SendMessageById() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SendMessageById(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageByIdRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSendMessageById(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::SendMessageByIdRequest,::sentry::SentPeers>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SendMessageToRandomPeers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SendMessageToRandomPeers() { ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::StreamedUnaryHandler< ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::SendMessageToRandomPeersRequest, ::sentry::SentPeers>* streamer) { return this->StreamedSendMessageToRandomPeers(context, streamer); })); } ~WithStreamedUnaryMethod_SendMessageToRandomPeers() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SendMessageToRandomPeers(::grpc::ServerContext* /*context*/, const ::sentry::SendMessageToRandomPeersRequest* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSendMessageToRandomPeers(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::SendMessageToRandomPeersRequest,::sentry::SentPeers>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SendMessageToAll : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SendMessageToAll() { ::grpc::Service::MarkMethodStreamed(7, new ::grpc::internal::StreamedUnaryHandler< ::sentry::OutboundMessageData, ::sentry::SentPeers>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::OutboundMessageData, ::sentry::SentPeers>* streamer) { return this->StreamedSendMessageToAll(context, streamer); })); } ~WithStreamedUnaryMethod_SendMessageToAll() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SendMessageToAll(::grpc::ServerContext* /*context*/, const ::sentry::OutboundMessageData* /*request*/, ::sentry::SentPeers* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSendMessageToAll(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::OutboundMessageData,::sentry::SentPeers>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Peers() { ::grpc::Service::MarkMethodStreamed(9, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::sentry::PeersReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::sentry::PeersReply>* streamer) { return this->StreamedPeers(context, streamer); })); } ~WithStreamedUnaryMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::sentry::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPeers(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::sentry::PeersReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_PeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_PeerCount() { ::grpc::Service::MarkMethodStreamed(10, new ::grpc::internal::StreamedUnaryHandler< ::sentry::PeerCountRequest, ::sentry::PeerCountReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PeerCountRequest, ::sentry::PeerCountReply>* streamer) { return this->StreamedPeerCount(context, streamer); })); } ~WithStreamedUnaryMethod_PeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status PeerCount(::grpc::ServerContext* /*context*/, const ::sentry::PeerCountRequest* /*request*/, ::sentry::PeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPeerCount(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PeerCountRequest,::sentry::PeerCountReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_PeerById : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_PeerById() { ::grpc::Service::MarkMethodStreamed(11, new ::grpc::internal::StreamedUnaryHandler< ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PeerByIdRequest, ::sentry::PeerByIdReply>* streamer) { return this->StreamedPeerById(context, streamer); })); } ~WithStreamedUnaryMethod_PeerById() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status PeerById(::grpc::ServerContext* /*context*/, const ::sentry::PeerByIdRequest* /*request*/, ::sentry::PeerByIdReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPeerById(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::PeerByIdRequest,::sentry::PeerByIdReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_AddPeer() { ::grpc::Service::MarkMethodStreamed(13, new ::grpc::internal::StreamedUnaryHandler< ::sentry::AddPeerRequest, ::sentry::AddPeerReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::AddPeerRequest, ::sentry::AddPeerReply>* streamer) { return this->StreamedAddPeer(context, streamer); })); } ~WithStreamedUnaryMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::sentry::AddPeerRequest* /*request*/, ::sentry::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedAddPeer(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sentry::AddPeerRequest,::sentry::AddPeerReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_NodeInfo() { ::grpc::Service::MarkMethodStreamed(14, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::types::NodeInfoReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::types::NodeInfoReply>* streamer) { return this->StreamedNodeInfo(context, streamer); })); } ~WithStreamedUnaryMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::NodeInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedNodeInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::types::NodeInfoReply>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_SetStatus > > > > > > > > > > > > StreamedUnaryService; template class WithSplitStreamingMethod_Messages : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_Messages() { ::grpc::Service::MarkMethodStreamed(8, new ::grpc::internal::SplitServerStreamingHandler< ::sentry::MessagesRequest, ::sentry::InboundMessage>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::sentry::MessagesRequest, ::sentry::InboundMessage>* streamer) { return this->StreamedMessages(context, streamer); })); } ~WithSplitStreamingMethod_Messages() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Messages(::grpc::ServerContext* /*context*/, const ::sentry::MessagesRequest* /*request*/, ::grpc::ServerWriter< ::sentry::InboundMessage>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedMessages(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::sentry::MessagesRequest,::sentry::InboundMessage>* server_split_streamer) = 0; }; template class WithSplitStreamingMethod_PeerEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_PeerEvents() { ::grpc::Service::MarkMethodStreamed(12, new ::grpc::internal::SplitServerStreamingHandler< ::sentry::PeerEventsRequest, ::sentry::PeerEvent>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::sentry::PeerEventsRequest, ::sentry::PeerEvent>* streamer) { return this->StreamedPeerEvents(context, streamer); })); } ~WithSplitStreamingMethod_PeerEvents() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status PeerEvents(::grpc::ServerContext* /*context*/, const ::sentry::PeerEventsRequest* /*request*/, ::grpc::ServerWriter< ::sentry::PeerEvent>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedPeerEvents(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::sentry::PeerEventsRequest,::sentry::PeerEvent>* server_split_streamer) = 0; }; typedef WithSplitStreamingMethod_Messages > SplitStreamedService; typedef WithStreamedUnaryMethod_SetStatus > > > > > > > > > > > > > > StreamedService; }; } // namespace sentry #endif // GRPC_p2psentry_2fsentry_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/p2psentry/sentry.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: p2psentry/sentry.proto // Protobuf C++ Version: 5.27.0 #include "p2psentry/sentry.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace sentry { template PROTOBUF_CONSTEXPR SetStatusReply::SetStatusReply(::_pbi::ConstantInitialized) {} struct SetStatusReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR SetStatusReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SetStatusReplyDefaultTypeInternal() {} union { SetStatusReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetStatusReplyDefaultTypeInternal _SetStatusReply_default_instance_; template PROTOBUF_CONSTEXPR PeerEventsRequest::PeerEventsRequest(::_pbi::ConstantInitialized) {} struct PeerEventsRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerEventsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerEventsRequestDefaultTypeInternal() {} union { PeerEventsRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerEventsRequestDefaultTypeInternal _PeerEventsRequest_default_instance_; template PROTOBUF_CONSTEXPR PeerCountRequest::PeerCountRequest(::_pbi::ConstantInitialized) {} struct PeerCountRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerCountRequestDefaultTypeInternal() {} union { PeerCountRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerCountRequestDefaultTypeInternal _PeerCountRequest_default_instance_; inline constexpr PeerCountPerProtocol::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : count_{::uint64_t{0u}}, protocol_{static_cast< ::sentry::Protocol >(0)}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR PeerCountPerProtocol::PeerCountPerProtocol(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeerCountPerProtocolDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerCountPerProtocolDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerCountPerProtocolDefaultTypeInternal() {} union { PeerCountPerProtocol _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerCountPerProtocolDefaultTypeInternal _PeerCountPerProtocol_default_instance_; inline constexpr OutboundMessageData::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), id_{static_cast< ::sentry::MessageId >(0)}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR OutboundMessageData::OutboundMessageData(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct OutboundMessageDataDefaultTypeInternal { PROTOBUF_CONSTEXPR OutboundMessageDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OutboundMessageDataDefaultTypeInternal() {} union { OutboundMessageData _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OutboundMessageDataDefaultTypeInternal _OutboundMessageData_default_instance_; inline constexpr MessagesRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : ids_{}, _ids_cached_byte_size_{0}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR MessagesRequest::MessagesRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct MessagesRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR MessagesRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~MessagesRequestDefaultTypeInternal() {} union { MessagesRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessagesRequestDefaultTypeInternal _MessagesRequest_default_instance_; inline constexpr HandShakeReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : protocol_{static_cast< ::sentry::Protocol >(0)}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR HandShakeReply::HandShakeReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HandShakeReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR HandShakeReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HandShakeReplyDefaultTypeInternal() {} union { HandShakeReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandShakeReplyDefaultTypeInternal _HandShakeReply_default_instance_; inline constexpr AddPeerRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : url_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR AddPeerRequest::AddPeerRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AddPeerRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR AddPeerRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AddPeerRequestDefaultTypeInternal() {} union { AddPeerRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddPeerRequestDefaultTypeInternal _AddPeerRequest_default_instance_; inline constexpr AddPeerReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : success_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR AddPeerReply::AddPeerReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AddPeerReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR AddPeerReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AddPeerReplyDefaultTypeInternal() {} union { AddPeerReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddPeerReplyDefaultTypeInternal _AddPeerReply_default_instance_; inline constexpr SendMessageToRandomPeersRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, data_{nullptr}, max_peers_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR SendMessageToRandomPeersRequest::SendMessageToRandomPeersRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SendMessageToRandomPeersRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR SendMessageToRandomPeersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SendMessageToRandomPeersRequestDefaultTypeInternal() {} union { SendMessageToRandomPeersRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SendMessageToRandomPeersRequestDefaultTypeInternal _SendMessageToRandomPeersRequest_default_instance_; inline constexpr SendMessageByMinBlockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, data_{nullptr}, min_block_{::uint64_t{0u}}, max_peers_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR SendMessageByMinBlockRequest::SendMessageByMinBlockRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SendMessageByMinBlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR SendMessageByMinBlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SendMessageByMinBlockRequestDefaultTypeInternal() {} union { SendMessageByMinBlockRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SendMessageByMinBlockRequestDefaultTypeInternal _SendMessageByMinBlockRequest_default_instance_; inline constexpr PeersReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : peers_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR PeersReply::PeersReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeersReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR PeersReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeersReplyDefaultTypeInternal() {} union { PeersReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeersReplyDefaultTypeInternal _PeersReply_default_instance_; inline constexpr PeerCountReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : counts_per_protocol_{}, count_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR PeerCountReply::PeerCountReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeerCountReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerCountReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerCountReplyDefaultTypeInternal() {} union { PeerCountReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerCountReplyDefaultTypeInternal _PeerCountReply_default_instance_; inline constexpr PeerByIdReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, peer_{nullptr} {} template PROTOBUF_CONSTEXPR PeerByIdReply::PeerByIdReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeerByIdReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerByIdReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerByIdReplyDefaultTypeInternal() {} union { PeerByIdReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerByIdReplyDefaultTypeInternal _PeerByIdReply_default_instance_; inline constexpr Forks::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, height_forks_{}, _height_forks_cached_byte_size_{0}, time_forks_{}, _time_forks_cached_byte_size_{0}, genesis_{nullptr} {} template PROTOBUF_CONSTEXPR Forks::Forks(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ForksDefaultTypeInternal { PROTOBUF_CONSTEXPR ForksDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ForksDefaultTypeInternal() {} union { Forks _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ForksDefaultTypeInternal _Forks_default_instance_; inline constexpr StatusData::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, total_difficulty_{nullptr}, best_hash_{nullptr}, fork_data_{nullptr}, network_id_{::uint64_t{0u}}, max_block_height_{::uint64_t{0u}}, max_block_time_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR StatusData::StatusData(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct StatusDataDefaultTypeInternal { PROTOBUF_CONSTEXPR StatusDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StatusDataDefaultTypeInternal() {} union { StatusData _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatusDataDefaultTypeInternal _StatusData_default_instance_; inline constexpr SentPeers::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : peers_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SentPeers::SentPeers(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SentPeersDefaultTypeInternal { PROTOBUF_CONSTEXPR SentPeersDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SentPeersDefaultTypeInternal() {} union { SentPeers _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SentPeersDefaultTypeInternal _SentPeers_default_instance_; inline constexpr SendMessageByIdRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, data_{nullptr}, peer_id_{nullptr} {} template PROTOBUF_CONSTEXPR SendMessageByIdRequest::SendMessageByIdRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SendMessageByIdRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR SendMessageByIdRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SendMessageByIdRequestDefaultTypeInternal() {} union { SendMessageByIdRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SendMessageByIdRequestDefaultTypeInternal _SendMessageByIdRequest_default_instance_; inline constexpr PenalizePeerRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, peer_id_{nullptr}, penalty_{static_cast< ::sentry::PenaltyKind >(0)} {} template PROTOBUF_CONSTEXPR PenalizePeerRequest::PenalizePeerRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PenalizePeerRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PenalizePeerRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PenalizePeerRequestDefaultTypeInternal() {} union { PenalizePeerRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PenalizePeerRequestDefaultTypeInternal _PenalizePeerRequest_default_instance_; inline constexpr PeerMinBlockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, peer_id_{nullptr}, min_block_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR PeerMinBlockRequest::PeerMinBlockRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeerMinBlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerMinBlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerMinBlockRequestDefaultTypeInternal() {} union { PeerMinBlockRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerMinBlockRequestDefaultTypeInternal _PeerMinBlockRequest_default_instance_; inline constexpr PeerEvent::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, peer_id_{nullptr}, event_id_{static_cast< ::sentry::PeerEvent_PeerEventId >(0)} {} template PROTOBUF_CONSTEXPR PeerEvent::PeerEvent(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeerEventDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerEventDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerEventDefaultTypeInternal() {} union { PeerEvent _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerEventDefaultTypeInternal _PeerEvent_default_instance_; inline constexpr PeerByIdRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, peer_id_{nullptr} {} template PROTOBUF_CONSTEXPR PeerByIdRequest::PeerByIdRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeerByIdRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerByIdRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerByIdRequestDefaultTypeInternal() {} union { PeerByIdRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerByIdRequestDefaultTypeInternal _PeerByIdRequest_default_instance_; inline constexpr InboundMessage::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), peer_id_{nullptr}, id_{static_cast< ::sentry::MessageId >(0)} {} template PROTOBUF_CONSTEXPR InboundMessage::InboundMessage(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct InboundMessageDefaultTypeInternal { PROTOBUF_CONSTEXPR InboundMessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~InboundMessageDefaultTypeInternal() {} union { InboundMessage _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InboundMessageDefaultTypeInternal _InboundMessage_default_instance_; } // namespace sentry static const ::_pb::EnumDescriptor* file_level_enum_descriptors_p2psentry_2fsentry_2eproto[4]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_p2psentry_2fsentry_2eproto = nullptr; const ::uint32_t TableStruct_p2psentry_2fsentry_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::OutboundMessageData, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::OutboundMessageData, _impl_.id_), PROTOBUF_FIELD_OFFSET(::sentry::OutboundMessageData, _impl_.data_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByMinBlockRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByMinBlockRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByMinBlockRequest, _impl_.data_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByMinBlockRequest, _impl_.min_block_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByMinBlockRequest, _impl_.max_peers_), 0, ~0u, ~0u, PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByIdRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByIdRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByIdRequest, _impl_.data_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageByIdRequest, _impl_.peer_id_), 0, 1, PROTOBUF_FIELD_OFFSET(::sentry::SendMessageToRandomPeersRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageToRandomPeersRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::SendMessageToRandomPeersRequest, _impl_.data_), PROTOBUF_FIELD_OFFSET(::sentry::SendMessageToRandomPeersRequest, _impl_.max_peers_), 0, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::SentPeers, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::SentPeers, _impl_.peers_), PROTOBUF_FIELD_OFFSET(::sentry::PenalizePeerRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::PenalizePeerRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PenalizePeerRequest, _impl_.peer_id_), PROTOBUF_FIELD_OFFSET(::sentry::PenalizePeerRequest, _impl_.penalty_), 0, ~0u, PROTOBUF_FIELD_OFFSET(::sentry::PeerMinBlockRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::PeerMinBlockRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeerMinBlockRequest, _impl_.peer_id_), PROTOBUF_FIELD_OFFSET(::sentry::PeerMinBlockRequest, _impl_.min_block_), 0, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::AddPeerRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::AddPeerRequest, _impl_.url_), PROTOBUF_FIELD_OFFSET(::sentry::InboundMessage, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::InboundMessage, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::InboundMessage, _impl_.id_), PROTOBUF_FIELD_OFFSET(::sentry::InboundMessage, _impl_.data_), PROTOBUF_FIELD_OFFSET(::sentry::InboundMessage, _impl_.peer_id_), ~0u, ~0u, 0, PROTOBUF_FIELD_OFFSET(::sentry::Forks, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::Forks, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::Forks, _impl_.genesis_), PROTOBUF_FIELD_OFFSET(::sentry::Forks, _impl_.height_forks_), PROTOBUF_FIELD_OFFSET(::sentry::Forks, _impl_.time_forks_), 0, ~0u, ~0u, PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _impl_.network_id_), PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _impl_.total_difficulty_), PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _impl_.best_hash_), PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _impl_.fork_data_), PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _impl_.max_block_height_), PROTOBUF_FIELD_OFFSET(::sentry::StatusData, _impl_.max_block_time_), ~0u, 0, 1, 2, ~0u, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::SetStatusReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::HandShakeReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::HandShakeReply, _impl_.protocol_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::MessagesRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::MessagesRequest, _impl_.ids_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::PeersReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeersReply, _impl_.peers_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::PeerCountRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::PeerCountPerProtocol, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeerCountPerProtocol, _impl_.protocol_), PROTOBUF_FIELD_OFFSET(::sentry::PeerCountPerProtocol, _impl_.count_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::PeerCountReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeerCountReply, _impl_.count_), PROTOBUF_FIELD_OFFSET(::sentry::PeerCountReply, _impl_.counts_per_protocol_), PROTOBUF_FIELD_OFFSET(::sentry::PeerByIdRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::PeerByIdRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeerByIdRequest, _impl_.peer_id_), 0, PROTOBUF_FIELD_OFFSET(::sentry::PeerByIdReply, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::PeerByIdReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeerByIdReply, _impl_.peer_), 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::PeerEventsRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeerEvent, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::sentry::PeerEvent, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::PeerEvent, _impl_.peer_id_), PROTOBUF_FIELD_OFFSET(::sentry::PeerEvent, _impl_.event_id_), 0, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::sentry::AddPeerReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::sentry::AddPeerReply, _impl_.success_), }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::sentry::OutboundMessageData)}, {10, 21, -1, sizeof(::sentry::SendMessageByMinBlockRequest)}, {24, 34, -1, sizeof(::sentry::SendMessageByIdRequest)}, {36, 46, -1, sizeof(::sentry::SendMessageToRandomPeersRequest)}, {48, -1, -1, sizeof(::sentry::SentPeers)}, {57, 67, -1, sizeof(::sentry::PenalizePeerRequest)}, {69, 79, -1, sizeof(::sentry::PeerMinBlockRequest)}, {81, -1, -1, sizeof(::sentry::AddPeerRequest)}, {90, 101, -1, sizeof(::sentry::InboundMessage)}, {104, 115, -1, sizeof(::sentry::Forks)}, {118, 132, -1, sizeof(::sentry::StatusData)}, {138, -1, -1, sizeof(::sentry::SetStatusReply)}, {146, -1, -1, sizeof(::sentry::HandShakeReply)}, {155, -1, -1, sizeof(::sentry::MessagesRequest)}, {164, -1, -1, sizeof(::sentry::PeersReply)}, {173, -1, -1, sizeof(::sentry::PeerCountRequest)}, {181, -1, -1, sizeof(::sentry::PeerCountPerProtocol)}, {191, -1, -1, sizeof(::sentry::PeerCountReply)}, {201, 210, -1, sizeof(::sentry::PeerByIdRequest)}, {211, 220, -1, sizeof(::sentry::PeerByIdReply)}, {221, -1, -1, sizeof(::sentry::PeerEventsRequest)}, {229, 239, -1, sizeof(::sentry::PeerEvent)}, {241, -1, -1, sizeof(::sentry::AddPeerReply)}, }; static const ::_pb::Message* const file_default_instances[] = { &::sentry::_OutboundMessageData_default_instance_._instance, &::sentry::_SendMessageByMinBlockRequest_default_instance_._instance, &::sentry::_SendMessageByIdRequest_default_instance_._instance, &::sentry::_SendMessageToRandomPeersRequest_default_instance_._instance, &::sentry::_SentPeers_default_instance_._instance, &::sentry::_PenalizePeerRequest_default_instance_._instance, &::sentry::_PeerMinBlockRequest_default_instance_._instance, &::sentry::_AddPeerRequest_default_instance_._instance, &::sentry::_InboundMessage_default_instance_._instance, &::sentry::_Forks_default_instance_._instance, &::sentry::_StatusData_default_instance_._instance, &::sentry::_SetStatusReply_default_instance_._instance, &::sentry::_HandShakeReply_default_instance_._instance, &::sentry::_MessagesRequest_default_instance_._instance, &::sentry::_PeersReply_default_instance_._instance, &::sentry::_PeerCountRequest_default_instance_._instance, &::sentry::_PeerCountPerProtocol_default_instance_._instance, &::sentry::_PeerCountReply_default_instance_._instance, &::sentry::_PeerByIdRequest_default_instance_._instance, &::sentry::_PeerByIdReply_default_instance_._instance, &::sentry::_PeerEventsRequest_default_instance_._instance, &::sentry::_PeerEvent_default_instance_._instance, &::sentry::_AddPeerReply_default_instance_._instance, }; const char descriptor_table_protodef_p2psentry_2fsentry_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\026p2psentry/sentry.proto\022\006sentry\032\033google" "/protobuf/empty.proto\032\021types/types.proto" "\"B\n\023OutboundMessageData\022\035\n\002id\030\001 \001(\0162\021.se" "ntry.MessageId\022\014\n\004data\030\002 \001(\014\"o\n\034SendMess" "ageByMinBlockRequest\022)\n\004data\030\001 \001(\0132\033.sen" "try.OutboundMessageData\022\021\n\tmin_block\030\002 \001" "(\004\022\021\n\tmax_peers\030\003 \001(\004\"a\n\026SendMessageById" "Request\022)\n\004data\030\001 \001(\0132\033.sentry.OutboundM" "essageData\022\034\n\007peer_id\030\002 \001(\0132\013.types.H512" "\"_\n\037SendMessageToRandomPeersRequest\022)\n\004d" "ata\030\001 \001(\0132\033.sentry.OutboundMessageData\022\021" "\n\tmax_peers\030\002 \001(\004\"\'\n\tSentPeers\022\032\n\005peers\030" "\001 \003(\0132\013.types.H512\"Y\n\023PenalizePeerReques" "t\022\034\n\007peer_id\030\001 \001(\0132\013.types.H512\022$\n\007penal" "ty\030\002 \001(\0162\023.sentry.PenaltyKind\"F\n\023PeerMin" "BlockRequest\022\034\n\007peer_id\030\001 \001(\0132\013.types.H5" "12\022\021\n\tmin_block\030\002 \001(\004\"\035\n\016AddPeerRequest\022" "\013\n\003url\030\001 \001(\t\"[\n\016InboundMessage\022\035\n\002id\030\001 \001" "(\0162\021.sentry.MessageId\022\014\n\004data\030\002 \001(\014\022\034\n\007p" "eer_id\030\003 \001(\0132\013.types.H512\"O\n\005Forks\022\034\n\007ge" "nesis\030\001 \001(\0132\013.types.H256\022\024\n\014height_forks" "\030\002 \003(\004\022\022\n\ntime_forks\030\003 \003(\004\"\273\001\n\nStatusDat" "a\022\022\n\nnetwork_id\030\001 \001(\004\022%\n\020total_difficult" "y\030\002 \001(\0132\013.types.H256\022\036\n\tbest_hash\030\003 \001(\0132" "\013.types.H256\022 \n\tfork_data\030\004 \001(\0132\r.sentry" ".Forks\022\030\n\020max_block_height\030\005 \001(\004\022\026\n\016max_" "block_time\030\006 \001(\004\"\020\n\016SetStatusReply\"4\n\016Ha" "ndShakeReply\022\"\n\010protocol\030\001 \001(\0162\020.sentry." "Protocol\"1\n\017MessagesRequest\022\036\n\003ids\030\001 \003(\016" "2\021.sentry.MessageId\",\n\nPeersReply\022\036\n\005pee" "rs\030\001 \003(\0132\017.types.PeerInfo\"\022\n\020PeerCountRe" "quest\"I\n\024PeerCountPerProtocol\022\"\n\010protoco" "l\030\001 \001(\0162\020.sentry.Protocol\022\r\n\005count\030\002 \001(\004" "\"Z\n\016PeerCountReply\022\r\n\005count\030\001 \001(\004\0229\n\023cou" "nts_per_protocol\030\002 \003(\0132\034.sentry.PeerCoun" "tPerProtocol\"/\n\017PeerByIdRequest\022\034\n\007peer_" "id\030\001 \001(\0132\013.types.H512\"<\n\rPeerByIdReply\022\"" "\n\004peer\030\001 \001(\0132\017.types.PeerInfoH\000\210\001\001B\007\n\005_p" "eer\"\023\n\021PeerEventsRequest\"\206\001\n\tPeerEvent\022\034" "\n\007peer_id\030\001 \001(\0132\013.types.H512\022/\n\010event_id" "\030\002 \001(\0162\035.sentry.PeerEvent.PeerEventId\"*\n" "\013PeerEventId\022\013\n\007Connect\020\000\022\016\n\nDisconnect\020" "\001\"\037\n\014AddPeerReply\022\017\n\007success\030\001 \001(\010*\200\006\n\tM" "essageId\022\r\n\tSTATUS_65\020\000\022\030\n\024GET_BLOCK_HEA" "DERS_65\020\001\022\024\n\020BLOCK_HEADERS_65\020\002\022\023\n\017BLOCK" "_HASHES_65\020\003\022\027\n\023GET_BLOCK_BODIES_65\020\004\022\023\n" "\017BLOCK_BODIES_65\020\005\022\024\n\020GET_NODE_DATA_65\020\006" "\022\020\n\014NODE_DATA_65\020\007\022\023\n\017GET_RECEIPTS_65\020\010\022" "\017\n\013RECEIPTS_65\020\t\022\027\n\023NEW_BLOCK_HASHES_65\020" "\n\022\020\n\014NEW_BLOCK_65\020\013\022\023\n\017TRANSACTIONS_65\020\014" "\022$\n NEW_POOLED_TRANSACTION_HASHES_65\020\r\022\036" "\n\032GET_POOLED_TRANSACTIONS_65\020\016\022\032\n\026POOLED" "_TRANSACTIONS_65\020\017\022\r\n\tSTATUS_66\020\021\022\027\n\023NEW" "_BLOCK_HASHES_66\020\022\022\020\n\014NEW_BLOCK_66\020\023\022\023\n\017" "TRANSACTIONS_66\020\024\022$\n NEW_POOLED_TRANSACT" "ION_HASHES_66\020\025\022\030\n\024GET_BLOCK_HEADERS_66\020" "\026\022\027\n\023GET_BLOCK_BODIES_66\020\027\022\024\n\020GET_NODE_D" "ATA_66\020\030\022\023\n\017GET_RECEIPTS_66\020\031\022\036\n\032GET_POO" "LED_TRANSACTIONS_66\020\032\022\024\n\020BLOCK_HEADERS_6" "6\020\033\022\023\n\017BLOCK_BODIES_66\020\034\022\020\n\014NODE_DATA_66" "\020\035\022\017\n\013RECEIPTS_66\020\036\022\032\n\026POOLED_TRANSACTIO" "NS_66\020\037\022$\n NEW_POOLED_TRANSACTION_HASHES" "_68\020 *\027\n\013PenaltyKind\022\010\n\004Kick\020\000*6\n\010Protoc" "ol\022\t\n\005ETH65\020\000\022\t\n\005ETH66\020\001\022\t\n\005ETH67\020\002\022\t\n\005E" "TH68\020\0032\334\007\n\006Sentry\0227\n\tSetStatus\022\022.sentry." "StatusData\032\026.sentry.SetStatusReply\022C\n\014Pe" "nalizePeer\022\033.sentry.PenalizePeerRequest\032" "\026.google.protobuf.Empty\022C\n\014PeerMinBlock\022" "\033.sentry.PeerMinBlockRequest\032\026.google.pr" "otobuf.Empty\022;\n\tHandShake\022\026.google.proto" "buf.Empty\032\026.sentry.HandShakeReply\022P\n\025Sen" "dMessageByMinBlock\022$.sentry.SendMessageB" "yMinBlockRequest\032\021.sentry.SentPeers\022D\n\017S" "endMessageById\022\036.sentry.SendMessageByIdR" "equest\032\021.sentry.SentPeers\022V\n\030SendMessage" "ToRandomPeers\022\'.sentry.SendMessageToRand" "omPeersRequest\032\021.sentry.SentPeers\022B\n\020Sen" "dMessageToAll\022\033.sentry.OutboundMessageDa" "ta\032\021.sentry.SentPeers\022=\n\010Messages\022\027.sent" "ry.MessagesRequest\032\026.sentry.InboundMessa" "ge0\001\0223\n\005Peers\022\026.google.protobuf.Empty\032\022." "sentry.PeersReply\022=\n\tPeerCount\022\030.sentry." "PeerCountRequest\032\026.sentry.PeerCountReply" "\022:\n\010PeerById\022\027.sentry.PeerByIdRequest\032\025." "sentry.PeerByIdReply\022<\n\nPeerEvents\022\031.sen" "try.PeerEventsRequest\032\021.sentry.PeerEvent" "0\001\0227\n\007AddPeer\022\026.sentry.AddPeerRequest\032\024." "sentry.AddPeerReply\0228\n\010NodeInfo\022\026.google" ".protobuf.Empty\032\024.types.NodeInfoReplyB\026Z" "\024./sentry;sentryprotob\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_p2psentry_2fsentry_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_types_2ftypes_2eproto, }; static ::absl::once_flag descriptor_table_p2psentry_2fsentry_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_p2psentry_2fsentry_2eproto = { false, false, 3589, descriptor_table_protodef_p2psentry_2fsentry_2eproto, "p2psentry/sentry.proto", &descriptor_table_p2psentry_2fsentry_2eproto_once, descriptor_table_p2psentry_2fsentry_2eproto_deps, 2, 23, schemas, file_default_instances, TableStruct_p2psentry_2fsentry_2eproto::offsets, file_level_enum_descriptors_p2psentry_2fsentry_2eproto, file_level_service_descriptors_p2psentry_2fsentry_2eproto, }; namespace sentry { const ::google::protobuf::EnumDescriptor* PeerEvent_PeerEventId_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_p2psentry_2fsentry_2eproto); return file_level_enum_descriptors_p2psentry_2fsentry_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t PeerEvent_PeerEventId_internal_data_[] = { 131072u, 0u, }; bool PeerEvent_PeerEventId_IsValid(int value) { return 0 <= value && value <= 1; } #if (__cplusplus < 201703) && \ (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr PeerEvent_PeerEventId PeerEvent::Connect; constexpr PeerEvent_PeerEventId PeerEvent::Disconnect; constexpr PeerEvent_PeerEventId PeerEvent::PeerEventId_MIN; constexpr PeerEvent_PeerEventId PeerEvent::PeerEventId_MAX; constexpr int PeerEvent::PeerEventId_ARRAYSIZE; #endif // (__cplusplus < 201703) && // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::google::protobuf::EnumDescriptor* MessageId_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_p2psentry_2fsentry_2eproto); return file_level_enum_descriptors_p2psentry_2fsentry_2eproto[1]; } PROTOBUF_CONSTINIT const uint32_t MessageId_internal_data_[] = { 1048576u, 32u, 131070u, }; bool MessageId_IsValid(int value) { return 0 <= value && value <= 32 && ((8589869055u >> value) & 1) != 0; } const ::google::protobuf::EnumDescriptor* PenaltyKind_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_p2psentry_2fsentry_2eproto); return file_level_enum_descriptors_p2psentry_2fsentry_2eproto[2]; } PROTOBUF_CONSTINIT const uint32_t PenaltyKind_internal_data_[] = { 65536u, 0u, }; bool PenaltyKind_IsValid(int value) { return 0 <= value && value <= 0; } const ::google::protobuf::EnumDescriptor* Protocol_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_p2psentry_2fsentry_2eproto); return file_level_enum_descriptors_p2psentry_2fsentry_2eproto[3]; } PROTOBUF_CONSTINIT const uint32_t Protocol_internal_data_[] = { 262144u, 0u, }; bool Protocol_IsValid(int value) { return 0 <= value && value <= 3; } // =================================================================== class OutboundMessageData::_Internal { public: }; OutboundMessageData::OutboundMessageData(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.OutboundMessageData) } inline PROTOBUF_NDEBUG_INLINE OutboundMessageData::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::OutboundMessageData& from_msg) : data_(arena, from.data_), _cached_size_{0} {} OutboundMessageData::OutboundMessageData( ::google::protobuf::Arena* arena, const OutboundMessageData& from) : ::google::protobuf::Message(arena) { OutboundMessageData* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.id_ = from._impl_.id_; // @@protoc_insertion_point(copy_constructor:sentry.OutboundMessageData) } inline PROTOBUF_NDEBUG_INLINE OutboundMessageData::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : data_(arena), _cached_size_{0} {} inline void OutboundMessageData::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.id_ = {}; } OutboundMessageData::~OutboundMessageData() { // @@protoc_insertion_point(destructor:sentry.OutboundMessageData) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void OutboundMessageData::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.data_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* OutboundMessageData::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OutboundMessageData, _impl_._cached_size_), false, }, &OutboundMessageData::MergeImpl, &OutboundMessageData::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> OutboundMessageData::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OutboundMessageData_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::OutboundMessageData>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes data = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(OutboundMessageData, _impl_.data_)}}, // .sentry.MessageId id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(OutboundMessageData, _impl_.id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(OutboundMessageData, _impl_.id_)}}, }}, {{ 65535, 65535 }}, {{ // .sentry.MessageId id = 1; {PROTOBUF_FIELD_OFFSET(OutboundMessageData, _impl_.id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // bytes data = 2; {PROTOBUF_FIELD_OFFSET(OutboundMessageData, _impl_.data_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void OutboundMessageData::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.OutboundMessageData) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.data_.ClearToEmpty(); _impl_.id_ = 0; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* OutboundMessageData::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.OutboundMessageData) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .sentry.MessageId id = 1; if (this->_internal_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_id(), target); } // bytes data = 2; if (!this->_internal_data().empty()) { const std::string& _s = this->_internal_data(); target = stream->WriteBytesMaybeAliased(2, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.OutboundMessageData) return target; } ::size_t OutboundMessageData::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.OutboundMessageData) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes data = 2; if (!this->_internal_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_data()); } // .sentry.MessageId id = 1; if (this->_internal_id() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_id()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void OutboundMessageData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.OutboundMessageData) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_data().empty()) { _this->_internal_set_data(from._internal_data()); } if (from._internal_id() != 0) { _this->_impl_.id_ = from._impl_.id_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void OutboundMessageData::CopyFrom(const OutboundMessageData& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.OutboundMessageData) if (&from == this) return; Clear(); MergeFrom(from); } void OutboundMessageData::InternalSwap(OutboundMessageData* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); swap(_impl_.id_, other->_impl_.id_); } ::google::protobuf::Metadata OutboundMessageData::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SendMessageByMinBlockRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_._has_bits_); }; SendMessageByMinBlockRequest::SendMessageByMinBlockRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.SendMessageByMinBlockRequest) } inline PROTOBUF_NDEBUG_INLINE SendMessageByMinBlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::SendMessageByMinBlockRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} SendMessageByMinBlockRequest::SendMessageByMinBlockRequest( ::google::protobuf::Arena* arena, const SendMessageByMinBlockRequest& from) : ::google::protobuf::Message(arena) { SendMessageByMinBlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.data_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::sentry::OutboundMessageData>( arena, *from._impl_.data_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, min_block_), reinterpret_cast(&from._impl_) + offsetof(Impl_, min_block_), offsetof(Impl_, max_peers_) - offsetof(Impl_, min_block_) + sizeof(Impl_::max_peers_)); // @@protoc_insertion_point(copy_constructor:sentry.SendMessageByMinBlockRequest) } inline PROTOBUF_NDEBUG_INLINE SendMessageByMinBlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void SendMessageByMinBlockRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, max_peers_) - offsetof(Impl_, data_) + sizeof(Impl_::max_peers_)); } SendMessageByMinBlockRequest::~SendMessageByMinBlockRequest() { // @@protoc_insertion_point(destructor:sentry.SendMessageByMinBlockRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SendMessageByMinBlockRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.data_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SendMessageByMinBlockRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_._cached_size_), false, }, &SendMessageByMinBlockRequest::MergeImpl, &SendMessageByMinBlockRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 1, 0, 2> SendMessageByMinBlockRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_SendMessageByMinBlockRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::SendMessageByMinBlockRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .sentry.OutboundMessageData data = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.data_)}}, // uint64 min_block = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendMessageByMinBlockRequest, _impl_.min_block_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.min_block_)}}, // uint64 max_peers = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendMessageByMinBlockRequest, _impl_.max_peers_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.max_peers_)}}, }}, {{ 65535, 65535 }}, {{ // .sentry.OutboundMessageData data = 1; {PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.data_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 min_block = 2; {PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.min_block_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 max_peers = 3; {PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.max_peers_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::sentry::OutboundMessageData>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void SendMessageByMinBlockRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.SendMessageByMinBlockRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.data_ != nullptr); _impl_.data_->Clear(); } ::memset(&_impl_.min_block_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.max_peers_) - reinterpret_cast(&_impl_.min_block_)) + sizeof(_impl_.max_peers_)); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SendMessageByMinBlockRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.SendMessageByMinBlockRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .sentry.OutboundMessageData data = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.data_, _impl_.data_->GetCachedSize(), target, stream); } // uint64 min_block = 2; if (this->_internal_min_block() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_min_block(), target); } // uint64 max_peers = 3; if (this->_internal_max_peers() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 3, this->_internal_max_peers(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.SendMessageByMinBlockRequest) return target; } ::size_t SendMessageByMinBlockRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.SendMessageByMinBlockRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .sentry.OutboundMessageData data = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.data_); } // uint64 min_block = 2; if (this->_internal_min_block() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_min_block()); } // uint64 max_peers = 3; if (this->_internal_max_peers() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_max_peers()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SendMessageByMinBlockRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.SendMessageByMinBlockRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.data_ != nullptr); if (_this->_impl_.data_ == nullptr) { _this->_impl_.data_ = ::google::protobuf::Message::CopyConstruct<::sentry::OutboundMessageData>(arena, *from._impl_.data_); } else { _this->_impl_.data_->MergeFrom(*from._impl_.data_); } } if (from._internal_min_block() != 0) { _this->_impl_.min_block_ = from._impl_.min_block_; } if (from._internal_max_peers() != 0) { _this->_impl_.max_peers_ = from._impl_.max_peers_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SendMessageByMinBlockRequest::CopyFrom(const SendMessageByMinBlockRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.SendMessageByMinBlockRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SendMessageByMinBlockRequest::InternalSwap(SendMessageByMinBlockRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.max_peers_) + sizeof(SendMessageByMinBlockRequest::_impl_.max_peers_) - PROTOBUF_FIELD_OFFSET(SendMessageByMinBlockRequest, _impl_.data_)>( reinterpret_cast(&_impl_.data_), reinterpret_cast(&other->_impl_.data_)); } ::google::protobuf::Metadata SendMessageByMinBlockRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SendMessageByIdRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_._has_bits_); }; void SendMessageByIdRequest::clear_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ != nullptr) _impl_.peer_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } SendMessageByIdRequest::SendMessageByIdRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.SendMessageByIdRequest) } inline PROTOBUF_NDEBUG_INLINE SendMessageByIdRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::SendMessageByIdRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} SendMessageByIdRequest::SendMessageByIdRequest( ::google::protobuf::Arena* arena, const SendMessageByIdRequest& from) : ::google::protobuf::Message(arena) { SendMessageByIdRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.data_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::sentry::OutboundMessageData>( arena, *from._impl_.data_) : nullptr; _impl_.peer_id_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.peer_id_) : nullptr; // @@protoc_insertion_point(copy_constructor:sentry.SendMessageByIdRequest) } inline PROTOBUF_NDEBUG_INLINE SendMessageByIdRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void SendMessageByIdRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, peer_id_) - offsetof(Impl_, data_) + sizeof(Impl_::peer_id_)); } SendMessageByIdRequest::~SendMessageByIdRequest() { // @@protoc_insertion_point(destructor:sentry.SendMessageByIdRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SendMessageByIdRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.data_; delete _impl_.peer_id_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SendMessageByIdRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_._cached_size_), false, }, &SendMessageByIdRequest::MergeImpl, &SendMessageByIdRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 2, 0, 2> SendMessageByIdRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_SendMessageByIdRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::SendMessageByIdRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H512 peer_id = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_.peer_id_)}}, // .sentry.OutboundMessageData data = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_.data_)}}, }}, {{ 65535, 65535 }}, {{ // .sentry.OutboundMessageData data = 1; {PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_.data_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H512 peer_id = 2; {PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_.peer_id_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::sentry::OutboundMessageData>()}, {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void SendMessageByIdRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.SendMessageByIdRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.data_ != nullptr); _impl_.data_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.peer_id_ != nullptr); _impl_.peer_id_->Clear(); } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SendMessageByIdRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.SendMessageByIdRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .sentry.OutboundMessageData data = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.data_, _impl_.data_->GetCachedSize(), target, stream); } // .types.H512 peer_id = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.peer_id_, _impl_.peer_id_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.SendMessageByIdRequest) return target; } ::size_t SendMessageByIdRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.SendMessageByIdRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { // .sentry.OutboundMessageData data = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.data_); } // .types.H512 peer_id = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.peer_id_); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SendMessageByIdRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.SendMessageByIdRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.data_ != nullptr); if (_this->_impl_.data_ == nullptr) { _this->_impl_.data_ = ::google::protobuf::Message::CopyConstruct<::sentry::OutboundMessageData>(arena, *from._impl_.data_); } else { _this->_impl_.data_->MergeFrom(*from._impl_.data_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.peer_id_ != nullptr); if (_this->_impl_.peer_id_ == nullptr) { _this->_impl_.peer_id_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.peer_id_); } else { _this->_impl_.peer_id_->MergeFrom(*from._impl_.peer_id_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SendMessageByIdRequest::CopyFrom(const SendMessageByIdRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.SendMessageByIdRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SendMessageByIdRequest::InternalSwap(SendMessageByIdRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_.peer_id_) + sizeof(SendMessageByIdRequest::_impl_.peer_id_) - PROTOBUF_FIELD_OFFSET(SendMessageByIdRequest, _impl_.data_)>( reinterpret_cast(&_impl_.data_), reinterpret_cast(&other->_impl_.data_)); } ::google::protobuf::Metadata SendMessageByIdRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SendMessageToRandomPeersRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_._has_bits_); }; SendMessageToRandomPeersRequest::SendMessageToRandomPeersRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.SendMessageToRandomPeersRequest) } inline PROTOBUF_NDEBUG_INLINE SendMessageToRandomPeersRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::SendMessageToRandomPeersRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} SendMessageToRandomPeersRequest::SendMessageToRandomPeersRequest( ::google::protobuf::Arena* arena, const SendMessageToRandomPeersRequest& from) : ::google::protobuf::Message(arena) { SendMessageToRandomPeersRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.data_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::sentry::OutboundMessageData>( arena, *from._impl_.data_) : nullptr; _impl_.max_peers_ = from._impl_.max_peers_; // @@protoc_insertion_point(copy_constructor:sentry.SendMessageToRandomPeersRequest) } inline PROTOBUF_NDEBUG_INLINE SendMessageToRandomPeersRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void SendMessageToRandomPeersRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, data_), 0, offsetof(Impl_, max_peers_) - offsetof(Impl_, data_) + sizeof(Impl_::max_peers_)); } SendMessageToRandomPeersRequest::~SendMessageToRandomPeersRequest() { // @@protoc_insertion_point(destructor:sentry.SendMessageToRandomPeersRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SendMessageToRandomPeersRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.data_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SendMessageToRandomPeersRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_._cached_size_), false, }, &SendMessageToRandomPeersRequest::MergeImpl, &SendMessageToRandomPeersRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> SendMessageToRandomPeersRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_SendMessageToRandomPeersRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::SendMessageToRandomPeersRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 max_peers = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendMessageToRandomPeersRequest, _impl_.max_peers_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_.max_peers_)}}, // .sentry.OutboundMessageData data = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_.data_)}}, }}, {{ 65535, 65535 }}, {{ // .sentry.OutboundMessageData data = 1; {PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_.data_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 max_peers = 2; {PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_.max_peers_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::sentry::OutboundMessageData>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void SendMessageToRandomPeersRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.SendMessageToRandomPeersRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.data_ != nullptr); _impl_.data_->Clear(); } _impl_.max_peers_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SendMessageToRandomPeersRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.SendMessageToRandomPeersRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .sentry.OutboundMessageData data = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.data_, _impl_.data_->GetCachedSize(), target, stream); } // uint64 max_peers = 2; if (this->_internal_max_peers() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_max_peers(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.SendMessageToRandomPeersRequest) return target; } ::size_t SendMessageToRandomPeersRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.SendMessageToRandomPeersRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .sentry.OutboundMessageData data = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.data_); } // uint64 max_peers = 2; if (this->_internal_max_peers() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_max_peers()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SendMessageToRandomPeersRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.SendMessageToRandomPeersRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.data_ != nullptr); if (_this->_impl_.data_ == nullptr) { _this->_impl_.data_ = ::google::protobuf::Message::CopyConstruct<::sentry::OutboundMessageData>(arena, *from._impl_.data_); } else { _this->_impl_.data_->MergeFrom(*from._impl_.data_); } } if (from._internal_max_peers() != 0) { _this->_impl_.max_peers_ = from._impl_.max_peers_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SendMessageToRandomPeersRequest::CopyFrom(const SendMessageToRandomPeersRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.SendMessageToRandomPeersRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SendMessageToRandomPeersRequest::InternalSwap(SendMessageToRandomPeersRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_.max_peers_) + sizeof(SendMessageToRandomPeersRequest::_impl_.max_peers_) - PROTOBUF_FIELD_OFFSET(SendMessageToRandomPeersRequest, _impl_.data_)>( reinterpret_cast(&_impl_.data_), reinterpret_cast(&other->_impl_.data_)); } ::google::protobuf::Metadata SendMessageToRandomPeersRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SentPeers::_Internal { public: }; void SentPeers::clear_peers() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.peers_.Clear(); } SentPeers::SentPeers(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.SentPeers) } inline PROTOBUF_NDEBUG_INLINE SentPeers::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::SentPeers& from_msg) : peers_{visibility, arena, from.peers_}, _cached_size_{0} {} SentPeers::SentPeers( ::google::protobuf::Arena* arena, const SentPeers& from) : ::google::protobuf::Message(arena) { SentPeers* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:sentry.SentPeers) } inline PROTOBUF_NDEBUG_INLINE SentPeers::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : peers_{visibility, arena}, _cached_size_{0} {} inline void SentPeers::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } SentPeers::~SentPeers() { // @@protoc_insertion_point(destructor:sentry.SentPeers) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SentPeers::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SentPeers::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SentPeers, _impl_._cached_size_), false, }, &SentPeers::MergeImpl, &SentPeers::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> SentPeers::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_SentPeers_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::SentPeers>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.H512 peers = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(SentPeers, _impl_.peers_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.H512 peers = 1; {PROTOBUF_FIELD_OFFSET(SentPeers, _impl_.peers_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void SentPeers::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.SentPeers) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.peers_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SentPeers::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.SentPeers) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.H512 peers = 1; for (unsigned i = 0, n = static_cast( this->_internal_peers_size()); i < n; i++) { const auto& repfield = this->_internal_peers().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.SentPeers) return target; } ::size_t SentPeers::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.SentPeers) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.H512 peers = 1; total_size += 1UL * this->_internal_peers_size(); for (const auto& msg : this->_internal_peers()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SentPeers::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.SentPeers) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_peers()->MergeFrom( from._internal_peers()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SentPeers::CopyFrom(const SentPeers& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.SentPeers) if (&from == this) return; Clear(); MergeFrom(from); } void SentPeers::InternalSwap(SentPeers* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.peers_.InternalSwap(&other->_impl_.peers_); } ::google::protobuf::Metadata SentPeers::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PenalizePeerRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_._has_bits_); }; void PenalizePeerRequest::clear_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ != nullptr) _impl_.peer_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } PenalizePeerRequest::PenalizePeerRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PenalizePeerRequest) } inline PROTOBUF_NDEBUG_INLINE PenalizePeerRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::PenalizePeerRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} PenalizePeerRequest::PenalizePeerRequest( ::google::protobuf::Arena* arena, const PenalizePeerRequest& from) : ::google::protobuf::Message(arena) { PenalizePeerRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.peer_id_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.peer_id_) : nullptr; _impl_.penalty_ = from._impl_.penalty_; // @@protoc_insertion_point(copy_constructor:sentry.PenalizePeerRequest) } inline PROTOBUF_NDEBUG_INLINE PenalizePeerRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void PenalizePeerRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, peer_id_), 0, offsetof(Impl_, penalty_) - offsetof(Impl_, peer_id_) + sizeof(Impl_::penalty_)); } PenalizePeerRequest::~PenalizePeerRequest() { // @@protoc_insertion_point(destructor:sentry.PenalizePeerRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PenalizePeerRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.peer_id_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PenalizePeerRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_._cached_size_), false, }, &PenalizePeerRequest::MergeImpl, &PenalizePeerRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> PenalizePeerRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PenalizePeerRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PenalizePeerRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .sentry.PenaltyKind penalty = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PenalizePeerRequest, _impl_.penalty_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_.penalty_)}}, // .types.H512 peer_id = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_.peer_id_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H512 peer_id = 1; {PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_.peer_id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .sentry.PenaltyKind penalty = 2; {PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_.penalty_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PenalizePeerRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PenalizePeerRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.peer_id_ != nullptr); _impl_.peer_id_->Clear(); } _impl_.penalty_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PenalizePeerRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PenalizePeerRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H512 peer_id = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.peer_id_, _impl_.peer_id_->GetCachedSize(), target, stream); } // .sentry.PenaltyKind penalty = 2; if (this->_internal_penalty() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 2, this->_internal_penalty(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PenalizePeerRequest) return target; } ::size_t PenalizePeerRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PenalizePeerRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H512 peer_id = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.peer_id_); } // .sentry.PenaltyKind penalty = 2; if (this->_internal_penalty() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_penalty()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PenalizePeerRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PenalizePeerRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.peer_id_ != nullptr); if (_this->_impl_.peer_id_ == nullptr) { _this->_impl_.peer_id_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.peer_id_); } else { _this->_impl_.peer_id_->MergeFrom(*from._impl_.peer_id_); } } if (from._internal_penalty() != 0) { _this->_impl_.penalty_ = from._impl_.penalty_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PenalizePeerRequest::CopyFrom(const PenalizePeerRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PenalizePeerRequest) if (&from == this) return; Clear(); MergeFrom(from); } void PenalizePeerRequest::InternalSwap(PenalizePeerRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_.penalty_) + sizeof(PenalizePeerRequest::_impl_.penalty_) - PROTOBUF_FIELD_OFFSET(PenalizePeerRequest, _impl_.peer_id_)>( reinterpret_cast(&_impl_.peer_id_), reinterpret_cast(&other->_impl_.peer_id_)); } ::google::protobuf::Metadata PenalizePeerRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerMinBlockRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_._has_bits_); }; void PeerMinBlockRequest::clear_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ != nullptr) _impl_.peer_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } PeerMinBlockRequest::PeerMinBlockRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PeerMinBlockRequest) } inline PROTOBUF_NDEBUG_INLINE PeerMinBlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::PeerMinBlockRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} PeerMinBlockRequest::PeerMinBlockRequest( ::google::protobuf::Arena* arena, const PeerMinBlockRequest& from) : ::google::protobuf::Message(arena) { PeerMinBlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.peer_id_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.peer_id_) : nullptr; _impl_.min_block_ = from._impl_.min_block_; // @@protoc_insertion_point(copy_constructor:sentry.PeerMinBlockRequest) } inline PROTOBUF_NDEBUG_INLINE PeerMinBlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void PeerMinBlockRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, peer_id_), 0, offsetof(Impl_, min_block_) - offsetof(Impl_, peer_id_) + sizeof(Impl_::min_block_)); } PeerMinBlockRequest::~PeerMinBlockRequest() { // @@protoc_insertion_point(destructor:sentry.PeerMinBlockRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeerMinBlockRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.peer_id_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeerMinBlockRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_._cached_size_), false, }, &PeerMinBlockRequest::MergeImpl, &PeerMinBlockRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> PeerMinBlockRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PeerMinBlockRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerMinBlockRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 min_block = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PeerMinBlockRequest, _impl_.min_block_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_.min_block_)}}, // .types.H512 peer_id = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_.peer_id_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H512 peer_id = 1; {PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_.peer_id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 min_block = 2; {PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_.min_block_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PeerMinBlockRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PeerMinBlockRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.peer_id_ != nullptr); _impl_.peer_id_->Clear(); } _impl_.min_block_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeerMinBlockRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PeerMinBlockRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H512 peer_id = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.peer_id_, _impl_.peer_id_->GetCachedSize(), target, stream); } // uint64 min_block = 2; if (this->_internal_min_block() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_min_block(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PeerMinBlockRequest) return target; } ::size_t PeerMinBlockRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PeerMinBlockRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H512 peer_id = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.peer_id_); } // uint64 min_block = 2; if (this->_internal_min_block() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_min_block()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeerMinBlockRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PeerMinBlockRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.peer_id_ != nullptr); if (_this->_impl_.peer_id_ == nullptr) { _this->_impl_.peer_id_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.peer_id_); } else { _this->_impl_.peer_id_->MergeFrom(*from._impl_.peer_id_); } } if (from._internal_min_block() != 0) { _this->_impl_.min_block_ = from._impl_.min_block_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeerMinBlockRequest::CopyFrom(const PeerMinBlockRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PeerMinBlockRequest) if (&from == this) return; Clear(); MergeFrom(from); } void PeerMinBlockRequest::InternalSwap(PeerMinBlockRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_.min_block_) + sizeof(PeerMinBlockRequest::_impl_.min_block_) - PROTOBUF_FIELD_OFFSET(PeerMinBlockRequest, _impl_.peer_id_)>( reinterpret_cast(&_impl_.peer_id_), reinterpret_cast(&other->_impl_.peer_id_)); } ::google::protobuf::Metadata PeerMinBlockRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AddPeerRequest::_Internal { public: }; AddPeerRequest::AddPeerRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.AddPeerRequest) } inline PROTOBUF_NDEBUG_INLINE AddPeerRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::AddPeerRequest& from_msg) : url_(arena, from.url_), _cached_size_{0} {} AddPeerRequest::AddPeerRequest( ::google::protobuf::Arena* arena, const AddPeerRequest& from) : ::google::protobuf::Message(arena) { AddPeerRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:sentry.AddPeerRequest) } inline PROTOBUF_NDEBUG_INLINE AddPeerRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : url_(arena), _cached_size_{0} {} inline void AddPeerRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } AddPeerRequest::~AddPeerRequest() { // @@protoc_insertion_point(destructor:sentry.AddPeerRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AddPeerRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.url_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AddPeerRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AddPeerRequest, _impl_._cached_size_), false, }, &AddPeerRequest::MergeImpl, &AddPeerRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 33, 2> AddPeerRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AddPeerRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::AddPeerRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // string url = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(AddPeerRequest, _impl_.url_)}}, }}, {{ 65535, 65535 }}, {{ // string url = 1; {PROTOBUF_FIELD_OFFSET(AddPeerRequest, _impl_.url_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\25\3\0\0\0\0\0\0" "sentry.AddPeerRequest" "url" }}, }; PROTOBUF_NOINLINE void AddPeerRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.AddPeerRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.url_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AddPeerRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.AddPeerRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string url = 1; if (!this->_internal_url().empty()) { const std::string& _s = this->_internal_url(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "sentry.AddPeerRequest.url"); target = stream->WriteStringMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.AddPeerRequest) return target; } ::size_t AddPeerRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.AddPeerRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string url = 1; if (!this->_internal_url().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_url()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AddPeerRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.AddPeerRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_url().empty()) { _this->_internal_set_url(from._internal_url()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AddPeerRequest::CopyFrom(const AddPeerRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.AddPeerRequest) if (&from == this) return; Clear(); MergeFrom(from); } void AddPeerRequest::InternalSwap(AddPeerRequest* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.url_, &other->_impl_.url_, arena); } ::google::protobuf::Metadata AddPeerRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class InboundMessage::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_._has_bits_); }; void InboundMessage::clear_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ != nullptr) _impl_.peer_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } InboundMessage::InboundMessage(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.InboundMessage) } inline PROTOBUF_NDEBUG_INLINE InboundMessage::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::InboundMessage& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, data_(arena, from.data_) {} InboundMessage::InboundMessage( ::google::protobuf::Arena* arena, const InboundMessage& from) : ::google::protobuf::Message(arena) { InboundMessage* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.peer_id_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.peer_id_) : nullptr; _impl_.id_ = from._impl_.id_; // @@protoc_insertion_point(copy_constructor:sentry.InboundMessage) } inline PROTOBUF_NDEBUG_INLINE InboundMessage::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, data_(arena) {} inline void InboundMessage::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, peer_id_), 0, offsetof(Impl_, id_) - offsetof(Impl_, peer_id_) + sizeof(Impl_::id_)); } InboundMessage::~InboundMessage() { // @@protoc_insertion_point(destructor:sentry.InboundMessage) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void InboundMessage::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.data_.Destroy(); delete _impl_.peer_id_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* InboundMessage::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_._cached_size_), false, }, &InboundMessage::MergeImpl, &InboundMessage::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 1, 0, 2> InboundMessage::_table_ = { { PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_InboundMessage_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::InboundMessage>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .sentry.MessageId id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(InboundMessage, _impl_.id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.id_)}}, // bytes data = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.data_)}}, // .types.H512 peer_id = 3; {::_pbi::TcParser::FastMtS1, {26, 0, 0, PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.peer_id_)}}, }}, {{ 65535, 65535 }}, {{ // .sentry.MessageId id = 1; {PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.id_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // bytes data = 2; {PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.data_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // .types.H512 peer_id = 3; {PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.peer_id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void InboundMessage::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.InboundMessage) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.data_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.peer_id_ != nullptr); _impl_.peer_id_->Clear(); } _impl_.id_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* InboundMessage::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.InboundMessage) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .sentry.MessageId id = 1; if (this->_internal_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_id(), target); } // bytes data = 2; if (!this->_internal_data().empty()) { const std::string& _s = this->_internal_data(); target = stream->WriteBytesMaybeAliased(2, _s, target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H512 peer_id = 3; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.peer_id_, _impl_.peer_id_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.InboundMessage) return target; } ::size_t InboundMessage::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.InboundMessage) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes data = 2; if (!this->_internal_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_data()); } // .types.H512 peer_id = 3; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.peer_id_); } // .sentry.MessageId id = 1; if (this->_internal_id() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_id()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void InboundMessage::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.InboundMessage) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_data().empty()) { _this->_internal_set_data(from._internal_data()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.peer_id_ != nullptr); if (_this->_impl_.peer_id_ == nullptr) { _this->_impl_.peer_id_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.peer_id_); } else { _this->_impl_.peer_id_->MergeFrom(*from._impl_.peer_id_); } } if (from._internal_id() != 0) { _this->_impl_.id_ = from._impl_.id_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void InboundMessage::CopyFrom(const InboundMessage& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.InboundMessage) if (&from == this) return; Clear(); MergeFrom(from); } void InboundMessage::InternalSwap(InboundMessage* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.id_) + sizeof(InboundMessage::_impl_.id_) - PROTOBUF_FIELD_OFFSET(InboundMessage, _impl_.peer_id_)>( reinterpret_cast(&_impl_.peer_id_), reinterpret_cast(&other->_impl_.peer_id_)); } ::google::protobuf::Metadata InboundMessage::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Forks::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(Forks, _impl_._has_bits_); }; void Forks::clear_genesis() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.genesis_ != nullptr) _impl_.genesis_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } Forks::Forks(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.Forks) } inline PROTOBUF_NDEBUG_INLINE Forks::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::Forks& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, height_forks_{visibility, arena, from.height_forks_}, _height_forks_cached_byte_size_{0}, time_forks_{visibility, arena, from.time_forks_}, _time_forks_cached_byte_size_{0} {} Forks::Forks( ::google::protobuf::Arena* arena, const Forks& from) : ::google::protobuf::Message(arena) { Forks* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.genesis_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.genesis_) : nullptr; // @@protoc_insertion_point(copy_constructor:sentry.Forks) } inline PROTOBUF_NDEBUG_INLINE Forks::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, height_forks_{visibility, arena}, _height_forks_cached_byte_size_{0}, time_forks_{visibility, arena}, _time_forks_cached_byte_size_{0} {} inline void Forks::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.genesis_ = {}; } Forks::~Forks() { // @@protoc_insertion_point(destructor:sentry.Forks) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Forks::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.genesis_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Forks::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Forks, _impl_._cached_size_), false, }, &Forks::MergeImpl, &Forks::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 1, 0, 2> Forks::_table_ = { { PROTOBUF_FIELD_OFFSET(Forks, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_Forks_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::Forks>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .types.H256 genesis = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(Forks, _impl_.genesis_)}}, // repeated uint64 height_forks = 2; {::_pbi::TcParser::FastV64P1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(Forks, _impl_.height_forks_)}}, // repeated uint64 time_forks = 3; {::_pbi::TcParser::FastV64P1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(Forks, _impl_.time_forks_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 genesis = 1; {PROTOBUF_FIELD_OFFSET(Forks, _impl_.genesis_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // repeated uint64 height_forks = 2; {PROTOBUF_FIELD_OFFSET(Forks, _impl_.height_forks_), -1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt64)}, // repeated uint64 time_forks = 3; {PROTOBUF_FIELD_OFFSET(Forks, _impl_.time_forks_), -1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void Forks::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.Forks) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.height_forks_.Clear(); _impl_.time_forks_.Clear(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.genesis_ != nullptr); _impl_.genesis_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Forks::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.Forks) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 genesis = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.genesis_, _impl_.genesis_->GetCachedSize(), target, stream); } // repeated uint64 height_forks = 2; { int byte_size = _impl_._height_forks_cached_byte_size_.Get(); if (byte_size > 0) { target = stream->WriteUInt64Packed( 2, _internal_height_forks(), byte_size, target); } } // repeated uint64 time_forks = 3; { int byte_size = _impl_._time_forks_cached_byte_size_.Get(); if (byte_size > 0) { target = stream->WriteUInt64Packed( 3, _internal_time_forks(), byte_size, target); } } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.Forks) return target; } ::size_t Forks::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.Forks) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated uint64 height_forks = 2; { std::size_t data_size = ::_pbi::WireFormatLite::UInt64Size( this->_internal_height_forks()) ; _impl_._height_forks_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size)); std::size_t tag_size = data_size == 0 ? 0 : 1 + ::_pbi::WireFormatLite::Int32Size( static_cast(data_size)) ; total_size += tag_size + data_size; } // repeated uint64 time_forks = 3; { std::size_t data_size = ::_pbi::WireFormatLite::UInt64Size( this->_internal_time_forks()) ; _impl_._time_forks_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size)); std::size_t tag_size = data_size == 0 ? 0 : 1 + ::_pbi::WireFormatLite::Int32Size( static_cast(data_size)) ; total_size += tag_size + data_size; } // .types.H256 genesis = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.genesis_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Forks::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.Forks) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_height_forks()->MergeFrom(from._internal_height_forks()); _this->_internal_mutable_time_forks()->MergeFrom(from._internal_time_forks()); cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.genesis_ != nullptr); if (_this->_impl_.genesis_ == nullptr) { _this->_impl_.genesis_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.genesis_); } else { _this->_impl_.genesis_->MergeFrom(*from._impl_.genesis_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Forks::CopyFrom(const Forks& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.Forks) if (&from == this) return; Clear(); MergeFrom(from); } void Forks::InternalSwap(Forks* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.height_forks_.InternalSwap(&other->_impl_.height_forks_); _impl_.time_forks_.InternalSwap(&other->_impl_.time_forks_); swap(_impl_.genesis_, other->_impl_.genesis_); } ::google::protobuf::Metadata Forks::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StatusData::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(StatusData, _impl_._has_bits_); }; void StatusData::clear_total_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.total_difficulty_ != nullptr) _impl_.total_difficulty_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } void StatusData::clear_best_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.best_hash_ != nullptr) _impl_.best_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } StatusData::StatusData(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.StatusData) } inline PROTOBUF_NDEBUG_INLINE StatusData::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::StatusData& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} StatusData::StatusData( ::google::protobuf::Arena* arena, const StatusData& from) : ::google::protobuf::Message(arena) { StatusData* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.total_difficulty_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.total_difficulty_) : nullptr; _impl_.best_hash_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.best_hash_) : nullptr; _impl_.fork_data_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::sentry::Forks>( arena, *from._impl_.fork_data_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, network_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, network_id_), offsetof(Impl_, max_block_time_) - offsetof(Impl_, network_id_) + sizeof(Impl_::max_block_time_)); // @@protoc_insertion_point(copy_constructor:sentry.StatusData) } inline PROTOBUF_NDEBUG_INLINE StatusData::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void StatusData::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, total_difficulty_), 0, offsetof(Impl_, max_block_time_) - offsetof(Impl_, total_difficulty_) + sizeof(Impl_::max_block_time_)); } StatusData::~StatusData() { // @@protoc_insertion_point(destructor:sentry.StatusData) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void StatusData::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.total_difficulty_; delete _impl_.best_hash_; delete _impl_.fork_data_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* StatusData::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(StatusData, _impl_._cached_size_), false, }, &StatusData::MergeImpl, &StatusData::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 6, 3, 0, 2> StatusData::_table_ = { { PROTOBUF_FIELD_OFFSET(StatusData, _impl_._has_bits_), 0, // no _extensions_ 6, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967232, // skipmap offsetof(decltype(_table_), field_entries), 6, // num_field_entries 3, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_StatusData_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::StatusData>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint64 network_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StatusData, _impl_.network_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(StatusData, _impl_.network_id_)}}, // .types.H256 total_difficulty = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(StatusData, _impl_.total_difficulty_)}}, // .types.H256 best_hash = 3; {::_pbi::TcParser::FastMtS1, {26, 1, 1, PROTOBUF_FIELD_OFFSET(StatusData, _impl_.best_hash_)}}, // .sentry.Forks fork_data = 4; {::_pbi::TcParser::FastMtS1, {34, 2, 2, PROTOBUF_FIELD_OFFSET(StatusData, _impl_.fork_data_)}}, // uint64 max_block_height = 5; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StatusData, _impl_.max_block_height_), 63>(), {40, 63, 0, PROTOBUF_FIELD_OFFSET(StatusData, _impl_.max_block_height_)}}, // uint64 max_block_time = 6; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StatusData, _impl_.max_block_time_), 63>(), {48, 63, 0, PROTOBUF_FIELD_OFFSET(StatusData, _impl_.max_block_time_)}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint64 network_id = 1; {PROTOBUF_FIELD_OFFSET(StatusData, _impl_.network_id_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .types.H256 total_difficulty = 2; {PROTOBUF_FIELD_OFFSET(StatusData, _impl_.total_difficulty_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 best_hash = 3; {PROTOBUF_FIELD_OFFSET(StatusData, _impl_.best_hash_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .sentry.Forks fork_data = 4; {PROTOBUF_FIELD_OFFSET(StatusData, _impl_.fork_data_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 max_block_height = 5; {PROTOBUF_FIELD_OFFSET(StatusData, _impl_.max_block_height_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 max_block_time = 6; {PROTOBUF_FIELD_OFFSET(StatusData, _impl_.max_block_time_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::sentry::Forks>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void StatusData::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.StatusData) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.total_difficulty_ != nullptr); _impl_.total_difficulty_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.best_hash_ != nullptr); _impl_.best_hash_->Clear(); } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(_impl_.fork_data_ != nullptr); _impl_.fork_data_->Clear(); } } ::memset(&_impl_.network_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.max_block_time_) - reinterpret_cast(&_impl_.network_id_)) + sizeof(_impl_.max_block_time_)); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* StatusData::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.StatusData) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 network_id = 1; if (this->_internal_network_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_network_id(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H256 total_difficulty = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.total_difficulty_, _impl_.total_difficulty_->GetCachedSize(), target, stream); } // .types.H256 best_hash = 3; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.best_hash_, _impl_.best_hash_->GetCachedSize(), target, stream); } // .sentry.Forks fork_data = 4; if (cached_has_bits & 0x00000004u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, *_impl_.fork_data_, _impl_.fork_data_->GetCachedSize(), target, stream); } // uint64 max_block_height = 5; if (this->_internal_max_block_height() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 5, this->_internal_max_block_height(), target); } // uint64 max_block_time = 6; if (this->_internal_max_block_time() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 6, this->_internal_max_block_time(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.StatusData) return target; } ::size_t StatusData::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.StatusData) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { // .types.H256 total_difficulty = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.total_difficulty_); } // .types.H256 best_hash = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.best_hash_); } // .sentry.Forks fork_data = 4; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.fork_data_); } } // uint64 network_id = 1; if (this->_internal_network_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_network_id()); } // uint64 max_block_height = 5; if (this->_internal_max_block_height() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_max_block_height()); } // uint64 max_block_time = 6; if (this->_internal_max_block_time() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_max_block_time()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void StatusData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.StatusData) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.total_difficulty_ != nullptr); if (_this->_impl_.total_difficulty_ == nullptr) { _this->_impl_.total_difficulty_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.total_difficulty_); } else { _this->_impl_.total_difficulty_->MergeFrom(*from._impl_.total_difficulty_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.best_hash_ != nullptr); if (_this->_impl_.best_hash_ == nullptr) { _this->_impl_.best_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.best_hash_); } else { _this->_impl_.best_hash_->MergeFrom(*from._impl_.best_hash_); } } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(from._impl_.fork_data_ != nullptr); if (_this->_impl_.fork_data_ == nullptr) { _this->_impl_.fork_data_ = ::google::protobuf::Message::CopyConstruct<::sentry::Forks>(arena, *from._impl_.fork_data_); } else { _this->_impl_.fork_data_->MergeFrom(*from._impl_.fork_data_); } } } if (from._internal_network_id() != 0) { _this->_impl_.network_id_ = from._impl_.network_id_; } if (from._internal_max_block_height() != 0) { _this->_impl_.max_block_height_ = from._impl_.max_block_height_; } if (from._internal_max_block_time() != 0) { _this->_impl_.max_block_time_ = from._impl_.max_block_time_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void StatusData::CopyFrom(const StatusData& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.StatusData) if (&from == this) return; Clear(); MergeFrom(from); } void StatusData::InternalSwap(StatusData* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(StatusData, _impl_.max_block_time_) + sizeof(StatusData::_impl_.max_block_time_) - PROTOBUF_FIELD_OFFSET(StatusData, _impl_.total_difficulty_)>( reinterpret_cast(&_impl_.total_difficulty_), reinterpret_cast(&other->_impl_.total_difficulty_)); } ::google::protobuf::Metadata StatusData::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SetStatusReply::_Internal { public: }; SetStatusReply::SetStatusReply(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:sentry.SetStatusReply) } SetStatusReply::SetStatusReply( ::google::protobuf::Arena* arena, const SetStatusReply& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { SetStatusReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:sentry.SetStatusReply) } const ::google::protobuf::MessageLite::ClassData* SetStatusReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SetStatusReply, _impl_._cached_size_), false, }, &SetStatusReply::MergeImpl, &SetStatusReply::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SetStatusReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SetStatusReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::SetStatusReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata SetStatusReply::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HandShakeReply::_Internal { public: }; HandShakeReply::HandShakeReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.HandShakeReply) } HandShakeReply::HandShakeReply( ::google::protobuf::Arena* arena, const HandShakeReply& from) : HandShakeReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE HandShakeReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void HandShakeReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.protocol_ = {}; } HandShakeReply::~HandShakeReply() { // @@protoc_insertion_point(destructor:sentry.HandShakeReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HandShakeReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HandShakeReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HandShakeReply, _impl_._cached_size_), false, }, &HandShakeReply::MergeImpl, &HandShakeReply::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> HandShakeReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HandShakeReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::HandShakeReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .sentry.Protocol protocol = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(HandShakeReply, _impl_.protocol_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(HandShakeReply, _impl_.protocol_)}}, }}, {{ 65535, 65535 }}, {{ // .sentry.Protocol protocol = 1; {PROTOBUF_FIELD_OFFSET(HandShakeReply, _impl_.protocol_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void HandShakeReply::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.HandShakeReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.protocol_ = 0; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HandShakeReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.HandShakeReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .sentry.Protocol protocol = 1; if (this->_internal_protocol() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_protocol(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.HandShakeReply) return target; } ::size_t HandShakeReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.HandShakeReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .sentry.Protocol protocol = 1; if (this->_internal_protocol() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_protocol()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HandShakeReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.HandShakeReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_protocol() != 0) { _this->_impl_.protocol_ = from._impl_.protocol_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HandShakeReply::CopyFrom(const HandShakeReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.HandShakeReply) if (&from == this) return; Clear(); MergeFrom(from); } void HandShakeReply::InternalSwap(HandShakeReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.protocol_, other->_impl_.protocol_); } ::google::protobuf::Metadata HandShakeReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class MessagesRequest::_Internal { public: }; MessagesRequest::MessagesRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.MessagesRequest) } inline PROTOBUF_NDEBUG_INLINE MessagesRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::MessagesRequest& from_msg) : ids_{visibility, arena, from.ids_}, _ids_cached_byte_size_{0}, _cached_size_{0} {} MessagesRequest::MessagesRequest( ::google::protobuf::Arena* arena, const MessagesRequest& from) : ::google::protobuf::Message(arena) { MessagesRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:sentry.MessagesRequest) } inline PROTOBUF_NDEBUG_INLINE MessagesRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : ids_{visibility, arena}, _ids_cached_byte_size_{0}, _cached_size_{0} {} inline void MessagesRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } MessagesRequest::~MessagesRequest() { // @@protoc_insertion_point(destructor:sentry.MessagesRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void MessagesRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* MessagesRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(MessagesRequest, _impl_._cached_size_), false, }, &MessagesRequest::MergeImpl, &MessagesRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> MessagesRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_MessagesRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::MessagesRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .sentry.MessageId ids = 1; {::_pbi::TcParser::FastV32P1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(MessagesRequest, _impl_.ids_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .sentry.MessageId ids = 1; {PROTOBUF_FIELD_OFFSET(MessagesRequest, _impl_.ids_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedOpenEnum)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void MessagesRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.MessagesRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.ids_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* MessagesRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.MessagesRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .sentry.MessageId ids = 1; { std::size_t byte_size = _impl_._ids_cached_byte_size_.Get(); if (byte_size > 0) { target = stream->WriteEnumPacked(1, _internal_ids(), byte_size, target); } } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.MessagesRequest) return target; } ::size_t MessagesRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.MessagesRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .sentry.MessageId ids = 1; { std::size_t data_size = 0; auto count = static_cast(this->_internal_ids_size()); for (std::size_t i = 0; i < count; ++i) { data_size += ::_pbi::WireFormatLite::EnumSize( this->_internal_ids().Get(static_cast(i))); } total_size += data_size; if (data_size > 0) { total_size += 1; total_size += ::_pbi::WireFormatLite::Int32Size( static_cast(data_size)); } _impl_._ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void MessagesRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.MessagesRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_ids()->MergeFrom(from._internal_ids()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void MessagesRequest::CopyFrom(const MessagesRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.MessagesRequest) if (&from == this) return; Clear(); MergeFrom(from); } void MessagesRequest::InternalSwap(MessagesRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.ids_.InternalSwap(&other->_impl_.ids_); } ::google::protobuf::Metadata MessagesRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeersReply::_Internal { public: }; void PeersReply::clear_peers() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.peers_.Clear(); } PeersReply::PeersReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PeersReply) } inline PROTOBUF_NDEBUG_INLINE PeersReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::PeersReply& from_msg) : peers_{visibility, arena, from.peers_}, _cached_size_{0} {} PeersReply::PeersReply( ::google::protobuf::Arena* arena, const PeersReply& from) : ::google::protobuf::Message(arena) { PeersReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:sentry.PeersReply) } inline PROTOBUF_NDEBUG_INLINE PeersReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : peers_{visibility, arena}, _cached_size_{0} {} inline void PeersReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PeersReply::~PeersReply() { // @@protoc_insertion_point(destructor:sentry.PeersReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeersReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeersReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeersReply, _impl_._cached_size_), false, }, &PeersReply::MergeImpl, &PeersReply::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> PeersReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PeersReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeersReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.PeerInfo peers = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(PeersReply, _impl_.peers_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.PeerInfo peers = 1; {PROTOBUF_FIELD_OFFSET(PeersReply, _impl_.peers_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::PeerInfo>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PeersReply::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PeersReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.peers_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeersReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PeersReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.PeerInfo peers = 1; for (unsigned i = 0, n = static_cast( this->_internal_peers_size()); i < n; i++) { const auto& repfield = this->_internal_peers().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PeersReply) return target; } ::size_t PeersReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PeersReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.PeerInfo peers = 1; total_size += 1UL * this->_internal_peers_size(); for (const auto& msg : this->_internal_peers()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeersReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PeersReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_peers()->MergeFrom( from._internal_peers()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeersReply::CopyFrom(const PeersReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PeersReply) if (&from == this) return; Clear(); MergeFrom(from); } void PeersReply::InternalSwap(PeersReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.peers_.InternalSwap(&other->_impl_.peers_); } ::google::protobuf::Metadata PeersReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerCountRequest::_Internal { public: }; PeerCountRequest::PeerCountRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:sentry.PeerCountRequest) } PeerCountRequest::PeerCountRequest( ::google::protobuf::Arena* arena, const PeerCountRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { PeerCountRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:sentry.PeerCountRequest) } const ::google::protobuf::MessageLite::ClassData* PeerCountRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerCountRequest, _impl_._cached_size_), false, }, &PeerCountRequest::MergeImpl, &PeerCountRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> PeerCountRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_PeerCountRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerCountRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata PeerCountRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerCountPerProtocol::_Internal { public: }; PeerCountPerProtocol::PeerCountPerProtocol(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PeerCountPerProtocol) } PeerCountPerProtocol::PeerCountPerProtocol( ::google::protobuf::Arena* arena, const PeerCountPerProtocol& from) : PeerCountPerProtocol(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE PeerCountPerProtocol::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void PeerCountPerProtocol::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, count_), 0, offsetof(Impl_, protocol_) - offsetof(Impl_, count_) + sizeof(Impl_::protocol_)); } PeerCountPerProtocol::~PeerCountPerProtocol() { // @@protoc_insertion_point(destructor:sentry.PeerCountPerProtocol) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeerCountPerProtocol::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeerCountPerProtocol::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerCountPerProtocol, _impl_._cached_size_), false, }, &PeerCountPerProtocol::MergeImpl, &PeerCountPerProtocol::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> PeerCountPerProtocol::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_PeerCountPerProtocol_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerCountPerProtocol>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 count = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PeerCountPerProtocol, _impl_.count_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(PeerCountPerProtocol, _impl_.count_)}}, // .sentry.Protocol protocol = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PeerCountPerProtocol, _impl_.protocol_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(PeerCountPerProtocol, _impl_.protocol_)}}, }}, {{ 65535, 65535 }}, {{ // .sentry.Protocol protocol = 1; {PROTOBUF_FIELD_OFFSET(PeerCountPerProtocol, _impl_.protocol_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // uint64 count = 2; {PROTOBUF_FIELD_OFFSET(PeerCountPerProtocol, _impl_.count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void PeerCountPerProtocol::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PeerCountPerProtocol) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.count_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.protocol_) - reinterpret_cast(&_impl_.count_)) + sizeof(_impl_.protocol_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeerCountPerProtocol::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PeerCountPerProtocol) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .sentry.Protocol protocol = 1; if (this->_internal_protocol() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_protocol(), target); } // uint64 count = 2; if (this->_internal_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_count(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PeerCountPerProtocol) return target; } ::size_t PeerCountPerProtocol::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PeerCountPerProtocol) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 count = 2; if (this->_internal_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_count()); } // .sentry.Protocol protocol = 1; if (this->_internal_protocol() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_protocol()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeerCountPerProtocol::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PeerCountPerProtocol) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_count() != 0) { _this->_impl_.count_ = from._impl_.count_; } if (from._internal_protocol() != 0) { _this->_impl_.protocol_ = from._impl_.protocol_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeerCountPerProtocol::CopyFrom(const PeerCountPerProtocol& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PeerCountPerProtocol) if (&from == this) return; Clear(); MergeFrom(from); } void PeerCountPerProtocol::InternalSwap(PeerCountPerProtocol* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(PeerCountPerProtocol, _impl_.protocol_) + sizeof(PeerCountPerProtocol::_impl_.protocol_) - PROTOBUF_FIELD_OFFSET(PeerCountPerProtocol, _impl_.count_)>( reinterpret_cast(&_impl_.count_), reinterpret_cast(&other->_impl_.count_)); } ::google::protobuf::Metadata PeerCountPerProtocol::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerCountReply::_Internal { public: }; PeerCountReply::PeerCountReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PeerCountReply) } inline PROTOBUF_NDEBUG_INLINE PeerCountReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::PeerCountReply& from_msg) : counts_per_protocol_{visibility, arena, from.counts_per_protocol_}, _cached_size_{0} {} PeerCountReply::PeerCountReply( ::google::protobuf::Arena* arena, const PeerCountReply& from) : ::google::protobuf::Message(arena) { PeerCountReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.count_ = from._impl_.count_; // @@protoc_insertion_point(copy_constructor:sentry.PeerCountReply) } inline PROTOBUF_NDEBUG_INLINE PeerCountReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : counts_per_protocol_{visibility, arena}, _cached_size_{0} {} inline void PeerCountReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.count_ = {}; } PeerCountReply::~PeerCountReply() { // @@protoc_insertion_point(destructor:sentry.PeerCountReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeerCountReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeerCountReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerCountReply, _impl_._cached_size_), false, }, &PeerCountReply::MergeImpl, &PeerCountReply::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> PeerCountReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PeerCountReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerCountReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .sentry.PeerCountPerProtocol counts_per_protocol = 2; {::_pbi::TcParser::FastMtR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(PeerCountReply, _impl_.counts_per_protocol_)}}, // uint64 count = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PeerCountReply, _impl_.count_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(PeerCountReply, _impl_.count_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 count = 1; {PROTOBUF_FIELD_OFFSET(PeerCountReply, _impl_.count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // repeated .sentry.PeerCountPerProtocol counts_per_protocol = 2; {PROTOBUF_FIELD_OFFSET(PeerCountReply, _impl_.counts_per_protocol_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::sentry::PeerCountPerProtocol>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PeerCountReply::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PeerCountReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.counts_per_protocol_.Clear(); _impl_.count_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeerCountReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PeerCountReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 count = 1; if (this->_internal_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_count(), target); } // repeated .sentry.PeerCountPerProtocol counts_per_protocol = 2; for (unsigned i = 0, n = static_cast( this->_internal_counts_per_protocol_size()); i < n; i++) { const auto& repfield = this->_internal_counts_per_protocol().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PeerCountReply) return target; } ::size_t PeerCountReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PeerCountReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .sentry.PeerCountPerProtocol counts_per_protocol = 2; total_size += 1UL * this->_internal_counts_per_protocol_size(); for (const auto& msg : this->_internal_counts_per_protocol()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // uint64 count = 1; if (this->_internal_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_count()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeerCountReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PeerCountReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_counts_per_protocol()->MergeFrom( from._internal_counts_per_protocol()); if (from._internal_count() != 0) { _this->_impl_.count_ = from._impl_.count_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeerCountReply::CopyFrom(const PeerCountReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PeerCountReply) if (&from == this) return; Clear(); MergeFrom(from); } void PeerCountReply::InternalSwap(PeerCountReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.counts_per_protocol_.InternalSwap(&other->_impl_.counts_per_protocol_); swap(_impl_.count_, other->_impl_.count_); } ::google::protobuf::Metadata PeerCountReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerByIdRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(PeerByIdRequest, _impl_._has_bits_); }; void PeerByIdRequest::clear_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ != nullptr) _impl_.peer_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } PeerByIdRequest::PeerByIdRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PeerByIdRequest) } inline PROTOBUF_NDEBUG_INLINE PeerByIdRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::PeerByIdRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} PeerByIdRequest::PeerByIdRequest( ::google::protobuf::Arena* arena, const PeerByIdRequest& from) : ::google::protobuf::Message(arena) { PeerByIdRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.peer_id_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.peer_id_) : nullptr; // @@protoc_insertion_point(copy_constructor:sentry.PeerByIdRequest) } inline PROTOBUF_NDEBUG_INLINE PeerByIdRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void PeerByIdRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.peer_id_ = {}; } PeerByIdRequest::~PeerByIdRequest() { // @@protoc_insertion_point(destructor:sentry.PeerByIdRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeerByIdRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.peer_id_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeerByIdRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerByIdRequest, _impl_._cached_size_), false, }, &PeerByIdRequest::MergeImpl, &PeerByIdRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> PeerByIdRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(PeerByIdRequest, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PeerByIdRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerByIdRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H512 peer_id = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(PeerByIdRequest, _impl_.peer_id_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H512 peer_id = 1; {PROTOBUF_FIELD_OFFSET(PeerByIdRequest, _impl_.peer_id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PeerByIdRequest::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PeerByIdRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.peer_id_ != nullptr); _impl_.peer_id_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeerByIdRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PeerByIdRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H512 peer_id = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.peer_id_, _impl_.peer_id_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PeerByIdRequest) return target; } ::size_t PeerByIdRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PeerByIdRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .types.H512 peer_id = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.peer_id_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeerByIdRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PeerByIdRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.peer_id_ != nullptr); if (_this->_impl_.peer_id_ == nullptr) { _this->_impl_.peer_id_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.peer_id_); } else { _this->_impl_.peer_id_->MergeFrom(*from._impl_.peer_id_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeerByIdRequest::CopyFrom(const PeerByIdRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PeerByIdRequest) if (&from == this) return; Clear(); MergeFrom(from); } void PeerByIdRequest::InternalSwap(PeerByIdRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.peer_id_, other->_impl_.peer_id_); } ::google::protobuf::Metadata PeerByIdRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerByIdReply::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(PeerByIdReply, _impl_._has_bits_); }; void PeerByIdReply::clear_peer() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_ != nullptr) _impl_.peer_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } PeerByIdReply::PeerByIdReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PeerByIdReply) } inline PROTOBUF_NDEBUG_INLINE PeerByIdReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::PeerByIdReply& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} PeerByIdReply::PeerByIdReply( ::google::protobuf::Arena* arena, const PeerByIdReply& from) : ::google::protobuf::Message(arena) { PeerByIdReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.peer_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::PeerInfo>( arena, *from._impl_.peer_) : nullptr; // @@protoc_insertion_point(copy_constructor:sentry.PeerByIdReply) } inline PROTOBUF_NDEBUG_INLINE PeerByIdReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void PeerByIdReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.peer_ = {}; } PeerByIdReply::~PeerByIdReply() { // @@protoc_insertion_point(destructor:sentry.PeerByIdReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeerByIdReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.peer_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeerByIdReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerByIdReply, _impl_._cached_size_), false, }, &PeerByIdReply::MergeImpl, &PeerByIdReply::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> PeerByIdReply::_table_ = { { PROTOBUF_FIELD_OFFSET(PeerByIdReply, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PeerByIdReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerByIdReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional .types.PeerInfo peer = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(PeerByIdReply, _impl_.peer_)}}, }}, {{ 65535, 65535 }}, {{ // optional .types.PeerInfo peer = 1; {PROTOBUF_FIELD_OFFSET(PeerByIdReply, _impl_.peer_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::PeerInfo>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PeerByIdReply::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PeerByIdReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.peer_ != nullptr); _impl_.peer_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeerByIdReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PeerByIdReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional .types.PeerInfo peer = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.peer_, _impl_.peer_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PeerByIdReply) return target; } ::size_t PeerByIdReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PeerByIdReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional .types.PeerInfo peer = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.peer_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeerByIdReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PeerByIdReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.peer_ != nullptr); if (_this->_impl_.peer_ == nullptr) { _this->_impl_.peer_ = ::google::protobuf::Message::CopyConstruct<::types::PeerInfo>(arena, *from._impl_.peer_); } else { _this->_impl_.peer_->MergeFrom(*from._impl_.peer_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeerByIdReply::CopyFrom(const PeerByIdReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PeerByIdReply) if (&from == this) return; Clear(); MergeFrom(from); } void PeerByIdReply::InternalSwap(PeerByIdReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.peer_, other->_impl_.peer_); } ::google::protobuf::Metadata PeerByIdReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerEventsRequest::_Internal { public: }; PeerEventsRequest::PeerEventsRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:sentry.PeerEventsRequest) } PeerEventsRequest::PeerEventsRequest( ::google::protobuf::Arena* arena, const PeerEventsRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { PeerEventsRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:sentry.PeerEventsRequest) } const ::google::protobuf::MessageLite::ClassData* PeerEventsRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerEventsRequest, _impl_._cached_size_), false, }, &PeerEventsRequest::MergeImpl, &PeerEventsRequest::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> PeerEventsRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_PeerEventsRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerEventsRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata PeerEventsRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerEvent::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_._has_bits_); }; void PeerEvent::clear_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ != nullptr) _impl_.peer_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } PeerEvent::PeerEvent(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.PeerEvent) } inline PROTOBUF_NDEBUG_INLINE PeerEvent::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::sentry::PeerEvent& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} PeerEvent::PeerEvent( ::google::protobuf::Arena* arena, const PeerEvent& from) : ::google::protobuf::Message(arena) { PeerEvent* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.peer_id_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.peer_id_) : nullptr; _impl_.event_id_ = from._impl_.event_id_; // @@protoc_insertion_point(copy_constructor:sentry.PeerEvent) } inline PROTOBUF_NDEBUG_INLINE PeerEvent::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void PeerEvent::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, peer_id_), 0, offsetof(Impl_, event_id_) - offsetof(Impl_, peer_id_) + sizeof(Impl_::event_id_)); } PeerEvent::~PeerEvent() { // @@protoc_insertion_point(destructor:sentry.PeerEvent) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeerEvent::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.peer_id_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeerEvent::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_._cached_size_), false, }, &PeerEvent::MergeImpl, &PeerEvent::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> PeerEvent::_table_ = { { PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PeerEvent_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::PeerEvent>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .sentry.PeerEvent.PeerEventId event_id = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PeerEvent, _impl_.event_id_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_.event_id_)}}, // .types.H512 peer_id = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_.peer_id_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H512 peer_id = 1; {PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_.peer_id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .sentry.PeerEvent.PeerEventId event_id = 2; {PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_.event_id_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PeerEvent::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.PeerEvent) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.peer_id_ != nullptr); _impl_.peer_id_->Clear(); } _impl_.event_id_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeerEvent::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.PeerEvent) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H512 peer_id = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.peer_id_, _impl_.peer_id_->GetCachedSize(), target, stream); } // .sentry.PeerEvent.PeerEventId event_id = 2; if (this->_internal_event_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 2, this->_internal_event_id(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.PeerEvent) return target; } ::size_t PeerEvent::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.PeerEvent) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H512 peer_id = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.peer_id_); } // .sentry.PeerEvent.PeerEventId event_id = 2; if (this->_internal_event_id() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_event_id()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeerEvent::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.PeerEvent) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.peer_id_ != nullptr); if (_this->_impl_.peer_id_ == nullptr) { _this->_impl_.peer_id_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.peer_id_); } else { _this->_impl_.peer_id_->MergeFrom(*from._impl_.peer_id_); } } if (from._internal_event_id() != 0) { _this->_impl_.event_id_ = from._impl_.event_id_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeerEvent::CopyFrom(const PeerEvent& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.PeerEvent) if (&from == this) return; Clear(); MergeFrom(from); } void PeerEvent::InternalSwap(PeerEvent* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_.event_id_) + sizeof(PeerEvent::_impl_.event_id_) - PROTOBUF_FIELD_OFFSET(PeerEvent, _impl_.peer_id_)>( reinterpret_cast(&_impl_.peer_id_), reinterpret_cast(&other->_impl_.peer_id_)); } ::google::protobuf::Metadata PeerEvent::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AddPeerReply::_Internal { public: }; AddPeerReply::AddPeerReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:sentry.AddPeerReply) } AddPeerReply::AddPeerReply( ::google::protobuf::Arena* arena, const AddPeerReply& from) : AddPeerReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE AddPeerReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void AddPeerReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.success_ = {}; } AddPeerReply::~AddPeerReply() { // @@protoc_insertion_point(destructor:sentry.AddPeerReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AddPeerReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AddPeerReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AddPeerReply, _impl_._cached_size_), false, }, &AddPeerReply::MergeImpl, &AddPeerReply::kDescriptorMethods, &descriptor_table_p2psentry_2fsentry_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> AddPeerReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AddPeerReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::sentry::AddPeerReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool success = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(AddPeerReply, _impl_.success_)}}, }}, {{ 65535, 65535 }}, {{ // bool success = 1; {PROTOBUF_FIELD_OFFSET(AddPeerReply, _impl_.success_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void AddPeerReply::Clear() { // @@protoc_insertion_point(message_clear_start:sentry.AddPeerReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.success_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AddPeerReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:sentry.AddPeerReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool success = 1; if (this->_internal_success() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_success(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:sentry.AddPeerReply) return target; } ::size_t AddPeerReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:sentry.AddPeerReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool success = 1; if (this->_internal_success() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AddPeerReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:sentry.AddPeerReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_success() != 0) { _this->_impl_.success_ = from._impl_.success_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AddPeerReply::CopyFrom(const AddPeerReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:sentry.AddPeerReply) if (&from == this) return; Clear(); MergeFrom(from); } void AddPeerReply::InternalSwap(AddPeerReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.success_, other->_impl_.success_); } ::google::protobuf::Metadata AddPeerReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace sentry namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_p2psentry_2fsentry_2eproto), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/p2psentry/sentry.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: p2psentry/sentry.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_p2psentry_2fsentry_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_p2psentry_2fsentry_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_bases.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" #include "types/types.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_p2psentry_2fsentry_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_p2psentry_2fsentry_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_p2psentry_2fsentry_2eproto; namespace sentry { class AddPeerReply; struct AddPeerReplyDefaultTypeInternal; extern AddPeerReplyDefaultTypeInternal _AddPeerReply_default_instance_; class AddPeerRequest; struct AddPeerRequestDefaultTypeInternal; extern AddPeerRequestDefaultTypeInternal _AddPeerRequest_default_instance_; class Forks; struct ForksDefaultTypeInternal; extern ForksDefaultTypeInternal _Forks_default_instance_; class HandShakeReply; struct HandShakeReplyDefaultTypeInternal; extern HandShakeReplyDefaultTypeInternal _HandShakeReply_default_instance_; class InboundMessage; struct InboundMessageDefaultTypeInternal; extern InboundMessageDefaultTypeInternal _InboundMessage_default_instance_; class MessagesRequest; struct MessagesRequestDefaultTypeInternal; extern MessagesRequestDefaultTypeInternal _MessagesRequest_default_instance_; class OutboundMessageData; struct OutboundMessageDataDefaultTypeInternal; extern OutboundMessageDataDefaultTypeInternal _OutboundMessageData_default_instance_; class PeerByIdReply; struct PeerByIdReplyDefaultTypeInternal; extern PeerByIdReplyDefaultTypeInternal _PeerByIdReply_default_instance_; class PeerByIdRequest; struct PeerByIdRequestDefaultTypeInternal; extern PeerByIdRequestDefaultTypeInternal _PeerByIdRequest_default_instance_; class PeerCountPerProtocol; struct PeerCountPerProtocolDefaultTypeInternal; extern PeerCountPerProtocolDefaultTypeInternal _PeerCountPerProtocol_default_instance_; class PeerCountReply; struct PeerCountReplyDefaultTypeInternal; extern PeerCountReplyDefaultTypeInternal _PeerCountReply_default_instance_; class PeerCountRequest; struct PeerCountRequestDefaultTypeInternal; extern PeerCountRequestDefaultTypeInternal _PeerCountRequest_default_instance_; class PeerEvent; struct PeerEventDefaultTypeInternal; extern PeerEventDefaultTypeInternal _PeerEvent_default_instance_; class PeerEventsRequest; struct PeerEventsRequestDefaultTypeInternal; extern PeerEventsRequestDefaultTypeInternal _PeerEventsRequest_default_instance_; class PeerMinBlockRequest; struct PeerMinBlockRequestDefaultTypeInternal; extern PeerMinBlockRequestDefaultTypeInternal _PeerMinBlockRequest_default_instance_; class PeersReply; struct PeersReplyDefaultTypeInternal; extern PeersReplyDefaultTypeInternal _PeersReply_default_instance_; class PenalizePeerRequest; struct PenalizePeerRequestDefaultTypeInternal; extern PenalizePeerRequestDefaultTypeInternal _PenalizePeerRequest_default_instance_; class SendMessageByIdRequest; struct SendMessageByIdRequestDefaultTypeInternal; extern SendMessageByIdRequestDefaultTypeInternal _SendMessageByIdRequest_default_instance_; class SendMessageByMinBlockRequest; struct SendMessageByMinBlockRequestDefaultTypeInternal; extern SendMessageByMinBlockRequestDefaultTypeInternal _SendMessageByMinBlockRequest_default_instance_; class SendMessageToRandomPeersRequest; struct SendMessageToRandomPeersRequestDefaultTypeInternal; extern SendMessageToRandomPeersRequestDefaultTypeInternal _SendMessageToRandomPeersRequest_default_instance_; class SentPeers; struct SentPeersDefaultTypeInternal; extern SentPeersDefaultTypeInternal _SentPeers_default_instance_; class SetStatusReply; struct SetStatusReplyDefaultTypeInternal; extern SetStatusReplyDefaultTypeInternal _SetStatusReply_default_instance_; class StatusData; struct StatusDataDefaultTypeInternal; extern StatusDataDefaultTypeInternal _StatusData_default_instance_; } // namespace sentry namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace sentry { enum PeerEvent_PeerEventId : int { PeerEvent_PeerEventId_Connect = 0, PeerEvent_PeerEventId_Disconnect = 1, PeerEvent_PeerEventId_PeerEvent_PeerEventId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), PeerEvent_PeerEventId_PeerEvent_PeerEventId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool PeerEvent_PeerEventId_IsValid(int value); extern const uint32_t PeerEvent_PeerEventId_internal_data_[]; constexpr PeerEvent_PeerEventId PeerEvent_PeerEventId_PeerEventId_MIN = static_cast(0); constexpr PeerEvent_PeerEventId PeerEvent_PeerEventId_PeerEventId_MAX = static_cast(1); constexpr int PeerEvent_PeerEventId_PeerEventId_ARRAYSIZE = 1 + 1; const ::google::protobuf::EnumDescriptor* PeerEvent_PeerEventId_descriptor(); template const std::string& PeerEvent_PeerEventId_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to PeerEventId_Name()."); return PeerEvent_PeerEventId_Name(static_cast(value)); } template <> inline const std::string& PeerEvent_PeerEventId_Name(PeerEvent_PeerEventId value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool PeerEvent_PeerEventId_Parse(absl::string_view name, PeerEvent_PeerEventId* value) { return ::google::protobuf::internal::ParseNamedEnum( PeerEvent_PeerEventId_descriptor(), name, value); } enum MessageId : int { STATUS_65 = 0, GET_BLOCK_HEADERS_65 = 1, BLOCK_HEADERS_65 = 2, BLOCK_HASHES_65 = 3, GET_BLOCK_BODIES_65 = 4, BLOCK_BODIES_65 = 5, GET_NODE_DATA_65 = 6, NODE_DATA_65 = 7, GET_RECEIPTS_65 = 8, RECEIPTS_65 = 9, NEW_BLOCK_HASHES_65 = 10, NEW_BLOCK_65 = 11, TRANSACTIONS_65 = 12, NEW_POOLED_TRANSACTION_HASHES_65 = 13, GET_POOLED_TRANSACTIONS_65 = 14, POOLED_TRANSACTIONS_65 = 15, STATUS_66 = 17, NEW_BLOCK_HASHES_66 = 18, NEW_BLOCK_66 = 19, TRANSACTIONS_66 = 20, NEW_POOLED_TRANSACTION_HASHES_66 = 21, GET_BLOCK_HEADERS_66 = 22, GET_BLOCK_BODIES_66 = 23, GET_NODE_DATA_66 = 24, GET_RECEIPTS_66 = 25, GET_POOLED_TRANSACTIONS_66 = 26, BLOCK_HEADERS_66 = 27, BLOCK_BODIES_66 = 28, NODE_DATA_66 = 29, RECEIPTS_66 = 30, POOLED_TRANSACTIONS_66 = 31, NEW_POOLED_TRANSACTION_HASHES_68 = 32, MessageId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), MessageId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool MessageId_IsValid(int value); extern const uint32_t MessageId_internal_data_[]; constexpr MessageId MessageId_MIN = static_cast(0); constexpr MessageId MessageId_MAX = static_cast(32); constexpr int MessageId_ARRAYSIZE = 32 + 1; const ::google::protobuf::EnumDescriptor* MessageId_descriptor(); template const std::string& MessageId_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to MessageId_Name()."); return MessageId_Name(static_cast(value)); } template <> inline const std::string& MessageId_Name(MessageId value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool MessageId_Parse(absl::string_view name, MessageId* value) { return ::google::protobuf::internal::ParseNamedEnum( MessageId_descriptor(), name, value); } enum PenaltyKind : int { Kick = 0, PenaltyKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), PenaltyKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool PenaltyKind_IsValid(int value); extern const uint32_t PenaltyKind_internal_data_[]; constexpr PenaltyKind PenaltyKind_MIN = static_cast(0); constexpr PenaltyKind PenaltyKind_MAX = static_cast(0); constexpr int PenaltyKind_ARRAYSIZE = 0 + 1; const ::google::protobuf::EnumDescriptor* PenaltyKind_descriptor(); template const std::string& PenaltyKind_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to PenaltyKind_Name()."); return PenaltyKind_Name(static_cast(value)); } template <> inline const std::string& PenaltyKind_Name(PenaltyKind value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool PenaltyKind_Parse(absl::string_view name, PenaltyKind* value) { return ::google::protobuf::internal::ParseNamedEnum( PenaltyKind_descriptor(), name, value); } enum Protocol : int { ETH65 = 0, ETH66 = 1, ETH67 = 2, ETH68 = 3, Protocol_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), Protocol_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool Protocol_IsValid(int value); extern const uint32_t Protocol_internal_data_[]; constexpr Protocol Protocol_MIN = static_cast(0); constexpr Protocol Protocol_MAX = static_cast(3); constexpr int Protocol_ARRAYSIZE = 3 + 1; const ::google::protobuf::EnumDescriptor* Protocol_descriptor(); template const std::string& Protocol_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to Protocol_Name()."); return Protocol_Name(static_cast(value)); } template <> inline const std::string& Protocol_Name(Protocol value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool Protocol_Parse(absl::string_view name, Protocol* value) { return ::google::protobuf::internal::ParseNamedEnum( Protocol_descriptor(), name, value); } // =================================================================== // ------------------------------------------------------------------- class SetStatusReply final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:sentry.SetStatusReply) */ { public: inline SetStatusReply() : SetStatusReply(nullptr) {} template explicit PROTOBUF_CONSTEXPR SetStatusReply( ::google::protobuf::internal::ConstantInitialized); inline SetStatusReply(const SetStatusReply& from) : SetStatusReply(nullptr, from) {} inline SetStatusReply(SetStatusReply&& from) noexcept : SetStatusReply(nullptr, std::move(from)) {} inline SetStatusReply& operator=(const SetStatusReply& from) { CopyFrom(from); return *this; } inline SetStatusReply& operator=(SetStatusReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SetStatusReply& default_instance() { return *internal_default_instance(); } static inline const SetStatusReply* internal_default_instance() { return reinterpret_cast( &_SetStatusReply_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(SetStatusReply& a, SetStatusReply& b) { a.Swap(&b); } inline void Swap(SetStatusReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SetStatusReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SetStatusReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const SetStatusReply& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const SetStatusReply& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.SetStatusReply"; } protected: explicit SetStatusReply(::google::protobuf::Arena* arena); SetStatusReply(::google::protobuf::Arena* arena, const SetStatusReply& from); SetStatusReply(::google::protobuf::Arena* arena, SetStatusReply&& from) noexcept : SetStatusReply(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:sentry.SetStatusReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SetStatusReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SetStatusReply& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerEventsRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:sentry.PeerEventsRequest) */ { public: inline PeerEventsRequest() : PeerEventsRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR PeerEventsRequest( ::google::protobuf::internal::ConstantInitialized); inline PeerEventsRequest(const PeerEventsRequest& from) : PeerEventsRequest(nullptr, from) {} inline PeerEventsRequest(PeerEventsRequest&& from) noexcept : PeerEventsRequest(nullptr, std::move(from)) {} inline PeerEventsRequest& operator=(const PeerEventsRequest& from) { CopyFrom(from); return *this; } inline PeerEventsRequest& operator=(PeerEventsRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerEventsRequest& default_instance() { return *internal_default_instance(); } static inline const PeerEventsRequest* internal_default_instance() { return reinterpret_cast( &_PeerEventsRequest_default_instance_); } static constexpr int kIndexInFileMessages = 20; friend void swap(PeerEventsRequest& a, PeerEventsRequest& b) { a.Swap(&b); } inline void Swap(PeerEventsRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerEventsRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerEventsRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const PeerEventsRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const PeerEventsRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerEventsRequest"; } protected: explicit PeerEventsRequest(::google::protobuf::Arena* arena); PeerEventsRequest(::google::protobuf::Arena* arena, const PeerEventsRequest& from); PeerEventsRequest(::google::protobuf::Arena* arena, PeerEventsRequest&& from) noexcept : PeerEventsRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:sentry.PeerEventsRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerEventsRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerEventsRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerCountRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:sentry.PeerCountRequest) */ { public: inline PeerCountRequest() : PeerCountRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR PeerCountRequest( ::google::protobuf::internal::ConstantInitialized); inline PeerCountRequest(const PeerCountRequest& from) : PeerCountRequest(nullptr, from) {} inline PeerCountRequest(PeerCountRequest&& from) noexcept : PeerCountRequest(nullptr, std::move(from)) {} inline PeerCountRequest& operator=(const PeerCountRequest& from) { CopyFrom(from); return *this; } inline PeerCountRequest& operator=(PeerCountRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerCountRequest& default_instance() { return *internal_default_instance(); } static inline const PeerCountRequest* internal_default_instance() { return reinterpret_cast( &_PeerCountRequest_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(PeerCountRequest& a, PeerCountRequest& b) { a.Swap(&b); } inline void Swap(PeerCountRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerCountRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerCountRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const PeerCountRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const PeerCountRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerCountRequest"; } protected: explicit PeerCountRequest(::google::protobuf::Arena* arena); PeerCountRequest(::google::protobuf::Arena* arena, const PeerCountRequest& from); PeerCountRequest(::google::protobuf::Arena* arena, PeerCountRequest&& from) noexcept : PeerCountRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:sentry.PeerCountRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerCountRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerCountRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerCountPerProtocol final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PeerCountPerProtocol) */ { public: inline PeerCountPerProtocol() : PeerCountPerProtocol(nullptr) {} ~PeerCountPerProtocol() override; template explicit PROTOBUF_CONSTEXPR PeerCountPerProtocol( ::google::protobuf::internal::ConstantInitialized); inline PeerCountPerProtocol(const PeerCountPerProtocol& from) : PeerCountPerProtocol(nullptr, from) {} inline PeerCountPerProtocol(PeerCountPerProtocol&& from) noexcept : PeerCountPerProtocol(nullptr, std::move(from)) {} inline PeerCountPerProtocol& operator=(const PeerCountPerProtocol& from) { CopyFrom(from); return *this; } inline PeerCountPerProtocol& operator=(PeerCountPerProtocol&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerCountPerProtocol& default_instance() { return *internal_default_instance(); } static inline const PeerCountPerProtocol* internal_default_instance() { return reinterpret_cast( &_PeerCountPerProtocol_default_instance_); } static constexpr int kIndexInFileMessages = 16; friend void swap(PeerCountPerProtocol& a, PeerCountPerProtocol& b) { a.Swap(&b); } inline void Swap(PeerCountPerProtocol* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerCountPerProtocol* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerCountPerProtocol* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeerCountPerProtocol& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeerCountPerProtocol& from) { PeerCountPerProtocol::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeerCountPerProtocol* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerCountPerProtocol"; } protected: explicit PeerCountPerProtocol(::google::protobuf::Arena* arena); PeerCountPerProtocol(::google::protobuf::Arena* arena, const PeerCountPerProtocol& from); PeerCountPerProtocol(::google::protobuf::Arena* arena, PeerCountPerProtocol&& from) noexcept : PeerCountPerProtocol(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCountFieldNumber = 2, kProtocolFieldNumber = 1, }; // uint64 count = 2; void clear_count() ; ::uint64_t count() const; void set_count(::uint64_t value); private: ::uint64_t _internal_count() const; void _internal_set_count(::uint64_t value); public: // .sentry.Protocol protocol = 1; void clear_protocol() ; ::sentry::Protocol protocol() const; void set_protocol(::sentry::Protocol value); private: ::sentry::Protocol _internal_protocol() const; void _internal_set_protocol(::sentry::Protocol value); public: // @@protoc_insertion_point(class_scope:sentry.PeerCountPerProtocol) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerCountPerProtocol_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerCountPerProtocol& from_msg); ::uint64_t count_; int protocol_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class OutboundMessageData final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.OutboundMessageData) */ { public: inline OutboundMessageData() : OutboundMessageData(nullptr) {} ~OutboundMessageData() override; template explicit PROTOBUF_CONSTEXPR OutboundMessageData( ::google::protobuf::internal::ConstantInitialized); inline OutboundMessageData(const OutboundMessageData& from) : OutboundMessageData(nullptr, from) {} inline OutboundMessageData(OutboundMessageData&& from) noexcept : OutboundMessageData(nullptr, std::move(from)) {} inline OutboundMessageData& operator=(const OutboundMessageData& from) { CopyFrom(from); return *this; } inline OutboundMessageData& operator=(OutboundMessageData&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OutboundMessageData& default_instance() { return *internal_default_instance(); } static inline const OutboundMessageData* internal_default_instance() { return reinterpret_cast( &_OutboundMessageData_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(OutboundMessageData& a, OutboundMessageData& b) { a.Swap(&b); } inline void Swap(OutboundMessageData* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OutboundMessageData* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OutboundMessageData* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const OutboundMessageData& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const OutboundMessageData& from) { OutboundMessageData::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(OutboundMessageData* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.OutboundMessageData"; } protected: explicit OutboundMessageData(::google::protobuf::Arena* arena); OutboundMessageData(::google::protobuf::Arena* arena, const OutboundMessageData& from); OutboundMessageData(::google::protobuf::Arena* arena, OutboundMessageData&& from) noexcept : OutboundMessageData(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 2, kIdFieldNumber = 1, }; // bytes data = 2; void clear_data() ; const std::string& data() const; template void set_data(Arg_&& arg, Args_... args); std::string* mutable_data(); PROTOBUF_NODISCARD std::string* release_data(); void set_allocated_data(std::string* value); private: const std::string& _internal_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( const std::string& value); std::string* _internal_mutable_data(); public: // .sentry.MessageId id = 1; void clear_id() ; ::sentry::MessageId id() const; void set_id(::sentry::MessageId value); private: ::sentry::MessageId _internal_id() const; void _internal_set_id(::sentry::MessageId value); public: // @@protoc_insertion_point(class_scope:sentry.OutboundMessageData) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OutboundMessageData_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OutboundMessageData& from_msg); ::google::protobuf::internal::ArenaStringPtr data_; int id_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class MessagesRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.MessagesRequest) */ { public: inline MessagesRequest() : MessagesRequest(nullptr) {} ~MessagesRequest() override; template explicit PROTOBUF_CONSTEXPR MessagesRequest( ::google::protobuf::internal::ConstantInitialized); inline MessagesRequest(const MessagesRequest& from) : MessagesRequest(nullptr, from) {} inline MessagesRequest(MessagesRequest&& from) noexcept : MessagesRequest(nullptr, std::move(from)) {} inline MessagesRequest& operator=(const MessagesRequest& from) { CopyFrom(from); return *this; } inline MessagesRequest& operator=(MessagesRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const MessagesRequest& default_instance() { return *internal_default_instance(); } static inline const MessagesRequest* internal_default_instance() { return reinterpret_cast( &_MessagesRequest_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(MessagesRequest& a, MessagesRequest& b) { a.Swap(&b); } inline void Swap(MessagesRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MessagesRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MessagesRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const MessagesRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const MessagesRequest& from) { MessagesRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(MessagesRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.MessagesRequest"; } protected: explicit MessagesRequest(::google::protobuf::Arena* arena); MessagesRequest(::google::protobuf::Arena* arena, const MessagesRequest& from); MessagesRequest(::google::protobuf::Arena* arena, MessagesRequest&& from) noexcept : MessagesRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdsFieldNumber = 1, }; // repeated .sentry.MessageId ids = 1; int ids_size() const; private: int _internal_ids_size() const; public: void clear_ids() ; public: ::sentry::MessageId ids(int index) const; void set_ids(int index, ::sentry::MessageId value); void add_ids(::sentry::MessageId value); const ::google::protobuf::RepeatedField& ids() const; ::google::protobuf::RepeatedField* mutable_ids(); private: const ::google::protobuf::RepeatedField& _internal_ids() const; ::google::protobuf::RepeatedField* _internal_mutable_ids(); public: // @@protoc_insertion_point(class_scope:sentry.MessagesRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_MessagesRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const MessagesRequest& from_msg); ::google::protobuf::RepeatedField ids_; mutable ::google::protobuf::internal::CachedSize _ids_cached_byte_size_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class HandShakeReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.HandShakeReply) */ { public: inline HandShakeReply() : HandShakeReply(nullptr) {} ~HandShakeReply() override; template explicit PROTOBUF_CONSTEXPR HandShakeReply( ::google::protobuf::internal::ConstantInitialized); inline HandShakeReply(const HandShakeReply& from) : HandShakeReply(nullptr, from) {} inline HandShakeReply(HandShakeReply&& from) noexcept : HandShakeReply(nullptr, std::move(from)) {} inline HandShakeReply& operator=(const HandShakeReply& from) { CopyFrom(from); return *this; } inline HandShakeReply& operator=(HandShakeReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HandShakeReply& default_instance() { return *internal_default_instance(); } static inline const HandShakeReply* internal_default_instance() { return reinterpret_cast( &_HandShakeReply_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(HandShakeReply& a, HandShakeReply& b) { a.Swap(&b); } inline void Swap(HandShakeReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HandShakeReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HandShakeReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HandShakeReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HandShakeReply& from) { HandShakeReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HandShakeReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.HandShakeReply"; } protected: explicit HandShakeReply(::google::protobuf::Arena* arena); HandShakeReply(::google::protobuf::Arena* arena, const HandShakeReply& from); HandShakeReply(::google::protobuf::Arena* arena, HandShakeReply&& from) noexcept : HandShakeReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kProtocolFieldNumber = 1, }; // .sentry.Protocol protocol = 1; void clear_protocol() ; ::sentry::Protocol protocol() const; void set_protocol(::sentry::Protocol value); private: ::sentry::Protocol _internal_protocol() const; void _internal_set_protocol(::sentry::Protocol value); public: // @@protoc_insertion_point(class_scope:sentry.HandShakeReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HandShakeReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HandShakeReply& from_msg); int protocol_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class AddPeerRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.AddPeerRequest) */ { public: inline AddPeerRequest() : AddPeerRequest(nullptr) {} ~AddPeerRequest() override; template explicit PROTOBUF_CONSTEXPR AddPeerRequest( ::google::protobuf::internal::ConstantInitialized); inline AddPeerRequest(const AddPeerRequest& from) : AddPeerRequest(nullptr, from) {} inline AddPeerRequest(AddPeerRequest&& from) noexcept : AddPeerRequest(nullptr, std::move(from)) {} inline AddPeerRequest& operator=(const AddPeerRequest& from) { CopyFrom(from); return *this; } inline AddPeerRequest& operator=(AddPeerRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AddPeerRequest& default_instance() { return *internal_default_instance(); } static inline const AddPeerRequest* internal_default_instance() { return reinterpret_cast( &_AddPeerRequest_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(AddPeerRequest& a, AddPeerRequest& b) { a.Swap(&b); } inline void Swap(AddPeerRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AddPeerRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AddPeerRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AddPeerRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AddPeerRequest& from) { AddPeerRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AddPeerRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.AddPeerRequest"; } protected: explicit AddPeerRequest(::google::protobuf::Arena* arena); AddPeerRequest(::google::protobuf::Arena* arena, const AddPeerRequest& from); AddPeerRequest(::google::protobuf::Arena* arena, AddPeerRequest&& from) noexcept : AddPeerRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kUrlFieldNumber = 1, }; // string url = 1; void clear_url() ; const std::string& url() const; template void set_url(Arg_&& arg, Args_... args); std::string* mutable_url(); PROTOBUF_NODISCARD std::string* release_url(); void set_allocated_url(std::string* value); private: const std::string& _internal_url() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_url( const std::string& value); std::string* _internal_mutable_url(); public: // @@protoc_insertion_point(class_scope:sentry.AddPeerRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 33, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AddPeerRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AddPeerRequest& from_msg); ::google::protobuf::internal::ArenaStringPtr url_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class AddPeerReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.AddPeerReply) */ { public: inline AddPeerReply() : AddPeerReply(nullptr) {} ~AddPeerReply() override; template explicit PROTOBUF_CONSTEXPR AddPeerReply( ::google::protobuf::internal::ConstantInitialized); inline AddPeerReply(const AddPeerReply& from) : AddPeerReply(nullptr, from) {} inline AddPeerReply(AddPeerReply&& from) noexcept : AddPeerReply(nullptr, std::move(from)) {} inline AddPeerReply& operator=(const AddPeerReply& from) { CopyFrom(from); return *this; } inline AddPeerReply& operator=(AddPeerReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AddPeerReply& default_instance() { return *internal_default_instance(); } static inline const AddPeerReply* internal_default_instance() { return reinterpret_cast( &_AddPeerReply_default_instance_); } static constexpr int kIndexInFileMessages = 22; friend void swap(AddPeerReply& a, AddPeerReply& b) { a.Swap(&b); } inline void Swap(AddPeerReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AddPeerReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AddPeerReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AddPeerReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AddPeerReply& from) { AddPeerReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AddPeerReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.AddPeerReply"; } protected: explicit AddPeerReply(::google::protobuf::Arena* arena); AddPeerReply(::google::protobuf::Arena* arena, const AddPeerReply& from); AddPeerReply(::google::protobuf::Arena* arena, AddPeerReply&& from) noexcept : AddPeerReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSuccessFieldNumber = 1, }; // bool success = 1; void clear_success() ; bool success() const; void set_success(bool value); private: bool _internal_success() const; void _internal_set_success(bool value); public: // @@protoc_insertion_point(class_scope:sentry.AddPeerReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AddPeerReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AddPeerReply& from_msg); bool success_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class SendMessageToRandomPeersRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.SendMessageToRandomPeersRequest) */ { public: inline SendMessageToRandomPeersRequest() : SendMessageToRandomPeersRequest(nullptr) {} ~SendMessageToRandomPeersRequest() override; template explicit PROTOBUF_CONSTEXPR SendMessageToRandomPeersRequest( ::google::protobuf::internal::ConstantInitialized); inline SendMessageToRandomPeersRequest(const SendMessageToRandomPeersRequest& from) : SendMessageToRandomPeersRequest(nullptr, from) {} inline SendMessageToRandomPeersRequest(SendMessageToRandomPeersRequest&& from) noexcept : SendMessageToRandomPeersRequest(nullptr, std::move(from)) {} inline SendMessageToRandomPeersRequest& operator=(const SendMessageToRandomPeersRequest& from) { CopyFrom(from); return *this; } inline SendMessageToRandomPeersRequest& operator=(SendMessageToRandomPeersRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SendMessageToRandomPeersRequest& default_instance() { return *internal_default_instance(); } static inline const SendMessageToRandomPeersRequest* internal_default_instance() { return reinterpret_cast( &_SendMessageToRandomPeersRequest_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(SendMessageToRandomPeersRequest& a, SendMessageToRandomPeersRequest& b) { a.Swap(&b); } inline void Swap(SendMessageToRandomPeersRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SendMessageToRandomPeersRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SendMessageToRandomPeersRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SendMessageToRandomPeersRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SendMessageToRandomPeersRequest& from) { SendMessageToRandomPeersRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SendMessageToRandomPeersRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.SendMessageToRandomPeersRequest"; } protected: explicit SendMessageToRandomPeersRequest(::google::protobuf::Arena* arena); SendMessageToRandomPeersRequest(::google::protobuf::Arena* arena, const SendMessageToRandomPeersRequest& from); SendMessageToRandomPeersRequest(::google::protobuf::Arena* arena, SendMessageToRandomPeersRequest&& from) noexcept : SendMessageToRandomPeersRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 1, kMaxPeersFieldNumber = 2, }; // .sentry.OutboundMessageData data = 1; bool has_data() const; void clear_data() ; const ::sentry::OutboundMessageData& data() const; PROTOBUF_NODISCARD ::sentry::OutboundMessageData* release_data(); ::sentry::OutboundMessageData* mutable_data(); void set_allocated_data(::sentry::OutboundMessageData* value); void unsafe_arena_set_allocated_data(::sentry::OutboundMessageData* value); ::sentry::OutboundMessageData* unsafe_arena_release_data(); private: const ::sentry::OutboundMessageData& _internal_data() const; ::sentry::OutboundMessageData* _internal_mutable_data(); public: // uint64 max_peers = 2; void clear_max_peers() ; ::uint64_t max_peers() const; void set_max_peers(::uint64_t value); private: ::uint64_t _internal_max_peers() const; void _internal_set_max_peers(::uint64_t value); public: // @@protoc_insertion_point(class_scope:sentry.SendMessageToRandomPeersRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SendMessageToRandomPeersRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SendMessageToRandomPeersRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::sentry::OutboundMessageData* data_; ::uint64_t max_peers_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class SendMessageByMinBlockRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.SendMessageByMinBlockRequest) */ { public: inline SendMessageByMinBlockRequest() : SendMessageByMinBlockRequest(nullptr) {} ~SendMessageByMinBlockRequest() override; template explicit PROTOBUF_CONSTEXPR SendMessageByMinBlockRequest( ::google::protobuf::internal::ConstantInitialized); inline SendMessageByMinBlockRequest(const SendMessageByMinBlockRequest& from) : SendMessageByMinBlockRequest(nullptr, from) {} inline SendMessageByMinBlockRequest(SendMessageByMinBlockRequest&& from) noexcept : SendMessageByMinBlockRequest(nullptr, std::move(from)) {} inline SendMessageByMinBlockRequest& operator=(const SendMessageByMinBlockRequest& from) { CopyFrom(from); return *this; } inline SendMessageByMinBlockRequest& operator=(SendMessageByMinBlockRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SendMessageByMinBlockRequest& default_instance() { return *internal_default_instance(); } static inline const SendMessageByMinBlockRequest* internal_default_instance() { return reinterpret_cast( &_SendMessageByMinBlockRequest_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(SendMessageByMinBlockRequest& a, SendMessageByMinBlockRequest& b) { a.Swap(&b); } inline void Swap(SendMessageByMinBlockRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SendMessageByMinBlockRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SendMessageByMinBlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SendMessageByMinBlockRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SendMessageByMinBlockRequest& from) { SendMessageByMinBlockRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SendMessageByMinBlockRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.SendMessageByMinBlockRequest"; } protected: explicit SendMessageByMinBlockRequest(::google::protobuf::Arena* arena); SendMessageByMinBlockRequest(::google::protobuf::Arena* arena, const SendMessageByMinBlockRequest& from); SendMessageByMinBlockRequest(::google::protobuf::Arena* arena, SendMessageByMinBlockRequest&& from) noexcept : SendMessageByMinBlockRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 1, kMinBlockFieldNumber = 2, kMaxPeersFieldNumber = 3, }; // .sentry.OutboundMessageData data = 1; bool has_data() const; void clear_data() ; const ::sentry::OutboundMessageData& data() const; PROTOBUF_NODISCARD ::sentry::OutboundMessageData* release_data(); ::sentry::OutboundMessageData* mutable_data(); void set_allocated_data(::sentry::OutboundMessageData* value); void unsafe_arena_set_allocated_data(::sentry::OutboundMessageData* value); ::sentry::OutboundMessageData* unsafe_arena_release_data(); private: const ::sentry::OutboundMessageData& _internal_data() const; ::sentry::OutboundMessageData* _internal_mutable_data(); public: // uint64 min_block = 2; void clear_min_block() ; ::uint64_t min_block() const; void set_min_block(::uint64_t value); private: ::uint64_t _internal_min_block() const; void _internal_set_min_block(::uint64_t value); public: // uint64 max_peers = 3; void clear_max_peers() ; ::uint64_t max_peers() const; void set_max_peers(::uint64_t value); private: ::uint64_t _internal_max_peers() const; void _internal_set_max_peers(::uint64_t value); public: // @@protoc_insertion_point(class_scope:sentry.SendMessageByMinBlockRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SendMessageByMinBlockRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SendMessageByMinBlockRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::sentry::OutboundMessageData* data_; ::uint64_t min_block_; ::uint64_t max_peers_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeersReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PeersReply) */ { public: inline PeersReply() : PeersReply(nullptr) {} ~PeersReply() override; template explicit PROTOBUF_CONSTEXPR PeersReply( ::google::protobuf::internal::ConstantInitialized); inline PeersReply(const PeersReply& from) : PeersReply(nullptr, from) {} inline PeersReply(PeersReply&& from) noexcept : PeersReply(nullptr, std::move(from)) {} inline PeersReply& operator=(const PeersReply& from) { CopyFrom(from); return *this; } inline PeersReply& operator=(PeersReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeersReply& default_instance() { return *internal_default_instance(); } static inline const PeersReply* internal_default_instance() { return reinterpret_cast( &_PeersReply_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(PeersReply& a, PeersReply& b) { a.Swap(&b); } inline void Swap(PeersReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeersReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeersReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeersReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeersReply& from) { PeersReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeersReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeersReply"; } protected: explicit PeersReply(::google::protobuf::Arena* arena); PeersReply(::google::protobuf::Arena* arena, const PeersReply& from); PeersReply(::google::protobuf::Arena* arena, PeersReply&& from) noexcept : PeersReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPeersFieldNumber = 1, }; // repeated .types.PeerInfo peers = 1; int peers_size() const; private: int _internal_peers_size() const; public: void clear_peers() ; ::types::PeerInfo* mutable_peers(int index); ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* mutable_peers(); private: const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& _internal_peers() const; ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* _internal_mutable_peers(); public: const ::types::PeerInfo& peers(int index) const; ::types::PeerInfo* add_peers(); const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& peers() const; // @@protoc_insertion_point(class_scope:sentry.PeersReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeersReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeersReply& from_msg); ::google::protobuf::RepeatedPtrField< ::types::PeerInfo > peers_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerCountReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PeerCountReply) */ { public: inline PeerCountReply() : PeerCountReply(nullptr) {} ~PeerCountReply() override; template explicit PROTOBUF_CONSTEXPR PeerCountReply( ::google::protobuf::internal::ConstantInitialized); inline PeerCountReply(const PeerCountReply& from) : PeerCountReply(nullptr, from) {} inline PeerCountReply(PeerCountReply&& from) noexcept : PeerCountReply(nullptr, std::move(from)) {} inline PeerCountReply& operator=(const PeerCountReply& from) { CopyFrom(from); return *this; } inline PeerCountReply& operator=(PeerCountReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerCountReply& default_instance() { return *internal_default_instance(); } static inline const PeerCountReply* internal_default_instance() { return reinterpret_cast( &_PeerCountReply_default_instance_); } static constexpr int kIndexInFileMessages = 17; friend void swap(PeerCountReply& a, PeerCountReply& b) { a.Swap(&b); } inline void Swap(PeerCountReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerCountReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerCountReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeerCountReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeerCountReply& from) { PeerCountReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeerCountReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerCountReply"; } protected: explicit PeerCountReply(::google::protobuf::Arena* arena); PeerCountReply(::google::protobuf::Arena* arena, const PeerCountReply& from); PeerCountReply(::google::protobuf::Arena* arena, PeerCountReply&& from) noexcept : PeerCountReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCountsPerProtocolFieldNumber = 2, kCountFieldNumber = 1, }; // repeated .sentry.PeerCountPerProtocol counts_per_protocol = 2; int counts_per_protocol_size() const; private: int _internal_counts_per_protocol_size() const; public: void clear_counts_per_protocol() ; ::sentry::PeerCountPerProtocol* mutable_counts_per_protocol(int index); ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>* mutable_counts_per_protocol(); private: const ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>& _internal_counts_per_protocol() const; ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>* _internal_mutable_counts_per_protocol(); public: const ::sentry::PeerCountPerProtocol& counts_per_protocol(int index) const; ::sentry::PeerCountPerProtocol* add_counts_per_protocol(); const ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>& counts_per_protocol() const; // uint64 count = 1; void clear_count() ; ::uint64_t count() const; void set_count(::uint64_t value); private: ::uint64_t _internal_count() const; void _internal_set_count(::uint64_t value); public: // @@protoc_insertion_point(class_scope:sentry.PeerCountReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerCountReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerCountReply& from_msg); ::google::protobuf::RepeatedPtrField< ::sentry::PeerCountPerProtocol > counts_per_protocol_; ::uint64_t count_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerByIdReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PeerByIdReply) */ { public: inline PeerByIdReply() : PeerByIdReply(nullptr) {} ~PeerByIdReply() override; template explicit PROTOBUF_CONSTEXPR PeerByIdReply( ::google::protobuf::internal::ConstantInitialized); inline PeerByIdReply(const PeerByIdReply& from) : PeerByIdReply(nullptr, from) {} inline PeerByIdReply(PeerByIdReply&& from) noexcept : PeerByIdReply(nullptr, std::move(from)) {} inline PeerByIdReply& operator=(const PeerByIdReply& from) { CopyFrom(from); return *this; } inline PeerByIdReply& operator=(PeerByIdReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerByIdReply& default_instance() { return *internal_default_instance(); } static inline const PeerByIdReply* internal_default_instance() { return reinterpret_cast( &_PeerByIdReply_default_instance_); } static constexpr int kIndexInFileMessages = 19; friend void swap(PeerByIdReply& a, PeerByIdReply& b) { a.Swap(&b); } inline void Swap(PeerByIdReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerByIdReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerByIdReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeerByIdReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeerByIdReply& from) { PeerByIdReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeerByIdReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerByIdReply"; } protected: explicit PeerByIdReply(::google::protobuf::Arena* arena); PeerByIdReply(::google::protobuf::Arena* arena, const PeerByIdReply& from); PeerByIdReply(::google::protobuf::Arena* arena, PeerByIdReply&& from) noexcept : PeerByIdReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPeerFieldNumber = 1, }; // optional .types.PeerInfo peer = 1; bool has_peer() const; void clear_peer() ; const ::types::PeerInfo& peer() const; PROTOBUF_NODISCARD ::types::PeerInfo* release_peer(); ::types::PeerInfo* mutable_peer(); void set_allocated_peer(::types::PeerInfo* value); void unsafe_arena_set_allocated_peer(::types::PeerInfo* value); ::types::PeerInfo* unsafe_arena_release_peer(); private: const ::types::PeerInfo& _internal_peer() const; ::types::PeerInfo* _internal_mutable_peer(); public: // @@protoc_insertion_point(class_scope:sentry.PeerByIdReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerByIdReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerByIdReply& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::PeerInfo* peer_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class Forks final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.Forks) */ { public: inline Forks() : Forks(nullptr) {} ~Forks() override; template explicit PROTOBUF_CONSTEXPR Forks( ::google::protobuf::internal::ConstantInitialized); inline Forks(const Forks& from) : Forks(nullptr, from) {} inline Forks(Forks&& from) noexcept : Forks(nullptr, std::move(from)) {} inline Forks& operator=(const Forks& from) { CopyFrom(from); return *this; } inline Forks& operator=(Forks&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Forks& default_instance() { return *internal_default_instance(); } static inline const Forks* internal_default_instance() { return reinterpret_cast( &_Forks_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(Forks& a, Forks& b) { a.Swap(&b); } inline void Swap(Forks* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Forks* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Forks* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Forks& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Forks& from) { Forks::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Forks* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.Forks"; } protected: explicit Forks(::google::protobuf::Arena* arena); Forks(::google::protobuf::Arena* arena, const Forks& from); Forks(::google::protobuf::Arena* arena, Forks&& from) noexcept : Forks(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHeightForksFieldNumber = 2, kTimeForksFieldNumber = 3, kGenesisFieldNumber = 1, }; // repeated uint64 height_forks = 2; int height_forks_size() const; private: int _internal_height_forks_size() const; public: void clear_height_forks() ; ::uint64_t height_forks(int index) const; void set_height_forks(int index, ::uint64_t value); void add_height_forks(::uint64_t value); const ::google::protobuf::RepeatedField<::uint64_t>& height_forks() const; ::google::protobuf::RepeatedField<::uint64_t>* mutable_height_forks(); private: const ::google::protobuf::RepeatedField<::uint64_t>& _internal_height_forks() const; ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_height_forks(); public: // repeated uint64 time_forks = 3; int time_forks_size() const; private: int _internal_time_forks_size() const; public: void clear_time_forks() ; ::uint64_t time_forks(int index) const; void set_time_forks(int index, ::uint64_t value); void add_time_forks(::uint64_t value); const ::google::protobuf::RepeatedField<::uint64_t>& time_forks() const; ::google::protobuf::RepeatedField<::uint64_t>* mutable_time_forks(); private: const ::google::protobuf::RepeatedField<::uint64_t>& _internal_time_forks() const; ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_time_forks(); public: // .types.H256 genesis = 1; bool has_genesis() const; void clear_genesis() ; const ::types::H256& genesis() const; PROTOBUF_NODISCARD ::types::H256* release_genesis(); ::types::H256* mutable_genesis(); void set_allocated_genesis(::types::H256* value); void unsafe_arena_set_allocated_genesis(::types::H256* value); ::types::H256* unsafe_arena_release_genesis(); private: const ::types::H256& _internal_genesis() const; ::types::H256* _internal_mutable_genesis(); public: // @@protoc_insertion_point(class_scope:sentry.Forks) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Forks_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Forks& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedField<::uint64_t> height_forks_; mutable ::google::protobuf::internal::CachedSize _height_forks_cached_byte_size_; ::google::protobuf::RepeatedField<::uint64_t> time_forks_; mutable ::google::protobuf::internal::CachedSize _time_forks_cached_byte_size_; ::types::H256* genesis_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class StatusData final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.StatusData) */ { public: inline StatusData() : StatusData(nullptr) {} ~StatusData() override; template explicit PROTOBUF_CONSTEXPR StatusData( ::google::protobuf::internal::ConstantInitialized); inline StatusData(const StatusData& from) : StatusData(nullptr, from) {} inline StatusData(StatusData&& from) noexcept : StatusData(nullptr, std::move(from)) {} inline StatusData& operator=(const StatusData& from) { CopyFrom(from); return *this; } inline StatusData& operator=(StatusData&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const StatusData& default_instance() { return *internal_default_instance(); } static inline const StatusData* internal_default_instance() { return reinterpret_cast( &_StatusData_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(StatusData& a, StatusData& b) { a.Swap(&b); } inline void Swap(StatusData* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StatusData* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StatusData* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const StatusData& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const StatusData& from) { StatusData::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(StatusData* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.StatusData"; } protected: explicit StatusData(::google::protobuf::Arena* arena); StatusData(::google::protobuf::Arena* arena, const StatusData& from); StatusData(::google::protobuf::Arena* arena, StatusData&& from) noexcept : StatusData(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTotalDifficultyFieldNumber = 2, kBestHashFieldNumber = 3, kForkDataFieldNumber = 4, kNetworkIdFieldNumber = 1, kMaxBlockHeightFieldNumber = 5, kMaxBlockTimeFieldNumber = 6, }; // .types.H256 total_difficulty = 2; bool has_total_difficulty() const; void clear_total_difficulty() ; const ::types::H256& total_difficulty() const; PROTOBUF_NODISCARD ::types::H256* release_total_difficulty(); ::types::H256* mutable_total_difficulty(); void set_allocated_total_difficulty(::types::H256* value); void unsafe_arena_set_allocated_total_difficulty(::types::H256* value); ::types::H256* unsafe_arena_release_total_difficulty(); private: const ::types::H256& _internal_total_difficulty() const; ::types::H256* _internal_mutable_total_difficulty(); public: // .types.H256 best_hash = 3; bool has_best_hash() const; void clear_best_hash() ; const ::types::H256& best_hash() const; PROTOBUF_NODISCARD ::types::H256* release_best_hash(); ::types::H256* mutable_best_hash(); void set_allocated_best_hash(::types::H256* value); void unsafe_arena_set_allocated_best_hash(::types::H256* value); ::types::H256* unsafe_arena_release_best_hash(); private: const ::types::H256& _internal_best_hash() const; ::types::H256* _internal_mutable_best_hash(); public: // .sentry.Forks fork_data = 4; bool has_fork_data() const; void clear_fork_data() ; const ::sentry::Forks& fork_data() const; PROTOBUF_NODISCARD ::sentry::Forks* release_fork_data(); ::sentry::Forks* mutable_fork_data(); void set_allocated_fork_data(::sentry::Forks* value); void unsafe_arena_set_allocated_fork_data(::sentry::Forks* value); ::sentry::Forks* unsafe_arena_release_fork_data(); private: const ::sentry::Forks& _internal_fork_data() const; ::sentry::Forks* _internal_mutable_fork_data(); public: // uint64 network_id = 1; void clear_network_id() ; ::uint64_t network_id() const; void set_network_id(::uint64_t value); private: ::uint64_t _internal_network_id() const; void _internal_set_network_id(::uint64_t value); public: // uint64 max_block_height = 5; void clear_max_block_height() ; ::uint64_t max_block_height() const; void set_max_block_height(::uint64_t value); private: ::uint64_t _internal_max_block_height() const; void _internal_set_max_block_height(::uint64_t value); public: // uint64 max_block_time = 6; void clear_max_block_time() ; ::uint64_t max_block_time() const; void set_max_block_time(::uint64_t value); private: ::uint64_t _internal_max_block_time() const; void _internal_set_max_block_time(::uint64_t value); public: // @@protoc_insertion_point(class_scope:sentry.StatusData) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 6, 3, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_StatusData_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const StatusData& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* total_difficulty_; ::types::H256* best_hash_; ::sentry::Forks* fork_data_; ::uint64_t network_id_; ::uint64_t max_block_height_; ::uint64_t max_block_time_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class SentPeers final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.SentPeers) */ { public: inline SentPeers() : SentPeers(nullptr) {} ~SentPeers() override; template explicit PROTOBUF_CONSTEXPR SentPeers( ::google::protobuf::internal::ConstantInitialized); inline SentPeers(const SentPeers& from) : SentPeers(nullptr, from) {} inline SentPeers(SentPeers&& from) noexcept : SentPeers(nullptr, std::move(from)) {} inline SentPeers& operator=(const SentPeers& from) { CopyFrom(from); return *this; } inline SentPeers& operator=(SentPeers&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SentPeers& default_instance() { return *internal_default_instance(); } static inline const SentPeers* internal_default_instance() { return reinterpret_cast( &_SentPeers_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(SentPeers& a, SentPeers& b) { a.Swap(&b); } inline void Swap(SentPeers* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SentPeers* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SentPeers* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SentPeers& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SentPeers& from) { SentPeers::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SentPeers* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.SentPeers"; } protected: explicit SentPeers(::google::protobuf::Arena* arena); SentPeers(::google::protobuf::Arena* arena, const SentPeers& from); SentPeers(::google::protobuf::Arena* arena, SentPeers&& from) noexcept : SentPeers(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPeersFieldNumber = 1, }; // repeated .types.H512 peers = 1; int peers_size() const; private: int _internal_peers_size() const; public: void clear_peers() ; ::types::H512* mutable_peers(int index); ::google::protobuf::RepeatedPtrField<::types::H512>* mutable_peers(); private: const ::google::protobuf::RepeatedPtrField<::types::H512>& _internal_peers() const; ::google::protobuf::RepeatedPtrField<::types::H512>* _internal_mutable_peers(); public: const ::types::H512& peers(int index) const; ::types::H512* add_peers(); const ::google::protobuf::RepeatedPtrField<::types::H512>& peers() const; // @@protoc_insertion_point(class_scope:sentry.SentPeers) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SentPeers_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SentPeers& from_msg); ::google::protobuf::RepeatedPtrField< ::types::H512 > peers_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class SendMessageByIdRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.SendMessageByIdRequest) */ { public: inline SendMessageByIdRequest() : SendMessageByIdRequest(nullptr) {} ~SendMessageByIdRequest() override; template explicit PROTOBUF_CONSTEXPR SendMessageByIdRequest( ::google::protobuf::internal::ConstantInitialized); inline SendMessageByIdRequest(const SendMessageByIdRequest& from) : SendMessageByIdRequest(nullptr, from) {} inline SendMessageByIdRequest(SendMessageByIdRequest&& from) noexcept : SendMessageByIdRequest(nullptr, std::move(from)) {} inline SendMessageByIdRequest& operator=(const SendMessageByIdRequest& from) { CopyFrom(from); return *this; } inline SendMessageByIdRequest& operator=(SendMessageByIdRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SendMessageByIdRequest& default_instance() { return *internal_default_instance(); } static inline const SendMessageByIdRequest* internal_default_instance() { return reinterpret_cast( &_SendMessageByIdRequest_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(SendMessageByIdRequest& a, SendMessageByIdRequest& b) { a.Swap(&b); } inline void Swap(SendMessageByIdRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SendMessageByIdRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SendMessageByIdRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SendMessageByIdRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SendMessageByIdRequest& from) { SendMessageByIdRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SendMessageByIdRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.SendMessageByIdRequest"; } protected: explicit SendMessageByIdRequest(::google::protobuf::Arena* arena); SendMessageByIdRequest(::google::protobuf::Arena* arena, const SendMessageByIdRequest& from); SendMessageByIdRequest(::google::protobuf::Arena* arena, SendMessageByIdRequest&& from) noexcept : SendMessageByIdRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 1, kPeerIdFieldNumber = 2, }; // .sentry.OutboundMessageData data = 1; bool has_data() const; void clear_data() ; const ::sentry::OutboundMessageData& data() const; PROTOBUF_NODISCARD ::sentry::OutboundMessageData* release_data(); ::sentry::OutboundMessageData* mutable_data(); void set_allocated_data(::sentry::OutboundMessageData* value); void unsafe_arena_set_allocated_data(::sentry::OutboundMessageData* value); ::sentry::OutboundMessageData* unsafe_arena_release_data(); private: const ::sentry::OutboundMessageData& _internal_data() const; ::sentry::OutboundMessageData* _internal_mutable_data(); public: // .types.H512 peer_id = 2; bool has_peer_id() const; void clear_peer_id() ; const ::types::H512& peer_id() const; PROTOBUF_NODISCARD ::types::H512* release_peer_id(); ::types::H512* mutable_peer_id(); void set_allocated_peer_id(::types::H512* value); void unsafe_arena_set_allocated_peer_id(::types::H512* value); ::types::H512* unsafe_arena_release_peer_id(); private: const ::types::H512& _internal_peer_id() const; ::types::H512* _internal_mutable_peer_id(); public: // @@protoc_insertion_point(class_scope:sentry.SendMessageByIdRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SendMessageByIdRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SendMessageByIdRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::sentry::OutboundMessageData* data_; ::types::H512* peer_id_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PenalizePeerRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PenalizePeerRequest) */ { public: inline PenalizePeerRequest() : PenalizePeerRequest(nullptr) {} ~PenalizePeerRequest() override; template explicit PROTOBUF_CONSTEXPR PenalizePeerRequest( ::google::protobuf::internal::ConstantInitialized); inline PenalizePeerRequest(const PenalizePeerRequest& from) : PenalizePeerRequest(nullptr, from) {} inline PenalizePeerRequest(PenalizePeerRequest&& from) noexcept : PenalizePeerRequest(nullptr, std::move(from)) {} inline PenalizePeerRequest& operator=(const PenalizePeerRequest& from) { CopyFrom(from); return *this; } inline PenalizePeerRequest& operator=(PenalizePeerRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PenalizePeerRequest& default_instance() { return *internal_default_instance(); } static inline const PenalizePeerRequest* internal_default_instance() { return reinterpret_cast( &_PenalizePeerRequest_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(PenalizePeerRequest& a, PenalizePeerRequest& b) { a.Swap(&b); } inline void Swap(PenalizePeerRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PenalizePeerRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PenalizePeerRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PenalizePeerRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PenalizePeerRequest& from) { PenalizePeerRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PenalizePeerRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PenalizePeerRequest"; } protected: explicit PenalizePeerRequest(::google::protobuf::Arena* arena); PenalizePeerRequest(::google::protobuf::Arena* arena, const PenalizePeerRequest& from); PenalizePeerRequest(::google::protobuf::Arena* arena, PenalizePeerRequest&& from) noexcept : PenalizePeerRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPeerIdFieldNumber = 1, kPenaltyFieldNumber = 2, }; // .types.H512 peer_id = 1; bool has_peer_id() const; void clear_peer_id() ; const ::types::H512& peer_id() const; PROTOBUF_NODISCARD ::types::H512* release_peer_id(); ::types::H512* mutable_peer_id(); void set_allocated_peer_id(::types::H512* value); void unsafe_arena_set_allocated_peer_id(::types::H512* value); ::types::H512* unsafe_arena_release_peer_id(); private: const ::types::H512& _internal_peer_id() const; ::types::H512* _internal_mutable_peer_id(); public: // .sentry.PenaltyKind penalty = 2; void clear_penalty() ; ::sentry::PenaltyKind penalty() const; void set_penalty(::sentry::PenaltyKind value); private: ::sentry::PenaltyKind _internal_penalty() const; void _internal_set_penalty(::sentry::PenaltyKind value); public: // @@protoc_insertion_point(class_scope:sentry.PenalizePeerRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PenalizePeerRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PenalizePeerRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H512* peer_id_; int penalty_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerMinBlockRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PeerMinBlockRequest) */ { public: inline PeerMinBlockRequest() : PeerMinBlockRequest(nullptr) {} ~PeerMinBlockRequest() override; template explicit PROTOBUF_CONSTEXPR PeerMinBlockRequest( ::google::protobuf::internal::ConstantInitialized); inline PeerMinBlockRequest(const PeerMinBlockRequest& from) : PeerMinBlockRequest(nullptr, from) {} inline PeerMinBlockRequest(PeerMinBlockRequest&& from) noexcept : PeerMinBlockRequest(nullptr, std::move(from)) {} inline PeerMinBlockRequest& operator=(const PeerMinBlockRequest& from) { CopyFrom(from); return *this; } inline PeerMinBlockRequest& operator=(PeerMinBlockRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerMinBlockRequest& default_instance() { return *internal_default_instance(); } static inline const PeerMinBlockRequest* internal_default_instance() { return reinterpret_cast( &_PeerMinBlockRequest_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(PeerMinBlockRequest& a, PeerMinBlockRequest& b) { a.Swap(&b); } inline void Swap(PeerMinBlockRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerMinBlockRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerMinBlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeerMinBlockRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeerMinBlockRequest& from) { PeerMinBlockRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeerMinBlockRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerMinBlockRequest"; } protected: explicit PeerMinBlockRequest(::google::protobuf::Arena* arena); PeerMinBlockRequest(::google::protobuf::Arena* arena, const PeerMinBlockRequest& from); PeerMinBlockRequest(::google::protobuf::Arena* arena, PeerMinBlockRequest&& from) noexcept : PeerMinBlockRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPeerIdFieldNumber = 1, kMinBlockFieldNumber = 2, }; // .types.H512 peer_id = 1; bool has_peer_id() const; void clear_peer_id() ; const ::types::H512& peer_id() const; PROTOBUF_NODISCARD ::types::H512* release_peer_id(); ::types::H512* mutable_peer_id(); void set_allocated_peer_id(::types::H512* value); void unsafe_arena_set_allocated_peer_id(::types::H512* value); ::types::H512* unsafe_arena_release_peer_id(); private: const ::types::H512& _internal_peer_id() const; ::types::H512* _internal_mutable_peer_id(); public: // uint64 min_block = 2; void clear_min_block() ; ::uint64_t min_block() const; void set_min_block(::uint64_t value); private: ::uint64_t _internal_min_block() const; void _internal_set_min_block(::uint64_t value); public: // @@protoc_insertion_point(class_scope:sentry.PeerMinBlockRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerMinBlockRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerMinBlockRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H512* peer_id_; ::uint64_t min_block_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerEvent final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PeerEvent) */ { public: inline PeerEvent() : PeerEvent(nullptr) {} ~PeerEvent() override; template explicit PROTOBUF_CONSTEXPR PeerEvent( ::google::protobuf::internal::ConstantInitialized); inline PeerEvent(const PeerEvent& from) : PeerEvent(nullptr, from) {} inline PeerEvent(PeerEvent&& from) noexcept : PeerEvent(nullptr, std::move(from)) {} inline PeerEvent& operator=(const PeerEvent& from) { CopyFrom(from); return *this; } inline PeerEvent& operator=(PeerEvent&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerEvent& default_instance() { return *internal_default_instance(); } static inline const PeerEvent* internal_default_instance() { return reinterpret_cast( &_PeerEvent_default_instance_); } static constexpr int kIndexInFileMessages = 21; friend void swap(PeerEvent& a, PeerEvent& b) { a.Swap(&b); } inline void Swap(PeerEvent* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerEvent* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerEvent* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeerEvent& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeerEvent& from) { PeerEvent::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeerEvent* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerEvent"; } protected: explicit PeerEvent(::google::protobuf::Arena* arena); PeerEvent(::google::protobuf::Arena* arena, const PeerEvent& from); PeerEvent(::google::protobuf::Arena* arena, PeerEvent&& from) noexcept : PeerEvent(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- using PeerEventId = PeerEvent_PeerEventId; static constexpr PeerEventId Connect = PeerEvent_PeerEventId_Connect; static constexpr PeerEventId Disconnect = PeerEvent_PeerEventId_Disconnect; static inline bool PeerEventId_IsValid(int value) { return PeerEvent_PeerEventId_IsValid(value); } static constexpr PeerEventId PeerEventId_MIN = PeerEvent_PeerEventId_PeerEventId_MIN; static constexpr PeerEventId PeerEventId_MAX = PeerEvent_PeerEventId_PeerEventId_MAX; static constexpr int PeerEventId_ARRAYSIZE = PeerEvent_PeerEventId_PeerEventId_ARRAYSIZE; static inline const ::google::protobuf::EnumDescriptor* PeerEventId_descriptor() { return PeerEvent_PeerEventId_descriptor(); } template static inline const std::string& PeerEventId_Name(T value) { return PeerEvent_PeerEventId_Name(value); } static inline bool PeerEventId_Parse(absl::string_view name, PeerEventId* value) { return PeerEvent_PeerEventId_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kPeerIdFieldNumber = 1, kEventIdFieldNumber = 2, }; // .types.H512 peer_id = 1; bool has_peer_id() const; void clear_peer_id() ; const ::types::H512& peer_id() const; PROTOBUF_NODISCARD ::types::H512* release_peer_id(); ::types::H512* mutable_peer_id(); void set_allocated_peer_id(::types::H512* value); void unsafe_arena_set_allocated_peer_id(::types::H512* value); ::types::H512* unsafe_arena_release_peer_id(); private: const ::types::H512& _internal_peer_id() const; ::types::H512* _internal_mutable_peer_id(); public: // .sentry.PeerEvent.PeerEventId event_id = 2; void clear_event_id() ; ::sentry::PeerEvent_PeerEventId event_id() const; void set_event_id(::sentry::PeerEvent_PeerEventId value); private: ::sentry::PeerEvent_PeerEventId _internal_event_id() const; void _internal_set_event_id(::sentry::PeerEvent_PeerEventId value); public: // @@protoc_insertion_point(class_scope:sentry.PeerEvent) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerEvent_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerEvent& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H512* peer_id_; int event_id_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class PeerByIdRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.PeerByIdRequest) */ { public: inline PeerByIdRequest() : PeerByIdRequest(nullptr) {} ~PeerByIdRequest() override; template explicit PROTOBUF_CONSTEXPR PeerByIdRequest( ::google::protobuf::internal::ConstantInitialized); inline PeerByIdRequest(const PeerByIdRequest& from) : PeerByIdRequest(nullptr, from) {} inline PeerByIdRequest(PeerByIdRequest&& from) noexcept : PeerByIdRequest(nullptr, std::move(from)) {} inline PeerByIdRequest& operator=(const PeerByIdRequest& from) { CopyFrom(from); return *this; } inline PeerByIdRequest& operator=(PeerByIdRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerByIdRequest& default_instance() { return *internal_default_instance(); } static inline const PeerByIdRequest* internal_default_instance() { return reinterpret_cast( &_PeerByIdRequest_default_instance_); } static constexpr int kIndexInFileMessages = 18; friend void swap(PeerByIdRequest& a, PeerByIdRequest& b) { a.Swap(&b); } inline void Swap(PeerByIdRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerByIdRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerByIdRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeerByIdRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeerByIdRequest& from) { PeerByIdRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeerByIdRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.PeerByIdRequest"; } protected: explicit PeerByIdRequest(::google::protobuf::Arena* arena); PeerByIdRequest(::google::protobuf::Arena* arena, const PeerByIdRequest& from); PeerByIdRequest(::google::protobuf::Arena* arena, PeerByIdRequest&& from) noexcept : PeerByIdRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPeerIdFieldNumber = 1, }; // .types.H512 peer_id = 1; bool has_peer_id() const; void clear_peer_id() ; const ::types::H512& peer_id() const; PROTOBUF_NODISCARD ::types::H512* release_peer_id(); ::types::H512* mutable_peer_id(); void set_allocated_peer_id(::types::H512* value); void unsafe_arena_set_allocated_peer_id(::types::H512* value); ::types::H512* unsafe_arena_release_peer_id(); private: const ::types::H512& _internal_peer_id() const; ::types::H512* _internal_mutable_peer_id(); public: // @@protoc_insertion_point(class_scope:sentry.PeerByIdRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerByIdRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerByIdRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H512* peer_id_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // ------------------------------------------------------------------- class InboundMessage final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:sentry.InboundMessage) */ { public: inline InboundMessage() : InboundMessage(nullptr) {} ~InboundMessage() override; template explicit PROTOBUF_CONSTEXPR InboundMessage( ::google::protobuf::internal::ConstantInitialized); inline InboundMessage(const InboundMessage& from) : InboundMessage(nullptr, from) {} inline InboundMessage(InboundMessage&& from) noexcept : InboundMessage(nullptr, std::move(from)) {} inline InboundMessage& operator=(const InboundMessage& from) { CopyFrom(from); return *this; } inline InboundMessage& operator=(InboundMessage&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const InboundMessage& default_instance() { return *internal_default_instance(); } static inline const InboundMessage* internal_default_instance() { return reinterpret_cast( &_InboundMessage_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(InboundMessage& a, InboundMessage& b) { a.Swap(&b); } inline void Swap(InboundMessage* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(InboundMessage* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- InboundMessage* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const InboundMessage& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const InboundMessage& from) { InboundMessage::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(InboundMessage* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "sentry.InboundMessage"; } protected: explicit InboundMessage(::google::protobuf::Arena* arena); InboundMessage(::google::protobuf::Arena* arena, const InboundMessage& from); InboundMessage(::google::protobuf::Arena* arena, InboundMessage&& from) noexcept : InboundMessage(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 2, kPeerIdFieldNumber = 3, kIdFieldNumber = 1, }; // bytes data = 2; void clear_data() ; const std::string& data() const; template void set_data(Arg_&& arg, Args_... args); std::string* mutable_data(); PROTOBUF_NODISCARD std::string* release_data(); void set_allocated_data(std::string* value); private: const std::string& _internal_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( const std::string& value); std::string* _internal_mutable_data(); public: // .types.H512 peer_id = 3; bool has_peer_id() const; void clear_peer_id() ; const ::types::H512& peer_id() const; PROTOBUF_NODISCARD ::types::H512* release_peer_id(); ::types::H512* mutable_peer_id(); void set_allocated_peer_id(::types::H512* value); void unsafe_arena_set_allocated_peer_id(::types::H512* value); ::types::H512* unsafe_arena_release_peer_id(); private: const ::types::H512& _internal_peer_id() const; ::types::H512* _internal_mutable_peer_id(); public: // .sentry.MessageId id = 1; void clear_id() ; ::sentry::MessageId id() const; void set_id(::sentry::MessageId value); private: ::sentry::MessageId _internal_id() const; void _internal_set_id(::sentry::MessageId value); public: // @@protoc_insertion_point(class_scope:sentry.InboundMessage) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_InboundMessage_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const InboundMessage& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr data_; ::types::H512* peer_id_; int id_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_p2psentry_2fsentry_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // OutboundMessageData // .sentry.MessageId id = 1; inline void OutboundMessageData::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = 0; } inline ::sentry::MessageId OutboundMessageData::id() const { // @@protoc_insertion_point(field_get:sentry.OutboundMessageData.id) return _internal_id(); } inline void OutboundMessageData::set_id(::sentry::MessageId value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:sentry.OutboundMessageData.id) } inline ::sentry::MessageId OutboundMessageData::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::sentry::MessageId>(_impl_.id_); } inline void OutboundMessageData::_internal_set_id(::sentry::MessageId value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = value; } // bytes data = 2; inline void OutboundMessageData::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.ClearToEmpty(); } inline const std::string& OutboundMessageData::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.OutboundMessageData.data) return _internal_data(); } template inline PROTOBUF_ALWAYS_INLINE void OutboundMessageData::set_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:sentry.OutboundMessageData.data) } inline std::string* OutboundMessageData::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:sentry.OutboundMessageData.data) return _s; } inline const std::string& OutboundMessageData::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.data_.Get(); } inline void OutboundMessageData::_internal_set_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.Set(value, GetArena()); } inline std::string* OutboundMessageData::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.data_.Mutable( GetArena()); } inline std::string* OutboundMessageData::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.OutboundMessageData.data) return _impl_.data_.Release(); } inline void OutboundMessageData::set_allocated_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.data_.IsDefault()) { _impl_.data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:sentry.OutboundMessageData.data) } // ------------------------------------------------------------------- // SendMessageByMinBlockRequest // .sentry.OutboundMessageData data = 1; inline bool SendMessageByMinBlockRequest::has_data() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline void SendMessageByMinBlockRequest::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::sentry::OutboundMessageData& SendMessageByMinBlockRequest::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::sentry::OutboundMessageData* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::sentry::_OutboundMessageData_default_instance_); } inline const ::sentry::OutboundMessageData& SendMessageByMinBlockRequest::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.SendMessageByMinBlockRequest.data) return _internal_data(); } inline void SendMessageByMinBlockRequest::unsafe_arena_set_allocated_data(::sentry::OutboundMessageData* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.SendMessageByMinBlockRequest.data) } inline ::sentry::OutboundMessageData* SendMessageByMinBlockRequest::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::sentry::OutboundMessageData* released = _impl_.data_; _impl_.data_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::sentry::OutboundMessageData* SendMessageByMinBlockRequest::unsafe_arena_release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.SendMessageByMinBlockRequest.data) _impl_._has_bits_[0] &= ~0x00000001u; ::sentry::OutboundMessageData* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } inline ::sentry::OutboundMessageData* SendMessageByMinBlockRequest::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::sentry::OutboundMessageData>(GetArena()); _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(p); } return _impl_.data_; } inline ::sentry::OutboundMessageData* SendMessageByMinBlockRequest::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::sentry::OutboundMessageData* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:sentry.SendMessageByMinBlockRequest.data) return _msg; } inline void SendMessageByMinBlockRequest::set_allocated_data(::sentry::OutboundMessageData* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.data_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.SendMessageByMinBlockRequest.data) } // uint64 min_block = 2; inline void SendMessageByMinBlockRequest::clear_min_block() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.min_block_ = ::uint64_t{0u}; } inline ::uint64_t SendMessageByMinBlockRequest::min_block() const { // @@protoc_insertion_point(field_get:sentry.SendMessageByMinBlockRequest.min_block) return _internal_min_block(); } inline void SendMessageByMinBlockRequest::set_min_block(::uint64_t value) { _internal_set_min_block(value); // @@protoc_insertion_point(field_set:sentry.SendMessageByMinBlockRequest.min_block) } inline ::uint64_t SendMessageByMinBlockRequest::_internal_min_block() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.min_block_; } inline void SendMessageByMinBlockRequest::_internal_set_min_block(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.min_block_ = value; } // uint64 max_peers = 3; inline void SendMessageByMinBlockRequest::clear_max_peers() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_peers_ = ::uint64_t{0u}; } inline ::uint64_t SendMessageByMinBlockRequest::max_peers() const { // @@protoc_insertion_point(field_get:sentry.SendMessageByMinBlockRequest.max_peers) return _internal_max_peers(); } inline void SendMessageByMinBlockRequest::set_max_peers(::uint64_t value) { _internal_set_max_peers(value); // @@protoc_insertion_point(field_set:sentry.SendMessageByMinBlockRequest.max_peers) } inline ::uint64_t SendMessageByMinBlockRequest::_internal_max_peers() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.max_peers_; } inline void SendMessageByMinBlockRequest::_internal_set_max_peers(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_peers_ = value; } // ------------------------------------------------------------------- // SendMessageByIdRequest // .sentry.OutboundMessageData data = 1; inline bool SendMessageByIdRequest::has_data() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline void SendMessageByIdRequest::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::sentry::OutboundMessageData& SendMessageByIdRequest::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::sentry::OutboundMessageData* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::sentry::_OutboundMessageData_default_instance_); } inline const ::sentry::OutboundMessageData& SendMessageByIdRequest::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.SendMessageByIdRequest.data) return _internal_data(); } inline void SendMessageByIdRequest::unsafe_arena_set_allocated_data(::sentry::OutboundMessageData* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.SendMessageByIdRequest.data) } inline ::sentry::OutboundMessageData* SendMessageByIdRequest::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::sentry::OutboundMessageData* released = _impl_.data_; _impl_.data_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::sentry::OutboundMessageData* SendMessageByIdRequest::unsafe_arena_release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.SendMessageByIdRequest.data) _impl_._has_bits_[0] &= ~0x00000001u; ::sentry::OutboundMessageData* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } inline ::sentry::OutboundMessageData* SendMessageByIdRequest::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::sentry::OutboundMessageData>(GetArena()); _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(p); } return _impl_.data_; } inline ::sentry::OutboundMessageData* SendMessageByIdRequest::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::sentry::OutboundMessageData* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:sentry.SendMessageByIdRequest.data) return _msg; } inline void SendMessageByIdRequest::set_allocated_data(::sentry::OutboundMessageData* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.data_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.SendMessageByIdRequest.data) } // .types.H512 peer_id = 2; inline bool SendMessageByIdRequest::has_peer_id() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.peer_id_ != nullptr); return value; } inline const ::types::H512& SendMessageByIdRequest::_internal_peer_id() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.peer_id_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& SendMessageByIdRequest::peer_id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.SendMessageByIdRequest.peer_id) return _internal_peer_id(); } inline void SendMessageByIdRequest::unsafe_arena_set_allocated_peer_id(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.SendMessageByIdRequest.peer_id) } inline ::types::H512* SendMessageByIdRequest::release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H512* released = _impl_.peer_id_; _impl_.peer_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* SendMessageByIdRequest::unsafe_arena_release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.SendMessageByIdRequest.peer_id) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H512* temp = _impl_.peer_id_; _impl_.peer_id_ = nullptr; return temp; } inline ::types::H512* SendMessageByIdRequest::_internal_mutable_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.peer_id_ = reinterpret_cast<::types::H512*>(p); } return _impl_.peer_id_; } inline ::types::H512* SendMessageByIdRequest::mutable_peer_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H512* _msg = _internal_mutable_peer_id(); // @@protoc_insertion_point(field_mutable:sentry.SendMessageByIdRequest.peer_id) return _msg; } inline void SendMessageByIdRequest::set_allocated_peer_id(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.SendMessageByIdRequest.peer_id) } // ------------------------------------------------------------------- // SendMessageToRandomPeersRequest // .sentry.OutboundMessageData data = 1; inline bool SendMessageToRandomPeersRequest::has_data() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr); return value; } inline void SendMessageToRandomPeersRequest::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ != nullptr) _impl_.data_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::sentry::OutboundMessageData& SendMessageToRandomPeersRequest::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::sentry::OutboundMessageData* p = _impl_.data_; return p != nullptr ? *p : reinterpret_cast(::sentry::_OutboundMessageData_default_instance_); } inline const ::sentry::OutboundMessageData& SendMessageToRandomPeersRequest::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.SendMessageToRandomPeersRequest.data) return _internal_data(); } inline void SendMessageToRandomPeersRequest::unsafe_arena_set_allocated_data(::sentry::OutboundMessageData* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.data_); } _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.SendMessageToRandomPeersRequest.data) } inline ::sentry::OutboundMessageData* SendMessageToRandomPeersRequest::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::sentry::OutboundMessageData* released = _impl_.data_; _impl_.data_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::sentry::OutboundMessageData* SendMessageToRandomPeersRequest::unsafe_arena_release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.SendMessageToRandomPeersRequest.data) _impl_._has_bits_[0] &= ~0x00000001u; ::sentry::OutboundMessageData* temp = _impl_.data_; _impl_.data_ = nullptr; return temp; } inline ::sentry::OutboundMessageData* SendMessageToRandomPeersRequest::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.data_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::sentry::OutboundMessageData>(GetArena()); _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(p); } return _impl_.data_; } inline ::sentry::OutboundMessageData* SendMessageToRandomPeersRequest::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::sentry::OutboundMessageData* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:sentry.SendMessageToRandomPeersRequest.data) return _msg; } inline void SendMessageToRandomPeersRequest::set_allocated_data(::sentry::OutboundMessageData* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.data_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.data_ = reinterpret_cast<::sentry::OutboundMessageData*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.SendMessageToRandomPeersRequest.data) } // uint64 max_peers = 2; inline void SendMessageToRandomPeersRequest::clear_max_peers() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_peers_ = ::uint64_t{0u}; } inline ::uint64_t SendMessageToRandomPeersRequest::max_peers() const { // @@protoc_insertion_point(field_get:sentry.SendMessageToRandomPeersRequest.max_peers) return _internal_max_peers(); } inline void SendMessageToRandomPeersRequest::set_max_peers(::uint64_t value) { _internal_set_max_peers(value); // @@protoc_insertion_point(field_set:sentry.SendMessageToRandomPeersRequest.max_peers) } inline ::uint64_t SendMessageToRandomPeersRequest::_internal_max_peers() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.max_peers_; } inline void SendMessageToRandomPeersRequest::_internal_set_max_peers(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_peers_ = value; } // ------------------------------------------------------------------- // SentPeers // repeated .types.H512 peers = 1; inline int SentPeers::_internal_peers_size() const { return _internal_peers().size(); } inline int SentPeers::peers_size() const { return _internal_peers_size(); } inline ::types::H512* SentPeers::mutable_peers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:sentry.SentPeers.peers) return _internal_mutable_peers()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H512>* SentPeers::mutable_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:sentry.SentPeers.peers) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_peers(); } inline const ::types::H512& SentPeers::peers(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.SentPeers.peers) return _internal_peers().Get(index); } inline ::types::H512* SentPeers::add_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H512* _add = _internal_mutable_peers()->Add(); // @@protoc_insertion_point(field_add:sentry.SentPeers.peers) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H512>& SentPeers::peers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:sentry.SentPeers.peers) return _internal_peers(); } inline const ::google::protobuf::RepeatedPtrField<::types::H512>& SentPeers::_internal_peers() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.peers_; } inline ::google::protobuf::RepeatedPtrField<::types::H512>* SentPeers::_internal_mutable_peers() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.peers_; } // ------------------------------------------------------------------- // PenalizePeerRequest // .types.H512 peer_id = 1; inline bool PenalizePeerRequest::has_peer_id() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.peer_id_ != nullptr); return value; } inline const ::types::H512& PenalizePeerRequest::_internal_peer_id() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.peer_id_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& PenalizePeerRequest::peer_id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.PenalizePeerRequest.peer_id) return _internal_peer_id(); } inline void PenalizePeerRequest::unsafe_arena_set_allocated_peer_id(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.PenalizePeerRequest.peer_id) } inline ::types::H512* PenalizePeerRequest::release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* released = _impl_.peer_id_; _impl_.peer_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* PenalizePeerRequest::unsafe_arena_release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.PenalizePeerRequest.peer_id) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* temp = _impl_.peer_id_; _impl_.peer_id_ = nullptr; return temp; } inline ::types::H512* PenalizePeerRequest::_internal_mutable_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.peer_id_ = reinterpret_cast<::types::H512*>(p); } return _impl_.peer_id_; } inline ::types::H512* PenalizePeerRequest::mutable_peer_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H512* _msg = _internal_mutable_peer_id(); // @@protoc_insertion_point(field_mutable:sentry.PenalizePeerRequest.peer_id) return _msg; } inline void PenalizePeerRequest::set_allocated_peer_id(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.PenalizePeerRequest.peer_id) } // .sentry.PenaltyKind penalty = 2; inline void PenalizePeerRequest::clear_penalty() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.penalty_ = 0; } inline ::sentry::PenaltyKind PenalizePeerRequest::penalty() const { // @@protoc_insertion_point(field_get:sentry.PenalizePeerRequest.penalty) return _internal_penalty(); } inline void PenalizePeerRequest::set_penalty(::sentry::PenaltyKind value) { _internal_set_penalty(value); // @@protoc_insertion_point(field_set:sentry.PenalizePeerRequest.penalty) } inline ::sentry::PenaltyKind PenalizePeerRequest::_internal_penalty() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::sentry::PenaltyKind>(_impl_.penalty_); } inline void PenalizePeerRequest::_internal_set_penalty(::sentry::PenaltyKind value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.penalty_ = value; } // ------------------------------------------------------------------- // PeerMinBlockRequest // .types.H512 peer_id = 1; inline bool PeerMinBlockRequest::has_peer_id() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.peer_id_ != nullptr); return value; } inline const ::types::H512& PeerMinBlockRequest::_internal_peer_id() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.peer_id_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& PeerMinBlockRequest::peer_id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.PeerMinBlockRequest.peer_id) return _internal_peer_id(); } inline void PeerMinBlockRequest::unsafe_arena_set_allocated_peer_id(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.PeerMinBlockRequest.peer_id) } inline ::types::H512* PeerMinBlockRequest::release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* released = _impl_.peer_id_; _impl_.peer_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* PeerMinBlockRequest::unsafe_arena_release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.PeerMinBlockRequest.peer_id) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* temp = _impl_.peer_id_; _impl_.peer_id_ = nullptr; return temp; } inline ::types::H512* PeerMinBlockRequest::_internal_mutable_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.peer_id_ = reinterpret_cast<::types::H512*>(p); } return _impl_.peer_id_; } inline ::types::H512* PeerMinBlockRequest::mutable_peer_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H512* _msg = _internal_mutable_peer_id(); // @@protoc_insertion_point(field_mutable:sentry.PeerMinBlockRequest.peer_id) return _msg; } inline void PeerMinBlockRequest::set_allocated_peer_id(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.PeerMinBlockRequest.peer_id) } // uint64 min_block = 2; inline void PeerMinBlockRequest::clear_min_block() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.min_block_ = ::uint64_t{0u}; } inline ::uint64_t PeerMinBlockRequest::min_block() const { // @@protoc_insertion_point(field_get:sentry.PeerMinBlockRequest.min_block) return _internal_min_block(); } inline void PeerMinBlockRequest::set_min_block(::uint64_t value) { _internal_set_min_block(value); // @@protoc_insertion_point(field_set:sentry.PeerMinBlockRequest.min_block) } inline ::uint64_t PeerMinBlockRequest::_internal_min_block() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.min_block_; } inline void PeerMinBlockRequest::_internal_set_min_block(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.min_block_ = value; } // ------------------------------------------------------------------- // AddPeerRequest // string url = 1; inline void AddPeerRequest::clear_url() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.ClearToEmpty(); } inline const std::string& AddPeerRequest::url() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.AddPeerRequest.url) return _internal_url(); } template inline PROTOBUF_ALWAYS_INLINE void AddPeerRequest::set_url(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:sentry.AddPeerRequest.url) } inline std::string* AddPeerRequest::mutable_url() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_url(); // @@protoc_insertion_point(field_mutable:sentry.AddPeerRequest.url) return _s; } inline const std::string& AddPeerRequest::_internal_url() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.url_.Get(); } inline void AddPeerRequest::_internal_set_url(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.Set(value, GetArena()); } inline std::string* AddPeerRequest::_internal_mutable_url() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.url_.Mutable( GetArena()); } inline std::string* AddPeerRequest::release_url() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.AddPeerRequest.url) return _impl_.url_.Release(); } inline void AddPeerRequest::set_allocated_url(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.url_.IsDefault()) { _impl_.url_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:sentry.AddPeerRequest.url) } // ------------------------------------------------------------------- // InboundMessage // .sentry.MessageId id = 1; inline void InboundMessage::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = 0; } inline ::sentry::MessageId InboundMessage::id() const { // @@protoc_insertion_point(field_get:sentry.InboundMessage.id) return _internal_id(); } inline void InboundMessage::set_id(::sentry::MessageId value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:sentry.InboundMessage.id) } inline ::sentry::MessageId InboundMessage::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::sentry::MessageId>(_impl_.id_); } inline void InboundMessage::_internal_set_id(::sentry::MessageId value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = value; } // bytes data = 2; inline void InboundMessage::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.ClearToEmpty(); } inline const std::string& InboundMessage::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.InboundMessage.data) return _internal_data(); } template inline PROTOBUF_ALWAYS_INLINE void InboundMessage::set_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:sentry.InboundMessage.data) } inline std::string* InboundMessage::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:sentry.InboundMessage.data) return _s; } inline const std::string& InboundMessage::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.data_.Get(); } inline void InboundMessage::_internal_set_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.Set(value, GetArena()); } inline std::string* InboundMessage::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.data_.Mutable( GetArena()); } inline std::string* InboundMessage::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.InboundMessage.data) return _impl_.data_.Release(); } inline void InboundMessage::set_allocated_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.data_.IsDefault()) { _impl_.data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:sentry.InboundMessage.data) } // .types.H512 peer_id = 3; inline bool InboundMessage::has_peer_id() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.peer_id_ != nullptr); return value; } inline const ::types::H512& InboundMessage::_internal_peer_id() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.peer_id_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& InboundMessage::peer_id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.InboundMessage.peer_id) return _internal_peer_id(); } inline void InboundMessage::unsafe_arena_set_allocated_peer_id(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.InboundMessage.peer_id) } inline ::types::H512* InboundMessage::release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* released = _impl_.peer_id_; _impl_.peer_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* InboundMessage::unsafe_arena_release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.InboundMessage.peer_id) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* temp = _impl_.peer_id_; _impl_.peer_id_ = nullptr; return temp; } inline ::types::H512* InboundMessage::_internal_mutable_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.peer_id_ = reinterpret_cast<::types::H512*>(p); } return _impl_.peer_id_; } inline ::types::H512* InboundMessage::mutable_peer_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H512* _msg = _internal_mutable_peer_id(); // @@protoc_insertion_point(field_mutable:sentry.InboundMessage.peer_id) return _msg; } inline void InboundMessage::set_allocated_peer_id(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.InboundMessage.peer_id) } // ------------------------------------------------------------------- // Forks // .types.H256 genesis = 1; inline bool Forks::has_genesis() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.genesis_ != nullptr); return value; } inline const ::types::H256& Forks::_internal_genesis() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.genesis_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& Forks::genesis() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.Forks.genesis) return _internal_genesis(); } inline void Forks::unsafe_arena_set_allocated_genesis(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.genesis_); } _impl_.genesis_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.Forks.genesis) } inline ::types::H256* Forks::release_genesis() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.genesis_; _impl_.genesis_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* Forks::unsafe_arena_release_genesis() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.Forks.genesis) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.genesis_; _impl_.genesis_ = nullptr; return temp; } inline ::types::H256* Forks::_internal_mutable_genesis() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.genesis_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.genesis_ = reinterpret_cast<::types::H256*>(p); } return _impl_.genesis_; } inline ::types::H256* Forks::mutable_genesis() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_genesis(); // @@protoc_insertion_point(field_mutable:sentry.Forks.genesis) return _msg; } inline void Forks::set_allocated_genesis(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.genesis_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.genesis_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.Forks.genesis) } // repeated uint64 height_forks = 2; inline int Forks::_internal_height_forks_size() const { return _internal_height_forks().size(); } inline int Forks::height_forks_size() const { return _internal_height_forks_size(); } inline void Forks::clear_height_forks() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.height_forks_.Clear(); } inline ::uint64_t Forks::height_forks(int index) const { // @@protoc_insertion_point(field_get:sentry.Forks.height_forks) return _internal_height_forks().Get(index); } inline void Forks::set_height_forks(int index, ::uint64_t value) { _internal_mutable_height_forks()->Set(index, value); // @@protoc_insertion_point(field_set:sentry.Forks.height_forks) } inline void Forks::add_height_forks(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_height_forks()->Add(value); // @@protoc_insertion_point(field_add:sentry.Forks.height_forks) } inline const ::google::protobuf::RepeatedField<::uint64_t>& Forks::height_forks() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:sentry.Forks.height_forks) return _internal_height_forks(); } inline ::google::protobuf::RepeatedField<::uint64_t>* Forks::mutable_height_forks() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:sentry.Forks.height_forks) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_height_forks(); } inline const ::google::protobuf::RepeatedField<::uint64_t>& Forks::_internal_height_forks() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.height_forks_; } inline ::google::protobuf::RepeatedField<::uint64_t>* Forks::_internal_mutable_height_forks() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.height_forks_; } // repeated uint64 time_forks = 3; inline int Forks::_internal_time_forks_size() const { return _internal_time_forks().size(); } inline int Forks::time_forks_size() const { return _internal_time_forks_size(); } inline void Forks::clear_time_forks() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.time_forks_.Clear(); } inline ::uint64_t Forks::time_forks(int index) const { // @@protoc_insertion_point(field_get:sentry.Forks.time_forks) return _internal_time_forks().Get(index); } inline void Forks::set_time_forks(int index, ::uint64_t value) { _internal_mutable_time_forks()->Set(index, value); // @@protoc_insertion_point(field_set:sentry.Forks.time_forks) } inline void Forks::add_time_forks(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_time_forks()->Add(value); // @@protoc_insertion_point(field_add:sentry.Forks.time_forks) } inline const ::google::protobuf::RepeatedField<::uint64_t>& Forks::time_forks() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:sentry.Forks.time_forks) return _internal_time_forks(); } inline ::google::protobuf::RepeatedField<::uint64_t>* Forks::mutable_time_forks() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:sentry.Forks.time_forks) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_time_forks(); } inline const ::google::protobuf::RepeatedField<::uint64_t>& Forks::_internal_time_forks() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.time_forks_; } inline ::google::protobuf::RepeatedField<::uint64_t>* Forks::_internal_mutable_time_forks() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.time_forks_; } // ------------------------------------------------------------------- // StatusData // uint64 network_id = 1; inline void StatusData::clear_network_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.network_id_ = ::uint64_t{0u}; } inline ::uint64_t StatusData::network_id() const { // @@protoc_insertion_point(field_get:sentry.StatusData.network_id) return _internal_network_id(); } inline void StatusData::set_network_id(::uint64_t value) { _internal_set_network_id(value); // @@protoc_insertion_point(field_set:sentry.StatusData.network_id) } inline ::uint64_t StatusData::_internal_network_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.network_id_; } inline void StatusData::_internal_set_network_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.network_id_ = value; } // .types.H256 total_difficulty = 2; inline bool StatusData::has_total_difficulty() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.total_difficulty_ != nullptr); return value; } inline const ::types::H256& StatusData::_internal_total_difficulty() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.total_difficulty_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& StatusData::total_difficulty() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.StatusData.total_difficulty) return _internal_total_difficulty(); } inline void StatusData::unsafe_arena_set_allocated_total_difficulty(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.total_difficulty_); } _impl_.total_difficulty_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.StatusData.total_difficulty) } inline ::types::H256* StatusData::release_total_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.total_difficulty_; _impl_.total_difficulty_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* StatusData::unsafe_arena_release_total_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.StatusData.total_difficulty) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.total_difficulty_; _impl_.total_difficulty_ = nullptr; return temp; } inline ::types::H256* StatusData::_internal_mutable_total_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.total_difficulty_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.total_difficulty_ = reinterpret_cast<::types::H256*>(p); } return _impl_.total_difficulty_; } inline ::types::H256* StatusData::mutable_total_difficulty() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_total_difficulty(); // @@protoc_insertion_point(field_mutable:sentry.StatusData.total_difficulty) return _msg; } inline void StatusData::set_allocated_total_difficulty(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.total_difficulty_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.total_difficulty_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.StatusData.total_difficulty) } // .types.H256 best_hash = 3; inline bool StatusData::has_best_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.best_hash_ != nullptr); return value; } inline const ::types::H256& StatusData::_internal_best_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.best_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& StatusData::best_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.StatusData.best_hash) return _internal_best_hash(); } inline void StatusData::unsafe_arena_set_allocated_best_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.best_hash_); } _impl_.best_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.StatusData.best_hash) } inline ::types::H256* StatusData::release_best_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* released = _impl_.best_hash_; _impl_.best_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* StatusData::unsafe_arena_release_best_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.StatusData.best_hash) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* temp = _impl_.best_hash_; _impl_.best_hash_ = nullptr; return temp; } inline ::types::H256* StatusData::_internal_mutable_best_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.best_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.best_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.best_hash_; } inline ::types::H256* StatusData::mutable_best_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H256* _msg = _internal_mutable_best_hash(); // @@protoc_insertion_point(field_mutable:sentry.StatusData.best_hash) return _msg; } inline void StatusData::set_allocated_best_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.best_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.best_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.StatusData.best_hash) } // .sentry.Forks fork_data = 4; inline bool StatusData::has_fork_data() const { bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || _impl_.fork_data_ != nullptr); return value; } inline void StatusData::clear_fork_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.fork_data_ != nullptr) _impl_.fork_data_->Clear(); _impl_._has_bits_[0] &= ~0x00000004u; } inline const ::sentry::Forks& StatusData::_internal_fork_data() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::sentry::Forks* p = _impl_.fork_data_; return p != nullptr ? *p : reinterpret_cast(::sentry::_Forks_default_instance_); } inline const ::sentry::Forks& StatusData::fork_data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.StatusData.fork_data) return _internal_fork_data(); } inline void StatusData::unsafe_arena_set_allocated_fork_data(::sentry::Forks* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fork_data_); } _impl_.fork_data_ = reinterpret_cast<::sentry::Forks*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.StatusData.fork_data) } inline ::sentry::Forks* StatusData::release_fork_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000004u; ::sentry::Forks* released = _impl_.fork_data_; _impl_.fork_data_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::sentry::Forks* StatusData::unsafe_arena_release_fork_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.StatusData.fork_data) _impl_._has_bits_[0] &= ~0x00000004u; ::sentry::Forks* temp = _impl_.fork_data_; _impl_.fork_data_ = nullptr; return temp; } inline ::sentry::Forks* StatusData::_internal_mutable_fork_data() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.fork_data_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::sentry::Forks>(GetArena()); _impl_.fork_data_ = reinterpret_cast<::sentry::Forks*>(p); } return _impl_.fork_data_; } inline ::sentry::Forks* StatusData::mutable_fork_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000004u; ::sentry::Forks* _msg = _internal_mutable_fork_data(); // @@protoc_insertion_point(field_mutable:sentry.StatusData.fork_data) return _msg; } inline void StatusData::set_allocated_fork_data(::sentry::Forks* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.fork_data_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } _impl_.fork_data_ = reinterpret_cast<::sentry::Forks*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.StatusData.fork_data) } // uint64 max_block_height = 5; inline void StatusData::clear_max_block_height() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_block_height_ = ::uint64_t{0u}; } inline ::uint64_t StatusData::max_block_height() const { // @@protoc_insertion_point(field_get:sentry.StatusData.max_block_height) return _internal_max_block_height(); } inline void StatusData::set_max_block_height(::uint64_t value) { _internal_set_max_block_height(value); // @@protoc_insertion_point(field_set:sentry.StatusData.max_block_height) } inline ::uint64_t StatusData::_internal_max_block_height() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.max_block_height_; } inline void StatusData::_internal_set_max_block_height(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_block_height_ = value; } // uint64 max_block_time = 6; inline void StatusData::clear_max_block_time() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_block_time_ = ::uint64_t{0u}; } inline ::uint64_t StatusData::max_block_time() const { // @@protoc_insertion_point(field_get:sentry.StatusData.max_block_time) return _internal_max_block_time(); } inline void StatusData::set_max_block_time(::uint64_t value) { _internal_set_max_block_time(value); // @@protoc_insertion_point(field_set:sentry.StatusData.max_block_time) } inline ::uint64_t StatusData::_internal_max_block_time() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.max_block_time_; } inline void StatusData::_internal_set_max_block_time(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_block_time_ = value; } // ------------------------------------------------------------------- // SetStatusReply // ------------------------------------------------------------------- // HandShakeReply // .sentry.Protocol protocol = 1; inline void HandShakeReply::clear_protocol() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocol_ = 0; } inline ::sentry::Protocol HandShakeReply::protocol() const { // @@protoc_insertion_point(field_get:sentry.HandShakeReply.protocol) return _internal_protocol(); } inline void HandShakeReply::set_protocol(::sentry::Protocol value) { _internal_set_protocol(value); // @@protoc_insertion_point(field_set:sentry.HandShakeReply.protocol) } inline ::sentry::Protocol HandShakeReply::_internal_protocol() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::sentry::Protocol>(_impl_.protocol_); } inline void HandShakeReply::_internal_set_protocol(::sentry::Protocol value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocol_ = value; } // ------------------------------------------------------------------- // MessagesRequest // repeated .sentry.MessageId ids = 1; inline int MessagesRequest::_internal_ids_size() const { return _internal_ids().size(); } inline int MessagesRequest::ids_size() const { return _internal_ids_size(); } inline void MessagesRequest::clear_ids() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ids_.Clear(); } inline ::sentry::MessageId MessagesRequest::ids(int index) const { // @@protoc_insertion_point(field_get:sentry.MessagesRequest.ids) return static_cast<::sentry::MessageId>(_internal_ids().Get(index)); } inline void MessagesRequest::set_ids(int index, ::sentry::MessageId value) { _internal_mutable_ids()->Set(index, value); // @@protoc_insertion_point(field_set:sentry.MessagesRequest.ids) } inline void MessagesRequest::add_ids(::sentry::MessageId value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_ids()->Add(value); // @@protoc_insertion_point(field_add:sentry.MessagesRequest.ids) } inline const ::google::protobuf::RepeatedField& MessagesRequest::ids() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:sentry.MessagesRequest.ids) return _internal_ids(); } inline ::google::protobuf::RepeatedField* MessagesRequest::mutable_ids() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:sentry.MessagesRequest.ids) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_ids(); } inline const ::google::protobuf::RepeatedField& MessagesRequest::_internal_ids() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ids_; } inline ::google::protobuf::RepeatedField* MessagesRequest::_internal_mutable_ids() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.ids_; } // ------------------------------------------------------------------- // PeersReply // repeated .types.PeerInfo peers = 1; inline int PeersReply::_internal_peers_size() const { return _internal_peers().size(); } inline int PeersReply::peers_size() const { return _internal_peers_size(); } inline ::types::PeerInfo* PeersReply::mutable_peers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:sentry.PeersReply.peers) return _internal_mutable_peers()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* PeersReply::mutable_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:sentry.PeersReply.peers) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_peers(); } inline const ::types::PeerInfo& PeersReply::peers(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.PeersReply.peers) return _internal_peers().Get(index); } inline ::types::PeerInfo* PeersReply::add_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::PeerInfo* _add = _internal_mutable_peers()->Add(); // @@protoc_insertion_point(field_add:sentry.PeersReply.peers) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& PeersReply::peers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:sentry.PeersReply.peers) return _internal_peers(); } inline const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& PeersReply::_internal_peers() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.peers_; } inline ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* PeersReply::_internal_mutable_peers() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.peers_; } // ------------------------------------------------------------------- // PeerCountRequest // ------------------------------------------------------------------- // PeerCountPerProtocol // .sentry.Protocol protocol = 1; inline void PeerCountPerProtocol::clear_protocol() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocol_ = 0; } inline ::sentry::Protocol PeerCountPerProtocol::protocol() const { // @@protoc_insertion_point(field_get:sentry.PeerCountPerProtocol.protocol) return _internal_protocol(); } inline void PeerCountPerProtocol::set_protocol(::sentry::Protocol value) { _internal_set_protocol(value); // @@protoc_insertion_point(field_set:sentry.PeerCountPerProtocol.protocol) } inline ::sentry::Protocol PeerCountPerProtocol::_internal_protocol() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::sentry::Protocol>(_impl_.protocol_); } inline void PeerCountPerProtocol::_internal_set_protocol(::sentry::Protocol value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocol_ = value; } // uint64 count = 2; inline void PeerCountPerProtocol::clear_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = ::uint64_t{0u}; } inline ::uint64_t PeerCountPerProtocol::count() const { // @@protoc_insertion_point(field_get:sentry.PeerCountPerProtocol.count) return _internal_count(); } inline void PeerCountPerProtocol::set_count(::uint64_t value) { _internal_set_count(value); // @@protoc_insertion_point(field_set:sentry.PeerCountPerProtocol.count) } inline ::uint64_t PeerCountPerProtocol::_internal_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.count_; } inline void PeerCountPerProtocol::_internal_set_count(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = value; } // ------------------------------------------------------------------- // PeerCountReply // uint64 count = 1; inline void PeerCountReply::clear_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = ::uint64_t{0u}; } inline ::uint64_t PeerCountReply::count() const { // @@protoc_insertion_point(field_get:sentry.PeerCountReply.count) return _internal_count(); } inline void PeerCountReply::set_count(::uint64_t value) { _internal_set_count(value); // @@protoc_insertion_point(field_set:sentry.PeerCountReply.count) } inline ::uint64_t PeerCountReply::_internal_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.count_; } inline void PeerCountReply::_internal_set_count(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = value; } // repeated .sentry.PeerCountPerProtocol counts_per_protocol = 2; inline int PeerCountReply::_internal_counts_per_protocol_size() const { return _internal_counts_per_protocol().size(); } inline int PeerCountReply::counts_per_protocol_size() const { return _internal_counts_per_protocol_size(); } inline void PeerCountReply::clear_counts_per_protocol() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.counts_per_protocol_.Clear(); } inline ::sentry::PeerCountPerProtocol* PeerCountReply::mutable_counts_per_protocol(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:sentry.PeerCountReply.counts_per_protocol) return _internal_mutable_counts_per_protocol()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>* PeerCountReply::mutable_counts_per_protocol() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:sentry.PeerCountReply.counts_per_protocol) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_counts_per_protocol(); } inline const ::sentry::PeerCountPerProtocol& PeerCountReply::counts_per_protocol(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.PeerCountReply.counts_per_protocol) return _internal_counts_per_protocol().Get(index); } inline ::sentry::PeerCountPerProtocol* PeerCountReply::add_counts_per_protocol() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::sentry::PeerCountPerProtocol* _add = _internal_mutable_counts_per_protocol()->Add(); // @@protoc_insertion_point(field_add:sentry.PeerCountReply.counts_per_protocol) return _add; } inline const ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>& PeerCountReply::counts_per_protocol() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:sentry.PeerCountReply.counts_per_protocol) return _internal_counts_per_protocol(); } inline const ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>& PeerCountReply::_internal_counts_per_protocol() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.counts_per_protocol_; } inline ::google::protobuf::RepeatedPtrField<::sentry::PeerCountPerProtocol>* PeerCountReply::_internal_mutable_counts_per_protocol() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.counts_per_protocol_; } // ------------------------------------------------------------------- // PeerByIdRequest // .types.H512 peer_id = 1; inline bool PeerByIdRequest::has_peer_id() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.peer_id_ != nullptr); return value; } inline const ::types::H512& PeerByIdRequest::_internal_peer_id() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.peer_id_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& PeerByIdRequest::peer_id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.PeerByIdRequest.peer_id) return _internal_peer_id(); } inline void PeerByIdRequest::unsafe_arena_set_allocated_peer_id(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.PeerByIdRequest.peer_id) } inline ::types::H512* PeerByIdRequest::release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* released = _impl_.peer_id_; _impl_.peer_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* PeerByIdRequest::unsafe_arena_release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.PeerByIdRequest.peer_id) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* temp = _impl_.peer_id_; _impl_.peer_id_ = nullptr; return temp; } inline ::types::H512* PeerByIdRequest::_internal_mutable_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.peer_id_ = reinterpret_cast<::types::H512*>(p); } return _impl_.peer_id_; } inline ::types::H512* PeerByIdRequest::mutable_peer_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H512* _msg = _internal_mutable_peer_id(); // @@protoc_insertion_point(field_mutable:sentry.PeerByIdRequest.peer_id) return _msg; } inline void PeerByIdRequest::set_allocated_peer_id(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.PeerByIdRequest.peer_id) } // ------------------------------------------------------------------- // PeerByIdReply // optional .types.PeerInfo peer = 1; inline bool PeerByIdReply::has_peer() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.peer_ != nullptr); return value; } inline const ::types::PeerInfo& PeerByIdReply::_internal_peer() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::PeerInfo* p = _impl_.peer_; return p != nullptr ? *p : reinterpret_cast(::types::_PeerInfo_default_instance_); } inline const ::types::PeerInfo& PeerByIdReply::peer() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.PeerByIdReply.peer) return _internal_peer(); } inline void PeerByIdReply::unsafe_arena_set_allocated_peer(::types::PeerInfo* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_); } _impl_.peer_ = reinterpret_cast<::types::PeerInfo*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.PeerByIdReply.peer) } inline ::types::PeerInfo* PeerByIdReply::release_peer() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::PeerInfo* released = _impl_.peer_; _impl_.peer_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::PeerInfo* PeerByIdReply::unsafe_arena_release_peer() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.PeerByIdReply.peer) _impl_._has_bits_[0] &= ~0x00000001u; ::types::PeerInfo* temp = _impl_.peer_; _impl_.peer_ = nullptr; return temp; } inline ::types::PeerInfo* PeerByIdReply::_internal_mutable_peer() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::PeerInfo>(GetArena()); _impl_.peer_ = reinterpret_cast<::types::PeerInfo*>(p); } return _impl_.peer_; } inline ::types::PeerInfo* PeerByIdReply::mutable_peer() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::PeerInfo* _msg = _internal_mutable_peer(); // @@protoc_insertion_point(field_mutable:sentry.PeerByIdReply.peer) return _msg; } inline void PeerByIdReply::set_allocated_peer(::types::PeerInfo* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.peer_ = reinterpret_cast<::types::PeerInfo*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.PeerByIdReply.peer) } // ------------------------------------------------------------------- // PeerEventsRequest // ------------------------------------------------------------------- // PeerEvent // .types.H512 peer_id = 1; inline bool PeerEvent::has_peer_id() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.peer_id_ != nullptr); return value; } inline const ::types::H512& PeerEvent::_internal_peer_id() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.peer_id_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& PeerEvent::peer_id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:sentry.PeerEvent.peer_id) return _internal_peer_id(); } inline void PeerEvent::unsafe_arena_set_allocated_peer_id(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentry.PeerEvent.peer_id) } inline ::types::H512* PeerEvent::release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* released = _impl_.peer_id_; _impl_.peer_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* PeerEvent::unsafe_arena_release_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:sentry.PeerEvent.peer_id) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* temp = _impl_.peer_id_; _impl_.peer_id_ = nullptr; return temp; } inline ::types::H512* PeerEvent::_internal_mutable_peer_id() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.peer_id_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.peer_id_ = reinterpret_cast<::types::H512*>(p); } return _impl_.peer_id_; } inline ::types::H512* PeerEvent::mutable_peer_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H512* _msg = _internal_mutable_peer_id(); // @@protoc_insertion_point(field_mutable:sentry.PeerEvent.peer_id) return _msg; } inline void PeerEvent::set_allocated_peer_id(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.peer_id_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.peer_id_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:sentry.PeerEvent.peer_id) } // .sentry.PeerEvent.PeerEventId event_id = 2; inline void PeerEvent::clear_event_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.event_id_ = 0; } inline ::sentry::PeerEvent_PeerEventId PeerEvent::event_id() const { // @@protoc_insertion_point(field_get:sentry.PeerEvent.event_id) return _internal_event_id(); } inline void PeerEvent::set_event_id(::sentry::PeerEvent_PeerEventId value) { _internal_set_event_id(value); // @@protoc_insertion_point(field_set:sentry.PeerEvent.event_id) } inline ::sentry::PeerEvent_PeerEventId PeerEvent::_internal_event_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::sentry::PeerEvent_PeerEventId>(_impl_.event_id_); } inline void PeerEvent::_internal_set_event_id(::sentry::PeerEvent_PeerEventId value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.event_id_ = value; } // ------------------------------------------------------------------- // AddPeerReply // bool success = 1; inline void AddPeerReply::clear_success() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.success_ = false; } inline bool AddPeerReply::success() const { // @@protoc_insertion_point(field_get:sentry.AddPeerReply.success) return _internal_success(); } inline void AddPeerReply::set_success(bool value) { _internal_set_success(value); // @@protoc_insertion_point(field_set:sentry.AddPeerReply.success) } inline bool AddPeerReply::_internal_success() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.success_; } inline void AddPeerReply::_internal_set_success(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.success_ = value; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace sentry namespace google { namespace protobuf { template <> struct is_proto_enum<::sentry::PeerEvent_PeerEventId> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::sentry::PeerEvent_PeerEventId>() { return ::sentry::PeerEvent_PeerEventId_descriptor(); } template <> struct is_proto_enum<::sentry::MessageId> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::sentry::MessageId>() { return ::sentry::MessageId_descriptor(); } template <> struct is_proto_enum<::sentry::PenaltyKind> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::sentry::PenaltyKind>() { return ::sentry::PenaltyKind_descriptor(); } template <> struct is_proto_enum<::sentry::Protocol> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::sentry::Protocol>() { return ::sentry::Protocol_descriptor(); } } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_p2psentry_2fsentry_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/27.0/p2psentry/sentry_mock.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: p2psentry/sentry.proto #ifndef GRPC_MOCK_p2psentry_2fsentry_2eproto__INCLUDED #define GRPC_MOCK_p2psentry_2fsentry_2eproto__INCLUDED #include "p2psentry/sentry.pb.h" #include "p2psentry/sentry.grpc.pb.h" #include #include #include namespace sentry { class MockSentryStub : public Sentry::StubInterface { public: MOCK_METHOD3(SetStatus, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::sentry::SetStatusReply* response)); MOCK_METHOD3(AsyncSetStatusRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>*(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSetStatusRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SetStatusReply>*(::grpc::ClientContext* context, const ::sentry::StatusData& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PenalizePeer, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::google::protobuf::Empty* response)); MOCK_METHOD3(AsyncPenalizePeerRaw, ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>*(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPenalizePeerRaw, ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>*(::grpc::ClientContext* context, const ::sentry::PenalizePeerRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PeerMinBlock, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::google::protobuf::Empty* response)); MOCK_METHOD3(AsyncPeerMinBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>*(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPeerMinBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>*(::grpc::ClientContext* context, const ::sentry::PeerMinBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(HandShake, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::HandShakeReply* response)); MOCK_METHOD3(AsyncHandShakeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHandShakeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::HandShakeReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(SendMessageByMinBlock, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::sentry::SentPeers* response)); MOCK_METHOD3(AsyncSendMessageByMinBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSendMessageByMinBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::SendMessageByMinBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(SendMessageById, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::sentry::SentPeers* response)); MOCK_METHOD3(AsyncSendMessageByIdRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSendMessageByIdRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::SendMessageByIdRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(SendMessageToRandomPeers, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::sentry::SentPeers* response)); MOCK_METHOD3(AsyncSendMessageToRandomPeersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSendMessageToRandomPeersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::SendMessageToRandomPeersRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(SendMessageToAll, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::sentry::SentPeers* response)); MOCK_METHOD3(AsyncSendMessageToAllRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSendMessageToAllRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::SentPeers>*(::grpc::ClientContext* context, const ::sentry::OutboundMessageData& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(MessagesRaw, ::grpc::ClientReaderInterface< ::sentry::InboundMessage>*(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request)); MOCK_METHOD4(AsyncMessagesRaw, ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>*(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncMessagesRaw, ::grpc::ClientAsyncReaderInterface< ::sentry::InboundMessage>*(::grpc::ClientContext* context, const ::sentry::MessagesRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Peers, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::sentry::PeersReply* response)); MOCK_METHOD3(AsyncPeersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPeersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeersReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PeerCount, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::sentry::PeerCountReply* response)); MOCK_METHOD3(AsyncPeerCountRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>*(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPeerCountRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerCountReply>*(::grpc::ClientContext* context, const ::sentry::PeerCountRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PeerById, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::sentry::PeerByIdReply* response)); MOCK_METHOD3(AsyncPeerByIdRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>*(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPeerByIdRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::PeerByIdReply>*(::grpc::ClientContext* context, const ::sentry::PeerByIdRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(PeerEventsRaw, ::grpc::ClientReaderInterface< ::sentry::PeerEvent>*(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request)); MOCK_METHOD4(AsyncPeerEventsRaw, ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>*(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncPeerEventsRaw, ::grpc::ClientAsyncReaderInterface< ::sentry::PeerEvent>*(::grpc::ClientContext* context, const ::sentry::PeerEventsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AddPeer, ::grpc::Status(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::sentry::AddPeerReply* response)); MOCK_METHOD3(AsyncAddPeerRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>*(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncAddPeerRaw, ::grpc::ClientAsyncResponseReaderInterface< ::sentry::AddPeerReply>*(::grpc::ClientContext* context, const ::sentry::AddPeerRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(NodeInfo, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::NodeInfoReply* response)); MOCK_METHOD3(AsyncNodeInfoRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncNodeInfoRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::NodeInfoReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); }; } // namespace sentry #endif // GRPC_MOCK_p2psentry_2fsentry_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/remote/bor.grpc.pb.cc ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/bor.proto #include "remote/bor.pb.h" #include "remote/bor.grpc.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace remote { static const char* BridgeBackend_method_names[] = { "/remote.BridgeBackend/Version", "/remote.BridgeBackend/BorTxnLookup", "/remote.BridgeBackend/BorEvents", }; std::unique_ptr< BridgeBackend::Stub> BridgeBackend::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< BridgeBackend::Stub> stub(new BridgeBackend::Stub(channel, options)); return stub; } BridgeBackend::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_Version_(BridgeBackend_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_BorTxnLookup_(BridgeBackend_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_BorEvents_(BridgeBackend_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status BridgeBackend::Stub::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Version_, context, request, response); } void BridgeBackend::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, std::move(f)); } void BridgeBackend::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* BridgeBackend::Stub::PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::types::VersionReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Version_, context, request); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* BridgeBackend::Stub::AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status BridgeBackend::Stub::BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BorTxnLookup_, context, request, response); } void BridgeBackend::Stub::async::BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorTxnLookup_, context, request, response, std::move(f)); } void BridgeBackend::Stub::async::BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorTxnLookup_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* BridgeBackend::Stub::PrepareAsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::BorTxnLookupReply, ::remote::BorTxnLookupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BorTxnLookup_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* BridgeBackend::Stub::AsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncBorTxnLookupRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status BridgeBackend::Stub::BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::BorEventsRequest, ::remote::BorEventsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BorEvents_, context, request, response); } void BridgeBackend::Stub::async::BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::BorEventsRequest, ::remote::BorEventsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorEvents_, context, request, response, std::move(f)); } void BridgeBackend::Stub::async::BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorEvents_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* BridgeBackend::Stub::PrepareAsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::BorEventsReply, ::remote::BorEventsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BorEvents_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* BridgeBackend::Stub::AsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncBorEventsRaw(context, request, cq); result->StartCall(); return result; } BridgeBackend::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( BridgeBackend_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< BridgeBackend::Service, ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](BridgeBackend::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::types::VersionReply* resp) { return service->Version(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( BridgeBackend_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< BridgeBackend::Service, ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](BridgeBackend::Service* service, ::grpc::ServerContext* ctx, const ::remote::BorTxnLookupRequest* req, ::remote::BorTxnLookupReply* resp) { return service->BorTxnLookup(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( BridgeBackend_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< BridgeBackend::Service, ::remote::BorEventsRequest, ::remote::BorEventsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](BridgeBackend::Service* service, ::grpc::ServerContext* ctx, const ::remote::BorEventsRequest* req, ::remote::BorEventsReply* resp) { return service->BorEvents(ctx, req, resp); }, this))); } BridgeBackend::Service::~Service() { } ::grpc::Status BridgeBackend::Service::Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status BridgeBackend::Service::BorTxnLookup(::grpc::ServerContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status BridgeBackend::Service::BorEvents(::grpc::ServerContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } static const char* HeimdallBackend_method_names[] = { "/remote.HeimdallBackend/Version", "/remote.HeimdallBackend/Producers", }; std::unique_ptr< HeimdallBackend::Stub> HeimdallBackend::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< HeimdallBackend::Stub> stub(new HeimdallBackend::Stub(channel, options)); return stub; } HeimdallBackend::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_Version_(HeimdallBackend_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Producers_(HeimdallBackend_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status HeimdallBackend::Stub::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Version_, context, request, response); } void HeimdallBackend::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, std::move(f)); } void HeimdallBackend::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* HeimdallBackend::Stub::PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::types::VersionReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Version_, context, request); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* HeimdallBackend::Stub::AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status HeimdallBackend::Stub::Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::remote::BorProducersResponse* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::BorProducersRequest, ::remote::BorProducersResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Producers_, context, request, response); } void HeimdallBackend::Stub::async::Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::BorProducersRequest, ::remote::BorProducersResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Producers_, context, request, response, std::move(f)); } void HeimdallBackend::Stub::async::Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Producers_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>* HeimdallBackend::Stub::PrepareAsyncProducersRaw(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::BorProducersResponse, ::remote::BorProducersRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Producers_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>* HeimdallBackend::Stub::AsyncProducersRaw(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncProducersRaw(context, request, cq); result->StartCall(); return result; } HeimdallBackend::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( HeimdallBackend_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< HeimdallBackend::Service, ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](HeimdallBackend::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::types::VersionReply* resp) { return service->Version(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( HeimdallBackend_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< HeimdallBackend::Service, ::remote::BorProducersRequest, ::remote::BorProducersResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](HeimdallBackend::Service* service, ::grpc::ServerContext* ctx, const ::remote::BorProducersRequest* req, ::remote::BorProducersResponse* resp) { return service->Producers(ctx, req, resp); }, this))); } HeimdallBackend::Service::~Service() { } ::grpc::Status HeimdallBackend::Service::Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status HeimdallBackend::Service::Producers(::grpc::ServerContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } } // namespace remote ================================================ FILE: silkworm/interfaces/27.0/remote/bor.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/bor.proto #ifndef GRPC_remote_2fbor_2eproto__INCLUDED #define GRPC_remote_2fbor_2eproto__INCLUDED #include "remote/bor.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace remote { class BridgeBackend final { public: static constexpr char const* service_full_name() { return "remote.BridgeBackend"; } class StubInterface { public: virtual ~StubInterface() {} // Version returns the service version number virtual ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } virtual ::grpc::Status BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>> AsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>>(AsyncBorTxnLookupRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>> PrepareAsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>>(PrepareAsyncBorTxnLookupRaw(context, request, cq)); } virtual ::grpc::Status BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>> AsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>>(AsyncBorEventsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>> PrepareAsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>>(PrepareAsyncBorEventsRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} // Version returns the service version number virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) = 0; virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, std::function) = 0; virtual void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, std::function) = 0; virtual void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>* AsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>* PrepareAsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>* AsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>* PrepareAsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } ::grpc::Status BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>> AsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>>(AsyncBorTxnLookupRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>> PrepareAsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>>(PrepareAsyncBorTxnLookupRaw(context, request, cq)); } ::grpc::Status BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>> AsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>>(AsyncBorEventsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>> PrepareAsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>>(PrepareAsyncBorEventsRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) override; void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, std::function) override; void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) override; void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, std::function) override; void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* AsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* PrepareAsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* AsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* PrepareAsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_Version_; const ::grpc::internal::RpcMethod rpcmethod_BorTxnLookup_; const ::grpc::internal::RpcMethod rpcmethod_BorEvents_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // Version returns the service version number virtual ::grpc::Status Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response); virtual ::grpc::Status BorTxnLookup(::grpc::ServerContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response); virtual ::grpc::Status BorEvents(::grpc::ServerContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response); }; template class WithAsyncMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Version() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::types::VersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_BorTxnLookup() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorTxnLookup(::grpc::ServerContext* context, ::remote::BorTxnLookupRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::BorTxnLookupReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_BorEvents() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorEvents(::grpc::ServerContext* context, ::remote::BorEventsRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::BorEventsReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_Version > > AsyncService; template class WithCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Version() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { return this->Version(context, request, response); }));} void SetMessageAllocatorFor_Version( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::types::VersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_BorTxnLookup() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response) { return this->BorTxnLookup(context, request, response); }));} void SetMessageAllocatorFor_BorTxnLookup( ::grpc::MessageAllocator< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorTxnLookup( ::grpc::CallbackServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_BorEvents() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::remote::BorEventsRequest, ::remote::BorEventsReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response) { return this->BorEvents(context, request, response); }));} void SetMessageAllocatorFor_BorEvents( ::grpc::MessageAllocator< ::remote::BorEventsRequest, ::remote::BorEventsReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::BorEventsRequest, ::remote::BorEventsReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorEvents( ::grpc::CallbackServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_Version > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Version() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_BorTxnLookup() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_BorEvents() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Version() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_BorTxnLookup() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorTxnLookup(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_BorEvents() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorEvents(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Version() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Version(context, request, response); })); } ~WithRawCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_BorTxnLookup() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->BorTxnLookup(context, request, response); })); } ~WithRawCallbackMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorTxnLookup( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_BorEvents() { ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->BorEvents(context, request, response); })); } ~WithRawCallbackMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorEvents( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Version() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::types::VersionReply>* streamer) { return this->StreamedVersion(context, streamer); })); } ~WithStreamedUnaryMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::types::VersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_BorTxnLookup() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>* streamer) { return this->StreamedBorTxnLookup(context, streamer); })); } ~WithStreamedUnaryMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedBorTxnLookup(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorTxnLookupRequest,::remote::BorTxnLookupReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_BorEvents() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::StreamedUnaryHandler< ::remote::BorEventsRequest, ::remote::BorEventsReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorEventsRequest, ::remote::BorEventsReply>* streamer) { return this->StreamedBorEvents(context, streamer); })); } ~WithStreamedUnaryMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedBorEvents(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorEventsRequest,::remote::BorEventsReply>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_Version > > StreamedUnaryService; typedef Service SplitStreamedService; typedef WithStreamedUnaryMethod_Version > > StreamedService; }; class HeimdallBackend final { public: static constexpr char const* service_full_name() { return "remote.HeimdallBackend"; } class StubInterface { public: virtual ~StubInterface() {} // Version returns the service version number virtual ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } virtual ::grpc::Status Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::remote::BorProducersResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>> AsyncProducers(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>>(AsyncProducersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>> PrepareAsyncProducers(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>>(PrepareAsyncProducersRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} // Version returns the service version number virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) = 0; virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response, std::function) = 0; virtual void Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>* AsyncProducersRaw(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>* PrepareAsyncProducersRaw(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } ::grpc::Status Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::remote::BorProducersResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>> AsyncProducers(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>>(AsyncProducersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>> PrepareAsyncProducers(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>>(PrepareAsyncProducersRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) override; void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response, std::function) override; void Producers(::grpc::ClientContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>* AsyncProducersRaw(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorProducersResponse>* PrepareAsyncProducersRaw(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_Version_; const ::grpc::internal::RpcMethod rpcmethod_Producers_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // Version returns the service version number virtual ::grpc::Status Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response); virtual ::grpc::Status Producers(::grpc::ServerContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response); }; template class WithAsyncMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Version() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::types::VersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Producers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Producers() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_Producers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Producers(::grpc::ServerContext* /*context*/, const ::remote::BorProducersRequest* /*request*/, ::remote::BorProducersResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestProducers(::grpc::ServerContext* context, ::remote::BorProducersRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::BorProducersResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_Version > AsyncService; template class WithCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Version() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { return this->Version(context, request, response); }));} void SetMessageAllocatorFor_Version( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::types::VersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Producers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Producers() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::remote::BorProducersRequest, ::remote::BorProducersResponse>( [this]( ::grpc::CallbackServerContext* context, const ::remote::BorProducersRequest* request, ::remote::BorProducersResponse* response) { return this->Producers(context, request, response); }));} void SetMessageAllocatorFor_Producers( ::grpc::MessageAllocator< ::remote::BorProducersRequest, ::remote::BorProducersResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::BorProducersRequest, ::remote::BorProducersResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Producers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Producers(::grpc::ServerContext* /*context*/, const ::remote::BorProducersRequest* /*request*/, ::remote::BorProducersResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Producers( ::grpc::CallbackServerContext* /*context*/, const ::remote::BorProducersRequest* /*request*/, ::remote::BorProducersResponse* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_Version > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Version() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Producers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Producers() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_Producers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Producers(::grpc::ServerContext* /*context*/, const ::remote::BorProducersRequest* /*request*/, ::remote::BorProducersResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Version() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Producers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Producers() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_Producers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Producers(::grpc::ServerContext* /*context*/, const ::remote::BorProducersRequest* /*request*/, ::remote::BorProducersResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestProducers(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Version() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Version(context, request, response); })); } ~WithRawCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Producers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Producers() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Producers(context, request, response); })); } ~WithRawCallbackMethod_Producers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Producers(::grpc::ServerContext* /*context*/, const ::remote::BorProducersRequest* /*request*/, ::remote::BorProducersResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Producers( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Version() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::types::VersionReply>* streamer) { return this->StreamedVersion(context, streamer); })); } ~WithStreamedUnaryMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::types::VersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Producers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Producers() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler< ::remote::BorProducersRequest, ::remote::BorProducersResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorProducersRequest, ::remote::BorProducersResponse>* streamer) { return this->StreamedProducers(context, streamer); })); } ~WithStreamedUnaryMethod_Producers() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Producers(::grpc::ServerContext* /*context*/, const ::remote::BorProducersRequest* /*request*/, ::remote::BorProducersResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedProducers(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorProducersRequest,::remote::BorProducersResponse>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_Version > StreamedUnaryService; typedef Service SplitStreamedService; typedef WithStreamedUnaryMethod_Version > StreamedService; }; } // namespace remote #endif // GRPC_remote_2fbor_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/remote/bor.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: remote/bor.proto // Protobuf C++ Version: 5.27.0 #include "remote/bor.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace remote { inline constexpr BorTxnLookupReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : block_number_{::uint64_t{0u}}, present_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR BorTxnLookupReply::BorTxnLookupReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BorTxnLookupReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR BorTxnLookupReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BorTxnLookupReplyDefaultTypeInternal() {} union { BorTxnLookupReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BorTxnLookupReplyDefaultTypeInternal _BorTxnLookupReply_default_instance_; inline constexpr BorProducersRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : block_num_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR BorProducersRequest::BorProducersRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BorProducersRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR BorProducersRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BorProducersRequestDefaultTypeInternal() {} union { BorProducersRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BorProducersRequestDefaultTypeInternal _BorProducersRequest_default_instance_; inline constexpr BorEventsReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : event_rlps_{}, state_receiver_contract_address_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR BorEventsReply::BorEventsReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BorEventsReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR BorEventsReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BorEventsReplyDefaultTypeInternal() {} union { BorEventsReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BorEventsReplyDefaultTypeInternal _BorEventsReply_default_instance_; inline constexpr Validator::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, address_{nullptr}, id_{::uint64_t{0u}}, voting_power_{::int64_t{0}}, proposer_priority_{::int64_t{0}} {} template PROTOBUF_CONSTEXPR Validator::Validator(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ValidatorDefaultTypeInternal { PROTOBUF_CONSTEXPR ValidatorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ValidatorDefaultTypeInternal() {} union { Validator _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValidatorDefaultTypeInternal _Validator_default_instance_; inline constexpr BorTxnLookupRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, bor_tx_hash_{nullptr} {} template PROTOBUF_CONSTEXPR BorTxnLookupRequest::BorTxnLookupRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BorTxnLookupRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR BorTxnLookupRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BorTxnLookupRequestDefaultTypeInternal() {} union { BorTxnLookupRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BorTxnLookupRequestDefaultTypeInternal _BorTxnLookupRequest_default_instance_; inline constexpr BorEventsRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, block_hash_{nullptr}, block_num_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR BorEventsRequest::BorEventsRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BorEventsRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR BorEventsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BorEventsRequestDefaultTypeInternal() {} union { BorEventsRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BorEventsRequestDefaultTypeInternal _BorEventsRequest_default_instance_; inline constexpr BorProducersResponse::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, validators_{}, proposer_{nullptr} {} template PROTOBUF_CONSTEXPR BorProducersResponse::BorProducersResponse(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BorProducersResponseDefaultTypeInternal { PROTOBUF_CONSTEXPR BorProducersResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BorProducersResponseDefaultTypeInternal() {} union { BorProducersResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BorProducersResponseDefaultTypeInternal _BorProducersResponse_default_instance_; } // namespace remote static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_remote_2fbor_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_remote_2fbor_2eproto = nullptr; const ::uint32_t TableStruct_remote_2fbor_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { PROTOBUF_FIELD_OFFSET(::remote::BorTxnLookupRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::BorTxnLookupRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BorTxnLookupRequest, _impl_.bor_tx_hash_), 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::BorTxnLookupReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BorTxnLookupReply, _impl_.present_), PROTOBUF_FIELD_OFFSET(::remote::BorTxnLookupReply, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::remote::BorEventsRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::BorEventsRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BorEventsRequest, _impl_.block_num_), PROTOBUF_FIELD_OFFSET(::remote::BorEventsRequest, _impl_.block_hash_), ~0u, 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::BorEventsReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BorEventsReply, _impl_.state_receiver_contract_address_), PROTOBUF_FIELD_OFFSET(::remote::BorEventsReply, _impl_.event_rlps_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::BorProducersRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BorProducersRequest, _impl_.block_num_), PROTOBUF_FIELD_OFFSET(::remote::BorProducersResponse, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::BorProducersResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BorProducersResponse, _impl_.proposer_), PROTOBUF_FIELD_OFFSET(::remote::BorProducersResponse, _impl_.validators_), 0, ~0u, PROTOBUF_FIELD_OFFSET(::remote::Validator, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::Validator, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::Validator, _impl_.id_), PROTOBUF_FIELD_OFFSET(::remote::Validator, _impl_.address_), PROTOBUF_FIELD_OFFSET(::remote::Validator, _impl_.voting_power_), PROTOBUF_FIELD_OFFSET(::remote::Validator, _impl_.proposer_priority_), ~0u, 0, ~0u, ~0u, }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, 9, -1, sizeof(::remote::BorTxnLookupRequest)}, {10, -1, -1, sizeof(::remote::BorTxnLookupReply)}, {20, 30, -1, sizeof(::remote::BorEventsRequest)}, {32, -1, -1, sizeof(::remote::BorEventsReply)}, {42, -1, -1, sizeof(::remote::BorProducersRequest)}, {51, 61, -1, sizeof(::remote::BorProducersResponse)}, {63, 75, -1, sizeof(::remote::Validator)}, }; static const ::_pb::Message* const file_default_instances[] = { &::remote::_BorTxnLookupRequest_default_instance_._instance, &::remote::_BorTxnLookupReply_default_instance_._instance, &::remote::_BorEventsRequest_default_instance_._instance, &::remote::_BorEventsReply_default_instance_._instance, &::remote::_BorProducersRequest_default_instance_._instance, &::remote::_BorProducersResponse_default_instance_._instance, &::remote::_Validator_default_instance_._instance, }; const char descriptor_table_protodef_remote_2fbor_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\020remote/bor.proto\022\006remote\032\033google/proto" "buf/empty.proto\032\021types/types.proto\"7\n\023Bo" "rTxnLookupRequest\022 \n\013bor_tx_hash\030\001 \001(\0132\013" ".types.H256\":\n\021BorTxnLookupReply\022\017\n\007pres" "ent\030\001 \001(\010\022\024\n\014block_number\030\002 \001(\004\"F\n\020BorEv" "entsRequest\022\021\n\tblock_num\030\001 \001(\004\022\037\n\nblock_" "hash\030\002 \001(\0132\013.types.H256\"M\n\016BorEventsRepl" "y\022\'\n\037state_receiver_contract_address\030\001 \001" "(\t\022\022\n\nevent_rlps\030\002 \003(\014\"(\n\023BorProducersRe" "quest\022\021\n\tblock_num\030\001 \001(\004\"b\n\024BorProducers" "Response\022#\n\010proposer\030\001 \001(\0132\021.remote.Vali" "dator\022%\n\nvalidators\030\002 \003(\0132\021.remote.Valid" "ator\"f\n\tValidator\022\n\n\002id\030\001 \001(\004\022\034\n\007address" "\030\002 \001(\0132\013.types.H160\022\024\n\014voting_power\030\003 \001(" "\003\022\031\n\021proposer_priority\030\004 \001(\0032\316\001\n\rBridgeB" "ackend\0226\n\007Version\022\026.google.protobuf.Empt" "y\032\023.types.VersionReply\022F\n\014BorTxnLookup\022\033" ".remote.BorTxnLookupRequest\032\031.remote.Bor" "TxnLookupReply\022=\n\tBorEvents\022\030.remote.Bor" "EventsRequest\032\026.remote.BorEventsReply2\221\001" "\n\017HeimdallBackend\0226\n\007Version\022\026.google.pr" "otobuf.Empty\032\023.types.VersionReply\022F\n\tPro" "ducers\022\033.remote.BorProducersRequest\032\034.re" "mote.BorProducersResponseB\026Z\024./remote;re" "moteprotob\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_remote_2fbor_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_types_2ftypes_2eproto, }; static ::absl::once_flag descriptor_table_remote_2fbor_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_remote_2fbor_2eproto = { false, false, 977, descriptor_table_protodef_remote_2fbor_2eproto, "remote/bor.proto", &descriptor_table_remote_2fbor_2eproto_once, descriptor_table_remote_2fbor_2eproto_deps, 2, 7, schemas, file_default_instances, TableStruct_remote_2fbor_2eproto::offsets, file_level_enum_descriptors_remote_2fbor_2eproto, file_level_service_descriptors_remote_2fbor_2eproto, }; namespace remote { // =================================================================== class BorTxnLookupRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(BorTxnLookupRequest, _impl_._has_bits_); }; void BorTxnLookupRequest::clear_bor_tx_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.bor_tx_hash_ != nullptr) _impl_.bor_tx_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } BorTxnLookupRequest::BorTxnLookupRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BorTxnLookupRequest) } inline PROTOBUF_NDEBUG_INLINE BorTxnLookupRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::BorTxnLookupRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} BorTxnLookupRequest::BorTxnLookupRequest( ::google::protobuf::Arena* arena, const BorTxnLookupRequest& from) : ::google::protobuf::Message(arena) { BorTxnLookupRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.bor_tx_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.bor_tx_hash_) : nullptr; // @@protoc_insertion_point(copy_constructor:remote.BorTxnLookupRequest) } inline PROTOBUF_NDEBUG_INLINE BorTxnLookupRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void BorTxnLookupRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.bor_tx_hash_ = {}; } BorTxnLookupRequest::~BorTxnLookupRequest() { // @@protoc_insertion_point(destructor:remote.BorTxnLookupRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BorTxnLookupRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.bor_tx_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BorTxnLookupRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BorTxnLookupRequest, _impl_._cached_size_), false, }, &BorTxnLookupRequest::MergeImpl, &BorTxnLookupRequest::kDescriptorMethods, &descriptor_table_remote_2fbor_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> BorTxnLookupRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(BorTxnLookupRequest, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_BorTxnLookupRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BorTxnLookupRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H256 bor_tx_hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(BorTxnLookupRequest, _impl_.bor_tx_hash_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 bor_tx_hash = 1; {PROTOBUF_FIELD_OFFSET(BorTxnLookupRequest, _impl_.bor_tx_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void BorTxnLookupRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BorTxnLookupRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.bor_tx_hash_ != nullptr); _impl_.bor_tx_hash_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BorTxnLookupRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BorTxnLookupRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 bor_tx_hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.bor_tx_hash_, _impl_.bor_tx_hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BorTxnLookupRequest) return target; } ::size_t BorTxnLookupRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BorTxnLookupRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .types.H256 bor_tx_hash = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.bor_tx_hash_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BorTxnLookupRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BorTxnLookupRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.bor_tx_hash_ != nullptr); if (_this->_impl_.bor_tx_hash_ == nullptr) { _this->_impl_.bor_tx_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.bor_tx_hash_); } else { _this->_impl_.bor_tx_hash_->MergeFrom(*from._impl_.bor_tx_hash_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BorTxnLookupRequest::CopyFrom(const BorTxnLookupRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BorTxnLookupRequest) if (&from == this) return; Clear(); MergeFrom(from); } void BorTxnLookupRequest::InternalSwap(BorTxnLookupRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.bor_tx_hash_, other->_impl_.bor_tx_hash_); } ::google::protobuf::Metadata BorTxnLookupRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BorTxnLookupReply::_Internal { public: }; BorTxnLookupReply::BorTxnLookupReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BorTxnLookupReply) } BorTxnLookupReply::BorTxnLookupReply( ::google::protobuf::Arena* arena, const BorTxnLookupReply& from) : BorTxnLookupReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE BorTxnLookupReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void BorTxnLookupReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, block_number_), 0, offsetof(Impl_, present_) - offsetof(Impl_, block_number_) + sizeof(Impl_::present_)); } BorTxnLookupReply::~BorTxnLookupReply() { // @@protoc_insertion_point(destructor:remote.BorTxnLookupReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BorTxnLookupReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BorTxnLookupReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BorTxnLookupReply, _impl_._cached_size_), false, }, &BorTxnLookupReply::MergeImpl, &BorTxnLookupReply::kDescriptorMethods, &descriptor_table_remote_2fbor_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> BorTxnLookupReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_BorTxnLookupReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BorTxnLookupReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 block_number = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(BorTxnLookupReply, _impl_.block_number_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(BorTxnLookupReply, _impl_.block_number_)}}, // bool present = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(BorTxnLookupReply, _impl_.present_)}}, }}, {{ 65535, 65535 }}, {{ // bool present = 1; {PROTOBUF_FIELD_OFFSET(BorTxnLookupReply, _impl_.present_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // uint64 block_number = 2; {PROTOBUF_FIELD_OFFSET(BorTxnLookupReply, _impl_.block_number_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void BorTxnLookupReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BorTxnLookupReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.block_number_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.present_) - reinterpret_cast(&_impl_.block_number_)) + sizeof(_impl_.present_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BorTxnLookupReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BorTxnLookupReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool present = 1; if (this->_internal_present() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_present(), target); } // uint64 block_number = 2; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_block_number(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BorTxnLookupReply) return target; } ::size_t BorTxnLookupReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BorTxnLookupReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 block_number = 2; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } // bool present = 1; if (this->_internal_present() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BorTxnLookupReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BorTxnLookupReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } if (from._internal_present() != 0) { _this->_impl_.present_ = from._impl_.present_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BorTxnLookupReply::CopyFrom(const BorTxnLookupReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BorTxnLookupReply) if (&from == this) return; Clear(); MergeFrom(from); } void BorTxnLookupReply::InternalSwap(BorTxnLookupReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(BorTxnLookupReply, _impl_.present_) + sizeof(BorTxnLookupReply::_impl_.present_) - PROTOBUF_FIELD_OFFSET(BorTxnLookupReply, _impl_.block_number_)>( reinterpret_cast(&_impl_.block_number_), reinterpret_cast(&other->_impl_.block_number_)); } ::google::protobuf::Metadata BorTxnLookupReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BorEventsRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_._has_bits_); }; void BorEventsRequest::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } BorEventsRequest::BorEventsRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BorEventsRequest) } inline PROTOBUF_NDEBUG_INLINE BorEventsRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::BorEventsRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} BorEventsRequest::BorEventsRequest( ::google::protobuf::Arena* arena, const BorEventsRequest& from) : ::google::protobuf::Message(arena) { BorEventsRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.block_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; _impl_.block_num_ = from._impl_.block_num_; // @@protoc_insertion_point(copy_constructor:remote.BorEventsRequest) } inline PROTOBUF_NDEBUG_INLINE BorEventsRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void BorEventsRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, block_hash_), 0, offsetof(Impl_, block_num_) - offsetof(Impl_, block_hash_) + sizeof(Impl_::block_num_)); } BorEventsRequest::~BorEventsRequest() { // @@protoc_insertion_point(destructor:remote.BorEventsRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BorEventsRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.block_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BorEventsRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_._cached_size_), false, }, &BorEventsRequest::MergeImpl, &BorEventsRequest::kDescriptorMethods, &descriptor_table_remote_2fbor_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> BorEventsRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_BorEventsRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BorEventsRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H256 block_hash = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_.block_hash_)}}, // uint64 block_num = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(BorEventsRequest, _impl_.block_num_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_.block_num_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 block_num = 1; {PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_.block_num_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .types.H256 block_hash = 2; {PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_.block_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void BorEventsRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BorEventsRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } _impl_.block_num_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BorEventsRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BorEventsRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 block_num = 1; if (this->_internal_block_num() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_block_num(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H256 block_hash = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BorEventsRequest) return target; } ::size_t BorEventsRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BorEventsRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H256 block_hash = 2; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } // uint64 block_num = 1; if (this->_internal_block_num() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_num()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BorEventsRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BorEventsRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } if (from._internal_block_num() != 0) { _this->_impl_.block_num_ = from._impl_.block_num_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BorEventsRequest::CopyFrom(const BorEventsRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BorEventsRequest) if (&from == this) return; Clear(); MergeFrom(from); } void BorEventsRequest::InternalSwap(BorEventsRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_.block_num_) + sizeof(BorEventsRequest::_impl_.block_num_) - PROTOBUF_FIELD_OFFSET(BorEventsRequest, _impl_.block_hash_)>( reinterpret_cast(&_impl_.block_hash_), reinterpret_cast(&other->_impl_.block_hash_)); } ::google::protobuf::Metadata BorEventsRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BorEventsReply::_Internal { public: }; BorEventsReply::BorEventsReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BorEventsReply) } inline PROTOBUF_NDEBUG_INLINE BorEventsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::BorEventsReply& from_msg) : event_rlps_{visibility, arena, from.event_rlps_}, state_receiver_contract_address_(arena, from.state_receiver_contract_address_), _cached_size_{0} {} BorEventsReply::BorEventsReply( ::google::protobuf::Arena* arena, const BorEventsReply& from) : ::google::protobuf::Message(arena) { BorEventsReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.BorEventsReply) } inline PROTOBUF_NDEBUG_INLINE BorEventsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : event_rlps_{visibility, arena}, state_receiver_contract_address_(arena), _cached_size_{0} {} inline void BorEventsReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } BorEventsReply::~BorEventsReply() { // @@protoc_insertion_point(destructor:remote.BorEventsReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BorEventsReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.state_receiver_contract_address_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BorEventsReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BorEventsReply, _impl_._cached_size_), false, }, &BorEventsReply::MergeImpl, &BorEventsReply::kDescriptorMethods, &descriptor_table_remote_2fbor_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 61, 2> BorEventsReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_BorEventsReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BorEventsReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated bytes event_rlps = 2; {::_pbi::TcParser::FastBR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(BorEventsReply, _impl_.event_rlps_)}}, // string state_receiver_contract_address = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(BorEventsReply, _impl_.state_receiver_contract_address_)}}, }}, {{ 65535, 65535 }}, {{ // string state_receiver_contract_address = 1; {PROTOBUF_FIELD_OFFSET(BorEventsReply, _impl_.state_receiver_contract_address_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // repeated bytes event_rlps = 2; {PROTOBUF_FIELD_OFFSET(BorEventsReply, _impl_.event_rlps_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, }}, // no aux_entries {{ "\25\37\0\0\0\0\0\0" "remote.BorEventsReply" "state_receiver_contract_address" }}, }; PROTOBUF_NOINLINE void BorEventsReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BorEventsReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.event_rlps_.Clear(); _impl_.state_receiver_contract_address_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BorEventsReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BorEventsReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string state_receiver_contract_address = 1; if (!this->_internal_state_receiver_contract_address().empty()) { const std::string& _s = this->_internal_state_receiver_contract_address(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.BorEventsReply.state_receiver_contract_address"); target = stream->WriteStringMaybeAliased(1, _s, target); } // repeated bytes event_rlps = 2; for (int i = 0, n = this->_internal_event_rlps_size(); i < n; ++i) { const auto& s = this->_internal_event_rlps().Get(i); target = stream->WriteBytes(2, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BorEventsReply) return target; } ::size_t BorEventsReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BorEventsReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes event_rlps = 2; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_event_rlps().size()); for (int i = 0, n = _internal_event_rlps().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_event_rlps().Get(i)); } // string state_receiver_contract_address = 1; if (!this->_internal_state_receiver_contract_address().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_state_receiver_contract_address()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BorEventsReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BorEventsReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_event_rlps()->MergeFrom(from._internal_event_rlps()); if (!from._internal_state_receiver_contract_address().empty()) { _this->_internal_set_state_receiver_contract_address(from._internal_state_receiver_contract_address()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BorEventsReply::CopyFrom(const BorEventsReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BorEventsReply) if (&from == this) return; Clear(); MergeFrom(from); } void BorEventsReply::InternalSwap(BorEventsReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.event_rlps_.InternalSwap(&other->_impl_.event_rlps_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.state_receiver_contract_address_, &other->_impl_.state_receiver_contract_address_, arena); } ::google::protobuf::Metadata BorEventsReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BorProducersRequest::_Internal { public: }; BorProducersRequest::BorProducersRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BorProducersRequest) } BorProducersRequest::BorProducersRequest( ::google::protobuf::Arena* arena, const BorProducersRequest& from) : BorProducersRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE BorProducersRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void BorProducersRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.block_num_ = {}; } BorProducersRequest::~BorProducersRequest() { // @@protoc_insertion_point(destructor:remote.BorProducersRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BorProducersRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BorProducersRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BorProducersRequest, _impl_._cached_size_), false, }, &BorProducersRequest::MergeImpl, &BorProducersRequest::kDescriptorMethods, &descriptor_table_remote_2fbor_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> BorProducersRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_BorProducersRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BorProducersRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 block_num = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(BorProducersRequest, _impl_.block_num_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(BorProducersRequest, _impl_.block_num_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 block_num = 1; {PROTOBUF_FIELD_OFFSET(BorProducersRequest, _impl_.block_num_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void BorProducersRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BorProducersRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.block_num_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BorProducersRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BorProducersRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 block_num = 1; if (this->_internal_block_num() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_block_num(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BorProducersRequest) return target; } ::size_t BorProducersRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BorProducersRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 block_num = 1; if (this->_internal_block_num() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_num()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BorProducersRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BorProducersRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_block_num() != 0) { _this->_impl_.block_num_ = from._impl_.block_num_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BorProducersRequest::CopyFrom(const BorProducersRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BorProducersRequest) if (&from == this) return; Clear(); MergeFrom(from); } void BorProducersRequest::InternalSwap(BorProducersRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.block_num_, other->_impl_.block_num_); } ::google::protobuf::Metadata BorProducersRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BorProducersResponse::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(BorProducersResponse, _impl_._has_bits_); }; BorProducersResponse::BorProducersResponse(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BorProducersResponse) } inline PROTOBUF_NDEBUG_INLINE BorProducersResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::BorProducersResponse& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, validators_{visibility, arena, from.validators_} {} BorProducersResponse::BorProducersResponse( ::google::protobuf::Arena* arena, const BorProducersResponse& from) : ::google::protobuf::Message(arena) { BorProducersResponse* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.proposer_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::remote::Validator>( arena, *from._impl_.proposer_) : nullptr; // @@protoc_insertion_point(copy_constructor:remote.BorProducersResponse) } inline PROTOBUF_NDEBUG_INLINE BorProducersResponse::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, validators_{visibility, arena} {} inline void BorProducersResponse::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.proposer_ = {}; } BorProducersResponse::~BorProducersResponse() { // @@protoc_insertion_point(destructor:remote.BorProducersResponse) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BorProducersResponse::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.proposer_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BorProducersResponse::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BorProducersResponse, _impl_._cached_size_), false, }, &BorProducersResponse::MergeImpl, &BorProducersResponse::kDescriptorMethods, &descriptor_table_remote_2fbor_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 2, 0, 2> BorProducersResponse::_table_ = { { PROTOBUF_FIELD_OFFSET(BorProducersResponse, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_BorProducersResponse_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BorProducersResponse>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .remote.Validator validators = 2; {::_pbi::TcParser::FastMtR1, {18, 63, 1, PROTOBUF_FIELD_OFFSET(BorProducersResponse, _impl_.validators_)}}, // .remote.Validator proposer = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(BorProducersResponse, _impl_.proposer_)}}, }}, {{ 65535, 65535 }}, {{ // .remote.Validator proposer = 1; {PROTOBUF_FIELD_OFFSET(BorProducersResponse, _impl_.proposer_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // repeated .remote.Validator validators = 2; {PROTOBUF_FIELD_OFFSET(BorProducersResponse, _impl_.validators_), -1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::remote::Validator>()}, {::_pbi::TcParser::GetTable<::remote::Validator>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void BorProducersResponse::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BorProducersResponse) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.validators_.Clear(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.proposer_ != nullptr); _impl_.proposer_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BorProducersResponse::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BorProducersResponse) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .remote.Validator proposer = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.proposer_, _impl_.proposer_->GetCachedSize(), target, stream); } // repeated .remote.Validator validators = 2; for (unsigned i = 0, n = static_cast( this->_internal_validators_size()); i < n; i++) { const auto& repfield = this->_internal_validators().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BorProducersResponse) return target; } ::size_t BorProducersResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BorProducersResponse) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .remote.Validator validators = 2; total_size += 1UL * this->_internal_validators_size(); for (const auto& msg : this->_internal_validators()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // .remote.Validator proposer = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.proposer_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BorProducersResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BorProducersResponse) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_validators()->MergeFrom( from._internal_validators()); cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.proposer_ != nullptr); if (_this->_impl_.proposer_ == nullptr) { _this->_impl_.proposer_ = ::google::protobuf::Message::CopyConstruct<::remote::Validator>(arena, *from._impl_.proposer_); } else { _this->_impl_.proposer_->MergeFrom(*from._impl_.proposer_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BorProducersResponse::CopyFrom(const BorProducersResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BorProducersResponse) if (&from == this) return; Clear(); MergeFrom(from); } void BorProducersResponse::InternalSwap(BorProducersResponse* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.validators_.InternalSwap(&other->_impl_.validators_); swap(_impl_.proposer_, other->_impl_.proposer_); } ::google::protobuf::Metadata BorProducersResponse::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Validator::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(Validator, _impl_._has_bits_); }; void Validator::clear_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ != nullptr) _impl_.address_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } Validator::Validator(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.Validator) } inline PROTOBUF_NDEBUG_INLINE Validator::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::Validator& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} Validator::Validator( ::google::protobuf::Arena* arena, const Validator& from) : ::google::protobuf::Message(arena) { Validator* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.address_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, id_), offsetof(Impl_, proposer_priority_) - offsetof(Impl_, id_) + sizeof(Impl_::proposer_priority_)); // @@protoc_insertion_point(copy_constructor:remote.Validator) } inline PROTOBUF_NDEBUG_INLINE Validator::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void Validator::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, address_), 0, offsetof(Impl_, proposer_priority_) - offsetof(Impl_, address_) + sizeof(Impl_::proposer_priority_)); } Validator::~Validator() { // @@protoc_insertion_point(destructor:remote.Validator) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Validator::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.address_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Validator::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Validator, _impl_._cached_size_), false, }, &Validator::MergeImpl, &Validator::kDescriptorMethods, &descriptor_table_remote_2fbor_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 4, 1, 0, 2> Validator::_table_ = { { PROTOBUF_FIELD_OFFSET(Validator, _impl_._has_bits_), 0, // no _extensions_ 4, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967280, // skipmap offsetof(decltype(_table_), field_entries), 4, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_Validator_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::Validator>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // int64 proposer_priority = 4; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Validator, _impl_.proposer_priority_), 63>(), {32, 63, 0, PROTOBUF_FIELD_OFFSET(Validator, _impl_.proposer_priority_)}}, // uint64 id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Validator, _impl_.id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(Validator, _impl_.id_)}}, // .types.H160 address = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(Validator, _impl_.address_)}}, // int64 voting_power = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Validator, _impl_.voting_power_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(Validator, _impl_.voting_power_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 id = 1; {PROTOBUF_FIELD_OFFSET(Validator, _impl_.id_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .types.H160 address = 2; {PROTOBUF_FIELD_OFFSET(Validator, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // int64 voting_power = 3; {PROTOBUF_FIELD_OFFSET(Validator, _impl_.voting_power_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, // int64 proposer_priority = 4; {PROTOBUF_FIELD_OFFSET(Validator, _impl_.proposer_priority_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void Validator::Clear() { // @@protoc_insertion_point(message_clear_start:remote.Validator) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.address_ != nullptr); _impl_.address_->Clear(); } ::memset(&_impl_.id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.proposer_priority_) - reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.proposer_priority_)); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Validator::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.Validator) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_id(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H160 address = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.address_, _impl_.address_->GetCachedSize(), target, stream); } // int64 voting_power = 3; if (this->_internal_voting_power() != 0) { target = ::google::protobuf::internal::WireFormatLite:: WriteInt64ToArrayWithField<3>( stream, this->_internal_voting_power(), target); } // int64 proposer_priority = 4; if (this->_internal_proposer_priority() != 0) { target = ::google::protobuf::internal::WireFormatLite:: WriteInt64ToArrayWithField<4>( stream, this->_internal_proposer_priority(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.Validator) return target; } ::size_t Validator::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.Validator) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H160 address = 2; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.address_); } // uint64 id = 1; if (this->_internal_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_id()); } // int64 voting_power = 3; if (this->_internal_voting_power() != 0) { total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( this->_internal_voting_power()); } // int64 proposer_priority = 4; if (this->_internal_proposer_priority() != 0) { total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( this->_internal_proposer_priority()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Validator::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.Validator) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.address_ != nullptr); if (_this->_impl_.address_ == nullptr) { _this->_impl_.address_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.address_); } else { _this->_impl_.address_->MergeFrom(*from._impl_.address_); } } if (from._internal_id() != 0) { _this->_impl_.id_ = from._impl_.id_; } if (from._internal_voting_power() != 0) { _this->_impl_.voting_power_ = from._impl_.voting_power_; } if (from._internal_proposer_priority() != 0) { _this->_impl_.proposer_priority_ = from._impl_.proposer_priority_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Validator::CopyFrom(const Validator& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.Validator) if (&from == this) return; Clear(); MergeFrom(from); } void Validator::InternalSwap(Validator* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(Validator, _impl_.proposer_priority_) + sizeof(Validator::_impl_.proposer_priority_) - PROTOBUF_FIELD_OFFSET(Validator, _impl_.address_)>( reinterpret_cast(&_impl_.address_), reinterpret_cast(&other->_impl_.address_)); } ::google::protobuf::Metadata Validator::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace remote namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_remote_2fbor_2eproto), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/remote/bor.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: remote/bor.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_remote_2fbor_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_remote_2fbor_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" #include "types/types.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_remote_2fbor_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_remote_2fbor_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_remote_2fbor_2eproto; namespace remote { class BorEventsReply; struct BorEventsReplyDefaultTypeInternal; extern BorEventsReplyDefaultTypeInternal _BorEventsReply_default_instance_; class BorEventsRequest; struct BorEventsRequestDefaultTypeInternal; extern BorEventsRequestDefaultTypeInternal _BorEventsRequest_default_instance_; class BorProducersRequest; struct BorProducersRequestDefaultTypeInternal; extern BorProducersRequestDefaultTypeInternal _BorProducersRequest_default_instance_; class BorProducersResponse; struct BorProducersResponseDefaultTypeInternal; extern BorProducersResponseDefaultTypeInternal _BorProducersResponse_default_instance_; class BorTxnLookupReply; struct BorTxnLookupReplyDefaultTypeInternal; extern BorTxnLookupReplyDefaultTypeInternal _BorTxnLookupReply_default_instance_; class BorTxnLookupRequest; struct BorTxnLookupRequestDefaultTypeInternal; extern BorTxnLookupRequestDefaultTypeInternal _BorTxnLookupRequest_default_instance_; class Validator; struct ValidatorDefaultTypeInternal; extern ValidatorDefaultTypeInternal _Validator_default_instance_; } // namespace remote namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace remote { // =================================================================== // ------------------------------------------------------------------- class BorTxnLookupReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BorTxnLookupReply) */ { public: inline BorTxnLookupReply() : BorTxnLookupReply(nullptr) {} ~BorTxnLookupReply() override; template explicit PROTOBUF_CONSTEXPR BorTxnLookupReply( ::google::protobuf::internal::ConstantInitialized); inline BorTxnLookupReply(const BorTxnLookupReply& from) : BorTxnLookupReply(nullptr, from) {} inline BorTxnLookupReply(BorTxnLookupReply&& from) noexcept : BorTxnLookupReply(nullptr, std::move(from)) {} inline BorTxnLookupReply& operator=(const BorTxnLookupReply& from) { CopyFrom(from); return *this; } inline BorTxnLookupReply& operator=(BorTxnLookupReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BorTxnLookupReply& default_instance() { return *internal_default_instance(); } static inline const BorTxnLookupReply* internal_default_instance() { return reinterpret_cast( &_BorTxnLookupReply_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(BorTxnLookupReply& a, BorTxnLookupReply& b) { a.Swap(&b); } inline void Swap(BorTxnLookupReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BorTxnLookupReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BorTxnLookupReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BorTxnLookupReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BorTxnLookupReply& from) { BorTxnLookupReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BorTxnLookupReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BorTxnLookupReply"; } protected: explicit BorTxnLookupReply(::google::protobuf::Arena* arena); BorTxnLookupReply(::google::protobuf::Arena* arena, const BorTxnLookupReply& from); BorTxnLookupReply(::google::protobuf::Arena* arena, BorTxnLookupReply&& from) noexcept : BorTxnLookupReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockNumberFieldNumber = 2, kPresentFieldNumber = 1, }; // uint64 block_number = 2; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // bool present = 1; void clear_present() ; bool present() const; void set_present(bool value); private: bool _internal_present() const; void _internal_set_present(bool value); public: // @@protoc_insertion_point(class_scope:remote.BorTxnLookupReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BorTxnLookupReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BorTxnLookupReply& from_msg); ::uint64_t block_number_; bool present_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fbor_2eproto; }; // ------------------------------------------------------------------- class BorProducersRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BorProducersRequest) */ { public: inline BorProducersRequest() : BorProducersRequest(nullptr) {} ~BorProducersRequest() override; template explicit PROTOBUF_CONSTEXPR BorProducersRequest( ::google::protobuf::internal::ConstantInitialized); inline BorProducersRequest(const BorProducersRequest& from) : BorProducersRequest(nullptr, from) {} inline BorProducersRequest(BorProducersRequest&& from) noexcept : BorProducersRequest(nullptr, std::move(from)) {} inline BorProducersRequest& operator=(const BorProducersRequest& from) { CopyFrom(from); return *this; } inline BorProducersRequest& operator=(BorProducersRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BorProducersRequest& default_instance() { return *internal_default_instance(); } static inline const BorProducersRequest* internal_default_instance() { return reinterpret_cast( &_BorProducersRequest_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(BorProducersRequest& a, BorProducersRequest& b) { a.Swap(&b); } inline void Swap(BorProducersRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BorProducersRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BorProducersRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BorProducersRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BorProducersRequest& from) { BorProducersRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BorProducersRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BorProducersRequest"; } protected: explicit BorProducersRequest(::google::protobuf::Arena* arena); BorProducersRequest(::google::protobuf::Arena* arena, const BorProducersRequest& from); BorProducersRequest(::google::protobuf::Arena* arena, BorProducersRequest&& from) noexcept : BorProducersRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockNumFieldNumber = 1, }; // uint64 block_num = 1; void clear_block_num() ; ::uint64_t block_num() const; void set_block_num(::uint64_t value); private: ::uint64_t _internal_block_num() const; void _internal_set_block_num(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.BorProducersRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BorProducersRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BorProducersRequest& from_msg); ::uint64_t block_num_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fbor_2eproto; }; // ------------------------------------------------------------------- class BorEventsReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BorEventsReply) */ { public: inline BorEventsReply() : BorEventsReply(nullptr) {} ~BorEventsReply() override; template explicit PROTOBUF_CONSTEXPR BorEventsReply( ::google::protobuf::internal::ConstantInitialized); inline BorEventsReply(const BorEventsReply& from) : BorEventsReply(nullptr, from) {} inline BorEventsReply(BorEventsReply&& from) noexcept : BorEventsReply(nullptr, std::move(from)) {} inline BorEventsReply& operator=(const BorEventsReply& from) { CopyFrom(from); return *this; } inline BorEventsReply& operator=(BorEventsReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BorEventsReply& default_instance() { return *internal_default_instance(); } static inline const BorEventsReply* internal_default_instance() { return reinterpret_cast( &_BorEventsReply_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(BorEventsReply& a, BorEventsReply& b) { a.Swap(&b); } inline void Swap(BorEventsReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BorEventsReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BorEventsReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BorEventsReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BorEventsReply& from) { BorEventsReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BorEventsReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BorEventsReply"; } protected: explicit BorEventsReply(::google::protobuf::Arena* arena); BorEventsReply(::google::protobuf::Arena* arena, const BorEventsReply& from); BorEventsReply(::google::protobuf::Arena* arena, BorEventsReply&& from) noexcept : BorEventsReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kEventRlpsFieldNumber = 2, kStateReceiverContractAddressFieldNumber = 1, }; // repeated bytes event_rlps = 2; int event_rlps_size() const; private: int _internal_event_rlps_size() const; public: void clear_event_rlps() ; const std::string& event_rlps(int index) const; std::string* mutable_event_rlps(int index); void set_event_rlps(int index, const std::string& value); void set_event_rlps(int index, std::string&& value); void set_event_rlps(int index, const char* value); void set_event_rlps(int index, const void* value, std::size_t size); void set_event_rlps(int index, absl::string_view value); std::string* add_event_rlps(); void add_event_rlps(const std::string& value); void add_event_rlps(std::string&& value); void add_event_rlps(const char* value); void add_event_rlps(const void* value, std::size_t size); void add_event_rlps(absl::string_view value); const ::google::protobuf::RepeatedPtrField& event_rlps() const; ::google::protobuf::RepeatedPtrField* mutable_event_rlps(); private: const ::google::protobuf::RepeatedPtrField& _internal_event_rlps() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_event_rlps(); public: // string state_receiver_contract_address = 1; void clear_state_receiver_contract_address() ; const std::string& state_receiver_contract_address() const; template void set_state_receiver_contract_address(Arg_&& arg, Args_... args); std::string* mutable_state_receiver_contract_address(); PROTOBUF_NODISCARD std::string* release_state_receiver_contract_address(); void set_allocated_state_receiver_contract_address(std::string* value); private: const std::string& _internal_state_receiver_contract_address() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_state_receiver_contract_address( const std::string& value); std::string* _internal_mutable_state_receiver_contract_address(); public: // @@protoc_insertion_point(class_scope:remote.BorEventsReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 61, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BorEventsReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BorEventsReply& from_msg); ::google::protobuf::RepeatedPtrField event_rlps_; ::google::protobuf::internal::ArenaStringPtr state_receiver_contract_address_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fbor_2eproto; }; // ------------------------------------------------------------------- class Validator final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.Validator) */ { public: inline Validator() : Validator(nullptr) {} ~Validator() override; template explicit PROTOBUF_CONSTEXPR Validator( ::google::protobuf::internal::ConstantInitialized); inline Validator(const Validator& from) : Validator(nullptr, from) {} inline Validator(Validator&& from) noexcept : Validator(nullptr, std::move(from)) {} inline Validator& operator=(const Validator& from) { CopyFrom(from); return *this; } inline Validator& operator=(Validator&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Validator& default_instance() { return *internal_default_instance(); } static inline const Validator* internal_default_instance() { return reinterpret_cast( &_Validator_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(Validator& a, Validator& b) { a.Swap(&b); } inline void Swap(Validator* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Validator* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Validator* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Validator& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Validator& from) { Validator::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Validator* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.Validator"; } protected: explicit Validator(::google::protobuf::Arena* arena); Validator(::google::protobuf::Arena* arena, const Validator& from); Validator(::google::protobuf::Arena* arena, Validator&& from) noexcept : Validator(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kAddressFieldNumber = 2, kIdFieldNumber = 1, kVotingPowerFieldNumber = 3, kProposerPriorityFieldNumber = 4, }; // .types.H160 address = 2; bool has_address() const; void clear_address() ; const ::types::H160& address() const; PROTOBUF_NODISCARD ::types::H160* release_address(); ::types::H160* mutable_address(); void set_allocated_address(::types::H160* value); void unsafe_arena_set_allocated_address(::types::H160* value); ::types::H160* unsafe_arena_release_address(); private: const ::types::H160& _internal_address() const; ::types::H160* _internal_mutable_address(); public: // uint64 id = 1; void clear_id() ; ::uint64_t id() const; void set_id(::uint64_t value); private: ::uint64_t _internal_id() const; void _internal_set_id(::uint64_t value); public: // int64 voting_power = 3; void clear_voting_power() ; ::int64_t voting_power() const; void set_voting_power(::int64_t value); private: ::int64_t _internal_voting_power() const; void _internal_set_voting_power(::int64_t value); public: // int64 proposer_priority = 4; void clear_proposer_priority() ; ::int64_t proposer_priority() const; void set_proposer_priority(::int64_t value); private: ::int64_t _internal_proposer_priority() const; void _internal_set_proposer_priority(::int64_t value); public: // @@protoc_insertion_point(class_scope:remote.Validator) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 4, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Validator_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Validator& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H160* address_; ::uint64_t id_; ::int64_t voting_power_; ::int64_t proposer_priority_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fbor_2eproto; }; // ------------------------------------------------------------------- class BorTxnLookupRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BorTxnLookupRequest) */ { public: inline BorTxnLookupRequest() : BorTxnLookupRequest(nullptr) {} ~BorTxnLookupRequest() override; template explicit PROTOBUF_CONSTEXPR BorTxnLookupRequest( ::google::protobuf::internal::ConstantInitialized); inline BorTxnLookupRequest(const BorTxnLookupRequest& from) : BorTxnLookupRequest(nullptr, from) {} inline BorTxnLookupRequest(BorTxnLookupRequest&& from) noexcept : BorTxnLookupRequest(nullptr, std::move(from)) {} inline BorTxnLookupRequest& operator=(const BorTxnLookupRequest& from) { CopyFrom(from); return *this; } inline BorTxnLookupRequest& operator=(BorTxnLookupRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BorTxnLookupRequest& default_instance() { return *internal_default_instance(); } static inline const BorTxnLookupRequest* internal_default_instance() { return reinterpret_cast( &_BorTxnLookupRequest_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(BorTxnLookupRequest& a, BorTxnLookupRequest& b) { a.Swap(&b); } inline void Swap(BorTxnLookupRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BorTxnLookupRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BorTxnLookupRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BorTxnLookupRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BorTxnLookupRequest& from) { BorTxnLookupRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BorTxnLookupRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BorTxnLookupRequest"; } protected: explicit BorTxnLookupRequest(::google::protobuf::Arena* arena); BorTxnLookupRequest(::google::protobuf::Arena* arena, const BorTxnLookupRequest& from); BorTxnLookupRequest(::google::protobuf::Arena* arena, BorTxnLookupRequest&& from) noexcept : BorTxnLookupRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBorTxHashFieldNumber = 1, }; // .types.H256 bor_tx_hash = 1; bool has_bor_tx_hash() const; void clear_bor_tx_hash() ; const ::types::H256& bor_tx_hash() const; PROTOBUF_NODISCARD ::types::H256* release_bor_tx_hash(); ::types::H256* mutable_bor_tx_hash(); void set_allocated_bor_tx_hash(::types::H256* value); void unsafe_arena_set_allocated_bor_tx_hash(::types::H256* value); ::types::H256* unsafe_arena_release_bor_tx_hash(); private: const ::types::H256& _internal_bor_tx_hash() const; ::types::H256* _internal_mutable_bor_tx_hash(); public: // @@protoc_insertion_point(class_scope:remote.BorTxnLookupRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BorTxnLookupRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BorTxnLookupRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* bor_tx_hash_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fbor_2eproto; }; // ------------------------------------------------------------------- class BorEventsRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BorEventsRequest) */ { public: inline BorEventsRequest() : BorEventsRequest(nullptr) {} ~BorEventsRequest() override; template explicit PROTOBUF_CONSTEXPR BorEventsRequest( ::google::protobuf::internal::ConstantInitialized); inline BorEventsRequest(const BorEventsRequest& from) : BorEventsRequest(nullptr, from) {} inline BorEventsRequest(BorEventsRequest&& from) noexcept : BorEventsRequest(nullptr, std::move(from)) {} inline BorEventsRequest& operator=(const BorEventsRequest& from) { CopyFrom(from); return *this; } inline BorEventsRequest& operator=(BorEventsRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BorEventsRequest& default_instance() { return *internal_default_instance(); } static inline const BorEventsRequest* internal_default_instance() { return reinterpret_cast( &_BorEventsRequest_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(BorEventsRequest& a, BorEventsRequest& b) { a.Swap(&b); } inline void Swap(BorEventsRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BorEventsRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BorEventsRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BorEventsRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BorEventsRequest& from) { BorEventsRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BorEventsRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BorEventsRequest"; } protected: explicit BorEventsRequest(::google::protobuf::Arena* arena); BorEventsRequest(::google::protobuf::Arena* arena, const BorEventsRequest& from); BorEventsRequest(::google::protobuf::Arena* arena, BorEventsRequest&& from) noexcept : BorEventsRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockHashFieldNumber = 2, kBlockNumFieldNumber = 1, }; // .types.H256 block_hash = 2; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // uint64 block_num = 1; void clear_block_num() ; ::uint64_t block_num() const; void set_block_num(::uint64_t value); private: ::uint64_t _internal_block_num() const; void _internal_set_block_num(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.BorEventsRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BorEventsRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BorEventsRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* block_hash_; ::uint64_t block_num_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fbor_2eproto; }; // ------------------------------------------------------------------- class BorProducersResponse final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BorProducersResponse) */ { public: inline BorProducersResponse() : BorProducersResponse(nullptr) {} ~BorProducersResponse() override; template explicit PROTOBUF_CONSTEXPR BorProducersResponse( ::google::protobuf::internal::ConstantInitialized); inline BorProducersResponse(const BorProducersResponse& from) : BorProducersResponse(nullptr, from) {} inline BorProducersResponse(BorProducersResponse&& from) noexcept : BorProducersResponse(nullptr, std::move(from)) {} inline BorProducersResponse& operator=(const BorProducersResponse& from) { CopyFrom(from); return *this; } inline BorProducersResponse& operator=(BorProducersResponse&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BorProducersResponse& default_instance() { return *internal_default_instance(); } static inline const BorProducersResponse* internal_default_instance() { return reinterpret_cast( &_BorProducersResponse_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(BorProducersResponse& a, BorProducersResponse& b) { a.Swap(&b); } inline void Swap(BorProducersResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BorProducersResponse* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BorProducersResponse* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BorProducersResponse& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BorProducersResponse& from) { BorProducersResponse::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BorProducersResponse* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BorProducersResponse"; } protected: explicit BorProducersResponse(::google::protobuf::Arena* arena); BorProducersResponse(::google::protobuf::Arena* arena, const BorProducersResponse& from); BorProducersResponse(::google::protobuf::Arena* arena, BorProducersResponse&& from) noexcept : BorProducersResponse(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kValidatorsFieldNumber = 2, kProposerFieldNumber = 1, }; // repeated .remote.Validator validators = 2; int validators_size() const; private: int _internal_validators_size() const; public: void clear_validators() ; ::remote::Validator* mutable_validators(int index); ::google::protobuf::RepeatedPtrField<::remote::Validator>* mutable_validators(); private: const ::google::protobuf::RepeatedPtrField<::remote::Validator>& _internal_validators() const; ::google::protobuf::RepeatedPtrField<::remote::Validator>* _internal_mutable_validators(); public: const ::remote::Validator& validators(int index) const; ::remote::Validator* add_validators(); const ::google::protobuf::RepeatedPtrField<::remote::Validator>& validators() const; // .remote.Validator proposer = 1; bool has_proposer() const; void clear_proposer() ; const ::remote::Validator& proposer() const; PROTOBUF_NODISCARD ::remote::Validator* release_proposer(); ::remote::Validator* mutable_proposer(); void set_allocated_proposer(::remote::Validator* value); void unsafe_arena_set_allocated_proposer(::remote::Validator* value); ::remote::Validator* unsafe_arena_release_proposer(); private: const ::remote::Validator& _internal_proposer() const; ::remote::Validator* _internal_mutable_proposer(); public: // @@protoc_insertion_point(class_scope:remote.BorProducersResponse) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BorProducersResponse_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BorProducersResponse& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::remote::Validator > validators_; ::remote::Validator* proposer_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fbor_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // BorTxnLookupRequest // .types.H256 bor_tx_hash = 1; inline bool BorTxnLookupRequest::has_bor_tx_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.bor_tx_hash_ != nullptr); return value; } inline const ::types::H256& BorTxnLookupRequest::_internal_bor_tx_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.bor_tx_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& BorTxnLookupRequest::bor_tx_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BorTxnLookupRequest.bor_tx_hash) return _internal_bor_tx_hash(); } inline void BorTxnLookupRequest::unsafe_arena_set_allocated_bor_tx_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bor_tx_hash_); } _impl_.bor_tx_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.BorTxnLookupRequest.bor_tx_hash) } inline ::types::H256* BorTxnLookupRequest::release_bor_tx_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.bor_tx_hash_; _impl_.bor_tx_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* BorTxnLookupRequest::unsafe_arena_release_bor_tx_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.BorTxnLookupRequest.bor_tx_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.bor_tx_hash_; _impl_.bor_tx_hash_ = nullptr; return temp; } inline ::types::H256* BorTxnLookupRequest::_internal_mutable_bor_tx_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.bor_tx_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.bor_tx_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.bor_tx_hash_; } inline ::types::H256* BorTxnLookupRequest::mutable_bor_tx_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_bor_tx_hash(); // @@protoc_insertion_point(field_mutable:remote.BorTxnLookupRequest.bor_tx_hash) return _msg; } inline void BorTxnLookupRequest::set_allocated_bor_tx_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.bor_tx_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.bor_tx_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.BorTxnLookupRequest.bor_tx_hash) } // ------------------------------------------------------------------- // BorTxnLookupReply // bool present = 1; inline void BorTxnLookupReply::clear_present() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.present_ = false; } inline bool BorTxnLookupReply::present() const { // @@protoc_insertion_point(field_get:remote.BorTxnLookupReply.present) return _internal_present(); } inline void BorTxnLookupReply::set_present(bool value) { _internal_set_present(value); // @@protoc_insertion_point(field_set:remote.BorTxnLookupReply.present) } inline bool BorTxnLookupReply::_internal_present() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.present_; } inline void BorTxnLookupReply::_internal_set_present(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.present_ = value; } // uint64 block_number = 2; inline void BorTxnLookupReply::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t BorTxnLookupReply::block_number() const { // @@protoc_insertion_point(field_get:remote.BorTxnLookupReply.block_number) return _internal_block_number(); } inline void BorTxnLookupReply::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:remote.BorTxnLookupReply.block_number) } inline ::uint64_t BorTxnLookupReply::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void BorTxnLookupReply::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // ------------------------------------------------------------------- // BorEventsRequest // uint64 block_num = 1; inline void BorEventsRequest::clear_block_num() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_num_ = ::uint64_t{0u}; } inline ::uint64_t BorEventsRequest::block_num() const { // @@protoc_insertion_point(field_get:remote.BorEventsRequest.block_num) return _internal_block_num(); } inline void BorEventsRequest::set_block_num(::uint64_t value) { _internal_set_block_num(value); // @@protoc_insertion_point(field_set:remote.BorEventsRequest.block_num) } inline ::uint64_t BorEventsRequest::_internal_block_num() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_num_; } inline void BorEventsRequest::_internal_set_block_num(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_num_ = value; } // .types.H256 block_hash = 2; inline bool BorEventsRequest::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline const ::types::H256& BorEventsRequest::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& BorEventsRequest::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BorEventsRequest.block_hash) return _internal_block_hash(); } inline void BorEventsRequest::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.BorEventsRequest.block_hash) } inline ::types::H256* BorEventsRequest::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* BorEventsRequest::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.BorEventsRequest.block_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* BorEventsRequest::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* BorEventsRequest::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:remote.BorEventsRequest.block_hash) return _msg; } inline void BorEventsRequest::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.BorEventsRequest.block_hash) } // ------------------------------------------------------------------- // BorEventsReply // string state_receiver_contract_address = 1; inline void BorEventsReply::clear_state_receiver_contract_address() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.state_receiver_contract_address_.ClearToEmpty(); } inline const std::string& BorEventsReply::state_receiver_contract_address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BorEventsReply.state_receiver_contract_address) return _internal_state_receiver_contract_address(); } template inline PROTOBUF_ALWAYS_INLINE void BorEventsReply::set_state_receiver_contract_address(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.state_receiver_contract_address_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.BorEventsReply.state_receiver_contract_address) } inline std::string* BorEventsReply::mutable_state_receiver_contract_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_state_receiver_contract_address(); // @@protoc_insertion_point(field_mutable:remote.BorEventsReply.state_receiver_contract_address) return _s; } inline const std::string& BorEventsReply::_internal_state_receiver_contract_address() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.state_receiver_contract_address_.Get(); } inline void BorEventsReply::_internal_set_state_receiver_contract_address(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.state_receiver_contract_address_.Set(value, GetArena()); } inline std::string* BorEventsReply::_internal_mutable_state_receiver_contract_address() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.state_receiver_contract_address_.Mutable( GetArena()); } inline std::string* BorEventsReply::release_state_receiver_contract_address() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.BorEventsReply.state_receiver_contract_address) return _impl_.state_receiver_contract_address_.Release(); } inline void BorEventsReply::set_allocated_state_receiver_contract_address(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.state_receiver_contract_address_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.state_receiver_contract_address_.IsDefault()) { _impl_.state_receiver_contract_address_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.BorEventsReply.state_receiver_contract_address) } // repeated bytes event_rlps = 2; inline int BorEventsReply::_internal_event_rlps_size() const { return _internal_event_rlps().size(); } inline int BorEventsReply::event_rlps_size() const { return _internal_event_rlps_size(); } inline void BorEventsReply::clear_event_rlps() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.event_rlps_.Clear(); } inline std::string* BorEventsReply::add_event_rlps() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_event_rlps()->Add(); // @@protoc_insertion_point(field_add_mutable:remote.BorEventsReply.event_rlps) return _s; } inline const std::string& BorEventsReply::event_rlps(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BorEventsReply.event_rlps) return _internal_event_rlps().Get(index); } inline std::string* BorEventsReply::mutable_event_rlps(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.BorEventsReply.event_rlps) return _internal_mutable_event_rlps()->Mutable(index); } inline void BorEventsReply::set_event_rlps(int index, const std::string& value) { _internal_mutable_event_rlps()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::set_event_rlps(int index, std::string&& value) { _internal_mutable_event_rlps()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::set_event_rlps(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_event_rlps()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::set_event_rlps(int index, const void* value, std::size_t size) { _internal_mutable_event_rlps()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::set_event_rlps(int index, absl::string_view value) { _internal_mutable_event_rlps()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::add_event_rlps(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_event_rlps()->Add()->assign(value); // @@protoc_insertion_point(field_add:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::add_event_rlps(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_event_rlps()->Add(std::move(value)); // @@protoc_insertion_point(field_add:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::add_event_rlps(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_event_rlps()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::add_event_rlps(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_event_rlps()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:remote.BorEventsReply.event_rlps) } inline void BorEventsReply::add_event_rlps(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_event_rlps()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:remote.BorEventsReply.event_rlps) } inline const ::google::protobuf::RepeatedPtrField& BorEventsReply::event_rlps() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.BorEventsReply.event_rlps) return _internal_event_rlps(); } inline ::google::protobuf::RepeatedPtrField* BorEventsReply::mutable_event_rlps() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.BorEventsReply.event_rlps) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_event_rlps(); } inline const ::google::protobuf::RepeatedPtrField& BorEventsReply::_internal_event_rlps() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.event_rlps_; } inline ::google::protobuf::RepeatedPtrField* BorEventsReply::_internal_mutable_event_rlps() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.event_rlps_; } // ------------------------------------------------------------------- // BorProducersRequest // uint64 block_num = 1; inline void BorProducersRequest::clear_block_num() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_num_ = ::uint64_t{0u}; } inline ::uint64_t BorProducersRequest::block_num() const { // @@protoc_insertion_point(field_get:remote.BorProducersRequest.block_num) return _internal_block_num(); } inline void BorProducersRequest::set_block_num(::uint64_t value) { _internal_set_block_num(value); // @@protoc_insertion_point(field_set:remote.BorProducersRequest.block_num) } inline ::uint64_t BorProducersRequest::_internal_block_num() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_num_; } inline void BorProducersRequest::_internal_set_block_num(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_num_ = value; } // ------------------------------------------------------------------- // BorProducersResponse // .remote.Validator proposer = 1; inline bool BorProducersResponse::has_proposer() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.proposer_ != nullptr); return value; } inline void BorProducersResponse::clear_proposer() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.proposer_ != nullptr) _impl_.proposer_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::remote::Validator& BorProducersResponse::_internal_proposer() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::remote::Validator* p = _impl_.proposer_; return p != nullptr ? *p : reinterpret_cast(::remote::_Validator_default_instance_); } inline const ::remote::Validator& BorProducersResponse::proposer() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BorProducersResponse.proposer) return _internal_proposer(); } inline void BorProducersResponse::unsafe_arena_set_allocated_proposer(::remote::Validator* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.proposer_); } _impl_.proposer_ = reinterpret_cast<::remote::Validator*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.BorProducersResponse.proposer) } inline ::remote::Validator* BorProducersResponse::release_proposer() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::remote::Validator* released = _impl_.proposer_; _impl_.proposer_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::remote::Validator* BorProducersResponse::unsafe_arena_release_proposer() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.BorProducersResponse.proposer) _impl_._has_bits_[0] &= ~0x00000001u; ::remote::Validator* temp = _impl_.proposer_; _impl_.proposer_ = nullptr; return temp; } inline ::remote::Validator* BorProducersResponse::_internal_mutable_proposer() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.proposer_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::remote::Validator>(GetArena()); _impl_.proposer_ = reinterpret_cast<::remote::Validator*>(p); } return _impl_.proposer_; } inline ::remote::Validator* BorProducersResponse::mutable_proposer() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::remote::Validator* _msg = _internal_mutable_proposer(); // @@protoc_insertion_point(field_mutable:remote.BorProducersResponse.proposer) return _msg; } inline void BorProducersResponse::set_allocated_proposer(::remote::Validator* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.proposer_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.proposer_ = reinterpret_cast<::remote::Validator*>(value); // @@protoc_insertion_point(field_set_allocated:remote.BorProducersResponse.proposer) } // repeated .remote.Validator validators = 2; inline int BorProducersResponse::_internal_validators_size() const { return _internal_validators().size(); } inline int BorProducersResponse::validators_size() const { return _internal_validators_size(); } inline void BorProducersResponse::clear_validators() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validators_.Clear(); } inline ::remote::Validator* BorProducersResponse::mutable_validators(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.BorProducersResponse.validators) return _internal_mutable_validators()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::remote::Validator>* BorProducersResponse::mutable_validators() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.BorProducersResponse.validators) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_validators(); } inline const ::remote::Validator& BorProducersResponse::validators(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BorProducersResponse.validators) return _internal_validators().Get(index); } inline ::remote::Validator* BorProducersResponse::add_validators() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::remote::Validator* _add = _internal_mutable_validators()->Add(); // @@protoc_insertion_point(field_add:remote.BorProducersResponse.validators) return _add; } inline const ::google::protobuf::RepeatedPtrField<::remote::Validator>& BorProducersResponse::validators() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.BorProducersResponse.validators) return _internal_validators(); } inline const ::google::protobuf::RepeatedPtrField<::remote::Validator>& BorProducersResponse::_internal_validators() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.validators_; } inline ::google::protobuf::RepeatedPtrField<::remote::Validator>* BorProducersResponse::_internal_mutable_validators() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.validators_; } // ------------------------------------------------------------------- // Validator // uint64 id = 1; inline void Validator::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = ::uint64_t{0u}; } inline ::uint64_t Validator::id() const { // @@protoc_insertion_point(field_get:remote.Validator.id) return _internal_id(); } inline void Validator::set_id(::uint64_t value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:remote.Validator.id) } inline ::uint64_t Validator::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_; } inline void Validator::_internal_set_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = value; } // .types.H160 address = 2; inline bool Validator::has_address() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); return value; } inline const ::types::H160& Validator::_internal_address() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.address_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& Validator::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Validator.address) return _internal_address(); } inline void Validator::unsafe_arena_set_allocated_address(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } _impl_.address_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.Validator.address) } inline ::types::H160* Validator::release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.address_; _impl_.address_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* Validator::unsafe_arena_release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.Validator.address) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.address_; _impl_.address_ = nullptr; return temp; } inline ::types::H160* Validator::_internal_mutable_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.address_ = reinterpret_cast<::types::H160*>(p); } return _impl_.address_; } inline ::types::H160* Validator::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_address(); // @@protoc_insertion_point(field_mutable:remote.Validator.address) return _msg; } inline void Validator::set_allocated_address(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.address_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:remote.Validator.address) } // int64 voting_power = 3; inline void Validator::clear_voting_power() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.voting_power_ = ::int64_t{0}; } inline ::int64_t Validator::voting_power() const { // @@protoc_insertion_point(field_get:remote.Validator.voting_power) return _internal_voting_power(); } inline void Validator::set_voting_power(::int64_t value) { _internal_set_voting_power(value); // @@protoc_insertion_point(field_set:remote.Validator.voting_power) } inline ::int64_t Validator::_internal_voting_power() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.voting_power_; } inline void Validator::_internal_set_voting_power(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.voting_power_ = value; } // int64 proposer_priority = 4; inline void Validator::clear_proposer_priority() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.proposer_priority_ = ::int64_t{0}; } inline ::int64_t Validator::proposer_priority() const { // @@protoc_insertion_point(field_get:remote.Validator.proposer_priority) return _internal_proposer_priority(); } inline void Validator::set_proposer_priority(::int64_t value) { _internal_set_proposer_priority(value); // @@protoc_insertion_point(field_set:remote.Validator.proposer_priority) } inline ::int64_t Validator::_internal_proposer_priority() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.proposer_priority_; } inline void Validator::_internal_set_proposer_priority(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.proposer_priority_ = value; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace remote // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_remote_2fbor_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/27.0/remote/bor_mock.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/bor.proto #ifndef GRPC_MOCK_remote_2fbor_2eproto__INCLUDED #define GRPC_MOCK_remote_2fbor_2eproto__INCLUDED #include "remote/bor.pb.h" #include "remote/bor.grpc.pb.h" #include #include #include namespace remote { class MockBridgeBackendStub : public BridgeBackend::StubInterface { public: MOCK_METHOD3(Version, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response)); MOCK_METHOD3(AsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(BorTxnLookup, ::grpc::Status(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response)); MOCK_METHOD3(AsyncBorTxnLookupRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>*(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncBorTxnLookupRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>*(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(BorEvents, ::grpc::Status(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response)); MOCK_METHOD3(AsyncBorEventsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>*(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncBorEventsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>*(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq)); }; class MockHeimdallBackendStub : public HeimdallBackend::StubInterface { public: MOCK_METHOD3(Version, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response)); MOCK_METHOD3(AsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Producers, ::grpc::Status(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::remote::BorProducersResponse* response)); MOCK_METHOD3(AsyncProducersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>*(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncProducersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorProducersResponse>*(::grpc::ClientContext* context, const ::remote::BorProducersRequest& request, ::grpc::CompletionQueue* cq)); }; } // namespace remote #endif // GRPC_MOCK_remote_2fbor_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/remote/ethbackend.grpc.pb.cc ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/ethbackend.proto #include "remote/ethbackend.pb.h" #include "remote/ethbackend.grpc.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace remote { static const char* ETHBACKEND_method_names[] = { "/remote.ETHBACKEND/Etherbase", "/remote.ETHBACKEND/NetVersion", "/remote.ETHBACKEND/NetPeerCount", "/remote.ETHBACKEND/Version", "/remote.ETHBACKEND/Syncing", "/remote.ETHBACKEND/ProtocolVersion", "/remote.ETHBACKEND/ClientVersion", "/remote.ETHBACKEND/Subscribe", "/remote.ETHBACKEND/SubscribeLogs", "/remote.ETHBACKEND/Block", "/remote.ETHBACKEND/CanonicalBodyForStorage", "/remote.ETHBACKEND/CanonicalHash", "/remote.ETHBACKEND/HeaderNumber", "/remote.ETHBACKEND/TxnLookup", "/remote.ETHBACKEND/NodeInfo", "/remote.ETHBACKEND/Peers", "/remote.ETHBACKEND/AddPeer", "/remote.ETHBACKEND/PendingBlock", "/remote.ETHBACKEND/BorTxnLookup", "/remote.ETHBACKEND/BorEvents", }; std::unique_ptr< ETHBACKEND::Stub> ETHBACKEND::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< ETHBACKEND::Stub> stub(new ETHBACKEND::Stub(channel, options)); return stub; } ETHBACKEND::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_Etherbase_(ETHBACKEND_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_NetVersion_(ETHBACKEND_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_NetPeerCount_(ETHBACKEND_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Version_(ETHBACKEND_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Syncing_(ETHBACKEND_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_ProtocolVersion_(ETHBACKEND_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_ClientVersion_(ETHBACKEND_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Subscribe_(ETHBACKEND_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_SubscribeLogs_(ETHBACKEND_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) , rpcmethod_Block_(ETHBACKEND_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_CanonicalBodyForStorage_(ETHBACKEND_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_CanonicalHash_(ETHBACKEND_method_names[11], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_HeaderNumber_(ETHBACKEND_method_names[12], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_TxnLookup_(ETHBACKEND_method_names[13], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_NodeInfo_(ETHBACKEND_method_names[14], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Peers_(ETHBACKEND_method_names[15], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_AddPeer_(ETHBACKEND_method_names[16], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PendingBlock_(ETHBACKEND_method_names[17], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_BorTxnLookup_(ETHBACKEND_method_names[18], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_BorEvents_(ETHBACKEND_method_names[19], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status ETHBACKEND::Stub::Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::remote::EtherbaseReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::EtherbaseRequest, ::remote::EtherbaseReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Etherbase_, context, request, response); } void ETHBACKEND::Stub::async::Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::EtherbaseRequest, ::remote::EtherbaseReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Etherbase_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Etherbase_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>* ETHBACKEND::Stub::PrepareAsyncEtherbaseRaw(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::EtherbaseReply, ::remote::EtherbaseRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Etherbase_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>* ETHBACKEND::Stub::AsyncEtherbaseRaw(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncEtherbaseRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::remote::NetVersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::NetVersionRequest, ::remote::NetVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_NetVersion_, context, request, response); } void ETHBACKEND::Stub::async::NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::NetVersionRequest, ::remote::NetVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NetVersion_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NetVersion_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>* ETHBACKEND::Stub::PrepareAsyncNetVersionRaw(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::NetVersionReply, ::remote::NetVersionRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_NetVersion_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>* ETHBACKEND::Stub::AsyncNetVersionRaw(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncNetVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::remote::NetPeerCountReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_NetPeerCount_, context, request, response); } void ETHBACKEND::Stub::async::NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NetPeerCount_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NetPeerCount_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>* ETHBACKEND::Stub::PrepareAsyncNetPeerCountRaw(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::NetPeerCountReply, ::remote::NetPeerCountRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_NetPeerCount_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>* ETHBACKEND::Stub::AsyncNetPeerCountRaw(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncNetPeerCountRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Version_, context, request, response); } void ETHBACKEND::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* ETHBACKEND::Stub::PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::types::VersionReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Version_, context, request); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* ETHBACKEND::Stub::AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::SyncingReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::remote::SyncingReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Syncing_, context, request, response); } void ETHBACKEND::Stub::async::Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::remote::SyncingReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Syncing_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Syncing_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>* ETHBACKEND::Stub::PrepareAsyncSyncingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::SyncingReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Syncing_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>* ETHBACKEND::Stub::AsyncSyncingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSyncingRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::remote::ProtocolVersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ProtocolVersion_, context, request, response); } void ETHBACKEND::Stub::async::ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ProtocolVersion_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ProtocolVersion_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>* ETHBACKEND::Stub::PrepareAsyncProtocolVersionRaw(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::ProtocolVersionReply, ::remote::ProtocolVersionRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ProtocolVersion_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>* ETHBACKEND::Stub::AsyncProtocolVersionRaw(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncProtocolVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::remote::ClientVersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::ClientVersionRequest, ::remote::ClientVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ClientVersion_, context, request, response); } void ETHBACKEND::Stub::async::ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::ClientVersionRequest, ::remote::ClientVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ClientVersion_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ClientVersion_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>* ETHBACKEND::Stub::PrepareAsyncClientVersionRaw(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::ClientVersionReply, ::remote::ClientVersionRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ClientVersion_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>* ETHBACKEND::Stub::AsyncClientVersionRaw(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncClientVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::ClientReader< ::remote::SubscribeReply>* ETHBACKEND::Stub::SubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request) { return ::grpc::internal::ClientReaderFactory< ::remote::SubscribeReply>::Create(channel_.get(), rpcmethod_Subscribe_, context, request); } void ETHBACKEND::Stub::async::Subscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest* request, ::grpc::ClientReadReactor< ::remote::SubscribeReply>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::remote::SubscribeReply>::Create(stub_->channel_.get(), stub_->rpcmethod_Subscribe_, context, request, reactor); } ::grpc::ClientAsyncReader< ::remote::SubscribeReply>* ETHBACKEND::Stub::AsyncSubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::remote::SubscribeReply>::Create(channel_.get(), cq, rpcmethod_Subscribe_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::remote::SubscribeReply>* ETHBACKEND::Stub::PrepareAsyncSubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::remote::SubscribeReply>::Create(channel_.get(), cq, rpcmethod_Subscribe_, context, request, false, nullptr); } ::grpc::ClientReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* ETHBACKEND::Stub::SubscribeLogsRaw(::grpc::ClientContext* context) { return ::grpc::internal::ClientReaderWriterFactory< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>::Create(channel_.get(), rpcmethod_SubscribeLogs_, context); } void ETHBACKEND::Stub::async::SubscribeLogs(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::remote::LogsFilterRequest,::remote::SubscribeLogsReply>* reactor) { ::grpc::internal::ClientCallbackReaderWriterFactory< ::remote::LogsFilterRequest,::remote::SubscribeLogsReply>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeLogs_, context, reactor); } ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* ETHBACKEND::Stub::AsyncSubscribeLogsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderWriterFactory< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>::Create(channel_.get(), cq, rpcmethod_SubscribeLogs_, context, true, tag); } ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* ETHBACKEND::Stub::PrepareAsyncSubscribeLogsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderWriterFactory< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>::Create(channel_.get(), cq, rpcmethod_SubscribeLogs_, context, false, nullptr); } ::grpc::Status ETHBACKEND::Stub::Block(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::remote::BlockReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::BlockRequest, ::remote::BlockReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Block_, context, request, response); } void ETHBACKEND::Stub::async::Block(::grpc::ClientContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::BlockRequest, ::remote::BlockReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Block_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::Block(::grpc::ClientContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Block_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>* ETHBACKEND::Stub::PrepareAsyncBlockRaw(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::BlockReply, ::remote::BlockRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Block_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>* ETHBACKEND::Stub::AsyncBlockRaw(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncBlockRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::remote::CanonicalBodyForStorageReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CanonicalBodyForStorage_, context, request, response); } void ETHBACKEND::Stub::async::CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CanonicalBodyForStorage_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CanonicalBodyForStorage_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>* ETHBACKEND::Stub::PrepareAsyncCanonicalBodyForStorageRaw(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::CanonicalBodyForStorageReply, ::remote::CanonicalBodyForStorageRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CanonicalBodyForStorage_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>* ETHBACKEND::Stub::AsyncCanonicalBodyForStorageRaw(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncCanonicalBodyForStorageRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::remote::CanonicalHashReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CanonicalHash_, context, request, response); } void ETHBACKEND::Stub::async::CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CanonicalHash_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CanonicalHash_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>* ETHBACKEND::Stub::PrepareAsyncCanonicalHashRaw(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::CanonicalHashReply, ::remote::CanonicalHashRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CanonicalHash_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>* ETHBACKEND::Stub::AsyncCanonicalHashRaw(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncCanonicalHashRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::remote::HeaderNumberReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HeaderNumber_, context, request, response); } void ETHBACKEND::Stub::async::HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HeaderNumber_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HeaderNumber_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>* ETHBACKEND::Stub::PrepareAsyncHeaderNumberRaw(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::HeaderNumberReply, ::remote::HeaderNumberRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HeaderNumber_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>* ETHBACKEND::Stub::AsyncHeaderNumberRaw(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncHeaderNumberRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::remote::TxnLookupReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::TxnLookupRequest, ::remote::TxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_TxnLookup_, context, request, response); } void ETHBACKEND::Stub::async::TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::TxnLookupRequest, ::remote::TxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_TxnLookup_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_TxnLookup_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>* ETHBACKEND::Stub::PrepareAsyncTxnLookupRaw(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::TxnLookupReply, ::remote::TxnLookupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_TxnLookup_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>* ETHBACKEND::Stub::AsyncTxnLookupRaw(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncTxnLookupRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::remote::NodesInfoReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::NodesInfoRequest, ::remote::NodesInfoReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_NodeInfo_, context, request, response); } void ETHBACKEND::Stub::async::NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::NodesInfoRequest, ::remote::NodesInfoReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NodeInfo_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_NodeInfo_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>* ETHBACKEND::Stub::PrepareAsyncNodeInfoRaw(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::NodesInfoReply, ::remote::NodesInfoRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_NodeInfo_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>* ETHBACKEND::Stub::AsyncNodeInfoRaw(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncNodeInfoRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PeersReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::remote::PeersReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Peers_, context, request, response); } void ETHBACKEND::Stub::async::Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::remote::PeersReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Peers_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Peers_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>* ETHBACKEND::Stub::PrepareAsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::PeersReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Peers_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>* ETHBACKEND::Stub::AsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPeersRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::remote::AddPeerReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::AddPeerRequest, ::remote::AddPeerReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddPeer_, context, request, response); } void ETHBACKEND::Stub::async::AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::AddPeerRequest, ::remote::AddPeerReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeer_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeer_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>* ETHBACKEND::Stub::PrepareAsyncAddPeerRaw(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::AddPeerReply, ::remote::AddPeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddPeer_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>* ETHBACKEND::Stub::AsyncAddPeerRaw(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncAddPeerRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PendingBlockReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::remote::PendingBlockReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PendingBlock_, context, request, response); } void ETHBACKEND::Stub::async::PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::remote::PendingBlockReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PendingBlock_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PendingBlock_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>* ETHBACKEND::Stub::PrepareAsyncPendingBlockRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::PendingBlockReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PendingBlock_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>* ETHBACKEND::Stub::AsyncPendingBlockRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPendingBlockRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BorTxnLookup_, context, request, response); } void ETHBACKEND::Stub::async::BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorTxnLookup_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorTxnLookup_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* ETHBACKEND::Stub::PrepareAsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::BorTxnLookupReply, ::remote::BorTxnLookupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BorTxnLookup_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* ETHBACKEND::Stub::AsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncBorTxnLookupRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status ETHBACKEND::Stub::BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::BorEventsRequest, ::remote::BorEventsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_BorEvents_, context, request, response); } void ETHBACKEND::Stub::async::BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::BorEventsRequest, ::remote::BorEventsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorEvents_, context, request, response, std::move(f)); } void ETHBACKEND::Stub::async::BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_BorEvents_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* ETHBACKEND::Stub::PrepareAsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::BorEventsReply, ::remote::BorEventsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_BorEvents_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* ETHBACKEND::Stub::AsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncBorEventsRaw(context, request, cq); result->StartCall(); return result; } ETHBACKEND::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::EtherbaseRequest, ::remote::EtherbaseReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::EtherbaseRequest* req, ::remote::EtherbaseReply* resp) { return service->Etherbase(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::NetVersionRequest, ::remote::NetVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::NetVersionRequest* req, ::remote::NetVersionReply* resp) { return service->NetVersion(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::NetPeerCountRequest* req, ::remote::NetPeerCountReply* resp) { return service->NetPeerCount(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::types::VersionReply* resp) { return service->Version(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::google::protobuf::Empty, ::remote::SyncingReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::remote::SyncingReply* resp) { return service->Syncing(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::ProtocolVersionRequest* req, ::remote::ProtocolVersionReply* resp) { return service->ProtocolVersion(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::ClientVersionRequest, ::remote::ClientVersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::ClientVersionRequest* req, ::remote::ClientVersionReply* resp) { return service->ClientVersion(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[7], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< ETHBACKEND::Service, ::remote::SubscribeRequest, ::remote::SubscribeReply>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::SubscribeRequest* req, ::grpc::ServerWriter<::remote::SubscribeReply>* writer) { return service->Subscribe(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[8], ::grpc::internal::RpcMethod::BIDI_STREAMING, new ::grpc::internal::BidiStreamingHandler< ETHBACKEND::Service, ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, ::grpc::ServerReaderWriter<::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* stream) { return service->SubscribeLogs(ctx, stream); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::BlockRequest, ::remote::BlockReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::BlockRequest* req, ::remote::BlockReply* resp) { return service->Block(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[10], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::CanonicalBodyForStorageRequest* req, ::remote::CanonicalBodyForStorageReply* resp) { return service->CanonicalBodyForStorage(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::CanonicalHashRequest* req, ::remote::CanonicalHashReply* resp) { return service->CanonicalHash(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[12], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::HeaderNumberRequest* req, ::remote::HeaderNumberReply* resp) { return service->HeaderNumber(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[13], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::TxnLookupRequest, ::remote::TxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::TxnLookupRequest* req, ::remote::TxnLookupReply* resp) { return service->TxnLookup(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[14], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::NodesInfoRequest, ::remote::NodesInfoReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::NodesInfoRequest* req, ::remote::NodesInfoReply* resp) { return service->NodeInfo(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[15], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::google::protobuf::Empty, ::remote::PeersReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::remote::PeersReply* resp) { return service->Peers(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[16], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::AddPeerRequest, ::remote::AddPeerReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::AddPeerRequest* req, ::remote::AddPeerReply* resp) { return service->AddPeer(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[17], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::google::protobuf::Empty, ::remote::PendingBlockReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::remote::PendingBlockReply* resp) { return service->PendingBlock(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[18], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::BorTxnLookupRequest* req, ::remote::BorTxnLookupReply* resp) { return service->BorTxnLookup(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( ETHBACKEND_method_names[19], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< ETHBACKEND::Service, ::remote::BorEventsRequest, ::remote::BorEventsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](ETHBACKEND::Service* service, ::grpc::ServerContext* ctx, const ::remote::BorEventsRequest* req, ::remote::BorEventsReply* resp) { return service->BorEvents(ctx, req, resp); }, this))); } ETHBACKEND::Service::~Service() { } ::grpc::Status ETHBACKEND::Service::Etherbase(::grpc::ServerContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::NetVersion(::grpc::ServerContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::NetPeerCount(::grpc::ServerContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::Syncing(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::ProtocolVersion(::grpc::ServerContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::ClientVersion(::grpc::ServerContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::Subscribe(::grpc::ServerContext* context, const ::remote::SubscribeRequest* request, ::grpc::ServerWriter< ::remote::SubscribeReply>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::SubscribeLogs(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* stream) { (void) context; (void) stream; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::Block(::grpc::ServerContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::CanonicalBodyForStorage(::grpc::ServerContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::CanonicalHash(::grpc::ServerContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::HeaderNumber(::grpc::ServerContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::TxnLookup(::grpc::ServerContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::NodeInfo(::grpc::ServerContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::Peers(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::AddPeer(::grpc::ServerContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::PendingBlock(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::BorTxnLookup(::grpc::ServerContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status ETHBACKEND::Service::BorEvents(::grpc::ServerContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } } // namespace remote ================================================ FILE: silkworm/interfaces/27.0/remote/ethbackend.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/ethbackend.proto #ifndef GRPC_remote_2fethbackend_2eproto__INCLUDED #define GRPC_remote_2fethbackend_2eproto__INCLUDED #include "remote/ethbackend.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace remote { class ETHBACKEND final { public: static constexpr char const* service_full_name() { return "remote.ETHBACKEND"; } class StubInterface { public: virtual ~StubInterface() {} virtual ::grpc::Status Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::remote::EtherbaseReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>> AsyncEtherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>>(AsyncEtherbaseRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>> PrepareAsyncEtherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>>(PrepareAsyncEtherbaseRaw(context, request, cq)); } virtual ::grpc::Status NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::remote::NetVersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>> AsyncNetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>>(AsyncNetVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>> PrepareAsyncNetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>>(PrepareAsyncNetVersionRaw(context, request, cq)); } virtual ::grpc::Status NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::remote::NetPeerCountReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>> AsyncNetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>>(AsyncNetPeerCountRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>> PrepareAsyncNetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>>(PrepareAsyncNetPeerCountRaw(context, request, cq)); } // Version returns the service version number virtual ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } // Syncing returns a data object detailing the status of the sync process virtual ::grpc::Status Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::SyncingReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>> AsyncSyncing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>>(AsyncSyncingRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>> PrepareAsyncSyncing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>>(PrepareAsyncSyncingRaw(context, request, cq)); } // ProtocolVersion returns the Ethereum protocol version number (e.g. 66 for ETH66). virtual ::grpc::Status ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::remote::ProtocolVersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>> AsyncProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>>(AsyncProtocolVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>> PrepareAsyncProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>>(PrepareAsyncProtocolVersionRaw(context, request, cq)); } // ClientVersion returns the Ethereum client version string using node name convention (e.g. TurboGeth/v2021.03.2-alpha/Linux). virtual ::grpc::Status ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::remote::ClientVersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>> AsyncClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>>(AsyncClientVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>> PrepareAsyncClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>>(PrepareAsyncClientVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReaderInterface< ::remote::SubscribeReply>> Subscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::remote::SubscribeReply>>(SubscribeRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>> AsyncSubscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>>(AsyncSubscribeRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>> PrepareAsyncSubscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>>(PrepareAsyncSubscribeRaw(context, request, cq)); } // Only one subscription is needed to serve all the users, LogsFilterRequest allows to dynamically modifying the subscription std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>> SubscribeLogs(::grpc::ClientContext* context) { return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>>(SubscribeLogsRaw(context)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>> AsyncSubscribeLogs(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>>(AsyncSubscribeLogsRaw(context, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>> PrepareAsyncSubscribeLogs(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>>(PrepareAsyncSubscribeLogsRaw(context, cq)); } // High-level method - can read block from db, snapshots or apply any other logic // it doesn't provide consistency // Request fields are optional - it's ok to request block only by hash or only by number virtual ::grpc::Status Block(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::remote::BlockReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>> AsyncBlock(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>>(AsyncBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>> PrepareAsyncBlock(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>>(PrepareAsyncBlockRaw(context, request, cq)); } // High-level method - can read block body (only storage metadata) from db, snapshots or apply any other logic virtual ::grpc::Status CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::remote::CanonicalBodyForStorageReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>> AsyncCanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>>(AsyncCanonicalBodyForStorageRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>> PrepareAsyncCanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>>(PrepareAsyncCanonicalBodyForStorageRaw(context, request, cq)); } // High-level method - can find block hash by block number virtual ::grpc::Status CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::remote::CanonicalHashReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>> AsyncCanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>>(AsyncCanonicalHashRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>> PrepareAsyncCanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>>(PrepareAsyncCanonicalHashRaw(context, request, cq)); } // High-level method - can find block number by block hash virtual ::grpc::Status HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::remote::HeaderNumberReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>> AsyncHeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>>(AsyncHeaderNumberRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>> PrepareAsyncHeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>>(PrepareAsyncHeaderNumberRaw(context, request, cq)); } // High-level method - can find block number by txn hash // it doesn't provide consistency virtual ::grpc::Status TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::remote::TxnLookupReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>> AsyncTxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>>(AsyncTxnLookupRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>> PrepareAsyncTxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>>(PrepareAsyncTxnLookupRaw(context, request, cq)); } // NodeInfo collects and returns NodeInfo from all running sentry instances. virtual ::grpc::Status NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::remote::NodesInfoReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>> AsyncNodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>>(AsyncNodeInfoRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>> PrepareAsyncNodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>>(PrepareAsyncNodeInfoRaw(context, request, cq)); } // Peers collects and returns peers information from all running sentry instances. virtual ::grpc::Status Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PeersReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>> AsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>>(AsyncPeersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>> PrepareAsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>>(PrepareAsyncPeersRaw(context, request, cq)); } virtual ::grpc::Status AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::remote::AddPeerReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>> AsyncAddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>>(AsyncAddPeerRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>> PrepareAsyncAddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>>(PrepareAsyncAddPeerRaw(context, request, cq)); } // PendingBlock returns latest built block. virtual ::grpc::Status PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PendingBlockReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>> AsyncPendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>>(AsyncPendingBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>> PrepareAsyncPendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>>(PrepareAsyncPendingBlockRaw(context, request, cq)); } virtual ::grpc::Status BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>> AsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>>(AsyncBorTxnLookupRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>> PrepareAsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>>(PrepareAsyncBorTxnLookupRaw(context, request, cq)); } virtual ::grpc::Status BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>> AsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>>(AsyncBorEventsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>> PrepareAsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>>(PrepareAsyncBorEventsRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} virtual void Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response, std::function) = 0; virtual void Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response, std::function) = 0; virtual void NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response, std::function) = 0; virtual void NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Version returns the service version number virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) = 0; virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Syncing returns a data object detailing the status of the sync process virtual void Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response, std::function) = 0; virtual void Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // ProtocolVersion returns the Ethereum protocol version number (e.g. 66 for ETH66). virtual void ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response, std::function) = 0; virtual void ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // ClientVersion returns the Ethereum client version string using node name convention (e.g. TurboGeth/v2021.03.2-alpha/Linux). virtual void ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response, std::function) = 0; virtual void ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void Subscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest* request, ::grpc::ClientReadReactor< ::remote::SubscribeReply>* reactor) = 0; // Only one subscription is needed to serve all the users, LogsFilterRequest allows to dynamically modifying the subscription virtual void SubscribeLogs(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::remote::LogsFilterRequest,::remote::SubscribeLogsReply>* reactor) = 0; // High-level method - can read block from db, snapshots or apply any other logic // it doesn't provide consistency // Request fields are optional - it's ok to request block only by hash or only by number virtual void Block(::grpc::ClientContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response, std::function) = 0; virtual void Block(::grpc::ClientContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // High-level method - can read block body (only storage metadata) from db, snapshots or apply any other logic virtual void CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response, std::function) = 0; virtual void CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // High-level method - can find block hash by block number virtual void CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response, std::function) = 0; virtual void CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // High-level method - can find block number by block hash virtual void HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response, std::function) = 0; virtual void HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // High-level method - can find block number by txn hash // it doesn't provide consistency virtual void TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response, std::function) = 0; virtual void TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // NodeInfo collects and returns NodeInfo from all running sentry instances. virtual void NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response, std::function) = 0; virtual void NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Peers collects and returns peers information from all running sentry instances. virtual void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response, std::function) = 0; virtual void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response, std::function) = 0; virtual void AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // PendingBlock returns latest built block. virtual void PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response, std::function) = 0; virtual void PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, std::function) = 0; virtual void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, std::function) = 0; virtual void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>* AsyncEtherbaseRaw(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>* PrepareAsyncEtherbaseRaw(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>* AsyncNetVersionRaw(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>* PrepareAsyncNetVersionRaw(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>* AsyncNetPeerCountRaw(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>* PrepareAsyncNetPeerCountRaw(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>* AsyncSyncingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>* PrepareAsyncSyncingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>* AsyncProtocolVersionRaw(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>* PrepareAsyncProtocolVersionRaw(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>* AsyncClientVersionRaw(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>* PrepareAsyncClientVersionRaw(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::remote::SubscribeReply>* SubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>* AsyncSubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>* PrepareAsyncSubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* SubscribeLogsRaw(::grpc::ClientContext* context) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* AsyncSubscribeLogsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* PrepareAsyncSubscribeLogsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>* AsyncBlockRaw(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>* PrepareAsyncBlockRaw(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>* AsyncCanonicalBodyForStorageRaw(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>* PrepareAsyncCanonicalBodyForStorageRaw(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>* AsyncCanonicalHashRaw(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>* PrepareAsyncCanonicalHashRaw(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>* AsyncHeaderNumberRaw(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>* PrepareAsyncHeaderNumberRaw(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>* AsyncTxnLookupRaw(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>* PrepareAsyncTxnLookupRaw(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>* AsyncNodeInfoRaw(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>* PrepareAsyncNodeInfoRaw(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>* AsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>* PrepareAsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>* AsyncAddPeerRaw(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>* PrepareAsyncAddPeerRaw(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>* AsyncPendingBlockRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>* PrepareAsyncPendingBlockRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>* AsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>* PrepareAsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>* AsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>* PrepareAsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::remote::EtherbaseReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>> AsyncEtherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>>(AsyncEtherbaseRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>> PrepareAsyncEtherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>>(PrepareAsyncEtherbaseRaw(context, request, cq)); } ::grpc::Status NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::remote::NetVersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>> AsyncNetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>>(AsyncNetVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>> PrepareAsyncNetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>>(PrepareAsyncNetVersionRaw(context, request, cq)); } ::grpc::Status NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::remote::NetPeerCountReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>> AsyncNetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>>(AsyncNetPeerCountRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>> PrepareAsyncNetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>>(PrepareAsyncNetPeerCountRaw(context, request, cq)); } ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } ::grpc::Status Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::SyncingReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>> AsyncSyncing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>>(AsyncSyncingRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>> PrepareAsyncSyncing(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>>(PrepareAsyncSyncingRaw(context, request, cq)); } ::grpc::Status ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::remote::ProtocolVersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>> AsyncProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>>(AsyncProtocolVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>> PrepareAsyncProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>>(PrepareAsyncProtocolVersionRaw(context, request, cq)); } ::grpc::Status ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::remote::ClientVersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>> AsyncClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>>(AsyncClientVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>> PrepareAsyncClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>>(PrepareAsyncClientVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::remote::SubscribeReply>> Subscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::remote::SubscribeReply>>(SubscribeRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::SubscribeReply>> AsyncSubscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::SubscribeReply>>(AsyncSubscribeRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::SubscribeReply>> PrepareAsyncSubscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::SubscribeReply>>(PrepareAsyncSubscribeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>> SubscribeLogs(::grpc::ClientContext* context) { return std::unique_ptr< ::grpc::ClientReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>>(SubscribeLogsRaw(context)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>> AsyncSubscribeLogs(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>>(AsyncSubscribeLogsRaw(context, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>> PrepareAsyncSubscribeLogs(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>>(PrepareAsyncSubscribeLogsRaw(context, cq)); } ::grpc::Status Block(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::remote::BlockReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>> AsyncBlock(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>>(AsyncBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>> PrepareAsyncBlock(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>>(PrepareAsyncBlockRaw(context, request, cq)); } ::grpc::Status CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::remote::CanonicalBodyForStorageReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>> AsyncCanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>>(AsyncCanonicalBodyForStorageRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>> PrepareAsyncCanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>>(PrepareAsyncCanonicalBodyForStorageRaw(context, request, cq)); } ::grpc::Status CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::remote::CanonicalHashReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>> AsyncCanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>>(AsyncCanonicalHashRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>> PrepareAsyncCanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>>(PrepareAsyncCanonicalHashRaw(context, request, cq)); } ::grpc::Status HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::remote::HeaderNumberReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>> AsyncHeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>>(AsyncHeaderNumberRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>> PrepareAsyncHeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>>(PrepareAsyncHeaderNumberRaw(context, request, cq)); } ::grpc::Status TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::remote::TxnLookupReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>> AsyncTxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>>(AsyncTxnLookupRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>> PrepareAsyncTxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>>(PrepareAsyncTxnLookupRaw(context, request, cq)); } ::grpc::Status NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::remote::NodesInfoReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>> AsyncNodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>>(AsyncNodeInfoRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>> PrepareAsyncNodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>>(PrepareAsyncNodeInfoRaw(context, request, cq)); } ::grpc::Status Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PeersReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>> AsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>>(AsyncPeersRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>> PrepareAsyncPeers(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>>(PrepareAsyncPeersRaw(context, request, cq)); } ::grpc::Status AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::remote::AddPeerReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>> AsyncAddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>>(AsyncAddPeerRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>> PrepareAsyncAddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>>(PrepareAsyncAddPeerRaw(context, request, cq)); } ::grpc::Status PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PendingBlockReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>> AsyncPendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>>(AsyncPendingBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>> PrepareAsyncPendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>>(PrepareAsyncPendingBlockRaw(context, request, cq)); } ::grpc::Status BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>> AsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>>(AsyncBorTxnLookupRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>> PrepareAsyncBorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>>(PrepareAsyncBorTxnLookupRaw(context, request, cq)); } ::grpc::Status BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>> AsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>>(AsyncBorEventsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>> PrepareAsyncBorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>>(PrepareAsyncBorEventsRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response, std::function) override; void Etherbase(::grpc::ClientContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response, ::grpc::ClientUnaryReactor* reactor) override; void NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response, std::function) override; void NetVersion(::grpc::ClientContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response, std::function) override; void NetPeerCount(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) override; void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response, std::function) override; void Syncing(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response, ::grpc::ClientUnaryReactor* reactor) override; void ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response, std::function) override; void ProtocolVersion(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response, std::function) override; void ClientVersion(::grpc::ClientContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Subscribe(::grpc::ClientContext* context, const ::remote::SubscribeRequest* request, ::grpc::ClientReadReactor< ::remote::SubscribeReply>* reactor) override; void SubscribeLogs(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::remote::LogsFilterRequest,::remote::SubscribeLogsReply>* reactor) override; void Block(::grpc::ClientContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response, std::function) override; void Block(::grpc::ClientContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response, ::grpc::ClientUnaryReactor* reactor) override; void CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response, std::function) override; void CanonicalBodyForStorage(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response, ::grpc::ClientUnaryReactor* reactor) override; void CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response, std::function) override; void CanonicalHash(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response, ::grpc::ClientUnaryReactor* reactor) override; void HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response, std::function) override; void HeaderNumber(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response, ::grpc::ClientUnaryReactor* reactor) override; void TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response, std::function) override; void TxnLookup(::grpc::ClientContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) override; void NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response, std::function) override; void NodeInfo(::grpc::ClientContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response, std::function) override; void Peers(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response, ::grpc::ClientUnaryReactor* reactor) override; void AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response, std::function) override; void AddPeer(::grpc::ClientContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response, ::grpc::ClientUnaryReactor* reactor) override; void PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response, std::function) override; void PendingBlock(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response, ::grpc::ClientUnaryReactor* reactor) override; void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, std::function) override; void BorTxnLookup(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response, ::grpc::ClientUnaryReactor* reactor) override; void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, std::function) override; void BorEvents(::grpc::ClientContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>* AsyncEtherbaseRaw(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::EtherbaseReply>* PrepareAsyncEtherbaseRaw(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>* AsyncNetVersionRaw(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::NetVersionReply>* PrepareAsyncNetVersionRaw(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>* AsyncNetPeerCountRaw(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::NetPeerCountReply>* PrepareAsyncNetPeerCountRaw(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>* AsyncSyncingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::SyncingReply>* PrepareAsyncSyncingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>* AsyncProtocolVersionRaw(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::ProtocolVersionReply>* PrepareAsyncProtocolVersionRaw(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>* AsyncClientVersionRaw(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::ClientVersionReply>* PrepareAsyncClientVersionRaw(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::remote::SubscribeReply>* SubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request) override; ::grpc::ClientAsyncReader< ::remote::SubscribeReply>* AsyncSubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::remote::SubscribeReply>* PrepareAsyncSubscribeRaw(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* SubscribeLogsRaw(::grpc::ClientContext* context) override; ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* AsyncSubscribeLogsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReaderWriter< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* PrepareAsyncSubscribeLogsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>* AsyncBlockRaw(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BlockReply>* PrepareAsyncBlockRaw(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>* AsyncCanonicalBodyForStorageRaw(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::CanonicalBodyForStorageReply>* PrepareAsyncCanonicalBodyForStorageRaw(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>* AsyncCanonicalHashRaw(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::CanonicalHashReply>* PrepareAsyncCanonicalHashRaw(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>* AsyncHeaderNumberRaw(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::HeaderNumberReply>* PrepareAsyncHeaderNumberRaw(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>* AsyncTxnLookupRaw(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::TxnLookupReply>* PrepareAsyncTxnLookupRaw(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>* AsyncNodeInfoRaw(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::NodesInfoReply>* PrepareAsyncNodeInfoRaw(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>* AsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::PeersReply>* PrepareAsyncPeersRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>* AsyncAddPeerRaw(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::AddPeerReply>* PrepareAsyncAddPeerRaw(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>* AsyncPendingBlockRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::PendingBlockReply>* PrepareAsyncPendingBlockRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* AsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorTxnLookupReply>* PrepareAsyncBorTxnLookupRaw(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* AsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::BorEventsReply>* PrepareAsyncBorEventsRaw(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_Etherbase_; const ::grpc::internal::RpcMethod rpcmethod_NetVersion_; const ::grpc::internal::RpcMethod rpcmethod_NetPeerCount_; const ::grpc::internal::RpcMethod rpcmethod_Version_; const ::grpc::internal::RpcMethod rpcmethod_Syncing_; const ::grpc::internal::RpcMethod rpcmethod_ProtocolVersion_; const ::grpc::internal::RpcMethod rpcmethod_ClientVersion_; const ::grpc::internal::RpcMethod rpcmethod_Subscribe_; const ::grpc::internal::RpcMethod rpcmethod_SubscribeLogs_; const ::grpc::internal::RpcMethod rpcmethod_Block_; const ::grpc::internal::RpcMethod rpcmethod_CanonicalBodyForStorage_; const ::grpc::internal::RpcMethod rpcmethod_CanonicalHash_; const ::grpc::internal::RpcMethod rpcmethod_HeaderNumber_; const ::grpc::internal::RpcMethod rpcmethod_TxnLookup_; const ::grpc::internal::RpcMethod rpcmethod_NodeInfo_; const ::grpc::internal::RpcMethod rpcmethod_Peers_; const ::grpc::internal::RpcMethod rpcmethod_AddPeer_; const ::grpc::internal::RpcMethod rpcmethod_PendingBlock_; const ::grpc::internal::RpcMethod rpcmethod_BorTxnLookup_; const ::grpc::internal::RpcMethod rpcmethod_BorEvents_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); virtual ::grpc::Status Etherbase(::grpc::ServerContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response); virtual ::grpc::Status NetVersion(::grpc::ServerContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response); virtual ::grpc::Status NetPeerCount(::grpc::ServerContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response); // Version returns the service version number virtual ::grpc::Status Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response); // Syncing returns a data object detailing the status of the sync process virtual ::grpc::Status Syncing(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response); // ProtocolVersion returns the Ethereum protocol version number (e.g. 66 for ETH66). virtual ::grpc::Status ProtocolVersion(::grpc::ServerContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response); // ClientVersion returns the Ethereum client version string using node name convention (e.g. TurboGeth/v2021.03.2-alpha/Linux). virtual ::grpc::Status ClientVersion(::grpc::ServerContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response); virtual ::grpc::Status Subscribe(::grpc::ServerContext* context, const ::remote::SubscribeRequest* request, ::grpc::ServerWriter< ::remote::SubscribeReply>* writer); // Only one subscription is needed to serve all the users, LogsFilterRequest allows to dynamically modifying the subscription virtual ::grpc::Status SubscribeLogs(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* stream); // High-level method - can read block from db, snapshots or apply any other logic // it doesn't provide consistency // Request fields are optional - it's ok to request block only by hash or only by number virtual ::grpc::Status Block(::grpc::ServerContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response); // High-level method - can read block body (only storage metadata) from db, snapshots or apply any other logic virtual ::grpc::Status CanonicalBodyForStorage(::grpc::ServerContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response); // High-level method - can find block hash by block number virtual ::grpc::Status CanonicalHash(::grpc::ServerContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response); // High-level method - can find block number by block hash virtual ::grpc::Status HeaderNumber(::grpc::ServerContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response); // High-level method - can find block number by txn hash // it doesn't provide consistency virtual ::grpc::Status TxnLookup(::grpc::ServerContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response); // NodeInfo collects and returns NodeInfo from all running sentry instances. virtual ::grpc::Status NodeInfo(::grpc::ServerContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response); // Peers collects and returns peers information from all running sentry instances. virtual ::grpc::Status Peers(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response); virtual ::grpc::Status AddPeer(::grpc::ServerContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response); // PendingBlock returns latest built block. virtual ::grpc::Status PendingBlock(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response); virtual ::grpc::Status BorTxnLookup(::grpc::ServerContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response); virtual ::grpc::Status BorEvents(::grpc::ServerContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response); }; template class WithAsyncMethod_Etherbase : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Etherbase() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_Etherbase() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Etherbase(::grpc::ServerContext* /*context*/, const ::remote::EtherbaseRequest* /*request*/, ::remote::EtherbaseReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestEtherbase(::grpc::ServerContext* context, ::remote::EtherbaseRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::EtherbaseReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_NetVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_NetVersion() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_NetVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetVersion(::grpc::ServerContext* /*context*/, const ::remote::NetVersionRequest* /*request*/, ::remote::NetVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNetVersion(::grpc::ServerContext* context, ::remote::NetVersionRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::NetVersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_NetPeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_NetPeerCount() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_NetPeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetPeerCount(::grpc::ServerContext* /*context*/, const ::remote::NetPeerCountRequest* /*request*/, ::remote::NetPeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNetPeerCount(::grpc::ServerContext* context, ::remote::NetPeerCountRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::NetPeerCountReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Version() { ::grpc::Service::MarkMethodAsync(3); } ~WithAsyncMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::types::VersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Syncing : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Syncing() { ::grpc::Service::MarkMethodAsync(4); } ~WithAsyncMethod_Syncing() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Syncing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::SyncingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSyncing(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::remote::SyncingReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_ProtocolVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_ProtocolVersion() { ::grpc::Service::MarkMethodAsync(5); } ~WithAsyncMethod_ProtocolVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ProtocolVersion(::grpc::ServerContext* /*context*/, const ::remote::ProtocolVersionRequest* /*request*/, ::remote::ProtocolVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestProtocolVersion(::grpc::ServerContext* context, ::remote::ProtocolVersionRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::ProtocolVersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_ClientVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_ClientVersion() { ::grpc::Service::MarkMethodAsync(6); } ~WithAsyncMethod_ClientVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ClientVersion(::grpc::ServerContext* /*context*/, const ::remote::ClientVersionRequest* /*request*/, ::remote::ClientVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestClientVersion(::grpc::ServerContext* context, ::remote::ClientVersionRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::ClientVersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Subscribe : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Subscribe() { ::grpc::Service::MarkMethodAsync(7); } ~WithAsyncMethod_Subscribe() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Subscribe(::grpc::ServerContext* /*context*/, const ::remote::SubscribeRequest* /*request*/, ::grpc::ServerWriter< ::remote::SubscribeReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubscribe(::grpc::ServerContext* context, ::remote::SubscribeRequest* request, ::grpc::ServerAsyncWriter< ::remote::SubscribeReply>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(7, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SubscribeLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SubscribeLogs() { ::grpc::Service::MarkMethodAsync(8); } ~WithAsyncMethod_SubscribeLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubscribeLogs(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubscribeLogs(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(8, context, stream, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Block : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Block() { ::grpc::Service::MarkMethodAsync(9); } ~WithAsyncMethod_Block() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Block(::grpc::ServerContext* /*context*/, const ::remote::BlockRequest* /*request*/, ::remote::BlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBlock(::grpc::ServerContext* context, ::remote::BlockRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::BlockReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_CanonicalBodyForStorage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CanonicalBodyForStorage() { ::grpc::Service::MarkMethodAsync(10); } ~WithAsyncMethod_CanonicalBodyForStorage() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalBodyForStorage(::grpc::ServerContext* /*context*/, const ::remote::CanonicalBodyForStorageRequest* /*request*/, ::remote::CanonicalBodyForStorageReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCanonicalBodyForStorage(::grpc::ServerContext* context, ::remote::CanonicalBodyForStorageRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::CanonicalBodyForStorageReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_CanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CanonicalHash() { ::grpc::Service::MarkMethodAsync(11); } ~WithAsyncMethod_CanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalHash(::grpc::ServerContext* /*context*/, const ::remote::CanonicalHashRequest* /*request*/, ::remote::CanonicalHashReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCanonicalHash(::grpc::ServerContext* context, ::remote::CanonicalHashRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::CanonicalHashReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_HeaderNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HeaderNumber() { ::grpc::Service::MarkMethodAsync(12); } ~WithAsyncMethod_HeaderNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HeaderNumber(::grpc::ServerContext* /*context*/, const ::remote::HeaderNumberRequest* /*request*/, ::remote::HeaderNumberReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHeaderNumber(::grpc::ServerContext* context, ::remote::HeaderNumberRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::HeaderNumberReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_TxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_TxnLookup() { ::grpc::Service::MarkMethodAsync(13); } ~WithAsyncMethod_TxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status TxnLookup(::grpc::ServerContext* /*context*/, const ::remote::TxnLookupRequest* /*request*/, ::remote::TxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestTxnLookup(::grpc::ServerContext* context, ::remote::TxnLookupRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::TxnLookupReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_NodeInfo() { ::grpc::Service::MarkMethodAsync(14); } ~WithAsyncMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::remote::NodesInfoRequest* /*request*/, ::remote::NodesInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNodeInfo(::grpc::ServerContext* context, ::remote::NodesInfoRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::NodesInfoReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Peers() { ::grpc::Service::MarkMethodAsync(15); } ~WithAsyncMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeers(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::remote::PeersReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(15, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_AddPeer() { ::grpc::Service::MarkMethodAsync(16); } ~WithAsyncMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::remote::AddPeerRequest* /*request*/, ::remote::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAddPeer(::grpc::ServerContext* context, ::remote::AddPeerRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::AddPeerReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(16, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_PendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PendingBlock() { ::grpc::Service::MarkMethodAsync(17); } ~WithAsyncMethod_PendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PendingBlock(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PendingBlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPendingBlock(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::remote::PendingBlockReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(17, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_BorTxnLookup() { ::grpc::Service::MarkMethodAsync(18); } ~WithAsyncMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorTxnLookup(::grpc::ServerContext* context, ::remote::BorTxnLookupRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::BorTxnLookupReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(18, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_BorEvents() { ::grpc::Service::MarkMethodAsync(19); } ~WithAsyncMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorEvents(::grpc::ServerContext* context, ::remote::BorEventsRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::BorEventsReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(19, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_Etherbase > > > > > > > > > > > > > > > > > > > AsyncService; template class WithCallbackMethod_Etherbase : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Etherbase() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::remote::EtherbaseRequest, ::remote::EtherbaseReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::EtherbaseRequest* request, ::remote::EtherbaseReply* response) { return this->Etherbase(context, request, response); }));} void SetMessageAllocatorFor_Etherbase( ::grpc::MessageAllocator< ::remote::EtherbaseRequest, ::remote::EtherbaseReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::EtherbaseRequest, ::remote::EtherbaseReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Etherbase() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Etherbase(::grpc::ServerContext* /*context*/, const ::remote::EtherbaseRequest* /*request*/, ::remote::EtherbaseReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Etherbase( ::grpc::CallbackServerContext* /*context*/, const ::remote::EtherbaseRequest* /*request*/, ::remote::EtherbaseReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_NetVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_NetVersion() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::remote::NetVersionRequest, ::remote::NetVersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::NetVersionRequest* request, ::remote::NetVersionReply* response) { return this->NetVersion(context, request, response); }));} void SetMessageAllocatorFor_NetVersion( ::grpc::MessageAllocator< ::remote::NetVersionRequest, ::remote::NetVersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::NetVersionRequest, ::remote::NetVersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_NetVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetVersion(::grpc::ServerContext* /*context*/, const ::remote::NetVersionRequest* /*request*/, ::remote::NetVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NetVersion( ::grpc::CallbackServerContext* /*context*/, const ::remote::NetVersionRequest* /*request*/, ::remote::NetVersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_NetPeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_NetPeerCount() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::NetPeerCountRequest* request, ::remote::NetPeerCountReply* response) { return this->NetPeerCount(context, request, response); }));} void SetMessageAllocatorFor_NetPeerCount( ::grpc::MessageAllocator< ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_NetPeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetPeerCount(::grpc::ServerContext* /*context*/, const ::remote::NetPeerCountRequest* /*request*/, ::remote::NetPeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NetPeerCount( ::grpc::CallbackServerContext* /*context*/, const ::remote::NetPeerCountRequest* /*request*/, ::remote::NetPeerCountReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Version() { ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { return this->Version(context, request, response); }));} void SetMessageAllocatorFor_Version( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::types::VersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Syncing : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Syncing() { ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::remote::SyncingReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::remote::SyncingReply* response) { return this->Syncing(context, request, response); }));} void SetMessageAllocatorFor_Syncing( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::remote::SyncingReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::remote::SyncingReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Syncing() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Syncing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::SyncingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Syncing( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::SyncingReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_ProtocolVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_ProtocolVersion() { ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::ProtocolVersionRequest* request, ::remote::ProtocolVersionReply* response) { return this->ProtocolVersion(context, request, response); }));} void SetMessageAllocatorFor_ProtocolVersion( ::grpc::MessageAllocator< ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_ProtocolVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ProtocolVersion(::grpc::ServerContext* /*context*/, const ::remote::ProtocolVersionRequest* /*request*/, ::remote::ProtocolVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* ProtocolVersion( ::grpc::CallbackServerContext* /*context*/, const ::remote::ProtocolVersionRequest* /*request*/, ::remote::ProtocolVersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_ClientVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_ClientVersion() { ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::remote::ClientVersionRequest, ::remote::ClientVersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::ClientVersionRequest* request, ::remote::ClientVersionReply* response) { return this->ClientVersion(context, request, response); }));} void SetMessageAllocatorFor_ClientVersion( ::grpc::MessageAllocator< ::remote::ClientVersionRequest, ::remote::ClientVersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::ClientVersionRequest, ::remote::ClientVersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_ClientVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ClientVersion(::grpc::ServerContext* /*context*/, const ::remote::ClientVersionRequest* /*request*/, ::remote::ClientVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* ClientVersion( ::grpc::CallbackServerContext* /*context*/, const ::remote::ClientVersionRequest* /*request*/, ::remote::ClientVersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Subscribe : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Subscribe() { ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackServerStreamingHandler< ::remote::SubscribeRequest, ::remote::SubscribeReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::SubscribeRequest* request) { return this->Subscribe(context, request); })); } ~WithCallbackMethod_Subscribe() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Subscribe(::grpc::ServerContext* /*context*/, const ::remote::SubscribeRequest* /*request*/, ::grpc::ServerWriter< ::remote::SubscribeReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::remote::SubscribeReply>* Subscribe( ::grpc::CallbackServerContext* /*context*/, const ::remote::SubscribeRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_SubscribeLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SubscribeLogs() { ::grpc::Service::MarkMethodCallback(8, new ::grpc::internal::CallbackBidiHandler< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>( [this]( ::grpc::CallbackServerContext* context) { return this->SubscribeLogs(context); })); } ~WithCallbackMethod_SubscribeLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubscribeLogs(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerBidiReactor< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>* SubscribeLogs( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; template class WithCallbackMethod_Block : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Block() { ::grpc::Service::MarkMethodCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::remote::BlockRequest, ::remote::BlockReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::BlockRequest* request, ::remote::BlockReply* response) { return this->Block(context, request, response); }));} void SetMessageAllocatorFor_Block( ::grpc::MessageAllocator< ::remote::BlockRequest, ::remote::BlockReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(9); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::BlockRequest, ::remote::BlockReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Block() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Block(::grpc::ServerContext* /*context*/, const ::remote::BlockRequest* /*request*/, ::remote::BlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Block( ::grpc::CallbackServerContext* /*context*/, const ::remote::BlockRequest* /*request*/, ::remote::BlockReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_CanonicalBodyForStorage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_CanonicalBodyForStorage() { ::grpc::Service::MarkMethodCallback(10, new ::grpc::internal::CallbackUnaryHandler< ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::CanonicalBodyForStorageRequest* request, ::remote::CanonicalBodyForStorageReply* response) { return this->CanonicalBodyForStorage(context, request, response); }));} void SetMessageAllocatorFor_CanonicalBodyForStorage( ::grpc::MessageAllocator< ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(10); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_CanonicalBodyForStorage() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalBodyForStorage(::grpc::ServerContext* /*context*/, const ::remote::CanonicalBodyForStorageRequest* /*request*/, ::remote::CanonicalBodyForStorageReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CanonicalBodyForStorage( ::grpc::CallbackServerContext* /*context*/, const ::remote::CanonicalBodyForStorageRequest* /*request*/, ::remote::CanonicalBodyForStorageReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_CanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_CanonicalHash() { ::grpc::Service::MarkMethodCallback(11, new ::grpc::internal::CallbackUnaryHandler< ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::CanonicalHashRequest* request, ::remote::CanonicalHashReply* response) { return this->CanonicalHash(context, request, response); }));} void SetMessageAllocatorFor_CanonicalHash( ::grpc::MessageAllocator< ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(11); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_CanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalHash(::grpc::ServerContext* /*context*/, const ::remote::CanonicalHashRequest* /*request*/, ::remote::CanonicalHashReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CanonicalHash( ::grpc::CallbackServerContext* /*context*/, const ::remote::CanonicalHashRequest* /*request*/, ::remote::CanonicalHashReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_HeaderNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_HeaderNumber() { ::grpc::Service::MarkMethodCallback(12, new ::grpc::internal::CallbackUnaryHandler< ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::HeaderNumberRequest* request, ::remote::HeaderNumberReply* response) { return this->HeaderNumber(context, request, response); }));} void SetMessageAllocatorFor_HeaderNumber( ::grpc::MessageAllocator< ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(12); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_HeaderNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HeaderNumber(::grpc::ServerContext* /*context*/, const ::remote::HeaderNumberRequest* /*request*/, ::remote::HeaderNumberReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HeaderNumber( ::grpc::CallbackServerContext* /*context*/, const ::remote::HeaderNumberRequest* /*request*/, ::remote::HeaderNumberReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_TxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_TxnLookup() { ::grpc::Service::MarkMethodCallback(13, new ::grpc::internal::CallbackUnaryHandler< ::remote::TxnLookupRequest, ::remote::TxnLookupReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::TxnLookupRequest* request, ::remote::TxnLookupReply* response) { return this->TxnLookup(context, request, response); }));} void SetMessageAllocatorFor_TxnLookup( ::grpc::MessageAllocator< ::remote::TxnLookupRequest, ::remote::TxnLookupReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(13); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::TxnLookupRequest, ::remote::TxnLookupReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_TxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status TxnLookup(::grpc::ServerContext* /*context*/, const ::remote::TxnLookupRequest* /*request*/, ::remote::TxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* TxnLookup( ::grpc::CallbackServerContext* /*context*/, const ::remote::TxnLookupRequest* /*request*/, ::remote::TxnLookupReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_NodeInfo() { ::grpc::Service::MarkMethodCallback(14, new ::grpc::internal::CallbackUnaryHandler< ::remote::NodesInfoRequest, ::remote::NodesInfoReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::NodesInfoRequest* request, ::remote::NodesInfoReply* response) { return this->NodeInfo(context, request, response); }));} void SetMessageAllocatorFor_NodeInfo( ::grpc::MessageAllocator< ::remote::NodesInfoRequest, ::remote::NodesInfoReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(14); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::NodesInfoRequest, ::remote::NodesInfoReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::remote::NodesInfoRequest* /*request*/, ::remote::NodesInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NodeInfo( ::grpc::CallbackServerContext* /*context*/, const ::remote::NodesInfoRequest* /*request*/, ::remote::NodesInfoReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Peers() { ::grpc::Service::MarkMethodCallback(15, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::remote::PeersReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::remote::PeersReply* response) { return this->Peers(context, request, response); }));} void SetMessageAllocatorFor_Peers( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::remote::PeersReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(15); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::remote::PeersReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Peers( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PeersReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_AddPeer() { ::grpc::Service::MarkMethodCallback(16, new ::grpc::internal::CallbackUnaryHandler< ::remote::AddPeerRequest, ::remote::AddPeerReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::AddPeerRequest* request, ::remote::AddPeerReply* response) { return this->AddPeer(context, request, response); }));} void SetMessageAllocatorFor_AddPeer( ::grpc::MessageAllocator< ::remote::AddPeerRequest, ::remote::AddPeerReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(16); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::AddPeerRequest, ::remote::AddPeerReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::remote::AddPeerRequest* /*request*/, ::remote::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* AddPeer( ::grpc::CallbackServerContext* /*context*/, const ::remote::AddPeerRequest* /*request*/, ::remote::AddPeerReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_PendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_PendingBlock() { ::grpc::Service::MarkMethodCallback(17, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::remote::PendingBlockReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::remote::PendingBlockReply* response) { return this->PendingBlock(context, request, response); }));} void SetMessageAllocatorFor_PendingBlock( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::remote::PendingBlockReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(17); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::remote::PendingBlockReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_PendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PendingBlock(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PendingBlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PendingBlock( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PendingBlockReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_BorTxnLookup() { ::grpc::Service::MarkMethodCallback(18, new ::grpc::internal::CallbackUnaryHandler< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::BorTxnLookupRequest* request, ::remote::BorTxnLookupReply* response) { return this->BorTxnLookup(context, request, response); }));} void SetMessageAllocatorFor_BorTxnLookup( ::grpc::MessageAllocator< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(18); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorTxnLookup( ::grpc::CallbackServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_BorEvents() { ::grpc::Service::MarkMethodCallback(19, new ::grpc::internal::CallbackUnaryHandler< ::remote::BorEventsRequest, ::remote::BorEventsReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::BorEventsRequest* request, ::remote::BorEventsReply* response) { return this->BorEvents(context, request, response); }));} void SetMessageAllocatorFor_BorEvents( ::grpc::MessageAllocator< ::remote::BorEventsRequest, ::remote::BorEventsReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(19); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::BorEventsRequest, ::remote::BorEventsReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorEvents( ::grpc::CallbackServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_Etherbase > > > > > > > > > > > > > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_Etherbase : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Etherbase() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_Etherbase() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Etherbase(::grpc::ServerContext* /*context*/, const ::remote::EtherbaseRequest* /*request*/, ::remote::EtherbaseReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_NetVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_NetVersion() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_NetVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetVersion(::grpc::ServerContext* /*context*/, const ::remote::NetVersionRequest* /*request*/, ::remote::NetVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_NetPeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_NetPeerCount() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_NetPeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetPeerCount(::grpc::ServerContext* /*context*/, const ::remote::NetPeerCountRequest* /*request*/, ::remote::NetPeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Version() { ::grpc::Service::MarkMethodGeneric(3); } ~WithGenericMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Syncing : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Syncing() { ::grpc::Service::MarkMethodGeneric(4); } ~WithGenericMethod_Syncing() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Syncing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::SyncingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_ProtocolVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_ProtocolVersion() { ::grpc::Service::MarkMethodGeneric(5); } ~WithGenericMethod_ProtocolVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ProtocolVersion(::grpc::ServerContext* /*context*/, const ::remote::ProtocolVersionRequest* /*request*/, ::remote::ProtocolVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_ClientVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_ClientVersion() { ::grpc::Service::MarkMethodGeneric(6); } ~WithGenericMethod_ClientVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ClientVersion(::grpc::ServerContext* /*context*/, const ::remote::ClientVersionRequest* /*request*/, ::remote::ClientVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Subscribe : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Subscribe() { ::grpc::Service::MarkMethodGeneric(7); } ~WithGenericMethod_Subscribe() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Subscribe(::grpc::ServerContext* /*context*/, const ::remote::SubscribeRequest* /*request*/, ::grpc::ServerWriter< ::remote::SubscribeReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SubscribeLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SubscribeLogs() { ::grpc::Service::MarkMethodGeneric(8); } ~WithGenericMethod_SubscribeLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubscribeLogs(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Block : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Block() { ::grpc::Service::MarkMethodGeneric(9); } ~WithGenericMethod_Block() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Block(::grpc::ServerContext* /*context*/, const ::remote::BlockRequest* /*request*/, ::remote::BlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_CanonicalBodyForStorage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CanonicalBodyForStorage() { ::grpc::Service::MarkMethodGeneric(10); } ~WithGenericMethod_CanonicalBodyForStorage() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalBodyForStorage(::grpc::ServerContext* /*context*/, const ::remote::CanonicalBodyForStorageRequest* /*request*/, ::remote::CanonicalBodyForStorageReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_CanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CanonicalHash() { ::grpc::Service::MarkMethodGeneric(11); } ~WithGenericMethod_CanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalHash(::grpc::ServerContext* /*context*/, const ::remote::CanonicalHashRequest* /*request*/, ::remote::CanonicalHashReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_HeaderNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HeaderNumber() { ::grpc::Service::MarkMethodGeneric(12); } ~WithGenericMethod_HeaderNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HeaderNumber(::grpc::ServerContext* /*context*/, const ::remote::HeaderNumberRequest* /*request*/, ::remote::HeaderNumberReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_TxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_TxnLookup() { ::grpc::Service::MarkMethodGeneric(13); } ~WithGenericMethod_TxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status TxnLookup(::grpc::ServerContext* /*context*/, const ::remote::TxnLookupRequest* /*request*/, ::remote::TxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_NodeInfo() { ::grpc::Service::MarkMethodGeneric(14); } ~WithGenericMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::remote::NodesInfoRequest* /*request*/, ::remote::NodesInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Peers() { ::grpc::Service::MarkMethodGeneric(15); } ~WithGenericMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_AddPeer() { ::grpc::Service::MarkMethodGeneric(16); } ~WithGenericMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::remote::AddPeerRequest* /*request*/, ::remote::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_PendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PendingBlock() { ::grpc::Service::MarkMethodGeneric(17); } ~WithGenericMethod_PendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PendingBlock(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PendingBlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_BorTxnLookup() { ::grpc::Service::MarkMethodGeneric(18); } ~WithGenericMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_BorEvents() { ::grpc::Service::MarkMethodGeneric(19); } ~WithGenericMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_Etherbase : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Etherbase() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_Etherbase() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Etherbase(::grpc::ServerContext* /*context*/, const ::remote::EtherbaseRequest* /*request*/, ::remote::EtherbaseReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestEtherbase(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_NetVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_NetVersion() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_NetVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetVersion(::grpc::ServerContext* /*context*/, const ::remote::NetVersionRequest* /*request*/, ::remote::NetVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNetVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_NetPeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_NetPeerCount() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_NetPeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetPeerCount(::grpc::ServerContext* /*context*/, const ::remote::NetPeerCountRequest* /*request*/, ::remote::NetPeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNetPeerCount(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Version() { ::grpc::Service::MarkMethodRaw(3); } ~WithRawMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Syncing : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Syncing() { ::grpc::Service::MarkMethodRaw(4); } ~WithRawMethod_Syncing() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Syncing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::SyncingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSyncing(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_ProtocolVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_ProtocolVersion() { ::grpc::Service::MarkMethodRaw(5); } ~WithRawMethod_ProtocolVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ProtocolVersion(::grpc::ServerContext* /*context*/, const ::remote::ProtocolVersionRequest* /*request*/, ::remote::ProtocolVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestProtocolVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_ClientVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_ClientVersion() { ::grpc::Service::MarkMethodRaw(6); } ~WithRawMethod_ClientVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ClientVersion(::grpc::ServerContext* /*context*/, const ::remote::ClientVersionRequest* /*request*/, ::remote::ClientVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestClientVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Subscribe : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Subscribe() { ::grpc::Service::MarkMethodRaw(7); } ~WithRawMethod_Subscribe() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Subscribe(::grpc::ServerContext* /*context*/, const ::remote::SubscribeRequest* /*request*/, ::grpc::ServerWriter< ::remote::SubscribeReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubscribe(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(7, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SubscribeLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SubscribeLogs() { ::grpc::Service::MarkMethodRaw(8); } ~WithRawMethod_SubscribeLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubscribeLogs(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubscribeLogs(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(8, context, stream, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Block : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Block() { ::grpc::Service::MarkMethodRaw(9); } ~WithRawMethod_Block() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Block(::grpc::ServerContext* /*context*/, const ::remote::BlockRequest* /*request*/, ::remote::BlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_CanonicalBodyForStorage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CanonicalBodyForStorage() { ::grpc::Service::MarkMethodRaw(10); } ~WithRawMethod_CanonicalBodyForStorage() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalBodyForStorage(::grpc::ServerContext* /*context*/, const ::remote::CanonicalBodyForStorageRequest* /*request*/, ::remote::CanonicalBodyForStorageReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCanonicalBodyForStorage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_CanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CanonicalHash() { ::grpc::Service::MarkMethodRaw(11); } ~WithRawMethod_CanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalHash(::grpc::ServerContext* /*context*/, const ::remote::CanonicalHashRequest* /*request*/, ::remote::CanonicalHashReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCanonicalHash(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_HeaderNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HeaderNumber() { ::grpc::Service::MarkMethodRaw(12); } ~WithRawMethod_HeaderNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HeaderNumber(::grpc::ServerContext* /*context*/, const ::remote::HeaderNumberRequest* /*request*/, ::remote::HeaderNumberReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHeaderNumber(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_TxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_TxnLookup() { ::grpc::Service::MarkMethodRaw(13); } ~WithRawMethod_TxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status TxnLookup(::grpc::ServerContext* /*context*/, const ::remote::TxnLookupRequest* /*request*/, ::remote::TxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestTxnLookup(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_NodeInfo() { ::grpc::Service::MarkMethodRaw(14); } ~WithRawMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::remote::NodesInfoRequest* /*request*/, ::remote::NodesInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNodeInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Peers() { ::grpc::Service::MarkMethodRaw(15); } ~WithRawMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPeers(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(15, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_AddPeer() { ::grpc::Service::MarkMethodRaw(16); } ~WithRawMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::remote::AddPeerRequest* /*request*/, ::remote::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAddPeer(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(16, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_PendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PendingBlock() { ::grpc::Service::MarkMethodRaw(17); } ~WithRawMethod_PendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PendingBlock(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PendingBlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPendingBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(17, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_BorTxnLookup() { ::grpc::Service::MarkMethodRaw(18); } ~WithRawMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorTxnLookup(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(18, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_BorEvents() { ::grpc::Service::MarkMethodRaw(19); } ~WithRawMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBorEvents(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(19, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_Etherbase : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Etherbase() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Etherbase(context, request, response); })); } ~WithRawCallbackMethod_Etherbase() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Etherbase(::grpc::ServerContext* /*context*/, const ::remote::EtherbaseRequest* /*request*/, ::remote::EtherbaseReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Etherbase( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_NetVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_NetVersion() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->NetVersion(context, request, response); })); } ~WithRawCallbackMethod_NetVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetVersion(::grpc::ServerContext* /*context*/, const ::remote::NetVersionRequest* /*request*/, ::remote::NetVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NetVersion( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_NetPeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_NetPeerCount() { ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->NetPeerCount(context, request, response); })); } ~WithRawCallbackMethod_NetPeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NetPeerCount(::grpc::ServerContext* /*context*/, const ::remote::NetPeerCountRequest* /*request*/, ::remote::NetPeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NetPeerCount( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Version() { ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Version(context, request, response); })); } ~WithRawCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Syncing : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Syncing() { ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Syncing(context, request, response); })); } ~WithRawCallbackMethod_Syncing() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Syncing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::SyncingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Syncing( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_ProtocolVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_ProtocolVersion() { ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ProtocolVersion(context, request, response); })); } ~WithRawCallbackMethod_ProtocolVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ProtocolVersion(::grpc::ServerContext* /*context*/, const ::remote::ProtocolVersionRequest* /*request*/, ::remote::ProtocolVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* ProtocolVersion( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_ClientVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_ClientVersion() { ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ClientVersion(context, request, response); })); } ~WithRawCallbackMethod_ClientVersion() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status ClientVersion(::grpc::ServerContext* /*context*/, const ::remote::ClientVersionRequest* /*request*/, ::remote::ClientVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* ClientVersion( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Subscribe : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Subscribe() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->Subscribe(context, request); })); } ~WithRawCallbackMethod_Subscribe() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Subscribe(::grpc::ServerContext* /*context*/, const ::remote::SubscribeRequest* /*request*/, ::grpc::ServerWriter< ::remote::SubscribeReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* Subscribe( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_SubscribeLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SubscribeLogs() { ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context) { return this->SubscribeLogs(context); })); } ~WithRawCallbackMethod_SubscribeLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubscribeLogs(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::SubscribeLogsReply, ::remote::LogsFilterRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* SubscribeLogs( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; template class WithRawCallbackMethod_Block : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Block() { ::grpc::Service::MarkMethodRawCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Block(context, request, response); })); } ~WithRawCallbackMethod_Block() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Block(::grpc::ServerContext* /*context*/, const ::remote::BlockRequest* /*request*/, ::remote::BlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Block( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_CanonicalBodyForStorage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_CanonicalBodyForStorage() { ::grpc::Service::MarkMethodRawCallback(10, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->CanonicalBodyForStorage(context, request, response); })); } ~WithRawCallbackMethod_CanonicalBodyForStorage() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalBodyForStorage(::grpc::ServerContext* /*context*/, const ::remote::CanonicalBodyForStorageRequest* /*request*/, ::remote::CanonicalBodyForStorageReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CanonicalBodyForStorage( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_CanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_CanonicalHash() { ::grpc::Service::MarkMethodRawCallback(11, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->CanonicalHash(context, request, response); })); } ~WithRawCallbackMethod_CanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CanonicalHash(::grpc::ServerContext* /*context*/, const ::remote::CanonicalHashRequest* /*request*/, ::remote::CanonicalHashReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CanonicalHash( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_HeaderNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_HeaderNumber() { ::grpc::Service::MarkMethodRawCallback(12, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->HeaderNumber(context, request, response); })); } ~WithRawCallbackMethod_HeaderNumber() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HeaderNumber(::grpc::ServerContext* /*context*/, const ::remote::HeaderNumberRequest* /*request*/, ::remote::HeaderNumberReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HeaderNumber( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_TxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_TxnLookup() { ::grpc::Service::MarkMethodRawCallback(13, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->TxnLookup(context, request, response); })); } ~WithRawCallbackMethod_TxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status TxnLookup(::grpc::ServerContext* /*context*/, const ::remote::TxnLookupRequest* /*request*/, ::remote::TxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* TxnLookup( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_NodeInfo() { ::grpc::Service::MarkMethodRawCallback(14, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->NodeInfo(context, request, response); })); } ~WithRawCallbackMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::remote::NodesInfoRequest* /*request*/, ::remote::NodesInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NodeInfo( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Peers() { ::grpc::Service::MarkMethodRawCallback(15, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Peers(context, request, response); })); } ~WithRawCallbackMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Peers( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_AddPeer() { ::grpc::Service::MarkMethodRawCallback(16, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AddPeer(context, request, response); })); } ~WithRawCallbackMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::remote::AddPeerRequest* /*request*/, ::remote::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* AddPeer( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_PendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_PendingBlock() { ::grpc::Service::MarkMethodRawCallback(17, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PendingBlock(context, request, response); })); } ~WithRawCallbackMethod_PendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status PendingBlock(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PendingBlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PendingBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_BorTxnLookup() { ::grpc::Service::MarkMethodRawCallback(18, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->BorTxnLookup(context, request, response); })); } ~WithRawCallbackMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorTxnLookup( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_BorEvents() { ::grpc::Service::MarkMethodRawCallback(19, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->BorEvents(context, request, response); })); } ~WithRawCallbackMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BorEvents( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_Etherbase : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Etherbase() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::remote::EtherbaseRequest, ::remote::EtherbaseReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::EtherbaseRequest, ::remote::EtherbaseReply>* streamer) { return this->StreamedEtherbase(context, streamer); })); } ~WithStreamedUnaryMethod_Etherbase() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Etherbase(::grpc::ServerContext* /*context*/, const ::remote::EtherbaseRequest* /*request*/, ::remote::EtherbaseReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedEtherbase(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::EtherbaseRequest,::remote::EtherbaseReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_NetVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_NetVersion() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler< ::remote::NetVersionRequest, ::remote::NetVersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::NetVersionRequest, ::remote::NetVersionReply>* streamer) { return this->StreamedNetVersion(context, streamer); })); } ~WithStreamedUnaryMethod_NetVersion() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status NetVersion(::grpc::ServerContext* /*context*/, const ::remote::NetVersionRequest* /*request*/, ::remote::NetVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedNetVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::NetVersionRequest,::remote::NetVersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_NetPeerCount : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_NetPeerCount() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::StreamedUnaryHandler< ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::NetPeerCountRequest, ::remote::NetPeerCountReply>* streamer) { return this->StreamedNetPeerCount(context, streamer); })); } ~WithStreamedUnaryMethod_NetPeerCount() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status NetPeerCount(::grpc::ServerContext* /*context*/, const ::remote::NetPeerCountRequest* /*request*/, ::remote::NetPeerCountReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedNetPeerCount(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::NetPeerCountRequest,::remote::NetPeerCountReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Version() { ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::types::VersionReply>* streamer) { return this->StreamedVersion(context, streamer); })); } ~WithStreamedUnaryMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::types::VersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Syncing : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Syncing() { ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::remote::SyncingReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::remote::SyncingReply>* streamer) { return this->StreamedSyncing(context, streamer); })); } ~WithStreamedUnaryMethod_Syncing() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Syncing(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::SyncingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSyncing(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::remote::SyncingReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_ProtocolVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_ProtocolVersion() { ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler< ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::ProtocolVersionRequest, ::remote::ProtocolVersionReply>* streamer) { return this->StreamedProtocolVersion(context, streamer); })); } ~WithStreamedUnaryMethod_ProtocolVersion() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status ProtocolVersion(::grpc::ServerContext* /*context*/, const ::remote::ProtocolVersionRequest* /*request*/, ::remote::ProtocolVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedProtocolVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::ProtocolVersionRequest,::remote::ProtocolVersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_ClientVersion : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_ClientVersion() { ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::StreamedUnaryHandler< ::remote::ClientVersionRequest, ::remote::ClientVersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::ClientVersionRequest, ::remote::ClientVersionReply>* streamer) { return this->StreamedClientVersion(context, streamer); })); } ~WithStreamedUnaryMethod_ClientVersion() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status ClientVersion(::grpc::ServerContext* /*context*/, const ::remote::ClientVersionRequest* /*request*/, ::remote::ClientVersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedClientVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::ClientVersionRequest,::remote::ClientVersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Block : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Block() { ::grpc::Service::MarkMethodStreamed(9, new ::grpc::internal::StreamedUnaryHandler< ::remote::BlockRequest, ::remote::BlockReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BlockRequest, ::remote::BlockReply>* streamer) { return this->StreamedBlock(context, streamer); })); } ~WithStreamedUnaryMethod_Block() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Block(::grpc::ServerContext* /*context*/, const ::remote::BlockRequest* /*request*/, ::remote::BlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedBlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BlockRequest,::remote::BlockReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_CanonicalBodyForStorage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CanonicalBodyForStorage() { ::grpc::Service::MarkMethodStreamed(10, new ::grpc::internal::StreamedUnaryHandler< ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::CanonicalBodyForStorageRequest, ::remote::CanonicalBodyForStorageReply>* streamer) { return this->StreamedCanonicalBodyForStorage(context, streamer); })); } ~WithStreamedUnaryMethod_CanonicalBodyForStorage() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status CanonicalBodyForStorage(::grpc::ServerContext* /*context*/, const ::remote::CanonicalBodyForStorageRequest* /*request*/, ::remote::CanonicalBodyForStorageReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedCanonicalBodyForStorage(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::CanonicalBodyForStorageRequest,::remote::CanonicalBodyForStorageReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_CanonicalHash : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CanonicalHash() { ::grpc::Service::MarkMethodStreamed(11, new ::grpc::internal::StreamedUnaryHandler< ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::CanonicalHashRequest, ::remote::CanonicalHashReply>* streamer) { return this->StreamedCanonicalHash(context, streamer); })); } ~WithStreamedUnaryMethod_CanonicalHash() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status CanonicalHash(::grpc::ServerContext* /*context*/, const ::remote::CanonicalHashRequest* /*request*/, ::remote::CanonicalHashReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedCanonicalHash(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::CanonicalHashRequest,::remote::CanonicalHashReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HeaderNumber : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HeaderNumber() { ::grpc::Service::MarkMethodStreamed(12, new ::grpc::internal::StreamedUnaryHandler< ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::HeaderNumberRequest, ::remote::HeaderNumberReply>* streamer) { return this->StreamedHeaderNumber(context, streamer); })); } ~WithStreamedUnaryMethod_HeaderNumber() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status HeaderNumber(::grpc::ServerContext* /*context*/, const ::remote::HeaderNumberRequest* /*request*/, ::remote::HeaderNumberReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedHeaderNumber(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::HeaderNumberRequest,::remote::HeaderNumberReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_TxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_TxnLookup() { ::grpc::Service::MarkMethodStreamed(13, new ::grpc::internal::StreamedUnaryHandler< ::remote::TxnLookupRequest, ::remote::TxnLookupReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::TxnLookupRequest, ::remote::TxnLookupReply>* streamer) { return this->StreamedTxnLookup(context, streamer); })); } ~WithStreamedUnaryMethod_TxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status TxnLookup(::grpc::ServerContext* /*context*/, const ::remote::TxnLookupRequest* /*request*/, ::remote::TxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedTxnLookup(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::TxnLookupRequest,::remote::TxnLookupReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_NodeInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_NodeInfo() { ::grpc::Service::MarkMethodStreamed(14, new ::grpc::internal::StreamedUnaryHandler< ::remote::NodesInfoRequest, ::remote::NodesInfoReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::NodesInfoRequest, ::remote::NodesInfoReply>* streamer) { return this->StreamedNodeInfo(context, streamer); })); } ~WithStreamedUnaryMethod_NodeInfo() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status NodeInfo(::grpc::ServerContext* /*context*/, const ::remote::NodesInfoRequest* /*request*/, ::remote::NodesInfoReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedNodeInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::NodesInfoRequest,::remote::NodesInfoReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Peers : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Peers() { ::grpc::Service::MarkMethodStreamed(15, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::remote::PeersReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::remote::PeersReply>* streamer) { return this->StreamedPeers(context, streamer); })); } ~WithStreamedUnaryMethod_Peers() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Peers(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PeersReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPeers(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::remote::PeersReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_AddPeer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_AddPeer() { ::grpc::Service::MarkMethodStreamed(16, new ::grpc::internal::StreamedUnaryHandler< ::remote::AddPeerRequest, ::remote::AddPeerReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::AddPeerRequest, ::remote::AddPeerReply>* streamer) { return this->StreamedAddPeer(context, streamer); })); } ~WithStreamedUnaryMethod_AddPeer() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status AddPeer(::grpc::ServerContext* /*context*/, const ::remote::AddPeerRequest* /*request*/, ::remote::AddPeerReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedAddPeer(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::AddPeerRequest,::remote::AddPeerReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_PendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_PendingBlock() { ::grpc::Service::MarkMethodStreamed(17, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::remote::PendingBlockReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::remote::PendingBlockReply>* streamer) { return this->StreamedPendingBlock(context, streamer); })); } ~WithStreamedUnaryMethod_PendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status PendingBlock(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::remote::PendingBlockReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPendingBlock(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::remote::PendingBlockReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_BorTxnLookup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_BorTxnLookup() { ::grpc::Service::MarkMethodStreamed(18, new ::grpc::internal::StreamedUnaryHandler< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorTxnLookupRequest, ::remote::BorTxnLookupReply>* streamer) { return this->StreamedBorTxnLookup(context, streamer); })); } ~WithStreamedUnaryMethod_BorTxnLookup() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status BorTxnLookup(::grpc::ServerContext* /*context*/, const ::remote::BorTxnLookupRequest* /*request*/, ::remote::BorTxnLookupReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedBorTxnLookup(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorTxnLookupRequest,::remote::BorTxnLookupReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_BorEvents : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_BorEvents() { ::grpc::Service::MarkMethodStreamed(19, new ::grpc::internal::StreamedUnaryHandler< ::remote::BorEventsRequest, ::remote::BorEventsReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorEventsRequest, ::remote::BorEventsReply>* streamer) { return this->StreamedBorEvents(context, streamer); })); } ~WithStreamedUnaryMethod_BorEvents() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status BorEvents(::grpc::ServerContext* /*context*/, const ::remote::BorEventsRequest* /*request*/, ::remote::BorEventsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedBorEvents(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::BorEventsRequest,::remote::BorEventsReply>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_Etherbase > > > > > > > > > > > > > > > > > StreamedUnaryService; template class WithSplitStreamingMethod_Subscribe : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_Subscribe() { ::grpc::Service::MarkMethodStreamed(7, new ::grpc::internal::SplitServerStreamingHandler< ::remote::SubscribeRequest, ::remote::SubscribeReply>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::remote::SubscribeRequest, ::remote::SubscribeReply>* streamer) { return this->StreamedSubscribe(context, streamer); })); } ~WithSplitStreamingMethod_Subscribe() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Subscribe(::grpc::ServerContext* /*context*/, const ::remote::SubscribeRequest* /*request*/, ::grpc::ServerWriter< ::remote::SubscribeReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedSubscribe(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::remote::SubscribeRequest,::remote::SubscribeReply>* server_split_streamer) = 0; }; typedef WithSplitStreamingMethod_Subscribe SplitStreamedService; typedef WithStreamedUnaryMethod_Etherbase > > > > > > > > > > > > > > > > > > StreamedService; }; } // namespace remote #endif // GRPC_remote_2fethbackend_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/remote/ethbackend.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: remote/ethbackend.proto // Protobuf C++ Version: 5.27.0 #include "remote/ethbackend.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace remote { inline constexpr TxnLookupReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : block_number_{::uint64_t{0u}}, tx_number_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR TxnLookupReply::TxnLookupReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct TxnLookupReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR TxnLookupReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~TxnLookupReplyDefaultTypeInternal() {} union { TxnLookupReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TxnLookupReplyDefaultTypeInternal _TxnLookupReply_default_instance_; inline constexpr SyncingReply_StageProgress::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : stage_name_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), block_number_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SyncingReply_StageProgress::SyncingReply_StageProgress(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SyncingReply_StageProgressDefaultTypeInternal { PROTOBUF_CONSTEXPR SyncingReply_StageProgressDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SyncingReply_StageProgressDefaultTypeInternal() {} union { SyncingReply_StageProgress _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncingReply_StageProgressDefaultTypeInternal _SyncingReply_StageProgress_default_instance_; inline constexpr SubscribeRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : type_{static_cast< ::remote::Event >(0)}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SubscribeRequest::SubscribeRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SubscribeRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR SubscribeRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SubscribeRequestDefaultTypeInternal() {} union { SubscribeRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscribeRequestDefaultTypeInternal _SubscribeRequest_default_instance_; inline constexpr SubscribeReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), type_{static_cast< ::remote::Event >(0)}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SubscribeReply::SubscribeReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SubscribeReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR SubscribeReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SubscribeReplyDefaultTypeInternal() {} union { SubscribeReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscribeReplyDefaultTypeInternal _SubscribeReply_default_instance_; template PROTOBUF_CONSTEXPR ProtocolVersionRequest::ProtocolVersionRequest(::_pbi::ConstantInitialized) {} struct ProtocolVersionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ProtocolVersionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ProtocolVersionRequestDefaultTypeInternal() {} union { ProtocolVersionRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ProtocolVersionRequestDefaultTypeInternal _ProtocolVersionRequest_default_instance_; inline constexpr ProtocolVersionReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : id_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR ProtocolVersionReply::ProtocolVersionReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ProtocolVersionReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR ProtocolVersionReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ProtocolVersionReplyDefaultTypeInternal() {} union { ProtocolVersionReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ProtocolVersionReplyDefaultTypeInternal _ProtocolVersionReply_default_instance_; inline constexpr PendingBlockReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : block_rlp_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR PendingBlockReply::PendingBlockReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PendingBlockReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR PendingBlockReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PendingBlockReplyDefaultTypeInternal() {} union { PendingBlockReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingBlockReplyDefaultTypeInternal _PendingBlockReply_default_instance_; inline constexpr NodesInfoRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : limit_{0u}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR NodesInfoRequest::NodesInfoRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NodesInfoRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR NodesInfoRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NodesInfoRequestDefaultTypeInternal() {} union { NodesInfoRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NodesInfoRequestDefaultTypeInternal _NodesInfoRequest_default_instance_; template PROTOBUF_CONSTEXPR NetVersionRequest::NetVersionRequest(::_pbi::ConstantInitialized) {} struct NetVersionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR NetVersionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NetVersionRequestDefaultTypeInternal() {} union { NetVersionRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetVersionRequestDefaultTypeInternal _NetVersionRequest_default_instance_; inline constexpr NetVersionReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : id_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR NetVersionReply::NetVersionReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NetVersionReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR NetVersionReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NetVersionReplyDefaultTypeInternal() {} union { NetVersionReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetVersionReplyDefaultTypeInternal _NetVersionReply_default_instance_; template PROTOBUF_CONSTEXPR NetPeerCountRequest::NetPeerCountRequest(::_pbi::ConstantInitialized) {} struct NetPeerCountRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR NetPeerCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NetPeerCountRequestDefaultTypeInternal() {} union { NetPeerCountRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetPeerCountRequestDefaultTypeInternal _NetPeerCountRequest_default_instance_; inline constexpr NetPeerCountReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : count_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR NetPeerCountReply::NetPeerCountReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NetPeerCountReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR NetPeerCountReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NetPeerCountReplyDefaultTypeInternal() {} union { NetPeerCountReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetPeerCountReplyDefaultTypeInternal _NetPeerCountReply_default_instance_; inline constexpr HeaderNumberReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, number_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR HeaderNumberReply::HeaderNumberReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HeaderNumberReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR HeaderNumberReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HeaderNumberReplyDefaultTypeInternal() {} union { HeaderNumberReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeaderNumberReplyDefaultTypeInternal _HeaderNumberReply_default_instance_; template PROTOBUF_CONSTEXPR EtherbaseRequest::EtherbaseRequest(::_pbi::ConstantInitialized) {} struct EtherbaseRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR EtherbaseRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~EtherbaseRequestDefaultTypeInternal() {} union { EtherbaseRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EtherbaseRequestDefaultTypeInternal _EtherbaseRequest_default_instance_; inline constexpr EngineGetPayloadBodiesByRangeV1Request::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : start_{::uint64_t{0u}}, count_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR EngineGetPayloadBodiesByRangeV1Request::EngineGetPayloadBodiesByRangeV1Request(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct EngineGetPayloadBodiesByRangeV1RequestDefaultTypeInternal { PROTOBUF_CONSTEXPR EngineGetPayloadBodiesByRangeV1RequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~EngineGetPayloadBodiesByRangeV1RequestDefaultTypeInternal() {} union { EngineGetPayloadBodiesByRangeV1Request _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EngineGetPayloadBodiesByRangeV1RequestDefaultTypeInternal _EngineGetPayloadBodiesByRangeV1Request_default_instance_; template PROTOBUF_CONSTEXPR ClientVersionRequest::ClientVersionRequest(::_pbi::ConstantInitialized) {} struct ClientVersionRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR ClientVersionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClientVersionRequestDefaultTypeInternal() {} union { ClientVersionRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientVersionRequestDefaultTypeInternal _ClientVersionRequest_default_instance_; inline constexpr ClientVersionReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : node_name_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR ClientVersionReply::ClientVersionReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ClientVersionReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR ClientVersionReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ClientVersionReplyDefaultTypeInternal() {} union { ClientVersionReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientVersionReplyDefaultTypeInternal _ClientVersionReply_default_instance_; inline constexpr CanonicalHashRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : block_number_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR CanonicalHashRequest::CanonicalHashRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct CanonicalHashRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR CanonicalHashRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~CanonicalHashRequestDefaultTypeInternal() {} union { CanonicalHashRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CanonicalHashRequestDefaultTypeInternal _CanonicalHashRequest_default_instance_; inline constexpr CanonicalBodyForStorageRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : blocknumber_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR CanonicalBodyForStorageRequest::CanonicalBodyForStorageRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct CanonicalBodyForStorageRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR CanonicalBodyForStorageRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~CanonicalBodyForStorageRequestDefaultTypeInternal() {} union { CanonicalBodyForStorageRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CanonicalBodyForStorageRequestDefaultTypeInternal _CanonicalBodyForStorageRequest_default_instance_; inline constexpr CanonicalBodyForStorageReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : body_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR CanonicalBodyForStorageReply::CanonicalBodyForStorageReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct CanonicalBodyForStorageReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR CanonicalBodyForStorageReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~CanonicalBodyForStorageReplyDefaultTypeInternal() {} union { CanonicalBodyForStorageReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CanonicalBodyForStorageReplyDefaultTypeInternal _CanonicalBodyForStorageReply_default_instance_; inline constexpr BlockReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : block_rlp_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), senders_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR BlockReply::BlockReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BlockReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR BlockReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BlockReplyDefaultTypeInternal() {} union { BlockReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockReplyDefaultTypeInternal _BlockReply_default_instance_; inline constexpr AddPeerRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : url_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR AddPeerRequest::AddPeerRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AddPeerRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR AddPeerRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AddPeerRequestDefaultTypeInternal() {} union { AddPeerRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddPeerRequestDefaultTypeInternal _AddPeerRequest_default_instance_; inline constexpr AddPeerReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : success_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR AddPeerReply::AddPeerReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AddPeerReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR AddPeerReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AddPeerReplyDefaultTypeInternal() {} union { AddPeerReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddPeerReplyDefaultTypeInternal _AddPeerReply_default_instance_; inline constexpr SyncingReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : stages_{}, last_new_block_seen_{::uint64_t{0u}}, frozen_blocks_{::uint64_t{0u}}, current_block_{::uint64_t{0u}}, syncing_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SyncingReply::SyncingReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SyncingReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR SyncingReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SyncingReplyDefaultTypeInternal() {} union { SyncingReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncingReplyDefaultTypeInternal _SyncingReply_default_instance_; inline constexpr PeersReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : peers_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR PeersReply::PeersReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeersReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR PeersReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeersReplyDefaultTypeInternal() {} union { PeersReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeersReplyDefaultTypeInternal _PeersReply_default_instance_; inline constexpr TxnLookupRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, txn_hash_{nullptr} {} template PROTOBUF_CONSTEXPR TxnLookupRequest::TxnLookupRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct TxnLookupRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR TxnLookupRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~TxnLookupRequestDefaultTypeInternal() {} union { TxnLookupRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TxnLookupRequestDefaultTypeInternal _TxnLookupRequest_default_instance_; inline constexpr SubscribeLogsReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, topics_{}, data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), address_{nullptr}, block_hash_{nullptr}, transaction_hash_{nullptr}, block_number_{::uint64_t{0u}}, log_index_{::uint64_t{0u}}, transaction_index_{::uint64_t{0u}}, removed_{false} {} template PROTOBUF_CONSTEXPR SubscribeLogsReply::SubscribeLogsReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SubscribeLogsReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR SubscribeLogsReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SubscribeLogsReplyDefaultTypeInternal() {} union { SubscribeLogsReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscribeLogsReplyDefaultTypeInternal _SubscribeLogsReply_default_instance_; inline constexpr NodesInfoReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : nodes_info_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR NodesInfoReply::NodesInfoReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NodesInfoReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR NodesInfoReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NodesInfoReplyDefaultTypeInternal() {} union { NodesInfoReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NodesInfoReplyDefaultTypeInternal _NodesInfoReply_default_instance_; inline constexpr LogsFilterRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : addresses_{}, topics_{}, all_addresses_{false}, all_topics_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR LogsFilterRequest::LogsFilterRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct LogsFilterRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR LogsFilterRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~LogsFilterRequestDefaultTypeInternal() {} union { LogsFilterRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LogsFilterRequestDefaultTypeInternal _LogsFilterRequest_default_instance_; inline constexpr HeaderNumberRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hash_{nullptr} {} template PROTOBUF_CONSTEXPR HeaderNumberRequest::HeaderNumberRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HeaderNumberRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR HeaderNumberRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HeaderNumberRequestDefaultTypeInternal() {} union { HeaderNumberRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeaderNumberRequestDefaultTypeInternal _HeaderNumberRequest_default_instance_; inline constexpr EtherbaseReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, address_{nullptr} {} template PROTOBUF_CONSTEXPR EtherbaseReply::EtherbaseReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct EtherbaseReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR EtherbaseReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~EtherbaseReplyDefaultTypeInternal() {} union { EtherbaseReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EtherbaseReplyDefaultTypeInternal _EtherbaseReply_default_instance_; inline constexpr EngineGetPayloadBodiesByHashV1Request::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : hashes_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR EngineGetPayloadBodiesByHashV1Request::EngineGetPayloadBodiesByHashV1Request(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct EngineGetPayloadBodiesByHashV1RequestDefaultTypeInternal { PROTOBUF_CONSTEXPR EngineGetPayloadBodiesByHashV1RequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~EngineGetPayloadBodiesByHashV1RequestDefaultTypeInternal() {} union { EngineGetPayloadBodiesByHashV1Request _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EngineGetPayloadBodiesByHashV1RequestDefaultTypeInternal _EngineGetPayloadBodiesByHashV1Request_default_instance_; inline constexpr CanonicalHashReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hash_{nullptr} {} template PROTOBUF_CONSTEXPR CanonicalHashReply::CanonicalHashReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct CanonicalHashReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR CanonicalHashReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~CanonicalHashReplyDefaultTypeInternal() {} union { CanonicalHashReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CanonicalHashReplyDefaultTypeInternal _CanonicalHashReply_default_instance_; inline constexpr BlockRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, block_hash_{nullptr}, block_height_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR BlockRequest::BlockRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR BlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BlockRequestDefaultTypeInternal() {} union { BlockRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockRequestDefaultTypeInternal _BlockRequest_default_instance_; } // namespace remote static const ::_pb::EnumDescriptor* file_level_enum_descriptors_remote_2fethbackend_2eproto[1]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_remote_2fethbackend_2eproto = nullptr; const ::uint32_t TableStruct_remote_2fethbackend_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::EtherbaseRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::EtherbaseReply, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::EtherbaseReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::EtherbaseReply, _impl_.address_), 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::NetVersionRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::NetVersionReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::NetVersionReply, _impl_.id_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::SyncingReply_StageProgress, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::SyncingReply_StageProgress, _impl_.stage_name_), PROTOBUF_FIELD_OFFSET(::remote::SyncingReply_StageProgress, _impl_.block_number_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::SyncingReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::SyncingReply, _impl_.last_new_block_seen_), PROTOBUF_FIELD_OFFSET(::remote::SyncingReply, _impl_.frozen_blocks_), PROTOBUF_FIELD_OFFSET(::remote::SyncingReply, _impl_.current_block_), PROTOBUF_FIELD_OFFSET(::remote::SyncingReply, _impl_.syncing_), PROTOBUF_FIELD_OFFSET(::remote::SyncingReply, _impl_.stages_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::NetPeerCountRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::NetPeerCountReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::NetPeerCountReply, _impl_.count_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::ProtocolVersionRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::ProtocolVersionReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::ProtocolVersionReply, _impl_.id_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::ClientVersionRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::ClientVersionReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::ClientVersionReply, _impl_.node_name_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::CanonicalHashRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::CanonicalHashRequest, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::remote::CanonicalHashReply, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::CanonicalHashReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::CanonicalHashReply, _impl_.hash_), 0, PROTOBUF_FIELD_OFFSET(::remote::HeaderNumberRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::HeaderNumberRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::HeaderNumberRequest, _impl_.hash_), 0, PROTOBUF_FIELD_OFFSET(::remote::HeaderNumberReply, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::HeaderNumberReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::HeaderNumberReply, _impl_.number_), 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::CanonicalBodyForStorageRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::CanonicalBodyForStorageRequest, _impl_.blocknumber_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::CanonicalBodyForStorageReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::CanonicalBodyForStorageReply, _impl_.body_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::SubscribeRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::SubscribeRequest, _impl_.type_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::SubscribeReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::SubscribeReply, _impl_.type_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeReply, _impl_.data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::LogsFilterRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::LogsFilterRequest, _impl_.all_addresses_), PROTOBUF_FIELD_OFFSET(::remote::LogsFilterRequest, _impl_.addresses_), PROTOBUF_FIELD_OFFSET(::remote::LogsFilterRequest, _impl_.all_topics_), PROTOBUF_FIELD_OFFSET(::remote::LogsFilterRequest, _impl_.topics_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.address_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.block_hash_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.data_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.log_index_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.topics_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.transaction_hash_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.transaction_index_), PROTOBUF_FIELD_OFFSET(::remote::SubscribeLogsReply, _impl_.removed_), 0, 1, ~0u, ~0u, ~0u, ~0u, 2, ~0u, ~0u, PROTOBUF_FIELD_OFFSET(::remote::BlockRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::BlockRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BlockRequest, _impl_.block_height_), PROTOBUF_FIELD_OFFSET(::remote::BlockRequest, _impl_.block_hash_), ~0u, 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::BlockReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::BlockReply, _impl_.block_rlp_), PROTOBUF_FIELD_OFFSET(::remote::BlockReply, _impl_.senders_), PROTOBUF_FIELD_OFFSET(::remote::TxnLookupRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::TxnLookupRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::TxnLookupRequest, _impl_.txn_hash_), 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::TxnLookupReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::TxnLookupReply, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::remote::TxnLookupReply, _impl_.tx_number_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::NodesInfoRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::NodesInfoRequest, _impl_.limit_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::AddPeerRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::AddPeerRequest, _impl_.url_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::NodesInfoReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::NodesInfoReply, _impl_.nodes_info_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::PeersReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::PeersReply, _impl_.peers_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::AddPeerReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::AddPeerReply, _impl_.success_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::PendingBlockReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::PendingBlockReply, _impl_.block_rlp_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::EngineGetPayloadBodiesByHashV1Request, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::EngineGetPayloadBodiesByHashV1Request, _impl_.hashes_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::EngineGetPayloadBodiesByRangeV1Request, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::EngineGetPayloadBodiesByRangeV1Request, _impl_.start_), PROTOBUF_FIELD_OFFSET(::remote::EngineGetPayloadBodiesByRangeV1Request, _impl_.count_), }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::remote::EtherbaseRequest)}, {8, 17, -1, sizeof(::remote::EtherbaseReply)}, {18, -1, -1, sizeof(::remote::NetVersionRequest)}, {26, -1, -1, sizeof(::remote::NetVersionReply)}, {35, -1, -1, sizeof(::remote::SyncingReply_StageProgress)}, {45, -1, -1, sizeof(::remote::SyncingReply)}, {58, -1, -1, sizeof(::remote::NetPeerCountRequest)}, {66, -1, -1, sizeof(::remote::NetPeerCountReply)}, {75, -1, -1, sizeof(::remote::ProtocolVersionRequest)}, {83, -1, -1, sizeof(::remote::ProtocolVersionReply)}, {92, -1, -1, sizeof(::remote::ClientVersionRequest)}, {100, -1, -1, sizeof(::remote::ClientVersionReply)}, {109, -1, -1, sizeof(::remote::CanonicalHashRequest)}, {118, 127, -1, sizeof(::remote::CanonicalHashReply)}, {128, 137, -1, sizeof(::remote::HeaderNumberRequest)}, {138, 147, -1, sizeof(::remote::HeaderNumberReply)}, {148, -1, -1, sizeof(::remote::CanonicalBodyForStorageRequest)}, {157, -1, -1, sizeof(::remote::CanonicalBodyForStorageReply)}, {166, -1, -1, sizeof(::remote::SubscribeRequest)}, {175, -1, -1, sizeof(::remote::SubscribeReply)}, {185, -1, -1, sizeof(::remote::LogsFilterRequest)}, {197, 214, -1, sizeof(::remote::SubscribeLogsReply)}, {223, 233, -1, sizeof(::remote::BlockRequest)}, {235, -1, -1, sizeof(::remote::BlockReply)}, {245, 254, -1, sizeof(::remote::TxnLookupRequest)}, {255, -1, -1, sizeof(::remote::TxnLookupReply)}, {265, -1, -1, sizeof(::remote::NodesInfoRequest)}, {274, -1, -1, sizeof(::remote::AddPeerRequest)}, {283, -1, -1, sizeof(::remote::NodesInfoReply)}, {292, -1, -1, sizeof(::remote::PeersReply)}, {301, -1, -1, sizeof(::remote::AddPeerReply)}, {310, -1, -1, sizeof(::remote::PendingBlockReply)}, {319, -1, -1, sizeof(::remote::EngineGetPayloadBodiesByHashV1Request)}, {328, -1, -1, sizeof(::remote::EngineGetPayloadBodiesByRangeV1Request)}, }; static const ::_pb::Message* const file_default_instances[] = { &::remote::_EtherbaseRequest_default_instance_._instance, &::remote::_EtherbaseReply_default_instance_._instance, &::remote::_NetVersionRequest_default_instance_._instance, &::remote::_NetVersionReply_default_instance_._instance, &::remote::_SyncingReply_StageProgress_default_instance_._instance, &::remote::_SyncingReply_default_instance_._instance, &::remote::_NetPeerCountRequest_default_instance_._instance, &::remote::_NetPeerCountReply_default_instance_._instance, &::remote::_ProtocolVersionRequest_default_instance_._instance, &::remote::_ProtocolVersionReply_default_instance_._instance, &::remote::_ClientVersionRequest_default_instance_._instance, &::remote::_ClientVersionReply_default_instance_._instance, &::remote::_CanonicalHashRequest_default_instance_._instance, &::remote::_CanonicalHashReply_default_instance_._instance, &::remote::_HeaderNumberRequest_default_instance_._instance, &::remote::_HeaderNumberReply_default_instance_._instance, &::remote::_CanonicalBodyForStorageRequest_default_instance_._instance, &::remote::_CanonicalBodyForStorageReply_default_instance_._instance, &::remote::_SubscribeRequest_default_instance_._instance, &::remote::_SubscribeReply_default_instance_._instance, &::remote::_LogsFilterRequest_default_instance_._instance, &::remote::_SubscribeLogsReply_default_instance_._instance, &::remote::_BlockRequest_default_instance_._instance, &::remote::_BlockReply_default_instance_._instance, &::remote::_TxnLookupRequest_default_instance_._instance, &::remote::_TxnLookupReply_default_instance_._instance, &::remote::_NodesInfoRequest_default_instance_._instance, &::remote::_AddPeerRequest_default_instance_._instance, &::remote::_NodesInfoReply_default_instance_._instance, &::remote::_PeersReply_default_instance_._instance, &::remote::_AddPeerReply_default_instance_._instance, &::remote::_PendingBlockReply_default_instance_._instance, &::remote::_EngineGetPayloadBodiesByHashV1Request_default_instance_._instance, &::remote::_EngineGetPayloadBodiesByRangeV1Request_default_instance_._instance, }; const char descriptor_table_protodef_remote_2fethbackend_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\027remote/ethbackend.proto\022\006remote\032\033googl" "e/protobuf/empty.proto\032\021types/types.prot" "o\032\020remote/bor.proto\"\022\n\020EtherbaseRequest\"" ".\n\016EtherbaseReply\022\034\n\007address\030\001 \001(\0132\013.typ" "es.H160\"\023\n\021NetVersionRequest\"\035\n\017NetVersi" "onReply\022\n\n\002id\030\001 \001(\004\"\331\001\n\014SyncingReply\022\033\n\023" "last_new_block_seen\030\001 \001(\004\022\025\n\rfrozen_bloc" "ks\030\002 \001(\004\022\025\n\rcurrent_block\030\003 \001(\004\022\017\n\007synci" "ng\030\004 \001(\010\0222\n\006stages\030\005 \003(\0132\".remote.Syncin" "gReply.StageProgress\0329\n\rStageProgress\022\022\n" "\nstage_name\030\001 \001(\t\022\024\n\014block_number\030\002 \001(\004\"" "\025\n\023NetPeerCountRequest\"\"\n\021NetPeerCountRe" "ply\022\r\n\005count\030\001 \001(\004\"\030\n\026ProtocolVersionReq" "uest\"\"\n\024ProtocolVersionReply\022\n\n\002id\030\001 \001(\004" "\"\026\n\024ClientVersionRequest\"\'\n\022ClientVersio" "nReply\022\021\n\tnode_name\030\001 \001(\t\",\n\024CanonicalHa" "shRequest\022\024\n\014block_number\030\001 \001(\004\"/\n\022Canon" "icalHashReply\022\031\n\004hash\030\001 \001(\0132\013.types.H256" "\"0\n\023HeaderNumberRequest\022\031\n\004hash\030\001 \001(\0132\013." "types.H256\"3\n\021HeaderNumberReply\022\023\n\006numbe" "r\030\001 \001(\004H\000\210\001\001B\t\n\007_number\"5\n\036CanonicalBody" "ForStorageRequest\022\023\n\013blockNumber\030\001 \001(\004\"," "\n\034CanonicalBodyForStorageReply\022\014\n\004body\030\001" " \001(\014\"/\n\020SubscribeRequest\022\033\n\004type\030\001 \001(\0162\r" ".remote.Event\";\n\016SubscribeReply\022\033\n\004type\030" "\001 \001(\0162\r.remote.Event\022\014\n\004data\030\002 \001(\014\"{\n\021Lo" "gsFilterRequest\022\025\n\rall_addresses\030\001 \001(\010\022\036" "\n\taddresses\030\002 \003(\0132\013.types.H160\022\022\n\nall_to" "pics\030\003 \001(\010\022\033\n\006topics\030\004 \003(\0132\013.types.H256\"" "\372\001\n\022SubscribeLogsReply\022\034\n\007address\030\001 \001(\0132" "\013.types.H160\022\037\n\nblock_hash\030\002 \001(\0132\013.types" ".H256\022\024\n\014block_number\030\003 \001(\004\022\014\n\004data\030\004 \001(" "\014\022\021\n\tlog_index\030\005 \001(\004\022\033\n\006topics\030\006 \003(\0132\013.t" "ypes.H256\022%\n\020transaction_hash\030\007 \001(\0132\013.ty" "pes.H256\022\031\n\021transaction_index\030\010 \001(\004\022\017\n\007r" "emoved\030\t \001(\010\"E\n\014BlockRequest\022\024\n\014block_he" "ight\030\002 \001(\004\022\037\n\nblock_hash\030\003 \001(\0132\013.types.H" "256\"0\n\nBlockReply\022\021\n\tblock_rlp\030\001 \001(\014\022\017\n\007" "senders\030\002 \001(\014\"1\n\020TxnLookupRequest\022\035\n\010txn" "_hash\030\001 \001(\0132\013.types.H256\"9\n\016TxnLookupRep" "ly\022\024\n\014block_number\030\001 \001(\004\022\021\n\ttx_number\030\002 " "\001(\004\"!\n\020NodesInfoRequest\022\r\n\005limit\030\001 \001(\r\"\035" "\n\016AddPeerRequest\022\013\n\003url\030\001 \001(\t\":\n\016NodesIn" "foReply\022(\n\nnodes_info\030\001 \003(\0132\024.types.Node" "InfoReply\",\n\nPeersReply\022\036\n\005peers\030\001 \003(\0132\017" ".types.PeerInfo\"\037\n\014AddPeerReply\022\017\n\007succe" "ss\030\001 \001(\010\"&\n\021PendingBlockReply\022\021\n\tblock_r" "lp\030\001 \001(\014\"D\n%EngineGetPayloadBodiesByHash" "V1Request\022\033\n\006hashes\030\001 \003(\0132\013.types.H256\"F" "\n&EngineGetPayloadBodiesByRangeV1Request" "\022\r\n\005start\030\001 \001(\004\022\r\n\005count\030\002 \001(\004*J\n\005Event\022" "\n\n\006HEADER\020\000\022\020\n\014PENDING_LOGS\020\001\022\021\n\rPENDING" "_BLOCK\020\002\022\020\n\014NEW_SNAPSHOT\020\0032\323\n\n\nETHBACKEN" "D\022=\n\tEtherbase\022\030.remote.EtherbaseRequest" "\032\026.remote.EtherbaseReply\022@\n\nNetVersion\022\031" ".remote.NetVersionRequest\032\027.remote.NetVe" "rsionReply\022F\n\014NetPeerCount\022\033.remote.NetP" "eerCountRequest\032\031.remote.NetPeerCountRep" "ly\0226\n\007Version\022\026.google.protobuf.Empty\032\023." "types.VersionReply\0227\n\007Syncing\022\026.google.p" "rotobuf.Empty\032\024.remote.SyncingReply\022O\n\017P" "rotocolVersion\022\036.remote.ProtocolVersionR" "equest\032\034.remote.ProtocolVersionReply\022I\n\r" "ClientVersion\022\034.remote.ClientVersionRequ" "est\032\032.remote.ClientVersionReply\022\?\n\tSubsc" "ribe\022\030.remote.SubscribeRequest\032\026.remote." "SubscribeReply0\001\022J\n\rSubscribeLogs\022\031.remo" "te.LogsFilterRequest\032\032.remote.SubscribeL" "ogsReply(\0010\001\0221\n\005Block\022\024.remote.BlockRequ" "est\032\022.remote.BlockReply\022g\n\027CanonicalBody" "ForStorage\022&.remote.CanonicalBodyForStor" "ageRequest\032$.remote.CanonicalBodyForStor" "ageReply\022I\n\rCanonicalHash\022\034.remote.Canon" "icalHashRequest\032\032.remote.CanonicalHashRe" "ply\022F\n\014HeaderNumber\022\033.remote.HeaderNumbe" "rRequest\032\031.remote.HeaderNumberReply\022=\n\tT" "xnLookup\022\030.remote.TxnLookupRequest\032\026.rem" "ote.TxnLookupReply\022<\n\010NodeInfo\022\030.remote." "NodesInfoRequest\032\026.remote.NodesInfoReply" "\0223\n\005Peers\022\026.google.protobuf.Empty\032\022.remo" "te.PeersReply\0227\n\007AddPeer\022\026.remote.AddPee" "rRequest\032\024.remote.AddPeerReply\022A\n\014Pendin" "gBlock\022\026.google.protobuf.Empty\032\031.remote." "PendingBlockReply\022F\n\014BorTxnLookup\022\033.remo" "te.BorTxnLookupRequest\032\031.remote.BorTxnLo" "okupReply\022=\n\tBorEvents\022\030.remote.BorEvent" "sRequest\032\026.remote.BorEventsReplyB\026Z\024./re" "mote;remoteprotob\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_remote_2fethbackend_2eproto_deps[3] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_remote_2fbor_2eproto, &::descriptor_table_types_2ftypes_2eproto, }; static ::absl::once_flag descriptor_table_remote_2fethbackend_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_remote_2fethbackend_2eproto = { false, false, 3504, descriptor_table_protodef_remote_2fethbackend_2eproto, "remote/ethbackend.proto", &descriptor_table_remote_2fethbackend_2eproto_once, descriptor_table_remote_2fethbackend_2eproto_deps, 3, 34, schemas, file_default_instances, TableStruct_remote_2fethbackend_2eproto::offsets, file_level_enum_descriptors_remote_2fethbackend_2eproto, file_level_service_descriptors_remote_2fethbackend_2eproto, }; namespace remote { const ::google::protobuf::EnumDescriptor* Event_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_remote_2fethbackend_2eproto); return file_level_enum_descriptors_remote_2fethbackend_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t Event_internal_data_[] = { 262144u, 0u, }; bool Event_IsValid(int value) { return 0 <= value && value <= 3; } // =================================================================== class EtherbaseRequest::_Internal { public: }; EtherbaseRequest::EtherbaseRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:remote.EtherbaseRequest) } EtherbaseRequest::EtherbaseRequest( ::google::protobuf::Arena* arena, const EtherbaseRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { EtherbaseRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:remote.EtherbaseRequest) } const ::google::protobuf::MessageLite::ClassData* EtherbaseRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(EtherbaseRequest, _impl_._cached_size_), false, }, &EtherbaseRequest::MergeImpl, &EtherbaseRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> EtherbaseRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_EtherbaseRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::EtherbaseRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata EtherbaseRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class EtherbaseReply::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(EtherbaseReply, _impl_._has_bits_); }; void EtherbaseReply::clear_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ != nullptr) _impl_.address_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } EtherbaseReply::EtherbaseReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.EtherbaseReply) } inline PROTOBUF_NDEBUG_INLINE EtherbaseReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::EtherbaseReply& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} EtherbaseReply::EtherbaseReply( ::google::protobuf::Arena* arena, const EtherbaseReply& from) : ::google::protobuf::Message(arena) { EtherbaseReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.address_) : nullptr; // @@protoc_insertion_point(copy_constructor:remote.EtherbaseReply) } inline PROTOBUF_NDEBUG_INLINE EtherbaseReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void EtherbaseReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.address_ = {}; } EtherbaseReply::~EtherbaseReply() { // @@protoc_insertion_point(destructor:remote.EtherbaseReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void EtherbaseReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.address_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* EtherbaseReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(EtherbaseReply, _impl_._cached_size_), false, }, &EtherbaseReply::MergeImpl, &EtherbaseReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> EtherbaseReply::_table_ = { { PROTOBUF_FIELD_OFFSET(EtherbaseReply, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_EtherbaseReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::EtherbaseReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H160 address = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(EtherbaseReply, _impl_.address_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H160 address = 1; {PROTOBUF_FIELD_OFFSET(EtherbaseReply, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void EtherbaseReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.EtherbaseReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.address_ != nullptr); _impl_.address_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* EtherbaseReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.EtherbaseReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H160 address = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.address_, _impl_.address_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.EtherbaseReply) return target; } ::size_t EtherbaseReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.EtherbaseReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .types.H160 address = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.address_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void EtherbaseReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.EtherbaseReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.address_ != nullptr); if (_this->_impl_.address_ == nullptr) { _this->_impl_.address_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.address_); } else { _this->_impl_.address_->MergeFrom(*from._impl_.address_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void EtherbaseReply::CopyFrom(const EtherbaseReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.EtherbaseReply) if (&from == this) return; Clear(); MergeFrom(from); } void EtherbaseReply::InternalSwap(EtherbaseReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.address_, other->_impl_.address_); } ::google::protobuf::Metadata EtherbaseReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NetVersionRequest::_Internal { public: }; NetVersionRequest::NetVersionRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:remote.NetVersionRequest) } NetVersionRequest::NetVersionRequest( ::google::protobuf::Arena* arena, const NetVersionRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { NetVersionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:remote.NetVersionRequest) } const ::google::protobuf::MessageLite::ClassData* NetVersionRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NetVersionRequest, _impl_._cached_size_), false, }, &NetVersionRequest::MergeImpl, &NetVersionRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> NetVersionRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_NetVersionRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::NetVersionRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata NetVersionRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NetVersionReply::_Internal { public: }; NetVersionReply::NetVersionReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.NetVersionReply) } NetVersionReply::NetVersionReply( ::google::protobuf::Arena* arena, const NetVersionReply& from) : NetVersionReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE NetVersionReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void NetVersionReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.id_ = {}; } NetVersionReply::~NetVersionReply() { // @@protoc_insertion_point(destructor:remote.NetVersionReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NetVersionReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NetVersionReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NetVersionReply, _impl_._cached_size_), false, }, &NetVersionReply::MergeImpl, &NetVersionReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> NetVersionReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_NetVersionReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::NetVersionReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(NetVersionReply, _impl_.id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(NetVersionReply, _impl_.id_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 id = 1; {PROTOBUF_FIELD_OFFSET(NetVersionReply, _impl_.id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void NetVersionReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.NetVersionReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.id_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NetVersionReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.NetVersionReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_id(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.NetVersionReply) return target; } ::size_t NetVersionReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.NetVersionReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_id()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NetVersionReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.NetVersionReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_id() != 0) { _this->_impl_.id_ = from._impl_.id_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NetVersionReply::CopyFrom(const NetVersionReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.NetVersionReply) if (&from == this) return; Clear(); MergeFrom(from); } void NetVersionReply::InternalSwap(NetVersionReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.id_, other->_impl_.id_); } ::google::protobuf::Metadata NetVersionReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SyncingReply_StageProgress::_Internal { public: }; SyncingReply_StageProgress::SyncingReply_StageProgress(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.SyncingReply.StageProgress) } inline PROTOBUF_NDEBUG_INLINE SyncingReply_StageProgress::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::SyncingReply_StageProgress& from_msg) : stage_name_(arena, from.stage_name_), _cached_size_{0} {} SyncingReply_StageProgress::SyncingReply_StageProgress( ::google::protobuf::Arena* arena, const SyncingReply_StageProgress& from) : ::google::protobuf::Message(arena) { SyncingReply_StageProgress* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.block_number_ = from._impl_.block_number_; // @@protoc_insertion_point(copy_constructor:remote.SyncingReply.StageProgress) } inline PROTOBUF_NDEBUG_INLINE SyncingReply_StageProgress::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : stage_name_(arena), _cached_size_{0} {} inline void SyncingReply_StageProgress::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.block_number_ = {}; } SyncingReply_StageProgress::~SyncingReply_StageProgress() { // @@protoc_insertion_point(destructor:remote.SyncingReply.StageProgress) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SyncingReply_StageProgress::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.stage_name_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SyncingReply_StageProgress::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SyncingReply_StageProgress, _impl_._cached_size_), false, }, &SyncingReply_StageProgress::MergeImpl, &SyncingReply_StageProgress::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 52, 2> SyncingReply_StageProgress::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SyncingReply_StageProgress_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::SyncingReply_StageProgress>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 block_number = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SyncingReply_StageProgress, _impl_.block_number_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(SyncingReply_StageProgress, _impl_.block_number_)}}, // string stage_name = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(SyncingReply_StageProgress, _impl_.stage_name_)}}, }}, {{ 65535, 65535 }}, {{ // string stage_name = 1; {PROTOBUF_FIELD_OFFSET(SyncingReply_StageProgress, _impl_.stage_name_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint64 block_number = 2; {PROTOBUF_FIELD_OFFSET(SyncingReply_StageProgress, _impl_.block_number_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ "\41\12\0\0\0\0\0\0" "remote.SyncingReply.StageProgress" "stage_name" }}, }; PROTOBUF_NOINLINE void SyncingReply_StageProgress::Clear() { // @@protoc_insertion_point(message_clear_start:remote.SyncingReply.StageProgress) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.stage_name_.ClearToEmpty(); _impl_.block_number_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SyncingReply_StageProgress::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.SyncingReply.StageProgress) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string stage_name = 1; if (!this->_internal_stage_name().empty()) { const std::string& _s = this->_internal_stage_name(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.SyncingReply.StageProgress.stage_name"); target = stream->WriteStringMaybeAliased(1, _s, target); } // uint64 block_number = 2; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_block_number(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.SyncingReply.StageProgress) return target; } ::size_t SyncingReply_StageProgress::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.SyncingReply.StageProgress) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string stage_name = 1; if (!this->_internal_stage_name().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_stage_name()); } // uint64 block_number = 2; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SyncingReply_StageProgress::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.SyncingReply.StageProgress) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_stage_name().empty()) { _this->_internal_set_stage_name(from._internal_stage_name()); } if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SyncingReply_StageProgress::CopyFrom(const SyncingReply_StageProgress& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.SyncingReply.StageProgress) if (&from == this) return; Clear(); MergeFrom(from); } void SyncingReply_StageProgress::InternalSwap(SyncingReply_StageProgress* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.stage_name_, &other->_impl_.stage_name_, arena); swap(_impl_.block_number_, other->_impl_.block_number_); } ::google::protobuf::Metadata SyncingReply_StageProgress::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SyncingReply::_Internal { public: }; SyncingReply::SyncingReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.SyncingReply) } inline PROTOBUF_NDEBUG_INLINE SyncingReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::SyncingReply& from_msg) : stages_{visibility, arena, from.stages_}, _cached_size_{0} {} SyncingReply::SyncingReply( ::google::protobuf::Arena* arena, const SyncingReply& from) : ::google::protobuf::Message(arena) { SyncingReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, last_new_block_seen_), reinterpret_cast(&from._impl_) + offsetof(Impl_, last_new_block_seen_), offsetof(Impl_, syncing_) - offsetof(Impl_, last_new_block_seen_) + sizeof(Impl_::syncing_)); // @@protoc_insertion_point(copy_constructor:remote.SyncingReply) } inline PROTOBUF_NDEBUG_INLINE SyncingReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : stages_{visibility, arena}, _cached_size_{0} {} inline void SyncingReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, last_new_block_seen_), 0, offsetof(Impl_, syncing_) - offsetof(Impl_, last_new_block_seen_) + sizeof(Impl_::syncing_)); } SyncingReply::~SyncingReply() { // @@protoc_insertion_point(destructor:remote.SyncingReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SyncingReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SyncingReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_._cached_size_), false, }, &SyncingReply::MergeImpl, &SyncingReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 5, 1, 0, 2> SyncingReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 5, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967264, // skipmap offsetof(decltype(_table_), field_entries), 5, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_SyncingReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::SyncingReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint64 last_new_block_seen = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SyncingReply, _impl_.last_new_block_seen_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.last_new_block_seen_)}}, // uint64 frozen_blocks = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SyncingReply, _impl_.frozen_blocks_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.frozen_blocks_)}}, // uint64 current_block = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SyncingReply, _impl_.current_block_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.current_block_)}}, // bool syncing = 4; {::_pbi::TcParser::SingularVarintNoZag1(), {32, 63, 0, PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.syncing_)}}, // repeated .remote.SyncingReply.StageProgress stages = 5; {::_pbi::TcParser::FastMtR1, {42, 63, 0, PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.stages_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint64 last_new_block_seen = 1; {PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.last_new_block_seen_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 frozen_blocks = 2; {PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.frozen_blocks_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 current_block = 3; {PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.current_block_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bool syncing = 4; {PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.syncing_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // repeated .remote.SyncingReply.StageProgress stages = 5; {PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.stages_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::remote::SyncingReply_StageProgress>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void SyncingReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.SyncingReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.stages_.Clear(); ::memset(&_impl_.last_new_block_seen_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.syncing_) - reinterpret_cast(&_impl_.last_new_block_seen_)) + sizeof(_impl_.syncing_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SyncingReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.SyncingReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 last_new_block_seen = 1; if (this->_internal_last_new_block_seen() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_last_new_block_seen(), target); } // uint64 frozen_blocks = 2; if (this->_internal_frozen_blocks() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_frozen_blocks(), target); } // uint64 current_block = 3; if (this->_internal_current_block() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 3, this->_internal_current_block(), target); } // bool syncing = 4; if (this->_internal_syncing() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 4, this->_internal_syncing(), target); } // repeated .remote.SyncingReply.StageProgress stages = 5; for (unsigned i = 0, n = static_cast( this->_internal_stages_size()); i < n; i++) { const auto& repfield = this->_internal_stages().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 5, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.SyncingReply) return target; } ::size_t SyncingReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.SyncingReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .remote.SyncingReply.StageProgress stages = 5; total_size += 1UL * this->_internal_stages_size(); for (const auto& msg : this->_internal_stages()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // uint64 last_new_block_seen = 1; if (this->_internal_last_new_block_seen() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_last_new_block_seen()); } // uint64 frozen_blocks = 2; if (this->_internal_frozen_blocks() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_frozen_blocks()); } // uint64 current_block = 3; if (this->_internal_current_block() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_current_block()); } // bool syncing = 4; if (this->_internal_syncing() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SyncingReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.SyncingReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_stages()->MergeFrom( from._internal_stages()); if (from._internal_last_new_block_seen() != 0) { _this->_impl_.last_new_block_seen_ = from._impl_.last_new_block_seen_; } if (from._internal_frozen_blocks() != 0) { _this->_impl_.frozen_blocks_ = from._impl_.frozen_blocks_; } if (from._internal_current_block() != 0) { _this->_impl_.current_block_ = from._impl_.current_block_; } if (from._internal_syncing() != 0) { _this->_impl_.syncing_ = from._impl_.syncing_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SyncingReply::CopyFrom(const SyncingReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.SyncingReply) if (&from == this) return; Clear(); MergeFrom(from); } void SyncingReply::InternalSwap(SyncingReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.stages_.InternalSwap(&other->_impl_.stages_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.syncing_) + sizeof(SyncingReply::_impl_.syncing_) - PROTOBUF_FIELD_OFFSET(SyncingReply, _impl_.last_new_block_seen_)>( reinterpret_cast(&_impl_.last_new_block_seen_), reinterpret_cast(&other->_impl_.last_new_block_seen_)); } ::google::protobuf::Metadata SyncingReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NetPeerCountRequest::_Internal { public: }; NetPeerCountRequest::NetPeerCountRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:remote.NetPeerCountRequest) } NetPeerCountRequest::NetPeerCountRequest( ::google::protobuf::Arena* arena, const NetPeerCountRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { NetPeerCountRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:remote.NetPeerCountRequest) } const ::google::protobuf::MessageLite::ClassData* NetPeerCountRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NetPeerCountRequest, _impl_._cached_size_), false, }, &NetPeerCountRequest::MergeImpl, &NetPeerCountRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> NetPeerCountRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_NetPeerCountRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::NetPeerCountRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata NetPeerCountRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NetPeerCountReply::_Internal { public: }; NetPeerCountReply::NetPeerCountReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.NetPeerCountReply) } NetPeerCountReply::NetPeerCountReply( ::google::protobuf::Arena* arena, const NetPeerCountReply& from) : NetPeerCountReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE NetPeerCountReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void NetPeerCountReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.count_ = {}; } NetPeerCountReply::~NetPeerCountReply() { // @@protoc_insertion_point(destructor:remote.NetPeerCountReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NetPeerCountReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NetPeerCountReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NetPeerCountReply, _impl_._cached_size_), false, }, &NetPeerCountReply::MergeImpl, &NetPeerCountReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> NetPeerCountReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_NetPeerCountReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::NetPeerCountReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 count = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(NetPeerCountReply, _impl_.count_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(NetPeerCountReply, _impl_.count_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 count = 1; {PROTOBUF_FIELD_OFFSET(NetPeerCountReply, _impl_.count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void NetPeerCountReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.NetPeerCountReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.count_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NetPeerCountReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.NetPeerCountReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 count = 1; if (this->_internal_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_count(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.NetPeerCountReply) return target; } ::size_t NetPeerCountReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.NetPeerCountReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 count = 1; if (this->_internal_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_count()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NetPeerCountReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.NetPeerCountReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_count() != 0) { _this->_impl_.count_ = from._impl_.count_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NetPeerCountReply::CopyFrom(const NetPeerCountReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.NetPeerCountReply) if (&from == this) return; Clear(); MergeFrom(from); } void NetPeerCountReply::InternalSwap(NetPeerCountReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.count_, other->_impl_.count_); } ::google::protobuf::Metadata NetPeerCountReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ProtocolVersionRequest::_Internal { public: }; ProtocolVersionRequest::ProtocolVersionRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:remote.ProtocolVersionRequest) } ProtocolVersionRequest::ProtocolVersionRequest( ::google::protobuf::Arena* arena, const ProtocolVersionRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { ProtocolVersionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:remote.ProtocolVersionRequest) } const ::google::protobuf::MessageLite::ClassData* ProtocolVersionRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ProtocolVersionRequest, _impl_._cached_size_), false, }, &ProtocolVersionRequest::MergeImpl, &ProtocolVersionRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ProtocolVersionRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_ProtocolVersionRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::ProtocolVersionRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata ProtocolVersionRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ProtocolVersionReply::_Internal { public: }; ProtocolVersionReply::ProtocolVersionReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.ProtocolVersionReply) } ProtocolVersionReply::ProtocolVersionReply( ::google::protobuf::Arena* arena, const ProtocolVersionReply& from) : ProtocolVersionReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE ProtocolVersionReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void ProtocolVersionReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.id_ = {}; } ProtocolVersionReply::~ProtocolVersionReply() { // @@protoc_insertion_point(destructor:remote.ProtocolVersionReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ProtocolVersionReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ProtocolVersionReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ProtocolVersionReply, _impl_._cached_size_), false, }, &ProtocolVersionReply::MergeImpl, &ProtocolVersionReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> ProtocolVersionReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_ProtocolVersionReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::ProtocolVersionReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ProtocolVersionReply, _impl_.id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(ProtocolVersionReply, _impl_.id_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 id = 1; {PROTOBUF_FIELD_OFFSET(ProtocolVersionReply, _impl_.id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void ProtocolVersionReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.ProtocolVersionReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.id_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ProtocolVersionReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.ProtocolVersionReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_id(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.ProtocolVersionReply) return target; } ::size_t ProtocolVersionReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.ProtocolVersionReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 id = 1; if (this->_internal_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_id()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ProtocolVersionReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.ProtocolVersionReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_id() != 0) { _this->_impl_.id_ = from._impl_.id_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ProtocolVersionReply::CopyFrom(const ProtocolVersionReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.ProtocolVersionReply) if (&from == this) return; Clear(); MergeFrom(from); } void ProtocolVersionReply::InternalSwap(ProtocolVersionReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.id_, other->_impl_.id_); } ::google::protobuf::Metadata ProtocolVersionReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClientVersionRequest::_Internal { public: }; ClientVersionRequest::ClientVersionRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:remote.ClientVersionRequest) } ClientVersionRequest::ClientVersionRequest( ::google::protobuf::Arena* arena, const ClientVersionRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { ClientVersionRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:remote.ClientVersionRequest) } const ::google::protobuf::MessageLite::ClassData* ClientVersionRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ClientVersionRequest, _impl_._cached_size_), false, }, &ClientVersionRequest::MergeImpl, &ClientVersionRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ClientVersionRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_ClientVersionRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::ClientVersionRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata ClientVersionRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ClientVersionReply::_Internal { public: }; ClientVersionReply::ClientVersionReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.ClientVersionReply) } inline PROTOBUF_NDEBUG_INLINE ClientVersionReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::ClientVersionReply& from_msg) : node_name_(arena, from.node_name_), _cached_size_{0} {} ClientVersionReply::ClientVersionReply( ::google::protobuf::Arena* arena, const ClientVersionReply& from) : ::google::protobuf::Message(arena) { ClientVersionReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.ClientVersionReply) } inline PROTOBUF_NDEBUG_INLINE ClientVersionReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : node_name_(arena), _cached_size_{0} {} inline void ClientVersionReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ClientVersionReply::~ClientVersionReply() { // @@protoc_insertion_point(destructor:remote.ClientVersionReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ClientVersionReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.node_name_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ClientVersionReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ClientVersionReply, _impl_._cached_size_), false, }, &ClientVersionReply::MergeImpl, &ClientVersionReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 43, 2> ClientVersionReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_ClientVersionReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::ClientVersionReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // string node_name = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(ClientVersionReply, _impl_.node_name_)}}, }}, {{ 65535, 65535 }}, {{ // string node_name = 1; {PROTOBUF_FIELD_OFFSET(ClientVersionReply, _impl_.node_name_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\31\11\0\0\0\0\0\0" "remote.ClientVersionReply" "node_name" }}, }; PROTOBUF_NOINLINE void ClientVersionReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.ClientVersionReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.node_name_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ClientVersionReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.ClientVersionReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string node_name = 1; if (!this->_internal_node_name().empty()) { const std::string& _s = this->_internal_node_name(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.ClientVersionReply.node_name"); target = stream->WriteStringMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.ClientVersionReply) return target; } ::size_t ClientVersionReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.ClientVersionReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string node_name = 1; if (!this->_internal_node_name().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_node_name()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ClientVersionReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.ClientVersionReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_node_name().empty()) { _this->_internal_set_node_name(from._internal_node_name()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ClientVersionReply::CopyFrom(const ClientVersionReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.ClientVersionReply) if (&from == this) return; Clear(); MergeFrom(from); } void ClientVersionReply::InternalSwap(ClientVersionReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.node_name_, &other->_impl_.node_name_, arena); } ::google::protobuf::Metadata ClientVersionReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class CanonicalHashRequest::_Internal { public: }; CanonicalHashRequest::CanonicalHashRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.CanonicalHashRequest) } CanonicalHashRequest::CanonicalHashRequest( ::google::protobuf::Arena* arena, const CanonicalHashRequest& from) : CanonicalHashRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE CanonicalHashRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void CanonicalHashRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.block_number_ = {}; } CanonicalHashRequest::~CanonicalHashRequest() { // @@protoc_insertion_point(destructor:remote.CanonicalHashRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void CanonicalHashRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* CanonicalHashRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(CanonicalHashRequest, _impl_._cached_size_), false, }, &CanonicalHashRequest::MergeImpl, &CanonicalHashRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CanonicalHashRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_CanonicalHashRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::CanonicalHashRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 block_number = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(CanonicalHashRequest, _impl_.block_number_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(CanonicalHashRequest, _impl_.block_number_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 block_number = 1; {PROTOBUF_FIELD_OFFSET(CanonicalHashRequest, _impl_.block_number_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void CanonicalHashRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.CanonicalHashRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.block_number_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* CanonicalHashRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.CanonicalHashRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 block_number = 1; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_block_number(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.CanonicalHashRequest) return target; } ::size_t CanonicalHashRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.CanonicalHashRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 block_number = 1; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void CanonicalHashRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.CanonicalHashRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void CanonicalHashRequest::CopyFrom(const CanonicalHashRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.CanonicalHashRequest) if (&from == this) return; Clear(); MergeFrom(from); } void CanonicalHashRequest::InternalSwap(CanonicalHashRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.block_number_, other->_impl_.block_number_); } ::google::protobuf::Metadata CanonicalHashRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class CanonicalHashReply::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(CanonicalHashReply, _impl_._has_bits_); }; void CanonicalHashReply::clear_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hash_ != nullptr) _impl_.hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } CanonicalHashReply::CanonicalHashReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.CanonicalHashReply) } inline PROTOBUF_NDEBUG_INLINE CanonicalHashReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::CanonicalHashReply& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} CanonicalHashReply::CanonicalHashReply( ::google::protobuf::Arena* arena, const CanonicalHashReply& from) : ::google::protobuf::Message(arena) { CanonicalHashReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.hash_) : nullptr; // @@protoc_insertion_point(copy_constructor:remote.CanonicalHashReply) } inline PROTOBUF_NDEBUG_INLINE CanonicalHashReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void CanonicalHashReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.hash_ = {}; } CanonicalHashReply::~CanonicalHashReply() { // @@protoc_insertion_point(destructor:remote.CanonicalHashReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void CanonicalHashReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* CanonicalHashReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(CanonicalHashReply, _impl_._cached_size_), false, }, &CanonicalHashReply::MergeImpl, &CanonicalHashReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> CanonicalHashReply::_table_ = { { PROTOBUF_FIELD_OFFSET(CanonicalHashReply, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_CanonicalHashReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::CanonicalHashReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H256 hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(CanonicalHashReply, _impl_.hash_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 hash = 1; {PROTOBUF_FIELD_OFFSET(CanonicalHashReply, _impl_.hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void CanonicalHashReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.CanonicalHashReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hash_ != nullptr); _impl_.hash_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* CanonicalHashReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.CanonicalHashReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hash_, _impl_.hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.CanonicalHashReply) return target; } ::size_t CanonicalHashReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.CanonicalHashReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .types.H256 hash = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hash_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void CanonicalHashReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.CanonicalHashReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hash_ != nullptr); if (_this->_impl_.hash_ == nullptr) { _this->_impl_.hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.hash_); } else { _this->_impl_.hash_->MergeFrom(*from._impl_.hash_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void CanonicalHashReply::CopyFrom(const CanonicalHashReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.CanonicalHashReply) if (&from == this) return; Clear(); MergeFrom(from); } void CanonicalHashReply::InternalSwap(CanonicalHashReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.hash_, other->_impl_.hash_); } ::google::protobuf::Metadata CanonicalHashReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HeaderNumberRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(HeaderNumberRequest, _impl_._has_bits_); }; void HeaderNumberRequest::clear_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hash_ != nullptr) _impl_.hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } HeaderNumberRequest::HeaderNumberRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.HeaderNumberRequest) } inline PROTOBUF_NDEBUG_INLINE HeaderNumberRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::HeaderNumberRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} HeaderNumberRequest::HeaderNumberRequest( ::google::protobuf::Arena* arena, const HeaderNumberRequest& from) : ::google::protobuf::Message(arena) { HeaderNumberRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.hash_) : nullptr; // @@protoc_insertion_point(copy_constructor:remote.HeaderNumberRequest) } inline PROTOBUF_NDEBUG_INLINE HeaderNumberRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void HeaderNumberRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.hash_ = {}; } HeaderNumberRequest::~HeaderNumberRequest() { // @@protoc_insertion_point(destructor:remote.HeaderNumberRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HeaderNumberRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HeaderNumberRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HeaderNumberRequest, _impl_._cached_size_), false, }, &HeaderNumberRequest::MergeImpl, &HeaderNumberRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> HeaderNumberRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(HeaderNumberRequest, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_HeaderNumberRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::HeaderNumberRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H256 hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(HeaderNumberRequest, _impl_.hash_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 hash = 1; {PROTOBUF_FIELD_OFFSET(HeaderNumberRequest, _impl_.hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void HeaderNumberRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.HeaderNumberRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hash_ != nullptr); _impl_.hash_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HeaderNumberRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.HeaderNumberRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hash_, _impl_.hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.HeaderNumberRequest) return target; } ::size_t HeaderNumberRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.HeaderNumberRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .types.H256 hash = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hash_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HeaderNumberRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.HeaderNumberRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hash_ != nullptr); if (_this->_impl_.hash_ == nullptr) { _this->_impl_.hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.hash_); } else { _this->_impl_.hash_->MergeFrom(*from._impl_.hash_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HeaderNumberRequest::CopyFrom(const HeaderNumberRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.HeaderNumberRequest) if (&from == this) return; Clear(); MergeFrom(from); } void HeaderNumberRequest::InternalSwap(HeaderNumberRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.hash_, other->_impl_.hash_); } ::google::protobuf::Metadata HeaderNumberRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HeaderNumberReply::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(HeaderNumberReply, _impl_._has_bits_); }; HeaderNumberReply::HeaderNumberReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.HeaderNumberReply) } HeaderNumberReply::HeaderNumberReply( ::google::protobuf::Arena* arena, const HeaderNumberReply& from) : HeaderNumberReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE HeaderNumberReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void HeaderNumberReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.number_ = {}; } HeaderNumberReply::~HeaderNumberReply() { // @@protoc_insertion_point(destructor:remote.HeaderNumberReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HeaderNumberReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HeaderNumberReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HeaderNumberReply, _impl_._cached_size_), false, }, &HeaderNumberReply::MergeImpl, &HeaderNumberReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> HeaderNumberReply::_table_ = { { PROTOBUF_FIELD_OFFSET(HeaderNumberReply, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HeaderNumberReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::HeaderNumberReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // optional uint64 number = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(HeaderNumberReply, _impl_.number_), 0>(), {8, 0, 0, PROTOBUF_FIELD_OFFSET(HeaderNumberReply, _impl_.number_)}}, }}, {{ 65535, 65535 }}, {{ // optional uint64 number = 1; {PROTOBUF_FIELD_OFFSET(HeaderNumberReply, _impl_.number_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void HeaderNumberReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.HeaderNumberReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.number_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HeaderNumberReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.HeaderNumberReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // optional uint64 number = 1; if (cached_has_bits & 0x00000001u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_number(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.HeaderNumberReply) return target; } ::size_t HeaderNumberReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.HeaderNumberReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // optional uint64 number = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HeaderNumberReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.HeaderNumberReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { _this->_impl_.number_ = from._impl_.number_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HeaderNumberReply::CopyFrom(const HeaderNumberReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.HeaderNumberReply) if (&from == this) return; Clear(); MergeFrom(from); } void HeaderNumberReply::InternalSwap(HeaderNumberReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.number_, other->_impl_.number_); } ::google::protobuf::Metadata HeaderNumberReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class CanonicalBodyForStorageRequest::_Internal { public: }; CanonicalBodyForStorageRequest::CanonicalBodyForStorageRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.CanonicalBodyForStorageRequest) } CanonicalBodyForStorageRequest::CanonicalBodyForStorageRequest( ::google::protobuf::Arena* arena, const CanonicalBodyForStorageRequest& from) : CanonicalBodyForStorageRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE CanonicalBodyForStorageRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void CanonicalBodyForStorageRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.blocknumber_ = {}; } CanonicalBodyForStorageRequest::~CanonicalBodyForStorageRequest() { // @@protoc_insertion_point(destructor:remote.CanonicalBodyForStorageRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void CanonicalBodyForStorageRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* CanonicalBodyForStorageRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(CanonicalBodyForStorageRequest, _impl_._cached_size_), false, }, &CanonicalBodyForStorageRequest::MergeImpl, &CanonicalBodyForStorageRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CanonicalBodyForStorageRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_CanonicalBodyForStorageRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::CanonicalBodyForStorageRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 blockNumber = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(CanonicalBodyForStorageRequest, _impl_.blocknumber_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(CanonicalBodyForStorageRequest, _impl_.blocknumber_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 blockNumber = 1; {PROTOBUF_FIELD_OFFSET(CanonicalBodyForStorageRequest, _impl_.blocknumber_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void CanonicalBodyForStorageRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.CanonicalBodyForStorageRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.blocknumber_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* CanonicalBodyForStorageRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.CanonicalBodyForStorageRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 blockNumber = 1; if (this->_internal_blocknumber() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_blocknumber(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.CanonicalBodyForStorageRequest) return target; } ::size_t CanonicalBodyForStorageRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.CanonicalBodyForStorageRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 blockNumber = 1; if (this->_internal_blocknumber() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_blocknumber()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void CanonicalBodyForStorageRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.CanonicalBodyForStorageRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_blocknumber() != 0) { _this->_impl_.blocknumber_ = from._impl_.blocknumber_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void CanonicalBodyForStorageRequest::CopyFrom(const CanonicalBodyForStorageRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.CanonicalBodyForStorageRequest) if (&from == this) return; Clear(); MergeFrom(from); } void CanonicalBodyForStorageRequest::InternalSwap(CanonicalBodyForStorageRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.blocknumber_, other->_impl_.blocknumber_); } ::google::protobuf::Metadata CanonicalBodyForStorageRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class CanonicalBodyForStorageReply::_Internal { public: }; CanonicalBodyForStorageReply::CanonicalBodyForStorageReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.CanonicalBodyForStorageReply) } inline PROTOBUF_NDEBUG_INLINE CanonicalBodyForStorageReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::CanonicalBodyForStorageReply& from_msg) : body_(arena, from.body_), _cached_size_{0} {} CanonicalBodyForStorageReply::CanonicalBodyForStorageReply( ::google::protobuf::Arena* arena, const CanonicalBodyForStorageReply& from) : ::google::protobuf::Message(arena) { CanonicalBodyForStorageReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.CanonicalBodyForStorageReply) } inline PROTOBUF_NDEBUG_INLINE CanonicalBodyForStorageReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : body_(arena), _cached_size_{0} {} inline void CanonicalBodyForStorageReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } CanonicalBodyForStorageReply::~CanonicalBodyForStorageReply() { // @@protoc_insertion_point(destructor:remote.CanonicalBodyForStorageReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void CanonicalBodyForStorageReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.body_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* CanonicalBodyForStorageReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(CanonicalBodyForStorageReply, _impl_._cached_size_), false, }, &CanonicalBodyForStorageReply::MergeImpl, &CanonicalBodyForStorageReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CanonicalBodyForStorageReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_CanonicalBodyForStorageReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::CanonicalBodyForStorageReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes body = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(CanonicalBodyForStorageReply, _impl_.body_)}}, }}, {{ 65535, 65535 }}, {{ // bytes body = 1; {PROTOBUF_FIELD_OFFSET(CanonicalBodyForStorageReply, _impl_.body_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void CanonicalBodyForStorageReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.CanonicalBodyForStorageReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.body_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* CanonicalBodyForStorageReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.CanonicalBodyForStorageReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes body = 1; if (!this->_internal_body().empty()) { const std::string& _s = this->_internal_body(); target = stream->WriteBytesMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.CanonicalBodyForStorageReply) return target; } ::size_t CanonicalBodyForStorageReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.CanonicalBodyForStorageReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bytes body = 1; if (!this->_internal_body().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_body()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void CanonicalBodyForStorageReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.CanonicalBodyForStorageReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_body().empty()) { _this->_internal_set_body(from._internal_body()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void CanonicalBodyForStorageReply::CopyFrom(const CanonicalBodyForStorageReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.CanonicalBodyForStorageReply) if (&from == this) return; Clear(); MergeFrom(from); } void CanonicalBodyForStorageReply::InternalSwap(CanonicalBodyForStorageReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.body_, &other->_impl_.body_, arena); } ::google::protobuf::Metadata CanonicalBodyForStorageReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SubscribeRequest::_Internal { public: }; SubscribeRequest::SubscribeRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.SubscribeRequest) } SubscribeRequest::SubscribeRequest( ::google::protobuf::Arena* arena, const SubscribeRequest& from) : SubscribeRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE SubscribeRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void SubscribeRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.type_ = {}; } SubscribeRequest::~SubscribeRequest() { // @@protoc_insertion_point(destructor:remote.SubscribeRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SubscribeRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SubscribeRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SubscribeRequest, _impl_._cached_size_), false, }, &SubscribeRequest::MergeImpl, &SubscribeRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SubscribeRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SubscribeRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::SubscribeRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .remote.Event type = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SubscribeRequest, _impl_.type_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeRequest, _impl_.type_)}}, }}, {{ 65535, 65535 }}, {{ // .remote.Event type = 1; {PROTOBUF_FIELD_OFFSET(SubscribeRequest, _impl_.type_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void SubscribeRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.SubscribeRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.type_ = 0; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SubscribeRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.SubscribeRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .remote.Event type = 1; if (this->_internal_type() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_type(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.SubscribeRequest) return target; } ::size_t SubscribeRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.SubscribeRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .remote.Event type = 1; if (this->_internal_type() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SubscribeRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.SubscribeRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_type() != 0) { _this->_impl_.type_ = from._impl_.type_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SubscribeRequest::CopyFrom(const SubscribeRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.SubscribeRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SubscribeRequest::InternalSwap(SubscribeRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.type_, other->_impl_.type_); } ::google::protobuf::Metadata SubscribeRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SubscribeReply::_Internal { public: }; SubscribeReply::SubscribeReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.SubscribeReply) } inline PROTOBUF_NDEBUG_INLINE SubscribeReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::SubscribeReply& from_msg) : data_(arena, from.data_), _cached_size_{0} {} SubscribeReply::SubscribeReply( ::google::protobuf::Arena* arena, const SubscribeReply& from) : ::google::protobuf::Message(arena) { SubscribeReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.type_ = from._impl_.type_; // @@protoc_insertion_point(copy_constructor:remote.SubscribeReply) } inline PROTOBUF_NDEBUG_INLINE SubscribeReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : data_(arena), _cached_size_{0} {} inline void SubscribeReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.type_ = {}; } SubscribeReply::~SubscribeReply() { // @@protoc_insertion_point(destructor:remote.SubscribeReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SubscribeReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.data_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SubscribeReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SubscribeReply, _impl_._cached_size_), false, }, &SubscribeReply::MergeImpl, &SubscribeReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> SubscribeReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SubscribeReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::SubscribeReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes data = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeReply, _impl_.data_)}}, // .remote.Event type = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SubscribeReply, _impl_.type_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeReply, _impl_.type_)}}, }}, {{ 65535, 65535 }}, {{ // .remote.Event type = 1; {PROTOBUF_FIELD_OFFSET(SubscribeReply, _impl_.type_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // bytes data = 2; {PROTOBUF_FIELD_OFFSET(SubscribeReply, _impl_.data_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void SubscribeReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.SubscribeReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.data_.ClearToEmpty(); _impl_.type_ = 0; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SubscribeReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.SubscribeReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .remote.Event type = 1; if (this->_internal_type() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_type(), target); } // bytes data = 2; if (!this->_internal_data().empty()) { const std::string& _s = this->_internal_data(); target = stream->WriteBytesMaybeAliased(2, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.SubscribeReply) return target; } ::size_t SubscribeReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.SubscribeReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes data = 2; if (!this->_internal_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_data()); } // .remote.Event type = 1; if (this->_internal_type() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SubscribeReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.SubscribeReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_data().empty()) { _this->_internal_set_data(from._internal_data()); } if (from._internal_type() != 0) { _this->_impl_.type_ = from._impl_.type_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SubscribeReply::CopyFrom(const SubscribeReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.SubscribeReply) if (&from == this) return; Clear(); MergeFrom(from); } void SubscribeReply::InternalSwap(SubscribeReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); swap(_impl_.type_, other->_impl_.type_); } ::google::protobuf::Metadata SubscribeReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class LogsFilterRequest::_Internal { public: }; void LogsFilterRequest::clear_addresses() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.addresses_.Clear(); } void LogsFilterRequest::clear_topics() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.topics_.Clear(); } LogsFilterRequest::LogsFilterRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.LogsFilterRequest) } inline PROTOBUF_NDEBUG_INLINE LogsFilterRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::LogsFilterRequest& from_msg) : addresses_{visibility, arena, from.addresses_}, topics_{visibility, arena, from.topics_}, _cached_size_{0} {} LogsFilterRequest::LogsFilterRequest( ::google::protobuf::Arena* arena, const LogsFilterRequest& from) : ::google::protobuf::Message(arena) { LogsFilterRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, all_addresses_), reinterpret_cast(&from._impl_) + offsetof(Impl_, all_addresses_), offsetof(Impl_, all_topics_) - offsetof(Impl_, all_addresses_) + sizeof(Impl_::all_topics_)); // @@protoc_insertion_point(copy_constructor:remote.LogsFilterRequest) } inline PROTOBUF_NDEBUG_INLINE LogsFilterRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : addresses_{visibility, arena}, topics_{visibility, arena}, _cached_size_{0} {} inline void LogsFilterRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, all_addresses_), 0, offsetof(Impl_, all_topics_) - offsetof(Impl_, all_addresses_) + sizeof(Impl_::all_topics_)); } LogsFilterRequest::~LogsFilterRequest() { // @@protoc_insertion_point(destructor:remote.LogsFilterRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void LogsFilterRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* LogsFilterRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_._cached_size_), false, }, &LogsFilterRequest::MergeImpl, &LogsFilterRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 4, 2, 0, 2> LogsFilterRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 4, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967280, // skipmap offsetof(decltype(_table_), field_entries), 4, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_LogsFilterRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::LogsFilterRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.H256 topics = 4; {::_pbi::TcParser::FastMtR1, {34, 63, 1, PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.topics_)}}, // bool all_addresses = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.all_addresses_)}}, // repeated .types.H160 addresses = 2; {::_pbi::TcParser::FastMtR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.addresses_)}}, // bool all_topics = 3; {::_pbi::TcParser::SingularVarintNoZag1(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.all_topics_)}}, }}, {{ 65535, 65535 }}, {{ // bool all_addresses = 1; {PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.all_addresses_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // repeated .types.H160 addresses = 2; {PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.addresses_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, // bool all_topics = 3; {PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.all_topics_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // repeated .types.H256 topics = 4; {PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.topics_), 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void LogsFilterRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.LogsFilterRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.addresses_.Clear(); _impl_.topics_.Clear(); ::memset(&_impl_.all_addresses_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.all_topics_) - reinterpret_cast(&_impl_.all_addresses_)) + sizeof(_impl_.all_topics_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* LogsFilterRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.LogsFilterRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool all_addresses = 1; if (this->_internal_all_addresses() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_all_addresses(), target); } // repeated .types.H160 addresses = 2; for (unsigned i = 0, n = static_cast( this->_internal_addresses_size()); i < n; i++) { const auto& repfield = this->_internal_addresses().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, repfield, repfield.GetCachedSize(), target, stream); } // bool all_topics = 3; if (this->_internal_all_topics() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 3, this->_internal_all_topics(), target); } // repeated .types.H256 topics = 4; for (unsigned i = 0, n = static_cast( this->_internal_topics_size()); i < n; i++) { const auto& repfield = this->_internal_topics().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.LogsFilterRequest) return target; } ::size_t LogsFilterRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.LogsFilterRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.H160 addresses = 2; total_size += 1UL * this->_internal_addresses_size(); for (const auto& msg : this->_internal_addresses()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // repeated .types.H256 topics = 4; total_size += 1UL * this->_internal_topics_size(); for (const auto& msg : this->_internal_topics()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // bool all_addresses = 1; if (this->_internal_all_addresses() != 0) { total_size += 2; } // bool all_topics = 3; if (this->_internal_all_topics() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void LogsFilterRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.LogsFilterRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_addresses()->MergeFrom( from._internal_addresses()); _this->_internal_mutable_topics()->MergeFrom( from._internal_topics()); if (from._internal_all_addresses() != 0) { _this->_impl_.all_addresses_ = from._impl_.all_addresses_; } if (from._internal_all_topics() != 0) { _this->_impl_.all_topics_ = from._impl_.all_topics_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void LogsFilterRequest::CopyFrom(const LogsFilterRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.LogsFilterRequest) if (&from == this) return; Clear(); MergeFrom(from); } void LogsFilterRequest::InternalSwap(LogsFilterRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.addresses_.InternalSwap(&other->_impl_.addresses_); _impl_.topics_.InternalSwap(&other->_impl_.topics_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.all_topics_) + sizeof(LogsFilterRequest::_impl_.all_topics_) - PROTOBUF_FIELD_OFFSET(LogsFilterRequest, _impl_.all_addresses_)>( reinterpret_cast(&_impl_.all_addresses_), reinterpret_cast(&other->_impl_.all_addresses_)); } ::google::protobuf::Metadata LogsFilterRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SubscribeLogsReply::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_._has_bits_); }; void SubscribeLogsReply::clear_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ != nullptr) _impl_.address_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } void SubscribeLogsReply::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } void SubscribeLogsReply::clear_topics() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.topics_.Clear(); } void SubscribeLogsReply::clear_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.transaction_hash_ != nullptr) _impl_.transaction_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000004u; } SubscribeLogsReply::SubscribeLogsReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.SubscribeLogsReply) } inline PROTOBUF_NDEBUG_INLINE SubscribeLogsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::SubscribeLogsReply& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, topics_{visibility, arena, from.topics_}, data_(arena, from.data_) {} SubscribeLogsReply::SubscribeLogsReply( ::google::protobuf::Arena* arena, const SubscribeLogsReply& from) : ::google::protobuf::Message(arena) { SubscribeLogsReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.address_) : nullptr; _impl_.block_hash_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; _impl_.transaction_hash_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.transaction_hash_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, block_number_), reinterpret_cast(&from._impl_) + offsetof(Impl_, block_number_), offsetof(Impl_, removed_) - offsetof(Impl_, block_number_) + sizeof(Impl_::removed_)); // @@protoc_insertion_point(copy_constructor:remote.SubscribeLogsReply) } inline PROTOBUF_NDEBUG_INLINE SubscribeLogsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, topics_{visibility, arena}, data_(arena) {} inline void SubscribeLogsReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, address_), 0, offsetof(Impl_, removed_) - offsetof(Impl_, address_) + sizeof(Impl_::removed_)); } SubscribeLogsReply::~SubscribeLogsReply() { // @@protoc_insertion_point(destructor:remote.SubscribeLogsReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SubscribeLogsReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.data_.Destroy(); delete _impl_.address_; delete _impl_.block_hash_; delete _impl_.transaction_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SubscribeLogsReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_._cached_size_), false, }, &SubscribeLogsReply::MergeImpl, &SubscribeLogsReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<4, 9, 4, 0, 2> SubscribeLogsReply::_table_ = { { PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_._has_bits_), 0, // no _extensions_ 9, 120, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294966784, // skipmap offsetof(decltype(_table_), field_entries), 9, // num_field_entries 4, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_SubscribeLogsReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::SubscribeLogsReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .types.H160 address = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.address_)}}, // .types.H256 block_hash = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.block_hash_)}}, // uint64 block_number = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SubscribeLogsReply, _impl_.block_number_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.block_number_)}}, // bytes data = 4; {::_pbi::TcParser::FastBS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.data_)}}, // uint64 log_index = 5; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SubscribeLogsReply, _impl_.log_index_), 63>(), {40, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.log_index_)}}, // repeated .types.H256 topics = 6; {::_pbi::TcParser::FastMtR1, {50, 63, 2, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.topics_)}}, // .types.H256 transaction_hash = 7; {::_pbi::TcParser::FastMtS1, {58, 2, 3, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.transaction_hash_)}}, // uint64 transaction_index = 8; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SubscribeLogsReply, _impl_.transaction_index_), 63>(), {64, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.transaction_index_)}}, // bool removed = 9; {::_pbi::TcParser::SingularVarintNoZag1(), {72, 63, 0, PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.removed_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // .types.H160 address = 1; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 block_hash = 2; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.block_hash_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 block_number = 3; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.block_number_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bytes data = 4; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.data_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // uint64 log_index = 5; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.log_index_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // repeated .types.H256 topics = 6; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.topics_), -1, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 transaction_hash = 7; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.transaction_hash_), _Internal::kHasBitsOffset + 2, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 transaction_index = 8; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.transaction_index_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bool removed = 9; {PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.removed_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void SubscribeLogsReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.SubscribeLogsReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.topics_.Clear(); _impl_.data_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.address_ != nullptr); _impl_.address_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(_impl_.transaction_hash_ != nullptr); _impl_.transaction_hash_->Clear(); } } ::memset(&_impl_.block_number_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.removed_) - reinterpret_cast(&_impl_.block_number_)) + sizeof(_impl_.removed_)); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SubscribeLogsReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.SubscribeLogsReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H160 address = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.address_, _impl_.address_->GetCachedSize(), target, stream); } // .types.H256 block_hash = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } // uint64 block_number = 3; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 3, this->_internal_block_number(), target); } // bytes data = 4; if (!this->_internal_data().empty()) { const std::string& _s = this->_internal_data(); target = stream->WriteBytesMaybeAliased(4, _s, target); } // uint64 log_index = 5; if (this->_internal_log_index() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 5, this->_internal_log_index(), target); } // repeated .types.H256 topics = 6; for (unsigned i = 0, n = static_cast( this->_internal_topics_size()); i < n; i++) { const auto& repfield = this->_internal_topics().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 6, repfield, repfield.GetCachedSize(), target, stream); } // .types.H256 transaction_hash = 7; if (cached_has_bits & 0x00000004u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 7, *_impl_.transaction_hash_, _impl_.transaction_hash_->GetCachedSize(), target, stream); } // uint64 transaction_index = 8; if (this->_internal_transaction_index() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 8, this->_internal_transaction_index(), target); } // bool removed = 9; if (this->_internal_removed() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 9, this->_internal_removed(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.SubscribeLogsReply) return target; } ::size_t SubscribeLogsReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.SubscribeLogsReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.H256 topics = 6; total_size += 1UL * this->_internal_topics_size(); for (const auto& msg : this->_internal_topics()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // bytes data = 4; if (!this->_internal_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_data()); } cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { // .types.H160 address = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.address_); } // .types.H256 block_hash = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } // .types.H256 transaction_hash = 7; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.transaction_hash_); } } // uint64 block_number = 3; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } // uint64 log_index = 5; if (this->_internal_log_index() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_log_index()); } // uint64 transaction_index = 8; if (this->_internal_transaction_index() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_transaction_index()); } // bool removed = 9; if (this->_internal_removed() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SubscribeLogsReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.SubscribeLogsReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_topics()->MergeFrom( from._internal_topics()); if (!from._internal_data().empty()) { _this->_internal_set_data(from._internal_data()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.address_ != nullptr); if (_this->_impl_.address_ == nullptr) { _this->_impl_.address_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.address_); } else { _this->_impl_.address_->MergeFrom(*from._impl_.address_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(from._impl_.transaction_hash_ != nullptr); if (_this->_impl_.transaction_hash_ == nullptr) { _this->_impl_.transaction_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.transaction_hash_); } else { _this->_impl_.transaction_hash_->MergeFrom(*from._impl_.transaction_hash_); } } } if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } if (from._internal_log_index() != 0) { _this->_impl_.log_index_ = from._impl_.log_index_; } if (from._internal_transaction_index() != 0) { _this->_impl_.transaction_index_ = from._impl_.transaction_index_; } if (from._internal_removed() != 0) { _this->_impl_.removed_ = from._impl_.removed_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SubscribeLogsReply::CopyFrom(const SubscribeLogsReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.SubscribeLogsReply) if (&from == this) return; Clear(); MergeFrom(from); } void SubscribeLogsReply::InternalSwap(SubscribeLogsReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.topics_.InternalSwap(&other->_impl_.topics_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.removed_) + sizeof(SubscribeLogsReply::_impl_.removed_) - PROTOBUF_FIELD_OFFSET(SubscribeLogsReply, _impl_.address_)>( reinterpret_cast(&_impl_.address_), reinterpret_cast(&other->_impl_.address_)); } ::google::protobuf::Metadata SubscribeLogsReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BlockRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_._has_bits_); }; void BlockRequest::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } BlockRequest::BlockRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BlockRequest) } inline PROTOBUF_NDEBUG_INLINE BlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::BlockRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} BlockRequest::BlockRequest( ::google::protobuf::Arena* arena, const BlockRequest& from) : ::google::protobuf::Message(arena) { BlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.block_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; _impl_.block_height_ = from._impl_.block_height_; // @@protoc_insertion_point(copy_constructor:remote.BlockRequest) } inline PROTOBUF_NDEBUG_INLINE BlockRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void BlockRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, block_hash_), 0, offsetof(Impl_, block_height_) - offsetof(Impl_, block_hash_) + sizeof(Impl_::block_height_)); } BlockRequest::~BlockRequest() { // @@protoc_insertion_point(destructor:remote.BlockRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BlockRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.block_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BlockRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_._cached_size_), false, }, &BlockRequest::MergeImpl, &BlockRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> BlockRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_._has_bits_), 0, // no _extensions_ 3, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967289, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_BlockRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BlockRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 block_height = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(BlockRequest, _impl_.block_height_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_.block_height_)}}, // .types.H256 block_hash = 3; {::_pbi::TcParser::FastMtS1, {26, 0, 0, PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_.block_hash_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 block_height = 2; {PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_.block_height_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .types.H256 block_hash = 3; {PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_.block_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void BlockRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BlockRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } _impl_.block_height_ = ::uint64_t{0u}; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BlockRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BlockRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 block_height = 2; if (this->_internal_block_height() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_block_height(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H256 block_hash = 3; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BlockRequest) return target; } ::size_t BlockRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BlockRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H256 block_hash = 3; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } // uint64 block_height = 2; if (this->_internal_block_height() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_height()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BlockRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BlockRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } if (from._internal_block_height() != 0) { _this->_impl_.block_height_ = from._impl_.block_height_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BlockRequest::CopyFrom(const BlockRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BlockRequest) if (&from == this) return; Clear(); MergeFrom(from); } void BlockRequest::InternalSwap(BlockRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_.block_height_) + sizeof(BlockRequest::_impl_.block_height_) - PROTOBUF_FIELD_OFFSET(BlockRequest, _impl_.block_hash_)>( reinterpret_cast(&_impl_.block_hash_), reinterpret_cast(&other->_impl_.block_hash_)); } ::google::protobuf::Metadata BlockRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BlockReply::_Internal { public: }; BlockReply::BlockReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.BlockReply) } inline PROTOBUF_NDEBUG_INLINE BlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::BlockReply& from_msg) : block_rlp_(arena, from.block_rlp_), senders_(arena, from.senders_), _cached_size_{0} {} BlockReply::BlockReply( ::google::protobuf::Arena* arena, const BlockReply& from) : ::google::protobuf::Message(arena) { BlockReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.BlockReply) } inline PROTOBUF_NDEBUG_INLINE BlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : block_rlp_(arena), senders_(arena), _cached_size_{0} {} inline void BlockReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } BlockReply::~BlockReply() { // @@protoc_insertion_point(destructor:remote.BlockReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BlockReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.block_rlp_.Destroy(); _impl_.senders_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BlockReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BlockReply, _impl_._cached_size_), false, }, &BlockReply::MergeImpl, &BlockReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> BlockReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_BlockReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::BlockReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes senders = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(BlockReply, _impl_.senders_)}}, // bytes block_rlp = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(BlockReply, _impl_.block_rlp_)}}, }}, {{ 65535, 65535 }}, {{ // bytes block_rlp = 1; {PROTOBUF_FIELD_OFFSET(BlockReply, _impl_.block_rlp_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes senders = 2; {PROTOBUF_FIELD_OFFSET(BlockReply, _impl_.senders_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void BlockReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.BlockReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.block_rlp_.ClearToEmpty(); _impl_.senders_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BlockReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.BlockReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes block_rlp = 1; if (!this->_internal_block_rlp().empty()) { const std::string& _s = this->_internal_block_rlp(); target = stream->WriteBytesMaybeAliased(1, _s, target); } // bytes senders = 2; if (!this->_internal_senders().empty()) { const std::string& _s = this->_internal_senders(); target = stream->WriteBytesMaybeAliased(2, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.BlockReply) return target; } ::size_t BlockReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.BlockReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes block_rlp = 1; if (!this->_internal_block_rlp().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_block_rlp()); } // bytes senders = 2; if (!this->_internal_senders().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_senders()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BlockReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.BlockReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_block_rlp().empty()) { _this->_internal_set_block_rlp(from._internal_block_rlp()); } if (!from._internal_senders().empty()) { _this->_internal_set_senders(from._internal_senders()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BlockReply::CopyFrom(const BlockReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.BlockReply) if (&from == this) return; Clear(); MergeFrom(from); } void BlockReply::InternalSwap(BlockReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.block_rlp_, &other->_impl_.block_rlp_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.senders_, &other->_impl_.senders_, arena); } ::google::protobuf::Metadata BlockReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class TxnLookupRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(TxnLookupRequest, _impl_._has_bits_); }; void TxnLookupRequest::clear_txn_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.txn_hash_ != nullptr) _impl_.txn_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } TxnLookupRequest::TxnLookupRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.TxnLookupRequest) } inline PROTOBUF_NDEBUG_INLINE TxnLookupRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::TxnLookupRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} TxnLookupRequest::TxnLookupRequest( ::google::protobuf::Arena* arena, const TxnLookupRequest& from) : ::google::protobuf::Message(arena) { TxnLookupRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.txn_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.txn_hash_) : nullptr; // @@protoc_insertion_point(copy_constructor:remote.TxnLookupRequest) } inline PROTOBUF_NDEBUG_INLINE TxnLookupRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void TxnLookupRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.txn_hash_ = {}; } TxnLookupRequest::~TxnLookupRequest() { // @@protoc_insertion_point(destructor:remote.TxnLookupRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void TxnLookupRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.txn_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* TxnLookupRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(TxnLookupRequest, _impl_._cached_size_), false, }, &TxnLookupRequest::MergeImpl, &TxnLookupRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> TxnLookupRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(TxnLookupRequest, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_TxnLookupRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::TxnLookupRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H256 txn_hash = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(TxnLookupRequest, _impl_.txn_hash_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 txn_hash = 1; {PROTOBUF_FIELD_OFFSET(TxnLookupRequest, _impl_.txn_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void TxnLookupRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.TxnLookupRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.txn_hash_ != nullptr); _impl_.txn_hash_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* TxnLookupRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.TxnLookupRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 txn_hash = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.txn_hash_, _impl_.txn_hash_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.TxnLookupRequest) return target; } ::size_t TxnLookupRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.TxnLookupRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .types.H256 txn_hash = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.txn_hash_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void TxnLookupRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.TxnLookupRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.txn_hash_ != nullptr); if (_this->_impl_.txn_hash_ == nullptr) { _this->_impl_.txn_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.txn_hash_); } else { _this->_impl_.txn_hash_->MergeFrom(*from._impl_.txn_hash_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void TxnLookupRequest::CopyFrom(const TxnLookupRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.TxnLookupRequest) if (&from == this) return; Clear(); MergeFrom(from); } void TxnLookupRequest::InternalSwap(TxnLookupRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.txn_hash_, other->_impl_.txn_hash_); } ::google::protobuf::Metadata TxnLookupRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class TxnLookupReply::_Internal { public: }; TxnLookupReply::TxnLookupReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.TxnLookupReply) } TxnLookupReply::TxnLookupReply( ::google::protobuf::Arena* arena, const TxnLookupReply& from) : TxnLookupReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE TxnLookupReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void TxnLookupReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, block_number_), 0, offsetof(Impl_, tx_number_) - offsetof(Impl_, block_number_) + sizeof(Impl_::tx_number_)); } TxnLookupReply::~TxnLookupReply() { // @@protoc_insertion_point(destructor:remote.TxnLookupReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void TxnLookupReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* TxnLookupReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(TxnLookupReply, _impl_._cached_size_), false, }, &TxnLookupReply::MergeImpl, &TxnLookupReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> TxnLookupReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_TxnLookupReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::TxnLookupReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 tx_number = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(TxnLookupReply, _impl_.tx_number_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(TxnLookupReply, _impl_.tx_number_)}}, // uint64 block_number = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(TxnLookupReply, _impl_.block_number_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(TxnLookupReply, _impl_.block_number_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 block_number = 1; {PROTOBUF_FIELD_OFFSET(TxnLookupReply, _impl_.block_number_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 tx_number = 2; {PROTOBUF_FIELD_OFFSET(TxnLookupReply, _impl_.tx_number_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void TxnLookupReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.TxnLookupReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.block_number_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.tx_number_) - reinterpret_cast(&_impl_.block_number_)) + sizeof(_impl_.tx_number_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* TxnLookupReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.TxnLookupReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 block_number = 1; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_block_number(), target); } // uint64 tx_number = 2; if (this->_internal_tx_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_tx_number(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.TxnLookupReply) return target; } ::size_t TxnLookupReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.TxnLookupReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 block_number = 1; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } // uint64 tx_number = 2; if (this->_internal_tx_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void TxnLookupReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.TxnLookupReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } if (from._internal_tx_number() != 0) { _this->_impl_.tx_number_ = from._impl_.tx_number_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void TxnLookupReply::CopyFrom(const TxnLookupReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.TxnLookupReply) if (&from == this) return; Clear(); MergeFrom(from); } void TxnLookupReply::InternalSwap(TxnLookupReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(TxnLookupReply, _impl_.tx_number_) + sizeof(TxnLookupReply::_impl_.tx_number_) - PROTOBUF_FIELD_OFFSET(TxnLookupReply, _impl_.block_number_)>( reinterpret_cast(&_impl_.block_number_), reinterpret_cast(&other->_impl_.block_number_)); } ::google::protobuf::Metadata TxnLookupReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NodesInfoRequest::_Internal { public: }; NodesInfoRequest::NodesInfoRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.NodesInfoRequest) } NodesInfoRequest::NodesInfoRequest( ::google::protobuf::Arena* arena, const NodesInfoRequest& from) : NodesInfoRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE NodesInfoRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void NodesInfoRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.limit_ = {}; } NodesInfoRequest::~NodesInfoRequest() { // @@protoc_insertion_point(destructor:remote.NodesInfoRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NodesInfoRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NodesInfoRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NodesInfoRequest, _impl_._cached_size_), false, }, &NodesInfoRequest::MergeImpl, &NodesInfoRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> NodesInfoRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_NodesInfoRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::NodesInfoRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint32 limit = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(NodesInfoRequest, _impl_.limit_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(NodesInfoRequest, _impl_.limit_)}}, }}, {{ 65535, 65535 }}, {{ // uint32 limit = 1; {PROTOBUF_FIELD_OFFSET(NodesInfoRequest, _impl_.limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void NodesInfoRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.NodesInfoRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.limit_ = 0u; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NodesInfoRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.NodesInfoRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint32 limit = 1; if (this->_internal_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 1, this->_internal_limit(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.NodesInfoRequest) return target; } ::size_t NodesInfoRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.NodesInfoRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 limit = 1; if (this->_internal_limit() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_limit()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NodesInfoRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.NodesInfoRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_limit() != 0) { _this->_impl_.limit_ = from._impl_.limit_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NodesInfoRequest::CopyFrom(const NodesInfoRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.NodesInfoRequest) if (&from == this) return; Clear(); MergeFrom(from); } void NodesInfoRequest::InternalSwap(NodesInfoRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.limit_, other->_impl_.limit_); } ::google::protobuf::Metadata NodesInfoRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AddPeerRequest::_Internal { public: }; AddPeerRequest::AddPeerRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.AddPeerRequest) } inline PROTOBUF_NDEBUG_INLINE AddPeerRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::AddPeerRequest& from_msg) : url_(arena, from.url_), _cached_size_{0} {} AddPeerRequest::AddPeerRequest( ::google::protobuf::Arena* arena, const AddPeerRequest& from) : ::google::protobuf::Message(arena) { AddPeerRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.AddPeerRequest) } inline PROTOBUF_NDEBUG_INLINE AddPeerRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : url_(arena), _cached_size_{0} {} inline void AddPeerRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } AddPeerRequest::~AddPeerRequest() { // @@protoc_insertion_point(destructor:remote.AddPeerRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AddPeerRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.url_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AddPeerRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AddPeerRequest, _impl_._cached_size_), false, }, &AddPeerRequest::MergeImpl, &AddPeerRequest::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 33, 2> AddPeerRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AddPeerRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::AddPeerRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // string url = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(AddPeerRequest, _impl_.url_)}}, }}, {{ 65535, 65535 }}, {{ // string url = 1; {PROTOBUF_FIELD_OFFSET(AddPeerRequest, _impl_.url_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\25\3\0\0\0\0\0\0" "remote.AddPeerRequest" "url" }}, }; PROTOBUF_NOINLINE void AddPeerRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.AddPeerRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.url_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AddPeerRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.AddPeerRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string url = 1; if (!this->_internal_url().empty()) { const std::string& _s = this->_internal_url(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.AddPeerRequest.url"); target = stream->WriteStringMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.AddPeerRequest) return target; } ::size_t AddPeerRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.AddPeerRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string url = 1; if (!this->_internal_url().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_url()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AddPeerRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.AddPeerRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_url().empty()) { _this->_internal_set_url(from._internal_url()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AddPeerRequest::CopyFrom(const AddPeerRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.AddPeerRequest) if (&from == this) return; Clear(); MergeFrom(from); } void AddPeerRequest::InternalSwap(AddPeerRequest* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.url_, &other->_impl_.url_, arena); } ::google::protobuf::Metadata AddPeerRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NodesInfoReply::_Internal { public: }; void NodesInfoReply::clear_nodes_info() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nodes_info_.Clear(); } NodesInfoReply::NodesInfoReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.NodesInfoReply) } inline PROTOBUF_NDEBUG_INLINE NodesInfoReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::NodesInfoReply& from_msg) : nodes_info_{visibility, arena, from.nodes_info_}, _cached_size_{0} {} NodesInfoReply::NodesInfoReply( ::google::protobuf::Arena* arena, const NodesInfoReply& from) : ::google::protobuf::Message(arena) { NodesInfoReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.NodesInfoReply) } inline PROTOBUF_NDEBUG_INLINE NodesInfoReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : nodes_info_{visibility, arena}, _cached_size_{0} {} inline void NodesInfoReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } NodesInfoReply::~NodesInfoReply() { // @@protoc_insertion_point(destructor:remote.NodesInfoReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NodesInfoReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NodesInfoReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NodesInfoReply, _impl_._cached_size_), false, }, &NodesInfoReply::MergeImpl, &NodesInfoReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> NodesInfoReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_NodesInfoReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::NodesInfoReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.NodeInfoReply nodes_info = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(NodesInfoReply, _impl_.nodes_info_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.NodeInfoReply nodes_info = 1; {PROTOBUF_FIELD_OFFSET(NodesInfoReply, _impl_.nodes_info_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::NodeInfoReply>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void NodesInfoReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.NodesInfoReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.nodes_info_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NodesInfoReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.NodesInfoReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.NodeInfoReply nodes_info = 1; for (unsigned i = 0, n = static_cast( this->_internal_nodes_info_size()); i < n; i++) { const auto& repfield = this->_internal_nodes_info().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.NodesInfoReply) return target; } ::size_t NodesInfoReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.NodesInfoReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.NodeInfoReply nodes_info = 1; total_size += 1UL * this->_internal_nodes_info_size(); for (const auto& msg : this->_internal_nodes_info()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NodesInfoReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.NodesInfoReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_nodes_info()->MergeFrom( from._internal_nodes_info()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NodesInfoReply::CopyFrom(const NodesInfoReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.NodesInfoReply) if (&from == this) return; Clear(); MergeFrom(from); } void NodesInfoReply::InternalSwap(NodesInfoReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.nodes_info_.InternalSwap(&other->_impl_.nodes_info_); } ::google::protobuf::Metadata NodesInfoReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeersReply::_Internal { public: }; void PeersReply::clear_peers() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.peers_.Clear(); } PeersReply::PeersReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.PeersReply) } inline PROTOBUF_NDEBUG_INLINE PeersReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::PeersReply& from_msg) : peers_{visibility, arena, from.peers_}, _cached_size_{0} {} PeersReply::PeersReply( ::google::protobuf::Arena* arena, const PeersReply& from) : ::google::protobuf::Message(arena) { PeersReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.PeersReply) } inline PROTOBUF_NDEBUG_INLINE PeersReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : peers_{visibility, arena}, _cached_size_{0} {} inline void PeersReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PeersReply::~PeersReply() { // @@protoc_insertion_point(destructor:remote.PeersReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeersReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeersReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeersReply, _impl_._cached_size_), false, }, &PeersReply::MergeImpl, &PeersReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> PeersReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PeersReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::PeersReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.PeerInfo peers = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(PeersReply, _impl_.peers_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.PeerInfo peers = 1; {PROTOBUF_FIELD_OFFSET(PeersReply, _impl_.peers_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::PeerInfo>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PeersReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.PeersReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.peers_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeersReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.PeersReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.PeerInfo peers = 1; for (unsigned i = 0, n = static_cast( this->_internal_peers_size()); i < n; i++) { const auto& repfield = this->_internal_peers().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.PeersReply) return target; } ::size_t PeersReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.PeersReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.PeerInfo peers = 1; total_size += 1UL * this->_internal_peers_size(); for (const auto& msg : this->_internal_peers()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeersReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.PeersReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_peers()->MergeFrom( from._internal_peers()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeersReply::CopyFrom(const PeersReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.PeersReply) if (&from == this) return; Clear(); MergeFrom(from); } void PeersReply::InternalSwap(PeersReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.peers_.InternalSwap(&other->_impl_.peers_); } ::google::protobuf::Metadata PeersReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AddPeerReply::_Internal { public: }; AddPeerReply::AddPeerReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.AddPeerReply) } AddPeerReply::AddPeerReply( ::google::protobuf::Arena* arena, const AddPeerReply& from) : AddPeerReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE AddPeerReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void AddPeerReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.success_ = {}; } AddPeerReply::~AddPeerReply() { // @@protoc_insertion_point(destructor:remote.AddPeerReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AddPeerReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AddPeerReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AddPeerReply, _impl_._cached_size_), false, }, &AddPeerReply::MergeImpl, &AddPeerReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> AddPeerReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AddPeerReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::AddPeerReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool success = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(AddPeerReply, _impl_.success_)}}, }}, {{ 65535, 65535 }}, {{ // bool success = 1; {PROTOBUF_FIELD_OFFSET(AddPeerReply, _impl_.success_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void AddPeerReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.AddPeerReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.success_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AddPeerReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.AddPeerReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool success = 1; if (this->_internal_success() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_success(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.AddPeerReply) return target; } ::size_t AddPeerReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.AddPeerReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool success = 1; if (this->_internal_success() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AddPeerReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.AddPeerReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_success() != 0) { _this->_impl_.success_ = from._impl_.success_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AddPeerReply::CopyFrom(const AddPeerReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.AddPeerReply) if (&from == this) return; Clear(); MergeFrom(from); } void AddPeerReply::InternalSwap(AddPeerReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.success_, other->_impl_.success_); } ::google::protobuf::Metadata AddPeerReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PendingBlockReply::_Internal { public: }; PendingBlockReply::PendingBlockReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.PendingBlockReply) } inline PROTOBUF_NDEBUG_INLINE PendingBlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::PendingBlockReply& from_msg) : block_rlp_(arena, from.block_rlp_), _cached_size_{0} {} PendingBlockReply::PendingBlockReply( ::google::protobuf::Arena* arena, const PendingBlockReply& from) : ::google::protobuf::Message(arena) { PendingBlockReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.PendingBlockReply) } inline PROTOBUF_NDEBUG_INLINE PendingBlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : block_rlp_(arena), _cached_size_{0} {} inline void PendingBlockReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PendingBlockReply::~PendingBlockReply() { // @@protoc_insertion_point(destructor:remote.PendingBlockReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PendingBlockReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.block_rlp_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PendingBlockReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PendingBlockReply, _impl_._cached_size_), false, }, &PendingBlockReply::MergeImpl, &PendingBlockReply::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> PendingBlockReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_PendingBlockReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::PendingBlockReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes block_rlp = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(PendingBlockReply, _impl_.block_rlp_)}}, }}, {{ 65535, 65535 }}, {{ // bytes block_rlp = 1; {PROTOBUF_FIELD_OFFSET(PendingBlockReply, _impl_.block_rlp_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void PendingBlockReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.PendingBlockReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.block_rlp_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PendingBlockReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.PendingBlockReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes block_rlp = 1; if (!this->_internal_block_rlp().empty()) { const std::string& _s = this->_internal_block_rlp(); target = stream->WriteBytesMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.PendingBlockReply) return target; } ::size_t PendingBlockReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.PendingBlockReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bytes block_rlp = 1; if (!this->_internal_block_rlp().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_block_rlp()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PendingBlockReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.PendingBlockReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_block_rlp().empty()) { _this->_internal_set_block_rlp(from._internal_block_rlp()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PendingBlockReply::CopyFrom(const PendingBlockReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.PendingBlockReply) if (&from == this) return; Clear(); MergeFrom(from); } void PendingBlockReply::InternalSwap(PendingBlockReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.block_rlp_, &other->_impl_.block_rlp_, arena); } ::google::protobuf::Metadata PendingBlockReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class EngineGetPayloadBodiesByHashV1Request::_Internal { public: }; void EngineGetPayloadBodiesByHashV1Request::clear_hashes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hashes_.Clear(); } EngineGetPayloadBodiesByHashV1Request::EngineGetPayloadBodiesByHashV1Request(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.EngineGetPayloadBodiesByHashV1Request) } inline PROTOBUF_NDEBUG_INLINE EngineGetPayloadBodiesByHashV1Request::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::EngineGetPayloadBodiesByHashV1Request& from_msg) : hashes_{visibility, arena, from.hashes_}, _cached_size_{0} {} EngineGetPayloadBodiesByHashV1Request::EngineGetPayloadBodiesByHashV1Request( ::google::protobuf::Arena* arena, const EngineGetPayloadBodiesByHashV1Request& from) : ::google::protobuf::Message(arena) { EngineGetPayloadBodiesByHashV1Request* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.EngineGetPayloadBodiesByHashV1Request) } inline PROTOBUF_NDEBUG_INLINE EngineGetPayloadBodiesByHashV1Request::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : hashes_{visibility, arena}, _cached_size_{0} {} inline void EngineGetPayloadBodiesByHashV1Request::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } EngineGetPayloadBodiesByHashV1Request::~EngineGetPayloadBodiesByHashV1Request() { // @@protoc_insertion_point(destructor:remote.EngineGetPayloadBodiesByHashV1Request) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void EngineGetPayloadBodiesByHashV1Request::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* EngineGetPayloadBodiesByHashV1Request::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByHashV1Request, _impl_._cached_size_), false, }, &EngineGetPayloadBodiesByHashV1Request::MergeImpl, &EngineGetPayloadBodiesByHashV1Request::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> EngineGetPayloadBodiesByHashV1Request::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_EngineGetPayloadBodiesByHashV1Request_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::EngineGetPayloadBodiesByHashV1Request>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.H256 hashes = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByHashV1Request, _impl_.hashes_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.H256 hashes = 1; {PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByHashV1Request, _impl_.hashes_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void EngineGetPayloadBodiesByHashV1Request::Clear() { // @@protoc_insertion_point(message_clear_start:remote.EngineGetPayloadBodiesByHashV1Request) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.hashes_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* EngineGetPayloadBodiesByHashV1Request::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.EngineGetPayloadBodiesByHashV1Request) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.H256 hashes = 1; for (unsigned i = 0, n = static_cast( this->_internal_hashes_size()); i < n; i++) { const auto& repfield = this->_internal_hashes().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.EngineGetPayloadBodiesByHashV1Request) return target; } ::size_t EngineGetPayloadBodiesByHashV1Request::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.EngineGetPayloadBodiesByHashV1Request) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.H256 hashes = 1; total_size += 1UL * this->_internal_hashes_size(); for (const auto& msg : this->_internal_hashes()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void EngineGetPayloadBodiesByHashV1Request::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.EngineGetPayloadBodiesByHashV1Request) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_hashes()->MergeFrom( from._internal_hashes()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void EngineGetPayloadBodiesByHashV1Request::CopyFrom(const EngineGetPayloadBodiesByHashV1Request& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.EngineGetPayloadBodiesByHashV1Request) if (&from == this) return; Clear(); MergeFrom(from); } void EngineGetPayloadBodiesByHashV1Request::InternalSwap(EngineGetPayloadBodiesByHashV1Request* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.hashes_.InternalSwap(&other->_impl_.hashes_); } ::google::protobuf::Metadata EngineGetPayloadBodiesByHashV1Request::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class EngineGetPayloadBodiesByRangeV1Request::_Internal { public: }; EngineGetPayloadBodiesByRangeV1Request::EngineGetPayloadBodiesByRangeV1Request(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.EngineGetPayloadBodiesByRangeV1Request) } EngineGetPayloadBodiesByRangeV1Request::EngineGetPayloadBodiesByRangeV1Request( ::google::protobuf::Arena* arena, const EngineGetPayloadBodiesByRangeV1Request& from) : EngineGetPayloadBodiesByRangeV1Request(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE EngineGetPayloadBodiesByRangeV1Request::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void EngineGetPayloadBodiesByRangeV1Request::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, start_), 0, offsetof(Impl_, count_) - offsetof(Impl_, start_) + sizeof(Impl_::count_)); } EngineGetPayloadBodiesByRangeV1Request::~EngineGetPayloadBodiesByRangeV1Request() { // @@protoc_insertion_point(destructor:remote.EngineGetPayloadBodiesByRangeV1Request) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void EngineGetPayloadBodiesByRangeV1Request::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* EngineGetPayloadBodiesByRangeV1Request::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByRangeV1Request, _impl_._cached_size_), false, }, &EngineGetPayloadBodiesByRangeV1Request::MergeImpl, &EngineGetPayloadBodiesByRangeV1Request::kDescriptorMethods, &descriptor_table_remote_2fethbackend_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> EngineGetPayloadBodiesByRangeV1Request::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_EngineGetPayloadBodiesByRangeV1Request_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::EngineGetPayloadBodiesByRangeV1Request>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 count = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(EngineGetPayloadBodiesByRangeV1Request, _impl_.count_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByRangeV1Request, _impl_.count_)}}, // uint64 start = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(EngineGetPayloadBodiesByRangeV1Request, _impl_.start_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByRangeV1Request, _impl_.start_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 start = 1; {PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByRangeV1Request, _impl_.start_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 count = 2; {PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByRangeV1Request, _impl_.count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void EngineGetPayloadBodiesByRangeV1Request::Clear() { // @@protoc_insertion_point(message_clear_start:remote.EngineGetPayloadBodiesByRangeV1Request) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.start_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.count_) - reinterpret_cast(&_impl_.start_)) + sizeof(_impl_.count_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* EngineGetPayloadBodiesByRangeV1Request::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.EngineGetPayloadBodiesByRangeV1Request) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 start = 1; if (this->_internal_start() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_start(), target); } // uint64 count = 2; if (this->_internal_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_count(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.EngineGetPayloadBodiesByRangeV1Request) return target; } ::size_t EngineGetPayloadBodiesByRangeV1Request::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.EngineGetPayloadBodiesByRangeV1Request) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 start = 1; if (this->_internal_start() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_start()); } // uint64 count = 2; if (this->_internal_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_count()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void EngineGetPayloadBodiesByRangeV1Request::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.EngineGetPayloadBodiesByRangeV1Request) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_start() != 0) { _this->_impl_.start_ = from._impl_.start_; } if (from._internal_count() != 0) { _this->_impl_.count_ = from._impl_.count_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void EngineGetPayloadBodiesByRangeV1Request::CopyFrom(const EngineGetPayloadBodiesByRangeV1Request& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.EngineGetPayloadBodiesByRangeV1Request) if (&from == this) return; Clear(); MergeFrom(from); } void EngineGetPayloadBodiesByRangeV1Request::InternalSwap(EngineGetPayloadBodiesByRangeV1Request* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByRangeV1Request, _impl_.count_) + sizeof(EngineGetPayloadBodiesByRangeV1Request::_impl_.count_) - PROTOBUF_FIELD_OFFSET(EngineGetPayloadBodiesByRangeV1Request, _impl_.start_)>( reinterpret_cast(&_impl_.start_), reinterpret_cast(&other->_impl_.start_)); } ::google::protobuf::Metadata EngineGetPayloadBodiesByRangeV1Request::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace remote namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_remote_2fethbackend_2eproto), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/remote/ethbackend.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: remote/ethbackend.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_remote_2fethbackend_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_remote_2fethbackend_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_bases.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" #include "types/types.pb.h" #include "remote/bor.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_remote_2fethbackend_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_remote_2fethbackend_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_remote_2fethbackend_2eproto; namespace remote { class AddPeerReply; struct AddPeerReplyDefaultTypeInternal; extern AddPeerReplyDefaultTypeInternal _AddPeerReply_default_instance_; class AddPeerRequest; struct AddPeerRequestDefaultTypeInternal; extern AddPeerRequestDefaultTypeInternal _AddPeerRequest_default_instance_; class BlockReply; struct BlockReplyDefaultTypeInternal; extern BlockReplyDefaultTypeInternal _BlockReply_default_instance_; class BlockRequest; struct BlockRequestDefaultTypeInternal; extern BlockRequestDefaultTypeInternal _BlockRequest_default_instance_; class CanonicalBodyForStorageReply; struct CanonicalBodyForStorageReplyDefaultTypeInternal; extern CanonicalBodyForStorageReplyDefaultTypeInternal _CanonicalBodyForStorageReply_default_instance_; class CanonicalBodyForStorageRequest; struct CanonicalBodyForStorageRequestDefaultTypeInternal; extern CanonicalBodyForStorageRequestDefaultTypeInternal _CanonicalBodyForStorageRequest_default_instance_; class CanonicalHashReply; struct CanonicalHashReplyDefaultTypeInternal; extern CanonicalHashReplyDefaultTypeInternal _CanonicalHashReply_default_instance_; class CanonicalHashRequest; struct CanonicalHashRequestDefaultTypeInternal; extern CanonicalHashRequestDefaultTypeInternal _CanonicalHashRequest_default_instance_; class ClientVersionReply; struct ClientVersionReplyDefaultTypeInternal; extern ClientVersionReplyDefaultTypeInternal _ClientVersionReply_default_instance_; class ClientVersionRequest; struct ClientVersionRequestDefaultTypeInternal; extern ClientVersionRequestDefaultTypeInternal _ClientVersionRequest_default_instance_; class EngineGetPayloadBodiesByHashV1Request; struct EngineGetPayloadBodiesByHashV1RequestDefaultTypeInternal; extern EngineGetPayloadBodiesByHashV1RequestDefaultTypeInternal _EngineGetPayloadBodiesByHashV1Request_default_instance_; class EngineGetPayloadBodiesByRangeV1Request; struct EngineGetPayloadBodiesByRangeV1RequestDefaultTypeInternal; extern EngineGetPayloadBodiesByRangeV1RequestDefaultTypeInternal _EngineGetPayloadBodiesByRangeV1Request_default_instance_; class EtherbaseReply; struct EtherbaseReplyDefaultTypeInternal; extern EtherbaseReplyDefaultTypeInternal _EtherbaseReply_default_instance_; class EtherbaseRequest; struct EtherbaseRequestDefaultTypeInternal; extern EtherbaseRequestDefaultTypeInternal _EtherbaseRequest_default_instance_; class HeaderNumberReply; struct HeaderNumberReplyDefaultTypeInternal; extern HeaderNumberReplyDefaultTypeInternal _HeaderNumberReply_default_instance_; class HeaderNumberRequest; struct HeaderNumberRequestDefaultTypeInternal; extern HeaderNumberRequestDefaultTypeInternal _HeaderNumberRequest_default_instance_; class LogsFilterRequest; struct LogsFilterRequestDefaultTypeInternal; extern LogsFilterRequestDefaultTypeInternal _LogsFilterRequest_default_instance_; class NetPeerCountReply; struct NetPeerCountReplyDefaultTypeInternal; extern NetPeerCountReplyDefaultTypeInternal _NetPeerCountReply_default_instance_; class NetPeerCountRequest; struct NetPeerCountRequestDefaultTypeInternal; extern NetPeerCountRequestDefaultTypeInternal _NetPeerCountRequest_default_instance_; class NetVersionReply; struct NetVersionReplyDefaultTypeInternal; extern NetVersionReplyDefaultTypeInternal _NetVersionReply_default_instance_; class NetVersionRequest; struct NetVersionRequestDefaultTypeInternal; extern NetVersionRequestDefaultTypeInternal _NetVersionRequest_default_instance_; class NodesInfoReply; struct NodesInfoReplyDefaultTypeInternal; extern NodesInfoReplyDefaultTypeInternal _NodesInfoReply_default_instance_; class NodesInfoRequest; struct NodesInfoRequestDefaultTypeInternal; extern NodesInfoRequestDefaultTypeInternal _NodesInfoRequest_default_instance_; class PeersReply; struct PeersReplyDefaultTypeInternal; extern PeersReplyDefaultTypeInternal _PeersReply_default_instance_; class PendingBlockReply; struct PendingBlockReplyDefaultTypeInternal; extern PendingBlockReplyDefaultTypeInternal _PendingBlockReply_default_instance_; class ProtocolVersionReply; struct ProtocolVersionReplyDefaultTypeInternal; extern ProtocolVersionReplyDefaultTypeInternal _ProtocolVersionReply_default_instance_; class ProtocolVersionRequest; struct ProtocolVersionRequestDefaultTypeInternal; extern ProtocolVersionRequestDefaultTypeInternal _ProtocolVersionRequest_default_instance_; class SubscribeLogsReply; struct SubscribeLogsReplyDefaultTypeInternal; extern SubscribeLogsReplyDefaultTypeInternal _SubscribeLogsReply_default_instance_; class SubscribeReply; struct SubscribeReplyDefaultTypeInternal; extern SubscribeReplyDefaultTypeInternal _SubscribeReply_default_instance_; class SubscribeRequest; struct SubscribeRequestDefaultTypeInternal; extern SubscribeRequestDefaultTypeInternal _SubscribeRequest_default_instance_; class SyncingReply; struct SyncingReplyDefaultTypeInternal; extern SyncingReplyDefaultTypeInternal _SyncingReply_default_instance_; class SyncingReply_StageProgress; struct SyncingReply_StageProgressDefaultTypeInternal; extern SyncingReply_StageProgressDefaultTypeInternal _SyncingReply_StageProgress_default_instance_; class TxnLookupReply; struct TxnLookupReplyDefaultTypeInternal; extern TxnLookupReplyDefaultTypeInternal _TxnLookupReply_default_instance_; class TxnLookupRequest; struct TxnLookupRequestDefaultTypeInternal; extern TxnLookupRequestDefaultTypeInternal _TxnLookupRequest_default_instance_; } // namespace remote namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace remote { enum Event : int { HEADER = 0, PENDING_LOGS = 1, PENDING_BLOCK = 2, NEW_SNAPSHOT = 3, Event_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), Event_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool Event_IsValid(int value); extern const uint32_t Event_internal_data_[]; constexpr Event Event_MIN = static_cast(0); constexpr Event Event_MAX = static_cast(3); constexpr int Event_ARRAYSIZE = 3 + 1; const ::google::protobuf::EnumDescriptor* Event_descriptor(); template const std::string& Event_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to Event_Name()."); return Event_Name(static_cast(value)); } template <> inline const std::string& Event_Name(Event value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool Event_Parse(absl::string_view name, Event* value) { return ::google::protobuf::internal::ParseNamedEnum( Event_descriptor(), name, value); } // =================================================================== // ------------------------------------------------------------------- class TxnLookupReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.TxnLookupReply) */ { public: inline TxnLookupReply() : TxnLookupReply(nullptr) {} ~TxnLookupReply() override; template explicit PROTOBUF_CONSTEXPR TxnLookupReply( ::google::protobuf::internal::ConstantInitialized); inline TxnLookupReply(const TxnLookupReply& from) : TxnLookupReply(nullptr, from) {} inline TxnLookupReply(TxnLookupReply&& from) noexcept : TxnLookupReply(nullptr, std::move(from)) {} inline TxnLookupReply& operator=(const TxnLookupReply& from) { CopyFrom(from); return *this; } inline TxnLookupReply& operator=(TxnLookupReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const TxnLookupReply& default_instance() { return *internal_default_instance(); } static inline const TxnLookupReply* internal_default_instance() { return reinterpret_cast( &_TxnLookupReply_default_instance_); } static constexpr int kIndexInFileMessages = 25; friend void swap(TxnLookupReply& a, TxnLookupReply& b) { a.Swap(&b); } inline void Swap(TxnLookupReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TxnLookupReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TxnLookupReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const TxnLookupReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const TxnLookupReply& from) { TxnLookupReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(TxnLookupReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.TxnLookupReply"; } protected: explicit TxnLookupReply(::google::protobuf::Arena* arena); TxnLookupReply(::google::protobuf::Arena* arena, const TxnLookupReply& from); TxnLookupReply(::google::protobuf::Arena* arena, TxnLookupReply&& from) noexcept : TxnLookupReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockNumberFieldNumber = 1, kTxNumberFieldNumber = 2, }; // uint64 block_number = 1; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // uint64 tx_number = 2; void clear_tx_number() ; ::uint64_t tx_number() const; void set_tx_number(::uint64_t value); private: ::uint64_t _internal_tx_number() const; void _internal_set_tx_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.TxnLookupReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_TxnLookupReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const TxnLookupReply& from_msg); ::uint64_t block_number_; ::uint64_t tx_number_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class SyncingReply_StageProgress final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.SyncingReply.StageProgress) */ { public: inline SyncingReply_StageProgress() : SyncingReply_StageProgress(nullptr) {} ~SyncingReply_StageProgress() override; template explicit PROTOBUF_CONSTEXPR SyncingReply_StageProgress( ::google::protobuf::internal::ConstantInitialized); inline SyncingReply_StageProgress(const SyncingReply_StageProgress& from) : SyncingReply_StageProgress(nullptr, from) {} inline SyncingReply_StageProgress(SyncingReply_StageProgress&& from) noexcept : SyncingReply_StageProgress(nullptr, std::move(from)) {} inline SyncingReply_StageProgress& operator=(const SyncingReply_StageProgress& from) { CopyFrom(from); return *this; } inline SyncingReply_StageProgress& operator=(SyncingReply_StageProgress&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SyncingReply_StageProgress& default_instance() { return *internal_default_instance(); } static inline const SyncingReply_StageProgress* internal_default_instance() { return reinterpret_cast( &_SyncingReply_StageProgress_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(SyncingReply_StageProgress& a, SyncingReply_StageProgress& b) { a.Swap(&b); } inline void Swap(SyncingReply_StageProgress* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SyncingReply_StageProgress* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SyncingReply_StageProgress* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SyncingReply_StageProgress& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SyncingReply_StageProgress& from) { SyncingReply_StageProgress::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SyncingReply_StageProgress* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.SyncingReply.StageProgress"; } protected: explicit SyncingReply_StageProgress(::google::protobuf::Arena* arena); SyncingReply_StageProgress(::google::protobuf::Arena* arena, const SyncingReply_StageProgress& from); SyncingReply_StageProgress(::google::protobuf::Arena* arena, SyncingReply_StageProgress&& from) noexcept : SyncingReply_StageProgress(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kStageNameFieldNumber = 1, kBlockNumberFieldNumber = 2, }; // string stage_name = 1; void clear_stage_name() ; const std::string& stage_name() const; template void set_stage_name(Arg_&& arg, Args_... args); std::string* mutable_stage_name(); PROTOBUF_NODISCARD std::string* release_stage_name(); void set_allocated_stage_name(std::string* value); private: const std::string& _internal_stage_name() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_stage_name( const std::string& value); std::string* _internal_mutable_stage_name(); public: // uint64 block_number = 2; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.SyncingReply.StageProgress) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 52, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SyncingReply_StageProgress_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SyncingReply_StageProgress& from_msg); ::google::protobuf::internal::ArenaStringPtr stage_name_; ::uint64_t block_number_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class SubscribeRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.SubscribeRequest) */ { public: inline SubscribeRequest() : SubscribeRequest(nullptr) {} ~SubscribeRequest() override; template explicit PROTOBUF_CONSTEXPR SubscribeRequest( ::google::protobuf::internal::ConstantInitialized); inline SubscribeRequest(const SubscribeRequest& from) : SubscribeRequest(nullptr, from) {} inline SubscribeRequest(SubscribeRequest&& from) noexcept : SubscribeRequest(nullptr, std::move(from)) {} inline SubscribeRequest& operator=(const SubscribeRequest& from) { CopyFrom(from); return *this; } inline SubscribeRequest& operator=(SubscribeRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SubscribeRequest& default_instance() { return *internal_default_instance(); } static inline const SubscribeRequest* internal_default_instance() { return reinterpret_cast( &_SubscribeRequest_default_instance_); } static constexpr int kIndexInFileMessages = 18; friend void swap(SubscribeRequest& a, SubscribeRequest& b) { a.Swap(&b); } inline void Swap(SubscribeRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubscribeRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubscribeRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SubscribeRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SubscribeRequest& from) { SubscribeRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SubscribeRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.SubscribeRequest"; } protected: explicit SubscribeRequest(::google::protobuf::Arena* arena); SubscribeRequest(::google::protobuf::Arena* arena, const SubscribeRequest& from); SubscribeRequest(::google::protobuf::Arena* arena, SubscribeRequest&& from) noexcept : SubscribeRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTypeFieldNumber = 1, }; // .remote.Event type = 1; void clear_type() ; ::remote::Event type() const; void set_type(::remote::Event value); private: ::remote::Event _internal_type() const; void _internal_set_type(::remote::Event value); public: // @@protoc_insertion_point(class_scope:remote.SubscribeRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SubscribeRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SubscribeRequest& from_msg); int type_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class SubscribeReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.SubscribeReply) */ { public: inline SubscribeReply() : SubscribeReply(nullptr) {} ~SubscribeReply() override; template explicit PROTOBUF_CONSTEXPR SubscribeReply( ::google::protobuf::internal::ConstantInitialized); inline SubscribeReply(const SubscribeReply& from) : SubscribeReply(nullptr, from) {} inline SubscribeReply(SubscribeReply&& from) noexcept : SubscribeReply(nullptr, std::move(from)) {} inline SubscribeReply& operator=(const SubscribeReply& from) { CopyFrom(from); return *this; } inline SubscribeReply& operator=(SubscribeReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SubscribeReply& default_instance() { return *internal_default_instance(); } static inline const SubscribeReply* internal_default_instance() { return reinterpret_cast( &_SubscribeReply_default_instance_); } static constexpr int kIndexInFileMessages = 19; friend void swap(SubscribeReply& a, SubscribeReply& b) { a.Swap(&b); } inline void Swap(SubscribeReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubscribeReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubscribeReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SubscribeReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SubscribeReply& from) { SubscribeReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SubscribeReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.SubscribeReply"; } protected: explicit SubscribeReply(::google::protobuf::Arena* arena); SubscribeReply(::google::protobuf::Arena* arena, const SubscribeReply& from); SubscribeReply(::google::protobuf::Arena* arena, SubscribeReply&& from) noexcept : SubscribeReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 2, kTypeFieldNumber = 1, }; // bytes data = 2; void clear_data() ; const std::string& data() const; template void set_data(Arg_&& arg, Args_... args); std::string* mutable_data(); PROTOBUF_NODISCARD std::string* release_data(); void set_allocated_data(std::string* value); private: const std::string& _internal_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( const std::string& value); std::string* _internal_mutable_data(); public: // .remote.Event type = 1; void clear_type() ; ::remote::Event type() const; void set_type(::remote::Event value); private: ::remote::Event _internal_type() const; void _internal_set_type(::remote::Event value); public: // @@protoc_insertion_point(class_scope:remote.SubscribeReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SubscribeReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SubscribeReply& from_msg); ::google::protobuf::internal::ArenaStringPtr data_; int type_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class ProtocolVersionRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:remote.ProtocolVersionRequest) */ { public: inline ProtocolVersionRequest() : ProtocolVersionRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR ProtocolVersionRequest( ::google::protobuf::internal::ConstantInitialized); inline ProtocolVersionRequest(const ProtocolVersionRequest& from) : ProtocolVersionRequest(nullptr, from) {} inline ProtocolVersionRequest(ProtocolVersionRequest&& from) noexcept : ProtocolVersionRequest(nullptr, std::move(from)) {} inline ProtocolVersionRequest& operator=(const ProtocolVersionRequest& from) { CopyFrom(from); return *this; } inline ProtocolVersionRequest& operator=(ProtocolVersionRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ProtocolVersionRequest& default_instance() { return *internal_default_instance(); } static inline const ProtocolVersionRequest* internal_default_instance() { return reinterpret_cast( &_ProtocolVersionRequest_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(ProtocolVersionRequest& a, ProtocolVersionRequest& b) { a.Swap(&b); } inline void Swap(ProtocolVersionRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ProtocolVersionRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ProtocolVersionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const ProtocolVersionRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const ProtocolVersionRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.ProtocolVersionRequest"; } protected: explicit ProtocolVersionRequest(::google::protobuf::Arena* arena); ProtocolVersionRequest(::google::protobuf::Arena* arena, const ProtocolVersionRequest& from); ProtocolVersionRequest(::google::protobuf::Arena* arena, ProtocolVersionRequest&& from) noexcept : ProtocolVersionRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:remote.ProtocolVersionRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ProtocolVersionRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ProtocolVersionRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class ProtocolVersionReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.ProtocolVersionReply) */ { public: inline ProtocolVersionReply() : ProtocolVersionReply(nullptr) {} ~ProtocolVersionReply() override; template explicit PROTOBUF_CONSTEXPR ProtocolVersionReply( ::google::protobuf::internal::ConstantInitialized); inline ProtocolVersionReply(const ProtocolVersionReply& from) : ProtocolVersionReply(nullptr, from) {} inline ProtocolVersionReply(ProtocolVersionReply&& from) noexcept : ProtocolVersionReply(nullptr, std::move(from)) {} inline ProtocolVersionReply& operator=(const ProtocolVersionReply& from) { CopyFrom(from); return *this; } inline ProtocolVersionReply& operator=(ProtocolVersionReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ProtocolVersionReply& default_instance() { return *internal_default_instance(); } static inline const ProtocolVersionReply* internal_default_instance() { return reinterpret_cast( &_ProtocolVersionReply_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(ProtocolVersionReply& a, ProtocolVersionReply& b) { a.Swap(&b); } inline void Swap(ProtocolVersionReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ProtocolVersionReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ProtocolVersionReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ProtocolVersionReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ProtocolVersionReply& from) { ProtocolVersionReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ProtocolVersionReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.ProtocolVersionReply"; } protected: explicit ProtocolVersionReply(::google::protobuf::Arena* arena); ProtocolVersionReply(::google::protobuf::Arena* arena, const ProtocolVersionReply& from); ProtocolVersionReply(::google::protobuf::Arena* arena, ProtocolVersionReply&& from) noexcept : ProtocolVersionReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdFieldNumber = 1, }; // uint64 id = 1; void clear_id() ; ::uint64_t id() const; void set_id(::uint64_t value); private: ::uint64_t _internal_id() const; void _internal_set_id(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.ProtocolVersionReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ProtocolVersionReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ProtocolVersionReply& from_msg); ::uint64_t id_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class PendingBlockReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.PendingBlockReply) */ { public: inline PendingBlockReply() : PendingBlockReply(nullptr) {} ~PendingBlockReply() override; template explicit PROTOBUF_CONSTEXPR PendingBlockReply( ::google::protobuf::internal::ConstantInitialized); inline PendingBlockReply(const PendingBlockReply& from) : PendingBlockReply(nullptr, from) {} inline PendingBlockReply(PendingBlockReply&& from) noexcept : PendingBlockReply(nullptr, std::move(from)) {} inline PendingBlockReply& operator=(const PendingBlockReply& from) { CopyFrom(from); return *this; } inline PendingBlockReply& operator=(PendingBlockReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PendingBlockReply& default_instance() { return *internal_default_instance(); } static inline const PendingBlockReply* internal_default_instance() { return reinterpret_cast( &_PendingBlockReply_default_instance_); } static constexpr int kIndexInFileMessages = 31; friend void swap(PendingBlockReply& a, PendingBlockReply& b) { a.Swap(&b); } inline void Swap(PendingBlockReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PendingBlockReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PendingBlockReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PendingBlockReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PendingBlockReply& from) { PendingBlockReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PendingBlockReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.PendingBlockReply"; } protected: explicit PendingBlockReply(::google::protobuf::Arena* arena); PendingBlockReply(::google::protobuf::Arena* arena, const PendingBlockReply& from); PendingBlockReply(::google::protobuf::Arena* arena, PendingBlockReply&& from) noexcept : PendingBlockReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockRlpFieldNumber = 1, }; // bytes block_rlp = 1; void clear_block_rlp() ; const std::string& block_rlp() const; template void set_block_rlp(Arg_&& arg, Args_... args); std::string* mutable_block_rlp(); PROTOBUF_NODISCARD std::string* release_block_rlp(); void set_allocated_block_rlp(std::string* value); private: const std::string& _internal_block_rlp() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_block_rlp( const std::string& value); std::string* _internal_mutable_block_rlp(); public: // @@protoc_insertion_point(class_scope:remote.PendingBlockReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PendingBlockReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PendingBlockReply& from_msg); ::google::protobuf::internal::ArenaStringPtr block_rlp_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class NodesInfoRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.NodesInfoRequest) */ { public: inline NodesInfoRequest() : NodesInfoRequest(nullptr) {} ~NodesInfoRequest() override; template explicit PROTOBUF_CONSTEXPR NodesInfoRequest( ::google::protobuf::internal::ConstantInitialized); inline NodesInfoRequest(const NodesInfoRequest& from) : NodesInfoRequest(nullptr, from) {} inline NodesInfoRequest(NodesInfoRequest&& from) noexcept : NodesInfoRequest(nullptr, std::move(from)) {} inline NodesInfoRequest& operator=(const NodesInfoRequest& from) { CopyFrom(from); return *this; } inline NodesInfoRequest& operator=(NodesInfoRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NodesInfoRequest& default_instance() { return *internal_default_instance(); } static inline const NodesInfoRequest* internal_default_instance() { return reinterpret_cast( &_NodesInfoRequest_default_instance_); } static constexpr int kIndexInFileMessages = 26; friend void swap(NodesInfoRequest& a, NodesInfoRequest& b) { a.Swap(&b); } inline void Swap(NodesInfoRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NodesInfoRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NodesInfoRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NodesInfoRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NodesInfoRequest& from) { NodesInfoRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NodesInfoRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.NodesInfoRequest"; } protected: explicit NodesInfoRequest(::google::protobuf::Arena* arena); NodesInfoRequest(::google::protobuf::Arena* arena, const NodesInfoRequest& from); NodesInfoRequest(::google::protobuf::Arena* arena, NodesInfoRequest&& from) noexcept : NodesInfoRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kLimitFieldNumber = 1, }; // uint32 limit = 1; void clear_limit() ; ::uint32_t limit() const; void set_limit(::uint32_t value); private: ::uint32_t _internal_limit() const; void _internal_set_limit(::uint32_t value); public: // @@protoc_insertion_point(class_scope:remote.NodesInfoRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NodesInfoRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NodesInfoRequest& from_msg); ::uint32_t limit_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class NetVersionRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:remote.NetVersionRequest) */ { public: inline NetVersionRequest() : NetVersionRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR NetVersionRequest( ::google::protobuf::internal::ConstantInitialized); inline NetVersionRequest(const NetVersionRequest& from) : NetVersionRequest(nullptr, from) {} inline NetVersionRequest(NetVersionRequest&& from) noexcept : NetVersionRequest(nullptr, std::move(from)) {} inline NetVersionRequest& operator=(const NetVersionRequest& from) { CopyFrom(from); return *this; } inline NetVersionRequest& operator=(NetVersionRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NetVersionRequest& default_instance() { return *internal_default_instance(); } static inline const NetVersionRequest* internal_default_instance() { return reinterpret_cast( &_NetVersionRequest_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(NetVersionRequest& a, NetVersionRequest& b) { a.Swap(&b); } inline void Swap(NetVersionRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NetVersionRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NetVersionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const NetVersionRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const NetVersionRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.NetVersionRequest"; } protected: explicit NetVersionRequest(::google::protobuf::Arena* arena); NetVersionRequest(::google::protobuf::Arena* arena, const NetVersionRequest& from); NetVersionRequest(::google::protobuf::Arena* arena, NetVersionRequest&& from) noexcept : NetVersionRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:remote.NetVersionRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NetVersionRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NetVersionRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class NetVersionReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.NetVersionReply) */ { public: inline NetVersionReply() : NetVersionReply(nullptr) {} ~NetVersionReply() override; template explicit PROTOBUF_CONSTEXPR NetVersionReply( ::google::protobuf::internal::ConstantInitialized); inline NetVersionReply(const NetVersionReply& from) : NetVersionReply(nullptr, from) {} inline NetVersionReply(NetVersionReply&& from) noexcept : NetVersionReply(nullptr, std::move(from)) {} inline NetVersionReply& operator=(const NetVersionReply& from) { CopyFrom(from); return *this; } inline NetVersionReply& operator=(NetVersionReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NetVersionReply& default_instance() { return *internal_default_instance(); } static inline const NetVersionReply* internal_default_instance() { return reinterpret_cast( &_NetVersionReply_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(NetVersionReply& a, NetVersionReply& b) { a.Swap(&b); } inline void Swap(NetVersionReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NetVersionReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NetVersionReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NetVersionReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NetVersionReply& from) { NetVersionReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NetVersionReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.NetVersionReply"; } protected: explicit NetVersionReply(::google::protobuf::Arena* arena); NetVersionReply(::google::protobuf::Arena* arena, const NetVersionReply& from); NetVersionReply(::google::protobuf::Arena* arena, NetVersionReply&& from) noexcept : NetVersionReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdFieldNumber = 1, }; // uint64 id = 1; void clear_id() ; ::uint64_t id() const; void set_id(::uint64_t value); private: ::uint64_t _internal_id() const; void _internal_set_id(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.NetVersionReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NetVersionReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NetVersionReply& from_msg); ::uint64_t id_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class NetPeerCountRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:remote.NetPeerCountRequest) */ { public: inline NetPeerCountRequest() : NetPeerCountRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR NetPeerCountRequest( ::google::protobuf::internal::ConstantInitialized); inline NetPeerCountRequest(const NetPeerCountRequest& from) : NetPeerCountRequest(nullptr, from) {} inline NetPeerCountRequest(NetPeerCountRequest&& from) noexcept : NetPeerCountRequest(nullptr, std::move(from)) {} inline NetPeerCountRequest& operator=(const NetPeerCountRequest& from) { CopyFrom(from); return *this; } inline NetPeerCountRequest& operator=(NetPeerCountRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NetPeerCountRequest& default_instance() { return *internal_default_instance(); } static inline const NetPeerCountRequest* internal_default_instance() { return reinterpret_cast( &_NetPeerCountRequest_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(NetPeerCountRequest& a, NetPeerCountRequest& b) { a.Swap(&b); } inline void Swap(NetPeerCountRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NetPeerCountRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NetPeerCountRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const NetPeerCountRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const NetPeerCountRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.NetPeerCountRequest"; } protected: explicit NetPeerCountRequest(::google::protobuf::Arena* arena); NetPeerCountRequest(::google::protobuf::Arena* arena, const NetPeerCountRequest& from); NetPeerCountRequest(::google::protobuf::Arena* arena, NetPeerCountRequest&& from) noexcept : NetPeerCountRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:remote.NetPeerCountRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NetPeerCountRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NetPeerCountRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class NetPeerCountReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.NetPeerCountReply) */ { public: inline NetPeerCountReply() : NetPeerCountReply(nullptr) {} ~NetPeerCountReply() override; template explicit PROTOBUF_CONSTEXPR NetPeerCountReply( ::google::protobuf::internal::ConstantInitialized); inline NetPeerCountReply(const NetPeerCountReply& from) : NetPeerCountReply(nullptr, from) {} inline NetPeerCountReply(NetPeerCountReply&& from) noexcept : NetPeerCountReply(nullptr, std::move(from)) {} inline NetPeerCountReply& operator=(const NetPeerCountReply& from) { CopyFrom(from); return *this; } inline NetPeerCountReply& operator=(NetPeerCountReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NetPeerCountReply& default_instance() { return *internal_default_instance(); } static inline const NetPeerCountReply* internal_default_instance() { return reinterpret_cast( &_NetPeerCountReply_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(NetPeerCountReply& a, NetPeerCountReply& b) { a.Swap(&b); } inline void Swap(NetPeerCountReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NetPeerCountReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NetPeerCountReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NetPeerCountReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NetPeerCountReply& from) { NetPeerCountReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NetPeerCountReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.NetPeerCountReply"; } protected: explicit NetPeerCountReply(::google::protobuf::Arena* arena); NetPeerCountReply(::google::protobuf::Arena* arena, const NetPeerCountReply& from); NetPeerCountReply(::google::protobuf::Arena* arena, NetPeerCountReply&& from) noexcept : NetPeerCountReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCountFieldNumber = 1, }; // uint64 count = 1; void clear_count() ; ::uint64_t count() const; void set_count(::uint64_t value); private: ::uint64_t _internal_count() const; void _internal_set_count(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.NetPeerCountReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NetPeerCountReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NetPeerCountReply& from_msg); ::uint64_t count_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class HeaderNumberReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.HeaderNumberReply) */ { public: inline HeaderNumberReply() : HeaderNumberReply(nullptr) {} ~HeaderNumberReply() override; template explicit PROTOBUF_CONSTEXPR HeaderNumberReply( ::google::protobuf::internal::ConstantInitialized); inline HeaderNumberReply(const HeaderNumberReply& from) : HeaderNumberReply(nullptr, from) {} inline HeaderNumberReply(HeaderNumberReply&& from) noexcept : HeaderNumberReply(nullptr, std::move(from)) {} inline HeaderNumberReply& operator=(const HeaderNumberReply& from) { CopyFrom(from); return *this; } inline HeaderNumberReply& operator=(HeaderNumberReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HeaderNumberReply& default_instance() { return *internal_default_instance(); } static inline const HeaderNumberReply* internal_default_instance() { return reinterpret_cast( &_HeaderNumberReply_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(HeaderNumberReply& a, HeaderNumberReply& b) { a.Swap(&b); } inline void Swap(HeaderNumberReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HeaderNumberReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HeaderNumberReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HeaderNumberReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HeaderNumberReply& from) { HeaderNumberReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HeaderNumberReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.HeaderNumberReply"; } protected: explicit HeaderNumberReply(::google::protobuf::Arena* arena); HeaderNumberReply(::google::protobuf::Arena* arena, const HeaderNumberReply& from); HeaderNumberReply(::google::protobuf::Arena* arena, HeaderNumberReply&& from) noexcept : HeaderNumberReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNumberFieldNumber = 1, }; // optional uint64 number = 1; bool has_number() const; void clear_number() ; ::uint64_t number() const; void set_number(::uint64_t value); private: ::uint64_t _internal_number() const; void _internal_set_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.HeaderNumberReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HeaderNumberReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HeaderNumberReply& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::uint64_t number_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class EtherbaseRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:remote.EtherbaseRequest) */ { public: inline EtherbaseRequest() : EtherbaseRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR EtherbaseRequest( ::google::protobuf::internal::ConstantInitialized); inline EtherbaseRequest(const EtherbaseRequest& from) : EtherbaseRequest(nullptr, from) {} inline EtherbaseRequest(EtherbaseRequest&& from) noexcept : EtherbaseRequest(nullptr, std::move(from)) {} inline EtherbaseRequest& operator=(const EtherbaseRequest& from) { CopyFrom(from); return *this; } inline EtherbaseRequest& operator=(EtherbaseRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const EtherbaseRequest& default_instance() { return *internal_default_instance(); } static inline const EtherbaseRequest* internal_default_instance() { return reinterpret_cast( &_EtherbaseRequest_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(EtherbaseRequest& a, EtherbaseRequest& b) { a.Swap(&b); } inline void Swap(EtherbaseRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(EtherbaseRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- EtherbaseRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const EtherbaseRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const EtherbaseRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.EtherbaseRequest"; } protected: explicit EtherbaseRequest(::google::protobuf::Arena* arena); EtherbaseRequest(::google::protobuf::Arena* arena, const EtherbaseRequest& from); EtherbaseRequest(::google::protobuf::Arena* arena, EtherbaseRequest&& from) noexcept : EtherbaseRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:remote.EtherbaseRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_EtherbaseRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const EtherbaseRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class EngineGetPayloadBodiesByRangeV1Request final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.EngineGetPayloadBodiesByRangeV1Request) */ { public: inline EngineGetPayloadBodiesByRangeV1Request() : EngineGetPayloadBodiesByRangeV1Request(nullptr) {} ~EngineGetPayloadBodiesByRangeV1Request() override; template explicit PROTOBUF_CONSTEXPR EngineGetPayloadBodiesByRangeV1Request( ::google::protobuf::internal::ConstantInitialized); inline EngineGetPayloadBodiesByRangeV1Request(const EngineGetPayloadBodiesByRangeV1Request& from) : EngineGetPayloadBodiesByRangeV1Request(nullptr, from) {} inline EngineGetPayloadBodiesByRangeV1Request(EngineGetPayloadBodiesByRangeV1Request&& from) noexcept : EngineGetPayloadBodiesByRangeV1Request(nullptr, std::move(from)) {} inline EngineGetPayloadBodiesByRangeV1Request& operator=(const EngineGetPayloadBodiesByRangeV1Request& from) { CopyFrom(from); return *this; } inline EngineGetPayloadBodiesByRangeV1Request& operator=(EngineGetPayloadBodiesByRangeV1Request&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const EngineGetPayloadBodiesByRangeV1Request& default_instance() { return *internal_default_instance(); } static inline const EngineGetPayloadBodiesByRangeV1Request* internal_default_instance() { return reinterpret_cast( &_EngineGetPayloadBodiesByRangeV1Request_default_instance_); } static constexpr int kIndexInFileMessages = 33; friend void swap(EngineGetPayloadBodiesByRangeV1Request& a, EngineGetPayloadBodiesByRangeV1Request& b) { a.Swap(&b); } inline void Swap(EngineGetPayloadBodiesByRangeV1Request* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(EngineGetPayloadBodiesByRangeV1Request* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- EngineGetPayloadBodiesByRangeV1Request* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const EngineGetPayloadBodiesByRangeV1Request& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const EngineGetPayloadBodiesByRangeV1Request& from) { EngineGetPayloadBodiesByRangeV1Request::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(EngineGetPayloadBodiesByRangeV1Request* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.EngineGetPayloadBodiesByRangeV1Request"; } protected: explicit EngineGetPayloadBodiesByRangeV1Request(::google::protobuf::Arena* arena); EngineGetPayloadBodiesByRangeV1Request(::google::protobuf::Arena* arena, const EngineGetPayloadBodiesByRangeV1Request& from); EngineGetPayloadBodiesByRangeV1Request(::google::protobuf::Arena* arena, EngineGetPayloadBodiesByRangeV1Request&& from) noexcept : EngineGetPayloadBodiesByRangeV1Request(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kStartFieldNumber = 1, kCountFieldNumber = 2, }; // uint64 start = 1; void clear_start() ; ::uint64_t start() const; void set_start(::uint64_t value); private: ::uint64_t _internal_start() const; void _internal_set_start(::uint64_t value); public: // uint64 count = 2; void clear_count() ; ::uint64_t count() const; void set_count(::uint64_t value); private: ::uint64_t _internal_count() const; void _internal_set_count(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.EngineGetPayloadBodiesByRangeV1Request) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_EngineGetPayloadBodiesByRangeV1Request_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const EngineGetPayloadBodiesByRangeV1Request& from_msg); ::uint64_t start_; ::uint64_t count_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class ClientVersionRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:remote.ClientVersionRequest) */ { public: inline ClientVersionRequest() : ClientVersionRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR ClientVersionRequest( ::google::protobuf::internal::ConstantInitialized); inline ClientVersionRequest(const ClientVersionRequest& from) : ClientVersionRequest(nullptr, from) {} inline ClientVersionRequest(ClientVersionRequest&& from) noexcept : ClientVersionRequest(nullptr, std::move(from)) {} inline ClientVersionRequest& operator=(const ClientVersionRequest& from) { CopyFrom(from); return *this; } inline ClientVersionRequest& operator=(ClientVersionRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ClientVersionRequest& default_instance() { return *internal_default_instance(); } static inline const ClientVersionRequest* internal_default_instance() { return reinterpret_cast( &_ClientVersionRequest_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(ClientVersionRequest& a, ClientVersionRequest& b) { a.Swap(&b); } inline void Swap(ClientVersionRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ClientVersionRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ClientVersionRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const ClientVersionRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const ClientVersionRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.ClientVersionRequest"; } protected: explicit ClientVersionRequest(::google::protobuf::Arena* arena); ClientVersionRequest(::google::protobuf::Arena* arena, const ClientVersionRequest& from); ClientVersionRequest(::google::protobuf::Arena* arena, ClientVersionRequest&& from) noexcept : ClientVersionRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:remote.ClientVersionRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ClientVersionRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ClientVersionRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class ClientVersionReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.ClientVersionReply) */ { public: inline ClientVersionReply() : ClientVersionReply(nullptr) {} ~ClientVersionReply() override; template explicit PROTOBUF_CONSTEXPR ClientVersionReply( ::google::protobuf::internal::ConstantInitialized); inline ClientVersionReply(const ClientVersionReply& from) : ClientVersionReply(nullptr, from) {} inline ClientVersionReply(ClientVersionReply&& from) noexcept : ClientVersionReply(nullptr, std::move(from)) {} inline ClientVersionReply& operator=(const ClientVersionReply& from) { CopyFrom(from); return *this; } inline ClientVersionReply& operator=(ClientVersionReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ClientVersionReply& default_instance() { return *internal_default_instance(); } static inline const ClientVersionReply* internal_default_instance() { return reinterpret_cast( &_ClientVersionReply_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(ClientVersionReply& a, ClientVersionReply& b) { a.Swap(&b); } inline void Swap(ClientVersionReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ClientVersionReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ClientVersionReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ClientVersionReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ClientVersionReply& from) { ClientVersionReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ClientVersionReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.ClientVersionReply"; } protected: explicit ClientVersionReply(::google::protobuf::Arena* arena); ClientVersionReply(::google::protobuf::Arena* arena, const ClientVersionReply& from); ClientVersionReply(::google::protobuf::Arena* arena, ClientVersionReply&& from) noexcept : ClientVersionReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNodeNameFieldNumber = 1, }; // string node_name = 1; void clear_node_name() ; const std::string& node_name() const; template void set_node_name(Arg_&& arg, Args_... args); std::string* mutable_node_name(); PROTOBUF_NODISCARD std::string* release_node_name(); void set_allocated_node_name(std::string* value); private: const std::string& _internal_node_name() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_name( const std::string& value); std::string* _internal_mutable_node_name(); public: // @@protoc_insertion_point(class_scope:remote.ClientVersionReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 43, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ClientVersionReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ClientVersionReply& from_msg); ::google::protobuf::internal::ArenaStringPtr node_name_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class CanonicalHashRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.CanonicalHashRequest) */ { public: inline CanonicalHashRequest() : CanonicalHashRequest(nullptr) {} ~CanonicalHashRequest() override; template explicit PROTOBUF_CONSTEXPR CanonicalHashRequest( ::google::protobuf::internal::ConstantInitialized); inline CanonicalHashRequest(const CanonicalHashRequest& from) : CanonicalHashRequest(nullptr, from) {} inline CanonicalHashRequest(CanonicalHashRequest&& from) noexcept : CanonicalHashRequest(nullptr, std::move(from)) {} inline CanonicalHashRequest& operator=(const CanonicalHashRequest& from) { CopyFrom(from); return *this; } inline CanonicalHashRequest& operator=(CanonicalHashRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const CanonicalHashRequest& default_instance() { return *internal_default_instance(); } static inline const CanonicalHashRequest* internal_default_instance() { return reinterpret_cast( &_CanonicalHashRequest_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(CanonicalHashRequest& a, CanonicalHashRequest& b) { a.Swap(&b); } inline void Swap(CanonicalHashRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CanonicalHashRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CanonicalHashRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const CanonicalHashRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const CanonicalHashRequest& from) { CanonicalHashRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(CanonicalHashRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.CanonicalHashRequest"; } protected: explicit CanonicalHashRequest(::google::protobuf::Arena* arena); CanonicalHashRequest(::google::protobuf::Arena* arena, const CanonicalHashRequest& from); CanonicalHashRequest(::google::protobuf::Arena* arena, CanonicalHashRequest&& from) noexcept : CanonicalHashRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockNumberFieldNumber = 1, }; // uint64 block_number = 1; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.CanonicalHashRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_CanonicalHashRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const CanonicalHashRequest& from_msg); ::uint64_t block_number_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class CanonicalBodyForStorageRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.CanonicalBodyForStorageRequest) */ { public: inline CanonicalBodyForStorageRequest() : CanonicalBodyForStorageRequest(nullptr) {} ~CanonicalBodyForStorageRequest() override; template explicit PROTOBUF_CONSTEXPR CanonicalBodyForStorageRequest( ::google::protobuf::internal::ConstantInitialized); inline CanonicalBodyForStorageRequest(const CanonicalBodyForStorageRequest& from) : CanonicalBodyForStorageRequest(nullptr, from) {} inline CanonicalBodyForStorageRequest(CanonicalBodyForStorageRequest&& from) noexcept : CanonicalBodyForStorageRequest(nullptr, std::move(from)) {} inline CanonicalBodyForStorageRequest& operator=(const CanonicalBodyForStorageRequest& from) { CopyFrom(from); return *this; } inline CanonicalBodyForStorageRequest& operator=(CanonicalBodyForStorageRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const CanonicalBodyForStorageRequest& default_instance() { return *internal_default_instance(); } static inline const CanonicalBodyForStorageRequest* internal_default_instance() { return reinterpret_cast( &_CanonicalBodyForStorageRequest_default_instance_); } static constexpr int kIndexInFileMessages = 16; friend void swap(CanonicalBodyForStorageRequest& a, CanonicalBodyForStorageRequest& b) { a.Swap(&b); } inline void Swap(CanonicalBodyForStorageRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CanonicalBodyForStorageRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CanonicalBodyForStorageRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const CanonicalBodyForStorageRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const CanonicalBodyForStorageRequest& from) { CanonicalBodyForStorageRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(CanonicalBodyForStorageRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.CanonicalBodyForStorageRequest"; } protected: explicit CanonicalBodyForStorageRequest(::google::protobuf::Arena* arena); CanonicalBodyForStorageRequest(::google::protobuf::Arena* arena, const CanonicalBodyForStorageRequest& from); CanonicalBodyForStorageRequest(::google::protobuf::Arena* arena, CanonicalBodyForStorageRequest&& from) noexcept : CanonicalBodyForStorageRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockNumberFieldNumber = 1, }; // uint64 blockNumber = 1; void clear_blocknumber() ; ::uint64_t blocknumber() const; void set_blocknumber(::uint64_t value); private: ::uint64_t _internal_blocknumber() const; void _internal_set_blocknumber(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.CanonicalBodyForStorageRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_CanonicalBodyForStorageRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const CanonicalBodyForStorageRequest& from_msg); ::uint64_t blocknumber_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class CanonicalBodyForStorageReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.CanonicalBodyForStorageReply) */ { public: inline CanonicalBodyForStorageReply() : CanonicalBodyForStorageReply(nullptr) {} ~CanonicalBodyForStorageReply() override; template explicit PROTOBUF_CONSTEXPR CanonicalBodyForStorageReply( ::google::protobuf::internal::ConstantInitialized); inline CanonicalBodyForStorageReply(const CanonicalBodyForStorageReply& from) : CanonicalBodyForStorageReply(nullptr, from) {} inline CanonicalBodyForStorageReply(CanonicalBodyForStorageReply&& from) noexcept : CanonicalBodyForStorageReply(nullptr, std::move(from)) {} inline CanonicalBodyForStorageReply& operator=(const CanonicalBodyForStorageReply& from) { CopyFrom(from); return *this; } inline CanonicalBodyForStorageReply& operator=(CanonicalBodyForStorageReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const CanonicalBodyForStorageReply& default_instance() { return *internal_default_instance(); } static inline const CanonicalBodyForStorageReply* internal_default_instance() { return reinterpret_cast( &_CanonicalBodyForStorageReply_default_instance_); } static constexpr int kIndexInFileMessages = 17; friend void swap(CanonicalBodyForStorageReply& a, CanonicalBodyForStorageReply& b) { a.Swap(&b); } inline void Swap(CanonicalBodyForStorageReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CanonicalBodyForStorageReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CanonicalBodyForStorageReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const CanonicalBodyForStorageReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const CanonicalBodyForStorageReply& from) { CanonicalBodyForStorageReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(CanonicalBodyForStorageReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.CanonicalBodyForStorageReply"; } protected: explicit CanonicalBodyForStorageReply(::google::protobuf::Arena* arena); CanonicalBodyForStorageReply(::google::protobuf::Arena* arena, const CanonicalBodyForStorageReply& from); CanonicalBodyForStorageReply(::google::protobuf::Arena* arena, CanonicalBodyForStorageReply&& from) noexcept : CanonicalBodyForStorageReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBodyFieldNumber = 1, }; // bytes body = 1; void clear_body() ; const std::string& body() const; template void set_body(Arg_&& arg, Args_... args); std::string* mutable_body(); PROTOBUF_NODISCARD std::string* release_body(); void set_allocated_body(std::string* value); private: const std::string& _internal_body() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_body( const std::string& value); std::string* _internal_mutable_body(); public: // @@protoc_insertion_point(class_scope:remote.CanonicalBodyForStorageReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_CanonicalBodyForStorageReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const CanonicalBodyForStorageReply& from_msg); ::google::protobuf::internal::ArenaStringPtr body_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class BlockReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BlockReply) */ { public: inline BlockReply() : BlockReply(nullptr) {} ~BlockReply() override; template explicit PROTOBUF_CONSTEXPR BlockReply( ::google::protobuf::internal::ConstantInitialized); inline BlockReply(const BlockReply& from) : BlockReply(nullptr, from) {} inline BlockReply(BlockReply&& from) noexcept : BlockReply(nullptr, std::move(from)) {} inline BlockReply& operator=(const BlockReply& from) { CopyFrom(from); return *this; } inline BlockReply& operator=(BlockReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BlockReply& default_instance() { return *internal_default_instance(); } static inline const BlockReply* internal_default_instance() { return reinterpret_cast( &_BlockReply_default_instance_); } static constexpr int kIndexInFileMessages = 23; friend void swap(BlockReply& a, BlockReply& b) { a.Swap(&b); } inline void Swap(BlockReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BlockReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BlockReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BlockReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BlockReply& from) { BlockReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BlockReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BlockReply"; } protected: explicit BlockReply(::google::protobuf::Arena* arena); BlockReply(::google::protobuf::Arena* arena, const BlockReply& from); BlockReply(::google::protobuf::Arena* arena, BlockReply&& from) noexcept : BlockReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockRlpFieldNumber = 1, kSendersFieldNumber = 2, }; // bytes block_rlp = 1; void clear_block_rlp() ; const std::string& block_rlp() const; template void set_block_rlp(Arg_&& arg, Args_... args); std::string* mutable_block_rlp(); PROTOBUF_NODISCARD std::string* release_block_rlp(); void set_allocated_block_rlp(std::string* value); private: const std::string& _internal_block_rlp() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_block_rlp( const std::string& value); std::string* _internal_mutable_block_rlp(); public: // bytes senders = 2; void clear_senders() ; const std::string& senders() const; template void set_senders(Arg_&& arg, Args_... args); std::string* mutable_senders(); PROTOBUF_NODISCARD std::string* release_senders(); void set_allocated_senders(std::string* value); private: const std::string& _internal_senders() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_senders( const std::string& value); std::string* _internal_mutable_senders(); public: // @@protoc_insertion_point(class_scope:remote.BlockReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BlockReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BlockReply& from_msg); ::google::protobuf::internal::ArenaStringPtr block_rlp_; ::google::protobuf::internal::ArenaStringPtr senders_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class AddPeerRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.AddPeerRequest) */ { public: inline AddPeerRequest() : AddPeerRequest(nullptr) {} ~AddPeerRequest() override; template explicit PROTOBUF_CONSTEXPR AddPeerRequest( ::google::protobuf::internal::ConstantInitialized); inline AddPeerRequest(const AddPeerRequest& from) : AddPeerRequest(nullptr, from) {} inline AddPeerRequest(AddPeerRequest&& from) noexcept : AddPeerRequest(nullptr, std::move(from)) {} inline AddPeerRequest& operator=(const AddPeerRequest& from) { CopyFrom(from); return *this; } inline AddPeerRequest& operator=(AddPeerRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AddPeerRequest& default_instance() { return *internal_default_instance(); } static inline const AddPeerRequest* internal_default_instance() { return reinterpret_cast( &_AddPeerRequest_default_instance_); } static constexpr int kIndexInFileMessages = 27; friend void swap(AddPeerRequest& a, AddPeerRequest& b) { a.Swap(&b); } inline void Swap(AddPeerRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AddPeerRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AddPeerRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AddPeerRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AddPeerRequest& from) { AddPeerRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AddPeerRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.AddPeerRequest"; } protected: explicit AddPeerRequest(::google::protobuf::Arena* arena); AddPeerRequest(::google::protobuf::Arena* arena, const AddPeerRequest& from); AddPeerRequest(::google::protobuf::Arena* arena, AddPeerRequest&& from) noexcept : AddPeerRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kUrlFieldNumber = 1, }; // string url = 1; void clear_url() ; const std::string& url() const; template void set_url(Arg_&& arg, Args_... args); std::string* mutable_url(); PROTOBUF_NODISCARD std::string* release_url(); void set_allocated_url(std::string* value); private: const std::string& _internal_url() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_url( const std::string& value); std::string* _internal_mutable_url(); public: // @@protoc_insertion_point(class_scope:remote.AddPeerRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 33, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AddPeerRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AddPeerRequest& from_msg); ::google::protobuf::internal::ArenaStringPtr url_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class AddPeerReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.AddPeerReply) */ { public: inline AddPeerReply() : AddPeerReply(nullptr) {} ~AddPeerReply() override; template explicit PROTOBUF_CONSTEXPR AddPeerReply( ::google::protobuf::internal::ConstantInitialized); inline AddPeerReply(const AddPeerReply& from) : AddPeerReply(nullptr, from) {} inline AddPeerReply(AddPeerReply&& from) noexcept : AddPeerReply(nullptr, std::move(from)) {} inline AddPeerReply& operator=(const AddPeerReply& from) { CopyFrom(from); return *this; } inline AddPeerReply& operator=(AddPeerReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AddPeerReply& default_instance() { return *internal_default_instance(); } static inline const AddPeerReply* internal_default_instance() { return reinterpret_cast( &_AddPeerReply_default_instance_); } static constexpr int kIndexInFileMessages = 30; friend void swap(AddPeerReply& a, AddPeerReply& b) { a.Swap(&b); } inline void Swap(AddPeerReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AddPeerReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AddPeerReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AddPeerReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AddPeerReply& from) { AddPeerReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AddPeerReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.AddPeerReply"; } protected: explicit AddPeerReply(::google::protobuf::Arena* arena); AddPeerReply(::google::protobuf::Arena* arena, const AddPeerReply& from); AddPeerReply(::google::protobuf::Arena* arena, AddPeerReply&& from) noexcept : AddPeerReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSuccessFieldNumber = 1, }; // bool success = 1; void clear_success() ; bool success() const; void set_success(bool value); private: bool _internal_success() const; void _internal_set_success(bool value); public: // @@protoc_insertion_point(class_scope:remote.AddPeerReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AddPeerReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AddPeerReply& from_msg); bool success_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class SyncingReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.SyncingReply) */ { public: inline SyncingReply() : SyncingReply(nullptr) {} ~SyncingReply() override; template explicit PROTOBUF_CONSTEXPR SyncingReply( ::google::protobuf::internal::ConstantInitialized); inline SyncingReply(const SyncingReply& from) : SyncingReply(nullptr, from) {} inline SyncingReply(SyncingReply&& from) noexcept : SyncingReply(nullptr, std::move(from)) {} inline SyncingReply& operator=(const SyncingReply& from) { CopyFrom(from); return *this; } inline SyncingReply& operator=(SyncingReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SyncingReply& default_instance() { return *internal_default_instance(); } static inline const SyncingReply* internal_default_instance() { return reinterpret_cast( &_SyncingReply_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(SyncingReply& a, SyncingReply& b) { a.Swap(&b); } inline void Swap(SyncingReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SyncingReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SyncingReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SyncingReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SyncingReply& from) { SyncingReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SyncingReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.SyncingReply"; } protected: explicit SyncingReply(::google::protobuf::Arena* arena); SyncingReply(::google::protobuf::Arena* arena, const SyncingReply& from); SyncingReply(::google::protobuf::Arena* arena, SyncingReply&& from) noexcept : SyncingReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- using StageProgress = SyncingReply_StageProgress; // accessors ------------------------------------------------------- enum : int { kStagesFieldNumber = 5, kLastNewBlockSeenFieldNumber = 1, kFrozenBlocksFieldNumber = 2, kCurrentBlockFieldNumber = 3, kSyncingFieldNumber = 4, }; // repeated .remote.SyncingReply.StageProgress stages = 5; int stages_size() const; private: int _internal_stages_size() const; public: void clear_stages() ; ::remote::SyncingReply_StageProgress* mutable_stages(int index); ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>* mutable_stages(); private: const ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>& _internal_stages() const; ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>* _internal_mutable_stages(); public: const ::remote::SyncingReply_StageProgress& stages(int index) const; ::remote::SyncingReply_StageProgress* add_stages(); const ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>& stages() const; // uint64 last_new_block_seen = 1; void clear_last_new_block_seen() ; ::uint64_t last_new_block_seen() const; void set_last_new_block_seen(::uint64_t value); private: ::uint64_t _internal_last_new_block_seen() const; void _internal_set_last_new_block_seen(::uint64_t value); public: // uint64 frozen_blocks = 2; void clear_frozen_blocks() ; ::uint64_t frozen_blocks() const; void set_frozen_blocks(::uint64_t value); private: ::uint64_t _internal_frozen_blocks() const; void _internal_set_frozen_blocks(::uint64_t value); public: // uint64 current_block = 3; void clear_current_block() ; ::uint64_t current_block() const; void set_current_block(::uint64_t value); private: ::uint64_t _internal_current_block() const; void _internal_set_current_block(::uint64_t value); public: // bool syncing = 4; void clear_syncing() ; bool syncing() const; void set_syncing(bool value); private: bool _internal_syncing() const; void _internal_set_syncing(bool value); public: // @@protoc_insertion_point(class_scope:remote.SyncingReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 5, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SyncingReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SyncingReply& from_msg); ::google::protobuf::RepeatedPtrField< ::remote::SyncingReply_StageProgress > stages_; ::uint64_t last_new_block_seen_; ::uint64_t frozen_blocks_; ::uint64_t current_block_; bool syncing_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class PeersReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.PeersReply) */ { public: inline PeersReply() : PeersReply(nullptr) {} ~PeersReply() override; template explicit PROTOBUF_CONSTEXPR PeersReply( ::google::protobuf::internal::ConstantInitialized); inline PeersReply(const PeersReply& from) : PeersReply(nullptr, from) {} inline PeersReply(PeersReply&& from) noexcept : PeersReply(nullptr, std::move(from)) {} inline PeersReply& operator=(const PeersReply& from) { CopyFrom(from); return *this; } inline PeersReply& operator=(PeersReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeersReply& default_instance() { return *internal_default_instance(); } static inline const PeersReply* internal_default_instance() { return reinterpret_cast( &_PeersReply_default_instance_); } static constexpr int kIndexInFileMessages = 29; friend void swap(PeersReply& a, PeersReply& b) { a.Swap(&b); } inline void Swap(PeersReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeersReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeersReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeersReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeersReply& from) { PeersReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeersReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.PeersReply"; } protected: explicit PeersReply(::google::protobuf::Arena* arena); PeersReply(::google::protobuf::Arena* arena, const PeersReply& from); PeersReply(::google::protobuf::Arena* arena, PeersReply&& from) noexcept : PeersReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPeersFieldNumber = 1, }; // repeated .types.PeerInfo peers = 1; int peers_size() const; private: int _internal_peers_size() const; public: void clear_peers() ; ::types::PeerInfo* mutable_peers(int index); ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* mutable_peers(); private: const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& _internal_peers() const; ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* _internal_mutable_peers(); public: const ::types::PeerInfo& peers(int index) const; ::types::PeerInfo* add_peers(); const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& peers() const; // @@protoc_insertion_point(class_scope:remote.PeersReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeersReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeersReply& from_msg); ::google::protobuf::RepeatedPtrField< ::types::PeerInfo > peers_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class TxnLookupRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.TxnLookupRequest) */ { public: inline TxnLookupRequest() : TxnLookupRequest(nullptr) {} ~TxnLookupRequest() override; template explicit PROTOBUF_CONSTEXPR TxnLookupRequest( ::google::protobuf::internal::ConstantInitialized); inline TxnLookupRequest(const TxnLookupRequest& from) : TxnLookupRequest(nullptr, from) {} inline TxnLookupRequest(TxnLookupRequest&& from) noexcept : TxnLookupRequest(nullptr, std::move(from)) {} inline TxnLookupRequest& operator=(const TxnLookupRequest& from) { CopyFrom(from); return *this; } inline TxnLookupRequest& operator=(TxnLookupRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const TxnLookupRequest& default_instance() { return *internal_default_instance(); } static inline const TxnLookupRequest* internal_default_instance() { return reinterpret_cast( &_TxnLookupRequest_default_instance_); } static constexpr int kIndexInFileMessages = 24; friend void swap(TxnLookupRequest& a, TxnLookupRequest& b) { a.Swap(&b); } inline void Swap(TxnLookupRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TxnLookupRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TxnLookupRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const TxnLookupRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const TxnLookupRequest& from) { TxnLookupRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(TxnLookupRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.TxnLookupRequest"; } protected: explicit TxnLookupRequest(::google::protobuf::Arena* arena); TxnLookupRequest(::google::protobuf::Arena* arena, const TxnLookupRequest& from); TxnLookupRequest(::google::protobuf::Arena* arena, TxnLookupRequest&& from) noexcept : TxnLookupRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTxnHashFieldNumber = 1, }; // .types.H256 txn_hash = 1; bool has_txn_hash() const; void clear_txn_hash() ; const ::types::H256& txn_hash() const; PROTOBUF_NODISCARD ::types::H256* release_txn_hash(); ::types::H256* mutable_txn_hash(); void set_allocated_txn_hash(::types::H256* value); void unsafe_arena_set_allocated_txn_hash(::types::H256* value); ::types::H256* unsafe_arena_release_txn_hash(); private: const ::types::H256& _internal_txn_hash() const; ::types::H256* _internal_mutable_txn_hash(); public: // @@protoc_insertion_point(class_scope:remote.TxnLookupRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_TxnLookupRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const TxnLookupRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* txn_hash_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class SubscribeLogsReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.SubscribeLogsReply) */ { public: inline SubscribeLogsReply() : SubscribeLogsReply(nullptr) {} ~SubscribeLogsReply() override; template explicit PROTOBUF_CONSTEXPR SubscribeLogsReply( ::google::protobuf::internal::ConstantInitialized); inline SubscribeLogsReply(const SubscribeLogsReply& from) : SubscribeLogsReply(nullptr, from) {} inline SubscribeLogsReply(SubscribeLogsReply&& from) noexcept : SubscribeLogsReply(nullptr, std::move(from)) {} inline SubscribeLogsReply& operator=(const SubscribeLogsReply& from) { CopyFrom(from); return *this; } inline SubscribeLogsReply& operator=(SubscribeLogsReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SubscribeLogsReply& default_instance() { return *internal_default_instance(); } static inline const SubscribeLogsReply* internal_default_instance() { return reinterpret_cast( &_SubscribeLogsReply_default_instance_); } static constexpr int kIndexInFileMessages = 21; friend void swap(SubscribeLogsReply& a, SubscribeLogsReply& b) { a.Swap(&b); } inline void Swap(SubscribeLogsReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubscribeLogsReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubscribeLogsReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SubscribeLogsReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SubscribeLogsReply& from) { SubscribeLogsReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SubscribeLogsReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.SubscribeLogsReply"; } protected: explicit SubscribeLogsReply(::google::protobuf::Arena* arena); SubscribeLogsReply(::google::protobuf::Arena* arena, const SubscribeLogsReply& from); SubscribeLogsReply(::google::protobuf::Arena* arena, SubscribeLogsReply&& from) noexcept : SubscribeLogsReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTopicsFieldNumber = 6, kDataFieldNumber = 4, kAddressFieldNumber = 1, kBlockHashFieldNumber = 2, kTransactionHashFieldNumber = 7, kBlockNumberFieldNumber = 3, kLogIndexFieldNumber = 5, kTransactionIndexFieldNumber = 8, kRemovedFieldNumber = 9, }; // repeated .types.H256 topics = 6; int topics_size() const; private: int _internal_topics_size() const; public: void clear_topics() ; ::types::H256* mutable_topics(int index); ::google::protobuf::RepeatedPtrField<::types::H256>* mutable_topics(); private: const ::google::protobuf::RepeatedPtrField<::types::H256>& _internal_topics() const; ::google::protobuf::RepeatedPtrField<::types::H256>* _internal_mutable_topics(); public: const ::types::H256& topics(int index) const; ::types::H256* add_topics(); const ::google::protobuf::RepeatedPtrField<::types::H256>& topics() const; // bytes data = 4; void clear_data() ; const std::string& data() const; template void set_data(Arg_&& arg, Args_... args); std::string* mutable_data(); PROTOBUF_NODISCARD std::string* release_data(); void set_allocated_data(std::string* value); private: const std::string& _internal_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( const std::string& value); std::string* _internal_mutable_data(); public: // .types.H160 address = 1; bool has_address() const; void clear_address() ; const ::types::H160& address() const; PROTOBUF_NODISCARD ::types::H160* release_address(); ::types::H160* mutable_address(); void set_allocated_address(::types::H160* value); void unsafe_arena_set_allocated_address(::types::H160* value); ::types::H160* unsafe_arena_release_address(); private: const ::types::H160& _internal_address() const; ::types::H160* _internal_mutable_address(); public: // .types.H256 block_hash = 2; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // .types.H256 transaction_hash = 7; bool has_transaction_hash() const; void clear_transaction_hash() ; const ::types::H256& transaction_hash() const; PROTOBUF_NODISCARD ::types::H256* release_transaction_hash(); ::types::H256* mutable_transaction_hash(); void set_allocated_transaction_hash(::types::H256* value); void unsafe_arena_set_allocated_transaction_hash(::types::H256* value); ::types::H256* unsafe_arena_release_transaction_hash(); private: const ::types::H256& _internal_transaction_hash() const; ::types::H256* _internal_mutable_transaction_hash(); public: // uint64 block_number = 3; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // uint64 log_index = 5; void clear_log_index() ; ::uint64_t log_index() const; void set_log_index(::uint64_t value); private: ::uint64_t _internal_log_index() const; void _internal_set_log_index(::uint64_t value); public: // uint64 transaction_index = 8; void clear_transaction_index() ; ::uint64_t transaction_index() const; void set_transaction_index(::uint64_t value); private: ::uint64_t _internal_transaction_index() const; void _internal_set_transaction_index(::uint64_t value); public: // bool removed = 9; void clear_removed() ; bool removed() const; void set_removed(bool value); private: bool _internal_removed() const; void _internal_set_removed(bool value); public: // @@protoc_insertion_point(class_scope:remote.SubscribeLogsReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 4, 9, 4, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SubscribeLogsReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SubscribeLogsReply& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::types::H256 > topics_; ::google::protobuf::internal::ArenaStringPtr data_; ::types::H160* address_; ::types::H256* block_hash_; ::types::H256* transaction_hash_; ::uint64_t block_number_; ::uint64_t log_index_; ::uint64_t transaction_index_; bool removed_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class NodesInfoReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.NodesInfoReply) */ { public: inline NodesInfoReply() : NodesInfoReply(nullptr) {} ~NodesInfoReply() override; template explicit PROTOBUF_CONSTEXPR NodesInfoReply( ::google::protobuf::internal::ConstantInitialized); inline NodesInfoReply(const NodesInfoReply& from) : NodesInfoReply(nullptr, from) {} inline NodesInfoReply(NodesInfoReply&& from) noexcept : NodesInfoReply(nullptr, std::move(from)) {} inline NodesInfoReply& operator=(const NodesInfoReply& from) { CopyFrom(from); return *this; } inline NodesInfoReply& operator=(NodesInfoReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NodesInfoReply& default_instance() { return *internal_default_instance(); } static inline const NodesInfoReply* internal_default_instance() { return reinterpret_cast( &_NodesInfoReply_default_instance_); } static constexpr int kIndexInFileMessages = 28; friend void swap(NodesInfoReply& a, NodesInfoReply& b) { a.Swap(&b); } inline void Swap(NodesInfoReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NodesInfoReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NodesInfoReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NodesInfoReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NodesInfoReply& from) { NodesInfoReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NodesInfoReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.NodesInfoReply"; } protected: explicit NodesInfoReply(::google::protobuf::Arena* arena); NodesInfoReply(::google::protobuf::Arena* arena, const NodesInfoReply& from); NodesInfoReply(::google::protobuf::Arena* arena, NodesInfoReply&& from) noexcept : NodesInfoReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNodesInfoFieldNumber = 1, }; // repeated .types.NodeInfoReply nodes_info = 1; int nodes_info_size() const; private: int _internal_nodes_info_size() const; public: void clear_nodes_info() ; ::types::NodeInfoReply* mutable_nodes_info(int index); ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>* mutable_nodes_info(); private: const ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>& _internal_nodes_info() const; ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>* _internal_mutable_nodes_info(); public: const ::types::NodeInfoReply& nodes_info(int index) const; ::types::NodeInfoReply* add_nodes_info(); const ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>& nodes_info() const; // @@protoc_insertion_point(class_scope:remote.NodesInfoReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NodesInfoReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NodesInfoReply& from_msg); ::google::protobuf::RepeatedPtrField< ::types::NodeInfoReply > nodes_info_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class LogsFilterRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.LogsFilterRequest) */ { public: inline LogsFilterRequest() : LogsFilterRequest(nullptr) {} ~LogsFilterRequest() override; template explicit PROTOBUF_CONSTEXPR LogsFilterRequest( ::google::protobuf::internal::ConstantInitialized); inline LogsFilterRequest(const LogsFilterRequest& from) : LogsFilterRequest(nullptr, from) {} inline LogsFilterRequest(LogsFilterRequest&& from) noexcept : LogsFilterRequest(nullptr, std::move(from)) {} inline LogsFilterRequest& operator=(const LogsFilterRequest& from) { CopyFrom(from); return *this; } inline LogsFilterRequest& operator=(LogsFilterRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const LogsFilterRequest& default_instance() { return *internal_default_instance(); } static inline const LogsFilterRequest* internal_default_instance() { return reinterpret_cast( &_LogsFilterRequest_default_instance_); } static constexpr int kIndexInFileMessages = 20; friend void swap(LogsFilterRequest& a, LogsFilterRequest& b) { a.Swap(&b); } inline void Swap(LogsFilterRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(LogsFilterRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- LogsFilterRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const LogsFilterRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const LogsFilterRequest& from) { LogsFilterRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(LogsFilterRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.LogsFilterRequest"; } protected: explicit LogsFilterRequest(::google::protobuf::Arena* arena); LogsFilterRequest(::google::protobuf::Arena* arena, const LogsFilterRequest& from); LogsFilterRequest(::google::protobuf::Arena* arena, LogsFilterRequest&& from) noexcept : LogsFilterRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kAddressesFieldNumber = 2, kTopicsFieldNumber = 4, kAllAddressesFieldNumber = 1, kAllTopicsFieldNumber = 3, }; // repeated .types.H160 addresses = 2; int addresses_size() const; private: int _internal_addresses_size() const; public: void clear_addresses() ; ::types::H160* mutable_addresses(int index); ::google::protobuf::RepeatedPtrField<::types::H160>* mutable_addresses(); private: const ::google::protobuf::RepeatedPtrField<::types::H160>& _internal_addresses() const; ::google::protobuf::RepeatedPtrField<::types::H160>* _internal_mutable_addresses(); public: const ::types::H160& addresses(int index) const; ::types::H160* add_addresses(); const ::google::protobuf::RepeatedPtrField<::types::H160>& addresses() const; // repeated .types.H256 topics = 4; int topics_size() const; private: int _internal_topics_size() const; public: void clear_topics() ; ::types::H256* mutable_topics(int index); ::google::protobuf::RepeatedPtrField<::types::H256>* mutable_topics(); private: const ::google::protobuf::RepeatedPtrField<::types::H256>& _internal_topics() const; ::google::protobuf::RepeatedPtrField<::types::H256>* _internal_mutable_topics(); public: const ::types::H256& topics(int index) const; ::types::H256* add_topics(); const ::google::protobuf::RepeatedPtrField<::types::H256>& topics() const; // bool all_addresses = 1; void clear_all_addresses() ; bool all_addresses() const; void set_all_addresses(bool value); private: bool _internal_all_addresses() const; void _internal_set_all_addresses(bool value); public: // bool all_topics = 3; void clear_all_topics() ; bool all_topics() const; void set_all_topics(bool value); private: bool _internal_all_topics() const; void _internal_set_all_topics(bool value); public: // @@protoc_insertion_point(class_scope:remote.LogsFilterRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 4, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_LogsFilterRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const LogsFilterRequest& from_msg); ::google::protobuf::RepeatedPtrField< ::types::H160 > addresses_; ::google::protobuf::RepeatedPtrField< ::types::H256 > topics_; bool all_addresses_; bool all_topics_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class HeaderNumberRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.HeaderNumberRequest) */ { public: inline HeaderNumberRequest() : HeaderNumberRequest(nullptr) {} ~HeaderNumberRequest() override; template explicit PROTOBUF_CONSTEXPR HeaderNumberRequest( ::google::protobuf::internal::ConstantInitialized); inline HeaderNumberRequest(const HeaderNumberRequest& from) : HeaderNumberRequest(nullptr, from) {} inline HeaderNumberRequest(HeaderNumberRequest&& from) noexcept : HeaderNumberRequest(nullptr, std::move(from)) {} inline HeaderNumberRequest& operator=(const HeaderNumberRequest& from) { CopyFrom(from); return *this; } inline HeaderNumberRequest& operator=(HeaderNumberRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HeaderNumberRequest& default_instance() { return *internal_default_instance(); } static inline const HeaderNumberRequest* internal_default_instance() { return reinterpret_cast( &_HeaderNumberRequest_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(HeaderNumberRequest& a, HeaderNumberRequest& b) { a.Swap(&b); } inline void Swap(HeaderNumberRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HeaderNumberRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HeaderNumberRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HeaderNumberRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HeaderNumberRequest& from) { HeaderNumberRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HeaderNumberRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.HeaderNumberRequest"; } protected: explicit HeaderNumberRequest(::google::protobuf::Arena* arena); HeaderNumberRequest(::google::protobuf::Arena* arena, const HeaderNumberRequest& from); HeaderNumberRequest(::google::protobuf::Arena* arena, HeaderNumberRequest&& from) noexcept : HeaderNumberRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashFieldNumber = 1, }; // .types.H256 hash = 1; bool has_hash() const; void clear_hash() ; const ::types::H256& hash() const; PROTOBUF_NODISCARD ::types::H256* release_hash(); ::types::H256* mutable_hash(); void set_allocated_hash(::types::H256* value); void unsafe_arena_set_allocated_hash(::types::H256* value); ::types::H256* unsafe_arena_release_hash(); private: const ::types::H256& _internal_hash() const; ::types::H256* _internal_mutable_hash(); public: // @@protoc_insertion_point(class_scope:remote.HeaderNumberRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HeaderNumberRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HeaderNumberRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* hash_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class EtherbaseReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.EtherbaseReply) */ { public: inline EtherbaseReply() : EtherbaseReply(nullptr) {} ~EtherbaseReply() override; template explicit PROTOBUF_CONSTEXPR EtherbaseReply( ::google::protobuf::internal::ConstantInitialized); inline EtherbaseReply(const EtherbaseReply& from) : EtherbaseReply(nullptr, from) {} inline EtherbaseReply(EtherbaseReply&& from) noexcept : EtherbaseReply(nullptr, std::move(from)) {} inline EtherbaseReply& operator=(const EtherbaseReply& from) { CopyFrom(from); return *this; } inline EtherbaseReply& operator=(EtherbaseReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const EtherbaseReply& default_instance() { return *internal_default_instance(); } static inline const EtherbaseReply* internal_default_instance() { return reinterpret_cast( &_EtherbaseReply_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(EtherbaseReply& a, EtherbaseReply& b) { a.Swap(&b); } inline void Swap(EtherbaseReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(EtherbaseReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- EtherbaseReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const EtherbaseReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const EtherbaseReply& from) { EtherbaseReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(EtherbaseReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.EtherbaseReply"; } protected: explicit EtherbaseReply(::google::protobuf::Arena* arena); EtherbaseReply(::google::protobuf::Arena* arena, const EtherbaseReply& from); EtherbaseReply(::google::protobuf::Arena* arena, EtherbaseReply&& from) noexcept : EtherbaseReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kAddressFieldNumber = 1, }; // .types.H160 address = 1; bool has_address() const; void clear_address() ; const ::types::H160& address() const; PROTOBUF_NODISCARD ::types::H160* release_address(); ::types::H160* mutable_address(); void set_allocated_address(::types::H160* value); void unsafe_arena_set_allocated_address(::types::H160* value); ::types::H160* unsafe_arena_release_address(); private: const ::types::H160& _internal_address() const; ::types::H160* _internal_mutable_address(); public: // @@protoc_insertion_point(class_scope:remote.EtherbaseReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_EtherbaseReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const EtherbaseReply& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H160* address_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class EngineGetPayloadBodiesByHashV1Request final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.EngineGetPayloadBodiesByHashV1Request) */ { public: inline EngineGetPayloadBodiesByHashV1Request() : EngineGetPayloadBodiesByHashV1Request(nullptr) {} ~EngineGetPayloadBodiesByHashV1Request() override; template explicit PROTOBUF_CONSTEXPR EngineGetPayloadBodiesByHashV1Request( ::google::protobuf::internal::ConstantInitialized); inline EngineGetPayloadBodiesByHashV1Request(const EngineGetPayloadBodiesByHashV1Request& from) : EngineGetPayloadBodiesByHashV1Request(nullptr, from) {} inline EngineGetPayloadBodiesByHashV1Request(EngineGetPayloadBodiesByHashV1Request&& from) noexcept : EngineGetPayloadBodiesByHashV1Request(nullptr, std::move(from)) {} inline EngineGetPayloadBodiesByHashV1Request& operator=(const EngineGetPayloadBodiesByHashV1Request& from) { CopyFrom(from); return *this; } inline EngineGetPayloadBodiesByHashV1Request& operator=(EngineGetPayloadBodiesByHashV1Request&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const EngineGetPayloadBodiesByHashV1Request& default_instance() { return *internal_default_instance(); } static inline const EngineGetPayloadBodiesByHashV1Request* internal_default_instance() { return reinterpret_cast( &_EngineGetPayloadBodiesByHashV1Request_default_instance_); } static constexpr int kIndexInFileMessages = 32; friend void swap(EngineGetPayloadBodiesByHashV1Request& a, EngineGetPayloadBodiesByHashV1Request& b) { a.Swap(&b); } inline void Swap(EngineGetPayloadBodiesByHashV1Request* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(EngineGetPayloadBodiesByHashV1Request* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- EngineGetPayloadBodiesByHashV1Request* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const EngineGetPayloadBodiesByHashV1Request& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const EngineGetPayloadBodiesByHashV1Request& from) { EngineGetPayloadBodiesByHashV1Request::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(EngineGetPayloadBodiesByHashV1Request* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.EngineGetPayloadBodiesByHashV1Request"; } protected: explicit EngineGetPayloadBodiesByHashV1Request(::google::protobuf::Arena* arena); EngineGetPayloadBodiesByHashV1Request(::google::protobuf::Arena* arena, const EngineGetPayloadBodiesByHashV1Request& from); EngineGetPayloadBodiesByHashV1Request(::google::protobuf::Arena* arena, EngineGetPayloadBodiesByHashV1Request&& from) noexcept : EngineGetPayloadBodiesByHashV1Request(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashesFieldNumber = 1, }; // repeated .types.H256 hashes = 1; int hashes_size() const; private: int _internal_hashes_size() const; public: void clear_hashes() ; ::types::H256* mutable_hashes(int index); ::google::protobuf::RepeatedPtrField<::types::H256>* mutable_hashes(); private: const ::google::protobuf::RepeatedPtrField<::types::H256>& _internal_hashes() const; ::google::protobuf::RepeatedPtrField<::types::H256>* _internal_mutable_hashes(); public: const ::types::H256& hashes(int index) const; ::types::H256* add_hashes(); const ::google::protobuf::RepeatedPtrField<::types::H256>& hashes() const; // @@protoc_insertion_point(class_scope:remote.EngineGetPayloadBodiesByHashV1Request) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_EngineGetPayloadBodiesByHashV1Request_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const EngineGetPayloadBodiesByHashV1Request& from_msg); ::google::protobuf::RepeatedPtrField< ::types::H256 > hashes_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class CanonicalHashReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.CanonicalHashReply) */ { public: inline CanonicalHashReply() : CanonicalHashReply(nullptr) {} ~CanonicalHashReply() override; template explicit PROTOBUF_CONSTEXPR CanonicalHashReply( ::google::protobuf::internal::ConstantInitialized); inline CanonicalHashReply(const CanonicalHashReply& from) : CanonicalHashReply(nullptr, from) {} inline CanonicalHashReply(CanonicalHashReply&& from) noexcept : CanonicalHashReply(nullptr, std::move(from)) {} inline CanonicalHashReply& operator=(const CanonicalHashReply& from) { CopyFrom(from); return *this; } inline CanonicalHashReply& operator=(CanonicalHashReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const CanonicalHashReply& default_instance() { return *internal_default_instance(); } static inline const CanonicalHashReply* internal_default_instance() { return reinterpret_cast( &_CanonicalHashReply_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(CanonicalHashReply& a, CanonicalHashReply& b) { a.Swap(&b); } inline void Swap(CanonicalHashReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CanonicalHashReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CanonicalHashReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const CanonicalHashReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const CanonicalHashReply& from) { CanonicalHashReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(CanonicalHashReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.CanonicalHashReply"; } protected: explicit CanonicalHashReply(::google::protobuf::Arena* arena); CanonicalHashReply(::google::protobuf::Arena* arena, const CanonicalHashReply& from); CanonicalHashReply(::google::protobuf::Arena* arena, CanonicalHashReply&& from) noexcept : CanonicalHashReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashFieldNumber = 1, }; // .types.H256 hash = 1; bool has_hash() const; void clear_hash() ; const ::types::H256& hash() const; PROTOBUF_NODISCARD ::types::H256* release_hash(); ::types::H256* mutable_hash(); void set_allocated_hash(::types::H256* value); void unsafe_arena_set_allocated_hash(::types::H256* value); ::types::H256* unsafe_arena_release_hash(); private: const ::types::H256& _internal_hash() const; ::types::H256* _internal_mutable_hash(); public: // @@protoc_insertion_point(class_scope:remote.CanonicalHashReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_CanonicalHashReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const CanonicalHashReply& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* hash_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // ------------------------------------------------------------------- class BlockRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.BlockRequest) */ { public: inline BlockRequest() : BlockRequest(nullptr) {} ~BlockRequest() override; template explicit PROTOBUF_CONSTEXPR BlockRequest( ::google::protobuf::internal::ConstantInitialized); inline BlockRequest(const BlockRequest& from) : BlockRequest(nullptr, from) {} inline BlockRequest(BlockRequest&& from) noexcept : BlockRequest(nullptr, std::move(from)) {} inline BlockRequest& operator=(const BlockRequest& from) { CopyFrom(from); return *this; } inline BlockRequest& operator=(BlockRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BlockRequest& default_instance() { return *internal_default_instance(); } static inline const BlockRequest* internal_default_instance() { return reinterpret_cast( &_BlockRequest_default_instance_); } static constexpr int kIndexInFileMessages = 22; friend void swap(BlockRequest& a, BlockRequest& b) { a.Swap(&b); } inline void Swap(BlockRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BlockRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BlockRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BlockRequest& from) { BlockRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BlockRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.BlockRequest"; } protected: explicit BlockRequest(::google::protobuf::Arena* arena); BlockRequest(::google::protobuf::Arena* arena, const BlockRequest& from); BlockRequest(::google::protobuf::Arena* arena, BlockRequest&& from) noexcept : BlockRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockHashFieldNumber = 3, kBlockHeightFieldNumber = 2, }; // .types.H256 block_hash = 3; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // uint64 block_height = 2; void clear_block_height() ; ::uint64_t block_height() const; void set_block_height(::uint64_t value); private: ::uint64_t _internal_block_height() const; void _internal_set_block_height(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.BlockRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BlockRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BlockRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* block_hash_; ::uint64_t block_height_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fethbackend_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // EtherbaseRequest // ------------------------------------------------------------------- // EtherbaseReply // .types.H160 address = 1; inline bool EtherbaseReply::has_address() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); return value; } inline const ::types::H160& EtherbaseReply::_internal_address() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.address_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& EtherbaseReply::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.EtherbaseReply.address) return _internal_address(); } inline void EtherbaseReply::unsafe_arena_set_allocated_address(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } _impl_.address_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.EtherbaseReply.address) } inline ::types::H160* EtherbaseReply::release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.address_; _impl_.address_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* EtherbaseReply::unsafe_arena_release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.EtherbaseReply.address) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.address_; _impl_.address_ = nullptr; return temp; } inline ::types::H160* EtherbaseReply::_internal_mutable_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.address_ = reinterpret_cast<::types::H160*>(p); } return _impl_.address_; } inline ::types::H160* EtherbaseReply::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_address(); // @@protoc_insertion_point(field_mutable:remote.EtherbaseReply.address) return _msg; } inline void EtherbaseReply::set_allocated_address(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.address_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:remote.EtherbaseReply.address) } // ------------------------------------------------------------------- // NetVersionRequest // ------------------------------------------------------------------- // NetVersionReply // uint64 id = 1; inline void NetVersionReply::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = ::uint64_t{0u}; } inline ::uint64_t NetVersionReply::id() const { // @@protoc_insertion_point(field_get:remote.NetVersionReply.id) return _internal_id(); } inline void NetVersionReply::set_id(::uint64_t value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:remote.NetVersionReply.id) } inline ::uint64_t NetVersionReply::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_; } inline void NetVersionReply::_internal_set_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = value; } // ------------------------------------------------------------------- // SyncingReply_StageProgress // string stage_name = 1; inline void SyncingReply_StageProgress::clear_stage_name() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stage_name_.ClearToEmpty(); } inline const std::string& SyncingReply_StageProgress::stage_name() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SyncingReply.StageProgress.stage_name) return _internal_stage_name(); } template inline PROTOBUF_ALWAYS_INLINE void SyncingReply_StageProgress::set_stage_name(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stage_name_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.SyncingReply.StageProgress.stage_name) } inline std::string* SyncingReply_StageProgress::mutable_stage_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_stage_name(); // @@protoc_insertion_point(field_mutable:remote.SyncingReply.StageProgress.stage_name) return _s; } inline const std::string& SyncingReply_StageProgress::_internal_stage_name() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.stage_name_.Get(); } inline void SyncingReply_StageProgress::_internal_set_stage_name(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stage_name_.Set(value, GetArena()); } inline std::string* SyncingReply_StageProgress::_internal_mutable_stage_name() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.stage_name_.Mutable( GetArena()); } inline std::string* SyncingReply_StageProgress::release_stage_name() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.SyncingReply.StageProgress.stage_name) return _impl_.stage_name_.Release(); } inline void SyncingReply_StageProgress::set_allocated_stage_name(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stage_name_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.stage_name_.IsDefault()) { _impl_.stage_name_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.SyncingReply.StageProgress.stage_name) } // uint64 block_number = 2; inline void SyncingReply_StageProgress::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t SyncingReply_StageProgress::block_number() const { // @@protoc_insertion_point(field_get:remote.SyncingReply.StageProgress.block_number) return _internal_block_number(); } inline void SyncingReply_StageProgress::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:remote.SyncingReply.StageProgress.block_number) } inline ::uint64_t SyncingReply_StageProgress::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void SyncingReply_StageProgress::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // ------------------------------------------------------------------- // SyncingReply // uint64 last_new_block_seen = 1; inline void SyncingReply::clear_last_new_block_seen() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.last_new_block_seen_ = ::uint64_t{0u}; } inline ::uint64_t SyncingReply::last_new_block_seen() const { // @@protoc_insertion_point(field_get:remote.SyncingReply.last_new_block_seen) return _internal_last_new_block_seen(); } inline void SyncingReply::set_last_new_block_seen(::uint64_t value) { _internal_set_last_new_block_seen(value); // @@protoc_insertion_point(field_set:remote.SyncingReply.last_new_block_seen) } inline ::uint64_t SyncingReply::_internal_last_new_block_seen() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.last_new_block_seen_; } inline void SyncingReply::_internal_set_last_new_block_seen(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.last_new_block_seen_ = value; } // uint64 frozen_blocks = 2; inline void SyncingReply::clear_frozen_blocks() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.frozen_blocks_ = ::uint64_t{0u}; } inline ::uint64_t SyncingReply::frozen_blocks() const { // @@protoc_insertion_point(field_get:remote.SyncingReply.frozen_blocks) return _internal_frozen_blocks(); } inline void SyncingReply::set_frozen_blocks(::uint64_t value) { _internal_set_frozen_blocks(value); // @@protoc_insertion_point(field_set:remote.SyncingReply.frozen_blocks) } inline ::uint64_t SyncingReply::_internal_frozen_blocks() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.frozen_blocks_; } inline void SyncingReply::_internal_set_frozen_blocks(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.frozen_blocks_ = value; } // uint64 current_block = 3; inline void SyncingReply::clear_current_block() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.current_block_ = ::uint64_t{0u}; } inline ::uint64_t SyncingReply::current_block() const { // @@protoc_insertion_point(field_get:remote.SyncingReply.current_block) return _internal_current_block(); } inline void SyncingReply::set_current_block(::uint64_t value) { _internal_set_current_block(value); // @@protoc_insertion_point(field_set:remote.SyncingReply.current_block) } inline ::uint64_t SyncingReply::_internal_current_block() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.current_block_; } inline void SyncingReply::_internal_set_current_block(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.current_block_ = value; } // bool syncing = 4; inline void SyncingReply::clear_syncing() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.syncing_ = false; } inline bool SyncingReply::syncing() const { // @@protoc_insertion_point(field_get:remote.SyncingReply.syncing) return _internal_syncing(); } inline void SyncingReply::set_syncing(bool value) { _internal_set_syncing(value); // @@protoc_insertion_point(field_set:remote.SyncingReply.syncing) } inline bool SyncingReply::_internal_syncing() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.syncing_; } inline void SyncingReply::_internal_set_syncing(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.syncing_ = value; } // repeated .remote.SyncingReply.StageProgress stages = 5; inline int SyncingReply::_internal_stages_size() const { return _internal_stages().size(); } inline int SyncingReply::stages_size() const { return _internal_stages_size(); } inline void SyncingReply::clear_stages() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.stages_.Clear(); } inline ::remote::SyncingReply_StageProgress* SyncingReply::mutable_stages(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.SyncingReply.stages) return _internal_mutable_stages()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>* SyncingReply::mutable_stages() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.SyncingReply.stages) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_stages(); } inline const ::remote::SyncingReply_StageProgress& SyncingReply::stages(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SyncingReply.stages) return _internal_stages().Get(index); } inline ::remote::SyncingReply_StageProgress* SyncingReply::add_stages() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::remote::SyncingReply_StageProgress* _add = _internal_mutable_stages()->Add(); // @@protoc_insertion_point(field_add:remote.SyncingReply.stages) return _add; } inline const ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>& SyncingReply::stages() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.SyncingReply.stages) return _internal_stages(); } inline const ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>& SyncingReply::_internal_stages() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.stages_; } inline ::google::protobuf::RepeatedPtrField<::remote::SyncingReply_StageProgress>* SyncingReply::_internal_mutable_stages() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.stages_; } // ------------------------------------------------------------------- // NetPeerCountRequest // ------------------------------------------------------------------- // NetPeerCountReply // uint64 count = 1; inline void NetPeerCountReply::clear_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = ::uint64_t{0u}; } inline ::uint64_t NetPeerCountReply::count() const { // @@protoc_insertion_point(field_get:remote.NetPeerCountReply.count) return _internal_count(); } inline void NetPeerCountReply::set_count(::uint64_t value) { _internal_set_count(value); // @@protoc_insertion_point(field_set:remote.NetPeerCountReply.count) } inline ::uint64_t NetPeerCountReply::_internal_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.count_; } inline void NetPeerCountReply::_internal_set_count(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = value; } // ------------------------------------------------------------------- // ProtocolVersionRequest // ------------------------------------------------------------------- // ProtocolVersionReply // uint64 id = 1; inline void ProtocolVersionReply::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = ::uint64_t{0u}; } inline ::uint64_t ProtocolVersionReply::id() const { // @@protoc_insertion_point(field_get:remote.ProtocolVersionReply.id) return _internal_id(); } inline void ProtocolVersionReply::set_id(::uint64_t value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:remote.ProtocolVersionReply.id) } inline ::uint64_t ProtocolVersionReply::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_; } inline void ProtocolVersionReply::_internal_set_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_ = value; } // ------------------------------------------------------------------- // ClientVersionRequest // ------------------------------------------------------------------- // ClientVersionReply // string node_name = 1; inline void ClientVersionReply::clear_node_name() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.node_name_.ClearToEmpty(); } inline const std::string& ClientVersionReply::node_name() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.ClientVersionReply.node_name) return _internal_node_name(); } template inline PROTOBUF_ALWAYS_INLINE void ClientVersionReply::set_node_name(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.node_name_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.ClientVersionReply.node_name) } inline std::string* ClientVersionReply::mutable_node_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_node_name(); // @@protoc_insertion_point(field_mutable:remote.ClientVersionReply.node_name) return _s; } inline const std::string& ClientVersionReply::_internal_node_name() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.node_name_.Get(); } inline void ClientVersionReply::_internal_set_node_name(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.node_name_.Set(value, GetArena()); } inline std::string* ClientVersionReply::_internal_mutable_node_name() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.node_name_.Mutable( GetArena()); } inline std::string* ClientVersionReply::release_node_name() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.ClientVersionReply.node_name) return _impl_.node_name_.Release(); } inline void ClientVersionReply::set_allocated_node_name(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.node_name_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.node_name_.IsDefault()) { _impl_.node_name_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.ClientVersionReply.node_name) } // ------------------------------------------------------------------- // CanonicalHashRequest // uint64 block_number = 1; inline void CanonicalHashRequest::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t CanonicalHashRequest::block_number() const { // @@protoc_insertion_point(field_get:remote.CanonicalHashRequest.block_number) return _internal_block_number(); } inline void CanonicalHashRequest::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:remote.CanonicalHashRequest.block_number) } inline ::uint64_t CanonicalHashRequest::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void CanonicalHashRequest::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // ------------------------------------------------------------------- // CanonicalHashReply // .types.H256 hash = 1; inline bool CanonicalHashReply::has_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hash_ != nullptr); return value; } inline const ::types::H256& CanonicalHashReply::_internal_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& CanonicalHashReply::hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.CanonicalHashReply.hash) return _internal_hash(); } inline void CanonicalHashReply::unsafe_arena_set_allocated_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hash_); } _impl_.hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.CanonicalHashReply.hash) } inline ::types::H256* CanonicalHashReply::release_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.hash_; _impl_.hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* CanonicalHashReply::unsafe_arena_release_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.CanonicalHashReply.hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.hash_; _impl_.hash_ = nullptr; return temp; } inline ::types::H256* CanonicalHashReply::_internal_mutable_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.hash_; } inline ::types::H256* CanonicalHashReply::mutable_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_hash(); // @@protoc_insertion_point(field_mutable:remote.CanonicalHashReply.hash) return _msg; } inline void CanonicalHashReply::set_allocated_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.CanonicalHashReply.hash) } // ------------------------------------------------------------------- // HeaderNumberRequest // .types.H256 hash = 1; inline bool HeaderNumberRequest::has_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hash_ != nullptr); return value; } inline const ::types::H256& HeaderNumberRequest::_internal_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& HeaderNumberRequest::hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.HeaderNumberRequest.hash) return _internal_hash(); } inline void HeaderNumberRequest::unsafe_arena_set_allocated_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hash_); } _impl_.hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.HeaderNumberRequest.hash) } inline ::types::H256* HeaderNumberRequest::release_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.hash_; _impl_.hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* HeaderNumberRequest::unsafe_arena_release_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.HeaderNumberRequest.hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.hash_; _impl_.hash_ = nullptr; return temp; } inline ::types::H256* HeaderNumberRequest::_internal_mutable_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.hash_; } inline ::types::H256* HeaderNumberRequest::mutable_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_hash(); // @@protoc_insertion_point(field_mutable:remote.HeaderNumberRequest.hash) return _msg; } inline void HeaderNumberRequest::set_allocated_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.HeaderNumberRequest.hash) } // ------------------------------------------------------------------- // HeaderNumberReply // optional uint64 number = 1; inline bool HeaderNumberReply::has_number() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; return value; } inline void HeaderNumberReply::clear_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.number_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00000001u; } inline ::uint64_t HeaderNumberReply::number() const { // @@protoc_insertion_point(field_get:remote.HeaderNumberReply.number) return _internal_number(); } inline void HeaderNumberReply::set_number(::uint64_t value) { _internal_set_number(value); _impl_._has_bits_[0] |= 0x00000001u; // @@protoc_insertion_point(field_set:remote.HeaderNumberReply.number) } inline ::uint64_t HeaderNumberReply::_internal_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.number_; } inline void HeaderNumberReply::_internal_set_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.number_ = value; } // ------------------------------------------------------------------- // CanonicalBodyForStorageRequest // uint64 blockNumber = 1; inline void CanonicalBodyForStorageRequest::clear_blocknumber() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blocknumber_ = ::uint64_t{0u}; } inline ::uint64_t CanonicalBodyForStorageRequest::blocknumber() const { // @@protoc_insertion_point(field_get:remote.CanonicalBodyForStorageRequest.blockNumber) return _internal_blocknumber(); } inline void CanonicalBodyForStorageRequest::set_blocknumber(::uint64_t value) { _internal_set_blocknumber(value); // @@protoc_insertion_point(field_set:remote.CanonicalBodyForStorageRequest.blockNumber) } inline ::uint64_t CanonicalBodyForStorageRequest::_internal_blocknumber() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.blocknumber_; } inline void CanonicalBodyForStorageRequest::_internal_set_blocknumber(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blocknumber_ = value; } // ------------------------------------------------------------------- // CanonicalBodyForStorageReply // bytes body = 1; inline void CanonicalBodyForStorageReply::clear_body() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.body_.ClearToEmpty(); } inline const std::string& CanonicalBodyForStorageReply::body() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.CanonicalBodyForStorageReply.body) return _internal_body(); } template inline PROTOBUF_ALWAYS_INLINE void CanonicalBodyForStorageReply::set_body(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.body_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.CanonicalBodyForStorageReply.body) } inline std::string* CanonicalBodyForStorageReply::mutable_body() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_body(); // @@protoc_insertion_point(field_mutable:remote.CanonicalBodyForStorageReply.body) return _s; } inline const std::string& CanonicalBodyForStorageReply::_internal_body() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.body_.Get(); } inline void CanonicalBodyForStorageReply::_internal_set_body(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.body_.Set(value, GetArena()); } inline std::string* CanonicalBodyForStorageReply::_internal_mutable_body() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.body_.Mutable( GetArena()); } inline std::string* CanonicalBodyForStorageReply::release_body() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.CanonicalBodyForStorageReply.body) return _impl_.body_.Release(); } inline void CanonicalBodyForStorageReply::set_allocated_body(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.body_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.body_.IsDefault()) { _impl_.body_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.CanonicalBodyForStorageReply.body) } // ------------------------------------------------------------------- // SubscribeRequest // .remote.Event type = 1; inline void SubscribeRequest::clear_type() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = 0; } inline ::remote::Event SubscribeRequest::type() const { // @@protoc_insertion_point(field_get:remote.SubscribeRequest.type) return _internal_type(); } inline void SubscribeRequest::set_type(::remote::Event value) { _internal_set_type(value); // @@protoc_insertion_point(field_set:remote.SubscribeRequest.type) } inline ::remote::Event SubscribeRequest::_internal_type() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::remote::Event>(_impl_.type_); } inline void SubscribeRequest::_internal_set_type(::remote::Event value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = value; } // ------------------------------------------------------------------- // SubscribeReply // .remote.Event type = 1; inline void SubscribeReply::clear_type() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = 0; } inline ::remote::Event SubscribeReply::type() const { // @@protoc_insertion_point(field_get:remote.SubscribeReply.type) return _internal_type(); } inline void SubscribeReply::set_type(::remote::Event value) { _internal_set_type(value); // @@protoc_insertion_point(field_set:remote.SubscribeReply.type) } inline ::remote::Event SubscribeReply::_internal_type() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::remote::Event>(_impl_.type_); } inline void SubscribeReply::_internal_set_type(::remote::Event value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_ = value; } // bytes data = 2; inline void SubscribeReply::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.ClearToEmpty(); } inline const std::string& SubscribeReply::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SubscribeReply.data) return _internal_data(); } template inline PROTOBUF_ALWAYS_INLINE void SubscribeReply::set_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.SubscribeReply.data) } inline std::string* SubscribeReply::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:remote.SubscribeReply.data) return _s; } inline const std::string& SubscribeReply::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.data_.Get(); } inline void SubscribeReply::_internal_set_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.Set(value, GetArena()); } inline std::string* SubscribeReply::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.data_.Mutable( GetArena()); } inline std::string* SubscribeReply::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.SubscribeReply.data) return _impl_.data_.Release(); } inline void SubscribeReply::set_allocated_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.data_.IsDefault()) { _impl_.data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.SubscribeReply.data) } // ------------------------------------------------------------------- // LogsFilterRequest // bool all_addresses = 1; inline void LogsFilterRequest::clear_all_addresses() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.all_addresses_ = false; } inline bool LogsFilterRequest::all_addresses() const { // @@protoc_insertion_point(field_get:remote.LogsFilterRequest.all_addresses) return _internal_all_addresses(); } inline void LogsFilterRequest::set_all_addresses(bool value) { _internal_set_all_addresses(value); // @@protoc_insertion_point(field_set:remote.LogsFilterRequest.all_addresses) } inline bool LogsFilterRequest::_internal_all_addresses() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.all_addresses_; } inline void LogsFilterRequest::_internal_set_all_addresses(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.all_addresses_ = value; } // repeated .types.H160 addresses = 2; inline int LogsFilterRequest::_internal_addresses_size() const { return _internal_addresses().size(); } inline int LogsFilterRequest::addresses_size() const { return _internal_addresses_size(); } inline ::types::H160* LogsFilterRequest::mutable_addresses(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.LogsFilterRequest.addresses) return _internal_mutable_addresses()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H160>* LogsFilterRequest::mutable_addresses() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.LogsFilterRequest.addresses) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_addresses(); } inline const ::types::H160& LogsFilterRequest::addresses(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.LogsFilterRequest.addresses) return _internal_addresses().Get(index); } inline ::types::H160* LogsFilterRequest::add_addresses() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H160* _add = _internal_mutable_addresses()->Add(); // @@protoc_insertion_point(field_add:remote.LogsFilterRequest.addresses) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H160>& LogsFilterRequest::addresses() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.LogsFilterRequest.addresses) return _internal_addresses(); } inline const ::google::protobuf::RepeatedPtrField<::types::H160>& LogsFilterRequest::_internal_addresses() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.addresses_; } inline ::google::protobuf::RepeatedPtrField<::types::H160>* LogsFilterRequest::_internal_mutable_addresses() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.addresses_; } // bool all_topics = 3; inline void LogsFilterRequest::clear_all_topics() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.all_topics_ = false; } inline bool LogsFilterRequest::all_topics() const { // @@protoc_insertion_point(field_get:remote.LogsFilterRequest.all_topics) return _internal_all_topics(); } inline void LogsFilterRequest::set_all_topics(bool value) { _internal_set_all_topics(value); // @@protoc_insertion_point(field_set:remote.LogsFilterRequest.all_topics) } inline bool LogsFilterRequest::_internal_all_topics() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.all_topics_; } inline void LogsFilterRequest::_internal_set_all_topics(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.all_topics_ = value; } // repeated .types.H256 topics = 4; inline int LogsFilterRequest::_internal_topics_size() const { return _internal_topics().size(); } inline int LogsFilterRequest::topics_size() const { return _internal_topics_size(); } inline ::types::H256* LogsFilterRequest::mutable_topics(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.LogsFilterRequest.topics) return _internal_mutable_topics()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H256>* LogsFilterRequest::mutable_topics() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.LogsFilterRequest.topics) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_topics(); } inline const ::types::H256& LogsFilterRequest::topics(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.LogsFilterRequest.topics) return _internal_topics().Get(index); } inline ::types::H256* LogsFilterRequest::add_topics() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H256* _add = _internal_mutable_topics()->Add(); // @@protoc_insertion_point(field_add:remote.LogsFilterRequest.topics) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& LogsFilterRequest::topics() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.LogsFilterRequest.topics) return _internal_topics(); } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& LogsFilterRequest::_internal_topics() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.topics_; } inline ::google::protobuf::RepeatedPtrField<::types::H256>* LogsFilterRequest::_internal_mutable_topics() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.topics_; } // ------------------------------------------------------------------- // SubscribeLogsReply // .types.H160 address = 1; inline bool SubscribeLogsReply::has_address() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); return value; } inline const ::types::H160& SubscribeLogsReply::_internal_address() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.address_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& SubscribeLogsReply::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.address) return _internal_address(); } inline void SubscribeLogsReply::unsafe_arena_set_allocated_address(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } _impl_.address_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.SubscribeLogsReply.address) } inline ::types::H160* SubscribeLogsReply::release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.address_; _impl_.address_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* SubscribeLogsReply::unsafe_arena_release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.SubscribeLogsReply.address) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.address_; _impl_.address_ = nullptr; return temp; } inline ::types::H160* SubscribeLogsReply::_internal_mutable_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.address_ = reinterpret_cast<::types::H160*>(p); } return _impl_.address_; } inline ::types::H160* SubscribeLogsReply::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_address(); // @@protoc_insertion_point(field_mutable:remote.SubscribeLogsReply.address) return _msg; } inline void SubscribeLogsReply::set_allocated_address(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.address_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:remote.SubscribeLogsReply.address) } // .types.H256 block_hash = 2; inline bool SubscribeLogsReply::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline const ::types::H256& SubscribeLogsReply::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& SubscribeLogsReply::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.block_hash) return _internal_block_hash(); } inline void SubscribeLogsReply::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.SubscribeLogsReply.block_hash) } inline ::types::H256* SubscribeLogsReply::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* SubscribeLogsReply::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.SubscribeLogsReply.block_hash) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* SubscribeLogsReply::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* SubscribeLogsReply::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:remote.SubscribeLogsReply.block_hash) return _msg; } inline void SubscribeLogsReply::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.SubscribeLogsReply.block_hash) } // uint64 block_number = 3; inline void SubscribeLogsReply::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t SubscribeLogsReply::block_number() const { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.block_number) return _internal_block_number(); } inline void SubscribeLogsReply::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:remote.SubscribeLogsReply.block_number) } inline ::uint64_t SubscribeLogsReply::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void SubscribeLogsReply::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // bytes data = 4; inline void SubscribeLogsReply::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.ClearToEmpty(); } inline const std::string& SubscribeLogsReply::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.data) return _internal_data(); } template inline PROTOBUF_ALWAYS_INLINE void SubscribeLogsReply::set_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.SubscribeLogsReply.data) } inline std::string* SubscribeLogsReply::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:remote.SubscribeLogsReply.data) return _s; } inline const std::string& SubscribeLogsReply::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.data_.Get(); } inline void SubscribeLogsReply::_internal_set_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.Set(value, GetArena()); } inline std::string* SubscribeLogsReply::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.data_.Mutable( GetArena()); } inline std::string* SubscribeLogsReply::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.SubscribeLogsReply.data) return _impl_.data_.Release(); } inline void SubscribeLogsReply::set_allocated_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.data_.IsDefault()) { _impl_.data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.SubscribeLogsReply.data) } // uint64 log_index = 5; inline void SubscribeLogsReply::clear_log_index() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.log_index_ = ::uint64_t{0u}; } inline ::uint64_t SubscribeLogsReply::log_index() const { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.log_index) return _internal_log_index(); } inline void SubscribeLogsReply::set_log_index(::uint64_t value) { _internal_set_log_index(value); // @@protoc_insertion_point(field_set:remote.SubscribeLogsReply.log_index) } inline ::uint64_t SubscribeLogsReply::_internal_log_index() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.log_index_; } inline void SubscribeLogsReply::_internal_set_log_index(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.log_index_ = value; } // repeated .types.H256 topics = 6; inline int SubscribeLogsReply::_internal_topics_size() const { return _internal_topics().size(); } inline int SubscribeLogsReply::topics_size() const { return _internal_topics_size(); } inline ::types::H256* SubscribeLogsReply::mutable_topics(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.SubscribeLogsReply.topics) return _internal_mutable_topics()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H256>* SubscribeLogsReply::mutable_topics() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.SubscribeLogsReply.topics) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_topics(); } inline const ::types::H256& SubscribeLogsReply::topics(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.topics) return _internal_topics().Get(index); } inline ::types::H256* SubscribeLogsReply::add_topics() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H256* _add = _internal_mutable_topics()->Add(); // @@protoc_insertion_point(field_add:remote.SubscribeLogsReply.topics) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& SubscribeLogsReply::topics() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.SubscribeLogsReply.topics) return _internal_topics(); } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& SubscribeLogsReply::_internal_topics() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.topics_; } inline ::google::protobuf::RepeatedPtrField<::types::H256>* SubscribeLogsReply::_internal_mutable_topics() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.topics_; } // .types.H256 transaction_hash = 7; inline bool SubscribeLogsReply::has_transaction_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || _impl_.transaction_hash_ != nullptr); return value; } inline const ::types::H256& SubscribeLogsReply::_internal_transaction_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.transaction_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& SubscribeLogsReply::transaction_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.transaction_hash) return _internal_transaction_hash(); } inline void SubscribeLogsReply::unsafe_arena_set_allocated_transaction_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.transaction_hash_); } _impl_.transaction_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.SubscribeLogsReply.transaction_hash) } inline ::types::H256* SubscribeLogsReply::release_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000004u; ::types::H256* released = _impl_.transaction_hash_; _impl_.transaction_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* SubscribeLogsReply::unsafe_arena_release_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.SubscribeLogsReply.transaction_hash) _impl_._has_bits_[0] &= ~0x00000004u; ::types::H256* temp = _impl_.transaction_hash_; _impl_.transaction_hash_ = nullptr; return temp; } inline ::types::H256* SubscribeLogsReply::_internal_mutable_transaction_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.transaction_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.transaction_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.transaction_hash_; } inline ::types::H256* SubscribeLogsReply::mutable_transaction_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000004u; ::types::H256* _msg = _internal_mutable_transaction_hash(); // @@protoc_insertion_point(field_mutable:remote.SubscribeLogsReply.transaction_hash) return _msg; } inline void SubscribeLogsReply::set_allocated_transaction_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.transaction_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } _impl_.transaction_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.SubscribeLogsReply.transaction_hash) } // uint64 transaction_index = 8; inline void SubscribeLogsReply::clear_transaction_index() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.transaction_index_ = ::uint64_t{0u}; } inline ::uint64_t SubscribeLogsReply::transaction_index() const { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.transaction_index) return _internal_transaction_index(); } inline void SubscribeLogsReply::set_transaction_index(::uint64_t value) { _internal_set_transaction_index(value); // @@protoc_insertion_point(field_set:remote.SubscribeLogsReply.transaction_index) } inline ::uint64_t SubscribeLogsReply::_internal_transaction_index() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.transaction_index_; } inline void SubscribeLogsReply::_internal_set_transaction_index(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.transaction_index_ = value; } // bool removed = 9; inline void SubscribeLogsReply::clear_removed() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.removed_ = false; } inline bool SubscribeLogsReply::removed() const { // @@protoc_insertion_point(field_get:remote.SubscribeLogsReply.removed) return _internal_removed(); } inline void SubscribeLogsReply::set_removed(bool value) { _internal_set_removed(value); // @@protoc_insertion_point(field_set:remote.SubscribeLogsReply.removed) } inline bool SubscribeLogsReply::_internal_removed() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.removed_; } inline void SubscribeLogsReply::_internal_set_removed(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.removed_ = value; } // ------------------------------------------------------------------- // BlockRequest // uint64 block_height = 2; inline void BlockRequest::clear_block_height() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_height_ = ::uint64_t{0u}; } inline ::uint64_t BlockRequest::block_height() const { // @@protoc_insertion_point(field_get:remote.BlockRequest.block_height) return _internal_block_height(); } inline void BlockRequest::set_block_height(::uint64_t value) { _internal_set_block_height(value); // @@protoc_insertion_point(field_set:remote.BlockRequest.block_height) } inline ::uint64_t BlockRequest::_internal_block_height() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_height_; } inline void BlockRequest::_internal_set_block_height(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_height_ = value; } // .types.H256 block_hash = 3; inline bool BlockRequest::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline const ::types::H256& BlockRequest::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& BlockRequest::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BlockRequest.block_hash) return _internal_block_hash(); } inline void BlockRequest::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.BlockRequest.block_hash) } inline ::types::H256* BlockRequest::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* BlockRequest::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.BlockRequest.block_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* BlockRequest::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* BlockRequest::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:remote.BlockRequest.block_hash) return _msg; } inline void BlockRequest::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.BlockRequest.block_hash) } // ------------------------------------------------------------------- // BlockReply // bytes block_rlp = 1; inline void BlockReply::clear_block_rlp() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.ClearToEmpty(); } inline const std::string& BlockReply::block_rlp() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BlockReply.block_rlp) return _internal_block_rlp(); } template inline PROTOBUF_ALWAYS_INLINE void BlockReply::set_block_rlp(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.BlockReply.block_rlp) } inline std::string* BlockReply::mutable_block_rlp() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_block_rlp(); // @@protoc_insertion_point(field_mutable:remote.BlockReply.block_rlp) return _s; } inline const std::string& BlockReply::_internal_block_rlp() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_rlp_.Get(); } inline void BlockReply::_internal_set_block_rlp(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.Set(value, GetArena()); } inline std::string* BlockReply::_internal_mutable_block_rlp() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.block_rlp_.Mutable( GetArena()); } inline std::string* BlockReply::release_block_rlp() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.BlockReply.block_rlp) return _impl_.block_rlp_.Release(); } inline void BlockReply::set_allocated_block_rlp(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.block_rlp_.IsDefault()) { _impl_.block_rlp_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.BlockReply.block_rlp) } // bytes senders = 2; inline void BlockReply::clear_senders() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.senders_.ClearToEmpty(); } inline const std::string& BlockReply::senders() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.BlockReply.senders) return _internal_senders(); } template inline PROTOBUF_ALWAYS_INLINE void BlockReply::set_senders(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.senders_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.BlockReply.senders) } inline std::string* BlockReply::mutable_senders() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_senders(); // @@protoc_insertion_point(field_mutable:remote.BlockReply.senders) return _s; } inline const std::string& BlockReply::_internal_senders() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.senders_.Get(); } inline void BlockReply::_internal_set_senders(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.senders_.Set(value, GetArena()); } inline std::string* BlockReply::_internal_mutable_senders() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.senders_.Mutable( GetArena()); } inline std::string* BlockReply::release_senders() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.BlockReply.senders) return _impl_.senders_.Release(); } inline void BlockReply::set_allocated_senders(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.senders_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.senders_.IsDefault()) { _impl_.senders_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.BlockReply.senders) } // ------------------------------------------------------------------- // TxnLookupRequest // .types.H256 txn_hash = 1; inline bool TxnLookupRequest::has_txn_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.txn_hash_ != nullptr); return value; } inline const ::types::H256& TxnLookupRequest::_internal_txn_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.txn_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& TxnLookupRequest::txn_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.TxnLookupRequest.txn_hash) return _internal_txn_hash(); } inline void TxnLookupRequest::unsafe_arena_set_allocated_txn_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.txn_hash_); } _impl_.txn_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.TxnLookupRequest.txn_hash) } inline ::types::H256* TxnLookupRequest::release_txn_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.txn_hash_; _impl_.txn_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* TxnLookupRequest::unsafe_arena_release_txn_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.TxnLookupRequest.txn_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.txn_hash_; _impl_.txn_hash_ = nullptr; return temp; } inline ::types::H256* TxnLookupRequest::_internal_mutable_txn_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.txn_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.txn_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.txn_hash_; } inline ::types::H256* TxnLookupRequest::mutable_txn_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_txn_hash(); // @@protoc_insertion_point(field_mutable:remote.TxnLookupRequest.txn_hash) return _msg; } inline void TxnLookupRequest::set_allocated_txn_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.txn_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.txn_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.TxnLookupRequest.txn_hash) } // ------------------------------------------------------------------- // TxnLookupReply // uint64 block_number = 1; inline void TxnLookupReply::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t TxnLookupReply::block_number() const { // @@protoc_insertion_point(field_get:remote.TxnLookupReply.block_number) return _internal_block_number(); } inline void TxnLookupReply::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:remote.TxnLookupReply.block_number) } inline ::uint64_t TxnLookupReply::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void TxnLookupReply::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // uint64 tx_number = 2; inline void TxnLookupReply::clear_tx_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_number_ = ::uint64_t{0u}; } inline ::uint64_t TxnLookupReply::tx_number() const { // @@protoc_insertion_point(field_get:remote.TxnLookupReply.tx_number) return _internal_tx_number(); } inline void TxnLookupReply::set_tx_number(::uint64_t value) { _internal_set_tx_number(value); // @@protoc_insertion_point(field_set:remote.TxnLookupReply.tx_number) } inline ::uint64_t TxnLookupReply::_internal_tx_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_number_; } inline void TxnLookupReply::_internal_set_tx_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_number_ = value; } // ------------------------------------------------------------------- // NodesInfoRequest // uint32 limit = 1; inline void NodesInfoRequest::clear_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = 0u; } inline ::uint32_t NodesInfoRequest::limit() const { // @@protoc_insertion_point(field_get:remote.NodesInfoRequest.limit) return _internal_limit(); } inline void NodesInfoRequest::set_limit(::uint32_t value) { _internal_set_limit(value); // @@protoc_insertion_point(field_set:remote.NodesInfoRequest.limit) } inline ::uint32_t NodesInfoRequest::_internal_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.limit_; } inline void NodesInfoRequest::_internal_set_limit(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = value; } // ------------------------------------------------------------------- // AddPeerRequest // string url = 1; inline void AddPeerRequest::clear_url() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.ClearToEmpty(); } inline const std::string& AddPeerRequest::url() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.AddPeerRequest.url) return _internal_url(); } template inline PROTOBUF_ALWAYS_INLINE void AddPeerRequest::set_url(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.AddPeerRequest.url) } inline std::string* AddPeerRequest::mutable_url() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_url(); // @@protoc_insertion_point(field_mutable:remote.AddPeerRequest.url) return _s; } inline const std::string& AddPeerRequest::_internal_url() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.url_.Get(); } inline void AddPeerRequest::_internal_set_url(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.Set(value, GetArena()); } inline std::string* AddPeerRequest::_internal_mutable_url() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.url_.Mutable( GetArena()); } inline std::string* AddPeerRequest::release_url() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.AddPeerRequest.url) return _impl_.url_.Release(); } inline void AddPeerRequest::set_allocated_url(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.url_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.url_.IsDefault()) { _impl_.url_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.AddPeerRequest.url) } // ------------------------------------------------------------------- // NodesInfoReply // repeated .types.NodeInfoReply nodes_info = 1; inline int NodesInfoReply::_internal_nodes_info_size() const { return _internal_nodes_info().size(); } inline int NodesInfoReply::nodes_info_size() const { return _internal_nodes_info_size(); } inline ::types::NodeInfoReply* NodesInfoReply::mutable_nodes_info(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.NodesInfoReply.nodes_info) return _internal_mutable_nodes_info()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>* NodesInfoReply::mutable_nodes_info() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.NodesInfoReply.nodes_info) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_nodes_info(); } inline const ::types::NodeInfoReply& NodesInfoReply::nodes_info(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.NodesInfoReply.nodes_info) return _internal_nodes_info().Get(index); } inline ::types::NodeInfoReply* NodesInfoReply::add_nodes_info() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::NodeInfoReply* _add = _internal_mutable_nodes_info()->Add(); // @@protoc_insertion_point(field_add:remote.NodesInfoReply.nodes_info) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>& NodesInfoReply::nodes_info() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.NodesInfoReply.nodes_info) return _internal_nodes_info(); } inline const ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>& NodesInfoReply::_internal_nodes_info() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nodes_info_; } inline ::google::protobuf::RepeatedPtrField<::types::NodeInfoReply>* NodesInfoReply::_internal_mutable_nodes_info() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.nodes_info_; } // ------------------------------------------------------------------- // PeersReply // repeated .types.PeerInfo peers = 1; inline int PeersReply::_internal_peers_size() const { return _internal_peers().size(); } inline int PeersReply::peers_size() const { return _internal_peers_size(); } inline ::types::PeerInfo* PeersReply::mutable_peers(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.PeersReply.peers) return _internal_mutable_peers()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* PeersReply::mutable_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.PeersReply.peers) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_peers(); } inline const ::types::PeerInfo& PeersReply::peers(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.PeersReply.peers) return _internal_peers().Get(index); } inline ::types::PeerInfo* PeersReply::add_peers() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::PeerInfo* _add = _internal_mutable_peers()->Add(); // @@protoc_insertion_point(field_add:remote.PeersReply.peers) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& PeersReply::peers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.PeersReply.peers) return _internal_peers(); } inline const ::google::protobuf::RepeatedPtrField<::types::PeerInfo>& PeersReply::_internal_peers() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.peers_; } inline ::google::protobuf::RepeatedPtrField<::types::PeerInfo>* PeersReply::_internal_mutable_peers() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.peers_; } // ------------------------------------------------------------------- // AddPeerReply // bool success = 1; inline void AddPeerReply::clear_success() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.success_ = false; } inline bool AddPeerReply::success() const { // @@protoc_insertion_point(field_get:remote.AddPeerReply.success) return _internal_success(); } inline void AddPeerReply::set_success(bool value) { _internal_set_success(value); // @@protoc_insertion_point(field_set:remote.AddPeerReply.success) } inline bool AddPeerReply::_internal_success() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.success_; } inline void AddPeerReply::_internal_set_success(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.success_ = value; } // ------------------------------------------------------------------- // PendingBlockReply // bytes block_rlp = 1; inline void PendingBlockReply::clear_block_rlp() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.ClearToEmpty(); } inline const std::string& PendingBlockReply::block_rlp() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.PendingBlockReply.block_rlp) return _internal_block_rlp(); } template inline PROTOBUF_ALWAYS_INLINE void PendingBlockReply::set_block_rlp(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.PendingBlockReply.block_rlp) } inline std::string* PendingBlockReply::mutable_block_rlp() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_block_rlp(); // @@protoc_insertion_point(field_mutable:remote.PendingBlockReply.block_rlp) return _s; } inline const std::string& PendingBlockReply::_internal_block_rlp() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_rlp_.Get(); } inline void PendingBlockReply::_internal_set_block_rlp(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.Set(value, GetArena()); } inline std::string* PendingBlockReply::_internal_mutable_block_rlp() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.block_rlp_.Mutable( GetArena()); } inline std::string* PendingBlockReply::release_block_rlp() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.PendingBlockReply.block_rlp) return _impl_.block_rlp_.Release(); } inline void PendingBlockReply::set_allocated_block_rlp(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_rlp_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.block_rlp_.IsDefault()) { _impl_.block_rlp_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.PendingBlockReply.block_rlp) } // ------------------------------------------------------------------- // EngineGetPayloadBodiesByHashV1Request // repeated .types.H256 hashes = 1; inline int EngineGetPayloadBodiesByHashV1Request::_internal_hashes_size() const { return _internal_hashes().size(); } inline int EngineGetPayloadBodiesByHashV1Request::hashes_size() const { return _internal_hashes_size(); } inline ::types::H256* EngineGetPayloadBodiesByHashV1Request::mutable_hashes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.EngineGetPayloadBodiesByHashV1Request.hashes) return _internal_mutable_hashes()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H256>* EngineGetPayloadBodiesByHashV1Request::mutable_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.EngineGetPayloadBodiesByHashV1Request.hashes) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_hashes(); } inline const ::types::H256& EngineGetPayloadBodiesByHashV1Request::hashes(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.EngineGetPayloadBodiesByHashV1Request.hashes) return _internal_hashes().Get(index); } inline ::types::H256* EngineGetPayloadBodiesByHashV1Request::add_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H256* _add = _internal_mutable_hashes()->Add(); // @@protoc_insertion_point(field_add:remote.EngineGetPayloadBodiesByHashV1Request.hashes) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& EngineGetPayloadBodiesByHashV1Request::hashes() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.EngineGetPayloadBodiesByHashV1Request.hashes) return _internal_hashes(); } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& EngineGetPayloadBodiesByHashV1Request::_internal_hashes() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.hashes_; } inline ::google::protobuf::RepeatedPtrField<::types::H256>* EngineGetPayloadBodiesByHashV1Request::_internal_mutable_hashes() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.hashes_; } // ------------------------------------------------------------------- // EngineGetPayloadBodiesByRangeV1Request // uint64 start = 1; inline void EngineGetPayloadBodiesByRangeV1Request::clear_start() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.start_ = ::uint64_t{0u}; } inline ::uint64_t EngineGetPayloadBodiesByRangeV1Request::start() const { // @@protoc_insertion_point(field_get:remote.EngineGetPayloadBodiesByRangeV1Request.start) return _internal_start(); } inline void EngineGetPayloadBodiesByRangeV1Request::set_start(::uint64_t value) { _internal_set_start(value); // @@protoc_insertion_point(field_set:remote.EngineGetPayloadBodiesByRangeV1Request.start) } inline ::uint64_t EngineGetPayloadBodiesByRangeV1Request::_internal_start() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.start_; } inline void EngineGetPayloadBodiesByRangeV1Request::_internal_set_start(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.start_ = value; } // uint64 count = 2; inline void EngineGetPayloadBodiesByRangeV1Request::clear_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = ::uint64_t{0u}; } inline ::uint64_t EngineGetPayloadBodiesByRangeV1Request::count() const { // @@protoc_insertion_point(field_get:remote.EngineGetPayloadBodiesByRangeV1Request.count) return _internal_count(); } inline void EngineGetPayloadBodiesByRangeV1Request::set_count(::uint64_t value) { _internal_set_count(value); // @@protoc_insertion_point(field_set:remote.EngineGetPayloadBodiesByRangeV1Request.count) } inline ::uint64_t EngineGetPayloadBodiesByRangeV1Request::_internal_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.count_; } inline void EngineGetPayloadBodiesByRangeV1Request::_internal_set_count(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.count_ = value; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace remote namespace google { namespace protobuf { template <> struct is_proto_enum<::remote::Event> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::remote::Event>() { return ::remote::Event_descriptor(); } } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_remote_2fethbackend_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/27.0/remote/ethbackend_mock.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/ethbackend.proto #ifndef GRPC_MOCK_remote_2fethbackend_2eproto__INCLUDED #define GRPC_MOCK_remote_2fethbackend_2eproto__INCLUDED #include "remote/ethbackend.pb.h" #include "remote/ethbackend.grpc.pb.h" #include #include #include namespace remote { class MockETHBACKENDStub : public ETHBACKEND::StubInterface { public: MOCK_METHOD3(Etherbase, ::grpc::Status(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::remote::EtherbaseReply* response)); MOCK_METHOD3(AsyncEtherbaseRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>*(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncEtherbaseRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::EtherbaseReply>*(::grpc::ClientContext* context, const ::remote::EtherbaseRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(NetVersion, ::grpc::Status(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::remote::NetVersionReply* response)); MOCK_METHOD3(AsyncNetVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>*(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncNetVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetVersionReply>*(::grpc::ClientContext* context, const ::remote::NetVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(NetPeerCount, ::grpc::Status(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::remote::NetPeerCountReply* response)); MOCK_METHOD3(AsyncNetPeerCountRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>*(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncNetPeerCountRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NetPeerCountReply>*(::grpc::ClientContext* context, const ::remote::NetPeerCountRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Version, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response)); MOCK_METHOD3(AsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Syncing, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::SyncingReply* response)); MOCK_METHOD3(AsyncSyncingRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSyncingRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::SyncingReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(ProtocolVersion, ::grpc::Status(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::remote::ProtocolVersionReply* response)); MOCK_METHOD3(AsyncProtocolVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>*(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncProtocolVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ProtocolVersionReply>*(::grpc::ClientContext* context, const ::remote::ProtocolVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(ClientVersion, ::grpc::Status(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::remote::ClientVersionReply* response)); MOCK_METHOD3(AsyncClientVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>*(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncClientVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::ClientVersionReply>*(::grpc::ClientContext* context, const ::remote::ClientVersionRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(SubscribeRaw, ::grpc::ClientReaderInterface< ::remote::SubscribeReply>*(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request)); MOCK_METHOD4(AsyncSubscribeRaw, ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>*(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncSubscribeRaw, ::grpc::ClientAsyncReaderInterface< ::remote::SubscribeReply>*(::grpc::ClientContext* context, const ::remote::SubscribeRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD1(SubscribeLogsRaw, ::grpc::ClientReaderWriterInterface< ::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>*(::grpc::ClientContext* context)); MOCK_METHOD3(AsyncSubscribeLogsRaw, ::grpc::ClientAsyncReaderWriterInterface<::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD2(PrepareAsyncSubscribeLogsRaw, ::grpc::ClientAsyncReaderWriterInterface<::remote::LogsFilterRequest, ::remote::SubscribeLogsReply>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Block, ::grpc::Status(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::remote::BlockReply* response)); MOCK_METHOD3(AsyncBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>*(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BlockReply>*(::grpc::ClientContext* context, const ::remote::BlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(CanonicalBodyForStorage, ::grpc::Status(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::remote::CanonicalBodyForStorageReply* response)); MOCK_METHOD3(AsyncCanonicalBodyForStorageRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>*(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncCanonicalBodyForStorageRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalBodyForStorageReply>*(::grpc::ClientContext* context, const ::remote::CanonicalBodyForStorageRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(CanonicalHash, ::grpc::Status(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::remote::CanonicalHashReply* response)); MOCK_METHOD3(AsyncCanonicalHashRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>*(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncCanonicalHashRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::CanonicalHashReply>*(::grpc::ClientContext* context, const ::remote::CanonicalHashRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(HeaderNumber, ::grpc::Status(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::remote::HeaderNumberReply* response)); MOCK_METHOD3(AsyncHeaderNumberRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>*(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHeaderNumberRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::HeaderNumberReply>*(::grpc::ClientContext* context, const ::remote::HeaderNumberRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(TxnLookup, ::grpc::Status(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::remote::TxnLookupReply* response)); MOCK_METHOD3(AsyncTxnLookupRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>*(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncTxnLookupRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::TxnLookupReply>*(::grpc::ClientContext* context, const ::remote::TxnLookupRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(NodeInfo, ::grpc::Status(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::remote::NodesInfoReply* response)); MOCK_METHOD3(AsyncNodeInfoRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>*(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncNodeInfoRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::NodesInfoReply>*(::grpc::ClientContext* context, const ::remote::NodesInfoRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Peers, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PeersReply* response)); MOCK_METHOD3(AsyncPeersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPeersRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::PeersReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(AddPeer, ::grpc::Status(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::remote::AddPeerReply* response)); MOCK_METHOD3(AsyncAddPeerRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>*(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncAddPeerRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::AddPeerReply>*(::grpc::ClientContext* context, const ::remote::AddPeerRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PendingBlock, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::remote::PendingBlockReply* response)); MOCK_METHOD3(AsyncPendingBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPendingBlockRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::PendingBlockReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(BorTxnLookup, ::grpc::Status(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::remote::BorTxnLookupReply* response)); MOCK_METHOD3(AsyncBorTxnLookupRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>*(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncBorTxnLookupRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorTxnLookupReply>*(::grpc::ClientContext* context, const ::remote::BorTxnLookupRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(BorEvents, ::grpc::Status(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::remote::BorEventsReply* response)); MOCK_METHOD3(AsyncBorEventsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>*(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncBorEventsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::BorEventsReply>*(::grpc::ClientContext* context, const ::remote::BorEventsRequest& request, ::grpc::CompletionQueue* cq)); }; } // namespace remote #endif // GRPC_MOCK_remote_2fethbackend_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/remote/kv.grpc.pb.cc ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/kv.proto #include "remote/kv.pb.h" #include "remote/kv.grpc.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace remote { static const char* KV_method_names[] = { "/remote.KV/Version", "/remote.KV/Tx", "/remote.KV/StateChanges", "/remote.KV/Snapshots", "/remote.KV/Range", "/remote.KV/GetLatest", "/remote.KV/HistorySeek", "/remote.KV/IndexRange", "/remote.KV/HistoryRange", "/remote.KV/RangeAsOf", }; std::unique_ptr< KV::Stub> KV::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< KV::Stub> stub(new KV::Stub(channel, options)); return stub; } KV::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_Version_(KV_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Tx_(KV_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) , rpcmethod_StateChanges_(KV_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_Snapshots_(KV_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Range_(KV_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_GetLatest_(KV_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_HistorySeek_(KV_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_IndexRange_(KV_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_HistoryRange_(KV_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_RangeAsOf_(KV_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status KV::Stub::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Version_, context, request, response); } void KV::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, std::move(f)); } void KV::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* KV::Stub::PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::types::VersionReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Version_, context, request); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* KV::Stub::AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::ClientReaderWriter< ::remote::Cursor, ::remote::Pair>* KV::Stub::TxRaw(::grpc::ClientContext* context) { return ::grpc::internal::ClientReaderWriterFactory< ::remote::Cursor, ::remote::Pair>::Create(channel_.get(), rpcmethod_Tx_, context); } void KV::Stub::async::Tx(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::remote::Cursor,::remote::Pair>* reactor) { ::grpc::internal::ClientCallbackReaderWriterFactory< ::remote::Cursor,::remote::Pair>::Create(stub_->channel_.get(), stub_->rpcmethod_Tx_, context, reactor); } ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>* KV::Stub::AsyncTxRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderWriterFactory< ::remote::Cursor, ::remote::Pair>::Create(channel_.get(), cq, rpcmethod_Tx_, context, true, tag); } ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>* KV::Stub::PrepareAsyncTxRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderWriterFactory< ::remote::Cursor, ::remote::Pair>::Create(channel_.get(), cq, rpcmethod_Tx_, context, false, nullptr); } ::grpc::ClientReader< ::remote::StateChangeBatch>* KV::Stub::StateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request) { return ::grpc::internal::ClientReaderFactory< ::remote::StateChangeBatch>::Create(channel_.get(), rpcmethod_StateChanges_, context, request); } void KV::Stub::async::StateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest* request, ::grpc::ClientReadReactor< ::remote::StateChangeBatch>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::remote::StateChangeBatch>::Create(stub_->channel_.get(), stub_->rpcmethod_StateChanges_, context, request, reactor); } ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>* KV::Stub::AsyncStateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::remote::StateChangeBatch>::Create(channel_.get(), cq, rpcmethod_StateChanges_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>* KV::Stub::PrepareAsyncStateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::remote::StateChangeBatch>::Create(channel_.get(), cq, rpcmethod_StateChanges_, context, request, false, nullptr); } ::grpc::Status KV::Stub::Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::remote::SnapshotsReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::SnapshotsRequest, ::remote::SnapshotsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Snapshots_, context, request, response); } void KV::Stub::async::Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::SnapshotsRequest, ::remote::SnapshotsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Snapshots_, context, request, response, std::move(f)); } void KV::Stub::async::Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Snapshots_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>* KV::Stub::PrepareAsyncSnapshotsRaw(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::SnapshotsReply, ::remote::SnapshotsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Snapshots_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>* KV::Stub::AsyncSnapshotsRaw(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSnapshotsRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status KV::Stub::Range(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::remote::Pairs* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::RangeReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Range_, context, request, response); } void KV::Stub::async::Range(::grpc::ClientContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::RangeReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, std::move(f)); } void KV::Stub::async::Range(::grpc::ClientContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* KV::Stub::PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::Pairs, ::remote::RangeReq, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Range_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* KV::Stub::AsyncRangeRaw(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncRangeRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status KV::Stub::GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::remote::GetLatestReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::GetLatestReq, ::remote::GetLatestReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetLatest_, context, request, response); } void KV::Stub::async::GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::GetLatestReq, ::remote::GetLatestReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetLatest_, context, request, response, std::move(f)); } void KV::Stub::async::GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetLatest_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>* KV::Stub::PrepareAsyncGetLatestRaw(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::GetLatestReply, ::remote::GetLatestReq, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetLatest_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>* KV::Stub::AsyncGetLatestRaw(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetLatestRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status KV::Stub::HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::remote::HistorySeekReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::HistorySeekReq, ::remote::HistorySeekReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HistorySeek_, context, request, response); } void KV::Stub::async::HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::HistorySeekReq, ::remote::HistorySeekReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HistorySeek_, context, request, response, std::move(f)); } void KV::Stub::async::HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HistorySeek_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>* KV::Stub::PrepareAsyncHistorySeekRaw(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::HistorySeekReply, ::remote::HistorySeekReq, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HistorySeek_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>* KV::Stub::AsyncHistorySeekRaw(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncHistorySeekRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status KV::Stub::IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::remote::IndexRangeReply* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::IndexRangeReq, ::remote::IndexRangeReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_IndexRange_, context, request, response); } void KV::Stub::async::IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::IndexRangeReq, ::remote::IndexRangeReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_IndexRange_, context, request, response, std::move(f)); } void KV::Stub::async::IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_IndexRange_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>* KV::Stub::PrepareAsyncIndexRangeRaw(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::IndexRangeReply, ::remote::IndexRangeReq, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_IndexRange_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>* KV::Stub::AsyncIndexRangeRaw(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncIndexRangeRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status KV::Stub::HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::remote::Pairs* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::HistoryRangeReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HistoryRange_, context, request, response); } void KV::Stub::async::HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::HistoryRangeReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HistoryRange_, context, request, response, std::move(f)); } void KV::Stub::async::HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HistoryRange_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* KV::Stub::PrepareAsyncHistoryRangeRaw(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::Pairs, ::remote::HistoryRangeReq, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HistoryRange_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* KV::Stub::AsyncHistoryRangeRaw(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncHistoryRangeRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status KV::Stub::RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::remote::Pairs* response) { return ::grpc::internal::BlockingUnaryCall< ::remote::RangeAsOfReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_RangeAsOf_, context, request, response); } void KV::Stub::async::RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::remote::RangeAsOfReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_RangeAsOf_, context, request, response, std::move(f)); } void KV::Stub::async::RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_RangeAsOf_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* KV::Stub::PrepareAsyncRangeAsOfRaw(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::remote::Pairs, ::remote::RangeAsOfReq, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_RangeAsOf_, context, request); } ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* KV::Stub::AsyncRangeAsOfRaw(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncRangeAsOfRaw(context, request, cq); result->StartCall(); return result; } KV::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::types::VersionReply* resp) { return service->Version(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[1], ::grpc::internal::RpcMethod::BIDI_STREAMING, new ::grpc::internal::BidiStreamingHandler< KV::Service, ::remote::Cursor, ::remote::Pair>( [](KV::Service* service, ::grpc::ServerContext* ctx, ::grpc::ServerReaderWriter<::remote::Pair, ::remote::Cursor>* stream) { return service->Tx(ctx, stream); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[2], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< KV::Service, ::remote::StateChangeRequest, ::remote::StateChangeBatch>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::StateChangeRequest* req, ::grpc::ServerWriter<::remote::StateChangeBatch>* writer) { return service->StateChanges(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::remote::SnapshotsRequest, ::remote::SnapshotsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::SnapshotsRequest* req, ::remote::SnapshotsReply* resp) { return service->Snapshots(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::remote::RangeReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::RangeReq* req, ::remote::Pairs* resp) { return service->Range(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::remote::GetLatestReq, ::remote::GetLatestReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::GetLatestReq* req, ::remote::GetLatestReply* resp) { return service->GetLatest(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::remote::HistorySeekReq, ::remote::HistorySeekReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::HistorySeekReq* req, ::remote::HistorySeekReply* resp) { return service->HistorySeek(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::remote::IndexRangeReq, ::remote::IndexRangeReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::IndexRangeReq* req, ::remote::IndexRangeReply* resp) { return service->IndexRange(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::remote::HistoryRangeReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::HistoryRangeReq* req, ::remote::Pairs* resp) { return service->HistoryRange(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( KV_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< KV::Service, ::remote::RangeAsOfReq, ::remote::Pairs, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](KV::Service* service, ::grpc::ServerContext* ctx, const ::remote::RangeAsOfReq* req, ::remote::Pairs* resp) { return service->RangeAsOf(ctx, req, resp); }, this))); } KV::Service::~Service() { } ::grpc::Status KV::Service::Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::Tx(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::remote::Pair, ::remote::Cursor>* stream) { (void) context; (void) stream; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::StateChanges(::grpc::ServerContext* context, const ::remote::StateChangeRequest* request, ::grpc::ServerWriter< ::remote::StateChangeBatch>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::Snapshots(::grpc::ServerContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::Range(::grpc::ServerContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::GetLatest(::grpc::ServerContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::HistorySeek(::grpc::ServerContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::IndexRange(::grpc::ServerContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::HistoryRange(::grpc::ServerContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status KV::Service::RangeAsOf(::grpc::ServerContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } } // namespace remote ================================================ FILE: silkworm/interfaces/27.0/remote/kv.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/kv.proto #ifndef GRPC_remote_2fkv_2eproto__INCLUDED #define GRPC_remote_2fkv_2eproto__INCLUDED #include "remote/kv.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace remote { // Variables Naming: // ts - TimeStamp // tx - Database Transaction // txn - Ethereum Transaction (and TxNum - is also number of Ethereum Transaction) // RoTx - Read-Only Database Transaction // RwTx - Read-Write Database Transaction // k - key // v - value // // Methods Naming: // Get: exact match of criterias // Range: [from, to) // Each: [from, INF) // Prefix: Has(k, prefix) // Amount: [from, INF) AND maximum N records // // Entity Naming: // State: simple table in db // InvertedIndex: supports range-scans // History: can return value of key K as of given TimeStamp. Doesn't know about latest/current value of key K. Returns NIL if K not changed after TimeStamp. // Domain: as History but also aware about latest/current value of key K. // // Provides methods to access key-value data class KV final { public: static constexpr char const* service_full_name() { return "remote.KV"; } class StubInterface { public: virtual ~StubInterface() {} // Version returns the service version number virtual ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } // Tx exposes read-only transactions for the key-value store // // When tx open, client must receive 1 message from server with txID // When cursor open, client must receive 1 message from server with cursorID // Then only client can initiate messages from server std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::remote::Cursor, ::remote::Pair>> Tx(::grpc::ClientContext* context) { return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::remote::Cursor, ::remote::Pair>>(TxRaw(context)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::Cursor, ::remote::Pair>> AsyncTx(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::Cursor, ::remote::Pair>>(AsyncTxRaw(context, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::Cursor, ::remote::Pair>> PrepareAsyncTx(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::remote::Cursor, ::remote::Pair>>(PrepareAsyncTxRaw(context, cq)); } std::unique_ptr< ::grpc::ClientReaderInterface< ::remote::StateChangeBatch>> StateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::remote::StateChangeBatch>>(StateChangesRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>> AsyncStateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>>(AsyncStateChangesRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>> PrepareAsyncStateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>>(PrepareAsyncStateChangesRaw(context, request, cq)); } // Snapshots returns list of current snapshot files. Then client can just open all of them. virtual ::grpc::Status Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::remote::SnapshotsReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>> AsyncSnapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>>(AsyncSnapshotsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>> PrepareAsyncSnapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>>(PrepareAsyncSnapshotsRaw(context, request, cq)); } // Range [from, to) // Range(from, nil) means [from, EndOfTable) // Range(nil, to) means [StartOfTable, to) // If orderAscend=false server expecting `from`<`to`. Example: Range("B", "A") virtual ::grpc::Status Range(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::remote::Pairs* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>> AsyncRange(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>>(AsyncRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>> PrepareAsyncRange(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>>(PrepareAsyncRangeRaw(context, request, cq)); } // rpc Stream(RangeReq) returns (stream Pairs); // Temporal methods virtual ::grpc::Status GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::remote::GetLatestReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>> AsyncGetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>>(AsyncGetLatestRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>> PrepareAsyncGetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>>(PrepareAsyncGetLatestRaw(context, request, cq)); } // can return latest value or as of given timestamp virtual ::grpc::Status HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::remote::HistorySeekReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>> AsyncHistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>>(AsyncHistorySeekRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>> PrepareAsyncHistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>>(PrepareAsyncHistorySeekRaw(context, request, cq)); } virtual ::grpc::Status IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::remote::IndexRangeReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>> AsyncIndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>>(AsyncIndexRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>> PrepareAsyncIndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>>(PrepareAsyncIndexRangeRaw(context, request, cq)); } virtual ::grpc::Status HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::remote::Pairs* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>> AsyncHistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>>(AsyncHistoryRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>> PrepareAsyncHistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>>(PrepareAsyncHistoryRangeRaw(context, request, cq)); } virtual ::grpc::Status RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::remote::Pairs* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>> AsyncRangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>>(AsyncRangeAsOfRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>> PrepareAsyncRangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>>(PrepareAsyncRangeAsOfRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} // Version returns the service version number virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) = 0; virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Tx exposes read-only transactions for the key-value store // // When tx open, client must receive 1 message from server with txID // When cursor open, client must receive 1 message from server with cursorID // Then only client can initiate messages from server virtual void Tx(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::remote::Cursor,::remote::Pair>* reactor) = 0; virtual void StateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest* request, ::grpc::ClientReadReactor< ::remote::StateChangeBatch>* reactor) = 0; // Snapshots returns list of current snapshot files. Then client can just open all of them. virtual void Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response, std::function) = 0; virtual void Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Range [from, to) // Range(from, nil) means [from, EndOfTable) // Range(nil, to) means [StartOfTable, to) // If orderAscend=false server expecting `from`<`to`. Example: Range("B", "A") virtual void Range(::grpc::ClientContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response, std::function) = 0; virtual void Range(::grpc::ClientContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) = 0; // rpc Stream(RangeReq) returns (stream Pairs); // Temporal methods virtual void GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response, std::function) = 0; virtual void GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // can return latest value or as of given timestamp virtual void HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response, std::function) = 0; virtual void HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response, std::function) = 0; virtual void IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response, std::function) = 0; virtual void HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response, std::function) = 0; virtual void RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderWriterInterface< ::remote::Cursor, ::remote::Pair>* TxRaw(::grpc::ClientContext* context) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::remote::Cursor, ::remote::Pair>* AsyncTxRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::remote::Cursor, ::remote::Pair>* PrepareAsyncTxRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::remote::StateChangeBatch>* StateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>* AsyncStateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>* PrepareAsyncStateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>* AsyncSnapshotsRaw(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>* PrepareAsyncSnapshotsRaw(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>* AsyncRangeRaw(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>* PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>* AsyncGetLatestRaw(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>* PrepareAsyncGetLatestRaw(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>* AsyncHistorySeekRaw(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>* PrepareAsyncHistorySeekRaw(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>* AsyncIndexRangeRaw(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>* PrepareAsyncIndexRangeRaw(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>* AsyncHistoryRangeRaw(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>* PrepareAsyncHistoryRangeRaw(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>* AsyncRangeAsOfRaw(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>* PrepareAsyncRangeAsOfRaw(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReaderWriter< ::remote::Cursor, ::remote::Pair>> Tx(::grpc::ClientContext* context) { return std::unique_ptr< ::grpc::ClientReaderWriter< ::remote::Cursor, ::remote::Pair>>(TxRaw(context)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>> AsyncTx(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>>(AsyncTxRaw(context, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>> PrepareAsyncTx(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>>(PrepareAsyncTxRaw(context, cq)); } std::unique_ptr< ::grpc::ClientReader< ::remote::StateChangeBatch>> StateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::remote::StateChangeBatch>>(StateChangesRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>> AsyncStateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>>(AsyncStateChangesRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>> PrepareAsyncStateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>>(PrepareAsyncStateChangesRaw(context, request, cq)); } ::grpc::Status Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::remote::SnapshotsReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>> AsyncSnapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>>(AsyncSnapshotsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>> PrepareAsyncSnapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>>(PrepareAsyncSnapshotsRaw(context, request, cq)); } ::grpc::Status Range(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::remote::Pairs* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>> AsyncRange(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>>(AsyncRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>> PrepareAsyncRange(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>>(PrepareAsyncRangeRaw(context, request, cq)); } ::grpc::Status GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::remote::GetLatestReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>> AsyncGetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>>(AsyncGetLatestRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>> PrepareAsyncGetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>>(PrepareAsyncGetLatestRaw(context, request, cq)); } ::grpc::Status HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::remote::HistorySeekReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>> AsyncHistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>>(AsyncHistorySeekRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>> PrepareAsyncHistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>>(PrepareAsyncHistorySeekRaw(context, request, cq)); } ::grpc::Status IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::remote::IndexRangeReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>> AsyncIndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>>(AsyncIndexRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>> PrepareAsyncIndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>>(PrepareAsyncIndexRangeRaw(context, request, cq)); } ::grpc::Status HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::remote::Pairs* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>> AsyncHistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>>(AsyncHistoryRangeRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>> PrepareAsyncHistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>>(PrepareAsyncHistoryRangeRaw(context, request, cq)); } ::grpc::Status RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::remote::Pairs* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>> AsyncRangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>>(AsyncRangeAsOfRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>> PrepareAsyncRangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::remote::Pairs>>(PrepareAsyncRangeAsOfRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) override; void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Tx(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::remote::Cursor,::remote::Pair>* reactor) override; void StateChanges(::grpc::ClientContext* context, const ::remote::StateChangeRequest* request, ::grpc::ClientReadReactor< ::remote::StateChangeBatch>* reactor) override; void Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response, std::function) override; void Snapshots(::grpc::ClientContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Range(::grpc::ClientContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response, std::function) override; void Range(::grpc::ClientContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) override; void GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response, std::function) override; void GetLatest(::grpc::ClientContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response, ::grpc::ClientUnaryReactor* reactor) override; void HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response, std::function) override; void HistorySeek(::grpc::ClientContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response, ::grpc::ClientUnaryReactor* reactor) override; void IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response, std::function) override; void IndexRange(::grpc::ClientContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response, ::grpc::ClientUnaryReactor* reactor) override; void HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response, std::function) override; void HistoryRange(::grpc::ClientContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) override; void RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response, std::function) override; void RangeAsOf(::grpc::ClientContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReaderWriter< ::remote::Cursor, ::remote::Pair>* TxRaw(::grpc::ClientContext* context) override; ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>* AsyncTxRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReaderWriter< ::remote::Cursor, ::remote::Pair>* PrepareAsyncTxRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::remote::StateChangeBatch>* StateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request) override; ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>* AsyncStateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::remote::StateChangeBatch>* PrepareAsyncStateChangesRaw(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>* AsyncSnapshotsRaw(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::SnapshotsReply>* PrepareAsyncSnapshotsRaw(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* AsyncRangeRaw(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>* AsyncGetLatestRaw(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::GetLatestReply>* PrepareAsyncGetLatestRaw(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>* AsyncHistorySeekRaw(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::HistorySeekReply>* PrepareAsyncHistorySeekRaw(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>* AsyncIndexRangeRaw(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::IndexRangeReply>* PrepareAsyncIndexRangeRaw(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* AsyncHistoryRangeRaw(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* PrepareAsyncHistoryRangeRaw(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* AsyncRangeAsOfRaw(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::remote::Pairs>* PrepareAsyncRangeAsOfRaw(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_Version_; const ::grpc::internal::RpcMethod rpcmethod_Tx_; const ::grpc::internal::RpcMethod rpcmethod_StateChanges_; const ::grpc::internal::RpcMethod rpcmethod_Snapshots_; const ::grpc::internal::RpcMethod rpcmethod_Range_; const ::grpc::internal::RpcMethod rpcmethod_GetLatest_; const ::grpc::internal::RpcMethod rpcmethod_HistorySeek_; const ::grpc::internal::RpcMethod rpcmethod_IndexRange_; const ::grpc::internal::RpcMethod rpcmethod_HistoryRange_; const ::grpc::internal::RpcMethod rpcmethod_RangeAsOf_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // Version returns the service version number virtual ::grpc::Status Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response); // Tx exposes read-only transactions for the key-value store // // When tx open, client must receive 1 message from server with txID // When cursor open, client must receive 1 message from server with cursorID // Then only client can initiate messages from server virtual ::grpc::Status Tx(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::remote::Pair, ::remote::Cursor>* stream); virtual ::grpc::Status StateChanges(::grpc::ServerContext* context, const ::remote::StateChangeRequest* request, ::grpc::ServerWriter< ::remote::StateChangeBatch>* writer); // Snapshots returns list of current snapshot files. Then client can just open all of them. virtual ::grpc::Status Snapshots(::grpc::ServerContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response); // Range [from, to) // Range(from, nil) means [from, EndOfTable) // Range(nil, to) means [StartOfTable, to) // If orderAscend=false server expecting `from`<`to`. Example: Range("B", "A") virtual ::grpc::Status Range(::grpc::ServerContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response); // rpc Stream(RangeReq) returns (stream Pairs); // Temporal methods virtual ::grpc::Status GetLatest(::grpc::ServerContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response); // can return latest value or as of given timestamp virtual ::grpc::Status HistorySeek(::grpc::ServerContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response); virtual ::grpc::Status IndexRange(::grpc::ServerContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response); virtual ::grpc::Status HistoryRange(::grpc::ServerContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response); virtual ::grpc::Status RangeAsOf(::grpc::ServerContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response); }; template class WithAsyncMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Version() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::types::VersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Tx : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Tx() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_Tx() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Tx(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::Pair, ::remote::Cursor>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestTx(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::remote::Pair, ::remote::Cursor>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(1, context, stream, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_StateChanges : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_StateChanges() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_StateChanges() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status StateChanges(::grpc::ServerContext* /*context*/, const ::remote::StateChangeRequest* /*request*/, ::grpc::ServerWriter< ::remote::StateChangeBatch>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestStateChanges(::grpc::ServerContext* context, ::remote::StateChangeRequest* request, ::grpc::ServerAsyncWriter< ::remote::StateChangeBatch>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(2, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Snapshots : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Snapshots() { ::grpc::Service::MarkMethodAsync(3); } ~WithAsyncMethod_Snapshots() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Snapshots(::grpc::ServerContext* /*context*/, const ::remote::SnapshotsRequest* /*request*/, ::remote::SnapshotsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSnapshots(::grpc::ServerContext* context, ::remote::SnapshotsRequest* request, ::grpc::ServerAsyncResponseWriter< ::remote::SnapshotsReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Range : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Range() { ::grpc::Service::MarkMethodAsync(4); } ~WithAsyncMethod_Range() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::remote::RangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestRange(::grpc::ServerContext* context, ::remote::RangeReq* request, ::grpc::ServerAsyncResponseWriter< ::remote::Pairs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetLatest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetLatest() { ::grpc::Service::MarkMethodAsync(5); } ~WithAsyncMethod_GetLatest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetLatest(::grpc::ServerContext* /*context*/, const ::remote::GetLatestReq* /*request*/, ::remote::GetLatestReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetLatest(::grpc::ServerContext* context, ::remote::GetLatestReq* request, ::grpc::ServerAsyncResponseWriter< ::remote::GetLatestReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_HistorySeek : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HistorySeek() { ::grpc::Service::MarkMethodAsync(6); } ~WithAsyncMethod_HistorySeek() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistorySeek(::grpc::ServerContext* /*context*/, const ::remote::HistorySeekReq* /*request*/, ::remote::HistorySeekReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHistorySeek(::grpc::ServerContext* context, ::remote::HistorySeekReq* request, ::grpc::ServerAsyncResponseWriter< ::remote::HistorySeekReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_IndexRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_IndexRange() { ::grpc::Service::MarkMethodAsync(7); } ~WithAsyncMethod_IndexRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IndexRange(::grpc::ServerContext* /*context*/, const ::remote::IndexRangeReq* /*request*/, ::remote::IndexRangeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestIndexRange(::grpc::ServerContext* context, ::remote::IndexRangeReq* request, ::grpc::ServerAsyncResponseWriter< ::remote::IndexRangeReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_HistoryRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HistoryRange() { ::grpc::Service::MarkMethodAsync(8); } ~WithAsyncMethod_HistoryRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistoryRange(::grpc::ServerContext* /*context*/, const ::remote::HistoryRangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHistoryRange(::grpc::ServerContext* context, ::remote::HistoryRangeReq* request, ::grpc::ServerAsyncResponseWriter< ::remote::Pairs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_RangeAsOf : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_RangeAsOf() { ::grpc::Service::MarkMethodAsync(9); } ~WithAsyncMethod_RangeAsOf() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status RangeAsOf(::grpc::ServerContext* /*context*/, const ::remote::RangeAsOfReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestRangeAsOf(::grpc::ServerContext* context, ::remote::RangeAsOfReq* request, ::grpc::ServerAsyncResponseWriter< ::remote::Pairs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_Version > > > > > > > > > AsyncService; template class WithCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Version() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { return this->Version(context, request, response); }));} void SetMessageAllocatorFor_Version( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::types::VersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Tx : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Tx() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackBidiHandler< ::remote::Cursor, ::remote::Pair>( [this]( ::grpc::CallbackServerContext* context) { return this->Tx(context); })); } ~WithCallbackMethod_Tx() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Tx(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::Pair, ::remote::Cursor>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerBidiReactor< ::remote::Cursor, ::remote::Pair>* Tx( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; template class WithCallbackMethod_StateChanges : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_StateChanges() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackServerStreamingHandler< ::remote::StateChangeRequest, ::remote::StateChangeBatch>( [this]( ::grpc::CallbackServerContext* context, const ::remote::StateChangeRequest* request) { return this->StateChanges(context, request); })); } ~WithCallbackMethod_StateChanges() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status StateChanges(::grpc::ServerContext* /*context*/, const ::remote::StateChangeRequest* /*request*/, ::grpc::ServerWriter< ::remote::StateChangeBatch>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::remote::StateChangeBatch>* StateChanges( ::grpc::CallbackServerContext* /*context*/, const ::remote::StateChangeRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_Snapshots : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Snapshots() { ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::remote::SnapshotsRequest, ::remote::SnapshotsReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::SnapshotsRequest* request, ::remote::SnapshotsReply* response) { return this->Snapshots(context, request, response); }));} void SetMessageAllocatorFor_Snapshots( ::grpc::MessageAllocator< ::remote::SnapshotsRequest, ::remote::SnapshotsReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::SnapshotsRequest, ::remote::SnapshotsReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Snapshots() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Snapshots(::grpc::ServerContext* /*context*/, const ::remote::SnapshotsRequest* /*request*/, ::remote::SnapshotsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Snapshots( ::grpc::CallbackServerContext* /*context*/, const ::remote::SnapshotsRequest* /*request*/, ::remote::SnapshotsReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Range : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Range() { ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::remote::RangeReq, ::remote::Pairs>( [this]( ::grpc::CallbackServerContext* context, const ::remote::RangeReq* request, ::remote::Pairs* response) { return this->Range(context, request, response); }));} void SetMessageAllocatorFor_Range( ::grpc::MessageAllocator< ::remote::RangeReq, ::remote::Pairs>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::RangeReq, ::remote::Pairs>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Range() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::remote::RangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Range( ::grpc::CallbackServerContext* /*context*/, const ::remote::RangeReq* /*request*/, ::remote::Pairs* /*response*/) { return nullptr; } }; template class WithCallbackMethod_GetLatest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetLatest() { ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::remote::GetLatestReq, ::remote::GetLatestReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::GetLatestReq* request, ::remote::GetLatestReply* response) { return this->GetLatest(context, request, response); }));} void SetMessageAllocatorFor_GetLatest( ::grpc::MessageAllocator< ::remote::GetLatestReq, ::remote::GetLatestReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::GetLatestReq, ::remote::GetLatestReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetLatest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetLatest(::grpc::ServerContext* /*context*/, const ::remote::GetLatestReq* /*request*/, ::remote::GetLatestReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetLatest( ::grpc::CallbackServerContext* /*context*/, const ::remote::GetLatestReq* /*request*/, ::remote::GetLatestReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_HistorySeek : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_HistorySeek() { ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::remote::HistorySeekReq, ::remote::HistorySeekReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::HistorySeekReq* request, ::remote::HistorySeekReply* response) { return this->HistorySeek(context, request, response); }));} void SetMessageAllocatorFor_HistorySeek( ::grpc::MessageAllocator< ::remote::HistorySeekReq, ::remote::HistorySeekReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::HistorySeekReq, ::remote::HistorySeekReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_HistorySeek() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistorySeek(::grpc::ServerContext* /*context*/, const ::remote::HistorySeekReq* /*request*/, ::remote::HistorySeekReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HistorySeek( ::grpc::CallbackServerContext* /*context*/, const ::remote::HistorySeekReq* /*request*/, ::remote::HistorySeekReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_IndexRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_IndexRange() { ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::remote::IndexRangeReq, ::remote::IndexRangeReply>( [this]( ::grpc::CallbackServerContext* context, const ::remote::IndexRangeReq* request, ::remote::IndexRangeReply* response) { return this->IndexRange(context, request, response); }));} void SetMessageAllocatorFor_IndexRange( ::grpc::MessageAllocator< ::remote::IndexRangeReq, ::remote::IndexRangeReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::IndexRangeReq, ::remote::IndexRangeReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_IndexRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IndexRange(::grpc::ServerContext* /*context*/, const ::remote::IndexRangeReq* /*request*/, ::remote::IndexRangeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* IndexRange( ::grpc::CallbackServerContext* /*context*/, const ::remote::IndexRangeReq* /*request*/, ::remote::IndexRangeReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_HistoryRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_HistoryRange() { ::grpc::Service::MarkMethodCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::remote::HistoryRangeReq, ::remote::Pairs>( [this]( ::grpc::CallbackServerContext* context, const ::remote::HistoryRangeReq* request, ::remote::Pairs* response) { return this->HistoryRange(context, request, response); }));} void SetMessageAllocatorFor_HistoryRange( ::grpc::MessageAllocator< ::remote::HistoryRangeReq, ::remote::Pairs>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(8); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::HistoryRangeReq, ::remote::Pairs>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_HistoryRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistoryRange(::grpc::ServerContext* /*context*/, const ::remote::HistoryRangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HistoryRange( ::grpc::CallbackServerContext* /*context*/, const ::remote::HistoryRangeReq* /*request*/, ::remote::Pairs* /*response*/) { return nullptr; } }; template class WithCallbackMethod_RangeAsOf : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_RangeAsOf() { ::grpc::Service::MarkMethodCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::remote::RangeAsOfReq, ::remote::Pairs>( [this]( ::grpc::CallbackServerContext* context, const ::remote::RangeAsOfReq* request, ::remote::Pairs* response) { return this->RangeAsOf(context, request, response); }));} void SetMessageAllocatorFor_RangeAsOf( ::grpc::MessageAllocator< ::remote::RangeAsOfReq, ::remote::Pairs>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(9); static_cast<::grpc::internal::CallbackUnaryHandler< ::remote::RangeAsOfReq, ::remote::Pairs>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_RangeAsOf() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status RangeAsOf(::grpc::ServerContext* /*context*/, const ::remote::RangeAsOfReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* RangeAsOf( ::grpc::CallbackServerContext* /*context*/, const ::remote::RangeAsOfReq* /*request*/, ::remote::Pairs* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_Version > > > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Version() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Tx : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Tx() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_Tx() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Tx(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::Pair, ::remote::Cursor>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_StateChanges : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_StateChanges() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_StateChanges() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status StateChanges(::grpc::ServerContext* /*context*/, const ::remote::StateChangeRequest* /*request*/, ::grpc::ServerWriter< ::remote::StateChangeBatch>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Snapshots : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Snapshots() { ::grpc::Service::MarkMethodGeneric(3); } ~WithGenericMethod_Snapshots() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Snapshots(::grpc::ServerContext* /*context*/, const ::remote::SnapshotsRequest* /*request*/, ::remote::SnapshotsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Range : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Range() { ::grpc::Service::MarkMethodGeneric(4); } ~WithGenericMethod_Range() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::remote::RangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetLatest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetLatest() { ::grpc::Service::MarkMethodGeneric(5); } ~WithGenericMethod_GetLatest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetLatest(::grpc::ServerContext* /*context*/, const ::remote::GetLatestReq* /*request*/, ::remote::GetLatestReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_HistorySeek : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HistorySeek() { ::grpc::Service::MarkMethodGeneric(6); } ~WithGenericMethod_HistorySeek() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistorySeek(::grpc::ServerContext* /*context*/, const ::remote::HistorySeekReq* /*request*/, ::remote::HistorySeekReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_IndexRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_IndexRange() { ::grpc::Service::MarkMethodGeneric(7); } ~WithGenericMethod_IndexRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IndexRange(::grpc::ServerContext* /*context*/, const ::remote::IndexRangeReq* /*request*/, ::remote::IndexRangeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_HistoryRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HistoryRange() { ::grpc::Service::MarkMethodGeneric(8); } ~WithGenericMethod_HistoryRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistoryRange(::grpc::ServerContext* /*context*/, const ::remote::HistoryRangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_RangeAsOf : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_RangeAsOf() { ::grpc::Service::MarkMethodGeneric(9); } ~WithGenericMethod_RangeAsOf() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status RangeAsOf(::grpc::ServerContext* /*context*/, const ::remote::RangeAsOfReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Version() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Tx : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Tx() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_Tx() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Tx(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::Pair, ::remote::Cursor>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestTx(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(1, context, stream, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_StateChanges : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_StateChanges() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_StateChanges() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status StateChanges(::grpc::ServerContext* /*context*/, const ::remote::StateChangeRequest* /*request*/, ::grpc::ServerWriter< ::remote::StateChangeBatch>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestStateChanges(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(2, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Snapshots : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Snapshots() { ::grpc::Service::MarkMethodRaw(3); } ~WithRawMethod_Snapshots() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Snapshots(::grpc::ServerContext* /*context*/, const ::remote::SnapshotsRequest* /*request*/, ::remote::SnapshotsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSnapshots(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Range : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Range() { ::grpc::Service::MarkMethodRaw(4); } ~WithRawMethod_Range() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::remote::RangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestRange(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetLatest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetLatest() { ::grpc::Service::MarkMethodRaw(5); } ~WithRawMethod_GetLatest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetLatest(::grpc::ServerContext* /*context*/, const ::remote::GetLatestReq* /*request*/, ::remote::GetLatestReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetLatest(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_HistorySeek : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HistorySeek() { ::grpc::Service::MarkMethodRaw(6); } ~WithRawMethod_HistorySeek() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistorySeek(::grpc::ServerContext* /*context*/, const ::remote::HistorySeekReq* /*request*/, ::remote::HistorySeekReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHistorySeek(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_IndexRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_IndexRange() { ::grpc::Service::MarkMethodRaw(7); } ~WithRawMethod_IndexRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IndexRange(::grpc::ServerContext* /*context*/, const ::remote::IndexRangeReq* /*request*/, ::remote::IndexRangeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestIndexRange(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_HistoryRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HistoryRange() { ::grpc::Service::MarkMethodRaw(8); } ~WithRawMethod_HistoryRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistoryRange(::grpc::ServerContext* /*context*/, const ::remote::HistoryRangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHistoryRange(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_RangeAsOf : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_RangeAsOf() { ::grpc::Service::MarkMethodRaw(9); } ~WithRawMethod_RangeAsOf() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status RangeAsOf(::grpc::ServerContext* /*context*/, const ::remote::RangeAsOfReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestRangeAsOf(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Version() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Version(context, request, response); })); } ~WithRawCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Tx : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Tx() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context) { return this->Tx(context); })); } ~WithRawCallbackMethod_Tx() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Tx(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::remote::Pair, ::remote::Cursor>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* Tx( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; template class WithRawCallbackMethod_StateChanges : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_StateChanges() { ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->StateChanges(context, request); })); } ~WithRawCallbackMethod_StateChanges() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status StateChanges(::grpc::ServerContext* /*context*/, const ::remote::StateChangeRequest* /*request*/, ::grpc::ServerWriter< ::remote::StateChangeBatch>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* StateChanges( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_Snapshots : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Snapshots() { ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Snapshots(context, request, response); })); } ~WithRawCallbackMethod_Snapshots() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Snapshots(::grpc::ServerContext* /*context*/, const ::remote::SnapshotsRequest* /*request*/, ::remote::SnapshotsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Snapshots( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Range : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Range() { ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Range(context, request, response); })); } ~WithRawCallbackMethod_Range() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::remote::RangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Range( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_GetLatest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetLatest() { ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetLatest(context, request, response); })); } ~WithRawCallbackMethod_GetLatest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetLatest(::grpc::ServerContext* /*context*/, const ::remote::GetLatestReq* /*request*/, ::remote::GetLatestReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetLatest( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_HistorySeek : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_HistorySeek() { ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->HistorySeek(context, request, response); })); } ~WithRawCallbackMethod_HistorySeek() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistorySeek(::grpc::ServerContext* /*context*/, const ::remote::HistorySeekReq* /*request*/, ::remote::HistorySeekReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HistorySeek( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_IndexRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_IndexRange() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->IndexRange(context, request, response); })); } ~WithRawCallbackMethod_IndexRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status IndexRange(::grpc::ServerContext* /*context*/, const ::remote::IndexRangeReq* /*request*/, ::remote::IndexRangeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* IndexRange( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_HistoryRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_HistoryRange() { ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->HistoryRange(context, request, response); })); } ~WithRawCallbackMethod_HistoryRange() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HistoryRange(::grpc::ServerContext* /*context*/, const ::remote::HistoryRangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HistoryRange( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_RangeAsOf : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_RangeAsOf() { ::grpc::Service::MarkMethodRawCallback(9, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->RangeAsOf(context, request, response); })); } ~WithRawCallbackMethod_RangeAsOf() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status RangeAsOf(::grpc::ServerContext* /*context*/, const ::remote::RangeAsOfReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* RangeAsOf( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Version() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::types::VersionReply>* streamer) { return this->StreamedVersion(context, streamer); })); } ~WithStreamedUnaryMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::types::VersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Snapshots : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Snapshots() { ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler< ::remote::SnapshotsRequest, ::remote::SnapshotsReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::SnapshotsRequest, ::remote::SnapshotsReply>* streamer) { return this->StreamedSnapshots(context, streamer); })); } ~WithStreamedUnaryMethod_Snapshots() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Snapshots(::grpc::ServerContext* /*context*/, const ::remote::SnapshotsRequest* /*request*/, ::remote::SnapshotsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSnapshots(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::SnapshotsRequest,::remote::SnapshotsReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Range : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Range() { ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler< ::remote::RangeReq, ::remote::Pairs>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::RangeReq, ::remote::Pairs>* streamer) { return this->StreamedRange(context, streamer); })); } ~WithStreamedUnaryMethod_Range() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::remote::RangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedRange(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::RangeReq,::remote::Pairs>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetLatest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetLatest() { ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler< ::remote::GetLatestReq, ::remote::GetLatestReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::GetLatestReq, ::remote::GetLatestReply>* streamer) { return this->StreamedGetLatest(context, streamer); })); } ~WithStreamedUnaryMethod_GetLatest() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetLatest(::grpc::ServerContext* /*context*/, const ::remote::GetLatestReq* /*request*/, ::remote::GetLatestReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetLatest(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::GetLatestReq,::remote::GetLatestReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HistorySeek : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HistorySeek() { ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::StreamedUnaryHandler< ::remote::HistorySeekReq, ::remote::HistorySeekReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::HistorySeekReq, ::remote::HistorySeekReply>* streamer) { return this->StreamedHistorySeek(context, streamer); })); } ~WithStreamedUnaryMethod_HistorySeek() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status HistorySeek(::grpc::ServerContext* /*context*/, const ::remote::HistorySeekReq* /*request*/, ::remote::HistorySeekReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedHistorySeek(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::HistorySeekReq,::remote::HistorySeekReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_IndexRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_IndexRange() { ::grpc::Service::MarkMethodStreamed(7, new ::grpc::internal::StreamedUnaryHandler< ::remote::IndexRangeReq, ::remote::IndexRangeReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::IndexRangeReq, ::remote::IndexRangeReply>* streamer) { return this->StreamedIndexRange(context, streamer); })); } ~WithStreamedUnaryMethod_IndexRange() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status IndexRange(::grpc::ServerContext* /*context*/, const ::remote::IndexRangeReq* /*request*/, ::remote::IndexRangeReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedIndexRange(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::IndexRangeReq,::remote::IndexRangeReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HistoryRange : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HistoryRange() { ::grpc::Service::MarkMethodStreamed(8, new ::grpc::internal::StreamedUnaryHandler< ::remote::HistoryRangeReq, ::remote::Pairs>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::HistoryRangeReq, ::remote::Pairs>* streamer) { return this->StreamedHistoryRange(context, streamer); })); } ~WithStreamedUnaryMethod_HistoryRange() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status HistoryRange(::grpc::ServerContext* /*context*/, const ::remote::HistoryRangeReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedHistoryRange(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::HistoryRangeReq,::remote::Pairs>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_RangeAsOf : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_RangeAsOf() { ::grpc::Service::MarkMethodStreamed(9, new ::grpc::internal::StreamedUnaryHandler< ::remote::RangeAsOfReq, ::remote::Pairs>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::RangeAsOfReq, ::remote::Pairs>* streamer) { return this->StreamedRangeAsOf(context, streamer); })); } ~WithStreamedUnaryMethod_RangeAsOf() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status RangeAsOf(::grpc::ServerContext* /*context*/, const ::remote::RangeAsOfReq* /*request*/, ::remote::Pairs* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedRangeAsOf(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::remote::RangeAsOfReq,::remote::Pairs>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_Version > > > > > > > StreamedUnaryService; template class WithSplitStreamingMethod_StateChanges : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_StateChanges() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::SplitServerStreamingHandler< ::remote::StateChangeRequest, ::remote::StateChangeBatch>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::remote::StateChangeRequest, ::remote::StateChangeBatch>* streamer) { return this->StreamedStateChanges(context, streamer); })); } ~WithSplitStreamingMethod_StateChanges() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status StateChanges(::grpc::ServerContext* /*context*/, const ::remote::StateChangeRequest* /*request*/, ::grpc::ServerWriter< ::remote::StateChangeBatch>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedStateChanges(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::remote::StateChangeRequest,::remote::StateChangeBatch>* server_split_streamer) = 0; }; typedef WithSplitStreamingMethod_StateChanges SplitStreamedService; typedef WithStreamedUnaryMethod_Version > > > > > > > > StreamedService; }; } // namespace remote #endif // GRPC_remote_2fkv_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/remote/kv.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: remote/kv.proto // Protobuf C++ Version: 5.27.0 #include "remote/kv.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace remote { inline constexpr StateChangeRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : with_storage_{false}, with_transactions_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR StateChangeRequest::StateChangeRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct StateChangeRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR StateChangeRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StateChangeRequestDefaultTypeInternal() {} union { StateChangeRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StateChangeRequestDefaultTypeInternal _StateChangeRequest_default_instance_; template PROTOBUF_CONSTEXPR SnapshotsRequest::SnapshotsRequest(::_pbi::ConstantInitialized) {} struct SnapshotsRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR SnapshotsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SnapshotsRequestDefaultTypeInternal() {} union { SnapshotsRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SnapshotsRequestDefaultTypeInternal _SnapshotsRequest_default_instance_; inline constexpr SnapshotsReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : blocks_files_{}, history_files_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SnapshotsReply::SnapshotsReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SnapshotsReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR SnapshotsReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SnapshotsReplyDefaultTypeInternal() {} union { SnapshotsReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SnapshotsReplyDefaultTypeInternal _SnapshotsReply_default_instance_; inline constexpr RangeReq::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : table_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), from_prefix_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), to_prefix_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), page_token_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), tx_id_{::uint64_t{0u}}, limit_{::int64_t{0}}, order_ascend_{false}, page_size_{0}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR RangeReq::RangeReq(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct RangeReqDefaultTypeInternal { PROTOBUF_CONSTEXPR RangeReqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RangeReqDefaultTypeInternal() {} union { RangeReq _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RangeReqDefaultTypeInternal _RangeReq_default_instance_; inline constexpr RangeAsOfReq::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : table_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), from_key_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), to_key_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), page_token_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), tx_id_{::uint64_t{0u}}, ts_{::uint64_t{0u}}, latest_{false}, order_ascend_{false}, page_size_{0}, limit_{::int64_t{0}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR RangeAsOfReq::RangeAsOfReq(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct RangeAsOfReqDefaultTypeInternal { PROTOBUF_CONSTEXPR RangeAsOfReqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RangeAsOfReqDefaultTypeInternal() {} union { RangeAsOfReq _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RangeAsOfReqDefaultTypeInternal _RangeAsOfReq_default_instance_; inline constexpr PairsPagination::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : next_key_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), limit_{::int64_t{0}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR PairsPagination::PairsPagination(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PairsPaginationDefaultTypeInternal { PROTOBUF_CONSTEXPR PairsPaginationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PairsPaginationDefaultTypeInternal() {} union { PairsPagination _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PairsPaginationDefaultTypeInternal _PairsPagination_default_instance_; inline constexpr Pairs::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : keys_{}, values_{}, next_page_token_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR Pairs::Pairs(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PairsDefaultTypeInternal { PROTOBUF_CONSTEXPR PairsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PairsDefaultTypeInternal() {} union { Pairs _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PairsDefaultTypeInternal _Pairs_default_instance_; inline constexpr Pair::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : k_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), v_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), view_id_{::uint64_t{0u}}, tx_id_{::uint64_t{0u}}, cursor_id_{0u}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR Pair::Pair(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PairDefaultTypeInternal { PROTOBUF_CONSTEXPR PairDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PairDefaultTypeInternal() {} union { Pair _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PairDefaultTypeInternal _Pair_default_instance_; inline constexpr IndexRangeReq::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : table_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), k_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), page_token_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), tx_id_{::uint64_t{0u}}, from_ts_{::int64_t{0}}, to_ts_{::int64_t{0}}, limit_{::int64_t{0}}, order_ascend_{false}, page_size_{0}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR IndexRangeReq::IndexRangeReq(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct IndexRangeReqDefaultTypeInternal { PROTOBUF_CONSTEXPR IndexRangeReqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~IndexRangeReqDefaultTypeInternal() {} union { IndexRangeReq _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IndexRangeReqDefaultTypeInternal _IndexRangeReq_default_instance_; inline constexpr IndexRangeReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : timestamps_{}, _timestamps_cached_byte_size_{0}, next_page_token_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR IndexRangeReply::IndexRangeReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct IndexRangeReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR IndexRangeReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~IndexRangeReplyDefaultTypeInternal() {} union { IndexRangeReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IndexRangeReplyDefaultTypeInternal _IndexRangeReply_default_instance_; inline constexpr IndexPagination::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : next_time_stamp_{::int64_t{0}}, limit_{::int64_t{0}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR IndexPagination::IndexPagination(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct IndexPaginationDefaultTypeInternal { PROTOBUF_CONSTEXPR IndexPaginationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~IndexPaginationDefaultTypeInternal() {} union { IndexPagination _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IndexPaginationDefaultTypeInternal _IndexPagination_default_instance_; inline constexpr HistorySeekReq::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : table_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), k_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), tx_id_{::uint64_t{0u}}, ts_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR HistorySeekReq::HistorySeekReq(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HistorySeekReqDefaultTypeInternal { PROTOBUF_CONSTEXPR HistorySeekReqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HistorySeekReqDefaultTypeInternal() {} union { HistorySeekReq _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySeekReqDefaultTypeInternal _HistorySeekReq_default_instance_; inline constexpr HistorySeekReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : v_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), ok_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR HistorySeekReply::HistorySeekReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HistorySeekReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR HistorySeekReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HistorySeekReplyDefaultTypeInternal() {} union { HistorySeekReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySeekReplyDefaultTypeInternal _HistorySeekReply_default_instance_; inline constexpr HistoryRangeReq::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : table_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), page_token_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), tx_id_{::uint64_t{0u}}, from_ts_{::int64_t{0}}, to_ts_{::int64_t{0}}, limit_{::int64_t{0}}, order_ascend_{false}, page_size_{0}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR HistoryRangeReq::HistoryRangeReq(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HistoryRangeReqDefaultTypeInternal { PROTOBUF_CONSTEXPR HistoryRangeReqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HistoryRangeReqDefaultTypeInternal() {} union { HistoryRangeReq _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistoryRangeReqDefaultTypeInternal _HistoryRangeReq_default_instance_; inline constexpr GetLatestReq::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : table_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), k_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), k2_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), tx_id_{::uint64_t{0u}}, ts_{::uint64_t{0u}}, latest_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR GetLatestReq::GetLatestReq(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetLatestReqDefaultTypeInternal { PROTOBUF_CONSTEXPR GetLatestReqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetLatestReqDefaultTypeInternal() {} union { GetLatestReq _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetLatestReqDefaultTypeInternal _GetLatestReq_default_instance_; inline constexpr GetLatestReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : v_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), ok_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR GetLatestReply::GetLatestReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetLatestReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR GetLatestReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetLatestReplyDefaultTypeInternal() {} union { GetLatestReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetLatestReplyDefaultTypeInternal _GetLatestReply_default_instance_; inline constexpr Cursor::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : bucket_name_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), k_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), v_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), op_{static_cast< ::remote::Op >(0)}, cursor_{0u}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR Cursor::Cursor(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct CursorDefaultTypeInternal { PROTOBUF_CONSTEXPR CursorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~CursorDefaultTypeInternal() {} union { Cursor _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CursorDefaultTypeInternal _Cursor_default_instance_; inline constexpr StorageChange::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), location_{nullptr} {} template PROTOBUF_CONSTEXPR StorageChange::StorageChange(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct StorageChangeDefaultTypeInternal { PROTOBUF_CONSTEXPR StorageChangeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StorageChangeDefaultTypeInternal() {} union { StorageChange _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StorageChangeDefaultTypeInternal _StorageChange_default_instance_; inline constexpr AccountChange::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, storage_changes_{}, data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), code_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), address_{nullptr}, incarnation_{::uint64_t{0u}}, action_{static_cast< ::remote::Action >(0)} {} template PROTOBUF_CONSTEXPR AccountChange::AccountChange(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AccountChangeDefaultTypeInternal { PROTOBUF_CONSTEXPR AccountChangeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AccountChangeDefaultTypeInternal() {} union { AccountChange _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AccountChangeDefaultTypeInternal _AccountChange_default_instance_; inline constexpr StateChange::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, changes_{}, txs_{}, block_hash_{nullptr}, block_height_{::uint64_t{0u}}, direction_{static_cast< ::remote::Direction >(0)} {} template PROTOBUF_CONSTEXPR StateChange::StateChange(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct StateChangeDefaultTypeInternal { PROTOBUF_CONSTEXPR StateChangeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StateChangeDefaultTypeInternal() {} union { StateChange _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StateChangeDefaultTypeInternal _StateChange_default_instance_; inline constexpr StateChangeBatch::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : change_batch_{}, state_version_id_{::uint64_t{0u}}, pending_block_base_fee_{::uint64_t{0u}}, block_gas_limit_{::uint64_t{0u}}, finalized_block_{::uint64_t{0u}}, pending_blob_fee_per_gas_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR StateChangeBatch::StateChangeBatch(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct StateChangeBatchDefaultTypeInternal { PROTOBUF_CONSTEXPR StateChangeBatchDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StateChangeBatchDefaultTypeInternal() {} union { StateChangeBatch _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StateChangeBatchDefaultTypeInternal _StateChangeBatch_default_instance_; } // namespace remote static const ::_pb::EnumDescriptor* file_level_enum_descriptors_remote_2fkv_2eproto[3]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_remote_2fkv_2eproto = nullptr; const ::uint32_t TableStruct_remote_2fkv_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::Cursor, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::Cursor, _impl_.op_), PROTOBUF_FIELD_OFFSET(::remote::Cursor, _impl_.bucket_name_), PROTOBUF_FIELD_OFFSET(::remote::Cursor, _impl_.cursor_), PROTOBUF_FIELD_OFFSET(::remote::Cursor, _impl_.k_), PROTOBUF_FIELD_OFFSET(::remote::Cursor, _impl_.v_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::Pair, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::Pair, _impl_.k_), PROTOBUF_FIELD_OFFSET(::remote::Pair, _impl_.v_), PROTOBUF_FIELD_OFFSET(::remote::Pair, _impl_.cursor_id_), PROTOBUF_FIELD_OFFSET(::remote::Pair, _impl_.view_id_), PROTOBUF_FIELD_OFFSET(::remote::Pair, _impl_.tx_id_), PROTOBUF_FIELD_OFFSET(::remote::StorageChange, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::StorageChange, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::StorageChange, _impl_.location_), PROTOBUF_FIELD_OFFSET(::remote::StorageChange, _impl_.data_), 0, ~0u, PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _impl_.address_), PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _impl_.incarnation_), PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _impl_.action_), PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _impl_.data_), PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _impl_.code_), PROTOBUF_FIELD_OFFSET(::remote::AccountChange, _impl_.storage_changes_), 0, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::StateChangeBatch, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::StateChangeBatch, _impl_.state_version_id_), PROTOBUF_FIELD_OFFSET(::remote::StateChangeBatch, _impl_.change_batch_), PROTOBUF_FIELD_OFFSET(::remote::StateChangeBatch, _impl_.pending_block_base_fee_), PROTOBUF_FIELD_OFFSET(::remote::StateChangeBatch, _impl_.block_gas_limit_), PROTOBUF_FIELD_OFFSET(::remote::StateChangeBatch, _impl_.finalized_block_), PROTOBUF_FIELD_OFFSET(::remote::StateChangeBatch, _impl_.pending_blob_fee_per_gas_), PROTOBUF_FIELD_OFFSET(::remote::StateChange, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::remote::StateChange, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::StateChange, _impl_.direction_), PROTOBUF_FIELD_OFFSET(::remote::StateChange, _impl_.block_height_), PROTOBUF_FIELD_OFFSET(::remote::StateChange, _impl_.block_hash_), PROTOBUF_FIELD_OFFSET(::remote::StateChange, _impl_.changes_), PROTOBUF_FIELD_OFFSET(::remote::StateChange, _impl_.txs_), ~0u, ~0u, 0, ~0u, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::StateChangeRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::StateChangeRequest, _impl_.with_storage_), PROTOBUF_FIELD_OFFSET(::remote::StateChangeRequest, _impl_.with_transactions_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::SnapshotsRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::SnapshotsReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::SnapshotsReply, _impl_.blocks_files_), PROTOBUF_FIELD_OFFSET(::remote::SnapshotsReply, _impl_.history_files_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.tx_id_), PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.table_), PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.from_prefix_), PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.to_prefix_), PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.order_ascend_), PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.limit_), PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.page_size_), PROTOBUF_FIELD_OFFSET(::remote::RangeReq, _impl_.page_token_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::GetLatestReq, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::GetLatestReq, _impl_.tx_id_), PROTOBUF_FIELD_OFFSET(::remote::GetLatestReq, _impl_.table_), PROTOBUF_FIELD_OFFSET(::remote::GetLatestReq, _impl_.k_), PROTOBUF_FIELD_OFFSET(::remote::GetLatestReq, _impl_.ts_), PROTOBUF_FIELD_OFFSET(::remote::GetLatestReq, _impl_.k2_), PROTOBUF_FIELD_OFFSET(::remote::GetLatestReq, _impl_.latest_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::GetLatestReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::GetLatestReply, _impl_.v_), PROTOBUF_FIELD_OFFSET(::remote::GetLatestReply, _impl_.ok_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReq, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReq, _impl_.tx_id_), PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReq, _impl_.table_), PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReq, _impl_.k_), PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReq, _impl_.ts_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReply, _impl_.v_), PROTOBUF_FIELD_OFFSET(::remote::HistorySeekReply, _impl_.ok_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.tx_id_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.table_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.k_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.from_ts_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.to_ts_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.order_ascend_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.limit_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.page_size_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReq, _impl_.page_token_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReply, _impl_.timestamps_), PROTOBUF_FIELD_OFFSET(::remote::IndexRangeReply, _impl_.next_page_token_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.tx_id_), PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.table_), PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.from_ts_), PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.to_ts_), PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.order_ascend_), PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.limit_), PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.page_size_), PROTOBUF_FIELD_OFFSET(::remote::HistoryRangeReq, _impl_.page_token_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.tx_id_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.table_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.from_key_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.to_key_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.ts_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.latest_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.order_ascend_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.limit_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.page_size_), PROTOBUF_FIELD_OFFSET(::remote::RangeAsOfReq, _impl_.page_token_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::Pairs, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::Pairs, _impl_.keys_), PROTOBUF_FIELD_OFFSET(::remote::Pairs, _impl_.values_), PROTOBUF_FIELD_OFFSET(::remote::Pairs, _impl_.next_page_token_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::PairsPagination, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::PairsPagination, _impl_.next_key_), PROTOBUF_FIELD_OFFSET(::remote::PairsPagination, _impl_.limit_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::remote::IndexPagination, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::remote::IndexPagination, _impl_.next_time_stamp_), PROTOBUF_FIELD_OFFSET(::remote::IndexPagination, _impl_.limit_), }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::remote::Cursor)}, {13, -1, -1, sizeof(::remote::Pair)}, {26, 36, -1, sizeof(::remote::StorageChange)}, {38, 52, -1, sizeof(::remote::AccountChange)}, {58, -1, -1, sizeof(::remote::StateChangeBatch)}, {72, 85, -1, sizeof(::remote::StateChange)}, {90, -1, -1, sizeof(::remote::StateChangeRequest)}, {100, -1, -1, sizeof(::remote::SnapshotsRequest)}, {108, -1, -1, sizeof(::remote::SnapshotsReply)}, {118, -1, -1, sizeof(::remote::RangeReq)}, {134, -1, -1, sizeof(::remote::GetLatestReq)}, {148, -1, -1, sizeof(::remote::GetLatestReply)}, {158, -1, -1, sizeof(::remote::HistorySeekReq)}, {170, -1, -1, sizeof(::remote::HistorySeekReply)}, {180, -1, -1, sizeof(::remote::IndexRangeReq)}, {197, -1, -1, sizeof(::remote::IndexRangeReply)}, {207, -1, -1, sizeof(::remote::HistoryRangeReq)}, {223, -1, -1, sizeof(::remote::RangeAsOfReq)}, {241, -1, -1, sizeof(::remote::Pairs)}, {252, -1, -1, sizeof(::remote::PairsPagination)}, {262, -1, -1, sizeof(::remote::IndexPagination)}, }; static const ::_pb::Message* const file_default_instances[] = { &::remote::_Cursor_default_instance_._instance, &::remote::_Pair_default_instance_._instance, &::remote::_StorageChange_default_instance_._instance, &::remote::_AccountChange_default_instance_._instance, &::remote::_StateChangeBatch_default_instance_._instance, &::remote::_StateChange_default_instance_._instance, &::remote::_StateChangeRequest_default_instance_._instance, &::remote::_SnapshotsRequest_default_instance_._instance, &::remote::_SnapshotsReply_default_instance_._instance, &::remote::_RangeReq_default_instance_._instance, &::remote::_GetLatestReq_default_instance_._instance, &::remote::_GetLatestReply_default_instance_._instance, &::remote::_HistorySeekReq_default_instance_._instance, &::remote::_HistorySeekReply_default_instance_._instance, &::remote::_IndexRangeReq_default_instance_._instance, &::remote::_IndexRangeReply_default_instance_._instance, &::remote::_HistoryRangeReq_default_instance_._instance, &::remote::_RangeAsOfReq_default_instance_._instance, &::remote::_Pairs_default_instance_._instance, &::remote::_PairsPagination_default_instance_._instance, &::remote::_IndexPagination_default_instance_._instance, }; const char descriptor_table_protodef_remote_2fkv_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\017remote/kv.proto\022\006remote\032\033google/protob" "uf/empty.proto\032\021types/types.proto\"[\n\006Cur" "sor\022\026\n\002op\030\001 \001(\0162\n.remote.Op\022\023\n\013bucket_na" "me\030\002 \001(\t\022\016\n\006cursor\030\003 \001(\r\022\t\n\001k\030\004 \001(\014\022\t\n\001v" "\030\005 \001(\014\"O\n\004Pair\022\t\n\001k\030\001 \001(\014\022\t\n\001v\030\002 \001(\014\022\021\n\t" "cursor_id\030\003 \001(\r\022\017\n\007view_id\030\004 \001(\004\022\r\n\005tx_i" "d\030\005 \001(\004\"<\n\rStorageChange\022\035\n\010location\030\001 \001" "(\0132\013.types.H256\022\014\n\004data\030\002 \001(\014\"\256\001\n\rAccoun" "tChange\022\034\n\007address\030\001 \001(\0132\013.types.H160\022\023\n" "\013incarnation\030\002 \001(\004\022\036\n\006action\030\003 \001(\0162\016.rem" "ote.Action\022\014\n\004data\030\004 \001(\014\022\014\n\004code\030\005 \001(\014\022." "\n\017storage_changes\030\006 \003(\0132\025.remote.Storage" "Change\"\313\001\n\020StateChangeBatch\022\030\n\020state_ver" "sion_id\030\001 \001(\004\022)\n\014change_batch\030\002 \003(\0132\023.re" "mote.StateChange\022\036\n\026pending_block_base_f" "ee\030\003 \001(\004\022\027\n\017block_gas_limit\030\004 \001(\004\022\027\n\017fin" "alized_block\030\005 \001(\004\022 \n\030pending_blob_fee_p" "er_gas\030\006 \001(\004\"\237\001\n\013StateChange\022$\n\tdirectio" "n\030\001 \001(\0162\021.remote.Direction\022\024\n\014block_heig" "ht\030\002 \001(\004\022\037\n\nblock_hash\030\003 \001(\0132\013.types.H25" "6\022&\n\007changes\030\004 \003(\0132\025.remote.AccountChang" "e\022\013\n\003txs\030\005 \003(\014\"E\n\022StateChangeRequest\022\024\n\014" "with_storage\030\001 \001(\010\022\031\n\021with_transactions\030" "\002 \001(\010\"\022\n\020SnapshotsRequest\"=\n\016SnapshotsRe" "ply\022\024\n\014blocks_files\030\001 \003(\t\022\025\n\rhistory_fil" "es\030\002 \003(\t\"\234\001\n\010RangeReq\022\r\n\005tx_id\030\001 \001(\004\022\r\n\005" "table\030\002 \001(\t\022\023\n\013from_prefix\030\003 \001(\014\022\021\n\tto_p" "refix\030\004 \001(\014\022\024\n\014order_ascend\030\005 \001(\010\022\r\n\005lim" "it\030\006 \001(\022\022\021\n\tpage_size\030\007 \001(\005\022\022\n\npage_toke" "n\030\010 \001(\t\"_\n\014GetLatestReq\022\r\n\005tx_id\030\001 \001(\004\022\r" "\n\005table\030\002 \001(\t\022\t\n\001k\030\003 \001(\014\022\n\n\002ts\030\004 \001(\004\022\n\n\002" "k2\030\005 \001(\014\022\016\n\006latest\030\006 \001(\010\"\'\n\016GetLatestRep" "ly\022\t\n\001v\030\001 \001(\014\022\n\n\002ok\030\002 \001(\010\"E\n\016HistorySeek" "Req\022\r\n\005tx_id\030\001 \001(\004\022\r\n\005table\030\002 \001(\t\022\t\n\001k\030\003" " \001(\014\022\n\n\002ts\030\004 \001(\004\")\n\020HistorySeekReply\022\t\n\001" "v\030\001 \001(\014\022\n\n\002ok\030\002 \001(\010\"\244\001\n\rIndexRangeReq\022\r\n" "\005tx_id\030\001 \001(\004\022\r\n\005table\030\002 \001(\t\022\t\n\001k\030\003 \001(\014\022\017" "\n\007from_ts\030\004 \001(\022\022\r\n\005to_ts\030\005 \001(\022\022\024\n\014order_" "ascend\030\006 \001(\010\022\r\n\005limit\030\007 \001(\022\022\021\n\tpage_size" "\030\010 \001(\005\022\022\n\npage_token\030\t \001(\t\">\n\017IndexRange" "Reply\022\022\n\ntimestamps\030\001 \003(\004\022\027\n\017next_page_t" "oken\030\002 \001(\t\"\233\001\n\017HistoryRangeReq\022\r\n\005tx_id\030" "\001 \001(\004\022\r\n\005table\030\002 \001(\t\022\017\n\007from_ts\030\004 \001(\022\022\r\n" "\005to_ts\030\005 \001(\022\022\024\n\014order_ascend\030\006 \001(\010\022\r\n\005li" "mit\030\007 \001(\022\022\021\n\tpage_size\030\010 \001(\005\022\022\n\npage_tok" "en\030\t \001(\t\"\266\001\n\014RangeAsOfReq\022\r\n\005tx_id\030\001 \001(\004" "\022\r\n\005table\030\002 \001(\t\022\020\n\010from_key\030\003 \001(\014\022\016\n\006to_" "key\030\004 \001(\014\022\n\n\002ts\030\005 \001(\004\022\016\n\006latest\030\006 \001(\010\022\024\n" "\014order_ascend\030\007 \001(\010\022\r\n\005limit\030\010 \001(\022\022\021\n\tpa" "ge_size\030\t \001(\005\022\022\n\npage_token\030\n \001(\t\">\n\005Pai" "rs\022\014\n\004keys\030\001 \003(\014\022\016\n\006values\030\002 \003(\014\022\027\n\017next" "_page_token\030\003 \001(\t\"2\n\017PairsPagination\022\020\n\010" "next_key\030\001 \001(\014\022\r\n\005limit\030\002 \001(\022\"9\n\017IndexPa" "gination\022\027\n\017next_time_stamp\030\001 \001(\022\022\r\n\005lim" "it\030\002 \001(\022*\373\001\n\002Op\022\t\n\005FIRST\020\000\022\r\n\tFIRST_DUP\020" "\001\022\010\n\004SEEK\020\002\022\r\n\tSEEK_BOTH\020\003\022\013\n\007CURRENT\020\004\022" "\010\n\004LAST\020\006\022\014\n\010LAST_DUP\020\007\022\010\n\004NEXT\020\010\022\014\n\010NEX" "T_DUP\020\t\022\017\n\013NEXT_NO_DUP\020\013\022\010\n\004PREV\020\014\022\014\n\010PR" "EV_DUP\020\r\022\017\n\013PREV_NO_DUP\020\016\022\016\n\nSEEK_EXACT\020" "\017\022\023\n\017SEEK_BOTH_EXACT\020\020\022\010\n\004OPEN\020\036\022\t\n\005CLOS" "E\020\037\022\021\n\rOPEN_DUP_SORT\020 *H\n\006Action\022\013\n\007STOR" "AGE\020\000\022\n\n\006UPSERT\020\001\022\010\n\004CODE\020\002\022\017\n\013UPSERT_CO" "DE\020\003\022\n\n\006REMOVE\020\004*$\n\tDirection\022\013\n\007FORWARD" "\020\000\022\n\n\006UNWIND\020\0012\271\004\n\002KV\0226\n\007Version\022\026.googl" "e.protobuf.Empty\032\023.types.VersionReply\022&\n" "\002Tx\022\016.remote.Cursor\032\014.remote.Pair(\0010\001\022F\n" "\014StateChanges\022\032.remote.StateChangeReques" "t\032\030.remote.StateChangeBatch0\001\022=\n\tSnapsho" "ts\022\030.remote.SnapshotsRequest\032\026.remote.Sn" "apshotsReply\022(\n\005Range\022\020.remote.RangeReq\032" "\r.remote.Pairs\0229\n\tGetLatest\022\024.remote.Get" "LatestReq\032\026.remote.GetLatestReply\022\?\n\013His" "torySeek\022\026.remote.HistorySeekReq\032\030.remot" "e.HistorySeekReply\022<\n\nIndexRange\022\025.remot" "e.IndexRangeReq\032\027.remote.IndexRangeReply" "\0226\n\014HistoryRange\022\027.remote.HistoryRangeRe" "q\032\r.remote.Pairs\0220\n\tRangeAsOf\022\024.remote.R" "angeAsOfReq\032\r.remote.PairsB\026Z\024./remote;r" "emoteprotob\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_remote_2fkv_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_types_2ftypes_2eproto, }; static ::absl::once_flag descriptor_table_remote_2fkv_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_remote_2fkv_2eproto = { false, false, 3138, descriptor_table_protodef_remote_2fkv_2eproto, "remote/kv.proto", &descriptor_table_remote_2fkv_2eproto_once, descriptor_table_remote_2fkv_2eproto_deps, 2, 21, schemas, file_default_instances, TableStruct_remote_2fkv_2eproto::offsets, file_level_enum_descriptors_remote_2fkv_2eproto, file_level_service_descriptors_remote_2fkv_2eproto, }; namespace remote { const ::google::protobuf::EnumDescriptor* Op_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_remote_2fkv_2eproto); return file_level_enum_descriptors_remote_2fkv_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t Op_internal_data_[] = { 327680u, 32u, 234885086u, }; bool Op_IsValid(int value) { return 0 <= value && value <= 32 && ((7516322783u >> value) & 1) != 0; } const ::google::protobuf::EnumDescriptor* Action_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_remote_2fkv_2eproto); return file_level_enum_descriptors_remote_2fkv_2eproto[1]; } PROTOBUF_CONSTINIT const uint32_t Action_internal_data_[] = { 327680u, 0u, }; bool Action_IsValid(int value) { return 0 <= value && value <= 4; } const ::google::protobuf::EnumDescriptor* Direction_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_remote_2fkv_2eproto); return file_level_enum_descriptors_remote_2fkv_2eproto[2]; } PROTOBUF_CONSTINIT const uint32_t Direction_internal_data_[] = { 131072u, 0u, }; bool Direction_IsValid(int value) { return 0 <= value && value <= 1; } // =================================================================== class Cursor::_Internal { public: }; Cursor::Cursor(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.Cursor) } inline PROTOBUF_NDEBUG_INLINE Cursor::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::Cursor& from_msg) : bucket_name_(arena, from.bucket_name_), k_(arena, from.k_), v_(arena, from.v_), _cached_size_{0} {} Cursor::Cursor( ::google::protobuf::Arena* arena, const Cursor& from) : ::google::protobuf::Message(arena) { Cursor* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, op_), reinterpret_cast(&from._impl_) + offsetof(Impl_, op_), offsetof(Impl_, cursor_) - offsetof(Impl_, op_) + sizeof(Impl_::cursor_)); // @@protoc_insertion_point(copy_constructor:remote.Cursor) } inline PROTOBUF_NDEBUG_INLINE Cursor::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : bucket_name_(arena), k_(arena), v_(arena), _cached_size_{0} {} inline void Cursor::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, op_), 0, offsetof(Impl_, cursor_) - offsetof(Impl_, op_) + sizeof(Impl_::cursor_)); } Cursor::~Cursor() { // @@protoc_insertion_point(destructor:remote.Cursor) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Cursor::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.bucket_name_.Destroy(); _impl_.k_.Destroy(); _impl_.v_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Cursor::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Cursor, _impl_._cached_size_), false, }, &Cursor::MergeImpl, &Cursor::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 5, 0, 33, 2> Cursor::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 5, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967264, // skipmap offsetof(decltype(_table_), field_entries), 5, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_Cursor_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::Cursor>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .remote.Op op = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Cursor, _impl_.op_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(Cursor, _impl_.op_)}}, // string bucket_name = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(Cursor, _impl_.bucket_name_)}}, // uint32 cursor = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Cursor, _impl_.cursor_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(Cursor, _impl_.cursor_)}}, // bytes k = 4; {::_pbi::TcParser::FastBS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(Cursor, _impl_.k_)}}, // bytes v = 5; {::_pbi::TcParser::FastBS1, {42, 63, 0, PROTOBUF_FIELD_OFFSET(Cursor, _impl_.v_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // .remote.Op op = 1; {PROTOBUF_FIELD_OFFSET(Cursor, _impl_.op_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // string bucket_name = 2; {PROTOBUF_FIELD_OFFSET(Cursor, _impl_.bucket_name_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 cursor = 3; {PROTOBUF_FIELD_OFFSET(Cursor, _impl_.cursor_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // bytes k = 4; {PROTOBUF_FIELD_OFFSET(Cursor, _impl_.k_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes v = 5; {PROTOBUF_FIELD_OFFSET(Cursor, _impl_.v_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\15\0\13\0\0\0\0\0" "remote.Cursor" "bucket_name" }}, }; PROTOBUF_NOINLINE void Cursor::Clear() { // @@protoc_insertion_point(message_clear_start:remote.Cursor) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.bucket_name_.ClearToEmpty(); _impl_.k_.ClearToEmpty(); _impl_.v_.ClearToEmpty(); ::memset(&_impl_.op_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.cursor_) - reinterpret_cast(&_impl_.op_)) + sizeof(_impl_.cursor_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Cursor::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.Cursor) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .remote.Op op = 1; if (this->_internal_op() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_op(), target); } // string bucket_name = 2; if (!this->_internal_bucket_name().empty()) { const std::string& _s = this->_internal_bucket_name(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.Cursor.bucket_name"); target = stream->WriteStringMaybeAliased(2, _s, target); } // uint32 cursor = 3; if (this->_internal_cursor() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 3, this->_internal_cursor(), target); } // bytes k = 4; if (!this->_internal_k().empty()) { const std::string& _s = this->_internal_k(); target = stream->WriteBytesMaybeAliased(4, _s, target); } // bytes v = 5; if (!this->_internal_v().empty()) { const std::string& _s = this->_internal_v(); target = stream->WriteBytesMaybeAliased(5, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.Cursor) return target; } ::size_t Cursor::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.Cursor) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string bucket_name = 2; if (!this->_internal_bucket_name().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_bucket_name()); } // bytes k = 4; if (!this->_internal_k().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_k()); } // bytes v = 5; if (!this->_internal_v().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_v()); } // .remote.Op op = 1; if (this->_internal_op() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_op()); } // uint32 cursor = 3; if (this->_internal_cursor() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_cursor()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Cursor::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.Cursor) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_bucket_name().empty()) { _this->_internal_set_bucket_name(from._internal_bucket_name()); } if (!from._internal_k().empty()) { _this->_internal_set_k(from._internal_k()); } if (!from._internal_v().empty()) { _this->_internal_set_v(from._internal_v()); } if (from._internal_op() != 0) { _this->_impl_.op_ = from._impl_.op_; } if (from._internal_cursor() != 0) { _this->_impl_.cursor_ = from._impl_.cursor_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Cursor::CopyFrom(const Cursor& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.Cursor) if (&from == this) return; Clear(); MergeFrom(from); } void Cursor::InternalSwap(Cursor* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.bucket_name_, &other->_impl_.bucket_name_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.k_, &other->_impl_.k_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.v_, &other->_impl_.v_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(Cursor, _impl_.cursor_) + sizeof(Cursor::_impl_.cursor_) - PROTOBUF_FIELD_OFFSET(Cursor, _impl_.op_)>( reinterpret_cast(&_impl_.op_), reinterpret_cast(&other->_impl_.op_)); } ::google::protobuf::Metadata Cursor::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Pair::_Internal { public: }; Pair::Pair(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.Pair) } inline PROTOBUF_NDEBUG_INLINE Pair::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::Pair& from_msg) : k_(arena, from.k_), v_(arena, from.v_), _cached_size_{0} {} Pair::Pair( ::google::protobuf::Arena* arena, const Pair& from) : ::google::protobuf::Message(arena) { Pair* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, view_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, view_id_), offsetof(Impl_, cursor_id_) - offsetof(Impl_, view_id_) + sizeof(Impl_::cursor_id_)); // @@protoc_insertion_point(copy_constructor:remote.Pair) } inline PROTOBUF_NDEBUG_INLINE Pair::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : k_(arena), v_(arena), _cached_size_{0} {} inline void Pair::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, view_id_), 0, offsetof(Impl_, cursor_id_) - offsetof(Impl_, view_id_) + sizeof(Impl_::cursor_id_)); } Pair::~Pair() { // @@protoc_insertion_point(destructor:remote.Pair) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Pair::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.k_.Destroy(); _impl_.v_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Pair::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Pair, _impl_._cached_size_), false, }, &Pair::MergeImpl, &Pair::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 5, 0, 0, 2> Pair::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 5, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967264, // skipmap offsetof(decltype(_table_), field_entries), 5, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_Pair_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::Pair>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // bytes k = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(Pair, _impl_.k_)}}, // bytes v = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(Pair, _impl_.v_)}}, // uint32 cursor_id = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Pair, _impl_.cursor_id_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(Pair, _impl_.cursor_id_)}}, // uint64 view_id = 4; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Pair, _impl_.view_id_), 63>(), {32, 63, 0, PROTOBUF_FIELD_OFFSET(Pair, _impl_.view_id_)}}, // uint64 tx_id = 5; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Pair, _impl_.tx_id_), 63>(), {40, 63, 0, PROTOBUF_FIELD_OFFSET(Pair, _impl_.tx_id_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // bytes k = 1; {PROTOBUF_FIELD_OFFSET(Pair, _impl_.k_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes v = 2; {PROTOBUF_FIELD_OFFSET(Pair, _impl_.v_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // uint32 cursor_id = 3; {PROTOBUF_FIELD_OFFSET(Pair, _impl_.cursor_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // uint64 view_id = 4; {PROTOBUF_FIELD_OFFSET(Pair, _impl_.view_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 tx_id = 5; {PROTOBUF_FIELD_OFFSET(Pair, _impl_.tx_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void Pair::Clear() { // @@protoc_insertion_point(message_clear_start:remote.Pair) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.k_.ClearToEmpty(); _impl_.v_.ClearToEmpty(); ::memset(&_impl_.view_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.cursor_id_) - reinterpret_cast(&_impl_.view_id_)) + sizeof(_impl_.cursor_id_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Pair::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.Pair) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes k = 1; if (!this->_internal_k().empty()) { const std::string& _s = this->_internal_k(); target = stream->WriteBytesMaybeAliased(1, _s, target); } // bytes v = 2; if (!this->_internal_v().empty()) { const std::string& _s = this->_internal_v(); target = stream->WriteBytesMaybeAliased(2, _s, target); } // uint32 cursor_id = 3; if (this->_internal_cursor_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 3, this->_internal_cursor_id(), target); } // uint64 view_id = 4; if (this->_internal_view_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 4, this->_internal_view_id(), target); } // uint64 tx_id = 5; if (this->_internal_tx_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 5, this->_internal_tx_id(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.Pair) return target; } ::size_t Pair::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.Pair) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes k = 1; if (!this->_internal_k().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_k()); } // bytes v = 2; if (!this->_internal_v().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_v()); } // uint64 view_id = 4; if (this->_internal_view_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_view_id()); } // uint64 tx_id = 5; if (this->_internal_tx_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_id()); } // uint32 cursor_id = 3; if (this->_internal_cursor_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_cursor_id()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Pair::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.Pair) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_k().empty()) { _this->_internal_set_k(from._internal_k()); } if (!from._internal_v().empty()) { _this->_internal_set_v(from._internal_v()); } if (from._internal_view_id() != 0) { _this->_impl_.view_id_ = from._impl_.view_id_; } if (from._internal_tx_id() != 0) { _this->_impl_.tx_id_ = from._impl_.tx_id_; } if (from._internal_cursor_id() != 0) { _this->_impl_.cursor_id_ = from._impl_.cursor_id_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Pair::CopyFrom(const Pair& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.Pair) if (&from == this) return; Clear(); MergeFrom(from); } void Pair::InternalSwap(Pair* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.k_, &other->_impl_.k_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.v_, &other->_impl_.v_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(Pair, _impl_.cursor_id_) + sizeof(Pair::_impl_.cursor_id_) - PROTOBUF_FIELD_OFFSET(Pair, _impl_.view_id_)>( reinterpret_cast(&_impl_.view_id_), reinterpret_cast(&other->_impl_.view_id_)); } ::google::protobuf::Metadata Pair::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StorageChange::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(StorageChange, _impl_._has_bits_); }; void StorageChange::clear_location() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.location_ != nullptr) _impl_.location_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } StorageChange::StorageChange(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.StorageChange) } inline PROTOBUF_NDEBUG_INLINE StorageChange::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::StorageChange& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, data_(arena, from.data_) {} StorageChange::StorageChange( ::google::protobuf::Arena* arena, const StorageChange& from) : ::google::protobuf::Message(arena) { StorageChange* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.location_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.location_) : nullptr; // @@protoc_insertion_point(copy_constructor:remote.StorageChange) } inline PROTOBUF_NDEBUG_INLINE StorageChange::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, data_(arena) {} inline void StorageChange::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.location_ = {}; } StorageChange::~StorageChange() { // @@protoc_insertion_point(destructor:remote.StorageChange) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void StorageChange::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.data_.Destroy(); delete _impl_.location_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* StorageChange::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(StorageChange, _impl_._cached_size_), false, }, &StorageChange::MergeImpl, &StorageChange::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> StorageChange::_table_ = { { PROTOBUF_FIELD_OFFSET(StorageChange, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_StorageChange_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::StorageChange>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes data = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(StorageChange, _impl_.data_)}}, // .types.H256 location = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(StorageChange, _impl_.location_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 location = 1; {PROTOBUF_FIELD_OFFSET(StorageChange, _impl_.location_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bytes data = 2; {PROTOBUF_FIELD_OFFSET(StorageChange, _impl_.data_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void StorageChange::Clear() { // @@protoc_insertion_point(message_clear_start:remote.StorageChange) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.data_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.location_ != nullptr); _impl_.location_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* StorageChange::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.StorageChange) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 location = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.location_, _impl_.location_->GetCachedSize(), target, stream); } // bytes data = 2; if (!this->_internal_data().empty()) { const std::string& _s = this->_internal_data(); target = stream->WriteBytesMaybeAliased(2, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.StorageChange) return target; } ::size_t StorageChange::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.StorageChange) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes data = 2; if (!this->_internal_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_data()); } // .types.H256 location = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.location_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void StorageChange::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.StorageChange) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_data().empty()) { _this->_internal_set_data(from._internal_data()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.location_ != nullptr); if (_this->_impl_.location_ == nullptr) { _this->_impl_.location_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.location_); } else { _this->_impl_.location_->MergeFrom(*from._impl_.location_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void StorageChange::CopyFrom(const StorageChange& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.StorageChange) if (&from == this) return; Clear(); MergeFrom(from); } void StorageChange::InternalSwap(StorageChange* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); swap(_impl_.location_, other->_impl_.location_); } ::google::protobuf::Metadata StorageChange::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AccountChange::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(AccountChange, _impl_._has_bits_); }; void AccountChange::clear_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ != nullptr) _impl_.address_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } AccountChange::AccountChange(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.AccountChange) } inline PROTOBUF_NDEBUG_INLINE AccountChange::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::AccountChange& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, storage_changes_{visibility, arena, from.storage_changes_}, data_(arena, from.data_), code_(arena, from.code_) {} AccountChange::AccountChange( ::google::protobuf::Arena* arena, const AccountChange& from) : ::google::protobuf::Message(arena) { AccountChange* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.address_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, incarnation_), reinterpret_cast(&from._impl_) + offsetof(Impl_, incarnation_), offsetof(Impl_, action_) - offsetof(Impl_, incarnation_) + sizeof(Impl_::action_)); // @@protoc_insertion_point(copy_constructor:remote.AccountChange) } inline PROTOBUF_NDEBUG_INLINE AccountChange::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, storage_changes_{visibility, arena}, data_(arena), code_(arena) {} inline void AccountChange::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, address_), 0, offsetof(Impl_, action_) - offsetof(Impl_, address_) + sizeof(Impl_::action_)); } AccountChange::~AccountChange() { // @@protoc_insertion_point(destructor:remote.AccountChange) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AccountChange::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.data_.Destroy(); _impl_.code_.Destroy(); delete _impl_.address_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AccountChange::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AccountChange, _impl_._cached_size_), false, }, &AccountChange::MergeImpl, &AccountChange::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 6, 2, 0, 2> AccountChange::_table_ = { { PROTOBUF_FIELD_OFFSET(AccountChange, _impl_._has_bits_), 0, // no _extensions_ 6, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967232, // skipmap offsetof(decltype(_table_), field_entries), 6, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_AccountChange_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::AccountChange>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .types.H160 address = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.address_)}}, // uint64 incarnation = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(AccountChange, _impl_.incarnation_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.incarnation_)}}, // .remote.Action action = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(AccountChange, _impl_.action_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.action_)}}, // bytes data = 4; {::_pbi::TcParser::FastBS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.data_)}}, // bytes code = 5; {::_pbi::TcParser::FastBS1, {42, 63, 0, PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.code_)}}, // repeated .remote.StorageChange storage_changes = 6; {::_pbi::TcParser::FastMtR1, {50, 63, 1, PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.storage_changes_)}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // .types.H160 address = 1; {PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 incarnation = 2; {PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.incarnation_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .remote.Action action = 3; {PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.action_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // bytes data = 4; {PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.data_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes code = 5; {PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.code_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // repeated .remote.StorageChange storage_changes = 6; {PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.storage_changes_), -1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, {::_pbi::TcParser::GetTable<::remote::StorageChange>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void AccountChange::Clear() { // @@protoc_insertion_point(message_clear_start:remote.AccountChange) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.storage_changes_.Clear(); _impl_.data_.ClearToEmpty(); _impl_.code_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.address_ != nullptr); _impl_.address_->Clear(); } ::memset(&_impl_.incarnation_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.action_) - reinterpret_cast(&_impl_.incarnation_)) + sizeof(_impl_.action_)); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AccountChange::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.AccountChange) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H160 address = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.address_, _impl_.address_->GetCachedSize(), target, stream); } // uint64 incarnation = 2; if (this->_internal_incarnation() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_incarnation(), target); } // .remote.Action action = 3; if (this->_internal_action() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 3, this->_internal_action(), target); } // bytes data = 4; if (!this->_internal_data().empty()) { const std::string& _s = this->_internal_data(); target = stream->WriteBytesMaybeAliased(4, _s, target); } // bytes code = 5; if (!this->_internal_code().empty()) { const std::string& _s = this->_internal_code(); target = stream->WriteBytesMaybeAliased(5, _s, target); } // repeated .remote.StorageChange storage_changes = 6; for (unsigned i = 0, n = static_cast( this->_internal_storage_changes_size()); i < n; i++) { const auto& repfield = this->_internal_storage_changes().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 6, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.AccountChange) return target; } ::size_t AccountChange::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.AccountChange) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .remote.StorageChange storage_changes = 6; total_size += 1UL * this->_internal_storage_changes_size(); for (const auto& msg : this->_internal_storage_changes()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // bytes data = 4; if (!this->_internal_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_data()); } // bytes code = 5; if (!this->_internal_code().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_code()); } // .types.H160 address = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.address_); } // uint64 incarnation = 2; if (this->_internal_incarnation() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_incarnation()); } // .remote.Action action = 3; if (this->_internal_action() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_action()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AccountChange::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.AccountChange) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_storage_changes()->MergeFrom( from._internal_storage_changes()); if (!from._internal_data().empty()) { _this->_internal_set_data(from._internal_data()); } if (!from._internal_code().empty()) { _this->_internal_set_code(from._internal_code()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.address_ != nullptr); if (_this->_impl_.address_ == nullptr) { _this->_impl_.address_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.address_); } else { _this->_impl_.address_->MergeFrom(*from._impl_.address_); } } if (from._internal_incarnation() != 0) { _this->_impl_.incarnation_ = from._impl_.incarnation_; } if (from._internal_action() != 0) { _this->_impl_.action_ = from._impl_.action_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AccountChange::CopyFrom(const AccountChange& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.AccountChange) if (&from == this) return; Clear(); MergeFrom(from); } void AccountChange::InternalSwap(AccountChange* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.storage_changes_.InternalSwap(&other->_impl_.storage_changes_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.code_, &other->_impl_.code_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.action_) + sizeof(AccountChange::_impl_.action_) - PROTOBUF_FIELD_OFFSET(AccountChange, _impl_.address_)>( reinterpret_cast(&_impl_.address_), reinterpret_cast(&other->_impl_.address_)); } ::google::protobuf::Metadata AccountChange::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StateChangeBatch::_Internal { public: }; StateChangeBatch::StateChangeBatch(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.StateChangeBatch) } inline PROTOBUF_NDEBUG_INLINE StateChangeBatch::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::StateChangeBatch& from_msg) : change_batch_{visibility, arena, from.change_batch_}, _cached_size_{0} {} StateChangeBatch::StateChangeBatch( ::google::protobuf::Arena* arena, const StateChangeBatch& from) : ::google::protobuf::Message(arena) { StateChangeBatch* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, state_version_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, state_version_id_), offsetof(Impl_, pending_blob_fee_per_gas_) - offsetof(Impl_, state_version_id_) + sizeof(Impl_::pending_blob_fee_per_gas_)); // @@protoc_insertion_point(copy_constructor:remote.StateChangeBatch) } inline PROTOBUF_NDEBUG_INLINE StateChangeBatch::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : change_batch_{visibility, arena}, _cached_size_{0} {} inline void StateChangeBatch::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, state_version_id_), 0, offsetof(Impl_, pending_blob_fee_per_gas_) - offsetof(Impl_, state_version_id_) + sizeof(Impl_::pending_blob_fee_per_gas_)); } StateChangeBatch::~StateChangeBatch() { // @@protoc_insertion_point(destructor:remote.StateChangeBatch) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void StateChangeBatch::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* StateChangeBatch::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_._cached_size_), false, }, &StateChangeBatch::MergeImpl, &StateChangeBatch::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 6, 1, 0, 2> StateChangeBatch::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 6, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967232, // skipmap offsetof(decltype(_table_), field_entries), 6, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_StateChangeBatch_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::StateChangeBatch>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint64 state_version_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StateChangeBatch, _impl_.state_version_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.state_version_id_)}}, // repeated .remote.StateChange change_batch = 2; {::_pbi::TcParser::FastMtR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.change_batch_)}}, // uint64 pending_block_base_fee = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StateChangeBatch, _impl_.pending_block_base_fee_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.pending_block_base_fee_)}}, // uint64 block_gas_limit = 4; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StateChangeBatch, _impl_.block_gas_limit_), 63>(), {32, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.block_gas_limit_)}}, // uint64 finalized_block = 5; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StateChangeBatch, _impl_.finalized_block_), 63>(), {40, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.finalized_block_)}}, // uint64 pending_blob_fee_per_gas = 6; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StateChangeBatch, _impl_.pending_blob_fee_per_gas_), 63>(), {48, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.pending_blob_fee_per_gas_)}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint64 state_version_id = 1; {PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.state_version_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // repeated .remote.StateChange change_batch = 2; {PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.change_batch_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 pending_block_base_fee = 3; {PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.pending_block_base_fee_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 block_gas_limit = 4; {PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.block_gas_limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 finalized_block = 5; {PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.finalized_block_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 pending_blob_fee_per_gas = 6; {PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.pending_blob_fee_per_gas_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::remote::StateChange>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void StateChangeBatch::Clear() { // @@protoc_insertion_point(message_clear_start:remote.StateChangeBatch) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.change_batch_.Clear(); ::memset(&_impl_.state_version_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.pending_blob_fee_per_gas_) - reinterpret_cast(&_impl_.state_version_id_)) + sizeof(_impl_.pending_blob_fee_per_gas_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* StateChangeBatch::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.StateChangeBatch) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 state_version_id = 1; if (this->_internal_state_version_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_state_version_id(), target); } // repeated .remote.StateChange change_batch = 2; for (unsigned i = 0, n = static_cast( this->_internal_change_batch_size()); i < n; i++) { const auto& repfield = this->_internal_change_batch().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, repfield, repfield.GetCachedSize(), target, stream); } // uint64 pending_block_base_fee = 3; if (this->_internal_pending_block_base_fee() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 3, this->_internal_pending_block_base_fee(), target); } // uint64 block_gas_limit = 4; if (this->_internal_block_gas_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 4, this->_internal_block_gas_limit(), target); } // uint64 finalized_block = 5; if (this->_internal_finalized_block() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 5, this->_internal_finalized_block(), target); } // uint64 pending_blob_fee_per_gas = 6; if (this->_internal_pending_blob_fee_per_gas() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 6, this->_internal_pending_blob_fee_per_gas(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.StateChangeBatch) return target; } ::size_t StateChangeBatch::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.StateChangeBatch) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .remote.StateChange change_batch = 2; total_size += 1UL * this->_internal_change_batch_size(); for (const auto& msg : this->_internal_change_batch()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // uint64 state_version_id = 1; if (this->_internal_state_version_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_state_version_id()); } // uint64 pending_block_base_fee = 3; if (this->_internal_pending_block_base_fee() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_pending_block_base_fee()); } // uint64 block_gas_limit = 4; if (this->_internal_block_gas_limit() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_gas_limit()); } // uint64 finalized_block = 5; if (this->_internal_finalized_block() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_finalized_block()); } // uint64 pending_blob_fee_per_gas = 6; if (this->_internal_pending_blob_fee_per_gas() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_pending_blob_fee_per_gas()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void StateChangeBatch::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.StateChangeBatch) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_change_batch()->MergeFrom( from._internal_change_batch()); if (from._internal_state_version_id() != 0) { _this->_impl_.state_version_id_ = from._impl_.state_version_id_; } if (from._internal_pending_block_base_fee() != 0) { _this->_impl_.pending_block_base_fee_ = from._impl_.pending_block_base_fee_; } if (from._internal_block_gas_limit() != 0) { _this->_impl_.block_gas_limit_ = from._impl_.block_gas_limit_; } if (from._internal_finalized_block() != 0) { _this->_impl_.finalized_block_ = from._impl_.finalized_block_; } if (from._internal_pending_blob_fee_per_gas() != 0) { _this->_impl_.pending_blob_fee_per_gas_ = from._impl_.pending_blob_fee_per_gas_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void StateChangeBatch::CopyFrom(const StateChangeBatch& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.StateChangeBatch) if (&from == this) return; Clear(); MergeFrom(from); } void StateChangeBatch::InternalSwap(StateChangeBatch* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.change_batch_.InternalSwap(&other->_impl_.change_batch_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.pending_blob_fee_per_gas_) + sizeof(StateChangeBatch::_impl_.pending_blob_fee_per_gas_) - PROTOBUF_FIELD_OFFSET(StateChangeBatch, _impl_.state_version_id_)>( reinterpret_cast(&_impl_.state_version_id_), reinterpret_cast(&other->_impl_.state_version_id_)); } ::google::protobuf::Metadata StateChangeBatch::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StateChange::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(StateChange, _impl_._has_bits_); }; void StateChange::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } StateChange::StateChange(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.StateChange) } inline PROTOBUF_NDEBUG_INLINE StateChange::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::StateChange& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, changes_{visibility, arena, from.changes_}, txs_{visibility, arena, from.txs_} {} StateChange::StateChange( ::google::protobuf::Arena* arena, const StateChange& from) : ::google::protobuf::Message(arena) { StateChange* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.block_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, block_height_), reinterpret_cast(&from._impl_) + offsetof(Impl_, block_height_), offsetof(Impl_, direction_) - offsetof(Impl_, block_height_) + sizeof(Impl_::direction_)); // @@protoc_insertion_point(copy_constructor:remote.StateChange) } inline PROTOBUF_NDEBUG_INLINE StateChange::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, changes_{visibility, arena}, txs_{visibility, arena} {} inline void StateChange::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, block_hash_), 0, offsetof(Impl_, direction_) - offsetof(Impl_, block_hash_) + sizeof(Impl_::direction_)); } StateChange::~StateChange() { // @@protoc_insertion_point(destructor:remote.StateChange) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void StateChange::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.block_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* StateChange::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(StateChange, _impl_._cached_size_), false, }, &StateChange::MergeImpl, &StateChange::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 5, 2, 0, 2> StateChange::_table_ = { { PROTOBUF_FIELD_OFFSET(StateChange, _impl_._has_bits_), 0, // no _extensions_ 5, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967264, // skipmap offsetof(decltype(_table_), field_entries), 5, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_StateChange_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::StateChange>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .remote.Direction direction = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(StateChange, _impl_.direction_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(StateChange, _impl_.direction_)}}, // uint64 block_height = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(StateChange, _impl_.block_height_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(StateChange, _impl_.block_height_)}}, // .types.H256 block_hash = 3; {::_pbi::TcParser::FastMtS1, {26, 0, 0, PROTOBUF_FIELD_OFFSET(StateChange, _impl_.block_hash_)}}, // repeated .remote.AccountChange changes = 4; {::_pbi::TcParser::FastMtR1, {34, 63, 1, PROTOBUF_FIELD_OFFSET(StateChange, _impl_.changes_)}}, // repeated bytes txs = 5; {::_pbi::TcParser::FastBR1, {42, 63, 0, PROTOBUF_FIELD_OFFSET(StateChange, _impl_.txs_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // .remote.Direction direction = 1; {PROTOBUF_FIELD_OFFSET(StateChange, _impl_.direction_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // uint64 block_height = 2; {PROTOBUF_FIELD_OFFSET(StateChange, _impl_.block_height_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .types.H256 block_hash = 3; {PROTOBUF_FIELD_OFFSET(StateChange, _impl_.block_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // repeated .remote.AccountChange changes = 4; {PROTOBUF_FIELD_OFFSET(StateChange, _impl_.changes_), -1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, // repeated bytes txs = 5; {PROTOBUF_FIELD_OFFSET(StateChange, _impl_.txs_), -1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::remote::AccountChange>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void StateChange::Clear() { // @@protoc_insertion_point(message_clear_start:remote.StateChange) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.changes_.Clear(); _impl_.txs_.Clear(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } ::memset(&_impl_.block_height_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.direction_) - reinterpret_cast(&_impl_.block_height_)) + sizeof(_impl_.direction_)); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* StateChange::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.StateChange) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .remote.Direction direction = 1; if (this->_internal_direction() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_direction(), target); } // uint64 block_height = 2; if (this->_internal_block_height() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_block_height(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H256 block_hash = 3; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } // repeated .remote.AccountChange changes = 4; for (unsigned i = 0, n = static_cast( this->_internal_changes_size()); i < n; i++) { const auto& repfield = this->_internal_changes().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, repfield, repfield.GetCachedSize(), target, stream); } // repeated bytes txs = 5; for (int i = 0, n = this->_internal_txs_size(); i < n; ++i) { const auto& s = this->_internal_txs().Get(i); target = stream->WriteBytes(5, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.StateChange) return target; } ::size_t StateChange::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.StateChange) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .remote.AccountChange changes = 4; total_size += 1UL * this->_internal_changes_size(); for (const auto& msg : this->_internal_changes()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // repeated bytes txs = 5; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_txs().size()); for (int i = 0, n = _internal_txs().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_txs().Get(i)); } // .types.H256 block_hash = 3; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } // uint64 block_height = 2; if (this->_internal_block_height() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_height()); } // .remote.Direction direction = 1; if (this->_internal_direction() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_direction()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void StateChange::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:remote.StateChange) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_changes()->MergeFrom( from._internal_changes()); _this->_internal_mutable_txs()->MergeFrom(from._internal_txs()); cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } if (from._internal_block_height() != 0) { _this->_impl_.block_height_ = from._impl_.block_height_; } if (from._internal_direction() != 0) { _this->_impl_.direction_ = from._impl_.direction_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void StateChange::CopyFrom(const StateChange& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.StateChange) if (&from == this) return; Clear(); MergeFrom(from); } void StateChange::InternalSwap(StateChange* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.changes_.InternalSwap(&other->_impl_.changes_); _impl_.txs_.InternalSwap(&other->_impl_.txs_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(StateChange, _impl_.direction_) + sizeof(StateChange::_impl_.direction_) - PROTOBUF_FIELD_OFFSET(StateChange, _impl_.block_hash_)>( reinterpret_cast(&_impl_.block_hash_), reinterpret_cast(&other->_impl_.block_hash_)); } ::google::protobuf::Metadata StateChange::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StateChangeRequest::_Internal { public: }; StateChangeRequest::StateChangeRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.StateChangeRequest) } StateChangeRequest::StateChangeRequest( ::google::protobuf::Arena* arena, const StateChangeRequest& from) : StateChangeRequest(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE StateChangeRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void StateChangeRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, with_storage_), 0, offsetof(Impl_, with_transactions_) - offsetof(Impl_, with_storage_) + sizeof(Impl_::with_transactions_)); } StateChangeRequest::~StateChangeRequest() { // @@protoc_insertion_point(destructor:remote.StateChangeRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void StateChangeRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* StateChangeRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(StateChangeRequest, _impl_._cached_size_), false, }, &StateChangeRequest::MergeImpl, &StateChangeRequest::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> StateChangeRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_StateChangeRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::StateChangeRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool with_transactions = 2; {::_pbi::TcParser::SingularVarintNoZag1(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeRequest, _impl_.with_transactions_)}}, // bool with_storage = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(StateChangeRequest, _impl_.with_storage_)}}, }}, {{ 65535, 65535 }}, {{ // bool with_storage = 1; {PROTOBUF_FIELD_OFFSET(StateChangeRequest, _impl_.with_storage_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // bool with_transactions = 2; {PROTOBUF_FIELD_OFFSET(StateChangeRequest, _impl_.with_transactions_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void StateChangeRequest::Clear() { // @@protoc_insertion_point(message_clear_start:remote.StateChangeRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.with_storage_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.with_transactions_) - reinterpret_cast(&_impl_.with_storage_)) + sizeof(_impl_.with_transactions_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* StateChangeRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.StateChangeRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool with_storage = 1; if (this->_internal_with_storage() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_with_storage(), target); } // bool with_transactions = 2; if (this->_internal_with_transactions() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 2, this->_internal_with_transactions(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.StateChangeRequest) return target; } ::size_t StateChangeRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.StateChangeRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bool with_storage = 1; if (this->_internal_with_storage() != 0) { total_size += 2; } // bool with_transactions = 2; if (this->_internal_with_transactions() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void StateChangeRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.StateChangeRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_with_storage() != 0) { _this->_impl_.with_storage_ = from._impl_.with_storage_; } if (from._internal_with_transactions() != 0) { _this->_impl_.with_transactions_ = from._impl_.with_transactions_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void StateChangeRequest::CopyFrom(const StateChangeRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.StateChangeRequest) if (&from == this) return; Clear(); MergeFrom(from); } void StateChangeRequest::InternalSwap(StateChangeRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(StateChangeRequest, _impl_.with_transactions_) + sizeof(StateChangeRequest::_impl_.with_transactions_) - PROTOBUF_FIELD_OFFSET(StateChangeRequest, _impl_.with_storage_)>( reinterpret_cast(&_impl_.with_storage_), reinterpret_cast(&other->_impl_.with_storage_)); } ::google::protobuf::Metadata StateChangeRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SnapshotsRequest::_Internal { public: }; SnapshotsRequest::SnapshotsRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:remote.SnapshotsRequest) } SnapshotsRequest::SnapshotsRequest( ::google::protobuf::Arena* arena, const SnapshotsRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { SnapshotsRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:remote.SnapshotsRequest) } const ::google::protobuf::MessageLite::ClassData* SnapshotsRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SnapshotsRequest, _impl_._cached_size_), false, }, &SnapshotsRequest::MergeImpl, &SnapshotsRequest::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SnapshotsRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SnapshotsRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::SnapshotsRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata SnapshotsRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SnapshotsReply::_Internal { public: }; SnapshotsReply::SnapshotsReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.SnapshotsReply) } inline PROTOBUF_NDEBUG_INLINE SnapshotsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::SnapshotsReply& from_msg) : blocks_files_{visibility, arena, from.blocks_files_}, history_files_{visibility, arena, from.history_files_}, _cached_size_{0} {} SnapshotsReply::SnapshotsReply( ::google::protobuf::Arena* arena, const SnapshotsReply& from) : ::google::protobuf::Message(arena) { SnapshotsReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.SnapshotsReply) } inline PROTOBUF_NDEBUG_INLINE SnapshotsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : blocks_files_{visibility, arena}, history_files_{visibility, arena}, _cached_size_{0} {} inline void SnapshotsReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } SnapshotsReply::~SnapshotsReply() { // @@protoc_insertion_point(destructor:remote.SnapshotsReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SnapshotsReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SnapshotsReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SnapshotsReply, _impl_._cached_size_), false, }, &SnapshotsReply::MergeImpl, &SnapshotsReply::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 55, 2> SnapshotsReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SnapshotsReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::SnapshotsReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated string history_files = 2; {::_pbi::TcParser::FastUR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(SnapshotsReply, _impl_.history_files_)}}, // repeated string blocks_files = 1; {::_pbi::TcParser::FastUR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(SnapshotsReply, _impl_.blocks_files_)}}, }}, {{ 65535, 65535 }}, {{ // repeated string blocks_files = 1; {PROTOBUF_FIELD_OFFSET(SnapshotsReply, _impl_.blocks_files_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, // repeated string history_files = 2; {PROTOBUF_FIELD_OFFSET(SnapshotsReply, _impl_.history_files_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, }}, // no aux_entries {{ "\25\14\15\0\0\0\0\0" "remote.SnapshotsReply" "blocks_files" "history_files" }}, }; PROTOBUF_NOINLINE void SnapshotsReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.SnapshotsReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.blocks_files_.Clear(); _impl_.history_files_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SnapshotsReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.SnapshotsReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated string blocks_files = 1; for (int i = 0, n = this->_internal_blocks_files_size(); i < n; ++i) { const auto& s = this->_internal_blocks_files().Get(i); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.SnapshotsReply.blocks_files"); target = stream->WriteString(1, s, target); } // repeated string history_files = 2; for (int i = 0, n = this->_internal_history_files_size(); i < n; ++i) { const auto& s = this->_internal_history_files().Get(i); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.SnapshotsReply.history_files"); target = stream->WriteString(2, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.SnapshotsReply) return target; } ::size_t SnapshotsReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.SnapshotsReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated string blocks_files = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_blocks_files().size()); for (int i = 0, n = _internal_blocks_files().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::StringSize( _internal_blocks_files().Get(i)); } // repeated string history_files = 2; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_history_files().size()); for (int i = 0, n = _internal_history_files().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::StringSize( _internal_history_files().Get(i)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SnapshotsReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.SnapshotsReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_blocks_files()->MergeFrom(from._internal_blocks_files()); _this->_internal_mutable_history_files()->MergeFrom(from._internal_history_files()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SnapshotsReply::CopyFrom(const SnapshotsReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.SnapshotsReply) if (&from == this) return; Clear(); MergeFrom(from); } void SnapshotsReply::InternalSwap(SnapshotsReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.blocks_files_.InternalSwap(&other->_impl_.blocks_files_); _impl_.history_files_.InternalSwap(&other->_impl_.history_files_); } ::google::protobuf::Metadata SnapshotsReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RangeReq::_Internal { public: }; RangeReq::RangeReq(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.RangeReq) } inline PROTOBUF_NDEBUG_INLINE RangeReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::RangeReq& from_msg) : table_(arena, from.table_), from_prefix_(arena, from.from_prefix_), to_prefix_(arena, from.to_prefix_), page_token_(arena, from.page_token_), _cached_size_{0} {} RangeReq::RangeReq( ::google::protobuf::Arena* arena, const RangeReq& from) : ::google::protobuf::Message(arena) { RangeReq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, tx_id_), offsetof(Impl_, page_size_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::page_size_)); // @@protoc_insertion_point(copy_constructor:remote.RangeReq) } inline PROTOBUF_NDEBUG_INLINE RangeReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : table_(arena), from_prefix_(arena), to_prefix_(arena), page_token_(arena), _cached_size_{0} {} inline void RangeReq::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), 0, offsetof(Impl_, page_size_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::page_size_)); } RangeReq::~RangeReq() { // @@protoc_insertion_point(destructor:remote.RangeReq) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void RangeReq::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.table_.Destroy(); _impl_.from_prefix_.Destroy(); _impl_.to_prefix_.Destroy(); _impl_.page_token_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* RangeReq::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(RangeReq, _impl_._cached_size_), false, }, &RangeReq::MergeImpl, &RangeReq::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 8, 0, 47, 2> RangeReq::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 8, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967040, // skipmap offsetof(decltype(_table_), field_entries), 8, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_RangeReq_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::RangeReq>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // string page_token = 8; {::_pbi::TcParser::FastUS1, {66, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.page_token_)}}, // uint64 tx_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RangeReq, _impl_.tx_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.tx_id_)}}, // string table = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.table_)}}, // bytes from_prefix = 3; {::_pbi::TcParser::FastBS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.from_prefix_)}}, // bytes to_prefix = 4; {::_pbi::TcParser::FastBS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.to_prefix_)}}, // bool order_ascend = 5; {::_pbi::TcParser::SingularVarintNoZag1(), {40, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.order_ascend_)}}, // sint64 limit = 6; {::_pbi::TcParser::FastZ64S1, {48, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.limit_)}}, // int32 page_size = 7; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RangeReq, _impl_.page_size_), 63>(), {56, 63, 0, PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.page_size_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 tx_id = 1; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.tx_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // string table = 2; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.table_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bytes from_prefix = 3; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.from_prefix_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes to_prefix = 4; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.to_prefix_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bool order_ascend = 5; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.order_ascend_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // sint64 limit = 6; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // int32 page_size = 7; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.page_size_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, // string page_token = 8; {PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.page_token_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\17\0\5\0\0\0\0\0\12\0\0\0\0\0\0\0" "remote.RangeReq" "table" "page_token" }}, }; PROTOBUF_NOINLINE void RangeReq::Clear() { // @@protoc_insertion_point(message_clear_start:remote.RangeReq) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.table_.ClearToEmpty(); _impl_.from_prefix_.ClearToEmpty(); _impl_.to_prefix_.ClearToEmpty(); _impl_.page_token_.ClearToEmpty(); ::memset(&_impl_.tx_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.page_size_) - reinterpret_cast(&_impl_.tx_id_)) + sizeof(_impl_.page_size_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* RangeReq::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.RangeReq) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_tx_id(), target); } // string table = 2; if (!this->_internal_table().empty()) { const std::string& _s = this->_internal_table(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.RangeReq.table"); target = stream->WriteStringMaybeAliased(2, _s, target); } // bytes from_prefix = 3; if (!this->_internal_from_prefix().empty()) { const std::string& _s = this->_internal_from_prefix(); target = stream->WriteBytesMaybeAliased(3, _s, target); } // bytes to_prefix = 4; if (!this->_internal_to_prefix().empty()) { const std::string& _s = this->_internal_to_prefix(); target = stream->WriteBytesMaybeAliased(4, _s, target); } // bool order_ascend = 5; if (this->_internal_order_ascend() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 5, this->_internal_order_ascend(), target); } // sint64 limit = 6; if (this->_internal_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 6, this->_internal_limit(), target); } // int32 page_size = 7; if (this->_internal_page_size() != 0) { target = ::google::protobuf::internal::WireFormatLite:: WriteInt32ToArrayWithField<7>( stream, this->_internal_page_size(), target); } // string page_token = 8; if (!this->_internal_page_token().empty()) { const std::string& _s = this->_internal_page_token(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.RangeReq.page_token"); target = stream->WriteStringMaybeAliased(8, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.RangeReq) return target; } ::size_t RangeReq::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.RangeReq) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string table = 2; if (!this->_internal_table().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_table()); } // bytes from_prefix = 3; if (!this->_internal_from_prefix().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_from_prefix()); } // bytes to_prefix = 4; if (!this->_internal_to_prefix().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_to_prefix()); } // string page_token = 8; if (!this->_internal_page_token().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_page_token()); } // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_id()); } // sint64 limit = 6; if (this->_internal_limit() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_limit()); } // bool order_ascend = 5; if (this->_internal_order_ascend() != 0) { total_size += 2; } // int32 page_size = 7; if (this->_internal_page_size() != 0) { total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( this->_internal_page_size()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void RangeReq::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.RangeReq) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_table().empty()) { _this->_internal_set_table(from._internal_table()); } if (!from._internal_from_prefix().empty()) { _this->_internal_set_from_prefix(from._internal_from_prefix()); } if (!from._internal_to_prefix().empty()) { _this->_internal_set_to_prefix(from._internal_to_prefix()); } if (!from._internal_page_token().empty()) { _this->_internal_set_page_token(from._internal_page_token()); } if (from._internal_tx_id() != 0) { _this->_impl_.tx_id_ = from._impl_.tx_id_; } if (from._internal_limit() != 0) { _this->_impl_.limit_ = from._impl_.limit_; } if (from._internal_order_ascend() != 0) { _this->_impl_.order_ascend_ = from._impl_.order_ascend_; } if (from._internal_page_size() != 0) { _this->_impl_.page_size_ = from._impl_.page_size_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void RangeReq::CopyFrom(const RangeReq& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.RangeReq) if (&from == this) return; Clear(); MergeFrom(from); } void RangeReq::InternalSwap(RangeReq* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.table_, &other->_impl_.table_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.from_prefix_, &other->_impl_.from_prefix_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.to_prefix_, &other->_impl_.to_prefix_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.page_token_, &other->_impl_.page_token_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.page_size_) + sizeof(RangeReq::_impl_.page_size_) - PROTOBUF_FIELD_OFFSET(RangeReq, _impl_.tx_id_)>( reinterpret_cast(&_impl_.tx_id_), reinterpret_cast(&other->_impl_.tx_id_)); } ::google::protobuf::Metadata RangeReq::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetLatestReq::_Internal { public: }; GetLatestReq::GetLatestReq(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.GetLatestReq) } inline PROTOBUF_NDEBUG_INLINE GetLatestReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::GetLatestReq& from_msg) : table_(arena, from.table_), k_(arena, from.k_), k2_(arena, from.k2_), _cached_size_{0} {} GetLatestReq::GetLatestReq( ::google::protobuf::Arena* arena, const GetLatestReq& from) : ::google::protobuf::Message(arena) { GetLatestReq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, tx_id_), offsetof(Impl_, latest_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::latest_)); // @@protoc_insertion_point(copy_constructor:remote.GetLatestReq) } inline PROTOBUF_NDEBUG_INLINE GetLatestReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : table_(arena), k_(arena), k2_(arena), _cached_size_{0} {} inline void GetLatestReq::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), 0, offsetof(Impl_, latest_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::latest_)); } GetLatestReq::~GetLatestReq() { // @@protoc_insertion_point(destructor:remote.GetLatestReq) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetLatestReq::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.table_.Destroy(); _impl_.k_.Destroy(); _impl_.k2_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetLatestReq::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_._cached_size_), false, }, &GetLatestReq::MergeImpl, &GetLatestReq::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 6, 0, 33, 2> GetLatestReq::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 6, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967232, // skipmap offsetof(decltype(_table_), field_entries), 6, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_GetLatestReq_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::GetLatestReq>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint64 tx_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(GetLatestReq, _impl_.tx_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.tx_id_)}}, // string table = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.table_)}}, // bytes k = 3; {::_pbi::TcParser::FastBS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.k_)}}, // uint64 ts = 4; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(GetLatestReq, _impl_.ts_), 63>(), {32, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.ts_)}}, // bytes k2 = 5; {::_pbi::TcParser::FastBS1, {42, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.k2_)}}, // bool latest = 6; {::_pbi::TcParser::SingularVarintNoZag1(), {48, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.latest_)}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint64 tx_id = 1; {PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.tx_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // string table = 2; {PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.table_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bytes k = 3; {PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.k_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // uint64 ts = 4; {PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.ts_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bytes k2 = 5; {PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.k2_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bool latest = 6; {PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.latest_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ "\23\0\5\0\0\0\0\0" "remote.GetLatestReq" "table" }}, }; PROTOBUF_NOINLINE void GetLatestReq::Clear() { // @@protoc_insertion_point(message_clear_start:remote.GetLatestReq) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.table_.ClearToEmpty(); _impl_.k_.ClearToEmpty(); _impl_.k2_.ClearToEmpty(); ::memset(&_impl_.tx_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.latest_) - reinterpret_cast(&_impl_.tx_id_)) + sizeof(_impl_.latest_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetLatestReq::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.GetLatestReq) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_tx_id(), target); } // string table = 2; if (!this->_internal_table().empty()) { const std::string& _s = this->_internal_table(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.GetLatestReq.table"); target = stream->WriteStringMaybeAliased(2, _s, target); } // bytes k = 3; if (!this->_internal_k().empty()) { const std::string& _s = this->_internal_k(); target = stream->WriteBytesMaybeAliased(3, _s, target); } // uint64 ts = 4; if (this->_internal_ts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 4, this->_internal_ts(), target); } // bytes k2 = 5; if (!this->_internal_k2().empty()) { const std::string& _s = this->_internal_k2(); target = stream->WriteBytesMaybeAliased(5, _s, target); } // bool latest = 6; if (this->_internal_latest() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 6, this->_internal_latest(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.GetLatestReq) return target; } ::size_t GetLatestReq::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.GetLatestReq) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string table = 2; if (!this->_internal_table().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_table()); } // bytes k = 3; if (!this->_internal_k().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_k()); } // bytes k2 = 5; if (!this->_internal_k2().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_k2()); } // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_id()); } // uint64 ts = 4; if (this->_internal_ts() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_ts()); } // bool latest = 6; if (this->_internal_latest() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetLatestReq::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.GetLatestReq) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_table().empty()) { _this->_internal_set_table(from._internal_table()); } if (!from._internal_k().empty()) { _this->_internal_set_k(from._internal_k()); } if (!from._internal_k2().empty()) { _this->_internal_set_k2(from._internal_k2()); } if (from._internal_tx_id() != 0) { _this->_impl_.tx_id_ = from._impl_.tx_id_; } if (from._internal_ts() != 0) { _this->_impl_.ts_ = from._impl_.ts_; } if (from._internal_latest() != 0) { _this->_impl_.latest_ = from._impl_.latest_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetLatestReq::CopyFrom(const GetLatestReq& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.GetLatestReq) if (&from == this) return; Clear(); MergeFrom(from); } void GetLatestReq::InternalSwap(GetLatestReq* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.table_, &other->_impl_.table_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.k_, &other->_impl_.k_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.k2_, &other->_impl_.k2_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.latest_) + sizeof(GetLatestReq::_impl_.latest_) - PROTOBUF_FIELD_OFFSET(GetLatestReq, _impl_.tx_id_)>( reinterpret_cast(&_impl_.tx_id_), reinterpret_cast(&other->_impl_.tx_id_)); } ::google::protobuf::Metadata GetLatestReq::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetLatestReply::_Internal { public: }; GetLatestReply::GetLatestReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.GetLatestReply) } inline PROTOBUF_NDEBUG_INLINE GetLatestReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::GetLatestReply& from_msg) : v_(arena, from.v_), _cached_size_{0} {} GetLatestReply::GetLatestReply( ::google::protobuf::Arena* arena, const GetLatestReply& from) : ::google::protobuf::Message(arena) { GetLatestReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.ok_ = from._impl_.ok_; // @@protoc_insertion_point(copy_constructor:remote.GetLatestReply) } inline PROTOBUF_NDEBUG_INLINE GetLatestReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : v_(arena), _cached_size_{0} {} inline void GetLatestReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.ok_ = {}; } GetLatestReply::~GetLatestReply() { // @@protoc_insertion_point(destructor:remote.GetLatestReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetLatestReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.v_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetLatestReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetLatestReply, _impl_._cached_size_), false, }, &GetLatestReply::MergeImpl, &GetLatestReply::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> GetLatestReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_GetLatestReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::GetLatestReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool ok = 2; {::_pbi::TcParser::SingularVarintNoZag1(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReply, _impl_.ok_)}}, // bytes v = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetLatestReply, _impl_.v_)}}, }}, {{ 65535, 65535 }}, {{ // bytes v = 1; {PROTOBUF_FIELD_OFFSET(GetLatestReply, _impl_.v_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bool ok = 2; {PROTOBUF_FIELD_OFFSET(GetLatestReply, _impl_.ok_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void GetLatestReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.GetLatestReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.v_.ClearToEmpty(); _impl_.ok_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetLatestReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.GetLatestReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes v = 1; if (!this->_internal_v().empty()) { const std::string& _s = this->_internal_v(); target = stream->WriteBytesMaybeAliased(1, _s, target); } // bool ok = 2; if (this->_internal_ok() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 2, this->_internal_ok(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.GetLatestReply) return target; } ::size_t GetLatestReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.GetLatestReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes v = 1; if (!this->_internal_v().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_v()); } // bool ok = 2; if (this->_internal_ok() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetLatestReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.GetLatestReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_v().empty()) { _this->_internal_set_v(from._internal_v()); } if (from._internal_ok() != 0) { _this->_impl_.ok_ = from._impl_.ok_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetLatestReply::CopyFrom(const GetLatestReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.GetLatestReply) if (&from == this) return; Clear(); MergeFrom(from); } void GetLatestReply::InternalSwap(GetLatestReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.v_, &other->_impl_.v_, arena); swap(_impl_.ok_, other->_impl_.ok_); } ::google::protobuf::Metadata GetLatestReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HistorySeekReq::_Internal { public: }; HistorySeekReq::HistorySeekReq(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.HistorySeekReq) } inline PROTOBUF_NDEBUG_INLINE HistorySeekReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::HistorySeekReq& from_msg) : table_(arena, from.table_), k_(arena, from.k_), _cached_size_{0} {} HistorySeekReq::HistorySeekReq( ::google::protobuf::Arena* arena, const HistorySeekReq& from) : ::google::protobuf::Message(arena) { HistorySeekReq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, tx_id_), offsetof(Impl_, ts_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::ts_)); // @@protoc_insertion_point(copy_constructor:remote.HistorySeekReq) } inline PROTOBUF_NDEBUG_INLINE HistorySeekReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : table_(arena), k_(arena), _cached_size_{0} {} inline void HistorySeekReq::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), 0, offsetof(Impl_, ts_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::ts_)); } HistorySeekReq::~HistorySeekReq() { // @@protoc_insertion_point(destructor:remote.HistorySeekReq) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HistorySeekReq::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.table_.Destroy(); _impl_.k_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HistorySeekReq::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_._cached_size_), false, }, &HistorySeekReq::MergeImpl, &HistorySeekReq::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 4, 0, 35, 2> HistorySeekReq::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 4, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967280, // skipmap offsetof(decltype(_table_), field_entries), 4, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HistorySeekReq_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::HistorySeekReq>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 ts = 4; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(HistorySeekReq, _impl_.ts_), 63>(), {32, 63, 0, PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.ts_)}}, // uint64 tx_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(HistorySeekReq, _impl_.tx_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.tx_id_)}}, // string table = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.table_)}}, // bytes k = 3; {::_pbi::TcParser::FastBS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.k_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 tx_id = 1; {PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.tx_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // string table = 2; {PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.table_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bytes k = 3; {PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.k_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // uint64 ts = 4; {PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.ts_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ "\25\0\5\0\0\0\0\0" "remote.HistorySeekReq" "table" }}, }; PROTOBUF_NOINLINE void HistorySeekReq::Clear() { // @@protoc_insertion_point(message_clear_start:remote.HistorySeekReq) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.table_.ClearToEmpty(); _impl_.k_.ClearToEmpty(); ::memset(&_impl_.tx_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.ts_) - reinterpret_cast(&_impl_.tx_id_)) + sizeof(_impl_.ts_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HistorySeekReq::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.HistorySeekReq) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_tx_id(), target); } // string table = 2; if (!this->_internal_table().empty()) { const std::string& _s = this->_internal_table(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.HistorySeekReq.table"); target = stream->WriteStringMaybeAliased(2, _s, target); } // bytes k = 3; if (!this->_internal_k().empty()) { const std::string& _s = this->_internal_k(); target = stream->WriteBytesMaybeAliased(3, _s, target); } // uint64 ts = 4; if (this->_internal_ts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 4, this->_internal_ts(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.HistorySeekReq) return target; } ::size_t HistorySeekReq::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.HistorySeekReq) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string table = 2; if (!this->_internal_table().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_table()); } // bytes k = 3; if (!this->_internal_k().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_k()); } // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_id()); } // uint64 ts = 4; if (this->_internal_ts() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_ts()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HistorySeekReq::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.HistorySeekReq) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_table().empty()) { _this->_internal_set_table(from._internal_table()); } if (!from._internal_k().empty()) { _this->_internal_set_k(from._internal_k()); } if (from._internal_tx_id() != 0) { _this->_impl_.tx_id_ = from._impl_.tx_id_; } if (from._internal_ts() != 0) { _this->_impl_.ts_ = from._impl_.ts_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HistorySeekReq::CopyFrom(const HistorySeekReq& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.HistorySeekReq) if (&from == this) return; Clear(); MergeFrom(from); } void HistorySeekReq::InternalSwap(HistorySeekReq* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.table_, &other->_impl_.table_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.k_, &other->_impl_.k_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.ts_) + sizeof(HistorySeekReq::_impl_.ts_) - PROTOBUF_FIELD_OFFSET(HistorySeekReq, _impl_.tx_id_)>( reinterpret_cast(&_impl_.tx_id_), reinterpret_cast(&other->_impl_.tx_id_)); } ::google::protobuf::Metadata HistorySeekReq::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HistorySeekReply::_Internal { public: }; HistorySeekReply::HistorySeekReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.HistorySeekReply) } inline PROTOBUF_NDEBUG_INLINE HistorySeekReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::HistorySeekReply& from_msg) : v_(arena, from.v_), _cached_size_{0} {} HistorySeekReply::HistorySeekReply( ::google::protobuf::Arena* arena, const HistorySeekReply& from) : ::google::protobuf::Message(arena) { HistorySeekReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.ok_ = from._impl_.ok_; // @@protoc_insertion_point(copy_constructor:remote.HistorySeekReply) } inline PROTOBUF_NDEBUG_INLINE HistorySeekReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : v_(arena), _cached_size_{0} {} inline void HistorySeekReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.ok_ = {}; } HistorySeekReply::~HistorySeekReply() { // @@protoc_insertion_point(destructor:remote.HistorySeekReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HistorySeekReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.v_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HistorySeekReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HistorySeekReply, _impl_._cached_size_), false, }, &HistorySeekReply::MergeImpl, &HistorySeekReply::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> HistorySeekReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HistorySeekReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::HistorySeekReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool ok = 2; {::_pbi::TcParser::SingularVarintNoZag1(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(HistorySeekReply, _impl_.ok_)}}, // bytes v = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(HistorySeekReply, _impl_.v_)}}, }}, {{ 65535, 65535 }}, {{ // bytes v = 1; {PROTOBUF_FIELD_OFFSET(HistorySeekReply, _impl_.v_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bool ok = 2; {PROTOBUF_FIELD_OFFSET(HistorySeekReply, _impl_.ok_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void HistorySeekReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.HistorySeekReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.v_.ClearToEmpty(); _impl_.ok_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HistorySeekReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.HistorySeekReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes v = 1; if (!this->_internal_v().empty()) { const std::string& _s = this->_internal_v(); target = stream->WriteBytesMaybeAliased(1, _s, target); } // bool ok = 2; if (this->_internal_ok() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 2, this->_internal_ok(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.HistorySeekReply) return target; } ::size_t HistorySeekReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.HistorySeekReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes v = 1; if (!this->_internal_v().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_v()); } // bool ok = 2; if (this->_internal_ok() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HistorySeekReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.HistorySeekReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_v().empty()) { _this->_internal_set_v(from._internal_v()); } if (from._internal_ok() != 0) { _this->_impl_.ok_ = from._impl_.ok_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HistorySeekReply::CopyFrom(const HistorySeekReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.HistorySeekReply) if (&from == this) return; Clear(); MergeFrom(from); } void HistorySeekReply::InternalSwap(HistorySeekReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.v_, &other->_impl_.v_, arena); swap(_impl_.ok_, other->_impl_.ok_); } ::google::protobuf::Metadata HistorySeekReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class IndexRangeReq::_Internal { public: }; IndexRangeReq::IndexRangeReq(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.IndexRangeReq) } inline PROTOBUF_NDEBUG_INLINE IndexRangeReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::IndexRangeReq& from_msg) : table_(arena, from.table_), k_(arena, from.k_), page_token_(arena, from.page_token_), _cached_size_{0} {} IndexRangeReq::IndexRangeReq( ::google::protobuf::Arena* arena, const IndexRangeReq& from) : ::google::protobuf::Message(arena) { IndexRangeReq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, tx_id_), offsetof(Impl_, page_size_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::page_size_)); // @@protoc_insertion_point(copy_constructor:remote.IndexRangeReq) } inline PROTOBUF_NDEBUG_INLINE IndexRangeReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : table_(arena), k_(arena), page_token_(arena), _cached_size_{0} {} inline void IndexRangeReq::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), 0, offsetof(Impl_, page_size_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::page_size_)); } IndexRangeReq::~IndexRangeReq() { // @@protoc_insertion_point(destructor:remote.IndexRangeReq) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void IndexRangeReq::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.table_.Destroy(); _impl_.k_.Destroy(); _impl_.page_token_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* IndexRangeReq::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_._cached_size_), false, }, &IndexRangeReq::MergeImpl, &IndexRangeReq::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<4, 9, 0, 52, 2> IndexRangeReq::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 9, 120, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294966784, // skipmap offsetof(decltype(_table_), field_entries), 9, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_IndexRangeReq_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::IndexRangeReq>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint64 tx_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IndexRangeReq, _impl_.tx_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.tx_id_)}}, // string table = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.table_)}}, // bytes k = 3; {::_pbi::TcParser::FastBS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.k_)}}, // sint64 from_ts = 4; {::_pbi::TcParser::FastZ64S1, {32, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.from_ts_)}}, // sint64 to_ts = 5; {::_pbi::TcParser::FastZ64S1, {40, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.to_ts_)}}, // bool order_ascend = 6; {::_pbi::TcParser::SingularVarintNoZag1(), {48, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.order_ascend_)}}, // sint64 limit = 7; {::_pbi::TcParser::FastZ64S1, {56, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.limit_)}}, // int32 page_size = 8; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(IndexRangeReq, _impl_.page_size_), 63>(), {64, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.page_size_)}}, // string page_token = 9; {::_pbi::TcParser::FastUS1, {74, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.page_token_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint64 tx_id = 1; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.tx_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // string table = 2; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.table_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bytes k = 3; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.k_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // sint64 from_ts = 4; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.from_ts_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // sint64 to_ts = 5; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.to_ts_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // bool order_ascend = 6; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.order_ascend_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // sint64 limit = 7; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // int32 page_size = 8; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.page_size_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, // string page_token = 9; {PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.page_token_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\24\0\5\0\0\0\0\0\0\12\0\0\0\0\0\0" "remote.IndexRangeReq" "table" "page_token" }}, }; PROTOBUF_NOINLINE void IndexRangeReq::Clear() { // @@protoc_insertion_point(message_clear_start:remote.IndexRangeReq) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.table_.ClearToEmpty(); _impl_.k_.ClearToEmpty(); _impl_.page_token_.ClearToEmpty(); ::memset(&_impl_.tx_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.page_size_) - reinterpret_cast(&_impl_.tx_id_)) + sizeof(_impl_.page_size_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* IndexRangeReq::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.IndexRangeReq) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_tx_id(), target); } // string table = 2; if (!this->_internal_table().empty()) { const std::string& _s = this->_internal_table(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.IndexRangeReq.table"); target = stream->WriteStringMaybeAliased(2, _s, target); } // bytes k = 3; if (!this->_internal_k().empty()) { const std::string& _s = this->_internal_k(); target = stream->WriteBytesMaybeAliased(3, _s, target); } // sint64 from_ts = 4; if (this->_internal_from_ts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 4, this->_internal_from_ts(), target); } // sint64 to_ts = 5; if (this->_internal_to_ts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 5, this->_internal_to_ts(), target); } // bool order_ascend = 6; if (this->_internal_order_ascend() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 6, this->_internal_order_ascend(), target); } // sint64 limit = 7; if (this->_internal_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 7, this->_internal_limit(), target); } // int32 page_size = 8; if (this->_internal_page_size() != 0) { target = ::google::protobuf::internal::WireFormatLite:: WriteInt32ToArrayWithField<8>( stream, this->_internal_page_size(), target); } // string page_token = 9; if (!this->_internal_page_token().empty()) { const std::string& _s = this->_internal_page_token(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.IndexRangeReq.page_token"); target = stream->WriteStringMaybeAliased(9, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.IndexRangeReq) return target; } ::size_t IndexRangeReq::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.IndexRangeReq) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string table = 2; if (!this->_internal_table().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_table()); } // bytes k = 3; if (!this->_internal_k().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_k()); } // string page_token = 9; if (!this->_internal_page_token().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_page_token()); } // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_id()); } // sint64 from_ts = 4; if (this->_internal_from_ts() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_from_ts()); } // sint64 to_ts = 5; if (this->_internal_to_ts() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_to_ts()); } // sint64 limit = 7; if (this->_internal_limit() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_limit()); } // bool order_ascend = 6; if (this->_internal_order_ascend() != 0) { total_size += 2; } // int32 page_size = 8; if (this->_internal_page_size() != 0) { total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( this->_internal_page_size()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void IndexRangeReq::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.IndexRangeReq) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_table().empty()) { _this->_internal_set_table(from._internal_table()); } if (!from._internal_k().empty()) { _this->_internal_set_k(from._internal_k()); } if (!from._internal_page_token().empty()) { _this->_internal_set_page_token(from._internal_page_token()); } if (from._internal_tx_id() != 0) { _this->_impl_.tx_id_ = from._impl_.tx_id_; } if (from._internal_from_ts() != 0) { _this->_impl_.from_ts_ = from._impl_.from_ts_; } if (from._internal_to_ts() != 0) { _this->_impl_.to_ts_ = from._impl_.to_ts_; } if (from._internal_limit() != 0) { _this->_impl_.limit_ = from._impl_.limit_; } if (from._internal_order_ascend() != 0) { _this->_impl_.order_ascend_ = from._impl_.order_ascend_; } if (from._internal_page_size() != 0) { _this->_impl_.page_size_ = from._impl_.page_size_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void IndexRangeReq::CopyFrom(const IndexRangeReq& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.IndexRangeReq) if (&from == this) return; Clear(); MergeFrom(from); } void IndexRangeReq::InternalSwap(IndexRangeReq* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.table_, &other->_impl_.table_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.k_, &other->_impl_.k_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.page_token_, &other->_impl_.page_token_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.page_size_) + sizeof(IndexRangeReq::_impl_.page_size_) - PROTOBUF_FIELD_OFFSET(IndexRangeReq, _impl_.tx_id_)>( reinterpret_cast(&_impl_.tx_id_), reinterpret_cast(&other->_impl_.tx_id_)); } ::google::protobuf::Metadata IndexRangeReq::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class IndexRangeReply::_Internal { public: }; IndexRangeReply::IndexRangeReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.IndexRangeReply) } inline PROTOBUF_NDEBUG_INLINE IndexRangeReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::IndexRangeReply& from_msg) : timestamps_{visibility, arena, from.timestamps_}, _timestamps_cached_byte_size_{0}, next_page_token_(arena, from.next_page_token_), _cached_size_{0} {} IndexRangeReply::IndexRangeReply( ::google::protobuf::Arena* arena, const IndexRangeReply& from) : ::google::protobuf::Message(arena) { IndexRangeReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.IndexRangeReply) } inline PROTOBUF_NDEBUG_INLINE IndexRangeReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : timestamps_{visibility, arena}, _timestamps_cached_byte_size_{0}, next_page_token_(arena), _cached_size_{0} {} inline void IndexRangeReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } IndexRangeReply::~IndexRangeReply() { // @@protoc_insertion_point(destructor:remote.IndexRangeReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void IndexRangeReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.next_page_token_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* IndexRangeReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(IndexRangeReply, _impl_._cached_size_), false, }, &IndexRangeReply::MergeImpl, &IndexRangeReply::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 46, 2> IndexRangeReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_IndexRangeReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::IndexRangeReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // string next_page_token = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReply, _impl_.next_page_token_)}}, // repeated uint64 timestamps = 1; {::_pbi::TcParser::FastV64P1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(IndexRangeReply, _impl_.timestamps_)}}, }}, {{ 65535, 65535 }}, {{ // repeated uint64 timestamps = 1; {PROTOBUF_FIELD_OFFSET(IndexRangeReply, _impl_.timestamps_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt64)}, // string next_page_token = 2; {PROTOBUF_FIELD_OFFSET(IndexRangeReply, _impl_.next_page_token_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\26\0\17\0\0\0\0\0" "remote.IndexRangeReply" "next_page_token" }}, }; PROTOBUF_NOINLINE void IndexRangeReply::Clear() { // @@protoc_insertion_point(message_clear_start:remote.IndexRangeReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.timestamps_.Clear(); _impl_.next_page_token_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* IndexRangeReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.IndexRangeReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated uint64 timestamps = 1; { int byte_size = _impl_._timestamps_cached_byte_size_.Get(); if (byte_size > 0) { target = stream->WriteUInt64Packed( 1, _internal_timestamps(), byte_size, target); } } // string next_page_token = 2; if (!this->_internal_next_page_token().empty()) { const std::string& _s = this->_internal_next_page_token(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.IndexRangeReply.next_page_token"); target = stream->WriteStringMaybeAliased(2, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.IndexRangeReply) return target; } ::size_t IndexRangeReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.IndexRangeReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated uint64 timestamps = 1; { std::size_t data_size = ::_pbi::WireFormatLite::UInt64Size( this->_internal_timestamps()) ; _impl_._timestamps_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size)); std::size_t tag_size = data_size == 0 ? 0 : 1 + ::_pbi::WireFormatLite::Int32Size( static_cast(data_size)) ; total_size += tag_size + data_size; } // string next_page_token = 2; if (!this->_internal_next_page_token().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_next_page_token()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void IndexRangeReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.IndexRangeReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_timestamps()->MergeFrom(from._internal_timestamps()); if (!from._internal_next_page_token().empty()) { _this->_internal_set_next_page_token(from._internal_next_page_token()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void IndexRangeReply::CopyFrom(const IndexRangeReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.IndexRangeReply) if (&from == this) return; Clear(); MergeFrom(from); } void IndexRangeReply::InternalSwap(IndexRangeReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.timestamps_.InternalSwap(&other->_impl_.timestamps_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.next_page_token_, &other->_impl_.next_page_token_, arena); } ::google::protobuf::Metadata IndexRangeReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HistoryRangeReq::_Internal { public: }; HistoryRangeReq::HistoryRangeReq(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.HistoryRangeReq) } inline PROTOBUF_NDEBUG_INLINE HistoryRangeReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::HistoryRangeReq& from_msg) : table_(arena, from.table_), page_token_(arena, from.page_token_), _cached_size_{0} {} HistoryRangeReq::HistoryRangeReq( ::google::protobuf::Arena* arena, const HistoryRangeReq& from) : ::google::protobuf::Message(arena) { HistoryRangeReq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, tx_id_), offsetof(Impl_, page_size_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::page_size_)); // @@protoc_insertion_point(copy_constructor:remote.HistoryRangeReq) } inline PROTOBUF_NDEBUG_INLINE HistoryRangeReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : table_(arena), page_token_(arena), _cached_size_{0} {} inline void HistoryRangeReq::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), 0, offsetof(Impl_, page_size_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::page_size_)); } HistoryRangeReq::~HistoryRangeReq() { // @@protoc_insertion_point(destructor:remote.HistoryRangeReq) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HistoryRangeReq::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.table_.Destroy(); _impl_.page_token_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HistoryRangeReq::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_._cached_size_), false, }, &HistoryRangeReq::MergeImpl, &HistoryRangeReq::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<4, 8, 0, 54, 2> HistoryRangeReq::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 9, 120, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294966788, // skipmap offsetof(decltype(_table_), field_entries), 8, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HistoryRangeReq_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::HistoryRangeReq>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint64 tx_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(HistoryRangeReq, _impl_.tx_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.tx_id_)}}, // string table = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.table_)}}, {::_pbi::TcParser::MiniParse, {}}, // sint64 from_ts = 4; {::_pbi::TcParser::FastZ64S1, {32, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.from_ts_)}}, // sint64 to_ts = 5; {::_pbi::TcParser::FastZ64S1, {40, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.to_ts_)}}, // bool order_ascend = 6; {::_pbi::TcParser::SingularVarintNoZag1(), {48, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.order_ascend_)}}, // sint64 limit = 7; {::_pbi::TcParser::FastZ64S1, {56, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.limit_)}}, // int32 page_size = 8; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(HistoryRangeReq, _impl_.page_size_), 63>(), {64, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.page_size_)}}, // string page_token = 9; {::_pbi::TcParser::FastUS1, {74, 63, 0, PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.page_token_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint64 tx_id = 1; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.tx_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // string table = 2; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.table_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // sint64 from_ts = 4; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.from_ts_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // sint64 to_ts = 5; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.to_ts_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // bool order_ascend = 6; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.order_ascend_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // sint64 limit = 7; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // int32 page_size = 8; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.page_size_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, // string page_token = 9; {PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.page_token_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\26\0\5\0\0\0\0\0\12\0\0\0\0\0\0\0" "remote.HistoryRangeReq" "table" "page_token" }}, }; PROTOBUF_NOINLINE void HistoryRangeReq::Clear() { // @@protoc_insertion_point(message_clear_start:remote.HistoryRangeReq) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.table_.ClearToEmpty(); _impl_.page_token_.ClearToEmpty(); ::memset(&_impl_.tx_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.page_size_) - reinterpret_cast(&_impl_.tx_id_)) + sizeof(_impl_.page_size_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HistoryRangeReq::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.HistoryRangeReq) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_tx_id(), target); } // string table = 2; if (!this->_internal_table().empty()) { const std::string& _s = this->_internal_table(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.HistoryRangeReq.table"); target = stream->WriteStringMaybeAliased(2, _s, target); } // sint64 from_ts = 4; if (this->_internal_from_ts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 4, this->_internal_from_ts(), target); } // sint64 to_ts = 5; if (this->_internal_to_ts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 5, this->_internal_to_ts(), target); } // bool order_ascend = 6; if (this->_internal_order_ascend() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 6, this->_internal_order_ascend(), target); } // sint64 limit = 7; if (this->_internal_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 7, this->_internal_limit(), target); } // int32 page_size = 8; if (this->_internal_page_size() != 0) { target = ::google::protobuf::internal::WireFormatLite:: WriteInt32ToArrayWithField<8>( stream, this->_internal_page_size(), target); } // string page_token = 9; if (!this->_internal_page_token().empty()) { const std::string& _s = this->_internal_page_token(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.HistoryRangeReq.page_token"); target = stream->WriteStringMaybeAliased(9, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.HistoryRangeReq) return target; } ::size_t HistoryRangeReq::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.HistoryRangeReq) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string table = 2; if (!this->_internal_table().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_table()); } // string page_token = 9; if (!this->_internal_page_token().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_page_token()); } // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_id()); } // sint64 from_ts = 4; if (this->_internal_from_ts() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_from_ts()); } // sint64 to_ts = 5; if (this->_internal_to_ts() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_to_ts()); } // sint64 limit = 7; if (this->_internal_limit() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_limit()); } // bool order_ascend = 6; if (this->_internal_order_ascend() != 0) { total_size += 2; } // int32 page_size = 8; if (this->_internal_page_size() != 0) { total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( this->_internal_page_size()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HistoryRangeReq::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.HistoryRangeReq) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_table().empty()) { _this->_internal_set_table(from._internal_table()); } if (!from._internal_page_token().empty()) { _this->_internal_set_page_token(from._internal_page_token()); } if (from._internal_tx_id() != 0) { _this->_impl_.tx_id_ = from._impl_.tx_id_; } if (from._internal_from_ts() != 0) { _this->_impl_.from_ts_ = from._impl_.from_ts_; } if (from._internal_to_ts() != 0) { _this->_impl_.to_ts_ = from._impl_.to_ts_; } if (from._internal_limit() != 0) { _this->_impl_.limit_ = from._impl_.limit_; } if (from._internal_order_ascend() != 0) { _this->_impl_.order_ascend_ = from._impl_.order_ascend_; } if (from._internal_page_size() != 0) { _this->_impl_.page_size_ = from._impl_.page_size_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HistoryRangeReq::CopyFrom(const HistoryRangeReq& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.HistoryRangeReq) if (&from == this) return; Clear(); MergeFrom(from); } void HistoryRangeReq::InternalSwap(HistoryRangeReq* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.table_, &other->_impl_.table_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.page_token_, &other->_impl_.page_token_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.page_size_) + sizeof(HistoryRangeReq::_impl_.page_size_) - PROTOBUF_FIELD_OFFSET(HistoryRangeReq, _impl_.tx_id_)>( reinterpret_cast(&_impl_.tx_id_), reinterpret_cast(&other->_impl_.tx_id_)); } ::google::protobuf::Metadata HistoryRangeReq::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RangeAsOfReq::_Internal { public: }; RangeAsOfReq::RangeAsOfReq(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.RangeAsOfReq) } inline PROTOBUF_NDEBUG_INLINE RangeAsOfReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::RangeAsOfReq& from_msg) : table_(arena, from.table_), from_key_(arena, from.from_key_), to_key_(arena, from.to_key_), page_token_(arena, from.page_token_), _cached_size_{0} {} RangeAsOfReq::RangeAsOfReq( ::google::protobuf::Arena* arena, const RangeAsOfReq& from) : ::google::protobuf::Message(arena) { RangeAsOfReq* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, tx_id_), offsetof(Impl_, limit_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::limit_)); // @@protoc_insertion_point(copy_constructor:remote.RangeAsOfReq) } inline PROTOBUF_NDEBUG_INLINE RangeAsOfReq::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : table_(arena), from_key_(arena), to_key_(arena), page_token_(arena), _cached_size_{0} {} inline void RangeAsOfReq::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, tx_id_), 0, offsetof(Impl_, limit_) - offsetof(Impl_, tx_id_) + sizeof(Impl_::limit_)); } RangeAsOfReq::~RangeAsOfReq() { // @@protoc_insertion_point(destructor:remote.RangeAsOfReq) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void RangeAsOfReq::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.table_.Destroy(); _impl_.from_key_.Destroy(); _impl_.to_key_.Destroy(); _impl_.page_token_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* RangeAsOfReq::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_._cached_size_), false, }, &RangeAsOfReq::MergeImpl, &RangeAsOfReq::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<4, 10, 0, 51, 2> RangeAsOfReq::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 10, 120, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294966272, // skipmap offsetof(decltype(_table_), field_entries), 10, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_RangeAsOfReq_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::RangeAsOfReq>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint64 tx_id = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RangeAsOfReq, _impl_.tx_id_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.tx_id_)}}, // string table = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.table_)}}, // bytes from_key = 3; {::_pbi::TcParser::FastBS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.from_key_)}}, // bytes to_key = 4; {::_pbi::TcParser::FastBS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.to_key_)}}, // uint64 ts = 5; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(RangeAsOfReq, _impl_.ts_), 63>(), {40, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.ts_)}}, // bool latest = 6; {::_pbi::TcParser::SingularVarintNoZag1(), {48, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.latest_)}}, // bool order_ascend = 7; {::_pbi::TcParser::SingularVarintNoZag1(), {56, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.order_ascend_)}}, // sint64 limit = 8; {::_pbi::TcParser::FastZ64S1, {64, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.limit_)}}, // int32 page_size = 9; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RangeAsOfReq, _impl_.page_size_), 63>(), {72, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.page_size_)}}, // string page_token = 10; {::_pbi::TcParser::FastUS1, {82, 63, 0, PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.page_token_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint64 tx_id = 1; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.tx_id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // string table = 2; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.table_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bytes from_key = 3; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.from_key_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes to_key = 4; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.to_key_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // uint64 ts = 5; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.ts_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bool latest = 6; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.latest_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // bool order_ascend = 7; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.order_ascend_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // sint64 limit = 8; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // int32 page_size = 9; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.page_size_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kInt32)}, // string page_token = 10; {PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.page_token_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\23\0\5\0\0\0\0\0\0\0\12\0\0\0\0\0" "remote.RangeAsOfReq" "table" "page_token" }}, }; PROTOBUF_NOINLINE void RangeAsOfReq::Clear() { // @@protoc_insertion_point(message_clear_start:remote.RangeAsOfReq) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.table_.ClearToEmpty(); _impl_.from_key_.ClearToEmpty(); _impl_.to_key_.ClearToEmpty(); _impl_.page_token_.ClearToEmpty(); ::memset(&_impl_.tx_id_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.limit_) - reinterpret_cast(&_impl_.tx_id_)) + sizeof(_impl_.limit_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* RangeAsOfReq::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.RangeAsOfReq) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_tx_id(), target); } // string table = 2; if (!this->_internal_table().empty()) { const std::string& _s = this->_internal_table(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.RangeAsOfReq.table"); target = stream->WriteStringMaybeAliased(2, _s, target); } // bytes from_key = 3; if (!this->_internal_from_key().empty()) { const std::string& _s = this->_internal_from_key(); target = stream->WriteBytesMaybeAliased(3, _s, target); } // bytes to_key = 4; if (!this->_internal_to_key().empty()) { const std::string& _s = this->_internal_to_key(); target = stream->WriteBytesMaybeAliased(4, _s, target); } // uint64 ts = 5; if (this->_internal_ts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 5, this->_internal_ts(), target); } // bool latest = 6; if (this->_internal_latest() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 6, this->_internal_latest(), target); } // bool order_ascend = 7; if (this->_internal_order_ascend() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 7, this->_internal_order_ascend(), target); } // sint64 limit = 8; if (this->_internal_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 8, this->_internal_limit(), target); } // int32 page_size = 9; if (this->_internal_page_size() != 0) { target = ::google::protobuf::internal::WireFormatLite:: WriteInt32ToArrayWithField<9>( stream, this->_internal_page_size(), target); } // string page_token = 10; if (!this->_internal_page_token().empty()) { const std::string& _s = this->_internal_page_token(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.RangeAsOfReq.page_token"); target = stream->WriteStringMaybeAliased(10, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.RangeAsOfReq) return target; } ::size_t RangeAsOfReq::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.RangeAsOfReq) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string table = 2; if (!this->_internal_table().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_table()); } // bytes from_key = 3; if (!this->_internal_from_key().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_from_key()); } // bytes to_key = 4; if (!this->_internal_to_key().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_to_key()); } // string page_token = 10; if (!this->_internal_page_token().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_page_token()); } // uint64 tx_id = 1; if (this->_internal_tx_id() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_tx_id()); } // uint64 ts = 5; if (this->_internal_ts() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_ts()); } // bool latest = 6; if (this->_internal_latest() != 0) { total_size += 2; } // bool order_ascend = 7; if (this->_internal_order_ascend() != 0) { total_size += 2; } // int32 page_size = 9; if (this->_internal_page_size() != 0) { total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( this->_internal_page_size()); } // sint64 limit = 8; if (this->_internal_limit() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_limit()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void RangeAsOfReq::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.RangeAsOfReq) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_table().empty()) { _this->_internal_set_table(from._internal_table()); } if (!from._internal_from_key().empty()) { _this->_internal_set_from_key(from._internal_from_key()); } if (!from._internal_to_key().empty()) { _this->_internal_set_to_key(from._internal_to_key()); } if (!from._internal_page_token().empty()) { _this->_internal_set_page_token(from._internal_page_token()); } if (from._internal_tx_id() != 0) { _this->_impl_.tx_id_ = from._impl_.tx_id_; } if (from._internal_ts() != 0) { _this->_impl_.ts_ = from._impl_.ts_; } if (from._internal_latest() != 0) { _this->_impl_.latest_ = from._impl_.latest_; } if (from._internal_order_ascend() != 0) { _this->_impl_.order_ascend_ = from._impl_.order_ascend_; } if (from._internal_page_size() != 0) { _this->_impl_.page_size_ = from._impl_.page_size_; } if (from._internal_limit() != 0) { _this->_impl_.limit_ = from._impl_.limit_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void RangeAsOfReq::CopyFrom(const RangeAsOfReq& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.RangeAsOfReq) if (&from == this) return; Clear(); MergeFrom(from); } void RangeAsOfReq::InternalSwap(RangeAsOfReq* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.table_, &other->_impl_.table_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.from_key_, &other->_impl_.from_key_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.to_key_, &other->_impl_.to_key_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.page_token_, &other->_impl_.page_token_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.limit_) + sizeof(RangeAsOfReq::_impl_.limit_) - PROTOBUF_FIELD_OFFSET(RangeAsOfReq, _impl_.tx_id_)>( reinterpret_cast(&_impl_.tx_id_), reinterpret_cast(&other->_impl_.tx_id_)); } ::google::protobuf::Metadata RangeAsOfReq::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Pairs::_Internal { public: }; Pairs::Pairs(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.Pairs) } inline PROTOBUF_NDEBUG_INLINE Pairs::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::Pairs& from_msg) : keys_{visibility, arena, from.keys_}, values_{visibility, arena, from.values_}, next_page_token_(arena, from.next_page_token_), _cached_size_{0} {} Pairs::Pairs( ::google::protobuf::Arena* arena, const Pairs& from) : ::google::protobuf::Message(arena) { Pairs* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:remote.Pairs) } inline PROTOBUF_NDEBUG_INLINE Pairs::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : keys_{visibility, arena}, values_{visibility, arena}, next_page_token_(arena), _cached_size_{0} {} inline void Pairs::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } Pairs::~Pairs() { // @@protoc_insertion_point(destructor:remote.Pairs) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Pairs::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.next_page_token_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Pairs::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Pairs, _impl_._cached_size_), false, }, &Pairs::MergeImpl, &Pairs::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 0, 36, 2> Pairs::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_Pairs_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::Pairs>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // repeated bytes keys = 1; {::_pbi::TcParser::FastBR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(Pairs, _impl_.keys_)}}, // repeated bytes values = 2; {::_pbi::TcParser::FastBR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(Pairs, _impl_.values_)}}, // string next_page_token = 3; {::_pbi::TcParser::FastUS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(Pairs, _impl_.next_page_token_)}}, }}, {{ 65535, 65535 }}, {{ // repeated bytes keys = 1; {PROTOBUF_FIELD_OFFSET(Pairs, _impl_.keys_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, // repeated bytes values = 2; {PROTOBUF_FIELD_OFFSET(Pairs, _impl_.values_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, // string next_page_token = 3; {PROTOBUF_FIELD_OFFSET(Pairs, _impl_.next_page_token_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\14\0\0\17\0\0\0\0" "remote.Pairs" "next_page_token" }}, }; PROTOBUF_NOINLINE void Pairs::Clear() { // @@protoc_insertion_point(message_clear_start:remote.Pairs) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.keys_.Clear(); _impl_.values_.Clear(); _impl_.next_page_token_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Pairs::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.Pairs) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated bytes keys = 1; for (int i = 0, n = this->_internal_keys_size(); i < n; ++i) { const auto& s = this->_internal_keys().Get(i); target = stream->WriteBytes(1, s, target); } // repeated bytes values = 2; for (int i = 0, n = this->_internal_values_size(); i < n; ++i) { const auto& s = this->_internal_values().Get(i); target = stream->WriteBytes(2, s, target); } // string next_page_token = 3; if (!this->_internal_next_page_token().empty()) { const std::string& _s = this->_internal_next_page_token(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "remote.Pairs.next_page_token"); target = stream->WriteStringMaybeAliased(3, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.Pairs) return target; } ::size_t Pairs::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.Pairs) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes keys = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_keys().size()); for (int i = 0, n = _internal_keys().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_keys().Get(i)); } // repeated bytes values = 2; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_values().size()); for (int i = 0, n = _internal_values().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_values().Get(i)); } // string next_page_token = 3; if (!this->_internal_next_page_token().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_next_page_token()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Pairs::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.Pairs) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_keys()->MergeFrom(from._internal_keys()); _this->_internal_mutable_values()->MergeFrom(from._internal_values()); if (!from._internal_next_page_token().empty()) { _this->_internal_set_next_page_token(from._internal_next_page_token()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Pairs::CopyFrom(const Pairs& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.Pairs) if (&from == this) return; Clear(); MergeFrom(from); } void Pairs::InternalSwap(Pairs* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.keys_.InternalSwap(&other->_impl_.keys_); _impl_.values_.InternalSwap(&other->_impl_.values_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.next_page_token_, &other->_impl_.next_page_token_, arena); } ::google::protobuf::Metadata Pairs::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PairsPagination::_Internal { public: }; PairsPagination::PairsPagination(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.PairsPagination) } inline PROTOBUF_NDEBUG_INLINE PairsPagination::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::remote::PairsPagination& from_msg) : next_key_(arena, from.next_key_), _cached_size_{0} {} PairsPagination::PairsPagination( ::google::protobuf::Arena* arena, const PairsPagination& from) : ::google::protobuf::Message(arena) { PairsPagination* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.limit_ = from._impl_.limit_; // @@protoc_insertion_point(copy_constructor:remote.PairsPagination) } inline PROTOBUF_NDEBUG_INLINE PairsPagination::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : next_key_(arena), _cached_size_{0} {} inline void PairsPagination::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.limit_ = {}; } PairsPagination::~PairsPagination() { // @@protoc_insertion_point(destructor:remote.PairsPagination) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PairsPagination::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.next_key_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PairsPagination::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PairsPagination, _impl_._cached_size_), false, }, &PairsPagination::MergeImpl, &PairsPagination::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> PairsPagination::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_PairsPagination_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::PairsPagination>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // sint64 limit = 2; {::_pbi::TcParser::FastZ64S1, {16, 63, 0, PROTOBUF_FIELD_OFFSET(PairsPagination, _impl_.limit_)}}, // bytes next_key = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(PairsPagination, _impl_.next_key_)}}, }}, {{ 65535, 65535 }}, {{ // bytes next_key = 1; {PROTOBUF_FIELD_OFFSET(PairsPagination, _impl_.next_key_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // sint64 limit = 2; {PROTOBUF_FIELD_OFFSET(PairsPagination, _impl_.limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void PairsPagination::Clear() { // @@protoc_insertion_point(message_clear_start:remote.PairsPagination) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.next_key_.ClearToEmpty(); _impl_.limit_ = ::int64_t{0}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PairsPagination::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.PairsPagination) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes next_key = 1; if (!this->_internal_next_key().empty()) { const std::string& _s = this->_internal_next_key(); target = stream->WriteBytesMaybeAliased(1, _s, target); } // sint64 limit = 2; if (this->_internal_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 2, this->_internal_limit(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.PairsPagination) return target; } ::size_t PairsPagination::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.PairsPagination) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes next_key = 1; if (!this->_internal_next_key().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_next_key()); } // sint64 limit = 2; if (this->_internal_limit() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_limit()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PairsPagination::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.PairsPagination) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_next_key().empty()) { _this->_internal_set_next_key(from._internal_next_key()); } if (from._internal_limit() != 0) { _this->_impl_.limit_ = from._impl_.limit_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PairsPagination::CopyFrom(const PairsPagination& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.PairsPagination) if (&from == this) return; Clear(); MergeFrom(from); } void PairsPagination::InternalSwap(PairsPagination* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.next_key_, &other->_impl_.next_key_, arena); swap(_impl_.limit_, other->_impl_.limit_); } ::google::protobuf::Metadata PairsPagination::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class IndexPagination::_Internal { public: }; IndexPagination::IndexPagination(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:remote.IndexPagination) } IndexPagination::IndexPagination( ::google::protobuf::Arena* arena, const IndexPagination& from) : IndexPagination(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE IndexPagination::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void IndexPagination::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, next_time_stamp_), 0, offsetof(Impl_, limit_) - offsetof(Impl_, next_time_stamp_) + sizeof(Impl_::limit_)); } IndexPagination::~IndexPagination() { // @@protoc_insertion_point(destructor:remote.IndexPagination) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void IndexPagination::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* IndexPagination::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(IndexPagination, _impl_._cached_size_), false, }, &IndexPagination::MergeImpl, &IndexPagination::kDescriptorMethods, &descriptor_table_remote_2fkv_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> IndexPagination::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_IndexPagination_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::remote::IndexPagination>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // sint64 limit = 2; {::_pbi::TcParser::FastZ64S1, {16, 63, 0, PROTOBUF_FIELD_OFFSET(IndexPagination, _impl_.limit_)}}, // sint64 next_time_stamp = 1; {::_pbi::TcParser::FastZ64S1, {8, 63, 0, PROTOBUF_FIELD_OFFSET(IndexPagination, _impl_.next_time_stamp_)}}, }}, {{ 65535, 65535 }}, {{ // sint64 next_time_stamp = 1; {PROTOBUF_FIELD_OFFSET(IndexPagination, _impl_.next_time_stamp_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, // sint64 limit = 2; {PROTOBUF_FIELD_OFFSET(IndexPagination, _impl_.limit_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kSInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void IndexPagination::Clear() { // @@protoc_insertion_point(message_clear_start:remote.IndexPagination) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.next_time_stamp_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.limit_) - reinterpret_cast(&_impl_.next_time_stamp_)) + sizeof(_impl_.limit_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* IndexPagination::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:remote.IndexPagination) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // sint64 next_time_stamp = 1; if (this->_internal_next_time_stamp() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 1, this->_internal_next_time_stamp(), target); } // sint64 limit = 2; if (this->_internal_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteSInt64ToArray( 2, this->_internal_limit(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:remote.IndexPagination) return target; } ::size_t IndexPagination::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:remote.IndexPagination) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // sint64 next_time_stamp = 1; if (this->_internal_next_time_stamp() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_next_time_stamp()); } // sint64 limit = 2; if (this->_internal_limit() != 0) { total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne( this->_internal_limit()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void IndexPagination::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:remote.IndexPagination) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_next_time_stamp() != 0) { _this->_impl_.next_time_stamp_ = from._impl_.next_time_stamp_; } if (from._internal_limit() != 0) { _this->_impl_.limit_ = from._impl_.limit_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void IndexPagination::CopyFrom(const IndexPagination& from) { // @@protoc_insertion_point(class_specific_copy_from_start:remote.IndexPagination) if (&from == this) return; Clear(); MergeFrom(from); } void IndexPagination::InternalSwap(IndexPagination* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(IndexPagination, _impl_.limit_) + sizeof(IndexPagination::_impl_.limit_) - PROTOBUF_FIELD_OFFSET(IndexPagination, _impl_.next_time_stamp_)>( reinterpret_cast(&_impl_.next_time_stamp_), reinterpret_cast(&other->_impl_.next_time_stamp_)); } ::google::protobuf::Metadata IndexPagination::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace remote namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_remote_2fkv_2eproto), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/remote/kv.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: remote/kv.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_remote_2fkv_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_remote_2fkv_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_bases.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" #include "types/types.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_remote_2fkv_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_remote_2fkv_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_remote_2fkv_2eproto; namespace remote { class AccountChange; struct AccountChangeDefaultTypeInternal; extern AccountChangeDefaultTypeInternal _AccountChange_default_instance_; class Cursor; struct CursorDefaultTypeInternal; extern CursorDefaultTypeInternal _Cursor_default_instance_; class GetLatestReply; struct GetLatestReplyDefaultTypeInternal; extern GetLatestReplyDefaultTypeInternal _GetLatestReply_default_instance_; class GetLatestReq; struct GetLatestReqDefaultTypeInternal; extern GetLatestReqDefaultTypeInternal _GetLatestReq_default_instance_; class HistoryRangeReq; struct HistoryRangeReqDefaultTypeInternal; extern HistoryRangeReqDefaultTypeInternal _HistoryRangeReq_default_instance_; class HistorySeekReply; struct HistorySeekReplyDefaultTypeInternal; extern HistorySeekReplyDefaultTypeInternal _HistorySeekReply_default_instance_; class HistorySeekReq; struct HistorySeekReqDefaultTypeInternal; extern HistorySeekReqDefaultTypeInternal _HistorySeekReq_default_instance_; class IndexPagination; struct IndexPaginationDefaultTypeInternal; extern IndexPaginationDefaultTypeInternal _IndexPagination_default_instance_; class IndexRangeReply; struct IndexRangeReplyDefaultTypeInternal; extern IndexRangeReplyDefaultTypeInternal _IndexRangeReply_default_instance_; class IndexRangeReq; struct IndexRangeReqDefaultTypeInternal; extern IndexRangeReqDefaultTypeInternal _IndexRangeReq_default_instance_; class Pair; struct PairDefaultTypeInternal; extern PairDefaultTypeInternal _Pair_default_instance_; class Pairs; struct PairsDefaultTypeInternal; extern PairsDefaultTypeInternal _Pairs_default_instance_; class PairsPagination; struct PairsPaginationDefaultTypeInternal; extern PairsPaginationDefaultTypeInternal _PairsPagination_default_instance_; class RangeAsOfReq; struct RangeAsOfReqDefaultTypeInternal; extern RangeAsOfReqDefaultTypeInternal _RangeAsOfReq_default_instance_; class RangeReq; struct RangeReqDefaultTypeInternal; extern RangeReqDefaultTypeInternal _RangeReq_default_instance_; class SnapshotsReply; struct SnapshotsReplyDefaultTypeInternal; extern SnapshotsReplyDefaultTypeInternal _SnapshotsReply_default_instance_; class SnapshotsRequest; struct SnapshotsRequestDefaultTypeInternal; extern SnapshotsRequestDefaultTypeInternal _SnapshotsRequest_default_instance_; class StateChange; struct StateChangeDefaultTypeInternal; extern StateChangeDefaultTypeInternal _StateChange_default_instance_; class StateChangeBatch; struct StateChangeBatchDefaultTypeInternal; extern StateChangeBatchDefaultTypeInternal _StateChangeBatch_default_instance_; class StateChangeRequest; struct StateChangeRequestDefaultTypeInternal; extern StateChangeRequestDefaultTypeInternal _StateChangeRequest_default_instance_; class StorageChange; struct StorageChangeDefaultTypeInternal; extern StorageChangeDefaultTypeInternal _StorageChange_default_instance_; } // namespace remote namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace remote { enum Op : int { FIRST = 0, FIRST_DUP = 1, SEEK = 2, SEEK_BOTH = 3, CURRENT = 4, LAST = 6, LAST_DUP = 7, NEXT = 8, NEXT_DUP = 9, NEXT_NO_DUP = 11, PREV = 12, PREV_DUP = 13, PREV_NO_DUP = 14, SEEK_EXACT = 15, SEEK_BOTH_EXACT = 16, OPEN = 30, CLOSE = 31, OPEN_DUP_SORT = 32, Op_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), Op_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool Op_IsValid(int value); extern const uint32_t Op_internal_data_[]; constexpr Op Op_MIN = static_cast(0); constexpr Op Op_MAX = static_cast(32); constexpr int Op_ARRAYSIZE = 32 + 1; const ::google::protobuf::EnumDescriptor* Op_descriptor(); template const std::string& Op_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to Op_Name()."); return Op_Name(static_cast(value)); } template <> inline const std::string& Op_Name(Op value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool Op_Parse(absl::string_view name, Op* value) { return ::google::protobuf::internal::ParseNamedEnum( Op_descriptor(), name, value); } enum Action : int { STORAGE = 0, UPSERT = 1, CODE = 2, UPSERT_CODE = 3, REMOVE = 4, Action_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), Action_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool Action_IsValid(int value); extern const uint32_t Action_internal_data_[]; constexpr Action Action_MIN = static_cast(0); constexpr Action Action_MAX = static_cast(4); constexpr int Action_ARRAYSIZE = 4 + 1; const ::google::protobuf::EnumDescriptor* Action_descriptor(); template const std::string& Action_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to Action_Name()."); return Action_Name(static_cast(value)); } template <> inline const std::string& Action_Name(Action value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool Action_Parse(absl::string_view name, Action* value) { return ::google::protobuf::internal::ParseNamedEnum( Action_descriptor(), name, value); } enum Direction : int { FORWARD = 0, UNWIND = 1, Direction_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), Direction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool Direction_IsValid(int value); extern const uint32_t Direction_internal_data_[]; constexpr Direction Direction_MIN = static_cast(0); constexpr Direction Direction_MAX = static_cast(1); constexpr int Direction_ARRAYSIZE = 1 + 1; const ::google::protobuf::EnumDescriptor* Direction_descriptor(); template const std::string& Direction_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to Direction_Name()."); return Direction_Name(static_cast(value)); } template <> inline const std::string& Direction_Name(Direction value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool Direction_Parse(absl::string_view name, Direction* value) { return ::google::protobuf::internal::ParseNamedEnum( Direction_descriptor(), name, value); } // =================================================================== // ------------------------------------------------------------------- class StateChangeRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.StateChangeRequest) */ { public: inline StateChangeRequest() : StateChangeRequest(nullptr) {} ~StateChangeRequest() override; template explicit PROTOBUF_CONSTEXPR StateChangeRequest( ::google::protobuf::internal::ConstantInitialized); inline StateChangeRequest(const StateChangeRequest& from) : StateChangeRequest(nullptr, from) {} inline StateChangeRequest(StateChangeRequest&& from) noexcept : StateChangeRequest(nullptr, std::move(from)) {} inline StateChangeRequest& operator=(const StateChangeRequest& from) { CopyFrom(from); return *this; } inline StateChangeRequest& operator=(StateChangeRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const StateChangeRequest& default_instance() { return *internal_default_instance(); } static inline const StateChangeRequest* internal_default_instance() { return reinterpret_cast( &_StateChangeRequest_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(StateChangeRequest& a, StateChangeRequest& b) { a.Swap(&b); } inline void Swap(StateChangeRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StateChangeRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StateChangeRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const StateChangeRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const StateChangeRequest& from) { StateChangeRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(StateChangeRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.StateChangeRequest"; } protected: explicit StateChangeRequest(::google::protobuf::Arena* arena); StateChangeRequest(::google::protobuf::Arena* arena, const StateChangeRequest& from); StateChangeRequest(::google::protobuf::Arena* arena, StateChangeRequest&& from) noexcept : StateChangeRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kWithStorageFieldNumber = 1, kWithTransactionsFieldNumber = 2, }; // bool with_storage = 1; void clear_with_storage() ; bool with_storage() const; void set_with_storage(bool value); private: bool _internal_with_storage() const; void _internal_set_with_storage(bool value); public: // bool with_transactions = 2; void clear_with_transactions() ; bool with_transactions() const; void set_with_transactions(bool value); private: bool _internal_with_transactions() const; void _internal_set_with_transactions(bool value); public: // @@protoc_insertion_point(class_scope:remote.StateChangeRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_StateChangeRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const StateChangeRequest& from_msg); bool with_storage_; bool with_transactions_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class SnapshotsRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:remote.SnapshotsRequest) */ { public: inline SnapshotsRequest() : SnapshotsRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR SnapshotsRequest( ::google::protobuf::internal::ConstantInitialized); inline SnapshotsRequest(const SnapshotsRequest& from) : SnapshotsRequest(nullptr, from) {} inline SnapshotsRequest(SnapshotsRequest&& from) noexcept : SnapshotsRequest(nullptr, std::move(from)) {} inline SnapshotsRequest& operator=(const SnapshotsRequest& from) { CopyFrom(from); return *this; } inline SnapshotsRequest& operator=(SnapshotsRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SnapshotsRequest& default_instance() { return *internal_default_instance(); } static inline const SnapshotsRequest* internal_default_instance() { return reinterpret_cast( &_SnapshotsRequest_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(SnapshotsRequest& a, SnapshotsRequest& b) { a.Swap(&b); } inline void Swap(SnapshotsRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SnapshotsRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SnapshotsRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const SnapshotsRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const SnapshotsRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.SnapshotsRequest"; } protected: explicit SnapshotsRequest(::google::protobuf::Arena* arena); SnapshotsRequest(::google::protobuf::Arena* arena, const SnapshotsRequest& from); SnapshotsRequest(::google::protobuf::Arena* arena, SnapshotsRequest&& from) noexcept : SnapshotsRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:remote.SnapshotsRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SnapshotsRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SnapshotsRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class SnapshotsReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.SnapshotsReply) */ { public: inline SnapshotsReply() : SnapshotsReply(nullptr) {} ~SnapshotsReply() override; template explicit PROTOBUF_CONSTEXPR SnapshotsReply( ::google::protobuf::internal::ConstantInitialized); inline SnapshotsReply(const SnapshotsReply& from) : SnapshotsReply(nullptr, from) {} inline SnapshotsReply(SnapshotsReply&& from) noexcept : SnapshotsReply(nullptr, std::move(from)) {} inline SnapshotsReply& operator=(const SnapshotsReply& from) { CopyFrom(from); return *this; } inline SnapshotsReply& operator=(SnapshotsReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SnapshotsReply& default_instance() { return *internal_default_instance(); } static inline const SnapshotsReply* internal_default_instance() { return reinterpret_cast( &_SnapshotsReply_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(SnapshotsReply& a, SnapshotsReply& b) { a.Swap(&b); } inline void Swap(SnapshotsReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SnapshotsReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SnapshotsReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SnapshotsReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SnapshotsReply& from) { SnapshotsReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SnapshotsReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.SnapshotsReply"; } protected: explicit SnapshotsReply(::google::protobuf::Arena* arena); SnapshotsReply(::google::protobuf::Arena* arena, const SnapshotsReply& from); SnapshotsReply(::google::protobuf::Arena* arena, SnapshotsReply&& from) noexcept : SnapshotsReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlocksFilesFieldNumber = 1, kHistoryFilesFieldNumber = 2, }; // repeated string blocks_files = 1; int blocks_files_size() const; private: int _internal_blocks_files_size() const; public: void clear_blocks_files() ; const std::string& blocks_files(int index) const; std::string* mutable_blocks_files(int index); void set_blocks_files(int index, const std::string& value); void set_blocks_files(int index, std::string&& value); void set_blocks_files(int index, const char* value); void set_blocks_files(int index, const char* value, std::size_t size); void set_blocks_files(int index, absl::string_view value); std::string* add_blocks_files(); void add_blocks_files(const std::string& value); void add_blocks_files(std::string&& value); void add_blocks_files(const char* value); void add_blocks_files(const char* value, std::size_t size); void add_blocks_files(absl::string_view value); const ::google::protobuf::RepeatedPtrField& blocks_files() const; ::google::protobuf::RepeatedPtrField* mutable_blocks_files(); private: const ::google::protobuf::RepeatedPtrField& _internal_blocks_files() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_blocks_files(); public: // repeated string history_files = 2; int history_files_size() const; private: int _internal_history_files_size() const; public: void clear_history_files() ; const std::string& history_files(int index) const; std::string* mutable_history_files(int index); void set_history_files(int index, const std::string& value); void set_history_files(int index, std::string&& value); void set_history_files(int index, const char* value); void set_history_files(int index, const char* value, std::size_t size); void set_history_files(int index, absl::string_view value); std::string* add_history_files(); void add_history_files(const std::string& value); void add_history_files(std::string&& value); void add_history_files(const char* value); void add_history_files(const char* value, std::size_t size); void add_history_files(absl::string_view value); const ::google::protobuf::RepeatedPtrField& history_files() const; ::google::protobuf::RepeatedPtrField* mutable_history_files(); private: const ::google::protobuf::RepeatedPtrField& _internal_history_files() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_history_files(); public: // @@protoc_insertion_point(class_scope:remote.SnapshotsReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 55, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SnapshotsReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SnapshotsReply& from_msg); ::google::protobuf::RepeatedPtrField blocks_files_; ::google::protobuf::RepeatedPtrField history_files_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class RangeReq final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.RangeReq) */ { public: inline RangeReq() : RangeReq(nullptr) {} ~RangeReq() override; template explicit PROTOBUF_CONSTEXPR RangeReq( ::google::protobuf::internal::ConstantInitialized); inline RangeReq(const RangeReq& from) : RangeReq(nullptr, from) {} inline RangeReq(RangeReq&& from) noexcept : RangeReq(nullptr, std::move(from)) {} inline RangeReq& operator=(const RangeReq& from) { CopyFrom(from); return *this; } inline RangeReq& operator=(RangeReq&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const RangeReq& default_instance() { return *internal_default_instance(); } static inline const RangeReq* internal_default_instance() { return reinterpret_cast( &_RangeReq_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(RangeReq& a, RangeReq& b) { a.Swap(&b); } inline void Swap(RangeReq* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeReq* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeReq* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const RangeReq& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const RangeReq& from) { RangeReq::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(RangeReq* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.RangeReq"; } protected: explicit RangeReq(::google::protobuf::Arena* arena); RangeReq(::google::protobuf::Arena* arena, const RangeReq& from); RangeReq(::google::protobuf::Arena* arena, RangeReq&& from) noexcept : RangeReq(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTableFieldNumber = 2, kFromPrefixFieldNumber = 3, kToPrefixFieldNumber = 4, kPageTokenFieldNumber = 8, kTxIdFieldNumber = 1, kLimitFieldNumber = 6, kOrderAscendFieldNumber = 5, kPageSizeFieldNumber = 7, }; // string table = 2; void clear_table() ; const std::string& table() const; template void set_table(Arg_&& arg, Args_... args); std::string* mutable_table(); PROTOBUF_NODISCARD std::string* release_table(); void set_allocated_table(std::string* value); private: const std::string& _internal_table() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_table( const std::string& value); std::string* _internal_mutable_table(); public: // bytes from_prefix = 3; void clear_from_prefix() ; const std::string& from_prefix() const; template void set_from_prefix(Arg_&& arg, Args_... args); std::string* mutable_from_prefix(); PROTOBUF_NODISCARD std::string* release_from_prefix(); void set_allocated_from_prefix(std::string* value); private: const std::string& _internal_from_prefix() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_from_prefix( const std::string& value); std::string* _internal_mutable_from_prefix(); public: // bytes to_prefix = 4; void clear_to_prefix() ; const std::string& to_prefix() const; template void set_to_prefix(Arg_&& arg, Args_... args); std::string* mutable_to_prefix(); PROTOBUF_NODISCARD std::string* release_to_prefix(); void set_allocated_to_prefix(std::string* value); private: const std::string& _internal_to_prefix() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_to_prefix( const std::string& value); std::string* _internal_mutable_to_prefix(); public: // string page_token = 8; void clear_page_token() ; const std::string& page_token() const; template void set_page_token(Arg_&& arg, Args_... args); std::string* mutable_page_token(); PROTOBUF_NODISCARD std::string* release_page_token(); void set_allocated_page_token(std::string* value); private: const std::string& _internal_page_token() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_token( const std::string& value); std::string* _internal_mutable_page_token(); public: // uint64 tx_id = 1; void clear_tx_id() ; ::uint64_t tx_id() const; void set_tx_id(::uint64_t value); private: ::uint64_t _internal_tx_id() const; void _internal_set_tx_id(::uint64_t value); public: // sint64 limit = 6; void clear_limit() ; ::int64_t limit() const; void set_limit(::int64_t value); private: ::int64_t _internal_limit() const; void _internal_set_limit(::int64_t value); public: // bool order_ascend = 5; void clear_order_ascend() ; bool order_ascend() const; void set_order_ascend(bool value); private: bool _internal_order_ascend() const; void _internal_set_order_ascend(bool value); public: // int32 page_size = 7; void clear_page_size() ; ::int32_t page_size() const; void set_page_size(::int32_t value); private: ::int32_t _internal_page_size() const; void _internal_set_page_size(::int32_t value); public: // @@protoc_insertion_point(class_scope:remote.RangeReq) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 8, 0, 47, 2> _table_; static constexpr const void* _raw_default_instance_ = &_RangeReq_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const RangeReq& from_msg); ::google::protobuf::internal::ArenaStringPtr table_; ::google::protobuf::internal::ArenaStringPtr from_prefix_; ::google::protobuf::internal::ArenaStringPtr to_prefix_; ::google::protobuf::internal::ArenaStringPtr page_token_; ::uint64_t tx_id_; ::int64_t limit_; bool order_ascend_; ::int32_t page_size_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class RangeAsOfReq final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.RangeAsOfReq) */ { public: inline RangeAsOfReq() : RangeAsOfReq(nullptr) {} ~RangeAsOfReq() override; template explicit PROTOBUF_CONSTEXPR RangeAsOfReq( ::google::protobuf::internal::ConstantInitialized); inline RangeAsOfReq(const RangeAsOfReq& from) : RangeAsOfReq(nullptr, from) {} inline RangeAsOfReq(RangeAsOfReq&& from) noexcept : RangeAsOfReq(nullptr, std::move(from)) {} inline RangeAsOfReq& operator=(const RangeAsOfReq& from) { CopyFrom(from); return *this; } inline RangeAsOfReq& operator=(RangeAsOfReq&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const RangeAsOfReq& default_instance() { return *internal_default_instance(); } static inline const RangeAsOfReq* internal_default_instance() { return reinterpret_cast( &_RangeAsOfReq_default_instance_); } static constexpr int kIndexInFileMessages = 17; friend void swap(RangeAsOfReq& a, RangeAsOfReq& b) { a.Swap(&b); } inline void Swap(RangeAsOfReq* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeAsOfReq* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeAsOfReq* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const RangeAsOfReq& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const RangeAsOfReq& from) { RangeAsOfReq::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(RangeAsOfReq* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.RangeAsOfReq"; } protected: explicit RangeAsOfReq(::google::protobuf::Arena* arena); RangeAsOfReq(::google::protobuf::Arena* arena, const RangeAsOfReq& from); RangeAsOfReq(::google::protobuf::Arena* arena, RangeAsOfReq&& from) noexcept : RangeAsOfReq(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTableFieldNumber = 2, kFromKeyFieldNumber = 3, kToKeyFieldNumber = 4, kPageTokenFieldNumber = 10, kTxIdFieldNumber = 1, kTsFieldNumber = 5, kLatestFieldNumber = 6, kOrderAscendFieldNumber = 7, kPageSizeFieldNumber = 9, kLimitFieldNumber = 8, }; // string table = 2; void clear_table() ; const std::string& table() const; template void set_table(Arg_&& arg, Args_... args); std::string* mutable_table(); PROTOBUF_NODISCARD std::string* release_table(); void set_allocated_table(std::string* value); private: const std::string& _internal_table() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_table( const std::string& value); std::string* _internal_mutable_table(); public: // bytes from_key = 3; void clear_from_key() ; const std::string& from_key() const; template void set_from_key(Arg_&& arg, Args_... args); std::string* mutable_from_key(); PROTOBUF_NODISCARD std::string* release_from_key(); void set_allocated_from_key(std::string* value); private: const std::string& _internal_from_key() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_from_key( const std::string& value); std::string* _internal_mutable_from_key(); public: // bytes to_key = 4; void clear_to_key() ; const std::string& to_key() const; template void set_to_key(Arg_&& arg, Args_... args); std::string* mutable_to_key(); PROTOBUF_NODISCARD std::string* release_to_key(); void set_allocated_to_key(std::string* value); private: const std::string& _internal_to_key() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_to_key( const std::string& value); std::string* _internal_mutable_to_key(); public: // string page_token = 10; void clear_page_token() ; const std::string& page_token() const; template void set_page_token(Arg_&& arg, Args_... args); std::string* mutable_page_token(); PROTOBUF_NODISCARD std::string* release_page_token(); void set_allocated_page_token(std::string* value); private: const std::string& _internal_page_token() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_token( const std::string& value); std::string* _internal_mutable_page_token(); public: // uint64 tx_id = 1; void clear_tx_id() ; ::uint64_t tx_id() const; void set_tx_id(::uint64_t value); private: ::uint64_t _internal_tx_id() const; void _internal_set_tx_id(::uint64_t value); public: // uint64 ts = 5; void clear_ts() ; ::uint64_t ts() const; void set_ts(::uint64_t value); private: ::uint64_t _internal_ts() const; void _internal_set_ts(::uint64_t value); public: // bool latest = 6; void clear_latest() ; bool latest() const; void set_latest(bool value); private: bool _internal_latest() const; void _internal_set_latest(bool value); public: // bool order_ascend = 7; void clear_order_ascend() ; bool order_ascend() const; void set_order_ascend(bool value); private: bool _internal_order_ascend() const; void _internal_set_order_ascend(bool value); public: // int32 page_size = 9; void clear_page_size() ; ::int32_t page_size() const; void set_page_size(::int32_t value); private: ::int32_t _internal_page_size() const; void _internal_set_page_size(::int32_t value); public: // sint64 limit = 8; void clear_limit() ; ::int64_t limit() const; void set_limit(::int64_t value); private: ::int64_t _internal_limit() const; void _internal_set_limit(::int64_t value); public: // @@protoc_insertion_point(class_scope:remote.RangeAsOfReq) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 4, 10, 0, 51, 2> _table_; static constexpr const void* _raw_default_instance_ = &_RangeAsOfReq_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const RangeAsOfReq& from_msg); ::google::protobuf::internal::ArenaStringPtr table_; ::google::protobuf::internal::ArenaStringPtr from_key_; ::google::protobuf::internal::ArenaStringPtr to_key_; ::google::protobuf::internal::ArenaStringPtr page_token_; ::uint64_t tx_id_; ::uint64_t ts_; bool latest_; bool order_ascend_; ::int32_t page_size_; ::int64_t limit_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class PairsPagination final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.PairsPagination) */ { public: inline PairsPagination() : PairsPagination(nullptr) {} ~PairsPagination() override; template explicit PROTOBUF_CONSTEXPR PairsPagination( ::google::protobuf::internal::ConstantInitialized); inline PairsPagination(const PairsPagination& from) : PairsPagination(nullptr, from) {} inline PairsPagination(PairsPagination&& from) noexcept : PairsPagination(nullptr, std::move(from)) {} inline PairsPagination& operator=(const PairsPagination& from) { CopyFrom(from); return *this; } inline PairsPagination& operator=(PairsPagination&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PairsPagination& default_instance() { return *internal_default_instance(); } static inline const PairsPagination* internal_default_instance() { return reinterpret_cast( &_PairsPagination_default_instance_); } static constexpr int kIndexInFileMessages = 19; friend void swap(PairsPagination& a, PairsPagination& b) { a.Swap(&b); } inline void Swap(PairsPagination* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PairsPagination* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PairsPagination* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PairsPagination& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PairsPagination& from) { PairsPagination::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PairsPagination* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.PairsPagination"; } protected: explicit PairsPagination(::google::protobuf::Arena* arena); PairsPagination(::google::protobuf::Arena* arena, const PairsPagination& from); PairsPagination(::google::protobuf::Arena* arena, PairsPagination&& from) noexcept : PairsPagination(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNextKeyFieldNumber = 1, kLimitFieldNumber = 2, }; // bytes next_key = 1; void clear_next_key() ; const std::string& next_key() const; template void set_next_key(Arg_&& arg, Args_... args); std::string* mutable_next_key(); PROTOBUF_NODISCARD std::string* release_next_key(); void set_allocated_next_key(std::string* value); private: const std::string& _internal_next_key() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_next_key( const std::string& value); std::string* _internal_mutable_next_key(); public: // sint64 limit = 2; void clear_limit() ; ::int64_t limit() const; void set_limit(::int64_t value); private: ::int64_t _internal_limit() const; void _internal_set_limit(::int64_t value); public: // @@protoc_insertion_point(class_scope:remote.PairsPagination) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PairsPagination_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PairsPagination& from_msg); ::google::protobuf::internal::ArenaStringPtr next_key_; ::int64_t limit_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class Pairs final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.Pairs) */ { public: inline Pairs() : Pairs(nullptr) {} ~Pairs() override; template explicit PROTOBUF_CONSTEXPR Pairs( ::google::protobuf::internal::ConstantInitialized); inline Pairs(const Pairs& from) : Pairs(nullptr, from) {} inline Pairs(Pairs&& from) noexcept : Pairs(nullptr, std::move(from)) {} inline Pairs& operator=(const Pairs& from) { CopyFrom(from); return *this; } inline Pairs& operator=(Pairs&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Pairs& default_instance() { return *internal_default_instance(); } static inline const Pairs* internal_default_instance() { return reinterpret_cast( &_Pairs_default_instance_); } static constexpr int kIndexInFileMessages = 18; friend void swap(Pairs& a, Pairs& b) { a.Swap(&b); } inline void Swap(Pairs* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Pairs* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Pairs* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Pairs& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Pairs& from) { Pairs::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Pairs* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.Pairs"; } protected: explicit Pairs(::google::protobuf::Arena* arena); Pairs(::google::protobuf::Arena* arena, const Pairs& from); Pairs(::google::protobuf::Arena* arena, Pairs&& from) noexcept : Pairs(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kKeysFieldNumber = 1, kValuesFieldNumber = 2, kNextPageTokenFieldNumber = 3, }; // repeated bytes keys = 1; int keys_size() const; private: int _internal_keys_size() const; public: void clear_keys() ; const std::string& keys(int index) const; std::string* mutable_keys(int index); void set_keys(int index, const std::string& value); void set_keys(int index, std::string&& value); void set_keys(int index, const char* value); void set_keys(int index, const void* value, std::size_t size); void set_keys(int index, absl::string_view value); std::string* add_keys(); void add_keys(const std::string& value); void add_keys(std::string&& value); void add_keys(const char* value); void add_keys(const void* value, std::size_t size); void add_keys(absl::string_view value); const ::google::protobuf::RepeatedPtrField& keys() const; ::google::protobuf::RepeatedPtrField* mutable_keys(); private: const ::google::protobuf::RepeatedPtrField& _internal_keys() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_keys(); public: // repeated bytes values = 2; int values_size() const; private: int _internal_values_size() const; public: void clear_values() ; const std::string& values(int index) const; std::string* mutable_values(int index); void set_values(int index, const std::string& value); void set_values(int index, std::string&& value); void set_values(int index, const char* value); void set_values(int index, const void* value, std::size_t size); void set_values(int index, absl::string_view value); std::string* add_values(); void add_values(const std::string& value); void add_values(std::string&& value); void add_values(const char* value); void add_values(const void* value, std::size_t size); void add_values(absl::string_view value); const ::google::protobuf::RepeatedPtrField& values() const; ::google::protobuf::RepeatedPtrField* mutable_values(); private: const ::google::protobuf::RepeatedPtrField& _internal_values() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_values(); public: // string next_page_token = 3; void clear_next_page_token() ; const std::string& next_page_token() const; template void set_next_page_token(Arg_&& arg, Args_... args); std::string* mutable_next_page_token(); PROTOBUF_NODISCARD std::string* release_next_page_token(); void set_allocated_next_page_token(std::string* value); private: const std::string& _internal_next_page_token() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_next_page_token( const std::string& value); std::string* _internal_mutable_next_page_token(); public: // @@protoc_insertion_point(class_scope:remote.Pairs) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 0, 36, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Pairs_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Pairs& from_msg); ::google::protobuf::RepeatedPtrField keys_; ::google::protobuf::RepeatedPtrField values_; ::google::protobuf::internal::ArenaStringPtr next_page_token_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class Pair final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.Pair) */ { public: inline Pair() : Pair(nullptr) {} ~Pair() override; template explicit PROTOBUF_CONSTEXPR Pair( ::google::protobuf::internal::ConstantInitialized); inline Pair(const Pair& from) : Pair(nullptr, from) {} inline Pair(Pair&& from) noexcept : Pair(nullptr, std::move(from)) {} inline Pair& operator=(const Pair& from) { CopyFrom(from); return *this; } inline Pair& operator=(Pair&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Pair& default_instance() { return *internal_default_instance(); } static inline const Pair* internal_default_instance() { return reinterpret_cast( &_Pair_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(Pair& a, Pair& b) { a.Swap(&b); } inline void Swap(Pair* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Pair* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Pair* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Pair& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Pair& from) { Pair::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Pair* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.Pair"; } protected: explicit Pair(::google::protobuf::Arena* arena); Pair(::google::protobuf::Arena* arena, const Pair& from); Pair(::google::protobuf::Arena* arena, Pair&& from) noexcept : Pair(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kKFieldNumber = 1, kVFieldNumber = 2, kViewIdFieldNumber = 4, kTxIdFieldNumber = 5, kCursorIdFieldNumber = 3, }; // bytes k = 1; void clear_k() ; const std::string& k() const; template void set_k(Arg_&& arg, Args_... args); std::string* mutable_k(); PROTOBUF_NODISCARD std::string* release_k(); void set_allocated_k(std::string* value); private: const std::string& _internal_k() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_k( const std::string& value); std::string* _internal_mutable_k(); public: // bytes v = 2; void clear_v() ; const std::string& v() const; template void set_v(Arg_&& arg, Args_... args); std::string* mutable_v(); PROTOBUF_NODISCARD std::string* release_v(); void set_allocated_v(std::string* value); private: const std::string& _internal_v() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_v( const std::string& value); std::string* _internal_mutable_v(); public: // uint64 view_id = 4; void clear_view_id() ; ::uint64_t view_id() const; void set_view_id(::uint64_t value); private: ::uint64_t _internal_view_id() const; void _internal_set_view_id(::uint64_t value); public: // uint64 tx_id = 5; void clear_tx_id() ; ::uint64_t tx_id() const; void set_tx_id(::uint64_t value); private: ::uint64_t _internal_tx_id() const; void _internal_set_tx_id(::uint64_t value); public: // uint32 cursor_id = 3; void clear_cursor_id() ; ::uint32_t cursor_id() const; void set_cursor_id(::uint32_t value); private: ::uint32_t _internal_cursor_id() const; void _internal_set_cursor_id(::uint32_t value); public: // @@protoc_insertion_point(class_scope:remote.Pair) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 5, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Pair_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Pair& from_msg); ::google::protobuf::internal::ArenaStringPtr k_; ::google::protobuf::internal::ArenaStringPtr v_; ::uint64_t view_id_; ::uint64_t tx_id_; ::uint32_t cursor_id_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class IndexRangeReq final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.IndexRangeReq) */ { public: inline IndexRangeReq() : IndexRangeReq(nullptr) {} ~IndexRangeReq() override; template explicit PROTOBUF_CONSTEXPR IndexRangeReq( ::google::protobuf::internal::ConstantInitialized); inline IndexRangeReq(const IndexRangeReq& from) : IndexRangeReq(nullptr, from) {} inline IndexRangeReq(IndexRangeReq&& from) noexcept : IndexRangeReq(nullptr, std::move(from)) {} inline IndexRangeReq& operator=(const IndexRangeReq& from) { CopyFrom(from); return *this; } inline IndexRangeReq& operator=(IndexRangeReq&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const IndexRangeReq& default_instance() { return *internal_default_instance(); } static inline const IndexRangeReq* internal_default_instance() { return reinterpret_cast( &_IndexRangeReq_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(IndexRangeReq& a, IndexRangeReq& b) { a.Swap(&b); } inline void Swap(IndexRangeReq* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IndexRangeReq* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IndexRangeReq* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const IndexRangeReq& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const IndexRangeReq& from) { IndexRangeReq::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(IndexRangeReq* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.IndexRangeReq"; } protected: explicit IndexRangeReq(::google::protobuf::Arena* arena); IndexRangeReq(::google::protobuf::Arena* arena, const IndexRangeReq& from); IndexRangeReq(::google::protobuf::Arena* arena, IndexRangeReq&& from) noexcept : IndexRangeReq(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTableFieldNumber = 2, kKFieldNumber = 3, kPageTokenFieldNumber = 9, kTxIdFieldNumber = 1, kFromTsFieldNumber = 4, kToTsFieldNumber = 5, kLimitFieldNumber = 7, kOrderAscendFieldNumber = 6, kPageSizeFieldNumber = 8, }; // string table = 2; void clear_table() ; const std::string& table() const; template void set_table(Arg_&& arg, Args_... args); std::string* mutable_table(); PROTOBUF_NODISCARD std::string* release_table(); void set_allocated_table(std::string* value); private: const std::string& _internal_table() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_table( const std::string& value); std::string* _internal_mutable_table(); public: // bytes k = 3; void clear_k() ; const std::string& k() const; template void set_k(Arg_&& arg, Args_... args); std::string* mutable_k(); PROTOBUF_NODISCARD std::string* release_k(); void set_allocated_k(std::string* value); private: const std::string& _internal_k() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_k( const std::string& value); std::string* _internal_mutable_k(); public: // string page_token = 9; void clear_page_token() ; const std::string& page_token() const; template void set_page_token(Arg_&& arg, Args_... args); std::string* mutable_page_token(); PROTOBUF_NODISCARD std::string* release_page_token(); void set_allocated_page_token(std::string* value); private: const std::string& _internal_page_token() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_token( const std::string& value); std::string* _internal_mutable_page_token(); public: // uint64 tx_id = 1; void clear_tx_id() ; ::uint64_t tx_id() const; void set_tx_id(::uint64_t value); private: ::uint64_t _internal_tx_id() const; void _internal_set_tx_id(::uint64_t value); public: // sint64 from_ts = 4; void clear_from_ts() ; ::int64_t from_ts() const; void set_from_ts(::int64_t value); private: ::int64_t _internal_from_ts() const; void _internal_set_from_ts(::int64_t value); public: // sint64 to_ts = 5; void clear_to_ts() ; ::int64_t to_ts() const; void set_to_ts(::int64_t value); private: ::int64_t _internal_to_ts() const; void _internal_set_to_ts(::int64_t value); public: // sint64 limit = 7; void clear_limit() ; ::int64_t limit() const; void set_limit(::int64_t value); private: ::int64_t _internal_limit() const; void _internal_set_limit(::int64_t value); public: // bool order_ascend = 6; void clear_order_ascend() ; bool order_ascend() const; void set_order_ascend(bool value); private: bool _internal_order_ascend() const; void _internal_set_order_ascend(bool value); public: // int32 page_size = 8; void clear_page_size() ; ::int32_t page_size() const; void set_page_size(::int32_t value); private: ::int32_t _internal_page_size() const; void _internal_set_page_size(::int32_t value); public: // @@protoc_insertion_point(class_scope:remote.IndexRangeReq) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 4, 9, 0, 52, 2> _table_; static constexpr const void* _raw_default_instance_ = &_IndexRangeReq_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const IndexRangeReq& from_msg); ::google::protobuf::internal::ArenaStringPtr table_; ::google::protobuf::internal::ArenaStringPtr k_; ::google::protobuf::internal::ArenaStringPtr page_token_; ::uint64_t tx_id_; ::int64_t from_ts_; ::int64_t to_ts_; ::int64_t limit_; bool order_ascend_; ::int32_t page_size_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class IndexRangeReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.IndexRangeReply) */ { public: inline IndexRangeReply() : IndexRangeReply(nullptr) {} ~IndexRangeReply() override; template explicit PROTOBUF_CONSTEXPR IndexRangeReply( ::google::protobuf::internal::ConstantInitialized); inline IndexRangeReply(const IndexRangeReply& from) : IndexRangeReply(nullptr, from) {} inline IndexRangeReply(IndexRangeReply&& from) noexcept : IndexRangeReply(nullptr, std::move(from)) {} inline IndexRangeReply& operator=(const IndexRangeReply& from) { CopyFrom(from); return *this; } inline IndexRangeReply& operator=(IndexRangeReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const IndexRangeReply& default_instance() { return *internal_default_instance(); } static inline const IndexRangeReply* internal_default_instance() { return reinterpret_cast( &_IndexRangeReply_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(IndexRangeReply& a, IndexRangeReply& b) { a.Swap(&b); } inline void Swap(IndexRangeReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IndexRangeReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IndexRangeReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const IndexRangeReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const IndexRangeReply& from) { IndexRangeReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(IndexRangeReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.IndexRangeReply"; } protected: explicit IndexRangeReply(::google::protobuf::Arena* arena); IndexRangeReply(::google::protobuf::Arena* arena, const IndexRangeReply& from); IndexRangeReply(::google::protobuf::Arena* arena, IndexRangeReply&& from) noexcept : IndexRangeReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTimestampsFieldNumber = 1, kNextPageTokenFieldNumber = 2, }; // repeated uint64 timestamps = 1; int timestamps_size() const; private: int _internal_timestamps_size() const; public: void clear_timestamps() ; ::uint64_t timestamps(int index) const; void set_timestamps(int index, ::uint64_t value); void add_timestamps(::uint64_t value); const ::google::protobuf::RepeatedField<::uint64_t>& timestamps() const; ::google::protobuf::RepeatedField<::uint64_t>* mutable_timestamps(); private: const ::google::protobuf::RepeatedField<::uint64_t>& _internal_timestamps() const; ::google::protobuf::RepeatedField<::uint64_t>* _internal_mutable_timestamps(); public: // string next_page_token = 2; void clear_next_page_token() ; const std::string& next_page_token() const; template void set_next_page_token(Arg_&& arg, Args_... args); std::string* mutable_next_page_token(); PROTOBUF_NODISCARD std::string* release_next_page_token(); void set_allocated_next_page_token(std::string* value); private: const std::string& _internal_next_page_token() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_next_page_token( const std::string& value); std::string* _internal_mutable_next_page_token(); public: // @@protoc_insertion_point(class_scope:remote.IndexRangeReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 46, 2> _table_; static constexpr const void* _raw_default_instance_ = &_IndexRangeReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const IndexRangeReply& from_msg); ::google::protobuf::RepeatedField<::uint64_t> timestamps_; mutable ::google::protobuf::internal::CachedSize _timestamps_cached_byte_size_; ::google::protobuf::internal::ArenaStringPtr next_page_token_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class IndexPagination final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.IndexPagination) */ { public: inline IndexPagination() : IndexPagination(nullptr) {} ~IndexPagination() override; template explicit PROTOBUF_CONSTEXPR IndexPagination( ::google::protobuf::internal::ConstantInitialized); inline IndexPagination(const IndexPagination& from) : IndexPagination(nullptr, from) {} inline IndexPagination(IndexPagination&& from) noexcept : IndexPagination(nullptr, std::move(from)) {} inline IndexPagination& operator=(const IndexPagination& from) { CopyFrom(from); return *this; } inline IndexPagination& operator=(IndexPagination&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const IndexPagination& default_instance() { return *internal_default_instance(); } static inline const IndexPagination* internal_default_instance() { return reinterpret_cast( &_IndexPagination_default_instance_); } static constexpr int kIndexInFileMessages = 20; friend void swap(IndexPagination& a, IndexPagination& b) { a.Swap(&b); } inline void Swap(IndexPagination* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IndexPagination* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IndexPagination* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const IndexPagination& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const IndexPagination& from) { IndexPagination::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(IndexPagination* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.IndexPagination"; } protected: explicit IndexPagination(::google::protobuf::Arena* arena); IndexPagination(::google::protobuf::Arena* arena, const IndexPagination& from); IndexPagination(::google::protobuf::Arena* arena, IndexPagination&& from) noexcept : IndexPagination(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNextTimeStampFieldNumber = 1, kLimitFieldNumber = 2, }; // sint64 next_time_stamp = 1; void clear_next_time_stamp() ; ::int64_t next_time_stamp() const; void set_next_time_stamp(::int64_t value); private: ::int64_t _internal_next_time_stamp() const; void _internal_set_next_time_stamp(::int64_t value); public: // sint64 limit = 2; void clear_limit() ; ::int64_t limit() const; void set_limit(::int64_t value); private: ::int64_t _internal_limit() const; void _internal_set_limit(::int64_t value); public: // @@protoc_insertion_point(class_scope:remote.IndexPagination) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_IndexPagination_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const IndexPagination& from_msg); ::int64_t next_time_stamp_; ::int64_t limit_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class HistorySeekReq final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.HistorySeekReq) */ { public: inline HistorySeekReq() : HistorySeekReq(nullptr) {} ~HistorySeekReq() override; template explicit PROTOBUF_CONSTEXPR HistorySeekReq( ::google::protobuf::internal::ConstantInitialized); inline HistorySeekReq(const HistorySeekReq& from) : HistorySeekReq(nullptr, from) {} inline HistorySeekReq(HistorySeekReq&& from) noexcept : HistorySeekReq(nullptr, std::move(from)) {} inline HistorySeekReq& operator=(const HistorySeekReq& from) { CopyFrom(from); return *this; } inline HistorySeekReq& operator=(HistorySeekReq&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HistorySeekReq& default_instance() { return *internal_default_instance(); } static inline const HistorySeekReq* internal_default_instance() { return reinterpret_cast( &_HistorySeekReq_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(HistorySeekReq& a, HistorySeekReq& b) { a.Swap(&b); } inline void Swap(HistorySeekReq* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HistorySeekReq* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HistorySeekReq* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HistorySeekReq& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HistorySeekReq& from) { HistorySeekReq::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HistorySeekReq* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.HistorySeekReq"; } protected: explicit HistorySeekReq(::google::protobuf::Arena* arena); HistorySeekReq(::google::protobuf::Arena* arena, const HistorySeekReq& from); HistorySeekReq(::google::protobuf::Arena* arena, HistorySeekReq&& from) noexcept : HistorySeekReq(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTableFieldNumber = 2, kKFieldNumber = 3, kTxIdFieldNumber = 1, kTsFieldNumber = 4, }; // string table = 2; void clear_table() ; const std::string& table() const; template void set_table(Arg_&& arg, Args_... args); std::string* mutable_table(); PROTOBUF_NODISCARD std::string* release_table(); void set_allocated_table(std::string* value); private: const std::string& _internal_table() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_table( const std::string& value); std::string* _internal_mutable_table(); public: // bytes k = 3; void clear_k() ; const std::string& k() const; template void set_k(Arg_&& arg, Args_... args); std::string* mutable_k(); PROTOBUF_NODISCARD std::string* release_k(); void set_allocated_k(std::string* value); private: const std::string& _internal_k() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_k( const std::string& value); std::string* _internal_mutable_k(); public: // uint64 tx_id = 1; void clear_tx_id() ; ::uint64_t tx_id() const; void set_tx_id(::uint64_t value); private: ::uint64_t _internal_tx_id() const; void _internal_set_tx_id(::uint64_t value); public: // uint64 ts = 4; void clear_ts() ; ::uint64_t ts() const; void set_ts(::uint64_t value); private: ::uint64_t _internal_ts() const; void _internal_set_ts(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.HistorySeekReq) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 4, 0, 35, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HistorySeekReq_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HistorySeekReq& from_msg); ::google::protobuf::internal::ArenaStringPtr table_; ::google::protobuf::internal::ArenaStringPtr k_; ::uint64_t tx_id_; ::uint64_t ts_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class HistorySeekReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.HistorySeekReply) */ { public: inline HistorySeekReply() : HistorySeekReply(nullptr) {} ~HistorySeekReply() override; template explicit PROTOBUF_CONSTEXPR HistorySeekReply( ::google::protobuf::internal::ConstantInitialized); inline HistorySeekReply(const HistorySeekReply& from) : HistorySeekReply(nullptr, from) {} inline HistorySeekReply(HistorySeekReply&& from) noexcept : HistorySeekReply(nullptr, std::move(from)) {} inline HistorySeekReply& operator=(const HistorySeekReply& from) { CopyFrom(from); return *this; } inline HistorySeekReply& operator=(HistorySeekReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HistorySeekReply& default_instance() { return *internal_default_instance(); } static inline const HistorySeekReply* internal_default_instance() { return reinterpret_cast( &_HistorySeekReply_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(HistorySeekReply& a, HistorySeekReply& b) { a.Swap(&b); } inline void Swap(HistorySeekReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HistorySeekReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HistorySeekReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HistorySeekReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HistorySeekReply& from) { HistorySeekReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HistorySeekReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.HistorySeekReply"; } protected: explicit HistorySeekReply(::google::protobuf::Arena* arena); HistorySeekReply(::google::protobuf::Arena* arena, const HistorySeekReply& from); HistorySeekReply(::google::protobuf::Arena* arena, HistorySeekReply&& from) noexcept : HistorySeekReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kVFieldNumber = 1, kOkFieldNumber = 2, }; // bytes v = 1; void clear_v() ; const std::string& v() const; template void set_v(Arg_&& arg, Args_... args); std::string* mutable_v(); PROTOBUF_NODISCARD std::string* release_v(); void set_allocated_v(std::string* value); private: const std::string& _internal_v() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_v( const std::string& value); std::string* _internal_mutable_v(); public: // bool ok = 2; void clear_ok() ; bool ok() const; void set_ok(bool value); private: bool _internal_ok() const; void _internal_set_ok(bool value); public: // @@protoc_insertion_point(class_scope:remote.HistorySeekReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HistorySeekReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HistorySeekReply& from_msg); ::google::protobuf::internal::ArenaStringPtr v_; bool ok_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class HistoryRangeReq final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.HistoryRangeReq) */ { public: inline HistoryRangeReq() : HistoryRangeReq(nullptr) {} ~HistoryRangeReq() override; template explicit PROTOBUF_CONSTEXPR HistoryRangeReq( ::google::protobuf::internal::ConstantInitialized); inline HistoryRangeReq(const HistoryRangeReq& from) : HistoryRangeReq(nullptr, from) {} inline HistoryRangeReq(HistoryRangeReq&& from) noexcept : HistoryRangeReq(nullptr, std::move(from)) {} inline HistoryRangeReq& operator=(const HistoryRangeReq& from) { CopyFrom(from); return *this; } inline HistoryRangeReq& operator=(HistoryRangeReq&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HistoryRangeReq& default_instance() { return *internal_default_instance(); } static inline const HistoryRangeReq* internal_default_instance() { return reinterpret_cast( &_HistoryRangeReq_default_instance_); } static constexpr int kIndexInFileMessages = 16; friend void swap(HistoryRangeReq& a, HistoryRangeReq& b) { a.Swap(&b); } inline void Swap(HistoryRangeReq* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HistoryRangeReq* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HistoryRangeReq* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HistoryRangeReq& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HistoryRangeReq& from) { HistoryRangeReq::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HistoryRangeReq* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.HistoryRangeReq"; } protected: explicit HistoryRangeReq(::google::protobuf::Arena* arena); HistoryRangeReq(::google::protobuf::Arena* arena, const HistoryRangeReq& from); HistoryRangeReq(::google::protobuf::Arena* arena, HistoryRangeReq&& from) noexcept : HistoryRangeReq(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTableFieldNumber = 2, kPageTokenFieldNumber = 9, kTxIdFieldNumber = 1, kFromTsFieldNumber = 4, kToTsFieldNumber = 5, kLimitFieldNumber = 7, kOrderAscendFieldNumber = 6, kPageSizeFieldNumber = 8, }; // string table = 2; void clear_table() ; const std::string& table() const; template void set_table(Arg_&& arg, Args_... args); std::string* mutable_table(); PROTOBUF_NODISCARD std::string* release_table(); void set_allocated_table(std::string* value); private: const std::string& _internal_table() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_table( const std::string& value); std::string* _internal_mutable_table(); public: // string page_token = 9; void clear_page_token() ; const std::string& page_token() const; template void set_page_token(Arg_&& arg, Args_... args); std::string* mutable_page_token(); PROTOBUF_NODISCARD std::string* release_page_token(); void set_allocated_page_token(std::string* value); private: const std::string& _internal_page_token() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_token( const std::string& value); std::string* _internal_mutable_page_token(); public: // uint64 tx_id = 1; void clear_tx_id() ; ::uint64_t tx_id() const; void set_tx_id(::uint64_t value); private: ::uint64_t _internal_tx_id() const; void _internal_set_tx_id(::uint64_t value); public: // sint64 from_ts = 4; void clear_from_ts() ; ::int64_t from_ts() const; void set_from_ts(::int64_t value); private: ::int64_t _internal_from_ts() const; void _internal_set_from_ts(::int64_t value); public: // sint64 to_ts = 5; void clear_to_ts() ; ::int64_t to_ts() const; void set_to_ts(::int64_t value); private: ::int64_t _internal_to_ts() const; void _internal_set_to_ts(::int64_t value); public: // sint64 limit = 7; void clear_limit() ; ::int64_t limit() const; void set_limit(::int64_t value); private: ::int64_t _internal_limit() const; void _internal_set_limit(::int64_t value); public: // bool order_ascend = 6; void clear_order_ascend() ; bool order_ascend() const; void set_order_ascend(bool value); private: bool _internal_order_ascend() const; void _internal_set_order_ascend(bool value); public: // int32 page_size = 8; void clear_page_size() ; ::int32_t page_size() const; void set_page_size(::int32_t value); private: ::int32_t _internal_page_size() const; void _internal_set_page_size(::int32_t value); public: // @@protoc_insertion_point(class_scope:remote.HistoryRangeReq) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 4, 8, 0, 54, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HistoryRangeReq_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HistoryRangeReq& from_msg); ::google::protobuf::internal::ArenaStringPtr table_; ::google::protobuf::internal::ArenaStringPtr page_token_; ::uint64_t tx_id_; ::int64_t from_ts_; ::int64_t to_ts_; ::int64_t limit_; bool order_ascend_; ::int32_t page_size_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class GetLatestReq final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.GetLatestReq) */ { public: inline GetLatestReq() : GetLatestReq(nullptr) {} ~GetLatestReq() override; template explicit PROTOBUF_CONSTEXPR GetLatestReq( ::google::protobuf::internal::ConstantInitialized); inline GetLatestReq(const GetLatestReq& from) : GetLatestReq(nullptr, from) {} inline GetLatestReq(GetLatestReq&& from) noexcept : GetLatestReq(nullptr, std::move(from)) {} inline GetLatestReq& operator=(const GetLatestReq& from) { CopyFrom(from); return *this; } inline GetLatestReq& operator=(GetLatestReq&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetLatestReq& default_instance() { return *internal_default_instance(); } static inline const GetLatestReq* internal_default_instance() { return reinterpret_cast( &_GetLatestReq_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(GetLatestReq& a, GetLatestReq& b) { a.Swap(&b); } inline void Swap(GetLatestReq* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetLatestReq* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetLatestReq* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetLatestReq& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetLatestReq& from) { GetLatestReq::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetLatestReq* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.GetLatestReq"; } protected: explicit GetLatestReq(::google::protobuf::Arena* arena); GetLatestReq(::google::protobuf::Arena* arena, const GetLatestReq& from); GetLatestReq(::google::protobuf::Arena* arena, GetLatestReq&& from) noexcept : GetLatestReq(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTableFieldNumber = 2, kKFieldNumber = 3, kK2FieldNumber = 5, kTxIdFieldNumber = 1, kTsFieldNumber = 4, kLatestFieldNumber = 6, }; // string table = 2; void clear_table() ; const std::string& table() const; template void set_table(Arg_&& arg, Args_... args); std::string* mutable_table(); PROTOBUF_NODISCARD std::string* release_table(); void set_allocated_table(std::string* value); private: const std::string& _internal_table() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_table( const std::string& value); std::string* _internal_mutable_table(); public: // bytes k = 3; void clear_k() ; const std::string& k() const; template void set_k(Arg_&& arg, Args_... args); std::string* mutable_k(); PROTOBUF_NODISCARD std::string* release_k(); void set_allocated_k(std::string* value); private: const std::string& _internal_k() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_k( const std::string& value); std::string* _internal_mutable_k(); public: // bytes k2 = 5; void clear_k2() ; const std::string& k2() const; template void set_k2(Arg_&& arg, Args_... args); std::string* mutable_k2(); PROTOBUF_NODISCARD std::string* release_k2(); void set_allocated_k2(std::string* value); private: const std::string& _internal_k2() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_k2( const std::string& value); std::string* _internal_mutable_k2(); public: // uint64 tx_id = 1; void clear_tx_id() ; ::uint64_t tx_id() const; void set_tx_id(::uint64_t value); private: ::uint64_t _internal_tx_id() const; void _internal_set_tx_id(::uint64_t value); public: // uint64 ts = 4; void clear_ts() ; ::uint64_t ts() const; void set_ts(::uint64_t value); private: ::uint64_t _internal_ts() const; void _internal_set_ts(::uint64_t value); public: // bool latest = 6; void clear_latest() ; bool latest() const; void set_latest(bool value); private: bool _internal_latest() const; void _internal_set_latest(bool value); public: // @@protoc_insertion_point(class_scope:remote.GetLatestReq) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 6, 0, 33, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetLatestReq_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetLatestReq& from_msg); ::google::protobuf::internal::ArenaStringPtr table_; ::google::protobuf::internal::ArenaStringPtr k_; ::google::protobuf::internal::ArenaStringPtr k2_; ::uint64_t tx_id_; ::uint64_t ts_; bool latest_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class GetLatestReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.GetLatestReply) */ { public: inline GetLatestReply() : GetLatestReply(nullptr) {} ~GetLatestReply() override; template explicit PROTOBUF_CONSTEXPR GetLatestReply( ::google::protobuf::internal::ConstantInitialized); inline GetLatestReply(const GetLatestReply& from) : GetLatestReply(nullptr, from) {} inline GetLatestReply(GetLatestReply&& from) noexcept : GetLatestReply(nullptr, std::move(from)) {} inline GetLatestReply& operator=(const GetLatestReply& from) { CopyFrom(from); return *this; } inline GetLatestReply& operator=(GetLatestReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetLatestReply& default_instance() { return *internal_default_instance(); } static inline const GetLatestReply* internal_default_instance() { return reinterpret_cast( &_GetLatestReply_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(GetLatestReply& a, GetLatestReply& b) { a.Swap(&b); } inline void Swap(GetLatestReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetLatestReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetLatestReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetLatestReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetLatestReply& from) { GetLatestReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetLatestReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.GetLatestReply"; } protected: explicit GetLatestReply(::google::protobuf::Arena* arena); GetLatestReply(::google::protobuf::Arena* arena, const GetLatestReply& from); GetLatestReply(::google::protobuf::Arena* arena, GetLatestReply&& from) noexcept : GetLatestReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kVFieldNumber = 1, kOkFieldNumber = 2, }; // bytes v = 1; void clear_v() ; const std::string& v() const; template void set_v(Arg_&& arg, Args_... args); std::string* mutable_v(); PROTOBUF_NODISCARD std::string* release_v(); void set_allocated_v(std::string* value); private: const std::string& _internal_v() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_v( const std::string& value); std::string* _internal_mutable_v(); public: // bool ok = 2; void clear_ok() ; bool ok() const; void set_ok(bool value); private: bool _internal_ok() const; void _internal_set_ok(bool value); public: // @@protoc_insertion_point(class_scope:remote.GetLatestReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetLatestReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetLatestReply& from_msg); ::google::protobuf::internal::ArenaStringPtr v_; bool ok_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class Cursor final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.Cursor) */ { public: inline Cursor() : Cursor(nullptr) {} ~Cursor() override; template explicit PROTOBUF_CONSTEXPR Cursor( ::google::protobuf::internal::ConstantInitialized); inline Cursor(const Cursor& from) : Cursor(nullptr, from) {} inline Cursor(Cursor&& from) noexcept : Cursor(nullptr, std::move(from)) {} inline Cursor& operator=(const Cursor& from) { CopyFrom(from); return *this; } inline Cursor& operator=(Cursor&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Cursor& default_instance() { return *internal_default_instance(); } static inline const Cursor* internal_default_instance() { return reinterpret_cast( &_Cursor_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(Cursor& a, Cursor& b) { a.Swap(&b); } inline void Swap(Cursor* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Cursor* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Cursor* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Cursor& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Cursor& from) { Cursor::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Cursor* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.Cursor"; } protected: explicit Cursor(::google::protobuf::Arena* arena); Cursor(::google::protobuf::Arena* arena, const Cursor& from); Cursor(::google::protobuf::Arena* arena, Cursor&& from) noexcept : Cursor(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBucketNameFieldNumber = 2, kKFieldNumber = 4, kVFieldNumber = 5, kOpFieldNumber = 1, kCursorFieldNumber = 3, }; // string bucket_name = 2; void clear_bucket_name() ; const std::string& bucket_name() const; template void set_bucket_name(Arg_&& arg, Args_... args); std::string* mutable_bucket_name(); PROTOBUF_NODISCARD std::string* release_bucket_name(); void set_allocated_bucket_name(std::string* value); private: const std::string& _internal_bucket_name() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_bucket_name( const std::string& value); std::string* _internal_mutable_bucket_name(); public: // bytes k = 4; void clear_k() ; const std::string& k() const; template void set_k(Arg_&& arg, Args_... args); std::string* mutable_k(); PROTOBUF_NODISCARD std::string* release_k(); void set_allocated_k(std::string* value); private: const std::string& _internal_k() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_k( const std::string& value); std::string* _internal_mutable_k(); public: // bytes v = 5; void clear_v() ; const std::string& v() const; template void set_v(Arg_&& arg, Args_... args); std::string* mutable_v(); PROTOBUF_NODISCARD std::string* release_v(); void set_allocated_v(std::string* value); private: const std::string& _internal_v() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_v( const std::string& value); std::string* _internal_mutable_v(); public: // .remote.Op op = 1; void clear_op() ; ::remote::Op op() const; void set_op(::remote::Op value); private: ::remote::Op _internal_op() const; void _internal_set_op(::remote::Op value); public: // uint32 cursor = 3; void clear_cursor() ; ::uint32_t cursor() const; void set_cursor(::uint32_t value); private: ::uint32_t _internal_cursor() const; void _internal_set_cursor(::uint32_t value); public: // @@protoc_insertion_point(class_scope:remote.Cursor) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 5, 0, 33, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Cursor_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Cursor& from_msg); ::google::protobuf::internal::ArenaStringPtr bucket_name_; ::google::protobuf::internal::ArenaStringPtr k_; ::google::protobuf::internal::ArenaStringPtr v_; int op_; ::uint32_t cursor_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class StorageChange final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.StorageChange) */ { public: inline StorageChange() : StorageChange(nullptr) {} ~StorageChange() override; template explicit PROTOBUF_CONSTEXPR StorageChange( ::google::protobuf::internal::ConstantInitialized); inline StorageChange(const StorageChange& from) : StorageChange(nullptr, from) {} inline StorageChange(StorageChange&& from) noexcept : StorageChange(nullptr, std::move(from)) {} inline StorageChange& operator=(const StorageChange& from) { CopyFrom(from); return *this; } inline StorageChange& operator=(StorageChange&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const StorageChange& default_instance() { return *internal_default_instance(); } static inline const StorageChange* internal_default_instance() { return reinterpret_cast( &_StorageChange_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(StorageChange& a, StorageChange& b) { a.Swap(&b); } inline void Swap(StorageChange* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StorageChange* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StorageChange* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const StorageChange& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const StorageChange& from) { StorageChange::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(StorageChange* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.StorageChange"; } protected: explicit StorageChange(::google::protobuf::Arena* arena); StorageChange(::google::protobuf::Arena* arena, const StorageChange& from); StorageChange(::google::protobuf::Arena* arena, StorageChange&& from) noexcept : StorageChange(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDataFieldNumber = 2, kLocationFieldNumber = 1, }; // bytes data = 2; void clear_data() ; const std::string& data() const; template void set_data(Arg_&& arg, Args_... args); std::string* mutable_data(); PROTOBUF_NODISCARD std::string* release_data(); void set_allocated_data(std::string* value); private: const std::string& _internal_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( const std::string& value); std::string* _internal_mutable_data(); public: // .types.H256 location = 1; bool has_location() const; void clear_location() ; const ::types::H256& location() const; PROTOBUF_NODISCARD ::types::H256* release_location(); ::types::H256* mutable_location(); void set_allocated_location(::types::H256* value); void unsafe_arena_set_allocated_location(::types::H256* value); ::types::H256* unsafe_arena_release_location(); private: const ::types::H256& _internal_location() const; ::types::H256* _internal_mutable_location(); public: // @@protoc_insertion_point(class_scope:remote.StorageChange) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_StorageChange_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const StorageChange& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr data_; ::types::H256* location_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class AccountChange final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.AccountChange) */ { public: inline AccountChange() : AccountChange(nullptr) {} ~AccountChange() override; template explicit PROTOBUF_CONSTEXPR AccountChange( ::google::protobuf::internal::ConstantInitialized); inline AccountChange(const AccountChange& from) : AccountChange(nullptr, from) {} inline AccountChange(AccountChange&& from) noexcept : AccountChange(nullptr, std::move(from)) {} inline AccountChange& operator=(const AccountChange& from) { CopyFrom(from); return *this; } inline AccountChange& operator=(AccountChange&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AccountChange& default_instance() { return *internal_default_instance(); } static inline const AccountChange* internal_default_instance() { return reinterpret_cast( &_AccountChange_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(AccountChange& a, AccountChange& b) { a.Swap(&b); } inline void Swap(AccountChange* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AccountChange* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AccountChange* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AccountChange& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AccountChange& from) { AccountChange::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AccountChange* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.AccountChange"; } protected: explicit AccountChange(::google::protobuf::Arena* arena); AccountChange(::google::protobuf::Arena* arena, const AccountChange& from); AccountChange(::google::protobuf::Arena* arena, AccountChange&& from) noexcept : AccountChange(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kStorageChangesFieldNumber = 6, kDataFieldNumber = 4, kCodeFieldNumber = 5, kAddressFieldNumber = 1, kIncarnationFieldNumber = 2, kActionFieldNumber = 3, }; // repeated .remote.StorageChange storage_changes = 6; int storage_changes_size() const; private: int _internal_storage_changes_size() const; public: void clear_storage_changes() ; ::remote::StorageChange* mutable_storage_changes(int index); ::google::protobuf::RepeatedPtrField<::remote::StorageChange>* mutable_storage_changes(); private: const ::google::protobuf::RepeatedPtrField<::remote::StorageChange>& _internal_storage_changes() const; ::google::protobuf::RepeatedPtrField<::remote::StorageChange>* _internal_mutable_storage_changes(); public: const ::remote::StorageChange& storage_changes(int index) const; ::remote::StorageChange* add_storage_changes(); const ::google::protobuf::RepeatedPtrField<::remote::StorageChange>& storage_changes() const; // bytes data = 4; void clear_data() ; const std::string& data() const; template void set_data(Arg_&& arg, Args_... args); std::string* mutable_data(); PROTOBUF_NODISCARD std::string* release_data(); void set_allocated_data(std::string* value); private: const std::string& _internal_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( const std::string& value); std::string* _internal_mutable_data(); public: // bytes code = 5; void clear_code() ; const std::string& code() const; template void set_code(Arg_&& arg, Args_... args); std::string* mutable_code(); PROTOBUF_NODISCARD std::string* release_code(); void set_allocated_code(std::string* value); private: const std::string& _internal_code() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_code( const std::string& value); std::string* _internal_mutable_code(); public: // .types.H160 address = 1; bool has_address() const; void clear_address() ; const ::types::H160& address() const; PROTOBUF_NODISCARD ::types::H160* release_address(); ::types::H160* mutable_address(); void set_allocated_address(::types::H160* value); void unsafe_arena_set_allocated_address(::types::H160* value); ::types::H160* unsafe_arena_release_address(); private: const ::types::H160& _internal_address() const; ::types::H160* _internal_mutable_address(); public: // uint64 incarnation = 2; void clear_incarnation() ; ::uint64_t incarnation() const; void set_incarnation(::uint64_t value); private: ::uint64_t _internal_incarnation() const; void _internal_set_incarnation(::uint64_t value); public: // .remote.Action action = 3; void clear_action() ; ::remote::Action action() const; void set_action(::remote::Action value); private: ::remote::Action _internal_action() const; void _internal_set_action(::remote::Action value); public: // @@protoc_insertion_point(class_scope:remote.AccountChange) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 6, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AccountChange_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AccountChange& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::remote::StorageChange > storage_changes_; ::google::protobuf::internal::ArenaStringPtr data_; ::google::protobuf::internal::ArenaStringPtr code_; ::types::H160* address_; ::uint64_t incarnation_; int action_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class StateChange final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.StateChange) */ { public: inline StateChange() : StateChange(nullptr) {} ~StateChange() override; template explicit PROTOBUF_CONSTEXPR StateChange( ::google::protobuf::internal::ConstantInitialized); inline StateChange(const StateChange& from) : StateChange(nullptr, from) {} inline StateChange(StateChange&& from) noexcept : StateChange(nullptr, std::move(from)) {} inline StateChange& operator=(const StateChange& from) { CopyFrom(from); return *this; } inline StateChange& operator=(StateChange&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const StateChange& default_instance() { return *internal_default_instance(); } static inline const StateChange* internal_default_instance() { return reinterpret_cast( &_StateChange_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(StateChange& a, StateChange& b) { a.Swap(&b); } inline void Swap(StateChange* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StateChange* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StateChange* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const StateChange& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const StateChange& from) { StateChange::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(StateChange* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.StateChange"; } protected: explicit StateChange(::google::protobuf::Arena* arena); StateChange(::google::protobuf::Arena* arena, const StateChange& from); StateChange(::google::protobuf::Arena* arena, StateChange&& from) noexcept : StateChange(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kChangesFieldNumber = 4, kTxsFieldNumber = 5, kBlockHashFieldNumber = 3, kBlockHeightFieldNumber = 2, kDirectionFieldNumber = 1, }; // repeated .remote.AccountChange changes = 4; int changes_size() const; private: int _internal_changes_size() const; public: void clear_changes() ; ::remote::AccountChange* mutable_changes(int index); ::google::protobuf::RepeatedPtrField<::remote::AccountChange>* mutable_changes(); private: const ::google::protobuf::RepeatedPtrField<::remote::AccountChange>& _internal_changes() const; ::google::protobuf::RepeatedPtrField<::remote::AccountChange>* _internal_mutable_changes(); public: const ::remote::AccountChange& changes(int index) const; ::remote::AccountChange* add_changes(); const ::google::protobuf::RepeatedPtrField<::remote::AccountChange>& changes() const; // repeated bytes txs = 5; int txs_size() const; private: int _internal_txs_size() const; public: void clear_txs() ; const std::string& txs(int index) const; std::string* mutable_txs(int index); void set_txs(int index, const std::string& value); void set_txs(int index, std::string&& value); void set_txs(int index, const char* value); void set_txs(int index, const void* value, std::size_t size); void set_txs(int index, absl::string_view value); std::string* add_txs(); void add_txs(const std::string& value); void add_txs(std::string&& value); void add_txs(const char* value); void add_txs(const void* value, std::size_t size); void add_txs(absl::string_view value); const ::google::protobuf::RepeatedPtrField& txs() const; ::google::protobuf::RepeatedPtrField* mutable_txs(); private: const ::google::protobuf::RepeatedPtrField& _internal_txs() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_txs(); public: // .types.H256 block_hash = 3; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // uint64 block_height = 2; void clear_block_height() ; ::uint64_t block_height() const; void set_block_height(::uint64_t value); private: ::uint64_t _internal_block_height() const; void _internal_set_block_height(::uint64_t value); public: // .remote.Direction direction = 1; void clear_direction() ; ::remote::Direction direction() const; void set_direction(::remote::Direction value); private: ::remote::Direction _internal_direction() const; void _internal_set_direction(::remote::Direction value); public: // @@protoc_insertion_point(class_scope:remote.StateChange) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 5, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_StateChange_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const StateChange& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField< ::remote::AccountChange > changes_; ::google::protobuf::RepeatedPtrField txs_; ::types::H256* block_hash_; ::uint64_t block_height_; int direction_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // ------------------------------------------------------------------- class StateChangeBatch final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:remote.StateChangeBatch) */ { public: inline StateChangeBatch() : StateChangeBatch(nullptr) {} ~StateChangeBatch() override; template explicit PROTOBUF_CONSTEXPR StateChangeBatch( ::google::protobuf::internal::ConstantInitialized); inline StateChangeBatch(const StateChangeBatch& from) : StateChangeBatch(nullptr, from) {} inline StateChangeBatch(StateChangeBatch&& from) noexcept : StateChangeBatch(nullptr, std::move(from)) {} inline StateChangeBatch& operator=(const StateChangeBatch& from) { CopyFrom(from); return *this; } inline StateChangeBatch& operator=(StateChangeBatch&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const StateChangeBatch& default_instance() { return *internal_default_instance(); } static inline const StateChangeBatch* internal_default_instance() { return reinterpret_cast( &_StateChangeBatch_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(StateChangeBatch& a, StateChangeBatch& b) { a.Swap(&b); } inline void Swap(StateChangeBatch* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StateChangeBatch* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StateChangeBatch* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const StateChangeBatch& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const StateChangeBatch& from) { StateChangeBatch::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(StateChangeBatch* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "remote.StateChangeBatch"; } protected: explicit StateChangeBatch(::google::protobuf::Arena* arena); StateChangeBatch(::google::protobuf::Arena* arena, const StateChangeBatch& from); StateChangeBatch(::google::protobuf::Arena* arena, StateChangeBatch&& from) noexcept : StateChangeBatch(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kChangeBatchFieldNumber = 2, kStateVersionIdFieldNumber = 1, kPendingBlockBaseFeeFieldNumber = 3, kBlockGasLimitFieldNumber = 4, kFinalizedBlockFieldNumber = 5, kPendingBlobFeePerGasFieldNumber = 6, }; // repeated .remote.StateChange change_batch = 2; int change_batch_size() const; private: int _internal_change_batch_size() const; public: void clear_change_batch() ; ::remote::StateChange* mutable_change_batch(int index); ::google::protobuf::RepeatedPtrField<::remote::StateChange>* mutable_change_batch(); private: const ::google::protobuf::RepeatedPtrField<::remote::StateChange>& _internal_change_batch() const; ::google::protobuf::RepeatedPtrField<::remote::StateChange>* _internal_mutable_change_batch(); public: const ::remote::StateChange& change_batch(int index) const; ::remote::StateChange* add_change_batch(); const ::google::protobuf::RepeatedPtrField<::remote::StateChange>& change_batch() const; // uint64 state_version_id = 1; void clear_state_version_id() ; ::uint64_t state_version_id() const; void set_state_version_id(::uint64_t value); private: ::uint64_t _internal_state_version_id() const; void _internal_set_state_version_id(::uint64_t value); public: // uint64 pending_block_base_fee = 3; void clear_pending_block_base_fee() ; ::uint64_t pending_block_base_fee() const; void set_pending_block_base_fee(::uint64_t value); private: ::uint64_t _internal_pending_block_base_fee() const; void _internal_set_pending_block_base_fee(::uint64_t value); public: // uint64 block_gas_limit = 4; void clear_block_gas_limit() ; ::uint64_t block_gas_limit() const; void set_block_gas_limit(::uint64_t value); private: ::uint64_t _internal_block_gas_limit() const; void _internal_set_block_gas_limit(::uint64_t value); public: // uint64 finalized_block = 5; void clear_finalized_block() ; ::uint64_t finalized_block() const; void set_finalized_block(::uint64_t value); private: ::uint64_t _internal_finalized_block() const; void _internal_set_finalized_block(::uint64_t value); public: // uint64 pending_blob_fee_per_gas = 6; void clear_pending_blob_fee_per_gas() ; ::uint64_t pending_blob_fee_per_gas() const; void set_pending_blob_fee_per_gas(::uint64_t value); private: ::uint64_t _internal_pending_blob_fee_per_gas() const; void _internal_set_pending_blob_fee_per_gas(::uint64_t value); public: // @@protoc_insertion_point(class_scope:remote.StateChangeBatch) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 6, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_StateChangeBatch_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const StateChangeBatch& from_msg); ::google::protobuf::RepeatedPtrField< ::remote::StateChange > change_batch_; ::uint64_t state_version_id_; ::uint64_t pending_block_base_fee_; ::uint64_t block_gas_limit_; ::uint64_t finalized_block_; ::uint64_t pending_blob_fee_per_gas_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_remote_2fkv_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // Cursor // .remote.Op op = 1; inline void Cursor::clear_op() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.op_ = 0; } inline ::remote::Op Cursor::op() const { // @@protoc_insertion_point(field_get:remote.Cursor.op) return _internal_op(); } inline void Cursor::set_op(::remote::Op value) { _internal_set_op(value); // @@protoc_insertion_point(field_set:remote.Cursor.op) } inline ::remote::Op Cursor::_internal_op() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::remote::Op>(_impl_.op_); } inline void Cursor::_internal_set_op(::remote::Op value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.op_ = value; } // string bucket_name = 2; inline void Cursor::clear_bucket_name() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bucket_name_.ClearToEmpty(); } inline const std::string& Cursor::bucket_name() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Cursor.bucket_name) return _internal_bucket_name(); } template inline PROTOBUF_ALWAYS_INLINE void Cursor::set_bucket_name(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bucket_name_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.Cursor.bucket_name) } inline std::string* Cursor::mutable_bucket_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_bucket_name(); // @@protoc_insertion_point(field_mutable:remote.Cursor.bucket_name) return _s; } inline const std::string& Cursor::_internal_bucket_name() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.bucket_name_.Get(); } inline void Cursor::_internal_set_bucket_name(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bucket_name_.Set(value, GetArena()); } inline std::string* Cursor::_internal_mutable_bucket_name() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.bucket_name_.Mutable( GetArena()); } inline std::string* Cursor::release_bucket_name() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.Cursor.bucket_name) return _impl_.bucket_name_.Release(); } inline void Cursor::set_allocated_bucket_name(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bucket_name_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.bucket_name_.IsDefault()) { _impl_.bucket_name_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.Cursor.bucket_name) } // uint32 cursor = 3; inline void Cursor::clear_cursor() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.cursor_ = 0u; } inline ::uint32_t Cursor::cursor() const { // @@protoc_insertion_point(field_get:remote.Cursor.cursor) return _internal_cursor(); } inline void Cursor::set_cursor(::uint32_t value) { _internal_set_cursor(value); // @@protoc_insertion_point(field_set:remote.Cursor.cursor) } inline ::uint32_t Cursor::_internal_cursor() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.cursor_; } inline void Cursor::_internal_set_cursor(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.cursor_ = value; } // bytes k = 4; inline void Cursor::clear_k() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.ClearToEmpty(); } inline const std::string& Cursor::k() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Cursor.k) return _internal_k(); } template inline PROTOBUF_ALWAYS_INLINE void Cursor::set_k(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.Cursor.k) } inline std::string* Cursor::mutable_k() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_k(); // @@protoc_insertion_point(field_mutable:remote.Cursor.k) return _s; } inline const std::string& Cursor::_internal_k() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.k_.Get(); } inline void Cursor::_internal_set_k(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.Set(value, GetArena()); } inline std::string* Cursor::_internal_mutable_k() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.k_.Mutable( GetArena()); } inline std::string* Cursor::release_k() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.Cursor.k) return _impl_.k_.Release(); } inline void Cursor::set_allocated_k(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.k_.IsDefault()) { _impl_.k_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.Cursor.k) } // bytes v = 5; inline void Cursor::clear_v() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.ClearToEmpty(); } inline const std::string& Cursor::v() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Cursor.v) return _internal_v(); } template inline PROTOBUF_ALWAYS_INLINE void Cursor::set_v(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.Cursor.v) } inline std::string* Cursor::mutable_v() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_v(); // @@protoc_insertion_point(field_mutable:remote.Cursor.v) return _s; } inline const std::string& Cursor::_internal_v() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.v_.Get(); } inline void Cursor::_internal_set_v(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.Set(value, GetArena()); } inline std::string* Cursor::_internal_mutable_v() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.v_.Mutable( GetArena()); } inline std::string* Cursor::release_v() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.Cursor.v) return _impl_.v_.Release(); } inline void Cursor::set_allocated_v(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.v_.IsDefault()) { _impl_.v_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.Cursor.v) } // ------------------------------------------------------------------- // Pair // bytes k = 1; inline void Pair::clear_k() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.ClearToEmpty(); } inline const std::string& Pair::k() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Pair.k) return _internal_k(); } template inline PROTOBUF_ALWAYS_INLINE void Pair::set_k(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.Pair.k) } inline std::string* Pair::mutable_k() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_k(); // @@protoc_insertion_point(field_mutable:remote.Pair.k) return _s; } inline const std::string& Pair::_internal_k() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.k_.Get(); } inline void Pair::_internal_set_k(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.Set(value, GetArena()); } inline std::string* Pair::_internal_mutable_k() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.k_.Mutable( GetArena()); } inline std::string* Pair::release_k() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.Pair.k) return _impl_.k_.Release(); } inline void Pair::set_allocated_k(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.k_.IsDefault()) { _impl_.k_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.Pair.k) } // bytes v = 2; inline void Pair::clear_v() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.ClearToEmpty(); } inline const std::string& Pair::v() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Pair.v) return _internal_v(); } template inline PROTOBUF_ALWAYS_INLINE void Pair::set_v(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.Pair.v) } inline std::string* Pair::mutable_v() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_v(); // @@protoc_insertion_point(field_mutable:remote.Pair.v) return _s; } inline const std::string& Pair::_internal_v() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.v_.Get(); } inline void Pair::_internal_set_v(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.Set(value, GetArena()); } inline std::string* Pair::_internal_mutable_v() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.v_.Mutable( GetArena()); } inline std::string* Pair::release_v() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.Pair.v) return _impl_.v_.Release(); } inline void Pair::set_allocated_v(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.v_.IsDefault()) { _impl_.v_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.Pair.v) } // uint32 cursor_id = 3; inline void Pair::clear_cursor_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.cursor_id_ = 0u; } inline ::uint32_t Pair::cursor_id() const { // @@protoc_insertion_point(field_get:remote.Pair.cursor_id) return _internal_cursor_id(); } inline void Pair::set_cursor_id(::uint32_t value) { _internal_set_cursor_id(value); // @@protoc_insertion_point(field_set:remote.Pair.cursor_id) } inline ::uint32_t Pair::_internal_cursor_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.cursor_id_; } inline void Pair::_internal_set_cursor_id(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.cursor_id_ = value; } // uint64 view_id = 4; inline void Pair::clear_view_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.view_id_ = ::uint64_t{0u}; } inline ::uint64_t Pair::view_id() const { // @@protoc_insertion_point(field_get:remote.Pair.view_id) return _internal_view_id(); } inline void Pair::set_view_id(::uint64_t value) { _internal_set_view_id(value); // @@protoc_insertion_point(field_set:remote.Pair.view_id) } inline ::uint64_t Pair::_internal_view_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.view_id_; } inline void Pair::_internal_set_view_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.view_id_ = value; } // uint64 tx_id = 5; inline void Pair::clear_tx_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = ::uint64_t{0u}; } inline ::uint64_t Pair::tx_id() const { // @@protoc_insertion_point(field_get:remote.Pair.tx_id) return _internal_tx_id(); } inline void Pair::set_tx_id(::uint64_t value) { _internal_set_tx_id(value); // @@protoc_insertion_point(field_set:remote.Pair.tx_id) } inline ::uint64_t Pair::_internal_tx_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_id_; } inline void Pair::_internal_set_tx_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = value; } // ------------------------------------------------------------------- // StorageChange // .types.H256 location = 1; inline bool StorageChange::has_location() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.location_ != nullptr); return value; } inline const ::types::H256& StorageChange::_internal_location() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.location_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& StorageChange::location() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.StorageChange.location) return _internal_location(); } inline void StorageChange::unsafe_arena_set_allocated_location(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.location_); } _impl_.location_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.StorageChange.location) } inline ::types::H256* StorageChange::release_location() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.location_; _impl_.location_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* StorageChange::unsafe_arena_release_location() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.StorageChange.location) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.location_; _impl_.location_ = nullptr; return temp; } inline ::types::H256* StorageChange::_internal_mutable_location() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.location_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.location_ = reinterpret_cast<::types::H256*>(p); } return _impl_.location_; } inline ::types::H256* StorageChange::mutable_location() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_location(); // @@protoc_insertion_point(field_mutable:remote.StorageChange.location) return _msg; } inline void StorageChange::set_allocated_location(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.location_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.location_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.StorageChange.location) } // bytes data = 2; inline void StorageChange::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.ClearToEmpty(); } inline const std::string& StorageChange::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.StorageChange.data) return _internal_data(); } template inline PROTOBUF_ALWAYS_INLINE void StorageChange::set_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.StorageChange.data) } inline std::string* StorageChange::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:remote.StorageChange.data) return _s; } inline const std::string& StorageChange::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.data_.Get(); } inline void StorageChange::_internal_set_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.Set(value, GetArena()); } inline std::string* StorageChange::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.data_.Mutable( GetArena()); } inline std::string* StorageChange::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.StorageChange.data) return _impl_.data_.Release(); } inline void StorageChange::set_allocated_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.data_.IsDefault()) { _impl_.data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.StorageChange.data) } // ------------------------------------------------------------------- // AccountChange // .types.H160 address = 1; inline bool AccountChange::has_address() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); return value; } inline const ::types::H160& AccountChange::_internal_address() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.address_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& AccountChange::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.AccountChange.address) return _internal_address(); } inline void AccountChange::unsafe_arena_set_allocated_address(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } _impl_.address_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.AccountChange.address) } inline ::types::H160* AccountChange::release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.address_; _impl_.address_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* AccountChange::unsafe_arena_release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.AccountChange.address) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.address_; _impl_.address_ = nullptr; return temp; } inline ::types::H160* AccountChange::_internal_mutable_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.address_ = reinterpret_cast<::types::H160*>(p); } return _impl_.address_; } inline ::types::H160* AccountChange::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_address(); // @@protoc_insertion_point(field_mutable:remote.AccountChange.address) return _msg; } inline void AccountChange::set_allocated_address(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.address_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:remote.AccountChange.address) } // uint64 incarnation = 2; inline void AccountChange::clear_incarnation() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.incarnation_ = ::uint64_t{0u}; } inline ::uint64_t AccountChange::incarnation() const { // @@protoc_insertion_point(field_get:remote.AccountChange.incarnation) return _internal_incarnation(); } inline void AccountChange::set_incarnation(::uint64_t value) { _internal_set_incarnation(value); // @@protoc_insertion_point(field_set:remote.AccountChange.incarnation) } inline ::uint64_t AccountChange::_internal_incarnation() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.incarnation_; } inline void AccountChange::_internal_set_incarnation(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.incarnation_ = value; } // .remote.Action action = 3; inline void AccountChange::clear_action() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.action_ = 0; } inline ::remote::Action AccountChange::action() const { // @@protoc_insertion_point(field_get:remote.AccountChange.action) return _internal_action(); } inline void AccountChange::set_action(::remote::Action value) { _internal_set_action(value); // @@protoc_insertion_point(field_set:remote.AccountChange.action) } inline ::remote::Action AccountChange::_internal_action() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::remote::Action>(_impl_.action_); } inline void AccountChange::_internal_set_action(::remote::Action value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.action_ = value; } // bytes data = 4; inline void AccountChange::clear_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.ClearToEmpty(); } inline const std::string& AccountChange::data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.AccountChange.data) return _internal_data(); } template inline PROTOBUF_ALWAYS_INLINE void AccountChange::set_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.AccountChange.data) } inline std::string* AccountChange::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:remote.AccountChange.data) return _s; } inline const std::string& AccountChange::_internal_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.data_.Get(); } inline void AccountChange::_internal_set_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.Set(value, GetArena()); } inline std::string* AccountChange::_internal_mutable_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.data_.Mutable( GetArena()); } inline std::string* AccountChange::release_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.AccountChange.data) return _impl_.data_.Release(); } inline void AccountChange::set_allocated_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.data_.IsDefault()) { _impl_.data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.AccountChange.data) } // bytes code = 5; inline void AccountChange::clear_code() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.code_.ClearToEmpty(); } inline const std::string& AccountChange::code() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.AccountChange.code) return _internal_code(); } template inline PROTOBUF_ALWAYS_INLINE void AccountChange::set_code(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.code_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.AccountChange.code) } inline std::string* AccountChange::mutable_code() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_code(); // @@protoc_insertion_point(field_mutable:remote.AccountChange.code) return _s; } inline const std::string& AccountChange::_internal_code() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.code_.Get(); } inline void AccountChange::_internal_set_code(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.code_.Set(value, GetArena()); } inline std::string* AccountChange::_internal_mutable_code() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.code_.Mutable( GetArena()); } inline std::string* AccountChange::release_code() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.AccountChange.code) return _impl_.code_.Release(); } inline void AccountChange::set_allocated_code(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.code_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.code_.IsDefault()) { _impl_.code_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.AccountChange.code) } // repeated .remote.StorageChange storage_changes = 6; inline int AccountChange::_internal_storage_changes_size() const { return _internal_storage_changes().size(); } inline int AccountChange::storage_changes_size() const { return _internal_storage_changes_size(); } inline void AccountChange::clear_storage_changes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.storage_changes_.Clear(); } inline ::remote::StorageChange* AccountChange::mutable_storage_changes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.AccountChange.storage_changes) return _internal_mutable_storage_changes()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::remote::StorageChange>* AccountChange::mutable_storage_changes() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.AccountChange.storage_changes) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_storage_changes(); } inline const ::remote::StorageChange& AccountChange::storage_changes(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.AccountChange.storage_changes) return _internal_storage_changes().Get(index); } inline ::remote::StorageChange* AccountChange::add_storage_changes() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::remote::StorageChange* _add = _internal_mutable_storage_changes()->Add(); // @@protoc_insertion_point(field_add:remote.AccountChange.storage_changes) return _add; } inline const ::google::protobuf::RepeatedPtrField<::remote::StorageChange>& AccountChange::storage_changes() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.AccountChange.storage_changes) return _internal_storage_changes(); } inline const ::google::protobuf::RepeatedPtrField<::remote::StorageChange>& AccountChange::_internal_storage_changes() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.storage_changes_; } inline ::google::protobuf::RepeatedPtrField<::remote::StorageChange>* AccountChange::_internal_mutable_storage_changes() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.storage_changes_; } // ------------------------------------------------------------------- // StateChangeBatch // uint64 state_version_id = 1; inline void StateChangeBatch::clear_state_version_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.state_version_id_ = ::uint64_t{0u}; } inline ::uint64_t StateChangeBatch::state_version_id() const { // @@protoc_insertion_point(field_get:remote.StateChangeBatch.state_version_id) return _internal_state_version_id(); } inline void StateChangeBatch::set_state_version_id(::uint64_t value) { _internal_set_state_version_id(value); // @@protoc_insertion_point(field_set:remote.StateChangeBatch.state_version_id) } inline ::uint64_t StateChangeBatch::_internal_state_version_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.state_version_id_; } inline void StateChangeBatch::_internal_set_state_version_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.state_version_id_ = value; } // repeated .remote.StateChange change_batch = 2; inline int StateChangeBatch::_internal_change_batch_size() const { return _internal_change_batch().size(); } inline int StateChangeBatch::change_batch_size() const { return _internal_change_batch_size(); } inline void StateChangeBatch::clear_change_batch() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.change_batch_.Clear(); } inline ::remote::StateChange* StateChangeBatch::mutable_change_batch(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.StateChangeBatch.change_batch) return _internal_mutable_change_batch()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::remote::StateChange>* StateChangeBatch::mutable_change_batch() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.StateChangeBatch.change_batch) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_change_batch(); } inline const ::remote::StateChange& StateChangeBatch::change_batch(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.StateChangeBatch.change_batch) return _internal_change_batch().Get(index); } inline ::remote::StateChange* StateChangeBatch::add_change_batch() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::remote::StateChange* _add = _internal_mutable_change_batch()->Add(); // @@protoc_insertion_point(field_add:remote.StateChangeBatch.change_batch) return _add; } inline const ::google::protobuf::RepeatedPtrField<::remote::StateChange>& StateChangeBatch::change_batch() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.StateChangeBatch.change_batch) return _internal_change_batch(); } inline const ::google::protobuf::RepeatedPtrField<::remote::StateChange>& StateChangeBatch::_internal_change_batch() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.change_batch_; } inline ::google::protobuf::RepeatedPtrField<::remote::StateChange>* StateChangeBatch::_internal_mutable_change_batch() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.change_batch_; } // uint64 pending_block_base_fee = 3; inline void StateChangeBatch::clear_pending_block_base_fee() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pending_block_base_fee_ = ::uint64_t{0u}; } inline ::uint64_t StateChangeBatch::pending_block_base_fee() const { // @@protoc_insertion_point(field_get:remote.StateChangeBatch.pending_block_base_fee) return _internal_pending_block_base_fee(); } inline void StateChangeBatch::set_pending_block_base_fee(::uint64_t value) { _internal_set_pending_block_base_fee(value); // @@protoc_insertion_point(field_set:remote.StateChangeBatch.pending_block_base_fee) } inline ::uint64_t StateChangeBatch::_internal_pending_block_base_fee() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.pending_block_base_fee_; } inline void StateChangeBatch::_internal_set_pending_block_base_fee(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pending_block_base_fee_ = value; } // uint64 block_gas_limit = 4; inline void StateChangeBatch::clear_block_gas_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_gas_limit_ = ::uint64_t{0u}; } inline ::uint64_t StateChangeBatch::block_gas_limit() const { // @@protoc_insertion_point(field_get:remote.StateChangeBatch.block_gas_limit) return _internal_block_gas_limit(); } inline void StateChangeBatch::set_block_gas_limit(::uint64_t value) { _internal_set_block_gas_limit(value); // @@protoc_insertion_point(field_set:remote.StateChangeBatch.block_gas_limit) } inline ::uint64_t StateChangeBatch::_internal_block_gas_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_gas_limit_; } inline void StateChangeBatch::_internal_set_block_gas_limit(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_gas_limit_ = value; } // uint64 finalized_block = 5; inline void StateChangeBatch::clear_finalized_block() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.finalized_block_ = ::uint64_t{0u}; } inline ::uint64_t StateChangeBatch::finalized_block() const { // @@protoc_insertion_point(field_get:remote.StateChangeBatch.finalized_block) return _internal_finalized_block(); } inline void StateChangeBatch::set_finalized_block(::uint64_t value) { _internal_set_finalized_block(value); // @@protoc_insertion_point(field_set:remote.StateChangeBatch.finalized_block) } inline ::uint64_t StateChangeBatch::_internal_finalized_block() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.finalized_block_; } inline void StateChangeBatch::_internal_set_finalized_block(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.finalized_block_ = value; } // uint64 pending_blob_fee_per_gas = 6; inline void StateChangeBatch::clear_pending_blob_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pending_blob_fee_per_gas_ = ::uint64_t{0u}; } inline ::uint64_t StateChangeBatch::pending_blob_fee_per_gas() const { // @@protoc_insertion_point(field_get:remote.StateChangeBatch.pending_blob_fee_per_gas) return _internal_pending_blob_fee_per_gas(); } inline void StateChangeBatch::set_pending_blob_fee_per_gas(::uint64_t value) { _internal_set_pending_blob_fee_per_gas(value); // @@protoc_insertion_point(field_set:remote.StateChangeBatch.pending_blob_fee_per_gas) } inline ::uint64_t StateChangeBatch::_internal_pending_blob_fee_per_gas() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.pending_blob_fee_per_gas_; } inline void StateChangeBatch::_internal_set_pending_blob_fee_per_gas(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pending_blob_fee_per_gas_ = value; } // ------------------------------------------------------------------- // StateChange // .remote.Direction direction = 1; inline void StateChange::clear_direction() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.direction_ = 0; } inline ::remote::Direction StateChange::direction() const { // @@protoc_insertion_point(field_get:remote.StateChange.direction) return _internal_direction(); } inline void StateChange::set_direction(::remote::Direction value) { _internal_set_direction(value); // @@protoc_insertion_point(field_set:remote.StateChange.direction) } inline ::remote::Direction StateChange::_internal_direction() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::remote::Direction>(_impl_.direction_); } inline void StateChange::_internal_set_direction(::remote::Direction value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.direction_ = value; } // uint64 block_height = 2; inline void StateChange::clear_block_height() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_height_ = ::uint64_t{0u}; } inline ::uint64_t StateChange::block_height() const { // @@protoc_insertion_point(field_get:remote.StateChange.block_height) return _internal_block_height(); } inline void StateChange::set_block_height(::uint64_t value) { _internal_set_block_height(value); // @@protoc_insertion_point(field_set:remote.StateChange.block_height) } inline ::uint64_t StateChange::_internal_block_height() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_height_; } inline void StateChange::_internal_set_block_height(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_height_ = value; } // .types.H256 block_hash = 3; inline bool StateChange::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline const ::types::H256& StateChange::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& StateChange::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.StateChange.block_hash) return _internal_block_hash(); } inline void StateChange::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.StateChange.block_hash) } inline ::types::H256* StateChange::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* StateChange::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.StateChange.block_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* StateChange::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* StateChange::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:remote.StateChange.block_hash) return _msg; } inline void StateChange::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:remote.StateChange.block_hash) } // repeated .remote.AccountChange changes = 4; inline int StateChange::_internal_changes_size() const { return _internal_changes().size(); } inline int StateChange::changes_size() const { return _internal_changes_size(); } inline void StateChange::clear_changes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.changes_.Clear(); } inline ::remote::AccountChange* StateChange::mutable_changes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.StateChange.changes) return _internal_mutable_changes()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::remote::AccountChange>* StateChange::mutable_changes() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.StateChange.changes) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_changes(); } inline const ::remote::AccountChange& StateChange::changes(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.StateChange.changes) return _internal_changes().Get(index); } inline ::remote::AccountChange* StateChange::add_changes() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::remote::AccountChange* _add = _internal_mutable_changes()->Add(); // @@protoc_insertion_point(field_add:remote.StateChange.changes) return _add; } inline const ::google::protobuf::RepeatedPtrField<::remote::AccountChange>& StateChange::changes() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.StateChange.changes) return _internal_changes(); } inline const ::google::protobuf::RepeatedPtrField<::remote::AccountChange>& StateChange::_internal_changes() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.changes_; } inline ::google::protobuf::RepeatedPtrField<::remote::AccountChange>* StateChange::_internal_mutable_changes() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.changes_; } // repeated bytes txs = 5; inline int StateChange::_internal_txs_size() const { return _internal_txs().size(); } inline int StateChange::txs_size() const { return _internal_txs_size(); } inline void StateChange::clear_txs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.txs_.Clear(); } inline std::string* StateChange::add_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_txs()->Add(); // @@protoc_insertion_point(field_add_mutable:remote.StateChange.txs) return _s; } inline const std::string& StateChange::txs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.StateChange.txs) return _internal_txs().Get(index); } inline std::string* StateChange::mutable_txs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.StateChange.txs) return _internal_mutable_txs()->Mutable(index); } inline void StateChange::set_txs(int index, const std::string& value) { _internal_mutable_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:remote.StateChange.txs) } inline void StateChange::set_txs(int index, std::string&& value) { _internal_mutable_txs()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:remote.StateChange.txs) } inline void StateChange::set_txs(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:remote.StateChange.txs) } inline void StateChange::set_txs(int index, const void* value, std::size_t size) { _internal_mutable_txs()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:remote.StateChange.txs) } inline void StateChange::set_txs(int index, absl::string_view value) { _internal_mutable_txs()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:remote.StateChange.txs) } inline void StateChange::add_txs(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add:remote.StateChange.txs) } inline void StateChange::add_txs(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_txs()->Add(std::move(value)); // @@protoc_insertion_point(field_add:remote.StateChange.txs) } inline void StateChange::add_txs(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:remote.StateChange.txs) } inline void StateChange::add_txs(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_txs()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:remote.StateChange.txs) } inline void StateChange::add_txs(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_txs()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:remote.StateChange.txs) } inline const ::google::protobuf::RepeatedPtrField& StateChange::txs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.StateChange.txs) return _internal_txs(); } inline ::google::protobuf::RepeatedPtrField* StateChange::mutable_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.StateChange.txs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_txs(); } inline const ::google::protobuf::RepeatedPtrField& StateChange::_internal_txs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.txs_; } inline ::google::protobuf::RepeatedPtrField* StateChange::_internal_mutable_txs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.txs_; } // ------------------------------------------------------------------- // StateChangeRequest // bool with_storage = 1; inline void StateChangeRequest::clear_with_storage() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.with_storage_ = false; } inline bool StateChangeRequest::with_storage() const { // @@protoc_insertion_point(field_get:remote.StateChangeRequest.with_storage) return _internal_with_storage(); } inline void StateChangeRequest::set_with_storage(bool value) { _internal_set_with_storage(value); // @@protoc_insertion_point(field_set:remote.StateChangeRequest.with_storage) } inline bool StateChangeRequest::_internal_with_storage() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.with_storage_; } inline void StateChangeRequest::_internal_set_with_storage(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.with_storage_ = value; } // bool with_transactions = 2; inline void StateChangeRequest::clear_with_transactions() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.with_transactions_ = false; } inline bool StateChangeRequest::with_transactions() const { // @@protoc_insertion_point(field_get:remote.StateChangeRequest.with_transactions) return _internal_with_transactions(); } inline void StateChangeRequest::set_with_transactions(bool value) { _internal_set_with_transactions(value); // @@protoc_insertion_point(field_set:remote.StateChangeRequest.with_transactions) } inline bool StateChangeRequest::_internal_with_transactions() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.with_transactions_; } inline void StateChangeRequest::_internal_set_with_transactions(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.with_transactions_ = value; } // ------------------------------------------------------------------- // SnapshotsRequest // ------------------------------------------------------------------- // SnapshotsReply // repeated string blocks_files = 1; inline int SnapshotsReply::_internal_blocks_files_size() const { return _internal_blocks_files().size(); } inline int SnapshotsReply::blocks_files_size() const { return _internal_blocks_files_size(); } inline void SnapshotsReply::clear_blocks_files() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blocks_files_.Clear(); } inline std::string* SnapshotsReply::add_blocks_files() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_blocks_files()->Add(); // @@protoc_insertion_point(field_add_mutable:remote.SnapshotsReply.blocks_files) return _s; } inline const std::string& SnapshotsReply::blocks_files(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SnapshotsReply.blocks_files) return _internal_blocks_files().Get(index); } inline std::string* SnapshotsReply::mutable_blocks_files(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.SnapshotsReply.blocks_files) return _internal_mutable_blocks_files()->Mutable(index); } inline void SnapshotsReply::set_blocks_files(int index, const std::string& value) { _internal_mutable_blocks_files()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::set_blocks_files(int index, std::string&& value) { _internal_mutable_blocks_files()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::set_blocks_files(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_blocks_files()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::set_blocks_files(int index, const char* value, std::size_t size) { _internal_mutable_blocks_files()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::set_blocks_files(int index, absl::string_view value) { _internal_mutable_blocks_files()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::add_blocks_files(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blocks_files()->Add()->assign(value); // @@protoc_insertion_point(field_add:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::add_blocks_files(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blocks_files()->Add(std::move(value)); // @@protoc_insertion_point(field_add:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::add_blocks_files(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blocks_files()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::add_blocks_files(const char* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blocks_files()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:remote.SnapshotsReply.blocks_files) } inline void SnapshotsReply::add_blocks_files(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blocks_files()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:remote.SnapshotsReply.blocks_files) } inline const ::google::protobuf::RepeatedPtrField& SnapshotsReply::blocks_files() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.SnapshotsReply.blocks_files) return _internal_blocks_files(); } inline ::google::protobuf::RepeatedPtrField* SnapshotsReply::mutable_blocks_files() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.SnapshotsReply.blocks_files) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_blocks_files(); } inline const ::google::protobuf::RepeatedPtrField& SnapshotsReply::_internal_blocks_files() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.blocks_files_; } inline ::google::protobuf::RepeatedPtrField* SnapshotsReply::_internal_mutable_blocks_files() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.blocks_files_; } // repeated string history_files = 2; inline int SnapshotsReply::_internal_history_files_size() const { return _internal_history_files().size(); } inline int SnapshotsReply::history_files_size() const { return _internal_history_files_size(); } inline void SnapshotsReply::clear_history_files() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.history_files_.Clear(); } inline std::string* SnapshotsReply::add_history_files() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_history_files()->Add(); // @@protoc_insertion_point(field_add_mutable:remote.SnapshotsReply.history_files) return _s; } inline const std::string& SnapshotsReply::history_files(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.SnapshotsReply.history_files) return _internal_history_files().Get(index); } inline std::string* SnapshotsReply::mutable_history_files(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.SnapshotsReply.history_files) return _internal_mutable_history_files()->Mutable(index); } inline void SnapshotsReply::set_history_files(int index, const std::string& value) { _internal_mutable_history_files()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::set_history_files(int index, std::string&& value) { _internal_mutable_history_files()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::set_history_files(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_history_files()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::set_history_files(int index, const char* value, std::size_t size) { _internal_mutable_history_files()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::set_history_files(int index, absl::string_view value) { _internal_mutable_history_files()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::add_history_files(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_history_files()->Add()->assign(value); // @@protoc_insertion_point(field_add:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::add_history_files(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_history_files()->Add(std::move(value)); // @@protoc_insertion_point(field_add:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::add_history_files(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_history_files()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::add_history_files(const char* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_history_files()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:remote.SnapshotsReply.history_files) } inline void SnapshotsReply::add_history_files(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_history_files()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:remote.SnapshotsReply.history_files) } inline const ::google::protobuf::RepeatedPtrField& SnapshotsReply::history_files() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.SnapshotsReply.history_files) return _internal_history_files(); } inline ::google::protobuf::RepeatedPtrField* SnapshotsReply::mutable_history_files() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.SnapshotsReply.history_files) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_history_files(); } inline const ::google::protobuf::RepeatedPtrField& SnapshotsReply::_internal_history_files() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.history_files_; } inline ::google::protobuf::RepeatedPtrField* SnapshotsReply::_internal_mutable_history_files() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.history_files_; } // ------------------------------------------------------------------- // RangeReq // uint64 tx_id = 1; inline void RangeReq::clear_tx_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = ::uint64_t{0u}; } inline ::uint64_t RangeReq::tx_id() const { // @@protoc_insertion_point(field_get:remote.RangeReq.tx_id) return _internal_tx_id(); } inline void RangeReq::set_tx_id(::uint64_t value) { _internal_set_tx_id(value); // @@protoc_insertion_point(field_set:remote.RangeReq.tx_id) } inline ::uint64_t RangeReq::_internal_tx_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_id_; } inline void RangeReq::_internal_set_tx_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = value; } // string table = 2; inline void RangeReq::clear_table() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.ClearToEmpty(); } inline const std::string& RangeReq::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeReq.table) return _internal_table(); } template inline PROTOBUF_ALWAYS_INLINE void RangeReq::set_table(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeReq.table) } inline std::string* RangeReq::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_table(); // @@protoc_insertion_point(field_mutable:remote.RangeReq.table) return _s; } inline const std::string& RangeReq::_internal_table() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.table_.Get(); } inline void RangeReq::_internal_set_table(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(value, GetArena()); } inline std::string* RangeReq::_internal_mutable_table() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.table_.Mutable( GetArena()); } inline std::string* RangeReq::release_table() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeReq.table) return _impl_.table_.Release(); } inline void RangeReq::set_allocated_table(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_.IsDefault()) { _impl_.table_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeReq.table) } // bytes from_prefix = 3; inline void RangeReq::clear_from_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_prefix_.ClearToEmpty(); } inline const std::string& RangeReq::from_prefix() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeReq.from_prefix) return _internal_from_prefix(); } template inline PROTOBUF_ALWAYS_INLINE void RangeReq::set_from_prefix(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_prefix_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeReq.from_prefix) } inline std::string* RangeReq::mutable_from_prefix() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_from_prefix(); // @@protoc_insertion_point(field_mutable:remote.RangeReq.from_prefix) return _s; } inline const std::string& RangeReq::_internal_from_prefix() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.from_prefix_.Get(); } inline void RangeReq::_internal_set_from_prefix(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_prefix_.Set(value, GetArena()); } inline std::string* RangeReq::_internal_mutable_from_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.from_prefix_.Mutable( GetArena()); } inline std::string* RangeReq::release_from_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeReq.from_prefix) return _impl_.from_prefix_.Release(); } inline void RangeReq::set_allocated_from_prefix(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_prefix_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.from_prefix_.IsDefault()) { _impl_.from_prefix_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeReq.from_prefix) } // bytes to_prefix = 4; inline void RangeReq::clear_to_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_prefix_.ClearToEmpty(); } inline const std::string& RangeReq::to_prefix() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeReq.to_prefix) return _internal_to_prefix(); } template inline PROTOBUF_ALWAYS_INLINE void RangeReq::set_to_prefix(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_prefix_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeReq.to_prefix) } inline std::string* RangeReq::mutable_to_prefix() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_to_prefix(); // @@protoc_insertion_point(field_mutable:remote.RangeReq.to_prefix) return _s; } inline const std::string& RangeReq::_internal_to_prefix() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.to_prefix_.Get(); } inline void RangeReq::_internal_set_to_prefix(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_prefix_.Set(value, GetArena()); } inline std::string* RangeReq::_internal_mutable_to_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.to_prefix_.Mutable( GetArena()); } inline std::string* RangeReq::release_to_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeReq.to_prefix) return _impl_.to_prefix_.Release(); } inline void RangeReq::set_allocated_to_prefix(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_prefix_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.to_prefix_.IsDefault()) { _impl_.to_prefix_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeReq.to_prefix) } // bool order_ascend = 5; inline void RangeReq::clear_order_ascend() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = false; } inline bool RangeReq::order_ascend() const { // @@protoc_insertion_point(field_get:remote.RangeReq.order_ascend) return _internal_order_ascend(); } inline void RangeReq::set_order_ascend(bool value) { _internal_set_order_ascend(value); // @@protoc_insertion_point(field_set:remote.RangeReq.order_ascend) } inline bool RangeReq::_internal_order_ascend() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.order_ascend_; } inline void RangeReq::_internal_set_order_ascend(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = value; } // sint64 limit = 6; inline void RangeReq::clear_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = ::int64_t{0}; } inline ::int64_t RangeReq::limit() const { // @@protoc_insertion_point(field_get:remote.RangeReq.limit) return _internal_limit(); } inline void RangeReq::set_limit(::int64_t value) { _internal_set_limit(value); // @@protoc_insertion_point(field_set:remote.RangeReq.limit) } inline ::int64_t RangeReq::_internal_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.limit_; } inline void RangeReq::_internal_set_limit(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = value; } // int32 page_size = 7; inline void RangeReq::clear_page_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = 0; } inline ::int32_t RangeReq::page_size() const { // @@protoc_insertion_point(field_get:remote.RangeReq.page_size) return _internal_page_size(); } inline void RangeReq::set_page_size(::int32_t value) { _internal_set_page_size(value); // @@protoc_insertion_point(field_set:remote.RangeReq.page_size) } inline ::int32_t RangeReq::_internal_page_size() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_size_; } inline void RangeReq::_internal_set_page_size(::int32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = value; } // string page_token = 8; inline void RangeReq::clear_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.ClearToEmpty(); } inline const std::string& RangeReq::page_token() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeReq.page_token) return _internal_page_token(); } template inline PROTOBUF_ALWAYS_INLINE void RangeReq::set_page_token(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeReq.page_token) } inline std::string* RangeReq::mutable_page_token() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_page_token(); // @@protoc_insertion_point(field_mutable:remote.RangeReq.page_token) return _s; } inline const std::string& RangeReq::_internal_page_token() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_token_.Get(); } inline void RangeReq::_internal_set_page_token(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(value, GetArena()); } inline std::string* RangeReq::_internal_mutable_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.page_token_.Mutable( GetArena()); } inline std::string* RangeReq::release_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeReq.page_token) return _impl_.page_token_.Release(); } inline void RangeReq::set_allocated_page_token(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.page_token_.IsDefault()) { _impl_.page_token_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeReq.page_token) } // ------------------------------------------------------------------- // GetLatestReq // uint64 tx_id = 1; inline void GetLatestReq::clear_tx_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = ::uint64_t{0u}; } inline ::uint64_t GetLatestReq::tx_id() const { // @@protoc_insertion_point(field_get:remote.GetLatestReq.tx_id) return _internal_tx_id(); } inline void GetLatestReq::set_tx_id(::uint64_t value) { _internal_set_tx_id(value); // @@protoc_insertion_point(field_set:remote.GetLatestReq.tx_id) } inline ::uint64_t GetLatestReq::_internal_tx_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_id_; } inline void GetLatestReq::_internal_set_tx_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = value; } // string table = 2; inline void GetLatestReq::clear_table() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.ClearToEmpty(); } inline const std::string& GetLatestReq::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.GetLatestReq.table) return _internal_table(); } template inline PROTOBUF_ALWAYS_INLINE void GetLatestReq::set_table(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.GetLatestReq.table) } inline std::string* GetLatestReq::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_table(); // @@protoc_insertion_point(field_mutable:remote.GetLatestReq.table) return _s; } inline const std::string& GetLatestReq::_internal_table() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.table_.Get(); } inline void GetLatestReq::_internal_set_table(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(value, GetArena()); } inline std::string* GetLatestReq::_internal_mutable_table() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.table_.Mutable( GetArena()); } inline std::string* GetLatestReq::release_table() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.GetLatestReq.table) return _impl_.table_.Release(); } inline void GetLatestReq::set_allocated_table(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_.IsDefault()) { _impl_.table_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.GetLatestReq.table) } // bytes k = 3; inline void GetLatestReq::clear_k() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.ClearToEmpty(); } inline const std::string& GetLatestReq::k() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.GetLatestReq.k) return _internal_k(); } template inline PROTOBUF_ALWAYS_INLINE void GetLatestReq::set_k(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.GetLatestReq.k) } inline std::string* GetLatestReq::mutable_k() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_k(); // @@protoc_insertion_point(field_mutable:remote.GetLatestReq.k) return _s; } inline const std::string& GetLatestReq::_internal_k() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.k_.Get(); } inline void GetLatestReq::_internal_set_k(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.Set(value, GetArena()); } inline std::string* GetLatestReq::_internal_mutable_k() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.k_.Mutable( GetArena()); } inline std::string* GetLatestReq::release_k() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.GetLatestReq.k) return _impl_.k_.Release(); } inline void GetLatestReq::set_allocated_k(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.k_.IsDefault()) { _impl_.k_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.GetLatestReq.k) } // uint64 ts = 4; inline void GetLatestReq::clear_ts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ts_ = ::uint64_t{0u}; } inline ::uint64_t GetLatestReq::ts() const { // @@protoc_insertion_point(field_get:remote.GetLatestReq.ts) return _internal_ts(); } inline void GetLatestReq::set_ts(::uint64_t value) { _internal_set_ts(value); // @@protoc_insertion_point(field_set:remote.GetLatestReq.ts) } inline ::uint64_t GetLatestReq::_internal_ts() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ts_; } inline void GetLatestReq::_internal_set_ts(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ts_ = value; } // bytes k2 = 5; inline void GetLatestReq::clear_k2() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k2_.ClearToEmpty(); } inline const std::string& GetLatestReq::k2() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.GetLatestReq.k2) return _internal_k2(); } template inline PROTOBUF_ALWAYS_INLINE void GetLatestReq::set_k2(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k2_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.GetLatestReq.k2) } inline std::string* GetLatestReq::mutable_k2() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_k2(); // @@protoc_insertion_point(field_mutable:remote.GetLatestReq.k2) return _s; } inline const std::string& GetLatestReq::_internal_k2() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.k2_.Get(); } inline void GetLatestReq::_internal_set_k2(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k2_.Set(value, GetArena()); } inline std::string* GetLatestReq::_internal_mutable_k2() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.k2_.Mutable( GetArena()); } inline std::string* GetLatestReq::release_k2() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.GetLatestReq.k2) return _impl_.k2_.Release(); } inline void GetLatestReq::set_allocated_k2(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k2_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.k2_.IsDefault()) { _impl_.k2_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.GetLatestReq.k2) } // bool latest = 6; inline void GetLatestReq::clear_latest() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latest_ = false; } inline bool GetLatestReq::latest() const { // @@protoc_insertion_point(field_get:remote.GetLatestReq.latest) return _internal_latest(); } inline void GetLatestReq::set_latest(bool value) { _internal_set_latest(value); // @@protoc_insertion_point(field_set:remote.GetLatestReq.latest) } inline bool GetLatestReq::_internal_latest() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.latest_; } inline void GetLatestReq::_internal_set_latest(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latest_ = value; } // ------------------------------------------------------------------- // GetLatestReply // bytes v = 1; inline void GetLatestReply::clear_v() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.ClearToEmpty(); } inline const std::string& GetLatestReply::v() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.GetLatestReply.v) return _internal_v(); } template inline PROTOBUF_ALWAYS_INLINE void GetLatestReply::set_v(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.GetLatestReply.v) } inline std::string* GetLatestReply::mutable_v() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_v(); // @@protoc_insertion_point(field_mutable:remote.GetLatestReply.v) return _s; } inline const std::string& GetLatestReply::_internal_v() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.v_.Get(); } inline void GetLatestReply::_internal_set_v(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.Set(value, GetArena()); } inline std::string* GetLatestReply::_internal_mutable_v() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.v_.Mutable( GetArena()); } inline std::string* GetLatestReply::release_v() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.GetLatestReply.v) return _impl_.v_.Release(); } inline void GetLatestReply::set_allocated_v(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.v_.IsDefault()) { _impl_.v_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.GetLatestReply.v) } // bool ok = 2; inline void GetLatestReply::clear_ok() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = false; } inline bool GetLatestReply::ok() const { // @@protoc_insertion_point(field_get:remote.GetLatestReply.ok) return _internal_ok(); } inline void GetLatestReply::set_ok(bool value) { _internal_set_ok(value); // @@protoc_insertion_point(field_set:remote.GetLatestReply.ok) } inline bool GetLatestReply::_internal_ok() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ok_; } inline void GetLatestReply::_internal_set_ok(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = value; } // ------------------------------------------------------------------- // HistorySeekReq // uint64 tx_id = 1; inline void HistorySeekReq::clear_tx_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = ::uint64_t{0u}; } inline ::uint64_t HistorySeekReq::tx_id() const { // @@protoc_insertion_point(field_get:remote.HistorySeekReq.tx_id) return _internal_tx_id(); } inline void HistorySeekReq::set_tx_id(::uint64_t value) { _internal_set_tx_id(value); // @@protoc_insertion_point(field_set:remote.HistorySeekReq.tx_id) } inline ::uint64_t HistorySeekReq::_internal_tx_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_id_; } inline void HistorySeekReq::_internal_set_tx_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = value; } // string table = 2; inline void HistorySeekReq::clear_table() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.ClearToEmpty(); } inline const std::string& HistorySeekReq::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.HistorySeekReq.table) return _internal_table(); } template inline PROTOBUF_ALWAYS_INLINE void HistorySeekReq::set_table(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.HistorySeekReq.table) } inline std::string* HistorySeekReq::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_table(); // @@protoc_insertion_point(field_mutable:remote.HistorySeekReq.table) return _s; } inline const std::string& HistorySeekReq::_internal_table() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.table_.Get(); } inline void HistorySeekReq::_internal_set_table(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(value, GetArena()); } inline std::string* HistorySeekReq::_internal_mutable_table() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.table_.Mutable( GetArena()); } inline std::string* HistorySeekReq::release_table() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.HistorySeekReq.table) return _impl_.table_.Release(); } inline void HistorySeekReq::set_allocated_table(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_.IsDefault()) { _impl_.table_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.HistorySeekReq.table) } // bytes k = 3; inline void HistorySeekReq::clear_k() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.ClearToEmpty(); } inline const std::string& HistorySeekReq::k() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.HistorySeekReq.k) return _internal_k(); } template inline PROTOBUF_ALWAYS_INLINE void HistorySeekReq::set_k(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.HistorySeekReq.k) } inline std::string* HistorySeekReq::mutable_k() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_k(); // @@protoc_insertion_point(field_mutable:remote.HistorySeekReq.k) return _s; } inline const std::string& HistorySeekReq::_internal_k() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.k_.Get(); } inline void HistorySeekReq::_internal_set_k(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.Set(value, GetArena()); } inline std::string* HistorySeekReq::_internal_mutable_k() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.k_.Mutable( GetArena()); } inline std::string* HistorySeekReq::release_k() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.HistorySeekReq.k) return _impl_.k_.Release(); } inline void HistorySeekReq::set_allocated_k(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.k_.IsDefault()) { _impl_.k_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.HistorySeekReq.k) } // uint64 ts = 4; inline void HistorySeekReq::clear_ts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ts_ = ::uint64_t{0u}; } inline ::uint64_t HistorySeekReq::ts() const { // @@protoc_insertion_point(field_get:remote.HistorySeekReq.ts) return _internal_ts(); } inline void HistorySeekReq::set_ts(::uint64_t value) { _internal_set_ts(value); // @@protoc_insertion_point(field_set:remote.HistorySeekReq.ts) } inline ::uint64_t HistorySeekReq::_internal_ts() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ts_; } inline void HistorySeekReq::_internal_set_ts(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ts_ = value; } // ------------------------------------------------------------------- // HistorySeekReply // bytes v = 1; inline void HistorySeekReply::clear_v() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.ClearToEmpty(); } inline const std::string& HistorySeekReply::v() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.HistorySeekReply.v) return _internal_v(); } template inline PROTOBUF_ALWAYS_INLINE void HistorySeekReply::set_v(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.HistorySeekReply.v) } inline std::string* HistorySeekReply::mutable_v() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_v(); // @@protoc_insertion_point(field_mutable:remote.HistorySeekReply.v) return _s; } inline const std::string& HistorySeekReply::_internal_v() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.v_.Get(); } inline void HistorySeekReply::_internal_set_v(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.Set(value, GetArena()); } inline std::string* HistorySeekReply::_internal_mutable_v() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.v_.Mutable( GetArena()); } inline std::string* HistorySeekReply::release_v() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.HistorySeekReply.v) return _impl_.v_.Release(); } inline void HistorySeekReply::set_allocated_v(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.v_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.v_.IsDefault()) { _impl_.v_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.HistorySeekReply.v) } // bool ok = 2; inline void HistorySeekReply::clear_ok() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = false; } inline bool HistorySeekReply::ok() const { // @@protoc_insertion_point(field_get:remote.HistorySeekReply.ok) return _internal_ok(); } inline void HistorySeekReply::set_ok(bool value) { _internal_set_ok(value); // @@protoc_insertion_point(field_set:remote.HistorySeekReply.ok) } inline bool HistorySeekReply::_internal_ok() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ok_; } inline void HistorySeekReply::_internal_set_ok(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = value; } // ------------------------------------------------------------------- // IndexRangeReq // uint64 tx_id = 1; inline void IndexRangeReq::clear_tx_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = ::uint64_t{0u}; } inline ::uint64_t IndexRangeReq::tx_id() const { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.tx_id) return _internal_tx_id(); } inline void IndexRangeReq::set_tx_id(::uint64_t value) { _internal_set_tx_id(value); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.tx_id) } inline ::uint64_t IndexRangeReq::_internal_tx_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_id_; } inline void IndexRangeReq::_internal_set_tx_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = value; } // string table = 2; inline void IndexRangeReq::clear_table() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.ClearToEmpty(); } inline const std::string& IndexRangeReq::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.table) return _internal_table(); } template inline PROTOBUF_ALWAYS_INLINE void IndexRangeReq::set_table(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.table) } inline std::string* IndexRangeReq::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_table(); // @@protoc_insertion_point(field_mutable:remote.IndexRangeReq.table) return _s; } inline const std::string& IndexRangeReq::_internal_table() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.table_.Get(); } inline void IndexRangeReq::_internal_set_table(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(value, GetArena()); } inline std::string* IndexRangeReq::_internal_mutable_table() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.table_.Mutable( GetArena()); } inline std::string* IndexRangeReq::release_table() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.IndexRangeReq.table) return _impl_.table_.Release(); } inline void IndexRangeReq::set_allocated_table(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_.IsDefault()) { _impl_.table_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.IndexRangeReq.table) } // bytes k = 3; inline void IndexRangeReq::clear_k() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.ClearToEmpty(); } inline const std::string& IndexRangeReq::k() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.k) return _internal_k(); } template inline PROTOBUF_ALWAYS_INLINE void IndexRangeReq::set_k(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.k) } inline std::string* IndexRangeReq::mutable_k() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_k(); // @@protoc_insertion_point(field_mutable:remote.IndexRangeReq.k) return _s; } inline const std::string& IndexRangeReq::_internal_k() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.k_.Get(); } inline void IndexRangeReq::_internal_set_k(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.Set(value, GetArena()); } inline std::string* IndexRangeReq::_internal_mutable_k() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.k_.Mutable( GetArena()); } inline std::string* IndexRangeReq::release_k() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.IndexRangeReq.k) return _impl_.k_.Release(); } inline void IndexRangeReq::set_allocated_k(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.k_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.k_.IsDefault()) { _impl_.k_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.IndexRangeReq.k) } // sint64 from_ts = 4; inline void IndexRangeReq::clear_from_ts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_ts_ = ::int64_t{0}; } inline ::int64_t IndexRangeReq::from_ts() const { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.from_ts) return _internal_from_ts(); } inline void IndexRangeReq::set_from_ts(::int64_t value) { _internal_set_from_ts(value); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.from_ts) } inline ::int64_t IndexRangeReq::_internal_from_ts() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.from_ts_; } inline void IndexRangeReq::_internal_set_from_ts(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_ts_ = value; } // sint64 to_ts = 5; inline void IndexRangeReq::clear_to_ts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_ts_ = ::int64_t{0}; } inline ::int64_t IndexRangeReq::to_ts() const { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.to_ts) return _internal_to_ts(); } inline void IndexRangeReq::set_to_ts(::int64_t value) { _internal_set_to_ts(value); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.to_ts) } inline ::int64_t IndexRangeReq::_internal_to_ts() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.to_ts_; } inline void IndexRangeReq::_internal_set_to_ts(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_ts_ = value; } // bool order_ascend = 6; inline void IndexRangeReq::clear_order_ascend() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = false; } inline bool IndexRangeReq::order_ascend() const { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.order_ascend) return _internal_order_ascend(); } inline void IndexRangeReq::set_order_ascend(bool value) { _internal_set_order_ascend(value); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.order_ascend) } inline bool IndexRangeReq::_internal_order_ascend() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.order_ascend_; } inline void IndexRangeReq::_internal_set_order_ascend(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = value; } // sint64 limit = 7; inline void IndexRangeReq::clear_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = ::int64_t{0}; } inline ::int64_t IndexRangeReq::limit() const { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.limit) return _internal_limit(); } inline void IndexRangeReq::set_limit(::int64_t value) { _internal_set_limit(value); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.limit) } inline ::int64_t IndexRangeReq::_internal_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.limit_; } inline void IndexRangeReq::_internal_set_limit(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = value; } // int32 page_size = 8; inline void IndexRangeReq::clear_page_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = 0; } inline ::int32_t IndexRangeReq::page_size() const { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.page_size) return _internal_page_size(); } inline void IndexRangeReq::set_page_size(::int32_t value) { _internal_set_page_size(value); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.page_size) } inline ::int32_t IndexRangeReq::_internal_page_size() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_size_; } inline void IndexRangeReq::_internal_set_page_size(::int32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = value; } // string page_token = 9; inline void IndexRangeReq::clear_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.ClearToEmpty(); } inline const std::string& IndexRangeReq::page_token() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.IndexRangeReq.page_token) return _internal_page_token(); } template inline PROTOBUF_ALWAYS_INLINE void IndexRangeReq::set_page_token(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.IndexRangeReq.page_token) } inline std::string* IndexRangeReq::mutable_page_token() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_page_token(); // @@protoc_insertion_point(field_mutable:remote.IndexRangeReq.page_token) return _s; } inline const std::string& IndexRangeReq::_internal_page_token() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_token_.Get(); } inline void IndexRangeReq::_internal_set_page_token(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(value, GetArena()); } inline std::string* IndexRangeReq::_internal_mutable_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.page_token_.Mutable( GetArena()); } inline std::string* IndexRangeReq::release_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.IndexRangeReq.page_token) return _impl_.page_token_.Release(); } inline void IndexRangeReq::set_allocated_page_token(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.page_token_.IsDefault()) { _impl_.page_token_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.IndexRangeReq.page_token) } // ------------------------------------------------------------------- // IndexRangeReply // repeated uint64 timestamps = 1; inline int IndexRangeReply::_internal_timestamps_size() const { return _internal_timestamps().size(); } inline int IndexRangeReply::timestamps_size() const { return _internal_timestamps_size(); } inline void IndexRangeReply::clear_timestamps() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamps_.Clear(); } inline ::uint64_t IndexRangeReply::timestamps(int index) const { // @@protoc_insertion_point(field_get:remote.IndexRangeReply.timestamps) return _internal_timestamps().Get(index); } inline void IndexRangeReply::set_timestamps(int index, ::uint64_t value) { _internal_mutable_timestamps()->Set(index, value); // @@protoc_insertion_point(field_set:remote.IndexRangeReply.timestamps) } inline void IndexRangeReply::add_timestamps(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_timestamps()->Add(value); // @@protoc_insertion_point(field_add:remote.IndexRangeReply.timestamps) } inline const ::google::protobuf::RepeatedField<::uint64_t>& IndexRangeReply::timestamps() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.IndexRangeReply.timestamps) return _internal_timestamps(); } inline ::google::protobuf::RepeatedField<::uint64_t>* IndexRangeReply::mutable_timestamps() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.IndexRangeReply.timestamps) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_timestamps(); } inline const ::google::protobuf::RepeatedField<::uint64_t>& IndexRangeReply::_internal_timestamps() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.timestamps_; } inline ::google::protobuf::RepeatedField<::uint64_t>* IndexRangeReply::_internal_mutable_timestamps() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.timestamps_; } // string next_page_token = 2; inline void IndexRangeReply::clear_next_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.ClearToEmpty(); } inline const std::string& IndexRangeReply::next_page_token() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.IndexRangeReply.next_page_token) return _internal_next_page_token(); } template inline PROTOBUF_ALWAYS_INLINE void IndexRangeReply::set_next_page_token(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.IndexRangeReply.next_page_token) } inline std::string* IndexRangeReply::mutable_next_page_token() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_next_page_token(); // @@protoc_insertion_point(field_mutable:remote.IndexRangeReply.next_page_token) return _s; } inline const std::string& IndexRangeReply::_internal_next_page_token() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.next_page_token_.Get(); } inline void IndexRangeReply::_internal_set_next_page_token(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.Set(value, GetArena()); } inline std::string* IndexRangeReply::_internal_mutable_next_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.next_page_token_.Mutable( GetArena()); } inline std::string* IndexRangeReply::release_next_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.IndexRangeReply.next_page_token) return _impl_.next_page_token_.Release(); } inline void IndexRangeReply::set_allocated_next_page_token(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.next_page_token_.IsDefault()) { _impl_.next_page_token_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.IndexRangeReply.next_page_token) } // ------------------------------------------------------------------- // HistoryRangeReq // uint64 tx_id = 1; inline void HistoryRangeReq::clear_tx_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = ::uint64_t{0u}; } inline ::uint64_t HistoryRangeReq::tx_id() const { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.tx_id) return _internal_tx_id(); } inline void HistoryRangeReq::set_tx_id(::uint64_t value) { _internal_set_tx_id(value); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.tx_id) } inline ::uint64_t HistoryRangeReq::_internal_tx_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_id_; } inline void HistoryRangeReq::_internal_set_tx_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = value; } // string table = 2; inline void HistoryRangeReq::clear_table() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.ClearToEmpty(); } inline const std::string& HistoryRangeReq::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.table) return _internal_table(); } template inline PROTOBUF_ALWAYS_INLINE void HistoryRangeReq::set_table(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.table) } inline std::string* HistoryRangeReq::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_table(); // @@protoc_insertion_point(field_mutable:remote.HistoryRangeReq.table) return _s; } inline const std::string& HistoryRangeReq::_internal_table() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.table_.Get(); } inline void HistoryRangeReq::_internal_set_table(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(value, GetArena()); } inline std::string* HistoryRangeReq::_internal_mutable_table() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.table_.Mutable( GetArena()); } inline std::string* HistoryRangeReq::release_table() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.HistoryRangeReq.table) return _impl_.table_.Release(); } inline void HistoryRangeReq::set_allocated_table(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_.IsDefault()) { _impl_.table_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.HistoryRangeReq.table) } // sint64 from_ts = 4; inline void HistoryRangeReq::clear_from_ts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_ts_ = ::int64_t{0}; } inline ::int64_t HistoryRangeReq::from_ts() const { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.from_ts) return _internal_from_ts(); } inline void HistoryRangeReq::set_from_ts(::int64_t value) { _internal_set_from_ts(value); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.from_ts) } inline ::int64_t HistoryRangeReq::_internal_from_ts() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.from_ts_; } inline void HistoryRangeReq::_internal_set_from_ts(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_ts_ = value; } // sint64 to_ts = 5; inline void HistoryRangeReq::clear_to_ts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_ts_ = ::int64_t{0}; } inline ::int64_t HistoryRangeReq::to_ts() const { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.to_ts) return _internal_to_ts(); } inline void HistoryRangeReq::set_to_ts(::int64_t value) { _internal_set_to_ts(value); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.to_ts) } inline ::int64_t HistoryRangeReq::_internal_to_ts() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.to_ts_; } inline void HistoryRangeReq::_internal_set_to_ts(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_ts_ = value; } // bool order_ascend = 6; inline void HistoryRangeReq::clear_order_ascend() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = false; } inline bool HistoryRangeReq::order_ascend() const { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.order_ascend) return _internal_order_ascend(); } inline void HistoryRangeReq::set_order_ascend(bool value) { _internal_set_order_ascend(value); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.order_ascend) } inline bool HistoryRangeReq::_internal_order_ascend() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.order_ascend_; } inline void HistoryRangeReq::_internal_set_order_ascend(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = value; } // sint64 limit = 7; inline void HistoryRangeReq::clear_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = ::int64_t{0}; } inline ::int64_t HistoryRangeReq::limit() const { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.limit) return _internal_limit(); } inline void HistoryRangeReq::set_limit(::int64_t value) { _internal_set_limit(value); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.limit) } inline ::int64_t HistoryRangeReq::_internal_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.limit_; } inline void HistoryRangeReq::_internal_set_limit(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = value; } // int32 page_size = 8; inline void HistoryRangeReq::clear_page_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = 0; } inline ::int32_t HistoryRangeReq::page_size() const { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.page_size) return _internal_page_size(); } inline void HistoryRangeReq::set_page_size(::int32_t value) { _internal_set_page_size(value); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.page_size) } inline ::int32_t HistoryRangeReq::_internal_page_size() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_size_; } inline void HistoryRangeReq::_internal_set_page_size(::int32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = value; } // string page_token = 9; inline void HistoryRangeReq::clear_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.ClearToEmpty(); } inline const std::string& HistoryRangeReq::page_token() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.HistoryRangeReq.page_token) return _internal_page_token(); } template inline PROTOBUF_ALWAYS_INLINE void HistoryRangeReq::set_page_token(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.HistoryRangeReq.page_token) } inline std::string* HistoryRangeReq::mutable_page_token() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_page_token(); // @@protoc_insertion_point(field_mutable:remote.HistoryRangeReq.page_token) return _s; } inline const std::string& HistoryRangeReq::_internal_page_token() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_token_.Get(); } inline void HistoryRangeReq::_internal_set_page_token(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(value, GetArena()); } inline std::string* HistoryRangeReq::_internal_mutable_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.page_token_.Mutable( GetArena()); } inline std::string* HistoryRangeReq::release_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.HistoryRangeReq.page_token) return _impl_.page_token_.Release(); } inline void HistoryRangeReq::set_allocated_page_token(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.page_token_.IsDefault()) { _impl_.page_token_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.HistoryRangeReq.page_token) } // ------------------------------------------------------------------- // RangeAsOfReq // uint64 tx_id = 1; inline void RangeAsOfReq::clear_tx_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = ::uint64_t{0u}; } inline ::uint64_t RangeAsOfReq::tx_id() const { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.tx_id) return _internal_tx_id(); } inline void RangeAsOfReq::set_tx_id(::uint64_t value) { _internal_set_tx_id(value); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.tx_id) } inline ::uint64_t RangeAsOfReq::_internal_tx_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.tx_id_; } inline void RangeAsOfReq::_internal_set_tx_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tx_id_ = value; } // string table = 2; inline void RangeAsOfReq::clear_table() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.ClearToEmpty(); } inline const std::string& RangeAsOfReq::table() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.table) return _internal_table(); } template inline PROTOBUF_ALWAYS_INLINE void RangeAsOfReq::set_table(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.table) } inline std::string* RangeAsOfReq::mutable_table() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_table(); // @@protoc_insertion_point(field_mutable:remote.RangeAsOfReq.table) return _s; } inline const std::string& RangeAsOfReq::_internal_table() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.table_.Get(); } inline void RangeAsOfReq::_internal_set_table(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.Set(value, GetArena()); } inline std::string* RangeAsOfReq::_internal_mutable_table() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.table_.Mutable( GetArena()); } inline std::string* RangeAsOfReq::release_table() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeAsOfReq.table) return _impl_.table_.Release(); } inline void RangeAsOfReq::set_allocated_table(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.table_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_.IsDefault()) { _impl_.table_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeAsOfReq.table) } // bytes from_key = 3; inline void RangeAsOfReq::clear_from_key() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_key_.ClearToEmpty(); } inline const std::string& RangeAsOfReq::from_key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.from_key) return _internal_from_key(); } template inline PROTOBUF_ALWAYS_INLINE void RangeAsOfReq::set_from_key(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.from_key) } inline std::string* RangeAsOfReq::mutable_from_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_from_key(); // @@protoc_insertion_point(field_mutable:remote.RangeAsOfReq.from_key) return _s; } inline const std::string& RangeAsOfReq::_internal_from_key() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.from_key_.Get(); } inline void RangeAsOfReq::_internal_set_from_key(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_key_.Set(value, GetArena()); } inline std::string* RangeAsOfReq::_internal_mutable_from_key() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.from_key_.Mutable( GetArena()); } inline std::string* RangeAsOfReq::release_from_key() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeAsOfReq.from_key) return _impl_.from_key_.Release(); } inline void RangeAsOfReq::set_allocated_from_key(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.from_key_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.from_key_.IsDefault()) { _impl_.from_key_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeAsOfReq.from_key) } // bytes to_key = 4; inline void RangeAsOfReq::clear_to_key() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_key_.ClearToEmpty(); } inline const std::string& RangeAsOfReq::to_key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.to_key) return _internal_to_key(); } template inline PROTOBUF_ALWAYS_INLINE void RangeAsOfReq::set_to_key(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.to_key) } inline std::string* RangeAsOfReq::mutable_to_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_to_key(); // @@protoc_insertion_point(field_mutable:remote.RangeAsOfReq.to_key) return _s; } inline const std::string& RangeAsOfReq::_internal_to_key() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.to_key_.Get(); } inline void RangeAsOfReq::_internal_set_to_key(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_key_.Set(value, GetArena()); } inline std::string* RangeAsOfReq::_internal_mutable_to_key() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.to_key_.Mutable( GetArena()); } inline std::string* RangeAsOfReq::release_to_key() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeAsOfReq.to_key) return _impl_.to_key_.Release(); } inline void RangeAsOfReq::set_allocated_to_key(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.to_key_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.to_key_.IsDefault()) { _impl_.to_key_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeAsOfReq.to_key) } // uint64 ts = 5; inline void RangeAsOfReq::clear_ts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ts_ = ::uint64_t{0u}; } inline ::uint64_t RangeAsOfReq::ts() const { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.ts) return _internal_ts(); } inline void RangeAsOfReq::set_ts(::uint64_t value) { _internal_set_ts(value); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.ts) } inline ::uint64_t RangeAsOfReq::_internal_ts() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ts_; } inline void RangeAsOfReq::_internal_set_ts(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ts_ = value; } // bool latest = 6; inline void RangeAsOfReq::clear_latest() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latest_ = false; } inline bool RangeAsOfReq::latest() const { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.latest) return _internal_latest(); } inline void RangeAsOfReq::set_latest(bool value) { _internal_set_latest(value); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.latest) } inline bool RangeAsOfReq::_internal_latest() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.latest_; } inline void RangeAsOfReq::_internal_set_latest(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.latest_ = value; } // bool order_ascend = 7; inline void RangeAsOfReq::clear_order_ascend() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = false; } inline bool RangeAsOfReq::order_ascend() const { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.order_ascend) return _internal_order_ascend(); } inline void RangeAsOfReq::set_order_ascend(bool value) { _internal_set_order_ascend(value); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.order_ascend) } inline bool RangeAsOfReq::_internal_order_ascend() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.order_ascend_; } inline void RangeAsOfReq::_internal_set_order_ascend(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.order_ascend_ = value; } // sint64 limit = 8; inline void RangeAsOfReq::clear_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = ::int64_t{0}; } inline ::int64_t RangeAsOfReq::limit() const { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.limit) return _internal_limit(); } inline void RangeAsOfReq::set_limit(::int64_t value) { _internal_set_limit(value); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.limit) } inline ::int64_t RangeAsOfReq::_internal_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.limit_; } inline void RangeAsOfReq::_internal_set_limit(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = value; } // int32 page_size = 9; inline void RangeAsOfReq::clear_page_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = 0; } inline ::int32_t RangeAsOfReq::page_size() const { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.page_size) return _internal_page_size(); } inline void RangeAsOfReq::set_page_size(::int32_t value) { _internal_set_page_size(value); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.page_size) } inline ::int32_t RangeAsOfReq::_internal_page_size() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_size_; } inline void RangeAsOfReq::_internal_set_page_size(::int32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_size_ = value; } // string page_token = 10; inline void RangeAsOfReq::clear_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.ClearToEmpty(); } inline const std::string& RangeAsOfReq::page_token() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.RangeAsOfReq.page_token) return _internal_page_token(); } template inline PROTOBUF_ALWAYS_INLINE void RangeAsOfReq::set_page_token(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.RangeAsOfReq.page_token) } inline std::string* RangeAsOfReq::mutable_page_token() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_page_token(); // @@protoc_insertion_point(field_mutable:remote.RangeAsOfReq.page_token) return _s; } inline const std::string& RangeAsOfReq::_internal_page_token() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.page_token_.Get(); } inline void RangeAsOfReq::_internal_set_page_token(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.Set(value, GetArena()); } inline std::string* RangeAsOfReq::_internal_mutable_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.page_token_.Mutable( GetArena()); } inline std::string* RangeAsOfReq::release_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.RangeAsOfReq.page_token) return _impl_.page_token_.Release(); } inline void RangeAsOfReq::set_allocated_page_token(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.page_token_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.page_token_.IsDefault()) { _impl_.page_token_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.RangeAsOfReq.page_token) } // ------------------------------------------------------------------- // Pairs // repeated bytes keys = 1; inline int Pairs::_internal_keys_size() const { return _internal_keys().size(); } inline int Pairs::keys_size() const { return _internal_keys_size(); } inline void Pairs::clear_keys() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.keys_.Clear(); } inline std::string* Pairs::add_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_keys()->Add(); // @@protoc_insertion_point(field_add_mutable:remote.Pairs.keys) return _s; } inline const std::string& Pairs::keys(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Pairs.keys) return _internal_keys().Get(index); } inline std::string* Pairs::mutable_keys(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.Pairs.keys) return _internal_mutable_keys()->Mutable(index); } inline void Pairs::set_keys(int index, const std::string& value) { _internal_mutable_keys()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:remote.Pairs.keys) } inline void Pairs::set_keys(int index, std::string&& value) { _internal_mutable_keys()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:remote.Pairs.keys) } inline void Pairs::set_keys(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_keys()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:remote.Pairs.keys) } inline void Pairs::set_keys(int index, const void* value, std::size_t size) { _internal_mutable_keys()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:remote.Pairs.keys) } inline void Pairs::set_keys(int index, absl::string_view value) { _internal_mutable_keys()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:remote.Pairs.keys) } inline void Pairs::add_keys(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_keys()->Add()->assign(value); // @@protoc_insertion_point(field_add:remote.Pairs.keys) } inline void Pairs::add_keys(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_keys()->Add(std::move(value)); // @@protoc_insertion_point(field_add:remote.Pairs.keys) } inline void Pairs::add_keys(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_keys()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:remote.Pairs.keys) } inline void Pairs::add_keys(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_keys()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:remote.Pairs.keys) } inline void Pairs::add_keys(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_keys()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:remote.Pairs.keys) } inline const ::google::protobuf::RepeatedPtrField& Pairs::keys() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.Pairs.keys) return _internal_keys(); } inline ::google::protobuf::RepeatedPtrField* Pairs::mutable_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.Pairs.keys) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_keys(); } inline const ::google::protobuf::RepeatedPtrField& Pairs::_internal_keys() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.keys_; } inline ::google::protobuf::RepeatedPtrField* Pairs::_internal_mutable_keys() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.keys_; } // repeated bytes values = 2; inline int Pairs::_internal_values_size() const { return _internal_values().size(); } inline int Pairs::values_size() const { return _internal_values_size(); } inline void Pairs::clear_values() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.values_.Clear(); } inline std::string* Pairs::add_values() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_values()->Add(); // @@protoc_insertion_point(field_add_mutable:remote.Pairs.values) return _s; } inline const std::string& Pairs::values(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Pairs.values) return _internal_values().Get(index); } inline std::string* Pairs::mutable_values(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:remote.Pairs.values) return _internal_mutable_values()->Mutable(index); } inline void Pairs::set_values(int index, const std::string& value) { _internal_mutable_values()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:remote.Pairs.values) } inline void Pairs::set_values(int index, std::string&& value) { _internal_mutable_values()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:remote.Pairs.values) } inline void Pairs::set_values(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_values()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:remote.Pairs.values) } inline void Pairs::set_values(int index, const void* value, std::size_t size) { _internal_mutable_values()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:remote.Pairs.values) } inline void Pairs::set_values(int index, absl::string_view value) { _internal_mutable_values()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:remote.Pairs.values) } inline void Pairs::add_values(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_values()->Add()->assign(value); // @@protoc_insertion_point(field_add:remote.Pairs.values) } inline void Pairs::add_values(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_values()->Add(std::move(value)); // @@protoc_insertion_point(field_add:remote.Pairs.values) } inline void Pairs::add_values(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_values()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:remote.Pairs.values) } inline void Pairs::add_values(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_values()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:remote.Pairs.values) } inline void Pairs::add_values(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_values()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:remote.Pairs.values) } inline const ::google::protobuf::RepeatedPtrField& Pairs::values() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:remote.Pairs.values) return _internal_values(); } inline ::google::protobuf::RepeatedPtrField* Pairs::mutable_values() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:remote.Pairs.values) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_values(); } inline const ::google::protobuf::RepeatedPtrField& Pairs::_internal_values() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.values_; } inline ::google::protobuf::RepeatedPtrField* Pairs::_internal_mutable_values() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.values_; } // string next_page_token = 3; inline void Pairs::clear_next_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.ClearToEmpty(); } inline const std::string& Pairs::next_page_token() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.Pairs.next_page_token) return _internal_next_page_token(); } template inline PROTOBUF_ALWAYS_INLINE void Pairs::set_next_page_token(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.Pairs.next_page_token) } inline std::string* Pairs::mutable_next_page_token() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_next_page_token(); // @@protoc_insertion_point(field_mutable:remote.Pairs.next_page_token) return _s; } inline const std::string& Pairs::_internal_next_page_token() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.next_page_token_.Get(); } inline void Pairs::_internal_set_next_page_token(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.Set(value, GetArena()); } inline std::string* Pairs::_internal_mutable_next_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.next_page_token_.Mutable( GetArena()); } inline std::string* Pairs::release_next_page_token() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.Pairs.next_page_token) return _impl_.next_page_token_.Release(); } inline void Pairs::set_allocated_next_page_token(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_page_token_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.next_page_token_.IsDefault()) { _impl_.next_page_token_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.Pairs.next_page_token) } // ------------------------------------------------------------------- // PairsPagination // bytes next_key = 1; inline void PairsPagination::clear_next_key() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_key_.ClearToEmpty(); } inline const std::string& PairsPagination::next_key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:remote.PairsPagination.next_key) return _internal_next_key(); } template inline PROTOBUF_ALWAYS_INLINE void PairsPagination::set_next_key(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_key_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:remote.PairsPagination.next_key) } inline std::string* PairsPagination::mutable_next_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_next_key(); // @@protoc_insertion_point(field_mutable:remote.PairsPagination.next_key) return _s; } inline const std::string& PairsPagination::_internal_next_key() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.next_key_.Get(); } inline void PairsPagination::_internal_set_next_key(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_key_.Set(value, GetArena()); } inline std::string* PairsPagination::_internal_mutable_next_key() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.next_key_.Mutable( GetArena()); } inline std::string* PairsPagination::release_next_key() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:remote.PairsPagination.next_key) return _impl_.next_key_.Release(); } inline void PairsPagination::set_allocated_next_key(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_key_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.next_key_.IsDefault()) { _impl_.next_key_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:remote.PairsPagination.next_key) } // sint64 limit = 2; inline void PairsPagination::clear_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = ::int64_t{0}; } inline ::int64_t PairsPagination::limit() const { // @@protoc_insertion_point(field_get:remote.PairsPagination.limit) return _internal_limit(); } inline void PairsPagination::set_limit(::int64_t value) { _internal_set_limit(value); // @@protoc_insertion_point(field_set:remote.PairsPagination.limit) } inline ::int64_t PairsPagination::_internal_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.limit_; } inline void PairsPagination::_internal_set_limit(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = value; } // ------------------------------------------------------------------- // IndexPagination // sint64 next_time_stamp = 1; inline void IndexPagination::clear_next_time_stamp() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_time_stamp_ = ::int64_t{0}; } inline ::int64_t IndexPagination::next_time_stamp() const { // @@protoc_insertion_point(field_get:remote.IndexPagination.next_time_stamp) return _internal_next_time_stamp(); } inline void IndexPagination::set_next_time_stamp(::int64_t value) { _internal_set_next_time_stamp(value); // @@protoc_insertion_point(field_set:remote.IndexPagination.next_time_stamp) } inline ::int64_t IndexPagination::_internal_next_time_stamp() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.next_time_stamp_; } inline void IndexPagination::_internal_set_next_time_stamp(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.next_time_stamp_ = value; } // sint64 limit = 2; inline void IndexPagination::clear_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = ::int64_t{0}; } inline ::int64_t IndexPagination::limit() const { // @@protoc_insertion_point(field_get:remote.IndexPagination.limit) return _internal_limit(); } inline void IndexPagination::set_limit(::int64_t value) { _internal_set_limit(value); // @@protoc_insertion_point(field_set:remote.IndexPagination.limit) } inline ::int64_t IndexPagination::_internal_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.limit_; } inline void IndexPagination::_internal_set_limit(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.limit_ = value; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace remote namespace google { namespace protobuf { template <> struct is_proto_enum<::remote::Op> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::remote::Op>() { return ::remote::Op_descriptor(); } template <> struct is_proto_enum<::remote::Action> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::remote::Action>() { return ::remote::Action_descriptor(); } template <> struct is_proto_enum<::remote::Direction> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::remote::Direction>() { return ::remote::Direction_descriptor(); } } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_remote_2fkv_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/27.0/remote/kv_mock.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: remote/kv.proto #ifndef GRPC_MOCK_remote_2fkv_2eproto__INCLUDED #define GRPC_MOCK_remote_2fkv_2eproto__INCLUDED #include "remote/kv.pb.h" #include "remote/kv.grpc.pb.h" #include #include #include namespace remote { class MockKVStub : public KV::StubInterface { public: MOCK_METHOD3(Version, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response)); MOCK_METHOD3(AsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD1(TxRaw, ::grpc::ClientReaderWriterInterface< ::remote::Cursor, ::remote::Pair>*(::grpc::ClientContext* context)); MOCK_METHOD3(AsyncTxRaw, ::grpc::ClientAsyncReaderWriterInterface<::remote::Cursor, ::remote::Pair>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD2(PrepareAsyncTxRaw, ::grpc::ClientAsyncReaderWriterInterface<::remote::Cursor, ::remote::Pair>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(StateChangesRaw, ::grpc::ClientReaderInterface< ::remote::StateChangeBatch>*(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request)); MOCK_METHOD4(AsyncStateChangesRaw, ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>*(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncStateChangesRaw, ::grpc::ClientAsyncReaderInterface< ::remote::StateChangeBatch>*(::grpc::ClientContext* context, const ::remote::StateChangeRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Snapshots, ::grpc::Status(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::remote::SnapshotsReply* response)); MOCK_METHOD3(AsyncSnapshotsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>*(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSnapshotsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::SnapshotsReply>*(::grpc::ClientContext* context, const ::remote::SnapshotsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Range, ::grpc::Status(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::remote::Pairs* response)); MOCK_METHOD3(AsyncRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::RangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetLatest, ::grpc::Status(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::remote::GetLatestReply* response)); MOCK_METHOD3(AsyncGetLatestRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>*(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetLatestRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::GetLatestReply>*(::grpc::ClientContext* context, const ::remote::GetLatestReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(HistorySeek, ::grpc::Status(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::remote::HistorySeekReply* response)); MOCK_METHOD3(AsyncHistorySeekRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>*(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHistorySeekRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::HistorySeekReply>*(::grpc::ClientContext* context, const ::remote::HistorySeekReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(IndexRange, ::grpc::Status(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::remote::IndexRangeReply* response)); MOCK_METHOD3(AsyncIndexRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>*(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncIndexRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::IndexRangeReply>*(::grpc::ClientContext* context, const ::remote::IndexRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(HistoryRange, ::grpc::Status(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::remote::Pairs* response)); MOCK_METHOD3(AsyncHistoryRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHistoryRangeRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::HistoryRangeReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(RangeAsOf, ::grpc::Status(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::remote::Pairs* response)); MOCK_METHOD3(AsyncRangeAsOfRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncRangeAsOfRaw, ::grpc::ClientAsyncResponseReaderInterface< ::remote::Pairs>*(::grpc::ClientContext* context, const ::remote::RangeAsOfReq& request, ::grpc::CompletionQueue* cq)); }; } // namespace remote #endif // GRPC_MOCK_remote_2fkv_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/txpool/mining.grpc.pb.cc ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: txpool/mining.proto #include "txpool/mining.pb.h" #include "txpool/mining.grpc.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace txpool { static const char* Mining_method_names[] = { "/txpool.Mining/Version", "/txpool.Mining/OnPendingBlock", "/txpool.Mining/OnMinedBlock", "/txpool.Mining/OnPendingLogs", "/txpool.Mining/GetWork", "/txpool.Mining/SubmitWork", "/txpool.Mining/SubmitHashRate", "/txpool.Mining/HashRate", "/txpool.Mining/Mining", }; std::unique_ptr< Mining::Stub> Mining::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< Mining::Stub> stub(new Mining::Stub(channel, options)); return stub; } Mining::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_Version_(Mining_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_OnPendingBlock_(Mining_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_OnMinedBlock_(Mining_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_OnPendingLogs_(Mining_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_GetWork_(Mining_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_SubmitWork_(Mining_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_SubmitHashRate_(Mining_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_HashRate_(Mining_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Mining_(Mining_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status Mining::Stub::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Version_, context, request, response); } void Mining::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, std::move(f)); } void Mining::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* Mining::Stub::PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::types::VersionReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Version_, context, request); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* Mining::Stub::AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::ClientReader< ::txpool::OnPendingBlockReply>* Mining::Stub::OnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request) { return ::grpc::internal::ClientReaderFactory< ::txpool::OnPendingBlockReply>::Create(channel_.get(), rpcmethod_OnPendingBlock_, context, request); } void Mining::Stub::async::OnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest* request, ::grpc::ClientReadReactor< ::txpool::OnPendingBlockReply>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::txpool::OnPendingBlockReply>::Create(stub_->channel_.get(), stub_->rpcmethod_OnPendingBlock_, context, request, reactor); } ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>* Mining::Stub::AsyncOnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnPendingBlockReply>::Create(channel_.get(), cq, rpcmethod_OnPendingBlock_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>* Mining::Stub::PrepareAsyncOnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnPendingBlockReply>::Create(channel_.get(), cq, rpcmethod_OnPendingBlock_, context, request, false, nullptr); } ::grpc::ClientReader< ::txpool::OnMinedBlockReply>* Mining::Stub::OnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request) { return ::grpc::internal::ClientReaderFactory< ::txpool::OnMinedBlockReply>::Create(channel_.get(), rpcmethod_OnMinedBlock_, context, request); } void Mining::Stub::async::OnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest* request, ::grpc::ClientReadReactor< ::txpool::OnMinedBlockReply>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::txpool::OnMinedBlockReply>::Create(stub_->channel_.get(), stub_->rpcmethod_OnMinedBlock_, context, request, reactor); } ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>* Mining::Stub::AsyncOnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnMinedBlockReply>::Create(channel_.get(), cq, rpcmethod_OnMinedBlock_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>* Mining::Stub::PrepareAsyncOnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnMinedBlockReply>::Create(channel_.get(), cq, rpcmethod_OnMinedBlock_, context, request, false, nullptr); } ::grpc::ClientReader< ::txpool::OnPendingLogsReply>* Mining::Stub::OnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request) { return ::grpc::internal::ClientReaderFactory< ::txpool::OnPendingLogsReply>::Create(channel_.get(), rpcmethod_OnPendingLogs_, context, request); } void Mining::Stub::async::OnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest* request, ::grpc::ClientReadReactor< ::txpool::OnPendingLogsReply>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::txpool::OnPendingLogsReply>::Create(stub_->channel_.get(), stub_->rpcmethod_OnPendingLogs_, context, request, reactor); } ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>* Mining::Stub::AsyncOnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnPendingLogsReply>::Create(channel_.get(), cq, rpcmethod_OnPendingLogs_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>* Mining::Stub::PrepareAsyncOnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnPendingLogsReply>::Create(channel_.get(), cq, rpcmethod_OnPendingLogs_, context, request, false, nullptr); } ::grpc::Status Mining::Stub::GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::txpool::GetWorkReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::GetWorkRequest, ::txpool::GetWorkReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetWork_, context, request, response); } void Mining::Stub::async::GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::GetWorkRequest, ::txpool::GetWorkReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetWork_, context, request, response, std::move(f)); } void Mining::Stub::async::GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetWork_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>* Mining::Stub::PrepareAsyncGetWorkRaw(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::GetWorkReply, ::txpool::GetWorkRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetWork_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>* Mining::Stub::AsyncGetWorkRaw(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncGetWorkRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Mining::Stub::SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::txpool::SubmitWorkReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SubmitWork_, context, request, response); } void Mining::Stub::async::SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitWork_, context, request, response, std::move(f)); } void Mining::Stub::async::SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitWork_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>* Mining::Stub::PrepareAsyncSubmitWorkRaw(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::SubmitWorkReply, ::txpool::SubmitWorkRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SubmitWork_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>* Mining::Stub::AsyncSubmitWorkRaw(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSubmitWorkRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Mining::Stub::SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::txpool::SubmitHashRateReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SubmitHashRate_, context, request, response); } void Mining::Stub::async::SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitHashRate_, context, request, response, std::move(f)); } void Mining::Stub::async::SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitHashRate_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>* Mining::Stub::PrepareAsyncSubmitHashRateRaw(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::SubmitHashRateReply, ::txpool::SubmitHashRateRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SubmitHashRate_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>* Mining::Stub::AsyncSubmitHashRateRaw(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncSubmitHashRateRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Mining::Stub::HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::txpool::HashRateReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::HashRateRequest, ::txpool::HashRateReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HashRate_, context, request, response); } void Mining::Stub::async::HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::HashRateRequest, ::txpool::HashRateReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HashRate_, context, request, response, std::move(f)); } void Mining::Stub::async::HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HashRate_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>* Mining::Stub::PrepareAsyncHashRateRaw(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::HashRateReply, ::txpool::HashRateRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HashRate_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>* Mining::Stub::AsyncHashRateRaw(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncHashRateRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Mining::Stub::Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::txpool::MiningReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::MiningRequest, ::txpool::MiningReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Mining_, context, request, response); } void Mining::Stub::async::Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::MiningRequest, ::txpool::MiningReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Mining_, context, request, response, std::move(f)); } void Mining::Stub::async::Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Mining_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>* Mining::Stub::PrepareAsyncMiningRaw(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::MiningReply, ::txpool::MiningRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Mining_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>* Mining::Stub::AsyncMiningRaw(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncMiningRaw(context, request, cq); result->StartCall(); return result; } Mining::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Mining::Service, ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::types::VersionReply* resp) { return service->Version(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[1], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< Mining::Service, ::txpool::OnPendingBlockRequest, ::txpool::OnPendingBlockReply>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::OnPendingBlockRequest* req, ::grpc::ServerWriter<::txpool::OnPendingBlockReply>* writer) { return service->OnPendingBlock(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[2], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< Mining::Service, ::txpool::OnMinedBlockRequest, ::txpool::OnMinedBlockReply>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::OnMinedBlockRequest* req, ::grpc::ServerWriter<::txpool::OnMinedBlockReply>* writer) { return service->OnMinedBlock(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[3], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< Mining::Service, ::txpool::OnPendingLogsRequest, ::txpool::OnPendingLogsReply>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::OnPendingLogsRequest* req, ::grpc::ServerWriter<::txpool::OnPendingLogsReply>* writer) { return service->OnPendingLogs(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Mining::Service, ::txpool::GetWorkRequest, ::txpool::GetWorkReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::GetWorkRequest* req, ::txpool::GetWorkReply* resp) { return service->GetWork(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Mining::Service, ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::SubmitWorkRequest* req, ::txpool::SubmitWorkReply* resp) { return service->SubmitWork(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Mining::Service, ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::SubmitHashRateRequest* req, ::txpool::SubmitHashRateReply* resp) { return service->SubmitHashRate(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Mining::Service, ::txpool::HashRateRequest, ::txpool::HashRateReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::HashRateRequest* req, ::txpool::HashRateReply* resp) { return service->HashRate(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Mining_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Mining::Service, ::txpool::MiningRequest, ::txpool::MiningReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Mining::Service* service, ::grpc::ServerContext* ctx, const ::txpool::MiningRequest* req, ::txpool::MiningReply* resp) { return service->Mining(ctx, req, resp); }, this))); } Mining::Service::~Service() { } ::grpc::Status Mining::Service::Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::OnPendingBlock(::grpc::ServerContext* context, const ::txpool::OnPendingBlockRequest* request, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::OnMinedBlock(::grpc::ServerContext* context, const ::txpool::OnMinedBlockRequest* request, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::OnPendingLogs(::grpc::ServerContext* context, const ::txpool::OnPendingLogsRequest* request, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::GetWork(::grpc::ServerContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::SubmitWork(::grpc::ServerContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::SubmitHashRate(::grpc::ServerContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::HashRate(::grpc::ServerContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Mining::Service::Mining(::grpc::ServerContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } } // namespace txpool ================================================ FILE: silkworm/interfaces/27.0/txpool/mining.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: txpool/mining.proto #ifndef GRPC_txpool_2fmining_2eproto__INCLUDED #define GRPC_txpool_2fmining_2eproto__INCLUDED #include "txpool/mining.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace txpool { class Mining final { public: static constexpr char const* service_full_name() { return "txpool.Mining"; } class StubInterface { public: virtual ~StubInterface() {} // Version returns the service version number virtual ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } // subscribe to pending blocks event std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnPendingBlockReply>> OnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnPendingBlockReply>>(OnPendingBlockRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>> AsyncOnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>>(AsyncOnPendingBlockRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>> PrepareAsyncOnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>>(PrepareAsyncOnPendingBlockRaw(context, request, cq)); } // subscribe to mined blocks event std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnMinedBlockReply>> OnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnMinedBlockReply>>(OnMinedBlockRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>> AsyncOnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>>(AsyncOnMinedBlockRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>> PrepareAsyncOnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>>(PrepareAsyncOnMinedBlockRaw(context, request, cq)); } // subscribe to pending blocks event std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnPendingLogsReply>> OnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnPendingLogsReply>>(OnPendingLogsRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>> AsyncOnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>>(AsyncOnPendingLogsRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>> PrepareAsyncOnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>>(PrepareAsyncOnPendingLogsRaw(context, request, cq)); } // GetWork returns a work package for external miner. // // The work package consists of 3 strings: // result[0] - 32 bytes hex encoded current block header pow-hash // result[1] - 32 bytes hex encoded seed hash used for DAG // result[2] - 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty // result[3] - hex encoded block number virtual ::grpc::Status GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::txpool::GetWorkReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>> AsyncGetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>>(AsyncGetWorkRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>> PrepareAsyncGetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>>(PrepareAsyncGetWorkRaw(context, request, cq)); } // SubmitWork can be used by external miner to submit their POW solution. // It returns an indication if the work was accepted. // Note either an invalid solution, a stale work a non-existent work will return false. virtual ::grpc::Status SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::txpool::SubmitWorkReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>> AsyncSubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>>(AsyncSubmitWorkRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>> PrepareAsyncSubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>>(PrepareAsyncSubmitWorkRaw(context, request, cq)); } // SubmitHashRate can be used for remote miners to submit their hash rate. // This enables the node to report the combined hash rate of all miners // which submit work through this node. // // It accepts the miner hash rate and an identifier which must be unique // between nodes. virtual ::grpc::Status SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::txpool::SubmitHashRateReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>> AsyncSubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>>(AsyncSubmitHashRateRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>> PrepareAsyncSubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>>(PrepareAsyncSubmitHashRateRaw(context, request, cq)); } // HashRate returns the current hashrate for local CPU miner and remote miner. virtual ::grpc::Status HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::txpool::HashRateReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>> AsyncHashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>>(AsyncHashRateRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>> PrepareAsyncHashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>>(PrepareAsyncHashRateRaw(context, request, cq)); } // Mining returns an indication if this node is currently mining and its mining configuration virtual ::grpc::Status Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::txpool::MiningReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>> AsyncMining(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>>(AsyncMiningRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>> PrepareAsyncMining(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>>(PrepareAsyncMiningRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} // Version returns the service version number virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) = 0; virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // subscribe to pending blocks event virtual void OnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest* request, ::grpc::ClientReadReactor< ::txpool::OnPendingBlockReply>* reactor) = 0; // subscribe to mined blocks event virtual void OnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest* request, ::grpc::ClientReadReactor< ::txpool::OnMinedBlockReply>* reactor) = 0; // subscribe to pending blocks event virtual void OnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest* request, ::grpc::ClientReadReactor< ::txpool::OnPendingLogsReply>* reactor) = 0; // GetWork returns a work package for external miner. // // The work package consists of 3 strings: // result[0] - 32 bytes hex encoded current block header pow-hash // result[1] - 32 bytes hex encoded seed hash used for DAG // result[2] - 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty // result[3] - hex encoded block number virtual void GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response, std::function) = 0; virtual void GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // SubmitWork can be used by external miner to submit their POW solution. // It returns an indication if the work was accepted. // Note either an invalid solution, a stale work a non-existent work will return false. virtual void SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response, std::function) = 0; virtual void SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // SubmitHashRate can be used for remote miners to submit their hash rate. // This enables the node to report the combined hash rate of all miners // which submit work through this node. // // It accepts the miner hash rate and an identifier which must be unique // between nodes. virtual void SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response, std::function) = 0; virtual void SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // HashRate returns the current hashrate for local CPU miner and remote miner. virtual void HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response, std::function) = 0; virtual void HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Mining returns an indication if this node is currently mining and its mining configuration virtual void Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response, std::function) = 0; virtual void Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::txpool::OnPendingBlockReply>* OnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>* AsyncOnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>* PrepareAsyncOnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::txpool::OnMinedBlockReply>* OnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>* AsyncOnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>* PrepareAsyncOnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::txpool::OnPendingLogsReply>* OnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>* AsyncOnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>* PrepareAsyncOnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>* AsyncGetWorkRaw(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>* PrepareAsyncGetWorkRaw(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>* AsyncSubmitWorkRaw(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>* PrepareAsyncSubmitWorkRaw(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>* AsyncSubmitHashRateRaw(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>* PrepareAsyncSubmitHashRateRaw(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>* AsyncHashRateRaw(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>* PrepareAsyncHashRateRaw(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>* AsyncMiningRaw(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>* PrepareAsyncMiningRaw(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::txpool::OnPendingBlockReply>> OnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::txpool::OnPendingBlockReply>>(OnPendingBlockRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>> AsyncOnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>>(AsyncOnPendingBlockRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>> PrepareAsyncOnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>>(PrepareAsyncOnPendingBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::txpool::OnMinedBlockReply>> OnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::txpool::OnMinedBlockReply>>(OnMinedBlockRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>> AsyncOnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>>(AsyncOnMinedBlockRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>> PrepareAsyncOnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>>(PrepareAsyncOnMinedBlockRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::txpool::OnPendingLogsReply>> OnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::txpool::OnPendingLogsReply>>(OnPendingLogsRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>> AsyncOnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>>(AsyncOnPendingLogsRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>> PrepareAsyncOnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>>(PrepareAsyncOnPendingLogsRaw(context, request, cq)); } ::grpc::Status GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::txpool::GetWorkReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>> AsyncGetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>>(AsyncGetWorkRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>> PrepareAsyncGetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>>(PrepareAsyncGetWorkRaw(context, request, cq)); } ::grpc::Status SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::txpool::SubmitWorkReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>> AsyncSubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>>(AsyncSubmitWorkRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>> PrepareAsyncSubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>>(PrepareAsyncSubmitWorkRaw(context, request, cq)); } ::grpc::Status SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::txpool::SubmitHashRateReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>> AsyncSubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>>(AsyncSubmitHashRateRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>> PrepareAsyncSubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>>(PrepareAsyncSubmitHashRateRaw(context, request, cq)); } ::grpc::Status HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::txpool::HashRateReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>> AsyncHashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>>(AsyncHashRateRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>> PrepareAsyncHashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>>(PrepareAsyncHashRateRaw(context, request, cq)); } ::grpc::Status Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::txpool::MiningReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>> AsyncMining(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>>(AsyncMiningRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>> PrepareAsyncMining(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>>(PrepareAsyncMiningRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) override; void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void OnPendingBlock(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest* request, ::grpc::ClientReadReactor< ::txpool::OnPendingBlockReply>* reactor) override; void OnMinedBlock(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest* request, ::grpc::ClientReadReactor< ::txpool::OnMinedBlockReply>* reactor) override; void OnPendingLogs(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest* request, ::grpc::ClientReadReactor< ::txpool::OnPendingLogsReply>* reactor) override; void GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response, std::function) override; void GetWork(::grpc::ClientContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response, ::grpc::ClientUnaryReactor* reactor) override; void SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response, std::function) override; void SubmitWork(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response, ::grpc::ClientUnaryReactor* reactor) override; void SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response, std::function) override; void SubmitHashRate(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response, ::grpc::ClientUnaryReactor* reactor) override; void HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response, std::function) override; void HashRate(::grpc::ClientContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response, std::function) override; void Mining(::grpc::ClientContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::txpool::OnPendingBlockReply>* OnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request) override; ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>* AsyncOnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::txpool::OnPendingBlockReply>* PrepareAsyncOnPendingBlockRaw(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::txpool::OnMinedBlockReply>* OnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request) override; ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>* AsyncOnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::txpool::OnMinedBlockReply>* PrepareAsyncOnMinedBlockRaw(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::txpool::OnPendingLogsReply>* OnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request) override; ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>* AsyncOnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::txpool::OnPendingLogsReply>* PrepareAsyncOnPendingLogsRaw(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>* AsyncGetWorkRaw(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::GetWorkReply>* PrepareAsyncGetWorkRaw(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>* AsyncSubmitWorkRaw(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::SubmitWorkReply>* PrepareAsyncSubmitWorkRaw(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>* AsyncSubmitHashRateRaw(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::SubmitHashRateReply>* PrepareAsyncSubmitHashRateRaw(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>* AsyncHashRateRaw(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::HashRateReply>* PrepareAsyncHashRateRaw(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>* AsyncMiningRaw(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::MiningReply>* PrepareAsyncMiningRaw(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_Version_; const ::grpc::internal::RpcMethod rpcmethod_OnPendingBlock_; const ::grpc::internal::RpcMethod rpcmethod_OnMinedBlock_; const ::grpc::internal::RpcMethod rpcmethod_OnPendingLogs_; const ::grpc::internal::RpcMethod rpcmethod_GetWork_; const ::grpc::internal::RpcMethod rpcmethod_SubmitWork_; const ::grpc::internal::RpcMethod rpcmethod_SubmitHashRate_; const ::grpc::internal::RpcMethod rpcmethod_HashRate_; const ::grpc::internal::RpcMethod rpcmethod_Mining_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // Version returns the service version number virtual ::grpc::Status Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response); // subscribe to pending blocks event virtual ::grpc::Status OnPendingBlock(::grpc::ServerContext* context, const ::txpool::OnPendingBlockRequest* request, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* writer); // subscribe to mined blocks event virtual ::grpc::Status OnMinedBlock(::grpc::ServerContext* context, const ::txpool::OnMinedBlockRequest* request, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* writer); // subscribe to pending blocks event virtual ::grpc::Status OnPendingLogs(::grpc::ServerContext* context, const ::txpool::OnPendingLogsRequest* request, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* writer); // GetWork returns a work package for external miner. // // The work package consists of 3 strings: // result[0] - 32 bytes hex encoded current block header pow-hash // result[1] - 32 bytes hex encoded seed hash used for DAG // result[2] - 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty // result[3] - hex encoded block number virtual ::grpc::Status GetWork(::grpc::ServerContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response); // SubmitWork can be used by external miner to submit their POW solution. // It returns an indication if the work was accepted. // Note either an invalid solution, a stale work a non-existent work will return false. virtual ::grpc::Status SubmitWork(::grpc::ServerContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response); // SubmitHashRate can be used for remote miners to submit their hash rate. // This enables the node to report the combined hash rate of all miners // which submit work through this node. // // It accepts the miner hash rate and an identifier which must be unique // between nodes. virtual ::grpc::Status SubmitHashRate(::grpc::ServerContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response); // HashRate returns the current hashrate for local CPU miner and remote miner. virtual ::grpc::Status HashRate(::grpc::ServerContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response); // Mining returns an indication if this node is currently mining and its mining configuration virtual ::grpc::Status Mining(::grpc::ServerContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response); }; template class WithAsyncMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Version() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::types::VersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_OnPendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_OnPendingBlock() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_OnPendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnPendingBlock(::grpc::ServerContext* context, ::txpool::OnPendingBlockRequest* request, ::grpc::ServerAsyncWriter< ::txpool::OnPendingBlockReply>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_OnMinedBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_OnMinedBlock() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_OnMinedBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnMinedBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnMinedBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnMinedBlock(::grpc::ServerContext* context, ::txpool::OnMinedBlockRequest* request, ::grpc::ServerAsyncWriter< ::txpool::OnMinedBlockReply>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(2, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_OnPendingLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_OnPendingLogs() { ::grpc::Service::MarkMethodAsync(3); } ~WithAsyncMethod_OnPendingLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingLogs(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingLogsRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnPendingLogs(::grpc::ServerContext* context, ::txpool::OnPendingLogsRequest* request, ::grpc::ServerAsyncWriter< ::txpool::OnPendingLogsReply>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_GetWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetWork() { ::grpc::Service::MarkMethodAsync(4); } ~WithAsyncMethod_GetWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetWork(::grpc::ServerContext* /*context*/, const ::txpool::GetWorkRequest* /*request*/, ::txpool::GetWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetWork(::grpc::ServerContext* context, ::txpool::GetWorkRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::GetWorkReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SubmitWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SubmitWork() { ::grpc::Service::MarkMethodAsync(5); } ~WithAsyncMethod_SubmitWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitWork(::grpc::ServerContext* /*context*/, const ::txpool::SubmitWorkRequest* /*request*/, ::txpool::SubmitWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubmitWork(::grpc::ServerContext* context, ::txpool::SubmitWorkRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::SubmitWorkReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SubmitHashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SubmitHashRate() { ::grpc::Service::MarkMethodAsync(6); } ~WithAsyncMethod_SubmitHashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitHashRate(::grpc::ServerContext* /*context*/, const ::txpool::SubmitHashRateRequest* /*request*/, ::txpool::SubmitHashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubmitHashRate(::grpc::ServerContext* context, ::txpool::SubmitHashRateRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::SubmitHashRateReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_HashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HashRate() { ::grpc::Service::MarkMethodAsync(7); } ~WithAsyncMethod_HashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HashRate(::grpc::ServerContext* /*context*/, const ::txpool::HashRateRequest* /*request*/, ::txpool::HashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHashRate(::grpc::ServerContext* context, ::txpool::HashRateRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::HashRateReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Mining : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Mining() { ::grpc::Service::MarkMethodAsync(8); } ~WithAsyncMethod_Mining() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Mining(::grpc::ServerContext* /*context*/, const ::txpool::MiningRequest* /*request*/, ::txpool::MiningReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestMining(::grpc::ServerContext* context, ::txpool::MiningRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::MiningReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_Version > > > > > > > > AsyncService; template class WithCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Version() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { return this->Version(context, request, response); }));} void SetMessageAllocatorFor_Version( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::types::VersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_OnPendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_OnPendingBlock() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackServerStreamingHandler< ::txpool::OnPendingBlockRequest, ::txpool::OnPendingBlockReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::OnPendingBlockRequest* request) { return this->OnPendingBlock(context, request); })); } ~WithCallbackMethod_OnPendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::txpool::OnPendingBlockReply>* OnPendingBlock( ::grpc::CallbackServerContext* /*context*/, const ::txpool::OnPendingBlockRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_OnMinedBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_OnMinedBlock() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackServerStreamingHandler< ::txpool::OnMinedBlockRequest, ::txpool::OnMinedBlockReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::OnMinedBlockRequest* request) { return this->OnMinedBlock(context, request); })); } ~WithCallbackMethod_OnMinedBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnMinedBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnMinedBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::txpool::OnMinedBlockReply>* OnMinedBlock( ::grpc::CallbackServerContext* /*context*/, const ::txpool::OnMinedBlockRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_OnPendingLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_OnPendingLogs() { ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackServerStreamingHandler< ::txpool::OnPendingLogsRequest, ::txpool::OnPendingLogsReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::OnPendingLogsRequest* request) { return this->OnPendingLogs(context, request); })); } ~WithCallbackMethod_OnPendingLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingLogs(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingLogsRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::txpool::OnPendingLogsReply>* OnPendingLogs( ::grpc::CallbackServerContext* /*context*/, const ::txpool::OnPendingLogsRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_GetWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_GetWork() { ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::txpool::GetWorkRequest, ::txpool::GetWorkReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::GetWorkRequest* request, ::txpool::GetWorkReply* response) { return this->GetWork(context, request, response); }));} void SetMessageAllocatorFor_GetWork( ::grpc::MessageAllocator< ::txpool::GetWorkRequest, ::txpool::GetWorkReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::GetWorkRequest, ::txpool::GetWorkReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_GetWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetWork(::grpc::ServerContext* /*context*/, const ::txpool::GetWorkRequest* /*request*/, ::txpool::GetWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetWork( ::grpc::CallbackServerContext* /*context*/, const ::txpool::GetWorkRequest* /*request*/, ::txpool::GetWorkReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SubmitWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SubmitWork() { ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::SubmitWorkRequest* request, ::txpool::SubmitWorkReply* response) { return this->SubmitWork(context, request, response); }));} void SetMessageAllocatorFor_SubmitWork( ::grpc::MessageAllocator< ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SubmitWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitWork(::grpc::ServerContext* /*context*/, const ::txpool::SubmitWorkRequest* /*request*/, ::txpool::SubmitWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SubmitWork( ::grpc::CallbackServerContext* /*context*/, const ::txpool::SubmitWorkRequest* /*request*/, ::txpool::SubmitWorkReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SubmitHashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SubmitHashRate() { ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::SubmitHashRateRequest* request, ::txpool::SubmitHashRateReply* response) { return this->SubmitHashRate(context, request, response); }));} void SetMessageAllocatorFor_SubmitHashRate( ::grpc::MessageAllocator< ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SubmitHashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitHashRate(::grpc::ServerContext* /*context*/, const ::txpool::SubmitHashRateRequest* /*request*/, ::txpool::SubmitHashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SubmitHashRate( ::grpc::CallbackServerContext* /*context*/, const ::txpool::SubmitHashRateRequest* /*request*/, ::txpool::SubmitHashRateReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_HashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_HashRate() { ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::txpool::HashRateRequest, ::txpool::HashRateReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::HashRateRequest* request, ::txpool::HashRateReply* response) { return this->HashRate(context, request, response); }));} void SetMessageAllocatorFor_HashRate( ::grpc::MessageAllocator< ::txpool::HashRateRequest, ::txpool::HashRateReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::HashRateRequest, ::txpool::HashRateReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_HashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HashRate(::grpc::ServerContext* /*context*/, const ::txpool::HashRateRequest* /*request*/, ::txpool::HashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HashRate( ::grpc::CallbackServerContext* /*context*/, const ::txpool::HashRateRequest* /*request*/, ::txpool::HashRateReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Mining : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Mining() { ::grpc::Service::MarkMethodCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::txpool::MiningRequest, ::txpool::MiningReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::MiningRequest* request, ::txpool::MiningReply* response) { return this->Mining(context, request, response); }));} void SetMessageAllocatorFor_Mining( ::grpc::MessageAllocator< ::txpool::MiningRequest, ::txpool::MiningReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(8); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::MiningRequest, ::txpool::MiningReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Mining() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Mining(::grpc::ServerContext* /*context*/, const ::txpool::MiningRequest* /*request*/, ::txpool::MiningReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Mining( ::grpc::CallbackServerContext* /*context*/, const ::txpool::MiningRequest* /*request*/, ::txpool::MiningReply* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_Version > > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Version() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_OnPendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_OnPendingBlock() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_OnPendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_OnMinedBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_OnMinedBlock() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_OnMinedBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnMinedBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnMinedBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_OnPendingLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_OnPendingLogs() { ::grpc::Service::MarkMethodGeneric(3); } ~WithGenericMethod_OnPendingLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingLogs(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingLogsRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_GetWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetWork() { ::grpc::Service::MarkMethodGeneric(4); } ~WithGenericMethod_GetWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetWork(::grpc::ServerContext* /*context*/, const ::txpool::GetWorkRequest* /*request*/, ::txpool::GetWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SubmitWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SubmitWork() { ::grpc::Service::MarkMethodGeneric(5); } ~WithGenericMethod_SubmitWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitWork(::grpc::ServerContext* /*context*/, const ::txpool::SubmitWorkRequest* /*request*/, ::txpool::SubmitWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SubmitHashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SubmitHashRate() { ::grpc::Service::MarkMethodGeneric(6); } ~WithGenericMethod_SubmitHashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitHashRate(::grpc::ServerContext* /*context*/, const ::txpool::SubmitHashRateRequest* /*request*/, ::txpool::SubmitHashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_HashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HashRate() { ::grpc::Service::MarkMethodGeneric(7); } ~WithGenericMethod_HashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HashRate(::grpc::ServerContext* /*context*/, const ::txpool::HashRateRequest* /*request*/, ::txpool::HashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Mining : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Mining() { ::grpc::Service::MarkMethodGeneric(8); } ~WithGenericMethod_Mining() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Mining(::grpc::ServerContext* /*context*/, const ::txpool::MiningRequest* /*request*/, ::txpool::MiningReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Version() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_OnPendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_OnPendingBlock() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_OnPendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnPendingBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_OnMinedBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_OnMinedBlock() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_OnMinedBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnMinedBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnMinedBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnMinedBlock(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(2, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_OnPendingLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_OnPendingLogs() { ::grpc::Service::MarkMethodRaw(3); } ~WithRawMethod_OnPendingLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingLogs(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingLogsRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnPendingLogs(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_GetWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetWork() { ::grpc::Service::MarkMethodRaw(4); } ~WithRawMethod_GetWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetWork(::grpc::ServerContext* /*context*/, const ::txpool::GetWorkRequest* /*request*/, ::txpool::GetWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetWork(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SubmitWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SubmitWork() { ::grpc::Service::MarkMethodRaw(5); } ~WithRawMethod_SubmitWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitWork(::grpc::ServerContext* /*context*/, const ::txpool::SubmitWorkRequest* /*request*/, ::txpool::SubmitWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubmitWork(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SubmitHashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SubmitHashRate() { ::grpc::Service::MarkMethodRaw(6); } ~WithRawMethod_SubmitHashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitHashRate(::grpc::ServerContext* /*context*/, const ::txpool::SubmitHashRateRequest* /*request*/, ::txpool::SubmitHashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSubmitHashRate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_HashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HashRate() { ::grpc::Service::MarkMethodRaw(7); } ~WithRawMethod_HashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HashRate(::grpc::ServerContext* /*context*/, const ::txpool::HashRateRequest* /*request*/, ::txpool::HashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHashRate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Mining : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Mining() { ::grpc::Service::MarkMethodRaw(8); } ~WithRawMethod_Mining() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Mining(::grpc::ServerContext* /*context*/, const ::txpool::MiningRequest* /*request*/, ::txpool::MiningReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestMining(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Version() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Version(context, request, response); })); } ~WithRawCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_OnPendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_OnPendingBlock() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->OnPendingBlock(context, request); })); } ~WithRawCallbackMethod_OnPendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* OnPendingBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_OnMinedBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_OnMinedBlock() { ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->OnMinedBlock(context, request); })); } ~WithRawCallbackMethod_OnMinedBlock() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnMinedBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnMinedBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* OnMinedBlock( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_OnPendingLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_OnPendingLogs() { ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->OnPendingLogs(context, request); })); } ~WithRawCallbackMethod_OnPendingLogs() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnPendingLogs(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingLogsRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* OnPendingLogs( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_GetWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_GetWork() { ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetWork(context, request, response); })); } ~WithRawCallbackMethod_GetWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status GetWork(::grpc::ServerContext* /*context*/, const ::txpool::GetWorkRequest* /*request*/, ::txpool::GetWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* GetWork( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SubmitWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SubmitWork() { ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SubmitWork(context, request, response); })); } ~WithRawCallbackMethod_SubmitWork() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitWork(::grpc::ServerContext* /*context*/, const ::txpool::SubmitWorkRequest* /*request*/, ::txpool::SubmitWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SubmitWork( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SubmitHashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SubmitHashRate() { ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SubmitHashRate(context, request, response); })); } ~WithRawCallbackMethod_SubmitHashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SubmitHashRate(::grpc::ServerContext* /*context*/, const ::txpool::SubmitHashRateRequest* /*request*/, ::txpool::SubmitHashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SubmitHashRate( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_HashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_HashRate() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->HashRate(context, request, response); })); } ~WithRawCallbackMethod_HashRate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status HashRate(::grpc::ServerContext* /*context*/, const ::txpool::HashRateRequest* /*request*/, ::txpool::HashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* HashRate( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Mining : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Mining() { ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Mining(context, request, response); })); } ~WithRawCallbackMethod_Mining() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Mining(::grpc::ServerContext* /*context*/, const ::txpool::MiningRequest* /*request*/, ::txpool::MiningReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Mining( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Version() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::types::VersionReply>* streamer) { return this->StreamedVersion(context, streamer); })); } ~WithStreamedUnaryMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::types::VersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetWork() { ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler< ::txpool::GetWorkRequest, ::txpool::GetWorkReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::GetWorkRequest, ::txpool::GetWorkReply>* streamer) { return this->StreamedGetWork(context, streamer); })); } ~WithStreamedUnaryMethod_GetWork() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status GetWork(::grpc::ServerContext* /*context*/, const ::txpool::GetWorkRequest* /*request*/, ::txpool::GetWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedGetWork(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::GetWorkRequest,::txpool::GetWorkReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SubmitWork : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SubmitWork() { ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler< ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::SubmitWorkRequest, ::txpool::SubmitWorkReply>* streamer) { return this->StreamedSubmitWork(context, streamer); })); } ~WithStreamedUnaryMethod_SubmitWork() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SubmitWork(::grpc::ServerContext* /*context*/, const ::txpool::SubmitWorkRequest* /*request*/, ::txpool::SubmitWorkReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSubmitWork(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::SubmitWorkRequest,::txpool::SubmitWorkReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SubmitHashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SubmitHashRate() { ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::StreamedUnaryHandler< ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::SubmitHashRateRequest, ::txpool::SubmitHashRateReply>* streamer) { return this->StreamedSubmitHashRate(context, streamer); })); } ~WithStreamedUnaryMethod_SubmitHashRate() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SubmitHashRate(::grpc::ServerContext* /*context*/, const ::txpool::SubmitHashRateRequest* /*request*/, ::txpool::SubmitHashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSubmitHashRate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::SubmitHashRateRequest,::txpool::SubmitHashRateReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HashRate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HashRate() { ::grpc::Service::MarkMethodStreamed(7, new ::grpc::internal::StreamedUnaryHandler< ::txpool::HashRateRequest, ::txpool::HashRateReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::HashRateRequest, ::txpool::HashRateReply>* streamer) { return this->StreamedHashRate(context, streamer); })); } ~WithStreamedUnaryMethod_HashRate() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status HashRate(::grpc::ServerContext* /*context*/, const ::txpool::HashRateRequest* /*request*/, ::txpool::HashRateReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedHashRate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::HashRateRequest,::txpool::HashRateReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Mining : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Mining() { ::grpc::Service::MarkMethodStreamed(8, new ::grpc::internal::StreamedUnaryHandler< ::txpool::MiningRequest, ::txpool::MiningReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::MiningRequest, ::txpool::MiningReply>* streamer) { return this->StreamedMining(context, streamer); })); } ~WithStreamedUnaryMethod_Mining() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Mining(::grpc::ServerContext* /*context*/, const ::txpool::MiningRequest* /*request*/, ::txpool::MiningReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedMining(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::MiningRequest,::txpool::MiningReply>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_Version > > > > > StreamedUnaryService; template class WithSplitStreamingMethod_OnPendingBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_OnPendingBlock() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::SplitServerStreamingHandler< ::txpool::OnPendingBlockRequest, ::txpool::OnPendingBlockReply>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnPendingBlockRequest, ::txpool::OnPendingBlockReply>* streamer) { return this->StreamedOnPendingBlock(context, streamer); })); } ~WithSplitStreamingMethod_OnPendingBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status OnPendingBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedOnPendingBlock(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnPendingBlockRequest,::txpool::OnPendingBlockReply>* server_split_streamer) = 0; }; template class WithSplitStreamingMethod_OnMinedBlock : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_OnMinedBlock() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::SplitServerStreamingHandler< ::txpool::OnMinedBlockRequest, ::txpool::OnMinedBlockReply>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnMinedBlockRequest, ::txpool::OnMinedBlockReply>* streamer) { return this->StreamedOnMinedBlock(context, streamer); })); } ~WithSplitStreamingMethod_OnMinedBlock() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status OnMinedBlock(::grpc::ServerContext* /*context*/, const ::txpool::OnMinedBlockRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnMinedBlockReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedOnMinedBlock(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnMinedBlockRequest,::txpool::OnMinedBlockReply>* server_split_streamer) = 0; }; template class WithSplitStreamingMethod_OnPendingLogs : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_OnPendingLogs() { ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::SplitServerStreamingHandler< ::txpool::OnPendingLogsRequest, ::txpool::OnPendingLogsReply>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnPendingLogsRequest, ::txpool::OnPendingLogsReply>* streamer) { return this->StreamedOnPendingLogs(context, streamer); })); } ~WithSplitStreamingMethod_OnPendingLogs() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status OnPendingLogs(::grpc::ServerContext* /*context*/, const ::txpool::OnPendingLogsRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnPendingLogsReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedOnPendingLogs(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnPendingLogsRequest,::txpool::OnPendingLogsReply>* server_split_streamer) = 0; }; typedef WithSplitStreamingMethod_OnPendingBlock > > SplitStreamedService; typedef WithStreamedUnaryMethod_Version > > > > > > > > StreamedService; }; } // namespace txpool #endif // GRPC_txpool_2fmining_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/txpool/mining.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: txpool/mining.proto // Protobuf C++ Version: 5.27.0 #include "txpool/mining.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace txpool { inline constexpr SubmitWorkRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : block_nonce_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), pow_hash_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), digest_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR SubmitWorkRequest::SubmitWorkRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SubmitWorkRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR SubmitWorkRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SubmitWorkRequestDefaultTypeInternal() {} union { SubmitWorkRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubmitWorkRequestDefaultTypeInternal _SubmitWorkRequest_default_instance_; inline constexpr SubmitWorkReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : ok_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SubmitWorkReply::SubmitWorkReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SubmitWorkReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR SubmitWorkReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SubmitWorkReplyDefaultTypeInternal() {} union { SubmitWorkReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubmitWorkReplyDefaultTypeInternal _SubmitWorkReply_default_instance_; inline constexpr SubmitHashRateRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : id_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), rate_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SubmitHashRateRequest::SubmitHashRateRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SubmitHashRateRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR SubmitHashRateRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SubmitHashRateRequestDefaultTypeInternal() {} union { SubmitHashRateRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubmitHashRateRequestDefaultTypeInternal _SubmitHashRateRequest_default_instance_; inline constexpr SubmitHashRateReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : ok_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR SubmitHashRateReply::SubmitHashRateReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct SubmitHashRateReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR SubmitHashRateReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~SubmitHashRateReplyDefaultTypeInternal() {} union { SubmitHashRateReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubmitHashRateReplyDefaultTypeInternal _SubmitHashRateReply_default_instance_; template PROTOBUF_CONSTEXPR OnPendingLogsRequest::OnPendingLogsRequest(::_pbi::ConstantInitialized) {} struct OnPendingLogsRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR OnPendingLogsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnPendingLogsRequestDefaultTypeInternal() {} union { OnPendingLogsRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnPendingLogsRequestDefaultTypeInternal _OnPendingLogsRequest_default_instance_; inline constexpr OnPendingLogsReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : rpl_logs_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR OnPendingLogsReply::OnPendingLogsReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct OnPendingLogsReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR OnPendingLogsReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnPendingLogsReplyDefaultTypeInternal() {} union { OnPendingLogsReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnPendingLogsReplyDefaultTypeInternal _OnPendingLogsReply_default_instance_; template PROTOBUF_CONSTEXPR OnPendingBlockRequest::OnPendingBlockRequest(::_pbi::ConstantInitialized) {} struct OnPendingBlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR OnPendingBlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnPendingBlockRequestDefaultTypeInternal() {} union { OnPendingBlockRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnPendingBlockRequestDefaultTypeInternal _OnPendingBlockRequest_default_instance_; inline constexpr OnPendingBlockReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : rpl_block_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR OnPendingBlockReply::OnPendingBlockReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct OnPendingBlockReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR OnPendingBlockReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnPendingBlockReplyDefaultTypeInternal() {} union { OnPendingBlockReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnPendingBlockReplyDefaultTypeInternal _OnPendingBlockReply_default_instance_; template PROTOBUF_CONSTEXPR OnMinedBlockRequest::OnMinedBlockRequest(::_pbi::ConstantInitialized) {} struct OnMinedBlockRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR OnMinedBlockRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnMinedBlockRequestDefaultTypeInternal() {} union { OnMinedBlockRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnMinedBlockRequestDefaultTypeInternal _OnMinedBlockRequest_default_instance_; inline constexpr OnMinedBlockReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : rpl_block_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR OnMinedBlockReply::OnMinedBlockReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct OnMinedBlockReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR OnMinedBlockReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnMinedBlockReplyDefaultTypeInternal() {} union { OnMinedBlockReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnMinedBlockReplyDefaultTypeInternal _OnMinedBlockReply_default_instance_; template PROTOBUF_CONSTEXPR MiningRequest::MiningRequest(::_pbi::ConstantInitialized) {} struct MiningRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR MiningRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~MiningRequestDefaultTypeInternal() {} union { MiningRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MiningRequestDefaultTypeInternal _MiningRequest_default_instance_; inline constexpr MiningReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : enabled_{false}, running_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR MiningReply::MiningReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct MiningReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR MiningReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~MiningReplyDefaultTypeInternal() {} union { MiningReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MiningReplyDefaultTypeInternal _MiningReply_default_instance_; template PROTOBUF_CONSTEXPR HashRateRequest::HashRateRequest(::_pbi::ConstantInitialized) {} struct HashRateRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR HashRateRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HashRateRequestDefaultTypeInternal() {} union { HashRateRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HashRateRequestDefaultTypeInternal _HashRateRequest_default_instance_; inline constexpr HashRateReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : hash_rate_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR HashRateReply::HashRateReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct HashRateReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR HashRateReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~HashRateReplyDefaultTypeInternal() {} union { HashRateReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HashRateReplyDefaultTypeInternal _HashRateReply_default_instance_; template PROTOBUF_CONSTEXPR GetWorkRequest::GetWorkRequest(::_pbi::ConstantInitialized) {} struct GetWorkRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR GetWorkRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetWorkRequestDefaultTypeInternal() {} union { GetWorkRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetWorkRequestDefaultTypeInternal _GetWorkRequest_default_instance_; inline constexpr GetWorkReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : header_hash_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), seed_hash_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), target_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), block_number_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), _cached_size_{0} {} template PROTOBUF_CONSTEXPR GetWorkReply::GetWorkReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct GetWorkReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR GetWorkReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~GetWorkReplyDefaultTypeInternal() {} union { GetWorkReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetWorkReplyDefaultTypeInternal _GetWorkReply_default_instance_; } // namespace txpool static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_txpool_2fmining_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_txpool_2fmining_2eproto = nullptr; const ::uint32_t TableStruct_txpool_2fmining_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnPendingBlockRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnPendingBlockReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::OnPendingBlockReply, _impl_.rpl_block_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnMinedBlockRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnMinedBlockReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::OnMinedBlockReply, _impl_.rpl_block_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnPendingLogsRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnPendingLogsReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::OnPendingLogsReply, _impl_.rpl_logs_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::GetWorkRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::GetWorkReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::GetWorkReply, _impl_.header_hash_), PROTOBUF_FIELD_OFFSET(::txpool::GetWorkReply, _impl_.seed_hash_), PROTOBUF_FIELD_OFFSET(::txpool::GetWorkReply, _impl_.target_), PROTOBUF_FIELD_OFFSET(::txpool::GetWorkReply, _impl_.block_number_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::SubmitWorkRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::SubmitWorkRequest, _impl_.block_nonce_), PROTOBUF_FIELD_OFFSET(::txpool::SubmitWorkRequest, _impl_.pow_hash_), PROTOBUF_FIELD_OFFSET(::txpool::SubmitWorkRequest, _impl_.digest_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::SubmitWorkReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::SubmitWorkReply, _impl_.ok_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::SubmitHashRateRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::SubmitHashRateRequest, _impl_.rate_), PROTOBUF_FIELD_OFFSET(::txpool::SubmitHashRateRequest, _impl_.id_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::SubmitHashRateReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::SubmitHashRateReply, _impl_.ok_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::HashRateRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::HashRateReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::HashRateReply, _impl_.hash_rate_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::MiningRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::MiningReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::MiningReply, _impl_.enabled_), PROTOBUF_FIELD_OFFSET(::txpool::MiningReply, _impl_.running_), }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::txpool::OnPendingBlockRequest)}, {8, -1, -1, sizeof(::txpool::OnPendingBlockReply)}, {17, -1, -1, sizeof(::txpool::OnMinedBlockRequest)}, {25, -1, -1, sizeof(::txpool::OnMinedBlockReply)}, {34, -1, -1, sizeof(::txpool::OnPendingLogsRequest)}, {42, -1, -1, sizeof(::txpool::OnPendingLogsReply)}, {51, -1, -1, sizeof(::txpool::GetWorkRequest)}, {59, -1, -1, sizeof(::txpool::GetWorkReply)}, {71, -1, -1, sizeof(::txpool::SubmitWorkRequest)}, {82, -1, -1, sizeof(::txpool::SubmitWorkReply)}, {91, -1, -1, sizeof(::txpool::SubmitHashRateRequest)}, {101, -1, -1, sizeof(::txpool::SubmitHashRateReply)}, {110, -1, -1, sizeof(::txpool::HashRateRequest)}, {118, -1, -1, sizeof(::txpool::HashRateReply)}, {127, -1, -1, sizeof(::txpool::MiningRequest)}, {135, -1, -1, sizeof(::txpool::MiningReply)}, }; static const ::_pb::Message* const file_default_instances[] = { &::txpool::_OnPendingBlockRequest_default_instance_._instance, &::txpool::_OnPendingBlockReply_default_instance_._instance, &::txpool::_OnMinedBlockRequest_default_instance_._instance, &::txpool::_OnMinedBlockReply_default_instance_._instance, &::txpool::_OnPendingLogsRequest_default_instance_._instance, &::txpool::_OnPendingLogsReply_default_instance_._instance, &::txpool::_GetWorkRequest_default_instance_._instance, &::txpool::_GetWorkReply_default_instance_._instance, &::txpool::_SubmitWorkRequest_default_instance_._instance, &::txpool::_SubmitWorkReply_default_instance_._instance, &::txpool::_SubmitHashRateRequest_default_instance_._instance, &::txpool::_SubmitHashRateReply_default_instance_._instance, &::txpool::_HashRateRequest_default_instance_._instance, &::txpool::_HashRateReply_default_instance_._instance, &::txpool::_MiningRequest_default_instance_._instance, &::txpool::_MiningReply_default_instance_._instance, }; const char descriptor_table_protodef_txpool_2fmining_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\023txpool/mining.proto\022\006txpool\032\033google/pr" "otobuf/empty.proto\032\021types/types.proto\"\027\n" "\025OnPendingBlockRequest\"(\n\023OnPendingBlock" "Reply\022\021\n\trpl_block\030\001 \001(\014\"\025\n\023OnMinedBlock" "Request\"&\n\021OnMinedBlockReply\022\021\n\trpl_bloc" "k\030\001 \001(\014\"\026\n\024OnPendingLogsRequest\"&\n\022OnPen" "dingLogsReply\022\020\n\010rpl_logs\030\001 \001(\014\"\020\n\016GetWo" "rkRequest\"\\\n\014GetWorkReply\022\023\n\013header_hash" "\030\001 \001(\t\022\021\n\tseed_hash\030\002 \001(\t\022\016\n\006target\030\003 \001(" "\t\022\024\n\014block_number\030\004 \001(\t\"J\n\021SubmitWorkReq" "uest\022\023\n\013block_nonce\030\001 \001(\014\022\020\n\010pow_hash\030\002 " "\001(\014\022\016\n\006digest\030\003 \001(\014\"\035\n\017SubmitWorkReply\022\n" "\n\002ok\030\001 \001(\010\"1\n\025SubmitHashRateRequest\022\014\n\004r" "ate\030\001 \001(\004\022\n\n\002id\030\002 \001(\014\"!\n\023SubmitHashRateR" "eply\022\n\n\002ok\030\001 \001(\010\"\021\n\017HashRateRequest\"\"\n\rH" "ashRateReply\022\021\n\thash_rate\030\001 \001(\004\"\017\n\rMinin" "gRequest\"/\n\013MiningReply\022\017\n\007enabled\030\001 \001(\010" "\022\017\n\007running\030\002 \001(\0102\342\004\n\006Mining\0226\n\007Version\022" "\026.google.protobuf.Empty\032\023.types.VersionR" "eply\022N\n\016OnPendingBlock\022\035.txpool.OnPendin" "gBlockRequest\032\033.txpool.OnPendingBlockRep" "ly0\001\022H\n\014OnMinedBlock\022\033.txpool.OnMinedBlo" "ckRequest\032\031.txpool.OnMinedBlockReply0\001\022K" "\n\rOnPendingLogs\022\034.txpool.OnPendingLogsRe" "quest\032\032.txpool.OnPendingLogsReply0\001\0227\n\007G" "etWork\022\026.txpool.GetWorkRequest\032\024.txpool." "GetWorkReply\022@\n\nSubmitWork\022\031.txpool.Subm" "itWorkRequest\032\027.txpool.SubmitWorkReply\022L" "\n\016SubmitHashRate\022\035.txpool.SubmitHashRate" "Request\032\033.txpool.SubmitHashRateReply\022:\n\010" "HashRate\022\027.txpool.HashRateRequest\032\025.txpo" "ol.HashRateReply\0224\n\006Mining\022\025.txpool.Mini" "ngRequest\032\023.txpool.MiningReplyB\026Z\024./txpo" "ol;txpoolprotob\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_txpool_2fmining_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_types_2ftypes_2eproto, }; static ::absl::once_flag descriptor_table_txpool_2fmining_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_txpool_2fmining_2eproto = { false, false, 1342, descriptor_table_protodef_txpool_2fmining_2eproto, "txpool/mining.proto", &descriptor_table_txpool_2fmining_2eproto_once, descriptor_table_txpool_2fmining_2eproto_deps, 2, 16, schemas, file_default_instances, TableStruct_txpool_2fmining_2eproto::offsets, file_level_enum_descriptors_txpool_2fmining_2eproto, file_level_service_descriptors_txpool_2fmining_2eproto, }; namespace txpool { // =================================================================== class OnPendingBlockRequest::_Internal { public: }; OnPendingBlockRequest::OnPendingBlockRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.OnPendingBlockRequest) } OnPendingBlockRequest::OnPendingBlockRequest( ::google::protobuf::Arena* arena, const OnPendingBlockRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { OnPendingBlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.OnPendingBlockRequest) } const ::google::protobuf::MessageLite::ClassData* OnPendingBlockRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnPendingBlockRequest, _impl_._cached_size_), false, }, &OnPendingBlockRequest::MergeImpl, &OnPendingBlockRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> OnPendingBlockRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnPendingBlockRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnPendingBlockRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata OnPendingBlockRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OnPendingBlockReply::_Internal { public: }; OnPendingBlockReply::OnPendingBlockReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.OnPendingBlockReply) } inline PROTOBUF_NDEBUG_INLINE OnPendingBlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::OnPendingBlockReply& from_msg) : rpl_block_(arena, from.rpl_block_), _cached_size_{0} {} OnPendingBlockReply::OnPendingBlockReply( ::google::protobuf::Arena* arena, const OnPendingBlockReply& from) : ::google::protobuf::Message(arena) { OnPendingBlockReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.OnPendingBlockReply) } inline PROTOBUF_NDEBUG_INLINE OnPendingBlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : rpl_block_(arena), _cached_size_{0} {} inline void OnPendingBlockReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } OnPendingBlockReply::~OnPendingBlockReply() { // @@protoc_insertion_point(destructor:txpool.OnPendingBlockReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void OnPendingBlockReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.rpl_block_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* OnPendingBlockReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnPendingBlockReply, _impl_._cached_size_), false, }, &OnPendingBlockReply::MergeImpl, &OnPendingBlockReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> OnPendingBlockReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnPendingBlockReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnPendingBlockReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes rpl_block = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(OnPendingBlockReply, _impl_.rpl_block_)}}, }}, {{ 65535, 65535 }}, {{ // bytes rpl_block = 1; {PROTOBUF_FIELD_OFFSET(OnPendingBlockReply, _impl_.rpl_block_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void OnPendingBlockReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.OnPendingBlockReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rpl_block_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* OnPendingBlockReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.OnPendingBlockReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes rpl_block = 1; if (!this->_internal_rpl_block().empty()) { const std::string& _s = this->_internal_rpl_block(); target = stream->WriteBytesMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.OnPendingBlockReply) return target; } ::size_t OnPendingBlockReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.OnPendingBlockReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bytes rpl_block = 1; if (!this->_internal_rpl_block().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_rpl_block()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void OnPendingBlockReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.OnPendingBlockReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_rpl_block().empty()) { _this->_internal_set_rpl_block(from._internal_rpl_block()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void OnPendingBlockReply::CopyFrom(const OnPendingBlockReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.OnPendingBlockReply) if (&from == this) return; Clear(); MergeFrom(from); } void OnPendingBlockReply::InternalSwap(OnPendingBlockReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.rpl_block_, &other->_impl_.rpl_block_, arena); } ::google::protobuf::Metadata OnPendingBlockReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OnMinedBlockRequest::_Internal { public: }; OnMinedBlockRequest::OnMinedBlockRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.OnMinedBlockRequest) } OnMinedBlockRequest::OnMinedBlockRequest( ::google::protobuf::Arena* arena, const OnMinedBlockRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { OnMinedBlockRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.OnMinedBlockRequest) } const ::google::protobuf::MessageLite::ClassData* OnMinedBlockRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnMinedBlockRequest, _impl_._cached_size_), false, }, &OnMinedBlockRequest::MergeImpl, &OnMinedBlockRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> OnMinedBlockRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnMinedBlockRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnMinedBlockRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata OnMinedBlockRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OnMinedBlockReply::_Internal { public: }; OnMinedBlockReply::OnMinedBlockReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.OnMinedBlockReply) } inline PROTOBUF_NDEBUG_INLINE OnMinedBlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::OnMinedBlockReply& from_msg) : rpl_block_(arena, from.rpl_block_), _cached_size_{0} {} OnMinedBlockReply::OnMinedBlockReply( ::google::protobuf::Arena* arena, const OnMinedBlockReply& from) : ::google::protobuf::Message(arena) { OnMinedBlockReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.OnMinedBlockReply) } inline PROTOBUF_NDEBUG_INLINE OnMinedBlockReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : rpl_block_(arena), _cached_size_{0} {} inline void OnMinedBlockReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } OnMinedBlockReply::~OnMinedBlockReply() { // @@protoc_insertion_point(destructor:txpool.OnMinedBlockReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void OnMinedBlockReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.rpl_block_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* OnMinedBlockReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnMinedBlockReply, _impl_._cached_size_), false, }, &OnMinedBlockReply::MergeImpl, &OnMinedBlockReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> OnMinedBlockReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnMinedBlockReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnMinedBlockReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes rpl_block = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(OnMinedBlockReply, _impl_.rpl_block_)}}, }}, {{ 65535, 65535 }}, {{ // bytes rpl_block = 1; {PROTOBUF_FIELD_OFFSET(OnMinedBlockReply, _impl_.rpl_block_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void OnMinedBlockReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.OnMinedBlockReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rpl_block_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* OnMinedBlockReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.OnMinedBlockReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes rpl_block = 1; if (!this->_internal_rpl_block().empty()) { const std::string& _s = this->_internal_rpl_block(); target = stream->WriteBytesMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.OnMinedBlockReply) return target; } ::size_t OnMinedBlockReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.OnMinedBlockReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bytes rpl_block = 1; if (!this->_internal_rpl_block().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_rpl_block()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void OnMinedBlockReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.OnMinedBlockReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_rpl_block().empty()) { _this->_internal_set_rpl_block(from._internal_rpl_block()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void OnMinedBlockReply::CopyFrom(const OnMinedBlockReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.OnMinedBlockReply) if (&from == this) return; Clear(); MergeFrom(from); } void OnMinedBlockReply::InternalSwap(OnMinedBlockReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.rpl_block_, &other->_impl_.rpl_block_, arena); } ::google::protobuf::Metadata OnMinedBlockReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OnPendingLogsRequest::_Internal { public: }; OnPendingLogsRequest::OnPendingLogsRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.OnPendingLogsRequest) } OnPendingLogsRequest::OnPendingLogsRequest( ::google::protobuf::Arena* arena, const OnPendingLogsRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { OnPendingLogsRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.OnPendingLogsRequest) } const ::google::protobuf::MessageLite::ClassData* OnPendingLogsRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnPendingLogsRequest, _impl_._cached_size_), false, }, &OnPendingLogsRequest::MergeImpl, &OnPendingLogsRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> OnPendingLogsRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnPendingLogsRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnPendingLogsRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata OnPendingLogsRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OnPendingLogsReply::_Internal { public: }; OnPendingLogsReply::OnPendingLogsReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.OnPendingLogsReply) } inline PROTOBUF_NDEBUG_INLINE OnPendingLogsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::OnPendingLogsReply& from_msg) : rpl_logs_(arena, from.rpl_logs_), _cached_size_{0} {} OnPendingLogsReply::OnPendingLogsReply( ::google::protobuf::Arena* arena, const OnPendingLogsReply& from) : ::google::protobuf::Message(arena) { OnPendingLogsReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.OnPendingLogsReply) } inline PROTOBUF_NDEBUG_INLINE OnPendingLogsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : rpl_logs_(arena), _cached_size_{0} {} inline void OnPendingLogsReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } OnPendingLogsReply::~OnPendingLogsReply() { // @@protoc_insertion_point(destructor:txpool.OnPendingLogsReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void OnPendingLogsReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.rpl_logs_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* OnPendingLogsReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnPendingLogsReply, _impl_._cached_size_), false, }, &OnPendingLogsReply::MergeImpl, &OnPendingLogsReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> OnPendingLogsReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnPendingLogsReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnPendingLogsReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes rpl_logs = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(OnPendingLogsReply, _impl_.rpl_logs_)}}, }}, {{ 65535, 65535 }}, {{ // bytes rpl_logs = 1; {PROTOBUF_FIELD_OFFSET(OnPendingLogsReply, _impl_.rpl_logs_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void OnPendingLogsReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.OnPendingLogsReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rpl_logs_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* OnPendingLogsReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.OnPendingLogsReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes rpl_logs = 1; if (!this->_internal_rpl_logs().empty()) { const std::string& _s = this->_internal_rpl_logs(); target = stream->WriteBytesMaybeAliased(1, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.OnPendingLogsReply) return target; } ::size_t OnPendingLogsReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.OnPendingLogsReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bytes rpl_logs = 1; if (!this->_internal_rpl_logs().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_rpl_logs()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void OnPendingLogsReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.OnPendingLogsReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_rpl_logs().empty()) { _this->_internal_set_rpl_logs(from._internal_rpl_logs()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void OnPendingLogsReply::CopyFrom(const OnPendingLogsReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.OnPendingLogsReply) if (&from == this) return; Clear(); MergeFrom(from); } void OnPendingLogsReply::InternalSwap(OnPendingLogsReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.rpl_logs_, &other->_impl_.rpl_logs_, arena); } ::google::protobuf::Metadata OnPendingLogsReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetWorkRequest::_Internal { public: }; GetWorkRequest::GetWorkRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.GetWorkRequest) } GetWorkRequest::GetWorkRequest( ::google::protobuf::Arena* arena, const GetWorkRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { GetWorkRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.GetWorkRequest) } const ::google::protobuf::MessageLite::ClassData* GetWorkRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetWorkRequest, _impl_._cached_size_), false, }, &GetWorkRequest::MergeImpl, &GetWorkRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> GetWorkRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_GetWorkRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::GetWorkRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata GetWorkRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class GetWorkReply::_Internal { public: }; GetWorkReply::GetWorkReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.GetWorkReply) } inline PROTOBUF_NDEBUG_INLINE GetWorkReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::GetWorkReply& from_msg) : header_hash_(arena, from.header_hash_), seed_hash_(arena, from.seed_hash_), target_(arena, from.target_), block_number_(arena, from.block_number_), _cached_size_{0} {} GetWorkReply::GetWorkReply( ::google::protobuf::Arena* arena, const GetWorkReply& from) : ::google::protobuf::Message(arena) { GetWorkReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.GetWorkReply) } inline PROTOBUF_NDEBUG_INLINE GetWorkReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : header_hash_(arena), seed_hash_(arena), target_(arena), block_number_(arena), _cached_size_{0} {} inline void GetWorkReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } GetWorkReply::~GetWorkReply() { // @@protoc_insertion_point(destructor:txpool.GetWorkReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void GetWorkReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.header_hash_.Destroy(); _impl_.seed_hash_.Destroy(); _impl_.target_.Destroy(); _impl_.block_number_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* GetWorkReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_._cached_size_), false, }, &GetWorkReply::MergeImpl, &GetWorkReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 4, 0, 66, 2> GetWorkReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 4, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967280, // skipmap offsetof(decltype(_table_), field_entries), 4, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_GetWorkReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::GetWorkReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // string block_number = 4; {::_pbi::TcParser::FastUS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.block_number_)}}, // string header_hash = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.header_hash_)}}, // string seed_hash = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.seed_hash_)}}, // string target = 3; {::_pbi::TcParser::FastUS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.target_)}}, }}, {{ 65535, 65535 }}, {{ // string header_hash = 1; {PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.header_hash_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string seed_hash = 2; {PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.seed_hash_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string target = 3; {PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.target_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string block_number = 4; {PROTOBUF_FIELD_OFFSET(GetWorkReply, _impl_.block_number_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ "\23\13\11\6\14\0\0\0" "txpool.GetWorkReply" "header_hash" "seed_hash" "target" "block_number" }}, }; PROTOBUF_NOINLINE void GetWorkReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.GetWorkReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.header_hash_.ClearToEmpty(); _impl_.seed_hash_.ClearToEmpty(); _impl_.target_.ClearToEmpty(); _impl_.block_number_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* GetWorkReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.GetWorkReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string header_hash = 1; if (!this->_internal_header_hash().empty()) { const std::string& _s = this->_internal_header_hash(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "txpool.GetWorkReply.header_hash"); target = stream->WriteStringMaybeAliased(1, _s, target); } // string seed_hash = 2; if (!this->_internal_seed_hash().empty()) { const std::string& _s = this->_internal_seed_hash(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "txpool.GetWorkReply.seed_hash"); target = stream->WriteStringMaybeAliased(2, _s, target); } // string target = 3; if (!this->_internal_target().empty()) { const std::string& _s = this->_internal_target(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "txpool.GetWorkReply.target"); target = stream->WriteStringMaybeAliased(3, _s, target); } // string block_number = 4; if (!this->_internal_block_number().empty()) { const std::string& _s = this->_internal_block_number(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "txpool.GetWorkReply.block_number"); target = stream->WriteStringMaybeAliased(4, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.GetWorkReply) return target; } ::size_t GetWorkReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.GetWorkReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string header_hash = 1; if (!this->_internal_header_hash().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_header_hash()); } // string seed_hash = 2; if (!this->_internal_seed_hash().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_seed_hash()); } // string target = 3; if (!this->_internal_target().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_target()); } // string block_number = 4; if (!this->_internal_block_number().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_block_number()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void GetWorkReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.GetWorkReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_header_hash().empty()) { _this->_internal_set_header_hash(from._internal_header_hash()); } if (!from._internal_seed_hash().empty()) { _this->_internal_set_seed_hash(from._internal_seed_hash()); } if (!from._internal_target().empty()) { _this->_internal_set_target(from._internal_target()); } if (!from._internal_block_number().empty()) { _this->_internal_set_block_number(from._internal_block_number()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void GetWorkReply::CopyFrom(const GetWorkReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.GetWorkReply) if (&from == this) return; Clear(); MergeFrom(from); } void GetWorkReply::InternalSwap(GetWorkReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.header_hash_, &other->_impl_.header_hash_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.seed_hash_, &other->_impl_.seed_hash_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.target_, &other->_impl_.target_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.block_number_, &other->_impl_.block_number_, arena); } ::google::protobuf::Metadata GetWorkReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SubmitWorkRequest::_Internal { public: }; SubmitWorkRequest::SubmitWorkRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.SubmitWorkRequest) } inline PROTOBUF_NDEBUG_INLINE SubmitWorkRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::SubmitWorkRequest& from_msg) : block_nonce_(arena, from.block_nonce_), pow_hash_(arena, from.pow_hash_), digest_(arena, from.digest_), _cached_size_{0} {} SubmitWorkRequest::SubmitWorkRequest( ::google::protobuf::Arena* arena, const SubmitWorkRequest& from) : ::google::protobuf::Message(arena) { SubmitWorkRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.SubmitWorkRequest) } inline PROTOBUF_NDEBUG_INLINE SubmitWorkRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : block_nonce_(arena), pow_hash_(arena), digest_(arena), _cached_size_{0} {} inline void SubmitWorkRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } SubmitWorkRequest::~SubmitWorkRequest() { // @@protoc_insertion_point(destructor:txpool.SubmitWorkRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SubmitWorkRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.block_nonce_.Destroy(); _impl_.pow_hash_.Destroy(); _impl_.digest_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SubmitWorkRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SubmitWorkRequest, _impl_._cached_size_), false, }, &SubmitWorkRequest::MergeImpl, &SubmitWorkRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 0, 0, 2> SubmitWorkRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SubmitWorkRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::SubmitWorkRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // bytes block_nonce = 1; {::_pbi::TcParser::FastBS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(SubmitWorkRequest, _impl_.block_nonce_)}}, // bytes pow_hash = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(SubmitWorkRequest, _impl_.pow_hash_)}}, // bytes digest = 3; {::_pbi::TcParser::FastBS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(SubmitWorkRequest, _impl_.digest_)}}, }}, {{ 65535, 65535 }}, {{ // bytes block_nonce = 1; {PROTOBUF_FIELD_OFFSET(SubmitWorkRequest, _impl_.block_nonce_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes pow_hash = 2; {PROTOBUF_FIELD_OFFSET(SubmitWorkRequest, _impl_.pow_hash_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes digest = 3; {PROTOBUF_FIELD_OFFSET(SubmitWorkRequest, _impl_.digest_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void SubmitWorkRequest::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.SubmitWorkRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.block_nonce_.ClearToEmpty(); _impl_.pow_hash_.ClearToEmpty(); _impl_.digest_.ClearToEmpty(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SubmitWorkRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.SubmitWorkRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bytes block_nonce = 1; if (!this->_internal_block_nonce().empty()) { const std::string& _s = this->_internal_block_nonce(); target = stream->WriteBytesMaybeAliased(1, _s, target); } // bytes pow_hash = 2; if (!this->_internal_pow_hash().empty()) { const std::string& _s = this->_internal_pow_hash(); target = stream->WriteBytesMaybeAliased(2, _s, target); } // bytes digest = 3; if (!this->_internal_digest().empty()) { const std::string& _s = this->_internal_digest(); target = stream->WriteBytesMaybeAliased(3, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.SubmitWorkRequest) return target; } ::size_t SubmitWorkRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.SubmitWorkRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes block_nonce = 1; if (!this->_internal_block_nonce().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_block_nonce()); } // bytes pow_hash = 2; if (!this->_internal_pow_hash().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_pow_hash()); } // bytes digest = 3; if (!this->_internal_digest().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_digest()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SubmitWorkRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.SubmitWorkRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_block_nonce().empty()) { _this->_internal_set_block_nonce(from._internal_block_nonce()); } if (!from._internal_pow_hash().empty()) { _this->_internal_set_pow_hash(from._internal_pow_hash()); } if (!from._internal_digest().empty()) { _this->_internal_set_digest(from._internal_digest()); } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SubmitWorkRequest::CopyFrom(const SubmitWorkRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.SubmitWorkRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SubmitWorkRequest::InternalSwap(SubmitWorkRequest* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.block_nonce_, &other->_impl_.block_nonce_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.pow_hash_, &other->_impl_.pow_hash_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.digest_, &other->_impl_.digest_, arena); } ::google::protobuf::Metadata SubmitWorkRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SubmitWorkReply::_Internal { public: }; SubmitWorkReply::SubmitWorkReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.SubmitWorkReply) } SubmitWorkReply::SubmitWorkReply( ::google::protobuf::Arena* arena, const SubmitWorkReply& from) : SubmitWorkReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE SubmitWorkReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void SubmitWorkReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.ok_ = {}; } SubmitWorkReply::~SubmitWorkReply() { // @@protoc_insertion_point(destructor:txpool.SubmitWorkReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SubmitWorkReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SubmitWorkReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SubmitWorkReply, _impl_._cached_size_), false, }, &SubmitWorkReply::MergeImpl, &SubmitWorkReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SubmitWorkReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SubmitWorkReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::SubmitWorkReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool ok = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(SubmitWorkReply, _impl_.ok_)}}, }}, {{ 65535, 65535 }}, {{ // bool ok = 1; {PROTOBUF_FIELD_OFFSET(SubmitWorkReply, _impl_.ok_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void SubmitWorkReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.SubmitWorkReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.ok_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SubmitWorkReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.SubmitWorkReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool ok = 1; if (this->_internal_ok() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_ok(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.SubmitWorkReply) return target; } ::size_t SubmitWorkReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.SubmitWorkReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool ok = 1; if (this->_internal_ok() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SubmitWorkReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.SubmitWorkReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_ok() != 0) { _this->_impl_.ok_ = from._impl_.ok_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SubmitWorkReply::CopyFrom(const SubmitWorkReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.SubmitWorkReply) if (&from == this) return; Clear(); MergeFrom(from); } void SubmitWorkReply::InternalSwap(SubmitWorkReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.ok_, other->_impl_.ok_); } ::google::protobuf::Metadata SubmitWorkReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SubmitHashRateRequest::_Internal { public: }; SubmitHashRateRequest::SubmitHashRateRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.SubmitHashRateRequest) } inline PROTOBUF_NDEBUG_INLINE SubmitHashRateRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::SubmitHashRateRequest& from_msg) : id_(arena, from.id_), _cached_size_{0} {} SubmitHashRateRequest::SubmitHashRateRequest( ::google::protobuf::Arena* arena, const SubmitHashRateRequest& from) : ::google::protobuf::Message(arena) { SubmitHashRateRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); _impl_.rate_ = from._impl_.rate_; // @@protoc_insertion_point(copy_constructor:txpool.SubmitHashRateRequest) } inline PROTOBUF_NDEBUG_INLINE SubmitHashRateRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : id_(arena), _cached_size_{0} {} inline void SubmitHashRateRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.rate_ = {}; } SubmitHashRateRequest::~SubmitHashRateRequest() { // @@protoc_insertion_point(destructor:txpool.SubmitHashRateRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SubmitHashRateRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.id_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SubmitHashRateRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SubmitHashRateRequest, _impl_._cached_size_), false, }, &SubmitHashRateRequest::MergeImpl, &SubmitHashRateRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> SubmitHashRateRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SubmitHashRateRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::SubmitHashRateRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bytes id = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(SubmitHashRateRequest, _impl_.id_)}}, // uint64 rate = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SubmitHashRateRequest, _impl_.rate_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(SubmitHashRateRequest, _impl_.rate_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 rate = 1; {PROTOBUF_FIELD_OFFSET(SubmitHashRateRequest, _impl_.rate_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bytes id = 2; {PROTOBUF_FIELD_OFFSET(SubmitHashRateRequest, _impl_.id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void SubmitHashRateRequest::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.SubmitHashRateRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.id_.ClearToEmpty(); _impl_.rate_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SubmitHashRateRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.SubmitHashRateRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 rate = 1; if (this->_internal_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_rate(), target); } // bytes id = 2; if (!this->_internal_id().empty()) { const std::string& _s = this->_internal_id(); target = stream->WriteBytesMaybeAliased(2, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.SubmitHashRateRequest) return target; } ::size_t SubmitHashRateRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.SubmitHashRateRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes id = 2; if (!this->_internal_id().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_id()); } // uint64 rate = 1; if (this->_internal_rate() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_rate()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SubmitHashRateRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.SubmitHashRateRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_id().empty()) { _this->_internal_set_id(from._internal_id()); } if (from._internal_rate() != 0) { _this->_impl_.rate_ = from._impl_.rate_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SubmitHashRateRequest::CopyFrom(const SubmitHashRateRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.SubmitHashRateRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SubmitHashRateRequest::InternalSwap(SubmitHashRateRequest* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, &other->_impl_.id_, arena); swap(_impl_.rate_, other->_impl_.rate_); } ::google::protobuf::Metadata SubmitHashRateRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class SubmitHashRateReply::_Internal { public: }; SubmitHashRateReply::SubmitHashRateReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.SubmitHashRateReply) } SubmitHashRateReply::SubmitHashRateReply( ::google::protobuf::Arena* arena, const SubmitHashRateReply& from) : SubmitHashRateReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE SubmitHashRateReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void SubmitHashRateReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.ok_ = {}; } SubmitHashRateReply::~SubmitHashRateReply() { // @@protoc_insertion_point(destructor:txpool.SubmitHashRateReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void SubmitHashRateReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* SubmitHashRateReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(SubmitHashRateReply, _impl_._cached_size_), false, }, &SubmitHashRateReply::MergeImpl, &SubmitHashRateReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SubmitHashRateReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_SubmitHashRateReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::SubmitHashRateReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool ok = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(SubmitHashRateReply, _impl_.ok_)}}, }}, {{ 65535, 65535 }}, {{ // bool ok = 1; {PROTOBUF_FIELD_OFFSET(SubmitHashRateReply, _impl_.ok_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void SubmitHashRateReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.SubmitHashRateReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.ok_ = false; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* SubmitHashRateReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.SubmitHashRateReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool ok = 1; if (this->_internal_ok() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_ok(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.SubmitHashRateReply) return target; } ::size_t SubmitHashRateReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.SubmitHashRateReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool ok = 1; if (this->_internal_ok() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void SubmitHashRateReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.SubmitHashRateReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_ok() != 0) { _this->_impl_.ok_ = from._impl_.ok_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void SubmitHashRateReply::CopyFrom(const SubmitHashRateReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.SubmitHashRateReply) if (&from == this) return; Clear(); MergeFrom(from); } void SubmitHashRateReply::InternalSwap(SubmitHashRateReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.ok_, other->_impl_.ok_); } ::google::protobuf::Metadata SubmitHashRateReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HashRateRequest::_Internal { public: }; HashRateRequest::HashRateRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.HashRateRequest) } HashRateRequest::HashRateRequest( ::google::protobuf::Arena* arena, const HashRateRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { HashRateRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.HashRateRequest) } const ::google::protobuf::MessageLite::ClassData* HashRateRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HashRateRequest, _impl_._cached_size_), false, }, &HashRateRequest::MergeImpl, &HashRateRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> HashRateRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HashRateRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::HashRateRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata HashRateRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class HashRateReply::_Internal { public: }; HashRateReply::HashRateReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.HashRateReply) } HashRateReply::HashRateReply( ::google::protobuf::Arena* arena, const HashRateReply& from) : HashRateReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE HashRateReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void HashRateReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.hash_rate_ = {}; } HashRateReply::~HashRateReply() { // @@protoc_insertion_point(destructor:txpool.HashRateReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void HashRateReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* HashRateReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(HashRateReply, _impl_._cached_size_), false, }, &HashRateReply::MergeImpl, &HashRateReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> HashRateReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_HashRateReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::HashRateReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 hash_rate = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(HashRateReply, _impl_.hash_rate_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(HashRateReply, _impl_.hash_rate_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 hash_rate = 1; {PROTOBUF_FIELD_OFFSET(HashRateReply, _impl_.hash_rate_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void HashRateReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.HashRateReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.hash_rate_ = ::uint64_t{0u}; _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* HashRateReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.HashRateReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 hash_rate = 1; if (this->_internal_hash_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_hash_rate(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.HashRateReply) return target; } ::size_t HashRateReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.HashRateReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint64 hash_rate = 1; if (this->_internal_hash_rate() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_hash_rate()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void HashRateReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.HashRateReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_hash_rate() != 0) { _this->_impl_.hash_rate_ = from._impl_.hash_rate_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void HashRateReply::CopyFrom(const HashRateReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.HashRateReply) if (&from == this) return; Clear(); MergeFrom(from); } void HashRateReply::InternalSwap(HashRateReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_.hash_rate_, other->_impl_.hash_rate_); } ::google::protobuf::Metadata HashRateReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class MiningRequest::_Internal { public: }; MiningRequest::MiningRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.MiningRequest) } MiningRequest::MiningRequest( ::google::protobuf::Arena* arena, const MiningRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { MiningRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.MiningRequest) } const ::google::protobuf::MessageLite::ClassData* MiningRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(MiningRequest, _impl_._cached_size_), false, }, &MiningRequest::MergeImpl, &MiningRequest::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> MiningRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_MiningRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::MiningRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata MiningRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class MiningReply::_Internal { public: }; MiningReply::MiningReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.MiningReply) } MiningReply::MiningReply( ::google::protobuf::Arena* arena, const MiningReply& from) : MiningReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE MiningReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void MiningReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, enabled_), 0, offsetof(Impl_, running_) - offsetof(Impl_, enabled_) + sizeof(Impl_::running_)); } MiningReply::~MiningReply() { // @@protoc_insertion_point(destructor:txpool.MiningReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void MiningReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* MiningReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(MiningReply, _impl_._cached_size_), false, }, &MiningReply::MergeImpl, &MiningReply::kDescriptorMethods, &descriptor_table_txpool_2fmining_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> MiningReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_MiningReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::MiningReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // bool running = 2; {::_pbi::TcParser::SingularVarintNoZag1(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(MiningReply, _impl_.running_)}}, // bool enabled = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(MiningReply, _impl_.enabled_)}}, }}, {{ 65535, 65535 }}, {{ // bool enabled = 1; {PROTOBUF_FIELD_OFFSET(MiningReply, _impl_.enabled_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // bool running = 2; {PROTOBUF_FIELD_OFFSET(MiningReply, _impl_.running_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void MiningReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.MiningReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.enabled_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.running_) - reinterpret_cast(&_impl_.enabled_)) + sizeof(_impl_.running_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* MiningReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.MiningReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool enabled = 1; if (this->_internal_enabled() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_enabled(), target); } // bool running = 2; if (this->_internal_running() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 2, this->_internal_running(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.MiningReply) return target; } ::size_t MiningReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.MiningReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bool enabled = 1; if (this->_internal_enabled() != 0) { total_size += 2; } // bool running = 2; if (this->_internal_running() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void MiningReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.MiningReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_enabled() != 0) { _this->_impl_.enabled_ = from._impl_.enabled_; } if (from._internal_running() != 0) { _this->_impl_.running_ = from._impl_.running_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void MiningReply::CopyFrom(const MiningReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.MiningReply) if (&from == this) return; Clear(); MergeFrom(from); } void MiningReply::InternalSwap(MiningReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(MiningReply, _impl_.running_) + sizeof(MiningReply::_impl_.running_) - PROTOBUF_FIELD_OFFSET(MiningReply, _impl_.enabled_)>( reinterpret_cast(&_impl_.enabled_), reinterpret_cast(&other->_impl_.enabled_)); } ::google::protobuf::Metadata MiningReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace txpool namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_txpool_2fmining_2eproto), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/txpool/mining.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: txpool/mining.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_txpool_2fmining_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_txpool_2fmining_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_bases.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" #include "types/types.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_txpool_2fmining_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_txpool_2fmining_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_txpool_2fmining_2eproto; namespace txpool { class GetWorkReply; struct GetWorkReplyDefaultTypeInternal; extern GetWorkReplyDefaultTypeInternal _GetWorkReply_default_instance_; class GetWorkRequest; struct GetWorkRequestDefaultTypeInternal; extern GetWorkRequestDefaultTypeInternal _GetWorkRequest_default_instance_; class HashRateReply; struct HashRateReplyDefaultTypeInternal; extern HashRateReplyDefaultTypeInternal _HashRateReply_default_instance_; class HashRateRequest; struct HashRateRequestDefaultTypeInternal; extern HashRateRequestDefaultTypeInternal _HashRateRequest_default_instance_; class MiningReply; struct MiningReplyDefaultTypeInternal; extern MiningReplyDefaultTypeInternal _MiningReply_default_instance_; class MiningRequest; struct MiningRequestDefaultTypeInternal; extern MiningRequestDefaultTypeInternal _MiningRequest_default_instance_; class OnMinedBlockReply; struct OnMinedBlockReplyDefaultTypeInternal; extern OnMinedBlockReplyDefaultTypeInternal _OnMinedBlockReply_default_instance_; class OnMinedBlockRequest; struct OnMinedBlockRequestDefaultTypeInternal; extern OnMinedBlockRequestDefaultTypeInternal _OnMinedBlockRequest_default_instance_; class OnPendingBlockReply; struct OnPendingBlockReplyDefaultTypeInternal; extern OnPendingBlockReplyDefaultTypeInternal _OnPendingBlockReply_default_instance_; class OnPendingBlockRequest; struct OnPendingBlockRequestDefaultTypeInternal; extern OnPendingBlockRequestDefaultTypeInternal _OnPendingBlockRequest_default_instance_; class OnPendingLogsReply; struct OnPendingLogsReplyDefaultTypeInternal; extern OnPendingLogsReplyDefaultTypeInternal _OnPendingLogsReply_default_instance_; class OnPendingLogsRequest; struct OnPendingLogsRequestDefaultTypeInternal; extern OnPendingLogsRequestDefaultTypeInternal _OnPendingLogsRequest_default_instance_; class SubmitHashRateReply; struct SubmitHashRateReplyDefaultTypeInternal; extern SubmitHashRateReplyDefaultTypeInternal _SubmitHashRateReply_default_instance_; class SubmitHashRateRequest; struct SubmitHashRateRequestDefaultTypeInternal; extern SubmitHashRateRequestDefaultTypeInternal _SubmitHashRateRequest_default_instance_; class SubmitWorkReply; struct SubmitWorkReplyDefaultTypeInternal; extern SubmitWorkReplyDefaultTypeInternal _SubmitWorkReply_default_instance_; class SubmitWorkRequest; struct SubmitWorkRequestDefaultTypeInternal; extern SubmitWorkRequestDefaultTypeInternal _SubmitWorkRequest_default_instance_; } // namespace txpool namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace txpool { // =================================================================== // ------------------------------------------------------------------- class SubmitWorkRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.SubmitWorkRequest) */ { public: inline SubmitWorkRequest() : SubmitWorkRequest(nullptr) {} ~SubmitWorkRequest() override; template explicit PROTOBUF_CONSTEXPR SubmitWorkRequest( ::google::protobuf::internal::ConstantInitialized); inline SubmitWorkRequest(const SubmitWorkRequest& from) : SubmitWorkRequest(nullptr, from) {} inline SubmitWorkRequest(SubmitWorkRequest&& from) noexcept : SubmitWorkRequest(nullptr, std::move(from)) {} inline SubmitWorkRequest& operator=(const SubmitWorkRequest& from) { CopyFrom(from); return *this; } inline SubmitWorkRequest& operator=(SubmitWorkRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SubmitWorkRequest& default_instance() { return *internal_default_instance(); } static inline const SubmitWorkRequest* internal_default_instance() { return reinterpret_cast( &_SubmitWorkRequest_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(SubmitWorkRequest& a, SubmitWorkRequest& b) { a.Swap(&b); } inline void Swap(SubmitWorkRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubmitWorkRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubmitWorkRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SubmitWorkRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SubmitWorkRequest& from) { SubmitWorkRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SubmitWorkRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.SubmitWorkRequest"; } protected: explicit SubmitWorkRequest(::google::protobuf::Arena* arena); SubmitWorkRequest(::google::protobuf::Arena* arena, const SubmitWorkRequest& from); SubmitWorkRequest(::google::protobuf::Arena* arena, SubmitWorkRequest&& from) noexcept : SubmitWorkRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlockNonceFieldNumber = 1, kPowHashFieldNumber = 2, kDigestFieldNumber = 3, }; // bytes block_nonce = 1; void clear_block_nonce() ; const std::string& block_nonce() const; template void set_block_nonce(Arg_&& arg, Args_... args); std::string* mutable_block_nonce(); PROTOBUF_NODISCARD std::string* release_block_nonce(); void set_allocated_block_nonce(std::string* value); private: const std::string& _internal_block_nonce() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_block_nonce( const std::string& value); std::string* _internal_mutable_block_nonce(); public: // bytes pow_hash = 2; void clear_pow_hash() ; const std::string& pow_hash() const; template void set_pow_hash(Arg_&& arg, Args_... args); std::string* mutable_pow_hash(); PROTOBUF_NODISCARD std::string* release_pow_hash(); void set_allocated_pow_hash(std::string* value); private: const std::string& _internal_pow_hash() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_pow_hash( const std::string& value); std::string* _internal_mutable_pow_hash(); public: // bytes digest = 3; void clear_digest() ; const std::string& digest() const; template void set_digest(Arg_&& arg, Args_... args); std::string* mutable_digest(); PROTOBUF_NODISCARD std::string* release_digest(); void set_allocated_digest(std::string* value); private: const std::string& _internal_digest() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_digest( const std::string& value); std::string* _internal_mutable_digest(); public: // @@protoc_insertion_point(class_scope:txpool.SubmitWorkRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SubmitWorkRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SubmitWorkRequest& from_msg); ::google::protobuf::internal::ArenaStringPtr block_nonce_; ::google::protobuf::internal::ArenaStringPtr pow_hash_; ::google::protobuf::internal::ArenaStringPtr digest_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class SubmitWorkReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.SubmitWorkReply) */ { public: inline SubmitWorkReply() : SubmitWorkReply(nullptr) {} ~SubmitWorkReply() override; template explicit PROTOBUF_CONSTEXPR SubmitWorkReply( ::google::protobuf::internal::ConstantInitialized); inline SubmitWorkReply(const SubmitWorkReply& from) : SubmitWorkReply(nullptr, from) {} inline SubmitWorkReply(SubmitWorkReply&& from) noexcept : SubmitWorkReply(nullptr, std::move(from)) {} inline SubmitWorkReply& operator=(const SubmitWorkReply& from) { CopyFrom(from); return *this; } inline SubmitWorkReply& operator=(SubmitWorkReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SubmitWorkReply& default_instance() { return *internal_default_instance(); } static inline const SubmitWorkReply* internal_default_instance() { return reinterpret_cast( &_SubmitWorkReply_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(SubmitWorkReply& a, SubmitWorkReply& b) { a.Swap(&b); } inline void Swap(SubmitWorkReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubmitWorkReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubmitWorkReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SubmitWorkReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SubmitWorkReply& from) { SubmitWorkReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SubmitWorkReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.SubmitWorkReply"; } protected: explicit SubmitWorkReply(::google::protobuf::Arena* arena); SubmitWorkReply(::google::protobuf::Arena* arena, const SubmitWorkReply& from); SubmitWorkReply(::google::protobuf::Arena* arena, SubmitWorkReply&& from) noexcept : SubmitWorkReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kOkFieldNumber = 1, }; // bool ok = 1; void clear_ok() ; bool ok() const; void set_ok(bool value); private: bool _internal_ok() const; void _internal_set_ok(bool value); public: // @@protoc_insertion_point(class_scope:txpool.SubmitWorkReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SubmitWorkReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SubmitWorkReply& from_msg); bool ok_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class SubmitHashRateRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.SubmitHashRateRequest) */ { public: inline SubmitHashRateRequest() : SubmitHashRateRequest(nullptr) {} ~SubmitHashRateRequest() override; template explicit PROTOBUF_CONSTEXPR SubmitHashRateRequest( ::google::protobuf::internal::ConstantInitialized); inline SubmitHashRateRequest(const SubmitHashRateRequest& from) : SubmitHashRateRequest(nullptr, from) {} inline SubmitHashRateRequest(SubmitHashRateRequest&& from) noexcept : SubmitHashRateRequest(nullptr, std::move(from)) {} inline SubmitHashRateRequest& operator=(const SubmitHashRateRequest& from) { CopyFrom(from); return *this; } inline SubmitHashRateRequest& operator=(SubmitHashRateRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SubmitHashRateRequest& default_instance() { return *internal_default_instance(); } static inline const SubmitHashRateRequest* internal_default_instance() { return reinterpret_cast( &_SubmitHashRateRequest_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(SubmitHashRateRequest& a, SubmitHashRateRequest& b) { a.Swap(&b); } inline void Swap(SubmitHashRateRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubmitHashRateRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubmitHashRateRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SubmitHashRateRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SubmitHashRateRequest& from) { SubmitHashRateRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SubmitHashRateRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.SubmitHashRateRequest"; } protected: explicit SubmitHashRateRequest(::google::protobuf::Arena* arena); SubmitHashRateRequest(::google::protobuf::Arena* arena, const SubmitHashRateRequest& from); SubmitHashRateRequest(::google::protobuf::Arena* arena, SubmitHashRateRequest&& from) noexcept : SubmitHashRateRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdFieldNumber = 2, kRateFieldNumber = 1, }; // bytes id = 2; void clear_id() ; const std::string& id() const; template void set_id(Arg_&& arg, Args_... args); std::string* mutable_id(); PROTOBUF_NODISCARD std::string* release_id(); void set_allocated_id(std::string* value); private: const std::string& _internal_id() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_id( const std::string& value); std::string* _internal_mutable_id(); public: // uint64 rate = 1; void clear_rate() ; ::uint64_t rate() const; void set_rate(::uint64_t value); private: ::uint64_t _internal_rate() const; void _internal_set_rate(::uint64_t value); public: // @@protoc_insertion_point(class_scope:txpool.SubmitHashRateRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SubmitHashRateRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SubmitHashRateRequest& from_msg); ::google::protobuf::internal::ArenaStringPtr id_; ::uint64_t rate_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class SubmitHashRateReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.SubmitHashRateReply) */ { public: inline SubmitHashRateReply() : SubmitHashRateReply(nullptr) {} ~SubmitHashRateReply() override; template explicit PROTOBUF_CONSTEXPR SubmitHashRateReply( ::google::protobuf::internal::ConstantInitialized); inline SubmitHashRateReply(const SubmitHashRateReply& from) : SubmitHashRateReply(nullptr, from) {} inline SubmitHashRateReply(SubmitHashRateReply&& from) noexcept : SubmitHashRateReply(nullptr, std::move(from)) {} inline SubmitHashRateReply& operator=(const SubmitHashRateReply& from) { CopyFrom(from); return *this; } inline SubmitHashRateReply& operator=(SubmitHashRateReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const SubmitHashRateReply& default_instance() { return *internal_default_instance(); } static inline const SubmitHashRateReply* internal_default_instance() { return reinterpret_cast( &_SubmitHashRateReply_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(SubmitHashRateReply& a, SubmitHashRateReply& b) { a.Swap(&b); } inline void Swap(SubmitHashRateReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubmitHashRateReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubmitHashRateReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const SubmitHashRateReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const SubmitHashRateReply& from) { SubmitHashRateReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(SubmitHashRateReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.SubmitHashRateReply"; } protected: explicit SubmitHashRateReply(::google::protobuf::Arena* arena); SubmitHashRateReply(::google::protobuf::Arena* arena, const SubmitHashRateReply& from); SubmitHashRateReply(::google::protobuf::Arena* arena, SubmitHashRateReply&& from) noexcept : SubmitHashRateReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kOkFieldNumber = 1, }; // bool ok = 1; void clear_ok() ; bool ok() const; void set_ok(bool value); private: bool _internal_ok() const; void _internal_set_ok(bool value); public: // @@protoc_insertion_point(class_scope:txpool.SubmitHashRateReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_SubmitHashRateReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const SubmitHashRateReply& from_msg); bool ok_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class OnPendingLogsRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.OnPendingLogsRequest) */ { public: inline OnPendingLogsRequest() : OnPendingLogsRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR OnPendingLogsRequest( ::google::protobuf::internal::ConstantInitialized); inline OnPendingLogsRequest(const OnPendingLogsRequest& from) : OnPendingLogsRequest(nullptr, from) {} inline OnPendingLogsRequest(OnPendingLogsRequest&& from) noexcept : OnPendingLogsRequest(nullptr, std::move(from)) {} inline OnPendingLogsRequest& operator=(const OnPendingLogsRequest& from) { CopyFrom(from); return *this; } inline OnPendingLogsRequest& operator=(OnPendingLogsRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnPendingLogsRequest& default_instance() { return *internal_default_instance(); } static inline const OnPendingLogsRequest* internal_default_instance() { return reinterpret_cast( &_OnPendingLogsRequest_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(OnPendingLogsRequest& a, OnPendingLogsRequest& b) { a.Swap(&b); } inline void Swap(OnPendingLogsRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnPendingLogsRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnPendingLogsRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const OnPendingLogsRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const OnPendingLogsRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnPendingLogsRequest"; } protected: explicit OnPendingLogsRequest(::google::protobuf::Arena* arena); OnPendingLogsRequest(::google::protobuf::Arena* arena, const OnPendingLogsRequest& from); OnPendingLogsRequest(::google::protobuf::Arena* arena, OnPendingLogsRequest&& from) noexcept : OnPendingLogsRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.OnPendingLogsRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnPendingLogsRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnPendingLogsRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class OnPendingLogsReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.OnPendingLogsReply) */ { public: inline OnPendingLogsReply() : OnPendingLogsReply(nullptr) {} ~OnPendingLogsReply() override; template explicit PROTOBUF_CONSTEXPR OnPendingLogsReply( ::google::protobuf::internal::ConstantInitialized); inline OnPendingLogsReply(const OnPendingLogsReply& from) : OnPendingLogsReply(nullptr, from) {} inline OnPendingLogsReply(OnPendingLogsReply&& from) noexcept : OnPendingLogsReply(nullptr, std::move(from)) {} inline OnPendingLogsReply& operator=(const OnPendingLogsReply& from) { CopyFrom(from); return *this; } inline OnPendingLogsReply& operator=(OnPendingLogsReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnPendingLogsReply& default_instance() { return *internal_default_instance(); } static inline const OnPendingLogsReply* internal_default_instance() { return reinterpret_cast( &_OnPendingLogsReply_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(OnPendingLogsReply& a, OnPendingLogsReply& b) { a.Swap(&b); } inline void Swap(OnPendingLogsReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnPendingLogsReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnPendingLogsReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const OnPendingLogsReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const OnPendingLogsReply& from) { OnPendingLogsReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(OnPendingLogsReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnPendingLogsReply"; } protected: explicit OnPendingLogsReply(::google::protobuf::Arena* arena); OnPendingLogsReply(::google::protobuf::Arena* arena, const OnPendingLogsReply& from); OnPendingLogsReply(::google::protobuf::Arena* arena, OnPendingLogsReply&& from) noexcept : OnPendingLogsReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRplLogsFieldNumber = 1, }; // bytes rpl_logs = 1; void clear_rpl_logs() ; const std::string& rpl_logs() const; template void set_rpl_logs(Arg_&& arg, Args_... args); std::string* mutable_rpl_logs(); PROTOBUF_NODISCARD std::string* release_rpl_logs(); void set_allocated_rpl_logs(std::string* value); private: const std::string& _internal_rpl_logs() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_rpl_logs( const std::string& value); std::string* _internal_mutable_rpl_logs(); public: // @@protoc_insertion_point(class_scope:txpool.OnPendingLogsReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnPendingLogsReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnPendingLogsReply& from_msg); ::google::protobuf::internal::ArenaStringPtr rpl_logs_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class OnPendingBlockRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.OnPendingBlockRequest) */ { public: inline OnPendingBlockRequest() : OnPendingBlockRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR OnPendingBlockRequest( ::google::protobuf::internal::ConstantInitialized); inline OnPendingBlockRequest(const OnPendingBlockRequest& from) : OnPendingBlockRequest(nullptr, from) {} inline OnPendingBlockRequest(OnPendingBlockRequest&& from) noexcept : OnPendingBlockRequest(nullptr, std::move(from)) {} inline OnPendingBlockRequest& operator=(const OnPendingBlockRequest& from) { CopyFrom(from); return *this; } inline OnPendingBlockRequest& operator=(OnPendingBlockRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnPendingBlockRequest& default_instance() { return *internal_default_instance(); } static inline const OnPendingBlockRequest* internal_default_instance() { return reinterpret_cast( &_OnPendingBlockRequest_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(OnPendingBlockRequest& a, OnPendingBlockRequest& b) { a.Swap(&b); } inline void Swap(OnPendingBlockRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnPendingBlockRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnPendingBlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const OnPendingBlockRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const OnPendingBlockRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnPendingBlockRequest"; } protected: explicit OnPendingBlockRequest(::google::protobuf::Arena* arena); OnPendingBlockRequest(::google::protobuf::Arena* arena, const OnPendingBlockRequest& from); OnPendingBlockRequest(::google::protobuf::Arena* arena, OnPendingBlockRequest&& from) noexcept : OnPendingBlockRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.OnPendingBlockRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnPendingBlockRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnPendingBlockRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class OnPendingBlockReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.OnPendingBlockReply) */ { public: inline OnPendingBlockReply() : OnPendingBlockReply(nullptr) {} ~OnPendingBlockReply() override; template explicit PROTOBUF_CONSTEXPR OnPendingBlockReply( ::google::protobuf::internal::ConstantInitialized); inline OnPendingBlockReply(const OnPendingBlockReply& from) : OnPendingBlockReply(nullptr, from) {} inline OnPendingBlockReply(OnPendingBlockReply&& from) noexcept : OnPendingBlockReply(nullptr, std::move(from)) {} inline OnPendingBlockReply& operator=(const OnPendingBlockReply& from) { CopyFrom(from); return *this; } inline OnPendingBlockReply& operator=(OnPendingBlockReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnPendingBlockReply& default_instance() { return *internal_default_instance(); } static inline const OnPendingBlockReply* internal_default_instance() { return reinterpret_cast( &_OnPendingBlockReply_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(OnPendingBlockReply& a, OnPendingBlockReply& b) { a.Swap(&b); } inline void Swap(OnPendingBlockReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnPendingBlockReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnPendingBlockReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const OnPendingBlockReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const OnPendingBlockReply& from) { OnPendingBlockReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(OnPendingBlockReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnPendingBlockReply"; } protected: explicit OnPendingBlockReply(::google::protobuf::Arena* arena); OnPendingBlockReply(::google::protobuf::Arena* arena, const OnPendingBlockReply& from); OnPendingBlockReply(::google::protobuf::Arena* arena, OnPendingBlockReply&& from) noexcept : OnPendingBlockReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRplBlockFieldNumber = 1, }; // bytes rpl_block = 1; void clear_rpl_block() ; const std::string& rpl_block() const; template void set_rpl_block(Arg_&& arg, Args_... args); std::string* mutable_rpl_block(); PROTOBUF_NODISCARD std::string* release_rpl_block(); void set_allocated_rpl_block(std::string* value); private: const std::string& _internal_rpl_block() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_rpl_block( const std::string& value); std::string* _internal_mutable_rpl_block(); public: // @@protoc_insertion_point(class_scope:txpool.OnPendingBlockReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnPendingBlockReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnPendingBlockReply& from_msg); ::google::protobuf::internal::ArenaStringPtr rpl_block_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class OnMinedBlockRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.OnMinedBlockRequest) */ { public: inline OnMinedBlockRequest() : OnMinedBlockRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR OnMinedBlockRequest( ::google::protobuf::internal::ConstantInitialized); inline OnMinedBlockRequest(const OnMinedBlockRequest& from) : OnMinedBlockRequest(nullptr, from) {} inline OnMinedBlockRequest(OnMinedBlockRequest&& from) noexcept : OnMinedBlockRequest(nullptr, std::move(from)) {} inline OnMinedBlockRequest& operator=(const OnMinedBlockRequest& from) { CopyFrom(from); return *this; } inline OnMinedBlockRequest& operator=(OnMinedBlockRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnMinedBlockRequest& default_instance() { return *internal_default_instance(); } static inline const OnMinedBlockRequest* internal_default_instance() { return reinterpret_cast( &_OnMinedBlockRequest_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(OnMinedBlockRequest& a, OnMinedBlockRequest& b) { a.Swap(&b); } inline void Swap(OnMinedBlockRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnMinedBlockRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnMinedBlockRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const OnMinedBlockRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const OnMinedBlockRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnMinedBlockRequest"; } protected: explicit OnMinedBlockRequest(::google::protobuf::Arena* arena); OnMinedBlockRequest(::google::protobuf::Arena* arena, const OnMinedBlockRequest& from); OnMinedBlockRequest(::google::protobuf::Arena* arena, OnMinedBlockRequest&& from) noexcept : OnMinedBlockRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.OnMinedBlockRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnMinedBlockRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnMinedBlockRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class OnMinedBlockReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.OnMinedBlockReply) */ { public: inline OnMinedBlockReply() : OnMinedBlockReply(nullptr) {} ~OnMinedBlockReply() override; template explicit PROTOBUF_CONSTEXPR OnMinedBlockReply( ::google::protobuf::internal::ConstantInitialized); inline OnMinedBlockReply(const OnMinedBlockReply& from) : OnMinedBlockReply(nullptr, from) {} inline OnMinedBlockReply(OnMinedBlockReply&& from) noexcept : OnMinedBlockReply(nullptr, std::move(from)) {} inline OnMinedBlockReply& operator=(const OnMinedBlockReply& from) { CopyFrom(from); return *this; } inline OnMinedBlockReply& operator=(OnMinedBlockReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnMinedBlockReply& default_instance() { return *internal_default_instance(); } static inline const OnMinedBlockReply* internal_default_instance() { return reinterpret_cast( &_OnMinedBlockReply_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(OnMinedBlockReply& a, OnMinedBlockReply& b) { a.Swap(&b); } inline void Swap(OnMinedBlockReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnMinedBlockReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnMinedBlockReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const OnMinedBlockReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const OnMinedBlockReply& from) { OnMinedBlockReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(OnMinedBlockReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnMinedBlockReply"; } protected: explicit OnMinedBlockReply(::google::protobuf::Arena* arena); OnMinedBlockReply(::google::protobuf::Arena* arena, const OnMinedBlockReply& from); OnMinedBlockReply(::google::protobuf::Arena* arena, OnMinedBlockReply&& from) noexcept : OnMinedBlockReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRplBlockFieldNumber = 1, }; // bytes rpl_block = 1; void clear_rpl_block() ; const std::string& rpl_block() const; template void set_rpl_block(Arg_&& arg, Args_... args); std::string* mutable_rpl_block(); PROTOBUF_NODISCARD std::string* release_rpl_block(); void set_allocated_rpl_block(std::string* value); private: const std::string& _internal_rpl_block() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_rpl_block( const std::string& value); std::string* _internal_mutable_rpl_block(); public: // @@protoc_insertion_point(class_scope:txpool.OnMinedBlockReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnMinedBlockReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnMinedBlockReply& from_msg); ::google::protobuf::internal::ArenaStringPtr rpl_block_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class MiningRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.MiningRequest) */ { public: inline MiningRequest() : MiningRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR MiningRequest( ::google::protobuf::internal::ConstantInitialized); inline MiningRequest(const MiningRequest& from) : MiningRequest(nullptr, from) {} inline MiningRequest(MiningRequest&& from) noexcept : MiningRequest(nullptr, std::move(from)) {} inline MiningRequest& operator=(const MiningRequest& from) { CopyFrom(from); return *this; } inline MiningRequest& operator=(MiningRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const MiningRequest& default_instance() { return *internal_default_instance(); } static inline const MiningRequest* internal_default_instance() { return reinterpret_cast( &_MiningRequest_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(MiningRequest& a, MiningRequest& b) { a.Swap(&b); } inline void Swap(MiningRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MiningRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MiningRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const MiningRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const MiningRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.MiningRequest"; } protected: explicit MiningRequest(::google::protobuf::Arena* arena); MiningRequest(::google::protobuf::Arena* arena, const MiningRequest& from); MiningRequest(::google::protobuf::Arena* arena, MiningRequest&& from) noexcept : MiningRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.MiningRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_MiningRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const MiningRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class MiningReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.MiningReply) */ { public: inline MiningReply() : MiningReply(nullptr) {} ~MiningReply() override; template explicit PROTOBUF_CONSTEXPR MiningReply( ::google::protobuf::internal::ConstantInitialized); inline MiningReply(const MiningReply& from) : MiningReply(nullptr, from) {} inline MiningReply(MiningReply&& from) noexcept : MiningReply(nullptr, std::move(from)) {} inline MiningReply& operator=(const MiningReply& from) { CopyFrom(from); return *this; } inline MiningReply& operator=(MiningReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const MiningReply& default_instance() { return *internal_default_instance(); } static inline const MiningReply* internal_default_instance() { return reinterpret_cast( &_MiningReply_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(MiningReply& a, MiningReply& b) { a.Swap(&b); } inline void Swap(MiningReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MiningReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MiningReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const MiningReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const MiningReply& from) { MiningReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(MiningReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.MiningReply"; } protected: explicit MiningReply(::google::protobuf::Arena* arena); MiningReply(::google::protobuf::Arena* arena, const MiningReply& from); MiningReply(::google::protobuf::Arena* arena, MiningReply&& from) noexcept : MiningReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kEnabledFieldNumber = 1, kRunningFieldNumber = 2, }; // bool enabled = 1; void clear_enabled() ; bool enabled() const; void set_enabled(bool value); private: bool _internal_enabled() const; void _internal_set_enabled(bool value); public: // bool running = 2; void clear_running() ; bool running() const; void set_running(bool value); private: bool _internal_running() const; void _internal_set_running(bool value); public: // @@protoc_insertion_point(class_scope:txpool.MiningReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_MiningReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const MiningReply& from_msg); bool enabled_; bool running_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class HashRateRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.HashRateRequest) */ { public: inline HashRateRequest() : HashRateRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR HashRateRequest( ::google::protobuf::internal::ConstantInitialized); inline HashRateRequest(const HashRateRequest& from) : HashRateRequest(nullptr, from) {} inline HashRateRequest(HashRateRequest&& from) noexcept : HashRateRequest(nullptr, std::move(from)) {} inline HashRateRequest& operator=(const HashRateRequest& from) { CopyFrom(from); return *this; } inline HashRateRequest& operator=(HashRateRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HashRateRequest& default_instance() { return *internal_default_instance(); } static inline const HashRateRequest* internal_default_instance() { return reinterpret_cast( &_HashRateRequest_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(HashRateRequest& a, HashRateRequest& b) { a.Swap(&b); } inline void Swap(HashRateRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HashRateRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HashRateRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const HashRateRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const HashRateRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.HashRateRequest"; } protected: explicit HashRateRequest(::google::protobuf::Arena* arena); HashRateRequest(::google::protobuf::Arena* arena, const HashRateRequest& from); HashRateRequest(::google::protobuf::Arena* arena, HashRateRequest&& from) noexcept : HashRateRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.HashRateRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HashRateRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HashRateRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class HashRateReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.HashRateReply) */ { public: inline HashRateReply() : HashRateReply(nullptr) {} ~HashRateReply() override; template explicit PROTOBUF_CONSTEXPR HashRateReply( ::google::protobuf::internal::ConstantInitialized); inline HashRateReply(const HashRateReply& from) : HashRateReply(nullptr, from) {} inline HashRateReply(HashRateReply&& from) noexcept : HashRateReply(nullptr, std::move(from)) {} inline HashRateReply& operator=(const HashRateReply& from) { CopyFrom(from); return *this; } inline HashRateReply& operator=(HashRateReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HashRateReply& default_instance() { return *internal_default_instance(); } static inline const HashRateReply* internal_default_instance() { return reinterpret_cast( &_HashRateReply_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(HashRateReply& a, HashRateReply& b) { a.Swap(&b); } inline void Swap(HashRateReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HashRateReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HashRateReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const HashRateReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const HashRateReply& from) { HashRateReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(HashRateReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.HashRateReply"; } protected: explicit HashRateReply(::google::protobuf::Arena* arena); HashRateReply(::google::protobuf::Arena* arena, const HashRateReply& from); HashRateReply(::google::protobuf::Arena* arena, HashRateReply&& from) noexcept : HashRateReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashRateFieldNumber = 1, }; // uint64 hash_rate = 1; void clear_hash_rate() ; ::uint64_t hash_rate() const; void set_hash_rate(::uint64_t value); private: ::uint64_t _internal_hash_rate() const; void _internal_set_hash_rate(::uint64_t value); public: // @@protoc_insertion_point(class_scope:txpool.HashRateReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_HashRateReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const HashRateReply& from_msg); ::uint64_t hash_rate_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class GetWorkRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.GetWorkRequest) */ { public: inline GetWorkRequest() : GetWorkRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR GetWorkRequest( ::google::protobuf::internal::ConstantInitialized); inline GetWorkRequest(const GetWorkRequest& from) : GetWorkRequest(nullptr, from) {} inline GetWorkRequest(GetWorkRequest&& from) noexcept : GetWorkRequest(nullptr, std::move(from)) {} inline GetWorkRequest& operator=(const GetWorkRequest& from) { CopyFrom(from); return *this; } inline GetWorkRequest& operator=(GetWorkRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetWorkRequest& default_instance() { return *internal_default_instance(); } static inline const GetWorkRequest* internal_default_instance() { return reinterpret_cast( &_GetWorkRequest_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(GetWorkRequest& a, GetWorkRequest& b) { a.Swap(&b); } inline void Swap(GetWorkRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetWorkRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetWorkRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const GetWorkRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const GetWorkRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.GetWorkRequest"; } protected: explicit GetWorkRequest(::google::protobuf::Arena* arena); GetWorkRequest(::google::protobuf::Arena* arena, const GetWorkRequest& from); GetWorkRequest(::google::protobuf::Arena* arena, GetWorkRequest&& from) noexcept : GetWorkRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.GetWorkRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetWorkRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetWorkRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // ------------------------------------------------------------------- class GetWorkReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.GetWorkReply) */ { public: inline GetWorkReply() : GetWorkReply(nullptr) {} ~GetWorkReply() override; template explicit PROTOBUF_CONSTEXPR GetWorkReply( ::google::protobuf::internal::ConstantInitialized); inline GetWorkReply(const GetWorkReply& from) : GetWorkReply(nullptr, from) {} inline GetWorkReply(GetWorkReply&& from) noexcept : GetWorkReply(nullptr, std::move(from)) {} inline GetWorkReply& operator=(const GetWorkReply& from) { CopyFrom(from); return *this; } inline GetWorkReply& operator=(GetWorkReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GetWorkReply& default_instance() { return *internal_default_instance(); } static inline const GetWorkReply* internal_default_instance() { return reinterpret_cast( &_GetWorkReply_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(GetWorkReply& a, GetWorkReply& b) { a.Swap(&b); } inline void Swap(GetWorkReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetWorkReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GetWorkReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const GetWorkReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const GetWorkReply& from) { GetWorkReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(GetWorkReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.GetWorkReply"; } protected: explicit GetWorkReply(::google::protobuf::Arena* arena); GetWorkReply(::google::protobuf::Arena* arena, const GetWorkReply& from); GetWorkReply(::google::protobuf::Arena* arena, GetWorkReply&& from) noexcept : GetWorkReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHeaderHashFieldNumber = 1, kSeedHashFieldNumber = 2, kTargetFieldNumber = 3, kBlockNumberFieldNumber = 4, }; // string header_hash = 1; void clear_header_hash() ; const std::string& header_hash() const; template void set_header_hash(Arg_&& arg, Args_... args); std::string* mutable_header_hash(); PROTOBUF_NODISCARD std::string* release_header_hash(); void set_allocated_header_hash(std::string* value); private: const std::string& _internal_header_hash() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_header_hash( const std::string& value); std::string* _internal_mutable_header_hash(); public: // string seed_hash = 2; void clear_seed_hash() ; const std::string& seed_hash() const; template void set_seed_hash(Arg_&& arg, Args_... args); std::string* mutable_seed_hash(); PROTOBUF_NODISCARD std::string* release_seed_hash(); void set_allocated_seed_hash(std::string* value); private: const std::string& _internal_seed_hash() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed_hash( const std::string& value); std::string* _internal_mutable_seed_hash(); public: // string target = 3; void clear_target() ; const std::string& target() const; template void set_target(Arg_&& arg, Args_... args); std::string* mutable_target(); PROTOBUF_NODISCARD std::string* release_target(); void set_allocated_target(std::string* value); private: const std::string& _internal_target() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_target( const std::string& value); std::string* _internal_mutable_target(); public: // string block_number = 4; void clear_block_number() ; const std::string& block_number() const; template void set_block_number(Arg_&& arg, Args_... args); std::string* mutable_block_number(); PROTOBUF_NODISCARD std::string* release_block_number(); void set_allocated_block_number(std::string* value); private: const std::string& _internal_block_number() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_block_number( const std::string& value); std::string* _internal_mutable_block_number(); public: // @@protoc_insertion_point(class_scope:txpool.GetWorkReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 4, 0, 66, 2> _table_; static constexpr const void* _raw_default_instance_ = &_GetWorkReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const GetWorkReply& from_msg); ::google::protobuf::internal::ArenaStringPtr header_hash_; ::google::protobuf::internal::ArenaStringPtr seed_hash_; ::google::protobuf::internal::ArenaStringPtr target_; ::google::protobuf::internal::ArenaStringPtr block_number_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2fmining_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // OnPendingBlockRequest // ------------------------------------------------------------------- // OnPendingBlockReply // bytes rpl_block = 1; inline void OnPendingBlockReply::clear_rpl_block() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.ClearToEmpty(); } inline const std::string& OnPendingBlockReply::rpl_block() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.OnPendingBlockReply.rpl_block) return _internal_rpl_block(); } template inline PROTOBUF_ALWAYS_INLINE void OnPendingBlockReply::set_rpl_block(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.OnPendingBlockReply.rpl_block) } inline std::string* OnPendingBlockReply::mutable_rpl_block() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_rpl_block(); // @@protoc_insertion_point(field_mutable:txpool.OnPendingBlockReply.rpl_block) return _s; } inline const std::string& OnPendingBlockReply::_internal_rpl_block() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rpl_block_.Get(); } inline void OnPendingBlockReply::_internal_set_rpl_block(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.Set(value, GetArena()); } inline std::string* OnPendingBlockReply::_internal_mutable_rpl_block() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.rpl_block_.Mutable( GetArena()); } inline std::string* OnPendingBlockReply::release_rpl_block() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.OnPendingBlockReply.rpl_block) return _impl_.rpl_block_.Release(); } inline void OnPendingBlockReply::set_allocated_rpl_block(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.rpl_block_.IsDefault()) { _impl_.rpl_block_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.OnPendingBlockReply.rpl_block) } // ------------------------------------------------------------------- // OnMinedBlockRequest // ------------------------------------------------------------------- // OnMinedBlockReply // bytes rpl_block = 1; inline void OnMinedBlockReply::clear_rpl_block() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.ClearToEmpty(); } inline const std::string& OnMinedBlockReply::rpl_block() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.OnMinedBlockReply.rpl_block) return _internal_rpl_block(); } template inline PROTOBUF_ALWAYS_INLINE void OnMinedBlockReply::set_rpl_block(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.OnMinedBlockReply.rpl_block) } inline std::string* OnMinedBlockReply::mutable_rpl_block() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_rpl_block(); // @@protoc_insertion_point(field_mutable:txpool.OnMinedBlockReply.rpl_block) return _s; } inline const std::string& OnMinedBlockReply::_internal_rpl_block() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rpl_block_.Get(); } inline void OnMinedBlockReply::_internal_set_rpl_block(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.Set(value, GetArena()); } inline std::string* OnMinedBlockReply::_internal_mutable_rpl_block() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.rpl_block_.Mutable( GetArena()); } inline std::string* OnMinedBlockReply::release_rpl_block() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.OnMinedBlockReply.rpl_block) return _impl_.rpl_block_.Release(); } inline void OnMinedBlockReply::set_allocated_rpl_block(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_block_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.rpl_block_.IsDefault()) { _impl_.rpl_block_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.OnMinedBlockReply.rpl_block) } // ------------------------------------------------------------------- // OnPendingLogsRequest // ------------------------------------------------------------------- // OnPendingLogsReply // bytes rpl_logs = 1; inline void OnPendingLogsReply::clear_rpl_logs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_logs_.ClearToEmpty(); } inline const std::string& OnPendingLogsReply::rpl_logs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.OnPendingLogsReply.rpl_logs) return _internal_rpl_logs(); } template inline PROTOBUF_ALWAYS_INLINE void OnPendingLogsReply::set_rpl_logs(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_logs_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.OnPendingLogsReply.rpl_logs) } inline std::string* OnPendingLogsReply::mutable_rpl_logs() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_rpl_logs(); // @@protoc_insertion_point(field_mutable:txpool.OnPendingLogsReply.rpl_logs) return _s; } inline const std::string& OnPendingLogsReply::_internal_rpl_logs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rpl_logs_.Get(); } inline void OnPendingLogsReply::_internal_set_rpl_logs(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_logs_.Set(value, GetArena()); } inline std::string* OnPendingLogsReply::_internal_mutable_rpl_logs() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.rpl_logs_.Mutable( GetArena()); } inline std::string* OnPendingLogsReply::release_rpl_logs() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.OnPendingLogsReply.rpl_logs) return _impl_.rpl_logs_.Release(); } inline void OnPendingLogsReply::set_allocated_rpl_logs(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_logs_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.rpl_logs_.IsDefault()) { _impl_.rpl_logs_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.OnPendingLogsReply.rpl_logs) } // ------------------------------------------------------------------- // GetWorkRequest // ------------------------------------------------------------------- // GetWorkReply // string header_hash = 1; inline void GetWorkReply::clear_header_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.header_hash_.ClearToEmpty(); } inline const std::string& GetWorkReply::header_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.GetWorkReply.header_hash) return _internal_header_hash(); } template inline PROTOBUF_ALWAYS_INLINE void GetWorkReply::set_header_hash(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.header_hash_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.GetWorkReply.header_hash) } inline std::string* GetWorkReply::mutable_header_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_header_hash(); // @@protoc_insertion_point(field_mutable:txpool.GetWorkReply.header_hash) return _s; } inline const std::string& GetWorkReply::_internal_header_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.header_hash_.Get(); } inline void GetWorkReply::_internal_set_header_hash(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.header_hash_.Set(value, GetArena()); } inline std::string* GetWorkReply::_internal_mutable_header_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.header_hash_.Mutable( GetArena()); } inline std::string* GetWorkReply::release_header_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.GetWorkReply.header_hash) return _impl_.header_hash_.Release(); } inline void GetWorkReply::set_allocated_header_hash(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.header_hash_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.header_hash_.IsDefault()) { _impl_.header_hash_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.GetWorkReply.header_hash) } // string seed_hash = 2; inline void GetWorkReply::clear_seed_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.seed_hash_.ClearToEmpty(); } inline const std::string& GetWorkReply::seed_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.GetWorkReply.seed_hash) return _internal_seed_hash(); } template inline PROTOBUF_ALWAYS_INLINE void GetWorkReply::set_seed_hash(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.seed_hash_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.GetWorkReply.seed_hash) } inline std::string* GetWorkReply::mutable_seed_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_seed_hash(); // @@protoc_insertion_point(field_mutable:txpool.GetWorkReply.seed_hash) return _s; } inline const std::string& GetWorkReply::_internal_seed_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.seed_hash_.Get(); } inline void GetWorkReply::_internal_set_seed_hash(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.seed_hash_.Set(value, GetArena()); } inline std::string* GetWorkReply::_internal_mutable_seed_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.seed_hash_.Mutable( GetArena()); } inline std::string* GetWorkReply::release_seed_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.GetWorkReply.seed_hash) return _impl_.seed_hash_.Release(); } inline void GetWorkReply::set_allocated_seed_hash(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.seed_hash_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.seed_hash_.IsDefault()) { _impl_.seed_hash_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.GetWorkReply.seed_hash) } // string target = 3; inline void GetWorkReply::clear_target() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.ClearToEmpty(); } inline const std::string& GetWorkReply::target() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.GetWorkReply.target) return _internal_target(); } template inline PROTOBUF_ALWAYS_INLINE void GetWorkReply::set_target(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.GetWorkReply.target) } inline std::string* GetWorkReply::mutable_target() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_target(); // @@protoc_insertion_point(field_mutable:txpool.GetWorkReply.target) return _s; } inline const std::string& GetWorkReply::_internal_target() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.target_.Get(); } inline void GetWorkReply::_internal_set_target(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.Set(value, GetArena()); } inline std::string* GetWorkReply::_internal_mutable_target() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.target_.Mutable( GetArena()); } inline std::string* GetWorkReply::release_target() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.GetWorkReply.target) return _impl_.target_.Release(); } inline void GetWorkReply::set_allocated_target(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.target_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.target_.IsDefault()) { _impl_.target_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.GetWorkReply.target) } // string block_number = 4; inline void GetWorkReply::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_.ClearToEmpty(); } inline const std::string& GetWorkReply::block_number() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.GetWorkReply.block_number) return _internal_block_number(); } template inline PROTOBUF_ALWAYS_INLINE void GetWorkReply::set_block_number(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.GetWorkReply.block_number) } inline std::string* GetWorkReply::mutable_block_number() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_block_number(); // @@protoc_insertion_point(field_mutable:txpool.GetWorkReply.block_number) return _s; } inline const std::string& GetWorkReply::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_.Get(); } inline void GetWorkReply::_internal_set_block_number(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_.Set(value, GetArena()); } inline std::string* GetWorkReply::_internal_mutable_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.block_number_.Mutable( GetArena()); } inline std::string* GetWorkReply::release_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.GetWorkReply.block_number) return _impl_.block_number_.Release(); } inline void GetWorkReply::set_allocated_block_number(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.block_number_.IsDefault()) { _impl_.block_number_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.GetWorkReply.block_number) } // ------------------------------------------------------------------- // SubmitWorkRequest // bytes block_nonce = 1; inline void SubmitWorkRequest::clear_block_nonce() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_nonce_.ClearToEmpty(); } inline const std::string& SubmitWorkRequest::block_nonce() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.SubmitWorkRequest.block_nonce) return _internal_block_nonce(); } template inline PROTOBUF_ALWAYS_INLINE void SubmitWorkRequest::set_block_nonce(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_nonce_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.SubmitWorkRequest.block_nonce) } inline std::string* SubmitWorkRequest::mutable_block_nonce() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_block_nonce(); // @@protoc_insertion_point(field_mutable:txpool.SubmitWorkRequest.block_nonce) return _s; } inline const std::string& SubmitWorkRequest::_internal_block_nonce() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_nonce_.Get(); } inline void SubmitWorkRequest::_internal_set_block_nonce(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_nonce_.Set(value, GetArena()); } inline std::string* SubmitWorkRequest::_internal_mutable_block_nonce() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.block_nonce_.Mutable( GetArena()); } inline std::string* SubmitWorkRequest::release_block_nonce() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.SubmitWorkRequest.block_nonce) return _impl_.block_nonce_.Release(); } inline void SubmitWorkRequest::set_allocated_block_nonce(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_nonce_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.block_nonce_.IsDefault()) { _impl_.block_nonce_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.SubmitWorkRequest.block_nonce) } // bytes pow_hash = 2; inline void SubmitWorkRequest::clear_pow_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pow_hash_.ClearToEmpty(); } inline const std::string& SubmitWorkRequest::pow_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.SubmitWorkRequest.pow_hash) return _internal_pow_hash(); } template inline PROTOBUF_ALWAYS_INLINE void SubmitWorkRequest::set_pow_hash(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pow_hash_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.SubmitWorkRequest.pow_hash) } inline std::string* SubmitWorkRequest::mutable_pow_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_pow_hash(); // @@protoc_insertion_point(field_mutable:txpool.SubmitWorkRequest.pow_hash) return _s; } inline const std::string& SubmitWorkRequest::_internal_pow_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.pow_hash_.Get(); } inline void SubmitWorkRequest::_internal_set_pow_hash(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pow_hash_.Set(value, GetArena()); } inline std::string* SubmitWorkRequest::_internal_mutable_pow_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.pow_hash_.Mutable( GetArena()); } inline std::string* SubmitWorkRequest::release_pow_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.SubmitWorkRequest.pow_hash) return _impl_.pow_hash_.Release(); } inline void SubmitWorkRequest::set_allocated_pow_hash(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pow_hash_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.pow_hash_.IsDefault()) { _impl_.pow_hash_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.SubmitWorkRequest.pow_hash) } // bytes digest = 3; inline void SubmitWorkRequest::clear_digest() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.digest_.ClearToEmpty(); } inline const std::string& SubmitWorkRequest::digest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.SubmitWorkRequest.digest) return _internal_digest(); } template inline PROTOBUF_ALWAYS_INLINE void SubmitWorkRequest::set_digest(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.digest_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.SubmitWorkRequest.digest) } inline std::string* SubmitWorkRequest::mutable_digest() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_digest(); // @@protoc_insertion_point(field_mutable:txpool.SubmitWorkRequest.digest) return _s; } inline const std::string& SubmitWorkRequest::_internal_digest() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.digest_.Get(); } inline void SubmitWorkRequest::_internal_set_digest(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.digest_.Set(value, GetArena()); } inline std::string* SubmitWorkRequest::_internal_mutable_digest() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.digest_.Mutable( GetArena()); } inline std::string* SubmitWorkRequest::release_digest() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.SubmitWorkRequest.digest) return _impl_.digest_.Release(); } inline void SubmitWorkRequest::set_allocated_digest(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.digest_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.digest_.IsDefault()) { _impl_.digest_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.SubmitWorkRequest.digest) } // ------------------------------------------------------------------- // SubmitWorkReply // bool ok = 1; inline void SubmitWorkReply::clear_ok() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = false; } inline bool SubmitWorkReply::ok() const { // @@protoc_insertion_point(field_get:txpool.SubmitWorkReply.ok) return _internal_ok(); } inline void SubmitWorkReply::set_ok(bool value) { _internal_set_ok(value); // @@protoc_insertion_point(field_set:txpool.SubmitWorkReply.ok) } inline bool SubmitWorkReply::_internal_ok() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ok_; } inline void SubmitWorkReply::_internal_set_ok(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = value; } // ------------------------------------------------------------------- // SubmitHashRateRequest // uint64 rate = 1; inline void SubmitHashRateRequest::clear_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rate_ = ::uint64_t{0u}; } inline ::uint64_t SubmitHashRateRequest::rate() const { // @@protoc_insertion_point(field_get:txpool.SubmitHashRateRequest.rate) return _internal_rate(); } inline void SubmitHashRateRequest::set_rate(::uint64_t value) { _internal_set_rate(value); // @@protoc_insertion_point(field_set:txpool.SubmitHashRateRequest.rate) } inline ::uint64_t SubmitHashRateRequest::_internal_rate() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rate_; } inline void SubmitHashRateRequest::_internal_set_rate(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rate_ = value; } // bytes id = 2; inline void SubmitHashRateRequest::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.ClearToEmpty(); } inline const std::string& SubmitHashRateRequest::id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.SubmitHashRateRequest.id) return _internal_id(); } template inline PROTOBUF_ALWAYS_INLINE void SubmitHashRateRequest::set_id(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.SubmitHashRateRequest.id) } inline std::string* SubmitHashRateRequest::mutable_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_id(); // @@protoc_insertion_point(field_mutable:txpool.SubmitHashRateRequest.id) return _s; } inline const std::string& SubmitHashRateRequest::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_.Get(); } inline void SubmitHashRateRequest::_internal_set_id(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.Set(value, GetArena()); } inline std::string* SubmitHashRateRequest::_internal_mutable_id() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.id_.Mutable( GetArena()); } inline std::string* SubmitHashRateRequest::release_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.SubmitHashRateRequest.id) return _impl_.id_.Release(); } inline void SubmitHashRateRequest::set_allocated_id(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.id_.IsDefault()) { _impl_.id_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.SubmitHashRateRequest.id) } // ------------------------------------------------------------------- // SubmitHashRateReply // bool ok = 1; inline void SubmitHashRateReply::clear_ok() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = false; } inline bool SubmitHashRateReply::ok() const { // @@protoc_insertion_point(field_get:txpool.SubmitHashRateReply.ok) return _internal_ok(); } inline void SubmitHashRateReply::set_ok(bool value) { _internal_set_ok(value); // @@protoc_insertion_point(field_set:txpool.SubmitHashRateReply.ok) } inline bool SubmitHashRateReply::_internal_ok() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.ok_; } inline void SubmitHashRateReply::_internal_set_ok(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ok_ = value; } // ------------------------------------------------------------------- // HashRateRequest // ------------------------------------------------------------------- // HashRateReply // uint64 hash_rate = 1; inline void HashRateReply::clear_hash_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hash_rate_ = ::uint64_t{0u}; } inline ::uint64_t HashRateReply::hash_rate() const { // @@protoc_insertion_point(field_get:txpool.HashRateReply.hash_rate) return _internal_hash_rate(); } inline void HashRateReply::set_hash_rate(::uint64_t value) { _internal_set_hash_rate(value); // @@protoc_insertion_point(field_set:txpool.HashRateReply.hash_rate) } inline ::uint64_t HashRateReply::_internal_hash_rate() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.hash_rate_; } inline void HashRateReply::_internal_set_hash_rate(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hash_rate_ = value; } // ------------------------------------------------------------------- // MiningRequest // ------------------------------------------------------------------- // MiningReply // bool enabled = 1; inline void MiningReply::clear_enabled() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enabled_ = false; } inline bool MiningReply::enabled() const { // @@protoc_insertion_point(field_get:txpool.MiningReply.enabled) return _internal_enabled(); } inline void MiningReply::set_enabled(bool value) { _internal_set_enabled(value); // @@protoc_insertion_point(field_set:txpool.MiningReply.enabled) } inline bool MiningReply::_internal_enabled() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.enabled_; } inline void MiningReply::_internal_set_enabled(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enabled_ = value; } // bool running = 2; inline void MiningReply::clear_running() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.running_ = false; } inline bool MiningReply::running() const { // @@protoc_insertion_point(field_get:txpool.MiningReply.running) return _internal_running(); } inline void MiningReply::set_running(bool value) { _internal_set_running(value); // @@protoc_insertion_point(field_set:txpool.MiningReply.running) } inline bool MiningReply::_internal_running() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.running_; } inline void MiningReply::_internal_set_running(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.running_ = value; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace txpool // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_txpool_2fmining_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/27.0/txpool/mining_mock.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: txpool/mining.proto #ifndef GRPC_MOCK_txpool_2fmining_2eproto__INCLUDED #define GRPC_MOCK_txpool_2fmining_2eproto__INCLUDED #include "txpool/mining.pb.h" #include "txpool/mining.grpc.pb.h" #include #include #include namespace txpool { class MockMiningStub : public Mining::StubInterface { public: MOCK_METHOD3(Version, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response)); MOCK_METHOD3(AsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(OnPendingBlockRaw, ::grpc::ClientReaderInterface< ::txpool::OnPendingBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request)); MOCK_METHOD4(AsyncOnPendingBlockRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncOnPendingBlockRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(OnMinedBlockRaw, ::grpc::ClientReaderInterface< ::txpool::OnMinedBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request)); MOCK_METHOD4(AsyncOnMinedBlockRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncOnMinedBlockRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnMinedBlockReply>*(::grpc::ClientContext* context, const ::txpool::OnMinedBlockRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(OnPendingLogsRaw, ::grpc::ClientReaderInterface< ::txpool::OnPendingLogsReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request)); MOCK_METHOD4(AsyncOnPendingLogsRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncOnPendingLogsRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnPendingLogsReply>*(::grpc::ClientContext* context, const ::txpool::OnPendingLogsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(GetWork, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::txpool::GetWorkReply* response)); MOCK_METHOD3(AsyncGetWorkRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>*(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncGetWorkRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::GetWorkReply>*(::grpc::ClientContext* context, const ::txpool::GetWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(SubmitWork, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::txpool::SubmitWorkReply* response)); MOCK_METHOD3(AsyncSubmitWorkRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>*(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSubmitWorkRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitWorkReply>*(::grpc::ClientContext* context, const ::txpool::SubmitWorkRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(SubmitHashRate, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::txpool::SubmitHashRateReply* response)); MOCK_METHOD3(AsyncSubmitHashRateRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>*(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncSubmitHashRateRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::SubmitHashRateReply>*(::grpc::ClientContext* context, const ::txpool::SubmitHashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(HashRate, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::txpool::HashRateReply* response)); MOCK_METHOD3(AsyncHashRateRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>*(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncHashRateRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::HashRateReply>*(::grpc::ClientContext* context, const ::txpool::HashRateRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Mining, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::txpool::MiningReply* response)); MOCK_METHOD3(AsyncMiningRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>*(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncMiningRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::MiningReply>*(::grpc::ClientContext* context, const ::txpool::MiningRequest& request, ::grpc::CompletionQueue* cq)); }; } // namespace txpool #endif // GRPC_MOCK_txpool_2fmining_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/txpool/txpool.grpc.pb.cc ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: txpool/txpool.proto #include "txpool/txpool.pb.h" #include "txpool/txpool.grpc.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace txpool { static const char* Txpool_method_names[] = { "/txpool.Txpool/Version", "/txpool.Txpool/FindUnknown", "/txpool.Txpool/Add", "/txpool.Txpool/Transactions", "/txpool.Txpool/All", "/txpool.Txpool/Pending", "/txpool.Txpool/OnAdd", "/txpool.Txpool/Status", "/txpool.Txpool/Nonce", }; std::unique_ptr< Txpool::Stub> Txpool::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { (void)options; std::unique_ptr< Txpool::Stub> stub(new Txpool::Stub(channel, options)); return stub; } Txpool::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) : channel_(channel), rpcmethod_Version_(Txpool_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_FindUnknown_(Txpool_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Add_(Txpool_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Transactions_(Txpool_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_All_(Txpool_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Pending_(Txpool_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_OnAdd_(Txpool_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) , rpcmethod_Status_(Txpool_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Nonce_(Txpool_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status Txpool::Stub::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Version_, context, request, response); } void Txpool::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, std::move(f)); } void Txpool::Stub::async::Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Version_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* Txpool::Stub::PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::types::VersionReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Version_, context, request); } ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* Txpool::Stub::AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncVersionRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Txpool::Stub::FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::txpool::TxHashes* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::TxHashes, ::txpool::TxHashes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_FindUnknown_, context, request, response); } void Txpool::Stub::async::FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::TxHashes, ::txpool::TxHashes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FindUnknown_, context, request, response, std::move(f)); } void Txpool::Stub::async::FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FindUnknown_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>* Txpool::Stub::PrepareAsyncFindUnknownRaw(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::TxHashes, ::txpool::TxHashes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_FindUnknown_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>* Txpool::Stub::AsyncFindUnknownRaw(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncFindUnknownRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Txpool::Stub::Add(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::txpool::AddReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::AddRequest, ::txpool::AddReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Add_, context, request, response); } void Txpool::Stub::async::Add(::grpc::ClientContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::AddRequest, ::txpool::AddReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Add_, context, request, response, std::move(f)); } void Txpool::Stub::async::Add(::grpc::ClientContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Add_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>* Txpool::Stub::PrepareAsyncAddRaw(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::AddReply, ::txpool::AddRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Add_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>* Txpool::Stub::AsyncAddRaw(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncAddRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Txpool::Stub::Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::txpool::TransactionsReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::TransactionsRequest, ::txpool::TransactionsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Transactions_, context, request, response); } void Txpool::Stub::async::Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::TransactionsRequest, ::txpool::TransactionsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Transactions_, context, request, response, std::move(f)); } void Txpool::Stub::async::Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Transactions_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>* Txpool::Stub::PrepareAsyncTransactionsRaw(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::TransactionsReply, ::txpool::TransactionsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Transactions_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>* Txpool::Stub::AsyncTransactionsRaw(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncTransactionsRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Txpool::Stub::All(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::txpool::AllReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::AllRequest, ::txpool::AllReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_All_, context, request, response); } void Txpool::Stub::async::All(::grpc::ClientContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::AllRequest, ::txpool::AllReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_All_, context, request, response, std::move(f)); } void Txpool::Stub::async::All(::grpc::ClientContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_All_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>* Txpool::Stub::PrepareAsyncAllRaw(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::AllReply, ::txpool::AllRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_All_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>* Txpool::Stub::AsyncAllRaw(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncAllRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Txpool::Stub::Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::txpool::PendingReply* response) { return ::grpc::internal::BlockingUnaryCall< ::google::protobuf::Empty, ::txpool::PendingReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Pending_, context, request, response); } void Txpool::Stub::async::Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::google::protobuf::Empty, ::txpool::PendingReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Pending_, context, request, response, std::move(f)); } void Txpool::Stub::async::Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Pending_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>* Txpool::Stub::PrepareAsyncPendingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::PendingReply, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Pending_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>* Txpool::Stub::AsyncPendingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPendingRaw(context, request, cq); result->StartCall(); return result; } ::grpc::ClientReader< ::txpool::OnAddReply>* Txpool::Stub::OnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request) { return ::grpc::internal::ClientReaderFactory< ::txpool::OnAddReply>::Create(channel_.get(), rpcmethod_OnAdd_, context, request); } void Txpool::Stub::async::OnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest* request, ::grpc::ClientReadReactor< ::txpool::OnAddReply>* reactor) { ::grpc::internal::ClientCallbackReaderFactory< ::txpool::OnAddReply>::Create(stub_->channel_.get(), stub_->rpcmethod_OnAdd_, context, request, reactor); } ::grpc::ClientAsyncReader< ::txpool::OnAddReply>* Txpool::Stub::AsyncOnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnAddReply>::Create(channel_.get(), cq, rpcmethod_OnAdd_, context, request, true, tag); } ::grpc::ClientAsyncReader< ::txpool::OnAddReply>* Txpool::Stub::PrepareAsyncOnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncReaderFactory< ::txpool::OnAddReply>::Create(channel_.get(), cq, rpcmethod_OnAdd_, context, request, false, nullptr); } ::grpc::Status Txpool::Stub::Status(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::txpool::StatusReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::StatusRequest, ::txpool::StatusReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Status_, context, request, response); } void Txpool::Stub::async::Status(::grpc::ClientContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::StatusRequest, ::txpool::StatusReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Status_, context, request, response, std::move(f)); } void Txpool::Stub::async::Status(::grpc::ClientContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Status_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>* Txpool::Stub::PrepareAsyncStatusRaw(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::StatusReply, ::txpool::StatusRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Status_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>* Txpool::Stub::AsyncStatusRaw(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncStatusRaw(context, request, cq); result->StartCall(); return result; } ::grpc::Status Txpool::Stub::Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::txpool::NonceReply* response) { return ::grpc::internal::BlockingUnaryCall< ::txpool::NonceRequest, ::txpool::NonceReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Nonce_, context, request, response); } void Txpool::Stub::async::Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response, std::function f) { ::grpc::internal::CallbackUnaryCall< ::txpool::NonceRequest, ::txpool::NonceReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Nonce_, context, request, response, std::move(f)); } void Txpool::Stub::async::Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Nonce_, context, request, response, reactor); } ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>* Txpool::Stub::PrepareAsyncNonceRaw(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::txpool::NonceReply, ::txpool::NonceRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Nonce_, context, request); } ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>* Txpool::Stub::AsyncNonceRaw(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncNonceRaw(context, request, cq); result->StartCall(); return result; } Txpool::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::google::protobuf::Empty, ::types::VersionReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::types::VersionReply* resp) { return service->Version(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::txpool::TxHashes, ::txpool::TxHashes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::txpool::TxHashes* req, ::txpool::TxHashes* resp) { return service->FindUnknown(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::txpool::AddRequest, ::txpool::AddReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::txpool::AddRequest* req, ::txpool::AddReply* resp) { return service->Add(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::txpool::TransactionsRequest, ::txpool::TransactionsReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::txpool::TransactionsRequest* req, ::txpool::TransactionsReply* resp) { return service->Transactions(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::txpool::AllRequest, ::txpool::AllReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::txpool::AllRequest* req, ::txpool::AllReply* resp) { return service->All(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::google::protobuf::Empty, ::txpool::PendingReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::google::protobuf::Empty* req, ::txpool::PendingReply* resp) { return service->Pending(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[6], ::grpc::internal::RpcMethod::SERVER_STREAMING, new ::grpc::internal::ServerStreamingHandler< Txpool::Service, ::txpool::OnAddRequest, ::txpool::OnAddReply>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::txpool::OnAddRequest* req, ::grpc::ServerWriter<::txpool::OnAddReply>* writer) { return service->OnAdd(ctx, req, writer); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::txpool::StatusRequest, ::txpool::StatusReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::txpool::StatusRequest* req, ::txpool::StatusReply* resp) { return service->Status(ctx, req, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( Txpool_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< Txpool::Service, ::txpool::NonceRequest, ::txpool::NonceReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( [](Txpool::Service* service, ::grpc::ServerContext* ctx, const ::txpool::NonceRequest* req, ::txpool::NonceReply* resp) { return service->Nonce(ctx, req, resp); }, this))); } Txpool::Service::~Service() { } ::grpc::Status Txpool::Service::Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::FindUnknown(::grpc::ServerContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::Add(::grpc::ServerContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::Transactions(::grpc::ServerContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::All(::grpc::ServerContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::Pending(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::OnAdd(::grpc::ServerContext* context, const ::txpool::OnAddRequest* request, ::grpc::ServerWriter< ::txpool::OnAddReply>* writer) { (void) context; (void) request; (void) writer; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::Status(::grpc::ServerContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } ::grpc::Status Txpool::Service::Nonce(::grpc::ServerContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } } // namespace txpool ================================================ FILE: silkworm/interfaces/27.0/txpool/txpool.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: txpool/txpool.proto #ifndef GRPC_txpool_2ftxpool_2eproto__INCLUDED #define GRPC_txpool_2ftxpool_2eproto__INCLUDED #include "txpool/txpool.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace txpool { class Txpool final { public: static constexpr char const* service_full_name() { return "txpool.Txpool"; } class StubInterface { public: virtual ~StubInterface() {} // Version returns the service version number virtual ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } // preserves incoming order, changes amount, unknown hashes will be omitted virtual ::grpc::Status FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::txpool::TxHashes* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>> AsyncFindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>>(AsyncFindUnknownRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>> PrepareAsyncFindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>>(PrepareAsyncFindUnknownRaw(context, request, cq)); } // Expecting signed transactions. Preserves incoming order and amount // Adding txs as local (use P2P to add remote txs) virtual ::grpc::Status Add(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::txpool::AddReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>> AsyncAdd(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>>(AsyncAddRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>> PrepareAsyncAdd(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>>(PrepareAsyncAddRaw(context, request, cq)); } // preserves incoming order and amount, if some transaction doesn't exists in pool - returns nil in this slot virtual ::grpc::Status Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::txpool::TransactionsReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>> AsyncTransactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>>(AsyncTransactionsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>> PrepareAsyncTransactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>>(PrepareAsyncTransactionsRaw(context, request, cq)); } // returns all transactions from tx pool virtual ::grpc::Status All(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::txpool::AllReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>> AsyncAll(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>>(AsyncAllRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>> PrepareAsyncAll(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>>(PrepareAsyncAllRaw(context, request, cq)); } // Returns all pending (processable) transactions, in ready-for-mining order virtual ::grpc::Status Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::txpool::PendingReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>> AsyncPending(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>>(AsyncPendingRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>> PrepareAsyncPending(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>>(PrepareAsyncPendingRaw(context, request, cq)); } // subscribe to new transactions add event std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnAddReply>> OnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::txpool::OnAddReply>>(OnAddRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>> AsyncOnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>>(AsyncOnAddRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>> PrepareAsyncOnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>>(PrepareAsyncOnAddRaw(context, request, cq)); } // returns high level status virtual ::grpc::Status Status(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::txpool::StatusReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>> AsyncStatus(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>>(AsyncStatusRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>> PrepareAsyncStatus(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>>(PrepareAsyncStatusRaw(context, request, cq)); } // returns nonce for given account virtual ::grpc::Status Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::txpool::NonceReply* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>> AsyncNonce(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>>(AsyncNonceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>> PrepareAsyncNonce(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>>(PrepareAsyncNonceRaw(context, request, cq)); } class async_interface { public: virtual ~async_interface() {} // Version returns the service version number virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) = 0; virtual void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // preserves incoming order, changes amount, unknown hashes will be omitted virtual void FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response, std::function) = 0; virtual void FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Expecting signed transactions. Preserves incoming order and amount // Adding txs as local (use P2P to add remote txs) virtual void Add(::grpc::ClientContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response, std::function) = 0; virtual void Add(::grpc::ClientContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // preserves incoming order and amount, if some transaction doesn't exists in pool - returns nil in this slot virtual void Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response, std::function) = 0; virtual void Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // returns all transactions from tx pool virtual void All(::grpc::ClientContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response, std::function) = 0; virtual void All(::grpc::ClientContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // Returns all pending (processable) transactions, in ready-for-mining order virtual void Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response, std::function) = 0; virtual void Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // subscribe to new transactions add event virtual void OnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest* request, ::grpc::ClientReadReactor< ::txpool::OnAddReply>* reactor) = 0; // returns high level status virtual void Status(::grpc::ClientContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response, std::function) = 0; virtual void Status(::grpc::ClientContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; // returns nonce for given account virtual void Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response, std::function) = 0; virtual void Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response, ::grpc::ClientUnaryReactor* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>* AsyncFindUnknownRaw(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>* PrepareAsyncFindUnknownRaw(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>* AsyncAddRaw(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>* PrepareAsyncAddRaw(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>* AsyncTransactionsRaw(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>* PrepareAsyncTransactionsRaw(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>* AsyncAllRaw(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>* PrepareAsyncAllRaw(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>* AsyncPendingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>* PrepareAsyncPendingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::txpool::OnAddReply>* OnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>* AsyncOnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>* PrepareAsyncOnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>* AsyncStatusRaw(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>* PrepareAsyncStatusRaw(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>* AsyncNonceRaw(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>* PrepareAsyncNonceRaw(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status Version(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> AsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(AsyncVersionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>> PrepareAsyncVersion(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::types::VersionReply>>(PrepareAsyncVersionRaw(context, request, cq)); } ::grpc::Status FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::txpool::TxHashes* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>> AsyncFindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>>(AsyncFindUnknownRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>> PrepareAsyncFindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>>(PrepareAsyncFindUnknownRaw(context, request, cq)); } ::grpc::Status Add(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::txpool::AddReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>> AsyncAdd(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>>(AsyncAddRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>> PrepareAsyncAdd(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>>(PrepareAsyncAddRaw(context, request, cq)); } ::grpc::Status Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::txpool::TransactionsReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>> AsyncTransactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>>(AsyncTransactionsRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>> PrepareAsyncTransactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>>(PrepareAsyncTransactionsRaw(context, request, cq)); } ::grpc::Status All(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::txpool::AllReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>> AsyncAll(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>>(AsyncAllRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>> PrepareAsyncAll(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>>(PrepareAsyncAllRaw(context, request, cq)); } ::grpc::Status Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::txpool::PendingReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>> AsyncPending(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>>(AsyncPendingRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>> PrepareAsyncPending(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>>(PrepareAsyncPendingRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::txpool::OnAddReply>> OnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::txpool::OnAddReply>>(OnAddRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnAddReply>> AsyncOnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnAddReply>>(AsyncOnAddRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnAddReply>> PrepareAsyncOnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::txpool::OnAddReply>>(PrepareAsyncOnAddRaw(context, request, cq)); } ::grpc::Status Status(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::txpool::StatusReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>> AsyncStatus(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>>(AsyncStatusRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>> PrepareAsyncStatus(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>>(PrepareAsyncStatusRaw(context, request, cq)); } ::grpc::Status Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::txpool::NonceReply* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>> AsyncNonce(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>>(AsyncNonceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>> PrepareAsyncNonce(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>>(PrepareAsyncNonceRaw(context, request, cq)); } class async final : public StubInterface::async_interface { public: void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, std::function) override; void Version(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response, ::grpc::ClientUnaryReactor* reactor) override; void FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response, std::function) override; void FindUnknown(::grpc::ClientContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response, ::grpc::ClientUnaryReactor* reactor) override; void Add(::grpc::ClientContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response, std::function) override; void Add(::grpc::ClientContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response, std::function) override; void Transactions(::grpc::ClientContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response, ::grpc::ClientUnaryReactor* reactor) override; void All(::grpc::ClientContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response, std::function) override; void All(::grpc::ClientContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response, std::function) override; void Pending(::grpc::ClientContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response, ::grpc::ClientUnaryReactor* reactor) override; void OnAdd(::grpc::ClientContext* context, const ::txpool::OnAddRequest* request, ::grpc::ClientReadReactor< ::txpool::OnAddReply>* reactor) override; void Status(::grpc::ClientContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response, std::function) override; void Status(::grpc::ClientContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response, ::grpc::ClientUnaryReactor* reactor) override; void Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response, std::function) override; void Nonce(::grpc::ClientContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } Stub* stub() { return stub_; } Stub* stub_; }; class async* async() override { return &async_stub_; } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* AsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::types::VersionReply>* PrepareAsyncVersionRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>* AsyncFindUnknownRaw(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::TxHashes>* PrepareAsyncFindUnknownRaw(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>* AsyncAddRaw(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::AddReply>* PrepareAsyncAddRaw(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>* AsyncTransactionsRaw(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::TransactionsReply>* PrepareAsyncTransactionsRaw(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>* AsyncAllRaw(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::AllReply>* PrepareAsyncAllRaw(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>* AsyncPendingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::PendingReply>* PrepareAsyncPendingRaw(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::txpool::OnAddReply>* OnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request) override; ::grpc::ClientAsyncReader< ::txpool::OnAddReply>* AsyncOnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::txpool::OnAddReply>* PrepareAsyncOnAddRaw(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>* AsyncStatusRaw(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::StatusReply>* PrepareAsyncStatusRaw(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>* AsyncNonceRaw(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::txpool::NonceReply>* PrepareAsyncNonceRaw(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_Version_; const ::grpc::internal::RpcMethod rpcmethod_FindUnknown_; const ::grpc::internal::RpcMethod rpcmethod_Add_; const ::grpc::internal::RpcMethod rpcmethod_Transactions_; const ::grpc::internal::RpcMethod rpcmethod_All_; const ::grpc::internal::RpcMethod rpcmethod_Pending_; const ::grpc::internal::RpcMethod rpcmethod_OnAdd_; const ::grpc::internal::RpcMethod rpcmethod_Status_; const ::grpc::internal::RpcMethod rpcmethod_Nonce_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); class Service : public ::grpc::Service { public: Service(); virtual ~Service(); // Version returns the service version number virtual ::grpc::Status Version(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response); // preserves incoming order, changes amount, unknown hashes will be omitted virtual ::grpc::Status FindUnknown(::grpc::ServerContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response); // Expecting signed transactions. Preserves incoming order and amount // Adding txs as local (use P2P to add remote txs) virtual ::grpc::Status Add(::grpc::ServerContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response); // preserves incoming order and amount, if some transaction doesn't exists in pool - returns nil in this slot virtual ::grpc::Status Transactions(::grpc::ServerContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response); // returns all transactions from tx pool virtual ::grpc::Status All(::grpc::ServerContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response); // Returns all pending (processable) transactions, in ready-for-mining order virtual ::grpc::Status Pending(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response); // subscribe to new transactions add event virtual ::grpc::Status OnAdd(::grpc::ServerContext* context, const ::txpool::OnAddRequest* request, ::grpc::ServerWriter< ::txpool::OnAddReply>* writer); // returns high level status virtual ::grpc::Status Status(::grpc::ServerContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response); // returns nonce for given account virtual ::grpc::Status Nonce(::grpc::ServerContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response); }; template class WithAsyncMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Version() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::types::VersionReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_FindUnknown : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_FindUnknown() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_FindUnknown() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FindUnknown(::grpc::ServerContext* /*context*/, const ::txpool::TxHashes* /*request*/, ::txpool::TxHashes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFindUnknown(::grpc::ServerContext* context, ::txpool::TxHashes* request, ::grpc::ServerAsyncResponseWriter< ::txpool::TxHashes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Add : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Add() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_Add() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Add(::grpc::ServerContext* /*context*/, const ::txpool::AddRequest* /*request*/, ::txpool::AddReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAdd(::grpc::ServerContext* context, ::txpool::AddRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::AddReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Transactions : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Transactions() { ::grpc::Service::MarkMethodAsync(3); } ~WithAsyncMethod_Transactions() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Transactions(::grpc::ServerContext* /*context*/, const ::txpool::TransactionsRequest* /*request*/, ::txpool::TransactionsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestTransactions(::grpc::ServerContext* context, ::txpool::TransactionsRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::TransactionsReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_All : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_All() { ::grpc::Service::MarkMethodAsync(4); } ~WithAsyncMethod_All() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status All(::grpc::ServerContext* /*context*/, const ::txpool::AllRequest* /*request*/, ::txpool::AllReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAll(::grpc::ServerContext* context, ::txpool::AllRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::AllReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Pending : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Pending() { ::grpc::Service::MarkMethodAsync(5); } ~WithAsyncMethod_Pending() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Pending(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::txpool::PendingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPending(::grpc::ServerContext* context, ::google::protobuf::Empty* request, ::grpc::ServerAsyncResponseWriter< ::txpool::PendingReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_OnAdd : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_OnAdd() { ::grpc::Service::MarkMethodAsync(6); } ~WithAsyncMethod_OnAdd() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnAdd(::grpc::ServerContext* /*context*/, const ::txpool::OnAddRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnAddReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnAdd(::grpc::ServerContext* context, ::txpool::OnAddRequest* request, ::grpc::ServerAsyncWriter< ::txpool::OnAddReply>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(6, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Status : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Status() { ::grpc::Service::MarkMethodAsync(7); } ~WithAsyncMethod_Status() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Status(::grpc::ServerContext* /*context*/, const ::txpool::StatusRequest* /*request*/, ::txpool::StatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestStatus(::grpc::ServerContext* context, ::txpool::StatusRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::StatusReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Nonce : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Nonce() { ::grpc::Service::MarkMethodAsync(8); } ~WithAsyncMethod_Nonce() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Nonce(::grpc::ServerContext* /*context*/, const ::txpool::NonceRequest* /*request*/, ::txpool::NonceReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNonce(::grpc::ServerContext* context, ::txpool::NonceRequest* request, ::grpc::ServerAsyncResponseWriter< ::txpool::NonceReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_Version > > > > > > > > AsyncService; template class WithCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Version() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::types::VersionReply* response) { return this->Version(context, request, response); }));} void SetMessageAllocatorFor_Version( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::types::VersionReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_FindUnknown : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_FindUnknown() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::txpool::TxHashes, ::txpool::TxHashes>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::TxHashes* request, ::txpool::TxHashes* response) { return this->FindUnknown(context, request, response); }));} void SetMessageAllocatorFor_FindUnknown( ::grpc::MessageAllocator< ::txpool::TxHashes, ::txpool::TxHashes>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::TxHashes, ::txpool::TxHashes>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_FindUnknown() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FindUnknown(::grpc::ServerContext* /*context*/, const ::txpool::TxHashes* /*request*/, ::txpool::TxHashes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* FindUnknown( ::grpc::CallbackServerContext* /*context*/, const ::txpool::TxHashes* /*request*/, ::txpool::TxHashes* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Add : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Add() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::txpool::AddRequest, ::txpool::AddReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::AddRequest* request, ::txpool::AddReply* response) { return this->Add(context, request, response); }));} void SetMessageAllocatorFor_Add( ::grpc::MessageAllocator< ::txpool::AddRequest, ::txpool::AddReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::AddRequest, ::txpool::AddReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Add() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Add(::grpc::ServerContext* /*context*/, const ::txpool::AddRequest* /*request*/, ::txpool::AddReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Add( ::grpc::CallbackServerContext* /*context*/, const ::txpool::AddRequest* /*request*/, ::txpool::AddReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Transactions : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Transactions() { ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::txpool::TransactionsRequest, ::txpool::TransactionsReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::TransactionsRequest* request, ::txpool::TransactionsReply* response) { return this->Transactions(context, request, response); }));} void SetMessageAllocatorFor_Transactions( ::grpc::MessageAllocator< ::txpool::TransactionsRequest, ::txpool::TransactionsReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::TransactionsRequest, ::txpool::TransactionsReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Transactions() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Transactions(::grpc::ServerContext* /*context*/, const ::txpool::TransactionsRequest* /*request*/, ::txpool::TransactionsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Transactions( ::grpc::CallbackServerContext* /*context*/, const ::txpool::TransactionsRequest* /*request*/, ::txpool::TransactionsReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_All : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_All() { ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::txpool::AllRequest, ::txpool::AllReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::AllRequest* request, ::txpool::AllReply* response) { return this->All(context, request, response); }));} void SetMessageAllocatorFor_All( ::grpc::MessageAllocator< ::txpool::AllRequest, ::txpool::AllReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::AllRequest, ::txpool::AllReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_All() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status All(::grpc::ServerContext* /*context*/, const ::txpool::AllRequest* /*request*/, ::txpool::AllReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* All( ::grpc::CallbackServerContext* /*context*/, const ::txpool::AllRequest* /*request*/, ::txpool::AllReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Pending : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Pending() { ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::txpool::PendingReply>( [this]( ::grpc::CallbackServerContext* context, const ::google::protobuf::Empty* request, ::txpool::PendingReply* response) { return this->Pending(context, request, response); }));} void SetMessageAllocatorFor_Pending( ::grpc::MessageAllocator< ::google::protobuf::Empty, ::txpool::PendingReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); static_cast<::grpc::internal::CallbackUnaryHandler< ::google::protobuf::Empty, ::txpool::PendingReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Pending() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Pending(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::txpool::PendingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Pending( ::grpc::CallbackServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::txpool::PendingReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_OnAdd : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_OnAdd() { ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackServerStreamingHandler< ::txpool::OnAddRequest, ::txpool::OnAddReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::OnAddRequest* request) { return this->OnAdd(context, request); })); } ~WithCallbackMethod_OnAdd() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnAdd(::grpc::ServerContext* /*context*/, const ::txpool::OnAddRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnAddReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::txpool::OnAddReply>* OnAdd( ::grpc::CallbackServerContext* /*context*/, const ::txpool::OnAddRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_Status : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Status() { ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::txpool::StatusRequest, ::txpool::StatusReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::StatusRequest* request, ::txpool::StatusReply* response) { return this->Status(context, request, response); }));} void SetMessageAllocatorFor_Status( ::grpc::MessageAllocator< ::txpool::StatusRequest, ::txpool::StatusReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::StatusRequest, ::txpool::StatusReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Status() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Status(::grpc::ServerContext* /*context*/, const ::txpool::StatusRequest* /*request*/, ::txpool::StatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Status( ::grpc::CallbackServerContext* /*context*/, const ::txpool::StatusRequest* /*request*/, ::txpool::StatusReply* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Nonce : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Nonce() { ::grpc::Service::MarkMethodCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::txpool::NonceRequest, ::txpool::NonceReply>( [this]( ::grpc::CallbackServerContext* context, const ::txpool::NonceRequest* request, ::txpool::NonceReply* response) { return this->Nonce(context, request, response); }));} void SetMessageAllocatorFor_Nonce( ::grpc::MessageAllocator< ::txpool::NonceRequest, ::txpool::NonceReply>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(8); static_cast<::grpc::internal::CallbackUnaryHandler< ::txpool::NonceRequest, ::txpool::NonceReply>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Nonce() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Nonce(::grpc::ServerContext* /*context*/, const ::txpool::NonceRequest* /*request*/, ::txpool::NonceReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Nonce( ::grpc::CallbackServerContext* /*context*/, const ::txpool::NonceRequest* /*request*/, ::txpool::NonceReply* /*response*/) { return nullptr; } }; typedef WithCallbackMethod_Version > > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Version() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_FindUnknown : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_FindUnknown() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_FindUnknown() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FindUnknown(::grpc::ServerContext* /*context*/, const ::txpool::TxHashes* /*request*/, ::txpool::TxHashes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Add : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Add() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_Add() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Add(::grpc::ServerContext* /*context*/, const ::txpool::AddRequest* /*request*/, ::txpool::AddReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Transactions : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Transactions() { ::grpc::Service::MarkMethodGeneric(3); } ~WithGenericMethod_Transactions() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Transactions(::grpc::ServerContext* /*context*/, const ::txpool::TransactionsRequest* /*request*/, ::txpool::TransactionsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_All : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_All() { ::grpc::Service::MarkMethodGeneric(4); } ~WithGenericMethod_All() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status All(::grpc::ServerContext* /*context*/, const ::txpool::AllRequest* /*request*/, ::txpool::AllReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Pending : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Pending() { ::grpc::Service::MarkMethodGeneric(5); } ~WithGenericMethod_Pending() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Pending(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::txpool::PendingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_OnAdd : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_OnAdd() { ::grpc::Service::MarkMethodGeneric(6); } ~WithGenericMethod_OnAdd() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnAdd(::grpc::ServerContext* /*context*/, const ::txpool::OnAddRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnAddReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Status : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Status() { ::grpc::Service::MarkMethodGeneric(7); } ~WithGenericMethod_Status() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Status(::grpc::ServerContext* /*context*/, const ::txpool::StatusRequest* /*request*/, ::txpool::StatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Nonce : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Nonce() { ::grpc::Service::MarkMethodGeneric(8); } ~WithGenericMethod_Nonce() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Nonce(::grpc::ServerContext* /*context*/, const ::txpool::NonceRequest* /*request*/, ::txpool::NonceReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Version() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestVersion(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_FindUnknown : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_FindUnknown() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_FindUnknown() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FindUnknown(::grpc::ServerContext* /*context*/, const ::txpool::TxHashes* /*request*/, ::txpool::TxHashes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFindUnknown(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Add : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Add() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_Add() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Add(::grpc::ServerContext* /*context*/, const ::txpool::AddRequest* /*request*/, ::txpool::AddReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAdd(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Transactions : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Transactions() { ::grpc::Service::MarkMethodRaw(3); } ~WithRawMethod_Transactions() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Transactions(::grpc::ServerContext* /*context*/, const ::txpool::TransactionsRequest* /*request*/, ::txpool::TransactionsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestTransactions(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_All : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_All() { ::grpc::Service::MarkMethodRaw(4); } ~WithRawMethod_All() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status All(::grpc::ServerContext* /*context*/, const ::txpool::AllRequest* /*request*/, ::txpool::AllReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestAll(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Pending : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Pending() { ::grpc::Service::MarkMethodRaw(5); } ~WithRawMethod_Pending() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Pending(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::txpool::PendingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPending(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_OnAdd : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_OnAdd() { ::grpc::Service::MarkMethodRaw(6); } ~WithRawMethod_OnAdd() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnAdd(::grpc::ServerContext* /*context*/, const ::txpool::OnAddRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnAddReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestOnAdd(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(6, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Status : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Status() { ::grpc::Service::MarkMethodRaw(7); } ~WithRawMethod_Status() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Status(::grpc::ServerContext* /*context*/, const ::txpool::StatusRequest* /*request*/, ::txpool::StatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestStatus(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Nonce : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Nonce() { ::grpc::Service::MarkMethodRaw(8); } ~WithRawMethod_Nonce() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Nonce(::grpc::ServerContext* /*context*/, const ::txpool::NonceRequest* /*request*/, ::txpool::NonceReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNonce(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Version() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Version(context, request, response); })); } ~WithRawCallbackMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Version( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_FindUnknown : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_FindUnknown() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->FindUnknown(context, request, response); })); } ~WithRawCallbackMethod_FindUnknown() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status FindUnknown(::grpc::ServerContext* /*context*/, const ::txpool::TxHashes* /*request*/, ::txpool::TxHashes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* FindUnknown( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Add : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Add() { ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Add(context, request, response); })); } ~WithRawCallbackMethod_Add() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Add(::grpc::ServerContext* /*context*/, const ::txpool::AddRequest* /*request*/, ::txpool::AddReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Add( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Transactions : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Transactions() { ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Transactions(context, request, response); })); } ~WithRawCallbackMethod_Transactions() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Transactions(::grpc::ServerContext* /*context*/, const ::txpool::TransactionsRequest* /*request*/, ::txpool::TransactionsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Transactions( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_All : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_All() { ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->All(context, request, response); })); } ~WithRawCallbackMethod_All() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status All(::grpc::ServerContext* /*context*/, const ::txpool::AllRequest* /*request*/, ::txpool::AllReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* All( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Pending : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Pending() { ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Pending(context, request, response); })); } ~WithRawCallbackMethod_Pending() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Pending(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::txpool::PendingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Pending( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_OnAdd : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_OnAdd() { ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->OnAdd(context, request); })); } ~WithRawCallbackMethod_OnAdd() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status OnAdd(::grpc::ServerContext* /*context*/, const ::txpool::OnAddRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnAddReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* OnAdd( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_Status : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Status() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Status(context, request, response); })); } ~WithRawCallbackMethod_Status() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Status(::grpc::ServerContext* /*context*/, const ::txpool::StatusRequest* /*request*/, ::txpool::StatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Status( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Nonce : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Nonce() { ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Nonce(context, request, response); })); } ~WithRawCallbackMethod_Nonce() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Nonce(::grpc::ServerContext* /*context*/, const ::txpool::NonceRequest* /*request*/, ::txpool::NonceReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Nonce( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithStreamedUnaryMethod_Version : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Version() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::types::VersionReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::types::VersionReply>* streamer) { return this->StreamedVersion(context, streamer); })); } ~WithStreamedUnaryMethod_Version() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Version(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::types::VersionReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedVersion(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::types::VersionReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_FindUnknown : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_FindUnknown() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler< ::txpool::TxHashes, ::txpool::TxHashes>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::TxHashes, ::txpool::TxHashes>* streamer) { return this->StreamedFindUnknown(context, streamer); })); } ~WithStreamedUnaryMethod_FindUnknown() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status FindUnknown(::grpc::ServerContext* /*context*/, const ::txpool::TxHashes* /*request*/, ::txpool::TxHashes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedFindUnknown(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::TxHashes,::txpool::TxHashes>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Add : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Add() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::StreamedUnaryHandler< ::txpool::AddRequest, ::txpool::AddReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::AddRequest, ::txpool::AddReply>* streamer) { return this->StreamedAdd(context, streamer); })); } ~WithStreamedUnaryMethod_Add() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Add(::grpc::ServerContext* /*context*/, const ::txpool::AddRequest* /*request*/, ::txpool::AddReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedAdd(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::AddRequest,::txpool::AddReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Transactions : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Transactions() { ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler< ::txpool::TransactionsRequest, ::txpool::TransactionsReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::TransactionsRequest, ::txpool::TransactionsReply>* streamer) { return this->StreamedTransactions(context, streamer); })); } ~WithStreamedUnaryMethod_Transactions() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Transactions(::grpc::ServerContext* /*context*/, const ::txpool::TransactionsRequest* /*request*/, ::txpool::TransactionsReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedTransactions(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::TransactionsRequest,::txpool::TransactionsReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_All : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_All() { ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler< ::txpool::AllRequest, ::txpool::AllReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::AllRequest, ::txpool::AllReply>* streamer) { return this->StreamedAll(context, streamer); })); } ~WithStreamedUnaryMethod_All() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status All(::grpc::ServerContext* /*context*/, const ::txpool::AllRequest* /*request*/, ::txpool::AllReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedAll(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::AllRequest,::txpool::AllReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Pending : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Pending() { ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler< ::google::protobuf::Empty, ::txpool::PendingReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty, ::txpool::PendingReply>* streamer) { return this->StreamedPending(context, streamer); })); } ~WithStreamedUnaryMethod_Pending() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Pending(::grpc::ServerContext* /*context*/, const ::google::protobuf::Empty* /*request*/, ::txpool::PendingReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedPending(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::google::protobuf::Empty,::txpool::PendingReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Status : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Status() { ::grpc::Service::MarkMethodStreamed(7, new ::grpc::internal::StreamedUnaryHandler< ::txpool::StatusRequest, ::txpool::StatusReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::StatusRequest, ::txpool::StatusReply>* streamer) { return this->StreamedStatus(context, streamer); })); } ~WithStreamedUnaryMethod_Status() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Status(::grpc::ServerContext* /*context*/, const ::txpool::StatusRequest* /*request*/, ::txpool::StatusReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedStatus(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::StatusRequest,::txpool::StatusReply>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Nonce : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Nonce() { ::grpc::Service::MarkMethodStreamed(8, new ::grpc::internal::StreamedUnaryHandler< ::txpool::NonceRequest, ::txpool::NonceReply>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::NonceRequest, ::txpool::NonceReply>* streamer) { return this->StreamedNonce(context, streamer); })); } ~WithStreamedUnaryMethod_Nonce() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Nonce(::grpc::ServerContext* /*context*/, const ::txpool::NonceRequest* /*request*/, ::txpool::NonceReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedNonce(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::txpool::NonceRequest,::txpool::NonceReply>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_Version > > > > > > > StreamedUnaryService; template class WithSplitStreamingMethod_OnAdd : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_OnAdd() { ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::SplitServerStreamingHandler< ::txpool::OnAddRequest, ::txpool::OnAddReply>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnAddRequest, ::txpool::OnAddReply>* streamer) { return this->StreamedOnAdd(context, streamer); })); } ~WithSplitStreamingMethod_OnAdd() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status OnAdd(::grpc::ServerContext* /*context*/, const ::txpool::OnAddRequest* /*request*/, ::grpc::ServerWriter< ::txpool::OnAddReply>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedOnAdd(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::txpool::OnAddRequest,::txpool::OnAddReply>* server_split_streamer) = 0; }; typedef WithSplitStreamingMethod_OnAdd SplitStreamedService; typedef WithStreamedUnaryMethod_Version > > > > > > > > StreamedService; }; } // namespace txpool #endif // GRPC_txpool_2ftxpool_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/txpool/txpool.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: txpool/txpool.proto // Protobuf C++ Version: 5.27.0 #include "txpool/txpool.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace txpool { inline constexpr TransactionsReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : rlp_txs_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR TransactionsReply::TransactionsReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct TransactionsReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR TransactionsReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~TransactionsReplyDefaultTypeInternal() {} union { TransactionsReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TransactionsReplyDefaultTypeInternal _TransactionsReply_default_instance_; template PROTOBUF_CONSTEXPR StatusRequest::StatusRequest(::_pbi::ConstantInitialized) {} struct StatusRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR StatusRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StatusRequestDefaultTypeInternal() {} union { StatusRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatusRequestDefaultTypeInternal _StatusRequest_default_instance_; inline constexpr StatusReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : pending_count_{0u}, queued_count_{0u}, base_fee_count_{0u}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR StatusReply::StatusReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct StatusReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR StatusReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~StatusReplyDefaultTypeInternal() {} union { StatusReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatusReplyDefaultTypeInternal _StatusReply_default_instance_; template PROTOBUF_CONSTEXPR OnAddRequest::OnAddRequest(::_pbi::ConstantInitialized) {} struct OnAddRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR OnAddRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnAddRequestDefaultTypeInternal() {} union { OnAddRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnAddRequestDefaultTypeInternal _OnAddRequest_default_instance_; inline constexpr OnAddReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : rpl_txs_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR OnAddReply::OnAddReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct OnAddReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR OnAddReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~OnAddReplyDefaultTypeInternal() {} union { OnAddReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnAddReplyDefaultTypeInternal _OnAddReply_default_instance_; inline constexpr NonceReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : nonce_{::uint64_t{0u}}, found_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR NonceReply::NonceReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NonceReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR NonceReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NonceReplyDefaultTypeInternal() {} union { NonceReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NonceReplyDefaultTypeInternal _NonceReply_default_instance_; template PROTOBUF_CONSTEXPR AllRequest::AllRequest(::_pbi::ConstantInitialized) {} struct AllRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR AllRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AllRequestDefaultTypeInternal() {} union { AllRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AllRequestDefaultTypeInternal _AllRequest_default_instance_; inline constexpr AddRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : rlp_txs_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR AddRequest::AddRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AddRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR AddRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AddRequestDefaultTypeInternal() {} union { AddRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddRequestDefaultTypeInternal _AddRequest_default_instance_; inline constexpr AddReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : imported_{}, _imported_cached_byte_size_{0}, errors_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR AddReply::AddReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AddReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR AddReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AddReplyDefaultTypeInternal() {} union { AddReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddReplyDefaultTypeInternal _AddReply_default_instance_; inline constexpr TxHashes::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : hashes_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR TxHashes::TxHashes(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct TxHashesDefaultTypeInternal { PROTOBUF_CONSTEXPR TxHashesDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~TxHashesDefaultTypeInternal() {} union { TxHashes _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TxHashesDefaultTypeInternal _TxHashes_default_instance_; inline constexpr TransactionsRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : hashes_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR TransactionsRequest::TransactionsRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct TransactionsRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR TransactionsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~TransactionsRequestDefaultTypeInternal() {} union { TransactionsRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TransactionsRequestDefaultTypeInternal _TransactionsRequest_default_instance_; inline constexpr PendingReply_Tx::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, rlp_tx_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), sender_{nullptr}, is_local_{false} {} template PROTOBUF_CONSTEXPR PendingReply_Tx::PendingReply_Tx(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PendingReply_TxDefaultTypeInternal { PROTOBUF_CONSTEXPR PendingReply_TxDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PendingReply_TxDefaultTypeInternal() {} union { PendingReply_Tx _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingReply_TxDefaultTypeInternal _PendingReply_Tx_default_instance_; inline constexpr NonceRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, address_{nullptr} {} template PROTOBUF_CONSTEXPR NonceRequest::NonceRequest(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NonceRequestDefaultTypeInternal { PROTOBUF_CONSTEXPR NonceRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NonceRequestDefaultTypeInternal() {} union { NonceRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NonceRequestDefaultTypeInternal _NonceRequest_default_instance_; inline constexpr AllReply_Tx::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, rlp_tx_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), sender_{nullptr}, txn_type_{static_cast< ::txpool::AllReply_TxnType >(0)} {} template PROTOBUF_CONSTEXPR AllReply_Tx::AllReply_Tx(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AllReply_TxDefaultTypeInternal { PROTOBUF_CONSTEXPR AllReply_TxDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AllReply_TxDefaultTypeInternal() {} union { AllReply_Tx _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AllReply_TxDefaultTypeInternal _AllReply_Tx_default_instance_; inline constexpr PendingReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : txs_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR PendingReply::PendingReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PendingReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR PendingReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PendingReplyDefaultTypeInternal() {} union { PendingReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingReplyDefaultTypeInternal _PendingReply_default_instance_; inline constexpr AllReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : txs_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR AllReply::AllReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct AllReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR AllReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~AllReplyDefaultTypeInternal() {} union { AllReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AllReplyDefaultTypeInternal _AllReply_default_instance_; } // namespace txpool static const ::_pb::EnumDescriptor* file_level_enum_descriptors_txpool_2ftxpool_2eproto[2]; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_txpool_2ftxpool_2eproto = nullptr; const ::uint32_t TableStruct_txpool_2ftxpool_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::TxHashes, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::TxHashes, _impl_.hashes_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::AddRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::AddRequest, _impl_.rlp_txs_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::AddReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::AddReply, _impl_.imported_), PROTOBUF_FIELD_OFFSET(::txpool::AddReply, _impl_.errors_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::TransactionsRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::TransactionsRequest, _impl_.hashes_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::TransactionsReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::TransactionsReply, _impl_.rlp_txs_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnAddRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::OnAddReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::OnAddReply, _impl_.rpl_txs_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::AllRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::AllReply_Tx, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::txpool::AllReply_Tx, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::AllReply_Tx, _impl_.txn_type_), PROTOBUF_FIELD_OFFSET(::txpool::AllReply_Tx, _impl_.sender_), PROTOBUF_FIELD_OFFSET(::txpool::AllReply_Tx, _impl_.rlp_tx_), ~0u, 0, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::AllReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::AllReply, _impl_.txs_), PROTOBUF_FIELD_OFFSET(::txpool::PendingReply_Tx, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::txpool::PendingReply_Tx, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::PendingReply_Tx, _impl_.sender_), PROTOBUF_FIELD_OFFSET(::txpool::PendingReply_Tx, _impl_.rlp_tx_), PROTOBUF_FIELD_OFFSET(::txpool::PendingReply_Tx, _impl_.is_local_), 0, ~0u, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::PendingReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::PendingReply, _impl_.txs_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::StatusRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::StatusReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::StatusReply, _impl_.pending_count_), PROTOBUF_FIELD_OFFSET(::txpool::StatusReply, _impl_.queued_count_), PROTOBUF_FIELD_OFFSET(::txpool::StatusReply, _impl_.base_fee_count_), PROTOBUF_FIELD_OFFSET(::txpool::NonceRequest, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::txpool::NonceRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::NonceRequest, _impl_.address_), 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::txpool::NonceReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::txpool::NonceReply, _impl_.found_), PROTOBUF_FIELD_OFFSET(::txpool::NonceReply, _impl_.nonce_), }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::txpool::TxHashes)}, {9, -1, -1, sizeof(::txpool::AddRequest)}, {18, -1, -1, sizeof(::txpool::AddReply)}, {28, -1, -1, sizeof(::txpool::TransactionsRequest)}, {37, -1, -1, sizeof(::txpool::TransactionsReply)}, {46, -1, -1, sizeof(::txpool::OnAddRequest)}, {54, -1, -1, sizeof(::txpool::OnAddReply)}, {63, -1, -1, sizeof(::txpool::AllRequest)}, {71, 82, -1, sizeof(::txpool::AllReply_Tx)}, {85, -1, -1, sizeof(::txpool::AllReply)}, {94, 105, -1, sizeof(::txpool::PendingReply_Tx)}, {108, -1, -1, sizeof(::txpool::PendingReply)}, {117, -1, -1, sizeof(::txpool::StatusRequest)}, {125, -1, -1, sizeof(::txpool::StatusReply)}, {136, 145, -1, sizeof(::txpool::NonceRequest)}, {146, -1, -1, sizeof(::txpool::NonceReply)}, }; static const ::_pb::Message* const file_default_instances[] = { &::txpool::_TxHashes_default_instance_._instance, &::txpool::_AddRequest_default_instance_._instance, &::txpool::_AddReply_default_instance_._instance, &::txpool::_TransactionsRequest_default_instance_._instance, &::txpool::_TransactionsReply_default_instance_._instance, &::txpool::_OnAddRequest_default_instance_._instance, &::txpool::_OnAddReply_default_instance_._instance, &::txpool::_AllRequest_default_instance_._instance, &::txpool::_AllReply_Tx_default_instance_._instance, &::txpool::_AllReply_default_instance_._instance, &::txpool::_PendingReply_Tx_default_instance_._instance, &::txpool::_PendingReply_default_instance_._instance, &::txpool::_StatusRequest_default_instance_._instance, &::txpool::_StatusReply_default_instance_._instance, &::txpool::_NonceRequest_default_instance_._instance, &::txpool::_NonceReply_default_instance_._instance, }; const char descriptor_table_protodef_txpool_2ftxpool_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\023txpool/txpool.proto\022\006txpool\032\033google/pr" "otobuf/empty.proto\032\021types/types.proto\"\'\n" "\010TxHashes\022\033\n\006hashes\030\001 \003(\0132\013.types.H256\"\035" "\n\nAddRequest\022\017\n\007rlp_txs\030\001 \003(\014\"B\n\010AddRepl" "y\022&\n\010imported\030\001 \003(\0162\024.txpool.ImportResul" "t\022\016\n\006errors\030\002 \003(\t\"2\n\023TransactionsRequest" "\022\033\n\006hashes\030\001 \003(\0132\013.types.H256\"$\n\021Transac" "tionsReply\022\017\n\007rlp_txs\030\001 \003(\014\"\016\n\014OnAddRequ" "est\"\035\n\nOnAddReply\022\017\n\007rpl_txs\030\001 \003(\014\"\014\n\nAl" "lRequest\"\275\001\n\010AllReply\022 \n\003txs\030\001 \003(\0132\023.txp" "ool.AllReply.Tx\032]\n\002Tx\022*\n\010txn_type\030\001 \001(\0162" "\030.txpool.AllReply.TxnType\022\033\n\006sender\030\002 \001(" "\0132\013.types.H160\022\016\n\006rlp_tx\030\003 \001(\014\"0\n\007TxnTyp" "e\022\013\n\007PENDING\020\000\022\n\n\006QUEUED\020\001\022\014\n\010BASE_FEE\020\002" "\"y\n\014PendingReply\022$\n\003txs\030\001 \003(\0132\027.txpool.P" "endingReply.Tx\032C\n\002Tx\022\033\n\006sender\030\001 \001(\0132\013.t" "ypes.H160\022\016\n\006rlp_tx\030\002 \001(\014\022\020\n\010is_local\030\003 " "\001(\010\"\017\n\rStatusRequest\"R\n\013StatusReply\022\025\n\rp" "ending_count\030\001 \001(\r\022\024\n\014queued_count\030\002 \001(\r" "\022\026\n\016base_fee_count\030\003 \001(\r\",\n\014NonceRequest" "\022\034\n\007address\030\001 \001(\0132\013.types.H160\"*\n\nNonceR" "eply\022\r\n\005found\030\001 \001(\010\022\r\n\005nonce\030\002 \001(\004*l\n\014Im" "portResult\022\013\n\007SUCCESS\020\000\022\022\n\016ALREADY_EXIST" "S\020\001\022\017\n\013FEE_TOO_LOW\020\002\022\t\n\005STALE\020\003\022\013\n\007INVAL" "ID\020\004\022\022\n\016INTERNAL_ERROR\020\0052\354\003\n\006Txpool\0226\n\007V" "ersion\022\026.google.protobuf.Empty\032\023.types.V" "ersionReply\0221\n\013FindUnknown\022\020.txpool.TxHa" "shes\032\020.txpool.TxHashes\022+\n\003Add\022\022.txpool.A" "ddRequest\032\020.txpool.AddReply\022F\n\014Transacti" "ons\022\033.txpool.TransactionsRequest\032\031.txpoo" "l.TransactionsReply\022+\n\003All\022\022.txpool.AllR" "equest\032\020.txpool.AllReply\0227\n\007Pending\022\026.go" "ogle.protobuf.Empty\032\024.txpool.PendingRepl" "y\0223\n\005OnAdd\022\024.txpool.OnAddRequest\032\022.txpoo" "l.OnAddReply0\001\0224\n\006Status\022\025.txpool.Status" "Request\032\023.txpool.StatusReply\0221\n\005Nonce\022\024." "txpool.NonceRequest\032\022.txpool.NonceReplyB" "\026Z\024./txpool;txpoolprotob\006proto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_txpool_2ftxpool_2eproto_deps[2] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, &::descriptor_table_types_2ftypes_2eproto, }; static ::absl::once_flag descriptor_table_txpool_2ftxpool_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_txpool_2ftxpool_2eproto = { false, false, 1511, descriptor_table_protodef_txpool_2ftxpool_2eproto, "txpool/txpool.proto", &descriptor_table_txpool_2ftxpool_2eproto_once, descriptor_table_txpool_2ftxpool_2eproto_deps, 2, 16, schemas, file_default_instances, TableStruct_txpool_2ftxpool_2eproto::offsets, file_level_enum_descriptors_txpool_2ftxpool_2eproto, file_level_service_descriptors_txpool_2ftxpool_2eproto, }; namespace txpool { const ::google::protobuf::EnumDescriptor* AllReply_TxnType_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_txpool_2ftxpool_2eproto); return file_level_enum_descriptors_txpool_2ftxpool_2eproto[0]; } PROTOBUF_CONSTINIT const uint32_t AllReply_TxnType_internal_data_[] = { 196608u, 0u, }; bool AllReply_TxnType_IsValid(int value) { return 0 <= value && value <= 2; } #if (__cplusplus < 201703) && \ (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr AllReply_TxnType AllReply::PENDING; constexpr AllReply_TxnType AllReply::QUEUED; constexpr AllReply_TxnType AllReply::BASE_FEE; constexpr AllReply_TxnType AllReply::TxnType_MIN; constexpr AllReply_TxnType AllReply::TxnType_MAX; constexpr int AllReply::TxnType_ARRAYSIZE; #endif // (__cplusplus < 201703) && // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::google::protobuf::EnumDescriptor* ImportResult_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_txpool_2ftxpool_2eproto); return file_level_enum_descriptors_txpool_2ftxpool_2eproto[1]; } PROTOBUF_CONSTINIT const uint32_t ImportResult_internal_data_[] = { 393216u, 0u, }; bool ImportResult_IsValid(int value) { return 0 <= value && value <= 5; } // =================================================================== class TxHashes::_Internal { public: }; void TxHashes::clear_hashes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hashes_.Clear(); } TxHashes::TxHashes(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.TxHashes) } inline PROTOBUF_NDEBUG_INLINE TxHashes::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::TxHashes& from_msg) : hashes_{visibility, arena, from.hashes_}, _cached_size_{0} {} TxHashes::TxHashes( ::google::protobuf::Arena* arena, const TxHashes& from) : ::google::protobuf::Message(arena) { TxHashes* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.TxHashes) } inline PROTOBUF_NDEBUG_INLINE TxHashes::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : hashes_{visibility, arena}, _cached_size_{0} {} inline void TxHashes::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } TxHashes::~TxHashes() { // @@protoc_insertion_point(destructor:txpool.TxHashes) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void TxHashes::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* TxHashes::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(TxHashes, _impl_._cached_size_), false, }, &TxHashes::MergeImpl, &TxHashes::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> TxHashes::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_TxHashes_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::TxHashes>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.H256 hashes = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(TxHashes, _impl_.hashes_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.H256 hashes = 1; {PROTOBUF_FIELD_OFFSET(TxHashes, _impl_.hashes_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void TxHashes::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.TxHashes) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.hashes_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* TxHashes::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.TxHashes) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.H256 hashes = 1; for (unsigned i = 0, n = static_cast( this->_internal_hashes_size()); i < n; i++) { const auto& repfield = this->_internal_hashes().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.TxHashes) return target; } ::size_t TxHashes::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.TxHashes) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.H256 hashes = 1; total_size += 1UL * this->_internal_hashes_size(); for (const auto& msg : this->_internal_hashes()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void TxHashes::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.TxHashes) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_hashes()->MergeFrom( from._internal_hashes()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void TxHashes::CopyFrom(const TxHashes& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.TxHashes) if (&from == this) return; Clear(); MergeFrom(from); } void TxHashes::InternalSwap(TxHashes* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.hashes_.InternalSwap(&other->_impl_.hashes_); } ::google::protobuf::Metadata TxHashes::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AddRequest::_Internal { public: }; AddRequest::AddRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.AddRequest) } inline PROTOBUF_NDEBUG_INLINE AddRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::AddRequest& from_msg) : rlp_txs_{visibility, arena, from.rlp_txs_}, _cached_size_{0} {} AddRequest::AddRequest( ::google::protobuf::Arena* arena, const AddRequest& from) : ::google::protobuf::Message(arena) { AddRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.AddRequest) } inline PROTOBUF_NDEBUG_INLINE AddRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : rlp_txs_{visibility, arena}, _cached_size_{0} {} inline void AddRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } AddRequest::~AddRequest() { // @@protoc_insertion_point(destructor:txpool.AddRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AddRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AddRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AddRequest, _impl_._cached_size_), false, }, &AddRequest::MergeImpl, &AddRequest::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> AddRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AddRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::AddRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated bytes rlp_txs = 1; {::_pbi::TcParser::FastBR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(AddRequest, _impl_.rlp_txs_)}}, }}, {{ 65535, 65535 }}, {{ // repeated bytes rlp_txs = 1; {PROTOBUF_FIELD_OFFSET(AddRequest, _impl_.rlp_txs_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void AddRequest::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.AddRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rlp_txs_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AddRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.AddRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated bytes rlp_txs = 1; for (int i = 0, n = this->_internal_rlp_txs_size(); i < n; ++i) { const auto& s = this->_internal_rlp_txs().Get(i); target = stream->WriteBytes(1, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.AddRequest) return target; } ::size_t AddRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.AddRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes rlp_txs = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_rlp_txs().size()); for (int i = 0, n = _internal_rlp_txs().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_rlp_txs().Get(i)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AddRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.AddRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_rlp_txs()->MergeFrom(from._internal_rlp_txs()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AddRequest::CopyFrom(const AddRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.AddRequest) if (&from == this) return; Clear(); MergeFrom(from); } void AddRequest::InternalSwap(AddRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.rlp_txs_.InternalSwap(&other->_impl_.rlp_txs_); } ::google::protobuf::Metadata AddRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AddReply::_Internal { public: }; AddReply::AddReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.AddReply) } inline PROTOBUF_NDEBUG_INLINE AddReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::AddReply& from_msg) : imported_{visibility, arena, from.imported_}, _imported_cached_byte_size_{0}, errors_{visibility, arena, from.errors_}, _cached_size_{0} {} AddReply::AddReply( ::google::protobuf::Arena* arena, const AddReply& from) : ::google::protobuf::Message(arena) { AddReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.AddReply) } inline PROTOBUF_NDEBUG_INLINE AddReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : imported_{visibility, arena}, _imported_cached_byte_size_{0}, errors_{visibility, arena}, _cached_size_{0} {} inline void AddReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } AddReply::~AddReply() { // @@protoc_insertion_point(destructor:txpool.AddReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AddReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AddReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AddReply, _impl_._cached_size_), false, }, &AddReply::MergeImpl, &AddReply::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 30, 2> AddReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AddReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::AddReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated string errors = 2; {::_pbi::TcParser::FastUR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(AddReply, _impl_.errors_)}}, // repeated .txpool.ImportResult imported = 1; {::_pbi::TcParser::FastV32P1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(AddReply, _impl_.imported_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .txpool.ImportResult imported = 1; {PROTOBUF_FIELD_OFFSET(AddReply, _impl_.imported_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedOpenEnum)}, // repeated string errors = 2; {PROTOBUF_FIELD_OFFSET(AddReply, _impl_.errors_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, }}, // no aux_entries {{ "\17\0\6\0\0\0\0\0" "txpool.AddReply" "errors" }}, }; PROTOBUF_NOINLINE void AddReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.AddReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.imported_.Clear(); _impl_.errors_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AddReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.AddReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .txpool.ImportResult imported = 1; { std::size_t byte_size = _impl_._imported_cached_byte_size_.Get(); if (byte_size > 0) { target = stream->WriteEnumPacked(1, _internal_imported(), byte_size, target); } } // repeated string errors = 2; for (int i = 0, n = this->_internal_errors_size(); i < n; ++i) { const auto& s = this->_internal_errors().Get(i); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "txpool.AddReply.errors"); target = stream->WriteString(2, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.AddReply) return target; } ::size_t AddReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.AddReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .txpool.ImportResult imported = 1; { std::size_t data_size = 0; auto count = static_cast(this->_internal_imported_size()); for (std::size_t i = 0; i < count; ++i) { data_size += ::_pbi::WireFormatLite::EnumSize( this->_internal_imported().Get(static_cast(i))); } total_size += data_size; if (data_size > 0) { total_size += 1; total_size += ::_pbi::WireFormatLite::Int32Size( static_cast(data_size)); } _impl_._imported_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size)); } // repeated string errors = 2; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_errors().size()); for (int i = 0, n = _internal_errors().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::StringSize( _internal_errors().Get(i)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AddReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.AddReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_imported()->MergeFrom(from._internal_imported()); _this->_internal_mutable_errors()->MergeFrom(from._internal_errors()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AddReply::CopyFrom(const AddReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.AddReply) if (&from == this) return; Clear(); MergeFrom(from); } void AddReply::InternalSwap(AddReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.imported_.InternalSwap(&other->_impl_.imported_); _impl_.errors_.InternalSwap(&other->_impl_.errors_); } ::google::protobuf::Metadata AddReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class TransactionsRequest::_Internal { public: }; void TransactionsRequest::clear_hashes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hashes_.Clear(); } TransactionsRequest::TransactionsRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.TransactionsRequest) } inline PROTOBUF_NDEBUG_INLINE TransactionsRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::TransactionsRequest& from_msg) : hashes_{visibility, arena, from.hashes_}, _cached_size_{0} {} TransactionsRequest::TransactionsRequest( ::google::protobuf::Arena* arena, const TransactionsRequest& from) : ::google::protobuf::Message(arena) { TransactionsRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.TransactionsRequest) } inline PROTOBUF_NDEBUG_INLINE TransactionsRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : hashes_{visibility, arena}, _cached_size_{0} {} inline void TransactionsRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } TransactionsRequest::~TransactionsRequest() { // @@protoc_insertion_point(destructor:txpool.TransactionsRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void TransactionsRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* TransactionsRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(TransactionsRequest, _impl_._cached_size_), false, }, &TransactionsRequest::MergeImpl, &TransactionsRequest::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> TransactionsRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_TransactionsRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::TransactionsRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.H256 hashes = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(TransactionsRequest, _impl_.hashes_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .types.H256 hashes = 1; {PROTOBUF_FIELD_OFFSET(TransactionsRequest, _impl_.hashes_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void TransactionsRequest::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.TransactionsRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.hashes_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* TransactionsRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.TransactionsRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .types.H256 hashes = 1; for (unsigned i = 0, n = static_cast( this->_internal_hashes_size()); i < n; i++) { const auto& repfield = this->_internal_hashes().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.TransactionsRequest) return target; } ::size_t TransactionsRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.TransactionsRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .types.H256 hashes = 1; total_size += 1UL * this->_internal_hashes_size(); for (const auto& msg : this->_internal_hashes()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void TransactionsRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.TransactionsRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_hashes()->MergeFrom( from._internal_hashes()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void TransactionsRequest::CopyFrom(const TransactionsRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.TransactionsRequest) if (&from == this) return; Clear(); MergeFrom(from); } void TransactionsRequest::InternalSwap(TransactionsRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.hashes_.InternalSwap(&other->_impl_.hashes_); } ::google::protobuf::Metadata TransactionsRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class TransactionsReply::_Internal { public: }; TransactionsReply::TransactionsReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.TransactionsReply) } inline PROTOBUF_NDEBUG_INLINE TransactionsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::TransactionsReply& from_msg) : rlp_txs_{visibility, arena, from.rlp_txs_}, _cached_size_{0} {} TransactionsReply::TransactionsReply( ::google::protobuf::Arena* arena, const TransactionsReply& from) : ::google::protobuf::Message(arena) { TransactionsReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.TransactionsReply) } inline PROTOBUF_NDEBUG_INLINE TransactionsReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : rlp_txs_{visibility, arena}, _cached_size_{0} {} inline void TransactionsReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } TransactionsReply::~TransactionsReply() { // @@protoc_insertion_point(destructor:txpool.TransactionsReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void TransactionsReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* TransactionsReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(TransactionsReply, _impl_._cached_size_), false, }, &TransactionsReply::MergeImpl, &TransactionsReply::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> TransactionsReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_TransactionsReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::TransactionsReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated bytes rlp_txs = 1; {::_pbi::TcParser::FastBR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(TransactionsReply, _impl_.rlp_txs_)}}, }}, {{ 65535, 65535 }}, {{ // repeated bytes rlp_txs = 1; {PROTOBUF_FIELD_OFFSET(TransactionsReply, _impl_.rlp_txs_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void TransactionsReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.TransactionsReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rlp_txs_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* TransactionsReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.TransactionsReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated bytes rlp_txs = 1; for (int i = 0, n = this->_internal_rlp_txs_size(); i < n; ++i) { const auto& s = this->_internal_rlp_txs().Get(i); target = stream->WriteBytes(1, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.TransactionsReply) return target; } ::size_t TransactionsReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.TransactionsReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes rlp_txs = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_rlp_txs().size()); for (int i = 0, n = _internal_rlp_txs().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_rlp_txs().Get(i)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void TransactionsReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.TransactionsReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_rlp_txs()->MergeFrom(from._internal_rlp_txs()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void TransactionsReply::CopyFrom(const TransactionsReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.TransactionsReply) if (&from == this) return; Clear(); MergeFrom(from); } void TransactionsReply::InternalSwap(TransactionsReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.rlp_txs_.InternalSwap(&other->_impl_.rlp_txs_); } ::google::protobuf::Metadata TransactionsReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OnAddRequest::_Internal { public: }; OnAddRequest::OnAddRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.OnAddRequest) } OnAddRequest::OnAddRequest( ::google::protobuf::Arena* arena, const OnAddRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { OnAddRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.OnAddRequest) } const ::google::protobuf::MessageLite::ClassData* OnAddRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnAddRequest, _impl_._cached_size_), false, }, &OnAddRequest::MergeImpl, &OnAddRequest::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> OnAddRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnAddRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnAddRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata OnAddRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class OnAddReply::_Internal { public: }; OnAddReply::OnAddReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.OnAddReply) } inline PROTOBUF_NDEBUG_INLINE OnAddReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::OnAddReply& from_msg) : rpl_txs_{visibility, arena, from.rpl_txs_}, _cached_size_{0} {} OnAddReply::OnAddReply( ::google::protobuf::Arena* arena, const OnAddReply& from) : ::google::protobuf::Message(arena) { OnAddReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.OnAddReply) } inline PROTOBUF_NDEBUG_INLINE OnAddReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : rpl_txs_{visibility, arena}, _cached_size_{0} {} inline void OnAddReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } OnAddReply::~OnAddReply() { // @@protoc_insertion_point(destructor:txpool.OnAddReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void OnAddReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* OnAddReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(OnAddReply, _impl_._cached_size_), false, }, &OnAddReply::MergeImpl, &OnAddReply::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> OnAddReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_OnAddReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::OnAddReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated bytes rpl_txs = 1; {::_pbi::TcParser::FastBR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(OnAddReply, _impl_.rpl_txs_)}}, }}, {{ 65535, 65535 }}, {{ // repeated bytes rpl_txs = 1; {PROTOBUF_FIELD_OFFSET(OnAddReply, _impl_.rpl_txs_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void OnAddReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.OnAddReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rpl_txs_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* OnAddReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.OnAddReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated bytes rpl_txs = 1; for (int i = 0, n = this->_internal_rpl_txs_size(); i < n; ++i) { const auto& s = this->_internal_rpl_txs().Get(i); target = stream->WriteBytes(1, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.OnAddReply) return target; } ::size_t OnAddReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.OnAddReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes rpl_txs = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_rpl_txs().size()); for (int i = 0, n = _internal_rpl_txs().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_rpl_txs().Get(i)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void OnAddReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.OnAddReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_rpl_txs()->MergeFrom(from._internal_rpl_txs()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void OnAddReply::CopyFrom(const OnAddReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.OnAddReply) if (&from == this) return; Clear(); MergeFrom(from); } void OnAddReply::InternalSwap(OnAddReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.rpl_txs_.InternalSwap(&other->_impl_.rpl_txs_); } ::google::protobuf::Metadata OnAddReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AllRequest::_Internal { public: }; AllRequest::AllRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.AllRequest) } AllRequest::AllRequest( ::google::protobuf::Arena* arena, const AllRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { AllRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.AllRequest) } const ::google::protobuf::MessageLite::ClassData* AllRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AllRequest, _impl_._cached_size_), false, }, &AllRequest::MergeImpl, &AllRequest::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> AllRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_AllRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::AllRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata AllRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AllReply_Tx::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_._has_bits_); }; void AllReply_Tx::clear_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sender_ != nullptr) _impl_.sender_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } AllReply_Tx::AllReply_Tx(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.AllReply.Tx) } inline PROTOBUF_NDEBUG_INLINE AllReply_Tx::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::AllReply_Tx& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, rlp_tx_(arena, from.rlp_tx_) {} AllReply_Tx::AllReply_Tx( ::google::protobuf::Arena* arena, const AllReply_Tx& from) : ::google::protobuf::Message(arena) { AllReply_Tx* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.sender_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.sender_) : nullptr; _impl_.txn_type_ = from._impl_.txn_type_; // @@protoc_insertion_point(copy_constructor:txpool.AllReply.Tx) } inline PROTOBUF_NDEBUG_INLINE AllReply_Tx::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, rlp_tx_(arena) {} inline void AllReply_Tx::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sender_), 0, offsetof(Impl_, txn_type_) - offsetof(Impl_, sender_) + sizeof(Impl_::txn_type_)); } AllReply_Tx::~AllReply_Tx() { // @@protoc_insertion_point(destructor:txpool.AllReply.Tx) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AllReply_Tx::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.rlp_tx_.Destroy(); delete _impl_.sender_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AllReply_Tx::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_._cached_size_), false, }, &AllReply_Tx::MergeImpl, &AllReply_Tx::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 1, 0, 2> AllReply_Tx::_table_ = { { PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_AllReply_Tx_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::AllReply_Tx>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .txpool.AllReply.TxnType txn_type = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(AllReply_Tx, _impl_.txn_type_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.txn_type_)}}, // .types.H160 sender = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.sender_)}}, // bytes rlp_tx = 3; {::_pbi::TcParser::FastBS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.rlp_tx_)}}, }}, {{ 65535, 65535 }}, {{ // .txpool.AllReply.TxnType txn_type = 1; {PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.txn_type_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)}, // .types.H160 sender = 2; {PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.sender_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bytes rlp_tx = 3; {PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.rlp_tx_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void AllReply_Tx::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.AllReply.Tx) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rlp_tx_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.sender_ != nullptr); _impl_.sender_->Clear(); } _impl_.txn_type_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AllReply_Tx::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.AllReply.Tx) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // .txpool.AllReply.TxnType txn_type = 1; if (this->_internal_txn_type() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( 1, this->_internal_txn_type(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H160 sender = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.sender_, _impl_.sender_->GetCachedSize(), target, stream); } // bytes rlp_tx = 3; if (!this->_internal_rlp_tx().empty()) { const std::string& _s = this->_internal_rlp_tx(); target = stream->WriteBytesMaybeAliased(3, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.AllReply.Tx) return target; } ::size_t AllReply_Tx::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.AllReply.Tx) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes rlp_tx = 3; if (!this->_internal_rlp_tx().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_rlp_tx()); } // .types.H160 sender = 2; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.sender_); } // .txpool.AllReply.TxnType txn_type = 1; if (this->_internal_txn_type() != 0) { total_size += 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_txn_type()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AllReply_Tx::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.AllReply.Tx) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_rlp_tx().empty()) { _this->_internal_set_rlp_tx(from._internal_rlp_tx()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.sender_ != nullptr); if (_this->_impl_.sender_ == nullptr) { _this->_impl_.sender_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.sender_); } else { _this->_impl_.sender_->MergeFrom(*from._impl_.sender_); } } if (from._internal_txn_type() != 0) { _this->_impl_.txn_type_ = from._impl_.txn_type_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AllReply_Tx::CopyFrom(const AllReply_Tx& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.AllReply.Tx) if (&from == this) return; Clear(); MergeFrom(from); } void AllReply_Tx::InternalSwap(AllReply_Tx* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.rlp_tx_, &other->_impl_.rlp_tx_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.txn_type_) + sizeof(AllReply_Tx::_impl_.txn_type_) - PROTOBUF_FIELD_OFFSET(AllReply_Tx, _impl_.sender_)>( reinterpret_cast(&_impl_.sender_), reinterpret_cast(&other->_impl_.sender_)); } ::google::protobuf::Metadata AllReply_Tx::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class AllReply::_Internal { public: }; AllReply::AllReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.AllReply) } inline PROTOBUF_NDEBUG_INLINE AllReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::AllReply& from_msg) : txs_{visibility, arena, from.txs_}, _cached_size_{0} {} AllReply::AllReply( ::google::protobuf::Arena* arena, const AllReply& from) : ::google::protobuf::Message(arena) { AllReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.AllReply) } inline PROTOBUF_NDEBUG_INLINE AllReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : txs_{visibility, arena}, _cached_size_{0} {} inline void AllReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } AllReply::~AllReply() { // @@protoc_insertion_point(destructor:txpool.AllReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void AllReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* AllReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(AllReply, _impl_._cached_size_), false, }, &AllReply::MergeImpl, &AllReply::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> AllReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_AllReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::AllReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .txpool.AllReply.Tx txs = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(AllReply, _impl_.txs_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .txpool.AllReply.Tx txs = 1; {PROTOBUF_FIELD_OFFSET(AllReply, _impl_.txs_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::txpool::AllReply_Tx>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void AllReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.AllReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.txs_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* AllReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.AllReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .txpool.AllReply.Tx txs = 1; for (unsigned i = 0, n = static_cast( this->_internal_txs_size()); i < n; i++) { const auto& repfield = this->_internal_txs().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.AllReply) return target; } ::size_t AllReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.AllReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .txpool.AllReply.Tx txs = 1; total_size += 1UL * this->_internal_txs_size(); for (const auto& msg : this->_internal_txs()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void AllReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.AllReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_txs()->MergeFrom( from._internal_txs()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void AllReply::CopyFrom(const AllReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.AllReply) if (&from == this) return; Clear(); MergeFrom(from); } void AllReply::InternalSwap(AllReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.txs_.InternalSwap(&other->_impl_.txs_); } ::google::protobuf::Metadata AllReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PendingReply_Tx::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_._has_bits_); }; void PendingReply_Tx::clear_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sender_ != nullptr) _impl_.sender_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } PendingReply_Tx::PendingReply_Tx(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.PendingReply.Tx) } inline PROTOBUF_NDEBUG_INLINE PendingReply_Tx::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::PendingReply_Tx& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, rlp_tx_(arena, from.rlp_tx_) {} PendingReply_Tx::PendingReply_Tx( ::google::protobuf::Arena* arena, const PendingReply_Tx& from) : ::google::protobuf::Message(arena) { PendingReply_Tx* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.sender_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.sender_) : nullptr; _impl_.is_local_ = from._impl_.is_local_; // @@protoc_insertion_point(copy_constructor:txpool.PendingReply.Tx) } inline PROTOBUF_NDEBUG_INLINE PendingReply_Tx::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, rlp_tx_(arena) {} inline void PendingReply_Tx::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, sender_), 0, offsetof(Impl_, is_local_) - offsetof(Impl_, sender_) + sizeof(Impl_::is_local_)); } PendingReply_Tx::~PendingReply_Tx() { // @@protoc_insertion_point(destructor:txpool.PendingReply.Tx) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PendingReply_Tx::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.rlp_tx_.Destroy(); delete _impl_.sender_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PendingReply_Tx::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_._cached_size_), false, }, &PendingReply_Tx::MergeImpl, &PendingReply_Tx::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 1, 0, 2> PendingReply_Tx::_table_ = { { PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PendingReply_Tx_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::PendingReply_Tx>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // .types.H160 sender = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.sender_)}}, // bytes rlp_tx = 2; {::_pbi::TcParser::FastBS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.rlp_tx_)}}, // bool is_local = 3; {::_pbi::TcParser::SingularVarintNoZag1(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.is_local_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H160 sender = 1; {PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.sender_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bytes rlp_tx = 2; {PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.rlp_tx_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // bool is_local = 3; {PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.is_local_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PendingReply_Tx::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.PendingReply.Tx) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.rlp_tx_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.sender_ != nullptr); _impl_.sender_->Clear(); } _impl_.is_local_ = false; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PendingReply_Tx::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.PendingReply.Tx) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H160 sender = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.sender_, _impl_.sender_->GetCachedSize(), target, stream); } // bytes rlp_tx = 2; if (!this->_internal_rlp_tx().empty()) { const std::string& _s = this->_internal_rlp_tx(); target = stream->WriteBytesMaybeAliased(2, _s, target); } // bool is_local = 3; if (this->_internal_is_local() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 3, this->_internal_is_local(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.PendingReply.Tx) return target; } ::size_t PendingReply_Tx::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.PendingReply.Tx) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // bytes rlp_tx = 2; if (!this->_internal_rlp_tx().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_rlp_tx()); } // .types.H160 sender = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.sender_); } // bool is_local = 3; if (this->_internal_is_local() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PendingReply_Tx::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.PendingReply.Tx) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_rlp_tx().empty()) { _this->_internal_set_rlp_tx(from._internal_rlp_tx()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.sender_ != nullptr); if (_this->_impl_.sender_ == nullptr) { _this->_impl_.sender_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.sender_); } else { _this->_impl_.sender_->MergeFrom(*from._impl_.sender_); } } if (from._internal_is_local() != 0) { _this->_impl_.is_local_ = from._impl_.is_local_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PendingReply_Tx::CopyFrom(const PendingReply_Tx& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.PendingReply.Tx) if (&from == this) return; Clear(); MergeFrom(from); } void PendingReply_Tx::InternalSwap(PendingReply_Tx* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.rlp_tx_, &other->_impl_.rlp_tx_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.is_local_) + sizeof(PendingReply_Tx::_impl_.is_local_) - PROTOBUF_FIELD_OFFSET(PendingReply_Tx, _impl_.sender_)>( reinterpret_cast(&_impl_.sender_), reinterpret_cast(&other->_impl_.sender_)); } ::google::protobuf::Metadata PendingReply_Tx::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PendingReply::_Internal { public: }; PendingReply::PendingReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.PendingReply) } inline PROTOBUF_NDEBUG_INLINE PendingReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::PendingReply& from_msg) : txs_{visibility, arena, from.txs_}, _cached_size_{0} {} PendingReply::PendingReply( ::google::protobuf::Arena* arena, const PendingReply& from) : ::google::protobuf::Message(arena) { PendingReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:txpool.PendingReply) } inline PROTOBUF_NDEBUG_INLINE PendingReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : txs_{visibility, arena}, _cached_size_{0} {} inline void PendingReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } PendingReply::~PendingReply() { // @@protoc_insertion_point(destructor:txpool.PendingReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PendingReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PendingReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PendingReply, _impl_._cached_size_), false, }, &PendingReply::MergeImpl, &PendingReply::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> PendingReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_PendingReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::PendingReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .txpool.PendingReply.Tx txs = 1; {::_pbi::TcParser::FastMtR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(PendingReply, _impl_.txs_)}}, }}, {{ 65535, 65535 }}, {{ // repeated .txpool.PendingReply.Tx txs = 1; {PROTOBUF_FIELD_OFFSET(PendingReply, _impl_.txs_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::txpool::PendingReply_Tx>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void PendingReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.PendingReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.txs_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PendingReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.PendingReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated .txpool.PendingReply.Tx txs = 1; for (unsigned i = 0, n = static_cast( this->_internal_txs_size()); i < n; i++) { const auto& repfield = this->_internal_txs().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.PendingReply) return target; } ::size_t PendingReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.PendingReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated .txpool.PendingReply.Tx txs = 1; total_size += 1UL * this->_internal_txs_size(); for (const auto& msg : this->_internal_txs()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PendingReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.PendingReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_txs()->MergeFrom( from._internal_txs()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PendingReply::CopyFrom(const PendingReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.PendingReply) if (&from == this) return; Clear(); MergeFrom(from); } void PendingReply::InternalSwap(PendingReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.txs_.InternalSwap(&other->_impl_.txs_); } ::google::protobuf::Metadata PendingReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StatusRequest::_Internal { public: }; StatusRequest::StatusRequest(::google::protobuf::Arena* arena) : ::google::protobuf::internal::ZeroFieldsBase(arena) { // @@protoc_insertion_point(arena_constructor:txpool.StatusRequest) } StatusRequest::StatusRequest( ::google::protobuf::Arena* arena, const StatusRequest& from) : ::google::protobuf::internal::ZeroFieldsBase(arena) { StatusRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:txpool.StatusRequest) } const ::google::protobuf::MessageLite::ClassData* StatusRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(StatusRequest, _impl_._cached_size_), false, }, &StatusRequest::MergeImpl, &StatusRequest::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 0, 0, 0, 2> StatusRequest::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 0, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967295, // skipmap offsetof(decltype(_table_), field_names), // no field_entries 0, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_StatusRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::StatusRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, // no field_entries, or aux_entries {{ }}, }; ::google::protobuf::Metadata StatusRequest::GetMetadata() const { return ::google::protobuf::internal::ZeroFieldsBase::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class StatusReply::_Internal { public: }; StatusReply::StatusReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.StatusReply) } StatusReply::StatusReply( ::google::protobuf::Arena* arena, const StatusReply& from) : StatusReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE StatusReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void StatusReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, pending_count_), 0, offsetof(Impl_, base_fee_count_) - offsetof(Impl_, pending_count_) + sizeof(Impl_::base_fee_count_)); } StatusReply::~StatusReply() { // @@protoc_insertion_point(destructor:txpool.StatusReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void StatusReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* StatusReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(StatusReply, _impl_._cached_size_), false, }, &StatusReply::MergeImpl, &StatusReply::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 0, 0, 2> StatusReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_StatusReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::StatusReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint32 pending_count = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(StatusReply, _impl_.pending_count_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.pending_count_)}}, // uint32 queued_count = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(StatusReply, _impl_.queued_count_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.queued_count_)}}, // uint32 base_fee_count = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(StatusReply, _impl_.base_fee_count_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.base_fee_count_)}}, }}, {{ 65535, 65535 }}, {{ // uint32 pending_count = 1; {PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.pending_count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // uint32 queued_count = 2; {PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.queued_count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // uint32 base_fee_count = 3; {PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.base_fee_count_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void StatusReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.StatusReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.pending_count_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.base_fee_count_) - reinterpret_cast(&_impl_.pending_count_)) + sizeof(_impl_.base_fee_count_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* StatusReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.StatusReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint32 pending_count = 1; if (this->_internal_pending_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 1, this->_internal_pending_count(), target); } // uint32 queued_count = 2; if (this->_internal_queued_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 2, this->_internal_queued_count(), target); } // uint32 base_fee_count = 3; if (this->_internal_base_fee_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 3, this->_internal_base_fee_count(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.StatusReply) return target; } ::size_t StatusReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.StatusReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint32 pending_count = 1; if (this->_internal_pending_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_pending_count()); } // uint32 queued_count = 2; if (this->_internal_queued_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_queued_count()); } // uint32 base_fee_count = 3; if (this->_internal_base_fee_count() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_base_fee_count()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void StatusReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.StatusReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_pending_count() != 0) { _this->_impl_.pending_count_ = from._impl_.pending_count_; } if (from._internal_queued_count() != 0) { _this->_impl_.queued_count_ = from._impl_.queued_count_; } if (from._internal_base_fee_count() != 0) { _this->_impl_.base_fee_count_ = from._impl_.base_fee_count_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void StatusReply::CopyFrom(const StatusReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.StatusReply) if (&from == this) return; Clear(); MergeFrom(from); } void StatusReply::InternalSwap(StatusReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.base_fee_count_) + sizeof(StatusReply::_impl_.base_fee_count_) - PROTOBUF_FIELD_OFFSET(StatusReply, _impl_.pending_count_)>( reinterpret_cast(&_impl_.pending_count_), reinterpret_cast(&other->_impl_.pending_count_)); } ::google::protobuf::Metadata StatusReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NonceRequest::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(NonceRequest, _impl_._has_bits_); }; void NonceRequest::clear_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ != nullptr) _impl_.address_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } NonceRequest::NonceRequest(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.NonceRequest) } inline PROTOBUF_NDEBUG_INLINE NonceRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::txpool::NonceRequest& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} NonceRequest::NonceRequest( ::google::protobuf::Arena* arena, const NonceRequest& from) : ::google::protobuf::Message(arena) { NonceRequest* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.address_) : nullptr; // @@protoc_insertion_point(copy_constructor:txpool.NonceRequest) } inline PROTOBUF_NDEBUG_INLINE NonceRequest::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void NonceRequest::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.address_ = {}; } NonceRequest::~NonceRequest() { // @@protoc_insertion_point(destructor:txpool.NonceRequest) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NonceRequest::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.address_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NonceRequest::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NonceRequest, _impl_._cached_size_), false, }, &NonceRequest::MergeImpl, &NonceRequest::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 1, 0, 2> NonceRequest::_table_ = { { PROTOBUF_FIELD_OFFSET(NonceRequest, _impl_._has_bits_), 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_NonceRequest_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::NonceRequest>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H160 address = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(NonceRequest, _impl_.address_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H160 address = 1; {PROTOBUF_FIELD_OFFSET(NonceRequest, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void NonceRequest::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.NonceRequest) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.address_ != nullptr); _impl_.address_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NonceRequest::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.NonceRequest) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H160 address = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.address_, _impl_.address_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.NonceRequest) return target; } ::size_t NonceRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.NonceRequest) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .types.H160 address = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.address_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NonceRequest::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.NonceRequest) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.address_ != nullptr); if (_this->_impl_.address_ == nullptr) { _this->_impl_.address_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.address_); } else { _this->_impl_.address_->MergeFrom(*from._impl_.address_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NonceRequest::CopyFrom(const NonceRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.NonceRequest) if (&from == this) return; Clear(); MergeFrom(from); } void NonceRequest::InternalSwap(NonceRequest* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_.address_, other->_impl_.address_); } ::google::protobuf::Metadata NonceRequest::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NonceReply::_Internal { public: }; NonceReply::NonceReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:txpool.NonceReply) } NonceReply::NonceReply( ::google::protobuf::Arena* arena, const NonceReply& from) : NonceReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE NonceReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void NonceReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, nonce_), 0, offsetof(Impl_, found_) - offsetof(Impl_, nonce_) + sizeof(Impl_::found_)); } NonceReply::~NonceReply() { // @@protoc_insertion_point(destructor:txpool.NonceReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NonceReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NonceReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NonceReply, _impl_._cached_size_), false, }, &NonceReply::MergeImpl, &NonceReply::kDescriptorMethods, &descriptor_table_txpool_2ftxpool_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> NonceReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_NonceReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::txpool::NonceReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 nonce = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(NonceReply, _impl_.nonce_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(NonceReply, _impl_.nonce_)}}, // bool found = 1; {::_pbi::TcParser::SingularVarintNoZag1(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(NonceReply, _impl_.found_)}}, }}, {{ 65535, 65535 }}, {{ // bool found = 1; {PROTOBUF_FIELD_OFFSET(NonceReply, _impl_.found_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // uint64 nonce = 2; {PROTOBUF_FIELD_OFFSET(NonceReply, _impl_.nonce_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void NonceReply::Clear() { // @@protoc_insertion_point(message_clear_start:txpool.NonceReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.nonce_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.found_) - reinterpret_cast(&_impl_.nonce_)) + sizeof(_impl_.found_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NonceReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:txpool.NonceReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // bool found = 1; if (this->_internal_found() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 1, this->_internal_found(), target); } // uint64 nonce = 2; if (this->_internal_nonce() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_nonce(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:txpool.NonceReply) return target; } ::size_t NonceReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:txpool.NonceReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 nonce = 2; if (this->_internal_nonce() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_nonce()); } // bool found = 1; if (this->_internal_found() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NonceReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:txpool.NonceReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_nonce() != 0) { _this->_impl_.nonce_ = from._impl_.nonce_; } if (from._internal_found() != 0) { _this->_impl_.found_ = from._impl_.found_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NonceReply::CopyFrom(const NonceReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:txpool.NonceReply) if (&from == this) return; Clear(); MergeFrom(from); } void NonceReply::InternalSwap(NonceReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(NonceReply, _impl_.found_) + sizeof(NonceReply::_impl_.found_) - PROTOBUF_FIELD_OFFSET(NonceReply, _impl_.nonce_)>( reinterpret_cast(&_impl_.nonce_), reinterpret_cast(&other->_impl_.nonce_)); } ::google::protobuf::Metadata NonceReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) } // namespace txpool namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_txpool_2ftxpool_2eproto), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/txpool/txpool.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: txpool/txpool.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_txpool_2ftxpool_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_txpool_2ftxpool_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_bases.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/empty.pb.h" #include "types/types.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_txpool_2ftxpool_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_txpool_2ftxpool_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_txpool_2ftxpool_2eproto; namespace txpool { class AddReply; struct AddReplyDefaultTypeInternal; extern AddReplyDefaultTypeInternal _AddReply_default_instance_; class AddRequest; struct AddRequestDefaultTypeInternal; extern AddRequestDefaultTypeInternal _AddRequest_default_instance_; class AllReply; struct AllReplyDefaultTypeInternal; extern AllReplyDefaultTypeInternal _AllReply_default_instance_; class AllReply_Tx; struct AllReply_TxDefaultTypeInternal; extern AllReply_TxDefaultTypeInternal _AllReply_Tx_default_instance_; class AllRequest; struct AllRequestDefaultTypeInternal; extern AllRequestDefaultTypeInternal _AllRequest_default_instance_; class NonceReply; struct NonceReplyDefaultTypeInternal; extern NonceReplyDefaultTypeInternal _NonceReply_default_instance_; class NonceRequest; struct NonceRequestDefaultTypeInternal; extern NonceRequestDefaultTypeInternal _NonceRequest_default_instance_; class OnAddReply; struct OnAddReplyDefaultTypeInternal; extern OnAddReplyDefaultTypeInternal _OnAddReply_default_instance_; class OnAddRequest; struct OnAddRequestDefaultTypeInternal; extern OnAddRequestDefaultTypeInternal _OnAddRequest_default_instance_; class PendingReply; struct PendingReplyDefaultTypeInternal; extern PendingReplyDefaultTypeInternal _PendingReply_default_instance_; class PendingReply_Tx; struct PendingReply_TxDefaultTypeInternal; extern PendingReply_TxDefaultTypeInternal _PendingReply_Tx_default_instance_; class StatusReply; struct StatusReplyDefaultTypeInternal; extern StatusReplyDefaultTypeInternal _StatusReply_default_instance_; class StatusRequest; struct StatusRequestDefaultTypeInternal; extern StatusRequestDefaultTypeInternal _StatusRequest_default_instance_; class TransactionsReply; struct TransactionsReplyDefaultTypeInternal; extern TransactionsReplyDefaultTypeInternal _TransactionsReply_default_instance_; class TransactionsRequest; struct TransactionsRequestDefaultTypeInternal; extern TransactionsRequestDefaultTypeInternal _TransactionsRequest_default_instance_; class TxHashes; struct TxHashesDefaultTypeInternal; extern TxHashesDefaultTypeInternal _TxHashes_default_instance_; } // namespace txpool namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace txpool { enum AllReply_TxnType : int { AllReply_TxnType_PENDING = 0, AllReply_TxnType_QUEUED = 1, AllReply_TxnType_BASE_FEE = 2, AllReply_TxnType_AllReply_TxnType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), AllReply_TxnType_AllReply_TxnType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool AllReply_TxnType_IsValid(int value); extern const uint32_t AllReply_TxnType_internal_data_[]; constexpr AllReply_TxnType AllReply_TxnType_TxnType_MIN = static_cast(0); constexpr AllReply_TxnType AllReply_TxnType_TxnType_MAX = static_cast(2); constexpr int AllReply_TxnType_TxnType_ARRAYSIZE = 2 + 1; const ::google::protobuf::EnumDescriptor* AllReply_TxnType_descriptor(); template const std::string& AllReply_TxnType_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to TxnType_Name()."); return AllReply_TxnType_Name(static_cast(value)); } template <> inline const std::string& AllReply_TxnType_Name(AllReply_TxnType value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool AllReply_TxnType_Parse(absl::string_view name, AllReply_TxnType* value) { return ::google::protobuf::internal::ParseNamedEnum( AllReply_TxnType_descriptor(), name, value); } enum ImportResult : int { SUCCESS = 0, ALREADY_EXISTS = 1, FEE_TOO_LOW = 2, STALE = 3, INVALID = 4, INTERNAL_ERROR = 5, ImportResult_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(), ImportResult_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max(), }; bool ImportResult_IsValid(int value); extern const uint32_t ImportResult_internal_data_[]; constexpr ImportResult ImportResult_MIN = static_cast(0); constexpr ImportResult ImportResult_MAX = static_cast(5); constexpr int ImportResult_ARRAYSIZE = 5 + 1; const ::google::protobuf::EnumDescriptor* ImportResult_descriptor(); template const std::string& ImportResult_Name(T value) { static_assert(std::is_same::value || std::is_integral::value, "Incorrect type passed to ImportResult_Name()."); return ImportResult_Name(static_cast(value)); } template <> inline const std::string& ImportResult_Name(ImportResult value) { return ::google::protobuf::internal::NameOfDenseEnum( static_cast(value)); } inline bool ImportResult_Parse(absl::string_view name, ImportResult* value) { return ::google::protobuf::internal::ParseNamedEnum( ImportResult_descriptor(), name, value); } // =================================================================== // ------------------------------------------------------------------- class TransactionsReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.TransactionsReply) */ { public: inline TransactionsReply() : TransactionsReply(nullptr) {} ~TransactionsReply() override; template explicit PROTOBUF_CONSTEXPR TransactionsReply( ::google::protobuf::internal::ConstantInitialized); inline TransactionsReply(const TransactionsReply& from) : TransactionsReply(nullptr, from) {} inline TransactionsReply(TransactionsReply&& from) noexcept : TransactionsReply(nullptr, std::move(from)) {} inline TransactionsReply& operator=(const TransactionsReply& from) { CopyFrom(from); return *this; } inline TransactionsReply& operator=(TransactionsReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const TransactionsReply& default_instance() { return *internal_default_instance(); } static inline const TransactionsReply* internal_default_instance() { return reinterpret_cast( &_TransactionsReply_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(TransactionsReply& a, TransactionsReply& b) { a.Swap(&b); } inline void Swap(TransactionsReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TransactionsReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TransactionsReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const TransactionsReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const TransactionsReply& from) { TransactionsReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(TransactionsReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.TransactionsReply"; } protected: explicit TransactionsReply(::google::protobuf::Arena* arena); TransactionsReply(::google::protobuf::Arena* arena, const TransactionsReply& from); TransactionsReply(::google::protobuf::Arena* arena, TransactionsReply&& from) noexcept : TransactionsReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRlpTxsFieldNumber = 1, }; // repeated bytes rlp_txs = 1; int rlp_txs_size() const; private: int _internal_rlp_txs_size() const; public: void clear_rlp_txs() ; const std::string& rlp_txs(int index) const; std::string* mutable_rlp_txs(int index); void set_rlp_txs(int index, const std::string& value); void set_rlp_txs(int index, std::string&& value); void set_rlp_txs(int index, const char* value); void set_rlp_txs(int index, const void* value, std::size_t size); void set_rlp_txs(int index, absl::string_view value); std::string* add_rlp_txs(); void add_rlp_txs(const std::string& value); void add_rlp_txs(std::string&& value); void add_rlp_txs(const char* value); void add_rlp_txs(const void* value, std::size_t size); void add_rlp_txs(absl::string_view value); const ::google::protobuf::RepeatedPtrField& rlp_txs() const; ::google::protobuf::RepeatedPtrField* mutable_rlp_txs(); private: const ::google::protobuf::RepeatedPtrField& _internal_rlp_txs() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_rlp_txs(); public: // @@protoc_insertion_point(class_scope:txpool.TransactionsReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_TransactionsReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const TransactionsReply& from_msg); ::google::protobuf::RepeatedPtrField rlp_txs_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class StatusRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.StatusRequest) */ { public: inline StatusRequest() : StatusRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR StatusRequest( ::google::protobuf::internal::ConstantInitialized); inline StatusRequest(const StatusRequest& from) : StatusRequest(nullptr, from) {} inline StatusRequest(StatusRequest&& from) noexcept : StatusRequest(nullptr, std::move(from)) {} inline StatusRequest& operator=(const StatusRequest& from) { CopyFrom(from); return *this; } inline StatusRequest& operator=(StatusRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const StatusRequest& default_instance() { return *internal_default_instance(); } static inline const StatusRequest* internal_default_instance() { return reinterpret_cast( &_StatusRequest_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(StatusRequest& a, StatusRequest& b) { a.Swap(&b); } inline void Swap(StatusRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StatusRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StatusRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const StatusRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const StatusRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.StatusRequest"; } protected: explicit StatusRequest(::google::protobuf::Arena* arena); StatusRequest(::google::protobuf::Arena* arena, const StatusRequest& from); StatusRequest(::google::protobuf::Arena* arena, StatusRequest&& from) noexcept : StatusRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.StatusRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_StatusRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const StatusRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class StatusReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.StatusReply) */ { public: inline StatusReply() : StatusReply(nullptr) {} ~StatusReply() override; template explicit PROTOBUF_CONSTEXPR StatusReply( ::google::protobuf::internal::ConstantInitialized); inline StatusReply(const StatusReply& from) : StatusReply(nullptr, from) {} inline StatusReply(StatusReply&& from) noexcept : StatusReply(nullptr, std::move(from)) {} inline StatusReply& operator=(const StatusReply& from) { CopyFrom(from); return *this; } inline StatusReply& operator=(StatusReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const StatusReply& default_instance() { return *internal_default_instance(); } static inline const StatusReply* internal_default_instance() { return reinterpret_cast( &_StatusReply_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(StatusReply& a, StatusReply& b) { a.Swap(&b); } inline void Swap(StatusReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StatusReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StatusReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const StatusReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const StatusReply& from) { StatusReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(StatusReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.StatusReply"; } protected: explicit StatusReply(::google::protobuf::Arena* arena); StatusReply(::google::protobuf::Arena* arena, const StatusReply& from); StatusReply(::google::protobuf::Arena* arena, StatusReply&& from) noexcept : StatusReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kPendingCountFieldNumber = 1, kQueuedCountFieldNumber = 2, kBaseFeeCountFieldNumber = 3, }; // uint32 pending_count = 1; void clear_pending_count() ; ::uint32_t pending_count() const; void set_pending_count(::uint32_t value); private: ::uint32_t _internal_pending_count() const; void _internal_set_pending_count(::uint32_t value); public: // uint32 queued_count = 2; void clear_queued_count() ; ::uint32_t queued_count() const; void set_queued_count(::uint32_t value); private: ::uint32_t _internal_queued_count() const; void _internal_set_queued_count(::uint32_t value); public: // uint32 base_fee_count = 3; void clear_base_fee_count() ; ::uint32_t base_fee_count() const; void set_base_fee_count(::uint32_t value); private: ::uint32_t _internal_base_fee_count() const; void _internal_set_base_fee_count(::uint32_t value); public: // @@protoc_insertion_point(class_scope:txpool.StatusReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_StatusReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const StatusReply& from_msg); ::uint32_t pending_count_; ::uint32_t queued_count_; ::uint32_t base_fee_count_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class OnAddRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.OnAddRequest) */ { public: inline OnAddRequest() : OnAddRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR OnAddRequest( ::google::protobuf::internal::ConstantInitialized); inline OnAddRequest(const OnAddRequest& from) : OnAddRequest(nullptr, from) {} inline OnAddRequest(OnAddRequest&& from) noexcept : OnAddRequest(nullptr, std::move(from)) {} inline OnAddRequest& operator=(const OnAddRequest& from) { CopyFrom(from); return *this; } inline OnAddRequest& operator=(OnAddRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnAddRequest& default_instance() { return *internal_default_instance(); } static inline const OnAddRequest* internal_default_instance() { return reinterpret_cast( &_OnAddRequest_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(OnAddRequest& a, OnAddRequest& b) { a.Swap(&b); } inline void Swap(OnAddRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnAddRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnAddRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const OnAddRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const OnAddRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnAddRequest"; } protected: explicit OnAddRequest(::google::protobuf::Arena* arena); OnAddRequest(::google::protobuf::Arena* arena, const OnAddRequest& from); OnAddRequest(::google::protobuf::Arena* arena, OnAddRequest&& from) noexcept : OnAddRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.OnAddRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnAddRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnAddRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class OnAddReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.OnAddReply) */ { public: inline OnAddReply() : OnAddReply(nullptr) {} ~OnAddReply() override; template explicit PROTOBUF_CONSTEXPR OnAddReply( ::google::protobuf::internal::ConstantInitialized); inline OnAddReply(const OnAddReply& from) : OnAddReply(nullptr, from) {} inline OnAddReply(OnAddReply&& from) noexcept : OnAddReply(nullptr, std::move(from)) {} inline OnAddReply& operator=(const OnAddReply& from) { CopyFrom(from); return *this; } inline OnAddReply& operator=(OnAddReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const OnAddReply& default_instance() { return *internal_default_instance(); } static inline const OnAddReply* internal_default_instance() { return reinterpret_cast( &_OnAddReply_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(OnAddReply& a, OnAddReply& b) { a.Swap(&b); } inline void Swap(OnAddReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnAddReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnAddReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const OnAddReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const OnAddReply& from) { OnAddReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(OnAddReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.OnAddReply"; } protected: explicit OnAddReply(::google::protobuf::Arena* arena); OnAddReply(::google::protobuf::Arena* arena, const OnAddReply& from); OnAddReply(::google::protobuf::Arena* arena, OnAddReply&& from) noexcept : OnAddReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRplTxsFieldNumber = 1, }; // repeated bytes rpl_txs = 1; int rpl_txs_size() const; private: int _internal_rpl_txs_size() const; public: void clear_rpl_txs() ; const std::string& rpl_txs(int index) const; std::string* mutable_rpl_txs(int index); void set_rpl_txs(int index, const std::string& value); void set_rpl_txs(int index, std::string&& value); void set_rpl_txs(int index, const char* value); void set_rpl_txs(int index, const void* value, std::size_t size); void set_rpl_txs(int index, absl::string_view value); std::string* add_rpl_txs(); void add_rpl_txs(const std::string& value); void add_rpl_txs(std::string&& value); void add_rpl_txs(const char* value); void add_rpl_txs(const void* value, std::size_t size); void add_rpl_txs(absl::string_view value); const ::google::protobuf::RepeatedPtrField& rpl_txs() const; ::google::protobuf::RepeatedPtrField* mutable_rpl_txs(); private: const ::google::protobuf::RepeatedPtrField& _internal_rpl_txs() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_rpl_txs(); public: // @@protoc_insertion_point(class_scope:txpool.OnAddReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_OnAddReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const OnAddReply& from_msg); ::google::protobuf::RepeatedPtrField rpl_txs_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class NonceReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.NonceReply) */ { public: inline NonceReply() : NonceReply(nullptr) {} ~NonceReply() override; template explicit PROTOBUF_CONSTEXPR NonceReply( ::google::protobuf::internal::ConstantInitialized); inline NonceReply(const NonceReply& from) : NonceReply(nullptr, from) {} inline NonceReply(NonceReply&& from) noexcept : NonceReply(nullptr, std::move(from)) {} inline NonceReply& operator=(const NonceReply& from) { CopyFrom(from); return *this; } inline NonceReply& operator=(NonceReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NonceReply& default_instance() { return *internal_default_instance(); } static inline const NonceReply* internal_default_instance() { return reinterpret_cast( &_NonceReply_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(NonceReply& a, NonceReply& b) { a.Swap(&b); } inline void Swap(NonceReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NonceReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NonceReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NonceReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NonceReply& from) { NonceReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NonceReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.NonceReply"; } protected: explicit NonceReply(::google::protobuf::Arena* arena); NonceReply(::google::protobuf::Arena* arena, const NonceReply& from); NonceReply(::google::protobuf::Arena* arena, NonceReply&& from) noexcept : NonceReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNonceFieldNumber = 2, kFoundFieldNumber = 1, }; // uint64 nonce = 2; void clear_nonce() ; ::uint64_t nonce() const; void set_nonce(::uint64_t value); private: ::uint64_t _internal_nonce() const; void _internal_set_nonce(::uint64_t value); public: // bool found = 1; void clear_found() ; bool found() const; void set_found(bool value); private: bool _internal_found() const; void _internal_set_found(bool value); public: // @@protoc_insertion_point(class_scope:txpool.NonceReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NonceReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NonceReply& from_msg); ::uint64_t nonce_; bool found_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class AllRequest final : public ::google::protobuf::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:txpool.AllRequest) */ { public: inline AllRequest() : AllRequest(nullptr) {} template explicit PROTOBUF_CONSTEXPR AllRequest( ::google::protobuf::internal::ConstantInitialized); inline AllRequest(const AllRequest& from) : AllRequest(nullptr, from) {} inline AllRequest(AllRequest&& from) noexcept : AllRequest(nullptr, std::move(from)) {} inline AllRequest& operator=(const AllRequest& from) { CopyFrom(from); return *this; } inline AllRequest& operator=(AllRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AllRequest& default_instance() { return *internal_default_instance(); } static inline const AllRequest* internal_default_instance() { return reinterpret_cast( &_AllRequest_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(AllRequest& a, AllRequest& b) { a.Swap(&b); } inline void Swap(AllRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AllRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AllRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::internal::ZeroFieldsBase::DefaultConstruct(arena); } using ::google::protobuf::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const AllRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::google::protobuf::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const AllRequest& from) { ::google::protobuf::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: bool IsInitialized() const { return true; } private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.AllRequest"; } protected: explicit AllRequest(::google::protobuf::Arena* arena); AllRequest(::google::protobuf::Arena* arena, const AllRequest& from); AllRequest(::google::protobuf::Arena* arena, AllRequest&& from) noexcept : AllRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ZeroFieldsBase::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:txpool.AllRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 0, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AllRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AllRequest& from_msg); PROTOBUF_TSAN_DECLARE_MEMBER }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class AddRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.AddRequest) */ { public: inline AddRequest() : AddRequest(nullptr) {} ~AddRequest() override; template explicit PROTOBUF_CONSTEXPR AddRequest( ::google::protobuf::internal::ConstantInitialized); inline AddRequest(const AddRequest& from) : AddRequest(nullptr, from) {} inline AddRequest(AddRequest&& from) noexcept : AddRequest(nullptr, std::move(from)) {} inline AddRequest& operator=(const AddRequest& from) { CopyFrom(from); return *this; } inline AddRequest& operator=(AddRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AddRequest& default_instance() { return *internal_default_instance(); } static inline const AddRequest* internal_default_instance() { return reinterpret_cast( &_AddRequest_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(AddRequest& a, AddRequest& b) { a.Swap(&b); } inline void Swap(AddRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AddRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AddRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AddRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AddRequest& from) { AddRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AddRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.AddRequest"; } protected: explicit AddRequest(::google::protobuf::Arena* arena); AddRequest(::google::protobuf::Arena* arena, const AddRequest& from); AddRequest(::google::protobuf::Arena* arena, AddRequest&& from) noexcept : AddRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRlpTxsFieldNumber = 1, }; // repeated bytes rlp_txs = 1; int rlp_txs_size() const; private: int _internal_rlp_txs_size() const; public: void clear_rlp_txs() ; const std::string& rlp_txs(int index) const; std::string* mutable_rlp_txs(int index); void set_rlp_txs(int index, const std::string& value); void set_rlp_txs(int index, std::string&& value); void set_rlp_txs(int index, const char* value); void set_rlp_txs(int index, const void* value, std::size_t size); void set_rlp_txs(int index, absl::string_view value); std::string* add_rlp_txs(); void add_rlp_txs(const std::string& value); void add_rlp_txs(std::string&& value); void add_rlp_txs(const char* value); void add_rlp_txs(const void* value, std::size_t size); void add_rlp_txs(absl::string_view value); const ::google::protobuf::RepeatedPtrField& rlp_txs() const; ::google::protobuf::RepeatedPtrField* mutable_rlp_txs(); private: const ::google::protobuf::RepeatedPtrField& _internal_rlp_txs() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_rlp_txs(); public: // @@protoc_insertion_point(class_scope:txpool.AddRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AddRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AddRequest& from_msg); ::google::protobuf::RepeatedPtrField rlp_txs_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class AddReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.AddReply) */ { public: inline AddReply() : AddReply(nullptr) {} ~AddReply() override; template explicit PROTOBUF_CONSTEXPR AddReply( ::google::protobuf::internal::ConstantInitialized); inline AddReply(const AddReply& from) : AddReply(nullptr, from) {} inline AddReply(AddReply&& from) noexcept : AddReply(nullptr, std::move(from)) {} inline AddReply& operator=(const AddReply& from) { CopyFrom(from); return *this; } inline AddReply& operator=(AddReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AddReply& default_instance() { return *internal_default_instance(); } static inline const AddReply* internal_default_instance() { return reinterpret_cast( &_AddReply_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(AddReply& a, AddReply& b) { a.Swap(&b); } inline void Swap(AddReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AddReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AddReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AddReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AddReply& from) { AddReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AddReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.AddReply"; } protected: explicit AddReply(::google::protobuf::Arena* arena); AddReply(::google::protobuf::Arena* arena, const AddReply& from); AddReply(::google::protobuf::Arena* arena, AddReply&& from) noexcept : AddReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kImportedFieldNumber = 1, kErrorsFieldNumber = 2, }; // repeated .txpool.ImportResult imported = 1; int imported_size() const; private: int _internal_imported_size() const; public: void clear_imported() ; public: ::txpool::ImportResult imported(int index) const; void set_imported(int index, ::txpool::ImportResult value); void add_imported(::txpool::ImportResult value); const ::google::protobuf::RepeatedField& imported() const; ::google::protobuf::RepeatedField* mutable_imported(); private: const ::google::protobuf::RepeatedField& _internal_imported() const; ::google::protobuf::RepeatedField* _internal_mutable_imported(); public: // repeated string errors = 2; int errors_size() const; private: int _internal_errors_size() const; public: void clear_errors() ; const std::string& errors(int index) const; std::string* mutable_errors(int index); void set_errors(int index, const std::string& value); void set_errors(int index, std::string&& value); void set_errors(int index, const char* value); void set_errors(int index, const char* value, std::size_t size); void set_errors(int index, absl::string_view value); std::string* add_errors(); void add_errors(const std::string& value); void add_errors(std::string&& value); void add_errors(const char* value); void add_errors(const char* value, std::size_t size); void add_errors(absl::string_view value); const ::google::protobuf::RepeatedPtrField& errors() const; ::google::protobuf::RepeatedPtrField* mutable_errors(); private: const ::google::protobuf::RepeatedPtrField& _internal_errors() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_errors(); public: // @@protoc_insertion_point(class_scope:txpool.AddReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 30, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AddReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AddReply& from_msg); ::google::protobuf::RepeatedField imported_; mutable ::google::protobuf::internal::CachedSize _imported_cached_byte_size_; ::google::protobuf::RepeatedPtrField errors_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class TxHashes final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.TxHashes) */ { public: inline TxHashes() : TxHashes(nullptr) {} ~TxHashes() override; template explicit PROTOBUF_CONSTEXPR TxHashes( ::google::protobuf::internal::ConstantInitialized); inline TxHashes(const TxHashes& from) : TxHashes(nullptr, from) {} inline TxHashes(TxHashes&& from) noexcept : TxHashes(nullptr, std::move(from)) {} inline TxHashes& operator=(const TxHashes& from) { CopyFrom(from); return *this; } inline TxHashes& operator=(TxHashes&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const TxHashes& default_instance() { return *internal_default_instance(); } static inline const TxHashes* internal_default_instance() { return reinterpret_cast( &_TxHashes_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(TxHashes& a, TxHashes& b) { a.Swap(&b); } inline void Swap(TxHashes* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TxHashes* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TxHashes* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const TxHashes& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const TxHashes& from) { TxHashes::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(TxHashes* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.TxHashes"; } protected: explicit TxHashes(::google::protobuf::Arena* arena); TxHashes(::google::protobuf::Arena* arena, const TxHashes& from); TxHashes(::google::protobuf::Arena* arena, TxHashes&& from) noexcept : TxHashes(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashesFieldNumber = 1, }; // repeated .types.H256 hashes = 1; int hashes_size() const; private: int _internal_hashes_size() const; public: void clear_hashes() ; ::types::H256* mutable_hashes(int index); ::google::protobuf::RepeatedPtrField<::types::H256>* mutable_hashes(); private: const ::google::protobuf::RepeatedPtrField<::types::H256>& _internal_hashes() const; ::google::protobuf::RepeatedPtrField<::types::H256>* _internal_mutable_hashes(); public: const ::types::H256& hashes(int index) const; ::types::H256* add_hashes(); const ::google::protobuf::RepeatedPtrField<::types::H256>& hashes() const; // @@protoc_insertion_point(class_scope:txpool.TxHashes) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_TxHashes_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const TxHashes& from_msg); ::google::protobuf::RepeatedPtrField< ::types::H256 > hashes_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class TransactionsRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.TransactionsRequest) */ { public: inline TransactionsRequest() : TransactionsRequest(nullptr) {} ~TransactionsRequest() override; template explicit PROTOBUF_CONSTEXPR TransactionsRequest( ::google::protobuf::internal::ConstantInitialized); inline TransactionsRequest(const TransactionsRequest& from) : TransactionsRequest(nullptr, from) {} inline TransactionsRequest(TransactionsRequest&& from) noexcept : TransactionsRequest(nullptr, std::move(from)) {} inline TransactionsRequest& operator=(const TransactionsRequest& from) { CopyFrom(from); return *this; } inline TransactionsRequest& operator=(TransactionsRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const TransactionsRequest& default_instance() { return *internal_default_instance(); } static inline const TransactionsRequest* internal_default_instance() { return reinterpret_cast( &_TransactionsRequest_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(TransactionsRequest& a, TransactionsRequest& b) { a.Swap(&b); } inline void Swap(TransactionsRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TransactionsRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TransactionsRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const TransactionsRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const TransactionsRequest& from) { TransactionsRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(TransactionsRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.TransactionsRequest"; } protected: explicit TransactionsRequest(::google::protobuf::Arena* arena); TransactionsRequest(::google::protobuf::Arena* arena, const TransactionsRequest& from); TransactionsRequest(::google::protobuf::Arena* arena, TransactionsRequest&& from) noexcept : TransactionsRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHashesFieldNumber = 1, }; // repeated .types.H256 hashes = 1; int hashes_size() const; private: int _internal_hashes_size() const; public: void clear_hashes() ; ::types::H256* mutable_hashes(int index); ::google::protobuf::RepeatedPtrField<::types::H256>* mutable_hashes(); private: const ::google::protobuf::RepeatedPtrField<::types::H256>& _internal_hashes() const; ::google::protobuf::RepeatedPtrField<::types::H256>* _internal_mutable_hashes(); public: const ::types::H256& hashes(int index) const; ::types::H256* add_hashes(); const ::google::protobuf::RepeatedPtrField<::types::H256>& hashes() const; // @@protoc_insertion_point(class_scope:txpool.TransactionsRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_TransactionsRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const TransactionsRequest& from_msg); ::google::protobuf::RepeatedPtrField< ::types::H256 > hashes_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class PendingReply_Tx final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.PendingReply.Tx) */ { public: inline PendingReply_Tx() : PendingReply_Tx(nullptr) {} ~PendingReply_Tx() override; template explicit PROTOBUF_CONSTEXPR PendingReply_Tx( ::google::protobuf::internal::ConstantInitialized); inline PendingReply_Tx(const PendingReply_Tx& from) : PendingReply_Tx(nullptr, from) {} inline PendingReply_Tx(PendingReply_Tx&& from) noexcept : PendingReply_Tx(nullptr, std::move(from)) {} inline PendingReply_Tx& operator=(const PendingReply_Tx& from) { CopyFrom(from); return *this; } inline PendingReply_Tx& operator=(PendingReply_Tx&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PendingReply_Tx& default_instance() { return *internal_default_instance(); } static inline const PendingReply_Tx* internal_default_instance() { return reinterpret_cast( &_PendingReply_Tx_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(PendingReply_Tx& a, PendingReply_Tx& b) { a.Swap(&b); } inline void Swap(PendingReply_Tx* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PendingReply_Tx* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PendingReply_Tx* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PendingReply_Tx& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PendingReply_Tx& from) { PendingReply_Tx::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PendingReply_Tx* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.PendingReply.Tx"; } protected: explicit PendingReply_Tx(::google::protobuf::Arena* arena); PendingReply_Tx(::google::protobuf::Arena* arena, const PendingReply_Tx& from); PendingReply_Tx(::google::protobuf::Arena* arena, PendingReply_Tx&& from) noexcept : PendingReply_Tx(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRlpTxFieldNumber = 2, kSenderFieldNumber = 1, kIsLocalFieldNumber = 3, }; // bytes rlp_tx = 2; void clear_rlp_tx() ; const std::string& rlp_tx() const; template void set_rlp_tx(Arg_&& arg, Args_... args); std::string* mutable_rlp_tx(); PROTOBUF_NODISCARD std::string* release_rlp_tx(); void set_allocated_rlp_tx(std::string* value); private: const std::string& _internal_rlp_tx() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_rlp_tx( const std::string& value); std::string* _internal_mutable_rlp_tx(); public: // .types.H160 sender = 1; bool has_sender() const; void clear_sender() ; const ::types::H160& sender() const; PROTOBUF_NODISCARD ::types::H160* release_sender(); ::types::H160* mutable_sender(); void set_allocated_sender(::types::H160* value); void unsafe_arena_set_allocated_sender(::types::H160* value); ::types::H160* unsafe_arena_release_sender(); private: const ::types::H160& _internal_sender() const; ::types::H160* _internal_mutable_sender(); public: // bool is_local = 3; void clear_is_local() ; bool is_local() const; void set_is_local(bool value); private: bool _internal_is_local() const; void _internal_set_is_local(bool value); public: // @@protoc_insertion_point(class_scope:txpool.PendingReply.Tx) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PendingReply_Tx_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PendingReply_Tx& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr rlp_tx_; ::types::H160* sender_; bool is_local_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class NonceRequest final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.NonceRequest) */ { public: inline NonceRequest() : NonceRequest(nullptr) {} ~NonceRequest() override; template explicit PROTOBUF_CONSTEXPR NonceRequest( ::google::protobuf::internal::ConstantInitialized); inline NonceRequest(const NonceRequest& from) : NonceRequest(nullptr, from) {} inline NonceRequest(NonceRequest&& from) noexcept : NonceRequest(nullptr, std::move(from)) {} inline NonceRequest& operator=(const NonceRequest& from) { CopyFrom(from); return *this; } inline NonceRequest& operator=(NonceRequest&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NonceRequest& default_instance() { return *internal_default_instance(); } static inline const NonceRequest* internal_default_instance() { return reinterpret_cast( &_NonceRequest_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(NonceRequest& a, NonceRequest& b) { a.Swap(&b); } inline void Swap(NonceRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NonceRequest* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NonceRequest* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NonceRequest& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NonceRequest& from) { NonceRequest::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NonceRequest* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.NonceRequest"; } protected: explicit NonceRequest(::google::protobuf::Arena* arena); NonceRequest(::google::protobuf::Arena* arena, const NonceRequest& from); NonceRequest(::google::protobuf::Arena* arena, NonceRequest&& from) noexcept : NonceRequest(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kAddressFieldNumber = 1, }; // .types.H160 address = 1; bool has_address() const; void clear_address() ; const ::types::H160& address() const; PROTOBUF_NODISCARD ::types::H160* release_address(); ::types::H160* mutable_address(); void set_allocated_address(::types::H160* value); void unsafe_arena_set_allocated_address(::types::H160* value); ::types::H160* unsafe_arena_release_address(); private: const ::types::H160& _internal_address() const; ::types::H160* _internal_mutable_address(); public: // @@protoc_insertion_point(class_scope:txpool.NonceRequest) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NonceRequest_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NonceRequest& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H160* address_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class AllReply_Tx final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.AllReply.Tx) */ { public: inline AllReply_Tx() : AllReply_Tx(nullptr) {} ~AllReply_Tx() override; template explicit PROTOBUF_CONSTEXPR AllReply_Tx( ::google::protobuf::internal::ConstantInitialized); inline AllReply_Tx(const AllReply_Tx& from) : AllReply_Tx(nullptr, from) {} inline AllReply_Tx(AllReply_Tx&& from) noexcept : AllReply_Tx(nullptr, std::move(from)) {} inline AllReply_Tx& operator=(const AllReply_Tx& from) { CopyFrom(from); return *this; } inline AllReply_Tx& operator=(AllReply_Tx&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AllReply_Tx& default_instance() { return *internal_default_instance(); } static inline const AllReply_Tx* internal_default_instance() { return reinterpret_cast( &_AllReply_Tx_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(AllReply_Tx& a, AllReply_Tx& b) { a.Swap(&b); } inline void Swap(AllReply_Tx* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AllReply_Tx* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AllReply_Tx* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AllReply_Tx& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AllReply_Tx& from) { AllReply_Tx::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AllReply_Tx* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.AllReply.Tx"; } protected: explicit AllReply_Tx(::google::protobuf::Arena* arena); AllReply_Tx(::google::protobuf::Arena* arena, const AllReply_Tx& from); AllReply_Tx(::google::protobuf::Arena* arena, AllReply_Tx&& from) noexcept : AllReply_Tx(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRlpTxFieldNumber = 3, kSenderFieldNumber = 2, kTxnTypeFieldNumber = 1, }; // bytes rlp_tx = 3; void clear_rlp_tx() ; const std::string& rlp_tx() const; template void set_rlp_tx(Arg_&& arg, Args_... args); std::string* mutable_rlp_tx(); PROTOBUF_NODISCARD std::string* release_rlp_tx(); void set_allocated_rlp_tx(std::string* value); private: const std::string& _internal_rlp_tx() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_rlp_tx( const std::string& value); std::string* _internal_mutable_rlp_tx(); public: // .types.H160 sender = 2; bool has_sender() const; void clear_sender() ; const ::types::H160& sender() const; PROTOBUF_NODISCARD ::types::H160* release_sender(); ::types::H160* mutable_sender(); void set_allocated_sender(::types::H160* value); void unsafe_arena_set_allocated_sender(::types::H160* value); ::types::H160* unsafe_arena_release_sender(); private: const ::types::H160& _internal_sender() const; ::types::H160* _internal_mutable_sender(); public: // .txpool.AllReply.TxnType txn_type = 1; void clear_txn_type() ; ::txpool::AllReply_TxnType txn_type() const; void set_txn_type(::txpool::AllReply_TxnType value); private: ::txpool::AllReply_TxnType _internal_txn_type() const; void _internal_set_txn_type(::txpool::AllReply_TxnType value); public: // @@protoc_insertion_point(class_scope:txpool.AllReply.Tx) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AllReply_Tx_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AllReply_Tx& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr rlp_tx_; ::types::H160* sender_; int txn_type_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class PendingReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.PendingReply) */ { public: inline PendingReply() : PendingReply(nullptr) {} ~PendingReply() override; template explicit PROTOBUF_CONSTEXPR PendingReply( ::google::protobuf::internal::ConstantInitialized); inline PendingReply(const PendingReply& from) : PendingReply(nullptr, from) {} inline PendingReply(PendingReply&& from) noexcept : PendingReply(nullptr, std::move(from)) {} inline PendingReply& operator=(const PendingReply& from) { CopyFrom(from); return *this; } inline PendingReply& operator=(PendingReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PendingReply& default_instance() { return *internal_default_instance(); } static inline const PendingReply* internal_default_instance() { return reinterpret_cast( &_PendingReply_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(PendingReply& a, PendingReply& b) { a.Swap(&b); } inline void Swap(PendingReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PendingReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PendingReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PendingReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PendingReply& from) { PendingReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PendingReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.PendingReply"; } protected: explicit PendingReply(::google::protobuf::Arena* arena); PendingReply(::google::protobuf::Arena* arena, const PendingReply& from); PendingReply(::google::protobuf::Arena* arena, PendingReply&& from) noexcept : PendingReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- using Tx = PendingReply_Tx; // accessors ------------------------------------------------------- enum : int { kTxsFieldNumber = 1, }; // repeated .txpool.PendingReply.Tx txs = 1; int txs_size() const; private: int _internal_txs_size() const; public: void clear_txs() ; ::txpool::PendingReply_Tx* mutable_txs(int index); ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>* mutable_txs(); private: const ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>& _internal_txs() const; ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>* _internal_mutable_txs(); public: const ::txpool::PendingReply_Tx& txs(int index) const; ::txpool::PendingReply_Tx* add_txs(); const ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>& txs() const; // @@protoc_insertion_point(class_scope:txpool.PendingReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PendingReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PendingReply& from_msg); ::google::protobuf::RepeatedPtrField< ::txpool::PendingReply_Tx > txs_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // ------------------------------------------------------------------- class AllReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:txpool.AllReply) */ { public: inline AllReply() : AllReply(nullptr) {} ~AllReply() override; template explicit PROTOBUF_CONSTEXPR AllReply( ::google::protobuf::internal::ConstantInitialized); inline AllReply(const AllReply& from) : AllReply(nullptr, from) {} inline AllReply(AllReply&& from) noexcept : AllReply(nullptr, std::move(from)) {} inline AllReply& operator=(const AllReply& from) { CopyFrom(from); return *this; } inline AllReply& operator=(AllReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const AllReply& default_instance() { return *internal_default_instance(); } static inline const AllReply* internal_default_instance() { return reinterpret_cast( &_AllReply_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(AllReply& a, AllReply& b) { a.Swap(&b); } inline void Swap(AllReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AllReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AllReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const AllReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const AllReply& from) { AllReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(AllReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "txpool.AllReply"; } protected: explicit AllReply(::google::protobuf::Arena* arena); AllReply(::google::protobuf::Arena* arena, const AllReply& from); AllReply(::google::protobuf::Arena* arena, AllReply&& from) noexcept : AllReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- using Tx = AllReply_Tx; using TxnType = AllReply_TxnType; static constexpr TxnType PENDING = AllReply_TxnType_PENDING; static constexpr TxnType QUEUED = AllReply_TxnType_QUEUED; static constexpr TxnType BASE_FEE = AllReply_TxnType_BASE_FEE; static inline bool TxnType_IsValid(int value) { return AllReply_TxnType_IsValid(value); } static constexpr TxnType TxnType_MIN = AllReply_TxnType_TxnType_MIN; static constexpr TxnType TxnType_MAX = AllReply_TxnType_TxnType_MAX; static constexpr int TxnType_ARRAYSIZE = AllReply_TxnType_TxnType_ARRAYSIZE; static inline const ::google::protobuf::EnumDescriptor* TxnType_descriptor() { return AllReply_TxnType_descriptor(); } template static inline const std::string& TxnType_Name(T value) { return AllReply_TxnType_Name(value); } static inline bool TxnType_Parse(absl::string_view name, TxnType* value) { return AllReply_TxnType_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kTxsFieldNumber = 1, }; // repeated .txpool.AllReply.Tx txs = 1; int txs_size() const; private: int _internal_txs_size() const; public: void clear_txs() ; ::txpool::AllReply_Tx* mutable_txs(int index); ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>* mutable_txs(); private: const ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>& _internal_txs() const; ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>* _internal_mutable_txs(); public: const ::txpool::AllReply_Tx& txs(int index) const; ::txpool::AllReply_Tx* add_txs(); const ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>& txs() const; // @@protoc_insertion_point(class_scope:txpool.AllReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_AllReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const AllReply& from_msg); ::google::protobuf::RepeatedPtrField< ::txpool::AllReply_Tx > txs_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_txpool_2ftxpool_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // TxHashes // repeated .types.H256 hashes = 1; inline int TxHashes::_internal_hashes_size() const { return _internal_hashes().size(); } inline int TxHashes::hashes_size() const { return _internal_hashes_size(); } inline ::types::H256* TxHashes::mutable_hashes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.TxHashes.hashes) return _internal_mutable_hashes()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H256>* TxHashes::mutable_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.TxHashes.hashes) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_hashes(); } inline const ::types::H256& TxHashes::hashes(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.TxHashes.hashes) return _internal_hashes().Get(index); } inline ::types::H256* TxHashes::add_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H256* _add = _internal_mutable_hashes()->Add(); // @@protoc_insertion_point(field_add:txpool.TxHashes.hashes) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& TxHashes::hashes() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.TxHashes.hashes) return _internal_hashes(); } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& TxHashes::_internal_hashes() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.hashes_; } inline ::google::protobuf::RepeatedPtrField<::types::H256>* TxHashes::_internal_mutable_hashes() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.hashes_; } // ------------------------------------------------------------------- // AddRequest // repeated bytes rlp_txs = 1; inline int AddRequest::_internal_rlp_txs_size() const { return _internal_rlp_txs().size(); } inline int AddRequest::rlp_txs_size() const { return _internal_rlp_txs_size(); } inline void AddRequest::clear_rlp_txs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_txs_.Clear(); } inline std::string* AddRequest::add_rlp_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_rlp_txs()->Add(); // @@protoc_insertion_point(field_add_mutable:txpool.AddRequest.rlp_txs) return _s; } inline const std::string& AddRequest::rlp_txs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.AddRequest.rlp_txs) return _internal_rlp_txs().Get(index); } inline std::string* AddRequest::mutable_rlp_txs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.AddRequest.rlp_txs) return _internal_mutable_rlp_txs()->Mutable(index); } inline void AddRequest::set_rlp_txs(int index, const std::string& value) { _internal_mutable_rlp_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:txpool.AddRequest.rlp_txs) } inline void AddRequest::set_rlp_txs(int index, std::string&& value) { _internal_mutable_rlp_txs()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:txpool.AddRequest.rlp_txs) } inline void AddRequest::set_rlp_txs(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_rlp_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:txpool.AddRequest.rlp_txs) } inline void AddRequest::set_rlp_txs(int index, const void* value, std::size_t size) { _internal_mutable_rlp_txs()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:txpool.AddRequest.rlp_txs) } inline void AddRequest::set_rlp_txs(int index, absl::string_view value) { _internal_mutable_rlp_txs()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:txpool.AddRequest.rlp_txs) } inline void AddRequest::add_rlp_txs(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add:txpool.AddRequest.rlp_txs) } inline void AddRequest::add_rlp_txs(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add(std::move(value)); // @@protoc_insertion_point(field_add:txpool.AddRequest.rlp_txs) } inline void AddRequest::add_rlp_txs(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:txpool.AddRequest.rlp_txs) } inline void AddRequest::add_rlp_txs(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:txpool.AddRequest.rlp_txs) } inline void AddRequest::add_rlp_txs(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:txpool.AddRequest.rlp_txs) } inline const ::google::protobuf::RepeatedPtrField& AddRequest::rlp_txs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.AddRequest.rlp_txs) return _internal_rlp_txs(); } inline ::google::protobuf::RepeatedPtrField* AddRequest::mutable_rlp_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.AddRequest.rlp_txs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_rlp_txs(); } inline const ::google::protobuf::RepeatedPtrField& AddRequest::_internal_rlp_txs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rlp_txs_; } inline ::google::protobuf::RepeatedPtrField* AddRequest::_internal_mutable_rlp_txs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.rlp_txs_; } // ------------------------------------------------------------------- // AddReply // repeated .txpool.ImportResult imported = 1; inline int AddReply::_internal_imported_size() const { return _internal_imported().size(); } inline int AddReply::imported_size() const { return _internal_imported_size(); } inline void AddReply::clear_imported() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.imported_.Clear(); } inline ::txpool::ImportResult AddReply::imported(int index) const { // @@protoc_insertion_point(field_get:txpool.AddReply.imported) return static_cast<::txpool::ImportResult>(_internal_imported().Get(index)); } inline void AddReply::set_imported(int index, ::txpool::ImportResult value) { _internal_mutable_imported()->Set(index, value); // @@protoc_insertion_point(field_set:txpool.AddReply.imported) } inline void AddReply::add_imported(::txpool::ImportResult value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_imported()->Add(value); // @@protoc_insertion_point(field_add:txpool.AddReply.imported) } inline const ::google::protobuf::RepeatedField& AddReply::imported() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.AddReply.imported) return _internal_imported(); } inline ::google::protobuf::RepeatedField* AddReply::mutable_imported() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.AddReply.imported) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_imported(); } inline const ::google::protobuf::RepeatedField& AddReply::_internal_imported() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.imported_; } inline ::google::protobuf::RepeatedField* AddReply::_internal_mutable_imported() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.imported_; } // repeated string errors = 2; inline int AddReply::_internal_errors_size() const { return _internal_errors().size(); } inline int AddReply::errors_size() const { return _internal_errors_size(); } inline void AddReply::clear_errors() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.errors_.Clear(); } inline std::string* AddReply::add_errors() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_errors()->Add(); // @@protoc_insertion_point(field_add_mutable:txpool.AddReply.errors) return _s; } inline const std::string& AddReply::errors(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.AddReply.errors) return _internal_errors().Get(index); } inline std::string* AddReply::mutable_errors(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.AddReply.errors) return _internal_mutable_errors()->Mutable(index); } inline void AddReply::set_errors(int index, const std::string& value) { _internal_mutable_errors()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:txpool.AddReply.errors) } inline void AddReply::set_errors(int index, std::string&& value) { _internal_mutable_errors()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:txpool.AddReply.errors) } inline void AddReply::set_errors(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_errors()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:txpool.AddReply.errors) } inline void AddReply::set_errors(int index, const char* value, std::size_t size) { _internal_mutable_errors()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:txpool.AddReply.errors) } inline void AddReply::set_errors(int index, absl::string_view value) { _internal_mutable_errors()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:txpool.AddReply.errors) } inline void AddReply::add_errors(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_errors()->Add()->assign(value); // @@protoc_insertion_point(field_add:txpool.AddReply.errors) } inline void AddReply::add_errors(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_errors()->Add(std::move(value)); // @@protoc_insertion_point(field_add:txpool.AddReply.errors) } inline void AddReply::add_errors(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_errors()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:txpool.AddReply.errors) } inline void AddReply::add_errors(const char* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_errors()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:txpool.AddReply.errors) } inline void AddReply::add_errors(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_errors()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:txpool.AddReply.errors) } inline const ::google::protobuf::RepeatedPtrField& AddReply::errors() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.AddReply.errors) return _internal_errors(); } inline ::google::protobuf::RepeatedPtrField* AddReply::mutable_errors() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.AddReply.errors) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_errors(); } inline const ::google::protobuf::RepeatedPtrField& AddReply::_internal_errors() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.errors_; } inline ::google::protobuf::RepeatedPtrField* AddReply::_internal_mutable_errors() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.errors_; } // ------------------------------------------------------------------- // TransactionsRequest // repeated .types.H256 hashes = 1; inline int TransactionsRequest::_internal_hashes_size() const { return _internal_hashes().size(); } inline int TransactionsRequest::hashes_size() const { return _internal_hashes_size(); } inline ::types::H256* TransactionsRequest::mutable_hashes(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.TransactionsRequest.hashes) return _internal_mutable_hashes()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::H256>* TransactionsRequest::mutable_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.TransactionsRequest.hashes) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_hashes(); } inline const ::types::H256& TransactionsRequest::hashes(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.TransactionsRequest.hashes) return _internal_hashes().Get(index); } inline ::types::H256* TransactionsRequest::add_hashes() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::H256* _add = _internal_mutable_hashes()->Add(); // @@protoc_insertion_point(field_add:txpool.TransactionsRequest.hashes) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& TransactionsRequest::hashes() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.TransactionsRequest.hashes) return _internal_hashes(); } inline const ::google::protobuf::RepeatedPtrField<::types::H256>& TransactionsRequest::_internal_hashes() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.hashes_; } inline ::google::protobuf::RepeatedPtrField<::types::H256>* TransactionsRequest::_internal_mutable_hashes() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.hashes_; } // ------------------------------------------------------------------- // TransactionsReply // repeated bytes rlp_txs = 1; inline int TransactionsReply::_internal_rlp_txs_size() const { return _internal_rlp_txs().size(); } inline int TransactionsReply::rlp_txs_size() const { return _internal_rlp_txs_size(); } inline void TransactionsReply::clear_rlp_txs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_txs_.Clear(); } inline std::string* TransactionsReply::add_rlp_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_rlp_txs()->Add(); // @@protoc_insertion_point(field_add_mutable:txpool.TransactionsReply.rlp_txs) return _s; } inline const std::string& TransactionsReply::rlp_txs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.TransactionsReply.rlp_txs) return _internal_rlp_txs().Get(index); } inline std::string* TransactionsReply::mutable_rlp_txs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.TransactionsReply.rlp_txs) return _internal_mutable_rlp_txs()->Mutable(index); } inline void TransactionsReply::set_rlp_txs(int index, const std::string& value) { _internal_mutable_rlp_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::set_rlp_txs(int index, std::string&& value) { _internal_mutable_rlp_txs()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::set_rlp_txs(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_rlp_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::set_rlp_txs(int index, const void* value, std::size_t size) { _internal_mutable_rlp_txs()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::set_rlp_txs(int index, absl::string_view value) { _internal_mutable_rlp_txs()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::add_rlp_txs(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::add_rlp_txs(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add(std::move(value)); // @@protoc_insertion_point(field_add:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::add_rlp_txs(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::add_rlp_txs(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:txpool.TransactionsReply.rlp_txs) } inline void TransactionsReply::add_rlp_txs(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rlp_txs()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:txpool.TransactionsReply.rlp_txs) } inline const ::google::protobuf::RepeatedPtrField& TransactionsReply::rlp_txs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.TransactionsReply.rlp_txs) return _internal_rlp_txs(); } inline ::google::protobuf::RepeatedPtrField* TransactionsReply::mutable_rlp_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.TransactionsReply.rlp_txs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_rlp_txs(); } inline const ::google::protobuf::RepeatedPtrField& TransactionsReply::_internal_rlp_txs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rlp_txs_; } inline ::google::protobuf::RepeatedPtrField* TransactionsReply::_internal_mutable_rlp_txs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.rlp_txs_; } // ------------------------------------------------------------------- // OnAddRequest // ------------------------------------------------------------------- // OnAddReply // repeated bytes rpl_txs = 1; inline int OnAddReply::_internal_rpl_txs_size() const { return _internal_rpl_txs().size(); } inline int OnAddReply::rpl_txs_size() const { return _internal_rpl_txs_size(); } inline void OnAddReply::clear_rpl_txs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rpl_txs_.Clear(); } inline std::string* OnAddReply::add_rpl_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_rpl_txs()->Add(); // @@protoc_insertion_point(field_add_mutable:txpool.OnAddReply.rpl_txs) return _s; } inline const std::string& OnAddReply::rpl_txs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.OnAddReply.rpl_txs) return _internal_rpl_txs().Get(index); } inline std::string* OnAddReply::mutable_rpl_txs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.OnAddReply.rpl_txs) return _internal_mutable_rpl_txs()->Mutable(index); } inline void OnAddReply::set_rpl_txs(int index, const std::string& value) { _internal_mutable_rpl_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::set_rpl_txs(int index, std::string&& value) { _internal_mutable_rpl_txs()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::set_rpl_txs(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_rpl_txs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::set_rpl_txs(int index, const void* value, std::size_t size) { _internal_mutable_rpl_txs()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::set_rpl_txs(int index, absl::string_view value) { _internal_mutable_rpl_txs()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::add_rpl_txs(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rpl_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::add_rpl_txs(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rpl_txs()->Add(std::move(value)); // @@protoc_insertion_point(field_add:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::add_rpl_txs(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rpl_txs()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::add_rpl_txs(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rpl_txs()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:txpool.OnAddReply.rpl_txs) } inline void OnAddReply::add_rpl_txs(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_rpl_txs()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:txpool.OnAddReply.rpl_txs) } inline const ::google::protobuf::RepeatedPtrField& OnAddReply::rpl_txs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.OnAddReply.rpl_txs) return _internal_rpl_txs(); } inline ::google::protobuf::RepeatedPtrField* OnAddReply::mutable_rpl_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.OnAddReply.rpl_txs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_rpl_txs(); } inline const ::google::protobuf::RepeatedPtrField& OnAddReply::_internal_rpl_txs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rpl_txs_; } inline ::google::protobuf::RepeatedPtrField* OnAddReply::_internal_mutable_rpl_txs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.rpl_txs_; } // ------------------------------------------------------------------- // AllRequest // ------------------------------------------------------------------- // AllReply_Tx // .txpool.AllReply.TxnType txn_type = 1; inline void AllReply_Tx::clear_txn_type() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.txn_type_ = 0; } inline ::txpool::AllReply_TxnType AllReply_Tx::txn_type() const { // @@protoc_insertion_point(field_get:txpool.AllReply.Tx.txn_type) return _internal_txn_type(); } inline void AllReply_Tx::set_txn_type(::txpool::AllReply_TxnType value) { _internal_set_txn_type(value); // @@protoc_insertion_point(field_set:txpool.AllReply.Tx.txn_type) } inline ::txpool::AllReply_TxnType AllReply_Tx::_internal_txn_type() const { ::google::protobuf::internal::TSanRead(&_impl_); return static_cast<::txpool::AllReply_TxnType>(_impl_.txn_type_); } inline void AllReply_Tx::_internal_set_txn_type(::txpool::AllReply_TxnType value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.txn_type_ = value; } // .types.H160 sender = 2; inline bool AllReply_Tx::has_sender() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.sender_ != nullptr); return value; } inline const ::types::H160& AllReply_Tx::_internal_sender() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.sender_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& AllReply_Tx::sender() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.AllReply.Tx.sender) return _internal_sender(); } inline void AllReply_Tx::unsafe_arena_set_allocated_sender(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sender_); } _impl_.sender_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:txpool.AllReply.Tx.sender) } inline ::types::H160* AllReply_Tx::release_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.sender_; _impl_.sender_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* AllReply_Tx::unsafe_arena_release_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.AllReply.Tx.sender) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.sender_; _impl_.sender_ = nullptr; return temp; } inline ::types::H160* AllReply_Tx::_internal_mutable_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sender_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.sender_ = reinterpret_cast<::types::H160*>(p); } return _impl_.sender_; } inline ::types::H160* AllReply_Tx::mutable_sender() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_sender(); // @@protoc_insertion_point(field_mutable:txpool.AllReply.Tx.sender) return _msg; } inline void AllReply_Tx::set_allocated_sender(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sender_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.sender_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:txpool.AllReply.Tx.sender) } // bytes rlp_tx = 3; inline void AllReply_Tx::clear_rlp_tx() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.ClearToEmpty(); } inline const std::string& AllReply_Tx::rlp_tx() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.AllReply.Tx.rlp_tx) return _internal_rlp_tx(); } template inline PROTOBUF_ALWAYS_INLINE void AllReply_Tx::set_rlp_tx(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.AllReply.Tx.rlp_tx) } inline std::string* AllReply_Tx::mutable_rlp_tx() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_rlp_tx(); // @@protoc_insertion_point(field_mutable:txpool.AllReply.Tx.rlp_tx) return _s; } inline const std::string& AllReply_Tx::_internal_rlp_tx() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rlp_tx_.Get(); } inline void AllReply_Tx::_internal_set_rlp_tx(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.Set(value, GetArena()); } inline std::string* AllReply_Tx::_internal_mutable_rlp_tx() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.rlp_tx_.Mutable( GetArena()); } inline std::string* AllReply_Tx::release_rlp_tx() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.AllReply.Tx.rlp_tx) return _impl_.rlp_tx_.Release(); } inline void AllReply_Tx::set_allocated_rlp_tx(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.rlp_tx_.IsDefault()) { _impl_.rlp_tx_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.AllReply.Tx.rlp_tx) } // ------------------------------------------------------------------- // AllReply // repeated .txpool.AllReply.Tx txs = 1; inline int AllReply::_internal_txs_size() const { return _internal_txs().size(); } inline int AllReply::txs_size() const { return _internal_txs_size(); } inline void AllReply::clear_txs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.txs_.Clear(); } inline ::txpool::AllReply_Tx* AllReply::mutable_txs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.AllReply.txs) return _internal_mutable_txs()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>* AllReply::mutable_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.AllReply.txs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_txs(); } inline const ::txpool::AllReply_Tx& AllReply::txs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.AllReply.txs) return _internal_txs().Get(index); } inline ::txpool::AllReply_Tx* AllReply::add_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::txpool::AllReply_Tx* _add = _internal_mutable_txs()->Add(); // @@protoc_insertion_point(field_add:txpool.AllReply.txs) return _add; } inline const ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>& AllReply::txs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.AllReply.txs) return _internal_txs(); } inline const ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>& AllReply::_internal_txs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.txs_; } inline ::google::protobuf::RepeatedPtrField<::txpool::AllReply_Tx>* AllReply::_internal_mutable_txs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.txs_; } // ------------------------------------------------------------------- // PendingReply_Tx // .types.H160 sender = 1; inline bool PendingReply_Tx::has_sender() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.sender_ != nullptr); return value; } inline const ::types::H160& PendingReply_Tx::_internal_sender() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.sender_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& PendingReply_Tx::sender() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.PendingReply.Tx.sender) return _internal_sender(); } inline void PendingReply_Tx::unsafe_arena_set_allocated_sender(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sender_); } _impl_.sender_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:txpool.PendingReply.Tx.sender) } inline ::types::H160* PendingReply_Tx::release_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.sender_; _impl_.sender_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* PendingReply_Tx::unsafe_arena_release_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.PendingReply.Tx.sender) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.sender_; _impl_.sender_ = nullptr; return temp; } inline ::types::H160* PendingReply_Tx::_internal_mutable_sender() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.sender_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.sender_ = reinterpret_cast<::types::H160*>(p); } return _impl_.sender_; } inline ::types::H160* PendingReply_Tx::mutable_sender() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_sender(); // @@protoc_insertion_point(field_mutable:txpool.PendingReply.Tx.sender) return _msg; } inline void PendingReply_Tx::set_allocated_sender(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sender_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.sender_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:txpool.PendingReply.Tx.sender) } // bytes rlp_tx = 2; inline void PendingReply_Tx::clear_rlp_tx() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.ClearToEmpty(); } inline const std::string& PendingReply_Tx::rlp_tx() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.PendingReply.Tx.rlp_tx) return _internal_rlp_tx(); } template inline PROTOBUF_ALWAYS_INLINE void PendingReply_Tx::set_rlp_tx(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:txpool.PendingReply.Tx.rlp_tx) } inline std::string* PendingReply_Tx::mutable_rlp_tx() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_rlp_tx(); // @@protoc_insertion_point(field_mutable:txpool.PendingReply.Tx.rlp_tx) return _s; } inline const std::string& PendingReply_Tx::_internal_rlp_tx() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.rlp_tx_.Get(); } inline void PendingReply_Tx::_internal_set_rlp_tx(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.Set(value, GetArena()); } inline std::string* PendingReply_Tx::_internal_mutable_rlp_tx() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.rlp_tx_.Mutable( GetArena()); } inline std::string* PendingReply_Tx::release_rlp_tx() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.PendingReply.Tx.rlp_tx) return _impl_.rlp_tx_.Release(); } inline void PendingReply_Tx::set_allocated_rlp_tx(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.rlp_tx_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.rlp_tx_.IsDefault()) { _impl_.rlp_tx_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:txpool.PendingReply.Tx.rlp_tx) } // bool is_local = 3; inline void PendingReply_Tx::clear_is_local() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.is_local_ = false; } inline bool PendingReply_Tx::is_local() const { // @@protoc_insertion_point(field_get:txpool.PendingReply.Tx.is_local) return _internal_is_local(); } inline void PendingReply_Tx::set_is_local(bool value) { _internal_set_is_local(value); // @@protoc_insertion_point(field_set:txpool.PendingReply.Tx.is_local) } inline bool PendingReply_Tx::_internal_is_local() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.is_local_; } inline void PendingReply_Tx::_internal_set_is_local(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.is_local_ = value; } // ------------------------------------------------------------------- // PendingReply // repeated .txpool.PendingReply.Tx txs = 1; inline int PendingReply::_internal_txs_size() const { return _internal_txs().size(); } inline int PendingReply::txs_size() const { return _internal_txs_size(); } inline void PendingReply::clear_txs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.txs_.Clear(); } inline ::txpool::PendingReply_Tx* PendingReply::mutable_txs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:txpool.PendingReply.txs) return _internal_mutable_txs()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>* PendingReply::mutable_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:txpool.PendingReply.txs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_txs(); } inline const ::txpool::PendingReply_Tx& PendingReply::txs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.PendingReply.txs) return _internal_txs().Get(index); } inline ::txpool::PendingReply_Tx* PendingReply::add_txs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::txpool::PendingReply_Tx* _add = _internal_mutable_txs()->Add(); // @@protoc_insertion_point(field_add:txpool.PendingReply.txs) return _add; } inline const ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>& PendingReply::txs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:txpool.PendingReply.txs) return _internal_txs(); } inline const ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>& PendingReply::_internal_txs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.txs_; } inline ::google::protobuf::RepeatedPtrField<::txpool::PendingReply_Tx>* PendingReply::_internal_mutable_txs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.txs_; } // ------------------------------------------------------------------- // StatusRequest // ------------------------------------------------------------------- // StatusReply // uint32 pending_count = 1; inline void StatusReply::clear_pending_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pending_count_ = 0u; } inline ::uint32_t StatusReply::pending_count() const { // @@protoc_insertion_point(field_get:txpool.StatusReply.pending_count) return _internal_pending_count(); } inline void StatusReply::set_pending_count(::uint32_t value) { _internal_set_pending_count(value); // @@protoc_insertion_point(field_set:txpool.StatusReply.pending_count) } inline ::uint32_t StatusReply::_internal_pending_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.pending_count_; } inline void StatusReply::_internal_set_pending_count(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pending_count_ = value; } // uint32 queued_count = 2; inline void StatusReply::clear_queued_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.queued_count_ = 0u; } inline ::uint32_t StatusReply::queued_count() const { // @@protoc_insertion_point(field_get:txpool.StatusReply.queued_count) return _internal_queued_count(); } inline void StatusReply::set_queued_count(::uint32_t value) { _internal_set_queued_count(value); // @@protoc_insertion_point(field_set:txpool.StatusReply.queued_count) } inline ::uint32_t StatusReply::_internal_queued_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.queued_count_; } inline void StatusReply::_internal_set_queued_count(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.queued_count_ = value; } // uint32 base_fee_count = 3; inline void StatusReply::clear_base_fee_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.base_fee_count_ = 0u; } inline ::uint32_t StatusReply::base_fee_count() const { // @@protoc_insertion_point(field_get:txpool.StatusReply.base_fee_count) return _internal_base_fee_count(); } inline void StatusReply::set_base_fee_count(::uint32_t value) { _internal_set_base_fee_count(value); // @@protoc_insertion_point(field_set:txpool.StatusReply.base_fee_count) } inline ::uint32_t StatusReply::_internal_base_fee_count() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.base_fee_count_; } inline void StatusReply::_internal_set_base_fee_count(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.base_fee_count_ = value; } // ------------------------------------------------------------------- // NonceRequest // .types.H160 address = 1; inline bool NonceRequest::has_address() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); return value; } inline const ::types::H160& NonceRequest::_internal_address() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.address_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& NonceRequest::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:txpool.NonceRequest.address) return _internal_address(); } inline void NonceRequest::unsafe_arena_set_allocated_address(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } _impl_.address_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:txpool.NonceRequest.address) } inline ::types::H160* NonceRequest::release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.address_; _impl_.address_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* NonceRequest::unsafe_arena_release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:txpool.NonceRequest.address) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.address_; _impl_.address_ = nullptr; return temp; } inline ::types::H160* NonceRequest::_internal_mutable_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.address_ = reinterpret_cast<::types::H160*>(p); } return _impl_.address_; } inline ::types::H160* NonceRequest::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_address(); // @@protoc_insertion_point(field_mutable:txpool.NonceRequest.address) return _msg; } inline void NonceRequest::set_allocated_address(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.address_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:txpool.NonceRequest.address) } // ------------------------------------------------------------------- // NonceReply // bool found = 1; inline void NonceReply::clear_found() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.found_ = false; } inline bool NonceReply::found() const { // @@protoc_insertion_point(field_get:txpool.NonceReply.found) return _internal_found(); } inline void NonceReply::set_found(bool value) { _internal_set_found(value); // @@protoc_insertion_point(field_set:txpool.NonceReply.found) } inline bool NonceReply::_internal_found() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.found_; } inline void NonceReply::_internal_set_found(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.found_ = value; } // uint64 nonce = 2; inline void NonceReply::clear_nonce() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nonce_ = ::uint64_t{0u}; } inline ::uint64_t NonceReply::nonce() const { // @@protoc_insertion_point(field_get:txpool.NonceReply.nonce) return _internal_nonce(); } inline void NonceReply::set_nonce(::uint64_t value) { _internal_set_nonce(value); // @@protoc_insertion_point(field_set:txpool.NonceReply.nonce) } inline ::uint64_t NonceReply::_internal_nonce() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.nonce_; } inline void NonceReply::_internal_set_nonce(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nonce_ = value; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace txpool namespace google { namespace protobuf { template <> struct is_proto_enum<::txpool::AllReply_TxnType> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::txpool::AllReply_TxnType>() { return ::txpool::AllReply_TxnType_descriptor(); } template <> struct is_proto_enum<::txpool::ImportResult> : std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor<::txpool::ImportResult>() { return ::txpool::ImportResult_descriptor(); } } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_txpool_2ftxpool_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/27.0/txpool/txpool_mock.grpc.pb.h ================================================ // Generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: txpool/txpool.proto #ifndef GRPC_MOCK_txpool_2ftxpool_2eproto__INCLUDED #define GRPC_MOCK_txpool_2ftxpool_2eproto__INCLUDED #include "txpool/txpool.pb.h" #include "txpool/txpool.grpc.pb.h" #include #include #include namespace txpool { class MockTxpoolStub : public Txpool::StubInterface { public: MOCK_METHOD3(Version, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::types::VersionReply* response)); MOCK_METHOD3(AsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncVersionRaw, ::grpc::ClientAsyncResponseReaderInterface< ::types::VersionReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(FindUnknown, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::txpool::TxHashes* response)); MOCK_METHOD3(AsyncFindUnknownRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>*(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncFindUnknownRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TxHashes>*(::grpc::ClientContext* context, const ::txpool::TxHashes& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Add, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::txpool::AddReply* response)); MOCK_METHOD3(AsyncAddRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>*(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncAddRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AddReply>*(::grpc::ClientContext* context, const ::txpool::AddRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Transactions, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::txpool::TransactionsReply* response)); MOCK_METHOD3(AsyncTransactionsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>*(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncTransactionsRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::TransactionsReply>*(::grpc::ClientContext* context, const ::txpool::TransactionsRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(All, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::txpool::AllReply* response)); MOCK_METHOD3(AsyncAllRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>*(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncAllRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::AllReply>*(::grpc::ClientContext* context, const ::txpool::AllRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Pending, ::grpc::Status(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::txpool::PendingReply* response)); MOCK_METHOD3(AsyncPendingRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncPendingRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::PendingReply>*(::grpc::ClientContext* context, const ::google::protobuf::Empty& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD2(OnAddRaw, ::grpc::ClientReaderInterface< ::txpool::OnAddReply>*(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request)); MOCK_METHOD4(AsyncOnAddRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>*(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq, void* tag)); MOCK_METHOD3(PrepareAsyncOnAddRaw, ::grpc::ClientAsyncReaderInterface< ::txpool::OnAddReply>*(::grpc::ClientContext* context, const ::txpool::OnAddRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Status, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::txpool::StatusReply* response)); MOCK_METHOD3(AsyncStatusRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>*(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncStatusRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::StatusReply>*(::grpc::ClientContext* context, const ::txpool::StatusRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(Nonce, ::grpc::Status(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::txpool::NonceReply* response)); MOCK_METHOD3(AsyncNonceRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>*(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq)); MOCK_METHOD3(PrepareAsyncNonceRaw, ::grpc::ClientAsyncResponseReaderInterface< ::txpool::NonceReply>*(::grpc::ClientContext* context, const ::txpool::NonceRequest& request, ::grpc::CompletionQueue* cq)); }; } // namespace txpool #endif // GRPC_MOCK_txpool_2ftxpool_2eproto__INCLUDED ================================================ FILE: silkworm/interfaces/27.0/types/types.pb.cc ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: types/types.proto // Protobuf C++ Version: 5.27.0 #include "types/types.pb.h" #include #include #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/generated_message_tctable_impl.h" #include "google/protobuf/extension_set.h" #include "google/protobuf/wire_format_lite.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/reflection_ops.h" #include "google/protobuf/wire_format.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" PROTOBUF_PRAGMA_INIT_SEG namespace _pb = ::google::protobuf; namespace _pbi = ::google::protobuf::internal; namespace _fl = ::google::protobuf::internal::field_layout; namespace types { inline constexpr VersionReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : major_{0u}, minor_{0u}, patch_{0u}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR VersionReply::VersionReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct VersionReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR VersionReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~VersionReplyDefaultTypeInternal() {} union { VersionReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VersionReplyDefaultTypeInternal _VersionReply_default_instance_; inline constexpr RequestsBundle::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : requests_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR RequestsBundle::RequestsBundle(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct RequestsBundleDefaultTypeInternal { PROTOBUF_CONSTEXPR RequestsBundleDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~RequestsBundleDefaultTypeInternal() {} union { RequestsBundle _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RequestsBundleDefaultTypeInternal _RequestsBundle_default_instance_; inline constexpr PeerInfo::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : caps_{}, id_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), name_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), enode_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), enr_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), conn_local_addr_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), conn_remote_addr_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), conn_is_inbound_{false}, conn_is_trusted_{false}, conn_is_static_{false}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR PeerInfo::PeerInfo(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct PeerInfoDefaultTypeInternal { PROTOBUF_CONSTEXPR PeerInfoDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~PeerInfoDefaultTypeInternal() {} union { PeerInfo _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PeerInfoDefaultTypeInternal _PeerInfo_default_instance_; inline constexpr NodeInfoPorts::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : discovery_{0u}, listener_{0u}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR NodeInfoPorts::NodeInfoPorts(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NodeInfoPortsDefaultTypeInternal { PROTOBUF_CONSTEXPR NodeInfoPortsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NodeInfoPortsDefaultTypeInternal() {} union { NodeInfoPorts _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NodeInfoPortsDefaultTypeInternal _NodeInfoPorts_default_instance_; inline constexpr H128::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : hi_{::uint64_t{0u}}, lo_{::uint64_t{0u}}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR H128::H128(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct H128DefaultTypeInternal { PROTOBUF_CONSTEXPR H128DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~H128DefaultTypeInternal() {} union { H128 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 H128DefaultTypeInternal _H128_default_instance_; inline constexpr BlobsBundleV1::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : commitments_{}, blobs_{}, proofs_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR BlobsBundleV1::BlobsBundleV1(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct BlobsBundleV1DefaultTypeInternal { PROTOBUF_CONSTEXPR BlobsBundleV1DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~BlobsBundleV1DefaultTypeInternal() {} union { BlobsBundleV1 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlobsBundleV1DefaultTypeInternal _BlobsBundleV1_default_instance_; inline constexpr NodeInfoReply::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, id_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), name_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), enode_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), enr_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), listener_addr_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), protocols_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), ports_{nullptr} {} template PROTOBUF_CONSTEXPR NodeInfoReply::NodeInfoReply(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct NodeInfoReplyDefaultTypeInternal { PROTOBUF_CONSTEXPR NodeInfoReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~NodeInfoReplyDefaultTypeInternal() {} union { NodeInfoReply _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NodeInfoReplyDefaultTypeInternal _NodeInfoReply_default_instance_; inline constexpr H256::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hi_{nullptr}, lo_{nullptr} {} template PROTOBUF_CONSTEXPR H256::H256(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct H256DefaultTypeInternal { PROTOBUF_CONSTEXPR H256DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~H256DefaultTypeInternal() {} union { H256 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 H256DefaultTypeInternal _H256_default_instance_; inline constexpr H160::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hi_{nullptr}, lo_{0u} {} template PROTOBUF_CONSTEXPR H160::H160(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct H160DefaultTypeInternal { PROTOBUF_CONSTEXPR H160DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~H160DefaultTypeInternal() {} union { H160 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 H160DefaultTypeInternal _H160_default_instance_; inline constexpr Withdrawal::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, address_{nullptr}, index_{::uint64_t{0u}}, validator_index_{::uint64_t{0u}}, amount_{::uint64_t{0u}} {} template PROTOBUF_CONSTEXPR Withdrawal::Withdrawal(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct WithdrawalDefaultTypeInternal { PROTOBUF_CONSTEXPR WithdrawalDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~WithdrawalDefaultTypeInternal() {} union { Withdrawal _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WithdrawalDefaultTypeInternal _Withdrawal_default_instance_; inline constexpr H512::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hi_{nullptr}, lo_{nullptr} {} template PROTOBUF_CONSTEXPR H512::H512(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct H512DefaultTypeInternal { PROTOBUF_CONSTEXPR H512DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~H512DefaultTypeInternal() {} union { H512 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 H512DefaultTypeInternal _H512_default_instance_; inline constexpr H1024::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hi_{nullptr}, lo_{nullptr} {} template PROTOBUF_CONSTEXPR H1024::H1024(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct H1024DefaultTypeInternal { PROTOBUF_CONSTEXPR H1024DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~H1024DefaultTypeInternal() {} union { H1024 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 H1024DefaultTypeInternal _H1024_default_instance_; inline constexpr ExecutionPayloadBodyV1::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : transactions_{}, withdrawals_{}, _cached_size_{0} {} template PROTOBUF_CONSTEXPR ExecutionPayloadBodyV1::ExecutionPayloadBodyV1(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ExecutionPayloadBodyV1DefaultTypeInternal { PROTOBUF_CONSTEXPR ExecutionPayloadBodyV1DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExecutionPayloadBodyV1DefaultTypeInternal() {} union { ExecutionPayloadBodyV1 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExecutionPayloadBodyV1DefaultTypeInternal _ExecutionPayloadBodyV1_default_instance_; inline constexpr H2048::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, hi_{nullptr}, lo_{nullptr} {} template PROTOBUF_CONSTEXPR H2048::H2048(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct H2048DefaultTypeInternal { PROTOBUF_CONSTEXPR H2048DefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~H2048DefaultTypeInternal() {} union { H2048 _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 H2048DefaultTypeInternal _H2048_default_instance_; inline constexpr ExecutionPayload::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, transactions_{}, withdrawals_{}, extra_data_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), parent_hash_{nullptr}, coinbase_{nullptr}, state_root_{nullptr}, receipt_root_{nullptr}, logs_bloom_{nullptr}, prev_randao_{nullptr}, base_fee_per_gas_{nullptr}, block_hash_{nullptr}, block_number_{::uint64_t{0u}}, gas_limit_{::uint64_t{0u}}, gas_used_{::uint64_t{0u}}, timestamp_{::uint64_t{0u}}, blob_gas_used_{::uint64_t{0u}}, excess_blob_gas_{::uint64_t{0u}}, version_{0u} {} template PROTOBUF_CONSTEXPR ExecutionPayload::ExecutionPayload(::_pbi::ConstantInitialized) : _impl_(::_pbi::ConstantInitialized()) {} struct ExecutionPayloadDefaultTypeInternal { PROTOBUF_CONSTEXPR ExecutionPayloadDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} ~ExecutionPayloadDefaultTypeInternal() {} union { ExecutionPayload _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExecutionPayloadDefaultTypeInternal _ExecutionPayload_default_instance_; } // namespace types static constexpr const ::_pb::EnumDescriptor** file_level_enum_descriptors_types_2ftypes_2eproto = nullptr; static constexpr const ::_pb::ServiceDescriptor** file_level_service_descriptors_types_2ftypes_2eproto = nullptr; const ::uint32_t TableStruct_types_2ftypes_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::types::H128, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::H128, _impl_.hi_), PROTOBUF_FIELD_OFFSET(::types::H128, _impl_.lo_), PROTOBUF_FIELD_OFFSET(::types::H160, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::H160, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::H160, _impl_.hi_), PROTOBUF_FIELD_OFFSET(::types::H160, _impl_.lo_), 0, ~0u, PROTOBUF_FIELD_OFFSET(::types::H256, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::H256, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::H256, _impl_.hi_), PROTOBUF_FIELD_OFFSET(::types::H256, _impl_.lo_), 0, 1, PROTOBUF_FIELD_OFFSET(::types::H512, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::H512, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::H512, _impl_.hi_), PROTOBUF_FIELD_OFFSET(::types::H512, _impl_.lo_), 0, 1, PROTOBUF_FIELD_OFFSET(::types::H1024, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::H1024, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::H1024, _impl_.hi_), PROTOBUF_FIELD_OFFSET(::types::H1024, _impl_.lo_), 0, 1, PROTOBUF_FIELD_OFFSET(::types::H2048, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::H2048, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::H2048, _impl_.hi_), PROTOBUF_FIELD_OFFSET(::types::H2048, _impl_.lo_), 0, 1, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::types::VersionReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::VersionReply, _impl_.major_), PROTOBUF_FIELD_OFFSET(::types::VersionReply, _impl_.minor_), PROTOBUF_FIELD_OFFSET(::types::VersionReply, _impl_.patch_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.version_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.parent_hash_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.coinbase_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.state_root_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.receipt_root_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.logs_bloom_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.prev_randao_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.block_number_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.gas_limit_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.gas_used_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.timestamp_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.extra_data_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.base_fee_per_gas_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.block_hash_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.transactions_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.withdrawals_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.blob_gas_used_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayload, _impl_.excess_blob_gas_), ~0u, 0, 1, 2, 3, 4, 5, ~0u, ~0u, ~0u, ~0u, ~0u, 6, 7, ~0u, ~0u, 8, 9, PROTOBUF_FIELD_OFFSET(::types::Withdrawal, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::Withdrawal, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::Withdrawal, _impl_.index_), PROTOBUF_FIELD_OFFSET(::types::Withdrawal, _impl_.validator_index_), PROTOBUF_FIELD_OFFSET(::types::Withdrawal, _impl_.address_), PROTOBUF_FIELD_OFFSET(::types::Withdrawal, _impl_.amount_), ~0u, ~0u, 0, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::types::BlobsBundleV1, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::BlobsBundleV1, _impl_.commitments_), PROTOBUF_FIELD_OFFSET(::types::BlobsBundleV1, _impl_.blobs_), PROTOBUF_FIELD_OFFSET(::types::BlobsBundleV1, _impl_.proofs_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::types::RequestsBundle, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::RequestsBundle, _impl_.requests_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::types::NodeInfoPorts, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::NodeInfoPorts, _impl_.discovery_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoPorts, _impl_.listener_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_.id_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_.name_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_.enode_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_.enr_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_.ports_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_.listener_addr_), PROTOBUF_FIELD_OFFSET(::types::NodeInfoReply, _impl_.protocols_), ~0u, ~0u, ~0u, ~0u, 0, ~0u, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.id_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.name_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.enode_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.enr_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.caps_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.conn_local_addr_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.conn_remote_addr_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.conn_is_inbound_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.conn_is_trusted_), PROTOBUF_FIELD_OFFSET(::types::PeerInfo, _impl_.conn_is_static_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::types::ExecutionPayloadBodyV1, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ ~0u, // no _split_ ~0u, // no sizeof(Split) PROTOBUF_FIELD_OFFSET(::types::ExecutionPayloadBodyV1, _impl_.transactions_), PROTOBUF_FIELD_OFFSET(::types::ExecutionPayloadBodyV1, _impl_.withdrawals_), }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::types::H128)}, {10, 20, -1, sizeof(::types::H160)}, {22, 32, -1, sizeof(::types::H256)}, {34, 44, -1, sizeof(::types::H512)}, {46, 56, -1, sizeof(::types::H1024)}, {58, 68, -1, sizeof(::types::H2048)}, {70, -1, -1, sizeof(::types::VersionReply)}, {81, 107, -1, sizeof(::types::ExecutionPayload)}, {125, 137, -1, sizeof(::types::Withdrawal)}, {141, -1, -1, sizeof(::types::BlobsBundleV1)}, {152, -1, -1, sizeof(::types::RequestsBundle)}, {161, -1, -1, sizeof(::types::NodeInfoPorts)}, {171, 186, -1, sizeof(::types::NodeInfoReply)}, {193, -1, -1, sizeof(::types::PeerInfo)}, {211, -1, -1, sizeof(::types::ExecutionPayloadBodyV1)}, }; static const ::_pb::Message* const file_default_instances[] = { &::types::_H128_default_instance_._instance, &::types::_H160_default_instance_._instance, &::types::_H256_default_instance_._instance, &::types::_H512_default_instance_._instance, &::types::_H1024_default_instance_._instance, &::types::_H2048_default_instance_._instance, &::types::_VersionReply_default_instance_._instance, &::types::_ExecutionPayload_default_instance_._instance, &::types::_Withdrawal_default_instance_._instance, &::types::_BlobsBundleV1_default_instance_._instance, &::types::_RequestsBundle_default_instance_._instance, &::types::_NodeInfoPorts_default_instance_._instance, &::types::_NodeInfoReply_default_instance_._instance, &::types::_PeerInfo_default_instance_._instance, &::types::_ExecutionPayloadBodyV1_default_instance_._instance, }; const char descriptor_table_protodef_types_2ftypes_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\021types/types.proto\022\005types\032 google/proto" "buf/descriptor.proto\"\036\n\004H128\022\n\n\002hi\030\001 \001(\004" "\022\n\n\002lo\030\002 \001(\004\"+\n\004H160\022\027\n\002hi\030\001 \001(\0132\013.types" ".H128\022\n\n\002lo\030\002 \001(\r\"8\n\004H256\022\027\n\002hi\030\001 \001(\0132\013." "types.H128\022\027\n\002lo\030\002 \001(\0132\013.types.H128\"8\n\004H" "512\022\027\n\002hi\030\001 \001(\0132\013.types.H256\022\027\n\002lo\030\002 \001(\013" "2\013.types.H256\"9\n\005H1024\022\027\n\002hi\030\001 \001(\0132\013.typ" "es.H512\022\027\n\002lo\030\002 \001(\0132\013.types.H512\";\n\005H204" "8\022\030\n\002hi\030\001 \001(\0132\014.types.H1024\022\030\n\002lo\030\002 \001(\0132" "\014.types.H1024\";\n\014VersionReply\022\r\n\005major\030\001" " \001(\r\022\r\n\005minor\030\002 \001(\r\022\r\n\005patch\030\003 \001(\r\"\264\004\n\020E" "xecutionPayload\022\017\n\007version\030\001 \001(\r\022 \n\013pare" "nt_hash\030\002 \001(\0132\013.types.H256\022\035\n\010coinbase\030\003" " \001(\0132\013.types.H160\022\037\n\nstate_root\030\004 \001(\0132\013." "types.H256\022!\n\014receipt_root\030\005 \001(\0132\013.types" ".H256\022 \n\nlogs_bloom\030\006 \001(\0132\014.types.H2048\022" " \n\013prev_randao\030\007 \001(\0132\013.types.H256\022\024\n\014blo" "ck_number\030\010 \001(\004\022\021\n\tgas_limit\030\t \001(\004\022\020\n\010ga" "s_used\030\n \001(\004\022\021\n\ttimestamp\030\013 \001(\004\022\022\n\nextra" "_data\030\014 \001(\014\022%\n\020base_fee_per_gas\030\r \001(\0132\013." "types.H256\022\037\n\nblock_hash\030\016 \001(\0132\013.types.H" "256\022\024\n\014transactions\030\017 \003(\014\022&\n\013withdrawals" "\030\020 \003(\0132\021.types.Withdrawal\022\032\n\rblob_gas_us" "ed\030\021 \001(\004H\000\210\001\001\022\034\n\017excess_blob_gas\030\022 \001(\004H\001" "\210\001\001B\020\n\016_blob_gas_usedB\022\n\020_excess_blob_ga" "s\"b\n\nWithdrawal\022\r\n\005index\030\001 \001(\004\022\027\n\017valida" "tor_index\030\002 \001(\004\022\034\n\007address\030\003 \001(\0132\013.types" ".H160\022\016\n\006amount\030\004 \001(\004\"C\n\rBlobsBundleV1\022\023" "\n\013commitments\030\001 \003(\014\022\r\n\005blobs\030\002 \003(\014\022\016\n\006pr" "oofs\030\003 \003(\014\"\"\n\016RequestsBundle\022\020\n\010requests" "\030\001 \003(\014\"4\n\rNodeInfoPorts\022\021\n\tdiscovery\030\001 \001" "(\r\022\020\n\010listener\030\002 \001(\r\"\224\001\n\rNodeInfoReply\022\n" "\n\002id\030\001 \001(\t\022\014\n\004name\030\002 \001(\t\022\r\n\005enode\030\003 \001(\t\022" "\013\n\003enr\030\004 \001(\t\022#\n\005ports\030\005 \001(\0132\024.types.Node" "InfoPorts\022\025\n\rlistener_addr\030\006 \001(\t\022\021\n\tprot" "ocols\030\007 \001(\014\"\313\001\n\010PeerInfo\022\n\n\002id\030\001 \001(\t\022\014\n\004" "name\030\002 \001(\t\022\r\n\005enode\030\003 \001(\t\022\013\n\003enr\030\004 \001(\t\022\014" "\n\004caps\030\005 \003(\t\022\027\n\017conn_local_addr\030\006 \001(\t\022\030\n" "\020conn_remote_addr\030\007 \001(\t\022\027\n\017conn_is_inbou" "nd\030\010 \001(\010\022\027\n\017conn_is_trusted\030\t \001(\010\022\026\n\016con" "n_is_static\030\n \001(\010\"V\n\026ExecutionPayloadBod" "yV1\022\024\n\014transactions\030\001 \003(\014\022&\n\013withdrawals" "\030\002 \003(\0132\021.types.Withdrawal:=\n\025service_maj" "or_version\022\034.google.protobuf.FileOptions" "\030\321\206\003 \001(\r:=\n\025service_minor_version\022\034.goog" "le.protobuf.FileOptions\030\322\206\003 \001(\r:=\n\025servi" "ce_patch_version\022\034.google.protobuf.FileO" "ptions\030\323\206\003 \001(\rB\024Z\022./types;typesprotob\006pr" "oto3" }; static const ::_pbi::DescriptorTable* const descriptor_table_types_2ftypes_2eproto_deps[1] = { &::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto, }; static ::absl::once_flag descriptor_table_types_2ftypes_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_types_2ftypes_2eproto = { false, false, 1924, descriptor_table_protodef_types_2ftypes_2eproto, "types/types.proto", &descriptor_table_types_2ftypes_2eproto_once, descriptor_table_types_2ftypes_2eproto_deps, 1, 15, schemas, file_default_instances, TableStruct_types_2ftypes_2eproto::offsets, file_level_enum_descriptors_types_2ftypes_2eproto, file_level_service_descriptors_types_2ftypes_2eproto, }; namespace types { // =================================================================== class H128::_Internal { public: }; H128::H128(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.H128) } H128::H128( ::google::protobuf::Arena* arena, const H128& from) : H128(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE H128::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void H128::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, hi_), 0, offsetof(Impl_, lo_) - offsetof(Impl_, hi_) + sizeof(Impl_::lo_)); } H128::~H128() { // @@protoc_insertion_point(destructor:types.H128) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void H128::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* H128::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(H128, _impl_._cached_size_), false, }, &H128::MergeImpl, &H128::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> H128::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_H128_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::H128>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 lo = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(H128, _impl_.lo_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(H128, _impl_.lo_)}}, // uint64 hi = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(H128, _impl_.hi_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(H128, _impl_.hi_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 hi = 1; {PROTOBUF_FIELD_OFFSET(H128, _impl_.hi_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 lo = 2; {PROTOBUF_FIELD_OFFSET(H128, _impl_.lo_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void H128::Clear() { // @@protoc_insertion_point(message_clear_start:types.H128) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.hi_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.lo_) - reinterpret_cast(&_impl_.hi_)) + sizeof(_impl_.lo_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* H128::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.H128) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 hi = 1; if (this->_internal_hi() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_hi(), target); } // uint64 lo = 2; if (this->_internal_lo() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_lo(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.H128) return target; } ::size_t H128::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.H128) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint64 hi = 1; if (this->_internal_hi() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_hi()); } // uint64 lo = 2; if (this->_internal_lo() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_lo()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void H128::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:types.H128) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_hi() != 0) { _this->_impl_.hi_ = from._impl_.hi_; } if (from._internal_lo() != 0) { _this->_impl_.lo_ = from._impl_.lo_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void H128::CopyFrom(const H128& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.H128) if (&from == this) return; Clear(); MergeFrom(from); } void H128::InternalSwap(H128* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(H128, _impl_.lo_) + sizeof(H128::_impl_.lo_) - PROTOBUF_FIELD_OFFSET(H128, _impl_.hi_)>( reinterpret_cast(&_impl_.hi_), reinterpret_cast(&other->_impl_.hi_)); } ::google::protobuf::Metadata H128::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class H160::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(H160, _impl_._has_bits_); }; H160::H160(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.H160) } inline PROTOBUF_NDEBUG_INLINE H160::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::H160& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} H160::H160( ::google::protobuf::Arena* arena, const H160& from) : ::google::protobuf::Message(arena) { H160* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hi_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H128>( arena, *from._impl_.hi_) : nullptr; _impl_.lo_ = from._impl_.lo_; // @@protoc_insertion_point(copy_constructor:types.H160) } inline PROTOBUF_NDEBUG_INLINE H160::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void H160::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, hi_), 0, offsetof(Impl_, lo_) - offsetof(Impl_, hi_) + sizeof(Impl_::lo_)); } H160::~H160() { // @@protoc_insertion_point(destructor:types.H160) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void H160::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hi_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* H160::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(H160, _impl_._cached_size_), false, }, &H160::MergeImpl, &H160::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> H160::_table_ = { { PROTOBUF_FIELD_OFFSET(H160, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_H160_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::H160>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint32 lo = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(H160, _impl_.lo_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(H160, _impl_.lo_)}}, // .types.H128 hi = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(H160, _impl_.hi_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H128 hi = 1; {PROTOBUF_FIELD_OFFSET(H160, _impl_.hi_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint32 lo = 2; {PROTOBUF_FIELD_OFFSET(H160, _impl_.lo_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H128>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void H160::Clear() { // @@protoc_insertion_point(message_clear_start:types.H160) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hi_ != nullptr); _impl_.hi_->Clear(); } _impl_.lo_ = 0u; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* H160::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.H160) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H128 hi = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hi_, _impl_.hi_->GetCachedSize(), target, stream); } // uint32 lo = 2; if (this->_internal_lo() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 2, this->_internal_lo(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.H160) return target; } ::size_t H160::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.H160) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H128 hi = 1; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hi_); } // uint32 lo = 2; if (this->_internal_lo() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_lo()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void H160::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.H160) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hi_ != nullptr); if (_this->_impl_.hi_ == nullptr) { _this->_impl_.hi_ = ::google::protobuf::Message::CopyConstruct<::types::H128>(arena, *from._impl_.hi_); } else { _this->_impl_.hi_->MergeFrom(*from._impl_.hi_); } } if (from._internal_lo() != 0) { _this->_impl_.lo_ = from._impl_.lo_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void H160::CopyFrom(const H160& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.H160) if (&from == this) return; Clear(); MergeFrom(from); } void H160::InternalSwap(H160* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(H160, _impl_.lo_) + sizeof(H160::_impl_.lo_) - PROTOBUF_FIELD_OFFSET(H160, _impl_.hi_)>( reinterpret_cast(&_impl_.hi_), reinterpret_cast(&other->_impl_.hi_)); } ::google::protobuf::Metadata H160::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class H256::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(H256, _impl_._has_bits_); }; H256::H256(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.H256) } inline PROTOBUF_NDEBUG_INLINE H256::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::H256& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} H256::H256( ::google::protobuf::Arena* arena, const H256& from) : ::google::protobuf::Message(arena) { H256* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hi_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H128>( arena, *from._impl_.hi_) : nullptr; _impl_.lo_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H128>( arena, *from._impl_.lo_) : nullptr; // @@protoc_insertion_point(copy_constructor:types.H256) } inline PROTOBUF_NDEBUG_INLINE H256::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void H256::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, hi_), 0, offsetof(Impl_, lo_) - offsetof(Impl_, hi_) + sizeof(Impl_::lo_)); } H256::~H256() { // @@protoc_insertion_point(destructor:types.H256) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void H256::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hi_; delete _impl_.lo_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* H256::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(H256, _impl_._cached_size_), false, }, &H256::MergeImpl, &H256::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 2, 0, 2> H256::_table_ = { { PROTOBUF_FIELD_OFFSET(H256, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_H256_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::H256>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H128 lo = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(H256, _impl_.lo_)}}, // .types.H128 hi = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(H256, _impl_.hi_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H128 hi = 1; {PROTOBUF_FIELD_OFFSET(H256, _impl_.hi_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H128 lo = 2; {PROTOBUF_FIELD_OFFSET(H256, _impl_.lo_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H128>()}, {::_pbi::TcParser::GetTable<::types::H128>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void H256::Clear() { // @@protoc_insertion_point(message_clear_start:types.H256) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hi_ != nullptr); _impl_.hi_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.lo_ != nullptr); _impl_.lo_->Clear(); } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* H256::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.H256) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H128 hi = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hi_, _impl_.hi_->GetCachedSize(), target, stream); } // .types.H128 lo = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.lo_, _impl_.lo_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.H256) return target; } ::size_t H256::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.H256) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { // .types.H128 hi = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hi_); } // .types.H128 lo = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.lo_); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void H256::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.H256) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hi_ != nullptr); if (_this->_impl_.hi_ == nullptr) { _this->_impl_.hi_ = ::google::protobuf::Message::CopyConstruct<::types::H128>(arena, *from._impl_.hi_); } else { _this->_impl_.hi_->MergeFrom(*from._impl_.hi_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.lo_ != nullptr); if (_this->_impl_.lo_ == nullptr) { _this->_impl_.lo_ = ::google::protobuf::Message::CopyConstruct<::types::H128>(arena, *from._impl_.lo_); } else { _this->_impl_.lo_->MergeFrom(*from._impl_.lo_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void H256::CopyFrom(const H256& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.H256) if (&from == this) return; Clear(); MergeFrom(from); } void H256::InternalSwap(H256* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(H256, _impl_.lo_) + sizeof(H256::_impl_.lo_) - PROTOBUF_FIELD_OFFSET(H256, _impl_.hi_)>( reinterpret_cast(&_impl_.hi_), reinterpret_cast(&other->_impl_.hi_)); } ::google::protobuf::Metadata H256::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class H512::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(H512, _impl_._has_bits_); }; H512::H512(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.H512) } inline PROTOBUF_NDEBUG_INLINE H512::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::H512& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} H512::H512( ::google::protobuf::Arena* arena, const H512& from) : ::google::protobuf::Message(arena) { H512* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hi_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.hi_) : nullptr; _impl_.lo_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.lo_) : nullptr; // @@protoc_insertion_point(copy_constructor:types.H512) } inline PROTOBUF_NDEBUG_INLINE H512::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void H512::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, hi_), 0, offsetof(Impl_, lo_) - offsetof(Impl_, hi_) + sizeof(Impl_::lo_)); } H512::~H512() { // @@protoc_insertion_point(destructor:types.H512) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void H512::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hi_; delete _impl_.lo_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* H512::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(H512, _impl_._cached_size_), false, }, &H512::MergeImpl, &H512::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 2, 0, 2> H512::_table_ = { { PROTOBUF_FIELD_OFFSET(H512, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_H512_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::H512>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H256 lo = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(H512, _impl_.lo_)}}, // .types.H256 hi = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(H512, _impl_.hi_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H256 hi = 1; {PROTOBUF_FIELD_OFFSET(H512, _impl_.hi_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 lo = 2; {PROTOBUF_FIELD_OFFSET(H512, _impl_.lo_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void H512::Clear() { // @@protoc_insertion_point(message_clear_start:types.H512) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hi_ != nullptr); _impl_.hi_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.lo_ != nullptr); _impl_.lo_->Clear(); } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* H512::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.H512) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H256 hi = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hi_, _impl_.hi_->GetCachedSize(), target, stream); } // .types.H256 lo = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.lo_, _impl_.lo_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.H512) return target; } ::size_t H512::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.H512) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { // .types.H256 hi = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hi_); } // .types.H256 lo = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.lo_); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void H512::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.H512) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hi_ != nullptr); if (_this->_impl_.hi_ == nullptr) { _this->_impl_.hi_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.hi_); } else { _this->_impl_.hi_->MergeFrom(*from._impl_.hi_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.lo_ != nullptr); if (_this->_impl_.lo_ == nullptr) { _this->_impl_.lo_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.lo_); } else { _this->_impl_.lo_->MergeFrom(*from._impl_.lo_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void H512::CopyFrom(const H512& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.H512) if (&from == this) return; Clear(); MergeFrom(from); } void H512::InternalSwap(H512* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(H512, _impl_.lo_) + sizeof(H512::_impl_.lo_) - PROTOBUF_FIELD_OFFSET(H512, _impl_.hi_)>( reinterpret_cast(&_impl_.hi_), reinterpret_cast(&other->_impl_.hi_)); } ::google::protobuf::Metadata H512::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class H1024::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(H1024, _impl_._has_bits_); }; H1024::H1024(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.H1024) } inline PROTOBUF_NDEBUG_INLINE H1024::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::H1024& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} H1024::H1024( ::google::protobuf::Arena* arena, const H1024& from) : ::google::protobuf::Message(arena) { H1024* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hi_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.hi_) : nullptr; _impl_.lo_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H512>( arena, *from._impl_.lo_) : nullptr; // @@protoc_insertion_point(copy_constructor:types.H1024) } inline PROTOBUF_NDEBUG_INLINE H1024::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void H1024::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, hi_), 0, offsetof(Impl_, lo_) - offsetof(Impl_, hi_) + sizeof(Impl_::lo_)); } H1024::~H1024() { // @@protoc_insertion_point(destructor:types.H1024) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void H1024::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hi_; delete _impl_.lo_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* H1024::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(H1024, _impl_._cached_size_), false, }, &H1024::MergeImpl, &H1024::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 2, 0, 2> H1024::_table_ = { { PROTOBUF_FIELD_OFFSET(H1024, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_H1024_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::H1024>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H512 lo = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(H1024, _impl_.lo_)}}, // .types.H512 hi = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(H1024, _impl_.hi_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H512 hi = 1; {PROTOBUF_FIELD_OFFSET(H1024, _impl_.hi_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H512 lo = 2; {PROTOBUF_FIELD_OFFSET(H1024, _impl_.lo_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H512>()}, {::_pbi::TcParser::GetTable<::types::H512>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void H1024::Clear() { // @@protoc_insertion_point(message_clear_start:types.H1024) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hi_ != nullptr); _impl_.hi_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.lo_ != nullptr); _impl_.lo_->Clear(); } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* H1024::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.H1024) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H512 hi = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hi_, _impl_.hi_->GetCachedSize(), target, stream); } // .types.H512 lo = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.lo_, _impl_.lo_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.H1024) return target; } ::size_t H1024::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.H1024) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { // .types.H512 hi = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hi_); } // .types.H512 lo = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.lo_); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void H1024::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.H1024) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hi_ != nullptr); if (_this->_impl_.hi_ == nullptr) { _this->_impl_.hi_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.hi_); } else { _this->_impl_.hi_->MergeFrom(*from._impl_.hi_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.lo_ != nullptr); if (_this->_impl_.lo_ == nullptr) { _this->_impl_.lo_ = ::google::protobuf::Message::CopyConstruct<::types::H512>(arena, *from._impl_.lo_); } else { _this->_impl_.lo_->MergeFrom(*from._impl_.lo_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void H1024::CopyFrom(const H1024& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.H1024) if (&from == this) return; Clear(); MergeFrom(from); } void H1024::InternalSwap(H1024* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(H1024, _impl_.lo_) + sizeof(H1024::_impl_.lo_) - PROTOBUF_FIELD_OFFSET(H1024, _impl_.hi_)>( reinterpret_cast(&_impl_.hi_), reinterpret_cast(&other->_impl_.hi_)); } ::google::protobuf::Metadata H1024::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class H2048::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(H2048, _impl_._has_bits_); }; H2048::H2048(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.H2048) } inline PROTOBUF_NDEBUG_INLINE H2048::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::H2048& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} H2048::H2048( ::google::protobuf::Arena* arena, const H2048& from) : ::google::protobuf::Message(arena) { H2048* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.hi_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H1024>( arena, *from._impl_.hi_) : nullptr; _impl_.lo_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H1024>( arena, *from._impl_.lo_) : nullptr; // @@protoc_insertion_point(copy_constructor:types.H2048) } inline PROTOBUF_NDEBUG_INLINE H2048::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void H2048::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, hi_), 0, offsetof(Impl_, lo_) - offsetof(Impl_, hi_) + sizeof(Impl_::lo_)); } H2048::~H2048() { // @@protoc_insertion_point(destructor:types.H2048) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void H2048::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.hi_; delete _impl_.lo_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* H2048::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(H2048, _impl_._cached_size_), false, }, &H2048::MergeImpl, &H2048::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 2, 0, 2> H2048::_table_ = { { PROTOBUF_FIELD_OFFSET(H2048, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_H2048_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::H2048>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // .types.H1024 lo = 2; {::_pbi::TcParser::FastMtS1, {18, 1, 1, PROTOBUF_FIELD_OFFSET(H2048, _impl_.lo_)}}, // .types.H1024 hi = 1; {::_pbi::TcParser::FastMtS1, {10, 0, 0, PROTOBUF_FIELD_OFFSET(H2048, _impl_.hi_)}}, }}, {{ 65535, 65535 }}, {{ // .types.H1024 hi = 1; {PROTOBUF_FIELD_OFFSET(H2048, _impl_.hi_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H1024 lo = 2; {PROTOBUF_FIELD_OFFSET(H2048, _impl_.lo_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H1024>()}, {::_pbi::TcParser::GetTable<::types::H1024>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void H2048::Clear() { // @@protoc_insertion_point(message_clear_start:types.H2048) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.hi_ != nullptr); _impl_.hi_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.lo_ != nullptr); _impl_.lo_->Clear(); } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* H2048::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.H2048) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; // .types.H1024 hi = 1; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 1, *_impl_.hi_, _impl_.hi_->GetCachedSize(), target, stream); } // .types.H1024 lo = 2; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.lo_, _impl_.lo_->GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.H2048) return target; } ::size_t H2048::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.H2048) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { // .types.H1024 hi = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.hi_); } // .types.H1024 lo = 2; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.lo_); } } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void H2048::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.H2048) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000003u) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.hi_ != nullptr); if (_this->_impl_.hi_ == nullptr) { _this->_impl_.hi_ = ::google::protobuf::Message::CopyConstruct<::types::H1024>(arena, *from._impl_.hi_); } else { _this->_impl_.hi_->MergeFrom(*from._impl_.hi_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.lo_ != nullptr); if (_this->_impl_.lo_ == nullptr) { _this->_impl_.lo_ = ::google::protobuf::Message::CopyConstruct<::types::H1024>(arena, *from._impl_.lo_); } else { _this->_impl_.lo_->MergeFrom(*from._impl_.lo_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void H2048::CopyFrom(const H2048& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.H2048) if (&from == this) return; Clear(); MergeFrom(from); } void H2048::InternalSwap(H2048* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(H2048, _impl_.lo_) + sizeof(H2048::_impl_.lo_) - PROTOBUF_FIELD_OFFSET(H2048, _impl_.hi_)>( reinterpret_cast(&_impl_.hi_), reinterpret_cast(&other->_impl_.hi_)); } ::google::protobuf::Metadata H2048::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class VersionReply::_Internal { public: }; VersionReply::VersionReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.VersionReply) } VersionReply::VersionReply( ::google::protobuf::Arena* arena, const VersionReply& from) : VersionReply(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE VersionReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void VersionReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, major_), 0, offsetof(Impl_, patch_) - offsetof(Impl_, major_) + sizeof(Impl_::patch_)); } VersionReply::~VersionReply() { // @@protoc_insertion_point(destructor:types.VersionReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void VersionReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* VersionReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(VersionReply, _impl_._cached_size_), false, }, &VersionReply::MergeImpl, &VersionReply::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 0, 0, 2> VersionReply::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_VersionReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::VersionReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint32 major = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(VersionReply, _impl_.major_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.major_)}}, // uint32 minor = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(VersionReply, _impl_.minor_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.minor_)}}, // uint32 patch = 3; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(VersionReply, _impl_.patch_), 63>(), {24, 63, 0, PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.patch_)}}, }}, {{ 65535, 65535 }}, {{ // uint32 major = 1; {PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.major_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // uint32 minor = 2; {PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.minor_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // uint32 patch = 3; {PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.patch_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void VersionReply::Clear() { // @@protoc_insertion_point(message_clear_start:types.VersionReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.major_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.patch_) - reinterpret_cast(&_impl_.major_)) + sizeof(_impl_.patch_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* VersionReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.VersionReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint32 major = 1; if (this->_internal_major() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 1, this->_internal_major(), target); } // uint32 minor = 2; if (this->_internal_minor() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 2, this->_internal_minor(), target); } // uint32 patch = 3; if (this->_internal_patch() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 3, this->_internal_patch(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.VersionReply) return target; } ::size_t VersionReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.VersionReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint32 major = 1; if (this->_internal_major() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_major()); } // uint32 minor = 2; if (this->_internal_minor() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_minor()); } // uint32 patch = 3; if (this->_internal_patch() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_patch()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void VersionReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:types.VersionReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_major() != 0) { _this->_impl_.major_ = from._impl_.major_; } if (from._internal_minor() != 0) { _this->_impl_.minor_ = from._impl_.minor_; } if (from._internal_patch() != 0) { _this->_impl_.patch_ = from._impl_.patch_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void VersionReply::CopyFrom(const VersionReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.VersionReply) if (&from == this) return; Clear(); MergeFrom(from); } void VersionReply::InternalSwap(VersionReply* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.patch_) + sizeof(VersionReply::_impl_.patch_) - PROTOBUF_FIELD_OFFSET(VersionReply, _impl_.major_)>( reinterpret_cast(&_impl_.major_), reinterpret_cast(&other->_impl_.major_)); } ::google::protobuf::Metadata VersionReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExecutionPayload::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_._has_bits_); }; ExecutionPayload::ExecutionPayload(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.ExecutionPayload) } inline PROTOBUF_NDEBUG_INLINE ExecutionPayload::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::ExecutionPayload& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, transactions_{visibility, arena, from.transactions_}, withdrawals_{visibility, arena, from.withdrawals_}, extra_data_(arena, from.extra_data_) {} ExecutionPayload::ExecutionPayload( ::google::protobuf::Arena* arena, const ExecutionPayload& from) : ::google::protobuf::Message(arena) { ExecutionPayload* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.parent_hash_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.parent_hash_) : nullptr; _impl_.coinbase_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.coinbase_) : nullptr; _impl_.state_root_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.state_root_) : nullptr; _impl_.receipt_root_ = (cached_has_bits & 0x00000008u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.receipt_root_) : nullptr; _impl_.logs_bloom_ = (cached_has_bits & 0x00000010u) ? ::google::protobuf::Message::CopyConstruct<::types::H2048>( arena, *from._impl_.logs_bloom_) : nullptr; _impl_.prev_randao_ = (cached_has_bits & 0x00000020u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.prev_randao_) : nullptr; _impl_.base_fee_per_gas_ = (cached_has_bits & 0x00000040u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.base_fee_per_gas_) : nullptr; _impl_.block_hash_ = (cached_has_bits & 0x00000080u) ? ::google::protobuf::Message::CopyConstruct<::types::H256>( arena, *from._impl_.block_hash_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, block_number_), reinterpret_cast(&from._impl_) + offsetof(Impl_, block_number_), offsetof(Impl_, version_) - offsetof(Impl_, block_number_) + sizeof(Impl_::version_)); // @@protoc_insertion_point(copy_constructor:types.ExecutionPayload) } inline PROTOBUF_NDEBUG_INLINE ExecutionPayload::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, transactions_{visibility, arena}, withdrawals_{visibility, arena}, extra_data_(arena) {} inline void ExecutionPayload::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, parent_hash_), 0, offsetof(Impl_, version_) - offsetof(Impl_, parent_hash_) + sizeof(Impl_::version_)); } ExecutionPayload::~ExecutionPayload() { // @@protoc_insertion_point(destructor:types.ExecutionPayload) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ExecutionPayload::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.extra_data_.Destroy(); delete _impl_.parent_hash_; delete _impl_.coinbase_; delete _impl_.state_root_; delete _impl_.receipt_root_; delete _impl_.logs_bloom_; delete _impl_.prev_randao_; delete _impl_.base_fee_per_gas_; delete _impl_.block_hash_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ExecutionPayload::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_._cached_size_), false, }, &ExecutionPayload::MergeImpl, &ExecutionPayload::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<5, 18, 9, 0, 2> ExecutionPayload::_table_ = { { PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_._has_bits_), 0, // no _extensions_ 18, 248, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294705152, // skipmap offsetof(decltype(_table_), field_entries), 18, // num_field_entries 9, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_ExecutionPayload_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::ExecutionPayload>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // uint32 version = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(ExecutionPayload, _impl_.version_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.version_)}}, // .types.H256 parent_hash = 2; {::_pbi::TcParser::FastMtS1, {18, 0, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.parent_hash_)}}, // .types.H160 coinbase = 3; {::_pbi::TcParser::FastMtS1, {26, 1, 1, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.coinbase_)}}, // .types.H256 state_root = 4; {::_pbi::TcParser::FastMtS1, {34, 2, 2, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.state_root_)}}, // .types.H256 receipt_root = 5; {::_pbi::TcParser::FastMtS1, {42, 3, 3, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.receipt_root_)}}, // .types.H2048 logs_bloom = 6; {::_pbi::TcParser::FastMtS1, {50, 4, 4, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.logs_bloom_)}}, // .types.H256 prev_randao = 7; {::_pbi::TcParser::FastMtS1, {58, 5, 5, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.prev_randao_)}}, // uint64 block_number = 8; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ExecutionPayload, _impl_.block_number_), 63>(), {64, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.block_number_)}}, // uint64 gas_limit = 9; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ExecutionPayload, _impl_.gas_limit_), 63>(), {72, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.gas_limit_)}}, // uint64 gas_used = 10; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ExecutionPayload, _impl_.gas_used_), 63>(), {80, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.gas_used_)}}, // uint64 timestamp = 11; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ExecutionPayload, _impl_.timestamp_), 63>(), {88, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.timestamp_)}}, // bytes extra_data = 12; {::_pbi::TcParser::FastBS1, {98, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.extra_data_)}}, // .types.H256 base_fee_per_gas = 13; {::_pbi::TcParser::FastMtS1, {106, 6, 6, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.base_fee_per_gas_)}}, // .types.H256 block_hash = 14; {::_pbi::TcParser::FastMtS1, {114, 7, 7, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.block_hash_)}}, // repeated bytes transactions = 15; {::_pbi::TcParser::FastBR1, {122, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.transactions_)}}, // repeated .types.Withdrawal withdrawals = 16; {::_pbi::TcParser::FastMtR2, {386, 63, 8, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.withdrawals_)}}, // optional uint64 blob_gas_used = 17; {::_pbi::TcParser::FastV64S2, {392, 8, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.blob_gas_used_)}}, // optional uint64 excess_blob_gas = 18; {::_pbi::TcParser::FastV64S2, {400, 9, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.excess_blob_gas_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // uint32 version = 1; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.version_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // .types.H256 parent_hash = 2; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.parent_hash_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H160 coinbase = 3; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.coinbase_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 state_root = 4; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.state_root_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 receipt_root = 5; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.receipt_root_), _Internal::kHasBitsOffset + 3, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H2048 logs_bloom = 6; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.logs_bloom_), _Internal::kHasBitsOffset + 4, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 prev_randao = 7; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.prev_randao_), _Internal::kHasBitsOffset + 5, 5, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 block_number = 8; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.block_number_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 gas_limit = 9; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.gas_limit_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 gas_used = 10; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.gas_used_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 timestamp = 11; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.timestamp_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // bytes extra_data = 12; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.extra_data_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, // .types.H256 base_fee_per_gas = 13; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.base_fee_per_gas_), _Internal::kHasBitsOffset + 6, 6, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .types.H256 block_hash = 14; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.block_hash_), _Internal::kHasBitsOffset + 7, 7, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // repeated bytes transactions = 15; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.transactions_), -1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, // repeated .types.Withdrawal withdrawals = 16; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.withdrawals_), -1, 8, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, // optional uint64 blob_gas_used = 17; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.blob_gas_used_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // optional uint64 excess_blob_gas = 18; {PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.excess_blob_gas_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H160>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H2048>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::H256>()}, {::_pbi::TcParser::GetTable<::types::Withdrawal>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void ExecutionPayload::Clear() { // @@protoc_insertion_point(message_clear_start:types.ExecutionPayload) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.transactions_.Clear(); _impl_.withdrawals_.Clear(); _impl_.extra_data_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.parent_hash_ != nullptr); _impl_.parent_hash_->Clear(); } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(_impl_.coinbase_ != nullptr); _impl_.coinbase_->Clear(); } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(_impl_.state_root_ != nullptr); _impl_.state_root_->Clear(); } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(_impl_.receipt_root_ != nullptr); _impl_.receipt_root_->Clear(); } if (cached_has_bits & 0x00000010u) { ABSL_DCHECK(_impl_.logs_bloom_ != nullptr); _impl_.logs_bloom_->Clear(); } if (cached_has_bits & 0x00000020u) { ABSL_DCHECK(_impl_.prev_randao_ != nullptr); _impl_.prev_randao_->Clear(); } if (cached_has_bits & 0x00000040u) { ABSL_DCHECK(_impl_.base_fee_per_gas_ != nullptr); _impl_.base_fee_per_gas_->Clear(); } if (cached_has_bits & 0x00000080u) { ABSL_DCHECK(_impl_.block_hash_ != nullptr); _impl_.block_hash_->Clear(); } } ::memset(&_impl_.block_number_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.timestamp_) - reinterpret_cast(&_impl_.block_number_)) + sizeof(_impl_.timestamp_)); if (cached_has_bits & 0x00000300u) { ::memset(&_impl_.blob_gas_used_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.excess_blob_gas_) - reinterpret_cast(&_impl_.blob_gas_used_)) + sizeof(_impl_.excess_blob_gas_)); } _impl_.version_ = 0u; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ExecutionPayload::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.ExecutionPayload) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint32 version = 1; if (this->_internal_version() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 1, this->_internal_version(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H256 parent_hash = 2; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, *_impl_.parent_hash_, _impl_.parent_hash_->GetCachedSize(), target, stream); } // .types.H160 coinbase = 3; if (cached_has_bits & 0x00000002u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.coinbase_, _impl_.coinbase_->GetCachedSize(), target, stream); } // .types.H256 state_root = 4; if (cached_has_bits & 0x00000004u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 4, *_impl_.state_root_, _impl_.state_root_->GetCachedSize(), target, stream); } // .types.H256 receipt_root = 5; if (cached_has_bits & 0x00000008u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 5, *_impl_.receipt_root_, _impl_.receipt_root_->GetCachedSize(), target, stream); } // .types.H2048 logs_bloom = 6; if (cached_has_bits & 0x00000010u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 6, *_impl_.logs_bloom_, _impl_.logs_bloom_->GetCachedSize(), target, stream); } // .types.H256 prev_randao = 7; if (cached_has_bits & 0x00000020u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 7, *_impl_.prev_randao_, _impl_.prev_randao_->GetCachedSize(), target, stream); } // uint64 block_number = 8; if (this->_internal_block_number() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 8, this->_internal_block_number(), target); } // uint64 gas_limit = 9; if (this->_internal_gas_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 9, this->_internal_gas_limit(), target); } // uint64 gas_used = 10; if (this->_internal_gas_used() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 10, this->_internal_gas_used(), target); } // uint64 timestamp = 11; if (this->_internal_timestamp() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 11, this->_internal_timestamp(), target); } // bytes extra_data = 12; if (!this->_internal_extra_data().empty()) { const std::string& _s = this->_internal_extra_data(); target = stream->WriteBytesMaybeAliased(12, _s, target); } // .types.H256 base_fee_per_gas = 13; if (cached_has_bits & 0x00000040u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 13, *_impl_.base_fee_per_gas_, _impl_.base_fee_per_gas_->GetCachedSize(), target, stream); } // .types.H256 block_hash = 14; if (cached_has_bits & 0x00000080u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 14, *_impl_.block_hash_, _impl_.block_hash_->GetCachedSize(), target, stream); } // repeated bytes transactions = 15; for (int i = 0, n = this->_internal_transactions_size(); i < n; ++i) { const auto& s = this->_internal_transactions().Get(i); target = stream->WriteBytes(15, s, target); } // repeated .types.Withdrawal withdrawals = 16; for (unsigned i = 0, n = static_cast( this->_internal_withdrawals_size()); i < n; i++) { const auto& repfield = this->_internal_withdrawals().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 16, repfield, repfield.GetCachedSize(), target, stream); } // optional uint64 blob_gas_used = 17; if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 17, this->_internal_blob_gas_used(), target); } // optional uint64 excess_blob_gas = 18; if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 18, this->_internal_excess_blob_gas(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.ExecutionPayload) return target; } ::size_t ExecutionPayload::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.ExecutionPayload) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes transactions = 15; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_transactions().size()); for (int i = 0, n = _internal_transactions().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_transactions().Get(i)); } // repeated .types.Withdrawal withdrawals = 16; total_size += 2UL * this->_internal_withdrawals_size(); for (const auto& msg : this->_internal_withdrawals()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } // bytes extra_data = 12; if (!this->_internal_extra_data().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_extra_data()); } cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // .types.H256 parent_hash = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.parent_hash_); } // .types.H160 coinbase = 3; if (cached_has_bits & 0x00000002u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.coinbase_); } // .types.H256 state_root = 4; if (cached_has_bits & 0x00000004u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.state_root_); } // .types.H256 receipt_root = 5; if (cached_has_bits & 0x00000008u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.receipt_root_); } // .types.H2048 logs_bloom = 6; if (cached_has_bits & 0x00000010u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.logs_bloom_); } // .types.H256 prev_randao = 7; if (cached_has_bits & 0x00000020u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.prev_randao_); } // .types.H256 base_fee_per_gas = 13; if (cached_has_bits & 0x00000040u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.base_fee_per_gas_); } // .types.H256 block_hash = 14; if (cached_has_bits & 0x00000080u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.block_hash_); } } // uint64 block_number = 8; if (this->_internal_block_number() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_block_number()); } // uint64 gas_limit = 9; if (this->_internal_gas_limit() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_gas_limit()); } // uint64 gas_used = 10; if (this->_internal_gas_used() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_gas_used()); } // uint64 timestamp = 11; if (this->_internal_timestamp() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_timestamp()); } if (cached_has_bits & 0x00000300u) { // optional uint64 blob_gas_used = 17; if (cached_has_bits & 0x00000100u) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this->_internal_blob_gas_used()); } // optional uint64 excess_blob_gas = 18; if (cached_has_bits & 0x00000200u) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this->_internal_excess_blob_gas()); } } // uint32 version = 1; if (this->_internal_version() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_version()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ExecutionPayload::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.ExecutionPayload) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_transactions()->MergeFrom(from._internal_transactions()); _this->_internal_mutable_withdrawals()->MergeFrom( from._internal_withdrawals()); if (!from._internal_extra_data().empty()) { _this->_internal_set_extra_data(from._internal_extra_data()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.parent_hash_ != nullptr); if (_this->_impl_.parent_hash_ == nullptr) { _this->_impl_.parent_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.parent_hash_); } else { _this->_impl_.parent_hash_->MergeFrom(*from._impl_.parent_hash_); } } if (cached_has_bits & 0x00000002u) { ABSL_DCHECK(from._impl_.coinbase_ != nullptr); if (_this->_impl_.coinbase_ == nullptr) { _this->_impl_.coinbase_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.coinbase_); } else { _this->_impl_.coinbase_->MergeFrom(*from._impl_.coinbase_); } } if (cached_has_bits & 0x00000004u) { ABSL_DCHECK(from._impl_.state_root_ != nullptr); if (_this->_impl_.state_root_ == nullptr) { _this->_impl_.state_root_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.state_root_); } else { _this->_impl_.state_root_->MergeFrom(*from._impl_.state_root_); } } if (cached_has_bits & 0x00000008u) { ABSL_DCHECK(from._impl_.receipt_root_ != nullptr); if (_this->_impl_.receipt_root_ == nullptr) { _this->_impl_.receipt_root_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.receipt_root_); } else { _this->_impl_.receipt_root_->MergeFrom(*from._impl_.receipt_root_); } } if (cached_has_bits & 0x00000010u) { ABSL_DCHECK(from._impl_.logs_bloom_ != nullptr); if (_this->_impl_.logs_bloom_ == nullptr) { _this->_impl_.logs_bloom_ = ::google::protobuf::Message::CopyConstruct<::types::H2048>(arena, *from._impl_.logs_bloom_); } else { _this->_impl_.logs_bloom_->MergeFrom(*from._impl_.logs_bloom_); } } if (cached_has_bits & 0x00000020u) { ABSL_DCHECK(from._impl_.prev_randao_ != nullptr); if (_this->_impl_.prev_randao_ == nullptr) { _this->_impl_.prev_randao_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.prev_randao_); } else { _this->_impl_.prev_randao_->MergeFrom(*from._impl_.prev_randao_); } } if (cached_has_bits & 0x00000040u) { ABSL_DCHECK(from._impl_.base_fee_per_gas_ != nullptr); if (_this->_impl_.base_fee_per_gas_ == nullptr) { _this->_impl_.base_fee_per_gas_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.base_fee_per_gas_); } else { _this->_impl_.base_fee_per_gas_->MergeFrom(*from._impl_.base_fee_per_gas_); } } if (cached_has_bits & 0x00000080u) { ABSL_DCHECK(from._impl_.block_hash_ != nullptr); if (_this->_impl_.block_hash_ == nullptr) { _this->_impl_.block_hash_ = ::google::protobuf::Message::CopyConstruct<::types::H256>(arena, *from._impl_.block_hash_); } else { _this->_impl_.block_hash_->MergeFrom(*from._impl_.block_hash_); } } } if (from._internal_block_number() != 0) { _this->_impl_.block_number_ = from._impl_.block_number_; } if (from._internal_gas_limit() != 0) { _this->_impl_.gas_limit_ = from._impl_.gas_limit_; } if (from._internal_gas_used() != 0) { _this->_impl_.gas_used_ = from._impl_.gas_used_; } if (from._internal_timestamp() != 0) { _this->_impl_.timestamp_ = from._impl_.timestamp_; } if (cached_has_bits & 0x00000300u) { if (cached_has_bits & 0x00000100u) { _this->_impl_.blob_gas_used_ = from._impl_.blob_gas_used_; } if (cached_has_bits & 0x00000200u) { _this->_impl_.excess_blob_gas_ = from._impl_.excess_blob_gas_; } } if (from._internal_version() != 0) { _this->_impl_.version_ = from._impl_.version_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ExecutionPayload::CopyFrom(const ExecutionPayload& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.ExecutionPayload) if (&from == this) return; Clear(); MergeFrom(from); } void ExecutionPayload::InternalSwap(ExecutionPayload* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.transactions_.InternalSwap(&other->_impl_.transactions_); _impl_.withdrawals_.InternalSwap(&other->_impl_.withdrawals_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.extra_data_, &other->_impl_.extra_data_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.version_) + sizeof(ExecutionPayload::_impl_.version_) - PROTOBUF_FIELD_OFFSET(ExecutionPayload, _impl_.parent_hash_)>( reinterpret_cast(&_impl_.parent_hash_), reinterpret_cast(&other->_impl_.parent_hash_)); } ::google::protobuf::Metadata ExecutionPayload::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class Withdrawal::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_._has_bits_); }; Withdrawal::Withdrawal(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.Withdrawal) } inline PROTOBUF_NDEBUG_INLINE Withdrawal::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::Withdrawal& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0} {} Withdrawal::Withdrawal( ::google::protobuf::Arena* arena, const Withdrawal& from) : ::google::protobuf::Message(arena) { Withdrawal* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.address_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::H160>( arena, *from._impl_.address_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, index_), reinterpret_cast(&from._impl_) + offsetof(Impl_, index_), offsetof(Impl_, amount_) - offsetof(Impl_, index_) + sizeof(Impl_::amount_)); // @@protoc_insertion_point(copy_constructor:types.Withdrawal) } inline PROTOBUF_NDEBUG_INLINE Withdrawal::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void Withdrawal::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, address_), 0, offsetof(Impl_, amount_) - offsetof(Impl_, address_) + sizeof(Impl_::amount_)); } Withdrawal::~Withdrawal() { // @@protoc_insertion_point(destructor:types.Withdrawal) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void Withdrawal::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); delete _impl_.address_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* Withdrawal::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_._cached_size_), false, }, &Withdrawal::MergeImpl, &Withdrawal::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 4, 1, 0, 2> Withdrawal::_table_ = { { PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_._has_bits_), 0, // no _extensions_ 4, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967280, // skipmap offsetof(decltype(_table_), field_entries), 4, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_Withdrawal_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::Withdrawal>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint64 amount = 4; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Withdrawal, _impl_.amount_), 63>(), {32, 63, 0, PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.amount_)}}, // uint64 index = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Withdrawal, _impl_.index_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.index_)}}, // uint64 validator_index = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(Withdrawal, _impl_.validator_index_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.validator_index_)}}, // .types.H160 address = 3; {::_pbi::TcParser::FastMtS1, {26, 0, 0, PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.address_)}}, }}, {{ 65535, 65535 }}, {{ // uint64 index = 1; {PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.index_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // uint64 validator_index = 2; {PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.validator_index_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, // .types.H160 address = 3; {PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.address_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint64 amount = 4; {PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.amount_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, }}, {{ {::_pbi::TcParser::GetTable<::types::H160>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void Withdrawal::Clear() { // @@protoc_insertion_point(message_clear_start:types.Withdrawal) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.address_ != nullptr); _impl_.address_->Clear(); } ::memset(&_impl_.index_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.amount_) - reinterpret_cast(&_impl_.index_)) + sizeof(_impl_.amount_)); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* Withdrawal::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.Withdrawal) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint64 index = 1; if (this->_internal_index() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 1, this->_internal_index(), target); } // uint64 validator_index = 2; if (this->_internal_validator_index() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 2, this->_internal_validator_index(), target); } cached_has_bits = _impl_._has_bits_[0]; // .types.H160 address = 3; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 3, *_impl_.address_, _impl_.address_->GetCachedSize(), target, stream); } // uint64 amount = 4; if (this->_internal_amount() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( 4, this->_internal_amount(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.Withdrawal) return target; } ::size_t Withdrawal::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.Withdrawal) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // .types.H160 address = 3; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.address_); } // uint64 index = 1; if (this->_internal_index() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_index()); } // uint64 validator_index = 2; if (this->_internal_validator_index() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_validator_index()); } // uint64 amount = 4; if (this->_internal_amount() != 0) { total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( this->_internal_amount()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void Withdrawal::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.Withdrawal) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.address_ != nullptr); if (_this->_impl_.address_ == nullptr) { _this->_impl_.address_ = ::google::protobuf::Message::CopyConstruct<::types::H160>(arena, *from._impl_.address_); } else { _this->_impl_.address_->MergeFrom(*from._impl_.address_); } } if (from._internal_index() != 0) { _this->_impl_.index_ = from._impl_.index_; } if (from._internal_validator_index() != 0) { _this->_impl_.validator_index_ = from._impl_.validator_index_; } if (from._internal_amount() != 0) { _this->_impl_.amount_ = from._impl_.amount_; } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void Withdrawal::CopyFrom(const Withdrawal& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.Withdrawal) if (&from == this) return; Clear(); MergeFrom(from); } void Withdrawal::InternalSwap(Withdrawal* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.amount_) + sizeof(Withdrawal::_impl_.amount_) - PROTOBUF_FIELD_OFFSET(Withdrawal, _impl_.address_)>( reinterpret_cast(&_impl_.address_), reinterpret_cast(&other->_impl_.address_)); } ::google::protobuf::Metadata Withdrawal::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class BlobsBundleV1::_Internal { public: }; BlobsBundleV1::BlobsBundleV1(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.BlobsBundleV1) } inline PROTOBUF_NDEBUG_INLINE BlobsBundleV1::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::BlobsBundleV1& from_msg) : commitments_{visibility, arena, from.commitments_}, blobs_{visibility, arena, from.blobs_}, proofs_{visibility, arena, from.proofs_}, _cached_size_{0} {} BlobsBundleV1::BlobsBundleV1( ::google::protobuf::Arena* arena, const BlobsBundleV1& from) : ::google::protobuf::Message(arena) { BlobsBundleV1* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:types.BlobsBundleV1) } inline PROTOBUF_NDEBUG_INLINE BlobsBundleV1::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : commitments_{visibility, arena}, blobs_{visibility, arena}, proofs_{visibility, arena}, _cached_size_{0} {} inline void BlobsBundleV1::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } BlobsBundleV1::~BlobsBundleV1() { // @@protoc_insertion_point(destructor:types.BlobsBundleV1) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void BlobsBundleV1::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* BlobsBundleV1::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(BlobsBundleV1, _impl_._cached_size_), false, }, &BlobsBundleV1::MergeImpl, &BlobsBundleV1::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<2, 3, 0, 0, 2> BlobsBundleV1::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967288, // skipmap offsetof(decltype(_table_), field_entries), 3, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_BlobsBundleV1_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::BlobsBundleV1>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // repeated bytes commitments = 1; {::_pbi::TcParser::FastBR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(BlobsBundleV1, _impl_.commitments_)}}, // repeated bytes blobs = 2; {::_pbi::TcParser::FastBR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(BlobsBundleV1, _impl_.blobs_)}}, // repeated bytes proofs = 3; {::_pbi::TcParser::FastBR1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(BlobsBundleV1, _impl_.proofs_)}}, }}, {{ 65535, 65535 }}, {{ // repeated bytes commitments = 1; {PROTOBUF_FIELD_OFFSET(BlobsBundleV1, _impl_.commitments_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, // repeated bytes blobs = 2; {PROTOBUF_FIELD_OFFSET(BlobsBundleV1, _impl_.blobs_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, // repeated bytes proofs = 3; {PROTOBUF_FIELD_OFFSET(BlobsBundleV1, _impl_.proofs_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void BlobsBundleV1::Clear() { // @@protoc_insertion_point(message_clear_start:types.BlobsBundleV1) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.commitments_.Clear(); _impl_.blobs_.Clear(); _impl_.proofs_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* BlobsBundleV1::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.BlobsBundleV1) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated bytes commitments = 1; for (int i = 0, n = this->_internal_commitments_size(); i < n; ++i) { const auto& s = this->_internal_commitments().Get(i); target = stream->WriteBytes(1, s, target); } // repeated bytes blobs = 2; for (int i = 0, n = this->_internal_blobs_size(); i < n; ++i) { const auto& s = this->_internal_blobs().Get(i); target = stream->WriteBytes(2, s, target); } // repeated bytes proofs = 3; for (int i = 0, n = this->_internal_proofs_size(); i < n; ++i) { const auto& s = this->_internal_proofs().Get(i); target = stream->WriteBytes(3, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.BlobsBundleV1) return target; } ::size_t BlobsBundleV1::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.BlobsBundleV1) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes commitments = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_commitments().size()); for (int i = 0, n = _internal_commitments().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_commitments().Get(i)); } // repeated bytes blobs = 2; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_blobs().size()); for (int i = 0, n = _internal_blobs().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_blobs().Get(i)); } // repeated bytes proofs = 3; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_proofs().size()); for (int i = 0, n = _internal_proofs().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_proofs().Get(i)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void BlobsBundleV1::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:types.BlobsBundleV1) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_commitments()->MergeFrom(from._internal_commitments()); _this->_internal_mutable_blobs()->MergeFrom(from._internal_blobs()); _this->_internal_mutable_proofs()->MergeFrom(from._internal_proofs()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void BlobsBundleV1::CopyFrom(const BlobsBundleV1& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.BlobsBundleV1) if (&from == this) return; Clear(); MergeFrom(from); } void BlobsBundleV1::InternalSwap(BlobsBundleV1* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.commitments_.InternalSwap(&other->_impl_.commitments_); _impl_.blobs_.InternalSwap(&other->_impl_.blobs_); _impl_.proofs_.InternalSwap(&other->_impl_.proofs_); } ::google::protobuf::Metadata BlobsBundleV1::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class RequestsBundle::_Internal { public: }; RequestsBundle::RequestsBundle(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.RequestsBundle) } inline PROTOBUF_NDEBUG_INLINE RequestsBundle::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::RequestsBundle& from_msg) : requests_{visibility, arena, from.requests_}, _cached_size_{0} {} RequestsBundle::RequestsBundle( ::google::protobuf::Arena* arena, const RequestsBundle& from) : ::google::protobuf::Message(arena) { RequestsBundle* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:types.RequestsBundle) } inline PROTOBUF_NDEBUG_INLINE RequestsBundle::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : requests_{visibility, arena}, _cached_size_{0} {} inline void RequestsBundle::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } RequestsBundle::~RequestsBundle() { // @@protoc_insertion_point(destructor:types.RequestsBundle) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void RequestsBundle::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* RequestsBundle::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(RequestsBundle, _impl_._cached_size_), false, }, &RequestsBundle::MergeImpl, &RequestsBundle::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RequestsBundle::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967294, // skipmap offsetof(decltype(_table_), field_entries), 1, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_RequestsBundle_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::RequestsBundle>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated bytes requests = 1; {::_pbi::TcParser::FastBR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(RequestsBundle, _impl_.requests_)}}, }}, {{ 65535, 65535 }}, {{ // repeated bytes requests = 1; {PROTOBUF_FIELD_OFFSET(RequestsBundle, _impl_.requests_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void RequestsBundle::Clear() { // @@protoc_insertion_point(message_clear_start:types.RequestsBundle) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.requests_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* RequestsBundle::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.RequestsBundle) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated bytes requests = 1; for (int i = 0, n = this->_internal_requests_size(); i < n; ++i) { const auto& s = this->_internal_requests().Get(i); target = stream->WriteBytes(1, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.RequestsBundle) return target; } ::size_t RequestsBundle::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.RequestsBundle) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes requests = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_requests().size()); for (int i = 0, n = _internal_requests().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_requests().Get(i)); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void RequestsBundle::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:types.RequestsBundle) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_requests()->MergeFrom(from._internal_requests()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void RequestsBundle::CopyFrom(const RequestsBundle& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.RequestsBundle) if (&from == this) return; Clear(); MergeFrom(from); } void RequestsBundle::InternalSwap(RequestsBundle* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.requests_.InternalSwap(&other->_impl_.requests_); } ::google::protobuf::Metadata RequestsBundle::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NodeInfoPorts::_Internal { public: }; NodeInfoPorts::NodeInfoPorts(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.NodeInfoPorts) } NodeInfoPorts::NodeInfoPorts( ::google::protobuf::Arena* arena, const NodeInfoPorts& from) : NodeInfoPorts(arena) { MergeFrom(from); } inline PROTOBUF_NDEBUG_INLINE NodeInfoPorts::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0} {} inline void NodeInfoPorts::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, discovery_), 0, offsetof(Impl_, listener_) - offsetof(Impl_, discovery_) + sizeof(Impl_::listener_)); } NodeInfoPorts::~NodeInfoPorts() { // @@protoc_insertion_point(destructor:types.NodeInfoPorts) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NodeInfoPorts::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NodeInfoPorts::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NodeInfoPorts, _impl_._cached_size_), false, }, &NodeInfoPorts::MergeImpl, &NodeInfoPorts::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 0, 0, 2> NodeInfoPorts::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_NodeInfoPorts_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::NodeInfoPorts>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // uint32 listener = 2; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(NodeInfoPorts, _impl_.listener_), 63>(), {16, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoPorts, _impl_.listener_)}}, // uint32 discovery = 1; {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(NodeInfoPorts, _impl_.discovery_), 63>(), {8, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoPorts, _impl_.discovery_)}}, }}, {{ 65535, 65535 }}, {{ // uint32 discovery = 1; {PROTOBUF_FIELD_OFFSET(NodeInfoPorts, _impl_.discovery_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, // uint32 listener = 2; {PROTOBUF_FIELD_OFFSET(NodeInfoPorts, _impl_.listener_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, }}, // no aux_entries {{ }}, }; PROTOBUF_NOINLINE void NodeInfoPorts::Clear() { // @@protoc_insertion_point(message_clear_start:types.NodeInfoPorts) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::memset(&_impl_.discovery_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.listener_) - reinterpret_cast(&_impl_.discovery_)) + sizeof(_impl_.listener_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NodeInfoPorts::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.NodeInfoPorts) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // uint32 discovery = 1; if (this->_internal_discovery() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 1, this->_internal_discovery(), target); } // uint32 listener = 2; if (this->_internal_listener() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( 2, this->_internal_listener(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.NodeInfoPorts) return target; } ::size_t NodeInfoPorts::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.NodeInfoPorts) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // uint32 discovery = 1; if (this->_internal_discovery() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_discovery()); } // uint32 listener = 2; if (this->_internal_listener() != 0) { total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( this->_internal_listener()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NodeInfoPorts::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:types.NodeInfoPorts) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (from._internal_discovery() != 0) { _this->_impl_.discovery_ = from._impl_.discovery_; } if (from._internal_listener() != 0) { _this->_impl_.listener_ = from._impl_.listener_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NodeInfoPorts::CopyFrom(const NodeInfoPorts& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.NodeInfoPorts) if (&from == this) return; Clear(); MergeFrom(from); } void NodeInfoPorts::InternalSwap(NodeInfoPorts* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(NodeInfoPorts, _impl_.listener_) + sizeof(NodeInfoPorts::_impl_.listener_) - PROTOBUF_FIELD_OFFSET(NodeInfoPorts, _impl_.discovery_)>( reinterpret_cast(&_impl_.discovery_), reinterpret_cast(&other->_impl_.discovery_)); } ::google::protobuf::Metadata NodeInfoPorts::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class NodeInfoReply::_Internal { public: using HasBits = decltype(std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = 8 * PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_._has_bits_); }; NodeInfoReply::NodeInfoReply(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.NodeInfoReply) } inline PROTOBUF_NDEBUG_INLINE NodeInfoReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::NodeInfoReply& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, id_(arena, from.id_), name_(arena, from.name_), enode_(arena, from.enode_), enr_(arena, from.enr_), listener_addr_(arena, from.listener_addr_), protocols_(arena, from.protocols_) {} NodeInfoReply::NodeInfoReply( ::google::protobuf::Arena* arena, const NodeInfoReply& from) : ::google::protobuf::Message(arena) { NodeInfoReply* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; _impl_.ports_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::types::NodeInfoPorts>( arena, *from._impl_.ports_) : nullptr; // @@protoc_insertion_point(copy_constructor:types.NodeInfoReply) } inline PROTOBUF_NDEBUG_INLINE NodeInfoReply::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : _cached_size_{0}, id_(arena), name_(arena), enode_(arena), enr_(arena), listener_addr_(arena), protocols_(arena) {} inline void NodeInfoReply::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); _impl_.ports_ = {}; } NodeInfoReply::~NodeInfoReply() { // @@protoc_insertion_point(destructor:types.NodeInfoReply) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void NodeInfoReply::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.id_.Destroy(); _impl_.name_.Destroy(); _impl_.enode_.Destroy(); _impl_.enr_.Destroy(); _impl_.listener_addr_.Destroy(); _impl_.protocols_.Destroy(); delete _impl_.ports_; _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* NodeInfoReply::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_._cached_size_), false, }, &NodeInfoReply::MergeImpl, &NodeInfoReply::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<3, 7, 1, 55, 2> NodeInfoReply::_table_ = { { PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_._has_bits_), 0, // no _extensions_ 7, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967168, // skipmap offsetof(decltype(_table_), field_entries), 7, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_NodeInfoReply_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::NodeInfoReply>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // string id = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.id_)}}, // string name = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.name_)}}, // string enode = 3; {::_pbi::TcParser::FastUS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.enode_)}}, // string enr = 4; {::_pbi::TcParser::FastUS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.enr_)}}, // .types.NodeInfoPorts ports = 5; {::_pbi::TcParser::FastMtS1, {42, 0, 0, PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.ports_)}}, // string listener_addr = 6; {::_pbi::TcParser::FastUS1, {50, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.listener_addr_)}}, // bytes protocols = 7; {::_pbi::TcParser::FastBS1, {58, 63, 0, PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.protocols_)}}, }}, {{ 65535, 65535 }}, {{ // string id = 1; {PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.id_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string name = 2; {PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.name_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string enode = 3; {PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.enode_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string enr = 4; {PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.enr_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // .types.NodeInfoPorts ports = 5; {PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.ports_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // string listener_addr = 6; {PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.listener_addr_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bytes protocols = 7; {PROTOBUF_FIELD_OFFSET(NodeInfoReply, _impl_.protocols_), -1, 0, (0 | ::_fl::kFcSingular | ::_fl::kBytes | ::_fl::kRepAString)}, }}, {{ {::_pbi::TcParser::GetTable<::types::NodeInfoPorts>()}, }}, {{ "\23\2\4\5\3\0\15\0" "types.NodeInfoReply" "id" "name" "enode" "enr" "listener_addr" }}, }; PROTOBUF_NOINLINE void NodeInfoReply::Clear() { // @@protoc_insertion_point(message_clear_start:types.NodeInfoReply) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.id_.ClearToEmpty(); _impl_.name_.ClearToEmpty(); _impl_.enode_.ClearToEmpty(); _impl_.enr_.ClearToEmpty(); _impl_.listener_addr_.ClearToEmpty(); _impl_.protocols_.ClearToEmpty(); cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(_impl_.ports_ != nullptr); _impl_.ports_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* NodeInfoReply::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.NodeInfoReply) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string id = 1; if (!this->_internal_id().empty()) { const std::string& _s = this->_internal_id(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.NodeInfoReply.id"); target = stream->WriteStringMaybeAliased(1, _s, target); } // string name = 2; if (!this->_internal_name().empty()) { const std::string& _s = this->_internal_name(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.NodeInfoReply.name"); target = stream->WriteStringMaybeAliased(2, _s, target); } // string enode = 3; if (!this->_internal_enode().empty()) { const std::string& _s = this->_internal_enode(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.NodeInfoReply.enode"); target = stream->WriteStringMaybeAliased(3, _s, target); } // string enr = 4; if (!this->_internal_enr().empty()) { const std::string& _s = this->_internal_enr(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.NodeInfoReply.enr"); target = stream->WriteStringMaybeAliased(4, _s, target); } cached_has_bits = _impl_._has_bits_[0]; // .types.NodeInfoPorts ports = 5; if (cached_has_bits & 0x00000001u) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 5, *_impl_.ports_, _impl_.ports_->GetCachedSize(), target, stream); } // string listener_addr = 6; if (!this->_internal_listener_addr().empty()) { const std::string& _s = this->_internal_listener_addr(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.NodeInfoReply.listener_addr"); target = stream->WriteStringMaybeAliased(6, _s, target); } // bytes protocols = 7; if (!this->_internal_protocols().empty()) { const std::string& _s = this->_internal_protocols(); target = stream->WriteBytesMaybeAliased(7, _s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.NodeInfoReply) return target; } ::size_t NodeInfoReply::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.NodeInfoReply) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // string id = 1; if (!this->_internal_id().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_id()); } // string name = 2; if (!this->_internal_name().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_name()); } // string enode = 3; if (!this->_internal_enode().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_enode()); } // string enr = 4; if (!this->_internal_enr().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_enr()); } // string listener_addr = 6; if (!this->_internal_listener_addr().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_listener_addr()); } // bytes protocols = 7; if (!this->_internal_protocols().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::BytesSize( this->_internal_protocols()); } // .types.NodeInfoPorts ports = 5; cached_has_bits = _impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.ports_); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void NodeInfoReply::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); ::google::protobuf::Arena* arena = _this->GetArena(); // @@protoc_insertion_point(class_specific_merge_from_start:types.NodeInfoReply) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; if (!from._internal_id().empty()) { _this->_internal_set_id(from._internal_id()); } if (!from._internal_name().empty()) { _this->_internal_set_name(from._internal_name()); } if (!from._internal_enode().empty()) { _this->_internal_set_enode(from._internal_enode()); } if (!from._internal_enr().empty()) { _this->_internal_set_enr(from._internal_enr()); } if (!from._internal_listener_addr().empty()) { _this->_internal_set_listener_addr(from._internal_listener_addr()); } if (!from._internal_protocols().empty()) { _this->_internal_set_protocols(from._internal_protocols()); } cached_has_bits = from._impl_._has_bits_[0]; if (cached_has_bits & 0x00000001u) { ABSL_DCHECK(from._impl_.ports_ != nullptr); if (_this->_impl_.ports_ == nullptr) { _this->_impl_.ports_ = ::google::protobuf::Message::CopyConstruct<::types::NodeInfoPorts>(arena, *from._impl_.ports_); } else { _this->_impl_.ports_->MergeFrom(*from._impl_.ports_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void NodeInfoReply::CopyFrom(const NodeInfoReply& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.NodeInfoReply) if (&from == this) return; Clear(); MergeFrom(from); } void NodeInfoReply::InternalSwap(NodeInfoReply* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, &other->_impl_.id_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.enode_, &other->_impl_.enode_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.enr_, &other->_impl_.enr_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.listener_addr_, &other->_impl_.listener_addr_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.protocols_, &other->_impl_.protocols_, arena); swap(_impl_.ports_, other->_impl_.ports_); } ::google::protobuf::Metadata NodeInfoReply::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class PeerInfo::_Internal { public: }; PeerInfo::PeerInfo(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.PeerInfo) } inline PROTOBUF_NDEBUG_INLINE PeerInfo::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::PeerInfo& from_msg) : caps_{visibility, arena, from.caps_}, id_(arena, from.id_), name_(arena, from.name_), enode_(arena, from.enode_), enr_(arena, from.enr_), conn_local_addr_(arena, from.conn_local_addr_), conn_remote_addr_(arena, from.conn_remote_addr_), _cached_size_{0} {} PeerInfo::PeerInfo( ::google::protobuf::Arena* arena, const PeerInfo& from) : ::google::protobuf::Message(arena) { PeerInfo* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, conn_is_inbound_), reinterpret_cast(&from._impl_) + offsetof(Impl_, conn_is_inbound_), offsetof(Impl_, conn_is_static_) - offsetof(Impl_, conn_is_inbound_) + sizeof(Impl_::conn_is_static_)); // @@protoc_insertion_point(copy_constructor:types.PeerInfo) } inline PROTOBUF_NDEBUG_INLINE PeerInfo::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : caps_{visibility, arena}, id_(arena), name_(arena), enode_(arena), enr_(arena), conn_local_addr_(arena), conn_remote_addr_(arena), _cached_size_{0} {} inline void PeerInfo::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, conn_is_inbound_), 0, offsetof(Impl_, conn_is_static_) - offsetof(Impl_, conn_is_inbound_) + sizeof(Impl_::conn_is_static_)); } PeerInfo::~PeerInfo() { // @@protoc_insertion_point(destructor:types.PeerInfo) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void PeerInfo::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.id_.Destroy(); _impl_.name_.Destroy(); _impl_.enode_.Destroy(); _impl_.enr_.Destroy(); _impl_.conn_local_addr_.Destroy(); _impl_.conn_remote_addr_.Destroy(); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* PeerInfo::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_._cached_size_), false, }, &PeerInfo::MergeImpl, &PeerInfo::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<4, 10, 0, 80, 2> PeerInfo::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 10, 120, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294966272, // skipmap offsetof(decltype(_table_), field_entries), 10, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries &_PeerInfo_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::PeerInfo>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, // string id = 1; {::_pbi::TcParser::FastUS1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.id_)}}, // string name = 2; {::_pbi::TcParser::FastUS1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.name_)}}, // string enode = 3; {::_pbi::TcParser::FastUS1, {26, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.enode_)}}, // string enr = 4; {::_pbi::TcParser::FastUS1, {34, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.enr_)}}, // repeated string caps = 5; {::_pbi::TcParser::FastUR1, {42, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.caps_)}}, // string conn_local_addr = 6; {::_pbi::TcParser::FastUS1, {50, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_local_addr_)}}, // string conn_remote_addr = 7; {::_pbi::TcParser::FastUS1, {58, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_remote_addr_)}}, // bool conn_is_inbound = 8; {::_pbi::TcParser::SingularVarintNoZag1(), {64, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_inbound_)}}, // bool conn_is_trusted = 9; {::_pbi::TcParser::SingularVarintNoZag1(), {72, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_trusted_)}}, // bool conn_is_static = 10; {::_pbi::TcParser::SingularVarintNoZag1(), {80, 63, 0, PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_static_)}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ // string id = 1; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.id_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string name = 2; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.name_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string enode = 3; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.enode_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string enr = 4; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.enr_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // repeated string caps = 5; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.caps_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, // string conn_local_addr = 6; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_local_addr_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string conn_remote_addr = 7; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_remote_addr_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool conn_is_inbound = 8; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_inbound_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // bool conn_is_trusted = 9; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_trusted_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, // bool conn_is_static = 10; {PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_static_), 0, 0, (0 | ::_fl::kFcSingular | ::_fl::kBool)}, }}, // no aux_entries {{ "\16\2\4\5\3\4\17\20\0\0\0\0\0\0\0\0" "types.PeerInfo" "id" "name" "enode" "enr" "caps" "conn_local_addr" "conn_remote_addr" }}, }; PROTOBUF_NOINLINE void PeerInfo::Clear() { // @@protoc_insertion_point(message_clear_start:types.PeerInfo) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.caps_.Clear(); _impl_.id_.ClearToEmpty(); _impl_.name_.ClearToEmpty(); _impl_.enode_.ClearToEmpty(); _impl_.enr_.ClearToEmpty(); _impl_.conn_local_addr_.ClearToEmpty(); _impl_.conn_remote_addr_.ClearToEmpty(); ::memset(&_impl_.conn_is_inbound_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.conn_is_static_) - reinterpret_cast(&_impl_.conn_is_inbound_)) + sizeof(_impl_.conn_is_static_)); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* PeerInfo::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.PeerInfo) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // string id = 1; if (!this->_internal_id().empty()) { const std::string& _s = this->_internal_id(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.PeerInfo.id"); target = stream->WriteStringMaybeAliased(1, _s, target); } // string name = 2; if (!this->_internal_name().empty()) { const std::string& _s = this->_internal_name(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.PeerInfo.name"); target = stream->WriteStringMaybeAliased(2, _s, target); } // string enode = 3; if (!this->_internal_enode().empty()) { const std::string& _s = this->_internal_enode(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.PeerInfo.enode"); target = stream->WriteStringMaybeAliased(3, _s, target); } // string enr = 4; if (!this->_internal_enr().empty()) { const std::string& _s = this->_internal_enr(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.PeerInfo.enr"); target = stream->WriteStringMaybeAliased(4, _s, target); } // repeated string caps = 5; for (int i = 0, n = this->_internal_caps_size(); i < n; ++i) { const auto& s = this->_internal_caps().Get(i); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.PeerInfo.caps"); target = stream->WriteString(5, s, target); } // string conn_local_addr = 6; if (!this->_internal_conn_local_addr().empty()) { const std::string& _s = this->_internal_conn_local_addr(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.PeerInfo.conn_local_addr"); target = stream->WriteStringMaybeAliased(6, _s, target); } // string conn_remote_addr = 7; if (!this->_internal_conn_remote_addr().empty()) { const std::string& _s = this->_internal_conn_remote_addr(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "types.PeerInfo.conn_remote_addr"); target = stream->WriteStringMaybeAliased(7, _s, target); } // bool conn_is_inbound = 8; if (this->_internal_conn_is_inbound() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 8, this->_internal_conn_is_inbound(), target); } // bool conn_is_trusted = 9; if (this->_internal_conn_is_trusted() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 9, this->_internal_conn_is_trusted(), target); } // bool conn_is_static = 10; if (this->_internal_conn_is_static() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( 10, this->_internal_conn_is_static(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.PeerInfo) return target; } ::size_t PeerInfo::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.PeerInfo) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated string caps = 5; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_caps().size()); for (int i = 0, n = _internal_caps().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::StringSize( _internal_caps().Get(i)); } // string id = 1; if (!this->_internal_id().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_id()); } // string name = 2; if (!this->_internal_name().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_name()); } // string enode = 3; if (!this->_internal_enode().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_enode()); } // string enr = 4; if (!this->_internal_enr().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_enr()); } // string conn_local_addr = 6; if (!this->_internal_conn_local_addr().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_conn_local_addr()); } // string conn_remote_addr = 7; if (!this->_internal_conn_remote_addr().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( this->_internal_conn_remote_addr()); } // bool conn_is_inbound = 8; if (this->_internal_conn_is_inbound() != 0) { total_size += 2; } // bool conn_is_trusted = 9; if (this->_internal_conn_is_trusted() != 0) { total_size += 2; } // bool conn_is_static = 10; if (this->_internal_conn_is_static() != 0) { total_size += 2; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void PeerInfo::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:types.PeerInfo) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_caps()->MergeFrom(from._internal_caps()); if (!from._internal_id().empty()) { _this->_internal_set_id(from._internal_id()); } if (!from._internal_name().empty()) { _this->_internal_set_name(from._internal_name()); } if (!from._internal_enode().empty()) { _this->_internal_set_enode(from._internal_enode()); } if (!from._internal_enr().empty()) { _this->_internal_set_enr(from._internal_enr()); } if (!from._internal_conn_local_addr().empty()) { _this->_internal_set_conn_local_addr(from._internal_conn_local_addr()); } if (!from._internal_conn_remote_addr().empty()) { _this->_internal_set_conn_remote_addr(from._internal_conn_remote_addr()); } if (from._internal_conn_is_inbound() != 0) { _this->_impl_.conn_is_inbound_ = from._impl_.conn_is_inbound_; } if (from._internal_conn_is_trusted() != 0) { _this->_impl_.conn_is_trusted_ = from._impl_.conn_is_trusted_; } if (from._internal_conn_is_static() != 0) { _this->_impl_.conn_is_static_ = from._impl_.conn_is_static_; } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void PeerInfo::CopyFrom(const PeerInfo& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.PeerInfo) if (&from == this) return; Clear(); MergeFrom(from); } void PeerInfo::InternalSwap(PeerInfo* PROTOBUF_RESTRICT other) { using std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.caps_.InternalSwap(&other->_impl_.caps_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, &other->_impl_.id_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.enode_, &other->_impl_.enode_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.enr_, &other->_impl_.enr_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.conn_local_addr_, &other->_impl_.conn_local_addr_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.conn_remote_addr_, &other->_impl_.conn_remote_addr_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_static_) + sizeof(PeerInfo::_impl_.conn_is_static_) - PROTOBUF_FIELD_OFFSET(PeerInfo, _impl_.conn_is_inbound_)>( reinterpret_cast(&_impl_.conn_is_inbound_), reinterpret_cast(&other->_impl_.conn_is_inbound_)); } ::google::protobuf::Metadata PeerInfo::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== class ExecutionPayloadBodyV1::_Internal { public: }; ExecutionPayloadBodyV1::ExecutionPayloadBodyV1(::google::protobuf::Arena* arena) : ::google::protobuf::Message(arena) { SharedCtor(arena); // @@protoc_insertion_point(arena_constructor:types.ExecutionPayloadBodyV1) } inline PROTOBUF_NDEBUG_INLINE ExecutionPayloadBodyV1::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ::types::ExecutionPayloadBodyV1& from_msg) : transactions_{visibility, arena, from.transactions_}, withdrawals_{visibility, arena, from.withdrawals_}, _cached_size_{0} {} ExecutionPayloadBodyV1::ExecutionPayloadBodyV1( ::google::protobuf::Arena* arena, const ExecutionPayloadBodyV1& from) : ::google::protobuf::Message(arena) { ExecutionPayloadBodyV1* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); // @@protoc_insertion_point(copy_constructor:types.ExecutionPayloadBodyV1) } inline PROTOBUF_NDEBUG_INLINE ExecutionPayloadBodyV1::Impl_::Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena) : transactions_{visibility, arena}, withdrawals_{visibility, arena}, _cached_size_{0} {} inline void ExecutionPayloadBodyV1::SharedCtor(::_pb::Arena* arena) { new (&_impl_) Impl_(internal_visibility(), arena); } ExecutionPayloadBodyV1::~ExecutionPayloadBodyV1() { // @@protoc_insertion_point(destructor:types.ExecutionPayloadBodyV1) _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); SharedDtor(); } inline void ExecutionPayloadBodyV1::SharedDtor() { ABSL_DCHECK(GetArena() == nullptr); _impl_.~Impl_(); } const ::google::protobuf::MessageLite::ClassData* ExecutionPayloadBodyV1::GetClassData() const { PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite:: ClassDataFull _data_ = { { &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized PROTOBUF_FIELD_OFFSET(ExecutionPayloadBodyV1, _impl_._cached_size_), false, }, &ExecutionPayloadBodyV1::MergeImpl, &ExecutionPayloadBodyV1::kDescriptorMethods, &descriptor_table_types_2ftypes_2eproto, nullptr, // tracker }; ::google::protobuf::internal::PrefetchToLocalCache(&_data_); ::google::protobuf::internal::PrefetchToLocalCache(_data_.tc_table); return _data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const ::_pbi::TcParseTable<1, 2, 1, 0, 2> ExecutionPayloadBodyV1::_table_ = { { 0, // no _has_bits_ 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), &_ExecutionPayloadBodyV1_default_instance_._instance, nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE ::_pbi::TcParser::GetTable<::types::ExecutionPayloadBodyV1>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ // repeated .types.Withdrawal withdrawals = 2; {::_pbi::TcParser::FastMtR1, {18, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayloadBodyV1, _impl_.withdrawals_)}}, // repeated bytes transactions = 1; {::_pbi::TcParser::FastBR1, {10, 63, 0, PROTOBUF_FIELD_OFFSET(ExecutionPayloadBodyV1, _impl_.transactions_)}}, }}, {{ 65535, 65535 }}, {{ // repeated bytes transactions = 1; {PROTOBUF_FIELD_OFFSET(ExecutionPayloadBodyV1, _impl_.transactions_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)}, // repeated .types.Withdrawal withdrawals = 2; {PROTOBUF_FIELD_OFFSET(ExecutionPayloadBodyV1, _impl_.withdrawals_), 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::types::Withdrawal>()}, }}, {{ }}, }; PROTOBUF_NOINLINE void ExecutionPayloadBodyV1::Clear() { // @@protoc_insertion_point(message_clear_start:types.ExecutionPayloadBodyV1) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; _impl_.transactions_.Clear(); _impl_.withdrawals_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } ::uint8_t* ExecutionPayloadBodyV1::_InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:types.ExecutionPayloadBodyV1) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; // repeated bytes transactions = 1; for (int i = 0, n = this->_internal_transactions_size(); i < n; ++i) { const auto& s = this->_internal_transactions().Get(i); target = stream->WriteBytes(1, s, target); } // repeated .types.Withdrawal withdrawals = 2; for (unsigned i = 0, n = static_cast( this->_internal_withdrawals_size()); i < n; i++) { const auto& repfield = this->_internal_withdrawals().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 2, repfield, repfield.GetCachedSize(), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:types.ExecutionPayloadBodyV1) return target; } ::size_t ExecutionPayloadBodyV1::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:types.ExecutionPayloadBodyV1) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ::_pbi::Prefetch5LinesFrom7Lines(reinterpret_cast(this)); // repeated bytes transactions = 1; total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_transactions().size()); for (int i = 0, n = _internal_transactions().size(); i < n; ++i) { total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( _internal_transactions().Get(i)); } // repeated .types.Withdrawal withdrawals = 2; total_size += 1UL * this->_internal_withdrawals_size(); for (const auto& msg : this->_internal_withdrawals()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } void ExecutionPayloadBodyV1::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = static_cast(&to_msg); auto& from = static_cast(from_msg); // @@protoc_insertion_point(class_specific_merge_from_start:types.ExecutionPayloadBodyV1) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void) cached_has_bits; _this->_internal_mutable_transactions()->MergeFrom(from._internal_transactions()); _this->_internal_mutable_withdrawals()->MergeFrom( from._internal_withdrawals()); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); } void ExecutionPayloadBodyV1::CopyFrom(const ExecutionPayloadBodyV1& from) { // @@protoc_insertion_point(class_specific_copy_from_start:types.ExecutionPayloadBodyV1) if (&from == this) return; Clear(); MergeFrom(from); } void ExecutionPayloadBodyV1::InternalSwap(ExecutionPayloadBodyV1* PROTOBUF_RESTRICT other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); _impl_.transactions_.InternalSwap(&other->_impl_.transactions_); _impl_.withdrawals_.InternalSwap(&other->_impl_.withdrawals_); } ::google::protobuf::Metadata ExecutionPayloadBodyV1::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::_pbi:: ExtensionIdentifier<::google::protobuf::FileOptions, ::_pbi::PrimitiveTypeTraits< ::uint32_t >, 13, false> service_major_version(kServiceMajorVersionFieldNumber, 0u); PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::_pbi:: ExtensionIdentifier<::google::protobuf::FileOptions, ::_pbi::PrimitiveTypeTraits< ::uint32_t >, 13, false> service_minor_version(kServiceMinorVersionFieldNumber, 0u); PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::_pbi:: ExtensionIdentifier<::google::protobuf::FileOptions, ::_pbi::PrimitiveTypeTraits< ::uint32_t >, 13, false> service_patch_version(kServicePatchVersionFieldNumber, 0u); // @@protoc_insertion_point(namespace_scope) } // namespace types namespace google { namespace protobuf { } // namespace protobuf } // namespace google // @@protoc_insertion_point(global_scope) PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type _static_init2_ PROTOBUF_UNUSED = (::_pbi::AddDescriptors(&descriptor_table_types_2ftypes_2eproto), ::_pbi::ExtensionSet::RegisterExtension( &::google::protobuf::FileOptions::default_instance(), 50001, 13, false, false), ::_pbi::ExtensionSet::RegisterExtension( &::google::protobuf::FileOptions::default_instance(), 50002, 13, false, false), ::_pbi::ExtensionSet::RegisterExtension( &::google::protobuf::FileOptions::default_instance(), 50003, 13, false, false), ::std::false_type{}); #include "google/protobuf/port_undef.inc" ================================================ FILE: silkworm/interfaces/27.0/types/types.pb.h ================================================ // Generated by the protocol buffer compiler. DO NOT EDIT! // NO CHECKED-IN PROTOBUF GENCODE // source: types/types.proto // Protobuf C++ Version: 5.27.0 #ifndef GOOGLE_PROTOBUF_INCLUDED_types_2ftypes_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_types_2ftypes_2eproto_2epb_2eh #include #include #include #include #include "google/protobuf/runtime_version.h" #if PROTOBUF_VERSION != 5027000 #error "Protobuf C++ gencode is built with an incompatible version of" #error "Protobuf C++ headers/runtime. See" #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" #endif #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_tctable_decl.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/generated_message_reflection.h" #include "google/protobuf/message.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/protobuf/unknown_field_set.h" #include "google/protobuf/descriptor.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_types_2ftypes_2eproto namespace google { namespace protobuf { namespace internal { class AnyMetadata; } // namespace internal } // namespace protobuf } // namespace google // Internal implementation detail -- do not use these members. struct TableStruct_types_2ftypes_2eproto { static const ::uint32_t offsets[]; }; extern const ::google::protobuf::internal::DescriptorTable descriptor_table_types_2ftypes_2eproto; namespace types { class BlobsBundleV1; struct BlobsBundleV1DefaultTypeInternal; extern BlobsBundleV1DefaultTypeInternal _BlobsBundleV1_default_instance_; class ExecutionPayload; struct ExecutionPayloadDefaultTypeInternal; extern ExecutionPayloadDefaultTypeInternal _ExecutionPayload_default_instance_; class ExecutionPayloadBodyV1; struct ExecutionPayloadBodyV1DefaultTypeInternal; extern ExecutionPayloadBodyV1DefaultTypeInternal _ExecutionPayloadBodyV1_default_instance_; class H1024; struct H1024DefaultTypeInternal; extern H1024DefaultTypeInternal _H1024_default_instance_; class H128; struct H128DefaultTypeInternal; extern H128DefaultTypeInternal _H128_default_instance_; class H160; struct H160DefaultTypeInternal; extern H160DefaultTypeInternal _H160_default_instance_; class H2048; struct H2048DefaultTypeInternal; extern H2048DefaultTypeInternal _H2048_default_instance_; class H256; struct H256DefaultTypeInternal; extern H256DefaultTypeInternal _H256_default_instance_; class H512; struct H512DefaultTypeInternal; extern H512DefaultTypeInternal _H512_default_instance_; class NodeInfoPorts; struct NodeInfoPortsDefaultTypeInternal; extern NodeInfoPortsDefaultTypeInternal _NodeInfoPorts_default_instance_; class NodeInfoReply; struct NodeInfoReplyDefaultTypeInternal; extern NodeInfoReplyDefaultTypeInternal _NodeInfoReply_default_instance_; class PeerInfo; struct PeerInfoDefaultTypeInternal; extern PeerInfoDefaultTypeInternal _PeerInfo_default_instance_; class RequestsBundle; struct RequestsBundleDefaultTypeInternal; extern RequestsBundleDefaultTypeInternal _RequestsBundle_default_instance_; class VersionReply; struct VersionReplyDefaultTypeInternal; extern VersionReplyDefaultTypeInternal _VersionReply_default_instance_; class Withdrawal; struct WithdrawalDefaultTypeInternal; extern WithdrawalDefaultTypeInternal _Withdrawal_default_instance_; } // namespace types namespace google { namespace protobuf { } // namespace protobuf } // namespace google namespace types { // =================================================================== // ------------------------------------------------------------------- class VersionReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.VersionReply) */ { public: inline VersionReply() : VersionReply(nullptr) {} ~VersionReply() override; template explicit PROTOBUF_CONSTEXPR VersionReply( ::google::protobuf::internal::ConstantInitialized); inline VersionReply(const VersionReply& from) : VersionReply(nullptr, from) {} inline VersionReply(VersionReply&& from) noexcept : VersionReply(nullptr, std::move(from)) {} inline VersionReply& operator=(const VersionReply& from) { CopyFrom(from); return *this; } inline VersionReply& operator=(VersionReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const VersionReply& default_instance() { return *internal_default_instance(); } static inline const VersionReply* internal_default_instance() { return reinterpret_cast( &_VersionReply_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(VersionReply& a, VersionReply& b) { a.Swap(&b); } inline void Swap(VersionReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(VersionReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- VersionReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const VersionReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const VersionReply& from) { VersionReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(VersionReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.VersionReply"; } protected: explicit VersionReply(::google::protobuf::Arena* arena); VersionReply(::google::protobuf::Arena* arena, const VersionReply& from); VersionReply(::google::protobuf::Arena* arena, VersionReply&& from) noexcept : VersionReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kMajorFieldNumber = 1, kMinorFieldNumber = 2, kPatchFieldNumber = 3, }; // uint32 major = 1; void clear_major() ; ::uint32_t major() const; void set_major(::uint32_t value); private: ::uint32_t _internal_major() const; void _internal_set_major(::uint32_t value); public: // uint32 minor = 2; void clear_minor() ; ::uint32_t minor() const; void set_minor(::uint32_t value); private: ::uint32_t _internal_minor() const; void _internal_set_minor(::uint32_t value); public: // uint32 patch = 3; void clear_patch() ; ::uint32_t patch() const; void set_patch(::uint32_t value); private: ::uint32_t _internal_patch() const; void _internal_set_patch(::uint32_t value); public: // @@protoc_insertion_point(class_scope:types.VersionReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_VersionReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const VersionReply& from_msg); ::uint32_t major_; ::uint32_t minor_; ::uint32_t patch_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class RequestsBundle final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.RequestsBundle) */ { public: inline RequestsBundle() : RequestsBundle(nullptr) {} ~RequestsBundle() override; template explicit PROTOBUF_CONSTEXPR RequestsBundle( ::google::protobuf::internal::ConstantInitialized); inline RequestsBundle(const RequestsBundle& from) : RequestsBundle(nullptr, from) {} inline RequestsBundle(RequestsBundle&& from) noexcept : RequestsBundle(nullptr, std::move(from)) {} inline RequestsBundle& operator=(const RequestsBundle& from) { CopyFrom(from); return *this; } inline RequestsBundle& operator=(RequestsBundle&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const RequestsBundle& default_instance() { return *internal_default_instance(); } static inline const RequestsBundle* internal_default_instance() { return reinterpret_cast( &_RequestsBundle_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(RequestsBundle& a, RequestsBundle& b) { a.Swap(&b); } inline void Swap(RequestsBundle* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RequestsBundle* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RequestsBundle* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const RequestsBundle& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const RequestsBundle& from) { RequestsBundle::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(RequestsBundle* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.RequestsBundle"; } protected: explicit RequestsBundle(::google::protobuf::Arena* arena); RequestsBundle(::google::protobuf::Arena* arena, const RequestsBundle& from); RequestsBundle(::google::protobuf::Arena* arena, RequestsBundle&& from) noexcept : RequestsBundle(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kRequestsFieldNumber = 1, }; // repeated bytes requests = 1; int requests_size() const; private: int _internal_requests_size() const; public: void clear_requests() ; const std::string& requests(int index) const; std::string* mutable_requests(int index); void set_requests(int index, const std::string& value); void set_requests(int index, std::string&& value); void set_requests(int index, const char* value); void set_requests(int index, const void* value, std::size_t size); void set_requests(int index, absl::string_view value); std::string* add_requests(); void add_requests(const std::string& value); void add_requests(std::string&& value); void add_requests(const char* value); void add_requests(const void* value, std::size_t size); void add_requests(absl::string_view value); const ::google::protobuf::RepeatedPtrField& requests() const; ::google::protobuf::RepeatedPtrField* mutable_requests(); private: const ::google::protobuf::RepeatedPtrField& _internal_requests() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_requests(); public: // @@protoc_insertion_point(class_scope:types.RequestsBundle) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 0, 1, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_RequestsBundle_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const RequestsBundle& from_msg); ::google::protobuf::RepeatedPtrField requests_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class PeerInfo final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.PeerInfo) */ { public: inline PeerInfo() : PeerInfo(nullptr) {} ~PeerInfo() override; template explicit PROTOBUF_CONSTEXPR PeerInfo( ::google::protobuf::internal::ConstantInitialized); inline PeerInfo(const PeerInfo& from) : PeerInfo(nullptr, from) {} inline PeerInfo(PeerInfo&& from) noexcept : PeerInfo(nullptr, std::move(from)) {} inline PeerInfo& operator=(const PeerInfo& from) { CopyFrom(from); return *this; } inline PeerInfo& operator=(PeerInfo&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const PeerInfo& default_instance() { return *internal_default_instance(); } static inline const PeerInfo* internal_default_instance() { return reinterpret_cast( &_PeerInfo_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(PeerInfo& a, PeerInfo& b) { a.Swap(&b); } inline void Swap(PeerInfo* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PeerInfo* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PeerInfo* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const PeerInfo& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const PeerInfo& from) { PeerInfo::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(PeerInfo* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.PeerInfo"; } protected: explicit PeerInfo(::google::protobuf::Arena* arena); PeerInfo(::google::protobuf::Arena* arena, const PeerInfo& from); PeerInfo(::google::protobuf::Arena* arena, PeerInfo&& from) noexcept : PeerInfo(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCapsFieldNumber = 5, kIdFieldNumber = 1, kNameFieldNumber = 2, kEnodeFieldNumber = 3, kEnrFieldNumber = 4, kConnLocalAddrFieldNumber = 6, kConnRemoteAddrFieldNumber = 7, kConnIsInboundFieldNumber = 8, kConnIsTrustedFieldNumber = 9, kConnIsStaticFieldNumber = 10, }; // repeated string caps = 5; int caps_size() const; private: int _internal_caps_size() const; public: void clear_caps() ; const std::string& caps(int index) const; std::string* mutable_caps(int index); void set_caps(int index, const std::string& value); void set_caps(int index, std::string&& value); void set_caps(int index, const char* value); void set_caps(int index, const char* value, std::size_t size); void set_caps(int index, absl::string_view value); std::string* add_caps(); void add_caps(const std::string& value); void add_caps(std::string&& value); void add_caps(const char* value); void add_caps(const char* value, std::size_t size); void add_caps(absl::string_view value); const ::google::protobuf::RepeatedPtrField& caps() const; ::google::protobuf::RepeatedPtrField* mutable_caps(); private: const ::google::protobuf::RepeatedPtrField& _internal_caps() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_caps(); public: // string id = 1; void clear_id() ; const std::string& id() const; template void set_id(Arg_&& arg, Args_... args); std::string* mutable_id(); PROTOBUF_NODISCARD std::string* release_id(); void set_allocated_id(std::string* value); private: const std::string& _internal_id() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_id( const std::string& value); std::string* _internal_mutable_id(); public: // string name = 2; void clear_name() ; const std::string& name() const; template void set_name(Arg_&& arg, Args_... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* value); private: const std::string& _internal_name() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_name( const std::string& value); std::string* _internal_mutable_name(); public: // string enode = 3; void clear_enode() ; const std::string& enode() const; template void set_enode(Arg_&& arg, Args_... args); std::string* mutable_enode(); PROTOBUF_NODISCARD std::string* release_enode(); void set_allocated_enode(std::string* value); private: const std::string& _internal_enode() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_enode( const std::string& value); std::string* _internal_mutable_enode(); public: // string enr = 4; void clear_enr() ; const std::string& enr() const; template void set_enr(Arg_&& arg, Args_... args); std::string* mutable_enr(); PROTOBUF_NODISCARD std::string* release_enr(); void set_allocated_enr(std::string* value); private: const std::string& _internal_enr() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_enr( const std::string& value); std::string* _internal_mutable_enr(); public: // string conn_local_addr = 6; void clear_conn_local_addr() ; const std::string& conn_local_addr() const; template void set_conn_local_addr(Arg_&& arg, Args_... args); std::string* mutable_conn_local_addr(); PROTOBUF_NODISCARD std::string* release_conn_local_addr(); void set_allocated_conn_local_addr(std::string* value); private: const std::string& _internal_conn_local_addr() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_conn_local_addr( const std::string& value); std::string* _internal_mutable_conn_local_addr(); public: // string conn_remote_addr = 7; void clear_conn_remote_addr() ; const std::string& conn_remote_addr() const; template void set_conn_remote_addr(Arg_&& arg, Args_... args); std::string* mutable_conn_remote_addr(); PROTOBUF_NODISCARD std::string* release_conn_remote_addr(); void set_allocated_conn_remote_addr(std::string* value); private: const std::string& _internal_conn_remote_addr() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_conn_remote_addr( const std::string& value); std::string* _internal_mutable_conn_remote_addr(); public: // bool conn_is_inbound = 8; void clear_conn_is_inbound() ; bool conn_is_inbound() const; void set_conn_is_inbound(bool value); private: bool _internal_conn_is_inbound() const; void _internal_set_conn_is_inbound(bool value); public: // bool conn_is_trusted = 9; void clear_conn_is_trusted() ; bool conn_is_trusted() const; void set_conn_is_trusted(bool value); private: bool _internal_conn_is_trusted() const; void _internal_set_conn_is_trusted(bool value); public: // bool conn_is_static = 10; void clear_conn_is_static() ; bool conn_is_static() const; void set_conn_is_static(bool value); private: bool _internal_conn_is_static() const; void _internal_set_conn_is_static(bool value); public: // @@protoc_insertion_point(class_scope:types.PeerInfo) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 4, 10, 0, 80, 2> _table_; static constexpr const void* _raw_default_instance_ = &_PeerInfo_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const PeerInfo& from_msg); ::google::protobuf::RepeatedPtrField caps_; ::google::protobuf::internal::ArenaStringPtr id_; ::google::protobuf::internal::ArenaStringPtr name_; ::google::protobuf::internal::ArenaStringPtr enode_; ::google::protobuf::internal::ArenaStringPtr enr_; ::google::protobuf::internal::ArenaStringPtr conn_local_addr_; ::google::protobuf::internal::ArenaStringPtr conn_remote_addr_; bool conn_is_inbound_; bool conn_is_trusted_; bool conn_is_static_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class NodeInfoPorts final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.NodeInfoPorts) */ { public: inline NodeInfoPorts() : NodeInfoPorts(nullptr) {} ~NodeInfoPorts() override; template explicit PROTOBUF_CONSTEXPR NodeInfoPorts( ::google::protobuf::internal::ConstantInitialized); inline NodeInfoPorts(const NodeInfoPorts& from) : NodeInfoPorts(nullptr, from) {} inline NodeInfoPorts(NodeInfoPorts&& from) noexcept : NodeInfoPorts(nullptr, std::move(from)) {} inline NodeInfoPorts& operator=(const NodeInfoPorts& from) { CopyFrom(from); return *this; } inline NodeInfoPorts& operator=(NodeInfoPorts&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NodeInfoPorts& default_instance() { return *internal_default_instance(); } static inline const NodeInfoPorts* internal_default_instance() { return reinterpret_cast( &_NodeInfoPorts_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(NodeInfoPorts& a, NodeInfoPorts& b) { a.Swap(&b); } inline void Swap(NodeInfoPorts* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NodeInfoPorts* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NodeInfoPorts* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NodeInfoPorts& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NodeInfoPorts& from) { NodeInfoPorts::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NodeInfoPorts* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.NodeInfoPorts"; } protected: explicit NodeInfoPorts(::google::protobuf::Arena* arena); NodeInfoPorts(::google::protobuf::Arena* arena, const NodeInfoPorts& from); NodeInfoPorts(::google::protobuf::Arena* arena, NodeInfoPorts&& from) noexcept : NodeInfoPorts(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDiscoveryFieldNumber = 1, kListenerFieldNumber = 2, }; // uint32 discovery = 1; void clear_discovery() ; ::uint32_t discovery() const; void set_discovery(::uint32_t value); private: ::uint32_t _internal_discovery() const; void _internal_set_discovery(::uint32_t value); public: // uint32 listener = 2; void clear_listener() ; ::uint32_t listener() const; void set_listener(::uint32_t value); private: ::uint32_t _internal_listener() const; void _internal_set_listener(::uint32_t value); public: // @@protoc_insertion_point(class_scope:types.NodeInfoPorts) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NodeInfoPorts_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NodeInfoPorts& from_msg); ::uint32_t discovery_; ::uint32_t listener_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class H128 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.H128) */ { public: inline H128() : H128(nullptr) {} ~H128() override; template explicit PROTOBUF_CONSTEXPR H128( ::google::protobuf::internal::ConstantInitialized); inline H128(const H128& from) : H128(nullptr, from) {} inline H128(H128&& from) noexcept : H128(nullptr, std::move(from)) {} inline H128& operator=(const H128& from) { CopyFrom(from); return *this; } inline H128& operator=(H128&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const H128& default_instance() { return *internal_default_instance(); } static inline const H128* internal_default_instance() { return reinterpret_cast( &_H128_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(H128& a, H128& b) { a.Swap(&b); } inline void Swap(H128* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(H128* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- H128* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const H128& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const H128& from) { H128::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(H128* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.H128"; } protected: explicit H128(::google::protobuf::Arena* arena); H128(::google::protobuf::Arena* arena, const H128& from); H128(::google::protobuf::Arena* arena, H128&& from) noexcept : H128(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHiFieldNumber = 1, kLoFieldNumber = 2, }; // uint64 hi = 1; void clear_hi() ; ::uint64_t hi() const; void set_hi(::uint64_t value); private: ::uint64_t _internal_hi() const; void _internal_set_hi(::uint64_t value); public: // uint64 lo = 2; void clear_lo() ; ::uint64_t lo() const; void set_lo(::uint64_t value); private: ::uint64_t _internal_lo() const; void _internal_set_lo(::uint64_t value); public: // @@protoc_insertion_point(class_scope:types.H128) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_H128_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const H128& from_msg); ::uint64_t hi_; ::uint64_t lo_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class BlobsBundleV1 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.BlobsBundleV1) */ { public: inline BlobsBundleV1() : BlobsBundleV1(nullptr) {} ~BlobsBundleV1() override; template explicit PROTOBUF_CONSTEXPR BlobsBundleV1( ::google::protobuf::internal::ConstantInitialized); inline BlobsBundleV1(const BlobsBundleV1& from) : BlobsBundleV1(nullptr, from) {} inline BlobsBundleV1(BlobsBundleV1&& from) noexcept : BlobsBundleV1(nullptr, std::move(from)) {} inline BlobsBundleV1& operator=(const BlobsBundleV1& from) { CopyFrom(from); return *this; } inline BlobsBundleV1& operator=(BlobsBundleV1&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const BlobsBundleV1& default_instance() { return *internal_default_instance(); } static inline const BlobsBundleV1* internal_default_instance() { return reinterpret_cast( &_BlobsBundleV1_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(BlobsBundleV1& a, BlobsBundleV1& b) { a.Swap(&b); } inline void Swap(BlobsBundleV1* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BlobsBundleV1* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BlobsBundleV1* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const BlobsBundleV1& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const BlobsBundleV1& from) { BlobsBundleV1::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(BlobsBundleV1* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.BlobsBundleV1"; } protected: explicit BlobsBundleV1(::google::protobuf::Arena* arena); BlobsBundleV1(::google::protobuf::Arena* arena, const BlobsBundleV1& from); BlobsBundleV1(::google::protobuf::Arena* arena, BlobsBundleV1&& from) noexcept : BlobsBundleV1(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCommitmentsFieldNumber = 1, kBlobsFieldNumber = 2, kProofsFieldNumber = 3, }; // repeated bytes commitments = 1; int commitments_size() const; private: int _internal_commitments_size() const; public: void clear_commitments() ; const std::string& commitments(int index) const; std::string* mutable_commitments(int index); void set_commitments(int index, const std::string& value); void set_commitments(int index, std::string&& value); void set_commitments(int index, const char* value); void set_commitments(int index, const void* value, std::size_t size); void set_commitments(int index, absl::string_view value); std::string* add_commitments(); void add_commitments(const std::string& value); void add_commitments(std::string&& value); void add_commitments(const char* value); void add_commitments(const void* value, std::size_t size); void add_commitments(absl::string_view value); const ::google::protobuf::RepeatedPtrField& commitments() const; ::google::protobuf::RepeatedPtrField* mutable_commitments(); private: const ::google::protobuf::RepeatedPtrField& _internal_commitments() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_commitments(); public: // repeated bytes blobs = 2; int blobs_size() const; private: int _internal_blobs_size() const; public: void clear_blobs() ; const std::string& blobs(int index) const; std::string* mutable_blobs(int index); void set_blobs(int index, const std::string& value); void set_blobs(int index, std::string&& value); void set_blobs(int index, const char* value); void set_blobs(int index, const void* value, std::size_t size); void set_blobs(int index, absl::string_view value); std::string* add_blobs(); void add_blobs(const std::string& value); void add_blobs(std::string&& value); void add_blobs(const char* value); void add_blobs(const void* value, std::size_t size); void add_blobs(absl::string_view value); const ::google::protobuf::RepeatedPtrField& blobs() const; ::google::protobuf::RepeatedPtrField* mutable_blobs(); private: const ::google::protobuf::RepeatedPtrField& _internal_blobs() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_blobs(); public: // repeated bytes proofs = 3; int proofs_size() const; private: int _internal_proofs_size() const; public: void clear_proofs() ; const std::string& proofs(int index) const; std::string* mutable_proofs(int index); void set_proofs(int index, const std::string& value); void set_proofs(int index, std::string&& value); void set_proofs(int index, const char* value); void set_proofs(int index, const void* value, std::size_t size); void set_proofs(int index, absl::string_view value); std::string* add_proofs(); void add_proofs(const std::string& value); void add_proofs(std::string&& value); void add_proofs(const char* value); void add_proofs(const void* value, std::size_t size); void add_proofs(absl::string_view value); const ::google::protobuf::RepeatedPtrField& proofs() const; ::google::protobuf::RepeatedPtrField* mutable_proofs(); private: const ::google::protobuf::RepeatedPtrField& _internal_proofs() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_proofs(); public: // @@protoc_insertion_point(class_scope:types.BlobsBundleV1) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 3, 0, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_BlobsBundleV1_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const BlobsBundleV1& from_msg); ::google::protobuf::RepeatedPtrField commitments_; ::google::protobuf::RepeatedPtrField blobs_; ::google::protobuf::RepeatedPtrField proofs_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class NodeInfoReply final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.NodeInfoReply) */ { public: inline NodeInfoReply() : NodeInfoReply(nullptr) {} ~NodeInfoReply() override; template explicit PROTOBUF_CONSTEXPR NodeInfoReply( ::google::protobuf::internal::ConstantInitialized); inline NodeInfoReply(const NodeInfoReply& from) : NodeInfoReply(nullptr, from) {} inline NodeInfoReply(NodeInfoReply&& from) noexcept : NodeInfoReply(nullptr, std::move(from)) {} inline NodeInfoReply& operator=(const NodeInfoReply& from) { CopyFrom(from); return *this; } inline NodeInfoReply& operator=(NodeInfoReply&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NodeInfoReply& default_instance() { return *internal_default_instance(); } static inline const NodeInfoReply* internal_default_instance() { return reinterpret_cast( &_NodeInfoReply_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(NodeInfoReply& a, NodeInfoReply& b) { a.Swap(&b); } inline void Swap(NodeInfoReply* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NodeInfoReply* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NodeInfoReply* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const NodeInfoReply& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const NodeInfoReply& from) { NodeInfoReply::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(NodeInfoReply* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.NodeInfoReply"; } protected: explicit NodeInfoReply(::google::protobuf::Arena* arena); NodeInfoReply(::google::protobuf::Arena* arena, const NodeInfoReply& from); NodeInfoReply(::google::protobuf::Arena* arena, NodeInfoReply&& from) noexcept : NodeInfoReply(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdFieldNumber = 1, kNameFieldNumber = 2, kEnodeFieldNumber = 3, kEnrFieldNumber = 4, kListenerAddrFieldNumber = 6, kProtocolsFieldNumber = 7, kPortsFieldNumber = 5, }; // string id = 1; void clear_id() ; const std::string& id() const; template void set_id(Arg_&& arg, Args_... args); std::string* mutable_id(); PROTOBUF_NODISCARD std::string* release_id(); void set_allocated_id(std::string* value); private: const std::string& _internal_id() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_id( const std::string& value); std::string* _internal_mutable_id(); public: // string name = 2; void clear_name() ; const std::string& name() const; template void set_name(Arg_&& arg, Args_... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* value); private: const std::string& _internal_name() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_name( const std::string& value); std::string* _internal_mutable_name(); public: // string enode = 3; void clear_enode() ; const std::string& enode() const; template void set_enode(Arg_&& arg, Args_... args); std::string* mutable_enode(); PROTOBUF_NODISCARD std::string* release_enode(); void set_allocated_enode(std::string* value); private: const std::string& _internal_enode() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_enode( const std::string& value); std::string* _internal_mutable_enode(); public: // string enr = 4; void clear_enr() ; const std::string& enr() const; template void set_enr(Arg_&& arg, Args_... args); std::string* mutable_enr(); PROTOBUF_NODISCARD std::string* release_enr(); void set_allocated_enr(std::string* value); private: const std::string& _internal_enr() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_enr( const std::string& value); std::string* _internal_mutable_enr(); public: // string listener_addr = 6; void clear_listener_addr() ; const std::string& listener_addr() const; template void set_listener_addr(Arg_&& arg, Args_... args); std::string* mutable_listener_addr(); PROTOBUF_NODISCARD std::string* release_listener_addr(); void set_allocated_listener_addr(std::string* value); private: const std::string& _internal_listener_addr() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_listener_addr( const std::string& value); std::string* _internal_mutable_listener_addr(); public: // bytes protocols = 7; void clear_protocols() ; const std::string& protocols() const; template void set_protocols(Arg_&& arg, Args_... args); std::string* mutable_protocols(); PROTOBUF_NODISCARD std::string* release_protocols(); void set_allocated_protocols(std::string* value); private: const std::string& _internal_protocols() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_protocols( const std::string& value); std::string* _internal_mutable_protocols(); public: // .types.NodeInfoPorts ports = 5; bool has_ports() const; void clear_ports() ; const ::types::NodeInfoPorts& ports() const; PROTOBUF_NODISCARD ::types::NodeInfoPorts* release_ports(); ::types::NodeInfoPorts* mutable_ports(); void set_allocated_ports(::types::NodeInfoPorts* value); void unsafe_arena_set_allocated_ports(::types::NodeInfoPorts* value); ::types::NodeInfoPorts* unsafe_arena_release_ports(); private: const ::types::NodeInfoPorts& _internal_ports() const; ::types::NodeInfoPorts* _internal_mutable_ports(); public: // @@protoc_insertion_point(class_scope:types.NodeInfoReply) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 3, 7, 1, 55, 2> _table_; static constexpr const void* _raw_default_instance_ = &_NodeInfoReply_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const NodeInfoReply& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr id_; ::google::protobuf::internal::ArenaStringPtr name_; ::google::protobuf::internal::ArenaStringPtr enode_; ::google::protobuf::internal::ArenaStringPtr enr_; ::google::protobuf::internal::ArenaStringPtr listener_addr_; ::google::protobuf::internal::ArenaStringPtr protocols_; ::types::NodeInfoPorts* ports_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class H256 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.H256) */ { public: inline H256() : H256(nullptr) {} ~H256() override; template explicit PROTOBUF_CONSTEXPR H256( ::google::protobuf::internal::ConstantInitialized); inline H256(const H256& from) : H256(nullptr, from) {} inline H256(H256&& from) noexcept : H256(nullptr, std::move(from)) {} inline H256& operator=(const H256& from) { CopyFrom(from); return *this; } inline H256& operator=(H256&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const H256& default_instance() { return *internal_default_instance(); } static inline const H256* internal_default_instance() { return reinterpret_cast( &_H256_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(H256& a, H256& b) { a.Swap(&b); } inline void Swap(H256* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(H256* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- H256* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const H256& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const H256& from) { H256::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(H256* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.H256"; } protected: explicit H256(::google::protobuf::Arena* arena); H256(::google::protobuf::Arena* arena, const H256& from); H256(::google::protobuf::Arena* arena, H256&& from) noexcept : H256(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHiFieldNumber = 1, kLoFieldNumber = 2, }; // .types.H128 hi = 1; bool has_hi() const; void clear_hi() ; const ::types::H128& hi() const; PROTOBUF_NODISCARD ::types::H128* release_hi(); ::types::H128* mutable_hi(); void set_allocated_hi(::types::H128* value); void unsafe_arena_set_allocated_hi(::types::H128* value); ::types::H128* unsafe_arena_release_hi(); private: const ::types::H128& _internal_hi() const; ::types::H128* _internal_mutable_hi(); public: // .types.H128 lo = 2; bool has_lo() const; void clear_lo() ; const ::types::H128& lo() const; PROTOBUF_NODISCARD ::types::H128* release_lo(); ::types::H128* mutable_lo(); void set_allocated_lo(::types::H128* value); void unsafe_arena_set_allocated_lo(::types::H128* value); ::types::H128* unsafe_arena_release_lo(); private: const ::types::H128& _internal_lo() const; ::types::H128* _internal_mutable_lo(); public: // @@protoc_insertion_point(class_scope:types.H256) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_H256_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const H256& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H128* hi_; ::types::H128* lo_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class H160 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.H160) */ { public: inline H160() : H160(nullptr) {} ~H160() override; template explicit PROTOBUF_CONSTEXPR H160( ::google::protobuf::internal::ConstantInitialized); inline H160(const H160& from) : H160(nullptr, from) {} inline H160(H160&& from) noexcept : H160(nullptr, std::move(from)) {} inline H160& operator=(const H160& from) { CopyFrom(from); return *this; } inline H160& operator=(H160&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const H160& default_instance() { return *internal_default_instance(); } static inline const H160* internal_default_instance() { return reinterpret_cast( &_H160_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(H160& a, H160& b) { a.Swap(&b); } inline void Swap(H160* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(H160* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- H160* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const H160& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const H160& from) { H160::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(H160* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.H160"; } protected: explicit H160(::google::protobuf::Arena* arena); H160(::google::protobuf::Arena* arena, const H160& from); H160(::google::protobuf::Arena* arena, H160&& from) noexcept : H160(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHiFieldNumber = 1, kLoFieldNumber = 2, }; // .types.H128 hi = 1; bool has_hi() const; void clear_hi() ; const ::types::H128& hi() const; PROTOBUF_NODISCARD ::types::H128* release_hi(); ::types::H128* mutable_hi(); void set_allocated_hi(::types::H128* value); void unsafe_arena_set_allocated_hi(::types::H128* value); ::types::H128* unsafe_arena_release_hi(); private: const ::types::H128& _internal_hi() const; ::types::H128* _internal_mutable_hi(); public: // uint32 lo = 2; void clear_lo() ; ::uint32_t lo() const; void set_lo(::uint32_t value); private: ::uint32_t _internal_lo() const; void _internal_set_lo(::uint32_t value); public: // @@protoc_insertion_point(class_scope:types.H160) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_H160_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const H160& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H128* hi_; ::uint32_t lo_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class Withdrawal final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.Withdrawal) */ { public: inline Withdrawal() : Withdrawal(nullptr) {} ~Withdrawal() override; template explicit PROTOBUF_CONSTEXPR Withdrawal( ::google::protobuf::internal::ConstantInitialized); inline Withdrawal(const Withdrawal& from) : Withdrawal(nullptr, from) {} inline Withdrawal(Withdrawal&& from) noexcept : Withdrawal(nullptr, std::move(from)) {} inline Withdrawal& operator=(const Withdrawal& from) { CopyFrom(from); return *this; } inline Withdrawal& operator=(Withdrawal&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Withdrawal& default_instance() { return *internal_default_instance(); } static inline const Withdrawal* internal_default_instance() { return reinterpret_cast( &_Withdrawal_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(Withdrawal& a, Withdrawal& b) { a.Swap(&b); } inline void Swap(Withdrawal* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Withdrawal* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Withdrawal* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const Withdrawal& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const Withdrawal& from) { Withdrawal::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(Withdrawal* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.Withdrawal"; } protected: explicit Withdrawal(::google::protobuf::Arena* arena); Withdrawal(::google::protobuf::Arena* arena, const Withdrawal& from); Withdrawal(::google::protobuf::Arena* arena, Withdrawal&& from) noexcept : Withdrawal(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kAddressFieldNumber = 3, kIndexFieldNumber = 1, kValidatorIndexFieldNumber = 2, kAmountFieldNumber = 4, }; // .types.H160 address = 3; bool has_address() const; void clear_address() ; const ::types::H160& address() const; PROTOBUF_NODISCARD ::types::H160* release_address(); ::types::H160* mutable_address(); void set_allocated_address(::types::H160* value); void unsafe_arena_set_allocated_address(::types::H160* value); ::types::H160* unsafe_arena_release_address(); private: const ::types::H160& _internal_address() const; ::types::H160* _internal_mutable_address(); public: // uint64 index = 1; void clear_index() ; ::uint64_t index() const; void set_index(::uint64_t value); private: ::uint64_t _internal_index() const; void _internal_set_index(::uint64_t value); public: // uint64 validator_index = 2; void clear_validator_index() ; ::uint64_t validator_index() const; void set_validator_index(::uint64_t value); private: ::uint64_t _internal_validator_index() const; void _internal_set_validator_index(::uint64_t value); public: // uint64 amount = 4; void clear_amount() ; ::uint64_t amount() const; void set_amount(::uint64_t value); private: ::uint64_t _internal_amount() const; void _internal_set_amount(::uint64_t value); public: // @@protoc_insertion_point(class_scope:types.Withdrawal) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 2, 4, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_Withdrawal_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const Withdrawal& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H160* address_; ::uint64_t index_; ::uint64_t validator_index_; ::uint64_t amount_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class H512 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.H512) */ { public: inline H512() : H512(nullptr) {} ~H512() override; template explicit PROTOBUF_CONSTEXPR H512( ::google::protobuf::internal::ConstantInitialized); inline H512(const H512& from) : H512(nullptr, from) {} inline H512(H512&& from) noexcept : H512(nullptr, std::move(from)) {} inline H512& operator=(const H512& from) { CopyFrom(from); return *this; } inline H512& operator=(H512&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const H512& default_instance() { return *internal_default_instance(); } static inline const H512* internal_default_instance() { return reinterpret_cast( &_H512_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(H512& a, H512& b) { a.Swap(&b); } inline void Swap(H512* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(H512* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- H512* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const H512& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const H512& from) { H512::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(H512* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.H512"; } protected: explicit H512(::google::protobuf::Arena* arena); H512(::google::protobuf::Arena* arena, const H512& from); H512(::google::protobuf::Arena* arena, H512&& from) noexcept : H512(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHiFieldNumber = 1, kLoFieldNumber = 2, }; // .types.H256 hi = 1; bool has_hi() const; void clear_hi() ; const ::types::H256& hi() const; PROTOBUF_NODISCARD ::types::H256* release_hi(); ::types::H256* mutable_hi(); void set_allocated_hi(::types::H256* value); void unsafe_arena_set_allocated_hi(::types::H256* value); ::types::H256* unsafe_arena_release_hi(); private: const ::types::H256& _internal_hi() const; ::types::H256* _internal_mutable_hi(); public: // .types.H256 lo = 2; bool has_lo() const; void clear_lo() ; const ::types::H256& lo() const; PROTOBUF_NODISCARD ::types::H256* release_lo(); ::types::H256* mutable_lo(); void set_allocated_lo(::types::H256* value); void unsafe_arena_set_allocated_lo(::types::H256* value); ::types::H256* unsafe_arena_release_lo(); private: const ::types::H256& _internal_lo() const; ::types::H256* _internal_mutable_lo(); public: // @@protoc_insertion_point(class_scope:types.H512) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_H512_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const H512& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H256* hi_; ::types::H256* lo_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class H1024 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.H1024) */ { public: inline H1024() : H1024(nullptr) {} ~H1024() override; template explicit PROTOBUF_CONSTEXPR H1024( ::google::protobuf::internal::ConstantInitialized); inline H1024(const H1024& from) : H1024(nullptr, from) {} inline H1024(H1024&& from) noexcept : H1024(nullptr, std::move(from)) {} inline H1024& operator=(const H1024& from) { CopyFrom(from); return *this; } inline H1024& operator=(H1024&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const H1024& default_instance() { return *internal_default_instance(); } static inline const H1024* internal_default_instance() { return reinterpret_cast( &_H1024_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(H1024& a, H1024& b) { a.Swap(&b); } inline void Swap(H1024* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(H1024* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- H1024* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const H1024& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const H1024& from) { H1024::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(H1024* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.H1024"; } protected: explicit H1024(::google::protobuf::Arena* arena); H1024(::google::protobuf::Arena* arena, const H1024& from); H1024(::google::protobuf::Arena* arena, H1024&& from) noexcept : H1024(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHiFieldNumber = 1, kLoFieldNumber = 2, }; // .types.H512 hi = 1; bool has_hi() const; void clear_hi() ; const ::types::H512& hi() const; PROTOBUF_NODISCARD ::types::H512* release_hi(); ::types::H512* mutable_hi(); void set_allocated_hi(::types::H512* value); void unsafe_arena_set_allocated_hi(::types::H512* value); ::types::H512* unsafe_arena_release_hi(); private: const ::types::H512& _internal_hi() const; ::types::H512* _internal_mutable_hi(); public: // .types.H512 lo = 2; bool has_lo() const; void clear_lo() ; const ::types::H512& lo() const; PROTOBUF_NODISCARD ::types::H512* release_lo(); ::types::H512* mutable_lo(); void set_allocated_lo(::types::H512* value); void unsafe_arena_set_allocated_lo(::types::H512* value); ::types::H512* unsafe_arena_release_lo(); private: const ::types::H512& _internal_lo() const; ::types::H512* _internal_mutable_lo(); public: // @@protoc_insertion_point(class_scope:types.H1024) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_H1024_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const H1024& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H512* hi_; ::types::H512* lo_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class ExecutionPayloadBodyV1 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.ExecutionPayloadBodyV1) */ { public: inline ExecutionPayloadBodyV1() : ExecutionPayloadBodyV1(nullptr) {} ~ExecutionPayloadBodyV1() override; template explicit PROTOBUF_CONSTEXPR ExecutionPayloadBodyV1( ::google::protobuf::internal::ConstantInitialized); inline ExecutionPayloadBodyV1(const ExecutionPayloadBodyV1& from) : ExecutionPayloadBodyV1(nullptr, from) {} inline ExecutionPayloadBodyV1(ExecutionPayloadBodyV1&& from) noexcept : ExecutionPayloadBodyV1(nullptr, std::move(from)) {} inline ExecutionPayloadBodyV1& operator=(const ExecutionPayloadBodyV1& from) { CopyFrom(from); return *this; } inline ExecutionPayloadBodyV1& operator=(ExecutionPayloadBodyV1&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ExecutionPayloadBodyV1& default_instance() { return *internal_default_instance(); } static inline const ExecutionPayloadBodyV1* internal_default_instance() { return reinterpret_cast( &_ExecutionPayloadBodyV1_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(ExecutionPayloadBodyV1& a, ExecutionPayloadBodyV1& b) { a.Swap(&b); } inline void Swap(ExecutionPayloadBodyV1* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ExecutionPayloadBodyV1* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ExecutionPayloadBodyV1* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ExecutionPayloadBodyV1& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ExecutionPayloadBodyV1& from) { ExecutionPayloadBodyV1::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ExecutionPayloadBodyV1* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.ExecutionPayloadBodyV1"; } protected: explicit ExecutionPayloadBodyV1(::google::protobuf::Arena* arena); ExecutionPayloadBodyV1(::google::protobuf::Arena* arena, const ExecutionPayloadBodyV1& from); ExecutionPayloadBodyV1(::google::protobuf::Arena* arena, ExecutionPayloadBodyV1&& from) noexcept : ExecutionPayloadBodyV1(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTransactionsFieldNumber = 1, kWithdrawalsFieldNumber = 2, }; // repeated bytes transactions = 1; int transactions_size() const; private: int _internal_transactions_size() const; public: void clear_transactions() ; const std::string& transactions(int index) const; std::string* mutable_transactions(int index); void set_transactions(int index, const std::string& value); void set_transactions(int index, std::string&& value); void set_transactions(int index, const char* value); void set_transactions(int index, const void* value, std::size_t size); void set_transactions(int index, absl::string_view value); std::string* add_transactions(); void add_transactions(const std::string& value); void add_transactions(std::string&& value); void add_transactions(const char* value); void add_transactions(const void* value, std::size_t size); void add_transactions(absl::string_view value); const ::google::protobuf::RepeatedPtrField& transactions() const; ::google::protobuf::RepeatedPtrField* mutable_transactions(); private: const ::google::protobuf::RepeatedPtrField& _internal_transactions() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_transactions(); public: // repeated .types.Withdrawal withdrawals = 2; int withdrawals_size() const; private: int _internal_withdrawals_size() const; public: void clear_withdrawals() ; ::types::Withdrawal* mutable_withdrawals(int index); ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* mutable_withdrawals(); private: const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& _internal_withdrawals() const; ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* _internal_mutable_withdrawals(); public: const ::types::Withdrawal& withdrawals(int index) const; ::types::Withdrawal* add_withdrawals(); const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& withdrawals() const; // @@protoc_insertion_point(class_scope:types.ExecutionPayloadBodyV1) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 1, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ExecutionPayloadBodyV1_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ExecutionPayloadBodyV1& from_msg); ::google::protobuf::RepeatedPtrField transactions_; ::google::protobuf::RepeatedPtrField< ::types::Withdrawal > withdrawals_; mutable ::google::protobuf::internal::CachedSize _cached_size_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class H2048 final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.H2048) */ { public: inline H2048() : H2048(nullptr) {} ~H2048() override; template explicit PROTOBUF_CONSTEXPR H2048( ::google::protobuf::internal::ConstantInitialized); inline H2048(const H2048& from) : H2048(nullptr, from) {} inline H2048(H2048&& from) noexcept : H2048(nullptr, std::move(from)) {} inline H2048& operator=(const H2048& from) { CopyFrom(from); return *this; } inline H2048& operator=(H2048&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const H2048& default_instance() { return *internal_default_instance(); } static inline const H2048* internal_default_instance() { return reinterpret_cast( &_H2048_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(H2048& a, H2048& b) { a.Swap(&b); } inline void Swap(H2048* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(H2048* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- H2048* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const H2048& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const H2048& from) { H2048::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(H2048* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.H2048"; } protected: explicit H2048(::google::protobuf::Arena* arena); H2048(::google::protobuf::Arena* arena, const H2048& from); H2048(::google::protobuf::Arena* arena, H2048&& from) noexcept : H2048(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHiFieldNumber = 1, kLoFieldNumber = 2, }; // .types.H1024 hi = 1; bool has_hi() const; void clear_hi() ; const ::types::H1024& hi() const; PROTOBUF_NODISCARD ::types::H1024* release_hi(); ::types::H1024* mutable_hi(); void set_allocated_hi(::types::H1024* value); void unsafe_arena_set_allocated_hi(::types::H1024* value); ::types::H1024* unsafe_arena_release_hi(); private: const ::types::H1024& _internal_hi() const; ::types::H1024* _internal_mutable_hi(); public: // .types.H1024 lo = 2; bool has_lo() const; void clear_lo() ; const ::types::H1024& lo() const; PROTOBUF_NODISCARD ::types::H1024* release_lo(); ::types::H1024* mutable_lo(); void set_allocated_lo(::types::H1024* value); void unsafe_arena_set_allocated_lo(::types::H1024* value); ::types::H1024* unsafe_arena_release_lo(); private: const ::types::H1024& _internal_lo() const; ::types::H1024* _internal_mutable_lo(); public: // @@protoc_insertion_point(class_scope:types.H2048) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 1, 2, 2, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_H2048_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const H2048& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::types::H1024* hi_; ::types::H1024* lo_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // ------------------------------------------------------------------- class ExecutionPayload final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:types.ExecutionPayload) */ { public: inline ExecutionPayload() : ExecutionPayload(nullptr) {} ~ExecutionPayload() override; template explicit PROTOBUF_CONSTEXPR ExecutionPayload( ::google::protobuf::internal::ConstantInitialized); inline ExecutionPayload(const ExecutionPayload& from) : ExecutionPayload(nullptr, from) {} inline ExecutionPayload(ExecutionPayload&& from) noexcept : ExecutionPayload(nullptr, std::move(from)) {} inline ExecutionPayload& operator=(const ExecutionPayload& from) { CopyFrom(from); return *this; } inline ExecutionPayload& operator=(ExecutionPayload&& from) noexcept { if (this == &from) return *this; if (GetArena() == from.GetArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND { return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } static const ::google::protobuf::Descriptor* descriptor() { return GetDescriptor(); } static const ::google::protobuf::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::google::protobuf::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ExecutionPayload& default_instance() { return *internal_default_instance(); } static inline const ExecutionPayload* internal_default_instance() { return reinterpret_cast( &_ExecutionPayload_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(ExecutionPayload& a, ExecutionPayload& b) { a.Swap(&b); } inline void Swap(ExecutionPayload* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() != nullptr && GetArena() == other->GetArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetArena() == other->GetArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::google::protobuf::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ExecutionPayload* other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ExecutionPayload* New(::google::protobuf::Arena* arena = nullptr) const final { return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; void CopyFrom(const ExecutionPayload& from); using ::google::protobuf::Message::MergeFrom; void MergeFrom(const ExecutionPayload& from) { ExecutionPayload::MergeImpl(*this, from); } private: static void MergeImpl( ::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg); public: bool IsInitialized() const { return true; } ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; ::size_t ByteSizeLong() const final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const { return _impl_._cached_size_.Get(); } private: void SharedCtor(::google::protobuf::Arena* arena); void SharedDtor(); void InternalSwap(ExecutionPayload* other); private: friend class ::google::protobuf::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "types.ExecutionPayload"; } protected: explicit ExecutionPayload(::google::protobuf::Arena* arena); ExecutionPayload(::google::protobuf::Arena* arena, const ExecutionPayload& from); ExecutionPayload(::google::protobuf::Arena* arena, ExecutionPayload&& from) noexcept : ExecutionPayload(arena) { *this = ::std::move(from); } const ::google::protobuf::Message::ClassData* GetClassData() const final; public: ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kTransactionsFieldNumber = 15, kWithdrawalsFieldNumber = 16, kExtraDataFieldNumber = 12, kParentHashFieldNumber = 2, kCoinbaseFieldNumber = 3, kStateRootFieldNumber = 4, kReceiptRootFieldNumber = 5, kLogsBloomFieldNumber = 6, kPrevRandaoFieldNumber = 7, kBaseFeePerGasFieldNumber = 13, kBlockHashFieldNumber = 14, kBlockNumberFieldNumber = 8, kGasLimitFieldNumber = 9, kGasUsedFieldNumber = 10, kTimestampFieldNumber = 11, kBlobGasUsedFieldNumber = 17, kExcessBlobGasFieldNumber = 18, kVersionFieldNumber = 1, }; // repeated bytes transactions = 15; int transactions_size() const; private: int _internal_transactions_size() const; public: void clear_transactions() ; const std::string& transactions(int index) const; std::string* mutable_transactions(int index); void set_transactions(int index, const std::string& value); void set_transactions(int index, std::string&& value); void set_transactions(int index, const char* value); void set_transactions(int index, const void* value, std::size_t size); void set_transactions(int index, absl::string_view value); std::string* add_transactions(); void add_transactions(const std::string& value); void add_transactions(std::string&& value); void add_transactions(const char* value); void add_transactions(const void* value, std::size_t size); void add_transactions(absl::string_view value); const ::google::protobuf::RepeatedPtrField& transactions() const; ::google::protobuf::RepeatedPtrField* mutable_transactions(); private: const ::google::protobuf::RepeatedPtrField& _internal_transactions() const; ::google::protobuf::RepeatedPtrField* _internal_mutable_transactions(); public: // repeated .types.Withdrawal withdrawals = 16; int withdrawals_size() const; private: int _internal_withdrawals_size() const; public: void clear_withdrawals() ; ::types::Withdrawal* mutable_withdrawals(int index); ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* mutable_withdrawals(); private: const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& _internal_withdrawals() const; ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* _internal_mutable_withdrawals(); public: const ::types::Withdrawal& withdrawals(int index) const; ::types::Withdrawal* add_withdrawals(); const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& withdrawals() const; // bytes extra_data = 12; void clear_extra_data() ; const std::string& extra_data() const; template void set_extra_data(Arg_&& arg, Args_... args); std::string* mutable_extra_data(); PROTOBUF_NODISCARD std::string* release_extra_data(); void set_allocated_extra_data(std::string* value); private: const std::string& _internal_extra_data() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_extra_data( const std::string& value); std::string* _internal_mutable_extra_data(); public: // .types.H256 parent_hash = 2; bool has_parent_hash() const; void clear_parent_hash() ; const ::types::H256& parent_hash() const; PROTOBUF_NODISCARD ::types::H256* release_parent_hash(); ::types::H256* mutable_parent_hash(); void set_allocated_parent_hash(::types::H256* value); void unsafe_arena_set_allocated_parent_hash(::types::H256* value); ::types::H256* unsafe_arena_release_parent_hash(); private: const ::types::H256& _internal_parent_hash() const; ::types::H256* _internal_mutable_parent_hash(); public: // .types.H160 coinbase = 3; bool has_coinbase() const; void clear_coinbase() ; const ::types::H160& coinbase() const; PROTOBUF_NODISCARD ::types::H160* release_coinbase(); ::types::H160* mutable_coinbase(); void set_allocated_coinbase(::types::H160* value); void unsafe_arena_set_allocated_coinbase(::types::H160* value); ::types::H160* unsafe_arena_release_coinbase(); private: const ::types::H160& _internal_coinbase() const; ::types::H160* _internal_mutable_coinbase(); public: // .types.H256 state_root = 4; bool has_state_root() const; void clear_state_root() ; const ::types::H256& state_root() const; PROTOBUF_NODISCARD ::types::H256* release_state_root(); ::types::H256* mutable_state_root(); void set_allocated_state_root(::types::H256* value); void unsafe_arena_set_allocated_state_root(::types::H256* value); ::types::H256* unsafe_arena_release_state_root(); private: const ::types::H256& _internal_state_root() const; ::types::H256* _internal_mutable_state_root(); public: // .types.H256 receipt_root = 5; bool has_receipt_root() const; void clear_receipt_root() ; const ::types::H256& receipt_root() const; PROTOBUF_NODISCARD ::types::H256* release_receipt_root(); ::types::H256* mutable_receipt_root(); void set_allocated_receipt_root(::types::H256* value); void unsafe_arena_set_allocated_receipt_root(::types::H256* value); ::types::H256* unsafe_arena_release_receipt_root(); private: const ::types::H256& _internal_receipt_root() const; ::types::H256* _internal_mutable_receipt_root(); public: // .types.H2048 logs_bloom = 6; bool has_logs_bloom() const; void clear_logs_bloom() ; const ::types::H2048& logs_bloom() const; PROTOBUF_NODISCARD ::types::H2048* release_logs_bloom(); ::types::H2048* mutable_logs_bloom(); void set_allocated_logs_bloom(::types::H2048* value); void unsafe_arena_set_allocated_logs_bloom(::types::H2048* value); ::types::H2048* unsafe_arena_release_logs_bloom(); private: const ::types::H2048& _internal_logs_bloom() const; ::types::H2048* _internal_mutable_logs_bloom(); public: // .types.H256 prev_randao = 7; bool has_prev_randao() const; void clear_prev_randao() ; const ::types::H256& prev_randao() const; PROTOBUF_NODISCARD ::types::H256* release_prev_randao(); ::types::H256* mutable_prev_randao(); void set_allocated_prev_randao(::types::H256* value); void unsafe_arena_set_allocated_prev_randao(::types::H256* value); ::types::H256* unsafe_arena_release_prev_randao(); private: const ::types::H256& _internal_prev_randao() const; ::types::H256* _internal_mutable_prev_randao(); public: // .types.H256 base_fee_per_gas = 13; bool has_base_fee_per_gas() const; void clear_base_fee_per_gas() ; const ::types::H256& base_fee_per_gas() const; PROTOBUF_NODISCARD ::types::H256* release_base_fee_per_gas(); ::types::H256* mutable_base_fee_per_gas(); void set_allocated_base_fee_per_gas(::types::H256* value); void unsafe_arena_set_allocated_base_fee_per_gas(::types::H256* value); ::types::H256* unsafe_arena_release_base_fee_per_gas(); private: const ::types::H256& _internal_base_fee_per_gas() const; ::types::H256* _internal_mutable_base_fee_per_gas(); public: // .types.H256 block_hash = 14; bool has_block_hash() const; void clear_block_hash() ; const ::types::H256& block_hash() const; PROTOBUF_NODISCARD ::types::H256* release_block_hash(); ::types::H256* mutable_block_hash(); void set_allocated_block_hash(::types::H256* value); void unsafe_arena_set_allocated_block_hash(::types::H256* value); ::types::H256* unsafe_arena_release_block_hash(); private: const ::types::H256& _internal_block_hash() const; ::types::H256* _internal_mutable_block_hash(); public: // uint64 block_number = 8; void clear_block_number() ; ::uint64_t block_number() const; void set_block_number(::uint64_t value); private: ::uint64_t _internal_block_number() const; void _internal_set_block_number(::uint64_t value); public: // uint64 gas_limit = 9; void clear_gas_limit() ; ::uint64_t gas_limit() const; void set_gas_limit(::uint64_t value); private: ::uint64_t _internal_gas_limit() const; void _internal_set_gas_limit(::uint64_t value); public: // uint64 gas_used = 10; void clear_gas_used() ; ::uint64_t gas_used() const; void set_gas_used(::uint64_t value); private: ::uint64_t _internal_gas_used() const; void _internal_set_gas_used(::uint64_t value); public: // uint64 timestamp = 11; void clear_timestamp() ; ::uint64_t timestamp() const; void set_timestamp(::uint64_t value); private: ::uint64_t _internal_timestamp() const; void _internal_set_timestamp(::uint64_t value); public: // optional uint64 blob_gas_used = 17; bool has_blob_gas_used() const; void clear_blob_gas_used() ; ::uint64_t blob_gas_used() const; void set_blob_gas_used(::uint64_t value); private: ::uint64_t _internal_blob_gas_used() const; void _internal_set_blob_gas_used(::uint64_t value); public: // optional uint64 excess_blob_gas = 18; bool has_excess_blob_gas() const; void clear_excess_blob_gas() ; ::uint64_t excess_blob_gas() const; void set_excess_blob_gas(::uint64_t value); private: ::uint64_t _internal_excess_blob_gas() const; void _internal_set_excess_blob_gas(::uint64_t value); public: // uint32 version = 1; void clear_version() ; ::uint32_t version() const; void set_version(::uint32_t value); private: ::uint32_t _internal_version() const; void _internal_set_version(::uint32_t value); public: // @@protoc_insertion_point(class_scope:types.ExecutionPayload) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable< 5, 18, 9, 0, 2> _table_; static constexpr const void* _raw_default_instance_ = &_ExecutionPayload_default_instance_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; template friend class ::google::protobuf::Arena::InternalHelper; using InternalArenaConstructable_ = void; using DestructorSkippable_ = void; struct Impl_ { inline explicit constexpr Impl_( ::google::protobuf::internal::ConstantInitialized) noexcept; inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena); inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, const Impl_& from, const ExecutionPayload& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; mutable ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::RepeatedPtrField transactions_; ::google::protobuf::RepeatedPtrField< ::types::Withdrawal > withdrawals_; ::google::protobuf::internal::ArenaStringPtr extra_data_; ::types::H256* parent_hash_; ::types::H160* coinbase_; ::types::H256* state_root_; ::types::H256* receipt_root_; ::types::H2048* logs_bloom_; ::types::H256* prev_randao_; ::types::H256* base_fee_per_gas_; ::types::H256* block_hash_; ::uint64_t block_number_; ::uint64_t gas_limit_; ::uint64_t gas_used_; ::uint64_t timestamp_; ::uint64_t blob_gas_used_; ::uint64_t excess_blob_gas_; ::uint32_t version_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_types_2ftypes_2eproto; }; // =================================================================== static const int kServiceMajorVersionFieldNumber = 50001; extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FileOptions, ::google::protobuf::internal::PrimitiveTypeTraits< ::uint32_t >, 13, false> service_major_version; static const int kServiceMinorVersionFieldNumber = 50002; extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FileOptions, ::google::protobuf::internal::PrimitiveTypeTraits< ::uint32_t >, 13, false> service_minor_version; static const int kServicePatchVersionFieldNumber = 50003; extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FileOptions, ::google::protobuf::internal::PrimitiveTypeTraits< ::uint32_t >, 13, false> service_patch_version; // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // H128 // uint64 hi = 1; inline void H128::clear_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hi_ = ::uint64_t{0u}; } inline ::uint64_t H128::hi() const { // @@protoc_insertion_point(field_get:types.H128.hi) return _internal_hi(); } inline void H128::set_hi(::uint64_t value) { _internal_set_hi(value); // @@protoc_insertion_point(field_set:types.H128.hi) } inline ::uint64_t H128::_internal_hi() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.hi_; } inline void H128::_internal_set_hi(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.hi_ = value; } // uint64 lo = 2; inline void H128::clear_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lo_ = ::uint64_t{0u}; } inline ::uint64_t H128::lo() const { // @@protoc_insertion_point(field_get:types.H128.lo) return _internal_lo(); } inline void H128::set_lo(::uint64_t value) { _internal_set_lo(value); // @@protoc_insertion_point(field_set:types.H128.lo) } inline ::uint64_t H128::_internal_lo() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.lo_; } inline void H128::_internal_set_lo(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lo_ = value; } // ------------------------------------------------------------------- // H160 // .types.H128 hi = 1; inline bool H160::has_hi() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hi_ != nullptr); return value; } inline void H160::clear_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ != nullptr) _impl_.hi_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::H128& H160::_internal_hi() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H128* p = _impl_.hi_; return p != nullptr ? *p : reinterpret_cast(::types::_H128_default_instance_); } inline const ::types::H128& H160::hi() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H160.hi) return _internal_hi(); } inline void H160::unsafe_arena_set_allocated_hi(::types::H128* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hi_); } _impl_.hi_ = reinterpret_cast<::types::H128*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H160.hi) } inline ::types::H128* H160::release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H128* released = _impl_.hi_; _impl_.hi_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H128* H160::unsafe_arena_release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H160.hi) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H128* temp = _impl_.hi_; _impl_.hi_ = nullptr; return temp; } inline ::types::H128* H160::_internal_mutable_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H128>(GetArena()); _impl_.hi_ = reinterpret_cast<::types::H128*>(p); } return _impl_.hi_; } inline ::types::H128* H160::mutable_hi() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H128* _msg = _internal_mutable_hi(); // @@protoc_insertion_point(field_mutable:types.H160.hi) return _msg; } inline void H160::set_allocated_hi(::types::H128* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.hi_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hi_ = reinterpret_cast<::types::H128*>(value); // @@protoc_insertion_point(field_set_allocated:types.H160.hi) } // uint32 lo = 2; inline void H160::clear_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lo_ = 0u; } inline ::uint32_t H160::lo() const { // @@protoc_insertion_point(field_get:types.H160.lo) return _internal_lo(); } inline void H160::set_lo(::uint32_t value) { _internal_set_lo(value); // @@protoc_insertion_point(field_set:types.H160.lo) } inline ::uint32_t H160::_internal_lo() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.lo_; } inline void H160::_internal_set_lo(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lo_ = value; } // ------------------------------------------------------------------- // H256 // .types.H128 hi = 1; inline bool H256::has_hi() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hi_ != nullptr); return value; } inline void H256::clear_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ != nullptr) _impl_.hi_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::H128& H256::_internal_hi() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H128* p = _impl_.hi_; return p != nullptr ? *p : reinterpret_cast(::types::_H128_default_instance_); } inline const ::types::H128& H256::hi() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H256.hi) return _internal_hi(); } inline void H256::unsafe_arena_set_allocated_hi(::types::H128* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hi_); } _impl_.hi_ = reinterpret_cast<::types::H128*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H256.hi) } inline ::types::H128* H256::release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H128* released = _impl_.hi_; _impl_.hi_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H128* H256::unsafe_arena_release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H256.hi) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H128* temp = _impl_.hi_; _impl_.hi_ = nullptr; return temp; } inline ::types::H128* H256::_internal_mutable_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H128>(GetArena()); _impl_.hi_ = reinterpret_cast<::types::H128*>(p); } return _impl_.hi_; } inline ::types::H128* H256::mutable_hi() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H128* _msg = _internal_mutable_hi(); // @@protoc_insertion_point(field_mutable:types.H256.hi) return _msg; } inline void H256::set_allocated_hi(::types::H128* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.hi_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hi_ = reinterpret_cast<::types::H128*>(value); // @@protoc_insertion_point(field_set_allocated:types.H256.hi) } // .types.H128 lo = 2; inline bool H256::has_lo() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.lo_ != nullptr); return value; } inline void H256::clear_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ != nullptr) _impl_.lo_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } inline const ::types::H128& H256::_internal_lo() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H128* p = _impl_.lo_; return p != nullptr ? *p : reinterpret_cast(::types::_H128_default_instance_); } inline const ::types::H128& H256::lo() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H256.lo) return _internal_lo(); } inline void H256::unsafe_arena_set_allocated_lo(::types::H128* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.lo_); } _impl_.lo_ = reinterpret_cast<::types::H128*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H256.lo) } inline ::types::H128* H256::release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H128* released = _impl_.lo_; _impl_.lo_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H128* H256::unsafe_arena_release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H256.lo) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H128* temp = _impl_.lo_; _impl_.lo_ = nullptr; return temp; } inline ::types::H128* H256::_internal_mutable_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H128>(GetArena()); _impl_.lo_ = reinterpret_cast<::types::H128*>(p); } return _impl_.lo_; } inline ::types::H128* H256::mutable_lo() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H128* _msg = _internal_mutable_lo(); // @@protoc_insertion_point(field_mutable:types.H256.lo) return _msg; } inline void H256::set_allocated_lo(::types::H128* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.lo_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.lo_ = reinterpret_cast<::types::H128*>(value); // @@protoc_insertion_point(field_set_allocated:types.H256.lo) } // ------------------------------------------------------------------- // H512 // .types.H256 hi = 1; inline bool H512::has_hi() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hi_ != nullptr); return value; } inline void H512::clear_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ != nullptr) _impl_.hi_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::H256& H512::_internal_hi() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.hi_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& H512::hi() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H512.hi) return _internal_hi(); } inline void H512::unsafe_arena_set_allocated_hi(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hi_); } _impl_.hi_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H512.hi) } inline ::types::H256* H512::release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.hi_; _impl_.hi_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* H512::unsafe_arena_release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H512.hi) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.hi_; _impl_.hi_ = nullptr; return temp; } inline ::types::H256* H512::_internal_mutable_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.hi_ = reinterpret_cast<::types::H256*>(p); } return _impl_.hi_; } inline ::types::H256* H512::mutable_hi() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_hi(); // @@protoc_insertion_point(field_mutable:types.H512.hi) return _msg; } inline void H512::set_allocated_hi(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.hi_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hi_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.H512.hi) } // .types.H256 lo = 2; inline bool H512::has_lo() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.lo_ != nullptr); return value; } inline void H512::clear_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ != nullptr) _impl_.lo_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } inline const ::types::H256& H512::_internal_lo() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.lo_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& H512::lo() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H512.lo) return _internal_lo(); } inline void H512::unsafe_arena_set_allocated_lo(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.lo_); } _impl_.lo_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H512.lo) } inline ::types::H256* H512::release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* released = _impl_.lo_; _impl_.lo_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* H512::unsafe_arena_release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H512.lo) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H256* temp = _impl_.lo_; _impl_.lo_ = nullptr; return temp; } inline ::types::H256* H512::_internal_mutable_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.lo_ = reinterpret_cast<::types::H256*>(p); } return _impl_.lo_; } inline ::types::H256* H512::mutable_lo() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H256* _msg = _internal_mutable_lo(); // @@protoc_insertion_point(field_mutable:types.H512.lo) return _msg; } inline void H512::set_allocated_lo(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.lo_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.lo_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.H512.lo) } // ------------------------------------------------------------------- // H1024 // .types.H512 hi = 1; inline bool H1024::has_hi() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hi_ != nullptr); return value; } inline void H1024::clear_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ != nullptr) _impl_.hi_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::H512& H1024::_internal_hi() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.hi_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& H1024::hi() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H1024.hi) return _internal_hi(); } inline void H1024::unsafe_arena_set_allocated_hi(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hi_); } _impl_.hi_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H1024.hi) } inline ::types::H512* H1024::release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* released = _impl_.hi_; _impl_.hi_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* H1024::unsafe_arena_release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H1024.hi) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H512* temp = _impl_.hi_; _impl_.hi_ = nullptr; return temp; } inline ::types::H512* H1024::_internal_mutable_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.hi_ = reinterpret_cast<::types::H512*>(p); } return _impl_.hi_; } inline ::types::H512* H1024::mutable_hi() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H512* _msg = _internal_mutable_hi(); // @@protoc_insertion_point(field_mutable:types.H1024.hi) return _msg; } inline void H1024::set_allocated_hi(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.hi_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hi_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:types.H1024.hi) } // .types.H512 lo = 2; inline bool H1024::has_lo() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.lo_ != nullptr); return value; } inline void H1024::clear_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ != nullptr) _impl_.lo_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } inline const ::types::H512& H1024::_internal_lo() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H512* p = _impl_.lo_; return p != nullptr ? *p : reinterpret_cast(::types::_H512_default_instance_); } inline const ::types::H512& H1024::lo() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H1024.lo) return _internal_lo(); } inline void H1024::unsafe_arena_set_allocated_lo(::types::H512* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.lo_); } _impl_.lo_ = reinterpret_cast<::types::H512*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H1024.lo) } inline ::types::H512* H1024::release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H512* released = _impl_.lo_; _impl_.lo_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H512* H1024::unsafe_arena_release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H1024.lo) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H512* temp = _impl_.lo_; _impl_.lo_ = nullptr; return temp; } inline ::types::H512* H1024::_internal_mutable_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H512>(GetArena()); _impl_.lo_ = reinterpret_cast<::types::H512*>(p); } return _impl_.lo_; } inline ::types::H512* H1024::mutable_lo() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H512* _msg = _internal_mutable_lo(); // @@protoc_insertion_point(field_mutable:types.H1024.lo) return _msg; } inline void H1024::set_allocated_lo(::types::H512* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.lo_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.lo_ = reinterpret_cast<::types::H512*>(value); // @@protoc_insertion_point(field_set_allocated:types.H1024.lo) } // ------------------------------------------------------------------- // H2048 // .types.H1024 hi = 1; inline bool H2048::has_hi() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.hi_ != nullptr); return value; } inline void H2048::clear_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ != nullptr) _impl_.hi_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::H1024& H2048::_internal_hi() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H1024* p = _impl_.hi_; return p != nullptr ? *p : reinterpret_cast(::types::_H1024_default_instance_); } inline const ::types::H1024& H2048::hi() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H2048.hi) return _internal_hi(); } inline void H2048::unsafe_arena_set_allocated_hi(::types::H1024* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.hi_); } _impl_.hi_ = reinterpret_cast<::types::H1024*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H2048.hi) } inline ::types::H1024* H2048::release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H1024* released = _impl_.hi_; _impl_.hi_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H1024* H2048::unsafe_arena_release_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H2048.hi) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H1024* temp = _impl_.hi_; _impl_.hi_ = nullptr; return temp; } inline ::types::H1024* H2048::_internal_mutable_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.hi_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H1024>(GetArena()); _impl_.hi_ = reinterpret_cast<::types::H1024*>(p); } return _impl_.hi_; } inline ::types::H1024* H2048::mutable_hi() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H1024* _msg = _internal_mutable_hi(); // @@protoc_insertion_point(field_mutable:types.H2048.hi) return _msg; } inline void H2048::set_allocated_hi(::types::H1024* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.hi_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.hi_ = reinterpret_cast<::types::H1024*>(value); // @@protoc_insertion_point(field_set_allocated:types.H2048.hi) } // .types.H1024 lo = 2; inline bool H2048::has_lo() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.lo_ != nullptr); return value; } inline void H2048::clear_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ != nullptr) _impl_.lo_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } inline const ::types::H1024& H2048::_internal_lo() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H1024* p = _impl_.lo_; return p != nullptr ? *p : reinterpret_cast(::types::_H1024_default_instance_); } inline const ::types::H1024& H2048::lo() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.H2048.lo) return _internal_lo(); } inline void H2048::unsafe_arena_set_allocated_lo(::types::H1024* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.lo_); } _impl_.lo_ = reinterpret_cast<::types::H1024*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.H2048.lo) } inline ::types::H1024* H2048::release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H1024* released = _impl_.lo_; _impl_.lo_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H1024* H2048::unsafe_arena_release_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.H2048.lo) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H1024* temp = _impl_.lo_; _impl_.lo_ = nullptr; return temp; } inline ::types::H1024* H2048::_internal_mutable_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.lo_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H1024>(GetArena()); _impl_.lo_ = reinterpret_cast<::types::H1024*>(p); } return _impl_.lo_; } inline ::types::H1024* H2048::mutable_lo() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H1024* _msg = _internal_mutable_lo(); // @@protoc_insertion_point(field_mutable:types.H2048.lo) return _msg; } inline void H2048::set_allocated_lo(::types::H1024* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.lo_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.lo_ = reinterpret_cast<::types::H1024*>(value); // @@protoc_insertion_point(field_set_allocated:types.H2048.lo) } // ------------------------------------------------------------------- // VersionReply // uint32 major = 1; inline void VersionReply::clear_major() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.major_ = 0u; } inline ::uint32_t VersionReply::major() const { // @@protoc_insertion_point(field_get:types.VersionReply.major) return _internal_major(); } inline void VersionReply::set_major(::uint32_t value) { _internal_set_major(value); // @@protoc_insertion_point(field_set:types.VersionReply.major) } inline ::uint32_t VersionReply::_internal_major() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.major_; } inline void VersionReply::_internal_set_major(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.major_ = value; } // uint32 minor = 2; inline void VersionReply::clear_minor() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.minor_ = 0u; } inline ::uint32_t VersionReply::minor() const { // @@protoc_insertion_point(field_get:types.VersionReply.minor) return _internal_minor(); } inline void VersionReply::set_minor(::uint32_t value) { _internal_set_minor(value); // @@protoc_insertion_point(field_set:types.VersionReply.minor) } inline ::uint32_t VersionReply::_internal_minor() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.minor_; } inline void VersionReply::_internal_set_minor(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.minor_ = value; } // uint32 patch = 3; inline void VersionReply::clear_patch() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.patch_ = 0u; } inline ::uint32_t VersionReply::patch() const { // @@protoc_insertion_point(field_get:types.VersionReply.patch) return _internal_patch(); } inline void VersionReply::set_patch(::uint32_t value) { _internal_set_patch(value); // @@protoc_insertion_point(field_set:types.VersionReply.patch) } inline ::uint32_t VersionReply::_internal_patch() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.patch_; } inline void VersionReply::_internal_set_patch(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.patch_ = value; } // ------------------------------------------------------------------- // ExecutionPayload // uint32 version = 1; inline void ExecutionPayload::clear_version() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_ = 0u; } inline ::uint32_t ExecutionPayload::version() const { // @@protoc_insertion_point(field_get:types.ExecutionPayload.version) return _internal_version(); } inline void ExecutionPayload::set_version(::uint32_t value) { _internal_set_version(value); // @@protoc_insertion_point(field_set:types.ExecutionPayload.version) } inline ::uint32_t ExecutionPayload::_internal_version() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.version_; } inline void ExecutionPayload::_internal_set_version(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.version_ = value; } // .types.H256 parent_hash = 2; inline bool ExecutionPayload::has_parent_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.parent_hash_ != nullptr); return value; } inline void ExecutionPayload::clear_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_hash_ != nullptr) _impl_.parent_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::H256& ExecutionPayload::_internal_parent_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.parent_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ExecutionPayload::parent_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.parent_hash) return _internal_parent_hash(); } inline void ExecutionPayload::unsafe_arena_set_allocated_parent_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.parent_hash_); } _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.parent_hash) } inline ::types::H256* ExecutionPayload::release_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* released = _impl_.parent_hash_; _impl_.parent_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ExecutionPayload::unsafe_arena_release_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.parent_hash) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H256* temp = _impl_.parent_hash_; _impl_.parent_hash_ = nullptr; return temp; } inline ::types::H256* ExecutionPayload::_internal_mutable_parent_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.parent_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.parent_hash_; } inline ::types::H256* ExecutionPayload::mutable_parent_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H256* _msg = _internal_mutable_parent_hash(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.parent_hash) return _msg; } inline void ExecutionPayload::set_allocated_parent_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.parent_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.parent_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.parent_hash) } // .types.H160 coinbase = 3; inline bool ExecutionPayload::has_coinbase() const { bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || _impl_.coinbase_ != nullptr); return value; } inline void ExecutionPayload::clear_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.coinbase_ != nullptr) _impl_.coinbase_->Clear(); _impl_._has_bits_[0] &= ~0x00000002u; } inline const ::types::H160& ExecutionPayload::_internal_coinbase() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.coinbase_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& ExecutionPayload::coinbase() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.coinbase) return _internal_coinbase(); } inline void ExecutionPayload::unsafe_arena_set_allocated_coinbase(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.coinbase_); } _impl_.coinbase_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.coinbase) } inline ::types::H160* ExecutionPayload::release_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000002u; ::types::H160* released = _impl_.coinbase_; _impl_.coinbase_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* ExecutionPayload::unsafe_arena_release_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.coinbase) _impl_._has_bits_[0] &= ~0x00000002u; ::types::H160* temp = _impl_.coinbase_; _impl_.coinbase_ = nullptr; return temp; } inline ::types::H160* ExecutionPayload::_internal_mutable_coinbase() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.coinbase_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.coinbase_ = reinterpret_cast<::types::H160*>(p); } return _impl_.coinbase_; } inline ::types::H160* ExecutionPayload::mutable_coinbase() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000002u; ::types::H160* _msg = _internal_mutable_coinbase(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.coinbase) return _msg; } inline void ExecutionPayload::set_allocated_coinbase(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.coinbase_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000002u; } else { _impl_._has_bits_[0] &= ~0x00000002u; } _impl_.coinbase_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.coinbase) } // .types.H256 state_root = 4; inline bool ExecutionPayload::has_state_root() const { bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || _impl_.state_root_ != nullptr); return value; } inline void ExecutionPayload::clear_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.state_root_ != nullptr) _impl_.state_root_->Clear(); _impl_._has_bits_[0] &= ~0x00000004u; } inline const ::types::H256& ExecutionPayload::_internal_state_root() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.state_root_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ExecutionPayload::state_root() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.state_root) return _internal_state_root(); } inline void ExecutionPayload::unsafe_arena_set_allocated_state_root(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.state_root_); } _impl_.state_root_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.state_root) } inline ::types::H256* ExecutionPayload::release_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000004u; ::types::H256* released = _impl_.state_root_; _impl_.state_root_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ExecutionPayload::unsafe_arena_release_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.state_root) _impl_._has_bits_[0] &= ~0x00000004u; ::types::H256* temp = _impl_.state_root_; _impl_.state_root_ = nullptr; return temp; } inline ::types::H256* ExecutionPayload::_internal_mutable_state_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.state_root_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.state_root_ = reinterpret_cast<::types::H256*>(p); } return _impl_.state_root_; } inline ::types::H256* ExecutionPayload::mutable_state_root() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000004u; ::types::H256* _msg = _internal_mutable_state_root(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.state_root) return _msg; } inline void ExecutionPayload::set_allocated_state_root(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.state_root_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000004u; } else { _impl_._has_bits_[0] &= ~0x00000004u; } _impl_.state_root_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.state_root) } // .types.H256 receipt_root = 5; inline bool ExecutionPayload::has_receipt_root() const { bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || _impl_.receipt_root_ != nullptr); return value; } inline void ExecutionPayload::clear_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.receipt_root_ != nullptr) _impl_.receipt_root_->Clear(); _impl_._has_bits_[0] &= ~0x00000008u; } inline const ::types::H256& ExecutionPayload::_internal_receipt_root() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.receipt_root_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ExecutionPayload::receipt_root() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.receipt_root) return _internal_receipt_root(); } inline void ExecutionPayload::unsafe_arena_set_allocated_receipt_root(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.receipt_root_); } _impl_.receipt_root_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.receipt_root) } inline ::types::H256* ExecutionPayload::release_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000008u; ::types::H256* released = _impl_.receipt_root_; _impl_.receipt_root_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ExecutionPayload::unsafe_arena_release_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.receipt_root) _impl_._has_bits_[0] &= ~0x00000008u; ::types::H256* temp = _impl_.receipt_root_; _impl_.receipt_root_ = nullptr; return temp; } inline ::types::H256* ExecutionPayload::_internal_mutable_receipt_root() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.receipt_root_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.receipt_root_ = reinterpret_cast<::types::H256*>(p); } return _impl_.receipt_root_; } inline ::types::H256* ExecutionPayload::mutable_receipt_root() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000008u; ::types::H256* _msg = _internal_mutable_receipt_root(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.receipt_root) return _msg; } inline void ExecutionPayload::set_allocated_receipt_root(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.receipt_root_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000008u; } else { _impl_._has_bits_[0] &= ~0x00000008u; } _impl_.receipt_root_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.receipt_root) } // .types.H2048 logs_bloom = 6; inline bool ExecutionPayload::has_logs_bloom() const { bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; PROTOBUF_ASSUME(!value || _impl_.logs_bloom_ != nullptr); return value; } inline void ExecutionPayload::clear_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.logs_bloom_ != nullptr) _impl_.logs_bloom_->Clear(); _impl_._has_bits_[0] &= ~0x00000010u; } inline const ::types::H2048& ExecutionPayload::_internal_logs_bloom() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H2048* p = _impl_.logs_bloom_; return p != nullptr ? *p : reinterpret_cast(::types::_H2048_default_instance_); } inline const ::types::H2048& ExecutionPayload::logs_bloom() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.logs_bloom) return _internal_logs_bloom(); } inline void ExecutionPayload::unsafe_arena_set_allocated_logs_bloom(::types::H2048* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.logs_bloom_); } _impl_.logs_bloom_ = reinterpret_cast<::types::H2048*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000010u; } else { _impl_._has_bits_[0] &= ~0x00000010u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.logs_bloom) } inline ::types::H2048* ExecutionPayload::release_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000010u; ::types::H2048* released = _impl_.logs_bloom_; _impl_.logs_bloom_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H2048* ExecutionPayload::unsafe_arena_release_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.logs_bloom) _impl_._has_bits_[0] &= ~0x00000010u; ::types::H2048* temp = _impl_.logs_bloom_; _impl_.logs_bloom_ = nullptr; return temp; } inline ::types::H2048* ExecutionPayload::_internal_mutable_logs_bloom() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.logs_bloom_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H2048>(GetArena()); _impl_.logs_bloom_ = reinterpret_cast<::types::H2048*>(p); } return _impl_.logs_bloom_; } inline ::types::H2048* ExecutionPayload::mutable_logs_bloom() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000010u; ::types::H2048* _msg = _internal_mutable_logs_bloom(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.logs_bloom) return _msg; } inline void ExecutionPayload::set_allocated_logs_bloom(::types::H2048* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.logs_bloom_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000010u; } else { _impl_._has_bits_[0] &= ~0x00000010u; } _impl_.logs_bloom_ = reinterpret_cast<::types::H2048*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.logs_bloom) } // .types.H256 prev_randao = 7; inline bool ExecutionPayload::has_prev_randao() const { bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; PROTOBUF_ASSUME(!value || _impl_.prev_randao_ != nullptr); return value; } inline void ExecutionPayload::clear_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.prev_randao_ != nullptr) _impl_.prev_randao_->Clear(); _impl_._has_bits_[0] &= ~0x00000020u; } inline const ::types::H256& ExecutionPayload::_internal_prev_randao() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.prev_randao_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ExecutionPayload::prev_randao() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.prev_randao) return _internal_prev_randao(); } inline void ExecutionPayload::unsafe_arena_set_allocated_prev_randao(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.prev_randao_); } _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000020u; } else { _impl_._has_bits_[0] &= ~0x00000020u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.prev_randao) } inline ::types::H256* ExecutionPayload::release_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000020u; ::types::H256* released = _impl_.prev_randao_; _impl_.prev_randao_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ExecutionPayload::unsafe_arena_release_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.prev_randao) _impl_._has_bits_[0] &= ~0x00000020u; ::types::H256* temp = _impl_.prev_randao_; _impl_.prev_randao_ = nullptr; return temp; } inline ::types::H256* ExecutionPayload::_internal_mutable_prev_randao() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.prev_randao_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(p); } return _impl_.prev_randao_; } inline ::types::H256* ExecutionPayload::mutable_prev_randao() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000020u; ::types::H256* _msg = _internal_mutable_prev_randao(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.prev_randao) return _msg; } inline void ExecutionPayload::set_allocated_prev_randao(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.prev_randao_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000020u; } else { _impl_._has_bits_[0] &= ~0x00000020u; } _impl_.prev_randao_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.prev_randao) } // uint64 block_number = 8; inline void ExecutionPayload::clear_block_number() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = ::uint64_t{0u}; } inline ::uint64_t ExecutionPayload::block_number() const { // @@protoc_insertion_point(field_get:types.ExecutionPayload.block_number) return _internal_block_number(); } inline void ExecutionPayload::set_block_number(::uint64_t value) { _internal_set_block_number(value); // @@protoc_insertion_point(field_set:types.ExecutionPayload.block_number) } inline ::uint64_t ExecutionPayload::_internal_block_number() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.block_number_; } inline void ExecutionPayload::_internal_set_block_number(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.block_number_ = value; } // uint64 gas_limit = 9; inline void ExecutionPayload::clear_gas_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_limit_ = ::uint64_t{0u}; } inline ::uint64_t ExecutionPayload::gas_limit() const { // @@protoc_insertion_point(field_get:types.ExecutionPayload.gas_limit) return _internal_gas_limit(); } inline void ExecutionPayload::set_gas_limit(::uint64_t value) { _internal_set_gas_limit(value); // @@protoc_insertion_point(field_set:types.ExecutionPayload.gas_limit) } inline ::uint64_t ExecutionPayload::_internal_gas_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.gas_limit_; } inline void ExecutionPayload::_internal_set_gas_limit(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_limit_ = value; } // uint64 gas_used = 10; inline void ExecutionPayload::clear_gas_used() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_used_ = ::uint64_t{0u}; } inline ::uint64_t ExecutionPayload::gas_used() const { // @@protoc_insertion_point(field_get:types.ExecutionPayload.gas_used) return _internal_gas_used(); } inline void ExecutionPayload::set_gas_used(::uint64_t value) { _internal_set_gas_used(value); // @@protoc_insertion_point(field_set:types.ExecutionPayload.gas_used) } inline ::uint64_t ExecutionPayload::_internal_gas_used() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.gas_used_; } inline void ExecutionPayload::_internal_set_gas_used(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.gas_used_ = value; } // uint64 timestamp = 11; inline void ExecutionPayload::clear_timestamp() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = ::uint64_t{0u}; } inline ::uint64_t ExecutionPayload::timestamp() const { // @@protoc_insertion_point(field_get:types.ExecutionPayload.timestamp) return _internal_timestamp(); } inline void ExecutionPayload::set_timestamp(::uint64_t value) { _internal_set_timestamp(value); // @@protoc_insertion_point(field_set:types.ExecutionPayload.timestamp) } inline ::uint64_t ExecutionPayload::_internal_timestamp() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.timestamp_; } inline void ExecutionPayload::_internal_set_timestamp(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.timestamp_ = value; } // bytes extra_data = 12; inline void ExecutionPayload::clear_extra_data() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.ClearToEmpty(); } inline const std::string& ExecutionPayload::extra_data() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.extra_data) return _internal_extra_data(); } template inline PROTOBUF_ALWAYS_INLINE void ExecutionPayload::set_extra_data(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.ExecutionPayload.extra_data) } inline std::string* ExecutionPayload::mutable_extra_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_extra_data(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.extra_data) return _s; } inline const std::string& ExecutionPayload::_internal_extra_data() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.extra_data_.Get(); } inline void ExecutionPayload::_internal_set_extra_data(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.Set(value, GetArena()); } inline std::string* ExecutionPayload::_internal_mutable_extra_data() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.extra_data_.Mutable( GetArena()); } inline std::string* ExecutionPayload::release_extra_data() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.extra_data) return _impl_.extra_data_.Release(); } inline void ExecutionPayload::set_allocated_extra_data(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.extra_data_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.extra_data_.IsDefault()) { _impl_.extra_data_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.extra_data) } // .types.H256 base_fee_per_gas = 13; inline bool ExecutionPayload::has_base_fee_per_gas() const { bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; PROTOBUF_ASSUME(!value || _impl_.base_fee_per_gas_ != nullptr); return value; } inline void ExecutionPayload::clear_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.base_fee_per_gas_ != nullptr) _impl_.base_fee_per_gas_->Clear(); _impl_._has_bits_[0] &= ~0x00000040u; } inline const ::types::H256& ExecutionPayload::_internal_base_fee_per_gas() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.base_fee_per_gas_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ExecutionPayload::base_fee_per_gas() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.base_fee_per_gas) return _internal_base_fee_per_gas(); } inline void ExecutionPayload::unsafe_arena_set_allocated_base_fee_per_gas(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.base_fee_per_gas_); } _impl_.base_fee_per_gas_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000040u; } else { _impl_._has_bits_[0] &= ~0x00000040u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.base_fee_per_gas) } inline ::types::H256* ExecutionPayload::release_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000040u; ::types::H256* released = _impl_.base_fee_per_gas_; _impl_.base_fee_per_gas_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ExecutionPayload::unsafe_arena_release_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.base_fee_per_gas) _impl_._has_bits_[0] &= ~0x00000040u; ::types::H256* temp = _impl_.base_fee_per_gas_; _impl_.base_fee_per_gas_ = nullptr; return temp; } inline ::types::H256* ExecutionPayload::_internal_mutable_base_fee_per_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.base_fee_per_gas_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.base_fee_per_gas_ = reinterpret_cast<::types::H256*>(p); } return _impl_.base_fee_per_gas_; } inline ::types::H256* ExecutionPayload::mutable_base_fee_per_gas() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000040u; ::types::H256* _msg = _internal_mutable_base_fee_per_gas(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.base_fee_per_gas) return _msg; } inline void ExecutionPayload::set_allocated_base_fee_per_gas(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.base_fee_per_gas_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000040u; } else { _impl_._has_bits_[0] &= ~0x00000040u; } _impl_.base_fee_per_gas_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.base_fee_per_gas) } // .types.H256 block_hash = 14; inline bool ExecutionPayload::has_block_hash() const { bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; PROTOBUF_ASSUME(!value || _impl_.block_hash_ != nullptr); return value; } inline void ExecutionPayload::clear_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ != nullptr) _impl_.block_hash_->Clear(); _impl_._has_bits_[0] &= ~0x00000080u; } inline const ::types::H256& ExecutionPayload::_internal_block_hash() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H256* p = _impl_.block_hash_; return p != nullptr ? *p : reinterpret_cast(::types::_H256_default_instance_); } inline const ::types::H256& ExecutionPayload::block_hash() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.block_hash) return _internal_block_hash(); } inline void ExecutionPayload::unsafe_arena_set_allocated_block_hash(::types::H256* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_hash_); } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000080u; } else { _impl_._has_bits_[0] &= ~0x00000080u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.ExecutionPayload.block_hash) } inline ::types::H256* ExecutionPayload::release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000080u; ::types::H256* released = _impl_.block_hash_; _impl_.block_hash_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H256* ExecutionPayload::unsafe_arena_release_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.ExecutionPayload.block_hash) _impl_._has_bits_[0] &= ~0x00000080u; ::types::H256* temp = _impl_.block_hash_; _impl_.block_hash_ = nullptr; return temp; } inline ::types::H256* ExecutionPayload::_internal_mutable_block_hash() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.block_hash_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H256>(GetArena()); _impl_.block_hash_ = reinterpret_cast<::types::H256*>(p); } return _impl_.block_hash_; } inline ::types::H256* ExecutionPayload::mutable_block_hash() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000080u; ::types::H256* _msg = _internal_mutable_block_hash(); // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.block_hash) return _msg; } inline void ExecutionPayload::set_allocated_block_hash(::types::H256* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.block_hash_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000080u; } else { _impl_._has_bits_[0] &= ~0x00000080u; } _impl_.block_hash_ = reinterpret_cast<::types::H256*>(value); // @@protoc_insertion_point(field_set_allocated:types.ExecutionPayload.block_hash) } // repeated bytes transactions = 15; inline int ExecutionPayload::_internal_transactions_size() const { return _internal_transactions().size(); } inline int ExecutionPayload::transactions_size() const { return _internal_transactions_size(); } inline void ExecutionPayload::clear_transactions() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.transactions_.Clear(); } inline std::string* ExecutionPayload::add_transactions() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_transactions()->Add(); // @@protoc_insertion_point(field_add_mutable:types.ExecutionPayload.transactions) return _s; } inline const std::string& ExecutionPayload::transactions(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.transactions) return _internal_transactions().Get(index); } inline std::string* ExecutionPayload::mutable_transactions(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.transactions) return _internal_mutable_transactions()->Mutable(index); } inline void ExecutionPayload::set_transactions(int index, const std::string& value) { _internal_mutable_transactions()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:types.ExecutionPayload.transactions) } inline void ExecutionPayload::set_transactions(int index, std::string&& value) { _internal_mutable_transactions()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:types.ExecutionPayload.transactions) } inline void ExecutionPayload::set_transactions(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_transactions()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:types.ExecutionPayload.transactions) } inline void ExecutionPayload::set_transactions(int index, const void* value, std::size_t size) { _internal_mutable_transactions()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:types.ExecutionPayload.transactions) } inline void ExecutionPayload::set_transactions(int index, absl::string_view value) { _internal_mutable_transactions()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:types.ExecutionPayload.transactions) } inline void ExecutionPayload::add_transactions(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value); // @@protoc_insertion_point(field_add:types.ExecutionPayload.transactions) } inline void ExecutionPayload::add_transactions(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add(std::move(value)); // @@protoc_insertion_point(field_add:types.ExecutionPayload.transactions) } inline void ExecutionPayload::add_transactions(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:types.ExecutionPayload.transactions) } inline void ExecutionPayload::add_transactions(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:types.ExecutionPayload.transactions) } inline void ExecutionPayload::add_transactions(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:types.ExecutionPayload.transactions) } inline const ::google::protobuf::RepeatedPtrField& ExecutionPayload::transactions() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.ExecutionPayload.transactions) return _internal_transactions(); } inline ::google::protobuf::RepeatedPtrField* ExecutionPayload::mutable_transactions() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.ExecutionPayload.transactions) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_transactions(); } inline const ::google::protobuf::RepeatedPtrField& ExecutionPayload::_internal_transactions() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.transactions_; } inline ::google::protobuf::RepeatedPtrField* ExecutionPayload::_internal_mutable_transactions() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.transactions_; } // repeated .types.Withdrawal withdrawals = 16; inline int ExecutionPayload::_internal_withdrawals_size() const { return _internal_withdrawals().size(); } inline int ExecutionPayload::withdrawals_size() const { return _internal_withdrawals_size(); } inline void ExecutionPayload::clear_withdrawals() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.withdrawals_.Clear(); } inline ::types::Withdrawal* ExecutionPayload::mutable_withdrawals(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.ExecutionPayload.withdrawals) return _internal_mutable_withdrawals()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* ExecutionPayload::mutable_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.ExecutionPayload.withdrawals) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_withdrawals(); } inline const ::types::Withdrawal& ExecutionPayload::withdrawals(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayload.withdrawals) return _internal_withdrawals().Get(index); } inline ::types::Withdrawal* ExecutionPayload::add_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::Withdrawal* _add = _internal_mutable_withdrawals()->Add(); // @@protoc_insertion_point(field_add:types.ExecutionPayload.withdrawals) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& ExecutionPayload::withdrawals() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.ExecutionPayload.withdrawals) return _internal_withdrawals(); } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& ExecutionPayload::_internal_withdrawals() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.withdrawals_; } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* ExecutionPayload::_internal_mutable_withdrawals() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.withdrawals_; } // optional uint64 blob_gas_used = 17; inline bool ExecutionPayload::has_blob_gas_used() const { bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; return value; } inline void ExecutionPayload::clear_blob_gas_used() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blob_gas_used_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00000100u; } inline ::uint64_t ExecutionPayload::blob_gas_used() const { // @@protoc_insertion_point(field_get:types.ExecutionPayload.blob_gas_used) return _internal_blob_gas_used(); } inline void ExecutionPayload::set_blob_gas_used(::uint64_t value) { _internal_set_blob_gas_used(value); _impl_._has_bits_[0] |= 0x00000100u; // @@protoc_insertion_point(field_set:types.ExecutionPayload.blob_gas_used) } inline ::uint64_t ExecutionPayload::_internal_blob_gas_used() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.blob_gas_used_; } inline void ExecutionPayload::_internal_set_blob_gas_used(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blob_gas_used_ = value; } // optional uint64 excess_blob_gas = 18; inline bool ExecutionPayload::has_excess_blob_gas() const { bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; return value; } inline void ExecutionPayload::clear_excess_blob_gas() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.excess_blob_gas_ = ::uint64_t{0u}; _impl_._has_bits_[0] &= ~0x00000200u; } inline ::uint64_t ExecutionPayload::excess_blob_gas() const { // @@protoc_insertion_point(field_get:types.ExecutionPayload.excess_blob_gas) return _internal_excess_blob_gas(); } inline void ExecutionPayload::set_excess_blob_gas(::uint64_t value) { _internal_set_excess_blob_gas(value); _impl_._has_bits_[0] |= 0x00000200u; // @@protoc_insertion_point(field_set:types.ExecutionPayload.excess_blob_gas) } inline ::uint64_t ExecutionPayload::_internal_excess_blob_gas() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.excess_blob_gas_; } inline void ExecutionPayload::_internal_set_excess_blob_gas(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.excess_blob_gas_ = value; } // ------------------------------------------------------------------- // Withdrawal // uint64 index = 1; inline void Withdrawal::clear_index() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.index_ = ::uint64_t{0u}; } inline ::uint64_t Withdrawal::index() const { // @@protoc_insertion_point(field_get:types.Withdrawal.index) return _internal_index(); } inline void Withdrawal::set_index(::uint64_t value) { _internal_set_index(value); // @@protoc_insertion_point(field_set:types.Withdrawal.index) } inline ::uint64_t Withdrawal::_internal_index() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.index_; } inline void Withdrawal::_internal_set_index(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.index_ = value; } // uint64 validator_index = 2; inline void Withdrawal::clear_validator_index() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validator_index_ = ::uint64_t{0u}; } inline ::uint64_t Withdrawal::validator_index() const { // @@protoc_insertion_point(field_get:types.Withdrawal.validator_index) return _internal_validator_index(); } inline void Withdrawal::set_validator_index(::uint64_t value) { _internal_set_validator_index(value); // @@protoc_insertion_point(field_set:types.Withdrawal.validator_index) } inline ::uint64_t Withdrawal::_internal_validator_index() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.validator_index_; } inline void Withdrawal::_internal_set_validator_index(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.validator_index_ = value; } // .types.H160 address = 3; inline bool Withdrawal::has_address() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.address_ != nullptr); return value; } inline void Withdrawal::clear_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ != nullptr) _impl_.address_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::H160& Withdrawal::_internal_address() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::H160* p = _impl_.address_; return p != nullptr ? *p : reinterpret_cast(::types::_H160_default_instance_); } inline const ::types::H160& Withdrawal::address() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.Withdrawal.address) return _internal_address(); } inline void Withdrawal::unsafe_arena_set_allocated_address(::types::H160* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.address_); } _impl_.address_ = reinterpret_cast<::types::H160*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.Withdrawal.address) } inline ::types::H160* Withdrawal::release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* released = _impl_.address_; _impl_.address_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::H160* Withdrawal::unsafe_arena_release_address() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.Withdrawal.address) _impl_._has_bits_[0] &= ~0x00000001u; ::types::H160* temp = _impl_.address_; _impl_.address_ = nullptr; return temp; } inline ::types::H160* Withdrawal::_internal_mutable_address() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.address_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::H160>(GetArena()); _impl_.address_ = reinterpret_cast<::types::H160*>(p); } return _impl_.address_; } inline ::types::H160* Withdrawal::mutable_address() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::H160* _msg = _internal_mutable_address(); // @@protoc_insertion_point(field_mutable:types.Withdrawal.address) return _msg; } inline void Withdrawal::set_allocated_address(::types::H160* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.address_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.address_ = reinterpret_cast<::types::H160*>(value); // @@protoc_insertion_point(field_set_allocated:types.Withdrawal.address) } // uint64 amount = 4; inline void Withdrawal::clear_amount() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.amount_ = ::uint64_t{0u}; } inline ::uint64_t Withdrawal::amount() const { // @@protoc_insertion_point(field_get:types.Withdrawal.amount) return _internal_amount(); } inline void Withdrawal::set_amount(::uint64_t value) { _internal_set_amount(value); // @@protoc_insertion_point(field_set:types.Withdrawal.amount) } inline ::uint64_t Withdrawal::_internal_amount() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.amount_; } inline void Withdrawal::_internal_set_amount(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.amount_ = value; } // ------------------------------------------------------------------- // BlobsBundleV1 // repeated bytes commitments = 1; inline int BlobsBundleV1::_internal_commitments_size() const { return _internal_commitments().size(); } inline int BlobsBundleV1::commitments_size() const { return _internal_commitments_size(); } inline void BlobsBundleV1::clear_commitments() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.commitments_.Clear(); } inline std::string* BlobsBundleV1::add_commitments() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_commitments()->Add(); // @@protoc_insertion_point(field_add_mutable:types.BlobsBundleV1.commitments) return _s; } inline const std::string& BlobsBundleV1::commitments(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.BlobsBundleV1.commitments) return _internal_commitments().Get(index); } inline std::string* BlobsBundleV1::mutable_commitments(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.BlobsBundleV1.commitments) return _internal_mutable_commitments()->Mutable(index); } inline void BlobsBundleV1::set_commitments(int index, const std::string& value) { _internal_mutable_commitments()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::set_commitments(int index, std::string&& value) { _internal_mutable_commitments()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::set_commitments(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_commitments()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::set_commitments(int index, const void* value, std::size_t size) { _internal_mutable_commitments()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::set_commitments(int index, absl::string_view value) { _internal_mutable_commitments()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::add_commitments(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_commitments()->Add()->assign(value); // @@protoc_insertion_point(field_add:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::add_commitments(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_commitments()->Add(std::move(value)); // @@protoc_insertion_point(field_add:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::add_commitments(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_commitments()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::add_commitments(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_commitments()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:types.BlobsBundleV1.commitments) } inline void BlobsBundleV1::add_commitments(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_commitments()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:types.BlobsBundleV1.commitments) } inline const ::google::protobuf::RepeatedPtrField& BlobsBundleV1::commitments() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.BlobsBundleV1.commitments) return _internal_commitments(); } inline ::google::protobuf::RepeatedPtrField* BlobsBundleV1::mutable_commitments() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.BlobsBundleV1.commitments) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_commitments(); } inline const ::google::protobuf::RepeatedPtrField& BlobsBundleV1::_internal_commitments() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.commitments_; } inline ::google::protobuf::RepeatedPtrField* BlobsBundleV1::_internal_mutable_commitments() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.commitments_; } // repeated bytes blobs = 2; inline int BlobsBundleV1::_internal_blobs_size() const { return _internal_blobs().size(); } inline int BlobsBundleV1::blobs_size() const { return _internal_blobs_size(); } inline void BlobsBundleV1::clear_blobs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.blobs_.Clear(); } inline std::string* BlobsBundleV1::add_blobs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_blobs()->Add(); // @@protoc_insertion_point(field_add_mutable:types.BlobsBundleV1.blobs) return _s; } inline const std::string& BlobsBundleV1::blobs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.BlobsBundleV1.blobs) return _internal_blobs().Get(index); } inline std::string* BlobsBundleV1::mutable_blobs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.BlobsBundleV1.blobs) return _internal_mutable_blobs()->Mutable(index); } inline void BlobsBundleV1::set_blobs(int index, const std::string& value) { _internal_mutable_blobs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::set_blobs(int index, std::string&& value) { _internal_mutable_blobs()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::set_blobs(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_blobs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::set_blobs(int index, const void* value, std::size_t size) { _internal_mutable_blobs()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::set_blobs(int index, absl::string_view value) { _internal_mutable_blobs()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::add_blobs(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blobs()->Add()->assign(value); // @@protoc_insertion_point(field_add:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::add_blobs(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blobs()->Add(std::move(value)); // @@protoc_insertion_point(field_add:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::add_blobs(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blobs()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::add_blobs(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blobs()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:types.BlobsBundleV1.blobs) } inline void BlobsBundleV1::add_blobs(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_blobs()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:types.BlobsBundleV1.blobs) } inline const ::google::protobuf::RepeatedPtrField& BlobsBundleV1::blobs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.BlobsBundleV1.blobs) return _internal_blobs(); } inline ::google::protobuf::RepeatedPtrField* BlobsBundleV1::mutable_blobs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.BlobsBundleV1.blobs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_blobs(); } inline const ::google::protobuf::RepeatedPtrField& BlobsBundleV1::_internal_blobs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.blobs_; } inline ::google::protobuf::RepeatedPtrField* BlobsBundleV1::_internal_mutable_blobs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.blobs_; } // repeated bytes proofs = 3; inline int BlobsBundleV1::_internal_proofs_size() const { return _internal_proofs().size(); } inline int BlobsBundleV1::proofs_size() const { return _internal_proofs_size(); } inline void BlobsBundleV1::clear_proofs() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.proofs_.Clear(); } inline std::string* BlobsBundleV1::add_proofs() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_proofs()->Add(); // @@protoc_insertion_point(field_add_mutable:types.BlobsBundleV1.proofs) return _s; } inline const std::string& BlobsBundleV1::proofs(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.BlobsBundleV1.proofs) return _internal_proofs().Get(index); } inline std::string* BlobsBundleV1::mutable_proofs(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.BlobsBundleV1.proofs) return _internal_mutable_proofs()->Mutable(index); } inline void BlobsBundleV1::set_proofs(int index, const std::string& value) { _internal_mutable_proofs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::set_proofs(int index, std::string&& value) { _internal_mutable_proofs()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::set_proofs(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_proofs()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::set_proofs(int index, const void* value, std::size_t size) { _internal_mutable_proofs()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::set_proofs(int index, absl::string_view value) { _internal_mutable_proofs()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::add_proofs(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_proofs()->Add()->assign(value); // @@protoc_insertion_point(field_add:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::add_proofs(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_proofs()->Add(std::move(value)); // @@protoc_insertion_point(field_add:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::add_proofs(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_proofs()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::add_proofs(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_proofs()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:types.BlobsBundleV1.proofs) } inline void BlobsBundleV1::add_proofs(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_proofs()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:types.BlobsBundleV1.proofs) } inline const ::google::protobuf::RepeatedPtrField& BlobsBundleV1::proofs() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.BlobsBundleV1.proofs) return _internal_proofs(); } inline ::google::protobuf::RepeatedPtrField* BlobsBundleV1::mutable_proofs() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.BlobsBundleV1.proofs) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_proofs(); } inline const ::google::protobuf::RepeatedPtrField& BlobsBundleV1::_internal_proofs() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.proofs_; } inline ::google::protobuf::RepeatedPtrField* BlobsBundleV1::_internal_mutable_proofs() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.proofs_; } // ------------------------------------------------------------------- // RequestsBundle // repeated bytes requests = 1; inline int RequestsBundle::_internal_requests_size() const { return _internal_requests().size(); } inline int RequestsBundle::requests_size() const { return _internal_requests_size(); } inline void RequestsBundle::clear_requests() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.requests_.Clear(); } inline std::string* RequestsBundle::add_requests() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_requests()->Add(); // @@protoc_insertion_point(field_add_mutable:types.RequestsBundle.requests) return _s; } inline const std::string& RequestsBundle::requests(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.RequestsBundle.requests) return _internal_requests().Get(index); } inline std::string* RequestsBundle::mutable_requests(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.RequestsBundle.requests) return _internal_mutable_requests()->Mutable(index); } inline void RequestsBundle::set_requests(int index, const std::string& value) { _internal_mutable_requests()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:types.RequestsBundle.requests) } inline void RequestsBundle::set_requests(int index, std::string&& value) { _internal_mutable_requests()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:types.RequestsBundle.requests) } inline void RequestsBundle::set_requests(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_requests()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:types.RequestsBundle.requests) } inline void RequestsBundle::set_requests(int index, const void* value, std::size_t size) { _internal_mutable_requests()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:types.RequestsBundle.requests) } inline void RequestsBundle::set_requests(int index, absl::string_view value) { _internal_mutable_requests()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:types.RequestsBundle.requests) } inline void RequestsBundle::add_requests(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_requests()->Add()->assign(value); // @@protoc_insertion_point(field_add:types.RequestsBundle.requests) } inline void RequestsBundle::add_requests(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_requests()->Add(std::move(value)); // @@protoc_insertion_point(field_add:types.RequestsBundle.requests) } inline void RequestsBundle::add_requests(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_requests()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:types.RequestsBundle.requests) } inline void RequestsBundle::add_requests(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_requests()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:types.RequestsBundle.requests) } inline void RequestsBundle::add_requests(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_requests()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:types.RequestsBundle.requests) } inline const ::google::protobuf::RepeatedPtrField& RequestsBundle::requests() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.RequestsBundle.requests) return _internal_requests(); } inline ::google::protobuf::RepeatedPtrField* RequestsBundle::mutable_requests() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.RequestsBundle.requests) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_requests(); } inline const ::google::protobuf::RepeatedPtrField& RequestsBundle::_internal_requests() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.requests_; } inline ::google::protobuf::RepeatedPtrField* RequestsBundle::_internal_mutable_requests() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.requests_; } // ------------------------------------------------------------------- // NodeInfoPorts // uint32 discovery = 1; inline void NodeInfoPorts::clear_discovery() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.discovery_ = 0u; } inline ::uint32_t NodeInfoPorts::discovery() const { // @@protoc_insertion_point(field_get:types.NodeInfoPorts.discovery) return _internal_discovery(); } inline void NodeInfoPorts::set_discovery(::uint32_t value) { _internal_set_discovery(value); // @@protoc_insertion_point(field_set:types.NodeInfoPorts.discovery) } inline ::uint32_t NodeInfoPorts::_internal_discovery() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.discovery_; } inline void NodeInfoPorts::_internal_set_discovery(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.discovery_ = value; } // uint32 listener = 2; inline void NodeInfoPorts::clear_listener() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.listener_ = 0u; } inline ::uint32_t NodeInfoPorts::listener() const { // @@protoc_insertion_point(field_get:types.NodeInfoPorts.listener) return _internal_listener(); } inline void NodeInfoPorts::set_listener(::uint32_t value) { _internal_set_listener(value); // @@protoc_insertion_point(field_set:types.NodeInfoPorts.listener) } inline ::uint32_t NodeInfoPorts::_internal_listener() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.listener_; } inline void NodeInfoPorts::_internal_set_listener(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.listener_ = value; } // ------------------------------------------------------------------- // NodeInfoReply // string id = 1; inline void NodeInfoReply::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.ClearToEmpty(); } inline const std::string& NodeInfoReply::id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.NodeInfoReply.id) return _internal_id(); } template inline PROTOBUF_ALWAYS_INLINE void NodeInfoReply::set_id(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.NodeInfoReply.id) } inline std::string* NodeInfoReply::mutable_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_id(); // @@protoc_insertion_point(field_mutable:types.NodeInfoReply.id) return _s; } inline const std::string& NodeInfoReply::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_.Get(); } inline void NodeInfoReply::_internal_set_id(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.Set(value, GetArena()); } inline std::string* NodeInfoReply::_internal_mutable_id() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.id_.Mutable( GetArena()); } inline std::string* NodeInfoReply::release_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.NodeInfoReply.id) return _impl_.id_.Release(); } inline void NodeInfoReply::set_allocated_id(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.id_.IsDefault()) { _impl_.id_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.NodeInfoReply.id) } // string name = 2; inline void NodeInfoReply::clear_name() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.ClearToEmpty(); } inline const std::string& NodeInfoReply::name() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.NodeInfoReply.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void NodeInfoReply::set_name(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.NodeInfoReply.name) } inline std::string* NodeInfoReply::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:types.NodeInfoReply.name) return _s; } inline const std::string& NodeInfoReply::_internal_name() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.name_.Get(); } inline void NodeInfoReply::_internal_set_name(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.Set(value, GetArena()); } inline std::string* NodeInfoReply::_internal_mutable_name() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.name_.Mutable( GetArena()); } inline std::string* NodeInfoReply::release_name() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.NodeInfoReply.name) return _impl_.name_.Release(); } inline void NodeInfoReply::set_allocated_name(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.NodeInfoReply.name) } // string enode = 3; inline void NodeInfoReply::clear_enode() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.ClearToEmpty(); } inline const std::string& NodeInfoReply::enode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.NodeInfoReply.enode) return _internal_enode(); } template inline PROTOBUF_ALWAYS_INLINE void NodeInfoReply::set_enode(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.NodeInfoReply.enode) } inline std::string* NodeInfoReply::mutable_enode() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_enode(); // @@protoc_insertion_point(field_mutable:types.NodeInfoReply.enode) return _s; } inline const std::string& NodeInfoReply::_internal_enode() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.enode_.Get(); } inline void NodeInfoReply::_internal_set_enode(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.Set(value, GetArena()); } inline std::string* NodeInfoReply::_internal_mutable_enode() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.enode_.Mutable( GetArena()); } inline std::string* NodeInfoReply::release_enode() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.NodeInfoReply.enode) return _impl_.enode_.Release(); } inline void NodeInfoReply::set_allocated_enode(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.enode_.IsDefault()) { _impl_.enode_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.NodeInfoReply.enode) } // string enr = 4; inline void NodeInfoReply::clear_enr() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.ClearToEmpty(); } inline const std::string& NodeInfoReply::enr() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.NodeInfoReply.enr) return _internal_enr(); } template inline PROTOBUF_ALWAYS_INLINE void NodeInfoReply::set_enr(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.NodeInfoReply.enr) } inline std::string* NodeInfoReply::mutable_enr() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_enr(); // @@protoc_insertion_point(field_mutable:types.NodeInfoReply.enr) return _s; } inline const std::string& NodeInfoReply::_internal_enr() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.enr_.Get(); } inline void NodeInfoReply::_internal_set_enr(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.Set(value, GetArena()); } inline std::string* NodeInfoReply::_internal_mutable_enr() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.enr_.Mutable( GetArena()); } inline std::string* NodeInfoReply::release_enr() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.NodeInfoReply.enr) return _impl_.enr_.Release(); } inline void NodeInfoReply::set_allocated_enr(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.enr_.IsDefault()) { _impl_.enr_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.NodeInfoReply.enr) } // .types.NodeInfoPorts ports = 5; inline bool NodeInfoReply::has_ports() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.ports_ != nullptr); return value; } inline void NodeInfoReply::clear_ports() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.ports_ != nullptr) _impl_.ports_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::types::NodeInfoPorts& NodeInfoReply::_internal_ports() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::types::NodeInfoPorts* p = _impl_.ports_; return p != nullptr ? *p : reinterpret_cast(::types::_NodeInfoPorts_default_instance_); } inline const ::types::NodeInfoPorts& NodeInfoReply::ports() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.NodeInfoReply.ports) return _internal_ports(); } inline void NodeInfoReply::unsafe_arena_set_allocated_ports(::types::NodeInfoPorts* value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.ports_); } _impl_.ports_ = reinterpret_cast<::types::NodeInfoPorts*>(value); if (value != nullptr) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:types.NodeInfoReply.ports) } inline ::types::NodeInfoPorts* NodeInfoReply::release_ports() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_._has_bits_[0] &= ~0x00000001u; ::types::NodeInfoPorts* released = _impl_.ports_; _impl_.ports_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); if (GetArena() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArena() != nullptr) { released = ::google::protobuf::internal::DuplicateIfNonNull(released); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return released; } inline ::types::NodeInfoPorts* NodeInfoReply::unsafe_arena_release_ports() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.NodeInfoReply.ports) _impl_._has_bits_[0] &= ~0x00000001u; ::types::NodeInfoPorts* temp = _impl_.ports_; _impl_.ports_ = nullptr; return temp; } inline ::types::NodeInfoPorts* NodeInfoReply::_internal_mutable_ports() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.ports_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::types::NodeInfoPorts>(GetArena()); _impl_.ports_ = reinterpret_cast<::types::NodeInfoPorts*>(p); } return _impl_.ports_; } inline ::types::NodeInfoPorts* NodeInfoReply::mutable_ports() ABSL_ATTRIBUTE_LIFETIME_BOUND { _impl_._has_bits_[0] |= 0x00000001u; ::types::NodeInfoPorts* _msg = _internal_mutable_ports(); // @@protoc_insertion_point(field_mutable:types.NodeInfoReply.ports) return _msg; } inline void NodeInfoReply::set_allocated_ports(::types::NodeInfoPorts* value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { delete (_impl_.ports_); } if (value != nullptr) { ::google::protobuf::Arena* submessage_arena = (value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.ports_ = reinterpret_cast<::types::NodeInfoPorts*>(value); // @@protoc_insertion_point(field_set_allocated:types.NodeInfoReply.ports) } // string listener_addr = 6; inline void NodeInfoReply::clear_listener_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.listener_addr_.ClearToEmpty(); } inline const std::string& NodeInfoReply::listener_addr() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.NodeInfoReply.listener_addr) return _internal_listener_addr(); } template inline PROTOBUF_ALWAYS_INLINE void NodeInfoReply::set_listener_addr(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.listener_addr_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.NodeInfoReply.listener_addr) } inline std::string* NodeInfoReply::mutable_listener_addr() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_listener_addr(); // @@protoc_insertion_point(field_mutable:types.NodeInfoReply.listener_addr) return _s; } inline const std::string& NodeInfoReply::_internal_listener_addr() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.listener_addr_.Get(); } inline void NodeInfoReply::_internal_set_listener_addr(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.listener_addr_.Set(value, GetArena()); } inline std::string* NodeInfoReply::_internal_mutable_listener_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.listener_addr_.Mutable( GetArena()); } inline std::string* NodeInfoReply::release_listener_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.NodeInfoReply.listener_addr) return _impl_.listener_addr_.Release(); } inline void NodeInfoReply::set_allocated_listener_addr(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.listener_addr_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.listener_addr_.IsDefault()) { _impl_.listener_addr_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.NodeInfoReply.listener_addr) } // bytes protocols = 7; inline void NodeInfoReply::clear_protocols() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocols_.ClearToEmpty(); } inline const std::string& NodeInfoReply::protocols() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.NodeInfoReply.protocols) return _internal_protocols(); } template inline PROTOBUF_ALWAYS_INLINE void NodeInfoReply::set_protocols(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocols_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.NodeInfoReply.protocols) } inline std::string* NodeInfoReply::mutable_protocols() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_protocols(); // @@protoc_insertion_point(field_mutable:types.NodeInfoReply.protocols) return _s; } inline const std::string& NodeInfoReply::_internal_protocols() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.protocols_.Get(); } inline void NodeInfoReply::_internal_set_protocols(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocols_.Set(value, GetArena()); } inline std::string* NodeInfoReply::_internal_mutable_protocols() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.protocols_.Mutable( GetArena()); } inline std::string* NodeInfoReply::release_protocols() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.NodeInfoReply.protocols) return _impl_.protocols_.Release(); } inline void NodeInfoReply::set_allocated_protocols(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.protocols_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.protocols_.IsDefault()) { _impl_.protocols_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.NodeInfoReply.protocols) } // ------------------------------------------------------------------- // PeerInfo // string id = 1; inline void PeerInfo::clear_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.ClearToEmpty(); } inline const std::string& PeerInfo::id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.PeerInfo.id) return _internal_id(); } template inline PROTOBUF_ALWAYS_INLINE void PeerInfo::set_id(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.PeerInfo.id) } inline std::string* PeerInfo::mutable_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_id(); // @@protoc_insertion_point(field_mutable:types.PeerInfo.id) return _s; } inline const std::string& PeerInfo::_internal_id() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.id_.Get(); } inline void PeerInfo::_internal_set_id(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.Set(value, GetArena()); } inline std::string* PeerInfo::_internal_mutable_id() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.id_.Mutable( GetArena()); } inline std::string* PeerInfo::release_id() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.PeerInfo.id) return _impl_.id_.Release(); } inline void PeerInfo::set_allocated_id(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.id_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.id_.IsDefault()) { _impl_.id_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.PeerInfo.id) } // string name = 2; inline void PeerInfo::clear_name() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.ClearToEmpty(); } inline const std::string& PeerInfo::name() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.PeerInfo.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void PeerInfo::set_name(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.PeerInfo.name) } inline std::string* PeerInfo::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:types.PeerInfo.name) return _s; } inline const std::string& PeerInfo::_internal_name() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.name_.Get(); } inline void PeerInfo::_internal_set_name(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.Set(value, GetArena()); } inline std::string* PeerInfo::_internal_mutable_name() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.name_.Mutable( GetArena()); } inline std::string* PeerInfo::release_name() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.PeerInfo.name) return _impl_.name_.Release(); } inline void PeerInfo::set_allocated_name(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.name_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.PeerInfo.name) } // string enode = 3; inline void PeerInfo::clear_enode() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.ClearToEmpty(); } inline const std::string& PeerInfo::enode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.PeerInfo.enode) return _internal_enode(); } template inline PROTOBUF_ALWAYS_INLINE void PeerInfo::set_enode(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.PeerInfo.enode) } inline std::string* PeerInfo::mutable_enode() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_enode(); // @@protoc_insertion_point(field_mutable:types.PeerInfo.enode) return _s; } inline const std::string& PeerInfo::_internal_enode() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.enode_.Get(); } inline void PeerInfo::_internal_set_enode(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.Set(value, GetArena()); } inline std::string* PeerInfo::_internal_mutable_enode() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.enode_.Mutable( GetArena()); } inline std::string* PeerInfo::release_enode() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.PeerInfo.enode) return _impl_.enode_.Release(); } inline void PeerInfo::set_allocated_enode(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enode_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.enode_.IsDefault()) { _impl_.enode_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.PeerInfo.enode) } // string enr = 4; inline void PeerInfo::clear_enr() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.ClearToEmpty(); } inline const std::string& PeerInfo::enr() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.PeerInfo.enr) return _internal_enr(); } template inline PROTOBUF_ALWAYS_INLINE void PeerInfo::set_enr(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.PeerInfo.enr) } inline std::string* PeerInfo::mutable_enr() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_enr(); // @@protoc_insertion_point(field_mutable:types.PeerInfo.enr) return _s; } inline const std::string& PeerInfo::_internal_enr() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.enr_.Get(); } inline void PeerInfo::_internal_set_enr(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.Set(value, GetArena()); } inline std::string* PeerInfo::_internal_mutable_enr() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.enr_.Mutable( GetArena()); } inline std::string* PeerInfo::release_enr() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.PeerInfo.enr) return _impl_.enr_.Release(); } inline void PeerInfo::set_allocated_enr(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enr_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.enr_.IsDefault()) { _impl_.enr_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.PeerInfo.enr) } // repeated string caps = 5; inline int PeerInfo::_internal_caps_size() const { return _internal_caps().size(); } inline int PeerInfo::caps_size() const { return _internal_caps_size(); } inline void PeerInfo::clear_caps() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.caps_.Clear(); } inline std::string* PeerInfo::add_caps() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_caps()->Add(); // @@protoc_insertion_point(field_add_mutable:types.PeerInfo.caps) return _s; } inline const std::string& PeerInfo::caps(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.PeerInfo.caps) return _internal_caps().Get(index); } inline std::string* PeerInfo::mutable_caps(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.PeerInfo.caps) return _internal_mutable_caps()->Mutable(index); } inline void PeerInfo::set_caps(int index, const std::string& value) { _internal_mutable_caps()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:types.PeerInfo.caps) } inline void PeerInfo::set_caps(int index, std::string&& value) { _internal_mutable_caps()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:types.PeerInfo.caps) } inline void PeerInfo::set_caps(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_caps()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:types.PeerInfo.caps) } inline void PeerInfo::set_caps(int index, const char* value, std::size_t size) { _internal_mutable_caps()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:types.PeerInfo.caps) } inline void PeerInfo::set_caps(int index, absl::string_view value) { _internal_mutable_caps()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:types.PeerInfo.caps) } inline void PeerInfo::add_caps(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_caps()->Add()->assign(value); // @@protoc_insertion_point(field_add:types.PeerInfo.caps) } inline void PeerInfo::add_caps(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_caps()->Add(std::move(value)); // @@protoc_insertion_point(field_add:types.PeerInfo.caps) } inline void PeerInfo::add_caps(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_caps()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:types.PeerInfo.caps) } inline void PeerInfo::add_caps(const char* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_caps()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:types.PeerInfo.caps) } inline void PeerInfo::add_caps(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_caps()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:types.PeerInfo.caps) } inline const ::google::protobuf::RepeatedPtrField& PeerInfo::caps() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.PeerInfo.caps) return _internal_caps(); } inline ::google::protobuf::RepeatedPtrField* PeerInfo::mutable_caps() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.PeerInfo.caps) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_caps(); } inline const ::google::protobuf::RepeatedPtrField& PeerInfo::_internal_caps() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.caps_; } inline ::google::protobuf::RepeatedPtrField* PeerInfo::_internal_mutable_caps() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.caps_; } // string conn_local_addr = 6; inline void PeerInfo::clear_conn_local_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_local_addr_.ClearToEmpty(); } inline const std::string& PeerInfo::conn_local_addr() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.PeerInfo.conn_local_addr) return _internal_conn_local_addr(); } template inline PROTOBUF_ALWAYS_INLINE void PeerInfo::set_conn_local_addr(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_local_addr_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.PeerInfo.conn_local_addr) } inline std::string* PeerInfo::mutable_conn_local_addr() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_conn_local_addr(); // @@protoc_insertion_point(field_mutable:types.PeerInfo.conn_local_addr) return _s; } inline const std::string& PeerInfo::_internal_conn_local_addr() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.conn_local_addr_.Get(); } inline void PeerInfo::_internal_set_conn_local_addr(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_local_addr_.Set(value, GetArena()); } inline std::string* PeerInfo::_internal_mutable_conn_local_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.conn_local_addr_.Mutable( GetArena()); } inline std::string* PeerInfo::release_conn_local_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.PeerInfo.conn_local_addr) return _impl_.conn_local_addr_.Release(); } inline void PeerInfo::set_allocated_conn_local_addr(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_local_addr_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conn_local_addr_.IsDefault()) { _impl_.conn_local_addr_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.PeerInfo.conn_local_addr) } // string conn_remote_addr = 7; inline void PeerInfo::clear_conn_remote_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_remote_addr_.ClearToEmpty(); } inline const std::string& PeerInfo::conn_remote_addr() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.PeerInfo.conn_remote_addr) return _internal_conn_remote_addr(); } template inline PROTOBUF_ALWAYS_INLINE void PeerInfo::set_conn_remote_addr(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_remote_addr_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:types.PeerInfo.conn_remote_addr) } inline std::string* PeerInfo::mutable_conn_remote_addr() ABSL_ATTRIBUTE_LIFETIME_BOUND { std::string* _s = _internal_mutable_conn_remote_addr(); // @@protoc_insertion_point(field_mutable:types.PeerInfo.conn_remote_addr) return _s; } inline const std::string& PeerInfo::_internal_conn_remote_addr() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.conn_remote_addr_.Get(); } inline void PeerInfo::_internal_set_conn_remote_addr(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_remote_addr_.Set(value, GetArena()); } inline std::string* PeerInfo::_internal_mutable_conn_remote_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.conn_remote_addr_.Mutable( GetArena()); } inline std::string* PeerInfo::release_conn_remote_addr() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:types.PeerInfo.conn_remote_addr) return _impl_.conn_remote_addr_.Release(); } inline void PeerInfo::set_allocated_conn_remote_addr(std::string* value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_remote_addr_.SetAllocated(value, GetArena()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conn_remote_addr_.IsDefault()) { _impl_.conn_remote_addr_.Set("", GetArena()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:types.PeerInfo.conn_remote_addr) } // bool conn_is_inbound = 8; inline void PeerInfo::clear_conn_is_inbound() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_is_inbound_ = false; } inline bool PeerInfo::conn_is_inbound() const { // @@protoc_insertion_point(field_get:types.PeerInfo.conn_is_inbound) return _internal_conn_is_inbound(); } inline void PeerInfo::set_conn_is_inbound(bool value) { _internal_set_conn_is_inbound(value); // @@protoc_insertion_point(field_set:types.PeerInfo.conn_is_inbound) } inline bool PeerInfo::_internal_conn_is_inbound() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.conn_is_inbound_; } inline void PeerInfo::_internal_set_conn_is_inbound(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_is_inbound_ = value; } // bool conn_is_trusted = 9; inline void PeerInfo::clear_conn_is_trusted() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_is_trusted_ = false; } inline bool PeerInfo::conn_is_trusted() const { // @@protoc_insertion_point(field_get:types.PeerInfo.conn_is_trusted) return _internal_conn_is_trusted(); } inline void PeerInfo::set_conn_is_trusted(bool value) { _internal_set_conn_is_trusted(value); // @@protoc_insertion_point(field_set:types.PeerInfo.conn_is_trusted) } inline bool PeerInfo::_internal_conn_is_trusted() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.conn_is_trusted_; } inline void PeerInfo::_internal_set_conn_is_trusted(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_is_trusted_ = value; } // bool conn_is_static = 10; inline void PeerInfo::clear_conn_is_static() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_is_static_ = false; } inline bool PeerInfo::conn_is_static() const { // @@protoc_insertion_point(field_get:types.PeerInfo.conn_is_static) return _internal_conn_is_static(); } inline void PeerInfo::set_conn_is_static(bool value) { _internal_set_conn_is_static(value); // @@protoc_insertion_point(field_set:types.PeerInfo.conn_is_static) } inline bool PeerInfo::_internal_conn_is_static() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.conn_is_static_; } inline void PeerInfo::_internal_set_conn_is_static(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.conn_is_static_ = value; } // ------------------------------------------------------------------- // ExecutionPayloadBodyV1 // repeated bytes transactions = 1; inline int ExecutionPayloadBodyV1::_internal_transactions_size() const { return _internal_transactions().size(); } inline int ExecutionPayloadBodyV1::transactions_size() const { return _internal_transactions_size(); } inline void ExecutionPayloadBodyV1::clear_transactions() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.transactions_.Clear(); } inline std::string* ExecutionPayloadBodyV1::add_transactions() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); std::string* _s = _internal_mutable_transactions()->Add(); // @@protoc_insertion_point(field_add_mutable:types.ExecutionPayloadBodyV1.transactions) return _s; } inline const std::string& ExecutionPayloadBodyV1::transactions(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayloadBodyV1.transactions) return _internal_transactions().Get(index); } inline std::string* ExecutionPayloadBodyV1::mutable_transactions(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.ExecutionPayloadBodyV1.transactions) return _internal_mutable_transactions()->Mutable(index); } inline void ExecutionPayloadBodyV1::set_transactions(int index, const std::string& value) { _internal_mutable_transactions()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::set_transactions(int index, std::string&& value) { _internal_mutable_transactions()->Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::set_transactions(int index, const char* value) { ABSL_DCHECK(value != nullptr); _internal_mutable_transactions()->Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::set_transactions(int index, const void* value, std::size_t size) { _internal_mutable_transactions()->Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::set_transactions(int index, absl::string_view value) { _internal_mutable_transactions()->Mutable(index)->assign( value.data(), value.size()); // @@protoc_insertion_point(field_set_string_piece:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::add_transactions(const std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value); // @@protoc_insertion_point(field_add:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::add_transactions(std::string&& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add(std::move(value)); // @@protoc_insertion_point(field_add:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::add_transactions(const char* value) { ABSL_DCHECK(value != nullptr); ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value); // @@protoc_insertion_point(field_add_char:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::add_transactions(const void* value, std::size_t size) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:types.ExecutionPayloadBodyV1.transactions) } inline void ExecutionPayloadBodyV1::add_transactions(absl::string_view value) { ::google::protobuf::internal::TSanWrite(&_impl_); _internal_mutable_transactions()->Add()->assign(value.data(), value.size()); // @@protoc_insertion_point(field_add_string_piece:types.ExecutionPayloadBodyV1.transactions) } inline const ::google::protobuf::RepeatedPtrField& ExecutionPayloadBodyV1::transactions() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.ExecutionPayloadBodyV1.transactions) return _internal_transactions(); } inline ::google::protobuf::RepeatedPtrField* ExecutionPayloadBodyV1::mutable_transactions() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.ExecutionPayloadBodyV1.transactions) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_transactions(); } inline const ::google::protobuf::RepeatedPtrField& ExecutionPayloadBodyV1::_internal_transactions() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.transactions_; } inline ::google::protobuf::RepeatedPtrField* ExecutionPayloadBodyV1::_internal_mutable_transactions() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.transactions_; } // repeated .types.Withdrawal withdrawals = 2; inline int ExecutionPayloadBodyV1::_internal_withdrawals_size() const { return _internal_withdrawals().size(); } inline int ExecutionPayloadBodyV1::withdrawals_size() const { return _internal_withdrawals_size(); } inline void ExecutionPayloadBodyV1::clear_withdrawals() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.withdrawals_.Clear(); } inline ::types::Withdrawal* ExecutionPayloadBodyV1::mutable_withdrawals(int index) ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable:types.ExecutionPayloadBodyV1.withdrawals) return _internal_mutable_withdrawals()->Mutable(index); } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* ExecutionPayloadBodyV1::mutable_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_mutable_list:types.ExecutionPayloadBodyV1.withdrawals) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_withdrawals(); } inline const ::types::Withdrawal& ExecutionPayloadBodyV1::withdrawals(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_get:types.ExecutionPayloadBodyV1.withdrawals) return _internal_withdrawals().Get(index); } inline ::types::Withdrawal* ExecutionPayloadBodyV1::add_withdrawals() ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); ::types::Withdrawal* _add = _internal_mutable_withdrawals()->Add(); // @@protoc_insertion_point(field_add:types.ExecutionPayloadBodyV1.withdrawals) return _add; } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& ExecutionPayloadBodyV1::withdrawals() const ABSL_ATTRIBUTE_LIFETIME_BOUND { // @@protoc_insertion_point(field_list:types.ExecutionPayloadBodyV1.withdrawals) return _internal_withdrawals(); } inline const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& ExecutionPayloadBodyV1::_internal_withdrawals() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.withdrawals_; } inline ::google::protobuf::RepeatedPtrField<::types::Withdrawal>* ExecutionPayloadBodyV1::_internal_mutable_withdrawals() { ::google::protobuf::internal::TSanRead(&_impl_); return &_impl_.withdrawals_; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace types // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_types_2ftypes_2eproto_2epb_2eh ================================================ FILE: silkworm/interfaces/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include(generate_grpc.cmake) find_package(absl REQUIRED) find_package(gRPC REQUIRED) find_package(Protobuf REQUIRED) unset(CMAKE_CXX_CLANG_TIDY) set(SILKWORM_INTERFACE_SRC "") list(APPEND SILKWORM_INTERFACE_SRC "${TYPES_SOURCES_SYMLINK}") list(APPEND SILKWORM_INTERFACE_SRC "${EXECUTION_SOURCES_SYMLINK}") list(APPEND SILKWORM_INTERFACE_SRC "${SENTRY_SOURCES_SYMLINK}") list(APPEND SILKWORM_INTERFACE_SRC "${KV_SOURCES_SYMLINK}") list(APPEND SILKWORM_INTERFACE_SRC "${ETHBACKEND_SOURCES_SYMLINK}") list(APPEND SILKWORM_INTERFACE_SRC "${BOR_SOURCES_SYMLINK}") list(APPEND SILKWORM_INTERFACE_SRC "${MINING_SOURCES_SYMLINK}") list(APPEND SILKWORM_INTERFACE_SRC "${TXPOOL_SOURCES_SYMLINK}") add_library(silkworm_interfaces "${SILKWORM_INTERFACE_SRC}") # cmake-format: off add_dependencies( silkworm_interfaces generate_types_proto_symlink generate_execution_grpc_symlink generate_sentry_grpc_symlink generate_remote_grpc_symlink generate_txpool_grpc_symlink ) # cmake-format: on # Disable warning in gRPC generated code on different compilers if(MSVC) target_compile_options(silkworm_interfaces PRIVATE /wd4100) # C4100: unreferenced formal parameter else() target_compile_options(silkworm_interfaces PRIVATE -Wno-sign-conversion) check_cxx_compiler_flag("-Wno-deprecated-pragma" HAS_NO_DEPRECATED_PRAGMA) if(HAS_NO_DEPRECATED_PRAGMA) target_compile_options(silkworm_interfaces PRIVATE -Wno-deprecated-pragma) endif() endif() target_include_directories(silkworm_interfaces PUBLIC "${SILKWORM_MAIN_DIR};${CMAKE_CURRENT_SOURCE_DIR}") # cmake-format: off set(LIBS_PUBLIC absl::log absl::strings gRPC::grpc++ protobuf::libprotobuf ) # cmake-format: on set(LIBS_PRIVATE "") if(MSVC) list(APPEND LIBS_PRIVATE ntdll.lib) endif(MSVC) target_link_libraries( silkworm_interfaces PUBLIC "${LIBS_PUBLIC}" PRIVATE "${LIBS_PRIVATE}" ) ================================================ FILE: silkworm/interfaces/generate_grpc.cmake ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 # Find Protobuf installation set(protobuf_MODULE_COMPATIBLE TRUE) find_package(Protobuf REQUIRED) find_program( PROTOBUF_PROTOC protoc PATHS "${protobuf_INCLUDE_DIR}/../bin" NO_CACHE REQUIRED NO_DEFAULT_PATH ) if(NOT EXISTS "${PROTOBUF_PROTOC}") message(FATAL_ERROR "PROTOBUF_PROTOC not found at '${PROTOBUF_PROTOC}'") endif() # Find Protobuf version execute_process( COMMAND "${PROTOBUF_PROTOC}" --version OUTPUT_VARIABLE PROTOC_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ERROR_IS_FATAL ANY ) string(SUBSTRING "${PROTOC_VERSION}" 10 -1 PROTOC_VERSION) # Find gRPC installation find_package(gRPC REQUIRED) set(GRPC_CPP_PLUGIN_EXECUTABLE "${GRPC_CPP_PLUGIN_PROGRAM}") if(NOT EXISTS "${GRPC_CPP_PLUGIN_EXECUTABLE}") message(FATAL_ERROR "GRPC_CPP_PLUGIN_EXECUTABLE not found at '${GRPC_CPP_PLUGIN_EXECUTABLE}'") endif() set(PROTO_PATH "${SILKWORM_MAIN_DIR}/third_party/erigon-interfaces") set(OUT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${PROTOC_VERSION}") set(OUT_PATH_SYMLINK "${CMAKE_CURRENT_SOURCE_DIR}") # cmake-format: off set(PROTOC_ARGS --cpp_out "${OUT_PATH}" -I "${PROTO_PATH}" --experimental_allow_proto3_optional ) set(PROTOC_ARGS_GRPC ${PROTOC_ARGS} --grpc_out generate_mock_code=true:"${OUT_PATH}" "--plugin=protoc-gen-grpc=${GRPC_CPP_PLUGIN_EXECUTABLE}" ) # cmake-format: on macro(create_symlink_target target link_path target_path) add_custom_command( OUTPUT "${link_path}" COMMAND "${CMAKE_COMMAND}" ARGS -E remove_directory "${link_path}" COMMAND "${CMAKE_COMMAND}" ARGS -E create_symlink "${target_path}" "${link_path}" COMMENT "${target}: symlink ${link_path} -> ${target_path}" ) add_custom_target(${target} DEPENDS "${link_path}") endmacro() # --------------------------------------------------------------------------------------------------------------------- # Types # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(TYPES_PROTO "${PROTO_PATH}/types/types.proto") set(TYPES_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/types/types.pb.cc" "${OUT_PATH_SYMLINK}/types/types.pb.h") create_symlink_target(generate_types_proto_symlink "${OUT_PATH_SYMLINK}/types" "${OUT_PATH}/types") add_custom_command( OUTPUT ${TYPES_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS} "${TYPES_PROTO}" DEPENDS ${TYPES_PROTO} generate_types_proto_symlink COMMENT "Running C++ gRPC compiler on ${TYPES_PROTO}" ) # --------------------------------------------------------------------------------------------------------------------- # Execution # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(EXECUTION_PROTO "${PROTO_PATH}/execution/execution.proto") # Generate sources set(EXECUTION_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/execution/execution.grpc.pb.cc" "${OUT_PATH_SYMLINK}/execution/execution.grpc.pb.h" "${OUT_PATH_SYMLINK}/execution/execution.pb.cc" "${OUT_PATH_SYMLINK}/execution/execution.pb.h" ) create_symlink_target(generate_execution_grpc_symlink "${OUT_PATH_SYMLINK}/execution" "${OUT_PATH}/execution") add_custom_command( OUTPUT ${EXECUTION_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS_GRPC} "${EXECUTION_PROTO}" DEPENDS ${EXECUTION_PROTO} generate_execution_grpc_symlink COMMENT "Running C++ gRPC compiler on ${EXECUTION_PROTO}" ) # --------------------------------------------------------------------------------------------------------------------- # Sentry # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(SENTRY_PROTO "${PROTO_PATH}/p2psentry/sentry.proto") # cmake-format: off set(SENTRY_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/p2psentry/sentry.grpc.pb.cc" "${OUT_PATH_SYMLINK}/p2psentry/sentry.grpc.pb.h" "${OUT_PATH_SYMLINK}/p2psentry/sentry.pb.cc" "${OUT_PATH_SYMLINK}/p2psentry/sentry.pb.h" "${OUT_PATH_SYMLINK}/p2psentry/sentry_mock.grpc.pb.h" ) # cmake-format: on create_symlink_target(generate_sentry_grpc_symlink "${OUT_PATH_SYMLINK}/p2psentry" "${OUT_PATH}/p2psentry") add_custom_command( OUTPUT ${SENTRY_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS_GRPC} "${SENTRY_PROTO}" DEPENDS ${SENTRY_PROTO} generate_sentry_grpc_symlink COMMENT "Running C++ gRPC compiler on ${SENTRY_PROTO}" ) # --------------------------------------------------------------------------------------------------------------------- # KV # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(KV_PROTO "${PROTO_PATH}/remote/kv.proto") # cmake-format: off set(KV_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/remote/kv.grpc.pb.cc" "${OUT_PATH_SYMLINK}/remote/kv.grpc.pb.h" "${OUT_PATH_SYMLINK}/remote/kv.pb.cc" "${OUT_PATH_SYMLINK}/remote/kv.pb.h" "${OUT_PATH_SYMLINK}/remote/kv_mock.grpc.pb.h" ) # cmake-format: on create_symlink_target(generate_remote_grpc_symlink "${OUT_PATH_SYMLINK}/remote" "${OUT_PATH}/remote") add_custom_command( OUTPUT ${KV_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS_GRPC} "${KV_PROTO}" DEPENDS ${KV_PROTO} generate_remote_grpc_symlink COMMENT "Running C++ gRPC compiler on ${KV_PROTO}" ) # --------------------------------------------------------------------------------------------------------------------- # ETHBACKEND # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(ETHBACKEND_PROTO "${PROTO_PATH}/remote/ethbackend.proto") # cmake-format: off set(ETHBACKEND_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/remote/ethbackend.grpc.pb.cc" "${OUT_PATH_SYMLINK}/remote/ethbackend.grpc.pb.h" "${OUT_PATH_SYMLINK}/remote/ethbackend.pb.cc" "${OUT_PATH_SYMLINK}/remote/ethbackend.pb.h" "${OUT_PATH_SYMLINK}/remote/ethbackend_mock.grpc.pb.h" ) # cmake-format: on add_custom_command( OUTPUT ${ETHBACKEND_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS_GRPC} "${ETHBACKEND_PROTO}" DEPENDS ${ETHBACKEND_PROTO} generate_remote_grpc_symlink COMMENT "Running C++ gRPC compiler on ${ETHBACKEND_PROTO}" ) # --------------------------------------------------------------------------------------------------------------------- # BOR # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(BOR_PROTO "${PROTO_PATH}/remote/bor.proto") # cmake-format: off set(BOR_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/remote/bor.grpc.pb.cc" "${OUT_PATH_SYMLINK}/remote/bor.grpc.pb.h" "${OUT_PATH_SYMLINK}/remote/bor.pb.cc" "${OUT_PATH_SYMLINK}/remote/bor.pb.h" "${OUT_PATH_SYMLINK}/remote/bor_mock.grpc.pb.h" ) # cmake-format: on add_custom_command( OUTPUT ${BOR_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS_GRPC} "${BOR_PROTO}" DEPENDS ${BOR_PROTO} generate_remote_grpc_symlink COMMENT "Running C++ gRPC compiler on ${BOR_PROTO}" ) # --------------------------------------------------------------------------------------------------------------------- # MINING # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(MINING_PROTO "${PROTO_PATH}/txpool/mining.proto") # cmake-format: off set(MINING_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/txpool/mining.grpc.pb.cc" "${OUT_PATH_SYMLINK}/txpool/mining.grpc.pb.h" "${OUT_PATH_SYMLINK}/txpool/mining.pb.cc" "${OUT_PATH_SYMLINK}/txpool/mining.pb.h" "${OUT_PATH_SYMLINK}/txpool/mining_mock.grpc.pb.h" ) # cmake-format: on create_symlink_target(generate_txpool_grpc_symlink "${OUT_PATH_SYMLINK}/txpool" "${OUT_PATH}/txpool") add_custom_command( OUTPUT ${MINING_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS_GRPC} "${MINING_PROTO}" DEPENDS ${MINING_PROTO} generate_txpool_grpc_symlink COMMENT "Running C++ gRPC compiler on ${KV_PROTO}" ) # --------------------------------------------------------------------------------------------------------------------- # TXPOOL # --------------------------------------------------------------------------------------------------------------------- # gRPC protocol interface file set(TXPOOL_PROTO "${PROTO_PATH}/txpool/txpool.proto") # cmake-format: off set(TXPOOL_SOURCES_SYMLINK "${OUT_PATH_SYMLINK}/txpool/txpool.grpc.pb.cc" "${OUT_PATH_SYMLINK}/txpool/txpool.grpc.pb.h" "${OUT_PATH_SYMLINK}/txpool/txpool.pb.cc" "${OUT_PATH_SYMLINK}/txpool/txpool.pb.h" "${OUT_PATH_SYMLINK}/txpool/txpool_mock.grpc.pb.h" ) # cmake-format: on add_custom_command( OUTPUT ${TXPOOL_SOURCES_SYMLINK} COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${OUT_PATH}" COMMAND ${PROTOBUF_PROTOC} ARGS ${PROTOC_ARGS_GRPC} "${TXPOOL_PROTO}" DEPENDS ${TXPOOL_PROTO} generate_txpool_grpc_symlink COMMENT "Running C++ gRPC compiler on ${TXPOOL_PROTO}" ) ================================================ FILE: silkworm/node/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") add_subdirectory(stagedsync/stages) find_package(absl REQUIRED COMPONENTS strings) find_package(Boost REQUIRED COMPONENTS headers) find_package(gRPC REQUIRED) find_package(GTest REQUIRED) find_package(magic_enum REQUIRED) find_package(Microsoft.GSL REQUIRED) find_package(Protobuf REQUIRED) set(SILKWORM_NODE_PUBLIC_LIBS silkworm_core silkworm_db silkworm_infra silkworm_sentry silkworm_snapshots asio-grpc::asio-grpc Boost::headers gRPC::grpc++ protobuf::libprotobuf ) set(SILKWORM_NODE_PRIVATE_LIBS absl::strings evmone magic_enum::magic_enum Microsoft.GSL::GSL silkworm_datastore_etl silkworm_execution silkworm_interfaces silkworm_stages silkworm_sync ) silkworm_library( silkworm_node PUBLIC ${SILKWORM_NODE_PUBLIC_LIBS} PRIVATE ${SILKWORM_NODE_PRIVATE_LIBS} ) # silkworm_node_cli depends on silkworm_node add_subdirectory(cli) # silkworm_node_test_util depends on silkworm_node add_subdirectory(test_util) target_link_libraries(silkworm_node_test PRIVATE silkworm_node_test_util GTest::gmock) ================================================ FILE: silkworm/node/backend/ethereum_backend.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ethereum_backend.hpp" namespace silkworm { EthereumBackEnd::EthereumBackEnd( const NodeSettings& node_settings, datastore::kvdb::ROAccess chaindata, std::shared_ptr sentry_client) : EthereumBackEnd{ node_settings, std::move(chaindata), std::move(sentry_client), std::make_unique(), } { } EthereumBackEnd::EthereumBackEnd( const NodeSettings& node_settings, datastore::kvdb::ROAccess chaindata, std::shared_ptr sentry_client, std::unique_ptr state_change_collection) : node_settings_(node_settings), chaindata_(std::move(chaindata)), sentry_client_(std::move(sentry_client)), state_change_collection_(std::move(state_change_collection)) { // Get the numeric chain identifier from node settings if (node_settings_.chain_config) { chain_id_ = (*node_settings_.chain_config).chain_id; } } EthereumBackEnd::~EthereumBackEnd() { close(); } void EthereumBackEnd::set_node_name(const std::string& node_name) noexcept { node_name_ = node_name; } void EthereumBackEnd::close() { state_change_collection_->close(); } } // namespace silkworm ================================================ FILE: silkworm/node/backend/ethereum_backend.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm { inline constexpr std::string_view kDefaultNodeName{"silkworm"}; class EthereumBackEnd { public: explicit EthereumBackEnd( const NodeSettings& node_settings, datastore::kvdb::ROAccess chaindata, std::shared_ptr sentry_client); ~EthereumBackEnd(); EthereumBackEnd(const EthereumBackEnd&) = delete; EthereumBackEnd& operator=(const EthereumBackEnd&) = delete; datastore::kvdb::ROAccess chaindata() const noexcept { return chaindata_; } const std::string& node_name() const noexcept { return node_name_; } std::optional chain_id() const noexcept { return chain_id_; } std::optional etherbase() const noexcept { return node_settings_.etherbase; } std::shared_ptr sentry_client() const noexcept { return sentry_client_; } StateChangeCollection* state_change_source() const noexcept { return state_change_collection_.get(); } void set_node_name(const std::string& node_name) noexcept; void close(); protected: //! Constructor for testability EthereumBackEnd( const NodeSettings& node_settings, datastore::kvdb::ROAccess chaindata, std::shared_ptr sentry_client, std::unique_ptr state_change_collection); private: const NodeSettings& node_settings_; datastore::kvdb::ROAccess chaindata_; std::string node_name_{kDefaultNodeName}; std::optional chain_id_{std::nullopt}; std::shared_ptr sentry_client_; std::unique_ptr state_change_collection_; }; } // namespace silkworm ================================================ FILE: silkworm/node/backend/ethereum_backend_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ethereum_backend.hpp" #include #include #include namespace silkworm { using namespace evmc::literals; TEST_CASE("EthereumBackEnd", "[silkworm][backend][ethereum_backend]") { TemporaryDirectory tmp_dir; DataDirectory data_dir{tmp_dir.path()}; REQUIRE_NOTHROW(data_dir.deploy()); datastore::kvdb::EnvConfig db_config{data_dir.chaindata().path().string()}; db_config.create = true; db_config.in_memory = true; auto chaindata_env = datastore::kvdb::open_env(db_config); datastore::kvdb::ROAccess chaindata{chaindata_env}; NodeSettings node_settings; std::shared_ptr null_sentry_client; SECTION("EthereumBackEnd::EthereumBackEnd", "[silkworm][backend][ethereum_backend]") { EthereumBackEnd backend{node_settings, chaindata, null_sentry_client}; CHECK(backend.node_name() == std::string{kDefaultNodeName}); CHECK(!backend.etherbase()); CHECK(backend.state_change_source() != nullptr); } SECTION("EthereumBackEnd::set_node_name", "[silkworm][backend][ethereum_backend]") { const std::string node_name{"server_name"}; EthereumBackEnd backend{node_settings, chaindata, null_sentry_client}; backend.set_node_name(node_name); CHECK(backend.node_name() == node_name); } SECTION("EthereumBackEnd::etherbase", "[silkworm][backend][ethereum_backend]") { node_settings.etherbase = 0xd4fe7bc31cedb7bfb8a345f31e668033056b2728_address; EthereumBackEnd backend{node_settings, chaindata, null_sentry_client}; CHECK(backend.etherbase() == 0xd4fe7bc31cedb7bfb8a345f31e668033056b2728_address); } SECTION("EthereumBackEnd::close", "[silkworm][backend][ethereum_backend]") { EthereumBackEnd backend{node_settings, chaindata, null_sentry_client}; CHECK_NOTHROW(backend.close()); } } } // namespace silkworm ================================================ FILE: silkworm/node/backend_kv_server.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "backend_kv_server.hpp" #include #include namespace silkworm::node { BackEndKvServer::BackEndKvServer(const rpc::ServerSettings& settings, const EthereumBackEnd& backend) : Server(settings), BackEndServer(settings, backend), KvServer(settings, backend.chaindata(), backend.state_change_source()) { } // Register the gRPC services: they must exist for the lifetime of the server built by builder. void BackEndKvServer::register_async_services(::grpc::ServerBuilder& builder) { BackEndServer::register_async_services(builder); KvServer::register_async_services(builder); } // Start server-side RPC requests as required by gRPC async model: one RPC per type is requested in advance. void BackEndKvServer::register_request_calls() { BackEndServer::register_request_calls(); KvServer::register_request_calls(); } } // namespace silkworm::node ================================================ FILE: silkworm/node/backend_kv_server.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::node { class BackEndKvServer : public ethbackend::grpc::server::BackEndServer, public db::kv::grpc::server::KvServer { public: BackEndKvServer(const rpc::ServerSettings& settings, const EthereumBackEnd& backend); BackEndKvServer(const BackEndKvServer&) = delete; BackEndKvServer& operator=(const BackEndKvServer&) = delete; protected: void register_async_services(::grpc::ServerBuilder& builder) override; void register_request_calls() override; }; } // namespace silkworm::node ================================================ FILE: silkworm/node/cli/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(CLI11 REQUIRED) find_package(magic_enum REQUIRED) add_library(silkworm_node_cli "node_options.cpp") target_link_libraries(silkworm_node_cli PUBLIC silkworm_node CLI11::CLI11) add_executable(backend_kv_server "backend_kv_server.cpp") target_link_libraries(backend_kv_server PRIVATE silkworm_node silkworm_infra_cli silkworm_db_cli silkworm_sync) add_executable(staged_pipeline "staged_pipeline.cpp") target_link_libraries(staged_pipeline PRIVATE silkworm_node silkworm_infra_cli magic_enum::magic_enum) ================================================ FILE: silkworm/node/cli/backend_kv_server.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::cmd::common; //! Assemble the relevant library version information std::string get_library_versions() { std::string library_versions{"gRPC: "}; library_versions.append(grpc::Version()); library_versions.append(" MDBX: "); library_versions.append(mdbx::get_version().git.describe); return library_versions; } //! Standalone BackEndKV server settings struct StandaloneBackEndKVSettings : public node::Settings { bool simulate_state_changes{false}; }; //! Parse the command-line arguments into the BackEnd and KV server settings void parse_command_line(int argc, char* argv[], CLI::App& app, StandaloneBackEndKVSettings& settings) { auto& log_settings = settings.log_settings; auto& node_settings = settings.node_settings; auto& server_settings = settings.server_settings; // Node options std::filesystem::path data_dir; add_option_data_dir(app, data_dir); std::string etherbase_address; add_option_etherbase(app, etherbase_address); uint32_t max_readers{0}; add_option_db_max_readers(app, max_readers); // RPC Server options add_option_private_api_address(app, server_settings.address_uri); add_option_remote_sentry_addresses(app, node_settings.remote_sentry_addresses, /* is_required = */ true); add_context_pool_options(app, server_settings.context_pool_settings); // Logging options add_logging_options(app, log_settings); // Standalone BackEndKV server options app.add_flag("--simulate.state.changes", settings.simulate_state_changes, "Simulate state change notifications"); app.parse(argc, argv); // Validate and assign settings if (!etherbase_address.empty()) { node_settings.etherbase = hex_to_address(etherbase_address); } node_settings.data_directory = std::make_unique(data_dir, /*create=*/false); node_settings.chaindata_env_config = datastore::kvdb::EnvConfig{node_settings.data_directory->chaindata().path().string(), /*create=*/false, /*readonly=*/true}; node_settings.chaindata_env_config.max_readers = max_readers; } std::shared_ptr make_sentry_client( const NodeSettings& node_settings, rpc::ClientContextPool& context_pool, datastore::kvdb::ROAccess db_access) { std::shared_ptr sentry_client; auto chain_head_provider = [db_access = std::move(db_access)]() { return db::read_chain_head(db_access); }; silkworm::sentry::eth::StatusDataProvider eth_status_data_provider{std::move(chain_head_provider), node_settings.chain_config.value()}; if (node_settings.remote_sentry_addresses.empty()) { SILKWORM_ASSERT(false); } else if (node_settings.remote_sentry_addresses.size() == 1) { // remote client auto remote_sentry_client = std::make_shared( node_settings.remote_sentry_addresses[0], *context_pool.next_context().grpc_context()); // wrap remote client in a session client sentry_client = std::make_shared( remote_sentry_client, silkworm::sentry::eth::StatusDataProvider::to_factory_function(std::move(eth_status_data_provider))); } else { std::vector> clients; for (const auto& address_uri : node_settings.remote_sentry_addresses) { // remote client auto remote_sentry_client = std::make_shared( address_uri, *context_pool.next_context().grpc_context()); // wrap remote client in a session client auto session_sentry_client = std::make_shared( remote_sentry_client, silkworm::sentry::eth::StatusDataProvider::to_factory_function(eth_status_data_provider)); clients.push_back(session_sentry_client); } sentry_client = std::make_shared(std::move(clients)); } return sentry_client; } int main(int argc, char* argv[]) { using namespace silkworm::concurrency::awaitable_wait_for_one; CLI::App cli{"ETH BACKEND & KV server"}; try { StandaloneBackEndKVSettings settings; parse_command_line(argc, argv, cli, settings); const auto pid = boost::this_process::get_id(); const auto tid = std::this_thread::get_id(); auto& log_settings = settings.log_settings; auto& node_settings = settings.node_settings; auto& server_settings = settings.server_settings; // Initialize logging with custom settings log::init(log_settings); log::set_thread_name("bekv_server"); const auto node_name{get_node_name_from_build_info(silkworm_get_buildinfo())}; SILK_LOG << "BackEndKvServer build info: " << node_name; SILK_LOG << "BackEndKvServer library info: " << get_library_versions(); SILK_LOG << "BackEndKvServer launched with chaindata: " << node_settings.chaindata_env_config.path << " address: " << server_settings.address_uri << " contexts: " << server_settings.context_pool_settings.num_contexts; auto chaindata_env = datastore::kvdb::open_env(node_settings.chaindata_env_config); SILK_INFO << "BackEndKvServer MDBX max readers: " << chaindata_env.max_readers(); // Read chain config from database (this allows for custom config) datastore::kvdb::ROAccess chaindata{chaindata_env}; datastore::kvdb::ROTxnManaged ro_txn = chaindata.start_ro_tx(); node_settings.chain_config = db::read_chain_config(ro_txn); if (!node_settings.chain_config.has_value()) { throw std::runtime_error("invalid chain config in database"); } node_settings.network_id = node_settings.chain_config.value().chain_id; SILK_INFO << "BackEndKvServer chain from db: " << node_settings.network_id; // Load genesis hash node_settings.chain_config->genesis_hash = db::read_canonical_header_hash(ro_txn, 0); if (!node_settings.chain_config->genesis_hash.has_value()) { throw std::runtime_error("could not load genesis hash"); } SILK_INFO << "BackEndKvServer genesis from db: " << to_hex(*node_settings.chain_config->genesis_hash); rpc::ClientContextPool context_pool{ server_settings.context_pool_settings, }; auto sentry_client = make_sentry_client(node_settings, context_pool, chaindata); EthereumBackEnd backend{ node_settings, chaindata, sentry_client, }; backend.set_node_name(node_name); node::BackEndKvServer server{server_settings, backend}; // Standalone BackEndKV server has no staged loop, so this simulates periodic state changes Task tasks; if (settings.simulate_state_changes) { using namespace boost::asio::experimental::awaitable_operators; auto state_changes_simulator = [](auto& ctx_pool, auto& be) -> Task { boost::asio::steady_timer state_changes_timer{ctx_pool.next_ioc()}; static constexpr std::chrono::seconds kStateChangeInterval{10}; static constexpr silkworm::BlockNum kStartBlock{100'000'000}; static constexpr uint64_t kGasLimit{30'000'000}; auto run = [&]() { boost::system::error_code ec; while (ec != boost::asio::error::operation_aborted) { state_changes_timer.expires_at(std::chrono::steady_clock::now() + kStateChangeInterval); state_changes_timer.wait(ec); static auto block_num = kStartBlock; be.state_change_source()->start_new_batch(block_num, evmc::bytes32{}, {}, false); be.state_change_source()->notify_batch(0, kGasLimit); SILK_INFO << "New batch notified for block: " << block_num; ++block_num; } }; auto stop = [&state_changes_timer]() { state_changes_timer.cancel(); }; co_await concurrency::async_thread(std::move(run), std::move(stop), "state-c-sim"); }; tasks = state_changes_simulator(context_pool, backend) && server.async_run("bekv-server"); } else { tasks = server.async_run("bekv-server"); } // Go! auto run_future = boost::asio::co_spawn( context_pool.next_ioc(), std::move(tasks) || ShutdownSignal::wait(), boost::asio::use_future); context_pool.start(); SILK_LOG << "BackEndKvServer is now running [pid=" + std::to_string(pid) + ", main thread=" << tid << "]"; // Wait for shutdown_signal or an exception run_future.get(); SILK_LOG << "BackEndKvServer exiting [pid=" + std::to_string(pid) + ", main thread=" << tid << "]"; return 0; } catch (const CLI::ParseError& pe) { return cli.exit(pe); } catch (const std::exception& e) { SILK_CRIT << "BackEndKvServer exiting due to exception: " << e.what(); return -2; } catch (...) { SILK_CRIT << "BackEndKvServer exiting due to unexpected exception"; return -3; } } ================================================ FILE: silkworm/node/cli/node_options.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node_options.hpp" #include #include #include #include #include namespace silkworm::cmd::common { void add_node_options(CLI::App& cli, NodeSettings& settings) { cli.add_flag("--chaindata.exclusive", settings.chaindata_env_config.exclusive, "Chaindata database opened in exclusive mode"); cli.add_flag("--chaindata.readahead", settings.chaindata_env_config.read_ahead, "Chaindata database enable readahead"); cli.add_flag("--chaindata.writemap", settings.chaindata_env_config.write_map, "Chaindata database enable writemap"); add_option_human_size( cli, "--chaindata.growthsize", settings.chaindata_env_config.growth_size, 32_Mebi, 128_Tebi, "Chaindata database growth size."); add_option_human_size( cli, "--chaindata.pagesize", settings.chaindata_env_config.page_size, 256, 64_Kibi, "Chaindata database page size. A power of 2"); add_option_human_size( cli, "--chaindata.maxsize", settings.chaindata_env_config.max_size, 32_Mebi, 128_Tebi, "Chaindata database max size."); add_option_human_size( cli, "--batchsize", settings.batch_size, 64_Mebi, 16_Gibi, "Batch size for stage execution"); add_option_human_size( cli, "--etl.buffersize", settings.etl_buffer_size, 64_Mebi, 1_Gibi, "Buffer size for ETL operations"); cli.add_option("--sync.loop.throttle", settings.sync_loop_throttle_seconds, "Sets the minimum delay between sync loop starts (in seconds)") ->capture_default_str() ->check(CLI::Range(1u, 7200u)); cli.add_option("--sync.loop.log.interval", settings.sync_loop_log_interval_seconds, "Sets the interval between sync loop logs (in seconds)") ->capture_default_str() ->check(CLI::Range(10u, 600u)); cli.add_flag("--fakepow", settings.fake_pow, "Disables proof-of-work verification"); add_option_remote_sentry_addresses(cli, settings.remote_sentry_addresses, /*is_required=*/false); cli.add_option("--exec.api.addr", settings.exec_api_address) ->description("Execution API GRPC server bind address (IP:port) for connecting an external chain sync client"); // Chain options add_option_chain(cli, settings.network_id); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/node/cli/node_options.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::cmd::common { void add_node_options(CLI::App& cli, NodeSettings& settings); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/node/cli/staged_pipeline.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace fs = std::filesystem; using namespace silkworm; using namespace silkworm::datastore; class Progress { public: explicit Progress(uint32_t width) : bar_width_{width}, percent_step_{100u / width} {}; ~Progress() = default; //! Returns current progress percent uint32_t percent() const { if (!max_counter_) { return 100; } if (!current_counter_) { return 0; } return static_cast(current_counter_ * 100 / max_counter_); } void step() { ++current_counter_; } void set_current(size_t count) { current_counter_ = std::max(count, current_counter_); } size_t get_current() const noexcept { return current_counter_; } size_t get_increment_count() const noexcept { return bar_width_ ? (max_counter_ / bar_width_) : 0u; } void reset() { current_counter_ = 0; printed_bar_len_ = 0; } void set_task_count(size_t iterations) { reset(); max_counter_ = iterations; } //! Prints progress ticks std::string print_interval(char c = '.') { uint32_t percentage{std::min(percent(), 100u)}; uint32_t num_chars{percentage / percent_step_}; if (!num_chars) return ""; uint32_t int_chars{num_chars - printed_bar_len_}; if (!int_chars) return ""; std::string ret(int_chars, c); printed_bar_len_ += int_chars; return ret; } [[maybe_unused]] std::string print_progress(char c = '.') const { uint32_t percentage{percent()}; uint32_t num_chars{percentage / percent_step_}; if (!num_chars) { return ""; } std::string ret(num_chars, c); return ret; } private: uint32_t bar_width_; uint32_t percent_step_; size_t max_counter_{0}; size_t current_counter_{0}; uint32_t printed_bar_len_{0}; }; void cursor_for_each(::mdbx::cursor& cursor, kvdb::WalkFuncRef walker) { auto data = cursor.eof() ? cursor.to_first(/*throw_notfound=*/false) : cursor.current(/*throw_notfound=*/false); while (data) { walker(kvdb::from_slice(data.key), kvdb::from_slice(data.value)); data = cursor.move(mdbx::cursor::move_operation::next, /*throw_notfound=*/false); } } bool user_confirmation(const std::string& message = {"Confirm ?"}) { static std::regex pattern{"^([yY])?([nN])?$"}; std::smatch matches; std::string user_input; do { std::cout << "\n" << message << " [y/N] "; std::cin >> user_input; std::cin.clear(); if (std::regex_search(user_input, matches, pattern, std::regex_constants::match_default)) { break; } std::cout << "Unexpected user input: " << user_input << "\n"; } while (true); return matches[2].length() == 0; } //! Comparison for stage names according to the forward stage order struct StageOrderCompare { bool operator()(const std::string& lhs, const std::string& rhs) const { static const auto kStagesForwardOrder = fix_stages_forward_order(); const auto lhs_it = std::ranges::find(kStagesForwardOrder, lhs); const auto rhs_it = std::ranges::find(kStagesForwardOrder, rhs); if (lhs_it == kStagesForwardOrder.end() && rhs_it == kStagesForwardOrder.end()) { return lhs < rhs; } return lhs_it < rhs_it; } private: static stagedsync::ExecutionPipeline::StageNames fix_stages_forward_order() { auto stages_forward_order = stagedsync::ExecutionPipeline::stages_forward_order(); add_after_history_index(stages_forward_order, db::stages::kStorageHistoryIndexKey); add_after_history_index(stages_forward_order, db::stages::kAccountHistoryIndexKey); return stages_forward_order; } static void add_after_history_index(stagedsync::ExecutionPipeline::StageNames& forward_stages, std::string_view stage) { auto history_index_it = std::ranges::find(forward_stages, db::stages::kHistoryIndexKey); forward_stages.insert(std::next(history_index_it), stage); } }; void list_stages(const kvdb::EnvConfig& config) { static constexpr char kTableHeaderFormat[] = " %-26s %10s "; static constexpr char kTableRowFormat[] = " %-26s %10u %-8s"; auto env = kvdb::open_env(config); auto txn = env.start_read(); if (!kvdb::has_map(txn, db::table::kSyncStageProgress.name)) { throw std::runtime_error("Either not a Silkworm db or table " + std::string{db::table::kSyncStageProgress.name} + " not found"); } auto stage_cursor = open_cursor(txn, db::table::kSyncStageProgress); if (txn.get_map_stat(stage_cursor.map()).ms_entries) { std::map stage_height_by_name; auto result = stage_cursor.to_first(/*throw_notfound =*/false); while (result.done) { std::string name{result.key.string_view()}; const size_t height = endian::load_big_u64(static_cast(result.value.data())); stage_height_by_name.insert_or_assign(std::move(name), height); result = stage_cursor.to_next(/*throw_notfound =*/false); } std::cout << "\n" << (boost::format(kTableHeaderFormat) % "Stage Name" % "Block") << "\n"; std::cout << (boost::format(kTableHeaderFormat) % std::string(26, '-') % std::string(10, '-')) << "\n"; for (const auto& [stage_name, stage_height] : stage_height_by_name) { // Handle "prune_" stages static constexpr std::string_view kPrunePrefix{"prune_"}; size_t offset{0}; if (std::memcmp(stage_name.data(), kPrunePrefix.data(), kPrunePrefix.size()) == 0) { offset = kPrunePrefix.size(); } const bool known = db::stages::is_known_stage(stage_name.data() + offset); std::cout << (boost::format(kTableRowFormat) % stage_name % stage_height % (known ? std::string(8, ' ') : "Unknown")) << "\n"; } std::cout << "\n\n"; } else { std::cout << "\n There are no stages to list\n\n"; } txn.abort(); env.close(config.shared); } void set_stage_progress(kvdb::EnvConfig& config, const std::string& stage_name, uint32_t new_height, bool dry) { config.readonly = false; if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } auto env{kvdb::open_env(config)}; kvdb::RWTxnManaged txn{env}; if (!db::stages::is_known_stage(stage_name)) { throw std::runtime_error("Stage name " + stage_name + " is not known"); } if (!has_map(txn, db::table::kSyncStageProgress.name)) { throw std::runtime_error("Either non Silkworm db or table " + std::string(db::table::kSyncStageProgress.name) + " not found"); } auto old_height{db::stages::read_stage_progress(txn, stage_name)}; db::stages::write_stage_progress(txn, stage_name, new_height); if (!dry) { txn.commit_and_renew(); } std::cout << "\n Stage " << stage_name << " touched from " << old_height << " to " << new_height << "\n\n"; } static stagedsync::BodiesStageFactory make_bodies_stage_factory( const ChainConfig& chain_config, db::DataModelFactory data_model_factory) { return [&chain_config, data_model_factory = std::move(data_model_factory)](stagedsync::SyncContext* sync_context) { return std::make_unique( sync_context, chain_config, data_model_factory, [] { return 0; }); }; } static stagedsync::StageContainerFactory make_stages_factory( const NodeSettings& node_settings, db::DataModelFactory data_model_factory) { auto bodies_stage_factory = make_bodies_stage_factory(*node_settings.chain_config, data_model_factory); return stagedsync::StagesFactoryImpl::to_factory({ node_settings, std::move(data_model_factory), std::move(bodies_stage_factory), }); } void debug_unwind(kvdb::EnvConfig& config, std::unique_ptr&& data_directory, BlockNum height, uint32_t step, const bool dry, const bool force, const std::string& start_at_stage, const std::string& stop_before_stage) { ensure(config.exclusive, "Function requires exclusive access to database"); ensure(height > 0, "Function requires non-zero height block"); config.readonly = false; const auto datadir_path = std::filesystem::path{config.path}.parent_path(); SILK_INFO << "Debug unwind datadir: " << datadir_path.string(); Environment::set_stop_at_block(height); Environment::set_start_at_stage(start_at_stage); Environment::set_stop_before_stage(stop_before_stage); db::DataStore data_store{config, data_directory->snapshots().path()}; kvdb::ROTxnManaged ro_txn = data_store.chaindata().access_ro().start_ro_tx(); const auto chain_config = db::read_chain_config(ro_txn); ensure(chain_config.has_value(), "Uninitialized Silkworm db or unknown/custom chain"); ro_txn.abort(); db::DataModelFactory data_model_factory{data_store.ref()}; // We need full snapshot sync to take place to have database tables properly updated snapshots::SnapshotSettings snapshot_settings{ .no_downloader = true, // do not download snapshots .stop_freezer = true, // do not generate new snapshots .no_seeding = true, // do not seed existing snapshots }; struct EmptyStageScheduler : public datastore::StageScheduler { Task schedule(std::function /*callback*/) override { co_return; } }; EmptyStageScheduler empty_scheduler; db::SnapshotSync snapshot_sync{ std::move(snapshot_settings), chain_config->chain_id, data_store.ref(), std::filesystem::path{}, empty_scheduler}; boost::asio::io_context io_context; std::thread ioc_thread{[&]() { boost::asio::executor_work_guard work{io_context.get_executor()}; io_context.run(); }}; auto _ = gsl::finally([&]() { io_context.stop(); ioc_thread.join(); }); auto snap_sync_future = concurrency::spawn_future(io_context.get_executor(), snapshot_sync.run()); snap_sync_future.get(); // Commit is enabled by default in RWTxn(Managed), so we need to check here kvdb::RWTxnManaged txn = data_store.chaindata().access_rw().start_rw_tx(); if (dry) { txn.disable_commit(); } else { if (!force && !user_confirmation("Are you sure? This will apply the changes to the database!")) { return; } txn.enable_commit(); // this doesn't harm and works even if default changes } // We should have all the blocks in the interval already validated by stages Headers+Bodies const auto headers_progress = db::stages::read_stage_progress(txn, db::stages::kHeadersKey); ensure(headers_progress >= height, [&]() { return "Insufficient Headers progress: " + std::to_string(headers_progress); }); const auto bodies_progress = db::stages::read_stage_progress(txn, db::stages::kBlockBodiesKey); ensure(bodies_progress >= height, [&]() { return "Insufficient Bodies progress: " + std::to_string(bodies_progress); }); NodeSettings settings{ .data_directory = std::move(data_directory), .chaindata_env_config = config, .chain_config = chain_config}; // Start timer scheduler thread to observe stage progress during processing stagedsync::TimerFactory log_timer_factory = [&](std::function callback) { return std::make_shared(io_context.get_executor(), settings.sync_loop_log_interval_seconds * 1000, std::move(callback)); }; stagedsync::ExecutionPipeline stage_pipeline{ data_model_factory, std::move(log_timer_factory), make_stages_factory(settings, data_model_factory), }; const auto forward_target = height; SILK_INFO << "Debug unwind: forward to=" << forward_target << " START"; const auto forward_result = stage_pipeline.forward(txn, forward_target); SILK_INFO << "Debug unwind: forward to=" << forward_target << " END"; ensure(forward_result == stagedsync::Stage::Result::kStoppedByEnv, [&]() { return "Debug unwind: forward failed " + std::string{magic_enum::enum_name(forward_result)}; }); const auto unwind_point = height - step; SILK_INFO << "Debug unwind: unwind down to block=" << unwind_point << " START"; const auto unwind_result = stage_pipeline.unwind(txn, unwind_point); ensure(unwind_result == stagedsync::Stage::Result::kSuccess, [&]() { return "unwind failed: " + std::string{magic_enum::enum_name(unwind_result)}; }); SILK_INFO << "Debug unwind: unwind down to block=" << unwind_point << " END"; SILK_INFO << "Debug unwind: forward+unwind success up to block=" << height; // Unwind has just set progress for pre-Execution stages back to unwind_point even if it is within the snapshots // We need to reset progress for such stages to the max block in snapshots to avoid database update on next start auto& blocks_repository = data_store.blocks_repository(); db::stages::write_stage_progress(txn, db::stages::kHeadersKey, blocks_repository.max_timestamp_available()); db::stages::write_stage_progress(txn, db::stages::kBlockBodiesKey, blocks_repository.max_timestamp_available()); db::stages::write_stage_progress(txn, db::stages::kBlockHashesKey, blocks_repository.max_timestamp_available()); db::stages::write_stage_progress(txn, db::stages::kSendersKey, blocks_repository.max_timestamp_available()); txn.commit_and_stop(); } void unwind(kvdb::EnvConfig& config, std::unique_ptr&& data_directory, BlockNum unwind_point, const bool remove_blocks, const bool dry) { ensure(config.exclusive, "Function requires exclusive access to database"); config.readonly = false; db::DataStore data_store{config, data_directory->snapshots().path()}; kvdb::RWTxnManaged txn = data_store.chaindata().access_rw().start_rw_tx(); // Commit is enabled by default in RWTxn(Managed), so we need to check here if (dry) { txn.disable_commit(); } else { if (!user_confirmation("Are you sure? This will apply the unwind changes to the database!")) { return; } txn.enable_commit(); // this doesn't harm and works even if default changes } const auto chain_config = db::read_chain_config(txn); ensure(chain_config.has_value(), "Not an initialized Silkworm db or unknown/custom chain"); db::DataModelFactory data_model_factory{data_store.ref()}; boost::asio::io_context io_context; NodeSettings settings{ .data_directory = std::move(data_directory), .chaindata_env_config = config, .chain_config = chain_config}; stagedsync::TimerFactory log_timer_factory = [&](std::function callback) { return std::make_shared(io_context.get_executor(), settings.sync_loop_log_interval_seconds * 1000, std::move(callback)); }; std::thread ioc_thread{[&]() { boost::asio::executor_work_guard work{io_context.get_executor()}; io_context.run(); }}; auto _ = gsl::finally([&]() { io_context.stop(); ioc_thread.join(); }); stagedsync::ExecutionPipeline stage_pipeline{ data_model_factory, std::move(log_timer_factory), make_stages_factory(settings, data_model_factory), }; const auto unwind_result = stage_pipeline.unwind(txn, unwind_point); ensure(unwind_result == stagedsync::Stage::Result::kSuccess, [&]() { return "unwind failed: " + std::string{magic_enum::enum_name(unwind_result)}; }); std::cout << "\n Staged pipeline unwind up to block: " << unwind_point << " completed\n"; // In consensus-separated Sync/Execution design block headers and bodies are stored by the Sync component // not by the Execution component: hence, ExecutionPipeline will not remove them during unwind phase if (remove_blocks) { std::cout << " Removing also block headers and bodies up to block: " << unwind_point << "\n"; // Remove the block bodies up to the unwind point const auto body_cursor{txn.rw_cursor(db::table::kBlockBodies)}; const auto start_key{db::block_key(unwind_point + 1)}; std::size_t erased_bodies{0}; auto body_data{body_cursor->lower_bound(kvdb::to_slice(start_key), /*throw_notfound=*/false)}; while (body_data) { body_cursor->erase(); ++erased_bodies; body_data = body_cursor->to_next(/*throw_notfound=*/false); } std::cout << " Removed block bodies erased: " << erased_bodies << "\n"; // Remove the block headers up to the unwind point const auto header_cursor{txn.rw_cursor(db::table::kHeaders)}; std::size_t erased_headers{0}; auto header_data{header_cursor->lower_bound(kvdb::to_slice(start_key), /*throw_notfound=*/false)}; while (header_data) { header_cursor->erase(); ++erased_headers; header_data = header_cursor->to_next(/*throw_notfound=*/false); } std::cout << " Removed block headers erased: " << erased_headers << "\n"; // Remove the canonical hashes up to the unwind point const auto canonical_cursor{txn.rw_cursor(db::table::kCanonicalHashes)}; std::size_t erased_hashes{0}; auto hash_data{canonical_cursor->lower_bound(kvdb::to_slice(start_key), /*throw_notfound=*/false)}; while (hash_data) { canonical_cursor->erase(); ++erased_hashes; hash_data = canonical_cursor->to_next(/*throw_notfound=*/false); } std::cout << " Removed canonical hashes erased: " << erased_hashes << "\n"; txn.commit_and_stop(); } } void forward(kvdb::EnvConfig& config, std::unique_ptr&& data_directory, BlockNum forward_point, const bool dry, const std::string& start_at_stage, const std::string& stop_before_stage) { ensure(config.exclusive, "Function requires exclusive access to database"); config.readonly = false; Environment::set_stop_at_block(forward_point); Environment::set_start_at_stage(start_at_stage); Environment::set_stop_before_stage(stop_before_stage); db::DataStore data_store{config, data_directory->snapshots().path()}; kvdb::RWTxnManaged txn = data_store.chaindata().access_rw().start_rw_tx(); // Commit is enabled by default in RWTxn(Managed), so we need to check here if (dry) { txn.disable_commit(); } else { if (!user_confirmation("Are you sure? This will apply the changes to the database!")) { return; } txn.enable_commit(); // this doesn't harm and works even if default changes } const auto chain_config{db::read_chain_config(txn)}; ensure(chain_config.has_value(), "Uninitialized Silkworm db or unknown/custom chain"); const auto datadir_path = std::filesystem::path{config.path}.parent_path(); SILK_INFO << "Forward: datadir=" << datadir_path.string(); db::DataModelFactory data_model_factory{data_store.ref()}; boost::asio::io_context io_context; NodeSettings settings{ .data_directory = std::move(data_directory), .chaindata_env_config = config, .chain_config = chain_config}; // Start timer scheduler thread to observe stage progress during processing stagedsync::TimerFactory log_timer_factory = [&](std::function callback) { return std::make_shared(io_context.get_executor(), settings.sync_loop_log_interval_seconds * 1000, std::move(callback)); }; std::thread ioc_thread{[&]() { boost::asio::executor_work_guard work{io_context.get_executor()}; io_context.run(); }}; auto _ = gsl::finally([&]() { io_context.stop(); ioc_thread.join(); }); stagedsync::ExecutionPipeline stage_pipeline{ data_model_factory, std::move(log_timer_factory), make_stages_factory(settings, data_model_factory), }; const auto forward_result = stage_pipeline.forward(txn, forward_point); ensure(forward_result == stagedsync::Stage::Result::kSuccess, [&]() { return "forward failed: " + std::string{magic_enum::enum_name(forward_result)}; }); std::cout << "\n Staged pipeline forward up to block: " << forward_point << " completed\n"; } void bisect_pipeline(kvdb::EnvConfig& config, BlockNum start, BlockNum end, const bool dry, const std::string& start_at_stage, const std::string& stop_before_stage) { ensure(config.exclusive, "Function requires exclusive access to database"); ensure(start > 0, "Function requires non-zero start block"); ensure(end >= start, "Function requires valid block interval: end must be greater than or equal to start"); config.readonly = false; Environment::set_stop_at_block(end); Environment::set_start_at_stage(start_at_stage); Environment::set_stop_before_stage(stop_before_stage); auto data_directory = std::make_unique(); db::DataStore data_store{config, data_directory->snapshots().path()}; kvdb::RWTxnManaged txn = data_store.chaindata().access_rw().start_rw_tx(); // Commit is enabled by default in RWTxn(Managed), so we need to check here if (dry) { txn.disable_commit(); } else { if (!user_confirmation("Are you sure? This will apply the changes to the database!")) { return; } txn.enable_commit(); // this doesn't harm and works even if default changes } const auto chain_config{db::read_chain_config(txn)}; ensure(chain_config.has_value(), "Uninitialized Silkworm db or unknown/custom chain"); const auto datadir_path = std::filesystem::path{config.path}.parent_path(); SILK_INFO << "Bisect: datadir=" << datadir_path.string(); db::DataModelFactory data_model_factory{data_store.ref()}; boost::asio::io_context io_context; NodeSettings settings{ .data_directory = std::move(data_directory), .chaindata_env_config = config, .chain_config = chain_config}; // Start timer scheduler thread to observe stage progress during processing stagedsync::TimerFactory log_timer_factory = [&](std::function callback) { return std::make_shared(io_context.get_executor(), settings.sync_loop_log_interval_seconds * 1000, std::move(callback)); }; std::thread ioc_thread{[&]() { boost::asio::executor_work_guard work{io_context.get_executor()}; io_context.run(); }}; auto _ = gsl::finally([&]() { io_context.stop(); ioc_thread.join(); }); stagedsync::ExecutionPipeline stage_pipeline{ data_model_factory, std::move(log_timer_factory), make_stages_factory(settings, data_model_factory), }; // Unwind staged pipeline down to the previous block wrt start const auto initial_unwind_point = start - 1; SILK_INFO << "Bisect: unwind down to block=" << initial_unwind_point << " START"; const auto first_unwind_result = stage_pipeline.unwind(txn, initial_unwind_point); ensure(first_unwind_result == stagedsync::Stage::Result::kSuccess, [&]() { return "unwind failed: " + std::string{magic_enum::enum_name(first_unwind_result)}; }); SILK_INFO << "Bisect: unwind down to block=" << initial_unwind_point << " END"; BlockNum left_point = start, right_point = end; std::optional first_broken_point; while (left_point < right_point) { Environment::set_stop_at_block(right_point); const uint64_t median_point = (left_point + right_point) >> 1; SILK_INFO << "Bisect: forward from=" << left_point << " to=" << right_point << " START"; const auto forward_result = stage_pipeline.forward(txn, right_point); SILK_INFO << "Bisect: forward from=" << left_point << " to=" << right_point << " END"; if (forward_result == stagedsync::Stage::Result::kSuccess || forward_result == stagedsync::Stage::Result::kStoppedByEnv) { left_point = right_point; if (right_point < end) { right_point = (right_point + first_broken_point.value_or(end)) >> 1; } } else if (stage_pipeline.unwind_point()) { first_broken_point = right_point; SILK_INFO << "Bisect: first_broken_point=" << *first_broken_point << " median=" << median_point; const auto unwind_point = *stage_pipeline.unwind_point(); SILK_INFO << "Bisect: unwind down to block=" << unwind_point << " START"; const auto unwind_result = stage_pipeline.unwind(txn, unwind_point); ensure(unwind_result == stagedsync::Stage::Result::kSuccess, [&]() { return "unwind failed: " + std::string{magic_enum::enum_name(unwind_result)}; }); SILK_INFO << "Bisect: unwind down to block=" << unwind_point << " END"; right_point = unwind_point; } else { if (forward_result != stagedsync::Stage::Result::kAborted) { SILK_ERROR << "Bisect: unexpected forward failure w/o unwind point: " << magic_enum::enum_name(forward_result); } break; } } if (left_point == end && right_point == end) { SILK_INFO << "Bisect: success at block=" << right_point; } else { SILKWORM_ASSERT(first_broken_point); SILK_INFO << "Bisect: failed at block=" << first_broken_point.value(); } } void reset_to_download(const kvdb::EnvConfig& config, const bool keep_senders, const bool force) { if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } if (!force && !user_confirmation("Are you sure? This will erase the database content written after " + std::string(keep_senders ? db::stages::kSendersKey : db::stages::kBlockHashesKey) + " stage!")) { return; } auto env{kvdb::open_env(config)}; kvdb::RWTxnManaged txn(env); StopWatch sw(/*auto_start=*/true); // Void finish stage db::stages::write_stage_progress(txn, db::stages::kFinishKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kFinishKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); // Void TxLookup stage SILK_INFO_M(db::stages::kTxLookupKey, {"table", db::table::kTxLookup.name_str()}) << "truncating ..."; kvdb::PooledCursor source(*txn, db::table::kTxLookup); txn->clear_map(source.map()); db::stages::write_stage_progress(txn, db::stages::kTxLookupKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kTxLookupKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kTxLookupKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); // Void CallTraces stage SILK_INFO_M(db::stages::kCallTracesKey, {"table", db::table::kCallFromIndex.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kCallFromIndex); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kCallTracesKey, {"table", db::table::kCallToIndex.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kCallToIndex); txn->clear_map(source.map()); db::stages::write_stage_progress(txn, db::stages::kCallTracesKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kCallTracesKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kCallTracesKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); // Void LogIndex stage SILK_INFO_M(db::stages::kLogIndexKey, {"table", db::table::kLogTopicIndex.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kLogTopicIndex); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kLogIndexKey, {"table", db::table::kLogAddressIndex.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kLogAddressIndex); txn->clear_map(source.map()); db::stages::write_stage_progress(txn, db::stages::kLogIndexKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kLogIndexKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kLogIndexKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); // Void HistoryIndex (StorageHistoryIndex + AccountHistoryIndex) stage SILK_INFO_M(db::stages::kStorageHistoryIndexKey, {"table", db::table::kStorageHistory.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kStorageHistory); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kAccountHistoryIndexKey, {"table", db::table::kAccountHistory.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kAccountHistory); txn->clear_map(source.map()); db::stages::write_stage_progress(txn, db::stages::kStorageHistoryIndexKey, 0); db::stages::write_stage_progress(txn, db::stages::kAccountHistoryIndexKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kStorageHistoryIndexKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kAccountHistoryIndexKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kStorageHistoryIndexKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); SILK_INFO_M(db::stages::kAccountHistoryIndexKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); // Void HashState stage SILK_INFO_M(db::stages::kHashStateKey, {"table", db::table::kHashedCodeHash.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kHashedCodeHash); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kHashStateKey, {"table", db::table::kHashedStorage.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kHashedStorage); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kHashStateKey, {"table", db::table::kHashedAccounts.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kHashedAccounts); txn->clear_map(source.map()); db::stages::write_stage_progress(txn, db::stages::kHashStateKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kHashStateKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kHashStateKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); // Void Intermediate Hashes stage SILK_INFO_M(db::stages::kIntermediateHashesKey, {"table", db::table::kTrieOfStorage.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kTrieOfStorage); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kIntermediateHashesKey, {"table", db::table::kTrieOfAccounts.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kTrieOfAccounts); txn->clear_map(source.map()); db::stages::write_stage_progress(txn, db::stages::kIntermediateHashesKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kIntermediateHashesKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); // Void Execution stage SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kBlockReceipts.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kBlockReceipts); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kLogs.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kLogs); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kIncarnationMap.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kIncarnationMap); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kCode.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kCode); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kPlainCodeHash.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kPlainCodeHash); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kAccountChangeSet.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kAccountChangeSet); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kStorageChangeSet.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kStorageChangeSet); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kCallTraceSet.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kCallTraceSet); txn->clear_map(source.map()); SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kPlainState.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kPlainState); txn->clear_map(source.map()); txn.commit_and_renew(); { SILK_INFO_M(db::stages::kExecutionKey, {"table", db::table::kPlainState.name_str()}) << "redo genesis allocations ..."; // Read chain ID from database const auto chain_config{db::read_chain_config(txn)}; ensure(chain_config.has_value(), "cannot read chain configuration from database"); // Read genesis data from embedded file auto source_data{read_genesis_data(chain_config->chain_id)}; // Parse genesis JSON data // N.B. = instead of {} initialization due to https://github.com/nlohmann/json/issues/2204 auto genesis_json = nlohmann::json::parse(source_data, nullptr, /* allow_exceptions = */ false); db::initialize_genesis_allocations(txn, genesis_json); txn.commit_and_renew(); } db::stages::write_stage_progress(txn, db::stages::kExecutionKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kExecutionKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kExecutionKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (!keep_senders) { // Void Senders stage SILK_INFO_M(db::stages::kSendersKey, {"table", db::table::kSenders.name_str()}) << "truncating ..."; source.bind(*txn, db::table::kSenders); txn->clear_map(source.map()); db::stages::write_stage_progress(txn, db::stages::kSendersKey, 0); db::stages::write_stage_prune_progress(txn, db::stages::kSendersKey, 0); txn.commit_and_renew(); SILK_INFO_M(db::stages::kSendersKey, {"new height", "0", "in", StopWatch::format(sw.lap().second)}); if (SignalHandler::signalled()) throw std::runtime_error("Aborted"); } const auto [tp, _] = sw.stop(); const auto duration = sw.since_start(tp); SILK_INFO_M("All done", {"in", StopWatch::format(duration)}); } void trie_account_analysis(const kvdb::EnvConfig& config) { static std::string fmt_hdr{" %-24s %=50s "}; if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } auto env{kvdb::open_env(config)}; auto txn{env.start_read()}; std::cout << "\n" << (boost::format(fmt_hdr) % "Table name" % "%") << "\n" << (boost::format(fmt_hdr) % std::string(24, '-') % std::string(50, '-')) << "\n" << (boost::format(" %-24s ") % db::table::kTrieOfAccounts.name) << std::flush; std::map histogram; auto code_cursor = open_cursor(txn, db::table::kTrieOfAccounts); Progress progress{50}; size_t total_entries{txn.get_map_stat(code_cursor.map()).ms_entries}; progress.set_task_count(total_entries); size_t batch_size{progress.get_increment_count()}; code_cursor.to_first(); cursor_for_each(code_cursor, [&histogram, &batch_size, &progress](ByteView key, ByteView) { ++histogram[key.size()]; if (!--batch_size) { progress.set_current(progress.get_current() + progress.get_increment_count()); std::cout << progress.print_interval('.') << std::flush; batch_size = progress.get_increment_count(); } }); progress.set_current(total_entries); std::cout << progress.print_interval('.') << "\n"; if (!histogram.empty()) { std::cout << (boost::format(" %-4s %8s") % "Size" % "Count") << "\n" << (boost::format(" %-4s %8s") % std::string(4, '-') % std::string(8, '-')) << "\n"; for (const auto& [size, usage_count] : histogram) { std::cout << (boost::format(" %4u %8u") % size % usage_count) << "\n"; } } std::cout << "\n\n"; } void trie_scan(const kvdb::EnvConfig& config, bool del) { auto env{open_env(config)}; auto txn{env.start_write()}; std::vector tables{db::table::kTrieOfAccounts, db::table::kTrieOfStorage}; size_t counter{1}; for (const auto& map_config : tables) { if (SignalHandler::signalled()) { break; } kvdb::PooledCursor cursor(txn, map_config); std::cout << " Scanning " << map_config.name << "\n"; auto data{cursor.to_first(false)}; while (data) { if (data.value.empty()) { std::cout << "Empty value at key " << to_hex(kvdb::from_slice(data.key), true) << "\n"; if (del) { cursor.erase(); } } data = cursor.to_next(false); if (!--counter) { counter = 128; if (SignalHandler::signalled()) { break; } } } } if (!SignalHandler::signalled()) { txn.commit(); } std::cout << "\n\n"; } void trie_integrity(kvdb::EnvConfig& config, bool with_state_coverage, bool continue_scan, bool sanitize) { if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } using namespace std::chrono_literals; std::chrono::time_point start{std::chrono::steady_clock::now()}; auto env{open_env(config)}; auto txn{env.start_write()}; std::string source{db::table::kTrieOfAccounts.name}; bool is_healthy{true}; kvdb::PooledCursor trie_cursor1{txn, db::table::kTrieOfAccounts}; kvdb::PooledCursor trie_cursor2{txn, db::table::kTrieOfAccounts}; kvdb::PooledCursor state_cursor{txn, db::table::kHashedAccounts}; size_t prefix_len{0}; Bytes buffer; buffer.reserve(256); // First loop Accounts; Second loop Storage for (int loop_id{0}; loop_id < 2; ++loop_id) { if (loop_id != 0) { source = std::string(db::table::kTrieOfStorage.name); trie_cursor1.bind(txn, db::table::kTrieOfStorage); trie_cursor2.bind(txn, db::table::kTrieOfStorage); state_cursor.bind(txn, db::table::kHashedStorage); prefix_len = db::kHashedStoragePrefixLength; } SILK_INFO << "Checking ..." << log::Args{"source", source, "state", (with_state_coverage ? "true" : "false")}; auto data1{trie_cursor1.to_first(false)}; while (data1) { auto data1_k{kvdb::from_slice(data1.key)}; auto data1_v{kvdb::from_slice(data1.value)}; auto node_k{data1_k.substr(prefix_len)}; // Only unmarshal relevant data without copy on read if (data1_v.size() < 6) { throw std::runtime_error("At key " + to_hex(data1_k, true) + " invalid value length " + std::to_string(data1_v.size()) + ". Expected >= 6"); } if ((data1_v.size() - 6) % kHashLength != 0) { throw std::runtime_error("At key " + to_hex(data1_k, true) + " invalid hashes count " + std::to_string(data1_v.size() - 6) + ". Expected multiple of " + std::to_string(kHashLength)); } const auto node_state_mask{endian::load_big_u16(&data1_v[0])}; const auto node_tree_mask{endian::load_big_u16(&data1_v[2])}; const auto node_hash_mask{endian::load_big_u16(&data1_v[4])}; bool node_has_root{false}; if (!node_state_mask) { // This node should not be here as it does not point to anything std::string what{"At key " + to_hex(data1_k, true) + " node with nil state_mask. Does not point to anything. Shouldn't be here"}; if (!continue_scan) { throw std::runtime_error(what); } is_healthy = false; std::cout << " " << what << "\n"; } if (!trie::is_subset(node_tree_mask, node_state_mask)) { throw std::runtime_error("At key " + to_hex(data1_k, true) + " tree mask " + std::bitset<16>(node_tree_mask).to_string() + " is not subset of state mask " + std::bitset<16>(node_state_mask).to_string()); } if (!trie::is_subset(node_hash_mask, node_state_mask)) { throw std::runtime_error("At key " + to_hex(data1_k, true) + " hash mask " + std::bitset<16>(node_hash_mask).to_string() + " is not subset of state mask " + std::bitset<16>(node_state_mask).to_string()); } data1_v.remove_prefix(6); auto expected_hashes_count{static_cast(std::popcount(node_hash_mask))}; auto effective_hashes_count{data1_v.size() / kHashLength}; if (!(effective_hashes_count == expected_hashes_count || effective_hashes_count == expected_hashes_count + 1u)) { std::string what{"At key " + to_hex(data1_k, true) + " invalid hashes count " + std::to_string(effective_hashes_count) + ". Expected " + std::to_string(expected_hashes_count) + " from mask " + std::bitset<16>(node_hash_mask).to_string()}; if (!continue_scan) { throw std::runtime_error(what); } is_healthy = false; std::cout << " " << what << "\n"; } else { node_has_root = (effective_hashes_count == expected_hashes_count + 1u); } /* * Nodes with a key length == 0 are root nodes and MUST have a root hash */ if (node_k.empty() && !node_has_root) { std::string what{"At key " + to_hex(data1_k, true) + " found root node without root hash"}; if (!continue_scan) { throw std::runtime_error(what); } is_healthy = false; std::cout << " " << what << "\n"; } else if (!node_k.empty() && node_has_root) { log::Warning("Unexpected root hash", {"key", to_hex(data1_k, true)}); } /* * Check children (if any) * Each bit set in tree_mask must point to an existing child * Example : * Current key : 010203 * Current tree_mask : 0b0000000000000100 * Children key : 01020302 must exist * * Current key : 010203 * Current tree_mask : 0b0000000000100000 * Children key : 01020305 must exist */ if (node_tree_mask) { buffer.assign(data1_k).push_back('\0'); for (int i{std::countr_zero(node_tree_mask)}, e{std::bit_width(node_tree_mask)}; i < e; ++i) { if (((1 << i) & node_tree_mask) == 0) { continue; } buffer.back() = static_cast(i); auto data2{trie_cursor2.lower_bound(kvdb::to_slice(buffer), false)}; if (!data2) { throw std::runtime_error("At key " + to_hex(data1_k, true) + " tree mask is " + std::bitset<16>(node_tree_mask).to_string() + " but there is no child " + std::to_string(i) + " in db. LTE found is : null"); } auto data2_k{kvdb::from_slice(data2.key)}; if (!data2_k.starts_with(buffer)) { throw std::runtime_error("At key " + to_hex(data1_k, true) + " tree mask is " + std::bitset<16>(node_tree_mask).to_string() + " but there is no child " + std::to_string(i) + " in db. LTE found is : " + to_hex(data2_k, true)); } } } /* * Check parents (if not root) * Whether node key length > 1 then at least one parent with a key length shorter than this one must exist * Note : length is expressed in nibbles count * Example: * When node key : 01020304 * Must find one key in list {010203; 0102} (max jump of 2) */ if (!node_k.empty()) { bool found{false}; for (size_t i{data1_k.size() - 1}; i >= prefix_len && !found; --i) { auto parent_seek_key{data1_k.substr(0, i)}; auto data2{trie_cursor2.find(kvdb::to_slice(parent_seek_key), false)}; if (!data2) { continue; } found = true; const auto data2_v{kvdb::from_slice(data2.value)}; const auto parent_tree_mask{endian::load_big_u16(&data2_v[2])}; const auto parent_child_id{static_cast(data1_k[i])}; const auto parent_has_tree_bit{(parent_tree_mask & (1 << parent_child_id)) != 0}; if (!parent_has_tree_bit) { found = false; if (sanitize) { SILK_WARN << "Erasing orphan" << log::Args{"key", to_hex(data1_k, true)}; trie_cursor1.erase(); goto next_node; } std::string what{"At key " + to_hex(data1_k, true) + " found parent key " + to_hex(parent_seek_key, true) + " with tree mask : " + std::bitset<16>(parent_tree_mask).to_string() + " and no bit set at position " + std::to_string(parent_child_id)}; if (!continue_scan) { throw std::runtime_error(what); } is_healthy = false; std::cout << " " << what << "\n"; } } if (!found) { if (sanitize) { SILK_WARN << "Erasing orphan" << log::Args{"key", to_hex(data1_k, true)}; trie_cursor1.erase(); goto next_node; } std::string what{"At key " + to_hex(data1_k, true) + " no parent found"}; if (!continue_scan) { throw std::runtime_error(what); } is_healthy = false; std::cout << " " << what << "\n"; } } /* * Slow check for state coverage * Whether the node has any hash_state bit set then we must ensure the bits point to * an existing hashed state (either account or storage) * * Example: * Current key : 010203 * Current state_mask : 0b0000000000000001 * New Nibbled key : 01020300 * Packed key : 1230 * A state with prefix in range [1230 ... 1231) must exist */ if (with_state_coverage && node_state_mask) { // Buffer is used to build seek key buffer.assign(data1_k.substr(prefix_len)); buffer.push_back('\0'); auto bits_to_match{buffer.size() * 4}; // >>> See Erigon /ethdb/kv_util.go::BytesMask uint8_t mask{0xff}; auto fixed_bytes{(bits_to_match + 7) / 8}; auto shift_bits{bits_to_match & 7}; if (shift_bits != 0) { mask <<= (8 - shift_bits); } // <<< See Erigon's ByteMask for (int i{std::countr_zero(node_state_mask)}, e{std::bit_width(node_state_mask)}; i < e; ++i) { if (((1 << i) & node_state_mask) == 0) { continue; } bool found{false}; buffer.back() = static_cast(i); Bytes seek{trie::pack_nibbles(buffer)}; // On first loop we search HashedAccounts (which is not dup-sorted) if (!loop_id) { auto data3{state_cursor.lower_bound(kvdb::to_slice(seek), false)}; if (data3) { auto data3_k{kvdb::from_slice(data3.key)}; if (data3_k.size() >= fixed_bytes) { found = (bits_to_match == 0 || ((data3_k.substr(0, fixed_bytes - 1) == seek.substr(0, fixed_bytes - 1)) && ((data3_k[fixed_bytes - 1] & mask) == (seek[fixed_bytes - 1] & mask)))); } } if (!found) { std::string what{"At key " + to_hex(data1_k, true) + " state mask is " + std::bitset<16>(node_state_mask).to_string() + " but there is no child " + std::to_string(i) + "," + to_hex(seek, true) + " in hashed state"}; if (data3) { auto data3_k{kvdb::from_slice(data3.key)}; what.append(" found instead " + to_hex(data3_k, true)); } throw std::runtime_error(what); } } else { // On second loop we search HashedStorage (which is dup-sorted) auto data3{state_cursor.lower_bound_multivalue(kvdb::to_slice(data1_k.substr(0, prefix_len)), kvdb::to_slice(seek), false)}; if (data3) { auto data3_v{kvdb::from_slice(data3.value)}; if (data3_v.size() >= fixed_bytes) { found = (bits_to_match == 0 || ((data3_v.substr(0, fixed_bytes - 1) == seek.substr(0, fixed_bytes - 1)) && ((data3_v[fixed_bytes - 1] & mask) == (seek[fixed_bytes - 1] & mask)))); } } if (!found) { std::string what{"At key " + to_hex(data1_k, true) + " state mask is " + std::bitset<16>(node_state_mask).to_string() + " but there is no child " + std::to_string(i) + "," + to_hex(seek, true) + " in state"}; if (data3) { auto data3_k{kvdb::from_slice(data3.key)}; auto data3_v{kvdb::from_slice(data3.value)}; what.append(" found instead " + to_hex(data3_k, true) + to_hex(data3_v, false)); } throw std::runtime_error(what); } } } } if (std::chrono::time_point now{std::chrono::steady_clock::now()}; now - start >= 10s) { if (SignalHandler::signalled()) { throw std::runtime_error("Interrupted"); } std::swap(start, now); log::Info("Checking ...", {"source", source, "key", to_hex(data1_k, true)}); } next_node: data1 = trie_cursor1.to_next(false); } } if (!is_healthy) { throw std::runtime_error("Check failed"); } SILK_INFO << "Integrity check" << log::Args{"status", "ok"}; SILK_INFO << "Closing db" << log::Args{"path", env.get_path().string()}; txn.commit(); env.close(); } void trie_reset(const kvdb::EnvConfig& config, bool always_yes) { if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } if (!always_yes) { if (!user_confirmation()) { return; } } auto env{open_env(config)}; kvdb::RWTxnManaged txn{env}; SILK_INFO << "Clearing ..." << log::Args{"table", db::table::kTrieOfAccounts.name_str()}; txn->clear_map(db::table::kTrieOfAccounts.name_str()); SILK_INFO << "Clearing ..." << log::Args{"table", db::table::kTrieOfStorage.name_str()}; txn->clear_map(db::table::kTrieOfStorage.name_str()); SILK_INFO << "Setting progress ..." << log::Args{"key", std::string{db::stages::kIntermediateHashesKey}, "value", "0"}; db::stages::write_stage_progress(txn, db::stages::kIntermediateHashesKey, 0); SILK_INFO << "Committing ..." << log::Args{}; txn.commit_and_renew(); SILK_INFO << "Closing db" << log::Args{"path", env.get_path().string()}; env.close(); } void trie_root(const kvdb::EnvConfig& config) { if (!config.exclusive) { throw std::runtime_error("Function requires exclusive access to database"); } auto env{open_env(config)}; kvdb::ROTxnManaged txn{env}; kvdb::PooledCursor trie_accounts(txn, db::table::kTrieOfAccounts); // Retrieve expected state root auto hashstate_stage_progress{db::stages::read_stage_progress(txn, db::stages::kHashStateKey)}; auto intermediate_hashes_stage_progress{db::stages::read_stage_progress(txn, db::stages::kIntermediateHashesKey)}; if (hashstate_stage_progress != intermediate_hashes_stage_progress) { throw std::runtime_error("HashState and Intermediate hashes stage progresses do not match"); } auto header_hash{db::read_canonical_header_hash(txn, hashstate_stage_progress)}; auto header{db::read_header(txn, hashstate_stage_progress, header_hash->bytes)}; auto expected_state_root{header->state_root}; trie::PrefixSet empty_changes{}; // We need this to tell we have no changes. If nullptr means full regen trie::HashBuilder hash_builder; trie::TrieCursor trie_cursor{trie_accounts, &empty_changes}; for (auto trie_data{trie_cursor.to_prefix({})}; trie_data.key.has_value(); trie_data = trie_cursor.to_next()) { SILKWORM_ASSERT(!trie_data.first_uncovered.has_value()); // Means skip state SILK_INFO << "Trie" << log::Args{"key", to_hex(trie_data.key.value(), true), "hash", to_hex(trie_data.hash.value(), true)}; auto& hash = trie_data.hash.value(); hash_builder.add_branch_node(trie_data.key.value(), hash, false); if (SignalHandler::signalled()) { throw std::runtime_error("Interrupted"); } if (trie_data.key->empty()) { break; // just added root node } } const auto computed_state_root = hash_builder.root_hash(); if (computed_state_root != expected_state_root) { log::Error("State root", {"expected", to_hex(expected_state_root, true), "got", to_hex(hash_builder.root_hash(), true)}); } else { log::Info("State root " + to_hex(computed_state_root, true)); } } int main(int argc, char* argv[]) { SignalHandler::init(); CLI::App app("Silkworm staged_pipeline dev tool"); app.get_formatter()->column_width(50); app.require_subcommand(1); // At least 1 subcommand is required log::Settings log_settings{}; /* Database options (path required) */ auto db_opts = app.add_option_group("Database", "Database options"); db_opts->get_formatter()->column_width(35); auto shared_opt = db_opts->add_flag("--shared", "Open database in shared mode"); auto exclusive_opt = db_opts->add_flag("--exclusive", "Open database in exclusive mode")->excludes(shared_opt); auto db_opts_paths = db_opts->add_option_group("Path", "Database path")->require_option(1); db_opts_paths->get_formatter()->column_width(35); auto chaindata_opt = db_opts_paths->add_option("--chaindata", "Path to directory for mdbx.dat"); auto datadir_opt = db_opts_paths->add_option("--datadir", "Path to data directory")->excludes(chaindata_opt); /* Common opts and flags */ auto app_yes_opt = app.add_flag("-Y,--yes", "Assume yes to all requests of confirmation"); auto app_dry_opt = app.add_flag("--dry", "Don't commit to db. Only simulate"); cmd::common::add_logging_options(app, log_settings); /* Subcommands */ // List stages keys and their heights auto cmd_stages = app.add_subcommand("stages", "List stages and their actual heights"); // Stages tool auto cmd_stageset = app.add_subcommand("stage_set", "Sets a stage to a new height"); auto cmd_stageset_name_opt = cmd_stageset->add_option("--name", "Name of the stage to set")->required(); auto cmd_stageset_height_opt = cmd_stageset->add_option("--height", "Block height to set the stage to")->required()->check(CLI::Range(0u, UINT32_MAX)); // Forward tool auto cmd_staged_forward = app.add_subcommand("forward", "Forward staged sync to a given height"); auto cmd_staged_forward_height = cmd_staged_forward->add_option("--height", "Block height to forward the staged sync to") ->required() ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_staged_forward_start_at_stage_opt = cmd_staged_forward->add_option("--start_at_stage", "The name of the pipeline stage to start from"); auto cmd_staged_forward_stop_before_stage_opt = cmd_staged_forward->add_option("--stop_before_stage", "The name of the pipeline stage to stop to"); // Unwind tool auto cmd_staged_unwind = app.add_subcommand("unwind", "Unwind staged sync to a previous height"); auto cmd_staged_unwind_height = cmd_staged_unwind->add_option("--height", "Block height to unwind the staged sync to") ->required() ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_staged_unwind_remove_blocks = cmd_staged_unwind->add_flag("--remove_blocks", "Remove block headers and bodies up to unwind point") ->capture_default_str(); // DebugUnwind tool auto cmd_debug_unwind = app.add_subcommand("debug_unwind", "Debug staged sync unwind"); auto cmd_debug_unwind_height = cmd_debug_unwind->add_option("--height", "Block height to debug unwind up to") ->required() ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_debug_unwind_step = cmd_debug_unwind->add_option("--step", "Step") ->default_val(1) ->check(CLI::Range(1u, UINT32_MAX)); auto cmd_debug_unwind_start_at_stage_opt = cmd_debug_unwind->add_option("--start_at_stage", "The name of the pipeline stage to start from"); auto cmd_debug_unwind_stop_before_stage_opt = cmd_debug_unwind->add_option("--stop_before_stage", "The name of the pipeline stage to stop to"); auto cmd_debug_unwind_force_opt = cmd_debug_unwind->add_flag("--force", "Force user confirmation"); // Bisect pipeline // Truncates all the work done beyond download stages auto cmd_bisect = app.add_subcommand("bisect", "Bisect the staged pipeline in the given block interval looking for any failure"); auto cmd_bisect_from_block_opt = cmd_bisect->add_option("--start", "Block number to start bisection from") ->required() ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_bisect_to_block_opt = cmd_bisect->add_option("--end", "Block number to end bisection to") ->required() ->check(CLI::Range(0u, UINT32_MAX)); auto cmd_bisect_start_at_stage_opt = cmd_bisect->add_option("--start_at_stage", "The name of the pipeline stage to start from"); auto cmd_bisect_stop_before_stage_opt = cmd_bisect->add_option("--stop_before_stage", "The name of the pipeline stage to stop to"); // Reset after download // Truncates all the work done beyond download stages auto cmd_reset_to_download = app.add_subcommand("reset_to_download", "Reset all work and data written after bodies download"); auto cmd_reset_to_download_keep_senders_opt = cmd_reset_to_download->add_flag("--keep_senders", "Keep the recovered transaction senders"); auto cmd_reset_to_download_force_opt = cmd_reset_to_download->add_flag("--force", "Force user confirmation"); // Scan tries auto cmd_trie_scan = app.add_subcommand("trie-scan", "Scans tries for empty values"); auto cmd_trie_scan_delete_opt = cmd_trie_scan->add_flag("--delete", "Delete"); // Reset tries auto cmd_trie_reset = app.add_subcommand("trie-reset", "Resets stage_interhashes"); // Trie integrity auto cmd_trie_integrity = app.add_subcommand("trie-integrity", "Checks trie integrity"); auto cmd_trie_integrity_state_opt = cmd_trie_integrity->add_flag("--with-state", "Checks covered states (slower)"); auto cmd_trie_integrity_continue_opt = cmd_trie_integrity->add_flag("--continue", "Keeps scanning on found errors"); auto cmd_trie_integrity_sanitize_opt = cmd_trie_integrity->add_flag("--sanitize", "Clean orphan nodes"); // Trie account analysis auto cmd_trie_account_analysis = app.add_subcommand("trie-account-analysis", "Trie account key sizes analysis"); // Trie root hash verification auto cmd_trie_root = app.add_subcommand("trie-root", "Checks trie root"); try { // Parse arguments and validate app.parse(argc, argv); auto data_dir_factory = [&chaindata_opt, &datadir_opt]() -> std::unique_ptr { if (*chaindata_opt) { fs::path p{chaindata_opt->as()}; return std::make_unique(DataDirectory::from_chaindata(p).path()); } fs::path p{datadir_opt->as()}; return std::make_unique(p, /*create=*/false); }; log::init(log_settings); auto data_dir = data_dir_factory(); kvdb::EnvConfig chaindata_env_config{data_dir->chaindata().path().string()}; chaindata_env_config.shared = shared_opt->as(); chaindata_env_config.exclusive = exclusive_opt->as(); if (!data_dir->chaindata().exists() || data_dir->chaindata().is_empty()) { data_dir->deploy(); db::chain_data_init(db::ChainDataInitSettings{ .chaindata_env_config = chaindata_env_config, .network_id = 1, .init_if_empty = true, }); } const auto mdbx_path{kvdb::get_datafile_path(data_dir->chaindata().path())}; if (!fs::exists(mdbx_path) || !fs::is_regular_file(mdbx_path)) { std::cerr << "\n Directory " << data_dir->chaindata().path().string() << " does not contain " << kvdb::kDbDataFileName << "\n"; return -1; } // Execute subcommand actions if (*cmd_stages) { list_stages(chaindata_env_config); } else if (*cmd_stageset) { set_stage_progress(chaindata_env_config, cmd_stageset_name_opt->as(), cmd_stageset_height_opt->as(), app_dry_opt->as()); } else if (*cmd_staged_forward) { forward(chaindata_env_config, std::move(data_dir), cmd_staged_forward_height->as(), app_dry_opt->as(), cmd_staged_forward_start_at_stage_opt->as(), cmd_staged_forward_stop_before_stage_opt->as()); } else if (*cmd_debug_unwind) { debug_unwind(chaindata_env_config, std::move(data_dir), cmd_debug_unwind_height->as(), cmd_debug_unwind_step->as(), app_dry_opt->as(), cmd_debug_unwind_force_opt->as(), cmd_debug_unwind_start_at_stage_opt->as(), cmd_debug_unwind_stop_before_stage_opt->as()); } else if (*cmd_staged_unwind) { unwind(chaindata_env_config, std::move(data_dir), cmd_staged_unwind_height->as(), cmd_staged_unwind_remove_blocks->as(), app_dry_opt->as()); } else if (*cmd_bisect) { bisect_pipeline(chaindata_env_config, cmd_bisect_from_block_opt->as(), cmd_bisect_to_block_opt->as(), app_dry_opt->as(), cmd_bisect_start_at_stage_opt->as(), cmd_bisect_stop_before_stage_opt->as()); } else if (*cmd_reset_to_download) { reset_to_download(chaindata_env_config, cmd_reset_to_download_keep_senders_opt->as(), cmd_reset_to_download_force_opt->as()); } else if (*cmd_trie_scan) { trie_scan(chaindata_env_config, static_cast(*cmd_trie_scan_delete_opt)); } else if (*cmd_trie_reset) { trie_reset(chaindata_env_config, static_cast(*app_yes_opt)); } else if (*cmd_trie_integrity) { trie_integrity(chaindata_env_config, static_cast(*cmd_trie_integrity_state_opt), static_cast(*cmd_trie_integrity_continue_opt), static_cast(*cmd_trie_integrity_sanitize_opt)); } else if (*cmd_trie_account_analysis) { trie_account_analysis(chaindata_env_config); } else if (*cmd_trie_root) { trie_root(chaindata_env_config); } return 0; } catch (const CLI::ParseError& pe) { return app.exit(pe); } catch (const std::exception& ex) { std::cerr << "Error: " << ex.what() << "\n"; } catch (...) { std::cerr << "Unexpected undefined error\n"; } return -1; } ================================================ FILE: silkworm/node/common/node_settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { struct NodeSettings { ApplicationInfo build_info; // Application build info (human-readable) std::unique_ptr data_directory; // Pointer to data folder datastore::kvdb::EnvConfig chaindata_env_config; // Chaindata db config uint64_t network_id{kMainnetConfig.chain_id}; // Network/Chain id std::optional chain_config; // Chain config size_t batch_size{512_Mebi}; // Batch size to use in stages size_t etl_buffer_size{256_Mebi}; // Buffer size for ETL operations std::vector remote_sentry_addresses; // Remote Sentry API addresses (host:port,host2:port2,...) bool fake_pow{false}; // Whether to verify Proof-of-Work (PoW) std::optional etherbase{std::nullopt}; // Coinbase address (PoW only) db::PruneMode prune_mode; // Prune mode uint32_t sync_loop_throttle_seconds{0}; // Minimum interval amongst sync cycle uint32_t sync_loop_log_interval_seconds{30}; // Interval for sync loop to emit logs bool parallel_fork_tracking_enabled{false}; // Whether to track multiple parallel forks at head bool keep_db_txn_open{true}; // Whether to keep db transaction open between requests std::optional exec_api_address; // Execution API GRPC server bind address (IP:port) datastore::etl::CollectorSettings etl() const { return {data_directory->temp().path(), etl_buffer_size}; } }; } // namespace silkworm ================================================ FILE: silkworm/node/execution/active_direct_service_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution::api { using testing::InvokeWithoutArgs; using testing::NiceMock; using silkworm::db::test_util::TempChainData; using silkworm::node::test_util::make_node_settings_from_temp_chain_data; using silkworm::test_util::TaskRunner; class ActiveDirectServiceForTest : public ActiveDirectService { public: using ActiveDirectService::ActiveDirectService, ActiveComponent::execution_loop, ActiveComponent::stop; }; struct ActiveDirectServiceTest : public TaskRunner { explicit ActiveDirectServiceTest() : settings_{make_node_settings_from_temp_chain_data(tmp_chaindata_)} { tmp_chaindata_.add_genesis_data(); tmp_chaindata_.commit_txn(); mock_execution_engine = std::make_unique>(executor(), settings_, tmp_chaindata_.chaindata_rw()); direct_service = std::make_unique(*mock_execution_engine, service_ioc_); service_thread_ = std::thread{[this]() { direct_service->execution_loop(); }}; } ~ActiveDirectServiceTest() override { direct_service->stop(); if (service_thread_.joinable()) { service_thread_.join(); } } private: TempChainData tmp_chaindata_; NodeSettings settings_; boost::asio::io_context service_ioc_; std::thread service_thread_; public: std::unique_ptr mock_execution_engine; std::unique_ptr direct_service; }; TEST_CASE_METHOD(ActiveDirectServiceTest, "ActiveDirectServiceTest::insert_blocks", "[node][execution][api]") { const std::vector test_vectors = { Blocks{}, Blocks{std::make_shared()}, }; for (const auto& blocks : test_vectors) { SECTION("blocks: " + std::to_string(blocks.size())) { EXPECT_CALL(*mock_execution_engine, insert_blocks(blocks)) .WillOnce(InvokeWithoutArgs([]() -> void { return; })); auto future = spawn_future(direct_service->insert_blocks(blocks)); ioc().run(); CHECK(future.get().status == api::ExecutionStatus::kSuccess); } } } TEST_CASE_METHOD(ActiveDirectServiceTest, "ActiveDirectServiceTest::verify_chain", "[node][execution][api]") { const Hash latest_valid_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; const Hash new_hash{0x000000000000000000000000000000000000000000000000000000000000000B_bytes32}; const BlockId latest_valid_head{ .block_num = 1, .hash = latest_valid_hash, }; const BlockId new_head{ .block_num = 2, .hash = new_hash, }; const std::vector> test_vectors{ {ValidChain{.current_head = new_head}, api::ValidChain{.current_head = new_head}}, {InvalidChain{.unwind_point = latest_valid_head}, api::InvalidChain{.unwind_point = latest_valid_head}}, {ValidationError{.latest_valid_head = latest_valid_head}, api::ValidationError{.latest_valid_head = latest_valid_head}}, }; for (const auto& [stagedsync_result, api_result] : test_vectors) { SECTION("result: " + std::to_string(stagedsync_result.index())) { EXPECT_CALL(*mock_execution_engine, verify_chain(new_head.hash)) .WillOnce(InvokeWithoutArgs([result = stagedsync_result]() -> Task { co_return result; })); auto future = spawn_future(direct_service->validate_chain(new_head)); ioc().run(); const auto result{future.get()}; if (std::holds_alternative(stagedsync_result)) { CHECK(std::holds_alternative(result)); const auto stagedsync_valid_chain{std::get(stagedsync_result)}; const auto api_valid_chain{std::get(result)}; CHECK(stagedsync_valid_chain.current_head == api_valid_chain.current_head); } else if (std::holds_alternative(stagedsync_result)) { CHECK(std::holds_alternative(result)); const auto stagedsync_invalid_chain{std::get(stagedsync_result)}; const auto api_invalid_chain{std::get(result)}; CHECK(stagedsync_invalid_chain.unwind_point == api_invalid_chain.unwind_point); CHECK(stagedsync_invalid_chain.bad_headers == api_invalid_chain.bad_headers); CHECK(stagedsync_invalid_chain.bad_block == api_invalid_chain.bad_block); } else if (std::holds_alternative(stagedsync_result)) { CHECK(std::holds_alternative(result)); const auto stagedsync_error{std::get(stagedsync_result)}; const auto api_error{std::get(result)}; CHECK(stagedsync_error.latest_valid_head == api_error.latest_valid_head); } else { REQUIRE(false); } } } } TEST_CASE_METHOD(ActiveDirectServiceTest, "ActiveDirectServiceTest::update_fork_choice", "[node][execution][api]") { const Hash head_block_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; const Hash finalized_block_hash{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; const Hash safe_block_hash{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; const ForkChoice fork_choice{ .head_block_hash = head_block_hash, .timeout = 0, .finalized_block_hash = finalized_block_hash, .safe_block_hash = safe_block_hash, }; const std::vector> test_vectors{ {true, ForkChoiceResult{.status = api::ExecutionStatus::kSuccess, .latest_valid_head = head_block_hash}}, {false, ForkChoiceResult{.status = api::ExecutionStatus::kInvalidForkchoice, .latest_valid_head = finalized_block_hash}}, }; for (const auto& [updated, expected_choice_result] : test_vectors) { SECTION("updated: " + std::to_string(updated)) { EXPECT_CALL(*mock_execution_engine, notify_fork_choice_update3(head_block_hash, finalized_block_hash, safe_block_hash)) .WillOnce(InvokeWithoutArgs([result = updated]() -> bool { return result; })); EXPECT_CALL(*mock_execution_engine, last_fork_choice()) .WillOnce(InvokeWithoutArgs([=, result = updated]() -> BlockId { return result ? BlockId{10, head_block_hash} : BlockId{2, finalized_block_hash}; })); auto future = spawn_future(direct_service->update_fork_choice(fork_choice)); ioc().run(); const auto fork_choice_result{future.get()}; CHECK(fork_choice_result.status == expected_choice_result.status); CHECK(fork_choice_result.latest_valid_head == expected_choice_result.latest_valid_head); } } } TEST_CASE_METHOD(ActiveDirectServiceTest, "ActiveDirectServiceTest::get_block_num", "[node][execution][api]") { const Hash block_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; SECTION("non-existent") { EXPECT_CALL(*mock_execution_engine, get_block_num(block_hash)) .WillOnce(InvokeWithoutArgs([=]() -> std::optional { return {}; })); auto future = spawn_future(direct_service->get_header_hash_number(block_hash)); ioc().run(); CHECK(future.get() == std::nullopt); } SECTION("existent") { const BlockNum block_num{2}; EXPECT_CALL(*mock_execution_engine, get_block_num(block_hash)) .WillOnce(InvokeWithoutArgs([=]() -> std::optional { return block_num; })); auto future = spawn_future(direct_service->get_header_hash_number(block_hash)); ioc().run(); CHECK(future.get() == block_num); } } TEST_CASE_METHOD(ActiveDirectServiceTest, "ActiveDirectServiceTest::get_fork_choice", "[node][execution][api]") { const Hash head_block_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; const Hash finalized_block_hash{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; const Hash safe_block_hash{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; const ForkChoice expected_fork_choice{ .head_block_hash = head_block_hash, .timeout = 0, .finalized_block_hash = finalized_block_hash, .safe_block_hash = safe_block_hash, }; EXPECT_CALL(*mock_execution_engine, last_fork_choice()) .WillOnce(InvokeWithoutArgs([=]() -> BlockId { return {10, head_block_hash}; })); EXPECT_CALL(*mock_execution_engine, last_finalized_block()) .WillOnce(InvokeWithoutArgs([=]() -> BlockId { return {2, finalized_block_hash}; })); EXPECT_CALL(*mock_execution_engine, last_safe_block()) .WillOnce(InvokeWithoutArgs([=]() -> BlockId { return {1, safe_block_hash}; })); auto future = spawn_future(direct_service->get_fork_choice()); ioc().run(); const auto last_choice{future.get()}; CHECK(last_choice.head_block_hash == expected_fork_choice.head_block_hash); CHECK(last_choice.timeout == expected_fork_choice.timeout); CHECK(last_choice.finalized_block_hash == expected_fork_choice.finalized_block_hash); CHECK(last_choice.safe_block_hash == expected_fork_choice.safe_block_hash); } TEST_CASE_METHOD(ActiveDirectServiceTest, "ActiveDirectServiceTest::get_last_headers", "[node][execution][api]") { const std::vector> test_vectors = { {0, {}}, {1, {BlockHeader{}}}, }; for (const auto& [how_many, last_headers] : test_vectors) { SECTION("how_many: " + std::to_string(how_many)) { EXPECT_CALL(*mock_execution_engine, get_last_headers(how_many)) .WillOnce(InvokeWithoutArgs([&, headers = last_headers]() -> BlockHeaders { return headers; })); auto future = spawn_future(direct_service->get_last_headers(how_many)); ioc().run(); CHECK(future.get() == last_headers); } } } TEST_CASE_METHOD(ActiveDirectServiceTest, "ActiveDirectServiceTest::block_progress", "[node][execution][api]") { const BlockNum progress{123'456'789}; EXPECT_CALL(*mock_execution_engine, block_progress()) .WillOnce(InvokeWithoutArgs([=]() -> BlockNum { return progress; })); auto future = spawn_future(direct_service->block_progress()); ioc().run(); CHECK(future.get() == progress); } } // namespace silkworm::execution::api ================================================ FILE: silkworm/node/execution/direct_service_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution::api { using testing::InvokeWithoutArgs; using silkworm::db::test_util::TempChainData; using silkworm::node::test_util::make_node_settings_from_temp_chain_data; using silkworm::test_util::TaskRunner; struct DirectServiceTest : public TaskRunner { explicit DirectServiceTest() : settings{make_node_settings_from_temp_chain_data(tmp_chaindata)} { tmp_chaindata.add_genesis_data(); tmp_chaindata.commit_txn(); mock_execution_engine = std::make_unique(executor(), settings, tmp_chaindata.chaindata_rw()); direct_service = std::make_unique(*mock_execution_engine); } TempChainData tmp_chaindata; NodeSettings settings; std::unique_ptr mock_execution_engine; std::unique_ptr direct_service; }; TEST_CASE_METHOD(DirectServiceTest, "DirectService::insert_blocks", "[node][execution][api]") { const std::vector test_vectors = { Blocks{}, Blocks{std::make_shared()}, }; for (const auto& blocks : test_vectors) { SECTION("blocks: " + std::to_string(blocks.size())) { EXPECT_CALL(*mock_execution_engine, insert_blocks(blocks)) .WillOnce(InvokeWithoutArgs([]() -> void { return; })); auto future = spawn_future(direct_service->insert_blocks(blocks)); ioc().run(); CHECK(future.get().status == api::ExecutionStatus::kSuccess); } } } TEST_CASE_METHOD(DirectServiceTest, "DirectService::verify_chain", "[node][execution][api]") { const Hash latest_valid_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; const Hash new_hash{0x000000000000000000000000000000000000000000000000000000000000000B_bytes32}; const BlockId latest_valid_head{ .block_num = 1, .hash = latest_valid_hash, }; const BlockId new_head{ .block_num = 2, .hash = new_hash, }; const std::vector> test_vectors{ {ValidChain{.current_head = new_head}, api::ValidChain{.current_head = new_head}}, {InvalidChain{.unwind_point = latest_valid_head}, api::InvalidChain{.unwind_point = latest_valid_head}}, {ValidationError{.latest_valid_head = latest_valid_head}, api::ValidationError{.latest_valid_head = latest_valid_head}}, }; for (const auto& [stagedsync_result, api_result] : test_vectors) { SECTION("result: " + std::to_string(stagedsync_result.index())) { EXPECT_CALL(*mock_execution_engine, verify_chain(new_head.hash)) .WillOnce(InvokeWithoutArgs([result = stagedsync_result]() -> Task { co_return result; })); auto future = spawn_future(direct_service->validate_chain(new_head)); ioc().run(); const auto result{future.get()}; if (std::holds_alternative(stagedsync_result)) { CHECK(std::holds_alternative(result)); const auto stagedsync_valid_chain{std::get(stagedsync_result)}; const auto api_valid_chain{std::get(result)}; CHECK(stagedsync_valid_chain.current_head == api_valid_chain.current_head); } else if (std::holds_alternative(stagedsync_result)) { CHECK(std::holds_alternative(result)); const auto stagedsync_invalid_chain{std::get(stagedsync_result)}; const auto api_invalid_chain{std::get(result)}; CHECK(stagedsync_invalid_chain.unwind_point == api_invalid_chain.unwind_point); CHECK(stagedsync_invalid_chain.bad_headers == api_invalid_chain.bad_headers); CHECK(stagedsync_invalid_chain.bad_block == api_invalid_chain.bad_block); } else if (std::holds_alternative(stagedsync_result)) { CHECK(std::holds_alternative(result)); const auto stagedsync_error{std::get(stagedsync_result)}; const auto api_error{std::get(result)}; CHECK(stagedsync_error.latest_valid_head == api_error.latest_valid_head); } else { REQUIRE(false); } } } } TEST_CASE_METHOD(DirectServiceTest, "DirectService::update_fork_choice", "[node][execution][api]") { const Hash head_block_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; const Hash finalized_block_hash{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; const Hash safe_block_hash{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; const ForkChoice fork_choice{ .head_block_hash = head_block_hash, .timeout = 0, .finalized_block_hash = finalized_block_hash, .safe_block_hash = safe_block_hash, }; const std::vector> test_vectors{ {true, ForkChoiceResult{.status = api::ExecutionStatus::kSuccess, .latest_valid_head = head_block_hash}}, {false, ForkChoiceResult{.status = api::ExecutionStatus::kInvalidForkchoice, .latest_valid_head = finalized_block_hash}}, }; for (const auto& [updated, expected_choice_result] : test_vectors) { SECTION("updated: " + std::to_string(updated)) { EXPECT_CALL(*mock_execution_engine, notify_fork_choice_update3(head_block_hash, finalized_block_hash, safe_block_hash)) .WillOnce(InvokeWithoutArgs([result = updated]() -> bool { return result; })); EXPECT_CALL(*mock_execution_engine, last_fork_choice()) .WillOnce(InvokeWithoutArgs([=, result = updated]() -> BlockId { return result ? BlockId{10, head_block_hash} : BlockId{2, finalized_block_hash}; })); auto future = spawn_future(direct_service->update_fork_choice(fork_choice)); ioc().run(); const auto fork_choice_result{future.get()}; CHECK(fork_choice_result.status == expected_choice_result.status); CHECK(fork_choice_result.latest_valid_head == expected_choice_result.latest_valid_head); } } } TEST_CASE_METHOD(DirectServiceTest, "DirectService::get_block_num", "[node][execution][api]") { const Hash block_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; SECTION("non-existent") { EXPECT_CALL(*mock_execution_engine, get_block_num(block_hash)) .WillOnce(InvokeWithoutArgs([=]() -> std::optional { return {}; })); auto future = spawn_future(direct_service->get_header_hash_number(block_hash)); ioc().run(); CHECK(future.get() == std::nullopt); } SECTION("existent") { const BlockNum block_num{2}; EXPECT_CALL(*mock_execution_engine, get_block_num(block_hash)) .WillOnce(InvokeWithoutArgs([=]() -> std::optional { return block_num; })); auto future = spawn_future(direct_service->get_header_hash_number(block_hash)); ioc().run(); CHECK(future.get() == block_num); } } TEST_CASE_METHOD(DirectServiceTest, "DirectService::get_fork_choice", "[node][execution][api]") { const Hash head_block_hash{0x000000000000000000000000000000000000000000000000000000000000000A_bytes32}; const Hash finalized_block_hash{0x0000000000000000000000000000000000000000000000000000000000000002_bytes32}; const Hash safe_block_hash{0x0000000000000000000000000000000000000000000000000000000000000001_bytes32}; const ForkChoice expected_fork_choice{ .head_block_hash = head_block_hash, .timeout = 0, .finalized_block_hash = finalized_block_hash, .safe_block_hash = safe_block_hash, }; EXPECT_CALL(*mock_execution_engine, last_fork_choice()) .WillOnce(InvokeWithoutArgs([=]() -> BlockId { return {10, head_block_hash}; })); EXPECT_CALL(*mock_execution_engine, last_finalized_block()) .WillOnce(InvokeWithoutArgs([=]() -> BlockId { return {2, finalized_block_hash}; })); EXPECT_CALL(*mock_execution_engine, last_safe_block()) .WillOnce(InvokeWithoutArgs([=]() -> BlockId { return {1, safe_block_hash}; })); auto future = spawn_future(direct_service->get_fork_choice()); ioc().run(); const auto last_choice{future.get()}; CHECK(last_choice.head_block_hash == expected_fork_choice.head_block_hash); CHECK(last_choice.timeout == expected_fork_choice.timeout); CHECK(last_choice.finalized_block_hash == expected_fork_choice.finalized_block_hash); CHECK(last_choice.safe_block_hash == expected_fork_choice.safe_block_hash); } TEST_CASE_METHOD(DirectServiceTest, "DirectService::get_last_headers", "[node][execution][api]") { const std::vector> test_vectors = { {0, {}}, {1, {BlockHeader{}}}, }; for (const auto& [how_many, last_headers] : test_vectors) { SECTION("how_many: " + std::to_string(how_many)) { EXPECT_CALL(*mock_execution_engine, get_last_headers(how_many)) .WillOnce(InvokeWithoutArgs([&, headers = last_headers]() -> BlockHeaders { return headers; })); auto future = spawn_future(direct_service->get_last_headers(how_many)); ioc().run(); CHECK(future.get() == last_headers); } } } TEST_CASE_METHOD(DirectServiceTest, "DirectService::block_progress", "[node][execution][api]") { const BlockNum progress{123'456'789}; EXPECT_CALL(*mock_execution_engine, block_progress()) .WillOnce(InvokeWithoutArgs([=]() -> BlockNum { return progress; })); auto future = spawn_future(direct_service->block_progress()); ioc().run(); CHECK(future.get() == progress); } } // namespace silkworm::execution::api ================================================ FILE: silkworm/node/execution/header_chain_plus_exec_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { using namespace stagedsync; using namespace silkworm::db; using silkworm::execution::api::ValidChain; using silkworm::stagedsync::test_util::make_stages_factory; using silkworm::test_util::TaskRunner; class HeaderChainForTest : public HeaderChain { public: // publication of internal members to test methods functioning using HeaderChain::generate_request_id; using HeaderChain::HeaderChain; }; class ExecutionEngineForTest : public stagedsync::ExecutionEngine { public: using stagedsync::ExecutionEngine::ExecutionEngine; using stagedsync::ExecutionEngine::insert_block; using stagedsync::ExecutionEngine::main_chain_; }; class DummyRuleSet : public protocol::RuleSet { public: DummyRuleSet() : RuleSet{kMainnetConfig, false} {} ValidationResult pre_validate_block_body(const Block&, const BlockState&) override { return ValidationResult::kOk; } ValidationResult validate_ommers(const Block&, const BlockState&) override { return ValidationResult::kOk; } ValidationResult validate_block_header(const BlockHeader&, const BlockState&, bool) override { return ValidationResult::kOk; } void initialize(EVM&) override {} ValidationResult finalize(IntraBlockState&, const Block&, EVM&, const std::vector&) override { return ValidationResult::kOk; } protected: ValidationResult validate_difficulty_and_seal(const BlockHeader&, const BlockHeader&) override { return ValidationResult::kOk; } }; TEST_CASE("Headers receiving and saving") { TaskRunner runner; db::test_util::TempChainDataStore context; context.add_genesis_data(); context.commit_txn(); db::DataModelFactory data_model_factory = context.data_model_factory(); NodeSettings node_settings = node::test_util::make_node_settings_from_temp_chain_data(context); auto db_access = context.chaindata_rw(); // creating the ExecutionEngine ExecutionEngineForTest exec_engine{ runner.executor(), node_settings, data_model_factory, /* log_timer_factory = */ std::nullopt, make_stages_factory(node_settings, data_model_factory), db_access, }; exec_engine.open(); auto& tx = exec_engine.main_chain_.tx(); // mdbx refuses to open a ROTxn when there is a RWTxn in the same thread auto head = exec_engine.last_fork_choice(); REQUIRE(head.block_num == 0); std::vector last_headers = exec_engine.get_last_headers(1); REQUIRE(last_headers.size() == 1); REQUIRE(last_headers[0].number == head.block_num); REQUIRE(last_headers[0].hash() == head.hash); // creating the working chain to simulate a bit of the sync BlockNum max_in_db = 0; HeaderChainForTest header_chain(kMainnetConfig.chain_id, std::make_unique()); header_chain.initial_state(last_headers); header_chain.current_state(max_in_db); auto request_id = header_chain.generate_request_id(); // reading genesis auto header0 = read_canonical_header(tx, 0); REQUIRE(header0.has_value()); auto header0_hash = header0->hash(); auto td = read_total_difficulty(tx, 0, header0_hash); REQUIRE(td.has_value()); // creating the chain-fork-view to simulate a bit of the HeaderStage chainsync::ChainForkView chain_fork_view{{header0->number, header0_hash, *td}}; CHECK(chain_fork_view.head() == head); chain_fork_view.add(*header0, *td); CHECK(chain_fork_view.head() == head); chain_fork_view.reset_head({header0->number, header0_hash, *td}); CHECK(chain_fork_view.head() == head); // stop execution pipeline at early stages because we use dummy headers without bodies Environment::set_stop_before_stage(stages::kBlockHashesKey); /* status: * h0 (persisted) * input: * (h0) <----- h1 <----- h2 * |-- h1' */ SECTION("accepting 1 batch of headers") { // testing initial status auto initial_block_num = chain_fork_view.head_block_num(); auto initial_hash = chain_fork_view.head_hash(); REQUIRE(initial_block_num == 0); REQUIRE(initial_hash == header0_hash); // receiving 3 headers from a peer BlockHeader header1; header1.number = 1; header1.difficulty = 1'000'000; // header1.gas_limit = 5000; // header1.timestamp = ++timestamp; // header1.difficulty = EthashEngine::difficulty(header1.number, header1.timestamp, header0->difficulty, // header0->timestamp, false, kMainnetIdentity.config); header1.parent_hash = header0_hash; auto header1_hash = header1.hash(); BlockHeader header2; header2.number = 2; header2.difficulty = 1'100'000; header2.parent_hash = header1_hash; auto header2_hash = header2.hash(); BlockHeader header1b; header1b.number = 1; header1b.difficulty = 2'000'000; header1b.gas_limit = 5000; header1b.parent_hash = header0_hash; header1b.extra_data = string_view_to_byte_view("I'm different"); auto header1b_hash = header1b.hash(); // processing the headers std::vector headers = {header1, header2, header1b}; PeerId peer_id{byte_ptr_cast("1")}; header_chain.accept_headers(headers, request_id, peer_id); // saving headers ready to persist as the header sync does in the forward() method Headers headers_to_persist = header_chain.withdraw_stable_headers(); std::ranges::for_each(headers_to_persist, [&](const auto& header) { chain_fork_view.add(*header); auto fake_block = std::make_shared(Block{{}, *header}); exec_engine.insert_block(fake_block); }); // check internal status BigInt expected_td = header0->difficulty + header1.difficulty + header2.difficulty; REQUIRE(headers_to_persist.size() == 3); REQUIRE(chain_fork_view.head_total_difficulty() == expected_td); REQUIRE(chain_fork_view.head_changed() == true); REQUIRE(chain_fork_view.head_block_num() == 2); REQUIRE(chain_fork_view.head_hash() == header2_hash); // check db content auto header1_in_db = read_header(tx, header1_hash); REQUIRE(header1_in_db.has_value()); REQUIRE(header1_in_db == header1); auto header2_in_db = read_header(tx, header2_hash); REQUIRE(header2_in_db.has_value()); REQUIRE(header2_in_db == header2); auto header1b_in_db = read_header(tx, header1b_hash); REQUIRE(header1b_in_db.has_value()); REQUIRE(header1b_in_db == header1b); // verify the inserted chain auto verification = runner.run(exec_engine.verify_chain(chain_fork_view.head_hash())); REQUIRE(std::holds_alternative(verification)); auto valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{2, header2_hash}); // check db content REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(2, header2_hash)); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td); REQUIRE(read_canonical_header_hash(tx, 1) == header1_hash); REQUIRE(read_canonical_header_hash(tx, 2) == header2_hash); // update the fork choice exec_engine.notify_fork_choice_update(header2_hash, {}, {}); // check db content REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(2, header2_hash)); } /* status: * h0 (persisted) * input 1: * (h0) <----- h1 <------ h2 * input 2: * (h0) <----- h1' * final status: * h0 <------ h1 <----- h2 * |--- h1' */ SECTION("accepting 2 batch of headers, the second not changing the canonical") { // receiving 2 headers from a peer BlockHeader header1; header1.number = 1; header1.difficulty = 1'000'000; header1.parent_hash = header0_hash; auto header1_hash = header1.hash(); BlockHeader header2; header2.number = 2; header2.difficulty = 1'100'000; header2.parent_hash = header1_hash; auto header2_hash = header2.hash(); // processing the headers std::vector headers = {header1, header2}; PeerId peer_id{byte_ptr_cast("1")}; header_chain.accept_headers(headers, request_id, peer_id); // saving headers ready to persist as the header sync does in the forward() method Headers headers_to_persist = header_chain.withdraw_stable_headers(); std::ranges::for_each(headers_to_persist, [&](const auto& header) { chain_fork_view.add(*header); auto fake_block = std::make_shared(Block{{}, *header}); exec_engine.insert_block(fake_block); }); // check internal status BigInt expected_td = header0->difficulty + header1.difficulty + header2.difficulty; REQUIRE(chain_fork_view.head_total_difficulty() == expected_td); REQUIRE(chain_fork_view.head_changed() == true); REQUIRE(chain_fork_view.head_block_num() == 2); REQUIRE(chain_fork_view.head_hash() == header2_hash); // check db content auto header1_in_db = read_header(tx, header1_hash); REQUIRE(header1_in_db.has_value()); REQUIRE(header1_in_db == header1); auto header2_in_db = read_header(tx, header2_hash); REQUIRE(header2_in_db.has_value()); REQUIRE(header2_in_db == header2); // verify the inserted chain auto verification = runner.run(exec_engine.verify_chain(chain_fork_view.head_hash())); REQUIRE(std::holds_alternative(verification)); auto valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{2, header2_hash}); // check db content REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td); // receiving a new header that is a fork BlockHeader header1b; header1b.number = 1; header1b.difficulty = 2'000'000; header1b.parent_hash = header0_hash; header1b.extra_data = string_view_to_byte_view("I'm different"); auto header1b_hash = header1b.hash(); std::vector headers_bis = {header1b}; peer_id = byte_ptr_cast("2"); header_chain.accept_headers(headers_bis, request_id, peer_id); // saving headers ready to persist as the header sync does in the forward() method Headers headers_to_persist_bis = header_chain.withdraw_stable_headers(); std::ranges::for_each(headers_to_persist_bis, [&](const auto& header) { auto fake_block = std::make_shared(Block{{}, *header}); exec_engine.insert_block(fake_block); }); // status and db content must be as before because the new header is not in the canonical chain REQUIRE(chain_fork_view.head_total_difficulty() == expected_td); REQUIRE(chain_fork_view.head_changed() == true); REQUIRE(chain_fork_view.head_block_num() == 2); REQUIRE(chain_fork_view.head_hash() == header2_hash); // check db content auto header1b_in_db = read_header(tx, header1b_hash); REQUIRE(header1b_in_db.has_value()); REQUIRE(header1b_in_db == header1b); // verify the inserted chain verification = runner.run(exec_engine.verify_chain(chain_fork_view.head_hash())); REQUIRE(std::holds_alternative(verification)); valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{2, header2_hash}); // check db content REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(2, header2_hash)); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td); REQUIRE(read_canonical_header_hash(tx, 1) == header1_hash); REQUIRE(read_canonical_header_hash(tx, 2) == header2_hash); // update the fork choice exec_engine.notify_fork_choice_update(header2_hash, {}, {}); // check db content REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(2, header2_hash)); } /* status: * h0 (persisted) * input 1: * (h0) <----- h1 <------ h2 * input 2: * (h0) <----- h1' (td > h2) * final status: * h0 <------ h1 <----- h2 * |--- h1' (canonical chain) */ SECTION("accepting 2 batch of headers, the second changing the canonical") { // receiving 2 headers from a peer BlockHeader header1; header1.number = 1; header1.difficulty = 1'000'000; header1.parent_hash = header0_hash; auto header1_hash = header1.hash(); BlockHeader header2; header2.number = 2; header2.difficulty = 1'100'000; header2.parent_hash = header1_hash; auto header2_hash = header2.hash(); // processing the headers std::vector headers = {header1, header2}; PeerId peer_id{byte_ptr_cast("1")}; header_chain.accept_headers(headers, request_id, peer_id); // saving headers ready to persist as the header sync does in the forward() method Headers headers_to_persist = header_chain.withdraw_stable_headers(); std::ranges::for_each(headers_to_persist, [&](const auto& header) { chain_fork_view.add(*header); auto fake_block = std::make_shared(Block{{}, *header}); exec_engine.insert_block(fake_block); }); // check internal status BigInt expected_td = header0->difficulty + header1.difficulty + header2.difficulty; REQUIRE(chain_fork_view.head_total_difficulty() == expected_td); REQUIRE(chain_fork_view.head_changed() == true); REQUIRE(chain_fork_view.head_block_num() == 2); REQUIRE(chain_fork_view.head_hash() == header2_hash); // check db content auto header1_in_db = read_header(tx, header1_hash); REQUIRE(header1_in_db.has_value()); REQUIRE(header1_in_db == header1); auto header2_in_db = read_header(tx, header2_hash); REQUIRE(header2_in_db.has_value()); REQUIRE(header2_in_db == header2); // verify the inserted chain auto verification = runner.run(exec_engine.verify_chain(chain_fork_view.head_hash())); REQUIRE(std::holds_alternative(verification)); auto valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{2, header2_hash}); // check db content REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td); // receiving a new header that is a fork BlockHeader header1b; header1b.number = 1; header1b.difficulty = 3'000'000; header1b.parent_hash = header0_hash; header1b.extra_data = string_view_to_byte_view("I'm different"); auto header1b_hash = header1b.hash(); std::vector headers_bis = {header1b}; peer_id = byte_ptr_cast("2"); header_chain.accept_headers(headers_bis, request_id, peer_id); // saving headers ready to persist as the header sync does in the forward() method Headers headers_to_persist_bis = header_chain.withdraw_stable_headers(); std::ranges::for_each(headers_to_persist_bis, [&](const auto& header) { chain_fork_view.add(*header); auto fake_block = std::make_shared(Block{{}, *header}); exec_engine.insert_block(fake_block); }); // the canonical is changed, check the new status auto new_expected_td = header0->difficulty + header1b.difficulty; REQUIRE(chain_fork_view.head_total_difficulty() == new_expected_td); REQUIRE(chain_fork_view.head_changed() == true); REQUIRE(chain_fork_view.head_block_num() == 1); // <-- NOTE! 1 not 2 REQUIRE(chain_fork_view.head_hash() == header1b_hash); // check db content auto header1b_in_db = read_header(tx, header1b_hash); REQUIRE(header1b_in_db.has_value()); REQUIRE(header1b_in_db == header1b); // verify the inserted chain // this will trigger unwind verification = runner.run(exec_engine.verify_chain(chain_fork_view.head_hash())); REQUIRE(std::holds_alternative(verification)); valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{1, header1b_hash}); // check db content REQUIRE(read_head_header_hash(tx) == header1b_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(1, header1b_hash)); // there was an unwind op REQUIRE(read_total_difficulty(tx, 1, header1b.hash()) == new_expected_td); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td); REQUIRE(read_canonical_header_hash(tx, 1) == header1b_hash); REQUIRE(read_canonical_header_hash(tx, 2).has_value() == false); REQUIRE(read_canonical_head(tx) == std::make_tuple(1, header1b_hash)); // update the fork choice exec_engine.notify_fork_choice_update(header1b_hash, {}, {}); // check db content REQUIRE(read_head_header_hash(tx) == header1b_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(1, header1b_hash)); } /* status: * h0 (persisted) * input 1: * (h0) <----- h1' temp canonical chain * input 2: * (h0) <----- h1 <----- h2 final canonical chain * final status: * h0 <------ h1' * |--- h1 <----- h2 */ SECTION("accepting 2 batch of headers, the second changing the canonical") { // receiving 1 header from a peer BlockHeader header1b; header1b.number = 1; header1b.difficulty = 2'000'000; header1b.parent_hash = header0_hash; header1b.extra_data = string_view_to_byte_view("I'm different"); auto header1b_hash = header1b.hash(); std::vector headers = {header1b}; PeerId peer_id{byte_ptr_cast("1")}; header_chain.accept_headers(headers, request_id, peer_id); // saving headers ready to persist as the header sync does in the forward() method Headers headers_to_persist = header_chain.withdraw_stable_headers(); std::ranges::for_each(headers_to_persist, [&](const auto& header) { chain_fork_view.add(*header); auto fake_block = std::make_shared(Block{{}, *header}); exec_engine.insert_block(fake_block); }); // check internal status BigInt expected_td = header0->difficulty + header1b.difficulty; REQUIRE(chain_fork_view.head_total_difficulty() == expected_td); REQUIRE(chain_fork_view.head_changed() == true); REQUIRE(chain_fork_view.head_block_num() == 1); REQUIRE(chain_fork_view.head_hash() == header1b_hash); // check db content auto header1b_in_db = read_header(tx, header1b_hash); REQUIRE(header1b_in_db.has_value()); REQUIRE(header1b_in_db == header1b); // verify the inserted chain auto verification = runner.run(exec_engine.verify_chain(chain_fork_view.head_hash())); REQUIRE(std::holds_alternative(verification)); auto valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{1, header1b_hash}); // check db content REQUIRE(read_head_header_hash(tx) == header1b_hash); REQUIRE(read_total_difficulty(tx, 1, header1b.hash()) == expected_td); // receiving 2 header that changes the canonical chain BlockHeader header1; header1.number = 1; header1.difficulty = 1'000'000; header1.parent_hash = header0_hash; auto header1_hash = header1.hash(); BlockHeader header2; header2.number = 2; header2.difficulty = 1'100'000; header2.parent_hash = header1_hash; auto header2_hash = header2.hash(); // processing the headers std::vector headers_bis = {header1, header2}; peer_id = byte_ptr_cast("2"); header_chain.accept_headers(headers_bis, request_id, peer_id); // saving headers ready to persist as the header sync does in the forward() method Headers headers_to_persist_bis = header_chain.withdraw_stable_headers(); std::ranges::for_each(headers_to_persist_bis, [&](const auto& header) { chain_fork_view.add(*header); auto fake_block = std::make_shared(Block{{}, *header}); exec_engine.insert_block(fake_block); }); // check internal status BigInt expected_td_bis = header0->difficulty + header1.difficulty + header2.difficulty; REQUIRE(chain_fork_view.head_total_difficulty() == expected_td_bis); REQUIRE(chain_fork_view.head_changed() == true); REQUIRE(chain_fork_view.head_block_num() == 2); REQUIRE(chain_fork_view.head_hash() == header2_hash); // check db auto header1_in_db = read_header(tx, header1_hash); REQUIRE(header1_in_db.has_value()); REQUIRE(header1_in_db == header1); auto header2_in_db = read_header(tx, header2_hash); REQUIRE(header2_in_db.has_value()); REQUIRE(header2_in_db == header2); header1b_in_db = read_header(tx, header1b_hash); REQUIRE(header1b_in_db.has_value()); REQUIRE(header1b_in_db == header1b); // verify the inserted chain // this will trigger unwind verification = runner.run(exec_engine.verify_chain(chain_fork_view.head_hash())); REQUIRE(std::holds_alternative(verification)); valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{2, header2_hash}); REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td_bis); REQUIRE(read_canonical_header_hash(tx, 1) == header1_hash); REQUIRE(read_canonical_header_hash(tx, 2) == header2_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(2, header2_hash)); // update the fork choice exec_engine.notify_fork_choice_update(header2_hash, {}, {}); // check db content REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_canonical_head(tx) == std::make_tuple(2, header2_hash)); } /* status: * h0 * input: * h0 <----- h1 <----- h2 * |-- h1' <----- h2' <----- h3' (new canonical) -> unwind? */ // SECTION("a header in a secondary chain") { // // ... // } /* status: * h0 <----- h1 <----- h2 * |-- h1' * input: * h0 <----- h1 <----- h2 * |-- h1' <----- h2' <----- h3' (new canonical) -> unwind? */ // SECTION("a forking point in the past") { // // ... // } } } // namespace silkworm ================================================ FILE: silkworm/node/node.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "backend_kv_server.hpp" namespace silkworm::node { //! Custom stack size for thread running block execution on EVM static constexpr uint64_t kExecutionThreadStackSize{16'777'216}; // 16MiB using SentryClientPtr = std::shared_ptr; class NodeImpl final { public: NodeImpl( rpc::ClientContextPool& context_pool, Settings& settings); NodeImpl(const NodeImpl&) = delete; NodeImpl& operator=(const NodeImpl&) = delete; Task run(); Task run_tasks(); Task wait_for_setup(); BlockNum last_pre_validated_block() const { return chain_sync_.last_pre_validated_block(); } private: db::DataStoreRef data_store() { return data_store_.ref(); } db::DataModelFactory data_model_factory() { return db::DataModelFactory{data_store()}; } const ChainConfig& chain_config() const { return *settings_.node_settings.chain_config; } Task run_execution_service(); Task run_execution_server(); Task run_backend_kv_grpc_server(); Task embedded_sentry_run_if_needed(); Task run_chain_sync(); Settings& settings_; db::DataStore data_store_; //! The execution layer server engine boost::asio::io_context execution_ioc_; stagedsync::ExecutionEngine execution_engine_; std::shared_ptr execution_service_; execution::grpc::server::Server execution_server_; execution::api::DirectClient execution_direct_client_; db::SnapshotSync snapshot_sync_; sentry::SentryClientFactory::SentryPtrPair sentry_; std::unique_ptr backend_; std::unique_ptr backend_kv_rpc_server_; // ChainSync: the chain synchronization process based on the consensus protocol chainsync::Sync chain_sync_; ResourceUsageLog resource_usage_log_; std::unique_ptr bittorrent_client_; }; static datastore::kvdb::EnvConfig init_chain_data_db(NodeSettings& node_settings) { node_settings.data_directory->deploy(); node_settings.chain_config = db::chain_data_init(db::ChainDataInitSettings{ .chaindata_env_config = node_settings.chaindata_env_config, .prune_mode = node_settings.prune_mode, .network_id = node_settings.network_id, .init_if_empty = true, }); return node_settings.chaindata_env_config; } static rpc::ServerSettings make_execution_server_settings(const std::optional& exec_api_address) { return rpc::ServerSettings{ .address_uri = exec_api_address.value_or("localhost:9092"), .context_pool_settings = {.num_contexts = 1}, // just one execution context }; } static chainsync::EngineRpcSettings make_sync_engine_rpc_settings( const rpc::DaemonSettings& rpcdaemon_settings, log::Level log_verbosity) { return chainsync::EngineRpcSettings{ .engine_end_point = rpcdaemon_settings.engine_end_point, .engine_ifc_log_settings = rpcdaemon_settings.engine_ifc_log_settings, .private_api_addr = rpcdaemon_settings.private_api_addr, .log_verbosity = log_verbosity, .jwt_secret_file = rpcdaemon_settings.jwt_secret_file, }; } static stagedsync::TimerFactory make_log_timer_factory( const boost::asio::any_io_executor& executor, uint32_t sync_loop_log_interval_seconds) { return [=](std::function callback) { return std::make_shared( executor, sync_loop_log_interval_seconds * 1'000, std::move(callback)); }; } static stagedsync::BodiesStageFactory make_bodies_stage_factory( const ChainConfig& chain_config, db::DataModelFactory data_model_factory, const NodeImpl& node) { return [&chain_config, data_model_factory = std::move(data_model_factory), &node](stagedsync::SyncContext* sync_context) { return std::make_unique( sync_context, chain_config, data_model_factory, [&node]() { return node.last_pre_validated_block(); }); }; }; static stagedsync::StageContainerFactory make_stages_factory( const NodeSettings& node_settings, db::DataModelFactory data_model_factory, const NodeImpl& node) { auto bodies_stage_factory = make_bodies_stage_factory(*node_settings.chain_config, data_model_factory, node); return stagedsync::StagesFactoryImpl::to_factory({ node_settings, std::move(data_model_factory), std::move(bodies_stage_factory), }); } static sentry::SessionSentryClient::StatusDataProvider make_sentry_eth_status_data_provider( datastore::kvdb::ROAccess db_access, const ChainConfig& chain_config) { auto chain_head_provider = [db_access = std::move(db_access)] { return db::read_chain_head(db_access); }; sentry::eth::StatusDataProvider provider{std::move(chain_head_provider), chain_config}; return sentry::eth::StatusDataProvider::to_factory_function(std::move(provider)); } NodeImpl::NodeImpl( rpc::ClientContextPool& context_pool, Settings& settings) : settings_{settings}, data_store_{ init_chain_data_db(settings.node_settings), settings_.snapshot_settings.repository_path, }, execution_engine_{ execution_ioc_.get_executor(), settings_.node_settings, data_model_factory(), make_log_timer_factory(context_pool.any_executor(), settings_.node_settings.sync_loop_log_interval_seconds), make_stages_factory(settings_.node_settings, data_model_factory(), *this), data_store_.chaindata().access_rw(), }, execution_service_{std::make_shared(execution_engine_, execution_ioc_)}, execution_server_{make_execution_server_settings(settings_.node_settings.exec_api_address), execution_service_}, execution_direct_client_{execution_service_}, snapshot_sync_{ settings.snapshot_settings, chain_config().chain_id, data_store(), settings_.node_settings.data_directory->temp().path(), execution_engine_.stage_scheduler(), }, sentry_{ sentry::SentryClientFactory::make_sentry( std::move(settings.sentry_settings), settings.node_settings.remote_sentry_addresses, context_pool.as_executor_pool(), context_pool, make_sentry_eth_status_data_provider(data_store_.chaindata().access_ro(), chain_config()))}, chain_sync_{ context_pool.any_executor(), data_store(), execution_direct_client_, std::get<0>(sentry_), chain_config(), /* use_preverified_hashes = */ true, make_sync_engine_rpc_settings(settings.rpcdaemon_settings, settings.log_settings.log_verbosity), }, resource_usage_log_{*settings_.node_settings.data_directory} { backend_ = std::make_unique(settings_.node_settings, data_store_.chaindata().access_ro(), std::get<0>(sentry_)); backend_->set_node_name(settings_.node_settings.build_info.node_name); backend_kv_rpc_server_ = std::make_unique(settings_.server_settings, *backend_); bittorrent_client_ = std::make_unique(settings_.snapshot_settings.bittorrent_settings); } Task NodeImpl::wait_for_setup() { co_await snapshot_sync_.wait_for_setup(); } Task NodeImpl::run() { using namespace concurrency::awaitable_wait_for_all; try { co_await ( run_tasks() && snapshot_sync_.run() && embedded_sentry_run_if_needed()); } catch (const boost::system::system_error& ex) { SILK_ERROR_M("node") << "NodeImpl::run ex=" << ex.what(); if (ex.code() == boost::system::errc::operation_canceled) { // TODO(canepat) demote to debug after https://github.com/erigontech/silkworm/issues/2333 is solved SILK_WARN_M("node") << "NodeImpl::run operation_canceled"; } throw; } } Task NodeImpl::run_tasks() { using namespace concurrency::awaitable_wait_for_all; co_await wait_for_setup(); co_await ( run_execution_service() && run_execution_server() && resource_usage_log_.run() && run_chain_sync() && run_backend_kv_grpc_server()); } Task NodeImpl::run_execution_service() { // Thread running block execution requires custom stack size because of deep EVM call stacks return execution_service_->async_run("exec-engine", /* stack_size = */ kExecutionThreadStackSize); } Task NodeImpl::run_execution_server() { // Thread running block execution requires custom stack size because of deep EVM call stacks if (settings_.node_settings.exec_api_address) { co_await execution_server_.async_run(/* stack_size = */ kExecutionThreadStackSize); } } Task NodeImpl::run_backend_kv_grpc_server() { auto run = [this]() { backend_kv_rpc_server_->build_and_start(); backend_kv_rpc_server_->join(); }; auto stop = [this]() { backend_kv_rpc_server_->shutdown(); }; co_await concurrency::async_thread(std::move(run), std::move(stop), "bekv-server"); } Task NodeImpl::embedded_sentry_run_if_needed() { sentry::SentryClientFactory::SentryServerPtr server = std::get<1>(sentry_); if (server) { co_await server->run(); } } Task NodeImpl::run_chain_sync() { if (!settings_.node_settings.exec_api_address) { co_await chain_sync_.async_run(); } } Node::Node( rpc::ClientContextPool& context_pool, Settings& settings) : p_impl_(std::make_unique( context_pool, settings)) {} // Must be here (not in header) because NodeImpl size is necessary for std::unique_ptr in PIMPL idiom Node::~Node() = default; Task Node::run() { return p_impl_->run(); } Task Node::wait_for_setup() { return p_impl_->wait_for_setup(); } } // namespace silkworm::node ================================================ FILE: silkworm/node/node.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::node { class NodeImpl; class Node { public: Node( rpc::ClientContextPool& context_pool, Settings& settings); ~Node(); Node(const Node&) = delete; Node& operator=(const Node&) = delete; Task run(); Task wait_for_setup(); private: std::unique_ptr p_impl_; }; } // namespace silkworm::node ================================================ FILE: silkworm/node/remote/ethbackend/grpc/server/backend_calls.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "backend_calls.hpp" #include #include #include #include #include #include #include namespace silkworm::ethbackend::grpc::server { remote::EtherbaseReply EtherbaseCall::response_; void EtherbaseCall::fill_predefined_reply(const EthereumBackEnd& backend) { const auto etherbase = backend.etherbase(); if (etherbase.has_value()) { const auto h160 = rpc::h160_from_address(etherbase.value()).release(); EtherbaseCall::response_.set_allocated_address(h160); } } Task EtherbaseCall::operator()(const EthereumBackEnd& /*backend*/) { SILK_TRACE << "EtherbaseCall START"; if (response_.has_address()) { co_await agrpc::finish(responder_, response_, ::grpc::Status::OK); SILK_TRACE << "EtherbaseCall END etherbase: " << rpc::address_from_h160(response_.address()); } else { const ::grpc::Status error{::grpc::StatusCode::INTERNAL, "etherbase must be explicitly specified"}; co_await agrpc::finish_with_error(responder_, error); SILK_TRACE << "EtherbaseCall END error: " << error; } } remote::NetVersionReply NetVersionCall::response_; void NetVersionCall::fill_predefined_reply(const EthereumBackEnd& backend) { if (backend.chain_id()) { NetVersionCall::response_.set_id(*backend.chain_id()); } else { NetVersionCall::response_.set_id(0); // unused chain ID } } Task NetVersionCall::operator()(const EthereumBackEnd& /*backend*/) { SILK_TRACE << "NetVersionCall START"; co_await agrpc::finish(responder_, response_, ::grpc::Status::OK); SILK_TRACE << "NetVersionCall END chain_id: " << response_.id(); } Task NetPeerCountCall::operator()(const EthereumBackEnd& backend) { SILK_TRACE << "NetPeerCountCall START"; auto sentry_client = backend.sentry_client(); auto sentry = co_await sentry_client->service(); remote::NetPeerCountReply response; ::grpc::Status result_status{::grpc::Status::OK}; try { auto peer_count = co_await sentry->peer_count(); response.set_count(peer_count); SILK_DEBUG << "Reply OK peer count = " << peer_count; } catch (const rpc::GrpcStatusError& status_error) { result_status = status_error.status(); SILK_ERROR << "Reply KO result: " << result_status; } if (result_status.ok()) { co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "NetPeerCountCall END count: " << response.count(); } else { co_await agrpc::finish_with_error(responder_, result_status); SILK_TRACE << "NetPeerCountCall END error: " << result_status; } } types::VersionReply BackEndVersionCall::response_; void BackEndVersionCall::fill_predefined_reply() { BackEndVersionCall::response_.set_major(std::get<0>(kEthBackEndApiVersion)); BackEndVersionCall::response_.set_minor(std::get<1>(kEthBackEndApiVersion)); BackEndVersionCall::response_.set_patch(std::get<2>(kEthBackEndApiVersion)); } Task BackEndVersionCall::operator()(const EthereumBackEnd& /*backend*/) { SILK_TRACE << "BackEndVersionCall START"; co_await agrpc::finish(responder_, response_, ::grpc::Status::OK); SILK_TRACE << "BackEndVersionCall END version: " << response_.major() << "." << response_.minor() << "." << response_.patch(); } remote::ProtocolVersionReply ProtocolVersionCall::response_; void ProtocolVersionCall::fill_predefined_reply() { ProtocolVersionCall::response_.set_id(kEthDevp2pProtocolVersion); } Task ProtocolVersionCall::operator()(const EthereumBackEnd& /*backend*/) { SILK_TRACE << "ProtocolVersionCall START"; co_await agrpc::finish(responder_, response_, ::grpc::Status::OK); SILK_TRACE << "ProtocolVersionCall END id: " << response_.id(); } remote::ClientVersionReply ClientVersionCall::response_; void ClientVersionCall::fill_predefined_reply(const EthereumBackEnd& backend) { ClientVersionCall::response_.set_node_name(backend.node_name()); } Task ClientVersionCall::operator()(const EthereumBackEnd& /*backend*/) { SILK_TRACE << "ClientVersionCall START"; co_await agrpc::finish(responder_, response_, ::grpc::Status::OK); SILK_TRACE << "ClientVersionCall END node name: " << response_.node_name(); } Task SubscribeCall::operator()(const EthereumBackEnd& /*backend*/) { SILK_TRACE << "SubscribeCall START type: " << request_.type(); // TODO(canepat): remove this example and fill the correct stream responses remote::SubscribeReply response1; response1.set_type(remote::Event::PENDING_BLOCK); response1.set_data("001122"); co_await agrpc::write(responder_, response1); remote::SubscribeReply response2; response2.set_type(remote::Event::PENDING_LOGS); response2.set_data("334455"); co_await agrpc::write_and_finish(responder_, response2, ::grpc::WriteOptions{}, ::grpc::Status::OK); SILK_TRACE << "SubscribeCall END"; } Task NodeInfoCall::operator()(const EthereumBackEnd& backend) { SILK_TRACE << "NodeInfoCall START limit: " << request_.limit(); auto sentry_client = backend.sentry_client(); auto sentry = co_await sentry_client->service(); remote::NodesInfoReply response; ::grpc::Status result_status{::grpc::Status::OK}; try { auto node_infos = co_await sentry->node_infos(); for (auto& node_info : node_infos) { SILK_DEBUG << "Reply OK node info: client_id=" << node_info.client_id; response.add_nodes_info()->CopyFrom(sentry::grpc::interfaces::proto_node_info_from_node_info(node_info)); } } catch (const rpc::GrpcStatusError& status_error) { result_status = status_error.status(); SILK_ERROR << "Reply KO result: " << result_status; } if (result_status.ok()) { co_await agrpc::finish(responder_, response, ::grpc::Status::OK); SILK_TRACE << "NodeInfoCall END #nodes: " << response.nodes_info_size(); } else { co_await agrpc::finish_with_error(responder_, result_status); SILK_TRACE << "NodeInfoCall END error: " << result_status; } } } // namespace silkworm::ethbackend::grpc::server ================================================ FILE: silkworm/node/remote/ethbackend/grpc/server/backend_calls.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include #include // ETHBACKEND API protocol versions // 2.2.0 - first issue namespace silkworm::ethbackend::grpc::server { //! Current devp2p 'eth' protocol version in use. inline constexpr uint64_t kEthDevp2pProtocolVersion = 66; //! Current ETHBACKEND API protocol version. inline constexpr auto kEthBackEndApiVersion = std::make_tuple(2, 3, 0); //! Unary RPC for Etherbase method of 'ethbackend' gRPC protocol. class EtherbaseCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; static void fill_predefined_reply(const EthereumBackEnd& backend); Task operator()(const EthereumBackEnd& backend); private: static remote::EtherbaseReply response_; }; //! Unary RPC for NetVersion method of 'ethbackend' gRPC protocol. class NetVersionCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; static void fill_predefined_reply(const EthereumBackEnd& backend); Task operator()(const EthereumBackEnd& backend); private: static remote::NetVersionReply response_; }; //! Unary RPC for NetPeerCount method of 'ethbackend' gRPC protocol. class NetPeerCountCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(const EthereumBackEnd& backend); }; //! Unary RPC for Version method of 'ethbackend' gRPC protocol. class BackEndVersionCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; static void fill_predefined_reply(); Task operator()(const EthereumBackEnd& backend); private: static types::VersionReply response_; }; //! Unary RPC for ProtocolVersion method of 'ethbackend' gRPC protocol. class ProtocolVersionCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; static void fill_predefined_reply(); Task operator()(const EthereumBackEnd& backend); private: static remote::ProtocolVersionReply response_; }; //! Unary RPC for ClientVersion method of 'ethbackend' gRPC protocol. class ClientVersionCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; static void fill_predefined_reply(const EthereumBackEnd& backend); Task operator()(const EthereumBackEnd& backend); private: static remote::ClientVersionReply response_; }; //! Server-streaming RPC for Subscribe method of 'ethbackend' gRPC protocol. class SubscribeCall : public rpc::server::ServerStreamingCall { public: using Base::ServerStreamingCall; Task operator()(const EthereumBackEnd& backend); }; //! Unary RPC for NodeInfo method of 'ethbackend' gRPC protocol. class NodeInfoCall : public rpc::server::UnaryCall { public: using Base::UnaryCall; Task operator()(const EthereumBackEnd& backend); }; } // namespace silkworm::ethbackend::grpc::server ================================================ FILE: silkworm/node/remote/ethbackend/grpc/server/backend_server.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "backend_server.hpp" #include #include #include namespace silkworm::ethbackend::grpc::server { using rpc::request_repeatedly; BackEndServer::BackEndServer(const rpc::ServerSettings& settings, const EthereumBackEnd& backend) : Server(settings), backend_(backend) { setup_backend_calls(backend); SILK_INFO << "BackEndServer created listening on: " << settings.address_uri; } // Register the gRPC services: they must exist for the lifetime of the server built by builder. void BackEndServer::register_async_services(::grpc::ServerBuilder& builder) { builder.RegisterService(&backend_async_service_); } void BackEndServer::setup_backend_calls(const EthereumBackEnd& backend) { EtherbaseCall::fill_predefined_reply(backend); NetVersionCall::fill_predefined_reply(backend); BackEndVersionCall::fill_predefined_reply(); ProtocolVersionCall::fill_predefined_reply(); ClientVersionCall::fill_predefined_reply(backend); } void BackEndServer::register_backend_request_calls(agrpc::GrpcContext* grpc_context) { SILK_TRACE << "BackEndService::register_backend_request_calls START"; auto service = &backend_async_service_; auto& backend = backend_; // Register one requested call repeatedly for each RPC: asio-grpc will take care of re-registration on any incoming call request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestEtherbase, [&backend](auto&&... args) -> Task { co_await EtherbaseCall{std::forward(args)...}(backend); }); request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestNetVersion, [&backend](auto&&... args) -> Task { co_await NetVersionCall{std::forward(args)...}(backend); }); request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestNetPeerCount, [&backend](auto&&... args) -> Task { co_await NetPeerCountCall{std::forward(args)...}(backend); }); request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestVersion, [&backend](auto&&... args) -> Task { co_await BackEndVersionCall{std::forward(args)...}(backend); }); request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestProtocolVersion, [&backend](auto&&... args) -> Task { co_await ProtocolVersionCall{std::forward(args)...}(backend); }); request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestClientVersion, [&backend](auto&&... args) -> Task { co_await ClientVersionCall{std::forward(args)...}(backend); }); request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestSubscribe, [&backend](auto&&... args) -> Task { co_await SubscribeCall{std::forward(args)...}(backend); }); request_repeatedly(*grpc_context, service, &remote::ETHBACKEND::AsyncService::RequestNodeInfo, [&backend](auto&&... args) -> Task { co_await NodeInfoCall{std::forward(args)...}(backend); }); SILK_TRACE << "BackEndService::register_backend_request_calls END"; } //! Start server-side RPC requests as required by gRPC async model: one RPC per type is requested in advance. void BackEndServer::register_request_calls() { // Start all server-side RPC requests for each available server context for (size_t i = 0; i < num_contexts(); ++i) { const auto& context = next_context(); auto grpc_context = context.server_grpc_context(); // Register initial requested calls for ETHBACKEND and KV services register_backend_request_calls(grpc_context); } } } // namespace silkworm::ethbackend::grpc::server ================================================ FILE: silkworm/node/remote/ethbackend/grpc/server/backend_server.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::ethbackend::grpc::server { class BackEndServer : public virtual rpc::Server { public: BackEndServer(const rpc::ServerSettings& settings, const EthereumBackEnd& backend); BackEndServer(const BackEndServer&) = delete; BackEndServer& operator=(const BackEndServer&) = delete; protected: void register_async_services(::grpc::ServerBuilder& builder) override; void register_request_calls() override; private: static void setup_backend_calls(const EthereumBackEnd& backend); void register_backend_request_calls(agrpc::GrpcContext* grpc_context); //! The Ethereum full node service. const EthereumBackEnd& backend_; //! \warning The gRPC service must exist for the lifetime of the gRPC server it is registered on. remote::ETHBACKEND::AsyncService backend_async_service_; }; } // namespace silkworm::ethbackend::grpc::server ================================================ FILE: silkworm/node/remote/ethbackend/grpc/server/backend_server_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "backend_server.hpp" #include #include // DO NOT remove: used for std::condition_variable, CLion suggestion is buggy #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std::chrono_literals; namespace { // Trick to avoid name clashes in multiple test modules class BackEndClient { public: explicit BackEndClient(remote::ETHBACKEND::StubInterface* stub) : stub_(stub) {} grpc::Status etherbase(remote::EtherbaseReply* response) { grpc::ClientContext context; return stub_->Etherbase(&context, remote::EtherbaseRequest{}, response); } grpc::Status net_version(remote::NetVersionReply* response) { grpc::ClientContext context; return stub_->NetVersion(&context, remote::NetVersionRequest{}, response); } grpc::Status net_peer_count(remote::NetPeerCountReply* response) { grpc::ClientContext context; return stub_->NetPeerCount(&context, remote::NetPeerCountRequest{}, response); } grpc::Status version(types::VersionReply* response) { grpc::ClientContext context; return stub_->Version(&context, google::protobuf::Empty{}, response); } grpc::Status protocol_version(remote::ProtocolVersionReply* response) { grpc::ClientContext context; return stub_->ProtocolVersion(&context, remote::ProtocolVersionRequest{}, response); } grpc::Status client_version(remote::ClientVersionReply* response) { grpc::ClientContext context; return stub_->ClientVersion(&context, remote::ClientVersionRequest{}, response); } grpc::Status subscribe_and_consume(const remote::SubscribeRequest& request, std::vector& responses) { grpc::ClientContext context; auto subscribe_reply_reader = stub_->Subscribe(&context, request); bool has_more{true}; do { has_more = subscribe_reply_reader->Read(&responses.emplace_back()); } while (has_more); responses.pop_back(); return subscribe_reply_reader->Finish(); } grpc::Status node_info(const remote::NodesInfoRequest& request, remote::NodesInfoReply* response) { grpc::ClientContext context; return stub_->NodeInfo(&context, request, response); } private: remote::ETHBACKEND::StubInterface* stub_; }; constexpr uint64_t kTestSentryPeerCount = 10; const std::string kTestSentryNodeId{"24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d"}; const std::string kTestSentryNodeClientId{"MockSentryClient"}; class MockSentryClient : public std::enable_shared_from_this, public silkworm::sentry::api::SentryClient, public silkworm::sentry::api::Service { template using Task = silkworm::Task; Task> service() override { co_return shared_from_this(); } bool is_ready() override { return true; } void on_disconnect(std::function()> /*callback*/) override {} Task reconnect() override { co_return; } Task set_status(silkworm::sentry::eth::StatusData /*status_data*/) override { throw std::runtime_error("not implemented"); } Task handshake() override { throw std::runtime_error("not implemented"); } Task node_infos() override { const std::string ip_str = "1.2.3.4"; const uint16_t port = 50555; const std::string node_url_str = std::string("enode://") + kTestSentryNodeId + "@" + ip_str + ":" + std::to_string(port); silkworm::sentry::api::NodeInfo info = { silkworm::sentry::EnodeUrl{node_url_str}, kTestSentryNodeClientId, boost::asio::ip::tcp::endpoint{boost::asio::ip::make_address(ip_str), port}, port, }; co_return NodeInfos{info}; } Task send_message_by_id(silkworm::sentry::Message /*message*/, silkworm::sentry::EccPublicKey /*public_key*/) override { throw std::runtime_error("not implemented"); } Task send_message_to_random_peers(silkworm::sentry::Message /*message*/, size_t /*max_peers*/) override { throw std::runtime_error("not implemented"); } Task send_message_to_all(silkworm::sentry::Message /*message*/) override { throw std::runtime_error("not implemented"); } Task send_message_by_min_block(silkworm::sentry::Message /*message*/, size_t /*max_peers*/) override { throw std::runtime_error("not implemented"); } Task peer_min_block(silkworm::sentry::EccPublicKey /*public_key*/) override { throw std::runtime_error("not implemented"); } Task messages( silkworm::sentry::api::MessageIdSet /*message_id_filter*/, std::function(silkworm::sentry::api::MessageFromPeer)> /*consumer*/) override { throw std::runtime_error("not implemented"); } Task peers() override { throw std::runtime_error("not implemented"); } Task peer_count() override { co_return kTestSentryPeerCount; } Task> peer_by_id(silkworm::sentry::EccPublicKey /*public_key*/) override { throw std::runtime_error("not implemented"); } Task penalize_peer(silkworm::sentry::EccPublicKey /*public_key*/) override { throw std::runtime_error("not implemented"); } Task peer_events(std::function(silkworm::sentry::api::PeerEvent)> /*consumer*/) override { throw std::runtime_error("not implemented"); } }; // TODO(canepat): better copy grpc_pick_unused_port_or_die to generate unused port constexpr std::string_view kTestAddressUri{"localhost:12345"}; const silkworm::datastore::kvdb::MapConfig kTestMap{"TestTable"}; const silkworm::datastore::kvdb::MapConfig kTestMultiMap{"TestMultiTable", mdbx::key_mode::usual, mdbx::value_mode::multi}; using namespace silkworm; using namespace silkworm::datastore::kvdb; using StateChangeTokenObserver = std::function)>; class TestableStateChangeCollection : public StateChangeCollection { public: std::optional subscribe(StateChangeConsumer consumer, StateChangeFilter filter) override { const auto token = StateChangeCollection::subscribe(consumer, filter); if (token_observer_) { token_observer_(token); } return token; } void set_token(StateChangeToken next_token) { next_token_ = next_token; } void register_token_observer(StateChangeTokenObserver token_observer) { token_observer_ = std::move(token_observer); } private: StateChangeTokenObserver token_observer_; }; class TestableEthereumBackEnd : public EthereumBackEnd { public: TestableEthereumBackEnd(const NodeSettings& node_settings, datastore::kvdb::ROAccess chaindata) : EthereumBackEnd{ node_settings, std::move(chaindata), std::make_shared(), std::make_unique(), } {} TestableStateChangeCollection* state_change_source_for_test() const noexcept { return dynamic_cast(EthereumBackEnd::state_change_source()); } }; using BackEndServer = ethbackend::grpc::server::BackEndServer; struct BackEndE2ETest { explicit BackEndE2ETest( const NodeSettings& options = {}) { std::shared_ptr channel = grpc::CreateChannel(std::string{kTestAddressUri}, grpc::InsecureChannelCredentials()); ethbackend_stub = remote::ETHBACKEND::NewStub(channel); backend_client = std::make_unique(ethbackend_stub.get()); srv_config.context_pool_settings.num_contexts = 1; srv_config.address_uri = kTestAddressUri; DataDirectory data_dir{tmp_dir.path()}; REQUIRE_NOTHROW(data_dir.deploy()); db_config = std::make_unique(); db_config->max_readers = options.chaindata_env_config.max_readers; db_config->path = data_dir.chaindata().path().string(); db_config->create = true; db_config->in_memory = true; database_env = open_env(*db_config); auto rw_txn{database_env.start_write()}; open_map(rw_txn, kTestMap); open_map(rw_txn, kTestMultiMap); rw_txn.commit(); backend = std::make_unique(options, datastore::kvdb::ROAccess{database_env}); server = std::make_unique(srv_config, *backend); server->build_and_start(); } void fill_tables() { auto rw_txn = database_env.start_write(); PooledCursor rw_cursor1{rw_txn, kTestMap}; rw_cursor1.upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor1.upsert(mdbx::slice{"BB"}, mdbx::slice{"11"}); PooledCursor rw_cursor2{rw_txn, kTestMultiMap}; rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"00"}); rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"11"}); rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"22"}); rw_cursor2.upsert(mdbx::slice{"BB"}, mdbx::slice{"22"}); rw_txn.commit(); } void alter_tables() { auto rw_txn = database_env.start_write(); PooledCursor rw_cursor1{rw_txn, kTestMap}; rw_cursor1.upsert(mdbx::slice{"CC"}, mdbx::slice{"22"}); PooledCursor rw_cursor2{rw_txn, kTestMultiMap}; rw_cursor2.upsert(mdbx::slice{"AA"}, mdbx::slice{"33"}); rw_cursor2.upsert(mdbx::slice{"BB"}, mdbx::slice{"33"}); rw_txn.commit(); } ~BackEndE2ETest() { server->shutdown(); server->join(); } std::unique_ptr ethbackend_stub; std::unique_ptr backend_client; rpc::ServerSettings srv_config; TemporaryDirectory tmp_dir; std::unique_ptr db_config; mdbx::env_managed database_env; std::unique_ptr backend; std::unique_ptr server; }; } // namespace namespace silkworm::ethbackend::grpc::server { // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("BackEndServer", "[silkworm][node][rpc]") { log::init(); rpc::ServerSettings srv_config; srv_config.address_uri = kTestAddressUri; TemporaryDirectory tmp_dir; DataDirectory data_dir{tmp_dir.path()}; REQUIRE_NOTHROW(data_dir.deploy()); EnvConfig db_config{data_dir.chaindata().path().string()}; db_config.create = true; db_config.in_memory = true; auto chaindata_env = open_env(db_config); NodeSettings node_settings; TestableEthereumBackEnd backend{node_settings, datastore::kvdb::ROAccess{chaindata_env}}; SECTION("BackEndServer::BackEndServer OK: create/destroy server") { BackEndServer server{srv_config, backend}; } SECTION("BackEndServer::BackEndServer OK: create/shutdown/destroy server") { BackEndServer server{srv_config, backend}; server.shutdown(); } SECTION("BackEndServer::build_and_start OK: run server in separate thread") { BackEndServer server{srv_config, backend}; server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; server.shutdown(); server_thread.join(); } SECTION("BackEndServer::build_and_start OK: create/shutdown/run/destroy server") { BackEndServer server{srv_config, backend}; server.shutdown(); server.build_and_start(); } SECTION("BackEndServer::shutdown OK: shutdown server not running") { BackEndServer server{srv_config, backend}; server.shutdown(); } SECTION("BackEndServer::shutdown OK: shutdown twice server not running") { BackEndServer server{srv_config, backend}; server.shutdown(); server.shutdown(); } SECTION("BackEndServer::shutdown OK: shutdown running server") { BackEndServer server{srv_config, backend}; server.build_and_start(); server.shutdown(); server.join(); } SECTION("BackEndServer::shutdown OK: shutdown twice running server") { BackEndServer server{srv_config, backend}; server.build_and_start(); server.shutdown(); server.shutdown(); server.join(); } SECTION("BackEndServer::shutdown OK: shutdown running server again after join") { BackEndServer server{srv_config, backend}; server.build_and_start(); server.shutdown(); server.join(); server.shutdown(); } SECTION("BackEndServer::join OK: shutdown joined server") { BackEndServer server{srv_config, backend}; server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; server.shutdown(); server_thread.join(); } SECTION("BackEndServer::join OK: shutdown joined server and join again") { BackEndServer server{srv_config, backend}; server.build_and_start(); std::thread server_thread{[&server]() { server.join(); }}; server.shutdown(); server_thread.join(); server.join(); // cannot move before server_thread.join() due to data race in boost::asio::detail::posix_thread } } TEST_CASE("BackEndServer E2E: empty node settings", "[silkworm][node][rpc]") { log::init(); BackEndE2ETest test; auto backend_client = *test.backend_client; SECTION("Etherbase: return missing coinbase error") { remote::EtherbaseReply response; const auto status = backend_client.etherbase(&response); CHECK(!status.ok()); CHECK(status.error_code() == ::grpc::StatusCode::INTERNAL); CHECK(status.error_message() == "etherbase must be explicitly specified"); CHECK(!response.has_address()); } SECTION("NetVersion: return out-of-range network ID") { remote::NetVersionReply response; const auto status = backend_client.net_version(&response); CHECK(status.ok()); CHECK(response.id() == 0); } SECTION("Version: return ETHBACKEND version") { types::VersionReply response; const auto status = backend_client.version(&response); CHECK(status.ok()); CHECK(response.major() == 2); CHECK(response.minor() == 3); CHECK(response.patch() == 0); } SECTION("ProtocolVersion: return ETH protocol version") { remote::ProtocolVersionReply response; const auto status = backend_client.protocol_version(&response); CHECK(status.ok()); CHECK(response.id() == kEthDevp2pProtocolVersion); } SECTION("ClientVersion: return Silkworm client version") { remote::ClientVersionReply response; const auto status = backend_client.client_version(&response); CHECK(status.ok()); CHECK(absl::StrContains(response.node_name(), "silkworm")); } // TODO(canepat): change using something meaningful when really implemented SECTION("Subscribe: return streamed subscriptions") { remote::SubscribeRequest request; std::vector responses; const auto status = backend_client.subscribe_and_consume(request, responses); CHECK(status.ok()); CHECK(responses.size() == 2); } } TEST_CASE("BackEndServer E2E: mainnet chain with zero etherbase", "[silkworm][node][rpc]") { log::init(); NodeSettings node_settings; node_settings.chain_config = kMainnetConfig; node_settings.etherbase = evmc::address{}; BackEndE2ETest test{node_settings}; auto backend_client = *test.backend_client; SECTION("Etherbase: return coinbase address") { remote::EtherbaseReply response; const auto status = backend_client.etherbase(&response); CHECK(status.ok()); CHECK(response.has_address()); CHECK(response.address() == types::H160()); } SECTION("NetVersion: return network ID") { remote::NetVersionReply response; const auto status = backend_client.net_version(&response); CHECK(status.ok()); CHECK(response.id() == kMainnetConfig.chain_id); } } TEST_CASE("BackEndServer E2E: one Sentry status OK", "[silkworm][node][rpc]") { BackEndE2ETest test; auto backend_client = *test.backend_client; SECTION("NetPeerCount: return peer count") { remote::NetPeerCountReply response; const auto status = backend_client.net_peer_count(&response); CHECK(status.ok()); CHECK(response.count() == kTestSentryPeerCount); } SECTION("NodeInfo: return information about nodes") { remote::NodesInfoRequest request; request.set_limit(0); remote::NodesInfoReply response; const auto status = backend_client.node_info(request, &response); CHECK(status.ok()); CHECK(response.nodes_info_size() == 1); CHECK(response.nodes_info(0).id() == kTestSentryNodeId); CHECK(response.nodes_info(0).name() == kTestSentryNodeClientId); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::ethbackend::grpc::server ================================================ FILE: silkworm/node/resource_usage.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "resource_usage.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::node { using namespace std::chrono_literals; using std::chrono::steady_clock; static constexpr std::chrono::seconds kResourceUsageInterval{300s}; Task ResourceUsageLog::run() { auto executor = co_await boost::asio::this_coro::executor; boost::asio::steady_timer timer{executor}; const auto start_time = steady_clock::now(); while (true) { try { timer.expires_after(kResourceUsageInterval); co_await timer.async_wait(boost::asio::use_awaitable); log::Info("Resource usage", {"mem", human_size(os::get_mem_usage()), "chain", human_size(data_directory_.chaindata().size()), "temp", human_size(data_directory_.temp().size()), "uptime", StopWatch::format(steady_clock::now() - start_time)}); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) { co_return; } } } } } // namespace silkworm::node ================================================ FILE: silkworm/node/resource_usage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::node { //! Log for resource usage class ResourceUsageLog { public: explicit ResourceUsageLog(const DataDirectory& data_directory) : data_directory_(data_directory) {} Task run(); private: const DataDirectory& data_directory_; }; } // namespace silkworm::node ================================================ FILE: silkworm/node/settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::node { struct Settings { log::Settings log_settings; // Configuration for the logging facility NodeSettings node_settings; // Configuration for the node rpc::DaemonSettings rpcdaemon_settings; // Configuration for the RPC daemon sentry::Settings sentry_settings; // Configuration for Sentry client + embedded server rpc::ServerSettings server_settings; // Configuration for the gRPC server snapshots::SnapshotSettings snapshot_settings; // Configuration for the database snapshots }; } // namespace silkworm::node ================================================ FILE: silkworm/node/stagedsync/execution_engine.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "execution_engine.hpp" #include #include #include #include #include namespace silkworm::stagedsync { using namespace boost::asio; using execution::api::ValidationError; using execution::api::ValidChain; using execution::api::VerificationResult; ExecutionEngine::ExecutionEngine( std::optional executor, NodeSettings& ns, db::DataModelFactory data_model_factory, std::optional log_timer_factory, StageContainerFactory stages_factory, datastore::kvdb::RWAccess dba) : context_pool_{executor ? std::unique_ptr>{} : std::make_unique>(1)}, executor_{executor ? std::move(*executor) : context_pool_->any_executor()}, node_settings_{ns}, main_chain_{ executor_, ns, std::move(data_model_factory), std::move(log_timer_factory), std::move(stages_factory), std::move(dba), }, block_cache_{kDefaultCacheSize} {} void ExecutionEngine::open() { // needed to circumvent mdbx threading model limitations if (context_pool_) context_pool_->start(); main_chain_.open(); last_finalized_block_ = main_chain_.last_finalized_head(); last_fork_choice_ = main_chain_.last_chosen_head(); block_progress_ = main_chain_.get_block_progress(); } void ExecutionEngine::close() { main_chain_.close(); context_pool_.reset(); } BlockNum ExecutionEngine::block_progress() const { return block_progress_; // main_chain_.get_block_progress() or forks block progress } BlockId ExecutionEngine::last_fork_choice() const { return last_fork_choice_; } BlockId ExecutionEngine::last_finalized_block() const { return last_finalized_block_; } BlockId ExecutionEngine::last_safe_block() const { return last_safe_block_; } BlockNum ExecutionEngine::max_frozen_block_num() const { return main_chain_.max_frozen_block_num(); } void ExecutionEngine::insert_blocks(const std::vector>& blocks) { SILK_DEBUG << "ExecutionEngine: inserting " << blocks.size() << " blocks"; if (blocks.empty()) return; for (const auto& block : blocks) { insert_block(block); } } bool ExecutionEngine::insert_block(const std::shared_ptr& block) { Hash header_hash{block->header.hash()}; if (block_cache_.get(header_hash)) return true; // ignore repeated blocks block_cache_.put(header_hash, block); block_progress_ = std::max(block_progress_, block->header.number); // if we are not tracking forks, just insert the block into the main chain if (!fork_tracking_active_) { main_chain_.insert_block(*block); // BLOCKING return true; } // find attachment point at fork heads auto f = find_fork_to_extend(forks_, block->header); if (f != forks_.end()) { // the block extends a fork SILK_DEBUG << "ExecutionEngine: extending a fork"; (*f)->extend_with(header_hash, *block); } else { // the block must be put to a new fork // (to avoid complicated code we ignore the case whether the attaching point is inside a current fork) auto forking_path = find_forking_point(block->header); if (!forking_path) return false; if (forking_path->forking_point.block_num < last_finalized_block().block_num) return false; // ignore forking_path->blocks.push_back(block); SILK_DEBUG << "ExecutionEngine: creating new fork"; forks_.push_back(main_chain_.fork(forking_path->forking_point)); auto& new_fork = forks_.back(); BlockId new_head = {.block_num = block->header.number, .hash = header_hash}; new_fork->start_with(new_head, std::move(forking_path->blocks)); } return true; } std::optional ExecutionEngine::find_forking_point(const BlockHeader& header) const { ForkingPath path; // a path from the header to the first block of the main chain using parent-child relationship // search in cache till to the main chain path.forking_point = {.block_num = header.number - 1, .hash = header.parent_hash}; while (path.forking_point.block_num > main_chain_.last_chosen_head().block_num) { auto parent = block_cache_.get_as_copy(path.forking_point.hash); // parent is a pointer if (!parent) return {}; // not found path.blocks.push_front(*parent); // in reverse order path.forking_point = {.block_num = (*parent)->header.number - 1, .hash = (*parent)->header.parent_hash}; } // forking point is on main chain canonical head if (path.forking_point == main_chain_.last_chosen_head()) return {std::move(path)}; // search remaining path on main chain if (main_chain_.is_finalized_canonical(path.forking_point)) return {std::move(path)}; auto forking_point = main_chain_.find_forking_point(path.forking_point.hash); if (!forking_point) return {}; // not found return {std::move(path)}; } VerificationResult ExecutionEngine::verify_chain_no_fork_tracking(Hash head_block_hash) { SILK_INFO_M("ExecutionEngine") << "verifying chain " << head_block_hash.to_hex(); SILKWORM_ASSERT(!fork_tracking_active_); if (last_fork_choice_.hash == head_block_hash) { SILK_DEBUG << "ExecutionEngine: chain " << head_block_hash.to_hex() << " already verified"; return ValidChain{last_fork_choice_}; } return main_chain_.verify_chain(head_block_hash); } Task ExecutionEngine::verify_chain(Hash head_block_hash) { SILK_INFO_M("ExecutionEngine") << "verifying chain " << head_block_hash.to_hex(); if (last_fork_choice_.hash == head_block_hash) { SILK_DEBUG << "ExecutionEngine: chain " << head_block_hash.to_hex() << " already verified"; co_return ValidChain{last_fork_choice_}; } if (!fork_tracking_active_) { auto verification = main_chain_.verify_chain(head_block_hash); // BLOCKING co_return verification; } auto fork = find_fork_by_head(forks_, head_block_hash); if (fork == forks_.end()) { if (main_chain_.is_finalized_canonical(head_block_hash)) { SILK_DEBUG << "ExecutionEngine: chain " << head_block_hash.to_hex() << " already verified"; co_return ValidChain{last_fork_choice_}; } else { SILK_WARN << "ExecutionEngine: chain " << head_block_hash.to_hex() << " not found at verification time"; co_return ValidationError{}; } } auto verify_chain_future = (*fork)->verify_chain(); co_return (co_await verify_chain_future.get()); } bool ExecutionEngine::notify_fork_choice_update(Hash head_block_hash, std::optional finalized_block_hash, std::optional safe_block_hash) { SILK_INFO_M("ExecutionEngine") << "updating fork choice to " << head_block_hash.to_hex(); if (!fork_tracking_active_ || head_block_hash == last_fork_choice_.hash) { bool updated = main_chain_.notify_fork_choice_update(head_block_hash, finalized_block_hash); // BLOCKING if (!updated) return false; last_fork_choice_ = main_chain_.last_chosen_head(); if (head_block_hash == main_chain_.current_head().hash && node_settings_.parallel_fork_tracking_enabled) { SILK_INFO_M("ExecutionEngine") << "activate parallel fork tracking at head " << head_block_hash.to_hex(); fork_tracking_active_ = true; } } else { // chose the fork with the given head auto f = find_fork_by_head(forks_, head_block_hash); if (f == forks_.end()) { if (main_chain_.is_finalized_canonical(head_block_hash)) { SILK_DEBUG << "ExecutionEngine: chain " << head_block_hash.to_hex() << " already chosen"; return true; } SILK_WARN << "ExecutionEngine: chain " << head_block_hash.to_hex() << " not found at fork choice update time"; return false; } // notify the fork of the update - we need to block here to restore the invariant auto fork_choice_aw_future = (*f)->fork_choice(head_block_hash, finalized_block_hash, safe_block_hash); std::future fork_choice_future = concurrency::spawn_future(executor_, fork_choice_aw_future.get()); bool updated = fork_choice_future.get(); // BLOCKING if (!updated) return false; std::unique_ptr fork = std::move(*f); forks_.erase(f); discard_all_forks(); // remove all other forks last_fork_choice_ = fork->current_head(); main_chain_.reintegrate_fork(*fork); // BLOCKING fork->close(); } if (finalized_block_hash) { const auto finalized_header = main_chain_.get_header(*finalized_block_hash); ensure_invariant(finalized_header.has_value(), "finalized block not found in main chain"); last_finalized_block_ = {finalized_header->number, *finalized_block_hash}; } if (safe_block_hash) { const auto safe_header = main_chain_.get_header(*safe_block_hash); ensure_invariant(safe_header.has_value(), "safe block not found in main chain"); last_safe_block_ = {safe_header->number, *safe_block_hash}; } return true; } void ExecutionEngine::discard_all_forks() { // remove all forks except the given one from forks_ // ensure a clean exit of all those forks that can be busy in a VerifyChain // method or something else; maybe use a sweeper thread for (auto& fork : forks_) { fork->close(); // todo: maybe we should wait for the fork to close in another thread, a sweeper thread } forks_.clear(); } // TO IMPLEMENT OR REWORK --------------------------------------------------------------------------------------------- std::optional ExecutionEngine::get_header(Hash header_hash) const { // read from cache, then from main_chain_ auto block = block_cache_.get_as_copy(header_hash); if (block) return (*block)->header; return main_chain_.get_header(header_hash); } std::optional ExecutionEngine::get_header(BlockNum block_num, Hash hash) const { // read from cache, then from main_chain_ auto block = block_cache_.get_as_copy(hash); if (block) return (*block)->header; return main_chain_.get_header(block_num, hash); } std::vector ExecutionEngine::get_last_headers(uint64_t limit) const { ensure_invariant(!fork_tracking_active_, "actual get_last_headers() impl assume it is called only at beginning"); // if fork_tracking_active_ is true, we should read blocks from cache where they are not ordered on block number return main_chain_.get_last_headers(limit); } std::optional ExecutionEngine::get_header_td(Hash h, std::optional block_num) const { ensure_invariant(!fork_tracking_active_, "actual get_header_td() impl assume it is called only at beginning"); // if fork_tracking_active_ is true, we should read blocks from forks and recompute total difficulty but this // is a duty of the sync component if (block_num) { return main_chain_.get_header_td(*block_num, h); } return main_chain_.get_header_td(h); } std::optional ExecutionEngine::get_body(Hash header_hash) const { // read from cache, then from main_chain_ auto block = block_cache_.get_as_copy(header_hash); if (block) return *(block.value().get()); return main_chain_.get_body(header_hash); } std::optional ExecutionEngine::get_canonical_header(BlockNum block_num) const { auto hash = main_chain_.get_finalized_canonical_hash(block_num); if (!hash) return {}; return main_chain_.get_header(*hash); } std::optional ExecutionEngine::get_canonical_hash(BlockNum block_num) const { return main_chain_.get_finalized_canonical_hash(block_num); } std::optional ExecutionEngine::get_canonical_body(BlockNum block_num) const { auto hash = main_chain_.get_finalized_canonical_hash(block_num); if (!hash) return {}; return main_chain_.get_body(*hash); } std::optional ExecutionEngine::get_block_num(Hash header_hash) const { auto cached_block = block_cache_.get_as_copy(header_hash); if (cached_block) return (*cached_block)->header.number; return main_chain_.get_block_num(header_hash); } bool ExecutionEngine::is_canonical(Hash header_hash) const { return main_chain_.is_finalized_canonical(header_hash); } datastore::StageScheduler& ExecutionEngine::stage_scheduler() const { return main_chain_.stage_scheduler(); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/execution_engine.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "forks/extending_fork.hpp" #include "forks/main_chain.hpp" #include "timer_factory.hpp" namespace silkworm::stagedsync { /** * ExecutionEngine is the main component of the staged sync. * It is responsible for: * - inserting blocks keeping track of forks * - verifying forks managing some parallel executions of the pipeline * - exposing a consistent view of the chain * * Its interface is sync to maintain a simple and consistent state but on forks: * - block insertion & chain verification immediately return * - notify_fork_choice_update need to block to set a consistent view of the chain * On main-chain operations are blocking because when there are no forks we do not need async execution */ class ExecutionEngine : public execution::api::ExecutionEngine, public Stoppable { public: ExecutionEngine( std::optional executor, NodeSettings& ns, db::DataModelFactory data_model_factory, std::optional log_timer_factory, StageContainerFactory stages_factory, datastore::kvdb::RWAccess dba); ~ExecutionEngine() override = default; // needed to circumvent mdbx threading model limitations void open() override; void close() override; // actions void insert_blocks(const std::vector>& blocks) override; bool insert_block(const std::shared_ptr& block); execution::api::VerificationResult verify_chain_no_fork_tracking(Hash head_block_hash); Task verify_chain(Hash head_block_hash) override; bool notify_fork_choice_update( Hash head_block_hash, std::optional finalized_block_hash, std::optional safe_block_hash) override; // state BlockNum block_progress() const override; BlockId last_fork_choice() const override; BlockId last_finalized_block() const override; BlockId last_safe_block() const override; BlockNum max_frozen_block_num() const override; // header/body retrieval std::optional get_header(Hash) const override; std::optional get_header(BlockNum, Hash) const; std::optional get_canonical_header(BlockNum) const override; std::optional get_canonical_hash(BlockNum) const override; std::optional get_body(Hash) const override; std::optional get_canonical_body(BlockNum) const override; bool is_canonical(Hash) const override; std::optional get_block_num(Hash) const override; std::vector get_last_headers(uint64_t limit) const override; std::optional get_header_td(Hash, std::optional) const override; datastore::StageScheduler& stage_scheduler() const; protected: struct ForkingPath { BlockId forking_point; std::list> blocks; // blocks in reverse order }; std::optional find_forking_point(const BlockHeader& header) const; void discard_all_forks(); std::unique_ptr> context_pool_; boost::asio::any_io_executor executor_; NodeSettings& node_settings_; MainChain main_chain_; ForkContainer forks_; static constexpr size_t kDefaultCacheSize = 1000; mutable LruCache> block_cache_; BlockNum block_progress_{0}; bool fork_tracking_active_{false}; BlockId last_fork_choice_; BlockId last_finalized_block_; BlockId last_safe_block_; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/execution_engine_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "execution_engine.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { using namespace silkworm::db; using namespace stagedsync; using execution::api::InvalidChain; using execution::api::ValidationError; using execution::api::ValidChain; using silkworm::stagedsync::test_util::make_stages_factory; using silkworm::test_util::generate_sample_child_blocks; using silkworm::test_util::TaskRunner; class ExecutionEngineForTest : public stagedsync::ExecutionEngine { public: using stagedsync::ExecutionEngine::ExecutionEngine; MainChain& main_chain() { return main_chain_; } }; TEST_CASE("ExecutionEngine Integration Test", "[node][execution][execution_engine]") { TemporaryDirectory tmp_dir; TaskRunner runner; Environment::set_stop_before_stage(stages::kSendersKey); // only headers, block hashes and bodies db::test_util::TestDataStore db_context{tmp_dir}; db::DataModelFactory data_model_factory = db_context.data_model_factory(); auto node_settings = NodeSettings{ .data_directory = std::make_unique(tmp_dir.path(), false), .chain_config = db_context.get_chain_config(), .parallel_fork_tracking_enabled = false, .keep_db_txn_open = true, }; auto db_access = db_context.chaindata_rw(); ExecutionEngineForTest exec_engine{ runner.executor(), node_settings, data_model_factory, /* log_timer_factory = */ std::nullopt, make_stages_factory(node_settings, data_model_factory), db_access, }; exec_engine.open(); auto& tx = exec_engine.main_chain().tx(); // mdbx refuses to open a ROTxn when there is a RWTxn in the same thread const auto header0_hash = exec_engine.get_canonical_hash(0).value(); const silkworm::Hash header1_hash{0x7cb4dd3daba1f739d0c1ec7d998b4a2f6fd83019116455afa54ca4f49dfa0ad4_bytes32}; auto const current_head_id = exec_engine.last_finalized_block(); auto const current_head = exec_engine.get_header(current_head_id.block_num, current_head_id.hash).value(); SECTION("get_block_num") { auto block_num = exec_engine.get_block_num(header1_hash); REQUIRE(block_num.has_value()); CHECK(*block_num == 1); } SECTION("get_header by hash") { auto db_block_num = silkworm::read_block_num(tx, header1_hash); silkworm::Block db_block; auto db_read = silkworm::read_block(tx, header1_hash, *db_block_num, db_block); REQUIRE(db_read); auto header1 = exec_engine.get_header(header1_hash); REQUIRE(header1.has_value()); CHECK(header1->hash() == db_block.header.hash()); CHECK(header1->number == 1); } SECTION("get_header by hash not found") { const silkworm::Hash header_not_found_hash{0x00000000000000000000000000000000000000000000000000000000deadbeef_bytes32}; auto db_block_num = silkworm::read_block_num(tx, header_not_found_hash); silkworm::Block db_block; auto db_read = silkworm::read_block(tx, header_not_found_hash, *db_block_num, db_block); REQUIRE(!db_read); auto header = exec_engine.get_header(header_not_found_hash); REQUIRE(!header.has_value()); } SECTION("get_header by number") { auto header1 = exec_engine.get_header(1, header1_hash); REQUIRE(header1.has_value()); CHECK(header1->hash() == header1_hash); CHECK(header1->number == 1); } SECTION("get_body by hash") { auto body = exec_engine.get_body(header1_hash); REQUIRE(body.has_value()); CHECK(body->transactions.size() == 1); } SECTION("get_last_headers shows numbers from the head down") { auto headers = exec_engine.get_last_headers(2); REQUIRE(headers.size() == 2); CHECK(headers[0].number == 9); CHECK(headers[1].number == 8); } SECTION("get_header_td returns correct total difficulty for genesis block") { auto td = exec_engine.get_header_td(header0_hash, std::nullopt); REQUIRE(td.has_value()); CHECK(*td == 1); } SECTION("last blocks points to head block") { auto block_progress = exec_engine.block_progress(); CHECK(block_progress == 9); auto last_fork_choice = exec_engine.last_fork_choice(); CHECK(last_fork_choice.block_num == 9); auto last_finalized_block = exec_engine.last_finalized_block(); CHECK(last_finalized_block.block_num == 9); auto last_safe_block = exec_engine.last_safe_block(); CHECK(last_safe_block.block_num == 0); } SECTION("insert_block does not update the head block and fork choice") { auto new_block = generate_sample_child_blocks(current_head); auto current_progress = exec_engine.block_progress(); CHECK(current_progress == 9); auto current_fork_choice = exec_engine.last_fork_choice(); CHECK(current_fork_choice == current_head_id); exec_engine.insert_block(new_block); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id == current_head_id); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice == current_head_id); } SECTION("insert_block with invalid block doesn't create valid chain") { auto new_block = std::make_shared(); new_block->header.number = current_head.number + 1; new_block->header.difficulty = 17'171'480'576; // a random value new_block->header.parent_hash = current_head.hash(); new_block->ommers.push_back(BlockHeader{}); // generates error InvalidOmmerHeader auto new_block_hash = new_block->header.hash(); auto block_inserted = exec_engine.insert_block(new_block); REQUIRE(block_inserted); auto is_canonical = exec_engine.is_canonical(new_block_hash); CHECK(!is_canonical); auto verification = runner.run(exec_engine.verify_chain(new_block_hash)); CHECK(!holds_alternative(verification)); REQUIRE(holds_alternative(verification)); auto invalid_chain = std::get(verification); CHECK(invalid_chain.unwind_point == current_head_id); CHECK(invalid_chain.bad_block.has_value()); CHECK(invalid_chain.bad_block.value() == new_block_hash); CHECK(invalid_chain.bad_headers.size() == 1); } // Test scenario: // c7 -> c8 -> c9 -> f1 -> f2 -> f3 SECTION("insert_blocks with valid blocks creates valid chain for each block") { auto block1 = generate_sample_child_blocks(current_head); auto block2 = generate_sample_child_blocks(block1->header); auto block3 = generate_sample_child_blocks(block2->header); auto blocks = std::vector>{block1, block2, block3}; exec_engine.insert_blocks(blocks); auto block1_hash = block1->header.hash(); auto block2_hash = block2->header.hash(); auto block3_hash = block3->header.hash(); auto is_canonical1 = exec_engine.is_canonical(block1_hash); CHECK(!is_canonical1); auto is_canonical2 = exec_engine.is_canonical(block2_hash); CHECK(!is_canonical2); auto is_canonical3 = exec_engine.is_canonical(block3_hash); CHECK(!is_canonical3); auto verification1 = runner.run(exec_engine.verify_chain(block1_hash)); CHECK(!holds_alternative(verification1)); REQUIRE(holds_alternative(verification1)); auto valid_chain1 = std::get(verification1); CHECK(valid_chain1.current_head == BlockId{10, block1_hash}); auto verification2 = runner.run(exec_engine.verify_chain(block2_hash)); CHECK(!holds_alternative(verification2)); REQUIRE(holds_alternative(verification2)); auto valid_chain2 = std::get(verification2); CHECK(valid_chain2.current_head == BlockId{11, block2_hash}); auto verification3 = runner.run(exec_engine.verify_chain(block3_hash)); CHECK(!holds_alternative(verification3)); REQUIRE(holds_alternative(verification3)); auto valid_chain3 = std::get(verification3); CHECK(valid_chain3.current_head == BlockId{12, block3_hash}); } SECTION("get_header for non-canonical blocks") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); // canonical auto header1 = exec_engine.get_header(header1_hash); REQUIRE(header1.has_value()); CHECK(header1->hash() == header1_hash); CHECK(header1->number == 1); header1 = exec_engine.get_header(1, header1_hash); REQUIRE(header1.has_value()); CHECK(header1->hash() == header1_hash); CHECK(header1->number == 1); // non-canonical auto header10 = exec_engine.get_header(new_block_hash); REQUIRE(header10.has_value()); CHECK(header10->hash() == new_block_hash); CHECK(header10->number == 10); header10 = exec_engine.get_header(10, new_block_hash); REQUIRE(header10.has_value()); CHECK(header10->hash() == new_block_hash); CHECK(header10->number == 10); } SECTION("get_body for non-canonical blocks") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); // canonical auto body1 = exec_engine.get_body(header1_hash); REQUIRE(body1.has_value()); // non-canonical auto body10 = exec_engine.get_body(new_block_hash); REQUIRE(body1.has_value()); } SECTION("get_block_num for non-canonical blocks") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); // canonical auto block_num1 = exec_engine.get_block_num(header1_hash); REQUIRE(block_num1.has_value()); CHECK(*block_num1 == 1); // non-canonical auto block_num10 = exec_engine.get_block_num(new_block_hash); REQUIRE(block_num10.has_value()); CHECK(*block_num10 == 10); } SECTION("get_canonical_* functions returns value only for canonical blocks") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); // get_canonical_header() auto header1 = exec_engine.get_canonical_header(1); REQUIRE(header1.has_value()); CHECK(header1->hash() == header1_hash); CHECK(header1->number == 1); auto header10 = exec_engine.get_canonical_header(10); REQUIRE(!header10.has_value()); // get_canonical_hash() auto hash1 = exec_engine.get_canonical_hash(1); REQUIRE(hash1.has_value()); CHECK(*hash1 == header1_hash); auto hash10 = exec_engine.get_canonical_hash(10); REQUIRE(!hash10.has_value()); // get_canonical_body() auto body1 = exec_engine.get_canonical_body(1); REQUIRE(body1.has_value()); auto body10 = exec_engine.get_canonical_body(10); REQUIRE(!body10.has_value()); // is_canonical() auto is_canonical1 = exec_engine.is_canonical(header1_hash); CHECK(is_canonical1); auto is_canonical10 = exec_engine.is_canonical(new_block_hash); CHECK(!is_canonical10); } SECTION("notify_fork_choice_update single block without prior verification") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); auto fcu_updated = exec_engine.notify_fork_choice_update(new_block_hash, {}, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); auto is_new_block_canonical = exec_engine.is_canonical(new_block_hash); CHECK(is_new_block_canonical); } SECTION("notify_fork_choice_update single block with prior verification") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); auto verification = runner.run(exec_engine.verify_chain(new_block_hash)); REQUIRE(holds_alternative(verification)); auto fcu_updated = exec_engine.notify_fork_choice_update(new_block_hash, {}, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); auto is_new_block_canonical = exec_engine.is_canonical(new_block_hash); CHECK(is_new_block_canonical); } SECTION("notify_fork_choice_update single block updates last_finalized_block and last_safe_block") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); auto fcu_updated = exec_engine.notify_fork_choice_update(new_block_hash, current_head_id.hash, current_head_id.hash); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); auto new_safe_block = exec_engine.last_safe_block(); CHECK(new_safe_block.block_num == 9); } SECTION("notify_fork_choice_update with multiple blocks using the first block as the head") { auto block1 = generate_sample_child_blocks(current_head); auto block2 = generate_sample_child_blocks(block1->header); auto block3 = generate_sample_child_blocks(block2->header); auto blocks = std::vector>{block1, block2, block3}; exec_engine.insert_blocks(blocks); auto block1_hash = block1->header.hash(); auto block2_hash = block2->header.hash(); auto block3_hash = block3->header.hash(); runner.run(exec_engine.verify_chain(block1_hash)); runner.run(exec_engine.verify_chain(block2_hash)); runner.run(exec_engine.verify_chain(block3_hash)); auto fcu_updated = exec_engine.notify_fork_choice_update(block1_hash, {}, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 12); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); auto is_block1_canonical = exec_engine.is_canonical(block1_hash); CHECK(is_block1_canonical); auto is_block2_canonical = exec_engine.is_canonical(block2_hash); CHECK(!is_block2_canonical); auto is_block3_canonical = exec_engine.is_canonical(block3_hash); CHECK(!is_block3_canonical); } SECTION("notify_fork_choice_update with multiple blocks using the last block as the head") { auto block1 = generate_sample_child_blocks(current_head); auto block2 = generate_sample_child_blocks(block1->header); auto block3 = generate_sample_child_blocks(block2->header); auto blocks = std::vector>{block1, block2, block3}; exec_engine.insert_blocks(blocks); auto block1_hash = block1->header.hash(); auto block2_hash = block2->header.hash(); auto block3_hash = block3->header.hash(); runner.run(exec_engine.verify_chain(block1_hash)); runner.run(exec_engine.verify_chain(block2_hash)); runner.run(exec_engine.verify_chain(block3_hash)); auto fcu_updated = exec_engine.notify_fork_choice_update(block3_hash, {}, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 12); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 12); auto is_block1_canonical = exec_engine.is_canonical(block1_hash); CHECK(is_block1_canonical); auto is_block2_canonical = exec_engine.is_canonical(block2_hash); CHECK(is_block2_canonical); auto is_block3_canonical = exec_engine.is_canonical(block3_hash); CHECK(is_block3_canonical); } SECTION("notify_fork_choice_update consecutive calls with the same block") { auto new_block = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block); auto new_block_hash = new_block->header.hash(); auto fcu_updated = exec_engine.notify_fork_choice_update(new_block_hash, {}, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); auto is_new_block_canonical = exec_engine.is_canonical(new_block_hash); CHECK(is_new_block_canonical); fcu_updated = exec_engine.notify_fork_choice_update(new_block_hash, {}, {}); CHECK(fcu_updated); //! updates despite the same block new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); } SECTION("notify_fork_choice_update consecutive calls with different blocks") { auto new_block1 = generate_sample_child_blocks(current_head); exec_engine.insert_block(new_block1); auto new_block1_hash = new_block1->header.hash(); auto fcu_updated = exec_engine.notify_fork_choice_update(new_block1_hash, {}, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); auto is_new_block1_canonical = exec_engine.is_canonical(new_block1_hash); CHECK(is_new_block1_canonical); auto new_block1_header = exec_engine.get_header(10, new_block1_hash); REQUIRE(new_block1_header.has_value()); auto new_block2 = generate_sample_child_blocks(*new_block1_header); exec_engine.insert_block(new_block2); auto new_block2_hash = new_block2->header.hash(); fcu_updated = exec_engine.notify_fork_choice_update(new_block2_hash, {}, {}); CHECK(fcu_updated); new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); new_progress = exec_engine.block_progress(); CHECK(new_progress == 11); new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 11); auto is_new_block2_canonical = exec_engine.is_canonical(new_block2_hash); CHECK(is_new_block2_canonical); } // Test scenario: // ↗ f1a -> f1b (fork 1) => fcu // c7 -> c8 -> c9 // ↘ f2a -> f2b (fork 2) SECTION("creates and verifies two forks, chooses first") { auto block1a = generate_sample_child_blocks(current_head); block1a->header.difficulty = 17'171'480'576; // a random value auto block1b = generate_sample_child_blocks(block1a->header); auto block2a = generate_sample_child_blocks(current_head); block2a->header.difficulty = 17'171'480'577; // a random value auto block2b = generate_sample_child_blocks(block2a->header); auto blocks = std::vector>{block1a, block1b, block2a, block2b}; exec_engine.insert_blocks(blocks); auto block1a_hash = block1a->header.hash(); auto block1b_hash = block1b->header.hash(); auto block2a_hash = block2a->header.hash(); auto block2b_hash = block2b->header.hash(); auto verification1 = runner.run(exec_engine.verify_chain(block1b_hash)); CHECK(!holds_alternative(verification1)); REQUIRE(holds_alternative(verification1)); auto verification2 = runner.run(exec_engine.verify_chain(block2b_hash)); CHECK(!holds_alternative(verification2)); REQUIRE(holds_alternative(verification2)); auto fcu_updated = exec_engine.notify_fork_choice_update(block1b_hash, current_head_id.hash, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 11); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 11); auto is_block1_canonical = exec_engine.is_canonical(block1a_hash); CHECK(is_block1_canonical); auto is_block2_canonical = exec_engine.is_canonical(block1b_hash); CHECK(is_block2_canonical); auto is_block3_canonical = exec_engine.is_canonical(block2a_hash); CHECK(!is_block3_canonical); auto is_block4_canonical = exec_engine.is_canonical(block2b_hash); CHECK(!is_block4_canonical); } // Test scenario: // ↗ f1 (10) => fcu // c7 -> c8 -> c9 // ↘ f2 (10) SECTION("creates and verifies two single-block forks, chooses first") { auto block_f1 = generate_sample_child_blocks(current_head); block_f1->header.difficulty = 17'171'480'576; // a random value auto block_f2 = generate_sample_child_blocks(current_head); block_f2->header.difficulty = 17'171'480'577; // a random value auto blocks = std::vector>{block_f1, block_f2}; exec_engine.insert_blocks(blocks); auto block_f1_hash = block_f1->header.hash(); auto block_f2_hash = block_f2->header.hash(); INFO(to_hex(block_f1_hash.bytes)); auto verification1 = runner.run(exec_engine.verify_chain(block_f1_hash)); CHECK(!holds_alternative(verification1)); REQUIRE(holds_alternative(verification1)); auto verification2 = runner.run(exec_engine.verify_chain(block_f2_hash)); CHECK(!holds_alternative(verification2)); REQUIRE(holds_alternative(verification2)); auto fcu_updated = exec_engine.notify_fork_choice_update(block_f1_hash, current_head_id.hash, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 10); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 10); auto is_block1_canonical = exec_engine.is_canonical(block_f1_hash); CHECK(is_block1_canonical); auto is_block3_canonical = exec_engine.is_canonical(block_f2_hash); CHECK(!is_block3_canonical); } // Test scenario: // ↗ f1a (10) -> f1b (11) (fork 1) // c7 -> c8 -> c9 // ↘ f2a (10) -> f2b (11) (fork 2) => fcu SECTION("creates and verifies two forks, chooses second") { auto block1a = generate_sample_child_blocks(current_head); block1a->header.difficulty = 17'171'480'576; // a random value auto block1b = generate_sample_child_blocks(block1a->header); auto block2a = generate_sample_child_blocks(current_head); block2a->header.difficulty = 17'171'480'577; // a random value auto block2b = generate_sample_child_blocks(block2a->header); auto blocks = std::vector>{block1a, block1b, block2a, block2b}; exec_engine.insert_blocks(blocks); auto block1a_hash = block1a->header.hash(); auto block1b_hash = block1b->header.hash(); auto block2a_hash = block2a->header.hash(); auto block2b_hash = block2b->header.hash(); auto verification1 = runner.run(exec_engine.verify_chain(block1b_hash)); CHECK(!holds_alternative(verification1)); REQUIRE(holds_alternative(verification1)); auto verification2 = runner.run(exec_engine.verify_chain(block2b_hash)); CHECK(!holds_alternative(verification2)); REQUIRE(holds_alternative(verification2)); auto fcu_updated = exec_engine.notify_fork_choice_update(block2b_hash, current_head_id.hash, {}); CHECK(fcu_updated); auto new_head_id = exec_engine.last_finalized_block(); CHECK(new_head_id.block_num == 9); auto new_progress = exec_engine.block_progress(); CHECK(new_progress == 11); auto new_fork_choice = exec_engine.last_fork_choice(); CHECK(new_fork_choice.block_num == 11); auto is_block1_canonical = exec_engine.is_canonical(block1a_hash); CHECK(!is_block1_canonical); auto is_block2_canonical = exec_engine.is_canonical(block1b_hash); CHECK(!is_block2_canonical); auto is_block3_canonical = exec_engine.is_canonical(block2a_hash); CHECK(is_block3_canonical); auto is_block4_canonical = exec_engine.is_canonical(block2b_hash); CHECK(is_block4_canonical); } // Test scenario: // c7 -> c8 -> c9 -> f1 -> f2 SECTION("insert_blocks updates chain database") { auto block1 = generate_sample_child_blocks(current_head); auto block2 = generate_sample_child_blocks(block1->header); auto block1_hash = block1->header.hash(); auto block2_hash = block2->header.hash(); CHECK(!read_block_num(tx, block1_hash).has_value()); CHECK(!read_block_num(tx, block2_hash).has_value()); auto blocks = std::vector>{block1, block2}; exec_engine.insert_blocks(blocks); CHECK(read_block_num(tx, block1_hash).has_value()); CHECK(read_block_num(tx, block2_hash).has_value()); tx.commit_and_renew(); // exec_engine.insert_blocks() automatically commits every 1000 blocks exec_engine.close(); auto tx2 = db_access.start_ro_tx(); CHECK(read_block_num(tx2, block1_hash).has_value()); CHECK(read_block_num(tx2, block2_hash).has_value()); } SECTION("verify_chain updates chain database") { auto block1 = generate_sample_child_blocks(current_head); auto block2 = generate_sample_child_blocks(block1->header); auto block1_hash = block1->header.hash(); auto block2_hash = block2->header.hash(); CHECK(!read_block_num(tx, block1_hash).has_value()); CHECK(!read_block_num(tx, block2_hash).has_value()); auto blocks = std::vector>{block1, block2}; exec_engine.insert_blocks(blocks); runner.run(exec_engine.verify_chain(block2_hash)); CHECK(read_block_num(tx, block1_hash).has_value()); CHECK(read_block_num(tx, block2_hash).has_value()); exec_engine.close(); auto tx2 = db_access.start_ro_tx(); CHECK(read_block_num(tx2, block1_hash).has_value()); CHECK(read_block_num(tx2, block2_hash).has_value()); tx2.abort(); } SECTION("notify_fork_choice_update does not update chain database") { auto block1 = generate_sample_child_blocks(current_head); auto block2 = generate_sample_child_blocks(block1->header); auto block1_hash = block1->header.hash(); auto block2_hash = block2->header.hash(); CHECK(!read_block_num(tx, block1_hash).has_value()); CHECK(!read_block_num(tx, block2_hash).has_value()); auto blocks = std::vector>{block1, block2}; exec_engine.insert_blocks(blocks); runner.run(exec_engine.verify_chain(block2_hash)); exec_engine.notify_fork_choice_update(block2_hash, current_head_id.hash, {}); CHECK(read_block_num(tx, block1_hash).has_value()); CHECK(read_block_num(tx, block2_hash).has_value()); exec_engine.close(); auto tx2 = db_access.start_ro_tx(); CHECK(read_block_num(tx2, block1_hash).has_value()); CHECK(read_block_num(tx2, block2_hash).has_value()); tx2.abort(); } // TODO: temporarily disabled, to be fixed (JG) // SECTION("updates storage") { // static constexpr evmc::address kSender{0xb685342b8c54347aad148e1f22eff3eb3eb29391_address}; // auto block1 = generate_sample_child_blocks(current_head); // // This contract initially sets its 0th storage to 0x2a and its 1st storage to 0x01c9. // // When called, it updates its 0th storage to the input provided. // Bytes contract_code{*from_hex("600035600055")}; // Bytes deployment_code{*from_hex("602a6000556101c960015560068060166000396000f3") + contract_code}; // block1->transactions.resize(1); // block1->transactions[0].chain_id = node_settings.chain_config->chain_id; // block1->transactions[0].data = deployment_code; // block1->transactions[0].gas_limit = block1->header.gas_limit; // block1->transactions[0].type = TransactionType::kDynamicFee; // block1->transactions[0].max_priority_fee_per_gas = 0; // block1->transactions[0].max_fee_per_gas = 20 * kGiga; // block1->transactions[0].r = 1; // dummy // block1->transactions[0].s = 1; // dummy // block1->transactions[0].set_sender(kSender); // // block1->transactions[0]. // auto block1_hash = block1->header.hash(); // auto block_inserted = exec_engine.insert_block(block1); // REQUIRE(block_inserted); // auto verification1 = exec_engine.verify_chain(block1_hash).get(); // REQUIRE(holds_alternative(verification1)); // auto fcu_successful = exec_engine.notify_fork_choice_update(block1_hash, current_head_id.hash, {}); // REQUIRE(fcu_successful); // auto contract_address{silkworm::create_address(kSender, /*nonce=*/0)}; // auto contract = read_account(tx, contract_address); // REQUIRE(contract.has_value()); // evmc::bytes32 storage_key0{}; // auto storage_value0 = read_storage(tx, contract_address, silkworm::kDefaultIncarnation, storage_key0); // CHECK(silkworm::to_hex(storage_value0) == "000000000000000000000000000000000000000000000000000000000000002a"); // evmc::bytes32 storage_key1{to_bytes32(*from_hex("01"))}; // auto storage_value1 = read_storage(tx, contract_address, silkworm::kDefaultIncarnation, storage_key1); // CHECK(silkworm::to_hex(storage_value1) == "00000000000000000000000000000000000000000000000000000000000001c9"); // } } TEST_CASE("ExecutionEngine") { TaskRunner runner; db::test_util::TempChainDataStore context; context.add_genesis_data(); context.commit_txn(); db::DataModelFactory data_model_factory = context.data_model_factory(); Environment::set_stop_before_stage(stages::kSendersKey); // only headers, block hashes and bodies NodeSettings node_settings = node::test_util::make_node_settings_from_temp_chain_data(context); ExecutionEngineForTest exec_engine{ runner.executor(), node_settings, data_model_factory, /* log_timer_factory = */ std::nullopt, make_stages_factory(node_settings, data_model_factory), context.chaindata_rw(), }; exec_engine.open(); auto& tx = exec_engine.main_chain().tx(); // mdbx refuses to open a ROTxn when there is a RWTxn in the same thread auto header0_hash = read_canonical_header_hash(tx, 0); REQUIRE(header0_hash.has_value()); auto header0 = read_canonical_header(tx, 0); REQUIRE(header0.has_value()); BlockId block0_id{0, *header0_hash}; // check db BlockBody block0_body; const bool block0_present = read_body(tx, *header0_hash, block0_id.block_num, block0_body); CHECK(block0_present); /* status: * h0 * input: * h0 <----- h1 */ SECTION("one invalid body after the genesis") { auto block1 = std::make_shared(); block1->header.number = 1; block1->header.difficulty = 17'171'480'576; // a random value block1->header.parent_hash = *header0_hash; // auto header1_hash = block1.header.hash(); block1->ommers.push_back(BlockHeader{}); // generate error InvalidOmmerHeader auto header1_hash = block1->header.hash(); // getting initial status auto initial_progress = exec_engine.block_progress(); CHECK(initial_progress == 0); auto last_fcu_at_start_time = exec_engine.last_fork_choice(); CHECK(last_fcu_at_start_time == block0_id); // inserting headers & bodies exec_engine.insert_block(block1); // check db BlockBody saved_body; const bool block1_present = read_body(tx, header1_hash, block1->header.number, saved_body); CHECK(block1_present); auto progress = exec_engine.block_progress(); CHECK(progress == 1); // verifying the chain auto verification = runner.run(exec_engine.verify_chain(header1_hash)); CHECK(stages::read_stage_progress(tx, stages::kHeadersKey) == 1); CHECK(stages::read_stage_progress(tx, stages::kBlockHashesKey) == 1); CHECK(stages::read_stage_progress(tx, stages::kBlockBodiesKey) == 1); CHECK(stages::read_stage_progress(tx, stages::kSendersKey) == 0); CHECK(stages::read_stage_progress(tx, stages::kExecutionKey) == 0); CHECK(!holds_alternative(verification)); REQUIRE(holds_alternative(verification)); auto invalid_chain = std::get(verification); CHECK(invalid_chain.unwind_point == BlockId{0, *header0_hash}); CHECK(invalid_chain.bad_block.has_value()); CHECK(invalid_chain.bad_block.value() == header1_hash); CHECK(invalid_chain.bad_headers.size() == 1); CHECK(*(invalid_chain.bad_headers.begin()) == header1_hash); // check status auto final_progress = exec_engine.block_progress(); CHECK(final_progress == block1->header.number); CHECK(exec_engine.last_fork_choice() == last_fcu_at_start_time); // not changed auto present_in_canonical = exec_engine.is_canonical(header1_hash); CHECK(!present_in_canonical); // reverting the chain bool updated = exec_engine.notify_fork_choice_update(*header0_hash, {}, {}); CHECK(updated); CHECK(exec_engine.last_fork_choice() == last_fcu_at_start_time); // not changed present_in_canonical = exec_engine.is_canonical(header1_hash); CHECK(!present_in_canonical); } SECTION("one valid body after the genesis") { std::string raw_header1 = "f90211a0d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3a01dcc4de8dec75d7aab85b567b6ccd41a" "d312451b948a7413f0a142fd40d493479405a56e2d52c817161883f50c441c3228cfe54d9fa0d67e4d450343046425ae4271474353" "857ab860dbc0a1dde64b41b5cd3a532bf3a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e8" "1f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000008503ff80000001821388808455ba422499476574682f76312e302e302f" "6c696e75782f676f312e342e32a0969b900de27b6ac6a67742365dd65f55a0526c41fd18e1b16f1a1215c2e66f5988539bd4979fef" "1ec4"; std::optional encoded_header1 = from_hex(raw_header1); auto block1 = std::make_shared(); ByteView encoded_view = encoded_header1.value(); auto decoding_result = rlp::decode(encoded_view, block1->header); // Note: block1 has zero transactions and zero ommers on mainnet REQUIRE(decoding_result); auto block1_hash = block1->header.hash(); BlockId block1_id{1, block1_hash}; // getting initial status auto initial_progress = exec_engine.block_progress(); CHECK(initial_progress == 0); auto last_fcu_at_start_time = exec_engine.last_fork_choice(); CHECK(last_fcu_at_start_time == block0_id); // inserting & verifying the block exec_engine.insert_block(block1); auto verification = runner.run(exec_engine.verify_chain(block1_hash)); REQUIRE(holds_alternative(verification)); auto valid_chain = std::get(verification); CHECK(valid_chain.current_head == block1_id); // check status auto final_progress = exec_engine.block_progress(); CHECK(final_progress == block1->header.number); CHECK(exec_engine.last_fork_choice() == last_fcu_at_start_time); // not changed // check db content BlockBody saved_body; bool present = read_body(tx, block1_hash, block1->header.number, saved_body); CHECK(present); auto present_in_canonical = exec_engine.is_canonical(block1_hash); CHECK(!present_in_canonical); // the current head is not yet accepted // confirming the chain exec_engine.notify_fork_choice_update(block1_hash, header0_hash, {}); // checking the status CHECK(exec_engine.last_fork_choice() == block1_id); CHECK(exec_engine.last_finalized_block() == block0_id); present_in_canonical = exec_engine.is_canonical(block1_hash); CHECK(present_in_canonical); } SECTION("a block that creates a fork") { auto block1 = generate_sample_child_blocks(*header0); auto block1_hash = block1->header.hash(); auto block2 = generate_sample_child_blocks(block1->header); auto block2_hash = block2->header.hash(); auto block3 = generate_sample_child_blocks(block2->header); auto block3_hash = block3->header.hash(); // inserting & verifying the block exec_engine.insert_block(block1); exec_engine.insert_block(block2); exec_engine.insert_block(block3); auto verification = runner.run(exec_engine.verify_chain(block3_hash)); REQUIRE(holds_alternative(verification)); auto valid_chain = std::get(verification); CHECK(valid_chain.current_head == BlockId{3, block3_hash}); // confirming the chain auto fcu_updated = exec_engine.notify_fork_choice_update(block3_hash, block1_hash, {}); CHECK(fcu_updated); CHECK(exec_engine.last_fork_choice() == BlockId{3, block3_hash}); CHECK(exec_engine.last_finalized_block() == BlockId{1, block1_hash}); CHECK(exec_engine.get_canonical_hash(2) == block2_hash); CHECK(exec_engine.get_canonical_header(2).has_value()); CHECK(exec_engine.get_canonical_hash(3) == block3_hash); CHECK(exec_engine.get_canonical_header(3).has_value()); auto [head_block_num, head_hash] = read_canonical_head(tx); CHECK(head_block_num == 3); CHECK(head_hash == block3_hash); // creating and reintegrating a fork auto block4 = generate_sample_child_blocks(block3->header); auto block4_hash = block4->header.hash(); { // inserting & verifying the block exec_engine.insert_block(block4); verification = runner.run(exec_engine.verify_chain(block4_hash)); REQUIRE(holds_alternative(verification)); valid_chain = std::get(verification); CHECK(valid_chain.current_head == BlockId{4, block4_hash}); // confirming the chain (i.e. flushing the memory mutation on the main db) fcu_updated = exec_engine.notify_fork_choice_update(block4_hash, block1_hash, {}); CHECK(fcu_updated); CHECK(exec_engine.last_fork_choice() == BlockId{4, block4_hash}); CHECK(exec_engine.last_finalized_block() == BlockId{1, block1_hash}); CHECK(exec_engine.get_canonical_hash(2) == block2_hash); CHECK(exec_engine.get_canonical_header(2).has_value()); CHECK(exec_engine.get_canonical_hash(3) == block3_hash); CHECK(exec_engine.get_canonical_header(3).has_value()); CHECK(exec_engine.get_canonical_hash(4) == block4_hash); CHECK(exec_engine.get_canonical_header(4).has_value()); std::tie(head_block_num, head_hash) = read_canonical_head(tx); CHECK(head_block_num == 4); CHECK(head_hash == block4_hash); } // creating a fork and changing the head (trigger unwind) auto block2b = generate_sample_child_blocks(block1->header); block2b->header.extra_data = string_view_to_byte_view("I'm different"); // to make it different from block2 auto block2b_hash = block2b->header.hash(); { // inserting & verifying the block exec_engine.insert_block(block2b); verification = runner.run(exec_engine.verify_chain(block2b_hash)); REQUIRE(holds_alternative(verification)); valid_chain = std::get(verification); CHECK(valid_chain.current_head == BlockId{2, block2b_hash}); // confirming the chain fcu_updated = exec_engine.notify_fork_choice_update(block2b_hash, header0_hash, {}); CHECK(fcu_updated); CHECK(exec_engine.last_fork_choice() == BlockId{2, block2b_hash}); CHECK(exec_engine.last_finalized_block() == block0_id); CHECK(exec_engine.main_chain().last_chosen_head() == BlockId{2, block2b_hash}); CHECK(exec_engine.get_canonical_hash(2) == block2b_hash); CHECK(exec_engine.get_canonical_header(2).has_value()); CHECK_FALSE(exec_engine.get_canonical_header(3).has_value()); CHECK_FALSE(exec_engine.get_canonical_header(4).has_value()); std::tie(head_block_num, head_hash) = read_canonical_head(tx); CHECK(head_block_num == 2); CHECK(head_hash == block2b_hash); } CHECK(exec_engine.get_header(block2b_hash).has_value()); // we do not remove old blocks CHECK(exec_engine.get_header(block2_hash).has_value()); // we do not remove old blocks CHECK(exec_engine.get_header(block3_hash).has_value()); // we do not remove old blocks CHECK(exec_engine.get_header(block4_hash).has_value()); // we do not remove old blocks } } } // namespace silkworm ================================================ FILE: silkworm/node/stagedsync/execution_pipeline.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "execution_pipeline.hpp" #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db::stages; #if defined(NDEBUG) static const std::chrono::milliseconds kStageDurationThresholdForLog{10}; #else static const std::chrono::milliseconds kStageDurationThresholdForLog{0}; #endif static const ExecutionPipeline::StageNames kStagesForwardOrder{ kHeadersKey, kBlockHashesKey, kBlockBodiesKey, kSendersKey, kExecutionKey, kHashStateKey, kIntermediateHashesKey, kHistoryIndexKey, kLogIndexKey, kCallTracesKey, kTxLookupKey, kTriggersStageKey, kFinishKey, }; static const ExecutionPipeline::StageNames kStagesUnwindOrder{ kFinishKey, kTriggersStageKey, kTxLookupKey, kCallTracesKey, kLogIndexKey, kHistoryIndexKey, kHashStateKey, kIntermediateHashesKey, // Needs to happen after unwinding HashState kExecutionKey, kSendersKey, kBlockBodiesKey, kBlockHashesKey, kHeadersKey, }; ExecutionPipeline::StageNames ExecutionPipeline::stages_forward_order() { return kStagesForwardOrder; } ExecutionPipeline::StageNames ExecutionPipeline::stages_unwind_order() { return kStagesUnwindOrder; } ExecutionPipeline::ExecutionPipeline( db::DataModelFactory data_model_factory, std::optional log_timer_factory, const StageContainerFactory& stages_factory) : data_model_factory_{std::move(data_model_factory)}, log_timer_factory_{std::move(log_timer_factory)}, sync_context_{std::make_unique()}, stages_{stages_factory(*sync_context_)}, current_stage_{stages_.end()}, stages_forward_order_{kStagesForwardOrder}, stages_unwind_order_{kStagesUnwindOrder} {} BlockNum ExecutionPipeline::head_header_number() const { return head_header_block_num_; } Hash ExecutionPipeline::head_header_hash() const { return head_header_hash_; } std::optional ExecutionPipeline::unwind_point() { return sync_context_->unwind_point; } std::optional ExecutionPipeline::bad_block() { return sync_context_->bad_block_hash; } bool ExecutionPipeline::stop() { bool stopped{true}; for (const auto& [_, stage] : stages_) { if (!stage->is_stopping()) { stopped &= stage->stop(); } } return stopped; } datastore::StageScheduler& ExecutionPipeline::stage_scheduler() const { return *dynamic_cast(stages_.at(kTriggersStageKey).get()); } Stage::Result ExecutionPipeline::forward(db::RWTxn& cycle_txn, BlockNum target_block_num) { using std::to_string; StopWatch stages_stop_watch(true); auto log_timer = make_log_timer(); sync_context_->target_block_num = target_block_num; SILK_INFO_M("ExecutionPipeline") << "Forward start"; try { Stage::Result result = Stage::Result::kSuccess; // We'll check if we're forced to start/stop at any particular stage/block_num for debugging purposes auto start_stage_name{Environment::get_start_at_stage()}; const auto stop_stage_name{Environment::get_stop_before_stage()}; const auto stop_at_block = Environment::get_stop_at_block(); if (stop_at_block) { sync_context_->target_block_num = *stop_at_block; } current_stages_count_ = stages_forward_order_.size(); current_stage_number_ = 0; for (auto& stage_id : stages_forward_order_) { // retrieve current stage current_stage_ = stages_.find(stage_id); if (current_stage_ == stages_.end()) { throw std::runtime_error("Stage " + std::string(stage_id) + " requested but not implemented"); } ++current_stage_number_; const auto& current_stage_name = current_stage_->first; current_stage_->second->set_log_prefix(get_log_prefix(current_stage_name)); // Check if we have to start at specific stage due to environment variable if (start_stage_name) { // Stage is not the start one, skip it and continue if (start_stage_name != stage_id) { log::Info("Skipping " + std::string(stage_id) + "...", {"START_AT_STAGE", *start_stage_name, "hit", "true"}); continue; } // Start stage just found, avoid skipping next stages start_stage_name = std::nullopt; } // Check if we have to stop due to environment variable if (stop_stage_name && stop_stage_name == stage_id) { log::Warning("Stopping ...", {"STOP_BEFORE_STAGE", *stop_stage_name, "hit", "true"}); result = Stage::Result::kStoppedByEnv; break; } if (log_timer) { log_timer->reset(); // Resets the interval for next log line from now } // forward const auto stage_result = current_stage_->second->forward(cycle_txn); if (stage_result != Stage::Result::kSuccess) { /* clang-format off */ const auto result_description = std::string(magic_enum::enum_name(stage_result)); SILK_ERROR_M(get_log_prefix(current_stage_name), {"op", "Forward", "failure", result_description}); return stage_result; } /* clang-format on */ const auto stage_head_number = read_stage_progress(cycle_txn, current_stage_name.data()); if (!stop_at_block && stage_head_number != target_block_num) { SILK_ERROR_M(get_log_prefix(current_stage_name), {"op", "Forward", "target", to_string(target_block_num), "reached", to_string(stage_head_number)}); throw std::logic_error("stage returned success with an block_num different from target=" + to_string(target_block_num) + " reached=" + to_string(stage_head_number)); } const auto [_, stage_duration] = stages_stop_watch.lap(); if (stage_duration > kStageDurationThresholdForLog) { SILK_INFO_M(get_log_prefix(current_stage_name), {"op", "Forward", "done", StopWatch::format(stage_duration)}); } } db::DataModel data_model = data_model_factory_(cycle_txn); const auto [head_header, head_header_hash] = data_model.read_head_header_and_hash(); head_header_hash_ = head_header_hash.value_or(Hash{}); ensure(head_header.has_value(), [&]() { return "Sync pipeline, missing head header hash " + to_hex(head_header_hash_); }); head_header_block_num_ = head_header->number; if (!stop_at_block && head_header_block_num_ != target_block_num) { throw std::logic_error("Sync pipeline: head header not at target block_num " + to_string(target_block_num) + ", head_header_block_num= " + to_string(head_header_block_num_)); } SILK_INFO_M("ExecutionPipeline") << "Forward done"; if (stop_at_block && stop_at_block <= head_header_block_num_) { SILK_WARN_M("ExecutionPipeline") << "Interrupted by STOP_AT_BLOCK at block " + to_string(*stop_at_block); return Stage::Result::kStoppedByEnv; } return result; } catch (const std::exception& ex) { SILK_ERROR_M("ExecutionPipeline") << get_log_prefix("unknown") << " Forward exception " << ex.what(); return Stage::Result::kUnexpectedError; } } Stage::Result ExecutionPipeline::unwind(db::RWTxn& cycle_txn, BlockNum unwind_point) { using std::to_string; StopWatch stages_stop_watch(true); auto log_timer = make_log_timer(); SILK_INFO_M("ExecutionPipeline") << "Unwind start"; try { sync_context_->unwind_point = unwind_point; // Loop at stages in unwind order current_stages_count_ = stages_unwind_order_.size(); current_stage_number_ = 0; for (auto& stage_id : stages_unwind_order_) { current_stage_ = stages_.find(stage_id); if (current_stage_ == stages_.end()) { throw std::runtime_error("Stage " + std::string(stage_id) + " requested but not implemented"); } ++current_stage_number_; const auto& current_stage_name = current_stage_->first; current_stage_->second->set_log_prefix(get_log_prefix(current_stage_name)); if (log_timer) { log_timer->reset(); // Resets the interval for next log line from now } // Do unwind on current stage const auto stage_result = current_stage_->second->unwind(cycle_txn); if (stage_result != Stage::Result::kSuccess) { auto result_description = std::string(magic_enum::enum_name(stage_result)); log::Error(get_log_prefix(current_stage_name), {"op", "Unwind", "returned", result_description}); SILK_ERROR_M("ExecutionPipeline") << "Unwind interrupted due to stage " << current_stage_->first << " failure"; return stage_result; } // Log performances auto [_, stage_duration] = stages_stop_watch.lap(); if (stage_duration > kStageDurationThresholdForLog) { log::Info(get_log_prefix(current_stage_name), {"op", "Unwind", "done", StopWatch::format(stage_duration)}); } } db::DataModel data_model = data_model_factory_(cycle_txn); const auto [head_header, head_header_hash] = data_model.read_head_header_and_hash(); head_header_hash_ = head_header_hash.value_or(Hash{}); ensure(head_header.has_value(), [&]() { return "Sync pipeline, missing head header hash " + to_hex(head_header_hash_); }); head_header_block_num_ = head_header->number; if (head_header_block_num_ != unwind_point) { throw std::logic_error("Sync pipeline: head header not at unwind point " + to_string(unwind_point) + ", head_header_block_num=" + to_string(head_header_block_num_)); } // Clear context std::swap(sync_context_->unwind_point, sync_context_->previous_unwind_point); sync_context_->unwind_point.reset(); sync_context_->bad_block_hash.reset(); SILK_INFO_M("ExecutionPipeline") << "Unwind done"; return is_stopping() ? Stage::Result::kAborted : Stage::Result::kSuccess; } catch (const std::exception& ex) { SILK_ERROR_M("ExecutionPipeline") << get_log_prefix("unknown") << " Unwind exception " << ex.what(); return Stage::Result::kUnexpectedError; } } Stage::Result ExecutionPipeline::prune(db::RWTxn& cycle_txn) { StopWatch stages_stop_watch(true); auto log_timer = make_log_timer(); SILK_INFO_M("ExecutionPipeline") << "Prune start"; try { current_stages_count_ = stages_forward_order_.size(); current_stage_number_ = 0; for (auto& stage_id : stages_unwind_order_) { current_stage_ = stages_.find(stage_id); if (current_stage_ == stages_.end()) { // Should not happen throw std::runtime_error("Stage " + std::string(stage_id) + " requested but not implemented"); } ++current_stage_number_; const auto& current_stage_name = current_stage_->first; current_stage_->second->set_log_prefix(get_log_prefix(current_stage_name)); if (log_timer) { log_timer->reset(); // Resets the interval for next log line from now } const auto stage_result{current_stage_->second->prune(cycle_txn)}; if (stage_result != Stage::Result::kSuccess) { log::Error(get_log_prefix(current_stage_name), {"op", "Prune", "returned", std::string(magic_enum::enum_name(stage_result))}); SILK_ERROR_M("ExecutionPipeline") << "Prune interrupted due to stage " << current_stage_->first << " failure"; return stage_result; } auto [_, stage_duration] = stages_stop_watch.lap(); if (stage_duration > kStageDurationThresholdForLog) { log::Info(get_log_prefix(current_stage_name), {"op", "Prune", "done", StopWatch::format(stage_duration)}); } } db::DataModel data_model = data_model_factory_(cycle_txn); const auto [head_header, head_header_hash] = data_model.read_head_header_and_hash(); head_header_hash_ = head_header_hash.value_or(Hash{}); ensure(head_header.has_value(), [&]() { return "Sync pipeline, missing head header hash " + to_hex(head_header_hash_); }); head_header_block_num_ = head_header->number; SILK_INFO_M("ExecutionPipeline") << "Prune done"; return is_stopping() ? Stage::Result::kAborted : Stage::Result::kSuccess; } catch (const std::exception& ex) { SILK_ERROR_M("ExecutionPipeline") << get_log_prefix("unknown") << " Prune exception " << ex.what(); return Stage::Result::kUnexpectedError; } } std::string ExecutionPipeline::get_log_prefix(const std::string_view& stage_name) const { return absl::StrFormat("[%u/%u %s]", current_stage_number_, current_stages_count_, stage_name); } std::shared_ptr ExecutionPipeline::make_log_timer() { if (log_timer_factory_) { return log_timer_factory_.value()([this]() { return log_timer_expired(); }); } return {}; } bool ExecutionPipeline::log_timer_expired() { const auto current_stage_name = (current_stage_ != stages_.end()) ? current_stage_->first : "unknown"; if (is_stopping()) { log::Info(get_log_prefix(current_stage_name)) << "stopping ..."; return false; } log::Info(get_log_prefix(current_stage_name), current_stage_->second->get_log_progress()); return true; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/execution_pipeline.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "timer_factory.hpp" namespace silkworm::stagedsync { using StageContainer = std::map>; using StageContainerFactory = std::function; class ExecutionPipeline : public Stoppable { public: using StageNames = std::vector; static StageNames stages_forward_order(); static StageNames stages_unwind_order(); ExecutionPipeline( db::DataModelFactory data_model_factory, std::optional log_timer_factory, const StageContainerFactory& stages_factory); ~ExecutionPipeline() override = default; Stage::Result forward(db::RWTxn&, BlockNum target_block_num); Stage::Result unwind(db::RWTxn&, BlockNum unwind_point); Stage::Result prune(db::RWTxn&); BlockNum head_header_number() const; Hash head_header_hash() const; std::optional unwind_point(); std::optional bad_block(); bool stop() override; datastore::StageScheduler& stage_scheduler() const; private: db::DataModelFactory data_model_factory_; std::optional log_timer_factory_; std::unique_ptr sync_context_; // context shared across stages StageContainer stages_; StageContainer::iterator current_stage_; StageNames stages_forward_order_; StageNames stages_unwind_order_; std::atomic current_stages_count_{0}; std::atomic current_stage_number_{0}; BlockNum head_header_block_num_{0}; Hash head_header_hash_; // Returns the current log lines prefix on behalf of current stage std::string get_log_prefix(const std::string_view& stage_name) const; std::shared_ptr make_log_timer(); bool log_timer_expired(); }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/canonical_chain.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "canonical_chain.hpp" #include #include #include #include namespace silkworm::stagedsync { CanonicalChain::CanonicalChain( db::RWTxn& tx, db::DataModelFactory data_model_factory, size_t cache_size) : tx_{tx}, data_model_factory_{std::move(data_model_factory)}, canonical_hash_cache_{std::make_unique>(cache_size)} { open(); } CanonicalChain::CanonicalChain(const CanonicalChain& copy, db::RWTxn& new_tx) : tx_{new_tx}, data_model_factory_{copy.data_model_factory_}, initial_head_{copy.initial_head_}, current_head_{copy.current_head_}, canonical_hash_cache_{std::make_unique>(copy.canonical_hash_cache_->size())} { open(); } CanonicalChain::CanonicalChain(CanonicalChain&& orig) noexcept : tx_{orig.tx_}, data_model_factory_{std::move(orig.data_model_factory_)}, initial_head_{orig.initial_head_}, current_head_{orig.current_head_}, canonical_hash_cache_{std::move(orig.canonical_hash_cache_)} { open(); } void CanonicalChain::set_current_head(BlockId head) { current_head_ = head; canonical_hash_cache_->clear(); // invalidate cache } void CanonicalChain::open() { // Read head of canonical chain std::tie(initial_head_.block_num, initial_head_.hash) = db::read_canonical_head(tx_); // Set current status current_head_ = initial_head_; } BlockId CanonicalChain::initial_head() const { return initial_head_; } BlockId CanonicalChain::current_head() const { return current_head_; } bool CanonicalChain::cache_enabled() const { return canonical_hash_cache_->max_size() > 0; } BlockId CanonicalChain::find_forking_point(Hash header_hash) const { std::optional header = data_model().read_header(header_hash); if (!header) throw std::logic_error("find_forking_point precondition violation, header not found"); return find_forking_point(*header, header_hash); } BlockId CanonicalChain::find_forking_point(const BlockHeader& header, Hash header_hash) const { BlockId forking_point{}; if (header.number == 0) return forking_point; if (get_hash(header.number) == header_hash) return {header.number, header_hash}; BlockNum block_num = header.number; Hash parent_hash = header.parent_hash; // Most common case: forking point is the block_num of the parent header auto prev_canon_hash = get_hash(block_num - 1); if (prev_canon_hash == header.parent_hash) { forking_point = {block_num - 1, *prev_canon_hash}; } // Going further back else { auto parent = data_model().read_header(block_num - 1, parent_hash); ensure_invariant(parent.has_value(), [&]() { return "canonical chain could not find parent with hash " + to_hex(parent_hash) + " and block_num " + std::to_string(block_num - 1); }); auto ancestor_hash = parent->parent_hash; auto ancestor_block_num = block_num - 2; std::optional canon_hash; while ((canon_hash = get_hash(ancestor_block_num)).has_value() && (canon_hash != ancestor_hash)) { auto ancestor = data_model().read_header(ancestor_block_num, ancestor_hash); ancestor_hash = ancestor->parent_hash; --ancestor_block_num; } // loop above terminates when prev_canon_hash == ancestor_hash, therefore ancestor_block_num is our forking point forking_point = {ancestor_block_num, ancestor_hash}; } return forking_point; } void CanonicalChain::advance(BlockNum block_num, Hash header_hash) { ensure_invariant(current_head_.block_num == block_num - 1, [&]() { return std::string("canonical chain must advance gradually,") + " current head " + std::to_string(current_head_.block_num) + " expected head " + std::to_string(block_num - 1); }); db::write_canonical_hash(tx_, block_num, header_hash); if (cache_enabled()) canonical_hash_cache_->put(block_num, header_hash); current_head_.block_num = block_num; current_head_.hash = header_hash; } void CanonicalChain::update_up_to(BlockNum block_num, Hash hash) { // hash can be empty if (block_num == 0) return; auto ancestor_hash = hash; auto ancestor_block_num = block_num; std::optional persisted_canon_hash = db::read_canonical_header_hash(tx_, ancestor_block_num); // while (persisted_canon_hash != ancestor_hash) { // better but gcc12 release erroneously raises a maybe-uninitialized warn while (!persisted_canon_hash || std::memcmp(persisted_canon_hash.value().bytes, ancestor_hash.bytes, kHashLength) != 0) { db::write_canonical_hash(tx_, ancestor_block_num, ancestor_hash); if (cache_enabled()) canonical_hash_cache_->put(ancestor_block_num, ancestor_hash); auto ancestor = data_model().read_header(ancestor_block_num, ancestor_hash); ensure_invariant(ancestor.has_value(), [&]() { return "fix canonical chain failed at ancestor= " + std::to_string(ancestor_block_num) + " hash=" + ancestor_hash.to_hex(); }); ancestor_hash = ancestor->parent_hash; --ancestor_block_num; persisted_canon_hash = db::read_canonical_header_hash(tx_, ancestor_block_num); } current_head_.block_num = block_num; current_head_.hash = hash; } void CanonicalChain::delete_down_to(BlockNum unwind_point) { for (BlockNum current_block_num = current_head_.block_num; current_block_num > unwind_point; --current_block_num) { db::delete_canonical_hash(tx_, current_block_num); // do not throw if not found if (cache_enabled()) canonical_hash_cache_->remove(current_block_num); } current_head_.block_num = unwind_point; auto current_head_hash = db::read_canonical_header_hash(tx_, unwind_point); ensure_invariant(current_head_hash.has_value(), [&]() { return "hash not found on canonical at block_num " + std::to_string(unwind_point); }); current_head_.hash = *current_head_hash; if (initial_head_.block_num > current_head_.block_num) { initial_head_ = current_head_; // we went under the prev initial head } } std::optional CanonicalChain::get_hash(BlockNum block_num) const { auto canon_hash = canonical_hash_cache_->get_as_copy(block_num); // look in the cache first if (!canon_hash) { canon_hash = db::read_canonical_header_hash(tx_, block_num); // then look in the db if (canon_hash) canonical_hash_cache_->put(block_num, *canon_hash); // and cache it } return canon_hash; } bool CanonicalChain::has(Hash block_hash) const { auto header = data_model().read_header(block_hash); if (!header) return false; auto canonical_hash_at_same_block_num = get_hash(header->number); return canonical_hash_at_same_block_num == block_hash; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/canonical_chain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { class CanonicalChain { public: static constexpr size_t kNoCache = 0; explicit CanonicalChain( db::RWTxn& tx, db::DataModelFactory data_model_factory, size_t cache_size = kDefaultCacheSize); CanonicalChain(CanonicalChain&) = delete; // tx is not copyable CanonicalChain(const CanonicalChain&, db::RWTxn&); // we can copy a CanonicalChain giving a new tx CanonicalChain(CanonicalChain&&) noexcept; void open(); BlockId find_forking_point(Hash header_hash) const; BlockId find_forking_point(const BlockHeader& header, Hash header_hash) const; void advance(BlockNum block_num, Hash header_hash); void update_up_to(BlockNum block_num, Hash hash); void delete_down_to(BlockNum unwind_point); void set_current_head(BlockId); BlockId initial_head() const; BlockId current_head() const; std::optional get_hash(BlockNum block_num) const; bool has(Hash block_hash) const; private: db::DataModel data_model() const { return data_model_factory_(tx_); } db::RWTxn& tx_; db::DataModelFactory data_model_factory_; BlockId initial_head_{}; BlockId current_head_{}; static constexpr size_t kDefaultCacheSize = 1000; std::unique_ptr> canonical_hash_cache_; // uses unique_ptr because LruCache is not movable bool cache_enabled() const; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/extending_fork.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "extending_fork.hpp" #include #include "main_chain.hpp" namespace silkworm::stagedsync { using namespace boost::asio; static void ensure(bool condition, const std::string& message) { if (!condition) { throw std::logic_error("ExtendingFork condition violation: " + message); } } ExtendingFork::ExtendingFork( BlockId forking_point, MainChain& main_chain, any_io_executor external_executor) : forking_point_{forking_point}, main_chain_{main_chain}, external_executor_{std::move(external_executor)}, current_head_{forking_point} {} ExtendingFork::~ExtendingFork() { close(); } BlockId ExtendingFork::current_head() const { return current_head_; } void ExtendingFork::execution_loop() { if (!ioc_) return; executor_work_guardget_executor())> work{ioc_->get_executor()}; ioc_->run(); if (fork_) fork_->close(); // close the fork here, in the same thread where was created to comply to mdbx limitations } void ExtendingFork::start_with(BlockId new_head, std::list> blocks) { propagate_exception_if_any(); ioc_ = std::make_unique(); thread_ = std::thread{[this]() { execution_loop(); }}; current_head_ = new_head; // setting this here is important for find_fork_by_head() due to the fact that block // insertion and head computation is delayed but find_fork_by_head() is called immediately post(*ioc_, [this, new_head, blocks = std::move(blocks)]() { // note: this requires a "stable" this pointer try { if (exception_) return; // create the real fork fork_ = std::make_unique( forking_point_, datastore::kvdb::ROTxnManaged(main_chain_.tx().db()), main_chain_.data_model_factory(), main_chain_.log_timer_factory(), main_chain_.stages_factory(), main_chain_.node_settings().data_directory->forks().path()); fork_->extend_with(blocks); ensure(fork_->current_head() == new_head, "fork head mismatch"); } catch (...) { save_exception(std::current_exception()); } }); } void ExtendingFork::close() { propagate_exception_if_any(); if (ioc_) ioc_->stop(); if (thread_.joinable()) thread_.join(); } void ExtendingFork::extend_with(Hash head_hash, const Block& head) { propagate_exception_if_any(); current_head_ = {head.header.number, head_hash}; // setting this here is important, same as above post(*ioc_, [this, head]() { try { if (exception_) return; fork_->extend_with(head); } catch (...) { save_exception(std::current_exception()); } }); } ExtendingFork::VerificationResultFuture ExtendingFork::verify_chain() { using execution::api::VerificationResult; propagate_exception_if_any(); concurrency::AwaitablePromise promise{external_executor_}; // note: promise uses an external io_context auto awaitable_future = promise.get_future(); post(*ioc_, [this, promise = std::move(promise)]() mutable { try { if (exception_) return; auto result = fork_->verify_chain(); current_head_ = fork_->current_head(); promise.set_value(result); } catch (...) { save_exception(std::current_exception()); } }); return awaitable_future; } concurrency::AwaitableFuture ExtendingFork::fork_choice(Hash head_block_hash, std::optional finalized_block_hash, std::optional safe_block_hash) { propagate_exception_if_any(); concurrency::AwaitablePromise promise{external_executor_}; // note: promise uses an external io_context auto awaitable_future = promise.get_future(); post(*ioc_, [this, promise = std::move(promise), head_block_hash, finalized_block_hash, safe_block_hash]() mutable { try { if (exception_) return; auto updated = fork_->fork_choice(head_block_hash, finalized_block_hash, safe_block_hash); current_head_ = fork_->current_head(); promise.set_value(updated); } catch (...) { save_exception(std::current_exception()); } }); return awaitable_future; } ForkContainer::iterator find_fork_by_head(ForkContainer& forks, const Hash& requested_head_hash) { return std::find_if(forks.begin(), forks.end(), [&](const auto& fork) { return fork->current_head().hash == requested_head_hash; }); } ForkContainer::iterator find_fork_to_extend(ForkContainer& forks, const BlockHeader& header) { return find_fork_by_head(forks, header.parent_hash); } void ExtendingFork::save_exception(std::exception_ptr e) { exception_ = e; // save exception to rethrow it later } void ExtendingFork::propagate_exception_if_any() { if (exception_) { std::rethrow_exception(exception_); } } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/extending_fork.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "fork.hpp" namespace silkworm::stagedsync { // ExtendingFork is a composition of a Fork, an in-memory database and an io_context. // It executes the fork operations on the private io_context, so we can: // - parallelize operations on different forks to improve performances // - put operations on the same fork in sequence to avoid races // The in-memory database is used to store the forked blocks & states. class ExtendingFork { public: explicit ExtendingFork( BlockId forking_point, MainChain& main_chain, boost::asio::any_io_executor external_executor); ExtendingFork(const ExtendingFork&) = delete; ExtendingFork(ExtendingFork&& orig) = delete; // not movable, it schedules methods execution in another thread ~ExtendingFork(); // opening & closing void start_with(BlockId new_head, std::list> blocks); void close(); // extension void extend_with(Hash head_hash, const Block& head); // verification using VerificationResultFuture = concurrency::AwaitableFuture; VerificationResultFuture verify_chain(); concurrency::AwaitableFuture fork_choice(Hash head_block_hash, std::optional finalized_block_hash = {}, std::optional safe_block_hash = {}); // state BlockId current_head() const; protected: friend MainChain; void execution_loop(); void save_exception(std::exception_ptr); void propagate_exception_if_any(); // starting point BlockId forking_point_; MainChain& main_chain_; // for promises boost::asio::any_io_executor external_executor_; // for domain logic std::unique_ptr fork_; // for pipeline execution std::unique_ptr ioc_; // for executor std::thread thread_; // last exception std::exception_ptr exception_{}; // cached values provided to avoid thread synchronization BlockId current_head_{}; }; using ForkContainer = std::vector>; // find the fork with the specified head ForkContainer::iterator find_fork_by_head(ForkContainer& forks, const Hash& requested_head_hash); // find the fork with the head to extend ForkContainer::iterator find_fork_to_extend(ForkContainer& forks, const BlockHeader& header); } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/fork.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "fork.hpp" #include #include #include #include namespace silkworm::stagedsync { using execution::api::InvalidChain; using execution::api::ValidationError; using execution::api::ValidChain; using execution::api::VerificationResult; static datastore::kvdb::MemoryOverlay create_memory_db(const std::filesystem::path& base_path, db::ROTxn& main_tx) { datastore::kvdb::MemoryOverlay memory_overlay{ TemporaryDirectory::get_unique_temporary_path(base_path), &main_tx, db::table::get_map_config, db::table::kSequenceName, }; // Create predefined tables for chaindata schema auto txn = memory_overlay.start_rw_txn(); datastore::kvdb::RWTxnUnmanaged txn_ref{txn}; db::table::check_or_create_chaindata_tables(txn_ref); txn.commit(); return memory_overlay; } Fork::Fork( BlockId forking_point, datastore::kvdb::ROTxnManaged main_tx, db::DataModelFactory data_model_factory, std::optional log_timer_factory, const StageContainerFactory& stages_factory, const std::filesystem::path& forks_dir_path) : main_tx_{std::move(main_tx)}, memory_db_{create_memory_db(forks_dir_path, main_tx_)}, memory_tx_{memory_db_}, data_model_factory_{std::move(data_model_factory)}, pipeline_{ data_model_factory_, std::move(log_timer_factory), stages_factory, }, canonical_chain_{memory_tx_, data_model_factory_}, current_head_{forking_point} // actual head { // go down if needed if (canonical_chain_.initial_head() != forking_point) { reduce_down_to(forking_point); ensure_invariant(canonical_chain_.current_head() == forking_point, "forking point must be the current canonical head"); } } void Fork::close() { if (memory_tx_.is_open()) memory_tx_.abort(); } void Fork::flush(db::RWTxn& main_chain_tx) { memory_tx_.flush(main_chain_tx); } BlockId Fork::current_head() const { return current_head_; } BlockId Fork::finalized_head() const { return finalized_head_; } BlockId Fork::safe_head() const { return safe_head_; } std::optional Fork::head_status() const { return head_status_; } bool Fork::extends_head(const BlockHeader& header) const { return current_head().hash == header.parent_hash; } std::optional Fork::find_block(Hash header_hash) const { auto curr_block_num = current_head().block_num; while (curr_block_num > canonical_chain_.initial_head().block_num) { auto canonical_hash = canonical_chain_.get_hash(curr_block_num); ensure_invariant(canonical_hash.has_value(), "canonical chain must be complete"); if (canonical_hash == header_hash) { return curr_block_num; } --curr_block_num; } return std::nullopt; } std::optional Fork::find_attachment_point(const BlockHeader& header) const { auto parent_hash = header.parent_hash; if (parent_hash == current_head().hash) return current_head(); auto parent_num = find_block(parent_hash); if (!parent_num.has_value()) return std::nullopt; return BlockId{*parent_num, parent_hash}; } BlockNum Fork::distance_from_root(const BlockId& block) const { return block.block_num - canonical_chain_.initial_head().block_num; } Hash Fork::insert_header(const BlockHeader& header) { return db::write_header_ex(memory_tx_, header, /*with_header_numbers=*/false); // kHeaderNumbers table will be updated by stage blockhashes } void Fork::insert_body(const Block& block, const Hash& block_hash) { // avoid calculation of block.header.hash() because is computationally expensive BlockNum block_num = block.header.number; if (!data_model().has_body(block_num, block_hash)) { db::write_body(memory_tx_, block, block_hash, block_num); } } void Fork::extend_with(const std::list>& blocks) { for (auto const& block : blocks) { extend_with(*block); } } void Fork::extend_with(const Block& block) { ensure_invariant(extends_head(block.header), "inserting block must extend the head"); Hash header_hash = insert_header(block.header); insert_body(block, header_hash); canonical_chain_.advance(block.header.number, header_hash); current_head_ = {block.header.number, header_hash}; } void Fork::reduce_down_to(BlockId unwind_point) { ensure(unwind_point.block_num < canonical_chain_.current_head().block_num, "reducing down to a block above the fork head"); // we do not handle differently the case where unwind_point.number > last_verified_head_.number // assuming pipeline unwind can handle it correctly auto unwind_result = pipeline_.unwind(memory_tx_, unwind_point.block_num); success_or_throw(unwind_result); // unwind must complete with success ensure_invariant(pipeline_.head_header_number() == unwind_point.block_num && pipeline_.head_header_hash() == unwind_point.hash, "unwind succeeded with pipeline head not aligned with unwind point"); canonical_chain_.delete_down_to(unwind_point.block_num); // remove last part of canonical ensure_invariant(canonical_chain_.current_head().hash == unwind_point.hash, "canonical chain not updated to unwind point"); head_status_ = ValidChain{unwind_point}; current_head_ = unwind_point; } VerificationResult Fork::verify_chain() { SILK_TRACE << "Fork: verifying chain from head " << current_head_.hash.to_hex(); // db commit policy memory_tx_.disable_commit(); // forward Stage::Result forward_result = pipeline_.forward(memory_tx_, current_head_.block_num); // evaluate result VerificationResult verify_result; switch (forward_result) { case Stage::Result::kSuccess: { ensure_invariant(pipeline_.head_header_number() == canonical_chain_.current_head().block_num && pipeline_.head_header_hash() == canonical_chain_.current_head().hash, "forward succeeded with pipeline head not aligned with canonical head"); verify_result = ValidChain{pipeline_.head_header_number()}; break; } case Stage::Result::kWrongFork: case Stage::Result::kInvalidBlock: case Stage::Result::kWrongStateRoot: { ensure_invariant(pipeline_.unwind_point().has_value(), "unwind point from pipeline requested when forward fails"); InvalidChain invalid_chain; invalid_chain.unwind_point.block_num = *pipeline_.unwind_point(); invalid_chain.unwind_point.hash = *canonical_chain_.get_hash(*pipeline_.unwind_point()); if (pipeline_.bad_block()) { invalid_chain.bad_block = pipeline_.bad_block(); invalid_chain.bad_headers = collect_bad_headers(invalid_chain); } verify_result = invalid_chain; break; } case Stage::Result::kStoppedByEnv: verify_result = ValidChain{pipeline_.head_header_number(), pipeline_.head_header_hash()}; break; default: verify_result = ValidationError{ .latest_valid_head = BlockId{pipeline_.head_header_number(), pipeline_.head_header_hash()}, }; break; } head_status_ = verify_result; // finish, no commit here return verify_result; } bool Fork::fork_choice(Hash head_block_hash, std::optional finalized_block_hash, std::optional safe_block_hash) { SILK_TRACE << "Fork: fork choice update " << head_block_hash.to_hex(); /* this block is to handle fork choice in the middle of this fork; it requires suitable ExecutionEngine behavior to be enabled, which is not the case at the moment if (last_verified_head_.hash != head_block_hash) { // usually update_fork_choice must follow verify_chain with the same header // except when verify_chain returned InvalidChain, in which case we expect // update_fork_choice to be called with a previous valid head block hash auto head_block_num = find_block(head_block_hash); ensure_invariant(head_block_num.has_value(), "fork choice update with unknown block hash"); ensure_invariant(*head_block_num < last_verified_head_.number, "fork choice update upon non verified block"); auto unwind_result = pipeline_.unwind(memory_tx_, *head_block_num); success_or_throw(unwind_result); // unwind must complete with success canonical_chain_.delete_down_to(*head_block_num); // remove last part of canonical ensure_invariant(canonical_chain_.current_head().hash == head_block_hash, "fork choice update failed to update canonical chain"); current_head_ = {*head_block_num, head_block_hash}; head_status_ = ValidChain{*head_block_num, head_block_hash}; } */ ensure_invariant(current_head_.hash == head_block_hash, "fork choice update with wrong head block hash"); if (!head_status_ || !holds_alternative(*head_status_)) return false; // todo: check if is_canonical(*finalized_block_hash) db::write_last_head_block(memory_tx_, head_block_hash); if (finalized_block_hash) { db::write_last_finalized_block(memory_tx_, *finalized_block_hash); const auto finalized_header = get_header(*finalized_block_hash); if (!finalized_header) return false; finalized_head_ = {finalized_header->number, *finalized_block_hash}; } if (safe_block_hash) { db::write_last_safe_block(memory_tx_, *safe_block_hash); const auto safe_header = get_header(*safe_block_hash); if (!safe_header) return false; safe_head_ = {safe_header->number, *safe_block_hash}; } memory_tx_.enable_commit(); memory_tx_.commit_and_stop(); return true; } std::set Fork::collect_bad_headers(InvalidChain& invalid_chain) { if (!invalid_chain.bad_block) return {}; std::set bad_headers; for (BlockNum current_block_num = canonical_chain_.current_head().block_num; current_block_num > invalid_chain.unwind_point.block_num; --current_block_num) { auto current_hash = canonical_chain_.get_hash(current_block_num); bad_headers.insert(*current_hash); } return bad_headers; } std::optional Fork::get_header(Hash header_hash) const { std::optional header = data_model().read_header(header_hash); return header; } std::vector::iterator find_fork_by_head(std::vector& forks, const Hash& requested_head_hash) { return std::find_if(forks.begin(), forks.end(), [&](const auto& fork) { return fork.current_head().hash == requested_head_hash; }); } std::vector::iterator find_fork_to_extend(std::vector& forks, const BlockHeader& header) { return find_fork_by_head(forks, header.parent_hash); } /* std::vector::iterator best_fork_to_branch(std::vector& forks, const BlockHeader& header) { auto fork = forks.end(); BlockNum block_num = 0; for (auto f = forks.begin(); f != forks.end(); ++f) { auto attachment_point = f->find_attachment_point(header); if (!attachment_point) continue; auto distance = f->distance_from_root(*attachment_point); if (fork == forks.end() || distance < block_num) { block_num = distance; fork = f; } } return fork; } */ } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/fork.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include "../timer_factory.hpp" #include "canonical_chain.hpp" namespace silkworm::stagedsync { class MainChain; class Fork { public: explicit Fork( BlockId forking_point, datastore::kvdb::ROTxnManaged main_tx, db::DataModelFactory data_model_factory, std::optional log_timer_factory, const StageContainerFactory& stages_factory, const std::filesystem::path& forks_dir_path); Fork(const Fork&) = delete; void close(); void flush(db::RWTxn& main_chain_tx); // extension & contraction void extend_with(const std::list>&); void extend_with(const Block&); // put block over the head of the fork (need verify_chain() to add state) void reduce_down_to(BlockId unwind_point); // remove blocks & state down to the specified head // verification using VerificationResult = execution::api::VerificationResult; // verify chain up to current head VerificationResult verify_chain(); // accept the current chain up to head_block_hash bool fork_choice(Hash head_block_hash, std::optional finalized_block_hash = {}, std::optional safe_block_hash = {}); // state BlockId current_head() const; std::optional head_status() const; BlockId finalized_head() const; BlockId safe_head() const; // checks bool extends_head(const BlockHeader&) const; std::optional find_block(Hash header_hash) const; std::optional find_attachment_point(const BlockHeader& header) const; BlockNum distance_from_root(const BlockId&) const; // header/body retrieval std::optional get_header(Hash) const; protected: db::DataModel data_model() const { return data_model_factory_(memory_tx_); } Hash insert_header(const BlockHeader&); void insert_body(const Block&, const Hash& block_hash); std::set collect_bad_headers(execution::api::InvalidChain& invalid_chain); datastore::kvdb::ROTxnManaged main_tx_; datastore::kvdb::MemoryOverlay memory_db_; mutable datastore::kvdb::MemoryMutation memory_tx_; db::DataModelFactory data_model_factory_; ExecutionPipeline pipeline_; CanonicalChain canonical_chain_; BlockId current_head_; std::optional head_status_; BlockId finalized_head_; BlockId safe_head_; }; // find the fork with the specified head std::vector::iterator find_fork_by_head(const std::vector& forks, const Hash& requested_head_hash); // find the fork with the head to extend std::vector::iterator find_fork_to_extend(const std::vector& forks, const BlockHeader& header); } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/fork_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "fork.hpp" #include #include #include #include #include #include #include #include #include #include #include #include "main_chain.hpp" namespace silkworm { namespace asio = boost::asio; using namespace silkworm::test_util; using namespace stagedsync; using namespace intx; // just for literals using execution::api::ValidChain; using silkworm::stagedsync::test_util::make_stages_factory; class ForkForTest : public Fork { public: using Fork::canonical_chain_; using Fork::current_head_; using Fork::Fork; // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved) using Fork::main_tx_; using Fork::memory_db_; using Fork::memory_tx_; using Fork::pipeline_; }; TEST_CASE("Fork") { db::test_util::TempChainDataStore context; context.add_genesis_data(); context.commit_txn(); db::DataModelFactory data_model_factory = context.data_model_factory(); asio::io_context ioc; asio::executor_work_guard work{ioc.get_executor()}; Environment::set_stop_before_stage(db::stages::kSendersKey); // only headers, block hashes and bodies NodeSettings node_settings = node::test_util::make_node_settings_from_temp_chain_data(context); datastore::kvdb::RWAccess db_access = context.chaindata_rw(); MainChain main_chain{ ioc.get_executor(), node_settings, data_model_factory, /* log_timer_factory = */ std::nullopt, make_stages_factory(node_settings, data_model_factory), db_access, }; main_chain.open(); auto& tx = main_chain.tx(); auto header0_hash = db::read_canonical_header_hash(tx, 0); REQUIRE(header0_hash.has_value()); auto header0 = db::read_canonical_header(tx, 0); REQUIRE(header0.has_value()); auto block1 = generate_sample_child_blocks(*header0); auto block1_hash = block1->header.hash(); auto block2 = generate_sample_child_blocks(block1->header); // auto block2_hash = block2.header.hash(); auto block3 = generate_sample_child_blocks(block2->header); auto block3_hash = block3->header.hash(); // inserting & verifying the block main_chain.insert_block(*block1); main_chain.insert_block(*block2); main_chain.insert_block(*block3); auto verification = main_chain.verify_chain(block3_hash); REQUIRE(holds_alternative(verification)); auto valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == BlockId{3, block3_hash}); REQUIRE(db::stages::read_stage_progress(main_chain.tx(), db::stages::kHeadersKey) == 3); REQUIRE(db::stages::read_stage_progress(main_chain.tx(), db::stages::kBlockHashesKey) == 3); REQUIRE(db::stages::read_stage_progress(main_chain.tx(), db::stages::kBlockBodiesKey) == 3); // confirming the chain auto fcu_updated = main_chain.notify_fork_choice_update(block3_hash, block1_hash); REQUIRE(fcu_updated); auto final_canonical_head = main_chain.last_chosen_head(); REQUIRE(final_canonical_head == BlockId{3, block3_hash}); SECTION("creating a fork") { std::exception_ptr test_failure; auto fork_thread = std::thread([&]() { // avoid mdbx limitations on txns & threads try { auto block4 = generate_sample_child_blocks(block3->header); auto block4_hash = block4->header.hash(); BlockId forking_point = main_chain.last_chosen_head(); ForkForTest fork{ forking_point, datastore::kvdb::ROTxnManaged(main_chain.tx().db()), // this need to be on a different thread than main_chain data_model_factory, /* log_timer_factory = */ std::nullopt, main_chain.stages_factory(), node_settings.data_directory->forks().path(), }; CHECK(db::stages::read_stage_progress(fork.memory_tx_, db::stages::kHeadersKey) == 3); CHECK(db::stages::read_stage_progress(fork.memory_tx_, db::stages::kBlockHashesKey) == 3); CHECK(db::stages::read_stage_progress(fork.memory_tx_, db::stages::kBlockBodiesKey) == 3); CHECK(!fork.head_status().has_value()); // inserting blocks fork.extend_with(*block4); CHECK(db::read_header(fork.memory_tx_, 4, block4_hash)); // verification auto fork_verification = fork.verify_chain(); // run pipeline REQUIRE(holds_alternative(fork_verification)); auto fork_valid_chain = std::get(fork_verification); CHECK(fork_valid_chain.current_head == BlockId{4, block4_hash}); CHECK(db::stages::read_stage_progress(fork.memory_tx_, db::stages::kHeadersKey) == 4); CHECK(db::stages::read_stage_progress(fork.memory_tx_, db::stages::kBlockHashesKey) == 4); CHECK(db::stages::read_stage_progress(fork.memory_tx_, db::stages::kBlockBodiesKey) == 4); // fork choice bool updated = fork.fork_choice(block4_hash, block3_hash); CHECK(updated); CHECK(fork.current_head() == BlockId{4, block4_hash}); CHECK((fork.head_status().has_value() && holds_alternative(*fork.head_status()))); // close fork.close(); } catch (...) { test_failure = std::current_exception(); } }); fork_thread.join(); if (test_failure) { std::rethrow_exception(test_failure); } } } } // namespace silkworm ================================================ FILE: silkworm/node/stagedsync/forks/main_chain.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "main_chain.hpp" #include #include #include #include #include #include #include "extending_fork.hpp" namespace { //! @brief Handles the transaction lifecycle for long-standing and per-request transactions class TransactionHandler { public: TransactionHandler(silkworm::datastore::kvdb::RWTxnManaged& txn, silkworm::datastore::kvdb::RWAccess& db_access, bool keep_db_txn_open = true) : txn_{txn}, db_access_{db_access}, keep_db_txn_open_{keep_db_txn_open} { if (!keep_db_txn_open_) { if (request_count_ == 0 && !txn_.is_open()) { txn_.reopen(*db_access_); } ++request_count_; } else { if (!txn_.is_open()) { txn_.reopen(*db_access_); } } } ~TransactionHandler() { if (!keep_db_txn_open_) { if (--request_count_ == 0) { txn_.commit_and_stop(); } } } private: silkworm::datastore::kvdb::RWTxnManaged& txn_; silkworm::datastore::kvdb::RWAccess& db_access_; bool keep_db_txn_open_{true}; static inline SILKWORM_THREAD_LOCAL int request_count_; }; } // namespace namespace silkworm::stagedsync { //! The number of inserted blocks between two successive commits on db static constexpr uint64_t kInsertedBlockBatch{1'000}; using execution::api::InvalidChain; using execution::api::ValidationError; using execution::api::ValidChain; using execution::api::VerificationResult; MainChain::MainChain( boost::asio::any_io_executor executor, NodeSettings& ns, db::DataModelFactory data_model_factory, std::optional log_timer_factory, StageContainerFactory stages_factory, datastore::kvdb::RWAccess dba) : executor_{std::move(executor)}, node_settings_{ns}, data_model_factory_{std::move(data_model_factory)}, log_timer_factory_{std::move(log_timer_factory)}, stages_factory_{std::move(stages_factory)}, db_access_{std::move(dba)}, tx_{db_access_.start_rw_tx()}, pipeline_{data_model_factory_, log_timer_factory_, stages_factory_}, interim_canonical_chain_{tx_, data_model_factory_} { // We commit and close the one-and-only RW txn here because it must be reopened below in MainChain::open tx_.commit_and_stop(); } void MainChain::open() { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; // Load last finalized and last chosen blocks from persistence auto last_finalized_hash = db::read_last_finalized_block(tx_); if (last_finalized_hash) { auto header = get_header(*last_finalized_hash); ensure_invariant(header.has_value(), "last finalized block not found in db"); last_finalized_head_ = {header->number, *last_finalized_hash}; } else { last_finalized_head_ = {0, node_settings_.chain_config.value().genesis_hash.value()}; } auto last_head_hash = db::read_last_head_block(tx_); if (last_head_hash) { auto header = get_header(*last_head_hash); ensure_invariant(header.has_value(), "last head block not found in db"); last_fork_choice_ = {header->number, *last_head_hash}; } else last_fork_choice_ = last_finalized_head_; interim_canonical_chain_.open(); // Revalidate chain by executing forward cycle up to the canonical current head at startup: // - if last cycle completed successfully, this will simply do nothing (no hurt) // - if last cycle was executed partially (i.e. not all stages are at the same block_num), this will do a cleanup cycle const auto& canonical_head{interim_canonical_chain_.current_head()}; SILK_INFO << "Revalidate canonical chain up to number=" << canonical_head.block_num << " hash=" << to_hex(canonical_head.hash); forward(canonical_head.block_num, canonical_head.hash); // If forward cleanup cycle has not produced a valid chain, then we need to unwind if (!std::holds_alternative(interim_head_status_)) { const auto unwind_point{pipeline_.unwind_point()}; ensure_invariant(unwind_point.has_value(), "unwind point from pipeline requested when forward fails"); unwind(*unwind_point); } } void MainChain::close() { if (node_settings_.keep_db_txn_open) { tx_.commit_and_stop(); } } void MainChain::abort() { tx_.abort(); } NodeSettings& MainChain::node_settings() { return node_settings_; } db::RWTxn& MainChain::tx() { return tx_; } const std::optional& MainChain::log_timer_factory() const { return log_timer_factory_; } datastore::StageScheduler& MainChain::stage_scheduler() const { return pipeline_.stage_scheduler(); } BlockId MainChain::current_head() const { return interim_canonical_chain_.current_head(); } BlockId MainChain::last_chosen_head() const { return last_fork_choice_; } BlockId MainChain::last_finalized_head() const { return last_finalized_head_; } std::optional MainChain::find_forking_point(const BlockHeader& header, const Hash& header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; return interim_canonical_chain_.find_forking_point(header, header_hash); } std::optional MainChain::find_forking_point(const Hash& header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; auto header = get_header(header_hash); if (!header) return std::nullopt; return find_forking_point(*header, header_hash); } bool MainChain::is_finalized_canonical(BlockId block) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; if (block.block_num > last_fork_choice_.block_num) return false; return (interim_canonical_chain_.get_hash(block.block_num) == block.hash); } // protected, no txn handling required Hash MainChain::insert_header(const BlockHeader& header) { return db::write_header_ex(tx_, header, /*with_header_numbers=*/true); // with_header_numbers=true is necessary at the moment because many getters here rely on kHeaderNumbers table; // that table is updated by stage block-hashes so only after a pipeline run // todo: remove getters that take only an hash as input and use with_header_numbers=false here } // protected, no txn handling required void MainChain::insert_body(const Block& block, const Hash& block_hash) { // avoid calculation of block.header.hash() because is computationally expensive BlockNum block_num = block.header.number; if (data_model().has_body(block_num, block_hash)) return; db::write_body(tx_, block, block_hash, block_num); } void MainChain::insert_block(const Block& block) { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; Hash header_hash = insert_header(block.header); insert_body(block, header_hash); // Check chain integrity also on execution side (remove in production?) const auto parent = get_header(block.header.number - 1, block.header.parent_hash); ensure_invariant(parent.has_value(), "inserting block must have parent"); // Commit inserted blocks once in a while not to lose downloading progress on restart static uint64_t block_count{0}; if (++block_count == kInsertedBlockBatch) { block_count = 0; StopWatch timing{StopWatch::kStart}; tx_.commit_and_renew(); SILK_INFO << "MainChain::insert_block commit " << kInsertedBlockBatch << " blocks up to " << block.header.number << " took " << StopWatch::format(timing.since_start()); } } VerificationResult MainChain::verify_chain(Hash block_hash) { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; SILK_TRACE << "MainChain: verifying chain block=" << block_hash.to_hex(); // Retrieve the block header to validate const auto block_header = get_header(block_hash); ensure_invariant(block_header.has_value(), "header to verify not found"); // Check if incoming block already exists as canonical block if (is_canonical(block_header->number, block_hash)) { // The incoming block matches a block already on the canonical chain, verification is not always needed if (block_header->number <= last_fork_choice_.block_num) { // Last FCU block is greater than or equal to incoming canonical block, chain is valid up to last FCU block return ValidChain{last_fork_choice_.block_num, last_fork_choice_.hash}; } if (std::holds_alternative(interim_head_status_)) { // Chain is valid up to canonical head return ValidChain{interim_canonical_chain_.current_head().block_num, interim_canonical_chain_.current_head().hash}; } if (std::holds_alternative(interim_head_status_)) { // Chain is valid up to unwind point const auto& invalid_chain{std::get(interim_head_status_)}; if (block_header->number <= invalid_chain.unwind_point.block_num) { // Unwind point is greater than or equal incoming canonical block, chain is valid up to unwind point return ValidChain{invalid_chain.unwind_point.block_num, invalid_chain.unwind_point.hash}; } // Incoming canonical block is greater than unwind point, so chain is invalid return invalid_chain; } } // db commit policy bool commit_at_each_stage = is_first_sync_; if (!commit_at_each_stage) tx_.disable_commit(); auto _ = gsl::finally([&]() { tx_.enable_commit(); }); // the new head is on a new fork? BlockId forking_point = interim_canonical_chain_.find_forking_point(*block_header, block_hash); // the forking origin if (block_hash != interim_canonical_chain_.current_head().hash && // if the new head is not the current head forking_point.block_num < interim_canonical_chain_.current_head().block_num) { // and if the forking is behind the head // We need to do unwind to change canonical unwind(forking_point.block_num); } // update canonical up to header_hash interim_canonical_chain_.update_up_to(block_header->number, block_hash); // forward Stage::Result forward_result = pipeline_.forward(tx_, block_header->number); SILK_INFO << "MainChain::verify_chain forward_result=" << magic_enum::enum_name<>(forward_result); // evaluate result VerificationResult verify_result; switch (forward_result) { case Stage::Result::kSuccess: { ensure_invariant(pipeline_.head_header_number() == interim_canonical_chain_.current_head().block_num && pipeline_.head_header_hash() == interim_canonical_chain_.current_head().hash, "forward succeeded with pipeline head not aligned with canonical head"); verify_result = ValidChain{pipeline_.head_header_number(), pipeline_.head_header_hash()}; break; } case Stage::Result::kWrongFork: case Stage::Result::kInvalidBlock: case Stage::Result::kWrongStateRoot: { ensure_invariant(pipeline_.unwind_point().has_value(), "unwind point from pipeline requested when forward fails"); InvalidChain invalid_chain; invalid_chain.unwind_point.block_num = *pipeline_.unwind_point(); invalid_chain.unwind_point.hash = *interim_canonical_chain_.get_hash(*pipeline_.unwind_point()); if (pipeline_.bad_block()) { invalid_chain.bad_block = pipeline_.bad_block(); invalid_chain.bad_headers = collect_bad_headers(tx_, invalid_chain); } verify_result = invalid_chain; break; } case Stage::Result::kStoppedByEnv: verify_result = ValidChain{pipeline_.head_header_number(), pipeline_.head_header_hash()}; break; default: verify_result = ValidationError{ .latest_valid_head = BlockId{pipeline_.head_header_number(), pipeline_.head_header_hash()}, }; break; } interim_head_status_ = verify_result; return verify_result; } bool MainChain::notify_fork_choice_update(Hash head_block_hash, std::optional finalized_block_hash) { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; if (finalized_block_hash && !interim_canonical_chain_.has(*finalized_block_hash)) { return false; // finalized block not found } const auto head_block_num{get_block_num(head_block_hash)}; ensure_invariant(head_block_num.has_value(), "unknown block number for head block hash"); if (is_canonical_head_ancestor(head_block_hash) && head_block_num <= last_fork_choice_.block_num) { // FCU selects an old canonical block already targeted by a previous FCU return true; } // Usually FCU must follow verify_chain with the same header except when: // 1) (PoS) CL is syncing so head_block_hash is referring to a previous valid head // 2) (PoW) previous verify_chain returned InvalidChain so CL is issuing a FCU with a previous valid head // When FCU selects a non-canonical block or our last validation result is not valid, we need to verify the resulting chain if (!interim_canonical_chain_.has(head_block_hash) || !std::holds_alternative(interim_head_status_)) { verify_chain(head_block_hash); // this will reset canonical chain to head_block_hash ensure_invariant(interim_canonical_chain_.current_head().hash == head_block_hash, "canonical head not aligned with fork choice"); } if (!std::holds_alternative(interim_head_status_)) { return false; // canonical head is not valid } const auto valid_chain = std::get(interim_head_status_); ensure_invariant(interim_canonical_chain_.current_head() == valid_chain.current_head, "canonical head not aligned with saved head status"); last_fork_choice_.block_num = *head_block_num; last_fork_choice_.hash = head_block_hash; db::write_last_head_block(tx_, last_fork_choice_.hash); if (finalized_block_hash) { db::write_last_finalized_block(tx_, *finalized_block_hash); const auto finalized_block_num = get_block_num(*finalized_block_hash); last_finalized_head_.block_num = *finalized_block_num; last_finalized_head_.hash = *finalized_block_hash; } tx_.commit_and_renew(); is_first_sync_ = false; return true; } // protected, no txn handling required std::set MainChain::collect_bad_headers(db::RWTxn& tx, InvalidChain& invalid_chain) { if (!invalid_chain.bad_block) return {}; const auto bad_count{interim_canonical_chain_.current_head().block_num - invalid_chain.unwind_point.block_num}; SILK_INFO << "MainChain::collect_bad_headers bad_count=" << bad_count << " skip=" << (bad_count > 10); // Do not collect too many headers, rather skip if (bad_count > 10) { return {}; } std::set bad_headers; for (BlockNum current_block_num = interim_canonical_chain_.current_head().block_num; current_block_num > invalid_chain.unwind_point.block_num; --current_block_num) { auto current_hash = db::read_canonical_header_hash(tx, current_block_num); bad_headers.insert(*current_hash); } /* todo: check if we need also the following code (remember that this entire algo changed in Erigon) BlockNum new_block_num = unwind_point; if (is_bad_block) { bad_headers.insert(*bad_block); auto [max_block_num, max_hash] = header_with_biggest_td(tx, &bad_headers); if (max_block_num == 0) { max_block_num = unwind_point; max_hash = *db::read_canonical_header_hash(tx, max_block_num); } db::write_head_header_hash(tx, max_hash); new_block_num = max_block_num; } return {bad_headers, new_block_num}; */ return bad_headers; } std::unique_ptr MainChain::fork(BlockId forking_point) { ensure(std::holds_alternative(interim_head_status_), "forking is allowed from a valid state"); return std::make_unique(forking_point, *this, executor_); } void MainChain::reintegrate_fork(ExtendingFork& extending_fork) { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; Fork* fork = extending_fork.fork_.get(); ensure(fork->head_status() && std::holds_alternative(*fork->head_status()), "fork to be reintegrated must be valid"); fork->flush(tx_); // this must be done here, in the tx_ thread, due to MDBX limitations tx_.commit_and_renew(); interim_canonical_chain_.set_current_head(fork->current_head()); interim_head_status_ = *fork->head_status(); last_fork_choice_ = fork->current_head(); last_finalized_head_ = fork->finalized_head(); } std::optional MainChain::get_header(Hash header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; // const BlockHeader* cached = header_cache_.get(header_hash); // if (cached) { // return *cached; // } return data_model().read_header(header_hash); } std::optional MainChain::get_header(BlockNum header_block_num, Hash header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; // const BlockHeader* cached = header_cache_.get(header_hash); // if (cached) { // return *cached; // } std::optional header = data_model().read_header(header_block_num, header_hash); return header; } std::optional MainChain::get_finalized_canonical_hash(BlockNum block_num) const { if (block_num > last_fork_choice_.block_num) return {}; TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; return interim_canonical_chain_.get_hash(block_num); } std::optional MainChain::get_header_td(BlockNum header_block_num, Hash header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; return db::read_total_difficulty(tx_, header_block_num, header_hash); } std::optional MainChain::get_header_td(Hash header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; auto header = get_header(header_hash); if (!header) return {}; return db::read_total_difficulty(tx_, header->number, header_hash); } std::optional MainChain::get_body(Hash header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; BlockBody body; bool found = data_model().read_body(header_hash, body); if (!found) return {}; return body; } BlockNum MainChain::get_block_progress() const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; return data_model().max_block_num(); } std::vector MainChain::get_last_headers(uint64_t limit) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; std::vector headers; data_model().for_last_n_headers(limit, [&headers](BlockHeader header) { headers.emplace_back(std::move(header)); }); return headers; } std::optional MainChain::get_block_num(Hash header_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; return data_model().read_block_num(header_hash); } BlockNum MainChain::max_frozen_block_num() const { return data_model().max_frozen_block_num(); } bool MainChain::is_ancestor(BlockId supposed_parent, BlockId block) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; return extends(block, supposed_parent); } bool MainChain::extends_last_fork_choice(BlockNum block_num, Hash hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; return extends({block_num, hash}, last_fork_choice_); } bool MainChain::extends(BlockId block, BlockId supposed_parent) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; while (block.block_num > supposed_parent.block_num) { auto header = get_header(block.block_num, block.hash); if (!header) return false; if (header->parent_hash == supposed_parent.hash) return true; --block.block_num; block.hash = header->parent_hash; } if (block.block_num == supposed_parent.block_num) return block.hash == supposed_parent.hash; return false; } bool MainChain::is_finalized_canonical(Hash block_hash) const { TransactionHandler tx_handler{tx_, db_access_, node_settings_.keep_db_txn_open}; auto header = get_header(block_hash); if (!header) return false; if (header->number > last_fork_choice_.block_num) return false; auto canonical_hash_at_same_block_num = interim_canonical_chain_.get_hash(header->number); return canonical_hash_at_same_block_num == block_hash; } // protected, no txn handling required bool MainChain::is_canonical(BlockNum block_num, const Hash& block_hash) const { // Check if specified block already exists as canonical block return interim_canonical_chain_.get_hash(block_num) == block_hash; } // protected, no txn handling required bool MainChain::is_canonical_head_ancestor(const Hash& block_hash) const { return interim_canonical_chain_.has(block_hash) && interim_canonical_chain_.current_head().hash != block_hash; } // protected, no txn handling required void MainChain::forward(BlockNum head_block_num, const Hash& head_hash) { // update canonical up to header_hash interim_canonical_chain_.update_up_to(head_block_num, head_hash); // forward Stage::Result forward_result = pipeline_.forward(tx_, head_block_num); // evaluate result VerificationResult verify_result; switch (forward_result) { case Stage::Result::kSuccess: { ensure_invariant(pipeline_.head_header_number() == interim_canonical_chain_.current_head().block_num && pipeline_.head_header_hash() == interim_canonical_chain_.current_head().hash, "forward succeeded with pipeline head not aligned with canonical head"); verify_result = ValidChain{pipeline_.head_header_number(), pipeline_.head_header_hash()}; break; } case Stage::Result::kWrongFork: case Stage::Result::kInvalidBlock: case Stage::Result::kWrongStateRoot: { ensure_invariant(pipeline_.unwind_point().has_value(), "unwind point from pipeline requested when forward fails"); InvalidChain invalid_chain; invalid_chain.unwind_point.block_num = *pipeline_.unwind_point(); invalid_chain.unwind_point.hash = *interim_canonical_chain_.get_hash(*pipeline_.unwind_point()); if (pipeline_.bad_block()) { invalid_chain.bad_block = pipeline_.bad_block(); invalid_chain.bad_headers = collect_bad_headers(tx_, invalid_chain); } verify_result = invalid_chain; break; } case Stage::Result::kStoppedByEnv: verify_result = ValidChain{pipeline_.head_header_number(), pipeline_.head_header_hash()}; break; default: verify_result = ValidationError{ .latest_valid_head = BlockId{pipeline_.head_header_number(), pipeline_.head_header_hash()}, }; break; } interim_head_status_ = verify_result; } // protected, no txn handling required void MainChain::unwind(BlockNum unwind_point) { const auto unwind_result = pipeline_.unwind(tx_, unwind_point); success_or_throw(unwind_result); // unwind must complete with success // Remove last part of canonical chain interim_canonical_chain_.delete_down_to(unwind_point); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/main_chain.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../timer_factory.hpp" #include "canonical_chain.hpp" namespace silkworm::stagedsync { class Fork; class ExtendingFork; class MainChain { public: explicit MainChain( boost::asio::any_io_executor executor, NodeSettings& ns, db::DataModelFactory data_model_factory, std::optional log_timer_factory, StageContainerFactory stages_factory, datastore::kvdb::RWAccess dba); void open(); // needed to circumvent mdbx threading model limitations void close(); void abort(); // extension void insert_block(const Block&); // branching std::unique_ptr fork(BlockId forking_point); // fort at the current head void reintegrate_fork(ExtendingFork&); // reintegrate fork into the main chain std::optional find_forking_point(const BlockHeader& header, const Hash& header_hash) const; std::optional find_forking_point(const Hash& header_hash) const; bool is_finalized_canonical(BlockId block) const; // verification using VerificationResult = execution::api::VerificationResult; // verify chain up to head_block_hash VerificationResult verify_chain(Hash head_block_hash); // accept the current chain up to head_block_hash bool notify_fork_choice_update(Hash head_block_hash, std::optional finalized_block_hash = std::nullopt); // state BlockId last_chosen_head() const; // set by notify_fork_choice_update(), is always valid BlockId last_finalized_head() const; BlockId current_head() const; // header/body retrieval BlockNum get_block_progress() const; std::optional get_header(BlockNum, Hash) const; std::optional get_finalized_canonical_hash(BlockNum) const; std::optional get_header_td(BlockNum, Hash) const; std::vector get_last_headers(uint64_t limit) const; bool extends_last_fork_choice(BlockNum, Hash) const; bool extends(BlockId block, BlockId supposed_parent) const; bool is_ancestor(BlockId supposed_parent, BlockId block) const; bool is_finalized_canonical(Hash) const; // Warning: this getters use kHeaderNumbers so will return only header processed by the pipeline std::optional get_header(Hash) const; std::optional get_header_td(Hash) const; std::optional get_body(Hash) const; std::optional get_block_num(Hash) const; BlockNum max_frozen_block_num() const; NodeSettings& node_settings(); db::RWTxn& tx(); // only for testing purposes due to MDBX limitations const db::DataModelFactory& data_model_factory() const { return data_model_factory_; } const std::optional& log_timer_factory() const; const StageContainerFactory& stages_factory() const { return stages_factory_; } datastore::StageScheduler& stage_scheduler() const; protected: db::DataModel data_model() const { return data_model_factory_(tx_); } Hash insert_header(const BlockHeader&); void insert_body(const Block&, const Hash& block_hash); void forward(BlockNum head_block_num, const Hash& head_hash); void unwind(BlockNum unwind_point); bool is_canonical(BlockNum block_num, const Hash& block_hash) const; bool is_canonical_head_ancestor(const Hash& block_hash) const; std::set collect_bad_headers(db::RWTxn& tx, execution::api::InvalidChain& invalid_chain); boost::asio::any_io_executor executor_; NodeSettings& node_settings_; db::DataModelFactory data_model_factory_; std::optional log_timer_factory_; StageContainerFactory stages_factory_; mutable datastore::kvdb::RWAccess db_access_; mutable datastore::kvdb::RWTxnManaged tx_; bool is_first_sync_{true}; ExecutionPipeline pipeline_; CanonicalChain interim_canonical_chain_; VerificationResult interim_head_status_; BlockId last_fork_choice_; BlockId last_finalized_head_; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/forks/main_chain_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "main_chain.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { namespace asio = boost::asio; using namespace silkworm::db; using namespace silkworm::test_util; using namespace stagedsync; using namespace intx; // just for literals using execution::api::InvalidChain; using execution::api::ValidationError; using execution::api::ValidChain; using silkworm::stagedsync::test_util::make_stages_factory; class MainChainForTest : public stagedsync::MainChain { public: using stagedsync::MainChain::current_head; using stagedsync::MainChain::insert_block; using stagedsync::MainChain::interim_canonical_chain_; using stagedsync::MainChain::interim_head_status_; using stagedsync::MainChain::MainChain; using stagedsync::MainChain::pipeline_; }; TEST_CASE("MainChain transaction handling") { for (int i = 0; i < 2; ++i) { auto keep_db_txn_open = i == 1; SECTION("keep_db_txn_open = " + std::to_string(keep_db_txn_open)) { asio::io_context ioc; asio::executor_work_guard work{ioc.get_executor()}; db::test_util::TempChainDataStore context; context.add_genesis_data(); context.commit_txn(); db::DataModelFactory data_model_factory = context.data_model_factory(); Environment::set_stop_before_stage(stages::kSendersKey); // only headers, block hashes and bodies NodeSettings node_settings = node::test_util::make_node_settings_from_temp_chain_data(context); node_settings.keep_db_txn_open = keep_db_txn_open; MainChainForTest main_chain{ ioc.get_executor(), node_settings, data_model_factory, /* log_timer_factory = */ std::nullopt, make_stages_factory(node_settings, data_model_factory), context.chaindata_rw(), }; main_chain.open(); auto& tx = main_chain.tx(); SECTION("multiple reads") { auto hash0 = main_chain.get_finalized_canonical_hash(0); REQUIRE(hash0.has_value()); CHECK(tx.is_open() == keep_db_txn_open); auto header0 = main_chain.get_header(0, *hash0); REQUIRE(header0.has_value()); CHECK(tx.is_open() == keep_db_txn_open); auto body0 = main_chain.get_body(*hash0); REQUIRE(body0.has_value()); CHECK(tx.is_open() == keep_db_txn_open); auto td0 = main_chain.get_header_td(0, *hash0); REQUIRE(td0.has_value()); CHECK(tx.is_open() == keep_db_txn_open); auto block_num0 = main_chain.get_block_num(*hash0); REQUIRE(block_num0.has_value()); CHECK(block_num0 == 0); CHECK(tx.is_open() == keep_db_txn_open); } SECTION("multiple inserts") { auto hash0 = main_chain.get_finalized_canonical_hash(0); auto header0 = main_chain.get_header(0, *hash0); auto block1 = generate_sample_child_blocks(*header0); auto block1_hash = block1->header.hash(); main_chain.insert_block(*block1); CHECK(tx.is_open() == keep_db_txn_open); auto header1 = main_chain.get_header(1, block1_hash); REQUIRE(header1.has_value()); CHECK(tx.is_open() == keep_db_txn_open); auto block2 = generate_sample_child_blocks(*header1); auto block2_hash = block2->header.hash(); main_chain.insert_block(*block2); CHECK(tx.is_open() == keep_db_txn_open); auto header2 = main_chain.get_header(2, block2_hash); REQUIRE(header2.has_value()); CHECK(tx.is_open() == keep_db_txn_open); } SECTION("completes fork choice update") { auto hash0 = main_chain.get_finalized_canonical_hash(0); auto header0 = main_chain.get_header(0, *hash0); auto block1 = generate_sample_child_blocks(*header0); auto block1_hash = block1->header.hash(); main_chain.insert_block(*block1); CHECK(tx.is_open() == keep_db_txn_open); auto verification1 = main_chain.verify_chain(block1_hash); REQUIRE(holds_alternative(verification1)); CHECK(tx.is_open() == keep_db_txn_open); auto fcu_updated = main_chain.notify_fork_choice_update(block1_hash); CHECK(fcu_updated); CHECK(tx.is_open() == keep_db_txn_open); auto hash1 = main_chain.get_finalized_canonical_hash(1); REQUIRE(hash1.has_value()); CHECK(tx.is_open() == keep_db_txn_open); } } } } TEST_CASE("MainChain") { asio::io_context ioc; asio::executor_work_guard work{ioc.get_executor()}; db::test_util::TempChainDataStore context; context.add_genesis_data(); context.commit_txn(); db::DataModelFactory data_model_factory = context.data_model_factory(); Environment::set_stop_before_stage(stages::kSendersKey); // only headers, block hashes and bodies NodeSettings node_settings = node::test_util::make_node_settings_from_temp_chain_data(context); auto db_access = context.chaindata_rw(); MainChainForTest main_chain{ ioc.get_executor(), node_settings, data_model_factory, /* log_timer_factory = */ std::nullopt, make_stages_factory(node_settings, data_model_factory), db_access, }; main_chain.open(); auto& tx = main_chain.tx(); auto header0_hash = read_canonical_header_hash(tx, 0); REQUIRE(header0_hash.has_value()); auto header0 = read_canonical_header(tx, 0); REQUIRE(header0.has_value()); BlockId block0_id{0, *header0_hash}; // initial status auto initial_progress = main_chain.get_block_progress(); REQUIRE(initial_progress == 0); auto initial_canonical_head = main_chain.current_head(); REQUIRE(initial_canonical_head == block0_id); REQUIRE(main_chain.last_chosen_head() == block0_id); REQUIRE(initial_canonical_head.block_num == initial_progress); REQUIRE(main_chain.interim_canonical_chain_.current_head() == initial_canonical_head); /* status: * h0 * input: * h0 <----- h1 */ SECTION("one invalid body after the genesis") { Block block1; block1.header.number = 1; block1.header.difficulty = 17'171'480'576; // a random value block1.header.parent_hash = *header0_hash; block1.ommers.push_back(BlockHeader{}); // generate error InvalidOmmerHeader auto block1_hash = block1.header.hash(); BlockId block1_id{1, block1_hash}; // inserting headers & bodies main_chain.insert_block(block1); // check db BlockBody saved_body; bool present = read_body(tx, block1_hash, block1.header.number, saved_body); REQUIRE(present); auto progress = main_chain.get_block_progress(); REQUIRE(progress == 1); auto canonical_head = main_chain.current_head(); REQUIRE(canonical_head == initial_canonical_head); // doesn't change // verifying the chain auto verification = main_chain.verify_chain(block1_hash); CHECK(stages::read_stage_progress(tx, stages::kHeadersKey) == 1); CHECK(stages::read_stage_progress(tx, stages::kBlockHashesKey) == 1); CHECK(stages::read_stage_progress(tx, stages::kBlockBodiesKey) == 1); CHECK(stages::read_stage_progress(tx, stages::kSendersKey) == 0); CHECK(stages::read_stage_progress(tx, stages::kExecutionKey) == 0); CHECK(!holds_alternative(verification)); REQUIRE(holds_alternative(verification)); auto invalid_chain = std::get(verification); REQUIRE(invalid_chain.unwind_point == block0_id); REQUIRE(invalid_chain.bad_block.has_value()); REQUIRE(invalid_chain.bad_block.value() == block1_hash); REQUIRE(invalid_chain.bad_headers.size() == 1); REQUIRE(*(invalid_chain.bad_headers.begin()) == block1_hash); // check status auto final_progress = main_chain.get_block_progress(); REQUIRE(final_progress == block1.header.number); auto final_canonical_head = main_chain.current_head(); REQUIRE(final_canonical_head == block1_id); REQUIRE(main_chain.interim_canonical_chain_.current_head() == block1_id); REQUIRE(main_chain.last_chosen_head() == block0_id); // not changed auto current_status = main_chain.interim_head_status_; REQUIRE(holds_alternative(current_status)); // check canonical auto present_in_canonical = main_chain.get_finalized_canonical_hash(block1.header.number); REQUIRE(!present_in_canonical); // reverting the chain auto updated = main_chain.notify_fork_choice_update(*header0_hash); CHECK(updated); // checking the status present_in_canonical = main_chain.get_finalized_canonical_hash(block1.header.number); REQUIRE(!present_in_canonical); final_canonical_head = main_chain.current_head(); CHECK(final_canonical_head == block1_id); // still block1 even if invalid CHECK(main_chain.last_chosen_head() == block0_id); // not changed current_status = main_chain.interim_head_status_; CHECK(holds_alternative(current_status)); CHECK(std::get(current_status).unwind_point == block0_id); } SECTION("one valid body after the genesis") { std::string raw_header1 = "f90211a0d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3a01dcc4de8dec75d7aab85b567b6ccd41a" "d312451b948a7413f0a142fd40d493479405a56e2d52c817161883f50c441c3228cfe54d9fa0d67e4d450343046425ae4271474353" "857ab860dbc0a1dde64b41b5cd3a532bf3a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e8" "1f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000008503ff80000001821388808455ba422499476574682f76312e302e302f" "6c696e75782f676f312e342e32a0969b900de27b6ac6a67742365dd65f55a0526c41fd18e1b16f1a1215c2e66f5988539bd4979fef" "1ec4"; std::optional encoded_header1 = from_hex(raw_header1); Block block1; ByteView encoded_view = encoded_header1.value(); auto decoding_result = rlp::decode(encoded_view, block1.header); // Note: block1 has zero transactions and zero ommers on mainnet REQUIRE(decoding_result); auto block1_hash = block1.header.hash(); BlockId block1_id{1, block1_hash}; // inserting & verifying the block main_chain.insert_block(block1); auto verification = main_chain.verify_chain(block1_hash); REQUIRE(holds_alternative(verification)); auto valid_chain = std::get(verification); REQUIRE(valid_chain.current_head == block1_id); // check status REQUIRE(main_chain.pipeline_.head_header_number() == block1.header.number); REQUIRE(main_chain.pipeline_.head_header_hash() == block1_hash); auto final_canonical_head = main_chain.current_head(); REQUIRE(final_canonical_head == block1_id); REQUIRE(main_chain.last_chosen_head() == block0_id); // not changed REQUIRE(main_chain.interim_canonical_chain_.current_head() == block1_id); auto current_status = main_chain.interim_head_status_; REQUIRE(holds_alternative(current_status)); REQUIRE(std::get(current_status).current_head == block1_id); // check db content BlockBody saved_body; bool present = read_body(tx, block1_hash, block1.header.number, saved_body); REQUIRE(present); auto present_in_canonical = main_chain.get_finalized_canonical_hash(block1.header.number); REQUIRE(!present_in_canonical); // not yet // confirming the chain auto updated = main_chain.notify_fork_choice_update(block1_hash); CHECK(updated); // checking the status present_in_canonical = main_chain.get_finalized_canonical_hash(block1.header.number); REQUIRE(present_in_canonical); final_canonical_head = main_chain.current_head(); REQUIRE(final_canonical_head == block1_id); REQUIRE(main_chain.last_chosen_head() == block1_id); // testing other methods Block block1b; block1b.header.number = 1; block1b.header.difficulty = 1'000'000'000; // a random value block1b.header.parent_hash = *header0_hash; main_chain.insert_block(block1b); bool extends_canonical = main_chain.extends_last_fork_choice(block1b.header.number, block1b.header.hash()); CHECK(!extends_canonical); Block block2; block2.header.number = 2; block2.header.difficulty = 1'171'480'576; // a random value block2.header.parent_hash = block1_hash; main_chain.insert_block(block2); extends_canonical = main_chain.extends_last_fork_choice(block2.header.number, block2.header.hash()); CHECK(extends_canonical); Block block3; block3.header.number = 3; block3.header.difficulty = 1'171'480'576; // a random value block3.header.parent_hash = block2.header.hash(); main_chain.insert_block(block3); extends_canonical = main_chain.extends_last_fork_choice(block3.header.number, block3.header.hash()); CHECK(extends_canonical); // Testing a mini re-org auto new_block1 = generate_sample_child_blocks(*header0); const auto new_block1_hash{new_block1->header.hash()}; BlockId new_block1_id{1, new_block1_hash}; // inserting & verifying the block main_chain.insert_block(*new_block1); const auto new_verification1 = main_chain.verify_chain(new_block1_hash); CHECK(holds_alternative(new_verification1)); CHECK(std::get(new_verification1).current_head == new_block1_id); // confirming the chain const auto new_block1_updated = main_chain.notify_fork_choice_update(new_block1_hash); CHECK(new_block1_updated); } SECTION("diverting the head") { auto block1 = generate_sample_child_blocks(*header0); auto block2 = generate_sample_child_blocks(block1->header); auto block3 = generate_sample_child_blocks(block2->header); auto block3_hash = block3->header.hash(); BlockId block3_id{3, block3_hash}; // inserting & verifying the block main_chain.insert_block(*block1); main_chain.insert_block(*block2); main_chain.insert_block(*block3); auto block_progress = main_chain.get_block_progress(); REQUIRE(block_progress == block3->header.number); auto verification = main_chain.verify_chain(block3_hash); REQUIRE(holds_alternative(verification)); auto valid_chain = std::get(verification); CHECK(valid_chain.current_head == BlockId{3, block3_hash}); // confirming the chain auto fcu_updated = main_chain.notify_fork_choice_update(block3_hash); CHECK(fcu_updated); auto final_canonical_head = main_chain.current_head(); CHECK(final_canonical_head == block3_id); CHECK(main_chain.interim_canonical_chain_.current_head() == block3_id); REQUIRE(main_chain.last_chosen_head() == block3_id); // not changed // Creating a fork and changing the head (trigger unwind) { auto block2b = generate_sample_child_blocks(block1->header); block2b->header.extra_data = string_view_to_byte_view("I'm different"); // to make it different from block2 auto block2b_hash = block2b->header.hash(); BlockId block2b_id{2, block2b_hash}; // inserting & verifying the block main_chain.insert_block(*block2b); verification = main_chain.verify_chain(block2b_hash); REQUIRE(holds_alternative(verification)); valid_chain = std::get(verification); CHECK(valid_chain.current_head == block2b_id); // confirming the chain fcu_updated = main_chain.notify_fork_choice_update(block2b_hash); CHECK(fcu_updated); final_canonical_head = main_chain.current_head(); CHECK(final_canonical_head == block2b_id); CHECK(main_chain.interim_canonical_chain_.current_head() == block2b_id); REQUIRE(main_chain.last_chosen_head() == block2b_id); // not changed } } SECTION("starting after fcu") { Block block1; block1.header.number = 1; block1.header.difficulty = 17'171'480'576; // a random value block1.header.parent_hash = *header0_hash; auto block1_hash = block1.header.hash(); BlockId block1_id{1, block1_hash}; // inserting, verifying & confirming main_chain.insert_block(block1); auto verification = main_chain.verify_chain(block1_hash); REQUIRE(holds_alternative(verification)); auto fcu_updated = main_chain.notify_fork_choice_update(block1_hash); CHECK(fcu_updated); // closing the chain (-> application shutdown) main_chain.close(); // opening another main chain (-> application start up) MainChainForTest main_chain2{ ioc.get_executor(), node_settings, main_chain.data_model_factory(), /* log_timer_factory = */ std::nullopt, main_chain.stages_factory(), db_access, }; main_chain2.open(); // checking that the initial state sees the prev fcu // auto& tx2 = main_chain2.tx(); CHECK(main_chain2.last_chosen_head() == block1_id); CHECK(main_chain2.last_finalized_head() == block0_id); CHECK(holds_alternative(main_chain2.interim_head_status_)); } } } // namespace silkworm ================================================ FILE: silkworm/node/stagedsync/stages/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED COMPONENTS btree) # circular_buffer find_package(Boost REQUIRED COMPONENTS headers) find_package(magic_enum REQUIRED) find_package(Microsoft.GSL REQUIRED) set(LIBS_PUBLIC Boost::headers ethash::keccak evmc secp256k1 silkworm_core silkworm_db silkworm_datastore_etl silkworm_infra ) # cmake-format: off set(LIBS_PRIVATE absl::btree magic_enum::magic_enum Microsoft.GSL::GSL silkworm_execution ) # cmake-format: on silkworm_library( silkworm_stages PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) target_link_libraries(silkworm_stages_test PRIVATE silkworm_db_test_util) ================================================ FILE: silkworm/node/stagedsync/stages/stage_blockhashes.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_blockhashes.hpp" #include #include namespace silkworm::stagedsync { using datastore::etl::Entry; using datastore::kvdb::Collector; namespace db { using namespace silkworm::db; } Stage::Result BlockHashes::forward(db::RWTxn& txn) { /* * Creates HeaderNumber index by transforming * from CanonicalHashes bucket : BlockNum -> HeaderHash * to HeaderNumber bucket : HeaderHash -> BlockNum */ Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto headers_stage_progress{db::stages::read_stage_progress(txn, db::stages::kHeadersKey)}; if (previous_progress == headers_stage_progress) { // Nothing to process operation_ = OperationType::kNone; return ret; } if (previous_progress > headers_stage_progress) { // Something bad had happened. // Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "BlockHashes progress " + std::to_string(previous_progress) + " greater than Headers progress " + std::to_string(headers_stage_progress)); } const BlockNum segment_width{headers_stage_progress - previous_progress}; if (segment_width > db::stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(headers_stage_progress), "span", std::to_string(segment_width)}); } collector_ = std::make_unique(etl_settings_); collect_and_load(txn, previous_progress, headers_stage_progress); update_progress(txn, reached_block_num_); txn.commit_and_renew(); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; collector_.reset(); return ret; } Stage::Result BlockHashes::unwind(db::RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); const auto previous_progress{get_progress(txn)}; if (previous_progress <= to) { // Nothing to process operation_ = OperationType::kNone; return ret; } const BlockNum segment_width{previous_progress - to}; if (segment_width > db::stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } update_progress(txn, to); txn.commit_and_renew(); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result BlockHashes::prune(db::RWTxn&) { return Stage::Result::kSuccess; } std::vector BlockHashes::get_log_progress() { if (!is_stopping()) { switch (current_phase_) { case 1: return {"from", db::table::kCanonicalHashes.name_str(), "to", "etl", "block", std::to_string(reached_block_num_)}; case 2: return {"from", "etl", "to", db::table::kHeaderNumbers.name_str(), "key", collector_ ? collector_->get_load_key() : ""}; default: break; } } return {}; } void BlockHashes::collect_and_load(db::RWTxn& txn, const BlockNum from, const BlockNum to) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; reached_block_num_ = 0; current_phase_ = 1; // Collect auto expected_block_num{from + 1}; auto header_key{db::block_key(expected_block_num)}; auto canon_hashes_cursor = txn.rw_cursor(db::table::kCanonicalHashes); auto data = canon_hashes_cursor->find(datastore::kvdb::to_slice(header_key), /*throw_notfound=*/false); while (data.done) { reached_block_num_ = endian::load_big_u64(static_cast(data.key.data())); if (reached_block_num_ > to) { --reached_block_num_; break; } // Sanity check_block_sequence(reached_block_num_, expected_block_num); if (data.value.length() != kHashLength) { throw StageError(Stage::Result::kDbError, "Invalid value length " + std::to_string(data.value.length()) + " expected " + std::to_string(kHashLength)); } collector_->collect(Entry{Bytes{datastore::kvdb::from_slice(data.value)}, operation_ == OperationType::kForward ? Bytes{datastore::kvdb::from_slice(data.key)} : Bytes{}}); // Do we need to abort ? if (auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); log_time = now + 5s; } ++expected_block_num; data = canon_hashes_cursor->to_next(/*throw_notfound=*/false); } current_phase_ = 2; // Load auto header_numbers_cursor = txn.rw_cursor_dup_sort(db::table::kHeaderNumbers); const MDBX_put_flags_t db_flags{header_numbers_cursor->empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT}; collector_->load(*header_numbers_cursor, nullptr, db_flags); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_blockhashes.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::stagedsync { class BlockHashes final : public Stage { public: explicit BlockHashes(SyncContext* sync_context, datastore::etl::CollectorSettings etl_settings) : Stage(sync_context, silkworm::db::stages::kBlockHashesKey), etl_settings_(std::move(etl_settings)) {} BlockHashes(const BlockHashes&) = delete; // not copyable BlockHashes(BlockHashes&&) = delete; // nor movable ~BlockHashes() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: datastore::etl::CollectorSettings etl_settings_; std::unique_ptr collector_; /* Stats */ std::atomic_uint32_t current_phase_{0}; std::atomic reached_block_num_{0}; void collect_and_load(db::RWTxn& txn, BlockNum from, BlockNum to); // Accrues canonical hashes in collector and loads them }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_bodies.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_bodies.hpp" #include #include #include #include #include #include #include namespace silkworm::stagedsync { BodiesStage::BodyDataModel::BodyDataModel( db::RWTxn& tx, db::DataModel data_model, BlockNum bodies_stage_block_num, const ChainConfig& chain_config) : data_model_(data_model), chain_config_{chain_config}, rule_set_{protocol::rule_set_factory(chain_config)}, chain_state_{tx, std::make_unique(data_model)}, initial_block_num_{bodies_stage_block_num}, max_block_num_{bodies_stage_block_num} { } BlockNum BodiesStage::BodyDataModel::initial_block_num() const { return initial_block_num_; } BlockNum BodiesStage::BodyDataModel::max_block_num() const { return max_block_num_; } bool BodiesStage::BodyDataModel::unwind_needed() const { return unwind_needed_; } BlockNum BodiesStage::BodyDataModel::unwind_point() const { return unwind_point_; } Hash BodiesStage::BodyDataModel::bad_block() const { return bad_block_; } void BodiesStage::BodyDataModel::set_preverified_block_num(BlockNum block_num) { preverified_block_num_ = block_num; } // update_tables has the responsibility to update all tables related with the block that is passed as parameter // Right now there is no table that need to be updated but the name of the method is retained because it makes a pair // with the same method in the HeadersStages::HeaderDataModel class void BodiesStage::BodyDataModel::update_tables(const Block& block) { Hash block_hash = block.header.hash(); // save cpu BlockNum block_num = block.header.number; auto validation_result = ValidationResult::kOk; // Body validation if (block_num > preverified_block_num_) { // Here we skip a full body pre-validation like // validation_result = rule_set_->pre_validate_block_body(block, chain_state_); // because we assume that the sync (BlockExchange) has already checked transaction & ommers root hash validation_result = protocol::pre_validate_transactions(block, chain_config_); if (validation_result == ValidationResult::kOk) { validation_result = rule_set_->validate_ommers(block, chain_state_); } } // There is no need to validate a body if its header is on the chain of the pre-verified hashes. // Note that here we expect: // 1) only bodies on the canonical chain // 2) only bodies whose ommers hashes and transaction root hashes were checked against those // of the headers by the sync (BlockExchange) if (validation_result != ValidationResult::kOk) { unwind_needed_ = true; unwind_point_ = block_num - 1; bad_block_ = block_hash; return; } max_block_num_ = std::max(max_block_num_, block_num); } void BodiesStage::BodyDataModel::close() { // does nothing } void BodiesStage::BodyDataModel::remove_bodies(BlockNum, std::optional, db::RWTxn&) { // we do not erase "wrong" blocks, only stage progress will be updated by bodies stage unwind operation // maybe we should remove only the bad block } bool BodiesStage::BodyDataModel::get_canonical_block(BlockNum block_num, Block& block) const { return data_model_.read_canonical_block(block_num, block); } BodiesStage::BodiesStage( SyncContext* sync_context, const ChainConfig& chain_config, db::DataModelFactory data_model_factory, std::function last_pre_validated_block) : Stage(sync_context, db::stages::kBlockBodiesKey), chain_config_(chain_config), data_model_factory_(std::move(data_model_factory)), last_pre_validated_block_(std::move(last_pre_validated_block)) {} Stage::Result BodiesStage::forward(db::RWTxn& tx) { using std::shared_ptr; using namespace std::chrono_literals; using namespace std::chrono; Stage::Result result = Stage::Result::kUnspecified; operation_ = OperationType::kForward; try { current_block_num_ = db::stages::read_stage_progress(tx, db::stages::kBlockBodiesKey); BlockNum target_block_num = db::stages::read_stage_progress(tx, db::stages::kHeadersKey); if (current_block_num_ == target_block_num) { // Nothing to process return Stage::Result::kSuccess; } if (current_block_num_ > target_block_num) { // Something bad had happened. Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "Previous progress " + std::to_string(current_block_num_) + " > target progress " + std::to_string(target_block_num)); } const BlockNum segment_width{target_block_num - current_block_num_}; if (segment_width > db::stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(current_block_num_), "to", std::to_string(target_block_num), "span", std::to_string(target_block_num - current_block_num_)}); } BodyDataModel body_persistence{ tx, data_model_factory_(tx), current_block_num_, chain_config_, }; body_persistence.set_preverified_block_num(last_pre_validated_block_()); get_log_progress(); // this is a trick to set log progress initial value, please improve RepeatedMeasure block_num_progress(current_block_num_); // block processing while (current_block_num_ < target_block_num && !body_persistence.unwind_needed() && !is_stopping()) { ++current_block_num_; // process header and ommers at current block_num Block block; bool present = body_persistence.get_canonical_block(current_block_num_, block); if (!present) throw std::logic_error("table Bodies has a hole"); body_persistence.update_tables(block); block_num_progress.set(body_persistence.max_block_num()); } db::stages::write_stage_progress(tx, db::stages::kBlockBodiesKey, current_block_num_); result = Stage::Result::kSuccess; // check unwind condition if (body_persistence.unwind_needed()) { result = Stage::Result::kInvalidBlock; sync_context_->unwind_point = body_persistence.unwind_point(); sync_context_->bad_block_hash = body_persistence.bad_block(); log::Info(log_prefix_) << "Unwind needed"; } body_persistence.close(); tx.commit_and_renew(); } catch (const std::exception& e) { log::Error(log_prefix_) << "Forward aborted due to exception: " << e.what(); // tx rollback executed automatically if needed result = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return result; } Stage::Result BodiesStage::unwind(db::RWTxn& tx) { current_block_num_ = db::stages::read_stage_progress(tx, db::stages::kBlockBodiesKey); get_log_progress(); // this is a trick to set log progress initial value, please improve if (!sync_context_->unwind_point.has_value()) return Stage::Result::kSuccess; auto new_block_num = sync_context_->unwind_point.value(); if (current_block_num_ <= new_block_num) return Stage::Result::kSuccess; operation_ = OperationType::kUnwind; const BlockNum segment_width{current_block_num_ - new_block_num}; if (segment_width > db::stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(current_block_num_), "to", std::to_string(new_block_num), "span", std::to_string(segment_width)}); } Stage::Result result{Stage::Result::kSuccess}; try { BodyDataModel::remove_bodies(new_block_num, sync_context_->bad_block_hash, tx); db::stages::write_stage_progress(tx, db::stages::kBlockBodiesKey, new_block_num); current_block_num_ = new_block_num; tx.commit_and_renew(); result = Stage::Result::kSuccess; } catch (const std::exception& e) { log::Error(log_prefix_) << "Unwind aborted due to exception: " << e.what(); // tx rollback executed automatically if needed result = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return result; } Stage::Result BodiesStage::prune(db::RWTxn&) { return Stage::Result::kSuccess; } std::vector BodiesStage::get_log_progress() { // implementation MUST be thread safe if (!is_stopping()) { static RepeatedMeasure block_num_progress{0}; block_num_progress.set(current_block_num_); return {"current block", std::to_string(block_num_progress.get()), "progress", std::to_string(block_num_progress.delta()), "bodies/secs", std::to_string(block_num_progress.throughput())}; } return {}; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_bodies.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { class BodiesStage : public Stage { public: BodiesStage( SyncContext* sync_context, const ChainConfig& chain_config, db::DataModelFactory data_model_factory, std::function last_pre_validated_block); BodiesStage(const BodiesStage&) = delete; // not copyable BodiesStage(BodiesStage&&) = delete; // nor movable ~BodiesStage() override = default; Stage::Result forward(db::RWTxn&) override; // go forward, downloading headers Stage::Result unwind(db::RWTxn&) override; // go backward, unwinding headers to new_block_num Stage::Result prune(db::RWTxn&) override; private: std::vector get_log_progress() override; // thread safe const ChainConfig& chain_config_; db::DataModelFactory data_model_factory_; std::function last_pre_validated_block_; std::atomic current_block_num_{0}; protected: // BodyDataModel has the responsibility to update bodies related tables class BodyDataModel { public: explicit BodyDataModel( db::RWTxn& tx, db::DataModel data_model, BlockNum bodies_stage_block_num, const ChainConfig& chain_config); ~BodyDataModel() = default; void update_tables(const Block&); // make a pre-verification of the body and update body related tables void close(); // remove body data from tables, used in unwind phase static void remove_bodies(BlockNum new_block_num, std::optional bad_block, db::RWTxn& tx); // holds the status of a batch insertion of bodies bool unwind_needed() const; BlockNum unwind_point() const; BlockNum initial_block_num() const; BlockNum max_block_num() const; Hash bad_block() const; bool get_canonical_block(BlockNum block_num, Block& block) const; void set_preverified_block_num(BlockNum block_num); private: db::DataModel data_model_; const ChainConfig& chain_config_; protocol::RuleSetPtr rule_set_; db::Buffer chain_state_; BlockNum initial_block_num_{0}; BlockNum max_block_num_{0}; BlockNum preverified_block_num_{0}; BlockNum unwind_point_{0}; bool unwind_needed_{false}; Hash bad_block_; }; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_bodies_factory.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::stagedsync { class BodiesStage; struct SyncContext; using BodiesStageFactory = std::function(SyncContext*)>; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_bodies_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_bodies.hpp" #include #include #include #include #include #include #include namespace silkworm { class BodiesStageForTest : public stagedsync::BodiesStage { public: using stagedsync::BodiesStage::BodyDataModel; }; using BodyDataModelForTest = BodiesStageForTest::BodyDataModel; TEST_CASE("BodiesStage - data model") { db::test_util::TempChainDataStore context; context.add_genesis_data(); context.commit_txn(); datastore::kvdb::RWAccess chaindata = context.chaindata_rw(); auto data_model_factory = context.data_model_factory(); auto& chain_config = context.chain_config(); /* status: * h0 * input: * h0 <----- h1 */ SECTION("one invalid body after the genesis") { auto tx = chaindata.start_rw_tx(); db::DataModel data_model = data_model_factory(tx); auto header0_hash = db::read_canonical_header_hash(tx, 0); REQUIRE(header0_hash.has_value()); auto header0 = db::read_canonical_header(tx, 0); REQUIRE(header0.has_value()); Block block1; block1.header.number = 1; block1.header.difficulty = 17'171'480'576; // a random value block1.header.parent_hash = *header0_hash; auto header1_hash = block1.header.hash(); block1.ommers.push_back(BlockHeader{}); // generate error InvalidOmmerHeader BlockNum bodies_stage_block_num = 0; BodyDataModelForTest bm{ tx, data_model, bodies_stage_block_num, chain_config, }; REQUIRE(bm.initial_block_num() == 0); REQUIRE(bm.max_block_num() == 0); REQUIRE(bm.unwind_needed() == false); REQUIRE(bm.unwind_point() == 0); bm.update_tables(block1); // check internal status REQUIRE(bm.max_block_num() == 0); // block is not valid so no progress REQUIRE(bm.unwind_needed() == true); // block is not valid -> unwind REQUIRE(bm.unwind_point() == 0); // block-num - 1 REQUIRE(bm.bad_block() == header1_hash); bm.close(); } SECTION("one valid body after the genesis") { auto tx = chaindata.start_rw_tx(); db::DataModel data_model = data_model_factory(tx); auto header0_hash = db::read_canonical_header_hash(tx, 0); REQUIRE(header0_hash.has_value()); auto header0 = db::read_canonical_header(tx, 0); REQUIRE(header0.has_value()); std::string raw_header1 = "f90211a0d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3a01dcc4de8dec75d7aab85b567b6ccd41a" "d312451b948a7413f0a142fd40d493479405a56e2d52c817161883f50c441c3228cfe54d9fa0d67e4d450343046425ae4271474353" "857ab860dbc0a1dde64b41b5cd3a532bf3a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e8" "1f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000008503ff80000001821388808455ba422499476574682f76312e302e302f" "6c696e75782f676f312e342e32a0969b900de27b6ac6a67742365dd65f55a0526c41fd18e1b16f1a1215c2e66f5988539bd4979fef" "1ec4"; std::optional encoded_header1 = from_hex(raw_header1); Block block1; ByteView encoded_view = encoded_header1.value(); auto decoding_result = rlp::decode(encoded_view, block1.header); // Note: block1 has zero transactions and zero ommers on mainnet REQUIRE(decoding_result); BlockNum bodies_stage_block_num = 0; BodyDataModelForTest bm{ tx, data_model, bodies_stage_block_num, chain_config, }; // check internal status REQUIRE(bm.initial_block_num() == 0); REQUIRE(bm.max_block_num() == 0); REQUIRE(bm.unwind_needed() == false); REQUIRE(bm.unwind_point() == 0); bm.update_tables(block1); // validation must pass // check internal status REQUIRE(bm.max_block_num() == 1); REQUIRE(bm.unwind_needed() == false); REQUIRE(bm.unwind_point() == 0); // close bm.close(); } } } // namespace silkworm ================================================ FILE: silkworm/node/stagedsync/stages/stage_call_trace_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_call_trace_index.hpp" #include namespace silkworm::stagedsync { using namespace silkworm::db; using namespace silkworm::datastore::kvdb; CallTraceIndex::CallTraceIndex(SyncContext* sync_context, size_t batch_size, datastore::etl::CollectorSettings etl_settings, BlockAmount prune_mode) : Stage(sync_context, stages::kCallTracesKey), batch_size_{batch_size}, etl_settings_{std::move(etl_settings)}, prune_mode_{prune_mode} {} Stage::Result CallTraceIndex::forward(RWTxn& txn) { Stage::Result result{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution auto previous_progress{get_progress(txn)}; const auto target_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress == target_progress) { // Nothing to process operation_ = OperationType::kNone; return result; } if (previous_progress > target_progress) { // Something bad had happened. Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "CallTraceIndex progress " + std::to_string(previous_progress) + " greater than Execution progress " + std::to_string(target_progress)); } reset_log_progress(); const BlockNum segment_width{target_progress - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(target_progress), "span", std::to_string(segment_width)}); } // If this is first time and prune mode is set, do not process all blocks rather only what is needed if (prune_mode_.enabled() && !previous_progress) { previous_progress = prune_mode_.value_from_head(target_progress); } if (previous_progress < target_progress) { forward_impl(txn, previous_progress, target_progress); } reset_log_progress(); update_progress(txn, target_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); result = Stage::Result::kUnexpectedError; } call_from_collector_.reset(); call_to_collector_.reset(); operation_ = OperationType::kNone; return result; } Stage::Result CallTraceIndex::unwind(RWTxn& txn) { Stage::Result result{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) { return result; } const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto execution_stage_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress <= to || execution_stage_progress <= to) { // Nothing to process operation_ = OperationType::kNone; return result; } reset_log_progress(); const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } if (previous_progress && previous_progress > to) { unwind_impl(txn, previous_progress, to); } reset_log_progress(); update_progress(txn, to); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); result = Stage::Result::kUnexpectedError; } call_from_collector_.reset(); call_to_collector_.reset(); operation_ = OperationType::kNone; return result; } Stage::Result CallTraceIndex::prune(RWTxn& txn) { Stage::Result result{Stage::Result::kSuccess}; operation_ = OperationType::kPrune; try { throw_if_stopping(); if (!prune_mode_.enabled()) { operation_ = OperationType::kNone; return result; } const auto forward_progress{get_progress(txn)}; const auto prune_progress{get_prune_progress(txn)}; if (prune_progress >= forward_progress) { operation_ = OperationType::kNone; return result; } // Need to erase all info below this threshold. If threshold is zero we don't have anything to prune const auto prune_threshold{prune_mode_.value_from_head(forward_progress)}; if (!prune_threshold) { operation_ = OperationType::kNone; return result; } reset_log_progress(); const BlockNum segment_width{forward_progress - prune_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } if (!prune_progress || prune_progress < forward_progress) { prune_impl(txn, prune_threshold, table::kCallFromIndex); prune_impl(txn, prune_threshold, table::kCallToIndex); } reset_log_progress(); stages::write_stage_prune_progress(txn, stage_name_, forward_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); result = Stage::Result::kUnexpectedError; } call_from_collector_.reset(); call_to_collector_.reset(); operation_ = OperationType::kNone; return result; } void CallTraceIndex::forward_impl(RWTxn& txn, const BlockNum from, const BlockNum to) { const MapConfig source_config{table::kCallTraceSet}; std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kForward; loading_ = false; call_from_collector_ = std::make_unique(etl_settings_); call_to_collector_ = std::make_unique(etl_settings_); current_source_ = std::string(source_config.name); current_target_.clear(); current_key_.clear(); log_lck.unlock(); // Into etl collectors collect_bitmaps_from_call_traces(txn, source_config, from, to); log_lck.lock(); loading_ = true; current_key_.clear(); current_target_ = table::kCallFromIndex.name; index_loader_ = std::make_unique(table::kCallFromIndex); log_lck.unlock(); index_loader_->merge_bitmaps(txn, kAddressLength, call_from_collector_.get()); log_lck.lock(); current_key_.clear(); current_target_ = table::kCallToIndex.name; index_loader_ = std::make_unique(table::kCallToIndex); log_lck.unlock(); index_loader_->merge_bitmaps(txn, kAddressLength, call_to_collector_.get()); log_lck.lock(); loading_ = false; current_target_.clear(); index_loader_.reset(); log_lck.unlock(); } void CallTraceIndex::unwind_impl(RWTxn& txn, BlockNum from, BlockNum to) { const MapConfig source_config{table::kCallTraceSet}; std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kUnwind; loading_ = false; current_source_ = std::string(source_config.name); current_key_.clear(); log_lck.unlock(); std::map call_from_keys; std::map call_to_keys; collect_unique_keys_from_call_traces(txn, source_config, from, to, call_from_keys, call_to_keys); log_lck.lock(); current_target_ = table::kCallFromIndex.name; index_loader_ = std::make_unique(table::kCallFromIndex); log_lck.unlock(); index_loader_->unwind_bitmaps(txn, to, call_from_keys); log_lck.lock(); current_target_ = table::kCallToIndex.name; index_loader_ = std::make_unique(table::kCallToIndex); log_lck.unlock(); index_loader_->unwind_bitmaps(txn, to, call_to_keys); log_lck.lock(); index_loader_.reset(); current_source_.clear(); current_target_.clear(); current_key_.clear(); log_lck.unlock(); } void CallTraceIndex::collect_bitmaps_from_call_traces(RWTxn& txn, const MapConfig& source_config, BlockNum from, BlockNum to) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; const BlockNum max_block_num{to}; BlockNum reached_block_num{0}; absl::btree_map call_from_bitmaps; absl::btree_map call_to_bitmaps; size_t call_from_bitmaps_size{0}; size_t call_to_bitmaps_size{0}; uint16_t call_from_flush_count{0}; uint16_t call_to_flush_count{0}; const auto start_key{block_key(from + 1)}; const auto source = txn.ro_cursor(source_config); auto source_data{source->lower_bound(to_slice(start_key), false)}; while (source_data) { reached_block_num = endian::load_big_u64(static_cast(source_data.key.data())); if (reached_block_num > max_block_num) break; // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } // Check expected value format ByteView value{static_cast(source_data.value.data()), source_data.value.length()}; ensure(value.size() == kAddressLength + 1, [&] { return "Unexpected value in CallTraceSet: " + to_hex(value); }); // Decode value as address|from_or_to_or_both and distribute it to the 2 bitmaps Bytes address{value.substr(0, kAddressLength)}; if (value[kAddressLength] & 1) { auto it{call_from_bitmaps.find(address)}; if (it == call_from_bitmaps.end()) { it = call_from_bitmaps.emplace(address, roaring::Roaring64Map()).first; call_from_bitmaps_size += kAddressLength + sizeof(uint64_t); } it->second.add(reached_block_num); call_from_bitmaps_size += sizeof(uint64_t); } if (value[kAddressLength] & 2) { auto it{call_to_bitmaps.find(address)}; if (it == call_to_bitmaps.end()) { it = call_to_bitmaps.emplace(address, roaring::Roaring64Map()).first; call_to_bitmaps_size += kAddressLength + sizeof(uint64_t); } it->second.add(reached_block_num); call_to_bitmaps_size += sizeof(uint64_t); } // Flush bitmaps batch by batch if (call_from_bitmaps_size > batch_size_) { bitmap::IndexLoader::flush_bitmaps_to_etl(call_from_bitmaps, call_from_collector_.get(), call_from_flush_count++); call_from_bitmaps_size = 0; } if (call_to_bitmaps_size > batch_size_) { bitmap::IndexLoader::flush_bitmaps_to_etl(call_to_bitmaps, call_to_collector_.get(), call_to_flush_count++); call_to_bitmaps_size = 0; } source_data = source->to_next(/*throw_notfound=*/false); } // Flush remaining portion of bitmaps (if any) bitmap::IndexLoader::flush_bitmaps_to_etl(call_from_bitmaps, call_from_collector_.get(), call_from_flush_count); bitmap::IndexLoader::flush_bitmaps_to_etl(call_to_bitmaps, call_to_collector_.get(), call_to_flush_count); } void CallTraceIndex::collect_unique_keys_from_call_traces(RWTxn& txn, const MapConfig& source_config, BlockNum from, BlockNum to, std::map& senders, std::map& receivers) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; BlockNum expected_block_num{std::min(from, to) + 1}; const BlockNum max_block_num{std::max(from, to)}; BlockNum reached_block_num{0}; const auto start_key{block_key(expected_block_num)}; const auto source = txn.ro_cursor(source_config); auto source_data{source->lower_bound(to_slice(start_key), false)}; while (source_data) { reached_block_num = endian::load_big_u64(static_cast(source_data.key.data())); if (reached_block_num > max_block_num) break; // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } // Check expected value format ByteView value{static_cast(source_data.value.data()), source_data.value.length()}; ensure(value.size() == kAddressLength + 1, [&] { return "Unexpected value in CallTraceSet: " + to_hex(value); }); // Decode value as address|from_or_to_or_both Bytes address{value.substr(0, kAddressLength)}; if (value[kAddressLength] & 1) { (void)senders.try_emplace(address, false); } if (value[kAddressLength] & 2) { (void)receivers.try_emplace(address, false); } source_data = source->to_next(/*throw_notfound=*/false); } } void CallTraceIndex::prune_impl(RWTxn& txn, BlockNum threshold, const MapConfig& target) { std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kPrune; loading_ = false; current_source_ = target.name; current_target_ = current_source_; current_key_.clear(); index_loader_ = std::make_unique(target); log_lck.unlock(); index_loader_->prune_bitmaps(txn, threshold); log_lck.lock(); index_loader_.reset(); current_source_.clear(); current_target_.clear(); current_key_.clear(); log_lck.unlock(); } std::vector CallTraceIndex::get_log_progress() { std::vector ret{"op", std::string(magic_enum::enum_name(operation_))}; std::unique_lock log_lck(sl_mutex_); if (current_source_.empty() && current_target_.empty()) { ret.insert(ret.end(), {"db", "waiting ..."}); } else { switch (operation_) { case OperationType::kForward: if (loading_) { if (current_target_ == table::kCallFromIndex.name && call_from_collector_) { current_key_ = abridge(call_from_collector_->get_load_key(), kAddressLength); } else if (current_target_ == table::kCallToIndex.name && call_to_collector_) { current_key_ = abridge(call_to_collector_->get_load_key(), kAddressLength); } else { current_key_.clear(); } ret.insert(ret.end(), {"from", "ETL", "to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "to", "ETL", "key", current_key_}); } break; case OperationType::kUnwind: if (index_loader_) { current_key_ = index_loader_->get_current_key(); ret.insert(ret.end(), {"from", "ETL", "to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "to", "ETL", "key", current_key_}); } break; case OperationType::kPrune: if (index_loader_) { current_key_ = index_loader_->get_current_key(); ret.insert(ret.end(), {"to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"to", current_target_, current_key_}); } break; default: ret.insert(ret.end(), {"from", current_source_, "key", current_key_}); } } return ret; } void CallTraceIndex::reset_log_progress() { std::unique_lock log_lck(sl_mutex_); loading_ = false; current_source_.clear(); current_target_.clear(); current_key_.clear(); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_call_trace_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::stagedsync { class CallTraceIndex : public Stage { public: CallTraceIndex(SyncContext* sync_context, size_t batch_size, datastore::etl::CollectorSettings etl_settings, db::BlockAmount prune_mode); CallTraceIndex(const CallTraceIndex&) = delete; // not copyable CallTraceIndex(CallTraceIndex&&) = delete; // nor movable ~CallTraceIndex() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: void forward_impl(db::RWTxn& txn, BlockNum from, BlockNum to); void unwind_impl(db::RWTxn& txn, BlockNum from, BlockNum to); void prune_impl(db::RWTxn& txn, BlockNum threshold, const db::MapConfig& target); //! \brief Collect bitmaps of block numbers for each call trace entry void collect_bitmaps_from_call_traces( db::RWTxn& txn, const db::MapConfig& source_config, BlockNum from, BlockNum to); //! \brief Collect unique keys for call trace entries within provided boundaries void collect_unique_keys_from_call_traces( db::RWTxn& txn, const db::MapConfig& source_config, BlockNum from, BlockNum to, std::map& senders, std::map& receivers); void reset_log_progress(); // Clears out all logging vars size_t batch_size_; datastore::etl::CollectorSettings etl_settings_; db::BlockAmount prune_mode_; std::unique_ptr call_from_collector_; std::unique_ptr call_to_collector_; std::unique_ptr index_loader_; //! Flag indicating if we're in ETL loading phase (for logging purposes) std::atomic_bool loading_{false}; //! Current source of data (for logging purposes) std::string current_source_; //! Current target of transformed data (for logging purposes) std::string current_target_; //! Actual processing key (for logging purposes) std::string current_key_; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_execution.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_execution.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; using namespace silkworm::datastore::kvdb; Stage::Result Execution::forward(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); if (!rule_set_) { throw StageError(Stage::Result::kUnknownProtocolRuleSet); } StopWatch commit_stopwatch; // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto senders_stage_progress{stages::read_stage_progress(txn, stages::kSendersKey)}; // This is next stage probably needing full history const auto hashstate_stage_progress{stages::read_stage_progress(txn, stages::kHashStateKey)}; if (previous_progress == senders_stage_progress) { // Nothing to process operation_ = OperationType::kNone; return ret; } if (previous_progress > senders_stage_progress) { // Something bad had happened. Not possible execution stage is ahead of senders // Maybe we need to unwind ? std::string what{"Bad progress sequence. Execution stage progress " + std::to_string(previous_progress) + " while Senders stage " + std::to_string(senders_stage_progress)}; throw StageError(Stage::Result::kInvalidProgress, what); } std::unique_lock progress_lock(progress_mtx_); processed_blocks_ = 0; processed_transactions_ = 0; processed_gas_ = 0; lap_time_ = std::chrono::steady_clock::now(); progress_lock.unlock(); block_num_ = previous_progress + 1; const auto stop_at_block = Environment::get_stop_at_block(); const BlockNum max_block_num{stop_at_block ? *stop_at_block : senders_stage_progress}; const BlockNum segment_width{max_block_num - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(max_block_num), "span", std::to_string(segment_width)}); } // Determine pruning thresholds on behalf of current db pruning mode and verify next stage(s) does not need // prune-able data BlockNum prune_history{prune_mode_.history().value_from_head(max_block_num)}; BlockNum prune_receipts{prune_mode_.receipts().value_from_head(max_block_num)}; BlockNum prune_call_traces{prune_mode_.call_traces().value_from_head(max_block_num)}; if (hashstate_stage_progress) { prune_history = std::min(prune_history, hashstate_stage_progress - 1); prune_receipts = std::min(prune_receipts, hashstate_stage_progress - 1); prune_call_traces = std::min(prune_call_traces, hashstate_stage_progress - 1); } static constexpr size_t kCacheSize{5'000}; AnalysisCache analysis_cache{kCacheSize}; prefetched_blocks_.clear(); while (block_num_ <= max_block_num) { throw_if_stopping(); const auto execution_result{execute_batch(txn, max_block_num, analysis_cache, prune_history, prune_receipts, prune_call_traces)}; // If we return with success we must persist data. Though counterintuitive, we must also persist on // kInvalidBlock to save good progress done so far: the subsequent unwind will remove last invalid updates if (execution_result != Stage::Result::kSuccess && execution_result != Stage::Result::kInvalidBlock) { throw StageError(execution_result); } // Persist forward and prune progresses update_progress(txn, block_num_); if (prune_mode_.history().enabled() || prune_mode_.receipts().enabled()) { stages::write_stage_prune_progress(txn, stages::kExecutionKey, block_num_); } (void)commit_stopwatch.start(/*with_reset=*/true); txn.commit_and_renew(); auto [_, duration]{commit_stopwatch.stop()}; SILK_INFO_M(log_prefix_ + " commit", {"batch time", StopWatch::format(duration)}); // If we got an invalid block, now after persisting we can exit if (execution_result == Stage::Result::kInvalidBlock) { ret = execution_result; break; } ++block_num_; } } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } void Execution::prefetch_blocks(RWTxn& txn, const BlockNum from, const BlockNum to) { std::unique_ptr sw; if (log::test_verbosity(log::Level::kTrace)) { sw = std::make_unique(/*auto_start=*/true); } SILKWORM_ASSERT(prefetched_blocks_.empty()); const size_t count{std::min(static_cast(to - from + 1), kMaxPrefetchedBlocks)}; size_t num_read{0}; DataModel data_model = data_model_factory_(txn); auto canonicals = txn.ro_cursor(table::kCanonicalHashes); Bytes starting_key{block_key(from)}; if (canonicals->seek(to_slice(starting_key))) { BlockNum block_num{from}; auto walk_function{[&](ByteView key, ByteView value) { BlockNum reached_block_num{endian::load_big_u64(key.data())}; if (reached_block_num != block_num) { throw std::runtime_error("Bad canonical header sequence: expected " + std::to_string(block_num) + " got " + std::to_string(reached_block_num)); } if (value.size() != kHashLength) { throw std::runtime_error("Invalid value for hash in " + std::string(table::kCanonicalHashes.name) + " expected=" + std::to_string(kHashLength) + " got=" + std::to_string(value.size())); } const auto hash_ptr{value.data()}; prefetched_blocks_.push_back(); if (!data_model.read_block(std::span{hash_ptr, kHashLength}, block_num, /*read_senders=*/true, prefetched_blocks_.back())) { throw std::runtime_error("Unable to read block " + std::to_string(block_num)); } ++block_num; }}; num_read = cursor_for_count(*canonicals, walk_function, count); } if (num_read != count) { throw std::runtime_error("Missing block " + std::to_string(from + num_read)); } if (sw) { auto [_, duration]{sw->lap()}; SILK_TRACE_M("Fetched blocks", {"size", std::to_string(num_read), "in", StopWatch::format(duration)}); } } Stage::Result Execution::execute_batch(RWTxn& txn, BlockNum max_block_num, AnalysisCache& analysis_cache, BlockNum prune_history_threshold, BlockNum prune_receipts_threshold, BlockNum prune_call_traces_threshold) { Result ret{Result::kSuccess}; using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; try { Buffer buffer{txn, std::make_unique(data_model_factory_(txn))}; buffer.set_prune_history_threshold(prune_history_threshold); buffer.set_memory_limit(batch_size_); std::vector receipts; { std::unique_lock progress_lock(progress_mtx_); lap_time_ = std::chrono::steady_clock::now(); } while (block_num_ <= max_block_num) { if (prefetched_blocks_.empty()) { throw_if_stopping(); prefetch_blocks(txn, block_num_, max_block_num); } const Block& block{prefetched_blocks_.front()}; check_block_sequence(block.header.number, block_num_); // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); log_time = now + 5s; } const bool write_receipts = block_num_ >= prune_receipts_threshold; const bool write_traces = block_num_ >= prune_call_traces_threshold; static constexpr bool kWriteChangeSets = true; execution::block::BlockExecutor executor{&chain_config_, write_receipts, write_traces, kWriteChangeSets}; try { if (const ValidationResult res = executor.execute_single(block, buffer, analysis_cache); res != ValidationResult::kOk) { // Flush work done so far not to lose progress up to the previous valid block and to correctly trigger unwind // This requires to commit in Execution::forward also for kInvalidBlock: unwind will remove last invalid block updates if (write_receipts) { buffer.insert_receipts(block_num_, receipts); } buffer.write_to_db(); // Notify sync_loop we need to unwind sync_context_->unwind_point.emplace(block_num_ - 1u); sync_context_->bad_block_hash.emplace(block.header.hash()); SILK_ERROR_M(log_prefix_, {"block", std::to_string(block_num_), "hash", to_hex(block.header.hash().bytes, true), "error", std::string(magic_enum::enum_name(res))}); prefetched_blocks_.clear(); // Must stay here to keep `block` reference valid return Result::kInvalidBlock; } } catch (const Buffer::MemoryLimitError&) { // batch done break; } // Stats std::unique_lock progress_lock(progress_mtx_); ++processed_blocks_; processed_transactions_ += block.transactions.size(); processed_gas_ += block.header.gas_used; progress_lock.unlock(); prefetched_blocks_.pop_front(); ++block_num_; } // update block_num_ to point to the last successfully executed block --block_num_; SILK_TRACE_M(log_prefix_, {"buffer", "state", "size", human_size(buffer.current_batch_state_size())}); buffer.write_to_db(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const DecodingException& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "decoding error", std::string(ex.what())}); return Stage::Result::kDecodingError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result Execution::unwind(RWTxn& txn) { static const MapConfig kUnwindTables[5] = { table::kAccountChangeSet, table::kStorageChangeSet, table::kBlockReceipts, table::kLogs, table::kCallTraceSet, }; Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { BlockNum previous_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (to >= previous_progress) { operation_ = OperationType::kNone; return Stage::Result::kSuccess; } operation_ = OperationType::kUnwind; const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } { // Revert states auto plain_state_cursor = txn.rw_cursor_dup_sort(table::kPlainState); auto plain_code_cursor = txn.rw_cursor(table::kPlainCodeHash); auto account_changeset_cursor = txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto storage_changeset_cursor = txn.ro_cursor_dup_sort(table::kStorageChangeSet); unwind_state_from_changeset(*account_changeset_cursor, *plain_state_cursor, *plain_code_cursor, to); unwind_state_from_changeset(*storage_changeset_cursor, *plain_state_cursor, *plain_code_cursor, to); } // Delete records which has keys greater than unwind point // Note erasing forward the start key is included that's why we increase unwind_point by 1 Bytes start_key{block_key(to + 1)}; for (const auto& map_config : kUnwindTables) { auto unwind_cursor = txn.rw_cursor(map_config); auto erased{cursor_erase(*unwind_cursor, start_key, CursorMoveDirection::kForward)}; SILK_INFO << "Erased " << erased << " records from " << map_config.name; } stages::write_stage_progress(txn, stages::kExecutionKey, to); txn.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result Execution::prune(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kPrune; std::unique_ptr stop_watch; if (log::test_verbosity(log::Level::kTrace)) { stop_watch = std::make_unique(true); } try { if (!prune_mode_.history().enabled() && !prune_mode_.receipts().enabled() && !prune_mode_.call_traces().enabled()) { operation_ = OperationType::kNone; return ret; } BlockNum forward_progress{get_progress(txn)}; BlockNum prune_progress{get_prune_progress(txn)}; if (prune_progress >= forward_progress) { operation_ = OperationType::kNone; return ret; } const BlockNum segment_width{forward_progress - prune_progress}; // Prune history of changes (changesets) if (const auto prune_threshold{prune_mode_.history().value_from_head(forward_progress)}; prune_threshold) { if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "source", "history", "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } auto key{block_key(prune_threshold)}; size_t erased{0}; auto source = txn.rw_cursor_dup_sort(table::kAccountChangeSet); auto data{source->lower_bound(to_slice(key), /*throw_notfound=*/false)}; while (data) { erased += source->count_multivalue(); source->erase(/*whole_multivalue=*/true); data = source->to_previous(/*throw_notfound=*/false); } if (stop_watch) { const auto [_, duration] = stop_watch->lap(); SILK_TRACE_M(log_prefix_, {"source", table::kAccountChangeSet.name_str(), "erased", std::to_string(erased), "elapsed", StopWatch::format(duration)}); } source->bind(txn, table::kStorageChangeSet); data = source->lower_bound(to_slice(key), /*throw_notfound=*/false); while (data) { auto data_value_view{from_slice(data.value)}; if (endian::load_big_u64(data_value_view.data()) < prune_threshold) { erased += source->count_multivalue(); source->erase(/*whole_multivalue=*/true); } data = source->to_previous(/*throw_notfound=*/false); } if (stop_watch) { const auto [_, duration] = stop_watch->lap(); SILK_TRACE_M(log_prefix_, {"source", table::kStorageChangeSet.name_str(), "erased", std::to_string(erased), "elapsed", StopWatch::format(duration)}); } } // Prune receipts if (const auto prune_threshold{prune_mode_.receipts().value_from_head(forward_progress)}; prune_threshold) { if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "source", "receipts", "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } auto key{block_key(prune_threshold)}; auto source = txn.rw_cursor(table::kBlockReceipts); size_t erased = cursor_erase(*source, key, CursorMoveDirection::kReverse); if (stop_watch) { const auto [_, duration] = stop_watch->lap(); SILK_TRACE_M(log_prefix_, {"source", table::kBlockReceipts.name_str(), "erased", std::to_string(erased), "elapsed", StopWatch::format(duration)}); } source->bind(txn, table::kLogs); erased = cursor_erase(*source, key, CursorMoveDirection::kReverse); if (stop_watch) { const auto [_, duration] = stop_watch->lap(); SILK_TRACE_M(log_prefix_, {"source", table::kLogs.name_str(), "erased", std::to_string(erased), "elapsed", StopWatch::format(duration)}); } } // Prune call traces if (const auto prune_threshold{prune_mode_.call_traces().value_from_head(forward_progress)}; prune_threshold) { if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "source", "call traces", "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } auto key{block_key(prune_threshold)}; auto source = txn.rw_cursor_dup_sort(table::kCallTraceSet); size_t erased = cursor_erase(*source, key, CursorMoveDirection::kReverse); if (stop_watch) { const auto [_, duration] = stop_watch->lap(); SILK_TRACE_M(log_prefix_, {"source", table::kCallTraceSet.name_str(), "erased", std::to_string(erased), "elapsed", StopWatch::format(duration)}); } } stages::write_stage_prune_progress(txn, stages::kExecutionKey, forward_progress); txn.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } std::vector Execution::get_log_progress() { std::unique_lock progress_lock(progress_mtx_); auto now{std::chrono::steady_clock::now()}; auto elapsed{now - lap_time_}; lap_time_ = now; auto elapsed_seconds = static_cast(std::chrono::duration_cast(elapsed).count()); if (!elapsed_seconds || !processed_blocks_) { return {"block", std::to_string(block_num_), "db", "waiting ..."}; } auto speed_blocks = processed_blocks_ / elapsed_seconds; auto speed_transactions = processed_transactions_ / elapsed_seconds; auto speed_mgas = processed_gas_ / elapsed_seconds / 1'000'000; processed_blocks_ = 0; processed_transactions_ = 0; processed_gas_ = 0; progress_lock.unlock(); return {"block", std::to_string(block_num_), "blocks/s", std::to_string(speed_blocks), "txns/s", std::to_string(speed_transactions), "Mgas/s", std::to_string(speed_mgas)}; } void Execution::revert_state(ByteView key, ByteView value, RWCursorDupSort& plain_state_table, RWCursor& plain_code_table) { if (key.size() == kAddressLength) { if (!value.empty()) { const auto account_res = db::state::AccountCodec::from_encoded_storage(value); SILKWORM_ASSERT(account_res); Account account{*account_res}; // Recover the account contract hash if (account.incarnation > 0 && account.code_hash == kEmptyHash) { Bytes code_hash_key(kAddressLength + kIncarnationLength, '\0'); std::memcpy(&code_hash_key[0], &key[0], kAddressLength); endian::store_big_u64(&code_hash_key[kAddressLength], account.incarnation); const auto new_code_hash = plain_code_table.find(to_slice(code_hash_key), /*throw_notfound=*/false); if (new_code_hash.done) { SILKWORM_ASSERT(new_code_hash.value.size() >= kHashLength); std::memcpy(&account.code_hash.bytes[0], new_code_hash.value.data(), kHashLength); } } // cleaning up contract codes auto state_account_encoded{plain_state_table.find(to_slice(key), /*throw_notfound=*/false)}; if (state_account_encoded) { const auto state_incarnation = db::state::AccountCodec::incarnation_from_encoded_storage(from_slice(state_account_encoded.value)); SILKWORM_ASSERT(state_incarnation); // Cleanup each code incarnation for (uint64_t i = *state_incarnation; i > account.incarnation; --i) { Bytes storage_key = storage_prefix(key, i); plain_code_table.erase(to_slice(storage_key)); } } Bytes new_encoded_account = db::state::AccountCodec::encode_for_storage(account); plain_state_table.erase(to_slice(key), /*whole_multivalue=*/true); plain_state_table.upsert(to_slice(key), to_slice(new_encoded_account)); } else { plain_state_table.erase(to_slice(key)); } return; } auto location{key.substr(kAddressLength + kIncarnationLength)}; auto key1{key.substr(0, kAddressLength + kIncarnationLength)}; if (find_value_suffix(plain_state_table, key1, location) != std::nullopt) { plain_state_table.erase(); } if (!value.empty()) { Bytes data{location}; data.append(value); plain_state_table.upsert(to_slice(key1), to_slice(data)); } } void Execution::unwind_state_from_changeset(ROCursor& source_changeset, RWCursorDupSort& plain_state_table, RWCursor& plain_code_table, BlockNum unwind_to) { auto src_data{source_changeset.to_last(/*throw_notfound*/ false)}; while (src_data) { auto key(from_slice(src_data.key)); auto value(from_slice(src_data.value)); if (const auto block_num{endian::load_big_u64(&key[0])}; block_num <= unwind_to) { break; } auto [new_key, new_value]{changeset_to_plainstate_format(key, value)}; revert_state(new_key, new_value, plain_state_table, plain_code_table); src_data = source_changeset.to_previous(/*throw_notfound*/ false); } } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_execution.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::stagedsync { class Execution final : public Stage { public: Execution( SyncContext* sync_context, db::DataModelFactory data_model_factory, const ChainConfig& chain_config, size_t batch_size, db::PruneMode prune_mode) : Stage(sync_context, db::stages::kExecutionKey), data_model_factory_(std::move(data_model_factory)), chain_config_(chain_config), batch_size_(batch_size), prune_mode_(prune_mode), rule_set_{protocol::rule_set_factory(chain_config)} {} ~Execution() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: static constexpr size_t kMaxPrefetchedBlocks{10240}; db::DataModelFactory data_model_factory_; const ChainConfig& chain_config_; size_t batch_size_; db::PruneMode prune_mode_; protocol::RuleSetPtr rule_set_; BlockNum block_num_{0}; boost::circular_buffer prefetched_blocks_{/*buffer_capacity=*/kMaxPrefetchedBlocks}; //! \brief Prefetches blocks for processing //! \param [in] from: the first block to prefetch (inclusive) //! \param [in] to: the last block to prefetch (inclusive) //! \remarks The amount of blocks to be fetched is determined by the upper block number (to) //! or kMaxPrefetchedBlocks collected, whichever comes first void prefetch_blocks(db::RWTxn& txn, BlockNum from, BlockNum to); //! \brief Executes a batch of blocks //! \remarks A batch completes when either max block is reached or buffer dimensions overflow Stage::Result execute_batch(db::RWTxn& txn, BlockNum max_block_num, AnalysisCache& analysis_cache, BlockNum prune_history_threshold, BlockNum prune_receipts_threshold, BlockNum prune_call_traces_threshold); //! \brief For given changeset cursor/bucket it reverts the changes on states buckets static void unwind_state_from_changeset(datastore::kvdb::ROCursor& source_changeset, datastore::kvdb::RWCursorDupSort& plain_state_table, datastore::kvdb::RWCursor& plain_code_table, BlockNum unwind_to); //! \brief Revert State for given address/storage location static void revert_state(ByteView key, ByteView value, datastore::kvdb::RWCursorDupSort& plain_state_table, datastore::kvdb::RWCursor& plain_code_table); // Stats std::mutex progress_mtx_; // Synchronizes access to progress stats std::chrono::time_point lap_time_{std::chrono::steady_clock::now()}; size_t processed_blocks_{0}; size_t processed_transactions_{0}; size_t processed_gas_{0}; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_finish.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_finish.hpp" #include #include #include namespace silkworm::stagedsync { Stage::Result Finish::forward(db::RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto execution_stage_progress{db::stages::read_stage_progress(txn, db::stages::kExecutionKey)}; if (previous_progress >= execution_stage_progress) { // Nothing to process return ret; } const BlockNum segment_width{execution_stage_progress - previous_progress}; if (segment_width > db::stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(execution_stage_progress), "span", std::to_string(segment_width)}); } throw_if_stopping(); update_progress(txn, execution_stage_progress); // Log the new version of app at this block_num if (sync_context_->is_first_cycle) { Bytes build_info{byte_ptr_cast(build_info_.data()), build_info_.size()}; db::write_build_info_block_num(txn, build_info, execution_stage_progress); } txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result Finish::unwind(db::RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); auto previous_progress{db::stages::read_stage_progress(txn, stage_name_)}; if (to >= previous_progress) return ret; const BlockNum segment_width{previous_progress - to}; if (segment_width > db::stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } throw_if_stopping(); update_progress(txn, to); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_finish.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::stagedsync { class Finish : public Stage { public: explicit Finish(SyncContext* sync_context, std::string build_info) : Stage(sync_context, db::stages::kFinishKey), build_info_(std::move(build_info)) {} ~Finish() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; // Finish does not prune. Stage::Result prune(db::RWTxn&) final { return Stage::Result::kSuccess; }; private: std::string build_info_; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_hashstate.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_hashstate.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; using datastore::kvdb::from_slice; using datastore::kvdb::to_slice; using silkworm::datastore::etl::Entry; Stage::Result HashState::forward(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto execution_stage_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress == execution_stage_progress) { // Nothing to process return ret; } if (previous_progress > execution_stage_progress) { // Something bad had happened. Not possible execution stage is ahead of bodies // Maybe we need to unwind ? std::string what{std::string(stage_name_) + " progress " + std::to_string(previous_progress) + " while " + std::string(stages::kExecutionKey) + " stage " + std::to_string(execution_stage_progress)}; throw StageError(Stage::Result::kInvalidProgress, what); } const BlockNum segment_width{execution_stage_progress - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(execution_stage_progress), "span", std::to_string(segment_width)}); } reset_log_progress(); collector_ = std::make_unique(etl_settings_); if (!previous_progress || segment_width > stages::kLargeBlockSegmentWorthRegen) { // Clear any previous contents SILK_INFO_M(log_prefix_, {"clearing", table::kHashedAccounts.name_str()}); txn->clear_map(table::kHashedAccounts.name_str()); SILK_INFO_M(log_prefix_, {"clearing", table::kHashedStorage.name_str()}); txn->clear_map(table::kHashedStorage.name_str()); SILK_INFO_M(log_prefix_, {"clearing", table::kHashedCodeHash.name_str()}); txn->clear_map(table::kHashedCodeHash.name_str()); txn.commit_and_renew(); success_or_throw(hash_from_plainstate(txn)); collector_->clear(); reset_log_progress(); success_or_throw(hash_from_plaincode(txn)); collector_->clear(); reset_log_progress(); } else { success_or_throw(hash_from_account_changeset(txn, previous_progress, execution_stage_progress)); reset_log_progress(); success_or_throw(hash_from_storage_changeset(txn, previous_progress, execution_stage_progress)); reset_log_progress(); } throw_if_stopping(); stages::write_stage_progress(txn, stages::kHashStateKey, execution_stage_progress); txn.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } reset_log_progress(); operation_ = OperationType::kNone; collector_.reset(); return ret; } Stage::Result HashState::unwind(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); auto previous_progress{stages::read_stage_progress(txn, stage_name_)}; if (to >= previous_progress) { // Nothing to unwind actually return ret; } const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } success_or_throw(unwind_from_account_changeset(txn, previous_progress, to)); reset_log_progress(); success_or_throw(unwind_from_storage_changeset(txn, previous_progress, to)); reset_log_progress(); throw_if_stopping(); update_progress(txn, to); txn.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result HashState::prune(RWTxn&) { // HashState does not prune return Stage::Result::kSuccess; } Stage::Result HashState::hash_from_plainstate(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; try { auto source = txn.ro_cursor_dup_sort(table::kPlainState); auto data{source->to_first(/*throw_notfound=*/true)}; /* * This relies on the assumption previous execution stage has completed correctly, * and we do nothing more than hashing keys already present in PlainState either * to HashedAccount or to HashedStorage. We don't need to check an upper block * limit as PlainState holds info up to the max executed block. */ evmc::address last_address{}; ethash_hash256 address_hash{keccak256(last_address.bytes)}; // We might have all zeroed addresses ? std::unique_lock log_lck(log_mtx_); current_source_ = std::string(table::kPlainState.name); current_key_ = to_hex(last_address.bytes, /*with_prefix=*/true); log_lck.unlock(); // New Hashed Storage Entry Key (72 bytes) // + Address hash (32 bytes) // + Incarnation ( 8 bytes) // + Location hash (32 bytes) Bytes etl_storage_entry_key(72, '\0'); // Hash accounts while (data) { auto data_key_view{from_slice(data.key)}; // We're reading PlainState which keys are ordered by address (always initial 20 bytes of key) // Rehash the address only when changes if (std::memcmp(data_key_view.data(), last_address.bytes, kAddressLength) != 0) { throw_if_stopping(); last_address = bytes_to_address(data_key_view); address_hash = keccak256(last_address.bytes); log_lck.lock(); current_key_ = to_hex(last_address.bytes, /*with_prefix=*/true); log_lck.unlock(); } if (data.key.length() == kAddressLength) { // Hash account // data.key == Address // data.value == Account encoded for storage (must exist) if (data.value.empty()) { const std::string what("Unexpected empty value in PlainState for Account " + current_key_); throw StageError(Stage::Result::kUnexpectedError, what); } Entry entry{Bytes(address_hash.bytes, kHashLength), Bytes{from_slice(data.value)}}; collector_->collect(std::move(entry)); } else if (data.key.length() == kPlainStoragePrefixLength) { // Hash storage // data.key == Address + Incarnation // data.value (multi) == Location + zeroless Value // See above for allocation std::memcpy(&etl_storage_entry_key[0], address_hash.bytes, kHashLength); std::memcpy(&etl_storage_entry_key[kHashLength], &data_key_view[kAddressLength], kIncarnationLength); // Iterate dupkeys only to avoid re-hashing of same address while (data) { if (data.value.length() <= kHashLength) { const auto incarnation{endian::load_big_u64(&data_key_view[kAddressLength])}; const std::string what("Unexpected empty value in PlainState for Account " + current_key_ + " incarnation " + std::to_string(incarnation)); throw StageError(Stage::Result::kUnexpectedError, what); } /* * NOTE ! * Destination table kHashedStorage is dup-sorted but as Collector implements sorting only on entry * key here we have to build the entry key as hashed address + incarnation + hashed storage location * eventually leaving entry value to only hashed storage value. This ensures entries are collected * and sorted properly and eventually the loader will move back hashed storage location in the value * part of the db record. This way we can reliably insert records using MDBX_APPENDDUP */ auto data_value_view{from_slice(data.value)}; std::memcpy(&etl_storage_entry_key[kHashLength + kIncarnationLength], keccak256(data_value_view.substr(0, kHashLength)).bytes, kHashLength); data_value_view.remove_prefix(kHashLength); Entry entry{etl_storage_entry_key, Bytes{data_value_view}}; collector_->collect(std::move(entry)); data = source->to_current_next_multi(false); } } else { std::string what{"Unexpected key length " + std::to_string(data.key.length())}; throw StageError(Stage::Result::kUnexpectedError, what); } data = source->to_next(/*throw_notfound=*/false); } throw_if_stopping(); if (!collector_->empty()) { auto account_target = txn.rw_cursor_dup_sort(table::kHashedAccounts); // note: not a multi-value table auto storage_target = txn.rw_cursor_dup_sort(table::kHashedStorage); if (!account_target->empty()) throw std::runtime_error(std::string(table::kHashedAccounts.name) + " should be empty"); if (!storage_target->empty()) throw std::runtime_error(std::string(table::kHashedStorage.name) + " should be empty"); // ETL key contains hashed location; for DB put we need to move it from key to value const datastore::kvdb::LoadFunc load_func = [&storage_target]( const Entry& entry, datastore::kvdb::RWCursorDupSort& target, MDBX_put_flags_t) -> void { if (entry.value.empty()) { return; } if (entry.key.size() == kHashLength) { mdbx::slice k{entry.key.data(), entry.key.size()}; mdbx::slice v{entry.value.data(), entry.value.size()}; mdbx::error::success_or_throw(target.put(k, &v, MDBX_APPEND)); } else if (entry.key.size() == kHashedStoragePrefixLength + kHashLength) { Bytes new_value(kHashLength + entry.value.size(), '\0'); std::memcpy(&new_value[0], &entry.key[kHashedStoragePrefixLength], kHashLength); std::memcpy(&new_value[kHashLength], entry.value.data(), entry.value.size()); mdbx::slice k{entry.key.data(), kHashedStoragePrefixLength}; mdbx::slice v{new_value.data(), new_value.size()}; mdbx::error::success_or_throw(storage_target->put(k, &v, MDBX_APPENDDUP)); } else { std::string what{"Unexpected key length " + std::to_string(entry.key.size()) + " in PlainState"}; throw StageError(Stage::Result::kUnexpectedError, what); } }; log_lck.lock(); current_target_ = std::string(table::kHashedAccounts.name) + "+" + std::string(table::kHashedStorage.name); loading_ = true; log_lck.unlock(); collector_->load(*account_target, load_func, MDBX_put_flags_t::MDBX_APPENDDUP); } } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result HashState::hash_from_plaincode(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; try { auto source = txn.ro_cursor(table::kPlainCodeHash); auto data{source->to_first(/*throw_notfound=*/false)}; evmc::address last_address{}; Bytes new_key(kHashedStoragePrefixLength, '\0'); std::unique_lock log_lck(log_mtx_); current_source_ = std::string(table::kPlainCodeHash.name); current_key_ = to_hex(last_address.bytes, /*with_prefix=*/true); log_lck.unlock(); while (data) { if (data.key.length() != kAddressLength + kIncarnationLength) { std::string what{"Unexpected key len " + std::to_string(data.key.length())}; throw StageError(Stage::Result::kUnexpectedError, what); } auto data_key_view{from_slice(data.key)}; // We're reading PlainCodeHash which keys are ordered by address (always initial 20 bytes of key) // Rehash the address only when changes if (std::memcmp(data_key_view.data(), last_address.bytes, kAddressLength) != 0) { throw_if_stopping(); last_address = bytes_to_address(data_key_view); log_lck.lock(); current_key_ = to_hex(last_address.bytes, /*with_prefix=*/true); log_lck.unlock(); const auto address_hash{keccak256(last_address.bytes)}; std::memcpy(&new_key[0], address_hash.bytes, kHashLength); } std::memcpy(&new_key[kHashLength], &data_key_view[kAddressLength], kIncarnationLength); Entry entry{new_key, Bytes{from_slice(data.value)}}; collector_->collect(std::move(entry)); data = source->to_next(/*throw_notfound=*/false); } throw_if_stopping(); if (!collector_->empty()) { auto target = txn.rw_cursor_dup_sort(table::kHashedCodeHash); // note: not a multi-value table if (!target->empty()) throw std::runtime_error(std::string(table::kHashedCodeHash.name) + " should be empty"); log_lck.lock(); current_target_ = std::string(table::kHashedCodeHash.name); loading_ = true; log_lck.unlock(); collector_->load(*target, nullptr, MDBX_put_flags_t::MDBX_APPEND); } } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result HashState::hash_from_account_changeset(RWTxn& txn, BlockNum previous_progress, BlockNum to) { Stage::Result ret{Stage::Result::kSuccess}; try { /* * 1) Read AccountChangeSet from previous_progress to 'to' * 2) For each address changed hash it and lookup current value from PlainState * 3) Process the collected list and write values into Hashed tables (Account and Code) */ BlockNum expected_blocknum{previous_progress + 1}; ChangedAddresses changed_addresses{}; std::unique_lock log_lck(log_mtx_); operation_ = OperationType::kForward; incremental_ = true; current_source_ = std::string(table::kAccountChangeSet.name); current_key_ = std::to_string(expected_blocknum); log_lck.unlock(); auto source_initial_key{block_key(expected_blocknum)}; auto source_changeset = txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto source_plainstate = txn.ro_cursor_dup_sort(table::kPlainState); // Initial record MUST be found because there is at least 1 change per block: the miner reward auto changeset_data = source_changeset->find(to_slice(source_initial_key), /*throw_notfound=*/true); while (changeset_data.done) { const BlockNum reached_blocknum = endian::load_big_u64(from_slice(changeset_data.key).data()); check_block_sequence(reached_blocknum, expected_blocknum); if (reached_blocknum > to) { break; } if (reached_blocknum % 32 == 0) { throw_if_stopping(); log_lck.lock(); current_key_ = std::to_string(reached_blocknum); log_lck.unlock(); } while (changeset_data) { auto changeset_value_view{from_slice(changeset_data.value)}; evmc::address address{bytes_to_address(changeset_value_view)}; if (!changed_addresses.contains(address)) { auto address_hash{to_bytes32(keccak256(address.bytes).bytes)}; auto plainstate_data = source_plainstate->find(db::to_slice(address), /*throw_notfound=*/false); if (plainstate_data.done) { Bytes current_value{from_slice(plainstate_data.value)}; changed_addresses[address] = std::make_pair(address_hash, current_value); } else { changed_addresses[address] = std::make_pair(address_hash, Bytes()); } } changeset_data = source_changeset->to_current_next_multi(/*throw_notfound=*/false); } ++expected_blocknum; changeset_data = source_changeset->to_next(/*throw_notfound=*/false); } write_changes_from_changed_addresses(txn, changed_addresses); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result HashState::hash_from_storage_changeset(RWTxn& txn, BlockNum previous_progress, BlockNum to) { Stage::Result ret{Stage::Result::kSuccess}; try { /* * 1) Read StorageChangeSet from previous_progress to 'to' * 2) For each address + incarnation changed hash it and lookup current value from PlainState * 3) Process the collected list and write values into HashedStorage */ StorageChanges storage_changes{}; absl::btree_map hashed_addresses{}; std::unique_lock log_lck(log_mtx_); operation_ = OperationType::kForward; incremental_ = true; current_source_ = std::string(table::kStorageChangeSet.name); current_key_ = std::to_string(previous_progress + 1); log_lck.unlock(); auto source_changeset = txn.ro_cursor_dup_sort(table::kStorageChangeSet); auto source_plainstate = txn.ro_cursor_dup_sort(table::kPlainState); // find fist block with changes BlockNum initial_block{previous_progress + 1}; auto source_initial_key{block_key(initial_block)}; auto changeset_data = source_changeset->lower_bound(to_slice(source_initial_key), /*throw_notfound=*/false); while (!changeset_data.done && initial_block <= to) { ++initial_block; source_initial_key = block_key(initial_block); changeset_data = source_changeset->lower_bound(to_slice(source_initial_key), /*throw_notfound=*/false); } // process changes while (changeset_data.done) { auto changeset_key_view{from_slice(changeset_data.key)}; const BlockNum reached_blocknum = endian::load_big_u64(changeset_key_view.data()); if (reached_blocknum > to) { break; } if (reached_blocknum % 32 == 0) { throw_if_stopping(); log_lck.lock(); current_key_ = std::to_string(reached_blocknum); log_lck.unlock(); } changeset_key_view.remove_prefix(8); evmc::address address{bytes_to_address(changeset_key_view)}; changeset_key_view.remove_prefix(kAddressLength); const auto incarnation{endian::load_big_u64(changeset_key_view.data())}; if (!incarnation) { throw StageError(Stage::Result::kUnexpectedError, "Unexpected EOA in StorageChangeset"); } if (!hashed_addresses.contains(address)) { hashed_addresses[address] = to_bytes32(keccak256(address.bytes).bytes); storage_changes[address].insert_or_assign(incarnation, absl::btree_map()); } Bytes plain_storage_prefix{storage_prefix(address, incarnation)}; while (changeset_data.done) { auto changeset_value_view{from_slice(changeset_data.value)}; auto location{to_bytes32(changeset_value_view)}; if (!storage_changes[address][incarnation].contains(location)) { auto plain_state_value{find_value_suffix(*source_plainstate, plain_storage_prefix, location.bytes)}; storage_changes[address][incarnation].insert_or_assign(location, plain_state_value.value_or(Bytes())); } changeset_data = source_changeset->to_current_next_multi(/*throw_notfound=*/false); } changeset_data = source_changeset->to_next(/*throw_notfound=*/false); } write_changes_from_changed_storage(txn, storage_changes, hashed_addresses); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result HashState::unwind_from_account_changeset(RWTxn& txn, BlockNum previous_progress, BlockNum to) { Stage::Result ret{Stage::Result::kSuccess}; try { /* * This behaves pretty much similar to hash_from_account_changeset with one major difference: * as AccountChangeset records the state of an account at previous block we take the status * from the changeset itself. Say we need to unwind to block 990 from 1000. We begin from * block 991 (which records a change has been made by block 991 and the value is the one * which was at block 990). See tables kAccountChangeSet for reference * * 1) Read AccountChangeSet from `to+1` to 'previous_progress' * 2) For each address changed hash it and take the value of previous block * 3) Process the collected list and write values into Hashed tables (Account and Code) */ BlockNum reached_blocknum{0}; BlockNum expected_blocknum{to + 1}; ChangedAddresses changed_addresses{}; std::unique_lock log_lck(log_mtx_); operation_ = OperationType::kUnwind; current_source_ = std::string(table::kAccountChangeSet.name); current_key_ = std::to_string(expected_blocknum); log_lck.unlock(); throw_if_stopping(); auto changeset_cursor = txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto initial_key{block_key(expected_blocknum)}; auto changeset_data = changeset_cursor->find(to_slice(initial_key), /*throw_notfound=*/true); while (changeset_data.done) { reached_blocknum = endian::load_big_u64(from_slice(changeset_data.key).data()); check_block_sequence(reached_blocknum, expected_blocknum); if (reached_blocknum > previous_progress) { break; } if (reached_blocknum % 32 == 0) { throw_if_stopping(); log_lck.lock(); current_key_ = std::to_string(reached_blocknum); log_lck.unlock(); } while (changeset_data.done) { auto changeset_value_view{from_slice(changeset_data.value)}; ensure(changeset_value_view.size() >= kAddressLength, [&]() { return "invalid account changeset value size=" + std::to_string(changeset_value_view.size()) + " at block " + std::to_string(reached_blocknum); }); evmc::address address{bytes_to_address(changeset_value_view)}; if (!changed_addresses.contains(address)) { changeset_value_view.remove_prefix(kAddressLength); auto address_hash{to_bytes32(keccak256(address.bytes).bytes)}; Bytes previous_value(changeset_value_view.data(), changeset_value_view.size()); changed_addresses[address] = std::make_pair(address_hash, previous_value); } changeset_data = changeset_cursor->to_current_next_multi(/*throw_notfound=*/false); } ++expected_blocknum; changeset_data = changeset_cursor->to_next(/*throw_notfound=*/false); } write_changes_from_changed_addresses(txn, changed_addresses); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result HashState::unwind_from_storage_changeset(RWTxn& txn, BlockNum previous_progress, BlockNum to) { Stage::Result ret{Stage::Result::kSuccess}; try { /* * This behaves pretty much similar to hash_from_storage_changeset with one major difference: * as StorageChangeset records the state of an account at previous block we take the status * from the changeset itself. Say we need to unwind to block 990 from 1000. We begin from * block 991 (which records a change has been made by block 991 and the value is the one * which was at block 990). See tables kAccountChangeSet for reference * * 1) Read StorageChangeSet from `to+1` to 'previous_progress' * 2) For each address + incarnation changed hash it and take previous value * 3) Process the collected list and write values into HashedStorage */ BlockNum reached_blocknum{0}; StorageChanges storage_changes{}; absl::btree_map hashed_addresses{}; std::unique_lock log_lck(log_mtx_); operation_ = OperationType::kUnwind; incremental_ = true; current_source_ = std::string(table::kStorageChangeSet.name); current_key_ = std::to_string(to + 1); log_lck.unlock(); auto changeset_cursor = txn.ro_cursor_dup_sort(table::kStorageChangeSet); auto initial_key_prefix{block_key(to + 1)}; auto changeset_data = changeset_cursor->lower_bound(to_slice(initial_key_prefix), /*throw_notfound=*/false); if (!changeset_data.done) { SILK_TRACE_M(log_prefix_, {"function", std::string(__FUNCTION__), "warning", "no storage changeset found", "description", "this should only happen during integration tests"}); return ret; } while (changeset_data.done) { auto changeset_key_view{from_slice(changeset_data.key)}; ensure(changeset_key_view.size() == sizeof(BlockNum) + kPlainStoragePrefixLength, [&]() { return "invalid storage changeset key size=" + std::to_string(changeset_key_view.size()); }); reached_blocknum = endian::load_big_u64(changeset_key_view.data()); if (reached_blocknum > previous_progress) { break; } if (reached_blocknum % 32 == 0) { throw_if_stopping(); log_lck.lock(); current_key_ = std::to_string(reached_blocknum); log_lck.unlock(); } changeset_key_view.remove_prefix(sizeof(BlockNum)); evmc::address address{bytes_to_address(changeset_key_view)}; changeset_key_view.remove_prefix(kAddressLength); const auto incarnation{endian::load_big_u64(changeset_key_view.data())}; if (!incarnation) { throw std::runtime_error("Unexpected EOA in StorageChangeset"); } if (!hashed_addresses.contains(address)) { hashed_addresses[address] = to_bytes32(keccak256(address.bytes).bytes); storage_changes[address].insert_or_assign(incarnation, absl::btree_map()); } while (changeset_data.done) { auto changeset_value_view{from_slice(changeset_data.value)}; ensure(changeset_value_view.size() >= kHashLength, [&]() { return "invalid storage changeset value size=" + std::to_string(changeset_value_view.size()) + " at block " + std::to_string(reached_blocknum); }); auto location{to_bytes32(changeset_value_view)}; if (!storage_changes[address][incarnation].contains(location)) { changeset_value_view.remove_prefix(kHashLength); Bytes previous_value{changeset_value_view}; storage_changes[address][incarnation].insert_or_assign(location, previous_value); } changeset_data = changeset_cursor->to_current_next_multi(/*throw_notfound=*/false); } changeset_data = changeset_cursor->to_next(/*throw_notfound=*/false); } write_changes_from_changed_storage(txn, storage_changes, hashed_addresses); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } void HashState::write_changes_from_changed_addresses(RWTxn& txn, const ChangedAddresses& changed_addresses) { throw_if_stopping(); std::unique_lock log_lck(log_mtx_); current_target_ = std::string(table::kHashedAccounts.name) + " " + std::string(table::kHashedCodeHash.name); loading_ = true; current_key_ = to_hex(changed_addresses.begin()->first.bytes, /*with_prefix=*/true); log_lck.unlock(); auto source_plaincode = txn.ro_cursor(table::kPlainCodeHash); auto target_hashed_accounts = txn.rw_cursor(table::kHashedAccounts); auto target_hashed_code = txn.rw_cursor(table::kHashedCodeHash); Bytes plain_code_key(kAddressLength + kIncarnationLength, '\0'); // Only one allocation Bytes hashed_code_key(kHashLength + kIncarnationLength, '\0'); // Only one allocation evmc::address last_address{}; for (const auto& [address, pair] : changed_addresses) { if (address != last_address) { throw_if_stopping(); last_address = address; log_lck.lock(); current_key_ = address_to_hex(address); log_lck.unlock(); } auto& [address_hash, current_encoded_value] = pair; if (!current_encoded_value.empty()) { // Update HashedAccounts table target_hashed_accounts->upsert(db::to_slice(address_hash), to_slice(current_encoded_value)); // Lookup value in PlainCodeHash for contract auto account = db::state::AccountCodec::from_encoded_storage(current_encoded_value); success_or_throw(account); if (account->incarnation != 0) { std::memcpy(&plain_code_key[0], address.bytes, kAddressLength); std::memcpy(&hashed_code_key[0], address_hash.bytes, kHashLength); endian::store_big_u64(&hashed_code_key[kHashLength], account->incarnation); endian::store_big_u64(&plain_code_key[kAddressLength], account->incarnation); const auto code_data = source_plaincode->find(to_slice(plain_code_key), /*throw_notfound=*/false); if (code_data.done && !code_data.value.empty()) { if (account->code_hash == kEmptyHash) { SILK_TRACE_M(log_prefix_, {"function", std::string(__FUNCTION__), "address", address_to_hex(address), "address_hash", to_hex(address_hash), "incarnation", std::to_string(account->incarnation)}); std::memcpy(account->code_hash.bytes, code_data.value.data(), kHashLength); Bytes account_data = db::state::AccountCodec::encode_for_storage(*account); target_hashed_accounts->upsert(db::to_slice(address_hash), to_slice(account_data)); } target_hashed_code->upsert(to_slice(hashed_code_key), code_data.value); } else { target_hashed_code->erase(to_slice(hashed_code_key)); } } } else { target_hashed_accounts->erase(db::to_slice(address_hash)); } } } void HashState::write_changes_from_changed_storage( RWTxn& txn, StorageChanges& storage_changes, const absl::btree_map& hashed_addresses) { throw_if_stopping(); auto target_hashed_storage = txn.rw_cursor_dup_sort(table::kHashedStorage); std::unique_lock log_lck(log_mtx_); loading_ = true; current_target_ = std::string(table::kHashedStorage.name); log_lck.unlock(); evmc::address last_address{}; Bytes hashed_storage_prefix(kHashedStoragePrefixLength, '\0'); // One allocation only for (const auto& [address, data] : storage_changes) { if (address != last_address) { throw_if_stopping(); last_address = address; std::memcpy(&hashed_storage_prefix[0], hashed_addresses.at(last_address).bytes, kHashLength); log_lck.lock(); current_key_ = address_to_hex(address); log_lck.unlock(); } for (const auto& [incarnation, data1] : data) { endian::store_big_u64(&hashed_storage_prefix[kHashLength], incarnation); for (const auto& [location, value] : data1) { auto hashed_location{keccak256(location.bytes)}; upsert_storage_value(*target_hashed_storage, hashed_storage_prefix, hashed_location.bytes, value); } } } } std::vector HashState::get_log_progress() { std::unique_lock log_lck(log_mtx_); if (is_stopping()) { return {}; } std::vector ret{"op", std::string(magic_enum::enum_name(operation_)), "mode", (incremental_ ? "incr" : "full")}; if (operation_ == OperationType::kNone) { return ret; } if (loading_) { if (!incremental_ && collector_ && !collector_->get_load_key().empty()) { current_key_ = abridge(collector_->get_load_key(), kAddressLength * 2 + 2); } ret.insert(ret.end(), {"to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "key", current_key_}); } return ret; } void HashState::reset_log_progress() { std::unique_lock log_lck(log_mtx_); incremental_ = false; loading_ = false; current_source_.clear(); current_target_.clear(); current_key_.clear(); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_hashstate.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::stagedsync { class HashState final : public Stage { public: HashState( SyncContext* sync_context, datastore::etl::CollectorSettings etl_settings) : Stage(sync_context, db::stages::kHashStateKey), etl_settings_(std::move(etl_settings)) {} HashState(const HashState&) = delete; // not copyable HashState(HashState&&) = delete; // nor movable ~HashState() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: //! \brief Store already processed addresses to avoid rehashing and multiple lookups //! \struct Address -> Address Hash -> Value using ChangedAddresses = absl::btree_map>; //! \brief Transforms PlainState into HashedAccounts and HashedStorage respectively in one single read pass over //! PlainState \remarks To be used only if this is very first time HashState stage runs forward (i.e. forwarding //! from 0) Stage::Result hash_from_plainstate(db::RWTxn& txn); //! \brief Transforms PlainCodeHash into HashedCodeHash in one single read pass over PlainCodeHash //! \remarks To be used only if this is very first time HashState stage runs forward (i.e. forwarding from 0) Stage::Result hash_from_plaincode(db::RWTxn& txn); //! \brief Detects account changes from AccountChangeSet and hashes the changed keys //! \remarks Though it could be used for initial sync only is way slower and builds an index of changed accounts. Stage::Result hash_from_account_changeset(db::RWTxn& txn, BlockNum previous_progress, BlockNum to); //! \brief Detects storage changes from StorageChangeSet and hashes the changed keys //! \remarks Though it could be used for initial sync only is way slower and builds an index of changed storage //! locations. Stage::Result hash_from_storage_changeset(db::RWTxn& txn, BlockNum previous_progress, BlockNum to); //! \brief Detects account changes from AccountChangeSet and reverts hashed states Stage::Result unwind_from_account_changeset(db::RWTxn& txn, BlockNum previous_progress, BlockNum to); //! \brief Detects storage changes from StorageChangeSet and reverts hashed states Stage::Result unwind_from_storage_changeset(db::RWTxn& txn, BlockNum previous_progress, BlockNum to); //! \brief Writes to db the changes collected from account changeset scan either in forward or unwind mode void write_changes_from_changed_addresses(db::RWTxn& txn, const ChangedAddresses& changed_addresses); //! \brief Writes to db the changes collected from storage changeset scan either in forward or unwind mode void write_changes_from_changed_storage(db::RWTxn& txn, silkworm::db::StorageChanges& storage_changes, const absl::btree_map& hashed_addresses); //! \brief Resets all fields related to log progress tracking void reset_log_progress(); // Guards async logging std::mutex log_mtx_{}; // Whether operation is incremental std::atomic_bool incremental_{false}; // Whether we're in ETL loading phase std::atomic_bool loading_{false}; // Current source of data std::string current_source_; // Current target of transformed data std::string current_target_; // Actual processing key std::string current_key_; // Collector (used only in !incremental_) datastore::etl::CollectorSettings etl_settings_; std::unique_ptr collector_; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_headers.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_headers.hpp" #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; HeadersStage::HeaderDataModel::HeaderDataModel( RWTxn& tx, DataModel data_model, BlockNum headers_block_num) : tx_(tx), data_model_(data_model), previous_block_num_(headers_block_num) { auto headers_hash = read_canonical_header_hash(tx, headers_block_num); ensure(headers_hash.has_value(), [&]() { return "Headers stage, inconsistent canonical table: not found hash at block_num " + std::to_string(headers_block_num); }); std::optional headers_head_td = read_total_difficulty(tx, headers_block_num, *headers_hash); ensure(headers_head_td.has_value(), [&]() { return "Headers stage, inconsistent total-difficulty table: not found td at block_num " + std::to_string(headers_block_num); }); previous_hash_ = *headers_hash; previous_td_ = *headers_head_td; } BlockNum HeadersStage::HeaderDataModel::max_block_num() const { return previous_block_num_; } Hash HeadersStage::HeaderDataModel::max_hash() const { return previous_hash_; } intx::uint256 HeadersStage::HeaderDataModel::total_difficulty() const { return previous_td_; } void HeadersStage::HeaderDataModel::update_tables(const BlockHeader& header) { auto block_num = header.number; Hash hash = header.hash(); // Admittance conditions ensure_invariant(header.parent_hash == previous_hash_, [&]() { return "Headers stage invariant violation: headers to process must be consecutive, at block_num=" + std::to_string(block_num) + ", prev.hash=" + previous_hash_.to_hex() + ", curr.hash=" + hash.to_hex(); }); // Calculate total difficulty of this header auto td = previous_td_ + header.difficulty; // Save progress write_total_difficulty(tx_, block_num, hash, td); previous_hash_ = hash; previous_td_ = td; previous_block_num_ = block_num; } void HeadersStage::HeaderDataModel::remove_headers(BlockNum unwind_point, RWTxn& tx) { auto canonical_hash = read_canonical_header_hash(tx, unwind_point); ensure(canonical_hash.has_value(), [&]() { return "Headers stage, expected canonical hash at block_num " + std::to_string(unwind_point); }); write_head_header_hash(tx, *canonical_hash); // maybe we should remove only the bad header } std::optional HeadersStage::HeaderDataModel::get_canonical_header(BlockNum block_num) const { return data_model_.read_canonical_header(block_num); } // HeadersStage HeadersStage::HeadersStage( SyncContext* sync_context, DataModelFactory data_model_factory) : Stage{sync_context, stages::kHeadersKey}, data_model_factory_{std::move(data_model_factory)} { // User can specify to stop downloading process at some block const auto stop_at_block = Environment::get_stop_at_block(); if (stop_at_block.has_value()) { forced_target_block_ = stop_at_block; SILK_DEBUG_M(log_prefix_, {"target=", std::to_string(*forced_target_block_)}) << " env var STOP_AT_BLOCK set"; } } Stage::Result HeadersStage::forward(RWTxn& tx) { using std::shared_ptr; using namespace std::chrono_literals; using namespace std::chrono; Stage::Result result = Stage::Result::kUnspecified; std::thread message_receiving; operation_ = OperationType::kForward; try { auto initial_block_num = current_block_num_ = stages::read_stage_progress(tx, stages::kHeadersKey); BlockNum target_block_num = sync_context_->target_block_num; if (forced_target_block_ && current_block_num_ >= *forced_target_block_) { tx.commit_and_renew(); log::Trace(log_prefix_) << "End, forward skipped due to STOP_AT_BLOCK, block=" << current_block_num_.load(); return Stage::Result::kSuccess; } if (current_block_num_ >= target_block_num) { tx.commit_and_renew(); log::Trace(log_prefix_) << "End, forward skipped, we are already at target block=" << target_block_num; return Stage::Result::kSuccess; } const BlockNum segment_width{target_block_num - current_block_num_}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(current_block_num_), "to", std::to_string(target_block_num), "span", std::to_string(segment_width)}); } HeaderDataModel header_persistence{ tx, data_model_factory_(tx), current_block_num_, }; get_log_progress(); // this is a trick to set log progress initial value, please improve RepeatedMeasure block_num_progress(current_block_num_); // header processing while (current_block_num_ < target_block_num && !is_stopping()) { ++current_block_num_; // process header and ommers at current block_num auto header = header_persistence.get_canonical_header(current_block_num_); if (!header) throw std::logic_error("table Headers has a hole"); header_persistence.update_tables(*header); block_num_progress.set(current_block_num_); } write_head_header_hash(tx, header_persistence.max_hash()); stages::write_stage_progress(tx, stages::kHeadersKey, current_block_num_); result = Stage::Result::kSuccess; // no reason to raise unwind auto headers_processed = current_block_num_ - initial_block_num; log::Trace(log_prefix_) << "Update completed wrote " << headers_processed << " headers last=" << current_block_num_; tx.commit_and_renew(); } catch (const std::exception& e) { log::Error(log_prefix_) << "Forward aborted due to exception: " << e.what(); result = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return result; } Stage::Result HeadersStage::unwind(RWTxn& tx) { current_block_num_ = stages::read_stage_progress(tx, stages::kHeadersKey); get_log_progress(); // this is a trick to set log progress initial value, please improve if (!sync_context_->unwind_point.has_value()) return Stage::Result::kSuccess; auto new_block_num = sync_context_->unwind_point.value(); if (current_block_num_ <= new_block_num) return Stage::Result::kSuccess; operation_ = OperationType::kUnwind; const BlockNum segment_width{current_block_num_ - new_block_num}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(current_block_num_), "to", std::to_string(new_block_num), "span", std::to_string(segment_width)}); } Stage::Result result{Stage::Result::kSuccess}; try { // std::optional bad_block = sync_context_->bad_block_hash; HeaderDataModel::remove_headers(new_block_num, tx); current_block_num_ = new_block_num; stages::write_stage_progress(tx, stages::kHeadersKey, current_block_num_); result = Stage::Result::kSuccess; tx.commit_and_renew(); } catch (const std::exception& e) { log::Error(log_prefix_) << "Unwind aborted due to exception: " << e.what(); // tx rollback executed automatically if needed result = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return result; } Stage::Result HeadersStage::prune(RWTxn&) { return Stage::Result::kSuccess; } std::vector HeadersStage::get_log_progress() { // implementation MUST be thread safe static RepeatedMeasure block_num_progress{0}; block_num_progress.set(current_block_num_); return {"current block", std::to_string(block_num_progress.get()), "progress", std::to_string(block_num_progress.delta()), "headers/secs", std::to_string(block_num_progress.throughput())}; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_headers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::stagedsync { /* * HeadersStage implement the header downloading stage. * Like the other stages it has two methods, one to go forward and one to go backwards (unwind) in the chain. * It is the counterpart of Erigon's HeaderForward and HeadersUnwind. * * HeadersStage internally uses HeaderChain and HeaderPersistence. The first represent the growing chain in memory * the second represent the growing chain on db. When headers are ready to be persisted they are withdrawn from * HeaderChain and transferred to the HeaderPersistence that write them on the db. * * HeadersStage has: * - an execution loop * - a forward/unwind method pair * * The execution loop process messages that arrives in a concurrent queue. They are of 2 types: * - inbound messages (from peers), like headers announcements (that we receive), responses for our header requests * - outbound messages (to peers), like headers announcements (that we propagate), header requests * Each message is class that encode in the execute() method the logic to process the message itself (command pattern). * Those messages operate on the HeaderChain (asking needed headers or providing arrived headers) and use the sentry. * Inbound messages are generated by the sentry, outbound messages are generated by the forward/unwind methods. * * The forward method periodically * - generate some outbound messages that ask HeaderChain to generate headers request, * - check if HeaderChain has headers ready to be persisted * - if there are some it uses HeaderPersistence to persist them * - check if HeaderPersistence has detected an unwind point * - check the conditions that determines the forward method to exit (unwind detected, chain in sync) * The unwind method do headers unwind down to an unwind point. * * Since the execution loop runs in its thread and the forward/unwind methods runs in the stage loop thread a * synchronisation is needed. So the HeadersStage is partitioned in 2 half: one half runs the execution loop, the * other half runs the forward/unwind methods; the two half communicate only by a MessageQueue that is a thread safe * queue. Thus, HeaderChain is used only in the first half and not need lock protection, whereas HeaderPersistence is * used in the other thread and also do not need lock protection. * */ class HeadersStage : public Stage { public: HeadersStage( SyncContext* sync_context, db::DataModelFactory data_model_factory); HeadersStage(const HeadersStage&) = delete; // not copyable HeadersStage(HeadersStage&&) = delete; // nor movable Stage::Result forward(db::RWTxn&) override; // go forward, downloading headers Stage::Result unwind(db::RWTxn&) override; // go backward, unwinding headers to new_block_num Stage::Result prune(db::RWTxn&) override; protected: std::vector get_log_progress() override; // thread safe db::DataModelFactory data_model_factory_; std::atomic current_block_num_{0}; std::optional forced_target_block_; // HeaderDataModel has the responsibility to update headers related tables class HeaderDataModel { public: HeaderDataModel( db::RWTxn& tx, db::DataModel data_model, BlockNum headers_block_num); void update_tables(const BlockHeader&); // update header related tables // remove header data from tables, used in unwind phase static void remove_headers(BlockNum unwind_point, db::RWTxn& tx); // holds the status of a batch insertion of headers BlockNum max_block_num() const; Hash max_hash() const; intx::uint256 total_difficulty() const; std::optional get_canonical_header(BlockNum block_num) const; private: db::RWTxn& tx_; db::DataModel data_model_; Hash previous_hash_; intx::uint256 previous_td_{0}; BlockNum previous_block_num_{0}; }; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_headers_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_headers.hpp" #include #include #include #include #include #include namespace silkworm { using namespace silkworm::db; class HeadersStageForTest : public stagedsync::HeadersStage { public: using stagedsync::HeadersStage::HeaderDataModel; }; using HeaderDataModelForTest = HeadersStageForTest::HeaderDataModel; TEST_CASE("HeadersStage - data model") { db::test_util::TempChainDataStore context; context.add_genesis_data(); context.commit_txn(); auto chaindata = context.chaindata_rw(); auto data_model_factory = context.data_model_factory(); /* status: * h0 * input: * h0 <----- h1 */ SECTION("one header after the genesis") { auto tx = chaindata.start_rw_tx(); DataModel data_model = data_model_factory(tx); auto header0_hash = read_canonical_header_hash(tx, 0); REQUIRE(header0_hash.has_value()); auto header0 = read_canonical_header(tx, 0); REQUIRE(header0.has_value()); BlockNum headers_stage_block_num = 0; HeaderDataModelForTest hm{tx, data_model, headers_stage_block_num}; REQUIRE(hm.max_block_num() == 0); REQUIRE(hm.max_hash() == header0_hash); REQUIRE(hm.total_difficulty() == header0->difficulty); BlockHeader header1; header1.number = 1; header1.difficulty = 17'171'480'576; header1.parent_hash = *header0_hash; auto header1_hash = header1.hash(); auto td = header0->difficulty + header1.difficulty; hm.update_tables(header1); // note that this will NOT write header1 on db // check internal status REQUIRE(hm.max_block_num() == header1.number); REQUIRE(hm.max_hash() == header1_hash); REQUIRE(hm.total_difficulty() == td); // check db content // REQUIRE(read_head_header_hash(tx) == header1_hash); REQUIRE(read_total_difficulty(tx, header1.number, header1.hash()) == td); // REQUIRE(read_block_num(tx, header1.hash()) == header1.number); block numbers will be added by stage block-hashes } /* status: * h0 (persisted) * input: * (h0) <----- h1 <----- h2 * |-- h1' */ SECTION("some header after the genesis") { auto tx = chaindata.start_rw_tx(); DataModel data_model = data_model_factory(tx); // starting from an initial status auto header0 = read_canonical_header(tx, 0); auto header0_hash = header0->hash(); // receiving 3 headers from a peer BlockHeader header1; header1.number = 1; header1.difficulty = 1'000'000; header1.parent_hash = header0_hash; auto header1_hash = header1.hash(); BlockHeader header2; header2.number = 2; header2.difficulty = 1'100'000; header2.parent_hash = header1_hash; auto header2_hash = header2.hash(); BlockHeader header1b; header1b.number = 1; header1b.difficulty = 2'000'000; header1b.parent_hash = header0_hash; header1b.extra_data = string_view_to_byte_view("I'm different"); auto header1b_hash = header1b.hash(); // updating the data model BlockNum headers_stage_block_num = 0; HeaderDataModelForTest hm{tx, data_model, headers_stage_block_num}; hm.update_tables(header1); hm.update_tables(header2); // check internal status intx::uint256 expected_td = header0->difficulty + header1.difficulty + header2.difficulty; REQUIRE(hm.total_difficulty() == expected_td); REQUIRE(hm.max_block_num() == 2); REQUIRE(hm.max_hash() == header2_hash); // check db content // REQUIRE(read_head_header_hash(tx) == header2_hash); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td); // Now we suppose CL triggers an unwind, resetting to h0 BlockNum headers_stage_block_num_fork = 0; HeaderDataModelForTest hm_fork{tx, data_model, headers_stage_block_num_fork}; hm_fork.update_tables(header1b); // suppose it arrives after header2 // check internal status intx::uint256 expected_td_fork = header0->difficulty + header1b.difficulty; REQUIRE(hm_fork.total_difficulty() == expected_td_fork); REQUIRE(hm_fork.max_block_num() == 1); REQUIRE(hm_fork.max_hash() == header1b_hash); // check db content // REQUIRE(read_head_header_hash(tx) == header1b_hash); REQUIRE(read_total_difficulty(tx, 1, header1b_hash) == expected_td_fork); REQUIRE(read_total_difficulty(tx, 2, header2.hash()) == expected_td); // this should remain } } } // namespace silkworm ================================================ FILE: silkworm/node/stagedsync/stages/stage_history_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_history_index.hpp" #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; using silkworm::datastore::kvdb::from_slice; using silkworm::datastore::kvdb::to_slice; namespace bitmap { using namespace silkworm::datastore::kvdb::bitmap; } Stage::Result HistoryIndex::forward(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; auto previous_progress_accounts{stages::read_stage_progress(txn, stages::kAccountHistoryIndexKey)}; auto previous_progress_storage{stages::read_stage_progress(txn, stages::kStorageHistoryIndexKey)}; const auto target_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress == target_progress) { // Nothing to process operation_ = OperationType::kNone; return ret; } if (previous_progress > target_progress) { // Something bad had happened. Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "HistoryIndex progress " + std::to_string(previous_progress) + " greater than Execution progress " + std::to_string(target_progress)); } reset_log_progress(); const BlockNum segment_width{target_progress - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(target_progress), "span", std::to_string(segment_width)}); } // If this is first time we forward AND we have "prune history" set // do not process all blocks rather only what is needed if (prune_mode_history_.enabled()) { if (!previous_progress_accounts) previous_progress_accounts = prune_mode_history_.value_from_head(target_progress); if (!previous_progress_storage) previous_progress_storage = prune_mode_history_.value_from_head(target_progress); } collector_ = std::make_unique(etl_settings_); if (previous_progress_accounts < target_progress) { success_or_throw(forward_impl(txn, previous_progress_accounts, target_progress, false)); txn.commit_and_renew(); } if (previous_progress_storage < target_progress) { success_or_throw(forward_impl(txn, previous_progress_storage, target_progress, true)); txn.commit_and_renew(); } reset_log_progress(); update_progress(txn, target_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } collector_.reset(); operation_ = OperationType::kNone; return is_stopping() ? Stage::Result::kAborted : ret; } Stage::Result HistoryIndex::unwind(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto previous_progress_accounts{ stages::read_stage_progress(txn, stages::kAccountHistoryIndexKey)}; const auto previous_progress_storage{ stages::read_stage_progress(txn, stages::kStorageHistoryIndexKey)}; const auto execution_stage_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress <= to || execution_stage_progress <= to) { // Nothing to process operation_ = OperationType::kNone; return ret; } reset_log_progress(); const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } if (previous_progress_accounts && previous_progress_accounts > to) success_or_throw(unwind_impl(txn, previous_progress_accounts, to, false)); if (previous_progress_storage && previous_progress_storage > to) success_or_throw(unwind_impl(txn, previous_progress_storage, to, true)); reset_log_progress(); update_progress(txn, to); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } collector_.reset(); operation_ = OperationType::kNone; return is_stopping() ? Stage::Result::kAborted : ret; } Stage::Result HistoryIndex::prune(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kPrune; try { throw_if_stopping(); if (!prune_mode_history_.enabled()) { operation_ = OperationType::kNone; return ret; } const auto forward_progress{get_progress(txn)}; const auto prune_progress{get_prune_progress(txn)}; if (prune_progress >= forward_progress) { operation_ = OperationType::kNone; return ret; } // Need to erase all history info below this threshold // If threshold is zero we don't have anything to prune const auto prune_threshold{prune_mode_history_.value_from_head(forward_progress)}; if (!prune_threshold) { operation_ = OperationType::kNone; return ret; } reset_log_progress(); const BlockNum segment_width{forward_progress - prune_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } // We split the stage in two const auto prune_progress_accounts{ stages::read_stage_prune_progress(txn, stages::kAccountHistoryIndexKey)}; const auto prune_progress_storage{ stages::read_stage_prune_progress(txn, stages::kStorageHistoryIndexKey)}; if (!prune_progress_accounts || prune_progress_accounts < forward_progress) success_or_throw(prune_impl(txn, prune_threshold, forward_progress, /*storage=*/false)); if (!prune_progress_storage || prune_progress_storage < forward_progress) success_or_throw(prune_impl(txn, prune_threshold, forward_progress, /*storage=*/true)); reset_log_progress(); stages::write_stage_prune_progress(txn, stage_name_, forward_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result HistoryIndex::forward_impl(RWTxn& txn, const BlockNum from, const BlockNum to, const bool storage) { const MapConfig source_config{storage ? table::kStorageChangeSet : table::kAccountChangeSet}; const MapConfig target_config{storage ? table::kStorageHistory : table::kAccountHistory}; const size_t target_key_size{kAddressLength + (storage ? kHashLength : 0)}; std::unique_lock log_lck(sl_mutex_); loading_ = false; current_source_ = std::string(source_config.name); current_target_ = std::string(target_config.name); current_key_.clear(); log_lck.unlock(); // Into etl collect_bitmaps_from_changeset(txn, source_config, from, to, storage); if (!collector_->empty()) { log_lck.lock(); loading_ = true; index_loader_ = std::make_unique(target_config); log_lck.unlock(); index_loader_->merge_bitmaps(txn, target_key_size, collector_.get()); log_lck.lock(); loading_ = false; index_loader_.reset(); current_source_.clear(); current_target_.clear(); log_lck.unlock(); } stages::write_stage_progress( txn, (storage ? stages::kStorageHistoryIndexKey : stages::kAccountHistoryIndexKey), to); return Stage::Result::kSuccess; } Stage::Result HistoryIndex::unwind_impl(RWTxn& txn, const BlockNum from, const BlockNum to, const bool storage) { const MapConfig source_config{storage ? table::kStorageChangeSet : table::kAccountChangeSet}; const MapConfig target_config{storage ? table::kStorageHistory : table::kAccountHistory}; std::unique_lock log_lck(sl_mutex_); loading_ = false; current_source_ = std::string(source_config.name); current_target_ = std::string(target_config.name); current_key_.clear(); log_lck.unlock(); const auto keys{collect_unique_keys_from_changeset(txn, source_config, from, to, storage)}; log_lck.lock(); index_loader_ = std::make_unique(target_config); log_lck.unlock(); index_loader_->unwind_bitmaps(txn, to, keys); log_lck.lock(); index_loader_.reset(); current_source_.clear(); current_target_.clear(); current_key_.clear(); log_lck.unlock(); stages::write_stage_progress( txn, (storage ? stages::kStorageHistoryIndexKey : stages::kAccountHistoryIndexKey), to); return Stage::Result::kSuccess; } Stage::Result HistoryIndex::prune_impl(RWTxn& txn, const BlockNum threshold, const BlockNum to, const bool storage) { const MapConfig table_config{storage ? table::kStorageHistory : table::kAccountHistory}; std::unique_lock log_lck(sl_mutex_); loading_ = false; current_source_ = std::string(table_config.name); current_target_ = current_source_; current_key_.clear(); index_loader_ = std::make_unique(table_config); log_lck.unlock(); index_loader_->prune_bitmaps(txn, threshold); log_lck.lock(); index_loader_.reset(); current_source_.clear(); current_target_.clear(); current_key_.clear(); log_lck.unlock(); stages::write_stage_prune_progress( txn, (storage ? stages::kStorageHistoryIndexKey : stages::kAccountHistoryIndexKey), to); return Stage::Result::kSuccess; } void HistoryIndex::collect_bitmaps_from_changeset(RWTxn& txn, const MapConfig& source_config, const BlockNum from, const BlockNum to, bool storage) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; absl::btree_map bitmaps; auto bitmaps_it{bitmaps.begin()}; Bytes bitmaps_key{}; size_t bitmaps_size{0}; // To account flushing threshold uint16_t flush_count{0}; // To account number of flushings const BlockNum max_block_num{to}; BlockNum reached_block_num{0}; auto start_key{block_key(from + 1)}; auto source = txn.ro_cursor_dup_sort(source_config); auto source_data{storage ? source->lower_bound(to_slice(start_key), false) : source->find(to_slice(start_key), false)}; while (source_data) { auto source_data_key_view{from_slice(source_data.key)}; reached_block_num = endian::load_big_u64(source_data_key_view.data()); if (reached_block_num > max_block_num) { break; } source_data_key_view.remove_prefix(sizeof(BlockNum)); // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } while (source_data) { const auto source_data_value_view{from_slice(source_data.value)}; if (storage) { // Contract address + location bitmaps_key.assign(source_data_key_view.substr(0, kAddressLength)) .append(source_data_value_view.substr(0, kHashLength)); } else { // Only address for accounts bitmaps_key.assign(source_data_value_view.substr(0, kAddressLength)); } bitmaps_it = bitmaps.find(bitmaps_key); if (bitmaps_it == bitmaps.end()) { bitmaps_it = bitmaps.emplace(bitmaps_key, roaring::Roaring64Map()).first; bitmaps_size += bitmaps_key.size(); bitmaps_size += sizeof(uint64_t); // see Roaring64Map()::getSizeInBytes() } bitmaps_it->second.add(reached_block_num); bitmaps_size += sizeof(uint32_t); // All blocks <= UINT32_MAX // Is there a chain exceeding that block_num ? source_data = source->to_current_next_multi(false); } // Flush bitmaps to etl if necessary if (bitmaps_size >= batch_size_) { bitmap::IndexLoader::flush_bitmaps_to_etl(bitmaps, collector_.get(), flush_count++); bitmaps_size = 0; } source_data = source->to_next(false); } if (bitmaps_size) { bitmap::IndexLoader::flush_bitmaps_to_etl(bitmaps, collector_.get(), flush_count); } } std::map HistoryIndex::collect_unique_keys_from_changeset( RWTxn& txn, const MapConfig& source_config, BlockNum from, BlockNum to, bool storage) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; std::map ret; Bytes unique_key{}; const BlockNum max_block_num{std::max(from, to)}; auto start_key{block_key(std::min(from, to) + 1)}; auto source = txn.ro_cursor_dup_sort(source_config); auto source_data{storage ? source->lower_bound(to_slice(start_key), false) : source->find(to_slice(start_key), false)}; BlockNum reached_block_num{0}; while (source_data) { auto source_data_key_view{from_slice(source_data.key)}; reached_block_num = endian::load_big_u64(source_data_key_view.data()); if (reached_block_num > max_block_num) break; source_data_key_view.remove_prefix(sizeof(BlockNum)); // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } while (source_data) { auto source_data_value_view{from_slice(source_data.value)}; if (storage) { // Contract address + location unique_key.assign(source_data_key_view.substr(0, kAddressLength)) .append(source_data_value_view.substr(0, kHashLength)); source_data_value_view.remove_prefix(kHashLength); } else { // Only address for accounts unique_key.assign(source_data_value_view.substr(0, kAddressLength)); source_data_value_view.remove_prefix(kAddressLength); } if (!ret.contains(unique_key)) { (void)ret.emplace(unique_key, source_data_value_view.empty()); } source_data = source->to_current_next_multi(false); } source_data = source->to_next(false); } return ret; } std::vector HistoryIndex::get_log_progress() { std::unique_lock log_lck(sl_mutex_); std::vector ret{"op", std::string(magic_enum::enum_name(operation_))}; if (current_source_.empty() && current_target_.empty()) { ret.insert(ret.end(), {"db", "waiting ..."}); } else { switch (operation_) { case OperationType::kForward: if (loading_) { current_key_ = collector_ ? abridge(collector_->get_load_key(), kAddressLength) : ""; ret.insert(ret.end(), {"from", "etl", "to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "to", "etl", "key", current_key_}); } break; case OperationType::kUnwind: if (index_loader_) { current_key_ = index_loader_->get_current_key(); ret.insert(ret.end(), {"from", "etl", "to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "to", "etl", "key", current_key_}); } break; case OperationType::kPrune: if (index_loader_) { current_key_ = index_loader_->get_current_key(); ret.insert(ret.end(), {"to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"to", current_target_, current_key_}); } break; default: ret.insert(ret.end(), {"from", current_source_, "key", current_key_}); } } return ret; } void HistoryIndex::reset_log_progress() { std::unique_lock log_lck(sl_mutex_); loading_ = false; current_source_.clear(); current_target_.clear(); current_key_.clear(); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_history_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::stagedsync { class HistoryIndex : public Stage { public: HistoryIndex( SyncContext* sync_context, size_t batch_size, datastore::etl::CollectorSettings etl_settings, db::BlockAmount prune_mode_history) : Stage(sync_context, db::stages::kHistoryIndexKey), batch_size_(batch_size), etl_settings_(std::move(etl_settings)), prune_mode_history_(prune_mode_history) {} HistoryIndex(const HistoryIndex&) = delete; // not copyable HistoryIndex(HistoryIndex&&) = delete; // nor movable ~HistoryIndex() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: size_t batch_size_; datastore::etl::CollectorSettings etl_settings_; db::BlockAmount prune_mode_history_; std::unique_ptr collector_; std::unique_ptr index_loader_; std::atomic_bool loading_{false}; // Whether we're in ETL loading phase std::string current_source_; // Current source of data std::string current_target_; // Current target of transformed data std::string current_key_; // Actual processing key Stage::Result forward_impl(db::RWTxn& txn, BlockNum from, BlockNum to, bool storage); Stage::Result unwind_impl(db::RWTxn& txn, BlockNum from, BlockNum to, bool storage); Stage::Result prune_impl(db::RWTxn& txn, BlockNum threshold, BlockNum to, bool storage); //! \brief Collects bitmaps of block numbers changes for each account within provided //! changeset boundaries void collect_bitmaps_from_changeset(db::RWTxn& txn, const db::MapConfig& source_config, BlockNum from, BlockNum to, bool storage); //! \brief Collects unique keys touched by changesets within provided boundaries std::map collect_unique_keys_from_changeset( db::RWTxn& txn, const db::MapConfig& source_config, BlockNum from, BlockNum to, bool storage); void reset_log_progress(); // Clears out all logging vars }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_history_index_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { using namespace evmc::literals; using namespace silkworm::db; using namespace silkworm::datastore::kvdb; using db::test_util::TempChainData; stagedsync::HistoryIndex make_stage_history_index( stagedsync::SyncContext* sync_context, const TempChainData& chain_data) { static constexpr size_t kBatchSize = 512_Mebi; return stagedsync::HistoryIndex{ sync_context, kBatchSize, datastore::etl::CollectorSettings{ .work_path = chain_data.dir().temp().path(), .buffer_size = 256_Mebi}, chain_data.prune_mode().history(), }; } TEST_CASE("Stage History Index") { TempChainData context; RWTxn& txn{context.rw_txn()}; txn.disable_commit(); SECTION("Check bitmaps values") { // --------------------------------------- // Prepare // --------------------------------------- uint64_t block_num{1}; auto miner{0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c_address}; Block block{}; block.header.number = block_num; block.header.beneficiary = miner; block.header.gas_limit = 100'000; block.header.gas_used = 63'820; // This contract initially sets its 0th storage to 0x2a // and its 1st storage to 0x01c9. // When called, it updates its 0th storage to the input provided. Bytes contract_code{*from_hex("600035600055")}; Bytes deployment_code{*from_hex("602a6000556101c960015560068060166000396000f3") + contract_code}; block.transactions.resize(1); block.transactions[0].data = deployment_code; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].max_priority_fee_per_gas = 20 * kGiga; block.transactions[0].max_fee_per_gas = block.transactions[0].max_priority_fee_per_gas; auto sender{0xb685342b8c54347aad148e1f22eff3eb3eb29391_address}; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(sender); Buffer buffer{txn, std::make_unique(txn)}; Account sender_account{}; sender_account.balance = kEther; buffer.update_account(sender, std::nullopt, sender_account); // --------------------------------------- // Execute first block // --------------------------------------- CHECK(execute_block(block, buffer, kMainnetConfig) == ValidationResult::kOk); auto contract_address{create_address(sender, /*nonce=*/0)}; // --------------------------------------- // Execute second block // --------------------------------------- std::string new_val{"000000000000000000000000000000000000000000000000000000000000003e"}; block_num = 2; block.header.number = block_num; block.header.gas_used = 26'201; block.transactions[0].nonce = 1; block.transactions[0].value = 1000; block.transactions[0].to = contract_address; block.transactions[0].data = *from_hex(new_val); CHECK(execute_block(block, buffer, kMainnetConfig) == ValidationResult::kOk); // --------------------------------------- // Execute third block // --------------------------------------- new_val = "000000000000000000000000000000000000000000000000000000000000003b"; block_num = 3; block.header.number = block_num; block.header.gas_used = 26'201; block.transactions[0].nonce = 2; block.transactions[0].value = 1000; block.transactions[0].to = contract_address; block.transactions[0].data = *from_hex(new_val); CHECK(execute_block(block, buffer, kMainnetConfig) == ValidationResult::kOk); buffer.write_to_db(); stages::write_stage_progress(txn, stages::kExecutionKey, 3); SECTION("Forward and Unwind") { PooledCursor account_changes(txn, table::kAccountChangeSet); REQUIRE(!account_changes.empty()); stagedsync::SyncContext sync_context{}; stagedsync::HistoryIndex stage_history_index = make_stage_history_index(&sync_context, context); REQUIRE(stage_history_index.forward(txn) == stagedsync::Stage::Result::kSuccess); PooledCursor account_history(txn, table::kAccountHistory); PooledCursor storage_history(txn, table::kStorageHistory); REQUIRE(!account_history.empty()); REQUIRE(!storage_history.empty()); // Miner has mined 3 blocks hence is historical balance must be < current balance auto current_miner_account{read_account(txn, miner)}; auto historical_miner_account{read_account(txn, miner, 2)}; REQUIRE(current_miner_account.has_value()); REQUIRE(historical_miner_account.has_value()); REQUIRE(historical_miner_account->balance); REQUIRE(historical_miner_account->balance < current_miner_account->balance); auto account_history_data{account_history.lower_bound(to_slice(sender), /*throw_notfound=*/false)}; REQUIRE(account_history_data.done); auto account_history_data_view{from_slice(account_history_data.key)}; REQUIRE(endian::load_big_u64(&account_history_data_view[account_history_data_view.size() - 8]) == UINT64_MAX); auto account_history_bitmap{bitmap::parse(account_history_data.value)}; REQUIRE(account_history_bitmap.cardinality() == 3); REQUIRE(account_history_bitmap.toString() == "{1,2,3}"); auto storage_history_data{ storage_history.lower_bound(to_slice(contract_address), /*throw_notfound=*/false)}; REQUIRE(storage_history_data.done); auto storage_history_data_view{from_slice(storage_history_data.key)}; REQUIRE(endian::load_big_u64(&storage_history_data_view[storage_history_data_view.size() - 8]) == UINT64_MAX); auto storage_history_bitmap{bitmap::parse(storage_history_data.value)}; REQUIRE(storage_history_bitmap.cardinality() == 3); REQUIRE(storage_history_bitmap.toString() == "{1,2,3}"); // The location is the first so it's at 0 evmc::bytes32 location{0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}; // Composite: Address + Location Bytes composite(kAddressLength + kHashLength, '\0'); std::memcpy(&composite[0], contract_address.bytes, kAddressLength); std::memcpy(&composite[kAddressLength], location.bytes, kHashLength); // Storage retrieving from Database storage_history_data = storage_history.lower_bound(to_slice(composite), false); REQUIRE(storage_history_data.done); storage_history_data_view = from_slice(storage_history_data.key); REQUIRE(storage_history_data_view.starts_with(composite)); REQUIRE(endian::load_big_u64(&storage_history_data_view[storage_history_data_view.size() - 8]) == UINT64_MAX); storage_history_bitmap = bitmap::parse(storage_history_data.value); REQUIRE(storage_history_bitmap.cardinality() == 3); REQUIRE(storage_history_bitmap.toString() == "{1,2,3}"); sync_context.unwind_point.emplace(2); REQUIRE(stage_history_index.unwind(txn) == stagedsync::Stage::Result::kSuccess); REQUIRE(stages::read_stage_progress(txn, stages::kHistoryIndexKey) == 2); // Account retrieving from Database account_history_data = account_history.lower_bound(to_slice(sender), /*throw_notfound=*/false); REQUIRE(account_history_data.done); account_history_bitmap = bitmap::parse(account_history_data.value); REQUIRE(account_history_bitmap.cardinality() == 2); REQUIRE(account_history_bitmap.toString() == "{1,2}"); // Contract retrieving from Database account_history_data = account_history.lower_bound(to_slice(contract_address), /*throw_notfound=*/false); REQUIRE(account_history_data.done); account_history_bitmap = bitmap::parse(account_history_data.value); REQUIRE(account_history_bitmap.cardinality() == 2); REQUIRE(account_history_bitmap.toString() == "{1,2}"); // Storage retrieving from Database storage_history_data = storage_history.lower_bound(to_slice(composite), false); REQUIRE(storage_history_data.done); storage_history_data_view = from_slice(storage_history_data.key); REQUIRE(storage_history_data_view.starts_with(composite)); REQUIRE(endian::load_big_u64(&storage_history_data_view[storage_history_data_view.size() - 8]) == UINT64_MAX); storage_history_bitmap = bitmap::parse(storage_history_data.value); REQUIRE(storage_history_bitmap.cardinality() == 2); REQUIRE(storage_history_bitmap.toString() == "{1,2}"); } SECTION("Prune") { // Prune from second block, so we delete block 1 // Alter node settings pruning PruneDistance older_history, older_receipts, older_senders, older_tx_index, older_call_traces; PruneThreshold before_history, before_receipts, before_senders, before_tx_index, before_call_traces; before_history.emplace(2); // Will delete any history before block 2 context.set_prune_mode( parse_prune_mode("h", older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces)); REQUIRE(context.prune_mode().history().enabled()); stagedsync::SyncContext sync_context{}; stagedsync::HistoryIndex stage_history_index = make_stage_history_index(&sync_context, context); REQUIRE(stage_history_index.forward(txn) == stagedsync::Stage::Result::kSuccess); REQUIRE(stage_history_index.prune(txn) == stagedsync::Stage::Result::kSuccess); REQUIRE(stages::read_stage_progress(txn, stages::kHistoryIndexKey) == 3); REQUIRE(stages::read_stage_prune_progress(txn, stages::kHistoryIndexKey) == 3); PooledCursor account_history(txn, table::kAccountHistory); PooledCursor storage_history(txn, table::kStorageHistory); REQUIRE(!account_history.empty()); REQUIRE(!storage_history.empty()); auto account_history_data{account_history.lower_bound(to_slice(sender), /*throw_notfound=*/false)}; REQUIRE(account_history_data.done); auto account_history_data_view{from_slice(account_history_data.key)}; REQUIRE(endian::load_big_u64(&account_history_data_view[account_history_data_view.size() - 8]) == UINT64_MAX); auto account_history_bitmap{bitmap::parse(account_history_data.value)}; REQUIRE(account_history_bitmap.cardinality() == 2); REQUIRE(account_history_bitmap.toString() == "{2,3}"); auto storage_history_data{ storage_history.lower_bound(to_slice(contract_address), /*throw_notfound=*/false)}; REQUIRE(storage_history_data.done); auto storage_history_data_view{from_slice(storage_history_data.key)}; REQUIRE(endian::load_big_u64(&storage_history_data_view[storage_history_data_view.size() - 8]) == UINT64_MAX); auto storage_history_bitmap{bitmap::parse(storage_history_data.value)}; REQUIRE(storage_history_bitmap.cardinality() == 2); REQUIRE(storage_history_bitmap.toString() == "{2,3}"); // The location is the first so it's at 0 evmc::bytes32 location{0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}; // Composite: Address + Location Bytes composite(kAddressLength + kHashLength, '\0'); std::memcpy(&composite[0], contract_address.bytes, kAddressLength); std::memcpy(&composite[kAddressLength], location.bytes, kHashLength); // Storage retrieving from Database storage_history_data = storage_history.lower_bound(to_slice(composite), false); REQUIRE(storage_history_data.done); storage_history_data_view = from_slice(storage_history_data.key); REQUIRE(storage_history_data_view.starts_with(composite)); REQUIRE(endian::load_big_u64(&storage_history_data_view[storage_history_data_view.size() - 8]) == UINT64_MAX); storage_history_bitmap = bitmap::parse(storage_history_data.value); REQUIRE(storage_history_bitmap.cardinality() == 2); REQUIRE(storage_history_bitmap.toString() == "{2,3}"); } } SECTION("Large dataset") { const Bytes non_empty(1, '\1'); std::vector addresses{{0x0000000000000000000000000000000000000001_address}, {0x0000000000000000000000000000000000000002_address}, {0x0000000000000000000000000000000000000003_address}}; // Use a large dataset in change sets (actual values do not matter) PooledCursor account_changeset(txn, table::kAccountChangeSet); BlockNum block_num = 1; for (; block_num <= 50000; ++block_num) { const auto block_key{db::block_key(block_num)}; for (const auto& address : addresses) { Bytes value(kAddressLength, '\0'); std::memcpy(&value[0], address.bytes, kAddressLength); value.append(non_empty); auto value_slice{to_slice(value)}; mdbx::error::success_or_throw( account_changeset.put(to_slice(block_key), &value_slice, MDBX_put_flags_t::MDBX_APPENDDUP)); } } // Fake generation of changesets stages::write_stage_progress(txn, stages::kExecutionKey, block_num - 1); // Forward history stagedsync::SyncContext sync_context{}; stagedsync::HistoryIndex stage_history_index = make_stage_history_index(&sync_context, context); REQUIRE(stage_history_index.forward(txn) == stagedsync::Stage::Result::kSuccess); PooledCursor account_history(txn, table::kAccountHistory); auto batch_1{account_history.size()}; REQUIRE(batch_1 != 0); auto check_addresses{[&account_history, &block_num](const std::vector& addrs) { for (const auto& address : addrs) { Bytes key(kAddressLength, '\0'); std::memcpy(&key[0], address.bytes, kAddressLength); key.append(block_key(UINT64_MAX)); bool has_thrown{false}; try { auto data = account_history.find(to_slice(key), /*throw_notfound=*/true); auto bitmap{bitmap::parse(data.value)}; REQUIRE(bitmap.maximum() == block_num - 1); } catch (...) { has_thrown = true; } REQUIRE_FALSE(has_thrown); } }}; // Ensure each of the accounts has a record in history with key address + UINT64_MAX(BE) // and it's stored bitmap as a maximum value of 5000 check_addresses(addresses); // Given the amount of blocks each address should hold 2 shards for (const auto& address : addresses) { Bytes prefix(kAddressLength, '\0'); std::memcpy(&prefix[0], address.bytes, kAddressLength); auto count{ cursor_for_prefix(account_history, prefix, [](ByteView, ByteView) {})}; REQUIRE(count == 2); } // Add one address and store changes from current block_num onwards { addresses.push_back(0x0000000000000000000000000000000000000004_address); const auto block_key{db::block_key(block_num++)}; Bytes value(kAddressLength, '\0'); std::memcpy(&value[0], addresses.back().bytes, kAddressLength); auto value_slice{to_slice(value)}; mdbx::error::success_or_throw( account_changeset.put(to_slice(block_key), &value_slice, MDBX_put_flags_t::MDBX_APPENDDUP)); } for (; block_num <= 100000; ++block_num) { const auto block_key{db::block_key(block_num)}; for (const auto& address : addresses) { Bytes value(kAddressLength, '\0'); std::memcpy(&value[0], address.bytes, kAddressLength); value.append(non_empty); auto value_slice{to_slice(value)}; mdbx::error::success_or_throw( account_changeset.put(to_slice(block_key), &value_slice, MDBX_put_flags_t::MDBX_APPENDDUP)); } } stages::write_stage_progress(txn, stages::kExecutionKey, block_num - 1); txn.commit_and_renew(); REQUIRE(stage_history_index.forward(txn) == stagedsync::Stage::Result::kSuccess); account_history.bind(txn, table::kAccountHistory); REQUIRE(batch_1 < account_history.size()); check_addresses(addresses); txn.commit_and_renew(); // Unwind to 4000 and ensure account 4 has been removed from history sync_context.unwind_point.emplace(4'000); REQUIRE(stage_history_index.unwind(txn) == stagedsync::Stage::Result::kSuccess); { Bytes prefix(kAddressLength, '\0'); std::memcpy(&prefix[0], addresses.back().bytes, kAddressLength); auto count{ cursor_for_prefix(account_history, prefix, [](ByteView, ByteView) {})}; REQUIRE(count == 0); addresses.pop_back(); // Remove unused address for next tests } // Each key must have only 1 record now which has UINT64_MAX suffix for (const auto& address : addresses) { Bytes prefix(kAddressLength, '\0'); std::memcpy(&prefix[0], address.bytes, kAddressLength); auto count{cursor_for_prefix( account_history, prefix, [](ByteView key, ByteView value) { CHECK(endian::load_big_u64(&key[key.size() - sizeof(BlockNum)]) == UINT64_MAX); const auto bitmap{bitmap::parse(value)}; CHECK(bitmap.maximum() == 4000); })}; REQUIRE(count == 1); } // Prune from block 3590 // Alter node settings pruning PruneDistance older_history, older_receipts, older_senders, older_tx_index, older_call_traces; PruneThreshold before_history, before_receipts, before_senders, before_tx_index, before_call_traces; before_history.emplace(3590); // Will delete any history before block 2 context.set_prune_mode( parse_prune_mode("h", older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces)); REQUIRE(context.prune_mode().history().enabled()); // Recreate the stage with enabled pruning stagedsync::HistoryIndex stage_history_index2 = make_stage_history_index(&sync_context, context); REQUIRE(stage_history_index2.prune(txn) == stagedsync::Stage::Result::kSuccess); // Each key must have only 1 record now which has UINT64_MAX suffix AND bitmap max value must be 3590 for (const auto& address : addresses) { Bytes prefix(kAddressLength, '\0'); std::memcpy(&prefix[0], address.bytes, kAddressLength); auto count{cursor_for_prefix( account_history, prefix, [](ByteView key, ByteView value) { CHECK(endian::load_big_u64(&key[key.size() - sizeof(BlockNum)]) == UINT64_MAX); const auto bitmap{bitmap::parse(value)}; CHECK(bitmap.minimum() == 3590); })}; REQUIRE(count == 1); } } } TEST_CASE("HistoryIndex + Account access_layer") { TempChainData context; RWTxn& txn{context.rw_txn()}; Buffer buffer{txn, std::make_unique(txn)}; const evmc::address miner_a{0x00000000000000000000000000000000000000aa_address}; const evmc::address miner_b{0x00000000000000000000000000000000000000bb_address}; Block block1; block1.header.number = 1; block1.header.beneficiary = miner_a; // miner_a gets one block reward REQUIRE(execute_block(block1, buffer, test::kFrontierConfig) == ValidationResult::kOk); Block block2; block2.header.number = 2; block2.header.beneficiary = miner_b; // miner_a gets nothing REQUIRE(execute_block(block2, buffer, test::kFrontierConfig) == ValidationResult::kOk); Block block3; block3.header.number = 3; block3.header.beneficiary = miner_a; // miner_a gets another block reward REQUIRE(execute_block(block3, buffer, test::kFrontierConfig) == ValidationResult::kOk); buffer.write_to_db(); stages::write_stage_progress(txn, stages::kExecutionKey, 3); stagedsync::SyncContext sync_context{}; stagedsync::HistoryIndex stage_history_index = make_stage_history_index(&sync_context, context); REQUIRE(stage_history_index.forward(txn) == stagedsync::Stage::Result::kSuccess); std::optional current_account{read_account(txn, miner_a)}; REQUIRE(current_account.has_value()); CHECK(current_account->balance == 2 * protocol::kBlockRewardFrontier); std::optional historical_account{read_account(txn, miner_a, /*block_num=*/2)}; REQUIRE(historical_account.has_value()); CHECK(intx::to_string(historical_account->balance) == std::to_string(protocol::kBlockRewardFrontier)); std::optional previous_incarnation{read_previous_incarnation(txn, miner_a, /*block_num=*/2)}; REQUIRE(previous_incarnation.has_value()); CHECK(previous_incarnation == 0); } } // namespace silkworm ================================================ FILE: silkworm/node/stagedsync/stages/stage_interhashes/_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::trie { using namespace silkworm::db; using namespace silkworm::db::state; using namespace silkworm::datastore::kvdb; using datastore::kvdb::Collector; static ethash::hash256 keccak256(const evmc::address& address) { return silkworm::keccak256(address.bytes); } TEST_CASE("Trie Cursor") { test_util::TempChainData db_context{}; auto txn{db_context.txn()}; SECTION("Only root trie no changes") { trie::PrefixSet changed_accounts{}; PooledCursor trie_accounts(txn, table::kTrieOfAccounts); trie::TrieCursor ta_cursor{trie_accounts, &changed_accounts}; Bytes k{}; Bytes v{*from_hex( "0xfffffffffffff587705b56c193a582ba235d2fbc0714369dc24c60df85bb6b010c405d6d4ff1c587157345c796457244932c27c7" "2a5b59b2af68229aced2a35c11064fcb52183c3a01330eeb55d1bc5229391d98f1d47677ff57f04aa31bccb2eae0458bf2435fc423" "08a6097114f741d87630f06fd8f8ff6b11889389b1f65e2ac07cc239233c896ad842d010f886b4ffbc558eb8dc2f20ad47f0fc082f" "c081d1ed1c354d51e1c6c148e00033f6699ff564e316647628c9d9b51204faf3841a6ca538e768be56a17afb284f6a858115b652be" "24501d6d8ecce5bf9e0581f19c908584f77db54869d85531ca872cf92d84a3dc3f9bafd302460fc3794ff14ff501e8220f40225561" "b133453ccddfdffe47be42f60fa2bccf1da4c067778c48b17f4d5b8ff3de9bf082bed77a58e8b350d503a409ceb9f0816cfe2c172e" "6505e2693431e48366118133493304604905a658efcccb180651eefbc857fbc4da230e20e8efe27a68231806d17d5ed83cb3fcf567" "e85099023711366935ed021785e4b34c071d5cfc03fa21bc068d956f62ba45516a74739733ff1eadfbd25dce36f25e4dfa8af5327f" "67beb3125b34103b14f16d88f9c68fc4516203fad53c3a2c405ef83201fee92bd4fb7cfb1022b46d6507c31957b94580926086c547" "b804061bfa46e86139874800ae6d6f9f79097ac8c221e9229d13a45a0864a3fda170863bb6513010e95cfdd3f4bb151c7d242a682a" "16041a426bea6de01aa9ed925e80d5fed57c302988")}; trie_accounts.insert(to_slice(k), to_slice(v)); auto ta_data{ta_cursor.to_prefix({})}; REQUIRE((ta_data.key.has_value() == true && ta_data.key.value().empty())); REQUIRE(ta_data.first_uncovered.has_value() == false); REQUIRE(ta_data.hash.has_value() == true); bool has_thrown{false}; try { // Must throw as we're at the end of tree ta_data = ta_cursor.to_next(); } catch (...) { has_thrown = true; } REQUIRE(has_thrown); } SECTION("Only root trie with changes") { trie::PrefixSet changed_accounts{}; PooledCursor trie_accounts(txn, table::kTrieOfAccounts); trie::TrieCursor ta_cursor{trie_accounts, &changed_accounts}; Bytes k{}; Bytes v{*from_hex( "0xfffffffffffff587705b56c193a582ba235d2fbc0714369dc24c60df85bb6b010c405d6d4ff1c587157345c796457244932c27c7" "2a5b59b2af68229aced2a35c11064fcb52183c3a01330eeb55d1bc5229391d98f1d47677ff57f04aa31bccb2eae0458bf2435fc423" "08a6097114f741d87630f06fd8f8ff6b11889389b1f65e2ac07cc239233c896ad842d010f886b4ffbc558eb8dc2f20ad47f0fc082f" "c081d1ed1c354d51e1c6c148e00033f6699ff564e316647628c9d9b51204faf3841a6ca538e768be56a17afb284f6a858115b652be" "24501d6d8ecce5bf9e0581f19c908584f77db54869d85531ca872cf92d84a3dc3f9bafd302460fc3794ff14ff501e8220f40225561" "b133453ccddfdffe47be42f60fa2bccf1da4c067778c48b17f4d5b8ff3de9bf082bed77a58e8b350d503a409ceb9f0816cfe2c172e" "6505e2693431e48366118133493304604905a658efcccb180651eefbc857fbc4da230e20e8efe27a68231806d17d5ed83cb3fcf567" "e85099023711366935ed021785e4b34c071d5cfc03fa21bc068d956f62ba45516a74739733ff1eadfbd25dce36f25e4dfa8af5327f" "67beb3125b34103b14f16d88f9c68fc4516203fad53c3a2c405ef83201fee92bd4fb7cfb1022b46d6507c31957b94580926086c547" "b804061bfa46e86139874800ae6d6f9f79097ac8c221e9229d13a45a0864a3fda170863bb6513010e95cfdd3f4bb151c7d242a682a" "16041a426bea6de01aa9ed925e80d5fed57c302988")}; trie_accounts.insert(to_slice(k), to_slice(v)); changed_accounts.insert(*from_hex("0x000001")); bool has_thrown{false}; try { // Must throw as it can't find child 00 (void)ta_cursor.to_prefix({}); } catch (...) { has_thrown = true; } REQUIRE(has_thrown); } SECTION("Root + child with changes") { Collector collector{db_context.dir().path()}; trie::PrefixSet changed_accounts{}; PooledCursor trie_accounts(txn, table::kTrieOfAccounts); trie::TrieCursor ta_cursor{trie_accounts, &changed_accounts, &collector}; Bytes k{}; Bytes v{*from_hex( "0xfffffffffffff587705b56c193a582ba235d2fbc0714369dc24c60df85bb6b010c405d6d4ff1c587157345c796457244932c27c7" "2a5b59b2af68229aced2a35c11064fcb52183c3a01330eeb55d1bc5229391d98f1d47677ff57f04aa31bccb2eae0458bf2435fc423" "08a6097114f741d87630f06fd8f8ff6b11889389b1f65e2ac07cc239233c896ad842d010f886b4ffbc558eb8dc2f20ad47f0fc082f" "c081d1ed1c354d51e1c6c148e00033f6699ff564e316647628c9d9b51204faf3841a6ca538e768be56a17afb284f6a858115b652be" "24501d6d8ecce5bf9e0581f19c908584f77db54869d85531ca872cf92d84a3dc3f9bafd302460fc3794ff14ff501e8220f40225561" "b133453ccddfdffe47be42f60fa2bccf1da4c067778c48b17f4d5b8ff3de9bf082bed77a58e8b350d503a409ceb9f0816cfe2c172e" "6505e2693431e48366118133493304604905a658efcccb180651eefbc857fbc4da230e20e8efe27a68231806d17d5ed83cb3fcf567" "e85099023711366935ed021785e4b34c071d5cfc03fa21bc068d956f62ba45516a74739733ff1eadfbd25dce36f25e4dfa8af5327f" "67beb3125b34103b14f16d88f9c68fc4516203fad53c3a2c405ef83201fee92bd4fb7cfb1022b46d6507c31957b94580926086c547" "b804061bfa46e86139874800ae6d6f9f79097ac8c221e9229d13a45a0864a3fda170863bb6513010e95cfdd3f4bb151c7d242a682a" "16041a426bea6de01aa9ed925e80d5fed57c302988")}; trie_accounts.insert(to_slice(k), to_slice(v)); k = *from_hex("0x00"); v = *from_hex( "0xffffffffffff061d711a452d9137600bc9a5fecb8fa8f4fe4496f232b0ec706c8fb601beff0b2652e642a62b64789a2565026172" "91e721c0b453fa9eac8d542ca04cb2867db59bcb89ce69e4e2ad0185e51482de826109c36f2cabd186fcbb4015d6ec43d6ee0a3baa" "8f90bb26daa90b18dbf4f7b256f3c847119b3ede4ce02d1ad5af1b05629be35bcaecab86eb1e15b0797d802cbb6c2c515e53abbc8c" "34e8b747089be40fceff32a5c0c2a5d115cb07f3bc86e14e90fb9538da1522a0ceddc6ee989c514ae54aebfbfe2d3d61bc48e46d09" "022477e184e44597b36be491d1dad83dc8ce00e81b80615e188d9b669c5938f3050e23e1c2db910526c65fb3e82c5743381c9295a8" "bc599bf76d9da8f4f6740e8d621426546490d79f5a24ca0f1894d81b817c1fdc989dcfd61eab6c79c6c136663d8aa7827dce04eb38" "168984adf51b4c72d8a0417df022c21b3b5f11917d9a0bbeb650745785793ccaa770bba8789e8025631c83eaf8beb6fa43b07bfcdc" "dceebdda2a2c6edad27f61d1441b631a7d6151b143d9e53230c753bd00ac41bc8e5bacb2deb575cbbcd85c889b27943e4be9a957cb" "8707ec51ee6b6bc877d1ceb5286146080ed0c0f51b81c48d125aed92d6987cab240a899fcfbcff78952c38d0d09a0364cf33dbe0b5" "aa6acd0cbab4c8bd7102392f16863b2c6ba09f74576d3599f35779abb3667116be78d9a188cec0e690ec"); changed_accounts.insert(*from_hex("0x010001")); auto ta_data{ta_cursor.to_prefix({})}; REQUIRE((ta_data.key.has_value() && ta_data.key.value() == *from_hex("0x00"))); REQUIRE(ta_data.first_uncovered.has_value() == false); REQUIRE(ta_data.hash.has_value() == true); REQUIRE(collector.empty() == false); // It MUST delete root node bool has_thrown{false}; try { // Must throw as it can't find child 01 (void)ta_cursor.to_next(); } catch (...) { has_thrown = true; } REQUIRE(has_thrown); } SECTION("Root + 16 children with changes") { Collector collector{db_context.dir().path()}; trie::PrefixSet changed_accounts{}; PooledCursor trie_accounts(txn, table::kTrieOfAccounts); trie::TrieCursor ta_cursor{trie_accounts, &changed_accounts, &collector}; // Fake root node with no hashes and only tree mask (must descend to all) Bytes k{}; Bytes v{*from_hex( "ffff" /* all state bits set */ "ffff" /* has all children */ "0000" /* no hash mask */ "061d711a452d9137600bc9a5fecb8fa8f4fe4496f232b0ec706c8fb601beff0b" /* root hash - must have it */)}; trie_accounts.insert(to_slice(k), to_slice(v)); // Generate 16 fake sub nodes - note root node above has all bits set in tree_mask v = *from_hex( "0001" /* at least one state bit */ "0000" /* no tree mask */ "0000" /* no hash mask */); for (uint8_t c{'\0'}; c < 0x10; ++c) { k.clear(); k.push_back(c); trie_accounts.insert(to_slice(k), to_slice(v)); } // Insert a change, so we don't get hash of root and // cursor forced to descend and traverse children changed_accounts.insert(*from_hex("0x000001")); // Moving to first MUST not throw REQUIRE_NOTHROW((void)ta_cursor.to_prefix({})); // Both root node and all child node should be traversed and deleted REQUIRE(collector.size() == 17); } SECTION("Empty prefixed trie no changes") { trie::PrefixSet changed_accounts{}; PooledCursor trie_storage(txn, table::kTrieOfStorage); trie::TrieCursor ts_cursor{trie_storage, &changed_accounts}; Bytes prefix{*from_hex("0xfff2bcbbf823e72a3a9025c14b96f5c28026735aeb7f19e5f2f317aa7a017c080000000000000001")}; auto ts_data{ts_cursor.to_prefix(prefix)}; REQUIRE(ts_data.key.has_value() == false); REQUIRE(ts_data.first_uncovered.has_value() == true); REQUIRE(ts_data.first_uncovered.value().empty() == true); REQUIRE(ts_data.hash.has_value() == false); bool has_thrown{false}; try { // Must throw as we're at the end of tree ts_data = ts_cursor.to_next(); } catch (...) { has_thrown = true; } REQUIRE(has_thrown); } SECTION("Missing prefixed root no changes") { trie::PrefixSet changed_storage{}; PooledCursor trie_storage(txn, table::kTrieOfStorage); Bytes k{ *from_hex("0xfff2bcbbf823e72a3a9025c14b96f5c28026735aeb7f19e5f2f317aa7a017c080000000000000001" /* prefix */ "00" /* first subnode */)}; Bytes v{ *from_hex("ffff" /* all state bits set */ "ffff" /* has all children */ "0000" /* no hash mask */ )}; trie_storage.insert(to_slice(k), to_slice(v)); trie::TrieCursor ts_cursor{trie_storage, &changed_storage}; Bytes prefix{*from_hex("0xfff2bcbbf823e72a3a9025c14b96f5c28026735aeb7f19e5f2f317aa7a017c080000000000000001")}; auto ts_data{ts_cursor.to_prefix(prefix)}; REQUIRE(ts_data.key.has_value() == false); REQUIRE(ts_data.first_uncovered.has_value() == true); REQUIRE(ts_data.first_uncovered.value().empty() == true); REQUIRE(ts_data.hash.has_value() == false); bool has_thrown{false}; try { // Must throw as we're at the end of tree ts_data = ts_cursor.to_next(); } catch (...) { has_thrown = true; } REQUIRE(has_thrown); } } TEST_CASE("Trie Cursor Increment Nibbles") { // Incrementable same level Bytes input{*from_hex("0x010203")}; std::optional incremented{trie::TrieCursor::increment_nibbled_key(input)}; REQUIRE(incremented.has_value()); REQUIRE(to_hex(*incremented, true) == "0x010204"); // Incrementable up one level input = *from_hex("0x01020f"); incremented = trie::TrieCursor::increment_nibbled_key(input); REQUIRE(incremented.has_value()); REQUIRE(to_hex(*incremented, true) == "0x0103"); // Increment overflows input = *from_hex("0x0f0f0f"); incremented = trie::TrieCursor::increment_nibbled_key(input); REQUIRE(incremented.has_value() == false); // Increment empty input = Bytes{}; incremented = trie::TrieCursor::increment_nibbled_key(input); REQUIRE(incremented.has_value() == false); } TEST_CASE("Trie Cursor KeyIsBefore") { ByteView input1_view{}; ByteView input2_view{}; REQUIRE(trie::TrieCursor::key_is_before(input1_view, input2_view) == false); Bytes input1{*from_hex("0x01")}; Bytes input2{*from_hex("0x02")}; input1_view = ByteView(input1.data(), input1.size()); REQUIRE(trie::TrieCursor::key_is_before(input1_view, input2_view) == true); input2_view = ByteView(input2.data(), input2.size()); REQUIRE(trie::TrieCursor::key_is_before(input1_view, input2_view) == true); REQUIRE(trie::TrieCursor::key_is_before(input2_view, input1_view) == false); } static evmc::bytes32 setup_storage(mdbx::txn& txn, ByteView storage_key) { const std::vector> locations{ {0x1200000000000000000000000000000000000000000000000000000000000000_bytes32, *from_hex("0x42")}, {0x1400000000000000000000000000000000000000000000000000000000000000_bytes32, *from_hex("0x01")}, {0x3000000000000000000000000000000000000000000000000000000000E00000_bytes32, *from_hex("0x127a89")}, {0x3000000000000000000000000000000000000000000000000000000000E00001_bytes32, *from_hex("0x05")}, }; PooledCursor hashed_storage(txn, table::kHashedStorage); HashBuilder storage_hb; Bytes value_rlp{}; for (const auto& [location, value] : locations) { upsert_storage_value(hashed_storage, storage_key, location.bytes, value); value_rlp.clear(); rlp::encode(value_rlp, value); storage_hb.add_leaf(unpack_nibbles(location.bytes), value_rlp); } return storage_hb.root_hash(); } static std::map read_all_nodes(ROCursor& cursor) { cursor.to_first(/*throw_notfound=*/false); std::map out; auto save_nodes{[&out](ByteView key, ByteView value) { Node node; REQUIRE(Node::decode_from_storage(value, node)); out.emplace(key, node); }}; cursor_for_each(cursor, save_nodes); return out; } static Bytes nibbles_from_hex(std::string_view s) { Bytes unpacked(s.size(), '\0'); for (size_t i{0}; i < s.size(); ++i) { unpacked[i] = *decode_hex_digit(s[i]); } return unpacked; } static evmc::bytes32 increment_intermediate_hashes(ROTxn& txn, const std::filesystem::path& etl_path, PrefixSet* account_changes, PrefixSet* storage_changes) { Collector account_trie_node_collector{etl_path}; Collector storage_trie_node_collector{etl_path}; TrieLoader trie_loader(txn, account_changes, storage_changes, &account_trie_node_collector, &storage_trie_node_collector); auto computed_root{trie_loader.calculate_root()}; // Save collected node changes PooledCursor account_cursor(txn, table::kTrieOfAccounts); MDBX_put_flags_t flags{account_cursor.empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT}; account_trie_node_collector.load(account_cursor, nullptr, flags); PooledCursor storage_cursor(txn, table::kTrieOfStorage); flags = storage_cursor.empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT; storage_trie_node_collector.load(storage_cursor, nullptr, flags); return computed_root; } static evmc::bytes32 regenerate_intermediate_hashes(ROTxn& txn, const std::filesystem::path& etl_path) { return increment_intermediate_hashes(txn, etl_path, nullptr, nullptr); } TEST_CASE("Account and storage trie") { test_util::TempChainData context; auto& txn{context.rw_txn()}; // ---------------------------------------------------------------- // Set up test accounts according to the example // in the big comment in intermediate_hashes.hpp // ---------------------------------------------------------------- auto hashed_accounts{open_cursor(txn, table::kHashedAccounts)}; HashBuilder hb; const evmc::bytes32 key1{0xB000000000000000000000000000000000000000000000000000000000000000_bytes32}; const AccountEncodable a1{0, 3 * kEther}; hashed_accounts.upsert(to_slice(key1), to_slice(a1.encode_for_storage())); hb.add_leaf(unpack_nibbles(key1.bytes), a1.rlp(/*storage_root=*/kEmptyRoot)); // Some address whose hash starts with 0xB040 const evmc::address address2{0x7db3e81b72d2695e19764583f6d219dbee0f35ca_address}; const auto key2{keccak256(address2)}; REQUIRE((key2.bytes[0] == 0xB0 && key2.bytes[1] == 0x40)); const AccountEncodable a2{0, 1 * kEther}; hashed_accounts.upsert(to_slice(key2.bytes), to_slice(a2.encode_for_storage())); hb.add_leaf(unpack_nibbles(key2.bytes), a2.rlp(/*storage_root=*/kEmptyRoot)); // Some address whose hash starts with 0xB041 const evmc::address address3{0x16b07afd1c635f77172e842a000ead9a2a222459_address}; const auto key3{keccak256(address3)}; REQUIRE((key3.bytes[0] == 0xB0 && key3.bytes[1] == 0x41)); const evmc::bytes32 code_hash{0x5be74cad16203c4905c068b012a2e9fb6d19d036c410f16fd177f337541440dd_bytes32}; const AccountEncodable a3{0, 2 * kEther, code_hash, kDefaultIncarnation}; hashed_accounts.upsert(to_slice(key3.bytes), to_slice(a3.encode_for_storage())); Bytes storage_key{storage_prefix(key3.bytes, kDefaultIncarnation)}; const evmc::bytes32 storage_root{setup_storage(txn, storage_key)}; hb.add_leaf(unpack_nibbles(key3.bytes), a3.rlp(storage_root)); const evmc::bytes32 key4a{0xB1A0000000000000000000000000000000000000000000000000000000000000_bytes32}; const AccountEncodable a4a{0, 4 * kEther}; hashed_accounts.upsert(to_slice(key4a), to_slice(a4a.encode_for_storage())); hb.add_leaf(unpack_nibbles(key4a.bytes), a4a.rlp(/*storage_root=*/kEmptyRoot)); const evmc::bytes32 key5{0xB310000000000000000000000000000000000000000000000000000000000000_bytes32}; const AccountEncodable a5{0, 8 * kEther}; hashed_accounts.upsert(to_slice(key5), to_slice(a5.encode_for_storage())); hb.add_leaf(unpack_nibbles(key5.bytes), a5.rlp(/*storage_root=*/kEmptyRoot)); const evmc::bytes32 key6{0xB340000000000000000000000000000000000000000000000000000000000000_bytes32}; const AccountEncodable a6{0, 1 * kEther}; hashed_accounts.upsert(to_slice(key6), to_slice(a6.encode_for_storage())); hb.add_leaf(unpack_nibbles(key6.bytes), a6.rlp(/*storage_root=*/kEmptyRoot)); // ---------------------------------------------------------------- // Populate account & storage trie DB tables // ---------------------------------------------------------------- evmc::bytes32 expected_root{hb.root_hash()}; evmc::bytes32 computed_root{regenerate_intermediate_hashes(txn, context.dir().temp().path())}; REQUIRE(to_hex(computed_root.bytes, true) == to_hex(expected_root.bytes, true)); // ---------------------------------------------------------------- // Check account trie // ---------------------------------------------------------------- PooledCursor account_trie(txn, table::kTrieOfAccounts); REQUIRE(account_trie.size() == 2); std::map node_map{read_all_nodes(account_trie)}; REQUIRE(node_map.size() == account_trie.size()); const Node node1a{node_map.at(nibbles_from_hex("B"))}; CHECK(0b1011 == node1a.state_mask()); CHECK(0b0001 == node1a.tree_mask()); CHECK(0b1001 == node1a.hash_mask()); CHECK(node1a.root_hash() == std::nullopt); CHECK(node1a.hashes().size() == 2); const Node node2a{node_map.at(nibbles_from_hex("B0"))}; CHECK(0b10001 == node2a.state_mask()); CHECK(0b00000 == node2a.tree_mask()); CHECK(0b10000 == node2a.hash_mask()); CHECK(node2a.root_hash() == std::nullopt); CHECK(node2a.hashes().size() == 1); // ---------------------------------------------------------------- // Check storage trie // ---------------------------------------------------------------- PooledCursor storage_trie(txn, table::kTrieOfStorage); REQUIRE(storage_trie.size() == 1); node_map = read_all_nodes(storage_trie); CHECK(node_map.size() == storage_trie.size()); const Node node3{node_map.at(storage_key)}; CHECK(0b1010 == node3.state_mask()); CHECK(0b0000 == node3.tree_mask()); CHECK(0b0010 == node3.hash_mask()); CHECK(node3.root_hash() == storage_root); CHECK(node3.hashes().size() == 1); // ---------------------------------------------------------------- // Add an account // ---------------------------------------------------------------- // Some address whose hash starts with 0xB1 const evmc::address address4b{0x4f61f2d5ebd991b85aa1677db97307caf5215c91_address}; const auto key4b{keccak256(address4b)}; REQUIRE(key4b.bytes[0] == key4a.bytes[0]); const AccountEncodable a4b{0, 5 * kEther}; hashed_accounts.upsert(to_slice(key4b.bytes), to_slice(a4b.encode_for_storage())); PrefixSet account_changes{}; PrefixSet storage_changes{}; account_changes.insert(unpack_nibbles(Bytes(&key4b.bytes[0], kHashLength))); expected_root = 0x8e263cd4eefb0c3cbbb14e5541a66a755cad25bcfab1e10dd9d706263e811b28_bytes32; computed_root = increment_intermediate_hashes(txn, context.dir().temp().path(), &account_changes, &storage_changes); REQUIRE(to_hex(computed_root.bytes, true) == to_hex(expected_root.bytes, true)); node_map = read_all_nodes(account_trie); CHECK(node_map.size() == 2); const Node node1b{node_map.at(nibbles_from_hex("B"))}; CHECK(0b1011 == node1b.state_mask()); CHECK(0b0001 == node1b.tree_mask()); CHECK(0b1011 == node1b.hash_mask()); CHECK(node1b.root_hash() == std::nullopt); REQUIRE(node1b.hashes().size() == 3); CHECK(node1a.hashes()[0] == node1b.hashes()[0]); CHECK(node1a.hashes()[1] == node1b.hashes()[2]); const Node node2b{node_map.at(nibbles_from_hex("B0"))}; CHECK(node2a == node2b); SECTION("Delete an account") { account_changes.clear(); storage_changes.clear(); hashed_accounts.erase(to_slice(key2.bytes)); account_changes.insert(unpack_nibbles(Bytes(&key2.bytes[0], kHashLength))); expected_root = 0x986b623eac8b26c8624cbaffaa60c1b48a7b88be1574bd98bd88391fc34c0a9c_bytes32; { Collector account_trie_node_collector{context.dir().temp().path()}; Collector storage_trie_node_collector{context.dir().temp().path()}; TrieLoader trie_loader(txn, &account_changes, &storage_changes, &account_trie_node_collector, &storage_trie_node_collector); computed_root = trie_loader.calculate_root(); REQUIRE(computed_root == expected_root); // Save collected node changes PooledCursor target(txn, table::kTrieOfAccounts); MDBX_put_flags_t flags{target.empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT}; account_trie_node_collector.load(target, nullptr, flags); target.bind(txn, table::kTrieOfStorage); flags = target.empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT; storage_trie_node_collector.load(target, nullptr, flags); } node_map = read_all_nodes(account_trie); // Compared to previous case the node 0b40 has been deleted so nodes are 3-1 == 2 CHECK(node_map.size() == 2); const Node node1c{node_map.at(nibbles_from_hex("B"))}; CHECK(0b1011 == node1c.state_mask()); CHECK(0b0000 == node1c.tree_mask()); CHECK(0b1011 == node1c.hash_mask()); CHECK(node1c.root_hash() == std::nullopt); REQUIRE(node1c.hashes().size() == 3); CHECK(node1b.hashes()[0] != node1c.hashes()[0]); CHECK(node1b.hashes()[1] == node1c.hashes()[1]); CHECK(node1b.hashes()[2] == node1c.hashes()[2]); } SECTION("Delete several accounts") { account_changes.clear(); storage_changes.clear(); hashed_accounts.erase(to_slice(key2.bytes)); account_changes.insert(unpack_nibbles(Bytes(&key2.bytes[0], kHashLength))); hashed_accounts.erase(to_slice(key3.bytes)); account_changes.insert(unpack_nibbles(Bytes(&key3.bytes[0], kHashLength))); expected_root = 0xaa953dc994f3375a95f2c413ed5a1a5a2f84d34b377d7587e3aa8dba944c12bf_bytes32; computed_root = increment_intermediate_hashes(txn, context.dir().temp().path(), &account_changes, &storage_changes); REQUIRE(computed_root == expected_root); node_map = read_all_nodes(account_trie); CHECK(node_map.size() == 2); const Node node1c{node_map.at(nibbles_from_hex("B"))}; CHECK(0b1011 == node1c.state_mask()); CHECK(0b0000 == node1c.tree_mask()); CHECK(0b1010 == node1c.hash_mask()); CHECK(node1c.root_hash() == std::nullopt); REQUIRE(node1c.hashes().size() == 2); CHECK(node1b.hashes()[1] == node1c.hashes()[0]); CHECK(node1b.hashes()[2] == node1c.hashes()[1]); } } TEST_CASE("Account trie around extension node") { const AccountEncodable account_one_ether{0, 1 * kEther}; const std::vector keys{ 0x30af561000000000000000000000000000000000000000000000000000000000_bytes32, 0x30af569000000000000000000000000000000000000000000000000000000000_bytes32, 0x30af650000000000000000000000000000000000000000000000000000000000_bytes32, 0x30af6f0000000000000000000000000000000000000000000000000000000000_bytes32, 0x30af8f0000000000000000000000000000000000000000000000000000000000_bytes32, 0x3100000000000000000000000000000000000000000000000000000000000000_bytes32, }; test_util::TempChainData context; auto& txn{context.rw_txn()}; auto hashed_accounts{open_cursor(txn, table::kHashedAccounts)}; HashBuilder hb; for (const auto& key : keys) { hashed_accounts.upsert(to_slice(key), to_slice(account_one_ether.encode_for_storage())); hb.add_leaf(unpack_nibbles(key.bytes), account_one_ether.rlp(/*storage_root=*/kEmptyRoot)); } const evmc::bytes32 expected_root{hb.root_hash()}; const evmc::bytes32 computed_root{regenerate_intermediate_hashes(txn, context.dir().temp().path())}; REQUIRE(to_hex(computed_root.bytes, true) == to_hex(expected_root.bytes, true)); PooledCursor account_trie(txn, table::kTrieOfAccounts); std::map node_map{read_all_nodes(account_trie)}; CHECK(node_map.size() == 2); const Node node1{node_map.at(nibbles_from_hex("3"))}; CHECK(0b11 == node1.state_mask()); CHECK(0b01 == node1.tree_mask()); CHECK(0b00 == node1.hash_mask()); CHECK(node1.root_hash() == std::nullopt); CHECK(node1.hashes().empty()); const Node node2{node_map.at(nibbles_from_hex("30af"))}; CHECK(0b101100000 == node2.state_mask()); CHECK(0b000000000 == node2.tree_mask()); CHECK(0b001000000 == node2.hash_mask()); CHECK(node2.root_hash() == std::nullopt); CHECK(node2.hashes().size() == 1); } static evmc::address int_to_address(uint64_t i) { uint8_t be[8]; endian::store_big_u64(be, i); return bytes_to_address(be); } static evmc::bytes32 int_to_bytes32(uint64_t i) { uint8_t be[8]; endian::store_big_u64(be, i); return to_bytes32(be); } TEST_CASE("Trie Accounts : incremental vs regeneration") { test_util::TempChainData context; auto& txn{context.rw_txn()}; PrefixSet account_changes; PrefixSet storage_changes; const size_t n{10'000}; PooledCursor hashed_accounts{txn, table::kHashedAccounts}; PooledCursor account_trie{txn, table::kTrieOfAccounts}; // ------------------------------------------------------------------------------ // Take A: create some accounts at genesis and then apply some changes // ------------------------------------------------------------------------------ // Start with 3n accounts at genesis, each holding 1 ETH const AccountEncodable one_eth{0, 1 * kEther}; for (size_t i{0}, e{3 * n}; i < e; ++i) { const evmc::address address{int_to_address(i)}; const auto hash{keccak256(address)}; hashed_accounts.upsert(to_slice(hash.bytes), to_slice(one_eth.encode_for_storage())); } // This populates TrieAccounts for the first pass (void)regenerate_intermediate_hashes(txn, context.dir().temp().path()); // Double the balance of the first third of the accounts const AccountEncodable two_eth{0, 2 * kEther}; for (size_t i{0}; i < n; ++i) { const evmc::address address{int_to_address(i)}; const auto hash{keccak256(address)}; hashed_accounts.upsert(to_slice(hash.bytes), to_slice(two_eth.encode_for_storage())); account_changes.insert(unpack_nibbles(Bytes(&hash.bytes[0], kHashLength))); } // Delete the second third of the accounts for (size_t i{n}, e{2 * n}; i < e; ++i) { const evmc::address address{int_to_address(i)}; const auto hash{keccak256(address)}; hashed_accounts.erase(to_slice(hash.bytes)); account_changes.insert(unpack_nibbles(Bytes(&hash.bytes[0], kHashLength))); } // Don't touch the last third of genesis accounts // And add some new accounts, each holding 1 ETH for (size_t i{3 * n}, e{4 * n}; i < e; ++i) { const evmc::address address{int_to_address(i)}; const auto hash{keccak256(address)}; hashed_accounts.upsert(to_slice(hash.bytes), to_slice(one_eth.encode_for_storage())); account_changes.insert(unpack_nibbles(Bytes(&hash.bytes[0], kHashLength)), /* mark as created */ true); } const auto incremental_root{ increment_intermediate_hashes(txn, context.dir().temp().path(), &account_changes, &storage_changes)}; const std::map incremental_nodes{read_all_nodes(account_trie)}; // ------------------------------------------------------------------------------ // Take B: generate intermediate hashes for the accounts as of Block 1 in one go, // without increment_intermediate_hashes // ------------------------------------------------------------------------------ txn->clear_map(open_map(txn, table::kHashedAccounts)); // Accounts [0,n) now hold 2 ETH for (size_t i{0}; i < n; ++i) { const evmc::address address{int_to_address(i)}; const auto hash{keccak256(address)}; hashed_accounts.upsert(to_slice(hash.bytes), to_slice(two_eth.encode_for_storage())); } // Accounts [n,2n) are deleted // Accounts [2n,4n) hold 1 ETH for (size_t i{2 * n}, e{4 * n}; i < e; ++i) { const evmc::address address{int_to_address(i)}; const auto hash{keccak256(address)}; hashed_accounts.upsert(to_slice(hash.bytes), to_slice(one_eth.encode_for_storage())); } txn->clear_map(open_map(txn, table::kTrieOfAccounts)); txn->clear_map(open_map(txn, table::kTrieOfStorage)); const auto fused_root{regenerate_intermediate_hashes(txn, context.dir().temp().path())}; const std::map fused_nodes{read_all_nodes(account_trie)}; // ------------------------------------------------------------------------------ // A and B should yield the same result // ------------------------------------------------------------------------------ REQUIRE(to_hex(fused_root.bytes, true) == to_hex(incremental_root.bytes, true)); REQUIRE(fused_nodes == incremental_nodes); } TEST_CASE("Trie Storage : incremental vs regeneration") { test_util::TempChainData context; auto& txn{context.rw_txn()}; PrefixSet account_changes; PrefixSet storage_changes; const size_t n{2'000}; PooledCursor hashed_accounts{txn, table::kHashedAccounts}; PooledCursor hashed_storage{txn, table::kHashedStorage}; PooledCursor storage_trie{txn, table::kTrieOfStorage}; const uint64_t incarnation1{3}; const uint64_t incarnation2{1}; const AccountEncodable account1{ 5, // nonce 7 * kEther, // balance 0x5e3c5ae99a1c6785210d0d233641562557ad763e18907cca3a8d42bd0a0b4ecb_bytes32, // code_hash incarnation1, // incarnation }; const AccountEncodable account2{ 1, // nonce 13 * kEther, // balance 0x3a9c1d84e48734ae951e023197bda6d03933a4ca44124a2a544e227aa93efe75_bytes32, // code_hash incarnation2, // incarnation }; const evmc::address address1{0x1000000000000000000000000000000000000000_address}; const evmc::address address2{0x2000000000000000000000000000000000000000_address}; const auto hashed_address1{keccak256(address1)}; const auto hashed_address2{keccak256(address2)}; hashed_accounts.upsert(to_slice(hashed_address1.bytes), to_slice(account1.encode_for_storage())); hashed_accounts.upsert(to_slice(hashed_address2.bytes), to_slice(account2.encode_for_storage())); const Bytes storage_prefix1{storage_prefix(hashed_address1.bytes, incarnation1)}; const Bytes storage_prefix2{storage_prefix(hashed_address2.bytes, incarnation2)}; const auto upsert_storage_for_two_test_accounts = [&](size_t i, ByteView value, bool register_change, bool new_records = false) { const evmc::bytes32 plain_loc1{int_to_bytes32(2 * i)}; const evmc::bytes32 plain_loc2{int_to_bytes32(2 * i + 1)}; const auto hashed_loc1{silkworm::keccak256(plain_loc1.bytes)}; const auto hashed_loc2{silkworm::keccak256(plain_loc2.bytes)}; const auto nibbled_hashed_loc1{unpack_nibbles(hashed_loc1.bytes)}; const auto nibbled_hashed_loc2{unpack_nibbles(hashed_loc2.bytes)}; upsert_storage_value(hashed_storage, storage_prefix1, hashed_loc1.bytes, value); upsert_storage_value(hashed_storage, storage_prefix2, hashed_loc2.bytes, value); if (register_change) { storage_changes.insert(Bytes{storage_prefix1 + nibbled_hashed_loc1}, new_records); storage_changes.insert(Bytes{storage_prefix2 + nibbled_hashed_loc2}, new_records); } }; // ------------------------------------------------------------------------------ // Take A: create some storage at genesis and then apply some changes at Block 1 // ------------------------------------------------------------------------------ // Start with 3n storage slots per account at genesis, each with the same value const Bytes value_x{*from_hex("42")}; for (size_t i{0}, e{3 * n}; i < e; ++i) { upsert_storage_for_two_test_accounts(i, value_x, false); } (void)regenerate_intermediate_hashes(txn, context.dir().temp().path()); // Change the value of the first third of the storage const Bytes value_y{*from_hex("71f602b294119bf452f1923814f5c6de768221254d3056b1bd63e72dc3142a29")}; for (size_t i{0}; i < n; ++i) { upsert_storage_for_two_test_accounts(i, value_y, true); } // Delete the second third of the storage for (size_t i{n}, e{2 * n}; i < e; ++i) { upsert_storage_for_two_test_accounts(i, {}, true); } // Don't touch the last third of genesis storage // And add some new storage for (size_t i{3 * n}, e{4 * n}; i < e; ++i) { upsert_storage_for_two_test_accounts(i, value_x, true, true); } account_changes.insert(unpack_nibbles(hashed_address1.bytes)); account_changes.insert(unpack_nibbles(hashed_address2.bytes)); const auto incremental_root{ increment_intermediate_hashes(txn, context.dir().temp().path(), &account_changes, &storage_changes)}; const std::map incremental_nodes{read_all_nodes(storage_trie)}; // ------------------------------------------------------------------------------ // Take B: generate intermediate hashes for the storage as of Block 1 in one go, // without increment_intermediate_hashes // ------------------------------------------------------------------------------ txn->clear_map(open_map(txn, table::kHashedStorage)); // The first third of the storage now has value_y for (size_t i{0}; i < n; ++i) { upsert_storage_for_two_test_accounts(i, value_y, false); } // The second third of the storage is deleted // The last third and the extra storage has value_x for (size_t i{2 * n}, e{4 * n}; i < e; ++i) { upsert_storage_for_two_test_accounts(i, value_x, false); } txn->clear_map(open_map(txn, table::kTrieOfAccounts)); txn->clear_map(open_map(txn, table::kTrieOfStorage)); const auto fused_root{regenerate_intermediate_hashes(txn, context.dir().temp().path())}; const std::map fused_nodes{read_all_nodes(storage_trie)}; // ------------------------------------------------------------------------------ // A and B should yield the same result // ------------------------------------------------------------------------------ REQUIRE(to_hex(fused_root.bytes, true) == to_hex(incremental_root.bytes, true)); REQUIRE(fused_nodes == incremental_nodes); } } // namespace silkworm::trie ================================================ FILE: silkworm/node/stagedsync/stages/stage_interhashes/trie_cursor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "trie_cursor.hpp" #include #include #include #include #include namespace silkworm::trie { bool SubNode::has_tree() const noexcept { return (tree_mask_ & (1u << child_id)) != 0; } bool SubNode::has_hash() const noexcept { return (hash_mask_ & (1u << child_id)) != 0; } bool SubNode::has_state() const noexcept { return (state_mask_ & (1u << child_id)) != 0; } void SubNode::reset() { key = ByteView(); value = ByteView(); root_hash_.reset(); hashes_.clear(); state_mask_ = 0; tree_mask_ = 0; hash_mask_ = 0; child_id = -1; max_child_id = 0x10; // Traverse all node for ephemeral ones. hash_id = -1; deleted = false; } Bytes SubNode::full_key() const noexcept { Bytes ret{key}; if (child_id != -1) { ret.push_back(static_cast(child_id)); } return ret; } const evmc::bytes32& SubNode::hash() { if (hash_id < 0 || static_cast(hash_id) >= hashes_.size()) { throw std::out_of_range("Hash id out of bounds"); } return hashes_[static_cast(hash_id)]; } void SubNode::parse(ByteView k, ByteView v) { key = k; value = v; success_or_throw(Node::decode_from_storage(v, *this)); child_id = gsl::narrow(std::countr_zero(state_mask_)) - 1; // NOLINT max_child_id = gsl::narrow(std::bit_width(state_mask_)); hash_id = -1; deleted = false; } TrieCursor::TrieCursor(datastore::kvdb::ROCursor& db_cursor, PrefixSet* changed, datastore::etl::Collector* collector) : db_cursor_(db_cursor), changed_list_{changed}, collector_{collector} { curr_key_.reserve(64); prev_key_.reserve(64); prefix_.reserve(64); buffer_.reserve(128); } TrieCursor::MoveOperationResult TrieCursor::to_prefix(ByteView prefix) { // 0 bytes for TrieAccounts // 40 bytes (hashed address + incarnation) for TrieStorage if (size_t len{prefix.size()}; len != 0 && len != db::kHashedStoragePrefixLength) { throw std::invalid_argument("Invalid prefix len : expected (0 || 40) whilst got " + std::to_string(len)); } prefix_.assign(prefix); buffer_.clear(); curr_key_.clear(); prev_key_.clear(); next_created_ = ByteView{}; end_of_tree_ = false; skip_state_ = true; level_ = 0u; sub_nodes_[level_].reset(); // Reset root node // ^^^ Note! We don't actually need to reset all sub-nodes (i.e. level_ > 0) as // the only case we descend level is when parsing a new sub node which implies // node at level_ gets overwritten in any case // Check changed list contains requested prefix_ and retrieve the first created account under "that" trie // This also returns the first "created" account in "that" trie bool has_changes{changed_list_ == nullptr}; // Full regeneration: everything is changed if (!has_changes) { std::tie(has_changes, next_created_) = changed_list_->contains_and_next_marked(prefix_, prefix_.size()); } // Lookup for a root node // Assumption: an existing trie MUST have its root node // If it doesn't exist we assume the whole trie must be rebuilt from scratch if (db_seek({})) { // Found a root node - use its root hash only if no changes // Otherwise this root can be marked for deletion as it needs // to be reconstructed and eventually begin the child_id loop auto& node{sub_nodes_[level_]}; if (!node.root_hash().has_value()) { throw std::logic_error("Trie integrity failure. Requested root node with key " + to_hex(node.full_key(), true) + " has no root_hash"); } if (!has_changes) { end_of_tree_ = true; // We don't need to further traverse this trie return {curr_key_, node.root_hash(), false}; } db_delete(node); } else { skip_state_ = false; end_of_tree_ = true; return {std::nullopt, std::nullopt, false, Bytes{}}; } // Begin looping child_ids (we have found a root node but has changes) return to_next(); } TrieCursor::MoveOperationResult TrieCursor::to_next() { /* * We process node's nibbled keys in ascending lexicographical order * 0x * 0x00 * 0x0000 * 0x0001 * 0x000100 * [...] * 0x000f * 0x01 * * When AtPrefix is executed it tries to locate the root node of the tree * If found (and no changes) then it returns the root hash. Otherwise, the to_next cycle is triggered. * On every to_next we * 1) Point to the node of current level_ and step on next child * 2) If step operation returns false it means we have exhausted all child_ids which have a state. As a result we * try to go up one level (if possible) and goto 1) * 3) If node has_hash return node.full_key and bound hash (it will be added as a branch node in hash builder). * If skip_state==false also return the previous nibbled key after increment * This will cause to process state of all previous hashed accounts as leaves *and* the branch node. * 4) If node does not have hash but has_tree try to locate child node. * If found descend one level (++level) and goto 1) * 5) If node has_state set skip_state to false * 6) goto 1) * * Note ! In absence of a root node then node at level 0 is always an ephemeral node (it does not have any value * loaded from db) and for all child_ids it has always has_tree and has_state */ if (end_of_tree_) { throw std::domain_error("Can't move next beyond the end of tree"); } skip_state_ = true; std::swap(prev_key_, curr_key_); curr_key_.clear(); while (!end_of_tree_) { auto& sub_node{sub_nodes_[level_]}; ++sub_node.child_id; // Advance to next child_id. (Note we start from -1 so "first next" is 0) if (sub_node.has_hash()) { ++sub_node.hash_id; } // On reach of max_child_id the node is completely traversed : // ascend one level, if possible, or mark the end of the tree (completely traversed) // Note ! We don't have intermediate "empty" nodes as in Erigon if (sub_node.child_id == sub_node.max_child_id) { if (level_) { --level_; } else { end_of_tree_ = true; } continue; } // Consume node's hash (if any) if (consume(sub_node)) { curr_key_.assign(sub_node.full_key()); return {curr_key_, sub_node.hash(), sub_node.has_tree(), first_uncovered()}; } // If a child is expected we MUST find it. db_seek also descends one level // If not found it means the tree is corrupted if (sub_node.has_tree()) { if (!db_seek(sub_node.full_key())) { throw std::logic_error( "Trie integrity failure. Missing child for node key=" + to_hex(sub_node.key, true) + " child_id=" + std::to_string(static_cast(sub_node.child_id))); } } else { skip_state_ = false; } if (sub_node.has_state()) { skip_state_ = false; } } auto next{increment_nibbled_key(prev_key_)}; skip_state_ = skip_state_ && (next == std::nullopt); return {std::nullopt, std::nullopt, false, first_uncovered()}; // No higher level } bool TrieCursor::db_seek(ByteView seek_key) { buffer_.assign(prefix_).append(seek_key); const auto buffer_slice = datastore::kvdb::to_slice(buffer_); auto data{buffer_.empty() ? db_cursor_.to_first(false) : db_cursor_.lower_bound(buffer_slice, false)}; if (!data || !data.key.starts_with(buffer_slice)) { return false; } ByteView db_cursor_key = datastore::kvdb::from_slice(data.key); // Save db_cursor_ key ... db_cursor_key.remove_prefix(prefix_.size()); // ... and remove prefix_ so we have node key if (seek_key.empty() && !db_cursor_key.empty()) { // Note ! an empty seek_key means we're looking for a root node with empty key which does not exist return false; } ByteView db_cursor_val = datastore::kvdb::from_slice(data.value); // Save db_cursor_ value level_ += seek_key.empty() ? 0 : 1u; // Down one level for child node. Stay at zero for root node auto& new_node{sub_nodes_[level_]}; new_node.parse(db_cursor_key, db_cursor_val); return true; } void TrieCursor::db_delete(SubNode& node) { if (!node.deleted && collector_) { buffer_.assign(prefix_).append(node.key); collector_->collect({buffer_, Bytes{}}); node.deleted = true; } } bool TrieCursor::consume(SubNode& node) { if (node.has_hash()) { buffer_.assign(prefix_).append(node.full_key()); auto [has_changes, next_created]{changed_list_->contains_and_next_marked(buffer_, prefix_.size())}; if (!has_changes) { skip_state_ = skip_state_ && key_is_before(buffer_, next_created_); std::swap(next_created_, next_created); return true; } } db_delete(node); return false; } bool TrieCursor::key_is_before(ByteView k1, ByteView k2) { if (k1.is_null()) { return false; } if (k2.is_null()) { return true; } return k1 < k2; } std::optional TrieCursor::increment_nibbled_key(const ByteView origin) { Bytes ret{}; auto rit{std::find_if(origin.rbegin(), origin.rend(), [](uint8_t nibble) { return nibble != 0xf; })}; if (rit == origin.rend()) { // Overflow return std::nullopt; } auto count{static_cast(std::distance(origin.begin(), rit.base()))}; ret.assign(origin.substr(0, count)); ++ret.back(); return ret; } std::optional TrieCursor::first_uncovered() { if (skip_state_) { return std::nullopt; } // This is intended. Don't want an empty origin to be marked as overflown if (prev_key_.empty()) { return prev_key_; } auto incremented_nibbled_key{increment_nibbled_key(prev_key_)}; if (incremented_nibbled_key.has_value()) { return pack_nibbles(incremented_nibbled_key.value()); } return incremented_nibbled_key; } } // namespace silkworm::trie ================================================ FILE: silkworm/node/stagedsync/stages/stage_interhashes/trie_cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::trie { //! \brief Extends trie::Node with methods for traversing child_ids class SubNode : public Node { public: SubNode() = default; // Not copyable nor movable SubNode(const SubNode&) = delete; SubNode& operator=(const SubNode&) = delete; bool has_tree() const noexcept; // Whether current child_id has bit set in tree mask bool has_hash() const noexcept; // Whether current child_id has bit set in hash mask bool has_state() const noexcept; // Whether current child_id has bit set in state mask void reset(); // Resets node to default values void parse(ByteView k, ByteView v); // Parses node data contents from db (may throw) Bytes full_key() const noexcept; // Returns full key to child node (i.e. key + child_id) const evmc::bytes32& hash(); // Returns hash of child node (i.e. key + child_id) ByteView key{}; // Key retrieved from db (if any) Is nibbled ByteView value{}; // Value retrieved from db (if any) int8_t child_id{-1}; // Current child being inspected in this node (aka nibble) int8_t max_child_id{0xf}; // Max child of this node int8_t hash_id{-1}; // Index of hash to be retrieved bool deleted{false}; // Whether already deleted (in collector) }; //! \brief Traverses TrieAccount or TrieStorage in pre-order: \n //! 1. Visit the current node \n //! 2. Recursively traverse the current node's left subtree. \n //! 3. Recursively traverse the current node's right subtree. \n //! \see https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR //! \see Erigon's AccTrieCursor/StorageTrieCursor //! \details Traversing the trie relies on various assumptions //! \verbatim //! 1) The keys being processed represent a node in the trie //! 2) The keys being processed are served in lexicographical order //! 3) The keys in database are stored in lexicographical order //! 4) Whenever a key is found it is checked against a list of changed accounts (or storage locations) to determine //! whether the retrieved node can be used as is or it needs to be recalculated //! \endverbatim //! The implementation takes into account that : TrieAccount hold all the nodes for Hashed accounts (hence is a single //! tree) whilst TrieStorage hold as many trees as many contracts are active on the chain (hence collection of trees). //! In this second case each tree is stored with a prefix which is exactly the sum of hashed address + incarnation. //! Due to the above traversing the trees implies there is no prefix for Accounts whilst there is always a prefix of 40 //! bytes for Storage. class TrieCursor { public: explicit TrieCursor( datastore::kvdb::ROCursor& db_cursor, PrefixSet* changed, datastore::etl::Collector* collector = nullptr); // Not copyable nor movable TrieCursor(const TrieCursor&) = delete; TrieCursor& operator=(const TrieCursor&) = delete; //! \brief Represent the data returned after a move operation (to_prefix or to_next) struct [[nodiscard]] MoveOperationResult { std::optional key{}; // Nibbled key of node std::optional hash{}; // Hash of node bool children_in_trie{false}; // Whether there are children in trie std::optional first_uncovered{}; // First uncovered prefix to be processed by higher loop }; //! \brief Acquires the prefix and position the cursor to the first occurrence MoveOperationResult to_prefix(ByteView prefix); //! \brief Moves the cursor to next relevant position MoveOperationResult to_next(); private: uint32_t level_{0}; // Depth level in sub_nodes_ bool end_of_tree_{false}; // Protects from to_next() beyond end of tree Bytes curr_key_{}; // Latest key returned on a valid hash Bytes prev_key_{}; // Same as curr_key_ but for previous cycle bool skip_state_{true}; // Whether account(s) state scan can be skipped std::array sub_nodes_{{}}; // Collection of sub-nodes being unrolled Bytes prefix_{}; // Db key prefix for this trie (0 bytes TrieAccount - 40 bytes TrieStorage) Bytes buffer_{}; // A convenience buffer datastore::kvdb::ROCursor& db_cursor_; // The underlying db cursor (TrieAccount/TrieStorage) PrefixSet* changed_list_; // The collection of changed nibbled keys ByteView next_created_{}; // The next created account/location in changed list datastore::etl::Collector* collector_; // Pointer to a collector for deletion of obsolete keys bool db_seek(ByteView seek_key); // Seeks lowerbound of provided key using db_cursor_ void db_delete(SubNode& node); // Collects deletion of node being rebuilt or no longer needed bool consume(SubNode& node); // If node has hash consume it //! \brief Returns the first uncovered prefix. nullopt if overflows //! \see increment_nibbled_key() std::optional first_uncovered(); public: //! \brief Produces the next key in sequence //! \details It's essentially +1 in the hexadecimal (base 16) numeral system //! \verbatim //! Example : //! increment_nibbled_key(0x125) == 0x126; //! increment_nibbled_key(0x12f) == 0x13; (note is shorter) //! increment_nibbled_key(0x13) == 0x14; //! \endverbatim //! \returns the new string of bytes or nullopt if overflows static std::optional increment_nibbled_key(ByteView origin); //! \brief Compares two strings and returns true when k1 < k2 //! \remarks Unlike standard lexical comparison null keys are last static bool key_is_before(ByteView k1, ByteView k2); }; } // namespace silkworm::trie ================================================ FILE: silkworm/node/stagedsync/stages/stage_interhashes/trie_loader.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "trie_loader.hpp" #include #include #include #include #include #include #include #include namespace silkworm::trie { using namespace silkworm::db; using namespace silkworm::datastore::kvdb; TrieLoader::TrieLoader( ROTxn& txn, PrefixSet* account_changes, PrefixSet* storage_changes, datastore::etl::Collector* account_trie_node_collector, datastore::etl::Collector* storage_trie_node_collector) : txn_{txn}, account_changes_{account_changes}, storage_changes_{storage_changes}, account_trie_node_collector_{account_trie_node_collector}, storage_trie_node_collector_{storage_trie_node_collector} { // Either both or nothing if ((account_changes == nullptr) != (storage_changes == nullptr)) { throw std::runtime_error("TrieLoader requires account_changes to be both provided or both nullptr"); } if (!account_trie_node_collector_ || !storage_trie_node_collector_) { throw std::runtime_error("TrieLoader requires account and storage collectors to be provided"); } } evmc::bytes32 TrieLoader::calculate_root() { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; auto hashed_accounts = txn_.ro_cursor(table::kHashedAccounts); auto hashed_storage = txn_.ro_cursor_dup_sort(table::kHashedStorage); auto trie_accounts = txn_.ro_cursor(table::kTrieOfAccounts); auto trie_storage = txn_.ro_cursor(table::kTrieOfStorage); // On full regeneration we must assert both trees are empty if (!account_changes_) { if (!trie_accounts->empty() || !trie_storage->empty()) { throw std::domain_error(" full regeneration detected but either " + std::string(table::kTrieOfAccounts.name) + " or " + std::string(table::kTrieOfStorage.name) + " aren't empty"); } } Bytes storage_prefix_buffer{}; storage_prefix_buffer.reserve(kHashedStoragePrefixLength); HashBuilder account_hash_builder; account_hash_builder.node_collector = [&](ByteView nibbled_key, const trie::Node& node) { Bytes value{node.state_mask() ? node.encode_for_storage() : Bytes{}}; // Node with no state should be deleted account_trie_node_collector_->collect({Bytes{nibbled_key}, value}); }; HashBuilder storage_hash_builder; storage_hash_builder.node_collector = [&](ByteView nibbled_key, const trie::Node& node) { Bytes key{storage_prefix_buffer}; key.append(nibbled_key); Bytes value{node.state_mask() ? node.encode_for_storage() : Bytes{}}; // Node with no state should be deleted storage_trie_node_collector_->collect({key, value}); }; // Open both tries (Account and Storage) to avoid reallocation of Storage on every contract TrieCursor trie_account_cursor(*trie_accounts, account_changes_, account_trie_node_collector_); TrieCursor trie_storage_cursor(*trie_storage, storage_changes_, storage_trie_node_collector_); // Begin loop on accounts auto trie_account_data{trie_account_cursor.to_prefix({})}; while (true) { if (trie_account_data.first_uncovered.has_value()) { auto hashed_account_seek_slice{to_slice(trie_account_data.first_uncovered.value())}; auto hashed_account_data{hashed_account_seek_slice.empty() ? hashed_accounts->to_first(false) : hashed_accounts->lower_bound(hashed_account_seek_slice, false)}; while (hashed_account_data) { auto hashed_account_data_key_view{from_slice(hashed_account_data.key)}; if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { SignalHandler::throw_if_signalled(); std::scoped_lock log_lck(log_mtx_); log_key_ = to_hex(hashed_account_data_key_view, true); log_time = now + 2s; } auto hashed_account_data_key_nibbled{unpack_nibbles(hashed_account_data_key_view)}; if (trie_account_data.key.has_value() && trie_account_data.key.value() < hashed_account_data_key_nibbled) { break; } // Retrieve account data const auto account = db::state::AccountCodec::from_encoded_storage(from_slice(hashed_account_data.value)); success_or_throw(account); evmc::bytes32 storage_root{kEmptyRoot}; if (account->incarnation) { // Calc storage root storage_prefix_buffer.assign(storage_prefix(hashed_account_data_key_view, account->incarnation)); storage_root = calculate_storage_root(trie_storage_cursor, storage_hash_builder, *hashed_storage, storage_prefix_buffer); } account_hash_builder.add_leaf(hashed_account_data_key_nibbled, account->rlp(storage_root)); hashed_account_data = hashed_accounts->to_next(false); } } // Interrupt loop when no more keys to process if (!trie_account_data.key.has_value()) { break; } account_hash_builder.add_branch_node(trie_account_data.key.value(), trie_account_data.hash.value(), trie_account_data.children_in_trie); // If root node added we can exit if (trie_account_data.key->empty()) { break; } trie_account_data = trie_account_cursor.to_next(); } auto root_hash{account_hash_builder.root_hash()}; account_hash_builder.reset(); return root_hash; } evmc::bytes32 TrieLoader::calculate_storage_root(TrieCursor& trie_storage_cursor, HashBuilder& storage_hash_builder, ROCursorDupSort& hashed_storage, const Bytes& db_storage_prefix) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; static Bytes rlp_buffer{}; const auto db_storage_prefix_slice{to_slice(db_storage_prefix)}; auto trie_storage_data{trie_storage_cursor.to_prefix(db_storage_prefix)}; while (true) { if (trie_storage_data.first_uncovered.has_value()) { const auto prefix_slice{to_slice(trie_storage_data.first_uncovered.value())}; auto hashed_storage_data{ hashed_storage.lower_bound_multivalue(db_storage_prefix_slice, prefix_slice, false)}; while (hashed_storage_data) { if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { SignalHandler::throw_if_signalled(); } auto hashed_storage_data_value_view{from_slice(hashed_storage_data.value)}; const auto nibbled_location{ trie::unpack_nibbles(hashed_storage_data_value_view.substr(0, kHashLength))}; if (trie_storage_data.key.has_value() && trie_storage_data.key.value() < nibbled_location) { break; } hashed_storage_data_value_view.remove_prefix(kHashLength); // Keep value part rlp_buffer.clear(); rlp::encode(rlp_buffer, hashed_storage_data_value_view); storage_hash_builder.add_leaf(nibbled_location, rlp_buffer); hashed_storage_data = hashed_storage.to_current_next_multi(false); } } // Interrupt loop when no more keys to process if (!trie_storage_data.key.has_value()) { break; } storage_hash_builder.add_branch_node(trie_storage_data.key.value(), trie_storage_data.hash.value(), trie_storage_data.children_in_trie); // Have we just sent Storage root for this contract ? if (trie_storage_data.key.value().empty()) { break; } trie_storage_data = trie_storage_cursor.to_next(); } auto storage_root{storage_hash_builder.root_hash()}; storage_hash_builder.reset(); return storage_root; } } // namespace silkworm::trie ================================================ FILE: silkworm/node/stagedsync/stages/stage_interhashes/trie_loader.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::trie { class TrieLoader { public: explicit TrieLoader( datastore::kvdb::ROTxn& txn, PrefixSet* account_changes, PrefixSet* storage_changes, datastore::etl::Collector* account_trie_node_collector, datastore::etl::Collector* storage_trie_node_collector); //! \brief (re)calculates root hash on behalf of collected hashed changes and existing data in TrieOfAccount and //! TrieOfStorage buckets //! \return The computed hash //! \remark May throw evmc::bytes32 calculate_root(); //! \brief Returns the hex representation of current load key (for progress tracking) std::string get_log_key() const { std::scoped_lock lock{log_mtx_}; return log_key_; } private: datastore::kvdb::ROTxn& txn_; PrefixSet* account_changes_; PrefixSet* storage_changes_; datastore::etl::Collector* account_trie_node_collector_; datastore::etl::Collector* storage_trie_node_collector_; std::string log_key_{}; // To export logging key mutable std::mutex log_mtx_{}; // Guards async logging //! \brief (re)calculates storage root hash on behalf of collected hashed changes and existing data in //! TrieOfStorage bucket //! \return The computed hash //! \remark May throw static evmc::bytes32 calculate_storage_root( TrieCursor& trie_storage_cursor, HashBuilder& storage_hash_builder, datastore::kvdb::ROCursorDupSort& hashed_storage, const Bytes& db_storage_prefix); }; } // namespace silkworm::trie ================================================ FILE: silkworm/node/stagedsync/stages/stage_interhashes.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_interhashes.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; using datastore::kvdb::Collector; using datastore::kvdb::from_slice; using datastore::kvdb::to_slice; using silkworm::db::state::AccountCodec; Stage::Result InterHashes::forward(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); DataModel data_model = data_model_factory_(txn); // Check stage boundaries from previous execution and previous stage execution auto previous_progress{get_progress(txn)}; auto hashstate_stage_progress{stages::read_stage_progress(txn, stages::kHashStateKey)}; if (previous_progress == hashstate_stage_progress) { // Nothing to process operation_ = OperationType::kNone; return Stage::Result::kSuccess; } if (previous_progress > hashstate_stage_progress) { // Something bad had happened. Not possible hashstate stage is ahead of bodies // Maybe we need to unwind ? // Something bad had happened. Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "InterHashes progress " + std::to_string(previous_progress) + " greater than HashState progress " + std::to_string(hashstate_stage_progress)); } const BlockNum segment_width{hashstate_stage_progress - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_ + " begin", {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(hashstate_stage_progress), "span", std::to_string(segment_width)}); } // Retrieve header's state_root at target block to be compared with the one computed here auto header_hash{read_canonical_header_hash(txn, hashstate_stage_progress)}; if (!header_hash.has_value()) { throw std::runtime_error("Could not find hash for canonical header " + std::to_string(hashstate_stage_progress)); } auto header{data_model.read_header(hashstate_stage_progress, header_hash->bytes)}; if (!header_hash.has_value()) { throw std::runtime_error("Could not find canonical header number " + std::to_string(hashstate_stage_progress) + " hash " + to_hex(header_hash->bytes, true)); } auto expected_state_root{header->state_root}; reset_log_progress(); if (!previous_progress || segment_width > stages::kLargeBlockSegmentWorthRegen) { // Full regeneration ret = regenerate_intermediate_hashes(txn, &expected_state_root); } else { // Incremental update // TODO(canepat) debug_unwind block 4'000'000 step 1 fails with kWrongStateRoot in incremental mode // ret = increment_intermediate_hashes(txn, previous_progress, hashstate_stage_progress, &expected_state_root); SILK_TRACE_M(log_prefix_, {"function", std::string(__FUNCTION__), "algo", "full rather than incremental"}); ret = regenerate_intermediate_hashes(txn, &expected_state_root); } if (ret == Stage::Result::kWrongStateRoot) { // Binary search for the correct block, biased to the lower numbers sync_context_->unwind_point.emplace(previous_progress + (segment_width / 2)); sync_context_->bad_block_hash.emplace(header_hash.value()); } success_or_throw(ret); throw_if_stopping(); stages::write_stage_progress(txn, stages::kIntermediateHashesKey, hashstate_stage_progress); txn.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result InterHashes::unwind(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); DataModel data_model = data_model_factory_(txn); BlockNum previous_progress{get_progress(txn)}; if (to >= previous_progress) { // Actually nothing to unwind operation_ = OperationType::kNone; return Stage::Result::kSuccess; } const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_ + " begin", {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } // Retrieve header's state_root at target block to be compared with the one computed here auto header_hash{read_canonical_header_hash(txn, to)}; if (!header_hash.has_value()) { throw std::runtime_error("Could not find hash for canonical header " + std::to_string(to)); } auto header{data_model.read_header(to, header_hash->bytes)}; if (!header_hash.has_value()) { throw std::runtime_error("Could not find canonical header number " + std::to_string(to) + " hash " + to_hex(header_hash->bytes, true)); } auto expected_state_root{header->state_root}; reset_log_progress(); if (segment_width > stages::kLargeBlockSegmentWorthRegen) { // Full regeneration // It will process all HashedState which is already unwound ret = regenerate_intermediate_hashes(txn, &expected_state_root); } else { // Incremental update // TODO(canepat) debug_unwind block 4'000'000 step 1 fails with kWrongStateRoot in incremental mode // ret = increment_intermediate_hashes(txn, previous_progress, to, &expected_state_root); SILK_TRACE_M(log_prefix_, {"function", std::string(__FUNCTION__), "algo", "full rather than incremental"}); ret = regenerate_intermediate_hashes(txn, &expected_state_root); } success_or_throw(ret); throw_if_stopping(); stages::write_stage_progress(txn, stages::kIntermediateHashesKey, to); txn.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result InterHashes::prune(RWTxn&) { return Stage::Result::kSuccess; } trie::PrefixSet InterHashes::collect_account_changes(RWTxn& txn, BlockNum from, BlockNum to, absl::btree_map& hashed_addresses) { std::unique_ptr sw; if (log::test_verbosity(log::Level::kTrace)) { sw = std::make_unique(/*auto_start=*/true); } bool forward{to > from}; // Are we forwarding or unwinding ? BlockNum reached_blocknum{0}; BlockNum expected_blocknum{std::min(from, to) + 1u}; BlockNum max_blocknum{std::max(from, to)}; absl::btree_set deleted_ts_prefixes{}; silkworm::LruCache> plainstate_accounts(100'000); using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; std::unique_lock log_lck(log_mtx_); current_source_ = std::string(table::kAccountChangeSet.name); log_lck.unlock(); const Bytes starting_key{block_key(expected_blocknum)}; trie::PrefixSet ret; auto account_changeset = txn.ro_cursor_dup_sort(table::kAccountChangeSet); auto plain_state = txn.ro_cursor_dup_sort(table::kPlainState); auto changeset_data{account_changeset->lower_bound(to_slice(starting_key), /*throw_notfound=*/false)}; while (changeset_data) { reached_blocknum = endian::load_big_u64(from_slice(changeset_data.key).data()); check_block_sequence(reached_blocknum, expected_blocknum); if (reached_blocknum > max_blocknum) { break; } if (auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); log_lck.lock(); log_time = now + 5s; current_key_ = std::to_string(reached_blocknum); log_lck.unlock(); } while (changeset_data) { auto changeset_value_view{from_slice(changeset_data.value)}; // Extract address and hash if needed const evmc::address address{bytes_to_address(changeset_value_view)}; changeset_value_view.remove_prefix(kAddressLength); auto hashed_addresses_it{hashed_addresses.find(address)}; if (hashed_addresses_it == hashed_addresses.end()) { const auto hashed_address{keccak256(address.bytes)}; hashed_addresses_it = hashed_addresses.insert_or_assign(address, hashed_address).first; } // Lookup value in plainstate if any // Note ! on unwinds plainstate has not been unwound yet. std::optional plainstate_account{}; if (auto item{plainstate_accounts.get(address)}; item != nullptr) { plainstate_account = *item; } else { auto ps_data{plain_state->find(db::to_slice(address), false)}; if (ps_data && !ps_data.value.empty()) { const auto account{AccountCodec::from_encoded_storage(from_slice(ps_data.value))}; success_or_throw(account); plainstate_account.emplace(*account); } plainstate_accounts.put(address, plainstate_account); } bool account_created{false}; // Whether the account has to be marked as created in changed list if (forward) { // For forward collection: // Creation : if there is no value in changeset it means the account has been created // TrieStorage cleanup : if there is value in changeset we check account in changeset matches account in // plainstate Specifically if both have value and incarnations do not match then a self-destruct has // happened (with possible recreation). If they don't match delete from TrieStorage all hashed addresses // + incarnation if (!changeset_value_view.empty()) { const auto changeset_account{AccountCodec::from_encoded_storage(changeset_value_view)}; success_or_throw(changeset_account); if (changeset_account->incarnation) { if (plainstate_account == std::nullopt || plainstate_account->incarnation != changeset_account->incarnation) { deleted_ts_prefixes.insert( storage_prefix(address.bytes, changeset_account->incarnation)); } } } else { account_created = true; } } else { // For unwind collection: // Creation : if there is no value in plainstate then it means the account has been created if (plainstate_account != std::nullopt) { if (plainstate_account->incarnation) { if (changeset_value_view.empty()) { deleted_ts_prefixes.insert(address.bytes); } else { const auto changeset_account{AccountCodec::from_encoded_storage(changeset_value_view)}; success_or_throw(changeset_account); if (changeset_account->incarnation > plainstate_account->incarnation) { deleted_ts_prefixes.insert( storage_prefix(address.bytes, plainstate_account->incarnation)); } } } } else { account_created = true; } } ret.insert(trie::unpack_nibbles(hashed_addresses_it->second.bytes), account_created); changeset_data = account_changeset->to_current_next_multi(/*throw_notfound=*/false); } ++expected_blocknum; changeset_data = account_changeset->to_next(/*throw_notfound=*/false); } // Eventually delete nodes from trie for deleted accounts if (!deleted_ts_prefixes.empty()) { auto trie_storage = txn.rw_cursor(table::kTrieOfStorage); for (const auto& prefix : deleted_ts_prefixes) { const auto prefix_slice{to_slice(prefix)}; auto data{trie_storage->lower_bound(prefix_slice, /*throw_notfound=*/false)}; while (data && data.key.starts_with(prefix_slice)) { trie_storage->erase(); data = trie_storage->to_next(/*throw_notfound=*/false); } } } if (sw) { const auto [_, duration]{sw->stop()}; SILK_TRACE_M(log_prefix_ + " gathered account changes", {"in", StopWatch::format(duration)}); } return ret; } trie::PrefixSet InterHashes::collect_storage_changes(RWTxn& txn, BlockNum from, BlockNum to, absl::btree_map& hashed_addresses) { std::unique_ptr sw; if (log::test_verbosity(log::Level::kTrace)) { sw = std::make_unique(/*auto_start=*/true); } BlockNum reached_blocknum{0}; BlockNum expected_blocknum{from + 1}; using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; std::unique_lock log_lck(log_mtx_); current_source_ = std::string(table::kStorageChangeSet.name); current_key_ = std::to_string(expected_blocknum); log_lck.unlock(); const Bytes starting_key{block_key(expected_blocknum)}; trie::PrefixSet ret; // Don't rehash same addresses absl::btree_map::iterator hashed_addresses_it{hashed_addresses.begin()}; auto storage_changeset = txn.ro_cursor_dup_sort(table::kStorageChangeSet); auto changeset_data{storage_changeset->lower_bound(to_slice(starting_key), /*throw_notfound=*/false)}; while (changeset_data) { auto changeset_key_view{from_slice(changeset_data.key)}; reached_blocknum = endian::load_big_u64(changeset_key_view.data()); if (reached_blocknum > to) { break; } if (auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); log_lck.lock(); log_time = now + 5s; current_key_ = std::to_string(reached_blocknum); log_lck.unlock(); } changeset_key_view.remove_prefix(sizeof(BlockNum)); const evmc::address address{bytes_to_address(changeset_key_view)}; hashed_addresses_it = hashed_addresses.find(address); if (hashed_addresses_it == hashed_addresses.end()) { const auto hashed_address{keccak256(address.bytes)}; hashed_addresses_it = hashed_addresses.insert_or_assign(address, hashed_address).first; } changeset_key_view.remove_prefix(kAddressLength); Bytes hashed_key(kHashedStoragePrefixLength + (2 * kHashLength), '\0'); std::memcpy(&hashed_key[0], hashed_addresses_it->second.bytes, kHashLength); std::memcpy(&hashed_key[kHashLength], changeset_key_view.data(), kIncarnationLength); while (changeset_data) { auto changeset_value_view{from_slice(changeset_data.value)}; const ByteView location{changeset_value_view.substr(0, kHashLength)}; const auto hashed_location{keccak256(location)}; auto unpacked_location{trie::unpack_nibbles(hashed_location.bytes)}; std::memcpy(&hashed_key[kHashedStoragePrefixLength], unpacked_location.data(), unpacked_location.size()); auto ret_item{ByteView(hashed_key.data(), kHashedStoragePrefixLength + unpacked_location.size())}; ret.insert(ret_item, changeset_value_view.size() == kHashLength); changeset_data = storage_changeset->to_current_next_multi(/*throw_notfound=*/false); } changeset_data = storage_changeset->to_next(/*throw_notfound=*/false); } if (sw) { const auto [_, duration]{sw->stop()}; SILK_TRACE_M(log_prefix_ + " gathered storage changes", {"in", StopWatch::format(duration)}); } return ret; } Stage::Result InterHashes::regenerate_intermediate_hashes(RWTxn& txn, const evmc::bytes32* expected_root) { std::unique_lock log_lck(log_mtx_); incremental_ = false; current_source_.clear(); current_target_.clear(); log_lck.unlock(); Stage::Result ret{Stage::Result::kSuccess}; try { SILK_INFO_M(log_prefix_, {"clearing", table::kTrieOfAccounts.name_str()}); txn->clear_map(table::kTrieOfAccounts.name_str()); SILK_INFO_M(log_prefix_, {"clearing", table::kTrieOfStorage.name_str()}); txn->clear_map(table::kTrieOfStorage.name_str()); txn.commit_and_renew(); account_collector_ = std::make_unique(etl_settings_); storage_collector_ = std::make_unique(etl_settings_); log_lck.lock(); current_source_ = "HashState"; current_target_.clear(); current_key_.clear(); trie_loader_ = std::make_unique(txn, nullptr, nullptr, account_collector_.get(), storage_collector_.get()); log_lck.unlock(); const evmc::bytes32 computed_root{trie_loader_->calculate_root()}; SILK_TRACE_M(log_prefix_, {"function", std::string(__FUNCTION__), "computed_root", to_hex(computed_root.bytes)}); // Fail if not what expected if (expected_root != nullptr && computed_root != *expected_root) { log_lck.lock(); trie_loader_.reset(); // Don't need anymore account_collector_.reset(); // Will invoke dtor which causes all flushed files (if any) to be deleted storage_collector_.reset(); // Will invoke dtor which causes all flushed files (if any) to be deleted log_lck.unlock(); const std::string what{"expected " + to_hex(*expected_root, true) + " got " + to_hex(computed_root, true)}; throw StageError(Stage::Result::kWrongStateRoot, what); } flush_collected_nodes(txn); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result InterHashes::increment_intermediate_hashes(RWTxn& txn, BlockNum from, BlockNum to, const evmc::bytes32* expected_root) { std::unique_lock log_lck(log_mtx_); incremental_ = true; current_source_ = "ChangeSets"; log_lck.unlock(); Stage::Result ret{Stage::Result::kSuccess}; try { account_collector_ = std::make_unique(etl_settings_); storage_collector_ = std::make_unique(etl_settings_); // Cache of hashed addresses absl::btree_map hashed_addresses{}; // Collect all changes from changesets trie::PrefixSet account_changes{collect_account_changes(txn, from, to, hashed_addresses)}; trie::PrefixSet storage_changes{collect_storage_changes(txn, from, to, hashed_addresses)}; // Remove unneeded RAM occupation hashed_addresses.clear(); log_lck.lock(); current_source_ = "ChangeSets"; current_target_.clear(); current_key_.clear(); trie_loader_ = std::make_unique(txn, &account_changes, &storage_changes, account_collector_.get(), storage_collector_.get()); log_lck.unlock(); const evmc::bytes32 computed_root{trie_loader_->calculate_root()}; SILK_TRACE_M(log_prefix_, {"function", std::string(__FUNCTION__), "computed_root", to_hex(computed_root.bytes)}); // Fail if not what expected if (expected_root != nullptr && computed_root != *expected_root) { log_lck.lock(); trie_loader_.reset(); // Don't need anymore account_collector_.reset(); // Will invoke dtor which causes all flushed files (if any) to be deleted storage_collector_.reset(); // Will invoke dtor which causes all flushed files (if any) to be deleted log_lck.unlock(); SILK_ERROR_M("Wrong trie root", {"expected", to_hex(*expected_root, true), "got", to_hex(computed_root, true)}); return Stage::Result::kWrongStateRoot; } flush_collected_nodes(txn); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } void InterHashes::flush_collected_nodes(RWTxn& txn) { // Proceed with loading of newly generated nodes and deletion of obsolete ones. std::unique_lock log_lck(log_mtx_); trie_loader_.reset(); loading_ = true; loading_collector_ = std::move(account_collector_); current_source_ = "etl"; current_target_ = std::string(table::kTrieOfAccounts.name); log_lck.unlock(); auto target = txn.rw_cursor_dup_sort(table::kTrieOfAccounts); // note: not a multi-value table MDBX_put_flags_t flags{target->empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT}; loading_collector_->load(*target, nullptr, flags); log_lck.lock(); loading_collector_ = std::move(storage_collector_); current_target_ = std::string(table::kTrieOfStorage.name); log_lck.unlock(); target->bind(txn, table::kTrieOfStorage); flags = target->empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT; loading_collector_->load(*target, nullptr, flags); log_lck.lock(); current_source_.clear(); current_target_.clear(); loading_ = false; loading_collector_.reset(); log_lck.unlock(); } void InterHashes::reset_log_progress() { std::unique_lock log_lck(log_mtx_); current_source_.clear(); current_target_.clear(); current_key_.clear(); } std::vector InterHashes::get_log_progress() { std::unique_lock log_lck(log_mtx_); std::vector ret{"op", std::string(magic_enum::enum_name(operation_)), "mode", (incremental_ ? "incr" : "full")}; if (trie_loader_) { current_key_ = abridge(trie_loader_->get_log_key(), kAddressLength); ret.insert(ret.end(), {"op", "building merkle tree", "key", current_key_}); } else { if (current_source_.empty() && current_target_.empty()) { ret.insert(ret.end(), {"db", "waiting ..."}); } else { if (loading_) { ret.insert(ret.end(), {"from", "etl", "to", current_target_}); if (loading_collector_) { current_key_ = abridge(loading_collector_->get_load_key(), kHashLength); ret.insert(ret.end(), {"key", current_key_}); } } else { ret.insert(ret.end(), {"from", current_source_, "key", current_key_}); } } } return ret; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_interhashes.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::stagedsync { class InterHashes final : public Stage { public: InterHashes( SyncContext* sync_context, db::DataModelFactory data_model_factory, datastore::etl::CollectorSettings etl_settings) : Stage(sync_context, db::stages::kIntermediateHashesKey), data_model_factory_(std::move(data_model_factory)), etl_settings_(std::move(etl_settings)) {} ~InterHashes() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: //! \brief Resets all fields related to log progress tracking void reset_log_progress(); //! \brief See Erigon (p *HashPromoter) Promote trie::PrefixSet collect_account_changes(db::RWTxn& txn, BlockNum from, BlockNum to, absl::btree_map& hashed_addresses); //! \brief See Erigon (p *HashPromoter) Promote trie::PrefixSet collect_storage_changes(db::RWTxn& txn, BlockNum from, BlockNum to, absl::btree_map& hashed_addresses); //! \brief Erigon RegenerateIntermediateHashes //! \remarks might throw WrongRoot //! \return the state root Stage::Result regenerate_intermediate_hashes( db::RWTxn& txn, const evmc::bytes32* expected_root = nullptr); //! \brief Erigon IncrementIntermediateHashes //! \remarks might throw //! \return the state root [[maybe_unused]] Stage::Result increment_intermediate_hashes( db::RWTxn& txn, BlockNum from, BlockNum to, const evmc::bytes32* expected_root = nullptr); //! \brief Persists in TrieAccount and TrieStorage the collected nodes (and respective deletions if any) void flush_collected_nodes(db::RWTxn& txn); /* **Theoretically:** "Merkle trie root calculation" starts from state, build from state keys - trie, on each level of trie calculates intermediate hash of underlying data. **Practically:** It can be implemented as "Preorder trie traversal" (Preorder - visit Root, visit Left, visit Right). But, let's make couple observations to make traversal over huge state efficient. **Observation 1:** `TrieOfAccounts` already stores state keys in sorted way. Iteration over this bucket will retrieve keys in same order as "Preorder trie traversal". **Observation 2:** each Eth block - changes not big part of state - it means most of Merkle trie intermediate hashes will not change. It means we effectively can cache them. `TrieOfAccounts` stores "Intermediate hashes of all Merkle trie levels". It also sorted and Iteration over `TrieOfAccounts` will retrieve keys in same order as "Preorder trie traversal". **Implementation:** by opening 1 Cursor on state and 1 more Cursor on intermediate hashes bucket - we will receive data in order of "Preorder trie traversal". Cursors will only do "sequential reads" and "jumps forward" - been hardware-friendly. Imagine that account with key 0000....00 (64 zeroes, 32 bytes of zeroes) changed. Here is an example sequence which can be seen by running 2 Cursors: ``` 00 // key came from cache, can't use it - because account with this prefix changed 0000 // key came from cache, can't use it - because account with this prefix changed ... {30 zero bytes}00 // key which came from cache, can't use it - because account with this prefix changed {30 zero bytes}0000 // account came from state, use it - calculate hash, jump to next sub-trie {30 zero bytes}01 // key came from cache, it's next sub-trie, use it, jump to next sub-trie {30 zero bytes}02 // key came from cache, it's next sub-trie, use it, jump to next sub-trie ... {30 zero bytes}ff // key came from cache, it's next sub-trie, use it, jump to next sub-trie {29 zero bytes}01 // key came from cache, it's next sub-trie (1 byte shorter key), use it, jump to next sub-trie {29 zero bytes}02 // key came from cache, it's next sub-trie (1 byte shorter key), use it, jump to next sub-trie ... ff // key came from cache, it's next sub-trie (1 byte shorter key), use it, jump to next sub-trie nil // db returned nil - means no more keys there, done ``` In practice Trie is not full - it means that after account key `{30 zero bytes}0000` may come `{5 zero bytes}01` and amount of iterations will not be big. */ // The loader which (re)builds the trees std::unique_ptr trie_loader_; db::DataModelFactory data_model_factory_; datastore::etl::CollectorSettings etl_settings_; std::unique_ptr account_collector_; // To accumulate new records for kTrieOfAccounts std::unique_ptr storage_collector_; // To accumulate new records for kTrieOfStorage std::unique_ptr loading_collector_; // Effectively the current collector undergoing load (for log) // Logger info std::mutex log_mtx_{}; // Guards async logging std::atomic_bool incremental_{false}; // Whether operation is incremental std::atomic_bool loading_{false}; // Whether we're etl loading std::string current_source_; // Current source of data std::string current_target_; // Current target of data std::string current_key_; // Actual processing key }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_log_index.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_log_index.hpp" #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; using silkworm::datastore::kvdb::to_slice; namespace bitmap { using namespace silkworm::datastore::kvdb::bitmap; } namespace { //! LogBitmapBuilder is a CBOR consumer which builds address and topic roaring bitmaps from the CBOR //! representation of a sequence of Logs class LogBitmapBuilder : public LogCborConsumer { public: using AddressHandler = std::function)>; using TopicHandler = std::function; LogBitmapBuilder(AddressHandler address_callback, TopicHandler topic_callback) : address_callback_{std::move(address_callback)}, topic_callback_{std::move(topic_callback)} {} void on_num_logs(size_t /*num_logs*/) override {} void on_address(std::span address) override { address_callback_(address); } void on_num_topics(size_t /*num_topics*/) override {} void on_topic(HashAsSpan topic) override { topic_callback_(topic); } void on_data(std::span /*data*/) override {} private: AddressHandler address_callback_; TopicHandler topic_callback_; }; } // namespace Stage::Result LogIndex::forward(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution auto previous_progress{get_progress(txn)}; const auto target_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress == target_progress) { // Nothing to process operation_ = OperationType::kNone; return ret; } if (previous_progress > target_progress) { // Something bad had happened. Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "LogIndex progress " + std::to_string(previous_progress) + " greater than Execution progress " + std::to_string(target_progress)); } reset_log_progress(); const BlockNum segment_width{target_progress - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(target_progress), "span", std::to_string(segment_width)}); } // If this is first time we forward AND we have "prune history" set // do not process all blocks rather only what is needed if (prune_mode_history_.enabled()) { if (!previous_progress) previous_progress = prune_mode_history_.value_from_head(target_progress); } if (previous_progress < target_progress) forward_impl(txn, previous_progress, target_progress); reset_log_progress(); update_progress(txn, target_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; addresses_collector_.reset(); topics_collector_.reset(); return ret; } Stage::Result LogIndex::unwind(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto execution_stage_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress <= to || execution_stage_progress <= to) { // Nothing to process operation_ = OperationType::kNone; return ret; } reset_log_progress(); const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } if (previous_progress && previous_progress > to) unwind_impl(txn, previous_progress, to); reset_log_progress(); update_progress(txn, to); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } addresses_collector_.reset(); topics_collector_.reset(); operation_ = OperationType::kNone; return ret; } Stage::Result LogIndex::prune(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kPrune; try { throw_if_stopping(); if (!prune_mode_history_.enabled()) { operation_ = OperationType::kNone; return ret; } const auto forward_progress{get_progress(txn)}; const auto prune_progress{get_prune_progress(txn)}; if (prune_progress >= forward_progress) { operation_ = OperationType::kNone; return ret; } // Need to erase all history info below this threshold // If threshold is zero we don't have anything to prune const auto prune_threshold{prune_mode_history_.value_from_head(forward_progress)}; if (!prune_threshold) { operation_ = OperationType::kNone; return ret; } reset_log_progress(); const BlockNum segment_width{forward_progress - prune_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } if (!prune_progress || prune_progress < forward_progress) { prune_impl(txn, prune_threshold, table::kLogAddressIndex); prune_impl(txn, prune_threshold, table::kLogTopicIndex); } reset_log_progress(); stages::write_stage_prune_progress(txn, stage_name_, forward_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } addresses_collector_.reset(); topics_collector_.reset(); return ret; } void LogIndex::forward_impl(RWTxn& txn, const BlockNum from, const BlockNum to) { using datastore::kvdb::Collector; const MapConfig source_config{table::kLogs}; std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kForward; loading_ = false; topics_collector_ = std::make_unique(etl_settings_); addresses_collector_ = std::make_unique(etl_settings_); current_source_ = std::string(source_config.name); current_target_.clear(); current_key_.clear(); log_lck.unlock(); // Into etl collectors collect_bitmaps_from_logs(txn, source_config, from, to); log_lck.lock(); loading_ = true; current_key_.clear(); current_target_ = table::kLogAddressIndex.name; index_loader_ = std::make_unique(table::kLogAddressIndex); log_lck.unlock(); index_loader_->merge_bitmaps32(txn, kAddressLength, addresses_collector_.get()); log_lck.lock(); current_key_.clear(); current_target_ = table::kLogTopicIndex.name; index_loader_ = std::make_unique(table::kLogTopicIndex); log_lck.unlock(); index_loader_->merge_bitmaps32(txn, kHashLength, topics_collector_.get()); log_lck.lock(); loading_ = false; current_target_.clear(); index_loader_.reset(); log_lck.unlock(); } void LogIndex::unwind_impl(RWTxn& txn, BlockNum from, BlockNum to) { const MapConfig source_config{table::kLogs}; std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kUnwind; loading_ = false; current_source_ = std::string(source_config.name); current_key_.clear(); log_lck.unlock(); std::map addresses_keys; std::map topics_keys; collect_unique_keys_from_logs(txn, source_config, from, to, addresses_keys, topics_keys); log_lck.lock(); current_target_ = table::kLogAddressIndex.name; index_loader_ = std::make_unique(table::kLogAddressIndex); log_lck.unlock(); index_loader_->unwind_bitmaps32(txn, to, addresses_keys); log_lck.lock(); current_target_ = table::kLogTopicIndex.name; index_loader_ = std::make_unique(table::kLogTopicIndex); log_lck.unlock(); index_loader_->unwind_bitmaps32(txn, to, topics_keys); log_lck.lock(); index_loader_.reset(); current_source_.clear(); current_target_.clear(); current_key_.clear(); log_lck.unlock(); } void LogIndex::collect_bitmaps_from_logs(RWTxn& txn, const MapConfig& source_config, BlockNum from, BlockNum to) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; const BlockNum max_block_num{to}; BlockNum reached_block_num{0}; absl::btree_map topics_bitmaps; absl::btree_map addresses_bitmaps; size_t topics_bitmaps_size{0}; size_t addresses_bitmaps_size{0}; uint16_t topics_flush_count{0}; uint16_t addresses_flush_count{0}; // The CBOR consumer we use to collect decoded data into bitmaps LogBitmapBuilder bitmap_builder{ [&](std::span address_data) { Bytes key(address_data.data(), address_data.size()); auto it{addresses_bitmaps.find(key)}; if (it == addresses_bitmaps.end()) { it = addresses_bitmaps.emplace(key, roaring::Roaring()).first; addresses_bitmaps_size += key.size() + sizeof(uint32_t); } it->second.add(gsl::narrow(reached_block_num)); addresses_bitmaps_size += sizeof(uint32_t); }, [&](HashAsSpan topic_data) { Bytes key(topic_data.data(), topic_data.size()); auto it{topics_bitmaps.find(key)}; if (it == topics_bitmaps.end()) { it = topics_bitmaps.emplace(key, roaring::Roaring()).first; topics_bitmaps_size += key.size() + sizeof(uint32_t); } it->second.add(gsl::narrow(reached_block_num)); topics_bitmaps_size += sizeof(uint32_t); }}; auto start_key{block_key(from + 1)}; auto source = txn.ro_cursor(source_config); auto source_data{source->lower_bound(to_slice(start_key), false)}; while (source_data) { reached_block_num = endian::load_big_u64(static_cast(source_data.key.data())); if (reached_block_num > max_block_num) break; // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } // Decode CBOR value content and distribute it to the 2 bitmaps cbor_decode({static_cast(source_data.value.data()), source_data.value.length()}, bitmap_builder); // Flush bitmaps batch by batch if (topics_bitmaps_size > batch_size_) { bitmap::IndexLoader::flush_bitmaps_to_etl(topics_bitmaps, topics_collector_.get(), topics_flush_count++); topics_bitmaps_size = 0; } if (addresses_bitmaps_size > batch_size_) { bitmap::IndexLoader::flush_bitmaps_to_etl(addresses_bitmaps, addresses_collector_.get(), addresses_flush_count++); addresses_bitmaps_size = 0; } source_data = source->to_next(/*throw_notfound=*/false); } // Flush remaining portion of bitmaps (if any) bitmap::IndexLoader::flush_bitmaps_to_etl(topics_bitmaps, topics_collector_.get(), topics_flush_count); bitmap::IndexLoader::flush_bitmaps_to_etl(addresses_bitmaps, addresses_collector_.get(), addresses_flush_count); } void LogIndex::collect_unique_keys_from_logs(RWTxn& txn, const MapConfig& source_config, BlockNum from, BlockNum to, std::map& addresses, std::map& topics) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; BlockNum expected_block_num{std::min(from, to) + 1}; const BlockNum max_block_num{std::max(from, to)}; BlockNum reached_block_num{0}; // The CBOR consumer we use to collect decoded data into bitmaps LogBitmapBuilder bitmap_builder{ [&](std::span address_data) { Bytes key(address_data.data(), address_data.size()); (void)addresses.try_emplace(key, false); }, [&](HashAsSpan topic_data) { Bytes key(topic_data.data(), topic_data.size()); (void)topics.try_emplace(key, false); }}; auto start_key{block_key(expected_block_num)}; auto source = txn.ro_cursor(source_config); auto source_data{source->lower_bound(to_slice(start_key), false)}; while (source_data) { reached_block_num = endian::load_big_u64(static_cast(source_data.key.data())); if (reached_block_num > max_block_num) break; // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } // Decode CBOR value content and distribute it to the 2 bitmaps cbor_decode({static_cast(source_data.value.data()), source_data.value.length()}, bitmap_builder); source_data = source->to_next(/*throw_notfound=*/false); } } void LogIndex::prune_impl(RWTxn& txn, BlockNum threshold, const MapConfig& target) { std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kPrune; loading_ = false; current_source_ = target.name; current_target_ = current_source_; current_key_.clear(); index_loader_ = std::make_unique(target); log_lck.unlock(); index_loader_->prune_bitmaps32(txn, threshold); log_lck.lock(); index_loader_.reset(); current_source_.clear(); current_target_.clear(); current_key_.clear(); log_lck.unlock(); } std::vector LogIndex::get_log_progress() { std::vector ret{"op", std::string(magic_enum::enum_name(operation_))}; std::unique_lock log_lck(sl_mutex_); if (current_source_.empty() && current_target_.empty()) { ret.insert(ret.end(), {"db", "waiting ..."}); } else { switch (operation_) { case OperationType::kForward: if (loading_) { if (current_target_ == table::kLogAddressIndex.name && addresses_collector_) { current_key_ = abridge(addresses_collector_->get_load_key(), kAddressLength); } else if (current_target_ == table::kLogTopicIndex.name && topics_collector_) { current_key_ = abridge(topics_collector_->get_load_key(), kAddressLength); } else { current_key_.clear(); } ret.insert(ret.end(), {"from", "etl", "to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "to", "etl", "key", current_key_}); } break; case OperationType::kUnwind: if (index_loader_) { current_key_ = index_loader_->get_current_key(); ret.insert(ret.end(), {"from", "etl", "to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "to", "etl", "key", current_key_}); } break; case OperationType::kPrune: if (index_loader_) { current_key_ = index_loader_->get_current_key(); ret.insert(ret.end(), {"to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"to", current_target_, current_key_}); } break; default: ret.insert(ret.end(), {"from", current_source_, "key", current_key_}); } } return ret; } void LogIndex::reset_log_progress() { std::unique_lock log_lck(sl_mutex_); loading_ = false; current_source_.clear(); current_target_.clear(); current_key_.clear(); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_log_index.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::stagedsync { class LogIndex : public Stage { public: LogIndex( SyncContext* sync_context, size_t batch_size, datastore::etl::CollectorSettings etl_settings, db::BlockAmount prune_mode_history) : Stage(sync_context, db::stages::kLogIndexKey), batch_size_(batch_size), etl_settings_(std::move(etl_settings)), prune_mode_history_(prune_mode_history) {} LogIndex(const LogIndex&) = delete; // not copyable LogIndex(LogIndex&&) = delete; // nor movable ~LogIndex() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: size_t batch_size_; datastore::etl::CollectorSettings etl_settings_; db::BlockAmount prune_mode_history_; std::unique_ptr topics_collector_; std::unique_ptr addresses_collector_; std::unique_ptr index_loader_; std::atomic_bool loading_{false}; // Whether we're in ETL loading phase std::string current_source_; // Current source of data std::string current_target_; // Current target of transformed data std::string current_key_; // Actual processing key void forward_impl(db::RWTxn& txn, BlockNum from, BlockNum to); void unwind_impl(db::RWTxn& txn, BlockNum from, BlockNum to); void prune_impl(db::RWTxn& txn, BlockNum threshold, const db::MapConfig& target); //! \brief Collects bitmaps of block numbers for each log entry void collect_bitmaps_from_logs(db::RWTxn& txn, const db::MapConfig& source_config, BlockNum from, BlockNum to); //! \brief Collects unique keys for log entries within provided boundaries void collect_unique_keys_from_logs( db::RWTxn& txn, const db::MapConfig& source_config, BlockNum from, BlockNum to, std::map& addresses, std::map& topics); void reset_log_progress(); // Clears out all logging vars }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_senders.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_senders.hpp" #include #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { using namespace std::chrono_literals; using namespace silkworm::db; using silkworm::datastore::kvdb::from_slice; using silkworm::datastore::kvdb::to_slice; Senders::Senders( SyncContext* sync_context, DataModelFactory data_model_factory, const ChainConfig& chain_config, size_t batch_size, datastore::etl::CollectorSettings etl_settings, BlockAmount prune_mode_senders) : Stage(sync_context, stages::kSendersKey), data_model_factory_(std::move(data_model_factory)), chain_config_(chain_config), prune_mode_senders_(prune_mode_senders), max_batch_size_{batch_size / std::thread::hardware_concurrency() / sizeof(AddressRecovery)}, batch_{std::make_shared>()}, etl_settings_(std::move(etl_settings)) { // Reserve space for max batch in advance batch_->reserve(max_batch_size_); } Stage::Result Senders::forward(RWTxn& txn) { std::unique_lock log_lock(sl_mutex_); operation_ = OperationType::kForward; total_processed_blocks_ = 0; total_collected_transactions_ = 0; log_lock.unlock(); collector_ = std::make_unique(etl_settings_); const auto res{parallel_recover(txn)}; if (res == Stage::Result::kSuccess) { txn.commit_and_renew(); } log_lock.lock(); operation_ = OperationType::kNone; log_lock.unlock(); collector_.reset(); return res; } Stage::Result Senders::unwind(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; const BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; current_key_.clear(); using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; std::unique_ptr sw; if (log::test_verbosity(log::Level::kTrace)) { sw = std::make_unique(/*auto_start=*/true); } try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto bodies_stage_progress{stages::read_stage_progress(txn, stages::kBlockBodiesKey)}; if (previous_progress <= to || bodies_stage_progress <= to) { // Nothing to process operation_ = OperationType::kNone; return ret; } const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } auto unwind_cursor = txn.rw_cursor(table::kSenders); const auto start_key{block_key(to + 1)}; size_t erased{0}; auto data{unwind_cursor->lower_bound(to_slice(start_key), /*throw_notfound=*/false)}; while (data) { // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); const auto reached_block_num{endian::load_big_u64(from_slice(data.key).data())}; current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } unwind_cursor->erase(); ++erased; data = unwind_cursor->to_next(/*throw_notfound=*/false); } if (sw) { const auto [_, duration]{sw->lap()}; log::Trace(log_prefix_, {"origin", table::kSenders.name_str(), "erased", std::to_string(erased), "in", StopWatch::format(duration)}); } update_progress(txn, to); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } Stage::Result Senders::prune(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kPrune; current_key_.clear(); std::unique_ptr sw; if (log::test_verbosity(log::Level::kTrace)) { sw = std::make_unique(/*auto_start=*/true); } using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; try { throw_if_stopping(); if (!prune_mode_senders_.enabled()) { operation_ = OperationType::kNone; return ret; } const auto forward_progress{get_progress(txn)}; const auto prune_progress{get_prune_progress(txn)}; if (prune_progress >= forward_progress) { operation_ = OperationType::kNone; return ret; } // Need to erase all history info below this threshold // If threshold is zero we don't have anything to prune const auto prune_threshold{prune_mode_senders_.value_from_head(forward_progress)}; if (!prune_threshold) { operation_ = OperationType::kNone; return ret; } const BlockNum segment_width{forward_progress - prune_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } auto prune_cursor = txn.rw_cursor(table::kSenders); const auto upper_key{block_key(prune_threshold)}; size_t erased{0}; auto prune_data{prune_cursor->lower_bound(to_slice(upper_key), /*throw_notfound=*/false)}; while (prune_data) { const auto reached_block_num{endian::load_big_u64(from_slice(prune_data.key).data())}; // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(reached_block_num); log_time = now + 5s; } if (reached_block_num <= prune_threshold) { prune_cursor->erase(); ++erased; } prune_data = prune_cursor->to_previous(/*throw_notfound=*/false); } throw_if_stopping(); if (sw) { const auto [_, duration]{sw->lap()}; log::Trace(log_prefix_, {"source", table::kSenders.name_str(), "erased", std::to_string(erased), "in", StopWatch::format(duration)}); } stages::write_stage_prune_progress(txn, stage_name_, forward_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } void Senders::set_prune_mode_senders(BlockAmount prune_mode_senders) { prune_mode_senders_ = prune_mode_senders; } Stage::Result Senders::parallel_recover(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; collected_senders_ = 0; collector_->clear(); batch_->clear(); results_.clear(); try { DataModel data_model = data_model_factory_(txn); // Check stage boundaries using previous execution of current stage and current execution of previous stage auto previous_progress{stages::read_stage_progress(txn, stages::kSendersKey)}; auto block_hashes_progress{stages::read_stage_progress(txn, stages::kBlockHashesKey)}; auto block_bodies_progress{stages::read_stage_progress(txn, stages::kBlockBodiesKey)}; auto target_block_num{std::min(block_hashes_progress, block_bodies_progress)}; // note: it would be better to use sync_context_->target_block_num instead of target_block const BlockNum segment_width{target_block_num - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(target_block_num), "span", std::to_string(segment_width), "max_batch_size", std::to_string(max_batch_size_)}); } if (previous_progress == target_block_num) { // Nothing to process return ret; } if (previous_progress > target_block_num) { // Something bad had happened. Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "Previous progress " + std::to_string(previous_progress) + " > target progress " + std::to_string(target_block_num)); } static secp256k1_context* context = secp256k1_context_create(SILKWORM_SECP256K1_CONTEXT_FLAGS); if (!context) throw std::runtime_error("Could not create elliptic curve context"); BlockNum start_block_num{previous_progress + 1u}; // Create the pool of worker threads crunching the address recovery tasks ThreadPool worker_pool; // Load block transactions from db and recover tx senders in batches uint64_t total_collected_senders{0}; uint64_t total_empty_blocks{0}; // Start from first block and read all in sequence for (auto current_block_num = start_block_num; current_block_num <= target_block_num; ++current_block_num) { const auto current_hash = read_canonical_header_hash(txn, current_block_num); if (!current_hash) throw StageError(Stage::Result::kBadChainSequence, "Canonical hash at block_num " + std::to_string(current_block_num) + " not found"); const auto block_header = data_model.read_header(current_block_num, *current_hash); if (!block_header) throw StageError(Stage::Result::kBadChainSequence, "Canonical header at block_num " + std::to_string(current_block_num) + " not found"); BlockBody block_body; const auto found = data_model.read_body(*current_hash, current_block_num, block_body); if (!found) throw StageError(Stage::Result::kBadChainSequence, "Canonical body at block_num " + std::to_string(current_block_num) + " not found"); // Every 1024 blocks check if the SignalHandler has been triggered if ((current_block_num % 1024 == 0) && is_stopping()) { throw StageError(Stage::Result::kAborted); } // Get the body and its transactions if (block_body.transactions.empty()) { ++total_empty_blocks; continue; } total_collected_senders += block_body.transactions.size(); success_or_throw(add_to_batch(current_block_num, block_header->timestamp, *current_hash, block_body.transactions)); // Process batch in parallel if max size has been reached if (batch_->size() >= max_batch_size_) { increment_total_collected_transactions(batch_->size()); recover_batch(worker_pool, context); } } // Recover last incomplete batch [likely] if (!batch_->empty()) { increment_total_collected_transactions(batch_->size()); recover_batch(worker_pool, context); } // Wait for all senders to be recovered and collected in ETL while (collected_senders_ != total_collected_senders) { collect_senders(); std::this_thread::sleep_for(1ms); } ensure(collector_->size() + total_empty_blocks == segment_width, [&]() { return "Senders: invalid number of ETL keys expected=" + std::to_string(segment_width) + "got=" + std::to_string(collector_->size() + total_empty_blocks); }); // Store all recovered senders into db log::Trace(log_prefix_, {"op", "store senders", "reached_block_num", std::to_string(target_block_num)}); store_senders(txn); // Update stage progress with last reached block number stages::write_stage_progress(txn, stages::kSendersKey, target_block_num); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } return ret; } Stage::Result Senders::add_to_batch(BlockNum block_num, BlockTime block_timestamp, const Hash& block_hash, const std::vector& transactions) { if (is_stopping()) { return Stage::Result::kAborted; } const evmc_revision rev{chain_config_.revision(block_num, block_timestamp)}; const bool has_homestead{rev >= EVMC_HOMESTEAD}; const bool has_spurious_dragon{rev >= EVMC_SPURIOUS_DRAGON}; uint32_t tx_id{0}; for (const auto& transaction : transactions) { if (!protocol::transaction_type_is_supported(transaction.type, rev)) { log::Error(log_prefix_) << "Transaction type " << magic_enum::enum_name(transaction.type) << " for transaction #" << tx_id << " in block #" << block_num << " before it's supported"; return Stage::Result::kInvalidTransaction; } if (!is_valid_signature(transaction.r, transaction.s, has_homestead)) { log::Error(log_prefix_) << "Got invalid signature for transaction #" << tx_id << " in block #" << block_num; return Stage::Result::kInvalidTransaction; } if (transaction.chain_id.has_value()) { if (!has_spurious_dragon) { log::Error(log_prefix_) << "EIP-155 signature for transaction #" << tx_id << " in block #" << block_num << " before Spurious Dragon"; return Stage::Result::kInvalidTransaction; } if (transaction.chain_id.value() != chain_config_.chain_id) { log::Error(log_prefix_) << "EIP-155 invalid signature for transaction #" << tx_id << " in block #" << block_num; return Stage::Result::kInvalidTransaction; } } Bytes rlp{}; transaction.encode_for_signing(rlp); batch_->push_back(AddressRecovery{block_num, block_hash, transaction.odd_y_parity}); intx::be::unsafe::store(batch_->back().tx_signature, transaction.r); intx::be::unsafe::store(batch_->back().tx_signature + kHashLength, transaction.s); batch_->back().rlp = std::move(rlp); ++tx_id; } increment_total_processed_blocks(); return is_stopping() ? Stage::Result::kAborted : Stage::Result::kSuccess; } void Senders::recover_batch(ThreadPool& worker_pool, const secp256k1_context* context) { // Launch parallel senders recovery log::Trace(log_prefix_, {"op", "recover_batch", "first", std::to_string(batch_->cbegin()->block_num)}); StopWatch sw; const auto start = sw.start(); // Wait until total unfinished tasks in worker pool falls below 2 * num workers const size_t max_unfinished_tasks = 2 * worker_pool.get_thread_count(); while (worker_pool.get_tasks_total() >= max_unfinished_tasks) { std::this_thread::sleep_for(1ms); } // Swap the waiting batch w/ an empty one and submit a new recovery task to the worker pool std::shared_ptr> ready_batch{std::make_shared>()}; ready_batch->reserve(max_batch_size_); ready_batch.swap(batch_); auto batch_result = worker_pool.submit([=]() { std::for_each(ready_batch->begin(), ready_batch->end(), [&](auto& package) { const auto tx_hash{keccak256(package.rlp)}; const bool ok = silkworm_recover_address(package.tx_from.bytes, tx_hash.bytes, package.tx_signature, package.odd_y_parity, context); if (!ok) { throw std::runtime_error("Unable to recover from address in block " + std::to_string(package.block_num)); } }); return ready_batch; }); results_.emplace_back(std::move(batch_result)); // Check completed batch of senders and collect them collect_senders(); const auto [end, _] = sw.lap(); log::Trace(log_prefix_, {"op", "recover_batch", "elapsed", StopWatch::format(end - start)}); if (is_stopping()) throw StageError(Stage::Result::kAborted); } void Senders::collect_senders() { std::erase_if(results_, [&](auto& future_completed_batch) { if (future_completed_batch.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { auto completed_batch = future_completed_batch.get(); // Put recovered senders into ETL collect_senders(completed_batch); // Update count of collected senders collected_senders_ += completed_batch->size(); return true; } return false; }); } void Senders::collect_senders(std::shared_ptr& batch) { StopWatch sw; const auto start = sw.start(); BlockNum block_num{0}; Bytes key; Bytes value; for (const auto& package : *batch) { if (package.block_num != block_num) { if (!key.empty()) { collector_->collect({key, value}); key.clear(); value.clear(); } key = block_key(package.block_num, package.block_hash.bytes); value.clear(); block_num = package.block_num; } value.append(package.tx_from.bytes, sizeof(evmc::address)); } if (!key.empty()) { collector_->collect({key, value}); key.clear(); value.clear(); } const auto [end, _] = sw.lap(); log::Trace(log_prefix_, {"op", "store_senders", "elapsed", StopWatch::format(end - start)}); if (is_stopping()) throw StageError(Stage::Result::kAborted); } void Senders::store_senders(RWTxn& txn) { if (!collector_->empty()) { log::Trace(log_prefix_, {"load ETL items", std::to_string(collector_->size())}); // Prepare target table auto senders_cursor = txn.rw_cursor_dup_sort(table::kSenders); log::Trace(log_prefix_, {"load ETL data", human_size(collector_->bytes_size())}); collector_->load(*senders_cursor, nullptr, MDBX_put_flags_t::MDBX_APPEND); } } std::vector Senders::get_log_progress() { std::unique_lock lock{mutex_}; switch (operation_) { case OperationType::kForward: { return {"blocks", std::to_string(total_processed_blocks_), "transactions", std::to_string(total_collected_transactions_)}; } default: return {"key", current_key_}; } } void Senders::increment_total_processed_blocks() { std::unique_lock lock{mutex_}; ++total_processed_blocks_; } void Senders::increment_total_collected_transactions(size_t delta) { std::unique_lock lock{mutex_}; total_collected_transactions_ += delta; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_senders.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { //! \brief The information to compute the sender address from transaction signature struct AddressRecovery { BlockNum block_num{0}; // Number of block containing the transaction Hash block_hash; // Hash of the block containing the transaction bool odd_y_parity{false}; // Whether y parity is odd (https://eips.ethereum.org/EIPS/eip-155) uint8_t tx_signature[64]{}; // Signature of the transaction evmc::address tx_from; // Recovered sender address Bytes rlp; // RLP representation of the transaction }; using AddressRecoveryBatch = std::vector; class Senders final : public Stage { public: Senders( SyncContext* sync_context, db::DataModelFactory data_model_factory, const ChainConfig& chain_config, size_t batch_size, datastore::etl::CollectorSettings etl_settings, db::BlockAmount prune_mode_senders); ~Senders() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; void set_prune_mode_senders(db::BlockAmount prune_mode_senders); private: Stage::Result parallel_recover(db::RWTxn& txn); Stage::Result add_to_batch(BlockNum block_num, BlockTime block_timestamp, const Hash& block_hash, const std::vector& transactions); void recover_batch(ThreadPool& worker_pool, const secp256k1_context* context); void collect_senders(); void collect_senders(std::shared_ptr& batch); void store_senders(db::RWTxn& txn); void increment_total_processed_blocks(); void increment_total_collected_transactions(size_t delta); db::DataModelFactory data_model_factory_; const ChainConfig& chain_config_; db::BlockAmount prune_mode_senders_; //! The size of recovery batches size_t max_batch_size_; //! The current recovery batch being created std::shared_ptr batch_; //! The sequence of completed batch futures std::vector>> results_; //! The total count of collected senders uint64_t collected_senders_{0}; //! ETL collector writing recovered senders in bulk datastore::etl::CollectorSettings etl_settings_; std::unique_ptr collector_; // Stats std::mutex mutex_{}; size_t total_processed_blocks_{0}; size_t total_collected_transactions_{0}; std::string current_key_{}; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_triggers.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_triggers.hpp" #include #include #include #include namespace silkworm::stagedsync { TriggersStage::TriggersStage(SyncContext* sync_context) : Stage(sync_context, db::stages::kTriggersStageKey) { } Stage::Result TriggersStage::forward(db::RWTxn& tx) { Stage::Result result = Stage::Result::kSuccess; operation_ = OperationType::kForward; try { current_tx_ = &tx; [[maybe_unused]] auto _ = gsl::finally([this] { current_tx_ = nullptr; }); ioc_.restart(); ioc_.run(); const auto current_progress = get_progress(tx); const BlockNum previous_stage_progress = db::stages::read_stage_progress(tx, db::stages::kTxLookupKey); if (current_progress >= previous_stage_progress) { // Nothing to process return result; } const BlockNum segment_width{previous_stage_progress - current_progress}; if (segment_width > db::stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(current_progress), "to", std::to_string(previous_stage_progress), "span", std::to_string(segment_width)}); } throw_if_stopping(); update_progress(tx, previous_stage_progress); tx.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); result = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return result; } Stage::Result TriggersStage::unwind(db::RWTxn& txn) { Stage::Result result = Stage::Result::kSuccess; if (!sync_context_->unwind_point) { return result; } const BlockNum unwind_point = *sync_context_->unwind_point; operation_ = OperationType::kUnwind; try { const auto current_progress = get_progress(txn); if (unwind_point >= current_progress) { return result; } const BlockNum segment_width = current_progress - unwind_point; if (segment_width > db::stages::kSmallBlockSegmentWidth) { SILK_INFO_M(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(current_progress), "to", std::to_string(unwind_point), "span", std::to_string(segment_width)}); } throw_if_stopping(); update_progress(txn, unwind_point); txn.commit_and_renew(); } catch (const StageError& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = static_cast(ex.err()); } catch (const mdbx::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kDbError; } catch (const std::exception& ex) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); result = Stage::Result::kUnexpectedError; } catch (...) { SILK_ERROR_M(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); result = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return result; } Task TriggersStage::schedule(std::function callback) { auto task_caller = [](auto* self, auto trigger) -> Task { db::RWTxn* tx = self->current_tx_; SILKWORM_ASSERT(tx); trigger(*tx); co_return; }; return concurrency::spawn_task(ioc_, task_caller(this, std::move(callback))); } bool TriggersStage::stop() { ioc_.stop(); return Stage::stop(); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_triggers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::stagedsync { class TriggersStage : public Stage, public datastore::StageScheduler { public: explicit TriggersStage(SyncContext* sync_context); ~TriggersStage() override = default; Stage::Result forward(db::RWTxn& tx) override; Stage::Result unwind(db::RWTxn& txn) override; Stage::Result prune(db::RWTxn&) override { return Stage::Result::kSuccess; } Task schedule(std::function callback) override; bool stop() override; protected: boost::asio::io_context ioc_; private: db::RWTxn* current_tx_{}; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_triggers_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_triggers.hpp" #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; using db::test_util::TempChainDataStore; class TriggersStateForTest : public TriggersStage { public: using TriggersStage::TriggersStage; boost::asio::io_context& io_context() { return ioc_; } }; TEST_CASE("TriggersStage: scheduled task lifetime") { TempChainDataStore temp_chaindata; RWTxn& txn{temp_chaindata.rw_txn()}; txn.disable_commit(); stagedsync::SyncContext sync_context{}; TriggersStateForTest stage_triggers{&sync_context}; auto future = concurrency::spawn_future(stage_triggers.io_context(), stage_triggers.schedule([](auto& rw_txn) { rw_txn.is_open(); })); REQUIRE(stage_triggers.forward(txn) == stagedsync::Stage::Result::kSuccess); CHECK_NOTHROW(future.get()); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_tx_lookup.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stage_tx_lookup.hpp" #include #include #include #include #include namespace silkworm::stagedsync { using namespace silkworm::db; using datastore::kvdb::Collector; Stage::Result TxLookup::forward(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kForward; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution auto previous_progress{get_progress(txn)}; const auto target_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress == target_progress) { // Nothing to process operation_ = OperationType::kNone; return ret; } if (previous_progress > target_progress) { // Something bad had happened. Maybe we need to unwind ? throw StageError(Stage::Result::kInvalidProgress, "TxLookup progress " + std::to_string(previous_progress) + " greater than Execution progress " + std::to_string(target_progress)); } // Snapshots already have TxLookup index, so we must start after max frozen block here DataModel data_model = data_model_factory_(txn); const auto max_frozen_block_num{data_model.max_frozen_block_num()}; if (max_frozen_block_num > previous_progress) { previous_progress = std::min(max_frozen_block_num, target_progress); // If pruning is enabled, make it start from max frozen block as well if (prune_mode_tx_index_.enabled()) { set_prune_progress(txn, previous_progress); } } reset_log_progress(); const BlockNum segment_width{target_progress - previous_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(target_progress), "span", std::to_string(segment_width)}); } // If this is first time we forward AND we have "prune history" set // do not process all blocks rather only what is needed if (!previous_progress && prune_mode_tx_index_.enabled()) previous_progress = prune_mode_tx_index_.value_from_head(target_progress); if (previous_progress < target_progress) forward_impl(txn, previous_progress, target_progress); reset_log_progress(); update_progress(txn, target_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; collector_.reset(); return ret; } Stage::Result TxLookup::unwind(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; if (!sync_context_->unwind_point.has_value()) return ret; BlockNum to{sync_context_->unwind_point.value()}; operation_ = OperationType::kUnwind; try { throw_if_stopping(); // Check stage boundaries from previous execution and previous stage execution const auto previous_progress{get_progress(txn)}; const auto execution_progress{stages::read_stage_progress(txn, stages::kExecutionKey)}; if (previous_progress <= to || execution_progress <= to) { // Nothing to process operation_ = OperationType::kNone; return ret; } // Snapshots already have TxLookup index, so we must stop before max frozen block here DataModel data_model = data_model_factory_(txn); const auto max_frozen_block_num{data_model.max_frozen_block_num()}; to = std::max(to, max_frozen_block_num); reset_log_progress(); const BlockNum segment_width{previous_progress - to}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(previous_progress), "to", std::to_string(to), "span", std::to_string(segment_width)}); } if (previous_progress && previous_progress > to) unwind_impl(txn, previous_progress, to); reset_log_progress(); update_progress(txn, to); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; collector_.reset(); return ret; } Stage::Result TxLookup::prune(RWTxn& txn) { Stage::Result ret{Stage::Result::kSuccess}; operation_ = OperationType::kPrune; try { throw_if_stopping(); if (!prune_mode_tx_index_.enabled()) { operation_ = OperationType::kNone; return ret; } const auto forward_progress{get_progress(txn)}; const auto prune_progress{get_prune_progress(txn)}; if (prune_progress >= forward_progress) { operation_ = OperationType::kNone; return ret; } // Need to erase all history info below this threshold // If threshold is zero we don't have anything to prune const auto prune_threshold{prune_mode_tx_index_.value_from_head(forward_progress)}; if (!prune_threshold) { operation_ = OperationType::kNone; return ret; } reset_log_progress(); const BlockNum segment_width{forward_progress - prune_progress}; if (segment_width > stages::kSmallBlockSegmentWidth) { log::Info(log_prefix_, {"op", std::string(magic_enum::enum_name(operation_)), "from", std::to_string(prune_progress), "to", std::to_string(forward_progress), "threshold", std::to_string(prune_threshold)}); } if (!prune_progress || prune_progress < forward_progress) { const auto previous_prune_threshold = prune_mode_tx_index_.value_from_head(prune_progress); prune_impl(txn, previous_prune_threshold, prune_threshold); } reset_log_progress(); stages::write_stage_prune_progress(txn, stage_name_, forward_progress); txn.commit_and_renew(); } catch (const StageError& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = static_cast(ex.err()); } catch (const mdbx::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kDbError; } catch (const std::exception& ex) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", std::string(ex.what())}); ret = Stage::Result::kUnexpectedError; } catch (...) { log::Error(log_prefix_, {"function", std::string(__FUNCTION__), "exception", "unexpected and undefined"}); ret = Stage::Result::kUnexpectedError; } operation_ = OperationType::kNone; return ret; } void TxLookup::forward_impl(RWTxn& txn, const BlockNum from, const BlockNum to) { std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kForward; loading_.store(false); collector_ = std::make_unique(etl_settings_); current_source_ = std::string(table::kBlockBodies.name); current_target_.clear(); current_key_.clear(); log_lck.unlock(); // Into etl collector collect_transaction_hashes_from_canonical_bodies(txn, from, to, /*for_deletion=*/false); log_lck.lock(); loading_.store(true); current_target_ = std::string(table::kTxLookup.name); current_key_.clear(); log_lck.unlock(); auto target = txn.rw_cursor_dup_sort(table::kTxLookup); // note: not a multi-value table collector_->load(*target, nullptr, target->empty() ? MDBX_put_flags_t::MDBX_APPEND : MDBX_put_flags_t::MDBX_UPSERT); log_lck.lock(); loading_.store(false); current_source_.clear(); current_target_.clear(); current_key_.clear(); collector_.reset(); log_lck.unlock(); } void TxLookup::unwind_impl(RWTxn& txn, BlockNum from, BlockNum to) { std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kUnwind; loading_.store(false); collector_ = std::make_unique(etl_settings_); current_source_ = std::string(table::kBlockBodies.name); current_target_.clear(); current_key_.clear(); log_lck.unlock(); // Into etl collector collect_transaction_hashes_from_canonical_bodies(txn, from, to, /*for_deletion=*/true); log_lck.lock(); loading_.store(true); current_target_ = std::string(table::kTxLookup.name); current_key_.clear(); log_lck.unlock(); auto target = txn.rw_cursor_dup_sort(table::kTxLookup); // note: not a multi-value table collector_->load(*target, nullptr, MDBX_put_flags_t::MDBX_UPSERT); log_lck.lock(); loading_.store(false); current_source_.clear(); current_target_.clear(); current_key_.clear(); collector_.reset(); log_lck.unlock(); } void TxLookup::prune_impl(RWTxn& txn, BlockNum from, BlockNum to) { const MapConfig source_config{table::kBlockBodies}; std::unique_lock log_lck(sl_mutex_); operation_ = OperationType::kPrune; loading_.store(false); collector_ = std::make_unique(etl_settings_); current_source_ = std::string(source_config.name); current_target_.clear(); current_key_.clear(); log_lck.unlock(); // Into etl collector collect_transaction_hashes_from_canonical_bodies(txn, from, to, /*for_deletion=*/true); log_lck.lock(); loading_.store(true); current_target_ = std::string(table::kTxLookup.name); current_key_.clear(); log_lck.unlock(); auto target = txn.rw_cursor_dup_sort(table::kTxLookup); // note: not a multi-value table collector_->load(*target, nullptr, MDBX_put_flags_t::MDBX_UPSERT); log_lck.lock(); loading_.store(false); current_source_.clear(); current_target_.clear(); current_key_.clear(); collector_.reset(); log_lck.unlock(); } void TxLookup::collect_transaction_hashes_from_canonical_bodies(RWTxn& txn, const BlockNum from, const BlockNum to, const bool for_deletion) { using namespace std::chrono_literals; auto log_time{std::chrono::steady_clock::now()}; DataModel data_model = data_model_factory_(txn); BlockNum target_block_num{std::max(from, to)}; BlockNum start_block_num{std::min(from, to) + 1}; Bytes etl_value{}; for (BlockNum current_block_num = start_block_num; current_block_num <= target_block_num; ++current_block_num) { auto current_hash = read_canonical_header_hash(txn, current_block_num); if (!current_hash) throw StageError(Stage::Result::kBadChainSequence, "Canonical hash at block_num " + std::to_string(current_block_num) + " not found"); std::vector rlp_encoded_txs; auto found = data_model.read_rlp_transactions(current_block_num, *current_hash, rlp_encoded_txs); if (!found) throw StageError(Stage::Result::kBadChainSequence, "Canonical block at block_num " + std::to_string(current_block_num) + " not found"); // Log and abort check if (const auto now{std::chrono::steady_clock::now()}; log_time <= now) { throw_if_stopping(); std::unique_lock log_lck(sl_mutex_); current_key_ = std::to_string(current_block_num); log_time = now + 5s; } if (rlp_encoded_txs.empty()) continue; // The same loop is used for forward and for unwind // In the latter two records must be deleted hence we set etl_value only if deletion is not required if (!for_deletion) { Bytes block_num_as_bytes(sizeof(BlockNum), '\0'); endian::store_big_u64(block_num_as_bytes.data(), current_block_num); etl_value.assign(zeroless_view(block_num_as_bytes)); } for (auto& rlp_encoded_tx : rlp_encoded_txs) { // Hash transaction rlp auto transaction_hash = keccak256(rlp_encoded_tx); // see Transaction::hash() collector_->collect({Bytes(transaction_hash.bytes, kHashLength), etl_value}); } } } std::vector TxLookup::get_log_progress() { std::vector ret{"op", std::string(magic_enum::enum_name(operation_))}; std::unique_lock log_lck(sl_mutex_); if (current_source_.empty() && current_target_.empty()) { ret.insert(ret.end(), {"db", "waiting ..."}); } else { if (loading_) { current_key_ = collector_ ? abridge(collector_->get_load_key(), kAddressLength) : ""; ret.insert(ret.end(), {"from", "etl", "to", current_target_, "key", current_key_}); } else { ret.insert(ret.end(), {"from", current_source_, "to", "etl", "key", current_key_}); } } return ret; } void TxLookup::reset_log_progress() { std::unique_lock log_lck(sl_mutex_); loading_ = false; current_source_.clear(); current_target_.clear(); current_key_.clear(); } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_tx_lookup.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::stagedsync { class TxLookup : public Stage { public: TxLookup( SyncContext* sync_context, db::DataModelFactory data_model_factory, datastore::etl::CollectorSettings etl_settings, db::BlockAmount prune_mode_tx_index) : Stage(sync_context, db::stages::kTxLookupKey), data_model_factory_(std::move(data_model_factory)), etl_settings_(std::move(etl_settings)), prune_mode_tx_index_(prune_mode_tx_index) {} TxLookup(const TxLookup&) = delete; // not copyable TxLookup(TxLookup&&) = delete; // nor movable ~TxLookup() override = default; Stage::Result forward(db::RWTxn& txn) final; Stage::Result unwind(db::RWTxn& txn) final; Stage::Result prune(db::RWTxn& txn) final; std::vector get_log_progress() final; private: db::DataModelFactory data_model_factory_; datastore::etl::CollectorSettings etl_settings_; db::BlockAmount prune_mode_tx_index_; std::unique_ptr collector_; std::atomic_bool loading_{false}; // Whether we're in ETL loading phase std::string current_source_; // Current source of data std::string current_target_; // Current target of transformed data std::string current_key_; // Actual processing key void forward_impl(db::RWTxn& txn, BlockNum from, BlockNum to); void unwind_impl(db::RWTxn& txn, BlockNum from, BlockNum to); void prune_impl(db::RWTxn& txn, BlockNum from, BlockNum to); void reset_log_progress(); // Clears out all logging vars void collect_transaction_hashes_from_canonical_bodies(db::RWTxn& txn, BlockNum from, BlockNum to, bool for_deletion); }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages/stage_tx_lookup_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include namespace silkworm { using namespace silkworm::db; using namespace silkworm::datastore::kvdb; using namespace evmc::literals; using db::test_util::TempChainDataStore; stagedsync::TxLookup make_tx_lookup_stage( stagedsync::SyncContext* sync_context, TempChainDataStore& chain_data) { return stagedsync::TxLookup{ sync_context, chain_data.data_model_factory(), datastore::etl::CollectorSettings{chain_data.dir().temp().path(), 256_Mebi}, chain_data.prune_mode().tx_index(), }; } TEST_CASE("Stage Transaction Lookups") { const evmc::bytes32 hash_0{0x3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb_bytes32}; const evmc::bytes32 hash_1{0xb5553de315e0edf504d9150af82dafa5c4667fa618ed0a6f19c69b41166c5510_bytes32}; TempChainDataStore context; RWTxn& txn{context.rw_txn()}; txn.disable_commit(); PooledCursor canonicals(txn, table::kCanonicalHashes); PooledCursor bodies_table(txn, table::kBlockBodies); PooledCursor transactions_table(txn, table::kBlockTransactions); BlockBodyForStorage block; auto transactions{test::sample_transactions()}; block.base_txn_id = 1; block.txn_count = 1 + 2; // + 2: 2 system txs (1 at the beginning and 1 at the end) // --------------------------------------- // Push first block // --------------------------------------- Bytes tx_rlp{}; rlp::encode(tx_rlp, transactions[0]); auto tx_hash_1{keccak256(tx_rlp)}; transactions_table.upsert(to_slice(block_key(block.base_txn_id + 1)), to_slice(tx_rlp)); bodies_table.upsert(to_slice(block_key(1, hash_0.bytes)), to_slice(block.encode())); REQUIRE_NOTHROW(write_canonical_header_hash(txn, hash_0.bytes, 1)); // --------------------------------------- // Push second block // --------------------------------------- block.base_txn_id += block.txn_count; rlp::encode(tx_rlp, transactions[1]); auto tx_hash_2{keccak256(tx_rlp)}; transactions_table.upsert(to_slice(block_key(block.base_txn_id + 1)), to_slice(tx_rlp)); bodies_table.upsert(to_slice(block_key(2, hash_1.bytes)), to_slice(block.encode())); REQUIRE_NOTHROW(write_canonical_header_hash(txn, hash_1.bytes, 2)); stages::write_stage_progress(txn, stages::kBlockBodiesKey, 2); stages::write_stage_progress(txn, stages::kBlockHashesKey, 2); stages::write_stage_progress(txn, stages::kExecutionKey, 2); SECTION("Forward checks and unwind") { // Execute stage forward stagedsync::SyncContext sync_context{}; stagedsync::TxLookup stage_tx_lookup = make_tx_lookup_stage(&sync_context, context); REQUIRE(stage_tx_lookup.forward(txn) == stagedsync::Stage::Result::kSuccess); PooledCursor lookup_table(txn, table::kTxLookup); REQUIRE(lookup_table.size() == 2); // Must be two transactions indexed // Retrieve block numbers associated with hashes auto lookup_data{lookup_table.find(to_slice(tx_hash_1.bytes), false)}; REQUIRE(lookup_data.done); REQUIRE(!lookup_data.value.empty()); BlockNum lookup_data_block_num{0}; REQUIRE(endian::from_big_compact(from_slice(lookup_data.value), lookup_data_block_num)); REQUIRE(lookup_data_block_num == 1u); lookup_data = lookup_table.find(to_slice(tx_hash_2.bytes), false); REQUIRE(lookup_data.done); REQUIRE(!lookup_data.value.empty()); REQUIRE(endian::from_big_compact(from_slice(lookup_data.value), lookup_data_block_num)); REQUIRE(lookup_data_block_num == 2u); // Execute stage unwind to block 1 sync_context.unwind_point.emplace(1); REQUIRE(stage_tx_lookup.unwind(txn) == stagedsync::Stage::Result::kSuccess); lookup_table.bind(txn, table::kTxLookup); // Needed due to commit // Block 1 should be still there lookup_data = lookup_table.find(to_slice(tx_hash_1.bytes), false); REQUIRE(lookup_data.done); REQUIRE(!lookup_data.value.empty()); REQUIRE(endian::from_big_compact(from_slice(lookup_data.value), lookup_data_block_num)); REQUIRE(lookup_data_block_num == 1u); // Block 2 must be absent due to unwind REQUIRE_THROWS(lookup_table.find(to_slice(tx_hash_2.bytes), true)); } SECTION("Prune") { // Prune from second block, so we delete block 1 // Alter node settings pruning PruneDistance older_history, older_receipts, older_senders, older_tx_index, older_call_traces; PruneThreshold before_history, before_receipts, before_senders, before_tx_index, before_call_traces; before_tx_index.emplace(2); // Will delete any transaction before block 2 context.set_prune_mode( parse_prune_mode("t", older_history, older_receipts, older_senders, older_tx_index, older_call_traces, before_history, before_receipts, before_senders, before_tx_index, before_call_traces)); REQUIRE(context.prune_mode().tx_index().enabled()); REQUIRE(context.prune_mode().tx_index().value_from_head(2) == 1); // Execute stage forward stagedsync::SyncContext sync_context{}; stagedsync::TxLookup stage_tx_lookup = make_tx_lookup_stage(&sync_context, context); REQUIRE(stage_tx_lookup.forward(txn) == stagedsync::Stage::Result::kSuccess); // Only leave block 2 alive REQUIRE(stage_tx_lookup.prune(txn) == stagedsync::Stage::Result::kSuccess); PooledCursor lookup_table(txn, table::kTxLookup); REQUIRE(lookup_table.size() == 1); // Block 1 should NOT be there auto lookup_data{lookup_table.find(to_slice(tx_hash_1.bytes), false)}; REQUIRE(lookup_data.done == false); // Block 2 should still be there lookup_data = lookup_table.find(to_slice(tx_hash_2.bytes), false); REQUIRE(lookup_data.done); REQUIRE(!lookup_data.value.empty()); BlockNum lookup_data_block_num{0}; REQUIRE(endian::from_big_compact(from_slice(lookup_data.value), lookup_data_block_num)); REQUIRE(lookup_data_block_num == 2u); } } } // namespace silkworm ================================================ FILE: silkworm/node/stagedsync/stages_factory_impl.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stages_factory_impl.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::stagedsync { using namespace db::stages; StageContainer StagesFactoryImpl::make(SyncContext& sync_context) const { SyncContext* sync_context_ptr = &sync_context; StageContainer stages; stages.emplace(kHeadersKey, std::make_unique(sync_context_ptr, data_model_factory_)); stages.emplace(kBlockBodiesKey, bodies_stage_factory_(sync_context_ptr)); stages.emplace(kBlockHashesKey, std::make_unique(sync_context_ptr, settings_.etl())); stages.emplace(kSendersKey, std::make_unique(sync_context_ptr, data_model_factory_, *settings_.chain_config, settings_.batch_size, settings_.etl(), settings_.prune_mode.senders())); stages.emplace(kExecutionKey, std::make_unique(sync_context_ptr, data_model_factory_, *settings_.chain_config, settings_.batch_size, settings_.prune_mode)); stages.emplace(kHashStateKey, std::make_unique(sync_context_ptr, settings_.etl())); stages.emplace(kIntermediateHashesKey, std::make_unique(sync_context_ptr, data_model_factory_, settings_.etl())); stages.emplace(kHistoryIndexKey, std::make_unique(sync_context_ptr, settings_.batch_size, settings_.etl(), settings_.prune_mode.history())); stages.emplace(kLogIndexKey, std::make_unique(sync_context_ptr, settings_.batch_size, settings_.etl(), settings_.prune_mode.history())); stages.emplace(kCallTracesKey, std::make_unique(sync_context_ptr, settings_.batch_size, settings_.etl(), settings_.prune_mode.call_traces())); stages.emplace(kTxLookupKey, std::make_unique(sync_context_ptr, data_model_factory_, settings_.etl(), settings_.prune_mode.tx_index())); stages.emplace(kTriggersStageKey, std::make_unique(sync_context_ptr)); stages.emplace(kFinishKey, std::make_unique(sync_context_ptr, settings_.build_info.build_description)); return stages; } StageContainerFactory StagesFactoryImpl::to_factory(StagesFactoryImpl instance) { return [instance = std::move(instance)](SyncContext& sync_context) -> StageContainer { return instance.make(sync_context); }; } } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages_factory_impl.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "execution_pipeline.hpp" #include "stages/stage_bodies_factory.hpp" namespace silkworm::stagedsync { class StagesFactoryImpl { public: StagesFactoryImpl( const NodeSettings& settings, db::DataModelFactory data_model_factory, BodiesStageFactory bodies_stage_factory) : settings_{settings}, data_model_factory_{std::move(data_model_factory)}, bodies_stage_factory_{std::move(bodies_stage_factory)} {} static StageContainerFactory to_factory(StagesFactoryImpl instance); private: StageContainer make(SyncContext& sync_context) const; const NodeSettings& settings_; db::DataModelFactory data_model_factory_; BodiesStageFactory bodies_stage_factory_; }; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/stages_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::db; using namespace silkworm::datastore::kvdb; using namespace evmc::literals; using silkworm::db::state::AccountCodec; static ethash::hash256 keccak256(const evmc::address& address) { return silkworm::keccak256(address.bytes); } static stagedsync::Execution make_execution_stage( stagedsync::SyncContext* sync_context, const NodeSettings& node_settings, db::DataModelFactory data_model_factory) { return stagedsync::Execution{ sync_context, std::move(data_model_factory), *node_settings.chain_config, node_settings.batch_size, node_settings.prune_mode, }; } static stagedsync::CallTraceIndex make_call_traces_stage( stagedsync::SyncContext* sync_context, const NodeSettings& node_settings) { return stagedsync::CallTraceIndex{ sync_context, node_settings.batch_size, node_settings.etl(), node_settings.prune_mode.call_traces(), }; } TEST_CASE("Sync Stages") { TemporaryDirectory tmp_dir; NodeSettings node_settings{}; node_settings.data_directory = std::make_unique(tmp_dir.path()); node_settings.data_directory->deploy(); node_settings.chaindata_env_config.path = node_settings.data_directory->chaindata().path().string(); node_settings.chaindata_env_config.max_size = 1_Gibi; // Small enough to fit in memory node_settings.chaindata_env_config.growth_size = 10_Mebi; // Small increases node_settings.chaindata_env_config.in_memory = true; node_settings.chaindata_env_config.create = true; node_settings.chaindata_env_config.exclusive = true; node_settings.prune_mode = parse_prune_mode("", std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt); db::DataStore data_store{ node_settings.chaindata_env_config, node_settings.data_directory->snapshots().path(), }; auto txn = data_store.chaindata().access_rw().start_rw_tx(); table::check_or_create_chaindata_tables(txn); txn.commit_and_renew(); const auto initial_tx_sequence{read_map_sequence(txn, table::kBlockTransactions.name)}; REQUIRE(initial_tx_sequence == 0); // no txs at start auto source_data{read_genesis_data(node_settings.network_id)}; auto genesis_json = nlohmann::json::parse(source_data, nullptr, /* allow_exceptions = */ false); initialize_genesis(txn, genesis_json, /*allow_exceptions=*/true); txn.commit_and_renew(); node_settings.chain_config = read_chain_config(txn); const auto tx_sequence_after_genesis{read_map_sequence(txn, table::kBlockTransactions.name)}; REQUIRE(tx_sequence_after_genesis == 2); // 2 system txs for genesis db::DataModelFactory data_model_factory{data_store.ref()}; SECTION("BlockHashes") { SECTION("Forward/Unwind/Prune args validation") { stagedsync::SyncContext sync_context{}; stagedsync::BlockHashes stage(&sync_context, node_settings.etl()); // (previous_progress == headers_progress == 0) REQUIRE(stage.forward(txn) == stagedsync::Stage::Result::kSuccess); REQUIRE(stage.unwind(txn) == stagedsync::Stage::Result::kSuccess); // (previous_progress > headers_progress) stage.update_progress(txn, 10); REQUIRE(stage.forward(txn) == stagedsync::Stage::Result::kInvalidProgress); } SECTION("Forward and Unwind") { std::vector block_hashes = { 0x3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1cb_bytes32, 0xb5553de315e0edf504d9150af82dafa5c4667fa618ed0a6f19c69b41166c5510_bytes32, 0x0b42b6393c1f53060fe3ddbfcd7aadcca894465a5a438f69c87d790b2299b9b2_bytes32}; PooledCursor canonical_table(txn, table::kCanonicalHashes); BlockNum block_num{1}; for (const auto& hash : block_hashes) { Bytes block_key{db::block_key(block_num++)}; canonical_table.insert(to_slice(block_key), to_slice(hash)); } stages::write_stage_progress(txn, stages::kHeadersKey, 3); REQUIRE_NOTHROW(txn.commit_and_renew()); stagedsync::SyncContext sync_context{}; stagedsync::BlockHashes stage(&sync_context, node_settings.etl()); // Forward auto stage_result{stage.forward(txn)}; REQUIRE(stage_result == stagedsync::Stage::Result::kSuccess); txn.commit_and_renew(); { // Verify written data is consistent PooledCursor target_table{txn, table::kHeaderNumbers}; REQUIRE(txn->get_map_stat(target_table.map()).ms_entries == block_hashes.size() + 1); // +1 cause block 0 is genesis std::vector> written_data{}; auto walk_func = [&written_data](ByteView key, ByteView value) { auto written_block_num{endian::load_big_u64(value.data())}; auto written_hash{to_bytes32(key)}; written_data.emplace_back(written_hash, written_block_num); }; cursor_for_each(target_table, walk_func); REQUIRE(written_data.size() == block_hashes.size() + 1); for (const auto& [written_hash, written_block_num] : written_data) { REQUIRE(written_block_num < block_hashes.size() + 1); if (written_block_num) { REQUIRE(written_hash == block_hashes.at(written_block_num - 1)); } } } // Unwind sync_context.unwind_point.emplace(1); stage_result = stage.unwind(txn); REQUIRE(stage_result == stagedsync::Stage::Result::kSuccess); { // Verify written data is consistent PooledCursor target_table(txn, table::kHeaderNumbers); REQUIRE(txn->get_map_stat(target_table.map()).ms_entries == 4); REQUIRE(target_table.seek(to_slice(block_hashes.back()))); } } } SECTION("Senders") { auto sample_transactions{test::sample_transactions()}; REQUIRE(!sample_transactions.empty()); auto sample_receipts{test::sample_receipts()}; REQUIRE(!sample_receipts.empty()); Block block{}; block.header.gas_limit = 5'000'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& dest, const Receipt& r) { rlp::encode(dest, r); }; block.header.receipts_root = trie::root_hash(std::vector{sample_receipts[0]}, kEncoder); block.transactions.resize(1); block.transactions[0] = sample_transactions[0]; // First block - 1 transaction Block b1 = block; b1.header.number = 1; REQUIRE_NOTHROW(write_header(txn, b1.header)); const auto b1_hash = b1.header.hash(); REQUIRE_NOTHROW(write_body(txn, b1, b1_hash, b1.header.number)); const auto tx_sequence_after_block1{read_map_sequence(txn, table::kBlockTransactions.name)}; REQUIRE(tx_sequence_after_block1 == 5); // 1 tx + 2 system txs for block 1 // Second block - 1 transaction Block b2 = block; b2.header.number = 2; REQUIRE_NOTHROW(write_header(txn, b2.header)); const auto b2_hash = b2.header.hash(); REQUIRE_NOTHROW(write_body(txn, b2, b2_hash, b2.header.number)); const auto tx_sequence_after_block2{read_map_sequence(txn, table::kBlockTransactions.name)}; REQUIRE(tx_sequence_after_block2 == 8); // 1 tx + 2 system txs for block 2 // Third block - 0 transactions Block b3 = block; b3.header.number = 3; b3.header.transactions_root = kEmptyRoot; b3.transactions.clear(); REQUIRE_NOTHROW(write_header(txn, b3.header)); const auto b3_hash = b3.header.hash(); REQUIRE_NOTHROW(write_body(txn, b3, b3_hash, b3.header.number)); // Write canonical hashes REQUIRE_NOTHROW(write_canonical_header_hash(txn, b1_hash.bytes, 1)); REQUIRE_NOTHROW(write_canonical_header_hash(txn, b2_hash.bytes, 2)); REQUIRE_NOTHROW(write_canonical_header_hash(txn, b3_hash.bytes, 3)); // Update progresses REQUIRE_NOTHROW(stages::write_stage_progress(txn, stages::kBlockBodiesKey, 3)); REQUIRE_NOTHROW(stages::write_stage_progress(txn, stages::kBlockHashesKey, 3)); // Commit REQUIRE_NOTHROW(txn.commit_and_renew()); // Verify sequence for transactions has been incremented properly const auto last_tx_sequence{read_map_sequence(txn, table::kBlockTransactions.name)}; REQUIRE(last_tx_sequence == 10); // 2 system txs for block 3 // Prepare stage stagedsync::SyncContext sync_context{}; stagedsync::Senders stage{ &sync_context, data_model_factory, *node_settings.chain_config, node_settings.batch_size, node_settings.etl(), node_settings.prune_mode.senders(), }; // Insert a martian stage progress stage.update_progress(txn, 5); auto stage_result = stage.forward(txn); REQUIRE(stage_result != stagedsync::Stage::Result::kSuccess); // Check forward works stage.update_progress(txn, 0); stage_result = stage.forward(txn); REQUIRE(stage_result == stagedsync::Stage::Result::kSuccess); REQUIRE(stage.get_progress(txn) == 3); // Executing once again with no changes should do nothing stage_result = stage.forward(txn); REQUIRE(stage_result == stagedsync::Stage::Result::kSuccess); REQUIRE(stage.get_progress(txn) == 3); REQUIRE_NOTHROW(txn.commit_and_renew()); constexpr evmc::address kExpectedSender{0xc15eb501c014515ad0ecb4ecbf75cc597110b060_address}; { auto senders_map{txn->open_map(table::kSenders.name_str())}; REQUIRE(txn->get_map_stat(senders_map).ms_entries == 2); auto written_senders{read_senders(txn, 1, b1_hash.bytes)}; REQUIRE(written_senders.size() == 1); REQUIRE(written_senders[0] == kExpectedSender); written_senders = read_senders(txn, 2, b2_hash.bytes); REQUIRE(written_senders.size() == 1); REQUIRE(written_senders[0] == kExpectedSender); written_senders = read_senders(txn, 3, b3_hash.bytes); REQUIRE(written_senders.empty()); } // Check unwind works sync_context.unwind_point.emplace(1); stage_result = stage.unwind(txn); REQUIRE(stage_result == stagedsync::Stage::Result::kSuccess); { auto senders_map{txn->open_map(table::kSenders.name_str())}; REQUIRE(txn->get_map_stat(senders_map).ms_entries == 1); auto written_senders{read_senders(txn, 1, b1_hash.bytes)}; REQUIRE(written_senders.size() == 1); REQUIRE(written_senders[0] == kExpectedSender); written_senders = read_senders(txn, 2, b2_hash.bytes); REQUIRE(written_senders.empty()); written_senders = read_senders(txn, 3, b3_hash.bytes); REQUIRE(written_senders.empty()); } // Check prune works // Override prune mode and issue pruning stage.set_prune_mode_senders(BlockAmount(BlockAmount::Type::kBefore, 2)); stage_result = stage.prune(txn); REQUIRE(stage_result == stagedsync::Stage::Result::kSuccess); auto written_senders{read_senders(txn, 1, b1_hash.bytes)}; REQUIRE(written_senders.empty()); } // TODO(canepat) refactor these tests to use Execution stage instead of mimicking it SECTION("Execution and HashState") { using namespace magic_enum; using StageResult = stagedsync::Stage::Result; // --------------------------------------- // Prepare // --------------------------------------- uint64_t block_num{1}; const evmc::address miner{0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c_address}; Block block{}; block.header.number = block_num; block.header.beneficiary = miner; block.header.gas_limit = 100'000; block.header.gas_used = 63'820; static constexpr auto kEncoder = [](Bytes& to, const Receipt& r) { rlp::encode(to, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); // This contract initially sets its 0th storage to 0x2a and its 1st storage to 0x01c9. // When called, it updates its 0th storage to the input provided. Bytes contract_code{*from_hex("600035600055")}; Bytes deployment_code{*from_hex("602a6000556101c960015560068060166000396000f3") + contract_code}; block.transactions.resize(1); block.transactions[0].data = deployment_code; block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; auto sender{0xb685342b8c54347aad148e1f22eff3eb3eb29391_address}; block.transactions[0].r = 1; // dummy block.transactions[0].s = 1; // dummy block.transactions[0].set_sender(sender); Buffer buffer{txn, std::make_unique(data_model_factory(txn))}; Account sender_account{}; sender_account.balance = kEther; buffer.update_account(sender, std::nullopt, sender_account); // --------------------------------------- // Execute first block // --------------------------------------- std::vector block_receipts; auto actual_validation_result = execute_block(block, buffer, node_settings.chain_config.value(), block_receipts); // We must insert receipts to mimic the behaviour of Execution stage buffer.insert_receipts(block_num, block_receipts); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 REQUIRE((enum_name(actual_validation_result) == enum_name(ValidationResult::kOk))); auto contract_address{create_address(sender, /*nonce=*/0)}; // --------------------------------------- // Execute second block // --------------------------------------- auto new_val{0x000000000000000000000000000000000000000000000000000000000000003e_bytes32}; block_num = 2; block.header.number = block_num; block.header.gas_used = 26'201; receipts[0].cumulative_gas_used = block.header.gas_used; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions[0].nonce = 1; block.transactions[0].value = 1000; block.transactions[0].to = contract_address; block.transactions[0].data = ByteView(new_val); block_receipts.clear(); actual_validation_result = execute_block(block, buffer, node_settings.chain_config.value(), block_receipts); // We must insert receipts to mimic the behaviour of Execution stage buffer.insert_receipts(block_num, block_receipts); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 REQUIRE((enum_name(actual_validation_result) == enum_name(ValidationResult::kOk))); // --------------------------------------- // Execute third block // --------------------------------------- new_val = 0x000000000000000000000000000000000000000000000000000000000000003b_bytes32; block_num = 3; block.header.number = block_num; block.transactions[0].nonce = 2; block.transactions[0].value = 1000; block.transactions[0].to = contract_address; block.transactions[0].data = ByteView{new_val}; block_receipts.clear(); actual_validation_result = execute_block(block, buffer, node_settings.chain_config.value(), block_receipts); // We must insert receipts to mimic the behaviour of Execution stage buffer.insert_receipts(block_num, block_receipts); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 REQUIRE((enum_name(actual_validation_result) == enum_name(ValidationResult::kOk))); REQUIRE_NOTHROW(buffer.write_to_db()); REQUIRE_NOTHROW(stages::write_stage_progress(txn, stages::kExecutionKey, 3)); REQUIRE_NOTHROW(txn.commit_and_renew()); // Check state after 3rd block in database auto plain_state_cursor = txn.ro_cursor(table::kPlainState); REQUIRE(plain_state_cursor->seek(to_slice(sender))); auto current_record = plain_state_cursor->current(/*throw_notfound=*/false); REQUIRE(current_record); REQUIRE(from_slice(current_record.key) == ByteView{sender.bytes}); auto decoded_account = AccountCodec::from_encoded_storage(from_slice(current_record.value)); REQUIRE(decoded_account); REQUIRE(decoded_account->nonce == 3); auto receipts_cursor = txn.ro_cursor(table::kBlockReceipts); REQUIRE(receipts_cursor->seek(to_slice(block_key(3)))); SECTION("Execution Unwind") { // --------------------------------------- // Unwind 3rd block and checks if state is second block // --------------------------------------- stagedsync::SyncContext sync_context{}; sync_context.unwind_point.emplace(2); stagedsync::Execution stage = make_execution_stage(&sync_context, node_settings, data_model_factory); REQUIRE(stage.unwind(txn) == stagedsync::Stage::Result::kSuccess); Buffer buffer2{txn, std::make_unique(data_model_factory(txn))}; std::optional contract_account{buffer2.read_account(contract_address)}; REQUIRE(contract_account.has_value()); CHECK(contract_account.value().balance == intx::uint256{1000}); // 2000 - 1000 std::optional current_sender{buffer2.read_account(sender)}; REQUIRE(current_sender.has_value()); CHECK(intx::to_string(current_sender.value().balance) == std::to_string(kEther - 1000)); CHECK(current_sender.value().nonce == 2); // Nonce at 2nd block ethash::hash256 code_hash{keccak256(contract_code)}; CHECK(to_hex(contract_account->code_hash) == to_hex(code_hash.bytes)); evmc::bytes32 storage_key0{}; evmc::bytes32 storage0{buffer2.read_storage(contract_address, kDefaultIncarnation, storage_key0)}; CHECK(storage0 == 0x000000000000000000000000000000000000000000000000000000000000003e_bytes32); // Check state after unwind of the 3rd block in database plain_state_cursor = txn.ro_cursor(table::kPlainState); REQUIRE(plain_state_cursor->seek(to_slice(sender))); current_record = plain_state_cursor->current(/*throw_notfound=*/false); REQUIRE(current_record); REQUIRE(from_slice(current_record.key) == ByteView{sender.bytes}); decoded_account = AccountCodec::from_encoded_storage(from_slice(current_record.value)); REQUIRE(decoded_account); REQUIRE(decoded_account->nonce == 2); receipts_cursor = txn.ro_cursor(table::kBlockReceipts); REQUIRE(receipts_cursor->seek(to_slice(block_key(2)))); } SECTION("Execution failure and unwind") { // Execute INVALID 4th block block_num = 4; block.header.number = block_num; block.transactions[0].nonce = 2; // <- invalid, should be 3 block.transactions[0].value = 1000; block.transactions[0].to = contract_address; block_receipts.clear(); actual_validation_result = execute_block(block, buffer, node_settings.chain_config.value(), block_receipts); // Execution stage *must* flush state+progress updates and commit even in case of kInvalidBlock error REQUIRE_NOTHROW(buffer.insert_receipts(block_num, block_receipts)); REQUIRE_NOTHROW(buffer.write_to_db()); REQUIRE_NOTHROW(stages::write_stage_progress(txn, stages::kExecutionKey, 4)); // this was missing after PR #1511 txn.commit_and_renew(); // this was missing after PR #1511 // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 REQUIRE((enum_name(actual_validation_result) == enum_name(ValidationResult::kWrongNonce))); // Unwind 4th block and checks if state corresponds to 3rd block stagedsync::SyncContext sync_context{}; sync_context.unwind_point.emplace(3); stagedsync::Execution stage = make_execution_stage(&sync_context, node_settings, data_model_factory); REQUIRE(stage.unwind(txn) == stagedsync::Stage::Result::kSuccess); plain_state_cursor = txn.ro_cursor(table::kPlainState); REQUIRE(plain_state_cursor->seek(to_slice(sender))); current_record = plain_state_cursor->current(/*throw_notfound=*/false); REQUIRE(current_record); REQUIRE(from_slice(current_record.key) == ByteView{sender.bytes}); decoded_account = AccountCodec::from_encoded_storage(from_slice(current_record.value)); REQUIRE(decoded_account); REQUIRE(decoded_account->nonce == 3); receipts_cursor = txn.ro_cursor(table::kBlockReceipts); REQUIRE(receipts_cursor->seek(to_slice(block_key(3)))); REQUIRE(!receipts_cursor->seek(to_slice(block_key(4)))); // <- this fails after PR #1511 } SECTION("Execution Prune Default") { SILK_INFO << "Pruning with " << node_settings.prune_mode.to_string(); stagedsync::SyncContext sync_context{}; stagedsync::Execution stage = make_execution_stage(&sync_context, node_settings, data_model_factory); REQUIRE(stage.prune(txn) == stagedsync::Stage::Result::kSuccess); // With default settings nothing should be pruned PooledCursor account_changeset_table(txn, table::kAccountChangeSet); auto data{account_changeset_table.to_first(false)}; REQUIRE(data.done); BlockNum expected_block_num{0}; // We have account changes from genesis auto actual_block_num = endian::load_big_u64(from_slice(data.key).data()); REQUIRE(actual_block_num == expected_block_num); PooledCursor storage_changeset_table(txn, table::kStorageChangeSet); data = storage_changeset_table.to_first(false); REQUIRE(data.done); expected_block_num = 1; // First storage change is at block 1 actual_block_num = endian::load_big_u64(from_slice(data.key).data()); REQUIRE(actual_block_num == expected_block_num); // There is no pruning setting enabled hence no pruning occurred REQUIRE(stages::read_stage_prune_progress(txn, stages::kExecutionKey) == 0); } SECTION("Execution Prune History") { // Override prune mode and issue pruning node_settings.prune_mode = parse_prune_mode("", std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, 2, std::nullopt, std::nullopt, std::nullopt, std::nullopt); SILK_INFO << "Pruning with " << node_settings.prune_mode.to_string(); REQUIRE(node_settings.prune_mode.history().enabled()); stagedsync::SyncContext sync_context{}; stagedsync::Execution stage = make_execution_stage(&sync_context, node_settings, data_model_factory); REQUIRE(stage.prune(txn) == stagedsync::Stage::Result::kSuccess); PooledCursor account_changeset_table(txn, table::kAccountChangeSet); auto data{account_changeset_table.to_first(false)}; REQUIRE(data.done); BlockNum expected_block_num = 2; // We've pruned history *before* 2 so the last is 2 BlockNum actual_block_num = endian::load_big_u64(from_slice(data.key).data()); REQUIRE(actual_block_num == expected_block_num); REQUIRE(stages::read_stage_prune_progress(txn, stages::kExecutionKey) == 3); } SECTION("HashState") { stagedsync::SyncContext sync_context{}; stagedsync::HashState stage{&sync_context, node_settings.etl()}; auto actual_stage_result = stage.forward(txn); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 REQUIRE((enum_name(actual_stage_result) == enum_name(StageResult::kSuccess))); REQUIRE(stages::read_stage_progress(txn, stages::kHashStateKey) == 3); // --------------------------------------- // Check hashed account // --------------------------------------- PooledCursor hashed_accounts_table(txn, table::kHashedAccounts); auto hashed_sender{keccak256(sender)}; REQUIRE(hashed_accounts_table.seek(to_slice(hashed_sender.bytes))); { auto account_encoded{from_slice(hashed_accounts_table.current().value)}; auto account = AccountCodec::from_encoded_storage(account_encoded); CHECK(account->nonce == 3); CHECK(account->balance < kEther); } // --------------------------------------- // Check hashed storage // --------------------------------------- PooledCursor hashed_storage_table(txn, table::kHashedStorage); auto hashed_contract{keccak256(contract_address)}; Bytes storage_key{storage_prefix(hashed_contract.bytes, kDefaultIncarnation)}; REQUIRE(hashed_storage_table.find(to_slice(storage_key))); REQUIRE(hashed_storage_table.count_multivalue() == 2); // location 0 auto hashed_loc0{keccak256((0x0000000000000000000000000000000000000000000000000000000000000000_bytes32).bytes)}; hashed_storage_table.to_current_first_multi(); mdbx::slice db_val{hashed_storage_table.current().value}; REQUIRE(db_val.starts_with(to_slice(hashed_loc0.bytes))); ByteView value{from_slice(db_val).substr(kHashLength)}; REQUIRE(to_hex(value) == to_hex(zeroless_view(new_val.bytes))); // location 1 auto hashed_loc1{keccak256((0x0000000000000000000000000000000000000000000000000000000000000001_bytes32).bytes)}; hashed_storage_table.to_current_next_multi(); db_val = hashed_storage_table.current().value; CHECK(db_val.starts_with(to_slice(hashed_loc1.bytes))); value = from_slice(db_val).substr(kHashLength); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 CHECK((to_hex(value) == "01c9")); // Unwind the stage to block 1 (i.e. block 1 *is* applied) BlockNum unwind_to{1}; sync_context.unwind_point.emplace(unwind_to); actual_stage_result = stage.unwind(txn); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 REQUIRE((enum_name(actual_stage_result) == enum_name(StageResult::kSuccess))); hashed_accounts_table.bind(txn, table::kHashedAccounts); REQUIRE(hashed_accounts_table.seek(to_slice(hashed_sender.bytes))); { auto account_encoded{from_slice(hashed_accounts_table.current().value)}; auto account = AccountCodec::from_encoded_storage(account_encoded); CHECK(account->nonce == 1); CHECK(account->balance == kEther); CHECK(stages::read_stage_progress(txn, stages::kHashStateKey) == unwind_to); } } } SECTION("Execution and CallTraceIndex") { using namespace magic_enum; using StageResult = stagedsync::Stage::Result; // Prepare block 1 const evmc::address miner{0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c_address}; const evmc::address sender{0x9b9e32061f64f6c3f570a63b97a178d84e961db1_address}; const evmc::address receiver{miner}; Block block{}; block.header.number = 1; block.header.beneficiary = receiver; block.header.gas_limit = 100'000; block.header.gas_used = 21'000; static constexpr auto kEncoder = [](Bytes& to, const Receipt& r) { rlp::encode(to, r); }; std::vector receipts{ {TransactionType::kLegacy, true, block.header.gas_used, {}, {}}, }; block.header.receipts_root = trie::root_hash(receipts, kEncoder); block.transactions.resize(1); block.transactions[0].gas_limit = block.header.gas_limit; block.transactions[0].type = TransactionType::kLegacy; block.transactions[0].to = miner; static_cast(block.transactions[0].set_v(27)); block.transactions[0].r = intx::from_string("0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353"); block.transactions[0].s = intx::from_string("0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804"); block.transactions[0].value = 0; write_header(txn, block.header, /*with_header_numbers=*/true); write_body(txn, block, block.header.hash(), block.header.number); write_canonical_header_hash(txn, block.header.hash().bytes, block.header.number); // Stage Execution up to block 1 REQUIRE_NOTHROW(stages::write_stage_progress(txn, stages::kSendersKey, 1)); stagedsync::SyncContext sync_context{}; sync_context.target_block_num = 1; stagedsync::Execution stage_execution = make_execution_stage(&sync_context, node_settings, data_model_factory); CHECK(stage_execution.forward(txn) == StageResult::kSuccess); // Post-condition: CallTraceSet table { auto call_traces_cursor{txn.ro_cursor(table::kCallTraceSet)}; REQUIRE(call_traces_cursor->size() == 2); const CursorResult call_traces_record1 = call_traces_cursor->to_next(/*throw_notfound=*/false); REQUIRE(call_traces_record1.done); const CursorResult call_traces_record2 = call_traces_cursor->to_next(/*throw_notfound=*/false); REQUIRE(call_traces_record2.done); auto check_call_trace_record = [&](const CursorResult& record, const evmc::address& address, bool is_sender, bool is_receiver) { const auto block_num = endian::load_big_u64(static_cast(record.key.data())); CHECK(block_num == 1); const ByteView value{static_cast(record.value.data()), record.value.length()}; REQUIRE(value.size() == kAddressLength + 1); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 CHECK((value.substr(0, kAddressLength) == address)); CHECK(bool(value[kAddressLength] & 1) == is_sender); CHECK(bool(value[kAddressLength] & 2) == is_receiver); }; check_call_trace_record(call_traces_record1, receiver, /*.from=*/false, /*.to=*/true); check_call_trace_record(call_traces_record2, sender, /*.from=*/true, /*.to=*/false); } // Stage CallTraceIndex up to block 1 stagedsync::CallTraceIndex stage_call_traces = make_call_traces_stage(&sync_context, node_settings); REQUIRE(stages::read_stage_progress(txn, stages::kCallTracesKey) == 0); const auto forward_result{stage_call_traces.forward(txn)}; // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 CHECK((enum_name(forward_result) == enum_name(StageResult::kSuccess))); CHECK(stages::read_stage_progress(txn, stages::kCallTracesKey) == 1); // Post-condition: CallFromIndex table { auto call_from_cursor{txn.ro_cursor(table::kCallFromIndex)}; REQUIRE(call_from_cursor->size() == 1); const auto call_from_record{call_from_cursor->to_next(/*throw_notfound=*/false)}; REQUIRE(call_from_record.done); const auto address_data{from_slice(call_from_record.key)}; REQUIRE(address_data.size() == kAddressLength + sizeof(uint64_t)); CHECK(bytes_to_address(address_data.substr(0, kAddressLength)) == sender); const auto bitmap_encoded{byte_view_to_string_view(from_slice(call_from_record.value))}; const auto bitmap{bitmap::parse(bitmap_encoded)}; CHECK(bitmap::seek(bitmap, 1)); } // Post-condition: CallToIndex table { auto call_to_cursor{txn.ro_cursor(table::kCallToIndex)}; REQUIRE(call_to_cursor->size() == 1); const auto call_to_record{call_to_cursor->to_next(/*throw_notfound=*/false)}; REQUIRE(call_to_record.done); const auto address_data{from_slice(call_to_record.key)}; REQUIRE(address_data.size() == kAddressLength + sizeof(uint64_t)); CHECK(bytes_to_address(address_data.substr(0, kAddressLength)) == receiver); const auto bitmap_encoded{byte_view_to_string_view(from_slice(call_to_record.value))}; const auto bitmap{bitmap::parse(bitmap_encoded)}; CHECK(bitmap::seek(bitmap, 1)); } // Unwind the stage down to block 0 (i.e. block 0 *is* applied) const BlockNum unwind_to{0}; sync_context.unwind_point.emplace(unwind_to); const auto unwind_result{stage_call_traces.unwind(txn)}; // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 CHECK((enum_name(unwind_result) == enum_name(StageResult::kSuccess))); CHECK(stages::read_stage_progress(txn, stages::kCallTracesKey) == unwind_to); auto call_from_cursor{txn.ro_cursor(table::kCallFromIndex)}; CHECK(call_from_cursor->empty()); auto call_to_cursor{txn.ro_cursor(table::kCallToIndex)}; CHECK(call_to_cursor->empty()); } } ================================================ FILE: silkworm/node/stagedsync/timer_factory.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::stagedsync { using TimerFactory = std::function(std::function callback)>; } // namespace silkworm::stagedsync ================================================ FILE: silkworm/node/stagedsync/types.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::execution { using BlockVector = std::vector>; struct ForkChoiceApplication { bool success{false}; // Fork choice is either successful or unsuccessful. Hash current_head; // Return latest valid hash in case of halt of execution. BlockNum current_block_num{0}; }; struct ValidChain { Hash current_head; }; struct InvalidChain { Hash latest_valid_head; std::optional bad_block; std::set bad_headers; }; struct ValidationError { Hash latest_valid_head; std::string error; }; using ValidationResult = std::variant; } // namespace silkworm::execution ================================================ FILE: silkworm/node/test_util/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(Boost REQUIRED COMPONENTS headers) find_package(GTest REQUIRED) silkworm_library( silkworm_node_test_util PUBLIC silkworm_infra silkworm_node PRIVATE silkworm_db_test_util Boost::headers glaze::glaze GTest::gmock ) ================================================ FILE: silkworm/node/test_util/dummy.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 // Empty compilation unit just to make silkworm_node_test_util build under macOS void node_test_util_dummy() {} ================================================ FILE: silkworm/node/test_util/make_stages_factory.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "make_stages_factory.hpp" #include "../stagedsync/stages/stage_bodies.hpp" #include "../stagedsync/stages_factory_impl.hpp" namespace silkworm::stagedsync::test_util { BodiesStageFactory make_bodies_stage_factory(const ChainConfig& chain_config, db::DataModelFactory data_model_factory) { return [chain_config, data_model_factory = std::move(data_model_factory)](SyncContext* sync_context) { return std::make_unique( sync_context, chain_config, data_model_factory, [] { return 0; }); }; }; StageContainerFactory make_stages_factory(const NodeSettings& node_settings, db::DataModelFactory data_model_factory) { auto bodies_stage_factory = make_bodies_stage_factory(*node_settings.chain_config, data_model_factory); return StagesFactoryImpl::to_factory({ node_settings, std::move(data_model_factory), std::move(bodies_stage_factory), }); } } // namespace silkworm::stagedsync::test_util ================================================ FILE: silkworm/node/test_util/make_stages_factory.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "../common/node_settings.hpp" #include "../stagedsync/execution_pipeline.hpp" #include "../stagedsync/stages/stage_bodies_factory.hpp" namespace silkworm::stagedsync::test_util { BodiesStageFactory make_bodies_stage_factory(const ChainConfig& chain_config, db::DataModelFactory data_model_factory); StageContainerFactory make_stages_factory(const NodeSettings& node_settings, db::DataModelFactory data_model_factory); } // namespace silkworm::stagedsync::test_util ================================================ FILE: silkworm/node/test_util/mock_execution_engine.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::execution::api { //! \brief gMock mock class for stagedsync::ExecutionEngine class MockExecutionEngine : public stagedsync::ExecutionEngine { public: static stagedsync::StageContainerFactory empty_stages_factory() { return [](stagedsync::SyncContext&) { return stagedsync::StageContainer{}; }; }; MockExecutionEngine(boost::asio::any_io_executor executor, NodeSettings& ns, datastore::kvdb::RWAccess dba) : ExecutionEngine{ std::move(executor), ns, db::DataModelFactory::null(), /* log_timer_factory = */ std::nullopt, empty_stages_factory(), std::move(dba), } {} ~MockExecutionEngine() override = default; MOCK_METHOD((void), open, (), (override)); MOCK_METHOD((void), close, (), (override)); MOCK_METHOD((void), insert_blocks, (const std::vector>&), (override)); MOCK_METHOD((Task), verify_chain, (Hash), (override)); MOCK_METHOD((bool), notify_fork_choice_update1, (Hash)); MOCK_METHOD((bool), notify_fork_choice_update2, (Hash, Hash)); MOCK_METHOD((bool), notify_fork_choice_update3, (Hash, Hash, Hash)); bool notify_fork_choice_update(Hash head_block_hash, std::optional finalized_block_hash, std::optional safe_block_hash) override { if (finalized_block_hash && safe_block_hash) { return notify_fork_choice_update3(head_block_hash, *finalized_block_hash, *safe_block_hash); } if (finalized_block_hash) { return notify_fork_choice_update2(head_block_hash, *finalized_block_hash); } return notify_fork_choice_update1(head_block_hash); } MOCK_METHOD((BlockId), last_fork_choice, (), (const, override)); MOCK_METHOD((BlockId), last_finalized_block, (), (const, override)); MOCK_METHOD((BlockId), last_safe_block, (), (const, override)); MOCK_METHOD((std::optional), get_block_num, (Hash), (const, override)); MOCK_METHOD((std::vector), get_last_headers, (uint64_t), (const, override)); MOCK_METHOD((BlockNum), block_progress, (), (const, override)); }; } // namespace silkworm::execution::api ================================================ FILE: silkworm/node/test_util/temp_chain_data_node_settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::node::test_util { inline NodeSettings make_node_settings_from_temp_chain_data(const db::test_util::TempChainData& db) { return NodeSettings{ .data_directory = std::make_unique(db.dir().path(), false), .chaindata_env_config = db.chaindata_env_config(), .chain_config = db.chain_config(), .prune_mode = db.prune_mode(), }; } } // namespace silkworm::node::test_util ================================================ FILE: silkworm/rpc/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED) find_package(Boost REQUIRED COMPONENTS headers container) find_package(gRPC REQUIRED) find_package(GTest REQUIRED) find_package(jwt-cpp REQUIRED) find_package(nlohmann_json REQUIRED) find_package(roaring REQUIRED) find_package(libdeflate REQUIRED) set(SILKWORM_RPCDAEMON_PUBLIC_LIBRARIES silkworm_db silkworm_core silkworm_interfaces asio-grpc::asio-grpc cborcpp evmone libdeflate::libdeflate_static glaze::glaze gRPC::grpc++ jwt-cpp::jwt-cpp nlohmann_json::nlohmann_json absl::btree Boost::container Boost::headers protobuf::libprotobuf intx::intx ) # cmake-format: off set(SILKWORM_RPCDAEMON_PRIVATE_LIBRARIES absl::strings cpp_base64 evmc::instructions roaring::roaring silkworm_capi_common silkworm_execution ) # cmake-format: on silkworm_library( silkworm_rpcdaemon PUBLIC ${SILKWORM_RPCDAEMON_PUBLIC_LIBRARIES} PRIVATE ${SILKWORM_RPCDAEMON_PRIVATE_LIBRARIES} ) # silkworm_rpcdaemon_cli depends on silkworm_rpcdaemon add_subdirectory(cli) # silkworm_rpcdaemon_test_util depends on silkworm_rpcdaemon add_subdirectory(test_util) target_link_libraries( silkworm_rpcdaemon_test PRIVATE silkworm_infra_test_util silkworm_rpcdaemon_test_util GTest::gmock ) ================================================ FILE: silkworm/rpc/capi/rpcdaemon.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rpcdaemon.h" #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::rpc; using namespace silkworm::capi; //! Build interface log settings for ETH JSON-RPC from their C representation static InterfaceLogSettings make_eth_ifc_log_settings(const struct SilkwormRpcInterfaceLogSettings settings) { InterfaceLogSettings eth_ifc_log_settings{.ifc_name = "eth_rpc_api"}; eth_ifc_log_settings.enabled = settings.enabled; eth_ifc_log_settings.container_folder = parse_path(settings.container_folder); eth_ifc_log_settings.max_file_size_mb = settings.max_file_size_mb; eth_ifc_log_settings.max_files = settings.max_files; eth_ifc_log_settings.dump_response = settings.dump_response; return eth_ifc_log_settings; } //! Build JSON-RPC endpoint from C settings static std::string parse_end_point(const char (&c_host)[SILKWORM_RPC_SETTINGS_HOST_SIZE], int port, std::string_view default_end_point) { auto host = std::string{c_host}; if (host.empty() && port == 0) { return std::string{default_end_point}; } const auto semicolon_position{default_end_point.find(':')}; SILKWORM_ASSERT(semicolon_position != std::string::npos); if (host.empty()) { host = default_end_point.substr(0, semicolon_position); } if (port == 0) { port = std::stoi(std::string{default_end_point.substr(semicolon_position + 1)}); } std::string eth_end_point{host + ":" + std::to_string(port)}; return eth_end_point; } //! Build list of CORS domains from their C representation static std::vector parse_cors_domains( const char (&c_cors_domains)[SILKWORM_RPC_SETTINGS_CORS_DOMAINS_MAX][SILKWORM_RPC_SETTINGS_CORS_DOMAIN_SIZE]) { std::vector cors_domains; for (const auto& c_domain : c_cors_domains) { std::string_view domain_str = c_domain; if (domain_str.empty()) break; cors_domains.emplace_back(domain_str); } return cors_domains; } //! Build whole RPC daemon settings from their C representation static DaemonSettings make_daemon_settings(SilkwormHandle handle, const struct SilkwormRpcSettings& settings) { const auto jwt_path{parse_path(settings.jwt_file_path)}; const auto& common = handle->common; return { .log_settings = common.log_settings, .eth_ifc_log_settings = make_eth_ifc_log_settings(settings.eth_if_log_settings), .context_pool_settings = common.context_pool_settings, .eth_end_point = parse_end_point(settings.eth_api_host, settings.eth_api_port, kDefaultEth1EndPoint), .engine_end_point = "", // disable end-point for Engine RPC API .eth_api_spec = std::string{settings.eth_api_spec}, .num_workers = settings.num_workers > 0 ? settings.num_workers : kDefaultNumWorkers, .cors_domain = parse_cors_domains(settings.cors_domains), .jwt_secret_file = jwt_path.empty() ? std::nullopt : std::make_optional(jwt_path.string()), .skip_protocol_check = settings.skip_internal_protocol_check, .erigon_json_rpc_compatibility = settings.erigon_json_rpc_compatibility, .use_websocket = settings.ws_enabled, .ws_compression = settings.ws_compression, .http_compression = settings.http_compression, }; } SILKWORM_EXPORT int silkworm_start_rpcdaemon(SilkwormHandle handle, MDBX_env* env, const struct SilkwormRpcSettings* settings) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } if (handle->rpcdaemon) { return SILKWORM_SERVICE_ALREADY_STARTED; } if (!env) { return SILKWORM_INVALID_MDBX_ENV; } if (!settings) { return SILKWORM_INVALID_SETTINGS; } if (!handle->db->chaindata) { handle->db->chaindata = std::make_unique( db::DataStore::make_chaindata_database(datastore::kvdb::EnvUnmanaged{env})); } db::DataStoreRef data_store = handle->db->data_store(); datastore::kvdb::ROTxnManaged ro_txn = data_store.chaindata.access_ro().start_ro_tx(); auto chain_config = db::read_chain_config(ro_txn); if (!chain_config) { return SILKWORM_INVALID_SETTINGS; } // Create the one-and-only Silkrpc daemon auto daemon_settings = make_daemon_settings(handle, *settings); handle->rpcdaemon = std::make_unique(daemon_settings, std::move(chain_config), data_store); // Check protocol version compatibility with Core Services if (!daemon_settings.skip_protocol_check) { SILK_INFO << "[Silkworm RPC] Checking protocol version compatibility with core services..."; const auto checklist = handle->rpcdaemon->run_checklist(); for (const auto& protocol_check : checklist.protocol_checklist) { SILK_INFO << protocol_check.result; } checklist.success_or_throw(); } else { SILK_TRACE << "[Silkworm RPC] Skip protocol version compatibility check with core services"; } SILK_INFO << "[Silkworm RPC] Starting ETH API at " << daemon_settings.eth_end_point; try { handle->rpcdaemon->start(); } catch (const std::exception& ex) { SILK_ERROR << "[Silkworm RPC] Cannot start RPC daemon due to: " << ex.what(); return SILKWORM_INTERNAL_ERROR; } return SILKWORM_OK; } SILKWORM_EXPORT int silkworm_stop_rpcdaemon(SilkwormHandle handle) SILKWORM_NOEXCEPT { if (!handle) { return SILKWORM_INVALID_HANDLE; } if (!handle->rpcdaemon) { return SILKWORM_OK; } try { handle->rpcdaemon->stop(); SILK_INFO << "[Silkworm RPC] Exiting..."; handle->rpcdaemon->join(); SILK_INFO << "[Silkworm RPC] Stopped"; handle->rpcdaemon.reset(); } catch (const std::exception& ex) { SILK_ERROR << "[Silkworm RPC] Cannot stop RPC daemon due to: " << ex.what(); return SILKWORM_INTERNAL_ERROR; } return SILKWORM_OK; } ================================================ FILE: silkworm/rpc/capi/rpcdaemon.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_RPCDAEMON_CAPI_H_ #define SILKWORM_RPCDAEMON_CAPI_H_ #ifdef SILKWORM_CAPI_COMPONENT #include #else #include "preamble.h" #endif #if __cplusplus extern "C" { #endif #define SILKWORM_RPC_SETTINGS_HOST_SIZE 128 #define SILKWORM_RPC_SETTINGS_API_NAMESPACE_SPEC_SIZE 256 #define SILKWORM_RPC_SETTINGS_CORS_DOMAINS_MAX 20 #define SILKWORM_RPC_SETTINGS_CORS_DOMAIN_SIZE 256 //! Silkworm RPC interface log options struct SilkwormRpcInterfaceLogSettings { bool enabled; char container_folder[SILKWORM_PATH_SIZE]; uint16_t max_file_size_mb; uint16_t max_files; bool dump_response; }; //! Silkworm RPC configuration options struct SilkwormRpcSettings { //! Configuration options for interface log of ETH JSON-RPC end-point struct SilkwormRpcInterfaceLogSettings eth_if_log_settings; //! Host address for ETH JSON-RPC end-point char eth_api_host[SILKWORM_RPC_SETTINGS_HOST_SIZE]; //! Listening port number for ETH JSON-RPC end-point uint16_t eth_api_port; //! ETH JSON-RPC namespace specification (comma-separated list of API namespaces) char eth_api_spec[SILKWORM_RPC_SETTINGS_API_NAMESPACE_SPEC_SIZE]; //! Number of threads in worker pool (for long-run tasks) uint32_t num_workers; //! Array of CORS domains char cors_domains[SILKWORM_RPC_SETTINGS_CORS_DOMAINS_MAX][SILKWORM_RPC_SETTINGS_CORS_DOMAIN_SIZE]; //! Path to the JWT file in UTF-8. char jwt_file_path[SILKWORM_PATH_SIZE]; //! Flag indicating if JSON-RPC strict compatibility w/ Erigon is supported bool erigon_json_rpc_compatibility; //! Flag indicating if WebSocket support is enabled bool ws_enabled; //! Flag indicating if compression of WebSocket messages is supported bool ws_compression; //! Flag indicating if compression of HTTP messages is supported bool http_compression; //! Flag indicating if version check on internal gRPC protocols should be skipped bool skip_internal_protocol_check; }; typedef struct MDBX_env MDBX_env; /** * \brief Start Silkworm RPC daemon. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. Must not be zero. * \param[in] env An valid MDBX environment. Must not be zero. * \param[in] settings The RPC daemon configuration settings. Must not be zero. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_start_rpcdaemon(SilkwormHandle handle, MDBX_env* env, const struct SilkwormRpcSettings* settings) SILKWORM_NOEXCEPT; /** * \brief Stop Silkworm RPC daemon and wait for its termination. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. Must not be zero. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_stop_rpcdaemon(SilkwormHandle handle) SILKWORM_NOEXCEPT; #if __cplusplus } #endif #endif // SILKWORM_RPCDAEMON_CAPI_H_ ================================================ FILE: silkworm/rpc/cli/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(absl REQUIRED) find_package(gRPC REQUIRED) find_package(Protobuf REQUIRED) add_library(silkworm_rpcdaemon_cli "rpcdaemon_options.cpp") target_link_libraries(silkworm_rpcdaemon_cli PUBLIC silkworm_rpcdaemon silkworm_infra_cli) add_executable(grpc_toolbox "grpc_toolbox.cpp") target_link_libraries(grpc_toolbox absl::flags_parse gRPC::grpc++ protobuf::libprotobuf silkworm_rpcdaemon) ================================================ FILE: silkworm/rpc/cli/grpc_toolbox.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace silkworm; using namespace silkworm::db::kv::api; using namespace silkworm::rpc; std::string h160_address_to_string(const types::H160& address) { std::stringstream out; out << "address=" << address.has_hi(); if (address.has_hi()) { auto& hi_half = address.hi(); out << std::hex << hi_half.hi() << hi_half.lo(); } else { auto lo_half = address.lo(); out << std::hex << lo_half; } out << std::dec; return out.str(); } std::ostream& operator<<(std::ostream& out, const types::H160& address) { out << h160_address_to_string(address); return out; } int ethbackend_sync(const std::string& target) { // Create ETHBACKEND stub using insecure channel to target grpc::Status status; const auto channel = grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); const auto stub = remote::ETHBACKEND::NewStub(channel); grpc::ClientContext eb_context; remote::EtherbaseReply eb_reply; std::cout << "ETHBACKEND Etherbase ->\n"; status = stub->Etherbase(&eb_context, remote::EtherbaseRequest{}, &eb_reply); if (status.ok()) { std::cout << "ETHBACKEND Etherbase <- " << status << " address: " << eb_reply.address() << "\n"; } else { std::cout << "ETHBACKEND Etherbase <- " << status << "\n"; } grpc::ClientContext nv_context; remote::NetVersionReply nv_reply; std::cout << "ETHBACKEND NetVersion ->\n"; status = stub->NetVersion(&nv_context, remote::NetVersionRequest{}, &nv_reply); if (status.ok()) { std::cout << "ETHBACKEND NetVersion <- " << status << " id: " << nv_reply.id() << "\n"; } else { std::cout << "ETHBACKEND NetVersion <- " << status << "\n"; } grpc::ClientContext v_context; types::VersionReply v_reply; std::cout << "ETHBACKEND Version ->\n"; status = stub->Version(&v_context, google::protobuf::Empty{}, &v_reply); if (status.ok()) { std::cout << "ETHBACKEND Version <- " << status << " major.minor.patch: " << v_reply.major() << "." << v_reply.minor() << "." << v_reply.patch() << "\n"; } else { std::cout << "ETHBACKEND Version <- " << status << "\n"; } grpc::ClientContext pv_context; remote::ProtocolVersionReply pv_reply; std::cout << "ETHBACKEND ProtocolVersion ->\n"; status = stub->ProtocolVersion(&pv_context, remote::ProtocolVersionRequest{}, &pv_reply); if (status.ok()) { std::cout << "ETHBACKEND ProtocolVersion <- " << status << " id: " << pv_reply.id() << "\n"; } else { std::cout << "ETHBACKEND ProtocolVersion <- " << status << "\n"; } grpc::ClientContext cv_context; remote::ClientVersionReply cv_reply; std::cout << "ETHBACKEND ClientVersion ->\n"; status = stub->ClientVersion(&cv_context, remote::ClientVersionRequest{}, &cv_reply); if (status.ok()) { std::cout << "ETHBACKEND ClientVersion <- " << status << " node name: " << cv_reply.node_name() << "\n"; } else { std::cout << "ETHBACKEND ClientVersion <- " << status << "\n"; } return 0; } int ethbackend_async(const std::string& target) { // Create ETHBACKEND stub using insecure channel to target grpc::CompletionQueue queue; grpc::Status status; void* got_tag{nullptr}; bool ok{false}; const auto channel = grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); const auto stub = remote::ETHBACKEND::NewStub(channel); // Etherbase grpc::ClientContext eb_context; const auto eb_reader = stub->PrepareAsyncEtherbase(&eb_context, remote::EtherbaseRequest{}, &queue); eb_reader->StartCall(); std::cout << "ETHBACKEND Etherbase ->\n"; remote::EtherbaseReply eb_reply; eb_reader->Finish(&eb_reply, &status, eb_reader.get()); bool has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != eb_reader.get()) { return -1; } if (status.ok()) { std::cout << "ETHBACKEND Etherbase <- " << status << " address: " << eb_reply.has_address() << "\n"; } else { std::cout << "ETHBACKEND Etherbase <- " << status << "\n"; } // NetVersion grpc::ClientContext nv_context; const auto nv_reader = stub->PrepareAsyncNetVersion(&nv_context, remote::NetVersionRequest{}, &queue); nv_reader->StartCall(); std::cout << "ETHBACKEND NetVersion ->\n"; remote::NetVersionReply nv_reply; nv_reader->Finish(&nv_reply, &status, nv_reader.get()); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != nv_reader.get()) { return -1; } if (status.ok()) { std::cout << "ETHBACKEND NetVersion <- " << status << " id: " << nv_reply.id() << "\n"; } else { std::cout << "ETHBACKEND NetVersion <- " << status << "\n"; } // Version grpc::ClientContext v_context; const auto v_reader = stub->PrepareAsyncVersion(&v_context, google::protobuf::Empty{}, &queue); v_reader->StartCall(); std::cout << "ETHBACKEND Version ->\n"; types::VersionReply v_reply; v_reader->Finish(&v_reply, &status, v_reader.get()); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != v_reader.get()) { return -1; } if (status.ok()) { std::cout << "ETHBACKEND Version <- " << status << " major.minor.patch: " << v_reply.major() << "." << v_reply.minor() << "." << v_reply.patch() << "\n"; } else { std::cout << "ETHBACKEND Version <- " << status << "\n"; } // ProtocolVersion grpc::ClientContext pv_context; const auto pv_reader = stub->PrepareAsyncProtocolVersion(&pv_context, remote::ProtocolVersionRequest{}, &queue); pv_reader->StartCall(); std::cout << "ETHBACKEND ProtocolVersion ->\n"; remote::ProtocolVersionReply pv_reply; pv_reader->Finish(&pv_reply, &status, pv_reader.get()); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != pv_reader.get()) { return -1; } if (status.ok()) { std::cout << "ETHBACKEND ProtocolVersion <- " << status << " id: " << pv_reply.id() << "\n"; } else { std::cout << "ETHBACKEND ProtocolVersion <- " << status << "\n"; } // ClientVersion grpc::ClientContext cv_context; const auto cv_reader = stub->PrepareAsyncClientVersion(&cv_context, remote::ClientVersionRequest{}, &queue); cv_reader->StartCall(); std::cout << "ETHBACKEND ClientVersion ->\n"; remote::ClientVersionReply cv_reply; cv_reader->Finish(&cv_reply, &status, cv_reader.get()); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != cv_reader.get()) { return -1; } if (status.ok()) { std::cout << "ETHBACKEND ClientVersion <- " << status << " node name: " << cv_reply.node_name() << "\n"; } else { std::cout << "ETHBACKEND ClientVersion <- " << status << "\n"; } return 0; } Task ethbackend_etherbase(ethbackend::BackEnd& backend) { try { std::cout << "ETHBACKEND Etherbase ->\n"; const auto address = co_await backend.etherbase(); std::cout << "ETHBACKEND Etherbase <- address: " << address << "\n"; } catch (const std::exception& e) { std::cout << "ETHBACKEND Etherbase <- error: " << e.what() << "\n"; } } int ethbackend_coroutines(const std::string& target) { try { ClientContextPool context_pool{1}; auto& context = context_pool.next_context(); auto ioc = context.ioc(); auto grpc_context = context.grpc_context(); boost::asio::signal_set signals(*ioc, SIGINT, SIGTERM); signals.async_wait([&](const boost::system::error_code& error, int signal_number) { std::cout << "Signal caught, error: " << error.message() << " number: " << signal_number << std::endl << std::flush; context_pool.stop(); }); const auto channel = grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); // Etherbase ethbackend::RemoteBackEnd eth_backend{channel, *grpc_context}; boost::asio::co_spawn(*ioc, ethbackend_etherbase(eth_backend), [&](std::exception_ptr) { context_pool.stop(); }); context_pool.run(); } catch (const std::exception& e) { std::cerr << "Exception: " << e.what() << "\n" << std::flush; } catch (...) { std::cerr << "Unexpected exception\n" << std::flush; } return 0; } int kv_seek(const std::string& target, const std::string& table_name, silkworm::ByteView key) { // Create KV stub using insecure channel to target grpc::ClientContext context; const auto channel = grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); const auto stub = remote::KV::NewStub(channel); const auto reader_writer = stub->Tx(&context); std::cout << "KV Tx START\n"; // Read TX identifier auto tx_id_pair = remote::Pair{}; auto success = reader_writer->Read(&tx_id_pair); if (!success) { std::cerr << "KV stream closed receiving TXID\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } const auto tx_id = tx_id_pair.cursor_id(); std::cout << "KV Tx START <- txid: " << tx_id << "\n"; // Open cursor auto open_message = remote::Cursor{}; open_message.set_op(remote::Op::OPEN); open_message.set_bucket_name(table_name); success = reader_writer->Write(open_message); if (!success) { std::cerr << "KV stream closed sending OPEN operation req\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx OPEN -> table_name: " << table_name << "\n"; auto open_pair = remote::Pair{}; success = reader_writer->Read(&open_pair); if (!success) { std::cerr << "KV stream closed receiving OPEN operation rsp\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } auto cursor_id = open_pair.cursor_id(); std::cout << "KV Tx OPEN <- cursor: " << cursor_id << "\n"; // Seek given key in given table auto seek_message = remote::Cursor{}; seek_message.set_op(remote::Op::SEEK); seek_message.set_cursor(cursor_id); seek_message.set_k(key.data(), key.size()); success = reader_writer->Write(seek_message); if (!success) { std::cerr << "KV stream closed sending SEEK operation req\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx SEEK -> cursor: " << cursor_id << " key: " << key << "\n"; auto seek_pair = remote::Pair{}; success = reader_writer->Read(&seek_pair); if (!success) { std::cerr << "KV stream closed receiving SEEK operation rsp\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } const auto& rsp_key = silkworm::string_view_to_byte_view(seek_pair.k()); const auto& rsp_value = silkworm::string_view_to_byte_view(seek_pair.v()); std::cout << "KV Tx SEEK <- key: " << rsp_key << " value: " << rsp_value << std::endl; // Close cursor auto close_message = remote::Cursor{}; close_message.set_op(remote::Op::CLOSE); close_message.set_cursor(cursor_id); success = reader_writer->Write(close_message); if (!success) { std::cerr << "KV stream closed sending CLOSE operation req\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx CLOSE -> cursor: " << cursor_id << "\n"; auto close_pair = remote::Pair{}; success = reader_writer->Read(&close_pair); if (!success) { std::cerr << "KV stream closed receiving CLOSE operation rsp\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx CLOSE <- cursor: " << close_pair.cursor_id() << "\n"; reader_writer->WritesDone(); grpc::Status status = reader_writer->Finish(); std::cout << "KV Tx STATUS: " << status << "\n"; return 0; } int kv_seek_async(const std::string& target, const std::string& table_name, silkworm::ByteView key, uint32_t timeout) { // Create KV stub using insecure channel to target grpc::ClientContext context; grpc::CompletionQueue queue; grpc::Status status; void* got_tag{nullptr}; bool ok{false}; const auto channel = grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); const auto stub = remote::KV::NewStub(channel); // Prepare RPC call context and stream context.set_deadline(std::chrono::system_clock::system_clock::now() + std::chrono::milliseconds{timeout}); const auto reader_writer = stub->PrepareAsyncTx(&context, &queue); void* start_tag = reinterpret_cast(0); void* open_tag = reinterpret_cast(1); void* seek_tag = reinterpret_cast(2); void* close_tag = reinterpret_cast(3); void* finish_tag = reinterpret_cast(4); // 1) StartCall std::cout << "KV Tx START\n"; // 1.1) StartCall + Next reader_writer->StartCall(start_tag); bool has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != start_tag) { return -1; } // 1.2) Read + Next auto tx_id_pair = remote::Pair{}; reader_writer->Read(&tx_id_pair, start_tag); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != start_tag) { return -1; } const auto tx_id = tx_id_pair.cursor_id(); std::cout << "KV Tx START <- txid: " << tx_id << "\n"; // 2) Open cursor std::cout << "KV Tx OPEN -> table_name: " << table_name << "\n"; // 2.1) Write + Next auto open_message = remote::Cursor{}; open_message.set_op(remote::Op::OPEN); open_message.set_bucket_name(table_name); reader_writer->Write(open_message, open_tag); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != open_tag) { return -1; } // 2.2) Read + Next auto open_pair = remote::Pair{}; reader_writer->Read(&open_pair, open_tag); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != open_tag) { return -1; } auto cursor_id = open_pair.cursor_id(); std::cout << "KV Tx OPEN <- cursor: " << cursor_id << "\n"; // 3) Seek given key in given table std::cout << "KV Tx SEEK -> cursor: " << cursor_id << " key: " << key << "\n"; // 3.1) Write + Next auto seek_message = remote::Cursor{}; seek_message.set_op(remote::Op::SEEK); seek_message.set_cursor(cursor_id); seek_message.set_k(key.data(), key.size()); reader_writer->Write(seek_message, seek_tag); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != seek_tag) { return -1; } // 3.2) Read + Next auto seek_pair = remote::Pair{}; reader_writer->Read(&seek_pair, seek_tag); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != seek_tag) { return -1; } const auto& key_bytes = silkworm::string_view_to_byte_view(seek_pair.k()); const auto& value_bytes = silkworm::string_view_to_byte_view(seek_pair.v()); std::cout << "KV Tx SEEK <- key: " << key_bytes << " value: " << value_bytes << std::endl; // 4) Close cursor std::cout << "KV Tx CLOSE -> cursor: " << cursor_id << "\n"; // 4.1) Write + Next auto close_message = remote::Cursor{}; close_message.set_op(remote::Op::CLOSE); close_message.set_cursor(cursor_id); reader_writer->Write(close_message, close_tag); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != close_tag) { return -1; } // 4.2) Read + Next auto close_pair = remote::Pair{}; reader_writer->Read(&close_pair, close_tag); has_event = queue.Next(&got_tag, &ok); if (!has_event || got_tag != close_tag) { return -1; } std::cout << "KV Tx CLOSE <- cursor: " << close_pair.cursor_id() << "\n"; // 5) Finish reader_writer->Finish(&status, finish_tag); if (!status.ok()) { std::cout << "KV Tx Status <- error_code: " << status.error_code() << "\n"; std::cout << "KV Tx Status <- error_message: " << status.error_message() << "\n"; std::cout << "KV Tx Status <- error_details: " << status.error_details() << "\n"; return -1; } return 0; } class GrpcKvCallbackReactor final : public grpc::ClientBidiReactor { public: explicit GrpcKvCallbackReactor(remote::KV::Stub& stub, std::chrono::milliseconds timeout) : stub_(stub) { context_.set_deadline(std::chrono::system_clock::now() + timeout); stub_.experimental_async()->Tx(&context_, this); StartCall(); } void read_start(std::function read_completed) { read_completed_ = std::move(read_completed); StartRead(&pair_); } void write_start(remote::Cursor* cursor, std::function write_completed) { write_completed_ = std::move(write_completed); StartWrite(cursor); } void OnReadDone(bool ok) override { read_completed_(ok, pair_); } void OnWriteDone(bool ok) override { write_completed_(ok); } private: remote::KV::Stub& stub_; grpc::ClientContext context_; remote::Pair pair_; std::function read_completed_; std::function write_completed_; }; int kv_seek_async_callback(const std::string& target, const std::string& table_name, silkworm::ByteView key, uint32_t timeout) { boost::asio::io_context ioc; boost::asio::executor_work_guard work{ioc.get_executor()}; const auto channel = grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); auto stub = remote::KV::NewStub(channel); boost::asio::signal_set signals(ioc, SIGINT, SIGTERM); signals.async_wait([&](const boost::system::error_code& error, int signal_number) { std::cout << "Signal caught, error: " << error.message() << " number: " << signal_number << std::endl << std::flush; ioc.stop(); }); GrpcKvCallbackReactor reactor{*stub, std::chrono::milliseconds{timeout}}; std::cout << "KV Tx START\n"; reactor.read_start([&](bool tx_id_read_ok, const remote::Pair& tx_id_pair) { if (!tx_id_read_ok) { std::cout << "KV Tx error reading tx ID" << std::flush; return; } const auto tx_id = tx_id_pair.cursor_id(); std::cout << "KV Tx START <- tx_id: " << tx_id << "\n"; auto open_message = remote::Cursor{}; open_message.set_op(remote::Op::OPEN); open_message.set_bucket_name(table_name); reactor.write_start(&open_message, [&](bool open_write_ok) { if (!open_write_ok) { std::cout << "error writing OPEN gRPC" << std::flush; return; } std::cout << "KV Tx OPEN -> table_name: " << table_name << "\n"; reactor.read_start([&](bool open_read_ok, const remote::Pair& open_pair) { if (!open_read_ok) { std::cout << "error reading OPEN gRPC" << std::flush; return; } const auto cursor_id = open_pair.cursor_id(); std::cout << "KV Tx OPEN <- cursor: " << cursor_id << "\n"; auto seek_message = remote::Cursor{}; seek_message.set_op(remote::Op::SEEK); seek_message.set_cursor(cursor_id); seek_message.set_k(key.data(), key.size()); reactor.write_start(&seek_message, [&, cursor_id](bool seek_write_ok) { if (!seek_write_ok) { std::cout << "error writing SEEK gRPC" << std::flush; return; } std::cout << "KV Tx SEEK -> cursor: " << cursor_id << " key: " << key << "\n"; reactor.read_start([&, cursor_id](bool seek_read_ok, const remote::Pair& seek_pair) { if (!seek_read_ok) { std::cout << "error reading SEEK gRPC" << std::flush; return; } const auto& key_bytes = silkworm::string_view_to_byte_view(seek_pair.k()); const auto& value_bytes = silkworm::string_view_to_byte_view(seek_pair.v()); std::cout << "KV Tx SEEK <- key: " << key_bytes << " value: " << value_bytes << std::endl; auto close_message = remote::Cursor{}; close_message.set_op(remote::Op::CLOSE); close_message.set_cursor(cursor_id); reactor.write_start(&close_message, [&, cursor_id](bool close_write_ok) { if (!close_write_ok) { std::cout << "error writing CLOSE gRPC" << std::flush; return; } std::cout << "KV Tx CLOSE -> cursor: " << cursor_id << "\n"; reactor.read_start([&](bool close_read_ok, const remote::Pair& close_pair) { if (!close_read_ok) { std::cout << "error reading CLOSE gRPC" << std::flush; return; } std::cout << "KV Tx CLOSE <- cursor: " << close_pair.cursor_id() << "\n"; ioc.stop(); }); }); }); }); }); }); }); ioc.run(); return 0; } int kv_seek_both(const std::string& target, const std::string& table_name, silkworm::ByteView key, silkworm::ByteView subkey) { // Create KV stub using insecure channel to target grpc::ClientContext context; const auto channel = grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); const auto stub = remote::KV::NewStub(channel); const auto reader_writer = stub->Tx(&context); std::cout << "KV Tx START\n"; // Read TX identifier auto tx_id_pair = remote::Pair{}; auto success = reader_writer->Read(&tx_id_pair); if (!success) { std::cerr << "KV stream closed receiving TXID\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } const auto tx_id = tx_id_pair.cursor_id(); std::cout << "KV Tx START <- txid: " << tx_id << "\n"; // Open cursor auto open_message = remote::Cursor{}; open_message.set_op(remote::Op::OPEN); open_message.set_bucket_name(table_name); success = reader_writer->Write(open_message); if (!success) { std::cerr << "KV stream closed sending OPEN operation req\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx OPEN -> table_name: " << table_name << "\n"; auto open_pair = remote::Pair{}; success = reader_writer->Read(&open_pair); if (!success) { std::cerr << "KV stream closed receiving OPEN operation rsp\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } auto cursor_id = open_pair.cursor_id(); std::cout << "KV Tx OPEN <- cursor: " << cursor_id << "\n"; // Seek given key in given table auto seek_both_message = remote::Cursor{}; seek_both_message.set_op(remote::Op::SEEK_BOTH); seek_both_message.set_cursor(cursor_id); seek_both_message.set_k(key.data(), key.size()); seek_both_message.set_v(subkey.data(), subkey.size()); success = reader_writer->Write(seek_both_message); if (!success) { std::cerr << "KV stream closed sending SEEK_BOTH operation req\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx SEEK_BOTH -> cursor: " << cursor_id << " key: " << key << " subkey: " << subkey << "\n"; auto seek_both_pair = remote::Pair{}; success = reader_writer->Read(&seek_both_pair); if (!success) { std::cerr << "KV stream closed receiving SEEK_BOTH operation rsp\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } const auto& rsp_key = silkworm::string_view_to_byte_view(seek_both_pair.k()); const auto& rsp_value = silkworm::string_view_to_byte_view(seek_both_pair.v()); std::cout << "KV Tx SEEK_BOTH <- key: " << rsp_key << " value: " << rsp_value << std::endl; // Close cursor auto close_message = remote::Cursor{}; close_message.set_op(remote::Op::CLOSE); close_message.set_cursor(cursor_id); success = reader_writer->Write(close_message); if (!success) { std::cerr << "KV stream closed sending CLOSE operation req\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx CLOSE -> cursor: " << cursor_id << "\n"; auto close_pair = remote::Pair{}; success = reader_writer->Read(&close_pair); if (!success) { std::cerr << "KV stream closed receiving CLOSE operation rsp\n"; std::cout << "KV Tx STATUS: " << reader_writer->Finish() << "\n"; return -1; } std::cout << "KV Tx CLOSE <- cursor: " << close_pair.cursor_id() << "\n"; reader_writer->WritesDone(); grpc::Status status = reader_writer->Finish(); std::cout << "KV Tx STATUS: " << status << "\n"; return 0; } ABSL_FLAG(std::string, key, "", "key as hex string w/o leading 0x"); ABSL_FLAG(std::string, seekkey, "", "seek key as hex string w/o leading 0x"); ABSL_FLAG(std::string, subkey, "", "subkey as hex string w/o leading 0x"); ABSL_FLAG(std::string, tool, "", "gRPC remote interface tool name as string"); ABSL_FLAG(std::string, target, std::string{kDefaultPrivateApiAddr}, "Silkworm location as string
:"); ABSL_FLAG(std::string, table, "", "database table name as string"); ABSL_FLAG(int, limit, -1, "max number of items returned by Temporal KV range queries"); ABSL_FLAG(std::string, from_key, "", "start lookup key as hex string w/o leading 0x"); ABSL_FLAG(std::string, to_key, "", "end lookup key as hex string w/o leading 0x"); ABSL_FLAG(int64_t, timestamp, -1, "history timestamp for Temporal KV domain_range query"); ABSL_FLAG(uint32_t, timeout, kDefaultTimeout.count(), "gRPC call timeout as integer"); ABSL_FLAG(bool, verbose, false, "verbose output"); int ethbackend_async() { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance\n"; return -1; } return ethbackend_async(target); } int ethbackend_coroutines() { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance\n"; return -1; } return ethbackend_coroutines(target); } int ethbackend_sync() { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance\n"; return -1; } return ethbackend_sync(target); } int kv_seek_async_callback() { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance\n"; return -1; } auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } auto key{absl::GetFlag(FLAGS_key)}; const auto key_bytes = silkworm::from_hex(key); if (key.empty() || !key_bytes.has_value()) { std::cerr << "Parameter key is invalid: [" << key << "]\n"; std::cerr << "Use --key flag to specify the key in key-value dupsort table\n"; return -1; } auto timeout{absl::GetFlag(FLAGS_timeout)}; return kv_seek_async_callback(target, table_name, key_bytes.value(), timeout); } int kv_seek_async() { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance\n"; return -1; } auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } auto key{absl::GetFlag(FLAGS_key)}; const auto key_bytes = silkworm::from_hex(key); if (key.empty() || !key_bytes.has_value()) { std::cerr << "Parameter key is invalid: [" << key << "]\n"; std::cerr << "Use --key flag to specify the key in key-value dupsort table\n"; return -1; } auto timeout{absl::GetFlag(FLAGS_timeout)}; return kv_seek_async(target, table_name, key_bytes.value(), timeout); } int kv_seek_both() { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance\n"; return -1; } auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } auto key{absl::GetFlag(FLAGS_key)}; const auto key_bytes = silkworm::from_hex(key); if (key.empty() || !key_bytes.has_value()) { std::cerr << "Parameter key is invalid: [" << key << "]\n"; std::cerr << "Use --key flag to specify the key in key-value dupsort table\n"; return -1; } auto subkey{absl::GetFlag(FLAGS_subkey)}; const auto subkey_bytes = silkworm::from_hex(subkey); if (subkey.empty() || !subkey_bytes.has_value()) { std::cerr << "Parameter subkey is invalid: [" << subkey << "]\n"; std::cerr << "Use --subkey flag to specify the subkey in key-value dupsort table\n"; return -1; } return kv_seek_both(target, table_name, key_bytes.value(), subkey_bytes.value()); } int kv_seek() { auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance\n"; return -1; } auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } auto key{absl::GetFlag(FLAGS_key)}; const auto key_bytes = silkworm::from_hex(key); if (key.empty() || !key_bytes.has_value()) { std::cerr << "Parameter key is invalid: [" << key << "]\n"; std::cerr << "Use --key flag to specify the key in key-value dupsort table\n"; return -1; } return kv_seek(target, table_name, key_bytes.value()); } Task kv_get_latest_query(const std::shared_ptr& kv_service, GetLatestRequest request, const bool /*verbose*/) { try { auto tx = co_await kv_service->begin_transaction(); std::cout << "KV GetLatest -> " << request.table << " key=" << to_hex(request.key) << " latest=true\n"; const auto result = co_await tx->get_latest(std::move(request)); std::cout << "KV GetLatest <- success: " << result.success << " value=" << to_hex(result.value) << "\n"; co_await tx->close(); } catch (const std::exception& e) { std::cout << "KV GetLatest <- error: " << e.what() << "\n"; } } Task kv_get_as_of_query(const std::shared_ptr& kv_service, GetAsOfRequest request, const bool /*verbose*/) { try { auto tx = co_await kv_service->begin_transaction(); std::cout << "KV GetLatest -> " << request.table << " key=" << to_hex(request.key) << " ts=" << request.timestamp << " latest=false\n"; const auto result = co_await tx->get_as_of(std::move(request)); std::cout << "KV GetLatest <- success: " << result.success << " value=" << to_hex(result.value) << "\n"; co_await tx->close(); } catch (const std::exception& e) { std::cout << "KV GetLatest <- error: " << e.what() << "\n"; } } Task kv_history_seek_query(const std::shared_ptr& kv_service, HistoryPointRequest request, const bool /*verbose*/) { try { auto tx = co_await kv_service->begin_transaction(); std::cout << "KV HistorySeek -> " << request.table << " key=" << to_hex(request.key) << " ts=" << request.timestamp << "\n"; const auto result = co_await tx->history_seek(std::move(request)); std::cout << "KV HistorySeek <- success: " << result.success << " value=" << to_hex(result.value) << "\n"; co_await tx->close(); } catch (const std::exception& e) { std::cout << "KV HistorySeek <- error: " << e.what() << "\n"; } } Task kv_index_range_query(const std::shared_ptr& kv_service, IndexRangeRequest request, const bool verbose) { try { auto tx = co_await kv_service->begin_transaction(); std::cout << "KV IndexRange -> " << request.table << "\n"; auto paginated_result = co_await tx->index_range(std::move(request)); auto it = co_await paginated_result.begin(); std::cout << "KV IndexRange <- #timestamps: "; int count{0}; ListOfTimestamp timestamps; while (const auto value = co_await it->next()) { timestamps.emplace_back(*value); ++count; } std::cout << count << "\n"; if (verbose) { for (const auto ts : timestamps) { std::cout << ts << "\n"; } } co_await tx->close(); } catch (const std::exception& e) { std::cout << "KV IndexRange <- error: " << e.what() << "\n"; } } Task kv_history_range_query(const std::shared_ptr& kv_service, HistoryRangeRequest request, const bool verbose) { try { auto tx = co_await kv_service->begin_transaction(); std::cout << "KV HistoryRange -> " << request.table << " limit=" << request.limit << "\n"; auto paginated_result = co_await tx->history_range(std::move(request)); auto it = co_await paginated_result.begin(); std::cout << "KV HistoryRange <- #keys and #values: "; int count{0}; std::vector keys_and_values; while (const auto key_value = co_await it->next()) { keys_and_values.emplace_back(*key_value); ++count; } std::cout << count << "\n"; if (verbose) { for (const auto& key_value_pair : keys_and_values) { std::cout << "k=" << to_hex(key_value_pair.key) << " v=" << to_hex(key_value_pair.value) << "\n"; } } co_await tx->close(); } catch (const std::exception& e) { std::cout << "KV HistoryRange <- error: " << e.what() << "\n"; } } Task kv_range_as_of_query(const std::shared_ptr& kv_service, DomainRangeRequest request, const bool verbose) { try { auto tx = co_await kv_service->begin_transaction(); std::cout << "KV RangeAsOf -> " << request.table << " limit=" << request.limit << "\n"; auto paginated_result = co_await tx->range_as_of(std::move(request)); auto it = co_await paginated_result.begin(); std::cout << "KV RangeAsOf <- #keys and #values: "; int count{0}; std::vector keys_and_values; while (const auto key_value = co_await it->next()) { keys_and_values.emplace_back(*key_value); ++count; } std::cout << count << "\n"; if (verbose) { for (const auto& key_value_pair : keys_and_values) { std::cout << "k=" << to_hex(key_value_pair.key) << " v=" << to_hex(key_value_pair.value) << "\n"; } } co_await tx->close(); } catch (const std::exception& e) { std::cout << "KV RangeAsOf <- error: " << e.what() << "\n"; } } template using KVQueryFunc = Task (*)(const std::shared_ptr&, Q, bool); template int execute_temporal_kv_query(const std::string& target, KVQueryFunc query_func, Q&& query, const bool verbose) { try { ClientContextPool context_pool{1}; auto& context = context_pool.next_context(); auto ioc = context.ioc(); auto grpc_context = context.grpc_context(); boost::asio::signal_set signals(*ioc, SIGINT, SIGTERM); signals.async_wait([&](const boost::system::error_code& error, int signal_number) { std::cout << "Signal caught, error: " << error.message() << " number: " << signal_number << std::endl << std::flush; context_pool.stop(); }); auto channel_factory = [target]() -> std::shared_ptr<::grpc::Channel> { return ::grpc::CreateChannel(target, grpc::InsecureChannelCredentials()); }; // ETHBACKEND ethbackend::RemoteBackEnd eth_backend{channel_factory(), *grpc_context}; // DB KV API client CoherentStateCache state_cache; db::kv::grpc::client::RemoteClient client{channel_factory, *grpc_context, &state_cache, ethdb::kv::make_backend_providers(ð_backend)}; auto kv_service = client.service(); boost::asio::co_spawn(*ioc, query_func(kv_service, std::forward(query), verbose), [&](std::exception_ptr) { context_pool.stop(); }); context_pool.run(); } catch (const std::exception& e) { std::cerr << "Exception: " << e.what() << "\n"; } catch (...) { std::cerr << "Unexpected exception\n"; } return 0; } int kv_get_latest() { const auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance in : format\n"; return -1; } const auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } const auto key{absl::GetFlag(FLAGS_key)}; const auto key_bytes = silkworm::from_hex(key); if (key.empty() || !key_bytes.has_value()) { std::cerr << "Parameter key is invalid: [" << key << "]\n"; std::cerr << "Use --key flag to specify the start key in key-value table as hex string\n"; return -1; } const auto timestamp{absl::GetFlag(FLAGS_timestamp)}; if (timestamp < -1) { std::cerr << "Parameter timestamp is invalid: [" << timestamp << "]\n"; std::cerr << "Use --timestamp flag to specify the timestamp for TKV domain_get query\n"; return -1; } const auto verbose{absl::GetFlag(FLAGS_verbose)}; if (timestamp > -1) { GetAsOfRequest query{ .table = table_name, .key = *key_bytes, .timestamp = timestamp, }; return execute_temporal_kv_query(target, kv_get_as_of_query, std::move(query), verbose); } GetLatestRequest query{ .table = table_name, .key = *key_bytes, }; return execute_temporal_kv_query(target, kv_get_latest_query, std::move(query), verbose); } int kv_history_seek() { const auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance in : format\n"; return -1; } const auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } const auto key{absl::GetFlag(FLAGS_key)}; const auto key_bytes = silkworm::from_hex(key); if (key.empty() || !key_bytes.has_value()) { std::cerr << "Parameter key is invalid: [" << key << "]\n"; std::cerr << "Use --key flag to specify the start key in key-value table as hex string\n"; return -1; } const auto timestamp{absl::GetFlag(FLAGS_timestamp)}; if (timestamp < -1) { std::cerr << "Parameter timestamp is invalid: [" << timestamp << "]\n"; std::cerr << "Use --timestamp flag to specify the history timestamp for TKV history_seek query\n"; return -1; } const auto verbose{absl::GetFlag(FLAGS_verbose)}; HistoryPointRequest query{ .table = table_name, .key = *key_bytes, .timestamp = timestamp, }; return execute_temporal_kv_query(target, kv_history_seek_query, std::move(query), verbose); } int kv_index_range() { const auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance in : format\n"; return -1; } const auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } const auto key{absl::GetFlag(FLAGS_key)}; const auto key_bytes = silkworm::from_hex(key); if (key.empty() || !key_bytes.has_value()) { std::cerr << "Parameter key is invalid: [" << key << "]\n"; std::cerr << "Use --key flag to specify the start key in key-value table as hex string\n"; return -1; } const auto limit{absl::GetFlag(FLAGS_limit)}; if (limit < -1) { std::cerr << "Parameter limit is invalid: [" << limit << "]\n"; std::cerr << "Use --limit flag to specify the max number of items returned by TKV queries (-1 means no limit)\n"; return -1; } const auto verbose{absl::GetFlag(FLAGS_verbose)}; IndexRangeRequest query{ .table = table_name, .key = *key_bytes, .from_timestamp = 0, .to_timestamp = -1, .ascending_order = true, .limit = limit, }; return execute_temporal_kv_query(target, kv_index_range_query, std::move(query), verbose); } int kv_history_range() { const auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance in : format\n"; return -1; } const auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } const auto limit{absl::GetFlag(FLAGS_limit)}; if (limit < -1) { std::cerr << "Parameter limit is invalid: [" << limit << "]\n"; std::cerr << "Use --limit flag to specify the max number of items returned by TKV queries (-1 means no limit)\n"; return -1; } const auto verbose{absl::GetFlag(FLAGS_verbose)}; HistoryRangeRequest query{ .table = table_name, .from_timestamp = 0, .to_timestamp = -1, .ascending_order = true, .limit = limit, }; return execute_temporal_kv_query(target, kv_history_range_query, std::move(query), verbose); } int kv_get_as_of() { const auto target{absl::GetFlag(FLAGS_target)}; if (target.empty() || !absl::StrContains(target, ":")) { std::cerr << "Parameter target is invalid: [" << target << "]\n"; std::cerr << "Use --target flag to specify the location of Erigon running instance in : format\n"; return -1; } const auto table_name{absl::GetFlag(FLAGS_table)}; if (table_name.empty()) { std::cerr << "Parameter table is invalid: [" << table_name << "]\n"; std::cerr << "Use --table flag to specify the name of Erigon database table\n"; return -1; } const auto from_key{absl::GetFlag(FLAGS_from_key)}; const auto from_key_bytes = silkworm::from_hex(from_key); if (from_key.empty() || !from_key_bytes.has_value()) { std::cerr << "Parameter from_key is invalid: [" << from_key << "]\n"; std::cerr << "Use --from_key flag to specify the start key in key-value table lookup as hex string\n"; return -1; } const auto to_key{absl::GetFlag(FLAGS_to_key)}; const auto to_key_bytes = silkworm::from_hex(to_key); if (to_key.empty() || !to_key_bytes.has_value()) { std::cerr << "Parameter to_key is invalid: [" << to_key << "]\n"; std::cerr << "Use --to_key flag to specify the end key in key-value table lookup as hex string\n"; return -1; } const auto timestamp{absl::GetFlag(FLAGS_timestamp)}; if (timestamp < -1) { std::cerr << "Parameter timestamp is invalid: [" << timestamp << "]\n"; std::cerr << "Use --timestamp flag to specify the history timestamp for TKV domain_range query (-1 means latest)\n"; return -1; } const auto limit{absl::GetFlag(FLAGS_limit)}; if (limit < -1) { std::cerr << "Parameter limit is invalid: [" << limit << "]\n"; std::cerr << "Use --limit flag to specify the max number of items returned by TKV queries (-1 means no limit)\n"; return -1; } const auto verbose{absl::GetFlag(FLAGS_verbose)}; DomainRangeRequest query{ .table = table_name, .from_key = *from_key_bytes, .to_key = *to_key_bytes, .timestamp = timestamp > -1 ? std::make_optional(timestamp) : std::nullopt, .ascending_order = true, .limit = limit, }; return execute_temporal_kv_query(target, kv_range_as_of_query, std::move(query), verbose); } int main(int argc, char* argv[]) { absl::SetProgramUsageMessage( "Execute specified internal gRPC I/F tool:\n" "\tethbackend\t\t\tquery the Erigon/Silkworm ETHBACKEND remote interface\n" "\tethbackend_async\t\tquery the Erigon/Silkworm ETHBACKEND remote interface\n" "\tethbackend_coroutines\t\tquery the Erigon/Silkworm ETHBACKEND remote interface\n" "\tkv_seek\t\t\t\tquery using SEEK the Erigon/Silkworm Key-Value (KV) remote interface to database\n" "\tkv_seek_async\t\t\tquery using SEEK the Erigon/Silkworm Key-Value (KV) remote interface to database\n" "\tkv_seek_async_callback\t\tquery using SEEK the Erigon/Silkworm Key-Value (KV) remote interface to database\n" "\tkv_seek_both\t\t\tquery using SEEK_BOTH the Erigon/Silkworm Key-Value (KV) remote interface to database\n" "\tkv_get_latest\t\tquery the Erigon/Silkworm Key-Value (KV) remote interface to data storage using DOMAIN_GET\n" "\tkv_history_seek\t\tquery using HISTORY_SEEK the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n" "\tkv_index_range\t\tquery using INDEX_RANGE the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n" "\tkv_history_range\t\tquery using HISTORY_RANGE the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n" "\tkv_get_as_of\t\tquery using DOMAIN_RANGE the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n"); const auto positional_args = absl::ParseCommandLine(argc, argv); if (positional_args.size() < 2) { std::cerr << "No gRPC tool specified as first positional argument\n\n"; std::cerr << absl::ProgramUsageMessage(); return -1; } log::set_verbosity(log::Level::kCritical); const std::string tool{positional_args[1]}; if (tool == "ethbackend_async") { return ethbackend_async(); } if (tool == "ethbackend_coroutines") { return ethbackend_coroutines(); } if (tool == "ethbackend") { return ethbackend_sync(); } if (tool == "kv_seek_async_callback") { return kv_seek_async_callback(); } if (tool == "kv_seek_async") { return kv_seek_async(); } if (tool == "kv_seek_both") { return kv_seek_both(); } if (tool == "kv_seek") { return kv_seek(); } if (tool == "kv_get_latest") { return kv_get_latest(); } if (tool == "kv_history_seek") { return kv_history_seek(); } if (tool == "kv_index_range") { return kv_index_range(); } if (tool == "kv_history_range") { return kv_history_range(); } if (tool == "kv_get_as_of") { return kv_get_as_of(); } std::cerr << "Unknown tool " << tool << " specified as first argument\n\n"; std::cerr << absl::ProgramUsageMessage(); return -1; } ================================================ FILE: silkworm/rpc/cli/rpcdaemon_options.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rpcdaemon_options.hpp" #include #include #include #include #include namespace silkworm::cmd::common { //! All Ethereum EL JSON RPC API namespaces (standard + custom) static constexpr std::array kAllEth1Namespaces{ kAdminApiNamespace, kDebugApiNamespace, kEthApiNamespace, kNetApiNamespace, kParityApiNamespace, kTraceApiNamespace, kTxPoolApiNamespace, kWeb3ApiNamespace, kErigonApiNamespace, kOtterscanApiNamespace}; //! Compute the maximum number of chars in comma-separated list of all API namespaces static const size_t kApiNamespaceListMaxChars{ std::accumulate(kAllEth1Namespaces.cbegin(), kAllEth1Namespaces.cend(), 0, [](size_t sum, auto s) { return sum + s.length(); }) + kAllEth1Namespaces.size() - 1}; //! CLI11 validator for ETH1 JSON API namespace specification struct ApiSpecValidator : public CLI::Validator { explicit ApiSpecValidator(bool allow_empty = false) { func_ = [&allow_empty](const std::string& value) -> std::string { if (value.empty() && allow_empty) { return {}; } if (value.size() > kApiNamespaceListMaxChars) { return "Value " + value + " is too long for valid API namespace specification"; } // Parse the entire API namespace specification, i.e. comma-separated list of API namespaces for (const auto ns : absl::StrSplit(value, ',')) { const auto it = std::find(kAllEth1Namespaces.cbegin(), kAllEth1Namespaces.cend(), ns); if (it == kAllEth1Namespaces.cend()) { return "Value " + std::string{ns} + " is not a valid API namespace"; } } return {}; }; } }; static void add_options_interface_log(CLI::App& cli, const std::string& option_prefix, const std::string& end_point_descr, rpc::InterfaceLogSettings& settings) { cli.add_flag("--" + option_prefix + ".log.enabled", settings.enabled) ->description("Enable interface log files for " + end_point_descr) ->capture_default_str(); cli.add_option("--" + option_prefix + ".log.max_files", settings.max_files) ->description("Maximum number of distinct interface log files for " + end_point_descr) ->check(CLI::Range(1, 500)) ->capture_default_str(); cli.add_option("--" + option_prefix + ".log.max_file_size", settings.max_file_size_mb) ->description("Maximum size in megabytes of each interface log file for " + end_point_descr) ->check(CLI::Range(1, 1024)) ->capture_default_str(); cli.add_flag("--" + option_prefix + ".log.dump_response", settings.dump_response) ->description("Enable response dump in interface log for " + end_point_descr) ->capture_default_str(); } void add_rpcdaemon_options(CLI::App& cli, silkworm::rpc::DaemonSettings& settings) { add_options_interface_log(cli, "eth", "Execution Layer JSON RPC API", settings.eth_ifc_log_settings); add_options_interface_log(cli, "engine", "Engine JSON RPC API", settings.engine_ifc_log_settings); add_option_ip_endpoint(cli, "--eth.addr", settings.eth_end_point, "Execution Layer JSON RPC API local end-point as
:"); add_option_ip_endpoint(cli, "--engine.addr", settings.engine_end_point, "Engine JSON RPC API local end-point as
:"); cli.add_option("--private.addr", settings.private_api_addr) ->description("Silkworm gRPC service remote end-point as
:") ->capture_default_str(); cli.add_option("--workers", settings.num_workers) ->description("Number of worker threads dedicated to long-running tasks") ->check(CLI::Range(1, 1024)) ->capture_default_str(); cli.add_option("--api", settings.eth_api_spec) ->description("Execution Layer JSON RPC API namespaces as comma-separated list of strings") ->check(ApiSpecValidator()) ->capture_default_str(); cli.add_option("--jwt", settings.jwt_secret_file) ->description("JWT secret file to ensure safe connection between CL and EL as file path") ->capture_default_str(); cli.add_option("--http.cors.domain", settings.cors_domain) ->description("Comma separated list of domains from which to accept cross origin requests (browser enforced)") ->delimiter(',') ->required(false); cli.add_flag("--skip_protocol_check", settings.skip_protocol_check) ->description("Flag indicating if gRPC protocol version check should be skipped") ->capture_default_str(); cli.add_flag("--erigon_compatibility", settings.erigon_json_rpc_compatibility) ->description("Flag indicating if strict compatibility with Erigon RpcDaemon is enabled") ->capture_default_str(); cli.add_flag("--ws", settings.use_websocket) ->description("Enable WebSocket protocol for Execution Layer and Engine JSON RPC API, same port as HTTP(S)") ->capture_default_str(); cli.add_flag("--ws.compression", settings.ws_compression) ->description("Enable compression on WebSocket protocol for Execution Layer and Engine JSON RPC API") ->capture_default_str(); cli.add_flag("--http.compression", settings.http_compression) ->description("Enable compression on HTTP protocol for Execution Layer and Engine JSON RPC API") ->capture_default_str(); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/rpc/cli/rpcdaemon_options.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::cmd::common { void add_rpcdaemon_options(CLI::App& cli, silkworm::rpc::DaemonSettings& settings); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/rpc/commands/admin_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "admin_api.hpp" #include #include #include #include namespace silkworm::rpc::commands { // https://eth.wiki/json-rpc/API#admin_nodeinfo Task AdminRpcApi::handle_admin_node_info(const nlohmann::json& request, nlohmann::json& reply) { try { const auto node_infos = co_await backend_->engine_node_info(); if (!node_infos.empty()) { reply = make_json_content(request, node_infos[0]); } else { reply = make_json_content(request, nlohmann::json::object()); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#admin_peers Task AdminRpcApi::handle_admin_peers(const nlohmann::json& request, nlohmann::json& reply) { try { const auto peers = co_await backend_->peers(); reply = make_json_content(request, peers); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/admin_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class AdminRpcApi { public: explicit AdminRpcApi(ethbackend::BackEnd* backend) : backend_(backend) {} explicit AdminRpcApi(boost::asio::io_context& ioc) : AdminRpcApi(must_use_private_service(ioc)) {} virtual ~AdminRpcApi() = default; AdminRpcApi(const AdminRpcApi&) = delete; AdminRpcApi& operator=(const AdminRpcApi&) = delete; AdminRpcApi(AdminRpcApi&&) = default; protected: Task handle_admin_node_info(const nlohmann::json& request, nlohmann::json& reply); Task handle_admin_peers(const nlohmann::json& request, nlohmann::json& reply); private: ethbackend::BackEnd* backend_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/debug_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "debug_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { static constexpr int16_t kAccountRangeMaxResults{8192}; static constexpr int16_t kAccountRangeMaxResultsWithStorage{256}; // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_accountrange Task DebugRpcApi::handle_debug_account_range(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 5) { auto error_msg = "invalid debug_accountRange params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_num_or_hash = params[0].get(); const auto start_key_array = params[1].get>(); auto max_result = params[2].get(); const auto exclude_code = params[3].get(); const auto exclude_storage = params[4].get(); silkworm::Bytes start_key(start_key_array.data(), start_key_array.size()); const auto start_address = bytes_to_address(start_key); // Determine how many results we will dump if (exclude_storage) { if (max_result > kAccountRangeMaxResults || max_result <= 0) { max_result = kAccountRangeMaxResults; } } else { if (max_result > kAccountRangeMaxResultsWithStorage || max_result <= 0) { max_result = kAccountRangeMaxResultsWithStorage; } } SILK_TRACE << "block_num_or_hash: " << block_num_or_hash << " start_address: " << start_address << " max_result: " << max_result << " exclude_code: " << exclude_code << " exclude_storage: " << exclude_storage; auto tx = co_await database_->begin_transaction(); try { auto start = std::chrono::system_clock::now(); core::AccountDumper dumper{*tx}; DumpAccounts dump_accounts = co_await dumper.dump_accounts(block_num_or_hash, start_address, max_result, exclude_code, exclude_storage); auto end = std::chrono::system_clock::now(); std::chrono::duration elapsed_seconds = end - start; SILK_DEBUG << "dump_accounts: elapsed " << elapsed_seconds.count() << " sec"; reply = make_json_content(request, dump_accounts); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_getmodifiedaccountsbynumber Task DebugRpcApi::handle_debug_get_modified_accounts_by_number(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.empty() || params.size() > 2) { auto error_msg = "invalid debug_getModifiedAccountsByNumber params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto start_block_id = params[0].get(); auto end_block_id = start_block_id; if (params.size() == 2) { end_block_id = params[1].get(); } SILK_DEBUG << "start_block_id: " << start_block_id << " end_block_id: " << end_block_id; auto tx = co_await database_->begin_transaction(); const auto chain_storage = tx->make_storage(); try { BlockReader block_reader{*chain_storage, *tx}; const auto start_block_num = co_await block_reader.get_block_num(start_block_id); const auto end_block_num = co_await block_reader.get_block_num(end_block_id); if (end_block_num < start_block_num) { std::stringstream msg; msg << "start block (" << start_block_num << ") must be less or equal to end block (" << end_block_num << ")"; throw std::invalid_argument(msg.str()); } const auto latest_block_num = co_await block_reader.get_block_num(kLatestBlockId); const auto addresses = co_await get_modified_accounts(*tx, start_block_num, end_block_num + 1, latest_block_num); reply = make_json_content(request, addresses); } catch (const std::invalid_argument& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_getmodifiedaccountsbyhash Task DebugRpcApi::handle_debug_get_modified_accounts_by_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.empty() || params.size() > 2) { auto error_msg = "invalid debug_getModifiedAccountsByHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto start_hash = params[0].get(); auto end_hash = start_hash; if (params.size() == 2) { end_hash = params[1].get(); } SILK_DEBUG << "start_hash: " << silkworm::to_hex(start_hash) << " end_hash: " << silkworm::to_hex(end_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto start_block_num = co_await chain_storage->read_block_num(start_hash); if (!start_block_num) { throw std::invalid_argument("start block " + silkworm::to_hex(start_hash) + " not found"); } const auto end_block_num = co_await chain_storage->read_block_num(end_hash); if (!end_block_num) { throw std::invalid_argument("end block " + silkworm::to_hex(end_hash) + " not found"); } const auto latest_block_num = co_await block_reader.get_block_num(kLatestBlockId); const auto addresses = co_await get_modified_accounts(*tx, *start_block_num, *end_block_num + 1, latest_block_num); reply = make_json_content(request, addresses); } catch (const std::invalid_argument& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_storagerangeat Task DebugRpcApi::handle_debug_storage_range_at(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.empty() || params.size() > 5) { auto error_msg = "invalid debug_storageRangeAt params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto block_hash = params[0].get(); auto tx_index = params[1].get(); auto address = params[2].get(); auto start_key = params[3].get(); auto max_result = params[4].get(); SILK_DEBUG << "block_hash: 0x" << silkworm::to_hex(block_hash) << " tx_index: " << tx_index << " address: " << address << " start_key: 0x" << silkworm::to_hex(start_key) << " max_result: " << max_result; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto header = co_await chain_storage->read_header(block_hash); if (!header) { SILK_WARN << "debug_storage_range_at: block not found, hash: " << evmc::hex(block_hash); nlohmann::json result = {{"storage", nullptr}, {"nextKey", nullptr}}; reply = make_json_content(request, result); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } nlohmann::json storage({}); silkworm::Bytes next_key; std::uint16_t count{0}; StorageWalker::StorageCollector collector = [&](const ByteView key, ByteView sec_key, ByteView value) { SILK_TRACE << "StorageCollector: suitable for result" << " key: 0x" << silkworm::to_hex(key) << " sec_key: 0x" << silkworm::to_hex(sec_key) << " value: " << silkworm::to_hex(value); auto val = silkworm::to_hex(value); val.insert(0, 64 - val.size(), '0'); if (count < max_result) { storage["0x" + silkworm::to_hex(sec_key)] = {{"key", "0x" + silkworm::to_hex(key)}, {"value", "0x" + val}}; } else { next_key = key; } return count++ < max_result; }; const auto min_tx_num = co_await tx->first_txn_num_in_block(header->number); const auto from_tx_num = min_tx_num + tx_index + 1; // for system txn in the beginning of block StorageWalker storage_walker{*tx}; co_await storage_walker.storage_range_at(from_tx_num, address, start_key, collector); nlohmann::json result = {{"storage", storage}}; if (next_key.empty()) { result["nextKey"] = nlohmann::json(); } else { result["nextKey"] = "0x" + silkworm::to_hex(next_key); } reply = make_json_content(request, result); } catch (const std::invalid_argument&) { nlohmann::json result = {{"storage", nullptr}, {"nextKey", nullptr}}; reply = make_json_content(request, result); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debugdebugaccountat Task DebugRpcApi::handle_debug_account_at(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.empty() || params.size() < 3) { auto error_msg = "invalid debug_accountAt params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto block_hash = params[0].get(); auto tx_index = params[1].get(); auto address = params[2].get(); SILK_DEBUG << "block_hash: 0x" << silkworm::to_hex(block_hash) << " tx_index: " << tx_index << " address: " << address; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (!block_with_hash) { reply = make_json_content(request, nlohmann::detail::value_t::null); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto& block = block_with_hash->block; auto block_num = block.header.number; const auto& transactions = block.transactions; SILK_TRACE << "Block number: " << block_num << " #tnx: " << transactions.size(); const auto min_tx_num = co_await tx->first_txn_num_in_block(block_with_hash->block.header.number); db::kv::api::GetAsOfRequest query_account{ .table = std::string{db::table::kAccountDomain}, .key = db::account_domain_key(address), .timestamp = static_cast(min_tx_num + tx_index + 1), }; const auto result = co_await tx->get_as_of(std::move(query_account)); nlohmann::json json_result{}; if (!result.success || result.value.empty()) { json_result["balance"] = "0x0"; json_result["code"] = "0x"; json_result["codeHash"] = "0x0000000000000000000000000000000000000000000000000000000000000000"; json_result["nonce"] = "0x0"; reply = make_json_content(request, json_result); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto account{db::state::AccountCodec::from_encoded_storage_v3(result.value)}; if (account) { json_result["nonce"] = rpc::to_quantity(account->nonce); json_result["balance"] = "0x" + intx::to_string(account->balance, 16); json_result["codeHash"] = account->code_hash; db::kv::api::GetAsOfRequest query_code{ .table = std::string{db::table::kCodeDomain}, .key = db::account_domain_key(address), .timestamp = static_cast(min_tx_num + tx_index), }; const auto code = co_await tx->get_as_of(std::move(query_code)); json_result["code"] = "0x" + silkworm::to_hex(code.value); } else { json_result["balance"] = "0x0"; json_result["code"] = "0x"; json_result["codeHash"] = "0x0000000000000000000000000000000000000000000000000000000000000000"; json_result["nonce"] = "0x0"; } reply = make_json_content(request, json_result); } catch (const std::invalid_argument& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_tracetransaction Task DebugRpcApi::handle_debug_trace_transaction(const nlohmann::json& request, json::Stream& stream) { const auto& params = request["params"]; if (params.empty()) { auto error_msg = "invalid debug_traceTransaction params: " + params.dump(); SILK_ERROR << error_msg; const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } const auto transaction_hash = params[0].get(); debug::DebugConfig config; if (params.size() > 1) { config = params[1].get(); } SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash) << " config: {" << config << "}"; stream.open_object(); stream.write_json_field("id", request["id"]); stream.write_field("jsonrpc", "2.0"); auto tx = co_await database_->begin_transaction(); try { debug::DebugExecutor executor{*block_cache_, workers_, *tx, config}; const auto chain_storage = tx->make_storage(); co_await executor.trace_transaction(stream, *chain_storage, transaction_hash); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); const Error error{kInternalError, e.what()}; stream.write_json_field("error", error); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); const Error error{kServerError, "unexpected exception"}; stream.write_json_field("error", error); } stream.close_object(); co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_tracecall Task DebugRpcApi::handle_debug_trace_call(const nlohmann::json& request, json::Stream& stream) { const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid debug_traceCall params: " + params.dump(); SILK_ERROR << error_msg; const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } const auto call = params[0].get(); const auto block_num_or_hash = params[1].get(); debug::DebugConfig config; if (params.size() > 2) { config = params[2].get(); } SILK_DEBUG << "call: " << call << " block_num_or_hash: " << block_num_or_hash << " config: {" << config << "}"; stream.open_object(); stream.write_json_field("id", request["id"]); stream.write_field("jsonrpc", "2.0"); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const bool is_latest_block = co_await block_reader.is_latest_block_num(block_num_or_hash); debug::DebugExecutor executor{*block_cache_, workers_, *tx, config}; co_await executor.trace_call(stream, block_num_or_hash, *chain_storage, call, is_latest_block); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); std::ostringstream oss; if (block_num_or_hash.hash()) oss << "block " << silkworm::to_hex(block_num_or_hash.hash()) << " not found"; else { oss << "block " << block_num_or_hash.number() << " not found"; } const Error error{kServerError, oss.str()}; stream.write_json_field("error", error); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); const Error error{kServerError, "unexpected exception"}; stream.write_json_field("error", error); } stream.close_object(); co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_tracecallmany Task DebugRpcApi::handle_debug_trace_call_many(const nlohmann::json& request, json::Stream& stream) { if (!request.contains("params")) { auto error_msg = "missing value for required arguments"; SILK_ERROR << error_msg << request.dump(); const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid debug_traceCallMany params: " + params.dump(); SILK_ERROR << error_msg; const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } const auto bundles = params[0].get(); if (bundles.empty()) { const auto error_msg = "invalid debug_traceCallMany bundle list: " + params.dump(); SILK_ERROR << error_msg; const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } const auto simulation_context = params[1].get(); debug::DebugConfig config; if (params.size() > 2) { config = params[2].get(); } SILK_DEBUG << "bundles: " << bundles << " simulation_context: " << simulation_context << " config: {" << config << "}"; stream.open_object(); stream.write_json_field("id", request["id"]); stream.write_field("jsonrpc", "2.0"); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const bool is_latest_block = co_await block_reader.is_latest_block_num(simulation_context.block_num); debug::DebugExecutor executor{*block_cache_, workers_, *tx, config}; co_await executor.trace_call_many(stream, *chain_storage, bundles, simulation_context, is_latest_block); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); const Error error{kServerError, "unexpected exception"}; stream.write_json_field("error", error); } stream.close_object(); co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_traceblockbynumber Task DebugRpcApi::handle_debug_trace_block_by_number(const nlohmann::json& request, json::Stream& stream) { const auto& params = request["params"]; if (params.empty()) { auto error_msg = "invalid debug_traceBlockByNumber params: " + params.dump(); SILK_ERROR << error_msg; const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } auto tx = co_await database_->begin_transaction(); BlockNum block_num{0}; if (params[0].is_string()) { auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto value = params[0].get(); block_num = co_await block_reader.get_block_num(value); } else { block_num = params[0].get(); } debug::DebugConfig config; if (params.size() > 1) { config = params[1].get(); } SILK_DEBUG << "block_num: " << block_num << " config: {" << config << "}"; stream.open_object(); stream.write_json_field("id", request["id"]); stream.write_field("jsonrpc", "2.0"); try { const auto chain_storage = tx->make_storage(); debug::DebugExecutor executor{*block_cache_, workers_, *tx, config}; co_await executor.trace_block(stream, *chain_storage, block_num); } catch (const std::invalid_argument& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); std::ostringstream oss; oss << "block_num " << block_num << " not found"; const Error error{kServerError, oss.str()}; stream.write_json_field("error", error); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); const Error error{kInternalError, e.what()}; stream.write_json_field("error", error); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); const Error error{kServerError, "unexpected exception"}; stream.write_json_field("error", error); } stream.close_object(); co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/retesteth/wiki/RPC-Methods#debug_traceblockbyhash Task DebugRpcApi::handle_debug_trace_block_by_hash(const nlohmann::json& request, json::Stream& stream) { const auto& params = request["params"]; if (params.empty()) { auto error_msg = "invalid debug_traceBlockByHash params: " + params.dump(); SILK_ERROR << error_msg; const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } const auto block_hash = params[0].get(); debug::DebugConfig config; if (params.size() > 1) { config = params[1].get(); } SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash) << " config: {" << config << "}"; stream.open_object(); stream.write_json_field("id", request["id"]); stream.write_field("jsonrpc", "2.0"); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); debug::DebugExecutor executor{*block_cache_, workers_, *tx, config}; co_await executor.trace_block(stream, *chain_storage, block_hash); } catch (const std::invalid_argument& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); std::ostringstream oss; oss << "block_hash " << silkworm::to_hex(block_hash) << " not found"; const Error error{kServerError, oss.str()}; stream.write_json_field("error", error); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); const Error error{kInternalError, e.what()}; stream.write_json_field("error", error); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); const Error error{kServerError, "unexpected exception"}; stream.write_json_field("error", error); } stream.close_object(); co_await tx->close(); // RAII not (yet) available with coroutines } Task> get_modified_accounts(db::kv::api::Transaction& tx, BlockNum start_block_num, BlockNum end_block_num, BlockNum latest_block_num) { SILK_DEBUG << "latest: " << latest_block_num << " start: " << start_block_num << " end: " << end_block_num; if (start_block_num > latest_block_num) { std::stringstream msg; msg << "start block (" << start_block_num << ") is later than the latest block (" << latest_block_num << ")"; throw std::invalid_argument(msg.str()); } if (end_block_num > latest_block_num) { std::stringstream msg; msg << "end block (" << end_block_num << ") is later than the latest block (" << latest_block_num << ")"; throw std::invalid_argument(msg.str()); } const auto start_txn_number = co_await tx.first_txn_num_in_block(start_block_num); const auto end_txn_number = co_await tx.first_txn_num_in_block(end_block_num == start_block_num ? end_block_num + 1 : end_block_num) - 1; db::kv::api::HistoryRangeRequest query{ .table = std::string{db::table::kAccountDomain}, .from_timestamp = static_cast(start_txn_number), .to_timestamp = static_cast(end_txn_number), .ascending_order = true}; auto paginated_result = co_await tx.history_range(std::move(query)); auto it = co_await paginated_result.begin(); std::set addresses; while (const auto value = co_await it->next()) { addresses.insert(bytes_to_address(value->first)); } co_return addresses; } Task DebugRpcApi::handle_debug_get_raw_block(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid debug_getRawBlock params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].get(); SILK_DEBUG << "block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); silkworm::Block block; if (!(co_await chain_storage->read_canonical_block(block_num, block))) { throw std::invalid_argument("block not found"); } Bytes encoded_block; rlp::encode(encoded_block, block); reply = make_json_content(request, silkworm::to_hex(encoded_block, true)); } catch (const std::invalid_argument& iv) { SILK_ERROR << "exception: " << iv.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, iv.what()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task DebugRpcApi::handle_debug_get_raw_receipts(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid debug_getRawReceipts params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_num_or_hash = params[0].get(); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(*block_cache_, block_num_or_hash); if (!block_with_hash) { reply = make_json_content(request, nullptr); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } auto receipts_ptr = co_await core::get_receipts(*tx, *block_with_hash, *chain_storage, workers_, /*extended_receipt_info=*/false); auto& receipts = *receipts_ptr; SILK_TRACE << "#receipts: " << receipts.size(); std::vector raw_receipts; for (auto& rpc_receipt : receipts) { silkworm::Receipt core_receipt{ .type = rpc_receipt->type, .success = rpc_receipt->success, .cumulative_gas_used = rpc_receipt->cumulative_gas_used, .bloom = rpc_receipt->bloom, }; for (auto& log : rpc_receipt->logs) { core_receipt.logs.push_back(silkworm::Log{ .address = log.address, .topics = log.topics, .data = log.data, }); } Bytes receipt_rlp; rlp::encode(receipt_rlp, core_receipt); raw_receipts.push_back(silkworm::to_hex(receipt_rlp, /*with_prefix=*/true)); } reply = make_json_content(request, raw_receipts); } catch (const std::invalid_argument& iv) { SILK_ERROR << "exception: " << iv.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, iv.what()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task DebugRpcApi::handle_debug_get_raw_header(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid debug_getRawHeader params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].get(); SILK_DEBUG << "block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_hash = co_await chain_storage->read_canonical_header_hash(block_num); const auto header = co_await chain_storage->read_header(block_num, block_hash->bytes); if (!header) { throw std::invalid_argument("header not found"); } Bytes encoded_header; rlp::encode(encoded_header, *header); reply = make_json_content(request, silkworm::to_hex(encoded_header, true)); } catch (const std::invalid_argument& iv) { SILK_ERROR << "exception: " << iv.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, iv.what()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task DebugRpcApi::handle_debug_get_raw_transaction(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid debug_getRawTransaction params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; Bytes rlp{}; co_await chain_storage->read_rlp_transaction(transaction_hash, rlp); reply = make_json_content(request, silkworm::to_hex(rlp, /*with_prefix=*/true)); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, iv.what()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/debug_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class DebugRpcApi { public: DebugRpcApi(boost::asio::io_context& ioc, WorkerPool& workers) : ioc_{ioc}, block_cache_{must_use_shared_service(ioc_)}, state_cache_{must_use_shared_service(ioc_)}, database_{must_use_private_service(ioc_)->service()}, workers_{workers}, backend_{must_use_private_service(ioc_)} {} virtual ~DebugRpcApi() = default; DebugRpcApi(const DebugRpcApi&) = delete; DebugRpcApi& operator=(const DebugRpcApi&) = delete; DebugRpcApi(DebugRpcApi&&) = default; protected: Task handle_debug_account_range(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_get_modified_accounts_by_number(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_storage_range_at(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_account_at(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_get_modified_accounts_by_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_trace_transaction(const nlohmann::json& request, json::Stream& stream); Task handle_debug_trace_call(const nlohmann::json& request, json::Stream& stream); Task handle_debug_trace_call_many(const nlohmann::json& request, json::Stream& stream); Task handle_debug_trace_block_by_number(const nlohmann::json& request, json::Stream& stream); Task handle_debug_trace_block_by_hash(const nlohmann::json& request, json::Stream& stream); Task handle_debug_get_raw_block(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_get_raw_header(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_get_raw_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_debug_get_raw_receipts(const nlohmann::json& request, nlohmann::json& reply); private: boost::asio::io_context& ioc_; BlockCache* block_cache_; db::kv::api::StateCache* state_cache_; std::shared_ptr database_; WorkerPool& workers_; ethbackend::BackEnd* backend_; friend class silkworm::rpc::json_rpc::RequestHandler; }; Task> get_modified_accounts(db::kv::api::Transaction& tx, BlockNum start_block_num, BlockNum end_block_num, BlockNum latest_block_num); } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/debug_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "debug_api.hpp" #include #include #include #if !defined(__clang__) #include #endif // !defined(__clang__) #include #include #include #include #include #include #if !defined(__clang__) #include #endif // !defined(__clang__) #include #include #include #if !defined(__clang__) #include #endif // !defined(__clang__) #include namespace silkworm::rpc::commands { using testing::Unused; using namespace evmc::literals; using PaginatedKV = db::kv::api::PaginatedSequencePair; using PaginatorKV = PaginatedKV::Paginator; using PageResultKV = PaginatedKV::PageResult; #ifndef SILKWORM_SANITIZE TEST_CASE("DebugRpcApi") { boost::asio::io_context ioc; add_shared_service(ioc, std::make_shared()); add_shared_service(ioc, std::make_shared()); WorkerPool workers{1}; SECTION("CTOR") { CHECK_THROWS_AS(DebugRpcApi(ioc, workers), std::logic_error); } } // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task { co_return 0; })); EXPECT_CALL(transaction, first_txn_num_in_block(0x52a011)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return 20; })); db::kv::api::HistoryRangeRequest request{ .table = std::string{db::table::kAccountDomain}, .from_timestamp = static_cast(0), .to_timestamp = static_cast(19), .ascending_order = true}; EXPECT_CALL(transaction, history_range(std::move(request))).WillOnce(Invoke([=](Unused) -> Task { PaginatorKV paginator = [](auto next_page_token) -> Task { co_return PageResultKV{ .keys = {*from_hex("07aaec0b237ccf56b03a7c43c1c7a783da5606420501010101")}, .values = {Bytes{}}, // encoded account value doesn't care .next_page_token = std::move(next_page_token)}; }; db::kv::api::PaginatedKeysValues result{paginator}; co_return db::kv::api::KeyValueStreamReply{result}; })); auto result = boost::asio::co_spawn(pool, get_modified_accounts(tx, 0x52a010, 0x52a010, 0x800000), boost::asio::use_future); const auto accounts = result.get(); nlohmann::json j = accounts; CHECK(j == R"([ "0x07aaec0b237ccf56b03a7c43c1c7a783da560642" ])"_json); } #ifdef notdef SECTION("end == start + 1") { auto result = boost::asio::co_spawn(pool, get_modified_accounts(*tx, 0x52a010, 0x52a011), boost::asio::use_future); auto accounts = result.get(); std::cout << "size2: " << accounts.size() << "\n"; CHECK(accounts.size() == 2); nlohmann::json j = accounts; CHECK(j == R"([ "0x07aaec0b237ccf56b03a7c43c1c7a783da560642", "0x0c7b6617b9bc0d20f4030ee079d355246246ef70" ])"_json); } SECTION("end >> start") { auto result = boost::asio::co_spawn(pool, get_modified_accounts(*tx, 0x52a010, 0x52a058), boost::asio::use_future); auto accounts = result.get(); CHECK(accounts.size() == 70); nlohmann::json j = accounts; CHECK(j == R"([ "0x053eafe07f12033715d31e1599bbf27dd1c05fb2", "0x07aaec0b237ccf56b03a7c43c1c7a783da560642", "0x0c7b6617b9bc0d20f4030ee079d355246246ef70", "0x15b1281f4e58215b2c3243d864bdf8b9dddc0da2", "0x1a99fb83141a5129a79ed062f6b643b0d4f4770e", "0x1b6bf510562cc62b28d23267ab1477dc936405bc", "0x209d9af3b5c8fa05d0663db92863ebff7a2f1fff", "0x22ea9f6b28db76a7162054c05ed812deb2f519cd", "0x23b790f50dacb056c5e1ef6bc33fde744a739633", "0x29f030109f19ff6ee9da1257c96620e50725617c", "0x2d734d0528bc9fb2722eb639dd3ecd1ece09b69e", "0x300e056ec74f9c1189a5cbb22ba46db848d8934c", "0x30d9ed9054681c56bf3cff638b4f3109ed06339a", "0x311f29bf022343f621278cb3cc8137f8f14ead09", "0x329254a40454288f4425220aa6c4173097025e93", "0x3432169802ba50d1a2bdbb012cfc449bc4f92c81", "0x3546ff99566fadff510fa0befa5b6279e6bc54b9", "0x3dfbfdf2fdb29d1976d70483eff7552de991be5c", "0x43966453636059ae8b30678b0475550fa53d9eba", "0x44bb73af73388f6c21f2ce8acda594172897d125", "0x4a3a65a271c40fb77ecfd032e0e15a12f975af7b", "0x4ba4880d287d504e503bc5883848cbcce839e495", "0x4f980a3ef05eaf6eb2395d8a48594b08502b9033", "0x4faa6c7f9ef1c3b575a4075ed4504108a7020ed0", "0x50d1443617147cf86f88296780574b40075139a5", "0x56768b032fc12d2e911ef654b0054e26a58cef74", "0x5c3f649ffdbc91a247ac45fc2c4c63f9319e5135", "0x5c954304085df2c17b9931b32129c42f894133dc", "0x6eec6a64fb1202e0d3fb3b3e6a3793f13df5cf61", "0x71b4daebdab8779a98343981a9a574366f45ee6b", "0x784798960e52dde47705f1aa1c21243ea8222dda", "0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb", "0x7ae250731360126a6f427a55c464134c3d2a9806", "0x80a79aac8921189f330db4f2e11f9653dde41ce2", "0x8348b5cd154ad11142353bf456a64bd15fe83a86", "0x861ca2f5ff2e03f90d2c3eafda88752fbffc6a69", "0x88231b2c9e726682d0282602fe33c38388cd89b2", "0x884173ac82bad835f297d54a2a71a369efe699b9", "0x89a284bd0f69a20778f9beba68a9b480957d7305", "0x8a555368749434957ea005ce23a61d41277bd8ab", "0x8bb2dc06b366a48fbf98824e2d30387b1d8c7488", "0x8dde3d034d5b77ab3102f2626310f63821226a1c", "0x901e370c28193fa207f2a6a515c18756db9557f7", "0x9a46a5638e41398310908b9194c89dd68582e12d", "0x9d1aae2c506f490e54f2a3f4d2f112e5f200709b", "0xab6cdb8b305f56d25e6b9a4ba50889a816e51cd2", "0xac72aeaced951f4da6695dee73c2f1b49e035949", "0xb1b19eff752019cd5108dbef2ff56eb1dd0bb063", "0xb344147ea92cf102cd92ec996b8986ddca4a918e", "0xbe22ac13ad6af062843eb33adfccfee6bbb4481b", "0xbe996442926a46e76b67eb7279f29adb3a7d6a2f", "0xc19875766825120516450c3754b8ab84fa6e7541", "0xc76d89d7322fcfe90e7c192a7bef5d3cf2212026", "0xc92047cec2355293a9e3710e32851f3509e7313e", "0xca3cd40edc45d29b28442e87892a32b020076d59", "0xcb9ec8584681f4ffc23029eb5d303370e2112b64", "0xd0b96c8ab7cedad79185999efbfb20ebdc92bf0d", "0xd2df9c09b885f69fcf4c12caa03a443d33a21b88", "0xd65fa0e9e05ee6015e1f7839068c467f57d58fac", "0xd978cc9c7a93935fecd66c96e2df5f363dc63bc8", "0xd9a5179f091d85051d3c982785efd1455cec8699", "0xe7a92c9bbace40d323db6abcb3b6900bdea0a184", "0xe9d5dd241732f2577a1b91d9b297ced3ed232a94", "0xed2b73e5a912ac2010dbf0d35515d4873cd9e669", "0xf14cd6286564e44223ad6aee242623bf4398f99d", "0xf3a3956d084e3f2a24add02c35c8afd09e3e9bf5", "0xf74a5ca65e4552cff0f13b116113ccb493c580c5", "0xfa08751e2097c5ba14052082ce2bf52a58c8a5be", "0xfb3b466500abc6b9c89192a81501aec6c677eee4", "0xfc7a377f85ec306da55f32eccbb7cff2389f569f" ])"_json); } SECTION("start > end") { auto result = boost::asio::co_spawn(pool, get_modified_accounts(*tx, 0x52a011, 0x52a010), boost::asio::use_future); auto accounts = result.get(); CHECK(accounts.empty()); } SECTION("start > last block") { auto result = boost::asio::co_spawn(pool, get_modified_accounts(*tx, 0x52a061, 0x52a061), boost::asio::use_future); CHECK_THROWS_AS(result.get(), std::invalid_argument); } #endif } #endif // !defined(__clang__) && !defined(_WIN32) #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/engine_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "engine_api.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { using namespace std::chrono_literals; // Engine API standard timeouts static constexpr std::chrono::seconds kGetPayloadTimeout{1s}; static constexpr std::chrono::seconds kGetPayloadBodiesTimeout{10s}; static constexpr std::chrono::seconds kNewPayloadTimeout{8s}; static constexpr std::chrono::seconds kForkChoiceUpdatedTimeout{8s}; static constexpr evmc::bytes32 kZeroHash = 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32; // https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md#engine_exchangecapabilities Task EngineRpcApi::handle_engine_exchange_capabilities( // NOLINT(readability-convert-member-functions-to-static) const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_exchangeCapabilities params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto cl_capabilities = params[0].get(); SILK_DEBUG << "RemoteBackEnd::engine_exchange_capabilities consensus layer capabilities: " << cl_capabilities; const Capabilities el_capabilities{ "engine_getClientVersionV1", "engine_newPayloadV1", "engine_newPayloadV2", "engine_newPayloadV3", "engine_newPayloadV4", "engine_forkchoiceUpdatedV1", "engine_forkchoiceUpdatedV2", "engine_forkchoiceUpdatedV3", "engine_getPayloadV1", "engine_getPayloadV2", "engine_getPayloadV3", "engine_getPayloadV4", "engine_getPayloadBodiesByHashV1", "engine_getPayloadBodiesByRangeV1", "engine_exchangeTransitionConfigurationV1", }; SILK_DEBUG << "RemoteBackEnd::engine_exchange_capabilities execution layer capabilities: " << el_capabilities; reply = make_json_content(request, el_capabilities); } // https://github.com/ethereum/execution-apis/blob/main/src/engine/identification.md#ClientVersionV1 Task EngineRpcApi::handle_engine_get_client_version_v1(const nlohmann::json& request, std::string& reply) { const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_getClientVersionV1 params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } make_glaze_json_content(request, build_info_, reply); } // https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#engine_getpayloadv1 Task EngineRpcApi::handle_engine_get_payload_v1(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_getPayloadV1 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } #ifndef BUILD_COVERAGE try { #endif const auto payload_quantity = params[0].get(); const auto payload_and_value = co_await engine_->get_payload(from_quantity(payload_quantity), kGetPayloadTimeout); reply = make_json_content(request, payload_and_value.payload); #ifndef BUILD_COVERAGE } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } #endif } // https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_getpayloadv2 Task EngineRpcApi::handle_engine_get_payload_v2(const nlohmann::json& request, nlohmann::json& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_getPayloadV2 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto payload_quantity = params[0].get(); const auto payload_and_value = co_await engine_->get_payload(from_quantity(payload_quantity), kGetPayloadTimeout); reply = make_json_content(request, payload_and_value); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#engine_getpayloadv3 Task EngineRpcApi::handle_engine_get_payload_v3(const nlohmann::json& request, nlohmann::json& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_getPayloadV3 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto payload_quantity = params[0].get(); // TODO(canepat) we need a way to specify V3 i.e. blobs should be returned (hint: use versioned struct PayloadIdentifier) const auto payload_and_value = co_await engine_->get_payload(from_quantity(payload_quantity), kGetPayloadTimeout); reply = make_json_content(request, payload_and_value); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#engine_getpayloadv4 Task EngineRpcApi::handle_engine_get_payload_v4(const nlohmann::json& request, nlohmann::json& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_getPayloadV4 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto payload_quantity = params[0].get(); const auto payload_and_value = co_await engine_->get_payload(from_quantity(payload_quantity), kGetPayloadTimeout); reply = make_json_content(request, payload_and_value); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_getpayloadbodiesbyhashv1 Task EngineRpcApi::handle_engine_get_payload_bodies_by_hash_v1(const nlohmann::json& request, nlohmann::json& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_getPayloadBodiesByHashV1 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto block_hashes = params[0].get>(); // We MUST support at least 32 block hashes and MUST check if number is too large for us [Specification 3.] if (block_hashes.size() > 32) { const auto error_msg = "number of block hashes > 32 is too large"; SILK_ERROR << error_msg; reply = make_json_error(request, kTooLargeRequest, error_msg); } const auto payload_bodies = co_await engine_->get_payload_bodies_by_hash(block_hashes, kGetPayloadBodiesTimeout); reply = make_json_content(request, payload_bodies); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_getpayloadbodiesbyrangev1 Task EngineRpcApi::handle_engine_get_payload_bodies_by_range_v1(const nlohmann::json& request, nlohmann::json& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto& params = request.at("params"); if (params.size() != 2) { auto error_msg = "invalid engine_getPayloadBodiesByRangeV1 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto start = from_quantity(params[0].get()); const auto count = from_quantity(params[1].get()); if (count == 0) { const auto error_msg = "count 0 is invalid"; SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } // We MUST support count values of at least 32 and MUST check if number is too large for us [Specification 2.] if (count > 32) { const auto error_msg = "count value > 32 is too large"; SILK_ERROR << error_msg; reply = make_json_error(request, kTooLargeRequest, error_msg); co_return; } const auto payload_bodies = co_await engine_->get_payload_bodies_by_range(start, count, kGetPayloadBodiesTimeout); reply = make_json_content(request, payload_bodies); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#engine_newpayloadv1 Task EngineRpcApi::handle_engine_new_payload_v1(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_newPayloadV1 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } #ifndef BUILD_COVERAGE try { #endif auto payload = params[0].get(); NewPayloadRequest new_payload_v1_request{.execution_payload = std::move(payload)}; const auto new_payload = co_await engine_->new_payload(new_payload_v1_request, kNewPayloadTimeout); reply = make_json_content(request, new_payload); #ifndef BUILD_COVERAGE } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } #endif } // https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_newpayloadv2 Task EngineRpcApi::handle_engine_new_payload_v2(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_newPayloadV2 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto payload = params[0].get(); auto tx = co_await database_->begin_transaction(); #ifndef BUILD_COVERAGE try { #endif const auto storage{tx->make_storage()}; const auto config{co_await storage->read_chain_config()}; ensure(config.shanghai_time.has_value(), "execution layer has no Shanghai timestamp in configuration"); // We MUST check that CL has sent the expected ExecutionPayload version [Specification for params] if (payload.timestamp < config.shanghai_time && payload.version != ExecutionPayload::kV1) { const auto error_msg = "consensus layer must use ExecutionPayloadV1 if timestamp lower than Shanghai"; SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_await tx->close(); co_return; } if (payload.timestamp >= config.shanghai_time && payload.version != ExecutionPayload::kV2) { const auto error_msg = "consensus layer must use ExecutionPayloadV2 if timestamp greater or equal to Shanghai"; SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_await tx->close(); co_return; } if (config.cancun_time && payload.timestamp >= config.cancun_time) { const auto error_msg = "consensus layer must use ExecutionPayloadV3 if timestamp greater or equal to Cancun"; SILK_ERROR << error_msg; reply = make_json_error(request, kUnsupportedFork, error_msg); co_await tx->close(); co_return; } NewPayloadRequest new_payload_v2_request{.execution_payload = std::move(payload)}; const auto new_payload = co_await engine_->new_payload(new_payload_v2_request, kNewPayloadTimeout); reply = make_json_content(request, new_payload); #ifndef BUILD_COVERAGE } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } #endif co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#engine_newpayloadv3 Task EngineRpcApi::handle_engine_new_payload_v3(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 3) { auto error_msg = "invalid engine_newPayloadV3 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto payload = params[0].get(); auto expected_blob_versioned_hashes = params[1].get>(); auto parent_beacon_block_root = params[2].get(); auto tx = co_await database_->begin_transaction(); #ifndef BUILD_COVERAGE try { #endif const auto storage{tx->make_storage()}; const auto config{co_await storage->read_chain_config()}; ensure(config.shanghai_time.has_value(), "execution layer has no Shanghai timestamp in configuration"); ensure(config.cancun_time.has_value(), "execution layer has no Cancun timestamp in configuration"); // We MUST check that CL has sent the expected ExecutionPayload version [Specification for params] if (payload.timestamp >= config.cancun_time && payload.version != ExecutionPayload::kV3) { const auto error_msg = "consensus layer must use ExecutionPayloadV3 if timestamp greater or equal to Cancun"; SILK_ERROR << error_msg; reply = make_json_error(request, kUnsupportedFork, error_msg); co_await tx->close(); co_return; } NewPayloadRequest new_payload_v3_request{ .execution_payload = std::move(payload), .expected_blob_versioned_hashes = std::move(expected_blob_versioned_hashes), .parent_beacon_block_root = parent_beacon_block_root, }; const auto new_payload = co_await engine_->new_payload(new_payload_v3_request, kNewPayloadTimeout); reply = make_json_content(request, new_payload); #ifndef BUILD_COVERAGE } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } #endif co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/execution-apis/blob/main/src/engine/prague.md#engine_newpayloadv4 Task EngineRpcApi::handle_engine_new_payload_v4(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 3) { auto error_msg = "invalid engine_newPayloadV4 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto payload = params[0].get(); auto expected_blob_versioned_hashes = params[1].get>(); auto parent_beacon_block_root = params[2].get(); auto execution_requests = params[3].get>(); auto tx = co_await database_->begin_transaction(); #ifndef BUILD_COVERAGE try { #endif const auto storage{tx->make_storage()}; const auto config{co_await storage->read_chain_config()}; ensure(config.shanghai_time.has_value(), "execution layer has no Shanghai timestamp in configuration"); ensure(config.cancun_time.has_value(), "execution layer has no Cancun timestamp in configuration"); ensure(config.prague_time.has_value(), "execution layer has no Prague timestamp in configuration"); // We MUST check that CL has sent the expected ExecutionPayload version [Specification for params] if (payload.timestamp < config.prague_time) { const auto error_msg = "consensus layer must use ExecutionPayloadV4 if timestamp greater or equal to Prague"; SILK_ERROR << error_msg; reply = make_json_error(request, kUnsupportedFork, error_msg); co_await tx->close(); co_return; } NewPayloadRequest new_payload_v4_request{ .execution_payload = std::move(payload), .expected_blob_versioned_hashes = std::move(expected_blob_versioned_hashes), .parent_beacon_block_root = parent_beacon_block_root, .execution_requests = execution_requests}; const auto new_payload = co_await engine_->new_payload(new_payload_v4_request, kNewPayloadTimeout); reply = make_json_content(request, new_payload); #ifndef BUILD_COVERAGE } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } #endif co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#engine_forkchoiceupdatedv1 Task EngineRpcApi::handle_engine_forkchoice_updated_v1(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1 && params.size() != 2) { auto error_msg = "invalid engine_forkchoiceUpdatedV1 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } #ifndef BUILD_COVERAGE try { #endif const auto fork_choice_state = params[0].get(); // We MUST check that ForkChoiceState is valid and consistent [Paris Specification 8.] if (const auto res{validate_fork_choice_state_v1(fork_choice_state)}; !res) { const auto [error_code, error_msg] = res.error(); SILK_ERROR << error_msg; reply = make_json_error(request, error_code, error_msg); co_return; } std::optional payload_attributes; if (params.size() == 2 && !params[1].is_null()) { payload_attributes = params[1].get(); } const ForkChoiceUpdatedRequest fcu_request{fork_choice_state, payload_attributes}; const auto fcu_reply = co_await engine_->fork_choice_updated(fcu_request, kForkChoiceUpdatedTimeout); reply = make_json_content(request, fcu_reply); #ifndef BUILD_COVERAGE } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } #endif } // https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_forkchoiceupdatedv2 Task EngineRpcApi::handle_engine_forkchoice_updated_v2(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1 && params.size() != 2) { auto error_msg = "invalid engine_forkchoiceUpdatedV2 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto fork_choice_state = params[0].get(); // We MUST check that ForkChoiceState is valid and consistent [Paris Specification 8.] if (const auto res{validate_fork_choice_state_v1(fork_choice_state)}; !res) { const auto [error_code, error_msg] = res.error(); SILK_ERROR << error_msg; reply = make_json_error(request, error_code, error_msg); co_return; } std::optional payload_attributes; if (params.size() == 2 && !params[1].is_null()) { payload_attributes = params[1].get(); } const ForkChoiceUpdatedRequest fcu_request{fork_choice_state, payload_attributes}; const auto fcu_reply = co_await engine_->fork_choice_updated(fcu_request, kForkChoiceUpdatedTimeout); // We MUST check that CL has sent consistent PayloadAttributes [Shanghai Specification 2.] const auto chain_config{co_await read_chain_config()}; if (const auto res{validate_payload_attributes_v2(payload_attributes, fcu_reply, chain_config)}; !res) { const auto [error_code, error_msg] = res.error(); SILK_ERROR << error_msg; reply = make_json_error(request, error_code, error_msg); co_return; } reply = make_json_content(request, fcu_reply); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#engine_forkchoiceupdatedv3 Task EngineRpcApi::handle_engine_forkchoice_updated_v3(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1 && params.size() != 2) { auto error_msg = "invalid engine_forkchoiceUpdatedV3 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto fork_choice_state = params[0].get(); // We MUST check that ForkChoiceState is valid and consistent [Paris Specification 8.] if (const auto res{validate_fork_choice_state_v1(fork_choice_state)}; !res) { const auto [error_code, error_msg] = res.error(); SILK_ERROR << error_msg; reply = make_json_error(request, error_code, error_msg); co_return; } std::optional payload_attributes; if (params.size() == 2 && !params[1].is_null()) { payload_attributes = params[1].get(); } const ForkChoiceUpdatedRequest fcu_request{fork_choice_state, payload_attributes}; const auto fcu_reply = co_await engine_->fork_choice_updated(fcu_request, kForkChoiceUpdatedTimeout); // We MUST check that CL has sent consistent PayloadAttributes [Cancun Specification 2.] const auto chain_config{co_await read_chain_config()}; if (auto res{validate_payload_attributes_v3(payload_attributes, fcu_reply, chain_config)}; !res) { const auto [error_code, error_msg] = res.error(); reply = make_json_error(request, error_code, error_msg); co_return; } reply = make_json_content(request, fcu_reply); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, se.code().value(), se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // Checks if the transition configurations of the Execution Layer is equal to the ones in the Consensus Layer // Format for params is a JSON list of TransitionConfiguration, i.e. [TransitionConfiguration] // https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#TransitionConfigurationV1 Task EngineRpcApi::handle_engine_exchange_transition_configuration_v1(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request.at("params"); if (params.size() != 1) { auto error_msg = "invalid engine_exchangeTransitionConfigurationV1 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto cl_configuration = params[0].get(); auto tx = co_await database_->begin_transaction(); #ifndef BUILD_COVERAGE try { #endif const auto storage{tx->make_storage()}; const auto config{co_await storage->read_chain_config()}; ensure(config.terminal_total_difficulty.has_value(), "execution layer does not have terminal total difficulty"); // We SHOULD check for any configuration mismatch except `terminalBlockNumber` [Specification 2.] if (config.terminal_total_difficulty != cl_configuration.terminal_total_difficulty) { SILK_ERROR << "execution layer has the incorrect terminal total difficulty, expected: " << cl_configuration.terminal_total_difficulty << " got: " << config.terminal_total_difficulty.value(); reply = make_json_error(request, kInvalidParams, "consensus layer terminal total difficulty does not match"); co_await tx->close(); co_return; } if (cl_configuration.terminal_block_hash != kZeroHash) { SILK_ERROR << "execution layer has the incorrect terminal block hash, expected: " << silkworm::to_hex(cl_configuration.terminal_block_hash) << " got: " << silkworm::to_hex(kZeroHash); reply = make_json_error(request, kInvalidParams, "consensus layer terminal block hash is not zero"); co_await tx->close(); co_return; } // We MUST respond with configurable setting values set according to EIP-3675 [Specification 1.] const TransitionConfiguration transition_configuration{ .terminal_total_difficulty = config.terminal_total_difficulty.value(), .terminal_block_hash = kZeroHash, // terminal_block_hash removed from chain_config, return zero .terminal_block_num = 0 // terminal_block_num removed from chain_config, return zero }; reply = make_json_content(request, transition_configuration); #ifndef BUILD_COVERAGE } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } #endif co_await tx->close(); // RAII not (yet) available with coroutines } // https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#forkchoicestatev1 EngineRpcApi::ValidationError EngineRpcApi::validate_fork_choice_state_v1(const ForkChoiceState& state) { // safeBlockHash and finalizedBlockHash are not allowed to be zero because transition block is finalized if (state.safe_block_hash == kZeroHash) { return tl::make_unexpected({kInvalidForkChoiceState, "safe block hash is empty"}); } if (state.finalized_block_hash == kZeroHash) { return tl::make_unexpected({kInvalidForkChoiceState, "finalized block hash is empty"}); } return {}; } // https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_forkchoiceupdatedv2 EngineRpcApi::ValidationError EngineRpcApi::validate_payload_attributes_v2(const std::optional& attributes, const ForkChoiceUpdatedReply& reply, const std::optional& config) { // Payload attributes must be validated only if non-null and FCU is valid if (!attributes || reply.payload_status.status != PayloadStatus::kValidStr) { return {}; } ensure(config.has_value(), "execution layer has invalid configuration"); ensure(config->shanghai_time.has_value(), "execution layer has no Shanghai timestamp in configuration"); if (attributes->timestamp < config->shanghai_time && attributes->version != PayloadAttributes::kV1) { return tl::make_unexpected( {kInvalidParams, "consensus layer must use PayloadAttributesV1 if timestamp lower than Shanghai"}); } if (attributes->timestamp >= config->shanghai_time && attributes->version != PayloadAttributes::kV2) { return tl::make_unexpected( {kInvalidParams, "consensus layer must use PayloadAttributesV2 if timestamp greater or equal to Shanghai"}); } if (attributes->timestamp >= config->cancun_time) { return tl::make_unexpected( {kUnsupportedFork, "consensus layer must use PayloadAttributesV3 if timestamp greater or equal to Cancun"}); } return {}; } EngineRpcApi::ValidationError EngineRpcApi::validate_payload_attributes_v3(const std::optional& attributes, const ForkChoiceUpdatedReply& reply, const std::optional& config) { // Payload attributes must be validated only if non-null and FCU is valid if (!attributes || reply.payload_status.status != PayloadStatus::kValidStr) { return {}; } ensure(config.has_value(), "execution layer has invalid configuration"); ensure(config->shanghai_time.has_value(), "execution layer has no Shanghai timestamp in configuration"); ensure(config->cancun_time.has_value(), "execution layer has no Cancun timestamp in configuration"); if (attributes->timestamp < config->cancun_time) { return tl::make_unexpected( {kUnsupportedFork, "consensus layer must not use PayloadAttributesV3 if timestamp lower than Cancun"}); } if (attributes->timestamp >= config->cancun_time && attributes->version != PayloadAttributes::kV3) { return tl::make_unexpected( {kInvalidPayloadAttributes, "consensus layer must use PayloadAttributesV3 if timestamp greater or equal to Cancun"}); } return {}; } Task> EngineRpcApi::read_chain_config() { auto tx = co_await database_->begin_transaction(); const auto storage{tx->make_storage()}; auto config{co_await storage->read_chain_config()}; co_await tx->close(); co_return config; } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/engine_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class EngineRpcApi { public: EngineRpcApi(std::shared_ptr database, engine::ExecutionEngine* engine, ethbackend::BackEnd* backend, ApplicationInfo build_info = {}) : database_{std::move(database)}, engine_{engine}, backend_{backend}, build_info_{std::move(build_info)} {} explicit EngineRpcApi(boost::asio::io_context& ioc, ApplicationInfo build_info = {}) : EngineRpcApi( must_use_private_service(ioc)->service(), must_use_shared_service(ioc), must_use_private_service(ioc), std::move(build_info)) {} virtual ~EngineRpcApi() = default; EngineRpcApi(const EngineRpcApi&) = delete; EngineRpcApi& operator=(const EngineRpcApi&) = delete; EngineRpcApi(EngineRpcApi&&) = default; protected: Task handle_engine_exchange_capabilities(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_get_client_version_v1(const nlohmann::json& request, std::string& reply); Task handle_engine_get_payload_v1(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_get_payload_v2(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_get_payload_v3(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_get_payload_v4(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_get_payload_bodies_by_hash_v1(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_get_payload_bodies_by_range_v1(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_new_payload_v1(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_new_payload_v2(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_new_payload_v3(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_new_payload_v4(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_forkchoice_updated_v1(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_forkchoice_updated_v2(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_forkchoice_updated_v3(const nlohmann::json& request, nlohmann::json& reply); Task handle_engine_exchange_transition_configuration_v1(const nlohmann::json& request, nlohmann::json& reply); private: // TODO(canepat) remove this method and pass ChainConfig as constructor parameter Task> read_chain_config(); using ApiError = std::pair; using ValidationError = tl::expected; ValidationError validate_fork_choice_state_v1(const ForkChoiceState& state); ValidationError validate_payload_attributes_v2(const std::optional& attributes, const ForkChoiceUpdatedReply& reply, const std::optional& config); ValidationError validate_payload_attributes_v3(const std::optional& attributes, const ForkChoiceUpdatedReply& reply, const std::optional& config); std::shared_ptr database_; engine::ExecutionEngine* engine_; ethbackend::BackEnd* backend_; ApplicationInfo build_info_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/engine_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "engine_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { using db::kv::api::KeyValue; using rpc::test::DummyClient; class EngineRpcApiForTest : public EngineRpcApi { public: explicit EngineRpcApiForTest(boost::asio::io_context& ioc) : EngineRpcApi(ioc) {} using EngineRpcApi::handle_engine_exchange_capabilities; using EngineRpcApi::handle_engine_exchange_transition_configuration_v1; using EngineRpcApi::handle_engine_forkchoice_updated_v1; using EngineRpcApi::handle_engine_get_client_version_v1; using EngineRpcApi::handle_engine_get_payload_v1; using EngineRpcApi::handle_engine_new_payload_v1; }; using testing::_; using testing::InvokeWithoutArgs; struct EngineRpcApiTest : public test_util::JsonApiTestBase { EngineRpcApiTest() : test_util::JsonApiTestBase() { auto local_backend = std::make_unique(); add_private_service(ioc_, std::move(local_backend)); mock_backend = dynamic_cast(must_use_private_service(ioc_)); // NOLINT add_private_service(ioc_, std::make_unique(mock_cursor, mock_cursor_dup_sort, mock_backend)); add_shared_service(ioc_, mock_engine); } test::BackEndMock* mock_backend{nullptr}; std::shared_ptr mock_engine{std::make_shared()}; std::shared_ptr mock_cursor{std::make_shared()}; std::shared_ptr mock_cursor_dup_sort{std::make_shared()}; }; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher( R"({ "jsonrpc":"2.0", "id":1, "method":"engine_exchangeCapabilities", "params":[] })"_json, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32602,"message":"invalid engine_exchangeCapabilities params: []"} })"_json); } SECTION("no CL capabilities is OK and we must return our EL capabilities") { CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_capabilities>( R"({ "jsonrpc":"2.0", "id":1, "method":"engine_exchangeCapabilities", "params":[[]] })"_json, reply)); CHECK(reply == R"({ "id":1, "jsonrpc":"2.0", "result":[ "engine_getClientVersionV1", "engine_newPayloadV1", "engine_newPayloadV2", "engine_newPayloadV3", "engine_newPayloadV4", "engine_forkchoiceUpdatedV1", "engine_forkchoiceUpdatedV2", "engine_forkchoiceUpdatedV3", "engine_getPayloadV1", "engine_getPayloadV2", "engine_getPayloadV3", "engine_getPayloadV4", "engine_getPayloadBodiesByHashV1", "engine_getPayloadBodiesByRangeV1", "engine_exchangeTransitionConfigurationV1" ] })"_json); } } TEST_CASE_METHOD(EngineRpcApiTest, "engine_getClientVersionV1", "[silkworm][rpc][commands][engine_api]") { std::string reply; SECTION("request params is empty: return error") { nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_getClientVersionV1", "params":[] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_get_client_version_v1>(request, reply)); CHECK(reply == R"({"jsonrpc":"2.0","id":1,"error":{"code":-32602,"message":"invalid engine_getClientVersionV1 params: []"}})"); } SECTION("CL client version is present and we must return our EL client version") { nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_getClientVersionV1", "params":[{ "code":"CA", "name":"caplin", "version":"1.0.0", "commit":"aa00bb11" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_get_client_version_v1>(request, reply)); CHECK(reply == R"({"jsonrpc":"2.0","id":1,"result":[{"code":"SW","name":"silkworm","version":"","commit":""}]})"); } } TEST_CASE_METHOD(EngineRpcApiTest, "engine_getPayloadV1 OK: request is expected payload", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_engine, get_payload(1, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return ExecutionPayloadAndValue{ExecutionPayload{.block_num = 1}, 0}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_getPayloadV1", "params":["0x0000000000000001"] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_get_payload_v1>(request, reply)); CHECK(reply == R"({ "id":1, "jsonrpc":"2.0", "result":{ "baseFeePerGas":"0x0", "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber":"0x1", "extraData":"0x", "gasLimit":"0x0", "gasUsed":"0x0", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "receiptsRoot": "0x0000000000000000000000000000000000000000000000000000000000000000", "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000000", "feeRecipient":"0x0000000000000000000000000000000000000000", "timestamp":"0x0", "transactions":null } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_getPayloadV1 KO: invalid amount of params", "[silkworm][rpc][commands][engine_api]") { nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_getPayloadV1", "params":[] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_get_payload_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32602, "message":"invalid engine_getPayloadV1 params: []" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "handle_engine_new_payload_v1 OK: request is expected payload status", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_engine, new_payload(_, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return PayloadStatus{ .status = "INVALID", .latest_valid_hash = 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32, .validation_error = "some error"}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_newPayloadV1", "params":[{ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"] }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_new_payload_v1>(request, reply)); CHECK(reply == R"({ "id":1, "jsonrpc":"2.0", "result": { "latestValidHash":"0x0000000000000000000000000000000000000000000000000000000000000040", "status":"INVALID", "validationError":"some error" } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_newPayloadV1 KO: invalid amount of params", "[silkworm][rpc][commands][engine_api]") { nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_newPayloadV1", "params":[] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_new_payload_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32602, "message":"invalid engine_newPayloadV1 params: []" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_forkchoiceUpdatedV1 OK: only forkchoiceState", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_engine, fork_choice_updated(_, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return ForkChoiceUpdatedReply{ .payload_status = PayloadStatus{ .status = "INVALID", .latest_valid_hash = 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32, .validation_error = "some error"}, .payload_id = std::nullopt}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_forkchoiceUpdatedV1", "params":[ { "headBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "safeBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "finalizedBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a" } ] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_forkchoice_updated_v1>(request, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "result": { "payloadStatus":{ "latestValidHash":"0x0000000000000000000000000000000000000000000000000000000000000040", "status":"INVALID", "validationError":"some error" } } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_forkchoiceUpdatedV1 OK: both params", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_engine, fork_choice_updated(_, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return ForkChoiceUpdatedReply{ .payload_status = PayloadStatus{ .status = "INVALID", .latest_valid_hash = 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32, .validation_error = "some error"}, .payload_id = std::nullopt}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_forkchoiceUpdatedV1", "params":[ { "headBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "safeBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "finalizedBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a" }, { "timestamp":"0x1", "prevRandao":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "suggestedFeeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" } ] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_forkchoice_updated_v1>(request, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "result": { "payloadStatus":{ "latestValidHash":"0x0000000000000000000000000000000000000000000000000000000000000040", "status":"INVALID", "validationError":"some error" } } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_forkchoiceUpdatedV1 OK: both params and null second", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_engine, fork_choice_updated(_, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return ForkChoiceUpdatedReply{ .payload_status = PayloadStatus{ .status = "INVALID", .latest_valid_hash = 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32, .validation_error = "some error"}, .payload_id = std::nullopt}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_forkchoiceUpdatedV1", "params":[ { "headBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "safeBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "finalizedBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a" }, null ] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_forkchoice_updated_v1>(request, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "result": { "payloadStatus":{ "latestValidHash":"0x0000000000000000000000000000000000000000000000000000000000000040", "status":"INVALID", "validationError":"some error" } } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_forkchoiceUpdatedV1 KO: invalid amount of params", "[silkworm][rpc][commands][engine_api]") { nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_forkchoiceUpdatedV1", "params":[] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_forkchoice_updated_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32602, "message":"invalid engine_forkchoiceUpdatedV1 params: []" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_forkchoiceUpdatedV1 KO: empty finalized block hash", "[silkworm][rpc][commands][engine_api]") { nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_forkchoiceUpdatedV1", "params":[ { "headBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "safeBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "finalizedBlockHash":"0x0000000000000000000000000000000000000000000000000000000000000000" } ] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_forkchoice_updated_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-38002, "message":"finalized block hash is empty" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_forkchoiceUpdatedv1 KO: empty safe block hash", "[silkworm][rpc][commands][engine_api]") { nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_forkchoiceUpdatedv1", "params":[ { "headBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "safeBlockHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "finalizedBlockHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a" } ] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_forkchoice_updated_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-38002, "message":"safe block hash is empty" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 OK: EL config has the same CL config", "[silkworm][rpc][commands][engine_api]") { const silkworm::Bytes genesis_block_hash{*silkworm::from_hex("0000000000000000000000000000000000000000000000000000000000000000")}; const silkworm::ByteView genesis_block_key{genesis_block_hash}; EXPECT_CALL(*mock_backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(*mock_cursor, seek_exact(genesis_block_key)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, Bytes{string_view_to_byte_view(kChainConfig.to_json().dump())}}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[{ "terminalTotalDifficulty":"0xa4a470", "terminalBlockHash":"0x0000000000000000000000000000000000000000000000000000000000000000_bytes32", "terminalBlockNumber":"0x0" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "id":1, "jsonrpc":"2.0", "result":{ "terminalBlockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber": "0x0", "terminalTotalDifficulty": "0xa4a470" } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 OK: terminal block number zero if not sent", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); const silkworm::Bytes genesis_block_hash{*silkworm::from_hex("0000000000000000000000000000000000000000000000000000000000000000")}; const silkworm::ByteView genesis_block_key{genesis_block_hash}; EXPECT_CALL(*mock_cursor, seek_exact(genesis_block_key)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, Bytes{string_view_to_byte_view(kChainConfig.to_json().dump())}}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[{ "terminalTotalDifficulty":"0xa4a470", "terminalBlockHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber":"0x0" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "id":1, "jsonrpc":"2.0", "result":{ "terminalBlockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber": "0x0", "terminalTotalDifficulty": "0xa4a470" } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 KO: incorrect terminal total difficulty", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); const silkworm::Bytes genesis_block_hash{*silkworm::from_hex("0000000000000000000000000000000000000000000000000000000000000000")}; const silkworm::ByteView genesis_block_key{genesis_block_hash}; EXPECT_CALL(*mock_cursor, seek_exact(genesis_block_key)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, Bytes{string_view_to_byte_view(kChainConfig.to_json().dump())}}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[{ "terminalTotalDifficulty":"0xf4242", "terminalBlockHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber":"0x0" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32602, "message":"consensus layer terminal total difficulty does not match" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 KO: EL does not have TTD", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); const silkworm::Bytes genesis_block_hash{*silkworm::from_hex("0000000000000000000000000000000000000000000000000000000000000000")}; const silkworm::ByteView genesis_block_key{genesis_block_hash}; EXPECT_CALL(*mock_cursor, seek_exact(genesis_block_key)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, Bytes{string_view_to_byte_view(kChainConfigNoTerminalTotalDifficulty.to_json().dump())}}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[{ "terminalTotalDifficulty":"0xf4240", "terminalBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "terminalBlockNumber":"0x0" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32603, "message":"execution layer does not have terminal total difficulty" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 KO: CL sends wrong TTD", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); const silkworm::Bytes genesis_block_hash{*silkworm::from_hex("0000000000000000000000000000000000000000000000000000000000000000")}; const silkworm::ByteView genesis_block_key{genesis_block_hash}; EXPECT_CALL(*mock_cursor, seek_exact(genesis_block_key)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, Bytes{string_view_to_byte_view(kChainConfig.to_json().dump())}}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[{ "terminalTotalDifficulty":"0x0", "terminalBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "terminalBlockNumber":"0x0" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32602, "message":"consensus layer terminal total difficulty does not match" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 KO: CL sends wrong terminal block hash", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); const silkworm::Bytes genesis_block_hash{*silkworm::from_hex("0000000000000000000000000000000000000000000000000000000000000000")}; const silkworm::ByteView genesis_block_key{genesis_block_hash}; EXPECT_CALL(*mock_cursor, seek_exact(genesis_block_key)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, Bytes{string_view_to_byte_view(kChainConfig.to_json().dump())}}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[{ "terminalTotalDifficulty":"0xa4a470", "terminalBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "terminalBlockNumber":"0x0" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32602, "message":"consensus layer terminal block hash is not zero" }, "id":1, "jsonrpc":"2.0" })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 OK: no matching terminal block number", "[silkworm][rpc][commands][engine_api]") { EXPECT_CALL(*mock_backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); const silkworm::Bytes genesis_block_hash{*silkworm::from_hex("0000000000000000000000000000000000000000000000000000000000000000")}; const silkworm::ByteView genesis_block_key{genesis_block_hash}; EXPECT_CALL(*mock_cursor, seek_exact(genesis_block_key)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, Bytes{string_view_to_byte_view(kChainConfig.to_json().dump())}}; })); nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[{ "terminalTotalDifficulty":"0xa4a470", "terminalBlockHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber":"0x1" }] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "id":1, "jsonrpc":"2.0", "result":{ "terminalBlockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber": "0x0", "terminalTotalDifficulty": "0xa4a470" } })"_json); } TEST_CASE_METHOD(EngineRpcApiTest, "engine_transitionConfigurationV1 KO: incorrect params", "[silkworm][rpc][commands][engine_api]") { nlohmann::json reply; nlohmann::json request = R"({ "jsonrpc":"2.0", "id":1, "method":"engine_transitionConfigurationV1", "params":[] })"_json; CHECK_NOTHROW(run<&EngineRpcApiForTest::handle_engine_exchange_transition_configuration_v1>(request, reply)); CHECK(reply == R"({ "error":{ "code":-32602, "message":"invalid engine_exchangeTransitionConfigurationV1 params: []" }, "id":1, "jsonrpc":"2.0" })"_json); } #endif // !defined(SILKWORM_SANITIZE) && !defined(_WIN32) } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/erigon_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "erigon_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { // https://eth.wiki/json-rpc/API#erigon_cachecheck Task ErigonRpcApi::handle_erigon_cache_check(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { const db::kv::api::StateCache::ValidationResult result = co_await state_cache_->validate_current_root(*tx); reply = make_json_content(request, CacheValidationResult{result}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_getbalancechangesinblock Task ErigonRpcApi::handle_erigon_get_balance_changes_in_block(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.empty()) { auto error_msg = "invalid erigon_getBalanceChangesInBlock params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_num_or_hash = params[0].get(); SILK_DEBUG << "block_num_or_hash: " << block_num_or_hash; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); auto start = std::chrono::system_clock::now(); BlockReader block_reader{*chain_storage, *tx}; BalanceChanges balance_changes; co_await block_reader.read_balance_changes(block_num_or_hash, balance_changes); auto end = std::chrono::system_clock::now(); std::chrono::duration elapsed_seconds = end - start; SILK_DEBUG << "balance_changes: elapsed " << elapsed_seconds.count() << " sec"; nlohmann::json json; to_json(json, balance_changes); reply = make_json_content(request, json); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_getBlockByTimestamp Task ErigonRpcApi::handle_erigon_get_block_by_timestamp(const nlohmann::json& request, std::string& reply) { // Decode request parameters const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid erigon_getBlockByTimestamp params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } const auto block_timestamp = params[0].get(); const auto full_tx = params[1].get(); SILK_DEBUG << "block_timestamp: " << block_timestamp << " full_tx: " << full_tx; const std::string::size_type begin = block_timestamp.find_first_not_of(" \""); const std::string::size_type end = block_timestamp.find_last_not_of(" \""); const auto timestamp = static_cast(std::stol(block_timestamp.substr(begin, end - begin + 1), nullptr, 0)); // Open a new remote database transaction (no need to close if code throws before the end) auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); // Lookup the first and last block headers const auto first_header = co_await chain_storage->read_canonical_header(kEarliestBlockNum); ensure(first_header.has_value(), "cannot find earliest header"); const auto [current_header, head_header_hash] = co_await chain_storage->read_head_header_and_hash(); ensure(current_header.has_value(), "cannot find head header"); const BlockNum current_block_num = current_header->number; // Find the lowest block header w/ timestamp greater or equal to provided timestamp BlockNum block_num{0}; if (current_header->timestamp <= timestamp) { block_num = current_block_num; } else if (first_header->timestamp >= timestamp) { block_num = kEarliestBlockNum; } else { // Good-old binary search to find the lowest block header matching timestamp auto matching_block_num = co_await async_binary_search(current_block_num, [&](uint64_t block_num1) -> Task { const auto header = co_await chain_storage->read_canonical_header(block_num1); co_return header && header->timestamp >= timestamp; }); // TODO(canepat) we should try to avoid this block header lookup (just done in search) auto matching_header = co_await chain_storage->read_canonical_header(matching_block_num); while (matching_header && matching_header->timestamp > timestamp) { const auto header = co_await chain_storage->read_canonical_header(matching_block_num - 1); if (!header || header->timestamp < timestamp) { break; } matching_block_num = matching_block_num - 1; matching_header = header; } block_num = matching_block_num; } // Lookup and return the matching block const BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); ensure(block_with_hash != nullptr, [&]() { return "block " + std::to_string(block_num) + " not found"; }); const Block extended_block{block_with_hash, full_tx}; make_glaze_json_content(request, extended_block, reply); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } // Close remote database transaction, RAII not available with coroutines co_await tx->close(); } // https://eth.wiki/json-rpc/API#erigon_getBlockReceiptsByBlockHash Task ErigonRpcApi::handle_erigon_get_block_receipts_by_block_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid erigon_getBlockReceiptsByBlockHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_hash = params[0].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (!block_with_hash) { SILK_TRACE << "handle_erigon_get_block_receipts_by_block_hash block not found: " << request.dump(); reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } auto receipts_ptr{co_await core::get_receipts(*tx, *block_with_hash, *chain_storage, workers_)}; auto& receipts = *receipts_ptr; SILK_TRACE << "#receipts: " << receipts.size(); const auto& block{block_with_hash->block}; if (block.transactions.size() != receipts.size()) { SILK_ERROR << "erigon_get_block_receipts_by_block_hash: receipts size mismatch transaction size: " << request.dump(); reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } reply = make_json_content(request, receipts); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_getHeaderByHash Task ErigonRpcApi::handle_erigon_get_header_by_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid erigon_getHeaderByHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_hash = params[0].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const auto header{co_await chain_storage->read_header(block_hash)}; if (!header) { auto error_msg = "block header not found: 0x" + silkworm::to_hex(block_hash); reply = make_json_error(request, kServerError, error_msg); } else { reply = make_json_content(request, *header); } } catch (const std::invalid_argument&) { reply = make_json_error(request, kServerError, "block header not found: 0x" + silkworm::to_hex(block_hash)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_getHeaderByNumber Task ErigonRpcApi::handle_erigon_get_header_by_number(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid erigon_getHeaderByNumber params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].is_string() ? params[0].get() : to_quantity(params[0].get()); SILK_DEBUG << "block_id: " << block_id; if (block_id == kPendingBlockId) { // TODO(canepat): add pending block only known to the miner auto error_msg = "pending block not implemented in erigon_getHeaderByNumber"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto header{co_await chain_storage->read_canonical_header(block_num)}; if (!header) { const auto error_msg = "block header not found: " + std::to_string(block_num); reply = make_json_error(request, kServerError, error_msg); } else { reply = make_json_content(request, *header); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_getlatestlogs Task ErigonRpcApi::handle_erigon_get_latest_logs(const nlohmann::json& request, nlohmann::json& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto& params = request["params"]; if (params.size() > 2) { auto error_msg = "too many arguments, want at most 2"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto filter = params[0].get(); if (filter.block_hash && (filter.from_block || filter.to_block)) { auto error_msg = "invalid argument 0: cannot specify both BlockHash and FromBlock/ToBlock, choose one or the other"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } LogFilterOptions options{true, true}; if (params.size() > 1) { options = params[1].get(); options.add_timestamp = true; options.overwrite_log_index = true; } if (options.log_count != 0 && options.block_count != 0) { auto error_msg = "logs count & block count are ambiguous"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kServerError, error_msg); co_return; } if (options.log_count == 0 && options.block_count == 0) { options.block_count = 1; } SILK_DEBUG << "filter: {" << filter << "}, options: {" << options << "}"; auto tx = co_await database_->begin_transaction(); try { auto storage = tx->make_storage(); LogsWalker logs_walker(*block_cache_, *tx, *storage, workers_); const auto [start, end] = co_await logs_walker.get_block_nums(filter); if (start == end && start == std::numeric_limits::max()) { auto error_msg = "invalid eth_getLogs filter block_hash: " + filter.block_hash.value(); SILK_ERROR << error_msg; reply = make_json_error(request, kInternalError, error_msg); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } else if (end < start) { std::ostringstream oss; oss << "end (" << end << ") < begin (" << start << ")"; SILK_ERROR << oss.str(); reply = make_json_error(request, kServerError, oss.str()); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } SILK_DEBUG << "start: " << start << " end: " << end; std::vector logs; co_await logs_walker.get_logs(start, end, filter.addresses, filter.topics, options, /*ascending_order=*/true, logs); reply = make_json_content(request, logs); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_getlogsbyhash Task ErigonRpcApi::handle_erigon_get_logs_by_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid erigon_getLogsByHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_hash = params[0].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash); std::vector logs{}; auto cached_receipts = co_await core::get_cached_receipts(block_hash); if (cached_receipts != nullptr) { logs.reserve(cached_receipts->size()); for (const auto& receipt : *cached_receipts) { logs.push_back(receipt->logs); } reply = make_json_content(request, logs); co_return; } auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (!block_with_hash) { reply = make_json_content(request, nullptr); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto receipts_ptr{co_await core::get_receipts(*tx, *block_with_hash, *chain_storage, workers_)}; auto& receipts = *receipts_ptr; SILK_DEBUG << "receipts.size(): " << receipts.size(); logs.reserve(receipts.size()); for (const auto& receipt : receipts) { SILK_DEBUG << "receipt.logs.size(): " << receipt->logs.size(); logs.push_back(receipt->logs); } SILK_DEBUG << "logs.size(): " << logs.size(); reply = make_json_content(request, logs); } catch (const std::invalid_argument&) { reply = make_json_content(request, nullptr); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_forks Task ErigonRpcApi::handle_erigon_forks(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const auto chain_config{co_await chain_storage->read_chain_config()}; Forks forks{chain_config}; reply = make_json_content(request, forks); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_blockNumber Task ErigonRpcApi::handle_erigon_block_num(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; std::string block_id; if (params.empty()) { block_id = kLatestExecutedBlockId; } else if (params.size() == 1) { block_id = params[0]; } else { auto error_msg = "invalid erigon_blockNumber params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } SILK_DEBUG << "block: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto block_num{co_await block_reader.get_block_num_by_tag(block_id)}; reply = make_json_content(request, to_quantity(block_num)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#erigon_nodeInfo Task ErigonRpcApi::handle_erigon_node_info(const nlohmann::json& request, nlohmann::json& reply) { try { const auto node_info_data = co_await backend_->engine_node_info(); reply = make_json_content(request, node_info_data); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/erigon_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { using db::kv::api::StateCache; class ErigonRpcApi { public: ErigonRpcApi(boost::asio::io_context& ioc, WorkerPool& workers) : block_cache_{must_use_shared_service(ioc)}, state_cache_{must_use_shared_service(ioc)}, database_{must_use_private_service(ioc)->service()}, backend_{must_use_private_service(ioc)}, workers_{workers} {} virtual ~ErigonRpcApi() = default; ErigonRpcApi(const ErigonRpcApi&) = delete; ErigonRpcApi& operator=(const ErigonRpcApi&) = delete; ErigonRpcApi(ErigonRpcApi&&) = default; protected: Task handle_erigon_block_num(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_cache_check(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_get_balance_changes_in_block(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_get_block_receipts_by_block_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_get_header_by_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_get_header_by_number(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_get_latest_logs(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_get_logs_by_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_forks(const nlohmann::json& request, nlohmann::json& reply); Task handle_erigon_node_info(const nlohmann::json& request, nlohmann::json& reply); // GLAZE Task handle_erigon_get_block_by_timestamp(const nlohmann::json& request, std::string& reply); private: BlockCache* block_cache_; StateCache* state_cache_; std::shared_ptr database_; ethbackend::BackEnd* backend_; WorkerPool& workers_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/erigon_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "erigon_api.hpp" #include #include #include namespace silkworm::rpc::commands { //! Utility class to expose handle hooks publicly just for tests class ErigonRpcApiForTest : public ErigonRpcApi { public: explicit ErigonRpcApiForTest(boost::asio::io_context& ioc, WorkerPool& workers) : ErigonRpcApi{ioc, workers} {} // MSVC doesn't support using access declarations properly, so explicitly forward these public accessors Task erigon_get_block_by_timestamp(const nlohmann::json& request, std::string& reply) { co_return co_await ErigonRpcApi::handle_erigon_get_block_by_timestamp(request, reply); } Task erigon_get_header_by_hash(const nlohmann::json& request, nlohmann::json& reply) { co_return co_await ErigonRpcApi::handle_erigon_get_header_by_hash(request, reply); } Task erigon_get_header_by_number(const nlohmann::json& request, nlohmann::json& reply) { co_return co_await ErigonRpcApi::handle_erigon_get_header_by_number(request, reply); } Task erigon_get_logs_by_hash(const nlohmann::json& request, nlohmann::json& reply) { co_return co_await ErigonRpcApi::handle_erigon_get_logs_by_hash(request, reply); } Task erigon_forks(const nlohmann::json& request, nlohmann::json& reply) { co_return co_await ErigonRpcApi::handle_erigon_forks(request, reply); } Task erigon_block_num(const nlohmann::json& request, nlohmann::json& reply) { co_return co_await ErigonRpcApi::handle_erigon_block_num(request, reply); } Task erigon_node_info(const nlohmann::json& request, nlohmann::json& reply) { co_return co_await ErigonRpcApi::handle_erigon_node_info(request, reply); } }; using ErigonRpcApiTest = test_util::JsonApiWithWorkersTestBase; #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(ErigonRpcApiTest, "ErigonRpcApi::handle_erigon_get_block_by_timestamp", "[rpc][erigon_api]") { std::string reply; nlohmann::json exp_rsp; SECTION("request params is empty: return error") { CHECK_NOTHROW(run<&ErigonRpcApiForTest::erigon_get_block_by_timestamp>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getBlockByTimestamp", "params":[] })"_json, reply)); std::string expected_rsp{R"({"jsonrpc":"2.0","id":1,"error":{"code":-32602,"message":"invalid erigon_getBlockByTimestamp params: []"}})"}; CHECK(reply == expected_rsp); } SECTION("request params are incomplete: return error") { CHECK_NOTHROW(run<&ErigonRpcApiForTest::erigon_get_block_by_timestamp>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getBlockByTimestamp", "params":["1658865942"] })"_json, reply)); const auto expected_reply = R"({ "jsonrpc":"2.0", "id":1, "error":{"code":100,"message":"invalid erigon_getBlockByTimestamp params: [\"1658865942\"]"} })"_json; std::string expected_rsp{R"({"jsonrpc":"2.0","id":1,"error":{"code":-32602,"message":"invalid erigon_getBlockByTimestamp params: [\"1658865942\"]"}})"}; CHECK(reply == expected_rsp); } SECTION("request 1st param is invalid: return error") { CHECK_THROWS_AS(run<&ErigonRpcApiForTest::erigon_get_block_by_timestamp>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getBlockByTimestamp", "params":[true, true] })"_json, reply), nlohmann::json::exception); } SECTION("request 2nd param is invalid: return error") { CHECK_THROWS_AS(run<&ErigonRpcApiForTest::erigon_get_block_by_timestamp>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getBlockByTimestamp", "params":["1658865942", "abc"] })"_json, reply), nlohmann::json::exception); } // TODO(canepat) we need to mock silkworm::core functions properly, then we must change this check SECTION("request params are valid: return block w/ full transactions") { CHECK_THROWS_AS(run<&ErigonRpcApiForTest::erigon_get_block_by_timestamp>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getBlockByTimestamp", "params":["1658865942", true] })"_json, reply), std::exception); } } TEST_CASE_METHOD(ErigonRpcApiTest, "ErigonRpcApi::handle_erigon_get_header_by_hash", "[rpc][erigon_api]") { nlohmann::json reply; SECTION("request params is empty: success and return error") { CHECK_NOTHROW(run<&ErigonRpcApiForTest::erigon_get_header_by_hash>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getHeaderByHash", "params":[] })"_json, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32602,"message":"invalid erigon_getHeaderByHash params: []"} })"_json); } } TEST_CASE_METHOD(ErigonRpcApiTest, "ErigonRpcApi::handle_erigon_get_header_by_number", "[rpc][erigon_api]") { nlohmann::json reply; SECTION("request params is empty: success and return error") { CHECK_NOTHROW(run<&ErigonRpcApiForTest::erigon_get_header_by_number>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getHeaderByNumber", "params":[] })"_json, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32602,"message":"invalid erigon_getHeaderByNumber params: []"} })"_json); } } TEST_CASE_METHOD(ErigonRpcApiTest, "ErigonRpcApi::handle_erigon_get_logs_by_hash", "[rpc][erigon_api]") { nlohmann::json reply; SECTION("request params is empty: success and return error") { CHECK_NOTHROW(run<&ErigonRpcApiForTest::erigon_get_logs_by_hash>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_getLogsByHash", "params":[] })"_json, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32602,"message":"invalid erigon_getLogsByHash params: []"} })"_json); } } TEST_CASE_METHOD(ErigonRpcApiTest, "ErigonRpcApi::handle_erigon_forks", "[rpc][erigon_api]") { nlohmann::json reply; SECTION("no server connection: failure") { CHECK_THROWS_AS(run<&ErigonRpcApiForTest::erigon_forks>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_forks", "params":[] })"_json, reply), std::exception); } } TEST_CASE_METHOD(ErigonRpcApiTest, "ErigonRpcApi::handle_erigon_block_num", "[rpc][erigon_api]") { nlohmann::json reply; #ifndef _WIN32 SECTION("request invalid params number") { CHECK_NOTHROW(run<&ErigonRpcApiForTest::erigon_block_num>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_blockNumber", "params":["earliest", "3"] })"_json, reply)); CHECK(reply == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32602,"message":"invalid erigon_blockNumber params: [\"earliest\",\"3\"]"} })"_json); } #endif // _WIN32 SECTION("request earliest") { CHECK_THROWS_AS(run<&ErigonRpcApiForTest::erigon_block_num>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_blockNumber", "params":["earliest"] })"_json, reply), std::exception); } SECTION("request empty param") { CHECK_THROWS_AS(run<&ErigonRpcApiForTest::erigon_block_num>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_blockNumber", "params":[] })"_json, reply), std::exception); } } TEST_CASE_METHOD(ErigonRpcApiTest, "ErigonRpcApi::handle_erigon_node_info", "[rpc][erigon_api]") { nlohmann::json reply; SECTION("request node_info") { CHECK_NOTHROW(run<&ErigonRpcApiForTest::erigon_node_info>( R"({ "jsonrpc":"2.0", "id":1, "method":"erigon_nodeInfo", "params":[] })"_json, reply)); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/eth_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "eth_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { using db::kv::StateReader; // https://eth.wiki/json-rpc/API#eth_blocknumber Task EthereumRpcApi::handle_eth_block_num(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; try { const auto block_num = co_await block_reader.get_latest_block_num(); reply = make_json_content(request, to_quantity(block_num)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_chainid Task EthereumRpcApi::handle_eth_chain_id(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const auto chain_config = co_await chain_storage->read_chain_config(); reply = make_json_content(request, to_quantity(chain_config.chain_id)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_protocolversion Task EthereumRpcApi::handle_eth_protocol_version(const nlohmann::json& request, nlohmann::json& reply) { try { const auto protocol_version = co_await backend_->protocol_version(); reply = make_json_content(request, to_quantity(protocol_version)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#eth_syncing Task EthereumRpcApi::handle_eth_syncing(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; try { const auto current_block_num = co_await block_reader.get_current_block_num(); const auto max_block_num = co_await block_reader.get_max_block_num(); if (current_block_num >= max_block_num) { reply = make_json_content(request, false); } else { SyncingData syncing_data{}; syncing_data.current_block = to_quantity(current_block_num); syncing_data.max_block = to_quantity(max_block_num); for (std::string_view stage_name : silkworm::db::stages::kAllStages) { StageData current_stage; current_stage.stage_name = stage_name; current_stage.block_num = to_quantity(co_await stages::get_sync_stage_progress(*tx, string_to_bytes(current_stage.stage_name))); syncing_data.stages.push_back(current_stage); } reply = make_json_content(request, syncing_data); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_gasprice Task EthereumRpcApi::handle_eth_gas_price(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto latest_block_num = co_await block_reader.get_block_num(kLatestBlockId); SILK_TRACE << "latest_block_num " << latest_block_num; BlockProvider block_provider = [this, &block_reader](BlockNum block_num) { return block_reader.read_block_by_number(*block_cache_, block_num); }; GasPriceOracle gas_price_oracle{block_provider}; auto gas_price = co_await gas_price_oracle.suggested_price(latest_block_num); const auto block_with_hash = co_await block_provider(latest_block_num); if (block_with_hash) { const auto base_fee = block_with_hash->block.header.base_fee_per_gas.value_or(0); gas_price += base_fee; reply = make_json_content(request, to_quantity(gas_price)); } else { reply = make_json_error(request, 100, "invalid block id"); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getblockbyhash Task EthereumRpcApi::handle_eth_get_block_by_hash(const nlohmann::json& request, std::string& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getBlockByHash params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } auto block_hash = params[0].get(); auto full_tx = params[1].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash) << " full_tx: " << std::boolalpha << full_tx; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (block_with_hash) { const Block extended_block{block_with_hash, full_tx}; make_glaze_json_content(request, extended_block, reply); } else { make_glaze_json_null_content(request, reply); } } catch (const std::invalid_argument&) { make_glaze_json_null_content(request, reply); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getblockbynumber Task EthereumRpcApi::handle_eth_get_block_by_number(const nlohmann::json& request, std::string& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getBlockByNumber params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } const auto block_id = params[0].get(); auto full_tx = params[1].get(); SILK_DEBUG << "block_id: " << block_id << " full_tx: " << std::boolalpha << full_tx; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (block_with_hash) { const Block extended_block{block_with_hash, full_tx}; make_glaze_json_content(request, extended_block, reply); } else { make_glaze_json_null_content(request, reply); } } catch (const std::invalid_argument&) { make_glaze_json_null_content(request, reply); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getblocktransactioncountbyhash Task EthereumRpcApi::handle_eth_get_block_transaction_count_by_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getBlockTransactionCountByHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto block_hash = params[0].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (block_with_hash) { const auto tx_count = block_with_hash->block.transactions.size(); reply = make_json_content(request, to_quantity(tx_count)); } else { reply = make_json_content(request, nullptr); } } catch (const std::invalid_argument&) { reply = make_json_content(request, nullptr); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getblocktransactioncountbynumber Task EthereumRpcApi::handle_eth_get_block_transaction_count_by_number(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getBlockTransactionCountByNumber params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].get(); SILK_DEBUG << "block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (block_with_hash) { const auto tx_count = block_with_hash->block.transactions.size(); reply = make_json_content(request, to_quantity(tx_count)); } else { reply = make_json_content(request, nullptr); } } catch (const std::invalid_argument&) { reply = make_json_content(request, nullptr); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getunclebyblockhashandindex Task EthereumRpcApi::handle_eth_get_uncle_by_block_hash_and_index(const nlohmann::json& request, std::string& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getUncleByBlockHashAndIndex params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } const auto block_hash = params[0].get(); const auto index = params[1].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash) << " index: " << index; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (block_with_hash) { const auto ommers = block_with_hash->block.ommers; const auto idx = std::stoul(index, nullptr, 16); if (idx >= ommers.size()) { SILK_WARN << "invalid_argument: index not found processing request: " << request.dump(); make_glaze_json_null_content(request, reply); } else { const auto& uncle = ommers[idx]; auto uncle_block_with_hash = std::make_shared(); uncle_block_with_hash->block.ommers.push_back(uncle); uncle_block_with_hash->hash = uncle.hash(); const Block uncle_block_with_hash_and_td{uncle_block_with_hash}; make_glaze_json_content(request, uncle_block_with_hash_and_td, reply); } } else { make_glaze_json_null_content(request, reply); } } catch (const std::invalid_argument&) { make_glaze_json_null_content(request, reply); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getunclebyblocknumberandindex Task EthereumRpcApi::handle_eth_get_uncle_by_block_num_and_index(const nlohmann::json& request, std::string& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getUncleByBlockNumberAndIndex params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } const auto block_id = params[0].get(); const auto index = params[1].get(); SILK_DEBUG << "block_id: " << block_id << " index: " << index; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (block_with_hash) { const auto ommers = block_with_hash->block.ommers; const auto idx = std::stoul(index, nullptr, 16); if (idx >= ommers.size()) { SILK_WARN << "invalid_argument: index not found processing request: " << request.dump(); make_glaze_json_null_content(request, reply); } else { const auto& uncle = ommers[idx]; auto uncle_block_with_hash = std::make_shared(); uncle_block_with_hash->block.ommers.push_back(uncle); uncle_block_with_hash->hash = uncle.hash(); const Block uncle_block_with_hash_and_td{uncle_block_with_hash}; make_glaze_json_content(request, uncle_block_with_hash_and_td, reply); } } else { make_glaze_json_null_content(request, reply); } } catch (const std::invalid_argument&) { make_glaze_json_null_content(request, reply); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getunclecountbyblockhash Task EthereumRpcApi::handle_eth_get_uncle_count_by_block_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getUncleCountByBlockHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto block_hash = params[0].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (!block_with_hash) { reply = make_json_content(request, nullptr); } else { const auto ommers = block_with_hash->block.ommers.size(); reply = make_json_content(request, to_quantity(ommers)); } } catch (const std::invalid_argument&) { reply = make_json_content(request, nullptr); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getunclecountbyblocknumber Task EthereumRpcApi::handle_eth_get_uncle_count_by_block_num(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getUncleCountByBlockNumber params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].get(); SILK_DEBUG << "block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (!block_with_hash) { reply = make_json_content(request, nullptr); } else { const auto ommers = block_with_hash->block.ommers.size(); reply = make_json_content(request, to_quantity(ommers)); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_gettransactionbyhash Task EthereumRpcApi::handle_eth_get_transaction_by_hash(const nlohmann::json& request, std::string& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getTransactionByHash params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } auto transaction_hash = params[0].get(); SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; BlockReader block_reader{*chain_storage, *tx}; const auto tx_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!tx_with_block) { const auto tx_rlp_buffer = co_await tx_pool_->get_transaction(transaction_hash); if (tx_rlp_buffer) { silkworm::ByteView encoded_tx_view{*tx_rlp_buffer}; Transaction transaction; const auto decoding_result = silkworm::rlp::decode(encoded_tx_view, transaction); if (decoding_result) { transaction.queued_in_pool = true; make_glaze_json_content(request, transaction, reply); } else { const auto error_msg = "invalid RLP decoding for tx hash: " + silkworm::to_hex(transaction_hash); SILK_ERROR << error_msg; make_glaze_json_null_content(request, reply); } } else { const auto error_msg = "tx hash: " + silkworm::to_hex(transaction_hash) + " does not exist in pool"; SILK_ERROR << error_msg; make_glaze_json_null_content(request, reply); } } else { make_glaze_json_content(request, tx_with_block->transaction, reply); } } catch (const std::invalid_argument&) { make_glaze_json_null_content(request, reply); } catch (const boost::system::system_error& se) { make_glaze_json_null_content(request, reply); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getrawtransactionbyhash Task EthereumRpcApi::handle_eth_get_raw_transaction_by_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getRawTransactionByHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; BlockReader block_reader{*chain_storage, *tx}; const auto tx_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!tx_with_block) { const auto tx_rlp_buffer = co_await tx_pool_->get_transaction(transaction_hash); if (tx_rlp_buffer) { Rlp rlp{*tx_rlp_buffer}; reply = make_json_content(request, rlp); } else { const auto error_msg = "tx hash: " + silkworm::to_hex(transaction_hash) + " does not exist in pool"; SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); } } else { Rlp rlp{}; silkworm::rlp::encode(rlp.buffer, tx_with_block->transaction, false); reply = make_json_content(request, rlp); } } catch (const std::invalid_argument&) { Rlp rlp{}; reply = make_json_content(request, rlp); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_gettransactionbyblockhashandindex Task EthereumRpcApi::handle_eth_get_transaction_by_block_hash_and_index(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getTransactionByBlockHashAndIndex params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_hash = params[0].get(); const auto index = params[1].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash) << " index: " << index; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (block_with_hash) { const auto& transactions = block_with_hash->block.transactions; const auto idx = std::stoul(index, nullptr, 16); if (idx >= transactions.size()) { SILK_WARN << "Transaction not found for index: " << index; reply = make_json_content(request, nullptr); } else { const auto& block_header = block_with_hash->block.header; rpc::Transaction txn{transactions[idx], block_with_hash->hash, block_header.number, block_header.base_fee_per_gas, idx}; reply = make_json_content(request, txn); } } else { reply = make_json_content(request, nullptr); } } catch (const std::invalid_argument&) { reply = make_json_content(request, nullptr); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getrawtransactionbyblockhashandindex Task EthereumRpcApi::handle_eth_get_raw_transaction_by_block_hash_and_index(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getRawTransactionByBlockHashAndIndex params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_hash = params[0].get(); const auto index = params[1].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash) << " index: " << index; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (block_with_hash) { const auto& transactions = block_with_hash->block.transactions; const auto idx = std::stoul(index, nullptr, 16); if (idx >= transactions.size()) { SILK_WARN << "Transaction not found for index: " << index; Rlp rlp{}; reply = make_json_content(request, rlp); } else { Rlp rlp{}; silkworm::rlp::encode(rlp.buffer, transactions[idx], false); reply = make_json_content(request, rlp); } } else { Rlp rlp{}; reply = make_json_content(request, rlp); } } catch (const std::invalid_argument&) { Rlp rlp{}; reply = make_json_content(request, rlp); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_gettransactionbyblocknumberandindex Task EthereumRpcApi::handle_eth_get_transaction_by_block_num_and_index(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getTransactionByBlockNumberAndIndex params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].get(); const auto index = params[1].get(); SILK_DEBUG << "block_id: " << block_id << " index: " << index; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (block_with_hash) { const auto& transactions = block_with_hash->block.transactions; const auto idx = std::stoul(index, nullptr, 16); if (idx >= transactions.size()) { SILK_WARN << "Transaction not found for index: " << index; reply = make_json_content(request, nullptr); } else { const auto block_header = block_with_hash->block.header; rpc::Transaction txn{transactions[idx], block_with_hash->hash, block_header.number, block_header.base_fee_per_gas, idx}; reply = make_json_content(request, txn); } } else { Rlp rlp{}; reply = make_json_content(request, rlp); } } catch (const std::invalid_argument&) { Rlp rlp{}; reply = make_json_content(request, rlp); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getrawtransactionbyblocknumberandindex Task EthereumRpcApi::handle_eth_get_raw_transaction_by_block_num_and_index(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getRawTransactionByBlockNumberAndIndex params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].get(); const auto index = params[1].get(); SILK_DEBUG << "block_id: " << block_id << " index: " << index; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (block_with_hash) { const auto& transactions = block_with_hash->block.transactions; const auto idx = std::stoul(index, nullptr, 16); if (idx >= transactions.size()) { SILK_WARN << "Transaction not found for index: " << index; Rlp rlp{}; reply = make_json_content(request, rlp); } else { Rlp rlp{}; silkworm::rlp::encode(rlp.buffer, transactions[idx], false); reply = make_json_content(request, rlp); } } else { Rlp rlp{}; reply = make_json_content(request, rlp); } } catch (const std::invalid_argument&) { Rlp rlp{}; reply = make_json_content(request, rlp); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_gettransactionreceipt Task EthereumRpcApi::handle_eth_get_transaction_receipt(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getTransactionReceipt params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto transaction_hash = params[0].get(); SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const auto result = co_await chain_storage->read_block_num_by_transaction_hash(transaction_hash); if (!result) { reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto [block_number, txn_id] = *result; auto header = co_await chain_storage->read_canonical_header(block_number); if (!header) { reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const silkworm::Block block{.header = std::move(*header)}; const auto base_txn_in_block = co_await tx->first_txn_num_in_block(block_number); const auto txn_index = static_cast(txn_id - base_txn_in_block - 1); const auto transaction = co_await chain_storage->read_transaction_by_idx_in_block(block_number, txn_index); if (!transaction) { reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } auto receipt = co_await core::get_receipt(*tx, block, txn_id, txn_index, *transaction, *chain_storage, workers_); if (!receipt) { reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } reply = make_json_content(request, receipt); } catch (const std::invalid_argument&) { reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_content(request, {}); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_estimategas Task EthereumRpcApi::handle_eth_estimate_gas(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() > 3 || params.empty()) { auto error_msg = "invalid eth_estimateGas params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto call = params[0].get(); SILK_DEBUG << "call: " << call; auto tx = co_await database_->begin_transaction(); const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; std::string block_id; if (params.size() >= 2) { block_id = params[1].get(); SILK_DEBUG << "block_id: " << block_id; } else { block_id = kLatestBlockId; } AccountsOverrides accounts_overrides; if (params.size() == 3) { from_json(params[2], accounts_overrides); SILK_TRACE << " accounts_overrides #" << accounts_overrides.size(); } try { const auto chain_config = co_await chain_storage->read_chain_config(); const auto req_block_num = co_await block_reader.get_block_num(block_id); SILK_DEBUG << "chain_id: " << chain_config.chain_id << ", block_num: " << req_block_num; const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, req_block_num); if (!block_with_hash) { std::string error_msg = "could not find the block " + std::to_string(req_block_num) + " in cache or db"; reply = make_json_error(request, -32000, error_msg); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto block = block_with_hash->block; rpc::AccountReader account_reader = [&](const evmc::address& address, std::optional txn_id) -> Task> { StateReader state_reader{*tx, txn_id}; // always at latest block co_return co_await state_reader.read_account(address); }; rpc::EstimateGasOracle estimate_gas_oracle{account_reader, chain_config, workers_, *tx, *chain_storage, accounts_overrides}; const auto estimated_gas = co_await estimate_gas_oracle.estimate_gas(call, block, /*txn_id=*/std::nullopt); reply = make_json_content(request, to_quantity(estimated_gas)); } catch (const std::invalid_argument&) { reply = make_json_content(request, to_quantity(0)); } catch (const rpc::EstimateGasException& e) { SILK_ERROR << "EstimateGasException: code: " << e.error_code() << " message: " << e.message() << " processing request: " << request.dump(); if (e.data().empty()) { reply = make_json_error(request, static_cast(e.error_code()), e.message()); } else { reply = make_json_error(request, RevertError{{3, e.message()}, e.data()}); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getbalance Task EthereumRpcApi::handle_eth_get_balance(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getBalance params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); const auto block_id = params[1].get(); SILK_DEBUG << "address: " << address << " block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto block_num_or_hash = BlockNumOrHash{block_id}; const auto [block_num, is_latest_block] = co_await block_reader.get_block_num(block_num_or_hash); std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx->user_txn_id_at(block_num + 1); } StateReader state_reader{*tx, txn_id}; std::optional account{co_await state_reader.read_account(address)}; reply = make_json_content(request, "0x" + (account ? intx::hex(account->balance) : "0")); } catch (const std::invalid_argument&) { reply = make_json_content(request, "0x0"); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getcode Task EthereumRpcApi::handle_eth_get_code(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getCode params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); const auto block_id = params[1].get(); SILK_DEBUG << "address: " << address << " block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto [block_num, is_latest_block] = co_await block_reader.get_block_num(block_id, /*latest_required=*/true); std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx->user_txn_id_at(block_num + 1); } StateReader state_reader{*tx, txn_id}; std::optional account{co_await state_reader.read_account(address)}; if (account) { auto code{co_await state_reader.read_code(address, account->code_hash)}; reply = make_json_content(request, code ? ("0x" + silkworm::to_hex(*code)) : "0x"); } else { reply = make_json_content(request, "0x"); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_gettransactioncount Task EthereumRpcApi::handle_eth_get_transaction_count(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { auto error_msg = "invalid eth_getTransactionCount params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); const auto block_id = params[1].get(); SILK_DEBUG << "address: " << address << " block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto [block_num, is_latest_block] = co_await block_reader.get_block_num(block_id, /*latest_required=*/true); std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx->user_txn_id_at(block_num + 1); } StateReader state_reader{*tx, txn_id}; std::optional account{co_await state_reader.read_account(address)}; if (account) { reply = make_json_content(request, to_quantity(account->nonce)); } else { reply = make_json_content(request, "0x0"); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getstorageat Task EthereumRpcApi::handle_eth_get_storage_at(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 3 || !is_valid_address(params[0].get())) { const auto error_msg = "invalid eth_getStorageAt params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); const auto position = params[1].get(); if (!is_valid_hex(position)) { const auto error_msg = "unable to decode storage key: hex string invalid: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto location = bytes32_from_hex(position); const auto block_id = params[2].get(); SILK_DEBUG << "address: " << address << " block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto [block_num, is_latest_block] = co_await block_reader.get_block_num(block_id, /*latest_required=*/true); std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx->user_txn_id_at(block_num + 1); } StateReader state_reader{*tx, txn_id}; std::optional account{co_await state_reader.read_account(address)}; if (account) { const auto storage_value = co_await state_reader.read_storage(address, account->incarnation, location); reply = make_json_content(request, "0x" + silkworm::to_hex(storage_value)); } else { reply = make_json_content(request, "0x0000000000000000000000000000000000000000000000000000000000000000"); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_call Task EthereumRpcApi::handle_eth_call(const nlohmann::json& request, std::string& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } const auto& params = request["params"]; if (params.size() < 2 || params.size() > 3) { auto error_msg = "invalid eth_call params: " + params.dump(); SILK_ERROR << error_msg; make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } const auto call = params[0].get(); const auto block_id = params[1].get(); std::optional accounts_overrides; if (params.size() == 3) { AccountsOverrides local_accounts_overrides; accounts_overrides = std::make_optional(local_accounts_overrides); from_json(params[2], *accounts_overrides); SILK_TRACE << " accounts_overrides #" << (*accounts_overrides).size(); } SILK_DEBUG << "call: " << call << " block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto chain_config = co_await chain_storage->read_chain_config(); const auto [block_num, is_latest_block] = co_await block_reader.get_block_num(block_id, /*latest_required=*/true); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (!block_with_hash) { make_glaze_json_error(request, 100, "block not found", reply); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } silkworm::Transaction txn{call.to_transaction()}; execution::StateFactory state_factory{*tx}; std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx->user_txn_id_at(block_num + 1); } const auto execution_result = co_await EVMExecutor::call( chain_config, *chain_storage, workers_, block_with_hash->block, txn, txn_id, [&state_factory](auto& io_executor, std::optional curr_txn_id, auto& storage) { return state_factory.make(io_executor, storage, curr_txn_id); }, /*tracers=*/{}, /*refund=*/true, /*gas_bailout=*/false, accounts_overrides); if (execution_result.success()) { make_glaze_json_content(request, execution_result.data, reply); } else { const auto error_message = execution_result.error_message(); if (execution_result.data.empty()) { make_glaze_json_error(request, kServerError, error_message, reply); } else { make_glaze_json_error(request, RevertError{{3, error_message}, execution_result.data}, reply); } } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_callMany Task EthereumRpcApi::handle_eth_call_many(const nlohmann::json& request, nlohmann::json& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required arguments"; SILK_ERROR << error_msg << request.dump(); reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid eth_callMany params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto bundles = params[0].get(); if (bundles.empty()) { const auto error_msg = "invalid eth_callMany bundle list: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto simulation_context = params[1].get(); AccountsOverrides accounts_overrides; if (params.size() > 2) { from_json(params[2], accounts_overrides); } std::optional timeout; if (params.size() > 3) { timeout = params[3].get(); } SILK_TRACE << "bundles: " << bundles << " simulation_context: " << simulation_context << " accounts_overrides #" << accounts_overrides.size() << " timeout: " << timeout.value_or(0); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; call::CallExecutor executor{*tx, *block_cache_, workers_, block_reader}; const auto result = co_await executor.execute(bundles, simulation_context, accounts_overrides, timeout); if (result.error) { reply = make_json_error(request, kServerError, result.error.value()); } else { reply = make_json_content(request, result.results); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_maxpriorityfeepergas Task EthereumRpcApi::handle_eth_max_priority_fee_per_gas(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; // always at latest block const auto latest_block_num = co_await block_reader.get_block_num(kLatestBlockId); SILK_TRACE << "latest_block_num " << latest_block_num; BlockProvider block_provider = [this, &block_reader](BlockNum block_num) { return block_reader.read_block_by_number(*block_cache_, block_num); }; GasPriceOracle gas_price_oracle{block_provider}; auto gas_price = co_await gas_price_oracle.suggested_price(latest_block_num); reply = make_json_content(request, to_quantity(gas_price)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://geth.ethereum.org/docs/rpc/ns-eth#eth_createaccesslist Task EthereumRpcApi::handle_eth_create_access_list(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2 && params.size() != 3) { auto error_msg = "invalid eth_createAccessList params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto call = params[0].get(); const auto block_num_or_hash = params[1].get(); bool optimize_gas = false; if (params.size() == 3) { optimize_gas = params[2]; } SILK_DEBUG << "call: " << call << " block_num_or_hash: " << block_num_or_hash << " optimize: " << optimize_gas; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(*block_cache_, block_num_or_hash); if (!block_with_hash) { reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto chain_config = co_await chain_storage->read_chain_config(); const bool is_latest_block = co_await block_reader.get_latest_executed_block_num() == block_with_hash->block.header.number; std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx->user_txn_id_at(block_with_hash->block.header.number + 1); } StateReader state_reader{*tx, txn_id}; std::optional nonce = std::nullopt; evmc::address to{}; if (call.to) { to = *(call.to); } else { if (!call.nonce) { // Retrieve nonce by txpool auto nonce_option = co_await tx_pool_->nonce(*call.from); if (!nonce_option) { std::optional account{co_await state_reader.read_account(*call.from)}; if (account) { nonce = (*account).nonce + 1; // NOLINT } } else { nonce = *nonce_option + 1; } } else { nonce = *(call.nonce); // NOLINT } to = silkworm::create_address(*call.from, *nonce); } auto tracer = std::make_shared(); Tracers tracers{tracer}; auto txn = call.to_transaction(std::nullopt, nonce); AccessList saved_access_list = call.access_list; execution::StateFactory state_factory{*tx}; while (true) { const auto execution_result = co_await EVMExecutor::call( chain_config, *chain_storage, workers_, block_with_hash->block, txn, txn_id, [&](auto& io_executor, std::optional curr_txn_id, auto& storage) { return state_factory.make(io_executor, storage, curr_txn_id); }, tracers, /* refund */ true, /* gasBailout */ false); if (execution_result.pre_check_error) { reply = make_json_error(request, kServerError, execution_result.pre_check_error.value()); break; } const AccessList& current_access_list = tracer->get_access_list(); if (saved_access_list == current_access_list) { AccessListResult access_list_result; access_list_result.gas_used = txn.gas_limit - execution_result.gas_left; if (!execution_result.success()) { access_list_result.error = execution_result.error_message(false /* full_error */); } if (optimize_gas) { tracer->optimize_gas(*call.from, to, block_with_hash->block.header.beneficiary); } access_list_result.access_list = current_access_list; reply = make_json_content(request, access_list_result); break; } txn = call.to_transaction(current_access_list, nonce); saved_access_list = current_access_list; } } catch (const std::invalid_argument&) { reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://docs.flashbots.net/flashbots-auction/advanced/rpc-endpoint#eth_callbundle Task EthereumRpcApi::handle_eth_call_bundle(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 3) { auto error_msg = "invalid eth_callBundle params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto tx_hash_list = params[0].get>(); const auto block_num_or_hash = params[1].get(); const auto timeout = params[2].get(); if (tx_hash_list.empty()) { const auto error_msg = "invalid eth_callBundle hash list: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } SILK_DEBUG << "block_num_or_hash: " << block_num_or_hash << " timeout: " << timeout; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(*block_cache_, block_num_or_hash); if (!block_with_hash) { reply = make_json_content(request, {}); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto chain_config = co_await chain_storage->read_chain_config(); const bool is_latest_block = co_await block_reader.get_latest_executed_block_num() == block_with_hash->block.header.number; const auto start_time = clock_time::now(); struct CallBundleInfo bundle_info {}; bool error{false}; silkworm::Bytes hash_data{}; for (size_t i{0}; i < tx_hash_list.size(); ++i) { CallBundleTxInfo tx_info{}; const auto tx_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, tx_hash_list[i]); if (!tx_with_block) { reply = make_json_content(request, {}); error = true; break; } execution::StateFactory state_factory{*tx}; std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx->user_txn_id_at(block_with_hash->block.header.number + 1); } const auto execution_result = co_await EVMExecutor::call( chain_config, *chain_storage, workers_, block_with_hash->block, tx_with_block->transaction, txn_id, [&](auto& io_executor, auto curr_txn_id, auto& storage) { return state_factory.make(io_executor, storage, curr_txn_id); }); if (execution_result.pre_check_error) { reply = make_json_error(request, kServerError, execution_result.pre_check_error.value()); error = true; break; } if ((clock_time::since(start_time) / 1000000) > timeout) { const auto error_msg = "execution aborted (timeout)"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); error = true; break; } tx_info.gas_used = tx_with_block->transaction.gas_limit - execution_result.gas_left; tx_info.hash = hash_of_transaction(tx_with_block->transaction); if (!execution_result.success()) { tx_info.error_message = execution_result.error_message(false /* full_error */); } else { tx_info.value = silkworm::to_bytes32(execution_result.data); } bundle_info.txs_info.push_back(tx_info); hash_data.append({tx_info.hash.bytes, silkworm::kHashLength}); } if (!error) { bundle_info.bundle_hash = hash_of(hash_data); reply = make_json_content(request, bundle_info); } } catch (const std::invalid_argument&) { reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_newfilter Task EthereumRpcApi::handle_eth_new_filter(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_newFilter params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto filter = params[0].get(); SILK_DEBUG << "filter: " << filter; if ((filter.from_block && filter.from_block.value() == kPendingBlockId) || (filter.to_block && filter.to_block.value() == kPendingBlockId)) { reply = make_json_error(request, kInvalidParams, "pending logs not supported"); co_return; } auto tx = co_await database_->begin_transaction(); try { auto storage = tx->make_storage(); LogsWalker logs_walker(*block_cache_, *tx, *storage, workers_); const auto [start, end] = co_await logs_walker.get_block_nums(filter); filter.start = start; filter.end = end; const auto filter_id = filter_storage_->add_filter(filter); SILK_TRACE << "Added a new filter, storage size: " << filter_storage_->size(); if (filter_id) { reply = make_json_content(request, filter_id.value()); } else { reply = make_json_error(request, kServerError, "TODO"); } } catch (const std::invalid_argument&) { reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_newblockfilter Task EthereumRpcApi::handle_eth_new_block_filter(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { reply = make_json_content(request, to_quantity(0)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_newpendingtransactionfilter Task EthereumRpcApi::handle_eth_new_pending_transaction_filter(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { reply = make_json_content(request, to_quantity(0)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getfilterlogs Task EthereumRpcApi::handle_eth_get_filter_logs(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getFilterLogs params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto filter_id = params[0].get(); SILK_TRACE << "filter_id: " << filter_id; const auto filter_ref = filter_storage_->get_filter(filter_id); if (!filter_ref) { reply = make_json_error(request, kServerError, "filter not found"); co_return; } auto& filter = filter_ref->get(); auto tx = co_await database_->begin_transaction(); try { auto storage = tx->make_storage(); LogsWalker logs_walker(*block_cache_, *tx, *storage, workers_); const auto [start, end] = co_await logs_walker.get_block_nums(filter); if (filter.start != start && filter.end != end) { filter.logs.clear(); co_await logs_walker.get_logs(start, end, filter.addresses, filter.topics, filter.logs); } else { co_await logs_walker.get_logs(start, end, filter.addresses, filter.topics, filter.logs); } filter.start = start; filter.end = end; reply = make_json_content(request, filter.logs); } catch (const std::invalid_argument&) { reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getfilterchanges Task EthereumRpcApi::handle_eth_get_filter_changes(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getFilterChanges params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto filter_id = params[0].get(); SILK_TRACE << "filter_id: " << filter_id; const auto filter_opt = filter_storage_->get_filter(filter_id); if (!filter_opt) { reply = make_json_error(request, kServerError, "filter not found"); co_return; } auto& filter = filter_opt.value().get(); auto tx = co_await database_->begin_transaction(); try { auto storage = tx->make_storage(); LogsWalker logs_walker(*block_cache_, *tx, *storage, workers_); const auto [start, end] = co_await logs_walker.get_block_nums(filter); std::vector logs; if (filter.start == start && filter.end != end) { co_await logs_walker.get_logs(start, end, filter.addresses, filter.topics, logs); filter.logs.insert(filter.logs.end(), logs.begin(), logs.end()); } else if (filter.start != start && filter.end != end) { co_await logs_walker.get_logs(start, end, filter.addresses, filter.topics, logs); filter.logs.clear(); filter.logs.insert(filter.logs.end(), logs.begin(), logs.end()); } filter.start = start; filter.end = end; reply = make_json_content(request, logs); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_uninstallfilter Task EthereumRpcApi::handle_eth_uninstall_filter(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_uninstallFilter params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); co_return; } auto filter_id = params[0].get(); SILK_DEBUG << "filter_id: " << filter_id; const auto success = filter_storage_->remove_filter(filter_id); SILK_TRACE << "Removing filter " << (success ? "succeeded" : "failed") << ", storage size: " << filter_storage_->size(); reply = make_json_content(request, success); } // https://eth.wiki/json-rpc/API#eth_getlogs Task EthereumRpcApi::handle_eth_get_logs(const nlohmann::json& request, std::string& reply) { if (!request.contains("params")) { auto error_msg = "missing value for required argument 0"; SILK_ERROR << error_msg << request.dump(); make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } const auto& params = request["params"]; if (params.size() > 1) { auto error_msg = "too many arguments, want at most 1"; SILK_ERROR << error_msg << request.dump(); make_glaze_json_error(request, kInvalidParams, error_msg, reply); co_return; } auto filter = params[0].get(); SILK_DEBUG << "filter: " << filter; auto tx = co_await database_->begin_transaction(); try { auto storage = tx->make_storage(); LogsWalker logs_walker(*block_cache_, *tx, *storage, workers_); const auto [start, end] = co_await logs_walker.get_block_nums(filter); if (start == end && start == std::numeric_limits::max()) { auto error_msg = "invalid eth_getLogs filter block_hash: " + filter.block_hash.value(); SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } std::vector logs; co_await logs_walker.get_logs(start, end, filter.addresses, filter.topics, logs); make_glaze_json_content(request, logs, reply); } catch (const std::invalid_argument&) { std::vector log{}; make_glaze_json_content(request, log, reply); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); make_glaze_json_error(request, kInternalError, e.what(), reply); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); make_glaze_json_error(request, kServerError, "unexpected exception", reply); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_sendrawtransaction Task EthereumRpcApi::handle_eth_send_raw_transaction(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_sendRawTransaction params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto encoded_tx_string = params[0].get(); const auto encoded_tx_bytes = silkworm::from_hex(encoded_tx_string); if (!encoded_tx_bytes.has_value()) { const auto error_msg = "invalid eth_sendRawTransaction encoded tx: " + encoded_tx_string; SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } silkworm::ByteView encoded_tx_view{*encoded_tx_bytes}; Transaction txn; const auto decoding_result{silkworm::rlp::decode_transaction(encoded_tx_view, txn, silkworm::rlp::Eip2718Wrapping::kBoth)}; if (!decoding_result) { const auto error_msg = decoding_result_to_string(decoding_result.error()); SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } constexpr float kTxFeeCap = 1; // 1 ether if (!check_tx_fee_less_cap(kTxFeeCap, txn.max_fee_per_gas, txn.gas_limit)) { const auto error_msg = "tx fee exceeds the configured cap"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } if (!is_replay_protected(txn)) { const auto error_msg = "only replay-protected (EIP-155) transactions allowed over RPC"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } const silkworm::ByteView encoded_tx{*encoded_tx_bytes}; const auto result = co_await tx_pool_->add_transaction(encoded_tx); if (!result.success) { SILK_ERROR << "cannot add transaction: " << result.error_descr; reply = make_json_error(request, kServerError, result.error_descr); co_return; } if (!txn.sender()) { const auto error_msg = "cannot recover sender"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } const auto ethash_hash = txn.hash(); const auto hash = silkworm::to_bytes32({ethash_hash.bytes, silkworm::kHashLength}); if (!txn.to.has_value()) { const auto contract_address = silkworm::create_address(*txn.sender(), txn.nonce); SILK_DEBUG << "submitted contract creation hash: " << silkworm::to_hex(hash) << " from: " << *txn.sender() << " nonce: " << txn.nonce << " contract: " << contract_address << " value: " << txn.value; } else { SILK_DEBUG << "submitted transaction hash: " << silkworm::to_hex(hash) << " from: " << *txn.sender() << " nonce: " << txn.nonce << " recipient: " << *txn.to << " value: " << txn.value; } reply = make_json_content(request, hash); } // https://eth.wiki/json-rpc/API#eth_sendtransaction Task EthereumRpcApi::handle_eth_send_transaction(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { reply = make_json_content(request, to_quantity(0)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_signtransaction Task EthereumRpcApi::handle_eth_sign_transaction(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { reply = make_json_content(request, to_quantity(0)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getproof Task EthereumRpcApi::handle_eth_get_proof(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { reply = make_json_content(request, to_quantity(0)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_mining Task EthereumRpcApi::handle_eth_mining(const nlohmann::json& request, nlohmann::json& reply) { try { const auto mining_result = co_await miner_->get_mining(); reply = make_json_content(request, mining_result.enabled && mining_result.running); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, kServerError, se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#eth_coinbase Task EthereumRpcApi::handle_eth_coinbase(const nlohmann::json& request, nlohmann::json& reply) { try { const auto coinbase_address = co_await backend_->etherbase(); reply = make_json_content(request, coinbase_address); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, kServerError, se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#eth_hashrate Task EthereumRpcApi::handle_eth_hashrate(const nlohmann::json& request, nlohmann::json& reply) { try { const auto hash_rate = co_await miner_->get_hash_rate(); reply = make_json_content(request, to_quantity(hash_rate)); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, kServerError, se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#eth_submithashrate Task EthereumRpcApi::handle_eth_submit_hashrate(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { const auto error_msg = "invalid eth_submitHashrate params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto hash_rate = params[0].get(); const auto id = params[1].get(); const auto success = co_await miner_->submit_hash_rate(hash_rate, id); reply = make_json_content(request, success); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, kServerError, se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#eth_getwork Task EthereumRpcApi::handle_eth_get_work(const nlohmann::json& request, nlohmann::json& reply) { try { const auto work = co_await miner_->get_work(); const std::vector current_work{ silkworm::to_hex(work.header_hash), silkworm::to_hex(work.seed_hash), silkworm::to_hex(work.target), silkworm::to_hex(work.block_num)}; reply = make_json_content(request, current_work); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, kServerError, se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#eth_submitwork Task EthereumRpcApi::handle_eth_submit_work(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 3) { const auto error_msg = "invalid eth_submitWork params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } try { const auto block_nonce = silkworm::from_hex(params[0].get()); if (!block_nonce.has_value()) { const auto error_msg = "invalid eth_submitWork params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); co_return; } const auto pow_hash = params[1].get(); const auto digest = params[2].get(); const auto success = co_await miner_->submit_work(block_nonce.value(), pow_hash, digest); reply = make_json_content(request, success); } catch (const boost::system::system_error& se) { SILK_ERROR << "error: \"" << se.code().message() << "\" processing request: " << request.dump(); reply = make_json_error(request, kServerError, se.code().message()); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#eth_subscribe Task EthereumRpcApi::handle_eth_subscribe(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { reply = make_json_content(request, to_quantity(0)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_unsubscribe Task EthereumRpcApi::handle_eth_unsubscribe(const nlohmann::json& request, nlohmann::json& reply) { auto tx = co_await database_->begin_transaction(); try { reply = make_json_content(request, to_quantity(0)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_feehistory Task EthereumRpcApi::handle_eth_fee_history(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 3) { const auto error_msg = "invalid eth_feeHistory params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); co_return; } uint64_t block_count{0}; if (params[0].is_string()) { const auto value = params[0].get(); size_t processed_characters{0}; block_count = std::stoul(value, &processed_characters, 16); if (processed_characters != value.size()) { const auto error_msg = "invalid block_count: " + value; SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); co_return; } } else { block_count = params[0].get(); } const auto newest_block = params[1].get(); const auto reward_percentiles = params[2].get>(); SILK_TRACE << "block_count: " << block_count << " newest_block: " << newest_block << " reward_percentiles size: " << reward_percentiles.size(); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; rpc::fee_history::BlockHeaderProvider block_header_provider = [&chain_storage](BlockNum block_num) { return chain_storage->read_canonical_header(block_num); }; rpc::fee_history::BlockProvider block_provider = [this, &block_reader](BlockNum block_num) { return block_reader.read_block_by_number(*block_cache_, block_num); }; rpc::fee_history::ReceiptsProvider receipts_provider = [&tx, &chain_storage, this](const BlockWithHash& block_with_hash) { return core::get_receipts(*tx, block_with_hash, *chain_storage, this->workers_); }; rpc::fee_history::LatestBlockProvider latest_block_provider = [&block_reader]() { return block_reader.get_block_num(kLatestBlockId); }; const auto chain_config = co_await chain_storage->read_chain_config(); rpc::fee_history::FeeHistoryOracle oracle{chain_config, block_header_provider, block_provider, receipts_provider, latest_block_provider}; const auto block_num = co_await block_reader.get_block_num(newest_block); const auto fee_history = co_await oracle.fee_history(block_num, block_count, reward_percentiles); if (fee_history.error) { reply = make_json_error(request, kServerError, fee_history.error.value()); } else { reply = make_json_content(request, fee_history); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task EthereumRpcApi::handle_eth_base_fee(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (!params.empty()) { const auto error_msg = "invalid eth_baseFee params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); co_return; } auto tx = co_await database_->begin_transaction(); try { intx::uint256 base_fee{0}; const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto chain_config = co_await chain_storage->read_chain_config(); const auto latest_block_num = co_await block_reader.get_block_num(kLatestBlockId); const auto latest_block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, latest_block_num); if (!latest_block_with_hash) { reply = make_json_content(request, to_quantity(base_fee)); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } auto& header = latest_block_with_hash->block.header; if (chain_config.is_london(header.number + 1)) { base_fee = protocol::expected_base_fee_per_gas(header); } else { base_fee = 0; } reply = make_json_content(request, to_quantity(base_fee)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task EthereumRpcApi::handle_eth_blob_base_fee(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (!params.empty()) { const auto error_msg = "invalid eth_blobBaseFee params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, 100, error_msg); co_return; } auto tx = co_await database_->begin_transaction(); try { intx::uint256 blob_base_fee{0}; const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto latest_block_num = co_await block_reader.get_block_num(kLatestBlockId); const auto latest_block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, latest_block_num); if (!latest_block_with_hash) { reply = make_json_content(request, to_quantity(blob_base_fee)); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } auto& header = latest_block_with_hash->block.header; if (header.excess_blob_gas) { const auto revision = header.requests_hash ? EVMC_PRAGUE : EVMC_CANCUN; blob_base_fee = calc_blob_gas_price(protocol::calc_excess_blob_gas(header, revision), revision); } else { blob_base_fee = 0; } reply = make_json_content(request, to_quantity(blob_base_fee)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } // https://eth.wiki/json-rpc/API#eth_getblockreceipts Task EthereumRpcApi::handle_eth_get_block_receipts(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid eth_getBlockReceipts params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].get(); SILK_DEBUG << "block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; const BlockReader block_reader{*chain_storage, *tx}; const auto block_num_or_hash = BlockNumOrHash{block_id}; const auto block_num = co_await block_reader.get_block_num(block_num_or_hash); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num.first); if (block_with_hash) { auto receipts_ptr{co_await core::get_receipts(*tx, *block_with_hash, *chain_storage, workers_)}; auto& receipts = *receipts_ptr; SILK_TRACE << "#receipts: " << receipts.size(); const auto& block{block_with_hash->block}; if (receipts.size() == block.transactions.size()) { for (size_t i{0}; i < block.transactions.size(); ++i) { receipts[i]->effective_gas_price = block.transactions[i].effective_gas_price(block.header.base_fee_per_gas.value_or(0)); } reply = make_json_content(request, receipts); } else { reply = make_json_content(request, {}); } } else { reply = make_json_content(request, {}); } } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/eth_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { using db::kv::api::StateCache; class EthereumRpcApi { public: EthereumRpcApi(boost::asio::io_context& ioc, WorkerPool& workers) : ioc_{ioc}, block_cache_{must_use_shared_service(ioc_)}, state_cache_{must_use_shared_service(ioc_)}, database_{must_use_private_service(ioc_)->service()}, backend_{must_use_private_service(ioc_)}, miner_{must_use_private_service(ioc_)}, tx_pool_{must_use_private_service(ioc_)}, filter_storage_{must_use_shared_service(ioc_)}, workers_{workers} {} virtual ~EthereumRpcApi() = default; EthereumRpcApi(const EthereumRpcApi&) = delete; EthereumRpcApi& operator=(const EthereumRpcApi&) = delete; EthereumRpcApi(EthereumRpcApi&&) = default; protected: Task handle_eth_block_num(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_chain_id(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_protocol_version(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_syncing(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_gas_price(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_block_transaction_count_by_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_block_transaction_count_by_number(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_uncle_count_by_block_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_uncle_count_by_block_num(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_transaction_by_block_hash_and_index(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_transaction_by_block_num_and_index(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_raw_transaction_by_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_raw_transaction_by_block_hash_and_index(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_raw_transaction_by_block_num_and_index(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_transaction_receipt(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_estimate_gas(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_balance(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_code(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_transaction_count(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_storage_at(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_call_bundle(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_create_access_list(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_new_filter(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_new_block_filter(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_new_pending_transaction_filter(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_filter_logs(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_filter_changes(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_uninstall_filter(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_send_raw_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_send_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_sign_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_proof(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_mining(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_coinbase(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_hashrate(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_submit_hashrate(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_work(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_submit_work(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_subscribe(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_unsubscribe(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_max_priority_fee_per_gas(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_fee_history(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_call_many(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_blob_base_fee(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_base_fee(const nlohmann::json& request, nlohmann::json& reply); Task handle_eth_get_block_receipts(const nlohmann::json& request, nlohmann::json& reply); // GLAZE format routine Task handle_eth_get_logs(const nlohmann::json& request, std::string& reply); Task handle_eth_call(const nlohmann::json& request, std::string& reply); Task handle_eth_get_block_by_number(const nlohmann::json& request, std::string& reply); Task handle_eth_get_block_by_hash(const nlohmann::json& request, std::string& reply); Task handle_eth_get_uncle_by_block_hash_and_index(const nlohmann::json& request, std::string& reply); Task handle_eth_get_uncle_by_block_num_and_index(const nlohmann::json& request, std::string& reply); Task handle_eth_get_transaction_by_hash(const nlohmann::json& request, std::string& reply); boost::asio::io_context& ioc_; BlockCache* block_cache_; StateCache* state_cache_; std::shared_ptr database_; ethbackend::BackEnd* backend_; txpool::Miner* miner_; txpool::TransactionPool* tx_pool_; FilterStorage* filter_storage_; WorkerPool& workers_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/eth_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include namespace silkworm::rpc::commands { #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(test_util::RpcApiE2ETest, "unit: eth_blockNumber succeeds if request well-formed", "[rpc][api]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "result":"0x9" })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "unit: eth_blockNumber fails if request empty", "[rpc][api]") { const nlohmann::json request = R"({})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":null, "error":{"code":-32600,"message":"invalid request"} })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "unit: eth_sendRawTransaction fails rlp parsing", "[rpc][api]") { const nlohmann::json request = R"({ "jsonrpc": "2.0", "id": 1, "method": "eth_sendRawTransaction", "params": ["0xd46ed67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f0724456"] })"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32000,"message":"rlp: input exceeds encoded length"} })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "unit: eth_sendRawTransaction fails length", "[rpc][api]") { const nlohmann::json request = R"({ "jsonrpc": "2.0", "id": 1, "method": "eth_sendRawTransaction", "params": ["0x01f87482053980843b9aca008509502f9000830493e080809a608060405260098060116000396000f3fe6080604052600080fdc001a02f770992b74b52f9e2beef5b33376590e6dc7669ee7ab648e1e31ad3a377f627a07c3030ba71736bb982ccbb1e36b073489abe0c18ffc14be5206c29f1c026c99a"] })"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32000,"message":"rlp: unexpected Length"} })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "unit: eth_sendRawTransaction fails to send", "[rpc][api]") { const nlohmann::json request = R"({ "jsonrpc": "2.0", "id": 1, "method": "eth_sendRawTransaction", "params": ["0x02f87482053980843b9aca008509502f9000830493e080809a608060405260098060116000396000f3fe6080604052600080fdc001a02f770992b74b52f9e2beef5b33376590e6dc7669ee7ab648e1e31ad3a377f627a07c3030ba71736bb982ccbb1e36b073489abe0c18ffc14be5206c29f1c026c99a"] })"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); auto reply_json = nlohmann::json::parse(reply); CHECK(reply_json["jsonrpc"] == "2.0"); CHECK(reply_json["id"] == 1); REQUIRE(reply_json["error"].is_object()); CHECK(reply_json["error"]["code"] == 100); CHECK_THAT(reply_json["error"]["message"], Catch::Matchers::StartsWith("failed to connect to all addresses; last error: UNKNOWN: ipv4:127.0.0.1:12345: Failed to connect to remote host")); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "unit: eth_feeHistory succeeds if request well-formed", "[rpc][api]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["0x1","0x9",[25,75]]})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "result":{"baseFeePerBlobGas":["0x0","0x0"],"baseFeePerGas":["0x122af097","0xfea74b1"],"blobGasUsedRatio":[0.0],"gasUsedRatio":[0.0042],"oldestBlock":"0x9","reward":[["0x1","0x1"]]} })"_json); } #ifdef notdef // temporarily commented out waiting for LocalTransaction implementation TEST_CASE_METHOD(test_util::RpcApiE2ETest, "eth_call without params on gas", "[rpc][api]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{}, "latest"]})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "result":"0x" })"_json); } #endif TEST_CASE_METHOD(test_util::RpcApiE2ETest, "fuzzy: eth_feeHistory sigsegv invalid input", "[rpc][api]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["5x1","0x2",[95,99]]})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":100,"message":"invalid block_count: 5x1"} })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "fuzzy: eth_feeHistory sigsegv valid input", "[rpc][api]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["0x5","0x2",[95,99]]})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "result":{ "baseFeePerBlobGas":["0x0","0x0","0x0","0x0"], "baseFeePerGas":["0x3b9aca00","0x342770c0","0x2db08786","0x2806be9d"], "blobGasUsedRatio":[0.0,0.0,0.0], "gasUsedRatio":[0.0,0.0042,0.0042], "oldestBlock":"0x0", "reward":[["0x0","0x0"],["0x1","0x1"],["0x1","0x1"]]} })"_json); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/net_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "net_api.hpp" #include #include #include #include namespace silkworm::rpc::commands { // https://eth.wiki/json-rpc/API#net_listening Task NetRpcApi::handle_net_listening(const nlohmann::json& request, nlohmann::json& reply) { try { co_await backend_->peers(); reply = make_json_content(request, true); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_content(request, false); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_content(request, false); } } // https://eth.wiki/json-rpc/API#net_peercount Task NetRpcApi::handle_net_peer_count(const nlohmann::json& request, nlohmann::json& reply) { try { const auto peer_count = co_await backend_->net_peer_count(); reply = make_json_content(request, to_quantity(peer_count)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#net_version Task NetRpcApi::handle_net_version(const nlohmann::json& request, nlohmann::json& reply) { try { const auto net_version = co_await backend_->net_version(); reply = make_json_content(request, std::to_string(net_version)); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/net_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class NetRpcApi { public: explicit NetRpcApi(ethbackend::BackEnd* backend) : backend_(backend) {} explicit NetRpcApi(boost::asio::io_context& ioc) : NetRpcApi(must_use_private_service(ioc)) {} virtual ~NetRpcApi() = default; NetRpcApi(const NetRpcApi&) = delete; NetRpcApi& operator=(const NetRpcApi&) = delete; NetRpcApi(NetRpcApi&&) = default; protected: Task handle_net_listening(const nlohmann::json& request, nlohmann::json& reply); Task handle_net_peer_count(const nlohmann::json& request, nlohmann::json& reply); Task handle_net_version(const nlohmann::json& request, nlohmann::json& reply); private: friend class silkworm::rpc::json_rpc::RequestHandler; ethbackend::BackEnd* backend_; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/net_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "net_api.hpp" #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include namespace silkworm::rpc::commands { #ifndef SILKWORM_SANITIZE TEST_CASE("NetRpcApi::NetRpcApi", "[rpc][erigon_api]") { boost::asio::io_context ioc; auto grpc_channel{grpc::CreateChannel("localhost", grpc::InsecureChannelCredentials())}; agrpc::GrpcContext grpc_context; add_private_service( ioc, std::make_unique(grpc_channel, grpc_context)); CHECK_NOTHROW(NetRpcApi{ioc}); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/ots_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ots_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { using namespace silkworm::db; using db::kv::StateReader; namespace bitmap { using namespace silkworm::datastore::kvdb::bitmap; } //! The current supported version of the Otterscan API static constexpr int kCurrentApiLevel{8}; //! The window size used when probing history periodically static constexpr uint64_t kTxnProbeWindowSize{4096}; //! The maximum allowed page size for the Otterscan API static constexpr int kMaxPageSize{25}; Task OtsRpcApi::handle_ots_get_api_level(const nlohmann::json& request, nlohmann::json& reply) { reply = make_json_content(request, kCurrentApiLevel); co_return; } Task OtsRpcApi::handle_ots_has_code(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { const auto error_msg = "invalid ots_hasCode params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); const auto block_id = params[1].is_string() ? params[1].get() : to_quantity(params[1].get()); SILK_DEBUG << "address: " << address << " block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; // Check if target block is the latest one: use local state cache (if any) for target transaction const bool is_latest_block = co_await block_reader.is_latest_block_num(BlockNumOrHash{block_id}); std::optional txn_id; if (!is_latest_block) { const auto block_num = co_await block_reader.get_block_num(block_id); txn_id = co_await tx->user_txn_id_at(block_num + 1); } StateReader state_reader{*tx, txn_id}; std::optional account{co_await state_reader.read_account(address)}; if (account) { auto code{co_await state_reader.read_code(address, account->code_hash)}; reply = make_json_content(request, code.has_value()); } else { reply = make_json_content(request, false); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_content(request, false); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_get_block_details(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid handle_ots_getBlockDetails params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].is_string() ? params[0].get() : to_quantity(params[0].get()); SILK_DEBUG << "block_id: " << block_id; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (block_with_hash) { const Block extended_block{block_with_hash, false}; const auto block_size = extended_block.get_block_size(); const BlockDetails block_details{block_size, block_with_hash->hash, block_with_hash->block.header, block_with_hash->block.transactions.size(), block_with_hash->block.ommers, block_with_hash->block.withdrawals}; const auto receipts = co_await core::get_receipts(*tx, *block_with_hash, *chain_storage, workers_); const auto chain_config = co_await chain_storage->read_chain_config(); const IssuanceDetails issuance = get_issuance(chain_config, *block_with_hash); const intx::uint256 total_fees = get_block_fees(*receipts); const BlockDetailsResponse block_details_response{block_details, issuance, total_fees}; reply = make_json_content(request, block_details_response); } else { reply = make_json_content(request, nlohmann::detail::value_t::null); } } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_get_block_details_by_hash(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid ots_getBlockDetailsByHash params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto block_hash = params[0].get(); SILK_DEBUG << "block_hash: " << silkworm::to_hex(block_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader reader{*chain_storage, *tx}; const auto block_with_hash = co_await reader.read_block_by_hash(*block_cache_, block_hash); if (block_with_hash) { const Block extended_block{block_with_hash, false}; const auto block_size = extended_block.get_block_size(); const BlockDetails block_details{block_size, block_with_hash->hash, block_with_hash->block.header, block_with_hash->block.transactions.size(), block_with_hash->block.ommers, block_with_hash->block.withdrawals}; const auto receipts = co_await core::get_receipts(*tx, *block_with_hash, *chain_storage, workers_); const auto chain_config = co_await chain_storage->read_chain_config(); const IssuanceDetails issuance = get_issuance(chain_config, *block_with_hash); const intx::uint256 total_fees = get_block_fees(*receipts); const BlockDetailsResponse block_details_response{block_details, issuance, total_fees}; reply = make_json_content(request, block_details_response); } else { reply = make_json_content(request, nlohmann::detail::value_t::null); } } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_get_block_transactions(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 3) { auto error_msg = "invalid ots_getBlockTransactions params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_id = params[0].is_string() ? params[0].get() : to_quantity(params[0].get()); const auto page_number = params[1].get(); const auto page_size = params[2].get(); SILK_DEBUG << "block_id: " << block_id << " page_number: " << page_number << " page_size: " << page_size; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (block_with_hash) { const Block extended_block{block_with_hash, false}; auto receipts = co_await core::get_receipts(*tx, *block_with_hash, *chain_storage, workers_); auto block_size = extended_block.get_block_size(); auto transaction_count = block_with_hash->block.transactions.size(); BlockTransactionsResponse block_transactions{ block_size, block_with_hash->hash, block_with_hash->block.header, transaction_count, block_with_hash->block.ommers, {}, // receipt {}, // transactions block_with_hash->block.withdrawals}; auto page_end = block_with_hash->block.transactions.size() - (page_size * page_number); if (page_end > block_with_hash->block.transactions.size()) { page_end = 0; } auto page_start = page_end - page_size; if (page_start > page_end) { page_start = 0; } for (auto i = page_start; i < page_end; ++i) { block_transactions.receipts.push_back(*(receipts->at(i))); block_transactions.transactions.push_back(block_with_hash->block.transactions.at(i)); } reply = make_json_content(request, block_transactions); } else { reply = make_json_content(request, {}); } } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_get_transaction_by_sender_and_nonce(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 2) { const auto error_msg = "invalid ots_getTransactionBySenderAndNonce params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto sender = params[0].get(); const auto nonce = params[1].get(); SILK_DEBUG << "sender: " << sender << ", nonce: " << nonce; auto tx = co_await database_->begin_transaction(); try { auto key = db::code_domain_key(sender); db::kv::api::IndexRangeRequest query{ .table = std::string{db::table::kAccountsHistoryIdx}, .key = key, .from_timestamp = -1, .to_timestamp = -1, .ascending_order = true}; auto paginated_result = co_await tx->index_range(std::move(query)); auto it = co_await paginated_result.begin(); std::vector keys; uint64_t count = 0; TxnId prev_txn_id = 0; TxnId next_txn_id = 0; while (const auto value = co_await it->next()) { const auto txn_id = static_cast(*value); if (count++ % kTxnProbeWindowSize != 0) { next_txn_id = txn_id; continue; } SILK_DEBUG << "count: " << count << ", txnId: " << txn_id; db::kv::api::HistoryPointRequest hpq{ .table = std::string{db::table::kAccountDomain}, .key = key, .timestamp = *value}; auto result = co_await tx->history_seek(std::move(hpq)); if (!result.success) { reply = make_json_content(request, nlohmann::detail::value_t::null); co_await tx->close(); co_return; } SILK_DEBUG << "history: len:" << result.value.size() << " [" << result.value << "]"; if (result.value.empty()) { SILK_DEBUG << "history bytes empty"; prev_txn_id = txn_id; continue; } const auto account{db::state::AccountCodec::from_encoded_storage_v3(result.value)}; SILK_DEBUG << "Account: " << *account; if (account->nonce > nonce) { break; } prev_txn_id = txn_id; } SILK_DEBUG << "range -> prev_txn_id: " << prev_txn_id << ", next_txn_id: " << next_txn_id; if (next_txn_id == 0) { next_txn_id = prev_txn_id + 1; } db::txn::TxNum creation_txn_id = 0; auto index = co_await async_binary_search(static_cast(next_txn_id - prev_txn_id), [&](size_t i) -> Task { auto txn_id = i + prev_txn_id; SILK_DEBUG << "searching for txnId: " << txn_id << ", i: " << i; db::kv::api::HistoryPointRequest hpq{ .table = std::string{db::table::kAccountDomain}, .key = key, .timestamp = static_cast(txn_id)}; auto result = co_await tx->history_seek(std::move(hpq)); if (!result.success) { co_return false; } if (result.value.empty()) { creation_txn_id = static_cast(txn_id); co_return false; } const auto account{db::state::AccountCodec::from_encoded_storage_v3(result.value)}; SILK_DEBUG << "account.nonce: " << account->nonce << ", nonce: " << nonce; if (account->nonce <= nonce) { creation_txn_id = std::max(creation_txn_id, static_cast(txn_id)); co_return false; } co_return true; }); SILK_DEBUG << "after search -> index: " << index << " creationTxnId: " << creation_txn_id; if (creation_txn_id == 0) { SILK_DEBUG << "binary search in [" << prev_txn_id << ", " << next_txn_id << "] found nothing"; reply = make_json_content(request, nlohmann::detail::value_t::null); } const auto chain_storage = tx->make_storage(); auto canonical_body_provider = db::chain::canonical_body_provider_from_chain_storage(*chain_storage); const auto block_num_opt = co_await db::txn::block_num_from_tx_num(*tx, creation_txn_id, canonical_body_provider); if (block_num_opt) { const auto block_num = block_num_opt.value(); const auto min_txn_id = co_await db::txn::min_tx_num(*tx, block_num, canonical_body_provider); const auto first_txn_id = co_await tx->first_txn_num_in_block(block_num); SILK_DEBUG << "block_num: " << block_num << ", min_txn_id: " << min_txn_id << ", first_txn_id: " << first_txn_id; TxnId tx_index{0}; if (creation_txn_id == min_txn_id) { tx_index = index + prev_txn_id - min_txn_id - 1; } else { tx_index = creation_txn_id - min_txn_id - 1; } SILK_DEBUG << "block_num: " << block_num << ", tx_index: " << tx_index; const auto transaction = co_await chain_storage->read_transaction_by_idx_in_block(block_num, tx_index); if (!transaction) { SILK_DEBUG << "No transaction found in block " << block_num << " for index " << tx_index; reply = make_json_content(request, nlohmann::detail::value_t::null); } else if (transaction.value().nonce != nonce) { SILK_DEBUG << "Transaction nonce " << transaction.value().nonce << " doesn't match required nonce " << nonce; reply = make_json_content(request, nlohmann::detail::value_t::null); } else { reply = make_json_content(request, transaction.value().hash()); } } else { SILK_INFO << "No block found for txn_id " << creation_txn_id; reply = make_json_content(request, nlohmann::detail::value_t::null); } } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_get_contract_creator(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { const auto error_msg = "invalid ots_getContractCreator params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto contract_address = params[0].get(); SILK_DEBUG << "contract_address: " << contract_address; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; BlockNum block_num = co_await block_reader.get_latest_block_num(); const auto txn_number = co_await tx->user_txn_id_at(block_num); StateReader state_reader{*tx, txn_number}; std::optional account_opt{co_await state_reader.read_account(contract_address)}; if (!account_opt || account_opt.value().code_hash == kEmptyHash) { reply = make_json_content(request, nlohmann::detail::value_t::null); co_await tx->close(); co_return; } // We're searching for the creation txn of the given contract: popular contracts may have dozens of state changes // due to ETH deposits/withdrawals after contract creation, so it is optimal to search from the beginning even if // the contract has multiple incarnations. // Navigate forward on history index of accounts and probe history periodically (cheaper than traversing history) // so as a result we'll have small range of blocks for binary search or full scan. const auto key = db::code_domain_key(contract_address); db::kv::api::IndexRangeRequest query{ .table = std::string{db::table::kAccountsHistoryIdx}, .key = key, .from_timestamp = 0, .to_timestamp = -1, .ascending_order = true}; auto paginated_result = co_await tx->index_range(std::move(query)); auto it = co_await paginated_result.begin(); uint64_t count = 0; TxnId prev_txn_id = 0; TxnId next_txn_id = 0; while (const auto value = co_await it->next()) { const auto txn_id = static_cast(*value); if (count++ % kTxnProbeWindowSize != 0) { next_txn_id = txn_id; continue; } SILK_DEBUG << "txn_id:" << txn_id << ", count: " << count; db::kv::api::HistoryPointRequest hpq{ .table = std::string{db::table::kAccountDomain}, .key = key, .timestamp = *value}; auto result = co_await tx->history_seek(std::move(hpq)); if (!result.success) { reply = make_json_content(request, nlohmann::detail::value_t::null); co_await tx->close(); co_return; } if (result.value.empty()) { SILK_DEBUG << "history bytes empty"; prev_txn_id = txn_id; continue; } const auto account{db::state::AccountCodec::from_encoded_storage_v3(result.value)}; SILK_DEBUG << "Decoded account: " << *account; if (account->incarnation == account_opt.value().incarnation) { next_txn_id = txn_id; break; } prev_txn_id = txn_id; } if (next_txn_id == 0) { next_txn_id = prev_txn_id + 1; } db::txn::TxNum creation_txn_id = 0; auto index = co_await async_binary_search(static_cast(next_txn_id - prev_txn_id), [&](size_t i) -> Task { auto txn_id = i + prev_txn_id; db::kv::api::HistoryPointRequest hpq{ .table = std::string{db::table::kAccountDomain}, .key = key, .timestamp = static_cast(txn_id)}; auto result = co_await tx->history_seek(std::move(hpq)); if (!result.success) { co_return false; } if (result.value.empty()) { creation_txn_id = std::max(static_cast(txn_id), creation_txn_id); co_return false; } co_return true; }); if (creation_txn_id == 0) { SILK_DEBUG << "binary search in [" << prev_txn_id << ", " << next_txn_id << "] found nothing"; reply = make_json_content(request, nlohmann::detail::value_t::null); } auto canonical_body_provider = db::chain::canonical_body_provider_from_chain_storage(*chain_storage); const auto block_num_opt = co_await db::txn::block_num_from_tx_num(*tx, creation_txn_id, canonical_body_provider); if (block_num_opt) { block_num = block_num_opt.value(); const auto min_txn_id = co_await db::txn::min_tx_num(*tx, block_num, canonical_body_provider); const auto first_txn_id = co_await tx->first_txn_num_in_block(block_num); SILK_DEBUG << "block_num: " << block_num << ", min_txn_id: " << min_txn_id << ", first_txn_id: " << first_txn_id; TxnId tx_index{0}; if (creation_txn_id == min_txn_id) { tx_index = index + prev_txn_id - min_txn_id - 1; } else { tx_index = creation_txn_id - min_txn_id - 1; } const auto transaction = co_await chain_storage->read_transaction_by_idx_in_block(block_num, tx_index); if (!transaction) { SILK_DEBUG << "No transaction found in block " << block_num << " for index " << tx_index; reply = make_json_content(request, nlohmann::detail::value_t::null); co_await tx->close(); co_return; } auto header = co_await chain_storage->read_canonical_header(block_num); if (!header) { SILK_DEBUG << "block not found" << block_num << " for index " << tx_index; reply = make_json_content(request, nlohmann::detail::value_t::null); co_await tx->close(); co_return; } const silkworm::Block block{.header = std::move(*header)}; trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; const auto result = co_await executor.trace_deploy_transaction(block, contract_address, *transaction, creation_txn_id); reply = make_json_content(request, result); } else { SILK_DEBUG << "No block found for txn_id " << creation_txn_id; reply = make_json_content(request, nlohmann::detail::value_t::null); } } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_trace_transaction(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { const auto error_msg = "invalid ots_traceTransaction params: " + params.dump(); SILK_ERROR << error_msg << "\n"; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; BlockReader block_reader{*chain_storage, *tx}; const auto transaction_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!transaction_with_block.has_value()) { const auto error_msg = "transaction 0x" + silkworm::to_hex(transaction_hash) + " not found"; reply = make_json_error(request, kServerError, error_msg); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const auto result = co_await executor.trace_transaction_entries(transaction_with_block.value()); reply = make_json_content(request, result); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_get_transaction_error(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { const auto error_msg = "invalid ots_getTransactionError params: " + params.dump(); SILK_ERROR << error_msg << "\n"; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; BlockReader block_reader{*chain_storage, *tx}; const auto transaction_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!transaction_with_block.has_value()) { const auto error_msg = "transaction 0x" + silkworm::to_hex(transaction_hash) + " not found"; reply = make_json_error(request, kServerError, error_msg); co_await tx->close(); co_return; } const auto result = co_await executor.trace_transaction_error(transaction_with_block.value()); reply = make_json_content(request, result); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_get_internal_operations(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { const auto error_msg = "invalid ots_getInternalOperations params: " + params.dump(); SILK_ERROR << error_msg << "\n"; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); SILK_DEBUG << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage{tx->make_storage()}; trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; BlockReader block_reader{*chain_storage, *tx}; const auto transaction_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!transaction_with_block.has_value()) { const auto error_msg = "transaction 0x" + silkworm::to_hex(transaction_hash) + " not found"; reply = make_json_error(request, kServerError, error_msg); co_await tx->close(); co_return; } const auto result = co_await executor.trace_operations(transaction_with_block.value()); reply = make_json_content(request, result); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } struct BlockInfo { BlockNum block_num{0}; BlockDetails details; }; Task OtsRpcApi::handle_ots_search_transactions_before(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 3) { const auto error_msg = "invalid ots_search_transactions_before params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); auto block_num = params[1].get(); const auto page_size = params[2].get(); SILK_DEBUG << "address: " << address << ", block_num: " << block_num << ", page_size: " << page_size; if (page_size > kMaxPageSize) { auto error_msg = "max allowed page size: " + std::to_string(kMaxPageSize); SILK_DEBUG << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } if (block_num > 0) { --block_num; } auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); auto canonical_body_provider = db::chain::canonical_body_provider_from_chain_storage(*chain_storage); db::kv::api::Timestamp from_timestamp{-1}; if (block_num > 0) { const auto max_tx_num = co_await db::txn::max_tx_num(*tx, block_num, canonical_body_provider); from_timestamp = static_cast(max_tx_num); SILK_DEBUG << "block_num: " << block_num << " max_tx_num: " << max_tx_num; } const TransactionsWithReceipts results = co_await collect_transactions_with_receipts( *tx, chain_storage, canonical_body_provider, block_num, address, from_timestamp, /*ascending=*/false, page_size); reply = make_json_content(request, results); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::handle_ots_search_transactions_after(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 3) { const auto error_msg = "invalid handle_ots_search_transactions_after params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); auto block_num = params[1].get(); const auto page_size = params[2].get(); SILK_DEBUG << "address: " << address << " block_num: " << block_num << " page_size: " << page_size; if (page_size > kMaxPageSize) { auto error_msg = "max allowed page size: " + std::to_string(kMaxPageSize); SILK_DEBUG << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); auto canonical_body_provider = db::chain::canonical_body_provider_from_chain_storage(*chain_storage); db::kv::api::Timestamp from_timestamp{-1}; if (block_num > 0) { const auto max_tx_num = co_await db::txn::min_tx_num(*tx, block_num + 1, canonical_body_provider); from_timestamp = static_cast(max_tx_num); SILK_DEBUG << "block_num: " << block_num << " max_tx_num: " << max_tx_num; } TransactionsWithReceipts results = co_await collect_transactions_with_receipts( *tx, chain_storage, canonical_body_provider, block_num, address, from_timestamp, /*ascending=*/true, page_size); std::ranges::reverse(results.transactions); std::ranges::reverse(results.receipts); std::ranges::reverse(results.headers); reply = make_json_content(request, results); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, nlohmann::detail::value_t::null); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } Task OtsRpcApi::collect_transactions_with_receipts( kv::api::Transaction& tx, const std::shared_ptr& chain_storage, db::chain::CanonicalBodyForStorageProvider& provider, BlockNum block_num_param, const evmc::address& address, db::kv::api::Timestamp from_timestamp, bool ascending, uint64_t page_size) { const auto key = db::code_domain_key(address); db::kv::api::IndexRangeRequest query_to{ .table = std::string{db::table::kTracesToIdx}, .key = key, .from_timestamp = from_timestamp, .to_timestamp = -1, .ascending_order = ascending}; auto paginated_result_to = co_await tx.index_range(std::move(query_to)); db::kv::api::IndexRangeRequest query_from{ .table = std::string{db::table::kTracesFromIdx}, .key = key, .from_timestamp = from_timestamp, .to_timestamp = -1, .ascending_order = ascending}; auto paginated_result_from = co_await tx.index_range(std::move(query_from)); auto it_from = co_await paginated_result_from.begin(); auto it_to = co_await paginated_result_to.begin(); TransactionsWithReceipts results; if (ascending) { results.first_page = true; results.last_page = block_num_param == 0; } else { results.first_page = block_num_param == 0; results.last_page = true; } std::map receipts; std::optional block_info; auto paginated_stream = db::kv::api::set_union(std::move(it_from), std::move(it_to), ascending); auto txn_nums_it = db::txn::make_txn_nums_stream(std::move(paginated_stream), ascending, tx, provider); silkworm::Block block; std::optional header; while (const auto tnx_nums = co_await txn_nums_it->next()) { SILK_DEBUG << "txn_id: " << tnx_nums->txn_id << " block_num: " << tnx_nums->block_num << ", tnx_index: " << (tnx_nums->txn_index ? std::to_string(*tnx_nums->txn_index) : "") << ", ascending: " << std::boolalpha << ascending; if (tnx_nums->block_changed) { block_info.reset(); // Even if the desired page size is reached, drain the entire matching txs inside the block to reproduce E2 // behavior. An E3 paginated-aware ots spec could improve in this area. if (results.transactions.size() >= page_size) { if (ascending) { results.first_page = false; } else { results.last_page = false; } break; } } if (!tnx_nums->txn_index) { continue; } if (tnx_nums->block_changed) { header = co_await chain_storage->read_canonical_header(tnx_nums->block_num); if (!header) { SILK_DEBUG << "Not found header no. " << tnx_nums->block_num; break; } block.header = std::move(*header); } SILKWORM_ASSERT(header); auto transaction = co_await chain_storage->read_transaction_by_idx_in_block(tnx_nums->block_num, tnx_nums->txn_index.value()); if (!transaction) { SILK_DEBUG << "No transaction found in block " << tnx_nums->block_num << " for index " << tnx_nums->txn_index.value(); continue; } auto receipt = co_await core::get_receipt(tx, block, tnx_nums->txn_id, tnx_nums->txn_index.value(), *transaction, *chain_storage, workers_); if (!receipt) { SILK_DEBUG << "No receipt found in block " << tnx_nums->block_num << " for index " << tnx_nums->txn_index.value(); continue; } results.receipts.push_back(std::move(*receipt)); results.transactions.push_back(std::move(*transaction)); results.headers.push_back(block.header); } SILK_DEBUG << "Results transactions size: " << results.transactions.size() << " receipts size: " << results.receipts.size(); co_return results; } IssuanceDetails OtsRpcApi::get_issuance(const silkworm::ChainConfig& config, const silkworm::BlockWithHash& block) { const auto rule_set_factory = protocol::rule_set_factory(config); const auto block_reward{rule_set_factory->compute_reward(block.block)}; intx::uint256 ommers_reward = std::accumulate(block_reward.ommers.begin(), block_reward.ommers.end(), intx::uint256{0}); IssuanceDetails issuance{ .miner_reward = block_reward.miner, .ommers_reward = ommers_reward, .total_reward = block_reward.miner + ommers_reward}; return issuance; } intx::uint256 OtsRpcApi::get_block_fees(const std::vector>& receipts) { intx::uint256 fees = 0; for (const auto& receipt : receipts) { fees += receipt->effective_gas_price * receipt->gas_used; } return fees; } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/ots_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { using db::kv::api::KeyValue; using db::kv::api::StateCache; class OtsRpcApi { public: OtsRpcApi(boost::asio::io_context& ioc, WorkerPool& workers) : ioc_{ioc}, workers_{workers}, database_{must_use_private_service(ioc_)->service()}, state_cache_{must_use_shared_service(ioc_)}, block_cache_{must_use_shared_service(ioc_)} {} virtual ~OtsRpcApi() = default; OtsRpcApi(const OtsRpcApi&) = delete; OtsRpcApi& operator=(const OtsRpcApi&) = delete; OtsRpcApi(OtsRpcApi&&) = default; protected: Task handle_ots_get_api_level(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_has_code(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_get_block_details(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_get_block_details_by_hash(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_get_block_transactions(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_get_transaction_by_sender_and_nonce(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_get_contract_creator(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_trace_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_get_transaction_error(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_get_internal_operations(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_search_transactions_before(const nlohmann::json& request, nlohmann::json& reply); Task handle_ots_search_transactions_after(const nlohmann::json& request, nlohmann::json& reply); boost::asio::io_context& ioc_; WorkerPool& workers_; std::shared_ptr database_; StateCache* state_cache_; BlockCache* block_cache_; friend class silkworm::rpc::json_rpc::RequestHandler; private: static IssuanceDetails get_issuance(const silkworm::ChainConfig& chain_config, const silkworm::BlockWithHash& block); static intx::uint256 get_block_fees(const std::vector>& receipts); Task collect_transactions_with_receipts( db::kv::api::Transaction& tx, const std::shared_ptr& chain_storage, db::chain::CanonicalBodyForStorageProvider& provider, BlockNum block_num_param, const evmc::address& address, db::kv::api::Timestamp from_timestamp, bool ascending, uint64_t page_size); }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/parity_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "parity_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { using db::kv::StateReader; Task ParityRpcApi::handle_parity_list_storage_keys(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid parity_listStorageKeys params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto address = params[0].get(); const auto quantity = params[1].get(); std::optional offset = std::nullopt; if (params.size() >= 3 && !params[2].is_null()) { auto value = params[2].get(); offset = silkworm::from_hex(value); } std::string block_id{kLatestBlockId}; if (params.size() >= 4) { block_id = params[3].get(); } SILK_TRACE << "parity_listStorageKeys: address=" << address << " quantity=" << quantity << " offset=" << (offset ? silkworm::to_hex(offset.value(), true) : "null"); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); rpc::BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_block_num(block_id); SILK_TRACE << "read account with address: " << address << " block number: " << block_num; std::optional txn_number; const bool is_latest_block = co_await block_reader.is_latest_block_num(block_num); if (!is_latest_block) { txn_number = co_await tx->user_txn_id_at(block_num); } StateReader state_reader{*tx, txn_number}; std::optional account = co_await state_reader.read_account(address); if (!account) throw std::domain_error{"account not found"}; auto from = db::code_domain_key(address); if (offset) { from.append(offset.value()); } auto to = db::code_domain_key(address); increment(to); SILK_TRACE << "handle_parity_list_storage_keys: from=" << from << ", to=" << to; db::kv::api::DomainRangeRequest query{ .table = std::string{db::table::kStorageDomain}, .from_key = from, .to_key = to, .timestamp = txn_number, .ascending_order = true, .limit = quantity}; auto paginated_result = co_await tx->range_as_of(std::move(query)); auto it = co_await paginated_result.begin(); std::vector keys; while (const auto value = co_await it->next()) { SILKWORM_ASSERT(value->first.size() >= kAddressLength); const auto key = value->first.substr(kAddressLength); keys.push_back(silkworm::to_hex(key, /*with_prefix=*/true)); } reply = make_json_content(request, keys); } catch (const std::invalid_argument& iv) { SILK_WARN << "invalid_argument: " << iv.what() << " processing request: " << request.dump(); reply = make_json_content(request, {}); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/parity_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { using db::kv::api::StateCache; class ParityRpcApi { public: explicit ParityRpcApi(boost::asio::io_context& ioc, WorkerPool& workers) : block_cache_{must_use_shared_service(ioc)}, state_cache_{must_use_shared_service(ioc)}, database_{must_use_private_service(ioc)->service()}, backend_{must_use_private_service(ioc)}, workers_{workers} {} virtual ~ParityRpcApi() = default; ParityRpcApi(const ParityRpcApi&) = delete; ParityRpcApi& operator=(const ParityRpcApi&) = delete; ParityRpcApi(ParityRpcApi&&) = default; protected: Task handle_parity_list_storage_keys(const nlohmann::json& request, nlohmann::json& reply); private: BlockCache* block_cache_; StateCache* state_cache_; std::shared_ptr database_; ethbackend::BackEnd* backend_; WorkerPool& workers_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/parity_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include namespace silkworm::rpc::commands { #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(test_util::RpcApiE2ETest, "parity_getBlockReceipts: misnamed 'params' field", "[rpc][api]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1,"method":"parity_getBlockReceipts","pirams":["0x0"]})"; std::string reply; run<&test_util::RequestHandlerForTest::handle_request>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "error":{"code":-32600,"message":"Invalid field: pirams"} })"_json); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/rpc_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class RpcApiTable; class RpcApi : protected EthereumRpcApi, NetRpcApi, AdminRpcApi, Web3RpcApi, DebugRpcApi, ParityRpcApi, ErigonRpcApi, TraceRpcApi, EngineRpcApi, TxPoolRpcApi, OtsRpcApi { public: explicit RpcApi( boost::asio::io_context& ioc, WorkerPool& workers, ApplicationInfo build_info = {}) : EthereumRpcApi{ioc, workers}, NetRpcApi{ioc}, AdminRpcApi{ioc}, Web3RpcApi{ioc}, DebugRpcApi{ioc, workers}, ParityRpcApi{ioc, workers}, ErigonRpcApi{ioc, workers}, TraceRpcApi{ioc, workers}, EngineRpcApi(ioc, std::move(build_info)), TxPoolRpcApi(ioc), OtsRpcApi{ioc, workers} {} ~RpcApi() override = default; RpcApi(const RpcApi&) = delete; RpcApi& operator=(const RpcApi&) = delete; RpcApi(RpcApi&&) = default; friend class RpcApiTable; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/rpc_api_table.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rpc_api_table.hpp" #include #include #include #include namespace silkworm::rpc::commands { RpcApiTable::RpcApiTable(std::string_view api_spec) { build_handlers(api_spec); } std::optional RpcApiTable::find_json_handler(const std::string& method) const { const auto handle_method_pair = method_handlers_.find(method); if (handle_method_pair == method_handlers_.end()) { return std::nullopt; } return handle_method_pair->second; } std::optional RpcApiTable::find_json_glaze_handler(const std::string& method) const { const auto handle_method_pair = method_handlers_glaze_.find(method); if (handle_method_pair == method_handlers_glaze_.end()) { return std::nullopt; } return handle_method_pair->second; } std::optional RpcApiTable::find_stream_handler(const std::string& method) const { const auto handle_method_pair = stream_handlers_.find(method); if (handle_method_pair == stream_handlers_.end()) { return std::nullopt; } return handle_method_pair->second; } void RpcApiTable::build_handlers(std::string_view api_spec) { size_t start = 0; size_t end = api_spec.find(kApiSpecSeparator); while (end != std::string::npos) { add_handlers(api_spec.substr(start, end - start)); start = end + kApiSpecSeparator.length(); end = api_spec.find(kApiSpecSeparator, start); } add_handlers(api_spec.substr(start, end)); } void RpcApiTable::add_handlers(std::string_view api_namespace) { if (api_namespace == kAdminApiNamespace) { add_admin_handlers(); } else if (api_namespace == kDebugApiNamespace) { add_debug_handlers(); } else if (api_namespace == kEthApiNamespace) { add_eth_handlers(); } else if (api_namespace == kNetApiNamespace) { add_net_handlers(); } else if (api_namespace == kParityApiNamespace) { add_parity_handlers(); } else if (api_namespace == kErigonApiNamespace) { add_erigon_handlers(); } else if (api_namespace == kTraceApiNamespace) { add_trace_handlers(); } else if (api_namespace == kWeb3ApiNamespace) { add_web3_handlers(); } else if (api_namespace == kEngineApiNamespace) { add_engine_handlers(); } else if (api_namespace == kTxPoolApiNamespace) { add_txpool_handlers(); } else if (api_namespace == kOtterscanApiNamespace) { add_ots_handlers(); } else { SILK_WARN << "Server::add_handlers invalid namespace [" << api_namespace << "] ignored"; } } void RpcApiTable::add_admin_handlers() { method_handlers_[json_rpc::method::k_admin_nodeInfo] = &commands::RpcApi::handle_admin_node_info; method_handlers_[json_rpc::method::k_admin_peers] = &commands::RpcApi::handle_admin_peers; } void RpcApiTable::add_debug_handlers() { method_handlers_[json_rpc::method::k_debug_accountRange] = &commands::RpcApi::handle_debug_account_range; method_handlers_[json_rpc::method::k_debug_getModifiedAccountsByNumber] = &commands::RpcApi::handle_debug_get_modified_accounts_by_number; method_handlers_[json_rpc::method::k_debug_getModifiedAccountsByHash] = &commands::RpcApi::handle_debug_get_modified_accounts_by_hash; method_handlers_[json_rpc::method::k_debug_storageRangeAt] = &commands::RpcApi::handle_debug_storage_range_at; method_handlers_[json_rpc::method::k_debug_accountAt] = &commands::RpcApi::handle_debug_account_at; method_handlers_[json_rpc::method::k_debug_getRawBlock] = &commands::RpcApi::handle_debug_get_raw_block; method_handlers_[json_rpc::method::k_debug_getRawHeader] = &commands::RpcApi::handle_debug_get_raw_header; method_handlers_[json_rpc::method::k_debug_getRawTransaction] = &commands::RpcApi::handle_debug_get_raw_transaction; method_handlers_[json_rpc::method::k_debug_getRawReceipts] = &commands::RpcApi::handle_debug_get_raw_receipts; stream_handlers_[json_rpc::method::k_debug_traceCall] = &commands::RpcApi::handle_debug_trace_call; stream_handlers_[json_rpc::method::k_debug_traceCallMany] = &commands::RpcApi::handle_debug_trace_call_many; stream_handlers_[json_rpc::method::k_debug_traceTransaction] = &commands::RpcApi::handle_debug_trace_transaction; stream_handlers_[json_rpc::method::k_debug_traceBlockByNumber] = &commands::RpcApi::handle_debug_trace_block_by_number; stream_handlers_[json_rpc::method::k_debug_traceBlockByHash] = &commands::RpcApi::handle_debug_trace_block_by_hash; } void RpcApiTable::add_eth_handlers() { method_handlers_[json_rpc::method::k_eth_blockNumber] = &commands::RpcApi::handle_eth_block_num; method_handlers_[json_rpc::method::k_eth_chainId] = &commands::RpcApi::handle_eth_chain_id; method_handlers_[json_rpc::method::k_eth_protocolVersion] = &commands::RpcApi::handle_eth_protocol_version; method_handlers_[json_rpc::method::k_eth_syncing] = &commands::RpcApi::handle_eth_syncing; method_handlers_[json_rpc::method::k_eth_gasPrice] = &commands::RpcApi::handle_eth_gas_price; method_handlers_[json_rpc::method::k_eth_getBlockTransactionCountByHash] = &commands::RpcApi::handle_eth_get_block_transaction_count_by_hash; method_handlers_[json_rpc::method::k_eth_getBlockTransactionCountByNumber] = &commands::RpcApi::handle_eth_get_block_transaction_count_by_number; method_handlers_[json_rpc::method::k_eth_getUncleCountByBlockNumber] = &commands::RpcApi::handle_eth_get_uncle_count_by_block_num; method_handlers_[json_rpc::method::k_eth_getUncleCountByBlockHash] = &commands::RpcApi::handle_eth_get_uncle_count_by_block_hash; method_handlers_[json_rpc::method::k_eth_getTransactionByBlockHashAndIndex] = &commands::RpcApi::handle_eth_get_transaction_by_block_hash_and_index; method_handlers_[json_rpc::method::k_eth_getTransactionByBlockNumberAndIndex] = &commands::RpcApi::handle_eth_get_transaction_by_block_num_and_index; method_handlers_[json_rpc::method::k_eth_getRawTransactionByHash] = &commands::RpcApi::handle_eth_get_raw_transaction_by_hash; method_handlers_[json_rpc::method::k_eth_getRawTransactionByBlockHashAndIndex] = &commands::RpcApi::handle_eth_get_raw_transaction_by_block_hash_and_index; method_handlers_[json_rpc::method::k_eth_getRawTransactionByBlockNumberAndIndex] = &commands::RpcApi::handle_eth_get_raw_transaction_by_block_num_and_index; method_handlers_[json_rpc::method::k_eth_getTransactionReceipt] = &commands::RpcApi::handle_eth_get_transaction_receipt; method_handlers_[json_rpc::method::k_eth_estimateGas] = &commands::RpcApi::handle_eth_estimate_gas; method_handlers_[json_rpc::method::k_eth_getBalance] = &commands::RpcApi::handle_eth_get_balance; method_handlers_[json_rpc::method::k_eth_getCode] = &commands::RpcApi::handle_eth_get_code; method_handlers_[json_rpc::method::k_eth_getTransactionCount] = &commands::RpcApi::handle_eth_get_transaction_count; method_handlers_[json_rpc::method::k_eth_getStorageAt] = &commands::RpcApi::handle_eth_get_storage_at; method_handlers_[json_rpc::method::k_eth_callBundle] = &commands::RpcApi::handle_eth_call_bundle; method_handlers_[json_rpc::method::k_eth_createAccessList] = &commands::RpcApi::handle_eth_create_access_list; method_handlers_[json_rpc::method::k_eth_newFilter] = &commands::RpcApi::handle_eth_new_filter; method_handlers_[json_rpc::method::k_eth_newBlockFilter] = &commands::RpcApi::handle_eth_new_block_filter; method_handlers_[json_rpc::method::k_eth_newPendingTransactionFilter] = &commands::RpcApi::handle_eth_new_pending_transaction_filter; method_handlers_[json_rpc::method::k_eth_getFilterLogs] = &commands::RpcApi::handle_eth_get_filter_logs; method_handlers_[json_rpc::method::k_eth_getFilterChanges] = &commands::RpcApi::handle_eth_get_filter_changes; method_handlers_[json_rpc::method::k_eth_uninstallFilter] = &commands::RpcApi::handle_eth_uninstall_filter; method_handlers_[json_rpc::method::k_eth_sendRawTransaction] = &commands::RpcApi::handle_eth_send_raw_transaction; method_handlers_[json_rpc::method::k_eth_sendTransaction] = &commands::RpcApi::handle_eth_send_transaction; method_handlers_[json_rpc::method::k_eth_signTransaction] = &commands::RpcApi::handle_eth_sign_transaction; method_handlers_[json_rpc::method::k_eth_getProof] = &commands::RpcApi::handle_eth_get_proof; method_handlers_[json_rpc::method::k_eth_mining] = &commands::RpcApi::handle_eth_mining; method_handlers_[json_rpc::method::k_eth_coinbase] = &commands::RpcApi::handle_eth_coinbase; method_handlers_[json_rpc::method::k_eth_hashrate] = &commands::RpcApi::handle_eth_hashrate; method_handlers_[json_rpc::method::k_eth_submitHashrate] = &commands::RpcApi::handle_eth_submit_hashrate; method_handlers_[json_rpc::method::k_eth_getWork] = &commands::RpcApi::handle_eth_get_work; method_handlers_[json_rpc::method::k_eth_submitWork] = &commands::RpcApi::handle_eth_submit_work; method_handlers_[json_rpc::method::k_eth_subscribe] = &commands::RpcApi::handle_eth_subscribe; method_handlers_[json_rpc::method::k_eth_unsubscribe] = &commands::RpcApi::handle_eth_unsubscribe; method_handlers_[json_rpc::method::k_eth_getBlockReceipts] = &commands::RpcApi::handle_eth_get_block_receipts; method_handlers_[json_rpc::method::k_eth_getTransactionReceiptsByBlock] = &commands::RpcApi::handle_eth_get_block_receipts; method_handlers_[json_rpc::method::k_eth_maxPriorityFeePerGas] = &commands::RpcApi::handle_eth_max_priority_fee_per_gas; method_handlers_[json_rpc::method::k_eth_feeHistory] = &commands::RpcApi::handle_eth_fee_history; method_handlers_[json_rpc::method::k_eth_callMany] = &commands::RpcApi::handle_eth_call_many; method_handlers_[json_rpc::method::k_eth_baseFee] = &commands::RpcApi::handle_eth_base_fee; method_handlers_[json_rpc::method::k_eth_blobBaseFee] = &commands::RpcApi::handle_eth_blob_base_fee; // GLAZE methods method_handlers_glaze_[json_rpc::method::k_eth_getLogs] = &commands::RpcApi::handle_eth_get_logs; method_handlers_glaze_[json_rpc::method::k_eth_call] = &commands::RpcApi::handle_eth_call; method_handlers_glaze_[json_rpc::method::k_eth_getBlockByNumber] = &commands::RpcApi::handle_eth_get_block_by_number; method_handlers_glaze_[json_rpc::method::k_eth_getBlockByHash] = &commands::RpcApi::handle_eth_get_block_by_hash; method_handlers_glaze_[json_rpc::method::k_eth_getUncleByBlockHashAndIndex] = &commands::RpcApi::handle_eth_get_uncle_by_block_hash_and_index; method_handlers_glaze_[json_rpc::method::k_eth_getUncleByBlockNumberAndIndex] = &commands::RpcApi::handle_eth_get_uncle_by_block_num_and_index; method_handlers_glaze_[json_rpc::method::k_eth_getTransactionByHash] = &commands::RpcApi::handle_eth_get_transaction_by_hash; } void RpcApiTable::add_net_handlers() { method_handlers_[json_rpc::method::k_net_listening] = &commands::RpcApi::handle_net_listening; method_handlers_[json_rpc::method::k_net_peerCount] = &commands::RpcApi::handle_net_peer_count; method_handlers_[json_rpc::method::k_net_version] = &commands::RpcApi::handle_net_version; } void RpcApiTable::add_parity_handlers() { method_handlers_[json_rpc::method::k_parity_listStorageKeys] = &commands::RpcApi::handle_parity_list_storage_keys; } void RpcApiTable::add_erigon_handlers() { method_handlers_[json_rpc::method::k_erigon_blockNumber] = &commands::RpcApi::handle_erigon_block_num; method_handlers_[json_rpc::method::k_erigon_cacheCheck] = &commands::RpcApi::handle_erigon_cache_check; method_handlers_[json_rpc::method::k_erigon_getBalanceChangesInBlock] = &commands::RpcApi::handle_erigon_get_balance_changes_in_block; method_handlers_[json_rpc::method::k_erigon_getBlockReceiptsByBlockHash] = &commands::RpcApi::handle_erigon_get_block_receipts_by_block_hash; method_handlers_[json_rpc::method::k_erigon_getHeaderByHash] = &commands::RpcApi::handle_erigon_get_header_by_hash; method_handlers_[json_rpc::method::k_erigon_getHeaderByNumber] = &commands::RpcApi::handle_erigon_get_header_by_number; method_handlers_[json_rpc::method::k_erigon_getLatestLogs] = &commands::RpcApi::handle_erigon_get_latest_logs; method_handlers_[json_rpc::method::k_erigon_getLogsByHash] = &commands::RpcApi::handle_erigon_get_logs_by_hash; method_handlers_[json_rpc::method::k_erigon_forks] = &commands::RpcApi::handle_erigon_forks; method_handlers_[json_rpc::method::k_erigon_nodeInfo] = &commands::RpcApi::handle_erigon_node_info; // GLAZE methods method_handlers_glaze_[json_rpc::method::k_erigon_getBlockByTimestamp] = &commands::RpcApi::handle_erigon_get_block_by_timestamp; } void RpcApiTable::add_trace_handlers() { method_handlers_[json_rpc::method::k_trace_call] = &commands::RpcApi::handle_trace_call; method_handlers_[json_rpc::method::k_trace_callMany] = &commands::RpcApi::handle_trace_call_many; method_handlers_[json_rpc::method::k_trace_rawTransaction] = &commands::RpcApi::handle_trace_raw_transaction; method_handlers_[json_rpc::method::k_trace_replayBlockTransactions] = &commands::RpcApi::handle_trace_replay_block_transactions; method_handlers_[json_rpc::method::k_trace_replayTransaction] = &commands::RpcApi::handle_trace_replay_transaction; method_handlers_[json_rpc::method::k_trace_block] = &commands::RpcApi::handle_trace_block; method_handlers_[json_rpc::method::k_trace_get] = &commands::RpcApi::handle_trace_get; method_handlers_[json_rpc::method::k_trace_transaction] = &commands::RpcApi::handle_trace_transaction; stream_handlers_[json_rpc::method::k_trace_filter] = &commands::RpcApi::handle_trace_filter; } void RpcApiTable::add_web3_handlers() { method_handlers_[json_rpc::method::k_web3_clientVersion] = &commands::RpcApi::handle_web3_client_version; method_handlers_[json_rpc::method::k_web3_sha3] = &commands::RpcApi::handle_web3_sha3; } void RpcApiTable::add_engine_handlers() { method_handlers_[json_rpc::method::k_engine_exchangeCapabilities] = &commands::RpcApi::handle_engine_exchange_capabilities; method_handlers_[json_rpc::method::k_engine_getPayloadV1] = &commands::RpcApi::handle_engine_get_payload_v1; method_handlers_[json_rpc::method::k_engine_getPayloadV2] = &commands::RpcApi::handle_engine_get_payload_v2; method_handlers_[json_rpc::method::k_engine_getPayloadV3] = &commands::RpcApi::handle_engine_get_payload_v3; method_handlers_[json_rpc::method::k_engine_getPayloadV4] = &commands::RpcApi::handle_engine_get_payload_v4; method_handlers_[json_rpc::method::k_engine_getPayloadBodiesByHashV1] = &commands::RpcApi::handle_engine_get_payload_bodies_by_hash_v1; method_handlers_[json_rpc::method::k_engine_getPayloadBodiesByRangeV1] = &commands::RpcApi::handle_engine_get_payload_bodies_by_range_v1; method_handlers_[json_rpc::method::k_engine_newPayloadV1] = &commands::RpcApi::handle_engine_new_payload_v1; method_handlers_[json_rpc::method::k_engine_newPayloadV2] = &commands::RpcApi::handle_engine_new_payload_v2; method_handlers_[json_rpc::method::k_engine_newPayloadV3] = &commands::RpcApi::handle_engine_new_payload_v3; method_handlers_[json_rpc::method::k_engine_newPayloadV4] = &commands::RpcApi::handle_engine_new_payload_v4; method_handlers_[json_rpc::method::k_engine_forkchoiceUpdatedV1] = &commands::RpcApi::handle_engine_forkchoice_updated_v1; method_handlers_[json_rpc::method::k_engine_forkchoiceUpdatedV2] = &commands::RpcApi::handle_engine_forkchoice_updated_v2; method_handlers_[json_rpc::method::k_engine_forkchoiceUpdatedV3] = &commands::RpcApi::handle_engine_forkchoice_updated_v3; method_handlers_[json_rpc::method::k_engine_exchangeTransitionConfiguration] = &commands::RpcApi::handle_engine_exchange_transition_configuration_v1; method_handlers_glaze_[json_rpc::method::k_engine_getClientVersionV1] = &commands::RpcApi::handle_engine_get_client_version_v1; } void RpcApiTable::add_txpool_handlers() { method_handlers_[json_rpc::method::k_txpool_status] = &commands::RpcApi::handle_txpool_status; method_handlers_[json_rpc::method::k_txpool_content] = &commands::RpcApi::handle_txpool_content; } void RpcApiTable::add_ots_handlers() { method_handlers_[json_rpc::method::k_ots_getApiLevel] = &commands::RpcApi::handle_ots_get_api_level; method_handlers_[json_rpc::method::k_ots_hasCode] = &commands::RpcApi::handle_ots_has_code; method_handlers_[json_rpc::method::k_ots_getBlockDetails] = &commands::RpcApi::handle_ots_get_block_details; method_handlers_[json_rpc::method::k_ots_getBlockDetailsByHash] = &commands::RpcApi::handle_ots_get_block_details_by_hash; method_handlers_[json_rpc::method::k_ots_getBlockTransactions] = &commands::RpcApi::handle_ots_get_block_transactions; method_handlers_[json_rpc::method::k_ots_getTransactionBySenderAndNonce] = &commands::RpcApi::handle_ots_get_transaction_by_sender_and_nonce; method_handlers_[json_rpc::method::k_ots_getContractCreator] = &commands::RpcApi::handle_ots_get_contract_creator; method_handlers_[json_rpc::method::k_ots_traceTransaction] = &commands::RpcApi::handle_ots_trace_transaction; method_handlers_[json_rpc::method::k_ots_getTransactionError] = &commands::RpcApi::handle_ots_get_transaction_error; method_handlers_[json_rpc::method::k_ots_getInternalOperations] = &commands::RpcApi::handle_ots_get_internal_operations; method_handlers_[json_rpc::method::k_ots_search_transactions_before] = &commands::RpcApi::handle_ots_search_transactions_before; method_handlers_[json_rpc::method::k_ots_search_transactions_after] = &commands::RpcApi::handle_ots_search_transactions_after; } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/rpc_api_table.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc::commands { class RpcApiTable { public: using HandleMethod = Task (RpcApi::*)(const nlohmann::json&, nlohmann::json&); using HandleMethodGlaze = Task (RpcApi::*)(const nlohmann::json&, std::string&); using HandleStream = Task (RpcApi::*)(const nlohmann::json&, json::Stream&); explicit RpcApiTable(std::string_view api_spec); RpcApiTable(const RpcApiTable&) = delete; RpcApiTable& operator=(const RpcApiTable&) = delete; RpcApiTable(RpcApiTable&&) = default; std::optional find_json_handler(const std::string& method) const; std::optional find_json_glaze_handler(const std::string& method) const; std::optional find_stream_handler(const std::string& method) const; private: void build_handlers(std::string_view api_spec); void add_handlers(std::string_view api_namespace); void add_admin_handlers(); void add_debug_handlers(); void add_eth_handlers(); void add_net_handlers(); void add_parity_handlers(); void add_erigon_handlers(); void add_trace_handlers(); void add_web3_handlers(); void add_engine_handlers(); void add_txpool_handlers(); void add_ots_handlers(); std::map method_handlers_; std::map method_handlers_glaze_; std::map stream_handlers_; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/rpc_api_table_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "rpc_api_table.hpp" #include #include #include namespace silkworm::rpc::commands { TEST_CASE("RpcApiTable empty spec", "[rpc][api]") { CHECK_NOTHROW(RpcApiTable{""}); } //! Check if API table contains specified method in any form static bool has_method(const RpcApiTable& t, const std::string& m) { return t.find_json_handler(m) || t.find_json_glaze_handler(m) || t.find_stream_handler(m); } //! Check if specified method is present or not in API table static bool check_method(const RpcApiTable& table, const std::string& method, const bool present) { return has_method(table, method) == present; } // These presence checks should always mirror the content of docs/JSON-RPC-API.md //! Ensure *supported* admin namespace subset is present or not static void check_admin_namespace(const RpcApiTable& table, bool present) { CHECK(check_method(table, json_rpc::method::k_admin_nodeInfo, present)); CHECK(check_method(table, json_rpc::method::k_admin_peers, present)); } //! Ensure *supported* net namespace subset is present or not static void check_net_namespace(const RpcApiTable& table, bool present) { CHECK(check_method(table, json_rpc::method::k_net_listening, present)); CHECK(check_method(table, json_rpc::method::k_net_peerCount, present)); CHECK(check_method(table, json_rpc::method::k_net_version, present)); } //! Ensure *supported* eth namespace subset is present or not static void check_eth_namespace(const RpcApiTable& table, bool present) { CHECK(check_method(table, json_rpc::method::k_eth_blockNumber, present)); CHECK(check_method(table, json_rpc::method::k_eth_chainId, present)); CHECK(check_method(table, json_rpc::method::k_eth_protocolVersion, present)); CHECK(check_method(table, json_rpc::method::k_eth_syncing, present)); CHECK(check_method(table, json_rpc::method::k_eth_gasPrice, present)); CHECK(check_method(table, json_rpc::method::k_eth_getUncleByBlockHashAndIndex, present)); CHECK(check_method(table, json_rpc::method::k_eth_getUncleByBlockNumberAndIndex, present)); CHECK(check_method(table, json_rpc::method::k_eth_getUncleCountByBlockHash, present)); CHECK(check_method(table, json_rpc::method::k_eth_getUncleCountByBlockNumber, present)); CHECK(check_method(table, json_rpc::method::k_eth_getTransactionByHash, present)); CHECK(check_method(table, json_rpc::method::k_eth_getTransactionByBlockHashAndIndex, present)); CHECK(check_method(table, json_rpc::method::k_eth_getRawTransactionByHash, present)); CHECK(check_method(table, json_rpc::method::k_eth_getRawTransactionByBlockHashAndIndex, present)); CHECK(check_method(table, json_rpc::method::k_eth_getRawTransactionByBlockNumberAndIndex, present)); CHECK(check_method(table, json_rpc::method::k_eth_getTransactionByBlockNumberAndIndex, present)); CHECK(check_method(table, json_rpc::method::k_eth_getTransactionReceipt, present)); CHECK(check_method(table, json_rpc::method::k_eth_estimateGas, present)); CHECK(check_method(table, json_rpc::method::k_eth_getBalance, present)); CHECK(check_method(table, json_rpc::method::k_eth_getCode, present)); CHECK(check_method(table, json_rpc::method::k_eth_getTransactionCount, present)); CHECK(check_method(table, json_rpc::method::k_eth_getStorageAt, present)); CHECK(check_method(table, json_rpc::method::k_eth_call, present)); CHECK(check_method(table, json_rpc::method::k_eth_callMany, present)); CHECK(check_method(table, json_rpc::method::k_eth_callBundle, present)); CHECK(check_method(table, json_rpc::method::k_eth_createAccessList, present)); CHECK(check_method(table, json_rpc::method::k_eth_newFilter, present)); CHECK(check_method(table, json_rpc::method::k_eth_newBlockFilter, present)); CHECK(check_method(table, json_rpc::method::k_eth_newPendingTransactionFilter, present)); CHECK(check_method(table, json_rpc::method::k_eth_getFilterLogs, present)); CHECK(check_method(table, json_rpc::method::k_eth_getFilterChanges, present)); CHECK(check_method(table, json_rpc::method::k_eth_uninstallFilter, present)); CHECK(check_method(table, json_rpc::method::k_eth_getLogs, present)); CHECK(check_method(table, json_rpc::method::k_eth_sendRawTransaction, present)); CHECK(check_method(table, json_rpc::method::k_eth_sendTransaction, present)); CHECK(check_method(table, json_rpc::method::k_eth_signTransaction, present)); CHECK(check_method(table, json_rpc::method::k_eth_getProof, present)); CHECK(check_method(table, json_rpc::method::k_eth_mining, present)); CHECK(check_method(table, json_rpc::method::k_eth_coinbase, present)); CHECK(check_method(table, json_rpc::method::k_eth_hashrate, present)); CHECK(check_method(table, json_rpc::method::k_eth_submitHashrate, present)); CHECK(check_method(table, json_rpc::method::k_eth_getWork, present)); CHECK(check_method(table, json_rpc::method::k_eth_submitWork, present)); CHECK(check_method(table, json_rpc::method::k_eth_subscribe, present)); CHECK(check_method(table, json_rpc::method::k_eth_unsubscribe, present)); CHECK(check_method(table, json_rpc::method::k_eth_getBlockByHash, present)); CHECK(check_method(table, json_rpc::method::k_eth_getBlockTransactionCountByHash, present)); CHECK(check_method(table, json_rpc::method::k_eth_getBlockByNumber, present)); CHECK(check_method(table, json_rpc::method::k_eth_getBlockTransactionCountByNumber, present)); CHECK(check_method(table, json_rpc::method::k_eth_getBlockReceipts, present)); CHECK(check_method(table, json_rpc::method::k_eth_getTransactionReceiptsByBlock, present)); CHECK(check_method(table, json_rpc::method::k_eth_maxPriorityFeePerGas, present)); CHECK(check_method(table, json_rpc::method::k_eth_feeHistory, present)); } //! Ensure *supported* web3 namespace subset is present or not static void check_web3_namespace(const RpcApiTable& table, bool present) { CHECK(check_method(table, json_rpc::method::k_web3_clientVersion, present)); CHECK(check_method(table, json_rpc::method::k_web3_sha3, present)); } TEST_CASE("RpcApiTable admin spec", "[rpc][api]") { RpcApiTable table{kAdminApiNamespace}; check_admin_namespace(table, true); check_eth_namespace(table, false); check_net_namespace(table, false); check_web3_namespace(table, false); } TEST_CASE("RpcApiTable eth spec", "[rpc][api]") { RpcApiTable table{kEthApiNamespace}; check_admin_namespace(table, false); check_eth_namespace(table, true); check_net_namespace(table, false); check_web3_namespace(table, false); } TEST_CASE("RpcApiTable default spec", "[rpc][api]") { RpcApiTable table{kDefaultEth1ApiSpec}; check_admin_namespace(table, true); check_eth_namespace(table, true); check_net_namespace(table, true); check_web3_namespace(table, true); } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/rpc_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include namespace silkworm::rpc::commands { #ifdef notdef // temporarily commented out waiting for LocalTransaction implementation using test_util::RequestHandlerForTest; using test_util::RpcApiTestBase; #endif // Function to recursively sort JSON arrays void sort_array(nlohmann::json& json_obj) { // NOLINT(*-no-recursion) if (json_obj.is_array()) { // Sort the elements within the array std::sort(json_obj.begin(), json_obj.end(), [](const nlohmann::json& a, const nlohmann::json& b) { return a.dump() < b.dump(); }); // Recursively sort nested arrays for (auto& item : json_obj) { sort_array(item); } } else if (json_obj.is_object()) { for (auto& item : json_obj.items()) { sort_array(item.value()); } } } // Function to compare two JSON objects while ignoring the order of elements in arrays bool are_equivalent(const nlohmann::json& obj1, const nlohmann::json& obj2) { // Create copies of the JSON objects and sort their arrays nlohmann::json sorted_obj1 = obj1; nlohmann::json sorted_obj2 = obj2; sort_array(sorted_obj1); sort_array(sorted_obj2); // Serialize the sorted JSON objects to strings std::string str1 = sorted_obj1.dump(); std::string str2 = sorted_obj2.dump(); // Compare the sorted JSON strings return str1 == str2; } static const std::vector kTestsToIgnore = { "eth_getProof", // not implemented "debug_getRawReceipts", // not implemented "eth_sendRawTransaction", // call to txpool fails, needs mocking }; static const std::vector kSubtestsToIgnore = { "create-al-multiple-reads.io", // eth_createAccessList: expected value doesn't contain gas optimization "estimate-simple-transfer.io", // eth_estimateGas: without gas paramters doesn't support base_fee_gas of block as default gas "estimate-simple-contract.io", // eth_estimateGas: without gas paramters doesn't support base_fee_gas of block as default gas "call-simple-transfer.io", // eth_call: without gas paramters doesn't support base_fee_gas of block as default gas "call-simple-contract.io", // eth_call: without gas paramters doesn't support base_fee_gas of block as default gas }; #ifdef notdef // temporarily commented out waiting for LocalTransaction implementation // Exclude tests from sanitizer builds due to ASAN/TSAN warnings inside gRPC library #ifndef SILKWORM_SANITIZE TEST_CASE("rpc_api io (all files)", "[rpc][rpc_api]") { auto tests_dir = db::test_util::get_tests_dir(); for (const auto& test_file : std::filesystem::recursive_directory_iterator(tests_dir)) { if (!test_file.is_directory() && test_file.path().extension() == ".io") { auto test_name = test_file.path().filename().string(); auto group_name = test_file.path().parent_path().filename().string(); if (std::find(kTestsToIgnore.begin(), kTestsToIgnore.end(), group_name) != kTestsToIgnore.end()) { continue; } if (std::find(kSubtestsToIgnore.begin(), kSubtestsToIgnore.end(), test_name) != kSubtestsToIgnore.end()) { continue; } std::ifstream test_stream(test_file.path()); if (!test_stream.is_open()) { FAIL("Failed to open the file: " + test_file.path().string()); } SECTION("RPC IO test " + group_name + " | " + test_name) { // NOLINT(*-inefficient-string-concatenation) TemporaryDirectory tmp_dir; auto context = db::test_util::TestDatabaseContext(tmp_dir); RpcApiTestBase test_base{context.mdbx_env()}; std::string line_out; std::string line_in; while (std::getline(test_stream, line_out) && std::getline(test_stream, line_in)) { if (!line_out.starts_with(">> ") || !line_in.starts_with("<< ")) { FAIL("Invalid test file format"); } auto request = nlohmann::json::parse(line_out.substr(3)); auto expected = nlohmann::json::parse(line_in.substr(3)); std::string response; test_base.run<&RequestHandlerForTest::request_and_create_reply>(request, response); INFO("Request: " << request.dump()); INFO("Actual response: " << response); INFO("Expected response: " << expected.dump()); if (absl::StrContains(test_name, "invalid")) { CHECK(nlohmann::json::parse(response).contains("error")); } else { CHECK(are_equivalent(nlohmann::json::parse(response), expected)); } } } } } } #ifdef SILKWORM_TEST_SKIP TEST_CASE("rpc_api io (individual)", "[rpc][rpc_api]") { TemporaryDirectory tmp_dir; auto context = db::test_util::TestDatabaseContext(tmp_dir); RpcApiTestBase test_base{context.mdbx_env()}; SECTION("sample test") { auto request = R"({"jsonrpc":"2.0","id":1,"method":"debug_getRawTransaction","params":["0x74e41d593675913d6d5521f46523f1bd396dff1891bdb35f59be47c7e5e0b34b"]})"_json; std::string response; test_base.run<&RequestHandlerForTest::request_and_create_reply>(request, response); CHECK(nlohmann::json::parse(response) == R"({"jsonrpc":"2.0","id":1,"result":"0xf8678084342770c182520894658bdf435d810c91414ec09147daa6db624063798203e880820a95a0af5fc351b9e457a31f37c84e5cd99dd3c5de60af3de33c6f4160177a2c786a60a0201da7a21046af55837330a2c52fc1543cd4d9ead00ddf178dd96935b607ff9b"})"_json); } } #endif // SILKWORM_TEST_SKIP #endif // SILKWORM_SANITIZE #endif } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/trace_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "trace_api.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::commands { // https://eth.wiki/json-rpc/API#trace_call Task TraceRpcApi::handle_trace_call(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() < 3) { auto error_msg = "invalid trace_call params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto call = params[0].get(); const auto config = params[1].get(); const auto block_num_or_hash = params[2].get(); SILK_TRACE << "call: " << call << " block_num_or_hash: " << block_num_or_hash << " config: " << config; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(*block_cache_, block_num_or_hash); if (!block_with_hash) { reply = make_json_error(request, 100, "block not found"); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const bool is_latest_block = co_await block_reader.is_latest_block_num(block_with_hash->block.header.number); trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; const auto result = co_await executor.trace_call(block_with_hash->block, call, config, is_latest_block); if (result.pre_check_error) { reply = make_json_error(request, kServerError, result.pre_check_error.value()); } else { reply = make_json_content(request, result.traces); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_callmany Task TraceRpcApi::handle_trace_call_many(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid trace_callMany params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto trace_calls = params[0].get>(); const auto block_num_or_hash = params[1].get(); SILK_TRACE << "#trace_calls: " << trace_calls.size() << " block_num_or_hash: " << block_num_or_hash; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(*block_cache_, block_num_or_hash); if (!block_with_hash) { reply = make_json_error(request, kInvalidParams, "block not found"); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const bool is_latest_block = co_await block_reader.is_latest_block_num(block_with_hash->block.header.number); trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; const auto result = co_await executor.trace_calls(block_with_hash->block, trace_calls, is_latest_block); if (result.pre_check_error) { reply = make_json_error(request, kServerError, result.pre_check_error.value()); } else { reply = make_json_content(request, result.traces); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_rawtransaction Task TraceRpcApi::handle_trace_raw_transaction(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() < 2) { const auto error_msg = "invalid trace_rawTransaction params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto encoded_tx_string = params[0].get(); const auto encoded_tx_bytes = silkworm::from_hex(encoded_tx_string); if (!encoded_tx_bytes.has_value()) { const auto error_msg = "invalid trace_rawTransaction encoded tx: " + encoded_tx_string; SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } silkworm::ByteView encoded_tx_view{*encoded_tx_bytes}; Transaction transaction; const auto decoding_result{silkworm::rlp::decode(encoded_tx_view, transaction)}; if (!decoding_result) { const auto error_msg = decoding_result_to_string(decoding_result.error()); SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } constexpr float kTxFeeCap = 1; // 1 ether if (!check_tx_fee_less_cap(kTxFeeCap, transaction.max_fee_per_gas, transaction.gas_limit)) { const auto error_msg = "tx fee exceeds the configured cap"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } if (!is_replay_protected(transaction)) { const auto error_msg = "only replay-protected (EIP-155) transactions allowed over RPC"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } if (!transaction.sender()) { const auto error_msg = "cannot recover sender"; SILK_ERROR << error_msg; reply = make_json_error(request, kServerError, error_msg); co_return; } const auto config = params[1].get(); SILK_TRACE << "transaction: " << transaction << " config: " << config; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_num = co_await block_reader.get_latest_block_num(); // always at latest block const auto block_with_hash = co_await block_reader.read_block_by_number(*block_cache_, block_num); if (!block_with_hash) { reply = make_json_error(request, kInvalidParams, "block not found"); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; const auto result = co_await executor.trace_transaction(block_with_hash->block, transaction, config); if (result.pre_check_error) { reply = make_json_error(request, kServerError, result.pre_check_error.value()); } else { reply = make_json_content(request, result.traces); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_replayblocktransactions Task TraceRpcApi::handle_trace_replay_block_transactions(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid trace_replayBlockTransactions params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_num_or_hash = params[0].get(); const auto config = params[1].get(); SILK_TRACE << " block_num_or_hash: " << block_num_or_hash << " config: " << config; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(*block_cache_, block_num_or_hash); if (block_with_hash) { const bool is_latest_block = co_await block_reader.is_latest_block_num(block_with_hash->block.header.number); trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; const auto result = co_await executor.trace_block_transactions(block_with_hash->block, config, is_latest_block); reply = make_json_content(request, result); } else { reply = make_json_error(request, kInvalidParams, "block not found"); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_replaytransaction Task TraceRpcApi::handle_trace_replay_transaction(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid trace_replayTransaction params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); const auto config = params[1].get(); SILK_TRACE << "transaction_hash: " << silkworm::to_hex(transaction_hash) << " config: " << config; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto tx_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!tx_with_block) { std::ostringstream oss; oss << "transaction " << silkworm::to_hex(transaction_hash, true) << " not found"; reply = make_json_error(request, kServerError, oss.str()); } else { trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; const auto result = co_await executor.trace_transaction(tx_with_block->block_with_hash->block, tx_with_block->transaction, config); if (result.pre_check_error) { reply = make_json_error(request, kServerError, result.pre_check_error.value()); } else { reply = make_json_content(request, result.traces); } } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_block Task TraceRpcApi::handle_trace_block(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.empty()) { auto error_msg = "invalid trace_block params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto block_num_or_hash = params[0].get(); SILK_TRACE << " block_num_or_hash: " << block_num_or_hash; auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); const BlockReader block_reader{*chain_storage, *tx}; const auto block_with_hash = co_await block_reader.read_block_by_block_num_or_hash(*block_cache_, block_num_or_hash); if (!block_with_hash) { reply = make_json_error(request, kInvalidParams, "block not found"); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } const bool is_latest_block = co_await block_reader.is_latest_block_num(block_with_hash->block.header.number); trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; trace::Filter filter; const auto result = co_await executor.trace_block(*block_with_hash, filter, nullptr /* json::Stream */, is_latest_block); reply = make_json_content(request, result); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_filter Task TraceRpcApi::handle_trace_filter(const nlohmann::json& request, json::Stream& stream) { const auto& params = request["params"]; if (params.empty()) { auto error_msg = "invalid trace_filter params: " + params.dump(); SILK_ERROR << error_msg; const auto reply = make_json_error(request, kInvalidParams, error_msg); stream.write_json(reply); co_return; } const auto trace_filter = params[0].get(); SILK_TRACE << "trace_filter: " << trace_filter; stream.open_object(); stream.write_json_field("id", request["id"]); stream.write_field("jsonrpc", "2.0"); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; co_await executor.trace_filter(trace_filter, *chain_storage, stream); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); const Error error{kInternalError, e.what()}; stream.write_json_field("error", error); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); const Error error{kServerError, "unexpected exception"}; stream.write_json_field("error", error); } stream.close_object(); co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_get Task TraceRpcApi::handle_trace_get(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() < 2) { auto error_msg = "invalid trace_get params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); const auto str_indices = params[1].get>(); std::vector indices; std::transform(str_indices.begin(), str_indices.end(), std::back_inserter(indices), [](const std::string& str) { return std::stoi(str, nullptr, 16); }); SILK_TRACE << "transaction_hash: " << silkworm::to_hex(transaction_hash) << ", #indices: " << indices.size(); // Erigon RpcDaemon compatibility // Parity fails if it gets more than a single index. It returns nothing in this case. Must we? if (indices.size() > 1) { reply = make_json_content(request); co_return; } auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto tx_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!tx_with_block) { reply = make_json_content(request); } else { trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; const auto result = co_await executor.trace_transaction(*(tx_with_block->block_with_hash), tx_with_block->transaction, /* gas_bailout */ false); uint16_t index = indices[0]; if (rpc::compatibility::is_erigon_json_api_compatibility_required()) { index = index + 1; // Erigon RpcDaemon compatibility } if (result.size() > index) { reply = make_json_content(request, result[index]); } else { reply = make_json_content(request); } } } catch (const std::exception&) { reply = make_json_content(request); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } // https://eth.wiki/json-rpc/API#trace_transaction Task TraceRpcApi::handle_trace_transaction(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.empty()) { auto error_msg = "invalid trace_transaction params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto transaction_hash = params[0].get(); SILK_TRACE << "transaction_hash: " << silkworm::to_hex(transaction_hash); auto tx = co_await database_->begin_transaction(); try { const auto chain_storage = tx->make_storage(); BlockReader block_reader{*chain_storage, *tx}; const auto tx_with_block = co_await block_reader.read_transaction_by_hash(*block_cache_, transaction_hash); if (!tx_with_block) { reply = make_json_content(request); } else { trace::TraceCallExecutor executor{*block_cache_, *chain_storage, workers_, *tx}; auto result = co_await executor.trace_transaction(*(tx_with_block->block_with_hash), tx_with_block->transaction, /* gas_bailout */ false); reply = make_json_content(request, result); } } catch (const std::exception&) { reply = make_json_content(request); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } co_await tx->close(); // RAII not (yet) available with coroutines co_return; } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/trace_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class TraceRpcApi { public: TraceRpcApi(boost::asio::io_context& ioc, WorkerPool& workers) : ioc_{ioc}, block_cache_{must_use_shared_service(ioc_)}, state_cache_{must_use_shared_service(ioc_)}, database_{must_use_private_service(ioc)->service()}, workers_{workers} {} virtual ~TraceRpcApi() = default; TraceRpcApi(const TraceRpcApi&) = delete; TraceRpcApi& operator=(const TraceRpcApi&) = delete; TraceRpcApi(TraceRpcApi&&) = default; protected: Task handle_trace_call(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_call_many(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_raw_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_replay_block_transactions(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_replay_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_block(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_get(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_transaction(const nlohmann::json& request, nlohmann::json& reply); Task handle_trace_filter(const nlohmann::json& request, json::Stream& stream); private: boost::asio::io_context& ioc_; BlockCache* block_cache_; db::kv::api::StateCache* state_cache_; std::shared_ptr database_; WorkerPool& workers_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/trace_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "trace_api.hpp" #include #include #include namespace silkworm::rpc::commands { #ifndef SILKWORM_SANITIZE TEST_CASE("TraceRpcApi") { boost::asio::io_context ioc; WorkerPool workers{1}; SECTION("CTOR") { CHECK_THROWS_AS(TraceRpcApi(ioc, workers), std::logic_error); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/txpool_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "txpool_api.hpp" #include #include #include #include #include #include namespace silkworm::rpc::commands { // https://eth.wiki/json-rpc/API#txpool_status Task TxPoolRpcApi::handle_txpool_status(const nlohmann::json& request, nlohmann::json& reply) { try { const auto status = co_await tx_pool_->get_status(); TxPoolStatusInfo txpool_status{status.base_fee_count, status.pending_count, status.queued_count}; reply = make_json_content(request, txpool_status); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://geth.ethereum.org/docs/rpc/ns-txpool Task TxPoolRpcApi::handle_txpool_content(const nlohmann::json& request, nlohmann::json& reply) { try { const auto txpool_transactions = co_await tx_pool_->get_transactions(); TransactionContent transactions_content; transactions_content["queued"]; transactions_content["pending"]; transactions_content["baseFee"]; bool error = false; for (size_t i{0}; i < txpool_transactions.size(); ++i) { ByteView from{txpool_transactions[i].rlp}; std::string sender = address_to_hex(txpool_transactions[i].sender); Transaction txn{}; const auto result = rlp::decode_transaction(from, txn, rlp::Eip2718Wrapping::kBoth); if (!result) { SILK_ERROR << "handle_txpool_content rlp::decode_transaction failed sender: " << sender; error = true; break; } txn.queued_in_pool = true; if (txpool_transactions[i].transaction_type == txpool::TransactionType::kQueued) { transactions_content["queued"][sender].insert(std::make_pair(std::to_string(txn.nonce), txn)); } else if (txpool_transactions[i].transaction_type == txpool::TransactionType::kPending) { transactions_content["pending"][sender].insert(std::make_pair(std::to_string(txn.nonce), txn)); } else { transactions_content["baseFee"][sender].insert(std::make_pair(std::to_string(txn.nonce), txn)); } } if (!error) { reply = make_json_content(request, transactions_content); } else { reply = make_json_error(request, kInternalError, "RLP decoding error"); } } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kInternalError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/txpool_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class TxPoolRpcApi { public: explicit TxPoolRpcApi(boost::asio::io_context& ioc) : tx_pool_{must_use_private_service(ioc)} {} virtual ~TxPoolRpcApi() = default; TxPoolRpcApi(const TxPoolRpcApi&) = delete; TxPoolRpcApi& operator=(const TxPoolRpcApi&) = delete; TxPoolRpcApi(TxPoolRpcApi&&) = default; protected: Task handle_txpool_status(const nlohmann::json& request, nlohmann::json& reply); Task handle_txpool_content(const nlohmann::json& request, nlohmann::json& reply); private: txpool::TransactionPool* tx_pool_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/web3_api.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "web3_api.hpp" #include #include #include #include #include #include namespace silkworm::rpc::commands { // https://eth.wiki/json-rpc/API#web3_clientversion Task Web3RpcApi::handle_web3_client_version(const nlohmann::json& request, nlohmann::json& reply) { try { const auto client_version = co_await backend_->client_version(); reply = make_json_content(request, client_version); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what() << " processing request: " << request.dump(); reply = make_json_error(request, kServerError, e.what()); } catch (...) { SILK_ERROR << "unexpected exception processing request: " << request.dump(); reply = make_json_error(request, kServerError, "unexpected exception"); } } // https://eth.wiki/json-rpc/API#web3_sha3 Task Web3RpcApi::handle_web3_sha3(const nlohmann::json& request, nlohmann::json& reply) { const auto& params = request["params"]; if (params.size() != 1) { auto error_msg = "invalid web3_sha3 params: " + params.dump(); SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } const auto input_string = params[0].get(); const auto optional_input_bytes = from_hex(input_string); if (!optional_input_bytes) { auto error_msg = "invalid input: " + input_string; SILK_ERROR << error_msg; reply = make_json_error(request, kInvalidParams, error_msg); co_return; } auto eth_hash = hash_of(optional_input_bytes.value()); const auto output = "0x" + silkworm::to_hex({eth_hash.bytes, silkworm::kHashLength}); reply = make_json_content(request, output); } } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/web3_api.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler; } namespace silkworm::rpc::commands { class Web3RpcApi { public: explicit Web3RpcApi(boost::asio::io_context& ioc) : backend_{must_use_private_service(ioc)} {} virtual ~Web3RpcApi() = default; Web3RpcApi(const Web3RpcApi&) = delete; Web3RpcApi& operator=(const Web3RpcApi&) = delete; Web3RpcApi(Web3RpcApi&&) = default; protected: Task handle_web3_client_version(const nlohmann::json& request, nlohmann::json& reply); Task handle_web3_sha3(const nlohmann::json& request, nlohmann::json& reply); private: ethbackend::BackEnd* backend_; friend class silkworm::rpc::json_rpc::RequestHandler; }; } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/commands/web3_api_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "web3_api.hpp" #include namespace silkworm::rpc::commands { #ifndef SILKWORM_SANITIZE TEST_CASE("Web3RpcApi::Web3RpcApi", "[rpc][erigon_api]") { boost::asio::io_context ioc; CHECK_THROWS_AS(Web3RpcApi(ioc), std::logic_error); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::commands ================================================ FILE: silkworm/rpc/common/async_task.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::rpc { //! Helper trait for any completion handler signature template struct CompletionHandler { using type = void(std::exception_ptr, R); }; //! Partial specialization for \code void return type template struct CompletionHandler { using type = void(std::exception_ptr); }; //! Alias helper trait for the completion handler signature of any task template using TaskCompletionHandler = typename CompletionHandler, F, Args...>::type; //! Asynchronous \code co_await-able task executing function \code fn with arguments \code args in \code runner executor template // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward) because of https://github.com/llvm/llvm-project/issues/68105 Task> async_task(Executor runner, F&& fn, Args&&... args) { auto this_executor = co_await boost::asio::this_coro::executor; co_return co_await boost::asio::async_compose>( [&this_executor, &runner, fn = std::forward(fn), ... args = std::forward(args)](auto& self) mutable { boost::asio::post(runner, [&, fn = std::forward(fn), ... args = std::forward(args), self = std::move(self)]() mutable { try { if constexpr (std::is_void_v>) { std::invoke(fn, args...); boost::asio::post(this_executor, [self = std::move(self)]() mutable { self.complete({}); }); } else { auto result = std::invoke(fn, args...); boost::asio::post(this_executor, [result = std::move(result), self = std::move(self)]() mutable { self.complete({}, result); }); } } catch (...) { std::exception_ptr eptr = std::current_exception(); boost::asio::post(this_executor, [eptr, self = std::move(self)]() mutable { if constexpr (std::is_void_v>) self.complete(eptr); else self.complete(eptr, {}); }); } }); }, boost::asio::use_awaitable); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/common/async_task_benchmark.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include "async_task.hpp" namespace silkworm::rpc { size_t recursive_factorial(size_t n) { return n == 0 ? 1 : n * recursive_factorial(n - 1); } struct AsyncTaskBenchTest : test_util::ServiceContextTestBase { }; template Task async_compose_factorial(const Executor runner, const size_t number) { const auto this_executor = co_await boost::asio::this_coro::executor; co_return co_await boost::asio::async_compose( [&](auto& self) { boost::asio::post(runner, [&, self = std::move(self)]() mutable { try { const auto result = recursive_factorial(number); boost::asio::post(this_executor, [result, self = std::move(self)]() mutable { self.complete({}, result); }); } catch (...) { std::exception_ptr eptr = std::current_exception(); boost::asio::post(this_executor, [eptr, self = std::move(self)]() mutable { self.complete(eptr, {}); }); } }); }, boost::asio::use_awaitable); } static void benchmark_async_compose(benchmark::State& state) { const auto n = static_cast(state.range(0)); WorkerPool workers{}; AsyncTaskBenchTest test; for ([[maybe_unused]] auto _ : state) { const auto result = test.spawn_and_wait(async_compose_factorial(workers.get_executor(), n)); benchmark::DoNotOptimize(result); } } BENCHMARK(benchmark_async_compose)->Arg(10); BENCHMARK(benchmark_async_compose)->Arg(100); BENCHMARK(benchmark_async_compose)->Arg(1'000); BENCHMARK(benchmark_async_compose)->Arg(10'000); template Task async_task_factorial(Executor runner, size_t number) { co_return co_await async_task(runner, recursive_factorial, number); } static void benchmark_async_task(benchmark::State& state) { const auto n = static_cast(state.range(0)); WorkerPool workers{}; AsyncTaskBenchTest test; for ([[maybe_unused]] auto _ : state) { const auto result = test.spawn_and_wait(async_task_factorial(workers.get_executor(), n)); benchmark::DoNotOptimize(result); } } BENCHMARK(benchmark_async_task)->Arg(10); BENCHMARK(benchmark_async_task)->Arg(100); BENCHMARK(benchmark_async_task)->Arg(1'000); BENCHMARK(benchmark_async_task)->Arg(10'000); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/common/async_task_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "async_task.hpp" #include #include #include #include #include namespace silkworm::rpc { struct AsyncTaskTest : test_util::ServiceContextTestBase { }; static const std::vector> kTestData{ {0, 1}, {1, 1}, {9, 362'880}, {10, 3'628'800}, }; size_t recursive_factorial(size_t n) { return n == 0 ? 1 : n * recursive_factorial(n - 1); } template Task async_factorial(Executor runner, size_t number) { co_return co_await async_task(runner, recursive_factorial, number); } TEST_CASE_METHOD(AsyncTaskTest, "async_task: factorial", "[rpc][common][async_task]") { WorkerPool workers; for (size_t i{0}; i < kTestData.size(); ++i) { const auto [n, r] = kTestData[i]; SECTION("factorial " + std::to_string(n)) { CHECK(spawn_and_wait(async_factorial(workers.get_executor(), n)) == r); CHECK(spawn_and_wait(async_task(workers.get_executor(), recursive_factorial, n)) == r); } } } void raise_exception() { throw std::runtime_error{""}; } void raise_exception_with_args(int i) { if (i > 0) { throw std::runtime_error{""}; } } template Task async_raise_exception(Executor runner) { co_await async_task(runner, raise_exception); co_return; } template Task async_raise_exception_with_args(Executor runner, int i) { co_await async_task(runner, raise_exception_with_args, i); co_return; } template Task async_lambda_raise_exception(Executor runner) { co_await async_task(runner, []() { throw std::runtime_error{""}; }); co_return; } template Task async_lambda_raise_exception_with_args(Executor runner, int i) { co_await async_task( runner, [](auto ii) { if (ii > 0) throw std::runtime_error{""}; }, i); co_return; } TEST_CASE_METHOD(AsyncTaskTest, "async_task: exception", "[rpc][common][async_task]") { WorkerPool workers; CHECK_THROWS_AS(spawn_and_wait(async_task(workers.get_executor(), raise_exception)), std::runtime_error); CHECK_THROWS_AS(spawn_and_wait(async_raise_exception(workers.get_executor())), std::runtime_error); CHECK_THROWS_AS(spawn_and_wait(async_lambda_raise_exception(workers.get_executor())), std::runtime_error); CHECK_THROWS_AS(spawn_and_wait(async_task(workers.get_executor(), raise_exception_with_args, 1)), std::runtime_error); CHECK_THROWS_AS(spawn_and_wait(async_raise_exception_with_args(workers.get_executor(), 1)), std::runtime_error); CHECK_THROWS_AS(spawn_and_wait(async_lambda_raise_exception_with_args(workers.get_executor(), 1)), std::runtime_error); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/common/compatibility.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "compatibility.hpp" namespace silkworm::rpc::compatibility { //! Flag indicating if strict compatibility with Erigon RpcDaemon at JSON RPC level is guaranteed static bool erigon_json_strict_compatibility_required{false}; bool is_erigon_json_api_compatibility_required() { return erigon_json_strict_compatibility_required; } void set_erigon_json_api_compatibility_required(bool compatibility_required) { erigon_json_strict_compatibility_required = compatibility_required; } } // namespace silkworm::rpc::compatibility ================================================ FILE: silkworm/rpc/common/compatibility.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once namespace silkworm::rpc::compatibility { bool is_erigon_json_api_compatibility_required(); void set_erigon_json_api_compatibility_required(bool compatibility_required); } // namespace silkworm::rpc::compatibility ================================================ FILE: silkworm/rpc/common/constants.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { inline constexpr std::string_view kAdminApiNamespace{"admin"}; inline constexpr std::string_view kDebugApiNamespace{"debug"}; inline constexpr std::string_view kEngineApiNamespace{"engine"}; inline constexpr std::string_view kEthApiNamespace{"eth"}; inline constexpr std::string_view kNetApiNamespace{"net"}; inline constexpr std::string_view kParityApiNamespace{"parity"}; inline constexpr std::string_view kErigonApiNamespace{"erigon"}; inline constexpr std::string_view kTxPoolApiNamespace{"txpool"}; inline constexpr std::string_view kTraceApiNamespace{"trace"}; inline constexpr std::string_view kWeb3ApiNamespace{"web3"}; inline constexpr std::string_view kOtterscanApiNamespace{"ots"}; inline constexpr std::string_view kAddressPortSeparator{":"}; inline constexpr std::string_view kApiSpecSeparator{","}; inline constexpr std::string_view kDefaultJwtFile{"jwt.hex"}; inline constexpr std::string_view kDefaultEth1EndPoint{"127.0.0.1:8545"}; inline constexpr std::string_view kDefaultEngineEndPoint{"127.0.0.1:8551"}; inline constexpr std::string_view kDefaultPrivateApiAddr{"127.0.0.1:9090"}; inline constexpr std::string_view kDefaultEth1ApiSpec{"admin,debug,eth,net,parity,erigon,trace,web3,txpool"}; inline constexpr std::string_view kDefaultEth2ApiSpec{"engine,eth"}; inline constexpr std::chrono::milliseconds kDefaultTimeout{10000}; } // namespace silkworm ================================================ FILE: silkworm/rpc/common/interface_log.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "interface_log.hpp" #include #include #include namespace silkworm::rpc { class InterfaceLogImpl final { public: explicit InterfaceLogImpl(InterfaceLogSettings settings); ~InterfaceLogImpl() { flush(); } bool dump_response() const { return dump_response_; } std::filesystem::path path() const { return file_path_; } template void log(spdlog::format_string_t fmt, Args&&... args) { rotating_logger_->info(fmt, std::forward(args)...); if (auto_flush_) { rotating_logger_->flush(); } } void log(std::string_view msg) { rotating_logger_->info(msg); if (auto_flush_) { rotating_logger_->flush(); } } void flush() { rotating_logger_->flush(); } private: std::string name_; bool auto_flush_; bool dump_response_; std::filesystem::path file_path_; size_t max_file_size_; size_t max_files_; std::shared_ptr rotating_sink_; std::shared_ptr rotating_logger_; }; InterfaceLogImpl::InterfaceLogImpl(InterfaceLogSettings settings) : name_{std::move(settings.ifc_name)}, auto_flush_{settings.auto_flush}, dump_response_{settings.dump_response}, file_path_{settings.container_folder / std::filesystem::path{name_ + ".log"}}, max_file_size_{settings.max_file_size_mb * kMebi}, max_files_{settings.max_files}, rotating_sink_{std::make_shared(file_path_.string(), max_file_size_, max_files_)}, rotating_logger_{std::make_shared(name_, rotating_sink_)} { ensure(!name_.empty(), "InterfaceLogImpl: name is empty"); // Hard-code log level because we want all-or-nothing in interface log rotating_logger_->set_level(spdlog::level::info); // Customize log pattern to avoid unnecessary fields (log level, logger name) rotating_logger_->set_pattern("[%Y-%m-%d %H:%M:%S.%e] %v"); } //! Fixed-size header prepended to every log line: "[YYYY-MM-dd hh:mm:ss.mss] REQ|RSP -> " const size_t InterfaceLog::kLogLineHeaderSize{33}; InterfaceLog::InterfaceLog(InterfaceLogSettings settings) : p_impl_{std::make_unique(std::move(settings))} { } // An explicit destructor is needed to avoid error: // invalid application of 'sizeof' to an incomplete type 'silkworm::log::InterfaceLogImpl' InterfaceLog::~InterfaceLog() { p_impl_->flush(); } std::filesystem::path InterfaceLog::path() const { return p_impl_->path(); } void InterfaceLog::log_req(std::string_view msg) { p_impl_->log("REQ -> {}", msg); } void InterfaceLog::log_rsp(std::string_view msg) { if (p_impl_->dump_response()) { p_impl_->log("RSP <- {}", msg); } } void InterfaceLog::flush() { p_impl_->flush(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/common/interface_log.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc { class InterfaceLogImpl; struct InterfaceLogSettings { bool enabled{false}; std::string ifc_name; std::filesystem::path container_folder{"logs/"}; size_t max_file_size_mb{1}; size_t max_files{100}; bool auto_flush{true}; bool dump_response{false}; }; class InterfaceLog final { public: static const size_t kLogLineHeaderSize; explicit InterfaceLog(InterfaceLogSettings settings); ~InterfaceLog(); // Not copyable InterfaceLog(const InterfaceLog&) = delete; InterfaceLog& operator=(const InterfaceLog&) = delete; // Only movable InterfaceLog(InterfaceLog&&) noexcept = default; InterfaceLog& operator=(InterfaceLog&&) noexcept = default; std::filesystem::path path() const; void log_req(std::string_view msg); void log_rsp(std::string_view msg); void flush(); private: std::unique_ptr p_impl_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/common/interface_log_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "interface_log.hpp" #include #include #include #include #include #include namespace silkworm::rpc { TEST_CASE("InterfaceLog dump: full (req+rsp)", "[rpc][common][interface_log]") { const auto tmp_dir{TemporaryDirectory::get_unique_temporary_path()}; InterfaceLogSettings settings{ .enabled = true, .ifc_name = "eth_rpc", .container_folder = tmp_dir, .auto_flush = false, .dump_response = true, }; auto ifc_log{std::make_unique(settings)}; REQUIRE(!ifc_log->path().empty()); ifc_log->log_req(R"({"json":"2.0"})"); ifc_log->log_rsp(R"({"json":"2.0"})"); std::ifstream log_ifstream{ifc_log->path().string()}; // Log file must be empty before flushing CHECK(log_ifstream.get() == -1); CHECK(log_ifstream.eof()); log_ifstream.clear(); log_ifstream.seekg(0); SECTION("explicit flush") { // InterfaceLog instance gets flushed here but remains alive until the end ifc_log->flush(); } SECTION("implicit flush") { // InterfaceLog instance gets destroyed here and implicitly flushed ifc_log.reset(); } // First line must be the request std::string content; std::getline(log_ifstream, content); CHECK(absl::StrContains(content, R"(REQ -> {"json":"2.0"})")); // Second line must be the response std::getline(log_ifstream, content); CHECK(absl::StrContains(content, R"(RSP <- {"json":"2.0"})")); // No other content is present CHECK(log_ifstream.get() == -1); CHECK(log_ifstream.eof()); } TEST_CASE("InterfaceLog dump: default (only req)", "[rpc][common][interface_log]") { const auto tmp_dir{TemporaryDirectory::get_unique_temporary_path()}; InterfaceLogSettings settings{ .enabled = true, .ifc_name = "eth_rpc", .container_folder = tmp_dir, .auto_flush = false, }; auto ifc_log{std::make_unique(settings)}; REQUIRE(!ifc_log->path().empty()); ifc_log->log_req(R"({"json":"2.0"})"); ifc_log->log_rsp(R"({"json":"2.0"})"); std::ifstream log_ifstream{ifc_log->path().string()}; // Log file must be empty before flushing CHECK(log_ifstream.get() == -1); CHECK(log_ifstream.eof()); log_ifstream.clear(); log_ifstream.seekg(0); SECTION("explicit flush") { // InterfaceLog instance gets flushed here but remains alive until the end ifc_log->flush(); } SECTION("implicit flush") { // InterfaceLog instance gets destroyed here and implicitly flushed ifc_log.reset(); } // First line must be the request std::string content; std::getline(log_ifstream, content); CHECK(absl::StrContains(content, R"(REQ -> {"json":"2.0"})")); // No other content is present CHECK(log_ifstream.get() == -1); CHECK(log_ifstream.eof()); } TEST_CASE("InterfaceLog dump: two instances w/o auto-flush", "[rpc][common][interface_log]") { const auto tmp_dir{TemporaryDirectory::get_unique_temporary_path()}; InterfaceLogSettings settings{ .enabled = true, .ifc_name = "eth_rpc", .container_folder = tmp_dir, .auto_flush = false, }; auto ifc_log1 = std::make_unique(settings); auto ifc_log2 = std::make_unique(settings); REQUIRE(ifc_log1->path() == ifc_log2->path()); std::ifstream log_ifstream{ifc_log1->path().string()}; static constexpr size_t kLogBufferSize{1024 * 4}; static const size_t kLogLineHeaderSize{InterfaceLog::kLogLineHeaderSize}; std::string request1; std::string request2(100, 'B'); // always less than page size SECTION("less than page size") { request1.assign(kLogBufferSize - kLogLineHeaderSize - 1 /*\n*/ - 1, 'A'); SECTION("same instance") { // Logging request1 is NOT sufficient to trigger page write w/o flush ifc_log1->log_req(request1); CHECK(std::filesystem::file_size(ifc_log1->path()) == 0); // Logging request2 crosses the page size, so one page is written w/o flush ifc_log1->log_req(request2); CHECK(std::filesystem::file_size(ifc_log1->path()) == kLogBufferSize); // Flushing writes the whole write buffer content ifc_log1->flush(); // Log file content is exactly log_line_header + request1 + log_line_header + request2 std::string content; std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request1); std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request2); } SECTION("different instances") { // Logging request1 through ifc_log1 is NOT sufficient to trigger page write w/o flush ifc_log1->log_req(request1); CHECK(std::filesystem::file_size(ifc_log1->path()) == 0); // Logging request2 through ifc_log2 DOES NOT trigger page write: write buffers are separate ifc_log2->log_req(request2); CHECK(std::filesystem::file_size(ifc_log2->path()) == 0); // Flushing both instances dumps the separate write buffers in order ifc_log2->flush(); ifc_log1->flush(); // Log file content is exactly log_line_header + request2 + log_line_header + request1 std::string content; std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request2); std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request1); } // No other content is present CHECK(log_ifstream.get() == -1); CHECK(log_ifstream.eof()); CHECK(std::filesystem::file_size(ifc_log1->path()) == (request1.size() + kLogLineHeaderSize + 1) + (request2.size() + kLogLineHeaderSize + 1)); } SECTION("greater than or equal to page size") { request1.assign(4096 - kLogLineHeaderSize + 1, 'A'); SECTION("same instance") { // Logging request1 is sufficient to trigger page write w/o flush ifc_log1->log_req(request1); CHECK(std::filesystem::file_size(ifc_log1->path()) == kLogBufferSize); // Logging request2 DOES NOT trigger another page write ifc_log1->log_req(request2); CHECK(std::filesystem::file_size(ifc_log1->path()) == kLogBufferSize); // Flushing writes the whole write buffer content ifc_log1->flush(); // Log file content is exactly log_line_header + request1 + log_line_header + request2 std::string content; std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request1); std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request2); } SECTION("different instances w/o flush: possible truncation") { // Logging request1 through ifc_log1 is sufficient to trigger page write w/o flush ifc_log1->log_req(request1); CHECK(std::filesystem::file_size(ifc_log1->path()) == kLogBufferSize); // Logging request2 through ifc_log2 DOES NOT trigger another page write ifc_log2->log_req(request2); CHECK(std::filesystem::file_size(ifc_log2->path()) == kLogBufferSize); // Flushing ifc_log2 BEFORE ifc_log1 generates a mixed content: truncated request1 + request2 ifc_log2->flush(); // Log file content is exactly log_line_header + request1 TRUNCATED AT 4k + log_line_header + request2 std::string content; std::getline(log_ifstream, content); CHECK(content.substr(0, kLogLineHeaderSize).ends_with("REQ -> ")); CHECK(content.substr(kLogLineHeaderSize, kLogBufferSize - kLogLineHeaderSize) == std::string(kLogBufferSize - kLogLineHeaderSize, 'A')); CHECK(content.substr(kLogBufferSize, kLogLineHeaderSize).ends_with("REQ -> ")); CHECK(content.substr(kLogBufferSize + kLogLineHeaderSize) == request2); } SECTION("different instances w/ flush: no truncation") { // Logging request1 through ifc_log1 and flushing ifc_log1->log_req(request1); ifc_log1->flush(); CHECK(std::filesystem::file_size(ifc_log1->path()) == request1.size() + kLogLineHeaderSize + 1); // Logging request2 through ifc_log2 and flushing ifc_log2->log_req(request2); ifc_log2->flush(); CHECK(std::filesystem::file_size(ifc_log2->path()) == (request1.size() + kLogLineHeaderSize + 1) + (request2.size() + kLogLineHeaderSize + 1)); // Log file content is exactly log_line_header + request2 + log_line_header + request1 std::string content; std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request1); std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request2); } // No other content is present CHECK(log_ifstream.get() == -1); CHECK(log_ifstream.eof()); } } TEST_CASE("InterfaceLog dump: two instances w/ auto-flush", "[rpc][common][interface_log]") { const auto tmp_dir{TemporaryDirectory::get_unique_temporary_path()}; InterfaceLogSettings settings{ .enabled = true, .ifc_name = "eth_rpc", .container_folder = tmp_dir, }; auto ifc_log1 = std::make_unique(settings); auto ifc_log2 = std::make_unique(settings); REQUIRE(ifc_log1->path() == ifc_log2->path()); static constexpr size_t kLogBufferSize{1024 * 4}; static const size_t kLogLineHeaderSize{InterfaceLog::kLogLineHeaderSize}; std::string request1; std::string request2(100, 'B'); // always less than page size SECTION("less than page size") { request1.assign(kLogBufferSize - kLogLineHeaderSize - 1 /*\n*/ - 1, 'A'); } SECTION("greater than or equal to page size") { request1.assign(4096 - kLogLineHeaderSize + 1, 'A'); } // Logging request1 through ifc_log1 implicitly flushes ifc_log1->log_req(request1); CHECK(std::filesystem::file_size(ifc_log1->path()) == request1.size() + kLogLineHeaderSize + 1); // Logging request2 through ifc_log2 implicitly flushes ifc_log2->log_req(request2); CHECK(std::filesystem::file_size(ifc_log2->path()) == (request1.size() + kLogLineHeaderSize + 1) + (request2.size() + kLogLineHeaderSize + 1)); // Log file content is exactly log_line_header + request1 + log_line_header + request2 std::ifstream log_ifstream{ifc_log1->path().string()}; std::string content; std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request1); std::getline(log_ifstream, content); CHECK(content.substr(kLogLineHeaderSize) == request2); // No other content is present CHECK(log_ifstream.get() == -1); CHECK(log_ifstream.eof()); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/common/tee.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm { // Tee code adapted from http://wordaligned.org/articles/cpp-streambufs class teebuf : public std::streambuf { public: // Construct a streambuf which tees output to the supplied streambufs. teebuf(std::streambuf* b1, std::streambuf* b2) : sb1(b1), sb2(b2) {} void set_streams(std::streambuf* b1, std::streambuf* b2) { sb1 = b1; sb2 = b2; } private: // This tee buffer has no buffer. So every character "overflows" // and can be put directly into the teed buffers. int overflow(int c) override { if (c == EOF) { return !EOF; } else { int const r1 = sb1->sputc(static_cast(c)); int const r2 = sb2->sputc(static_cast(c)); return (r1 == EOF || r2 == EOF) ? EOF : c; } } // Sync both teed buffers. int sync() override { int const r1 = sb1->pubsync(); int const r2 = sb2->pubsync(); return (r1 == 0 && r2 == 0) ? 0 : -1; } std::streambuf* sb1; std::streambuf* sb2; }; class teestream : public std::ostream { public: // Construct an ostream which tees output to the supplied ostreams. teestream(std::ostream& o1, std::ostream& o2) : std::ostream(&tbuf), tbuf(o1.rdbuf(), o2.rdbuf()) {} void set_streams(std::streambuf* sb1, std::streambuf* sb2) { tbuf.set_streams(sb1, sb2); } private: teebuf tbuf; }; } // namespace silkworm ================================================ FILE: silkworm/rpc/common/util.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include #include #include namespace silkworm { std::ostream& operator<<(std::ostream& out, const Account& account) { out << account.to_string(); return out; } void increment(Bytes& array) { for (auto& it : std::ranges::reverse_view(array)) { if (it < 0xFF) { ++it; break; } it = 0x00; } } std::string base64_encode(ByteView bytes_to_encode, bool url) { return ::base64_encode(byte_view_to_string_view(bytes_to_encode), url); } // check whether the fee of the given transaction is reasonable (under the cap) bool check_tx_fee_less_cap(float cap, const intx::uint256& max_fee_per_gas, uint64_t gas_limit) { // Short circuit if there is no cap for transaction fee at all if (cap == 0) { return true; } float fee_eth = (to_float(max_fee_per_gas) * static_cast(gas_limit)) / static_cast(silkworm::kEther); return fee_eth <= cap; } bool is_replay_protected(const silkworm::Transaction& txn) { if (txn.type != TransactionType::kLegacy) { return true; } intx::uint256 v = txn.v(); return v != 27 && v != 28 && v != 0 && v != 1; } std::string decoding_result_to_string(silkworm::DecodingError decode_result) { switch (decode_result) { case silkworm::DecodingError::kOverflow: return "rlp: uint overflow"; case silkworm::DecodingError::kLeadingZero: return "rlp: leading Zero"; case silkworm::DecodingError::kInputTooShort: return "rlp: value size exceeds available input length"; case silkworm::DecodingError::kInputTooLong: return "rlp: input exceeds encoded length"; case silkworm::DecodingError::kNonCanonicalSize: return "rlp: non-canonical size information"; case silkworm::DecodingError::kUnexpectedLength: return "rlp: unexpected Length"; case silkworm::DecodingError::kUnexpectedString: return "rlp: expected list, got string instead"; case silkworm::DecodingError::kUnexpectedList: return "rlp: expected string, got list instead"; case silkworm::DecodingError::kUnexpectedListElements: return "rlp: unexpected list element(s)"; case silkworm::DecodingError::kInvalidVInSignature: // v != 27 && v != 28 && v < 35, see EIP-155 return "rlp: invalid V in signature"; case silkworm::DecodingError::kUnsupportedTransactionType: return "rlp: unknown tx type prefix"; case silkworm::DecodingError::kInvalidFieldset: return "rlp: invalid field set"; case silkworm::DecodingError::kUnexpectedEip2718Serialization: return "rlp: unexpected EIP-2178 serialization"; case silkworm::DecodingError::kInvalidHashesLength: return "rlp: invalid hashes length"; case silkworm::DecodingError::kInvalidMasksSubsets: return "rlp: invalid masks subsets"; default: return "rlp: unknown error [" + std::to_string(static_cast(decode_result)) + "]"; } } const silkworm::ChainConfig* lookup_chain_config(uint64_t chain_id) { // TODO(canepat) we should read chain config from db const auto chain_config = kKnownChainConfigs.find(chain_id); if (!chain_config) { throw std::runtime_error{"unknown chain ID: " + std::to_string(chain_id)}; } return *chain_config; } std::string get_opcode_hex(uint8_t opcode) { static constexpr std::string_view kHexDigits = "0123456789abcdef"; if (opcode < 16) { return {'0', 'x', kHexDigits[opcode]}; } return {'0', 'x', kHexDigits[opcode >> 4], kHexDigits[opcode & 0xf]}; } std::optional get_opcode_name(std::uint8_t opcode) noexcept { // TODO(evmone): evmone can provide a function like this directly with optimized lookup table. const auto& tr = evmone::instr::traits[opcode]; if (!tr.since.has_value()) return std::nullopt; if (opcode == evmone::OP_PREVRANDAO) return "DIFFICULTY"; // Overwrite for compatibility with Erigon and Geth. return tr.name; } } // namespace silkworm ================================================ FILE: silkworm/rpc/common/util.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm { void increment(Bytes& array); std::string base64_encode(ByteView bytes_to_encode, bool url); bool check_tx_fee_less_cap(float cap, const intx::uint256& max_fee_per_gas, uint64_t gas_limit); bool is_replay_protected(const Transaction& txn); std::string decoding_result_to_string(DecodingError decode_result); inline ByteView full_view(const Bloom& bloom) { return {bloom.data(), kBloomByteLength}; } const ChainConfig* lookup_chain_config(uint64_t chain_id); inline evmc::bytes32 bytes32_from_hex(const std::string& s) { const auto b32_bytes = from_hex(s); return to_bytes32(b32_bytes.value_or(silkworm::Bytes{})); } std::ostream& operator<<(std::ostream& out, const Account& account); std::string get_opcode_hex(uint8_t opcode); /// Returns the opcode name or std::nullopt if the opcode is undefined. std::optional get_opcode_name(std::uint8_t opcode) noexcept; } // namespace silkworm inline auto hash_of(const silkworm::ByteView& bytes) { return ethash::keccak256(bytes.data(), bytes.size()); } inline auto hash_of_transaction(const silkworm::Transaction& txn) { silkworm::Bytes txn_rlp{}; silkworm::rlp::encode(txn_rlp, txn, /*wrap_eip2718_into_string=*/false); return ethash::keccak256(txn_rlp.data(), txn_rlp.size()); } namespace boost::asio { inline std::ostream& operator<<(std::ostream& out, const const_buffer& buffer) { out << std::string{static_cast(buffer.data()), buffer.size()}; return out; } inline std::ostream& operator<<(std::ostream& out, const std::vector& buffers) { for (const auto buffer : buffers) { out << buffer; } return out; } } // namespace boost::asio ================================================ FILE: silkworm/rpc/common/util_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "util.hpp" #include #include #include #include #include #include #include #include namespace silkworm { TEST_CASE("calculate hash of byte array", "[rpc][common][util]") { const auto eth_hash{hash_of(silkworm::ByteView{})}; CHECK(silkworm::to_bytes32(silkworm::ByteView{eth_hash.bytes, silkworm::kHashLength}) == silkworm::kEmptyHash); } TEST_CASE("calculate hash of transaction", "[rpc][common][util]") { const auto eth_hash{hash_of_transaction(silkworm::Transaction{})}; CHECK(silkworm::to_bytes32(silkworm::ByteView{eth_hash.bytes, silkworm::kHashLength}) == 0x3763e4f6e4198413383534c763f3f5dac5c5e939f0a81724e3beb96d6e2ad0d5_bytes32); } TEST_CASE("print empty address", "[rpc][common][util]") { evmc::address addr1{}; CHECK_NOTHROW(test_util::null_stream() << addr1); evmc::address addr2{0xa872626373628737383927236382161739290870_address}; CHECK_NOTHROW(test_util::null_stream() << addr2); } TEST_CASE("print bytes32", "[rpc][common][util]") { evmc::bytes32 b32_1{}; CHECK_NOTHROW(test_util::null_stream() << to_hex(b32_1)); evmc::bytes32 b32_2{0x3763e4f6e4198413383534c763f3f5dac5c5e939f0a81724e3beb96d6e2ad0d5_bytes32}; CHECK_NOTHROW(test_util::null_stream() << to_hex(b32_2)); } TEST_CASE("print empty const_buffer", "[rpc][common][util]") { boost::asio::const_buffer cb{}; CHECK_NOTHROW(test_util::null_stream() << cb); } TEST_CASE("print empty vector of const_buffer", "[rpc][common][util]") { std::vector v; boost::asio::const_buffer cb1{}; boost::asio::const_buffer cb2{}; v.push_back(cb1); v.push_back(cb2); CHECK_NOTHROW(test_util::null_stream() << v); } TEST_CASE("print Account", "[rpc][common][util]") { silkworm::Account account{}; CHECK_NOTHROW(test_util::null_stream() << account); } TEST_CASE("base64 encode", "[rpc][common][util]") { uint8_t plain[] = "deadbeaf"; auto encoded = base64_encode({plain, sizeof(plain)}, false); CHECK(encoded == "ZGVhZGJlYWYA"); encoded = base64_encode({plain, sizeof(plain)}, true); CHECK(encoded == "ZGVhZGJlYWYA"); } TEST_CASE("check_tx_fee_less_cap(cap=0) returns true", "[rpc][common][util]") { intx::uint256 max_fee_per_gas{silkworm::kEther * 1}; uint64_t gas_limit{20}; auto check = check_tx_fee_less_cap(0, max_fee_per_gas, gas_limit); CHECK(check == true); } TEST_CASE("check_tx_fee_less_cap returns true", "[rpc][common][util]") { intx::uint256 max_fee_per_gas{silkworm::kEther * 1}; uint64_t gas_limit{20}; auto check = check_tx_fee_less_cap(1, max_fee_per_gas, gas_limit); CHECK(check == false); } TEST_CASE("check_tx_fee_less_cap returns false", "[rpc][common][util]") { intx::uint256 max_fee_per_gas{silkworm::kEther / 10}; uint64_t gas_limit{8}; auto check = check_tx_fee_less_cap(1, max_fee_per_gas, gas_limit); CHECK(check == true); } TEST_CASE("is_replay_protected(tx legacy) returns true", "[rpc][common][util]") { Transaction txn{}; txn.type = TransactionType::kAccessList; txn.nonce = 0; txn.max_priority_fee_per_gas = 50'000 * kGiga; txn.max_fee_per_gas = 50'000 * kGiga; txn.gas_limit = 21'000; txn.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn.value = 31337; txn.odd_y_parity = true; txn.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); auto check = is_replay_protected(txn); CHECK(check == true); } TEST_CASE("is_replay_protected returns true", "[rpc][common][util]") { Transaction txn{}; txn.type = TransactionType::kLegacy; txn.chain_id = 9; txn.nonce = 0; txn.max_priority_fee_per_gas = 20000000000; txn.max_fee_per_gas = 20000000000; txn.gas_limit = 0; txn.to = 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address; txn.value = 8; txn.data = *from_hex("001122aabbcc"); txn.odd_y_parity = false; txn.r = 18; txn.s = 36; txn.set_sender(0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); auto check = is_replay_protected(txn); CHECK(check == true); } TEST_CASE("is_replay_protected returns false", "[rpc][common][util]") { Transaction txn{}; txn.type = TransactionType::kLegacy; txn.nonce = 0; txn.max_priority_fee_per_gas = 50'000 * kGiga; txn.max_fee_per_gas = 50'000 * kGiga; txn.gas_limit = 21'000; txn.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn.value = 31337; txn.odd_y_parity = true; txn.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); auto check = is_replay_protected(txn); CHECK(check == false); } TEST_CASE("decoding_result_to_string(kOverflow)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kOverflow) == "rlp: uint overflow"); } TEST_CASE("decoding_result_to_string(kLeadingZero)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kLeadingZero) == "rlp: leading Zero"); } TEST_CASE("decoding_result_to_string(kInputTooShort)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kInputTooShort) == "rlp: value size exceeds available input length"); } TEST_CASE("decoding_result_to_string(kInputTooLong)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kInputTooLong) == "rlp: input exceeds encoded length"); } TEST_CASE("decoding_result_to_string(kNonCanonicalSize)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kNonCanonicalSize) == "rlp: non-canonical size information"); } TEST_CASE("decoding_result_to_string(kUnexpectedLength)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kUnexpectedLength) == "rlp: unexpected Length"); } TEST_CASE("decoding_result_to_string(kUnexpectedString)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kUnexpectedString) == "rlp: expected list, got string instead"); } TEST_CASE("decoding_result_to_string(kUnexpectedList)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kUnexpectedList) == "rlp: expected string, got list instead"); } TEST_CASE("decoding_result_to_string(kUnexpectedListElements)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kUnexpectedListElements) == "rlp: unexpected list element(s)"); } TEST_CASE("decoding_result_to_string(kInvalidVInSignature)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kInvalidVInSignature) == "rlp: invalid V in signature"); } TEST_CASE("decoding_result_to_string(kUnsupportedTransactionType)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kUnsupportedTransactionType) == "rlp: unknown tx type prefix"); } TEST_CASE("decoding_result_to_string(kInvalidFieldset)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kInvalidFieldset) == "rlp: invalid field set"); } TEST_CASE("decoding_result_to_string(kUnexpectedEip2718Serialization)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kUnexpectedEip2718Serialization) == "rlp: unexpected EIP-2178 serialization"); } TEST_CASE("decoding_result_to_string(kInvalidHashesLength)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kInvalidHashesLength) == "rlp: invalid hashes length"); } TEST_CASE("decoding_result_to_string(kInvalidMasksSubsets)", "[rpc][common][util]") { CHECK(decoding_result_to_string(silkworm::DecodingError::kInvalidMasksSubsets) == "rlp: invalid masks subsets"); } TEST_CASE("lookup_chain_config", "[rpc][common][util]") { SECTION("lookup known chain") { for (const auto& [_, known_chain_id] : kKnownChainNameToId) { CHECK_NOTHROW(lookup_chain_config(known_chain_id) != nullptr); } } SECTION("lookup unknown chain") { CHECK_THROWS_AS(lookup_chain_config(0), std::runtime_error); } } TEST_CASE("get_opcode_name") { SECTION("valid op_code") { auto op_code_name = get_opcode_name(0x00); CHECK(op_code_name == "STOP"); } SECTION("not existent op_code") { auto op_code_name = get_opcode_name(0x0d); CHECK(!op_code_name.has_value()); } SECTION("DIFFICULTY/PREVRANDAO opcode") { auto op_code_name = get_opcode_name(0x44); CHECK(op_code_name == "DIFFICULTY"); } } TEST_CASE("get_opcode_hex") { SECTION("1 digit opcode") { auto op_code = get_opcode_hex(0x00); CHECK(op_code == "0x0"); op_code = get_opcode_hex(0x0a); CHECK(op_code == "0xa"); } SECTION("2 digit opcode") { auto op_code = get_opcode_hex(0x10); CHECK(op_code == "0x10"); op_code = get_opcode_hex(0x4f); CHECK(op_code == "0x4f"); } } } // namespace silkworm ================================================ FILE: silkworm/rpc/common/worker_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { //! Default number of threads in worker pool (i.e. dedicated to heavier tasks) inline const uint32_t kDefaultNumWorkers{std::thread::hardware_concurrency() / 2}; //! Pool of worker threads dedicated to heavier tasks using WorkerPool = boost::asio::thread_pool; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/account_dumper.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "account_dumper.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::core { Task AccountDumper::dump_accounts( const BlockNumOrHash& block_num_or_hash, const evmc::address& start_address, int16_t max_result, bool exclude_code, bool exclude_storage) { DumpAccounts dump_accounts; const auto chain_storage = transaction_.make_storage(); const BlockReader block_reader{*chain_storage, transaction_}; const auto header = co_await block_reader.read_header_by_block_num_or_hash(block_num_or_hash); if (!header) { throw std::invalid_argument("dump_accounts: block not found"); } dump_accounts.root = header->state_root; const auto block_num = header->number + 1; const auto start_txn_number = co_await transaction_.first_txn_num_in_block(block_num); db::kv::api::DomainRangeRequest query{ .table = std::string{db::table::kAccountDomain}, .from_key = db::account_domain_key(start_address), .timestamp = start_txn_number, .ascending_order = true, .skip_empty_values = true, // just for direct Data API }; auto domain_kv_result = co_await transaction_.range_as_of(std::move(query)); auto it = co_await domain_kv_result.begin(); while (const auto value = co_await it->next()) { DumpAccount dump_account; evmc::address address{bytes_to_address(value->first)}; if (value->second.empty()) { continue; } if (max_result > 0 && dump_accounts.accounts.size() >= static_cast(max_result)) { dump_accounts.next = bytes_to_address(value->first); break; } auto account{db::state::AccountCodec::from_encoded_storage_v3(value->second)}; success_or_throw(account); dump_account.balance = account->balance; dump_account.nonce = account->nonce; dump_account.incarnation = account->incarnation; dump_account.code_hash = account->code_hash; dump_account.root = kZeroHash; if (account->code_hash != kZeroHash && !exclude_code) { db::kv::api::GetLatestRequest query_code{ .table = std::string{db::table::kCodeDomain}, .key = db::account_domain_key(address)}; const auto code = co_await transaction_.get_latest(std::move(query_code)); if (!code.value.empty()) { dump_account.code = code.value; } } dump_accounts.accounts.insert(std::pair(address, dump_account)); } if (!exclude_storage) { co_await load_storage(block_num, dump_accounts); } co_return dump_accounts; } Task AccountDumper::load_storage(BlockNum block_num, DumpAccounts& dump_accounts) { SILK_TRACE << "block_number " << block_num << " START"; const auto txn_number = co_await transaction_.first_txn_num_in_block(block_num); for (auto& [address, account] : dump_accounts.accounts) { auto to = db::code_domain_key(address); increment(to); db::kv::api::DomainRangeRequest query{ .table = std::string{db::table::kStorageDomain}, .from_key = db::code_domain_key(address), .to_key = to, .timestamp = txn_number, .ascending_order = true}; auto paginated_result = co_await transaction_.range_as_of(std::move(query)); std::map collected_entries; auto it = co_await paginated_result.begin(); while (const auto value = co_await it->next()) { if (value->second.empty()) continue; if (!account.storage.has_value()) { account.storage = Storage{}; } auto& storage = *account.storage; SILKWORM_ASSERT(value->first.size() >= kAddressLength); const auto loc = value->first.substr(kAddressLength); storage[to_bytes32(loc)] = value->second; const auto hash = hash_of(loc); collected_entries[Bytes{hash.bytes, kHashLength}] = value->second; } trie::HashBuilder hb; for (const auto& [key, value] : collected_entries) { Bytes encoded{}; rlp::encode(encoded, value); Bytes unpacked = trie::unpack_nibbles(key); hb.add_leaf(unpacked, encoded); } account.root = hb.root_hash(); } SILK_TRACE << "block_number " << block_num << " END"; co_return; } } // namespace silkworm::rpc::core ================================================ FILE: silkworm/rpc/core/account_dumper.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc::core { using db::kv::api::KeyValue; class AccountDumper { public: explicit AccountDumper(db::kv::api::Transaction& transaction) : transaction_(transaction) {} AccountDumper(const AccountDumper&) = delete; AccountDumper& operator=(const AccountDumper&) = delete; Task dump_accounts( const BlockNumOrHash& block_num_or_hash, const evmc::address& start_address, int16_t max_result, bool exclude_code, bool exclude_storage); private: Task load_storage(BlockNum block_num, DumpAccounts& dump_accounts); db::kv::api::Transaction& transaction_; }; } // namespace silkworm::rpc::core ================================================ FILE: silkworm/rpc/core/account_dumper_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "account_dumper.hpp" #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using db::chain::ChainStorage; using db::kv::api::BaseTransaction; using db::kv::api::Cursor; using db::kv::api::CursorDupSort; using db::kv::api::KeyValue; static const nlohmann::json kEmpty; static constexpr std::string_view kZeros = "00000000000000000000000000000000000000000000000000000000000000000000000000000000"; #ifdef TEST_DISABLED static const evmc::bytes32 kZeroHash = 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32; #endif class DummyCursor : public CursorDupSort { public: explicit DummyCursor(const nlohmann::json& json) : json_{json} {} uint32_t cursor_id() const override { return 0; } Task open_cursor(std::string_view table_name, bool /*is_dup_sorted*/) override { table_name_ = table_name; table_ = json_.value(table_name_, kEmpty); itr_ = table_.end(); co_return; } Task close_cursor() override { table_name_ = ""; co_return; } Task seek(silkworm::ByteView key) override { const auto key_hex = silkworm::to_hex(key); KeyValue out; for (itr_ = table_.begin(); itr_ != table_.end(); ++itr_) { auto actual = key_hex; auto delta = itr_.key().size() - actual.size(); if (delta > 0) { actual += kZeros.substr(0, delta); } if (itr_.key() >= actual) { auto kk{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{kk, value}; break; } } co_return out; } Task seek_exact(silkworm::ByteView key) override { const nlohmann::json table = json_.value(table_name_, kEmpty); const auto& entry = table.value(silkworm::to_hex(key), ""); auto value{*silkworm::from_hex(entry)}; auto kv = KeyValue{silkworm::Bytes{key}, value}; co_return kv; } Task first() override { throw std::logic_error{"not implemented"}; } Task last() override { throw std::logic_error{"not implemented"}; } Task next() override { KeyValue out; if (++itr_ != table_.end()) { auto key{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{key, value}; } co_return out; } Task previous() override { KeyValue out; if (--itr_ != table_.begin()) { auto key{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{key, value}; } co_return out; } Task next_dup() override { KeyValue out; if (++itr_ != table_.end()) { auto key{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{key, value}; } co_return out; } Task seek_both(silkworm::ByteView key, silkworm::ByteView value) override { silkworm::Bytes key_val{key}; key_val += value; const nlohmann::json table = json_.value(table_name_, kEmpty); const auto& entry = table.value(silkworm::to_hex(key_val), ""); auto out{*silkworm::from_hex(entry)}; co_return out; } Task seek_both_exact(silkworm::ByteView key, silkworm::ByteView value) override { silkworm::Bytes key_val{key}; key_val += value; const nlohmann::json table = json_.value(table_name_, kEmpty); const auto& entry = table.value(silkworm::to_hex(key_val), ""); auto out{*silkworm::from_hex(entry)}; auto kv = KeyValue{silkworm::Bytes{}, out}; co_return kv; } private: std::string table_name_; const nlohmann::json& json_; nlohmann::json table_; nlohmann::json::iterator itr_; }; class DummyTransaction : public BaseTransaction { public: explicit DummyTransaction(const nlohmann::json& json) : BaseTransaction{nullptr}, json_{json} {} uint64_t tx_id() const override { return 0; } uint64_t view_id() const override { return 0; } Task open() override { co_return; } Task> cursor(std::string_view table) override { auto cursor = std::make_unique(json_); co_await cursor->open_cursor(table, false); co_return cursor; } Task> cursor_dup_sort(std::string_view table) override { auto cursor = std::make_unique(json_); co_await cursor->open_cursor(table, true); co_return cursor; } std::shared_ptr make_storage() override { return nullptr; } Task first_txn_num_in_block(BlockNum /*block_num*/) override { co_return 0; } Task close() override { co_return; } Task get_latest(db::kv::api::GetLatestRequest /*query*/) override { co_return db::kv::api::GetLatestResult{}; } Task get_as_of(db::kv::api::GetAsOfRequest /*query*/) override { co_return db::kv::api::GetAsOfResult{}; } Task history_seek(db::kv::api::HistoryPointRequest /*query*/) override { co_return db::kv::api::HistoryPointResult{}; } Task index_range(db::kv::api::IndexRangeRequest /*query*/) override { co_return test::empty_timestamps(); } Task history_range(db::kv::api::HistoryRangeRequest /*query*/) override { co_return test::empty_keys_and_values(); } Task range_as_of(db::kv::api::DomainRangeRequest /*query*/) override { co_return test::empty_keys_and_values(); } private: const nlohmann::json& json_; }; class DummyDatabase : public db::kv::api::Service { public: explicit DummyDatabase(const nlohmann::json& json) : json_{json} {} Task> begin_transaction() override { auto txn = std::make_unique(json_); co_return txn; } Task version() override { co_return db::kv::api::kCurrentVersion; } Task state_changes(const db::kv::api::StateChangeOptions&, db::kv::api::StateChangeConsumer) override { co_return; } private: const nlohmann::json& json_; }; // const evmc::address start_address{0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address}; #ifdef TEST_DISABLED TEST_CASE("account dumper") { WorkerPool pool{1}; nlohmann::json json; BlockCache block_cache(100, true); json["TxSender"] = { {"000000000052a0b3e64899e6fe64ebb72b8f65565e9dd765776da064aff9af4601c1efa445dbb0a1", "56768b032fc12d2e911ef654b0054e26a58cef7479a4d418f7887dd4d5123a41b6c8c186686ae8cbf14cd6286564e44223ad6aee242623bf4398f99d8bb2dc06b366a48fbf98824e2d30387b1d8c748823b790f50dacb056c5e1ef6bc33fde744a739633b1b19eff752019cd5108dbef2ff56eb1dd0bb0633dfbfdf2fdb29d1976d70483eff7552de991be5c4ba4880d287d504e503bc5883848cbcce839e495cb9ec8584681f4ffc23029eb5d303370e2112b64f3a3956d084e3f2a24add02c35c8afd09e3e9bf5ca3cd40edc45d29b28442e87892a32b020076d59d978cc9c7a93935fecd66c96e2df5f363dc63bc8784798960e52dde47705f1aa1c21243ea8222dda"}, // NOLINT }; json["CanonicalHeader"] = { {"000000000052a0b3", "e64899e6fe64ebb72b8f65565e9dd765776da064aff9af4601c1efa445dbb0a1"}}; json["Header"] = { {"000000000052a0b3e64899e6fe64ebb72b8f65565e9dd765776da064aff9af4601c1efa445dbb0a1", "f9025ea05dfbfea4e8281a3c88251302b934250b4c106ca9e28886996bec4be6d83b5a7ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a09aae6b27d42db5f0130981f83cb17a781cc3450926a1c5f3448776ab303a6062a0070f786d033c1bc1ff1aa0d0bd6284b509c7f996aeae1e2cbf0444d125150d0da055d831ce3b18b3658554040bf6478c4d6f56b973f4228d27d6142b9b3b59adcab901000000140000000000000000000000000000000000080000000000400000000000000000004000000000000000040000000000000400040000000000000020400000000000020000000100000d000000000000000000000000000000008080050040000001020000000408000000000800000000000000000000000010000200000000000000000000020000000000000000000040000000000000000000000000260000000008000800000000000000000000000000000000000000000002000000000002000080000000000000000000000000002000000000000020000020000010000000000010000000000000000020000000000000000000000800000000028352a0b38401c951118312445c84612de46cb861f09f928e20407072796c616273206e6f64652d3020f09f928e0000000000000002e9e802dfe510235dc79ed41e4f712ad17f9e0f0076484cba36993318d7c6b0538e97593097597bc95e6f1a2144eeeeea14982b13667dcbaec7e1b490ed9cd801a0000000000000000000000000000000000000000000000000000000000000000088000000000000000007"} // NOLINT }; json["BlockBody"] = {{"000000000052a0b3e64899e6fe64ebb72b8f65565e9dd765776da064aff9af4601c1efa445dbb0a1", "c784024402390dc0"}}; json["BlockTransaction"] = { {"0000000002440239", "b89202f88f05168459682f008459682f0a830147f794c92047cec2355293a9e3710e32851f3509e7313e80a4a694fc3a00000000000000000000000000000000000000000000010f0cf064dd59200000c080a0f9f7c30262e7f988fef887dcaa8e210232b5b70a24dacab590f55ad7b4d29813a0369e1621cea46508cdeb8e6ccc3664e7470485662688787c4ee3e3577dbf0651"}, // NOLINT {"000000000244023a", "b87602f873058207e98459682f008459682f0a82520894861ca2f5ff2e03f90d2c3eafda88752fbffc6a6987470de4df82000080c001a0b6809d941f0c51652eaeefeaabe769ecf20e2ecbc2e2a0f8ffb79674a7dd323ea05a0c7018dba31912dd177d78a11b917be460faad27ca937e66b663abc8e131b9"}, // NOLINT {"000000000244023b", "f8a8048459682f0582855c9407aaec0b237ccf56b03a7c43c1c7a783da56064280b844783d80e1000000000000000000000000f14cd6286564e44223ad6aee242623bf4398f99d000000000000000000000000f14cd6286564e44223ad6aee242623bf4398f99d2da02fecfc9a8c280276d7b166c628793e922044a2f89e3e9bb1681774e26b63465ea0419f1f0a7c59d7893ab8e8b4ac15df3ac397144bdce91126c6d0e6578bcceadb"}, // NOLINT {"000000000244023c", "f8a9058459682f05830117ef9407aaec0b237ccf56b03a7c43c1c7a783da56064280b844783d80e10000000000000000000000008bb2dc06b366a48fbf98824e2d30387b1d8c74880000000000000000000000008bb2dc06b366a48fbf98824e2d30387b1d8c74882da07fe6c6759140cf4c533f36f4b8a99150d2378a75bd2394d6ddd7e6308c3997c8a003d28b50442328c6ae90d4a830013461244582aeeff13fa56547c27192aaf36c"}, // NOLINT {"000000000244023d", "f868038459682f058301f5769407aaec0b237ccf56b03a7c43c1c7a783da56064280845feeed8d2ea0697f347e55c058a03c01026f0f2e485d9255562baf4688db668c1b2cbc96ea45a045fd699769adce06b3b6d829b6ba7bca20e001d01a9a029926648a639d876a16"}, // NOLINT {"000000000244023e", "f8a9048459682f05830117ef9407aaec0b237ccf56b03a7c43c1c7a783da56064280b844783d80e1000000000000000000000000b1b19eff752019cd5108dbef2ff56eb1dd0bb063000000000000000000000000b1b19eff752019cd5108dbef2ff56eb1dd0bb0632da0ea6937ca91455ac8fc576b5af80dbbd7cff4272008ec50d597384b0830eb4610a07b6df980c9960632bb6da7cb25d101db6b46f4ccabb4931f52c4bbf5d9fc21d3"}, // NOLINT {"000000000244023f", "f868048459682f058301f5769407aaec0b237ccf56b03a7c43c1c7a783da56064280845feeed8d2ea0de498c970a1a49b51339172182fbbf23ab6966962e949b54d358ce542f16ff29a002f777a82a4120b8172bf7845aa2f7d2db21b23c757982c8dcd0b52ef7dad2c8"}, // NOLINT {"0000000002440240", "f868808459682f0583011fab9430d9ed9054681c56bf3cff638b4f3109ed06339a8084d02042a32da0937cf92d2f3e7234d4346947e380aa13e17937e896aa9e799faba0fc0913e765a063952418db203637e0264a6c2be25719d3e3169f5908a594d1ed59cdedc992f0"}, // NOLINT {"0000000002440241", "f868028459682f0583021cea9407aaec0b237ccf56b03a7c43c1c7a783da56064280845feeed8d2da02df3d3b21eb23af8470e700d028b9b2ab180f1ea5d437dbc858689f3c6d765c1a023aad70dc08bf61f9423b6057e74ae8f496755cce789e5c26ed3c914ec3f2aba"}, // NOLINT {"0000000002440242", "f868058459682f058301f5769407aaec0b237ccf56b03a7c43c1c7a783da56064280845feeed8d2ea0b5bf525d617be11f12287e0e25f26d9d0abce312d09e4978ea74e77f5e79bf6ca0699d151e6379df76965f9498813259e8a83e7ac09a977bd1c97619d9d4340696"}, // NOLINT {"0000000002440243", "f868068459682f058301f5769407aaec0b237ccf56b03a7c43c1c7a783da56064280845feeed8d2da0530bb04a9cbfd4bd513b8d7cc127495de9f0303e3aa20c63cae98b2add03859ba060d7b7d6a92a8c4427ca55ce1c819c5f3f9ab57669c04e13d4db379c0600360d"}, // NOLINT {"0000000002440244", "f868058459682f058301f5769407aaec0b237ccf56b03a7c43c1c7a783da56064280845feeed8d2ea0fc4d95d267881283c62ced98179c96ac36e818b96f6ff1300c30e825825af270a0436e031da786da986afa7d1a01108ad3030d1b760764a8b0d600485f8cba7f0b"}, // NOLINT {"0000000002440245", "f868028459682f05830129d19407aaec0b237ccf56b03a7c43c1c7a783da5606428084d02042a32ea0fc8d0b3cea1caab2ef34549fb4c0437ab8d7d4034eb5d3d1cd7ae609715f7660a020ec8b1b775c3d1c455f66dd59daac590cadd54d5ff5883ecf7db86fdbf0f6a7"} // NOLINT }; json["PlainState"] = { {"79a4d418f7887dd4d5123a41b6c8c186686ae8cb", "030207fc08107ee3bbb7bf3a70"}, {"79a4d492a05cfd836ea0967edb5943161dd041f7", "0d0101010120d6ea9698de278dad2f31566cd744dd75c4e09925b4bb8f041d265012a940797c"}, {"79a4d492a05cfd836ea0967edb5943161dd041f700000000000000010000000000000000000000000000000000000000000000000000000000000001", "2ac3c1d3e24b45c6c310534bc2dd84b5ed576335"}, // NOLINT {"79a4d492a05cfd836ea0967edb5943161dd041f700000000000000010000000000000000000000000000000000000000000000000000000000000006", "335a9b3f79dcfefda3295be6f7c7c47f077dbcd9"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea", "0d0101010120925fa7384049febb1eddca32821f1f1d709687628c1cf77ef40ca5013d04bdef"}, {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010000000000000000000000000000000000000000000000000000000000000001", "2ac3c1d3e24b45c6c310534bc2dd84b5ed576335"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010000000000000000000000000000000000000000000000000000000000000003", "1f6ea08600"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010000000000000000000000000000000000000000000000000000000000000006", "9d5a08e7551951a3ca73cd84a6409ef1e77f5abe"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010178b166a1bcfd299a6ce6918f016c8d0c52788988d89f65f5727c2fa97be6e9", "1e80355e00"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000001b797965b738ad51ddbf643b315d0421c26972862ca2e64304783dc8930a2b6e8", "ee6b2800"}, // NOLINT {"79a4d75bd00b1843ec5292217e71dace5e5a7439", "03010107181855facbc200"}}; json["AccountHistory"] = { {"79a4d418f7887dd4d5123a41b6c8c186686ae8cb00000000005151a3", "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"}, // NOLINT {"79a4d418f7887dd4d5123a41b6c8c186686ae8cb000000000052a0b3", "0100000000000000000000003b3001000151000201520032005a00a551040072ba0000efba0600f7ba0100faba0000fcba030004bb030009bb070012bb000014bb010017bb02001bbb00001dbb050024bb000026bb02002abb040030bb00009cbb01009fbb0200a4bb0100a7bb0200abbb0000aebb0200b3bb0100b6bb0100bcbb0000c4bb000025bd000027bd01002cbd00002ebd000030bd0e0040bd000042bd00004fbd030054bd010057bd04005fbd020064bd0200cebd0000d0bd0200d4bd0300d9bd0000dbbd0100e0bd0000e2bd0000e4bd0500ebbd0700f4bd0000f6bd0500fdbd0000ffbd050006be000008be01000bbe040051eb030056eb010059eb030065eb00006deb000077eb090084eb000086eb000088eb00008deb00008feb010092eb020096eb000098eb0a00a4eb0700adeb02000fee000045ee010048ee01004bee00004dee010050ee020054ee000056ee05005dee00005fee000062ee000064ee000066ee000068ee02006eee010071ee010074ee020078ee00007aee07000d9c139c169c179c1b9c219c229c249c279c2c9c2d9c329c349c379c389c3c9c3d9c489c4d9c519c549ca59cb69cb19eb39eb69eda9edc9edd9ee09ee39ee49ee79ee99eed9eee9e969f989fd89f06a007a058a059a05aa05ba05ca05da07ea080a0b2a0b3a0"}, // NOLINT {"79a4d418f7887dd4d5123a41b6c8c186686ae8cb000000000052a140", "0100000000000000000000003a300000010000005200040010000000b4a03da13ea13fa140a1"}, // NOLINT {"79a4d418f7887dd4d5123a41b6c8c186686ae8cbffffffffffffffff", "0100000000000000000000003a30000001000000520007001000000041a16fa179a17aa187a195a197a1a5a1"}, // NOLINT {"79a4d492a05cfd836ea0967edb5943161dd041f7ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000019b"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981eaffffffffffffffff", "0100000000000000000000003a30000002000000480000004b000100180000001a000000b9e0d505c5c5"}, // NOLINT {"79a4d75bd00b1843ec5292217e71dace5e5a7439ffffffffffffffff", "0100000000000000000000003a300000020000004500000046000000180000001a0000005b7f3fb1"} // NOLINT }; json["AccountChangeSet"] = { {"000000000052a0b479a4d418f7887dd4d5123a41b6c8c186686ae8cb", "79a4d418f7887dd4d5123a41b6c8c186686ae8cb030207ea08157fe18268af2da8"} // NOLINT }; json["Code"] = { {"d6ea9698de278dad2f31566cd744dd75c4e09925b4bb8f041d265012a940797c", "363d3d373d3d3d363d73a8607bb8554de1589893d21d08832ccadbba53ff5af43d82803e903d91602b57fd5bf3"}, // NOLINT {"925fa7384049febb1eddca32821f1f1d709687628c1cf77ef40ca5013d04bdef", "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"} // NOLINT }; json["StorageHistory"] = { {"79a4d492a05cfd836ea0967edb5943161dd041f70000000000000000000000000000000000000000000000000000000000000001ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000019b"}, // NOLINT {"79a4d492a05cfd836ea0967edb5943161dd041f70000000000000000000000000000000000000000000000000000000000000006ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000019b"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000000000000000000000000000000000000000000000000000001ffffffffffffffff", "0100000000000000000000003a300000010000004800000010000000b9e0"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000000000000000000000000000000000000000000000000000003ffffffffffffffff", "0100000000000000000000003a300000010000004b00010010000000d505c5c5"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000000000000000000000000000000000000000000000000000006ffffffffffffffff", "0100000000000000000000003a300000010000004800000010000000b9e0"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0178b166a1bcfd299a6ce6918f016c8d0c52788988d89f65f5727c2fa97be6e9ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000c5c5"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981eab797965b738ad51ddbf643b315d0421c26972862ca2e64304783dc8930a2b6e8ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000d505"}, // NOLINT {"79a4e7d68b82799b9d52609756b86bd18193f2b20000000000000000000000000000000000000000000000000000000000000000ffffffffffffffff", "0100000000000000000000003a300000010000004d0000001000000052ca"} // NOLINT }; auto database = DummyDatabase{json}; auto begin_result = boost::asio::co_spawn(pool, database.begin(), boost::asio::use_future); auto tx = begin_result.get(); core::AccountDumper ad{*tx}; const BlockNumOrHash block_num_or_hash{0x52a0b3}; const evmc::address start_address{0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address}; const evmc::bytes32 root{0x9aae6b27d42db5f0130981f83cb17a781cc3450926a1c5f3448776ab303a6062_bytes32}; evmc::address address_1 = 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address; evmc::address address_2 = 0x79a4d492a05cfd836ea0967edb5943161dd041f7_address; evmc::address address_3 = 0x79a4d706e4bc7fd8ff9d0593a1311386a7a981ea_address; evmc::bytes32 root_1 = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32; // evmc::bytes32 root_2 = 0xd0e669fbe330badbad9746ffbe0eded2c37d0044b71984204ec3d42b7ed405f5_bytes32; // evmc::bytes32 root_3 = 0xf88d7fd6659bcd2fdd4c62038f86cdea902d401c5d4d682288027310e5cca24e_bytes32; evmc::bytes32 code_hash_1 = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470_bytes32; evmc::bytes32 code_hash_2 = 0xd6ea9698de278dad2f31566cd744dd75c4e09925b4bb8f041d265012a940797c_bytes32; evmc::bytes32 code_hash_3 = 0x925fa7384049febb1eddca32821f1f1d709687628c1cf77ef40ca5013d04bdef_bytes32; SECTION("1 result, exclude code and storage") { int16_t max_result = 1; bool exclude_code = true; bool exclude_storage = true; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts& da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == static_cast(max_result)); CHECK(da.accounts.find(address_1) != da.accounts.end()); const auto& account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); } SECTION("2 result, exclude code and storage") { int16_t max_result = 2; bool exclude_code = true; bool exclude_storage = true; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts& da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == static_cast(max_result)); CHECK(da.accounts.find(address_1) != da.accounts.end()); auto account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_2) != da.accounts.end()); account = da.accounts.at(address_2); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_2); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); } SECTION("3 result, exclude code and storage") { int16_t max_result = 3; bool exclude_code = true; bool exclude_storage = true; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts& da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == static_cast(max_result)); CHECK(da.accounts.find(address_1) != da.accounts.end()); auto account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_2) != da.accounts.end()); account = da.accounts.at(address_2); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_2); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_3) != da.accounts.end()); account = da.accounts.at(address_3); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_3); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); } SECTION("1 result, include code exclude storage") { int16_t max_result = 1; bool exclude_code = false; bool exclude_storage = true; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts& da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == static_cast(max_result)); CHECK(da.accounts.find(address_1) != da.accounts.end()); const auto& account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); } SECTION("2 result, include code exclude storage") { int16_t max_result = 2; bool exclude_code = false; bool exclude_storage = true; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts& da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == static_cast(max_result)); CHECK(da.accounts.find(address_1) != da.accounts.end()); auto account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_2) != da.accounts.end()); account = da.accounts.at(address_2); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_2); CHECK(account.code.has_value()); CHECK(account.code.value() == *silkworm::from_hex("0x363d3d373d3d3d363d73a8607bb8554de1589893d21d08832ccadbba53ff5af43d82803e903d91602b57fd5bf3")); CHECK(!account.storage.has_value()); } SECTION("3 result, include code exclude storage") { int16_t max_result = 3; bool exclude_code = false; bool exclude_storage = true; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts& da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == static_cast(max_result)); CHECK(da.accounts.find(address_1) != da.accounts.end()); auto account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_2) != da.accounts.end()); account = da.accounts.at(address_2); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_2); CHECK(account.code.has_value()); CHECK(account.code.value() == *silkworm::from_hex("0x363d3d373d3d3d363d73a8607bb8554de1589893d21d08832ccadbba53ff5af43d82803e903d91602b57fd5bf3")); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_3) != da.accounts.end()); account = da.accounts.at(address_3); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == kZeroHash); CHECK(account.code_hash == code_hash_3); CHECK(account.code.has_value()); CHECK(!account.storage.has_value()); } SECTION("1 result, include code and storage") { int16_t max_result = 1; bool exclude_code = false; bool exclude_storage = false; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts& da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == static_cast(max_result)); CHECK(da.accounts.find(address_1) != da.accounts.end()); const auto& account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == root_1); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); } /*SECTION("2 result, include code and storage") { uint64_t max_result = 2; bool exclude_code = false; bool exclude_storage = false; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts &da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == max_result); CHECK(da.accounts.find(address_1) != da.accounts.end()); auto account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == root_1); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_2) != da.accounts.end()); account = da.accounts.at(address_2); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == root_2); CHECK(account.code_hash == code_hash_2); CHECK(account.code.has_value()); CHECK(account.code.value() == *silkworm::from_hex("0x363d3d373d3d3d363d73a8607bb8554de1589893d21d08832ccadbba53ff5af43d82803e903d91602b57fd5bf3")); CHECK(account.storage.has_value()); auto storage = account.storage.value(); CHECK(storage.size() == 2); CHECK(storage[0x0000000000000000000000000000000000000000000000000000000000000001_bytes32] == *silkworm::from_hex("2ac3c1d3e24b45c6c310534bc2dd84b5ed576335")); CHECK(storage[0x0000000000000000000000000000000000000000000000000000000000000006_bytes32] == *silkworm::from_hex("335a9b3f79dcfefda3295be6f7c7c47f077dbcd9")); } SECTION("3 result, include code and storage") { uint64_t max_result = 3; bool exclude_code = false; bool exclude_storage = false; auto result = boost::asio::co_spawn(pool, ad.dump_accounts(block_cache, block_num_or_hash, start_address, max_result, exclude_code, exclude_storage), boost::asio::use_future); const DumpAccounts &da = result.get(); CHECK(da.root == root); CHECK(da.accounts.size() == max_result); CHECK(da.accounts.find(address_1) != da.accounts.end()); auto account = da.accounts.at(address_1); CHECK(account.balance == 1549204747057049000); CHECK(account.nonce == 2026); CHECK(account.incarnation == 0); CHECK(account.root == root_1); CHECK(account.code_hash == code_hash_1); CHECK(!account.code.has_value()); CHECK(!account.storage.has_value()); CHECK(da.accounts.find(address_2) != da.accounts.end()); account = da.accounts.at(address_2); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == root_2); CHECK(account.code_hash == code_hash_2); CHECK(account.code.has_value()); CHECK(account.code.value() == *silkworm::from_hex("0x363d3d373d3d3d363d73a8607bb8554de1589893d21d08832ccadbba53ff5af43d82803e903d91602b57fd5bf3")); CHECK(account.storage.has_value()); auto storage = account.storage.value(); CHECK(storage.size() == 2); CHECK(storage[0x0000000000000000000000000000000000000000000000000000000000000001_bytes32] == *silkworm::from_hex("2ac3c1d3e24b45c6c310534bc2dd84b5ed576335")); CHECK(storage[0x0000000000000000000000000000000000000000000000000000000000000006_bytes32] == *silkworm::from_hex("335a9b3f79dcfefda3295be6f7c7c47f077dbcd9")); CHECK(da.accounts.find(address_3) != da.accounts.end()); account = da.accounts.at(address_3); CHECK(account.balance == 0); CHECK(account.nonce == 1); CHECK(account.incarnation == 1); CHECK(account.root == root_3); CHECK(account.code_hash == code_hash_3); CHECK(account.code.has_value()); CHECK(account.storage.has_value()); storage = account.storage.value(); CHECK(storage.size() == 5); CHECK(storage[0x0000000000000000000000000000000000000000000000000000000000000001_bytes32] == *silkworm::from_hex("2ac3c1d3e24b45c6c310534bc2dd84b5ed576335")); CHECK(storage[0x0000000000000000000000000000000000000000000000000000000000000003_bytes32] == *silkworm::from_hex("1f6ea08600")); CHECK(storage[0x0000000000000000000000000000000000000000000000000000000000000006_bytes32] == *silkworm::from_hex("9d5a08e7551951a3ca73cd84a6409ef1e77f5abe")); CHECK(storage[0x0178b166a1bcfd299a6ce6918f016c8d0c52788988d89f65f5727c2fa97be6e9_bytes32] == *silkworm::from_hex("1e80355e00")); CHECK(storage[0xb797965b738ad51ddbf643b315d0421c26972862ca2e64304783dc8930a2b6e8_bytes32] == *silkworm::from_hex("ee6b2800")); }*/ } #endif } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/block_reader.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block_reader.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using db::kv::StateReader; using namespace silkworm::db; using namespace silkworm::db::chain; static constexpr std::string_view kHeadBlockHash = "headBlockHash"; static constexpr std::string_view kFinalizedBlockHash = "finalizedBlockHash"; static constexpr std::string_view kSafeBlockHash = "safeBlockHash"; void to_json(nlohmann::json& json, const BalanceChanges& balance_changes) { for (const auto& entry : balance_changes) { json[address_to_hex(entry.first)] = to_quantity(entry.second); } } Task> BlockReader::read_block_by_number(BlockCache& cache, BlockNum block_num) const { const auto block_hash = co_await chain_storage_.read_canonical_header_hash(block_num); if (!block_hash) { co_return nullptr; } const auto cached_block = cache.get(*block_hash); if (cached_block) { co_return cached_block; } const auto block_with_hash = std::make_shared(); const auto block_found = co_await chain_storage_.read_block(block_hash->bytes, block_num, /*read_senders=*/true, block_with_hash->block); if (!block_found) { co_return nullptr; } block_with_hash->hash = *block_hash; if (!block_with_hash->block.transactions.empty()) { // don't save empty (without txs) blocks to cache, if block become non-canonical (not in main chain), we remove it's transactions, // but block can in the future become canonical(inserted in main chain) with its transactions cache.insert(*block_hash, block_with_hash); } co_return block_with_hash; } Task> BlockReader::read_block_by_hash(BlockCache& cache, const evmc::bytes32& block_hash) const { const auto cached_block = cache.get(block_hash); if (cached_block) { co_return cached_block; } const auto block_with_hash = std::make_shared(); const auto block_num = co_await chain_storage_.read_block_num(block_hash); if (!block_num) { co_return nullptr; } const auto block_found = co_await chain_storage_.read_block(block_hash.bytes, *block_num, /*read_senders=*/true, block_with_hash->block); if (!block_found) { co_return nullptr; } block_with_hash->hash = block_hash; if (!block_with_hash->block.transactions.empty()) { // don't save empty (without txs) blocks to cache, if block become non-canonical (not in main chain), we remove it's transactions, // but block can in the future become canonical(inserted in main chain) with its transactions cache.insert(block_hash, block_with_hash); } co_return block_with_hash; } Task> BlockReader::read_block_by_block_num_or_hash(BlockCache& cache, const BlockNumOrHash& block_num_or_hash) const { if (block_num_or_hash.is_number()) { // NOLINT(bugprone-branch-clone) co_return co_await read_block_by_number(cache, block_num_or_hash.number()); } if (block_num_or_hash.is_hash()) { co_return co_await read_block_by_hash(cache, block_num_or_hash.hash()); } if (block_num_or_hash.is_tag()) { auto [block_num, ignore] = co_await get_block_num(block_num_or_hash.tag(), /*latest_required=*/false); co_return co_await read_block_by_number(cache, block_num); } throw std::runtime_error{"invalid block_num_or_hash value"}; } Task> BlockReader::read_header_by_block_num_or_hash(const BlockNumOrHash& block_num_or_hash) const { if (block_num_or_hash.is_number()) { // NOLINT(bugprone-branch-clone) co_return co_await chain_storage_.read_canonical_header(block_num_or_hash.number()); } if (block_num_or_hash.is_hash()) { co_return co_await chain_storage_.read_header(block_num_or_hash.hash()); } if (block_num_or_hash.is_tag()) { auto [block_num, ignore] = co_await get_block_num(block_num_or_hash.tag(), /*latest_required=*/false); co_return co_await chain_storage_.read_canonical_header(block_num); } throw std::runtime_error{"invalid block_num_or_hash value"}; } Task> BlockReader::read_transaction_by_hash(BlockCache& cache, const evmc::bytes32& transaction_hash) const { const auto result = co_await chain_storage_.read_block_num_by_transaction_hash(transaction_hash); if (!result) { co_return std::nullopt; } const auto block_with_hash = co_await read_block_by_number(cache, result->first); if (!block_with_hash) { co_return std::nullopt; } const auto& transactions = block_with_hash->block.transactions; for (size_t idx{0}; idx < transactions.size(); ++idx) { if (transaction_hash == transactions[idx].hash()) { const auto& block_header = block_with_hash->block.header; co_return TransactionWithBlock{ block_with_hash, {transactions[idx], block_with_hash->hash, block_header.number, block_header.base_fee_per_gas, idx}}; } } co_return std::nullopt; } Task BlockReader::read_balance_changes(const BlockNumOrHash& block_num_or_hash, BalanceChanges& balance_changes) const { const auto [block_num, is_latest] = co_await get_block_num(block_num_or_hash); SILK_TRACE << "read_balance_changes: block_num: " << block_num; const auto start_txn_number = co_await transaction_.first_txn_num_in_block(block_num); const auto end_txn_number = co_await transaction_.first_txn_num_in_block(block_num + 1); std::optional txn_id; if (!is_latest) { txn_id = co_await transaction_.user_txn_id_at(block_num + 1); } StateReader state_reader{transaction_, txn_id}; db::kv::api::HistoryRangeRequest query{ .table = std::string{db::table::kAccountDomain}, .from_timestamp = static_cast(start_txn_number), .to_timestamp = static_cast(end_txn_number), .ascending_order = true}; auto paginated_result = co_await transaction_.history_range(std::move(query)); auto it = co_await paginated_result.begin(); while (const auto value = co_await it->next()) { intx::uint256 old_balance{0}; intx::uint256 current_balance{0}; if (!value->second.empty()) { const auto account{db::state::AccountCodec::from_encoded_storage_v3(value->second)}; if (account) { old_balance = account->balance; } } evmc::address address = bytes_to_address(value->first); if (auto current_account = co_await state_reader.read_account(address)) { current_balance = current_account->balance; } if (current_balance != old_balance) { balance_changes[address] = current_balance; } } SILK_DEBUG << "Changed balances: " << balance_changes.size(); } Task BlockReader::get_forkchoice_block_num(std::string_view block_hash_tag) const { const auto kv_pair = co_await transaction_.get(table::kLastForkchoiceName, string_view_to_byte_view(block_hash_tag)); const auto block_hash_data = kv_pair.value; if (block_hash_data.empty()) { co_return 0; } const auto block_hash = to_bytes32(block_hash_data); auto block_num = co_await chain_storage_.read_block_num(block_hash); if (!block_num) { co_return 0; } co_return *block_num; } Task BlockReader::is_latest_block_num(BlockNum block_num) const { const auto last_executed_block_num = co_await get_latest_executed_block_num(); co_return last_executed_block_num == block_num; } Task BlockReader::get_block_num_by_tag(std::string_view block_id) const { BlockNum block_num{0}; if (block_id == kEarliestBlockId) { block_num = kEarliestBlockNum; } else if (block_id == kLatestBlockId || block_id == kPendingBlockId) { // NOLINT(bugprone-branch-clone) block_num = co_await get_latest_block_num(); } else if (block_id == kFinalizedBlockId) { block_num = co_await get_forkchoice_finalized_block_num(); } else if (block_id == kSafeBlockId) { block_num = co_await get_forkchoice_safe_block_num(); } else { block_num = co_await get_latest_executed_block_num(); } SILK_DEBUG << "get_block_num_by_tag block_num: " << block_num; co_return block_num; } Task> BlockReader::get_block_num(std::string_view block_id, bool latest_required) const { BlockNum block_num{0}; bool is_latest_block = false; bool check_if_latest = false; if (block_id == kEarliestBlockId) { block_num = kEarliestBlockNum; } else if (block_id == kLatestBlockId || block_id == kPendingBlockId) { // NOLINT(bugprone-branch-clone) block_num = co_await get_latest_block_num(); is_latest_block = true; } else if (block_id == kFinalizedBlockId) { // NOLINT(bugprone-branch-clone) block_num = co_await get_forkchoice_finalized_block_num(); check_if_latest = latest_required; } else if (block_id == kSafeBlockId) { block_num = co_await get_forkchoice_safe_block_num(); check_if_latest = latest_required; } else if (block_id == kLatestExecutedBlockId) { block_num = co_await get_latest_executed_block_num(); is_latest_block = true; } else if (is_valid_hex(block_id)) { std::from_chars(block_id.data() + 2, block_id.data() + block_id.size(), block_num, 16); check_if_latest = latest_required; } else if (is_valid_dec(block_id)) { std::from_chars(block_id.data(), block_id.data() + block_id.size(), block_num, 10); check_if_latest = latest_required; } else { throw std::invalid_argument("get_block_num::Invalid Block Id"); } if (check_if_latest) { is_latest_block = co_await is_latest_block_num(block_num); } SILK_DEBUG << "get_block_num block_num: " << block_num << " is_latest_block: " << is_latest_block; co_return std::make_pair(block_num, is_latest_block); } Task BlockReader::get_block_num(std::string_view block_id) const { const auto [block_num, _] = co_await get_block_num(block_id, /*latest_required=*/false); co_return block_num; } Task> BlockReader::get_block_num(const BlockNumOrHash& block_num_or_hash) const { if (block_num_or_hash.is_tag()) { co_return co_await get_block_num(block_num_or_hash.tag(), true); } else if (block_num_or_hash.is_number()) { co_return co_await get_block_num(silkworm::to_hex(block_num_or_hash.number(), true), true); } else if (block_num_or_hash.is_hash()) { const auto block_num = co_await chain_storage_.read_block_num(block_num_or_hash.hash()); if (!block_num) { throw std::invalid_argument("Invalid Block Hash"); } const auto latest_block_num = co_await get_latest_block_num(); co_return std::make_pair(*block_num, *block_num == latest_block_num); } else { throw std::invalid_argument("Invalid Block Number or Hash"); } } Task BlockReader::get_block_num(const Hash& hash) const { auto bn = co_await chain_storage_.read_block_num(hash); ensure(bn != 0, "get_block_num: block with hash not found"); co_return *bn; } Task BlockReader::get_current_block_num() const { co_return co_await stages::get_sync_stage_progress(transaction_, stages::kFinish); } Task BlockReader::get_max_block_num() const { co_return co_await stages::get_sync_stage_progress(transaction_, stages::kHeaders); } Task BlockReader::get_latest_executed_block_num() const { co_return co_await stages::get_sync_stage_progress(transaction_, stages::kExecution); } Task BlockReader::get_latest_block_num() const { const auto kv_pair = co_await transaction_.get(table::kLastForkchoiceName, string_view_to_byte_view(kHeadBlockHash)); const auto head_block_hash_data = kv_pair.value; if (!head_block_hash_data.empty()) { const auto head_block_hash = to_bytes32(head_block_hash_data); auto block_num = co_await chain_storage_.read_block_num(head_block_hash); if (!block_num) { co_return 0; } co_return *block_num; } co_return co_await get_latest_executed_block_num(); } Task BlockReader::get_forkchoice_finalized_block_num() const { co_return co_await get_forkchoice_block_num(kFinalizedBlockHash); } Task BlockReader::get_forkchoice_safe_block_num() const { co_return co_await get_forkchoice_block_num(kSafeBlockHash); } Task BlockReader::is_latest_block_num(const BlockNumOrHash& block_num_or_hash) const { if (block_num_or_hash.is_tag()) { co_return block_num_or_hash.tag() == kLatestBlockId || block_num_or_hash.tag() == kPendingBlockId; } else { const auto latest_block_num = co_await get_latest_block_num(); if (block_num_or_hash.is_number()) { co_return block_num_or_hash.number() == latest_block_num; } else { SILKWORM_ASSERT(block_num_or_hash.is_hash()); const auto block_num = co_await chain_storage_.read_block_num(block_num_or_hash.hash()); if (!block_num) { co_return false; } co_return *block_num == latest_block_num; } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/block_reader.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using BalanceChanges = std::map; void to_json(nlohmann::json& json, const BalanceChanges& balance_changes); inline constexpr std::string_view kEarliestBlockId{"earliest"}; inline constexpr std::string_view kLatestBlockId{"latest"}; inline constexpr std::string_view kPendingBlockId{"pending"}; inline constexpr std::string_view kFinalizedBlockId{"finalized"}; inline constexpr std::string_view kSafeBlockId{"safe"}; inline constexpr std::string_view kLatestExecutedBlockId{"latestExecuted"}; class BlockReader { public: BlockReader(const db::chain::ChainStorage& chain_storage, db::kv::api::Transaction& transaction) : chain_storage_(chain_storage), transaction_(transaction) {} BlockReader(const BlockReader&) = delete; BlockReader& operator=(const BlockReader&) = delete; Task> read_block_by_number(BlockCache& cache, BlockNum block_num) const; Task> read_block_by_hash(BlockCache& cache, const evmc::bytes32& block_hash) const; Task> read_block_by_block_num_or_hash(BlockCache& cache, const BlockNumOrHash& block_num_or_hash) const; Task> read_transaction_by_hash(BlockCache& cache, const evmc::bytes32& transaction_hash) const; Task read_balance_changes(const BlockNumOrHash& block_num_or_hash, BalanceChanges& balance_changes) const; Task is_latest_block_num(BlockNum block_num) const; Task get_block_num_by_tag(std::string_view block_id) const; Task> get_block_num(std::string_view block_id, bool latest_required) const; Task get_block_num(std::string_view block_id) const; Task> get_block_num(const BlockNumOrHash& block_num_or_hash) const; Task get_block_num(const Hash& hash) const; Task get_current_block_num() const; Task get_max_block_num() const; Task get_latest_block_num() const; Task get_latest_executed_block_num() const; Task get_forkchoice_finalized_block_num() const; Task get_forkchoice_safe_block_num() const; Task is_latest_block_num(const BlockNumOrHash& block_num_or_hash) const; Task> read_header(BlockNum block_num) const { return chain_storage_.read_canonical_header(block_num); } Task> read_header_by_block_num_or_hash(const BlockNumOrHash& block_num_or_hash) const; private: Task get_forkchoice_block_num(std::string_view block_hash_tag) const; const db::chain::ChainStorage& chain_storage_; db::kv::api::Transaction& transaction_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/block_reader_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block_reader.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::core { using db::kv::api::KeyValue; using db::test_util::MockChainStorage; using db::test_util::MockTransaction; using testing::_; using testing::InvokeWithoutArgs; namespace table = silkworm::db::table; static silkworm::BlockNum kBlockNumber{0x3D0900}; static silkworm::Bytes kNumber{*silkworm::from_hex("00000000003D0900")}; static silkworm::Bytes block_hash = string_to_bytes(std::string("0x439816753229fc0736bf86a5048de4bc9fcdede8c91dadf88c828c76b2281dff")); static silkworm::Bytes kHeader{*silkworm::from_hex( "f9025ca0209f062567c161c5f71b3f57a7de277b0e95c3455050b152d785ad" "7524ef8ee7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000" "000000000a0e7536c5b61ed0e0ab7f3ce7f085806d40f716689c0c086676757de401b595658a040be247314d834a319556d1dcf458e87" "07cc1aa4a416b6118474ce0c96fccb1aa07862fe11d10a9b237ffe9cb660f31e4bc4be66836c9bfc17310d47c60d75671fb9010000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000001833d0900837a1200831e784b845fe880abb8" "61d88301091a846765746888676f312e31352e36856c696e757800000000000000be009d0049d6f0ee8ca6764a1d3eb519bd4d046e167" "ddcab467d5db31d063f2d58f266fa86c4502aa169d17762090e92b821843de69b41adbb5d86f5d114ba7f01a000000000000000000000" "00000000000000000000000000000000000000000000880000000000000000")}; static const silkworm::ByteView kExecutionStage{stages::kExecution}; // The following constants must stay here and outlive the spawned coroutine to avoid ASAN complains because: // 1) passing const char* constants directly where const std::string& is expected creates references to temporary objects // into the coroutine frame // 2) when the coroutine is actually executed such references refer to destroyed stack objects, hence stack-use-after-scope error static constexpr std::string_view kEarliest = kEarliestBlockId; static constexpr std::string_view kLatest = kLatestBlockId; static constexpr std::string_view kLatestExecuted = kLatestExecutedBlockId; static constexpr std::string_view kPending = kPendingBlockId; static constexpr std::string_view kFinalized = kFinalizedBlockId; static constexpr std::string_view kSafe = kSafeBlockId; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("1234567890123456")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kLatest, /*latest_required=*/false), boost::asio::use_future); auto [block_num, ignore] = result.get(); CHECK(block_num == 0x1234567890123456); } SECTION("kLatestExecutedBlockId") { EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("1234567890123456")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kLatestExecuted, /*latest_required=*/false), boost::asio::use_future); auto [block_num, ignore] = result.get(); CHECK(block_num == 0x1234567890123456); } SECTION("kPendingBlockId") { EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("1234567890123456")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kPending, /*latest_required=*/false), boost::asio::use_future); auto [block_num, ignore] = result.get(); CHECK(block_num == 0x1234567890123456); } SECTION("kFinalizedBlockId") { EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, block_hash}; })); EXPECT_CALL(chain_storage, read_block_num(_)).WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kBlockNumber; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kFinalized, /*latest_required=*/false), boost::asio::use_future); auto [block_num, ignore] = result.get(); CHECK(block_num == 0x3d0900); } SECTION("kSafeBlockId") { EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, block_hash}; })); EXPECT_CALL(chain_storage, read_block_num(_)).WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kBlockNumber; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kSafe, /*latest_required=*/false), boost::asio::use_future); auto [block_num, ignore] = result.get(); CHECK(block_num == 0x3d0900); } SECTION("block_num in hex") { static constexpr std::string_view kBlockIdHex = "0x12345"; auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kBlockIdHex, /*latest_required=*/false), boost::asio::use_future); auto [block_num, ignore] = result.get(); CHECK(block_num == 0x12345); } SECTION("block_num in dec") { static constexpr std::string_view kBlockIdDec = "67890"; auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kBlockIdDec, /*latest_required=*/false), boost::asio::use_future); auto [block_num, ignore] = result.get(); CHECK(block_num == 67890); } SECTION("block_num in hex & latest true") { static constexpr std::string_view kBlockIdHex = "0x1234"; EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("0000000000001234")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kBlockIdHex, /*latest_required=*/true), boost::asio::use_future); auto [block_num, is_latest_block] = result.get(); CHECK(block_num == 0x0000000000001234); CHECK(is_latest_block == true); } SECTION("block_num in hex & latest false") { static constexpr std::string_view kBlockIdHex = "0x1234"; EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("0000000000001235")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kBlockIdHex, /*latest_required=*/true), boost::asio::use_future); auto [block_num, is_latest_block] = result.get(); CHECK(block_num == 0x0000000000001234); CHECK(is_latest_block == false); } } TEST_CASE("get_block_num ", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; SECTION("kEarliestBlockId") { auto result = boost::asio::co_spawn(pool, block_reader.get_block_num(kEarliest), boost::asio::use_future); auto block_num = result.get(); CHECK(block_num == kEarliestBlockNum); } } TEST_CASE("get_block_num_by_tag", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; SECTION("kEarliestBlockId") { auto result = boost::asio::co_spawn(pool, block_reader.get_block_num_by_tag(kEarliest), boost::asio::use_future); auto block_num = result.get(); CHECK(block_num == kEarliestBlockNum); } SECTION("kLatestBlockId") { EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("1234567890123456")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num_by_tag(kLatest), boost::asio::use_future); auto block_num = result.get(); CHECK(block_num == 0x1234567890123456); } SECTION("kLatestExecutedBlockId") { EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("1234567890123456")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num_by_tag(kLatestExecuted), boost::asio::use_future); auto block_num = result.get(); CHECK(block_num == 0x1234567890123456); } SECTION("kPendingBlockId") { EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("1234567890123456")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num_by_tag(kPending), boost::asio::use_future); auto block_num = result.get(); CHECK(block_num == 0x1234567890123456); } SECTION("kFinalizedBlockId") { EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, block_hash}; })); EXPECT_CALL(chain_storage, read_block_num(_)).WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kBlockNumber; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num_by_tag(kFinalized), boost::asio::use_future); auto block_num = result.get(); CHECK(block_num == 0x3d0900); } SECTION("kSafeBlockId") { EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, block_hash}; })); EXPECT_CALL(chain_storage, read_block_num(_)).WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kBlockNumber; })); auto result = boost::asio::co_spawn(pool, block_reader.get_block_num_by_tag(kSafe), boost::asio::use_future); auto block_num = result.get(); CHECK(block_num == 0x3d0900); } } TEST_CASE("get_current_block_num", "[rpc][core][blocks]") { static const silkworm::ByteView kFinishStage{stages::kFinish}; MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kFinishStage)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("0000ddff12121212")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_current_block_num(), boost::asio::use_future); CHECK(result.get() == 0x0000ddff12121212); } TEST_CASE("get_max_block_num", "[rpc][core][blocks]") { static const silkworm::ByteView kHeadersStage{stages::kHeaders}; MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kHeadersStage)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("0000ddff12345678")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_max_block_num(), boost::asio::use_future); CHECK(result.get() == 0x0000ddff12345678); } TEST_CASE("get_latest_block_num", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("0000ddff12345678")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_latest_block_num(), boost::asio::use_future); CHECK(result.get() == 0x0000ddff12345678); } TEST_CASE("get_latest_executed_block_num", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("0000ddff12345678")}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_latest_executed_block_num(), boost::asio::use_future); CHECK(result.get() == 0x0000ddff12345678); } TEST_CASE("get_latest_block_num with head forkchoice block_num", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, block_hash}; })); EXPECT_CALL(chain_storage, read_block_num(_)).WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kBlockNumber; })); auto result = boost::asio::co_spawn(pool, block_reader.get_latest_block_num(), boost::asio::use_future); CHECK(result.get() == 0x3d0900); } TEST_CASE("get_forkchoice_finalized_block_num genesis block_num if no finalized block", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_forkchoice_finalized_block_num(), boost::asio::use_future); CHECK(result.get() == 0x0); } TEST_CASE("get_forkchoice_safe_block_num genesis block_num if no safe block", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([&]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); auto result = boost::asio::co_spawn(pool, block_reader.get_forkchoice_safe_block_num(), boost::asio::use_future); CHECK(result.get() == 0x0); } TEST_CASE("is_latest_block_num", "[rpc][core][blocks]") { MockTransaction transaction; MockChainStorage chain_storage; BlockReader block_reader{chain_storage, transaction}; WorkerPool pool{1}; SECTION("tag: latest") { BlockNumOrHash block_num_or_hash{"latest"}; auto result = boost::asio::co_spawn(pool, block_reader.is_latest_block_num(block_num_or_hash), boost::asio::use_future); CHECK(result.get()); } SECTION("tag: pending") { BlockNumOrHash block_num_or_hash{"pending"}; auto result = boost::asio::co_spawn(pool, block_reader.is_latest_block_num(block_num_or_hash), boost::asio::use_future); CHECK(result.get()); } SECTION("block_num: latest") { BlockNumOrHash block_num_or_hash{1'000'000}; // Mock reader shall be used to read the latest block from Execution stage in table SyncStageProgress EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("00000000000F4240")}; })); auto result = boost::asio::co_spawn(pool, block_reader.is_latest_block_num(block_num_or_hash), boost::asio::use_future); CHECK(result.get()); } SECTION("block_num: not latest") { BlockNumOrHash block_num_or_hash{1'000'000}; // Mock reader shall be used to read the latest block from Execution stage in table SyncStageProgress EXPECT_CALL(transaction, get(table::kLastForkchoiceName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); EXPECT_CALL(transaction, get(table::kSyncStageProgressName, kExecutionStage)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("00000000000F4241")}; })); auto result = boost::asio::co_spawn(pool, block_reader.is_latest_block_num(block_num_or_hash), boost::asio::use_future); CHECK(!result.get()); } } #endif // _WIN32 } // namespace silkworm::rpc::core ================================================ FILE: silkworm/rpc/core/call_many.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call_many.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::call { CallManyResult CallExecutor::executes_all_bundles(const silkworm::ChainConfig& config, const ChainStorage& storage, const std::shared_ptr& block_with_hash, const Bundles& bundles, std::optional opt_timeout, const AccountsOverrides& accounts_overrides, std::optional txn_id, boost::asio::any_io_executor& this_executor) { CallManyResult result; const auto& block = block_with_hash->block; auto state = execution::StateFactory{transaction_}.make(this_executor, storage, txn_id); EVMExecutor executor{block, config, workers_, std::make_shared(*state, accounts_overrides)}; uint64_t timeout = opt_timeout.value_or(5000); const auto start_time = clock_time::now(); // Don't call reserve here to preallocate result.results - since json value is dynamic it doesn't know yet how much it should allocate! // -> Don't uncomment this line result.results.reserve(bundles.size()); for (const auto& bundle : bundles) { const auto& block_override = bundle.block_override; // creates a block copy where overrides few values auto block_with_hash_shared_copy = std::make_shared(); *block_with_hash_shared_copy = *block_with_hash; rpc::Block block_context{{block_with_hash_shared_copy}}; if (block_override.block_num) { block_context.block_with_hash->block.header.number = block_override.block_num.value(); } if (block_override.coin_base) { block_context.block_with_hash->block.header.beneficiary = block_override.coin_base.value(); } if (block_override.timestamp) { block_context.block_with_hash->block.header.timestamp = block_override.timestamp.value(); } if (block_override.difficulty) { block_context.block_with_hash->block.header.difficulty = block_override.difficulty.value(); } if (block_override.gas_limit) { block_context.block_with_hash->block.header.gas_limit = block_override.gas_limit.value(); } if (block_override.base_fee) { block_context.block_with_hash->block.header.base_fee_per_gas = block_override.base_fee; } std::vector results; // Don't call reserve here to preallocate result.results - since json value is dynamic it doesn't know yet how much it should allocate! // -> Don't uncomment this line result.results.reserve(bundle.transactions.size()); for (const auto& call : bundle.transactions) { silkworm::Transaction txn{call.to_transaction()}; auto call_execution_result = executor.call(txn); if (call_execution_result.pre_check_error) { result.error = call_execution_result.pre_check_error; return result; } if ((clock_time::since(start_time) / 1000000) > timeout) { std::ostringstream oss; oss << "execution aborted (timeout = " << static_cast(timeout) / 1000.0 << "s)"; result.error = oss.str(); return result; } nlohmann::json reply; if (call_execution_result.status_code == evmc_status_code::EVMC_SUCCESS) { if (rpc::compatibility::is_erigon_json_api_compatibility_required()) { reply["value"] = silkworm::to_hex(call_execution_result.data); } else { reply["value"] = "0x" + silkworm::to_hex(call_execution_result.data); } } else { const auto error_message = call_execution_result.error_message(); if (call_execution_result.data.empty()) { reply["error"] = error_message; } else if (rpc::compatibility::is_erigon_json_api_compatibility_required()) { reply["error"] = nlohmann::json::object(); } else { RevertError revert_error{{3, error_message}, call_execution_result.data}; reply = revert_error; } } results.push_back(reply); } result.results.push_back(results); } return result; } Task CallExecutor::execute( const Bundles& bundles, const SimulationContext& context, const AccountsOverrides& accounts_overrides, std::optional timeout) { const auto chain_storage{transaction_.make_storage()}; uint16_t count{0}; bool empty = true; for (const auto& bundle : bundles) { SILK_DEBUG << "bundle[" << count++ << "]: " << bundle; if (!bundle.transactions.empty()) { empty = false; } } CallManyResult result; if (empty) { result.error = "empty all bundles transactions"; co_return result; } const auto chain_config = co_await chain_storage->read_chain_config(); const auto block_with_hash = co_await block_reader_.read_block_by_block_num_or_hash(block_cache_, context.block_num); if (!block_with_hash) { throw std::invalid_argument("read_block_by_block_num_or_hash: block not found"); } auto this_executor = co_await boost::asio::this_coro::executor; std::optional txn_id; if (!co_await block_reader_.is_latest_block_num(block_with_hash->block.header.number)) { const uint32_t transaction_index = context.transaction_index == -1 ? static_cast(block_with_hash->block.transactions.size()) : static_cast(context.transaction_index); txn_id = co_await transaction_.user_txn_id_at(block_with_hash->block.header.number, transaction_index); } result = co_await async_task(workers_.executor(), [&]() -> CallManyResult { return executes_all_bundles(chain_config, *chain_storage, block_with_hash, bundles, timeout, accounts_overrides, txn_id, this_executor); }); co_return result; } } // namespace silkworm::rpc::call ================================================ FILE: silkworm/rpc/core/call_many.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::call { struct CallManyResult { std::optional error{std::nullopt}; std::vector> results; }; class CallExecutor { public: CallExecutor( db::kv::api::Transaction& transaction, BlockCache& block_cache, WorkerPool& workers, const BlockReader& block_reader) : transaction_(transaction), block_cache_(block_cache), workers_{workers}, block_reader_{block_reader} {} virtual ~CallExecutor() = default; CallExecutor(const CallExecutor&) = delete; CallExecutor& operator=(const CallExecutor&) = delete; Task execute( const Bundles& bundles, const SimulationContext& context, const AccountsOverrides& accounts_overrides, std::optional timeout); CallManyResult executes_all_bundles(const silkworm::ChainConfig& config, const ChainStorage& storage, const std::shared_ptr& block_with_hash, const Bundles& bundles, std::optional opt_timeout, const AccountsOverrides& accounts_overrides, std::optional txn_id, boost::asio::any_io_executor& executor); private: db::kv::api::Transaction& transaction_; BlockCache& block_cache_; WorkerPool& workers_; const BlockReader& block_reader_; }; } // namespace silkworm::rpc::call ================================================ FILE: silkworm/rpc/core/estimate_gas_oracle.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "estimate_gas_oracle.hpp" #include #include #include #include #include namespace silkworm::rpc { Task EstimateGasOracle::estimate_gas(const Call& call, const silkworm::Block& block, std::optional txn_id) { SILK_DEBUG << "EstimateGasOracle::estimate_gas called"; uint64_t hi = 0, lo = 0; if (call.gas.value_or(0) >= kTxGas) { SILK_DEBUG << "Set gas limit using call args: " << call.gas.value_or(0); hi = call.gas.value(); } else { hi = block.header.gas_limit; SILK_DEBUG << "Set gas limit using block: " << block.header.gas_limit; } if (hi > kGasCap) { SILK_WARN << "caller gas above allowance, capping: requested " << hi << ", cap " << kGasCap; hi = kGasCap; } std::optional gas_price = call.gas_price; if (gas_price && gas_price != 0) { evmc::address from = call.from.value_or(evmc::address{0}); std::optional account{co_await account_reader_(from, txn_id)}; intx::uint256 balance = account->balance; SILK_DEBUG << "balance for address " << from << ": 0x" << intx::hex(balance); if (call.value.value_or(0) > balance) { // TODO(sixtysixter) what is the right error code? throw EstimateGasException{-32000, "insufficient funds for transfer"}; } auto available = balance - call.value.value_or(0); auto allowance = available / *gas_price; SILK_DEBUG << "allowance: " << allowance << ", available: 0x" << intx::hex(available) << ", balance: 0x" << intx::hex(balance); if (hi > allowance) { SILK_WARN << "gas estimation capped by limited funds: original " << hi << ", balance 0x" << intx::hex(balance) << ", sent " << intx::hex(call.value.value_or(0)) << ", gasprice " << intx::hex(*gas_price) << ", allowance " << allowance; hi = uint64_t{allowance}; } } auto this_executor = co_await boost::asio::this_coro::executor; execution::StateFactory state_factory{transaction_}; auto exec_result = co_await async_task(workers_.executor(), [&]() -> ExecutionResult { auto state = state_factory.make(this_executor, storage_, txn_id); ExecutionResult result{evmc_status_code::EVMC_SUCCESS}; silkworm::Transaction transaction{call.to_transaction()}; auto state_overrides = std::make_shared(*state, accounts_overrides_); EVMExecutor executor{block, config_, workers_, state_overrides}; // First try with highest gas possible transaction.gas_limit = hi; result = try_execution(executor, transaction); if (!result.success()) { return result; } // Assuming a contract can freely run all the instructions, we have // the true amount of gas it wants to consume to execute fully. // We want to ensure that the gas used doesn't fall below this auto true_gas = result.gas_used.value_or(0); uint64_t refund = result.gas_refund.value_or(0); lo = std::max(true_gas + refund - 1, kTxGas - 1); SILK_DEBUG << "hi: " << hi << ", lo: " << lo; while (lo + 1 < hi) { state_overrides = std::make_shared(*state, accounts_overrides_); EVMExecutor curr_executor{block, config_, workers_, state_overrides}; auto mid = (hi + lo) / 2; transaction.gas_limit = mid; result = try_execution(curr_executor, transaction); if (result.pre_check_error_code == PreCheckErrorCode::kIntrinsicGasTooLow || result.status_code != evmc_status_code::EVMC_SUCCESS || result.gas_used.value_or(0) < true_gas) { lo = mid; } else { hi = mid; } } result.status_code = evmc_status_code::EVMC_SUCCESS; SILK_DEBUG << "EstimateGasOracle::estimate_gas returns " << hi; return result; }); if (!exec_result.success()) { if (exec_result.status_code == evmc_status_code::EVMC_OUT_OF_GAS) { std::string error_msg = "gas required exceeds allowance (" + std::to_string(hi) + ")"; throw EstimateGasException{-32000, error_msg}; } throw_exception(exec_result); } co_return hi; } ExecutionResult EstimateGasOracle::try_execution(EVMExecutor& executor, const silkworm::Transaction& transaction) { return executor.call(transaction); } void EstimateGasOracle::throw_exception(ExecutionResult& result) { if (result.pre_check_error) { SILK_DEBUG << "result error " << result.pre_check_error.value(); throw EstimateGasException{-32000, *result.pre_check_error}; } auto error_message = result.error_message(); SILK_DEBUG << "result message: " << error_message << ", code " << *result.status_code; if (result.data.empty()) { throw EstimateGasException{-32000, error_message}; } throw EstimateGasException{3, error_message, result.data}; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/estimate_gas_oracle.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { inline constexpr std::uint64_t kTxGas = 21'000; inline constexpr std::uint64_t kGasCap = 50'000'000; using AccountReader = std::function>(const evmc::address&, std::optional txn_id)>; struct EstimateGasException : public std::exception { public: EstimateGasException(int64_t error_code, std::string message) : error_code_{error_code}, message_{std::move(message)}, data_{} {} EstimateGasException(int64_t error_code, std::string message, silkworm::Bytes data) : error_code_{error_code}, message_{std::move(message)}, data_{std::move(data)} {} ~EstimateGasException() noexcept override = default; int64_t error_code() const { return error_code_; } const std::string& message() const { return message_; } const silkworm::Bytes& data() const { return data_; } const char* what() const noexcept override { return message_.c_str(); } private: int64_t error_code_; std::string message_; silkworm::Bytes data_; }; class EstimateGasOracle { public: explicit EstimateGasOracle(const AccountReader& account_reader, const silkworm::ChainConfig& config, WorkerPool& workers, db::kv::api::Transaction& tx, const ChainStorage& chain_storage, AccountsOverrides& accounts_overrides) : account_reader_{account_reader}, config_{config}, workers_{workers}, transaction_{tx}, storage_{chain_storage}, accounts_overrides_{accounts_overrides} {} virtual ~EstimateGasOracle() = default; EstimateGasOracle(const EstimateGasOracle&) = delete; EstimateGasOracle& operator=(const EstimateGasOracle&) = delete; Task estimate_gas(const Call& call, const silkworm::Block& latest_block, std::optional txn_id); protected: virtual ExecutionResult try_execution(EVMExecutor& executor, const silkworm::Transaction& transaction); private: void throw_exception(ExecutionResult& result); const AccountReader& account_reader_; const silkworm::ChainConfig& config_; WorkerPool& workers_; db::kv::api::Transaction& transaction_; const ChainStorage& storage_; AccountsOverrides& accounts_overrides_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/estimate_gas_oracle_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "estimate_gas_oracle.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { class RemoteDatabaseTest : public db::test_util::KVTestBase { public: db::kv::api::CoherentStateCache state_cache; }; using testing::_; using testing::Return; TEST_CASE("EstimateGasException") { SECTION("EstimateGasException(int64_t, std::string const&)") { static constexpr char kErrorMessage[] = "insufficient funds for transfer"; constexpr int64_t kErrorCode = -1; EstimateGasException ex{kErrorCode, kErrorMessage}; CHECK(ex.error_code() == kErrorCode); CHECK(ex.message() == kErrorMessage); CHECK(std::strcmp(ex.what(), kErrorMessage) == 0); } SECTION("EstimateGasException(int64_t, std::string const&, silkworm::Bytes const&)") { static constexpr char kErrorMessage[] = "execution failed"; constexpr int64_t kErrorCode = 3; const silkworm::Bytes data{*silkworm::from_hex("0x00")}; EstimateGasException ex{kErrorCode, kErrorMessage, data}; CHECK(ex.error_code() == kErrorCode); CHECK(ex.message() == kErrorMessage); CHECK(ex.data() == data); CHECK(std::strcmp(ex.what(), kErrorMessage) == 0); } } TEST_CASE("estimate gas") { WorkerPool pool{1}; WorkerPool workers{1}; intx::uint256 balance{1'000'000'000}; silkworm::Account account{0, balance}; AccountReader account_reader = [&account](const evmc::address& /*address*/, std::optional /* txn_id */) -> Task> { co_return account; }; Call call; silkworm::Block block; block.header.gas_limit = kTxGas * 2; const silkworm::ChainConfig& config{kMainnetConfig}; RemoteDatabaseTest remote_db_test; test::BackEndMock backend; db::chain::Providers providers = ethdb::kv::make_backend_providers(&backend); auto tx = std::make_unique(remote_db_test.stub(), remote_db_test.grpc_context(), &remote_db_test.state_cache, providers); const db::chain::RemoteChainStorage storage{*tx, std::move(providers)}; AccountsOverrides accounts_overrides; MockEstimateGasOracle estimate_gas_oracle{account_reader, config, workers, *tx, storage, accounts_overrides}; SECTION("Call empty, always fails but success in first step") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(16) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0xa40e); } SECTION("Call empty, always succeeds") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(16).WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0); } SECTION("Call empty, fails first call") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; try { EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(1).WillOnce(Return(expect_result_fail)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); result.get(); CHECK(false); } catch (const silkworm::rpc::EstimateGasException&) { CHECK(true); } catch (const std::exception&) { CHECK(false); } catch (...) { CHECK(false); } } SECTION("Call empty, alternatively succeeds and fails") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(17) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillRepeatedly(Return(expect_result_fail)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0x6d61); } SECTION("Call empty, alternatively succeeds and fails with intrinsic") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail_pre_check{ .pre_check_error = "intrinsic ", .pre_check_error_code = PreCheckErrorCode::kIntrinsicGasTooLow}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; try { EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(16) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail_pre_check)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); result.get(); CHECK(false); } catch (const silkworm::rpc::EstimateGasException&) { CHECK(true); } catch (const std::exception&) { CHECK(false); } catch (...) { CHECK(false); } } SECTION("Call with gas, always fails but succes first and last step") { call.gas = kTxGas * 4; ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(17) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0x1481e); } SECTION("Call with gas, always succeeds") { call.gas = kTxGas * 4; ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(17) .WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0); } SECTION("Call with gas_price, gas not capped") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; call.gas = kTxGas * 2; call.gas_price = intx::uint256{10'000}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(16) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0x4ce); } SECTION("Call with gas_price, gas capped") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; call.gas = kTxGas * 2; call.gas_price = intx::uint256{40'000}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(16) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0x2717); } SECTION("Call with gas_price and value, gas not capped") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; call.gas = kTxGas * 2; call.gas_price = intx::uint256{10'000}; call.value = intx::uint256{500'000'000}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(16) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0x5205); } SECTION("Call with gas_price and value, gas capped") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; call.gas = kTxGas * 2; call.gas_price = intx::uint256{20'000}; call.value = intx::uint256{500'000'000}; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(16) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_ok)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillOnce(Return(expect_result_fail)) .WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0x30d2); } SECTION("Call gas above allowance, always succeeds, gas capped") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; call.gas = kGasCap * 2; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(26).WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0); } SECTION("Call gas below minimum, always succeeds") { ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS}; call.gas = kTxGas / 2; EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(16).WillRepeatedly(Return(expect_result_ok)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); const intx::uint256& estimate_gas = result.get(); CHECK(estimate_gas == 0); } SECTION("Call with too high value, exception") { ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; call.value = intx::uint256{2'000'000'000}; try { EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(1).WillRepeatedly(Return(expect_result_fail)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); result.get(); CHECK(false); } catch (const silkworm::rpc::EstimateGasException&) { CHECK(true); } catch (const std::exception&) { CHECK(false); } catch (...) { CHECK(false); } } SECTION("Call fail, try exception") { ExecutionResult expect_result_fail_pre_check{ .pre_check_error = "insufficient funds", .pre_check_error_code = PreCheckErrorCode::kInsufficientFunds}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS}; call.gas = kTxGas * 2; call.gas_price = intx::uint256{20'000}; call.value = intx::uint256{500'000'000}; try { EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(1) .WillOnce(Return(expect_result_fail)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); result.get(); CHECK(false); } catch (const silkworm::rpc::EstimateGasException&) { CHECK(true); } catch (const std::exception&) { CHECK(false); } catch (...) { CHECK(false); } } SECTION("Call fail, try exception with data") { auto data = *silkworm::from_hex("2ac3c1d3e24b45c6c310534bc2dd84b5ed576335"); ExecutionResult expect_result_fail_pre_check{ .pre_check_error = "insufficient funds", .pre_check_error_code = PreCheckErrorCode::kInsufficientFunds}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS, .data = data}; call.gas = kTxGas * 2; call.gas_price = intx::uint256{20'000}; call.value = intx::uint256{500'000'000}; try { EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(1) .WillOnce(Return(expect_result_fail)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); result.get(); CHECK(false); } catch (const silkworm::rpc::EstimateGasException&) { CHECK(true); } catch (const std::exception&) { CHECK(false); } catch (...) { CHECK(false); } } SECTION("Call fail-EVMC_INVALID_INSTRUCTION, try exception") { ExecutionResult expect_result_fail_pre_check{ .pre_check_error = "insufficient funds", .pre_check_error_code = PreCheckErrorCode::kInsufficientFunds}; ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_INVALID_INSTRUCTION}; call.gas = kTxGas * 2; call.gas_price = intx::uint256{20'000}; call.value = intx::uint256{500'000'000}; try { EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)) .Times(1) .WillOnce(Return(expect_result_fail)); auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future); result.get(); CHECK(false); } catch (const silkworm::rpc::EstimateGasException&) { CHECK(true); } catch (const std::exception&) { CHECK(false); } catch (...) { CHECK(false); } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/evm_access_list_tracer.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm_access_list_tracer.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { static constexpr size_t kTxAccessListStorageKeyGas = 1900; // per storage key specified in EIP 2930 access list static constexpr size_t kTxAccessListAddressGas = 2400; // per address specified in EIP 2930 access list void AccessListTracer::on_instruction_start(uint32_t pc, const intx::uint256* stack_top, const int stack_height, int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept { SILKWORM_ASSERT(execution_state.msg); evmc::address recipient(execution_state.msg->recipient); const auto opcode = execution_state.original_code[pc]; SILK_DEBUG << "on_instruction_start:" << " pc: " << std::dec << pc << " opcode: 0x" << std::hex << evmc::hex(opcode) << " recipient: " << recipient << " execution_state: {" << " gas_left: " << std::dec << gas << " status: " << execution_state.status << " msg.gas: " << std::dec << execution_state.msg->gas << " msg.depth: " << std::dec << execution_state.msg->depth << "}"; if (is_storage_opcode(opcode) && stack_height >= 1) { evmc::bytes32 address; intx::be::store(address.bytes, stack_top[0]); if (!exclude(recipient, execution_state.rev)) { add_storage(recipient, address); if (!is_created_contract(recipient)) { use_address_on_old_contract(recipient); } } } else if (is_call_opcode(opcode) && stack_height >= 5) { evmc::address address; intx::be::trunc(address.bytes, stack_top[-1]); if (!exclude(address, execution_state.rev)) { add_address(address); if (!is_created_contract(address)) { use_address_on_old_contract(address); } } } else if (is_contract_opcode(opcode) && stack_height >= 1) { evmc::address address; intx::be::trunc(address.bytes, stack_top[0]); if (!exclude(address, execution_state.rev)) { add_address(address); if (!is_created_contract(address)) { use_address_on_old_contract(address); } } } else if (opcode == evmc_opcode::OP_CREATE) { const uint64_t nonce{intra_block_state.get_nonce(execution_state.msg->recipient)}; const auto& contract_address{create_address(execution_state.msg->recipient, nonce)}; add_contract(contract_address); } else if (opcode == evmc_opcode::OP_CREATE2) { if (stack_height < 4) { return; // Invariant break for current implementation of OP_CREATE2, let's handle this gracefully. } const auto init_code_offset = static_cast(stack_top[-1]); if (init_code_offset >= execution_state.memory.size()) { return; // Invariant break for current implementation of OP_CREATE2, let's handle this gracefully. } const auto init_code_size = static_cast(stack_top[-2]); const evmc::bytes32 salt2{intx::be::store(stack_top[-3])}; auto init_code_hash{ init_code_size > 0 ? ethash::keccak256(&execution_state.memory.data()[init_code_offset], init_code_size) : ethash_hash256{}}; const auto& contract_address{create2_address(execution_state.msg->recipient, salt2, init_code_hash.bytes)}; add_contract(contract_address); } } inline bool AccessListTracer::is_storage_opcode(const int opcode) { return (opcode == evmc_opcode::OP_SLOAD || opcode == evmc_opcode::OP_SSTORE); } inline bool AccessListTracer::is_contract_opcode(const int opcode) { return (opcode == evmc_opcode::OP_EXTCODECOPY || opcode == evmc_opcode::OP_EXTCODEHASH || opcode == evmc_opcode::OP_EXTCODESIZE || opcode == evmc_opcode::OP_BALANCE || opcode == evmc_opcode::OP_SELFDESTRUCT); } inline bool AccessListTracer::is_call_opcode(const int opcode) { return (opcode == evmc_opcode::OP_DELEGATECALL || opcode == evmc_opcode::OP_CALL || opcode == evmc_opcode::OP_STATICCALL || opcode == evmc_opcode::OP_CALLCODE); } inline bool AccessListTracer::exclude(const evmc::address& address, evmc_revision rev) { return (precompile::is_precompile(address, rev)); } void AccessListTracer::add_storage(const evmc::address& address, const evmc::bytes32& storage) { SILK_TRACE << "add_storage:" << address << " storage: " << to_hex(storage); for (size_t i{0}; i < access_list_.size(); ++i) { if (access_list_[i].account == address) { for (const auto& storage_key : access_list_[i].storage_keys) { if (storage_key == storage) { return; } } access_list_[i].storage_keys.push_back(storage); return; } } silkworm::AccessListEntry item; item.account = address; item.storage_keys.push_back(storage); access_list_.push_back(item); } void AccessListTracer::add_address(const evmc::address& address) { SILK_TRACE << "add_address:" << address; for (size_t i{0}; i < access_list_.size(); ++i) { if (access_list_[i].account == address) { return; } } silkworm::AccessListEntry item; item.account = address; access_list_.push_back(std::move(item)); } void AccessListTracer::dump(const std::string& user_string, const AccessList& acl) { std::cout << "Dump: " << user_string << "\n"; for (size_t i{0}; i < acl.size(); ++i) { std::cout << "Address: " << acl[i].account << "\n"; for (size_t z{0}; z < acl[i].storage_keys.size(); ++z) { std::cout << "-> StorageKeys: " << to_hex(acl[i].storage_keys[z]) << "\n"; } } std::cout << "---------\n"; } bool AccessListTracer::compare(const AccessList& acl1, const AccessList& acl2) { if (acl1.size() != acl2.size()) { return false; } for (size_t i{0}; i < acl1.size(); ++i) { bool match_address = false; for (size_t j{0}; j < acl2.size(); ++j) { if (acl2[j].account == acl1[i].account) { match_address = true; if (acl2[j].storage_keys.size() != acl1[i].storage_keys.size()) { return false; } bool match_storage = false; for (size_t z{0}; z < acl1[i].storage_keys.size(); ++z) { for (size_t t{0}; t < acl2[j].storage_keys.size(); ++t) { if (acl2[j].storage_keys[t] == acl1[i].storage_keys[z]) { match_storage = true; break; } } if (!match_storage) { return false; } } break; } } if (!match_address) { return false; } } return true; } bool AccessListTracer::is_created_contract(const evmc::address& address) { return created_contracts_.find(address) != created_contracts_.end(); } void AccessListTracer::add_contract(const evmc::address& address) { if (created_contracts_.find(address) != created_contracts_.end()) { created_contracts_[address] = true; } } void AccessListTracer::use_address_on_old_contract(const evmc::address& address) { if (used_before_creation_.find(address) != used_before_creation_.end()) { used_before_creation_[address] = true; } } // some addresses (like sender, recipient, block producer, and created contracts) // are considered warm already, so we can save by adding these to the access list // only if we are adding a lot of their respective storage slots as well void AccessListTracer::optimize_gas(const evmc::address& from, const evmc::address& to, const evmc::address& coinbase) { optimize_warm_address_in_access_list(from); optimize_warm_address_in_access_list(to); optimize_warm_address_in_access_list(coinbase); for (const auto& [address, _] : created_contracts_) { if (!used_before_creation_.contains(address)) { optimize_warm_address_in_access_list(address); } } } void AccessListTracer::optimize_warm_address_in_access_list(const evmc::address& address) { for (auto it = access_list_.begin(); it != access_list_.end(); ++it) { if (it->account == address) { // https://eips.ethereum.org/EIPS/eip-2930#charging-less-for-accesses-in-the-access-list size_t access_list_saving_per_slot = evmone::instr::cold_sload_cost - evmone::instr::warm_storage_read_cost - kTxAccessListStorageKeyGas; if (access_list_saving_per_slot * it->storage_keys.size() <= kTxAccessListAddressGas) { access_list_.erase(it); return; } } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/evm_access_list_tracer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc { class AccessListTracer : public silkworm::EvmTracer { public: AccessListTracer() = default; AccessListTracer(const AccessListTracer&) = delete; AccessListTracer& operator=(const AccessListTracer&) = delete; const AccessList& get_access_list() { return access_list_; } void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept override; void reset_access_list() { access_list_.clear(); } void optimize_gas(const evmc::address& from, const evmc::address& to, const evmc::address& coinbase); static void dump(const std::string& user_string, const AccessList& acl); static bool compare(const AccessList& acl1, const AccessList& acl2); private: static inline bool exclude(const evmc::address& address, evmc_revision rev); static inline bool is_storage_opcode(int opcode); static inline bool is_contract_opcode(int opcode); static inline bool is_call_opcode(int opcode); void add_storage(const evmc::address& address, const evmc::bytes32& storage); void add_address(const evmc::address& address); bool is_created_contract(const evmc::address& address); void add_contract(const evmc::address& address); void use_address_on_old_contract(const evmc::address& address); void optimize_warm_address_in_access_list(const evmc::address& address); std::map created_contracts_; std::map used_before_creation_; AccessList access_list_; }; inline bool operator!=(const AccessList& acl1, const AccessList& acl2) { return !AccessListTracer::compare(acl1, acl2); } inline bool operator==(const AccessList& acl1, const AccessList& acl2) { return AccessListTracer::compare(acl1, acl2); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/evm_debug.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm_debug.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::debug { void from_json(const nlohmann::json& json, DebugConfig& tc) { json.at("disableStorage").get_to(tc.disable_storage); json.at("disableMemory").get_to(tc.disable_memory); json.at("disableStack").get_to(tc.disable_stack); if (json.count("NoRefunds") != 0) { json.at("NoRefunds").get_to(tc.no_refunds); } if (json.count("TxIndex") != 0) { const auto& json_idx = json.at("TxIndex"); if (json_idx.is_string()) { tc.tx_index = std::stol(json_idx.get(), nullptr, 16); } else { tc.tx_index = json_idx.get(); } } } std::ostream& operator<<(std::ostream& out, const DebugConfig& tc) { out << tc.to_string(); return out; } std::string DebugConfig::to_string() const { const auto& tc = *this; std::stringstream out; out << "disableStorage: " << std::boolalpha << tc.disable_storage; out << " disableMemory: " << std::boolalpha << tc.disable_memory; out << " disableStack: " << std::boolalpha << tc.disable_stack; out << " NoRefunds: " << std::boolalpha << tc.no_refunds; if (tc.tx_index) { out << " TxIndex: " << std::dec << tc.tx_index.value(); } return out.str(); } std::string uint256_to_hex(const evmone::uint256& x) { static constexpr std::string_view kHexDigits{"0123456789abcdef"}; std::string out(2 + 64, '\0'); char* dest = out.data(); *dest++ = '0'; *dest++ = 'x'; bool leading_zeros = true; const uint64_t* px = &x[0]; for (int i = 3; i >= 0; --i) { for (int shift = 60; shift >= 0; shift -= 4) { char hex_digit = kHexDigits[(px[i] >> shift) & 0xF]; if (hex_digit != '0' || !leading_zeros) { *dest++ = hex_digit; leading_zeros = false; } } } if (leading_zeros) { *dest++ = '0'; } out.resize(static_cast(dest - out.data())); return out; } static void output_stack(std::vector& vect, const evmone::uint256* stack, int stack_size) { vect.reserve(static_cast(stack_size)); for (int i = stack_size - 1; i >= 0; --i) { vect.push_back(uint256_to_hex(stack[-i])); } } void output_memory(std::vector& vect, const evmone::Memory& memory) { const auto data = memory.data(); vect.push_back(silkworm::to_hex({data, memory.size()})); } void insert_error(DebugLog& log, evmc_status_code status_code) { switch (status_code) { case evmc_status_code::EVMC_OUT_OF_GAS: log.error = "out of gas"; break; case evmc_status_code::EVMC_STACK_OVERFLOW: log.error = {"stack overflow (" + std::to_string(log.stack_height) + " <=> " + std::to_string(evmone::instr::traits[log.op_code].stack_height_required) + ")"}; break; case evmc_status_code::EVMC_STACK_UNDERFLOW: log.error = {"stack underflow (" + std::to_string(log.stack_height) + " <=> " + std::to_string(evmone::instr::traits[log.op_code].stack_height_required) + ")"}; break; case evmc_status_code::EVMC_UNDEFINED_INSTRUCTION: case evmc_status_code::EVMC_FAILURE: default: log.error = ""; break; } } void DebugTracer::on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept { last_opcode_ = std::nullopt; if (metrics_ == nullptr) { metrics_ = evmc_get_instruction_metrics_table(rev); } const evmc::address recipient(msg.recipient); const evmc::address sender(msg.sender); if (!logs_.empty()) { auto& log = logs_[logs_.size() - 1]; // it should be a CALL* opcode log.gas_cost = msg.gas_cost; } SILK_DEBUG << "on_execution_start:" << " rev: " << rev << " gas: " << std::dec << msg.gas << " depth: " << msg.depth << " recipient: " << recipient << " sender: " << sender << " code: " << silkworm::to_hex(code); } void DebugTracer::on_instruction_start(uint32_t pc, const intx::uint256* stack_top, const int stack_height, const int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept { SILKWORM_ASSERT(execution_state.msg); const evmc::address recipient(execution_state.msg->recipient); const evmc::address sender(execution_state.msg->sender); const auto opcode = execution_state.original_code[pc]; const auto opcode_name = get_opcode_name(opcode); last_opcode_ = opcode; SILK_DEBUG << "on_instruction_start:" << " pc: " << std::dec << pc << " opcode: 0x" << std::hex << evmc::hex(opcode) << " opcode_name: " << opcode_name.value_or("UNDEFINED") << " recipient: " << recipient << " sender: " << sender << " execution_state: {" << " gas_left: " << std::dec << gas << " status: " << execution_state.status << " msg.gas: " << std::dec << execution_state.msg->gas << " msg.depth: " << std::dec << execution_state.msg->depth << "}"; bool output_storage = false; if (!config_.disable_storage) { if (opcode == OP_SLOAD && stack_height >= 1) { evmc::bytes32 address; intx::be::store(address.bytes, stack_top[0]); const auto value = intra_block_state.get_current_storage(recipient, address); storage_[recipient][silkworm::to_hex(address)] = silkworm::to_hex(value); output_storage = true; } else if (opcode == OP_SSTORE && stack_height >= 2) { evmc::bytes32 address; intx::be::store(address.bytes, stack_top[0]); evmc::bytes32 value; intx::be::store(value.bytes, stack_top[-1]); storage_[recipient][silkworm::to_hex(address)] = silkworm::to_hex(value); output_storage = true; } } if (!logs_.empty()) { auto& log = logs_[logs_.size() - 1]; if (log.op_code == OP_RETURN || log.op_code == OP_STOP || log.op_code == OP_REVERT) { log.gas_cost = 0; } else if (log.depth == execution_state.msg->depth + 1) { log.gas_cost = execution_state.last_opcode_gas_cost; } } if (logs_.size() > 1) { auto& log = logs_.front(); write_log(log); logs_.erase(logs_.begin()); } DebugLog log; log.pc = pc; log.op_code = opcode; log.op_name = opcode_name; log.gas = gas; log.gas_cost = metrics_[opcode].gas_cost; log.depth = execution_state.msg->depth + 1; log.stack_height = stack_height; if (!config_.disable_stack) { output_stack(log.stack, stack_top, stack_height); } if (!config_.disable_memory) { output_memory(log.memory, execution_state.memory); } if (output_storage) { for (const auto& entry : storage_[recipient]) { log.storage[entry.first] = entry.second; } } insert_error(log, execution_state.status); logs_.push_back(log); } void DebugTracer::on_precompiled_run(const evmc_result& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { SILK_DEBUG << "DebugTracer::on_precompiled_run:" << " status: " << result.status_code; if (logs_.size() > 1) { flush_logs(); } } void DebugTracer::on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { if (!logs_.empty()) { auto& log = logs_[logs_.size() - 1]; insert_error(log, result.status_code); switch (result.status_code) { case evmc_status_code::EVMC_UNDEFINED_INSTRUCTION: case evmc_status_code::EVMC_INVALID_INSTRUCTION: case evmc_status_code::EVMC_STACK_OVERFLOW: case evmc_status_code::EVMC_STACK_UNDERFLOW: if (log.op_name) { log.gas_cost = result.gas_cost; } else { log.gas_cost = 0; } break; case evmc_status_code::EVMC_OUT_OF_GAS: if (log.op_code != OP_CALLCODE) { log.gas_cost = result.gas_cost; } break; case evmc_status_code::EVMC_REVERT: if (log.op_code == OP_REVERT) { log.gas_cost = result.gas_cost; } break; default: if (log.op_code == OP_CALL || log.op_code == OP_CALLCODE || log.op_code == OP_STATICCALL || log.op_code == OP_DELEGATECALL || log.op_code == OP_CREATE || log.op_code == OP_CREATE2) { log.gas_cost += result.gas_cost; } else { log.gas_cost = log.gas_cost; } break; } /* EVM WA: EVMONE add OP_STOP at the end of tx if not present but doesn't notify to the tracer. Add sw to add STOP to the op list */ if (result.status_code == EVMC_SUCCESS && last_opcode_ && last_opcode_ != OP_SELFDESTRUCT && last_opcode_ != OP_RETURN && last_opcode_ != OP_STOP) { DebugLog newlog; newlog.pc = log.pc + 1; newlog.op_name = get_opcode_name(OP_STOP); newlog.op_code = OP_STOP; newlog.gas = log.gas - log.gas_cost; newlog.gas_cost = 0; newlog.depth = log.depth; newlog.memory = log.memory; logs_.push_back(newlog); } } if (logs_.size() > 1) { flush_logs(); } SILK_DEBUG << "on_execution_end:" << " result.status_code: " << result.status_code << " gas_left: " << std::dec << result.gas_left << " gas_cost: " << std::dec << result.gas_cost; } void DebugTracer::flush_logs() { for (const auto& log : logs_) { write_log(log); } logs_.clear(); } void AccountTracer::on_execution_end(const evmc_result& /*result*/, const silkworm::IntraBlockState& intra_block_state) noexcept { nonce_ = intra_block_state.get_nonce(address_); balance_ = intra_block_state.get_balance(address_); code_hash_ = intra_block_state.get_code_hash(address_); code_ = intra_block_state.get_code(address_); } void DebugTracer::write_log(const DebugLog& log) { stream_.open_object(); stream_.write_field("depth", log.depth); stream_.write_field("gas", log.gas); stream_.write_field("gasCost", log.gas_cost); if (log.op_name) { stream_.write_field("op", log.op_name.value()); } else { stream_.write_field("op", "opcode " + get_opcode_hex(log.op_code) + " not defined"); } stream_.write_field("pc", log.pc); if (!config_.disable_stack) { stream_.write_field("stack"); stream_.open_array(); for (const auto& item : log.stack) { stream_.write_entry(item); } stream_.close_array(); } if (!config_.disable_memory) { stream_.write_field("memory"); stream_.open_array(); for (const auto& item : log.memory) { const size_t len = 64; const auto data = item.data(); for (size_t start = 0; start < item.size(); start += len) { stream_.write_entry({data + start, len}); } } stream_.close_array(); } if (!config_.disable_storage && !log.storage.empty()) { stream_.write_field("storage"); stream_.open_object(); for (const auto& entry : log.storage) { stream_.write_field(entry.first, entry.second); } stream_.close_object(); } if (!log.error.empty()) { stream_.write_field("error", log.error); } stream_.close_object(); } Task DebugExecutor::trace_block(json::Stream& stream, const ChainStorage& storage, BlockNum block_num) { const BlockReader reader{storage, tx_}; const auto block_with_hash = co_await reader.read_block_by_number(block_cache_, block_num); if (!block_with_hash) { co_return; } stream.write_field("result"); stream.open_array(); co_await execute(stream, storage, block_with_hash->block); stream.close_array(); co_return; } Task DebugExecutor::trace_block(json::Stream& stream, const ChainStorage& storage, const evmc::bytes32& block_hash) { const BlockReader reader{storage, tx_}; const auto block_with_hash = co_await reader.read_block_by_hash(block_cache_, block_hash); if (!block_with_hash) { co_return; } stream.write_field("result"); stream.open_array(); co_await execute(stream, storage, block_with_hash->block); stream.close_array(); co_return; } Task DebugExecutor::trace_call(json::Stream& stream, const BlockNumOrHash& block_num_or_hash, const ChainStorage& storage, const Call& call, bool is_latest_block) { const BlockReader reader{storage, tx_}; const auto block_with_hash = co_await reader.read_block_by_block_num_or_hash(block_cache_, block_num_or_hash); if (!block_with_hash) { co_return; } rpc::Transaction transaction{call.to_transaction()}; if (config_.tx_index) { const auto tx_index = static_cast(config_.tx_index.value()); if (tx_index > block_with_hash->block.transactions.size()) { std::ostringstream oss; oss << "TxIndex " << tx_index << " greater than #tnx in block " << block_num_or_hash; const Error error{-32000, oss.str()}; stream.write_json_field("error", error); co_return; } } const auto& block = block_with_hash->block; const auto block_num = block.header.number + (config_.tx_index ? 0 : 1); const auto index = config_.tx_index ? config_.tx_index.value() : 0; // trace_call semantics: we must execute the call from the state at the end of the given block, so we pass block.header.number + 1 co_await execute(stream, storage, block_num, block, transaction, index, is_latest_block); co_return; } Task DebugExecutor::trace_transaction(json::Stream& stream, const ChainStorage& storage, const evmc::bytes32& tx_hash) { const BlockReader reader{storage, tx_}; const auto tx_with_block = co_await reader.read_transaction_by_hash(block_cache_, tx_hash); if (!tx_with_block) { std::ostringstream oss; oss << "transaction " << silkworm::to_hex(tx_hash, true) << " not found"; const Error error{-32000, oss.str()}; stream.write_json_field("error", error); } else { const auto& block = tx_with_block->block_with_hash->block; const auto& transaction = tx_with_block->transaction; const auto block_num = block.header.number; // trace_transaction semantics: we must execute the txn from the state at the current block co_await execute(stream, storage, block_num, block, transaction, gsl::narrow(transaction.transaction_index)); } co_return; } Task DebugExecutor::trace_call_many(json::Stream& stream, const ChainStorage& storage, const Bundles& bundles, const SimulationContext& context, bool is_latest_block) { const BlockReader reader{storage, tx_}; const auto block_with_hash = co_await reader.read_block_by_block_num_or_hash(block_cache_, context.block_num); if (!block_with_hash) { co_return; } auto transaction_index = context.transaction_index; if (transaction_index == -1) { transaction_index = static_cast(block_with_hash->block.transactions.size()); } stream.write_field("result"); stream.open_array(); co_await execute(stream, storage, block_with_hash, bundles, transaction_index, is_latest_block); stream.close_array(); co_return; } Task DebugExecutor::execute(json::Stream& stream, const ChainStorage& storage, const silkworm::Block& block) { auto block_num = block.header.number; const auto& transactions = block.transactions; SILK_DEBUG << "execute: block_num: " << block_num << " #txns: " << transactions.size() << " config: " << config_; const auto chain_config = co_await storage.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; execution::StateFactory state_factory{tx_}; const auto txn_id = co_await tx_.user_txn_id_at(block_num); co_await async_task(workers_.executor(), [&]() -> void { auto state = state_factory.make(current_executor, storage, txn_id); EVMExecutor executor{block, chain_config, workers_, state}; bool refunds = !config_.no_refunds; for (std::uint64_t idx = 0; idx < transactions.size(); ++idx) { rpc::Transaction txn{block.transactions[idx]}; SILK_DEBUG << "processing transaction: idx: " << idx << " txn: " << txn; auto debug_tracer = std::make_shared(stream, config_); stream.open_object(); stream.write_field("result"); stream.open_object(); stream.write_field("structLogs"); stream.open_array(); Tracers tracers{debug_tracer}; const auto execution_result = executor.call(txn, tracers, refunds); debug_tracer->flush_logs(); stream.close_array(); stream.write_json_field("failed", !execution_result.success()); if (!execution_result.pre_check_error) { stream.write_field("gas", txn.gas_limit - execution_result.gas_left); stream.write_field("returnValue", silkworm::to_hex(execution_result.data)); } stream.close_object(); stream.write_field("txHash", txn.hash()); stream.close_object(); executor.reset(); } }); co_return; } // used by unit-test Task DebugExecutor::execute(json::Stream& stream, const ChainStorage& storage, const silkworm::Block& block, const Call& call) { rpc::Transaction transaction{call.to_transaction()}; auto transaction_index = static_cast(block.transactions.size()); co_await execute(stream, storage, block.header.number + 1, block, transaction, transaction_index); co_return; } Task DebugExecutor::execute( json::Stream& stream, const ChainStorage& storage, BlockNum block_num, const silkworm::Block& block, const Transaction& transaction, int32_t index, bool is_latest_block) { SILK_TRACE << "DebugExecutor::execute: " << " block_num: " << block_num << " transaction: {" << transaction << "}" << " index: " << std::dec << index << " config: " << config_; const auto chain_config = co_await storage.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; // We must do the execution at the state after the txn identified by the given index within the given block // at the state after the block identified by the given block_num std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx_.user_txn_id_at(block_num, static_cast(index)); } co_await async_task(workers_.executor(), [&]() { execution::StateFactory state_factory{tx_}; const auto state = state_factory.make(current_executor, storage, txn_id); EVMExecutor executor{block, chain_config, workers_, state}; auto debug_tracer = std::make_shared(stream, config_); stream.write_field("result"); stream.open_object(); stream.write_field("structLogs"); stream.open_array(); bool refunds = !config_.no_refunds; Tracers tracers{debug_tracer}; const auto execution_result = executor.call(transaction, tracers, refunds); debug_tracer->flush_logs(); stream.close_array(); SILK_DEBUG << "result error_code: " << execution_result.status_code.value_or(evmc_status_code::EVMC_SUCCESS) << ", message: " << execution_result.error_message(); if (!execution_result.pre_check_error) { stream.write_json_field("failed", !execution_result.success()); stream.write_field("gas", transaction.gas_limit - execution_result.gas_left); const auto status_code = execution_result.status_code.value_or(evmc_status_code::EVMC_SUCCESS); if (status_code == evmc_status_code::EVMC_SUCCESS || status_code == evmc_status_code::EVMC_REVERT) { stream.write_field("returnValue", silkworm::to_hex(execution_result.data)); } else { stream.write_field("returnValue", ""); } } stream.close_object(); if (execution_result.pre_check_error) { const Error error{-32000, "tracing failed: " + execution_result.pre_check_error.value()}; stream.write_json_field("error", error); } }); co_return; } Task DebugExecutor::execute( json::Stream& stream, const ChainStorage& storage, std::shared_ptr block_with_hash, const Bundles& bundles, int32_t transaction_index, bool is_latest_block) { const auto& block = block_with_hash->block; const auto& block_transactions = block.transactions; SILK_TRACE << "DebugExecutor::execute: " << " block number: " << block.header.number << " txns in block: " << block_transactions.size() << " bundles: [" << bundles << "]" << " transaction_index: " << std::dec << transaction_index << " config: " << config_; const auto chain_config = co_await storage.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; // We must do the execution at the state after the txn identified by transaction_with_block param in the same block // at the state of the block identified by the given block_num, i.e. at the start of the block (block_num) execution::StateFactory state_factory{tx_}; std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx_.user_txn_id_at(block.header.number, static_cast(transaction_index)); } co_await async_task(workers_.executor(), [&]() { auto state = state_factory.make(current_executor, storage, txn_id); EVMExecutor executor{block, chain_config, workers_, state}; for (const auto& bundle : bundles) { const auto& block_override = bundle.block_override; rpc::Block block_context{{block_with_hash}}; if (block_override.block_num) { block_context.block_with_hash->block.header.number = block_override.block_num.value(); } if (block_override.coin_base) { block_context.block_with_hash->block.header.beneficiary = block_override.coin_base.value(); } if (block_override.timestamp) { block_context.block_with_hash->block.header.timestamp = block_override.timestamp.value(); } if (block_override.difficulty) { block_context.block_with_hash->block.header.difficulty = block_override.difficulty.value(); } if (block_override.gas_limit) { block_context.block_with_hash->block.header.gas_limit = block_override.gas_limit.value(); } if (block_override.base_fee) { block_context.block_with_hash->block.header.base_fee_per_gas = block_override.base_fee; } stream.open_array(); bool refunds = !config_.no_refunds; for (const auto& call : bundle.transactions) { silkworm::Transaction txn{call.to_transaction()}; stream.open_object(); stream.write_field("structLogs"); stream.open_array(); auto debug_tracer = std::make_shared(stream, config_); Tracers tracers{debug_tracer}; const auto execution_result = executor.call(txn, tracers, refunds); debug_tracer->flush_logs(); stream.close_array(); SILK_DEBUG << "debug return: " << execution_result.error_message(); stream.write_json_field("failed", !execution_result.success()); if (!execution_result.pre_check_error) { stream.write_field("gas", txn.gas_limit - execution_result.gas_left); stream.write_field("returnValue", silkworm::to_hex(execution_result.data)); } stream.close_object(); } stream.close_array(); } }); co_return; } } // namespace silkworm::rpc::debug ================================================ FILE: silkworm/rpc/core/evm_debug.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "block_reader.hpp" namespace silkworm::rpc::debug { using namespace db::chain; struct DebugConfig { bool disable_storage{false}; bool disable_memory{false}; bool disable_stack{false}; bool no_refunds{false}; std::optional tx_index; std::string to_string() const; }; std::string uint256_to_hex(const evmone::uint256& x); std::string bytes_to_hex(evmc::bytes_view bv); void from_json(const nlohmann::json& json, DebugConfig& tc); std::ostream& operator<<(std::ostream& out, const DebugConfig& tc); using Storage = std::map; struct DebugLog { std::uint32_t pc{0}; unsigned char op_code{0}; std::optional op_name; std::int64_t gas{0}; std::int64_t gas_cost{0}; std::int32_t depth{0}; std::string error; int stack_height{0}; std::vector memory; std::vector stack; Storage storage; }; class DebugTracer : public EvmTracer { public: explicit DebugTracer(json::Stream& stream, const DebugConfig& config = {}) : stream_(stream), config_(config) {} DebugTracer(const DebugTracer&) = delete; DebugTracer& operator=(const DebugTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_precompiled_run(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; void flush_logs(); private: void write_log(const DebugLog& log); json::Stream& stream_; const DebugConfig& config_; std::vector logs_; std::map storage_; const evmc_instruction_metrics* metrics_ = nullptr; std::optional last_opcode_; }; class AccountTracer : public EvmTracer { public: explicit AccountTracer(const evmc::address& address) : address_{address} {} AccountTracer(const AccountTracer&) = delete; AccountTracer& operator=(const AccountTracer&) = delete; void on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; private: const evmc::address& address_; uint64_t nonce_{0}; intx::uint256 balance_; evmc::bytes32 code_hash_{kEmptyHash}; silkworm::Bytes code_; }; class DebugExecutor { public: explicit DebugExecutor( BlockCache& block_cache, WorkerPool& workers, db::kv::api::Transaction& tx, DebugConfig config = {}) : block_cache_(block_cache), workers_{workers}, tx_{tx}, config_{config} {} virtual ~DebugExecutor() = default; DebugExecutor(const DebugExecutor&) = delete; DebugExecutor& operator=(const DebugExecutor&) = delete; Task trace_block(json::Stream& stream, const ChainStorage& storage, BlockNum block_num); Task trace_block(json::Stream& stream, const ChainStorage& storage, const evmc::bytes32& block_hash); Task trace_call(json::Stream& stream, const BlockNumOrHash& block_num_or_hash, const ChainStorage& storage, const Call& call, bool is_latest_block); Task trace_transaction(json::Stream& stream, const ChainStorage& storage, const evmc::bytes32& tx_hash); Task trace_call_many(json::Stream& stream, const ChainStorage& storage, const Bundles& bundles, const SimulationContext& context, bool is_latest_block); protected: Task execute(json::Stream& stream, const ChainStorage& storage, const silkworm::Block& block, const Call& call); private: Task execute(json::Stream& stream, const ChainStorage& storage, const silkworm::Block& block); Task execute( json::Stream& stream, const ChainStorage& storage, BlockNum block_num, const silkworm::Block& block, const Transaction& transaction, int32_t index = -1, bool is_latest_block = false); Task execute( json::Stream& stream, const ChainStorage& storage, std::shared_ptr block_with_hash, const Bundles& bundles, int32_t transaction_index, bool is_latest_block = false); BlockCache& block_cache_; WorkerPool& workers_; db::kv::api::Transaction& tx_; DebugConfig config_; }; } // namespace silkworm::rpc::debug ================================================ FILE: silkworm/rpc/core/evm_debug_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm_debug.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::debug { using namespace silkworm::db; struct DebugExecutorTest : public test_util::ServiceContextTestBase { test::MockBlockCache cache; db::test_util::MockTransaction transaction; WorkerPool workers{1}; StringWriter writer{4096}; boost::asio::any_io_executor io_executor{ioc_.get_executor()}; json::Stream stream{io_executor, writer, /* request_id */ 0}; test::BackEndMock backend; RemoteChainStorage chain_storage{transaction, ethdb::kv::make_backend_providers(&backend)}; }; class TestDebugExecutor : DebugExecutor { public: explicit TestDebugExecutor( BlockCache& block_cache, WorkerPool& workers, kv::api::Transaction& tx, DebugConfig config = {}) : DebugExecutor(block_cache, workers, tx, config) {} ~TestDebugExecutor() override = default; TestDebugExecutor(const TestDebugExecutor&) = delete; TestDebugExecutor& operator=(const TestDebugExecutor&) = delete; Task exec(json::Stream& stream, const ChainStorage& storage, const silkworm::Block& block, const Call& call) { return DebugExecutor::execute(stream, storage, block, call); } }; #if !defined(SILKWORM_SANITIZE) && !defined(_WIN32) using testing::_; using testing::Invoke; using testing::InvokeWithoutArgs; using testing::Unused; using namespace evmc::literals; static const evmc::bytes32 kZeroHeaderHash{0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a_bytes32}; static const Bytes kConfigKey{kZeroHeaderHash.bytes, kHashLength}; static const Bytes kConfigValue{string_view_to_byte_view(kSepoliaConfig.to_json().dump())}; // NOLINT(cppcoreguidelines-interfaces-global-init) TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute precompiled") { static Bytes account_history_key1{*silkworm::from_hex("0a6bb546b9208cfab9e8fa2b9b2c042b18df7030")}; static Bytes account_history_key2{*silkworm::from_hex("0000000000000000000000000000000000000009")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value1{*silkworm::from_hex("010203ed03e820f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c92390105")}; SECTION("precompiled contract failure") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(10'336'007)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = true, .value = account_history_value1}; co_return rsp1; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = true, .value = Bytes{}}; co_return rsp1; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = true, .value = Bytes{}}; co_return rsp1; })); evmc::address blake2f_precompile{0x0000000000000000000000000000000000000009_address}; Call call; call.from = 0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address; call.to = blake2f_precompile; call.gas = 50'000; call.gas_price = 7; silkworm::Block block{}; block.header.number = 10'336'006; TestDebugExecutor executor{cache, workers, transaction}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed":true, "gas":50000, "returnValue":"", "structLogs":[] } })"_json); } } TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 1") { static Bytes account_history_key1{*silkworm::from_hex("e0a2bd4258d2768837baa26a28fe71dc079f84c7")}; static Bytes account_history_value1{*silkworm::from_hex("0203430b141e903194951083c424fd0000")}; static Bytes account_history_key2{*silkworm::from_hex("52728289eba496b6080d57d0250a90663a07e556")}; static Bytes account_history_key3{*silkworm::from_hex("0x0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("000944ed67f28fd50bb8e90000")}; SECTION("Call: failed with intrinsic gas too low") { EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, first_txn_num_in_block(_)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 50'000; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TestDebugExecutor executor{cache, workers, transaction}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "error": { "code": -32000, "message": "tracing failed: intrinsic gas too low: have 50000, want 53072" }, "result": { "structLogs": [] } })"_json); } SECTION("Call: full output") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TestDebugExecutor executor{cache, workers, transaction}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": false, "gas": 75178, "returnValue": "", "structLogs": [ { "depth": 1, "gas": 65864, "gasCost": 3, "memory": [], "op": "PUSH1", "pc": 0, "stack": [] }, { "depth": 1, "gas": 65861, "gasCost": 3, "memory": [], "op": "PUSH1", "pc": 2, "stack": [ "0x2a" ] }, { "depth": 1, "gas": 65858, "gasCost": 22100, "memory": [], "op": "SSTORE", "pc": 4, "stack": [ "0x2a", "0x0" ], "storage": { "0000000000000000000000000000000000000000000000000000000000000000": "000000000000000000000000000000000000000000000000000000000000002a" } }, { "depth": 1, "gas": 43758, "gasCost": 0, "memory": [], "op": "STOP", "pc": 5, "stack": [] } ] } })"_json); } SECTION("Call: no stack") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; DebugConfig config{false, false, true}; TestDebugExecutor executor{cache, workers, transaction, config}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": false, "gas": 75178, "returnValue": "", "structLogs": [ { "depth": 1, "gas": 65864, "gasCost": 3, "memory": [], "op": "PUSH1", "pc": 0 }, { "depth": 1, "gas": 65861, "gasCost": 3, "memory": [], "op": "PUSH1", "pc": 2 }, { "depth": 1, "gas": 65858, "gasCost": 22100, "memory": [], "op": "SSTORE", "pc": 4, "storage": { "0000000000000000000000000000000000000000000000000000000000000000": "000000000000000000000000000000000000000000000000000000000000002a" } }, { "depth": 1, "gas": 43758, "gasCost": 0, "memory": [], "op": "STOP", "pc": 5 } ] } })"_json); } SECTION("Call: no memory") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; DebugConfig config{false, true, false}; TestDebugExecutor executor{cache, workers, transaction, config}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": false, "gas": 75178, "returnValue": "", "structLogs": [ { "depth": 1, "gas": 65864, "gasCost": 3, "op": "PUSH1", "pc": 0, "stack": [] }, { "depth": 1, "gas": 65861, "gasCost": 3, "op": "PUSH1", "pc": 2, "stack": [ "0x2a" ] }, { "depth": 1, "gas": 65858, "gasCost": 22100, "op": "SSTORE", "pc": 4, "stack": [ "0x2a", "0x0" ], "storage": { "0000000000000000000000000000000000000000000000000000000000000000": "000000000000000000000000000000000000000000000000000000000000002a" } }, { "depth": 1, "gas": 43758, "gasCost": 0, "op": "STOP", "pc": 5, "stack": [] } ] } })"_json); } SECTION("Call: no storage") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; DebugConfig config{true, false, false}; TestDebugExecutor executor{cache, workers, transaction, config}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": false, "gas": 75178, "returnValue": "", "structLogs": [ { "depth": 1, "gas": 65864, "gasCost": 3, "memory": [], "op": "PUSH1", "pc": 0, "stack": [] }, { "depth": 1, "gas": 65861, "gasCost": 3, "memory": [], "op": "PUSH1", "pc": 2, "stack": [ "0x2a" ] }, { "depth": 1, "gas": 65858, "gasCost": 22100, "memory": [], "op": "SSTORE", "pc": 4, "stack": [ "0x2a", "0x0" ] }, { "depth": 1, "gas": 43758, "gasCost": 0, "memory": [], "op": "STOP", "pc": 5, "stack": [] } ] } })"_json); } SECTION("Call: no stack, memory and storage") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; DebugConfig config{true, true, true}; TestDebugExecutor executor{cache, workers, transaction, config}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": false, "gas": 75178, "returnValue": "", "structLogs": [ { "depth": 1, "gas": 65864, "gasCost": 3, "op": "PUSH1", "pc": 0 }, { "depth": 1, "gas": 65861, "gasCost": 3, "op": "PUSH1", "pc": 2 }, { "depth": 1, "gas": 65858, "gasCost": 22100, "op": "SSTORE", "pc": 4 }, { "depth": 1, "gas": 43758, "gasCost": 0, "op": "STOP", "pc": 5 } ] } })"_json); } SECTION("Call with stream") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; DebugConfig config{true, true, true}; TestDebugExecutor executor{cache, workers, transaction, config}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": false, "gas": 75178, "returnValue": "", "structLogs": [ { "depth": 1, "gas": 65864, "gasCost": 3, "op": "PUSH1", "pc": 0 }, { "depth": 1, "gas": 65861, "gasCost": 3, "op": "PUSH1", "pc": 2 }, { "depth": 1, "gas": 65858, "gasCost": 22100, "op": "SSTORE", "pc": 4 }, { "depth": 1, "gas": 43758, "gasCost": 0, "op": "STOP", "pc": 5 } ] } })"_json); } } TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 2") { static Bytes account_history_key1{*silkworm::from_hex("8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9")}; static Bytes account_history_value1{*silkworm::from_hex("03038c330a01a098914888dc0516d20000")}; static Bytes account_history_key2{*silkworm::from_hex("5e1f0c9ddbe3cb57b80c933fab5151627d7966fa")}; static Bytes account_history_value2{*silkworm::from_hex("010408014219564ff26a000000")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("00094165832d46fa1082db0000")}; SECTION("Call: TO present") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(4'417'197)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value2}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 4'417'196; // 0x4366AC Call call; call.from = 0x8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9_address; call.to = 0x5e1f0c9ddbe3cb57b80c933fab5151627d7966fa_address; call.value = 50'000'000; call.gas = 30'000; call.gas_price = 1'000'000'000; call.data = *silkworm::from_hex("00"); silkworm::Block block{}; block.header.number = block_num; TestDebugExecutor executor{cache, workers, transaction}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": false, "gas": 21004, "returnValue": "", "structLogs": [] } })"_json); } } TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call with error") { static Bytes account_history_key1{*silkworm::from_hex("578f0a154b23be77fc2033197fbc775637648ad4")}; static Bytes account_history_value1{*silkworm::from_hex("012f090207fbc719f215d7050000")}; static Bytes account_history_key2{*silkworm::from_hex("6951c35e335fa18c97cb207119133cd8009580cd")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("000944ed67f28fd50bb8e90000")}; db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillOnce(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0x578f0a154b23be77fc2033197fbc775637648ad4_address; call.value = 0; call.gas = 211'190; call.gas_price = 14; call.data = *silkworm::from_hex( "0x414bf3890000000000000000000000009d381f0b1637475f133c92d9b9fdc5493ae19b630000000000000000000000009b73fc19" "3bfa16abe18d1ea30734e4a6444a753f00000000000000000000000000000000000000000000000000000000000027100000000000" "00000000000000578f0a154b23be77fc2033197fbc775637648ad40000000000000000000000000000000000000000000000000000" "0000612ba19c00000000000000000000000000000000000000000001a784379d99db42000000000000000000000000000000000000" "00000000000002cdc48e6cca575707722c0000000000000000000000000000000000000000000000000000000000000000"); silkworm::Block block{}; block.header.number = block_num; TestDebugExecutor executor{cache, workers, transaction}; stream.open_object(); spawn_and_wait(executor.exec(stream, chain_storage, block, call)); stream.close_object(); spawn_and_wait(stream.close()); nlohmann::json json = nlohmann::json::parse(writer.get_content()); CHECK(json == R"({ "result": { "failed": true, "gas": 211190, "returnValue": "", "structLogs": [ { "depth": 1, "gas": 156082, "gasCost": 2, "memory": [], "op": "COINBASE", "pc": 0, "stack": [] }, { "depth": 1, "gas": 156080, "gasCost": 0, "memory": [], "op": "opcode 0x4b not defined", "pc": 1, "stack": [ "0x0" ] } ] } })"_json); } TEST_CASE_METHOD(DebugExecutorTest, "DebugConfig") { SECTION("json deserialization") { nlohmann::json json = R"({ "disableStorage": true, "disableMemory": false, "disableStack": true })"_json; DebugConfig config; from_json(json, config); CHECK(config.disable_storage == true); CHECK(config.disable_memory == false); CHECK(config.disable_stack == true); } SECTION("dump on stream") { DebugConfig config{true, false, true}; std::ostringstream os; os << config; CHECK(os.str() == "disableStorage: true disableMemory: false disableStack: true NoRefunds: false"); } } TEST_CASE("uint256_to_hex", "evmone::uint256") { SECTION("test 1") { evmone::uint256 v{0xB0A0}; const std::string intx_hex{"0x" + intx::to_string(v, 16)}; std::string hex{uint256_to_hex(v)}; CHECK(intx_hex == hex); } SECTION("test 2") { evmone::uint256 v{0xCB0A0}; const std::string intx_hex{"0x" + intx::to_string(v, 16)}; std::string hex{uint256_to_hex(v)}; CHECK(intx_hex == hex); } } #endif // !defined(SILKWORM_SANITIZE) && !defined(_WIN32) } // namespace silkworm::rpc::debug ================================================ FILE: silkworm/rpc/core/evm_executor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm_executor.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "silkworm/core/execution/processor.hpp" namespace silkworm::rpc { std::string ExecutionResult::error_message(bool full_error) const { if (pre_check_error) { return *pre_check_error; } if (status_code) { return silkworm::rpc::EVMExecutor::get_error_message(*status_code, data, full_error); } return ""; } static Bytes build_abi_selector(const std::string& signature) { const auto signature_hash = hash_of(string_view_to_byte_view(signature)); return {std::begin(signature_hash.bytes), std::begin(signature_hash.bytes) + 4}; } static std::optional decode_error_reason(const Bytes& error_data) { static const Bytes kRevertSelector = build_abi_selector("Error(string)"); static constexpr size_t kAbiStringOffsetSize{32}; if (error_data.size() < kRevertSelector.size() || error_data.substr(0, kRevertSelector.size()) != kRevertSelector) { return std::nullopt; } ByteView encoded_msg{error_data.data() + kRevertSelector.size(), error_data.size() - kRevertSelector.size()}; SILK_TRACE << "decode_error_reason size: " << encoded_msg.size() << " error_message: " << to_hex(encoded_msg); if (encoded_msg.size() < kAbiStringOffsetSize) { return std::nullopt; } const auto offset_uint256{intx::be::unsafe::load(encoded_msg.data())}; SILK_TRACE << "decode_error_reason offset_uint256: " << intx::to_string(offset_uint256); const auto offset = static_cast(offset_uint256); if (encoded_msg.size() < kAbiStringOffsetSize + offset) { return std::nullopt; } const uint64_t message_offset{kAbiStringOffsetSize + offset}; const auto length_uint256{intx::be::unsafe::load(encoded_msg.data() + offset)}; SILK_TRACE << "decode_error_reason length_uint256: " << intx::to_string(length_uint256); const auto length = static_cast(length_uint256); if (encoded_msg.size() < message_offset + length) { return std::nullopt; } return std::string{std::begin(encoded_msg) + message_offset, std::begin(encoded_msg) + message_offset + length}; } std::string EVMExecutor::get_error_message(int64_t error_code, const Bytes& error_data, bool full_error) { SILK_DEBUG << "EVMExecutor::get_error_message error_data: " << to_hex(error_data); std::string error_message; switch (error_code) { case evmc_status_code::EVMC_FAILURE: error_message = "execution failed"; break; case evmc_status_code::EVMC_REVERT: error_message = "execution reverted"; break; case evmc_status_code::EVMC_OUT_OF_GAS: error_message = "out of gas"; break; case evmc_status_code::EVMC_INVALID_INSTRUCTION: error_message = "invalid instruction"; break; case evmc_status_code::EVMC_UNDEFINED_INSTRUCTION: error_message = "invalid opcode"; break; case evmc_status_code::EVMC_STACK_OVERFLOW: error_message = "stack overflow"; break; case evmc_status_code::EVMC_STACK_UNDERFLOW: error_message = "stack underflow"; break; case evmc_status_code::EVMC_BAD_JUMP_DESTINATION: error_message = "invalid jump destination"; break; case evmc_status_code::EVMC_INVALID_MEMORY_ACCESS: error_message = "invalid memory access"; break; case evmc_status_code::EVMC_CALL_DEPTH_EXCEEDED: error_message = "call depth exceeded"; break; case evmc_status_code::EVMC_STATIC_MODE_VIOLATION: error_message = "static mode violation"; break; case evmc_status_code::EVMC_PRECOMPILE_FAILURE: error_message = "precompile failure"; break; case evmc_status_code::EVMC_CONTRACT_VALIDATION_FAILURE: error_message = "contract validation failure"; break; case evmc_status_code::EVMC_ARGUMENT_OUT_OF_RANGE: error_message = "argument out of range"; break; case evmc_status_code::EVMC_WASM_UNREACHABLE_INSTRUCTION: error_message = "wasm unreachable instruction"; break; case evmc_status_code::EVMC_WASM_TRAP: error_message = "wasm trap"; break; case evmc_status_code::EVMC_INSUFFICIENT_BALANCE: error_message = "insufficient balance"; break; case evmc_status_code::EVMC_INTERNAL_ERROR: error_message = "internal error"; break; case evmc_status_code::EVMC_REJECTED: error_message = "execution rejected"; break; case evmc_status_code::EVMC_OUT_OF_MEMORY: error_message = "out of memory"; break; default: error_message = "unknown error code"; } if (full_error) { const auto error_reason{decode_error_reason(error_data)}; if (error_reason) { error_message += ": " + *error_reason; } } SILK_DEBUG << "EVMExecutor::get_error_message error_message: " << error_message; return error_message; } void EVMExecutor::reset() { execution_processor_.reset(); } ExecutionResult EVMExecutor::convert_validation_result(const ValidationResult& result, const silkworm::Transaction& txn) { auto& evm = execution_processor_.evm(); auto& block = evm.block(); std::string from = address_to_hex(*txn.sender()); switch (result) { case ValidationResult::kMaxPriorityFeeGreaterThanMax: { std::string error = "tip higher than fee cap: address " + from + ", tip: " + intx::to_string(txn.max_priority_fee_per_gas) + " gasFeeCap: " + intx::to_string(txn.max_fee_per_gas); return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, {}, error, PreCheckErrorCode::kTipHigherThanFeeCap}; } case ValidationResult::kMaxFeeLessThanBase: { std::string error = "fee cap less than block base fee: address " + from + ", gasFeeCap: " + intx::to_string(txn.max_fee_per_gas) + " baseFee: " + intx::to_string(*block.header.base_fee_per_gas); return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, {}, error, PreCheckErrorCode::kFeeCapLessThanBlockFeePerGas}; } case ValidationResult::kIntrinsicGas: { const intx::uint128 g0{protocol::intrinsic_gas(txn, evm.revision())}; std::string error = "intrinsic gas too low: have " + std::to_string(txn.gas_limit) + ", want " + intx::to_string(g0); return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, {}, error, PreCheckErrorCode::kIntrinsicGasTooLow}; } case ValidationResult::kWrongBlockGas: { std::string error = "internal failure: Cancun is active but ExcessBlobGas is nil"; return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, {}, error, PreCheckErrorCode::kInternalError}; } case ValidationResult::kUnsupportedTransactionType: { std::string error = "eip-1559 transactions require london"; return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, {}, error, PreCheckErrorCode::kIsNotLondon}; } case ValidationResult::kInsufficientFunds: { auto owned_funds = execution_processor_.intra_block_state().get_balance(*txn.sender()); const intx::uint256 base_fee_per_gas{block.header.base_fee_per_gas.value_or(0)}; const intx::uint256 effective_gas_price{txn.max_fee_per_gas >= base_fee_per_gas ? txn.effective_gas_price(base_fee_per_gas) : txn.max_priority_fee_per_gas}; const auto required_funds = protocol::compute_call_cost(txn, effective_gas_price, evm); intx::uint512 maximum_cost = required_funds; if (txn.type != TransactionType::kLegacy && txn.type != TransactionType::kAccessList) { maximum_cost = txn.maximum_gas_cost(); } std::string error = "insufficient funds for gas * price + value: address " + from + " have " + intx::to_string(owned_funds) + " want " + intx::to_string(maximum_cost + txn.value); return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, {}, error, PreCheckErrorCode::kInsufficientFunds}; } default: { std::string error = "internal failure"; return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, {}, error, PreCheckErrorCode::kInternalError}; } } } ExecutionResult EVMExecutor::call( const silkworm::Transaction& txn, const Tracers& tracers, bool refund, bool bailout) { auto& evm = execution_processor_.evm(); auto& svc = use_service(workers_); evm.analysis_cache = svc.get_analysis_cache(); evm.beneficiary = rule_set_->get_beneficiary(evm.block().header); evm.transfer = rule_set_->transfer_func(); evm.bailout = bailout; if (!txn.sender()) { return {std::nullopt, txn.gas_limit, std::nullopt, std::nullopt, Bytes{}, "malformed transaction: cannot recover sender"}; } const auto result = execution_processor_.call(txn, tracers, refund); if (result.validation_result != ValidationResult::kOk) { return convert_validation_result(result.validation_result, txn); } ExecutionResult exec_result{result.status, result.gas_left, result.gas_refund, result.gas_used.value_or(0), result.data}; SILK_DEBUG << "EVMExecutor::call call_result: " << exec_result.error_message() << " #data: " << exec_result.data.size() << " end"; return exec_result; } ExecutionResult EVMExecutor::call_with_receipt( const silkworm::Transaction& txn, Receipt& receipt, const Tracers& tracers, bool refund, bool gas_bailout) { SILK_DEBUG << "EVMExecutor::call: blockNumber: " << execution_processor_.evm().block().header.number << " gas_limit: " << txn.gas_limit << " refund: " << refund << " gas_bailout: " << gas_bailout << " transaction: " << rpc::Transaction{txn}; const auto exec_result = call(txn, tracers, refund, gas_bailout); auto& logs = execution_processor_.intra_block_state().logs(); receipt.success = exec_result.success(); receipt.bloom = logs_bloom(logs); receipt.gas_used = txn.gas_limit - exec_result.gas_left; receipt.type = txn.type; for (auto& log : logs) { Log rpc_log; rpc_log.address = log.address; rpc_log.data = std::move(log.data); rpc_log.topics = std::move(log.topics); receipt.logs.push_back(std::move(rpc_log)); } SILK_DEBUG << "EVMExecutor::call call_result: " << exec_result.error_message() << " #data: " << exec_result.data.size() << " end"; return exec_result; } Task EVMExecutor::call( const silkworm::ChainConfig& config, const ChainStorage& chain_storage, WorkerPool& workers, const silkworm::Block& block, const silkworm::Transaction& txn, const std::optional txn_id, StateFactory state_factory, const Tracers& tracers, bool refund, bool gas_bailout, std::optional accounts_overrides) { auto this_executor = co_await boost::asio::this_coro::executor; const auto execution_result = co_await async_task(workers.executor(), [&]() -> ExecutionResult { auto state = state_factory(this_executor, txn_id, chain_storage); if (accounts_overrides) { auto state_overrides = std::make_shared(*state, *accounts_overrides); EVMExecutor executor{block, config, workers, state_overrides}; return executor.call(txn, tracers, refund, gas_bailout); } EVMExecutor executor{block, config, workers, state}; return executor.call(txn, tracers, refund, gas_bailout); }); co_return execution_result; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/evm_executor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { enum class PreCheckErrorCode { kFeeCapLessThanBlockFeePerGas, kInsufficientFunds, kInternalError, kIntrinsicGasTooLow, kIsNotLondon, kMaxFeePerBlobGasTooLowError, kTipHigherThanFeeCap, }; struct ExecutionResult { std::optional status_code; uint64_t gas_left{0}; std::optional gas_refund; std::optional gas_used; Bytes data; std::optional pre_check_error{std::nullopt}; std::optional pre_check_error_code{std::nullopt}; bool success() const { return ((status_code == std::nullopt || *status_code == evmc_status_code::EVMC_SUCCESS) && pre_check_error == std::nullopt); } std::string error_message(bool full_error = true) const; }; inline constexpr int kCacheSize = 32000; template using ServiceBase = boost::asio::detail::execution_context_service_base; class AnalysisCacheService : public ServiceBase { public: explicit AnalysisCacheService(boost::asio::execution_context& owner) : ServiceBase(owner) {} void shutdown() override {} AnalysisCache* get_analysis_cache() { return &analysis_cache_; } private: AnalysisCache analysis_cache_{kCacheSize, true}; }; using db::chain::ChainStorage; using Tracers = std::vector>; class EVMExecutor { public: using StateFactory = std::function(boost::asio::any_io_executor&, std::optional, const ChainStorage&)>; static Task call( const silkworm::ChainConfig& config, const ChainStorage& storage, WorkerPool& workers, const silkworm::Block& block, const silkworm::Transaction& txn, std::optional txn_id, StateFactory state_factory, const Tracers& tracers = {}, bool refund = true, bool gas_bailout = false, std::optional accounts_overrides = std::nullopt); static std::string get_error_message(int64_t error_code, const Bytes& error_data, bool full_error = true); EVMExecutor(const silkworm::Block& block, const silkworm::ChainConfig& config, WorkerPool& workers, std::shared_ptr state) : config_(config), workers_{workers}, state_{std::move(state)}, rule_set_{protocol::rule_set_factory(config)}, execution_processor_{block, *rule_set_, *state_, config, false} { SILKWORM_ASSERT(rule_set_); } virtual ~EVMExecutor() = default; static void register_service(WorkerPool& workers) { make_service(workers); } EVMExecutor(const EVMExecutor&) = delete; EVMExecutor& operator=(const EVMExecutor&) = delete; ExecutionResult call( const silkworm::Transaction& txn, const Tracers& tracers = {}, bool refund = true, bool gas_bailout = false); ExecutionResult call_with_receipt( const silkworm::Transaction& txn, Receipt& receipt, const Tracers& tracers = {}, bool refund = true, bool gas_bailout = false); void reset(); private: ExecutionResult convert_validation_result(const ValidationResult& result, const silkworm::Transaction& txn); const silkworm::ChainConfig& config_; WorkerPool& workers_; std::shared_ptr state_; protocol::RuleSetPtr rule_set_; ExecutionProcessor execution_processor_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/evm_executor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm_executor.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using db::chain::RemoteChainStorage; struct EVMExecutorTest : public test_util::ServiceContextTestBase { EVMExecutorTest() { pool.start(); } db::test_util::MockTransaction transaction; WorkerPool workers{1}; ClientContextPool pool{1}; boost::asio::any_io_executor io_executor{pool.next_ioc().get_executor()}; test::BackEndMock backend; RemoteChainStorage storage{transaction, ethdb::kv::make_backend_providers(&backend)}; const uint64_t chain_id{11155111}; const ChainConfig* chain_config_ptr{lookup_chain_config(chain_id)}; BlockNum block_num{6'000'000}; std::shared_ptr state{std::make_shared(io_executor, transaction, storage, block_num)}; }; #if !defined(SILKWORM_SANITIZE) && !defined(_WIN32) using testing::_; using testing::Invoke; using testing::Unused; TEST_CASE_METHOD(EVMExecutorTest, "EVMExecutor") { SECTION("failed if gas_limit < intrinsic_gas") { silkworm::Transaction txn{}; txn.set_sender(0xa872626373628737383927236382161739290870_address); silkworm::Block block{}; block.header.number = block_num; EVMExecutor executor{block, *chain_config_ptr, workers, state}; const auto result = executor.call(txn, {}); CHECK(result.status_code == std::nullopt); CHECK(result.pre_check_error.value() == "intrinsic gas too low: have 0, want 53000"); } SECTION("failed if base_fee_per_gas > max_fee_per_gas ") { silkworm::Block block{}; block.header.base_fee_per_gas = 0x7; block.header.number = block_num; silkworm::Transaction txn{}; txn.gas_limit = 100'000; txn.max_fee_per_gas = 0x2; txn.set_sender(0xa872626373628737383927236382161739290870_address); EVMExecutor executor{block, *chain_config_ptr, workers, state}; const auto result = executor.call(txn, {}); CHECK(result.status_code == std::nullopt); CHECK(result.pre_check_error.value() == "fee cap less than block base fee: address 0xa872626373628737383927236382161739290870, gasFeeCap: 2 baseFee: 7"); } SECTION("failed if max_priority_fee_per_gas > max_fee_per_gas ") { silkworm::Block block{}; block.header.base_fee_per_gas = 0x1; block.header.number = block_num; silkworm::Transaction txn{}; txn.gas_limit = 100'000; txn.max_fee_per_gas = 0x2; txn.set_sender(0xa872626373628737383927236382161739290870_address); txn.max_priority_fee_per_gas = 0x18; EVMExecutor executor{block, *chain_config_ptr, workers, state}; const auto result = executor.call(txn, {}); CHECK(result.status_code == std::nullopt); CHECK(result.pre_check_error.value() == "tip higher than fee cap: address 0xa872626373628737383927236382161739290870, tip: 24 gasFeeCap: 2"); } SECTION("failed if transaction cost greater user amount") { auto cursor = std::make_shared(); EXPECT_CALL(transaction, get_as_of(_)).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); silkworm::Block block{}; block.header.base_fee_per_gas = 0x1; block.header.number = block_num; silkworm::Transaction txn{}; txn.max_fee_per_gas = 0x2; txn.gas_limit = 60000; txn.set_sender(0xa872626373628737383927236382161739290870_address); EVMExecutor executor{block, *chain_config_ptr, workers, state}; const auto result = executor.call(txn, {}); CHECK(result.status_code == std::nullopt); CHECK(result.pre_check_error.value() == "insufficient funds for gas * price + value: address 0xa872626373628737383927236382161739290870 have 0 want 60000"); } SECTION("doesn't fail if transaction cost greater user amount && gasBailout == true") { auto cursor = std::make_shared(); EXPECT_CALL(transaction, get_as_of(_)).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); silkworm::Block block{}; block.header.base_fee_per_gas = 0x1; block.header.number = block_num; silkworm::Transaction txn{}; txn.max_fee_per_gas = 0x2; txn.gas_limit = 60000; txn.set_sender(0xa872626373628737383927236382161739290870_address); EVMExecutor executor{block, *chain_config_ptr, workers, state}; const auto result = executor.call(txn, {}, false, /* gasBailout */ true); executor.reset(); CHECK(result.status_code == evmc_status_code::EVMC_SUCCESS); } AccessList access_list{ {0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae_address, { 0x0000000000000000000000000000000000000000000000000000000000000003_bytes32, 0x0000000000000000000000000000000000000000000000000000000000000007_bytes32, }}, {0xbb9bc244d798123fde783fcc1c72d3bb8c189413_address, {}}, }; SECTION("call returns SUCCESS") { auto cursor = std::make_shared(); EXPECT_CALL(transaction, get_as_of(_)).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = Bytes{}}; co_return response; })); silkworm::Block block{}; block.header.number = block_num; silkworm::Transaction txn{}; txn.gas_limit = 600000; txn.set_sender(0xa872626373628737383927236382161739290870_address); txn.access_list = access_list; EVMExecutor executor{block, *chain_config_ptr, workers, state}; const auto result = executor.call(txn, {}, true, /* gasBailout */ true); CHECK(result.status_code == 0); } static silkworm::Bytes error_data{ 0x08, 0xc3, 0x79, 0xa0, 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, 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, 0x00, 0x00, 0x20, 0x4f, 0x77, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x77, 0x6e, 0x65, 0x72}; static silkworm::Bytes short_error_data_1{0x08, 0xc3}; static silkworm::Bytes short_error_data_2{ 0x08, 0xc3, 0x79, 0xa0, 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}; static silkworm::Bytes short_error_data_3{ 0x08, 0xc3, 0x79, 0xa0, 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, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; static silkworm::Bytes short_error_data_4{ 0x08, 0xc3, 0x79, 0xa0, 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, 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, 0x00, 0x00, 0x20, 0x4f, 0x77, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20}; SECTION("get_error_message(EVMC_FAILURE) with short error_data_1") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_FAILURE, short_error_data_1); CHECK(error_message == "execution failed"); // only short answer because error_data is too short */ } SECTION("get_error_message(EVMC_FAILURE) with short error_data_2") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_FAILURE, short_error_data_2); CHECK(error_message == "execution failed"); // only short answer because error_data is too short */ } SECTION("get_error_message(EVMC_FAILURE) with short error_data_3") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_FAILURE, short_error_data_3); CHECK(error_message == "execution failed"); // only short answer because error_data is too short */ } SECTION("get_error_message(EVMC_FAILURE) with short error_data_4") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_FAILURE, short_error_data_4); CHECK(error_message == "execution failed"); // only short answer because error_data is too short */ } SECTION("get_error_message(EVMC_FAILURE) with full error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_FAILURE, error_data); CHECK(error_message == "execution failed: Ownable: caller is not the owner"); } SECTION("get_error_message(EVMC_FAILURE) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_FAILURE, error_data, false); CHECK(error_message == "execution failed"); } SECTION("get_error_message(EVMC_REVERT) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_REVERT, error_data, false); CHECK(error_message == "execution reverted"); } SECTION("get_error_message(EVMC_OUT_OF_GAS) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_OUT_OF_GAS, error_data, false); CHECK(error_message == "out of gas"); } SECTION("get_error_message(EVMC_INVALID_INSTRUCTION) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_INVALID_INSTRUCTION, error_data, false); CHECK(error_message == "invalid instruction"); } SECTION("get_error_message(EVMC_UNDEFINED_INSTRUCTION) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_UNDEFINED_INSTRUCTION, error_data, false); CHECK(error_message == "invalid opcode"); } SECTION("get_error_message(EVMC_STACK_OVERFLOW) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_STACK_OVERFLOW, error_data, false); CHECK(error_message == "stack overflow"); } SECTION("get_error_message(EVMC_STACK_UNDERFLOW) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_STACK_UNDERFLOW, error_data, false); CHECK(error_message == "stack underflow"); } SECTION("get_error_message(EVMC_BAD_JUMP_DESTINATION) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_BAD_JUMP_DESTINATION, error_data, false); CHECK(error_message == "invalid jump destination"); } SECTION("get_error_message(EVMC_INVALID_MEMORY_ACCESS) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_INVALID_MEMORY_ACCESS, error_data, false); CHECK(error_message == "invalid memory access"); } SECTION("get_error_message(EVMC_CALL_DEPTH_EXCEEDED) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_CALL_DEPTH_EXCEEDED, error_data, false); CHECK(error_message == "call depth exceeded"); } SECTION("get_error_message(EVMC_STATIC_MODE_VIOLATION) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_STATIC_MODE_VIOLATION, error_data, false); CHECK(error_message == "static mode violation"); } SECTION("get_error_message(EVMC_PRECOMPILE_FAILURE) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_PRECOMPILE_FAILURE, error_data, false); CHECK(error_message == "precompile failure"); } SECTION("get_error_message(EVMC_CONTRACT_VALIDATION_FAILURE) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_CONTRACT_VALIDATION_FAILURE, error_data, false); CHECK(error_message == "contract validation failure"); } SECTION("get_error_message(EVMC_ARGUMENT_OUT_OF_RANGE) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_ARGUMENT_OUT_OF_RANGE, error_data, false); CHECK(error_message == "argument out of range"); } SECTION("get_error_message(wrong status_code) with short error") { const auto error_message = EVMExecutor::get_error_message(8888, error_data, false); CHECK(error_message == "unknown error code"); } SECTION("get_error_message(EVMC_WASM_UNREACHABLE_INSTRUCTION) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_WASM_UNREACHABLE_INSTRUCTION, error_data, false); CHECK(error_message == "wasm unreachable instruction"); } SECTION("get_error_message(EVMC_WASM_TRAP) with short error") { const auto error_message = EVMExecutor::get_error_message(evmc_status_code::EVMC_WASM_TRAP, error_data, false); CHECK(error_message == "wasm trap"); } } #endif // !defined(SILKWORM_SANITIZE) && !defined(_WIN32) } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/evm_trace.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm_trace.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "block_reader.hpp" namespace silkworm::rpc::trace { void from_json(const nlohmann::json& json, TraceConfig& tc) { std::vector config; json.get_to(config); tc.vm_trace = std::find(config.begin(), config.end(), "vmTrace") != config.end(); tc.trace = std::find(config.begin(), config.end(), "trace") != config.end(); tc.state_diff = std::find(config.begin(), config.end(), "stateDiff") != config.end(); } std::ostream& operator<<(std::ostream& out, const TraceConfig& tc) { out << tc.to_string(); return out; } std::string TraceConfig::to_string() const { const auto& tc = *this; std::stringstream out; out << "vmTrace: " << std::boolalpha << tc.vm_trace; out << " Trace: " << std::boolalpha << tc.trace; out << " stateDiff: " << std::boolalpha << tc.state_diff; return out.str(); } std::ostream& operator<<(std::ostream& out, const TraceFilter& tf) { out << tf.to_string(); return out; } std::string TraceFilter::to_string() const { const auto& tf = *this; std::stringstream out; out << "from_block: " << std::dec << tf.from_block; out << ", to_block: " << std::dec << tf.to_block; if (!tf.from_addresses.empty()) { out << ", from_addresses: ["; std::copy(tf.from_addresses.begin(), tf.from_addresses.end(), std::ostream_iterator(out, ", ")); out << "]"; } if (!tf.to_addresses.empty()) { out << ", to_addresses: ["; std::copy(tf.to_addresses.begin(), tf.to_addresses.end(), std::ostream_iterator(out, ", ")); out << "]"; } if (tf.mode) { out << ", mode: " << tf.mode.value(); } out << ", after: " << std::dec << tf.after; out << ", count: " << std::dec << tf.count; return out.str(); } void from_json(const nlohmann::json& json, TraceCall& tc) { tc.call = json.at(0); tc.trace_config = json.at(1); } void from_json(const nlohmann::json& json, TraceFilter& tf) { if (json.contains("fromBlock")) { tf.from_block = json["fromBlock"]; } if (json.contains("toBlock")) { tf.to_block = json["toBlock"]; } if (json.contains("fromAddress")) { tf.from_addresses = json["fromAddress"]; } if (json.contains("toAddress")) { tf.to_addresses = json["toAddress"]; } if (json.contains("mode")) { tf.mode = json["mode"]; } if (json.contains("after")) { tf.after = json["after"]; } if (json.contains("count")) { tf.count = json["count"]; } } void to_json(nlohmann::json& json, const VmTrace& vm_trace) { json["code"] = vm_trace.code; json["ops"] = vm_trace.ops; } void to_json(nlohmann::json& json, const TraceOp& trace_op) { json["cost"] = trace_op.gas_cost; // In case of out-of-gas Erigon gives null trace_ex, so we must handle it if (!trace_op.trace_ex) { json["ex"] = nlohmann::json::value_t::null; } else { json["ex"] = *(trace_op.trace_ex); } json["idx"] = trace_op.idx; if (trace_op.op_name) { json["op"] = trace_op.op_name.value(); } else { json["op"] = "opcode " + get_opcode_hex(trace_op.op_code) + " not defined"; } json["pc"] = trace_op.pc; if (trace_op.sub) { json["sub"] = *trace_op.sub; } else { json["sub"] = nlohmann::json::value_t::null; } } void to_json(nlohmann::json& json, const TraceEx& trace_ex) { if (trace_ex.memory && trace_ex.memory->len) { const auto& memory = trace_ex.memory.value(); json["mem"] = memory; } else { json["mem"] = nlohmann::json::value_t::null; } json["push"] = trace_ex.stack; if (trace_ex.storage) { const auto& storage = trace_ex.storage.value(); json["store"] = storage; } else { json["store"] = nlohmann::json::value_t::null; } json["used"] = trace_ex.used; } void to_json(nlohmann::json& json, const TraceMemory& trace_memory) { json = { {"data", trace_memory.data}, {"off", trace_memory.offset}}; } void to_json(nlohmann::json& json, const TraceStorage& trace_storage) { json = { {"key", trace_storage.key}, {"val", trace_storage.value}}; } void to_json(nlohmann::json& json, const TraceAction& action) { if (action.call_type) { json["callType"] = action.call_type.value(); } json["from"] = action.from; if (action.to) { json["to"] = action.to.value(); } std::ostringstream ss; ss << "0x" << std::hex << action.gas; json["gas"] = ss.str(); if (action.input) { json["input"] = "0x" + silkworm::to_hex(action.input.value()); } if (action.init) { json["init"] = "0x" + silkworm::to_hex(action.init.value()); } json["value"] = to_quantity(action.value); } void to_json(nlohmann::json& json, const RewardAction& action) { json["author"] = action.author; json["rewardType"] = action.reward_type; json["value"] = to_quantity(action.value); } void to_json(nlohmann::json& json, const SuicideAction& action) { json["address"] = action.address; json["balance"] = to_quantity(action.balance); json["refundAddress"] = action.refund_address; } void to_json(nlohmann::json& json, const TraceResult& trace_result) { if (trace_result.address) { json["address"] = trace_result.address.value(); } if (trace_result.code) { json["code"] = "0x" + silkworm::to_hex(trace_result.code.value()); } if (trace_result.output) { json["output"] = "0x" + silkworm::to_hex(trace_result.output.value()); } std::ostringstream ss; ss << "0x" << std::hex << trace_result.gas_used; json["gasUsed"] = ss.str(); } void to_json(nlohmann::json& json, const Trace& trace) { if (std::holds_alternative(trace.action)) { json["action"] = std::get(trace.action); } else if (std::holds_alternative(trace.action)) { json["action"] = std::get(trace.action); } else if (std::holds_alternative(trace.action)) { json["action"] = std::get(trace.action); } if (trace.trace_result) { json["result"] = trace.trace_result.value(); } else { json["result"] = nlohmann::json::value_t::null; } json["subtraces"] = trace.sub_traces; json["traceAddress"] = trace.trace_address; if (trace.error) { json["error"] = trace.error.value(); } json["type"] = trace.type; if (trace.block_hash) { json["blockHash"] = trace.block_hash.value(); } if (trace.block_num) { json["blockNumber"] = trace.block_num.value(); } if (trace.transaction_hash) { json["transactionHash"] = trace.transaction_hash.value(); } if (trace.transaction_position) { json["transactionPosition"] = trace.transaction_position.value(); } } void to_json(nlohmann::json& json, const DiffValue& dv) { if (dv.from && dv.to) { json["*"] = { {"from", dv.from.value()}, {"to", dv.to.value()}}; } else if (dv.from) { json["-"] = dv.from.value(); } else if (dv.to) { json["+"] = dv.to.value(); } else { json = "="; } } void to_json(nlohmann::json& json, const StateDiffEntry& state_diff) { json["balance"] = state_diff.balance; json["code"] = state_diff.code; json["nonce"] = state_diff.nonce; json["storage"] = state_diff.storage; } void to_json(nlohmann::json& json, const TraceCallTraces& result) { json["output"] = result.output; if (result.state_diff) { json["stateDiff"] = result.state_diff.value(); } else { json["stateDiff"] = nlohmann::json::value_t::null; } json["trace"] = result.trace; if (result.vm_trace) { json["vmTrace"] = result.vm_trace.value(); } else { json["vmTrace"] = nlohmann::json::value_t::null; } if (result.transaction_hash) { json["transactionHash"] = result.transaction_hash.value(); } } void to_json(nlohmann::json& json, const TraceCallResult& result) { to_json(json, result.traces); } void to_json(nlohmann::json& json, const TraceManyCallResult& result) { json = nlohmann::json::array(); for (const auto& trace : result.traces) { json.push_back(nlohmann::json::value_t::null); to_json(json.at(json.size() - 1), trace); } } void to_json(nlohmann::json& json, const TraceDeployResult& result) { if (result.transaction_hash) { json["hash"] = result.transaction_hash.value(); } if (result.contract_creator) { json["creator"] = result.contract_creator.value(); } } void to_json(nlohmann::json& json, const TraceEntry& trace_entry) { json["type"] = trace_entry.type; json["depth"] = trace_entry.depth; json["from"] = trace_entry.from; json["to"] = trace_entry.to; if (trace_entry.value.empty()) { json["value"] = nullptr; } else { json["value"] = trace_entry.value; } if (!trace_entry.input) { json["input"] = nullptr; } else { json["input"] = *trace_entry.input; } if (!trace_entry.output) { json["output"] = nullptr; } else { json["output"] = *trace_entry.output; } } void to_json(nlohmann::json& json, const InternalOperation& trace_operation) { json["type"] = trace_operation.type; json["from"] = trace_operation.from; json["to"] = trace_operation.to; if (trace_operation.value.empty()) { json["value"] = nullptr; } else { json["value"] = trace_operation.value; } } int get_stack_count(std::uint8_t op_code) { int count{0}; switch (op_code) { case evmc_opcode::OP_PUSH1: case evmc_opcode::OP_PUSH2: case evmc_opcode::OP_PUSH3: case evmc_opcode::OP_PUSH4: case evmc_opcode::OP_PUSH5: case evmc_opcode::OP_PUSH6: case evmc_opcode::OP_PUSH7: case evmc_opcode::OP_PUSH8: case evmc_opcode::OP_PUSH9: case evmc_opcode::OP_PUSH10: case evmc_opcode::OP_PUSH11: case evmc_opcode::OP_PUSH12: case evmc_opcode::OP_PUSH13: case evmc_opcode::OP_PUSH14: case evmc_opcode::OP_PUSH15: case evmc_opcode::OP_PUSH16: case evmc_opcode::OP_PUSH17: case evmc_opcode::OP_PUSH18: case evmc_opcode::OP_PUSH19: case evmc_opcode::OP_PUSH20: case evmc_opcode::OP_PUSH21: case evmc_opcode::OP_PUSH22: case evmc_opcode::OP_PUSH23: case evmc_opcode::OP_PUSH24: case evmc_opcode::OP_PUSH25: case evmc_opcode::OP_PUSH26: case evmc_opcode::OP_PUSH27: case evmc_opcode::OP_PUSH28: case evmc_opcode::OP_PUSH29: case evmc_opcode::OP_PUSH30: case evmc_opcode::OP_PUSH31: case evmc_opcode::OP_PUSH32: count = 1; break; case evmc_opcode::OP_SWAP1: case evmc_opcode::OP_SWAP2: case evmc_opcode::OP_SWAP3: case evmc_opcode::OP_SWAP4: case evmc_opcode::OP_SWAP5: case evmc_opcode::OP_SWAP6: case evmc_opcode::OP_SWAP7: case evmc_opcode::OP_SWAP8: case evmc_opcode::OP_SWAP9: case evmc_opcode::OP_SWAP10: case evmc_opcode::OP_SWAP11: case evmc_opcode::OP_SWAP12: case evmc_opcode::OP_SWAP13: case evmc_opcode::OP_SWAP14: case evmc_opcode::OP_SWAP15: case evmc_opcode::OP_SWAP16: count = op_code - evmc_opcode::OP_SWAP1 + 2; break; case evmc_opcode::OP_DUP1: case evmc_opcode::OP_DUP2: case evmc_opcode::OP_DUP3: case evmc_opcode::OP_DUP4: case evmc_opcode::OP_DUP5: case evmc_opcode::OP_DUP6: case evmc_opcode::OP_DUP7: case evmc_opcode::OP_DUP8: case evmc_opcode::OP_DUP9: case evmc_opcode::OP_DUP10: case evmc_opcode::OP_DUP11: case evmc_opcode::OP_DUP12: case evmc_opcode::OP_DUP13: case evmc_opcode::OP_DUP14: case evmc_opcode::OP_DUP15: case evmc_opcode::OP_DUP16: count = op_code - evmc_opcode::OP_DUP1 + 2; break; case evmc_opcode::OP_CALLDATALOAD: case evmc_opcode::OP_SLOAD: case evmc_opcode::OP_MLOAD: case evmc_opcode::OP_CALLDATASIZE: case evmc_opcode::OP_LT: case evmc_opcode::OP_GT: case evmc_opcode::OP_DIV: case evmc_opcode::OP_SDIV: case evmc_opcode::OP_SAR: case evmc_opcode::OP_AND: case evmc_opcode::OP_EQ: case evmc_opcode::OP_CALLVALUE: case evmc_opcode::OP_ISZERO: case evmc_opcode::OP_ADD: case evmc_opcode::OP_EXP: case evmc_opcode::OP_CALLER: case evmc_opcode::OP_KECCAK256: case evmc_opcode::OP_SUB: case evmc_opcode::OP_ADDRESS: case evmc_opcode::OP_GAS: case evmc_opcode::OP_MUL: case evmc_opcode::OP_RETURNDATASIZE: case evmc_opcode::OP_NOT: case evmc_opcode::OP_SHR: case evmc_opcode::OP_SHL: case evmc_opcode::OP_EXTCODESIZE: case evmc_opcode::OP_SLT: case evmc_opcode::OP_OR: case evmc_opcode::OP_NUMBER: case evmc_opcode::OP_PC: case evmc_opcode::OP_TIMESTAMP: case evmc_opcode::OP_BALANCE: case evmc_opcode::OP_SELFBALANCE: case evmc_opcode::OP_MULMOD: case evmc_opcode::OP_ADDMOD: case evmc_opcode::OP_BASEFEE: case evmc_opcode::OP_BLOCKHASH: case evmc_opcode::OP_BYTE: case evmc_opcode::OP_XOR: case evmc_opcode::OP_ORIGIN: case evmc_opcode::OP_CODESIZE: case evmc_opcode::OP_MOD: case evmc_opcode::OP_SIGNEXTEND: case evmc_opcode::OP_GASLIMIT: case evmc_opcode::OP_PREVRANDAO: case evmc_opcode::OP_SGT: case evmc_opcode::OP_GASPRICE: case evmc_opcode::OP_MSIZE: case evmc_opcode::OP_EXTCODEHASH: case evmc_opcode::OP_STATICCALL: case evmc_opcode::OP_DELEGATECALL: case evmc_opcode::OP_CALL: case evmc_opcode::OP_CALLCODE: case evmc_opcode::OP_CREATE: case evmc_opcode::OP_CREATE2: case evmc_opcode::OP_COINBASE: case evmc_opcode::OP_CHAINID: case evmc_opcode::OP_SMOD: count = 1; break; default: count = 0; break; } return count; } void copy_address(const evmone::uint256* stack, std::string& address) { std::string addr{"0000000000000000000000000000000000000000"}; auto hex = intx::hex(stack[0]); auto pos = static_cast(addr.size()) - static_cast(hex.size()); if (pos > 0) { std::copy(hex.begin(), hex.end(), addr.begin() + pos); } else { addr = hex; } address = "0x" + addr; } void copy_stack(std::uint8_t op_code, const evmone::uint256* stack, std::vector& trace_stack) { const int top = get_stack_count(op_code); trace_stack.reserve(top > 0 ? static_cast(top) : 0); for (int i = top - 1; i >= 0; --i) { trace_stack.push_back("0x" + intx::to_string(stack[-i], 16)); } } void copy_memory(const evmone::Memory& memory, std::optional& trace_memory) { if (trace_memory) { TraceMemory& tm = trace_memory.value(); if (tm.len == 0) { trace_memory.reset(); return; } tm.data = "0x"; const auto data = memory.data(); const auto start = tm.offset; for (size_t idx{0}; idx < tm.len; ++idx) { std::string entry{evmc::hex({data + start + idx, 1})}; tm.data.append(entry); } } } void copy_store(std::uint8_t op_code, const evmone::uint256* stack, std::optional& trace_storage) { if (op_code == evmc_opcode::OP_SSTORE) { trace_storage = TraceStorage{"0x" + intx::to_string(stack[0], 16), "0x" + intx::to_string(stack[-1], 16)}; } } void copy_memory_offset_len(std::uint8_t op_code, const evmone::uint256* stack, std::optional& trace_memory) { switch (op_code) { case evmc_opcode::OP_MSTORE: case evmc_opcode::OP_MLOAD: trace_memory = TraceMemory{stack[0][0], 32}; break; case evmc_opcode::OP_MSTORE8: trace_memory = TraceMemory{stack[0][0], 1}; break; case evmc_opcode::OP_RETURNDATACOPY: case evmc_opcode::OP_CALLDATACOPY: case evmc_opcode::OP_CODECOPY: trace_memory = TraceMemory{stack[0][0], stack[-2][0]}; break; case evmc_opcode::OP_STATICCALL: case evmc_opcode::OP_DELEGATECALL: trace_memory = TraceMemory{stack[-4][0], stack[-5][0]}; break; case evmc_opcode::OP_CALL: case evmc_opcode::OP_CALLCODE: trace_memory = TraceMemory{stack[-5][0], stack[-6][0]}; break; case evmc_opcode::OP_CREATE: case evmc_opcode::OP_CREATE2: trace_memory = TraceMemory{0, 0}; break; default: break; } } void push_memory_offset_len(std::uint8_t op_code, const evmone::uint256* stack, std::stack& tms) { switch (op_code) { case evmc_opcode::OP_STATICCALL: case evmc_opcode::OP_DELEGATECALL: tms.emplace(TraceMemory{stack[-4][0], stack[-5][0]}); break; case evmc_opcode::OP_CALL: case evmc_opcode::OP_CALLCODE: tms.emplace(TraceMemory{stack[-5][0], stack[-6][0]}); break; case evmc_opcode::OP_CREATE: case evmc_opcode::OP_CREATE2: tms.emplace(TraceMemory{0, 0}); break; default: break; } } std::string to_string(intx::uint256 value) { static constexpr std::string_view kPadding = "0x0000000000000000000000000000000000000000000000000000000000000000"; const auto out = intx::to_string(value, 16); std::string padding = std::string{kPadding}; return padding.substr(0, padding.size() - out.size()) + out; } void VmTraceTracer::on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept { last_opcode_ = std::nullopt; if (metrics_ == nullptr) { metrics_ = evmc_get_instruction_metrics_table(rev); } start_gas_.push(msg.gas); if (msg.depth == 0) { vm_trace_.code = "0x" + silkworm::to_hex(code); traces_stack_.emplace(vm_trace_); if (transaction_index_ == -1) { index_prefix_.emplace(""); } else { index_prefix_.push(std::to_string(transaction_index_) + "-"); } } else if (!traces_stack_.empty()) { auto& vm_trace = traces_stack_.top().get(); auto index_prefix = index_prefix_.top(); index_prefix = index_prefix + std::to_string(vm_trace.ops.size() - 1) + "-"; index_prefix_.push(index_prefix); auto& op = vm_trace.ops[vm_trace.ops.size() - 1]; if (op.op_code == OP_CREATE || op.op_code == OP_CREATE2) { op.gas_cost = msg.gas; } else { op.gas_cost = msg.gas_cost; } op.sub = std::make_shared(); traces_stack_.emplace(*op.sub); op.sub->code = "0x" + silkworm::to_hex(code); } auto& index_prefix = index_prefix_.top(); SILK_DEBUG << "VmTraceTracer::on_execution_start:" << " depth: " << msg.depth << ", gas: " << std::dec << msg.gas << ", recipient: " << evmc::address{msg.recipient} << ", sender: " << evmc::address{msg.sender} << ", code: " << silkworm::to_hex(code) << ", code_address: " << evmc::address{msg.code_address} << ", input_size: " << msg.input_size << ", index_prefix: " << index_prefix; } void VmTraceTracer::on_instruction_start(uint32_t pc, const intx::uint256* stack_top, const int /*stack_height*/, const int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { const auto op_code = execution_state.original_code[pc]; const auto op_name = get_opcode_name(op_code); last_opcode_ = op_code; int64_t used = 0; auto& vm_trace = traces_stack_.top().get(); if (!vm_trace.ops.empty()) { auto& op = vm_trace.ops[vm_trace.ops.size() - 1]; if (op.op_code == OP_RETURN || op.op_code == OP_STOP || op.op_code == OP_REVERT) { op.gas_cost = 0; } else if (op.op_code == OP_CREATE || op.op_code == OP_CREATE2) { op.gas_cost += execution_state.last_opcode_gas_cost; } else if (op.depth == execution_state.msg->depth) { op.gas_cost = execution_state.last_opcode_gas_cost; } op.trace_ex->used = gas; used = op.trace_ex->used; copy_memory(execution_state.memory, op.trace_ex->memory); copy_stack(op.op_code, stack_top, op.trace_ex->stack); } auto index_prefix = index_prefix_.top() + std::to_string(vm_trace.ops.size()); TraceOp trace_op; trace_op.gas_cost = metrics_[op_code].gas_cost; trace_op.idx = index_prefix; trace_op.depth = execution_state.msg->depth; trace_op.op_code = op_code; trace_op.op_name = op_name; trace_op.pc = pc; trace_op.trace_ex = TraceEx{used}; if (op_code == OP_SELFDESTRUCT) { trace_op.sub = std::make_shared(); trace_op.sub->code = "0x"; } copy_memory_offset_len(op_code, stack_top, trace_op.trace_ex->memory); copy_store(op_code, stack_top, trace_op.trace_ex->storage); vm_trace.ops.push_back(trace_op); SILK_DEBUG << "VmTraceTracer::on_instruction_start:" << " pc: " << std::dec << pc << ", opcode: 0x" << std::hex << evmc::hex(op_code) << ", opcode_name: " << op_name.value_or("UNDEFINED") << ", index_prefix: " << index_prefix << ", execution_state: {" << " gas_left: " << std::dec << gas << ", status: " << execution_state.status << ", msg.gas: " << std::dec << execution_state.msg->gas << ", msg.depth: " << std::dec << execution_state.msg->depth; } void VmTraceTracer::on_precompiled_run(const evmc_result& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { SILK_DEBUG << "VmTraceTracer::on_precompiled_run:" << " status: " << result.status_code << "\n"; if (!traces_stack_.empty()) { auto& vm_trace = traces_stack_.top().get(); if (!vm_trace.ops.empty()) { auto& op = vm_trace.ops[vm_trace.ops.size() - 1]; op.sub = std::make_shared(); op.sub->code = "0x"; } } } void VmTraceTracer::on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { auto& vm_trace = traces_stack_.top().get(); traces_stack_.pop(); int64_t start_gas = start_gas_.top(); start_gas_.pop(); SILK_DEBUG << "VmTraceTracer::on_execution_end:" << " result.status_code: " << result.status_code << ", start_gas: " << std::dec << start_gas << ", gas_left: " << std::dec << result.gas_left; if (vm_trace.ops.empty()) { index_prefix_.pop(); return; } auto& op = vm_trace.ops[vm_trace.ops.size() - 1]; if (op.op_code == evmc_opcode::OP_STOP && vm_trace.ops.size() == 1) { vm_trace.ops.clear(); return; } switch (result.status_code) { case evmc_status_code::EVMC_OUT_OF_GAS: // If we run out of gas, we reset trace_ex to null (no matter what the content is) as Erigon does op.trace_ex = std::nullopt; if (op.op_code != OP_CALLCODE) { op.gas_cost = result.gas_cost; } break; // We need to adjust gas used and gas cost from evmone to match evm.go values case evmc_status_code::EVMC_STACK_UNDERFLOW: case evmc_status_code::EVMC_STACK_OVERFLOW: case evmc_status_code::EVMC_BAD_JUMP_DESTINATION: if (op.op_code == evmc_opcode::OP_EXP) { // In Erigon the static part is 0 op.trace_ex->used = start_gas; op.gas_cost = 0; } else { /* EVM WA: EVMONE in case of this error returns always zero on gas-left */ if (op.trace_ex->used > 0) { op.trace_ex->used -= op.gas_cost; } else { op.trace_ex->used = start_gas - op.gas_cost; } op.gas_cost = metrics_[op.op_code].gas_cost; } break; case evmc_status_code::EVMC_UNDEFINED_INSTRUCTION: case evmc_status_code::EVMC_INVALID_INSTRUCTION: op.gas_cost = 0; if (op.trace_ex->used == 0) { op.trace_ex->used = start_gas; } break; default: if (op.op_code == OP_CALL || op.op_code == OP_CALLCODE || op.op_code == OP_STATICCALL || op.op_code == OP_DELEGATECALL || op.op_code == OP_CREATE || op.op_code == OP_CREATE2) { op.gas_cost += result.gas_cost; } op.trace_ex->used = result.gas_left; break; } /* EVM WA: EVMONE add OP_STOP at the end of tx if not present but doesn't notify to the tracer. Add sw to add STOP to the op list */ if (result.status_code == EVMC_SUCCESS && last_opcode_ && last_opcode_ != OP_SELFDESTRUCT && last_opcode_ != OP_RETURN && last_opcode_ != OP_STOP) { auto index_prefix = index_prefix_.top() + std::to_string(vm_trace.ops.size()); TraceOp trace_op; trace_op.gas_cost = 0; trace_op.idx = index_prefix; trace_op.depth = op.depth; trace_op.op_code = OP_STOP; trace_op.op_name = get_opcode_name(OP_STOP); trace_op.pc = op.pc + 1; trace_op.trace_ex = std::make_optional(); trace_op.trace_ex->used = result.gas_left; vm_trace.ops.push_back(trace_op); } index_prefix_.pop(); } void VmTraceTracer::on_pre_check_failed(const evmc_result& /*result*/, const evmc_message& msg) noexcept { vm_trace_.code = "0x" + silkworm::to_hex(ByteView{msg.input_data, msg.input_size}); } void TraceTracer::on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept { if (precompile::is_precompile(msg.code_address, rev)) { is_precompile_ = true; return; } auto sender = evmc::address{msg.sender}; auto recipient = evmc::address{msg.recipient}; auto code_address = evmc::address{msg.code_address}; current_depth_ = msg.depth; auto create = (!initial_ibs_.exists(recipient) && created_address_.find(recipient) == created_address_.end() && recipient != code_address); if (last_opcode_) { create = create || last_opcode_.value() == OP_CREATE2 || last_opcode_.value() == OP_CREATE; } start_gas_.push(msg.gas); size_t index = traces_.size(); traces_.resize(traces_.size() + 1); Trace& trace = traces_[index]; trace.type = create ? "create" : "call"; auto& trace_action = std::get(trace.action); trace_action.from = sender; trace_action.gas = msg.gas; trace_action.value = intx::be::load(msg.value); trace.trace_result.emplace(); if (create) { created_address_.insert(recipient); trace_action.init = code; trace.trace_result->code.emplace(); trace.trace_result->address = recipient; } else { trace.trace_result->output.emplace(); trace_action.input = silkworm::ByteView{msg.input_data, msg.input_size}; trace_action.to = recipient; switch (msg.kind) { case evmc_call_kind::EVMC_CALL: if (last_opcode_) { /* EVM WA: EVMONE doesn't set flags STATICCALL CALL bases, but if one CALL is static all the next calls are signalled STATIC in the same tx */ trace_action.call_type = last_opcode_ == OP_STATICCALL ? "staticcall" : "call"; } else { trace_action.call_type = "call"; } break; case evmc_call_kind::EVMC_DELEGATECALL: trace_action.call_type = "delegatecall"; trace_action.to = code_address; trace_action.from = recipient; break; case evmc_call_kind::EVMC_CALLCODE: trace_action.call_type = "callcode"; trace_action.to = code_address; break; case evmc_call_kind::EVMC_CREATE: case evmc_call_kind::EVMC_CREATE2: case evmc_call_kind::EVMC_EOFCREATE: break; } } if (msg.depth > 0) { if (!index_stack_.empty()) { auto index_stack = index_stack_.top(); Trace& calling_trace = traces_[index_stack]; trace.trace_address = calling_trace.trace_address; trace.trace_address.push_back(calling_trace.sub_traces); ++calling_trace.sub_traces; } } else { initial_gas_ = msg.gas; } index_stack_.push(index); SILK_DEBUG << "TraceTracer::on_execution_start: gas: " << std::dec << msg.gas << " create: " << create << ", msg.depth: " << msg.depth << ", msg.kind: " << msg.kind << ", sender: " << sender << ", recipient: " << recipient << " (created: " << create << ")" << ", code_address: " << code_address << ", msg.value: " << intx::hex(intx::be::load(msg.value)) << ", code: " << silkworm::to_hex(code); } void TraceTracer::on_instruction_start(uint32_t pc, const intx::uint256* stack_top, const int stack_height, const int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { const auto opcode = execution_state.original_code[pc]; last_opcode_ = opcode; Trace& last_trace = traces_[traces_.size() - 1]; last_trace.stack_height = stack_height; last_trace.op_code = opcode; if (opcode == OP_SELFDESTRUCT) { size_t idx = traces_.size(); traces_.resize(traces_.size() + 1); Trace& trace = traces_[idx]; trace.type = "suicide"; trace.action = SuicideAction{}; auto index = index_stack_.top(); Trace& calling_trace = traces_[index]; auto& calling_action = std::get(calling_trace.action); auto& suicide_action = std::get(trace.action); if (calling_trace.trace_result && calling_trace.trace_result->address) { suicide_action.address = calling_trace.trace_result->address.value(); } else if (calling_action.to) { suicide_action.address = calling_action.to.value(); } suicide_action.balance = 0; copy_address(stack_top, suicide_action.refund_address); trace.trace_address = calling_trace.trace_address; trace.trace_address.push_back(calling_trace.sub_traces); ++calling_trace.sub_traces; nlohmann::json trace_json = trace; nlohmann::json calling_trace_json = calling_trace; } auto opcode_name = get_opcode_name(opcode); SILK_DEBUG << "TraceTracer::on_instruction_start:" << " pc: " << std::dec << pc << ", opcode: 0x" << std::hex << evmc::hex(opcode) << ", opcode_name: " << opcode_name.value_or("UNDEFINED") << ", recipient: " << evmc::address{execution_state.msg->recipient} << ", sender: " << evmc::address{execution_state.msg->sender} << ", execution_state: {" << " gas_left: " << std::dec << gas << ", status: " << execution_state.status << ", msg.gas: " << std::dec << execution_state.msg->gas << ", msg.depth: " << std::dec << execution_state.msg->depth << "}"; } void TraceTracer::on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { if (is_precompile_) { is_precompile_ = false; return; } if (index_stack_.empty()) return; if (index_stack_.empty()) { return; } auto index = index_stack_.top(); auto start_gas = start_gas_.top(); Trace& trace = traces_[index]; if (!trace.trace_result->code) { start_gas_.pop(); index_stack_.pop(); } if (current_depth_ > 0) { if (trace.trace_result->code) { trace.trace_result->code = silkworm::ByteView{result.output_data, result.output_size}; } else if (trace.trace_result->output) { trace.trace_result->output = silkworm::ByteView{result.output_data, result.output_size}; } } --current_depth_; switch (result.status_code) { case evmc_status_code::EVMC_SUCCESS: trace.trace_result->gas_used = start_gas - result.gas_left; break; case evmc_status_code::EVMC_REVERT: trace.error = "Reverted"; trace.trace_result->gas_used = start_gas - result.gas_left; break; case evmc_status_code::EVMC_OUT_OF_GAS: case evmc_status_code::EVMC_STACK_OVERFLOW: trace.error = "out of gas"; trace.trace_result.reset(); break; case evmc_status_code::EVMC_UNDEFINED_INSTRUCTION: trace.error = "invalid opcode: opcode " + get_opcode_hex(last_opcode_.value_or(0)) + " not defined"; trace.trace_result.reset(); break; case evmc_status_code::EVMC_INVALID_INSTRUCTION: trace.error = "invalid opcode: INVALID"; trace.trace_result.reset(); break; case evmc_status_code::EVMC_STACK_UNDERFLOW: { std::string trace_error{"stack underflow (" + std::to_string(trace.stack_height) + " <=> " + std::to_string(evmone::instr::traits[trace.op_code].stack_height_required) + ")"}; trace.error = trace_error; trace.trace_result.reset(); break; } case evmc_status_code::EVMC_BAD_JUMP_DESTINATION: trace.error = "invalid jump destination"; trace.trace_result.reset(); break; default: trace.error = ""; trace.trace_result.reset(); break; } last_opcode_.reset(); SILK_DEBUG << "TraceTracer::on_execution_end:" << " result.status_code: " << result.status_code << " start_gas: " << std::dec << start_gas << " gas_left: " << std::dec << result.gas_left; } void TraceTracer::on_pre_check_failed(const evmc_result& result, const evmc_message& msg) noexcept { Trace trace; trace.type = (msg.kind == EVMC_CREATE || msg.kind == EVMC_CREATE2) ? "create" : "call"; auto& trace_action = std::get(trace.action); auto sender = evmc::address{msg.sender}; trace_action.from = sender; trace_action.gas = msg.gas; trace_action.init = ByteView{msg.input_data, msg.input_size}; trace_action.value = intx::be::load(msg.value); switch (result.status_code) { case evmc_status_code::EVMC_ARGUMENT_OUT_OF_RANGE: trace.error = "nonce uint64 overflow"; break; case evmc_status_code::EVMC_INSUFFICIENT_BALANCE: trace.error = "insufficient balance for transfer"; break; default: trace.error = ""; break; } traces_.push_back(trace); } void TraceTracer::on_creation_completed(const evmc_result& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { if (index_stack_.empty()) return; auto index = index_stack_.top(); auto start_gas = start_gas_.top(); index_stack_.pop(); start_gas_.pop(); Trace& trace = traces_[index]; switch (result.status_code) { case evmc_status_code::EVMC_OUT_OF_GAS: trace.error = "out of gas"; trace.trace_result.reset(); break; default: trace.trace_result->gas_used = start_gas - result.gas_left; break; } } void TraceTracer::on_reward_granted(const silkworm::CallResult& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { SILK_DEBUG << "TraceTracer::on_reward_granted:" << " result.status_code: " << result.status << ", result.gas_left: " << result.gas_left << ", initial_gas: " << std::dec << initial_gas_ << ", result.data: " << silkworm::to_hex(result.data); // Reward only on first trace if (traces_.empty()) { return; } Trace& trace = traces_[0]; switch (result.status) { case evmc_status_code::EVMC_SUCCESS: case evmc_status_code::EVMC_REVERT: trace.trace_result->gas_used = initial_gas_ - static_cast(result.gas_left); if (!result.data.empty()) { if (trace.trace_result->code) { trace.trace_result->code = result.data; } else if (trace.trace_result->output) { trace.trace_result->output = result.data; } } break; default: break; } } intx::uint256 StateAddresses::get_balance(const evmc::address& address) const noexcept { auto it = balances_.find(address); if (it != balances_.end()) { return it->second; } return initial_ibs_.get_balance(address); } uint64_t StateAddresses::get_nonce(const evmc::address& address) const noexcept { auto it = nonces_.find(address); if (it != nonces_.end()) { return it->second; } return initial_ibs_.get_nonce(address); } silkworm::ByteView StateAddresses::get_code(const evmc::address& address) const noexcept { auto it = codes_.find(address); if (it != codes_.end()) { return it->second; } return initial_ibs_.get_code(address); } void StateAddresses::remove(const evmc::address& address) noexcept { balances_.erase(address); nonces_.erase(address); codes_.erase(address); } bool StateAddresses::exists(const evmc::address& address) const noexcept { if (balances_.contains(address) || nonces_.contains(address) || codes_.contains(address)) { return true; } return initial_ibs_.exists(address); } void StateDiffTracer::on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept { if (precompile::is_precompile(msg.code_address, rev)) { is_precompile_ = true; return; } auto recipient = evmc::address{msg.recipient}; code_[recipient] = code; auto exists = state_addresses_.exists(recipient); SILK_DEBUG << "StateDiffTracer::on_execution_start: gas: " << std::dec << msg.gas << ", depth: " << msg.depth << ", sender: " << evmc::address{msg.sender} << ", recipient: " << recipient << " (exists: " << exists << ")" << ", code: " << silkworm::to_hex(code); } void StateDiffTracer::on_instruction_start(uint32_t pc, const intx::uint256* stack_top, const int /*stack_height*/, const int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { const auto opcode = execution_state.original_code[pc]; const auto opcode_name = get_opcode_name(opcode); if (opcode == evmc_opcode::OP_SSTORE) { auto key = to_string(stack_top[0]); auto address = evmc::address{execution_state.msg->recipient}; auto& keys = diff_storage_[address]; keys.insert(key); } SILK_DEBUG << "StateDiffTracer::on_instruction_start:" << " pc: " << std::dec << pc << ", opcode_name: " << opcode_name.value_or("UNDEFINED") << ", recipient: " << evmc::address{execution_state.msg->recipient} << ", sender: " << evmc::address{execution_state.msg->sender} << ", execution_state: {" << " gas_left: " << std::dec << gas << ", status: " << execution_state.status << ", msg.gas: " << std::dec << execution_state.msg->gas << ", msg.depth: " << std::dec << execution_state.msg->depth << "}"; } void StateDiffTracer::on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept { if (is_precompile_) { is_precompile_ = false; return; } SILK_DEBUG << "StateDiffTracer::on_execution_end:" << " result.status_code: " << result.status_code << ", gas_left: " << std::dec << result.gas_left; } void StateDiffTracer::on_reward_granted(const silkworm::CallResult& result, const silkworm::IntraBlockState& intra_block_state) noexcept { SILK_DEBUG << "StateDiffTracer::on_reward_granted:" << " result.status_code: " << result.status << ", result.gas_left: " << result.gas_left << ", #touched: " << std::dec << intra_block_state.touched().size(); for (const auto& address : intra_block_state.touched()) { auto initial_exists = state_addresses_.exists(address); auto exists = intra_block_state.exists(address) && !intra_block_state.is_self_destructed(address); auto& diff_storage = diff_storage_[address]; auto address_key = address_to_hex(address); auto& entry = state_diff_[address_key]; if (initial_exists) { auto initial_balance = state_addresses_.get_balance(address); auto initial_code = state_addresses_.get_code(address); auto initial_nonce = state_addresses_.get_nonce(address); if (exists) { bool all_equals = true; auto final_balance = intra_block_state.get_balance(address); if (initial_balance != final_balance) { all_equals = false; entry.balance = DiffValue{ "0x" + intx::to_string(initial_balance, 16), "0x" + intx::to_string(final_balance, 16)}; } auto final_code = intra_block_state.get_code(address); if (initial_code != final_code) { all_equals = false; entry.code = DiffValue{ "0x" + silkworm::to_hex(initial_code), "0x" + silkworm::to_hex(final_code)}; } auto final_nonce = intra_block_state.get_nonce(address); if (initial_nonce != final_nonce) { all_equals = false; entry.nonce = DiffValue{ to_quantity(initial_nonce), to_quantity(final_nonce)}; } for (auto& key : diff_storage) { auto key_b32 = silkworm::bytes32_from_hex(key); auto initial_storage = intra_block_state.get_original_storage(address, key_b32); auto final_storage = intra_block_state.get_current_storage(address, key_b32); if (initial_storage != final_storage) { all_equals = false; entry.storage[key] = DiffValue{ silkworm::to_hex(intra_block_state.get_original_storage(address, key_b32), true), silkworm::to_hex(intra_block_state.get_current_storage(address, key_b32), true)}; } } if (all_equals) { state_diff_.erase(address_key); } } else { entry.balance = DiffValue{ "0x" + intx::to_string(initial_balance, 16)}; entry.code = DiffValue{ "0x" + silkworm::to_hex(initial_code)}; entry.nonce = DiffValue{ to_quantity(initial_nonce)}; for (auto& key : diff_storage) { auto key_b32 = silkworm::bytes32_from_hex(key); entry.storage[key] = DiffValue{ silkworm::to_hex(intra_block_state.get_original_storage(address, key_b32), true)}; } } } else if (exists) { const auto balance = intra_block_state.get_balance(address); entry.balance = DiffValue{ {}, "0x" + intx::to_string(balance, 16)}; const auto code = intra_block_state.get_code(address); entry.code = DiffValue{ {}, "0x" + silkworm::to_hex(code)}; const auto nonce = intra_block_state.get_nonce(address); entry.nonce = DiffValue{ {}, to_quantity(nonce)}; bool to_be_removed = (balance == 0) && code.empty() && (nonce == 0); for (auto& key : diff_storage) { auto key_b32 = silkworm::bytes32_from_hex(key); if (intra_block_state.get_current_storage(address, key_b32) != evmc::bytes32{}) { entry.storage[key] = DiffValue{ {}, silkworm::to_hex(intra_block_state.get_current_storage(address, key_b32), true)}; } to_be_removed = false; } if (to_be_removed) { state_diff_.erase(address_key); } } } } void IntraBlockStateTracer::on_reward_granted(const silkworm::CallResult& result, const silkworm::IntraBlockState& intra_block_state) noexcept { SILK_DEBUG << "IntraBlockStateTracer::on_reward_granted:" << " result.status_code: " << result.status << ", result.gas_left: " << result.gas_left << ", #touched: " << intra_block_state.touched().size(); for (auto& address : intra_block_state.touched()) { if (intra_block_state.exists(address) && !intra_block_state.is_self_destructed(address)) { auto balance = intra_block_state.get_balance(address); state_addresses_.set_balance(address, balance); auto nonce = intra_block_state.get_nonce(address); state_addresses_.set_nonce(address, nonce); auto code = intra_block_state.get_code(address); state_addresses_.set_code(address, code); } else { state_addresses_.remove(address); } } } Task> TraceCallExecutor::trace_block(const BlockWithHash& block_with_hash, Filter& filter, json::Stream* stream, bool is_latest_block) { std::vector traces; const TraceConfig trace_block_config{ .vm_trace = false, .trace = true, .state_diff = false, }; const auto trace_call_results = co_await trace_block_transactions(block_with_hash.block, trace_block_config, is_latest_block); for (size_t pos = 0; pos < trace_call_results.size(); ++pos) { rpc::Transaction transaction{block_with_hash.block.transactions[pos]}; const auto tnx_hash = transaction.hash(); const auto& trace_call_result = trace_call_results.at(pos); const auto& call_traces = trace_call_result.traces.trace; for (const auto& call_trace : call_traces) { Trace trace{call_trace}; bool skip = !(filter.from_addresses.empty() && filter.to_addresses.empty()); if (std::holds_alternative(trace.action)) { const auto& action = std::get(trace.action); if (skip && !filter.from_addresses.empty()) { if (filter.from_addresses.find(action.from) != filter.from_addresses.end()) { skip = false; } } if (skip && !filter.to_addresses.empty() && action.to) { if (filter.to_addresses.find(action.to.value()) != filter.to_addresses.end()) { skip = false; } } } if (!skip) { if (filter.after > 0) { --filter.after; } else { trace.block_num = block_with_hash.block.header.number; trace.block_hash = block_with_hash.hash; trace.transaction_position = pos; trace.transaction_hash = tnx_hash; if (stream != nullptr) { stream->write_json(trace); } else { traces.push_back(trace); } --filter.count; } } if (filter.count == 0) { break; } } if (filter.count == 0) { break; } } if (!filter.from_addresses.empty() || !filter.to_addresses.empty()) { co_return traces; } const auto chain_config = co_await chain_storage_.read_chain_config(); const auto rule_set_factory = protocol::rule_set_factory(chain_config); const auto block_rewards = rule_set_factory->compute_reward(block_with_hash.block); if (filter.count > 0 && filter.after == 0) { if (block_rewards.miner) { RewardAction action; action.author = block_with_hash.block.header.beneficiary; action.reward_type = "block"; action.value = block_rewards.miner; Trace trace; trace.block_num = block_with_hash.block.header.number; trace.block_hash = block_with_hash.hash; trace.type = "reward"; trace.action = action; if (stream != nullptr) { stream->write_json(trace); } else { traces.push_back(trace); } } size_t index{0}; for (auto& ommer_reward : block_rewards.ommers) { RewardAction action; action.author = block_with_hash.block.ommers[index].beneficiary; action.reward_type = "uncle"; action.value = ommer_reward; Trace trace; trace.block_num = block_with_hash.block.header.number; trace.block_hash = block_with_hash.hash; trace.type = "reward"; trace.action = action; if (stream != nullptr) { stream->write_json(trace); } else { traces.push_back(trace); } } --filter.count; } else if (filter.after > 0) { if (block_rewards.miner || !block_rewards.ommers.empty()) --filter.after; } co_return traces; } Task> TraceCallExecutor::trace_block_transactions(const silkworm::Block& block, const TraceConfig& config, bool is_latest_block) { auto block_num = block.header.number; const auto& transactions = block.transactions; SILK_TRACE << "trace_block_transactions: block_num: " << std::dec << block_num << " #txns: " << transactions.size() << " config: " << config; const auto chain_config = co_await chain_storage_.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; std::optional txn_id; if (!is_latest_block) { // trace_block semantics: we must execute the call from the state at the current block txn_id = co_await tx_.user_txn_id_at(block_num); } const auto call_result = co_await async_task(workers_.executor(), [&]() -> std::vector { execution::StateFactory state_factory{tx_}; auto state = state_factory.make(current_executor, chain_storage_, txn_id); IntraBlockState initial_ibs{*state}; StateAddresses state_addresses(initial_ibs); std::shared_ptr ibs_tracer = std::make_shared(state_addresses); auto curr_state = execution::StateFactory{tx_}.make(current_executor, chain_storage_, txn_id); EVMExecutor executor{block, chain_config, workers_, curr_state}; std::vector trace_call_result(transactions.size()); for (size_t index = 0; index < transactions.size(); ++index) { const silkworm::Transaction& transaction{block.transactions[index]}; auto& result = trace_call_result.at(index); TraceCallTraces& traces = result.traces; traces.transaction_hash = transaction.hash(); Tracers tracers; if (config.vm_trace) { traces.vm_trace.emplace(); std::shared_ptr tracer = std::make_shared(traces.vm_trace.value(), index); tracers.push_back(tracer); } if (config.trace) { std::shared_ptr tracer = std::make_shared(traces.trace, initial_ibs); tracers.push_back(tracer); } if (config.state_diff) { traces.state_diff.emplace(); std::shared_ptr tracer = std::make_shared(traces.state_diff.value(), state_addresses); tracers.push_back(tracer); } tracers.push_back(ibs_tracer); auto execution_result = executor.call(transaction, tracers, /*refund=*/true, /*gas_bailout=*/false); if (execution_result.pre_check_error) { result.pre_check_error = execution_result.pre_check_error.value(); } else { traces.output = "0x" + silkworm::to_hex(execution_result.data); } executor.reset(); } return trace_call_result; }); co_return call_result; } Task TraceCallExecutor::trace_call(const silkworm::Block& block, const Call& call, const TraceConfig& config, bool is_latest_block) { // trace_call semantics: we must execute the call from the state at the end of the given block, so we pass block.header.number + 1 rpc::Transaction transaction{call.to_transaction()}; auto result = co_await execute(block.header.number + 1, block, transaction, /*index=*/-1, config, /*gas_bailout=*/true, is_latest_block); co_return result; } Task TraceCallExecutor::trace_calls(const silkworm::Block& block, const std::vector& calls, bool is_latest_block) { const auto block_num = block.header.number; SILK_DEBUG << "trace_call_many: " << " block_num: " << block_num << " #trace_calls: " << calls.size(); const auto chain_config = co_await chain_storage_.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; execution::StateFactory state_factory{tx_}; // trace_calls semantics: we must execute the call from the state at the end of the given block, so we pass block.header.number + 1 std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx_.user_txn_id_at(block_num + 1); } const auto trace_calls_result = co_await async_task(workers_.executor(), [&]() -> TraceManyCallResult { auto state = state_factory.make(current_executor, chain_storage_, txn_id); silkworm::IntraBlockState initial_ibs{*state}; StateAddresses state_addresses(initial_ibs); auto curr_state = state_factory.make(current_executor, chain_storage_, txn_id); EVMExecutor executor{block, chain_config, workers_, state}; std::shared_ptr ibs_tracer = std::make_shared(state_addresses); TraceManyCallResult result; for (size_t index{0}; index < calls.size(); ++index) { const auto& config = calls[index].trace_config; silkworm::Transaction transaction{calls[index].call.to_transaction()}; Tracers tracers; TraceCallTraces traces; if (config.vm_trace) { traces.vm_trace.emplace(); std::shared_ptr tracer = std::make_shared(traces.vm_trace.value(), index); tracers.push_back(tracer); } if (config.trace) { std::shared_ptr tracer = std::make_shared(traces.trace, initial_ibs); tracers.push_back(tracer); } if (config.state_diff) { traces.state_diff.emplace(); std::shared_ptr tracer = std::make_shared(traces.state_diff.value(), state_addresses); tracers.push_back(tracer); } tracers.push_back(ibs_tracer); auto execution_result = executor.call(transaction, tracers, /*refund=*/true, /*gas_bailout=*/true); if (execution_result.pre_check_error) { result.pre_check_error = "first run for txIndex " + std::to_string(index) + " error: " + execution_result.pre_check_error.value(); result.traces.clear(); break; } traces.output = "0x" + silkworm::to_hex(execution_result.data); result.traces.push_back(traces); executor.reset(); } return result; }); co_return trace_calls_result; } Task TraceCallExecutor::trace_deploy_transaction(const silkworm::Block& block, const evmc::address& contract_address, const silkworm::Transaction& transaction, TxnId creation_txn_id) { auto block_num = block.header.number; SILK_DEBUG << "trace_deploy_transaction: block_num: " << std::dec << block_num << " transaction.hash: " << silkworm::to_hex(transaction.hash()); const auto chain_config = co_await chain_storage_.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; execution::StateFactory state_factory{tx_}; const auto txn_id = co_await tx_.user_txn_id_at(block_num); const auto deploy_result = co_await async_task(workers_.executor(), [&]() -> TraceDeployResult { auto state = state_factory.make(current_executor, chain_storage_, txn_id); silkworm::IntraBlockState initial_ibs{*state}; auto curr_state = state_factory.make(current_executor, chain_storage_, creation_txn_id); EVMExecutor executor{block, chain_config, workers_, curr_state}; TraceDeployResult result; auto create_tracer = std::make_shared(contract_address, initial_ibs); Tracers tracers{create_tracer}; executor.call(transaction, tracers, /*refund=*/true, /*gas_bailout=*/true); if (create_tracer->found()) { result.transaction_hash = transaction.hash(); result.contract_creator = transaction.sender(); } return result; }); co_return deploy_result; } Task TraceCallExecutor::trace_transaction(const silkworm::Block& block, const rpc::Transaction& transaction, const TraceConfig& config) { // trace_transaction semantics: we must execute the txn from the state at the current block return execute(block.header.number, block, transaction, gsl::narrow(transaction.transaction_index), config, /*gas_bailout=*/false, false /* is_latest_block */); } Task> TraceCallExecutor::trace_transaction(const BlockWithHash& block_with_hash, const rpc::Transaction& transaction, bool gas_bailout) { std::vector traces; // trace_transaction semantics: we must execute the txn from the state at the position transaction_index of the current block const auto result = co_await execute(block_with_hash.block.header.number, block_with_hash.block, transaction, gsl::narrow(transaction.transaction_index), {false, true, false}, gas_bailout, false /* is_latest_block */); const auto& trace_result = result.traces.trace; const auto tnx_hash = transaction.hash(); for (const auto& call_trace : trace_result) { Trace trace{call_trace}; trace.block_num = block_with_hash.block.header.number; trace.block_hash = block_with_hash.hash; trace.transaction_position = transaction.transaction_index; trace.transaction_hash = tnx_hash; traces.push_back(trace); } co_return traces; } Task TraceCallExecutor::trace_transaction_entries(const TransactionWithBlock& transaction_with_block) { const auto& block = transaction_with_block.block_with_hash->block; const auto block_num = block.header.number; const auto chain_config = co_await chain_storage_.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; // We must do the execution at the state after the txn identified by transaction_with_block param in the same block // at the state of the block identified by the given block_num, i.e. at the start of the block (block_num) execution::StateFactory state_factory{tx_}; const auto txn_id = co_await tx_.user_txn_id_at(block_num, gsl::narrow(transaction_with_block.transaction.transaction_index)); const auto trace_result = co_await async_task(workers_.executor(), [&]() -> TraceEntriesResult { auto state = state_factory.make(current_executor, chain_storage_, txn_id); silkworm::IntraBlockState initial_ibs{*state}; auto curr_state = state_factory.make(current_executor, chain_storage_, txn_id); EVMExecutor executor{block, chain_config, workers_, curr_state}; const auto entry_tracer = std::make_shared(initial_ibs); Tracers tracers{entry_tracer}; const auto& txn = block.transactions.at(transaction_with_block.transaction.transaction_index); executor.call(txn, tracers, /*refund=*/true, /*gas_bailout=*/false); return entry_tracer->result(); }); co_return trace_result; } Task TraceCallExecutor::trace_transaction_error(const TransactionWithBlock& transaction_with_block) { const auto& block = transaction_with_block.block_with_hash->block; const auto block_num = block.header.number; const auto chain_config = co_await chain_storage_.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; // We must do the execution at the state after the txn identified by transaction_with_block param in the same block // at the state of the block identified by the given block_num, i.e. at the start of the block (block_num) execution::StateFactory state_factory{tx_}; const auto txn_id = co_await tx_.user_txn_id_at(block_num, gsl::narrow(transaction_with_block.transaction.transaction_index)); const auto trace_error = co_await async_task(workers_.executor(), [&]() -> std::string { auto state = state_factory.make(current_executor, chain_storage_, txn_id); silkworm::IntraBlockState initial_ibs{*state}; auto curr_state = state_factory.make(current_executor, chain_storage_, txn_id); EVMExecutor executor{block, chain_config, workers_, curr_state}; const auto& txn = block.transactions.at(transaction_with_block.transaction.transaction_index); auto execution_result = executor.call(txn, {}, /*refund=*/true, /*gas_bailout=*/false); std::string result = "0x"; if (execution_result.status_code != evmc_status_code::EVMC_SUCCESS) { result = "0x" + silkworm::to_hex(execution_result.data); } return result; }); co_return trace_error; } Task TraceCallExecutor::trace_operations(const TransactionWithBlock& transaction_with_block) { const auto& block = transaction_with_block.block_with_hash->block; auto block_num = block.header.number; const auto chain_config = co_await chain_storage_.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; // We must do the execution at the state after the txn identified by transaction_with_block param in the same block // at the state of the block identified by the given block_num, i.e. at the start of the block (block_num) const auto txn_id = co_await tx_.user_txn_id_at(block_num, gsl::narrow(transaction_with_block.transaction.transaction_index)); const auto trace_op_result = co_await async_task(workers_.executor(), [&]() -> TraceOperationsResult { auto state = execution::StateFactory{tx_}.make(current_executor, chain_storage_, txn_id); silkworm::IntraBlockState initial_ibs{*state}; auto curr_state = execution::StateFactory{tx_}.make(current_executor, chain_storage_, txn_id); EVMExecutor executor{block, chain_config, workers_, curr_state}; auto entry_tracer = std::make_shared(initial_ibs); Tracers tracers{entry_tracer}; const auto& txn = block.transactions.at(transaction_with_block.transaction.transaction_index); executor.call(txn, tracers, /*refund=*/true, /*gas_bailout=*/false); return entry_tracer->result(); }); co_return trace_op_result; } Task TraceCallExecutor::trace_filter(const TraceFilter& trace_filter, const ChainStorage& storage, json::Stream& stream) { SILK_TRACE << "TraceCallExecutor::trace_filter: filter " << trace_filter; if (trace_filter.from_block.number() > trace_filter.to_block.number()) { const Error error{-32000, "invalid parameters: fromBlock cannot be greater than toBlock"}; stream.write_json_field("error", error); stream.write_json_field("result", nlohmann::json::value_t::null); co_return; } stream.write_field("result"); stream.open_array(); Filter filter; filter.from_addresses.insert(trace_filter.from_addresses.begin(), trace_filter.from_addresses.end()); filter.to_addresses.insert(trace_filter.to_addresses.begin(), trace_filter.to_addresses.end()); filter.after = trace_filter.after; filter.count = trace_filter.count; const BlockReader reader{storage, tx_}; auto block_with_hash = co_await reader.read_block_by_block_num_or_hash(block_cache_, trace_filter.from_block); auto block_num = trace_filter.from_block.number(); while (block_num <= trace_filter.to_block.number()) { if (!block_with_hash) { break; } const Block block{block_with_hash, false}; SILK_TRACE << "TraceCallExecutor::trace_filter: processing block_num: " << block_num << " block: " << block; co_await trace_block(*block_with_hash, filter, &stream); if (filter.count == 0) { break; } ++block_num; block_with_hash = co_await reader.read_block_by_number(block_cache_, block_num); } stream.close_array(); SILK_TRACE << "TraceCallExecutor::trace_filter: end"; co_return; } Task TraceCallExecutor::execute( BlockNum block_num, const silkworm::Block& block, const rpc::Transaction& transaction, std::int32_t index, const TraceConfig& config, bool gas_bailout, bool is_latest_block) { SILK_DEBUG << "execute: " << " block_num: " << std::dec << block_num << " transaction: {" << transaction << "}" << " index: " << std::dec << index << " config: " << config; const auto chain_config = co_await chain_storage_.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; // We must do the execution at the state after the txn identified by the given index within the given block // at the state after the block identified by the given block_num execution::StateFactory state_factory{tx_}; std::optional txn_id; if (!is_latest_block) { txn_id = co_await tx_.user_txn_id_at(block_num, gsl::narrow(transaction.transaction_index)); } auto state = state_factory.make(current_executor, chain_storage_, txn_id); auto curr_state = state_factory.make(current_executor, chain_storage_, txn_id); const auto trace_call_result = co_await async_task(workers_.executor(), [&]() -> TraceCallResult { Tracers tracers; silkworm::IntraBlockState initial_ibs{*state}; StateAddresses state_addresses(initial_ibs); EVMExecutor executor{block, chain_config, workers_, curr_state}; TraceCallResult result; TraceCallTraces& traces = result.traces; if (config.vm_trace) { traces.vm_trace.emplace(); tracers.push_back(std::make_shared(traces.vm_trace.value(), index)); } if (config.trace) { tracers.push_back(std::make_shared(traces.trace, initial_ibs)); } if (config.state_diff) { traces.state_diff.emplace(); tracers.push_back(std::make_shared(traces.state_diff.value(), state_addresses)); } if (index != -1) { traces.transaction_hash = transaction.hash(); // to have same behaviour as erigon, should be done PR on erigon } const auto execution_result = executor.call(transaction, tracers, /*refund=*/true, gas_bailout); if (execution_result.pre_check_error) { result.pre_check_error = execution_result.pre_check_error.value(); } else { traces.output = "0x" + silkworm::to_hex(execution_result.data); } return result; }); co_return trace_call_result; } void CreateTracer::on_execution_start(evmc_revision, const evmc_message& msg, evmone::bytes_view code) noexcept { auto recipient = evmc::address{msg.recipient}; auto code_address = evmc::address{msg.code_address}; bool create = (!initial_ibs_.exists(recipient) && recipient != code_address); if (create && recipient == contract_address_) { this->found_ = true; } SILK_DEBUG << "CreateTracer::on_execution_start: gas: " << std::dec << msg.gas << " create: " << create << ", msg.depth: " << msg.depth << ", msg.kind: " << msg.kind << ", recipient: " << recipient << " (created: " << create << ")" << ", code_address: " << code_address << ", msg.value: " << intx::hex(intx::be::load(msg.value)) << ", code: " << silkworm::to_hex(code); } void EntryTracer::on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& /* intra_block_state */) noexcept { --current_depth_; if (traces_stack_idx_.empty()) return; auto& trace_idx = traces_stack_idx_.top(); traces_stack_idx_.pop(); if (trace_idx != std::numeric_limits::max()) { result_[trace_idx].output = "0x" + silkworm::to_hex(silkworm::ByteView{result.output_data, result.output_size}); } } void EntryTracer::on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept { auto balance = initial_ibs_.get_balance(address); result_.push_back(TraceEntry{"SELFDESTRUCT", current_depth_ + 1, address, beneficiary, "0x" + intx::to_string(balance, 16), "0x", "0x"}); } void EntryTracer::on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept { const auto& sender = evmc::address{msg.sender}; const auto& recipient = evmc::address{msg.recipient}; const auto& code_address = evmc::address{msg.code_address}; const auto& input = silkworm::ByteView{msg.input_data, msg.input_size}; const auto str_value = "0x" + intx::hex(intx::be::load(msg.value)); auto str_input = "0x" + silkworm::to_hex(input); current_depth_ = msg.depth; // Ignore precompiles in the returned trace (maybe we shouldn't?) if (precompile::is_precompile(msg.code_address, rev)) { // writes special value for index traces_stack_idx_.emplace(std::numeric_limits::max()); return; } if (msg.kind == evmc_call_kind::EVMC_CREATE) { str_input = "0x" + silkworm::to_hex(code); result_.push_back(TraceEntry{"CREATE", msg.depth, sender, recipient, str_value, str_input}); } else if (msg.kind == evmc_call_kind::EVMC_CREATE2) { str_input = "0x" + silkworm::to_hex(code); result_.push_back(TraceEntry{"CREATE2", msg.depth, sender, recipient, str_value, str_input}); } else { switch (msg.kind) { case evmc_call_kind::EVMC_CALL: { if (last_opcode_ == OP_STATICCALL) { result_.push_back(TraceEntry{"STATICCALL", msg.depth, sender, recipient, "", str_input}); } else { result_.push_back(TraceEntry{"CALL", msg.depth, sender, recipient, str_value, str_input}); } } break; case evmc_call_kind::EVMC_DELEGATECALL: result_.push_back(TraceEntry{"DELEGATECALL", msg.depth, recipient, code_address, "", str_input}); break; case evmc_call_kind::EVMC_CALLCODE: result_.push_back(TraceEntry{"CALLCODE", msg.depth, sender, recipient, str_value, str_input}); break; default: // safeguard in case new CALL-like opcodes are introduced but not handled, result_.push_back(TraceEntry{"UNKNWON", msg.depth, sender, recipient, str_value, str_input}); break; } } traces_stack_idx_.emplace(result_.size() - 1); SILK_DEBUG << "EntryTracer::on_execution_start: gas: " << std::dec << msg.gas << ", msg.depth: " << msg.depth << ", msg.kind: " << msg.kind << ", sender: " << sender << ", recipient: " << recipient << ", code_address: " << code_address << ", msg.value: " << intx::hex(intx::be::load(msg.value)) << ", code: " << silkworm::to_hex(code) << ", msg.input_data: " << to_hex(ByteView{msg.input_data, msg.input_size}); } void EntryTracer::on_instruction_start(uint32_t pc, const intx::uint256* /* stack_top */, const int /* stack_height */, const int64_t /* gas */, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& /* intra_block_state */) noexcept { last_opcode_ = execution_state.original_code[pc]; } void OperationTracer::on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept { auto balance = initial_ibs_.get_balance(address); result_.push_back(InternalOperation{OperationType::kOpSelfDestruct, address, beneficiary, "0x" + intx::to_string(balance, 16)}); } void OperationTracer::on_execution_start(evmc_revision, const evmc_message& msg, evmone::bytes_view code) noexcept { const auto& sender = evmc::address{msg.sender}; const auto& recipient = evmc::address{msg.recipient}; const auto& code_address = evmc::address{msg.code_address}; const auto depth = msg.depth; const auto kind = msg.kind; auto str_value = "0x" + intx::hex(intx::be::load(msg.value)); if (msg.depth > 0) { if (msg.kind == evmc_call_kind::EVMC_CREATE) { result_.push_back(InternalOperation{OperationType::kOpCreate, sender, recipient, str_value}); } else if (msg.kind == evmc_call_kind::EVMC_CREATE2) { result_.push_back(InternalOperation{OperationType::kOpCreate2, sender, recipient, str_value}); } else if (msg.kind == evmc_call_kind::EVMC_CALL && intx::be::load(msg.value) > 0) { result_.push_back(InternalOperation{OperationType::kOpTransfer, sender, recipient, str_value}); } } SILK_DEBUG << "OperationTracer::on_execution_start: gas: " << std::dec << msg.gas << ", msg.depth: " << depth << ", msg.kind: " << kind << ", sender: " << sender << ", recipient: " << recipient << ", code_address: " << code_address << ", msg.value: " << intx::hex(intx::be::load(msg.value)) << ", code: " << silkworm::to_hex(code) << ", msg.input_data: " << to_hex(ByteView{msg.input_data, msg.input_size}); } void TouchTracer::on_execution_start(evmc_revision, const evmc_message& msg, evmone::bytes_view code) noexcept { if (found_) { return; } const auto& sender = evmc::address{msg.sender}; const auto& recipient = evmc::address{msg.recipient}; const auto& code_address = evmc::address{msg.code_address}; const auto kind = msg.kind; if (sender == address_ || recipient == address_ || (code_address == address_ && (kind == EVMC_DELEGATECALL || kind == EVMC_CALLCODE))) { found_ = true; } SILK_DEBUG << "TouchTracer::on_execution_start: gas: " << std::dec << msg.gas << ", msg.depth: " << msg.depth << ", msg.kind: " << msg.kind << ", sender: " << sender << ", recipient: " << recipient << ", code_address: " << code_address << ", msg.value: " << intx::hex(intx::be::load(msg.value)) << ", code: " << silkworm::to_hex(code); } void TouchTracer::on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept { if (found_) { return; } if (address == address_ || beneficiary == address_) { found_ = true; } } } // namespace silkworm::rpc::trace ================================================ FILE: silkworm/rpc/core/evm_trace.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::trace { struct TraceConfig { bool vm_trace{false}; bool trace{false}; bool state_diff{false}; std::string to_string() const; }; void from_json(const nlohmann::json& json, TraceConfig& tc); struct TraceCall { Call call; TraceConfig trace_config; }; void from_json(const nlohmann::json& json, TraceCall& tc); struct TraceFilter { BlockNumOrHash from_block{0}; BlockNumOrHash to_block{"latest"}; std::vector from_addresses; std::vector to_addresses; std::optional mode; std::uint32_t after{0}; std::uint32_t count{std::numeric_limits::max()}; std::string to_string() const; }; void from_json(const nlohmann::json& json, TraceFilter& tf); std::string to_string(intx::uint256 value); std::ostream& operator<<(std::ostream& out, const TraceConfig& tc); std::ostream& operator<<(std::ostream& out, const TraceFilter& tf); struct TraceStorage { std::string key; std::string value; }; struct TraceMemory { uint64_t offset{0}; uint64_t len{0}; std::string data; }; struct TraceEx { int64_t used{0}; std::optional memory; std::vector stack; std::optional storage; }; struct VmTrace; struct TraceOp { int64_t gas_cost{0}; std::optional call_gas_cap; std::optional trace_ex; std::string idx; int32_t depth{0}; uint8_t op_code{0}; std::optional op_name; uint32_t pc{0}; std::shared_ptr sub; }; struct VmTrace { std::string code{"0x"}; std::vector ops; }; void to_json(nlohmann::json& json, const VmTrace& vm_trace); void to_json(nlohmann::json& json, const TraceOp& trace_op); void to_json(nlohmann::json& json, const TraceEx& trace_ex); void to_json(nlohmann::json& json, const TraceMemory& trace_memory); void to_json(nlohmann::json& json, const TraceStorage& trace_storage); void copy_address(const evmone::uint256* stack, std::string& address); void copy_stack(std::uint8_t op_code, const evmone::uint256* stack, std::vector& trace_stack); void copy_memory(const evmone::Memory& memory, std::optional& trace_memory); void copy_store(std::uint8_t op_code, const evmone::uint256* stack, std::optional& trace_storage); void copy_memory_offset_len(std::uint8_t op_code, const evmone::uint256* stack, std::optional& trace_memory); void push_memory_offset_len(std::uint8_t op_code, const evmone::uint256* stack, std::stack& tms); struct FixCallGasInfo { int32_t depth{0}; int64_t stipend{0}; int16_t code_cost{0}; TraceOp& trace_op; int64_t gas_cost{0}; bool precompiled{false}; }; class VmTraceTracer : public silkworm::EvmTracer { public: explicit VmTraceTracer(VmTrace& vm_trace, std::int32_t index = -1) : vm_trace_(vm_trace), transaction_index_{index} {} VmTraceTracer(const VmTraceTracer&) = delete; VmTraceTracer& operator=(const VmTraceTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_pre_check_failed(const evmc_result& result, const evmc_message& msg) noexcept override; void on_precompiled_run(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; private: VmTrace& vm_trace_; std::int32_t transaction_index_; std::stack index_prefix_; std::stack> traces_stack_; const evmc_instruction_metrics* metrics_ = nullptr; std::stack start_gas_; std::stack trace_memory_stack_; std::optional last_opcode_; }; struct TraceAction { std::optional call_type; evmc::address from; std::optional to; int64_t gas{0}; std::optional input; std::optional init; intx::uint256 value{0}; }; struct RewardAction { evmc::address author; std::string reward_type; intx::uint256 value{0}; }; struct SuicideAction { evmc::address address; std::string refund_address; intx::uint256 balance{0}; }; using Action = std::variant; struct TraceResult { std::optional address; std::optional code; std::optional output; int64_t gas_used{0}; }; struct Trace { Action action; std::optional trace_result; std::int32_t sub_traces{0}; std::vector trace_address; std::optional error; std::string type; std::optional block_hash; std::optional block_num; std::optional transaction_hash; std::optional transaction_position; int stack_height{0}; uint8_t op_code{0}; }; void to_json(nlohmann::json& json, const TraceAction& action); void to_json(nlohmann::json& json, const RewardAction& action); void to_json(nlohmann::json& json, const SuicideAction& action); void to_json(nlohmann::json& json, const TraceResult& trace_result); void to_json(nlohmann::json& json, const Trace& trace); template > class IterableStack : public std::stack { using std::stack::c; public: using const_iterator = typename Container::const_iterator; const_iterator begin() const { return c.begin(); } const_iterator end() const { return std::end(c); } }; class TraceTracer : public silkworm::EvmTracer { public: explicit TraceTracer(std::vector& traces, silkworm::IntraBlockState& initial_ibs) : traces_(traces), initial_ibs_(initial_ibs) {} TraceTracer(const TraceTracer&) = delete; TraceTracer& operator=(const TraceTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_reward_granted(const silkworm::CallResult& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_pre_check_failed(const evmc_result& result, const evmc_message& msg) noexcept override; void on_creation_completed(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; private: bool is_precompile_{false}; std::vector& traces_; silkworm::IntraBlockState& initial_ibs_; std::optional last_opcode_; int64_t initial_gas_{0}; int32_t current_depth_{-1}; std::set created_address_; IterableStack index_stack_; std::stack start_gas_; }; struct DiffValue { std::optional from; std::optional to; }; using DiffStorage = std::map; struct StateDiffEntry { DiffValue balance; DiffValue code; DiffValue nonce; DiffStorage storage; }; using StateDiff = std::map; class StateAddresses { public: explicit StateAddresses(silkworm::IntraBlockState& initial_ibs) : initial_ibs_(initial_ibs) {} StateAddresses(const StateAddresses&) = delete; StateAddresses& operator=(const StateAddresses&) = delete; bool exists(const evmc::address& address) const noexcept; intx::uint256 get_balance(const evmc::address& address) const noexcept; void set_balance(const evmc::address& address, const intx::uint256& value) noexcept { balances_[address] = value; } uint64_t get_nonce(const evmc::address& address) const noexcept; void set_nonce(const evmc::address& address, uint64_t nonce) noexcept { nonces_[address] = nonce; } silkworm::ByteView get_code(const evmc::address& address) const noexcept; void set_code(const evmc::address& address, silkworm::ByteView code) noexcept { codes_[address] = silkworm::Bytes{code}; } void remove(const evmc::address& address) noexcept; private: std::map balances_; std::map nonces_; std::map codes_; silkworm::IntraBlockState& initial_ibs_; }; void to_json(nlohmann::json& json, const DiffValue& dv); void to_json(nlohmann::json& json, const StateDiffEntry& state_diff); class StateDiffTracer : public silkworm::EvmTracer { public: explicit StateDiffTracer(StateDiff& state_diff, StateAddresses& state_addresses) : state_diff_(state_diff), state_addresses_(state_addresses) {} StateDiffTracer(const StateDiffTracer&) = delete; StateDiffTracer& operator=(const StateDiffTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_reward_granted(const silkworm::CallResult& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; private: bool is_precompile_{false}; StateDiff& state_diff_; StateAddresses& state_addresses_; std::map> diff_storage_; std::map code_; }; struct TraceCallTraces { std::string output{"0x"}; std::optional transaction_hash; std::optional state_diff; std::vector trace; std::optional vm_trace; }; struct TraceCallResult { TraceCallTraces traces; std::optional pre_check_error{std::nullopt}; }; struct TraceManyCallResult { std::vector traces; std::optional pre_check_error{std::nullopt}; }; struct TraceDeployResult { std::optional transaction_hash; std::optional contract_creator; }; struct TraceEntry { std::string type; int32_t depth; evmc::address from; evmc::address to; std::string value; std::optional input; std::optional output; }; enum OperationType : int { kOpTransfer = 0, kOpSelfDestruct = 1, kOpCreate = 2, kOpCreate2 = 3 }; struct InternalOperation { OperationType type; evmc::address from; evmc::address to; std::string value; }; using TraceEntriesResult = std::vector; using TraceOperationsResult = std::vector; void to_json(nlohmann::json& json, const TraceCallTraces& result); void to_json(nlohmann::json& json, const TraceCallResult& result); void to_json(nlohmann::json& json, const TraceManyCallResult& result); void to_json(nlohmann::json& json, const TraceDeployResult& result); void to_json(nlohmann::json& json, const TraceEntry& trace_entry); void to_json(nlohmann::json& json, const InternalOperation& trace_operation); class IntraBlockStateTracer : public silkworm::EvmTracer { public: explicit IntraBlockStateTracer(StateAddresses& state_addresses) : state_addresses_{state_addresses} {} IntraBlockStateTracer(const IntraBlockStateTracer&) = delete; IntraBlockStateTracer& operator=(const IntraBlockStateTracer&) = delete; void on_reward_granted(const silkworm::CallResult& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; private: StateAddresses& state_addresses_; }; class CreateTracer : public silkworm::EvmTracer { public: explicit CreateTracer(const evmc::address& contract_address, silkworm::IntraBlockState& initial_ibs) : contract_address_(contract_address), initial_ibs_(initial_ibs) {} CreateTracer(const CreateTracer&) = delete; CreateTracer& operator=(const CreateTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; bool found() const { return found_; } private: bool found_{false}; const evmc::address& contract_address_; const silkworm::IntraBlockState& initial_ibs_; }; class EntryTracer : public silkworm::EvmTracer { public: explicit EntryTracer(silkworm::IntraBlockState& initial_ibs) : initial_ibs_(initial_ibs) {} EntryTracer(const EntryTracer&) = delete; EntryTracer& operator=(const EntryTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height, int64_t gas, const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& intra_block_state) noexcept override; void on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept override; TraceEntriesResult result() const { return result_; } private: const silkworm::IntraBlockState& initial_ibs_; TraceEntriesResult result_; std::stack traces_stack_idx_; int32_t current_depth_{-1}; std::optional last_opcode_; }; class OperationTracer : public silkworm::EvmTracer { public: explicit OperationTracer(silkworm::IntraBlockState& initial_ibs) : initial_ibs_(initial_ibs) {} OperationTracer(const OperationTracer&) = delete; OperationTracer& operator=(const OperationTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept override; TraceOperationsResult result() const { return result_; } private: const silkworm::IntraBlockState& initial_ibs_; TraceOperationsResult result_; }; class TouchTracer : public silkworm::EvmTracer { public: explicit TouchTracer(const evmc::address& address, silkworm::IntraBlockState& initial_ibs) : address_(address), initial_ibs_(initial_ibs) {} TouchTracer(const TouchTracer&) = delete; TouchTracer& operator=(const TouchTracer&) = delete; void on_execution_start(evmc_revision rev, const evmc_message& msg, evmone::bytes_view code) noexcept override; void on_self_destruct(const evmc::address& address, const evmc::address& beneficiary) noexcept override; bool found() const { return found_; } private: bool found_{false}; const evmc::address& address_; const silkworm::IntraBlockState& initial_ibs_; TraceOperationsResult result_; }; struct Filter { std::set from_addresses; std::set to_addresses; std::optional mode; std::uint32_t after{0}; std::uint32_t count{std::numeric_limits::max()}; }; class TraceCallExecutor { public: explicit TraceCallExecutor(BlockCache& block_cache, const ChainStorage& chain_storage, WorkerPool& workers, db::kv::api::Transaction& tx) : block_cache_(block_cache), chain_storage_(chain_storage), workers_(workers), tx_(tx) {} virtual ~TraceCallExecutor() = default; TraceCallExecutor(const TraceCallExecutor&) = delete; TraceCallExecutor& operator=(const TraceCallExecutor&) = delete; Task> trace_block(const BlockWithHash& block_with_hash, Filter& filter, json::Stream* stream = nullptr, bool is_latest_block = false); Task> trace_block_transactions(const silkworm::Block& block, const TraceConfig& config, bool is_latest_block = false); Task trace_call(const silkworm::Block& block, const Call& call, const TraceConfig& config, bool is_latest_block = false); Task trace_calls(const silkworm::Block& block, const std::vector& calls, bool is_latest_block = false); Task trace_deploy_transaction(const silkworm::Block& block, const evmc::address& contract_address, const silkworm::Transaction& transaction, TxnId creation_txn_id); Task trace_transaction(const silkworm::Block& block, const rpc::Transaction& transaction, const TraceConfig& config); Task> trace_transaction(const silkworm::BlockWithHash& block, const rpc::Transaction& transaction, bool gas_bailout); Task trace_transaction_entries(const TransactionWithBlock& transaction_with_block); Task trace_transaction_error(const TransactionWithBlock& transaction_with_block); Task trace_operations(const TransactionWithBlock& transaction_with_block); Task trace_filter(const TraceFilter& trace_filter, const ChainStorage& storage, json::Stream& stream); private: Task execute( BlockNum block_num, const silkworm::Block& block, const rpc::Transaction& transaction, std::int32_t index, const TraceConfig& config, bool gas_bailout, bool is_latest_block); BlockCache& block_cache_; const ChainStorage& chain_storage_; WorkerPool& workers_; db::kv::api::Transaction& tx_; }; } // namespace silkworm::rpc::trace ================================================ FILE: silkworm/rpc/core/evm_trace_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "evm_trace.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::trace { using namespace silkworm::db; using chain::RemoteChainStorage; struct TraceCallExecutorTest : public test_util::ServiceContextTestBase { db::test_util::MockTransaction transaction; WorkerPool workers{1}; test::MockBlockCache block_cache; StringWriter writer{4096}; boost::asio::any_io_executor io_executor{ioc_.get_executor()}; test::BackEndMock backend; RemoteChainStorage chain_storage{transaction, ethdb::kv::make_backend_providers(&backend)}; }; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(10'336'007)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = false, .value = Bytes{}}; co_return rsp1; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = false, .value = Bytes{}}; co_return rsp1; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = false, .value = Bytes{}}; co_return rsp1; })); evmc::address blake2f_precompile{0x0000000000000000000000000000000000000009_address}; Call call; call.from = 0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address; call.to = blake2f_precompile; call.gas = 50'000; call.gas_price = 7; silkworm::Block block{}; block.header.number = 10'336'006; TraceConfig config{true, true, true}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(!result.pre_check_error); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance":{ "+":"0x55730" }, "code":{ "+":"0x" }, "nonce":{ "+":"0x0" }, "storage":{} }, "0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030":{ "balance":{ "+":"0x0" }, "code":{ "+":"0x" }, "nonce":{ "+":"0x1" }, "storage":{} } }, "trace":[], "vmTrace": { "code": "0x", "ops": [] } })"_json); } } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 1") { static Bytes account_history_key1{*silkworm::from_hex("e0a2bd4258d2768837baa26a28fe71dc079f84c7")}; static Bytes account_history_value1{*silkworm::from_hex("0203430b141e903194951083c424fd0000")}; static Bytes account_history_key2{*silkworm::from_hex("52728289eba496b6080d57d0250a90663a07e556")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("000944ed67f28fd50bb8e90000")}; SECTION("Call: failed with intrinsic gas too low") { EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 50'000; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{false, false, false}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == true); CHECK(result.pre_check_error.value() == "intrinsic gas too low: have 50000, want 53072"); } SECTION("Call: full output") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{true, true, true}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x44ed67f28fd50bb8e9", "to": "0x44ed67f28fd513c08f" } }, "code": "=", "nonce": "=", "storage": {} }, "0x52728289eba496b6080d57d0250a90663a07e556": { "balance": { "+": "0x0" }, "code": { "+": "0x" }, "nonce": { "+": "0x1" }, "storage": { "0x0000000000000000000000000000000000000000000000000000000000000000": { "+": "0x000000000000000000000000000000000000000000000000000000000000002a" } } }, "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7": { "balance": "=", "code": "=", "nonce": { "*": { "from": "0x343", "to": "0x344" } }, "storage": {} } }, "trace": [ { "action": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x10148", "init": "0x602a60005500", "value": "0x0" }, "result": { "address": "0x52728289eba496b6080d57d0250a90663a07e556", "code": "0x", "gasUsed": "0x565a" }, "subtraces": 0, "traceAddress": [], "type": "create" } ], "vmTrace": { "code": "0x602a60005500", "ops": [ { "cost": 3, "ex": { "mem": null, "push": [ "0x2a" ], "store": null, "used": 65861 }, "idx": "0", "op": "PUSH1", "pc": 0, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 65858 }, "idx": "1", "op": "PUSH1", "pc": 2, "sub": null }, { "cost": 22100, "ex": { "mem": null, "push": [], "store": { "key": "0x0", "val": "0x2a" }, "used": 43758 }, "idx": "2", "op": "SSTORE", "pc": 4, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 43758 }, "idx": "3", "op": "STOP", "pc": 5, "sub": null } ] } })"_json); } SECTION("Call: no vmTrace") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{false, true, true}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x44ed67f28fd50bb8e9", "to": "0x44ed67f28fd513c08f" } }, "code": "=", "nonce": "=", "storage": {} }, "0x52728289eba496b6080d57d0250a90663a07e556": { "balance": { "+": "0x0" }, "code": { "+": "0x" }, "nonce": { "+": "0x1" }, "storage": { "0x0000000000000000000000000000000000000000000000000000000000000000": { "+": "0x000000000000000000000000000000000000000000000000000000000000002a" } } }, "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7": { "balance": "=", "code": "=", "nonce": { "*": { "from": "0x343", "to": "0x344" } }, "storage": {} } }, "trace": [ { "action": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x10148", "init": "0x602a60005500", "value": "0x0" }, "result": { "address": "0x52728289eba496b6080d57d0250a90663a07e556", "code": "0x", "gasUsed": "0x565a" }, "subtraces": 0, "traceAddress": [], "type": "create" } ], "vmTrace": null })"_json); } SECTION("Call: no trace") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{true, false, true}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x44ed67f28fd50bb8e9", "to": "0x44ed67f28fd513c08f" } }, "code": "=", "nonce": "=", "storage": {} }, "0x52728289eba496b6080d57d0250a90663a07e556": { "balance": { "+": "0x0" }, "code": { "+": "0x" }, "nonce": { "+": "0x1" }, "storage": { "0x0000000000000000000000000000000000000000000000000000000000000000": { "+": "0x000000000000000000000000000000000000000000000000000000000000002a" } } }, "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7": { "balance": "=", "code": "=", "nonce": { "*": { "from": "0x343", "to": "0x344" } }, "storage": {} } }, "trace": [], "vmTrace": { "code": "0x602a60005500", "ops": [ { "cost": 3, "ex": { "mem": null, "push": [ "0x2a" ], "store": null, "used": 65861 }, "idx": "0", "op": "PUSH1", "pc": 0, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 65858 }, "idx": "1", "op": "PUSH1", "pc": 2, "sub": null }, { "cost": 22100, "ex": { "mem": null, "push": [], "store": { "key": "0x0", "val": "0x2a" }, "used": 43758 }, "idx": "2", "op": "SSTORE", "pc": 4, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 43758 }, "idx": "3", "op": "STOP", "pc": 5, "sub": null } ] } })"_json); } SECTION("Call: no stateDiff") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{true, true, false}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": null, "trace": [ { "action": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x10148", "init": "0x602a60005500", "value": "0x0" }, "result": { "address": "0x52728289eba496b6080d57d0250a90663a07e556", "code": "0x", "gasUsed": "0x565a" }, "subtraces": 0, "traceAddress": [], "type": "create" } ], "vmTrace": { "code": "0x602a60005500", "ops": [ { "cost": 3, "ex": { "mem": null, "push": [ "0x2a" ], "store": null, "used": 65861 }, "idx": "0", "op": "PUSH1", "pc": 0, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 65858 }, "idx": "1", "op": "PUSH1", "pc": 2, "sub": null }, { "cost": 22100, "ex": { "mem": null, "push": [], "store": { "key": "0x0", "val": "0x2a" }, "used": 43758 }, "idx": "2", "op": "SSTORE", "pc": 4, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 43758 }, "idx": "3", "op": "STOP", "pc": 5, "sub": null } ] } })"_json); } SECTION("Call: no vmTrace, trace and stateDiff") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; call.gas = 118'936; call.gas_price = 7; call.data = *silkworm::from_hex("602a60005500"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{false, false, false}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": null, "trace": [], "vmTrace": null })"_json); } } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 2") { static Bytes account_history_key1{*silkworm::from_hex("8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9")}; static Bytes account_history_value1{*silkworm::from_hex("03038c330a01a098914888dc0516d20000")}; static Bytes account_history_key2{*silkworm::from_hex("5e1f0c9ddbe3cb57b80c933fab5151627d7966fa")}; static Bytes account_history_value2{*silkworm::from_hex("010408014219564ff26a000000")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; SECTION("Call: TO present") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(4'417'197)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value2}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); const BlockNum block_num = 4'417'196; // 0x4366AC Call call; call.from = 0x8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9_address; call.to = 0x5e1f0c9ddbe3cb57b80c933fab5151627d7966fa_address; call.value = 50'000'000; call.gas = 30'000; call.gas_price = 1'000'000'000; call.data = *silkworm::from_hex("00"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{true, true, true}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "+": "0x131a5ff57800" }, "code": { "+": "0x" }, "nonce": { "+": "0x0" }, "storage": {} }, "0x5e1f0c9ddbe3cb57b80c933fab5151627d7966fa": { "balance": { "*": { "from": "0x14219564ff26a00", "to": "0x142195652ed5a80" } }, "code": "=", "nonce": "=", "storage": {} }, "0x8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9": { "balance": { "*": { "from": "0x1a098914888dc0516d2", "to": "0x1a098914888d90a2652" } }, "code": "=", "nonce": { "*": { "from": "0x38c33", "to": "0x38c34" } }, "storage": {} } }, "trace": [ { "action": { "callType": "call", "from": "0x8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9", "gas": "0x2324", "input": "0x00", "to": "0x5e1f0c9ddbe3cb57b80c933fab5151627d7966fa", "value": "0x2faf080" }, "result": { "gasUsed": "0x0", "output": "0x" }, "subtraces": 0, "traceAddress": [], "type": "call" } ], "vmTrace": { "code": "0x", "ops": [] } })"_json); } } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call with error") { static Bytes account_history_key1{*silkworm::from_hex("578f0a154b23be77fc2033197fbc775637648ad4")}; static Bytes account_history_value1{*silkworm::from_hex("012f090207fbc719f215d7050000")}; static Bytes account_history_key2{*silkworm::from_hex("6951c35e335fa18c97cb207119133cd8009580cd")}; static Bytes account_history_value2{*silkworm::from_hex("00000000")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("000944ed67f28fd50bb8e90000")}; db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value2}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); BlockNum block_num = 5'405'095; // 0x5279A7 Call call; call.from = 0x578f0a154b23be77fc2033197fbc775637648ad4_address; call.value = 0; call.gas = 211'190; call.gas_price = 14; call.data = *silkworm::from_hex( "0x414bf3890000000000000000000000009d381f0b1637475f133c92d9b9fdc5493ae19b630000000000000000000000009b73fc19" "3bfa16abe18d1ea30734e4a6444a753f00000000000000000000000000000000000000000000000000000000000027100000000000" "00000000000000578f0a154b23be77fc2033197fbc775637648ad40000000000000000000000000000000000000000000000000000" "0000612ba19c00000000000000000000000000000000000000000001a784379d99db42000000000000000000000000000000000000" "00000000000002cdc48e6cca575707722c0000000000000000000000000000000000000000000000000000000000000000"); silkworm::Block block{}; block.header.number = block_num; TraceConfig config{true, true, true}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_call(block, call, config)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"({ "output": "0x", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x44ed67f28fd50bb8e9", "to": "0x44ed67f28fd538d65d" } }, "code": "=", "nonce": "=", "storage": {} }, "0x578f0a154b23be77fc2033197fbc775637648ad4": { "balance": "=", "code": "=", "nonce": { "*": { "from": "0x2f", "to": "0x30" } }, "storage": {} } }, "trace": [ { "action": { "callType": "call", "from": "0x578f0a154b23be77fc2033197fbc775637648ad4", "gas": "0x261b2", "input": "0x", "to": "0x6951c35e335fa18c97cb207119133cd8009580cd", "value": "0x0" }, "error": "invalid opcode: opcode 0x4b not defined", "result": null, "subtraces": 0, "traceAddress": [], "type": "call" } ], "vmTrace": { "code": "0x414bf3890000000000000000000000009d381f0b1637475f133c92d9b9fdc5493ae19b630000000000000000000000009b73fc193bfa16abe18d1ea30734e4a6444a753f0000000000000000000000000000000000000000000000000000000000002710000000000000000000000000578f0a154b23be77fc2033197fbc775637648ad400000000000000000000000000000000000000000000000000000000612ba19c00000000000000000000000000000000000000000001a784379d99db4200000000000000000000000000000000000000000000000002cdc48e6cca575707722c0000000000000000000000000000000000000000000000000000000000000000", "ops": [ { "cost": 2, "ex": { "mem": null, "push": ["0x0"], "store": null, "used": 156080 }, "idx": "0", "op": "COINBASE", "pc": 0, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 156080 }, "idx": "1", "op": "opcode 0x4b not defined", "pc": 1, "sub": null } ] } })"_json); } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_calls") { static Bytes account_history_key1{*silkworm::from_hex("e0a2bd4258d2768837baa26a28fe71dc079f84c700000000005279a8")}; static Bytes account_history_value1{*silkworm::from_hex("0203430b141e903194951083c424fd0000")}; static Bytes account_history_key2{*silkworm::from_hex("52728289eba496b6080d57d0250a90663a07e55600000000005279a8")}; static Bytes account_history_key3{*silkworm::from_hex("000000000000000000000000000000000000000000000000005279a8")}; static Bytes account_history_value3{*silkworm::from_hex("000944ed67f28fd50bb8e90000")}; SECTION("callMany: failed with intrinsic gas too low") { EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); const BlockNum block_num = 5'405'095; // 0x5279A7 TraceCall trace_call; trace_call.call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; trace_call.call.gas = 50'000; trace_call.call.gas_price = 7; trace_call.call.data = *silkworm::from_hex("602a60005500"); trace_call.trace_config = TraceConfig{false, false, false}; std::vector calls; calls.push_back(trace_call); silkworm::Block block{}; block.header.number = block_num; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_calls(block, calls)); CHECK(result.pre_check_error.has_value() == true); CHECK(result.pre_check_error.value() == "first run for txIndex 0 error: intrinsic gas too low: have 50000, want 53072"); } SECTION("Call: full output") { db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(5'405'096)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); const BlockNum block_num = 5'405'095; // 0x5279A7 TraceCall trace_call; trace_call.call.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; trace_call.call.gas = 118'936; trace_call.call.gas_price = 7; trace_call.call.data = *silkworm::from_hex("602a60005500"); trace_call.trace_config = TraceConfig{true, true, true}; std::vector calls; calls.push_back(trace_call); silkworm::Block block{}; block.header.number = block_num; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_calls(block, calls)); CHECK(result.pre_check_error.has_value() == false); CHECK(nlohmann::json(result.traces) == R"([ { "output": "0x", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x44ed67f28fd50bb8e9", "to": "0x44ed67f28fd513c08f" } }, "code": "=", "nonce": "=", "storage": {} }, "0x52728289eba496b6080d57d0250a90663a07e556": { "balance": { "+": "0x0" }, "code": { "+": "0x" }, "nonce": { "+": "0x1" }, "storage": { "0x0000000000000000000000000000000000000000000000000000000000000000": { "+": "0x000000000000000000000000000000000000000000000000000000000000002a" } } }, "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7": { "balance": "=", "code": "=", "nonce": { "*": { "from": "0x343", "to": "0x344" } }, "storage": {} } }, "trace": [ { "action": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x10148", "init": "0x602a60005500", "value": "0x0" }, "result": { "address": "0x52728289eba496b6080d57d0250a90663a07e556", "code": "0x", "gasUsed": "0x565a" }, "subtraces": 0, "traceAddress": [], "type": "create" } ], "vmTrace": { "code": "0x602a60005500", "ops": [ { "cost": 3, "ex": { "mem": null, "push": [ "0x2a" ], "store": null, "used": 65861 }, "idx": "0-0", "op": "PUSH1", "pc": 0, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 65858 }, "idx": "0-1", "op": "PUSH1", "pc": 2, "sub": null }, { "cost": 22100, "ex": { "mem": null, "push": [], "store": { "key": "0x0", "val": "0x2a" }, "used": 43758 }, "idx": "0-2", "op": "SSTORE", "pc": 4, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 43758 }, "idx": "0-3", "op": "STOP", "pc": 5, "sub": null } ] } } ])"_json); } } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_block_transactions") { // TransactionDatabase::get: TABLE AccountHistory static Bytes account_history_key1{*silkworm::from_hex("daae090d53f9ed9e2e1fd25258c01bac4dd6d1c5")}; static Bytes account_history_value1{*silkworm::from_hex("0127080334e1d62a9e34400000")}; static Bytes account_history_key2{*silkworm::from_hex("a85b4c37cd8f447848d49851a1bb06d10d410c13")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("0008028ded68c33d14010000")}; db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); BlockNum block_num = 1'024'165; // 0xFA0A5 silkworm::Block block{}; block.header.number = block_num; silkworm::Transaction txn; txn.set_sender(0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5_address); txn.nonce = 27; txn.value = 0; txn.data = *silkworm::from_hex( "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004" "361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080" "fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060" "008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c" "60af2c64736f6c634300050a0032"); txn.max_priority_fee_per_gas = 0x3b9aca00; txn.max_fee_per_gas = 0x3b9aca00; txn.gas_limit = 0x47b760; txn.type = TransactionType::kLegacy; block.transactions.push_back(txn); TraceConfig config{true, true, true}; TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_block_transactions(block, config)); CHECK(nlohmann::json(result) == R"([ { "output": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x28ded68c33d1401", "to": "0x28e46f23db3ea01" } }, "code": "=", "nonce": "=", "storage": {} }, "0xa85b4c37cd8f447848d49851a1bb06d10d410c13": { "balance": { "+": "0x0" }, "code": { "+": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032" }, "nonce": { "+": "0x1" }, "storage": {} }, "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5": { "balance": { "*": { "from": "0x334e1d62a9e3440", "to": "0x334884cb0275e40" } }, "code": "=", "nonce": { "*": { "from": "0x27", "to": "0x28" } }, "storage": {} } }, "trace": [ { "action": { "from": "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5", "gas": "0x46da7c", "init": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "value": "0x0" }, "result": { "address": "0xa85b4c37cd8f447848d49851a1bb06d10d410c13", "code": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "gasUsed": "0xa3ab" }, "subtraces": 0, "traceAddress": [], "type": "create" } ], "transactionHash": "0x849ca3076047d76288f2d15b652f18e80622aa6163eff0a216a446d0a4a5288e", "vmTrace": { "code": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "ops": [ { "cost": 3, "ex": { "mem": null, "push": [ "0x80" ], "store": null, "used": 4643449 }, "idx": "0-0", "op": "PUSH1", "pc": 0, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x40" ], "store": null, "used": 4643446 }, "idx": "0-1", "op": "PUSH1", "pc": 2, "sub": null }, { "cost": 12, "ex": { "mem": { "data": "0x0000000000000000000000000000000000000000000000000000000000000080", "off": 64 }, "push": [], "store": null, "used": 4643434 }, "idx": "0-2", "op": "MSTORE", "pc": 4, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4643431 }, "idx": "0-3", "op": "PUSH1", "pc": 5, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0", "0x0" ], "store": null, "used": 4643428 }, "idx": "0-4", "op": "DUP1", "pc": 7, "sub": null }, { "cost": 2200, "ex": { "mem": null, "push": [], "store": { "key": "0x0", "val": "0x0" }, "used": 4641228 }, "idx": "0-5", "op": "SSTORE", "pc": 8, "sub": null }, { "cost": 2, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641226 }, "idx": "0-6", "op": "CALLVALUE", "pc": 9, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0", "0x0" ], "store": null, "used": 4641223 }, "idx": "0-7", "op": "DUP1", "pc": 10, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x1" ], "store": null, "used": 4641220 }, "idx": "0-8", "op": "ISZERO", "pc": 11, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x14" ], "store": null, "used": 4641217 }, "idx": "0-9", "op": "PUSH2", "pc": 12, "sub": null }, { "cost": 10, "ex": { "mem": null, "push": [], "store": null, "used": 4641207 }, "idx": "0-10", "op": "JUMPI", "pc": 15, "sub": null }, { "cost": 1, "ex": { "mem": null, "push": [], "store": null, "used": 4641206 }, "idx": "0-11", "op": "JUMPDEST", "pc": 20, "sub": null }, { "cost": 2, "ex": { "mem": null, "push": [], "store": null, "used": 4641204 }, "idx": "0-12", "op": "POP", "pc": 21, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0xc6" ], "store": null, "used": 4641201 }, "idx": "0-13", "op": "PUSH1", "pc": 22, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0xc6", "0xc6" ], "store": null, "used": 4641198 }, "idx": "0-14", "op": "DUP1", "pc": 24, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x23" ], "store": null, "used": 4641195 }, "idx": "0-15", "op": "PUSH2", "pc": 25, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641192 }, "idx": "0-16", "op": "PUSH1", "pc": 28, "sub": null }, { "cost": 36, "ex": { "mem": { "data": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "off": 0 }, "push": [], "store": null, "used": 4641156 }, "idx": "0-17", "op": "CODECOPY", "pc": 30, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641153 }, "idx": "0-18", "op": "PUSH1", "pc": 31, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 4641153 }, "idx": "0-19", "op": "RETURN", "pc": 33, "sub": null } ] } } ])"_json); } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_block") { static Bytes account_history_key1{*silkworm::from_hex("a85b4c37cd8f447848d49851a1bb06d10d410c13")}; static Bytes account_history_key2{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value2{*silkworm::from_hex("0008028ded68c33d14010000")}; static Bytes account_history_key3{*silkworm::from_hex("daae090d53f9ed9e2e1fd25258c01bac4dd6d1c5")}; static Bytes account_history_value3{*silkworm::from_hex("0127080334e1d62a9e34400000")}; db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .Times(2) .WillRepeatedly(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillRepeatedly(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value2}; co_return response; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); BlockNum block_num = 1'024'165; // 0xFA0A5 silkworm::BlockWithHash block_with_hash; block_with_hash.block.header.number = block_num; block_with_hash.hash = 0x527198f474c1f1f1d01129d3a17ecc17895d85884a31b05ef0ecd480faee1592_bytes32; silkworm::Transaction txn; txn.set_sender(0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5_address); txn.nonce = 27; txn.value = 0; txn.data = *silkworm::from_hex( "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004" "361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080" "fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060" "008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c" "60af2c64736f6c634300050a0032"); txn.max_priority_fee_per_gas = 0x3b9aca00; txn.max_fee_per_gas = 0x3b9aca00; txn.gas_limit = 0x47b760; txn.type = TransactionType::kLegacy; block_with_hash.block.transactions.push_back(txn); TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; Filter filter; const auto result = spawn_and_wait(executor.trace_block(block_with_hash, filter)); CHECK(nlohmann::json(result) == R"([ { "action": { "from": "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5", "gas": "0x46da7c", "init": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "value": "0x0" }, "blockHash": "0x527198f474c1f1f1d01129d3a17ecc17895d85884a31b05ef0ecd480faee1592", "blockNumber": 1024165, "result": { "address": "0xa85b4c37cd8f447848d49851a1bb06d10d410c13", "code": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "gasUsed": "0xa3ab" }, "subtraces": 0, "traceAddress": [], "transactionHash": "0x849ca3076047d76288f2d15b652f18e80622aa6163eff0a216a446d0a4a5288e", "transactionPosition": 0, "type": "create" } ])"_json); } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_replayTransaction") { static Bytes account_history_key1{*silkworm::from_hex("daae090d53f9ed9e2e1fd25258c01bac4dd6d1c5")}; static Bytes account_history_value1{*silkworm::from_hex("0127080334e1d62a9e34400000")}; static Bytes account_history_key2{*silkworm::from_hex("a85b4c37cd8f447848d49851a1bb06d10d410c13")}; static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("0008028ded68c33d14010000")}; db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillRepeatedly(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); BlockNum block_num = 1'024'165; // 0xFA0A5 silkworm::BlockWithHash block_with_hash; block_with_hash.block.header.number = block_num; block_with_hash.hash = 0x527198f474c1f1f1d01129d3a17ecc17895d85884a31b05ef0ecd480faee1592_bytes32; rpc::Transaction txn; txn.set_sender(0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5_address); txn.nonce = 27; txn.value = 0; txn.data = *silkworm::from_hex( "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004" "361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080" "fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060" "008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c" "60af2c64736f6c634300050a0032"); txn.max_priority_fee_per_gas = 0x3b9aca00; txn.max_fee_per_gas = 0x3b9aca00; txn.gas_limit = 0x47b760; txn.type = TransactionType::kLegacy; txn.block_hash = block_with_hash.hash; txn.block_num = block_num; txn.transaction_index = 0; block_with_hash.block.transactions.push_back(txn); SECTION("Call: only vmTrace") { EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; TraceConfig config{.vm_trace = true, .trace = false, .state_diff = false}; const auto result = spawn_and_wait(executor.trace_transaction(block_with_hash.block, txn, config)); CHECK(nlohmann::json(result) == R"({ "output": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "stateDiff": null, "trace": [], "transactionHash": "0x849ca3076047d76288f2d15b652f18e80622aa6163eff0a216a446d0a4a5288e", "vmTrace": { "code": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "ops": [ { "cost": 3, "ex": { "mem": null, "push": [ "0x80" ], "store": null, "used": 4643449 }, "idx": "0-0", "op": "PUSH1", "pc": 0, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x40" ], "store": null, "used": 4643446 }, "idx": "0-1", "op": "PUSH1", "pc": 2, "sub": null }, { "cost": 12, "ex": { "mem": { "data": "0x0000000000000000000000000000000000000000000000000000000000000080", "off": 64 }, "push": [], "store": null, "used": 4643434 }, "idx": "0-2", "op": "MSTORE", "pc": 4, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4643431 }, "idx": "0-3", "op": "PUSH1", "pc": 5, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0", "0x0" ], "store": null, "used": 4643428 }, "idx": "0-4", "op": "DUP1", "pc": 7, "sub": null }, { "cost": 2200, "ex": { "mem": null, "push": [], "store": { "key": "0x0", "val": "0x0" }, "used": 4641228 }, "idx": "0-5", "op": "SSTORE", "pc": 8, "sub": null }, { "cost": 2, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641226 }, "idx": "0-6", "op": "CALLVALUE", "pc": 9, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0", "0x0" ], "store": null, "used": 4641223 }, "idx": "0-7", "op": "DUP1", "pc": 10, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x1" ], "store": null, "used": 4641220 }, "idx": "0-8", "op": "ISZERO", "pc": 11, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x14" ], "store": null, "used": 4641217 }, "idx": "0-9", "op": "PUSH2", "pc": 12, "sub": null }, { "cost": 10, "ex": { "mem": null, "push": [], "store": null, "used": 4641207 }, "idx": "0-10", "op": "JUMPI", "pc": 15, "sub": null }, { "cost": 1, "ex": { "mem": null, "push": [], "store": null, "used": 4641206 }, "idx": "0-11", "op": "JUMPDEST", "pc": 20, "sub": null }, { "cost": 2, "ex": { "mem": null, "push": [], "store": null, "used": 4641204 }, "idx": "0-12", "op": "POP", "pc": 21, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0xc6" ], "store": null, "used": 4641201 }, "idx": "0-13", "op": "PUSH1", "pc": 22, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0xc6", "0xc6" ], "store": null, "used": 4641198 }, "idx": "0-14", "op": "DUP1", "pc": 24, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x23" ], "store": null, "used": 4641195 }, "idx": "0-15", "op": "PUSH2", "pc": 25, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641192 }, "idx": "0-16", "op": "PUSH1", "pc": 28, "sub": null }, { "cost": 36, "ex": { "mem": { "data": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "off": 0 }, "push": [], "store": null, "used": 4641156 }, "idx": "0-17", "op": "CODECOPY", "pc": 30, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641153 }, "idx": "0-18", "op": "PUSH1", "pc": 31, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 4641153 }, "idx": "0-19", "op": "RETURN", "pc": 33, "sub": null } ] } })"_json); } SECTION("Call: only trace") { EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; TraceConfig config{.vm_trace = false, .trace = true, .state_diff = false}; const auto result = spawn_and_wait(executor.trace_transaction(block_with_hash.block, txn, config)); CHECK(nlohmann::json(result) == R"({ "output": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "transactionHash": "0x849ca3076047d76288f2d15b652f18e80622aa6163eff0a216a446d0a4a5288e", "stateDiff": null, "trace": [ { "action": { "from": "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5", "gas": "0x46da7c", "init": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "value": "0x0" }, "result": { "address": "0xa85b4c37cd8f447848d49851a1bb06d10d410c13", "code": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "gasUsed": "0xa3ab" }, "subtraces": 0, "traceAddress": [], "type": "create" } ], "vmTrace": null })"_json); } SECTION("Call: only stateDiff") { EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; TraceConfig config{.vm_trace = false, .trace = false, .state_diff = true}; const auto result = spawn_and_wait(executor.trace_transaction(block_with_hash.block, txn, config)); CHECK(nlohmann::json(result) == R"({ "output": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "transactionHash": "0x849ca3076047d76288f2d15b652f18e80622aa6163eff0a216a446d0a4a5288e", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x28ded68c33d1401", "to": "0x28e46f23db3ea01" } }, "code": "=", "nonce": "=", "storage": {} }, "0xa85b4c37cd8f447848d49851a1bb06d10d410c13": { "balance": { "+": "0x0" }, "code": { "+": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032" }, "nonce": { "+": "0x1" }, "storage": {} }, "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5": { "balance": { "*": { "from": "0x334e1d62a9e3440", "to": "0x334884cb0275e40" } }, "code": "=", "nonce": { "*": { "from": "0x27", "to": "0x28" } }, "storage": {} } }, "trace": [], "vmTrace": null })"_json); } SECTION("Call: full output") { EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; co_return response; })); TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; TraceConfig config{.vm_trace = true, .trace = true, .state_diff = true}; const auto result = spawn_and_wait(executor.trace_transaction(block_with_hash.block, txn, config)); CHECK(nlohmann::json(result) == R"({ "output": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "transactionHash": "0x849ca3076047d76288f2d15b652f18e80622aa6163eff0a216a446d0a4a5288e", "stateDiff": { "0x0000000000000000000000000000000000000000": { "balance": { "*": { "from": "0x28ded68c33d1401", "to": "0x28e46f23db3ea01" } }, "code": "=", "nonce": "=", "storage": {} }, "0xa85b4c37cd8f447848d49851a1bb06d10d410c13": { "balance": { "+": "0x0" }, "code": { "+": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032" }, "nonce": { "+": "0x1" }, "storage": {} }, "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5": { "balance": { "*": { "from": "0x334e1d62a9e3440", "to": "0x334884cb0275e40" } }, "code": "=", "nonce": { "*": { "from": "0x27", "to": "0x28" } }, "storage": {} } }, "trace": [ { "action": { "from": "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5", "gas": "0x46da7c", "init": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "value": "0x0" }, "result": { "address": "0xa85b4c37cd8f447848d49851a1bb06d10d410c13", "code": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "gasUsed": "0xa3ab" }, "subtraces": 0, "traceAddress": [], "type": "create" } ], "vmTrace": { "code": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "ops": [ { "cost": 3, "ex": { "mem": null, "push": [ "0x80" ], "store": null, "used": 4643449 }, "idx": "0-0", "op": "PUSH1", "pc": 0, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x40" ], "store": null, "used": 4643446 }, "idx": "0-1", "op": "PUSH1", "pc": 2, "sub": null }, { "cost": 12, "ex": { "mem": { "data": "0x0000000000000000000000000000000000000000000000000000000000000080", "off": 64 }, "push": [], "store": null, "used": 4643434 }, "idx": "0-2", "op": "MSTORE", "pc": 4, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4643431 }, "idx": "0-3", "op": "PUSH1", "pc": 5, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0", "0x0" ], "store": null, "used": 4643428 }, "idx": "0-4", "op": "DUP1", "pc": 7, "sub": null }, { "cost": 2200, "ex": { "mem": null, "push": [], "store": { "key": "0x0", "val": "0x0" }, "used": 4641228 }, "idx": "0-5", "op": "SSTORE", "pc": 8, "sub": null }, { "cost": 2, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641226 }, "idx": "0-6", "op": "CALLVALUE", "pc": 9, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0", "0x0" ], "store": null, "used": 4641223 }, "idx": "0-7", "op": "DUP1", "pc": 10, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x1" ], "store": null, "used": 4641220 }, "idx": "0-8", "op": "ISZERO", "pc": 11, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x14" ], "store": null, "used": 4641217 }, "idx": "0-9", "op": "PUSH2", "pc": 12, "sub": null }, { "cost": 10, "ex": { "mem": null, "push": [], "store": null, "used": 4641207 }, "idx": "0-10", "op": "JUMPI", "pc": 15, "sub": null }, { "cost": 1, "ex": { "mem": null, "push": [], "store": null, "used": 4641206 }, "idx": "0-11", "op": "JUMPDEST", "pc": 20, "sub": null }, { "cost": 2, "ex": { "mem": null, "push": [], "store": null, "used": 4641204 }, "idx": "0-12", "op": "POP", "pc": 21, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0xc6" ], "store": null, "used": 4641201 }, "idx": "0-13", "op": "PUSH1", "pc": 22, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0xc6", "0xc6" ], "store": null, "used": 4641198 }, "idx": "0-14", "op": "DUP1", "pc": 24, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x23" ], "store": null, "used": 4641195 }, "idx": "0-15", "op": "PUSH2", "pc": 25, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641192 }, "idx": "0-16", "op": "PUSH1", "pc": 28, "sub": null }, { "cost": 36, "ex": { "mem": { "data": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "off": 0 }, "push": [], "store": null, "used": 4641156 }, "idx": "0-17", "op": "CODECOPY", "pc": 30, "sub": null }, { "cost": 3, "ex": { "mem": null, "push": [ "0x0" ], "store": null, "used": 4641153 }, "idx": "0-18", "op": "PUSH1", "pc": 31, "sub": null }, { "cost": 0, "ex": { "mem": null, "push": [], "store": null, "used": 4641153 }, "idx": "0-19", "op": "RETURN", "pc": 33, "sub": null } ] } })"_json); } } TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_transaction") { static Bytes account_history_key1{*silkworm::from_hex("a85b4c37cd8f447848d49851a1bb06d10d410c13")}; static Bytes account_history_key2{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value2{*silkworm::from_hex("0008028ded68c33d14010000")}; static Bytes account_history_key3{*silkworm::from_hex("daae090d53f9ed9e2e1fd25258c01bac4dd6d1c5")}; static Bytes account_history_value3{*silkworm::from_hex("0127080334e1d62a9e34400000")}; db::kv::api::GetAsOfRequest query1{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query2{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; db::kv::api::GetAsOfRequest query3{ .table = std::string{table::kAccountDomain}, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, }; EXPECT_CALL(backend, get_block_hash_from_block_num(_)) .WillOnce(InvokeWithoutArgs([]() -> Task> { co_return kZeroHeaderHash; })); EXPECT_CALL(transaction, get_one(table::kConfigName, silkworm::ByteView{kConfigKey})) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kConfigValue; })); EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); EXPECT_CALL(transaction, get_as_of(std::move(query1))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = false, .value = Bytes{}}; co_return rsp1; })); EXPECT_CALL(transaction, get_as_of(std::move(query2))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = true, .value = account_history_value2}; co_return rsp1; })); EXPECT_CALL(transaction, get_as_of(std::move(query3))).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult rsp1{ .success = true, .value = account_history_value3}; co_return rsp1; })); BlockNum block_num = 1'024'165; // 0xFA0A5 silkworm::BlockWithHash block_with_hash; block_with_hash.block.header.number = block_num; block_with_hash.hash = 0x527198f474c1f1f1d01129d3a17ecc17895d85884a31b05ef0ecd480faee1592_bytes32; rpc::Transaction txn; txn.set_sender(0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5_address); txn.nonce = 27; txn.value = 0; txn.data = *silkworm::from_hex( "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004" "361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080" "fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060" "008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c" "60af2c64736f6c634300050a0032"); txn.max_priority_fee_per_gas = 0x3b9aca00; txn.max_fee_per_gas = 0x3b9aca00; txn.gas_limit = 0x47b760; txn.type = TransactionType::kLegacy; txn.block_hash = block_with_hash.hash; txn.block_num = block_num; txn.transaction_index = 0; block_with_hash.block.transactions.push_back(txn); TraceCallExecutor executor{block_cache, chain_storage, workers, transaction}; const auto result = spawn_and_wait(executor.trace_transaction(block_with_hash, txn, true)); CHECK(nlohmann::json(result) == R"([ { "action": { "from": "0xdaae090d53f9ed9e2e1fd25258c01bac4dd6d1c5", "gas": "0x46da7c", "init": "0x60806040526000805534801561001457600080fd5b5060c6806100236000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "value": "0x0" }, "blockHash": "0x527198f474c1f1f1d01129d3a17ecc17895d85884a31b05ef0ecd480faee1592", "blockNumber": 1024165, "result": { "address": "0xa85b4c37cd8f447848d49851a1bb06d10d410c13", "code": "0x6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea265627a7a72305820ca7603d2458ae7a9db8bde091d8ba88a4637b54a8cc213b73af865f97c60af2c64736f6c634300050a0032", "gasUsed": "0xa3ab" }, "subtraces": 0, "traceAddress": [], "transactionHash": "0x849ca3076047d76288f2d15b652f18e80622aa6163eff0a216a446d0a4a5288e", "transactionPosition": 0, "type": "create" } ])"_json); } TEST_CASE("VmTrace json serialization") { TraceEx trace_ex; trace_ex.used = 5000; trace_ex.stack.emplace_back("0xdeadbeaf"); trace_ex.memory = TraceMemory{10, 0, "data"}; trace_ex.storage = TraceStorage{"key", "value"}; TraceOp trace_op; trace_op.gas_cost = 42; trace_op.trace_ex = trace_ex; trace_op.idx = "12"; trace_op.op_name = "PUSH1"; trace_op.pc = 27; VmTrace vm_trace; vm_trace.code = "0xdeadbeaf"; vm_trace.ops.push_back(trace_op); SECTION("VmTrace") { CHECK(nlohmann::json(vm_trace) == R"({ "code": "0xdeadbeaf", "ops": [ { "cost":42, "ex":{ "mem": null, "push":["0xdeadbeaf"], "store":{ "key":"key", "val":"value" }, "used":5000 }, "idx":"12", "op":"PUSH1", "pc":27, "sub":null } ] })"_json); } SECTION("TraceOp") { CHECK(nlohmann::json(trace_op) == R"({ "cost":42, "ex":{ "mem": null, "push":["0xdeadbeaf"], "store":{ "key":"key", "val":"value" }, "used":5000 }, "idx":"12", "op":"PUSH1", "pc":27, "sub":null })"_json); } SECTION("TraceEx") { CHECK(nlohmann::json(trace_ex) == R"({ "mem": null, "push":["0xdeadbeaf"], "store":{ "key":"key", "val":"value" }, "used":5000 })"_json); } SECTION("TraceMemory") { const auto& memory = trace_ex.memory.value(); CHECK(nlohmann::json(memory) == R"({ "data":"data", "off":10 })"_json); } SECTION("TraceStorage") { const auto& storage = trace_ex.storage.value(); CHECK(nlohmann::json(storage) == R"({ "key":"key", "val":"value" })"_json); } } TEST_CASE("TraceAction json serialization") { TraceAction trace_action; trace_action.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; trace_action.gas = 1000; trace_action.value = intx::uint256{0xdeadbeaf}; SECTION("basic") { CHECK(nlohmann::json(trace_action) == R"({ "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x3e8", "value": "0xdeadbeaf" })"_json); } SECTION("with to") { trace_action.to = 0xe0a2bd4258d2768837baa26a28fe71dc079f8aaa_address; CHECK(nlohmann::json(trace_action) == R"({ "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "to": "0xe0a2bd4258d2768837baa26a28fe71dc079f8aaa", "gas": "0x3e8", "value": "0xdeadbeaf" })"_json); } SECTION("with input") { trace_action.input = *silkworm::from_hex("0xdeadbeaf"); CHECK(nlohmann::json(trace_action) == R"({ "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x3e8", "input": "0xdeadbeaf", "value": "0xdeadbeaf" })"_json); } SECTION("with init") { trace_action.init = *silkworm::from_hex("0xdeadbeaf"); CHECK(nlohmann::json(trace_action) == R"({ "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x3e8", "init": "0xdeadbeaf", "value": "0xdeadbeaf" })"_json); } } TEST_CASE("TraceResult json serialization") { TraceResult trace_result; trace_result.address = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; trace_result.code = *silkworm::from_hex("0x1234567890abcdef"); trace_result.gas_used = 1000; CHECK(nlohmann::json(trace_result) == R"({ "address": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "code": "0x1234567890abcdef", "gasUsed": "0x3e8" })"_json); } TEST_CASE("Trace json serialization") { TraceAction trace_action; trace_action.from = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c7_address; trace_action.gas = 1000; trace_action.value = intx::uint256{0xdeadbeaf}; Trace trace; trace.action = trace_action; trace.type = "CALL"; SECTION("basic with trace action") { CHECK(nlohmann::json(trace) == R"({ "action": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x3e8", "value": "0xdeadbeaf" }, "result": null, "subtraces": 0, "traceAddress": [], "type": "CALL" })"_json); } SECTION("basic with reward action") { RewardAction reward_action; reward_action.author = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84d8_address; reward_action.reward_type = "block"; reward_action.value = intx::uint256{0xdeadbeaf}; trace.action = reward_action; trace.type = "reward"; CHECK(nlohmann::json(trace) == R"({ "action": { "author": "0xe0a2bd4258d2768837baa26a28fe71dc079f84d8", "rewardType": "block", "value": "0xdeadbeaf" }, "result": null, "subtraces": 0, "traceAddress": [], "type": "reward" })"_json); } SECTION("with trace_result") { TraceResult trace_result; trace_result.address = 0xe0a2Bd4258D2768837BAa26A28fE71Dc079f84c8_address; trace_result.code = *silkworm::from_hex("0x1234567890abcdef"); trace_result.gas_used = 1000; trace.trace_result = trace_result; CHECK(nlohmann::json(trace) == R"({ "action": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x3e8", "value": "0xdeadbeaf" }, "result": { "address": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c8", "code": "0x1234567890abcdef", "gasUsed": "0x3e8" }, "subtraces": 0, "traceAddress": [], "type": "CALL" })"_json); } SECTION("with error") { trace.error = "error"; CHECK(nlohmann::json(trace) == R"({ "action": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "gas": "0x3e8", "value": "0xdeadbeaf" }, "error": "error", "result": null, "subtraces": 0, "traceAddress": [], "type": "CALL" })"_json); } } TEST_CASE("StateDiff json serialization") { StateDiff state_diff; SECTION("basic") { CHECK(nlohmann::json(state_diff) == R"({ })"_json); } SECTION("with 1 entry") { StateDiffEntry entry; state_diff.insert(std::pair("item", entry)); CHECK(nlohmann::json(state_diff) == R"({ "item": { "balance": "=", "code": "=", "nonce": "=", "storage": {} } })"_json); } } TEST_CASE("DiffValue json serialization") { SECTION("no entries") { DiffValue dv; CHECK(nlohmann::json(dv) == R"("=")"_json); } SECTION("only from entry") { DiffValue dv{"0xe0a2bd4258d2768837baa26a28fe71dc079f84c7"}; CHECK(nlohmann::json(dv) == R"({ "-":"0xe0a2bd4258d2768837baa26a28fe71dc079f84c7" })"_json); } SECTION("only to entry") { DiffValue dv{{}, "0xe0a2bd4258d2768837baa26a28fe71dc079f84c8"}; CHECK(nlohmann::json(dv) == R"({ "+": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c8" })"_json); } SECTION("both entries") { DiffValue dv{"0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "0xe0a2bd4258d2768837baa26a28fe71dc079f84c8"}; CHECK(nlohmann::json(dv) == R"({ "*": { "from": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c7", "to": "0xe0a2bd4258d2768837baa26a28fe71dc079f84c8" } })"_json); } } TEST_CASE("copy_stack") { const size_t stack_size{32}; evmone::uint256 stack[stack_size] = { {0x00}, {0x01}, {0x02}, {0x03}, {0x04}, {0x05}, {0x06}, {0x07}, {0x08}, {0x09}, {0x0A}, {0x0B}, {0x0C}, {0x0D}, {0x0E}, {0x0F}, {0x10}, {0x11}, {0x12}, {0x13}, {0x14}, {0x15}, {0x16}, {0x17}, {0x18}, {0x19}, {0x1A}, {0x1B}, {0x1C}, {0x1D}, {0x1E}, {0x1F}}; evmone::uint256* top_stack = &stack[stack_size - 1]; SECTION("PUSHX") { for (std::uint8_t op_code = evmc_opcode::OP_PUSH1; op_code < evmc_opcode::OP_PUSH32 + 1; ++op_code) { std::vector trace_stack; copy_stack(op_code, top_stack, trace_stack); CHECK(trace_stack.size() == 1); CHECK(trace_stack[0] == "0x1f"); } } SECTION("OP_SWAPX") { for (std::uint8_t op_code = evmc_opcode::OP_SWAP1; op_code < evmc_opcode::OP_SWAP16 + 1; ++op_code) { std::vector trace_stack; copy_stack(op_code, top_stack, trace_stack); std::uint8_t size = op_code - evmc_opcode::OP_SWAP1 + 2; CHECK(trace_stack.size() == size); for (size_t idx = 0; idx < size; ++idx) { CHECK(trace_stack[idx] == "0x" + intx::to_string(stack[stack_size - size + idx], 16)); } } } SECTION("OP_DUPX") { for (std::uint8_t op_code = evmc_opcode::OP_DUP1; op_code < evmc_opcode::OP_DUP16 + 1; ++op_code) { std::vector trace_stack; copy_stack(op_code, top_stack, trace_stack); std::uint8_t size = op_code - evmc_opcode::OP_DUP1 + 2; CHECK(trace_stack.size() == size); for (size_t idx = 0; idx < size; ++idx) { CHECK(trace_stack[idx] == "0x" + intx::to_string(stack[stack_size - size + idx], 16)); } } } SECTION("OP_OTHER") { for (std::uint8_t op_code = evmc_opcode::OP_STOP; op_code < evmc_opcode::OP_SELFDESTRUCT; ++op_code) { std::vector trace_stack; switch (op_code) { case evmc_opcode::OP_PUSH1: case evmc_opcode::OP_PUSH2: case evmc_opcode::OP_PUSH3: case evmc_opcode::OP_PUSH4: case evmc_opcode::OP_PUSH5: case evmc_opcode::OP_PUSH6: case evmc_opcode::OP_PUSH7: case evmc_opcode::OP_PUSH8: case evmc_opcode::OP_PUSH9: case evmc_opcode::OP_PUSH10: case evmc_opcode::OP_PUSH11: case evmc_opcode::OP_PUSH12: case evmc_opcode::OP_PUSH13: case evmc_opcode::OP_PUSH14: case evmc_opcode::OP_PUSH15: case evmc_opcode::OP_PUSH16: case evmc_opcode::OP_PUSH17: case evmc_opcode::OP_PUSH18: case evmc_opcode::OP_PUSH19: case evmc_opcode::OP_PUSH20: case evmc_opcode::OP_PUSH21: case evmc_opcode::OP_PUSH22: case evmc_opcode::OP_PUSH23: case evmc_opcode::OP_PUSH24: case evmc_opcode::OP_PUSH25: case evmc_opcode::OP_PUSH26: case evmc_opcode::OP_PUSH27: case evmc_opcode::OP_PUSH28: case evmc_opcode::OP_PUSH29: case evmc_opcode::OP_PUSH30: case evmc_opcode::OP_PUSH31: case evmc_opcode::OP_PUSH32: case evmc_opcode::OP_SWAP1: case evmc_opcode::OP_SWAP2: case evmc_opcode::OP_SWAP3: case evmc_opcode::OP_SWAP4: case evmc_opcode::OP_SWAP5: case evmc_opcode::OP_SWAP6: case evmc_opcode::OP_SWAP7: case evmc_opcode::OP_SWAP8: case evmc_opcode::OP_SWAP9: case evmc_opcode::OP_SWAP10: case evmc_opcode::OP_SWAP11: case evmc_opcode::OP_SWAP12: case evmc_opcode::OP_SWAP13: case evmc_opcode::OP_SWAP14: case evmc_opcode::OP_SWAP15: case evmc_opcode::OP_SWAP16: case evmc_opcode::OP_DUP1: case evmc_opcode::OP_DUP2: case evmc_opcode::OP_DUP3: case evmc_opcode::OP_DUP4: case evmc_opcode::OP_DUP5: case evmc_opcode::OP_DUP6: case evmc_opcode::OP_DUP7: case evmc_opcode::OP_DUP8: case evmc_opcode::OP_DUP9: case evmc_opcode::OP_DUP10: case evmc_opcode::OP_DUP11: case evmc_opcode::OP_DUP12: case evmc_opcode::OP_DUP13: case evmc_opcode::OP_DUP14: case evmc_opcode::OP_DUP15: case evmc_opcode::OP_DUP16: break; case evmc_opcode::OP_CALLDATALOAD: case evmc_opcode::OP_SLOAD: case evmc_opcode::OP_MLOAD: case evmc_opcode::OP_CALLDATASIZE: case evmc_opcode::OP_LT: case evmc_opcode::OP_GT: case evmc_opcode::OP_DIV: case evmc_opcode::OP_SDIV: case evmc_opcode::OP_SAR: case evmc_opcode::OP_AND: case evmc_opcode::OP_EQ: case evmc_opcode::OP_CALLVALUE: case evmc_opcode::OP_ISZERO: case evmc_opcode::OP_ADD: case evmc_opcode::OP_EXP: case evmc_opcode::OP_CALLER: case evmc_opcode::OP_KECCAK256: case evmc_opcode::OP_SUB: case evmc_opcode::OP_ADDRESS: case evmc_opcode::OP_GAS: case evmc_opcode::OP_MUL: case evmc_opcode::OP_RETURNDATASIZE: case evmc_opcode::OP_NOT: case evmc_opcode::OP_SHR: case evmc_opcode::OP_SHL: case evmc_opcode::OP_EXTCODESIZE: case evmc_opcode::OP_SLT: case evmc_opcode::OP_OR: case evmc_opcode::OP_NUMBER: case evmc_opcode::OP_PC: case evmc_opcode::OP_TIMESTAMP: case evmc_opcode::OP_BALANCE: case evmc_opcode::OP_SELFBALANCE: case evmc_opcode::OP_MULMOD: case evmc_opcode::OP_ADDMOD: case evmc_opcode::OP_BASEFEE: case evmc_opcode::OP_BLOCKHASH: case evmc_opcode::OP_BYTE: case evmc_opcode::OP_XOR: case evmc_opcode::OP_ORIGIN: case evmc_opcode::OP_CODESIZE: case evmc_opcode::OP_MOD: case evmc_opcode::OP_SIGNEXTEND: case evmc_opcode::OP_GASLIMIT: case evmc_opcode::OP_PREVRANDAO: case evmc_opcode::OP_SGT: case evmc_opcode::OP_GASPRICE: case evmc_opcode::OP_MSIZE: case evmc_opcode::OP_EXTCODEHASH: case evmc_opcode::OP_STATICCALL: case evmc_opcode::OP_DELEGATECALL: case evmc_opcode::OP_CALL: case evmc_opcode::OP_CALLCODE: case evmc_opcode::OP_CREATE: case evmc_opcode::OP_CREATE2: case evmc_opcode::OP_COINBASE: case evmc_opcode::OP_CHAINID: case evmc_opcode::OP_SMOD: copy_stack(op_code, top_stack, trace_stack); CHECK(trace_stack.size() == 1); CHECK(trace_stack[0] == "0x1f"); break; default: copy_stack(op_code, top_stack, trace_stack); CHECK(trace_stack.empty()); break; } } } } TEST_CASE("copy_memory") { evmone::Memory memory; for (std::uint8_t idx = 0; idx < 16; ++idx) { memory[idx] = idx; } SECTION("TRACE_MEMORY NOT SET") { std::optional trace_memory; copy_memory(memory, trace_memory); CHECK(trace_memory.has_value() == false); } SECTION("TRACE_MEMORY LEN == 0") { std::optional trace_memory = TraceMemory{0, 0}; copy_memory(memory, trace_memory); CHECK(trace_memory.has_value() == false); } SECTION("TRACE_MEMORY LEN != 0") { std::optional trace_memory = TraceMemory{0, 10}; copy_memory(memory, trace_memory); CHECK(trace_memory.has_value() == true); CHECK(nlohmann::json(trace_memory.value()) == R"({ "off":0, "data":"0x00010203040506070809" })"_json); } } TEST_CASE("copy_store") { const size_t stack_size{32}; evmone::uint256 stack[stack_size] = { {0x00}, {0x01}, {0x02}, {0x03}, {0x04}, {0x05}, {0x06}, {0x07}, {0x08}, {0x09}, {0x0A}, {0x0B}, {0x0C}, {0x0D}, {0x0E}, {0x0F}, {0x10}, {0x11}, {0x12}, {0x13}, {0x14}, {0x15}, {0x16}, {0x17}, {0x18}, {0x19}, {0x1A}, {0x1B}, {0x1C}, {0x1D}, {0x1E}, {0x1F}}; evmone::uint256* top_stack = &stack[stack_size - 1]; SECTION("op_code == OP_SSTORE") { std::optional trace_storage; copy_store(evmc_opcode::OP_SSTORE, top_stack, trace_storage); CHECK(trace_storage.has_value() == true); CHECK(nlohmann::json(trace_storage.value()) == R"({ "key":"0x1f", "val":"0x1e" })"_json); } SECTION("op_code != OP_SSTORE") { std::optional trace_storage; copy_store(evmc_opcode::OP_CALLDATASIZE, top_stack, trace_storage); CHECK(trace_storage.has_value() == false); } } TEST_CASE("copy_memory_offset_len") { const size_t stack_size{32}; evmone::uint256 stack[stack_size] = { {0x00}, {0x01}, {0x02}, {0x03}, {0x04}, {0x05}, {0x06}, {0x07}, {0x08}, {0x09}, {0x0A}, {0x0B}, {0x0C}, {0x0D}, {0x0E}, {0x0F}, {0x10}, {0x11}, {0x12}, {0x13}, {0x14}, {0x15}, {0x16}, {0x17}, {0x18}, {0x19}, {0x1A}, {0x1B}, {0x1C}, {0x1D}, {0x1E}, {0x1F}}; evmone::uint256* top_stack = &stack[stack_size - 1]; for (std::uint8_t op_code = evmc_opcode::OP_STOP; op_code < evmc_opcode::OP_SELFDESTRUCT; ++op_code) { std::optional trace_memory; copy_memory_offset_len(op_code, top_stack, trace_memory); switch (op_code) { case evmc_opcode::OP_MSTORE: case evmc_opcode::OP_MLOAD: CHECK(trace_memory.has_value() == true); CHECK(nlohmann::json(trace_memory.value()) == R"({ "data":"", "off": 31 })"_json); break; case evmc_opcode::OP_MSTORE8: CHECK(trace_memory.has_value() == true); CHECK(nlohmann::json(trace_memory.value()) == R"({ "data":"", "off": 31 })"_json); break; case evmc_opcode::OP_RETURNDATACOPY: case evmc_opcode::OP_CALLDATACOPY: case evmc_opcode::OP_CODECOPY: CHECK(trace_memory.has_value() == true); CHECK(nlohmann::json(trace_memory.value()) == R"({ "data":"", "off": 31 })"_json); break; case evmc_opcode::OP_STATICCALL: case evmc_opcode::OP_DELEGATECALL: CHECK(trace_memory.has_value() == true); CHECK(nlohmann::json(trace_memory.value()) == R"({ "data":"", "off": 27 })"_json); break; case evmc_opcode::OP_CALL: case evmc_opcode::OP_CALLCODE: CHECK(trace_memory.has_value() == true); CHECK(nlohmann::json(trace_memory.value()) == R"({ "data":"", "off": 26 })"_json); break; case evmc_opcode::OP_CREATE: case evmc_opcode::OP_CREATE2: CHECK(trace_memory.has_value() == true); CHECK(nlohmann::json(trace_memory.value()) == R"({ "data":"", "off": 0 })"_json); break; default: CHECK(trace_memory.has_value() == false); break; } } } TEST_CASE("push_memory_offset_len") { const size_t stack_size{32}; evmone::uint256 stack[stack_size] = { {0x00}, {0x01}, {0x02}, {0x03}, {0x04}, {0x05}, {0x06}, {0x07}, {0x08}, {0x09}, {0x0A}, {0x0B}, {0x0C}, {0x0D}, {0x0E}, {0x0F}, {0x10}, {0x11}, {0x12}, {0x13}, {0x14}, {0x15}, {0x16}, {0x17}, {0x18}, {0x19}, {0x1A}, {0x1B}, {0x1C}, {0x1D}, {0x1E}, {0x1F}}; evmone::uint256* top_stack = &stack[stack_size - 1]; for (std::uint8_t op_code = evmc_opcode::OP_STOP; op_code < evmc_opcode::OP_SELFDESTRUCT; ++op_code) { std::stack tms; push_memory_offset_len(op_code, top_stack, tms); switch (op_code) { case evmc_opcode::OP_STATICCALL: case evmc_opcode::OP_DELEGATECALL: CHECK(tms.size() == 1); CHECK(nlohmann::json(tms.top()) == R"({ "data":"", "off": 27 })"_json); break; case evmc_opcode::OP_CALL: case evmc_opcode::OP_CALLCODE: CHECK(tms.size() == 1); CHECK(nlohmann::json(tms.top()) == R"({ "data":"", "off": 26 })"_json); break; case evmc_opcode::OP_CREATE: case evmc_opcode::OP_CREATE2: CHECK(tms.size() == 1); CHECK(nlohmann::json(tms.top()) == R"({ "data":"", "off": 0 })"_json); break; default: CHECK(tms.empty()); break; } } } TEST_CASE("to_string") { SECTION("value == 0") { auto out = to_string(intx::uint256{0}); CHECK(out == "0x0000000000000000000000000000000000000000000000000000000000000000"); } SECTION("value == 1") { auto out = to_string(intx::uint256{1}); CHECK(out == "0x0000000000000000000000000000000000000000000000000000000000000001"); } SECTION("value == 1") { auto out = to_string(intx::uint256{0xdeadbeaf}); CHECK(out == "0x00000000000000000000000000000000000000000000000000000000deadbeaf"); } } TEST_CASE("TraceConfig") { SECTION("dump on stream") { TraceConfig config{true, false, true}; std::ostringstream os; os << config; CHECK(os.str() == "vmTrace: true Trace: false stateDiff: true"); } SECTION("json deserialization: empty") { nlohmann::json json = R"([])"_json; TraceConfig config; from_json(json, config); CHECK(config.trace == false); CHECK(config.vm_trace == false); CHECK(config.state_diff == false); } SECTION("json deserialization: full") { nlohmann::json json = R"(["trace", "vmTrace", "stateDiff"])"_json; TraceConfig config; from_json(json, config); CHECK(config.trace == true); CHECK(config.vm_trace == true); CHECK(config.state_diff == true); } } TEST_CASE("TraceFilter") { SECTION("dump on stream: simple") { TraceFilter config; std::ostringstream os; os << config; CHECK(os.str() == "from_block: 0x0, to_block: latest, after: 0, count: 4294967295"); } SECTION("dump on stream: full") { TraceFilter config; config.from_addresses.push_back(0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030_address); config.to_addresses.push_back(0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7031_address); config.mode = "union"; std::ostringstream os; os << config; CHECK(os.str() == "from_block: 0x0, to_block: latest, from_addresses: [0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7030, ], " "to_addresses: [0x0a6bb546b9208cfab9e8fa2b9b2c042b18df7031, ], mode: union, after: 0, count: 4294967295"); } SECTION("json deserialization: simple") { nlohmann::json json = R"({ "after": 18, "count": 10, "fromBlock": "0x6DDD00", "toBlock": "latest" })"_json; TraceFilter config = json; CHECK(config.after == 18); CHECK(config.count == 10); CHECK(config.from_block.is_number() == true); CHECK(config.from_block.number() == 0x6DDD00); CHECK(config.to_block.is_tag() == true); CHECK(config.to_block.tag() == "latest"); CHECK(config.from_addresses.empty()); CHECK(config.to_addresses.empty()); CHECK(!config.mode); } SECTION("json deserialization: full") { nlohmann::json json = R"({ "after": 18, "count": 10, "fromAddress": [ "0xd05526a73bf45dadf7f9a99dcceac23c2d43c6c7" ], "fromBlock": "0x6DDD00", "toAddress": [ "0x11fe4b6ae13d2a6055c8d9cf65c55bac32b5d844" ], "toBlock": "latest", "mode": "union" })"_json; TraceFilter config; from_json(json, config); CHECK(config.after == 18); CHECK(config.count == 10); CHECK(config.from_block.is_number() == true); CHECK(config.from_block.number() == 0x6DDD00); CHECK(config.to_block.is_tag() == true); CHECK(config.from_addresses.size() == 1); CHECK(config.from_addresses[0] == 0xd05526a73bf45dadf7f9a99dcceac23c2d43c6c7_address); CHECK(config.to_addresses.size() == 1); CHECK(config.to_addresses[0] == 0x11fe4b6ae13d2a6055c8d9cf65c55bac32b5d844_address); CHECK(config.mode); CHECK(config.mode.value() == "union"); } } TEST_CASE("TraceCall") { SECTION("json deserialization") { nlohmann::json json = R"([ { "from": "0x8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9", "to": "0x5e1f0c9ddbe3cb57b80c933fab5151627d7966fa", "gas": "0x7530", "gasPrice": "0x3b9aca00", "value": "0x2FAF080", "data": "0x01" }, ["trace", "vmTrace", "stateDiff"] ])"_json; TraceCall trace_call; from_json(json, trace_call); CHECK(trace_call.call.from == 0x8ced5ad0d8da4ec211c17355ed3dbfec4cf0e5b9_address); CHECK(trace_call.call.to == 0x5e1f0c9ddbe3cb57b80c933fab5151627d7966fa_address); CHECK(trace_call.call.gas == 0x7530); CHECK(trace_call.call.gas_price == 0x3b9aca00); CHECK(trace_call.call.value == 0x2FAF080); CHECK(trace_call.call.data == *silkworm::from_hex("01")); CHECK(trace_call.trace_config.trace == true); CHECK(trace_call.trace_config.vm_trace == true); CHECK(trace_call.trace_config.state_diff == true); } } TEST_CASE("TraceCallTraces: json serialization") { TraceCallTraces tct; tct.output = "0xdeadbeaf"; SECTION("with transaction_hash") { tct.transaction_hash = 0xe0d4933284f1254835aac8823535278f0eb9608b137266cf3d3d8df8240bbe48_bytes32; CHECK(nlohmann::json(tct) == R"({ "output": "0xdeadbeaf", "stateDiff": null, "trace": [], "transactionHash": "0xe0d4933284f1254835aac8823535278f0eb9608b137266cf3d3d8df8240bbe48", "vmTrace": null })"_json); } SECTION("with state_diff") { tct.state_diff = StateDiff{}; CHECK(nlohmann::json(tct) == R"({ "output": "0xdeadbeaf", "stateDiff": {}, "trace": [], "vmTrace": null })"_json); } SECTION("with trace") { tct.trace.push_back(Trace{}); CHECK(nlohmann::json(tct) == R"({ "output": "0xdeadbeaf", "stateDiff": null, "trace": [ { "action": { "from": "0x0000000000000000000000000000000000000000", "gas": "0x0", "value": "0x0" }, "result": null, "subtraces": 0, "traceAddress": [], "type": "" } ], "vmTrace": null })"_json); } SECTION("with vm_trace") { tct.vm_trace = VmTrace{}; CHECK(nlohmann::json(tct) == R"({ "output": "0xdeadbeaf", "stateDiff": null, "trace": [], "vmTrace": { "code": "0x", "ops": [] } })"_json); } } TEST_CASE("TraceCallResult: json serialization") { TraceCallResult tcr; SECTION("with traces") { tcr.traces = TraceCallTraces{}; CHECK(nlohmann::json(tcr) == R"({ "output": "0x", "stateDiff": null, "trace": [], "vmTrace": null })"_json); } } TEST_CASE("TraceManyCallResult: json serialization") { TraceManyCallResult tmcr; SECTION("with traces") { tmcr.traces.push_back(TraceCallTraces{}); CHECK(nlohmann::json(tmcr) == R"([ { "output": "0x", "stateDiff": null, "trace": [], "vmTrace": null } ])"_json); } } #endif // !defined(SILKWORM_SANITIZE) && !defined(_WIN32) } // namespace silkworm::rpc::trace ================================================ FILE: silkworm/rpc/core/fee_history_oracle.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "fee_history_oracle.hpp" #include #include #include #include #include #include namespace silkworm::rpc::fee_history { void to_json(nlohmann::json& json, const Rewards& rewards) { std::vector rewards_list; rewards_list.reserve(rewards.size()); for (const auto& reward : rewards) { rewards_list.push_back(to_quantity(reward)); } json = rewards_list; } void to_json(nlohmann::json& json, const FeeHistory& fh) { if (fh.gas_used_ratio.empty()) { json["gasUsedRatio"] = nullptr; } else { json["gasUsedRatio"] = fh.gas_used_ratio; } if (fh.blob_gas_used_ratio.empty()) { json["blobGasUsedRatio"] = nullptr; } else { json["blobGasUsedRatio"] = fh.blob_gas_used_ratio; } json["oldestBlock"] = to_quantity(fh.oldest_block); if (!fh.base_fees_per_gas.empty()) { std::vector fee_string_list; fee_string_list.reserve(fh.base_fees_per_gas.size()); for (const auto& fee : fh.base_fees_per_gas) { fee_string_list.push_back(to_quantity(fee)); } json["baseFeePerGas"] = fee_string_list; } if (!fh.blob_base_fees_per_gas.empty()) { std::vector blob_fee_string_list; blob_fee_string_list.reserve(fh.blob_base_fees_per_gas.size()); for (const auto& fee : fh.blob_base_fees_per_gas) { blob_fee_string_list.push_back(to_quantity(fee)); } json["baseFeePerBlobGas"] = blob_fee_string_list; } if (!fh.rewards.empty()) { // Don't call reserve here to preallocate vector - since json value is dynamic it doesn't know yet how much it should allocate! // -> Don't uncomment this line json_list.reserve(fh.rewards.size()); std::vector json_list; for (const auto& rewards : fh.rewards) { nlohmann::json item; to_json(item, rewards); json_list.push_back(item); } json["reward"] = json_list; } } Task FeeHistoryOracle::fee_history(BlockNum newest_block, BlockNum block_count, const std::vector& reward_percentiles) { FeeHistory fee_history; if (block_count < 1) { co_return fee_history; } if (block_count > kDefaultMaxFeeHistory) { SILK_WARN << "FeeHistoryOracle::fee_history fee history length too long: requested " << block_count << " truncated to " << kDefaultMaxFeeHistory; block_count = kDefaultMaxFeeHistory; } for (size_t idx = 0; idx < reward_percentiles.size(); ++idx) { if (reward_percentiles[idx] < 0 || reward_percentiles[idx] > 100) { std::ostringstream ss; ss << "ErrInvalidPercentile: " << std::dec << reward_percentiles[idx]; fee_history.error = ss.str(); co_return fee_history; } if (idx > 0 && reward_percentiles[idx] < reward_percentiles[idx - 1]) { std::ostringstream ss; ss << "ErrInvalidPercentile: #" << idx - 1 << ":" << reward_percentiles[idx - 1] << "> #" << idx << ":" << reward_percentiles[idx]; fee_history.error = ss.str(); co_return fee_history; } } // Only process blocks if reward percentiles were requested const auto max_history = reward_percentiles.empty() ? kDefaultMaxHeaderHistory : kDefaultMaxBlockHistory; const auto block_range = co_await resolve_block_range(newest_block, block_count, max_history); if (block_range.num_blocks == 0) { if (block_range.error) { fee_history.error = block_range.error.value(); } co_return fee_history; } fee_history.rewards.resize(block_range.num_blocks); fee_history.base_fees_per_gas.resize(block_range.num_blocks + 1); fee_history.blob_base_fees_per_gas.resize(block_range.num_blocks + 1); fee_history.gas_used_ratio.resize(block_range.num_blocks); fee_history.blob_gas_used_ratio.resize(block_range.num_blocks); const auto oldest_block_num = block_range.last_block_num + 1 - block_range.num_blocks; auto first_missing = block_range.num_blocks; for (auto idx = block_range.num_blocks, next = oldest_block_num; idx > 0; --idx) { const auto block_num = ++next - 1; if (block_num > block_range.last_block_num) { continue; } BlockFees block_fees{block_num}; if (!reward_percentiles.empty()) { block_fees.block = co_await block_provider_(block_num); // block_range.last_block; if (!block_fees.block) { continue; } block_fees.receipts = *co_await receipts_provider_(*block_fees.block); block_fees.block_header = block_fees.block->block.header; } else { const auto block_header = co_await block_header_provider_(block_num); if (!block_header) { continue; } block_fees.block_header = block_header; } co_await process_block(block_fees, reward_percentiles); ensure(block_fees.block_num >= oldest_block_num, "fee_history: block_num lower than oldest"); const auto index = block_fees.block_num - oldest_block_num; if (block_fees.block_header) { fee_history.rewards[index] = block_fees.rewards; fee_history.base_fees_per_gas[index] = block_fees.base_fee; fee_history.blob_base_fees_per_gas[index] = block_fees.blob_base_fee; fee_history.base_fees_per_gas[index + 1] = block_fees.next_base_fee; fee_history.blob_base_fees_per_gas[index + 1] = block_fees.next_blob_base_fee; fee_history.gas_used_ratio[index] = block_fees.gas_used_ratio; fee_history.blob_gas_used_ratio[index] = block_fees.blob_gas_used_ratio; } else { // Getting no block and no error means we are requesting into the future (might happen because of a reorg) first_missing = std::min(first_missing, index); } } if (first_missing == 0) { co_return FeeHistory{}; } if (!reward_percentiles.empty()) { fee_history.rewards.resize(first_missing); } else { fee_history.rewards.clear(); } fee_history.base_fees_per_gas.resize(first_missing + 1); fee_history.blob_base_fees_per_gas.resize(first_missing + 1); fee_history.gas_used_ratio.resize(first_missing); fee_history.blob_gas_used_ratio.resize(first_missing); fee_history.oldest_block = oldest_block_num; co_return fee_history; } Task FeeHistoryOracle::resolve_block_range(BlockNum newest_block, uint64_t block_count, uint64_t max_history) { const auto latest_block_num = co_await latest_block_provider_(); if (newest_block > latest_block_num) { std::ostringstream oss; oss << "request beyond head block: requested " << std::dec << newest_block << ", head " << latest_block_num; co_return BlockRange{0, 0, oss.str()}; } if (max_history != 0) { // Limit retrieval to the given number of latest blocks const auto too_old_count = latest_block_num - max_history - newest_block + block_count; if (too_old_count > 0) { // too_old_count is the number of requested blocks that are too old to be served if (block_count > too_old_count) { block_count -= too_old_count; } else { co_return BlockRange{0}; } } } // Ensure not trying to retrieve before genesis block_count = std::min(block_count, newest_block + 1); co_return BlockRange{block_count, newest_block}; } bool sort_by_reward(std::pair& p1, const std::pair& p2) { return (p1.first < p2.first); } Task FeeHistoryOracle::process_block(BlockFees& block_fees, const std::vector& reward_percentiles) { auto& header = *(block_fees.block_header); auto next_block_num = header.number + 1; block_fees.base_fee = header.base_fee_per_gas.value_or(0); if (config_.is_london(next_block_num)) { block_fees.next_base_fee = protocol::expected_base_fee_per_gas(header); } else { block_fees.next_base_fee = 0; // EIP-4844 blob gas cost (calc_data_fee)block_fees.next_blob_base_fee } block_fees.blob_base_fee = header.blob_gas_price().value_or(0); if (header.excess_blob_gas) { // EIP-7691: Blob throughput increase const auto revision = config_.revision(header.number, header.timestamp); block_fees.next_blob_base_fee = calc_blob_gas_price(protocol::calc_excess_blob_gas(header, revision), revision); } else { block_fees.next_blob_base_fee = 0; } block_fees.gas_used_ratio = static_cast(header.gas_used) / static_cast(header.gas_limit); if (reward_percentiles.empty()) { co_return; // rewards were not requested, return } if (header.blob_gas_used) { // EIP-7691: Blob throughput increase const auto max_blob_gas_per_block = config_.is_prague(header.number, header.timestamp) ? protocol::kMaxBlobGasPerBlockPrague : protocol::kMaxBlobGasPerBlock; block_fees.blob_gas_used_ratio = static_cast(*(header.blob_gas_used)) / static_cast(max_blob_gas_per_block); } if (block_fees.receipts.size() != block_fees.block->block.transactions.size()) { co_return; } if (block_fees.block->block.transactions.empty()) { std::fill(block_fees.rewards.begin(), block_fees.rewards.end(), 0); // return an all zero row if there are no transactions to gather data from for (size_t idx = 0; idx < reward_percentiles.size(); ++idx) { block_fees.rewards.emplace_back(0); } co_return; } std::vector > rewards_and_gas; for (size_t idx = 0; idx < block_fees.block->block.transactions.size(); ++idx) { auto& txn = block_fees.block->block.transactions[idx]; const auto reward{txn.max_fee_per_gas >= block_fees.base_fee ? txn.effective_gas_price(block_fees.base_fee) - block_fees.base_fee : txn.max_priority_fee_per_gas}; rewards_and_gas.emplace_back(reward, block_fees.receipts[idx]->gas_used); } sort(rewards_and_gas.begin(), rewards_and_gas.end(), sort_by_reward); auto index = rewards_and_gas.begin(); const auto last = --rewards_and_gas.end(); auto sum_gas_used = index->second; for (const auto percentile : reward_percentiles) { const uint64_t threshold_gas_used = header.gas_used * static_cast(percentile) / 100; while (sum_gas_used < threshold_gas_used && index != last) { ++index; sum_gas_used += index->second; } block_fees.rewards.push_back(index->first); } co_return; } } // namespace silkworm::rpc::fee_history ================================================ FILE: silkworm/rpc/core/fee_history_oracle.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::fee_history { using BlockHeaderProvider = std::function>(BlockNum)>; using BlockProvider = std::function>(BlockNum)>; using ReceiptsProvider = std::function>(const BlockWithHash&)>; using LatestBlockProvider = std::function()>; using Rewards = std::vector; struct FeeHistory { BlockNum oldest_block{0}; std::vector base_fees_per_gas; std::vector gas_used_ratio; std::vector rewards; std::vector blob_gas_used_ratio; std::vector blob_base_fees_per_gas; std::optional error{std::nullopt}; }; void to_json(nlohmann::json& json, const FeeHistory& fh); struct BlockRange { uint64_t num_blocks{0}; BlockNum last_block_num{0}; std::optional error; }; struct BlockFees { BlockNum block_num{0}; std::optional block_header; std::shared_ptr block; // only set if reward percentiles are requested rpc::Receipts receipts; Rewards rewards; intx::uint256 base_fee; intx::uint256 next_base_fee; intx::uint256 blob_base_fee; intx::uint256 next_blob_base_fee; double gas_used_ratio{0}; double blob_gas_used_ratio{0}; }; class FeeHistoryOracle { public: explicit FeeHistoryOracle(const silkworm::ChainConfig& config, const BlockHeaderProvider& header_provider, const BlockProvider& block_provider, ReceiptsProvider& receipts_provider, LatestBlockProvider& latest_block_provider) : config_{config}, block_header_provider_(header_provider), block_provider_(block_provider), receipts_provider_(receipts_provider), latest_block_provider_{latest_block_provider} {} virtual ~FeeHistoryOracle() = default; FeeHistoryOracle(const FeeHistoryOracle&) = delete; FeeHistoryOracle& operator=(const FeeHistoryOracle&) = delete; Task fee_history(BlockNum newest_block, BlockNum block_count, const std::vector& reward_percentiles); private: static constexpr std::uint32_t kDefaultMaxFeeHistory{1024}; static constexpr std::uint32_t kDefaultMaxHeaderHistory{0}; static constexpr std::uint32_t kDefaultMaxBlockHistory{0}; Task resolve_block_range(BlockNum newest_block, uint64_t block_count, uint64_t max_history); Task process_block(BlockFees& block_fees, const std::vector& reward_percentiles); const silkworm::ChainConfig& config_; const BlockHeaderProvider& block_header_provider_; const BlockProvider& block_provider_; const ReceiptsProvider& receipts_provider_; const LatestBlockProvider& latest_block_provider_; }; } // namespace silkworm::rpc::fee_history ================================================ FILE: silkworm/rpc/core/fee_history_oracle_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "fee_history_oracle.hpp" #include #include #include namespace silkworm::rpc::fee_history { TEST_CASE("FeeHistory: json serialization") { SECTION("default value") { FeeHistory fh; CHECK(nlohmann::json(fh) == R"({ "gasUsedRatio":null, "blobGasUsedRatio":null, "oldestBlock":"0x0" })"_json); } SECTION("built value") { FeeHistory fh{ 0x867a80, {0x13c723946e, 0x163fe26534}, {0.9998838666666666}, {{0x59682f00, 0x9502f900}}}; CHECK(nlohmann::json(fh) == R"({ "baseFeePerGas":["0x13c723946e","0x163fe26534"], "blobGasUsedRatio":null, "blobGasUsedRatio":null, "gasUsedRatio":[0.9998838666666666], "oldestBlock":"0x867a80", "reward":[ ["0x59682f00","0x9502f900"] ] })"_json); } } } // namespace silkworm::rpc::fee_history ================================================ FILE: silkworm/rpc/core/filter_storage.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "filter_storage.hpp" #include #include namespace silkworm::rpc { std::mt19937_64 random_engine{std::random_device{}()}; Generator default_generator = []() { return random_engine(); }; FilterStorage::FilterStorage(size_t max_size, double max_filter_age) : generator_{default_generator}, max_size_{max_size}, max_filter_age_{max_filter_age} {} FilterStorage::FilterStorage(Generator& generator, size_t max_size, double max_filter_age) : generator_{generator}, max_size_{max_size}, max_filter_age_{max_filter_age} {} std::optional FilterStorage::add_filter(const StoredFilter& filter) { std::scoped_lock lock{mutex_}; if (storage_.size() >= max_size_) { clean_up(); } if (storage_.size() >= max_size_) { SILK_WARN << "No room available in storage, max size " << max_size_ << " reached"; return std::nullopt; } FilterEntry entry{filter}; std::string filter_id; bool slot_found{false}; size_t count{0}; while (max_size_ > count++) { filter_id = to_quantity(generator_()); slot_found = storage_.find(filter_id) == storage_.end(); if (slot_found) { break; } } if (!slot_found) { SILK_WARN << "Unable to generate a new filter_id without clashing"; return std::nullopt; } storage_.emplace(filter_id, entry); return filter_id; } bool FilterStorage::remove_filter(const std::string& filter_id) { std::scoped_lock lock{mutex_}; const auto itr = storage_.find(filter_id); if (itr == storage_.end()) { return false; } storage_.erase(itr); return true; } std::optional> FilterStorage::get_filter(const std::string& filter_id) { std::scoped_lock lock{mutex_}; clean_up(); const auto itr = storage_.find(filter_id); if (itr == storage_.end()) { return std::nullopt; } auto age = itr->second.age(); if (age > max_filter_age_) { SILK_TRACE << "Filter " << filter_id << " exhausted: removed"; storage_.erase(itr); return std::nullopt; } itr->second.renew(); return itr->second.filter; } void FilterStorage::clean_up() { auto itr = storage_.begin(); while (itr != storage_.end()) { auto age = itr->second.age(); if (age > max_filter_age_) { SILK_TRACE << "Filter " << itr->first << " exhausted: removed"; itr = storage_.erase(itr); } else { ++itr; } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/filter_storage.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { inline constexpr size_t kDefaultFilterStorageSize = 1024; // default filter storage size, ie max num for filters in storage inline constexpr size_t kDefaultMaxFilterAge = 900; // lasting time for unused filters in seconds (15 min) enum FilterType { kLogs, kBlock }; struct StoredFilter : public Filter { FilterType type = FilterType::kLogs; uint64_t start = std::numeric_limits::max(); uint64_t end = std::numeric_limits::max(); std::vector logs; }; struct FilterEntry { void renew() { last_access = std::chrono::system_clock::now(); } std::chrono::duration age() const { return std::chrono::system_clock::now() - last_access; } StoredFilter filter; std::chrono::system_clock::time_point last_access = std::chrono::system_clock::now(); }; using Generator = std::function; class FilterStorage { public: explicit FilterStorage(size_t max_size, double max_filter_age = kDefaultMaxFilterAge); explicit FilterStorage(Generator& generator, size_t max_size, double max_filter_age = kDefaultMaxFilterAge); FilterStorage(const FilterStorage&) = delete; FilterStorage& operator=(const FilterStorage&) = delete; std::optional add_filter(const StoredFilter& filter); bool remove_filter(const std::string& filter_id); std::optional> get_filter(const std::string& filter_id); auto size() const { return storage_.size(); } private: void clean_up(); Generator& generator_; size_t max_size_; std::chrono::duration max_filter_age_; std::mutex mutex_; std::map storage_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/filter_storage_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "filter_storage.hpp" #include #include #include #include #include namespace silkworm::rpc { TEST_CASE("FilterStorage base") { FilterStorage filter_storage{3, 0.01}; SECTION("adding 1 entry") { StoredFilter filter; const auto filter_id = filter_storage.add_filter(filter); CHECK(filter_id.has_value() == true); CHECK(filter_storage.size() == 1); } SECTION("getting 1 entry") { auto json = R"({ "address": "0x6090a6e47849629b7245dfa1ca21d94cd15878ef", "fromBlock": "0x3d0000", "toBlock": "0x3d2600" })"_json; const auto filter_id = filter_storage.add_filter(json); const auto filter = filter_storage.get_filter(filter_id.value()); CHECK(filter.has_value() == true); const nlohmann::json result = filter.value(); CHECK(result == json); } SECTION("removing 1 entry") { StoredFilter filter; const auto filter_id = filter_storage.add_filter(filter); auto result = filter_storage.remove_filter(filter_id.value()); CHECK(result == true); CHECK(filter_storage.size() == 0); } SECTION("adding 2 entries") { StoredFilter filter; const auto filter_id_1 = filter_storage.add_filter(filter); const auto filter_id_2 = filter_storage.add_filter(filter); CHECK(filter_id_1.has_value() == true); CHECK(filter_id_2.has_value() == true); CHECK(filter_id_1.value() != filter_id_2.value()); CHECK(filter_storage.size() == 2); } SECTION("adding 3 entries") { StoredFilter filter; filter_storage.add_filter(filter); filter_storage.add_filter(filter); const auto filter_id = filter_storage.add_filter(filter); CHECK(filter_id.has_value() == true); CHECK(filter_storage.size() == 3); } SECTION("adding too many entries") { StoredFilter filter; filter_storage.add_filter(filter); filter_storage.add_filter(filter); filter_storage.add_filter(filter); const auto filter_id = filter_storage.add_filter(filter); CHECK(filter_id.has_value() == false); CHECK(filter_storage.size() == 3); } SECTION("filter expires") { StoredFilter filter; const auto filter_id = filter_storage.add_filter(filter); std::this_thread::sleep_for(std::chrono::milliseconds(100)); const auto filter_opt = filter_storage.get_filter(filter_id.value()); CHECK(filter_opt.has_value() == false); CHECK(filter_storage.size() == 0); } SECTION("filters expire") { StoredFilter filter; filter_storage.add_filter(filter); filter_storage.add_filter(filter); filter_storage.add_filter(filter); std::this_thread::sleep_for(std::chrono::milliseconds(100)); const auto filter_id = filter_storage.add_filter(filter); CHECK(filter_id.has_value() == true); CHECK(filter_storage.size() == 1); } } TEST_CASE("FilterStorage enhanced") { std::uint64_t count = 0; std::uint64_t max_keys = 3; Generator default_generator = [&]() { return count++ % max_keys; }; FilterStorage filter_storage{default_generator, 2 * max_keys, 1}; SECTION("keys OK") { StoredFilter filter; filter_storage.add_filter(filter); filter_storage.add_filter(filter); const auto filter_id = filter_storage.add_filter(filter); CHECK(filter_id.has_value() == true); CHECK(filter_storage.size() == 3); } SECTION("no more keys") { StoredFilter filter; filter_storage.add_filter(filter); filter_storage.add_filter(filter); filter_storage.add_filter(filter); const auto filter_id = filter_storage.add_filter(filter); CHECK(filter_id.has_value() == false); CHECK(filter_storage.size() == 3); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/gas_price_oracle.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "gas_price_oracle.hpp" #include #include #include #include #include namespace silkworm::rpc { struct PriceComparator { bool operator()(const intx::uint256& p1, const intx::uint256& p2) const { return p1 < p2; } }; Task GasPriceOracle::suggested_price(BlockNum block_num) { SILK_TRACE << "GasPriceOracle::suggested_price starting block: " << block_num; std::vector tx_prices; tx_prices.reserve(kMaxSamples); while (tx_prices.size() < kMaxSamples && block_num > 0) { co_await load_block_prices(block_num, kSamples, tx_prices); --block_num; } SILK_TRACE << "GasPriceOracle::suggested_price ending block: " << block_num; std::sort(tx_prices.begin(), tx_prices.end(), PriceComparator()); intx::uint256 price = kDefaultPrice; if (!tx_prices.empty()) { auto position = (tx_prices.size() - 1) * kPercentile / 100; SILK_TRACE << "GasPriceOracle::suggested_price getting price in position: " << position; if (tx_prices.size() > position) { price = tx_prices[position]; } } if (price > kDefaultMaxPrice) { SILK_TRACE << "GasPriceOracle::suggested_price price to high: set to 0x" << intx::hex(kDefaultMaxPrice); price = kDefaultMaxPrice; } SILK_TRACE << "GasPriceOracle::suggested_price price: 0x" << intx::hex(price); co_return price; } Task GasPriceOracle::load_block_prices(BlockNum block_num, uint64_t limit, std::vector& tx_prices) { SILK_TRACE << "GasPriceOracle::load_block_prices processing block: " << block_num; const auto block_with_hash = co_await block_provider_(block_num); if (!block_with_hash) { throw std::invalid_argument("GasPriceOracle::load_block_prices invalid block number"); } const auto& base_fee = block_with_hash->block.header.base_fee_per_gas.value_or(0); const auto& coinbase = block_with_hash->block.header.beneficiary; SILK_TRACE << "GasPriceOracle::load_block_prices # transactions in block: " << block_with_hash->block.transactions.size(); SILK_TRACE << "GasPriceOracle::load_block_prices # block base_fee: 0x" << intx::hex(base_fee); SILK_TRACE << "GasPriceOracle::load_block_prices # block beneficiary: " << coinbase; std::vector block_prices; int idx = 0; block_prices.reserve(block_with_hash->block.transactions.size()); for (const auto& transaction : block_with_hash->block.transactions) { const auto priority_fee_per_gas = transaction.priority_fee_per_gas(base_fee); SILK_TRACE << "idx: " << idx++ << " hash: " << silkworm::to_hex(transaction.hash().bytes) << " priority_fee_per_gas: 0x" << intx::hex(transaction.priority_fee_per_gas(base_fee)) << " max_fee_per_gas: 0x" << intx::hex(transaction.max_fee_per_gas) << " max_priority_fee_per_gas: 0x" << intx::hex(transaction.max_priority_fee_per_gas); if (priority_fee_per_gas < kDefaultMinPrice) { continue; } if (transaction.sender() == coinbase) { continue; } block_prices.push_back(priority_fee_per_gas); } std::sort(block_prices.begin(), block_prices.end(), PriceComparator()); for (uint64_t count = 0; const auto& priority_fee_per_gas : block_prices) { SILK_TRACE << " priority_fee_per_gas : 0x" << intx::hex(priority_fee_per_gas); tx_prices.push_back(priority_fee_per_gas); if (++count >= limit) { break; } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/gas_price_oracle.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc { inline const intx::uint256 kWei = 1; inline const intx::uint256 kGWei = 1E9; inline const intx::uint256 kDefaultPrice = 0; inline const intx::uint256 kDefaultMaxPrice = 500 * kGWei; inline const intx::uint256 kDefaultMinPrice = 2 * kWei; inline constexpr uint8_t kCheckBlocks = 20; inline constexpr uint8_t kSamples = 3; inline constexpr uint8_t kMaxSamples = kCheckBlocks * kSamples; inline constexpr uint8_t kPercentile = 60; using BlockProvider = std::function>(BlockNum)>; class GasPriceOracle { public: explicit GasPriceOracle(const BlockProvider& block_provider) : block_provider_(block_provider) {} virtual ~GasPriceOracle() = default; GasPriceOracle(const GasPriceOracle&) = delete; GasPriceOracle& operator=(const GasPriceOracle&) = delete; Task suggested_price(BlockNum block_num); private: Task load_block_prices(BlockNum block_num, uint64_t limit, std::vector& tx_prices); const BlockProvider& block_provider_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/gas_price_oracle_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "gas_price_oracle.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { static const evmc::address kBeneficiary = 0xe5ef458d37212a06e3f59d40c454e76150ae7c31_address; static const evmc::address kFromTnx1 = 0xe5ef458d37212a06e3f59d40c454e76150ae7c32_address; static const evmc::address kFromTnx2 = 0xe5ef458d37212a06e3f59d40c454e76150ae7c33_address; struct FixedBlockData { intx::uint256 base_fee; intx::uint256 max_priority_fee_per_gas_tx1; intx::uint256 max_fee_per_gas_tx1; intx::uint256 max_priority_fee_per_gas_tx2; intx::uint256 max_fee_per_gas_tx2; }; struct VariableBlockData { intx::uint256 base_fee; intx::uint256 max_priority_fee_per_gas; int delta_max_priority_fee_per_gas; intx::uint256 max_fee_per_gas; int delta_max_fee_per_gas; }; static silkworm::BlockWithHash allocate_block(BlockNum block_num, const evmc::address& beneficiary, const FixedBlockData& block_data) { silkworm::BlockWithHash block_with_hash; block_with_hash.block.header.number = block_num; block_with_hash.block.header.beneficiary = beneficiary; block_with_hash.block.header.base_fee_per_gas = block_data.base_fee; block_with_hash.block.transactions.resize(2); block_with_hash.block.transactions[0].max_priority_fee_per_gas = block_data.max_priority_fee_per_gas_tx1; block_with_hash.block.transactions[0].max_fee_per_gas = block_data.max_fee_per_gas_tx1; block_with_hash.block.transactions[0].set_sender(kFromTnx1); block_with_hash.block.transactions[1].max_priority_fee_per_gas = block_data.max_priority_fee_per_gas_tx2; block_with_hash.block.transactions[1].max_fee_per_gas = block_data.max_fee_per_gas_tx2; block_with_hash.block.transactions[1].set_sender(kFromTnx2); return block_with_hash; } static void fill_blocks_vector(std::vector& blocks, const evmc::address& beneficiary, const FixedBlockData& block_data) { for (auto idx = 0u; idx < blocks.capacity(); ++idx) { silkworm::BlockWithHash block_with_hash = allocate_block(static_cast(idx), beneficiary, block_data); blocks.push_back(block_with_hash); } } static void fill_blocks_vector(std::vector& blocks, const evmc::address& beneficiary, const VariableBlockData& variable_block_data) { for (auto idx = 0; idx < static_cast(blocks.capacity()); ++idx) { int64_t max_priority = int64_t{variable_block_data.max_priority_fee_per_gas} + variable_block_data.delta_max_priority_fee_per_gas * idx; max_priority = std::max(max_priority, 0); int64_t max_fee = int64_t{variable_block_data.max_fee_per_gas} + variable_block_data.delta_max_fee_per_gas * idx; max_fee = std::max(max_fee, 0); FixedBlockData block_data = { variable_block_data.base_fee, intx::uint256{max_priority}, intx::uint256{max_fee}, intx::uint256{max_priority}, intx::uint256{max_fee}}; silkworm::BlockWithHash block_with_hash = allocate_block(static_cast(idx), beneficiary, block_data); blocks.push_back(block_with_hash); } } TEST_CASE("suggested price") { WorkerPool pool{1}; std::vector blocks; BlockProvider block_provider = [&](BlockNum block_num) -> Task> { auto block_with_hash = std::make_shared(); *block_with_hash = blocks[block_num]; co_return block_with_hash; }; GasPriceOracle gas_price_oracle{block_provider}; SECTION("when there is no block in chain") { FixedBlockData data = {0, 0x32, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = kDefaultPrice; blocks.reserve(1); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(0), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there is just 1 block in chain with 0x0 base fee") { FixedBlockData data = {0, 0x32, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x32; blocks.reserve(2); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there is just 1 block in chain with 0x7 base fee") { FixedBlockData data = {0x7, 0x32, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(2); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there is just 1 block in chain with 0x7 base fee and different max_priority and max_fee in tnxs") { FixedBlockData data = {0x7, 0x0, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(2); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 20 blocks with 0x0 base fee and same max_priority and max_fee in tnxs") { FixedBlockData data = {0x0, 0x32, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x32; blocks.reserve(20); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 20 blocks with 0x7 base fee and different max_priority and max_fee in tnxs") { FixedBlockData data = {0x7, 0x0, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(20); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 30 blocks with 0x0 base fee and same max_priority and max_fee in tnxs") { FixedBlockData data = {0x0, 0x32, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x32; blocks.reserve(30); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 30 blocks with 0x7 base fee and different max_priority and max_fee in tnxs") { FixedBlockData data = {0x7, 0x0, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(30); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee and same max_priority and max_fee in tnxs") { FixedBlockData data = {0x0, 0x32, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x32; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base fee and different max_priority and max_fee in tnxs") { FixedBlockData data = {0x7, 0x0, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base fee and max_priority > max_fee") { FixedBlockData data = {0x7, 0x40, 0x32, 0x40, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base fee and max_priority < max_fee") { FixedBlockData data = {0x7, 0x32, 0x40, 0x32, 0x40}; const intx::uint256 expected_price = 0x32; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base fee and different max_priority and max_fee in tnxs, beneficiary == tx1 from") { FixedBlockData data = {0x7, 0x0, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(60); fill_blocks_vector(blocks, kFromTnx1, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base_fee and different max_priority and max_fee in tnxs, beneficiary == tx2 from") { FixedBlockData data = {0x7, 0x0, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x0; blocks.reserve(60); fill_blocks_vector(blocks, kFromTnx2, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee and 1 tnx with fee == kDefaultMinPrice") { FixedBlockData data = {0x0, 0x32, 0x32, kDefaultMinPrice, kDefaultMinPrice}; const intx::uint256 expected_price = kDefaultMinPrice; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks ith 0x0 base fee and 1 tnx with fee < kDefaultMinPrice") { FixedBlockData data = {0x0, 0x32, 0x32, kDefaultMinPrice - 1, kDefaultMinPrice - 1}; const intx::uint256 expected_price = 0x32; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee with fee == kDefaultMaxPrice") { FixedBlockData data = {0x0, kDefaultMaxPrice, kDefaultMaxPrice, kDefaultMaxPrice, kDefaultMaxPrice}; const intx::uint256 expected_price = kDefaultMaxPrice; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with with 0x07 base fee with fee == kDefaultMaxPrice") { FixedBlockData data = {0x07, kDefaultMaxPrice + 0x07, kDefaultMaxPrice + 0x07, kDefaultMaxPrice + 0x07, kDefaultMaxPrice + 0x07}; const intx::uint256 expected_price = kDefaultMaxPrice; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee with fee > kDefaultMaxPrice") { FixedBlockData data = {0x0, kDefaultMaxPrice + 0x10, kDefaultMaxPrice + 0x10, kDefaultMaxPrice + 0x10, kDefaultMaxPrice + 0x10}; const intx::uint256 expected_price = kDefaultMaxPrice; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x07 base fee with fee > kDefaultMaxPrice") { FixedBlockData data = {0x07, kDefaultMaxPrice + 0x10, kDefaultMaxPrice + 0x10, kDefaultMaxPrice + 0x10, kDefaultMaxPrice + 0x10}; const intx::uint256 expected_price = kDefaultMaxPrice; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee and 1 tnx with fee > kDefaultMaxPrice") { FixedBlockData data = {0x0, kDefaultMaxPrice + kDefaultMaxPrice + 0x10, 0x32, 0x32, 0x32}; const intx::uint256 expected_price = 0x32; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base fee and 1 tnx with fee > kDefaultMaxPrice") { FixedBlockData data = {0x7, kDefaultMaxPrice + 0x10, kDefaultMaxPrice + 0x10, 0x32, 0x32}; const intx::uint256 expected_price = 0x2b; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee and tnxs with increasing max_priority_fee_per_gas and max_fee_per_gas") { VariableBlockData data = {0x0, 0x10, 0x9, 0x10, 0x9}; const intx::uint256 expected_price = 0x019; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base fee and tnxs with increasing max_priority_fee_per_gas and max_fee_per_gas") { VariableBlockData data = {0x7, 0x10, 0x9, 0x10, 0x9}; const intx::uint256 expected_price = 0x012; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee and tnxs with decreasing max_priority_fee_per_gas and max_fee_per_gas") { VariableBlockData data = {0x0, 0x300, -0x9, 0x300, -0x9}; const intx::uint256 expected_price = 0x2f7; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x7 base fee and tnxs with decreasing max_priority_fee_per_gas and max_fee_per_gas") { VariableBlockData data = {0x7, 0x200, -0x9, 0x200, -0x9}; const intx::uint256 expected_price = 0x1f0; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } SECTION("when there are 60 blocks with 0x0 base fee and tnxs with max_priority_fee_per_gas and max_fee_per_gas increasing over threshold") { VariableBlockData data = {0x0, kDefaultMaxPrice - intx::uint256{0x200}, 0x9, kDefaultMaxPrice - intx::uint256{0x200}, 0x9}; const intx::uint256 expected_price = 0x746a528609; blocks.reserve(60); fill_blocks_vector(blocks, kBeneficiary, data); auto result = boost::asio::co_spawn(pool, gas_price_oracle.suggested_price(1), boost::asio::use_future); const intx::uint256& price = result.get(); CHECK(price == expected_price); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/logs_walker.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "logs_walker.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using namespace db::chain; Task> LogsWalker::get_block_nums(const Filter& filter) { BlockNum start{}, end{}; if (filter.block_hash.has_value()) { auto block_hash_bytes = silkworm::from_hex(filter.block_hash.value()); if (!block_hash_bytes.has_value()) { start = end = std::numeric_limits::max(); } else { auto block_hash = silkworm::to_bytes32(block_hash_bytes.value()); auto block_num = co_await block_reader_.get_block_num(block_hash); start = end = block_num; } } else { uint64_t last_block_num = std::numeric_limits::max(); if (filter.from_block.has_value()) { start = co_await block_reader_.get_block_num(filter.from_block.value()); } else { last_block_num = co_await block_reader_.get_latest_block_num(); start = last_block_num; } if (filter.to_block.has_value()) { end = co_await block_reader_.get_block_num(filter.to_block.value()); } else { if (last_block_num == std::numeric_limits::max()) { last_block_num = co_await block_reader_.get_latest_block_num(); } end = last_block_num; } } co_return std::make_pair(start, end); } Task LogsWalker::get_logs(BlockNum start, BlockNum end, const FilterAddresses& addresses, const FilterTopics& topics, const LogFilterOptions& options, bool ascending_order, std::vector& logs) { db::txn::TxNum min_tx_num{0}; if (start > 0) { min_tx_num = co_await db::txn::min_tx_num(tx_, start, canonical_body_for_storage_provider_); } auto max_tx_num = co_await db::txn::max_tx_num(tx_, end, canonical_body_for_storage_provider_) + 1; SILK_DEBUG << "start: " << start << ", end: " << end << ", min_tx_num: " << min_tx_num << ", max_tx_num: " << max_tx_num; const auto from_timestamp = static_cast(min_tx_num); const auto to_timestamp = static_cast(max_tx_num); const auto chain_storage{tx_.make_storage()}; db::kv::api::Stream paginated_stream; if (!topics.empty()) { for (auto sub_topic = topics.begin(); sub_topic < topics.end(); ++sub_topic) { if (sub_topic->empty()) { continue; } db::kv::api::Stream union_stream; for (auto it = sub_topic->begin(); it < sub_topic->end(); ++it) { SILK_DEBUG << "topic: " << to_hex(*it) << ", from_timestamp: " << from_timestamp << ", to_timestamp: " << to_timestamp; db::kv::api::IndexRangeRequest query = { .table = std::string{db::table::kLogTopicIdx}, .key = db::topic_domain_key(*it), .from_timestamp = from_timestamp, .to_timestamp = to_timestamp, .ascending_order = ascending_order}; auto paginated_result = co_await tx_.index_range(std::move(query)); union_stream = db::kv::api::set_union(std::move(union_stream), co_await paginated_result.begin()); } if (!paginated_stream) { paginated_stream = std::move(union_stream); continue; } paginated_stream = db::kv::api::set_intersection(std::move(paginated_stream), std::move(union_stream)); } } if (!addresses.empty()) { db::kv::api::Stream union_stream; for (auto it = addresses.begin(); it < addresses.end(); ++it) { SILK_DEBUG << "address: " << *it << ", from_timestamp: " << from_timestamp << ", to_timestamp: " << to_timestamp; db::kv::api::IndexRangeRequest query = { .table = std::string{db::table::kLogAddrIdx}, .key = db::account_domain_key(*it), .from_timestamp = from_timestamp, .to_timestamp = to_timestamp, .ascending_order = ascending_order}; auto paginated_result = co_await tx_.index_range(std::move(query)); union_stream = db::kv::api::set_union(std::move(union_stream), co_await paginated_result.begin()); } if (paginated_stream) { paginated_stream = db::kv::api::set_intersection(std::move(paginated_stream), std::move(union_stream)); } else { paginated_stream = std::move(union_stream); } } if (!paginated_stream) { paginated_stream = db::kv::api::make_range_stream(from_timestamp, to_timestamp); } Receipts receipts; uint64_t block_count{0}; uint64_t log_count{0}; Logs filtered_chunk_logs; uint64_t block_timestamp{0}; silkworm::Block block; std::optional header; auto itr = db::txn::make_txn_nums_stream(std::move(paginated_stream), ascending_order, tx_, canonical_body_for_storage_provider_); while (const auto tnx_nums = co_await itr->next()) { SILK_DEBUG << " blockNum: " << tnx_nums->block_num << " txn_id: " << tnx_nums->txn_id << " txn_index: " << (tnx_nums->txn_index ? std::to_string(*(tnx_nums->txn_index)) : "nullopt"); if (tnx_nums->block_changed) { receipts.clear(); header = co_await chain_storage->read_canonical_header(tnx_nums->block_num); if (!header) { SILK_DEBUG << "Not found header no. " << tnx_nums->block_num; break; } block_timestamp = header->timestamp; block.header = std::move(*header); } if (!tnx_nums->txn_index) { continue; } SILKWORM_ASSERT(header); const auto transaction = co_await chain_storage->read_transaction_by_idx_in_block(tnx_nums->block_num, tnx_nums->txn_index.value()); if (!transaction) { SILK_DEBUG << "No transaction found in block " << tnx_nums->block_num << " for index " << tnx_nums->txn_index.value(); continue; } auto receipt = co_await core::get_receipt(tx_, block, tnx_nums->txn_id, tnx_nums->txn_index.value(), *transaction, *chain_storage, workers_); if (!receipt) { SILK_DEBUG << "No receipt found in block " << tnx_nums->block_num << " for index " << tnx_nums->txn_index.value(); continue; } SILK_DEBUG << "Got transaction: block_num: " << tnx_nums->block_num << ", txn_index: " << tnx_nums->txn_index.value(); filtered_chunk_logs.clear(); // ERIGON3 compatibility: erigon_getLatestLogs overwrites log index if (options.overwrite_log_index) { uint32_t log_index{0}; auto local_receipt = *receipt; for (auto& log : local_receipt.logs) { log.index = log_index++; } filter_logs(local_receipt.logs, addresses, topics, filtered_chunk_logs, options.log_count == 0 ? 0 : options.log_count - log_count); } else { filter_logs(receipt->logs, addresses, topics, filtered_chunk_logs, options.log_count == 0 ? 0 : options.log_count - log_count); } SILK_DEBUG << "filtered #logs: " << filtered_chunk_logs.size(); if (filtered_chunk_logs.empty()) { continue; } ++block_count; log_count += filtered_chunk_logs.size(); SILK_DEBUG << "log_count: " << log_count; if (options.add_timestamp) { for (auto& curr_log : filtered_chunk_logs) { curr_log.timestamp = block_timestamp; } } logs.insert(logs.end(), filtered_chunk_logs.begin(), filtered_chunk_logs.end()); if (options.log_count != 0 && options.log_count <= log_count) { break; } if (options.block_count != 0 && options.block_count == block_count) { break; } } SILK_DEBUG << "resulting logs size: " << logs.size(); co_return; } void LogsWalker::filter_logs(const std::vector& logs, const FilterAddresses& addresses, const FilterTopics& topics, std::vector& filtered_logs, size_t max_logs) { SILK_DEBUG << "filter_logs: addresses: " << addresses << ", topics: " << topics; size_t log_count = 0; for (auto& log : logs) { SILK_DEBUG << "log: " << log; if (!addresses.empty() && std::find(addresses.begin(), addresses.end(), log.address) == addresses.end()) { SILK_DEBUG << "skipped log for address: " << log.address; continue; } auto matches = true; if (!topics.empty()) { if (topics.size() > log.topics.size()) { SILK_DEBUG << "#topics: " << topics.size() << " #log.topics: " << log.topics.size(); continue; } for (size_t i{0}; i < topics.size(); ++i) { SILK_DEBUG << "log.topics[i]: " << to_hex(log.topics[i]); auto subtopics = topics[i]; auto matches_subtopics = subtopics.empty(); // empty rule set == wildcard SILK_DEBUG << "matches_subtopics: " << std::boolalpha << matches_subtopics; for (auto& topic : subtopics) { SILK_DEBUG << "topic: " << to_hex(topic); if (log.topics[i] == topic) { matches_subtopics = true; SILK_DEBUG << "matches_subtopics: " << std::boolalpha << matches_subtopics; break; } } if (!matches_subtopics) { SILK_DEBUG << "No subtopic matches"; matches = false; break; } } } SILK_DEBUG << "matches: " << std::boolalpha << matches; if (matches) { filtered_logs.push_back(log); } if (max_logs != 0 && ++log_count >= max_logs) { return; } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/logs_walker.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using boost::asio::awaitable; class LogsWalker { public: LogsWalker(BlockCache& block_cache, db::kv::api::Transaction& tx, const db::chain::ChainStorage& chain_storage, WorkerPool& workers) : block_cache_(block_cache), tx_(tx), canonical_body_for_storage_provider_(db::chain::canonical_body_provider_from_chain_storage(chain_storage)), block_reader_(chain_storage, tx), workers_(workers) {} LogsWalker(const LogsWalker&) = delete; LogsWalker& operator=(const LogsWalker&) = delete; Task> get_block_nums(const Filter& filter); Task get_logs(BlockNum start, BlockNum end, const FilterAddresses& addresses, const FilterTopics& topics, std::vector& logs) { LogFilterOptions options; co_return co_await get_logs(start, end, addresses, topics, options, /*ascending_order=*/true, logs); } Task get_logs(BlockNum start, BlockNum end, const FilterAddresses& addresses, const FilterTopics& topics, const LogFilterOptions& options, bool ascending_order, std::vector& logs); private: void filter_logs(const std::vector& logs, const FilterAddresses& addresses, const FilterTopics& topics, std::vector& filtered_logs, size_t max_logs); BlockCache& block_cache_; db::kv::api::Transaction& tx_; db::chain::CanonicalBodyForStorageProvider canonical_body_for_storage_provider_; BlockReader block_reader_; WorkerPool& workers_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/override_state.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "override_state.hpp" #include #include #include #include #include #include #include namespace silkworm::rpc::state { silkworm::Account get_account(const AccountOverrides& overrides, const std::optional& optional_account) { auto overridden_account = optional_account.value_or(silkworm::Account{}); if (overrides.nonce) { overridden_account.nonce = overrides.nonce.value(); } if (overrides.balance) { overridden_account.balance = overrides.balance.value(); } if (overrides.code_hash) { overridden_account.code_hash = overrides.code_hash.value(); } return overridden_account; } OverrideState::OverrideState(silkworm::State& inner_state, const AccountsOverrides& accounts_overrides) : inner_state_{inner_state}, accounts_overrides_{accounts_overrides} { for (const auto& [key, value] : accounts_overrides_) { if (value.code) { code_.emplace(key, value.code.value()); } } } std::optional OverrideState::read_account(const evmc::address& address) const noexcept { SILK_DEBUG << "OverrideState::read_account address=" << address << " start"; auto optional_account = inner_state_.read_account(address); auto it = accounts_overrides_.find(address); if (it != accounts_overrides_.end()) { auto overridden_account = get_account(it->second, optional_account); SILK_DEBUG << "OverrideState::read_account address=" << address << " account=" << overridden_account; optional_account = overridden_account; } return optional_account; } silkworm::ByteView OverrideState::read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept { SILK_DEBUG << "OverrideState::read_code code_hash=" << to_hex(code_hash) << " start"; auto it = code_.find(address); if (it != code_.end()) { SILK_DEBUG << "OverrideState::read_code code_hash=" << to_hex(code_hash) << " code: " << it->second; return it->second; } return inner_state_.read_code(address, code_hash); } evmc::bytes32 OverrideState::read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept { SILK_DEBUG << "OverrideState::read_storage address=" << address << " incarnation=" << incarnation << " location=" << to_hex(location) << " start"; for (const auto& [key, value] : accounts_overrides_) { if (key == address) { for (const auto& entry : value.state) { if (location == entry.first) { auto storage_value = intx::be::store(entry.second); SILK_DEBUG << "OverrideState::read_storage reads from cache storage_value=" << to_hex(storage_value); return storage_value; } } } } auto storage_value = inner_state_.read_storage(address, incarnation, location); SILK_DEBUG << "OverrideState::read_storage storage_value=" << to_hex(storage_value); return storage_value; } std::optional OverrideState::read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { SILK_DEBUG << "OverrideState::read_header block_num=" << block_num << " block_hash=" << to_hex(block_hash); auto optional_header = inner_state_.read_header(block_num, block_hash); return optional_header; } bool OverrideState::read_body(BlockNum block_num, const evmc::bytes32& block_hash, silkworm::BlockBody& out) const noexcept { SILK_DEBUG << "OverrideState::read_body block_num=" << block_num << " block_hash=" << to_hex(block_hash); auto result = inner_state_.read_body(block_num, block_hash, out); return result; } std::optional OverrideState::total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept { SILK_DEBUG << "OverrideState::total_difficulty block_num=" << block_num << " block_hash=" << to_hex(block_hash); auto optional_total_difficulty = inner_state_.total_difficulty(block_num, block_hash); SILK_DEBUG << "OverrideState::total_difficulty optional_total_difficulty=" << optional_total_difficulty.value_or(intx::uint256{}); return optional_total_difficulty; } std::optional OverrideState::canonical_hash(BlockNum block_num) const { SILK_DEBUG << "OverrideState::canonical_hash block_num=" << block_num; auto optional_canonical_hash = inner_state_.canonical_hash(block_num); SILK_DEBUG << "OverrideState::canonical_hash optional_canonical_hash=" << to_hex(optional_canonical_hash.value_or(evmc::bytes32{})); return optional_canonical_hash; } } // namespace silkworm::rpc::state ================================================ FILE: silkworm/rpc/core/override_state.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc::state { class OverrideState : public silkworm::State { public: explicit OverrideState(silkworm::State& inner_state, const AccountsOverrides& accounts_overrides); std::optional read_account(const evmc::address& address) const noexcept override; silkworm::ByteView read_code(const evmc::address& address, const evmc::bytes32& code_hash) const noexcept override; evmc::bytes32 read_storage(const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location) const noexcept override; uint64_t previous_incarnation(const evmc::address& address) const noexcept override { return inner_state_.previous_incarnation(address); } std::optional read_header(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; bool read_body(BlockNum block_num, const evmc::bytes32& block_hash, silkworm::BlockBody& out) const noexcept override; std::optional total_difficulty(BlockNum block_num, const evmc::bytes32& block_hash) const noexcept override; evmc::bytes32 state_root_hash() const override { return inner_state_.state_root_hash(); } BlockNum current_canonical_block() const override { return inner_state_.current_canonical_block(); } std::optional canonical_hash(BlockNum block_num) const override; void insert_block(const silkworm::Block& block, const evmc::bytes32& hash) override { inner_state_.insert_block(block, hash); } void canonize_block(BlockNum block_num, const evmc::bytes32& block_hash) override { inner_state_.canonize_block(block_num, block_hash); } void decanonize_block(BlockNum block_num) override { inner_state_.decanonize_block(block_num); } void insert_receipts(BlockNum block_num, const std::vector& receipts) override { inner_state_.insert_receipts(block_num, receipts); } void insert_call_traces(BlockNum block_num, const CallTraces& traces) override { inner_state_.insert_call_traces(block_num, traces); } void begin_block(BlockNum block_num, size_t updated_accounts_count) override { inner_state_.begin_block(block_num, updated_accounts_count); } void update_account( const evmc::address& address, std::optional initial, std::optional current) override { inner_state_.update_account(address, initial, current); } void update_account_code( const evmc::address& address, uint64_t incarnation, const evmc::bytes32& code_hash, silkworm::ByteView code) override { inner_state_.update_account_code(address, incarnation, code_hash, code); } void update_storage( const evmc::address& address, uint64_t incarnation, const evmc::bytes32& location, const evmc::bytes32& initial, const evmc::bytes32& current) override { inner_state_.update_storage(address, incarnation, location, initial, current); } void unwind_state_changes(BlockNum block_num) override { inner_state_.unwind_state_changes(block_num); } private: silkworm::State& inner_state_; const AccountsOverrides& accounts_overrides_; std::map code_; }; } // namespace silkworm::rpc::state ================================================ FILE: silkworm/rpc/core/receipts.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipts.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::core { using ethdb::walk; static constexpr int kGasPerBlob = 0x20000; const Bytes kCumulativeGasUsedKey{static_cast(db::state::ReceiptsDomainKey::kCumulativeGasUsedInBlockKey)}; const Bytes kFirstLogIndexKey{static_cast(db::state::ReceiptsDomainKey::kFirstLogIndexKey)}; ReceiptCache receipt_cache; ReceiptsCache receipts_cache; Task> get_cached_receipts(const evmc::bytes32& hash) { const auto receipts = receipts_cache.get(hash); if (receipts != nullptr) { co_return (receipts); } co_return nullptr; } Task> get_receipts(db::kv::api::Transaction& tx, const silkworm::BlockWithHash& block_with_hash, const db::chain::ChainStorage& chain_storage, WorkerPool& workers, bool extended_receipt_info) { if (block_with_hash.block.transactions.empty()) { co_return std::make_shared(); } const evmc::bytes32 block_hash = block_with_hash.hash; const BlockNum block_num = block_with_hash.block.header.number; const auto cached_receipts = receipts_cache.get(block_hash); if (cached_receipts != nullptr) { co_return (cached_receipts); } // Try to read receipts from storage, if not present regenerate them auto receipts_ptr = co_await read_receipts(tx, block_num); if (receipts_ptr == nullptr || receipts_ptr->empty()) { receipts_ptr = co_await generate_receipts(tx, block_with_hash.block, chain_storage, workers); if (receipts_ptr == nullptr || receipts_ptr->empty()) { co_return std::make_shared(); } } auto& receipts = *receipts_ptr; const auto& transactions = block_with_hash.block.transactions; SILK_DEBUG << "#transactions=" << block_with_hash.block.transactions.size() << " #receipts=" << receipts.size(); if (transactions.size() != receipts.size()) { throw std::runtime_error{"#transactions and #receipts do not match in get_receipts"}; } if (!extended_receipt_info) { co_return receipts_ptr; } // Add derived fields to the receipts const auto& header = block_with_hash.block.header; uint32_t log_index{0}; for (size_t i{0}; i < receipts.size(); ++i) { // The tx hash can be calculated by the tx content itself auto tx_hash{transactions[i].hash()}; receipts[i]->tx_hash = to_bytes32(tx_hash.bytes); receipts[i]->effective_gas_price = transactions[i].effective_gas_price(block_with_hash.block.header.base_fee_per_gas.value_or(0)); receipts[i]->tx_index = static_cast(i); receipts[i]->block_hash = block_hash; receipts[i]->block_num = block_num; if (!transactions[i].blob_versioned_hashes.empty()) { receipts[i]->blob_gas_used = kGasPerBlob * transactions[i].blob_versioned_hashes.size(); if (header.excess_blob_gas) { receipts[i]->blob_gas_price = header.blob_gas_price(); } } // When tx receiver is not set, create a contract with address depending on tx sender and its nonce if (!transactions[i].to.has_value()) { receipts[i]->contract_address = create_address(*transactions[i].sender(), transactions[i].nonce); } // The gas used can be calculated by the previous receipt if (i == 0) { receipts[i]->gas_used = receipts[i]->cumulative_gas_used; } else { receipts[i]->gas_used = receipts[i]->cumulative_gas_used - receipts[i - 1]->cumulative_gas_used; } receipts[i]->from = transactions[i].sender(); receipts[i]->to = transactions[i].to; receipts[i]->type = transactions[i].type; receipts[i]->effective_gas_price = transactions[i].effective_gas_price(header.base_fee_per_gas.value_or(0)); // The derived fields of receipt are taken from block and transaction for (size_t j{0}; j < receipts[i]->logs.size(); ++j) { receipts[i]->logs[j].block_num = block_num; receipts[i]->logs[j].block_hash = block_hash; receipts[i]->logs[j].tx_hash = receipts[i]->tx_hash; receipts[i]->logs[j].tx_index = static_cast(i); receipts[i]->logs[j].index = log_index++; receipts[i]->logs[j].removed = false; } } receipts_cache.insert(block_with_hash.hash, receipts_ptr); co_return receipts_ptr; } Task> read_receipts(db::kv::api::Transaction& tx, BlockNum block_num) { const auto block_key = db::block_key(block_num); const auto data = co_await tx.get_one(db::table::kBlockReceiptsName, block_key); SILK_TRACE << "read_receipts data: " << silkworm::to_hex(data); if (data.empty()) { co_return nullptr; } auto receipts_ptr = std::make_shared(); auto& receipts = *receipts_ptr; const bool decoding_ok{cbor_decode(data, receipts)}; if (!decoding_ok) { throw std::runtime_error("cannot decode raw receipts in block: " + std::to_string(block_num)); } SILK_TRACE << "#receipts: " << receipts.size(); if (receipts.empty()) { co_return receipts_ptr; } auto log_key = db::log_key(block_num, 0); SILK_DEBUG << "log_key: " << silkworm::to_hex(log_key); auto walker = [&](const silkworm::Bytes& k, const silkworm::Bytes& v) { if (k.size() != sizeof(uint64_t) + sizeof(uint32_t)) { return false; } auto tx_id = endian::load_big_u32(&k[sizeof(uint64_t)]); const bool decode_ok{cbor_decode(v, receipts[tx_id]->logs)}; if (!decode_ok) { SILK_WARN << "cannot decode logs for receipt: " << tx_id << " in block: " << block_num; return false; } receipts[tx_id]->bloom = bloom_from_logs(receipts[tx_id]->logs); SILK_DEBUG << "#receipts[" << tx_id << "].logs: " << receipts[tx_id]->logs.size(); return true; }; co_await walk(tx, db::table::kLogsName, log_key, 8 * CHAR_BIT, walker); co_return receipts_ptr; } Task> generate_receipts(db::kv::api::Transaction& tx, const silkworm::Block& block, const db::chain::ChainStorage& chain_storage, WorkerPool& workers) { auto block_num = block.header.number; const auto& transactions = block.transactions; SILK_TRACE << "generate_receipts: block_num: " << std::dec << block_num << " #txns: " << transactions.size(); const auto chain_config = co_await chain_storage.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; execution::StateFactory state_factory{tx}; const auto txn_id = co_await tx.user_txn_id_at(block_num); const auto generated_receipts = co_await async_task(workers.executor(), [&]() -> std::shared_ptr { auto receipts = std::make_shared(); receipts->reserve(transactions.size()); auto state = state_factory.make(current_executor, chain_storage, txn_id); EVMExecutor executor{block, chain_config, workers, state}; uint64_t cumulative_gas_used{0}; for (const auto& transaction : transactions) { auto receipt = std::make_shared(); auto result = executor.call_with_receipt(transaction, *receipt, {}, /*refund=*/true, /*gas_bailout=*/false); cumulative_gas_used += receipt->gas_used; receipt->cumulative_gas_used = cumulative_gas_used; receipts->push_back(receipt); executor.reset(); } return receipts; }); co_return generated_receipts; } Task> get_receipt(db::kv::api::Transaction& tx, const silkworm::Block& block, TxnId txn_id, uint32_t tx_index, const silkworm::Transaction& transaction, const db::chain::ChainStorage& chain_storage, WorkerPool& workers) { using Word = snapshots::Decoder::Word; const auto tx_receipt = receipt_cache.get(transaction.hash()); if (tx_receipt != nullptr) { co_return tx_receipt; } const auto receipts = receipts_cache.get(block.header.hash()); if (receipts != nullptr) { SILKWORM_ASSERT(tx_index < receipts->size() && (*receipts)[tx_index] != nullptr); co_return (*receipts)[tx_index]; } const auto chain_config = co_await chain_storage.read_chain_config(); auto current_executor = co_await boost::asio::this_coro::executor; execution::StateFactory state_factory{tx}; auto new_receipt = co_await async_task(workers.executor(), [&]() -> std::shared_ptr { auto state = state_factory.make(current_executor, chain_storage, txn_id); EVMExecutor executor{block, chain_config, workers, state}; auto receipt = std::make_shared(); auto result = executor.call_with_receipt(transaction, *receipt, {}, /*refund=*/true, /*gas_bailout=*/false); return receipt; }); txn_id++; // query db on next txn db::kv::api::GetAsOfRequest query_cumulative_gas{ .table = std::string{db::table::kReceiptDomain}, .key = kCumulativeGasUsedKey, .timestamp = static_cast(txn_id), }; auto result = co_await tx.get_as_of(std::move(query_cumulative_gas)); if (!result.success) { co_return nullptr; } db::state::VarintSnapshotsDecoder varint; Word value1{std::move(result.value)}; varint.decode_word(value1); const auto first_cumulative_gas_used_in_tx = varint.value; db::kv::api::GetAsOfRequest query_first_log_index{ .table = std::string{db::table::kReceiptDomain}, .key = kFirstLogIndexKey, .timestamp = static_cast(txn_id), }; result = co_await tx.get_as_of(std::move(query_first_log_index)); if (!result.success) { co_return nullptr; } Word value2{std::move(result.value)}; varint.decode_word(value2); auto first_log_index = static_cast(varint.value); new_receipt->cumulative_gas_used = first_cumulative_gas_used_in_tx; new_receipt->from = transaction.sender(); new_receipt->to = transaction.to; new_receipt->type = transaction.type; new_receipt->block_num = block.header.number; new_receipt->block_hash = block.header.hash(); new_receipt->tx_hash = transaction.hash(); new_receipt->tx_index = tx_index; new_receipt->effective_gas_price = transaction.effective_gas_price(block.header.base_fee_per_gas.value_or(0)); // When tx receiver is not set, compute contract address depending on tx sender and its nonce const auto sender = transaction.sender(); if (!transaction.to && sender) { new_receipt->contract_address = create_address(*sender, transaction.nonce); } for (auto& curr_log : new_receipt->logs) { curr_log.block_num = block.header.number; curr_log.block_hash = block.header.hash(); curr_log.tx_hash = transaction.hash(); curr_log.tx_index = tx_index; curr_log.index = first_log_index++; curr_log.removed = false; } receipt_cache.insert(transaction.hash(), new_receipt); co_return new_receipt; } } // namespace silkworm::rpc::core ================================================ FILE: silkworm/rpc/core/receipts.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc::core { Task> get_receipts(db::kv::api::Transaction& tx, const silkworm::BlockWithHash& block_with_hash, const db::chain::ChainStorage& chain_storage, WorkerPool& workers, bool extended_receipt_info = true); Task> read_receipts(db::kv::api::Transaction& tx, BlockNum block_num); Task> generate_receipts(db::kv::api::Transaction& tx, const silkworm::Block& block, const db::chain::ChainStorage& chain_storage, WorkerPool& workers); Task> get_receipt(db::kv::api::Transaction& tx, const silkworm::Block& block, TxnId txn_id, uint32_t tx_index, const silkworm::Transaction& transaction, const db::chain::ChainStorage& chain_storage, WorkerPool& workers); Task> get_cached_receipts(const evmc::bytes32& hash); } // namespace silkworm::rpc::core ================================================ FILE: silkworm/rpc/core/receipts_cache.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc { inline constexpr size_t kReceiptCacheLimit = 1024 * 1000; inline constexpr size_t kReceiptsCacheLimit = 1024; class ReceiptCache { public: explicit ReceiptCache(size_t capacity = kReceiptCacheLimit, bool shared_cache = true) : receipt_cache_(capacity, shared_cache) {} std::shared_ptr get(const evmc::bytes32& key) { auto result = receipt_cache_.get_as_copy(key); if (result) { return *result; } return nullptr; } void insert(const evmc::bytes32& key, const std::shared_ptr& block) { receipt_cache_.put(key, block); } private: LruCache> receipt_cache_; }; class ReceiptsCache { public: explicit ReceiptsCache(size_t capacity = kReceiptsCacheLimit, bool shared_cache = true) : receipts_cache_(capacity, shared_cache) {} std::shared_ptr get(const evmc::bytes32& key) { auto result = receipts_cache_.get_as_copy(key); if (result) { return *result; } return nullptr; } void insert(const evmc::bytes32& key, const std::shared_ptr& receipt) { receipts_cache_.put(key, receipt); } private: LruCache> receipts_cache_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/receipts_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipts.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::core { using namespace silkworm::db; using db::test_util::MockCursor; using kv::api::KeyValue; using testing::_; using testing::InSequence; using testing::Invoke; using testing::InvokeWithoutArgs; using testing::Unused; static silkworm::Bytes kNumber{*silkworm::from_hex("00000000003D0900")}; static silkworm::Bytes kHeader{*silkworm::from_hex( "f9025ca0209f062567c161c5f71b3f57a7de277b0e95c3455050b152d785ad" "7524ef8ee7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000" "000000000a0e7536c5b61ed0e0ab7f3ce7f085806d40f716689c0c086676757de401b595658a040be247314d834a319556d1dcf458e87" "07cc1aa4a416b6118474ce0c96fccb1aa07862fe11d10a9b237ffe9cb660f31e4bc4be66836c9bfc17310d47c60d75671fb9010000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000001833d0900837a1200831e784b845fe880abb8" "61d88301091a846765746888676f312e31352e36856c696e757800000000000000be009d0049d6f0ee8ca6764a1d3eb519bd4d046e167" "ddcab467d5db31d063f2d58f266fa86c4502aa169d17762090e92b821843de69b41adbb5d86f5d114ba7f01a000000000000000000000" "00000000000000000000000000000000000000000000880000000000000000")}; static silkworm::Bytes kBody{*silkworm::from_hex("c68369e45a03c0")}; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task { co_return silkworm::Bytes{}; })); auto result = boost::asio::co_spawn(pool, read_receipts(transaction, block_num), boost::asio::use_future); CHECK(result.get() == nullptr); } SECTION("zero receipts") { const uint64_t block_num{0}; EXPECT_CALL(transaction, get_one(table::kBlockReceiptsName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("f6"); })); auto result = boost::asio::co_spawn(pool, read_receipts(transaction, block_num), boost::asio::use_future); const auto receipts = result.get(); CHECK(receipts != nullptr); if (receipts) { CHECK(receipts->empty()); } } SECTION("one receipt") { // https://goerli.etherscan.io/block/3529600 const uint64_t block_num{3'529'600}; EXPECT_CALL(transaction, get_one(table::kBlockReceiptsName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("818400f6011a0004a0c8"); })); auto cursor{std::make_shared()}; EXPECT_CALL(transaction, cursor(table::kLogsName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); EXPECT_CALL(*cursor, seek(_)).WillOnce(Invoke([](Unused) -> Task { silkworm::Bytes key{*silkworm::from_hex("000000000035db8000000000")}; silkworm::Bytes value{*silkworm::from_hex( "8683547753cfad258efbc52a9a1452e42ffbce9be486cb835820ddf252ad1be2c89b69c2b068fc" "378daa952ba7f163c4a11628f55a4df523b3ef5820000000000000000000000000ac399a5dfb98" "48d9e83d92d5f7dda9ba1a00132058200000000000000000000000003dd81545f3149538edcb66" "91a4ffee1898bd2ef0582000000000000000000000000000000000000000000000000000000000" "009896808354ac399a5dfb9848d9e83d92d5f7dda9ba1a0013208158209a7def6556351196c74c" "99e1cc8dcd284e9da181ea854c3e6367cc9fad882a515840000000000000000000000000f13c66" "6056048634109c1ecca6893da293c70da40000000000000000000000000214281cf15c1a66b519" "90e2e65e1f7b7c36331883540214281cf15c1a66b51990e2e65e1f7b7c363318815820be2e1f3a" "6197dfd16fa6830c4870364b618b8b288c21cbcfa4fdb5d7c6a5e45b58409f29225dee002d9875" "a2251ca89348cb8db9656b7ff556065eddb16c9f0618a100000000000000000000000000000000" "0000000000000000000000000000000083547753cfad258efbc52a9a1452e42ffbce9be486cb83" "5820ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef5820000000" "0000000000000000003dd81545f3149538edcb6691a4ffee1898bd2ef058200000000000000000" "000000000828d0386c1122e565f07dd28c7d1340ed5b3315582000000000000000000000000000" "0000000000000000000000000000000098968083543dd81545f3149538edcb6691a4ffee1898bd" "2ef08358202ed7bcf2ff03098102c7003d7ce2a633e4b49b8198b07de5383cdf4c0ab9228b5820" "000000000000000000000000f13c666056048634109c1ecca6893da293c70da458200000000000" "000000000000000214281cf15c1a66b51990e2e65e1f7b7c363318582000000000000000000000" "0000ac399a5dfb9848d9e83d92d5f7dda9ba1a00132083543dd81545f3149538edcb6691a4ffee" "1898bd2ef0835820efaf768237c22e140a862d5d375ad5c153479fac3f8bcf8b580a1651fd62c3" "ef5820000000000000000000000000f13c666056048634109c1ecca6893da293c70da458200000" "000000000000000000000214281cf15c1a66b51990e2e65e1f7b7c363318f6")}; co_return KeyValue{std::move(key), std::move(value)}; })); EXPECT_CALL(*cursor, next()).WillOnce(Invoke([]() -> Task { co_return KeyValue{}; })); auto result = boost::asio::co_spawn(pool, read_receipts(transaction, block_num), boost::asio::use_future); // CHECK(result.get() == Receipts{Receipt{...}}); // TODO(canepat): provide operator== and operator!= for Receipt type CHECK(result.get()->size() == Receipts{std::make_shared(Receipt{})}.size()); } SECTION("many receipts") { // https://goerli.etherscan.io/block/3529600 const uint64_t block_num{3'529'604}; EXPECT_CALL(transaction, get_one(table::kBlockReceiptsName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("828400f6011a0003be508400f6011a0008b89a"); })); auto cursor{std::make_shared()}; EXPECT_CALL(transaction, cursor(table::kLogsName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); EXPECT_CALL(*cursor, seek(_)).WillOnce(Invoke([](Unused) -> Task { silkworm::Bytes key1{*silkworm::from_hex("000000000035db8400000000")}; silkworm::Bytes value1{*silkworm::from_hex( "8383547977d4f555fbee46303682b17e72e3d94339b4418258206155cfd0fd028b0ca77e8495a6" "0cbe563e8bce8611f0aad6fedbdaafc05d44a258200000000000000000000000004ed7fae4af36" "f11ac28275a98ca1d131e91bb6cd58600000000000000000000000000000000000000000000000" "00015bb9773f49f764000000000000000000000000000000000000000000000000015c2a7b13fd" "0000000000000000000000000000000000000000000000000000000000005f7cd33d8354fa365f" "1384e4eaf6d59f353c782af3ea42feaab98258207aa1a8eb998c779420645fc14513bf058edb34" "7d95c2fc2e6845bdc22f88863158200000000000000000000000004ed7fae4af36f11ac28275a9" "8ca1d131e91bb6cd5840000000000000000000000000000000000000000000000000015c2a7b13" "fd0000000000000000000000000000000000000000000000000000000000005f7cd33d835408f0" "006e549edaef936ac2e3cb0c6f7c45ad5f968258202c7d80ba9bc6395644b4ff4a878353ac20ad" "eed6e23cead48c8cec7a58b6e7195820d76aaac3ecd5ced13bbab3b240a426352f76a6fffd583c" "3b15f4ddae2b754e4e5840000000000000000000000000000000000000000000000000015c2a7b" "13fd0000000000000000000000000000000000000000000000000000000000005f7cd33d")}; co_return KeyValue{std::move(key1), std::move(value1)}; })); InSequence following_calls_in_specific_order; EXPECT_CALL(*cursor, next()).WillOnce(Invoke([]() -> Task { silkworm::Bytes key2{*silkworm::from_hex("000000000035db8400000001")}; silkworm::Bytes value2{*silkworm::from_hex( "82835407b39f4fde4a38bace212b546dac87c58dfe3fdc815820649bbc62d0e31342afea4e5cd8" "2d4049e7e1ee912fc0889aa790803be39038c55902400000000000000000000000000000000000" "0000000000000000000000000000a0000000000000000000000000000000000000000000000000" "000000000000010000000000000000000000000000000000000000000000000000000000000001" "400000000000000000000000000000000000000000000000000000000000000180000000000000" "000000000000000000000000000000000000000000000000020000000000000000000000000000" "00000000000000000000000000000000000030a5a151a2320abaab98cfa8366fc326fb6f45cf1c" "93697191ec1370e1caca0fc6237e3bc5328755ae66bc5ddb141f0cb10000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000002000d7" "7be6277f1cdcfce33fdcb127b95fe91e09eec04aecc521dc94866f0055f0000000000000000000" "000000000000000000000000000000000000000000000800405973070000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000060a4dcd35675e049ea5b58d9567f8029669d4cdbe72511d330d96a578e2714" "f1c9db00f6a9babc217b250fc7f217b0261506727657b420d9e05adc73675390ce2eb1e1aef3ba" "c7d1b4b424c9dc07cdcac2729eabdb81c857325e20202ea2476160000000000000000000000000" "0000000000000000000000000000000000000008ac360100000000000000000000000000000000" "00000000000000000000000000835431af35bdfa897cd42b204c003560c385d444707582582026" "725881c2a4290b02cd153d6599fd484f0d4e6062c361e740fbbe39e7ad61425820000000000000" "000000000000000000000000000000000000000000000000000258200000000000000000000000" "00000000000000000000000000000000005f7cd33d")}; co_return KeyValue{std::move(key2), std::move(value2)}; })); EXPECT_CALL(*cursor, next()).WillOnce(Invoke([]() -> Task { co_return KeyValue{}; })); auto result = boost::asio::co_spawn(pool, read_receipts(transaction, block_num), boost::asio::use_future); // CHECK(result.get() == Receipts{Receipt{...}, Receipt{...}}); // TODO(canepat): provide operator== and operator!= for Receipt type CHECK(result.get()->size() == Receipts{std::make_shared(Receipt{}), std::make_shared(Receipt{})}.size()); } SECTION("invalid receipt log") { // https://goerli.etherscan.io/block/3529600 const uint64_t block_num{3'529'600}; EXPECT_CALL(transaction, get_one(table::kBlockReceiptsName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("818400f6011a0004a0c8"); })); auto cursor{std::make_shared()}; EXPECT_CALL(transaction, cursor(table::kLogsName)).WillOnce(Invoke([&cursor](Unused) -> Task> { co_return cursor; })); EXPECT_CALL(*cursor, seek(_)).WillOnce(Invoke([](Unused) -> Task { silkworm::Bytes key{}; silkworm::Bytes value{*silkworm::from_hex( "8683547753cfad258efbc52a9a1452e42ffbce9be486cb835820ddf252ad1be2c89b69c2b068fc" "378daa952ba7f163c4a11628f55a4df523b3ef5820000000000000000000000000ac399a5dfb98" "48d9e83d92d5f7dda9ba1a00132058200000000000000000000000003dd81545f3149538edcb66" "91a4ffee1898bd2ef0582000000000000000000000000000000000000000000000000000000000" "009896808354ac399a5dfb9848d9e83d92d5f7dda9ba1a0013208158209a7def6556351196c74c" "99e1cc8dcd284e9da181ea854c3e6367cc9fad882a515840000000000000000000000000f13c66" "6056048634109c1ecca6893da293c70da40000000000000000000000000214281cf15c1a66b519" "90e2e65e1f7b7c36331883540214281cf15c1a66b51990e2e65e1f7b7c363318815820be2e1f3a" "6197dfd16fa6830c4870364b618b8b288c21cbcfa4fdb5d7c6a5e45b58409f29225dee002d9875" "a2251ca89348cb8db9656b7ff556065eddb16c9f0618a100000000000000000000000000000000" "0000000000000000000000000000000083547753cfad258efbc52a9a1452e42ffbce9be486cb83" "5820ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef5820000000" "0000000000000000003dd81545f3149538edcb6691a4ffee1898bd2ef058200000000000000000" "000000000828d0386c1122e565f07dd28c7d1340ed5b3315582000000000000000000000000000" "0000000000000000000000000000000098968083543dd81545f3149538edcb6691a4ffee1898bd" "2ef08358202ed7bcf2ff03098102c7003d7ce2a633e4b49b8198b07de5383cdf4c0ab9228b5820" "000000000000000000000000f13c666056048634109c1ecca6893da293c70da458200000000000" "000000000000000214281cf15c1a66b51990e2e65e1f7b7c363318582000000000000000000000" "0000ac399a5dfb9848d9e83d92d5f7dda9ba1a00132083543dd81545f3149538edcb6691a4ffee" "1898bd2ef0835820efaf768237c22e140a862d5d375ad5c153479fac3f8bcf8b580a1651fd62c3" "ef5820000000000000000000000000f13c666056048634109c1ecca6893da293c70da458200000" "000000000000000000000214281cf15c1a66b51990e2e65e1f7b7c363318f6")}; co_return KeyValue{std::move(key), std::move(value)}; })); auto result = boost::asio::co_spawn(pool, read_receipts(transaction, block_num), boost::asio::use_future); // TODO(canepat): this case should fail instead of providing 1 receipt with 0 logs const auto receipts = result.get(); CHECK(receipts->size() == 1); CHECK((*receipts)[0]->logs.empty()); } } #endif // _WIN32 TEST_CASE("get_receipts") { WorkerPool pool{1}; db::test_util::MockTransaction transaction; std::unique_ptr backend = std::make_unique(); chain::RemoteChainStorage chain_storage{transaction, ethdb::kv::make_backend_providers(backend.get())}; SECTION("null receipts without data") { const silkworm::BlockWithHash block_with_hash{}; auto result = boost::asio::co_spawn(pool, get_receipts(transaction, block_with_hash, chain_storage, pool), boost::asio::use_future); const auto receipts = result.get(); CHECK(receipts->empty()); } SECTION("zero receipts w/ zero transactions") { const silkworm::BlockWithHash block_with_hash{}; auto result = boost::asio::co_spawn(pool, get_receipts(transaction, block_with_hash, chain_storage, pool), boost::asio::use_future); const auto receipts = result.get(); CHECK(receipts->empty()); } #ifdef TEST_DELETED SECTION("zero receipts w/ non-zero transactions") { const auto block_hash{silkworm::kEmptyHash}; EXPECT_CALL(transaction, get_one(table::kHeaderNumbersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kNumber; })); EXPECT_CALL(transaction, get_one(table::kHeadersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kHeader; })); EXPECT_CALL(transaction, get_one(table::kBlockBodiesName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kBody; })); EXPECT_CALL(transaction, walk(table::kBlockTransactionsName, _, _, _)).WillOnce(Invoke([](Unused, Unused, Unused, Walker w) -> Task { silkworm::Bytes key{}; silkworm::Bytes value{*silkworm::from_hex( "f8ac8301942e8477359400834c4b40945f62669ba0c6cf41cc162d8157ed71a0b9d6dbaf80b844f2" "f0387700000000000000000000000000000000000000000000000000000000000158b09f0270fc889c577c1c64db7c819f921d" "1b6e8c7e5d3f2ff34f162cf4b324cc052ea0d5494ad16e2233197daa9d54cbbcb1ee534cf9f675fa587c264a4ce01e7d3d23a0" "1421bcf57f4b39eb84a35042dc4675ae167f3e2f50e808252afa23e62e692355")}; w(key, value); co_return; })); EXPECT_CALL(transaction, get_one(table::kSendersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("70A5C9D346416f901826581d423Cd5B92d44Ff5a"); })); auto result = boost::asio::co_spawn(pool, read_block_by_hash(transaction, block_hash), boost::asio::use_future); const std::shared_ptr bwh = result.get(); EXPECT_CALL(transaction, get_one(table::kBlockReceiptsName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return silkworm::Bytes{}; })); auto result1 = boost::asio::co_spawn(pool, read_receipts(transaction, *bwh), boost::asio::use_future); #ifdef SILKWORM_SANITIZE // Avoid comparison against exception message: it triggers a TSAN data race seemingly related to libstdc++ string implementation CHECK_THROWS_AS(result1.get(), std::runtime_error); #else CHECK_THROWS_MATCHES(result1.get(), std::runtime_error, Message("#transactions and #receipts do not match in read_receipts")); #endif // SILKWORM_SANITIZE } SECTION("one receipt") { // https://goerli.etherscan.io/block/3529600 const auto block_hash{silkworm::kEmptyHash}; EXPECT_CALL(transaction, get_one(table::kHeaderNumbersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kNumber; })); EXPECT_CALL(transaction, get_one(table::kHeadersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kHeader; })); EXPECT_CALL(transaction, get_one(table::kBlockBodiesName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kBody; })); EXPECT_CALL(transaction, walk(table::kBlockTransactionsName, _, _, _)).WillOnce(Invoke([](Unused, Unused, Unused, Walker w) -> Task { silkworm::Bytes key{}; silkworm::Bytes value{*silkworm::from_hex( "f8ac8301942e8477359400834c4b40945f62669ba0c6cf41cc162d8157ed71a0b9d6dbaf80b844f2" "f0387700000000000000000000000000000000000000000000000000000000000158b09f0270fc889c577c1c64db7c819f921d" "1b6e8c7e5d3f2ff34f162cf4b324cc052ea0d5494ad16e2233197daa9d54cbbcb1ee534cf9f675fa587c264a4ce01e7d3d23a0" "1421bcf57f4b39eb84a35042dc4675ae167f3e2f50e808252afa23e62e692355")}; w(key, value); co_return; })); EXPECT_CALL(transaction, get_one(table::kSendersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("70A5C9D346416f901826581d423Cd5B92d44Ff5a"); })); auto result = boost::asio::co_spawn(pool, read_block_by_hash(transaction, block_hash), boost::asio::use_future); const std::shared_ptr bwh = result.get(); EXPECT_CALL(transaction, get_one(table::kBlockReceiptsName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("818400f6011a0004a0c8"); })); EXPECT_CALL(transaction, walk(table::kLogsName, _, _, _)).WillOnce(Invoke([](Unused, Unused, Unused, Walker w) -> Task { silkworm::Bytes key{*silkworm::from_hex("000000000035db8000000000")}; silkworm::Bytes value{*silkworm::from_hex( "8683547753cfad258efbc52a9a1452e42ffbce9be486cb835820ddf252ad1be2c89b69c2b068fc" "378daa952ba7f163c4a11628f55a4df523b3ef5820000000000000000000000000ac399a5dfb98" "48d9e83d92d5f7dda9ba1a00132058200000000000000000000000003dd81545f3149538edcb66" "91a4ffee1898bd2ef0582000000000000000000000000000000000000000000000000000000000" "009896808354ac399a5dfb9848d9e83d92d5f7dda9ba1a0013208158209a7def6556351196c74c" "99e1cc8dcd284e9da181ea854c3e6367cc9fad882a515840000000000000000000000000f13c66" "6056048634109c1ecca6893da293c70da40000000000000000000000000214281cf15c1a66b519" "90e2e65e1f7b7c36331883540214281cf15c1a66b51990e2e65e1f7b7c363318815820be2e1f3a" "6197dfd16fa6830c4870364b618b8b288c21cbcfa4fdb5d7c6a5e45b58409f29225dee002d9875" "a2251ca89348cb8db9656b7ff556065eddb16c9f0618a100000000000000000000000000000000" "0000000000000000000000000000000083547753cfad258efbc52a9a1452e42ffbce9be486cb83" "5820ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef5820000000" "0000000000000000003dd81545f3149538edcb6691a4ffee1898bd2ef058200000000000000000" "000000000828d0386c1122e565f07dd28c7d1340ed5b3315582000000000000000000000000000" "0000000000000000000000000000000098968083543dd81545f3149538edcb6691a4ffee1898bd" "2ef08358202ed7bcf2ff03098102c7003d7ce2a633e4b49b8198b07de5383cdf4c0ab9228b5820" "000000000000000000000000f13c666056048634109c1ecca6893da293c70da458200000000000" "000000000000000214281cf15c1a66b51990e2e65e1f7b7c363318582000000000000000000000" "0000ac399a5dfb9848d9e83d92d5f7dda9ba1a00132083543dd81545f3149538edcb6691a4ffee" "1898bd2ef0835820efaf768237c22e140a862d5d375ad5c153479fac3f8bcf8b580a1651fd62c3" "ef5820000000000000000000000000f13c666056048634109c1ecca6893da293c70da458200000" "000000000000000000000214281cf15c1a66b51990e2e65e1f7b7c363318f6")}; w(key, value); co_return; })); auto result1 = boost::asio::co_spawn(pool, read_receipts(transaction, *bwh), boost::asio::use_future); // CHECK(result1.get() == Receipts{...}); // TODO(canepat): provide operator== and operator!= for Receipt type CHECK(result1.get().size() == 1); } SECTION("one contract creation receipt") { // TODO(canepat): at least 1 contract creation receipt } SECTION("many receipts") { // https://goerli.etherscan.io/block/469011 const evmc::bytes32 block_hash{0x608e7102f689c99c027c9f49860212348000eb2e13bff37aa4453605a0a2b9e7_bytes32}; EXPECT_CALL(transaction, get_one(table::kHeaderNumbersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kNumber; })); EXPECT_CALL(transaction, get_one(table::kHeadersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kHeader; })); EXPECT_CALL(transaction, get_one(table::kBlockBodiesName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return kBody; })); EXPECT_CALL(transaction, walk(table::kBlockTransactionsName, _, _, _)).WillOnce(Invoke([](Unused, Unused, Unused, Walker w) -> Task { silkworm::Bytes key1{}; silkworm::Bytes value1{*silkworm::from_hex( "f8cb823392843b9aca008303d090947ef66b77759e12caf3ddb3e4aff524e577c59d8d80b864e9c6c1760000000000000000000000000000" "00000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000a4e09362c0d3e9488c" "19c1600c863d0ae91981e20ccdf4679813b521851735b306309b1ba03aaa1d392769f655b7a751d60239ef9a52a70772eb8135e94abc9bc0" "6ea28323a067d93fbedbb12048fc8d70c5b99dddaaf04a109894671a57f1285f48a9e3b3e9")}; w(key1, value1); silkworm::Bytes key2{}; silkworm::Bytes value2{*silkworm::from_hex( "f8cb823393843b9aca008303d090947ef66b77759e12caf3ddb3e4aff524e577c59d8d80b864e9c6c1760000000000000000000000000000" "00000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000004100fa3ce6ba2fb2eb" "7fa648ad0970b9f8eecfd4c511bf7499c971c10743c555ed24961ba0752f02b1438be7f67ebf0e71310db3514b162fb169cdb95ad15dde38" "eff7719ba01033638bf86024fe2750ace6f79ea444703f6920979ad1fd495f9167d197a436")}; w(key2, value2); co_return; })); EXPECT_CALL(transaction, get_one(table::kSendersName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex( "be188D6641E8b680743A4815dFA0f6208038960F" "Dd74564BC9ff247C23f02cFbA1083c805829D981"); })); auto result = boost::asio::co_spawn(pool, read_block_by_hash(transaction, block_hash), boost::asio::use_future); const std::shared_ptr bwh = result.get(); EXPECT_CALL(transaction, get_one(table::kBlockReceiptsName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return *silkworm::from_hex("828400f6011a00016e5b8400f6011a0002dc76"); })); EXPECT_CALL(transaction, walk(table::kLogsName, _, _, _)).WillOnce(DoAll(Invoke([](Unused, Unused, Unused, Walker w) -> Task { silkworm::Bytes key{*silkworm::from_hex("000000000007281300000000")}; silkworm::Bytes value{*silkworm::from_hex( "8183547ef66b77759e12caf3ddb3e4aff524e577c59d8d8358208a22ee899102a366ac8ad0495127319cb1ff2403cfae855f83a89cda126667" "4d5820000000000000000000000000000000000000000000000000000000000000002a58200000000000000000000000000000000000000000" "000000000000000000a4e093582062c0d3e9488c19c1600c863d0ae91981e20ccdf4679813b521851735b306309b")}; w(key, value); co_return; }), Invoke([](Unused, Unused, Unused, Walker w) -> Task { silkworm::Bytes key{*silkworm::from_hex("000000000007281300000001")}; silkworm::Bytes value{*silkworm::from_hex( "8183547ef66b77759e12caf3ddb3e4aff524e577c59d8d8358208a22ee899102a366ac8ad0495127319cb1ff2403cfae855f83a89cda126667" "4d5820000000000000000000000000000000000000000000000000000000000000000458200000000000000000000000000000000000000000" "0000000000000000004100fa58203ce6ba2fb2eb7fa648ad0970b9f8eecfd4c511bf7499c971c10743c555ed2496")}; w(key, value); co_return; }))); auto result1 = boost::asio::co_spawn(pool, read_receipts(transaction, *bwh), boost::asio::use_future); // CHECK(result1.get() == Receipts{Receipt{...}, Receipt{...}}); // TODO(canepat): provide operator== and operator!= for Receipt type CHECK(result1.get().size() == Receipts{Receipt{}, Receipt{}}.size()); } #endif } } // namespace silkworm::rpc::core ================================================ FILE: silkworm/rpc/core/storage_walker.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "storage_walker.hpp" #include #include #include #include #include #include namespace silkworm::rpc { Bytes make_key(const evmc::address& address, const evmc::bytes32& location) { Bytes res(silkworm::kAddressLength + kHashLength, '\0'); std::memcpy(&res[0], address.bytes, kAddressLength); std::memcpy(&res[kAddressLength], location.bytes, kHashLength); return res; } Task StorageWalker::storage_range_at( TxnId txn_number, const evmc::address& address, const evmc::bytes32& start_location, StorageCollector& collector) { auto from{make_key(address, start_location)}; auto to = db::code_domain_key(address); increment(to); db::kv::api::DomainRangeRequest query{ .table = std::string{db::table::kStorageDomain}, .from_key = from, .to_key = to, .timestamp = txn_number, .ascending_order = true}; auto paginated_result = co_await transaction_.range_as_of(std::move(query)); auto it = co_await paginated_result.begin(); while (const auto value = co_await it->next()) { if (value->second.empty()) continue; SILKWORM_ASSERT(value->first.size() >= kAddressLength); const auto key = value->first.substr(kAddressLength); auto hash = hash_of(key); const auto sec_key = ByteView{hash.bytes}; if (!collector(key, sec_key, value->second)) co_return; } co_return; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/storage_walker.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc { silkworm::Bytes make_key(const evmc::address& address, const evmc::bytes32& location); class StorageWalker { public: using AccountCollector = std::function; using StorageCollector = std::function; explicit StorageWalker(db::kv::api::Transaction& transaction) : transaction_(transaction) {} StorageWalker(const StorageWalker&) = delete; StorageWalker& operator=(const StorageWalker&) = delete; Task storage_range_at( TxnId txn_number, const evmc::address& address, const evmc::bytes32& start_location, StorageCollector& collector); private: db::kv::api::Transaction& transaction_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/core/storage_walker_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "storage_walker.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using db::chain::ChainStorage; using db::kv::api::BaseTransaction; using db::kv::api::Cursor; using db::kv::api::CursorDupSort; using db::kv::api::KeyValue; static const nlohmann::json kEmpty; static constexpr std::string_view kZeros = "00000000000000000000000000000000000000000000000000000000000000000000000000000000"; class DummyCursor : public CursorDupSort { public: explicit DummyCursor(const nlohmann::json& json) : json_{json} {} uint32_t cursor_id() const override { return 0; } Task open_cursor(std::string_view table_name, bool /*is_dup_cursor*/) override { table_name_ = table_name; table_ = json_.value(table_name_, kEmpty); itr_ = table_.end(); co_return; } Task close_cursor() override { table_name_ = ""; co_return; } Task seek(silkworm::ByteView key) override { const auto key_hex = silkworm::to_hex(key); KeyValue out; for (itr_ = table_.begin(); itr_ != table_.end(); ++itr_) { auto actual = key_hex; auto delta = itr_.key().size() - actual.size(); if (delta > 0) { actual += kZeros.substr(0, delta); } if (itr_.key() >= actual) { auto kk{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{kk, value}; break; } } co_return out; } Task seek_exact(silkworm::ByteView key) override { const nlohmann::json table = json_.value(table_name_, kEmpty); const auto& entry = table.value(silkworm::to_hex(key), ""); auto value{*silkworm::from_hex(entry)}; auto kv = KeyValue{silkworm::Bytes{key}, value}; co_return kv; } Task first() override { throw std::logic_error{"not implemented"}; } Task last() override { throw std::logic_error{"not implemented"}; } Task next() override { KeyValue out; if (++itr_ != table_.end()) { auto key{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{key, value}; } co_return out; } Task previous() override { KeyValue out; if (--itr_ != table_.begin()) { auto key{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{key, value}; } co_return out; } Task next_dup() override { KeyValue out; if (++itr_ != table_.end()) { auto key{*silkworm::from_hex(itr_.key())}; auto value{*silkworm::from_hex(itr_.value().get())}; out = KeyValue{key, value}; } co_return out; } Task seek_both(silkworm::ByteView key, silkworm::ByteView value) override { silkworm::Bytes key_val{key}; key_val += value; const nlohmann::json table = json_.value(table_name_, kEmpty); const auto& entry = table.value(silkworm::to_hex(key_val), ""); auto out{*silkworm::from_hex(entry)}; co_return out; } Task seek_both_exact(silkworm::ByteView key, silkworm::ByteView value) override { silkworm::Bytes key_val{key}; key_val += value; const nlohmann::json table = json_.value(table_name_, kEmpty); const auto& entry = table.value(silkworm::to_hex(key_val), ""); auto out{*silkworm::from_hex(entry)}; auto kv = KeyValue{silkworm::Bytes{}, out}; co_return kv; } private: std::string table_name_; const nlohmann::json& json_; nlohmann::json table_; nlohmann::json::iterator itr_; }; class DummyTransaction : public BaseTransaction { public: explicit DummyTransaction(const nlohmann::json& json) : BaseTransaction{nullptr}, json_{json} {} uint64_t tx_id() const override { return 0; } uint64_t view_id() const override { return 0; } Task open() override { co_return; } Task> cursor(std::string_view table) override { auto cursor = std::make_unique(json_); co_await cursor->open_cursor(table, false); co_return cursor; } Task> cursor_dup_sort(std::string_view table) override { auto cursor = std::make_unique(json_); co_await cursor->open_cursor(table, true); co_return cursor; } std::shared_ptr make_storage() override { return nullptr; } Task first_txn_num_in_block(BlockNum /*block_num*/) override { co_return 0; } Task close() override { co_return; } Task get_latest(db::kv::api::GetLatestRequest /*query*/) override { co_return db::kv::api::GetLatestResult{}; } Task get_as_of(db::kv::api::GetAsOfRequest /*query*/) override { co_return db::kv::api::GetAsOfResult{}; } Task history_seek(db::kv::api::HistoryPointRequest /*query*/) override { co_return db::kv::api::HistoryPointResult{}; } Task index_range(db::kv::api::IndexRangeRequest /*query*/) override { co_return test::empty_timestamps(); } Task history_range(db::kv::api::HistoryRangeRequest /*query*/) override { co_return test::empty_keys_and_values(); } Task range_as_of(db::kv::api::DomainRangeRequest /*query*/) override { co_return test::empty_keys_and_values(); } private: const nlohmann::json& json_; }; class DummyDatabase : public db::kv::api::Service { public: explicit DummyDatabase(const nlohmann::json& json) : json_{json} {} Task> begin_transaction() override { auto txn = std::make_unique(json_); co_return txn; } Task version() override { co_return db::kv::api::kCurrentVersion; } Task state_changes(const db::kv::api::StateChangeOptions&, db::kv::api::StateChangeConsumer) override { co_return; } private: const nlohmann::json& json_; }; TEST_CASE("StorageWalker::storage_range_at") { WorkerPool pool{1}; nlohmann::json json; json["PlainState"] = { {"79a4d418f7887dd4d5123a41b6c8c186686ae8cb", "030207fc08107ee3bbb7bf3a70"}, {"79a4d492a05cfd836ea0967edb5943161dd041f7", "0d0101010120d6ea9698de278dad2f31566cd744dd75c4e09925b4bb8f041d265012a940797c"}, {"79a4d492a05cfd836ea0967edb5943161dd041f700000000000000010000000000000000000000000000000000000000000000000000000000000001", "2ac3c1d3e24b45c6c310534bc2dd84b5ed576335"}, {"79a4d492a05cfd836ea0967edb5943161dd041f700000000000000010000000000000000000000000000000000000000000000000000000000000006", "335a9b3f79dcfefda3295be6f7c7c47f077dbcd9"}, {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea", "0d0101010120925fa7384049febb1eddca32821f1f1d709687628c1cf77ef40ca5013d04bdef"}, {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010000000000000000000000000000000000000000000000000000000000000001", "2ac3c1d3e24b45c6c310534bc2dd84b5ed576335"}, {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010000000000000000000000000000000000000000000000000000000000000003", "1f6ea08600"}, {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010000000000000000000000000000000000000000000000000000000000000006", "9d5a08e7551951a3ca73cd84a6409ef1e77f5abe"}, {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea00000000000000010178b166a1bcfd299a6ce6918f016c8d0c52788988d89f65f5727c2fa97be6e9", "1e80355e00"}, {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000001b797965b738ad51ddbf643b315d0421c26972862ca2e64304783dc8930a2b6e8", "ee6b2800"}, {"79a4d75bd00b1843ec5292217e71dace5e5a7439", "03010107181855facbc200"}}; json["StorageHistory"] = { {"79a4d492a05cfd836ea0967edb5943161dd041f70000000000000000000000000000000000000000000000000000000000000001ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000019b"}, // NOLINT {"79a4d492a05cfd836ea0967edb5943161dd041f70000000000000000000000000000000000000000000000000000000000000006ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000019b"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000000000000000000000000000000000000000000000000000001ffffffffffffffff", "0100000000000000000000003a300000010000004800000010000000b9e0"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000000000000000000000000000000000000000000000000000003ffffffffffffffff", "0100000000000000000000003a300000010000004b00010010000000d505c5c5"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0000000000000000000000000000000000000000000000000000000000000006ffffffffffffffff", "0100000000000000000000003a300000010000004800000010000000b9e0"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981ea0178b166a1bcfd299a6ce6918f016c8d0c52788988d89f65f5727c2fa97be6e9ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000c5c5"}, // NOLINT {"79a4d706e4bc7fd8ff9d0593a1311386a7a981eab797965b738ad51ddbf643b315d0421c26972862ca2e64304783dc8930a2b6e8ffffffffffffffff", "0100000000000000000000003a300000010000004b00000010000000d505"}, // NOLINT {"79a4e7d68b82799b9d52609756b86bd18193f2b20000000000000000000000000000000000000000000000000000000000000000ffffffffffffffff", "0100000000000000000000003a300000010000004d0000001000000052ca"} // NOLINT }; auto database = DummyDatabase{json}; auto result = boost::asio::co_spawn(pool, database.begin_transaction(), boost::asio::use_future); auto tx = result.get(); StorageWalker walker{*tx}; const evmc::bytes32 start_location{}; nlohmann::json storage({}); StorageWalker::StorageCollector collector = [&](const silkworm::ByteView key, const silkworm::ByteView sec_key, const silkworm::ByteView value) { auto val = silkworm::to_hex(value); val.insert(0, 64 - val.size(), '0'); storage["0x" + silkworm::to_hex(sec_key)] = {{"key", "0x" + silkworm::to_hex(key)}, {"value", "0x" + val}}; return true; }; SECTION("storage range 1") { const evmc::address start_address{0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address}; auto result1 = boost::asio::co_spawn(pool, walker.storage_range_at(10000, start_address, start_location, collector), boost::asio::use_future); result1.get(); CHECK(storage.empty()); } } TEST_CASE("make key for address and location") { evmc::address address = 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address; evmc::bytes32 location = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32; auto key = make_key(address, location); CHECK(silkworm::to_hex(key) == "79a4d418f7887dd4d5123a41b6c8c186686ae8cb56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/daemon.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "daemon.hpp" #ifndef WIN32 #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { //! The maximum receive message in bytes for gRPC channels. static constexpr int kRpcMaxReceiveMessageSize = 64 * 1024 * 1024; // 64 MiB //! The maximum number of concurrent readers allowed for MDBX datastore. static constexpr int kDatabaseMaxReaders = 32000; void DaemonChecklist::success_or_throw() const { for (const auto& protocol_check : protocol_checklist) { if (!protocol_check.compatible) { throw std::runtime_error{protocol_check.result}; } } } static const char* current_exception_name() { #ifdef WIN32 return ""; #else int status{0}; return abi::__cxa_demangle(abi::__cxa_current_exception_type()->name(), nullptr, nullptr, &status); #endif } //! Assemble the relevant library version information static std::string get_library_versions() { std::string library_versions{"gRPC: "}; library_versions.append(grpc::Version()); library_versions.append(" Boost Asio: "); library_versions.append(std::to_string(BOOST_ASIO_VERSION)); return library_versions; } int Daemon::run(const DaemonSettings& settings) { const bool are_settings_valid{validate_settings(settings)}; if (!are_settings_valid) { return -1; } auto& log_settings = settings.log_settings; auto& context_pool_settings = settings.context_pool_settings; log::init(log_settings); log::set_thread_name("main-thread"); const auto mdbx_ver{mdbx::get_version()}; const auto mdbx_bld{mdbx::get_build()}; SILK_INFO << "Silkrpc starting " << settings.build_info.build_description << " " << get_library_versions(); SILK_INFO << "Silkrpc libmdbx version: " << mdbx_ver.git.describe << " build: " << mdbx_bld.target << " compiler: " << mdbx_bld.compiler; std::set_terminate([]() { try { auto exc = std::current_exception(); if (exc) { std::rethrow_exception(exc); } } catch (const std::exception& e) { SILK_CRIT << "Silkrpc terminating due to exception: " << e.what(); } catch (...) { SILK_CRIT << "Silkrpc terminating due to unexpected exception: " << current_exception_name(); } std::abort(); }); const auto pid = boost::this_process::get_id(); const auto tid = std::this_thread::get_id(); try { constexpr uint64_t kMaxFileDescriptors{10'240}; const uint64_t current_max_file_descriptors = os::max_file_descriptors(); if (current_max_file_descriptors < kMaxFileDescriptors) { const bool set_fd_result = os::set_max_file_descriptors(kMaxFileDescriptors); if (!set_fd_result) { throw std::runtime_error{"Cannot increase max file descriptors up to " + std::to_string(kMaxFileDescriptors)}; } const uint64_t new_max_file_descriptors = os::max_file_descriptors(); SILK_INFO << "Silkrpc raised fd limit from " << current_max_file_descriptors << " to " << new_max_file_descriptors; } if (!settings.datadir) { SILK_INFO << "Silkrpc launched with private address " << settings.private_api_addr << " using " << context_pool_settings.num_contexts << " contexts, " << settings.num_workers << " workers"; } else { SILK_INFO << "Silkrpc launched with datadir " << *settings.datadir << " using " << context_pool_settings.num_contexts << " contexts, " << settings.num_workers << " workers"; } // Activate the local chaindata and snapshot access (if required) std::optional data_store; std::optional chain_config; if (settings.datadir) { DataDirectory data_dir{*settings.datadir}; silkworm::datastore::kvdb::EnvConfig db_config{ .path = data_dir.chaindata().path().string(), .readonly = true, .shared = true, .max_readers = kDatabaseMaxReaders}; data_store.emplace(db::DataStore{ db_config, data_dir.snapshots().path(), }); // At startup check that chain configuration is valid datastore::kvdb::ROTxnManaged ro_txn = data_store->chaindata().access_ro().start_ro_tx(); db::DataModel data_access = db::DataModelFactory{data_store->ref()}(ro_txn); if (chain_config = data_access.read_chain_config(); !chain_config) { throw std::runtime_error{"invalid chain configuration"}; } } // Create the one-and-only Silkrpc daemon Daemon rpc_daemon{ settings, chain_config, data_store ? std::make_optional(data_store->ref()) : std::nullopt, }; // Check protocol version compatibility with Core Services if (!settings.skip_protocol_check) { SILK_INFO << "Checking protocol version compatibility with core services..."; const auto checklist = rpc_daemon.run_checklist(); for (const auto& protocol_check : checklist.protocol_checklist) { SILK_INFO << protocol_check.result; } checklist.success_or_throw(); } else { SILK_INFO << "Skip protocol version compatibility check with core services"; } // Start execution context dedicated to handling termination signals boost::asio::io_context shutdown_signal_ioc; boost::asio::signal_set shutdown_signal{shutdown_signal_ioc, SIGINT, SIGTERM}; shutdown_signal.async_wait([&](const boost::system::error_code& error, int signal_number) { if (signal_number == SIGINT) std::cout << "\n"; SILK_INFO << "Signal number: " << signal_number << " caught" << (error ? ", error: " + error.message() : ""); rpc_daemon.stop(); }); SILK_INFO << "Starting ETH RPC API at " << settings.eth_end_point << " ENGINE RPC API at " << settings.engine_end_point; rpc_daemon.start(); SILK_LOG << "Silkrpc is now running [pid=" << pid << ", main thread=" << tid << "]"; shutdown_signal_ioc.run(); rpc_daemon.join(); } catch (const std::exception& e) { SILK_CRIT << "Exception: " << e.what(); } catch (...) { SILK_CRIT << "Unexpected exception: " << current_exception_name(); } SILK_LOG << "Silkrpc exiting [pid=" << pid << ", main thread=" << tid << "]"; return 0; } bool Daemon::validate_settings(const DaemonSettings& settings) { if (!settings.datadir && settings.private_api_addr.empty()) { SILK_ERROR << "Parameters datadir and private_api_addr cannot be both empty, specify one of them"; SILK_ERROR << "Use --datadir or --private_api_addr flag to specify the path of database or the location of running instance"; return false; } return true; } ChannelFactory Daemon::make_channel_factory(const DaemonSettings& settings) { return [&settings]() { grpc::ChannelArguments channel_args; // Allow to receive messages up to specified max size channel_args.SetMaxReceiveMessageSize(kRpcMaxReceiveMessageSize); // Allow each client to open its own TCP connection to server (sharing one single connection becomes a bottleneck under high load) channel_args.SetInt(GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL, 1); return grpc::CreateCustomChannel(settings.private_api_addr, grpc::InsecureChannelCredentials(), channel_args); }; } Daemon::Daemon( DaemonSettings settings, std::optional chain_config, std::optional data_store) : settings_(std::move(settings)), chain_config_{std::move(chain_config)}, channel_factory_{make_channel_factory(settings_)}, context_pool_{settings_.context_pool_settings.num_contexts}, worker_pool_{settings_.num_workers}, data_store_{std::move(data_store)} { // Load the channel authentication token (if required) if (settings_.jwt_secret_file) { jwt_secret_ = load_jwt_token(*settings_.jwt_secret_file); } // Create shared and private state in execution contexts: order *matters* (e.g. for state cache) add_shared_services(); add_private_services(); EVMExecutor::register_service(worker_pool_); // Create the unique KV state-changes stream feeding the state cache auto& context = context_pool_.next_context(); // TODO(canepat) should be /*remote=*/settings.standalone but we must fix state changes in db::kv::api::DirectClient mode state_changes_client_ = make_kv_client(context, /*remote=*/true); state_changes_stream_ = std::make_unique(context, *state_changes_client_); // Set compatibility with Erigon RpcDaemon at JSON RPC level compatibility::set_erigon_json_api_compatibility_required(settings_.erigon_json_rpc_compatibility); // Load JSON RPC specification for Ethereum API rpc::json_rpc::Validator::load_specification(); } void Daemon::add_private_services() { auto grpc_channel = channel_factory_(); // Add the private state to each execution context for (size_t i{0}; i < settings_.context_pool_settings.num_contexts; ++i) { auto& context = context_pool_.next_context(); auto& ioc = *context.ioc(); auto& grpc_context{*context.grpc_context()}; add_private_service(ioc, std::make_unique(grpc_channel, grpc_context)); add_private_service(ioc, make_kv_client(context, /*remote=*/!settings_.datadir)); add_private_service(ioc, std::make_unique(grpc_channel, grpc_context)); add_private_service(ioc, std::make_unique(grpc_channel, grpc_context)); } } void Daemon::add_shared_services() { // Create the unique block cache to be shared among the execution contexts auto block_cache = std::make_shared(); // Create the unique state cache to be shared among the execution contexts auto state_cache = std::make_shared(); // Create the unique filter storage to be shared among the execution contexts auto filter_storage = std::make_shared(context_pool_.size() * kDefaultFilterStorageSize); // Add the shared state to the execution contexts for (size_t i{0}; i < settings_.context_pool_settings.num_contexts; ++i) { auto& context = context_pool_.next_context(); auto& ioc = *context.ioc(); auto engine{std::make_shared(settings_.private_api_addr, *context.grpc_context())}; add_shared_service(ioc, block_cache); add_shared_service(ioc, state_cache); add_shared_service(ioc, filter_storage); add_shared_service(ioc, std::move(engine)); } } std::unique_ptr Daemon::make_kv_client(rpc::ClientContext& context, bool remote) { auto& ioc = *context.ioc(); auto& grpc_context = *context.grpc_context(); auto* state_cache{must_use_shared_service(ioc)}; auto* backend{must_use_private_service(ioc)}; if (remote) { return std::make_unique( channel_factory_, grpc_context, state_cache, ethdb::kv::make_backend_providers(backend)); } // TODO(canepat) finish implementation and clean-up composition of objects here db::kv::api::StateChangeRunner runner{ioc.get_executor()}; db::kv::api::ServiceRouter router{runner.state_changes_calls_channel()}; return std::make_unique( std::make_shared(router, *data_store_, *chain_config_, state_cache)); } void Daemon::add_execution_services(const std::vector>& engines) { ensure(engines.size() == settings_.context_pool_settings.num_contexts, "Daemon::add_execution_services: number of execution engines must be equal to the number of contexts"); // Add the Engine API execution service to each execution context for (size_t i{0}; i < settings_.context_pool_settings.num_contexts; ++i) { auto& ioc = context_pool_.next_ioc(); add_shared_service(ioc, engines[i]); } } DaemonChecklist Daemon::run_checklist() { const auto core_service_channel{channel_factory_()}; const auto kv_protocol_check{wait_for_kv_protocol_check(core_service_channel)}; const auto ethbackend_protocol_check{wait_for_ethbackend_protocol_check(core_service_channel)}; const auto mining_protocol_check{wait_for_mining_protocol_check(core_service_channel)}; const auto txpool_protocol_check{wait_for_txpool_protocol_check(core_service_channel)}; DaemonChecklist checklist{{kv_protocol_check, ethbackend_protocol_check, mining_protocol_check, txpool_protocol_check}}; return checklist; } void Daemon::start() { auto make_rpc_server = [this](std::string_view end_point, std::string_view api_spec, boost::asio::io_context& ioc, std::optional jwt_secret, InterfaceLogSettings ilog_settings) { commands::RpcApi rpc_api{ioc, worker_pool_, settings_.build_info}; commands::RpcApiTable handler_table{api_spec}; auto make_jsonrpc_handler = [rpc_api = std::move(rpc_api), handler_table = std::move(handler_table), ilog_settings = std::move(ilog_settings)](StreamWriter* stream_writer) mutable { return std::make_unique(stream_writer, rpc_api, handler_table, ilog_settings); }; return std::make_unique( end_point, std::move(make_jsonrpc_handler), ioc, worker_pool_, settings_.cors_domain, std::move(jwt_secret), settings_.use_websocket, settings_.ws_compression, settings_.http_compression, settings_.erigon_json_rpc_compatibility); }; // Put the interface logs into the data folder std::filesystem::path data_folder{}; if (data_store_) { datastore::kvdb::RWAccess chaindata = data_store_->chaindata.access_rw(); mdbx::env& chaindata_env = *chaindata; auto chaindata_path = chaindata_env.get_path(); // Trick to remove any empty filename because MDBX chaindata path ends with '/' if (chaindata_path.filename().empty()) { chaindata_path = chaindata_path.parent_path(); } data_folder = chaindata_path.parent_path(); } if (settings_.datadir) { data_folder = *settings_.datadir; } settings_.eth_ifc_log_settings.container_folder = data_folder / settings_.eth_ifc_log_settings.container_folder; settings_.engine_ifc_log_settings.container_folder = data_folder / settings_.engine_ifc_log_settings.container_folder; // Create and start the configured RPC services for each execution context for (size_t i{0}; i < settings_.context_pool_settings.num_contexts; ++i) { auto& ioc = context_pool_.next_ioc(); if (!settings_.eth_end_point.empty()) { // ETH RPC API accepts customized namespaces and does not support JWT authentication rpc_services_.emplace_back(make_rpc_server( settings_.eth_end_point, settings_.eth_api_spec, ioc, /*jwt_secret=*/std::nullopt, settings_.eth_ifc_log_settings)); } if (!settings_.engine_end_point.empty()) { // Engine RPC API has fixed namespaces and supports JWT authentication rpc_services_.emplace_back(make_rpc_server( settings_.engine_end_point, kDefaultEth2ApiSpec, ioc, jwt_secret_, settings_.engine_ifc_log_settings)); } } for (auto& service : rpc_services_) { service->start(); } // Open the KV state-changes stream feeding the state cache state_changes_stream_->open(); context_pool_.start(); } void Daemon::stop() { // Cancel registration for incoming KV state changes state_changes_stream_->close(); context_pool_.stop(); } void Daemon::join() { context_pool_.join(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/daemon.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include "settings.hpp" namespace silkworm::rpc { struct DaemonChecklist { std::vector protocol_checklist; void success_or_throw() const; }; class Daemon { public: static int run(const DaemonSettings& settings); Daemon( DaemonSettings settings, std::optional chain_config, std::optional data_store); Daemon(const Daemon&) = delete; Daemon& operator=(const Daemon&) = delete; ClientContextPool& context_pool() { return context_pool_; } void add_execution_services(const std::vector>& engines); DaemonChecklist run_checklist(); void start(); void stop(); void join(); protected: static bool validate_settings(const DaemonSettings& settings); static ChannelFactory make_channel_factory(const DaemonSettings& settings); void add_private_services(); void add_shared_services(); std::unique_ptr make_kv_client(rpc::ClientContext& context, bool remote); //! The RPC daemon configuration settings. DaemonSettings settings_; //! The chain configuration or std::nullopt if working remotely std::optional chain_config_; //! The factory of gRPC client-side channels. ChannelFactory channel_factory_; //! The execution contexts capturing the asynchronous scheduling model. ClientContextPool context_pool_; //! The pool of workers for long-running tasks. WorkerPool worker_pool_; //! The data store or std::nullopt if working remotely std::optional data_store_; //! The JSON RPC API services. std::vector> rpc_services_; //! The KV client supporting the state changes stream. std::unique_ptr state_changes_client_; //! The stream handling StateChanges server-streaming RPC. std::unique_ptr state_changes_stream_; //! The secret key for communication from CL & EL std::optional jwt_secret_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/daemon_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "daemon.hpp" #include namespace silkworm::rpc { #ifndef BUILD_COVERAGE TEST_CASE("DaemonChecklist::success_or_throw", "[rpc]") { DaemonChecklist checklist; SECTION("empty checklist does not throw") { CHECK_NOTHROW(checklist.success_or_throw()); } SECTION("checklist w/ at least one incompatible throws") { checklist.protocol_checklist.emplace_back(ProtocolVersionResult{false, ""}); CHECK_THROWS_AS(checklist.success_or_throw(), std::runtime_error); } } #endif // BUILD_COVERAGE } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/engine/conversion.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "conversion.hpp" #include #include #include #include namespace silkworm::rpc::engine { using namespace execution::api; class PayloadValidationError : public std::logic_error { public: PayloadValidationError() : std::logic_error("payload validation error, unknown reason") {} explicit PayloadValidationError(const std::string& reason) : std::logic_error(reason) {} }; rpc::ForkChoiceUpdatedReply fork_choice_updated_reply_from_result(const ForkChoiceResult& result) { rpc::ForkChoiceUpdatedReply reply; switch (result.status) { case ExecutionStatus::kSuccess: reply.payload_status = rpc::PayloadStatus::kAccepted; break; case ExecutionStatus::kInvalidForkchoice: reply.payload_status.status = rpc::PayloadStatus::kInvalidStr; break; case ExecutionStatus::kBadBlock: reply.payload_status.status = rpc::PayloadStatus::kInvalidBlockHashStr; break; case ExecutionStatus::kBusy: case ExecutionStatus::kMissingSegment: case ExecutionStatus::kTooFarAway: reply.payload_status.status = rpc::PayloadStatus::kSyncingStr; break; } if (!result) { reply.payload_status.latest_valid_hash = result.latest_valid_head; reply.payload_status.validation_error = result.validation_error; } return reply; } rpc::ExecutionPayloadBodies execution_payloads_from_bodies(const execution::api::BlockBodies& bodies) { rpc::ExecutionPayloadBodies payload_bodies; payload_bodies.resize(bodies.size()); for (const auto& block_body : bodies) { std::vector rlp_txs; rlp_txs.reserve(block_body.transactions.size()); for (const auto& transaction : block_body.transactions) { Bytes tx_rlp; rlp::encode(tx_rlp, transaction); rlp_txs.emplace_back(tx_rlp.data(), tx_rlp.size()); } rpc::ExecutionPayloadBody payload_body{ .transactions = std::move(rlp_txs), .withdrawals = block_body.withdrawals, }; payload_bodies.push_back(std::move(payload_body)); } return payload_bodies; } std::shared_ptr block_from_execution_payload(const rpc::ExecutionPayload& payload) { std::shared_ptr block = std::make_shared(); BlockHeader& header = block->header; header.number = payload.block_num; header.timestamp = payload.timestamp; header.parent_hash = payload.parent_hash; header.state_root = payload.state_root; header.receipts_root = payload.receipts_root; header.logs_bloom = payload.logs_bloom; header.gas_used = payload.gas_used; header.gas_limit = payload.gas_limit; header.timestamp = payload.timestamp; header.extra_data = payload.extra_data; header.base_fee_per_gas = payload.base_fee; header.beneficiary = payload.suggested_fee_recipient; for (const auto& rlp_encoded_tx : payload.transactions) { ByteView rlp_encoded_tx_view{rlp_encoded_tx}; Transaction tx; auto decoding_result = rlp::decode_transaction(rlp_encoded_tx_view, tx, rlp::Eip2718Wrapping::kBoth); if (!decoding_result) { std::string reason{magic_enum::enum_name(decoding_result.error())}; throw PayloadValidationError("tx rlp decoding error: " + reason); } block->transactions.push_back(tx); } header.transactions_root = protocol::compute_transaction_root(*block); // as per EIP-4895 if (payload.withdrawals) { block->withdrawals = std::vector{}; block->withdrawals->reserve(payload.withdrawals->size()); std::copy(payload.withdrawals->begin(), payload.withdrawals->end(), std::back_inserter(*block->withdrawals)); header.withdrawals_root = protocol::compute_withdrawals_root(*block); } // as per EIP-3675 header.ommers_hash = kEmptyListHash; // = Keccak256(RLP([])) header.difficulty = 0; header.nonce = {0, 0, 0, 0, 0, 0, 0, 0}; block->ommers = {}; // RLP([]) = 0xc0 // as per EIP-4399 header.prev_randao = payload.prev_randao; // as per EIP-4844 header.blob_gas_used = payload.blob_gas_used; header.excess_blob_gas = payload.excess_blob_gas; return block; } } // namespace silkworm::rpc::engine ================================================ FILE: silkworm/rpc/engine/conversion.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc::engine { rpc::ForkChoiceUpdatedReply fork_choice_updated_reply_from_result(const execution::api::ForkChoiceResult&); rpc::ExecutionPayloadBodies execution_payloads_from_bodies(const execution::api::BlockBodies&); //! Convert an ExecutionPayload to a Block as per Engine API spec std::shared_ptr block_from_execution_payload(const rpc::ExecutionPayload&); } // namespace silkworm::rpc::engine ================================================ FILE: silkworm/rpc/engine/execution_engine.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc::engine { class ExecutionEngine { public: virtual ~ExecutionEngine() = default; using Msec = std::chrono::milliseconds; virtual Task new_payload(const NewPayloadRequest& request, Msec timeout) = 0; virtual Task fork_choice_updated(const ForkChoiceUpdatedRequest& request, Msec timeout) = 0; virtual Task get_payload(uint64_t payload_id, Msec timeout) = 0; virtual Task get_payload_bodies_by_hash(const std::vector& block_hashes, Msec timeout) = 0; virtual Task get_payload_bodies_by_range(BlockNum start, uint64_t count, Msec timeout) = 0; }; } // namespace silkworm::rpc::engine ================================================ FILE: silkworm/rpc/engine/remote_execution_engine.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_execution_engine.hpp" #include #include #include #include #include #include "conversion.hpp" #include "validation.hpp" namespace silkworm::rpc::engine { using namespace concurrency::awaitable_wait_for_one; using namespace execution::api; Task RemoteExecutionEngine::new_payload(const NewPayloadRequest& request, Msec timeout) { const auto& payload{request.execution_payload}; // Make the execution full block from the block payload auto block = block_from_execution_payload(payload); if (request.parent_beacon_block_root) { block->header.parent_beacon_block_root = request.parent_beacon_block_root; } // Validations if (const auto result = validate_blob_hashes(*block, request.expected_blob_versioned_hashes); !result) { co_return PayloadStatus{std::string{rpc::PayloadStatus::kInvalidStr}, {}, result.error()}; } const Hash block_hash = block->header.hash(); if (payload.block_hash != block_hash) { co_return PayloadStatus::kInvalidBlockHash; } // Insert the new block std::vector> blocks{std::move(block)}; const auto insert_result = co_await execution_service_->insert_blocks(blocks); if (!insert_result) { co_return PayloadStatus::kSyncing; } // Retrieve back the block number const auto block_num = co_await execution_service_->get_header_hash_number(block_hash); if (!block_num) { co_return PayloadStatus::kAccepted; } const auto verification = co_await (execution_service_->validate_chain({*block_num, block_hash}) || concurrency::timeout(timeout)); if (std::holds_alternative(verification)) { // VALID co_return PayloadStatus{.status = std::string{PayloadStatus::kValidStr}, .latest_valid_hash = block_hash}; } else if (std::holds_alternative(verification)) { // INVALID const auto invalid_chain = std::get(verification); co_return PayloadStatus{.status = std::string{PayloadStatus::kInvalidStr}, .latest_valid_hash = invalid_chain.unwind_point.hash}; } else { // ERROR const auto validation_error = std::get(verification); co_return PayloadStatus{std::string{PayloadStatus::kInvalidStr}, {}, validation_error.error}; } } Task RemoteExecutionEngine::fork_choice_updated(const ForkChoiceUpdatedRequest& request, Msec timeout) { const ForkChoice fork_choice{ request.fork_choice_state.head_block_hash, static_cast(timeout.count()), request.fork_choice_state.finalized_block_hash, request.fork_choice_state.safe_block_hash, }; const auto fork_choice_result = co_await execution_service_->update_fork_choice(fork_choice); co_return fork_choice_updated_reply_from_result(fork_choice_result); } Task RemoteExecutionEngine::get_payload(uint64_t /*payload_id*/, Msec /*timeout*/) { // We do not support the payload building process yet, so any payload ID is unknown throw boost::system::system_error{to_system_code(ErrorCode::kUnknownPayload)}; } Task RemoteExecutionEngine::get_payload_bodies_by_hash(const std::vector& block_hashes, Msec timeout) { const auto result = co_await (execution_service_->get_bodies_by_hashes(block_hashes) || concurrency::timeout(timeout)); ensure(std::holds_alternative(result), "get_payload_bodies_by_hash: unexpected awaitable operators outcome"); const auto block_bodies = std::get(result); ensure(block_bodies.size() == block_hashes.size(), "get_payload_bodies_by_hash: number of hashes and bodies do not match"); co_return execution_payloads_from_bodies(block_bodies); } Task RemoteExecutionEngine::get_payload_bodies_by_range(BlockNum start, uint64_t count, Msec timeout) { ensure(count >= 1, "get_payload_bodies_by_range: invalid count zero"); const BlockNumRange block_num_range{start, start + count - 1}; const auto result = co_await (execution_service_->get_bodies_by_range(block_num_range) || concurrency::timeout(timeout)); ensure(std::holds_alternative(result), "get_payload_bodies_by_hash: unexpected awaitable operators outcome"); const auto block_bodies = std::get(result); ensure(block_bodies.size() == count, "get_payload_bodies_by_range: number of bodies and count do not match"); co_return execution_payloads_from_bodies(block_bodies); } } // namespace silkworm::rpc::engine ================================================ FILE: silkworm/rpc/engine/remote_execution_engine.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include "execution_engine.hpp" namespace silkworm::rpc::engine { class RemoteExecutionEngine final : public ExecutionEngine { public: RemoteExecutionEngine(const std::string& address_uri, agrpc::GrpcContext& grpc_context) : execution_client_{address_uri, grpc_context}, execution_service_{execution_client_.service()} {} ~RemoteExecutionEngine() override = default; Task new_payload(const NewPayloadRequest& request, Msec timeout) override; Task fork_choice_updated(const ForkChoiceUpdatedRequest& request, Msec timeout) override; Task get_payload(uint64_t payload_id, Msec timeout) override; Task get_payload_bodies_by_hash(const std::vector& block_hashes, Msec timeout) override; Task get_payload_bodies_by_range(BlockNum start, uint64_t count, Msec timeout) override; private: execution::grpc::client::RemoteClient execution_client_; std::shared_ptr execution_service_; }; } // namespace silkworm::rpc::engine ================================================ FILE: silkworm/rpc/engine/validation.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "validation.hpp" #include namespace silkworm::rpc::engine { ValidationResult validate_blob_hashes(const Block& block, const std::optional& expected_blob_versioned_hashes) { BlobVersionedHashes blob_versioned_hashes; for (const auto& tx : block.transactions) { if (tx.type == TransactionType::kBlob) { blob_versioned_hashes.insert(blob_versioned_hashes.end(), tx.blob_versioned_hashes.cbegin(), tx.blob_versioned_hashes.cend()); } } if (expected_blob_versioned_hashes && blob_versioned_hashes != *expected_blob_versioned_hashes) { return tl::make_unexpected("computed blob versioned hashes list does not match expected one"); } if (!expected_blob_versioned_hashes && !blob_versioned_hashes.empty()) { return tl::make_unexpected("computed blob versioned hashes list is not empty"); } return {}; } } // namespace silkworm::rpc::engine ================================================ FILE: silkworm/rpc/engine/validation.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc::engine { using BlobVersionedHashes = std::vector; using ValidationResult = tl::expected; ValidationResult validate_blob_hashes(const Block&, const std::optional&); } // namespace silkworm::rpc::engine ================================================ FILE: silkworm/rpc/ethbackend/backend.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::ethbackend { class BackEnd { public: virtual ~BackEnd() = default; virtual Task etherbase() = 0; virtual Task protocol_version() = 0; virtual Task net_version() = 0; virtual Task client_version() = 0; virtual Task net_peer_count() = 0; virtual Task engine_node_info() = 0; virtual Task peers() = 0; virtual Task get_block(BlockNum block_num, const HashAsSpan& hash, bool read_senders, silkworm::Block& block) = 0; virtual Task>> get_block_num_from_txn_hash(const HashAsSpan& hash) = 0; virtual Task> get_block_num_from_hash(const HashAsSpan& hash) = 0; virtual Task> get_block_hash_from_block_num(BlockNum block_num) = 0; virtual Task> canonical_body_for_storage(BlockNum block_num) = 0; }; } // namespace silkworm::rpc::ethbackend ================================================ FILE: silkworm/rpc/ethbackend/remote_backend.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_backend.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::ethbackend { namespace proto = ::remote; using Stub = proto::ETHBACKEND::StubInterface; RemoteBackEnd::RemoteBackEnd(const std::shared_ptr& channel, agrpc::GrpcContext& grpc_context) : RemoteBackEnd(proto::ETHBACKEND::NewStub(channel), grpc_context) {} RemoteBackEnd::RemoteBackEnd(std::unique_ptr stub, agrpc::GrpcContext& grpc_context) : stub_(std::move(stub)), grpc_context_(grpc_context) {} Task RemoteBackEnd::etherbase() { const auto start_time = clock_time::now(); const proto::EtherbaseRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncEtherbase, *stub_, request, grpc_context_); evmc::address evmc_address; if (reply.has_address()) { const auto& h160_address = reply.address(); evmc_address = address_from_h160(h160_address); } SILK_TRACE << "RemoteBackEnd::etherbase address=" << evmc_address << " t=" << clock_time::since(start_time); co_return evmc_address; } Task RemoteBackEnd::protocol_version() { const auto start_time = clock_time::now(); const proto::ProtocolVersionRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncProtocolVersion, *stub_, request, grpc_context_); const auto pv = reply.id(); SILK_TRACE << "RemoteBackEnd::protocol_version version=" << pv << " t=" << clock_time::since(start_time); co_return pv; } Task RemoteBackEnd::net_version() { const auto start_time = clock_time::now(); const proto::NetVersionRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncNetVersion, *stub_, request, grpc_context_); const auto nv = reply.id(); SILK_TRACE << "RemoteBackEnd::net_version version=" << nv << " t=" << clock_time::since(start_time); co_return nv; } Task RemoteBackEnd::client_version() { const auto start_time = clock_time::now(); const proto::ClientVersionRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncClientVersion, *stub_, request, grpc_context_); const auto& cv = reply.node_name(); SILK_TRACE << "RemoteBackEnd::client_version version=" << cv << " t=" << clock_time::since(start_time); co_return cv; } Task RemoteBackEnd::net_peer_count() { const auto start_time = clock_time::now(); const proto::NetPeerCountRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncNetPeerCount, *stub_, request, grpc_context_); const auto count = reply.count(); SILK_TRACE << "RemoteBackEnd::net_peer_count count=" << count << " t=" << clock_time::since(start_time); co_return count; } Task RemoteBackEnd::engine_node_info() { NodeInfos node_info_list; const auto start_time = clock_time::now(); const proto::NodesInfoRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncNodeInfo, *stub_, request, grpc_context_); for (int i = 0; i < reply.nodes_info_size(); ++i) { NodeInfo node_info; const auto& backend_node_info = reply.nodes_info(i); node_info.id = backend_node_info.id(); node_info.name = backend_node_info.name(); node_info.enode = backend_node_info.enode(); node_info.enr = backend_node_info.enr(); node_info.listener_addr = backend_node_info.listener_addr(); node_info.protocols = backend_node_info.protocols(); if (backend_node_info.has_ports()) { const auto& ports = backend_node_info.ports(); node_info.ports.discovery = ports.discovery(); node_info.ports.listener = ports.listener(); } node_info_list.push_back(node_info); } SILK_TRACE << "RemoteBackEnd::engine_node_info t=" << clock_time::since(start_time); co_return node_info_list; } Task RemoteBackEnd::peers() { const auto start_time = clock_time::now(); const ::google::protobuf::Empty request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncPeers, *stub_, request, grpc_context_); PeerInfos peer_infos; peer_infos.reserve(static_cast(reply.peers_size())); for (const auto& peer : reply.peers()) { PeerInfo peer_info{ .id = peer.id(), .name = peer.name(), .enode = peer.enode(), .enr = peer.enr(), .caps = {peer.caps().begin(), peer.caps().end()}, .local_address = peer.conn_local_addr(), .remote_address = peer.conn_remote_addr(), .is_connection_inbound = peer.conn_is_inbound(), .is_connection_trusted = peer.conn_is_trusted(), .is_connection_static = peer.conn_is_static(), }; peer_infos.push_back(peer_info); } SILK_TRACE << "RemoteBackEnd::peers t=" << clock_time::since(start_time); co_return peer_infos; } Task RemoteBackEnd::get_block(BlockNum block_num, const HashAsSpan& hash, bool read_senders, silkworm::Block& block) { const auto start_time = clock_time::now(); ::remote::BlockRequest request; request.set_block_height(block_num); request.set_allocated_block_hash(h256_from_bytes(hash).release()); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncBlock, *stub_, request, grpc_context_); ByteView block_rlp{string_view_to_byte_view(reply.block_rlp())}; if (const auto decode_result{rlp::decode(block_rlp, block)}; !decode_result) { co_return false; } if (read_senders) { ByteView senders{string_view_to_byte_view(reply.senders())}; if (senders.size() % kAddressLength == 0 && senders.size() / kAddressLength == block.transactions.size()) { std::vector sender_addresses; sender_addresses.reserve(block.transactions.size()); for (size_t i{0}; i < block.transactions.size(); ++i) { ByteView sender{senders.substr(i * kAddressLength, kAddressLength)}; block.transactions[i].set_sender(bytes_to_address(sender)); } } } SILK_TRACE << "RemoteBackEnd::get_block t=" << clock_time::since(start_time); co_return true; } Task>> RemoteBackEnd::get_block_num_from_txn_hash(const HashAsSpan& hash) { const auto start_time = clock_time::now(); ::remote::TxnLookupRequest request; request.set_allocated_txn_hash(h256_from_bytes(hash).release()); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncTxnLookup, *stub_, request, grpc_context_); if (reply.block_number() == 0) { co_return std::nullopt; } const auto block_num = reply.block_number(); const TxnId txn_id = reply.tx_number(); SILK_TRACE << "RemoteBackEnd::get_block_num_from_txn_hash block_num=" << block_num << " txn_id=" << txn_id << " t=" << clock_time::since(start_time); co_return std::make_pair(block_num, txn_id); } Task> RemoteBackEnd::get_block_num_from_hash(const HashAsSpan& hash) { const auto start_time = clock_time::now(); ::remote::HeaderNumberRequest request; request.set_allocated_hash(h256_from_bytes(hash).release()); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHeaderNumber, *stub_, request, grpc_context_); if (!reply.has_number()) { co_return std::nullopt; } auto block_num = reply.number(); SILK_TRACE << "RemoteBackEnd::get_block_num_from_hash block_num=" << block_num << " t=" << clock_time::since(start_time); co_return block_num; } Task> RemoteBackEnd::get_block_hash_from_block_num(BlockNum block_num) { const auto start_time = clock_time::now(); ::remote::CanonicalHashRequest request; request.set_block_number(block_num); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncCanonicalHash, *stub_, request, grpc_context_); evmc::bytes32 hash; if (reply.has_hash() == 0) { co_return std::nullopt; } span_from_h256(reply.hash(), hash.bytes); SILK_TRACE << "RemoteBackEnd::get_block_hash_from_block_num block_num=" << " t=" << clock_time::since(start_time); co_return hash; } Task> RemoteBackEnd::canonical_body_for_storage(BlockNum block_num) { const auto start_time = clock_time::now(); ::remote::CanonicalBodyForStorageRequest request; request.set_blocknumber(block_num); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncCanonicalBodyForStorage, *stub_, request, grpc_context_); SILK_TRACE << "RemoteBackEnd::canonical_body_for_storage block_num=" << block_num << " t=" << clock_time::since(start_time); if (reply.body().empty()) { co_return std::nullopt; } co_return string_to_bytes(reply.body()); } std::vector RemoteBackEnd::decode(const ::google::protobuf::RepeatedPtrField& grpc_txs) { // Convert encoded transactions from std::string to Bytes std::vector encoded_transactions; encoded_transactions.reserve(static_cast(grpc_txs.size())); for (const auto& grpc_tx_string : grpc_txs) { encoded_transactions.push_back(string_to_bytes(grpc_tx_string)); } return encoded_transactions; } std::vector RemoteBackEnd::decode(const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& grpc_withdrawals) { std::vector withdrawals; withdrawals.reserve(static_cast(grpc_withdrawals.size())); for (auto& grpc_withdrawal : grpc_withdrawals) { Withdrawal w{grpc_withdrawal.index(), grpc_withdrawal.validator_index(), address_from_h160(grpc_withdrawal.address()), grpc_withdrawal.amount()}; withdrawals.emplace_back(w); } return withdrawals; } } // namespace silkworm::rpc::ethbackend ================================================ FILE: silkworm/rpc/ethbackend/remote_backend.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include #include #include namespace silkworm::rpc::ethbackend { class RemoteBackEnd final : public BackEnd { public: RemoteBackEnd(const std::shared_ptr& channel, agrpc::GrpcContext& grpc_context); RemoteBackEnd(std::unique_ptr<::remote::ETHBACKEND::StubInterface> stub, agrpc::GrpcContext& grpc_context); Task etherbase() override; Task protocol_version() override; Task net_version() override; Task client_version() override; Task net_peer_count() override; Task engine_node_info() override; Task peers() override; Task get_block(BlockNum block_num, const HashAsSpan& hash, bool read_senders, silkworm::Block& block) override; Task>> get_block_num_from_txn_hash(const HashAsSpan& hash) override; Task> get_block_num_from_hash(const HashAsSpan& hash) override; Task> get_block_hash_from_block_num(BlockNum block_num) override; Task> canonical_body_for_storage(BlockNum block_num) override; private: static std::vector decode(const ::google::protobuf::RepeatedPtrField& grpc_txs); static std::vector decode(const ::google::protobuf::RepeatedPtrField<::types::Withdrawal>& grpc_withdrawals); std::unique_ptr<::remote::ETHBACKEND::StubInterface> stub_; agrpc::GrpcContext& grpc_context_; }; } // namespace silkworm::rpc::ethbackend ================================================ FILE: silkworm/rpc/ethbackend/remote_backend_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "remote_backend.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_address; ::types::H160* make_h160(uint64_t hi_hi, uint64_t hi_lo, uint32_t lo) { auto h128_ptr{new ::types::H128()}; h128_ptr->set_hi(hi_hi); h128_ptr->set_lo(hi_lo); auto h160_ptr{new ::types::H160()}; h160_ptr->set_allocated_hi(h128_ptr); h160_ptr->set_lo(lo); return h160_ptr; } ::types::H256* make_h256(uint64_t hi_hi, uint64_t hi_lo, uint64_t lo_hi, uint64_t lo_lo) { auto h256_ptr{new ::types::H256()}; auto hi_ptr{new ::types::H128()}; hi_ptr->set_hi(hi_hi); hi_ptr->set_lo(hi_lo); auto lo_ptr{new ::types::H128()}; lo_ptr->set_hi(lo_hi); lo_ptr->set_lo(lo_lo); h256_ptr->set_allocated_hi(hi_ptr); h256_ptr->set_allocated_lo(lo_ptr); return h256_ptr; } using StrictMockEthBackendStub = testing::StrictMock<::remote::MockETHBACKENDStub>; using EthBackendTest = test_util::GrpcApiTestBase; #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(EthBackendTest, "BackEnd::etherbase", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::EtherbaseReply> reader; EXPECT_CALL(*stub_, AsyncEtherbaseRaw).WillOnce(testing::Return(&reader)); SECTION("call etherbase and get address") { ::remote::EtherbaseReply response; response.set_allocated_address(make_h160(0xAAAAEEFFFFEEAAAA, 0x11DDBBAAAABBDD11, 0xCCDDDDCC)); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto etherbase = run<ðbackend::RemoteBackEnd::etherbase>(); CHECK(etherbase == 0xaaaaeeffffeeaaaa11ddbbaaaabbdd11ccddddcc_address); } SECTION("call etherbase and get empty address") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto etherbase = run<ðbackend::RemoteBackEnd::etherbase>(); CHECK(etherbase == evmc::address{}); } SECTION("call etherbase and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::etherbase>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::protocol_version", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::ProtocolVersionReply> reader; EXPECT_CALL(*stub_, AsyncProtocolVersionRaw).WillOnce(testing::Return(&reader)); SECTION("call protocol_version and get version") { ::remote::ProtocolVersionReply response; response.set_id(15); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto protocol_version = run<ðbackend::RemoteBackEnd::protocol_version>(); CHECK(protocol_version == 15); } SECTION("call protocol_version and get empty version") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto protocol_version = run<ðbackend::RemoteBackEnd::protocol_version>(); CHECK(protocol_version == 0); } SECTION("call protocol_version and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::protocol_version>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::net_version", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::NetVersionReply> reader; EXPECT_CALL(*stub_, AsyncNetVersionRaw).WillOnce(testing::Return(&reader)); SECTION("call net_version and get version") { ::remote::NetVersionReply response; response.set_id(66); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto net_version = run<ðbackend::RemoteBackEnd::net_version>(); CHECK(net_version == 66); } SECTION("call net_version and get empty version") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto net_version = run<ðbackend::RemoteBackEnd::net_version>(); CHECK(net_version == 0); } SECTION("call net_version and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::net_version>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::client_version", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::ClientVersionReply> reader; EXPECT_CALL(*stub_, AsyncClientVersionRaw).WillOnce(testing::Return(&reader)); SECTION("call client_version and get version") { ::remote::ClientVersionReply response; response.set_node_name("erigon"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto client_version = run<ðbackend::RemoteBackEnd::client_version>(); CHECK(client_version == "erigon"); } SECTION("call client_version and get empty version") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto client_version = run<ðbackend::RemoteBackEnd::client_version>(); CHECK(client_version.empty()); } SECTION("call client_version and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::client_version>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::get_block_num_from_txn_hash", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::TxnLookupReply> reader; const Hash hash; EXPECT_CALL(*stub_, AsyncTxnLookupRaw).WillOnce(testing::Return(&reader)); SECTION("call get_block_num_from_txn_hash and get number") { ::remote::TxnLookupReply response; response.set_block_number(5); response.set_tx_number(10000001); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto result = run<ðbackend::RemoteBackEnd::get_block_num_from_txn_hash>(hash.bytes); CHECK(result->first == 5); CHECK(result->second == 10000001); } SECTION("call get_block_num_from_txn_hash and get zero count") { ::remote::TxnLookupReply response; EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); response.set_block_number(0); response.set_tx_number(0); const auto result = run<ðbackend::RemoteBackEnd::get_block_num_from_txn_hash>(hash.bytes); CHECK(result == std::nullopt); } SECTION("call get_block_num_from_txn_hash and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::get_block_num_from_txn_hash>(hash.bytes)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::get_block_num_from_hash", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::HeaderNumberReply> reader; const Hash hash; EXPECT_CALL(*stub_, AsyncHeaderNumberRaw).WillOnce(testing::Return(&reader)); SECTION("call get_block_num_from_hash and get number") { ::remote::HeaderNumberReply response; response.set_number(3); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto block_num = run<ðbackend::RemoteBackEnd::get_block_num_from_hash>(hash.bytes); CHECK(*block_num == 3); } SECTION("call get_block_num_from_hash return no number") { ::remote::HeaderNumberReply response; response.clear_number(); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto block_num = run<ðbackend::RemoteBackEnd::get_block_num_from_hash>(hash.bytes); CHECK(block_num == std::nullopt); } SECTION("call get_block_num_from_hash and get zero count") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto block_num = run<ðbackend::RemoteBackEnd::get_block_num_from_hash>(hash.bytes); CHECK(block_num == std::nullopt); } SECTION("call get_block_num_from_hash and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::get_block_num_from_hash>(hash.bytes)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::canonical_body_for_storage", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::CanonicalBodyForStorageReply> reader; const uint64_t block_num{0}; EXPECT_CALL(*stub_, AsyncCanonicalBodyForStorageRaw).WillOnce(testing::Return(&reader)); SECTION("call canonical_body_for_storage, and number") { ::remote::CanonicalBodyForStorageReply response; response.set_body("123"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto body = run<ðbackend::RemoteBackEnd::canonical_body_for_storage>(block_num); CHECK(body == string_to_bytes("123")); } SECTION("call get_block_num_from_hash and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::canonical_body_for_storage>(block_num)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::get_block_hash_from_block_num", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::CanonicalHashReply> reader; const uint64_t block_num{0}; EXPECT_CALL(*stub_, AsyncCanonicalHashRaw).WillOnce(testing::Return(&reader)); SECTION("call get_block_hash_from_block_num and get number") { ::remote::CanonicalHashReply response; response.set_allocated_hash(make_h256(0x3b8fb240d288781d, 0x4aac94d3fd16809e, 0xe413bc99294a0857, 0x98a589dae51ddd4a)); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto hash = run<ðbackend::RemoteBackEnd::get_block_hash_from_block_num>(block_num); CHECK(hash == 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32); } SECTION("call get_block_hash_from_block_num and get zero count") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto hash = run<ðbackend::RemoteBackEnd::get_block_hash_from_block_num>(block_num); CHECK(hash == std::nullopt); } SECTION("call get_block_hash_from_block_num and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::get_block_hash_from_block_num>(block_num)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::net_peer_count", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::NetPeerCountReply> reader; EXPECT_CALL(*stub_, AsyncNetPeerCountRaw).WillOnce(testing::Return(&reader)); SECTION("call net_peer_count and get count") { ::remote::NetPeerCountReply response; response.set_count(20); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto net_peer_count = run<ðbackend::RemoteBackEnd::net_peer_count>(); CHECK(net_peer_count == 20); } SECTION("call net_peer_count and get zero count") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto net_peer_count = run<ðbackend::RemoteBackEnd::net_peer_count>(); CHECK(net_peer_count == 0); } SECTION("call net_peer_count and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::net_peer_count>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::node_info", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::NodesInfoReply> reader; EXPECT_CALL(*stub_, AsyncNodeInfoRaw).WillOnce(testing::Return(&reader)); SECTION("call node_info") { ::remote::NodesInfoReply response; types::NodeInfoPorts ports; auto reply = response.add_nodes_info(); const auto ports_ref = ports.New(); reply->set_id("340e3cda481a935658b86f4987d50d0153a68f97fa2b9e8f70a8e9f5b755eeb6"); reply->set_name("erigon/v2.32.0-stable-021891a3/linux-amd64/go1.19"); reply->set_enode("enode://b428a8d89b621a1bea008922f5fb7cd7644e2289f85fc8620f1e497eff767e2bcdc77"); reply->set_enr("enr:-JK4QJMWPkW7iDLYfevZj80Rcs-B9GkRqptsH0L6hcFKSFJ3bKFlbzjnMk29y0ZD0omRMVDlrzgTThXYcd_"); reply->set_listener_addr("[::]:30303"); ports_ref->set_discovery(32); ports_ref->set_listener(30000); reply->set_allocated_ports(ports_ref); std::string protocols = std::string(R"({"eth": {"network":5, "difficulty":10790000, "genesis":"0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a",)"); protocols += R"("config": {"ChainName":"goerli", "chainId":5, "consensus":"clique", "homesteadBlock":0, "daoForkSupport":true, "eip150Block":0,)"; protocols += R"("eip150Hash":"0x0000000000000000000000000000000000000000000000000000000000000000", "eip155Block":0, "byzantiumBlock":0, "constantinopleBlock":0,)"; protocols += R"("petersburgBlock":0, "istanbulBlock":1561651, "berlinBlock":4460644, "londonBlock":5062605, "terminalTotalDifficulty":10790000,)"; protocols += R"("terminalTotalDifficultyPassed":true, "clique": {"period":15, "epoch":30000}},)"; protocols += R"("head":"0x11fce21bdebbcf09e1e2e37b874729c17518cd342fcf0959659e650fa45f9768"}})"; reply->set_protocols(protocols); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto node_info = run<ðbackend::RemoteBackEnd::engine_node_info>(); CHECK(node_info[0].id == "340e3cda481a935658b86f4987d50d0153a68f97fa2b9e8f70a8e9f5b755eeb6"); CHECK(node_info[0].name == "erigon/v2.32.0-stable-021891a3/linux-amd64/go1.19"); CHECK(node_info[0].enode == "enode://b428a8d89b621a1bea008922f5fb7cd7644e2289f85fc8620f1e497eff767e2bcdc77"); CHECK(node_info[0].enr == "enr:-JK4QJMWPkW7iDLYfevZj80Rcs-B9GkRqptsH0L6hcFKSFJ3bKFlbzjnMk29y0ZD0omRMVDlrzgTThXYcd_"); CHECK(node_info[0].listener_addr == "[::]:30303"); CHECK(node_info[0].protocols == protocols); CHECK(node_info[0].ports.discovery == 32); CHECK(node_info[0].ports.listener == 30000); } } // TODO(canepat) move these unit tests to execute.proto I/F implementation /*TEST_CASE_METHOD(EthBackendTest, "BackEnd::engine_get_payload", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::EngineGetPayloadResponse> reader; EXPECT_CALL(*stub_, AsyncEngineGetPayloadRaw).WillOnce(testing::Return(&reader)); SECTION("call engine_get_payload and get payload") { const auto p{new ::types::ExecutionPayload}; p->set_allocated_coinbase(make_h160(0xa94f5374fce5edbc, 0x8e2a8697c1533167, 0x7e6ebf0b)); p->set_allocated_block_hash(make_h256(0x3559e851470f6e7b, 0xbed1db474980683e, 0x8c315bfce99b2a6e, 0xf47c057c04de7858)); p->set_allocated_base_fee_per_gas(make_h256(0x0, 0x0, 0x0, 0x7)); p->set_allocated_state_root(make_h256(0xca3149fa9e37db08, 0xd1cd49c9061db100, 0x2ef1cd58db2210f2, 0x115c8c989b2bdf45)); p->set_allocated_receipt_root(make_h256(0x56e81f171bcc55a6, 0xff8345e692c0f86e, 0x5b48e01b996cadc0, 0x01622fb5e363b421)); p->set_allocated_parent_hash(make_h256(0x3b8fb240d288781d, 0x4aac94d3fd16809e, 0xe413bc99294a0857, 0x98a589dae51ddd4a)); p->set_allocated_prev_randao(make_h256(0x0, 0x0, 0x0, 0x1)); p->set_block_num(0x1); p->set_gas_limit(0x1c9c380); p->set_timestamp(0x5); const Bytes tx_bytes{*from_hex("0xf92ebdeab45d368f6354e8c5a8ac586c")}; p->add_transactions(tx_bytes.data(), tx_bytes.size()); const auto hi_hi_hi_logsbloom{make_h256(0x1000000000000000, 0x0, 0x0, 0x0)}; const auto hi_hi_logsbloom{new ::types::H512()}; hi_hi_logsbloom->set_allocated_hi(hi_hi_hi_logsbloom); const auto hi_logsbloom{new ::types::H1024()}; hi_logsbloom->set_allocated_hi(hi_hi_logsbloom); const auto logsbloom{new ::types::H2048()}; logsbloom->set_allocated_hi(hi_logsbloom); p->set_allocated_logs_bloom(logsbloom); ::remote::EngineGetPayloadResponse response; response.set_allocated_execution_payload(p); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto payload_and_value = run<ðbackend::RemoteBackEnd::engine_get_payload>(0u); const auto& payload = payload_and_value.payload; CHECK(payload.number == 0x1); CHECK(payload.gas_limit == 0x1c9c380); CHECK(payload.suggested_fee_recipient == 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address); CHECK(payload.state_root == 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32); CHECK(payload.receipts_root == 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32); CHECK(payload.parent_hash == 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32); CHECK(payload.block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(payload.prev_randao == 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32); CHECK(payload.base_fee == 0x7); CHECK(payload.transactions.size() == 1); CHECK(to_hex(payload.transactions[0]) == "f92ebdeab45d368f6354e8c5a8ac586c"); silkworm::Bloom expected_bloom{0}; expected_bloom[0] = 0x10; CHECK(payload.logs_bloom == expected_bloom); CHECK(payload_and_value.block_value == 0); } SECTION("call engine_get_payload and get empty payload") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto payload = run<ðbackend::RemoteBackEnd::engine_get_payload>(0u); CHECK(payload.payload.number == 0); } SECTION("call engine_get_payload and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::engine_get_payload>(0u)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::engine_new_payload", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::EnginePayloadStatus> reader; EXPECT_CALL(*stub_, AsyncEngineNewPayloadRaw).WillOnce(testing::Return(&reader)); silkworm::Bloom bloom; bloom.fill(0); bloom[0] = 0x12; const Bytes transaction{*from_hex("0xf92ebdeab45d368f6354e8c5a8ac586c")}; const NewPayloadRequest request_v1{ .execution_payload = ExecutionPayload{ .version = ExecutionPayload::kV1, .timestamp = 0x5, .gas_limit = 0x1c9c380, .gas_used = 0x9, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .state_root = 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf43_bytes32, .receipts_root = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32, .parent_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .base_fee = 0x7, .logs_bloom = bloom, .transactions = {transaction}, }, }; const NewPayloadRequest request_v2_no_w{ .execution_payload = ExecutionPayload{ .version = ExecutionPayload::kV2, .timestamp = 0x5, .gas_limit = 0x1c9c380, .gas_used = 0x9, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .state_root = 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf43_bytes32, .receipts_root = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32, .parent_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .base_fee = 0x7, .logs_bloom = bloom, .transactions = {transaction}, .withdrawals = std::vector{}, }, }; const NewPayloadRequest request_v2_w{ .execution_payload = ExecutionPayload{ .version = ExecutionPayload::kV2, .timestamp = 0x5, .gas_limit = 0x1c9c380, .gas_used = 0x9, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .state_root = 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf43_bytes32, .receipts_root = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32, .parent_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .base_fee = 0x7, .logs_bloom = bloom, .transactions = {transaction}, .withdrawals = std::vector{ {.index = 6, .validator_index = 12, .address = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .amount = 10'000}}, }, }; const std::vector requests = {request_v1, request_v2_no_w, request_v2_w}; for (size_t i{0}; i < requests.size(); ++i) { const auto& new_payload_request = requests[i]; SECTION("call engine_new_payload and get VALID status [i=" + std::to_string(i) + "]") { ::remote::EnginePayloadStatus response; response.set_allocated_latest_valid_hash(make_h256(0, 0, 0, 0x40)); response.set_status(::remote::EngineStatus::VALID); response.set_validation_error("some error"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto payload_status = run<ðbackend::RemoteBackEnd::engine_new_payload>(new_payload_request); CHECK(payload_status.status == "VALID"); CHECK(payload_status.latest_valid_hash == 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32); CHECK(payload_status.validation_error == "some error"); } const ::remote::EngineStatus all_engine_statuses[] = { ::remote::EngineStatus::VALID, ::remote::EngineStatus::INVALID, ::remote::EngineStatus::SYNCING, ::remote::EngineStatus::ACCEPTED, ::remote::EngineStatus::INVALID_BLOCK_HASH}; for (const auto engine_status : all_engine_statuses) { const auto engine_status_name{::remote::EngineStatus_Name(engine_status)}; SECTION(std::string("call engine_new_payload and get ") + engine_status_name + " status [i=" + std::to_string(i) + "]") { ::remote::EnginePayloadStatus response; response.set_status(engine_status); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto payload_status = run<ðbackend::RemoteBackEnd::engine_new_payload>(new_payload_request); CHECK(payload_status.status == engine_status_name); } } SECTION("call engine_new_payload and get empty payload [i=" + std::to_string(i) + "]") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto payload_status = run<ðbackend::RemoteBackEnd::engine_new_payload>(new_payload_request); CHECK(payload_status.status == "VALID"); // Default value in interfaces is Valid CHECK(payload_status.latest_valid_hash == std::nullopt); CHECK(payload_status.validation_error == std::nullopt); } SECTION("call engine_new_payload and get error [i=" + std::to_string(i) + "]") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::engine_new_payload>(new_payload_request)), rpc::GrpcStatusError); } } } TEST_CASE_METHOD(EthBackendTest, "BackEnd::engine_forkchoice_updated", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::EngineForkChoiceUpdatedResponse> reader; EXPECT_CALL(*stub_, AsyncEngineForkChoiceUpdatedRaw).WillOnce(testing::Return(&reader)); const ForkChoiceUpdatedRequest forkchoice_request{ .fork_choice_state = ForkChoiceState{ .head_block_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .safe_block_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .finalized_block_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32}, .payload_attributes = PayloadAttributes{ .timestamp = 0x1, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address}}; SECTION("call engine_forkchoice_updated_v1 and get VALID status") { ::remote::EngineForkChoiceUpdatedResponse response; auto* engine_payload_status = new ::remote::EnginePayloadStatus(); engine_payload_status->set_allocated_latest_valid_hash(make_h256(0, 0, 0, 0x40)); engine_payload_status->set_validation_error("some error"); engine_payload_status->set_status(::remote::EngineStatus::VALID); response.set_allocated_payload_status(engine_payload_status); response.set_payload_id(1); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto forkchoice_reply = run<ðbackend::RemoteBackEnd::engine_forkchoice_updated>(forkchoice_request); const PayloadStatus payload_status = forkchoice_reply.payload_status; CHECK(payload_status.status == "VALID"); CHECK(payload_status.latest_valid_hash == 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32); CHECK(payload_status.validation_error == "some error"); } SECTION("call engine_forkchoice_updated_v1 and get zero count") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto forkchoice_reply = run<ðbackend::RemoteBackEnd::engine_forkchoice_updated>(forkchoice_request); const PayloadStatus payload_status = forkchoice_reply.payload_status; CHECK(payload_status.status == "VALID"); // Default value in interfaces is Valid CHECK(payload_status.latest_valid_hash == std::nullopt); CHECK(payload_status.validation_error == std::nullopt); } SECTION("call engine_forkchoice_updated_v1 and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<ðbackend::RemoteBackEnd::engine_forkchoice_updated>(forkchoice_request)), rpc::GrpcStatusError); } }*/ TEST_CASE_METHOD(EthBackendTest, "BackEnd::peers", "[silkworm][rpc][ethbackend][backend]") { test::StrictMockAsyncResponseReader<::remote::PeersReply> reader; EXPECT_CALL(*stub_, AsyncPeersRaw).WillOnce(testing::Return(&reader)); SECTION("call peers") { ::remote::PeersReply response; auto reply = response.add_peers(); reply->set_id("340e3cda481a935658b86f4987d50d0153a68f97fa2b9e8f70a8e9f5b755eeb6"); reply->set_name("erigon/v2.32.0-stable-021891a3/linux-amd64/go1.19"); reply->set_enode("enode://b428a8d89b621a1bea008922f5fb7cd7644e2289f85fc8620f1e497eff767e2bcdc77"); reply->set_enr("enr:-JK4QJMWPkW7iDLYfevZj80Rcs-B9GkRqptsH0L6hcFKSFJ3bKFlbzjnMk29y0ZD0omRMVDlrzgTThXYcd_"); reply->set_conn_local_addr("[::]:30303"); reply->set_conn_remote_addr("[::]:30302"); reply->set_conn_is_inbound(false); reply->set_conn_is_trusted(true); reply->set_conn_is_static(true); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto peer_infos = run<ðbackend::RemoteBackEnd::peers>(); CHECK(peer_infos.size() == 1); const auto& peer_info = peer_infos[0]; CHECK(peer_info.id == "340e3cda481a935658b86f4987d50d0153a68f97fa2b9e8f70a8e9f5b755eeb6"); CHECK(peer_info.name == "erigon/v2.32.0-stable-021891a3/linux-amd64/go1.19"); CHECK(peer_info.enode == "enode://b428a8d89b621a1bea008922f5fb7cd7644e2289f85fc8620f1e497eff767e2bcdc77"); CHECK(peer_info.enr == "enr:-JK4QJMWPkW7iDLYfevZj80Rcs-B9GkRqptsH0L6hcFKSFJ3bKFlbzjnMk29y0ZD0omRMVDlrzgTThXYcd_"); CHECK(peer_info.caps.empty()); CHECK(peer_info.local_address == "[::]:30303"); CHECK(peer_info.remote_address == "[::]:30302"); CHECK(!peer_info.is_connection_inbound); CHECK(peer_info.is_connection_trusted); CHECK(peer_info.is_connection_static); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/ethdb/bitmap.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bitmap.hpp" #include #include #include #include #include #include #include #include namespace silkworm::rpc::ethdb::bitmap { using roaring_bitmap_t = roaring::api::roaring_bitmap_t; using Roaring = roaring::Roaring; using rpc::ethdb::walk; static Roaring fast_or(size_t n, const std::vector>& inputs) { std::vector x(n); for (size_t k = 0; k < n; ++k) { x[k] = &inputs[k]->roaring; } roaring_bitmap_t* c_ans = roaring_bitmap_or_many(n, x.data()); if (c_ans == nullptr) { throw std::runtime_error("failed memory alloc in fast_or"); } Roaring ans(c_ans); return ans; } Task get( db::kv::api::Transaction& tx, const std::string& table, Bytes& key, uint32_t from_block, uint32_t to_block) { std::vector> chunks; Bytes from_key{key.begin(), key.end()}; from_key.resize(key.size() + sizeof(uint32_t)); endian::store_big_u32(&from_key[key.size()], from_block); SILK_DEBUG << "table: " << table << " key: " << key << " from_key: " << from_key; auto walker = [&](const Bytes& k, const Bytes& v) { SILK_TRACE << "k: " << k << " v: " << v; auto chunk = std::make_unique(Roaring::readSafe(reinterpret_cast(v.data()), v.size())); SILK_TRACE << "chunk: " << chunk->toString(); chunks.push_back(std::move(chunk)); auto block = endian::load_big_u32(&k[k.size() - sizeof(uint32_t)]); return block < to_block; }; co_await walk(tx, table, from_key, gsl::narrow(key.size() * CHAR_BIT), walker); auto result{fast_or(chunks.size(), chunks)}; SILK_DEBUG << "result: " << result.toString(); co_return result; } Task from_topics( db::kv::api::Transaction& tx, const std::string& table, const FilterTopics& topics, uint64_t start, uint64_t end) { SILK_DEBUG << "#topics: " << topics.size() << " start: " << start << " end: " << end; roaring::Roaring result_bitmap; for (const auto& subtopics : topics) { SILK_DEBUG << "#subtopics: " << subtopics.size(); roaring::Roaring subtopic_bitmap; for (auto& topic : subtopics) { Bytes topic_key{std::begin(topic.bytes), std::end(topic.bytes)}; SILK_TRACE << "topic: " << to_hex(topic) << " topic_key: " << to_hex(topic_key); auto bitmap = co_await ethdb::bitmap::get(tx, table, topic_key, gsl::narrow(start), gsl::narrow(end)); SILK_TRACE << "bitmap: " << bitmap.toString(); subtopic_bitmap |= bitmap; SILK_TRACE << "subtopic_bitmap: " << subtopic_bitmap.toString(); } if (!subtopic_bitmap.isEmpty()) { if (result_bitmap.isEmpty()) { result_bitmap = subtopic_bitmap; } else { result_bitmap &= subtopic_bitmap; } } SILK_DEBUG << "result_bitmap: " << result_bitmap.toString(); } co_return result_bitmap; } Task from_addresses( db::kv::api::Transaction& tx, const std::string& table, const FilterAddresses& addresses, uint64_t start, uint64_t end) { SILK_TRACE << "#addresses: " << addresses.size() << " start: " << start << " end: " << end; roaring::Roaring result_bitmap; for (auto& address : addresses) { Bytes address_key{std::begin(address.bytes), std::end(address.bytes)}; auto bitmap = co_await ethdb::bitmap::get(tx, table, address_key, gsl::narrow(start), gsl::narrow(end)); SILK_TRACE << "bitmap: " << bitmap.toString(); result_bitmap |= bitmap; } SILK_TRACE << "result_bitmap: " << result_bitmap.toString(); co_return result_bitmap; } } // namespace silkworm::rpc::ethdb::bitmap ================================================ FILE: silkworm/rpc/ethdb/bitmap.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wold-style-cast" #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include namespace silkworm::rpc::ethdb::bitmap { Task get( db::kv::api::Transaction& tx, const std::string& table, Bytes& key, uint32_t from_block, uint32_t to_block); Task from_topics( db::kv::api::Transaction& tx, const std::string& table, const FilterTopics& topics, uint64_t start, uint64_t end); Task from_addresses( db::kv::api::Transaction& tx, const std::string& table, const FilterAddresses& addresses, uint64_t start, uint64_t end); } // namespace silkworm::rpc::ethdb::bitmap ================================================ FILE: silkworm/rpc/ethdb/cbor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "cbor.hpp" #include #include #include #include #include #include #include #include namespace silkworm::rpc { class LogCborListener : public cbor::listener { private: enum class ProcessingState { kWaitNLogs, kWaitNFields, kWaitAddress, kWaitNTopics, kWaitTopics, kWaitData }; public: explicit LogCborListener(std::vector& logs) : logs_(logs), current_log_{} {} void on_integer(int) override { throw std::invalid_argument("Log CBOR: unexpected format(on_integer)"); } void on_map(int) override { throw std::invalid_argument("Log CBOR: unexpected format(on_map)"); } void on_string(std::string&) override { throw std::invalid_argument("Log CBOR: unexpected format(on_string)"); } void on_tag(unsigned int) override { throw std::invalid_argument("Log CBOR: unexpected format(on_tag)"); } void on_undefined() override { throw std::invalid_argument("Log CBOR: unexpected format(on_undefined)"); } void on_extra_integer(unsigned long long, int) override { // NOLINT(google-runtime-int) throw std::invalid_argument("Log CBOR: unexpected format(on_extra_integer)"); } void on_bool(bool) override { throw std::invalid_argument("Log CBOR: unexpected format(on_bool)"); } void on_extra_tag(unsigned long long) override { // NOLINT(google-runtime-int) throw std::invalid_argument("Log CBOR: unexpected format(on_extra_tag)"); } void on_float32(float) override { throw std::invalid_argument("Log CBOR: unexpected format(on_float)"); } void on_double(double) override { throw std::invalid_argument("Log CBOR: unexpected format(on_double)"); } void on_extra_special(unsigned long long) override { // NOLINT(google-runtime-int) throw std::invalid_argument("Log CBOR: unexpected format(on_extra_special)"); } void on_error(const char*) override { throw std::invalid_argument("Log CBOR: unexpected format(on_error)"); } void on_special(unsigned int) override { throw std::invalid_argument("Log CBOR: unexpected format(on_special)"); } void on_bytes(unsigned char* data, int size) override { if (size < 0) { throw std::invalid_argument("Log CBOR: unexpected format(on_bytes negatize size)"); } if (state_ == ProcessingState::kWaitAddress) { size_t n{static_cast(size) < kAddressLength ? static_cast(size) : kAddressLength}; std::memcpy(current_log_.address.bytes + kAddressLength - n, data, n); state_ = ProcessingState::kWaitNTopics; } else if (state_ == ProcessingState::kWaitTopics) { evmc::bytes32 out; std::memcpy(out.bytes, data, static_cast(size)); current_log_.topics.emplace_back(out); if (++current_topic_ == num_topics_) { state_ = ProcessingState::kWaitData; } } else if (state_ == ProcessingState::kWaitData) { current_log_.data.resize(static_cast::size_type>(size)); std::memcpy(current_log_.data.data(), data, static_cast(size)); logs_.emplace_back(std::move(current_log_)); current_log_.topics.clear(); state_ = ProcessingState::kWaitNFields; } else { throw std::invalid_argument("Log CBOR: unexpected format(on_bytes bad state)"); } } void on_array(int size) override { if (size < 0) { throw std::invalid_argument("Log CBOR: unexpected format(on_array negatize size)"); } if (state_ == ProcessingState::kWaitNLogs) { num_logs_ = size; logs_.reserve(static_cast::size_type>(size)); state_ = ProcessingState::kWaitNFields; } else if (state_ == ProcessingState::kWaitNFields) { if (size != 3) { throw std::invalid_argument("Log CBOR: unexpected format(on_array wrong number of fields)"); } state_ = ProcessingState::kWaitAddress; } else if (state_ == ProcessingState::kWaitNTopics) { if (size == 0) { state_ = ProcessingState::kWaitData; } else { current_log_.topics.reserve(static_cast::size_type>(size)); num_topics_ = size; current_topic_ = 0; state_ = ProcessingState::kWaitTopics; } } else { throw std::invalid_argument("Log CBOR: unexpected format(on_array bad state)"); } } void on_null() override { current_log_.data = silkworm::Bytes{}; logs_.emplace_back(std::move(current_log_)); current_log_.topics.clear(); state_ = ProcessingState::kWaitNFields; } bool success() { return std::cmp_equal(logs_.size(), num_logs_); } private: ProcessingState state_{ProcessingState::kWaitNLogs}; int num_logs_{0}; int num_topics_{0}; std::vector& logs_; Log current_log_; int current_topic_{0}; }; bool cbor_decode(const silkworm::Bytes& bytes, std::vector& logs) { if (bytes.empty()) { return false; } cbor::input input(bytes.data(), static_cast(bytes.size())); LogCborListener listener(logs); cbor::decoder decoder(input, listener); decoder.run(); const auto decode_success = listener.success(); if (!decode_success) { SILK_ERROR << "cbor_decode> unexpected cbor: wrong number of logs"; } return decode_success; } bool cbor_decode(const silkworm::Bytes& bytes, std::vector>& receipts) { if (bytes.empty()) { return false; } auto json = nlohmann::json::from_cbor(bytes); SILK_TRACE << "cbor_decode> json: " << json.dump(); if (json.is_array()) { receipts = json.get>>(); return true; } if (json.is_null()) { return true; } SILK_ERROR << "cbor_decode> unexpected json: " << json.dump(); return false; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/ethdb/cbor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc { [[nodiscard]] bool cbor_decode(const silkworm::Bytes& bytes, std::vector& logs); [[nodiscard]] bool cbor_decode(const silkworm::Bytes& bytes, std::vector>& receipts); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/ethdb/cbor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "cbor.hpp" #include #include #include #include #include #include #include #include namespace { #ifdef _WIN32 static constexpr std::string_view kInvalidArgumentMessage = "invalid argument"; #else constexpr std::string_view kInvalidArgumentMessage = "Invalid argument"; #endif } // namespace namespace silkworm::rpc { using Catch::Matchers::Message; using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("decode logs from empty bytes", "[rpc][ethdb][cbor]") { Logs logs{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex(""), logs)); CHECK(logs.empty()); } TEST_CASE("decode logs from empty array", "[rpc][ethdb][cbor]") { Logs logs{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex("80"), logs)); CHECK(logs.empty()); } TEST_CASE("decode logs from CBOR 1", "[rpc][ethdb][cbor]") { Logs logs{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex("818354000000000000000000000000000000000000000080f6"), logs)); CHECK(logs.size() == 1); CHECK(logs[0].address == 0x0000000000000000000000000000000000000000_address); CHECK(logs[0].topics.empty()); CHECK(logs[0].data.empty()); } TEST_CASE("decode logs from CBOR 2", "[rpc][ethdb][cbor]") { Logs logs{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex( "82" "83540715a7794a1dc8e42615f059dd6e406a6594651a80f6" "8354007fb8417eb9ad4d958b050fc3720d5b46a2c053805000110011001100110011001100110011"), logs)); CHECK(logs.size() == 2); CHECK(logs[0].address == 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address); CHECK(logs[0].topics.empty()); CHECK(logs[0].data.empty()); CHECK(logs[1].address == 0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); CHECK(logs[1].topics.empty()); CHECK(logs[1].data == *silkworm::from_hex("00110011001100110011001100110011")); } TEST_CASE("decode logs from CBOR 3", "[rpc][ethdb][cbor]") { Logs logs{}; auto bytes = *silkworm::from_hex("818354ea674fdde714fd979de3edf0f56aa9716b898ec88043010043"); CHECK_NOTHROW(cbor_decode(bytes, logs)); CHECK(logs.size() == 1); CHECK(logs[0].address == 0xea674fdde714fd979de3edf0f56aa9716b898ec8_address); CHECK(logs[0].topics.empty()); CHECK(silkworm::to_hex(logs[0].data) == "010043"); } TEST_CASE("decode logs from CBOR 4", "[rpc][ethdb][cbor]") { Logs logs{}; auto bytes = *silkworm::from_hex( "81835456c0369e002852c2570ca0cc3442e26df98e01a2835820ddf252ad1be2c89b69c2b068fc37" "8daa952ba7f163c4a11628f55a4df523b3ef5820000000000000000000000000a2e1ffe3aa9cbcde" "1955b04d22e2cc092c3738785820000000000000000000000000520d849db6e4bf7e0c58a45fc513" "a6d633baf77e5820000000000000000000000000000000000000000000084595161401484a000000"); CHECK_NOTHROW(cbor_decode(bytes, logs)); CHECK(logs.size() == 1); CHECK(logs[0].address == 0x56c0369e002852c2570ca0cc3442e26df98e01a2_address); CHECK(logs[0].topics.size() == 3); CHECK(logs[0].topics == std::vector{ 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef_bytes32, 0x000000000000000000000000a2e1ffe3aa9cbcde1955b04d22e2cc092c373878_bytes32, 0x000000000000000000000000520d849db6e4bf7e0c58a45fc513a6d633baf77e_bytes32, }); CHECK(silkworm::to_hex(logs[0].data) == "000000000000000000000000000000000000000000084595161401484a000000"); } TEST_CASE("decode logs from incorrect bytes", "[rpc][ethdb][cbor]") { Logs logs{}; const Bytes b1 = *silkworm::from_hex("81"); CHECK(!cbor_decode(b1, logs)); const Bytes b2 = *silkworm::from_hex("83808040"); CHECK_THROWS_MATCHES(cbor_decode(b2, logs), std::invalid_argument, Message("Log CBOR: unexpected format(on_array wrong number of fields)")); } TEST_CASE("decode receipts from empty bytes", "[rpc][ethdb][cbor]") { Receipts receipts{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex(""), receipts)); CHECK(receipts.empty()); } TEST_CASE("decode receipts from empty array", "[rpc][ethdb][cbor]") { Receipts receipts{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex("80"), receipts)); CHECK(receipts.empty()); } TEST_CASE("decode receipts from CBOR 1", "[rpc][ethdb][cbor]") { Receipts receipts{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex("818400f60101"), receipts)); CHECK(receipts.size() == 1); CHECK(receipts[0]->type == TransactionType::kLegacy); CHECK(receipts[0]->success == 1); CHECK(receipts[0]->cumulative_gas_used == 1); } TEST_CASE("decode receipts from CBOR 2", "[rpc][ethdb][cbor]") { Receipts receipts{}; CHECK_NOTHROW(cbor_decode(*silkworm::from_hex( "82" "8400f60101" "8400f60101"), receipts)); CHECK(receipts.size() == 2); CHECK(receipts[0]->type == TransactionType::kLegacy); CHECK(receipts[0]->success == 1); CHECK(receipts[0]->cumulative_gas_used == 1); CHECK(receipts[1]->type == TransactionType::kLegacy); CHECK(receipts[1]->success == 1); CHECK(receipts[1]->cumulative_gas_used == 1); } TEST_CASE("decode receipts from CBOR 3", "[rpc][ethdb][cbor]") { Receipts receipts{}; auto bytes = *silkworm::from_hex("838400f601196d398400f6011a00371b0b8400f6011a003947f4"); CHECK_NOTHROW(cbor_decode(bytes, receipts)); CHECK(receipts.size() == 3); CHECK(receipts[0]->success == true); CHECK(receipts[0]->cumulative_gas_used == 0x6d39); CHECK(receipts[1]->success == true); CHECK(receipts[1]->cumulative_gas_used == 0x371b0b); CHECK(receipts[2]->success == true); CHECK(receipts[2]->cumulative_gas_used == 0x3947f4); } TEST_CASE("decode receipts from incorrect bytes", "[rpc][ethdb][cbor]") { Receipts receipts{}; const Bytes b1 = *silkworm::from_hex("81"); CHECK_THROWS(cbor_decode(b1, receipts)); const Bytes b2 = *silkworm::from_hex("83808040"); CHECK_THROWS_MATCHES(cbor_decode(b2, receipts), std::system_error, Message("Receipt CBOR: missing entries: " + std::string{kInvalidArgumentMessage})); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/ethdb/kv/backend_providers.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc::ethdb::kv { inline db::chain::BlockProvider block_provider(ethbackend::BackEnd* backend) { return [backend](auto block_num, HashAsSpan hash, bool read_senders, auto& block) -> Task { co_return co_await backend->get_block(block_num, hash, read_senders, block); }; } inline db::chain::BlockNumFromTxnHashProvider block_num_from_txn_hash_provider(ethbackend::BackEnd* backend) { return [backend](HashAsSpan hash) -> Task>> { co_return co_await backend->get_block_num_from_txn_hash(hash); }; } inline db::chain::BlockNumFromBlockHashProvider block_num_from_block_hash_provider(ethbackend::BackEnd* backend) { return [backend](HashAsSpan hash) -> Task> { co_return co_await backend->get_block_num_from_hash(hash); }; } inline db::chain::CanonicalBlockHashFromNumberProvider canonical_block_hash_from_number_provider(ethbackend::BackEnd* backend) { return [backend](BlockNum block_num) -> Task> { co_return co_await backend->get_block_hash_from_block_num(block_num); }; } inline db::chain::CanonicalBodyForStorageProvider canonical_body_for_storage_provider(ethbackend::BackEnd* backend) { return [backend](BlockNum block_num) -> Task> { co_return co_await backend->canonical_body_for_storage(block_num); }; } inline db::chain::Providers make_backend_providers(ethbackend::BackEnd* backend) { return { ethdb::kv::block_provider(backend), ethdb::kv::block_num_from_txn_hash_provider(backend), ethdb::kv::block_num_from_block_hash_provider(backend), ethdb::kv::canonical_block_hash_from_number_provider(backend), ethdb::kv::canonical_body_for_storage_provider(backend)}; } } // namespace silkworm::rpc::ethdb::kv ================================================ FILE: silkworm/rpc/ethdb/split_cursor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "split_cursor.hpp" namespace silkworm::rpc::ethdb { SplitCursor::SplitCursor(Cursor& inner_cursor, ByteView key, uint64_t match_bits, uint64_t part1_end, uint64_t part2_start, uint64_t part3_start) : inner_cursor_{inner_cursor}, key_{key}, part1_end_{part1_end}, part2_start_{part2_start}, part3_start_{part3_start}, match_bytes_{(match_bits + 7) / 8} { uint8_t shift_bits = match_bits & 7; if (shift_bits != 0) { mask_ = static_cast(0xff << (8 - shift_bits)); } else { mask_ = 0xff; } first_bytes_ = key.substr(0, match_bytes_ - 1); if (match_bytes_ > 0) { last_bits_ = key[match_bytes_ - 1] & mask_; } } Task SplitCursor::seek() { KeyValue kv = co_await inner_cursor_.seek(key_); co_return split_key_value(kv); } Task SplitCursor::next() { KeyValue kv = co_await inner_cursor_.next(); co_return split_key_value(kv); } bool SplitCursor::match_key(const ByteView& key) { if (key.empty()) { return false; } if (match_bytes_ == 0) { return true; } if (key.size() < match_bytes_) { return false; } if (first_bytes_ != key.substr(0, match_bytes_ - 1)) { return false; } return ((key[match_bytes_ - 1] & mask_) == last_bits_); } SplittedKeyValue SplitCursor::split_key_value(const KeyValue& kv) { const Bytes& key = kv.key; if (key.empty()) { return SplittedKeyValue{}; } if (!match_key(key)) { return SplittedKeyValue{}; } SplittedKeyValue skv{key.substr(0, part1_end_)}; if (key.size() > part2_start_) { skv.key2 = kv.key.substr(part2_start_, part3_start_ - part2_start_); } if (key.size() > part3_start_) { skv.key3 = kv.key.substr(part3_start_); } skv.value = kv.value; return skv; } SplitCursorDupSort::SplitCursorDupSort(CursorDupSort& inner_cursor, ByteView key, ByteView subkey, uint64_t match_bits, uint64_t part1_end, uint64_t value_offset) : inner_cursor_{inner_cursor}, key_{key}, subkey_{subkey}, part1_end_{part1_end}, match_bytes_{(match_bits + 7) / 8}, value_offset_{value_offset} { uint8_t shift_bits = match_bits & 7; if (shift_bits != 0) { mask_ = static_cast(0xff << (8 - shift_bits)); } else { mask_ = 0xff; } first_bytes_ = key.substr(0, match_bytes_ - 1); if (match_bytes_ > 0) { last_bits_ = key[match_bytes_ - 1] & mask_; } } Task SplitCursorDupSort::seek_both() { auto value = co_await inner_cursor_.seek_both(key_, subkey_); co_return split_key_value(KeyValue{key_, value}); } Task SplitCursorDupSort::next_dup() { KeyValue kv = co_await inner_cursor_.next_dup(); co_return split_key_value(kv); } bool SplitCursorDupSort::match_key(const ByteView& key) { if (key.empty()) { return false; } if (match_bytes_ == 0) { return true; } if (key.size() < match_bytes_) { return false; } if (first_bytes_ != key.substr(0, match_bytes_ - 1)) { return false; } return ((key[match_bytes_ - 1] & mask_) == last_bits_); } SplittedKeyValue SplitCursorDupSort::split_key_value(const KeyValue& kv) { const Bytes& key = kv.key; if (key.empty()) { return SplittedKeyValue{}; } if (!match_key(key)) { return SplittedKeyValue{}; } SplittedKeyValue skv{}; if (kv.value.size() >= value_offset_) { skv.key1 = key.substr(0, part1_end_); skv.key2 = kv.value.substr(0, value_offset_); skv.value = kv.value.substr(value_offset_); } return skv; } } // namespace silkworm::rpc::ethdb ================================================ FILE: silkworm/rpc/ethdb/split_cursor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc::ethdb { using db::kv::api::Cursor; using db::kv::api::CursorDupSort; using db::kv::api::KeyValue; struct SplittedKeyValue { Bytes key1; Bytes key2; Bytes key3; Bytes value; }; class SplitCursor { public: SplitCursor(Cursor& inner_cursor, ByteView key, uint64_t match_bits, uint64_t part1_end, uint64_t part2_start, uint64_t part3_start); SplitCursor& operator=(const SplitCursor&) = delete; Task seek(); Task next(); private: Cursor& inner_cursor_; Bytes key_; Bytes first_bytes_; uint8_t last_bits_; uint64_t part1_end_; uint64_t part2_start_; uint64_t part3_start_; uint64_t match_bytes_; uint8_t mask_; bool match_key(const ByteView& key); SplittedKeyValue split_key_value(const KeyValue& kv); }; class SplitCursorDupSort { public: SplitCursorDupSort(CursorDupSort& inner_cursor, ByteView key, ByteView subkey, uint64_t match_bits, uint64_t part1_end, uint64_t value_offset); SplitCursorDupSort& operator=(const SplitCursorDupSort&) = delete; Task seek_both(); Task next_dup(); private: CursorDupSort& inner_cursor_; Bytes key_; Bytes subkey_; Bytes first_bytes_; uint8_t last_bits_; uint64_t part1_end_; uint64_t match_bytes_; uint8_t mask_; uint64_t value_offset_; bool match_key(const ByteView& key); SplittedKeyValue split_key_value(const KeyValue& kv); }; } // namespace silkworm::rpc::ethdb ================================================ FILE: silkworm/rpc/ethdb/split_cursor_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "split_cursor.hpp" #include #include #include #include #include #include #include #include namespace silkworm::rpc::ethdb { using evmc::literals::operator""_bytes32; using evmc::literals::operator""_address; using testing::_; using testing::InvokeWithoutArgs; static const silkworm::Bytes kValue{*silkworm::from_hex("0x000000000000000000000000000000000000000000000000000000000000001134567")}; static const silkworm::Bytes kEmptyKey{}; static const silkworm::Bytes kShortKey{*silkworm::from_hex("0x79a4d35bd00b1843ec5292217e71dace5e5")}; static const silkworm::Bytes kWrongKeyLastByte{*silkworm::from_hex("0x79a4d35bd00b1843ec5292217e71dace5e5a7430")}; static const silkworm::Bytes kWrongKeyFirstByte{*silkworm::from_hex("0x59a4d35bd00b1843ec5292217e71dace5e5a7430")}; static const silkworm::Bytes kKey{(0x79a4d35bd00b1843ec5292217e71dace5e5a7439_address).bytes, kAddressLength}; static const silkworm::Bytes kCorrectKey{*silkworm::from_hex("0x79a4d35bd00b1843ec5292217e71dace5e5a7439")}; static const silkworm::Bytes kLocation{(0x0000000000000000000000000000000000000000000000000000000000000001_bytes32).bytes, kHashLength}; TEST_CASE("split cursor dup sort") { WorkerPool pool{1}; db::test_util::MockCursorDupSort csdp; SECTION("0 matching bits: seek_both, key not exists") { SplitCursorDupSort sc(csdp, kKey, kLocation, 0, silkworm::kAddressLength, 0); EXPECT_CALL(csdp, seek_both(_, _)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return silkworm::Bytes{}; })); auto result = boost::asio::co_spawn(pool, sc.seek_both(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1) == silkworm::to_hex(kKey)); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: seek_both, key not exists") { SplitCursorDupSort sc(csdp, kKey, kLocation, 8 * silkworm::kAddressLength, silkworm::kAddressLength, silkworm::kHashLength); EXPECT_CALL(csdp, seek_both(_, _)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return silkworm::Bytes{}; })); auto result = boost::asio::co_spawn(pool, sc.seek_both(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address odd matching bits: seek_both, key not exists") { SplitCursorDupSort sc(csdp, kKey, kLocation, 153, silkworm::kAddressLength, silkworm::kHashLength); EXPECT_CALL(csdp, seek_both(_, _)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return silkworm::Bytes{}; })); auto result = boost::asio::co_spawn(pool, sc.seek_both(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: seek_both, key exists") { SplitCursorDupSort sc(csdp, kKey, kLocation, 8 * silkworm::kAddressLength, silkworm::kAddressLength, silkworm::kHashLength); EXPECT_CALL(csdp, seek_both(_, _)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return kValue; })); auto result = boost::asio::co_spawn(pool, sc.seek_both(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1) == silkworm::to_hex(kKey)); CHECK(silkworm::to_hex(skv.key2) == silkworm::to_hex(kLocation)); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value) == "134567"); } SECTION("evmc:.address maching bits: next_dup, key exists short key") { SplitCursorDupSort sc(csdp, kKey, kLocation, 8 * silkworm::kAddressLength, silkworm::kAddressLength, silkworm::kHashLength); EXPECT_CALL(csdp, next_dup()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kShortKey, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next_dup(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: next_dup, key exists empty key") { SplitCursorDupSort sc(csdp, kKey, kLocation, 8 * silkworm::kAddressLength, silkworm::kAddressLength, silkworm::kHashLength); EXPECT_CALL(csdp, next_dup()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kEmptyKey, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next_dup(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: next_dup, key exists wrong key last byte") { SplitCursorDupSort sc(csdp, kKey, kLocation, 8 * silkworm::kAddressLength, silkworm::kAddressLength, silkworm::kHashLength); EXPECT_CALL(csdp, next_dup()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kWrongKeyLastByte, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next_dup(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: next_dup, key exists wrong key first byte") { SplitCursorDupSort sc(csdp, kKey, kLocation, 8 * silkworm::kAddressLength, silkworm::kAddressLength, silkworm::kHashLength); EXPECT_CALL(csdp, next_dup()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kWrongKeyFirstByte, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next_dup(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } } TEST_CASE("split cursor") { WorkerPool pool{1}; db::test_util::MockCursor csdp; SECTION("0 matching bits: seek, key not exists") { SplitCursor sc(csdp, kKey, 0, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, seek(_)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kCorrectKey, {}}; })); auto result = boost::asio::co_spawn(pool, sc.seek(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1) == silkworm::to_hex(kKey)); CHECK(silkworm::to_hex(skv.key2) == silkworm::to_hex(kKey)); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: seek, key not exists") { SplitCursor sc(csdp, kKey, 8 * silkworm::kAddressLength, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, seek(_)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kShortKey, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.seek(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address odd matching bits: seek, key not exists") { SplitCursor sc(csdp, kKey, 131, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, seek(_)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kShortKey, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.seek(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: seek, key exists") { SplitCursor sc(csdp, kKey, 8 * silkworm::kAddressLength, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, seek(_)) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kCorrectKey, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.seek(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1) == silkworm::to_hex(kKey)); CHECK(silkworm::to_hex(skv.key2) == silkworm::to_hex(kKey)); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value) == "0000000000000000000000000000000000000000000000000000000000000001134567"); } SECTION("evmc:.address matching bits: next_dup, key exists short key") { SplitCursor sc(csdp, kKey, 8 * silkworm::kAddressLength, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, next()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kShortKey, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: next, empty key") { SplitCursor sc(csdp, kKey, 8 * silkworm::kAddressLength, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, next()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kEmptyKey, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: next, key exists wrong key last byte") { SplitCursor sc(csdp, kKey, 8 * silkworm::kAddressLength, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, next()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kWrongKeyLastByte, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } SECTION("evmc:.address matching bits: next, key exists wrong key first byte") { SplitCursor sc(csdp, kKey, 8 * silkworm::kAddressLength, silkworm::kAddressLength, 0, silkworm::kAddressLength); EXPECT_CALL(csdp, next()) .WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{kWrongKeyFirstByte, kValue}; })); auto result = boost::asio::co_spawn(pool, sc.next(), boost::asio::use_future); const SplittedKeyValue& skv = result.get(); CHECK(silkworm::to_hex(skv.key1).empty()); CHECK(silkworm::to_hex(skv.key2).empty()); CHECK(silkworm::to_hex(skv.key3).empty()); CHECK(silkworm::to_hex(skv.value).empty()); } } } // namespace silkworm::rpc::ethdb ================================================ FILE: silkworm/rpc/ethdb/walk.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "walk.hpp" #include namespace silkworm::rpc::ethdb { Task walk(db::kv::api::Transaction& tx, std::string_view table, ByteView start_key, uint32_t fixed_bits, Walker w) { const auto fixed_bytes = (fixed_bits + 7) / CHAR_BIT; SILK_TRACE << "rpc::ethdb::walk fixed_bits: " << fixed_bits << " fixed_bytes: " << fixed_bytes; const auto shift_bits = fixed_bits & 7; uint8_t mask{0xff}; if (shift_bits != 0) { mask = static_cast(0xff << (CHAR_BIT - shift_bits)); } SILK_TRACE << "mask: " << std::hex << std::setw(2) << std::setfill('0') << static_cast(mask) << std::dec; const auto new_cursor = co_await tx.cursor(table); SILK_TRACE << "rpc::ethdb::walk cursor_id: " << new_cursor->cursor_id(); auto kv_pair = co_await new_cursor->seek(start_key); auto k = kv_pair.key; auto v = kv_pair.value; SILK_TRACE << "k: " << k << " v: " << v; while ( !k.empty() && k.size() >= fixed_bytes && (fixed_bits == 0 || (k.compare(0, fixed_bytes - 1, start_key, 0, fixed_bytes - 1) == 0 && (k[fixed_bytes - 1] & mask) == (start_key[fixed_bytes - 1] & mask)))) { const auto go_on = w(k, v); if (!go_on) { break; } kv_pair = co_await new_cursor->next(); k = kv_pair.key; v = kv_pair.value; } } Task for_prefix(db::kv::api::Transaction& tx, std::string_view table, ByteView prefix, Walker w) { const auto new_cursor = co_await tx.cursor(table); SILK_TRACE << "rpc::ethdb::for_prefix cursor_id: " << new_cursor->cursor_id() << " prefix: " << silkworm::to_hex(prefix); auto kv_pair = co_await new_cursor->seek(prefix); auto k = kv_pair.key; auto v = kv_pair.value; SILK_TRACE << "rpc::ethdb::for_prefix k: " << k << " v: " << v; while (k.substr(0, prefix.size()) == prefix) { const auto go_on = w(k, v); if (!go_on) { break; } kv_pair = co_await new_cursor->next(); k = kv_pair.key; v = kv_pair.value; SILK_TRACE << "rpc::ethdb::for_prefix k: " << k << " v: " << v; } } } // namespace silkworm::rpc::ethdb ================================================ FILE: silkworm/rpc/ethdb/walk.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc::ethdb { using Walker = std::function; Task walk(db::kv::api::Transaction& tx, std::string_view table, ByteView start_key, uint32_t fixed_bits, Walker w); Task for_prefix(db::kv::api::Transaction& tx, std::string_view table, ByteView prefix, Walker w); } // namespace silkworm::rpc::ethdb ================================================ FILE: silkworm/rpc/http/chunker.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc::http { inline constexpr int kDefaultMaxChunkSize = 2048; class Chunker { public: Chunker(const Chunker&) = delete; Chunker() { current_chunk_.reserve(kDefaultMaxChunkSize); } ~Chunker() = default; void queue_data(const std::string& new_buffer) { size_t position = 0; // creates chunk: even if new:buffer is greater kDefaultMaxChunkSize while (position < new_buffer.size()) { size_t available_space = kDefaultMaxChunkSize - current_chunk_.size(); const size_t chunk_size = std::min(available_space, new_buffer.size() - position); current_chunk_.append(new_buffer, position, chunk_size); position += chunk_size; // one chunk is completed copy it in complete_chunk queue if (current_chunk_.size() >= kDefaultMaxChunkSize) { complete_chunk_.push_back(std::move(current_chunk_)); current_chunk_.clear(); } } } std::pair get_complete_chunk() { if (!complete_chunk_.empty()) { // at least one chunk is available return it , indicating if first chunk or not auto ret_first_chunk = !first_chunk_completed_; first_chunk_completed_ = true; std::string chunk = std::move(complete_chunk_.front()); complete_chunk_.pop_front(); return std::make_pair(std::move(chunk), ret_first_chunk); } // queue is empty no chunk are available return std::make_pair("", false); } bool has_chunks() const { return !complete_chunk_.empty(); } std::pair get_remainder() { if (current_chunk_.empty()) { // no bytes are present on current_chunk so return empty string and indication if first chunk or not // we are in two possible cases: at least one completed chunk is already produced, or any chunk are produced return std::make_pair("", !first_chunk_completed_); } // returns the chunk return std::make_pair(std::move(current_chunk_), !first_chunk_completed_); } private: std::deque complete_chunk_; std::string current_chunk_; bool first_chunk_completed_{false}; }; }; // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/http/connection.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "connection.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::http { using namespace std::chrono_literals; static constexpr std::string_view kMaxAge{"600"}; static constexpr uint64_t kMaxPayloadSize = 30 * kMebi; // 30MiB static constexpr std::array kAcceptedContentTypes{"application/json", "application/jsonrequest", "application/json-rpc"}; static constexpr std::string_view kGzipEncoding{"gzip"}; static constexpr std::string_view kIdentity{"Identity"}; static constexpr std::string_view kBearerTokenPrefix{"Bearer "}; // space matters: format is `Bearer ` Task Connection::run_read_loop(std::shared_ptr connection) { co_await connection->read_loop(); } Connection::Connection(boost::asio::ip::tcp::socket socket, RequestHandlerFactory& handler_factory, const std::vector& allowed_origins, std::optional jwt_secret, bool ws_upgrade_enabled, bool ws_compression, bool http_compression, WorkerPool& workers, bool erigon_json_rpc_compatibility) : socket_{std::move(socket)}, handler_factory_{handler_factory}, handler_{handler_factory_(this)}, allowed_origins_{allowed_origins}, jwt_secret_{std ::move(jwt_secret)}, ws_upgrade_enabled_{ws_upgrade_enabled}, ws_compression_{ws_compression}, http_compression_{http_compression}, workers_{workers}, erigon_json_rpc_compatibility_{erigon_json_rpc_compatibility} { socket_.set_option(boost::asio::ip::tcp::socket::keep_alive(true)); SILK_TRACE << "Connection::Connection created for " << socket_.remote_endpoint(); } Connection::~Connection() { socket_.close(); SILK_TRACE << "Connection::~Connection socket " << &socket_ << " deleted"; } Task Connection::read_loop() { try { bool continue_processing{true}; while (continue_processing) { continue_processing = co_await do_read(); } } catch (const boost::system::system_error& se) { if (se.code() == boost::beast::http::error::end_of_stream) { SILK_TRACE << "Connection::read_loop received graceful close from " << socket_.remote_endpoint(); } else { SILK_TRACE << "Connection::read_loop system_error: " << se.code(); } } catch (const std::exception& e) { SILK_ERROR << "Connection::read_loop exception: " << e.what(); } } Task Connection::do_read() { SILK_TRACE << "Connection::do_read going to read..."; boost::beast::http::request_parser parser; parser.body_limit(kMaxPayloadSize); const auto bytes_transferred = co_await boost::beast::http::async_read(socket_, data_, parser, boost::asio::use_awaitable); SILK_TRACE << "Connection::do_read bytes_read: " << bytes_transferred << " message: " << parser.get(); if (!parser.is_done()) { co_return true; } auto req = parser.release(); const auto accept_encoding = req[boost::beast::http::field::accept_encoding]; auto gzip_encoding_requested = accept_encoding.contains(kGzipEncoding) && http_compression_; RequestData request_data{ .request_keep_alive = parser.get().keep_alive(), .request_http_version = parser.get().version(), .gzip_encoding_requested = gzip_encoding_requested, .vary = req[boost::beast::http::field::vary], .origin = req[boost::beast::http::field::origin], .method = req.method(), }; if (boost::beast::websocket::is_upgrade(parser.get())) { if (const auto auth_result = is_request_authorized(parser.get()); !auth_result) { co_await do_write(auth_result.error() + "\n", boost::beast::http::status::forbidden, request_data); co_return false; } if (ws_upgrade_enabled_) { co_await do_upgrade(parser.release()); co_return false; } else { // If it does not (or cannot) upgrade the connection, it ignores the Upgrade header and sends back a regular response (OK) co_await do_write("", boost::beast::http::status::ok, request_data); } co_return true; } co_await handle_request(req, request_data); co_return true; } Task Connection::do_upgrade(const RequestWithStringBody& req) { // Now that talking to the socket is successful, we tie the socket object to a WebSocket stream boost::beast::websocket::stream stream(std::move(socket_)); auto ws_connection = std::make_shared(std::move(stream), handler_factory_, ws_compression_); co_await ws_connection->accept(req); auto connection_loop = [](auto websocket_connection) -> Task { co_await websocket_connection->read_loop(); }; boost::asio::co_spawn(socket_.get_executor(), connection_loop(ws_connection), boost::asio::detached); } Task Connection::handle_request(const RequestWithStringBody& req, RequestData& request_data) { if (req.method() == boost::beast::http::verb::options && !req[boost::beast::http::field::access_control_request_method].empty()) { co_await handle_preflight(req, request_data); } else { co_await handle_actual_request(req, request_data); } } Task Connection::handle_preflight(const RequestWithStringBody& req, RequestData& request_data) { boost::beast::http::response res{boost::beast::http::status::no_content, request_data.request_http_version}; std::string vary = req[boost::beast::http::field::vary]; if (vary.empty()) { res.set(boost::beast::http::field::vary, "Origin, Access-Control-Request-Method, Access-Control-Request-Headers"); } else { vary.append(" Origin"); res.set(boost::beast::http::field::vary, vary); } std::string origin = req[boost::beast::http::field::origin]; if (!origin.empty() && is_origin_allowed(allowed_origins_, origin) && is_method_allowed(req.method())) { if (allowed_origins_.at(0) == "*") { res.set(boost::beast::http::field::access_control_allow_origin, "*"); } else { res.set(boost::beast::http::field::access_control_allow_origin, origin); } res.set(boost::beast::http::field::access_control_request_method, req[boost::beast::http::field::access_control_request_method]); res.set(boost::beast::http::field::access_control_allow_headers, "*"); res.set(boost::beast::http::field::access_control_max_age, kMaxAge); } res.prepare_payload(); co_await boost::beast::http::async_write(socket_, res, boost::asio::use_awaitable); } Task Connection::handle_actual_request(const RequestWithStringBody& req, RequestData& request_data) { const auto accept_encoding = req[boost::beast::http::field::accept_encoding]; if (req.body().empty()) { co_await do_write(std::string{}, boost::beast::http::status::ok, request_data); // just like Erigon co_return; } if (!http_compression_ && !accept_encoding.empty() && !erigon_json_rpc_compatibility_) { co_await do_write("unsupported compression\n", boost::beast::http::status::unsupported_media_type, request_data, "identity"); co_return; } if (http_compression_ && !accept_encoding.empty() && !accept_encoding.contains(kIdentity) && !request_data.gzip_encoding_requested) { co_await do_write("unsupported requested compression\n", boost::beast::http::status::unsupported_media_type, request_data, kGzipEncoding); co_return; } // Check HTTP method and content type [max body size is limited using beast::http::request_parser::body_limit in do_read] if (!is_method_allowed(req.method())) { co_await do_write("method not allowed\n", boost::beast::http::status::method_not_allowed, request_data); co_return; } if (req.method() != boost::beast::http::verb::options && req.method() != boost::beast::http::verb::get) { if (!is_accepted_content_type(req[boost::beast::http::field::content_type])) { co_await do_write("invalid content type\n, only application/json is supported\n", boost::beast::http::status::bad_request, request_data); co_return; } } SILK_TRACE << "Connection::handle_request body size: " << req.body().size() << " data: " << req.body(); if (const auto auth_result = is_request_authorized(req); !auth_result) { co_await do_write(auth_result.error() + "\n", boost::beast::http::status::forbidden, request_data); co_return; } request_map_.emplace(request_id_, std::move(request_data)); auto rsp_content = co_await handler_->handle(req.body(), request_id_); if (rsp_content) { // no streaming const auto& req_data = request_map_.at(request_id_); co_await do_write(rsp_content->append("\n"), boost::beast::http::status::ok, req_data, req_data.gzip_encoding_requested ? kGzipEncoding : "", req_data.gzip_encoding_requested); const auto it = request_map_.find(request_id_); if (it != request_map_.end()) { request_map_.erase(it); } } request_id_++; } //! Write chunked response headers Task Connection::create_chunk_header(RequestData& request_data) { try { boost::beast::http::response rsp{boost::beast::http::status::ok, request_data.request_http_version}; rsp.set(boost::beast::http::field::content_type, "application/json"); rsp.set(boost::beast::http::field::date, get_date_time()); rsp.chunked(true); if (request_data.gzip_encoding_requested) { rsp.set(boost::beast::http::field::content_encoding, kGzipEncoding); } set_cors(rsp, request_data); boost::beast::http::response_serializer serializer{rsp}; co_await async_write_header(socket_, serializer, boost::asio::use_awaitable); } catch (const boost::system::system_error& se) { SILK_TRACE << "Connection::create_chunk_header system_error: " << se.what(); throw; } catch (const std::exception& e) { SILK_ERROR << "Connection::create_chunk_header exception: " << e.what(); throw; } co_return; } Task Connection::open_stream(uint64_t request_id) { const auto request_data_it = request_map_.find(request_id); if (request_data_it == request_map_.end()) { SILK_ERROR << "Connection::open_stream request_id not found: " << request_id; SILKWORM_ASSERT(false); } auto& request_data = request_data_it->second; // add chunking supports request_data.chunk = std::make_unique(); if (request_data.gzip_encoding_requested) { request_data.zlib_compressor = std::make_unique(); } request_data.chunk = std::make_unique(); co_return; } Task Connection::close_stream(uint64_t request_id) { const auto request_data_it = request_map_.find(request_id); if (request_data_it == request_map_.end()) { SILK_ERROR << "Connection::close_stream request_id not found: " << request_id; SILKWORM_ASSERT(false); } auto& request_data = request_data_it->second; try { // Get remaining chunk and flush it auto [chunk, first_chunk] = request_data.chunk->get_remainder(); if (first_chunk) { if (!chunk.empty()) { // If it is the first chunk, send without chunking co_await do_write(chunk, boost::beast::http::status::ok, request_data, request_data.gzip_encoding_requested ? kGzipEncoding : "", /* to_be_compressed */ false); // data already compressed if nec } } else { // A previous chunk was already generated if (!chunk.empty()) { // Send the new one co_await send_chunk(chunk); } co_await boost::asio::async_write(socket_, boost::beast::http::make_chunk_last(), boost::asio::use_awaitable); } } catch (const boost::system::system_error& se) { request_map_.erase(request_data_it); SILK_TRACE << "Connection::close system_error: " << se.what(); throw; } catch (const std::exception& e) { request_map_.erase(request_data_it); SILK_ERROR << "Connection::close exception: " << e.what(); throw; } request_map_.erase(request_data_it); co_return; } //! Write chunked response content to the underlying socket Task Connection::write(uint64_t request_id, std::string_view content, bool last) { const auto request_data_it = request_map_.find(request_id); if (request_data_it == request_map_.end()) { SILK_ERROR << "Connection::write request_id not found: " << request_id; SILKWORM_ASSERT(false); } auto& request_data = request_data_it->second; std::string response(std::move(content)); if (last) { response.append("\n"); } if (request_data.gzip_encoding_requested) { std::string compressed_content; co_await compress(response, compressed_content); // queued compressed buffer request_data.chunk->queue_data(compressed_content); } else { // queued clear buffer request_data.chunk->queue_data(response); } // until completed chunk are present while (request_data.chunk->has_chunks()) { auto [complete_chunk, first_chunk] = request_data.chunk->get_complete_chunk(); if (first_chunk) { co_await create_chunk_header(request_data); } co_await send_chunk(complete_chunk); } co_return 0; } Task Connection::send_chunk(const std::string& content) { size_t bytes_transferred{0}; try { boost::asio::const_buffer buffer{content.data(), content.size()}; bytes_transferred = co_await boost::asio::async_write(socket_, boost::beast::http::chunk_body(buffer), boost::asio::use_awaitable); } catch (const boost::system::system_error& se) { SILK_TRACE << "Connection::write system_error: " << se.what(); throw; } catch (const std::exception& e) { SILK_ERROR << "Connection::write exception: " << e.what(); throw; } SILK_TRACE << "Connection::write bytes_transferred: " << bytes_transferred; co_return bytes_transferred; } Task Connection::do_write(const std::string& content, boost::beast::http::status http_status, const RequestData& request_data, std::string_view content_encoding, bool to_be_compressed) { try { SILK_TRACE << "Connection::do_write response: " << http_status << " content: " << content; boost::beast::http::response res{http_status, request_data.request_http_version}; if (http_status != boost::beast::http::status::ok) { res.set(boost::beast::http::field::content_type, "text/plain"); } else { res.set(boost::beast::http::field::content_type, "application/json"); } res.set(boost::beast::http::field::date, get_date_time()); res.erase(boost::beast::http::field::host); res.keep_alive(request_data.request_keep_alive); if (http_status == boost::beast::http::status::ok && !content_encoding.empty()) { // Positive response w/ compression required res.set(boost::beast::http::field::content_encoding, content_encoding); if (to_be_compressed) { std::string compressed_content; co_await compress(content, compressed_content); res.content_length(compressed_content.size()); res.body() = std::move(compressed_content); } else { res.content_length(content.size()); res.body() = content; } } else { // Any negative response or positive response w/o compression if (!content_encoding.empty()) { res.set(boost::beast::http::field::accept_encoding, content_encoding); // Indicate the supported encoding } res.content_length(content.size()); res.body() = content; } set_cors(res, request_data); res.prepare_payload(); const auto bytes_transferred = co_await boost::beast::http::async_write(socket_, res, boost::asio::use_awaitable); SILK_TRACE << "Connection::do_write bytes_transferred: " << bytes_transferred; } catch (const boost::system::system_error& se) { SILK_TRACE << "Connection::do_write system_error: " << se.what(); throw; } catch (const std::exception& e) { SILK_ERROR << "Connection::do_write exception: " << e.what(); throw; } co_return; } Connection::AuthorizationResult Connection::is_request_authorized(const RequestWithStringBody& req) { if (!jwt_secret_ || jwt_secret_->empty()) { return {}; } // Bearer authentication system: HTTP Authorization header with expected value `Bearer ` const auto authorization_it = req.find("Authorization"); if (authorization_it == req.end()) { SILK_ERROR << "HTTP request without Authorization header received from " << socket_.remote_endpoint(); return tl::make_unexpected("missing token"); } std::string client_token; const auto authorization_value{authorization_it->value()}; if (authorization_value.starts_with(kBearerTokenPrefix)) { client_token = authorization_value.substr(kBearerTokenPrefix.size()); } else { SILK_ERROR << "HTTP request without Bearer token in Authorization header received from " << socket_.remote_endpoint(); return tl::make_unexpected("missing token"); } try { // Parse JWT token payload const auto decoded_client_token = jwt::decode(client_token); if (decoded_client_token.has_issued_at() == 0) { SILK_ERROR << "JWT iat (issued-at) claim not present in token received from " << socket_.remote_endpoint(); return tl::make_unexpected("missing issued-at claim"); } // Ensure JWT iat timestamp is within +-60 seconds from the current time // https://github.com/ethereum/execution-apis/blob/main/src/engine/authentication.md#jwt-claims const auto issued_at_timestamp{decoded_client_token.get_issued_at()}; const auto current_timestamp{std::chrono::system_clock::now()}; if (std::chrono::abs(std::chrono::duration_cast(current_timestamp - issued_at_timestamp)) > 60s) { SILK_ERROR << "JWT iat (issued-at) claim not present in token received from " << socket_.remote_endpoint(); return tl::make_unexpected("invalid issued-at claim"); } // Validate received JWT token const auto verifier = jwt::verify().allow_algorithm(jwt::algorithm::hs256{*jwt_secret_}); SILK_TRACE << "JWT client token: " << client_token << " secret: " << *jwt_secret_; verifier.verify(decoded_client_token); } catch (const std::system_error& se) { SILK_ERROR << "JWT invalid token: " << se.what(); return tl::make_unexpected(se.what()); } catch (const std::exception& se) { SILK_ERROR << "JWT invalid token: " << se.what(); return tl::make_unexpected("invalid token"); } return {}; } template void Connection::set_cors(boost::beast::http::response& res, const RequestData& request_data) { if (request_data.vary.empty()) { res.set(boost::beast::http::field::vary, "Origin"); } else { auto vary{request_data.vary}; res.set(boost::beast::http::field::vary, vary.append(" Origin")); } if (request_data.origin.empty()) { return; } if (!is_origin_allowed(allowed_origins_, request_data.origin)) { return; } if (!is_method_allowed(request_data.method)) { return; } if (allowed_origins_.at(0) == "*") { res.set(boost::beast::http::field::access_control_allow_origin, "*"); } else { res.set(boost::beast::http::field::access_control_allow_origin, request_data.origin); } } bool Connection::is_origin_allowed(const std::vector& allowed_origins, const std::string& origin) { if (allowed_origins.size() == 1 && allowed_origins[0] == "*") { return true; } if (std::ranges::any_of(allowed_origins, [&](const auto& allowed) { return origin == allowed; })) { return true; } return false; } bool Connection::is_accepted_content_type(const std::string& req_content_type) { return std::ranges::any_of(kAcceptedContentTypes, [&](const auto& content_type) { return req_content_type == content_type; }); } bool Connection::is_method_allowed(boost::beast::http::verb method) { return (method == boost::beast::http::verb::options || method == boost::beast::http::verb::post || method == boost::beast::http::verb::get); } std::string Connection::get_date_time() { static const absl::TimeZone kTz{absl::LocalTimeZone()}; static std::pair cache; static std::shared_mutex cache_mutex; // read cache std::pair result; { std::shared_lock lock{cache_mutex}; result = cache; } const int64_t ts = absl::ToUnixSeconds(absl::Now()); // if timestamp matches - return the cached result if (ts == result.first) { return std::move(result.second); } // otherwise - format const absl::Time now = absl::FromUnixSeconds(ts); std::stringstream ss; ss << absl::FormatTime("%a, %d %b %E4Y %H:%M:%S ", now, kTz) << kTz.name(); result = {ts, ss.str()}; // update cache if timestamp increased { std::unique_lock lock{cache_mutex}; if (ts > cache.first) { cache = result; } } return std::move(result.second); } Task Connection::compress(const std::string& clear_data, std::string& compressed_data) { co_await async_task(workers_.executor(), [&]() -> void { Deflater deflater; deflater.compress(clear_data, compressed_data); }); } Task Connection::compress_stream(const std::string& clear_data, std::string& compressed_data, const RequestData& req_data, bool last) { co_await async_task(workers_.executor(), [&]() -> void { req_data.zlib_compressor->compress_chunk(clear_data, compressed_data, last); }); } } // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/http/connection.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::http { using RequestWithStringBody = boost::beast::http::request; inline constexpr size_t kDefaultCapacity = 1 * 1024 * 1024; struct RequestData { bool request_keep_alive{false}; unsigned int request_http_version{11}; bool gzip_encoding_requested{false}; std::string vary; std::string origin; boost::beast::http::verb method{boost::beast::http::verb::unknown}; std::unique_ptr chunk; std::unique_ptr zlib_compressor; }; //! Represents a single connection from a client. class Connection : public StreamWriter { public: //! Run the asynchronous read loop for the specified connection. //! \note This is co_spawn-friendly because the connection lifetime is tied to the coroutine frame static Task run_read_loop(std::shared_ptr connection); Connection(const Connection&) = delete; Connection& operator=(const Connection&) = delete; //! Construct a connection running within the given execution context. Connection(boost::asio::ip::tcp::socket socket, RequestHandlerFactory& handler_factory, const std::vector& allowed_origins, std::optional jwt_secret, bool ws_upgrade_enabled, bool ws_compression, bool http_compression, WorkerPool& workers, bool erigon_json_rpc_compatibility); ~Connection() override; /* StreamWriter Interface */ Task open_stream(uint64_t request_id) override; Task close_stream(uint64_t request_id) override; size_t get_capacity() const noexcept override { return kDefaultCapacity; } Task write(uint64_t request_id, std::string_view content, bool last) override; protected: //! Start the asynchronous read loop for the connection Task read_loop(); using AuthorizationError = std::string; using AuthorizationResult = tl::expected; AuthorizationResult is_request_authorized(const RequestWithStringBody& req); Task handle_request(const RequestWithStringBody& req, RequestData& request_data); Task handle_actual_request(const RequestWithStringBody& req, RequestData& request_data); Task handle_preflight(const RequestWithStringBody& req, RequestData& request_data); bool is_origin_allowed(const std::vector& allowed_origins, const std::string& origin); bool is_method_allowed(boost::beast::http::verb method); bool is_accepted_content_type(const std::string& content_type); Task do_upgrade(const RequestWithStringBody& req); template void set_cors(boost::beast::http::response& res, const RequestData& request_data); //! Perform an asynchronous read operation. Task do_read(); //! Perform an asynchronous write operation. Task do_write(const std::string& content, boost::beast::http::status http_status, const RequestData& request_data, std::string_view content_encoding = "", bool to_be_compressed = false); static std::string get_date_time(); Task compress(const std::string& clear_data, std::string& compressed_data); Task compress_stream(const std::string& clear_data, std::string& compressed_data, const RequestData& req_data, bool last); Task create_chunk_header(RequestData& request_data); Task send_chunk(const std::string& content); //! Socket for the connection. boost::asio::ip::tcp::socket socket_; RequestHandlerFactory& handler_factory_; //! The handler used to process the incoming request. RequestHandlerPtr handler_; const std::vector& allowed_origins_; const std::optional jwt_secret_; boost::beast::flat_buffer data_; bool ws_upgrade_enabled_; bool ws_compression_; bool http_compression_; WorkerPool& workers_; bool erigon_json_rpc_compatibility_{false}; uint64_t request_id_{0}; std::map request_map_; }; } // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/http/connection_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "connection.hpp" #include #include #include #include #include #include namespace silkworm::rpc::http { // Exclude gRPC tests from sanitizer builds due to data race warnings inside gRPC library // SUMMARY: ThreadSanitizer: data race /usr/include/c++/11/bits/stl_algobase.h:431 // - write of size 1 thread T8 'grpc_global_tim' created by main thread // - previous write of size 1 by main thread #ifndef SILKWORM_SANITIZE class ConnectionForTest : public Connection { public: using Connection::Connection; using Connection::is_request_authorized; }; TEST_CASE("connection creation", "[rpc][http][connection]") { SECTION("field initialization") { boost::asio::io_context ioc; boost::asio::ip::tcp::socket socket{ioc}; socket.open(boost::asio::ip::tcp::v4()); RequestHandlerFactory handler_factory = [](auto*) -> RequestHandlerPtr { return nullptr; }; std::vector allowed_origins; std::optional jwt_secret; WorkerPool workers; CHECK_NOTHROW(ConnectionForTest{std::move(socket), handler_factory, allowed_origins, std::move(jwt_secret), /*ws_upgrade_enabled=*/false, /*ws_compression=*/false, /*http_compression=*/false, workers, /*erigon_json_rpc_compatibility=*/true}); } } static constexpr std::string_view kSampleJWTKey{ "NTNv7j0TuYARvmNMmWXo6fKvM4o6nv/aUi9ryX38ZH+L1bkrnD1ObOQ8JAUmHCBq7Iy7otZcyAagBLHVKvvYaIpmMuxmARQ97jUVG16Jkpkp1wXO" "PsrF9zwew6TpczyHkHgX5EuLg2MeBuiT/qJACs1J0apruOOJCg/gOtkjB4c="}; static constexpr std::string_view kSampleJWTBearer{ "Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUs" "ImlhdCI6MTcxMzUxNDQ3MCwiZXhwIjoxNzEzNTE4MDcwfQ.IBKIdE8Bcto9cwGSkr6mqylBLvfcPZZyDOyZMWYtEaQ"}; static std::string create_and_sign_jwt_token(auto&& jwt_secret, bool include_issued_at = true) { auto token_builder{jwt::create()}; if (include_issued_at) { token_builder.set_issued_at(jwt::date::clock::now()); } return token_builder.sign(jwt::algorithm::hs256{std::forward(jwt_secret)}); } static RequestWithStringBody create_request_with_authorization(std::string_view auth_value) { RequestWithStringBody req; req.insert(boost::beast::http::field::authorization, auth_value); return req; } static RequestWithStringBody create_request_with_bearer_token(const std::string& jwt_token) { return create_request_with_authorization("Bearer " + jwt_token); } TEST_CASE("is_request_authorized", "[rpc][http][connection]") { boost::asio::io_context ioc; RequestHandlerFactory handler_factory = [](auto*) -> RequestHandlerPtr { return nullptr; }; std::vector allowed_origins; WorkerPool workers; std::optional jwt_secret{kSampleJWTKey}; ConnectionForTest connection = [&]() -> ConnectionForTest { boost::asio::ip::tcp::socket socket{ioc}; socket.open(boost::asio::ip::tcp::v4()); return { std::move(socket), handler_factory, allowed_origins, jwt_secret, /*ws_upgrade_enabled=*/false, /*ws_compression=*/false, /*http_compression=*/false, workers, /*erigon_json_rpc_compatibility=*/true}; }(); SECTION("no HTTP Authorization header") { const auto auth_result{connection.is_request_authorized(RequestWithStringBody{})}; CHECK(!auth_result); CHECK(auth_result.error() == "missing token"); } SECTION("empty HTTP Authorization header") { RequestWithStringBody req; req.insert(boost::beast::http::field::authorization, ""); const auto auth_result{connection.is_request_authorized(req)}; CHECK(!auth_result); CHECK(auth_result.error() == "missing token"); } SECTION("invalid Bearer token") { RequestWithStringBody req{create_request_with_authorization("Bear")}; const auto auth_result{connection.is_request_authorized(req)}; CHECK(!auth_result); CHECK(auth_result.error() == "missing token"); } SECTION("invalid JWT token") { RequestWithStringBody req = create_request_with_bearer_token("INVALID_TOKEN"); const auto auth_result{connection.is_request_authorized(req)}; CHECK(!auth_result); CHECK(auth_result.error() == "invalid token"); } SECTION("invalid JWT issued-at claim") { // Create the HTTP request using a valid-but-too-old Bearer token RequestWithStringBody req = create_request_with_authorization(kSampleJWTBearer); const auto auth_result{connection.is_request_authorized(req)}; CHECK(!auth_result); CHECK(auth_result.error() == "invalid issued-at claim"); } SECTION("invalid JWT signature") { // Create *now* a new JWT token and sign it using `another_jwt_secret` std::optional another_jwt_secret{"00112233"}; const auto jwt_token{create_and_sign_jwt_token(*another_jwt_secret)}; // Create the HTTP request using the JWT token RequestWithStringBody req = create_request_with_bearer_token(jwt_token); const auto auth_result{connection.is_request_authorized(req)}; CHECK(!auth_result); CHECK(auth_result.error() == "invalid signature"); } SECTION("missing JWT issued-at claim") { // Create *now* a new JWT token w/o issued-at claim and sign it using the same `jwt_secret` const auto jwt_token{create_and_sign_jwt_token(*jwt_secret, /*include_issued_at=*/false)}; // Create the HTTP request using the JWT token RequestWithStringBody req = create_request_with_bearer_token(jwt_token); const auto auth_result{connection.is_request_authorized(req)}; CHECK(!auth_result); CHECK(auth_result.error() == "missing issued-at claim"); } SECTION("valid JWT token") { // Create *now* a new JWT token and sign it using the same `jwt_secret` const auto jwt_token{create_and_sign_jwt_token(*jwt_secret)}; // Create the HTTP request using the JWT token RequestWithStringBody req = create_request_with_bearer_token(jwt_token); CHECK(connection.is_request_authorized(req)); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/http/deflater.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc::http { inline constexpr int kDefaultCompressionLevel = 6; class Deflater { public: Deflater(const Deflater&) = delete; Deflater() : compressor_(libdeflate_alloc_compressor(kDefaultCompressionLevel)) {} ~Deflater() { libdeflate_free_compressor(compressor_); } void compress(const std::string& clear_data, std::string& compressed_data) const { const size_t max_compressed_data = libdeflate_gzip_compress_bound(compressor_, clear_data.size()); compressed_data.resize(max_compressed_data); const size_t compressed_data_size = libdeflate_gzip_compress( compressor_, clear_data.data(), clear_data.size(), compressed_data.data(), compressed_data.size()); if (compressed_data_size == 0) { throw std::runtime_error("compression error"); } compressed_data.resize(compressed_data_size); } private: libdeflate_compressor* compressor_; }; } // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/http/jwt.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "jwt.hpp" #include #include #include #include #include #include static std::string hex_to_string(const std::string& jwt_token) { const auto jwt_token_bytes = silkworm::from_hex(jwt_token); if (!jwt_token_bytes) { const auto error_msg{"JWT token format is incorrect: " + jwt_token}; SILK_ERROR << error_msg; throw std::runtime_error{error_msg}; } return {jwt_token_bytes->cbegin(), jwt_token_bytes->cend()}; } namespace silkworm { static constexpr char kHexCharacters[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; static constexpr size_t kTokenSize{32 * 2}; // 32-bytes as hex chars static constexpr size_t kPrefixedTokenSize{2 + kTokenSize}; // "0x" + 32-bytes as hex chars std::string generate_jwt_token(const std::filesystem::path& file_path) { // Check input file path is not empty if (file_path.empty()) { const auto error_msg{"Empty JWT file path"}; SILK_ERROR << error_msg; throw std::runtime_error{error_msg}; } if (!std::filesystem::exists(file_path)) { std::filesystem::create_directories(file_path.parent_path()); } std::string jwt_token; jwt_token.reserve(kTokenSize); // Generate a random 32-bytes hex token (not including prefix) RandomNumber rnd{0, 15}; for (int i = 0; i < 64; ++i) { jwt_token += kHexCharacters[rnd.generate_one()]; } SILK_INFO << "JWT token written to file: " << file_path.string(); std::ofstream write_file{file_path}; write_file << "0x" << jwt_token; return hex_to_string(jwt_token); } std::string load_jwt_token(const std::filesystem::path& file_path) { // Check input file path is not empty if (file_path.empty()) { const auto error_msg{"Empty JWT file path"}; SILK_ERROR << error_msg; throw std::runtime_error{error_msg}; } // If the input file does not exist, make a new JWT token since we don't have one if (!std::filesystem::exists(file_path)) { return generate_jwt_token(file_path); } // Check input file has expected size const auto file_size = std::filesystem::file_size(file_path); if (file_size != kPrefixedTokenSize && file_size != kTokenSize) { const auto error_msg{"Unexpected JWT file size: " + std::to_string(file_size)}; SILK_ERROR << error_msg; throw std::runtime_error{error_msg}; } std::string jwt_token; jwt_token.reserve(kPrefixedTokenSize); // Read JWT token from input file strictly checking content size std::ifstream read_file{file_path}; read_file >> jwt_token; // Get rid of prefix if any if (jwt_token.starts_with("0x") || jwt_token.starts_with("0X")) { jwt_token = jwt_token.substr(2); } if (jwt_token.size() != kTokenSize) { const auto error_msg{"JWT token has wrong size: " + std::to_string(jwt_token.size())}; SILK_ERROR << error_msg; throw std::runtime_error{error_msg}; } read_file.close(); SILK_INFO << "JWT secret read from file: " << file_path.string(); return hex_to_string(jwt_token); } } // namespace silkworm ================================================ FILE: silkworm/rpc/http/jwt.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm { //! Generate a new JSON Web Token (JWT) secret std::string generate_jwt_token(const std::filesystem::path& file_path); //! Load a JWT secret token from provided file path. If the file doesn't contain the token then we generate one std::string load_jwt_token(const std::filesystem::path& file_path); } // namespace silkworm ================================================ FILE: silkworm/rpc/http/jwt_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "jwt.hpp" #include #include #include #include #include namespace silkworm { TEST_CASE("generate_jwt_token", "[silkworm][rpc][http][jwt]") { test_util::TemporaryFile tmp_jwt_file; SECTION("empty file path") { CHECK_THROWS_AS(generate_jwt_token(std::filesystem::path{""}), std::runtime_error); } static constexpr size_t kExpectedJwtTokenChars{32}; static constexpr size_t kExpectedJwtTokenHexSize{32 * 2 + 2}; // +2 for 0x SECTION("check generated JWT chars") { REQUIRE(std::filesystem::exists(tmp_jwt_file.path())); std::string jwt_token; CHECK_NOTHROW((jwt_token = generate_jwt_token(tmp_jwt_file.path()))); REQUIRE(std::filesystem::file_size(tmp_jwt_file.path()) == kExpectedJwtTokenHexSize); CHECK(jwt_token.size() == kExpectedJwtTokenChars); std::string jwt_token_hex; std::ifstream tmp_jwt_ifs{tmp_jwt_file.path()}; tmp_jwt_ifs >> jwt_token_hex; REQUIRE(jwt_token_hex.size() == kExpectedJwtTokenHexSize); jwt_token_hex = jwt_token_hex.substr(2); CHECK(jwt_token == test_util::ascii_from_hex(jwt_token_hex)); } SECTION("file path does not exist") { const auto jwt_parent_path = TemporaryDirectory::get_unique_temporary_path(); REQUIRE(!std::filesystem::exists(jwt_parent_path)); const auto jwt_file_path = jwt_parent_path / "jwt.hex"; REQUIRE(!std::filesystem::exists(jwt_file_path)); std::string jwt_token; CHECK_NOTHROW((jwt_token = generate_jwt_token(jwt_file_path))); REQUIRE(std::filesystem::exists(jwt_file_path)); REQUIRE(std::filesystem::file_size(jwt_file_path) == kExpectedJwtTokenHexSize); CHECK(jwt_token.size() == kExpectedJwtTokenChars); std::string jwt_token_hex; std::ifstream tmp_jwt_ifs{jwt_file_path}; tmp_jwt_ifs >> jwt_token_hex; REQUIRE(jwt_token_hex.size() == kExpectedJwtTokenHexSize); jwt_token_hex = jwt_token_hex.substr(2); CHECK(jwt_token == test_util::ascii_from_hex(jwt_token_hex)); } SECTION("file path contains . or ..") { const std::vector jwt_file_paths{ TemporaryDirectory::get_unique_temporary_path() / "../jwt.hex", TemporaryDirectory::get_unique_temporary_path() / "./jwt.hex"}; for (const auto& jwt_file_path : jwt_file_paths) { std::string jwt_token; CHECK_NOTHROW((jwt_token = generate_jwt_token(jwt_file_path))); REQUIRE(std::filesystem::exists(jwt_file_path)); } } } TEST_CASE("load_jwt_token", "[silkworm][rpc][http][jwt]") { test_util::TemporaryFile tmp_jwt_file; std::ofstream tmp_jwt_ofs{tmp_jwt_file.path()}; SECTION("empty file path") { CHECK_THROWS_AS(load_jwt_token(std::filesystem::path{""}), std::runtime_error); } SECTION("empty file") { tmp_jwt_ofs.close(); CHECK_THROWS_AS(load_jwt_token(tmp_jwt_file.path()), std::runtime_error); } const std::vector invalid_tokens{ "", "?=?", "d4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8", "d4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f", "d4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f4f", "d4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f4ff", "0x", "0x?=?", "0xd4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8", "0xd4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f", "0xd4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f4f", "0xd4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f4ff"}; for (const auto& token : invalid_tokens) { SECTION("invalid JWT file content: " + token) { tmp_jwt_ofs << token; tmp_jwt_ofs.close(); CHECK_THROWS_AS(load_jwt_token(tmp_jwt_file.path()), std::runtime_error); } } const std::vector valid_tokens{ "d4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f4", "0xd4414235d86b6d00ab77bb3eae739605aa9d4036b99bda915ecfb5e170cbf8f4", }; for (const auto& token : valid_tokens) { SECTION("valid JWT file content: " + token) { tmp_jwt_ofs << token; tmp_jwt_ofs.close(); CHECK_NOTHROW(load_jwt_token(tmp_jwt_file.path())); } } } } // namespace silkworm ================================================ FILE: silkworm/rpc/http/server.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server.hpp" #include #include #include #include #include #include #include #include namespace silkworm::rpc::http { #ifdef WIN32 using reuse_port = boost::asio::detail::socket_option::boolean; #else using reuse_port = boost::asio::detail::socket_option::boolean; #endif std::tuple Server::parse_endpoint(std::string_view tcp_end_point) { const auto host = tcp_end_point.substr(0, tcp_end_point.find(kAddressPortSeparator)); const auto port = tcp_end_point.substr(tcp_end_point.find(kAddressPortSeparator) + 1, std::string::npos); return {host, port}; } Server::Server(std::string_view end_point, RequestHandlerFactory&& handler_factory, boost::asio::io_context& ioc, WorkerPool& workers, std::vector allowed_origins, std::optional jwt_secret, bool use_websocket, bool ws_compression, bool http_compression, bool erigon_json_rpc_compatibility) : handler_factory_{std::move(handler_factory)}, acceptor_{ioc}, allowed_origins_{std::move(allowed_origins)}, jwt_secret_(std::move(jwt_secret)), use_websocket_{use_websocket}, ws_compression_{ws_compression}, http_compression_{http_compression}, workers_{workers}, erigon_json_rpc_compatibility_{erigon_json_rpc_compatibility} { const auto [host, port] = parse_endpoint(end_point); // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR). boost::asio::ip::tcp::resolver resolver{acceptor_.get_executor()}; boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(host, port).begin(); acceptor_.open(endpoint.protocol()); acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); acceptor_.set_option(reuse_port(true)); acceptor_.bind(endpoint); } void Server::start() { boost::asio::co_spawn(acceptor_.get_executor(), run(), [&](const std::exception_ptr& eptr) { if (eptr) std::rethrow_exception(eptr); }); } Task Server::run() { auto this_executor = co_await boost::asio::this_coro::executor; try { acceptor_.listen(); while (acceptor_.is_open()) { SILK_TRACE << "Server::run accepting using executor " << &this_executor << "..."; boost::asio::ip::tcp::socket socket{this_executor}; co_await acceptor_.async_accept(socket, boost::asio::use_awaitable); if (!acceptor_.is_open()) { SILK_TRACE << "Server::run returning..."; co_return; } SILK_TRACE << "Server::run accepted connection from " << socket.remote_endpoint(); auto new_connection = std::make_shared( std::move(socket), handler_factory_, allowed_origins_, jwt_secret_, use_websocket_, ws_compression_, http_compression_, workers_, erigon_json_rpc_compatibility_); boost::asio::co_spawn(this_executor, Connection::run_read_loop(new_connection), boost::asio::detached); } } catch (const boost::system::system_error& se) { if (se.code() != boost::asio::error::operation_aborted) { SILK_ERROR << "Server::run system_error: " << se.what(); std::rethrow_exception(std::make_exception_ptr(se)); } else { SILK_DEBUG << "Server::run operation_aborted: " << se.what(); } } catch (const std::exception& e) { SILK_ERROR << "Server::run exception: " << e.what(); std::rethrow_exception(std::make_exception_ptr(e)); } SILK_DEBUG << "Server::run exiting..."; } } // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/http/server.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::http { //! The top-level class of the HTTP server. class Server { public: Server(const Server&) = delete; Server& operator=(const Server&) = delete; // Construct the server to listen on the specified local TCP end-point Server(std::string_view end_point, RequestHandlerFactory&& handler_factory, boost::asio::io_context& ioc, WorkerPool& workers, std::vector allowed_origins, std::optional jwt_secret, bool use_websocket, bool ws_compression, bool http_compression, bool erigon_json_rpc_compatibility); void start(); private: static std::tuple parse_endpoint(std::string_view tcp_end_point); Task run(); //! The factory of RPC request handlers RequestHandlerFactory handler_factory_; //! The acceptor used to listen for incoming TCP connections boost::asio::ip::tcp::acceptor acceptor_; //! The list of allowed origins for CORS std::vector allowed_origins_; //! The JSON Web Token (JWT) secret for secure channel communication std::optional jwt_secret_; //! Flag indicating if WebSocket protocol will be used instead of HTTP bool use_websocket_; //! Flag indicating if WebSocket protocol compression will be used bool ws_compression_; //! Flag indicating if HTTP protocol compression will be used bool http_compression_; //! The configured workers WorkerPool& workers_; //! Flag indicating if JSON-RPC compatibility with Erigon is enabled or not bool erigon_json_rpc_compatibility_; }; } // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/http/zlib_compressor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc::http { inline constexpr int kZlibCompressionBufferSize = 65536; class ZlibCompressor { public: ZlibCompressor(const ZlibCompressor&) = delete; ZlibCompressor() { memset(&stream_, 0, sizeof(z_stream)); stream_.zalloc = Z_NULL; stream_.zfree = Z_NULL; stream_.opaque = Z_NULL; if (deflateInit2(&stream_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY) != Z_OK) { throw std::runtime_error("zlib initialization error"); } } ~ZlibCompressor() { deflateEnd(&stream_); } void compress_chunk(const std::string& clear_data, std::string& compressed_data, const bool flush) { stream_.next_in = const_cast(reinterpret_cast(clear_data.data())); stream_.avail_in = static_cast(clear_data.size()); size_t offset = 0; do { compressed_data.resize(kZlibCompressionBufferSize + offset); stream_.next_out = reinterpret_cast(compressed_data.data() + offset); stream_.avail_out = kZlibCompressionBufferSize; const int ret = deflate(&stream_, flush ? Z_FINISH : Z_NO_FLUSH); if (ret == Z_STREAM_ERROR) { throw std::runtime_error("zlib compression error"); } offset += kZlibCompressionBufferSize - stream_.avail_out; if (flush && ret == Z_STREAM_END) { break; } } while (stream_.avail_in > 0 || stream_.avail_out == 0); compressed_data.resize(offset); } private: z_stream stream_; }; } // namespace silkworm::rpc::http ================================================ FILE: silkworm/rpc/json/access_list_entry.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "access_list_entry.hpp" #include #include "types.hpp" namespace silkworm { void from_json(const nlohmann::json& json, AccessListEntry& entry) { entry.account = json.at("address").get(); entry.storage_keys = json.at("storageKeys").get>(); } void to_json(nlohmann::json& json, const AccessListEntry& access_list) { json["address"] = access_list.account; json["storageKeys"] = access_list.storage_keys; } } // namespace silkworm ================================================ FILE: silkworm/rpc/json/access_list_entry.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc { struct GlazeJsonAccessList { char address[kAddressHexSize]{}; std::vector storage_keys; struct glaze { using T = GlazeJsonAccessList; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "address", &T::address, "storageKeys", &T::storage_keys); }; }; } // namespace silkworm::rpc namespace silkworm { void from_json(const nlohmann::json& json, AccessListEntry& entry); void to_json(nlohmann::json& json, const AccessListEntry& access_list); } // namespace silkworm ================================================ FILE: silkworm/rpc/json/authorization.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "authorization.hpp" #include "types.hpp" namespace silkworm { void from_json(const nlohmann::json& json, Authorization& entry) { entry.chain_id = json.at("chainId").get(); entry.address = json.at("address").get(); entry.y_parity = json.at("yParity").get(); entry.r = json.at("r").get(); entry.s = json.at("s").get(); } void to_json(nlohmann::json& json, const Authorization& authorization) { json["chainId"] = rpc::to_quantity(authorization.chain_id); json["address"] = authorization.address; json["yParity"] = rpc::to_quantity(authorization.y_parity); json["r"] = rpc::to_quantity(authorization.r); json["s"] = rpc::to_quantity(authorization.s); } } // namespace silkworm ================================================ FILE: silkworm/rpc/json/authorization.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc { struct GlazeJsonAuthorization { char chain_id[kInt256HexSize]{}; char address[kAddressHexSize]{}; char y_parity[sizeof(uint8_t)]{}; char r[kInt256HexSize]{}; char s[kInt256HexSize]{}; std::vector storage_keys; struct glaze { using T = GlazeJsonAuthorization; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "chainId", &T::chain_id, "address", &T::address, "yParity", &T::y_parity, "r", &T::r, "s", &T::s); }; }; } // namespace silkworm::rpc namespace silkworm { void from_json(const nlohmann::json& json, Authorization& entry); void to_json(nlohmann::json& json, const Authorization& authorization); } // namespace silkworm ================================================ FILE: silkworm/rpc/json/block.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const Block& b) { auto& header = b.block_with_hash->block.header; const auto block_num = to_quantity(header.number); json["number"] = block_num; json["hash"] = b.block_with_hash->hash; json["parentHash"] = header.parent_hash; json["nonce"] = "0x" + silkworm::to_hex({header.nonce.data(), header.nonce.size()}); json["sha3Uncles"] = header.ommers_hash; json["logsBloom"] = "0x" + silkworm::to_hex(full_view(header.logs_bloom)); json["transactionsRoot"] = header.transactions_root; if (header.withdrawals_root) { json["withdrawalsRoot"] = *(header.withdrawals_root); } json["stateRoot"] = header.state_root; json["receiptsRoot"] = header.receipts_root; json["miner"] = header.beneficiary; json["difficulty"] = to_quantity(silkworm::endian::to_big_compact(header.difficulty)); json["extraData"] = "0x" + silkworm::to_hex(header.extra_data); json["mixHash"] = header.prev_randao; json["size"] = to_quantity(b.get_block_size()); json["gasLimit"] = to_quantity(header.gas_limit); json["gasUsed"] = to_quantity(header.gas_used); if (header.base_fee_per_gas.has_value()) { json["baseFeePerGas"] = to_quantity(header.base_fee_per_gas.value_or(0)); } json["timestamp"] = to_quantity(header.timestamp); if (b.full_tx) { json["transactions"] = b.block_with_hash->block.transactions; for (size_t i{0}; i < json["transactions"].size(); ++i) { auto& json_txn = json["transactions"][i]; json_txn["transactionIndex"] = to_quantity(i); json_txn["blockHash"] = b.block_with_hash->hash; json_txn["blockNumber"] = block_num; json_txn["gasPrice"] = to_quantity(b.block_with_hash->block.transactions[i].effective_gas_price(header.base_fee_per_gas.value_or(0))); } } else { std::vector transaction_hashes; transaction_hashes.reserve(b.block_with_hash->block.transactions.size()); for (size_t i{0}; i < b.block_with_hash->block.transactions.size(); ++i) { transaction_hashes.emplace(transaction_hashes.end(), b.block_with_hash->block.transactions[i].hash()); SILK_DEBUG << "transaction_hashes[" << i << "]: " << silkworm::to_hex({transaction_hashes[i].bytes, silkworm::kHashLength}); } json["transactions"] = transaction_hashes; } std::vector ommer_hashes; ommer_hashes.reserve(b.block_with_hash->block.ommers.size()); for (size_t i{0}; i < b.block_with_hash->block.ommers.size(); ++i) { ommer_hashes.emplace(ommer_hashes.end(), b.block_with_hash->block.ommers[i].hash()); SILK_DEBUG << "ommer_hashes[" << i << "]: " << silkworm::to_hex({ommer_hashes[i].bytes, silkworm::kHashLength}); } json["uncles"] = ommer_hashes; if (b.block_with_hash->block.withdrawals) { json["withdrawals"] = *(b.block_with_hash->block.withdrawals); } } struct GlazeJsonBlock { char block_num[kInt64HexSize]; char hash[kHashHexSize]; char parent_hash[kHashHexSize]; char nonce[kInt64HexSize]; char sha3_uncles[kHashHexSize]; char logs_bloom[kBloomSize]; char transactions_root[kHashHexSize]; char state_root[kHashHexSize]; char receipts_root[kHashHexSize]; char miner[kAddressHexSize]; char size[kInt64HexSize]; char gas_limit[kInt64HexSize]; char gas_used[kInt64HexSize]; char timestamp[kInt64HexSize]; char difficulty[kInt256HexSize]; char mix_hash[kHashHexSize]; char extra_data[kDataSize]; std::vector ommers_hashes; std::optional base_fee_per_gas; std::optional> transaction_hashes; std::optional> transactions; std::optional> withdrawals; std::optional withdrawals_root; std::optional blob_gas_used; std::optional excess_blob_gas; std::optional parent_beacon_block_root; std::optional requests_hash; struct glaze { using T = GlazeJsonBlock; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "number", &T::block_num, "hash", &T::hash, "parentHash", &T::parent_hash, "nonce", &T::nonce, "sha3Uncles", &T::sha3_uncles, "logsBloom", &T::logs_bloom, "transactionsRoot", &T::transactions_root, "withdrawalsRoot", &T::withdrawals_root, "stateRoot", &T::state_root, "receiptsRoot", &T::receipts_root, "miner", &T::miner, "size", &T::size, "gasLimit", &T::gas_limit, "blobGasUsed", &T::blob_gas_used, "excessBlobGas", &T::excess_blob_gas, "parentBeaconBlockRoot", &T::parent_beacon_block_root, "timestamp", &T::timestamp, "difficulty", &T::difficulty, "mixHash", &T::mix_hash, "extraData", &T::extra_data, "baseFeePerGas", &T::base_fee_per_gas, "gasUsed", &T::gas_used, "transactions", &T::transaction_hashes, "transactions", &T::transactions, "uncles", &T::ommers_hashes, "withdrawals", &T::withdrawals); }; }; struct GlazeJsonBlockReply { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; GlazeJsonBlock result; struct glaze { using T = GlazeJsonBlockReply; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "result", &T::result); }; }; struct GlazeJsonNullBlockReply { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; std::monostate result; struct glaze { using T = GlazeJsonNullBlockReply; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "result", &T::result); }; }; void make_glaze_json_null_content(const nlohmann::json& request_json, std::string& json_reply) { GlazeJsonNullBlockReply block_json_data{}; block_json_data.id = make_jsonrpc_id(request_json); glz::write(block_json_data, json_reply); } void make_glaze_json_content(const nlohmann::json& request_json, const Block& b, std::string& json_reply) { auto& block = b.block_with_hash->block; GlazeJsonBlockReply block_json_data{}; auto& header = block.header; auto& result = block_json_data.result; block_json_data.id = make_jsonrpc_id(request_json); to_quantity(std::span(result.block_num), header.number); to_hex(std::span(result.hash), b.block_with_hash->hash.bytes); to_hex(std::span(result.parent_hash), header.parent_hash.bytes); to_hex(std::span(result.nonce), header.nonce); to_hex(std::span(result.sha3_uncles), header.ommers_hash.bytes); to_hex(std::span(result.transactions_root), header.transactions_root.bytes); to_hex(std::span(result.logs_bloom), header.logs_bloom); if (header.withdrawals_root) { result.withdrawals_root = std::make_optional("0x" + silkworm::to_hex(*(header.withdrawals_root))); } if (header.blob_gas_used) { result.blob_gas_used = std::make_optional(to_quantity(*(header.blob_gas_used))); } if (header.excess_blob_gas) { result.excess_blob_gas = std::make_optional(to_quantity(*(header.excess_blob_gas))); } if (header.parent_beacon_block_root) { result.parent_beacon_block_root = std::make_optional("0x" + silkworm::to_hex(*(header.parent_beacon_block_root))); } if (header.requests_hash) { result.requests_hash = std::make_optional("0x" + silkworm::to_hex(*(header.requests_hash))); } to_hex(std::span(result.state_root), header.state_root.bytes); to_hex(std::span(result.receipts_root), header.receipts_root.bytes); to_hex(std::span(result.miner), header.beneficiary.bytes); to_quantity(std::span(result.size), b.get_block_size()); to_quantity(std::span(result.gas_limit), header.gas_limit); to_quantity(std::span(result.gas_used), header.gas_used); to_quantity(std::span(result.difficulty), header.difficulty); to_hex(std::span(result.mix_hash), header.prev_randao.bytes); to_hex(std::span(result.extra_data), header.extra_data); if (header.base_fee_per_gas.has_value()) { result.base_fee_per_gas = std::make_optional(to_quantity(header.base_fee_per_gas.value_or(0))); } to_quantity(std::span(result.timestamp), header.timestamp); if (b.full_tx) { std::vector transaction_data_list; transaction_data_list.reserve(block.transactions.size()); for (size_t i{0}; i < block.transactions.size(); ++i) { const silkworm::Transaction& transaction = block.transactions[i]; GlazeJsonTransaction item{}; to_quantity(std::span(item.transaction_index), i); to_quantity(std::span(item.block_num), header.number); to_hex(std::span(item.block_hash), b.block_with_hash->hash.bytes); to_quantity(std::span(item.gas_price), transaction.effective_gas_price(header.base_fee_per_gas.value_or(0))); make_glaze_json_transaction(transaction, item); transaction_data_list.push_back(std::move(item)); } result.transactions = make_optional(std::move(transaction_data_list)); } else { std::vector transaction_hashes; transaction_hashes.reserve(block.transactions.size()); for (const auto& transaction : block.transactions) { transaction_hashes.push_back("0x" + silkworm::to_hex(transaction.hash())); } result.transaction_hashes = std::make_optional(std::move(transaction_hashes)); } result.ommers_hashes.reserve(block.ommers.size()); for (const auto& ommer : block.ommers) { result.ommers_hashes.push_back("0x" + silkworm::to_hex(ommer.hash())); } if (block.withdrawals) { result.withdrawals = make_glaze_json_withdrawals(block); } glz::write_json(block_json_data, json_reply); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/block.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const Block& b); void make_glaze_json_content(const nlohmann::json& request_json, const Block& b, std::string& json_reply); void make_glaze_json_null_content(const nlohmann::json& request_json, std::string& json_reply); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/block_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include #include #include namespace silkworm::rpc { TEST_CASE("serialize block with baseFeePerGas", "[rpc][to_json]") { silkworm::BlockWithHash block_with_hash{ {/* Block */ { /* BlockBody */ .transactions = std::vector{}, .ommers = std::vector{}, .withdrawals = std::nullopt, }, { /* BlockHeader */ .parent_hash = 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32, .ommers_hash = 0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d_bytes32, .beneficiary = 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address, .state_root = 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d_bytes32, .transactions_root = 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e_bytes32, .receipts_root = 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f_bytes32, .logs_bloom = silkworm::Bloom{}, .difficulty = intx::uint256{0}, .number = BlockNum{5}, .gas_limit = uint64_t{1000000}, .gas_used = uint64_t{1000000}, .timestamp = uint64_t{5405021}, .extra_data = *silkworm::from_hex("0001FF0100"), .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .nonce = {0, 0, 0, 0, 0, 0, 0, 255}, .base_fee_per_gas = std::optional(0x244428), }}}; auto block_with_hash_shared = std::make_shared(); *block_with_hash_shared = block_with_hash; silkworm::rpc::Block rpc_block{block_with_hash_shared}; auto body = rpc_block.block_with_hash->block; body.transactions.resize(2); body.transactions[0].nonce = 172339; body.transactions[0].max_priority_fee_per_gas = 50 * kGiga; body.transactions[0].max_fee_per_gas = 50 * kGiga; body.transactions[0].gas_limit = 90'000; body.transactions[0].to = 0xe5ef458d37212a06e3f59d40c454e76150ae7c32_address; body.transactions[0].value = 1'027'501'080 * kGiga; body.transactions[0].data = {}; REQUIRE(body.transactions[0].set_v(27)); body.transactions[0].r = intx::from_string("0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353"); body.transactions[0].s = intx::from_string("0x1fffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804"); body.transactions[1].type = TransactionType::kDynamicFee; body.transactions[1].nonce = 1; body.transactions[1].max_priority_fee_per_gas = 5 * kGiga; body.transactions[1].max_fee_per_gas = 30 * kGiga; body.transactions[1].gas_limit = 1'000'000; body.transactions[1].to = {}; body.transactions[1].value = 0; body.transactions[1].data = *silkworm::from_hex("602a6000556101c960015560068060166000396000f3600035600055"); REQUIRE(body.transactions[1].set_v(37)); body.transactions[1].r = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); body.transactions[1].s = intx::from_string("0x52f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"); body.ommers.resize(1); body.ommers[0].parent_hash = 0xb397a22bb95bf14753ec174f02f99df3f0bdf70d1851cdff813ebf745f5aeb55_bytes32; body.ommers[0].ommers_hash = silkworm::kEmptyListHash; body.ommers[0].beneficiary = 0x0c729be7c39543c3d549282a40395299d987cec2_address; body.ommers[0].state_root = 0xc2bcdfd012534fa0b19ffba5fae6fc81edd390e9b7d5007d1e92e8e835286e9d_bytes32; body.ommers[0].transactions_root = silkworm::kEmptyRoot; body.ommers[0].receipts_root = silkworm::kEmptyRoot; body.ommers[0].difficulty = 12'555'442'155'599; body.ommers[0].number = 13'000'013; body.ommers[0].gas_limit = 3'141'592; body.ommers[0].gas_used = 0; body.ommers[0].timestamp = 1455404305; body.ommers[0].prev_randao = 0xf0a53dfdd6c2f2a661e718ef29092de60d81d45f84044bec7bf4b36630b2bc08_bytes32; body.ommers[0].nonce[7] = 35; nlohmann::json j = rpc_block; CHECK(j == R"({ "parentHash":"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c", "sha3Uncles":"0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d", "miner":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "stateRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d", "transactionsRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e", "receiptsRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f", "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "difficulty":"0x0", "number":"0x5", "hash": "0x0000000000000000000000000000000000000000000000000000000000000000", "gasLimit":"0xf4240", "gasUsed":"0xf4240", "timestamp":"0x52795d", "size":"0x207", "extraData":"0x0001ff0100", "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000001", "nonce":"0x00000000000000ff", "baseFeePerGas":"0x244428", "transactions":[], "uncles":[] })"_json); } TEST_CASE("serialize empty block", "[rpc][to_json]") { auto block_with_hash = std::make_shared(); silkworm::rpc::Block block{block_with_hash}; nlohmann::json j = block; CHECK(j == R"({ "parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000", "miner":"0x0000000000000000000000000000000000000000", "stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "difficulty":"0x0", "nonce":"0x0000000000000000", "number":"0x0", "gasLimit":"0x0", "gasUsed":"0x0", "timestamp":"0x0", "extraData":"0x", "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "hash":"0x0000000000000000000000000000000000000000000000000000000000000000", "size":"0x1f5", "transactions":[], "uncles":[] })"_json); } TEST_CASE("serialize EIP-2718 block", "[rpc][to_json]") { const char* rlp_hex{ "f90319f90211a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd4" "1ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ef1552a40b7165c3cd773806b9e0c165" "b75356e0314bf0706f279c729f51e017a0e6e49996c7ec59f7a23d22b83239a60151512c65613bf84a0d7da336399ebc4aa0cafe75574d" "59780665a97fbfd11365c7545aa8f1abf4e5e12e8243334ef7286bb9010000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000083020000820200832fefd882a410845506eb0796636f6f6c65737420626c6f636b206f6e20636861696ea0bd" "4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff49888a13a5a8c8f2bb1c4f90101f85f800a82c35094095e7bae" "a6a6c7c4c2dfeb977efac326af552d870a801ba09bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094fa08a8f" "ae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b1b89e01f89b01800a8301e24194095e7baea6a6c7c4c2dfeb97" "7efac326af552d878080f838f7940000000000000000000000000000000000000001e1a000000000000000000000000000000000000000" "0000000000000000000000000001a03dbacc8d0259f2508625e97fdfc57cd85fdd16e5821bc2c10bdd1a52649e8335a0476e10695b183a" "87b0aa292a7f4b78ef0c3fbe62aa2c42c84e1d9c3da159ef14c0"}; silkworm::Bytes rlp_bytes{*silkworm::from_hex(rlp_hex)}; silkworm::ByteView view{rlp_bytes}; auto block_with_hash = std::make_shared(); silkworm::rpc::Block rpc_block{block_with_hash}; REQUIRE(silkworm::rlp::decode(view, rpc_block.block_with_hash->block)); nlohmann::json rpc_block_json = rpc_block; CHECK(rpc_block_json == R"({ "difficulty":"0x20000", "extraData":"0x636f6f6c65737420626c6f636b206f6e20636861696e", "gasLimit":"0x2fefd8", "gasUsed":"0xa410", "hash":"0x0000000000000000000000000000000000000000000000000000000000000000", "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "miner":"0x8888f1f195afa192cfee860698584c030f4c9db1", "mixHash":"0xbd4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff498", "nonce":"0xa13a5a8c8f2bb1c4", "number":"0x200", "parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "receiptsRoot":"0xcafe75574d59780665a97fbfd11365c7545aa8f1abf4e5e12e8243334ef7286b", "sha3Uncles":"0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "size":"0x31c", "stateRoot":"0xef1552a40b7165c3cd773806b9e0c165b75356e0314bf0706f279c729f51e017", "timestamp":"0x5506eb07", "transactions":[ "0x77b19baa4de67e45a7b26e4a220bccdbb6731885aa9927064e239ca232023215", "0x554af720acf477830f996f1bc5d11e54c38aa40042aeac6f66cb66f9084a959d" ], "transactionsRoot":"0xe6e49996c7ec59f7a23d22b83239a60151512c65613bf84a0d7da336399ebc4a", "uncles":[] })"_json); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/cache_validation_result.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "cache_validation_result.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const CacheValidationResult& result) { json["requestCanceled"] = result.ref.request_canceled; json["enabled"] = result.ref.enabled; json["latestStateBehind"] = result.ref.latest_state_behind; json["cacheCleared"] = result.ref.cache_cleared; json["latestStateID"] = result.ref.latest_state_version_id; json["stateKeysOutOfSync"] = result.ref.state_keys_out_of_sync; json["codeKeysOutOfSync"] = result.ref.code_keys_out_of_sync; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/cache_validation_result.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "../types/cache_validation_result.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const CacheValidationResult& result); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/call.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call.hpp" #include #include #include #include #include namespace silkworm::rpc { void from_json(const nlohmann::json& json, Call& call) { if (json.count("from") != 0) { call.from = json.at("from").get(); } if (json.count("to") != 0) { const auto& to = json.at("to"); if (!to.is_null()) { call.to = json.at("to").get(); } } if (json.count("nonce") != 0) { const auto& json_nonce = json.at("nonce"); if (json_nonce.is_string()) { call.nonce = std::stol(json_nonce.get(), nullptr, 16); } else { call.nonce = json_nonce.get(); } } if (json.count("gas") != 0) { const auto& json_gas = json.at("gas"); if (json_gas.is_string()) { call.gas = std::stol(json_gas.get(), nullptr, 16); } else { call.gas = json_gas.get(); } } if (json.count("gasPrice") != 0) { call.gas_price = json.at("gasPrice").get(); } if (json.count("maxFeePerGas") != 0) { call.max_fee_per_gas = json.at("maxFeePerGas").get(); } if (json.count("maxPriorityFeePerGas") != 0) { call.max_priority_fee_per_gas = json.at("maxPriorityFeePerGas").get(); } if (json.count("value") != 0) { call.value = json.at("value").get(); } // backward compatibility: both `data` and `input` fields are accepted as input if (json.count("data") != 0) { const auto json_data = json.at("data").get(); call.data = silkworm::from_hex(json_data); } if (json.count("input") != 0) { const auto json_data = json.at("input").get(); call.data = silkworm::from_hex(json_data); } if (json.count("accessList") != 0) { call.access_list = json.at("accessList").get(); } } struct GlazeJsonCall { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; char result[2048]; struct glaze { using T = GlazeJsonCall; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "result", &T::result); }; }; struct GlazeJsonCallResultAsString { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; std::string result; struct glaze { using T = GlazeJsonCallResultAsString; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "result", &T::result); }; }; void make_glaze_json_content(const nlohmann::json& request_json, const silkworm::Bytes& call_result, std::string& json_reply) { if (call_result.size() * 2 + 2 + 1 > kEthCallResultFixedSize) { GlazeJsonCallResultAsString log_json_data{}; log_json_data.result.reserve(call_result.size() * 2 + 2); log_json_data.id = make_jsonrpc_id(request_json); log_json_data.result = "0x" + silkworm::to_hex(call_result); glz::write_json(std::move(log_json_data), json_reply); } else { GlazeJsonCall log_json_data{}; log_json_data.id = make_jsonrpc_id(request_json); to_hex(log_json_data.result, call_result); glz::write_json(std::move(log_json_data), json_reply); } } void from_json(const nlohmann::json& json, Bundle& call) { call.transactions = json.at("transactions").get>(); if (json.contains("blockOverride")) { call.block_override = json["blockOverride"].get(); } } void from_json(const nlohmann::json& json, SimulationContext& sc) { sc.block_num = json["blockNumber"].get(); if (json.contains("transactionIndex")) { sc.transaction_index = json["transactionIndex"].get(); } } void from_json(const nlohmann::json& json, AccountOverrides& ao) { if (json.contains("balance")) { ao.balance = json["balance"].get(); } if (json.count("nonce") != 0) { const auto& json_nonce = json.at("nonce"); if (json_nonce.is_string()) { ao.nonce = std::stol(json_nonce.get(), nullptr, 16); } else { ao.nonce = json_nonce.get(); } } if (json.contains("code")) { const auto json_data = json.at("code").get(); ao.code = silkworm::from_hex(json_data); ao.code_hash = std::bit_cast(keccak256(ao.code.value())); } if (json.contains("state")) { const auto& state = json["state"]; auto ss = state.get>(); for (const auto& entry : ss) { auto b32 = bytes32_from_hex(entry.first); auto u256 = intx::from_string(entry.second); ao.state.emplace(b32, u256); } } if (json.contains("stateDiff")) { const auto& state = json["stateDiff"]; auto ss = state.get>(); for (const auto& entry : ss) { auto b32 = bytes32_from_hex(entry.first); auto u256 = intx::from_string(entry.second); ao.state_diff.emplace(b32, u256); } } } void from_json(const nlohmann::json& json, BlockOverrides& bo) { if (json.contains("blockNumber")) { const auto& block_num_json = json["blockNumber"]; if (block_num_json.is_string()) { bo.block_num = std::stoull(block_num_json.get(), nullptr, /*base=*/16); } else { bo.block_num = block_num_json.get(); } } if (json.contains("coinbase")) { bo.coin_base = json["coinbase"].get(); } if (json.contains("timestamp")) { bo.timestamp = json["timestamp"].get(); } if (json.contains("difficulty")) { bo.difficulty = json["difficulty"].get(); } if (json.contains("gasLimit")) { const auto& gas_limit_json = json["gasLimit"]; if (gas_limit_json.is_string()) { bo.gas_limit = std::stoull(gas_limit_json.get(), nullptr, /*base=*/16); } else { bo.gas_limit = gas_limit_json.get(); } } if (json.contains("baseFee")) { const auto& base_fee_json = json["baseFee"]; if (base_fee_json.is_string()) { bo.base_fee = std::stoull(base_fee_json.get(), nullptr, /*base=*/16); } else { bo.base_fee = base_fee_json.get(); } } } void from_json(const nlohmann::json& json, AccountsOverrides& accounts_overrides) { for (const auto& el : json.items()) { const auto key = hex_to_address(el.key(), /*return_zero_on_err=*/true); const auto value = el.value().get(); accounts_overrides.emplace(key, value); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void from_json(const nlohmann::json&, Call&); void from_json(const nlohmann::json&, Bundle&); void from_json(const nlohmann::json&, SimulationContext&); void from_json(const nlohmann::json&, AccountOverrides&); void from_json(const nlohmann::json&, BlockOverrides&); void from_json(const nlohmann::json&, AccountsOverrides&); void make_glaze_json_content(const nlohmann::json& request_json, const silkworm::Bytes& call_result, std::string& json_reply); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/call_bundle.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call_bundle.hpp" #include #include #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const struct CallBundleTxInfo& tx_info) { json["gasUsed"] = tx_info.gas_used; json["txHash"] = silkworm::to_bytes32({tx_info.hash.bytes, silkworm::kHashLength}); if (!tx_info.error_message.empty()) json["error"] = tx_info.error_message; else json["value"] = silkworm::to_bytes32({tx_info.value.bytes, silkworm::kHashLength}); } void to_json(nlohmann::json& json, const struct CallBundleInfo& bundle_info) { json["bundleHash"] = silkworm::to_bytes32({bundle_info.bundle_hash.bytes, silkworm::kHashLength}); json["results"] = bundle_info.txs_info; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/call_bundle.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const struct CallBundleTxInfo& tx_info); void to_json(nlohmann::json& json, const struct CallBundleInfo& bundle_info); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/call_bundle_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call_bundle.hpp" #include #include #include namespace silkworm::rpc { TEST_CASE("serialize empty call_bundle", "[rpc][to_json]") { struct CallBundleInfo bundle_info {}; nlohmann::json j = bundle_info; CHECK(j == R"({ "bundleHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "results":[] })"_json); } TEST_CASE("serialize call_bundle with error", "[rpc][to_json]") { struct CallBundleInfo bundle_info {}; struct CallBundleTxInfo tx_info {}; tx_info.gas_used = 0x234; tx_info.error_message = "operation reverted"; bundle_info.txs_info.push_back(tx_info); nlohmann::json j = bundle_info; CHECK(j == R"({ "bundleHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "results":[{"error": "operation reverted", "gasUsed": 564, "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000"}] })"_json); } TEST_CASE("serialize call_bundle with value", "[rpc][to_json]") { struct CallBundleInfo bundle_info {}; struct CallBundleTxInfo tx_info {}; tx_info.gas_used = 0x234; tx_info.value = 0x1230000000000000000000000000000000000000000000000000000000000321_bytes32; bundle_info.txs_info.push_back(tx_info); nlohmann::json j = bundle_info; CHECK(j == R"({ "bundleHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "results":[{"value": "0x1230000000000000000000000000000000000000000000000000000000000321", "gasUsed": 564, "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000"}] })"_json); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/call_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call.hpp" #include #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("deserialize null call", "[silkworm::json][from_json]") { auto j1 = R"({})"_json; CHECK_NOTHROW(j1.get()); } TEST_CASE("deserialize minimal call", "[silkworm::json][from_json]") { auto j1 = R"({ "to": "0x0715a7794a1dc8e42615f059dd6e406a6594651a" })"_json; auto c1 = j1.get(); CHECK(c1.from == std::nullopt); CHECK(c1.to == evmc::address{0x0715a7794a1dc8e42615f059dd6e406a6594651a_address}); CHECK(c1.gas == std::nullopt); CHECK(c1.gas_price == std::nullopt); CHECK(c1.max_priority_fee_per_gas == std::nullopt); CHECK(c1.max_fee_per_gas == std::nullopt); CHECK(c1.value == std::nullopt); CHECK(c1.data == std::nullopt); CHECK(c1.nonce == std::nullopt); CHECK(c1.access_list.empty()); } TEST_CASE("deserialize full call", "[silkworm::json][from_json]") { auto j1 = R"({ "from": "0x52c24586c31cff0485a6208bb63859290fba5bce", "to": "0x0715a7794a1dc8e42615f059dd6e406a6594651a", "gas": "0xF4240", "gasPrice": "0x10C388C00", "value": "0x10C388C00", "nonce": "0x1", "data": "0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000", "accessList":[ { "address":"0x52c24586c31cff0485a6208bb63859290fba5bce", "storageKeys":["0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c"] }, { "address": "0x62c24586c31cff0485a6208bb63859290fba5bce", "storageKeys":[] } ] })"_json; auto c1 = j1.get(); CHECK(c1.from == 0x52c24586c31cff0485a6208bb63859290fba5bce_address); CHECK(c1.to == 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address); CHECK(c1.gas == intx::uint256{1000000}); CHECK(c1.gas_price == intx::uint256{4499999744}); CHECK(c1.value == intx::uint256{4499999744}); CHECK(c1.data == silkworm::from_hex("0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000")); CHECK(c1.nonce == intx::uint256{1}); CHECK(c1.access_list.size() == 2); auto j2 = R"({ "from":"0x52c24586c31cff0485a6208bb63859290fba5bce", "to":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "gas":1000000, "gasPrice":"0x10C388C00", "data":"0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000", "value":"0x124F80", "nonce": 1 })"_json; auto c2 = j2.get(); CHECK(c2.from == 0x52c24586c31cff0485a6208bb63859290fba5bce_address); CHECK(c2.to == 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address); CHECK(c2.gas == intx::uint256{1000000}); CHECK(c2.gas_price == intx::uint256{4499999744}); CHECK(c2.data == silkworm::from_hex("0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000")); CHECK(c2.value == intx::uint256{1200000}); CHECK(c2.nonce == intx::uint256{1}); auto j3 = R"({ "from":"0x52c24586c31cff0485a6208bb63859290fba5bce", "to":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "gas":1000000, "gasPrice":"0x10C388C00", "input":"0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000", "value":"0x124F80", "nonce": 1 })"_json; auto c3 = j3.get(); CHECK(c3.from == 0x52c24586c31cff0485a6208bb63859290fba5bce_address); CHECK(c3.to == 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address); CHECK(c3.gas == intx::uint256{1000000}); CHECK(c3.gas_price == intx::uint256{4499999744}); CHECK(c3.data == silkworm::from_hex("0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000")); CHECK(c3.value == intx::uint256{1200000}); CHECK(c3.nonce == intx::uint256{1}); } TEST_CASE("make glaze content (data)", "[make_glaze_json_error]") { std::string json; const char* data_hex{"c68341b58302d066"}; silkworm::Bytes data_bytes{*silkworm::from_hex(data_hex)}; make_glaze_json_content(1, data_bytes, json); CHECK(strcmp(json.c_str(), "{\"jsonrpc\":\"2.0\",\ \"id\":1,\ \"result\":\"0xc68341b58302d066\"}")); } TEST_CASE("Bundle", "[silkworm::json][from_json]") { SECTION("Only 1 transaction") { auto json = R"({ "transactions": [ { "from":"0x52c24586c31cff0485a6208bb63859290fba5bce", "to":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "gas":1000000, "gasPrice":"0x10C388C00", "data":"0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000", "value":"0x124F80", "nonce": 1 } ] })"_json; auto bundle = json.get(); CHECK(bundle.transactions.size() == 1); auto& call = bundle.transactions[0]; CHECK(call.from == evmc::address{0x52c24586c31cff0485a6208bb63859290fba5bce_address}); CHECK(call.to == evmc::address{0x0715a7794a1dc8e42615f059dd6e406a6594651a_address}); CHECK(call.gas == intx::uint256{1000000}); CHECK(call.gas_price == intx::uint256{4499999744}); CHECK(call.data == silkworm::from_hex("0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000")); CHECK(call.value == intx::uint256{1200000}); CHECK(call.nonce == intx::uint256{1}); auto& bo = bundle.block_override; CHECK(bo.block_num == std::nullopt); CHECK(bo.coin_base == std::nullopt); CHECK(bo.timestamp == std::nullopt); CHECK(bo.difficulty == std::nullopt); CHECK(bo.gas_limit == std::nullopt); CHECK(bo.base_fee == std::nullopt); } SECTION("2 transaction") { auto json = R"({ "transactions": [ { "from":"0x52c24586c31cff0485a6208bb63859290fba5bce" }, { "from":"0x52c24586c31cff0485a6208bb63859290fba5baa" } ] })"_json; auto bundle = json.get(); CHECK(bundle.transactions.size() == 2); CHECK(bundle.transactions[0].from == evmc::address{0x52c24586c31cff0485a6208bb63859290fba5bce_address}); CHECK(bundle.transactions[1].from == evmc::address{0x52c24586c31cff0485a6208bb63859290fba5baa_address}); } SECTION("Simple transaction and block overrides") { auto json = R"({ "transactions": [ { "from":"0x52c24586c31cff0485a6208bb63859290fba5bce" } ], "blockOverride": { "blockNumber": 10, "coinbase": "0x52c24586c31cff0485a6208bb63859290fba5baa", "timestamp": 1000, "difficulty": "0x1000000", "gasLimit": 3, "baseFee": 4 } })"_json; auto bundle = json.get(); CHECK(bundle.transactions.size() == 1); auto& call = bundle.transactions[0]; CHECK(call.from == evmc::address{0x52c24586c31cff0485a6208bb63859290fba5bce_address}); auto& bo = bundle.block_override; CHECK(bo.block_num == 10); CHECK(bo.coin_base == evmc::address{0x52c24586c31cff0485a6208bb63859290fba5baa_address}); CHECK(bo.timestamp == 1000); CHECK(bo.difficulty == intx::uint256{16777216}); CHECK(bo.gas_limit == 3); CHECK(bo.base_fee == 4); } } TEST_CASE("AccountOverrides", "[silkworm::json][from_json]") { SECTION("Empty account overrides") { auto json = R"({ })"_json; auto state = json.get(); CHECK(state.balance.has_value() == false); CHECK(state.nonce.has_value() == false); CHECK(state.code.has_value() == false); CHECK(state.state.empty()); CHECK(state.state_diff.empty()); } SECTION("Full account overrides") { auto json = R"({ "balance": "0x1000000", "nonce": 10, "code": "0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000" })"_json; auto state = json.get(); CHECK(state.balance.has_value() == true); CHECK(state.balance.value() == intx::uint256{16777216}); CHECK(state.nonce.has_value() == true); CHECK(state.nonce.value() == 10); CHECK(state.code.has_value() == true); CHECK(state.code.value() == silkworm::from_hex("0xdaa6d5560000000000000000000000000000000000000000000000000000000000000000")); CHECK(state.state.empty()); CHECK(state.state_diff.empty()); } SECTION("Account overrides with states") { auto json = R"({ "state": { "0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6": "0x1000000" }, "stateDiff": { "0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6": "0x1000000" } })"_json; auto state = json.get(); CHECK(state.balance.has_value() == false); CHECK(state.nonce.has_value() == false); CHECK(state.code.has_value() == false); CHECK(state.state.size() == 1); CHECK(state.state[0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32] == intx::uint256{16777216}); CHECK(state.state_diff.size() == 1); CHECK(state.state_diff[0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32] == intx::uint256{16777216}); } } TEST_CASE("SimulationContext", "[silkworm::json][from_json]") { SECTION("Only block number") { auto json = R"({ "blockNumber": 1000 })"_json; auto context = json.get(); CHECK(context.block_num.is_number()); CHECK(context.block_num.number() == 1000); CHECK(context.transaction_index == -1); } SECTION("Block number and tx index") { auto json = R"({ "blockNumber": 1000, "transactionIndex": 5 })"_json; auto context = json.get(); CHECK(context.block_num.is_number()); CHECK(context.block_num.number() == 1000); CHECK(context.transaction_index == 5); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/client_version.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "client_version.hpp" #include #include #include #include namespace silkworm::rpc { //! Commit hash length is hard-coded at 4-bytes hex by spec inline constexpr size_t kCommitSize = 4 * 2; //! ClientVersionV1 as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/identification.md#clientversionv1 struct ClientVersionV1 { // NOLINTBEGIN(readability-identifier-naming) static constexpr std::string_view code{"SW"}; // never-changing value, hard-coded for efficiency static constexpr std::string_view name{"silkworm"}; // never-changing value, hard-coded for efficiency // NOLINTEND(readability-identifier-naming) std::string_view version; std::string_view commit; struct glaze { using T = ClientVersionV1; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "code", &T::code, "name", &T::name, "version", &T::version, "commit", &T::commit); }; }; struct ClientVersionV1Reply { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; std::array result; // array with just 1 element for any EL client (multiplexers may have many) struct glaze { using T = ClientVersionV1Reply; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "result", &T::result); }; }; void make_glaze_json_content(const nlohmann::json& request_json, const ApplicationInfo& build_info, std::string& json_reply) { ClientVersionV1Reply reply{ .id = make_jsonrpc_id(request_json), .result = {ClientVersionV1{ .version = build_info.version, .commit = build_info.commit_hash.substr(0, kCommitSize), }}, }; glz::write_json(std::move(reply), json_reply); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/client_version.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void make_glaze_json_content(const nlohmann::json& request_json, const ApplicationInfo& build_info, std::string& json_reply); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/execution_payload.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include "filter.hpp" #include "types.hpp" #include "withdrawal.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const ExecutionPayload& execution_payload) { nlohmann::json transaction_list; for (const auto& transaction : execution_payload.transactions) { transaction_list.push_back("0x" + silkworm::to_hex(transaction)); } json["parentHash"] = execution_payload.parent_hash; json["feeRecipient"] = execution_payload.suggested_fee_recipient; json["stateRoot"] = execution_payload.state_root; json["receiptsRoot"] = execution_payload.receipts_root; json["logsBloom"] = "0x" + silkworm::to_hex(execution_payload.logs_bloom); json["prevRandao"] = execution_payload.prev_randao; json["blockNumber"] = to_quantity(execution_payload.block_num); json["gasLimit"] = to_quantity(execution_payload.gas_limit); json["gasUsed"] = to_quantity(execution_payload.gas_used); json["timestamp"] = to_quantity(execution_payload.timestamp); json["extraData"] = "0x" + silkworm::to_hex(execution_payload.extra_data); json["baseFeePerGas"] = to_quantity(execution_payload.base_fee); json["blockHash"] = execution_payload.block_hash; json["transactions"] = transaction_list; if (execution_payload.withdrawals) { json["withdrawals"] = execution_payload.withdrawals.value(); } if (execution_payload.blob_gas_used) { json["blobGasUsed"] = to_quantity(*execution_payload.blob_gas_used); } if (execution_payload.excess_blob_gas) { json["excessBlobGas"] = to_quantity(*execution_payload.excess_blob_gas); } } void from_json(const nlohmann::json& json, ExecutionPayload& execution_payload) { // Parse logs bloom silkworm::Bloom logs_bloom; std::memcpy(&logs_bloom[0], silkworm::from_hex(json.at("logsBloom").get())->data(), silkworm::kBloomByteLength); // Parse transactions std::vector transactions; for (const auto& hex_transaction : json.at("transactions")) { const auto hex_bytes{from_hex(hex_transaction.get())}; if (hex_bytes) { transactions.push_back(*hex_bytes); } else { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "ExecutionPayload: invalid hex transaction: " + hex_transaction.dump()}; } } // Optionally parse V2 fields std::optional> withdrawals; if (json.contains("withdrawals")) { withdrawals = json.at("withdrawals").get>(); } // Optional parse V3 fields std::optional blob_gas_used; if (json.contains("blobGasUsed")) { blob_gas_used = from_quantity(json.at("blobGasUsed").get()); } std::optional excess_blob_gas; if (json.contains("excessBlobGas")) { excess_blob_gas = from_quantity(json.at("excessBlobGas").get()); } execution_payload = ExecutionPayload{ .block_num = from_quantity(json.at("blockNumber").get()), .timestamp = from_quantity(json.at("timestamp").get()), .gas_limit = from_quantity(json.at("gasLimit").get()), .gas_used = from_quantity(json.at("gasUsed").get()), .suggested_fee_recipient = json.at("feeRecipient").get(), .state_root = json.at("stateRoot").get(), .receipts_root = json.at("receiptsRoot").get(), .parent_hash = json.at("parentHash").get(), .block_hash = json.at("blockHash").get(), .prev_randao = json.at("prevRandao").get(), .base_fee = json.at("baseFeePerGas").get(), .logs_bloom = logs_bloom, .extra_data = *silkworm::from_hex(json.at("extraData").get()), .transactions = transactions, .withdrawals = std::move(withdrawals), .blob_gas_used = blob_gas_used, .excess_blob_gas = excess_blob_gas, }; // Set the ExecutionPayload version (default is V1) SILKWORM_ASSERT(execution_payload.version == ExecutionPayload::kV1); if (execution_payload.withdrawals) { if (execution_payload.blob_gas_used.has_value() != execution_payload.excess_blob_gas.has_value()) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "ExecutionPayload: invalid V3 payload, missing " + std::string{execution_payload.blob_gas_used ? "excess_blob_gas" : "blob_gas_used"}}; } if (execution_payload.blob_gas_used && execution_payload.excess_blob_gas) { execution_payload.version = ExecutionPayload::kV3; } else { execution_payload.version = ExecutionPayload::kV2; } } else { if (execution_payload.blob_gas_used || execution_payload.excess_blob_gas) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "ExecutionPayload: invalid V3 payload, missing withdrawals"}; } } } void to_json(nlohmann::json& json, const ExecutionPayloadAndValue& reply) { json["executionPayload"] = reply.payload; json["blockValue"] = to_quantity(reply.block_value); } void to_json(nlohmann::json& json, const ExecutionPayloadBody& body) { if (!body.transactions) { json = nlohmann::json::value_t::null; return; } nlohmann::json transaction_list; for (const auto& transaction : *body.transactions) { transaction_list.push_back("0x" + silkworm::to_hex(transaction)); } json["transactions"] = transaction_list; if (body.withdrawals) { json["withdrawals"] = body.withdrawals.value(); } else { json["withdrawals"] = nlohmann::json::value_t::null; } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/execution_payload.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const ExecutionPayload& execution_payload); void from_json(const nlohmann::json& json, ExecutionPayload& execution_payload); void to_json(nlohmann::json& json, const ExecutionPayloadAndValue& reply); void to_json(nlohmann::json& json, const ExecutionPayloadBody& body); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/execution_payload_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "execution_payload.hpp" #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("serialize ExecutionPayloadV1", "[silkworm][rpc][json]") { ExecutionPayload payload_v1{ .version = ExecutionPayload::kV1, .block_num = 0x1, .timestamp = 0x5, .gas_limit = 0x1c9c380, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .state_root = 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32, .receipts_root = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32, .parent_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .base_fee = 0x7, .transactions = {*silkworm::from_hex("0xf92ebdeab45d368f6354e8c5a8ac586c")}, }; CHECK(nlohmann::json(payload_v1) == R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"] })"_json); } TEST_CASE("deserialize ExecutionPayloadV1", "[silkworm][rpc][json]") { ExecutionPayload payload = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"] })"_json; CHECK(payload.version == ExecutionPayload::kV1); CHECK(payload.parent_hash == 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32); CHECK(payload.suggested_fee_recipient == 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address); CHECK(payload.state_root == 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32); CHECK(payload.receipts_root == 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32); CHECK(payload.prev_randao == 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32); CHECK(payload.block_num == 0x1); CHECK(payload.gas_limit == 0x1c9c380); CHECK(payload.timestamp == 0x5); CHECK(payload.base_fee == 0x7); CHECK(payload.block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(payload.transactions == std::vector{{0xf9, 0x2e, 0xbd, 0xea, 0xb4, 0x5d, 0x36, 0x8f, 0x63, 0x54, 0xe8, 0xc5, 0xa8, 0xac, 0x58, 0x6c}}); CHECK(payload.withdrawals == std::nullopt); } TEST_CASE("serialize ExecutionPayloadV2", "[silkworm][rpc][json]") { ExecutionPayload payload_v2{ .version = ExecutionPayload::kV2, .block_num = 0x1, .timestamp = 0x5, .gas_limit = 0x1c9c380, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .state_root = 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32, .receipts_root = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32, .parent_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .base_fee = 0x7, .transactions = {*silkworm::from_hex("0xf92ebdeab45d368f6354e8c5a8ac586c")}, .withdrawals = std::vector{}, }; SECTION("empty withdrawals") { CHECK(nlohmann::json(payload_v2) == R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[] })"_json); } SECTION("non-empty withdrawals") { payload_v2.withdrawals = std::vector{ {.index = 6, .validator_index = 12, .address = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .amount = 10'000}, }; CHECK(nlohmann::json(payload_v2) == R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[{"address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","amount":"0x2710","index":"0x6","validatorIndex":"0xc"}] })"_json); } } TEST_CASE("deserialize ExecutionPayloadV2", "[silkworm][rpc][json]") { SECTION("empty withdrawals") { ExecutionPayload payload = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[] })"_json; CHECK(payload.version == ExecutionPayload::kV2); CHECK(payload.parent_hash == 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32); CHECK(payload.suggested_fee_recipient == 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address); CHECK(payload.state_root == 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32); CHECK(payload.receipts_root == 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32); CHECK(payload.prev_randao == 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32); CHECK(payload.block_num == 0x1); CHECK(payload.gas_limit == 0x1c9c380); CHECK(payload.timestamp == 0x5); CHECK(payload.base_fee == 0x7); CHECK(payload.block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(payload.transactions == std::vector{{0xf9, 0x2e, 0xbd, 0xea, 0xb4, 0x5d, 0x36, 0x8f, 0x63, 0x54, 0xe8, 0xc5, 0xa8, 0xac, 0x58, 0x6c}}); CHECK(payload.withdrawals == std::vector{}); } SECTION("non-empty withdrawals") { ExecutionPayload payload = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[{"address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","amount":"0x2710","index":"0x6","validatorIndex":"0xc"}] })"_json; CHECK(payload.version == ExecutionPayload::kV2); CHECK(payload.parent_hash == 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32); CHECK(payload.suggested_fee_recipient == 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address); CHECK(payload.state_root == 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32); CHECK(payload.receipts_root == 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32); CHECK(payload.prev_randao == 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32); CHECK(payload.block_num == 0x1); CHECK(payload.gas_limit == 0x1c9c380); CHECK(payload.timestamp == 0x5); CHECK(payload.base_fee == 0x7); CHECK(payload.block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(payload.transactions == std::vector{{0xf9, 0x2e, 0xbd, 0xea, 0xb4, 0x5d, 0x36, 0x8f, 0x63, 0x54, 0xe8, 0xc5, 0xa8, 0xac, 0x58, 0x6c}}); CHECK(payload.withdrawals == std::vector{ {.index = 6, .validator_index = 12, .address = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .amount = 10'000}, }); } SECTION("invalid hex transaction") { const nlohmann::json json = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["xyz"], "withdrawals":[{"address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","amount":"0x2710","index":"0x6","validatorIndex":"0xc"}] })"_json; ExecutionPayload payload; CHECK_THROWS_AS(from_json(json, payload), std::system_error); } } TEST_CASE("serialize ExecutionPayloadAndValue", "[silkworm][rpc][json]") { ExecutionPayload payload_v1{ .version = ExecutionPayload::kV1, .block_num = 0x1, .timestamp = 0x5, .gas_limit = 0x1c9c380, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .state_root = 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32, .receipts_root = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32, .parent_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .base_fee = 0x7, .transactions = {*silkworm::from_hex("0xf92ebdeab45d368f6354e8c5a8ac586c")}, }; ExecutionPayloadAndValue payload_and_value{payload_v1, 4'000'000}; CHECK(nlohmann::json(payload_and_value) == R"({ "executionPayload":{ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"] }, "blockValue":"0x3d0900" })"_json); } TEST_CASE("serialize ExecutionPayloadBody", "[silkworm][rpc][json]") { ExecutionPayloadBody payload_body{ .transactions = std::vector{*silkworm::from_hex("0xf92ebdeab45d368f6354e8c5a8ac586c")}, .withdrawals = std::vector{ {.index = 6, .validator_index = 12, .address = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .amount = 10'000}, }}; CHECK(nlohmann::json(payload_body) == R"({ "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[{"address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","amount":"0x2710","index":"0x6","validatorIndex":"0xc"}] })"_json); } TEST_CASE("serialize ExecutionPayloadV3", "[silkworm][rpc][json]") { ExecutionPayload payload_v3{ .version = ExecutionPayload::kV3, .block_num = 0x1, .timestamp = 0x5, .gas_limit = 0x1c9c380, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .state_root = 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32, .receipts_root = 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32, .parent_hash = 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32, .block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .prev_randao = 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, .base_fee = 0x7, .transactions = {*silkworm::from_hex("0xf92ebdeab45d368f6354e8c5a8ac586c")}, .withdrawals = std::vector{}, }; SECTION("missing blob_gas_used and excess_blob_gas") { CHECK(nlohmann::json(payload_v3) == R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[] })"_json); } SECTION("missing blob_gas_used") { payload_v3.excess_blob_gas = 0x1000; CHECK(nlohmann::json(payload_v3) == R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[], "excessBlobGas":"0x1000" })"_json); } SECTION("missing excess_blob_gas") { payload_v3.blob_gas_used = 0x1000; CHECK(nlohmann::json(payload_v3) == R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[], "blobGasUsed":"0x1000" })"_json); } SECTION("both blob_gas_used and excess_blob_gas present") { payload_v3.withdrawals = std::vector{ {.index = 6, .validator_index = 12, .address = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .amount = 10'000}, }; payload_v3.blob_gas_used = 0x1000; payload_v3.excess_blob_gas = 0x1000; CHECK(nlohmann::json(payload_v3) == R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[{"address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","amount":"0x2710","index":"0x6","validatorIndex":"0xc"}], "blobGasUsed":"0x1000", "excessBlobGas":"0x1000" })"_json); } } TEST_CASE("deserialize ExecutionPayloadV3", "[silkworm][rpc][json]") { SECTION("both blob_gas_used and excess_blob_gas present") { ExecutionPayload payload = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[], "blobGasUsed":"0x1000", "excessBlobGas":"0x0100" })"_json; CHECK(payload.version == ExecutionPayload::kV3); CHECK(payload.parent_hash == 0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a_bytes32); CHECK(payload.suggested_fee_recipient == 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address); CHECK(payload.state_root == 0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45_bytes32); CHECK(payload.receipts_root == 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421_bytes32); CHECK(payload.prev_randao == 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32); CHECK(payload.block_num == 0x1); CHECK(payload.gas_limit == 0x1c9c380); CHECK(payload.timestamp == 0x5); CHECK(payload.base_fee == 0x7); CHECK(payload.block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(payload.transactions == std::vector{{0xf9, 0x2e, 0xbd, 0xea, 0xb4, 0x5d, 0x36, 0x8f, 0x63, 0x54, 0xe8, 0xc5, 0xa8, 0xac, 0x58, 0x6c}}); CHECK(payload.withdrawals == std::vector{}); CHECK(payload.blob_gas_used == 0x1000); CHECK(payload.excess_blob_gas == 0x0100); } SECTION("missing excess_blob_gas") { const nlohmann::json json = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[{"address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","amount":"0x2710","index":"0x6","validatorIndex":"0xc"}], "blobGasUsed":"0x1000" })"_json; ExecutionPayload payload; CHECK_THROWS_AS(from_json(json, payload), std::system_error); } SECTION("missing blob_gas_used") { const nlohmann::json json = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "withdrawals":[{"address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","amount":"0x2710","index":"0x6","validatorIndex":"0xc"}], "excessBlobGas":"0x1000" })"_json; ExecutionPayload payload; CHECK_THROWS_AS(from_json(json, payload), std::system_error); } SECTION("invalid missing withdrawals") { const nlohmann::json json = R"({ "parentHash":"0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot":"0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0x0000000000000000000000000000000000000000000000000000000000000001", "blockNumber":"0x1", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x5", "extraData":"0x", "baseFeePerGas":"0x7", "blockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions":["0xf92ebdeab45d368f6354e8c5a8ac586c"], "blobGasUsed":"0x1000", "excessBlobGas":"0x1000" })"_json; ExecutionPayload payload; CHECK_THROWS_AS(from_json(json, payload), std::system_error); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/filter.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "filter.hpp" #include #include "types.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const Filter& filter) { if (filter.from_block != std::nullopt) { json["fromBlock"] = filter.from_block.value(); } if (filter.to_block != std::nullopt) { json["toBlock"] = filter.to_block.value(); } if (!filter.addresses.empty()) { if (filter.addresses.size() == 1) { json["address"] = filter.addresses[0]; } else { json["address"] = filter.addresses; } } if (!filter.topics.empty()) { json["topics"] = filter.topics; } if (filter.block_hash != std::nullopt) { json["blockHash"] = filter.block_hash.value(); } } void from_json(const nlohmann::json& json, Filter& filter) { if (json.count("fromBlock") != 0) { const auto& json_from_block = json.at("fromBlock"); if (json_from_block.is_string()) { filter.from_block = json_from_block.get(); } else { filter.from_block = to_quantity(json_from_block.get()); } } if (json.count("toBlock") != 0) { const auto& json_to_block = json.at("toBlock"); if (json_to_block.is_string()) { filter.to_block = json_to_block.get(); } else { filter.to_block = to_quantity(json_to_block.get()); } } if (json.count("address") != 0) { if (json.at("address").is_string()) { filter.addresses = {json.at("address").get()}; } else { filter.addresses = json.at("address").get(); } } if (json.count("topics") != 0) { auto topics = json.at("topics"); if (topics != nlohmann::detail::value_t::null) { for (auto& topic_item : topics) { if (topic_item.is_null()) { topic_item = FilterSubTopics{}; } if (topic_item.is_string()) { topic_item = FilterSubTopics{topic_item}; } } filter.topics = topics.get(); } } if (json.count("blockHash") != 0) { filter.block_hash = json.at("blockHash").get(); } } void from_json(const nlohmann::json& json, LogFilterOptions& filter_options) { if (json.count("logCount") != 0) { const auto& value = json.at("logCount"); filter_options.log_count = value.get(); } if (json.count("blockCount") != 0) { const auto& value = json.at("blockCount"); filter_options.block_count = value.get(); } if (json.count("ignoreTopicsOrder") != 0) { const auto& value = json.at("ignoreTopicsOrder"); filter_options.ignore_topics_order = value.get(); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/filter.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const Filter& filter); void from_json(const nlohmann::json& json, Filter& filter); void from_json(const nlohmann::json& json, LogFilterOptions& filter_options); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/filter_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "filter.hpp" #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("serialize empty filter", "[silkworm::json][to_json]") { Filter f{"0", "0", FilterAddresses{}, FilterTopics(2), ""}; nlohmann::json j = f; CHECK(j == R"({"blockHash":"","fromBlock":"0","toBlock":"0","topics":[[], []]})"_json); } TEST_CASE("serialize filter with one address", "[silkworm::json][to_json]") { Filter f; f.addresses = {{0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address}}; nlohmann::json j = f; CHECK(j == R"({"address":"0x007fb8417eb9ad4d958b050fc3720d5b46a2c053"})"_json); } TEST_CASE("serialize filter with fromBlock and toBlock", "[silkworm::json][to_json]") { Filter f{"1000", "2000", FilterAddresses{}, FilterTopics(2), ""}; nlohmann::json j = f; CHECK(j == R"({"blockHash":"","fromBlock":"1000","toBlock":"2000","topics":[[], []]})"_json); } TEST_CASE("deserialize null filter", "[silkworm::json][from_json]") { auto j1 = R"({})"_json; auto f1 = j1.get(); CHECK(f1.from_block == std::nullopt); CHECK(f1.to_block == std::nullopt); } TEST_CASE("deserialize empty filter", "[silkworm::json][from_json]") { auto j1 = R"({"address":["",""],"blockHash":"","fromBlock":0,"toBlock":0,"topics":[["",""], ["",""]]})"_json; auto f1 = j1.get(); CHECK(f1.from_block == "0x0"); CHECK(f1.to_block == "0x0"); } TEST_CASE("deserialize filter with topic", "[silkworm::json][from_json]") { auto j = R"({ "address": "0x6090a6e47849629b7245dfa1ca21d94cd15878ef", "fromBlock": "0x3d0000", "toBlock": "0x3d2600", "topics": [ null, "0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c" ] })"_json; auto f = j.get(); CHECK(f.from_block == "0x3d0000"); CHECK(f.to_block == "0x3d2600"); CHECK(f.addresses == std::vector{0x6090a6e47849629b7245dfa1ca21d94cd15878ef_address}); CHECK(f.topics == std::vector>{ {}, {0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}}); CHECK(f.block_hash == std::nullopt); } TEST_CASE("deserialize filter with topic null", "[silkworm::json][from_json]") { auto j = R"({ "address": "0x6090a6e47849629b7245dfa1ca21d94cd15878ef", "fromBlock": "0x3d0000", "toBlock": "0x3d2600", "topics": null })"_json; auto f = j.get(); CHECK(f.from_block == "0x3d0000"); CHECK(f.to_block == "0x3d2600"); CHECK(f.addresses == std::vector{0x6090a6e47849629b7245dfa1ca21d94cd15878ef_address}); CHECK(f.block_hash == std::nullopt); } TEST_CASE("deserialize LogFilterOptions", "[silkworm::json][from_json]") { SECTION("default values") { auto j = R"({ "logCount": 0, "blockCount": 0, "ignoreTopicsOrder": false })"_json; auto options = j.get(); CHECK(options.log_count == 0); CHECK(options.block_count == 0); CHECK(options.ignore_topics_order == false); } SECTION("log_count != 0") { auto j = R"({ "logCount": 100, "blockCount": 0, "ignoreTopicsOrder": false })"_json; auto options = j.get(); CHECK(options.log_count == 100); CHECK(options.block_count == 0); CHECK(options.ignore_topics_order == false); } SECTION("block_count != 0") { auto j = R"({ "logCount": 0, "blockCount": 100, "ignoreTopicsOrder": false })"_json; auto options = j.get(); CHECK(options.log_count == 0); CHECK(options.block_count == 100); CHECK(options.ignore_topics_order == false); } SECTION("ignore_topics_order == true") { auto j = R"({ "logCount": 0, "blockCount": 0, "ignoreTopicsOrder": true })"_json; auto options = j.get(); CHECK(options.log_count == 0); CHECK(options.block_count == 0); CHECK(options.ignore_topics_order == true); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/fork_choice.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "fork_choice.hpp" #include "types.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const ForkChoiceState& forkchoice_state) { json["headBlockHash"] = forkchoice_state.head_block_hash; json["safeBlockHash"] = forkchoice_state.safe_block_hash; json["finalizedBlockHash"] = forkchoice_state.finalized_block_hash; } void from_json(const nlohmann::json& json, ForkChoiceState& forkchoice_state) { forkchoice_state = ForkChoiceState{ .head_block_hash = json.at("headBlockHash").get(), .safe_block_hash = json.at("safeBlockHash").get(), .finalized_block_hash = json.at("finalizedBlockHash").get()}; } void to_json(nlohmann::json& json, const ForkChoiceUpdatedReply& forkchoice_updated_reply) { nlohmann::json json_payload_status = forkchoice_updated_reply.payload_status; json["payloadStatus"] = json_payload_status; if (forkchoice_updated_reply.payload_id) { json["payloadId"] = to_hex(forkchoice_updated_reply.payload_id.value()); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/fork_choice.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const ForkChoiceState& forkchoice_state); void from_json(const nlohmann::json& json, ForkChoiceState& forkchoice_state); void to_json(nlohmann::json& json, const ForkChoiceUpdatedReply& forkchoice_updated_reply); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/fork_choice_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "fork_choice.hpp" #include #include namespace silkworm::rpc { using namespace evmc::literals; TEST_CASE("serialize ForkChoiceStateV1", "[silkworm::json][to_json]") { ForkChoiceState forkchoice_state{ .head_block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .safe_block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .finalized_block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32}; nlohmann::json j = forkchoice_state; CHECK(j == R"({ "headBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "safeBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "finalizedBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858" })"_json); } TEST_CASE("deserialize ForkChoiceStateV1", "[silkworm::json][from_json]") { nlohmann::json j = R"({ "headBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "safeBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "finalizedBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858" })"_json; ForkChoiceState forkchoice_state = j; CHECK(forkchoice_state.head_block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(forkchoice_state.safe_block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(forkchoice_state.finalized_block_hash == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); } TEST_CASE("serialize ForkChoiceUpdatedReply", "[silkworm::json][to_json]") { ForkChoiceUpdatedReply fcu_reply{ .payload_status = PayloadStatus::kAccepted, .payload_id = 0}; nlohmann::json j = fcu_reply; CHECK(j == R"({ "payloadStatus":{"status":"ACCEPTED"}, "payloadId":"0x0000000000000000" })"_json); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/glaze.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "glaze.hpp" #include #include #include #include #include #include namespace silkworm::rpc { //! Maximum size of RPC error message static constexpr size_t kMaxErrorMessageSize{1024}; //! Fill a fixed error message by trimming the provided message if needed static void fill_error_message(char fixed_msg[kMaxErrorMessageSize], const std::string& msg) { const auto error_message_size{std::min(msg.size(), kMaxErrorMessageSize - 1)}; std::strncpy(fixed_msg, msg.c_str(), error_message_size); fixed_msg[error_message_size] = '\0'; } struct GlazeJsonError { int code{-1}; char message[kMaxErrorMessageSize]{}; struct glaze { using T = GlazeJsonError; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "code", &T::code, "message", &T::message); }; }; struct GlazeJsonErrorRsp { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; GlazeJsonError json_error; struct glaze { using T = GlazeJsonErrorRsp; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "error", &T::json_error); }; }; void make_glaze_json_error(const nlohmann::json& request, const int error_id, const std::string& message, std::string& reply) { GlazeJsonErrorRsp glaze_json_error{}; glaze_json_error.id = make_jsonrpc_id(request); glaze_json_error.json_error.code = error_id; fill_error_message(glaze_json_error.json_error.message, message); glz::write_json(glaze_json_error, reply); } struct GlazeJsonRevert { int code{-1}; char message[kMaxErrorMessageSize]{}; std::string data; struct glaze { using T = GlazeJsonRevert; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "code", &T::code, "message", &T::message, "data", &T::data); }; }; struct GlazeJsonRevertError { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; GlazeJsonRevert revert_data; struct glaze { using T = GlazeJsonRevertError; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "error", &T::revert_data); }; }; void make_glaze_json_error(const nlohmann::json& request, const RevertError& error, std::string& reply) { GlazeJsonRevertError glaze_json_revert{}; glaze_json_revert.id = make_jsonrpc_id(request); glaze_json_revert.revert_data.code = error.code; fill_error_message(glaze_json_revert.revert_data.message, error.message); glaze_json_revert.revert_data.data = "0x" + silkworm::to_hex(error.data); glz::write_json(glaze_json_revert, reply); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/glaze.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #pragma GCC diagnostic ignored "-Wshadow" #include #pragma GCC diagnostic pop #include #include #include namespace silkworm::rpc { inline constexpr std::string_view kJsonVersion{"2.0"}; inline constexpr size_t kAddressHexSize = 2 + 2 * kAddressLength + 1; inline constexpr size_t kHashHexSize = 2 + 2 * kHashLength + 1; inline constexpr size_t kBloomSize = 1024; inline constexpr size_t kInt64HexSize = 2 + 2 * sizeof(uint64_t) + 1; inline constexpr size_t kInt256HexSize = 2 + 2 * sizeof(intx::uint256) + 1; inline constexpr size_t kDataSize = 16384; inline constexpr size_t kEthCallResultFixedSize = 2048; void make_glaze_json_error(const nlohmann::json& request, int error_id, const std::string& message, std::string& reply); void make_glaze_json_error(const nlohmann::json& request, const RevertError& error, std::string& reply); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/glaze_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "glaze.hpp" #include #include #include namespace silkworm::rpc { // Necessary just to extract `id` field to fill the same into the reply static const nlohmann::json kEmptyRequest{{"jsonrpc", "2.0"}, {"id", 1}}; TEST_CASE("make glaze json error", "[silkworm][rpc][make_glaze_json_error]") { std::string json; make_glaze_json_error(kEmptyRequest, 3, "generic_error", json); CHECK(json == R"({"jsonrpc":"2.0","id":1,"error":{"code":3,"message":"generic_error"}})"); } // Temporary skip in sanitizer builds due to ASAN error after upgrade to glaze 1.9.9 // https://app.circleci.com/pipelines/github/erigontech/silkworm/10176/workflows/e2c43524-e9c4-4c95-b087-199ded7baf09/jobs/45082 #ifndef SILKWORM_SANITIZE TEST_CASE("make glaze json revert error", "[silkworm][rpc][make_glaze_json_error]") { std::string json; const char* data_hex{"c68341b58302c0"}; Bytes data_bytes{*from_hex(data_hex)}; make_glaze_json_error(kEmptyRequest, RevertError{{3, "generic_error"}, data_bytes}, json); CHECK(json == R"({"jsonrpc":"2.0","id":1,"error":{"code":3,"message":"generic_error","data":"0xc68341b58302c0"}})"); } TEST_CASE("make glaze json revert error too big", "[silkworm][rpc][make_glaze_json_error]") { std::string json; const char* data_hex{"c68341b58302c0"}; Bytes data_bytes{*from_hex(data_hex)}; std::string error_message(1024, '\1'); make_glaze_json_error(kEmptyRequest, RevertError{{3, error_message}, data_bytes}, json); CHECK(std::strcmp(json.c_str(), R"({"jsonrpc":"2.0","id":1,"error":{"code":3,"message":")" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01)" R"(\x01\x01\x01","data":"0xc68341b58302c0"}})")); } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/log.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include #include #include #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const std::vector& logs) { json = nlohmann::json::array(); for (size_t k{0}; k < logs.size(); ++k) { auto& inner_logs{logs[k]}; nlohmann::basic_json inner_json = nlohmann::json::array(); if (inner_logs.empty()) { inner_json = nullptr; } else { for (size_t i{0}; i < inner_logs.size(); ++i) { inner_json.push_back(inner_logs[i]); } } json.push_back(inner_json); } } void to_json(nlohmann::json& json, const Log& log) { json["address"] = log.address; json["topics"] = log.topics; json["data"] = "0x" + silkworm::to_hex(log.data); json["blockNumber"] = to_quantity(log.block_num); json["blockHash"] = log.block_hash; json["transactionHash"] = log.tx_hash; json["transactionIndex"] = to_quantity(log.tx_index); json["logIndex"] = to_quantity(log.index); json["removed"] = log.removed; if (log.timestamp) { json["timestamp"] = to_quantity(*(log.timestamp)); } } void from_json(const nlohmann::json& json, Log& log) { if (json.is_array()) { if (json.size() < 3) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Log CBOR: missing entries"}; } if (!json[0].is_binary()) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Log CBOR: binary expected in [0]"}; } auto address_bytes = json[0].get_binary(); log.address = bytes_to_address(silkworm::Bytes{address_bytes.begin(), address_bytes.end()}); if (!json[1].is_array()) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Log CBOR: array expected in [1]"}; } std::vector topics{}; topics.reserve(json[1].size()); for (auto& topic : json[1]) { auto topic_bytes = topic.get_binary(); topics.push_back(silkworm::to_bytes32(silkworm::Bytes{topic_bytes.begin(), topic_bytes.end()})); } log.topics = topics; if (json[2].is_binary()) { auto data_bytes = json[2].get_binary(); log.data = silkworm::Bytes{data_bytes.begin(), data_bytes.end()}; } else if (json[2].is_null()) { log.data = silkworm::Bytes{}; } else { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Log CBOR: binary or null expected in [2]"}; } } else { log.address = json.at("address").get(); log.topics = json.at("topics").get>(); log.data = json.at("data").get(); } } struct GlazeJsonLogItem { char address[kAddressHexSize]; char tx_hash[kHashHexSize]; char block_hash[kHashHexSize]; char block_num[kInt64HexSize]; char tx_index[kInt64HexSize]; char index[kInt64HexSize]; char data[kDataSize]; bool removed; std::vector topics; std::optional timestamp; struct glaze { using T = GlazeJsonLogItem; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "address", &T::address, "transactionHash", &T::tx_hash, "blockHash", &T::block_hash, "blockNumber", &T::block_num, "transactionIndex", &T::tx_index, "logIndex", &T::index, "data", &T::data, "removed", &T::removed, "topics", &T::topics, "timestamp", &T::timestamp); }; }; struct GlazeJsonLog { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; std::vector log_json_list; struct glaze { using T = GlazeJsonLog; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "result", &T::log_json_list); }; }; void make_glaze_json_content(const nlohmann::json& request_json, const Logs& logs, std::string& json_reply) { GlazeJsonLog log_json_data{}; log_json_data.log_json_list.reserve(logs.size()); log_json_data.id = make_jsonrpc_id(request_json); for (const auto& l : logs) { GlazeJsonLogItem item{}; to_hex(std::span(item.address), l.address.bytes); to_hex(std::span(item.tx_hash), l.tx_hash.bytes); to_hex(std::span(item.block_hash), l.block_hash.bytes); to_quantity(std::span(item.block_num), l.block_num); to_quantity(std::span(item.tx_index), l.tx_index); to_quantity(std::span(item.index), l.index); item.removed = l.removed; to_hex(item.data, l.data); if (l.timestamp) { item.timestamp = to_quantity(*(l.timestamp)); } for (const auto& t : l.topics) { item.topics.push_back(silkworm::to_hex(t, true)); } log_json_data.log_json_list.push_back(std::move(item)); } glz::write_json(log_json_data, json_reply); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/log.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void from_json(const nlohmann::json& json, Log& log); void to_json(nlohmann::json& json, const Log& log); void to_json(nlohmann::json& json, const std::vector& logs); void make_glaze_json_content(const nlohmann::json& request_json, const Logs& logs, std::string& json_reply); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/log_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include #include #include #include #include #include namespace { #ifdef _WIN32 static constexpr std::string_view kInvalidArgumentMessage = "invalid argument"; #else constexpr std::string_view kInvalidArgumentMessage = "Invalid argument"; #endif } // namespace namespace silkworm::rpc { using Catch::Matchers::Message; using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("serialize empty log", "[rpc][to_json]") { Log l{{}, {}, {}}; nlohmann::json j = l; CHECK(j == R"({ "address":"0x0000000000000000000000000000000000000000", "topics":[], "data":"0x", "blockNumber":"0x0", "blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "transactionIndex":"0x0", "logIndex":"0x0", "removed":false })"_json); } TEST_CASE("shortest hex for 4206337", "[rpc][to_json]") { Log l{{}, {}, {}, 4206337}; nlohmann::json j = l; CHECK(j == R"({ "address":"0x0000000000000000000000000000000000000000", "topics":[], "data":"0x", "blockNumber":"0x402f01", "blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "transactionIndex":"0x0", "logIndex":"0x0", "removed":false })"_json); } TEST_CASE("deserialize wrong size log", "[rpc][from_json]") { const auto j1 = nlohmann::json::from_cbor(*silkworm::from_hex("80")); CHECK_THROWS_MATCHES(j1.get(), std::system_error, Message("Log CBOR: missing entries: " + std::string{kInvalidArgumentMessage})); const auto j2 = nlohmann::json::from_cbor(*silkworm::from_hex("81540000000000000000000000000000000000000000")); CHECK_THROWS_MATCHES(j2.get(), std::system_error, Message("Log CBOR: missing entries: " + std::string{kInvalidArgumentMessage})); const auto j3 = nlohmann::json::from_cbor(*silkworm::from_hex("8254000000000000000000000000000000000000000080")); CHECK_THROWS_MATCHES(j3.get(), std::system_error, Message("Log CBOR: missing entries: " + std::string{kInvalidArgumentMessage})); const auto j4 = nlohmann::json::from_cbor(*silkworm::from_hex("83808040")); CHECK_THROWS_MATCHES(j4.get(), std::system_error, Message("Log CBOR: binary expected in [0]: " + std::string{kInvalidArgumentMessage})); const auto j5 = nlohmann::json::from_cbor(*silkworm::from_hex("835400000000000000000000000000000000000000004040")); CHECK_THROWS_MATCHES(j5.get(), std::system_error, Message("Log CBOR: array expected in [1]: " + std::string{kInvalidArgumentMessage})); const auto j6 = nlohmann::json::from_cbor(*silkworm::from_hex("835400000000000000000000000000000000000000008080")); CHECK_THROWS_MATCHES(j6.get(), std::system_error, Message("Log CBOR: binary or null expected in [2]: " + std::string{kInvalidArgumentMessage})); } TEST_CASE("deserialize empty array log", "[rpc][from_json]") { const auto j1 = nlohmann::json::from_cbor(*silkworm::from_hex("835400000000000000000000000000000000000000008040")); const auto log1 = j1.get(); CHECK(log1.address == evmc::address{}); CHECK(log1.topics.empty()); CHECK(log1.data.empty()); const auto j2 = nlohmann::json::from_cbor(*silkworm::from_hex("8354000000000000000000000000000000000000000080f6")); const auto log2 = j2.get(); CHECK(log2.address == evmc::address{}); CHECK(log2.topics.empty()); CHECK(log2.data.empty()); } TEST_CASE("deserialize empty log", "[rpc][from_json]") { const auto j = R"({ "address":"0000000000000000000000000000000000000000", "topics":[], "data":[] })"_json; const auto log = j.get(); CHECK(log.address == evmc::address{}); CHECK(log.topics.empty()); CHECK(log.data.empty()); } TEST_CASE("deserialize array log", "[rpc][from_json]") { const Bytes bytes = silkworm::from_hex("8354ea674fdde714fd979de3edf0f56aa9716b898ec88043010043").value(); const auto j = nlohmann::json::from_cbor(bytes); const auto log = j.get(); CHECK(log.address == 0xea674fdde714fd979de3edf0f56aa9716b898ec8_address); CHECK(log.topics.empty()); CHECK(log.data == silkworm::Bytes{0x01, 0x00, 0x43}); } TEST_CASE("deserialize topics", "[rpc][from_json]") { auto j1 = R"({ "address":"0000000000000000000000000000000000000000", "topics":["0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c"], "data":[] })"_json; auto f1 = j1.get(); CHECK(f1.address == evmc::address{}); CHECK(f1.topics == std::vector{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}); CHECK(f1.data.empty()); } TEST_CASE("make empty glaze Log", "[make_glaze_content(Log)]") { std::string json; std::vector log{}; make_glaze_json_content(1, log, json); CHECK(strcmp(json.c_str(), "[{\"jsonrpc\":\"2.0\",\ \"id\":1,\ \"result\":[]}]")); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/node_info.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node_info.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const NodeInfoPorts& node_info_ports) { json["discovery"] = node_info_ports.discovery; json["listener"] = node_info_ports.listener; } void to_json(nlohmann::json& json, const NodeInfo& node_info) { json["id"] = node_info.id; json["name"] = node_info.name; json["enode"] = node_info.enode; json["enr"] = node_info.enr; json["listenAddr"] = node_info.listener_addr; json["ports"] = node_info.ports; json["ip"] = node_info.enode; json["protocols"] = nlohmann::json::parse(node_info.protocols, nullptr, /* allow_exceptions = */ false); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/node_info.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const NodeInfoPorts& node_info_ports); void to_json(nlohmann::json& json, const NodeInfo& node_info); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/node_info_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node_info.hpp" #include #include namespace silkworm::rpc { TEST_CASE("serialize NodeInfoPorts", "[silkworm::json][to_json]") { silkworm::rpc::NodeInfoPorts ports{6, 7}; nlohmann::json j = ports; CHECK(j == R"({ "discovery":6, "listener":7 })"_json); } TEST_CASE("serialize NodeInfo", "[silkworm::json][to_json]") { silkworm::rpc::NodeInfo node_info{"340", "erigon", "enode", "enr", "[::]:30303", R"({"eth": {"network":5, "difficulty":10790000}})"}; nlohmann::json j = node_info; CHECK(j == R"( { "enode":"enode", "enr":"enr", "id":"340", "ip":"enode", "listenAddr":"[::]:30303", "name":"erigon", "ports":{"discovery":0,"listener":0}, "protocols": { "eth": {"network":5, "difficulty":10790000}} })"_json); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/payload_attributes.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "payload_attributes.hpp" #include #include #include #include "types.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const PayloadAttributes& payload_attributes) { json["timestamp"] = to_quantity(payload_attributes.timestamp); json["prevRandao"] = payload_attributes.prev_randao; json["suggestedFeeRecipient"] = payload_attributes.suggested_fee_recipient; } void from_json(const nlohmann::json& json, PayloadAttributes& payload_attributes) { // Optionally parse V2 fields std::optional> withdrawals; if (json.contains("withdrawals")) { withdrawals = json.at("withdrawals").get>(); } // Optionally parse V3 fields std::optional parent_beacon_block_root; if (json.contains("parentBeaconBlockRoot")) { parent_beacon_block_root = json.at("parentBeaconBlockRoot").get(); } payload_attributes = PayloadAttributes{ .timestamp = from_quantity(json.at("timestamp").get()), .prev_randao = json.at("prevRandao").get(), .suggested_fee_recipient = json.at("suggestedFeeRecipient").get(), .withdrawals = std::move(withdrawals), .parent_beacon_block_root = parent_beacon_block_root, }; // Set the PayloadAttributes version (default is V1) SILKWORM_ASSERT(payload_attributes.version == PayloadAttributes::kV1); if (payload_attributes.withdrawals) { if (payload_attributes.parent_beacon_block_root) { payload_attributes.version = PayloadAttributes::kV3; } else { payload_attributes.version = PayloadAttributes::kV2; } } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/payload_attributes.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const PayloadAttributes& payload_attributes); void from_json(const nlohmann::json& json, PayloadAttributes& payload_attributes); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/payload_attributes_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "payload_attributes.hpp" #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("serialize PayloadAttributesV1", "[silkworm::json][to_json]") { PayloadAttributes payload_attributes{ .timestamp = 0x1, .prev_randao = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .suggested_fee_recipient = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address}; nlohmann::json j = payload_attributes; CHECK(j == R"({ "timestamp":"0x1", "prevRandao":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "suggestedFeeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" })"_json); } TEST_CASE("deserialize PayloadAttributesV1", "[silkworm::json][from_json]") { nlohmann::json j = R"({ "timestamp":"0x1", "prevRandao":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "suggestedFeeRecipient":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" })"_json; PayloadAttributes payload_attributes = j; CHECK(payload_attributes.timestamp == 0x1); CHECK(payload_attributes.prev_randao == 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32); CHECK(payload_attributes.suggested_fee_recipient == 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/receipt.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipt.hpp" #include #include #include #include "types.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const std::shared_ptr& receipt) { json = *receipt; } void to_json(nlohmann::json& json, const Receipt& receipt) { json["blockHash"] = receipt.block_hash; json["blockNumber"] = to_quantity(receipt.block_num); json["transactionHash"] = receipt.tx_hash; json["transactionIndex"] = to_quantity(receipt.tx_index); json["from"] = receipt.from.value_or(evmc::address{}); if (receipt.to) { json["to"] = *receipt.to; } else { json["to"] = nlohmann::json{}; } json["type"] = to_quantity(static_cast(receipt.type)); json["gasUsed"] = to_quantity(receipt.gas_used); json["cumulativeGasUsed"] = to_quantity(receipt.cumulative_gas_used); json["effectiveGasPrice"] = to_quantity(receipt.effective_gas_price); if (receipt.contract_address) { json["contractAddress"] = receipt.contract_address; } else { json["contractAddress"] = nlohmann::json{}; } json["logs"] = receipt.logs; json["logsBloom"] = "0x" + silkworm::to_hex(full_view(receipt.bloom)); json["status"] = to_quantity(receipt.success ? 1 : 0); if (receipt.blob_gas_used) { json["blobGasUsed"] = to_quantity(*(receipt.blob_gas_used)); } if (receipt.blob_gas_price) { json["blobGasPrice"] = to_quantity(*(receipt.blob_gas_price)); } } void from_json(const nlohmann::json& json, std::shared_ptr& receipt) { receipt = std::make_shared(); *receipt = json; } void from_json(const nlohmann::json& json, Receipt& receipt) { SILK_TRACE << "from_json json: " << json.dump(); if (json.is_array()) { if (json.size() < 4) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: missing entries"}; } if (!json[0].is_number()) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: number expected in [0]"}; } receipt = Receipt(); receipt.type = json[0]; if (!json[1].is_null()) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: null expected in [1]"}; } if (!json[2].is_number()) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: number expected in [2]"}; } receipt.success = json[2] == 1u; if (!json[3].is_number()) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: number expected in [3]"}; } receipt.cumulative_gas_used = json[3]; } else { if (!json.contains("success") || !json.contains("cumulative_gas_used")) { throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: missing entries in " + json.dump()}; } receipt = Receipt(); receipt.success = json.at("success").get(); receipt.cumulative_gas_used = json.at("cumulative_gas_used").get(); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/receipt.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const std::shared_ptr& receipt); void to_json(nlohmann::json& json, const Receipt& receipt); void from_json(const nlohmann::json& json, std::shared_ptr& receipt); void from_json(const nlohmann::json& json, Receipt& receipt); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/receipt_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipt.hpp" #include #include namespace silkworm::rpc { TEST_CASE("deserialize wrong receipt", "[rpc][from_json]") { const nlohmann::json j = R"({})"_json; CHECK_THROWS(j.get()); } TEST_CASE("deserialize empty receipt", "[rpc][from_json]") { const nlohmann::json j = R"({"success":false,"cumulative_gas_used":0})"_json; const auto r = j.get(); CHECK(r.success == false); CHECK(r.cumulative_gas_used == 0); } TEST_CASE("deserialize wrong array receipt", "[rpc][from_json]") { CHECK_THROWS_AS(R"([])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([""])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([null])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,0])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,""])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,null])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,null,""])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,null,null])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,null,0])"_json.get(), std::system_error); CHECK_THROWS_AS(R"(["",null,0,0])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,"",0,0])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,null,"",0])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,null,0,""])"_json.get(), std::system_error); CHECK_THROWS_AS(R"([0,null,0,null])"_json.get(), std::system_error); } TEST_CASE("deserialize wrong object receipt", "[rpc][from_json]") { CHECK_THROWS_AS(R"({})"_json.get(), std::system_error); CHECK_THROWS_AS(R"({"result_success":false,"cumulative_gas_used":"0"})"_json.get(), std::system_error); CHECK_THROWS_AS(R"({"success":false,"result_cumulative_gas_used":"0"})"_json.get(), std::system_error); } TEST_CASE("deserialize empty array receipt", "[rpc][from_json]") { const nlohmann::json j1 = R"([0,null,0,0])"_json; const auto r1 = j1.get(); CHECK(r1.type == TransactionType::kLegacy); CHECK(r1.success == false); CHECK(r1.cumulative_gas_used == 0); const auto j2 = nlohmann::json::from_cbor(*silkworm::from_hex("8400f60000")); const auto r2 = j2.get(); CHECK(r2.type == TransactionType::kLegacy); CHECK(r2.success == false); CHECK(r2.cumulative_gas_used == 0); } TEST_CASE("deserialize array receipt", "[rpc][from_json]") { const nlohmann::json j = R"([1,null,1,123456])"_json; const auto r = j.get(); CHECK(r.type == TransactionType::kAccessList); CHECK(r.success == true); CHECK(r.cumulative_gas_used == 123456); } TEST_CASE("serialize empty receipt", "[silkworm::json][to_json]") { Receipt r{}; nlohmann::json j = r; CHECK(j == R"({ "blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber":"0x0", "contractAddress":null, "cumulativeGasUsed":"0x0", "effectiveGasPrice":"0x0", "from":"0x0000000000000000000000000000000000000000", "gasUsed":"0x0", "logs":[], "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "status":"0x0", "to":null, "transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "transactionIndex":"0x0", "type":"0x0" })"_json); } TEST_CASE("serialize receipt", "[silkworm::json][to_json]") { Receipt r{ TransactionType::kAccessList, true, 454647, silkworm::Bloom{}, Logs{}, 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32, 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address, 10, 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f_bytes32, 5000000, 3, 0x22ea9f6b28db76a7162054c05ed812deb2f519cd_address, 0x22ea9f6b28db76a7162054c05ed812deb2f519cd_address, 2000000000}; nlohmann::json j = r; CHECK(j == R"({ "blockHash":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f", "blockNumber":"0x4c4b40", "contractAddress":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "cumulativeGasUsed":"0x6eff7", "effectiveGasPrice":"0x77359400", "from":"0x22ea9f6b28db76a7162054c05ed812deb2f519cd", "gasUsed":"0xa", "logs":[], "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "status":"0x0", "status":"0x1", "to":"0x22ea9f6b28db76a7162054c05ed812deb2f519cd", "transactionHash":"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c", "transactionIndex":"0x3", "type":"0x1" })"_json); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/stream.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stream.hpp" #include #include #include #include #include #include #include #ifndef _WIN32 // Workaround for Windows build error due to bug https://github.com/chriskohlhoff/asio/issues/1281 #include #endif // _WIN32 #include namespace silkworm::rpc::json { using namespace std::chrono_literals; static constexpr uint8_t kObjectOpen{1}; static constexpr uint8_t kArrayOpen{2}; static constexpr uint8_t kFieldWritten{3}; static constexpr uint8_t kEntryWritten{4}; static constexpr std::string_view kOpenBrace{"{"}; static constexpr std::string_view kCloseBrace{"}"}; static constexpr std::string_view kOpenBracket{"["}; static constexpr std::string_view kCloseBracket{"]"}; static constexpr std::string_view kFieldSeparator{","}; static constexpr std::string_view kColon{":"}; static constexpr std::string_view kDoubleQuotes{"\""}; //! The maximum number of items enqueued in the chunk channel static constexpr size_t kChannelCapacity{100}; Stream::Stream(boost::asio::any_io_executor& executor, StreamWriter& writer, uint64_t request_id, size_t buffer_capacity) : writer_(writer), request_id_{request_id}, buffer_capacity_{buffer_capacity ? buffer_capacity : writer_.get_capacity()}, channel_{executor, kChannelCapacity}, // Workaround for Windows build error due to bug https://github.com/chriskohlhoff/asio/issues/1281 #ifndef _WIN32 run_completion_promise_{co_spawn( executor, [](auto self) -> Task { co_await self->run(); }(this), boost::asio::experimental::use_promise)} { #else run_completion_channel_{executor, 1} { co_spawn( executor, [](auto self) -> Task { co_await self->run(); }(this), boost::asio::detached); #endif // _WIN32 // Try to prevent reallocation when buffer overflows buffer_.reserve(buffer_capacity_ + buffer_capacity_ / 4); } Task Stream::open() { co_await writer_.open_stream(request_id_); } Task Stream::close() { if (!buffer_.empty()) { co_await do_async_write(std::make_shared(std::move(buffer_)), true); } else { co_await do_async_write(std::make_shared(""), true); } co_await do_async_write(nullptr, true); // Workaround for Windows build error due to bug https://github.com/chriskohlhoff/asio/issues/1281 #ifndef _WIN32 co_await run_completion_promise_(boost::asio::use_awaitable); #else co_await run_completion_channel_.async_receive(boost::asio::use_awaitable); #endif // _WIN32 co_await writer_.close_stream(request_id_); } void Stream::open_object() { bool is_entry = !stack_.empty() && (stack_.top() == kArrayOpen || stack_.top() == kEntryWritten); if (is_entry) { if (stack_.top() != kEntryWritten) { stack_.push(kEntryWritten); } else { write(kFieldSeparator); } } write(kOpenBrace); stack_.push(kObjectOpen); } void Stream::close_object() { if (!stack_.empty() && stack_.top() == kFieldWritten) { stack_.pop(); } stack_.pop(); write(kCloseBrace); } void Stream::open_array() { write(kOpenBracket); stack_.push(kArrayOpen); } void Stream::close_array() { if (!stack_.empty() && (stack_.top() == kEntryWritten || stack_.top() == kFieldWritten)) { stack_.pop(); } stack_.pop(); write(kCloseBracket); } void Stream::write_json(const nlohmann::json& json) { const bool is_entry = !stack_.empty() && (stack_.top() == kArrayOpen || stack_.top() == kEntryWritten); if (is_entry) { if (stack_.top() != kEntryWritten) { stack_.push(kEntryWritten); } else { write(kFieldSeparator); } } const auto content = json.dump(/*indent=*/-1, /*indent_char=*/' ', /*ensure_ascii=*/false, nlohmann::json::error_handler_t::replace); write(content); } void Stream::write_field(std::string_view name) { ensure_separator(); write_string(name); write(kColon); } void Stream::write_entry(std::string_view value) { ensure_separator(); write_string(value); } void Stream::write_json_field(std::string_view name, const nlohmann::json& value) { ensure_separator(); const auto content = value.dump(/*indent=*/-1, /*indent_char=*/' ', /*ensure_ascii=*/false, nlohmann::json::error_handler_t::replace); write_string(name); write(kColon); write(content); } void Stream::write_field(std::string_view name, std::string_view value) { ensure_separator(); write_string(name); write(kColon); write_string(value); } void Stream::write_field(std::string_view name, bool value) { ensure_separator(); write_string(name); write(kColon); write(value ? "true" : "false"); } void Stream::write_field(std::string_view name, const char* value) { ensure_separator(); write_string(name); write(kColon); write_string(std::string_view(value, strlen(value))); } void Stream::write_field(std::string_view name, evmc::bytes32 value) { ensure_separator(); write_string(name); write(kColon); write_string("0x" + to_hex(value)); } void Stream::write_field(std::string_view name, std::int32_t value) { ensure_separator(); write_string(name); write(kColon); std::array str{}; if (auto [ptr, ec] = std::to_chars(str.data(), str.data() + str.size(), value); ec == std::errc()) { write(std::string_view(str.data(), ptr)); } else { write("Invalid value"); } } void Stream::write_field(std::string_view name, std::uint32_t value) { ensure_separator(); write_string(name); write(kColon); std::array str{}; if (auto [ptr, ec] = std::to_chars(str.data(), str.data() + str.size(), value); ec == std::errc()) { write(std::string_view(str.data(), ptr)); } else { write("Invalid value"); } } void Stream::write_field(std::string_view name, std::int64_t value) { ensure_separator(); write_string(name); write(kColon); std::array str{}; if (auto [ptr, ec] = std::to_chars(str.data(), str.data() + str.size(), value); ec == std::errc()) { write(std::string_view(str.data(), ptr)); } else { write("Invalid value"); } } void Stream::write_field(std::string_view name, std::uint64_t value) { ensure_separator(); write_string(name); write(kColon); std::array str{}; if (auto [ptr, ec] = std::to_chars(str.data(), str.data() + str.size(), value); ec == std::errc()) { write(std::string_view(str.data(), ptr)); } else { write("Invalid value"); } } void Stream::write_field(std::string_view name, std::double_t value) { ensure_separator(); write_string(name); write(kColon); std::array str{}; if (auto [ptr, ec] = std::to_chars(str.data(), str.data() + str.size(), value); ec == std::errc()) { write(std::string_view(str.data(), ptr)); } else { write("Invalid value"); } } void Stream::write_string(std::string_view str) { write(kDoubleQuotes); write(str); write(kDoubleQuotes); } void Stream::write(std::string_view str) { buffer_ += str; if (buffer_.size() >= buffer_capacity_) { do_write(std::make_shared(std::move(buffer_)), false); } } void Stream::ensure_separator() { if (!stack_.empty()) { if (stack_.top() != kFieldWritten) { stack_.push(kFieldWritten); } else { write(kFieldSeparator); } } } void Stream::do_write(ChunkPtr chunk, bool last) { // Stream write API will usually be called by worker threads rather than I/O contexts, but we must handle both const auto& channel_executor{channel_.get_executor()}; if (channel_executor.target()->running_in_this_thread()) [[unlikely]] { // Delegate any back pressure to do_async_write boost::asio::co_spawn(channel_executor, do_async_write(chunk, false), boost::asio::detached); } else { DataChunk data_chunk{}; data_chunk.chunk = std::move(chunk); data_chunk.last = last; // Handle back pressure simply by retrying after a while // TODO(canepat) clever wait strategy while (channel_.is_open()) { if (const bool ok{channel_.try_send(boost::system::error_code(), data_chunk)}; ok) { break; } SILK_TRACE << "Chunk size=" << (data_chunk.chunk ? data_chunk.chunk->size() : 0) << " not enqueued, worker back pressured"; std::this_thread::sleep_for(10ms); } } } Task Stream::do_async_write(ChunkPtr chunk, bool last) { DataChunk data_chunk{}; data_chunk.chunk = std::move(chunk); data_chunk.last = last; // TODO(canepat) handle back pressure try { co_await channel_.async_send(boost::system::error_code(), data_chunk, boost::asio::use_awaitable); } catch (const boost::system::system_error& se) { if (se.code() != boost::asio::experimental::error::channel_cancelled) { SILK_ERROR << "Stream::do_async_write unexpected system_error: " << se.what(); } } catch (const std::exception& exception) { SILK_ERROR << "Stream::do_async_write unexpected exception: " << exception.what(); } } Task Stream::run() { uint32_t total_writes{0}; size_t total_bytes_sent{0}; while (true) { try { const DataChunk data_chunk = co_await channel_.async_receive(boost::asio::use_awaitable); if (!data_chunk.chunk) { break; } total_bytes_sent += co_await writer_.write(request_id_, *data_chunk.chunk, data_chunk.last); ++total_writes; } catch (const boost::system::system_error& se) { if (se.code() != boost::asio::experimental::error::channel_cancelled) { SILK_ERROR << "Stream::run unexpected system_error: " << se.what(); } break; } catch (const std::exception& exception) { SILK_ERROR << "Stream::run unexpected exception: " << exception.what(); break; } } channel_.close(); // Workaround for Windows build error due to bug https://github.com/chriskohlhoff/asio/issues/1281 #ifdef _WIN32 co_await run_completion_channel_.async_send(boost::system::error_code(), 0, boost::asio::use_awaitable); #endif // _WIN32 SILK_TRACE << "Stream::run total_writes: " << total_writes << " total_bytes_sent: " << total_bytes_sent; } } // namespace silkworm::rpc::json ================================================ FILE: silkworm/rpc/json/stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #ifndef _WIN32 // Workaround for Windows build error due to bug https://github.com/chriskohlhoff/asio/issues/1281 #include #endif // _WIN32 #include #include namespace silkworm::rpc::json { struct DataChunk { std::shared_ptr chunk; bool last{false}; }; //! Stream can be used to send big JSON data split into multiple fragments. class Stream { public: Stream(boost::asio::any_io_executor& executor, StreamWriter& writer, uint64_t request_id, size_t buffer_capacity = 0); Stream(const Stream& stream) = delete; Stream& operator=(const Stream&) = delete; Task open(); //! Flush any remaining data and close properly as per the underlying transport Task close(); void open_object(); void close_object(); void open_array(); void close_array(); void write_json(const nlohmann::json& json); void write_json_field(std::string_view name, const nlohmann::json& value); void write_field(std::string_view name); void write_entry(std::string_view value); void write_field(std::string_view name, std::string_view value); void write_field(std::string_view name, bool value); void write_field(std::string_view name, const char* value); void write_field(std::string_view name, std::int32_t value); void write_field(std::string_view name, std::uint32_t value); void write_field(std::string_view name, std::int64_t value); void write_field(std::string_view name, std::uint64_t value); void write_field(std::string_view name, std::double_t value); void write_field(std::string_view name, evmc::bytes32 value); private: using ChunkPtr = std::shared_ptr; void write_string(std::string_view str); void ensure_separator(); void write(std::string_view str); void do_write(ChunkPtr chunk, bool last); Task do_async_write(ChunkPtr chunk, bool last); //! Run loop writing channeled chunks in order Task run(); StreamWriter& writer_; std::stack stack_; uint64_t request_id_{0}; const size_t buffer_capacity_; std::string buffer_; using ChunkChannel = boost::asio::experimental::concurrent_channel; ChunkChannel channel_; // Chunks enqueued waiting to be written asynchronously // Workaround for Windows build error due to bug https://github.com/chriskohlhoff/asio/issues/1281 #ifndef _WIN32 using RunPromise = boost::asio::experimental::promise; RunPromise run_completion_promise_; // Rendez-vous for run loop completion #else using SyncChannel = boost::asio::experimental::concurrent_channel; SyncChannel run_completion_channel_; // Rendez-vous for run loop completion #endif // _WIN32 }; } // namespace silkworm::rpc::json ================================================ FILE: silkworm/rpc/json/stream_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stream.hpp" #include #include #include #include namespace silkworm::rpc::json { // The following constants *must* be initialized using assignment and *not* uniform initialization syntax static const nlohmann::json kJsonNull = nlohmann::json::value_t::null; static const nlohmann::json kJsonEmptyObject = nlohmann::json::value_t::object; static const nlohmann::json kJsonEmptyArray = nlohmann::json::value_t::array; struct StreamTest : test_util::ServiceContextTestBase { }; TEST_CASE_METHOD(StreamTest, "json::Stream writing JSON", "[rpc][json]") { boost::asio::any_io_executor io_executor = ioc_.get_executor(); StringWriter string_writer; SECTION("write_json in string") { Stream stream(io_executor, string_writer, /* request_id */ 0); nlohmann::json json = R"({ "test": "test" })"_json; stream.write_json(json); spawn_and_wait(stream.close()); // We need double parentheses here: https://github.com/conan-io/conan-center-index/issues/13993 CHECK((string_writer.get_content() == "{\"test\":\"test\"}")); } SECTION("write_json in 1 chunk") { Stream stream(io_executor, string_writer, /* request_id */ 0); nlohmann::json json = R"({ "test": "test" })"_json; stream.write_json(json); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"test\":\"test\"}")); } SECTION("write_json in 2 chunks") { Stream stream(io_executor, string_writer, /* request_id */ 0); nlohmann::json json = R"({ "check": "check", "test": "test" })"_json; stream.write_json(json); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"check\":\"check\",\"test\":\"test\"}")); } } TEST_CASE_METHOD(StreamTest, "json::Stream API", "[rpc][json]") { boost::asio::any_io_executor io_executor = ioc_.get_executor(); StringWriter string_writer; Stream stream(io_executor, string_writer, /* request_id */ 0); SECTION("write_json json") { nlohmann::json json = R"({ "test": "test" })"_json; stream.write_json(json); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"test\":\"test\"}")); } SECTION("empty object 1") { stream.open_object(); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{}")); } SECTION("empty object 2") { stream.write_json(kJsonEmptyObject); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{}")); } SECTION("empty array 1") { stream.open_array(); stream.close_array(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "[]")); } SECTION("empty array 2") { stream.write_json(kJsonEmptyArray); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "[]")); } SECTION("simple object 1") { stream.open_object(); stream.write_json_field("null", kJsonNull); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"null\":null}")); } SECTION("simple object 2") { stream.open_object(); stream.write_json_field("array", kJsonEmptyArray); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"array\":[]}")); } SECTION("simple object 3") { stream.open_object(); stream.write_field("name", "value"); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name\":\"value\"}")); } SECTION("simple object 4") { stream.open_object(); stream.write_field("name1", "value1"); stream.write_field("name2", "value2"); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name1\":\"value1\",\"name2\":\"value2\"}")); } SECTION("complex object 1") { nlohmann::json json = R"({ "test": "test" })"_json; stream.open_object(); stream.write_field("name1", "value1"); stream.write_json_field("name2", json); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name1\":\"value1\",\"name2\":{\"test\":\"test\"}}")); } SECTION("complex object 2") { nlohmann::json json = R"([ "one", "two" ])"_json; stream.open_object(); stream.write_field("name1", "value1"); stream.write_json_field("name2", json); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name1\":\"value1\",\"name2\":[\"one\",\"two\"]}")); } SECTION("complex object 3") { nlohmann::json json = R"({ "test": "test" })"_json; stream.open_object(); stream.write_field("name1", "value1"); stream.write_field("name2"); stream.open_array(); stream.write_json(json); stream.close_array(); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name1\":\"value1\",\"name2\":[{\"test\":\"test\"}]}")); } SECTION("complex object 4") { nlohmann::json json_obj = R"({ "test": "test" })"_json; nlohmann::json json_array = R"([ "one", "two" ])"_json; stream.open_object(); stream.write_json_field("name1", json_obj); stream.write_json_field("name2", json_array); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name1\":{\"test\":\"test\"},\"name2\":[\"one\",\"two\"]}")); } SECTION("complex object 5") { nlohmann::json json_obj = R"({ "numeric": 1, "boolean": true })"_json; nlohmann::json json_array = R"([ "1.2", "3.4" ])"_json; stream.open_object(); stream.write_json_field("name1", json_obj); stream.write_json_field("name2", json_array); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name1\":{\"boolean\":true,\"numeric\":1},\"name2\":[\"1.2\",\"3.4\"]}")); } SECTION("complex object 6") { nlohmann::json json_obj = R"({ "numeric": 1, "boolean": true })"_json; stream.open_object(); stream.write_field("name1", "name1"); stream.write_field("name2"); stream.open_array(); stream.write_json(json_obj); stream.write_json(json_obj); stream.close_array(); stream.write_field("name3", "name3"); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"name1\":\"name1\",\"name2\":[{\"boolean\":true,\"numeric\":1},{\"boolean\":true,\"numeric\":1}],\"name3\":\"name3\"}")); } SECTION("complex object 7") { stream.open_object(); stream.write_field("numeric", 10); stream.write_field("double", 10.3); stream.write_field("boolean", true); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"numeric\":10,\"double\":10.3,\"boolean\":true}")); } SECTION("complex object 8") { stream.open_object(); stream.write_field("result"); stream.open_array(); stream.open_object(); stream.write_field("item", 1); stream.write_field("logs"); stream.open_array(); stream.open_object(); stream.write_field("item", 1.1); stream.close_object(); stream.close_array(); stream.close_object(); stream.open_object(); stream.write_field("item", 2); stream.write_field("logs"); stream.open_array(); stream.open_object(); stream.write_field("item", 2.1); stream.close_object(); stream.close_array(); stream.close_object(); stream.close_array(); stream.close_object(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "{\"result\":[{\"item\":1,\"logs\":[{\"item\":1.1}]},{\"item\":2,\"logs\":[{\"item\":2.1}]}]}")); } SECTION("simple array 1") { nlohmann::json json = R"({ "test": "test" })"_json; stream.open_array(); stream.write_json(json); stream.close_array(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "[{\"test\":\"test\"}]")); } SECTION("simple array 2") { nlohmann::json json = R"({ "test": "test" })"_json; stream.open_array(); stream.write_json(json); stream.write_json(json); stream.close_array(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "[{\"test\":\"test\"},{\"test\":\"test\"}]")); } SECTION("simple array 3") { stream.open_array(); stream.write_json(10); stream.write_json(10.3); stream.write_json(true); stream.close_array(); spawn_and_wait(stream.close()); CHECK((string_writer.get_content() == "[10,10.3,true]")); } } TEST_CASE_METHOD(StreamTest, "json::Stream threading", "[rpc][json]") { boost::asio::any_io_executor io_executor = ioc_.get_executor(); constexpr std::string_view kData{R"({"test":"test"})"}; StringWriter string_writer; Stream stream(io_executor, string_writer, /* request_id */ 0, 1); // tiny buffer capacity const nlohmann::json json = R"({"test":"test"})"_json; SECTION("using I/O context thread") { stream.write_json(json); CHECK_NOTHROW(spawn_and_wait(stream.close())); CHECK((string_writer.get_content() == kData)); } SECTION("using worker thread") { WorkerPool workers; boost::asio::post(workers, [&]() { for (int i{0}; i < 1'000; ++i) { stream.write_json(json); } }); workers.join(); CHECK_NOTHROW(spawn_and_wait(stream.close())); CHECK(string_writer.get_content().size() == kData.size() * 1'000); } } } // namespace silkworm::rpc::json ================================================ FILE: silkworm/rpc/json/transaction.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction.hpp" #include #include #include namespace silkworm { void to_json(nlohmann::json& json, const Transaction& transaction) { if (const std::optional sender{transaction.sender()}; sender) { json["from"] = *sender; } json["gas"] = rpc::to_quantity(transaction.gas_limit); json["hash"] = transaction.hash(); json["input"] = "0x" + silkworm::to_hex(transaction.data); json["nonce"] = rpc::to_quantity(transaction.nonce); if (transaction.to) { json["to"] = transaction.to.value(); } else { json["to"] = nullptr; } json["type"] = rpc::to_quantity(static_cast(transaction.type)); if (transaction.type == silkworm::TransactionType::kDynamicFee || transaction.type == silkworm::TransactionType::kBlob || transaction.type == silkworm::TransactionType::kSetCode) { json["maxPriorityFeePerGas"] = rpc::to_quantity(transaction.max_priority_fee_per_gas); json["maxFeePerGas"] = rpc::to_quantity(transaction.max_fee_per_gas); } if (transaction.type != silkworm::TransactionType::kLegacy) { json["chainId"] = rpc::to_quantity(*transaction.chain_id); json["v"] = rpc::to_quantity(uint64_t{transaction.odd_y_parity}); json["accessList"] = transaction.access_list; // EIP2930 json["yParity"] = rpc::to_quantity(transaction.odd_y_parity); } else if (transaction.chain_id) { json["chainId"] = rpc::to_quantity(*transaction.chain_id); json["v"] = rpc::to_quantity(silkworm::endian::to_big_compact(transaction.v())); } else { json["v"] = rpc::to_quantity(silkworm::endian::to_big_compact(transaction.v())); } if (transaction.type == TransactionType::kSetCode) { json["authorizations"] = transaction.authorizations; // EIP7702 } json["value"] = rpc::to_quantity(transaction.value); json["r"] = rpc::to_quantity(silkworm::endian::to_big_compact(transaction.r)); json["s"] = rpc::to_quantity(silkworm::endian::to_big_compact(transaction.s)); } } // namespace silkworm namespace silkworm::rpc { void make_glaze_json_transaction(const silkworm::Transaction& tx, GlazeJsonTransaction& json_tx) { if (const std::optional sender{tx.sender()}; sender) { to_hex(std::span(json_tx.from), sender->bytes); } if (tx.to) { json_tx.to = std::make_optional("0x" + silkworm::to_hex(tx.to.value().bytes)); } else { std::monostate null_value{}; json_tx.nullto = std::make_optional(null_value); } to_quantity(std::span(json_tx.gas), tx.gas_limit); to_hex(std::span(json_tx.hash), tx.hash().bytes); json_tx.input.reserve(tx.data.size() * 2 + 3); json_tx.input = "0x" + silkworm::to_hex(tx.data); to_quantity(std::span(json_tx.nonce), tx.nonce); to_quantity(std::span(json_tx.type), static_cast(tx.type)); if (tx.type != silkworm::TransactionType::kLegacy) { json_tx.chain_id = std::make_optional(to_quantity(*tx.chain_id)); to_quantity(std::span(json_tx.v), uint64_t{tx.odd_y_parity}); std::vector glaze_access_list; glaze_access_list.reserve(tx.access_list.size()); for (const auto& access_list : tx.access_list) { GlazeJsonAccessList access_list_json_tx; to_hex(std::span(access_list_json_tx.address), access_list.account.bytes); for (const auto& storage_key : access_list.storage_keys) { auto key_hash = silkworm::to_bytes32({storage_key.bytes, silkworm::kHashLength}); access_list_json_tx.storage_keys.push_back("0x" + silkworm::to_hex(key_hash.bytes)); } glaze_access_list.push_back(std::move(access_list_json_tx)); } json_tx.access_list = std::make_optional(std::move(glaze_access_list)); json_tx.yparity = std::make_optional(rpc::to_quantity(tx.odd_y_parity)); } else if (tx.chain_id) { json_tx.chain_id = std::make_optional(to_quantity(*tx.chain_id)); to_quantity(std::span(json_tx.v), silkworm::endian::to_big_compact(tx.v())); } else { rpc::to_quantity(std::span(json_tx.v), silkworm::endian::to_big_compact(tx.v())); } if (tx.type == silkworm::TransactionType::kDynamicFee || tx.type == silkworm::TransactionType::kBlob || tx.type == silkworm::TransactionType::kSetCode) { json_tx.max_pri_fee_per_gas = std::make_optional(rpc::to_quantity(tx.max_priority_fee_per_gas)); json_tx.max_fee_per_gas = std::make_optional(rpc::to_quantity(tx.max_fee_per_gas)); } if (tx.type == silkworm::TransactionType::kBlob) { json_tx.max_fee_per_blob_gas = std::make_optional(rpc::to_quantity(tx.max_fee_per_blob_gas)); std::vector hashes; for (const auto& curr_hash : tx.blob_versioned_hashes) { auto hash = silkworm::to_hex(curr_hash.bytes, /* with_prefix = */ true); hashes.push_back(hash); } json_tx.blob_versioned_hashes = std::make_optional(hashes); } if (tx.type == silkworm::TransactionType::kSetCode) { std::vector glaze_authorizations; glaze_authorizations.reserve(tx.authorizations.size()); for (const auto& authorization : tx.authorizations) { GlazeJsonAuthorization authorization_json_tx; to_quantity(std::span(authorization_json_tx.chain_id), silkworm::endian::to_big_compact(authorization.chain_id)); to_hex(std::span(authorization_json_tx.address), authorization.address.bytes); to_quantity(std::span(authorization_json_tx.y_parity), silkworm::endian::to_big_compact(authorization.y_parity)); to_quantity(std::span(authorization_json_tx.r), silkworm::endian::to_big_compact(authorization.r)); to_quantity(std::span(authorization_json_tx.s), silkworm::endian::to_big_compact(authorization.s)); glaze_authorizations.push_back(std::move(authorization_json_tx)); } json_tx.authorizations = std::make_optional(std::move(glaze_authorizations)); } to_quantity(std::span(json_tx.value), tx.value); to_quantity(std::span(json_tx.r), silkworm::endian::to_big_compact(tx.r)); to_quantity(std::span(json_tx.s), silkworm::endian::to_big_compact(tx.s)); } struct GlazeJsonTransactionReply { std::string_view jsonrpc = kJsonVersion; JsonRpcId id; GlazeJsonTransaction result; struct glaze { using T = GlazeJsonTransactionReply; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "jsonrpc", &T::jsonrpc, "id", &T::id, "result", &T::result); }; }; void make_glaze_json_content(const nlohmann::json& request_json, const Transaction& tx, std::string& json_reply) { GlazeJsonTransactionReply tx_json_data{}; tx_json_data.id = make_jsonrpc_id(request_json); to_quantity(std::span(tx_json_data.result.transaction_index), tx.transaction_index); to_quantity(std::span(tx_json_data.result.block_num), tx.block_num); to_hex(std::span(tx_json_data.result.block_hash), tx.block_hash.bytes); to_quantity(std::span(tx_json_data.result.gas_price), tx.effective_gas_price()); make_glaze_json_transaction(tx, tx_json_data.result); glz::write_json(tx_json_data, json_reply); } void to_json(nlohmann::json& json, const Transaction& transaction) { to_json(json, static_cast(transaction)); json["gasPrice"] = to_quantity(transaction.effective_gas_price()); if (transaction.queued_in_pool) { json["blockHash"] = nullptr; json["blockNumber"] = nullptr; json["transactionIndex"] = nullptr; } else { json["blockHash"] = transaction.block_hash; json["blockNumber"] = to_quantity(transaction.block_num); json["transactionIndex"] = to_quantity(transaction.transaction_index); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm { void to_json(nlohmann::json& json, const Transaction& transaction); } // namespace silkworm namespace silkworm::rpc { struct GlazeJsonTransaction { char from[kAddressHexSize]; char gas[kInt64HexSize]; char hash[kHashHexSize]; char nonce[kInt64HexSize]; char value[kInt256HexSize]; char type[kInt64HexSize]; char v[kInt256HexSize]; char r[kInt256HexSize]; char s[kInt256HexSize]; char transaction_index[kInt64HexSize]; char block_hash[kHashHexSize]; char block_num[kInt64HexSize]; char gas_price[kInt64HexSize]; std::string input; std::optional yparity; std::optional chain_id; std::optional max_fee_per_gas; std::optional max_pri_fee_per_gas; std::optional max_fee_per_blob_gas; std::optional to; std::optional nullto; std::optional> access_list; std::optional> blob_versioned_hashes; std::optional> authorizations; struct glaze { using T = GlazeJsonTransaction; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "from", &T::from, "gas", &T::gas, "hash", &T::hash, "input", &T::input, "nonce", &T::nonce, "yParity", &T::yparity, "chainId", &T::chain_id, "maxPriorityFeePerGas", &T::max_pri_fee_per_gas, "maxFeePerGas", &T::max_fee_per_gas, "maxFeePerBlobGas", &T::max_fee_per_blob_gas, "blobVersionedHashes", &T::blob_versioned_hashes, "accessList", &T::access_list, "to", &T::to, "to", &T::nullto, "value", &T::value, "type", &T::type, "v", &T::v, "r", &T::r, "s", &T::s, "transactionIndex", &T::transaction_index, "blockHash", &T::block_hash, "blockNumber", &T::block_num, "gasPrice", &T::gas_price, "authorizations", &T::authorizations); }; }; void to_json(nlohmann::json& json, const Transaction& transaction); void make_glaze_json_transaction(const silkworm::Transaction& tx, GlazeJsonTransaction& json_tx); void make_glaze_json_content(const nlohmann::json& request_json, const Transaction& tx, std::string& json_reply); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/transaction_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction.hpp" #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("serialize empty transaction", "[rpc][to_json]") { silkworm::Transaction txn{}; nlohmann::json j = txn; CHECK(j == R"({ "nonce":"0x0", "gas":"0x0", "to":null, "type":"0x0", "value":"0x0", "input":"0x", "hash":"0x3763e4f6e4198413383534c763f3f5dac5c5e939f0a81724e3beb96d6e2ad0d5", "r":"0x0", "s":"0x0", "v":"0x1b" })"_json); } TEST_CASE("serialize legacy transaction (type=0)", "[rpc][to_json]") { // https://etherscan.io/tx/0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060 // Block 46147 silkworm::Transaction txn1{}; txn1.type = TransactionType::kLegacy; txn1.nonce = 0; txn1.max_priority_fee_per_gas = 50'000 * kGiga; txn1.max_fee_per_gas = 50'000 * kGiga; txn1.gas_limit = 21'000; txn1.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn1.value = 31337; txn1.odd_y_parity = true; txn1.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn1.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); nlohmann::json j1 = txn1; CHECK(j1 == R"({ "from":"0xa1e4380a3b1f749673e270229993ee55f35663b4", "gas":"0x5208", "hash":"0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060", "input":"0x", "nonce":"0x0", "r":"0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0", "s":"0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a", "to":"0x5df9b87991262f6ba471f09758cde1c0fc1de734", "type":"0x0", "v":"0x1c", "value":"0x7a69" })"_json); silkworm::rpc::Transaction txn2{}; txn2.type = TransactionType::kLegacy; txn2.nonce = 0; txn2.max_priority_fee_per_gas = 50'000 * kGiga; txn2.max_fee_per_gas = 50'000 * kGiga; txn2.gas_limit = 21'000; txn2.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn2.value = 31337; txn2.odd_y_parity = true; txn2.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn2.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn2.set_sender(0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); txn2.block_hash = 0x4e3a3754410177e6937ef1f84bba68ea139e8d1a2258c5f85db9f1cd715a1bdd_bytes32; txn2.block_num = 46147; txn2.block_base_fee_per_gas = intx::uint256{0}; txn2.transaction_index = 0; nlohmann::json j2 = txn2; CHECK(j2 == R"({ "blockHash":"0x4e3a3754410177e6937ef1f84bba68ea139e8d1a2258c5f85db9f1cd715a1bdd", "blockNumber":"0xb443", "from":"0x007fb8417eb9ad4d958b050fc3720d5b46a2c053", "gas":"0x5208", "gasPrice":"0x2d79883d2000", "hash":"0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060", "input":"0x", "nonce":"0x0", "r":"0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0", "s":"0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a", "to":"0x5df9b87991262f6ba471f09758cde1c0fc1de734", "transactionIndex":"0x0", "type":"0x0", "v":"0x1c", "value":"0x7a69" })"_json); silkworm::rpc::Transaction txn3{}; txn3.type = TransactionType::kLegacy; txn3.nonce = 0; txn3.max_priority_fee_per_gas = 50'000 * kGiga; txn3.max_fee_per_gas = 50'000 * kGiga; txn3.gas_limit = 21'000; txn3.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn3.value = 31337; txn3.odd_y_parity = true; txn3.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn3.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn3.set_sender(0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); txn3.block_hash = 0x4e3a3754410177e6937ef1f84bba68ea139e8d1a2258c5f85db9f1cd715a1bdd_bytes32; txn3.block_num = 46147; txn3.block_base_fee_per_gas = intx::uint256{0}; txn3.transaction_index = 0; txn3.queued_in_pool = true; nlohmann::json j3 = txn3; CHECK(j3 == R"({ "blockHash":null, "blockNumber":null, "from":"0x007fb8417eb9ad4d958b050fc3720d5b46a2c053", "gas":"0x5208", "gasPrice":"0x2d79883d2000", "hash":"0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060", "input":"0x", "nonce":"0x0", "r":"0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0", "s":"0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a", "to":"0x5df9b87991262f6ba471f09758cde1c0fc1de734", "transactionIndex":null, "type":"0x0", "v":"0x1c", "value":"0x7a69" })"_json); } TEST_CASE("serialize EIP-2930 transaction (type=1)", "[rpc][to_json]") { silkworm::Transaction txn1{}; txn1.type = TransactionType::kAccessList; txn1.chain_id = 1; txn1.nonce = 0; txn1.max_priority_fee_per_gas = 20000000000; txn1.max_fee_per_gas = 20000000000; txn1.gas_limit = 0; txn1.to = 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address; txn1.value = 0; txn1.data = *from_hex("001122aabbcc"); txn1.odd_y_parity = false; txn1.r = 18; txn1.s = 36; txn1.set_sender(0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); nlohmann::json j1 = txn1; CHECK(j1 == R"({ "nonce":"0x0", "chainId":"0x1", "yParity":"0x0", "gas":"0x0", "to":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "from":"0x007fb8417eb9ad4d958b050fc3720d5b46a2c053", "type":"0x1", "value":"0x0", "input":"0x001122aabbcc", "hash":"0xe976a1c7600ed37c7aeea9b34de01b2424a68a4c9dfb0a0315a3db3cd9975512", "accessList":[], "r":"0x12", "s":"0x24", "v":"0x0" })"_json); std::vector access_list{ {0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae_address, { 0x0000000000000000000000000000000000000000000000000000000000000003_bytes32, 0x0000000000000000000000000000000000000000000000000000000000000007_bytes32, }}, {0xbb9bc244d798123fde783fcc1c72d3bb8c189413_address, {}}, }; silkworm::rpc::Transaction txn2{}; txn2.type = TransactionType::kAccessList; txn2.chain_id = 1; txn2.nonce = 0; txn2.max_priority_fee_per_gas = 20000000000; txn2.max_fee_per_gas = 30000000000; txn2.gas_limit = 0; txn2.to = 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address; txn2.value = 0; txn2.data = *from_hex("001122aabbcc"); txn2.access_list = access_list; txn2.odd_y_parity = false; txn2.r = 18; txn2.s = 36; txn2.set_sender(0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); txn2.block_hash = 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32; txn2.block_num = 123123; txn2.block_base_fee_per_gas = intx::uint256{12}; txn2.transaction_index = 3; nlohmann::json j2 = txn2; CHECK(j2 == R"({ "nonce":"0x0", "gasPrice":"0x4a817c80c", "chainId":"0x1", "yParity":"0x0", "gas":"0x0", "to":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "from":"0x007fb8417eb9ad4d958b050fc3720d5b46a2c053", "type":"0x1", "value":"0x0", "input":"0x001122aabbcc", "hash":"0xae1aea7493cc9a029710b601f62538993ebc6281ac63a241b83a218bd060b291", "r":"0x12", "s":"0x24", "v":"0x0", "blockHash":"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c", "blockNumber":"0x1e0f3", "transactionIndex":"0x3", "accessList":[ { "address":"0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae", "storageKeys":[ "0x0000000000000000000000000000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000000000000000000000000000007" ] }, { "address":"0xbb9bc244d798123fde783fcc1c72d3bb8c189413", "storageKeys":[] } ] })"_json); } TEST_CASE("serialize EIP-1559 transaction (type=2)", "[rpc][to_json]") { silkworm::Transaction txn1{}; txn1.type = TransactionType::kDynamicFee; txn1.chain_id = 1; txn1.nonce = 0; txn1.max_priority_fee_per_gas = 50'000 * kGiga; txn1.max_fee_per_gas = 50'000 * kGiga; txn1.gas_limit = 21'000; txn1.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn1.value = 31337; txn1.data = *from_hex("001122aabbcc"); txn1.odd_y_parity = true; txn1.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn1.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn1.set_sender(0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); nlohmann::json j1 = txn1; CHECK(j1 == R"({ "nonce":"0x0", "chainId":"0x1", "yParity":"0x1", "gas":"0x5208", "to":"0x5df9b87991262f6ba471f09758cde1c0fc1de734", "from":"0x007fb8417eb9ad4d958b050fc3720d5b46a2c053", "type":"0x2", "value":"0x7a69", "input":"0x001122aabbcc", "hash":"0x64ab530a48c64d248b85dd6952539cae03cad7a001ed32ba5d358aca20eef0a8", "accessList":[], "r":"0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0", "s":"0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a", "v":"0x1", "maxPriorityFeePerGas":"0x2d79883d2000", "maxFeePerGas":"0x2d79883d2000" })"_json); } TEST_CASE("serialize EIP-7702 transaction (type=4)", "[rpc][to_json]") { silkworm::Transaction txn1{}; txn1.type = TransactionType::kSetCode; txn1.chain_id = 1; txn1.nonce = 0; txn1.max_priority_fee_per_gas = 50'000 * kGiga; txn1.max_fee_per_gas = 50'000 * kGiga; txn1.gas_limit = 21'000; txn1.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn1.value = 31337; txn1.data = *from_hex("001122aabbcc"); txn1.odd_y_parity = true; txn1.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn1.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn1.set_sender(0x007fb8417eb9ad4d958b050fc3720d5b46a2c053_address); txn1.authorizations.emplace_back(Authorization{ .chain_id = 100, .address = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address, .y_parity = 27, .r = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"), .s = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0")}); nlohmann::json j1 = txn1; CHECK(j1 == R"({ "nonce":"0x0", "chainId":"0x1", "yParity":"0x1", "gas":"0x5208", "to":"0x5df9b87991262f6ba471f09758cde1c0fc1de734", "from":"0x007fb8417eb9ad4d958b050fc3720d5b46a2c053", "type":"0x4", "value":"0x7a69", "input":"0x001122aabbcc", "hash":"0x89628f3eefc44a2e120e12ca39c72065cf3552ad3e3d42f1727c09b4fc0f33d6", "accessList":[], "r":"0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0", "s":"0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a", "v":"0x1", "maxPriorityFeePerGas":"0x2d79883d2000", "maxFeePerGas":"0x2d79883d2000", "authorizations":[ { "chainId":"0x64", "address":"0x5df9b87991262f6ba471f09758cde1c0fc1de734", "yParity":"0x1b", "r":"0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a", "s":"0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0" } ] })"_json); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/transition_configuration.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transition_configuration.hpp" #include "types.hpp" namespace silkworm::rpc { void to_json(nlohmann::json& json, const TransitionConfiguration& transition_configuration) { json["terminalTotalDifficulty"] = to_quantity(transition_configuration.terminal_total_difficulty); json["terminalBlockHash"] = transition_configuration.terminal_block_hash; json["terminalBlockNumber"] = to_quantity(transition_configuration.terminal_block_num); } void from_json(const nlohmann::json& json, TransitionConfiguration& transition_configuration) { transition_configuration = TransitionConfiguration{ .terminal_total_difficulty = json.at("terminalTotalDifficulty").get(), .terminal_block_hash = json.at("terminalBlockHash").get(), .terminal_block_num = static_cast(std::stol(json.at("terminalBlockNumber").get(), nullptr, 16))}; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/transition_configuration.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { void to_json(nlohmann::json& json, const TransitionConfiguration& transition_configuration); void from_json(const nlohmann::json& json, TransitionConfiguration& transition_configuration); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/transition_configuration_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transition_configuration.hpp" #include #include namespace silkworm::rpc { using evmc::literals::operator""_bytes32; TEST_CASE("serialize TransitionConfigurationV1", "[silkworm::json][to_json]") { TransitionConfiguration transition_configuration{ .terminal_total_difficulty = 0xf4240, .terminal_block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .terminal_block_num = 0x0}; nlohmann::json j = transition_configuration; CHECK(j["terminalTotalDifficulty"] == "0xf4240"); CHECK(j["terminalBlockHash"] == "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858"); CHECK(j["terminalBlockNumber"] == "0x0"); } TEST_CASE("deserialize TransitionConfigurationV1", "[silkworm::json][from_json]") { TransitionConfiguration actual_transition_configuration = R"({ "terminalTotalDifficulty":"0xf4240", "terminalBlockHash":"0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "terminalBlockNumber":"0x0" })"_json; TransitionConfiguration expected_transition_configuration{ .terminal_total_difficulty = 0xf4240, .terminal_block_hash = 0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858_bytes32, .terminal_block_num = 0x0}; CHECK(actual_transition_configuration.terminal_total_difficulty == expected_transition_configuration.terminal_total_difficulty); CHECK(actual_transition_configuration.terminal_block_hash == expected_transition_configuration.terminal_block_hash); CHECK(actual_transition_configuration.terminal_block_num == expected_transition_configuration.terminal_block_num); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/types.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "types.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { void to_hex(std::span hex_bytes, silkworm::ByteView bytes) { static constexpr std::string_view kHexDigits{"0123456789abcdef"}; if (bytes.size() * 2 + 2 + 1 > hex_bytes.size()) { SILK_ERROR << "req buffer length: " << bytes.size() * 2 + 2 + 1 << " buffer length: " << hex_bytes.size() << "\n"; throw std::invalid_argument("to_hex: hex_bytes too small"); } char* dest = hex_bytes.data(); *dest++ = '0'; *dest++ = 'x'; for (const auto& b : bytes) { *dest++ = kHexDigits[b >> 4]; // Hi *dest++ = kHexDigits[b & 0x0f]; // Lo } *dest = '\0'; } void to_hex_no_leading_zeros(std::span hex_bytes, silkworm::ByteView bytes) { static constexpr std::string_view kHexDigits{"0123456789abcdef"}; size_t len = bytes.size(); if (len * 2 + 2 + 1 > hex_bytes.size()) { SILK_ERROR << "req buffer length: " << len * 2 + 2 + 1 << " buffer length: " << hex_bytes.size() << "\n"; throw std::invalid_argument("to_hex_no_leading_zeros: hex_bytes too small"); } char* dest = hex_bytes.data(); *dest++ = '0'; *dest++ = 'x'; bool found_nonzero{false}; for (size_t i{0}; i < len; ++i) { auto x{bytes[i]}; char lo{kHexDigits[x & 0x0f]}; char hi{kHexDigits[x >> 4]}; if (!found_nonzero && hi != '0') { found_nonzero = true; } if (found_nonzero) { *dest++ = hi; } if (!found_nonzero && lo != '0') { found_nonzero = true; } if (found_nonzero || i == len - 1) { *dest++ = lo; } } *dest = '\0'; } void to_quantity(std::span quantity_hex_bytes, silkworm::ByteView bytes) { to_hex_no_leading_zeros(quantity_hex_bytes, bytes); } void to_quantity(std::span quantity_hex_bytes, BlockNum block_num) { silkworm::Bytes block_num_bytes(8, '\0'); silkworm::endian::store_big_u64(block_num_bytes.data(), block_num); to_hex_no_leading_zeros(quantity_hex_bytes, block_num_bytes); } void to_quantity(std::span quantity_hex_bytes, intx::uint256 number) { if (number == 0) { quantity_hex_bytes[0] = '0'; quantity_hex_bytes[1] = 'x'; quantity_hex_bytes[2] = '0'; quantity_hex_bytes[3] = '\0'; return; } to_quantity(quantity_hex_bytes, silkworm::endian::to_big_compact(number)); } std::string to_hex_no_leading_zeros(silkworm::ByteView bytes) { static constexpr std::string_view kHexDigits{"0123456789abcdef"}; std::string out{}; if (bytes.empty()) { out.reserve(1); out.push_back('0'); return out; } out.reserve(2 * bytes.size()); bool found_nonzero{false}; for (size_t i{0}; i < bytes.size(); ++i) { uint8_t x{bytes[i]}; char lo{kHexDigits[x & 0x0f]}; char hi{kHexDigits[x >> 4]}; if (!found_nonzero && hi != '0') { found_nonzero = true; } if (found_nonzero) { out.push_back(hi); } if (!found_nonzero && lo != '0') { found_nonzero = true; } if (found_nonzero || i == bytes.size() - 1) { out.push_back(lo); } } return out; } uint64_t from_quantity(const std::string& hex_quantity) { return std::stoul(hex_quantity, nullptr, 16); } std::string to_hex(uint64_t number) { silkworm::Bytes number_bytes(8, '\0'); endian::store_big_u64(&number_bytes[0], number); return silkworm::to_hex(number_bytes, /*with_prefix=*/true); } std::string to_hex_no_leading_zeros(uint64_t number) { silkworm::Bytes number_bytes(8, '\0'); endian::store_big_u64(&number_bytes[0], number); return to_hex_no_leading_zeros(number_bytes); } std::string to_quantity(silkworm::ByteView bytes) { return "0x" + to_hex_no_leading_zeros(bytes); } std::string to_quantity(const evmc::bytes32& bytes) { return to_quantity(silkworm::ByteView{bytes.bytes}); } std::string to_quantity(uint64_t number) { return "0x" + to_hex_no_leading_zeros(number); } std::string to_quantity(const intx::uint256& number) { if (number == 0) { return "0x0"; } return to_quantity(silkworm::endian::to_big_compact(number)); } } // namespace silkworm::rpc namespace evmc { void to_json(nlohmann::json& json, const address& addr) { json = silkworm::address_to_hex(addr); } void from_json(const nlohmann::json& json, address& addr) { addr = silkworm::hex_to_address(json.get(), /*return_zero_on_err=*/true); } void to_json(nlohmann::json& json, const bytes32& b32) { json = silkworm::to_hex(b32, true); } void from_json(const nlohmann::json& json, bytes32& b32) { const auto b32_bytes = silkworm::from_hex(json.get()); b32 = silkworm::to_bytes32(b32_bytes.value_or(silkworm::Bytes{})); } } // namespace evmc namespace intx { void from_json(const nlohmann::json& json, uint256& ui256) { ui256 = intx::from_string(json.get()); } } // namespace intx namespace silkworm { void to_json(nlohmann::json& json, const BlockHeader& header) { const auto block_num = rpc::to_quantity(header.number); json["number"] = block_num; json["hash"] = rpc::to_quantity(header.hash()); json["parentHash"] = header.parent_hash; json["nonce"] = "0x" + silkworm::to_hex({header.nonce.data(), header.nonce.size()}); json["sha3Uncles"] = header.ommers_hash; json["logsBloom"] = "0x" + silkworm::to_hex(silkworm::full_view(header.logs_bloom)); json["transactionsRoot"] = header.transactions_root; json["stateRoot"] = header.state_root; json["receiptsRoot"] = header.receipts_root; json["miner"] = header.beneficiary; json["difficulty"] = rpc::to_quantity(silkworm::endian::to_big_compact(header.difficulty)); json["extraData"] = "0x" + silkworm::to_hex(header.extra_data); json["mixHash"] = header.prev_randao; json["gasLimit"] = rpc::to_quantity(header.gas_limit); json["gasUsed"] = rpc::to_quantity(header.gas_used); json["timestamp"] = rpc::to_quantity(header.timestamp); if (header.base_fee_per_gas) { json["baseFeePerGas"] = rpc::to_quantity(header.base_fee_per_gas.value_or(0)); } else { json["baseFeePerGas"] = nullptr; } if (rpc::compatibility::is_erigon_json_api_compatibility_required()) { json["AuRaSeal"] = nullptr; json["AuRaStep"] = 0; json["Verkle"] = false; json["VerkleKeyVals"] = nullptr; json["VerkleProof"] = nullptr; json["requestsHash"] = nullptr; } if (header.blob_gas_used) { json["blobGasUsed"] = rpc::to_quantity(*header.blob_gas_used); } else { json["blobGasUsed"] = nullptr; } if (header.excess_blob_gas) { json["excessBlobGas"] = rpc::to_quantity(*header.excess_blob_gas); } else { json["excessBlobGas"] = nullptr; } if (header.parent_beacon_block_root) { json["parentBeaconBlockRoot"] = "0x" + to_hex(*header.parent_beacon_block_root); } else { json["parentBeaconBlockRoot"] = nullptr; } if (header.withdrawals_root) { json["withdrawalsRoot"] = *header.withdrawals_root; } else { json["withdrawalsRoot"] = nullptr; } if (header.requests_hash) { json["requestsHash"] = "0x" + to_hex(*header.requests_hash); } else { json["requestsHash"] = nullptr; } } } // namespace silkworm namespace silkworm::rpc { void to_json(nlohmann::json& json, const ChainTraffic& chain_traffic) { json["cumulativeGasUsed"] = to_quantity(chain_traffic.cumulative_gas_used); json["cumulativeTransactionsCount"] = to_quantity(chain_traffic.cumulative_transactions_count); } void to_json(nlohmann::json& json, const StageData& stage_data) { json["stage_name"] = stage_data.stage_name; json["block_number"] = stage_data.block_num; } void to_json(nlohmann::json& json, const SyncingData& syncing_data) { json["currentBlock"] = syncing_data.current_block; json["highestBlock"] = syncing_data.max_block; json["stages"] = syncing_data.stages; } void to_json(nlohmann::json& json, const struct TxPoolStatusInfo& status_info) { json["queued"] = to_quantity(status_info.queued); json["pending"] = to_quantity(status_info.pending); json["baseFee"] = to_quantity(status_info.base_fee); } void to_json(nlohmann::json& json, const Rlp& rlp) { json = "0x" + silkworm::to_hex(rlp.buffer); } void to_json(nlohmann::json& json, const PeerInfo& info) { json["id"] = info.id; json["name"] = info.name; json["enode"] = info.enode; if (!info.enr.empty()) { json["enr"] = info.enr; } json["caps"] = info.caps; json["network"]["localAddress"] = info.local_address; json["network"]["remoteAddress"] = info.remote_address; json["network"]["inbound"] = info.is_connection_inbound; json["network"]["static"] = info.is_connection_static; json["network"]["trusted"] = info.is_connection_trusted; json["protocols"] = nullptr; } void to_json(nlohmann::json& json, const AccessListResult& access_list_result) { json["accessList"] = access_list_result.access_list; if (access_list_result.error) { json["error"] = *(access_list_result.error); } json["gasUsed"] = to_quantity(access_list_result.gas_used); } void to_json(nlohmann::json& json, const BlockDetailsResponse& b) { const auto block_num = to_quantity(b.block.header.number); json["block"]["number"] = block_num; json["block"]["difficulty"] = to_quantity(silkworm::endian::to_big_compact(b.block.header.difficulty)); json["block"]["extraData"] = "0x" + silkworm::to_hex(b.block.header.extra_data); json["block"]["gasLimit"] = to_quantity(b.block.header.gas_limit); json["block"]["gasUsed"] = to_quantity(b.block.header.gas_used); json["block"]["hash"] = b.block.hash; json["block"]["logsBloom"] = nullptr; json["block"]["miner"] = b.block.header.beneficiary; json["block"]["mixHash"] = b.block.header.prev_randao; json["block"]["nonce"] = "0x" + silkworm::to_hex({b.block.header.nonce.data(), b.block.header.nonce.size()}); json["block"]["parentHash"] = b.block.header.parent_hash; json["block"]["receiptsRoot"] = b.block.header.receipts_root; json["block"]["sha3Uncles"] = b.block.header.ommers_hash; json["block"]["size"] = to_quantity(b.block.block_size); json["block"]["stateRoot"] = b.block.header.state_root; json["block"]["timestamp"] = to_quantity(b.block.header.timestamp); json["block"]["transactionCount"] = b.block.transaction_count; // to_quantity(b.block.transaction_count); json["block"]["transactionsRoot"] = b.block.header.transactions_root; if (b.block.header.base_fee_per_gas.has_value()) { json["block"]["baseFeePerGas"] = rpc::to_quantity(b.block.header.base_fee_per_gas.value_or(0)); } std::vector ommer_hashes; ommer_hashes.reserve(b.block.ommers.size()); for (size_t i{0}; i < b.block.ommers.size(); ++i) { ommer_hashes.emplace(ommer_hashes.end(), b.block.ommers[i].hash()); SILK_DEBUG << "ommer_hashes[" << i << "]: " << silkworm::to_hex({ommer_hashes[i].bytes, silkworm::kHashLength}); } json["block"]["uncles"] = ommer_hashes; if (b.issuance.total_reward > 0) { json["issuance"]["issuance"] = to_quantity(b.issuance.miner_reward); json["issuance"]["uncleReward"] = to_quantity(b.issuance.ommers_reward); json["issuance"]["blockReward"] = to_quantity(b.issuance.total_reward); } else { json["issuance"]["issuance"] = "0x0"; json["issuance"]["uncleReward"] = "0x0"; json["issuance"]["blockReward"] = "0x0"; } json["totalFees"] = to_quantity(b.total_fees); if (b.block.header.blob_gas_used) { json["block"]["blobGasUsed"] = rpc::to_quantity(*b.block.header.blob_gas_used); } if (b.block.header.excess_blob_gas) { json["block"]["excessBlobGas"] = rpc::to_quantity(*b.block.header.excess_blob_gas); } if (b.block.header.parent_beacon_block_root) { json["block"]["parentBeaconBlockRoot"] = "0x" + silkworm::to_hex(*b.block.header.parent_beacon_block_root); } if (b.block.header.withdrawals_root) { json["block"]["withdrawalsRoot"] = *b.block.header.withdrawals_root; } if (b.block.withdrawals) { json["block"]["withdrawals"] = *b.block.withdrawals; } if (b.block.header.requests_hash) { json["block"]["requestsHash"] = *b.block.header.requests_hash; } } void to_json(nlohmann::json& json, const BlockTransactionsResponse& b) { const auto block_num = to_quantity(b.header.number); json["fullblock"]["difficulty"] = to_quantity(silkworm::endian::to_big_compact(b.header.difficulty)); json["fullblock"]["extraData"] = "0x" + silkworm::to_hex(b.header.extra_data); json["fullblock"]["gasLimit"] = to_quantity(b.header.gas_limit); json["fullblock"]["gasUsed"] = to_quantity(b.header.gas_used); json["fullblock"]["hash"] = b.hash; json["fullblock"]["logsBloom"]; json["fullblock"]["miner"] = b.header.beneficiary; json["fullblock"]["mixHash"] = b.header.prev_randao; json["fullblock"]["nonce"] = "0x" + silkworm::to_hex({b.header.nonce.data(), b.header.nonce.size()}); json["fullblock"]["number"] = block_num; json["fullblock"]["parentHash"] = b.header.parent_hash; json["fullblock"]["receiptsRoot"] = b.header.receipts_root; json["fullblock"]["sha3Uncles"] = b.header.ommers_hash; json["fullblock"]["size"] = to_quantity(b.block_size); json["fullblock"]["stateRoot"] = b.header.state_root; json["fullblock"]["timestamp"] = to_quantity(b.header.timestamp); json["fullblock"]["transactionCount"] = b.transaction_count; if (b.header.base_fee_per_gas) { json["fullblock"]["baseFeePerGas"] = rpc::to_quantity(b.header.base_fee_per_gas.value_or(0)); } if (b.header.withdrawals_root) { json["fullblock"]["withdrawalsRoot"] = *b.header.withdrawals_root; } if (b.withdrawals) { json["fullblock"]["withdrawals"] = *(b.withdrawals); } if (b.header.blob_gas_used) { json["fullblock"]["blobGasUsed"] = rpc::to_quantity(*b.header.blob_gas_used); } if (b.header.excess_blob_gas) { json["fullblock"]["excessBlobGas"] = rpc::to_quantity(*b.header.excess_blob_gas); } if (b.header.parent_beacon_block_root) { json["fullblock"]["parentBeaconBlockRoot"] = silkworm::to_hex(*b.header.parent_beacon_block_root, /* with_prefix = */ true); } if (b.header.requests_hash) { json["fullblock"]["requestsHash"] = silkworm::to_hex(*b.header.requests_hash, /* with_prefix = */ true); } json["fullblock"]["transactions"] = b.transactions; for (size_t i{0}; i < json["fullblock"]["transactions"].size(); ++i) { auto& json_txn = json["fullblock"]["transactions"][i]; json_txn["transactionIndex"] = to_quantity(b.receipts.at(i).tx_index); json_txn["blockHash"] = b.hash; json_txn["blockNumber"] = block_num; json_txn["gasPrice"] = to_quantity(b.transactions[i].effective_gas_price(b.header.base_fee_per_gas.value_or(0))); json_txn["input"] = "0x" + silkworm::to_hex(b.transactions[i].data.substr(0, 4)); } json["fullblock"]["transactionsRoot"] = b.header.transactions_root; std::vector ommer_hashes; ommer_hashes.reserve(b.ommers.size()); for (size_t i{0}; i < b.ommers.size(); ++i) { ommer_hashes.emplace(ommer_hashes.end(), b.ommers[i].hash()); SILK_DEBUG << "ommer_hashes[" << i << "]: " << silkworm::to_hex({ommer_hashes[i].bytes, silkworm::kHashLength}); } json["fullblock"]["uncles"] = ommer_hashes; json["receipts"] = b.receipts; for (size_t i{0}; i < json["receipts"].size(); ++i) { auto& json_txn = json["receipts"][i]; json_txn["logs"] = nullptr; json_txn["logsBloom"] = nullptr; json_txn["effectiveGasPrice"] = to_quantity(b.transactions[i].effective_gas_price(b.header.base_fee_per_gas.value_or(0))); } } void to_json(nlohmann::json& json, const TransactionsWithReceipts& b) { json["firstPage"] = b.first_page; json["lastPage"] = b.last_page; json["txs"] = b.transactions; json["receipts"] = b.receipts; for (size_t i{0}; i < b.transactions.size(); ++i) { auto& json_txn = json["txs"][i]; auto& json_receipt = json["receipts"][i]; auto gas_price = to_quantity(b.receipts.at(i).effective_gas_price); json_txn["blockHash"] = b.receipts.at(i).block_hash; json_txn["blockNumber"] = to_quantity(b.receipts.at(i).block_num); json_txn["gasPrice"] = gas_price; json_txn["transactionIndex"] = to_quantity(b.receipts.at(i).tx_index); json_receipt["blockHash"] = b.receipts.at(i).block_hash; json_receipt["blockNumber"] = to_quantity(b.receipts.at(i).block_num); json_receipt["timestamp"] = b.headers.at(i).timestamp; json_receipt["effectiveGasPrice"] = gas_price; json_receipt["transactionHash"] = json_txn["hash"]; } } void to_json(nlohmann::json& json, const PayloadStatus& payload_status) { json["status"] = payload_status.status; if (payload_status.latest_valid_hash) { json["latestValidHash"] = *payload_status.latest_valid_hash; } if (payload_status.validation_error) { json["validationError"] = *payload_status.validation_error; } } void to_json(nlohmann::json& json, const Forks& forks) { json["genesis"] = forks.genesis_hash; json["heightForks"] = forks.block_nums; json["timeForks"] = forks.block_times; } void to_json(nlohmann::json& json, const Issuance& issuance) { if (issuance.block_reward) { json["blockReward"] = issuance.block_reward.value(); } else { json["blockReward"] = nullptr; } if (issuance.ommer_reward) { json["uncleReward"] = issuance.ommer_reward.value(); } else { json["uncleReward"] = nullptr; } if (issuance.issuance) { json["issuance"] = issuance.issuance.value(); } else { json["issuance"] = nullptr; } if (issuance.burnt) { json["burnt"] = issuance.burnt.value(); } else { json["burnt"] = nullptr; } if (issuance.total_issued) { json["totalIssued"] = issuance.total_issued.value(); } else { json["totalIssued"] = nullptr; } if (issuance.total_burnt) { json["totalBurnt"] = issuance.total_burnt.value(); } else { json["totalBurnt"] = nullptr; } if (issuance.tips) { json["tips"] = issuance.tips.value(); } else { json["tips"] = nullptr; } } void to_json(nlohmann::json& json, const Error& error) { json = {{"code", error.code}, {"message", error.message}}; } void to_json(nlohmann::json& json, const RevertError& error) { json = {{"code", error.code}, {"message", error.message}, {"data", "0x" + silkworm::to_hex(error.data)}}; } void to_json(nlohmann::json& json, const std::set& addresses) { json = nlohmann::json::array(); for (const auto& address : addresses) { json.push_back(address_to_hex(address)); } } nlohmann::json make_json_content(const nlohmann::json& request_json) { const nlohmann::json id = request_json.contains("id") ? request_json["id"] : nullptr; return {{"jsonrpc", kJsonVersion}, {"id", id}, {"result", nullptr}}; } nlohmann::json make_json_content(const nlohmann::json& request_json, const nlohmann::json& result) { const nlohmann::json id = request_json.contains("id") ? request_json["id"] : nullptr; nlohmann::json json{{"jsonrpc", kJsonVersion}, {"id", id}, {"result", result}}; return json; } nlohmann::json make_json_error(const nlohmann::json& request_json, int code, const std::string& message) { const nlohmann::json id = request_json.contains("id") ? request_json["id"] : nullptr; const Error error{code, message}; return {{"jsonrpc", kJsonVersion}, {"id", id}, {"error", error}}; } nlohmann::json make_json_error(const nlohmann::json& request_json, const RevertError& error) { const nlohmann::json id = request_json.contains("id") ? request_json["id"] : nullptr; return {{"jsonrpc", kJsonVersion}, {"id", id}, {"error", error}}; } JsonRpcId make_jsonrpc_id(const nlohmann::json& request_json) { JsonRpcId json_rpc_id; if (request_json.contains("id")) { const auto& id = request_json["id"]; if (id.is_number()) { json_rpc_id = id.get(); } else if (id.is_string()) { json_rpc_id = id.get(); } else { json_rpc_id = nullptr; } } else { json_rpc_id = nullptr; } return json_rpc_id; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/types.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace evmc { void to_json(nlohmann::json& json, const address& addr); void from_json(const nlohmann::json& json, address& addr); void to_json(nlohmann::json& json, const bytes32& b32); void from_json(const nlohmann::json& json, bytes32& b32); } // namespace evmc namespace intx { void from_json(const nlohmann::json& json, uint256& ui256); } // namespace intx namespace silkworm { void to_json(nlohmann::json& json, const BlockHeader& header); } // namespace silkworm namespace silkworm::rpc { void to_json(nlohmann::json& json, const PeerInfo& peer_info); void to_json(nlohmann::json& json, const struct ChainTraffic& chain_traffic); void to_json(nlohmann::json& json, const struct TxPoolStatusInfo& status_info); void to_json(nlohmann::json& json, const AccessListResult& access_list_result); void to_json(nlohmann::json& json, const SyncingData& syncing_data); void to_json(nlohmann::json& json, const StageData& stage_data); void to_json(nlohmann::json& json, const Rlp& rlp); void to_json(nlohmann::json& json, const BlockDetailsResponse& b); void to_json(nlohmann::json& json, const BlockTransactionsResponse& b); void to_json(nlohmann::json& json, const TransactionsWithReceipts& b); void to_json(nlohmann::json& json, const PayloadStatus& payload_status); void to_json(nlohmann::json& json, const Forks& forks); void to_json(nlohmann::json& json, const Issuance& issuance); void to_json(nlohmann::json& json, const Error& error); void to_json(nlohmann::json& json, const RevertError& error); void to_json(nlohmann::json& json, const std::set& addresses); uint64_t from_quantity(const std::string& hex_quantity); std::string to_hex(uint64_t number); std::string to_hex_no_leading_zeros(uint64_t number); std::string to_hex_no_leading_zeros(silkworm::ByteView bytes); std::string to_quantity(uint64_t number); std::string to_quantity(const intx::uint256& number); std::string to_quantity(silkworm::ByteView bytes); void to_quantity(std::span hex_bytes, uint64_t block_num); void to_quantity(std::span hex_bytes, intx::uint256 number); void to_quantity(std::span hex_bytes, silkworm::ByteView bytes); void to_hex(std::span hex_bytes, silkworm::ByteView bytes); nlohmann::json make_json_content(const nlohmann::json& request_json); nlohmann::json make_json_content(const nlohmann::json& request_json, const nlohmann::json& result); nlohmann::json make_json_error(const nlohmann::json& request_json, int code, const std::string& message); nlohmann::json make_json_error(const nlohmann::json& request_json, const RevertError& error); using JsonRpcId = std::variant; JsonRpcId make_jsonrpc_id(const nlohmann::json& request_json); } // namespace silkworm::rpc namespace nlohmann { template <> struct adl_serializer { static silkworm::rpc::BlockNumOrHash from_json(const json& json) { if (json.is_string()) { return silkworm::rpc::BlockNumOrHash{json.get()}; } if (json.is_number()) { return silkworm::rpc::BlockNumOrHash{json.get()}; } return silkworm::rpc::BlockNumOrHash{0}; } }; } // namespace nlohmann ================================================ FILE: silkworm/rpc/json/types_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "types.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("convert zero uint256 to quantity", "[rpc][to_quantity]") { intx::uint256 zero_u256{0}; const auto zero_quantity = to_quantity(zero_u256); CHECK(zero_quantity == "0x0"); } TEST_CASE("convert zero uint256 to quantity(buff)", "[rpc][to_quantity]") { intx::uint256 zero_u256{0}; char zero_quantity[64]; to_quantity(zero_quantity, zero_u256); CHECK(strcmp(zero_quantity, "0x0") == 0); } TEST_CASE("convert positive uint256 to quantity", "[rpc][to_quantity]") { intx::uint256 positive_u256{100}; const auto positive_quantity = to_quantity(positive_u256); CHECK(positive_quantity == "0x64"); } TEST_CASE("convert positive uint256 to quantity(buff)", "[rpc][to_quantity]") { intx::uint256 positive_u256{100}; char positive_quantity[64]; to_quantity(positive_quantity, positive_u256); CHECK(strcmp(positive_quantity, "0x64") == 0); } TEST_CASE("serialize empty address using to_hex(char *)", "[rpc][to_json]") { evmc::address address{}; char address_zero[64]; to_hex(address_zero, address.bytes); CHECK(strcmp(address_zero, "0x0000000000000000000000000000000000000000") == 0); } TEST_CASE("serialize empty address using to_hex(char *) small buffer", "[rpc][to_json]") { evmc::address address{}; char address_zero[10]; CHECK_THROWS(to_hex(address_zero, address.bytes)); } TEST_CASE("serialize empty address", "[rpc][to_json]") { evmc::address address{}; nlohmann::json j = address; CHECK(j == R"("0x0000000000000000000000000000000000000000")"_json); } TEST_CASE("serialize address", "[rpc][to_json]") { evmc::address address{0x0715a7794a1dc8e42615f059dd6e406a6594651a_address}; nlohmann::json j = address; CHECK(j == R"("0x0715a7794a1dc8e42615f059dd6e406a6594651a")"_json); } TEST_CASE("deserialize empty address", "[rpc][from_json]") { auto j1 = R"("0000000000000000000000000000000000000000")"_json; auto address = j1.get(); CHECK(address == evmc::address{}); } TEST_CASE("deserialize address", "[rpc][from_json]") { auto j1 = R"("0x0715a7794a1dc8e42615f059dd6e406a6594651a")"_json; auto address = j1.get(); CHECK(address == evmc::address{0x0715a7794a1dc8e42615f059dd6e406a6594651a_address}); } TEST_CASE("serialize empty bytes32", "[rpc][to_json]") { evmc::bytes32 b32{}; nlohmann::json j = b32; CHECK(j == R"("0x0000000000000000000000000000000000000000000000000000000000000000")"_json); } TEST_CASE("serialize empty Rlp", "[rpc][to_json]") { Rlp rlp; nlohmann::json j = rlp; CHECK(j == R"("0x")"_json); } TEST_CASE("serialize not empty Rlp", "[rpc][to_json]") { Rlp rlp; rlp.buffer.push_back(0x78); rlp.buffer.push_back(0x24); nlohmann::json j = rlp; CHECK(j == R"("0x7824")"_json); } TEST_CASE("serialize AccessListResult with gas_used", "[rpc][to_json]") { AccessListResult access_list_result; access_list_result.gas_used = 0x1234; nlohmann::json j = access_list_result; CHECK(j == R"({ "accessList":[], "gasUsed":"0x1234" })"_json); } TEST_CASE("serialize AccessListResult with error", "[rpc][to_json]") { AccessListResult access_list_result; access_list_result.gas_used = 0x1234; access_list_result.error = "operation reverted"; nlohmann::json j = access_list_result; CHECK(j == R"({ "accessList":[], "error":"operation reverted", "gasUsed":"0x1234" })"_json); } TEST_CASE("serialize TxPoolStatusInfo", "[rpc][to_json]") { TxPoolStatusInfo status_info{}; status_info.pending = 0x7; status_info.queued = 0x8; status_info.base_fee = 0x9; nlohmann::json j = status_info; CHECK(j == R"({ "baseFee":"0x9", "pending":"0x7", "queued":"0x8" })"_json); } TEST_CASE("serialize non-empty bytes32", "[rpc][to_json]") { evmc::bytes32 b32{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; nlohmann::json j = b32; CHECK(j == R"("0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c")"_json); } TEST_CASE("serialize empty block header", "[rpc][to_json]") { silkworm::BlockHeader header{}; rpc::compatibility::set_erigon_json_api_compatibility_required(true); nlohmann::json j = header; CHECK(j == R"({ "baseFeePerGas":null, "hash": "0xc3bd2d00745c03048a5616146a96f5ff78e54efb9e5b04af208cdaff6f3830ee", "parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000", "miner":"0x0000000000000000000000000000000000000000", "stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "difficulty":"0x0", "nonce":"0x0000000000000000", "number":"0x0", "gasLimit":"0x0", "gasUsed":"0x0", "timestamp":"0x0", "extraData":"0x", "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "withdrawalsRoot":null, "AuRaSeal":null, "AuRaStep":0, "Verkle":false, "VerkleKeyVals":null, "VerkleProof":null, "requestsHash":null, "blobGasUsed":null, "excessBlobGas": null, "parentBeaconBlockRoot": null })"_json); } TEST_CASE("serialize block header", "[rpc][to_json]") { rpc::compatibility::set_erigon_json_api_compatibility_required(true); silkworm::BlockHeader header{ 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32, 0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d_bytes32, 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address, 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d_bytes32, 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e_bytes32, 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f_bytes32, silkworm::Bloom{}, intx::uint256{0}, BlockNum{5}, uint64_t{1000000}, uint64_t{1000000}, uint64_t{5405021}, *silkworm::from_hex("0001FF0100"), 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, {0, 0, 0, 0, 0, 0, 0, 255}}; nlohmann::json j = header; CHECK(j == R"({ "baseFeePerGas":null, "hash": "0x5e053b099d472a3fc02394243961937ffa008bad0daa81a984a0830ba0beee01", "parentHash":"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c", "sha3Uncles":"0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d", "miner":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "stateRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d", "transactionsRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e", "receiptsRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f", "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "difficulty":"0x0", "number":"0x5", "gasLimit":"0xf4240", "gasUsed":"0xf4240", "timestamp":"0x52795d", "extraData":"0x0001ff0100", "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000001", "nonce":"0x00000000000000ff", "withdrawalsRoot":null, "AuRaSeal":null, "AuRaStep":0, "Verkle":false, "VerkleKeyVals":null, "VerkleProof":null, "requestsHash":null, "blobGasUsed":null, "excessBlobGas": null, "parentBeaconBlockRoot": null })"_json); } TEST_CASE("serialize block header with baseFeePerGas", "[rpc][to_json]") { rpc::compatibility::set_erigon_json_api_compatibility_required(true); silkworm::BlockHeader header{ 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32, 0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d_bytes32, 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address, 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d_bytes32, 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e_bytes32, 0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f_bytes32, silkworm::Bloom{}, intx::uint256{0}, BlockNum{5}, uint64_t{1000000}, uint64_t{1000000}, uint64_t{5405021}, *silkworm::from_hex("0001FF0100"), // extradata 0x0000000000000000000000000000000000000000000000000000000000000001_bytes32, // mixhash {1, 2, 3, 4, 5, 6, 7, 8}, // nonce std::optional(1000), // base_fee_per_gas }; nlohmann::json j = header; CHECK(j == R"({ "baseFeePerGas":"0x3e8", "hash": "0x5e3a9484b3ee70cc9ae7673051efd0369cfa4126430075921c70255cbdefbe6", "parentHash":"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c", "sha3Uncles":"0x474f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126d", "miner":"0x0715a7794a1dc8e42615f059dd6e406a6594651a", "stateRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126d", "transactionsRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126e", "receiptsRoot":"0xb02a3b0ee16c858afaa34bcd6770b3c20ee56aa2f75858733eb0e927b5b7126f", "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "difficulty":"0x0", "number":"0x5", "gasLimit":"0xf4240", "gasUsed":"0xf4240", "timestamp":"0x52795d", "extraData":"0x0001ff0100", "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000001", "nonce":"0x0102030405060708", "baseFeePerGas":"0x3e8", "withdrawalsRoot":null, "AuRaSeal":null, "AuRaStep":0, "Verkle":false, "VerkleKeyVals":null, "VerkleProof":null, "requestsHash":null, "blobGasUsed":null, "excessBlobGas": null, "parentBeaconBlockRoot": null })"_json); } TEST_CASE("serialize block with hydrated transactions", "[rpc][to_json]") { // 1) build block https://goerli.etherscan.io/block/3529604 // 1.1) value from table Header for key 000000000035db84 const char* header_rlp_hex{ "f9025ca08059c265f40cdb2d3b3245847c21ed154eebf299fd0ff01ee3afded43cdadc45a01dcc4de8dec75d7aab85b567b6ccd41ad312" "451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a08add6cb86a4b4a4e5758ce21c8d156e4355917" "d29eae7c19f56d4a38f384401da095e5f810e7a45d476d7416fbffbc931473cfdba2b90204e019067bcc6d136dc3a08c3d469c1fbce4e4" "144d5e5f91a81baca60b1fb6b5bdcf691b9dc40a5bf21b35b9010004000000000000000000000000040010001000402000000000000000" "00000008000020001000000001000000000080000000000010000000000800000000000000000000000000000000000000000000000000" "10100000000000000000000008000008000000000000000000000000002000000000000000000000000000040000000000000010000000" "00000000000000000000000000000000000000400000000000000000000000020180440020000000080000000000000000000000000000" "00000000000000000000000000000000020000000000000000000000000000000000000000000000180000002000004010000880800000" "0200400000000000018335db84837a12008308b89a845f7cd33db861476f65726c6920496e697469617469766520417574686f72697479" "00000000001f3070be3668d4e3bdd1d08969becd5b06ab0ae4224873453d827a67b3a089ee03c69941418ac300e2c3ca9b5597c7a37959" "32a7ff2f907db605a93a88c5b4a800a0000000000000000000000000000000000000000000000000000000000000000088000000000000" "0000"}; silkworm::Bytes header_rlp_bytes{*silkworm::from_hex(header_rlp_hex)}; silkworm::ByteView header_view{header_rlp_bytes}; silkworm::BlockHeader header; REQUIRE(silkworm::rlp::decode(header_view, header)); // 1.2) value from table BlockBody for key 000000000035db84c9e65d063911aa583e17bbb7070893482203217caf6d9fbb50265c72e7bf73e5 const char* body_rlp_hex{"c68341b58302c0"}; silkworm::Bytes body_rlp_bytes{*silkworm::from_hex(body_rlp_hex)}; silkworm::ByteView body_view{body_rlp_bytes}; const auto body_for_storage{silkworm::unwrap_or_throw(silkworm::decode_stored_block_body(body_view))}; REQUIRE(body_for_storage.txn_count == 2); REQUIRE(body_for_storage.base_txn_id == 0x41b583); // 1.3) value from table BlockTransaction for key 000000000041b583 and 000000000041b584 const char* tx1_rlp_hex{ "f87080843b9aca00830c350094fa365f1384e4eaf6d59f353c782af3ea42feaab988015c2a7b13fd000084d0e30db02ea06b0df7c31119" "b257e7faeb391984f199c8da817b14279ac09262bdf3493599a6a00c729ce28ec0030002490d6217a8b50041495925142e70fa1b77e465" "eab97c4b"}; silkworm::Bytes tx1_rlp_bytes{*silkworm::from_hex(tx1_rlp_hex)}; silkworm::ByteView tx1_view{tx1_rlp_bytes}; silkworm::Transaction tx1; REQUIRE(silkworm::rlp::decode(tx1_view, tx1)); const char* tx2_rlp_hex{ "f901aa02843b9aca008304fa4a9431af35bdfa897cd42b204c003560c385d444707580b901449b4e463400000000000000000000000000" "0000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c081c2ac5b" "ba256c88daa744c9caa7d6c99c32c1bc0c07bdca87bd2a054118c47b000000000000000000000000000000000000000000000000000000" "0000000030a5a151a2320abaab98cfa8366fc326fb6f45cf1c93697191ec1370e1caca0fc6237e3bc5328755ae66bc5ddb141f0cb10000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060a4dcd35675e049ea5b" "58d9567f8029669d4cdbe72511d330d96a578e2714f1c9db00f6a9babc217b250fc7f217b0261506727657b420d9e05adc73675390ce2e" "b1e1aef3bac7d1b4b424c9dc07cdcac2729eabdb81c857325e20202ea24761601ba01d8e665abc1278a9526aaf4c604f75b293e43ccf9d" "c72918a633af584b73425ba07f8913ecd5db0e98d48097abefd7b2fa954d7cf1514496b870b8a1335034df4d"}; silkworm::Bytes tx2_rlp_bytes{*silkworm::from_hex(tx2_rlp_hex)}; silkworm::ByteView tx2_view{tx2_rlp_bytes}; silkworm::Transaction tx2; REQUIRE(silkworm::rlp::decode(tx2_view, tx2)); silkworm::BlockWithHash block_with_hash{ // BlockWithHash /*.block =*/{ // Block { // BlockBody .transactions = std::vector{tx1, tx2}, .ommers = std::vector{}, .withdrawals = std::nullopt, }, /*.header =*/header, }, /*.hash =*/0xc9e65d063911aa583e17bbb7070893482203217caf6d9fbb50265c72e7bf73e5_bytes32, }; auto block_with_hash_shared = std::make_shared(); *block_with_hash_shared = block_with_hash; silkworm::rpc::Block rpc_block{block_with_hash_shared, /* full_tx */ true}; nlohmann::json rpc_block_json = rpc_block; CHECK(rpc_block_json == R"({ "difficulty":"0x1", "extraData":"0x476f65726c6920496e697469617469766520417574686f7269747900000000001f3070be3)" R"(668d4e3bdd1d08969becd5b06ab0ae4224873453d827a67b3a089ee03c69941418ac300e2c3c)" R"(a9b5597c7a3795932a7ff2f907db605a93a88c5b4a800", "gasLimit":"0x7a1200", "gasUsed":"0x8b89a", "hash":"0xc9e65d063911aa583e17bbb7070893482203217caf6d9fbb50265c72e7bf73e5", "logsBloom":"0x040000000000000000000000000400100010004020000000000000000000000800002000)" R"(100000000100000000008000000000001000000000080000000000000000000000000000)" R"(000000000000000000000010100000000000000000000008000008000000000000000000)" R"(000000002000000000000000000000000000040000000000000010000000000000000000)" R"(000000000000000000000000004000000000000000000000000201804400200000000800)" R"(000000000000000000000000000000000000000000000000000000000002000000000000)" R"(000000000000000000000000000000000018000000200000401000088080000002004000)" R"(00000000", "miner":"0x0000000000000000000000000000000000000000", "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "nonce":"0x0000000000000000", "number":"0x35db84", "parentHash":"0x8059c265f40cdb2d3b3245847c21ed154eebf299fd0ff01ee3afded43cdadc45", "receiptsRoot":"0x8c3d469c1fbce4e4144d5e5f91a81baca60b1fb6b5bdcf691b9dc40a5bf21b35", "sha3Uncles":"0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "size":"0x485", "stateRoot":"0x8add6cb86a4b4a4e5758ce21c8d156e4355917d29eae7c19f56d4a38f384401d", "timestamp":"0x5f7cd33d", "transactions":[ { "blockHash":"0xc9e65d063911aa583e17bbb7070893482203217caf6d9fbb50265c72e7bf73e5", "blockNumber":"0x35db84", "from":"0x4ed7fae4af36f11ac28275a98ca1d131e91bb6cd", "gas":"0xc3500", "gasPrice":"0x3b9aca00", "hash":"0xa52100232ad8abc15bdcd95b071194d2084781f88a71974eef7292c8513a03b4", "input":"0xd0e30db0", "nonce":"0x0", "r":"0x6b0df7c31119b257e7faeb391984f199c8da817b14279ac09262bdf3493599a6", "s":"0xc729ce28ec0030002490d6217a8b50041495925142e70fa1b77e465eab97c4b", "to":"0xfa365f1384e4eaf6d59f353c782af3ea42feaab9", "transactionIndex":"0x0", "type":"0x0", "v":"0x2e", "chainId":"0x5", "value":"0x15c2a7b13fd0000" }, { "blockHash":"0xc9e65d063911aa583e17bbb7070893482203217caf6d9fbb50265c72e7bf73e5", "blockNumber":"0x35db84", "from":"0xab2e6a1020c511615f82155259086717802d1474", "gas":"0x4fa4a", "gasPrice":"0x3b9aca00", "hash":"0x81d69137fe27a549e957c2dd3d54f374a019bf12409ca44fb9e01dc82ac7e925", "input":"0x9b4e463400000000000000000000000000000000000000000000000000000000000000600)" R"(0000000000000000000000000000000000000000000000000000000000000c081c2ac5bba256)" R"(c88daa744c9caa7d6c99c32c1bc0c07bdca87bd2a054118c47b0000000000000000000000000)" R"(000000000000000000000000000000000000030a5a151a2320abaab98cfa8366fc326fb6f45c)" R"(f1c93697191ec1370e1caca0fc6237e3bc5328755ae66bc5ddb141f0cb100000000000000000)" R"(0000000000000000000000000000000000000000000000000000000000000000000000000000)" R"(060a4dcd35675e049ea5b58d9567f8029669d4cdbe72511d330d96a578e2714f1c9db00f6a9b)" R"(abc217b250fc7f217b0261506727657b420d9e05adc73675390ce2eb1e1aef3bac7d1b4b424c)" R"(9dc07cdcac2729eabdb81c857325e20202ea2476160", "nonce":"0x2", "r":"0x1d8e665abc1278a9526aaf4c604f75b293e43ccf9dc72918a633af584b73425b", "s":"0x7f8913ecd5db0e98d48097abefd7b2fa954d7cf1514496b870b8a1335034df4d", "to":"0x31af35bdfa897cd42b204c003560c385d4447075", "transactionIndex":"0x1", "type":"0x0", "v":"0x1b", "value":"0x0" } ], "transactionsRoot":"0x95e5f810e7a45d476d7416fbffbc931473cfdba2b90204e019067bcc6d136dc3", "uncles":[] })"_json); } TEST_CASE("serialize block body with ommers", "[rpc][to_json]") { // https://etherscan.io/block/3 const char* rlp_hex{ "f90219c0f90215f90212a0d4e56740f876aef8c010b86a40d5f56745a118d090" "6a34e69aec8c0db1cb8fa3a01dcc4de8dec75d7aab85b567b6ccd41ad312451b" "948a7413f0a142fd40d4934794c8ebccc5f5689fa8659d83713341e5ad193494" "48a01e6e030581fd1873b4784280859cd3b3c04aa85520f08c304cf5ee63d393" "5adda056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e3" "63b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5" "e363b421b9010000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000" "000000000000008503ff80000001821388808455ba42429a5961746573205261" "6e64616c6c202d2045746865724e696e6a61a0f8c94dfe61cf26dcdf8cffeda3" "37cf6a903d65c449d7691a022837f6e2d994598868b769c5451a7aea"}; silkworm::Bytes rlp_bytes{*silkworm::from_hex(rlp_hex)}; silkworm::ByteView in{rlp_bytes}; auto block_with_hash_shared = std::make_shared(); silkworm::rpc::Block rpc_block{block_with_hash_shared}; silkworm::BlockBody block_body; REQUIRE(silkworm::rlp::decode(in, block_body)); rpc_block.block_with_hash->block.ommers = block_body.ommers; nlohmann::json rpc_block_json = rpc_block; CHECK(rpc_block_json == R"({ "difficulty":"0x0", "extraData":"0x", "gasLimit":"0x0", "gasUsed":"0x0", "hash":"0x0000000000000000000000000000000000000000000000000000000000000000", "logsBloom":"0x000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(000000000000000000000000000000000000000000000000000000000000000000000000)" R"(00000000000000000000000000000000000000000000000000000000000000000000000000000000", "miner":"0x0000000000000000000000000000000000000000", "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "nonce":"0x0000000000000000", "number":"0x0", "parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000", "size":"0x40c", "stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "timestamp":"0x0", "transactions":[], "transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000", "uncles":["0x5cd50096dbb856a6d1befa6de8f9c20decb299f375154427d90761dc0b101109"] })"_json); } TEST_CASE("serialize filled SyncingData", "[rpc][to_json]") { SyncingData syncing_data{}; StageData stage_data; syncing_data.current_block = "0x1"; syncing_data.max_block = "0x2"; stage_data.stage_name = "stage1"; stage_data.block_num = "0x3"; syncing_data.stages.push_back(stage_data); stage_data.stage_name = "stage2"; stage_data.block_num = "0x4"; syncing_data.stages.push_back(stage_data); nlohmann::json j = syncing_data; CHECK(j == R"({ "currentBlock":"0x1","highestBlock":"0x2","stages":[{"block_number":"0x3","stage_name":"stage1"},{"block_number":"0x4","stage_name":"stage2"}] })"_json); } TEST_CASE("serialize error", "[rpc][to_json]") { Error err{100, {"generic error"}}; nlohmann::json j = err; CHECK(j == R"({ "code":100, "message":"generic error" })"_json); } TEST_CASE("serialize std::set", "[rpc][to_json]") { std::set addresses; SECTION("empty addresses set") { nlohmann::json j; to_json(j, addresses); CHECK(j == R"([])"_json); } SECTION("filled addresses set") { addresses.insert(0x07aaec0b237ccf56b03a7c43c1c7a783da560642_address); nlohmann::json j; to_json(j, addresses); CHECK(j == R"(["0x07aaec0b237ccf56b03a7c43c1c7a783da560642"])"_json); } } TEST_CASE("deserialize block_num_or_hash", "[silkworm::json][from_json]") { SECTION("as hash") { auto json = R"("0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c")"_json; auto block_num_or_hash = json.get(); CHECK(block_num_or_hash.is_hash() == true); CHECK(block_num_or_hash.is_number() == false); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.hash() == 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32); } SECTION("as decimal number string") { auto json = R"("1966")"_json; auto block_num_or_hash = json.get(); CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == true); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.number() == 1966); } SECTION("as hex number string") { auto json = R"("0x374f3")"_json; auto block_num_or_hash = json.get(); CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == true); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.number() == 0x374f3); } SECTION("as tag string") { auto json = R"("latest")"_json; auto block_num_or_hash = json.get(); CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == false); CHECK(block_num_or_hash.is_tag() == true); CHECK(block_num_or_hash.tag() == "latest"); } SECTION("as number") { auto json = R"(123456)"_json; auto block_num_or_hash = json.get(); CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == true); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.number() == 123456); } } TEST_CASE("serialize zero forks", "[silkworm::json][to_json]") { auto cc = ChainConfig::from_json(R"({"chainId":1,"ethash":{}})"_json); REQUIRE(cc.has_value()); cc->genesis_hash = 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32; Forks f{*cc}; nlohmann::json j = f; CHECK(j == R"({ "genesis":"0x0000000000000000000000000000000000000000000000000000000000000000", "heightForks":[], "timeForks":[] })"_json); } TEST_CASE("serialize forks", "[silkworm::json][to_json]") { auto cc = ChainConfig::from_json(R"({ "berlinBlock":12244000, "byzantiumBlock":4370000, "chainId":1, "constantinopleBlock":7280000, "daoForkBlock":1920000, "eip150Block":2463000, "eip155Block":2675000, "ethash":{}, "homesteadBlock":1150000, "istanbulBlock":9069000, "londonBlock":12965000, "muirGlacierBlock":9200000, "petersburgBlock":7280000, "shanghaiTime":1678832736 })"_json); REQUIRE(cc.has_value()); cc->genesis_hash = 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32; Forks f{*cc}; nlohmann::json j = f; CHECK(j == R"({ "genesis":"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c", "heightForks":[1150000,1920000,2463000,2675000,4370000,7280000,9069000,9200000,12244000,12965000], "timeForks":[1678832736] })"_json); } TEST_CASE("serialize empty issuance", "[silkworm::json][to_json]") { silkworm::rpc::Issuance issuance{}; nlohmann::json j = issuance; CHECK(j == R"({ "blockReward":null, "uncleReward":null, "issuance":null, "burnt":null, "tips":null, "totalBurnt":null, "totalIssued":null })"_json); } TEST_CASE("serialize chain_traffic", "[silkworm::json][to_json]") { silkworm::rpc::ChainTraffic chain_traffic{4, 5}; nlohmann::json j = chain_traffic; CHECK(j == R"({ "cumulativeGasUsed":"0x4", "cumulativeTransactionsCount":"0x5" })"_json); } TEST_CASE("serialize issuance", "[silkworm::json][to_json]") { silkworm::rpc::Issuance issuance{ "0x0", "0x0", "0x0", "0x0", "0x0", "0x0", "0x0"}; nlohmann::json j = issuance; CHECK(j == R"({ "blockReward":"0x0", "uncleReward":"0x0", "issuance":"0x0", "burnt":"0x0", "tips":"0x0", "totalBurnt":"0x0", "totalIssued":"0x0" })"_json); } TEST_CASE("serialize ForkChoiceUpdatedReplyV1", "[silkworm::json][to_json]") { silkworm::rpc::PayloadStatus payload_status{ .status = "VALID", .latest_valid_hash = 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32, .validation_error = "some error"}; silkworm::rpc::ForkChoiceUpdatedReply forkchoice_update_reply{ .payload_status = payload_status, .payload_id = 0x1}; nlohmann::json j = forkchoice_update_reply; CHECK(j == R"({ "payloadStatus": { "status":"VALID", "latestValidHash":"0x0000000000000000000000000000000000000000000000000000000000000040", "validationError":"some error" }, "payloadId":"0x0000000000000001" })"_json); } TEST_CASE("serialize PayloadStatusV1", "[silkworm::json][to_json]") { silkworm::rpc::PayloadStatus payload_status{ .status = "VALID", .latest_valid_hash = 0x0000000000000000000000000000000000000000000000000000000000000040_bytes32, .validation_error = "some error"}; nlohmann::json j = payload_status; CHECK(j == R"({ "status":"VALID", "latestValidHash":"0x0000000000000000000000000000000000000000000000000000000000000040", "validationError":"some error" })"_json); } TEST_CASE("make empty json content", "[silkworm::json][make_json_content]") { const nlohmann::json request = R"({ "id":0 })"_json; const auto j = make_json_content(request, {}); CHECK(j == R"({ "jsonrpc":"2.0", "id":0, "result":null })"_json); } TEST_CASE("make json content", "[silkworm::json][make_json_content]") { const nlohmann::json request = R"({ "id":123 })"_json; nlohmann::json json_result = {{"currency", "ETH"}, {"value", 4.2}}; const auto j = make_json_content(request, json_result); CHECK(j == R"({ "jsonrpc":"2.0", "id":123, "result":{"currency":"ETH","value":4.2} })"_json); } TEST_CASE("make empty json error", "[silkworm::json][make_json_error]") { const nlohmann::json request = R"({ "id":0 })"_json; const auto j = make_json_error(request, 0, ""); CHECK(j == R"({ "jsonrpc":"2.0", "id":0, "error":{"code":0,"message":""} })"_json); } TEST_CASE("make empty json revert error", "[silkworm::json][make_json_error]") { const nlohmann::json request = R"({ "id":0 })"_json; const auto j = make_json_error(request, {{0, ""}, silkworm::Bytes{}}); CHECK(j == R"({ "jsonrpc":"2.0", "id":0, "error":{"code":0,"message":"","data":"0x"} })"_json); } TEST_CASE("make json error", "[silkworm::json][make_json_error]") { const nlohmann::json request = R"({ "id":123 })"_json; const auto j = make_json_error(request, -32000, "revert"); CHECK(j == R"({ "jsonrpc":"2.0", "id":123, "error":{"code":-32000,"message":"revert"} })"_json); } TEST_CASE("make json revert error", "[silkworm::json][make_json_error]") { const nlohmann::json request = R"({ "id":123 })"_json; const auto j = make_json_error(request, {{3, "execution reverted: Ownable: caller is not the owner"}, *silkworm::from_hex("0x00010203")}); CHECK(j == R"({ "jsonrpc":"2.0", "id":123, "error":{"code":3,"message":"execution reverted: Ownable: caller is not the owner","data":"0x00010203"} })"_json); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/withdrawal.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "withdrawal.hpp" #include "types.hpp" namespace silkworm { void to_json(nlohmann::json& json, const Withdrawal& withdrawal) { json["index"] = rpc::to_quantity(withdrawal.index); json["validatorIndex"] = rpc::to_quantity(withdrawal.validator_index); json["address"] = withdrawal.address; json["amount"] = rpc::to_quantity(withdrawal.amount); } void from_json(const nlohmann::json& json, Withdrawal& withdrawal) { withdrawal.index = rpc::from_quantity(json.at("index")); withdrawal.validator_index = rpc::from_quantity(json.at("validatorIndex")); withdrawal.address = json.at("address").get(); withdrawal.amount = rpc::from_quantity(json.at("amount")); } } // namespace silkworm namespace silkworm::rpc { std::optional> make_glaze_json_withdrawals(const BlockBody& block) { std::vector withdrawals; withdrawals.reserve(block.withdrawals->size()); for (size_t i{0}; i < block.withdrawals->size(); ++i) { GlazeJsonWithdrawals item; to_quantity(std::span(item.index), (*(block.withdrawals))[i].index); to_quantity(std::span(item.amount), (*(block.withdrawals))[i].amount); to_quantity(std::span(item.validator_index), (*(block.withdrawals))[i].validator_index); to_hex(std::span(item.address), (*(block.withdrawals))[i].address.bytes); withdrawals.push_back(item); } return make_optional(std::move(withdrawals)); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/json/withdrawal.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc { struct GlazeJsonWithdrawals { char index[kInt64HexSize]{}; char validator_index[kInt64HexSize]{}; char address[kAddressHexSize]{}; char amount[kInt64HexSize]{}; struct glaze { using T = GlazeJsonWithdrawals; // NOLINTNEXTLINE(readability-identifier-naming) static constexpr auto value = glz::object( "index", &T::index, "validatorIndex", &T::validator_index, "address", &T::address, "amount", &T::amount); }; }; std::optional> make_glaze_json_withdrawals(const BlockBody& block); } // namespace silkworm::rpc namespace silkworm { void to_json(nlohmann::json& json, const Withdrawal& withdrawal); void from_json(const nlohmann::json& json, Withdrawal& withdrawal); } // namespace silkworm ================================================ FILE: silkworm/rpc/json/withdrawal_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "withdrawal.hpp" #include #include namespace silkworm { using evmc::literals::operator""_address; TEST_CASE("serialize WithdrawalV1", "[silkworm::json][to_json]") { Withdrawal withdrawal{ .index = 6, .validator_index = 12, .address = 0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b_address, .amount = 10'000}; CHECK(nlohmann::json(withdrawal) == R"({ "index":"0x6", "validatorIndex":"0xc", "address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "amount":"0x2710" })"_json); } } // namespace silkworm ================================================ FILE: silkworm/rpc/json_rpc/methods.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::rpc::json_rpc::method { // Constants defined here have a different naming from our standard: k_ // where is *exactly* the JSON RPC API method // NOLINTBEGIN(readability-identifier-naming) inline constexpr const char* k_web3_clientVersion{"web3_clientVersion"}; inline constexpr const char* k_web3_sha3{"web3_sha3"}; inline constexpr const char* k_admin_nodeInfo{"admin_nodeInfo"}; inline constexpr const char* k_admin_peers{"admin_peers"}; inline constexpr const char* k_net_listening{"net_listening"}; inline constexpr const char* k_net_peerCount{"net_peerCount"}; inline constexpr const char* k_net_version{"net_version"}; inline constexpr const char* k_eth_blockNumber{"eth_blockNumber"}; inline constexpr const char* k_eth_chainId{"eth_chainId"}; inline constexpr const char* k_eth_protocolVersion{"eth_protocolVersion"}; inline constexpr const char* k_eth_syncing{"eth_syncing"}; inline constexpr const char* k_eth_gasPrice{"eth_gasPrice"}; inline constexpr const char* k_eth_getUncleByBlockHashAndIndex{"eth_getUncleByBlockHashAndIndex"}; inline constexpr const char* k_eth_getUncleByBlockNumberAndIndex{"eth_getUncleByBlockNumberAndIndex"}; inline constexpr const char* k_eth_getUncleCountByBlockHash{"eth_getUncleCountByBlockHash"}; inline constexpr const char* k_eth_getUncleCountByBlockNumber{"eth_getUncleCountByBlockNumber"}; inline constexpr const char* k_eth_getTransactionByHash{"eth_getTransactionByHash"}; inline constexpr const char* k_eth_getTransactionByBlockHashAndIndex{"eth_getTransactionByBlockHashAndIndex"}; inline constexpr const char* k_eth_getRawTransactionByHash{"eth_getRawTransactionByHash"}; inline constexpr const char* k_eth_getRawTransactionByBlockHashAndIndex{"eth_getRawTransactionByBlockHashAndIndex"}; inline constexpr const char* k_eth_getRawTransactionByBlockNumberAndIndex{"eth_getRawTransactionByBlockNumberAndIndex"}; inline constexpr const char* k_eth_getTransactionByBlockNumberAndIndex{"eth_getTransactionByBlockNumberAndIndex"}; inline constexpr const char* k_eth_getTransactionReceipt{"eth_getTransactionReceipt"}; inline constexpr const char* k_eth_estimateGas{"eth_estimateGas"}; inline constexpr const char* k_eth_getBalance{"eth_getBalance"}; inline constexpr const char* k_eth_getCode{"eth_getCode"}; inline constexpr const char* k_eth_getTransactionCount{"eth_getTransactionCount"}; inline constexpr const char* k_eth_getStorageAt{"eth_getStorageAt"}; inline constexpr const char* k_eth_call{"eth_call"}; inline constexpr const char* k_eth_callMany{"eth_callMany"}; inline constexpr const char* k_eth_callBundle{"eth_callBundle"}; inline constexpr const char* k_eth_createAccessList{"eth_createAccessList"}; inline constexpr const char* k_eth_newFilter{"eth_newFilter"}; inline constexpr const char* k_eth_newBlockFilter{"eth_newBlockFilter"}; inline constexpr const char* k_eth_newPendingTransactionFilter{"eth_newPendingTransactionFilter"}; inline constexpr const char* k_eth_getFilterLogs{"eth_getFilterLogs"}; inline constexpr const char* k_eth_getFilterChanges{"eth_getFilterChanges"}; inline constexpr const char* k_eth_uninstallFilter{"eth_uninstallFilter"}; inline constexpr const char* k_eth_getLogs{"eth_getLogs"}; inline constexpr const char* k_eth_sendRawTransaction{"eth_sendRawTransaction"}; inline constexpr const char* k_eth_sendTransaction{"eth_sendTransaction"}; inline constexpr const char* k_eth_signTransaction{"eth_signTransaction"}; inline constexpr const char* k_eth_getProof{"eth_getProof"}; inline constexpr const char* k_eth_mining{"eth_mining"}; inline constexpr const char* k_eth_coinbase{"eth_coinbase"}; inline constexpr const char* k_eth_hashrate{"eth_hashrate"}; inline constexpr const char* k_eth_submitHashrate{"eth_submitHashrate"}; inline constexpr const char* k_eth_getWork{"eth_getWork"}; inline constexpr const char* k_eth_submitWork{"eth_submitWork"}; inline constexpr const char* k_eth_subscribe{"eth_subscribe"}; inline constexpr const char* k_eth_unsubscribe{"eth_unsubscribe"}; inline constexpr const char* k_eth_getBlockByHash{"eth_getBlockByHash"}; inline constexpr const char* k_eth_getBlockTransactionCountByHash{"eth_getBlockTransactionCountByHash"}; inline constexpr const char* k_eth_getBlockByNumber{"eth_getBlockByNumber"}; inline constexpr const char* k_eth_getBlockTransactionCountByNumber{"eth_getBlockTransactionCountByNumber"}; inline constexpr const char* k_eth_getBlockReceipts{"eth_getBlockReceipts"}; inline constexpr const char* k_eth_getTransactionReceiptsByBlock{"eth_getTransactionReceiptsByBlock"}; inline constexpr const char* k_eth_maxPriorityFeePerGas{"eth_maxPriorityFeePerGas"}; inline constexpr const char* k_eth_feeHistory{"eth_feeHistory"}; inline constexpr const char* k_eth_blobBaseFee{"eth_blobBaseFee"}; inline constexpr const char* k_eth_baseFee{"eth_baseFee"}; inline constexpr const char* k_debug_accountRange{"debug_accountRange"}; inline constexpr const char* k_debug_getModifiedAccountsByNumber{"debug_getModifiedAccountsByNumber"}; inline constexpr const char* k_debug_getModifiedAccountsByHash{"debug_getModifiedAccountsByHash"}; inline constexpr const char* k_debug_storageRangeAt{"debug_storageRangeAt"}; inline constexpr const char* k_debug_accountAt{"debug_accountAt"}; inline constexpr const char* k_debug_traceTransaction{"debug_traceTransaction"}; inline constexpr const char* k_debug_traceCall{"debug_traceCall"}; inline constexpr const char* k_debug_traceCallMany{"debug_traceCallMany"}; inline constexpr const char* k_debug_traceBlockByNumber{"debug_traceBlockByNumber"}; inline constexpr const char* k_debug_traceBlockByHash{"debug_traceBlockByHash"}; inline constexpr const char* k_debug_getRawBlock{"debug_getRawBlock"}; inline constexpr const char* k_debug_getRawHeader{"debug_getRawHeader"}; inline constexpr const char* k_debug_getRawTransaction{"debug_getRawTransaction"}; inline constexpr const char* k_debug_getRawReceipts{"debug_getRawReceipts"}; inline constexpr const char* k_trace_call{"trace_call"}; inline constexpr const char* k_trace_callMany{"trace_callMany"}; inline constexpr const char* k_trace_rawTransaction{"trace_rawTransaction"}; inline constexpr const char* k_trace_replayBlockTransactions{"trace_replayBlockTransactions"}; inline constexpr const char* k_trace_replayTransaction{"trace_replayTransaction"}; inline constexpr const char* k_trace_block{"trace_block"}; inline constexpr const char* k_trace_filter{"trace_filter"}; inline constexpr const char* k_trace_get{"trace_get"}; inline constexpr const char* k_trace_transaction{"trace_transaction"}; inline constexpr const char* k_erigon_blockNumber{"erigon_blockNumber"}; inline constexpr const char* k_erigon_cacheCheck{"erigon_cacheCheck"}; inline constexpr const char* k_erigon_getBalanceChangesInBlock{"erigon_getBalanceChangesInBlock"}; inline constexpr const char* k_erigon_getBlockByTimestamp{"erigon_getBlockByTimestamp"}; inline constexpr const char* k_erigon_getBlockReceiptsByBlockHash{"erigon_getBlockReceiptsByBlockHash"}; inline constexpr const char* k_erigon_getHeaderByHash{"erigon_getHeaderByHash"}; inline constexpr const char* k_erigon_getHeaderByNumber{"erigon_getHeaderByNumber"}; inline constexpr const char* k_erigon_getLatestLogs{"erigon_getLatestLogs"}; inline constexpr const char* k_erigon_getLogsByHash{"erigon_getLogsByHash"}; inline constexpr const char* k_erigon_forks{"erigon_forks"}; inline constexpr const char* k_erigon_watchTheBurn{"erigon_watchTheBurn"}; inline constexpr const char* k_erigon_nodeInfo{"erigon_nodeInfo"}; inline constexpr const char* k_parity_listStorageKeys{"parity_listStorageKeys"}; inline constexpr const char* k_engine_exchangeCapabilities{"engine_exchangeCapabilities"}; inline constexpr const char* k_engine_getClientVersionV1{"engine_getClientVersionV1"}; inline constexpr const char* k_engine_getPayloadV1{"engine_getPayloadV1"}; inline constexpr const char* k_engine_getPayloadV2{"engine_getPayloadV2"}; inline constexpr const char* k_engine_getPayloadV3{"engine_getPayloadV3"}; inline constexpr const char* k_engine_getPayloadV4{"engine_getPayloadV4"}; inline constexpr const char* k_engine_getPayloadBodiesByHashV1{"engine_getPayloadBodiesByHashV1"}; inline constexpr const char* k_engine_getPayloadBodiesByRangeV1{"engine_getPayloadBodiesByRangeV1"}; inline constexpr const char* k_engine_newPayloadV1{"engine_newPayloadV1"}; inline constexpr const char* k_engine_newPayloadV2{"engine_newPayloadV2"}; inline constexpr const char* k_engine_newPayloadV3{"engine_newPayloadV3"}; inline constexpr const char* k_engine_newPayloadV4{"engine_newPayloadV4"}; inline constexpr const char* k_engine_forkchoiceUpdatedV1{"engine_forkchoiceUpdatedV1"}; inline constexpr const char* k_engine_forkchoiceUpdatedV2{"engine_forkchoiceUpdatedV2"}; inline constexpr const char* k_engine_forkchoiceUpdatedV3{"engine_forkchoiceUpdatedV3"}; inline constexpr const char* k_engine_exchangeTransitionConfiguration{"engine_exchangeTransitionConfigurationV1"}; inline constexpr const char* k_txpool_status{"txpool_status"}; inline constexpr const char* k_txpool_content{"txpool_content"}; inline constexpr const char* k_ots_getApiLevel{"ots_getApiLevel"}; inline constexpr const char* k_ots_hasCode{"ots_hasCode"}; inline constexpr const char* k_ots_getBlockDetails{"ots_getBlockDetails"}; inline constexpr const char* k_ots_getBlockDetailsByHash{"ots_getBlockDetailsByHash"}; inline constexpr const char* k_ots_getBlockTransactions{"ots_getBlockTransactions"}; inline constexpr const char* k_ots_getTransactionBySenderAndNonce{"ots_getTransactionBySenderAndNonce"}; inline constexpr const char* k_ots_getContractCreator{"ots_getContractCreator"}; inline constexpr const char* k_ots_traceTransaction{"ots_traceTransaction"}; inline constexpr const char* k_ots_getTransactionError{"ots_getTransactionError"}; inline constexpr const char* k_ots_getInternalOperations{"ots_getInternalOperations"}; inline constexpr const char* k_ots_search_transactions_after{"ots_searchTransactionsAfter"}; inline constexpr const char* k_ots_search_transactions_before{"ots_searchTransactionsBefore"}; // NOLINTEND(readability-identifier-naming) } // namespace silkworm::rpc::json_rpc::method ================================================ FILE: silkworm/rpc/json_rpc/request_handler.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "request_handler.hpp" #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { RequestHandler::RequestHandler(StreamWriter* stream_writer, commands::RpcApi& rpc_api, const commands::RpcApiTable& rpc_api_table, InterfaceLogSettings ifc_log_settings) : stream_writer_{stream_writer}, rpc_api_{rpc_api}, rpc_api_table_{rpc_api_table}, ifc_log_{ifc_log_settings.enabled ? std::make_shared(std::move(ifc_log_settings)) : nullptr} {} Task> RequestHandler::handle(const std::string& request, uint64_t request_id) { const auto start = clock_time::now(); std::string response; bool return_reply{true}; try { if (ifc_log_) { ifc_log_->log_req(request); } const auto request_json = prevalidate_and_parse(request); if (request_json.is_object()) { if (const auto valid_result{is_valid_jsonrpc(request_json)}; !valid_result) { response = make_json_error(request_json, kInvalidRequest, valid_result.error()).dump() + "\n"; } else { return_reply = co_await handle_request_and_create_reply(request_json, response, request_id); } } else { std::stringstream batch_reply_content; batch_reply_content << "["; int index = 0; for (auto& item : request_json.items()) { const auto& single_request_json{item.value()}; if (index++ > 0) { batch_reply_content << ","; } if (const auto valid_result{is_valid_jsonrpc(single_request_json)}; !valid_result) { batch_reply_content << make_json_error(request_json, kInvalidRequest, valid_result.error()).dump(); } else { std::string single_reply; return_reply = co_await handle_request_and_create_reply(single_request_json, single_reply, request_id); batch_reply_content << single_reply; } } batch_reply_content << "]"; response = batch_reply_content.str(); } } catch (const nlohmann::json::exception& e) { SILK_ERROR << "RequestHandler::handle nlohmann::json::exception: " << e.what(); response = make_json_error(0, kInvalidRequest, "invalid request").dump() + "\n"; return_reply = true; } catch (const std::runtime_error& re) { SILK_ERROR << "RequestHandler::handle runtime error: " << re.what(); response = make_json_error(0, kMethodNotFound, "invalid request").dump() + "\n"; return_reply = true; } if (ifc_log_) { ifc_log_->log_rsp(response); } SILK_TRACE << "handle HTTP request t=" << clock_time::since(start) << "ns"; if (return_reply) { co_return response; } else { co_return std::nullopt; } } /** * @brief Prevalidate and parse the JSON request. Specifically, it checks for nil characters that are only allowed inside quoted strings. * @param request The JSON request * @return The parsed JSON request */ nlohmann::json RequestHandler::prevalidate_and_parse(const std::string& request) { bool inside_quote = false; bool previous_char_escape = false; for (auto ch : request) { if (!inside_quote && ch == 0x0) { throw std::runtime_error("invalid request: nil character"); } if (ch == '"' && !previous_char_escape) { inside_quote = !inside_quote; } previous_char_escape = ch == '\\' && !previous_char_escape; } return nlohmann::json::parse(request); } ValidationResult RequestHandler::is_valid_jsonrpc(const nlohmann::json& request_json) { return json_rpc_validator_.validate(request_json); } Task RequestHandler::handle_request_and_create_reply(const nlohmann::json& request_json, std::string& response, uint64_t request_id) { if (!request_json.contains("method")) { response = make_json_error(request_json, kInvalidRequest, "invalid request").dump(); co_return true; } const auto method = request_json["method"].get(); if (method.empty()) { response = make_json_error(request_json, kInvalidRequest, "invalid request").dump(); co_return true; } // Dispatch JSON handlers in this order: 1) glaze JSON 2) nlohmann JSON 3) JSON streaming const auto json_glaze_handler = rpc_api_table_.find_json_glaze_handler(method); if (json_glaze_handler) { SILK_TRACE << "--> handle RPC request: " << method; co_await handle_request(*json_glaze_handler, request_json, response); SILK_TRACE << "<-- handle RPC request: " << method; co_return true; } const auto json_handler = rpc_api_table_.find_json_handler(method); if (json_handler) { SILK_TRACE << "--> handle RPC request: " << method; co_await handle_request(*json_handler, request_json, response); SILK_TRACE << "<-- handle RPC request: " << method; co_return true; } const auto stream_handler = rpc_api_table_.find_stream_handler(method); if (stream_handler) { SILK_TRACE << "--> handle RPC stream request: " << method; co_await handle_request(*stream_handler, request_json, request_id); SILK_TRACE << "<-- handle RPC stream request: " << method; co_return false; } response = make_json_error(request_json, kMethodNotFound, "the method " + method + " does not exist/is not available").dump(); co_return true; } Task RequestHandler::handle_request(commands::RpcApiTable::HandleMethodGlaze handler, const nlohmann::json& request_json, std::string& response) { try { std::string reply_json; reply_json.reserve(2048); co_await (rpc_api_.*handler)(request_json, reply_json); response = std::move(reply_json); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what(); response = make_json_error(request_json, 100, e.what()).dump(); } catch (...) { SILK_ERROR << "unexpected exception"; response = make_json_error(request_json, 100, "unexpected exception").dump(); } } Task RequestHandler::handle_request(commands::RpcApiTable::HandleMethod handler, const nlohmann::json& request_json, std::string& response) { try { nlohmann::json reply_json; co_await (rpc_api_.*handler)(request_json, reply_json); response = reply_json.dump( /*indent=*/-1, /*indent_char=*/' ', /*ensure_ascii=*/false, nlohmann::json::error_handler_t::replace); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what(); response = make_json_error(request_json, 100, e.what()).dump(); } catch (...) { SILK_ERROR << "unexpected exception"; response = make_json_error(request_json, 100, "unexpected exception").dump(); } } Task RequestHandler::handle_request(commands::RpcApiTable::HandleStream handler, const nlohmann::json& request_json, uint64_t request_id) { auto io_executor = co_await boost::asio::this_coro::executor; try { json::Stream stream(io_executor, *stream_writer_, request_id); co_await stream.open(); try { co_await (rpc_api_.*handler)(request_json, stream); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what(); const auto error = make_json_error(request_json, 100, e.what()); stream.write_json(error); } catch (...) { SILK_ERROR << "unexpected exception"; const auto error = make_json_error(request_json, 100, "unexpected exception"); stream.write_json(error); } co_await stream.close(); } catch (const std::exception& e) { SILK_ERROR << "exception: " << e.what(); } } } // namespace silkworm::rpc::json_rpc ================================================ FILE: silkworm/rpc/json_rpc/request_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::json_rpc { class RequestHandler : public rpc::RequestHandler { public: RequestHandler(StreamWriter* stream_writer, commands::RpcApi& rpc_api, const commands::RpcApiTable& rpc_api_table, InterfaceLogSettings ifc_log_settings = {}); ~RequestHandler() override = default; RequestHandler(const RequestHandler&) = delete; RequestHandler& operator=(const RequestHandler&) = delete; Task> handle(const std::string& request, uint64_t request_id) override; protected: Task handle_request_and_create_reply(const nlohmann::json& request_json, std::string& response, uint64_t request_id); private: nlohmann::json prevalidate_and_parse(const std::string& request); ValidationResult is_valid_jsonrpc(const nlohmann::json& request_json); Task handle_request( commands::RpcApiTable::HandleMethod handler, const nlohmann::json& request_json, std::string& response); Task handle_request( commands::RpcApiTable::HandleMethodGlaze handler, const nlohmann::json& request_json, std::string& response); Task handle_request(commands::RpcApiTable::HandleStream handler, const nlohmann::json& request_json, uint64_t request_id); StreamWriter* stream_writer_; commands::RpcApi& rpc_api_; const commands::RpcApiTable& rpc_api_table_; Validator json_rpc_validator_; std::shared_ptr ifc_log_; }; } // namespace silkworm::rpc::json_rpc ================================================ FILE: silkworm/rpc/json_rpc/request_handler_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "request_handler.hpp" #include #include namespace silkworm::rpc::json_rpc { #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(test_util::RpcApiE2ETest, "check handle_request no method", "[rpc][handle]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "error":{ "code":-32600, "message":"invalid request" } })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "check handle_request invalid method", "[rpc][handle_request]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":1, "method":"eth_AAA"})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":1, "error":{ "code":-32601, "message": "the method eth_AAA does not exist/is not available" } })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "check handle_request method return failed", "[rpc][handle_request]") { const nlohmann::json request = R"({"jsonrpc":"2.0","id":3,"method":"eth_getBlockByNumber","params":[]})"_json; std::string reply; run<&test_util::RequestHandlerForTest::request_and_create_reply>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "jsonrpc":"2.0", "id":3, "error":{ "code":-32602, "message":"invalid eth_getBlockByNumber params: []" } })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "check handle_request does not allow nil characters after json object", "[rpc][handle_request]") { // request: {"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["0x1A","0x2",[95,99]]}\0x0H static constexpr char kBinaryInputInternal[] = {0x7b, 0x22, 0x6a, 0x73, 0x6f, 0x6e, 0x72, 0x70, 0x63, 0x22, 0x3a, 0x22, 0x32, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x69, 0x64, 0x22, 0x3a, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x66, 0x65, 0x65, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x31, 0x41, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x32, 0x22, 0x2c, 0x5b, 0x39, 0x35, 0x2c, 0x39, 0x39, 0x5d, 0x5d, 0x7d, 0x0, 0x48}; const std::string_view request_view{&kBinaryInputInternal[0], sizeof(kBinaryInputInternal)}; const std::string request{request_view}; std::string reply; run<&test_util::RequestHandlerForTest::handle_request>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "error": { "code": -32601, "message": "invalid request" }, "id": null, "jsonrpc": "2.0" })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "check handle_request does not allow nil characters inside json object", "[rpc][handle_request]") { // request: {"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["0x1A","0x2",[95,99]]\0x0} static constexpr char kBinaryInputInternal[] = {0x7b, 0x22, 0x6a, 0x73, 0x6f, 0x6e, 0x72, 0x70, 0x63, 0x22, 0x3a, 0x22, 0x32, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x69, 0x64, 0x22, 0x3a, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x66, 0x65, 0x65, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x31, 0x41, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x32, 0x22, 0x2c, 0x5b, 0x39, 0x35, 0x2c, 0x39, 0x39, 0x5d, 0x5d, 0x0, 0x7d}; const std::string_view request_view{&kBinaryInputInternal[0], sizeof(kBinaryInputInternal)}; const std::string request{request_view}; std::string reply; run<&test_util::RequestHandlerForTest::handle_request>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "error": { "code": -32601, "message": "invalid request" }, "id": null, "jsonrpc": "2.0" })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "check handle_request does allow nil characters inside quoted string", "[rpc][handle_request]") { // request: {"jsonrpc":"2.0","id":1,"method":"eth_feeHistory\0x0","params":["0x1A","0x2",[95,99]]} static constexpr char kBinaryInputInternal[] = { 0x7b, 0x22, 0x6a, 0x73, 0x6f, 0x6e, 0x72, 0x70, 0x63, 0x22, 0x3a, 0x22, 0x32, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x69, 0x64, 0x22, 0x3a, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x66, 0x65, 0x65, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x0, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x31, 0x41, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x32, 0x22, 0x2c, 0x5b, 0x39, 0x35, 0x2c, 0x39, 0x39, 0x5d, 0x5d, 0x7d}; const std::string_view request_view{&kBinaryInputInternal[0], sizeof(kBinaryInputInternal)}; const std::string request{request_view}; std::string reply; run<&test_util::RequestHandlerForTest::handle_request>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "error": { "code": -32600, "message": "invalid request" }, "id": null, "jsonrpc": "2.0" })"_json); } TEST_CASE_METHOD(test_util::RpcApiE2ETest, "check handle_request does not allow missing params if required", "[rpc][handle_request]") { // request: {"jsonrpc":"2.0","id":1,"method":"eth_getBlockReceipts"}\012 static constexpr char kBinaryInputInternal[] = { 0x7b, 0x22, 0x6a, 0x73, 0x6f, 0x6e, 0x72, 0x70, 0x63, 0x22, 0x3a, 0x22, 0x32, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x69, 0x64, 0x22, 0x3a, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x22, 0x7d, 0xa}; const std::string_view request_view{&kBinaryInputInternal[0], sizeof(kBinaryInputInternal)}; const std::string request{request_view}; std::string reply; run<&test_util::RequestHandlerForTest::handle_request>(request, reply); CHECK(nlohmann::json::parse(reply) == R"({ "error": { "code": -32600, "message": "Missing required parameter: Block" }, "id": 1, "jsonrpc": "2.0" })"_json); } #endif } // namespace silkworm::rpc::json_rpc ================================================ FILE: silkworm/rpc/json_rpc/specification.cpp ================================================ /* Generated from specification.json using silkworm embed_json tool */ #include "specification.hpp" constexpr char kSpecificationDataInternal[] = { 0x7b, 0x22, 0x6f, 0x70, 0x65, 0x6e, 0x72, 0x70, 0x63, 0x22, 0x3a, 0x22, 0x31, 0x2e, 0x32, 0x2e, 0x34, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x66, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x20, 0x4a, 0x53, 0x4f, 0x4e, 0x2d, 0x52, 0x50, 0x43, 0x20, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x43, 0x30, 0x2d, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x73, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x7a, 0x65, 0x72, 0x6f, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x30, 0x2e, 0x30, 0x2e, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x45, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x20, 0x38, 0x2d, 0x62, 0x69, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x22, 0x3a, 0x20, 0x32, 0x35, 0x35, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x36, 0x34, 0x20, 0x62, 0x69, 0x74, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x64, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x20, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x20, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x75, 0x6d, 0x70, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x75, 0x6d, 0x70, 0x65, 0x64, 0x20, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x65, 0x78, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x6e, 0x65, 0x78, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x78, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x28, 0x3f, 0x3a, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x2b, 0x5c, 0x5c, 0x2f, 0x5d, 0x7b, 0x34, 0x7d, 0x29, 0x2a, 0x28, 0x3f, 0x3a, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x2b, 0x5c, 0x5c, 0x2f, 0x5d, 0x7b, 0x34, 0x7d, 0x7c, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x2b, 0x5c, 0x5c, 0x2f, 0x5d, 0x7b, 0x33, 0x7d, 0x3d, 0x7c, 0x5b, 0x41, 0x2d, 0x5a, 0x61, 0x2d, 0x7a, 0x30, 0x2d, 0x39, 0x2b, 0x5c, 0x5c, 0x2f, 0x5d, 0x7b, 0x32, 0x7d, 0x3d, 0x7b, 0x32, 0x7d, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x61, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x73, 0x65, 0x65, 0x6e, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x72, 0x6c, 0x70, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4f, 0x6d, 0x6d, 0x65, 0x72, 0x73, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x69, 0x78, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x75, 0x6c, 0x6c, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x75, 0x6e, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x34, 0x38, 0x34, 0x34, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x31, 0x35, 0x35, 0x39, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x32, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x32, 0x39, 0x33, 0x30, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x31, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x6c, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x4c, 0x50, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x63, 0x32, 0x65, 0x64, 0x63, 0x31, 0x63, 0x61, 0x37, 0x34, 0x62, 0x34, 0x38, 0x36, 0x33, 0x63, 0x61, 0x62, 0x34, 0x36, 0x66, 0x66, 0x36, 0x65, 0x64, 0x34, 0x64, 0x66, 0x35, 0x31, 0x34, 0x61, 0x36, 0x39, 0x38, 0x61, 0x61, 0x37, 0x63, 0x32, 0x39, 0x61, 0x39, 0x62, 0x63, 0x65, 0x35, 0x38, 0x37, 0x34, 0x32, 0x61, 0x33, 0x33, 0x61, 0x66, 0x30, 0x37, 0x64, 0x37, 0x65, 0x36, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x34, 0x34, 0x61, 0x32, 0x66, 0x37, 0x61, 0x34, 0x63, 0x38, 0x64, 0x65, 0x66, 0x63, 0x30, 0x64, 0x38, 0x64, 0x61, 0x34, 0x34, 0x61, 0x61, 0x30, 0x63, 0x30, 0x64, 0x62, 0x37, 0x63, 0x33, 0x36, 0x62, 0x35, 0x36, 0x64, 0x62, 0x32, 0x36, 0x30, 0x35, 0x63, 0x30, 0x31, 0x65, 0x64, 0x32, 0x36, 0x36, 0x65, 0x39, 0x31, 0x39, 0x65, 0x39, 0x33, 0x36, 0x35, 0x37, 0x39, 0x64, 0x33, 0x31, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x32, 0x63, 0x33, 0x38, 0x37, 0x65, 0x30, 0x30, 0x31, 0x63, 0x62, 0x65, 0x32, 0x61, 0x38, 0x32, 0x39, 0x36, 0x62, 0x66, 0x61, 0x32, 0x65, 0x31, 0x38, 0x61, 0x66, 0x62, 0x63, 0x33, 0x34, 0x38, 0x30, 0x64, 0x30, 0x65, 0x34, 0x39, 0x35, 0x38, 0x38, 0x62, 0x30, 0x35, 0x35, 0x35, 0x36, 0x31, 0x34, 0x38, 0x62, 0x30, 0x62, 0x66, 0x37, 0x63, 0x31, 0x37, 0x64, 0x65, 0x63, 0x34, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x36, 0x31, 0x61, 0x62, 0x37, 0x65, 0x38, 0x36, 0x38, 0x65, 0x33, 0x63, 0x32, 0x33, 0x66, 0x38, 0x34, 0x62, 0x37, 0x63, 0x34, 0x65, 0x64, 0x38, 0x36, 0x62, 0x35, 0x32, 0x61, 0x36, 0x61, 0x34, 0x66, 0x30, 0x36, 0x33, 0x36, 0x33, 0x33, 0x62, 0x63, 0x34, 0x35, 0x65, 0x66, 0x32, 0x39, 0x32, 0x31, 0x32, 0x63, 0x33, 0x33, 0x34, 0x35, 0x39, 0x64, 0x66, 0x38, 0x34, 0x65, 0x61, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x63, 0x64, 0x32, 0x64, 0x33, 0x33, 0x37, 0x36, 0x33, 0x64, 0x63, 0x30, 0x61, 0x63, 0x33, 0x66, 0x65, 0x30, 0x32, 0x64, 0x34, 0x65, 0x63, 0x62, 0x62, 0x63, 0x64, 0x37, 0x64, 0x32, 0x62, 0x64, 0x63, 0x36, 0x66, 0x35, 0x37, 0x64, 0x62, 0x36, 0x33, 0x35, 0x62, 0x61, 0x33, 0x31, 0x30, 0x30, 0x37, 0x31, 0x38, 0x34, 0x36, 0x37, 0x39, 0x33, 0x30, 0x33, 0x37, 0x32, 0x31, 0x64, 0x37, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x63, 0x36, 0x61, 0x30, 0x39, 0x31, 0x66, 0x30, 0x37, 0x65, 0x34, 0x62, 0x61, 0x33, 0x39, 0x33, 0x30, 0x66, 0x32, 0x66, 0x35, 0x66, 0x61, 0x62, 0x62, 0x66, 0x63, 0x35, 0x62, 0x31, 0x63, 0x37, 0x30, 0x39, 0x38, 0x36, 0x33, 0x31, 0x39, 0x30, 0x39, 0x36, 0x37, 0x36, 0x30, 0x62, 0x61, 0x32, 0x30, 0x30, 0x61, 0x36, 0x61, 0x62, 0x63, 0x30, 0x64, 0x33, 0x30, 0x65, 0x33, 0x33, 0x63, 0x32, 0x64, 0x35, 0x30, 0x31, 0x37, 0x30, 0x32, 0x64, 0x31, 0x62, 0x35, 0x38, 0x64, 0x37, 0x66, 0x37, 0x35, 0x38, 0x30, 0x37, 0x62, 0x64, 0x62, 0x66, 0x39, 0x38, 0x31, 0x30, 0x34, 0x34, 0x35, 0x35, 0x37, 0x36, 0x32, 0x38, 0x36, 0x31, 0x31, 0x33, 0x31, 0x39, 0x31, 0x32, 0x31, 0x31, 0x37, 0x30, 0x62, 0x39, 0x36, 0x34, 0x36, 0x36, 0x65, 0x63, 0x30, 0x36, 0x62, 0x62, 0x33, 0x66, 0x64, 0x30, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x61, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x61, 0x34, 0x38, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x66, 0x35, 0x62, 0x36, 0x38, 0x32, 0x34, 0x22, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x63, 0x32, 0x65, 0x64, 0x63, 0x31, 0x63, 0x61, 0x37, 0x34, 0x62, 0x34, 0x38, 0x36, 0x33, 0x63, 0x61, 0x62, 0x34, 0x36, 0x66, 0x66, 0x36, 0x65, 0x64, 0x34, 0x64, 0x66, 0x35, 0x31, 0x34, 0x61, 0x36, 0x39, 0x38, 0x61, 0x61, 0x37, 0x63, 0x32, 0x39, 0x61, 0x39, 0x62, 0x63, 0x65, 0x35, 0x38, 0x37, 0x34, 0x32, 0x61, 0x33, 0x33, 0x61, 0x66, 0x30, 0x37, 0x64, 0x37, 0x65, 0x36, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x65, 0x33, 0x62, 0x35, 0x35, 0x37, 0x65, 0x38, 0x66, 0x62, 0x36, 0x32, 0x62, 0x38, 0x39, 0x66, 0x34, 0x39, 0x31, 0x36, 0x62, 0x37, 0x32, 0x31, 0x62, 0x65, 0x35, 0x35, 0x63, 0x65, 0x62, 0x38, 0x32, 0x38, 0x64, 0x62, 0x64, 0x37, 0x33, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x61, 0x34, 0x39, 0x65, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x64, 0x64, 0x38, 0x63, 0x66, 0x30, 0x34, 0x35, 0x31, 0x31, 0x33, 0x37, 0x35, 0x34, 0x63, 0x33, 0x30, 0x36, 0x62, 0x61, 0x39, 0x61, 0x63, 0x38, 0x61, 0x63, 0x38, 0x37, 0x38, 0x36, 0x32, 0x33, 0x35, 0x65, 0x33, 0x33, 0x62, 0x63, 0x35, 0x63, 0x30, 0x38, 0x37, 0x36, 0x37, 0x38, 0x30, 0x38, 0x34, 0x65, 0x66, 0x32, 0x36, 0x30, 0x61, 0x32, 0x61, 0x35, 0x38, 0x33, 0x66, 0x31, 0x32, 0x37, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x63, 0x37, 0x38, 0x30, 0x36, 0x31, 0x30, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x30, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x66, 0x33, 0x66, 0x65, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x30, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x30, 0x33, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x35, 0x37, 0x33, 0x36, 0x31, 0x64, 0x31, 0x34, 0x36, 0x30, 0x33, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x30, 0x35, 0x37, 0x38, 0x34, 0x62, 0x38, 0x31, 0x34, 0x36, 0x30, 0x36, 0x32, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x30, 0x34, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, 0x65, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x36, 0x30, 0x36, 0x38, 0x36, 0x30, 0x38, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x32, 0x36, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x36, 0x37, 0x33, 0x35, 0x38, 0x32, 0x32, 0x31, 0x32, 0x32, 0x30, 0x38, 0x64, 0x65, 0x61, 0x30, 0x33, 0x39, 0x32, 0x34, 0x35, 0x62, 0x66, 0x37, 0x38, 0x63, 0x33, 0x38, 0x31, 0x32, 0x37, 0x38, 0x33, 0x38, 0x32, 0x64, 0x37, 0x30, 0x35, 0x36, 0x65, 0x65, 0x66, 0x35, 0x30, 0x38, 0x33, 0x66, 0x37, 0x64, 0x32, 0x34, 0x33, 0x64, 0x38, 0x39, 0x35, 0x38, 0x38, 0x31, 0x37, 0x65, 0x66, 0x34, 0x34, 0x37, 0x65, 0x30, 0x61, 0x34, 0x30, 0x33, 0x62, 0x64, 0x30, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x33, 0x33, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x39, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x37, 0x61, 0x31, 0x35, 0x30, 0x35, 0x30, 0x33, 0x30, 0x32, 0x63, 0x61, 0x34, 0x62, 0x37, 0x64, 0x33, 0x38, 0x34, 0x32, 0x64, 0x33, 0x35, 0x63, 0x64, 0x64, 0x33, 0x63, 0x62, 0x66, 0x32, 0x35, 0x62, 0x32, 0x63, 0x34, 0x38, 0x63, 0x30, 0x63, 0x33, 0x37, 0x66, 0x39, 0x36, 0x64, 0x37, 0x38, 0x62, 0x65, 0x62, 0x36, 0x61, 0x36, 0x61, 0x36, 0x62, 0x63, 0x34, 0x66, 0x31, 0x63, 0x37, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x33, 0x30, 0x64, 0x32, 0x39, 0x32, 0x39, 0x34, 0x62, 0x32, 0x62, 0x36, 0x61, 0x32, 0x62, 0x37, 0x65, 0x38, 0x39, 0x66, 0x35, 0x30, 0x31, 0x65, 0x62, 0x32, 0x37, 0x37, 0x37, 0x32, 0x66, 0x37, 0x61, 0x62, 0x66, 0x33, 0x37, 0x62, 0x66, 0x61, 0x32, 0x38, 0x61, 0x31, 0x63, 0x65, 0x33, 0x30, 0x30, 0x64, 0x61, 0x61, 0x64, 0x65, 0x39, 0x37, 0x35, 0x35, 0x38, 0x39, 0x66, 0x63, 0x61, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x63, 0x32, 0x65, 0x64, 0x63, 0x31, 0x63, 0x61, 0x37, 0x34, 0x62, 0x34, 0x38, 0x36, 0x33, 0x63, 0x61, 0x62, 0x34, 0x36, 0x66, 0x66, 0x36, 0x65, 0x64, 0x34, 0x64, 0x66, 0x35, 0x31, 0x34, 0x61, 0x36, 0x39, 0x38, 0x61, 0x61, 0x37, 0x63, 0x32, 0x39, 0x61, 0x39, 0x62, 0x63, 0x65, 0x35, 0x38, 0x37, 0x34, 0x32, 0x61, 0x33, 0x33, 0x61, 0x66, 0x30, 0x37, 0x64, 0x37, 0x65, 0x36, 0x22, 0x2c, 0x22, 0x72, 0x6c, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x39, 0x30, 0x33, 0x39, 0x64, 0x66, 0x39, 0x30, 0x32, 0x35, 0x63, 0x61, 0x30, 0x35, 0x34, 0x34, 0x61, 0x32, 0x66, 0x37, 0x61, 0x34, 0x63, 0x38, 0x64, 0x65, 0x66, 0x63, 0x30, 0x64, 0x38, 0x64, 0x61, 0x34, 0x34, 0x61, 0x61, 0x30, 0x63, 0x30, 0x64, 0x62, 0x37, 0x63, 0x33, 0x36, 0x62, 0x35, 0x36, 0x64, 0x62, 0x32, 0x36, 0x30, 0x35, 0x63, 0x30, 0x31, 0x65, 0x64, 0x32, 0x36, 0x36, 0x65, 0x39, 0x31, 0x39, 0x65, 0x39, 0x33, 0x36, 0x35, 0x37, 0x39, 0x64, 0x33, 0x31, 0x61, 0x30, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x38, 0x36, 0x31, 0x61, 0x62, 0x37, 0x65, 0x38, 0x36, 0x38, 0x65, 0x33, 0x63, 0x32, 0x33, 0x66, 0x38, 0x34, 0x62, 0x37, 0x63, 0x34, 0x65, 0x64, 0x38, 0x36, 0x62, 0x35, 0x32, 0x61, 0x36, 0x61, 0x34, 0x66, 0x30, 0x36, 0x33, 0x36, 0x33, 0x33, 0x62, 0x63, 0x34, 0x35, 0x65, 0x66, 0x32, 0x39, 0x32, 0x31, 0x32, 0x63, 0x33, 0x33, 0x34, 0x35, 0x39, 0x64, 0x66, 0x38, 0x34, 0x65, 0x61, 0x35, 0x61, 0x30, 0x30, 0x32, 0x63, 0x33, 0x38, 0x37, 0x65, 0x30, 0x30, 0x31, 0x63, 0x62, 0x65, 0x32, 0x61, 0x38, 0x32, 0x39, 0x36, 0x62, 0x66, 0x61, 0x32, 0x65, 0x31, 0x38, 0x61, 0x66, 0x62, 0x63, 0x33, 0x34, 0x38, 0x30, 0x64, 0x30, 0x65, 0x34, 0x39, 0x35, 0x38, 0x38, 0x62, 0x30, 0x35, 0x35, 0x35, 0x36, 0x31, 0x34, 0x38, 0x62, 0x30, 0x62, 0x66, 0x37, 0x63, 0x31, 0x37, 0x64, 0x65, 0x63, 0x34, 0x31, 0x61, 0x30, 0x63, 0x63, 0x64, 0x32, 0x64, 0x33, 0x33, 0x37, 0x36, 0x33, 0x64, 0x63, 0x30, 0x61, 0x63, 0x33, 0x66, 0x65, 0x30, 0x32, 0x64, 0x34, 0x65, 0x63, 0x62, 0x62, 0x63, 0x64, 0x37, 0x64, 0x32, 0x62, 0x64, 0x63, 0x36, 0x66, 0x35, 0x37, 0x64, 0x62, 0x36, 0x33, 0x35, 0x62, 0x61, 0x33, 0x31, 0x30, 0x30, 0x37, 0x31, 0x38, 0x34, 0x36, 0x37, 0x39, 0x33, 0x30, 0x33, 0x37, 0x32, 0x31, 0x64, 0x37, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x64, 0x38, 0x36, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x33, 0x30, 0x31, 0x61, 0x34, 0x38, 0x38, 0x38, 0x34, 0x35, 0x66, 0x35, 0x62, 0x36, 0x38, 0x32, 0x34, 0x62, 0x38, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x63, 0x36, 0x61, 0x30, 0x39, 0x31, 0x66, 0x30, 0x37, 0x65, 0x34, 0x62, 0x61, 0x33, 0x39, 0x33, 0x30, 0x66, 0x32, 0x66, 0x35, 0x66, 0x61, 0x62, 0x62, 0x66, 0x63, 0x35, 0x62, 0x31, 0x63, 0x37, 0x30, 0x39, 0x38, 0x36, 0x33, 0x31, 0x39, 0x30, 0x39, 0x36, 0x37, 0x36, 0x30, 0x62, 0x61, 0x32, 0x30, 0x30, 0x61, 0x36, 0x61, 0x62, 0x63, 0x30, 0x64, 0x33, 0x30, 0x65, 0x33, 0x33, 0x63, 0x32, 0x64, 0x35, 0x30, 0x31, 0x37, 0x30, 0x32, 0x64, 0x31, 0x62, 0x35, 0x38, 0x64, 0x37, 0x66, 0x37, 0x35, 0x38, 0x30, 0x37, 0x62, 0x64, 0x62, 0x66, 0x39, 0x38, 0x31, 0x30, 0x34, 0x34, 0x35, 0x35, 0x37, 0x36, 0x32, 0x38, 0x36, 0x31, 0x31, 0x33, 0x31, 0x39, 0x31, 0x32, 0x31, 0x31, 0x37, 0x30, 0x62, 0x39, 0x36, 0x34, 0x36, 0x36, 0x65, 0x63, 0x30, 0x36, 0x62, 0x62, 0x33, 0x66, 0x64, 0x30, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x39, 0x30, 0x31, 0x33, 0x61, 0x66, 0x39, 0x30, 0x31, 0x33, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x65, 0x38, 0x38, 0x33, 0x30, 0x31, 0x61, 0x34, 0x39, 0x65, 0x38, 0x30, 0x38, 0x30, 0x62, 0x38, 0x65, 0x36, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x63, 0x37, 0x38, 0x30, 0x36, 0x31, 0x30, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x30, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x66, 0x33, 0x66, 0x65, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x30, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x30, 0x33, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x35, 0x37, 0x33, 0x36, 0x31, 0x64, 0x31, 0x34, 0x36, 0x30, 0x33, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x30, 0x35, 0x37, 0x38, 0x34, 0x62, 0x38, 0x31, 0x34, 0x36, 0x30, 0x36, 0x32, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x30, 0x34, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, 0x65, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x36, 0x30, 0x36, 0x38, 0x36, 0x30, 0x38, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x32, 0x36, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x36, 0x37, 0x33, 0x35, 0x38, 0x32, 0x32, 0x31, 0x32, 0x32, 0x30, 0x38, 0x64, 0x65, 0x61, 0x30, 0x33, 0x39, 0x32, 0x34, 0x35, 0x62, 0x66, 0x37, 0x38, 0x63, 0x33, 0x38, 0x31, 0x32, 0x37, 0x38, 0x33, 0x38, 0x32, 0x64, 0x37, 0x30, 0x35, 0x36, 0x65, 0x65, 0x66, 0x35, 0x30, 0x38, 0x33, 0x66, 0x37, 0x64, 0x32, 0x34, 0x33, 0x64, 0x38, 0x39, 0x35, 0x38, 0x38, 0x31, 0x37, 0x65, 0x66, 0x34, 0x34, 0x37, 0x65, 0x30, 0x61, 0x34, 0x30, 0x33, 0x62, 0x64, 0x30, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x33, 0x33, 0x38, 0x32, 0x30, 0x66, 0x39, 0x64, 0x61, 0x30, 0x61, 0x37, 0x61, 0x31, 0x35, 0x30, 0x35, 0x30, 0x33, 0x30, 0x32, 0x63, 0x61, 0x34, 0x62, 0x37, 0x64, 0x33, 0x38, 0x34, 0x32, 0x64, 0x33, 0x35, 0x63, 0x64, 0x64, 0x33, 0x63, 0x62, 0x66, 0x32, 0x35, 0x62, 0x32, 0x63, 0x34, 0x38, 0x63, 0x30, 0x63, 0x33, 0x37, 0x66, 0x39, 0x36, 0x64, 0x37, 0x38, 0x62, 0x65, 0x62, 0x36, 0x61, 0x36, 0x61, 0x36, 0x62, 0x63, 0x34, 0x66, 0x31, 0x63, 0x37, 0x61, 0x30, 0x31, 0x33, 0x30, 0x64, 0x32, 0x39, 0x32, 0x39, 0x34, 0x62, 0x32, 0x62, 0x36, 0x61, 0x32, 0x62, 0x37, 0x65, 0x38, 0x39, 0x66, 0x35, 0x30, 0x31, 0x65, 0x62, 0x32, 0x37, 0x37, 0x37, 0x32, 0x66, 0x37, 0x61, 0x62, 0x66, 0x33, 0x37, 0x62, 0x66, 0x61, 0x32, 0x38, 0x61, 0x31, 0x63, 0x65, 0x33, 0x30, 0x30, 0x64, 0x61, 0x61, 0x64, 0x65, 0x39, 0x37, 0x35, 0x35, 0x38, 0x39, 0x66, 0x63, 0x61, 0x63, 0x30, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x31, 0x61, 0x33, 0x61, 0x65, 0x39, 0x62, 0x36, 0x65, 0x63, 0x65, 0x62, 0x32, 0x34, 0x37, 0x36, 0x64, 0x32, 0x34, 0x39, 0x65, 0x31, 0x63, 0x66, 0x66, 0x65, 0x30, 0x35, 0x38, 0x62, 0x61, 0x33, 0x66, 0x66, 0x32, 0x63, 0x39, 0x63, 0x31, 0x62, 0x32, 0x38, 0x62, 0x31, 0x65, 0x63, 0x37, 0x61, 0x30, 0x32, 0x35, 0x39, 0x66, 0x64, 0x64, 0x31, 0x64, 0x39, 0x30, 0x31, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x61, 0x65, 0x34, 0x34, 0x30, 0x63, 0x64, 0x37, 0x62, 0x39, 0x30, 0x34, 0x64, 0x38, 0x34, 0x32, 0x64, 0x61, 0x61, 0x36, 0x63, 0x32, 0x36, 0x33, 0x36, 0x30, 0x38, 0x39, 0x36, 0x39, 0x61, 0x33, 0x63, 0x38, 0x63, 0x65, 0x36, 0x61, 0x39, 0x61, 0x63, 0x64, 0x36, 0x62, 0x64, 0x31, 0x66, 0x39, 0x39, 0x62, 0x33, 0x39, 0x34, 0x66, 0x35, 0x66, 0x32, 0x38, 0x61, 0x32, 0x30, 0x37, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x65, 0x65, 0x39, 0x39, 0x38, 0x63, 0x63, 0x36, 0x39, 0x39, 0x61, 0x31, 0x66, 0x39, 0x33, 0x31, 0x30, 0x61, 0x31, 0x30, 0x37, 0x39, 0x34, 0x35, 0x38, 0x37, 0x38, 0x30, 0x62, 0x33, 0x65, 0x62, 0x65, 0x65, 0x38, 0x37, 0x35, 0x36, 0x66, 0x39, 0x36, 0x61, 0x30, 0x39, 0x30, 0x35, 0x66, 0x35, 0x32, 0x32, 0x34, 0x62, 0x38, 0x39, 0x64, 0x30, 0x65, 0x62, 0x31, 0x37, 0x34, 0x38, 0x36, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x34, 0x30, 0x61, 0x39, 0x37, 0x38, 0x33, 0x32, 0x39, 0x31, 0x37, 0x30, 0x34, 0x32, 0x32, 0x33, 0x65, 0x62, 0x37, 0x35, 0x39, 0x65, 0x33, 0x61, 0x30, 0x64, 0x62, 0x35, 0x34, 0x37, 0x31, 0x61, 0x35, 0x32, 0x30, 0x64, 0x33, 0x34, 0x39, 0x66, 0x63, 0x31, 0x37, 0x61, 0x63, 0x32, 0x66, 0x37, 0x37, 0x66, 0x66, 0x38, 0x35, 0x38, 0x32, 0x34, 0x37, 0x32, 0x65, 0x33, 0x62, 0x61, 0x63, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x62, 0x35, 0x63, 0x37, 0x37, 0x66, 0x36, 0x65, 0x37, 0x37, 0x36, 0x34, 0x64, 0x32, 0x34, 0x36, 0x38, 0x31, 0x37, 0x38, 0x66, 0x61, 0x62, 0x37, 0x32, 0x35, 0x33, 0x33, 0x34, 0x36, 0x62, 0x39, 0x62, 0x38, 0x62, 0x62, 0x36, 0x61, 0x33, 0x34, 0x62, 0x36, 0x33, 0x39, 0x34, 0x36, 0x66, 0x36, 0x62, 0x64, 0x63, 0x32, 0x66, 0x35, 0x61, 0x64, 0x33, 0x39, 0x38, 0x62, 0x66, 0x63, 0x33, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x30, 0x34, 0x35, 0x35, 0x31, 0x62, 0x64, 0x64, 0x39, 0x61, 0x65, 0x30, 0x38, 0x61, 0x66, 0x31, 0x66, 0x64, 0x36, 0x36, 0x31, 0x65, 0x34, 0x39, 0x64, 0x34, 0x61, 0x62, 0x36, 0x36, 0x32, 0x63, 0x39, 0x38, 0x63, 0x35, 0x33, 0x32, 0x63, 0x37, 0x65, 0x63, 0x30, 0x65, 0x34, 0x36, 0x35, 0x36, 0x61, 0x32, 0x37, 0x65, 0x34, 0x64, 0x65, 0x37, 0x64, 0x33, 0x33, 0x30, 0x61, 0x66, 0x35, 0x37, 0x38, 0x61, 0x62, 0x31, 0x65, 0x34, 0x66, 0x35, 0x65, 0x34, 0x39, 0x65, 0x30, 0x38, 0x35, 0x66, 0x66, 0x31, 0x64, 0x37, 0x38, 0x36, 0x37, 0x33, 0x63, 0x37, 0x33, 0x38, 0x38, 0x65, 0x64, 0x39, 0x63, 0x63, 0x66, 0x30, 0x31, 0x37, 0x66, 0x62, 0x65, 0x38, 0x39, 0x65, 0x35, 0x33, 0x30, 0x36, 0x36, 0x62, 0x66, 0x61, 0x34, 0x30, 0x31, 0x38, 0x31, 0x34, 0x32, 0x63, 0x30, 0x37, 0x30, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x61, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x61, 0x34, 0x63, 0x39, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x66, 0x35, 0x62, 0x36, 0x62, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x31, 0x61, 0x33, 0x61, 0x65, 0x39, 0x62, 0x36, 0x65, 0x63, 0x65, 0x62, 0x32, 0x34, 0x37, 0x36, 0x64, 0x32, 0x34, 0x39, 0x65, 0x31, 0x63, 0x66, 0x66, 0x65, 0x30, 0x35, 0x38, 0x62, 0x61, 0x33, 0x66, 0x66, 0x32, 0x63, 0x39, 0x63, 0x31, 0x62, 0x32, 0x38, 0x62, 0x31, 0x65, 0x63, 0x37, 0x61, 0x30, 0x32, 0x35, 0x39, 0x66, 0x64, 0x64, 0x31, 0x64, 0x39, 0x30, 0x31, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x65, 0x33, 0x62, 0x35, 0x35, 0x37, 0x65, 0x38, 0x66, 0x62, 0x36, 0x32, 0x62, 0x38, 0x39, 0x66, 0x34, 0x39, 0x31, 0x36, 0x62, 0x37, 0x32, 0x31, 0x62, 0x65, 0x35, 0x35, 0x63, 0x65, 0x62, 0x38, 0x32, 0x38, 0x64, 0x62, 0x64, 0x37, 0x33, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x61, 0x34, 0x63, 0x39, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x37, 0x35, 0x65, 0x33, 0x33, 0x36, 0x61, 0x34, 0x32, 0x38, 0x31, 0x62, 0x32, 0x39, 0x63, 0x36, 0x31, 0x39, 0x64, 0x66, 0x64, 0x34, 0x63, 0x63, 0x66, 0x62, 0x64, 0x32, 0x66, 0x39, 0x33, 0x30, 0x66, 0x33, 0x37, 0x32, 0x38, 0x62, 0x32, 0x30, 0x63, 0x61, 0x66, 0x39, 0x65, 0x30, 0x30, 0x36, 0x37, 0x32, 0x38, 0x34, 0x61, 0x61, 0x33, 0x32, 0x32, 0x34, 0x65, 0x36, 0x37, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x63, 0x37, 0x38, 0x30, 0x36, 0x31, 0x30, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x30, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x66, 0x33, 0x66, 0x65, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x30, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x30, 0x33, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x35, 0x37, 0x33, 0x36, 0x31, 0x64, 0x31, 0x34, 0x36, 0x30, 0x33, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x30, 0x35, 0x37, 0x38, 0x34, 0x62, 0x38, 0x31, 0x34, 0x36, 0x30, 0x36, 0x32, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x30, 0x34, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, 0x65, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x36, 0x30, 0x36, 0x38, 0x36, 0x30, 0x38, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x32, 0x36, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x36, 0x37, 0x33, 0x35, 0x38, 0x32, 0x32, 0x31, 0x32, 0x32, 0x30, 0x38, 0x64, 0x65, 0x61, 0x30, 0x33, 0x39, 0x32, 0x34, 0x35, 0x62, 0x66, 0x37, 0x38, 0x63, 0x33, 0x38, 0x31, 0x32, 0x37, 0x38, 0x33, 0x38, 0x32, 0x64, 0x37, 0x30, 0x35, 0x36, 0x65, 0x65, 0x66, 0x35, 0x30, 0x38, 0x33, 0x66, 0x37, 0x64, 0x32, 0x34, 0x33, 0x64, 0x38, 0x39, 0x35, 0x38, 0x38, 0x31, 0x37, 0x65, 0x66, 0x34, 0x34, 0x37, 0x65, 0x30, 0x61, 0x34, 0x30, 0x33, 0x62, 0x64, 0x30, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x33, 0x33, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x39, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x65, 0x33, 0x30, 0x36, 0x32, 0x34, 0x63, 0x30, 0x33, 0x30, 0x35, 0x65, 0x36, 0x34, 0x38, 0x31, 0x32, 0x65, 0x31, 0x64, 0x39, 0x65, 0x33, 0x32, 0x35, 0x62, 0x61, 0x36, 0x65, 0x35, 0x30, 0x34, 0x31, 0x30, 0x33, 0x31, 0x34, 0x36, 0x33, 0x34, 0x62, 0x30, 0x30, 0x38, 0x65, 0x64, 0x63, 0x62, 0x35, 0x30, 0x66, 0x34, 0x35, 0x62, 0x65, 0x37, 0x31, 0x66, 0x61, 0x30, 0x64, 0x34, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x30, 0x65, 0x32, 0x30, 0x35, 0x66, 0x61, 0x65, 0x64, 0x32, 0x33, 0x63, 0x32, 0x31, 0x39, 0x62, 0x61, 0x31, 0x35, 0x36, 0x31, 0x30, 0x64, 0x65, 0x32, 0x34, 0x35, 0x31, 0x64, 0x34, 0x35, 0x38, 0x63, 0x62, 0x64, 0x34, 0x32, 0x32, 0x31, 0x32, 0x30, 0x37, 0x62, 0x32, 0x31, 0x36, 0x38, 0x33, 0x34, 0x34, 0x63, 0x66, 0x63, 0x39, 0x37, 0x32, 0x61, 0x37, 0x39, 0x37, 0x33, 0x63, 0x30, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x31, 0x61, 0x33, 0x61, 0x65, 0x39, 0x62, 0x36, 0x65, 0x63, 0x65, 0x62, 0x32, 0x34, 0x37, 0x36, 0x64, 0x32, 0x34, 0x39, 0x65, 0x31, 0x63, 0x66, 0x66, 0x65, 0x30, 0x35, 0x38, 0x62, 0x61, 0x33, 0x66, 0x66, 0x32, 0x63, 0x39, 0x63, 0x31, 0x62, 0x32, 0x38, 0x62, 0x31, 0x65, 0x63, 0x37, 0x61, 0x30, 0x32, 0x35, 0x39, 0x66, 0x64, 0x64, 0x31, 0x64, 0x39, 0x30, 0x31, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x72, 0x6c, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x39, 0x30, 0x33, 0x39, 0x64, 0x66, 0x39, 0x30, 0x32, 0x35, 0x63, 0x61, 0x30, 0x39, 0x38, 0x61, 0x65, 0x34, 0x34, 0x30, 0x63, 0x64, 0x37, 0x62, 0x39, 0x30, 0x34, 0x64, 0x38, 0x34, 0x32, 0x64, 0x61, 0x61, 0x36, 0x63, 0x32, 0x36, 0x33, 0x36, 0x30, 0x38, 0x39, 0x36, 0x39, 0x61, 0x33, 0x63, 0x38, 0x63, 0x65, 0x36, 0x61, 0x39, 0x61, 0x63, 0x64, 0x36, 0x62, 0x64, 0x31, 0x66, 0x39, 0x39, 0x62, 0x33, 0x39, 0x34, 0x66, 0x35, 0x66, 0x32, 0x38, 0x61, 0x32, 0x30, 0x37, 0x61, 0x30, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x31, 0x34, 0x30, 0x61, 0x39, 0x37, 0x38, 0x33, 0x32, 0x39, 0x31, 0x37, 0x30, 0x34, 0x32, 0x32, 0x33, 0x65, 0x62, 0x37, 0x35, 0x39, 0x65, 0x33, 0x61, 0x30, 0x64, 0x62, 0x35, 0x34, 0x37, 0x31, 0x61, 0x35, 0x32, 0x30, 0x64, 0x33, 0x34, 0x39, 0x66, 0x63, 0x31, 0x37, 0x61, 0x63, 0x32, 0x66, 0x37, 0x37, 0x66, 0x66, 0x38, 0x35, 0x38, 0x32, 0x34, 0x37, 0x32, 0x65, 0x33, 0x62, 0x61, 0x63, 0x61, 0x30, 0x38, 0x65, 0x65, 0x39, 0x39, 0x38, 0x63, 0x63, 0x36, 0x39, 0x39, 0x61, 0x31, 0x66, 0x39, 0x33, 0x31, 0x30, 0x61, 0x31, 0x30, 0x37, 0x39, 0x34, 0x35, 0x38, 0x37, 0x38, 0x30, 0x62, 0x33, 0x65, 0x62, 0x65, 0x65, 0x38, 0x37, 0x35, 0x36, 0x66, 0x39, 0x36, 0x61, 0x30, 0x39, 0x30, 0x35, 0x66, 0x35, 0x32, 0x32, 0x34, 0x62, 0x38, 0x39, 0x64, 0x30, 0x65, 0x62, 0x31, 0x37, 0x34, 0x38, 0x36, 0x61, 0x30, 0x32, 0x62, 0x35, 0x63, 0x37, 0x37, 0x66, 0x36, 0x65, 0x37, 0x37, 0x36, 0x34, 0x64, 0x32, 0x34, 0x36, 0x38, 0x31, 0x37, 0x38, 0x66, 0x61, 0x62, 0x37, 0x32, 0x35, 0x33, 0x33, 0x34, 0x36, 0x62, 0x39, 0x62, 0x38, 0x62, 0x62, 0x36, 0x61, 0x33, 0x34, 0x62, 0x36, 0x33, 0x39, 0x34, 0x36, 0x66, 0x36, 0x62, 0x64, 0x63, 0x32, 0x66, 0x35, 0x61, 0x64, 0x33, 0x39, 0x38, 0x62, 0x66, 0x63, 0x33, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x38, 0x36, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x38, 0x33, 0x30, 0x31, 0x61, 0x34, 0x63, 0x39, 0x38, 0x34, 0x35, 0x66, 0x35, 0x62, 0x36, 0x62, 0x38, 0x30, 0x62, 0x38, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x30, 0x34, 0x35, 0x35, 0x31, 0x62, 0x64, 0x64, 0x39, 0x61, 0x65, 0x30, 0x38, 0x61, 0x66, 0x31, 0x66, 0x64, 0x36, 0x36, 0x31, 0x65, 0x34, 0x39, 0x64, 0x34, 0x61, 0x62, 0x36, 0x36, 0x32, 0x63, 0x39, 0x38, 0x63, 0x35, 0x33, 0x32, 0x63, 0x37, 0x65, 0x63, 0x30, 0x65, 0x34, 0x36, 0x35, 0x36, 0x61, 0x32, 0x37, 0x65, 0x34, 0x64, 0x65, 0x37, 0x64, 0x33, 0x33, 0x30, 0x61, 0x66, 0x35, 0x37, 0x38, 0x61, 0x62, 0x31, 0x65, 0x34, 0x66, 0x35, 0x65, 0x34, 0x39, 0x65, 0x30, 0x38, 0x35, 0x66, 0x66, 0x31, 0x64, 0x37, 0x38, 0x36, 0x37, 0x33, 0x63, 0x37, 0x33, 0x38, 0x38, 0x65, 0x64, 0x39, 0x63, 0x63, 0x66, 0x30, 0x31, 0x37, 0x66, 0x62, 0x65, 0x38, 0x39, 0x65, 0x35, 0x33, 0x30, 0x36, 0x36, 0x62, 0x66, 0x61, 0x34, 0x30, 0x31, 0x38, 0x31, 0x34, 0x32, 0x63, 0x30, 0x37, 0x30, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x39, 0x30, 0x31, 0x33, 0x61, 0x66, 0x39, 0x30, 0x31, 0x33, 0x37, 0x38, 0x30, 0x38, 0x32, 0x30, 0x33, 0x65, 0x38, 0x38, 0x33, 0x30, 0x31, 0x61, 0x34, 0x63, 0x39, 0x38, 0x30, 0x38, 0x30, 0x62, 0x38, 0x65, 0x36, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x31, 0x30, 0x30, 0x31, 0x30, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x63, 0x37, 0x38, 0x30, 0x36, 0x31, 0x30, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x30, 0x33, 0x39, 0x36, 0x30, 0x30, 0x30, 0x66, 0x33, 0x66, 0x65, 0x36, 0x30, 0x38, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x32, 0x33, 0x34, 0x38, 0x30, 0x31, 0x35, 0x36, 0x30, 0x30, 0x66, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x35, 0x30, 0x36, 0x30, 0x30, 0x34, 0x33, 0x36, 0x31, 0x30, 0x36, 0x30, 0x33, 0x32, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x33, 0x35, 0x36, 0x30, 0x65, 0x30, 0x31, 0x63, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x35, 0x37, 0x33, 0x36, 0x31, 0x64, 0x31, 0x34, 0x36, 0x30, 0x33, 0x37, 0x35, 0x37, 0x38, 0x30, 0x36, 0x33, 0x62, 0x30, 0x35, 0x37, 0x38, 0x34, 0x62, 0x38, 0x31, 0x34, 0x36, 0x30, 0x36, 0x32, 0x35, 0x37, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x36, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x34, 0x38, 0x30, 0x33, 0x36, 0x30, 0x33, 0x36, 0x30, 0x32, 0x30, 0x38, 0x31, 0x31, 0x30, 0x31, 0x35, 0x36, 0x30, 0x34, 0x62, 0x35, 0x37, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x66, 0x64, 0x35, 0x62, 0x38, 0x31, 0x30, 0x31, 0x39, 0x30, 0x38, 0x30, 0x38, 0x30, 0x33, 0x35, 0x39, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x30, 0x39, 0x32, 0x39, 0x31, 0x39, 0x30, 0x35, 0x30, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, 0x65, 0x35, 0x36, 0x35, 0x62, 0x30, 0x30, 0x35, 0x62, 0x36, 0x30, 0x36, 0x38, 0x36, 0x30, 0x38, 0x38, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x38, 0x32, 0x38, 0x31, 0x35, 0x32, 0x36, 0x30, 0x32, 0x30, 0x30, 0x31, 0x39, 0x31, 0x35, 0x30, 0x35, 0x30, 0x36, 0x30, 0x34, 0x30, 0x35, 0x31, 0x38, 0x30, 0x39, 0x31, 0x30, 0x33, 0x39, 0x30, 0x66, 0x33, 0x35, 0x62, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x38, 0x31, 0x39, 0x30, 0x35, 0x35, 0x35, 0x30, 0x35, 0x30, 0x35, 0x36, 0x35, 0x62, 0x36, 0x30, 0x30, 0x30, 0x38, 0x30, 0x35, 0x34, 0x39, 0x30, 0x35, 0x30, 0x39, 0x30, 0x35, 0x36, 0x66, 0x65, 0x61, 0x32, 0x36, 0x34, 0x36, 0x39, 0x37, 0x30, 0x36, 0x36, 0x37, 0x33, 0x35, 0x38, 0x32, 0x32, 0x31, 0x32, 0x32, 0x30, 0x38, 0x64, 0x65, 0x61, 0x30, 0x33, 0x39, 0x32, 0x34, 0x35, 0x62, 0x66, 0x37, 0x38, 0x63, 0x33, 0x38, 0x31, 0x32, 0x37, 0x38, 0x33, 0x38, 0x32, 0x64, 0x37, 0x30, 0x35, 0x36, 0x65, 0x65, 0x66, 0x35, 0x30, 0x38, 0x33, 0x66, 0x37, 0x64, 0x32, 0x34, 0x33, 0x64, 0x38, 0x39, 0x35, 0x38, 0x38, 0x31, 0x37, 0x65, 0x66, 0x34, 0x34, 0x37, 0x65, 0x30, 0x61, 0x34, 0x30, 0x33, 0x62, 0x64, 0x30, 0x36, 0x34, 0x37, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x33, 0x34, 0x33, 0x30, 0x30, 0x30, 0x36, 0x30, 0x36, 0x30, 0x30, 0x33, 0x33, 0x38, 0x32, 0x30, 0x66, 0x39, 0x64, 0x61, 0x30, 0x30, 0x32, 0x65, 0x33, 0x30, 0x36, 0x32, 0x34, 0x63, 0x30, 0x33, 0x30, 0x35, 0x65, 0x36, 0x34, 0x38, 0x31, 0x32, 0x65, 0x31, 0x64, 0x39, 0x65, 0x33, 0x32, 0x35, 0x62, 0x61, 0x36, 0x65, 0x35, 0x30, 0x34, 0x31, 0x30, 0x33, 0x31, 0x34, 0x36, 0x33, 0x34, 0x62, 0x30, 0x30, 0x38, 0x65, 0x64, 0x63, 0x62, 0x35, 0x30, 0x66, 0x34, 0x35, 0x62, 0x65, 0x37, 0x31, 0x66, 0x61, 0x30, 0x64, 0x34, 0x61, 0x30, 0x35, 0x30, 0x65, 0x32, 0x30, 0x35, 0x66, 0x61, 0x65, 0x64, 0x32, 0x33, 0x63, 0x32, 0x31, 0x39, 0x62, 0x61, 0x31, 0x35, 0x36, 0x31, 0x30, 0x64, 0x65, 0x32, 0x34, 0x35, 0x31, 0x64, 0x34, 0x35, 0x38, 0x63, 0x62, 0x64, 0x34, 0x32, 0x32, 0x31, 0x32, 0x30, 0x37, 0x62, 0x32, 0x31, 0x36, 0x38, 0x33, 0x34, 0x34, 0x63, 0x66, 0x63, 0x39, 0x37, 0x32, 0x61, 0x37, 0x39, 0x37, 0x33, 0x63, 0x30, 0x63, 0x30, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x52, 0x4c, 0x50, 0x2d, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x52, 0x4c, 0x50, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x32, 0x30, 0x32, 0x36, 0x45, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x52, 0x4c, 0x50, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x39, 0x36, 0x30, 0x39, 0x36, 0x66, 0x39, 0x30, 0x32, 0x33, 0x36, 0x61, 0x30, 0x39, 0x66, 0x37, 0x33, 0x36, 0x39, 0x31, 0x66, 0x36, 0x64, 0x61, 0x62, 0x63, 0x61, 0x34, 0x66, 0x30, 0x61, 0x39, 0x39, 0x62, 0x30, 0x35, 0x64, 0x30, 0x61, 0x37, 0x30, 0x31, 0x39, 0x39, 0x35, 0x35, 0x30, 0x36, 0x61, 0x61, 0x33, 0x31, 0x31, 0x64, 0x63, 0x61, 0x61, 0x39, 0x63, 0x65, 0x39, 0x38, 0x33, 0x33, 0x64, 0x36, 0x66, 0x34, 0x63, 0x61, 0x34, 0x37, 0x34, 0x63, 0x31, 0x36, 0x32, 0x61, 0x30, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x39, 0x34, 0x63, 0x36, 0x65, 0x32, 0x34, 0x35, 0x39, 0x39, 0x39, 0x31, 0x62, 0x66, 0x65, 0x32, 0x37, 0x63, 0x63, 0x61, 0x36, 0x64, 0x38, 0x36, 0x37, 0x32, 0x32, 0x66, 0x33, 0x35, 0x64, 0x61, 0x32, 0x33, 0x61, 0x31, 0x65, 0x34, 0x63, 0x62, 0x39, 0x37, 0x61, 0x30, 0x37, 0x38, 0x31, 0x30, 0x33, 0x65, 0x61, 0x38, 0x63, 0x34, 0x37, 0x32, 0x33, 0x31, 0x38, 0x38, 0x36, 0x34, 0x38, 0x31, 0x64, 0x37, 0x32, 0x65, 0x63, 0x31, 0x61, 0x66, 0x61, 0x65, 0x36, 0x65, 0x65, 0x62, 0x30, 0x36, 0x63, 0x33, 0x37, 0x37, 0x33, 0x63, 0x65, 0x32, 0x34, 0x61, 0x39, 0x31, 0x33, 0x32, 0x33, 0x64, 0x35, 0x63, 0x39, 0x65, 0x65, 0x64, 0x36, 0x39, 0x64, 0x34, 0x63, 0x63, 0x61, 0x30, 0x30, 0x30, 0x38, 0x39, 0x39, 0x32, 0x64, 0x61, 0x32, 0x35, 0x33, 0x31, 0x64, 0x62, 0x34, 0x30, 0x34, 0x66, 0x30, 0x37, 0x62, 0x30, 0x38, 0x37, 0x31, 0x64, 0x64, 0x36, 0x32, 0x30, 0x61, 0x39, 0x34, 0x62, 0x61, 0x33, 0x34, 0x36, 0x39, 0x36, 0x33, 0x65, 0x31, 0x62, 0x31, 0x63, 0x36, 0x64, 0x63, 0x37, 0x62, 0x30, 0x30, 0x37, 0x34, 0x38, 0x65, 0x38, 0x35, 0x39, 0x33, 0x61, 0x31, 0x65, 0x61, 0x30, 0x62, 0x36, 0x63, 0x33, 0x38, 0x39, 0x30, 0x64, 0x39, 0x36, 0x30, 0x34, 0x34, 0x33, 0x34, 0x66, 0x63, 0x35, 0x32, 0x66, 0x37, 0x32, 0x32, 0x38, 0x34, 0x38, 0x63, 0x38, 0x34, 0x64, 0x31, 0x37, 0x37, 0x30, 0x61, 0x64, 0x64, 0x32, 0x30, 0x63, 0x64, 0x37, 0x35, 0x62, 0x62, 0x63, 0x32, 0x38, 0x63, 0x64, 0x65, 0x64, 0x66, 0x66, 0x34, 0x32, 0x39, 0x34, 0x30, 0x64, 0x62, 0x62, 0x35, 0x36, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x32, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x34, 0x38, 0x30, 0x30, 0x32, 0x30, 0x38, 0x34, 0x30, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x34, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x34, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x32, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x34, 0x31, 0x30, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x38, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x38, 0x30, 0x30, 0x34, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x30, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x33, 0x32, 0x30, 0x32, 0x36, 0x65, 0x38, 0x34, 0x30, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x38, 0x33, 0x33, 0x65, 0x33, 0x63, 0x33, 0x63, 0x38, 0x34, 0x36, 0x34, 0x33, 0x36, 0x66, 0x39, 0x33, 0x38, 0x39, 0x39, 0x64, 0x38, 0x38, 0x33, 0x30, 0x31, 0x30, 0x62, 0x30, 0x35, 0x38, 0x34, 0x36, 0x37, 0x36, 0x35, 0x37, 0x34, 0x36, 0x38, 0x38, 0x38, 0x36, 0x37, 0x36, 0x66, 0x33, 0x31, 0x32, 0x65, 0x33, 0x32, 0x33, 0x30, 0x32, 0x65, 0x33, 0x32, 0x38, 0x35, 0x36, 0x63, 0x36, 0x39, 0x36, 0x65, 0x37, 0x35, 0x37, 0x38, 0x61, 0x30, 0x31, 0x31, 0x32, 0x64, 0x38, 0x66, 0x31, 0x35, 0x37, 0x39, 0x33, 0x65, 0x37, 0x64, 0x66, 0x37, 0x66, 0x38, 0x64, 0x63, 0x64, 0x62, 0x32, 0x31, 0x63, 0x38, 0x39, 0x31, 0x63, 0x66, 0x66, 0x37, 0x38, 0x63, 0x30, 0x64, 0x31, 0x38, 0x33, 0x39, 0x63, 0x62, 0x35, 0x62, 0x36, 0x64, 0x63, 0x64, 0x30, 0x36, 0x31, 0x31, 0x36, 0x63, 0x64, 0x62, 0x62, 0x39, 0x39, 0x35, 0x33, 0x36, 0x61, 0x65, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, 0x30, 0x63, 0x64, 0x62, 0x39, 0x37, 0x37, 0x31, 0x32, 0x61, 0x66, 0x36, 0x36, 0x38, 0x35, 0x62, 0x62, 0x39, 0x36, 0x35, 0x30, 0x64, 0x32, 0x31, 0x64, 0x36, 0x30, 0x39, 0x35, 0x32, 0x35, 0x39, 0x31, 0x33, 0x32, 0x39, 0x33, 0x63, 0x34, 0x38, 0x61, 0x64, 0x64, 0x61, 0x37, 0x63, 0x34, 0x35, 0x39, 0x39, 0x30, 0x39, 0x32, 0x36, 0x64, 0x61, 0x61, 0x64, 0x61, 0x33, 0x33, 0x35, 0x63, 0x39, 0x62, 0x66, 0x39, 0x35, 0x63, 0x35, 0x36, 0x66, 0x38, 0x61, 0x63, 0x38, 0x32, 0x64, 0x35, 0x31, 0x66, 0x38, 0x35, 0x30, 0x32, 0x35, 0x34, 0x30, 0x62, 0x65, 0x34, 0x30, 0x30, 0x38, 0x33, 0x30, 0x33, 0x63, 0x39, 0x65, 0x32, 0x39, 0x34, 0x61, 0x36, 0x38, 0x64, 0x34, 0x63, 0x31, 0x65, 0x33, 0x64, 0x65, 0x31, 0x62, 0x37, 0x32, 0x31, 0x61, 0x64, 0x31, 0x33, 0x35, 0x36, 0x62, 0x62, 0x66, 0x38, 0x32, 0x37, 0x64, 0x36, 0x62, 0x63, 0x38, 0x63, 0x65, 0x66, 0x33, 0x30, 0x34, 0x66, 0x38, 0x30, 0x62, 0x38, 0x34, 0x34, 0x62, 0x31, 0x62, 0x62, 0x34, 0x64, 0x33, 0x35, 0x31, 0x33, 0x30, 0x30, 0x64, 0x62, 0x63, 0x37, 0x65, 0x31, 0x32, 0x33, 0x34, 0x32, 0x35, 0x36, 0x36, 0x33, 0x31, 0x38, 0x30, 0x30, 0x31, 0x62, 0x38, 0x33, 0x61, 0x65, 0x66, 0x63, 0x39, 0x66, 0x32, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x66, 0x33, 0x65, 0x66, 0x32, 0x35, 0x34, 0x37, 0x32, 0x34, 0x30, 0x37, 0x66, 0x65, 0x39, 0x63, 0x39, 0x63, 0x36, 0x39, 0x61, 0x31, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x36, 0x39, 0x32, 0x62, 0x62, 0x34, 0x63, 0x64, 0x35, 0x30, 0x36, 0x63, 0x34, 0x30, 0x39, 0x36, 0x35, 0x31, 0x61, 0x62, 0x38, 0x30, 0x65, 0x62, 0x33, 0x61, 0x63, 0x66, 0x61, 0x35, 0x34, 0x35, 0x35, 0x31, 0x64, 0x33, 0x64, 0x62, 0x63, 0x39, 0x61, 0x66, 0x34, 0x34, 0x39, 0x33, 0x36, 0x30, 0x35, 0x64, 0x37, 0x39, 0x38, 0x37, 0x31, 0x62, 0x61, 0x30, 0x31, 0x65, 0x34, 0x37, 0x34, 0x66, 0x62, 0x31, 0x34, 0x37, 0x62, 0x31, 0x36, 0x62, 0x39, 0x35, 0x33, 0x38, 0x64, 0x37, 0x61, 0x35, 0x39, 0x61, 0x35, 0x37, 0x37, 0x33, 0x38, 0x65, 0x34, 0x30, 0x36, 0x31, 0x35, 0x38, 0x64, 0x39, 0x63, 0x63, 0x33, 0x30, 0x36, 0x61, 0x39, 0x30, 0x36, 0x32, 0x62, 0x31, 0x62, 0x37, 0x61, 0x39, 0x66, 0x35, 0x34, 0x34, 0x63, 0x33, 0x35, 0x61, 0x62, 0x66, 0x61, 0x30, 0x36, 0x31, 0x61, 0x61, 0x62, 0x62, 0x37, 0x31, 0x34, 0x63, 0x37, 0x36, 0x30, 0x66, 0x32, 0x32, 0x34, 0x33, 0x61, 0x31, 0x36, 0x61, 0x30, 0x32, 0x34, 0x38, 0x31, 0x31, 0x36, 0x37, 0x39, 0x64, 0x34, 0x30, 0x32, 0x63, 0x38, 0x38, 0x32, 0x32, 0x65, 0x38, 0x62, 0x32, 0x35, 0x64, 0x66, 0x64, 0x30, 0x30, 0x33, 0x38, 0x64, 0x38, 0x34, 0x32, 0x39, 0x38, 0x66, 0x62, 0x35, 0x32, 0x30, 0x35, 0x62, 0x38, 0x37, 0x35, 0x30, 0x32, 0x66, 0x38, 0x37, 0x32, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x35, 0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x32, 0x66, 0x39, 0x30, 0x30, 0x38, 0x34, 0x39, 0x35, 0x30, 0x32, 0x66, 0x39, 0x31, 0x30, 0x38, 0x33, 0x30, 0x32, 0x32, 0x32, 0x32, 0x37, 0x39, 0x34, 0x31, 0x30, 0x32, 0x35, 0x35, 0x34, 0x61, 0x66, 0x61, 0x36, 0x62, 0x35, 0x64, 0x62, 0x63, 0x63, 0x63, 0x38, 0x36, 0x31, 0x37, 0x36, 0x66, 0x61, 0x65, 0x66, 0x32, 0x62, 0x32, 0x64, 0x38, 0x35, 0x34, 0x32, 0x30, 0x31, 0x37, 0x35, 0x36, 0x65, 0x38, 0x30, 0x38, 0x34, 0x65, 0x32, 0x62, 0x63, 0x37, 0x62, 0x34, 0x33, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x34, 0x66, 0x32, 0x33, 0x39, 0x38, 0x66, 0x32, 0x34, 0x62, 0x63, 0x39, 0x35, 0x30, 0x64, 0x62, 0x31, 0x66, 0x35, 0x34, 0x33, 0x39, 0x64, 0x65, 0x33, 0x63, 0x66, 0x36, 0x34, 0x33, 0x31, 0x65, 0x61, 0x32, 0x37, 0x37, 0x32, 0x33, 0x36, 0x35, 0x39, 0x35, 0x61, 0x65, 0x38, 0x64, 0x63, 0x35, 0x38, 0x31, 0x35, 0x63, 0x30, 0x63, 0x63, 0x36, 0x37, 0x31, 0x63, 0x39, 0x66, 0x39, 0x37, 0x63, 0x61, 0x30, 0x32, 0x39, 0x38, 0x39, 0x38, 0x37, 0x38, 0x36, 0x61, 0x35, 0x39, 0x63, 0x35, 0x36, 0x66, 0x30, 0x38, 0x36, 0x66, 0x63, 0x30, 0x66, 0x37, 0x61, 0x31, 0x36, 0x38, 0x35, 0x39, 0x66, 0x33, 0x36, 0x36, 0x63, 0x66, 0x34, 0x36, 0x30, 0x38, 0x34, 0x61, 0x64, 0x64, 0x39, 0x39, 0x39, 0x66, 0x65, 0x31, 0x33, 0x37, 0x63, 0x62, 0x66, 0x34, 0x33, 0x36, 0x39, 0x33, 0x37, 0x31, 0x32, 0x65, 0x38, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x66, 0x38, 0x37, 0x39, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x32, 0x39, 0x33, 0x37, 0x34, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x36, 0x35, 0x61, 0x30, 0x62, 0x63, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x34, 0x66, 0x61, 0x66, 0x62, 0x35, 0x36, 0x62, 0x62, 0x35, 0x62, 0x33, 0x37, 0x63, 0x33, 0x62, 0x30, 0x62, 0x30, 0x65, 0x65, 0x39, 0x64, 0x37, 0x63, 0x33, 0x31, 0x66, 0x30, 0x31, 0x38, 0x61, 0x61, 0x63, 0x39, 0x31, 0x64, 0x66, 0x62, 0x37, 0x37, 0x38, 0x38, 0x30, 0x36, 0x66, 0x30, 0x35, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x62, 0x30, 0x36, 0x39, 0x64, 0x64, 0x38, 0x39, 0x36, 0x37, 0x35, 0x33, 0x33, 0x61, 0x37, 0x37, 0x33, 0x65, 0x35, 0x39, 0x32, 0x63, 0x32, 0x36, 0x62, 0x31, 0x62, 0x33, 0x36, 0x64, 0x66, 0x30, 0x37, 0x39, 0x33, 0x64, 0x30, 0x62, 0x39, 0x66, 0x36, 0x65, 0x63, 0x65, 0x62, 0x61, 0x33, 0x34, 0x64, 0x61, 0x32, 0x34, 0x36, 0x66, 0x36, 0x30, 0x32, 0x63, 0x32, 0x66, 0x61, 0x65, 0x35, 0x38, 0x61, 0x30, 0x30, 0x32, 0x30, 0x30, 0x39, 0x64, 0x61, 0x62, 0x33, 0x32, 0x61, 0x62, 0x36, 0x33, 0x61, 0x32, 0x35, 0x62, 0x37, 0x30, 0x35, 0x64, 0x39, 0x61, 0x30, 0x30, 0x65, 0x33, 0x31, 0x31, 0x66, 0x37, 0x63, 0x64, 0x35, 0x64, 0x38, 0x35, 0x65, 0x37, 0x33, 0x66, 0x39, 0x62, 0x32, 0x63, 0x30, 0x33, 0x66, 0x66, 0x64, 0x30, 0x65, 0x35, 0x31, 0x33, 0x35, 0x63, 0x30, 0x62, 0x62, 0x32, 0x63, 0x36, 0x62, 0x38, 0x39, 0x35, 0x30, 0x32, 0x66, 0x38, 0x39, 0x32, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x30, 0x31, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x39, 0x38, 0x33, 0x30, 0x31, 0x31, 0x66, 0x65, 0x63, 0x39, 0x34, 0x35, 0x62, 0x39, 0x66, 0x65, 0x64, 0x64, 0x33, 0x37, 0x66, 0x30, 0x62, 0x39, 0x32, 0x65, 0x37, 0x65, 0x32, 0x38, 0x32, 0x62, 0x31, 0x39, 0x63, 0x65, 0x62, 0x63, 0x66, 0x30, 0x36, 0x66, 0x35, 0x37, 0x62, 0x37, 0x37, 0x63, 0x36, 0x30, 0x34, 0x38, 0x30, 0x61, 0x34, 0x36, 0x61, 0x36, 0x32, 0x37, 0x38, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x61, 0x31, 0x66, 0x63, 0x63, 0x36, 0x66, 0x63, 0x63, 0x35, 0x38, 0x33, 0x32, 0x63, 0x64, 0x32, 0x64, 0x62, 0x37, 0x37, 0x30, 0x34, 0x64, 0x37, 0x35, 0x65, 0x66, 0x62, 0x63, 0x38, 0x30, 0x30, 0x66, 0x35, 0x61, 0x37, 0x34, 0x32, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x63, 0x36, 0x35, 0x65, 0x62, 0x30, 0x65, 0x34, 0x38, 0x30, 0x39, 0x30, 0x61, 0x38, 0x66, 0x38, 0x38, 0x33, 0x30, 0x64, 0x65, 0x34, 0x37, 0x66, 0x34, 0x33, 0x30, 0x62, 0x39, 0x61, 0x64, 0x31, 0x31, 0x30, 0x37, 0x31, 0x61, 0x36, 0x32, 0x61, 0x35, 0x64, 0x62, 0x39, 0x35, 0x35, 0x35, 0x36, 0x31, 0x39, 0x61, 0x39, 0x39, 0x30, 0x64, 0x37, 0x65, 0x39, 0x62, 0x38, 0x31, 0x37, 0x33, 0x38, 0x61, 0x30, 0x35, 0x61, 0x36, 0x65, 0x38, 0x32, 0x36, 0x36, 0x31, 0x30, 0x61, 0x35, 0x62, 0x32, 0x65, 0x65, 0x35, 0x32, 0x39, 0x61, 0x32, 0x32, 0x39, 0x34, 0x32, 0x65, 0x62, 0x63, 0x64, 0x33, 0x61, 0x62, 0x64, 0x32, 0x61, 0x38, 0x61, 0x31, 0x30, 0x32, 0x32, 0x38, 0x30, 0x39, 0x38, 0x63, 0x38, 0x31, 0x35, 0x38, 0x33, 0x38, 0x30, 0x65, 0x38, 0x66, 0x63, 0x63, 0x65, 0x62, 0x39, 0x36, 0x32, 0x66, 0x62, 0x39, 0x30, 0x32, 0x38, 0x30, 0x30, 0x32, 0x66, 0x39, 0x30, 0x32, 0x37, 0x63, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x31, 0x37, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x39, 0x38, 0x33, 0x30, 0x31, 0x37, 0x61, 0x63, 0x39, 0x39, 0x34, 0x32, 0x61, 0x62, 0x37, 0x63, 0x30, 0x61, 0x62, 0x39, 0x61, 0x62, 0x34, 0x37, 0x66, 0x63, 0x66, 0x33, 0x37, 0x30, 0x64, 0x31, 0x33, 0x30, 0x35, 0x38, 0x62, 0x66, 0x65, 0x65, 0x32, 0x38, 0x66, 0x32, 0x65, 0x63, 0x30, 0x39, 0x34, 0x30, 0x63, 0x38, 0x38, 0x30, 0x31, 0x36, 0x39, 0x39, 0x36, 0x34, 0x33, 0x39, 0x34, 0x66, 0x63, 0x38, 0x38, 0x36, 0x30, 0x62, 0x39, 0x30, 0x32, 0x30, 0x34, 0x39, 0x36, 0x65, 0x31, 0x37, 0x38, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x61, 0x34, 0x64, 0x37, 0x65, 0x62, 0x35, 0x35, 0x65, 0x63, 0x32, 0x35, 0x33, 0x39, 0x66, 0x35, 0x33, 0x30, 0x35, 0x65, 0x62, 0x32, 0x37, 0x65, 0x61, 0x34, 0x32, 0x66, 0x36, 0x66, 0x39, 0x30, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x63, 0x35, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x61, 0x34, 0x64, 0x37, 0x65, 0x62, 0x35, 0x35, 0x65, 0x63, 0x32, 0x35, 0x33, 0x39, 0x66, 0x35, 0x33, 0x30, 0x35, 0x65, 0x62, 0x32, 0x37, 0x65, 0x61, 0x34, 0x32, 0x66, 0x36, 0x66, 0x39, 0x30, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x61, 0x34, 0x64, 0x37, 0x65, 0x62, 0x35, 0x35, 0x65, 0x63, 0x32, 0x35, 0x33, 0x39, 0x66, 0x35, 0x33, 0x30, 0x35, 0x65, 0x62, 0x32, 0x37, 0x65, 0x61, 0x34, 0x32, 0x66, 0x36, 0x66, 0x39, 0x30, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x61, 0x34, 0x64, 0x37, 0x65, 0x62, 0x35, 0x35, 0x65, 0x63, 0x32, 0x35, 0x33, 0x39, 0x66, 0x35, 0x33, 0x30, 0x35, 0x65, 0x62, 0x32, 0x37, 0x65, 0x61, 0x34, 0x32, 0x66, 0x36, 0x66, 0x39, 0x30, 0x66, 0x31, 0x36, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x33, 0x34, 0x35, 0x37, 0x38, 0x35, 0x64, 0x38, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x30, 0x63, 0x62, 0x33, 0x37, 0x37, 0x32, 0x38, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x30, 0x34, 0x66, 0x38, 0x36, 0x36, 0x36, 0x63, 0x38, 0x65, 0x35, 0x64, 0x30, 0x66, 0x33, 0x63, 0x37, 0x31, 0x31, 0x30, 0x39, 0x39, 0x34, 0x66, 0x36, 0x32, 0x34, 0x64, 0x32, 0x34, 0x61, 0x61, 0x34, 0x37, 0x61, 0x31, 0x33, 0x32, 0x37, 0x38, 0x31, 0x34, 0x32, 0x38, 0x39, 0x36, 0x39, 0x38, 0x63, 0x33, 0x65, 0x32, 0x37, 0x37, 0x37, 0x32, 0x38, 0x34, 0x61, 0x35, 0x63, 0x66, 0x64, 0x63, 0x61, 0x30, 0x34, 0x66, 0x66, 0x30, 0x35, 0x66, 0x31, 0x62, 0x38, 0x63, 0x35, 0x62, 0x65, 0x62, 0x35, 0x38, 0x39, 0x37, 0x32, 0x64, 0x34, 0x30, 0x65, 0x35, 0x61, 0x37, 0x62, 0x38, 0x39, 0x34, 0x64, 0x35, 0x65, 0x32, 0x38, 0x61, 0x64, 0x32, 0x66, 0x31, 0x35, 0x61, 0x33, 0x34, 0x32, 0x39, 0x63, 0x37, 0x64, 0x32, 0x62, 0x65, 0x65, 0x36, 0x62, 0x36, 0x61, 0x39, 0x36, 0x33, 0x33, 0x37, 0x33, 0x30, 0x62, 0x39, 0x30, 0x31, 0x39, 0x66, 0x30, 0x32, 0x66, 0x39, 0x30, 0x31, 0x39, 0x62, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x30, 0x62, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x39, 0x38, 0x33, 0x30, 0x33, 0x36, 0x34, 0x34, 0x66, 0x39, 0x34, 0x34, 0x32, 0x38, 0x34, 0x38, 0x39, 0x30, 0x64, 0x34, 0x61, 0x63, 0x64, 0x30, 0x62, 0x63, 0x62, 0x30, 0x31, 0x37, 0x65, 0x63, 0x65, 0x34, 0x38, 0x31, 0x62, 0x39, 0x36, 0x66, 0x64, 0x34, 0x63, 0x62, 0x34, 0x35, 0x37, 0x63, 0x61, 0x63, 0x38, 0x38, 0x37, 0x31, 0x35, 0x63, 0x30, 0x66, 0x34, 0x64, 0x62, 0x36, 0x65, 0x30, 0x65, 0x61, 0x30, 0x62, 0x39, 0x30, 0x31, 0x32, 0x34, 0x65, 0x65, 0x31, 0x34, 0x39, 0x30, 0x62, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x63, 0x35, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x37, 0x66, 0x32, 0x65, 0x30, 0x32, 0x36, 0x32, 0x35, 0x31, 0x32, 0x32, 0x30, 0x36, 0x33, 0x33, 0x33, 0x66, 0x66, 0x62, 0x32, 0x30, 0x30, 0x66, 0x36, 0x64, 0x39, 0x64, 0x66, 0x32, 0x64, 0x61, 0x33, 0x31, 0x39, 0x64, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x38, 0x63, 0x31, 0x30, 0x34, 0x64, 0x30, 0x36, 0x38, 0x66, 0x32, 0x32, 0x64, 0x33, 0x35, 0x31, 0x38, 0x35, 0x39, 0x63, 0x64, 0x62, 0x66, 0x65, 0x34, 0x31, 0x61, 0x36, 0x39, 0x37, 0x61, 0x39, 0x38, 0x65, 0x36, 0x65, 0x61, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x30, 0x62, 0x36, 0x62, 0x33, 0x61, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x63, 0x30, 0x66, 0x34, 0x64, 0x62, 0x36, 0x65, 0x30, 0x65, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x34, 0x37, 0x66, 0x32, 0x65, 0x30, 0x32, 0x36, 0x32, 0x35, 0x31, 0x32, 0x32, 0x30, 0x36, 0x33, 0x33, 0x33, 0x66, 0x66, 0x62, 0x32, 0x30, 0x30, 0x66, 0x36, 0x64, 0x39, 0x64, 0x66, 0x32, 0x64, 0x61, 0x33, 0x31, 0x39, 0x64, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x65, 0x35, 0x32, 0x37, 0x30, 0x66, 0x36, 0x32, 0x39, 0x31, 0x61, 0x63, 0x63, 0x31, 0x36, 0x32, 0x38, 0x38, 0x35, 0x36, 0x35, 0x36, 0x62, 0x65, 0x64, 0x66, 0x36, 0x34, 0x66, 0x62, 0x63, 0x62, 0x39, 0x30, 0x34, 0x63, 0x34, 0x31, 0x39, 0x35, 0x31, 0x32, 0x32, 0x31, 0x64, 0x63, 0x30, 0x63, 0x62, 0x62, 0x62, 0x64, 0x63, 0x61, 0x30, 0x33, 0x62, 0x62, 0x33, 0x33, 0x63, 0x65, 0x34, 0x33, 0x61, 0x30, 0x31, 0x66, 0x30, 0x38, 0x63, 0x37, 0x65, 0x64, 0x33, 0x63, 0x32, 0x33, 0x31, 0x34, 0x30, 0x33, 0x62, 0x35, 0x35, 0x66, 0x33, 0x37, 0x61, 0x31, 0x35, 0x37, 0x64, 0x38, 0x30, 0x65, 0x31, 0x32, 0x31, 0x62, 0x36, 0x35, 0x33, 0x62, 0x61, 0x61, 0x38, 0x31, 0x30, 0x61, 0x64, 0x64, 0x38, 0x63, 0x30, 0x32, 0x61, 0x65, 0x61, 0x37, 0x32, 0x32, 0x36, 0x33, 0x31, 0x34, 0x35, 0x30, 0x64, 0x63, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x66, 0x38, 0x37, 0x39, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x32, 0x39, 0x33, 0x37, 0x35, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x36, 0x35, 0x61, 0x30, 0x62, 0x63, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x34, 0x38, 0x64, 0x32, 0x34, 0x37, 0x66, 0x34, 0x66, 0x62, 0x62, 0x65, 0x38, 0x31, 0x34, 0x32, 0x39, 0x64, 0x33, 0x64, 0x31, 0x36, 0x34, 0x61, 0x35, 0x63, 0x39, 0x61, 0x65, 0x30, 0x30, 0x36, 0x33, 0x32, 0x31, 0x30, 0x65, 0x64, 0x62, 0x64, 0x63, 0x38, 0x38, 0x30, 0x36, 0x66, 0x30, 0x35, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x62, 0x62, 0x38, 0x33, 0x64, 0x64, 0x36, 0x31, 0x38, 0x31, 0x63, 0x39, 0x61, 0x37, 0x61, 0x65, 0x33, 0x30, 0x36, 0x39, 0x61, 0x66, 0x33, 0x62, 0x64, 0x66, 0x31, 0x38, 0x32, 0x30, 0x62, 0x35, 0x65, 0x35, 0x35, 0x36, 0x65, 0x61, 0x66, 0x39, 0x39, 0x65, 0x33, 0x38, 0x35, 0x62, 0x38, 0x64, 0x37, 0x62, 0x33, 0x35, 0x37, 0x31, 0x33, 0x32, 0x31, 0x66, 0x62, 0x32, 0x39, 0x36, 0x36, 0x62, 0x61, 0x30, 0x32, 0x61, 0x63, 0x31, 0x39, 0x33, 0x37, 0x37, 0x33, 0x37, 0x30, 0x34, 0x35, 0x32, 0x34, 0x61, 0x64, 0x63, 0x64, 0x30, 0x32, 0x38, 0x32, 0x34, 0x37, 0x39, 0x36, 0x64, 0x66, 0x38, 0x33, 0x34, 0x30, 0x37, 0x61, 0x34, 0x32, 0x63, 0x64, 0x64, 0x38, 0x31, 0x65, 0x37, 0x38, 0x36, 0x62, 0x35, 0x39, 0x31, 0x65, 0x62, 0x61, 0x34, 0x33, 0x63, 0x34, 0x66, 0x66, 0x63, 0x36, 0x63, 0x34, 0x30, 0x62, 0x39, 0x30, 0x32, 0x38, 0x30, 0x30, 0x32, 0x66, 0x39, 0x30, 0x32, 0x37, 0x63, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x30, 0x34, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x39, 0x38, 0x33, 0x30, 0x31, 0x37, 0x61, 0x63, 0x39, 0x39, 0x34, 0x32, 0x61, 0x62, 0x37, 0x63, 0x30, 0x61, 0x62, 0x39, 0x61, 0x62, 0x34, 0x37, 0x66, 0x63, 0x66, 0x33, 0x37, 0x30, 0x64, 0x31, 0x33, 0x30, 0x35, 0x38, 0x62, 0x66, 0x65, 0x65, 0x32, 0x38, 0x66, 0x32, 0x65, 0x63, 0x30, 0x39, 0x34, 0x30, 0x63, 0x38, 0x38, 0x30, 0x31, 0x36, 0x39, 0x39, 0x36, 0x34, 0x33, 0x39, 0x34, 0x66, 0x63, 0x38, 0x38, 0x36, 0x30, 0x62, 0x39, 0x30, 0x32, 0x30, 0x34, 0x39, 0x36, 0x65, 0x31, 0x37, 0x38, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x64, 0x32, 0x33, 0x65, 0x64, 0x37, 0x37, 0x64, 0x30, 0x65, 0x35, 0x64, 0x30, 0x32, 0x30, 0x35, 0x65, 0x64, 0x61, 0x62, 0x65, 0x34, 0x63, 0x65, 0x33, 0x61, 0x32, 0x37, 0x61, 0x64, 0x63, 0x34, 0x39, 0x61, 0x63, 0x36, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x63, 0x35, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x64, 0x32, 0x33, 0x65, 0x64, 0x37, 0x37, 0x64, 0x30, 0x65, 0x35, 0x64, 0x30, 0x32, 0x30, 0x35, 0x65, 0x64, 0x61, 0x62, 0x65, 0x34, 0x63, 0x65, 0x33, 0x61, 0x32, 0x37, 0x61, 0x64, 0x63, 0x34, 0x39, 0x61, 0x63, 0x36, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x64, 0x32, 0x33, 0x65, 0x64, 0x37, 0x37, 0x64, 0x30, 0x65, 0x35, 0x64, 0x30, 0x32, 0x30, 0x35, 0x65, 0x64, 0x61, 0x62, 0x65, 0x34, 0x63, 0x65, 0x33, 0x61, 0x32, 0x37, 0x61, 0x64, 0x63, 0x34, 0x39, 0x61, 0x63, 0x36, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x64, 0x32, 0x33, 0x65, 0x64, 0x37, 0x37, 0x64, 0x30, 0x65, 0x35, 0x64, 0x30, 0x32, 0x30, 0x35, 0x65, 0x64, 0x61, 0x62, 0x65, 0x34, 0x63, 0x65, 0x33, 0x61, 0x32, 0x37, 0x61, 0x64, 0x63, 0x34, 0x39, 0x61, 0x63, 0x36, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x33, 0x34, 0x35, 0x37, 0x38, 0x35, 0x64, 0x38, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x30, 0x63, 0x62, 0x33, 0x37, 0x37, 0x32, 0x38, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x66, 0x63, 0x38, 0x38, 0x32, 0x39, 0x36, 0x38, 0x30, 0x30, 0x35, 0x66, 0x37, 0x31, 0x37, 0x61, 0x37, 0x34, 0x61, 0x32, 0x63, 0x32, 0x66, 0x62, 0x33, 0x34, 0x35, 0x66, 0x36, 0x39, 0x31, 0x30, 0x39, 0x31, 0x63, 0x61, 0x62, 0x30, 0x38, 0x34, 0x66, 0x34, 0x62, 0x64, 0x33, 0x39, 0x33, 0x34, 0x33, 0x35, 0x38, 0x37, 0x34, 0x31, 0x38, 0x30, 0x37, 0x62, 0x64, 0x35, 0x61, 0x36, 0x36, 0x65, 0x61, 0x30, 0x33, 0x66, 0x38, 0x31, 0x63, 0x36, 0x38, 0x64, 0x30, 0x35, 0x64, 0x30, 0x36, 0x62, 0x66, 0x38, 0x35, 0x31, 0x61, 0x36, 0x65, 0x66, 0x35, 0x65, 0x61, 0x36, 0x38, 0x37, 0x34, 0x35, 0x35, 0x37, 0x61, 0x32, 0x32, 0x31, 0x63, 0x62, 0x61, 0x64, 0x64, 0x65, 0x32, 0x34, 0x66, 0x33, 0x66, 0x61, 0x35, 0x31, 0x66, 0x37, 0x37, 0x37, 0x36, 0x39, 0x39, 0x62, 0x35, 0x64, 0x32, 0x38, 0x30, 0x34, 0x62, 0x38, 0x64, 0x38, 0x30, 0x32, 0x66, 0x38, 0x64, 0x35, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x32, 0x32, 0x63, 0x30, 0x62, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x39, 0x38, 0x33, 0x30, 0x33, 0x35, 0x33, 0x34, 0x66, 0x39, 0x34, 0x33, 0x33, 0x36, 0x37, 0x64, 0x66, 0x61, 0x31, 0x31, 0x65, 0x33, 0x31, 0x34, 0x38, 0x61, 0x30, 0x37, 0x63, 0x32, 0x64, 0x61, 0x37, 0x37, 0x33, 0x65, 0x31, 0x66, 0x36, 0x35, 0x62, 0x31, 0x35, 0x35, 0x62, 0x30, 0x61, 0x62, 0x65, 0x35, 0x36, 0x38, 0x30, 0x62, 0x38, 0x36, 0x34, 0x61, 0x64, 0x35, 0x38, 0x62, 0x64, 0x64, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x38, 0x34, 0x34, 0x66, 0x39, 0x35, 0x37, 0x37, 0x63, 0x32, 0x33, 0x33, 0x34, 0x65, 0x35, 0x34, 0x31, 0x61, 0x65, 0x63, 0x37, 0x64, 0x66, 0x37, 0x31, 0x37, 0x34, 0x65, 0x63, 0x65, 0x35, 0x64, 0x66, 0x31, 0x66, 0x63, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x39, 0x65, 0x31, 0x32, 0x63, 0x36, 0x36, 0x30, 0x65, 0x37, 0x37, 0x61, 0x37, 0x33, 0x32, 0x39, 0x34, 0x30, 0x62, 0x61, 0x62, 0x33, 0x63, 0x32, 0x63, 0x66, 0x33, 0x38, 0x35, 0x63, 0x38, 0x34, 0x33, 0x62, 0x38, 0x33, 0x34, 0x62, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x35, 0x64, 0x36, 0x33, 0x37, 0x63, 0x31, 0x37, 0x37, 0x35, 0x38, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x61, 0x32, 0x39, 0x32, 0x65, 0x37, 0x37, 0x32, 0x33, 0x64, 0x33, 0x63, 0x39, 0x35, 0x30, 0x61, 0x61, 0x38, 0x61, 0x35, 0x35, 0x37, 0x62, 0x64, 0x39, 0x31, 0x64, 0x65, 0x63, 0x65, 0x33, 0x34, 0x65, 0x63, 0x35, 0x32, 0x37, 0x64, 0x39, 0x65, 0x66, 0x65, 0x32, 0x63, 0x63, 0x34, 0x31, 0x33, 0x64, 0x35, 0x38, 0x32, 0x64, 0x63, 0x64, 0x39, 0x66, 0x63, 0x36, 0x62, 0x66, 0x36, 0x65, 0x62, 0x61, 0x30, 0x33, 0x33, 0x38, 0x36, 0x63, 0x65, 0x36, 0x66, 0x35, 0x38, 0x65, 0x38, 0x36, 0x32, 0x66, 0x33, 0x32, 0x39, 0x39, 0x34, 0x36, 0x62, 0x66, 0x33, 0x32, 0x38, 0x39, 0x37, 0x66, 0x37, 0x64, 0x66, 0x35, 0x64, 0x31, 0x63, 0x38, 0x66, 0x38, 0x31, 0x38, 0x66, 0x65, 0x63, 0x66, 0x61, 0x66, 0x63, 0x31, 0x32, 0x32, 0x33, 0x30, 0x35, 0x32, 0x66, 0x62, 0x32, 0x35, 0x31, 0x64, 0x39, 0x37, 0x65, 0x62, 0x38, 0x62, 0x36, 0x30, 0x32, 0x66, 0x38, 0x62, 0x33, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x31, 0x33, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x39, 0x38, 0x33, 0x32, 0x64, 0x63, 0x36, 0x63, 0x30, 0x39, 0x34, 0x62, 0x61, 0x31, 0x37, 0x35, 0x66, 0x64, 0x61, 0x62, 0x30, 0x30, 0x65, 0x37, 0x66, 0x63, 0x66, 0x36, 0x30, 0x33, 0x66, 0x34, 0x33, 0x62, 0x65, 0x38, 0x66, 0x36, 0x38, 0x64, 0x62, 0x37, 0x66, 0x34, 0x64, 0x65, 0x39, 0x66, 0x33, 0x61, 0x39, 0x38, 0x30, 0x62, 0x38, 0x34, 0x34, 0x30, 0x39, 0x35, 0x65, 0x61, 0x37, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x61, 0x30, 0x63, 0x63, 0x31, 0x61, 0x62, 0x33, 0x35, 0x33, 0x64, 0x61, 0x36, 0x62, 0x37, 0x38, 0x31, 0x37, 0x39, 0x34, 0x37, 0x66, 0x37, 0x62, 0x31, 0x31, 0x36, 0x62, 0x38, 0x65, 0x61, 0x39, 0x38, 0x32, 0x63, 0x33, 0x64, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x66, 0x33, 0x36, 0x35, 0x61, 0x65, 0x61, 0x31, 0x65, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x39, 0x36, 0x38, 0x65, 0x64, 0x30, 0x32, 0x37, 0x34, 0x38, 0x32, 0x39, 0x39, 0x31, 0x38, 0x30, 0x37, 0x31, 0x64, 0x39, 0x63, 0x65, 0x66, 0x32, 0x38, 0x65, 0x31, 0x61, 0x64, 0x62, 0x66, 0x31, 0x66, 0x64, 0x31, 0x35, 0x65, 0x63, 0x37, 0x36, 0x65, 0x35, 0x61, 0x34, 0x66, 0x38, 0x30, 0x39, 0x39, 0x37, 0x31, 0x65, 0x38, 0x38, 0x37, 0x62, 0x34, 0x63, 0x39, 0x66, 0x33, 0x34, 0x62, 0x36, 0x61, 0x30, 0x30, 0x31, 0x63, 0x65, 0x32, 0x36, 0x34, 0x38, 0x35, 0x62, 0x63, 0x37, 0x65, 0x33, 0x65, 0x61, 0x37, 0x31, 0x66, 0x62, 0x39, 0x39, 0x38, 0x36, 0x36, 0x62, 0x64, 0x34, 0x33, 0x30, 0x30, 0x32, 0x62, 0x32, 0x36, 0x34, 0x62, 0x32, 0x65, 0x64, 0x38, 0x30, 0x65, 0x31, 0x30, 0x38, 0x35, 0x30, 0x32, 0x30, 0x33, 0x63, 0x32, 0x66, 0x30, 0x37, 0x62, 0x37, 0x38, 0x38, 0x35, 0x36, 0x62, 0x64, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x66, 0x38, 0x37, 0x39, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x32, 0x39, 0x33, 0x37, 0x36, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x36, 0x35, 0x61, 0x30, 0x62, 0x63, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x34, 0x36, 0x64, 0x33, 0x62, 0x39, 0x33, 0x64, 0x62, 0x34, 0x65, 0x34, 0x30, 0x37, 0x38, 0x63, 0x66, 0x36, 0x35, 0x34, 0x31, 0x61, 0x36, 0x38, 0x35, 0x33, 0x32, 0x64, 0x30, 0x30, 0x37, 0x30, 0x35, 0x64, 0x39, 0x61, 0x34, 0x64, 0x61, 0x36, 0x31, 0x38, 0x38, 0x30, 0x36, 0x66, 0x30, 0x35, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x38, 0x33, 0x63, 0x38, 0x33, 0x31, 0x36, 0x33, 0x30, 0x37, 0x38, 0x38, 0x65, 0x37, 0x65, 0x65, 0x35, 0x37, 0x63, 0x38, 0x37, 0x31, 0x32, 0x38, 0x64, 0x31, 0x38, 0x35, 0x38, 0x32, 0x65, 0x32, 0x39, 0x61, 0x61, 0x35, 0x31, 0x66, 0x31, 0x66, 0x32, 0x33, 0x33, 0x65, 0x39, 0x31, 0x64, 0x39, 0x31, 0x36, 0x63, 0x30, 0x36, 0x64, 0x30, 0x37, 0x35, 0x30, 0x35, 0x37, 0x38, 0x31, 0x35, 0x36, 0x61, 0x30, 0x35, 0x34, 0x39, 0x62, 0x35, 0x61, 0x30, 0x30, 0x34, 0x37, 0x37, 0x66, 0x33, 0x66, 0x62, 0x34, 0x64, 0x38, 0x66, 0x62, 0x66, 0x39, 0x35, 0x62, 0x61, 0x33, 0x61, 0x36, 0x33, 0x36, 0x63, 0x33, 0x61, 0x31, 0x34, 0x66, 0x66, 0x30, 0x31, 0x31, 0x63, 0x31, 0x62, 0x62, 0x66, 0x33, 0x61, 0x37, 0x31, 0x37, 0x65, 0x30, 0x30, 0x64, 0x36, 0x31, 0x37, 0x33, 0x35, 0x63, 0x62, 0x66, 0x33, 0x34, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x66, 0x38, 0x37, 0x39, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x32, 0x39, 0x33, 0x37, 0x37, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x36, 0x35, 0x61, 0x30, 0x62, 0x63, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x34, 0x30, 0x64, 0x33, 0x61, 0x37, 0x64, 0x36, 0x39, 0x38, 0x35, 0x39, 0x61, 0x30, 0x64, 0x64, 0x36, 0x39, 0x37, 0x31, 0x64, 0x33, 0x39, 0x37, 0x30, 0x33, 0x62, 0x31, 0x35, 0x33, 0x37, 0x39, 0x65, 0x30, 0x35, 0x61, 0x65, 0x32, 0x65, 0x63, 0x34, 0x38, 0x38, 0x30, 0x36, 0x66, 0x30, 0x35, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x30, 0x38, 0x32, 0x36, 0x36, 0x30, 0x62, 0x35, 0x64, 0x62, 0x32, 0x64, 0x33, 0x61, 0x38, 0x61, 0x35, 0x38, 0x63, 0x30, 0x62, 0x38, 0x36, 0x33, 0x36, 0x37, 0x33, 0x61, 0x62, 0x32, 0x37, 0x66, 0x37, 0x63, 0x66, 0x65, 0x34, 0x63, 0x30, 0x34, 0x39, 0x64, 0x63, 0x63, 0x35, 0x32, 0x63, 0x37, 0x36, 0x61, 0x30, 0x30, 0x61, 0x62, 0x34, 0x35, 0x62, 0x30, 0x33, 0x35, 0x38, 0x64, 0x62, 0x35, 0x61, 0x30, 0x35, 0x61, 0x37, 0x35, 0x31, 0x39, 0x61, 0x32, 0x64, 0x33, 0x39, 0x39, 0x63, 0x62, 0x35, 0x33, 0x34, 0x34, 0x38, 0x30, 0x33, 0x38, 0x33, 0x61, 0x63, 0x32, 0x31, 0x32, 0x36, 0x32, 0x66, 0x62, 0x64, 0x65, 0x32, 0x64, 0x64, 0x38, 0x35, 0x32, 0x34, 0x31, 0x34, 0x39, 0x35, 0x64, 0x37, 0x38, 0x33, 0x32, 0x64, 0x65, 0x65, 0x38, 0x62, 0x62, 0x30, 0x32, 0x63, 0x34, 0x39, 0x63, 0x38, 0x37, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x66, 0x38, 0x37, 0x39, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x32, 0x39, 0x33, 0x37, 0x38, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x36, 0x35, 0x61, 0x30, 0x62, 0x63, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x34, 0x31, 0x62, 0x65, 0x31, 0x33, 0x66, 0x36, 0x34, 0x61, 0x32, 0x34, 0x36, 0x33, 0x66, 0x63, 0x37, 0x61, 0x37, 0x36, 0x62, 0x34, 0x30, 0x39, 0x32, 0x63, 0x35, 0x33, 0x33, 0x32, 0x38, 0x63, 0x63, 0x39, 0x36, 0x35, 0x61, 0x37, 0x37, 0x66, 0x62, 0x38, 0x38, 0x30, 0x36, 0x66, 0x30, 0x35, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x65, 0x36, 0x65, 0x65, 0x39, 0x62, 0x38, 0x35, 0x63, 0x33, 0x62, 0x37, 0x32, 0x39, 0x35, 0x31, 0x38, 0x35, 0x32, 0x34, 0x66, 0x64, 0x61, 0x65, 0x62, 0x32, 0x35, 0x64, 0x34, 0x37, 0x66, 0x38, 0x39, 0x66, 0x36, 0x66, 0x63, 0x36, 0x63, 0x34, 0x64, 0x32, 0x63, 0x34, 0x64, 0x66, 0x37, 0x30, 0x37, 0x31, 0x38, 0x37, 0x62, 0x65, 0x66, 0x37, 0x34, 0x64, 0x37, 0x33, 0x66, 0x39, 0x35, 0x38, 0x61, 0x30, 0x37, 0x35, 0x36, 0x62, 0x62, 0x66, 0x34, 0x61, 0x62, 0x31, 0x31, 0x39, 0x38, 0x30, 0x35, 0x62, 0x37, 0x37, 0x34, 0x36, 0x36, 0x39, 0x35, 0x37, 0x62, 0x35, 0x38, 0x39, 0x35, 0x63, 0x31, 0x64, 0x35, 0x62, 0x66, 0x34, 0x32, 0x32, 0x63, 0x35, 0x66, 0x36, 0x35, 0x64, 0x38, 0x61, 0x30, 0x36, 0x66, 0x37, 0x65, 0x66, 0x64, 0x33, 0x37, 0x64, 0x63, 0x62, 0x32, 0x63, 0x38, 0x37, 0x61, 0x66, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x66, 0x38, 0x37, 0x39, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x32, 0x39, 0x33, 0x37, 0x39, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x36, 0x35, 0x61, 0x30, 0x62, 0x63, 0x30, 0x30, 0x38, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x34, 0x61, 0x39, 0x30, 0x62, 0x32, 0x38, 0x66, 0x64, 0x36, 0x66, 0x38, 0x65, 0x34, 0x36, 0x61, 0x63, 0x36, 0x36, 0x38, 0x66, 0x63, 0x62, 0x36, 0x38, 0x38, 0x34, 0x31, 0x34, 0x31, 0x38, 0x34, 0x61, 0x31, 0x36, 0x33, 0x65, 0x32, 0x63, 0x64, 0x32, 0x38, 0x38, 0x30, 0x36, 0x66, 0x30, 0x35, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x64, 0x33, 0x39, 0x34, 0x64, 0x64, 0x34, 0x33, 0x63, 0x35, 0x38, 0x35, 0x39, 0x31, 0x65, 0x35, 0x64, 0x64, 0x61, 0x38, 0x61, 0x37, 0x66, 0x33, 0x61, 0x32, 0x66, 0x34, 0x65, 0x61, 0x65, 0x31, 0x62, 0x66, 0x64, 0x36, 0x35, 0x36, 0x35, 0x35, 0x62, 0x39, 0x65, 0x39, 0x65, 0x65, 0x63, 0x35, 0x66, 0x61, 0x63, 0x63, 0x36, 0x64, 0x63, 0x62, 0x33, 0x39, 0x61, 0x61, 0x37, 0x37, 0x62, 0x61, 0x61, 0x30, 0x30, 0x32, 0x65, 0x65, 0x61, 0x62, 0x66, 0x33, 0x66, 0x65, 0x39, 0x63, 0x30, 0x61, 0x35, 0x36, 0x65, 0x61, 0x65, 0x34, 0x37, 0x36, 0x64, 0x32, 0x66, 0x36, 0x34, 0x35, 0x32, 0x65, 0x61, 0x37, 0x32, 0x65, 0x36, 0x33, 0x61, 0x39, 0x63, 0x39, 0x62, 0x31, 0x31, 0x38, 0x30, 0x32, 0x39, 0x30, 0x62, 0x37, 0x39, 0x32, 0x38, 0x38, 0x33, 0x32, 0x35, 0x38, 0x66, 0x39, 0x33, 0x39, 0x66, 0x35, 0x62, 0x38, 0x66, 0x38, 0x30, 0x32, 0x66, 0x38, 0x66, 0x35, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x32, 0x38, 0x33, 0x38, 0x31, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x30, 0x30, 0x38, 0x34, 0x35, 0x39, 0x36, 0x38, 0x32, 0x66, 0x31, 0x30, 0x38, 0x32, 0x39, 0x36, 0x32, 0x34, 0x39, 0x34, 0x64, 0x30, 0x66, 0x37, 0x32, 0x33, 0x63, 0x36, 0x62, 0x32, 0x32, 0x32, 0x36, 0x64, 0x66, 0x35, 0x36, 0x66, 0x65, 0x34, 0x31, 0x65, 0x36, 0x33, 0x62, 0x39, 0x65, 0x61, 0x61, 0x36, 0x36, 0x65, 0x62, 0x35, 0x34, 0x30, 0x62, 0x63, 0x62, 0x38, 0x38, 0x30, 0x62, 0x38, 0x38, 0x34, 0x61, 0x62, 0x61, 0x63, 0x30, 0x34, 0x37, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x65, 0x39, 0x66, 0x30, 0x66, 0x33, 0x34, 0x37, 0x31, 0x64, 0x63, 0x34, 0x34, 0x35, 0x64, 0x38, 0x66, 0x32, 0x30, 0x39, 0x65, 0x66, 0x35, 0x34, 0x36, 0x65, 0x30, 0x64, 0x32, 0x30, 0x65, 0x61, 0x63, 0x63, 0x63, 0x31, 0x32, 0x65, 0x64, 0x30, 0x61, 0x35, 0x62, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x37, 0x66, 0x35, 0x37, 0x64, 0x39, 0x62, 0x63, 0x38, 0x36, 0x33, 0x38, 0x64, 0x61, 0x63, 0x61, 0x66, 0x36, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x32, 0x30, 0x39, 0x62, 0x31, 0x65, 0x61, 0x31, 0x31, 0x64, 0x37, 0x37, 0x64, 0x31, 0x61, 0x62, 0x34, 0x35, 0x37, 0x65, 0x62, 0x33, 0x65, 0x32, 0x39, 0x35, 0x34, 0x63, 0x62, 0x32, 0x62, 0x39, 0x38, 0x65, 0x37, 0x37, 0x62, 0x35, 0x62, 0x30, 0x37, 0x65, 0x32, 0x61, 0x34, 0x66, 0x34, 0x38, 0x35, 0x30, 0x37, 0x61, 0x66, 0x30, 0x61, 0x64, 0x63, 0x36, 0x31, 0x33, 0x32, 0x39, 0x64, 0x64, 0x63, 0x32, 0x31, 0x30, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x65, 0x66, 0x61, 0x31, 0x30, 0x61, 0x62, 0x36, 0x30, 0x66, 0x33, 0x62, 0x64, 0x31, 0x65, 0x37, 0x63, 0x34, 0x61, 0x38, 0x64, 0x35, 0x32, 0x61, 0x32, 0x37, 0x35, 0x61, 0x35, 0x36, 0x38, 0x66, 0x62, 0x65, 0x32, 0x66, 0x35, 0x65, 0x64, 0x63, 0x39, 0x65, 0x31, 0x65, 0x61, 0x66, 0x33, 0x38, 0x36, 0x32, 0x39, 0x39, 0x35, 0x37, 0x37, 0x66, 0x66, 0x39, 0x64, 0x64, 0x62, 0x64, 0x36, 0x62, 0x61, 0x30, 0x36, 0x65, 0x36, 0x32, 0x63, 0x66, 0x32, 0x66, 0x36, 0x36, 0x62, 0x35, 0x38, 0x66, 0x36, 0x35, 0x35, 0x64, 0x64, 0x64, 0x33, 0x65, 0x61, 0x65, 0x34, 0x37, 0x63, 0x65, 0x34, 0x30, 0x34, 0x30, 0x38, 0x34, 0x34, 0x35, 0x62, 0x30, 0x38, 0x36, 0x66, 0x36, 0x65, 0x61, 0x38, 0x35, 0x38, 0x65, 0x64, 0x62, 0x37, 0x62, 0x64, 0x38, 0x34, 0x37, 0x65, 0x65, 0x32, 0x30, 0x36, 0x32, 0x30, 0x37, 0x66, 0x38, 0x36, 0x66, 0x38, 0x32, 0x65, 0x36, 0x65, 0x35, 0x38, 0x32, 0x30, 0x31, 0x34, 0x34, 0x38, 0x32, 0x66, 0x36, 0x31, 0x38, 0x39, 0x34, 0x39, 0x65, 0x62, 0x66, 0x36, 0x62, 0x31, 0x32, 0x65, 0x37, 0x65, 0x33, 0x33, 0x62, 0x38, 0x36, 0x37, 0x32, 0x37, 0x38, 0x38, 0x65, 0x37, 0x62, 0x32, 0x62, 0x33, 0x33, 0x33, 0x30, 0x33, 0x35, 0x36, 0x66, 0x36, 0x66, 0x32, 0x63, 0x34, 0x31, 0x38, 0x38, 0x30, 0x64, 0x65, 0x30, 0x62, 0x36, 0x62, 0x33, 0x61, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x35, 0x34, 0x36, 0x64, 0x37, 0x32, 0x61, 0x30, 0x30, 0x38, 0x64, 0x36, 0x62, 0x65, 0x37, 0x61, 0x61, 0x32, 0x31, 0x62, 0x65, 0x30, 0x61, 0x34, 0x33, 0x65, 0x30, 0x38, 0x65, 0x39, 0x36, 0x30, 0x36, 0x32, 0x30, 0x66, 0x34, 0x63, 0x34, 0x30, 0x63, 0x34, 0x34, 0x30, 0x31, 0x30, 0x61, 0x37, 0x34, 0x33, 0x65, 0x61, 0x64, 0x39, 0x39, 0x31, 0x39, 0x65, 0x66, 0x39, 0x34, 0x32, 0x33, 0x38, 0x36, 0x33, 0x63, 0x30, 0x38, 0x62, 0x31, 0x32, 0x61, 0x30, 0x36, 0x61, 0x36, 0x33, 0x61, 0x37, 0x63, 0x61, 0x61, 0x65, 0x34, 0x35, 0x30, 0x34, 0x65, 0x65, 0x35, 0x35, 0x32, 0x38, 0x65, 0x35, 0x30, 0x33, 0x38, 0x37, 0x63, 0x61, 0x30, 0x39, 0x39, 0x37, 0x34, 0x66, 0x37, 0x31, 0x32, 0x34, 0x30, 0x33, 0x35, 0x33, 0x32, 0x38, 0x61, 0x36, 0x32, 0x64, 0x31, 0x30, 0x38, 0x35, 0x64, 0x61, 0x32, 0x66, 0x65, 0x65, 0x36, 0x36, 0x31, 0x38, 0x66, 0x39, 0x66, 0x38, 0x36, 0x66, 0x38, 0x32, 0x65, 0x31, 0x63, 0x33, 0x38, 0x32, 0x30, 0x31, 0x34, 0x34, 0x38, 0x32, 0x66, 0x36, 0x31, 0x38, 0x39, 0x34, 0x39, 0x63, 0x36, 0x38, 0x65, 0x62, 0x33, 0x31, 0x63, 0x34, 0x64, 0x30, 0x30, 0x62, 0x39, 0x34, 0x63, 0x33, 0x65, 0x33, 0x64, 0x34, 0x63, 0x32, 0x38, 0x38, 0x37, 0x39, 0x34, 0x36, 0x66, 0x38, 0x62, 0x30, 0x37, 0x36, 0x62, 0x32, 0x34, 0x63, 0x38, 0x38, 0x30, 0x64, 0x65, 0x30, 0x62, 0x36, 0x62, 0x33, 0x61, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x35, 0x34, 0x36, 0x64, 0x37, 0x32, 0x61, 0x30, 0x63, 0x32, 0x32, 0x64, 0x34, 0x38, 0x64, 0x37, 0x32, 0x63, 0x37, 0x30, 0x63, 0x63, 0x66, 0x30, 0x61, 0x34, 0x34, 0x64, 0x30, 0x39, 0x35, 0x30, 0x64, 0x61, 0x66, 0x31, 0x36, 0x37, 0x34, 0x31, 0x38, 0x33, 0x38, 0x66, 0x39, 0x33, 0x33, 0x33, 0x65, 0x65, 0x30, 0x62, 0x63, 0x35, 0x65, 0x30, 0x35, 0x66, 0x66, 0x30, 0x32, 0x62, 0x30, 0x35, 0x38, 0x64, 0x61, 0x31, 0x65, 0x30, 0x31, 0x30, 0x61, 0x30, 0x36, 0x61, 0x32, 0x30, 0x63, 0x39, 0x66, 0x37, 0x34, 0x63, 0x62, 0x63, 0x31, 0x34, 0x63, 0x30, 0x64, 0x35, 0x62, 0x66, 0x33, 0x62, 0x33, 0x63, 0x33, 0x38, 0x64, 0x33, 0x63, 0x33, 0x33, 0x61, 0x35, 0x61, 0x63, 0x65, 0x39, 0x31, 0x39, 0x34, 0x63, 0x64, 0x64, 0x63, 0x32, 0x63, 0x35, 0x33, 0x33, 0x61, 0x66, 0x62, 0x31, 0x36, 0x34, 0x35, 0x39, 0x65, 0x61, 0x61, 0x37, 0x36, 0x34, 0x37, 0x66, 0x38, 0x36, 0x66, 0x38, 0x32, 0x65, 0x34, 0x63, 0x62, 0x38, 0x32, 0x30, 0x31, 0x34, 0x34, 0x38, 0x32, 0x66, 0x36, 0x31, 0x38, 0x39, 0x34, 0x64, 0x35, 0x33, 0x31, 0x65, 0x37, 0x61, 0x61, 0x33, 0x63, 0x30, 0x62, 0x65, 0x65, 0x38, 0x33, 0x32, 0x61, 0x61, 0x66, 0x66, 0x32, 0x32, 0x36, 0x34, 0x32, 0x63, 0x37, 0x61, 0x33, 0x31, 0x32, 0x38, 0x64, 0x34, 0x38, 0x61, 0x38, 0x31, 0x61, 0x38, 0x38, 0x30, 0x64, 0x65, 0x30, 0x62, 0x36, 0x62, 0x33, 0x61, 0x37, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x35, 0x34, 0x36, 0x64, 0x37, 0x32, 0x61, 0x30, 0x31, 0x64, 0x62, 0x61, 0x65, 0x66, 0x66, 0x63, 0x38, 0x65, 0x31, 0x31, 0x39, 0x36, 0x34, 0x63, 0x30, 0x36, 0x61, 0x37, 0x32, 0x32, 0x62, 0x61, 0x65, 0x37, 0x33, 0x65, 0x33, 0x35, 0x62, 0x62, 0x35, 0x64, 0x65, 0x35, 0x35, 0x62, 0x38, 0x66, 0x39, 0x35, 0x39, 0x35, 0x39, 0x32, 0x38, 0x36, 0x38, 0x66, 0x32, 0x66, 0x66, 0x35, 0x66, 0x63, 0x31, 0x33, 0x62, 0x36, 0x39, 0x62, 0x64, 0x33, 0x61, 0x30, 0x30, 0x32, 0x61, 0x63, 0x61, 0x64, 0x63, 0x30, 0x34, 0x36, 0x36, 0x35, 0x35, 0x37, 0x30, 0x61, 0x32, 0x30, 0x33, 0x32, 0x63, 0x64, 0x62, 0x36, 0x31, 0x36, 0x64, 0x65, 0x31, 0x35, 0x62, 0x64, 0x63, 0x61, 0x37, 0x39, 0x31, 0x32, 0x37, 0x66, 0x32, 0x31, 0x33, 0x30, 0x32, 0x64, 0x36, 0x32, 0x64, 0x62, 0x35, 0x62, 0x61, 0x66, 0x39, 0x36, 0x61, 0x65, 0x34, 0x37, 0x33, 0x34, 0x65, 0x36, 0x66, 0x38, 0x36, 0x65, 0x38, 0x33, 0x30, 0x31, 0x37, 0x36, 0x65, 0x33, 0x38, 0x31, 0x64, 0x38, 0x38, 0x32, 0x35, 0x32, 0x30, 0x38, 0x39, 0x34, 0x61, 0x64, 0x33, 0x34, 0x36, 0x65, 0x38, 0x31, 0x63, 0x35, 0x62, 0x32, 0x36, 0x66, 0x65, 0x35, 0x36, 0x33, 0x61, 0x62, 0x31, 0x62, 0x61, 0x32, 0x61, 0x61, 0x34, 0x66, 0x66, 0x38, 0x31, 0x31, 0x36, 0x35, 0x35, 0x38, 0x38, 0x32, 0x63, 0x61, 0x38, 0x37, 0x32, 0x33, 0x38, 0x36, 0x66, 0x32, 0x36, 0x66, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x31, 0x35, 0x34, 0x36, 0x64, 0x37, 0x32, 0x61, 0x30, 0x62, 0x36, 0x64, 0x65, 0x31, 0x31, 0x35, 0x39, 0x38, 0x38, 0x32, 0x34, 0x65, 0x33, 0x33, 0x38, 0x31, 0x30, 0x30, 0x64, 0x35, 0x65, 0x62, 0x65, 0x37, 0x30, 0x63, 0x30, 0x62, 0x30, 0x66, 0x34, 0x64, 0x36, 0x38, 0x39, 0x33, 0x66, 0x62, 0x62, 0x33, 0x36, 0x66, 0x31, 0x31, 0x61, 0x64, 0x35, 0x35, 0x63, 0x66, 0x37, 0x34, 0x62, 0x32, 0x66, 0x34, 0x33, 0x61, 0x66, 0x63, 0x35, 0x64, 0x64, 0x61, 0x30, 0x35, 0x31, 0x30, 0x31, 0x65, 0x36, 0x35, 0x65, 0x37, 0x65, 0x38, 0x34, 0x65, 0x61, 0x39, 0x65, 0x64, 0x62, 0x61, 0x36, 0x65, 0x35, 0x62, 0x66, 0x31, 0x61, 0x31, 0x65, 0x30, 0x37, 0x30, 0x32, 0x38, 0x61, 0x65, 0x33, 0x66, 0x61, 0x35, 0x32, 0x31, 0x33, 0x32, 0x34, 0x30, 0x65, 0x38, 0x31, 0x32, 0x65, 0x35, 0x37, 0x63, 0x66, 0x36, 0x62, 0x32, 0x39, 0x30, 0x38, 0x30, 0x37, 0x32, 0x36, 0x62, 0x39, 0x32, 0x33, 0x35, 0x33, 0x30, 0x32, 0x66, 0x39, 0x32, 0x33, 0x34, 0x66, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x31, 0x33, 0x37, 0x64, 0x35, 0x36, 0x34, 0x37, 0x34, 0x38, 0x33, 0x31, 0x35, 0x66, 0x35, 0x32, 0x31, 0x39, 0x34, 0x61, 0x63, 0x39, 0x32, 0x35, 0x31, 0x65, 0x65, 0x39, 0x37, 0x65, 0x64, 0x38, 0x62, 0x65, 0x66, 0x33, 0x31, 0x37, 0x30, 0x36, 0x33, 0x35, 0x34, 0x33, 0x31, 0x30, 0x63, 0x36, 0x62, 0x30, 0x32, 0x30, 0x63, 0x33, 0x35, 0x64, 0x38, 0x37, 0x62, 0x38, 0x30, 0x62, 0x39, 0x32, 0x32, 0x65, 0x34, 0x38, 0x65, 0x64, 0x37, 0x62, 0x33, 0x62, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x64, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x64, 0x36, 0x39, 0x33, 0x39, 0x34, 0x62, 0x64, 0x37, 0x31, 0x39, 0x30, 0x36, 0x61, 0x32, 0x33, 0x35, 0x66, 0x39, 0x31, 0x31, 0x33, 0x63, 0x63, 0x30, 0x34, 0x33, 0x32, 0x31, 0x66, 0x35, 0x37, 0x33, 0x39, 0x35, 0x38, 0x64, 0x33, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x64, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x36, 0x64, 0x36, 0x62, 0x31, 0x62, 0x36, 0x35, 0x35, 0x66, 0x36, 0x36, 0x63, 0x66, 0x38, 0x66, 0x39, 0x39, 0x64, 0x33, 0x35, 0x34, 0x33, 0x32, 0x34, 0x39, 0x32, 0x66, 0x38, 0x66, 0x62, 0x65, 0x64, 0x66, 0x61, 0x39, 0x37, 0x61, 0x32, 0x61, 0x34, 0x38, 0x66, 0x30, 0x65, 0x66, 0x61, 0x61, 0x65, 0x36, 0x35, 0x64, 0x65, 0x36, 0x37, 0x33, 0x38, 0x65, 0x32, 0x35, 0x39, 0x34, 0x61, 0x61, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x31, 0x63, 0x31, 0x35, 0x32, 0x33, 0x35, 0x63, 0x33, 0x34, 0x38, 0x32, 0x30, 0x37, 0x65, 0x39, 0x33, 0x35, 0x65, 0x37, 0x32, 0x62, 0x39, 0x31, 0x35, 0x31, 0x30, 0x35, 0x36, 0x61, 0x39, 0x36, 0x36, 0x31, 0x64, 0x37, 0x33, 0x36, 0x33, 0x31, 0x64, 0x31, 0x65, 0x32, 0x63, 0x33, 0x66, 0x38, 0x39, 0x66, 0x66, 0x64, 0x64, 0x66, 0x38, 0x65, 0x37, 0x34, 0x65, 0x66, 0x65, 0x38, 0x61, 0x34, 0x32, 0x61, 0x62, 0x38, 0x37, 0x36, 0x37, 0x30, 0x37, 0x36, 0x61, 0x35, 0x35, 0x35, 0x61, 0x30, 0x34, 0x39, 0x33, 0x37, 0x32, 0x30, 0x35, 0x35, 0x63, 0x38, 0x34, 0x36, 0x30, 0x39, 0x37, 0x63, 0x39, 0x39, 0x65, 0x36, 0x39, 0x63, 0x32, 0x36, 0x61, 0x62, 0x30, 0x61, 0x32, 0x34, 0x35, 0x35, 0x33, 0x64, 0x32, 0x31, 0x63, 0x31, 0x35, 0x64, 0x65, 0x32, 0x39, 0x65, 0x61, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x65, 0x66, 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x36, 0x66, 0x38, 0x64, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x36, 0x35, 0x38, 0x32, 0x32, 0x31, 0x30, 0x37, 0x66, 0x63, 0x66, 0x64, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x63, 0x31, 0x35, 0x61, 0x62, 0x65, 0x65, 0x32, 0x35, 0x37, 0x32, 0x35, 0x36, 0x64, 0x61, 0x31, 0x61, 0x39, 0x36, 0x34, 0x34, 0x33, 0x34, 0x30, 0x30, 0x30, 0x66, 0x35, 0x39, 0x64, 0x64, 0x64, 0x34, 0x35, 0x62, 0x31, 0x63, 0x65, 0x36, 0x37, 0x64, 0x35, 0x64, 0x66, 0x34, 0x34, 0x66, 0x31, 0x63, 0x38, 0x32, 0x66, 0x64, 0x35, 0x62, 0x66, 0x65, 0x39, 0x35, 0x63, 0x33, 0x62, 0x33, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x34, 0x62, 0x35, 0x62, 0x33, 0x35, 0x64, 0x39, 0x33, 0x66, 0x35, 0x31, 0x63, 0x38, 0x31, 0x34, 0x33, 0x66, 0x36, 0x61, 0x34, 0x63, 0x63, 0x33, 0x64, 0x37, 0x62, 0x33, 0x32, 0x30, 0x64, 0x33, 0x37, 0x63, 0x65, 0x30, 0x33, 0x39, 0x38, 0x39, 0x63, 0x64, 0x38, 0x38, 0x63, 0x32, 0x38, 0x36, 0x30, 0x31, 0x66, 0x34, 0x65, 0x61, 0x39, 0x34, 0x63, 0x64, 0x36, 0x35, 0x35, 0x34, 0x32, 0x34, 0x39, 0x63, 0x66, 0x66, 0x38, 0x33, 0x65, 0x34, 0x64, 0x64, 0x38, 0x65, 0x39, 0x39, 0x61, 0x38, 0x65, 0x66, 0x39, 0x30, 0x30, 0x34, 0x62, 0x32, 0x61, 0x63, 0x37, 0x35, 0x31, 0x38, 0x39, 0x39, 0x36, 0x66, 0x34, 0x37, 0x38, 0x34, 0x61, 0x66, 0x31, 0x66, 0x39, 0x65, 0x35, 0x32, 0x64, 0x65, 0x62, 0x62, 0x36, 0x32, 0x32, 0x33, 0x61, 0x36, 0x39, 0x37, 0x65, 0x39, 0x36, 0x35, 0x32, 0x35, 0x33, 0x30, 0x66, 0x65, 0x64, 0x61, 0x32, 0x31, 0x39, 0x66, 0x33, 0x33, 0x33, 0x65, 0x30, 0x31, 0x66, 0x38, 0x63, 0x64, 0x30, 0x62, 0x33, 0x31, 0x65, 0x65, 0x38, 0x33, 0x62, 0x39, 0x63, 0x32, 0x35, 0x30, 0x65, 0x65, 0x35, 0x31, 0x66, 0x64, 0x65, 0x39, 0x37, 0x31, 0x38, 0x65, 0x66, 0x35, 0x66, 0x61, 0x33, 0x30, 0x35, 0x63, 0x62, 0x63, 0x64, 0x30, 0x31, 0x39, 0x30, 0x31, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x30, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x38, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x63, 0x38, 0x34, 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x31, 0x30, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x64, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x62, 0x66, 0x62, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x64, 0x62, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x36, 0x66, 0x38, 0x64, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x30, 0x34, 0x32, 0x61, 0x62, 0x38, 0x37, 0x36, 0x37, 0x30, 0x37, 0x36, 0x61, 0x35, 0x35, 0x35, 0x61, 0x30, 0x34, 0x39, 0x33, 0x37, 0x32, 0x30, 0x35, 0x35, 0x63, 0x38, 0x34, 0x36, 0x30, 0x39, 0x37, 0x63, 0x39, 0x39, 0x65, 0x36, 0x39, 0x63, 0x32, 0x36, 0x61, 0x62, 0x30, 0x61, 0x32, 0x34, 0x35, 0x35, 0x33, 0x64, 0x32, 0x31, 0x63, 0x31, 0x35, 0x64, 0x65, 0x32, 0x39, 0x65, 0x61, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x32, 0x30, 0x32, 0x62, 0x66, 0x32, 0x30, 0x66, 0x66, 0x37, 0x38, 0x37, 0x32, 0x37, 0x66, 0x33, 0x38, 0x65, 0x66, 0x31, 0x36, 0x65, 0x30, 0x33, 0x62, 0x66, 0x62, 0x33, 0x64, 0x34, 0x38, 0x39, 0x35, 0x66, 0x33, 0x35, 0x63, 0x63, 0x36, 0x32, 0x36, 0x66, 0x39, 0x37, 0x65, 0x64, 0x65, 0x37, 0x63, 0x63, 0x39, 0x39, 0x66, 0x34, 0x38, 0x61, 0x65, 0x66, 0x66, 0x38, 0x36, 0x36, 0x31, 0x66, 0x65, 0x33, 0x32, 0x30, 0x31, 0x35, 0x65, 0x61, 0x38, 0x64, 0x36, 0x32, 0x65, 0x63, 0x37, 0x61, 0x37, 0x39, 0x65, 0x30, 0x31, 0x63, 0x64, 0x33, 0x39, 0x38, 0x65, 0x38, 0x35, 0x38, 0x36, 0x37, 0x62, 0x61, 0x66, 0x64, 0x63, 0x66, 0x35, 0x35, 0x63, 0x62, 0x36, 0x61, 0x37, 0x31, 0x32, 0x31, 0x62, 0x36, 0x66, 0x65, 0x66, 0x30, 0x39, 0x37, 0x66, 0x35, 0x66, 0x35, 0x36, 0x35, 0x36, 0x61, 0x35, 0x64, 0x31, 0x31, 0x64, 0x64, 0x66, 0x33, 0x33, 0x36, 0x62, 0x36, 0x38, 0x37, 0x39, 0x39, 0x32, 0x36, 0x65, 0x61, 0x32, 0x61, 0x65, 0x34, 0x32, 0x35, 0x65, 0x39, 0x31, 0x63, 0x37, 0x34, 0x38, 0x61, 0x35, 0x35, 0x33, 0x63, 0x39, 0x61, 0x34, 0x39, 0x36, 0x63, 0x62, 0x65, 0x32, 0x61, 0x62, 0x35, 0x35, 0x36, 0x61, 0x39, 0x31, 0x36, 0x38, 0x39, 0x66, 0x37, 0x35, 0x65, 0x65, 0x32, 0x62, 0x30, 0x31, 0x61, 0x64, 0x33, 0x63, 0x34, 0x33, 0x61, 0x61, 0x37, 0x37, 0x34, 0x62, 0x35, 0x30, 0x61, 0x39, 0x64, 0x38, 0x34, 0x31, 0x31, 0x61, 0x39, 0x66, 0x36, 0x35, 0x62, 0x65, 0x34, 0x32, 0x64, 0x36, 0x63, 0x64, 0x65, 0x37, 0x38, 0x31, 0x64, 0x62, 0x31, 0x61, 0x31, 0x39, 0x34, 0x39, 0x61, 0x31, 0x65, 0x38, 0x38, 0x36, 0x66, 0x38, 0x36, 0x38, 0x39, 0x31, 0x37, 0x39, 0x39, 0x37, 0x62, 0x32, 0x61, 0x37, 0x31, 0x32, 0x32, 0x37, 0x32, 0x30, 0x31, 0x35, 0x35, 0x39, 0x33, 0x35, 0x66, 0x31, 0x35, 0x64, 0x61, 0x30, 0x38, 0x30, 0x37, 0x64, 0x30, 0x30, 0x35, 0x34, 0x66, 0x31, 0x61, 0x34, 0x63, 0x33, 0x64, 0x62, 0x32, 0x61, 0x39, 0x32, 0x65, 0x63, 0x34, 0x31, 0x32, 0x34, 0x62, 0x66, 0x35, 0x39, 0x30, 0x63, 0x65, 0x37, 0x61, 0x31, 0x36, 0x35, 0x39, 0x34, 0x66, 0x33, 0x66, 0x31, 0x38, 0x31, 0x32, 0x66, 0x32, 0x36, 0x30, 0x61, 0x63, 0x62, 0x30, 0x34, 0x39, 0x64, 0x30, 0x31, 0x61, 0x64, 0x35, 0x33, 0x34, 0x61, 0x39, 0x33, 0x37, 0x38, 0x34, 0x30, 0x61, 0x38, 0x30, 0x63, 0x30, 0x66, 0x35, 0x36, 0x66, 0x64, 0x39, 0x61, 0x35, 0x34, 0x63, 0x61, 0x35, 0x61, 0x38, 0x36, 0x32, 0x38, 0x65, 0x64, 0x38, 0x39, 0x36, 0x64, 0x31, 0x34, 0x61, 0x35, 0x66, 0x38, 0x62, 0x32, 0x35, 0x37, 0x30, 0x66, 0x35, 0x38, 0x31, 0x33, 0x65, 0x33, 0x35, 0x63, 0x39, 0x39, 0x30, 0x36, 0x35, 0x36, 0x66, 0x36, 0x33, 0x30, 0x30, 0x61, 0x31, 0x61, 0x31, 0x38, 0x34, 0x39, 0x34, 0x32, 0x39, 0x31, 0x33, 0x35, 0x61, 0x64, 0x61, 0x36, 0x33, 0x33, 0x37, 0x36, 0x34, 0x36, 0x32, 0x34, 0x38, 0x66, 0x36, 0x65, 0x61, 0x30, 0x33, 0x61, 0x37, 0x66, 0x37, 0x30, 0x61, 0x63, 0x34, 0x32, 0x36, 0x63, 0x31, 0x64, 0x38, 0x30, 0x35, 0x32, 0x31, 0x36, 0x64, 0x31, 0x35, 0x34, 0x65, 0x61, 0x35, 0x61, 0x38, 0x65, 0x35, 0x66, 0x66, 0x39, 0x35, 0x33, 0x62, 0x63, 0x30, 0x34, 0x62, 0x37, 0x31, 0x62, 0x30, 0x34, 0x39, 0x62, 0x34, 0x62, 0x35, 0x62, 0x64, 0x35, 0x34, 0x39, 0x62, 0x36, 0x62, 0x30, 0x63, 0x66, 0x61, 0x37, 0x66, 0x38, 0x62, 0x32, 0x31, 0x64, 0x62, 0x61, 0x37, 0x32, 0x61, 0x33, 0x38, 0x30, 0x35, 0x63, 0x37, 0x30, 0x39, 0x33, 0x64, 0x38, 0x35, 0x38, 0x39, 0x66, 0x32, 0x64, 0x34, 0x63, 0x35, 0x35, 0x62, 0x36, 0x32, 0x31, 0x31, 0x34, 0x34, 0x31, 0x30, 0x34, 0x31, 0x65, 0x38, 0x62, 0x64, 0x37, 0x39, 0x31, 0x36, 0x64, 0x61, 0x65, 0x64, 0x35, 0x30, 0x39, 0x33, 0x66, 0x63, 0x65, 0x62, 0x64, 0x33, 0x37, 0x37, 0x63, 0x33, 0x31, 0x65, 0x38, 0x31, 0x30, 0x61, 0x36, 0x34, 0x39, 0x39, 0x65, 0x36, 0x65, 0x32, 0x36, 0x38, 0x34, 0x30, 0x65, 0x33, 0x61, 0x66, 0x61, 0x64, 0x63, 0x39, 0x62, 0x33, 0x33, 0x39, 0x63, 0x36, 0x61, 0x62, 0x63, 0x38, 0x36, 0x62, 0x37, 0x66, 0x38, 0x39, 0x66, 0x63, 0x33, 0x35, 0x35, 0x39, 0x66, 0x34, 0x32, 0x34, 0x32, 0x64, 0x33, 0x37, 0x33, 0x61, 0x37, 0x31, 0x33, 0x38, 0x39, 0x64, 0x62, 0x32, 0x30, 0x32, 0x31, 0x39, 0x31, 0x39, 0x35, 0x66, 0x36, 0x65, 0x31, 0x33, 0x30, 0x36, 0x39, 0x37, 0x30, 0x31, 0x66, 0x36, 0x64, 0x35, 0x33, 0x39, 0x64, 0x63, 0x66, 0x36, 0x33, 0x61, 0x30, 0x34, 0x39, 0x37, 0x32, 0x36, 0x63, 0x64, 0x64, 0x38, 0x63, 0x61, 0x64, 0x63, 0x34, 0x31, 0x32, 0x64, 0x31, 0x63, 0x34, 0x33, 0x63, 0x66, 0x33, 0x66, 0x63, 0x30, 0x30, 0x39, 0x35, 0x61, 0x65, 0x35, 0x65, 0x32, 0x31, 0x35, 0x37, 0x64, 0x63, 0x36, 0x36, 0x38, 0x62, 0x64, 0x62, 0x39, 0x32, 0x34, 0x64, 0x37, 0x64, 0x37, 0x61, 0x66, 0x63, 0x32, 0x62, 0x34, 0x36, 0x33, 0x32, 0x61, 0x62, 0x38, 0x61, 0x30, 0x65, 0x34, 0x65, 0x66, 0x37, 0x31, 0x39, 0x34, 0x31, 0x61, 0x30, 0x61, 0x36, 0x61, 0x36, 0x35, 0x36, 0x34, 0x35, 0x66, 0x36, 0x63, 0x64, 0x38, 0x35, 0x37, 0x30, 0x33, 0x30, 0x32, 0x66, 0x39, 0x30, 0x62, 0x39, 0x38, 0x62, 0x62, 0x64, 0x64, 0x30, 0x31, 0x62, 0x65, 0x32, 0x33, 0x38, 0x64, 0x63, 0x30, 0x37, 0x37, 0x38, 0x30, 0x65, 0x65, 0x39, 0x62, 0x39, 0x33, 0x65, 0x32, 0x32, 0x61, 0x62, 0x38, 0x37, 0x66, 0x32, 0x36, 0x31, 0x37, 0x30, 0x64, 0x37, 0x66, 0x63, 0x35, 0x35, 0x33, 0x31, 0x33, 0x34, 0x37, 0x66, 0x62, 0x39, 0x66, 0x61, 0x64, 0x63, 0x62, 0x36, 0x35, 0x64, 0x63, 0x32, 0x63, 0x61, 0x32, 0x30, 0x34, 0x34, 0x32, 0x61, 0x37, 0x30, 0x62, 0x65, 0x39, 0x65, 0x37, 0x38, 0x35, 0x32, 0x39, 0x32, 0x64, 0x35, 0x33, 0x33, 0x66, 0x61, 0x39, 0x34, 0x39, 0x36, 0x33, 0x30, 0x38, 0x61, 0x37, 0x62, 0x31, 0x35, 0x38, 0x38, 0x62, 0x35, 0x30, 0x62, 0x34, 0x35, 0x63, 0x31, 0x37, 0x65, 0x61, 0x37, 0x36, 0x35, 0x64, 0x65, 0x35, 0x32, 0x35, 0x32, 0x35, 0x39, 0x66, 0x30, 0x33, 0x36, 0x65, 0x64, 0x64, 0x33, 0x39, 0x38, 0x34, 0x37, 0x38, 0x32, 0x33, 0x39, 0x39, 0x62, 0x34, 0x36, 0x37, 0x39, 0x33, 0x61, 0x63, 0x64, 0x35, 0x61, 0x62, 0x62, 0x39, 0x66, 0x34, 0x39, 0x65, 0x33, 0x38, 0x62, 0x33, 0x30, 0x39, 0x63, 0x32, 0x33, 0x36, 0x33, 0x61, 0x65, 0x61, 0x64, 0x35, 0x37, 0x32, 0x36, 0x34, 0x61, 0x63, 0x31, 0x61, 0x34, 0x34, 0x65, 0x36, 0x34, 0x33, 0x32, 0x62, 0x38, 0x31, 0x31, 0x32, 0x37, 0x61, 0x30, 0x62, 0x66, 0x64, 0x63, 0x32, 0x39, 0x66, 0x30, 0x31, 0x62, 0x64, 0x30, 0x34, 0x65, 0x37, 0x64, 0x62, 0x32, 0x62, 0x32, 0x35, 0x34, 0x35, 0x65, 0x64, 0x38, 0x34, 0x32, 0x36, 0x64, 0x32, 0x66, 0x65, 0x39, 0x62, 0x33, 0x65, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x65, 0x63, 0x38, 0x66, 0x63, 0x38, 0x37, 0x35, 0x66, 0x32, 0x61, 0x37, 0x31, 0x66, 0x33, 0x31, 0x63, 0x31, 0x33, 0x64, 0x31, 0x31, 0x62, 0x39, 0x34, 0x66, 0x38, 0x39, 0x32, 0x62, 0x62, 0x39, 0x66, 0x39, 0x36, 0x62, 0x64, 0x32, 0x39, 0x33, 0x31, 0x62, 0x36, 0x36, 0x66, 0x66, 0x61, 0x35, 0x65, 0x32, 0x32, 0x62, 0x31, 0x30, 0x34, 0x63, 0x35, 0x34, 0x39, 0x65, 0x37, 0x63, 0x30, 0x64, 0x35, 0x30, 0x31, 0x30, 0x65, 0x34, 0x65, 0x37, 0x30, 0x65, 0x32, 0x37, 0x31, 0x64, 0x34, 0x38, 0x63, 0x30, 0x62, 0x64, 0x36, 0x65, 0x34, 0x62, 0x65, 0x36, 0x38, 0x63, 0x39, 0x32, 0x30, 0x65, 0x61, 0x37, 0x37, 0x61, 0x66, 0x38, 0x35, 0x64, 0x31, 0x32, 0x65, 0x62, 0x31, 0x35, 0x35, 0x64, 0x39, 0x62, 0x32, 0x35, 0x37, 0x30, 0x33, 0x65, 0x61, 0x62, 0x62, 0x64, 0x30, 0x65, 0x64, 0x65, 0x31, 0x39, 0x30, 0x39, 0x35, 0x36, 0x35, 0x61, 0x35, 0x35, 0x66, 0x31, 0x31, 0x66, 0x63, 0x62, 0x61, 0x38, 0x34, 0x38, 0x65, 0x30, 0x31, 0x63, 0x36, 0x30, 0x34, 0x33, 0x38, 0x36, 0x31, 0x31, 0x39, 0x35, 0x38, 0x31, 0x30, 0x31, 0x33, 0x32, 0x31, 0x38, 0x39, 0x38, 0x65, 0x39, 0x35, 0x63, 0x38, 0x66, 0x64, 0x63, 0x39, 0x33, 0x36, 0x64, 0x33, 0x31, 0x33, 0x38, 0x39, 0x62, 0x64, 0x62, 0x61, 0x38, 0x30, 0x37, 0x33, 0x62, 0x33, 0x38, 0x32, 0x65, 0x35, 0x62, 0x31, 0x65, 0x32, 0x63, 0x64, 0x32, 0x35, 0x39, 0x39, 0x33, 0x61, 0x64, 0x33, 0x31, 0x35, 0x38, 0x36, 0x64, 0x37, 0x35, 0x32, 0x35, 0x66, 0x31, 0x36, 0x35, 0x66, 0x62, 0x32, 0x35, 0x61, 0x31, 0x63, 0x66, 0x38, 0x63, 0x32, 0x32, 0x36, 0x32, 0x33, 0x66, 0x39, 0x38, 0x33, 0x63, 0x30, 0x32, 0x35, 0x64, 0x32, 0x31, 0x66, 0x30, 0x65, 0x35, 0x32, 0x65, 0x63, 0x66, 0x65, 0x63, 0x35, 0x66, 0x30, 0x32, 0x33, 0x32, 0x61, 0x37, 0x35, 0x33, 0x61, 0x64, 0x64, 0x61, 0x61, 0x64, 0x38, 0x38, 0x33, 0x34, 0x30, 0x63, 0x61, 0x33, 0x39, 0x66, 0x30, 0x30, 0x65, 0x39, 0x37, 0x32, 0x32, 0x66, 0x33, 0x35, 0x64, 0x64, 0x32, 0x35, 0x66, 0x62, 0x65, 0x38, 0x66, 0x64, 0x64, 0x38, 0x38, 0x34, 0x36, 0x62, 0x66, 0x63, 0x30, 0x32, 0x38, 0x38, 0x32, 0x31, 0x35, 0x64, 0x30, 0x36, 0x33, 0x38, 0x30, 0x30, 0x34, 0x30, 0x30, 0x39, 0x33, 0x39, 0x36, 0x62, 0x66, 0x63, 0x64, 0x35, 0x65, 0x36, 0x65, 0x62, 0x30, 0x63, 0x35, 0x38, 0x37, 0x37, 0x39, 0x37, 0x61, 0x65, 0x38, 0x32, 0x39, 0x37, 0x64, 0x65, 0x63, 0x62, 0x63, 0x61, 0x34, 0x38, 0x62, 0x30, 0x32, 0x34, 0x30, 0x37, 0x32, 0x31, 0x39, 0x62, 0x39, 0x31, 0x30, 0x63, 0x65, 0x31, 0x36, 0x33, 0x35, 0x35, 0x32, 0x65, 0x64, 0x32, 0x33, 0x30, 0x34, 0x33, 0x38, 0x32, 0x39, 0x32, 0x63, 0x65, 0x63, 0x34, 0x33, 0x30, 0x30, 0x30, 0x37, 0x38, 0x38, 0x36, 0x62, 0x65, 0x61, 0x62, 0x65, 0x37, 0x63, 0x64, 0x66, 0x35, 0x63, 0x36, 0x66, 0x39, 0x63, 0x33, 0x37, 0x34, 0x30, 0x61, 0x33, 0x64, 0x64, 0x36, 0x63, 0x35, 0x32, 0x62, 0x61, 0x38, 0x38, 0x65, 0x36, 0x64, 0x36, 0x35, 0x32, 0x63, 0x65, 0x34, 0x33, 0x66, 0x39, 0x30, 0x30, 0x34, 0x34, 0x31, 0x39, 0x33, 0x63, 0x34, 0x61, 0x34, 0x32, 0x33, 0x33, 0x35, 0x32, 0x39, 0x31, 0x37, 0x39, 0x35, 0x63, 0x32, 0x63, 0x63, 0x31, 0x36, 0x30, 0x64, 0x63, 0x36, 0x38, 0x62, 0x36, 0x32, 0x32, 0x35, 0x65, 0x64, 0x62, 0x34, 0x32, 0x35, 0x61, 0x38, 0x38, 0x64, 0x32, 0x37, 0x63, 0x61, 0x65, 0x31, 0x35, 0x39, 0x66, 0x37, 0x37, 0x64, 0x66, 0x33, 0x61, 0x32, 0x32, 0x34, 0x31, 0x66, 0x62, 0x65, 0x38, 0x30, 0x39, 0x63, 0x38, 0x66, 0x31, 0x31, 0x32, 0x32, 0x64, 0x32, 0x34, 0x35, 0x62, 0x66, 0x34, 0x33, 0x39, 0x64, 0x66, 0x30, 0x37, 0x36, 0x31, 0x62, 0x65, 0x63, 0x39, 0x37, 0x33, 0x35, 0x38, 0x62, 0x39, 0x36, 0x64, 0x36, 0x36, 0x35, 0x33, 0x62, 0x63, 0x38, 0x33, 0x37, 0x30, 0x32, 0x62, 0x35, 0x35, 0x39, 0x62, 0x64, 0x65, 0x35, 0x61, 0x32, 0x64, 0x31, 0x32, 0x66, 0x37, 0x37, 0x31, 0x61, 0x32, 0x61, 0x31, 0x31, 0x62, 0x63, 0x39, 0x64, 0x63, 0x33, 0x32, 0x35, 0x38, 0x30, 0x62, 0x63, 0x33, 0x63, 0x63, 0x66, 0x39, 0x64, 0x66, 0x61, 0x63, 0x64, 0x30, 0x61, 0x35, 0x33, 0x37, 0x39, 0x35, 0x38, 0x37, 0x61, 0x63, 0x35, 0x31, 0x36, 0x30, 0x62, 0x34, 0x35, 0x64, 0x33, 0x33, 0x33, 0x61, 0x38, 0x35, 0x63, 0x64, 0x65, 0x34, 0x36, 0x38, 0x31, 0x30, 0x61, 0x64, 0x32, 0x38, 0x37, 0x35, 0x62, 0x34, 0x30, 0x36, 0x66, 0x30, 0x30, 0x34, 0x33, 0x38, 0x61, 0x65, 0x65, 0x32, 0x34, 0x35, 0x65, 0x63, 0x63, 0x36, 0x33, 0x38, 0x31, 0x35, 0x35, 0x32, 0x38, 0x61, 0x31, 0x38, 0x35, 0x65, 0x39, 0x65, 0x32, 0x61, 0x30, 0x32, 0x39, 0x31, 0x34, 0x37, 0x64, 0x62, 0x37, 0x66, 0x63, 0x66, 0x66, 0x63, 0x62, 0x38, 0x38, 0x37, 0x35, 0x65, 0x35, 0x32, 0x35, 0x39, 0x66, 0x31, 0x35, 0x63, 0x33, 0x65, 0x34, 0x36, 0x37, 0x64, 0x65, 0x30, 0x32, 0x65, 0x30, 0x33, 0x35, 0x38, 0x39, 0x31, 0x62, 0x31, 0x33, 0x31, 0x62, 0x63, 0x37, 0x31, 0x35, 0x65, 0x35, 0x34, 0x65, 0x37, 0x65, 0x32, 0x37, 0x61, 0x37, 0x61, 0x63, 0x63, 0x34, 0x33, 0x37, 0x62, 0x62, 0x39, 0x66, 0x36, 0x66, 0x38, 0x34, 0x66, 0x61, 0x34, 0x34, 0x35, 0x36, 0x61, 0x61, 0x30, 0x31, 0x36, 0x62, 0x33, 0x35, 0x37, 0x38, 0x61, 0x37, 0x33, 0x65, 0x64, 0x38, 0x61, 0x34, 0x37, 0x30, 0x36, 0x65, 0x66, 0x62, 0x39, 0x33, 0x35, 0x62, 0x65, 0x38, 0x62, 0x36, 0x61, 0x62, 0x65, 0x30, 0x36, 0x39, 0x37, 0x65, 0x34, 0x36, 0x64, 0x38, 0x37, 0x38, 0x64, 0x39, 0x63, 0x37, 0x34, 0x65, 0x32, 0x37, 0x34, 0x66, 0x32, 0x38, 0x31, 0x36, 0x64, 0x32, 0x66, 0x64, 0x38, 0x38, 0x31, 0x34, 0x36, 0x62, 0x33, 0x31, 0x36, 0x37, 0x33, 0x31, 0x37, 0x31, 0x39, 0x65, 0x31, 0x32, 0x35, 0x64, 0x32, 0x32, 0x37, 0x65, 0x30, 0x30, 0x32, 0x61, 0x66, 0x39, 0x35, 0x61, 0x61, 0x31, 0x33, 0x66, 0x34, 0x36, 0x38, 0x61, 0x39, 0x62, 0x61, 0x65, 0x34, 0x66, 0x66, 0x34, 0x31, 0x61, 0x34, 0x61, 0x36, 0x30, 0x33, 0x36, 0x65, 0x65, 0x37, 0x66, 0x63, 0x33, 0x32, 0x31, 0x62, 0x33, 0x32, 0x34, 0x39, 0x61, 0x65, 0x64, 0x34, 0x64, 0x66, 0x62, 0x36, 0x65, 0x37, 0x35, 0x30, 0x38, 0x39, 0x65, 0x63, 0x30, 0x36, 0x35, 0x36, 0x65, 0x65, 0x34, 0x65, 0x38, 0x37, 0x65, 0x31, 0x66, 0x66, 0x66, 0x65, 0x66, 0x62, 0x64, 0x37, 0x34, 0x65, 0x64, 0x66, 0x35, 0x35, 0x61, 0x32, 0x30, 0x64, 0x37, 0x35, 0x32, 0x61, 0x38, 0x35, 0x63, 0x61, 0x63, 0x63, 0x66, 0x35, 0x38, 0x33, 0x63, 0x30, 0x64, 0x39, 0x65, 0x32, 0x65, 0x66, 0x31, 0x30, 0x34, 0x30, 0x62, 0x34, 0x64, 0x33, 0x36, 0x61, 0x38, 0x65, 0x39, 0x39, 0x32, 0x61, 0x64, 0x35, 0x30, 0x63, 0x65, 0x31, 0x63, 0x34, 0x62, 0x64, 0x32, 0x62, 0x33, 0x30, 0x30, 0x62, 0x33, 0x34, 0x34, 0x63, 0x61, 0x38, 0x38, 0x31, 0x37, 0x32, 0x35, 0x63, 0x31, 0x36, 0x34, 0x38, 0x38, 0x36, 0x61, 0x35, 0x66, 0x38, 0x66, 0x31, 0x38, 0x30, 0x33, 0x35, 0x66, 0x36, 0x65, 0x37, 0x35, 0x65, 0x36, 0x37, 0x61, 0x33, 0x65, 0x61, 0x61, 0x32, 0x30, 0x36, 0x34, 0x66, 0x63, 0x32, 0x34, 0x66, 0x66, 0x37, 0x39, 0x38, 0x39, 0x37, 0x65, 0x64, 0x62, 0x36, 0x32, 0x34, 0x65, 0x31, 0x61, 0x36, 0x37, 0x66, 0x33, 0x34, 0x64, 0x65, 0x62, 0x34, 0x31, 0x34, 0x64, 0x35, 0x65, 0x66, 0x61, 0x66, 0x34, 0x63, 0x35, 0x35, 0x64, 0x34, 0x38, 0x32, 0x64, 0x61, 0x31, 0x30, 0x38, 0x61, 0x61, 0x32, 0x61, 0x62, 0x37, 0x35, 0x30, 0x34, 0x66, 0x64, 0x35, 0x64, 0x37, 0x66, 0x37, 0x38, 0x64, 0x39, 0x31, 0x64, 0x61, 0x35, 0x63, 0x32, 0x30, 0x32, 0x33, 0x30, 0x33, 0x38, 0x30, 0x65, 0x63, 0x30, 0x31, 0x33, 0x62, 0x39, 0x31, 0x30, 0x62, 0x30, 0x31, 0x61, 0x32, 0x36, 0x62, 0x38, 0x62, 0x65, 0x64, 0x38, 0x61, 0x30, 0x35, 0x61, 0x30, 0x30, 0x34, 0x64, 0x35, 0x32, 0x64, 0x62, 0x33, 0x30, 0x62, 0x37, 0x66, 0x62, 0x30, 0x31, 0x66, 0x31, 0x36, 0x33, 0x34, 0x37, 0x36, 0x39, 0x32, 0x65, 0x39, 0x66, 0x31, 0x39, 0x66, 0x33, 0x30, 0x33, 0x66, 0x34, 0x38, 0x65, 0x61, 0x38, 0x63, 0x62, 0x62, 0x65, 0x64, 0x32, 0x64, 0x33, 0x61, 0x33, 0x65, 0x62, 0x32, 0x37, 0x37, 0x64, 0x64, 0x66, 0x34, 0x65, 0x39, 0x65, 0x64, 0x38, 0x30, 0x32, 0x36, 0x61, 0x66, 0x35, 0x63, 0x65, 0x39, 0x32, 0x61, 0x36, 0x31, 0x38, 0x63, 0x38, 0x39, 0x34, 0x32, 0x63, 0x61, 0x66, 0x32, 0x38, 0x62, 0x33, 0x32, 0x34, 0x39, 0x30, 0x34, 0x34, 0x33, 0x34, 0x37, 0x65, 0x31, 0x34, 0x65, 0x35, 0x63, 0x33, 0x63, 0x32, 0x65, 0x64, 0x35, 0x65, 0x63, 0x30, 0x66, 0x39, 0x63, 0x63, 0x63, 0x66, 0x31, 0x64, 0x31, 0x31, 0x61, 0x35, 0x62, 0x32, 0x39, 0x30, 0x63, 0x30, 0x30, 0x37, 0x37, 0x33, 0x65, 0x31, 0x32, 0x63, 0x32, 0x35, 0x66, 0x65, 0x61, 0x66, 0x62, 0x63, 0x63, 0x65, 0x65, 0x62, 0x38, 0x61, 0x65, 0x36, 0x63, 0x32, 0x35, 0x61, 0x38, 0x38, 0x63, 0x39, 0x36, 0x35, 0x37, 0x63, 0x36, 0x32, 0x37, 0x31, 0x38, 0x37, 0x61, 0x66, 0x36, 0x66, 0x65, 0x30, 0x62, 0x66, 0x65, 0x61, 0x30, 0x62, 0x33, 0x63, 0x63, 0x33, 0x36, 0x63, 0x39, 0x30, 0x38, 0x61, 0x37, 0x36, 0x66, 0x39, 0x30, 0x65, 0x39, 0x36, 0x35, 0x62, 0x63, 0x34, 0x31, 0x33, 0x35, 0x63, 0x38, 0x35, 0x39, 0x36, 0x35, 0x33, 0x34, 0x66, 0x34, 0x34, 0x34, 0x63, 0x39, 0x31, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x36, 0x32, 0x37, 0x37, 0x39, 0x38, 0x35, 0x65, 0x33, 0x36, 0x32, 0x34, 0x38, 0x62, 0x64, 0x35, 0x33, 0x65, 0x66, 0x30, 0x66, 0x37, 0x34, 0x66, 0x31, 0x30, 0x33, 0x65, 0x65, 0x61, 0x63, 0x39, 0x38, 0x62, 0x61, 0x39, 0x32, 0x63, 0x35, 0x33, 0x35, 0x30, 0x65, 0x34, 0x61, 0x30, 0x63, 0x35, 0x38, 0x36, 0x63, 0x38, 0x35, 0x31, 0x61, 0x64, 0x32, 0x35, 0x64, 0x66, 0x39, 0x38, 0x32, 0x65, 0x31, 0x36, 0x62, 0x32, 0x64, 0x34, 0x30, 0x38, 0x64, 0x65, 0x33, 0x37, 0x63, 0x36, 0x38, 0x37, 0x65, 0x66, 0x63, 0x36, 0x39, 0x31, 0x35, 0x61, 0x34, 0x31, 0x31, 0x39, 0x37, 0x64, 0x66, 0x33, 0x37, 0x39, 0x36, 0x31, 0x34, 0x61, 0x61, 0x36, 0x35, 0x37, 0x61, 0x62, 0x35, 0x31, 0x30, 0x30, 0x36, 0x32, 0x37, 0x63, 0x34, 0x37, 0x38, 0x39, 0x36, 0x62, 0x35, 0x31, 0x62, 0x30, 0x30, 0x30, 0x63, 0x62, 0x39, 0x35, 0x35, 0x30, 0x35, 0x62, 0x61, 0x63, 0x37, 0x37, 0x65, 0x34, 0x65, 0x34, 0x34, 0x30, 0x65, 0x63, 0x64, 0x31, 0x66, 0x65, 0x35, 0x30, 0x32, 0x35, 0x32, 0x66, 0x63, 0x39, 0x38, 0x66, 0x31, 0x35, 0x65, 0x65, 0x34, 0x31, 0x63, 0x61, 0x66, 0x62, 0x66, 0x37, 0x31, 0x37, 0x65, 0x31, 0x34, 0x34, 0x64, 0x61, 0x33, 0x35, 0x66, 0x34, 0x32, 0x34, 0x65, 0x31, 0x34, 0x31, 0x36, 0x33, 0x39, 0x64, 0x65, 0x30, 0x34, 0x65, 0x62, 0x65, 0x35, 0x64, 0x33, 0x33, 0x33, 0x65, 0x39, 0x64, 0x66, 0x38, 0x63, 0x30, 0x36, 0x38, 0x32, 0x31, 0x63, 0x36, 0x38, 0x39, 0x64, 0x31, 0x65, 0x66, 0x32, 0x61, 0x62, 0x62, 0x66, 0x64, 0x31, 0x32, 0x65, 0x38, 0x61, 0x31, 0x65, 0x64, 0x63, 0x30, 0x35, 0x39, 0x61, 0x39, 0x32, 0x37, 0x39, 0x64, 0x62, 0x37, 0x66, 0x66, 0x34, 0x34, 0x62, 0x61, 0x63, 0x31, 0x39, 0x36, 0x32, 0x62, 0x35, 0x66, 0x37, 0x32, 0x39, 0x37, 0x64, 0x61, 0x35, 0x63, 0x39, 0x38, 0x39, 0x35, 0x32, 0x38, 0x32, 0x32, 0x39, 0x65, 0x39, 0x38, 0x61, 0x39, 0x31, 0x61, 0x33, 0x61, 0x32, 0x65, 0x33, 0x35, 0x31, 0x66, 0x33, 0x37, 0x31, 0x64, 0x66, 0x61, 0x33, 0x34, 0x64, 0x34, 0x63, 0x33, 0x36, 0x37, 0x36, 0x37, 0x32, 0x35, 0x62, 0x61, 0x61, 0x35, 0x66, 0x61, 0x34, 0x36, 0x39, 0x36, 0x66, 0x36, 0x37, 0x66, 0x34, 0x32, 0x33, 0x39, 0x62, 0x35, 0x66, 0x65, 0x31, 0x65, 0x33, 0x66, 0x61, 0x33, 0x35, 0x31, 0x64, 0x36, 0x36, 0x61, 0x61, 0x35, 0x61, 0x32, 0x64, 0x66, 0x39, 0x39, 0x32, 0x34, 0x32, 0x36, 0x64, 0x39, 0x34, 0x62, 0x61, 0x30, 0x34, 0x39, 0x62, 0x62, 0x62, 0x34, 0x65, 0x65, 0x61, 0x30, 0x61, 0x62, 0x32, 0x32, 0x65, 0x33, 0x62, 0x39, 0x61, 0x37, 0x34, 0x30, 0x39, 0x66, 0x32, 0x62, 0x36, 0x37, 0x31, 0x39, 0x65, 0x64, 0x65, 0x36, 0x34, 0x33, 0x35, 0x33, 0x66, 0x34, 0x31, 0x31, 0x32, 0x65, 0x34, 0x64, 0x61, 0x33, 0x39, 0x31, 0x39, 0x61, 0x64, 0x63, 0x31, 0x36, 0x64, 0x63, 0x64, 0x39, 0x39, 0x63, 0x35, 0x34, 0x35, 0x39, 0x36, 0x36, 0x32, 0x35, 0x36, 0x34, 0x39, 0x33, 0x64, 0x32, 0x36, 0x39, 0x39, 0x61, 0x65, 0x35, 0x32, 0x39, 0x65, 0x33, 0x36, 0x35, 0x63, 0x32, 0x30, 0x35, 0x31, 0x35, 0x64, 0x39, 0x35, 0x63, 0x30, 0x31, 0x33, 0x62, 0x61, 0x32, 0x36, 0x32, 0x37, 0x35, 0x37, 0x36, 0x66, 0x62, 0x37, 0x35, 0x61, 0x30, 0x33, 0x30, 0x66, 0x66, 0x64, 0x32, 0x35, 0x62, 0x38, 0x35, 0x65, 0x64, 0x33, 0x66, 0x63, 0x34, 0x30, 0x64, 0x62, 0x62, 0x65, 0x64, 0x62, 0x63, 0x61, 0x35, 0x34, 0x34, 0x32, 0x37, 0x66, 0x38, 0x64, 0x63, 0x32, 0x32, 0x35, 0x35, 0x63, 0x31, 0x36, 0x62, 0x37, 0x34, 0x32, 0x62, 0x33, 0x65, 0x32, 0x62, 0x38, 0x32, 0x65, 0x31, 0x62, 0x62, 0x36, 0x33, 0x34, 0x61, 0x65, 0x37, 0x33, 0x61, 0x34, 0x30, 0x32, 0x39, 0x32, 0x37, 0x65, 0x36, 0x64, 0x63, 0x34, 0x32, 0x34, 0x64, 0x31, 0x39, 0x30, 0x38, 0x39, 0x34, 0x32, 0x62, 0x39, 0x62, 0x30, 0x66, 0x32, 0x63, 0x63, 0x31, 0x37, 0x39, 0x30, 0x39, 0x65, 0x64, 0x30, 0x35, 0x30, 0x64, 0x65, 0x66, 0x65, 0x38, 0x35, 0x64, 0x32, 0x34, 0x61, 0x31, 0x39, 0x38, 0x36, 0x32, 0x39, 0x31, 0x66, 0x61, 0x63, 0x62, 0x62, 0x34, 0x65, 0x63, 0x66, 0x39, 0x62, 0x37, 0x66, 0x66, 0x36, 0x36, 0x63, 0x32, 0x37, 0x66, 0x38, 0x65, 0x37, 0x37, 0x31, 0x64, 0x32, 0x38, 0x65, 0x63, 0x36, 0x38, 0x36, 0x36, 0x65, 0x33, 0x64, 0x32, 0x34, 0x62, 0x63, 0x39, 0x37, 0x65, 0x37, 0x62, 0x65, 0x33, 0x38, 0x38, 0x30, 0x31, 0x33, 0x64, 0x66, 0x38, 0x62, 0x61, 0x38, 0x66, 0x34, 0x30, 0x37, 0x62, 0x39, 0x31, 0x34, 0x37, 0x65, 0x64, 0x39, 0x62, 0x33, 0x35, 0x38, 0x31, 0x37, 0x38, 0x34, 0x30, 0x30, 0x33, 0x61, 0x32, 0x32, 0x65, 0x65, 0x61, 0x64, 0x61, 0x35, 0x35, 0x36, 0x35, 0x36, 0x64, 0x32, 0x62, 0x65, 0x32, 0x37, 0x31, 0x61, 0x66, 0x63, 0x65, 0x30, 0x36, 0x65, 0x66, 0x33, 0x66, 0x63, 0x61, 0x33, 0x32, 0x61, 0x63, 0x39, 0x62, 0x37, 0x37, 0x62, 0x34, 0x66, 0x32, 0x34, 0x32, 0x30, 0x64, 0x36, 0x30, 0x65, 0x38, 0x39, 0x32, 0x63, 0x39, 0x35, 0x34, 0x31, 0x38, 0x62, 0x32, 0x61, 0x31, 0x62, 0x37, 0x64, 0x33, 0x64, 0x61, 0x65, 0x32, 0x37, 0x33, 0x38, 0x61, 0x30, 0x37, 0x33, 0x65, 0x66, 0x31, 0x30, 0x35, 0x65, 0x36, 0x36, 0x63, 0x30, 0x38, 0x34, 0x38, 0x38, 0x65, 0x38, 0x61, 0x39, 0x31, 0x65, 0x38, 0x65, 0x62, 0x64, 0x62, 0x35, 0x61, 0x31, 0x30, 0x65, 0x39, 0x37, 0x39, 0x36, 0x31, 0x31, 0x62, 0x64, 0x32, 0x39, 0x32, 0x34, 0x35, 0x63, 0x31, 0x33, 0x63, 0x63, 0x34, 0x63, 0x30, 0x66, 0x35, 0x62, 0x33, 0x33, 0x65, 0x65, 0x64, 0x63, 0x35, 0x32, 0x36, 0x33, 0x65, 0x64, 0x64, 0x36, 0x63, 0x32, 0x37, 0x36, 0x36, 0x36, 0x65, 0x30, 0x63, 0x33, 0x66, 0x30, 0x32, 0x31, 0x36, 0x31, 0x31, 0x31, 0x34, 0x31, 0x32, 0x30, 0x32, 0x33, 0x30, 0x35, 0x31, 0x31, 0x34, 0x30, 0x36, 0x66, 0x39, 0x66, 0x38, 0x32, 0x31, 0x30, 0x32, 0x66, 0x64, 0x38, 0x63, 0x33, 0x37, 0x63, 0x33, 0x36, 0x64, 0x34, 0x65, 0x33, 0x38, 0x33, 0x65, 0x34, 0x34, 0x35, 0x64, 0x66, 0x34, 0x61, 0x66, 0x63, 0x36, 0x65, 0x37, 0x64, 0x62, 0x61, 0x61, 0x35, 0x37, 0x30, 0x63, 0x66, 0x65, 0x30, 0x35, 0x62, 0x33, 0x66, 0x36, 0x30, 0x33, 0x38, 0x65, 0x63, 0x31, 0x62, 0x37, 0x39, 0x33, 0x32, 0x62, 0x37, 0x30, 0x65, 0x37, 0x62, 0x30, 0x36, 0x38, 0x61, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x33, 0x64, 0x32, 0x34, 0x31, 0x65, 0x38, 0x66, 0x32, 0x30, 0x62, 0x62, 0x36, 0x62, 0x65, 0x33, 0x61, 0x33, 0x61, 0x33, 0x37, 0x36, 0x37, 0x31, 0x31, 0x31, 0x61, 0x61, 0x36, 0x66, 0x34, 0x35, 0x39, 0x66, 0x38, 0x34, 0x62, 0x65, 0x39, 0x36, 0x31, 0x63, 0x32, 0x33, 0x33, 0x37, 0x66, 0x36, 0x65, 0x30, 0x33, 0x65, 0x64, 0x33, 0x63, 0x63, 0x36, 0x63, 0x38, 0x34, 0x37, 0x61, 0x33, 0x36, 0x38, 0x33, 0x38, 0x39, 0x34, 0x32, 0x38, 0x38, 0x62, 0x34, 0x37, 0x31, 0x35, 0x30, 0x34, 0x63, 0x62, 0x64, 0x63, 0x34, 0x33, 0x61, 0x37, 0x38, 0x66, 0x38, 0x35, 0x36, 0x38, 0x30, 0x31, 0x61, 0x31, 0x30, 0x61, 0x38, 0x37, 0x63, 0x37, 0x37, 0x33, 0x32, 0x32, 0x65, 0x33, 0x36, 0x65, 0x30, 0x63, 0x61, 0x34, 0x32, 0x36, 0x65, 0x63, 0x36, 0x37, 0x61, 0x64, 0x33, 0x61, 0x32, 0x61, 0x33, 0x62, 0x37, 0x39, 0x62, 0x63, 0x35, 0x63, 0x62, 0x38, 0x31, 0x39, 0x32, 0x38, 0x61, 0x37, 0x39, 0x61, 0x36, 0x37, 0x61, 0x30, 0x66, 0x62, 0x34, 0x36, 0x62, 0x62, 0x39, 0x36, 0x37, 0x63, 0x62, 0x61, 0x62, 0x37, 0x33, 0x66, 0x64, 0x33, 0x36, 0x30, 0x32, 0x32, 0x66, 0x39, 0x32, 0x64, 0x39, 0x32, 0x30, 0x32, 0x30, 0x34, 0x64, 0x65, 0x36, 0x31, 0x37, 0x31, 0x37, 0x64, 0x64, 0x65, 0x36, 0x61, 0x38, 0x35, 0x62, 0x37, 0x62, 0x63, 0x66, 0x35, 0x37, 0x35, 0x38, 0x34, 0x63, 0x31, 0x31, 0x63, 0x65, 0x35, 0x34, 0x61, 0x63, 0x39, 0x32, 0x39, 0x39, 0x38, 0x66, 0x38, 0x35, 0x36, 0x62, 0x66, 0x30, 0x34, 0x32, 0x61, 0x30, 0x31, 0x63, 0x35, 0x30, 0x30, 0x36, 0x66, 0x31, 0x35, 0x35, 0x61, 0x63, 0x39, 0x37, 0x64, 0x36, 0x37, 0x35, 0x37, 0x37, 0x32, 0x38, 0x63, 0x61, 0x63, 0x65, 0x62, 0x61, 0x35, 0x35, 0x33, 0x30, 0x65, 0x62, 0x37, 0x34, 0x35, 0x65, 0x37, 0x32, 0x32, 0x37, 0x37, 0x37, 0x32, 0x33, 0x61, 0x64, 0x33, 0x34, 0x32, 0x36, 0x38, 0x62, 0x33, 0x34, 0x30, 0x30, 0x38, 0x61, 0x39, 0x37, 0x61, 0x32, 0x37, 0x63, 0x33, 0x37, 0x30, 0x65, 0x39, 0x62, 0x63, 0x30, 0x30, 0x36, 0x61, 0x65, 0x61, 0x63, 0x61, 0x34, 0x61, 0x63, 0x33, 0x36, 0x34, 0x31, 0x34, 0x66, 0x33, 0x35, 0x61, 0x61, 0x34, 0x31, 0x66, 0x66, 0x34, 0x30, 0x30, 0x66, 0x36, 0x39, 0x38, 0x36, 0x32, 0x33, 0x61, 0x34, 0x34, 0x37, 0x63, 0x39, 0x34, 0x39, 0x66, 0x37, 0x66, 0x30, 0x30, 0x34, 0x66, 0x33, 0x63, 0x33, 0x66, 0x64, 0x62, 0x30, 0x39, 0x66, 0x32, 0x61, 0x66, 0x33, 0x63, 0x39, 0x36, 0x30, 0x34, 0x32, 0x65, 0x32, 0x31, 0x35, 0x66, 0x30, 0x64, 0x34, 0x62, 0x62, 0x62, 0x32, 0x33, 0x66, 0x64, 0x61, 0x37, 0x32, 0x64, 0x34, 0x66, 0x30, 0x31, 0x64, 0x64, 0x39, 0x61, 0x35, 0x35, 0x64, 0x62, 0x64, 0x65, 0x63, 0x39, 0x33, 0x30, 0x39, 0x31, 0x39, 0x37, 0x31, 0x35, 0x61, 0x32, 0x33, 0x65, 0x32, 0x63, 0x64, 0x37, 0x37, 0x32, 0x61, 0x32, 0x36, 0x30, 0x65, 0x32, 0x62, 0x39, 0x31, 0x33, 0x32, 0x34, 0x63, 0x32, 0x34, 0x34, 0x64, 0x38, 0x38, 0x63, 0x65, 0x31, 0x62, 0x38, 0x33, 0x63, 0x39, 0x32, 0x64, 0x63, 0x65, 0x31, 0x61, 0x61, 0x30, 0x65, 0x30, 0x63, 0x32, 0x35, 0x35, 0x62, 0x38, 0x30, 0x65, 0x64, 0x39, 0x33, 0x32, 0x35, 0x64, 0x65, 0x63, 0x30, 0x65, 0x36, 0x37, 0x37, 0x35, 0x36, 0x33, 0x39, 0x38, 0x34, 0x61, 0x31, 0x63, 0x35, 0x35, 0x39, 0x64, 0x64, 0x62, 0x34, 0x61, 0x35, 0x34, 0x34, 0x65, 0x61, 0x64, 0x65, 0x62, 0x32, 0x61, 0x33, 0x38, 0x65, 0x38, 0x65, 0x64, 0x37, 0x37, 0x33, 0x36, 0x31, 0x37, 0x34, 0x61, 0x33, 0x30, 0x64, 0x32, 0x62, 0x65, 0x65, 0x36, 0x65, 0x30, 0x62, 0x36, 0x35, 0x66, 0x33, 0x37, 0x36, 0x36, 0x65, 0x30, 0x62, 0x37, 0x61, 0x34, 0x65, 0x34, 0x64, 0x38, 0x30, 0x32, 0x32, 0x64, 0x64, 0x39, 0x66, 0x38, 0x32, 0x34, 0x39, 0x33, 0x61, 0x39, 0x62, 0x31, 0x66, 0x61, 0x64, 0x64, 0x31, 0x39, 0x30, 0x37, 0x31, 0x34, 0x37, 0x61, 0x63, 0x32, 0x39, 0x65, 0x64, 0x65, 0x62, 0x38, 0x63, 0x66, 0x38, 0x63, 0x37, 0x63, 0x35, 0x38, 0x66, 0x62, 0x66, 0x61, 0x39, 0x62, 0x38, 0x32, 0x65, 0x64, 0x33, 0x64, 0x39, 0x66, 0x39, 0x66, 0x30, 0x35, 0x62, 0x66, 0x63, 0x39, 0x30, 0x30, 0x65, 0x35, 0x32, 0x65, 0x32, 0x39, 0x61, 0x30, 0x35, 0x63, 0x61, 0x38, 0x64, 0x34, 0x34, 0x35, 0x62, 0x35, 0x32, 0x34, 0x35, 0x62, 0x31, 0x36, 0x39, 0x32, 0x38, 0x64, 0x64, 0x36, 0x31, 0x38, 0x30, 0x30, 0x65, 0x62, 0x62, 0x36, 0x33, 0x39, 0x33, 0x33, 0x64, 0x39, 0x63, 0x34, 0x37, 0x31, 0x63, 0x32, 0x66, 0x62, 0x33, 0x38, 0x37, 0x37, 0x36, 0x34, 0x35, 0x39, 0x36, 0x34, 0x31, 0x65, 0x39, 0x64, 0x65, 0x62, 0x64, 0x63, 0x36, 0x30, 0x36, 0x61, 0x62, 0x66, 0x36, 0x63, 0x63, 0x66, 0x64, 0x66, 0x38, 0x66, 0x62, 0x34, 0x31, 0x64, 0x61, 0x38, 0x38, 0x62, 0x61, 0x30, 0x37, 0x34, 0x35, 0x64, 0x39, 0x36, 0x66, 0x64, 0x34, 0x35, 0x35, 0x37, 0x61, 0x38, 0x37, 0x39, 0x66, 0x65, 0x65, 0x38, 0x32, 0x65, 0x33, 0x33, 0x64, 0x66, 0x33, 0x32, 0x64, 0x31, 0x38, 0x62, 0x31, 0x38, 0x64, 0x37, 0x33, 0x36, 0x30, 0x35, 0x32, 0x39, 0x66, 0x38, 0x39, 0x66, 0x33, 0x64, 0x65, 0x61, 0x36, 0x38, 0x30, 0x61, 0x35, 0x63, 0x62, 0x30, 0x63, 0x36, 0x61, 0x37, 0x36, 0x35, 0x32, 0x65, 0x65, 0x33, 0x38, 0x35, 0x38, 0x39, 0x65, 0x31, 0x39, 0x39, 0x37, 0x66, 0x33, 0x65, 0x36, 0x34, 0x63, 0x65, 0x34, 0x64, 0x62, 0x31, 0x64, 0x33, 0x63, 0x30, 0x34, 0x63, 0x64, 0x36, 0x32, 0x38, 0x66, 0x63, 0x30, 0x66, 0x64, 0x36, 0x65, 0x37, 0x65, 0x66, 0x31, 0x39, 0x34, 0x34, 0x31, 0x30, 0x38, 0x64, 0x34, 0x38, 0x65, 0x62, 0x37, 0x34, 0x32, 0x61, 0x32, 0x38, 0x34, 0x36, 0x37, 0x66, 0x61, 0x34, 0x62, 0x63, 0x61, 0x36, 0x39, 0x33, 0x64, 0x62, 0x63, 0x38, 0x66, 0x39, 0x32, 0x33, 0x39, 0x34, 0x35, 0x32, 0x35, 0x36, 0x64, 0x61, 0x32, 0x61, 0x38, 0x33, 0x32, 0x32, 0x32, 0x64, 0x31, 0x37, 0x32, 0x32, 0x38, 0x36, 0x63, 0x38, 0x32, 0x62, 0x31, 0x39, 0x34, 0x39, 0x38, 0x30, 0x33, 0x63, 0x35, 0x34, 0x34, 0x30, 0x39, 0x64, 0x65, 0x34, 0x36, 0x35, 0x33, 0x66, 0x32, 0x35, 0x38, 0x64, 0x30, 0x63, 0x66, 0x34, 0x32, 0x36, 0x36, 0x63, 0x38, 0x33, 0x64, 0x35, 0x36, 0x37, 0x35, 0x63, 0x61, 0x39, 0x62, 0x35, 0x62, 0x33, 0x61, 0x33, 0x66, 0x62, 0x33, 0x32, 0x32, 0x62, 0x39, 0x63, 0x34, 0x39, 0x33, 0x65, 0x64, 0x37, 0x62, 0x66, 0x66, 0x30, 0x61, 0x36, 0x31, 0x36, 0x35, 0x62, 0x61, 0x62, 0x62, 0x31, 0x39, 0x63, 0x39, 0x34, 0x64, 0x39, 0x65, 0x32, 0x30, 0x31, 0x34, 0x62, 0x31, 0x33, 0x62, 0x30, 0x39, 0x39, 0x66, 0x30, 0x39, 0x38, 0x39, 0x34, 0x66, 0x62, 0x63, 0x66, 0x33, 0x32, 0x39, 0x35, 0x39, 0x62, 0x39, 0x64, 0x34, 0x63, 0x65, 0x37, 0x31, 0x64, 0x64, 0x66, 0x39, 0x64, 0x32, 0x34, 0x64, 0x65, 0x65, 0x38, 0x62, 0x63, 0x34, 0x30, 0x64, 0x36, 0x62, 0x65, 0x39, 0x32, 0x65, 0x65, 0x36, 0x65, 0x31, 0x32, 0x32, 0x30, 0x64, 0x38, 0x34, 0x64, 0x36, 0x38, 0x65, 0x63, 0x66, 0x31, 0x61, 0x30, 0x34, 0x32, 0x34, 0x31, 0x33, 0x32, 0x33, 0x31, 0x35, 0x63, 0x30, 0x36, 0x31, 0x32, 0x38, 0x30, 0x32, 0x62, 0x34, 0x37, 0x37, 0x62, 0x30, 0x61, 0x63, 0x61, 0x62, 0x63, 0x66, 0x33, 0x34, 0x36, 0x62, 0x30, 0x61, 0x64, 0x35, 0x65, 0x61, 0x33, 0x32, 0x39, 0x65, 0x61, 0x37, 0x32, 0x66, 0x34, 0x64, 0x65, 0x37, 0x35, 0x32, 0x34, 0x35, 0x33, 0x30, 0x62, 0x63, 0x30, 0x30, 0x61, 0x64, 0x33, 0x36, 0x62, 0x61, 0x65, 0x65, 0x65, 0x38, 0x33, 0x35, 0x39, 0x30, 0x38, 0x36, 0x35, 0x35, 0x66, 0x61, 0x65, 0x63, 0x64, 0x33, 0x35, 0x30, 0x34, 0x36, 0x33, 0x34, 0x38, 0x34, 0x64, 0x33, 0x31, 0x36, 0x32, 0x33, 0x31, 0x32, 0x37, 0x63, 0x30, 0x39, 0x63, 0x36, 0x63, 0x65, 0x63, 0x34, 0x34, 0x36, 0x61, 0x39, 0x61, 0x63, 0x39, 0x61, 0x35, 0x33, 0x63, 0x62, 0x36, 0x38, 0x34, 0x31, 0x63, 0x61, 0x32, 0x61, 0x30, 0x39, 0x37, 0x63, 0x65, 0x65, 0x66, 0x38, 0x38, 0x65, 0x35, 0x33, 0x37, 0x65, 0x32, 0x30, 0x39, 0x38, 0x38, 0x30, 0x66, 0x66, 0x64, 0x63, 0x66, 0x64, 0x35, 0x30, 0x33, 0x33, 0x62, 0x63, 0x33, 0x66, 0x35, 0x61, 0x38, 0x38, 0x35, 0x63, 0x32, 0x37, 0x31, 0x65, 0x34, 0x31, 0x65, 0x65, 0x33, 0x33, 0x32, 0x33, 0x36, 0x36, 0x33, 0x34, 0x35, 0x66, 0x61, 0x38, 0x36, 0x37, 0x37, 0x38, 0x30, 0x62, 0x65, 0x62, 0x33, 0x63, 0x31, 0x64, 0x35, 0x65, 0x61, 0x61, 0x34, 0x39, 0x36, 0x65, 0x61, 0x30, 0x39, 0x30, 0x38, 0x63, 0x35, 0x36, 0x30, 0x65, 0x38, 0x34, 0x62, 0x34, 0x30, 0x34, 0x61, 0x66, 0x62, 0x34, 0x35, 0x66, 0x36, 0x39, 0x31, 0x36, 0x39, 0x64, 0x32, 0x38, 0x33, 0x34, 0x38, 0x63, 0x61, 0x32, 0x30, 0x62, 0x62, 0x34, 0x66, 0x35, 0x36, 0x39, 0x33, 0x64, 0x62, 0x31, 0x39, 0x33, 0x30, 0x34, 0x64, 0x31, 0x35, 0x34, 0x66, 0x36, 0x30, 0x61, 0x39, 0x31, 0x65, 0x63, 0x34, 0x65, 0x39, 0x32, 0x35, 0x35, 0x62, 0x65, 0x30, 0x35, 0x37, 0x33, 0x39, 0x66, 0x35, 0x64, 0x63, 0x37, 0x65, 0x30, 0x62, 0x34, 0x32, 0x30, 0x64, 0x34, 0x62, 0x64, 0x65, 0x34, 0x62, 0x31, 0x38, 0x38, 0x61, 0x38, 0x35, 0x32, 0x30, 0x62, 0x66, 0x33, 0x39, 0x32, 0x30, 0x32, 0x66, 0x38, 0x31, 0x64, 0x64, 0x33, 0x65, 0x32, 0x66, 0x34, 0x61, 0x64, 0x63, 0x63, 0x36, 0x66, 0x34, 0x62, 0x34, 0x62, 0x65, 0x31, 0x36, 0x38, 0x38, 0x30, 0x31, 0x30, 0x33, 0x65, 0x30, 0x61, 0x62, 0x32, 0x33, 0x32, 0x66, 0x35, 0x30, 0x39, 0x37, 0x32, 0x39, 0x63, 0x39, 0x31, 0x64, 0x64, 0x66, 0x30, 0x30, 0x30, 0x36, 0x64, 0x36, 0x61, 0x30, 0x39, 0x39, 0x61, 0x37, 0x36, 0x39, 0x62, 0x33, 0x38, 0x61, 0x66, 0x66, 0x62, 0x38, 0x39, 0x64, 0x37, 0x34, 0x38, 0x39, 0x62, 0x33, 0x62, 0x66, 0x32, 0x36, 0x31, 0x31, 0x30, 0x36, 0x61, 0x65, 0x63, 0x33, 0x36, 0x32, 0x63, 0x37, 0x37, 0x61, 0x63, 0x64, 0x62, 0x62, 0x30, 0x61, 0x37, 0x31, 0x63, 0x33, 0x64, 0x61, 0x33, 0x36, 0x39, 0x30, 0x36, 0x37, 0x65, 0x62, 0x30, 0x66, 0x32, 0x65, 0x65, 0x39, 0x38, 0x36, 0x36, 0x61, 0x30, 0x62, 0x62, 0x64, 0x63, 0x34, 0x65, 0x65, 0x34, 0x31, 0x61, 0x65, 0x38, 0x31, 0x61, 0x38, 0x38, 0x64, 0x38, 0x36, 0x30, 0x66, 0x31, 0x37, 0x38, 0x34, 0x35, 0x36, 0x35, 0x62, 0x37, 0x62, 0x31, 0x63, 0x64, 0x64, 0x33, 0x35, 0x30, 0x65, 0x38, 0x65, 0x31, 0x32, 0x32, 0x34, 0x31, 0x31, 0x30, 0x33, 0x66, 0x66, 0x39, 0x64, 0x35, 0x37, 0x63, 0x38, 0x36, 0x63, 0x33, 0x36, 0x38, 0x37, 0x37, 0x35, 0x35, 0x33, 0x30, 0x37, 0x37, 0x33, 0x62, 0x61, 0x66, 0x63, 0x30, 0x35, 0x38, 0x63, 0x62, 0x63, 0x65, 0x61, 0x36, 0x33, 0x30, 0x39, 0x62, 0x64, 0x36, 0x64, 0x39, 0x63, 0x31, 0x34, 0x34, 0x63, 0x66, 0x36, 0x36, 0x35, 0x37, 0x63, 0x61, 0x63, 0x35, 0x30, 0x38, 0x34, 0x61, 0x63, 0x35, 0x66, 0x65, 0x36, 0x33, 0x65, 0x66, 0x30, 0x33, 0x38, 0x61, 0x37, 0x31, 0x62, 0x33, 0x64, 0x37, 0x39, 0x65, 0x36, 0x62, 0x37, 0x61, 0x33, 0x32, 0x63, 0x63, 0x37, 0x30, 0x30, 0x33, 0x39, 0x65, 0x31, 0x38, 0x32, 0x30, 0x35, 0x32, 0x66, 0x35, 0x63, 0x64, 0x35, 0x65, 0x34, 0x31, 0x35, 0x31, 0x32, 0x38, 0x65, 0x39, 0x61, 0x62, 0x31, 0x66, 0x35, 0x35, 0x33, 0x66, 0x31, 0x33, 0x63, 0x31, 0x36, 0x35, 0x65, 0x61, 0x31, 0x32, 0x32, 0x64, 0x30, 0x38, 0x39, 0x39, 0x37, 0x35, 0x63, 0x31, 0x64, 0x61, 0x66, 0x36, 0x31, 0x37, 0x37, 0x36, 0x36, 0x65, 0x31, 0x32, 0x64, 0x39, 0x66, 0x33, 0x61, 0x62, 0x62, 0x32, 0x35, 0x30, 0x31, 0x35, 0x37, 0x31, 0x65, 0x65, 0x66, 0x64, 0x65, 0x31, 0x38, 0x32, 0x62, 0x37, 0x36, 0x37, 0x65, 0x34, 0x62, 0x36, 0x33, 0x35, 0x36, 0x38, 0x64, 0x33, 0x37, 0x61, 0x38, 0x63, 0x35, 0x35, 0x33, 0x36, 0x37, 0x31, 0x61, 0x64, 0x63, 0x65, 0x65, 0x32, 0x65, 0x65, 0x34, 0x63, 0x37, 0x63, 0x36, 0x64, 0x37, 0x37, 0x34, 0x39, 0x33, 0x65, 0x34, 0x35, 0x39, 0x39, 0x63, 0x64, 0x37, 0x30, 0x64, 0x30, 0x30, 0x32, 0x61, 0x37, 0x31, 0x38, 0x66, 0x65, 0x30, 0x64, 0x37, 0x63, 0x33, 0x31, 0x62, 0x37, 0x64, 0x66, 0x33, 0x38, 0x39, 0x33, 0x66, 0x38, 0x62, 0x39, 0x39, 0x39, 0x33, 0x63, 0x39, 0x30, 0x64, 0x37, 0x64, 0x35, 0x35, 0x65, 0x65, 0x61, 0x31, 0x63, 0x33, 0x38, 0x32, 0x39, 0x32, 0x66, 0x31, 0x65, 0x61, 0x65, 0x33, 0x61, 0x37, 0x38, 0x38, 0x37, 0x63, 0x66, 0x64, 0x31, 0x38, 0x32, 0x39, 0x37, 0x37, 0x34, 0x30, 0x33, 0x64, 0x35, 0x63, 0x30, 0x32, 0x39, 0x61, 0x34, 0x32, 0x38, 0x30, 0x39, 0x66, 0x32, 0x63, 0x36, 0x66, 0x62, 0x38, 0x64, 0x30, 0x34, 0x61, 0x66, 0x66, 0x31, 0x63, 0x36, 0x30, 0x31, 0x30, 0x36, 0x62, 0x61, 0x33, 0x36, 0x33, 0x36, 0x37, 0x65, 0x63, 0x63, 0x61, 0x30, 0x36, 0x39, 0x39, 0x38, 0x36, 0x36, 0x65, 0x35, 0x65, 0x63, 0x39, 0x32, 0x32, 0x65, 0x62, 0x61, 0x65, 0x66, 0x66, 0x63, 0x34, 0x65, 0x36, 0x32, 0x34, 0x64, 0x30, 0x63, 0x63, 0x32, 0x63, 0x37, 0x34, 0x38, 0x66, 0x39, 0x63, 0x34, 0x34, 0x36, 0x64, 0x61, 0x30, 0x63, 0x32, 0x39, 0x33, 0x64, 0x38, 0x62, 0x61, 0x37, 0x61, 0x32, 0x38, 0x31, 0x32, 0x35, 0x31, 0x34, 0x35, 0x63, 0x65, 0x30, 0x39, 0x33, 0x36, 0x61, 0x32, 0x64, 0x64, 0x34, 0x37, 0x31, 0x37, 0x32, 0x63, 0x34, 0x35, 0x30, 0x32, 0x63, 0x63, 0x66, 0x30, 0x35, 0x30, 0x31, 0x34, 0x35, 0x66, 0x63, 0x30, 0x35, 0x38, 0x34, 0x61, 0x64, 0x38, 0x36, 0x30, 0x38, 0x65, 0x65, 0x38, 0x66, 0x36, 0x63, 0x33, 0x34, 0x63, 0x33, 0x65, 0x37, 0x31, 0x38, 0x66, 0x61, 0x35, 0x63, 0x61, 0x36, 0x31, 0x36, 0x37, 0x32, 0x32, 0x63, 0x35, 0x62, 0x33, 0x35, 0x34, 0x39, 0x64, 0x64, 0x62, 0x35, 0x65, 0x32, 0x66, 0x36, 0x61, 0x39, 0x36, 0x65, 0x38, 0x32, 0x63, 0x33, 0x64, 0x37, 0x30, 0x36, 0x62, 0x66, 0x32, 0x35, 0x35, 0x61, 0x66, 0x64, 0x61, 0x30, 0x32, 0x37, 0x32, 0x63, 0x31, 0x39, 0x39, 0x64, 0x61, 0x35, 0x31, 0x66, 0x39, 0x61, 0x34, 0x61, 0x38, 0x36, 0x39, 0x63, 0x65, 0x38, 0x62, 0x31, 0x36, 0x34, 0x36, 0x39, 0x34, 0x66, 0x36, 0x65, 0x66, 0x37, 0x35, 0x39, 0x33, 0x63, 0x65, 0x30, 0x38, 0x62, 0x34, 0x62, 0x62, 0x30, 0x61, 0x66, 0x64, 0x61, 0x38, 0x32, 0x32, 0x65, 0x65, 0x64, 0x34, 0x61, 0x30, 0x61, 0x37, 0x38, 0x36, 0x33, 0x66, 0x35, 0x33, 0x32, 0x66, 0x63, 0x30, 0x61, 0x32, 0x32, 0x64, 0x65, 0x39, 0x64, 0x65, 0x35, 0x64, 0x33, 0x34, 0x35, 0x36, 0x35, 0x37, 0x34, 0x30, 0x32, 0x31, 0x62, 0x37, 0x31, 0x31, 0x63, 0x34, 0x32, 0x65, 0x62, 0x31, 0x63, 0x39, 0x31, 0x39, 0x30, 0x64, 0x65, 0x33, 0x35, 0x65, 0x61, 0x35, 0x39, 0x32, 0x35, 0x36, 0x38, 0x66, 0x38, 0x62, 0x61, 0x35, 0x35, 0x32, 0x38, 0x63, 0x30, 0x66, 0x35, 0x66, 0x61, 0x64, 0x63, 0x33, 0x38, 0x65, 0x31, 0x30, 0x62, 0x31, 0x34, 0x61, 0x38, 0x39, 0x61, 0x31, 0x65, 0x34, 0x39, 0x66, 0x62, 0x61, 0x39, 0x61, 0x37, 0x36, 0x63, 0x61, 0x32, 0x34, 0x37, 0x38, 0x64, 0x63, 0x63, 0x61, 0x32, 0x30, 0x66, 0x38, 0x61, 0x33, 0x63, 0x37, 0x38, 0x62, 0x62, 0x33, 0x65, 0x31, 0x62, 0x39, 0x38, 0x36, 0x39, 0x62, 0x37, 0x33, 0x37, 0x35, 0x64, 0x30, 0x64, 0x65, 0x62, 0x38, 0x37, 0x38, 0x31, 0x39, 0x63, 0x65, 0x37, 0x32, 0x30, 0x39, 0x61, 0x64, 0x34, 0x64, 0x37, 0x33, 0x64, 0x38, 0x34, 0x61, 0x39, 0x32, 0x64, 0x30, 0x38, 0x64, 0x32, 0x33, 0x36, 0x34, 0x39, 0x62, 0x62, 0x35, 0x30, 0x65, 0x63, 0x62, 0x34, 0x61, 0x31, 0x37, 0x36, 0x33, 0x30, 0x35, 0x30, 0x62, 0x37, 0x38, 0x36, 0x30, 0x61, 0x66, 0x62, 0x30, 0x35, 0x35, 0x34, 0x36, 0x31, 0x62, 0x33, 0x31, 0x35, 0x38, 0x36, 0x34, 0x37, 0x62, 0x34, 0x35, 0x33, 0x64, 0x37, 0x39, 0x37, 0x37, 0x62, 0x64, 0x64, 0x64, 0x65, 0x30, 0x66, 0x61, 0x63, 0x39, 0x34, 0x31, 0x35, 0x33, 0x32, 0x37, 0x65, 0x37, 0x65, 0x62, 0x32, 0x65, 0x61, 0x33, 0x37, 0x33, 0x66, 0x63, 0x38, 0x61, 0x62, 0x64, 0x36, 0x37, 0x39, 0x33, 0x66, 0x35, 0x37, 0x36, 0x65, 0x37, 0x32, 0x61, 0x34, 0x37, 0x63, 0x39, 0x32, 0x64, 0x36, 0x66, 0x36, 0x65, 0x31, 0x39, 0x66, 0x61, 0x64, 0x66, 0x64, 0x66, 0x32, 0x63, 0x36, 0x39, 0x31, 0x32, 0x33, 0x36, 0x35, 0x62, 0x37, 0x34, 0x39, 0x32, 0x39, 0x64, 0x39, 0x62, 0x34, 0x38, 0x33, 0x63, 0x31, 0x39, 0x66, 0x35, 0x31, 0x34, 0x36, 0x61, 0x63, 0x35, 0x61, 0x38, 0x64, 0x64, 0x39, 0x34, 0x33, 0x63, 0x61, 0x66, 0x35, 0x30, 0x62, 0x32, 0x65, 0x30, 0x61, 0x39, 0x35, 0x66, 0x62, 0x31, 0x39, 0x30, 0x36, 0x36, 0x61, 0x36, 0x33, 0x61, 0x37, 0x31, 0x38, 0x36, 0x32, 0x61, 0x35, 0x34, 0x30, 0x62, 0x32, 0x65, 0x34, 0x31, 0x37, 0x33, 0x31, 0x65, 0x61, 0x36, 0x36, 0x36, 0x39, 0x37, 0x30, 0x39, 0x34, 0x65, 0x35, 0x31, 0x64, 0x33, 0x30, 0x39, 0x35, 0x38, 0x39, 0x63, 0x65, 0x39, 0x64, 0x32, 0x35, 0x61, 0x33, 0x37, 0x63, 0x30, 0x36, 0x63, 0x39, 0x61, 0x31, 0x32, 0x38, 0x33, 0x39, 0x63, 0x34, 0x63, 0x30, 0x38, 0x61, 0x30, 0x35, 0x30, 0x61, 0x33, 0x66, 0x66, 0x39, 0x65, 0x35, 0x30, 0x32, 0x35, 0x31, 0x34, 0x66, 0x32, 0x30, 0x64, 0x35, 0x37, 0x33, 0x63, 0x36, 0x31, 0x30, 0x34, 0x36, 0x36, 0x61, 0x63, 0x35, 0x33, 0x39, 0x39, 0x65, 0x31, 0x31, 0x62, 0x30, 0x31, 0x35, 0x33, 0x39, 0x35, 0x34, 0x34, 0x32, 0x38, 0x66, 0x32, 0x35, 0x64, 0x31, 0x36, 0x39, 0x35, 0x38, 0x61, 0x62, 0x34, 0x38, 0x36, 0x31, 0x34, 0x64, 0x33, 0x34, 0x66, 0x37, 0x36, 0x38, 0x39, 0x39, 0x31, 0x66, 0x38, 0x34, 0x34, 0x31, 0x31, 0x63, 0x34, 0x30, 0x31, 0x65, 0x36, 0x39, 0x30, 0x30, 0x66, 0x62, 0x30, 0x64, 0x66, 0x61, 0x61, 0x62, 0x34, 0x31, 0x30, 0x38, 0x64, 0x62, 0x30, 0x61, 0x64, 0x34, 0x32, 0x66, 0x63, 0x39, 0x61, 0x65, 0x30, 0x61, 0x32, 0x35, 0x35, 0x65, 0x36, 0x30, 0x66, 0x61, 0x34, 0x64, 0x39, 0x32, 0x37, 0x34, 0x37, 0x64, 0x64, 0x64, 0x61, 0x34, 0x37, 0x64, 0x30, 0x37, 0x64, 0x65, 0x39, 0x66, 0x38, 0x34, 0x37, 0x65, 0x37, 0x61, 0x32, 0x62, 0x65, 0x32, 0x38, 0x39, 0x37, 0x39, 0x38, 0x63, 0x35, 0x64, 0x33, 0x34, 0x39, 0x32, 0x34, 0x61, 0x61, 0x65, 0x34, 0x31, 0x39, 0x61, 0x62, 0x64, 0x63, 0x34, 0x31, 0x64, 0x33, 0x30, 0x66, 0x62, 0x30, 0x39, 0x35, 0x63, 0x36, 0x63, 0x63, 0x61, 0x62, 0x65, 0x35, 0x63, 0x35, 0x64, 0x35, 0x62, 0x65, 0x37, 0x33, 0x65, 0x63, 0x36, 0x31, 0x39, 0x37, 0x33, 0x37, 0x31, 0x65, 0x61, 0x37, 0x34, 0x65, 0x30, 0x38, 0x66, 0x30, 0x35, 0x38, 0x33, 0x62, 0x32, 0x31, 0x39, 0x30, 0x31, 0x62, 0x64, 0x37, 0x34, 0x38, 0x64, 0x62, 0x35, 0x33, 0x34, 0x38, 0x32, 0x38, 0x32, 0x63, 0x61, 0x62, 0x61, 0x66, 0x35, 0x37, 0x64, 0x38, 0x38, 0x33, 0x66, 0x35, 0x63, 0x35, 0x35, 0x33, 0x31, 0x31, 0x66, 0x31, 0x33, 0x30, 0x34, 0x64, 0x37, 0x66, 0x63, 0x64, 0x33, 0x30, 0x61, 0x39, 0x66, 0x30, 0x62, 0x32, 0x32, 0x66, 0x38, 0x31, 0x30, 0x62, 0x31, 0x61, 0x37, 0x66, 0x30, 0x38, 0x39, 0x38, 0x36, 0x30, 0x65, 0x34, 0x63, 0x61, 0x30, 0x66, 0x32, 0x33, 0x64, 0x64, 0x63, 0x65, 0x39, 0x61, 0x32, 0x33, 0x64, 0x37, 0x31, 0x36, 0x37, 0x37, 0x36, 0x32, 0x37, 0x33, 0x34, 0x62, 0x31, 0x30, 0x62, 0x39, 0x39, 0x35, 0x64, 0x35, 0x62, 0x64, 0x32, 0x63, 0x66, 0x33, 0x62, 0x33, 0x31, 0x66, 0x38, 0x66, 0x32, 0x34, 0x62, 0x31, 0x38, 0x64, 0x30, 0x61, 0x32, 0x66, 0x37, 0x63, 0x65, 0x31, 0x31, 0x30, 0x31, 0x64, 0x33, 0x61, 0x33, 0x32, 0x64, 0x31, 0x38, 0x39, 0x38, 0x38, 0x66, 0x31, 0x36, 0x32, 0x65, 0x39, 0x31, 0x61, 0x63, 0x39, 0x34, 0x62, 0x30, 0x66, 0x35, 0x32, 0x31, 0x66, 0x32, 0x34, 0x66, 0x61, 0x32, 0x38, 0x37, 0x62, 0x30, 0x64, 0x32, 0x62, 0x39, 0x37, 0x63, 0x34, 0x30, 0x38, 0x30, 0x37, 0x39, 0x33, 0x33, 0x36, 0x62, 0x38, 0x39, 0x61, 0x66, 0x39, 0x65, 0x38, 0x34, 0x32, 0x63, 0x66, 0x33, 0x31, 0x38, 0x38, 0x36, 0x63, 0x37, 0x30, 0x31, 0x30, 0x31, 0x38, 0x62, 0x61, 0x39, 0x38, 0x64, 0x35, 0x62, 0x30, 0x65, 0x62, 0x30, 0x65, 0x36, 0x64, 0x34, 0x31, 0x62, 0x36, 0x37, 0x62, 0x34, 0x39, 0x39, 0x66, 0x34, 0x63, 0x34, 0x36, 0x36, 0x63, 0x62, 0x31, 0x34, 0x31, 0x32, 0x64, 0x62, 0x30, 0x65, 0x35, 0x39, 0x33, 0x37, 0x66, 0x37, 0x66, 0x66, 0x61, 0x38, 0x33, 0x34, 0x32, 0x36, 0x63, 0x39, 0x32, 0x33, 0x34, 0x63, 0x37, 0x31, 0x33, 0x30, 0x39, 0x36, 0x34, 0x34, 0x34, 0x64, 0x30, 0x66, 0x63, 0x36, 0x35, 0x64, 0x31, 0x62, 0x34, 0x35, 0x66, 0x31, 0x36, 0x36, 0x65, 0x35, 0x34, 0x64, 0x32, 0x61, 0x35, 0x34, 0x62, 0x63, 0x31, 0x30, 0x33, 0x64, 0x65, 0x31, 0x31, 0x30, 0x36, 0x36, 0x39, 0x66, 0x62, 0x63, 0x33, 0x34, 0x35, 0x35, 0x35, 0x61, 0x36, 0x64, 0x31, 0x36, 0x37, 0x31, 0x34, 0x63, 0x61, 0x33, 0x37, 0x36, 0x35, 0x31, 0x65, 0x39, 0x37, 0x36, 0x62, 0x30, 0x36, 0x61, 0x37, 0x65, 0x65, 0x39, 0x36, 0x64, 0x38, 0x30, 0x61, 0x66, 0x39, 0x66, 0x66, 0x35, 0x30, 0x31, 0x36, 0x32, 0x30, 0x31, 0x36, 0x61, 0x39, 0x39, 0x38, 0x34, 0x35, 0x31, 0x65, 0x32, 0x63, 0x65, 0x35, 0x38, 0x31, 0x39, 0x66, 0x33, 0x33, 0x34, 0x36, 0x62, 0x31, 0x66, 0x63, 0x64, 0x66, 0x36, 0x66, 0x65, 0x39, 0x66, 0x66, 0x33, 0x65, 0x63, 0x38, 0x34, 0x32, 0x30, 0x64, 0x34, 0x38, 0x36, 0x30, 0x61, 0x39, 0x39, 0x38, 0x30, 0x63, 0x65, 0x32, 0x38, 0x66, 0x64, 0x38, 0x63, 0x35, 0x35, 0x36, 0x36, 0x30, 0x39, 0x38, 0x33, 0x61, 0x33, 0x66, 0x62, 0x30, 0x32, 0x63, 0x62, 0x65, 0x64, 0x62, 0x35, 0x63, 0x36, 0x33, 0x38, 0x61, 0x34, 0x39, 0x65, 0x35, 0x63, 0x64, 0x66, 0x30, 0x62, 0x36, 0x39, 0x62, 0x37, 0x31, 0x64, 0x37, 0x38, 0x65, 0x30, 0x37, 0x31, 0x66, 0x31, 0x32, 0x30, 0x30, 0x36, 0x30, 0x38, 0x65, 0x32, 0x33, 0x35, 0x65, 0x36, 0x65, 0x64, 0x30, 0x65, 0x65, 0x38, 0x66, 0x65, 0x61, 0x35, 0x35, 0x36, 0x37, 0x62, 0x65, 0x31, 0x32, 0x30, 0x31, 0x38, 0x62, 0x63, 0x64, 0x30, 0x32, 0x36, 0x34, 0x31, 0x32, 0x64, 0x62, 0x30, 0x35, 0x33, 0x38, 0x63, 0x32, 0x38, 0x62, 0x63, 0x64, 0x34, 0x61, 0x39, 0x61, 0x66, 0x65, 0x37, 0x39, 0x39, 0x64, 0x35, 0x63, 0x36, 0x37, 0x37, 0x32, 0x39, 0x38, 0x36, 0x34, 0x36, 0x39, 0x34, 0x33, 0x63, 0x34, 0x32, 0x30, 0x30, 0x61, 0x30, 0x33, 0x39, 0x64, 0x32, 0x66, 0x63, 0x65, 0x64, 0x37, 0x31, 0x64, 0x39, 0x38, 0x35, 0x64, 0x31, 0x38, 0x38, 0x66, 0x38, 0x34, 0x64, 0x66, 0x64, 0x33, 0x31, 0x33, 0x32, 0x62, 0x36, 0x61, 0x30, 0x31, 0x35, 0x63, 0x35, 0x30, 0x62, 0x38, 0x61, 0x36, 0x30, 0x64, 0x37, 0x31, 0x32, 0x61, 0x39, 0x37, 0x63, 0x38, 0x39, 0x65, 0x30, 0x63, 0x64, 0x37, 0x64, 0x33, 0x61, 0x31, 0x37, 0x34, 0x30, 0x32, 0x34, 0x34, 0x63, 0x31, 0x35, 0x32, 0x32, 0x62, 0x31, 0x31, 0x37, 0x64, 0x61, 0x64, 0x31, 0x32, 0x32, 0x30, 0x34, 0x36, 0x33, 0x66, 0x35, 0x64, 0x34, 0x61, 0x66, 0x31, 0x30, 0x30, 0x34, 0x63, 0x31, 0x61, 0x32, 0x61, 0x64, 0x36, 0x62, 0x35, 0x37, 0x30, 0x38, 0x64, 0x37, 0x64, 0x36, 0x62, 0x32, 0x38, 0x66, 0x38, 0x61, 0x65, 0x31, 0x65, 0x31, 0x65, 0x37, 0x64, 0x64, 0x31, 0x62, 0x32, 0x64, 0x33, 0x37, 0x39, 0x38, 0x62, 0x38, 0x63, 0x32, 0x65, 0x32, 0x37, 0x61, 0x33, 0x35, 0x35, 0x39, 0x63, 0x37, 0x32, 0x30, 0x32, 0x61, 0x61, 0x32, 0x36, 0x38, 0x30, 0x39, 0x39, 0x65, 0x62, 0x33, 0x62, 0x62, 0x64, 0x66, 0x37, 0x63, 0x34, 0x32, 0x64, 0x30, 0x64, 0x32, 0x30, 0x62, 0x34, 0x37, 0x65, 0x35, 0x36, 0x32, 0x33, 0x64, 0x62, 0x61, 0x38, 0x65, 0x36, 0x61, 0x61, 0x31, 0x33, 0x39, 0x32, 0x66, 0x66, 0x35, 0x33, 0x32, 0x31, 0x31, 0x33, 0x63, 0x33, 0x32, 0x62, 0x64, 0x38, 0x33, 0x36, 0x66, 0x34, 0x31, 0x36, 0x30, 0x61, 0x62, 0x62, 0x32, 0x38, 0x37, 0x61, 0x65, 0x66, 0x65, 0x36, 0x34, 0x38, 0x61, 0x61, 0x66, 0x66, 0x36, 0x62, 0x62, 0x30, 0x61, 0x32, 0x33, 0x39, 0x32, 0x38, 0x66, 0x35, 0x38, 0x30, 0x33, 0x34, 0x37, 0x30, 0x34, 0x36, 0x62, 0x36, 0x34, 0x62, 0x61, 0x62, 0x66, 0x33, 0x35, 0x34, 0x37, 0x39, 0x30, 0x37, 0x30, 0x34, 0x35, 0x33, 0x38, 0x63, 0x36, 0x63, 0x65, 0x38, 0x33, 0x66, 0x31, 0x31, 0x37, 0x61, 0x63, 0x37, 0x65, 0x38, 0x33, 0x65, 0x31, 0x65, 0x30, 0x66, 0x35, 0x34, 0x30, 0x35, 0x34, 0x34, 0x36, 0x36, 0x63, 0x63, 0x38, 0x32, 0x62, 0x32, 0x31, 0x34, 0x34, 0x63, 0x66, 0x31, 0x33, 0x35, 0x62, 0x65, 0x33, 0x31, 0x66, 0x32, 0x34, 0x66, 0x31, 0x62, 0x32, 0x32, 0x34, 0x65, 0x32, 0x61, 0x39, 0x35, 0x36, 0x38, 0x32, 0x37, 0x63, 0x33, 0x30, 0x33, 0x62, 0x30, 0x64, 0x38, 0x32, 0x39, 0x36, 0x34, 0x65, 0x32, 0x38, 0x34, 0x62, 0x39, 0x36, 0x38, 0x63, 0x35, 0x65, 0x62, 0x65, 0x39, 0x37, 0x36, 0x38, 0x38, 0x65, 0x34, 0x39, 0x63, 0x61, 0x37, 0x39, 0x33, 0x61, 0x34, 0x61, 0x62, 0x61, 0x38, 0x31, 0x61, 0x33, 0x64, 0x33, 0x36, 0x65, 0x65, 0x66, 0x64, 0x38, 0x63, 0x31, 0x32, 0x65, 0x33, 0x63, 0x65, 0x39, 0x34, 0x30, 0x39, 0x62, 0x65, 0x36, 0x33, 0x63, 0x33, 0x61, 0x33, 0x30, 0x38, 0x36, 0x33, 0x36, 0x61, 0x37, 0x62, 0x32, 0x39, 0x36, 0x62, 0x38, 0x30, 0x34, 0x64, 0x38, 0x31, 0x32, 0x35, 0x62, 0x34, 0x66, 0x32, 0x39, 0x30, 0x36, 0x38, 0x65, 0x66, 0x34, 0x34, 0x64, 0x33, 0x66, 0x32, 0x61, 0x33, 0x63, 0x39, 0x65, 0x62, 0x31, 0x33, 0x65, 0x36, 0x31, 0x64, 0x36, 0x33, 0x36, 0x35, 0x62, 0x62, 0x39, 0x36, 0x64, 0x36, 0x39, 0x37, 0x33, 0x65, 0x38, 0x38, 0x61, 0x37, 0x30, 0x37, 0x35, 0x37, 0x62, 0x31, 0x64, 0x39, 0x32, 0x31, 0x33, 0x35, 0x31, 0x31, 0x64, 0x33, 0x35, 0x37, 0x64, 0x32, 0x35, 0x32, 0x64, 0x66, 0x35, 0x38, 0x64, 0x31, 0x65, 0x38, 0x34, 0x38, 0x64, 0x35, 0x33, 0x34, 0x64, 0x39, 0x35, 0x31, 0x37, 0x31, 0x36, 0x35, 0x32, 0x36, 0x33, 0x65, 0x38, 0x30, 0x33, 0x38, 0x35, 0x35, 0x65, 0x38, 0x63, 0x61, 0x66, 0x33, 0x38, 0x37, 0x35, 0x37, 0x39, 0x66, 0x31, 0x66, 0x66, 0x30, 0x65, 0x37, 0x65, 0x39, 0x63, 0x33, 0x63, 0x38, 0x65, 0x35, 0x33, 0x32, 0x61, 0x32, 0x30, 0x32, 0x35, 0x64, 0x38, 0x30, 0x31, 0x36, 0x62, 0x37, 0x30, 0x61, 0x34, 0x35, 0x63, 0x32, 0x34, 0x61, 0x35, 0x34, 0x36, 0x66, 0x30, 0x62, 0x32, 0x31, 0x61, 0x63, 0x66, 0x33, 0x38, 0x64, 0x31, 0x36, 0x62, 0x32, 0x37, 0x65, 0x61, 0x65, 0x36, 0x34, 0x36, 0x36, 0x65, 0x32, 0x32, 0x33, 0x39, 0x36, 0x30, 0x39, 0x37, 0x30, 0x39, 0x30, 0x32, 0x39, 0x31, 0x31, 0x38, 0x34, 0x61, 0x37, 0x37, 0x31, 0x39, 0x62, 0x65, 0x62, 0x34, 0x61, 0x35, 0x35, 0x62, 0x65, 0x62, 0x38, 0x39, 0x32, 0x37, 0x35, 0x63, 0x36, 0x38, 0x39, 0x33, 0x65, 0x30, 0x31, 0x66, 0x32, 0x30, 0x37, 0x35, 0x64, 0x33, 0x62, 0x37, 0x33, 0x65, 0x31, 0x36, 0x35, 0x63, 0x33, 0x39, 0x33, 0x33, 0x35, 0x64, 0x33, 0x34, 0x61, 0x35, 0x61, 0x61, 0x37, 0x62, 0x32, 0x38, 0x30, 0x33, 0x38, 0x36, 0x65, 0x33, 0x30, 0x61, 0x36, 0x64, 0x66, 0x39, 0x62, 0x61, 0x39, 0x31, 0x37, 0x65, 0x31, 0x64, 0x63, 0x36, 0x37, 0x37, 0x34, 0x65, 0x32, 0x65, 0x64, 0x61, 0x61, 0x30, 0x63, 0x38, 0x37, 0x65, 0x38, 0x66, 0x35, 0x66, 0x63, 0x66, 0x38, 0x39, 0x33, 0x30, 0x36, 0x61, 0x36, 0x66, 0x64, 0x62, 0x63, 0x66, 0x38, 0x63, 0x66, 0x35, 0x32, 0x63, 0x66, 0x32, 0x35, 0x66, 0x35, 0x64, 0x66, 0x34, 0x37, 0x33, 0x66, 0x65, 0x33, 0x35, 0x30, 0x33, 0x32, 0x35, 0x64, 0x35, 0x31, 0x30, 0x34, 0x32, 0x31, 0x35, 0x34, 0x36, 0x37, 0x36, 0x35, 0x61, 0x63, 0x64, 0x30, 0x30, 0x62, 0x33, 0x34, 0x65, 0x66, 0x35, 0x33, 0x65, 0x35, 0x36, 0x62, 0x30, 0x31, 0x34, 0x34, 0x35, 0x64, 0x65, 0x65, 0x61, 0x30, 0x34, 0x32, 0x32, 0x38, 0x32, 0x65, 0x37, 0x64, 0x36, 0x63, 0x65, 0x32, 0x30, 0x63, 0x38, 0x66, 0x39, 0x36, 0x37, 0x32, 0x30, 0x34, 0x63, 0x32, 0x36, 0x62, 0x64, 0x61, 0x39, 0x66, 0x32, 0x35, 0x39, 0x36, 0x66, 0x61, 0x33, 0x37, 0x38, 0x64, 0x63, 0x36, 0x31, 0x31, 0x30, 0x39, 0x31, 0x61, 0x62, 0x36, 0x64, 0x62, 0x39, 0x65, 0x31, 0x65, 0x38, 0x64, 0x34, 0x65, 0x39, 0x62, 0x35, 0x63, 0x31, 0x63, 0x63, 0x34, 0x63, 0x34, 0x64, 0x36, 0x65, 0x65, 0x32, 0x61, 0x64, 0x38, 0x32, 0x62, 0x33, 0x32, 0x64, 0x30, 0x38, 0x66, 0x38, 0x63, 0x62, 0x35, 0x61, 0x39, 0x64, 0x64, 0x39, 0x62, 0x30, 0x33, 0x66, 0x37, 0x61, 0x61, 0x37, 0x35, 0x34, 0x66, 0x32, 0x37, 0x33, 0x38, 0x64, 0x64, 0x66, 0x32, 0x64, 0x63, 0x30, 0x63, 0x33, 0x33, 0x31, 0x38, 0x39, 0x37, 0x34, 0x66, 0x66, 0x33, 0x38, 0x31, 0x30, 0x37, 0x36, 0x35, 0x39, 0x31, 0x37, 0x63, 0x32, 0x35, 0x31, 0x63, 0x37, 0x34, 0x63, 0x65, 0x33, 0x64, 0x37, 0x31, 0x33, 0x32, 0x63, 0x32, 0x36, 0x62, 0x35, 0x66, 0x32, 0x65, 0x64, 0x65, 0x31, 0x32, 0x61, 0x36, 0x66, 0x36, 0x32, 0x66, 0x32, 0x65, 0x38, 0x64, 0x64, 0x65, 0x63, 0x64, 0x35, 0x65, 0x30, 0x64, 0x30, 0x32, 0x66, 0x39, 0x39, 0x66, 0x32, 0x65, 0x64, 0x38, 0x61, 0x63, 0x31, 0x35, 0x36, 0x34, 0x31, 0x63, 0x35, 0x38, 0x36, 0x64, 0x36, 0x38, 0x65, 0x30, 0x39, 0x33, 0x66, 0x62, 0x65, 0x38, 0x30, 0x63, 0x65, 0x66, 0x64, 0x36, 0x61, 0x37, 0x64, 0x62, 0x64, 0x61, 0x63, 0x36, 0x64, 0x34, 0x33, 0x65, 0x32, 0x36, 0x31, 0x31, 0x36, 0x30, 0x38, 0x30, 0x37, 0x65, 0x62, 0x38, 0x32, 0x66, 0x63, 0x32, 0x61, 0x65, 0x61, 0x38, 0x37, 0x30, 0x61, 0x32, 0x32, 0x62, 0x32, 0x35, 0x31, 0x34, 0x38, 0x64, 0x32, 0x35, 0x36, 0x61, 0x30, 0x38, 0x33, 0x33, 0x32, 0x35, 0x61, 0x35, 0x62, 0x39, 0x37, 0x62, 0x63, 0x66, 0x30, 0x31, 0x38, 0x37, 0x66, 0x37, 0x34, 0x38, 0x62, 0x36, 0x63, 0x30, 0x61, 0x31, 0x36, 0x39, 0x31, 0x38, 0x36, 0x37, 0x33, 0x34, 0x34, 0x65, 0x66, 0x64, 0x64, 0x35, 0x33, 0x38, 0x30, 0x39, 0x66, 0x62, 0x39, 0x65, 0x64, 0x65, 0x61, 0x35, 0x37, 0x36, 0x36, 0x39, 0x63, 0x33, 0x33, 0x37, 0x38, 0x30, 0x61, 0x34, 0x61, 0x61, 0x39, 0x65, 0x36, 0x35, 0x31, 0x34, 0x39, 0x39, 0x33, 0x37, 0x38, 0x31, 0x37, 0x64, 0x33, 0x64, 0x38, 0x34, 0x35, 0x64, 0x39, 0x66, 0x63, 0x63, 0x61, 0x65, 0x31, 0x38, 0x37, 0x36, 0x35, 0x37, 0x35, 0x64, 0x35, 0x33, 0x38, 0x33, 0x64, 0x30, 0x36, 0x61, 0x64, 0x65, 0x61, 0x63, 0x64, 0x30, 0x66, 0x33, 0x33, 0x37, 0x31, 0x32, 0x30, 0x39, 0x61, 0x33, 0x30, 0x65, 0x31, 0x61, 0x39, 0x63, 0x39, 0x38, 0x34, 0x34, 0x36, 0x31, 0x37, 0x34, 0x62, 0x30, 0x62, 0x39, 0x38, 0x35, 0x36, 0x30, 0x36, 0x35, 0x32, 0x64, 0x30, 0x36, 0x34, 0x33, 0x66, 0x31, 0x32, 0x30, 0x62, 0x64, 0x61, 0x62, 0x64, 0x35, 0x34, 0x38, 0x34, 0x34, 0x33, 0x35, 0x38, 0x37, 0x31, 0x62, 0x34, 0x32, 0x61, 0x64, 0x30, 0x63, 0x65, 0x33, 0x36, 0x61, 0x61, 0x38, 0x33, 0x33, 0x30, 0x63, 0x37, 0x65, 0x64, 0x64, 0x32, 0x36, 0x65, 0x36, 0x34, 0x65, 0x38, 0x39, 0x65, 0x62, 0x38, 0x34, 0x65, 0x30, 0x63, 0x37, 0x32, 0x61, 0x32, 0x63, 0x36, 0x65, 0x34, 0x39, 0x66, 0x62, 0x32, 0x34, 0x30, 0x38, 0x38, 0x61, 0x65, 0x32, 0x62, 0x64, 0x61, 0x66, 0x37, 0x65, 0x66, 0x30, 0x37, 0x61, 0x66, 0x39, 0x62, 0x66, 0x65, 0x33, 0x38, 0x31, 0x64, 0x64, 0x36, 0x61, 0x39, 0x65, 0x64, 0x34, 0x33, 0x30, 0x61, 0x35, 0x35, 0x33, 0x64, 0x65, 0x31, 0x62, 0x61, 0x64, 0x34, 0x64, 0x63, 0x65, 0x66, 0x64, 0x35, 0x32, 0x33, 0x39, 0x62, 0x33, 0x38, 0x39, 0x30, 0x39, 0x30, 0x39, 0x32, 0x35, 0x61, 0x36, 0x39, 0x65, 0x34, 0x34, 0x65, 0x32, 0x35, 0x38, 0x30, 0x30, 0x64, 0x39, 0x66, 0x63, 0x63, 0x64, 0x61, 0x31, 0x31, 0x66, 0x66, 0x34, 0x65, 0x31, 0x65, 0x34, 0x64, 0x33, 0x30, 0x34, 0x39, 0x33, 0x38, 0x36, 0x33, 0x39, 0x37, 0x66, 0x31, 0x31, 0x34, 0x35, 0x63, 0x33, 0x35, 0x39, 0x35, 0x61, 0x62, 0x35, 0x31, 0x31, 0x35, 0x32, 0x35, 0x35, 0x62, 0x63, 0x31, 0x63, 0x31, 0x65, 0x61, 0x62, 0x62, 0x33, 0x37, 0x39, 0x61, 0x33, 0x37, 0x35, 0x30, 0x34, 0x65, 0x64, 0x61, 0x32, 0x37, 0x62, 0x31, 0x61, 0x31, 0x30, 0x33, 0x62, 0x38, 0x38, 0x61, 0x65, 0x38, 0x66, 0x31, 0x37, 0x34, 0x65, 0x31, 0x64, 0x31, 0x38, 0x32, 0x65, 0x33, 0x64, 0x66, 0x62, 0x62, 0x30, 0x62, 0x38, 0x33, 0x31, 0x37, 0x64, 0x30, 0x35, 0x64, 0x36, 0x65, 0x30, 0x38, 0x63, 0x31, 0x39, 0x31, 0x36, 0x36, 0x31, 0x62, 0x30, 0x34, 0x35, 0x33, 0x37, 0x34, 0x32, 0x31, 0x66, 0x64, 0x38, 0x34, 0x30, 0x35, 0x37, 0x61, 0x39, 0x66, 0x66, 0x35, 0x61, 0x36, 0x65, 0x63, 0x65, 0x62, 0x36, 0x38, 0x63, 0x35, 0x62, 0x66, 0x31, 0x66, 0x30, 0x65, 0x33, 0x35, 0x36, 0x64, 0x66, 0x36, 0x65, 0x39, 0x33, 0x64, 0x39, 0x33, 0x36, 0x62, 0x62, 0x36, 0x62, 0x64, 0x63, 0x63, 0x62, 0x34, 0x32, 0x31, 0x32, 0x37, 0x63, 0x62, 0x61, 0x34, 0x33, 0x65, 0x37, 0x36, 0x31, 0x35, 0x64, 0x35, 0x32, 0x32, 0x32, 0x34, 0x32, 0x64, 0x66, 0x31, 0x33, 0x66, 0x30, 0x38, 0x65, 0x35, 0x66, 0x61, 0x31, 0x36, 0x32, 0x61, 0x36, 0x34, 0x31, 0x34, 0x33, 0x30, 0x63, 0x31, 0x34, 0x33, 0x31, 0x61, 0x37, 0x64, 0x37, 0x31, 0x38, 0x31, 0x64, 0x65, 0x63, 0x36, 0x35, 0x32, 0x30, 0x32, 0x66, 0x62, 0x36, 0x31, 0x38, 0x61, 0x36, 0x39, 0x30, 0x63, 0x32, 0x62, 0x66, 0x33, 0x33, 0x36, 0x31, 0x64, 0x37, 0x64, 0x63, 0x36, 0x38, 0x39, 0x64, 0x35, 0x65, 0x34, 0x61, 0x39, 0x37, 0x61, 0x35, 0x35, 0x30, 0x61, 0x39, 0x62, 0x31, 0x37, 0x63, 0x38, 0x61, 0x35, 0x61, 0x64, 0x61, 0x38, 0x66, 0x33, 0x32, 0x64, 0x62, 0x33, 0x66, 0x37, 0x37, 0x34, 0x65, 0x39, 0x65, 0x64, 0x30, 0x34, 0x37, 0x63, 0x30, 0x32, 0x65, 0x62, 0x37, 0x64, 0x31, 0x62, 0x61, 0x37, 0x61, 0x64, 0x64, 0x32, 0x39, 0x66, 0x61, 0x30, 0x37, 0x61, 0x62, 0x39, 0x30, 0x66, 0x32, 0x39, 0x30, 0x65, 0x37, 0x37, 0x62, 0x64, 0x39, 0x31, 0x65, 0x65, 0x39, 0x62, 0x35, 0x32, 0x30, 0x38, 0x62, 0x31, 0x66, 0x62, 0x31, 0x39, 0x61, 0x33, 0x37, 0x66, 0x32, 0x39, 0x64, 0x64, 0x31, 0x61, 0x34, 0x39, 0x32, 0x66, 0x61, 0x33, 0x32, 0x31, 0x35, 0x36, 0x61, 0x37, 0x64, 0x34, 0x33, 0x31, 0x34, 0x36, 0x61, 0x33, 0x33, 0x36, 0x66, 0x65, 0x36, 0x31, 0x34, 0x34, 0x64, 0x31, 0x39, 0x32, 0x32, 0x38, 0x66, 0x39, 0x37, 0x35, 0x63, 0x35, 0x34, 0x61, 0x62, 0x33, 0x30, 0x34, 0x35, 0x36, 0x35, 0x32, 0x36, 0x39, 0x31, 0x32, 0x34, 0x65, 0x30, 0x36, 0x39, 0x65, 0x38, 0x36, 0x34, 0x38, 0x37, 0x33, 0x63, 0x30, 0x65, 0x65, 0x66, 0x32, 0x33, 0x66, 0x32, 0x65, 0x37, 0x62, 0x30, 0x31, 0x32, 0x65, 0x38, 0x34, 0x61, 0x64, 0x30, 0x63, 0x37, 0x31, 0x64, 0x37, 0x36, 0x65, 0x31, 0x62, 0x32, 0x33, 0x62, 0x38, 0x62, 0x39, 0x61, 0x30, 0x61, 0x36, 0x36, 0x65, 0x64, 0x63, 0x64, 0x35, 0x39, 0x66, 0x34, 0x62, 0x32, 0x30, 0x33, 0x61, 0x39, 0x37, 0x37, 0x33, 0x63, 0x65, 0x32, 0x36, 0x62, 0x61, 0x65, 0x65, 0x32, 0x30, 0x36, 0x32, 0x35, 0x34, 0x62, 0x34, 0x39, 0x65, 0x66, 0x62, 0x31, 0x30, 0x63, 0x63, 0x34, 0x38, 0x62, 0x61, 0x64, 0x38, 0x31, 0x34, 0x62, 0x32, 0x65, 0x32, 0x39, 0x39, 0x62, 0x64, 0x34, 0x37, 0x38, 0x66, 0x64, 0x34, 0x62, 0x64, 0x38, 0x62, 0x31, 0x61, 0x65, 0x32, 0x63, 0x38, 0x62, 0x64, 0x39, 0x39, 0x30, 0x37, 0x30, 0x62, 0x32, 0x35, 0x39, 0x61, 0x39, 0x65, 0x32, 0x30, 0x34, 0x65, 0x34, 0x32, 0x66, 0x63, 0x35, 0x66, 0x36, 0x35, 0x66, 0x39, 0x65, 0x32, 0x35, 0x63, 0x62, 0x34, 0x65, 0x34, 0x61, 0x31, 0x61, 0x33, 0x62, 0x36, 0x37, 0x38, 0x37, 0x32, 0x33, 0x31, 0x34, 0x66, 0x63, 0x61, 0x65, 0x65, 0x64, 0x65, 0x32, 0x61, 0x62, 0x62, 0x62, 0x63, 0x36, 0x39, 0x37, 0x38, 0x36, 0x36, 0x30, 0x63, 0x33, 0x65, 0x36, 0x38, 0x35, 0x66, 0x36, 0x64, 0x63, 0x63, 0x62, 0x35, 0x33, 0x31, 0x36, 0x30, 0x64, 0x31, 0x66, 0x37, 0x35, 0x31, 0x37, 0x62, 0x62, 0x64, 0x61, 0x35, 0x34, 0x31, 0x37, 0x37, 0x34, 0x39, 0x35, 0x63, 0x32, 0x33, 0x66, 0x63, 0x66, 0x34, 0x35, 0x63, 0x64, 0x64, 0x36, 0x36, 0x33, 0x36, 0x33, 0x61, 0x37, 0x30, 0x61, 0x38, 0x34, 0x66, 0x32, 0x36, 0x39, 0x39, 0x65, 0x32, 0x33, 0x39, 0x62, 0x35, 0x30, 0x37, 0x31, 0x63, 0x39, 0x65, 0x36, 0x63, 0x62, 0x31, 0x39, 0x30, 0x36, 0x39, 0x66, 0x33, 0x65, 0x30, 0x62, 0x65, 0x39, 0x66, 0x34, 0x33, 0x39, 0x30, 0x63, 0x38, 0x30, 0x32, 0x38, 0x61, 0x65, 0x39, 0x39, 0x36, 0x30, 0x38, 0x35, 0x31, 0x65, 0x33, 0x34, 0x65, 0x61, 0x31, 0x38, 0x66, 0x66, 0x38, 0x38, 0x64, 0x33, 0x36, 0x65, 0x65, 0x38, 0x32, 0x36, 0x63, 0x30, 0x61, 0x34, 0x64, 0x62, 0x34, 0x65, 0x33, 0x33, 0x65, 0x39, 0x34, 0x66, 0x30, 0x65, 0x63, 0x36, 0x36, 0x35, 0x31, 0x61, 0x37, 0x32, 0x38, 0x61, 0x31, 0x61, 0x32, 0x62, 0x30, 0x63, 0x31, 0x35, 0x62, 0x33, 0x30, 0x61, 0x31, 0x37, 0x38, 0x33, 0x61, 0x64, 0x34, 0x62, 0x31, 0x64, 0x32, 0x32, 0x34, 0x64, 0x38, 0x37, 0x32, 0x36, 0x34, 0x37, 0x37, 0x39, 0x61, 0x38, 0x31, 0x37, 0x64, 0x31, 0x30, 0x37, 0x64, 0x34, 0x30, 0x63, 0x37, 0x35, 0x62, 0x37, 0x37, 0x63, 0x32, 0x35, 0x61, 0x64, 0x64, 0x64, 0x37, 0x62, 0x37, 0x64, 0x36, 0x61, 0x38, 0x62, 0x37, 0x33, 0x62, 0x32, 0x64, 0x35, 0x35, 0x31, 0x66, 0x31, 0x32, 0x35, 0x64, 0x61, 0x65, 0x64, 0x39, 0x35, 0x37, 0x38, 0x36, 0x39, 0x32, 0x30, 0x63, 0x34, 0x31, 0x33, 0x30, 0x64, 0x32, 0x30, 0x36, 0x31, 0x31, 0x37, 0x38, 0x36, 0x30, 0x34, 0x66, 0x39, 0x36, 0x30, 0x34, 0x61, 0x30, 0x65, 0x32, 0x66, 0x31, 0x63, 0x36, 0x63, 0x64, 0x62, 0x66, 0x33, 0x30, 0x36, 0x36, 0x66, 0x64, 0x32, 0x38, 0x62, 0x66, 0x32, 0x37, 0x36, 0x65, 0x65, 0x30, 0x61, 0x65, 0x65, 0x33, 0x37, 0x39, 0x62, 0x63, 0x30, 0x34, 0x39, 0x62, 0x63, 0x38, 0x65, 0x62, 0x61, 0x33, 0x36, 0x31, 0x66, 0x34, 0x30, 0x35, 0x32, 0x62, 0x64, 0x32, 0x61, 0x36, 0x39, 0x38, 0x64, 0x61, 0x33, 0x31, 0x32, 0x63, 0x39, 0x39, 0x31, 0x30, 0x31, 0x35, 0x63, 0x30, 0x66, 0x62, 0x63, 0x34, 0x33, 0x65, 0x61, 0x31, 0x64, 0x32, 0x65, 0x37, 0x32, 0x34, 0x32, 0x36, 0x32, 0x37, 0x39, 0x66, 0x63, 0x35, 0x31, 0x38, 0x31, 0x38, 0x35, 0x31, 0x61, 0x31, 0x35, 0x61, 0x32, 0x66, 0x34, 0x38, 0x38, 0x33, 0x30, 0x31, 0x38, 0x61, 0x62, 0x30, 0x31, 0x66, 0x66, 0x38, 0x37, 0x34, 0x35, 0x36, 0x32, 0x35, 0x66, 0x33, 0x38, 0x38, 0x66, 0x30, 0x35, 0x66, 0x35, 0x66, 0x61, 0x39, 0x61, 0x62, 0x63, 0x35, 0x64, 0x38, 0x37, 0x61, 0x37, 0x31, 0x30, 0x61, 0x31, 0x32, 0x32, 0x37, 0x33, 0x32, 0x32, 0x36, 0x32, 0x36, 0x31, 0x31, 0x35, 0x62, 0x36, 0x30, 0x66, 0x37, 0x38, 0x31, 0x66, 0x34, 0x64, 0x64, 0x64, 0x39, 0x31, 0x65, 0x32, 0x30, 0x35, 0x63, 0x31, 0x63, 0x63, 0x61, 0x35, 0x38, 0x32, 0x61, 0x35, 0x65, 0x33, 0x37, 0x65, 0x30, 0x30, 0x35, 0x33, 0x39, 0x36, 0x37, 0x30, 0x33, 0x33, 0x37, 0x35, 0x38, 0x34, 0x36, 0x62, 0x65, 0x34, 0x66, 0x33, 0x36, 0x66, 0x64, 0x62, 0x37, 0x36, 0x63, 0x32, 0x37, 0x37, 0x64, 0x63, 0x31, 0x61, 0x32, 0x66, 0x66, 0x31, 0x66, 0x31, 0x38, 0x33, 0x63, 0x62, 0x61, 0x66, 0x63, 0x36, 0x64, 0x62, 0x34, 0x38, 0x35, 0x61, 0x35, 0x36, 0x32, 0x66, 0x34, 0x64, 0x30, 0x38, 0x32, 0x36, 0x32, 0x61, 0x32, 0x30, 0x37, 0x38, 0x34, 0x34, 0x61, 0x33, 0x64, 0x31, 0x32, 0x32, 0x36, 0x31, 0x66, 0x61, 0x30, 0x61, 0x63, 0x34, 0x37, 0x39, 0x61, 0x62, 0x63, 0x61, 0x37, 0x36, 0x66, 0x34, 0x31, 0x37, 0x64, 0x66, 0x34, 0x32, 0x62, 0x30, 0x33, 0x37, 0x65, 0x36, 0x31, 0x31, 0x62, 0x31, 0x62, 0x36, 0x61, 0x63, 0x66, 0x64, 0x61, 0x39, 0x34, 0x64, 0x35, 0x64, 0x61, 0x63, 0x63, 0x36, 0x32, 0x30, 0x63, 0x33, 0x65, 0x64, 0x66, 0x35, 0x37, 0x34, 0x34, 0x64, 0x62, 0x32, 0x34, 0x62, 0x63, 0x63, 0x34, 0x31, 0x65, 0x66, 0x31, 0x37, 0x32, 0x32, 0x64, 0x63, 0x30, 0x65, 0x36, 0x32, 0x30, 0x66, 0x38, 0x61, 0x33, 0x35, 0x63, 0x35, 0x30, 0x35, 0x38, 0x35, 0x61, 0x37, 0x63, 0x65, 0x63, 0x66, 0x63, 0x39, 0x37, 0x66, 0x30, 0x35, 0x62, 0x66, 0x65, 0x63, 0x32, 0x31, 0x66, 0x39, 0x31, 0x39, 0x34, 0x32, 0x30, 0x65, 0x36, 0x32, 0x61, 0x39, 0x63, 0x34, 0x66, 0x32, 0x38, 0x65, 0x61, 0x39, 0x35, 0x38, 0x35, 0x63, 0x63, 0x30, 0x35, 0x36, 0x61, 0x65, 0x65, 0x30, 0x38, 0x65, 0x64, 0x38, 0x38, 0x39, 0x31, 0x64, 0x30, 0x37, 0x37, 0x61, 0x39, 0x36, 0x34, 0x37, 0x64, 0x39, 0x63, 0x30, 0x62, 0x35, 0x63, 0x33, 0x31, 0x34, 0x31, 0x66, 0x38, 0x63, 0x35, 0x31, 0x37, 0x66, 0x31, 0x33, 0x62, 0x30, 0x35, 0x62, 0x66, 0x30, 0x61, 0x31, 0x38, 0x62, 0x39, 0x39, 0x31, 0x31, 0x31, 0x64, 0x32, 0x64, 0x36, 0x65, 0x37, 0x62, 0x34, 0x38, 0x39, 0x32, 0x65, 0x37, 0x38, 0x66, 0x61, 0x62, 0x33, 0x35, 0x64, 0x38, 0x38, 0x32, 0x65, 0x34, 0x65, 0x31, 0x35, 0x33, 0x30, 0x36, 0x30, 0x66, 0x30, 0x63, 0x34, 0x34, 0x63, 0x62, 0x39, 0x34, 0x36, 0x64, 0x32, 0x30, 0x61, 0x64, 0x30, 0x38, 0x39, 0x37, 0x61, 0x33, 0x34, 0x64, 0x32, 0x61, 0x32, 0x34, 0x64, 0x33, 0x38, 0x30, 0x30, 0x62, 0x35, 0x34, 0x61, 0x63, 0x64, 0x36, 0x38, 0x66, 0x64, 0x64, 0x37, 0x39, 0x37, 0x61, 0x61, 0x33, 0x36, 0x32, 0x35, 0x36, 0x30, 0x64, 0x63, 0x65, 0x64, 0x65, 0x36, 0x64, 0x31, 0x32, 0x39, 0x30, 0x39, 0x39, 0x34, 0x38, 0x62, 0x64, 0x36, 0x66, 0x34, 0x37, 0x32, 0x36, 0x61, 0x32, 0x30, 0x31, 0x34, 0x32, 0x65, 0x65, 0x63, 0x39, 0x63, 0x36, 0x62, 0x37, 0x38, 0x64, 0x32, 0x32, 0x34, 0x62, 0x32, 0x63, 0x32, 0x34, 0x38, 0x38, 0x35, 0x34, 0x39, 0x30, 0x62, 0x66, 0x62, 0x34, 0x39, 0x32, 0x32, 0x31, 0x37, 0x63, 0x36, 0x38, 0x30, 0x39, 0x65, 0x30, 0x36, 0x32, 0x38, 0x31, 0x36, 0x34, 0x35, 0x37, 0x39, 0x64, 0x32, 0x63, 0x32, 0x63, 0x31, 0x36, 0x61, 0x39, 0x30, 0x66, 0x32, 0x38, 0x61, 0x61, 0x35, 0x33, 0x39, 0x33, 0x61, 0x64, 0x34, 0x34, 0x63, 0x34, 0x35, 0x64, 0x34, 0x65, 0x31, 0x35, 0x30, 0x30, 0x66, 0x63, 0x63, 0x64, 0x63, 0x63, 0x36, 0x38, 0x34, 0x30, 0x32, 0x33, 0x64, 0x37, 0x63, 0x61, 0x63, 0x34, 0x65, 0x32, 0x63, 0x63, 0x61, 0x38, 0x38, 0x39, 0x33, 0x33, 0x33, 0x66, 0x30, 0x34, 0x38, 0x63, 0x64, 0x39, 0x61, 0x32, 0x39, 0x64, 0x65, 0x30, 0x31, 0x38, 0x65, 0x39, 0x35, 0x38, 0x64, 0x30, 0x30, 0x35, 0x35, 0x33, 0x63, 0x37, 0x37, 0x63, 0x37, 0x34, 0x61, 0x62, 0x35, 0x30, 0x64, 0x39, 0x37, 0x34, 0x64, 0x66, 0x35, 0x66, 0x36, 0x35, 0x34, 0x32, 0x33, 0x33, 0x66, 0x62, 0x39, 0x32, 0x33, 0x65, 0x38, 0x30, 0x39, 0x65, 0x66, 0x36, 0x63, 0x65, 0x61, 0x62, 0x65, 0x36, 0x61, 0x38, 0x36, 0x30, 0x33, 0x38, 0x36, 0x36, 0x30, 0x33, 0x30, 0x30, 0x33, 0x63, 0x63, 0x33, 0x37, 0x36, 0x65, 0x39, 0x30, 0x62, 0x38, 0x62, 0x65, 0x65, 0x37, 0x34, 0x66, 0x32, 0x34, 0x37, 0x37, 0x33, 0x34, 0x33, 0x61, 0x35, 0x61, 0x65, 0x39, 0x32, 0x33, 0x61, 0x65, 0x61, 0x34, 0x66, 0x66, 0x65, 0x39, 0x39, 0x61, 0x39, 0x31, 0x62, 0x39, 0x64, 0x39, 0x32, 0x38, 0x39, 0x64, 0x64, 0x63, 0x63, 0x33, 0x63, 0x61, 0x33, 0x31, 0x36, 0x62, 0x30, 0x32, 0x36, 0x62, 0x33, 0x64, 0x33, 0x36, 0x39, 0x61, 0x63, 0x61, 0x34, 0x37, 0x34, 0x62, 0x37, 0x39, 0x34, 0x31, 0x35, 0x38, 0x38, 0x66, 0x63, 0x36, 0x65, 0x39, 0x63, 0x62, 0x30, 0x36, 0x32, 0x35, 0x32, 0x38, 0x62, 0x31, 0x30, 0x66, 0x31, 0x33, 0x62, 0x39, 0x30, 0x64, 0x64, 0x35, 0x35, 0x61, 0x66, 0x64, 0x36, 0x34, 0x66, 0x37, 0x62, 0x30, 0x61, 0x62, 0x37, 0x39, 0x31, 0x36, 0x33, 0x31, 0x36, 0x33, 0x63, 0x65, 0x30, 0x32, 0x61, 0x65, 0x64, 0x33, 0x37, 0x39, 0x61, 0x66, 0x32, 0x35, 0x37, 0x34, 0x30, 0x61, 0x63, 0x35, 0x65, 0x33, 0x37, 0x63, 0x35, 0x36, 0x32, 0x38, 0x63, 0x30, 0x62, 0x38, 0x36, 0x38, 0x62, 0x37, 0x63, 0x63, 0x66, 0x65, 0x64, 0x30, 0x61, 0x65, 0x35, 0x32, 0x31, 0x63, 0x39, 0x36, 0x34, 0x38, 0x34, 0x36, 0x66, 0x30, 0x32, 0x38, 0x37, 0x64, 0x33, 0x30, 0x30, 0x36, 0x39, 0x35, 0x32, 0x35, 0x33, 0x39, 0x62, 0x32, 0x64, 0x66, 0x66, 0x61, 0x66, 0x38, 0x39, 0x31, 0x62, 0x64, 0x30, 0x31, 0x66, 0x65, 0x39, 0x38, 0x61, 0x31, 0x36, 0x38, 0x35, 0x65, 0x37, 0x31, 0x35, 0x33, 0x36, 0x64, 0x37, 0x66, 0x33, 0x33, 0x61, 0x65, 0x38, 0x35, 0x37, 0x37, 0x35, 0x64, 0x31, 0x31, 0x35, 0x34, 0x35, 0x65, 0x62, 0x33, 0x37, 0x39, 0x65, 0x30, 0x39, 0x31, 0x36, 0x62, 0x65, 0x36, 0x31, 0x36, 0x32, 0x30, 0x36, 0x39, 0x36, 0x38, 0x36, 0x30, 0x35, 0x65, 0x35, 0x30, 0x33, 0x33, 0x32, 0x36, 0x37, 0x66, 0x36, 0x66, 0x37, 0x39, 0x63, 0x63, 0x36, 0x35, 0x31, 0x63, 0x32, 0x63, 0x65, 0x37, 0x31, 0x61, 0x37, 0x39, 0x30, 0x61, 0x65, 0x35, 0x63, 0x65, 0x66, 0x31, 0x39, 0x66, 0x65, 0x61, 0x37, 0x36, 0x30, 0x34, 0x65, 0x34, 0x37, 0x39, 0x63, 0x30, 0x37, 0x39, 0x33, 0x66, 0x38, 0x32, 0x64, 0x62, 0x31, 0x66, 0x38, 0x65, 0x38, 0x35, 0x62, 0x65, 0x63, 0x34, 0x30, 0x64, 0x38, 0x63, 0x36, 0x61, 0x32, 0x64, 0x62, 0x63, 0x39, 0x62, 0x66, 0x37, 0x36, 0x64, 0x30, 0x32, 0x61, 0x36, 0x31, 0x36, 0x61, 0x63, 0x65, 0x64, 0x36, 0x31, 0x31, 0x61, 0x65, 0x31, 0x61, 0x37, 0x61, 0x33, 0x37, 0x35, 0x36, 0x64, 0x38, 0x37, 0x64, 0x61, 0x62, 0x32, 0x38, 0x35, 0x35, 0x63, 0x61, 0x35, 0x38, 0x35, 0x64, 0x30, 0x30, 0x34, 0x38, 0x65, 0x31, 0x65, 0x34, 0x32, 0x32, 0x32, 0x65, 0x64, 0x39, 0x64, 0x36, 0x66, 0x61, 0x32, 0x34, 0x65, 0x33, 0x65, 0x31, 0x33, 0x36, 0x37, 0x37, 0x32, 0x35, 0x36, 0x66, 0x62, 0x62, 0x39, 0x39, 0x35, 0x39, 0x62, 0x39, 0x36, 0x35, 0x37, 0x32, 0x37, 0x63, 0x31, 0x39, 0x32, 0x36, 0x39, 0x36, 0x61, 0x31, 0x31, 0x34, 0x37, 0x34, 0x61, 0x37, 0x66, 0x36, 0x61, 0x36, 0x62, 0x36, 0x63, 0x38, 0x65, 0x66, 0x62, 0x36, 0x34, 0x39, 0x62, 0x31, 0x66, 0x36, 0x30, 0x31, 0x63, 0x37, 0x36, 0x35, 0x37, 0x36, 0x66, 0x33, 0x36, 0x39, 0x39, 0x36, 0x65, 0x63, 0x37, 0x61, 0x32, 0x30, 0x65, 0x65, 0x65, 0x38, 0x34, 0x32, 0x30, 0x38, 0x32, 0x33, 0x32, 0x63, 0x32, 0x30, 0x65, 0x38, 0x35, 0x30, 0x32, 0x39, 0x30, 0x33, 0x64, 0x34, 0x65, 0x33, 0x30, 0x33, 0x65, 0x34, 0x61, 0x64, 0x37, 0x31, 0x33, 0x39, 0x63, 0x36, 0x35, 0x34, 0x62, 0x37, 0x65, 0x35, 0x64, 0x32, 0x61, 0x61, 0x32, 0x36, 0x32, 0x64, 0x37, 0x35, 0x36, 0x37, 0x32, 0x63, 0x62, 0x62, 0x34, 0x66, 0x36, 0x35, 0x33, 0x65, 0x36, 0x32, 0x65, 0x64, 0x38, 0x65, 0x34, 0x64, 0x32, 0x38, 0x38, 0x33, 0x35, 0x66, 0x37, 0x64, 0x36, 0x64, 0x30, 0x65, 0x66, 0x62, 0x33, 0x66, 0x33, 0x39, 0x63, 0x34, 0x30, 0x35, 0x35, 0x38, 0x64, 0x39, 0x63, 0x62, 0x66, 0x31, 0x39, 0x66, 0x32, 0x35, 0x30, 0x36, 0x38, 0x31, 0x61, 0x35, 0x63, 0x38, 0x61, 0x35, 0x39, 0x31, 0x34, 0x33, 0x66, 0x65, 0x63, 0x38, 0x30, 0x64, 0x36, 0x61, 0x36, 0x39, 0x64, 0x38, 0x61, 0x32, 0x36, 0x35, 0x38, 0x33, 0x35, 0x64, 0x36, 0x35, 0x36, 0x32, 0x65, 0x66, 0x32, 0x34, 0x38, 0x66, 0x61, 0x34, 0x61, 0x63, 0x35, 0x30, 0x38, 0x62, 0x64, 0x36, 0x30, 0x63, 0x39, 0x32, 0x38, 0x33, 0x66, 0x36, 0x65, 0x37, 0x33, 0x31, 0x62, 0x61, 0x61, 0x37, 0x38, 0x36, 0x38, 0x32, 0x38, 0x64, 0x30, 0x66, 0x37, 0x61, 0x36, 0x33, 0x35, 0x65, 0x31, 0x64, 0x31, 0x34, 0x61, 0x34, 0x34, 0x38, 0x33, 0x38, 0x33, 0x63, 0x38, 0x62, 0x30, 0x32, 0x34, 0x33, 0x35, 0x37, 0x30, 0x64, 0x66, 0x34, 0x61, 0x34, 0x32, 0x37, 0x39, 0x39, 0x61, 0x66, 0x65, 0x30, 0x33, 0x31, 0x34, 0x33, 0x63, 0x32, 0x32, 0x37, 0x65, 0x33, 0x66, 0x63, 0x66, 0x30, 0x62, 0x31, 0x33, 0x39, 0x33, 0x62, 0x64, 0x66, 0x38, 0x62, 0x61, 0x63, 0x62, 0x64, 0x32, 0x36, 0x66, 0x31, 0x30, 0x34, 0x31, 0x64, 0x35, 0x65, 0x33, 0x31, 0x31, 0x32, 0x63, 0x38, 0x34, 0x37, 0x35, 0x35, 0x39, 0x34, 0x32, 0x66, 0x61, 0x63, 0x37, 0x37, 0x39, 0x38, 0x31, 0x66, 0x65, 0x31, 0x36, 0x66, 0x30, 0x34, 0x38, 0x63, 0x64, 0x38, 0x38, 0x32, 0x32, 0x34, 0x33, 0x61, 0x38, 0x37, 0x38, 0x37, 0x62, 0x30, 0x39, 0x62, 0x64, 0x63, 0x33, 0x38, 0x38, 0x34, 0x37, 0x61, 0x35, 0x61, 0x39, 0x63, 0x63, 0x39, 0x61, 0x61, 0x66, 0x34, 0x64, 0x33, 0x30, 0x35, 0x34, 0x34, 0x31, 0x38, 0x31, 0x66, 0x66, 0x30, 0x31, 0x34, 0x64, 0x63, 0x61, 0x38, 0x62, 0x32, 0x38, 0x39, 0x32, 0x63, 0x30, 0x30, 0x61, 0x39, 0x33, 0x33, 0x33, 0x33, 0x33, 0x64, 0x66, 0x36, 0x64, 0x38, 0x65, 0x66, 0x37, 0x39, 0x30, 0x34, 0x31, 0x34, 0x38, 0x33, 0x66, 0x32, 0x64, 0x38, 0x63, 0x36, 0x34, 0x31, 0x36, 0x38, 0x39, 0x37, 0x61, 0x65, 0x37, 0x38, 0x39, 0x37, 0x63, 0x61, 0x31, 0x64, 0x61, 0x38, 0x35, 0x65, 0x38, 0x66, 0x30, 0x61, 0x34, 0x39, 0x33, 0x62, 0x65, 0x34, 0x35, 0x32, 0x30, 0x35, 0x39, 0x35, 0x63, 0x64, 0x30, 0x64, 0x64, 0x37, 0x64, 0x33, 0x32, 0x63, 0x38, 0x37, 0x39, 0x39, 0x39, 0x65, 0x37, 0x30, 0x33, 0x37, 0x30, 0x34, 0x62, 0x61, 0x30, 0x61, 0x63, 0x37, 0x64, 0x38, 0x62, 0x34, 0x34, 0x34, 0x64, 0x62, 0x61, 0x38, 0x30, 0x37, 0x37, 0x34, 0x36, 0x31, 0x32, 0x33, 0x31, 0x30, 0x30, 0x65, 0x32, 0x63, 0x66, 0x37, 0x35, 0x37, 0x33, 0x38, 0x34, 0x33, 0x61, 0x30, 0x61, 0x37, 0x35, 0x35, 0x65, 0x65, 0x62, 0x61, 0x64, 0x36, 0x30, 0x34, 0x35, 0x64, 0x32, 0x39, 0x37, 0x30, 0x61, 0x30, 0x65, 0x66, 0x38, 0x63, 0x39, 0x61, 0x64, 0x64, 0x64, 0x66, 0x66, 0x30, 0x39, 0x33, 0x65, 0x37, 0x39, 0x37, 0x33, 0x31, 0x64, 0x35, 0x65, 0x35, 0x30, 0x36, 0x66, 0x31, 0x63, 0x34, 0x33, 0x33, 0x31, 0x38, 0x66, 0x62, 0x32, 0x35, 0x31, 0x34, 0x34, 0x66, 0x66, 0x35, 0x66, 0x62, 0x36, 0x33, 0x30, 0x34, 0x31, 0x35, 0x37, 0x34, 0x65, 0x38, 0x39, 0x32, 0x31, 0x36, 0x65, 0x62, 0x65, 0x30, 0x61, 0x63, 0x37, 0x35, 0x64, 0x37, 0x64, 0x63, 0x66, 0x66, 0x63, 0x33, 0x35, 0x64, 0x30, 0x39, 0x35, 0x36, 0x39, 0x31, 0x37, 0x32, 0x33, 0x34, 0x39, 0x33, 0x63, 0x39, 0x34, 0x64, 0x63, 0x63, 0x31, 0x31, 0x64, 0x34, 0x34, 0x38, 0x30, 0x62, 0x66, 0x33, 0x66, 0x65, 0x37, 0x62, 0x37, 0x36, 0x62, 0x61, 0x35, 0x33, 0x63, 0x61, 0x65, 0x35, 0x62, 0x34, 0x30, 0x39, 0x63, 0x30, 0x30, 0x32, 0x66, 0x32, 0x64, 0x31, 0x62, 0x62, 0x35, 0x65, 0x61, 0x62, 0x30, 0x38, 0x61, 0x63, 0x39, 0x39, 0x33, 0x30, 0x35, 0x34, 0x65, 0x63, 0x32, 0x39, 0x37, 0x35, 0x34, 0x33, 0x37, 0x39, 0x38, 0x37, 0x30, 0x30, 0x66, 0x65, 0x33, 0x65, 0x32, 0x38, 0x37, 0x37, 0x61, 0x34, 0x61, 0x30, 0x63, 0x63, 0x65, 0x35, 0x33, 0x35, 0x39, 0x39, 0x61, 0x36, 0x36, 0x65, 0x62, 0x34, 0x66, 0x31, 0x66, 0x65, 0x66, 0x35, 0x63, 0x61, 0x66, 0x63, 0x37, 0x37, 0x34, 0x32, 0x37, 0x37, 0x66, 0x30, 0x65, 0x36, 0x39, 0x34, 0x65, 0x62, 0x64, 0x37, 0x66, 0x38, 0x37, 0x34, 0x38, 0x66, 0x62, 0x35, 0x31, 0x34, 0x30, 0x37, 0x33, 0x35, 0x32, 0x38, 0x32, 0x65, 0x35, 0x65, 0x30, 0x62, 0x39, 0x62, 0x62, 0x33, 0x35, 0x62, 0x38, 0x61, 0x65, 0x62, 0x30, 0x39, 0x38, 0x37, 0x37, 0x35, 0x61, 0x33, 0x33, 0x38, 0x32, 0x30, 0x63, 0x39, 0x62, 0x38, 0x64, 0x65, 0x63, 0x61, 0x64, 0x33, 0x61, 0x64, 0x36, 0x63, 0x65, 0x33, 0x36, 0x66, 0x37, 0x39, 0x63, 0x33, 0x34, 0x37, 0x64, 0x63, 0x63, 0x32, 0x63, 0x36, 0x30, 0x61, 0x35, 0x34, 0x34, 0x32, 0x64, 0x32, 0x65, 0x61, 0x62, 0x34, 0x33, 0x36, 0x38, 0x38, 0x32, 0x37, 0x61, 0x63, 0x61, 0x65, 0x31, 0x66, 0x30, 0x63, 0x63, 0x64, 0x35, 0x32, 0x66, 0x30, 0x34, 0x37, 0x35, 0x66, 0x61, 0x62, 0x39, 0x35, 0x61, 0x63, 0x35, 0x37, 0x63, 0x33, 0x63, 0x39, 0x64, 0x37, 0x63, 0x32, 0x36, 0x34, 0x39, 0x64, 0x33, 0x35, 0x35, 0x37, 0x35, 0x36, 0x31, 0x34, 0x30, 0x64, 0x35, 0x61, 0x31, 0x65, 0x38, 0x63, 0x36, 0x65, 0x61, 0x62, 0x38, 0x62, 0x36, 0x37, 0x61, 0x35, 0x63, 0x31, 0x36, 0x39, 0x63, 0x62, 0x38, 0x39, 0x39, 0x32, 0x33, 0x30, 0x63, 0x34, 0x62, 0x65, 0x31, 0x64, 0x63, 0x37, 0x30, 0x32, 0x33, 0x32, 0x33, 0x66, 0x32, 0x62, 0x30, 0x37, 0x65, 0x65, 0x31, 0x66, 0x63, 0x66, 0x35, 0x36, 0x35, 0x37, 0x33, 0x36, 0x31, 0x65, 0x32, 0x35, 0x30, 0x63, 0x63, 0x62, 0x65, 0x39, 0x33, 0x62, 0x62, 0x34, 0x30, 0x33, 0x61, 0x62, 0x64, 0x38, 0x35, 0x37, 0x65, 0x65, 0x65, 0x34, 0x33, 0x33, 0x35, 0x65, 0x34, 0x35, 0x34, 0x65, 0x38, 0x34, 0x38, 0x35, 0x61, 0x33, 0x62, 0x30, 0x35, 0x35, 0x63, 0x39, 0x30, 0x38, 0x63, 0x39, 0x35, 0x37, 0x64, 0x63, 0x61, 0x33, 0x66, 0x39, 0x61, 0x32, 0x38, 0x38, 0x32, 0x39, 0x39, 0x37, 0x32, 0x39, 0x32, 0x31, 0x36, 0x31, 0x30, 0x33, 0x30, 0x38, 0x39, 0x39, 0x31, 0x30, 0x33, 0x38, 0x36, 0x66, 0x62, 0x39, 0x39, 0x34, 0x32, 0x38, 0x35, 0x36, 0x30, 0x32, 0x63, 0x65, 0x31, 0x32, 0x62, 0x30, 0x34, 0x62, 0x65, 0x31, 0x38, 0x31, 0x39, 0x61, 0x32, 0x63, 0x38, 0x30, 0x33, 0x39, 0x34, 0x62, 0x32, 0x34, 0x31, 0x30, 0x37, 0x36, 0x37, 0x64, 0x39, 0x61, 0x61, 0x62, 0x64, 0x62, 0x35, 0x39, 0x31, 0x65, 0x34, 0x63, 0x34, 0x64, 0x63, 0x64, 0x30, 0x38, 0x64, 0x31, 0x64, 0x35, 0x62, 0x63, 0x31, 0x62, 0x63, 0x62, 0x35, 0x33, 0x32, 0x34, 0x39, 0x36, 0x66, 0x66, 0x31, 0x66, 0x63, 0x39, 0x36, 0x38, 0x61, 0x63, 0x33, 0x66, 0x66, 0x35, 0x39, 0x62, 0x63, 0x37, 0x32, 0x36, 0x36, 0x64, 0x38, 0x65, 0x63, 0x62, 0x62, 0x36, 0x37, 0x66, 0x33, 0x34, 0x62, 0x36, 0x38, 0x31, 0x33, 0x33, 0x31, 0x36, 0x38, 0x35, 0x61, 0x39, 0x39, 0x62, 0x37, 0x38, 0x31, 0x63, 0x39, 0x37, 0x35, 0x32, 0x64, 0x66, 0x65, 0x38, 0x33, 0x64, 0x31, 0x34, 0x35, 0x62, 0x64, 0x34, 0x66, 0x33, 0x63, 0x38, 0x65, 0x63, 0x36, 0x33, 0x34, 0x66, 0x30, 0x32, 0x38, 0x65, 0x38, 0x35, 0x30, 0x65, 0x32, 0x34, 0x36, 0x61, 0x61, 0x38, 0x31, 0x66, 0x31, 0x64, 0x30, 0x33, 0x61, 0x65, 0x66, 0x34, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x63, 0x66, 0x39, 0x30, 0x31, 0x30, 0x39, 0x62, 0x38, 0x35, 0x33, 0x66, 0x38, 0x35, 0x31, 0x61, 0x30, 0x62, 0x66, 0x33, 0x32, 0x62, 0x39, 0x30, 0x33, 0x37, 0x62, 0x36, 0x30, 0x30, 0x61, 0x61, 0x65, 0x33, 0x65, 0x63, 0x64, 0x33, 0x64, 0x64, 0x31, 0x38, 0x33, 0x38, 0x62, 0x63, 0x39, 0x66, 0x31, 0x38, 0x61, 0x65, 0x31, 0x36, 0x36, 0x31, 0x66, 0x36, 0x31, 0x35, 0x63, 0x66, 0x33, 0x64, 0x37, 0x30, 0x62, 0x63, 0x32, 0x37, 0x30, 0x62, 0x36, 0x63, 0x33, 0x31, 0x66, 0x35, 0x35, 0x66, 0x62, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x61, 0x30, 0x61, 0x32, 0x33, 0x38, 0x31, 0x39, 0x39, 0x31, 0x61, 0x66, 0x65, 0x61, 0x36, 0x34, 0x34, 0x65, 0x63, 0x65, 0x35, 0x63, 0x62, 0x61, 0x30, 0x64, 0x38, 0x64, 0x36, 0x39, 0x66, 0x38, 0x33, 0x38, 0x66, 0x37, 0x62, 0x31, 0x32, 0x33, 0x64, 0x32, 0x65, 0x30, 0x30, 0x35, 0x37, 0x61, 0x35, 0x34, 0x35, 0x30, 0x39, 0x65, 0x30, 0x63, 0x36, 0x31, 0x65, 0x38, 0x62, 0x32, 0x39, 0x33, 0x30, 0x32, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x62, 0x38, 0x62, 0x32, 0x66, 0x38, 0x62, 0x30, 0x33, 0x30, 0x62, 0x38, 0x61, 0x64, 0x66, 0x38, 0x61, 0x62, 0x38, 0x33, 0x30, 0x31, 0x65, 0x64, 0x62, 0x66, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x64, 0x30, 0x39, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x62, 0x38, 0x34, 0x34, 0x61, 0x30, 0x63, 0x61, 0x32, 0x64, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x36, 0x64, 0x36, 0x62, 0x31, 0x62, 0x36, 0x35, 0x35, 0x66, 0x36, 0x36, 0x63, 0x66, 0x38, 0x66, 0x39, 0x39, 0x64, 0x33, 0x35, 0x34, 0x33, 0x32, 0x34, 0x39, 0x32, 0x66, 0x38, 0x66, 0x62, 0x65, 0x64, 0x66, 0x61, 0x39, 0x37, 0x61, 0x32, 0x61, 0x34, 0x38, 0x66, 0x30, 0x65, 0x66, 0x61, 0x61, 0x65, 0x36, 0x35, 0x64, 0x65, 0x36, 0x37, 0x33, 0x38, 0x65, 0x32, 0x35, 0x39, 0x34, 0x61, 0x61, 0x35, 0x38, 0x33, 0x30, 0x35, 0x31, 0x38, 0x64, 0x63, 0x61, 0x30, 0x37, 0x39, 0x62, 0x65, 0x36, 0x36, 0x37, 0x65, 0x66, 0x39, 0x64, 0x63, 0x62, 0x62, 0x61, 0x63, 0x35, 0x35, 0x61, 0x30, 0x36, 0x32, 0x39, 0x35, 0x63, 0x65, 0x38, 0x37, 0x30, 0x62, 0x30, 0x37, 0x30, 0x32, 0x39, 0x62, 0x66, 0x63, 0x64, 0x62, 0x32, 0x64, 0x63, 0x65, 0x32, 0x38, 0x64, 0x39, 0x35, 0x39, 0x66, 0x32, 0x38, 0x31, 0x35, 0x62, 0x31, 0x36, 0x66, 0x38, 0x31, 0x37, 0x39, 0x38, 0x61, 0x30, 0x35, 0x66, 0x33, 0x62, 0x34, 0x31, 0x65, 0x39, 0x37, 0x35, 0x62, 0x34, 0x36, 0x65, 0x38, 0x36, 0x64, 0x35, 0x33, 0x36, 0x35, 0x39, 0x34, 0x33, 0x63, 0x66, 0x65, 0x32, 0x35, 0x61, 0x65, 0x39, 0x36, 0x30, 0x66, 0x63, 0x32, 0x63, 0x37, 0x63, 0x31, 0x62, 0x62, 0x34, 0x65, 0x62, 0x30, 0x30, 0x32, 0x35, 0x65, 0x61, 0x63, 0x35, 0x65, 0x62, 0x30, 0x62, 0x63, 0x36, 0x36, 0x33, 0x39, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x62, 0x66, 0x39, 0x30, 0x31, 0x65, 0x38, 0x62, 0x38, 0x35, 0x33, 0x66, 0x38, 0x35, 0x31, 0x61, 0x30, 0x35, 0x32, 0x39, 0x66, 0x32, 0x64, 0x38, 0x39, 0x32, 0x35, 0x36, 0x66, 0x63, 0x30, 0x33, 0x38, 0x37, 0x38, 0x32, 0x61, 0x34, 0x64, 0x37, 0x30, 0x62, 0x34, 0x30, 0x62, 0x66, 0x31, 0x32, 0x37, 0x64, 0x65, 0x39, 0x30, 0x36, 0x63, 0x62, 0x65, 0x32, 0x31, 0x31, 0x65, 0x37, 0x61, 0x63, 0x61, 0x61, 0x33, 0x65, 0x39, 0x32, 0x38, 0x65, 0x30, 0x66, 0x64, 0x35, 0x63, 0x66, 0x31, 0x31, 0x64, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x61, 0x30, 0x62, 0x34, 0x66, 0x34, 0x64, 0x30, 0x62, 0x65, 0x30, 0x31, 0x63, 0x36, 0x35, 0x64, 0x61, 0x35, 0x33, 0x30, 0x38, 0x62, 0x61, 0x62, 0x34, 0x31, 0x64, 0x35, 0x32, 0x64, 0x38, 0x61, 0x37, 0x63, 0x39, 0x33, 0x61, 0x31, 0x36, 0x39, 0x33, 0x63, 0x31, 0x37, 0x30, 0x63, 0x34, 0x34, 0x64, 0x31, 0x66, 0x36, 0x31, 0x39, 0x62, 0x38, 0x33, 0x36, 0x34, 0x64, 0x34, 0x30, 0x65, 0x33, 0x34, 0x32, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x62, 0x39, 0x30, 0x31, 0x39, 0x30, 0x66, 0x39, 0x30, 0x31, 0x38, 0x64, 0x33, 0x30, 0x62, 0x39, 0x30, 0x31, 0x38, 0x39, 0x66, 0x39, 0x30, 0x31, 0x38, 0x36, 0x30, 0x31, 0x38, 0x33, 0x30, 0x33, 0x39, 0x34, 0x34, 0x35, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x37, 0x63, 0x66, 0x38, 0x37, 0x61, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x38, 0x34, 0x32, 0x61, 0x30, 0x35, 0x38, 0x33, 0x31, 0x33, 0x62, 0x36, 0x30, 0x65, 0x63, 0x36, 0x63, 0x35, 0x62, 0x66, 0x63, 0x33, 0x38, 0x31, 0x65, 0x35, 0x32, 0x66, 0x30, 0x64, 0x65, 0x33, 0x65, 0x64, 0x65, 0x30, 0x66, 0x61, 0x61, 0x63, 0x33, 0x63, 0x64, 0x66, 0x66, 0x65, 0x61, 0x32, 0x36, 0x66, 0x37, 0x64, 0x36, 0x62, 0x63, 0x63, 0x33, 0x64, 0x30, 0x39, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x39, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x36, 0x61, 0x30, 0x64, 0x36, 0x62, 0x31, 0x62, 0x36, 0x35, 0x35, 0x66, 0x36, 0x36, 0x63, 0x66, 0x38, 0x66, 0x39, 0x39, 0x64, 0x33, 0x35, 0x34, 0x33, 0x32, 0x34, 0x39, 0x32, 0x66, 0x38, 0x66, 0x62, 0x65, 0x64, 0x66, 0x61, 0x39, 0x37, 0x61, 0x32, 0x61, 0x34, 0x38, 0x66, 0x30, 0x65, 0x66, 0x61, 0x61, 0x65, 0x36, 0x35, 0x64, 0x65, 0x36, 0x37, 0x33, 0x38, 0x65, 0x32, 0x35, 0x39, 0x34, 0x61, 0x61, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x66, 0x38, 0x61, 0x62, 0x38, 0x33, 0x30, 0x31, 0x65, 0x64, 0x62, 0x66, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x64, 0x30, 0x39, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x62, 0x38, 0x34, 0x34, 0x61, 0x30, 0x63, 0x61, 0x32, 0x64, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x36, 0x64, 0x36, 0x62, 0x31, 0x62, 0x36, 0x35, 0x35, 0x66, 0x36, 0x36, 0x63, 0x66, 0x38, 0x66, 0x39, 0x39, 0x64, 0x33, 0x35, 0x34, 0x33, 0x32, 0x34, 0x39, 0x32, 0x66, 0x38, 0x66, 0x62, 0x65, 0x64, 0x66, 0x61, 0x39, 0x37, 0x61, 0x32, 0x61, 0x34, 0x38, 0x66, 0x30, 0x65, 0x66, 0x61, 0x61, 0x65, 0x36, 0x35, 0x64, 0x65, 0x36, 0x37, 0x33, 0x38, 0x65, 0x32, 0x35, 0x39, 0x34, 0x61, 0x61, 0x35, 0x38, 0x33, 0x30, 0x35, 0x31, 0x38, 0x64, 0x63, 0x61, 0x30, 0x37, 0x39, 0x62, 0x65, 0x36, 0x36, 0x37, 0x65, 0x66, 0x39, 0x64, 0x63, 0x62, 0x62, 0x61, 0x63, 0x35, 0x35, 0x61, 0x30, 0x36, 0x32, 0x39, 0x35, 0x63, 0x65, 0x38, 0x37, 0x30, 0x62, 0x30, 0x37, 0x30, 0x32, 0x39, 0x62, 0x66, 0x63, 0x64, 0x62, 0x32, 0x64, 0x63, 0x65, 0x32, 0x38, 0x64, 0x39, 0x35, 0x39, 0x66, 0x32, 0x38, 0x31, 0x35, 0x62, 0x31, 0x36, 0x66, 0x38, 0x31, 0x37, 0x39, 0x38, 0x61, 0x30, 0x35, 0x66, 0x33, 0x62, 0x34, 0x31, 0x65, 0x39, 0x37, 0x35, 0x62, 0x34, 0x36, 0x65, 0x38, 0x36, 0x64, 0x35, 0x33, 0x36, 0x35, 0x39, 0x34, 0x33, 0x63, 0x66, 0x65, 0x32, 0x35, 0x61, 0x65, 0x39, 0x36, 0x30, 0x66, 0x63, 0x32, 0x63, 0x37, 0x63, 0x31, 0x62, 0x62, 0x34, 0x65, 0x62, 0x30, 0x30, 0x32, 0x35, 0x65, 0x61, 0x63, 0x35, 0x65, 0x62, 0x30, 0x62, 0x63, 0x36, 0x36, 0x33, 0x39, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x39, 0x66, 0x39, 0x30, 0x31, 0x38, 0x36, 0x30, 0x31, 0x38, 0x33, 0x30, 0x33, 0x39, 0x34, 0x34, 0x35, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x37, 0x63, 0x66, 0x38, 0x37, 0x61, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x38, 0x34, 0x32, 0x61, 0x30, 0x35, 0x38, 0x33, 0x31, 0x33, 0x62, 0x36, 0x30, 0x65, 0x63, 0x36, 0x63, 0x35, 0x62, 0x66, 0x63, 0x33, 0x38, 0x31, 0x65, 0x35, 0x32, 0x66, 0x30, 0x64, 0x65, 0x33, 0x65, 0x64, 0x65, 0x30, 0x66, 0x61, 0x61, 0x63, 0x33, 0x63, 0x64, 0x66, 0x66, 0x65, 0x61, 0x32, 0x36, 0x66, 0x37, 0x64, 0x36, 0x62, 0x63, 0x63, 0x33, 0x64, 0x30, 0x39, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x39, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x36, 0x61, 0x30, 0x64, 0x36, 0x62, 0x31, 0x62, 0x36, 0x35, 0x35, 0x66, 0x36, 0x36, 0x63, 0x66, 0x38, 0x66, 0x39, 0x39, 0x64, 0x33, 0x35, 0x34, 0x33, 0x32, 0x34, 0x39, 0x32, 0x66, 0x38, 0x66, 0x62, 0x65, 0x64, 0x66, 0x61, 0x39, 0x37, 0x61, 0x32, 0x61, 0x34, 0x38, 0x66, 0x30, 0x65, 0x66, 0x61, 0x61, 0x65, 0x36, 0x35, 0x64, 0x65, 0x36, 0x37, 0x33, 0x38, 0x65, 0x32, 0x35, 0x39, 0x34, 0x61, 0x61, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x61, 0x65, 0x35, 0x65, 0x36, 0x37, 0x36, 0x37, 0x33, 0x62, 0x39, 0x30, 0x66, 0x32, 0x64, 0x36, 0x38, 0x30, 0x32, 0x65, 0x38, 0x64, 0x62, 0x61, 0x32, 0x36, 0x61, 0x61, 0x64, 0x62, 0x32, 0x65, 0x38, 0x62, 0x38, 0x31, 0x65, 0x30, 0x35, 0x39, 0x64, 0x31, 0x36, 0x31, 0x31, 0x61, 0x66, 0x64, 0x31, 0x39, 0x30, 0x38, 0x65, 0x37, 0x34, 0x33, 0x65, 0x33, 0x63, 0x30, 0x62, 0x37, 0x35, 0x64, 0x61, 0x30, 0x30, 0x34, 0x38, 0x38, 0x36, 0x62, 0x30, 0x61, 0x63, 0x33, 0x61, 0x38, 0x31, 0x30, 0x35, 0x31, 0x39, 0x61, 0x61, 0x32, 0x33, 0x39, 0x35, 0x62, 0x66, 0x66, 0x64, 0x64, 0x39, 0x34, 0x66, 0x62, 0x63, 0x66, 0x65, 0x34, 0x61, 0x32, 0x64, 0x65, 0x39, 0x38, 0x39, 0x65, 0x63, 0x39, 0x35, 0x64, 0x31, 0x61, 0x65, 0x61, 0x30, 0x66, 0x63, 0x64, 0x30, 0x39, 0x61, 0x66, 0x64, 0x39, 0x33, 0x31, 0x62, 0x39, 0x32, 0x33, 0x35, 0x33, 0x30, 0x32, 0x66, 0x39, 0x32, 0x33, 0x34, 0x66, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x33, 0x30, 0x31, 0x33, 0x37, 0x64, 0x36, 0x36, 0x34, 0x37, 0x34, 0x38, 0x33, 0x31, 0x35, 0x66, 0x34, 0x32, 0x35, 0x39, 0x34, 0x61, 0x63, 0x39, 0x32, 0x35, 0x31, 0x65, 0x65, 0x39, 0x37, 0x65, 0x64, 0x38, 0x62, 0x65, 0x66, 0x33, 0x31, 0x37, 0x30, 0x36, 0x33, 0x35, 0x34, 0x33, 0x31, 0x30, 0x63, 0x36, 0x62, 0x30, 0x32, 0x30, 0x63, 0x33, 0x35, 0x64, 0x38, 0x37, 0x62, 0x38, 0x30, 0x62, 0x39, 0x32, 0x32, 0x65, 0x34, 0x38, 0x65, 0x64, 0x37, 0x62, 0x33, 0x62, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x64, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x64, 0x36, 0x39, 0x33, 0x39, 0x34, 0x62, 0x64, 0x37, 0x31, 0x39, 0x30, 0x36, 0x61, 0x32, 0x33, 0x35, 0x66, 0x39, 0x31, 0x31, 0x33, 0x63, 0x63, 0x30, 0x34, 0x33, 0x32, 0x31, 0x66, 0x35, 0x37, 0x33, 0x39, 0x35, 0x38, 0x64, 0x33, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x64, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x37, 0x64, 0x62, 0x66, 0x62, 0x66, 0x32, 0x63, 0x35, 0x33, 0x35, 0x66, 0x66, 0x63, 0x35, 0x32, 0x31, 0x31, 0x37, 0x64, 0x34, 0x63, 0x63, 0x36, 0x31, 0x36, 0x62, 0x38, 0x64, 0x39, 0x37, 0x62, 0x64, 0x30, 0x37, 0x63, 0x64, 0x64, 0x38, 0x35, 0x38, 0x35, 0x61, 0x62, 0x36, 0x37, 0x64, 0x39, 0x30, 0x39, 0x35, 0x63, 0x30, 0x36, 0x37, 0x65, 0x39, 0x64, 0x65, 0x36, 0x64, 0x36, 0x37, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x32, 0x66, 0x32, 0x30, 0x64, 0x35, 0x62, 0x61, 0x32, 0x30, 0x61, 0x30, 0x39, 0x65, 0x31, 0x38, 0x35, 0x64, 0x34, 0x35, 0x32, 0x63, 0x39, 0x39, 0x39, 0x63, 0x31, 0x32, 0x39, 0x64, 0x37, 0x31, 0x32, 0x62, 0x38, 0x33, 0x63, 0x37, 0x35, 0x34, 0x38, 0x30, 0x65, 0x32, 0x65, 0x30, 0x32, 0x39, 0x66, 0x63, 0x38, 0x39, 0x35, 0x39, 0x38, 0x36, 0x64, 0x33, 0x36, 0x31, 0x61, 0x37, 0x38, 0x31, 0x62, 0x32, 0x30, 0x34, 0x35, 0x62, 0x38, 0x62, 0x35, 0x32, 0x32, 0x36, 0x66, 0x39, 0x63, 0x31, 0x66, 0x64, 0x37, 0x31, 0x32, 0x64, 0x38, 0x62, 0x31, 0x61, 0x35, 0x66, 0x31, 0x66, 0x61, 0x63, 0x61, 0x38, 0x34, 0x66, 0x35, 0x66, 0x63, 0x65, 0x65, 0x38, 0x37, 0x61, 0x37, 0x64, 0x31, 0x64, 0x64, 0x32, 0x62, 0x35, 0x37, 0x66, 0x35, 0x35, 0x36, 0x31, 0x37, 0x64, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x39, 0x34, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x36, 0x66, 0x38, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x36, 0x35, 0x38, 0x32, 0x32, 0x31, 0x30, 0x37, 0x66, 0x63, 0x66, 0x64, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x62, 0x65, 0x32, 0x30, 0x65, 0x65, 0x64, 0x63, 0x63, 0x30, 0x32, 0x31, 0x36, 0x63, 0x36, 0x31, 0x35, 0x64, 0x33, 0x61, 0x30, 0x35, 0x35, 0x30, 0x61, 0x35, 0x35, 0x30, 0x37, 0x62, 0x64, 0x62, 0x32, 0x66, 0x39, 0x39, 0x31, 0x32, 0x65, 0x62, 0x61, 0x37, 0x62, 0x36, 0x30, 0x38, 0x33, 0x30, 0x30, 0x34, 0x38, 0x36, 0x65, 0x38, 0x37, 0x31, 0x61, 0x34, 0x65, 0x34, 0x32, 0x34, 0x39, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x38, 0x35, 0x32, 0x61, 0x62, 0x38, 0x31, 0x64, 0x32, 0x33, 0x36, 0x66, 0x33, 0x35, 0x63, 0x33, 0x39, 0x36, 0x64, 0x34, 0x38, 0x33, 0x36, 0x61, 0x36, 0x66, 0x38, 0x32, 0x32, 0x33, 0x39, 0x66, 0x35, 0x36, 0x37, 0x32, 0x61, 0x34, 0x62, 0x36, 0x31, 0x33, 0x36, 0x61, 0x62, 0x39, 0x65, 0x62, 0x64, 0x64, 0x38, 0x36, 0x36, 0x39, 0x61, 0x39, 0x66, 0x39, 0x65, 0x38, 0x33, 0x31, 0x62, 0x38, 0x37, 0x61, 0x32, 0x36, 0x39, 0x34, 0x34, 0x65, 0x35, 0x63, 0x30, 0x34, 0x66, 0x31, 0x36, 0x62, 0x37, 0x39, 0x34, 0x32, 0x36, 0x31, 0x33, 0x35, 0x61, 0x63, 0x31, 0x31, 0x62, 0x31, 0x35, 0x35, 0x39, 0x32, 0x32, 0x63, 0x31, 0x34, 0x31, 0x37, 0x38, 0x62, 0x66, 0x33, 0x64, 0x31, 0x65, 0x63, 0x62, 0x62, 0x31, 0x66, 0x62, 0x31, 0x32, 0x63, 0x63, 0x63, 0x38, 0x31, 0x31, 0x39, 0x61, 0x32, 0x32, 0x64, 0x66, 0x35, 0x30, 0x30, 0x33, 0x64, 0x65, 0x32, 0x64, 0x35, 0x39, 0x35, 0x36, 0x63, 0x37, 0x34, 0x35, 0x66, 0x39, 0x65, 0x38, 0x32, 0x35, 0x61, 0x38, 0x66, 0x30, 0x63, 0x61, 0x31, 0x62, 0x62, 0x31, 0x65, 0x32, 0x36, 0x35, 0x64, 0x34, 0x64, 0x34, 0x33, 0x31, 0x37, 0x38, 0x31, 0x62, 0x30, 0x30, 0x37, 0x36, 0x35, 0x65, 0x30, 0x66, 0x65, 0x33, 0x37, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x63, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x30, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x32, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x64, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x36, 0x34, 0x65, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x35, 0x36, 0x65, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x33, 0x36, 0x66, 0x38, 0x65, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x30, 0x37, 0x38, 0x31, 0x62, 0x32, 0x30, 0x34, 0x35, 0x62, 0x38, 0x62, 0x35, 0x32, 0x32, 0x36, 0x66, 0x39, 0x63, 0x31, 0x66, 0x64, 0x37, 0x31, 0x32, 0x64, 0x38, 0x62, 0x31, 0x61, 0x35, 0x66, 0x31, 0x66, 0x61, 0x63, 0x61, 0x38, 0x34, 0x66, 0x35, 0x66, 0x63, 0x65, 0x65, 0x38, 0x37, 0x61, 0x37, 0x64, 0x31, 0x64, 0x64, 0x32, 0x62, 0x35, 0x37, 0x66, 0x35, 0x35, 0x36, 0x31, 0x37, 0x64, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x32, 0x30, 0x32, 0x62, 0x66, 0x32, 0x30, 0x66, 0x66, 0x37, 0x38, 0x37, 0x32, 0x37, 0x66, 0x33, 0x38, 0x65, 0x66, 0x31, 0x36, 0x65, 0x30, 0x33, 0x62, 0x66, 0x62, 0x33, 0x64, 0x34, 0x38, 0x39, 0x35, 0x66, 0x33, 0x35, 0x63, 0x63, 0x36, 0x32, 0x36, 0x66, 0x39, 0x37, 0x65, 0x64, 0x65, 0x37, 0x63, 0x63, 0x39, 0x39, 0x66, 0x34, 0x38, 0x61, 0x65, 0x66, 0x66, 0x38, 0x36, 0x36, 0x31, 0x66, 0x65, 0x33, 0x32, 0x30, 0x31, 0x35, 0x65, 0x61, 0x38, 0x64, 0x36, 0x32, 0x65, 0x63, 0x37, 0x61, 0x37, 0x39, 0x65, 0x30, 0x31, 0x63, 0x64, 0x33, 0x39, 0x38, 0x65, 0x38, 0x35, 0x38, 0x36, 0x37, 0x62, 0x61, 0x66, 0x64, 0x63, 0x66, 0x35, 0x35, 0x63, 0x62, 0x36, 0x61, 0x37, 0x31, 0x32, 0x31, 0x62, 0x36, 0x66, 0x65, 0x66, 0x30, 0x39, 0x37, 0x66, 0x35, 0x66, 0x35, 0x36, 0x35, 0x36, 0x61, 0x35, 0x64, 0x31, 0x31, 0x64, 0x64, 0x66, 0x33, 0x33, 0x36, 0x62, 0x36, 0x38, 0x37, 0x39, 0x39, 0x32, 0x36, 0x65, 0x61, 0x32, 0x61, 0x65, 0x34, 0x32, 0x35, 0x65, 0x39, 0x31, 0x63, 0x37, 0x34, 0x38, 0x61, 0x35, 0x35, 0x33, 0x63, 0x39, 0x61, 0x34, 0x39, 0x36, 0x63, 0x62, 0x65, 0x32, 0x61, 0x62, 0x35, 0x35, 0x36, 0x61, 0x39, 0x31, 0x36, 0x38, 0x39, 0x66, 0x37, 0x35, 0x65, 0x65, 0x32, 0x62, 0x30, 0x31, 0x61, 0x64, 0x33, 0x63, 0x34, 0x33, 0x61, 0x61, 0x37, 0x37, 0x34, 0x62, 0x35, 0x30, 0x61, 0x39, 0x64, 0x38, 0x34, 0x31, 0x31, 0x61, 0x39, 0x66, 0x36, 0x35, 0x62, 0x65, 0x34, 0x32, 0x64, 0x36, 0x63, 0x64, 0x65, 0x37, 0x38, 0x31, 0x64, 0x62, 0x31, 0x61, 0x31, 0x39, 0x34, 0x39, 0x61, 0x31, 0x65, 0x38, 0x38, 0x36, 0x66, 0x38, 0x36, 0x38, 0x39, 0x31, 0x37, 0x39, 0x39, 0x37, 0x62, 0x32, 0x31, 0x61, 0x64, 0x30, 0x35, 0x62, 0x37, 0x63, 0x31, 0x65, 0x62, 0x30, 0x64, 0x32, 0x30, 0x38, 0x64, 0x31, 0x37, 0x34, 0x32, 0x36, 0x63, 0x35, 0x32, 0x38, 0x33, 0x31, 0x63, 0x36, 0x33, 0x34, 0x37, 0x61, 0x38, 0x64, 0x62, 0x37, 0x35, 0x62, 0x31, 0x32, 0x62, 0x66, 0x65, 0x62, 0x32, 0x39, 0x37, 0x30, 0x63, 0x34, 0x64, 0x63, 0x36, 0x36, 0x36, 0x36, 0x65, 0x34, 0x65, 0x62, 0x61, 0x30, 0x34, 0x39, 0x32, 0x64, 0x32, 0x65, 0x63, 0x33, 0x31, 0x38, 0x30, 0x38, 0x39, 0x62, 0x31, 0x31, 0x65, 0x65, 0x37, 0x65, 0x63, 0x36, 0x30, 0x38, 0x37, 0x61, 0x62, 0x36, 0x61, 0x33, 0x64, 0x66, 0x33, 0x33, 0x35, 0x37, 0x37, 0x30, 0x35, 0x32, 0x36, 0x63, 0x63, 0x30, 0x63, 0x31, 0x36, 0x37, 0x39, 0x62, 0x37, 0x36, 0x34, 0x64, 0x38, 0x34, 0x37, 0x62, 0x34, 0x65, 0x63, 0x31, 0x65, 0x33, 0x30, 0x33, 0x64, 0x34, 0x30, 0x30, 0x63, 0x31, 0x32, 0x65, 0x36, 0x39, 0x30, 0x61, 0x61, 0x32, 0x36, 0x61, 0x33, 0x37, 0x37, 0x31, 0x65, 0x35, 0x36, 0x37, 0x36, 0x65, 0x37, 0x61, 0x63, 0x39, 0x35, 0x65, 0x32, 0x64, 0x63, 0x37, 0x61, 0x31, 0x62, 0x33, 0x33, 0x62, 0x65, 0x36, 0x39, 0x38, 0x66, 0x30, 0x37, 0x37, 0x63, 0x35, 0x39, 0x38, 0x66, 0x38, 0x38, 0x30, 0x64, 0x34, 0x32, 0x30, 0x33, 0x64, 0x65, 0x66, 0x61, 0x32, 0x36, 0x61, 0x64, 0x33, 0x36, 0x62, 0x38, 0x34, 0x35, 0x37, 0x33, 0x65, 0x39, 0x32, 0x33, 0x61, 0x66, 0x33, 0x34, 0x37, 0x34, 0x37, 0x35, 0x63, 0x37, 0x63, 0x37, 0x36, 0x37, 0x31, 0x62, 0x65, 0x32, 0x34, 0x35, 0x65, 0x39, 0x38, 0x35, 0x39, 0x63, 0x61, 0x31, 0x64, 0x62, 0x33, 0x63, 0x30, 0x34, 0x37, 0x66, 0x61, 0x65, 0x65, 0x65, 0x34, 0x62, 0x31, 0x63, 0x30, 0x65, 0x38, 0x31, 0x64, 0x38, 0x61, 0x39, 0x32, 0x39, 0x31, 0x35, 0x63, 0x32, 0x62, 0x39, 0x34, 0x66, 0x66, 0x33, 0x30, 0x30, 0x65, 0x31, 0x38, 0x66, 0x37, 0x37, 0x66, 0x37, 0x30, 0x66, 0x66, 0x65, 0x63, 0x31, 0x35, 0x36, 0x33, 0x31, 0x31, 0x36, 0x31, 0x65, 0x30, 0x62, 0x63, 0x33, 0x63, 0x64, 0x63, 0x39, 0x31, 0x34, 0x33, 0x63, 0x34, 0x33, 0x34, 0x32, 0x32, 0x63, 0x32, 0x30, 0x38, 0x31, 0x38, 0x37, 0x36, 0x35, 0x32, 0x63, 0x31, 0x65, 0x63, 0x38, 0x33, 0x63, 0x35, 0x64, 0x32, 0x38, 0x32, 0x65, 0x31, 0x30, 0x35, 0x38, 0x37, 0x32, 0x31, 0x36, 0x65, 0x61, 0x66, 0x35, 0x36, 0x36, 0x38, 0x39, 0x65, 0x35, 0x66, 0x65, 0x32, 0x33, 0x36, 0x66, 0x37, 0x32, 0x63, 0x31, 0x33, 0x65, 0x62, 0x39, 0x35, 0x37, 0x34, 0x61, 0x66, 0x61, 0x62, 0x63, 0x36, 0x32, 0x32, 0x61, 0x37, 0x33, 0x39, 0x63, 0x65, 0x66, 0x62, 0x62, 0x65, 0x31, 0x31, 0x61, 0x61, 0x61, 0x34, 0x65, 0x32, 0x65, 0x33, 0x64, 0x34, 0x63, 0x35, 0x34, 0x31, 0x35, 0x38, 0x31, 0x38, 0x39, 0x31, 0x34, 0x66, 0x65, 0x35, 0x35, 0x34, 0x61, 0x30, 0x37, 0x62, 0x65, 0x33, 0x37, 0x34, 0x66, 0x35, 0x36, 0x35, 0x64, 0x39, 0x62, 0x63, 0x65, 0x62, 0x63, 0x30, 0x31, 0x33, 0x34, 0x39, 0x34, 0x30, 0x65, 0x38, 0x39, 0x32, 0x31, 0x62, 0x38, 0x37, 0x62, 0x64, 0x34, 0x66, 0x36, 0x62, 0x34, 0x32, 0x61, 0x36, 0x34, 0x33, 0x32, 0x65, 0x36, 0x65, 0x31, 0x37, 0x36, 0x62, 0x65, 0x35, 0x65, 0x63, 0x38, 0x32, 0x62, 0x62, 0x38, 0x65, 0x62, 0x36, 0x62, 0x64, 0x62, 0x37, 0x65, 0x34, 0x61, 0x63, 0x63, 0x31, 0x66, 0x31, 0x65, 0x39, 0x39, 0x37, 0x32, 0x35, 0x62, 0x64, 0x33, 0x61, 0x62, 0x32, 0x65, 0x33, 0x66, 0x61, 0x35, 0x32, 0x65, 0x30, 0x32, 0x63, 0x32, 0x37, 0x34, 0x31, 0x64, 0x66, 0x65, 0x36, 0x65, 0x64, 0x64, 0x66, 0x35, 0x61, 0x33, 0x38, 0x34, 0x36, 0x64, 0x66, 0x64, 0x35, 0x37, 0x66, 0x36, 0x61, 0x37, 0x32, 0x65, 0x38, 0x33, 0x34, 0x66, 0x61, 0x61, 0x30, 0x34, 0x38, 0x63, 0x62, 0x30, 0x30, 0x37, 0x38, 0x32, 0x36, 0x61, 0x32, 0x39, 0x33, 0x64, 0x39, 0x65, 0x31, 0x36, 0x33, 0x64, 0x34, 0x37, 0x66, 0x39, 0x65, 0x61, 0x36, 0x33, 0x35, 0x38, 0x37, 0x31, 0x62, 0x32, 0x35, 0x61, 0x66, 0x63, 0x63, 0x33, 0x35, 0x36, 0x31, 0x64, 0x66, 0x63, 0x65, 0x37, 0x37, 0x62, 0x33, 0x61, 0x32, 0x36, 0x30, 0x34, 0x62, 0x33, 0x63, 0x38, 0x64, 0x65, 0x39, 0x30, 0x61, 0x61, 0x32, 0x34, 0x39, 0x31, 0x36, 0x66, 0x34, 0x31, 0x61, 0x65, 0x64, 0x36, 0x32, 0x64, 0x32, 0x65, 0x30, 0x63, 0x30, 0x64, 0x31, 0x38, 0x66, 0x39, 0x63, 0x32, 0x35, 0x39, 0x62, 0x66, 0x36, 0x31, 0x34, 0x66, 0x31, 0x33, 0x32, 0x31, 0x63, 0x35, 0x62, 0x37, 0x63, 0x66, 0x37, 0x62, 0x35, 0x62, 0x64, 0x37, 0x33, 0x63, 0x65, 0x63, 0x34, 0x30, 0x38, 0x64, 0x64, 0x38, 0x35, 0x66, 0x30, 0x34, 0x36, 0x62, 0x66, 0x33, 0x36, 0x33, 0x30, 0x32, 0x65, 0x32, 0x30, 0x66, 0x33, 0x36, 0x30, 0x33, 0x62, 0x37, 0x38, 0x33, 0x32, 0x30, 0x37, 0x31, 0x37, 0x39, 0x36, 0x30, 0x32, 0x32, 0x65, 0x38, 0x39, 0x33, 0x33, 0x38, 0x36, 0x64, 0x65, 0x34, 0x65, 0x33, 0x62, 0x31, 0x37, 0x30, 0x31, 0x33, 0x35, 0x61, 0x35, 0x39, 0x31, 0x62, 0x31, 0x61, 0x34, 0x34, 0x31, 0x31, 0x37, 0x32, 0x34, 0x30, 0x62, 0x61, 0x38, 0x35, 0x38, 0x37, 0x36, 0x64, 0x62, 0x61, 0x35, 0x38, 0x36, 0x62, 0x31, 0x66, 0x33, 0x31, 0x63, 0x31, 0x33, 0x64, 0x31, 0x31, 0x62, 0x39, 0x34, 0x66, 0x38, 0x39, 0x32, 0x62, 0x62, 0x39, 0x66, 0x39, 0x36, 0x62, 0x64, 0x32, 0x39, 0x33, 0x31, 0x62, 0x36, 0x36, 0x66, 0x66, 0x61, 0x35, 0x65, 0x32, 0x32, 0x62, 0x31, 0x30, 0x34, 0x63, 0x35, 0x34, 0x39, 0x65, 0x37, 0x63, 0x30, 0x64, 0x35, 0x30, 0x31, 0x30, 0x65, 0x34, 0x65, 0x37, 0x30, 0x65, 0x32, 0x37, 0x31, 0x64, 0x34, 0x38, 0x63, 0x30, 0x62, 0x64, 0x36, 0x65, 0x34, 0x62, 0x65, 0x36, 0x38, 0x63, 0x39, 0x32, 0x30, 0x65, 0x61, 0x37, 0x37, 0x61, 0x66, 0x38, 0x35, 0x64, 0x31, 0x32, 0x65, 0x62, 0x31, 0x35, 0x35, 0x64, 0x39, 0x62, 0x32, 0x35, 0x37, 0x30, 0x33, 0x65, 0x61, 0x62, 0x62, 0x64, 0x30, 0x65, 0x64, 0x65, 0x31, 0x39, 0x30, 0x39, 0x35, 0x36, 0x35, 0x61, 0x35, 0x35, 0x66, 0x31, 0x32, 0x66, 0x37, 0x65, 0x33, 0x30, 0x65, 0x37, 0x34, 0x62, 0x30, 0x33, 0x32, 0x39, 0x32, 0x32, 0x32, 0x66, 0x36, 0x30, 0x36, 0x37, 0x63, 0x61, 0x64, 0x33, 0x62, 0x34, 0x33, 0x32, 0x34, 0x61, 0x38, 0x30, 0x66, 0x35, 0x37, 0x30, 0x35, 0x30, 0x36, 0x39, 0x38, 0x35, 0x64, 0x37, 0x32, 0x39, 0x66, 0x37, 0x37, 0x38, 0x30, 0x39, 0x35, 0x35, 0x33, 0x33, 0x33, 0x66, 0x34, 0x30, 0x65, 0x36, 0x31, 0x35, 0x66, 0x30, 0x36, 0x35, 0x30, 0x32, 0x33, 0x66, 0x62, 0x36, 0x30, 0x37, 0x64, 0x39, 0x37, 0x35, 0x64, 0x37, 0x61, 0x32, 0x62, 0x39, 0x66, 0x32, 0x33, 0x34, 0x31, 0x33, 0x37, 0x65, 0x37, 0x32, 0x32, 0x36, 0x30, 0x64, 0x38, 0x66, 0x36, 0x62, 0x35, 0x38, 0x36, 0x62, 0x61, 0x65, 0x63, 0x66, 0x34, 0x32, 0x38, 0x31, 0x39, 0x66, 0x38, 0x33, 0x32, 0x38, 0x64, 0x66, 0x62, 0x33, 0x33, 0x30, 0x34, 0x34, 0x34, 0x31, 0x66, 0x32, 0x63, 0x39, 0x65, 0x39, 0x37, 0x64, 0x31, 0x66, 0x61, 0x62, 0x39, 0x61, 0x33, 0x36, 0x32, 0x35, 0x30, 0x37, 0x33, 0x61, 0x63, 0x33, 0x64, 0x32, 0x62, 0x66, 0x66, 0x36, 0x62, 0x61, 0x32, 0x66, 0x38, 0x64, 0x36, 0x35, 0x39, 0x63, 0x62, 0x63, 0x36, 0x66, 0x36, 0x36, 0x65, 0x38, 0x64, 0x39, 0x61, 0x66, 0x64, 0x65, 0x31, 0x65, 0x66, 0x32, 0x32, 0x39, 0x66, 0x66, 0x33, 0x39, 0x62, 0x61, 0x63, 0x31, 0x65, 0x63, 0x64, 0x36, 0x35, 0x65, 0x64, 0x64, 0x63, 0x34, 0x39, 0x35, 0x33, 0x65, 0x32, 0x37, 0x32, 0x36, 0x61, 0x37, 0x32, 0x64, 0x61, 0x65, 0x66, 0x61, 0x37, 0x36, 0x66, 0x30, 0x30, 0x64, 0x35, 0x38, 0x65, 0x31, 0x31, 0x63, 0x39, 0x61, 0x39, 0x62, 0x61, 0x33, 0x34, 0x34, 0x38, 0x66, 0x62, 0x65, 0x30, 0x64, 0x33, 0x61, 0x30, 0x33, 0x64, 0x62, 0x37, 0x38, 0x64, 0x37, 0x30, 0x65, 0x64, 0x39, 0x63, 0x35, 0x37, 0x34, 0x64, 0x64, 0x63, 0x34, 0x35, 0x64, 0x65, 0x35, 0x63, 0x37, 0x33, 0x65, 0x66, 0x64, 0x66, 0x33, 0x31, 0x31, 0x33, 0x65, 0x65, 0x37, 0x30, 0x61, 0x34, 0x62, 0x34, 0x32, 0x63, 0x65, 0x61, 0x39, 0x38, 0x38, 0x34, 0x66, 0x38, 0x35, 0x63, 0x31, 0x62, 0x39, 0x39, 0x35, 0x35, 0x31, 0x36, 0x39, 0x31, 0x32, 0x38, 0x30, 0x30, 0x61, 0x62, 0x65, 0x62, 0x37, 0x30, 0x66, 0x33, 0x30, 0x32, 0x32, 0x64, 0x35, 0x64, 0x65, 0x36, 0x64, 0x39, 0x66, 0x34, 0x39, 0x34, 0x36, 0x39, 0x31, 0x36, 0x31, 0x61, 0x33, 0x36, 0x61, 0x36, 0x61, 0x33, 0x30, 0x39, 0x30, 0x39, 0x39, 0x63, 0x61, 0x34, 0x33, 0x65, 0x33, 0x38, 0x38, 0x39, 0x30, 0x38, 0x36, 0x33, 0x35, 0x65, 0x64, 0x34, 0x61, 0x65, 0x38, 0x32, 0x35, 0x61, 0x31, 0x34, 0x62, 0x37, 0x63, 0x66, 0x35, 0x32, 0x31, 0x33, 0x34, 0x35, 0x34, 0x61, 0x31, 0x66, 0x33, 0x34, 0x35, 0x34, 0x39, 0x37, 0x30, 0x30, 0x38, 0x65, 0x64, 0x34, 0x31, 0x37, 0x65, 0x35, 0x64, 0x33, 0x33, 0x65, 0x66, 0x38, 0x34, 0x63, 0x34, 0x39, 0x33, 0x34, 0x33, 0x36, 0x38, 0x62, 0x33, 0x36, 0x66, 0x32, 0x37, 0x36, 0x30, 0x36, 0x30, 0x37, 0x32, 0x31, 0x39, 0x32, 0x61, 0x31, 0x62, 0x34, 0x33, 0x33, 0x39, 0x36, 0x66, 0x38, 0x39, 0x36, 0x34, 0x37, 0x66, 0x30, 0x35, 0x34, 0x31, 0x64, 0x64, 0x32, 0x35, 0x66, 0x35, 0x35, 0x62, 0x34, 0x32, 0x63, 0x35, 0x32, 0x39, 0x35, 0x64, 0x33, 0x61, 0x62, 0x32, 0x61, 0x32, 0x32, 0x33, 0x35, 0x35, 0x36, 0x36, 0x34, 0x36, 0x30, 0x38, 0x62, 0x38, 0x64, 0x66, 0x65, 0x63, 0x33, 0x63, 0x39, 0x64, 0x37, 0x36, 0x30, 0x34, 0x35, 0x62, 0x32, 0x37, 0x64, 0x38, 0x63, 0x32, 0x62, 0x64, 0x62, 0x61, 0x37, 0x66, 0x33, 0x37, 0x36, 0x61, 0x34, 0x34, 0x38, 0x32, 0x36, 0x62, 0x62, 0x66, 0x34, 0x30, 0x34, 0x34, 0x61, 0x65, 0x64, 0x30, 0x64, 0x35, 0x37, 0x30, 0x36, 0x38, 0x34, 0x38, 0x39, 0x66, 0x64, 0x33, 0x32, 0x61, 0x32, 0x62, 0x66, 0x35, 0x32, 0x66, 0x38, 0x36, 0x31, 0x33, 0x61, 0x61, 0x31, 0x35, 0x30, 0x31, 0x38, 0x35, 0x61, 0x61, 0x66, 0x65, 0x36, 0x35, 0x35, 0x64, 0x32, 0x62, 0x38, 0x36, 0x62, 0x66, 0x38, 0x38, 0x36, 0x37, 0x61, 0x36, 0x66, 0x37, 0x37, 0x32, 0x38, 0x63, 0x34, 0x31, 0x33, 0x33, 0x66, 0x62, 0x39, 0x35, 0x37, 0x37, 0x36, 0x35, 0x34, 0x35, 0x62, 0x31, 0x39, 0x37, 0x36, 0x37, 0x61, 0x30, 0x64, 0x37, 0x31, 0x34, 0x34, 0x66, 0x36, 0x30, 0x66, 0x35, 0x65, 0x66, 0x30, 0x33, 0x38, 0x65, 0x61, 0x63, 0x33, 0x39, 0x30, 0x64, 0x31, 0x63, 0x61, 0x63, 0x36, 0x66, 0x39, 0x38, 0x38, 0x32, 0x32, 0x31, 0x31, 0x64, 0x37, 0x33, 0x30, 0x32, 0x31, 0x33, 0x37, 0x65, 0x66, 0x63, 0x38, 0x32, 0x62, 0x39, 0x33, 0x62, 0x38, 0x66, 0x39, 0x63, 0x35, 0x35, 0x64, 0x62, 0x36, 0x32, 0x39, 0x66, 0x34, 0x37, 0x61, 0x32, 0x63, 0x36, 0x31, 0x39, 0x33, 0x31, 0x63, 0x32, 0x31, 0x64, 0x30, 0x31, 0x64, 0x35, 0x61, 0x64, 0x39, 0x36, 0x37, 0x63, 0x39, 0x64, 0x63, 0x36, 0x63, 0x31, 0x61, 0x62, 0x66, 0x64, 0x34, 0x39, 0x36, 0x61, 0x37, 0x34, 0x64, 0x66, 0x32, 0x61, 0x63, 0x34, 0x37, 0x31, 0x34, 0x63, 0x66, 0x62, 0x30, 0x32, 0x37, 0x62, 0x63, 0x34, 0x64, 0x38, 0x63, 0x30, 0x31, 0x35, 0x33, 0x35, 0x34, 0x33, 0x63, 0x61, 0x36, 0x36, 0x33, 0x64, 0x65, 0x64, 0x32, 0x61, 0x66, 0x36, 0x34, 0x66, 0x37, 0x33, 0x39, 0x36, 0x65, 0x64, 0x33, 0x62, 0x32, 0x65, 0x62, 0x64, 0x31, 0x39, 0x37, 0x36, 0x33, 0x38, 0x36, 0x38, 0x31, 0x34, 0x65, 0x39, 0x34, 0x62, 0x37, 0x66, 0x37, 0x66, 0x63, 0x63, 0x33, 0x61, 0x31, 0x39, 0x61, 0x34, 0x64, 0x64, 0x38, 0x37, 0x36, 0x32, 0x38, 0x38, 0x62, 0x39, 0x30, 0x35, 0x63, 0x33, 0x38, 0x31, 0x62, 0x63, 0x38, 0x66, 0x30, 0x30, 0x38, 0x64, 0x65, 0x31, 0x34, 0x35, 0x30, 0x38, 0x33, 0x64, 0x36, 0x34, 0x30, 0x34, 0x38, 0x39, 0x30, 0x61, 0x38, 0x36, 0x33, 0x65, 0x31, 0x61, 0x66, 0x31, 0x64, 0x64, 0x38, 0x39, 0x37, 0x61, 0x65, 0x65, 0x66, 0x32, 0x35, 0x31, 0x36, 0x62, 0x32, 0x30, 0x64, 0x66, 0x35, 0x30, 0x62, 0x65, 0x66, 0x62, 0x36, 0x63, 0x37, 0x30, 0x38, 0x63, 0x39, 0x37, 0x32, 0x38, 0x61, 0x32, 0x32, 0x63, 0x62, 0x33, 0x31, 0x64, 0x38, 0x30, 0x62, 0x30, 0x65, 0x39, 0x35, 0x33, 0x61, 0x61, 0x37, 0x31, 0x32, 0x33, 0x30, 0x64, 0x32, 0x34, 0x36, 0x32, 0x62, 0x62, 0x30, 0x36, 0x36, 0x38, 0x64, 0x64, 0x38, 0x37, 0x30, 0x31, 0x65, 0x31, 0x31, 0x62, 0x63, 0x35, 0x32, 0x34, 0x30, 0x64, 0x38, 0x35, 0x31, 0x38, 0x34, 0x66, 0x39, 0x32, 0x39, 0x38, 0x65, 0x32, 0x63, 0x35, 0x61, 0x33, 0x32, 0x35, 0x37, 0x62, 0x35, 0x64, 0x63, 0x63, 0x33, 0x65, 0x31, 0x33, 0x38, 0x64, 0x66, 0x38, 0x62, 0x37, 0x64, 0x34, 0x31, 0x36, 0x32, 0x64, 0x36, 0x32, 0x35, 0x33, 0x66, 0x62, 0x35, 0x63, 0x32, 0x31, 0x61, 0x36, 0x35, 0x65, 0x39, 0x35, 0x32, 0x36, 0x30, 0x30, 0x63, 0x38, 0x37, 0x36, 0x34, 0x63, 0x36, 0x31, 0x33, 0x63, 0x36, 0x66, 0x34, 0x33, 0x64, 0x32, 0x32, 0x63, 0x38, 0x36, 0x31, 0x64, 0x34, 0x33, 0x38, 0x30, 0x63, 0x64, 0x36, 0x38, 0x38, 0x63, 0x32, 0x38, 0x36, 0x65, 0x39, 0x66, 0x66, 0x61, 0x64, 0x36, 0x62, 0x62, 0x38, 0x35, 0x38, 0x32, 0x34, 0x32, 0x31, 0x66, 0x63, 0x61, 0x62, 0x39, 0x36, 0x62, 0x30, 0x37, 0x35, 0x37, 0x36, 0x39, 0x63, 0x66, 0x34, 0x38, 0x62, 0x33, 0x31, 0x36, 0x30, 0x66, 0x30, 0x35, 0x36, 0x64, 0x66, 0x61, 0x63, 0x34, 0x30, 0x34, 0x31, 0x62, 0x30, 0x38, 0x32, 0x38, 0x37, 0x35, 0x33, 0x33, 0x61, 0x37, 0x36, 0x39, 0x62, 0x65, 0x64, 0x30, 0x66, 0x30, 0x38, 0x66, 0x64, 0x65, 0x65, 0x39, 0x61, 0x31, 0x36, 0x63, 0x35, 0x63, 0x38, 0x66, 0x34, 0x31, 0x34, 0x65, 0x62, 0x33, 0x35, 0x38, 0x33, 0x30, 0x37, 0x39, 0x33, 0x63, 0x37, 0x62, 0x36, 0x34, 0x33, 0x34, 0x31, 0x66, 0x65, 0x66, 0x37, 0x39, 0x64, 0x62, 0x63, 0x35, 0x32, 0x39, 0x61, 0x37, 0x62, 0x39, 0x39, 0x66, 0x38, 0x35, 0x64, 0x34, 0x65, 0x32, 0x65, 0x38, 0x38, 0x62, 0x36, 0x34, 0x39, 0x35, 0x34, 0x62, 0x65, 0x39, 0x36, 0x37, 0x63, 0x35, 0x65, 0x65, 0x36, 0x33, 0x38, 0x36, 0x66, 0x39, 0x31, 0x33, 0x31, 0x62, 0x38, 0x30, 0x62, 0x34, 0x35, 0x34, 0x63, 0x65, 0x37, 0x30, 0x32, 0x30, 0x39, 0x66, 0x37, 0x38, 0x66, 0x32, 0x31, 0x30, 0x31, 0x64, 0x30, 0x63, 0x61, 0x37, 0x31, 0x64, 0x61, 0x32, 0x37, 0x33, 0x37, 0x33, 0x35, 0x62, 0x63, 0x62, 0x63, 0x64, 0x63, 0x35, 0x65, 0x61, 0x35, 0x64, 0x33, 0x64, 0x35, 0x34, 0x62, 0x36, 0x30, 0x37, 0x38, 0x32, 0x30, 0x62, 0x39, 0x62, 0x63, 0x38, 0x35, 0x32, 0x61, 0x62, 0x62, 0x31, 0x62, 0x37, 0x33, 0x33, 0x63, 0x62, 0x37, 0x62, 0x62, 0x35, 0x30, 0x31, 0x38, 0x32, 0x37, 0x36, 0x64, 0x33, 0x30, 0x63, 0x34, 0x63, 0x30, 0x61, 0x37, 0x66, 0x39, 0x66, 0x66, 0x63, 0x64, 0x33, 0x31, 0x38, 0x34, 0x39, 0x39, 0x61, 0x32, 0x30, 0x34, 0x31, 0x30, 0x34, 0x33, 0x34, 0x39, 0x34, 0x62, 0x38, 0x32, 0x34, 0x35, 0x36, 0x63, 0x61, 0x38, 0x61, 0x63, 0x36, 0x66, 0x30, 0x37, 0x36, 0x37, 0x38, 0x61, 0x38, 0x62, 0x37, 0x37, 0x30, 0x33, 0x32, 0x39, 0x62, 0x37, 0x63, 0x30, 0x30, 0x66, 0x33, 0x31, 0x65, 0x37, 0x30, 0x65, 0x39, 0x37, 0x63, 0x65, 0x34, 0x38, 0x62, 0x63, 0x37, 0x39, 0x36, 0x35, 0x37, 0x30, 0x62, 0x65, 0x32, 0x37, 0x35, 0x37, 0x37, 0x65, 0x38, 0x39, 0x38, 0x36, 0x65, 0x65, 0x34, 0x63, 0x37, 0x66, 0x61, 0x35, 0x31, 0x64, 0x61, 0x34, 0x34, 0x62, 0x64, 0x65, 0x63, 0x66, 0x64, 0x64, 0x66, 0x63, 0x66, 0x31, 0x38, 0x36, 0x38, 0x36, 0x63, 0x62, 0x64, 0x64, 0x63, 0x30, 0x32, 0x63, 0x61, 0x32, 0x30, 0x36, 0x64, 0x39, 0x31, 0x33, 0x32, 0x64, 0x34, 0x35, 0x31, 0x61, 0x62, 0x35, 0x35, 0x63, 0x63, 0x65, 0x38, 0x30, 0x36, 0x39, 0x66, 0x36, 0x33, 0x31, 0x34, 0x31, 0x32, 0x61, 0x64, 0x32, 0x61, 0x65, 0x30, 0x32, 0x62, 0x31, 0x61, 0x38, 0x32, 0x34, 0x35, 0x64, 0x33, 0x31, 0x63, 0x30, 0x61, 0x36, 0x35, 0x38, 0x35, 0x34, 0x64, 0x30, 0x37, 0x33, 0x37, 0x30, 0x32, 0x35, 0x39, 0x66, 0x36, 0x33, 0x32, 0x66, 0x65, 0x32, 0x35, 0x33, 0x62, 0x32, 0x34, 0x31, 0x32, 0x63, 0x35, 0x61, 0x37, 0x38, 0x35, 0x31, 0x34, 0x38, 0x32, 0x34, 0x38, 0x64, 0x36, 0x36, 0x30, 0x64, 0x37, 0x63, 0x62, 0x36, 0x62, 0x65, 0x66, 0x35, 0x32, 0x34, 0x30, 0x37, 0x34, 0x39, 0x64, 0x36, 0x61, 0x63, 0x34, 0x61, 0x34, 0x61, 0x63, 0x35, 0x39, 0x33, 0x38, 0x34, 0x62, 0x32, 0x37, 0x65, 0x37, 0x30, 0x31, 0x39, 0x63, 0x36, 0x63, 0x61, 0x65, 0x31, 0x35, 0x65, 0x66, 0x37, 0x63, 0x38, 0x32, 0x65, 0x35, 0x61, 0x39, 0x35, 0x32, 0x66, 0x34, 0x64, 0x61, 0x30, 0x37, 0x39, 0x62, 0x36, 0x32, 0x30, 0x35, 0x66, 0x39, 0x65, 0x31, 0x36, 0x66, 0x33, 0x64, 0x33, 0x63, 0x38, 0x34, 0x65, 0x39, 0x34, 0x62, 0x34, 0x39, 0x30, 0x35, 0x33, 0x30, 0x63, 0x35, 0x62, 0x36, 0x30, 0x32, 0x64, 0x34, 0x62, 0x66, 0x35, 0x65, 0x39, 0x64, 0x33, 0x34, 0x66, 0x32, 0x61, 0x37, 0x38, 0x35, 0x63, 0x64, 0x62, 0x37, 0x66, 0x37, 0x37, 0x35, 0x35, 0x64, 0x36, 0x64, 0x34, 0x36, 0x37, 0x61, 0x39, 0x64, 0x38, 0x38, 0x30, 0x37, 0x31, 0x62, 0x62, 0x64, 0x66, 0x38, 0x63, 0x37, 0x39, 0x31, 0x39, 0x35, 0x37, 0x33, 0x30, 0x64, 0x62, 0x37, 0x64, 0x30, 0x62, 0x37, 0x38, 0x37, 0x32, 0x63, 0x62, 0x64, 0x63, 0x64, 0x61, 0x62, 0x61, 0x62, 0x30, 0x32, 0x62, 0x64, 0x34, 0x62, 0x38, 0x34, 0x38, 0x37, 0x62, 0x37, 0x32, 0x36, 0x63, 0x35, 0x63, 0x65, 0x36, 0x34, 0x39, 0x32, 0x33, 0x34, 0x34, 0x61, 0x65, 0x37, 0x65, 0x39, 0x30, 0x30, 0x61, 0x32, 0x31, 0x38, 0x39, 0x33, 0x65, 0x37, 0x62, 0x38, 0x34, 0x30, 0x62, 0x34, 0x36, 0x33, 0x38, 0x30, 0x62, 0x61, 0x39, 0x39, 0x32, 0x37, 0x38, 0x63, 0x65, 0x39, 0x35, 0x33, 0x32, 0x32, 0x64, 0x63, 0x32, 0x33, 0x64, 0x61, 0x61, 0x39, 0x37, 0x39, 0x39, 0x35, 0x64, 0x31, 0x31, 0x34, 0x39, 0x64, 0x34, 0x32, 0x35, 0x39, 0x35, 0x32, 0x39, 0x31, 0x33, 0x34, 0x32, 0x38, 0x63, 0x38, 0x65, 0x66, 0x38, 0x36, 0x35, 0x39, 0x64, 0x64, 0x32, 0x63, 0x63, 0x32, 0x38, 0x39, 0x35, 0x66, 0x31, 0x32, 0x62, 0x30, 0x38, 0x65, 0x30, 0x35, 0x33, 0x32, 0x61, 0x32, 0x35, 0x34, 0x66, 0x64, 0x35, 0x36, 0x37, 0x34, 0x66, 0x63, 0x61, 0x63, 0x31, 0x62, 0x30, 0x39, 0x39, 0x32, 0x34, 0x37, 0x32, 0x65, 0x66, 0x37, 0x35, 0x33, 0x33, 0x37, 0x64, 0x38, 0x64, 0x37, 0x37, 0x66, 0x36, 0x66, 0x65, 0x66, 0x33, 0x37, 0x32, 0x30, 0x64, 0x34, 0x62, 0x37, 0x62, 0x31, 0x37, 0x33, 0x30, 0x32, 0x34, 0x37, 0x38, 0x63, 0x37, 0x64, 0x32, 0x65, 0x33, 0x62, 0x38, 0x64, 0x65, 0x63, 0x37, 0x61, 0x66, 0x34, 0x63, 0x36, 0x38, 0x31, 0x61, 0x62, 0x61, 0x35, 0x65, 0x32, 0x35, 0x64, 0x38, 0x61, 0x61, 0x33, 0x66, 0x34, 0x33, 0x38, 0x32, 0x62, 0x30, 0x30, 0x38, 0x32, 0x30, 0x36, 0x36, 0x63, 0x33, 0x66, 0x37, 0x61, 0x30, 0x62, 0x34, 0x65, 0x34, 0x32, 0x63, 0x34, 0x36, 0x33, 0x37, 0x64, 0x66, 0x39, 0x30, 0x64, 0x39, 0x61, 0x31, 0x65, 0x32, 0x66, 0x33, 0x66, 0x64, 0x31, 0x63, 0x66, 0x66, 0x61, 0x37, 0x65, 0x30, 0x64, 0x35, 0x35, 0x37, 0x37, 0x66, 0x35, 0x64, 0x61, 0x38, 0x39, 0x33, 0x35, 0x33, 0x35, 0x32, 0x31, 0x65, 0x64, 0x30, 0x32, 0x63, 0x62, 0x31, 0x63, 0x33, 0x39, 0x65, 0x62, 0x35, 0x37, 0x34, 0x36, 0x63, 0x65, 0x66, 0x31, 0x30, 0x63, 0x65, 0x62, 0x37, 0x34, 0x63, 0x33, 0x66, 0x64, 0x62, 0x61, 0x31, 0x33, 0x31, 0x39, 0x39, 0x62, 0x34, 0x32, 0x35, 0x31, 0x36, 0x65, 0x62, 0x66, 0x65, 0x32, 0x39, 0x61, 0x66, 0x34, 0x30, 0x64, 0x61, 0x36, 0x34, 0x61, 0x64, 0x38, 0x31, 0x62, 0x34, 0x36, 0x62, 0x37, 0x62, 0x66, 0x30, 0x34, 0x62, 0x66, 0x32, 0x35, 0x39, 0x39, 0x34, 0x32, 0x35, 0x35, 0x63, 0x37, 0x61, 0x35, 0x31, 0x66, 0x36, 0x38, 0x33, 0x39, 0x38, 0x34, 0x38, 0x38, 0x31, 0x30, 0x30, 0x32, 0x35, 0x62, 0x62, 0x35, 0x32, 0x66, 0x65, 0x37, 0x35, 0x30, 0x30, 0x63, 0x66, 0x31, 0x65, 0x66, 0x36, 0x32, 0x38, 0x61, 0x30, 0x37, 0x37, 0x34, 0x37, 0x38, 0x39, 0x34, 0x65, 0x33, 0x62, 0x37, 0x33, 0x64, 0x35, 0x33, 0x65, 0x36, 0x62, 0x32, 0x39, 0x39, 0x37, 0x64, 0x30, 0x36, 0x35, 0x34, 0x66, 0x31, 0x66, 0x66, 0x64, 0x30, 0x63, 0x30, 0x37, 0x30, 0x34, 0x35, 0x35, 0x34, 0x30, 0x30, 0x66, 0x64, 0x37, 0x65, 0x39, 0x64, 0x36, 0x37, 0x30, 0x39, 0x38, 0x34, 0x61, 0x63, 0x38, 0x30, 0x37, 0x61, 0x30, 0x66, 0x38, 0x31, 0x33, 0x31, 0x39, 0x37, 0x37, 0x65, 0x64, 0x31, 0x38, 0x30, 0x36, 0x66, 0x64, 0x33, 0x63, 0x30, 0x39, 0x32, 0x37, 0x63, 0x33, 0x34, 0x62, 0x37, 0x62, 0x34, 0x64, 0x61, 0x62, 0x66, 0x30, 0x31, 0x31, 0x64, 0x33, 0x31, 0x65, 0x38, 0x36, 0x62, 0x31, 0x62, 0x37, 0x39, 0x33, 0x32, 0x62, 0x37, 0x30, 0x65, 0x37, 0x62, 0x30, 0x36, 0x38, 0x61, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x33, 0x64, 0x32, 0x34, 0x31, 0x65, 0x38, 0x66, 0x32, 0x30, 0x62, 0x62, 0x36, 0x62, 0x65, 0x33, 0x61, 0x33, 0x61, 0x33, 0x37, 0x36, 0x37, 0x31, 0x31, 0x31, 0x61, 0x61, 0x36, 0x66, 0x34, 0x35, 0x39, 0x66, 0x38, 0x34, 0x62, 0x65, 0x39, 0x36, 0x31, 0x63, 0x32, 0x33, 0x33, 0x37, 0x66, 0x36, 0x65, 0x30, 0x33, 0x65, 0x64, 0x33, 0x63, 0x63, 0x36, 0x63, 0x38, 0x34, 0x37, 0x61, 0x33, 0x36, 0x38, 0x33, 0x38, 0x39, 0x34, 0x32, 0x38, 0x38, 0x62, 0x34, 0x37, 0x31, 0x35, 0x30, 0x34, 0x63, 0x62, 0x64, 0x63, 0x34, 0x33, 0x61, 0x37, 0x38, 0x66, 0x38, 0x35, 0x36, 0x38, 0x30, 0x31, 0x61, 0x31, 0x30, 0x61, 0x38, 0x37, 0x63, 0x37, 0x37, 0x33, 0x32, 0x32, 0x65, 0x33, 0x36, 0x65, 0x30, 0x63, 0x61, 0x34, 0x32, 0x36, 0x65, 0x63, 0x36, 0x37, 0x61, 0x64, 0x33, 0x61, 0x32, 0x61, 0x33, 0x62, 0x37, 0x39, 0x62, 0x63, 0x35, 0x63, 0x62, 0x38, 0x31, 0x39, 0x32, 0x38, 0x61, 0x37, 0x39, 0x61, 0x36, 0x37, 0x61, 0x30, 0x66, 0x62, 0x34, 0x36, 0x62, 0x62, 0x39, 0x36, 0x37, 0x63, 0x62, 0x61, 0x62, 0x37, 0x33, 0x66, 0x64, 0x33, 0x36, 0x30, 0x32, 0x32, 0x66, 0x39, 0x32, 0x64, 0x39, 0x32, 0x30, 0x32, 0x30, 0x34, 0x64, 0x65, 0x36, 0x31, 0x37, 0x31, 0x37, 0x64, 0x64, 0x65, 0x36, 0x61, 0x38, 0x35, 0x62, 0x37, 0x62, 0x63, 0x66, 0x35, 0x37, 0x35, 0x38, 0x34, 0x63, 0x31, 0x31, 0x63, 0x65, 0x35, 0x34, 0x61, 0x63, 0x39, 0x32, 0x39, 0x39, 0x38, 0x66, 0x38, 0x35, 0x36, 0x62, 0x66, 0x30, 0x34, 0x32, 0x61, 0x30, 0x31, 0x63, 0x35, 0x30, 0x32, 0x30, 0x64, 0x32, 0x36, 0x36, 0x62, 0x31, 0x63, 0x63, 0x65, 0x61, 0x37, 0x37, 0x34, 0x39, 0x35, 0x35, 0x34, 0x38, 0x34, 0x34, 0x30, 0x35, 0x66, 0x35, 0x38, 0x61, 0x64, 0x31, 0x36, 0x31, 0x32, 0x35, 0x31, 0x64, 0x38, 0x37, 0x39, 0x61, 0x38, 0x37, 0x63, 0x34, 0x33, 0x64, 0x35, 0x64, 0x62, 0x61, 0x65, 0x63, 0x64, 0x39, 0x37, 0x36, 0x61, 0x63, 0x35, 0x64, 0x30, 0x34, 0x64, 0x64, 0x32, 0x35, 0x38, 0x36, 0x64, 0x37, 0x30, 0x30, 0x33, 0x31, 0x61, 0x38, 0x36, 0x62, 0x30, 0x64, 0x63, 0x61, 0x64, 0x65, 0x31, 0x34, 0x30, 0x32, 0x38, 0x66, 0x33, 0x36, 0x61, 0x30, 0x34, 0x35, 0x30, 0x38, 0x34, 0x39, 0x34, 0x63, 0x37, 0x61, 0x32, 0x30, 0x65, 0x39, 0x38, 0x62, 0x33, 0x62, 0x32, 0x31, 0x66, 0x37, 0x37, 0x36, 0x35, 0x65, 0x37, 0x62, 0x33, 0x65, 0x66, 0x36, 0x38, 0x66, 0x31, 0x30, 0x39, 0x36, 0x30, 0x37, 0x30, 0x39, 0x65, 0x36, 0x33, 0x65, 0x65, 0x61, 0x33, 0x35, 0x61, 0x32, 0x36, 0x66, 0x66, 0x34, 0x37, 0x34, 0x32, 0x34, 0x65, 0x31, 0x38, 0x64, 0x66, 0x38, 0x63, 0x63, 0x32, 0x37, 0x31, 0x66, 0x66, 0x33, 0x30, 0x34, 0x39, 0x32, 0x36, 0x32, 0x63, 0x38, 0x35, 0x35, 0x64, 0x36, 0x61, 0x31, 0x33, 0x31, 0x36, 0x39, 0x35, 0x61, 0x33, 0x39, 0x35, 0x66, 0x32, 0x62, 0x61, 0x32, 0x66, 0x31, 0x62, 0x30, 0x33, 0x39, 0x30, 0x31, 0x32, 0x61, 0x63, 0x38, 0x61, 0x32, 0x61, 0x62, 0x64, 0x66, 0x36, 0x64, 0x39, 0x66, 0x36, 0x62, 0x30, 0x63, 0x34, 0x33, 0x32, 0x66, 0x30, 0x61, 0x65, 0x37, 0x38, 0x62, 0x39, 0x62, 0x63, 0x63, 0x62, 0x39, 0x39, 0x66, 0x38, 0x39, 0x37, 0x35, 0x39, 0x34, 0x33, 0x34, 0x34, 0x37, 0x37, 0x32, 0x35, 0x37, 0x63, 0x65, 0x31, 0x66, 0x34, 0x34, 0x63, 0x63, 0x36, 0x31, 0x65, 0x39, 0x35, 0x62, 0x39, 0x63, 0x39, 0x38, 0x34, 0x33, 0x65, 0x63, 0x38, 0x65, 0x66, 0x62, 0x31, 0x37, 0x63, 0x36, 0x34, 0x30, 0x66, 0x63, 0x34, 0x63, 0x38, 0x33, 0x37, 0x65, 0x63, 0x31, 0x32, 0x35, 0x66, 0x62, 0x32, 0x35, 0x33, 0x32, 0x33, 0x64, 0x33, 0x66, 0x30, 0x36, 0x34, 0x34, 0x36, 0x31, 0x35, 0x64, 0x32, 0x31, 0x37, 0x32, 0x31, 0x36, 0x30, 0x37, 0x66, 0x65, 0x65, 0x34, 0x64, 0x36, 0x38, 0x65, 0x32, 0x64, 0x63, 0x39, 0x62, 0x64, 0x32, 0x39, 0x66, 0x35, 0x62, 0x31, 0x33, 0x66, 0x61, 0x66, 0x65, 0x33, 0x39, 0x62, 0x30, 0x37, 0x31, 0x30, 0x64, 0x30, 0x33, 0x36, 0x35, 0x64, 0x63, 0x63, 0x64, 0x61, 0x33, 0x35, 0x65, 0x33, 0x63, 0x39, 0x33, 0x37, 0x61, 0x65, 0x64, 0x31, 0x62, 0x36, 0x39, 0x34, 0x39, 0x62, 0x32, 0x61, 0x30, 0x61, 0x37, 0x35, 0x32, 0x33, 0x30, 0x31, 0x31, 0x65, 0x62, 0x37, 0x30, 0x36, 0x33, 0x35, 0x37, 0x62, 0x38, 0x35, 0x65, 0x31, 0x37, 0x34, 0x33, 0x37, 0x36, 0x65, 0x61, 0x37, 0x63, 0x61, 0x64, 0x62, 0x64, 0x30, 0x31, 0x65, 0x64, 0x30, 0x64, 0x64, 0x31, 0x62, 0x63, 0x36, 0x61, 0x38, 0x65, 0x35, 0x61, 0x35, 0x61, 0x31, 0x31, 0x62, 0x63, 0x36, 0x31, 0x33, 0x31, 0x66, 0x30, 0x36, 0x36, 0x31, 0x64, 0x64, 0x36, 0x33, 0x36, 0x35, 0x62, 0x31, 0x33, 0x63, 0x36, 0x65, 0x32, 0x64, 0x65, 0x35, 0x30, 0x62, 0x39, 0x38, 0x63, 0x62, 0x61, 0x31, 0x63, 0x64, 0x65, 0x35, 0x38, 0x61, 0x39, 0x32, 0x31, 0x64, 0x31, 0x39, 0x39, 0x33, 0x36, 0x63, 0x37, 0x31, 0x31, 0x34, 0x32, 0x34, 0x65, 0x62, 0x36, 0x32, 0x35, 0x62, 0x37, 0x63, 0x33, 0x35, 0x63, 0x62, 0x61, 0x30, 0x31, 0x61, 0x30, 0x66, 0x37, 0x64, 0x66, 0x61, 0x38, 0x64, 0x36, 0x66, 0x38, 0x36, 0x61, 0x32, 0x61, 0x30, 0x32, 0x34, 0x32, 0x35, 0x61, 0x62, 0x34, 0x38, 0x65, 0x32, 0x63, 0x32, 0x38, 0x66, 0x38, 0x66, 0x32, 0x66, 0x36, 0x31, 0x61, 0x64, 0x62, 0x62, 0x37, 0x34, 0x34, 0x63, 0x32, 0x32, 0x31, 0x62, 0x39, 0x63, 0x34, 0x66, 0x33, 0x35, 0x62, 0x31, 0x36, 0x63, 0x37, 0x34, 0x39, 0x63, 0x32, 0x32, 0x37, 0x62, 0x63, 0x65, 0x65, 0x31, 0x32, 0x30, 0x32, 0x65, 0x38, 0x37, 0x35, 0x33, 0x37, 0x63, 0x37, 0x34, 0x34, 0x31, 0x66, 0x34, 0x32, 0x31, 0x63, 0x38, 0x35, 0x35, 0x63, 0x65, 0x38, 0x37, 0x64, 0x38, 0x35, 0x38, 0x61, 0x36, 0x37, 0x39, 0x66, 0x30, 0x39, 0x64, 0x63, 0x66, 0x38, 0x31, 0x34, 0x62, 0x66, 0x61, 0x31, 0x66, 0x32, 0x36, 0x66, 0x37, 0x64, 0x39, 0x63, 0x65, 0x31, 0x38, 0x66, 0x37, 0x32, 0x33, 0x64, 0x32, 0x66, 0x38, 0x34, 0x64, 0x34, 0x62, 0x32, 0x35, 0x65, 0x63, 0x36, 0x30, 0x61, 0x64, 0x62, 0x62, 0x36, 0x33, 0x36, 0x37, 0x65, 0x39, 0x32, 0x32, 0x37, 0x30, 0x38, 0x33, 0x36, 0x64, 0x30, 0x33, 0x63, 0x37, 0x31, 0x65, 0x64, 0x34, 0x33, 0x34, 0x31, 0x33, 0x37, 0x36, 0x37, 0x33, 0x34, 0x32, 0x61, 0x34, 0x66, 0x62, 0x38, 0x64, 0x36, 0x38, 0x30, 0x31, 0x62, 0x38, 0x37, 0x35, 0x35, 0x62, 0x66, 0x36, 0x35, 0x65, 0x37, 0x39, 0x34, 0x37, 0x65, 0x64, 0x34, 0x34, 0x35, 0x39, 0x61, 0x64, 0x36, 0x34, 0x38, 0x36, 0x66, 0x63, 0x31, 0x63, 0x63, 0x61, 0x31, 0x66, 0x31, 0x63, 0x63, 0x38, 0x39, 0x64, 0x66, 0x33, 0x64, 0x33, 0x30, 0x37, 0x66, 0x30, 0x31, 0x64, 0x38, 0x61, 0x63, 0x36, 0x38, 0x61, 0x61, 0x31, 0x64, 0x30, 0x38, 0x64, 0x31, 0x38, 0x61, 0x61, 0x33, 0x35, 0x61, 0x34, 0x36, 0x62, 0x66, 0x32, 0x34, 0x35, 0x35, 0x38, 0x39, 0x63, 0x35, 0x39, 0x39, 0x65, 0x64, 0x64, 0x63, 0x36, 0x33, 0x33, 0x37, 0x65, 0x37, 0x36, 0x34, 0x63, 0x33, 0x36, 0x34, 0x32, 0x36, 0x66, 0x37, 0x62, 0x37, 0x66, 0x35, 0x64, 0x32, 0x61, 0x66, 0x64, 0x65, 0x30, 0x61, 0x37, 0x36, 0x66, 0x64, 0x33, 0x61, 0x61, 0x35, 0x33, 0x36, 0x64, 0x31, 0x61, 0x31, 0x36, 0x35, 0x66, 0x39, 0x66, 0x32, 0x33, 0x63, 0x66, 0x63, 0x36, 0x35, 0x38, 0x36, 0x36, 0x66, 0x35, 0x37, 0x34, 0x66, 0x32, 0x32, 0x38, 0x39, 0x61, 0x61, 0x35, 0x62, 0x65, 0x30, 0x35, 0x36, 0x64, 0x64, 0x33, 0x32, 0x63, 0x37, 0x32, 0x61, 0x32, 0x30, 0x34, 0x62, 0x61, 0x38, 0x33, 0x32, 0x38, 0x64, 0x64, 0x39, 0x62, 0x30, 0x62, 0x34, 0x36, 0x34, 0x33, 0x37, 0x39, 0x30, 0x34, 0x36, 0x33, 0x34, 0x38, 0x34, 0x64, 0x33, 0x31, 0x36, 0x32, 0x33, 0x31, 0x32, 0x37, 0x63, 0x30, 0x39, 0x63, 0x36, 0x63, 0x65, 0x63, 0x34, 0x34, 0x36, 0x61, 0x39, 0x61, 0x63, 0x39, 0x61, 0x35, 0x33, 0x63, 0x62, 0x36, 0x38, 0x34, 0x31, 0x63, 0x61, 0x32, 0x61, 0x30, 0x39, 0x37, 0x63, 0x65, 0x65, 0x66, 0x38, 0x38, 0x65, 0x35, 0x33, 0x37, 0x65, 0x32, 0x30, 0x39, 0x38, 0x38, 0x30, 0x66, 0x66, 0x64, 0x63, 0x66, 0x64, 0x35, 0x30, 0x33, 0x33, 0x62, 0x63, 0x33, 0x66, 0x35, 0x61, 0x38, 0x38, 0x35, 0x63, 0x32, 0x37, 0x31, 0x65, 0x34, 0x31, 0x65, 0x65, 0x33, 0x33, 0x32, 0x33, 0x36, 0x36, 0x33, 0x34, 0x35, 0x66, 0x61, 0x38, 0x36, 0x37, 0x37, 0x38, 0x30, 0x62, 0x65, 0x62, 0x33, 0x63, 0x31, 0x64, 0x35, 0x65, 0x61, 0x61, 0x34, 0x39, 0x36, 0x65, 0x61, 0x30, 0x39, 0x31, 0x36, 0x30, 0x64, 0x62, 0x33, 0x66, 0x61, 0x37, 0x34, 0x37, 0x37, 0x61, 0x32, 0x66, 0x66, 0x66, 0x34, 0x33, 0x36, 0x65, 0x63, 0x65, 0x65, 0x39, 0x35, 0x61, 0x61, 0x32, 0x64, 0x35, 0x31, 0x66, 0x66, 0x34, 0x32, 0x63, 0x61, 0x39, 0x64, 0x34, 0x66, 0x63, 0x66, 0x30, 0x32, 0x31, 0x62, 0x36, 0x65, 0x35, 0x30, 0x31, 0x34, 0x31, 0x30, 0x66, 0x64, 0x34, 0x31, 0x30, 0x39, 0x38, 0x61, 0x31, 0x61, 0x38, 0x66, 0x36, 0x30, 0x32, 0x31, 0x36, 0x33, 0x36, 0x65, 0x63, 0x65, 0x39, 0x38, 0x63, 0x32, 0x37, 0x62, 0x64, 0x37, 0x34, 0x37, 0x34, 0x30, 0x62, 0x37, 0x32, 0x38, 0x30, 0x64, 0x33, 0x61, 0x35, 0x65, 0x31, 0x33, 0x64, 0x39, 0x38, 0x35, 0x30, 0x66, 0x63, 0x66, 0x37, 0x66, 0x32, 0x31, 0x31, 0x38, 0x63, 0x34, 0x63, 0x39, 0x31, 0x35, 0x37, 0x32, 0x62, 0x61, 0x35, 0x38, 0x32, 0x36, 0x66, 0x63, 0x63, 0x34, 0x62, 0x30, 0x38, 0x33, 0x37, 0x64, 0x30, 0x62, 0x33, 0x39, 0x34, 0x66, 0x36, 0x36, 0x38, 0x33, 0x63, 0x62, 0x61, 0x33, 0x38, 0x66, 0x61, 0x33, 0x35, 0x61, 0x35, 0x65, 0x32, 0x62, 0x64, 0x32, 0x34, 0x32, 0x30, 0x34, 0x31, 0x35, 0x33, 0x33, 0x62, 0x64, 0x32, 0x35, 0x39, 0x33, 0x39, 0x63, 0x63, 0x38, 0x37, 0x33, 0x64, 0x31, 0x66, 0x35, 0x38, 0x35, 0x32, 0x61, 0x32, 0x66, 0x35, 0x37, 0x63, 0x62, 0x31, 0x37, 0x32, 0x65, 0x62, 0x31, 0x37, 0x63, 0x32, 0x65, 0x33, 0x63, 0x33, 0x35, 0x31, 0x32, 0x34, 0x30, 0x61, 0x30, 0x62, 0x32, 0x62, 0x33, 0x33, 0x34, 0x39, 0x37, 0x38, 0x62, 0x39, 0x30, 0x61, 0x63, 0x31, 0x38, 0x30, 0x34, 0x31, 0x62, 0x30, 0x39, 0x61, 0x65, 0x61, 0x64, 0x32, 0x36, 0x36, 0x34, 0x39, 0x62, 0x31, 0x63, 0x31, 0x63, 0x30, 0x31, 0x39, 0x65, 0x34, 0x31, 0x37, 0x33, 0x31, 0x65, 0x37, 0x37, 0x63, 0x36, 0x62, 0x32, 0x32, 0x31, 0x31, 0x64, 0x37, 0x64, 0x61, 0x39, 0x34, 0x36, 0x33, 0x30, 0x35, 0x30, 0x37, 0x62, 0x61, 0x64, 0x30, 0x32, 0x37, 0x35, 0x36, 0x31, 0x64, 0x63, 0x36, 0x32, 0x35, 0x62, 0x37, 0x65, 0x38, 0x34, 0x30, 0x39, 0x34, 0x33, 0x37, 0x38, 0x65, 0x35, 0x39, 0x39, 0x61, 0x35, 0x37, 0x62, 0x30, 0x39, 0x65, 0x62, 0x33, 0x32, 0x63, 0x32, 0x61, 0x36, 0x37, 0x63, 0x66, 0x35, 0x66, 0x32, 0x66, 0x30, 0x62, 0x66, 0x39, 0x32, 0x35, 0x30, 0x65, 0x36, 0x64, 0x61, 0x30, 0x37, 0x62, 0x31, 0x36, 0x35, 0x66, 0x39, 0x37, 0x64, 0x63, 0x61, 0x31, 0x30, 0x35, 0x31, 0x37, 0x65, 0x39, 0x66, 0x33, 0x66, 0x65, 0x33, 0x35, 0x36, 0x31, 0x64, 0x30, 0x32, 0x65, 0x63, 0x38, 0x33, 0x61, 0x37, 0x32, 0x32, 0x62, 0x35, 0x34, 0x34, 0x62, 0x64, 0x36, 0x65, 0x32, 0x35, 0x65, 0x66, 0x32, 0x37, 0x64, 0x39, 0x38, 0x32, 0x35, 0x64, 0x31, 0x33, 0x36, 0x35, 0x31, 0x34, 0x34, 0x33, 0x63, 0x34, 0x64, 0x39, 0x38, 0x34, 0x64, 0x37, 0x65, 0x35, 0x64, 0x30, 0x66, 0x64, 0x37, 0x30, 0x63, 0x32, 0x61, 0x37, 0x66, 0x39, 0x38, 0x33, 0x62, 0x33, 0x61, 0x65, 0x38, 0x63, 0x36, 0x39, 0x38, 0x64, 0x32, 0x37, 0x61, 0x32, 0x61, 0x30, 0x62, 0x66, 0x32, 0x64, 0x33, 0x35, 0x36, 0x35, 0x35, 0x66, 0x34, 0x37, 0x37, 0x61, 0x64, 0x63, 0x39, 0x39, 0x63, 0x35, 0x36, 0x66, 0x34, 0x38, 0x37, 0x37, 0x33, 0x39, 0x32, 0x32, 0x38, 0x33, 0x31, 0x37, 0x34, 0x36, 0x66, 0x38, 0x61, 0x66, 0x35, 0x38, 0x64, 0x65, 0x39, 0x34, 0x31, 0x61, 0x30, 0x32, 0x30, 0x39, 0x38, 0x36, 0x61, 0x64, 0x37, 0x63, 0x32, 0x33, 0x66, 0x62, 0x37, 0x64, 0x33, 0x31, 0x63, 0x32, 0x66, 0x31, 0x37, 0x66, 0x33, 0x30, 0x35, 0x31, 0x37, 0x34, 0x64, 0x62, 0x32, 0x36, 0x62, 0x34, 0x30, 0x34, 0x34, 0x37, 0x65, 0x36, 0x34, 0x63, 0x36, 0x36, 0x32, 0x31, 0x36, 0x64, 0x63, 0x65, 0x39, 0x38, 0x65, 0x37, 0x61, 0x38, 0x33, 0x31, 0x36, 0x64, 0x64, 0x39, 0x31, 0x64, 0x65, 0x65, 0x34, 0x36, 0x38, 0x65, 0x36, 0x30, 0x32, 0x32, 0x30, 0x36, 0x61, 0x34, 0x64, 0x31, 0x64, 0x31, 0x38, 0x66, 0x61, 0x37, 0x38, 0x32, 0x37, 0x66, 0x37, 0x33, 0x33, 0x30, 0x33, 0x37, 0x66, 0x61, 0x38, 0x37, 0x64, 0x66, 0x63, 0x39, 0x63, 0x37, 0x34, 0x63, 0x39, 0x64, 0x66, 0x30, 0x39, 0x36, 0x30, 0x38, 0x36, 0x37, 0x30, 0x38, 0x37, 0x63, 0x37, 0x37, 0x36, 0x33, 0x38, 0x32, 0x62, 0x39, 0x34, 0x64, 0x62, 0x39, 0x34, 0x32, 0x30, 0x61, 0x31, 0x39, 0x65, 0x35, 0x33, 0x33, 0x38, 0x65, 0x31, 0x37, 0x65, 0x38, 0x61, 0x36, 0x38, 0x63, 0x62, 0x37, 0x36, 0x32, 0x31, 0x66, 0x30, 0x62, 0x35, 0x36, 0x39, 0x38, 0x34, 0x36, 0x31, 0x30, 0x62, 0x65, 0x64, 0x64, 0x33, 0x64, 0x39, 0x62, 0x37, 0x37, 0x64, 0x63, 0x35, 0x34, 0x34, 0x37, 0x63, 0x64, 0x62, 0x31, 0x32, 0x39, 0x65, 0x63, 0x63, 0x33, 0x33, 0x35, 0x39, 0x36, 0x30, 0x37, 0x39, 0x63, 0x66, 0x32, 0x30, 0x36, 0x65, 0x39, 0x33, 0x39, 0x30, 0x34, 0x33, 0x36, 0x38, 0x63, 0x61, 0x65, 0x30, 0x37, 0x66, 0x30, 0x64, 0x34, 0x34, 0x39, 0x65, 0x32, 0x30, 0x39, 0x35, 0x66, 0x38, 0x61, 0x62, 0x64, 0x39, 0x35, 0x66, 0x32, 0x36, 0x36, 0x30, 0x33, 0x64, 0x32, 0x64, 0x62, 0x30, 0x34, 0x37, 0x36, 0x34, 0x37, 0x62, 0x61, 0x62, 0x63, 0x38, 0x33, 0x34, 0x32, 0x32, 0x30, 0x30, 0x62, 0x65, 0x30, 0x30, 0x39, 0x35, 0x61, 0x61, 0x35, 0x34, 0x38, 0x39, 0x66, 0x64, 0x31, 0x38, 0x63, 0x64, 0x30, 0x30, 0x61, 0x35, 0x32, 0x66, 0x35, 0x39, 0x62, 0x37, 0x30, 0x66, 0x66, 0x30, 0x34, 0x63, 0x34, 0x62, 0x31, 0x65, 0x35, 0x37, 0x32, 0x64, 0x62, 0x37, 0x36, 0x64, 0x30, 0x38, 0x62, 0x61, 0x64, 0x34, 0x31, 0x39, 0x61, 0x62, 0x62, 0x61, 0x62, 0x62, 0x30, 0x30, 0x62, 0x39, 0x65, 0x34, 0x38, 0x35, 0x65, 0x33, 0x66, 0x30, 0x31, 0x37, 0x38, 0x30, 0x37, 0x63, 0x31, 0x32, 0x62, 0x34, 0x32, 0x37, 0x62, 0x35, 0x65, 0x30, 0x65, 0x36, 0x34, 0x38, 0x63, 0x66, 0x37, 0x62, 0x31, 0x36, 0x30, 0x36, 0x35, 0x65, 0x33, 0x31, 0x33, 0x63, 0x31, 0x63, 0x30, 0x37, 0x33, 0x63, 0x65, 0x33, 0x35, 0x34, 0x61, 0x35, 0x66, 0x63, 0x36, 0x38, 0x31, 0x32, 0x63, 0x30, 0x32, 0x62, 0x38, 0x64, 0x34, 0x62, 0x36, 0x61, 0x61, 0x31, 0x31, 0x36, 0x38, 0x63, 0x35, 0x37, 0x35, 0x64, 0x61, 0x64, 0x39, 0x38, 0x37, 0x35, 0x30, 0x38, 0x37, 0x66, 0x65, 0x39, 0x66, 0x36, 0x31, 0x37, 0x30, 0x32, 0x33, 0x30, 0x39, 0x66, 0x65, 0x62, 0x66, 0x62, 0x39, 0x39, 0x62, 0x38, 0x39, 0x35, 0x33, 0x38, 0x37, 0x63, 0x63, 0x31, 0x31, 0x30, 0x34, 0x63, 0x33, 0x35, 0x65, 0x31, 0x32, 0x33, 0x62, 0x37, 0x31, 0x33, 0x30, 0x31, 0x39, 0x62, 0x35, 0x65, 0x35, 0x31, 0x63, 0x33, 0x32, 0x30, 0x66, 0x63, 0x32, 0x35, 0x32, 0x31, 0x63, 0x64, 0x62, 0x35, 0x63, 0x66, 0x63, 0x61, 0x32, 0x30, 0x66, 0x36, 0x31, 0x37, 0x37, 0x37, 0x33, 0x66, 0x64, 0x34, 0x36, 0x64, 0x33, 0x38, 0x37, 0x32, 0x31, 0x32, 0x38, 0x62, 0x38, 0x37, 0x64, 0x66, 0x36, 0x66, 0x36, 0x36, 0x61, 0x32, 0x31, 0x66, 0x62, 0x33, 0x66, 0x61, 0x31, 0x36, 0x37, 0x31, 0x31, 0x32, 0x34, 0x35, 0x61, 0x62, 0x36, 0x35, 0x65, 0x65, 0x66, 0x36, 0x32, 0x39, 0x63, 0x35, 0x65, 0x36, 0x30, 0x37, 0x33, 0x65, 0x66, 0x61, 0x66, 0x66, 0x35, 0x62, 0x37, 0x30, 0x37, 0x36, 0x35, 0x37, 0x66, 0x34, 0x34, 0x34, 0x32, 0x66, 0x32, 0x65, 0x62, 0x32, 0x36, 0x33, 0x37, 0x66, 0x61, 0x37, 0x31, 0x30, 0x30, 0x30, 0x66, 0x31, 0x34, 0x66, 0x63, 0x36, 0x39, 0x31, 0x61, 0x37, 0x31, 0x61, 0x61, 0x63, 0x66, 0x39, 0x30, 0x32, 0x63, 0x30, 0x63, 0x31, 0x61, 0x31, 0x61, 0x35, 0x64, 0x37, 0x64, 0x38, 0x64, 0x33, 0x35, 0x31, 0x62, 0x38, 0x62, 0x33, 0x63, 0x61, 0x64, 0x35, 0x37, 0x61, 0x63, 0x64, 0x30, 0x61, 0x39, 0x65, 0x34, 0x37, 0x61, 0x31, 0x61, 0x62, 0x64, 0x63, 0x61, 0x66, 0x32, 0x62, 0x37, 0x30, 0x61, 0x65, 0x64, 0x38, 0x62, 0x37, 0x33, 0x37, 0x30, 0x61, 0x36, 0x62, 0x62, 0x32, 0x62, 0x62, 0x34, 0x66, 0x33, 0x64, 0x36, 0x37, 0x39, 0x63, 0x34, 0x66, 0x39, 0x37, 0x39, 0x33, 0x65, 0x34, 0x62, 0x32, 0x35, 0x36, 0x64, 0x65, 0x65, 0x66, 0x61, 0x65, 0x66, 0x31, 0x65, 0x36, 0x64, 0x62, 0x63, 0x64, 0x62, 0x62, 0x36, 0x34, 0x38, 0x62, 0x39, 0x31, 0x37, 0x65, 0x33, 0x34, 0x38, 0x32, 0x32, 0x64, 0x38, 0x33, 0x33, 0x64, 0x32, 0x61, 0x63, 0x31, 0x36, 0x31, 0x34, 0x61, 0x65, 0x62, 0x63, 0x66, 0x33, 0x36, 0x30, 0x64, 0x33, 0x32, 0x38, 0x64, 0x39, 0x32, 0x37, 0x31, 0x66, 0x32, 0x37, 0x63, 0x35, 0x32, 0x63, 0x39, 0x33, 0x64, 0x65, 0x34, 0x61, 0x39, 0x34, 0x35, 0x35, 0x63, 0x65, 0x36, 0x63, 0x64, 0x38, 0x64, 0x32, 0x31, 0x34, 0x30, 0x65, 0x62, 0x66, 0x36, 0x62, 0x32, 0x31, 0x63, 0x39, 0x62, 0x31, 0x37, 0x32, 0x63, 0x66, 0x34, 0x37, 0x35, 0x35, 0x36, 0x65, 0x66, 0x63, 0x35, 0x64, 0x66, 0x66, 0x39, 0x61, 0x66, 0x62, 0x39, 0x31, 0x33, 0x65, 0x33, 0x32, 0x38, 0x61, 0x37, 0x30, 0x38, 0x32, 0x39, 0x32, 0x62, 0x66, 0x62, 0x36, 0x35, 0x63, 0x39, 0x36, 0x64, 0x36, 0x36, 0x38, 0x66, 0x34, 0x64, 0x30, 0x62, 0x33, 0x61, 0x39, 0x61, 0x32, 0x31, 0x62, 0x32, 0x32, 0x32, 0x30, 0x33, 0x39, 0x31, 0x35, 0x36, 0x63, 0x62, 0x61, 0x39, 0x39, 0x38, 0x30, 0x64, 0x36, 0x62, 0x66, 0x31, 0x31, 0x65, 0x66, 0x62, 0x64, 0x38, 0x64, 0x64, 0x38, 0x39, 0x33, 0x33, 0x37, 0x38, 0x65, 0x35, 0x64, 0x63, 0x31, 0x62, 0x33, 0x32, 0x33, 0x63, 0x35, 0x37, 0x64, 0x38, 0x66, 0x37, 0x30, 0x32, 0x30, 0x37, 0x36, 0x63, 0x32, 0x32, 0x64, 0x31, 0x32, 0x35, 0x64, 0x31, 0x34, 0x38, 0x39, 0x62, 0x61, 0x62, 0x32, 0x35, 0x35, 0x33, 0x63, 0x35, 0x35, 0x32, 0x31, 0x36, 0x33, 0x31, 0x63, 0x33, 0x35, 0x66, 0x37, 0x62, 0x35, 0x32, 0x33, 0x36, 0x30, 0x30, 0x37, 0x63, 0x65, 0x38, 0x66, 0x33, 0x37, 0x30, 0x31, 0x32, 0x63, 0x61, 0x63, 0x65, 0x37, 0x38, 0x64, 0x36, 0x65, 0x62, 0x33, 0x39, 0x37, 0x31, 0x38, 0x39, 0x30, 0x34, 0x62, 0x35, 0x64, 0x63, 0x33, 0x31, 0x64, 0x64, 0x63, 0x62, 0x36, 0x66, 0x34, 0x66, 0x31, 0x37, 0x35, 0x65, 0x35, 0x32, 0x62, 0x63, 0x66, 0x36, 0x63, 0x36, 0x30, 0x30, 0x38, 0x66, 0x36, 0x66, 0x35, 0x61, 0x35, 0x37, 0x32, 0x39, 0x32, 0x35, 0x36, 0x30, 0x30, 0x31, 0x39, 0x34, 0x62, 0x39, 0x61, 0x66, 0x37, 0x61, 0x65, 0x30, 0x37, 0x34, 0x64, 0x62, 0x66, 0x38, 0x35, 0x31, 0x31, 0x39, 0x65, 0x33, 0x61, 0x66, 0x64, 0x31, 0x34, 0x31, 0x62, 0x32, 0x66, 0x66, 0x32, 0x36, 0x35, 0x32, 0x61, 0x35, 0x38, 0x66, 0x30, 0x34, 0x33, 0x65, 0x39, 0x37, 0x66, 0x31, 0x31, 0x62, 0x37, 0x37, 0x39, 0x39, 0x37, 0x61, 0x39, 0x64, 0x61, 0x31, 0x63, 0x39, 0x36, 0x63, 0x31, 0x38, 0x62, 0x35, 0x32, 0x35, 0x34, 0x61, 0x31, 0x30, 0x37, 0x66, 0x32, 0x34, 0x65, 0x39, 0x39, 0x37, 0x61, 0x33, 0x65, 0x61, 0x36, 0x31, 0x63, 0x32, 0x30, 0x36, 0x39, 0x62, 0x39, 0x64, 0x30, 0x34, 0x64, 0x34, 0x39, 0x62, 0x64, 0x31, 0x62, 0x63, 0x64, 0x32, 0x34, 0x39, 0x35, 0x62, 0x31, 0x39, 0x62, 0x63, 0x37, 0x31, 0x38, 0x34, 0x38, 0x66, 0x32, 0x38, 0x62, 0x66, 0x62, 0x34, 0x66, 0x30, 0x33, 0x34, 0x36, 0x62, 0x36, 0x38, 0x32, 0x61, 0x31, 0x62, 0x34, 0x37, 0x34, 0x65, 0x30, 0x34, 0x30, 0x62, 0x30, 0x35, 0x36, 0x65, 0x36, 0x30, 0x61, 0x33, 0x32, 0x62, 0x35, 0x65, 0x38, 0x61, 0x61, 0x35, 0x33, 0x32, 0x31, 0x30, 0x33, 0x31, 0x30, 0x31, 0x63, 0x62, 0x34, 0x35, 0x63, 0x61, 0x34, 0x31, 0x63, 0x36, 0x61, 0x36, 0x39, 0x30, 0x63, 0x38, 0x36, 0x38, 0x38, 0x35, 0x32, 0x33, 0x62, 0x38, 0x35, 0x36, 0x36, 0x64, 0x35, 0x30, 0x37, 0x66, 0x32, 0x39, 0x65, 0x62, 0x34, 0x34, 0x66, 0x65, 0x32, 0x64, 0x32, 0x34, 0x39, 0x30, 0x65, 0x38, 0x31, 0x66, 0x34, 0x33, 0x34, 0x33, 0x63, 0x61, 0x36, 0x31, 0x63, 0x38, 0x37, 0x38, 0x33, 0x62, 0x38, 0x33, 0x65, 0x34, 0x30, 0x65, 0x33, 0x63, 0x65, 0x36, 0x36, 0x35, 0x33, 0x32, 0x66, 0x31, 0x38, 0x36, 0x65, 0x39, 0x64, 0x30, 0x39, 0x62, 0x64, 0x32, 0x36, 0x36, 0x37, 0x63, 0x66, 0x39, 0x37, 0x34, 0x61, 0x37, 0x36, 0x33, 0x30, 0x37, 0x32, 0x61, 0x39, 0x31, 0x30, 0x31, 0x32, 0x31, 0x61, 0x61, 0x35, 0x65, 0x38, 0x36, 0x65, 0x31, 0x35, 0x31, 0x64, 0x39, 0x32, 0x61, 0x38, 0x36, 0x38, 0x35, 0x30, 0x38, 0x62, 0x36, 0x38, 0x30, 0x66, 0x37, 0x39, 0x35, 0x62, 0x63, 0x33, 0x30, 0x62, 0x34, 0x35, 0x30, 0x32, 0x37, 0x36, 0x39, 0x66, 0x34, 0x31, 0x65, 0x33, 0x61, 0x66, 0x65, 0x66, 0x35, 0x66, 0x33, 0x32, 0x31, 0x62, 0x65, 0x39, 0x63, 0x65, 0x32, 0x66, 0x31, 0x63, 0x66, 0x66, 0x33, 0x65, 0x62, 0x33, 0x33, 0x30, 0x38, 0x64, 0x36, 0x35, 0x61, 0x61, 0x30, 0x65, 0x64, 0x37, 0x38, 0x30, 0x63, 0x63, 0x38, 0x38, 0x39, 0x66, 0x36, 0x30, 0x35, 0x66, 0x33, 0x35, 0x65, 0x62, 0x35, 0x65, 0x30, 0x32, 0x62, 0x61, 0x37, 0x37, 0x32, 0x64, 0x30, 0x38, 0x64, 0x62, 0x32, 0x35, 0x37, 0x39, 0x66, 0x38, 0x35, 0x36, 0x31, 0x63, 0x36, 0x31, 0x66, 0x61, 0x30, 0x39, 0x61, 0x38, 0x65, 0x32, 0x33, 0x65, 0x61, 0x31, 0x34, 0x31, 0x36, 0x66, 0x62, 0x39, 0x35, 0x63, 0x61, 0x30, 0x63, 0x37, 0x65, 0x31, 0x33, 0x39, 0x64, 0x64, 0x64, 0x31, 0x36, 0x66, 0x30, 0x34, 0x62, 0x30, 0x63, 0x38, 0x37, 0x32, 0x34, 0x39, 0x39, 0x65, 0x34, 0x34, 0x63, 0x62, 0x35, 0x61, 0x30, 0x33, 0x38, 0x36, 0x38, 0x64, 0x36, 0x63, 0x35, 0x66, 0x61, 0x31, 0x33, 0x30, 0x30, 0x63, 0x31, 0x39, 0x61, 0x39, 0x36, 0x62, 0x38, 0x35, 0x38, 0x36, 0x62, 0x38, 0x66, 0x33, 0x33, 0x62, 0x64, 0x37, 0x36, 0x30, 0x63, 0x36, 0x33, 0x35, 0x30, 0x37, 0x31, 0x33, 0x36, 0x39, 0x36, 0x62, 0x37, 0x64, 0x33, 0x32, 0x33, 0x36, 0x61, 0x63, 0x62, 0x30, 0x65, 0x62, 0x33, 0x35, 0x62, 0x64, 0x65, 0x32, 0x65, 0x36, 0x33, 0x37, 0x38, 0x65, 0x39, 0x65, 0x66, 0x39, 0x62, 0x31, 0x31, 0x37, 0x62, 0x30, 0x32, 0x32, 0x39, 0x30, 0x65, 0x61, 0x64, 0x37, 0x38, 0x32, 0x34, 0x64, 0x34, 0x32, 0x34, 0x35, 0x32, 0x65, 0x33, 0x33, 0x32, 0x66, 0x36, 0x65, 0x63, 0x39, 0x35, 0x61, 0x37, 0x66, 0x38, 0x37, 0x31, 0x64, 0x61, 0x39, 0x65, 0x62, 0x64, 0x66, 0x36, 0x61, 0x64, 0x30, 0x32, 0x63, 0x39, 0x35, 0x39, 0x61, 0x31, 0x61, 0x33, 0x36, 0x62, 0x61, 0x33, 0x33, 0x66, 0x66, 0x30, 0x30, 0x38, 0x39, 0x61, 0x34, 0x66, 0x35, 0x32, 0x31, 0x37, 0x62, 0x37, 0x62, 0x66, 0x61, 0x35, 0x33, 0x37, 0x39, 0x61, 0x35, 0x30, 0x37, 0x62, 0x31, 0x65, 0x39, 0x39, 0x34, 0x66, 0x62, 0x37, 0x62, 0x38, 0x66, 0x65, 0x66, 0x34, 0x38, 0x39, 0x66, 0x31, 0x66, 0x32, 0x63, 0x66, 0x36, 0x66, 0x64, 0x65, 0x64, 0x66, 0x30, 0x65, 0x35, 0x33, 0x30, 0x36, 0x33, 0x35, 0x65, 0x66, 0x33, 0x31, 0x66, 0x61, 0x61, 0x61, 0x31, 0x61, 0x33, 0x37, 0x34, 0x35, 0x37, 0x63, 0x34, 0x34, 0x35, 0x38, 0x33, 0x36, 0x33, 0x37, 0x36, 0x64, 0x63, 0x35, 0x63, 0x64, 0x65, 0x66, 0x63, 0x37, 0x37, 0x37, 0x30, 0x66, 0x62, 0x62, 0x61, 0x64, 0x38, 0x63, 0x33, 0x32, 0x36, 0x39, 0x35, 0x35, 0x36, 0x35, 0x35, 0x65, 0x66, 0x65, 0x34, 0x65, 0x63, 0x64, 0x65, 0x38, 0x39, 0x62, 0x64, 0x32, 0x66, 0x31, 0x64, 0x63, 0x36, 0x32, 0x61, 0x32, 0x35, 0x35, 0x31, 0x61, 0x34, 0x35, 0x32, 0x30, 0x36, 0x66, 0x64, 0x37, 0x64, 0x34, 0x32, 0x36, 0x30, 0x35, 0x61, 0x61, 0x31, 0x63, 0x30, 0x66, 0x63, 0x38, 0x30, 0x34, 0x37, 0x36, 0x62, 0x37, 0x34, 0x31, 0x62, 0x64, 0x37, 0x64, 0x66, 0x31, 0x66, 0x30, 0x66, 0x32, 0x64, 0x62, 0x30, 0x66, 0x63, 0x33, 0x38, 0x37, 0x36, 0x31, 0x34, 0x32, 0x34, 0x30, 0x65, 0x37, 0x38, 0x34, 0x32, 0x37, 0x62, 0x62, 0x33, 0x61, 0x38, 0x63, 0x62, 0x62, 0x61, 0x66, 0x39, 0x62, 0x62, 0x31, 0x31, 0x32, 0x64, 0x61, 0x30, 0x36, 0x65, 0x61, 0x36, 0x39, 0x34, 0x32, 0x33, 0x33, 0x35, 0x66, 0x38, 0x38, 0x63, 0x36, 0x35, 0x64, 0x34, 0x32, 0x64, 0x31, 0x37, 0x38, 0x31, 0x36, 0x31, 0x33, 0x36, 0x35, 0x30, 0x39, 0x65, 0x63, 0x33, 0x39, 0x62, 0x35, 0x31, 0x30, 0x37, 0x39, 0x62, 0x35, 0x65, 0x62, 0x32, 0x61, 0x38, 0x63, 0x64, 0x31, 0x35, 0x63, 0x33, 0x64, 0x31, 0x66, 0x62, 0x63, 0x35, 0x36, 0x64, 0x64, 0x37, 0x32, 0x63, 0x33, 0x34, 0x39, 0x39, 0x63, 0x31, 0x30, 0x31, 0x65, 0x32, 0x66, 0x63, 0x39, 0x31, 0x32, 0x36, 0x65, 0x38, 0x66, 0x31, 0x39, 0x34, 0x63, 0x36, 0x63, 0x38, 0x30, 0x30, 0x36, 0x66, 0x61, 0x65, 0x66, 0x33, 0x30, 0x39, 0x31, 0x37, 0x63, 0x35, 0x65, 0x35, 0x33, 0x35, 0x34, 0x33, 0x39, 0x63, 0x36, 0x62, 0x30, 0x64, 0x37, 0x38, 0x62, 0x65, 0x35, 0x32, 0x61, 0x34, 0x64, 0x31, 0x37, 0x61, 0x33, 0x61, 0x32, 0x35, 0x64, 0x30, 0x38, 0x37, 0x38, 0x36, 0x34, 0x39, 0x62, 0x36, 0x36, 0x38, 0x64, 0x62, 0x30, 0x32, 0x37, 0x65, 0x65, 0x63, 0x62, 0x62, 0x61, 0x66, 0x63, 0x66, 0x61, 0x63, 0x37, 0x61, 0x36, 0x31, 0x32, 0x31, 0x33, 0x38, 0x63, 0x37, 0x37, 0x64, 0x31, 0x35, 0x31, 0x31, 0x66, 0x39, 0x63, 0x63, 0x35, 0x65, 0x37, 0x36, 0x33, 0x65, 0x61, 0x64, 0x64, 0x62, 0x61, 0x64, 0x36, 0x64, 0x39, 0x64, 0x38, 0x37, 0x37, 0x30, 0x37, 0x30, 0x35, 0x65, 0x66, 0x37, 0x62, 0x34, 0x64, 0x30, 0x36, 0x32, 0x62, 0x34, 0x63, 0x36, 0x64, 0x63, 0x37, 0x32, 0x66, 0x33, 0x30, 0x64, 0x31, 0x64, 0x32, 0x37, 0x32, 0x64, 0x63, 0x61, 0x38, 0x37, 0x30, 0x30, 0x61, 0x65, 0x30, 0x33, 0x61, 0x34, 0x63, 0x36, 0x64, 0x32, 0x63, 0x63, 0x36, 0x61, 0x30, 0x61, 0x30, 0x33, 0x66, 0x39, 0x62, 0x66, 0x62, 0x32, 0x36, 0x31, 0x35, 0x62, 0x32, 0x62, 0x32, 0x39, 0x34, 0x35, 0x31, 0x35, 0x63, 0x61, 0x38, 0x30, 0x38, 0x32, 0x37, 0x65, 0x63, 0x39, 0x63, 0x62, 0x61, 0x61, 0x37, 0x37, 0x34, 0x36, 0x31, 0x31, 0x32, 0x35, 0x33, 0x30, 0x66, 0x35, 0x65, 0x37, 0x30, 0x66, 0x32, 0x33, 0x36, 0x61, 0x36, 0x34, 0x31, 0x63, 0x30, 0x35, 0x62, 0x62, 0x63, 0x38, 0x36, 0x34, 0x37, 0x64, 0x64, 0x31, 0x33, 0x30, 0x66, 0x30, 0x32, 0x64, 0x62, 0x33, 0x35, 0x36, 0x31, 0x66, 0x39, 0x64, 0x66, 0x61, 0x61, 0x31, 0x64, 0x36, 0x38, 0x37, 0x32, 0x33, 0x35, 0x62, 0x63, 0x63, 0x62, 0x30, 0x34, 0x39, 0x38, 0x32, 0x30, 0x32, 0x61, 0x66, 0x34, 0x37, 0x38, 0x61, 0x36, 0x30, 0x37, 0x30, 0x64, 0x66, 0x61, 0x34, 0x39, 0x64, 0x66, 0x39, 0x39, 0x37, 0x38, 0x35, 0x61, 0x36, 0x31, 0x65, 0x62, 0x35, 0x66, 0x65, 0x35, 0x66, 0x31, 0x38, 0x37, 0x37, 0x37, 0x35, 0x36, 0x39, 0x63, 0x31, 0x38, 0x62, 0x30, 0x38, 0x64, 0x32, 0x30, 0x34, 0x32, 0x61, 0x65, 0x38, 0x36, 0x33, 0x39, 0x61, 0x62, 0x62, 0x63, 0x32, 0x32, 0x35, 0x62, 0x38, 0x33, 0x32, 0x61, 0x32, 0x66, 0x62, 0x63, 0x64, 0x39, 0x35, 0x66, 0x66, 0x34, 0x33, 0x61, 0x33, 0x66, 0x65, 0x65, 0x34, 0x66, 0x62, 0x32, 0x39, 0x36, 0x32, 0x39, 0x38, 0x33, 0x61, 0x66, 0x38, 0x33, 0x30, 0x34, 0x65, 0x66, 0x39, 0x39, 0x35, 0x37, 0x31, 0x36, 0x31, 0x31, 0x30, 0x61, 0x37, 0x61, 0x64, 0x33, 0x35, 0x63, 0x35, 0x33, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x30, 0x39, 0x63, 0x30, 0x31, 0x63, 0x34, 0x32, 0x37, 0x63, 0x61, 0x36, 0x63, 0x65, 0x66, 0x65, 0x66, 0x33, 0x61, 0x38, 0x34, 0x32, 0x66, 0x63, 0x66, 0x37, 0x34, 0x62, 0x31, 0x63, 0x34, 0x39, 0x61, 0x33, 0x66, 0x32, 0x64, 0x61, 0x38, 0x38, 0x62, 0x38, 0x35, 0x66, 0x64, 0x62, 0x31, 0x64, 0x30, 0x35, 0x65, 0x32, 0x30, 0x63, 0x64, 0x35, 0x36, 0x37, 0x35, 0x33, 0x38, 0x39, 0x34, 0x32, 0x66, 0x61, 0x32, 0x66, 0x30, 0x66, 0x66, 0x62, 0x62, 0x35, 0x64, 0x32, 0x66, 0x66, 0x37, 0x33, 0x64, 0x36, 0x30, 0x64, 0x35, 0x36, 0x32, 0x64, 0x39, 0x61, 0x30, 0x61, 0x36, 0x38, 0x39, 0x34, 0x62, 0x65, 0x63, 0x33, 0x64, 0x38, 0x35, 0x61, 0x37, 0x30, 0x39, 0x62, 0x34, 0x33, 0x65, 0x34, 0x32, 0x61, 0x62, 0x36, 0x34, 0x65, 0x32, 0x33, 0x30, 0x36, 0x63, 0x62, 0x39, 0x36, 0x39, 0x31, 0x39, 0x65, 0x30, 0x37, 0x38, 0x62, 0x38, 0x39, 0x39, 0x66, 0x33, 0x31, 0x35, 0x35, 0x61, 0x66, 0x35, 0x36, 0x33, 0x39, 0x30, 0x64, 0x30, 0x36, 0x64, 0x64, 0x63, 0x36, 0x36, 0x32, 0x61, 0x66, 0x65, 0x38, 0x64, 0x32, 0x63, 0x39, 0x31, 0x66, 0x63, 0x30, 0x39, 0x31, 0x65, 0x32, 0x63, 0x35, 0x63, 0x62, 0x62, 0x66, 0x61, 0x62, 0x33, 0x66, 0x64, 0x62, 0x33, 0x66, 0x34, 0x39, 0x34, 0x32, 0x33, 0x61, 0x35, 0x61, 0x35, 0x66, 0x37, 0x37, 0x34, 0x31, 0x66, 0x32, 0x64, 0x37, 0x30, 0x63, 0x36, 0x37, 0x33, 0x36, 0x61, 0x64, 0x63, 0x36, 0x36, 0x65, 0x37, 0x63, 0x32, 0x63, 0x61, 0x61, 0x38, 0x39, 0x63, 0x36, 0x62, 0x62, 0x63, 0x36, 0x37, 0x38, 0x62, 0x62, 0x34, 0x62, 0x34, 0x34, 0x35, 0x61, 0x38, 0x61, 0x36, 0x33, 0x64, 0x31, 0x32, 0x30, 0x38, 0x36, 0x37, 0x66, 0x30, 0x31, 0x66, 0x31, 0x36, 0x34, 0x64, 0x63, 0x38, 0x37, 0x61, 0x64, 0x63, 0x38, 0x35, 0x33, 0x36, 0x33, 0x33, 0x63, 0x61, 0x37, 0x62, 0x64, 0x34, 0x62, 0x39, 0x64, 0x35, 0x38, 0x35, 0x63, 0x32, 0x61, 0x36, 0x33, 0x37, 0x64, 0x31, 0x34, 0x36, 0x39, 0x64, 0x61, 0x36, 0x31, 0x32, 0x62, 0x35, 0x32, 0x31, 0x30, 0x34, 0x37, 0x36, 0x66, 0x63, 0x38, 0x64, 0x36, 0x36, 0x66, 0x39, 0x30, 0x30, 0x32, 0x39, 0x62, 0x64, 0x62, 0x66, 0x37, 0x66, 0x61, 0x35, 0x65, 0x64, 0x64, 0x63, 0x38, 0x33, 0x33, 0x35, 0x63, 0x64, 0x32, 0x33, 0x64, 0x65, 0x62, 0x34, 0x62, 0x62, 0x34, 0x37, 0x65, 0x31, 0x35, 0x38, 0x32, 0x65, 0x36, 0x34, 0x61, 0x30, 0x33, 0x64, 0x64, 0x30, 0x32, 0x31, 0x32, 0x39, 0x32, 0x64, 0x33, 0x34, 0x34, 0x33, 0x35, 0x34, 0x31, 0x39, 0x61, 0x66, 0x38, 0x30, 0x61, 0x66, 0x31, 0x37, 0x38, 0x63, 0x64, 0x66, 0x61, 0x62, 0x30, 0x66, 0x62, 0x39, 0x33, 0x37, 0x34, 0x66, 0x61, 0x30, 0x66, 0x61, 0x64, 0x65, 0x34, 0x38, 0x31, 0x30, 0x38, 0x63, 0x64, 0x33, 0x61, 0x35, 0x37, 0x31, 0x62, 0x38, 0x31, 0x34, 0x32, 0x33, 0x31, 0x37, 0x38, 0x34, 0x61, 0x63, 0x33, 0x37, 0x63, 0x39, 0x66, 0x36, 0x30, 0x37, 0x31, 0x66, 0x63, 0x36, 0x61, 0x63, 0x30, 0x62, 0x62, 0x30, 0x31, 0x38, 0x35, 0x39, 0x35, 0x63, 0x39, 0x64, 0x38, 0x61, 0x66, 0x62, 0x66, 0x63, 0x64, 0x36, 0x66, 0x33, 0x31, 0x38, 0x33, 0x32, 0x62, 0x32, 0x35, 0x38, 0x31, 0x66, 0x37, 0x66, 0x37, 0x63, 0x65, 0x37, 0x63, 0x34, 0x35, 0x64, 0x32, 0x32, 0x38, 0x31, 0x37, 0x61, 0x61, 0x62, 0x38, 0x61, 0x63, 0x36, 0x64, 0x66, 0x30, 0x65, 0x30, 0x39, 0x39, 0x35, 0x65, 0x31, 0x32, 0x64, 0x62, 0x64, 0x31, 0x35, 0x39, 0x35, 0x63, 0x33, 0x33, 0x37, 0x37, 0x62, 0x37, 0x30, 0x37, 0x62, 0x38, 0x31, 0x36, 0x63, 0x39, 0x36, 0x63, 0x65, 0x62, 0x31, 0x38, 0x39, 0x33, 0x62, 0x39, 0x65, 0x37, 0x63, 0x37, 0x34, 0x37, 0x61, 0x35, 0x37, 0x37, 0x62, 0x62, 0x37, 0x35, 0x34, 0x30, 0x62, 0x38, 0x39, 0x65, 0x62, 0x33, 0x66, 0x66, 0x37, 0x63, 0x61, 0x63, 0x38, 0x37, 0x38, 0x61, 0x37, 0x61, 0x31, 0x32, 0x31, 0x61, 0x33, 0x37, 0x62, 0x33, 0x38, 0x66, 0x63, 0x64, 0x33, 0x32, 0x34, 0x38, 0x61, 0x62, 0x66, 0x64, 0x32, 0x34, 0x62, 0x35, 0x30, 0x65, 0x32, 0x35, 0x39, 0x34, 0x38, 0x64, 0x63, 0x61, 0x65, 0x66, 0x66, 0x38, 0x63, 0x31, 0x63, 0x37, 0x61, 0x62, 0x38, 0x62, 0x37, 0x34, 0x35, 0x61, 0x39, 0x33, 0x61, 0x64, 0x62, 0x38, 0x37, 0x63, 0x64, 0x35, 0x34, 0x66, 0x63, 0x61, 0x32, 0x32, 0x33, 0x64, 0x64, 0x39, 0x34, 0x30, 0x65, 0x66, 0x34, 0x64, 0x37, 0x65, 0x63, 0x61, 0x39, 0x64, 0x64, 0x36, 0x39, 0x32, 0x34, 0x33, 0x63, 0x37, 0x34, 0x65, 0x61, 0x31, 0x32, 0x38, 0x65, 0x64, 0x36, 0x32, 0x34, 0x65, 0x35, 0x32, 0x63, 0x37, 0x61, 0x32, 0x32, 0x35, 0x37, 0x66, 0x33, 0x39, 0x35, 0x30, 0x64, 0x30, 0x63, 0x37, 0x34, 0x30, 0x39, 0x64, 0x36, 0x36, 0x35, 0x64, 0x39, 0x31, 0x32, 0x34, 0x39, 0x35, 0x66, 0x38, 0x61, 0x38, 0x61, 0x32, 0x63, 0x66, 0x32, 0x34, 0x38, 0x32, 0x63, 0x31, 0x64, 0x35, 0x31, 0x63, 0x64, 0x37, 0x37, 0x39, 0x33, 0x64, 0x33, 0x64, 0x33, 0x31, 0x66, 0x33, 0x32, 0x66, 0x66, 0x63, 0x32, 0x34, 0x33, 0x37, 0x34, 0x64, 0x38, 0x36, 0x30, 0x36, 0x64, 0x61, 0x61, 0x32, 0x61, 0x34, 0x32, 0x33, 0x39, 0x33, 0x31, 0x64, 0x39, 0x37, 0x30, 0x31, 0x39, 0x62, 0x61, 0x32, 0x66, 0x64, 0x33, 0x62, 0x61, 0x37, 0x37, 0x33, 0x36, 0x34, 0x35, 0x62, 0x37, 0x66, 0x64, 0x30, 0x31, 0x63, 0x66, 0x37, 0x35, 0x65, 0x38, 0x32, 0x30, 0x31, 0x64, 0x64, 0x32, 0x39, 0x66, 0x36, 0x39, 0x34, 0x61, 0x37, 0x32, 0x31, 0x33, 0x36, 0x62, 0x35, 0x38, 0x35, 0x64, 0x39, 0x34, 0x30, 0x62, 0x66, 0x66, 0x38, 0x38, 0x36, 0x37, 0x36, 0x35, 0x34, 0x32, 0x32, 0x33, 0x63, 0x32, 0x38, 0x64, 0x30, 0x36, 0x30, 0x33, 0x64, 0x38, 0x35, 0x66, 0x65, 0x34, 0x34, 0x37, 0x32, 0x64, 0x39, 0x33, 0x65, 0x65, 0x33, 0x30, 0x65, 0x33, 0x35, 0x66, 0x34, 0x36, 0x65, 0x32, 0x37, 0x62, 0x38, 0x66, 0x34, 0x30, 0x66, 0x39, 0x61, 0x39, 0x61, 0x64, 0x30, 0x33, 0x39, 0x39, 0x32, 0x64, 0x39, 0x66, 0x66, 0x32, 0x33, 0x33, 0x30, 0x35, 0x66, 0x63, 0x30, 0x36, 0x32, 0x63, 0x37, 0x64, 0x39, 0x35, 0x39, 0x37, 0x31, 0x62, 0x61, 0x61, 0x65, 0x31, 0x61, 0x62, 0x30, 0x37, 0x34, 0x64, 0x66, 0x38, 0x38, 0x64, 0x34, 0x31, 0x65, 0x30, 0x39, 0x65, 0x63, 0x39, 0x37, 0x35, 0x32, 0x65, 0x66, 0x66, 0x66, 0x30, 0x31, 0x32, 0x63, 0x34, 0x38, 0x32, 0x65, 0x30, 0x63, 0x66, 0x39, 0x61, 0x65, 0x61, 0x32, 0x62, 0x37, 0x38, 0x63, 0x63, 0x32, 0x36, 0x64, 0x62, 0x31, 0x34, 0x36, 0x61, 0x32, 0x37, 0x38, 0x64, 0x35, 0x38, 0x34, 0x35, 0x37, 0x35, 0x65, 0x64, 0x36, 0x31, 0x35, 0x66, 0x35, 0x64, 0x31, 0x36, 0x38, 0x65, 0x36, 0x64, 0x66, 0x37, 0x61, 0x38, 0x33, 0x32, 0x33, 0x32, 0x32, 0x64, 0x61, 0x30, 0x39, 0x33, 0x66, 0x30, 0x61, 0x65, 0x61, 0x37, 0x30, 0x36, 0x63, 0x65, 0x65, 0x35, 0x39, 0x34, 0x32, 0x30, 0x37, 0x34, 0x32, 0x37, 0x64, 0x33, 0x30, 0x30, 0x35, 0x66, 0x64, 0x39, 0x31, 0x30, 0x38, 0x34, 0x33, 0x66, 0x33, 0x64, 0x63, 0x35, 0x34, 0x62, 0x31, 0x34, 0x66, 0x38, 0x62, 0x31, 0x38, 0x37, 0x65, 0x33, 0x62, 0x34, 0x39, 0x35, 0x62, 0x37, 0x34, 0x37, 0x34, 0x37, 0x39, 0x32, 0x37, 0x34, 0x33, 0x66, 0x63, 0x32, 0x65, 0x34, 0x33, 0x66, 0x36, 0x32, 0x62, 0x62, 0x63, 0x37, 0x66, 0x64, 0x35, 0x30, 0x61, 0x37, 0x36, 0x35, 0x31, 0x33, 0x66, 0x31, 0x66, 0x61, 0x34, 0x30, 0x37, 0x33, 0x62, 0x31, 0x35, 0x61, 0x34, 0x32, 0x64, 0x31, 0x65, 0x37, 0x38, 0x61, 0x37, 0x30, 0x38, 0x31, 0x33, 0x34, 0x32, 0x33, 0x38, 0x66, 0x32, 0x35, 0x32, 0x31, 0x63, 0x37, 0x34, 0x39, 0x64, 0x30, 0x38, 0x36, 0x64, 0x65, 0x65, 0x65, 0x66, 0x35, 0x31, 0x32, 0x38, 0x32, 0x33, 0x62, 0x35, 0x31, 0x34, 0x61, 0x61, 0x36, 0x34, 0x31, 0x32, 0x32, 0x62, 0x33, 0x36, 0x35, 0x65, 0x66, 0x64, 0x35, 0x31, 0x65, 0x31, 0x31, 0x34, 0x31, 0x35, 0x64, 0x65, 0x34, 0x30, 0x38, 0x32, 0x36, 0x39, 0x37, 0x31, 0x63, 0x32, 0x33, 0x34, 0x64, 0x35, 0x37, 0x31, 0x63, 0x33, 0x65, 0x32, 0x61, 0x30, 0x35, 0x30, 0x37, 0x32, 0x32, 0x36, 0x63, 0x36, 0x63, 0x63, 0x63, 0x35, 0x34, 0x30, 0x65, 0x34, 0x33, 0x61, 0x39, 0x61, 0x61, 0x33, 0x32, 0x32, 0x34, 0x34, 0x62, 0x32, 0x39, 0x37, 0x38, 0x34, 0x61, 0x63, 0x38, 0x32, 0x34, 0x63, 0x32, 0x30, 0x64, 0x33, 0x64, 0x31, 0x62, 0x37, 0x32, 0x64, 0x63, 0x37, 0x32, 0x36, 0x32, 0x66, 0x36, 0x31, 0x63, 0x63, 0x65, 0x34, 0x65, 0x65, 0x66, 0x62, 0x65, 0x39, 0x61, 0x34, 0x65, 0x61, 0x34, 0x63, 0x62, 0x31, 0x30, 0x36, 0x31, 0x65, 0x34, 0x61, 0x37, 0x31, 0x39, 0x32, 0x35, 0x61, 0x61, 0x31, 0x33, 0x66, 0x33, 0x31, 0x64, 0x36, 0x63, 0x65, 0x38, 0x30, 0x62, 0x62, 0x37, 0x63, 0x35, 0x36, 0x62, 0x66, 0x34, 0x37, 0x62, 0x39, 0x31, 0x63, 0x66, 0x31, 0x30, 0x37, 0x61, 0x62, 0x31, 0x37, 0x31, 0x36, 0x38, 0x64, 0x64, 0x34, 0x66, 0x62, 0x36, 0x30, 0x36, 0x31, 0x34, 0x37, 0x35, 0x37, 0x64, 0x37, 0x63, 0x37, 0x66, 0x34, 0x65, 0x62, 0x65, 0x30, 0x33, 0x32, 0x30, 0x36, 0x39, 0x32, 0x32, 0x33, 0x35, 0x66, 0x62, 0x35, 0x30, 0x32, 0x36, 0x32, 0x31, 0x65, 0x64, 0x39, 0x62, 0x31, 0x35, 0x62, 0x39, 0x62, 0x33, 0x66, 0x61, 0x32, 0x33, 0x61, 0x61, 0x31, 0x62, 0x66, 0x32, 0x36, 0x36, 0x61, 0x32, 0x61, 0x32, 0x63, 0x33, 0x66, 0x32, 0x33, 0x38, 0x36, 0x62, 0x35, 0x32, 0x36, 0x32, 0x35, 0x65, 0x34, 0x32, 0x65, 0x30, 0x63, 0x64, 0x38, 0x35, 0x63, 0x33, 0x37, 0x33, 0x31, 0x39, 0x65, 0x33, 0x32, 0x36, 0x36, 0x31, 0x38, 0x35, 0x34, 0x31, 0x39, 0x62, 0x63, 0x66, 0x36, 0x64, 0x65, 0x61, 0x39, 0x39, 0x37, 0x65, 0x35, 0x32, 0x65, 0x63, 0x38, 0x66, 0x63, 0x61, 0x35, 0x38, 0x38, 0x37, 0x61, 0x36, 0x38, 0x35, 0x33, 0x30, 0x30, 0x30, 0x32, 0x66, 0x63, 0x63, 0x35, 0x62, 0x33, 0x36, 0x31, 0x39, 0x65, 0x38, 0x38, 0x64, 0x34, 0x64, 0x63, 0x39, 0x61, 0x39, 0x31, 0x38, 0x63, 0x63, 0x33, 0x36, 0x62, 0x61, 0x63, 0x32, 0x34, 0x31, 0x36, 0x66, 0x66, 0x61, 0x39, 0x62, 0x39, 0x37, 0x33, 0x34, 0x61, 0x63, 0x34, 0x65, 0x36, 0x37, 0x61, 0x39, 0x33, 0x61, 0x38, 0x30, 0x30, 0x66, 0x33, 0x36, 0x64, 0x37, 0x61, 0x62, 0x61, 0x34, 0x65, 0x63, 0x66, 0x65, 0x64, 0x38, 0x64, 0x36, 0x35, 0x66, 0x36, 0x32, 0x63, 0x66, 0x36, 0x61, 0x64, 0x31, 0x33, 0x64, 0x31, 0x38, 0x34, 0x61, 0x38, 0x63, 0x36, 0x34, 0x30, 0x36, 0x65, 0x33, 0x62, 0x61, 0x31, 0x37, 0x62, 0x38, 0x61, 0x65, 0x65, 0x36, 0x61, 0x66, 0x30, 0x37, 0x32, 0x31, 0x65, 0x64, 0x30, 0x39, 0x31, 0x65, 0x31, 0x64, 0x32, 0x32, 0x35, 0x64, 0x30, 0x34, 0x34, 0x36, 0x32, 0x39, 0x61, 0x34, 0x65, 0x66, 0x35, 0x31, 0x35, 0x33, 0x63, 0x32, 0x39, 0x34, 0x61, 0x33, 0x65, 0x38, 0x37, 0x65, 0x32, 0x34, 0x33, 0x65, 0x30, 0x33, 0x62, 0x64, 0x63, 0x66, 0x36, 0x65, 0x61, 0x66, 0x37, 0x65, 0x65, 0x35, 0x36, 0x64, 0x39, 0x64, 0x39, 0x36, 0x39, 0x61, 0x31, 0x66, 0x30, 0x35, 0x34, 0x64, 0x35, 0x37, 0x37, 0x34, 0x61, 0x37, 0x65, 0x32, 0x63, 0x33, 0x36, 0x33, 0x62, 0x31, 0x36, 0x30, 0x33, 0x38, 0x36, 0x62, 0x39, 0x30, 0x39, 0x63, 0x38, 0x39, 0x37, 0x31, 0x37, 0x61, 0x61, 0x37, 0x30, 0x31, 0x35, 0x33, 0x38, 0x35, 0x66, 0x34, 0x61, 0x62, 0x38, 0x62, 0x36, 0x63, 0x39, 0x37, 0x38, 0x30, 0x35, 0x63, 0x31, 0x32, 0x63, 0x33, 0x37, 0x64, 0x39, 0x38, 0x31, 0x63, 0x61, 0x39, 0x34, 0x35, 0x31, 0x33, 0x34, 0x63, 0x62, 0x31, 0x33, 0x30, 0x36, 0x64, 0x33, 0x39, 0x61, 0x34, 0x64, 0x31, 0x33, 0x36, 0x62, 0x34, 0x32, 0x63, 0x33, 0x36, 0x64, 0x38, 0x61, 0x61, 0x63, 0x64, 0x32, 0x63, 0x33, 0x37, 0x35, 0x37, 0x35, 0x61, 0x31, 0x31, 0x62, 0x31, 0x37, 0x66, 0x61, 0x35, 0x30, 0x65, 0x64, 0x65, 0x38, 0x30, 0x37, 0x32, 0x64, 0x36, 0x36, 0x37, 0x66, 0x36, 0x34, 0x62, 0x62, 0x35, 0x35, 0x65, 0x33, 0x62, 0x35, 0x34, 0x61, 0x66, 0x66, 0x32, 0x63, 0x33, 0x63, 0x36, 0x31, 0x37, 0x38, 0x32, 0x65, 0x34, 0x34, 0x32, 0x65, 0x30, 0x38, 0x38, 0x64, 0x62, 0x37, 0x63, 0x31, 0x63, 0x65, 0x36, 0x32, 0x32, 0x38, 0x37, 0x34, 0x37, 0x37, 0x31, 0x33, 0x32, 0x62, 0x65, 0x66, 0x30, 0x30, 0x63, 0x31, 0x37, 0x65, 0x39, 0x39, 0x39, 0x32, 0x64, 0x64, 0x34, 0x32, 0x66, 0x33, 0x35, 0x62, 0x35, 0x65, 0x30, 0x39, 0x38, 0x65, 0x62, 0x39, 0x37, 0x37, 0x32, 0x34, 0x66, 0x63, 0x34, 0x65, 0x36, 0x39, 0x37, 0x64, 0x37, 0x35, 0x38, 0x31, 0x32, 0x36, 0x33, 0x35, 0x32, 0x30, 0x33, 0x61, 0x62, 0x65, 0x38, 0x66, 0x39, 0x36, 0x30, 0x30, 0x30, 0x64, 0x39, 0x35, 0x35, 0x33, 0x30, 0x31, 0x32, 0x62, 0x65, 0x30, 0x36, 0x35, 0x39, 0x38, 0x30, 0x66, 0x62, 0x31, 0x36, 0x64, 0x36, 0x64, 0x31, 0x63, 0x30, 0x63, 0x38, 0x30, 0x34, 0x35, 0x37, 0x35, 0x38, 0x35, 0x63, 0x36, 0x65, 0x62, 0x36, 0x39, 0x39, 0x62, 0x30, 0x65, 0x38, 0x61, 0x36, 0x65, 0x33, 0x36, 0x63, 0x31, 0x63, 0x64, 0x35, 0x31, 0x38, 0x64, 0x64, 0x31, 0x66, 0x66, 0x63, 0x35, 0x31, 0x37, 0x61, 0x66, 0x63, 0x62, 0x39, 0x31, 0x31, 0x34, 0x61, 0x34, 0x66, 0x66, 0x36, 0x32, 0x39, 0x64, 0x30, 0x36, 0x63, 0x64, 0x32, 0x66, 0x30, 0x62, 0x65, 0x31, 0x34, 0x39, 0x35, 0x63, 0x34, 0x65, 0x65, 0x30, 0x39, 0x32, 0x34, 0x33, 0x65, 0x39, 0x36, 0x35, 0x32, 0x39, 0x65, 0x36, 0x63, 0x33, 0x61, 0x32, 0x32, 0x38, 0x63, 0x39, 0x32, 0x33, 0x63, 0x61, 0x32, 0x61, 0x37, 0x30, 0x33, 0x39, 0x33, 0x30, 0x65, 0x61, 0x39, 0x34, 0x66, 0x37, 0x61, 0x35, 0x38, 0x30, 0x33, 0x36, 0x34, 0x35, 0x33, 0x32, 0x34, 0x62, 0x61, 0x39, 0x65, 0x61, 0x31, 0x61, 0x30, 0x38, 0x65, 0x36, 0x63, 0x33, 0x32, 0x34, 0x31, 0x66, 0x65, 0x35, 0x37, 0x61, 0x38, 0x30, 0x62, 0x64, 0x32, 0x34, 0x66, 0x37, 0x38, 0x30, 0x35, 0x36, 0x36, 0x33, 0x34, 0x32, 0x35, 0x36, 0x31, 0x31, 0x38, 0x39, 0x62, 0x61, 0x65, 0x64, 0x31, 0x35, 0x65, 0x38, 0x35, 0x62, 0x61, 0x39, 0x32, 0x35, 0x37, 0x62, 0x37, 0x30, 0x31, 0x64, 0x36, 0x35, 0x31, 0x37, 0x35, 0x34, 0x66, 0x66, 0x35, 0x33, 0x34, 0x65, 0x35, 0x31, 0x32, 0x37, 0x39, 0x39, 0x36, 0x31, 0x66, 0x66, 0x33, 0x37, 0x39, 0x39, 0x37, 0x34, 0x65, 0x33, 0x34, 0x30, 0x31, 0x30, 0x64, 0x38, 0x30, 0x37, 0x37, 0x33, 0x62, 0x31, 0x36, 0x39, 0x61, 0x31, 0x34, 0x30, 0x65, 0x30, 0x65, 0x65, 0x37, 0x63, 0x35, 0x65, 0x32, 0x63, 0x30, 0x33, 0x31, 0x32, 0x63, 0x39, 0x64, 0x65, 0x65, 0x34, 0x36, 0x66, 0x62, 0x37, 0x62, 0x33, 0x30, 0x39, 0x37, 0x31, 0x30, 0x64, 0x34, 0x34, 0x38, 0x61, 0x34, 0x33, 0x38, 0x30, 0x35, 0x63, 0x37, 0x65, 0x61, 0x62, 0x35, 0x31, 0x33, 0x65, 0x38, 0x34, 0x65, 0x33, 0x34, 0x36, 0x34, 0x31, 0x31, 0x62, 0x37, 0x31, 0x34, 0x35, 0x66, 0x37, 0x37, 0x66, 0x66, 0x34, 0x63, 0x65, 0x64, 0x37, 0x62, 0x33, 0x32, 0x65, 0x62, 0x36, 0x34, 0x31, 0x35, 0x32, 0x38, 0x66, 0x37, 0x38, 0x64, 0x38, 0x38, 0x61, 0x66, 0x30, 0x66, 0x65, 0x38, 0x38, 0x65, 0x30, 0x38, 0x34, 0x30, 0x65, 0x39, 0x63, 0x31, 0x36, 0x66, 0x32, 0x32, 0x31, 0x30, 0x65, 0x31, 0x38, 0x63, 0x31, 0x64, 0x61, 0x36, 0x30, 0x35, 0x62, 0x62, 0x30, 0x34, 0x61, 0x34, 0x63, 0x39, 0x36, 0x33, 0x34, 0x34, 0x31, 0x63, 0x30, 0x36, 0x66, 0x61, 0x38, 0x33, 0x39, 0x66, 0x37, 0x32, 0x32, 0x62, 0x30, 0x63, 0x36, 0x37, 0x33, 0x34, 0x35, 0x31, 0x36, 0x38, 0x62, 0x63, 0x30, 0x66, 0x62, 0x62, 0x31, 0x63, 0x38, 0x32, 0x36, 0x66, 0x32, 0x30, 0x34, 0x37, 0x32, 0x63, 0x37, 0x35, 0x35, 0x31, 0x61, 0x31, 0x33, 0x32, 0x37, 0x65, 0x61, 0x65, 0x39, 0x65, 0x64, 0x64, 0x62, 0x63, 0x32, 0x34, 0x65, 0x36, 0x33, 0x38, 0x31, 0x34, 0x66, 0x62, 0x38, 0x31, 0x33, 0x32, 0x30, 0x63, 0x62, 0x63, 0x36, 0x66, 0x30, 0x33, 0x34, 0x38, 0x38, 0x64, 0x36, 0x34, 0x35, 0x38, 0x37, 0x66, 0x33, 0x65, 0x35, 0x66, 0x35, 0x33, 0x63, 0x30, 0x33, 0x64, 0x62, 0x30, 0x32, 0x63, 0x62, 0x31, 0x35, 0x34, 0x31, 0x32, 0x65, 0x36, 0x32, 0x32, 0x66, 0x39, 0x65, 0x63, 0x39, 0x39, 0x34, 0x34, 0x36, 0x34, 0x33, 0x64, 0x34, 0x62, 0x35, 0x35, 0x33, 0x30, 0x62, 0x30, 0x63, 0x64, 0x34, 0x64, 0x35, 0x37, 0x37, 0x34, 0x38, 0x39, 0x64, 0x38, 0x65, 0x65, 0x34, 0x39, 0x39, 0x65, 0x63, 0x66, 0x32, 0x62, 0x37, 0x34, 0x66, 0x62, 0x37, 0x32, 0x34, 0x32, 0x33, 0x34, 0x31, 0x32, 0x61, 0x63, 0x61, 0x38, 0x35, 0x33, 0x30, 0x66, 0x65, 0x35, 0x33, 0x63, 0x33, 0x66, 0x63, 0x35, 0x38, 0x34, 0x65, 0x64, 0x38, 0x65, 0x33, 0x39, 0x66, 0x39, 0x30, 0x30, 0x38, 0x34, 0x33, 0x61, 0x63, 0x37, 0x33, 0x65, 0x33, 0x36, 0x66, 0x62, 0x31, 0x31, 0x33, 0x63, 0x33, 0x34, 0x33, 0x63, 0x63, 0x31, 0x39, 0x37, 0x63, 0x64, 0x36, 0x38, 0x39, 0x61, 0x30, 0x39, 0x65, 0x31, 0x32, 0x66, 0x32, 0x39, 0x32, 0x30, 0x33, 0x63, 0x31, 0x64, 0x66, 0x65, 0x38, 0x33, 0x39, 0x36, 0x33, 0x30, 0x66, 0x36, 0x39, 0x33, 0x32, 0x66, 0x33, 0x61, 0x32, 0x39, 0x64, 0x65, 0x38, 0x31, 0x62, 0x61, 0x37, 0x38, 0x37, 0x66, 0x36, 0x30, 0x34, 0x34, 0x65, 0x37, 0x30, 0x64, 0x66, 0x66, 0x38, 0x39, 0x38, 0x31, 0x62, 0x37, 0x31, 0x66, 0x65, 0x38, 0x32, 0x66, 0x38, 0x61, 0x34, 0x64, 0x30, 0x31, 0x66, 0x34, 0x35, 0x37, 0x37, 0x30, 0x61, 0x35, 0x33, 0x62, 0x30, 0x39, 0x30, 0x30, 0x32, 0x36, 0x61, 0x30, 0x30, 0x33, 0x62, 0x33, 0x65, 0x36, 0x33, 0x39, 0x65, 0x63, 0x61, 0x30, 0x65, 0x36, 0x61, 0x31, 0x65, 0x35, 0x62, 0x64, 0x64, 0x30, 0x61, 0x61, 0x64, 0x34, 0x35, 0x36, 0x65, 0x38, 0x39, 0x64, 0x38, 0x33, 0x30, 0x31, 0x32, 0x65, 0x61, 0x31, 0x66, 0x35, 0x33, 0x65, 0x31, 0x61, 0x35, 0x66, 0x65, 0x38, 0x34, 0x38, 0x62, 0x33, 0x33, 0x35, 0x32, 0x38, 0x66, 0x37, 0x31, 0x39, 0x35, 0x61, 0x37, 0x62, 0x30, 0x63, 0x33, 0x36, 0x64, 0x34, 0x33, 0x31, 0x35, 0x66, 0x31, 0x62, 0x39, 0x36, 0x62, 0x36, 0x32, 0x64, 0x35, 0x36, 0x30, 0x33, 0x65, 0x38, 0x37, 0x61, 0x31, 0x33, 0x65, 0x31, 0x32, 0x61, 0x39, 0x37, 0x65, 0x63, 0x33, 0x33, 0x35, 0x65, 0x33, 0x39, 0x32, 0x32, 0x64, 0x34, 0x33, 0x33, 0x39, 0x64, 0x39, 0x35, 0x37, 0x35, 0x63, 0x62, 0x32, 0x36, 0x64, 0x35, 0x36, 0x39, 0x31, 0x64, 0x61, 0x37, 0x38, 0x61, 0x37, 0x33, 0x38, 0x61, 0x61, 0x35, 0x63, 0x38, 0x34, 0x61, 0x65, 0x63, 0x63, 0x32, 0x32, 0x61, 0x39, 0x33, 0x30, 0x33, 0x33, 0x61, 0x36, 0x39, 0x31, 0x32, 0x66, 0x38, 0x34, 0x33, 0x36, 0x30, 0x64, 0x31, 0x33, 0x65, 0x32, 0x65, 0x32, 0x33, 0x62, 0x30, 0x31, 0x38, 0x35, 0x62, 0x64, 0x63, 0x32, 0x63, 0x64, 0x33, 0x33, 0x31, 0x62, 0x64, 0x32, 0x36, 0x61, 0x62, 0x61, 0x62, 0x63, 0x63, 0x39, 0x31, 0x38, 0x39, 0x34, 0x39, 0x33, 0x35, 0x64, 0x62, 0x35, 0x63, 0x37, 0x65, 0x31, 0x38, 0x30, 0x30, 0x62, 0x38, 0x61, 0x31, 0x30, 0x64, 0x62, 0x38, 0x38, 0x34, 0x61, 0x37, 0x36, 0x31, 0x34, 0x63, 0x65, 0x65, 0x61, 0x39, 0x31, 0x66, 0x33, 0x38, 0x62, 0x62, 0x66, 0x36, 0x32, 0x33, 0x63, 0x35, 0x65, 0x37, 0x65, 0x37, 0x32, 0x33, 0x38, 0x65, 0x65, 0x66, 0x30, 0x36, 0x63, 0x64, 0x39, 0x66, 0x63, 0x39, 0x65, 0x34, 0x33, 0x35, 0x30, 0x37, 0x63, 0x35, 0x36, 0x65, 0x38, 0x64, 0x36, 0x32, 0x31, 0x32, 0x62, 0x37, 0x64, 0x30, 0x33, 0x65, 0x66, 0x32, 0x64, 0x62, 0x30, 0x64, 0x66, 0x63, 0x65, 0x62, 0x30, 0x34, 0x30, 0x63, 0x30, 0x62, 0x32, 0x30, 0x36, 0x65, 0x31, 0x62, 0x37, 0x65, 0x65, 0x65, 0x36, 0x61, 0x65, 0x35, 0x36, 0x34, 0x62, 0x31, 0x35, 0x65, 0x34, 0x63, 0x30, 0x32, 0x65, 0x39, 0x63, 0x33, 0x65, 0x34, 0x31, 0x37, 0x39, 0x64, 0x37, 0x38, 0x62, 0x63, 0x36, 0x38, 0x61, 0x39, 0x66, 0x62, 0x63, 0x32, 0x31, 0x36, 0x36, 0x63, 0x62, 0x38, 0x34, 0x35, 0x38, 0x33, 0x34, 0x32, 0x66, 0x32, 0x31, 0x38, 0x64, 0x63, 0x36, 0x33, 0x31, 0x37, 0x30, 0x35, 0x36, 0x30, 0x32, 0x62, 0x32, 0x65, 0x66, 0x31, 0x63, 0x36, 0x37, 0x31, 0x36, 0x64, 0x62, 0x63, 0x30, 0x38, 0x66, 0x33, 0x30, 0x38, 0x31, 0x30, 0x63, 0x39, 0x65, 0x32, 0x61, 0x62, 0x33, 0x61, 0x63, 0x37, 0x61, 0x30, 0x33, 0x65, 0x33, 0x30, 0x30, 0x65, 0x39, 0x63, 0x32, 0x31, 0x63, 0x64, 0x32, 0x61, 0x30, 0x32, 0x34, 0x30, 0x30, 0x32, 0x35, 0x65, 0x64, 0x35, 0x65, 0x64, 0x61, 0x31, 0x33, 0x65, 0x36, 0x64, 0x61, 0x61, 0x32, 0x34, 0x36, 0x32, 0x34, 0x31, 0x36, 0x36, 0x39, 0x61, 0x63, 0x66, 0x61, 0x65, 0x36, 0x35, 0x33, 0x30, 0x32, 0x64, 0x62, 0x63, 0x61, 0x35, 0x63, 0x35, 0x37, 0x39, 0x64, 0x33, 0x62, 0x35, 0x63, 0x33, 0x61, 0x34, 0x63, 0x31, 0x36, 0x61, 0x39, 0x37, 0x36, 0x32, 0x30, 0x39, 0x65, 0x32, 0x32, 0x38, 0x34, 0x35, 0x33, 0x33, 0x37, 0x66, 0x39, 0x63, 0x61, 0x30, 0x33, 0x33, 0x33, 0x32, 0x39, 0x66, 0x38, 0x34, 0x39, 0x66, 0x33, 0x63, 0x63, 0x65, 0x62, 0x63, 0x36, 0x39, 0x66, 0x66, 0x30, 0x31, 0x62, 0x33, 0x30, 0x31, 0x64, 0x39, 0x39, 0x64, 0x62, 0x65, 0x39, 0x65, 0x37, 0x39, 0x30, 0x35, 0x38, 0x66, 0x61, 0x64, 0x65, 0x36, 0x37, 0x62, 0x66, 0x38, 0x38, 0x31, 0x63, 0x37, 0x30, 0x32, 0x38, 0x33, 0x66, 0x34, 0x31, 0x65, 0x61, 0x63, 0x61, 0x31, 0x33, 0x30, 0x64, 0x31, 0x34, 0x32, 0x33, 0x65, 0x37, 0x33, 0x33, 0x63, 0x63, 0x64, 0x35, 0x32, 0x30, 0x66, 0x32, 0x36, 0x65, 0x62, 0x62, 0x65, 0x38, 0x64, 0x33, 0x30, 0x34, 0x63, 0x62, 0x62, 0x38, 0x66, 0x61, 0x32, 0x66, 0x34, 0x62, 0x66, 0x36, 0x37, 0x65, 0x32, 0x65, 0x30, 0x34, 0x31, 0x65, 0x35, 0x65, 0x39, 0x30, 0x65, 0x38, 0x34, 0x30, 0x64, 0x35, 0x35, 0x31, 0x30, 0x64, 0x33, 0x33, 0x61, 0x39, 0x66, 0x37, 0x30, 0x30, 0x32, 0x31, 0x39, 0x66, 0x62, 0x65, 0x61, 0x64, 0x36, 0x39, 0x39, 0x39, 0x30, 0x31, 0x65, 0x61, 0x33, 0x62, 0x33, 0x66, 0x38, 0x61, 0x61, 0x33, 0x64, 0x35, 0x66, 0x66, 0x30, 0x63, 0x30, 0x32, 0x38, 0x63, 0x65, 0x65, 0x65, 0x35, 0x62, 0x35, 0x65, 0x37, 0x31, 0x31, 0x63, 0x32, 0x39, 0x65, 0x37, 0x37, 0x34, 0x30, 0x62, 0x63, 0x39, 0x38, 0x66, 0x34, 0x62, 0x37, 0x38, 0x66, 0x31, 0x35, 0x66, 0x32, 0x61, 0x61, 0x31, 0x65, 0x30, 0x31, 0x34, 0x34, 0x39, 0x66, 0x31, 0x66, 0x31, 0x35, 0x65, 0x36, 0x38, 0x30, 0x32, 0x33, 0x38, 0x36, 0x31, 0x66, 0x35, 0x34, 0x30, 0x64, 0x32, 0x61, 0x65, 0x30, 0x35, 0x34, 0x31, 0x32, 0x37, 0x33, 0x63, 0x36, 0x34, 0x31, 0x39, 0x31, 0x34, 0x65, 0x61, 0x30, 0x65, 0x36, 0x61, 0x62, 0x61, 0x64, 0x62, 0x62, 0x32, 0x66, 0x31, 0x31, 0x36, 0x31, 0x38, 0x62, 0x62, 0x36, 0x37, 0x38, 0x63, 0x38, 0x62, 0x37, 0x61, 0x62, 0x66, 0x66, 0x31, 0x66, 0x36, 0x64, 0x34, 0x65, 0x39, 0x66, 0x37, 0x38, 0x39, 0x37, 0x30, 0x36, 0x63, 0x64, 0x62, 0x64, 0x38, 0x64, 0x63, 0x63, 0x31, 0x61, 0x63, 0x64, 0x34, 0x62, 0x62, 0x64, 0x35, 0x30, 0x36, 0x65, 0x34, 0x32, 0x65, 0x39, 0x32, 0x38, 0x64, 0x31, 0x33, 0x34, 0x33, 0x36, 0x36, 0x64, 0x33, 0x66, 0x33, 0x32, 0x64, 0x38, 0x63, 0x61, 0x61, 0x34, 0x62, 0x38, 0x36, 0x37, 0x33, 0x36, 0x62, 0x62, 0x30, 0x36, 0x35, 0x62, 0x31, 0x61, 0x33, 0x66, 0x38, 0x39, 0x33, 0x35, 0x34, 0x38, 0x33, 0x35, 0x62, 0x37, 0x62, 0x61, 0x35, 0x61, 0x65, 0x31, 0x65, 0x35, 0x33, 0x63, 0x63, 0x31, 0x62, 0x64, 0x39, 0x66, 0x35, 0x64, 0x66, 0x61, 0x33, 0x65, 0x30, 0x64, 0x34, 0x39, 0x63, 0x30, 0x61, 0x30, 0x61, 0x38, 0x64, 0x33, 0x32, 0x36, 0x37, 0x30, 0x63, 0x33, 0x38, 0x32, 0x37, 0x31, 0x32, 0x65, 0x33, 0x30, 0x66, 0x38, 0x66, 0x34, 0x63, 0x62, 0x38, 0x66, 0x63, 0x39, 0x38, 0x30, 0x37, 0x38, 0x35, 0x66, 0x62, 0x36, 0x30, 0x31, 0x32, 0x64, 0x66, 0x37, 0x35, 0x32, 0x65, 0x30, 0x32, 0x63, 0x39, 0x32, 0x33, 0x64, 0x33, 0x66, 0x35, 0x36, 0x66, 0x35, 0x37, 0x36, 0x34, 0x61, 0x34, 0x31, 0x36, 0x32, 0x39, 0x36, 0x34, 0x36, 0x66, 0x39, 0x66, 0x64, 0x37, 0x36, 0x34, 0x31, 0x63, 0x38, 0x33, 0x36, 0x35, 0x66, 0x30, 0x39, 0x31, 0x37, 0x66, 0x38, 0x35, 0x61, 0x36, 0x34, 0x64, 0x30, 0x62, 0x61, 0x33, 0x36, 0x31, 0x37, 0x39, 0x65, 0x32, 0x63, 0x32, 0x62, 0x33, 0x30, 0x34, 0x35, 0x64, 0x37, 0x62, 0x33, 0x63, 0x36, 0x63, 0x63, 0x66, 0x64, 0x62, 0x36, 0x30, 0x63, 0x64, 0x35, 0x63, 0x33, 0x36, 0x35, 0x63, 0x34, 0x33, 0x64, 0x38, 0x38, 0x65, 0x32, 0x33, 0x31, 0x34, 0x36, 0x35, 0x63, 0x36, 0x36, 0x31, 0x36, 0x66, 0x37, 0x64, 0x32, 0x63, 0x61, 0x62, 0x30, 0x64, 0x62, 0x38, 0x38, 0x63, 0x64, 0x37, 0x39, 0x32, 0x36, 0x38, 0x65, 0x35, 0x62, 0x61, 0x30, 0x63, 0x65, 0x63, 0x62, 0x39, 0x38, 0x38, 0x37, 0x35, 0x39, 0x35, 0x38, 0x65, 0x65, 0x33, 0x38, 0x32, 0x37, 0x61, 0x66, 0x37, 0x38, 0x34, 0x32, 0x65, 0x33, 0x35, 0x64, 0x39, 0x63, 0x63, 0x38, 0x39, 0x63, 0x33, 0x37, 0x37, 0x36, 0x65, 0x35, 0x36, 0x34, 0x30, 0x66, 0x32, 0x34, 0x33, 0x33, 0x61, 0x36, 0x61, 0x66, 0x63, 0x63, 0x66, 0x30, 0x65, 0x36, 0x66, 0x66, 0x66, 0x39, 0x33, 0x32, 0x31, 0x65, 0x33, 0x31, 0x38, 0x30, 0x32, 0x37, 0x34, 0x36, 0x36, 0x33, 0x39, 0x62, 0x66, 0x32, 0x62, 0x66, 0x37, 0x37, 0x66, 0x33, 0x37, 0x35, 0x64, 0x64, 0x36, 0x37, 0x39, 0x39, 0x62, 0x61, 0x61, 0x31, 0x38, 0x34, 0x62, 0x34, 0x38, 0x38, 0x31, 0x35, 0x66, 0x32, 0x34, 0x64, 0x33, 0x66, 0x63, 0x61, 0x35, 0x64, 0x35, 0x33, 0x34, 0x64, 0x66, 0x65, 0x36, 0x31, 0x64, 0x31, 0x33, 0x30, 0x36, 0x64, 0x31, 0x35, 0x65, 0x39, 0x37, 0x64, 0x33, 0x61, 0x33, 0x32, 0x30, 0x34, 0x35, 0x37, 0x64, 0x64, 0x64, 0x32, 0x32, 0x33, 0x39, 0x63, 0x63, 0x35, 0x32, 0x66, 0x62, 0x33, 0x31, 0x64, 0x62, 0x66, 0x39, 0x38, 0x37, 0x30, 0x39, 0x63, 0x66, 0x30, 0x39, 0x30, 0x61, 0x65, 0x35, 0x39, 0x61, 0x66, 0x61, 0x62, 0x62, 0x64, 0x61, 0x36, 0x64, 0x61, 0x37, 0x35, 0x66, 0x34, 0x65, 0x31, 0x33, 0x37, 0x33, 0x61, 0x32, 0x38, 0x62, 0x63, 0x61, 0x64, 0x63, 0x32, 0x34, 0x30, 0x35, 0x65, 0x30, 0x61, 0x37, 0x66, 0x36, 0x64, 0x62, 0x66, 0x39, 0x61, 0x33, 0x65, 0x32, 0x36, 0x35, 0x31, 0x31, 0x66, 0x63, 0x36, 0x30, 0x30, 0x61, 0x34, 0x39, 0x36, 0x62, 0x34, 0x36, 0x32, 0x33, 0x35, 0x39, 0x33, 0x32, 0x31, 0x33, 0x32, 0x38, 0x33, 0x61, 0x31, 0x66, 0x64, 0x33, 0x33, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x63, 0x66, 0x39, 0x30, 0x31, 0x30, 0x39, 0x62, 0x38, 0x35, 0x33, 0x66, 0x38, 0x35, 0x31, 0x61, 0x30, 0x34, 0x64, 0x64, 0x35, 0x61, 0x39, 0x31, 0x36, 0x39, 0x31, 0x37, 0x63, 0x34, 0x36, 0x39, 0x36, 0x39, 0x64, 0x62, 0x32, 0x65, 0x32, 0x30, 0x39, 0x33, 0x65, 0x37, 0x33, 0x39, 0x37, 0x32, 0x64, 0x61, 0x61, 0x35, 0x32, 0x64, 0x35, 0x35, 0x38, 0x32, 0x65, 0x31, 0x38, 0x33, 0x65, 0x62, 0x30, 0x62, 0x64, 0x30, 0x38, 0x33, 0x36, 0x32, 0x65, 0x37, 0x61, 0x63, 0x61, 0x31, 0x64, 0x63, 0x32, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x61, 0x30, 0x33, 0x36, 0x30, 0x35, 0x64, 0x30, 0x64, 0x32, 0x63, 0x34, 0x37, 0x36, 0x35, 0x62, 0x65, 0x32, 0x39, 0x38, 0x38, 0x33, 0x61, 0x62, 0x62, 0x37, 0x31, 0x66, 0x31, 0x63, 0x34, 0x62, 0x31, 0x36, 0x32, 0x66, 0x39, 0x64, 0x36, 0x37, 0x38, 0x36, 0x38, 0x33, 0x35, 0x63, 0x63, 0x61, 0x62, 0x62, 0x30, 0x36, 0x38, 0x61, 0x32, 0x34, 0x33, 0x66, 0x66, 0x38, 0x31, 0x39, 0x39, 0x30, 0x39, 0x66, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x62, 0x38, 0x62, 0x32, 0x66, 0x38, 0x62, 0x30, 0x33, 0x30, 0x62, 0x38, 0x61, 0x64, 0x66, 0x38, 0x61, 0x62, 0x38, 0x33, 0x30, 0x31, 0x65, 0x64, 0x63, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x64, 0x30, 0x39, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x62, 0x38, 0x34, 0x34, 0x61, 0x30, 0x63, 0x61, 0x32, 0x64, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x37, 0x64, 0x62, 0x66, 0x62, 0x66, 0x32, 0x63, 0x35, 0x33, 0x35, 0x66, 0x66, 0x63, 0x35, 0x32, 0x31, 0x31, 0x37, 0x64, 0x34, 0x63, 0x63, 0x36, 0x31, 0x36, 0x62, 0x38, 0x64, 0x39, 0x37, 0x62, 0x64, 0x30, 0x37, 0x63, 0x64, 0x64, 0x38, 0x35, 0x38, 0x35, 0x61, 0x62, 0x36, 0x37, 0x64, 0x39, 0x30, 0x39, 0x35, 0x63, 0x30, 0x36, 0x37, 0x65, 0x39, 0x64, 0x65, 0x36, 0x64, 0x36, 0x37, 0x34, 0x34, 0x38, 0x33, 0x30, 0x35, 0x31, 0x38, 0x64, 0x62, 0x61, 0x30, 0x37, 0x39, 0x62, 0x65, 0x36, 0x36, 0x37, 0x65, 0x66, 0x39, 0x64, 0x63, 0x62, 0x62, 0x61, 0x63, 0x35, 0x35, 0x61, 0x30, 0x36, 0x32, 0x39, 0x35, 0x63, 0x65, 0x38, 0x37, 0x30, 0x62, 0x30, 0x37, 0x30, 0x32, 0x39, 0x62, 0x66, 0x63, 0x64, 0x62, 0x32, 0x64, 0x63, 0x65, 0x32, 0x38, 0x64, 0x39, 0x35, 0x39, 0x66, 0x32, 0x38, 0x31, 0x35, 0x62, 0x31, 0x36, 0x66, 0x38, 0x31, 0x37, 0x39, 0x38, 0x61, 0x30, 0x35, 0x61, 0x34, 0x62, 0x61, 0x32, 0x39, 0x30, 0x64, 0x38, 0x34, 0x39, 0x62, 0x37, 0x31, 0x39, 0x38, 0x33, 0x39, 0x38, 0x37, 0x32, 0x61, 0x61, 0x31, 0x65, 0x36, 0x39, 0x39, 0x39, 0x65, 0x65, 0x36, 0x37, 0x32, 0x66, 0x66, 0x66, 0x33, 0x37, 0x64, 0x34, 0x35, 0x30, 0x39, 0x35, 0x36, 0x64, 0x65, 0x38, 0x35, 0x66, 0x65, 0x30, 0x37, 0x63, 0x39, 0x36, 0x66, 0x31, 0x37, 0x32, 0x64, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x62, 0x66, 0x39, 0x30, 0x31, 0x65, 0x38, 0x62, 0x38, 0x35, 0x33, 0x66, 0x38, 0x35, 0x31, 0x61, 0x30, 0x38, 0x37, 0x65, 0x65, 0x66, 0x36, 0x63, 0x36, 0x66, 0x61, 0x62, 0x32, 0x32, 0x38, 0x62, 0x63, 0x32, 0x38, 0x30, 0x31, 0x33, 0x38, 0x34, 0x34, 0x31, 0x64, 0x38, 0x37, 0x30, 0x35, 0x39, 0x32, 0x61, 0x33, 0x39, 0x31, 0x30, 0x66, 0x30, 0x34, 0x32, 0x38, 0x30, 0x36, 0x62, 0x31, 0x36, 0x66, 0x32, 0x35, 0x37, 0x66, 0x61, 0x66, 0x35, 0x66, 0x31, 0x35, 0x34, 0x32, 0x66, 0x39, 0x61, 0x32, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x61, 0x30, 0x30, 0x61, 0x63, 0x36, 0x30, 0x61, 0x33, 0x61, 0x35, 0x62, 0x61, 0x66, 0x61, 0x34, 0x35, 0x36, 0x30, 0x65, 0x64, 0x62, 0x37, 0x62, 0x64, 0x39, 0x37, 0x38, 0x61, 0x36, 0x62, 0x38, 0x39, 0x38, 0x30, 0x66, 0x61, 0x38, 0x31, 0x38, 0x63, 0x35, 0x65, 0x64, 0x65, 0x61, 0x37, 0x63, 0x30, 0x31, 0x30, 0x39, 0x38, 0x36, 0x33, 0x32, 0x38, 0x64, 0x65, 0x34, 0x64, 0x39, 0x62, 0x34, 0x62, 0x61, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x38, 0x30, 0x62, 0x39, 0x30, 0x31, 0x39, 0x30, 0x66, 0x39, 0x30, 0x31, 0x38, 0x64, 0x33, 0x30, 0x62, 0x39, 0x30, 0x31, 0x38, 0x39, 0x66, 0x39, 0x30, 0x31, 0x38, 0x36, 0x30, 0x31, 0x38, 0x33, 0x30, 0x33, 0x39, 0x34, 0x34, 0x35, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x37, 0x63, 0x66, 0x38, 0x37, 0x61, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x38, 0x34, 0x32, 0x61, 0x30, 0x35, 0x38, 0x33, 0x31, 0x33, 0x62, 0x36, 0x30, 0x65, 0x63, 0x36, 0x63, 0x35, 0x62, 0x66, 0x63, 0x33, 0x38, 0x31, 0x65, 0x35, 0x32, 0x66, 0x30, 0x64, 0x65, 0x33, 0x65, 0x64, 0x65, 0x30, 0x66, 0x61, 0x61, 0x63, 0x33, 0x63, 0x64, 0x66, 0x66, 0x65, 0x61, 0x32, 0x36, 0x66, 0x37, 0x64, 0x36, 0x62, 0x63, 0x63, 0x33, 0x64, 0x30, 0x39, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x39, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x37, 0x61, 0x30, 0x64, 0x62, 0x66, 0x62, 0x66, 0x32, 0x63, 0x35, 0x33, 0x35, 0x66, 0x66, 0x63, 0x35, 0x32, 0x31, 0x31, 0x37, 0x64, 0x34, 0x63, 0x63, 0x36, 0x31, 0x36, 0x62, 0x38, 0x64, 0x39, 0x37, 0x62, 0x64, 0x30, 0x37, 0x63, 0x64, 0x64, 0x38, 0x35, 0x38, 0x35, 0x61, 0x62, 0x36, 0x37, 0x64, 0x39, 0x30, 0x39, 0x35, 0x63, 0x30, 0x36, 0x37, 0x65, 0x39, 0x64, 0x65, 0x36, 0x64, 0x36, 0x37, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x66, 0x38, 0x61, 0x62, 0x38, 0x33, 0x30, 0x31, 0x65, 0x64, 0x63, 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x33, 0x64, 0x30, 0x39, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x62, 0x38, 0x34, 0x34, 0x61, 0x30, 0x63, 0x61, 0x32, 0x64, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x37, 0x64, 0x62, 0x66, 0x62, 0x66, 0x32, 0x63, 0x35, 0x33, 0x35, 0x66, 0x66, 0x63, 0x35, 0x32, 0x31, 0x31, 0x37, 0x64, 0x34, 0x63, 0x63, 0x36, 0x31, 0x36, 0x62, 0x38, 0x64, 0x39, 0x37, 0x62, 0x64, 0x30, 0x37, 0x63, 0x64, 0x64, 0x38, 0x35, 0x38, 0x35, 0x61, 0x62, 0x36, 0x37, 0x64, 0x39, 0x30, 0x39, 0x35, 0x63, 0x30, 0x36, 0x37, 0x65, 0x39, 0x64, 0x65, 0x36, 0x64, 0x36, 0x37, 0x34, 0x34, 0x38, 0x33, 0x30, 0x35, 0x31, 0x38, 0x64, 0x62, 0x61, 0x30, 0x37, 0x39, 0x62, 0x65, 0x36, 0x36, 0x37, 0x65, 0x66, 0x39, 0x64, 0x63, 0x62, 0x62, 0x61, 0x63, 0x35, 0x35, 0x61, 0x30, 0x36, 0x32, 0x39, 0x35, 0x63, 0x65, 0x38, 0x37, 0x30, 0x62, 0x30, 0x37, 0x30, 0x32, 0x39, 0x62, 0x66, 0x63, 0x64, 0x62, 0x32, 0x64, 0x63, 0x65, 0x32, 0x38, 0x64, 0x39, 0x35, 0x39, 0x66, 0x32, 0x38, 0x31, 0x35, 0x62, 0x31, 0x36, 0x66, 0x38, 0x31, 0x37, 0x39, 0x38, 0x61, 0x30, 0x35, 0x61, 0x34, 0x62, 0x61, 0x32, 0x39, 0x30, 0x64, 0x38, 0x34, 0x39, 0x62, 0x37, 0x31, 0x39, 0x38, 0x33, 0x39, 0x38, 0x37, 0x32, 0x61, 0x61, 0x31, 0x65, 0x36, 0x39, 0x39, 0x39, 0x65, 0x65, 0x36, 0x37, 0x32, 0x66, 0x66, 0x66, 0x33, 0x37, 0x64, 0x34, 0x35, 0x30, 0x39, 0x35, 0x36, 0x64, 0x65, 0x38, 0x35, 0x66, 0x65, 0x30, 0x37, 0x63, 0x39, 0x36, 0x66, 0x31, 0x37, 0x32, 0x64, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x39, 0x66, 0x39, 0x30, 0x31, 0x38, 0x36, 0x30, 0x31, 0x38, 0x33, 0x30, 0x33, 0x39, 0x34, 0x34, 0x35, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x37, 0x63, 0x66, 0x38, 0x37, 0x61, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x37, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x38, 0x34, 0x32, 0x61, 0x30, 0x35, 0x38, 0x33, 0x31, 0x33, 0x62, 0x36, 0x30, 0x65, 0x63, 0x36, 0x63, 0x35, 0x62, 0x66, 0x63, 0x33, 0x38, 0x31, 0x65, 0x35, 0x32, 0x66, 0x30, 0x64, 0x65, 0x33, 0x65, 0x64, 0x65, 0x30, 0x66, 0x61, 0x61, 0x63, 0x33, 0x63, 0x64, 0x66, 0x66, 0x65, 0x61, 0x32, 0x36, 0x66, 0x37, 0x64, 0x36, 0x62, 0x63, 0x63, 0x33, 0x64, 0x30, 0x39, 0x62, 0x36, 0x31, 0x30, 0x31, 0x38, 0x36, 0x39, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x32, 0x36, 0x37, 0x61, 0x30, 0x64, 0x62, 0x66, 0x62, 0x66, 0x32, 0x63, 0x35, 0x33, 0x35, 0x66, 0x66, 0x63, 0x35, 0x32, 0x31, 0x31, 0x37, 0x64, 0x34, 0x63, 0x63, 0x36, 0x31, 0x36, 0x62, 0x38, 0x64, 0x39, 0x37, 0x62, 0x64, 0x30, 0x37, 0x63, 0x64, 0x64, 0x38, 0x35, 0x38, 0x35, 0x61, 0x62, 0x36, 0x37, 0x64, 0x39, 0x30, 0x39, 0x35, 0x63, 0x30, 0x36, 0x37, 0x65, 0x39, 0x64, 0x65, 0x36, 0x64, 0x36, 0x37, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x64, 0x38, 0x36, 0x61, 0x37, 0x31, 0x65, 0x38, 0x65, 0x35, 0x33, 0x31, 0x62, 0x61, 0x65, 0x33, 0x62, 0x32, 0x61, 0x32, 0x65, 0x37, 0x30, 0x64, 0x39, 0x38, 0x65, 0x35, 0x31, 0x36, 0x63, 0x63, 0x66, 0x33, 0x31, 0x62, 0x36, 0x35, 0x38, 0x33, 0x64, 0x39, 0x33, 0x36, 0x66, 0x66, 0x61, 0x33, 0x31, 0x63, 0x33, 0x37, 0x37, 0x32, 0x61, 0x63, 0x32, 0x36, 0x35, 0x64, 0x62, 0x38, 0x32, 0x38, 0x61, 0x30, 0x34, 0x32, 0x30, 0x66, 0x35, 0x61, 0x38, 0x30, 0x36, 0x37, 0x63, 0x37, 0x65, 0x65, 0x63, 0x35, 0x32, 0x31, 0x34, 0x31, 0x31, 0x37, 0x36, 0x34, 0x37, 0x64, 0x61, 0x31, 0x34, 0x39, 0x65, 0x61, 0x61, 0x34, 0x65, 0x37, 0x63, 0x37, 0x38, 0x61, 0x31, 0x30, 0x64, 0x38, 0x65, 0x65, 0x36, 0x66, 0x61, 0x36, 0x32, 0x30, 0x30, 0x31, 0x65, 0x65, 0x31, 0x62, 0x36, 0x38, 0x30, 0x66, 0x39, 0x66, 0x62, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x32, 0x66, 0x39, 0x30, 0x35, 0x66, 0x63, 0x38, 0x33, 0x61, 0x61, 0x33, 0x36, 0x61, 0x37, 0x38, 0x32, 0x33, 0x64, 0x33, 0x66, 0x36, 0x34, 0x37, 0x34, 0x38, 0x32, 0x61, 0x39, 0x63, 0x34, 0x39, 0x34, 0x62, 0x61, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x62, 0x39, 0x30, 0x35, 0x39, 0x33, 0x30, 0x30, 0x30, 0x31, 0x35, 0x33, 0x36, 0x63, 0x62, 0x38, 0x64, 0x61, 0x33, 0x64, 0x64, 0x31, 0x30, 0x35, 0x65, 0x39, 0x34, 0x34, 0x31, 0x34, 0x36, 0x39, 0x30, 0x37, 0x39, 0x38, 0x63, 0x37, 0x66, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x62, 0x37, 0x38, 0x64, 0x61, 0x38, 0x63, 0x63, 0x66, 0x66, 0x62, 0x33, 0x62, 0x64, 0x33, 0x38, 0x62, 0x30, 0x33, 0x63, 0x30, 0x66, 0x31, 0x32, 0x31, 0x39, 0x39, 0x62, 0x62, 0x39, 0x36, 0x34, 0x62, 0x34, 0x32, 0x36, 0x64, 0x64, 0x36, 0x62, 0x30, 0x39, 0x31, 0x65, 0x66, 0x64, 0x37, 0x64, 0x63, 0x33, 0x61, 0x64, 0x31, 0x61, 0x39, 0x64, 0x33, 0x32, 0x31, 0x64, 0x31, 0x37, 0x31, 0x33, 0x62, 0x32, 0x65, 0x61, 0x31, 0x31, 0x38, 0x39, 0x64, 0x33, 0x39, 0x32, 0x38, 0x30, 0x62, 0x34, 0x37, 0x39, 0x31, 0x63, 0x35, 0x63, 0x38, 0x35, 0x38, 0x37, 0x32, 0x39, 0x30, 0x39, 0x30, 0x63, 0x33, 0x62, 0x36, 0x31, 0x38, 0x32, 0x61, 0x63, 0x37, 0x35, 0x39, 0x35, 0x31, 0x65, 0x65, 0x66, 0x37, 0x34, 0x62, 0x33, 0x38, 0x31, 0x39, 0x31, 0x36, 0x38, 0x36, 0x62, 0x33, 0x35, 0x63, 0x34, 0x36, 0x36, 0x39, 0x36, 0x35, 0x36, 0x63, 0x61, 0x39, 0x64, 0x63, 0x35, 0x61, 0x30, 0x63, 0x65, 0x37, 0x65, 0x39, 0x33, 0x39, 0x39, 0x66, 0x37, 0x65, 0x66, 0x66, 0x66, 0x63, 0x30, 0x33, 0x61, 0x66, 0x65, 0x37, 0x66, 0x64, 0x36, 0x65, 0x37, 0x34, 0x38, 0x35, 0x38, 0x38, 0x37, 0x66, 0x36, 0x32, 0x36, 0x34, 0x65, 0x39, 0x37, 0x65, 0x39, 0x38, 0x35, 0x36, 0x61, 0x36, 0x39, 0x37, 0x38, 0x62, 0x36, 0x35, 0x63, 0x35, 0x64, 0x62, 0x33, 0x62, 0x34, 0x63, 0x65, 0x35, 0x37, 0x63, 0x66, 0x34, 0x38, 0x31, 0x32, 0x61, 0x62, 0x65, 0x62, 0x61, 0x30, 0x64, 0x65, 0x31, 0x30, 0x64, 0x30, 0x64, 0x36, 0x65, 0x65, 0x35, 0x61, 0x32, 0x63, 0x62, 0x63, 0x39, 0x38, 0x38, 0x35, 0x61, 0x32, 0x31, 0x36, 0x33, 0x61, 0x35, 0x38, 0x64, 0x31, 0x38, 0x39, 0x35, 0x35, 0x32, 0x34, 0x61, 0x64, 0x62, 0x66, 0x64, 0x38, 0x36, 0x64, 0x37, 0x39, 0x35, 0x65, 0x61, 0x63, 0x37, 0x34, 0x65, 0x63, 0x37, 0x34, 0x64, 0x37, 0x38, 0x33, 0x62, 0x35, 0x39, 0x39, 0x38, 0x36, 0x31, 0x62, 0x66, 0x34, 0x62, 0x37, 0x62, 0x33, 0x65, 0x36, 0x64, 0x61, 0x66, 0x37, 0x30, 0x62, 0x33, 0x61, 0x65, 0x30, 0x65, 0x35, 0x37, 0x34, 0x30, 0x63, 0x38, 0x38, 0x61, 0x34, 0x64, 0x63, 0x31, 0x35, 0x62, 0x38, 0x39, 0x33, 0x66, 0x37, 0x36, 0x66, 0x65, 0x30, 0x37, 0x34, 0x61, 0x37, 0x31, 0x38, 0x62, 0x63, 0x65, 0x61, 0x64, 0x35, 0x32, 0x66, 0x62, 0x32, 0x61, 0x30, 0x36, 0x64, 0x36, 0x65, 0x35, 0x66, 0x31, 0x63, 0x66, 0x33, 0x63, 0x61, 0x33, 0x34, 0x34, 0x61, 0x64, 0x30, 0x35, 0x64, 0x63, 0x66, 0x35, 0x63, 0x61, 0x31, 0x30, 0x62, 0x64, 0x39, 0x62, 0x63, 0x32, 0x38, 0x30, 0x39, 0x63, 0x64, 0x38, 0x65, 0x63, 0x64, 0x34, 0x30, 0x61, 0x32, 0x64, 0x64, 0x30, 0x65, 0x30, 0x33, 0x32, 0x30, 0x30, 0x64, 0x61, 0x64, 0x64, 0x38, 0x66, 0x39, 0x32, 0x31, 0x66, 0x30, 0x65, 0x39, 0x39, 0x35, 0x33, 0x61, 0x37, 0x65, 0x36, 0x64, 0x38, 0x63, 0x37, 0x64, 0x63, 0x39, 0x39, 0x65, 0x36, 0x30, 0x63, 0x66, 0x36, 0x66, 0x65, 0x38, 0x31, 0x34, 0x36, 0x35, 0x31, 0x37, 0x35, 0x65, 0x30, 0x63, 0x66, 0x39, 0x39, 0x62, 0x37, 0x30, 0x32, 0x61, 0x63, 0x36, 0x61, 0x31, 0x33, 0x37, 0x30, 0x36, 0x65, 0x36, 0x34, 0x61, 0x63, 0x33, 0x34, 0x39, 0x61, 0x31, 0x31, 0x31, 0x39, 0x37, 0x39, 0x36, 0x65, 0x62, 0x30, 0x62, 0x36, 0x65, 0x37, 0x64, 0x35, 0x61, 0x65, 0x34, 0x38, 0x61, 0x64, 0x37, 0x34, 0x61, 0x35, 0x63, 0x39, 0x39, 0x37, 0x64, 0x36, 0x37, 0x39, 0x65, 0x66, 0x39, 0x63, 0x36, 0x33, 0x37, 0x63, 0x36, 0x31, 0x39, 0x35, 0x38, 0x37, 0x63, 0x62, 0x39, 0x38, 0x65, 0x63, 0x66, 0x38, 0x38, 0x65, 0x36, 0x32, 0x30, 0x64, 0x61, 0x63, 0x64, 0x63, 0x35, 0x37, 0x37, 0x30, 0x31, 0x35, 0x30, 0x30, 0x63, 0x37, 0x34, 0x65, 0x30, 0x38, 0x37, 0x35, 0x33, 0x33, 0x66, 0x39, 0x37, 0x38, 0x38, 0x33, 0x31, 0x61, 0x37, 0x38, 0x62, 0x66, 0x33, 0x38, 0x35, 0x37, 0x63, 0x62, 0x36, 0x30, 0x34, 0x34, 0x61, 0x38, 0x63, 0x36, 0x36, 0x65, 0x34, 0x31, 0x36, 0x34, 0x35, 0x63, 0x64, 0x65, 0x65, 0x37, 0x34, 0x61, 0x63, 0x37, 0x63, 0x64, 0x61, 0x63, 0x36, 0x39, 0x61, 0x38, 0x34, 0x38, 0x34, 0x30, 0x38, 0x33, 0x65, 0x62, 0x30, 0x30, 0x33, 0x38, 0x32, 0x37, 0x63, 0x63, 0x66, 0x64, 0x36, 0x62, 0x39, 0x32, 0x63, 0x37, 0x37, 0x62, 0x37, 0x30, 0x39, 0x37, 0x61, 0x31, 0x35, 0x66, 0x33, 0x38, 0x61, 0x34, 0x31, 0x39, 0x66, 0x36, 0x66, 0x30, 0x35, 0x37, 0x38, 0x66, 0x33, 0x35, 0x36, 0x38, 0x34, 0x36, 0x35, 0x65, 0x36, 0x66, 0x62, 0x36, 0x33, 0x39, 0x66, 0x31, 0x61, 0x38, 0x64, 0x36, 0x65, 0x35, 0x32, 0x65, 0x39, 0x64, 0x31, 0x37, 0x61, 0x30, 0x34, 0x31, 0x33, 0x31, 0x30, 0x30, 0x63, 0x61, 0x38, 0x64, 0x30, 0x38, 0x62, 0x32, 0x31, 0x30, 0x61, 0x32, 0x65, 0x35, 0x61, 0x64, 0x62, 0x32, 0x62, 0x65, 0x61, 0x64, 0x33, 0x64, 0x66, 0x61, 0x61, 0x64, 0x61, 0x31, 0x34, 0x62, 0x32, 0x35, 0x31, 0x33, 0x31, 0x31, 0x33, 0x38, 0x30, 0x32, 0x66, 0x33, 0x39, 0x39, 0x36, 0x64, 0x61, 0x63, 0x63, 0x61, 0x63, 0x38, 0x39, 0x30, 0x31, 0x34, 0x64, 0x61, 0x66, 0x64, 0x31, 0x33, 0x36, 0x38, 0x37, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x35, 0x33, 0x61, 0x64, 0x37, 0x64, 0x61, 0x65, 0x65, 0x61, 0x32, 0x61, 0x34, 0x64, 0x34, 0x64, 0x39, 0x65, 0x38, 0x35, 0x30, 0x32, 0x61, 0x61, 0x34, 0x34, 0x33, 0x33, 0x37, 0x63, 0x36, 0x66, 0x66, 0x39, 0x31, 0x31, 0x36, 0x35, 0x61, 0x32, 0x35, 0x64, 0x65, 0x38, 0x34, 0x66, 0x65, 0x35, 0x32, 0x37, 0x33, 0x62, 0x32, 0x65, 0x35, 0x62, 0x37, 0x66, 0x34, 0x64, 0x64, 0x61, 0x33, 0x61, 0x30, 0x34, 0x31, 0x30, 0x39, 0x30, 0x30, 0x31, 0x32, 0x35, 0x65, 0x37, 0x37, 0x37, 0x38, 0x64, 0x35, 0x63, 0x32, 0x61, 0x35, 0x39, 0x61, 0x32, 0x63, 0x61, 0x32, 0x63, 0x65, 0x33, 0x36, 0x62, 0x61, 0x63, 0x63, 0x39, 0x65, 0x39, 0x35, 0x38, 0x31, 0x32, 0x61, 0x65, 0x31, 0x62, 0x36, 0x39, 0x61, 0x34, 0x37, 0x38, 0x66, 0x63, 0x37, 0x65, 0x63, 0x66, 0x35, 0x64, 0x65, 0x64, 0x31, 0x34, 0x62, 0x36, 0x38, 0x61, 0x38, 0x30, 0x61, 0x30, 0x31, 0x30, 0x64, 0x36, 0x65, 0x30, 0x33, 0x65, 0x30, 0x37, 0x31, 0x33, 0x37, 0x64, 0x35, 0x64, 0x65, 0x38, 0x30, 0x38, 0x32, 0x37, 0x37, 0x33, 0x66, 0x38, 0x61, 0x34, 0x32, 0x32, 0x33, 0x39, 0x30, 0x63, 0x64, 0x30, 0x61, 0x35, 0x39, 0x32, 0x64, 0x38, 0x31, 0x65, 0x36, 0x65, 0x36, 0x32, 0x33, 0x61, 0x34, 0x32, 0x62, 0x63, 0x36, 0x39, 0x35, 0x34, 0x37, 0x65, 0x36, 0x62, 0x33, 0x34, 0x33, 0x65, 0x31, 0x64, 0x39, 0x61, 0x31, 0x34, 0x65, 0x36, 0x34, 0x61, 0x63, 0x33, 0x34, 0x38, 0x36, 0x31, 0x31, 0x36, 0x65, 0x32, 0x39, 0x61, 0x38, 0x33, 0x31, 0x35, 0x34, 0x38, 0x36, 0x61, 0x32, 0x33, 0x32, 0x34, 0x64, 0x39, 0x33, 0x64, 0x33, 0x65, 0x33, 0x33, 0x61, 0x38, 0x33, 0x34, 0x34, 0x66, 0x66, 0x64, 0x62, 0x63, 0x32, 0x36, 0x35, 0x35, 0x62, 0x37, 0x36, 0x64, 0x62, 0x66, 0x37, 0x32, 0x30, 0x37, 0x37, 0x65, 0x34, 0x33, 0x63, 0x31, 0x33, 0x39, 0x36, 0x31, 0x61, 0x36, 0x61, 0x35, 0x32, 0x66, 0x30, 0x35, 0x36, 0x35, 0x66, 0x32, 0x30, 0x30, 0x30, 0x38, 0x38, 0x31, 0x35, 0x37, 0x36, 0x63, 0x37, 0x61, 0x31, 0x31, 0x33, 0x65, 0x37, 0x61, 0x61, 0x36, 0x65, 0x39, 0x61, 0x36, 0x65, 0x64, 0x34, 0x36, 0x37, 0x39, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x66, 0x38, 0x64, 0x31, 0x62, 0x66, 0x38, 0x30, 0x66, 0x66, 0x34, 0x34, 0x61, 0x65, 0x35, 0x35, 0x39, 0x39, 0x38, 0x31, 0x33, 0x65, 0x38, 0x30, 0x64, 0x32, 0x63, 0x31, 0x66, 0x32, 0x66, 0x64, 0x30, 0x61, 0x30, 0x33, 0x34, 0x30, 0x30, 0x38, 0x36, 0x34, 0x39, 0x35, 0x32, 0x31, 0x33, 0x37, 0x39, 0x31, 0x36, 0x37, 0x32, 0x34, 0x61, 0x34, 0x35, 0x30, 0x34, 0x62, 0x62, 0x31, 0x31, 0x38, 0x63, 0x63, 0x61, 0x66, 0x39, 0x32, 0x33, 0x36, 0x66, 0x32, 0x31, 0x37, 0x61, 0x31, 0x65, 0x34, 0x33, 0x63, 0x39, 0x37, 0x65, 0x34, 0x37, 0x31, 0x33, 0x39, 0x37, 0x61, 0x33, 0x66, 0x38, 0x36, 0x36, 0x37, 0x32, 0x32, 0x32, 0x36, 0x64, 0x64, 0x30, 0x65, 0x30, 0x32, 0x65, 0x30, 0x30, 0x64, 0x34, 0x64, 0x63, 0x62, 0x66, 0x65, 0x34, 0x64, 0x64, 0x32, 0x35, 0x30, 0x61, 0x39, 0x37, 0x64, 0x30, 0x63, 0x38, 0x33, 0x30, 0x62, 0x33, 0x64, 0x39, 0x33, 0x32, 0x31, 0x33, 0x66, 0x64, 0x30, 0x34, 0x38, 0x66, 0x65, 0x64, 0x33, 0x38, 0x65, 0x61, 0x38, 0x33, 0x37, 0x38, 0x30, 0x31, 0x38, 0x63, 0x37, 0x32, 0x36, 0x62, 0x65, 0x36, 0x38, 0x37, 0x32, 0x38, 0x65, 0x32, 0x32, 0x63, 0x36, 0x38, 0x37, 0x30, 0x33, 0x37, 0x30, 0x30, 0x30, 0x65, 0x33, 0x62, 0x62, 0x36, 0x64, 0x32, 0x38, 0x35, 0x38, 0x66, 0x62, 0x61, 0x38, 0x32, 0x64, 0x62, 0x38, 0x37, 0x37, 0x63, 0x32, 0x65, 0x32, 0x38, 0x66, 0x61, 0x31, 0x65, 0x32, 0x63, 0x63, 0x61, 0x34, 0x63, 0x65, 0x35, 0x37, 0x62, 0x36, 0x62, 0x64, 0x66, 0x64, 0x62, 0x61, 0x37, 0x35, 0x31, 0x33, 0x64, 0x63, 0x64, 0x32, 0x36, 0x34, 0x39, 0x64, 0x61, 0x39, 0x33, 0x35, 0x34, 0x34, 0x30, 0x38, 0x33, 0x64, 0x30, 0x36, 0x66, 0x38, 0x35, 0x63, 0x38, 0x66, 0x34, 0x64, 0x32, 0x31, 0x35, 0x35, 0x39, 0x65, 0x38, 0x65, 0x37, 0x36, 0x35, 0x31, 0x64, 0x63, 0x61, 0x61, 0x30, 0x63, 0x33, 0x61, 0x61, 0x66, 0x63, 0x34, 0x61, 0x36, 0x39, 0x31, 0x66, 0x64, 0x66, 0x62, 0x32, 0x37, 0x66, 0x32, 0x66, 0x33, 0x39, 0x65, 0x61, 0x30, 0x38, 0x65, 0x61, 0x36, 0x32, 0x66, 0x65, 0x66, 0x66, 0x34, 0x33, 0x63, 0x66, 0x30, 0x64, 0x38, 0x30, 0x30, 0x36, 0x31, 0x35, 0x30, 0x30, 0x62, 0x30, 0x62, 0x30, 0x30, 0x63, 0x62, 0x32, 0x34, 0x36, 0x66, 0x33, 0x36, 0x34, 0x31, 0x64, 0x38, 0x33, 0x66, 0x35, 0x63, 0x39, 0x33, 0x34, 0x63, 0x34, 0x37, 0x37, 0x63, 0x61, 0x36, 0x34, 0x31, 0x61, 0x35, 0x63, 0x35, 0x34, 0x35, 0x64, 0x61, 0x38, 0x61, 0x61, 0x30, 0x65, 0x34, 0x36, 0x36, 0x32, 0x63, 0x34, 0x63, 0x35, 0x66, 0x32, 0x36, 0x65, 0x65, 0x37, 0x30, 0x35, 0x32, 0x35, 0x61, 0x30, 0x34, 0x31, 0x32, 0x35, 0x30, 0x30, 0x36, 0x63, 0x66, 0x32, 0x36, 0x38, 0x66, 0x62, 0x64, 0x63, 0x61, 0x64, 0x64, 0x62, 0x31, 0x35, 0x31, 0x31, 0x36, 0x38, 0x62, 0x66, 0x32, 0x34, 0x64, 0x33, 0x66, 0x61, 0x32, 0x65, 0x30, 0x39, 0x66, 0x37, 0x34, 0x34, 0x35, 0x64, 0x38, 0x35, 0x39, 0x66, 0x66, 0x39, 0x65, 0x35, 0x62, 0x61, 0x32, 0x66, 0x65, 0x37, 0x31, 0x65, 0x37, 0x65, 0x66, 0x38, 0x38, 0x36, 0x31, 0x62, 0x61, 0x36, 0x31, 0x38, 0x33, 0x34, 0x61, 0x38, 0x30, 0x32, 0x38, 0x30, 0x65, 0x62, 0x64, 0x64, 0x66, 0x31, 0x62, 0x63, 0x39, 0x39, 0x65, 0x38, 0x64, 0x30, 0x30, 0x61, 0x65, 0x35, 0x64, 0x32, 0x61, 0x30, 0x38, 0x39, 0x33, 0x64, 0x36, 0x34, 0x37, 0x37, 0x34, 0x64, 0x34, 0x63, 0x65, 0x61, 0x31, 0x62, 0x61, 0x64, 0x37, 0x31, 0x34, 0x36, 0x66, 0x63, 0x39, 0x36, 0x34, 0x35, 0x32, 0x36, 0x62, 0x36, 0x63, 0x34, 0x36, 0x31, 0x37, 0x63, 0x64, 0x37, 0x30, 0x61, 0x36, 0x38, 0x35, 0x30, 0x30, 0x64, 0x30, 0x30, 0x66, 0x37, 0x65, 0x38, 0x31, 0x33, 0x31, 0x62, 0x39, 0x37, 0x36, 0x62, 0x39, 0x35, 0x33, 0x37, 0x61, 0x62, 0x34, 0x65, 0x32, 0x62, 0x39, 0x63, 0x39, 0x63, 0x66, 0x30, 0x38, 0x36, 0x66, 0x63, 0x66, 0x64, 0x38, 0x32, 0x65, 0x32, 0x33, 0x35, 0x63, 0x66, 0x36, 0x63, 0x36, 0x65, 0x61, 0x62, 0x62, 0x66, 0x38, 0x30, 0x33, 0x30, 0x63, 0x63, 0x33, 0x66, 0x64, 0x31, 0x65, 0x33, 0x39, 0x35, 0x30, 0x37, 0x31, 0x61, 0x38, 0x34, 0x30, 0x31, 0x32, 0x30, 0x62, 0x66, 0x62, 0x64, 0x37, 0x66, 0x64, 0x34, 0x61, 0x35, 0x34, 0x33, 0x39, 0x37, 0x65, 0x63, 0x61, 0x30, 0x63, 0x30, 0x66, 0x37, 0x61, 0x64, 0x63, 0x31, 0x32, 0x33, 0x31, 0x64, 0x64, 0x35, 0x33, 0x39, 0x39, 0x35, 0x30, 0x66, 0x35, 0x30, 0x38, 0x66, 0x39, 0x32, 0x65, 0x32, 0x33, 0x37, 0x65, 0x33, 0x61, 0x65, 0x62, 0x39, 0x31, 0x34, 0x36, 0x38, 0x63, 0x33, 0x38, 0x64, 0x34, 0x30, 0x38, 0x33, 0x65, 0x61, 0x30, 0x30, 0x36, 0x38, 0x61, 0x38, 0x39, 0x61, 0x62, 0x64, 0x33, 0x38, 0x31, 0x37, 0x38, 0x65, 0x32, 0x65, 0x39, 0x66, 0x36, 0x37, 0x35, 0x35, 0x39, 0x37, 0x35, 0x38, 0x34, 0x31, 0x39, 0x62, 0x36, 0x39, 0x30, 0x38, 0x64, 0x34, 0x38, 0x64, 0x35, 0x38, 0x39, 0x36, 0x37, 0x35, 0x34, 0x37, 0x63, 0x39, 0x65, 0x64, 0x66, 0x65, 0x39, 0x38, 0x62, 0x61, 0x30, 0x31, 0x36, 0x65, 0x30, 0x35, 0x30, 0x37, 0x33, 0x34, 0x61, 0x38, 0x30, 0x39, 0x38, 0x30, 0x37, 0x39, 0x35, 0x37, 0x39, 0x33, 0x36, 0x63, 0x30, 0x37, 0x39, 0x32, 0x37, 0x32, 0x62, 0x32, 0x33, 0x38, 0x37, 0x34, 0x38, 0x35, 0x39, 0x33, 0x65, 0x65, 0x33, 0x61, 0x37, 0x33, 0x66, 0x35, 0x63, 0x37, 0x36, 0x34, 0x37, 0x64, 0x30, 0x65, 0x63, 0x65, 0x32, 0x30, 0x61, 0x35, 0x63, 0x32, 0x30, 0x38, 0x37, 0x36, 0x39, 0x63, 0x34, 0x38, 0x34, 0x34, 0x37, 0x34, 0x61, 0x61, 0x32, 0x66, 0x31, 0x39, 0x32, 0x62, 0x36, 0x64, 0x63, 0x63, 0x37, 0x38, 0x30, 0x61, 0x37, 0x37, 0x30, 0x63, 0x39, 0x62, 0x34, 0x30, 0x62, 0x34, 0x32, 0x33, 0x34, 0x38, 0x32, 0x31, 0x39, 0x61, 0x33, 0x34, 0x61, 0x37, 0x34, 0x36, 0x63, 0x62, 0x34, 0x39, 0x35, 0x66, 0x33, 0x66, 0x31, 0x65, 0x66, 0x62, 0x37, 0x31, 0x30, 0x61, 0x38, 0x31, 0x36, 0x61, 0x63, 0x31, 0x34, 0x32, 0x31, 0x32, 0x31, 0x34, 0x36, 0x31, 0x63, 0x36, 0x66, 0x37, 0x62, 0x66, 0x38, 0x32, 0x66, 0x62, 0x30, 0x30, 0x62, 0x30, 0x64, 0x65, 0x63, 0x35, 0x62, 0x66, 0x62, 0x63, 0x61, 0x61, 0x32, 0x65, 0x33, 0x32, 0x39, 0x38, 0x33, 0x30, 0x37, 0x35, 0x63, 0x38, 0x34, 0x39, 0x38, 0x39, 0x65, 0x34, 0x33, 0x39, 0x31, 0x35, 0x34, 0x62, 0x66, 0x63, 0x37, 0x64, 0x66, 0x31, 0x64, 0x30, 0x35, 0x34, 0x39, 0x36, 0x38, 0x30, 0x61, 0x36, 0x63, 0x31, 0x61, 0x34, 0x39, 0x39, 0x39, 0x63, 0x31, 0x38, 0x61, 0x61, 0x30, 0x31, 0x30, 0x64, 0x65, 0x65, 0x30, 0x37, 0x34, 0x30, 0x32, 0x38, 0x66, 0x63, 0x61, 0x64, 0x65, 0x32, 0x39, 0x39, 0x35, 0x62, 0x37, 0x64, 0x61, 0x65, 0x63, 0x34, 0x35, 0x36, 0x32, 0x34, 0x34, 0x39, 0x63, 0x63, 0x62, 0x63, 0x65, 0x64, 0x30, 0x63, 0x61, 0x66, 0x37, 0x61, 0x36, 0x36, 0x30, 0x66, 0x34, 0x39, 0x61, 0x63, 0x34, 0x65, 0x61, 0x30, 0x37, 0x64, 0x34, 0x38, 0x35, 0x62, 0x32, 0x32, 0x33, 0x34, 0x38, 0x39, 0x34, 0x38, 0x61, 0x30, 0x34, 0x31, 0x35, 0x64, 0x30, 0x30, 0x31, 0x63, 0x65, 0x38, 0x65, 0x31, 0x36, 0x66, 0x37, 0x30, 0x63, 0x61, 0x35, 0x38, 0x31, 0x33, 0x31, 0x34, 0x31, 0x66, 0x37, 0x66, 0x37, 0x35, 0x34, 0x34, 0x35, 0x38, 0x36, 0x64, 0x61, 0x31, 0x33, 0x36, 0x34, 0x64, 0x32, 0x66, 0x37, 0x37, 0x64, 0x64, 0x38, 0x66, 0x62, 0x62, 0x37, 0x63, 0x63, 0x39, 0x33, 0x37, 0x63, 0x36, 0x64, 0x34, 0x36, 0x31, 0x33, 0x36, 0x66, 0x39, 0x33, 0x64, 0x36, 0x38, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x61, 0x37, 0x32, 0x64, 0x35, 0x39, 0x65, 0x35, 0x61, 0x39, 0x62, 0x64, 0x66, 0x31, 0x64, 0x65, 0x35, 0x65, 0x36, 0x30, 0x62, 0x62, 0x62, 0x31, 0x37, 0x33, 0x35, 0x38, 0x62, 0x63, 0x36, 0x35, 0x65, 0x38, 0x66, 0x66, 0x31, 0x35, 0x36, 0x36, 0x66, 0x61, 0x62, 0x61, 0x64, 0x36, 0x64, 0x36, 0x65, 0x62, 0x34, 0x32, 0x65, 0x66, 0x32, 0x37, 0x38, 0x31, 0x66, 0x36, 0x64, 0x36, 0x64, 0x34, 0x30, 0x38, 0x33, 0x37, 0x30, 0x30, 0x30, 0x62, 0x63, 0x65, 0x32, 0x31, 0x63, 0x36, 0x34, 0x38, 0x34, 0x37, 0x39, 0x34, 0x32, 0x33, 0x31, 0x39, 0x62, 0x34, 0x61, 0x63, 0x31, 0x63, 0x39, 0x32, 0x62, 0x32, 0x65, 0x65, 0x30, 0x32, 0x66, 0x65, 0x32, 0x62, 0x66, 0x62, 0x66, 0x34, 0x33, 0x62, 0x36, 0x38, 0x35, 0x39, 0x30, 0x38, 0x62, 0x39, 0x32, 0x61, 0x30, 0x63, 0x33, 0x63, 0x64, 0x32, 0x35, 0x66, 0x32, 0x31, 0x36, 0x34, 0x31, 0x61, 0x30, 0x34, 0x31, 0x37, 0x64, 0x30, 0x30, 0x38, 0x34, 0x31, 0x33, 0x38, 0x35, 0x39, 0x39, 0x34, 0x31, 0x39, 0x63, 0x66, 0x37, 0x33, 0x34, 0x38, 0x39, 0x33, 0x31, 0x32, 0x62, 0x64, 0x61, 0x30, 0x64, 0x35, 0x33, 0x65, 0x31, 0x66, 0x61, 0x37, 0x34, 0x38, 0x65, 0x31, 0x66, 0x37, 0x39, 0x32, 0x37, 0x33, 0x38, 0x30, 0x39, 0x36, 0x31, 0x34, 0x37, 0x30, 0x65, 0x63, 0x39, 0x66, 0x64, 0x61, 0x37, 0x33, 0x62, 0x33, 0x36, 0x39, 0x37, 0x38, 0x63, 0x39, 0x35, 0x33, 0x36, 0x36, 0x31, 0x63, 0x38, 0x30, 0x36, 0x35, 0x61, 0x61, 0x61, 0x66, 0x65, 0x30, 0x39, 0x66, 0x62, 0x38, 0x34, 0x37, 0x66, 0x62, 0x35, 0x34, 0x65, 0x33, 0x35, 0x62, 0x33, 0x63, 0x36, 0x38, 0x66, 0x37, 0x37, 0x31, 0x62, 0x36, 0x39, 0x35, 0x33, 0x39, 0x34, 0x31, 0x62, 0x32, 0x62, 0x34, 0x65, 0x36, 0x31, 0x39, 0x62, 0x34, 0x38, 0x36, 0x64, 0x38, 0x31, 0x37, 0x36, 0x31, 0x65, 0x65, 0x31, 0x38, 0x37, 0x62, 0x66, 0x38, 0x32, 0x38, 0x37, 0x30, 0x30, 0x33, 0x30, 0x31, 0x63, 0x64, 0x33, 0x34, 0x35, 0x32, 0x39, 0x37, 0x36, 0x33, 0x63, 0x36, 0x30, 0x37, 0x33, 0x38, 0x63, 0x31, 0x32, 0x65, 0x31, 0x63, 0x63, 0x63, 0x65, 0x36, 0x64, 0x64, 0x66, 0x66, 0x38, 0x62, 0x38, 0x33, 0x33, 0x38, 0x63, 0x64, 0x61, 0x38, 0x66, 0x64, 0x61, 0x32, 0x34, 0x35, 0x65, 0x35, 0x64, 0x38, 0x64, 0x35, 0x36, 0x31, 0x33, 0x64, 0x32, 0x30, 0x37, 0x33, 0x34, 0x34, 0x30, 0x38, 0x33, 0x30, 0x36, 0x64, 0x66, 0x39, 0x36, 0x62, 0x64, 0x36, 0x35, 0x63, 0x37, 0x62, 0x38, 0x64, 0x35, 0x63, 0x32, 0x37, 0x32, 0x39, 0x39, 0x32, 0x36, 0x39, 0x64, 0x64, 0x39, 0x33, 0x33, 0x35, 0x65, 0x66, 0x37, 0x63, 0x62, 0x31, 0x66, 0x33, 0x33, 0x35, 0x37, 0x31, 0x34, 0x35, 0x39, 0x38, 0x33, 0x66, 0x33, 0x36, 0x35, 0x65, 0x63, 0x32, 0x66, 0x39, 0x33, 0x33, 0x36, 0x38, 0x36, 0x66, 0x63, 0x36, 0x64, 0x37, 0x37, 0x64, 0x30, 0x61, 0x30, 0x31, 0x31, 0x30, 0x30, 0x63, 0x61, 0x33, 0x61, 0x33, 0x37, 0x37, 0x33, 0x64, 0x33, 0x66, 0x30, 0x61, 0x35, 0x32, 0x35, 0x35, 0x39, 0x65, 0x65, 0x36, 0x39, 0x31, 0x37, 0x37, 0x36, 0x62, 0x37, 0x31, 0x34, 0x66, 0x65, 0x64, 0x63, 0x38, 0x63, 0x37, 0x62, 0x32, 0x63, 0x64, 0x36, 0x37, 0x32, 0x63, 0x37, 0x30, 0x36, 0x35, 0x63, 0x32, 0x39, 0x35, 0x36, 0x39, 0x33, 0x64, 0x30, 0x36, 0x31, 0x36, 0x64, 0x33, 0x37, 0x34, 0x30, 0x38, 0x33, 0x31, 0x38, 0x30, 0x30, 0x37, 0x63, 0x31, 0x38, 0x65, 0x39, 0x61, 0x39, 0x66, 0x36, 0x65, 0x34, 0x39, 0x32, 0x39, 0x65, 0x32, 0x30, 0x64, 0x38, 0x65, 0x66, 0x64, 0x34, 0x63, 0x32, 0x34, 0x32, 0x38, 0x30, 0x36, 0x35, 0x37, 0x32, 0x30, 0x65, 0x64, 0x31, 0x39, 0x33, 0x38, 0x61, 0x66, 0x38, 0x65, 0x35, 0x33, 0x34, 0x38, 0x63, 0x31, 0x34, 0x62, 0x33, 0x37, 0x33, 0x62, 0x30, 0x61, 0x38, 0x34, 0x35, 0x64, 0x31, 0x30, 0x36, 0x33, 0x34, 0x36, 0x38, 0x64, 0x32, 0x66, 0x39, 0x36, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x38, 0x36, 0x66, 0x39, 0x61, 0x61, 0x35, 0x30, 0x30, 0x31, 0x63, 0x30, 0x30, 0x31, 0x61, 0x30, 0x38, 0x66, 0x37, 0x38, 0x35, 0x61, 0x31, 0x63, 0x38, 0x65, 0x34, 0x63, 0x35, 0x34, 0x39, 0x63, 0x34, 0x31, 0x35, 0x64, 0x64, 0x39, 0x34, 0x38, 0x64, 0x61, 0x38, 0x30, 0x66, 0x38, 0x36, 0x65, 0x33, 0x61, 0x61, 0x61, 0x62, 0x63, 0x34, 0x65, 0x37, 0x61, 0x37, 0x38, 0x34, 0x36, 0x30, 0x34, 0x62, 0x36, 0x33, 0x36, 0x32, 0x32, 0x30, 0x38, 0x65, 0x30, 0x66, 0x62, 0x36, 0x62, 0x38, 0x35, 0x61, 0x30, 0x31, 0x31, 0x64, 0x33, 0x36, 0x36, 0x64, 0x35, 0x37, 0x62, 0x36, 0x61, 0x64, 0x39, 0x35, 0x63, 0x64, 0x61, 0x32, 0x65, 0x62, 0x36, 0x62, 0x36, 0x31, 0x38, 0x37, 0x30, 0x34, 0x38, 0x35, 0x39, 0x62, 0x34, 0x64, 0x34, 0x33, 0x33, 0x61, 0x64, 0x37, 0x35, 0x35, 0x37, 0x63, 0x61, 0x64, 0x31, 0x37, 0x37, 0x65, 0x66, 0x66, 0x36, 0x66, 0x36, 0x62, 0x61, 0x65, 0x35, 0x37, 0x38, 0x63, 0x62, 0x63, 0x30, 0x66, 0x39, 0x30, 0x32, 0x30, 0x30, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x37, 0x65, 0x38, 0x32, 0x30, 0x33, 0x65, 0x34, 0x39, 0x34, 0x65, 0x32, 0x37, 0x36, 0x62, 0x63, 0x33, 0x37, 0x38, 0x61, 0x35, 0x32, 0x37, 0x61, 0x38, 0x37, 0x39, 0x32, 0x62, 0x33, 0x35, 0x33, 0x63, 0x64, 0x63, 0x61, 0x35, 0x62, 0x35, 0x65, 0x35, 0x33, 0x32, 0x36, 0x33, 0x64, 0x66, 0x62, 0x39, 0x65, 0x38, 0x32, 0x31, 0x36, 0x38, 0x63, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x37, 0x66, 0x38, 0x32, 0x30, 0x33, 0x65, 0x35, 0x39, 0x34, 0x65, 0x32, 0x37, 0x36, 0x62, 0x63, 0x33, 0x37, 0x38, 0x61, 0x35, 0x32, 0x37, 0x61, 0x38, 0x37, 0x39, 0x32, 0x62, 0x33, 0x35, 0x33, 0x63, 0x64, 0x63, 0x61, 0x35, 0x62, 0x35, 0x65, 0x35, 0x33, 0x32, 0x36, 0x33, 0x64, 0x66, 0x62, 0x39, 0x65, 0x38, 0x32, 0x31, 0x36, 0x38, 0x63, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x30, 0x38, 0x32, 0x30, 0x36, 0x32, 0x32, 0x39, 0x34, 0x33, 0x38, 0x38, 0x65, 0x61, 0x36, 0x36, 0x32, 0x65, 0x66, 0x32, 0x63, 0x32, 0x32, 0x33, 0x65, 0x63, 0x30, 0x62, 0x30, 0x34, 0x37, 0x64, 0x34, 0x31, 0x62, 0x66, 0x33, 0x63, 0x30, 0x66, 0x33, 0x36, 0x32, 0x31, 0x34, 0x32, 0x61, 0x64, 0x35, 0x38, 0x32, 0x31, 0x32, 0x63, 0x61, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x31, 0x38, 0x32, 0x30, 0x36, 0x32, 0x33, 0x39, 0x34, 0x33, 0x38, 0x38, 0x65, 0x61, 0x36, 0x36, 0x32, 0x65, 0x66, 0x32, 0x63, 0x32, 0x32, 0x33, 0x65, 0x63, 0x30, 0x62, 0x30, 0x34, 0x37, 0x64, 0x34, 0x31, 0x62, 0x66, 0x33, 0x63, 0x30, 0x66, 0x33, 0x36, 0x32, 0x31, 0x34, 0x32, 0x61, 0x64, 0x35, 0x38, 0x32, 0x31, 0x32, 0x63, 0x61, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x32, 0x38, 0x32, 0x30, 0x31, 0x39, 0x34, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x31, 0x32, 0x63, 0x61, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x33, 0x38, 0x32, 0x30, 0x31, 0x39, 0x37, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x31, 0x32, 0x63, 0x61, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x34, 0x38, 0x32, 0x30, 0x31, 0x39, 0x39, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x31, 0x32, 0x63, 0x61, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x35, 0x38, 0x32, 0x30, 0x31, 0x39, 0x61, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x31, 0x32, 0x63, 0x61, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x36, 0x38, 0x32, 0x30, 0x31, 0x39, 0x62, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x31, 0x32, 0x63, 0x61, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x37, 0x38, 0x32, 0x30, 0x31, 0x39, 0x65, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x30, 0x66, 0x30, 0x38, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x38, 0x38, 0x32, 0x30, 0x31, 0x61, 0x32, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x30, 0x66, 0x30, 0x38, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x39, 0x38, 0x32, 0x30, 0x31, 0x61, 0x35, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x30, 0x66, 0x30, 0x38, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x61, 0x38, 0x32, 0x30, 0x31, 0x61, 0x38, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x30, 0x66, 0x30, 0x38, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x62, 0x38, 0x32, 0x30, 0x31, 0x61, 0x39, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x30, 0x66, 0x30, 0x38, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x63, 0x38, 0x32, 0x30, 0x31, 0x61, 0x61, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x30, 0x66, 0x30, 0x38, 0x64, 0x66, 0x38, 0x33, 0x34, 0x35, 0x64, 0x65, 0x38, 0x64, 0x38, 0x32, 0x30, 0x31, 0x61, 0x63, 0x39, 0x34, 0x32, 0x35, 0x63, 0x34, 0x61, 0x37, 0x36, 0x65, 0x37, 0x64, 0x31, 0x31, 0x38, 0x37, 0x30, 0x35, 0x65, 0x37, 0x65, 0x61, 0x32, 0x65, 0x39, 0x62, 0x37, 0x64, 0x38, 0x63, 0x35, 0x39, 0x39, 0x33, 0x30, 0x64, 0x38, 0x61, 0x63, 0x64, 0x33, 0x62, 0x38, 0x32, 0x30, 0x66, 0x30, 0x38, 0x22, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x52, 0x4c, 0x50, 0x2d, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x52, 0x4c, 0x50, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x32, 0x30, 0x32, 0x36, 0x45, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x52, 0x4c, 0x50, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x39, 0x30, 0x32, 0x33, 0x36, 0x61, 0x30, 0x39, 0x66, 0x37, 0x33, 0x36, 0x39, 0x31, 0x66, 0x36, 0x64, 0x61, 0x62, 0x63, 0x61, 0x34, 0x66, 0x30, 0x61, 0x39, 0x39, 0x62, 0x30, 0x35, 0x64, 0x30, 0x61, 0x37, 0x30, 0x31, 0x39, 0x39, 0x35, 0x35, 0x30, 0x36, 0x61, 0x61, 0x33, 0x31, 0x31, 0x64, 0x63, 0x61, 0x61, 0x39, 0x63, 0x65, 0x39, 0x38, 0x33, 0x33, 0x64, 0x36, 0x66, 0x34, 0x63, 0x61, 0x34, 0x37, 0x34, 0x63, 0x31, 0x36, 0x32, 0x61, 0x30, 0x31, 0x64, 0x63, 0x63, 0x34, 0x64, 0x65, 0x38, 0x64, 0x65, 0x63, 0x37, 0x35, 0x64, 0x37, 0x61, 0x61, 0x62, 0x38, 0x35, 0x62, 0x35, 0x36, 0x37, 0x62, 0x36, 0x63, 0x63, 0x64, 0x34, 0x31, 0x61, 0x64, 0x33, 0x31, 0x32, 0x34, 0x35, 0x31, 0x62, 0x39, 0x34, 0x38, 0x61, 0x37, 0x34, 0x31, 0x33, 0x66, 0x30, 0x61, 0x31, 0x34, 0x32, 0x66, 0x64, 0x34, 0x30, 0x64, 0x34, 0x39, 0x33, 0x34, 0x37, 0x39, 0x34, 0x63, 0x36, 0x65, 0x32, 0x34, 0x35, 0x39, 0x39, 0x39, 0x31, 0x62, 0x66, 0x65, 0x32, 0x37, 0x63, 0x63, 0x61, 0x36, 0x64, 0x38, 0x36, 0x37, 0x32, 0x32, 0x66, 0x33, 0x35, 0x64, 0x61, 0x32, 0x33, 0x61, 0x31, 0x65, 0x34, 0x63, 0x62, 0x39, 0x37, 0x61, 0x30, 0x37, 0x38, 0x31, 0x30, 0x33, 0x65, 0x61, 0x38, 0x63, 0x34, 0x37, 0x32, 0x33, 0x31, 0x38, 0x38, 0x36, 0x34, 0x38, 0x31, 0x64, 0x37, 0x32, 0x65, 0x63, 0x31, 0x61, 0x66, 0x61, 0x65, 0x36, 0x65, 0x65, 0x62, 0x30, 0x36, 0x63, 0x33, 0x37, 0x37, 0x33, 0x63, 0x65, 0x32, 0x34, 0x61, 0x39, 0x31, 0x33, 0x32, 0x33, 0x64, 0x35, 0x63, 0x39, 0x65, 0x65, 0x64, 0x36, 0x39, 0x64, 0x34, 0x63, 0x63, 0x61, 0x30, 0x30, 0x30, 0x38, 0x39, 0x39, 0x32, 0x64, 0x61, 0x32, 0x35, 0x33, 0x31, 0x64, 0x62, 0x34, 0x30, 0x34, 0x66, 0x30, 0x37, 0x62, 0x30, 0x38, 0x37, 0x31, 0x64, 0x64, 0x36, 0x32, 0x30, 0x61, 0x39, 0x34, 0x62, 0x61, 0x33, 0x34, 0x36, 0x39, 0x36, 0x33, 0x65, 0x31, 0x62, 0x31, 0x63, 0x36, 0x64, 0x63, 0x37, 0x62, 0x30, 0x30, 0x37, 0x34, 0x38, 0x65, 0x38, 0x35, 0x39, 0x33, 0x61, 0x31, 0x65, 0x61, 0x30, 0x62, 0x36, 0x63, 0x33, 0x38, 0x39, 0x30, 0x64, 0x39, 0x36, 0x30, 0x34, 0x34, 0x33, 0x34, 0x66, 0x63, 0x35, 0x32, 0x66, 0x37, 0x32, 0x32, 0x38, 0x34, 0x38, 0x63, 0x38, 0x34, 0x64, 0x31, 0x37, 0x37, 0x30, 0x61, 0x64, 0x64, 0x32, 0x30, 0x63, 0x64, 0x37, 0x35, 0x62, 0x62, 0x63, 0x32, 0x38, 0x63, 0x64, 0x65, 0x64, 0x66, 0x66, 0x34, 0x32, 0x39, 0x34, 0x30, 0x64, 0x62, 0x62, 0x35, 0x36, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x32, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x34, 0x38, 0x30, 0x30, 0x32, 0x30, 0x38, 0x34, 0x30, 0x30, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x34, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x34, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x32, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x34, 0x31, 0x30, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x38, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x38, 0x30, 0x30, 0x34, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x30, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x33, 0x33, 0x32, 0x30, 0x32, 0x36, 0x65, 0x38, 0x34, 0x30, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x38, 0x33, 0x33, 0x65, 0x33, 0x63, 0x33, 0x63, 0x38, 0x34, 0x36, 0x34, 0x33, 0x36, 0x66, 0x39, 0x33, 0x38, 0x39, 0x39, 0x64, 0x38, 0x38, 0x33, 0x30, 0x31, 0x30, 0x62, 0x30, 0x35, 0x38, 0x34, 0x36, 0x37, 0x36, 0x35, 0x37, 0x34, 0x36, 0x38, 0x38, 0x38, 0x36, 0x37, 0x36, 0x66, 0x33, 0x31, 0x32, 0x65, 0x33, 0x32, 0x33, 0x30, 0x32, 0x65, 0x33, 0x32, 0x38, 0x35, 0x36, 0x63, 0x36, 0x39, 0x36, 0x65, 0x37, 0x35, 0x37, 0x38, 0x61, 0x30, 0x31, 0x31, 0x32, 0x64, 0x38, 0x66, 0x31, 0x35, 0x37, 0x39, 0x33, 0x65, 0x37, 0x64, 0x66, 0x37, 0x66, 0x38, 0x64, 0x63, 0x64, 0x62, 0x32, 0x31, 0x63, 0x38, 0x39, 0x31, 0x63, 0x66, 0x66, 0x37, 0x38, 0x63, 0x30, 0x64, 0x31, 0x38, 0x33, 0x39, 0x63, 0x62, 0x35, 0x62, 0x36, 0x64, 0x63, 0x64, 0x30, 0x36, 0x31, 0x31, 0x36, 0x63, 0x64, 0x62, 0x62, 0x39, 0x39, 0x35, 0x33, 0x36, 0x61, 0x65, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, 0x30, 0x63, 0x64, 0x62, 0x39, 0x37, 0x37, 0x31, 0x32, 0x61, 0x66, 0x36, 0x36, 0x38, 0x35, 0x62, 0x62, 0x39, 0x36, 0x35, 0x30, 0x64, 0x32, 0x31, 0x64, 0x36, 0x30, 0x39, 0x35, 0x32, 0x35, 0x39, 0x31, 0x33, 0x32, 0x39, 0x33, 0x63, 0x34, 0x38, 0x61, 0x64, 0x64, 0x61, 0x37, 0x63, 0x34, 0x35, 0x39, 0x39, 0x30, 0x39, 0x32, 0x36, 0x64, 0x61, 0x61, 0x64, 0x61, 0x33, 0x33, 0x35, 0x63, 0x39, 0x62, 0x22, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x37, 0x31, 0x38, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x2d, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x32, 0x30, 0x32, 0x36, 0x45, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x39, 0x30, 0x31, 0x61, 0x36, 0x30, 0x31, 0x38, 0x32, 0x63, 0x37, 0x30, 0x65, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x39, 0x64, 0x66, 0x38, 0x39, 0x62, 0x39, 0x34, 0x37, 0x37, 0x35, 0x33, 0x63, 0x66, 0x61, 0x64, 0x32, 0x35, 0x38, 0x65, 0x66, 0x62, 0x63, 0x35, 0x32, 0x61, 0x39, 0x61, 0x31, 0x34, 0x35, 0x32, 0x65, 0x34, 0x32, 0x66, 0x66, 0x62, 0x63, 0x65, 0x39, 0x62, 0x65, 0x34, 0x38, 0x36, 0x63, 0x62, 0x66, 0x38, 0x36, 0x33, 0x61, 0x30, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x64, 0x30, 0x33, 0x38, 0x36, 0x63, 0x31, 0x31, 0x32, 0x32, 0x65, 0x35, 0x36, 0x35, 0x66, 0x30, 0x37, 0x64, 0x64, 0x32, 0x38, 0x63, 0x37, 0x64, 0x31, 0x33, 0x34, 0x30, 0x65, 0x64, 0x35, 0x62, 0x33, 0x33, 0x31, 0x35, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x38, 0x34, 0x39, 0x65, 0x39, 0x39, 0x63, 0x33, 0x31, 0x65, 0x33, 0x31, 0x31, 0x33, 0x61, 0x34, 0x38, 0x39, 0x64, 0x37, 0x65, 0x62, 0x30, 0x66, 0x64, 0x34, 0x64, 0x38, 0x63, 0x30, 0x65, 0x64, 0x62, 0x65, 0x34, 0x37, 0x61, 0x66, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x62, 0x39, 0x32, 0x37, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x66, 0x39, 0x30, 0x31, 0x61, 0x37, 0x30, 0x31, 0x38, 0x33, 0x30, 0x31, 0x38, 0x65, 0x31, 0x63, 0x62, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x39, 0x64, 0x66, 0x38, 0x39, 0x62, 0x39, 0x34, 0x37, 0x37, 0x35, 0x33, 0x63, 0x66, 0x61, 0x64, 0x32, 0x35, 0x38, 0x65, 0x66, 0x62, 0x63, 0x35, 0x32, 0x61, 0x39, 0x61, 0x31, 0x34, 0x35, 0x32, 0x65, 0x34, 0x32, 0x66, 0x66, 0x62, 0x63, 0x65, 0x39, 0x62, 0x65, 0x34, 0x38, 0x36, 0x63, 0x62, 0x66, 0x38, 0x36, 0x33, 0x61, 0x30, 0x64, 0x64, 0x66, 0x32, 0x35, 0x32, 0x61, 0x64, 0x31, 0x62, 0x65, 0x32, 0x63, 0x38, 0x39, 0x62, 0x36, 0x39, 0x63, 0x32, 0x62, 0x30, 0x36, 0x38, 0x66, 0x63, 0x33, 0x37, 0x38, 0x64, 0x61, 0x61, 0x39, 0x35, 0x32, 0x62, 0x61, 0x37, 0x66, 0x31, 0x36, 0x33, 0x63, 0x34, 0x61, 0x31, 0x31, 0x36, 0x32, 0x38, 0x66, 0x35, 0x35, 0x61, 0x34, 0x64, 0x66, 0x35, 0x32, 0x33, 0x62, 0x33, 0x65, 0x66, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x38, 0x64, 0x30, 0x33, 0x38, 0x36, 0x63, 0x31, 0x31, 0x32, 0x32, 0x65, 0x35, 0x36, 0x35, 0x66, 0x30, 0x37, 0x64, 0x64, 0x32, 0x38, 0x63, 0x37, 0x64, 0x31, 0x33, 0x34, 0x30, 0x65, 0x64, 0x35, 0x62, 0x33, 0x33, 0x31, 0x35, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x63, 0x64, 0x61, 0x39, 0x64, 0x36, 0x63, 0x63, 0x36, 0x63, 0x65, 0x30, 0x35, 0x39, 0x38, 0x32, 0x64, 0x30, 0x62, 0x34, 0x66, 0x64, 0x66, 0x39, 0x34, 0x38, 0x30, 0x66, 0x32, 0x39, 0x39, 0x31, 0x66, 0x33, 0x39, 0x62, 0x35, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x62, 0x39, 0x32, 0x37, 0x30, 0x30, 0x22, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x37, 0x31, 0x38, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x2d, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x37, 0x31, 0x38, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x2d, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x67, 0x65, 0x74, 0x52, 0x61, 0x77, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x61, 0x32, 0x66, 0x64, 0x31, 0x61, 0x35, 0x65, 0x61, 0x39, 0x66, 0x66, 0x65, 0x65, 0x34, 0x37, 0x37, 0x66, 0x34, 0x34, 0x39, 0x62, 0x65, 0x35, 0x33, 0x61, 0x34, 0x39, 0x33, 0x39, 0x38, 0x35, 0x33, 0x33, 0x64, 0x32, 0x63, 0x30, 0x30, 0x36, 0x61, 0x35, 0x38, 0x31, 0x35, 0x30, 0x32, 0x33, 0x39, 0x32, 0x30, 0x64, 0x31, 0x63, 0x33, 0x39, 0x37, 0x32, 0x39, 0x38, 0x64, 0x66, 0x33, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x37, 0x31, 0x38, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x2d, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x37, 0x38, 0x30, 0x38, 0x34, 0x33, 0x34, 0x32, 0x37, 0x37, 0x30, 0x63, 0x31, 0x38, 0x32, 0x35, 0x32, 0x30, 0x38, 0x39, 0x34, 0x36, 0x35, 0x38, 0x62, 0x64, 0x66, 0x34, 0x33, 0x35, 0x64, 0x38, 0x31, 0x30, 0x63, 0x39, 0x31, 0x34, 0x31, 0x34, 0x65, 0x63, 0x30, 0x39, 0x31, 0x34, 0x37, 0x64, 0x61, 0x61, 0x36, 0x64, 0x62, 0x36, 0x32, 0x34, 0x30, 0x36, 0x33, 0x37, 0x39, 0x38, 0x32, 0x30, 0x33, 0x65, 0x38, 0x38, 0x30, 0x38, 0x32, 0x30, 0x61, 0x39, 0x35, 0x61, 0x30, 0x61, 0x66, 0x35, 0x66, 0x63, 0x33, 0x35, 0x31, 0x62, 0x39, 0x65, 0x34, 0x35, 0x37, 0x61, 0x33, 0x31, 0x66, 0x33, 0x37, 0x63, 0x38, 0x34, 0x65, 0x35, 0x63, 0x64, 0x39, 0x39, 0x64, 0x64, 0x33, 0x63, 0x35, 0x64, 0x65, 0x36, 0x30, 0x61, 0x66, 0x33, 0x64, 0x65, 0x33, 0x33, 0x63, 0x36, 0x66, 0x34, 0x31, 0x36, 0x30, 0x31, 0x37, 0x37, 0x61, 0x32, 0x63, 0x37, 0x38, 0x36, 0x61, 0x36, 0x30, 0x61, 0x30, 0x32, 0x30, 0x31, 0x64, 0x61, 0x37, 0x61, 0x32, 0x31, 0x30, 0x34, 0x36, 0x61, 0x66, 0x35, 0x35, 0x38, 0x33, 0x37, 0x33, 0x33, 0x30, 0x61, 0x32, 0x63, 0x35, 0x32, 0x66, 0x63, 0x31, 0x35, 0x34, 0x33, 0x63, 0x64, 0x34, 0x64, 0x39, 0x65, 0x61, 0x64, 0x30, 0x30, 0x64, 0x64, 0x66, 0x31, 0x37, 0x38, 0x64, 0x64, 0x39, 0x36, 0x39, 0x33, 0x35, 0x62, 0x36, 0x30, 0x37, 0x66, 0x66, 0x39, 0x62, 0x22, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x20, 0x41, 0x50, 0x49, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x22, 0x5d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x56, 0x31, 0x22, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x69, 0x73, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x76, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x69, 0x73, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x76, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x65, 0x61, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x61, 0x66, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x66, 0x65, 0x65, 0x20, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x53, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x2c, 0x20, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x2c, 0x20, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x32, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x33, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x31, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x66, 0x33, 0x32, 0x63, 0x63, 0x31, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x76, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x65, 0x61, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x61, 0x66, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x66, 0x65, 0x65, 0x20, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x53, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x2c, 0x20, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x2c, 0x20, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x32, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x33, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x32, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x66, 0x33, 0x32, 0x63, 0x63, 0x31, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x33, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x75, 0x6e, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x76, 0x33, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x65, 0x61, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x61, 0x66, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x33, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x66, 0x65, 0x65, 0x20, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x53, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x2c, 0x20, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x2c, 0x20, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x32, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x33, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x32, 0x36, 0x30, 0x32, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x35, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x56, 0x33, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x65, 0x64, 0x46, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x66, 0x37, 0x38, 0x30, 0x61, 0x39, 0x35, 0x34, 0x62, 0x63, 0x62, 0x61, 0x38, 0x38, 0x38, 0x39, 0x39, 0x39, 0x38, 0x65, 0x34, 0x65, 0x36, 0x31, 0x64, 0x65, 0x61, 0x61, 0x65, 0x36, 0x33, 0x38, 0x38, 0x64, 0x64, 0x32, 0x33, 0x39, 0x31, 0x65, 0x39, 0x63, 0x38, 0x31, 0x30, 0x62, 0x64, 0x39, 0x63, 0x39, 0x34, 0x39, 0x36, 0x32, 0x63, 0x63, 0x31, 0x65, 0x61, 0x64, 0x63, 0x31, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x66, 0x33, 0x32, 0x63, 0x63, 0x31, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x47, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x62, 0x79, 0x68, 0x61, 0x73, 0x68, 0x76, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x34, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x6f, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x56, 0x31, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x64, 0x35, 0x66, 0x31, 0x38, 0x31, 0x32, 0x35, 0x34, 0x38, 0x62, 0x65, 0x34, 0x32, 0x39, 0x63, 0x62, 0x64, 0x63, 0x36, 0x33, 0x37, 0x36, 0x62, 0x32, 0x39, 0x36, 0x31, 0x31, 0x66, 0x63, 0x34, 0x39, 0x65, 0x30, 0x36, 0x66, 0x31, 0x33, 0x35, 0x39, 0x37, 0x35, 0x38, 0x63, 0x34, 0x63, 0x65, 0x61, 0x61, 0x61, 0x33, 0x62, 0x33, 0x39, 0x33, 0x65, 0x32, 0x32, 0x33, 0x39, 0x66, 0x39, 0x63, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x66, 0x65, 0x38, 0x38, 0x63, 0x39, 0x34, 0x64, 0x38, 0x36, 0x30, 0x66, 0x30, 0x31, 0x61, 0x31, 0x37, 0x66, 0x39, 0x36, 0x31, 0x62, 0x66, 0x34, 0x62, 0x64, 0x66, 0x62, 0x36, 0x65, 0x30, 0x63, 0x36, 0x63, 0x64, 0x31, 0x30, 0x64, 0x33, 0x66, 0x64, 0x61, 0x35, 0x63, 0x63, 0x38, 0x36, 0x31, 0x65, 0x38, 0x30, 0x35, 0x63, 0x61, 0x31, 0x32, 0x34, 0x30, 0x63, 0x35, 0x38, 0x35, 0x35, 0x33, 0x22, 0x5d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x38, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x32, 0x63, 0x34, 0x64, 0x38, 0x38, 0x62, 0x66, 0x64, 0x63, 0x32, 0x66, 0x36, 0x64, 0x62, 0x66, 0x38, 0x32, 0x63, 0x33, 0x33, 0x64, 0x32, 0x33, 0x35, 0x63, 0x34, 0x65, 0x37, 0x38, 0x35, 0x65, 0x39, 0x66, 0x63, 0x32, 0x33, 0x62, 0x32, 0x64, 0x30, 0x66, 0x63, 0x37, 0x62, 0x39, 0x64, 0x32, 0x30, 0x66, 0x63, 0x35, 0x65, 0x39, 0x36, 0x37, 0x34, 0x66, 0x31, 0x66, 0x39, 0x64, 0x31, 0x35, 0x61, 0x30, 0x31, 0x36, 0x64, 0x36, 0x64, 0x36, 0x39, 0x62, 0x39, 0x32, 0x35, 0x63, 0x66, 0x32, 0x36, 0x31, 0x32, 0x38, 0x36, 0x38, 0x33, 0x61, 0x62, 0x34, 0x61, 0x30, 0x39, 0x36, 0x65, 0x31, 0x39, 0x36, 0x66, 0x62, 0x62, 0x31, 0x31, 0x34, 0x32, 0x64, 0x36, 0x63, 0x36, 0x64, 0x34, 0x65, 0x38, 0x64, 0x33, 0x34, 0x38, 0x31, 0x62, 0x39, 0x62, 0x65, 0x66, 0x31, 0x62, 0x64, 0x30, 0x66, 0x36, 0x35, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x33, 0x39, 0x34, 0x30, 0x39, 0x62, 0x34, 0x65, 0x35, 0x36, 0x30, 0x33, 0x64, 0x64, 0x38, 0x63, 0x33, 0x63, 0x66, 0x33, 0x38, 0x32, 0x33, 0x32, 0x33, 0x34, 0x38, 0x36, 0x36, 0x31, 0x61, 0x38, 0x65, 0x39, 0x39, 0x61, 0x63, 0x35, 0x31, 0x38, 0x33, 0x39, 0x36, 0x65, 0x65, 0x61, 0x61, 0x31, 0x32, 0x38, 0x65, 0x63, 0x39, 0x65, 0x63, 0x32, 0x61, 0x33, 0x65, 0x62, 0x38, 0x31, 0x32, 0x37, 0x61, 0x30, 0x36, 0x62, 0x32, 0x31, 0x61, 0x62, 0x39, 0x35, 0x36, 0x66, 0x35, 0x66, 0x31, 0x33, 0x38, 0x63, 0x62, 0x34, 0x34, 0x66, 0x64, 0x61, 0x31, 0x61, 0x39, 0x30, 0x35, 0x35, 0x62, 0x64, 0x30, 0x38, 0x39, 0x38, 0x30, 0x65, 0x61, 0x34, 0x66, 0x38, 0x30, 0x34, 0x30, 0x64, 0x38, 0x37, 0x37, 0x63, 0x30, 0x30, 0x64, 0x61, 0x63, 0x30, 0x32, 0x35, 0x36, 0x30, 0x38, 0x64, 0x30, 0x64, 0x39, 0x35, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x31, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x64, 0x39, 0x37, 0x31, 0x32, 0x61, 0x33, 0x63, 0x34, 0x30, 0x61, 0x65, 0x38, 0x35, 0x61, 0x65, 0x61, 0x34, 0x61, 0x64, 0x31, 0x62, 0x64, 0x39, 0x35, 0x61, 0x30, 0x62, 0x37, 0x63, 0x63, 0x37, 0x62, 0x64, 0x38, 0x30, 0x35, 0x31, 0x38, 0x39, 0x61, 0x39, 0x65, 0x32, 0x35, 0x31, 0x37, 0x34, 0x30, 0x33, 0x62, 0x31, 0x31, 0x61, 0x30, 0x30, 0x61, 0x31, 0x35, 0x33, 0x30, 0x66, 0x38, 0x31, 0x61, 0x30, 0x35, 0x33, 0x62, 0x35, 0x33, 0x62, 0x30, 0x32, 0x36, 0x37, 0x61, 0x36, 0x64, 0x63, 0x66, 0x65, 0x39, 0x66, 0x39, 0x61, 0x31, 0x36, 0x35, 0x32, 0x33, 0x30, 0x37, 0x62, 0x33, 0x39, 0x36, 0x62, 0x33, 0x65, 0x38, 0x61, 0x36, 0x35, 0x65, 0x36, 0x35, 0x37, 0x30, 0x37, 0x61, 0x34, 0x35, 0x30, 0x65, 0x36, 0x30, 0x63, 0x39, 0x32, 0x62, 0x61, 0x65, 0x66, 0x64, 0x62, 0x63, 0x66, 0x62, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x31, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x37, 0x31, 0x64, 0x33, 0x36, 0x62, 0x63, 0x39, 0x33, 0x63, 0x37, 0x61, 0x65, 0x38, 0x63, 0x63, 0x35, 0x63, 0x30, 0x31, 0x35, 0x30, 0x31, 0x65, 0x35, 0x31, 0x65, 0x35, 0x65, 0x39, 0x37, 0x61, 0x35, 0x31, 0x61, 0x61, 0x35, 0x34, 0x31, 0x64, 0x31, 0x61, 0x38, 0x39, 0x63, 0x38, 0x30, 0x39, 0x61, 0x32, 0x61, 0x66, 0x37, 0x65, 0x62, 0x34, 0x30, 0x65, 0x39, 0x62, 0x63, 0x32, 0x63, 0x62, 0x61, 0x30, 0x37, 0x31, 0x36, 0x34, 0x34, 0x32, 0x33, 0x30, 0x65, 0x32, 0x31, 0x63, 0x30, 0x37, 0x35, 0x63, 0x31, 0x64, 0x61, 0x30, 0x38, 0x39, 0x31, 0x36, 0x61, 0x66, 0x66, 0x35, 0x65, 0x66, 0x65, 0x39, 0x66, 0x39, 0x35, 0x61, 0x36, 0x66, 0x36, 0x61, 0x34, 0x66, 0x39, 0x34, 0x64, 0x63, 0x32, 0x31, 0x37, 0x66, 0x36, 0x63, 0x31, 0x62, 0x62, 0x34, 0x61, 0x33, 0x32, 0x34, 0x30, 0x62, 0x32, 0x39, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x47, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x72, 0x61, 0x67, 0x75, 0x65, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x62, 0x79, 0x68, 0x61, 0x73, 0x68, 0x76, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x39, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x20, 0x2d, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x2d, 0x20, 0x27, 0x6e, 0x75, 0x6c, 0x6c, 0x27, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x34, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x6f, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x56, 0x32, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x64, 0x35, 0x66, 0x31, 0x38, 0x31, 0x32, 0x35, 0x34, 0x38, 0x62, 0x65, 0x34, 0x32, 0x39, 0x63, 0x62, 0x64, 0x63, 0x36, 0x33, 0x37, 0x36, 0x62, 0x32, 0x39, 0x36, 0x31, 0x31, 0x66, 0x63, 0x34, 0x39, 0x65, 0x30, 0x36, 0x66, 0x31, 0x33, 0x35, 0x39, 0x37, 0x35, 0x38, 0x63, 0x34, 0x63, 0x65, 0x61, 0x61, 0x61, 0x33, 0x62, 0x33, 0x39, 0x33, 0x65, 0x32, 0x32, 0x33, 0x39, 0x66, 0x39, 0x63, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x66, 0x65, 0x38, 0x38, 0x63, 0x39, 0x34, 0x64, 0x38, 0x36, 0x30, 0x66, 0x30, 0x31, 0x61, 0x31, 0x37, 0x66, 0x39, 0x36, 0x31, 0x62, 0x66, 0x34, 0x62, 0x64, 0x66, 0x62, 0x36, 0x65, 0x30, 0x63, 0x36, 0x63, 0x64, 0x31, 0x30, 0x64, 0x33, 0x66, 0x64, 0x61, 0x35, 0x63, 0x63, 0x38, 0x36, 0x31, 0x65, 0x38, 0x30, 0x35, 0x63, 0x61, 0x31, 0x32, 0x34, 0x30, 0x63, 0x35, 0x38, 0x35, 0x35, 0x33, 0x22, 0x5d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x38, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x32, 0x63, 0x34, 0x64, 0x38, 0x38, 0x62, 0x66, 0x64, 0x63, 0x32, 0x66, 0x36, 0x64, 0x62, 0x66, 0x38, 0x32, 0x63, 0x33, 0x33, 0x64, 0x32, 0x33, 0x35, 0x63, 0x34, 0x65, 0x37, 0x38, 0x35, 0x65, 0x39, 0x66, 0x63, 0x32, 0x33, 0x62, 0x32, 0x64, 0x30, 0x66, 0x63, 0x37, 0x62, 0x39, 0x64, 0x32, 0x30, 0x66, 0x63, 0x35, 0x65, 0x39, 0x36, 0x37, 0x34, 0x66, 0x31, 0x66, 0x39, 0x64, 0x31, 0x35, 0x61, 0x30, 0x31, 0x36, 0x64, 0x36, 0x64, 0x36, 0x39, 0x62, 0x39, 0x32, 0x35, 0x63, 0x66, 0x32, 0x36, 0x31, 0x32, 0x38, 0x36, 0x38, 0x33, 0x61, 0x62, 0x34, 0x61, 0x30, 0x39, 0x36, 0x65, 0x31, 0x39, 0x36, 0x66, 0x62, 0x62, 0x31, 0x31, 0x34, 0x32, 0x64, 0x36, 0x63, 0x36, 0x64, 0x34, 0x65, 0x38, 0x64, 0x33, 0x34, 0x38, 0x31, 0x62, 0x39, 0x62, 0x65, 0x66, 0x31, 0x62, 0x64, 0x30, 0x66, 0x36, 0x35, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x33, 0x39, 0x34, 0x30, 0x39, 0x62, 0x34, 0x65, 0x35, 0x36, 0x30, 0x33, 0x64, 0x64, 0x38, 0x63, 0x33, 0x63, 0x66, 0x33, 0x38, 0x32, 0x33, 0x32, 0x33, 0x34, 0x38, 0x36, 0x36, 0x31, 0x61, 0x38, 0x65, 0x39, 0x39, 0x61, 0x63, 0x35, 0x31, 0x38, 0x33, 0x39, 0x36, 0x65, 0x65, 0x61, 0x61, 0x31, 0x32, 0x38, 0x65, 0x63, 0x39, 0x65, 0x63, 0x32, 0x61, 0x33, 0x65, 0x62, 0x38, 0x31, 0x32, 0x37, 0x61, 0x30, 0x36, 0x62, 0x32, 0x31, 0x61, 0x62, 0x39, 0x35, 0x36, 0x66, 0x35, 0x66, 0x31, 0x33, 0x38, 0x63, 0x62, 0x34, 0x34, 0x66, 0x64, 0x61, 0x31, 0x61, 0x39, 0x30, 0x35, 0x35, 0x62, 0x64, 0x30, 0x38, 0x39, 0x38, 0x30, 0x65, 0x61, 0x34, 0x66, 0x38, 0x30, 0x34, 0x30, 0x64, 0x38, 0x37, 0x37, 0x63, 0x30, 0x30, 0x64, 0x61, 0x63, 0x30, 0x32, 0x35, 0x36, 0x30, 0x38, 0x64, 0x30, 0x64, 0x39, 0x35, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x36, 0x61, 0x39, 0x36, 0x30, 0x38, 0x36, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x66, 0x31, 0x37, 0x36, 0x36, 0x38, 0x66, 0x33, 0x35, 0x66, 0x37, 0x34, 0x31, 0x38, 0x65, 0x66, 0x38, 0x37, 0x39, 0x38, 0x30, 0x37, 0x39, 0x31, 0x36, 0x37, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x37, 0x32, 0x65, 0x63, 0x64, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x32, 0x36, 0x31, 0x33, 0x37, 0x63, 0x66, 0x34, 0x35, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x32, 0x34, 0x37, 0x38, 0x36, 0x61, 0x62, 0x33, 0x34, 0x38, 0x33, 0x63, 0x32, 0x66, 0x39, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x33, 0x66, 0x35, 0x31, 0x30, 0x32, 0x64, 0x61, 0x62, 0x65, 0x30, 0x61, 0x32, 0x37, 0x62, 0x31, 0x37, 0x34, 0x36, 0x30, 0x39, 0x38, 0x64, 0x31, 0x64, 0x63, 0x31, 0x37, 0x61, 0x35, 0x64, 0x33, 0x66, 0x62, 0x64, 0x34, 0x37, 0x38, 0x37, 0x35, 0x39, 0x66, 0x65, 0x61, 0x39, 0x32, 0x38, 0x37, 0x65, 0x34, 0x65, 0x34, 0x31, 0x39, 0x62, 0x33, 0x63, 0x33, 0x63, 0x65, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x31, 0x61, 0x63, 0x64, 0x62, 0x32, 0x63, 0x34, 0x64, 0x33, 0x64, 0x66, 0x33, 0x66, 0x31, 0x62, 0x38, 0x64, 0x33, 0x62, 0x66, 0x64, 0x33, 0x33, 0x34, 0x32, 0x31, 0x36, 0x36, 0x30, 0x64, 0x66, 0x33, 0x35, 0x38, 0x64, 0x38, 0x34, 0x64, 0x37, 0x38, 0x64, 0x31, 0x36, 0x63, 0x34, 0x36, 0x30, 0x33, 0x35, 0x35, 0x31, 0x39, 0x33, 0x35, 0x66, 0x34, 0x62, 0x36, 0x37, 0x36, 0x34, 0x33, 0x33, 0x37, 0x33, 0x65, 0x37, 0x65, 0x62, 0x36, 0x33, 0x64, 0x63, 0x62, 0x31, 0x36, 0x65, 0x63, 0x33, 0x35, 0x39, 0x62, 0x65, 0x30, 0x65, 0x63, 0x34, 0x31, 0x66, 0x65, 0x65, 0x33, 0x33, 0x62, 0x30, 0x33, 0x61, 0x31, 0x36, 0x65, 0x38, 0x30, 0x37, 0x34, 0x35, 0x66, 0x32, 0x33, 0x37, 0x34, 0x66, 0x66, 0x31, 0x64, 0x33, 0x63, 0x33, 0x35, 0x32, 0x35, 0x30, 0x38, 0x61, 0x63, 0x35, 0x64, 0x38, 0x35, 0x37, 0x63, 0x36, 0x34, 0x37, 0x36, 0x64, 0x33, 0x63, 0x33, 0x62, 0x63, 0x66, 0x37, 0x65, 0x36, 0x63, 0x61, 0x33, 0x37, 0x34, 0x32, 0x37, 0x63, 0x39, 0x32, 0x30, 0x39, 0x66, 0x31, 0x37, 0x62, 0x65, 0x33, 0x61, 0x66, 0x35, 0x32, 0x36, 0x34, 0x63, 0x30, 0x65, 0x32, 0x31, 0x33, 0x32, 0x62, 0x33, 0x64, 0x64, 0x31, 0x31, 0x35, 0x36, 0x63, 0x32, 0x38, 0x62, 0x34, 0x65, 0x39, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x36, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x36, 0x61, 0x39, 0x36, 0x30, 0x38, 0x36, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x66, 0x31, 0x37, 0x36, 0x36, 0x38, 0x66, 0x33, 0x35, 0x66, 0x37, 0x34, 0x31, 0x38, 0x65, 0x66, 0x38, 0x37, 0x39, 0x38, 0x30, 0x37, 0x39, 0x31, 0x36, 0x37, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x37, 0x32, 0x65, 0x63, 0x64, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x32, 0x36, 0x31, 0x33, 0x37, 0x63, 0x66, 0x34, 0x35, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x32, 0x34, 0x37, 0x38, 0x36, 0x61, 0x62, 0x33, 0x34, 0x38, 0x33, 0x63, 0x32, 0x66, 0x39, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x63, 0x38, 0x35, 0x61, 0x36, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x63, 0x32, 0x31, 0x35, 0x66, 0x36, 0x61, 0x31, 0x32, 0x38, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x31, 0x65, 0x65, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x36, 0x34, 0x32, 0x34, 0x34, 0x30, 0x34, 0x33, 0x61, 0x35, 0x66, 0x36, 0x33, 0x39, 0x61, 0x61, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x32, 0x30, 0x34, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x63, 0x38, 0x35, 0x31, 0x66, 0x32, 0x39, 0x63, 0x37, 0x63, 0x31, 0x38, 0x33, 0x62, 0x65, 0x32, 0x35, 0x33, 0x65, 0x61, 0x31, 0x35, 0x31, 0x30, 0x62, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x31, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x64, 0x39, 0x37, 0x31, 0x32, 0x61, 0x33, 0x63, 0x34, 0x30, 0x61, 0x65, 0x38, 0x35, 0x61, 0x65, 0x61, 0x34, 0x61, 0x64, 0x31, 0x62, 0x64, 0x39, 0x35, 0x61, 0x30, 0x62, 0x37, 0x63, 0x63, 0x37, 0x62, 0x64, 0x38, 0x30, 0x35, 0x31, 0x38, 0x39, 0x61, 0x39, 0x65, 0x32, 0x35, 0x31, 0x37, 0x34, 0x30, 0x33, 0x62, 0x31, 0x31, 0x61, 0x30, 0x30, 0x61, 0x31, 0x35, 0x33, 0x30, 0x66, 0x38, 0x31, 0x61, 0x30, 0x35, 0x33, 0x62, 0x35, 0x33, 0x62, 0x30, 0x32, 0x36, 0x37, 0x61, 0x36, 0x64, 0x63, 0x66, 0x65, 0x39, 0x66, 0x39, 0x61, 0x31, 0x36, 0x35, 0x32, 0x33, 0x30, 0x37, 0x62, 0x33, 0x39, 0x36, 0x62, 0x33, 0x65, 0x38, 0x61, 0x36, 0x35, 0x65, 0x36, 0x35, 0x37, 0x30, 0x37, 0x61, 0x34, 0x35, 0x30, 0x65, 0x36, 0x30, 0x63, 0x39, 0x32, 0x62, 0x61, 0x65, 0x66, 0x64, 0x62, 0x63, 0x66, 0x62, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x31, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x37, 0x31, 0x64, 0x33, 0x36, 0x62, 0x63, 0x39, 0x33, 0x63, 0x37, 0x61, 0x65, 0x38, 0x63, 0x63, 0x35, 0x63, 0x30, 0x31, 0x35, 0x30, 0x31, 0x65, 0x35, 0x31, 0x65, 0x35, 0x65, 0x39, 0x37, 0x61, 0x35, 0x31, 0x61, 0x61, 0x35, 0x34, 0x31, 0x64, 0x31, 0x61, 0x38, 0x39, 0x63, 0x38, 0x30, 0x39, 0x61, 0x32, 0x61, 0x66, 0x37, 0x65, 0x62, 0x34, 0x30, 0x65, 0x39, 0x62, 0x63, 0x32, 0x63, 0x62, 0x61, 0x30, 0x37, 0x31, 0x36, 0x34, 0x34, 0x32, 0x33, 0x30, 0x65, 0x32, 0x31, 0x63, 0x30, 0x37, 0x35, 0x63, 0x31, 0x64, 0x61, 0x30, 0x38, 0x39, 0x31, 0x36, 0x61, 0x66, 0x66, 0x35, 0x65, 0x66, 0x65, 0x39, 0x66, 0x39, 0x35, 0x61, 0x36, 0x66, 0x36, 0x61, 0x34, 0x66, 0x39, 0x34, 0x64, 0x63, 0x32, 0x31, 0x37, 0x66, 0x36, 0x63, 0x31, 0x62, 0x62, 0x34, 0x61, 0x33, 0x32, 0x34, 0x30, 0x62, 0x32, 0x39, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x63, 0x38, 0x35, 0x61, 0x36, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x63, 0x32, 0x31, 0x35, 0x66, 0x36, 0x61, 0x31, 0x32, 0x38, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x31, 0x65, 0x65, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x36, 0x34, 0x32, 0x34, 0x34, 0x30, 0x34, 0x33, 0x61, 0x35, 0x66, 0x36, 0x33, 0x39, 0x61, 0x61, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x32, 0x30, 0x34, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x63, 0x38, 0x35, 0x31, 0x66, 0x32, 0x39, 0x63, 0x37, 0x63, 0x31, 0x38, 0x33, 0x62, 0x65, 0x32, 0x35, 0x33, 0x65, 0x61, 0x31, 0x35, 0x31, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x31, 0x64, 0x62, 0x37, 0x30, 0x63, 0x34, 0x38, 0x35, 0x62, 0x36, 0x32, 0x36, 0x34, 0x36, 0x39, 0x32, 0x66, 0x32, 0x36, 0x62, 0x38, 0x61, 0x65, 0x61, 0x61, 0x62, 0x35, 0x62, 0x30, 0x63, 0x33, 0x38, 0x34, 0x31, 0x38, 0x30, 0x64, 0x66, 0x38, 0x65, 0x32, 0x31, 0x38, 0x34, 0x61, 0x32, 0x31, 0x61, 0x38, 0x30, 0x38, 0x61, 0x33, 0x65, 0x63, 0x38, 0x65, 0x38, 0x36, 0x63, 0x61, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x35, 0x36, 0x31, 0x37, 0x33, 0x31, 0x37, 0x38, 0x35, 0x62, 0x34, 0x38, 0x63, 0x66, 0x31, 0x38, 0x38, 0x36, 0x34, 0x31, 0x32, 0x32, 0x33, 0x34, 0x35, 0x33, 0x31, 0x65, 0x34, 0x39, 0x34, 0x30, 0x30, 0x36, 0x34, 0x35, 0x38, 0x34, 0x34, 0x36, 0x33, 0x65, 0x39, 0x36, 0x61, 0x63, 0x36, 0x33, 0x61, 0x31, 0x61, 0x31, 0x35, 0x34, 0x33, 0x32, 0x30, 0x32, 0x32, 0x37, 0x65, 0x33, 0x33, 0x33, 0x66, 0x62, 0x35, 0x31, 0x61, 0x64, 0x64, 0x63, 0x34, 0x61, 0x38, 0x39, 0x62, 0x37, 0x65, 0x30, 0x64, 0x33, 0x66, 0x38, 0x36, 0x32, 0x64, 0x37, 0x63, 0x31, 0x66, 0x64, 0x34, 0x65, 0x61, 0x30, 0x33, 0x62, 0x64, 0x38, 0x65, 0x62, 0x33, 0x64, 0x38, 0x38, 0x30, 0x36, 0x66, 0x31, 0x65, 0x37, 0x64, 0x61, 0x66, 0x35, 0x39, 0x31, 0x63, 0x62, 0x62, 0x62, 0x62, 0x39, 0x32, 0x62, 0x30, 0x62, 0x65, 0x62, 0x37, 0x34, 0x64, 0x31, 0x33, 0x63, 0x30, 0x31, 0x36, 0x31, 0x37, 0x66, 0x32, 0x32, 0x63, 0x35, 0x30, 0x32, 0x36, 0x62, 0x34, 0x66, 0x39, 0x66, 0x39, 0x66, 0x32, 0x39, 0x34, 0x61, 0x38, 0x61, 0x37, 0x63, 0x33, 0x32, 0x64, 0x62, 0x38, 0x39, 0x35, 0x64, 0x65, 0x33, 0x62, 0x30, 0x31, 0x62, 0x65, 0x65, 0x30, 0x31, 0x33, 0x32, 0x63, 0x39, 0x32, 0x30, 0x39, 0x65, 0x31, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x36, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x64, 0x61, 0x65, 0x65, 0x64, 0x37, 0x33, 0x34, 0x64, 0x61, 0x31, 0x31, 0x34, 0x34, 0x37, 0x30, 0x64, 0x61, 0x35, 0x35, 0x39, 0x62, 0x64, 0x34, 0x62, 0x34, 0x63, 0x37, 0x32, 0x35, 0x39, 0x65, 0x31, 0x66, 0x37, 0x39, 0x35, 0x32, 0x35, 0x35, 0x35, 0x32, 0x34, 0x31, 0x64, 0x63, 0x62, 0x63, 0x39, 0x30, 0x63, 0x66, 0x31, 0x39, 0x34, 0x61, 0x32, 0x65, 0x66, 0x36, 0x37, 0x36, 0x66, 0x63, 0x36, 0x30, 0x30, 0x35, 0x66, 0x33, 0x36, 0x37, 0x32, 0x66, 0x61, 0x64, 0x61, 0x32, 0x61, 0x33, 0x36, 0x34, 0x35, 0x65, 0x64, 0x62, 0x32, 0x39, 0x37, 0x61, 0x37, 0x35, 0x35, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x64, 0x61, 0x65, 0x65, 0x64, 0x37, 0x33, 0x34, 0x64, 0x61, 0x31, 0x31, 0x34, 0x34, 0x37, 0x30, 0x64, 0x61, 0x35, 0x35, 0x39, 0x62, 0x64, 0x34, 0x62, 0x34, 0x63, 0x37, 0x32, 0x35, 0x39, 0x65, 0x31, 0x66, 0x37, 0x39, 0x35, 0x32, 0x35, 0x35, 0x35, 0x32, 0x34, 0x31, 0x64, 0x63, 0x62, 0x63, 0x39, 0x30, 0x63, 0x66, 0x31, 0x39, 0x34, 0x61, 0x32, 0x65, 0x66, 0x36, 0x37, 0x36, 0x66, 0x63, 0x36, 0x30, 0x30, 0x35, 0x66, 0x33, 0x36, 0x37, 0x32, 0x66, 0x61, 0x64, 0x61, 0x32, 0x61, 0x33, 0x36, 0x34, 0x35, 0x65, 0x64, 0x62, 0x32, 0x39, 0x37, 0x61, 0x37, 0x35, 0x35, 0x33, 0x22, 0x7d, 0x5d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x47, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x62, 0x79, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x76, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x36, 0x34, 0x20, 0x62, 0x69, 0x74, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x36, 0x34, 0x20, 0x62, 0x69, 0x74, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x34, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x6f, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x56, 0x31, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x30, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x38, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x32, 0x63, 0x34, 0x64, 0x38, 0x38, 0x62, 0x66, 0x64, 0x63, 0x32, 0x66, 0x36, 0x64, 0x62, 0x66, 0x38, 0x32, 0x63, 0x33, 0x33, 0x64, 0x32, 0x33, 0x35, 0x63, 0x34, 0x65, 0x37, 0x38, 0x35, 0x65, 0x39, 0x66, 0x63, 0x32, 0x33, 0x62, 0x32, 0x64, 0x30, 0x66, 0x63, 0x37, 0x62, 0x39, 0x64, 0x32, 0x30, 0x66, 0x63, 0x35, 0x65, 0x39, 0x36, 0x37, 0x34, 0x66, 0x31, 0x66, 0x39, 0x64, 0x31, 0x35, 0x61, 0x30, 0x31, 0x36, 0x64, 0x36, 0x64, 0x36, 0x39, 0x62, 0x39, 0x32, 0x35, 0x63, 0x66, 0x32, 0x36, 0x31, 0x32, 0x38, 0x36, 0x38, 0x33, 0x61, 0x62, 0x34, 0x61, 0x30, 0x39, 0x36, 0x65, 0x31, 0x39, 0x36, 0x66, 0x62, 0x62, 0x31, 0x31, 0x34, 0x32, 0x64, 0x36, 0x63, 0x36, 0x64, 0x34, 0x65, 0x38, 0x64, 0x33, 0x34, 0x38, 0x31, 0x62, 0x39, 0x62, 0x65, 0x66, 0x31, 0x62, 0x64, 0x30, 0x66, 0x36, 0x35, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x33, 0x39, 0x34, 0x30, 0x39, 0x62, 0x34, 0x65, 0x35, 0x36, 0x30, 0x33, 0x64, 0x64, 0x38, 0x63, 0x33, 0x63, 0x66, 0x33, 0x38, 0x32, 0x33, 0x32, 0x33, 0x34, 0x38, 0x36, 0x36, 0x31, 0x61, 0x38, 0x65, 0x39, 0x39, 0x61, 0x63, 0x35, 0x31, 0x38, 0x33, 0x39, 0x36, 0x65, 0x65, 0x61, 0x61, 0x31, 0x32, 0x38, 0x65, 0x63, 0x39, 0x65, 0x63, 0x32, 0x61, 0x33, 0x65, 0x62, 0x38, 0x31, 0x32, 0x37, 0x61, 0x30, 0x36, 0x62, 0x32, 0x31, 0x61, 0x62, 0x39, 0x35, 0x36, 0x66, 0x35, 0x66, 0x31, 0x33, 0x38, 0x63, 0x62, 0x34, 0x34, 0x66, 0x64, 0x61, 0x31, 0x61, 0x39, 0x30, 0x35, 0x35, 0x62, 0x64, 0x30, 0x38, 0x39, 0x38, 0x30, 0x65, 0x61, 0x34, 0x66, 0x38, 0x30, 0x34, 0x30, 0x64, 0x38, 0x37, 0x37, 0x63, 0x30, 0x30, 0x64, 0x61, 0x63, 0x30, 0x32, 0x35, 0x36, 0x30, 0x38, 0x64, 0x30, 0x64, 0x39, 0x35, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x31, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x64, 0x39, 0x37, 0x31, 0x32, 0x61, 0x33, 0x63, 0x34, 0x30, 0x61, 0x65, 0x38, 0x35, 0x61, 0x65, 0x61, 0x34, 0x61, 0x64, 0x31, 0x62, 0x64, 0x39, 0x35, 0x61, 0x30, 0x62, 0x37, 0x63, 0x63, 0x37, 0x62, 0x64, 0x38, 0x30, 0x35, 0x31, 0x38, 0x39, 0x61, 0x39, 0x65, 0x32, 0x35, 0x31, 0x37, 0x34, 0x30, 0x33, 0x62, 0x31, 0x31, 0x61, 0x30, 0x30, 0x61, 0x31, 0x35, 0x33, 0x30, 0x66, 0x38, 0x31, 0x61, 0x30, 0x35, 0x33, 0x62, 0x35, 0x33, 0x62, 0x30, 0x32, 0x36, 0x37, 0x61, 0x36, 0x64, 0x63, 0x66, 0x65, 0x39, 0x66, 0x39, 0x61, 0x31, 0x36, 0x35, 0x32, 0x33, 0x30, 0x37, 0x62, 0x33, 0x39, 0x36, 0x62, 0x33, 0x65, 0x38, 0x61, 0x36, 0x35, 0x65, 0x36, 0x35, 0x37, 0x30, 0x37, 0x61, 0x34, 0x35, 0x30, 0x65, 0x36, 0x30, 0x63, 0x39, 0x32, 0x62, 0x61, 0x65, 0x66, 0x64, 0x62, 0x63, 0x66, 0x62, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x31, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x37, 0x31, 0x64, 0x33, 0x36, 0x62, 0x63, 0x39, 0x33, 0x63, 0x37, 0x61, 0x65, 0x38, 0x63, 0x63, 0x35, 0x63, 0x30, 0x31, 0x35, 0x30, 0x31, 0x65, 0x35, 0x31, 0x65, 0x35, 0x65, 0x39, 0x37, 0x61, 0x35, 0x31, 0x61, 0x61, 0x35, 0x34, 0x31, 0x64, 0x31, 0x61, 0x38, 0x39, 0x63, 0x38, 0x30, 0x39, 0x61, 0x32, 0x61, 0x66, 0x37, 0x65, 0x62, 0x34, 0x30, 0x65, 0x39, 0x62, 0x63, 0x32, 0x63, 0x62, 0x61, 0x30, 0x37, 0x31, 0x36, 0x34, 0x34, 0x32, 0x33, 0x30, 0x65, 0x32, 0x31, 0x63, 0x30, 0x37, 0x35, 0x63, 0x31, 0x64, 0x61, 0x30, 0x38, 0x39, 0x31, 0x36, 0x61, 0x66, 0x66, 0x35, 0x65, 0x66, 0x65, 0x39, 0x66, 0x39, 0x35, 0x61, 0x36, 0x66, 0x36, 0x61, 0x34, 0x66, 0x39, 0x34, 0x64, 0x63, 0x32, 0x31, 0x37, 0x66, 0x36, 0x63, 0x31, 0x62, 0x62, 0x34, 0x61, 0x33, 0x32, 0x34, 0x30, 0x62, 0x32, 0x39, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x47, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x72, 0x61, 0x67, 0x75, 0x65, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x62, 0x79, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x76, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x36, 0x34, 0x20, 0x62, 0x69, 0x74, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x36, 0x34, 0x20, 0x62, 0x69, 0x74, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x39, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x5d, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x20, 0x2d, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x2d, 0x20, 0x27, 0x6e, 0x75, 0x6c, 0x6c, 0x27, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x34, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x6f, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x56, 0x32, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x30, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x32, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x38, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x32, 0x63, 0x34, 0x64, 0x38, 0x38, 0x62, 0x66, 0x64, 0x63, 0x32, 0x66, 0x36, 0x64, 0x62, 0x66, 0x38, 0x32, 0x63, 0x33, 0x33, 0x64, 0x32, 0x33, 0x35, 0x63, 0x34, 0x65, 0x37, 0x38, 0x35, 0x65, 0x39, 0x66, 0x63, 0x32, 0x33, 0x62, 0x32, 0x64, 0x30, 0x66, 0x63, 0x37, 0x62, 0x39, 0x64, 0x32, 0x30, 0x66, 0x63, 0x35, 0x65, 0x39, 0x36, 0x37, 0x34, 0x66, 0x31, 0x66, 0x39, 0x64, 0x31, 0x35, 0x61, 0x30, 0x31, 0x36, 0x64, 0x36, 0x64, 0x36, 0x39, 0x62, 0x39, 0x32, 0x35, 0x63, 0x66, 0x32, 0x36, 0x31, 0x32, 0x38, 0x36, 0x38, 0x33, 0x61, 0x62, 0x34, 0x61, 0x30, 0x39, 0x36, 0x65, 0x31, 0x39, 0x36, 0x66, 0x62, 0x62, 0x31, 0x31, 0x34, 0x32, 0x64, 0x36, 0x63, 0x36, 0x64, 0x34, 0x65, 0x38, 0x64, 0x33, 0x34, 0x38, 0x31, 0x62, 0x39, 0x62, 0x65, 0x66, 0x31, 0x62, 0x64, 0x30, 0x66, 0x36, 0x35, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x33, 0x39, 0x34, 0x30, 0x39, 0x62, 0x34, 0x65, 0x35, 0x36, 0x30, 0x33, 0x64, 0x64, 0x38, 0x63, 0x33, 0x63, 0x66, 0x33, 0x38, 0x32, 0x33, 0x32, 0x33, 0x34, 0x38, 0x36, 0x36, 0x31, 0x61, 0x38, 0x65, 0x39, 0x39, 0x61, 0x63, 0x35, 0x31, 0x38, 0x33, 0x39, 0x36, 0x65, 0x65, 0x61, 0x61, 0x31, 0x32, 0x38, 0x65, 0x63, 0x39, 0x65, 0x63, 0x32, 0x61, 0x33, 0x65, 0x62, 0x38, 0x31, 0x32, 0x37, 0x61, 0x30, 0x36, 0x62, 0x32, 0x31, 0x61, 0x62, 0x39, 0x35, 0x36, 0x66, 0x35, 0x66, 0x31, 0x33, 0x38, 0x63, 0x62, 0x34, 0x34, 0x66, 0x64, 0x61, 0x31, 0x61, 0x39, 0x30, 0x35, 0x35, 0x62, 0x64, 0x30, 0x38, 0x39, 0x38, 0x30, 0x65, 0x61, 0x34, 0x66, 0x38, 0x30, 0x34, 0x30, 0x64, 0x38, 0x37, 0x37, 0x63, 0x30, 0x30, 0x64, 0x61, 0x63, 0x30, 0x32, 0x35, 0x36, 0x30, 0x38, 0x64, 0x30, 0x64, 0x39, 0x35, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x36, 0x61, 0x39, 0x36, 0x30, 0x38, 0x36, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x66, 0x31, 0x37, 0x36, 0x36, 0x38, 0x66, 0x33, 0x35, 0x66, 0x37, 0x34, 0x31, 0x38, 0x65, 0x66, 0x38, 0x37, 0x39, 0x38, 0x30, 0x37, 0x39, 0x31, 0x36, 0x37, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x37, 0x32, 0x65, 0x63, 0x64, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x32, 0x36, 0x31, 0x33, 0x37, 0x63, 0x66, 0x34, 0x35, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x32, 0x34, 0x37, 0x38, 0x36, 0x61, 0x62, 0x33, 0x34, 0x38, 0x33, 0x63, 0x32, 0x66, 0x39, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x33, 0x66, 0x35, 0x31, 0x30, 0x32, 0x64, 0x61, 0x62, 0x65, 0x30, 0x61, 0x32, 0x37, 0x62, 0x31, 0x37, 0x34, 0x36, 0x30, 0x39, 0x38, 0x64, 0x31, 0x64, 0x63, 0x31, 0x37, 0x61, 0x35, 0x64, 0x33, 0x66, 0x62, 0x64, 0x34, 0x37, 0x38, 0x37, 0x35, 0x39, 0x66, 0x65, 0x61, 0x39, 0x32, 0x38, 0x37, 0x65, 0x34, 0x65, 0x34, 0x31, 0x39, 0x62, 0x33, 0x63, 0x33, 0x63, 0x65, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x31, 0x61, 0x63, 0x64, 0x62, 0x32, 0x63, 0x34, 0x64, 0x33, 0x64, 0x66, 0x33, 0x66, 0x31, 0x62, 0x38, 0x64, 0x33, 0x62, 0x66, 0x64, 0x33, 0x33, 0x34, 0x32, 0x31, 0x36, 0x36, 0x30, 0x64, 0x66, 0x33, 0x35, 0x38, 0x64, 0x38, 0x34, 0x64, 0x37, 0x38, 0x64, 0x31, 0x36, 0x63, 0x34, 0x36, 0x30, 0x33, 0x35, 0x35, 0x31, 0x39, 0x33, 0x35, 0x66, 0x34, 0x62, 0x36, 0x37, 0x36, 0x34, 0x33, 0x33, 0x37, 0x33, 0x65, 0x37, 0x65, 0x62, 0x36, 0x33, 0x64, 0x63, 0x62, 0x31, 0x36, 0x65, 0x63, 0x33, 0x35, 0x39, 0x62, 0x65, 0x30, 0x65, 0x63, 0x34, 0x31, 0x66, 0x65, 0x65, 0x33, 0x33, 0x62, 0x30, 0x33, 0x61, 0x31, 0x36, 0x65, 0x38, 0x30, 0x37, 0x34, 0x35, 0x66, 0x32, 0x33, 0x37, 0x34, 0x66, 0x66, 0x31, 0x64, 0x33, 0x63, 0x33, 0x35, 0x32, 0x35, 0x30, 0x38, 0x61, 0x63, 0x35, 0x64, 0x38, 0x35, 0x37, 0x63, 0x36, 0x34, 0x37, 0x36, 0x64, 0x33, 0x63, 0x33, 0x62, 0x63, 0x66, 0x37, 0x65, 0x36, 0x63, 0x61, 0x33, 0x37, 0x34, 0x32, 0x37, 0x63, 0x39, 0x32, 0x30, 0x39, 0x66, 0x31, 0x37, 0x62, 0x65, 0x33, 0x61, 0x66, 0x35, 0x32, 0x36, 0x34, 0x63, 0x30, 0x65, 0x32, 0x31, 0x33, 0x32, 0x62, 0x33, 0x64, 0x64, 0x31, 0x31, 0x35, 0x36, 0x63, 0x32, 0x38, 0x62, 0x34, 0x65, 0x39, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x36, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x36, 0x61, 0x39, 0x36, 0x30, 0x38, 0x36, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x66, 0x31, 0x37, 0x36, 0x36, 0x38, 0x66, 0x33, 0x35, 0x66, 0x37, 0x34, 0x31, 0x38, 0x65, 0x66, 0x38, 0x37, 0x39, 0x38, 0x30, 0x37, 0x39, 0x31, 0x36, 0x37, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x37, 0x32, 0x65, 0x63, 0x64, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x32, 0x36, 0x31, 0x33, 0x37, 0x63, 0x66, 0x34, 0x35, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x32, 0x34, 0x37, 0x38, 0x36, 0x61, 0x62, 0x33, 0x34, 0x38, 0x33, 0x63, 0x32, 0x66, 0x39, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x63, 0x38, 0x35, 0x61, 0x36, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x63, 0x32, 0x31, 0x35, 0x66, 0x36, 0x61, 0x31, 0x32, 0x38, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x31, 0x65, 0x65, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x36, 0x34, 0x32, 0x34, 0x34, 0x30, 0x34, 0x33, 0x61, 0x35, 0x66, 0x36, 0x33, 0x39, 0x61, 0x61, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x32, 0x30, 0x34, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x63, 0x38, 0x35, 0x31, 0x66, 0x32, 0x39, 0x63, 0x37, 0x63, 0x31, 0x38, 0x33, 0x62, 0x65, 0x32, 0x35, 0x33, 0x65, 0x61, 0x31, 0x35, 0x31, 0x30, 0x62, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x66, 0x38, 0x36, 0x35, 0x31, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x38, 0x30, 0x33, 0x31, 0x61, 0x30, 0x64, 0x39, 0x37, 0x31, 0x32, 0x61, 0x33, 0x63, 0x34, 0x30, 0x61, 0x65, 0x38, 0x35, 0x61, 0x65, 0x61, 0x34, 0x61, 0x64, 0x31, 0x62, 0x64, 0x39, 0x35, 0x61, 0x30, 0x62, 0x37, 0x63, 0x63, 0x37, 0x62, 0x64, 0x38, 0x30, 0x35, 0x31, 0x38, 0x39, 0x61, 0x39, 0x65, 0x32, 0x35, 0x31, 0x37, 0x34, 0x30, 0x33, 0x62, 0x31, 0x31, 0x61, 0x30, 0x30, 0x61, 0x31, 0x35, 0x33, 0x30, 0x66, 0x38, 0x31, 0x61, 0x30, 0x35, 0x33, 0x62, 0x35, 0x33, 0x62, 0x30, 0x32, 0x36, 0x37, 0x61, 0x36, 0x64, 0x63, 0x66, 0x65, 0x39, 0x66, 0x39, 0x61, 0x31, 0x36, 0x35, 0x32, 0x33, 0x30, 0x37, 0x62, 0x33, 0x39, 0x36, 0x62, 0x33, 0x65, 0x38, 0x61, 0x36, 0x35, 0x65, 0x36, 0x35, 0x37, 0x30, 0x37, 0x61, 0x34, 0x35, 0x30, 0x65, 0x36, 0x30, 0x63, 0x39, 0x32, 0x62, 0x61, 0x65, 0x66, 0x64, 0x62, 0x63, 0x66, 0x62, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x32, 0x66, 0x38, 0x36, 0x63, 0x30, 0x37, 0x31, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x32, 0x34, 0x66, 0x38, 0x39, 0x34, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x30, 0x63, 0x30, 0x38, 0x30, 0x61, 0x30, 0x37, 0x31, 0x64, 0x33, 0x36, 0x62, 0x63, 0x39, 0x33, 0x63, 0x37, 0x61, 0x65, 0x38, 0x63, 0x63, 0x35, 0x63, 0x30, 0x31, 0x35, 0x30, 0x31, 0x65, 0x35, 0x31, 0x65, 0x35, 0x65, 0x39, 0x37, 0x61, 0x35, 0x31, 0x61, 0x61, 0x35, 0x34, 0x31, 0x64, 0x31, 0x61, 0x38, 0x39, 0x63, 0x38, 0x30, 0x39, 0x61, 0x32, 0x61, 0x66, 0x37, 0x65, 0x62, 0x34, 0x30, 0x65, 0x39, 0x62, 0x63, 0x32, 0x63, 0x62, 0x61, 0x30, 0x37, 0x31, 0x36, 0x34, 0x34, 0x32, 0x33, 0x30, 0x65, 0x32, 0x31, 0x63, 0x30, 0x37, 0x35, 0x63, 0x31, 0x64, 0x61, 0x30, 0x38, 0x39, 0x31, 0x36, 0x61, 0x66, 0x66, 0x35, 0x65, 0x66, 0x65, 0x39, 0x66, 0x39, 0x35, 0x61, 0x36, 0x66, 0x36, 0x61, 0x34, 0x66, 0x39, 0x34, 0x64, 0x63, 0x32, 0x31, 0x37, 0x66, 0x36, 0x63, 0x31, 0x62, 0x62, 0x34, 0x61, 0x33, 0x32, 0x34, 0x30, 0x62, 0x32, 0x39, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x63, 0x38, 0x35, 0x61, 0x36, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x63, 0x32, 0x31, 0x35, 0x66, 0x36, 0x61, 0x31, 0x32, 0x38, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x31, 0x65, 0x65, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x36, 0x34, 0x32, 0x34, 0x34, 0x30, 0x34, 0x33, 0x61, 0x35, 0x66, 0x36, 0x33, 0x39, 0x61, 0x61, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x32, 0x30, 0x34, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x63, 0x38, 0x35, 0x31, 0x66, 0x32, 0x39, 0x63, 0x37, 0x63, 0x31, 0x38, 0x33, 0x62, 0x65, 0x32, 0x35, 0x33, 0x65, 0x61, 0x31, 0x35, 0x31, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x31, 0x64, 0x62, 0x37, 0x30, 0x63, 0x34, 0x38, 0x35, 0x62, 0x36, 0x32, 0x36, 0x34, 0x36, 0x39, 0x32, 0x66, 0x32, 0x36, 0x62, 0x38, 0x61, 0x65, 0x61, 0x61, 0x62, 0x35, 0x62, 0x30, 0x63, 0x33, 0x38, 0x34, 0x31, 0x38, 0x30, 0x64, 0x66, 0x38, 0x65, 0x32, 0x31, 0x38, 0x34, 0x61, 0x32, 0x31, 0x61, 0x38, 0x30, 0x38, 0x61, 0x33, 0x65, 0x63, 0x38, 0x65, 0x38, 0x36, 0x63, 0x61, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x35, 0x36, 0x31, 0x37, 0x33, 0x31, 0x37, 0x38, 0x35, 0x62, 0x34, 0x38, 0x63, 0x66, 0x31, 0x38, 0x38, 0x36, 0x34, 0x31, 0x32, 0x32, 0x33, 0x34, 0x35, 0x33, 0x31, 0x65, 0x34, 0x39, 0x34, 0x30, 0x30, 0x36, 0x34, 0x35, 0x38, 0x34, 0x34, 0x36, 0x33, 0x65, 0x39, 0x36, 0x61, 0x63, 0x36, 0x33, 0x61, 0x31, 0x61, 0x31, 0x35, 0x34, 0x33, 0x32, 0x30, 0x32, 0x32, 0x37, 0x65, 0x33, 0x33, 0x33, 0x66, 0x62, 0x35, 0x31, 0x61, 0x64, 0x64, 0x63, 0x34, 0x61, 0x38, 0x39, 0x62, 0x37, 0x65, 0x30, 0x64, 0x33, 0x66, 0x38, 0x36, 0x32, 0x64, 0x37, 0x63, 0x31, 0x66, 0x64, 0x34, 0x65, 0x61, 0x30, 0x33, 0x62, 0x64, 0x38, 0x65, 0x62, 0x33, 0x64, 0x38, 0x38, 0x30, 0x36, 0x66, 0x31, 0x65, 0x37, 0x64, 0x61, 0x66, 0x35, 0x39, 0x31, 0x63, 0x62, 0x62, 0x62, 0x62, 0x39, 0x32, 0x62, 0x30, 0x62, 0x65, 0x62, 0x37, 0x34, 0x64, 0x31, 0x33, 0x63, 0x30, 0x31, 0x36, 0x31, 0x37, 0x66, 0x32, 0x32, 0x63, 0x35, 0x30, 0x32, 0x36, 0x62, 0x34, 0x66, 0x39, 0x66, 0x39, 0x66, 0x32, 0x39, 0x34, 0x61, 0x38, 0x61, 0x37, 0x63, 0x33, 0x32, 0x64, 0x62, 0x38, 0x39, 0x35, 0x64, 0x65, 0x33, 0x62, 0x30, 0x31, 0x62, 0x65, 0x65, 0x30, 0x31, 0x33, 0x32, 0x63, 0x39, 0x32, 0x30, 0x39, 0x65, 0x31, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x36, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x64, 0x61, 0x65, 0x65, 0x64, 0x37, 0x33, 0x34, 0x64, 0x61, 0x31, 0x31, 0x34, 0x34, 0x37, 0x30, 0x64, 0x61, 0x35, 0x35, 0x39, 0x62, 0x64, 0x34, 0x62, 0x34, 0x63, 0x37, 0x32, 0x35, 0x39, 0x65, 0x31, 0x66, 0x37, 0x39, 0x35, 0x32, 0x35, 0x35, 0x35, 0x32, 0x34, 0x31, 0x64, 0x63, 0x62, 0x63, 0x39, 0x30, 0x63, 0x66, 0x31, 0x39, 0x34, 0x61, 0x32, 0x65, 0x66, 0x36, 0x37, 0x36, 0x66, 0x63, 0x36, 0x30, 0x30, 0x35, 0x66, 0x33, 0x36, 0x37, 0x32, 0x66, 0x61, 0x64, 0x61, 0x32, 0x61, 0x33, 0x36, 0x34, 0x35, 0x65, 0x64, 0x62, 0x32, 0x39, 0x37, 0x61, 0x37, 0x35, 0x35, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x64, 0x61, 0x65, 0x65, 0x64, 0x37, 0x33, 0x34, 0x64, 0x61, 0x31, 0x31, 0x34, 0x34, 0x37, 0x30, 0x64, 0x61, 0x35, 0x35, 0x39, 0x62, 0x64, 0x34, 0x62, 0x34, 0x63, 0x37, 0x32, 0x35, 0x39, 0x65, 0x31, 0x66, 0x37, 0x39, 0x35, 0x32, 0x35, 0x35, 0x35, 0x32, 0x34, 0x31, 0x64, 0x63, 0x62, 0x63, 0x39, 0x30, 0x63, 0x66, 0x31, 0x39, 0x34, 0x61, 0x32, 0x65, 0x66, 0x36, 0x37, 0x36, 0x66, 0x63, 0x36, 0x30, 0x30, 0x35, 0x66, 0x33, 0x36, 0x37, 0x32, 0x66, 0x61, 0x64, 0x61, 0x32, 0x61, 0x33, 0x36, 0x34, 0x35, 0x65, 0x64, 0x62, 0x32, 0x39, 0x37, 0x61, 0x37, 0x35, 0x35, 0x33, 0x22, 0x7d, 0x5d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x4f, 0x62, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x69, 0x73, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x66, 0x33, 0x32, 0x63, 0x63, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x4f, 0x62, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x65, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x32, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x66, 0x61, 0x35, 0x64, 0x64, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x32, 0x37, 0x32, 0x30, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x61, 0x64, 0x32, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x32, 0x35, 0x36, 0x66, 0x39, 0x39, 0x66, 0x62, 0x38, 0x39, 0x39, 0x63, 0x32, 0x64, 0x65, 0x30, 0x61, 0x65, 0x61, 0x63, 0x30, 0x63, 0x35, 0x61, 0x61, 0x36, 0x61, 0x61, 0x64, 0x36, 0x39, 0x64, 0x65, 0x31, 0x38, 0x38, 0x62, 0x36, 0x61, 0x30, 0x66, 0x34, 0x61, 0x63, 0x32, 0x39, 0x66, 0x32, 0x64, 0x30, 0x37, 0x35, 0x61, 0x35, 0x33, 0x61, 0x61, 0x33, 0x65, 0x64, 0x30, 0x65, 0x34, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x38, 0x30, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x30, 0x31, 0x61, 0x30, 0x38, 0x34, 0x30, 0x36, 0x35, 0x30, 0x61, 0x61, 0x38, 0x66, 0x37, 0x34, 0x64, 0x32, 0x62, 0x30, 0x37, 0x66, 0x34, 0x30, 0x30, 0x36, 0x37, 0x64, 0x63, 0x33, 0x33, 0x62, 0x37, 0x31, 0x35, 0x30, 0x37, 0x38, 0x64, 0x37, 0x33, 0x34, 0x32, 0x32, 0x66, 0x30, 0x31, 0x64, 0x61, 0x31, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x31, 0x31, 0x65, 0x30, 0x32, 0x62, 0x62, 0x64, 0x66, 0x64, 0x61, 0x39, 0x61, 0x30, 0x34, 0x62, 0x32, 0x32, 0x36, 0x30, 0x66, 0x36, 0x30, 0x32, 0x32, 0x62, 0x66, 0x35, 0x33, 0x65, 0x61, 0x64, 0x62, 0x33, 0x33, 0x37, 0x62, 0x33, 0x65, 0x35, 0x39, 0x35, 0x31, 0x34, 0x39, 0x33, 0x36, 0x66, 0x37, 0x33, 0x31, 0x37, 0x64, 0x38, 0x37, 0x32, 0x64, 0x65, 0x66, 0x62, 0x38, 0x39, 0x31, 0x61, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x37, 0x39, 0x62, 0x64, 0x63, 0x61, 0x39, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x35, 0x32, 0x31, 0x64, 0x35, 0x32, 0x38, 0x61, 0x64, 0x30, 0x63, 0x37, 0x36, 0x30, 0x33, 0x35, 0x34, 0x61, 0x34, 0x66, 0x30, 0x34, 0x39, 0x36, 0x37, 0x37, 0x36, 0x63, 0x66, 0x31, 0x34, 0x61, 0x39, 0x32, 0x66, 0x65, 0x31, 0x66, 0x62, 0x35, 0x64, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x63, 0x65, 0x61, 0x31, 0x61, 0x34, 0x38, 0x39, 0x63, 0x37, 0x63, 0x38, 0x33, 0x31, 0x30, 0x31, 0x61, 0x30, 0x61, 0x38, 0x36, 0x63, 0x31, 0x66, 0x64, 0x38, 0x63, 0x32, 0x65, 0x37, 0x34, 0x38, 0x32, 0x30, 0x36, 0x38, 0x36, 0x39, 0x33, 0x37, 0x66, 0x35, 0x63, 0x31, 0x62, 0x66, 0x65, 0x38, 0x33, 0x36, 0x65, 0x32, 0x66, 0x62, 0x36, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66, 0x63, 0x62, 0x65, 0x62, 0x64, 0x63, 0x34, 0x61, 0x62, 0x34, 0x33, 0x35, 0x37, 0x66, 0x32, 0x64, 0x62, 0x62, 0x63, 0x36, 0x31, 0x61, 0x30, 0x35, 0x63, 0x33, 0x62, 0x32, 0x62, 0x34, 0x34, 0x66, 0x66, 0x38, 0x32, 0x35, 0x32, 0x66, 0x37, 0x38, 0x64, 0x37, 0x30, 0x61, 0x65, 0x62, 0x33, 0x33, 0x66, 0x38, 0x62, 0x61, 0x30, 0x39, 0x62, 0x65, 0x61, 0x65, 0x61, 0x64, 0x61, 0x64, 0x31, 0x62, 0x33, 0x37, 0x36, 0x61, 0x35, 0x37, 0x64, 0x33, 0x34, 0x66, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x63, 0x34, 0x61, 0x31, 0x38, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x32, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x36, 0x32, 0x63, 0x33, 0x36, 0x30, 0x66, 0x64, 0x64, 0x38, 0x38, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x39, 0x64, 0x34, 0x36, 0x33, 0x65, 0x36, 0x64, 0x36, 0x34, 0x62, 0x32, 0x65, 0x65, 0x33, 0x32, 0x30, 0x61, 0x63, 0x36, 0x61, 0x30, 0x38, 0x38, 0x38, 0x35, 0x64, 0x66, 0x36, 0x30, 0x38, 0x33, 0x36, 0x34, 0x34, 0x61, 0x30, 0x36, 0x33, 0x65, 0x37, 0x30, 0x31, 0x61, 0x30, 0x33, 0x37, 0x61, 0x37, 0x32, 0x38, 0x61, 0x65, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x66, 0x66, 0x61, 0x37, 0x30, 0x32, 0x61, 0x32, 0x63, 0x61, 0x36, 0x32, 0x30, 0x64, 0x62, 0x38, 0x39, 0x63, 0x61, 0x66, 0x33, 0x65, 0x34, 0x36, 0x61, 0x62, 0x37, 0x66, 0x32, 0x35, 0x66, 0x37, 0x36, 0x34, 0x36, 0x66, 0x63, 0x39, 0x35, 0x31, 0x35, 0x31, 0x30, 0x39, 0x39, 0x31, 0x62, 0x61, 0x64, 0x63, 0x61, 0x30, 0x36, 0x35, 0x64, 0x38, 0x34, 0x36, 0x66, 0x30, 0x34, 0x36, 0x33, 0x35, 0x37, 0x61, 0x66, 0x33, 0x39, 0x62, 0x62, 0x37, 0x33, 0x39, 0x62, 0x31, 0x36, 0x31, 0x32, 0x33, 0x33, 0x66, 0x63, 0x65, 0x37, 0x33, 0x64, 0x64, 0x66, 0x65, 0x30, 0x62, 0x62, 0x38, 0x37, 0x66, 0x32, 0x64, 0x32, 0x38, 0x65, 0x66, 0x36, 0x30, 0x64, 0x66, 0x65, 0x36, 0x64, 0x62, 0x62, 0x30, 0x31, 0x32, 0x38, 0x64, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x30, 0x61, 0x37, 0x34, 0x31, 0x61, 0x34, 0x36, 0x32, 0x37, 0x38, 0x30, 0x31, 0x34, 0x64, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x33, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x4f, 0x62, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x75, 0x6e, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x33, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x65, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x20, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x66, 0x6c, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x35, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x33, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x66, 0x61, 0x35, 0x64, 0x64, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x32, 0x37, 0x32, 0x30, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x61, 0x64, 0x32, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x32, 0x35, 0x36, 0x66, 0x39, 0x39, 0x66, 0x62, 0x38, 0x39, 0x39, 0x63, 0x32, 0x64, 0x65, 0x30, 0x61, 0x65, 0x61, 0x63, 0x30, 0x63, 0x35, 0x61, 0x61, 0x36, 0x61, 0x61, 0x64, 0x36, 0x39, 0x64, 0x65, 0x31, 0x38, 0x38, 0x62, 0x36, 0x61, 0x30, 0x66, 0x34, 0x61, 0x63, 0x32, 0x39, 0x66, 0x32, 0x64, 0x30, 0x37, 0x35, 0x61, 0x35, 0x33, 0x61, 0x61, 0x33, 0x65, 0x64, 0x30, 0x65, 0x34, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x38, 0x30, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x30, 0x31, 0x61, 0x30, 0x38, 0x34, 0x30, 0x36, 0x35, 0x30, 0x61, 0x61, 0x38, 0x66, 0x37, 0x34, 0x64, 0x32, 0x62, 0x30, 0x37, 0x66, 0x34, 0x30, 0x30, 0x36, 0x37, 0x64, 0x63, 0x33, 0x33, 0x62, 0x37, 0x31, 0x35, 0x30, 0x37, 0x38, 0x64, 0x37, 0x33, 0x34, 0x32, 0x32, 0x66, 0x30, 0x31, 0x64, 0x61, 0x31, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x31, 0x31, 0x65, 0x30, 0x32, 0x62, 0x62, 0x64, 0x66, 0x64, 0x61, 0x39, 0x61, 0x30, 0x34, 0x62, 0x32, 0x32, 0x36, 0x30, 0x66, 0x36, 0x30, 0x32, 0x32, 0x62, 0x66, 0x35, 0x33, 0x65, 0x61, 0x64, 0x62, 0x33, 0x33, 0x37, 0x62, 0x33, 0x65, 0x35, 0x39, 0x35, 0x31, 0x34, 0x39, 0x33, 0x36, 0x66, 0x37, 0x33, 0x31, 0x37, 0x64, 0x38, 0x37, 0x32, 0x64, 0x65, 0x66, 0x62, 0x38, 0x39, 0x31, 0x61, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x37, 0x39, 0x62, 0x64, 0x63, 0x61, 0x39, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x35, 0x32, 0x31, 0x64, 0x35, 0x32, 0x38, 0x61, 0x64, 0x30, 0x63, 0x37, 0x36, 0x30, 0x33, 0x35, 0x34, 0x61, 0x34, 0x66, 0x30, 0x34, 0x39, 0x36, 0x37, 0x37, 0x36, 0x63, 0x66, 0x31, 0x34, 0x61, 0x39, 0x32, 0x66, 0x65, 0x31, 0x66, 0x62, 0x35, 0x64, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x63, 0x65, 0x61, 0x31, 0x61, 0x34, 0x38, 0x39, 0x63, 0x37, 0x63, 0x38, 0x33, 0x31, 0x30, 0x31, 0x61, 0x30, 0x61, 0x38, 0x36, 0x63, 0x31, 0x66, 0x64, 0x38, 0x63, 0x32, 0x65, 0x37, 0x34, 0x38, 0x32, 0x30, 0x36, 0x38, 0x36, 0x39, 0x33, 0x37, 0x66, 0x35, 0x63, 0x31, 0x62, 0x66, 0x65, 0x38, 0x33, 0x36, 0x65, 0x32, 0x66, 0x62, 0x36, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66, 0x63, 0x62, 0x65, 0x62, 0x64, 0x63, 0x34, 0x61, 0x62, 0x34, 0x33, 0x35, 0x37, 0x66, 0x32, 0x64, 0x62, 0x62, 0x63, 0x36, 0x31, 0x61, 0x30, 0x35, 0x63, 0x33, 0x62, 0x32, 0x62, 0x34, 0x34, 0x66, 0x66, 0x38, 0x32, 0x35, 0x32, 0x66, 0x37, 0x38, 0x64, 0x37, 0x30, 0x61, 0x65, 0x62, 0x33, 0x33, 0x66, 0x38, 0x62, 0x61, 0x30, 0x39, 0x62, 0x65, 0x61, 0x65, 0x61, 0x64, 0x61, 0x64, 0x31, 0x62, 0x33, 0x37, 0x36, 0x61, 0x35, 0x37, 0x64, 0x33, 0x34, 0x66, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x63, 0x34, 0x61, 0x31, 0x38, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x32, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x36, 0x32, 0x63, 0x33, 0x36, 0x30, 0x66, 0x64, 0x64, 0x38, 0x38, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x39, 0x64, 0x34, 0x36, 0x33, 0x65, 0x36, 0x64, 0x36, 0x34, 0x62, 0x32, 0x65, 0x65, 0x33, 0x32, 0x30, 0x61, 0x63, 0x36, 0x61, 0x30, 0x38, 0x38, 0x38, 0x35, 0x64, 0x66, 0x36, 0x30, 0x38, 0x33, 0x36, 0x34, 0x34, 0x61, 0x30, 0x36, 0x33, 0x65, 0x37, 0x30, 0x31, 0x61, 0x30, 0x33, 0x37, 0x61, 0x37, 0x32, 0x38, 0x61, 0x65, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x66, 0x66, 0x61, 0x37, 0x30, 0x32, 0x61, 0x32, 0x63, 0x61, 0x36, 0x32, 0x30, 0x64, 0x62, 0x38, 0x39, 0x63, 0x61, 0x66, 0x33, 0x65, 0x34, 0x36, 0x61, 0x62, 0x37, 0x66, 0x32, 0x35, 0x66, 0x37, 0x36, 0x34, 0x36, 0x66, 0x63, 0x39, 0x35, 0x31, 0x35, 0x31, 0x30, 0x39, 0x39, 0x31, 0x62, 0x61, 0x64, 0x63, 0x61, 0x30, 0x36, 0x35, 0x64, 0x38, 0x34, 0x36, 0x66, 0x30, 0x34, 0x36, 0x33, 0x35, 0x37, 0x61, 0x66, 0x33, 0x39, 0x62, 0x62, 0x37, 0x33, 0x39, 0x62, 0x31, 0x36, 0x31, 0x32, 0x33, 0x33, 0x66, 0x63, 0x65, 0x37, 0x33, 0x64, 0x64, 0x66, 0x65, 0x30, 0x62, 0x62, 0x38, 0x37, 0x66, 0x32, 0x64, 0x32, 0x38, 0x65, 0x66, 0x36, 0x30, 0x64, 0x66, 0x65, 0x36, 0x64, 0x62, 0x62, 0x30, 0x31, 0x32, 0x38, 0x64, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x30, 0x61, 0x37, 0x34, 0x31, 0x61, 0x34, 0x36, 0x32, 0x37, 0x38, 0x30, 0x31, 0x34, 0x64, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x38, 0x30, 0x63, 0x35, 0x66, 0x32, 0x65, 0x31, 0x65, 0x62, 0x32, 0x33, 0x39, 0x33, 0x39, 0x63, 0x66, 0x33, 0x36, 0x30, 0x30, 0x66, 0x36, 0x31, 0x38, 0x37, 0x32, 0x65, 0x33, 0x65, 0x39, 0x39, 0x36, 0x34, 0x64, 0x30, 0x61, 0x63, 0x61, 0x66, 0x62, 0x34, 0x34, 0x30, 0x36, 0x33, 0x34, 0x65, 0x35, 0x33, 0x30, 0x64, 0x36, 0x31, 0x33, 0x39, 0x61, 0x31, 0x39, 0x33, 0x62, 0x38, 0x38, 0x39, 0x63, 0x35, 0x36, 0x61, 0x30, 0x63, 0x30, 0x37, 0x64, 0x37, 0x33, 0x37, 0x37, 0x32, 0x39, 0x64, 0x62, 0x65, 0x30, 0x36, 0x32, 0x36, 0x37, 0x30, 0x36, 0x66, 0x63, 0x39, 0x66, 0x32, 0x35, 0x66, 0x22, 0x5d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x37, 0x32, 0x32, 0x36, 0x36, 0x32, 0x31, 0x35, 0x34, 0x65, 0x36, 0x64, 0x37, 0x36, 0x62, 0x32, 0x62, 0x32, 0x62, 0x39, 0x32, 0x65, 0x37, 0x30, 0x63, 0x30, 0x63, 0x61, 0x63, 0x33, 0x63, 0x63, 0x66, 0x35, 0x33, 0x34, 0x66, 0x39, 0x62, 0x37, 0x34, 0x65, 0x62, 0x35, 0x62, 0x38, 0x39, 0x38, 0x31, 0x39, 0x65, 0x63, 0x35, 0x30, 0x39, 0x30, 0x38, 0x33, 0x64, 0x30, 0x30, 0x61, 0x35, 0x30, 0x33, 0x61, 0x65, 0x35, 0x63, 0x31, 0x39, 0x38, 0x64, 0x31, 0x37, 0x36, 0x33, 0x34, 0x65, 0x37, 0x39, 0x30, 0x35, 0x39, 0x63, 0x32, 0x63, 0x64, 0x37, 0x33, 0x35, 0x34, 0x39, 0x31, 0x35, 0x35, 0x33, 0x64, 0x32, 0x32, 0x63, 0x34, 0x65, 0x30, 0x39, 0x64, 0x31, 0x64, 0x39, 0x66, 0x65, 0x61, 0x33, 0x65, 0x63, 0x66, 0x32, 0x31, 0x34, 0x35, 0x36, 0x35, 0x64, 0x66, 0x32, 0x32, 0x38, 0x34, 0x37, 0x32, 0x36, 0x37, 0x64, 0x64, 0x64, 0x37, 0x63, 0x34, 0x37, 0x30, 0x33, 0x30, 0x66, 0x38, 0x36, 0x36, 0x37, 0x62, 0x36, 0x31, 0x61, 0x39, 0x38, 0x36, 0x30, 0x62, 0x30, 0x38, 0x35, 0x63, 0x30, 0x36, 0x30, 0x63, 0x30, 0x37, 0x65, 0x62, 0x32, 0x31, 0x35, 0x61, 0x34, 0x64, 0x65, 0x39, 0x39, 0x31, 0x61, 0x38, 0x66, 0x65, 0x64, 0x30, 0x63, 0x61, 0x65, 0x33, 0x38, 0x32, 0x31, 0x66, 0x30, 0x65, 0x65, 0x38, 0x64, 0x65, 0x36, 0x34, 0x64, 0x32, 0x35, 0x64, 0x32, 0x64, 0x65, 0x34, 0x61, 0x37, 0x31, 0x30, 0x65, 0x61, 0x39, 0x66, 0x64, 0x38, 0x39, 0x66, 0x38, 0x66, 0x34, 0x36, 0x36, 0x36, 0x66, 0x63, 0x63, 0x37, 0x34, 0x35, 0x31, 0x65, 0x36, 0x64, 0x36, 0x39, 0x61, 0x30, 0x32, 0x30, 0x39, 0x38, 0x62, 0x62, 0x65, 0x35, 0x64, 0x35, 0x62, 0x38, 0x37, 0x63, 0x36, 0x30, 0x37, 0x32, 0x30, 0x66, 0x36, 0x64, 0x62, 0x37, 0x35, 0x62, 0x63, 0x62, 0x61, 0x64, 0x34, 0x39, 0x66, 0x63, 0x31, 0x31, 0x35, 0x31, 0x32, 0x39, 0x33, 0x30, 0x64, 0x39, 0x64, 0x39, 0x37, 0x62, 0x65, 0x66, 0x33, 0x66, 0x32, 0x62, 0x34, 0x62, 0x66, 0x36, 0x63, 0x38, 0x66, 0x63, 0x62, 0x63, 0x34, 0x31, 0x34, 0x62, 0x66, 0x36, 0x31, 0x63, 0x39, 0x38, 0x64, 0x36, 0x62, 0x66, 0x66, 0x32, 0x33, 0x62, 0x61, 0x36, 0x61, 0x62, 0x31, 0x64, 0x37, 0x36, 0x65, 0x30, 0x34, 0x34, 0x39, 0x30, 0x38, 0x31, 0x33, 0x35, 0x65, 0x36, 0x63, 0x38, 0x37, 0x32, 0x30, 0x64, 0x33, 0x64, 0x38, 0x63, 0x61, 0x31, 0x38, 0x62, 0x65, 0x31, 0x65, 0x30, 0x31, 0x33, 0x63, 0x32, 0x37, 0x35, 0x62, 0x61, 0x39, 0x66, 0x32, 0x61, 0x35, 0x64, 0x37, 0x65, 0x65, 0x66, 0x35, 0x63, 0x32, 0x62, 0x35, 0x66, 0x33, 0x38, 0x36, 0x38, 0x64, 0x66, 0x34, 0x37, 0x30, 0x62, 0x34, 0x65, 0x37, 0x38, 0x34, 0x38, 0x66, 0x37, 0x39, 0x64, 0x39, 0x38, 0x63, 0x66, 0x64, 0x37, 0x33, 0x38, 0x31, 0x63, 0x38, 0x65, 0x33, 0x38, 0x65, 0x39, 0x64, 0x64, 0x62, 0x64, 0x66, 0x32, 0x31, 0x33, 0x61, 0x66, 0x38, 0x64, 0x33, 0x65, 0x61, 0x63, 0x62, 0x64, 0x64, 0x31, 0x62, 0x37, 0x64, 0x30, 0x66, 0x65, 0x61, 0x35, 0x37, 0x32, 0x34, 0x66, 0x61, 0x35, 0x61, 0x65, 0x65, 0x35, 0x66, 0x35, 0x62, 0x38, 0x31, 0x39, 0x66, 0x33, 0x35, 0x66, 0x38, 0x66, 0x64, 0x61, 0x66, 0x66, 0x62, 0x64, 0x64, 0x63, 0x32, 0x61, 0x32, 0x62, 0x62, 0x32, 0x66, 0x64, 0x32, 0x31, 0x66, 0x30, 0x37, 0x66, 0x32, 0x34, 0x66, 0x62, 0x65, 0x31, 0x31, 0x66, 0x39, 0x38, 0x65, 0x62, 0x63, 0x64, 0x62, 0x66, 0x36, 0x65, 0x33, 0x32, 0x37, 0x32, 0x35, 0x37, 0x33, 0x38, 0x39, 0x66, 0x62, 0x30, 0x62, 0x63, 0x62, 0x34, 0x33, 0x31, 0x30, 0x38, 0x30, 0x39, 0x32, 0x39, 0x34, 0x35, 0x33, 0x31, 0x32, 0x64, 0x37, 0x36, 0x37, 0x64, 0x34, 0x34, 0x38, 0x35, 0x33, 0x35, 0x38, 0x66, 0x64, 0x35, 0x34, 0x33, 0x32, 0x31, 0x35, 0x38, 0x30, 0x37, 0x64, 0x62, 0x35, 0x65, 0x35, 0x65, 0x33, 0x63, 0x62, 0x33, 0x37, 0x34, 0x31, 0x63, 0x37, 0x32, 0x32, 0x66, 0x32, 0x35, 0x38, 0x31, 0x64, 0x31, 0x35, 0x65, 0x63, 0x38, 0x64, 0x36, 0x65, 0x65, 0x61, 0x37, 0x63, 0x30, 0x65, 0x37, 0x64, 0x62, 0x32, 0x61, 0x62, 0x36, 0x66, 0x39, 0x62, 0x35, 0x61, 0x37, 0x37, 0x34, 0x62, 0x65, 0x38, 0x33, 0x34, 0x31, 0x64, 0x33, 0x32, 0x61, 0x33, 0x37, 0x33, 0x39, 0x64, 0x31, 0x30, 0x33, 0x39, 0x32, 0x39, 0x63, 0x65, 0x30, 0x35, 0x34, 0x37, 0x32, 0x30, 0x38, 0x62, 0x33, 0x32, 0x34, 0x62, 0x37, 0x62, 0x32, 0x39, 0x61, 0x38, 0x35, 0x35, 0x35, 0x32, 0x64, 0x32, 0x66, 0x63, 0x39, 0x30, 0x62, 0x34, 0x30, 0x66, 0x39, 0x65, 0x35, 0x31, 0x30, 0x36, 0x38, 0x30, 0x61, 0x63, 0x65, 0x31, 0x34, 0x34, 0x37, 0x37, 0x32, 0x30, 0x63, 0x39, 0x38, 0x30, 0x30, 0x32, 0x66, 0x37, 0x65, 0x66, 0x37, 0x62, 0x37, 0x66, 0x65, 0x30, 0x39, 0x33, 0x30, 0x38, 0x66, 0x66, 0x33, 0x61, 0x38, 0x66, 0x37, 0x35, 0x30, 0x33, 0x36, 0x63, 0x34, 0x38, 0x61, 0x66, 0x62, 0x62, 0x30, 0x39, 0x64, 0x61, 0x66, 0x34, 0x32, 0x66, 0x31, 0x66, 0x33, 0x36, 0x66, 0x34, 0x37, 0x37, 0x65, 0x36, 0x34, 0x36, 0x30, 0x36, 0x63, 0x33, 0x33, 0x32, 0x32, 0x66, 0x39, 0x38, 0x37, 0x66, 0x62, 0x30, 0x35, 0x36, 0x30, 0x33, 0x62, 0x63, 0x36, 0x32, 0x64, 0x32, 0x31, 0x37, 0x31, 0x64, 0x65, 0x30, 0x66, 0x63, 0x66, 0x65, 0x33, 0x30, 0x39, 0x30, 0x63, 0x33, 0x32, 0x32, 0x33, 0x34, 0x61, 0x37, 0x31, 0x32, 0x64, 0x37, 0x66, 0x32, 0x34, 0x38, 0x33, 0x38, 0x30, 0x36, 0x66, 0x31, 0x39, 0x32, 0x37, 0x37, 0x31, 0x63, 0x64, 0x30, 0x65, 0x32, 0x61, 0x62, 0x31, 0x34, 0x37, 0x32, 0x65, 0x66, 0x64, 0x66, 0x34, 0x32, 0x38, 0x66, 0x35, 0x66, 0x61, 0x37, 0x32, 0x63, 0x32, 0x63, 0x35, 0x61, 0x35, 0x63, 0x61, 0x37, 0x33, 0x65, 0x33, 0x66, 0x30, 0x39, 0x35, 0x61, 0x64, 0x37, 0x36, 0x33, 0x30, 0x35, 0x34, 0x65, 0x64, 0x32, 0x61, 0x34, 0x61, 0x38, 0x66, 0x61, 0x36, 0x61, 0x30, 0x35, 0x62, 0x66, 0x33, 0x62, 0x30, 0x32, 0x39, 0x36, 0x34, 0x36, 0x63, 0x35, 0x66, 0x38, 0x62, 0x36, 0x31, 0x30, 0x33, 0x33, 0x65, 0x64, 0x38, 0x35, 0x31, 0x37, 0x32, 0x37, 0x65, 0x37, 0x61, 0x61, 0x34, 0x64, 0x31, 0x32, 0x30, 0x66, 0x39, 0x38, 0x31, 0x37, 0x61, 0x62, 0x32, 0x34, 0x32, 0x30, 0x61, 0x37, 0x63, 0x62, 0x64, 0x65, 0x66, 0x62, 0x36, 0x37, 0x64, 0x36, 0x64, 0x31, 0x36, 0x36, 0x36, 0x63, 0x63, 0x30, 0x30, 0x61, 0x31, 0x61, 0x33, 0x37, 0x62, 0x35, 0x36, 0x34, 0x63, 0x65, 0x61, 0x63, 0x64, 0x31, 0x34, 0x63, 0x33, 0x37, 0x63, 0x37, 0x32, 0x65, 0x30, 0x61, 0x65, 0x30, 0x36, 0x66, 0x61, 0x31, 0x61, 0x30, 0x39, 0x62, 0x66, 0x36, 0x33, 0x30, 0x37, 0x65, 0x32, 0x32, 0x36, 0x64, 0x32, 0x39, 0x39, 0x34, 0x32, 0x64, 0x62, 0x31, 0x65, 0x66, 0x33, 0x31, 0x63, 0x36, 0x35, 0x64, 0x65, 0x36, 0x61, 0x34, 0x39, 0x39, 0x32, 0x32, 0x66, 0x38, 0x66, 0x34, 0x38, 0x36, 0x30, 0x65, 0x63, 0x32, 0x64, 0x38, 0x61, 0x37, 0x31, 0x37, 0x32, 0x36, 0x66, 0x37, 0x34, 0x63, 0x63, 0x32, 0x39, 0x34, 0x39, 0x36, 0x61, 0x38, 0x35, 0x61, 0x37, 0x37, 0x35, 0x62, 0x62, 0x32, 0x39, 0x31, 0x30, 0x33, 0x66, 0x37, 0x35, 0x32, 0x34, 0x37, 0x62, 0x32, 0x62, 0x33, 0x34, 0x37, 0x31, 0x38, 0x61, 0x38, 0x39, 0x30, 0x31, 0x30, 0x64, 0x64, 0x39, 0x33, 0x37, 0x31, 0x35, 0x35, 0x37, 0x63, 0x31, 0x65, 0x64, 0x34, 0x36, 0x36, 0x37, 0x37, 0x32, 0x30, 0x38, 0x37, 0x62, 0x66, 0x65, 0x33, 0x31, 0x34, 0x38, 0x64, 0x31, 0x37, 0x66, 0x38, 0x32, 0x37, 0x39, 0x64, 0x65, 0x31, 0x66, 0x65, 0x38, 0x33, 0x38, 0x37, 0x31, 0x30, 0x34, 0x64, 0x30, 0x65, 0x32, 0x35, 0x62, 0x62, 0x33, 0x36, 0x65, 0x30, 0x31, 0x38, 0x37, 0x62, 0x32, 0x65, 0x31, 0x64, 0x34, 0x64, 0x66, 0x39, 0x64, 0x66, 0x33, 0x65, 0x66, 0x63, 0x35, 0x32, 0x64, 0x37, 0x32, 0x66, 0x38, 0x39, 0x36, 0x65, 0x35, 0x61, 0x61, 0x65, 0x34, 0x65, 0x35, 0x33, 0x37, 0x31, 0x62, 0x64, 0x65, 0x34, 0x35, 0x37, 0x31, 0x34, 0x32, 0x31, 0x62, 0x64, 0x64, 0x31, 0x65, 0x34, 0x37, 0x62, 0x31, 0x65, 0x63, 0x65, 0x32, 0x61, 0x38, 0x66, 0x61, 0x64, 0x62, 0x66, 0x32, 0x37, 0x66, 0x32, 0x37, 0x62, 0x38, 0x37, 0x64, 0x31, 0x36, 0x38, 0x39, 0x66, 0x34, 0x34, 0x35, 0x33, 0x64, 0x38, 0x37, 0x64, 0x34, 0x62, 0x64, 0x63, 0x31, 0x66, 0x34, 0x31, 0x31, 0x62, 0x66, 0x61, 0x31, 0x33, 0x37, 0x38, 0x39, 0x34, 0x37, 0x38, 0x66, 0x34, 0x62, 0x32, 0x66, 0x36, 0x32, 0x30, 0x33, 0x61, 0x66, 0x31, 0x39, 0x63, 0x37, 0x63, 0x32, 0x34, 0x30, 0x36, 0x33, 0x65, 0x33, 0x64, 0x32, 0x36, 0x36, 0x33, 0x64, 0x63, 0x37, 0x61, 0x33, 0x63, 0x39, 0x37, 0x64, 0x31, 0x32, 0x35, 0x35, 0x38, 0x36, 0x32, 0x65, 0x63, 0x35, 0x31, 0x32, 0x31, 0x65, 0x34, 0x63, 0x63, 0x37, 0x33, 0x33, 0x65, 0x37, 0x65, 0x36, 0x39, 0x32, 0x39, 0x38, 0x34, 0x37, 0x66, 0x33, 0x32, 0x33, 0x35, 0x33, 0x61, 0x34, 0x62, 0x63, 0x66, 0x36, 0x38, 0x39, 0x37, 0x66, 0x31, 0x66, 0x66, 0x35, 0x32, 0x64, 0x63, 0x63, 0x36, 0x36, 0x64, 0x38, 0x63, 0x39, 0x39, 0x32, 0x33, 0x66, 0x30, 0x64, 0x35, 0x32, 0x35, 0x61, 0x32, 0x32, 0x36, 0x39, 0x39, 0x65, 0x62, 0x62, 0x65, 0x62, 0x63, 0x63, 0x38, 0x30, 0x66, 0x62, 0x31, 0x66, 0x31, 0x35, 0x38, 0x62, 0x65, 0x62, 0x38, 0x63, 0x36, 0x31, 0x35, 0x31, 0x31, 0x36, 0x39, 0x38, 0x65, 0x65, 0x39, 0x66, 0x65, 0x39, 0x62, 0x34, 0x30, 0x61, 0x32, 0x64, 0x64, 0x65, 0x61, 0x37, 0x34, 0x36, 0x63, 0x37, 0x61, 0x39, 0x32, 0x31, 0x65, 0x38, 0x35, 0x33, 0x32, 0x32, 0x38, 0x31, 0x62, 0x34, 0x36, 0x62, 0x66, 0x34, 0x65, 0x66, 0x37, 0x31, 0x38, 0x33, 0x35, 0x39, 0x37, 0x65, 0x32, 0x30, 0x38, 0x61, 0x66, 0x66, 0x31, 0x37, 0x38, 0x34, 0x64, 0x37, 0x39, 0x34, 0x33, 0x36, 0x63, 0x63, 0x36, 0x39, 0x65, 0x66, 0x35, 0x62, 0x64, 0x64, 0x63, 0x30, 0x64, 0x62, 0x32, 0x39, 0x66, 0x65, 0x32, 0x64, 0x61, 0x38, 0x34, 0x62, 0x63, 0x65, 0x37, 0x32, 0x63, 0x37, 0x38, 0x62, 0x32, 0x33, 0x64, 0x63, 0x39, 0x34, 0x63, 0x31, 0x65, 0x37, 0x36, 0x35, 0x39, 0x38, 0x64, 0x63, 0x64, 0x36, 0x63, 0x65, 0x38, 0x63, 0x32, 0x34, 0x63, 0x30, 0x62, 0x64, 0x37, 0x32, 0x63, 0x62, 0x35, 0x38, 0x31, 0x36, 0x30, 0x35, 0x63, 0x34, 0x64, 0x38, 0x61, 0x34, 0x65, 0x37, 0x31, 0x31, 0x65, 0x66, 0x62, 0x39, 0x35, 0x37, 0x39, 0x35, 0x32, 0x66, 0x37, 0x32, 0x36, 0x36, 0x66, 0x39, 0x66, 0x61, 0x61, 0x61, 0x64, 0x31, 0x65, 0x30, 0x32, 0x35, 0x38, 0x34, 0x36, 0x32, 0x65, 0x62, 0x36, 0x38, 0x64, 0x65, 0x36, 0x38, 0x31, 0x30, 0x33, 0x32, 0x64, 0x33, 0x64, 0x63, 0x63, 0x33, 0x30, 0x34, 0x37, 0x62, 0x62, 0x66, 0x31, 0x63, 0x37, 0x66, 0x31, 0x66, 0x33, 0x33, 0x33, 0x37, 0x62, 0x62, 0x36, 0x37, 0x64, 0x39, 0x35, 0x36, 0x33, 0x61, 0x37, 0x32, 0x31, 0x32, 0x61, 0x34, 0x32, 0x61, 0x39, 0x30, 0x64, 0x63, 0x39, 0x33, 0x36, 0x34, 0x37, 0x62, 0x36, 0x33, 0x36, 0x35, 0x34, 0x30, 0x63, 0x37, 0x37, 0x34, 0x61, 0x36, 0x38, 0x30, 0x65, 0x38, 0x61, 0x65, 0x38, 0x39, 0x35, 0x38, 0x66, 0x33, 0x38, 0x36, 0x64, 0x34, 0x36, 0x33, 0x39, 0x66, 0x61, 0x39, 0x64, 0x36, 0x31, 0x65, 0x30, 0x32, 0x66, 0x61, 0x35, 0x32, 0x39, 0x33, 0x35, 0x34, 0x30, 0x66, 0x36, 0x66, 0x37, 0x33, 0x33, 0x64, 0x65, 0x34, 0x39, 0x36, 0x61, 0x30, 0x35, 0x34, 0x38, 0x65, 0x61, 0x65, 0x63, 0x33, 0x64, 0x35, 0x31, 0x30, 0x65, 0x65, 0x36, 0x65, 0x31, 0x61, 0x65, 0x32, 0x38, 0x32, 0x32, 0x64, 0x33, 0x34, 0x38, 0x37, 0x39, 0x33, 0x36, 0x39, 0x33, 0x65, 0x31, 0x64, 0x63, 0x33, 0x38, 0x64, 0x64, 0x33, 0x65, 0x36, 0x39, 0x33, 0x39, 0x34, 0x37, 0x32, 0x30, 0x61, 0x64, 0x62, 0x61, 0x35, 0x35, 0x62, 0x36, 0x37, 0x39, 0x32, 0x66, 0x61, 0x64, 0x34, 0x37, 0x38, 0x31, 0x37, 0x61, 0x39, 0x62, 0x61, 0x30, 0x38, 0x38, 0x31, 0x35, 0x37, 0x32, 0x62, 0x34, 0x65, 0x63, 0x62, 0x31, 0x61, 0x39, 0x31, 0x63, 0x63, 0x37, 0x66, 0x65, 0x64, 0x33, 0x65, 0x32, 0x64, 0x66, 0x63, 0x35, 0x31, 0x35, 0x36, 0x39, 0x34, 0x31, 0x39, 0x37, 0x37, 0x37, 0x32, 0x37, 0x30, 0x34, 0x33, 0x37, 0x39, 0x38, 0x38, 0x62, 0x62, 0x37, 0x34, 0x65, 0x35, 0x65, 0x65, 0x62, 0x38, 0x38, 0x38, 0x64, 0x35, 0x38, 0x35, 0x30, 0x66, 0x39, 0x64, 0x65, 0x34, 0x33, 0x32, 0x65, 0x62, 0x63, 0x36, 0x61, 0x32, 0x30, 0x31, 0x35, 0x34, 0x36, 0x33, 0x32, 0x35, 0x64, 0x66, 0x36, 0x38, 0x66, 0x31, 0x30, 0x30, 0x34, 0x39, 0x64, 0x35, 0x34, 0x63, 0x39, 0x36, 0x37, 0x32, 0x62, 0x33, 0x66, 0x35, 0x32, 0x37, 0x31, 0x65, 0x62, 0x35, 0x63, 0x62, 0x33, 0x37, 0x61, 0x39, 0x39, 0x35, 0x64, 0x39, 0x66, 0x66, 0x30, 0x34, 0x31, 0x36, 0x32, 0x61, 0x35, 0x33, 0x32, 0x30, 0x61, 0x34, 0x38, 0x30, 0x63, 0x34, 0x35, 0x37, 0x34, 0x30, 0x39, 0x62, 0x32, 0x38, 0x61, 0x36, 0x36, 0x33, 0x65, 0x64, 0x37, 0x31, 0x62, 0x32, 0x62, 0x34, 0x30, 0x61, 0x64, 0x32, 0x32, 0x62, 0x35, 0x34, 0x31, 0x62, 0x35, 0x66, 0x66, 0x64, 0x64, 0x63, 0x36, 0x32, 0x64, 0x30, 0x38, 0x62, 0x38, 0x64, 0x34, 0x63, 0x38, 0x64, 0x61, 0x36, 0x32, 0x64, 0x32, 0x31, 0x66, 0x61, 0x34, 0x32, 0x39, 0x61, 0x36, 0x64, 0x36, 0x35, 0x38, 0x62, 0x33, 0x35, 0x34, 0x33, 0x32, 0x61, 0x37, 0x33, 0x36, 0x35, 0x31, 0x61, 0x64, 0x39, 0x66, 0x39, 0x63, 0x32, 0x31, 0x32, 0x31, 0x65, 0x37, 0x32, 0x65, 0x31, 0x37, 0x32, 0x64, 0x63, 0x62, 0x35, 0x31, 0x61, 0x65, 0x36, 0x65, 0x65, 0x34, 0x66, 0x32, 0x62, 0x62, 0x62, 0x35, 0x30, 0x63, 0x35, 0x31, 0x61, 0x39, 0x37, 0x63, 0x65, 0x37, 0x63, 0x37, 0x34, 0x32, 0x66, 0x61, 0x64, 0x37, 0x38, 0x36, 0x65, 0x34, 0x36, 0x35, 0x64, 0x65, 0x34, 0x32, 0x63, 0x66, 0x35, 0x36, 0x39, 0x66, 0x35, 0x34, 0x33, 0x63, 0x34, 0x63, 0x63, 0x32, 0x61, 0x33, 0x37, 0x39, 0x34, 0x32, 0x62, 0x66, 0x33, 0x34, 0x35, 0x35, 0x61, 0x33, 0x31, 0x66, 0x63, 0x65, 0x63, 0x61, 0x61, 0x36, 0x63, 0x31, 0x65, 0x32, 0x37, 0x31, 0x38, 0x64, 0x30, 0x30, 0x34, 0x37, 0x38, 0x38, 0x37, 0x31, 0x64, 0x63, 0x39, 0x64, 0x30, 0x64, 0x64, 0x62, 0x36, 0x65, 0x39, 0x38, 0x34, 0x37, 0x30, 0x31, 0x31, 0x39, 0x36, 0x66, 0x34, 0x39, 0x61, 0x63, 0x39, 0x37, 0x32, 0x61, 0x33, 0x66, 0x64, 0x64, 0x35, 0x30, 0x65, 0x36, 0x33, 0x31, 0x65, 0x38, 0x32, 0x38, 0x63, 0x38, 0x32, 0x33, 0x61, 0x33, 0x35, 0x34, 0x36, 0x31, 0x39, 0x38, 0x65, 0x66, 0x65, 0x35, 0x66, 0x38, 0x63, 0x61, 0x33, 0x31, 0x32, 0x65, 0x33, 0x31, 0x66, 0x62, 0x32, 0x61, 0x36, 0x62, 0x61, 0x66, 0x31, 0x34, 0x38, 0x63, 0x61, 0x62, 0x64, 0x35, 0x39, 0x35, 0x61, 0x62, 0x38, 0x37, 0x32, 0x30, 0x36, 0x35, 0x37, 0x66, 0x38, 0x64, 0x64, 0x39, 0x39, 0x62, 0x37, 0x39, 0x32, 0x39, 0x37, 0x36, 0x65, 0x36, 0x65, 0x30, 0x38, 0x37, 0x62, 0x37, 0x31, 0x31, 0x39, 0x37, 0x37, 0x65, 0x66, 0x31, 0x37, 0x65, 0x66, 0x64, 0x34, 0x65, 0x30, 0x64, 0x32, 0x38, 0x64, 0x39, 0x63, 0x65, 0x65, 0x34, 0x38, 0x65, 0x63, 0x31, 0x31, 0x33, 0x63, 0x35, 0x30, 0x39, 0x32, 0x35, 0x36, 0x37, 0x32, 0x34, 0x38, 0x62, 0x32, 0x35, 0x62, 0x63, 0x66, 0x64, 0x35, 0x62, 0x62, 0x61, 0x64, 0x61, 0x38, 0x31, 0x33, 0x36, 0x34, 0x32, 0x33, 0x32, 0x33, 0x61, 0x37, 0x66, 0x64, 0x37, 0x61, 0x37, 0x36, 0x33, 0x35, 0x36, 0x63, 0x64, 0x65, 0x38, 0x64, 0x61, 0x62, 0x62, 0x62, 0x65, 0x61, 0x34, 0x34, 0x63, 0x64, 0x65, 0x36, 0x63, 0x65, 0x31, 0x66, 0x63, 0x63, 0x31, 0x65, 0x36, 0x36, 0x37, 0x32, 0x38, 0x30, 0x65, 0x35, 0x39, 0x33, 0x32, 0x66, 0x30, 0x63, 0x64, 0x30, 0x38, 0x62, 0x33, 0x64, 0x32, 0x33, 0x39, 0x39, 0x61, 0x35, 0x37, 0x34, 0x36, 0x32, 0x39, 0x65, 0x31, 0x65, 0x62, 0x61, 0x39, 0x38, 0x62, 0x30, 0x61, 0x30, 0x64, 0x62, 0x34, 0x36, 0x37, 0x61, 0x36, 0x36, 0x34, 0x39, 0x39, 0x34, 0x35, 0x66, 0x38, 0x65, 0x32, 0x37, 0x31, 0x63, 0x66, 0x65, 0x66, 0x31, 0x32, 0x32, 0x33, 0x30, 0x30, 0x36, 0x62, 0x61, 0x66, 0x66, 0x38, 0x35, 0x31, 0x31, 0x62, 0x35, 0x35, 0x34, 0x62, 0x39, 0x63, 0x31, 0x31, 0x38, 0x31, 0x64, 0x37, 0x34, 0x63, 0x34, 0x39, 0x39, 0x65, 0x33, 0x35, 0x31, 0x36, 0x63, 0x30, 0x33, 0x31, 0x30, 0x33, 0x63, 0x62, 0x36, 0x63, 0x63, 0x62, 0x31, 0x65, 0x35, 0x34, 0x39, 0x65, 0x39, 0x65, 0x35, 0x37, 0x62, 0x65, 0x38, 0x30, 0x66, 0x37, 0x32, 0x65, 0x33, 0x39, 0x32, 0x35, 0x30, 0x38, 0x62, 0x63, 0x36, 0x32, 0x34, 0x64, 0x39, 0x61, 0x66, 0x34, 0x37, 0x64, 0x32, 0x64, 0x61, 0x32, 0x62, 0x61, 0x38, 0x39, 0x38, 0x66, 0x63, 0x33, 0x32, 0x36, 0x30, 0x38, 0x61, 0x34, 0x64, 0x66, 0x31, 0x61, 0x35, 0x61, 0x63, 0x34, 0x39, 0x35, 0x34, 0x64, 0x38, 0x31, 0x39, 0x65, 0x31, 0x37, 0x62, 0x61, 0x39, 0x33, 0x38, 0x61, 0x35, 0x37, 0x32, 0x33, 0x37, 0x63, 0x36, 0x39, 0x39, 0x61, 0x62, 0x62, 0x64, 0x65, 0x38, 0x30, 0x65, 0x34, 0x61, 0x37, 0x33, 0x61, 0x61, 0x34, 0x32, 0x61, 0x34, 0x63, 0x61, 0x38, 0x35, 0x35, 0x63, 0x38, 0x31, 0x30, 0x38, 0x64, 0x34, 0x36, 0x35, 0x38, 0x62, 0x30, 0x32, 0x39, 0x33, 0x66, 0x30, 0x39, 0x61, 0x39, 0x34, 0x66, 0x65, 0x31, 0x39, 0x32, 0x61, 0x35, 0x63, 0x30, 0x34, 0x30, 0x34, 0x37, 0x32, 0x62, 0x35, 0x36, 0x64, 0x66, 0x65, 0x65, 0x62, 0x31, 0x38, 0x63, 0x33, 0x35, 0x36, 0x33, 0x63, 0x38, 0x36, 0x66, 0x33, 0x32, 0x35, 0x62, 0x38, 0x33, 0x30, 0x35, 0x65, 0x39, 0x61, 0x62, 0x38, 0x34, 0x62, 0x32, 0x37, 0x36, 0x38, 0x31, 0x31, 0x61, 0x66, 0x36, 0x65, 0x30, 0x37, 0x62, 0x63, 0x31, 0x35, 0x61, 0x61, 0x33, 0x65, 0x64, 0x33, 0x65, 0x34, 0x37, 0x38, 0x31, 0x39, 0x33, 0x31, 0x34, 0x35, 0x32, 0x32, 0x35, 0x38, 0x64, 0x33, 0x38, 0x37, 0x65, 0x32, 0x38, 0x34, 0x61, 0x34, 0x64, 0x64, 0x32, 0x33, 0x62, 0x37, 0x38, 0x38, 0x34, 0x62, 0x38, 0x65, 0x39, 0x66, 0x30, 0x61, 0x33, 0x61, 0x65, 0x34, 0x31, 0x37, 0x37, 0x39, 0x61, 0x32, 0x30, 0x62, 0x31, 0x38, 0x36, 0x30, 0x37, 0x64, 0x36, 0x39, 0x32, 0x32, 0x38, 0x33, 0x61, 0x34, 0x31, 0x33, 0x62, 0x63, 0x34, 0x33, 0x33, 0x38, 0x61, 0x64, 0x39, 0x33, 0x31, 0x32, 0x34, 0x39, 0x39, 0x66, 0x63, 0x66, 0x38, 0x62, 0x31, 0x37, 0x61, 0x36, 0x66, 0x32, 0x38, 0x65, 0x61, 0x62, 0x38, 0x64, 0x64, 0x63, 0x33, 0x31, 0x35, 0x31, 0x61, 0x65, 0x38, 0x39, 0x38, 0x30, 0x35, 0x34, 0x30, 0x30, 0x61, 0x31, 0x30, 0x39, 0x36, 0x31, 0x36, 0x34, 0x30, 0x36, 0x33, 0x36, 0x35, 0x33, 0x32, 0x36, 0x37, 0x66, 0x37, 0x32, 0x34, 0x63, 0x38, 0x62, 0x37, 0x31, 0x32, 0x34, 0x35, 0x32, 0x63, 0x62, 0x65, 0x39, 0x39, 0x39, 0x33, 0x38, 0x36, 0x63, 0x34, 0x35, 0x65, 0x35, 0x34, 0x64, 0x39, 0x34, 0x39, 0x31, 0x36, 0x65, 0x30, 0x61, 0x38, 0x30, 0x31, 0x37, 0x65, 0x30, 0x64, 0x61, 0x64, 0x62, 0x32, 0x31, 0x61, 0x64, 0x32, 0x37, 0x63, 0x38, 0x30, 0x35, 0x39, 0x32, 0x31, 0x34, 0x64, 0x39, 0x37, 0x64, 0x33, 0x32, 0x63, 0x37, 0x36, 0x66, 0x63, 0x34, 0x37, 0x64, 0x62, 0x62, 0x64, 0x66, 0x35, 0x32, 0x38, 0x37, 0x34, 0x35, 0x61, 0x65, 0x39, 0x65, 0x35, 0x35, 0x63, 0x63, 0x35, 0x64, 0x61, 0x35, 0x66, 0x66, 0x30, 0x66, 0x39, 0x61, 0x65, 0x62, 0x34, 0x36, 0x64, 0x31, 0x62, 0x37, 0x39, 0x36, 0x35, 0x34, 0x36, 0x30, 0x30, 0x66, 0x61, 0x33, 0x63, 0x37, 0x64, 0x66, 0x34, 0x39, 0x61, 0x63, 0x37, 0x32, 0x33, 0x63, 0x30, 0x66, 0x63, 0x34, 0x35, 0x37, 0x34, 0x34, 0x30, 0x38, 0x36, 0x32, 0x62, 0x34, 0x63, 0x36, 0x31, 0x33, 0x38, 0x64, 0x35, 0x37, 0x37, 0x66, 0x62, 0x38, 0x64, 0x37, 0x34, 0x61, 0x64, 0x61, 0x37, 0x32, 0x38, 0x62, 0x65, 0x33, 0x63, 0x35, 0x34, 0x33, 0x38, 0x66, 0x35, 0x63, 0x32, 0x63, 0x31, 0x64, 0x61, 0x38, 0x35, 0x33, 0x33, 0x30, 0x35, 0x65, 0x66, 0x65, 0x37, 0x32, 0x61, 0x39, 0x31, 0x37, 0x63, 0x34, 0x64, 0x66, 0x64, 0x38, 0x39, 0x37, 0x33, 0x35, 0x65, 0x38, 0x66, 0x61, 0x35, 0x63, 0x30, 0x37, 0x63, 0x39, 0x63, 0x63, 0x34, 0x34, 0x35, 0x32, 0x62, 0x36, 0x38, 0x34, 0x34, 0x34, 0x36, 0x33, 0x61, 0x31, 0x38, 0x37, 0x38, 0x31, 0x62, 0x64, 0x39, 0x61, 0x63, 0x63, 0x64, 0x64, 0x61, 0x37, 0x34, 0x62, 0x31, 0x65, 0x39, 0x35, 0x38, 0x65, 0x31, 0x63, 0x61, 0x37, 0x64, 0x65, 0x39, 0x66, 0x34, 0x39, 0x63, 0x39, 0x30, 0x30, 0x30, 0x37, 0x39, 0x61, 0x62, 0x36, 0x31, 0x30, 0x38, 0x36, 0x37, 0x30, 0x63, 0x63, 0x35, 0x35, 0x31, 0x39, 0x62, 0x36, 0x37, 0x34, 0x34, 0x61, 0x64, 0x32, 0x64, 0x31, 0x30, 0x35, 0x66, 0x36, 0x62, 0x30, 0x64, 0x34, 0x65, 0x63, 0x35, 0x62, 0x35, 0x65, 0x65, 0x38, 0x38, 0x63, 0x65, 0x65, 0x39, 0x62, 0x34, 0x65, 0x33, 0x31, 0x34, 0x38, 0x64, 0x61, 0x31, 0x64, 0x62, 0x63, 0x39, 0x63, 0x38, 0x31, 0x33, 0x61, 0x64, 0x39, 0x36, 0x65, 0x39, 0x31, 0x31, 0x66, 0x61, 0x61, 0x64, 0x33, 0x34, 0x39, 0x31, 0x35, 0x31, 0x64, 0x36, 0x38, 0x34, 0x33, 0x39, 0x35, 0x34, 0x64, 0x38, 0x39, 0x35, 0x37, 0x32, 0x63, 0x31, 0x37, 0x66, 0x36, 0x33, 0x62, 0x38, 0x33, 0x63, 0x64, 0x32, 0x64, 0x65, 0x66, 0x37, 0x32, 0x32, 0x38, 0x35, 0x39, 0x39, 0x38, 0x30, 0x61, 0x34, 0x33, 0x63, 0x62, 0x31, 0x31, 0x32, 0x34, 0x38, 0x30, 0x61, 0x37, 0x30, 0x61, 0x66, 0x32, 0x31, 0x31, 0x36, 0x31, 0x37, 0x64, 0x38, 0x65, 0x33, 0x34, 0x36, 0x65, 0x39, 0x36, 0x31, 0x61, 0x62, 0x66, 0x32, 0x66, 0x35, 0x64, 0x66, 0x36, 0x35, 0x31, 0x33, 0x36, 0x64, 0x61, 0x31, 0x36, 0x31, 0x39, 0x65, 0x30, 0x66, 0x30, 0x37, 0x32, 0x34, 0x37, 0x62, 0x31, 0x61, 0x38, 0x35, 0x38, 0x39, 0x66, 0x30, 0x30, 0x65, 0x39, 0x64, 0x65, 0x65, 0x66, 0x36, 0x31, 0x39, 0x37, 0x30, 0x61, 0x32, 0x33, 0x65, 0x64, 0x64, 0x36, 0x62, 0x39, 0x36, 0x62, 0x33, 0x33, 0x30, 0x65, 0x35, 0x34, 0x63, 0x39, 0x38, 0x65, 0x30, 0x64, 0x66, 0x30, 0x65, 0x36, 0x30, 0x32, 0x37, 0x32, 0x34, 0x64, 0x30, 0x30, 0x33, 0x36, 0x38, 0x63, 0x37, 0x32, 0x39, 0x66, 0x30, 0x39, 0x61, 0x32, 0x31, 0x64, 0x31, 0x62, 0x35, 0x32, 0x39, 0x33, 0x32, 0x32, 0x37, 0x36, 0x62, 0x31, 0x61, 0x66, 0x66, 0x34, 0x65, 0x36, 0x33, 0x64, 0x30, 0x30, 0x61, 0x63, 0x62, 0x33, 0x61, 0x33, 0x34, 0x31, 0x66, 0x31, 0x36, 0x39, 0x39, 0x39, 0x64, 0x35, 0x61, 0x30, 0x31, 0x33, 0x63, 0x32, 0x34, 0x35, 0x34, 0x66, 0x39, 0x35, 0x63, 0x65, 0x64, 0x33, 0x30, 0x66, 0x30, 0x64, 0x32, 0x32, 0x66, 0x36, 0x63, 0x38, 0x38, 0x66, 0x36, 0x37, 0x32, 0x66, 0x66, 0x63, 0x33, 0x65, 0x36, 0x31, 0x64, 0x35, 0x32, 0x32, 0x33, 0x64, 0x61, 0x33, 0x39, 0x32, 0x36, 0x36, 0x66, 0x36, 0x32, 0x65, 0x62, 0x61, 0x65, 0x35, 0x64, 0x64, 0x37, 0x35, 0x61, 0x34, 0x38, 0x39, 0x65, 0x66, 0x65, 0x62, 0x36, 0x64, 0x66, 0x30, 0x38, 0x36, 0x32, 0x64, 0x31, 0x31, 0x37, 0x32, 0x63, 0x64, 0x64, 0x66, 0x30, 0x65, 0x33, 0x36, 0x35, 0x66, 0x37, 0x35, 0x63, 0x31, 0x38, 0x64, 0x62, 0x63, 0x38, 0x34, 0x38, 0x66, 0x36, 0x37, 0x34, 0x36, 0x61, 0x33, 0x63, 0x63, 0x61, 0x65, 0x31, 0x36, 0x38, 0x34, 0x37, 0x35, 0x32, 0x61, 0x32, 0x31, 0x37, 0x34, 0x30, 0x39, 0x62, 0x38, 0x62, 0x35, 0x37, 0x61, 0x39, 0x31, 0x61, 0x61, 0x30, 0x35, 0x65, 0x65, 0x61, 0x32, 0x37, 0x32, 0x66, 0x38, 0x63, 0x39, 0x36, 0x61, 0x30, 0x39, 0x35, 0x39, 0x34, 0x39, 0x35, 0x36, 0x63, 0x33, 0x65, 0x35, 0x64, 0x39, 0x31, 0x37, 0x63, 0x64, 0x36, 0x31, 0x35, 0x36, 0x63, 0x30, 0x39, 0x36, 0x63, 0x32, 0x36, 0x64, 0x62, 0x64, 0x39, 0x33, 0x66, 0x39, 0x61, 0x34, 0x66, 0x61, 0x35, 0x63, 0x38, 0x61, 0x34, 0x31, 0x31, 0x30, 0x39, 0x32, 0x63, 0x30, 0x63, 0x31, 0x63, 0x36, 0x33, 0x62, 0x65, 0x39, 0x34, 0x30, 0x33, 0x66, 0x31, 0x39, 0x64, 0x36, 0x63, 0x36, 0x61, 0x39, 0x61, 0x30, 0x35, 0x32, 0x66, 0x63, 0x34, 0x61, 0x36, 0x61, 0x63, 0x66, 0x34, 0x36, 0x63, 0x39, 0x66, 0x64, 0x61, 0x61, 0x66, 0x38, 0x61, 0x36, 0x36, 0x32, 0x35, 0x39, 0x31, 0x66, 0x37, 0x35, 0x34, 0x63, 0x33, 0x30, 0x39, 0x63, 0x32, 0x64, 0x35, 0x66, 0x36, 0x32, 0x37, 0x35, 0x65, 0x39, 0x32, 0x66, 0x36, 0x34, 0x62, 0x36, 0x66, 0x38, 0x31, 0x36, 0x34, 0x39, 0x66, 0x62, 0x66, 0x35, 0x65, 0x38, 0x66, 0x30, 0x35, 0x63, 0x37, 0x65, 0x37, 0x32, 0x38, 0x34, 0x32, 0x65, 0x61, 0x36, 0x32, 0x61, 0x63, 0x63, 0x39, 0x62, 0x38, 0x61, 0x62, 0x38, 0x63, 0x38, 0x32, 0x65, 0x34, 0x39, 0x62, 0x38, 0x65, 0x39, 0x36, 0x61, 0x66, 0x32, 0x32, 0x31, 0x39, 0x62, 0x32, 0x62, 0x39, 0x32, 0x37, 0x32, 0x32, 0x63, 0x64, 0x35, 0x61, 0x36, 0x32, 0x38, 0x61, 0x62, 0x31, 0x34, 0x66, 0x37, 0x34, 0x38, 0x33, 0x66, 0x38, 0x66, 0x35, 0x36, 0x32, 0x36, 0x31, 0x61, 0x61, 0x63, 0x31, 0x37, 0x65, 0x37, 0x62, 0x38, 0x62, 0x64, 0x31, 0x30, 0x31, 0x36, 0x61, 0x34, 0x61, 0x39, 0x36, 0x31, 0x36, 0x30, 0x37, 0x35, 0x38, 0x32, 0x39, 0x63, 0x32, 0x30, 0x65, 0x62, 0x35, 0x34, 0x30, 0x36, 0x37, 0x32, 0x63, 0x61, 0x38, 0x64, 0x38, 0x32, 0x39, 0x34, 0x37, 0x30, 0x63, 0x30, 0x30, 0x35, 0x30, 0x64, 0x38, 0x66, 0x30, 0x38, 0x34, 0x31, 0x37, 0x63, 0x64, 0x66, 0x34, 0x65, 0x62, 0x34, 0x31, 0x37, 0x65, 0x61, 0x30, 0x63, 0x35, 0x38, 0x36, 0x34, 0x65, 0x39, 0x65, 0x37, 0x63, 0x62, 0x38, 0x63, 0x61, 0x63, 0x61, 0x38, 0x38, 0x38, 0x33, 0x32, 0x63, 0x62, 0x32, 0x34, 0x35, 0x66, 0x37, 0x32, 0x36, 0x64, 0x36, 0x30, 0x61, 0x34, 0x36, 0x30, 0x30, 0x34, 0x66, 0x34, 0x62, 0x66, 0x37, 0x31, 0x66, 0x31, 0x30, 0x37, 0x33, 0x33, 0x30, 0x64, 0x36, 0x33, 0x34, 0x62, 0x38, 0x36, 0x64, 0x39, 0x66, 0x61, 0x38, 0x39, 0x30, 0x35, 0x31, 0x35, 0x37, 0x33, 0x65, 0x64, 0x39, 0x34, 0x37, 0x65, 0x37, 0x65, 0x30, 0x39, 0x35, 0x64, 0x38, 0x63, 0x66, 0x64, 0x36, 0x37, 0x37, 0x64, 0x37, 0x32, 0x33, 0x39, 0x36, 0x39, 0x31, 0x32, 0x61, 0x61, 0x31, 0x32, 0x62, 0x39, 0x66, 0x62, 0x38, 0x64, 0x64, 0x37, 0x64, 0x34, 0x66, 0x32, 0x31, 0x64, 0x63, 0x30, 0x62, 0x62, 0x32, 0x38, 0x66, 0x32, 0x64, 0x31, 0x65, 0x32, 0x39, 0x30, 0x34, 0x37, 0x36, 0x37, 0x38, 0x37, 0x66, 0x36, 0x33, 0x66, 0x61, 0x33, 0x65, 0x34, 0x65, 0x65, 0x64, 0x32, 0x34, 0x36, 0x39, 0x63, 0x66, 0x37, 0x37, 0x32, 0x63, 0x66, 0x61, 0x37, 0x34, 0x35, 0x31, 0x66, 0x64, 0x66, 0x31, 0x39, 0x36, 0x37, 0x34, 0x61, 0x30, 0x31, 0x30, 0x30, 0x64, 0x36, 0x30, 0x66, 0x66, 0x63, 0x35, 0x33, 0x35, 0x63, 0x64, 0x61, 0x38, 0x36, 0x63, 0x32, 0x34, 0x38, 0x64, 0x65, 0x31, 0x66, 0x31, 0x37, 0x63, 0x36, 0x30, 0x63, 0x64, 0x65, 0x31, 0x30, 0x34, 0x62, 0x39, 0x37, 0x34, 0x31, 0x30, 0x35, 0x65, 0x63, 0x36, 0x65, 0x64, 0x63, 0x39, 0x62, 0x37, 0x65, 0x34, 0x30, 0x38, 0x32, 0x32, 0x61, 0x39, 0x36, 0x62, 0x33, 0x63, 0x37, 0x65, 0x36, 0x30, 0x31, 0x38, 0x65, 0x36, 0x30, 0x64, 0x62, 0x32, 0x34, 0x39, 0x33, 0x64, 0x33, 0x65, 0x35, 0x33, 0x61, 0x61, 0x30, 0x63, 0x62, 0x39, 0x63, 0x61, 0x39, 0x65, 0x33, 0x35, 0x39, 0x39, 0x34, 0x30, 0x36, 0x34, 0x34, 0x33, 0x34, 0x37, 0x61, 0x65, 0x32, 0x33, 0x66, 0x65, 0x35, 0x33, 0x63, 0x39, 0x38, 0x30, 0x36, 0x32, 0x65, 0x37, 0x34, 0x63, 0x62, 0x39, 0x39, 0x31, 0x61, 0x64, 0x37, 0x65, 0x30, 0x33, 0x33, 0x34, 0x32, 0x36, 0x31, 0x34, 0x66, 0x38, 0x36, 0x39, 0x36, 0x62, 0x62, 0x66, 0x63, 0x30, 0x39, 0x37, 0x62, 0x31, 0x62, 0x61, 0x37, 0x36, 0x38, 0x65, 0x30, 0x34, 0x34, 0x34, 0x39, 0x64, 0x63, 0x62, 0x33, 0x32, 0x39, 0x38, 0x64, 0x37, 0x32, 0x65, 0x35, 0x30, 0x61, 0x30, 0x37, 0x33, 0x33, 0x61, 0x36, 0x34, 0x34, 0x61, 0x36, 0x63, 0x30, 0x36, 0x64, 0x30, 0x36, 0x65, 0x38, 0x32, 0x37, 0x34, 0x64, 0x39, 0x30, 0x65, 0x33, 0x64, 0x39, 0x39, 0x39, 0x34, 0x65, 0x64, 0x37, 0x62, 0x39, 0x32, 0x38, 0x61, 0x65, 0x37, 0x63, 0x37, 0x65, 0x66, 0x61, 0x64, 0x31, 0x34, 0x35, 0x65, 0x32, 0x33, 0x30, 0x36, 0x65, 0x62, 0x66, 0x33, 0x61, 0x32, 0x66, 0x32, 0x35, 0x38, 0x32, 0x32, 0x33, 0x61, 0x66, 0x65, 0x38, 0x66, 0x31, 0x64, 0x34, 0x32, 0x31, 0x39, 0x62, 0x66, 0x33, 0x37, 0x64, 0x61, 0x33, 0x36, 0x37, 0x30, 0x30, 0x32, 0x36, 0x32, 0x36, 0x34, 0x64, 0x34, 0x64, 0x63, 0x31, 0x64, 0x32, 0x39, 0x32, 0x38, 0x63, 0x31, 0x62, 0x37, 0x38, 0x36, 0x35, 0x62, 0x66, 0x39, 0x39, 0x62, 0x30, 0x33, 0x36, 0x64, 0x65, 0x37, 0x32, 0x38, 0x39, 0x32, 0x38, 0x36, 0x65, 0x63, 0x36, 0x61, 0x62, 0x64, 0x31, 0x32, 0x33, 0x35, 0x61, 0x64, 0x61, 0x37, 0x63, 0x34, 0x65, 0x66, 0x62, 0x33, 0x34, 0x39, 0x64, 0x32, 0x31, 0x66, 0x37, 0x39, 0x63, 0x61, 0x30, 0x35, 0x36, 0x32, 0x63, 0x65, 0x33, 0x65, 0x39, 0x33, 0x31, 0x65, 0x62, 0x35, 0x30, 0x64, 0x34, 0x31, 0x31, 0x36, 0x61, 0x34, 0x61, 0x66, 0x37, 0x62, 0x66, 0x37, 0x32, 0x62, 0x63, 0x66, 0x32, 0x66, 0x33, 0x39, 0x30, 0x33, 0x34, 0x31, 0x34, 0x31, 0x32, 0x63, 0x37, 0x37, 0x63, 0x62, 0x64, 0x65, 0x62, 0x61, 0x32, 0x36, 0x63, 0x61, 0x62, 0x61, 0x62, 0x35, 0x30, 0x64, 0x30, 0x35, 0x37, 0x36, 0x61, 0x30, 0x30, 0x62, 0x33, 0x31, 0x33, 0x66, 0x65, 0x63, 0x34, 0x32, 0x34, 0x62, 0x61, 0x30, 0x33, 0x64, 0x34, 0x64, 0x65, 0x31, 0x39, 0x61, 0x33, 0x37, 0x32, 0x33, 0x32, 0x36, 0x62, 0x31, 0x37, 0x31, 0x65, 0x32, 0x35, 0x31, 0x37, 0x30, 0x30, 0x61, 0x37, 0x32, 0x31, 0x32, 0x31, 0x64, 0x37, 0x66, 0x61, 0x30, 0x30, 0x30, 0x39, 0x65, 0x34, 0x65, 0x38, 0x63, 0x39, 0x34, 0x65, 0x31, 0x38, 0x36, 0x61, 0x37, 0x62, 0x65, 0x33, 0x36, 0x35, 0x62, 0x61, 0x31, 0x35, 0x36, 0x38, 0x64, 0x39, 0x39, 0x33, 0x61, 0x63, 0x31, 0x36, 0x62, 0x39, 0x37, 0x32, 0x30, 0x37, 0x36, 0x34, 0x38, 0x30, 0x36, 0x31, 0x39, 0x37, 0x62, 0x32, 0x65, 0x65, 0x61, 0x63, 0x32, 0x64, 0x37, 0x35, 0x36, 0x35, 0x37, 0x38, 0x33, 0x62, 0x39, 0x33, 0x38, 0x61, 0x36, 0x66, 0x62, 0x61, 0x62, 0x61, 0x35, 0x37, 0x63, 0x62, 0x36, 0x30, 0x30, 0x36, 0x32, 0x62, 0x35, 0x33, 0x63, 0x31, 0x65, 0x38, 0x63, 0x65, 0x32, 0x32, 0x36, 0x39, 0x38, 0x33, 0x61, 0x39, 0x37, 0x32, 0x64, 0x65, 0x65, 0x61, 0x39, 0x33, 0x63, 0x65, 0x64, 0x37, 0x62, 0x38, 0x38, 0x63, 0x32, 0x65, 0x38, 0x37, 0x39, 0x32, 0x30, 0x61, 0x30, 0x31, 0x35, 0x36, 0x63, 0x31, 0x62, 0x39, 0x34, 0x61, 0x34, 0x62, 0x65, 0x63, 0x30, 0x65, 0x34, 0x37, 0x66, 0x63, 0x66, 0x62, 0x33, 0x30, 0x65, 0x31, 0x39, 0x37, 0x32, 0x66, 0x30, 0x34, 0x37, 0x62, 0x35, 0x36, 0x32, 0x35, 0x32, 0x62, 0x36, 0x39, 0x64, 0x66, 0x32, 0x32, 0x66, 0x31, 0x32, 0x31, 0x37, 0x35, 0x38, 0x61, 0x34, 0x39, 0x62, 0x30, 0x38, 0x64, 0x38, 0x65, 0x35, 0x31, 0x34, 0x37, 0x61, 0x37, 0x36, 0x31, 0x31, 0x34, 0x33, 0x65, 0x36, 0x65, 0x63, 0x35, 0x65, 0x32, 0x61, 0x34, 0x33, 0x32, 0x32, 0x66, 0x39, 0x66, 0x65, 0x64, 0x61, 0x34, 0x64, 0x65, 0x65, 0x35, 0x39, 0x62, 0x32, 0x36, 0x38, 0x63, 0x34, 0x38, 0x37, 0x32, 0x35, 0x35, 0x30, 0x61, 0x37, 0x36, 0x63, 0x35, 0x62, 0x63, 0x30, 0x63, 0x30, 0x37, 0x32, 0x33, 0x32, 0x61, 0x37, 0x37, 0x63, 0x37, 0x64, 0x30, 0x34, 0x63, 0x34, 0x37, 0x62, 0x33, 0x30, 0x65, 0x66, 0x36, 0x39, 0x36, 0x35, 0x38, 0x34, 0x30, 0x37, 0x35, 0x36, 0x65, 0x30, 0x30, 0x37, 0x63, 0x63, 0x38, 0x37, 0x32, 0x66, 0x37, 0x31, 0x65, 0x39, 0x66, 0x61, 0x66, 0x31, 0x39, 0x34, 0x61, 0x36, 0x32, 0x62, 0x36, 0x39, 0x37, 0x38, 0x37, 0x65, 0x30, 0x31, 0x37, 0x37, 0x36, 0x32, 0x66, 0x64, 0x34, 0x66, 0x39, 0x31, 0x34, 0x38, 0x66, 0x37, 0x61, 0x34, 0x33, 0x62, 0x39, 0x64, 0x35, 0x30, 0x64, 0x38, 0x61, 0x62, 0x65, 0x34, 0x32, 0x39, 0x30, 0x66, 0x62, 0x39, 0x38, 0x36, 0x38, 0x36, 0x34, 0x63, 0x63, 0x66, 0x32, 0x34, 0x66, 0x39, 0x66, 0x35, 0x32, 0x66, 0x38, 0x34, 0x38, 0x33, 0x63, 0x38, 0x37, 0x65, 0x35, 0x65, 0x34, 0x65, 0x34, 0x35, 0x63, 0x34, 0x65, 0x39, 0x33, 0x35, 0x66, 0x34, 0x66, 0x33, 0x33, 0x37, 0x62, 0x37, 0x64, 0x38, 0x38, 0x62, 0x61, 0x61, 0x33, 0x38, 0x62, 0x39, 0x30, 0x33, 0x39, 0x66, 0x64, 0x66, 0x30, 0x33, 0x63, 0x65, 0x34, 0x30, 0x61, 0x39, 0x66, 0x66, 0x64, 0x63, 0x36, 0x65, 0x31, 0x31, 0x31, 0x66, 0x65, 0x36, 0x39, 0x32, 0x66, 0x33, 0x38, 0x63, 0x36, 0x35, 0x30, 0x37, 0x35, 0x32, 0x30, 0x31, 0x39, 0x64, 0x62, 0x32, 0x38, 0x33, 0x36, 0x36, 0x38, 0x35, 0x36, 0x30, 0x66, 0x64, 0x33, 0x31, 0x33, 0x34, 0x39, 0x63, 0x35, 0x38, 0x34, 0x39, 0x31, 0x38, 0x33, 0x66, 0x30, 0x64, 0x39, 0x31, 0x64, 0x65, 0x30, 0x64, 0x32, 0x62, 0x38, 0x38, 0x39, 0x33, 0x31, 0x65, 0x64, 0x33, 0x39, 0x33, 0x61, 0x33, 0x31, 0x37, 0x32, 0x36, 0x32, 0x34, 0x36, 0x34, 0x39, 0x39, 0x33, 0x37, 0x66, 0x62, 0x31, 0x61, 0x66, 0x62, 0x30, 0x34, 0x61, 0x39, 0x32, 0x66, 0x66, 0x32, 0x63, 0x34, 0x34, 0x36, 0x39, 0x30, 0x34, 0x31, 0x36, 0x37, 0x39, 0x30, 0x35, 0x37, 0x37, 0x36, 0x32, 0x64, 0x64, 0x64, 0x31, 0x35, 0x61, 0x34, 0x63, 0x38, 0x61, 0x34, 0x35, 0x30, 0x31, 0x62, 0x36, 0x31, 0x31, 0x36, 0x63, 0x39, 0x61, 0x37, 0x32, 0x61, 0x32, 0x32, 0x36, 0x30, 0x62, 0x32, 0x65, 0x38, 0x35, 0x38, 0x38, 0x39, 0x34, 0x38, 0x66, 0x61, 0x65, 0x36, 0x39, 0x31, 0x33, 0x30, 0x33, 0x63, 0x35, 0x61, 0x37, 0x30, 0x34, 0x31, 0x30, 0x32, 0x37, 0x63, 0x65, 0x34, 0x61, 0x35, 0x38, 0x32, 0x37, 0x63, 0x33, 0x39, 0x65, 0x64, 0x63, 0x36, 0x61, 0x38, 0x37, 0x31, 0x34, 0x34, 0x33, 0x34, 0x62, 0x35, 0x33, 0x37, 0x64, 0x37, 0x32, 0x34, 0x38, 0x38, 0x34, 0x66, 0x62, 0x62, 0x39, 0x61, 0x33, 0x39, 0x62, 0x66, 0x62, 0x66, 0x38, 0x38, 0x37, 0x65, 0x39, 0x34, 0x35, 0x31, 0x35, 0x37, 0x63, 0x61, 0x32, 0x65, 0x65, 0x39, 0x39, 0x30, 0x66, 0x64, 0x65, 0x64, 0x36, 0x38, 0x65, 0x33, 0x30, 0x36, 0x30, 0x34, 0x61, 0x66, 0x39, 0x39, 0x34, 0x32, 0x66, 0x38, 0x65, 0x33, 0x39, 0x31, 0x39, 0x35, 0x63, 0x35, 0x39, 0x37, 0x32, 0x61, 0x35, 0x33, 0x32, 0x33, 0x33, 0x33, 0x65, 0x66, 0x34, 0x64, 0x35, 0x65, 0x61, 0x63, 0x62, 0x63, 0x39, 0x62, 0x65, 0x38, 0x35, 0x33, 0x34, 0x32, 0x37, 0x33, 0x38, 0x35, 0x34, 0x35, 0x30, 0x33, 0x61, 0x30, 0x65, 0x62, 0x39, 0x34, 0x65, 0x62, 0x36, 0x30, 0x30, 0x37, 0x64, 0x34, 0x66, 0x37, 0x65, 0x66, 0x33, 0x38, 0x36, 0x63, 0x36, 0x61, 0x61, 0x33, 0x37, 0x61, 0x38, 0x36, 0x36, 0x65, 0x31, 0x63, 0x31, 0x32, 0x63, 0x30, 0x66, 0x33, 0x34, 0x66, 0x35, 0x64, 0x62, 0x32, 0x61, 0x39, 0x32, 0x62, 0x31, 0x65, 0x33, 0x61, 0x64, 0x34, 0x36, 0x37, 0x63, 0x37, 0x65, 0x31, 0x66, 0x37, 0x35, 0x62, 0x64, 0x61, 0x64, 0x33, 0x36, 0x65, 0x30, 0x35, 0x34, 0x37, 0x34, 0x65, 0x31, 0x35, 0x38, 0x31, 0x36, 0x62, 0x64, 0x31, 0x64, 0x66, 0x34, 0x65, 0x63, 0x38, 0x35, 0x32, 0x35, 0x39, 0x32, 0x36, 0x32, 0x64, 0x33, 0x66, 0x66, 0x37, 0x61, 0x35, 0x31, 0x38, 0x34, 0x66, 0x38, 0x30, 0x31, 0x32, 0x32, 0x62, 0x31, 0x33, 0x64, 0x65, 0x32, 0x30, 0x38, 0x65, 0x38, 0x37, 0x62, 0x64, 0x39, 0x62, 0x32, 0x63, 0x36, 0x30, 0x37, 0x65, 0x36, 0x65, 0x66, 0x61, 0x65, 0x38, 0x36, 0x34, 0x35, 0x36, 0x39, 0x61, 0x32, 0x64, 0x38, 0x62, 0x34, 0x36, 0x34, 0x66, 0x63, 0x30, 0x34, 0x37, 0x33, 0x64, 0x65, 0x61, 0x36, 0x35, 0x33, 0x35, 0x31, 0x66, 0x34, 0x65, 0x33, 0x64, 0x35, 0x32, 0x61, 0x34, 0x39, 0x37, 0x34, 0x35, 0x32, 0x63, 0x37, 0x39, 0x37, 0x34, 0x30, 0x63, 0x34, 0x35, 0x38, 0x34, 0x35, 0x30, 0x39, 0x31, 0x34, 0x65, 0x64, 0x61, 0x36, 0x38, 0x39, 0x34, 0x37, 0x34, 0x33, 0x36, 0x37, 0x32, 0x31, 0x37, 0x64, 0x31, 0x38, 0x64, 0x36, 0x32, 0x30, 0x34, 0x32, 0x65, 0x36, 0x33, 0x34, 0x38, 0x37, 0x63, 0x64, 0x61, 0x62, 0x37, 0x30, 0x65, 0x65, 0x66, 0x35, 0x31, 0x32, 0x66, 0x36, 0x36, 0x38, 0x31, 0x61, 0x32, 0x61, 0x65, 0x66, 0x34, 0x64, 0x32, 0x33, 0x35, 0x39, 0x37, 0x38, 0x33, 0x39, 0x33, 0x36, 0x63, 0x61, 0x65, 0x32, 0x61, 0x35, 0x63, 0x33, 0x64, 0x66, 0x38, 0x34, 0x33, 0x63, 0x39, 0x33, 0x63, 0x37, 0x66, 0x33, 0x35, 0x66, 0x37, 0x32, 0x30, 0x38, 0x62, 0x33, 0x38, 0x36, 0x62, 0x39, 0x38, 0x32, 0x32, 0x66, 0x37, 0x39, 0x64, 0x32, 0x31, 0x31, 0x35, 0x34, 0x61, 0x31, 0x65, 0x64, 0x66, 0x32, 0x35, 0x36, 0x38, 0x62, 0x34, 0x62, 0x33, 0x35, 0x35, 0x65, 0x64, 0x37, 0x64, 0x61, 0x33, 0x63, 0x66, 0x37, 0x65, 0x35, 0x65, 0x37, 0x39, 0x35, 0x34, 0x63, 0x61, 0x37, 0x35, 0x38, 0x32, 0x32, 0x31, 0x37, 0x61, 0x32, 0x37, 0x32, 0x38, 0x62, 0x63, 0x31, 0x63, 0x34, 0x32, 0x37, 0x36, 0x31, 0x30, 0x61, 0x33, 0x38, 0x33, 0x31, 0x64, 0x36, 0x37, 0x62, 0x39, 0x33, 0x31, 0x66, 0x32, 0x39, 0x36, 0x62, 0x33, 0x63, 0x33, 0x30, 0x62, 0x33, 0x37, 0x32, 0x64, 0x31, 0x39, 0x66, 0x63, 0x62, 0x34, 0x64, 0x36, 0x30, 0x62, 0x33, 0x63, 0x30, 0x62, 0x38, 0x62, 0x66, 0x65, 0x30, 0x66, 0x36, 0x36, 0x37, 0x35, 0x30, 0x33, 0x64, 0x63, 0x37, 0x63, 0x64, 0x37, 0x30, 0x64, 0x34, 0x31, 0x64, 0x66, 0x36, 0x32, 0x39, 0x66, 0x66, 0x31, 0x33, 0x39, 0x64, 0x30, 0x66, 0x36, 0x36, 0x39, 0x35, 0x32, 0x39, 0x30, 0x31, 0x66, 0x34, 0x32, 0x37, 0x39, 0x35, 0x63, 0x34, 0x62, 0x61, 0x62, 0x63, 0x36, 0x38, 0x66, 0x36, 0x35, 0x33, 0x65, 0x64, 0x30, 0x38, 0x30, 0x62, 0x63, 0x38, 0x39, 0x35, 0x66, 0x35, 0x36, 0x66, 0x34, 0x30, 0x35, 0x33, 0x61, 0x65, 0x63, 0x62, 0x39, 0x37, 0x66, 0x36, 0x36, 0x30, 0x33, 0x39, 0x32, 0x36, 0x61, 0x32, 0x61, 0x65, 0x32, 0x38, 0x35, 0x64, 0x66, 0x38, 0x63, 0x66, 0x32, 0x30, 0x63, 0x35, 0x37, 0x65, 0x33, 0x34, 0x65, 0x35, 0x36, 0x39, 0x36, 0x35, 0x65, 0x61, 0x61, 0x64, 0x64, 0x34, 0x66, 0x37, 0x62, 0x64, 0x31, 0x62, 0x32, 0x30, 0x33, 0x30, 0x38, 0x66, 0x38, 0x30, 0x37, 0x32, 0x35, 0x30, 0x38, 0x33, 0x39, 0x30, 0x37, 0x32, 0x34, 0x63, 0x61, 0x65, 0x35, 0x36, 0x31, 0x31, 0x66, 0x30, 0x35, 0x37, 0x34, 0x64, 0x31, 0x65, 0x38, 0x33, 0x63, 0x30, 0x64, 0x62, 0x64, 0x66, 0x62, 0x63, 0x36, 0x31, 0x61, 0x62, 0x30, 0x36, 0x66, 0x64, 0x63, 0x63, 0x30, 0x65, 0x36, 0x35, 0x62, 0x65, 0x33, 0x32, 0x62, 0x66, 0x32, 0x37, 0x32, 0x65, 0x61, 0x64, 0x38, 0x36, 0x37, 0x32, 0x35, 0x34, 0x35, 0x61, 0x38, 0x31, 0x34, 0x35, 0x62, 0x62, 0x31, 0x31, 0x37, 0x39, 0x35, 0x31, 0x31, 0x63, 0x38, 0x38, 0x32, 0x32, 0x63, 0x36, 0x33, 0x66, 0x66, 0x31, 0x65, 0x37, 0x62, 0x66, 0x62, 0x62, 0x33, 0x62, 0x38, 0x35, 0x32, 0x37, 0x63, 0x34, 0x38, 0x62, 0x61, 0x35, 0x62, 0x65, 0x32, 0x38, 0x33, 0x30, 0x37, 0x38, 0x65, 0x62, 0x66, 0x63, 0x61, 0x61, 0x32, 0x66, 0x37, 0x32, 0x65, 0x61, 0x66, 0x30, 0x61, 0x33, 0x36, 0x32, 0x66, 0x66, 0x37, 0x34, 0x37, 0x65, 0x32, 0x32, 0x36, 0x63, 0x34, 0x66, 0x32, 0x32, 0x38, 0x32, 0x38, 0x31, 0x66, 0x65, 0x35, 0x65, 0x33, 0x36, 0x30, 0x36, 0x65, 0x62, 0x38, 0x32, 0x36, 0x66, 0x34, 0x31, 0x36, 0x31, 0x38, 0x32, 0x38, 0x65, 0x65, 0x31, 0x61, 0x35, 0x30, 0x31, 0x64, 0x34, 0x38, 0x63, 0x36, 0x61, 0x33, 0x36, 0x32, 0x37, 0x34, 0x39, 0x62, 0x61, 0x34, 0x33, 0x30, 0x32, 0x62, 0x38, 0x39, 0x34, 0x31, 0x64, 0x38, 0x31, 0x62, 0x65, 0x37, 0x35, 0x31, 0x66, 0x32, 0x33, 0x63, 0x64, 0x32, 0x37, 0x62, 0x30, 0x34, 0x30, 0x63, 0x32, 0x64, 0x38, 0x39, 0x30, 0x63, 0x39, 0x61, 0x36, 0x61, 0x32, 0x30, 0x34, 0x37, 0x62, 0x33, 0x61, 0x31, 0x66, 0x37, 0x61, 0x33, 0x33, 0x66, 0x63, 0x65, 0x36, 0x31, 0x32, 0x37, 0x32, 0x35, 0x65, 0x37, 0x64, 0x38, 0x33, 0x31, 0x39, 0x64, 0x65, 0x63, 0x63, 0x35, 0x34, 0x35, 0x38, 0x30, 0x33, 0x61, 0x34, 0x32, 0x30, 0x30, 0x39, 0x39, 0x61, 0x64, 0x35, 0x61, 0x37, 0x63, 0x61, 0x35, 0x32, 0x62, 0x34, 0x31, 0x62, 0x30, 0x66, 0x35, 0x31, 0x65, 0x35, 0x38, 0x38, 0x64, 0x33, 0x35, 0x38, 0x33, 0x65, 0x37, 0x31, 0x32, 0x34, 0x34, 0x64, 0x37, 0x35, 0x30, 0x32, 0x37, 0x32, 0x33, 0x37, 0x31, 0x30, 0x37, 0x37, 0x31, 0x33, 0x64, 0x64, 0x61, 0x30, 0x38, 0x30, 0x33, 0x30, 0x35, 0x35, 0x33, 0x31, 0x34, 0x63, 0x31, 0x66, 0x61, 0x65, 0x38, 0x66, 0x63, 0x64, 0x38, 0x39, 0x39, 0x33, 0x36, 0x33, 0x32, 0x61, 0x37, 0x65, 0x64, 0x39, 0x31, 0x62, 0x62, 0x30, 0x66, 0x64, 0x63, 0x63, 0x37, 0x39, 0x31, 0x63, 0x66, 0x62, 0x33, 0x64, 0x37, 0x32, 0x30, 0x33, 0x37, 0x32, 0x64, 0x32, 0x66, 0x35, 0x30, 0x36, 0x39, 0x38, 0x36, 0x39, 0x38, 0x39, 0x30, 0x35, 0x31, 0x61, 0x36, 0x64, 0x33, 0x32, 0x37, 0x37, 0x37, 0x63, 0x32, 0x64, 0x31, 0x61, 0x61, 0x30, 0x32, 0x35, 0x32, 0x34, 0x36, 0x37, 0x38, 0x38, 0x66, 0x33, 0x30, 0x66, 0x35, 0x34, 0x63, 0x31, 0x34, 0x34, 0x63, 0x30, 0x35, 0x33, 0x35, 0x39, 0x38, 0x39, 0x33, 0x33, 0x33, 0x64, 0x35, 0x37, 0x37, 0x32, 0x33, 0x66, 0x39, 0x66, 0x66, 0x35, 0x34, 0x61, 0x36, 0x39, 0x31, 0x64, 0x30, 0x34, 0x33, 0x66, 0x32, 0x63, 0x32, 0x64, 0x38, 0x34, 0x61, 0x65, 0x39, 0x35, 0x32, 0x37, 0x32, 0x38, 0x30, 0x37, 0x38, 0x36, 0x30, 0x64, 0x36, 0x63, 0x35, 0x37, 0x36, 0x61, 0x30, 0x63, 0x36, 0x64, 0x66, 0x64, 0x39, 0x30, 0x63, 0x34, 0x62, 0x61, 0x65, 0x36, 0x62, 0x36, 0x35, 0x30, 0x33, 0x32, 0x37, 0x32, 0x32, 0x35, 0x30, 0x37, 0x38, 0x61, 0x63, 0x32, 0x62, 0x64, 0x39, 0x36, 0x64, 0x63, 0x35, 0x64, 0x36, 0x34, 0x36, 0x61, 0x38, 0x37, 0x33, 0x61, 0x36, 0x64, 0x37, 0x35, 0x34, 0x33, 0x63, 0x32, 0x65, 0x31, 0x32, 0x36, 0x35, 0x62, 0x37, 0x31, 0x66, 0x39, 0x39, 0x64, 0x33, 0x63, 0x39, 0x66, 0x31, 0x65, 0x32, 0x61, 0x30, 0x36, 0x61, 0x33, 0x30, 0x35, 0x39, 0x63, 0x30, 0x36, 0x37, 0x32, 0x37, 0x63, 0x30, 0x66, 0x35, 0x31, 0x39, 0x36, 0x34, 0x31, 0x39, 0x61, 0x66, 0x63, 0x31, 0x39, 0x61, 0x34, 0x35, 0x35, 0x62, 0x63, 0x33, 0x61, 0x64, 0x62, 0x34, 0x61, 0x65, 0x32, 0x33, 0x65, 0x36, 0x39, 0x65, 0x61, 0x30, 0x30, 0x37, 0x33, 0x65, 0x37, 0x63, 0x36, 0x30, 0x30, 0x66, 0x63, 0x35, 0x64, 0x66, 0x64, 0x37, 0x30, 0x35, 0x30, 0x62, 0x62, 0x61, 0x62, 0x38, 0x38, 0x35, 0x30, 0x62, 0x61, 0x33, 0x35, 0x62, 0x32, 0x35, 0x64, 0x65, 0x36, 0x64, 0x62, 0x62, 0x64, 0x38, 0x66, 0x37, 0x66, 0x37, 0x62, 0x33, 0x39, 0x35, 0x61, 0x63, 0x62, 0x36, 0x62, 0x36, 0x64, 0x34, 0x36, 0x30, 0x65, 0x37, 0x62, 0x37, 0x38, 0x38, 0x33, 0x65, 0x39, 0x33, 0x35, 0x30, 0x38, 0x63, 0x34, 0x32, 0x64, 0x37, 0x66, 0x32, 0x61, 0x66, 0x61, 0x34, 0x63, 0x38, 0x66, 0x39, 0x61, 0x32, 0x36, 0x66, 0x37, 0x36, 0x39, 0x66, 0x31, 0x61, 0x30, 0x64, 0x33, 0x31, 0x66, 0x65, 0x38, 0x38, 0x38, 0x63, 0x61, 0x37, 0x63, 0x61, 0x32, 0x37, 0x37, 0x31, 0x65, 0x31, 0x63, 0x31, 0x32, 0x38, 0x37, 0x33, 0x31, 0x34, 0x64, 0x32, 0x38, 0x33, 0x33, 0x65, 0x62, 0x64, 0x35, 0x33, 0x37, 0x32, 0x36, 0x61, 0x66, 0x38, 0x35, 0x36, 0x65, 0x34, 0x36, 0x35, 0x38, 0x61, 0x30, 0x62, 0x62, 0x36, 0x65, 0x64, 0x35, 0x35, 0x63, 0x34, 0x31, 0x61, 0x63, 0x30, 0x34, 0x62, 0x34, 0x33, 0x34, 0x61, 0x33, 0x65, 0x36, 0x37, 0x33, 0x36, 0x63, 0x64, 0x39, 0x32, 0x36, 0x31, 0x33, 0x30, 0x30, 0x62, 0x39, 0x33, 0x31, 0x35, 0x61, 0x64, 0x33, 0x36, 0x34, 0x63, 0x34, 0x36, 0x37, 0x32, 0x33, 0x38, 0x34, 0x38, 0x37, 0x62, 0x61, 0x30, 0x31, 0x30, 0x38, 0x61, 0x63, 0x65, 0x65, 0x64, 0x64, 0x31, 0x63, 0x38, 0x38, 0x31, 0x34, 0x66, 0x37, 0x66, 0x61, 0x39, 0x65, 0x31, 0x34, 0x62, 0x38, 0x32, 0x32, 0x34, 0x33, 0x31, 0x36, 0x34, 0x65, 0x38, 0x34, 0x37, 0x36, 0x30, 0x38, 0x38, 0x37, 0x61, 0x32, 0x34, 0x31, 0x39, 0x65, 0x31, 0x35, 0x35, 0x39, 0x31, 0x32, 0x33, 0x65, 0x39, 0x64, 0x35, 0x66, 0x39, 0x34, 0x31, 0x62, 0x64, 0x34, 0x31, 0x63, 0x38, 0x38, 0x33, 0x33, 0x63, 0x61, 0x37, 0x32, 0x33, 0x39, 0x30, 0x64, 0x33, 0x33, 0x61, 0x32, 0x37, 0x64, 0x34, 0x35, 0x62, 0x36, 0x65, 0x37, 0x33, 0x61, 0x62, 0x34, 0x65, 0x65, 0x30, 0x32, 0x66, 0x32, 0x33, 0x62, 0x33, 0x62, 0x30, 0x31, 0x65, 0x65, 0x30, 0x66, 0x39, 0x34, 0x62, 0x34, 0x61, 0x39, 0x38, 0x33, 0x30, 0x34, 0x36, 0x37, 0x31, 0x66, 0x31, 0x61, 0x61, 0x62, 0x34, 0x32, 0x33, 0x66, 0x65, 0x65, 0x63, 0x64, 0x32, 0x38, 0x37, 0x39, 0x66, 0x62, 0x36, 0x31, 0x39, 0x36, 0x35, 0x30, 0x33, 0x62, 0x36, 0x65, 0x62, 0x34, 0x39, 0x39, 0x66, 0x32, 0x30, 0x31, 0x34, 0x34, 0x63, 0x35, 0x36, 0x38, 0x33, 0x36, 0x63, 0x33, 0x63, 0x65, 0x66, 0x37, 0x38, 0x38, 0x64, 0x30, 0x61, 0x65, 0x35, 0x33, 0x30, 0x65, 0x38, 0x61, 0x65, 0x61, 0x63, 0x61, 0x66, 0x39, 0x63, 0x30, 0x31, 0x61, 0x65, 0x34, 0x30, 0x31, 0x37, 0x32, 0x32, 0x39, 0x37, 0x63, 0x35, 0x66, 0x34, 0x36, 0x66, 0x37, 0x30, 0x62, 0x30, 0x38, 0x35, 0x34, 0x31, 0x37, 0x62, 0x62, 0x31, 0x63, 0x34, 0x32, 0x31, 0x37, 0x65, 0x66, 0x36, 0x62, 0x30, 0x66, 0x33, 0x34, 0x30, 0x30, 0x62, 0x34, 0x39, 0x39, 0x34, 0x65, 0x35, 0x37, 0x63, 0x65, 0x66, 0x37, 0x31, 0x31, 0x36, 0x66, 0x65, 0x65, 0x61, 0x63, 0x33, 0x37, 0x63, 0x39, 0x32, 0x39, 0x33, 0x39, 0x32, 0x61, 0x62, 0x36, 0x62, 0x62, 0x39, 0x35, 0x66, 0x66, 0x65, 0x39, 0x32, 0x66, 0x36, 0x34, 0x33, 0x66, 0x36, 0x34, 0x65, 0x63, 0x37, 0x65, 0x30, 0x33, 0x36, 0x61, 0x66, 0x32, 0x36, 0x35, 0x36, 0x66, 0x38, 0x34, 0x37, 0x32, 0x37, 0x63, 0x63, 0x33, 0x30, 0x38, 0x33, 0x35, 0x34, 0x30, 0x39, 0x31, 0x63, 0x31, 0x63, 0x64, 0x37, 0x65, 0x61, 0x66, 0x34, 0x64, 0x66, 0x31, 0x37, 0x32, 0x34, 0x34, 0x62, 0x31, 0x61, 0x30, 0x34, 0x35, 0x31, 0x34, 0x64, 0x34, 0x66, 0x38, 0x65, 0x31, 0x36, 0x32, 0x39, 0x38, 0x38, 0x31, 0x63, 0x38, 0x34, 0x63, 0x62, 0x36, 0x66, 0x35, 0x62, 0x65, 0x31, 0x38, 0x32, 0x62, 0x34, 0x30, 0x62, 0x34, 0x39, 0x38, 0x63, 0x33, 0x66, 0x61, 0x61, 0x35, 0x35, 0x62, 0x32, 0x38, 0x61, 0x37, 0x38, 0x36, 0x34, 0x33, 0x36, 0x39, 0x32, 0x39, 0x37, 0x32, 0x38, 0x64, 0x61, 0x35, 0x32, 0x38, 0x65, 0x36, 0x30, 0x31, 0x35, 0x30, 0x30, 0x33, 0x34, 0x65, 0x31, 0x34, 0x36, 0x36, 0x62, 0x36, 0x30, 0x61, 0x37, 0x65, 0x62, 0x63, 0x66, 0x33, 0x37, 0x39, 0x35, 0x38, 0x34, 0x35, 0x35, 0x65, 0x62, 0x30, 0x39, 0x36, 0x38, 0x36, 0x39, 0x36, 0x35, 0x63, 0x38, 0x31, 0x62, 0x35, 0x38, 0x35, 0x62, 0x64, 0x63, 0x61, 0x61, 0x61, 0x64, 0x63, 0x37, 0x32, 0x35, 0x61, 0x63, 0x65, 0x31, 0x39, 0x31, 0x64, 0x65, 0x64, 0x61, 0x33, 0x62, 0x30, 0x64, 0x30, 0x66, 0x62, 0x33, 0x65, 0x36, 0x33, 0x36, 0x33, 0x66, 0x32, 0x38, 0x62, 0x36, 0x32, 0x36, 0x63, 0x31, 0x34, 0x65, 0x34, 0x35, 0x39, 0x31, 0x38, 0x62, 0x63, 0x33, 0x31, 0x34, 0x36, 0x38, 0x34, 0x36, 0x38, 0x32, 0x62, 0x36, 0x38, 0x63, 0x35, 0x31, 0x66, 0x64, 0x64, 0x31, 0x32, 0x37, 0x32, 0x33, 0x35, 0x63, 0x31, 0x64, 0x66, 0x61, 0x61, 0x30, 0x32, 0x31, 0x64, 0x64, 0x39, 0x36, 0x32, 0x35, 0x63, 0x65, 0x38, 0x34, 0x61, 0x64, 0x33, 0x64, 0x63, 0x33, 0x61, 0x63, 0x62, 0x37, 0x39, 0x37, 0x38, 0x66, 0x35, 0x37, 0x38, 0x32, 0x35, 0x61, 0x36, 0x66, 0x61, 0x61, 0x65, 0x39, 0x65, 0x37, 0x30, 0x34, 0x62, 0x39, 0x61, 0x62, 0x35, 0x31, 0x37, 0x37, 0x32, 0x64, 0x61, 0x36, 0x31, 0x31, 0x39, 0x65, 0x31, 0x38, 0x34, 0x61, 0x65, 0x31, 0x62, 0x63, 0x39, 0x39, 0x65, 0x65, 0x32, 0x39, 0x62, 0x66, 0x61, 0x64, 0x66, 0x38, 0x61, 0x62, 0x63, 0x38, 0x33, 0x61, 0x62, 0x36, 0x38, 0x30, 0x35, 0x34, 0x38, 0x38, 0x65, 0x38, 0x39, 0x63, 0x65, 0x32, 0x32, 0x61, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, 0x63, 0x31, 0x64, 0x39, 0x64, 0x65, 0x66, 0x30, 0x35, 0x37, 0x34, 0x36, 0x32, 0x64, 0x61, 0x33, 0x34, 0x63, 0x65, 0x66, 0x64, 0x38, 0x66, 0x66, 0x39, 0x36, 0x61, 0x62, 0x37, 0x36, 0x37, 0x64, 0x66, 0x62, 0x37, 0x64, 0x32, 0x64, 0x66, 0x33, 0x62, 0x39, 0x64, 0x32, 0x66, 0x31, 0x33, 0x37, 0x66, 0x63, 0x34, 0x30, 0x30, 0x33, 0x33, 0x38, 0x66, 0x65, 0x38, 0x38, 0x61, 0x36, 0x63, 0x31, 0x38, 0x66, 0x38, 0x35, 0x37, 0x37, 0x35, 0x30, 0x37, 0x66, 0x31, 0x31, 0x38, 0x38, 0x64, 0x63, 0x64, 0x35, 0x62, 0x63, 0x39, 0x37, 0x35, 0x66, 0x30, 0x34, 0x31, 0x32, 0x33, 0x39, 0x36, 0x62, 0x31, 0x62, 0x64, 0x35, 0x63, 0x31, 0x31, 0x66, 0x36, 0x66, 0x36, 0x30, 0x36, 0x35, 0x65, 0x30, 0x35, 0x38, 0x61, 0x66, 0x34, 0x35, 0x39, 0x38, 0x33, 0x35, 0x66, 0x66, 0x39, 0x34, 0x32, 0x61, 0x65, 0x34, 0x66, 0x38, 0x30, 0x61, 0x65, 0x34, 0x63, 0x31, 0x31, 0x37, 0x32, 0x33, 0x39, 0x38, 0x32, 0x38, 0x62, 0x39, 0x38, 0x62, 0x33, 0x62, 0x33, 0x34, 0x64, 0x30, 0x39, 0x32, 0x63, 0x63, 0x38, 0x63, 0x64, 0x35, 0x33, 0x61, 0x37, 0x66, 0x37, 0x65, 0x38, 0x30, 0x34, 0x64, 0x32, 0x65, 0x33, 0x33, 0x37, 0x63, 0x39, 0x66, 0x64, 0x38, 0x35, 0x37, 0x32, 0x32, 0x38, 0x65, 0x35, 0x32, 0x63, 0x36, 0x33, 0x37, 0x30, 0x65, 0x65, 0x64, 0x37, 0x36, 0x36, 0x37, 0x32, 0x39, 0x35, 0x35, 0x33, 0x66, 0x64, 0x39, 0x64, 0x63, 0x64, 0x62, 0x36, 0x34, 0x33, 0x61, 0x30, 0x31, 0x32, 0x37, 0x61, 0x65, 0x31, 0x63, 0x66, 0x63, 0x61, 0x38, 0x66, 0x65, 0x38, 0x62, 0x33, 0x38, 0x31, 0x31, 0x33, 0x38, 0x30, 0x62, 0x33, 0x33, 0x32, 0x37, 0x63, 0x33, 0x31, 0x32, 0x38, 0x64, 0x62, 0x34, 0x62, 0x36, 0x36, 0x39, 0x35, 0x61, 0x36, 0x62, 0x34, 0x61, 0x35, 0x37, 0x32, 0x61, 0x66, 0x35, 0x37, 0x63, 0x65, 0x33, 0x65, 0x35, 0x65, 0x39, 0x61, 0x66, 0x31, 0x35, 0x36, 0x66, 0x33, 0x63, 0x33, 0x38, 0x34, 0x62, 0x65, 0x63, 0x61, 0x62, 0x62, 0x35, 0x38, 0x37, 0x31, 0x37, 0x38, 0x34, 0x39, 0x66, 0x34, 0x39, 0x33, 0x61, 0x63, 0x61, 0x30, 0x32, 0x37, 0x62, 0x36, 0x66, 0x36, 0x39, 0x64, 0x36, 0x30, 0x36, 0x32, 0x63, 0x63, 0x64, 0x62, 0x33, 0x61, 0x32, 0x66, 0x62, 0x38, 0x32, 0x33, 0x30, 0x37, 0x37, 0x30, 0x62, 0x32, 0x32, 0x39, 0x62, 0x30, 0x61, 0x64, 0x37, 0x30, 0x39, 0x38, 0x32, 0x37, 0x33, 0x35, 0x32, 0x31, 0x36, 0x37, 0x35, 0x36, 0x35, 0x34, 0x64, 0x63, 0x37, 0x37, 0x33, 0x66, 0x66, 0x39, 0x30, 0x36, 0x34, 0x36, 0x33, 0x65, 0x31, 0x66, 0x33, 0x61, 0x64, 0x34, 0x39, 0x62, 0x63, 0x62, 0x36, 0x61, 0x34, 0x31, 0x38, 0x66, 0x34, 0x64, 0x35, 0x66, 0x61, 0x63, 0x35, 0x39, 0x33, 0x37, 0x37, 0x66, 0x63, 0x62, 0x38, 0x30, 0x34, 0x65, 0x33, 0x39, 0x36, 0x31, 0x34, 0x37, 0x35, 0x62, 0x33, 0x38, 0x61, 0x32, 0x35, 0x65, 0x33, 0x37, 0x36, 0x33, 0x63, 0x36, 0x39, 0x39, 0x65, 0x62, 0x34, 0x30, 0x66, 0x33, 0x33, 0x61, 0x65, 0x65, 0x30, 0x32, 0x31, 0x65, 0x34, 0x31, 0x64, 0x34, 0x34, 0x33, 0x66, 0x31, 0x30, 0x31, 0x37, 0x32, 0x35, 0x36, 0x63, 0x62, 0x38, 0x35, 0x31, 0x63, 0x61, 0x36, 0x31, 0x62, 0x31, 0x33, 0x37, 0x30, 0x32, 0x33, 0x39, 0x66, 0x34, 0x62, 0x30, 0x33, 0x61, 0x33, 0x34, 0x63, 0x61, 0x34, 0x66, 0x33, 0x37, 0x63, 0x37, 0x34, 0x66, 0x36, 0x66, 0x36, 0x63, 0x32, 0x32, 0x35, 0x31, 0x32, 0x64, 0x65, 0x62, 0x65, 0x66, 0x31, 0x62, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x61, 0x64, 0x37, 0x32, 0x66, 0x38, 0x61, 0x66, 0x65, 0x35, 0x65, 0x31, 0x35, 0x62, 0x34, 0x33, 0x36, 0x38, 0x35, 0x62, 0x31, 0x32, 0x38, 0x64, 0x33, 0x35, 0x37, 0x32, 0x61, 0x37, 0x32, 0x61, 0x34, 0x66, 0x63, 0x33, 0x33, 0x64, 0x33, 0x32, 0x61, 0x65, 0x64, 0x61, 0x36, 0x30, 0x38, 0x33, 0x66, 0x32, 0x36, 0x35, 0x33, 0x63, 0x37, 0x39, 0x32, 0x39, 0x64, 0x64, 0x34, 0x39, 0x62, 0x35, 0x62, 0x35, 0x32, 0x63, 0x39, 0x61, 0x36, 0x38, 0x36, 0x63, 0x30, 0x64, 0x39, 0x38, 0x31, 0x63, 0x64, 0x37, 0x61, 0x64, 0x35, 0x30, 0x31, 0x66, 0x31, 0x33, 0x37, 0x63, 0x62, 0x36, 0x36, 0x61, 0x66, 0x30, 0x34, 0x62, 0x64, 0x30, 0x35, 0x31, 0x38, 0x38, 0x64, 0x39, 0x33, 0x37, 0x63, 0x34, 0x64, 0x36, 0x66, 0x63, 0x30, 0x34, 0x34, 0x34, 0x65, 0x31, 0x31, 0x39, 0x61, 0x35, 0x30, 0x66, 0x30, 0x37, 0x37, 0x32, 0x31, 0x61, 0x32, 0x39, 0x37, 0x64, 0x64, 0x39, 0x65, 0x62, 0x31, 0x39, 0x37, 0x33, 0x64, 0x35, 0x33, 0x30, 0x66, 0x39, 0x62, 0x33, 0x38, 0x37, 0x31, 0x35, 0x35, 0x35, 0x35, 0x64, 0x39, 0x31, 0x63, 0x31, 0x65, 0x65, 0x63, 0x36, 0x32, 0x32, 0x35, 0x63, 0x36, 0x34, 0x62, 0x31, 0x66, 0x39, 0x30, 0x39, 0x33, 0x63, 0x39, 0x30, 0x33, 0x61, 0x30, 0x62, 0x61, 0x32, 0x62, 0x39, 0x37, 0x32, 0x33, 0x62, 0x36, 0x34, 0x34, 0x63, 0x65, 0x33, 0x64, 0x35, 0x35, 0x31, 0x61, 0x36, 0x66, 0x66, 0x35, 0x66, 0x39, 0x33, 0x32, 0x31, 0x62, 0x61, 0x31, 0x39, 0x39, 0x62, 0x33, 0x61, 0x61, 0x65, 0x31, 0x66, 0x61, 0x37, 0x36, 0x64, 0x34, 0x37, 0x38, 0x30, 0x32, 0x34, 0x33, 0x30, 0x38, 0x64, 0x64, 0x64, 0x38, 0x66, 0x31, 0x33, 0x63, 0x38, 0x65, 0x31, 0x37, 0x37, 0x62, 0x64, 0x37, 0x32, 0x35, 0x65, 0x66, 0x63, 0x65, 0x35, 0x32, 0x66, 0x65, 0x39, 0x37, 0x64, 0x63, 0x35, 0x36, 0x37, 0x35, 0x63, 0x37, 0x62, 0x36, 0x39, 0x31, 0x36, 0x65, 0x38, 0x35, 0x38, 0x39, 0x64, 0x35, 0x65, 0x34, 0x65, 0x63, 0x33, 0x33, 0x32, 0x38, 0x39, 0x33, 0x65, 0x35, 0x31, 0x38, 0x32, 0x61, 0x35, 0x33, 0x39, 0x30, 0x39, 0x39, 0x63, 0x39, 0x34, 0x30, 0x31, 0x62, 0x37, 0x65, 0x62, 0x37, 0x32, 0x34, 0x65, 0x61, 0x37, 0x37, 0x63, 0x38, 0x32, 0x33, 0x65, 0x39, 0x32, 0x34, 0x36, 0x35, 0x64, 0x65, 0x34, 0x36, 0x64, 0x38, 0x35, 0x30, 0x36, 0x63, 0x34, 0x37, 0x65, 0x62, 0x61, 0x30, 0x38, 0x35, 0x35, 0x62, 0x64, 0x32, 0x30, 0x66, 0x34, 0x34, 0x62, 0x30, 0x34, 0x38, 0x31, 0x63, 0x34, 0x65, 0x35, 0x61, 0x61, 0x63, 0x34, 0x64, 0x66, 0x66, 0x65, 0x61, 0x61, 0x39, 0x65, 0x37, 0x32, 0x63, 0x32, 0x33, 0x36, 0x62, 0x39, 0x30, 0x32, 0x31, 0x61, 0x34, 0x66, 0x33, 0x65, 0x34, 0x30, 0x64, 0x38, 0x37, 0x64, 0x37, 0x34, 0x35, 0x38, 0x62, 0x65, 0x33, 0x37, 0x32, 0x30, 0x30, 0x62, 0x39, 0x64, 0x35, 0x33, 0x66, 0x66, 0x66, 0x34, 0x31, 0x31, 0x34, 0x36, 0x34, 0x63, 0x33, 0x63, 0x61, 0x38, 0x33, 0x36, 0x66, 0x65, 0x32, 0x38, 0x65, 0x32, 0x32, 0x38, 0x63, 0x63, 0x31, 0x62, 0x61, 0x37, 0x37, 0x39, 0x66, 0x31, 0x33, 0x38, 0x39, 0x66, 0x32, 0x65, 0x37, 0x31, 0x30, 0x35, 0x34, 0x32, 0x32, 0x37, 0x62, 0x66, 0x62, 0x66, 0x64, 0x62, 0x34, 0x33, 0x62, 0x36, 0x30, 0x39, 0x65, 0x30, 0x39, 0x37, 0x31, 0x35, 0x33, 0x61, 0x62, 0x39, 0x65, 0x36, 0x32, 0x36, 0x31, 0x34, 0x36, 0x38, 0x34, 0x30, 0x36, 0x62, 0x33, 0x34, 0x63, 0x37, 0x39, 0x36, 0x38, 0x38, 0x37, 0x32, 0x36, 0x61, 0x34, 0x61, 0x61, 0x61, 0x39, 0x64, 0x37, 0x36, 0x38, 0x64, 0x64, 0x35, 0x39, 0x30, 0x38, 0x66, 0x37, 0x36, 0x32, 0x37, 0x39, 0x32, 0x63, 0x38, 0x33, 0x33, 0x64, 0x39, 0x35, 0x64, 0x38, 0x65, 0x31, 0x39, 0x34, 0x62, 0x32, 0x66, 0x61, 0x64, 0x37, 0x35, 0x36, 0x61, 0x65, 0x65, 0x35, 0x63, 0x33, 0x37, 0x64, 0x65, 0x35, 0x66, 0x34, 0x65, 0x32, 0x65, 0x64, 0x34, 0x34, 0x31, 0x37, 0x30, 0x64, 0x31, 0x66, 0x38, 0x30, 0x30, 0x38, 0x30, 0x61, 0x35, 0x36, 0x32, 0x65, 0x37, 0x61, 0x31, 0x30, 0x37, 0x66, 0x30, 0x66, 0x66, 0x37, 0x34, 0x31, 0x37, 0x30, 0x37, 0x65, 0x66, 0x64, 0x63, 0x64, 0x63, 0x66, 0x63, 0x31, 0x31, 0x36, 0x66, 0x35, 0x64, 0x36, 0x32, 0x33, 0x61, 0x61, 0x63, 0x64, 0x33, 0x31, 0x34, 0x62, 0x39, 0x31, 0x34, 0x33, 0x38, 0x63, 0x61, 0x37, 0x32, 0x66, 0x34, 0x36, 0x61, 0x34, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x32, 0x37, 0x65, 0x65, 0x66, 0x66, 0x38, 0x35, 0x35, 0x64, 0x36, 0x35, 0x33, 0x31, 0x63, 0x38, 0x62, 0x64, 0x33, 0x33, 0x63, 0x61, 0x66, 0x62, 0x65, 0x37, 0x34, 0x33, 0x31, 0x37, 0x37, 0x38, 0x62, 0x37, 0x33, 0x31, 0x34, 0x35, 0x31, 0x39, 0x61, 0x33, 0x30, 0x37, 0x31, 0x32, 0x39, 0x30, 0x31, 0x65, 0x30, 0x30, 0x32, 0x33, 0x62, 0x32, 0x34, 0x61, 0x61, 0x39, 0x39, 0x32, 0x66, 0x64, 0x64, 0x30, 0x34, 0x64, 0x35, 0x33, 0x37, 0x63, 0x62, 0x30, 0x64, 0x31, 0x30, 0x30, 0x37, 0x36, 0x31, 0x61, 0x30, 0x39, 0x39, 0x37, 0x37, 0x62, 0x33, 0x37, 0x34, 0x32, 0x30, 0x39, 0x64, 0x37, 0x38, 0x65, 0x65, 0x34, 0x61, 0x37, 0x31, 0x36, 0x37, 0x66, 0x38, 0x66, 0x33, 0x36, 0x63, 0x30, 0x63, 0x63, 0x64, 0x37, 0x32, 0x38, 0x32, 0x66, 0x63, 0x39, 0x36, 0x33, 0x31, 0x37, 0x66, 0x39, 0x61, 0x31, 0x61, 0x65, 0x30, 0x39, 0x39, 0x39, 0x61, 0x37, 0x31, 0x62, 0x30, 0x32, 0x39, 0x31, 0x62, 0x34, 0x66, 0x62, 0x33, 0x63, 0x64, 0x39, 0x62, 0x64, 0x35, 0x66, 0x36, 0x65, 0x64, 0x36, 0x65, 0x37, 0x38, 0x64, 0x32, 0x35, 0x66, 0x33, 0x35, 0x33, 0x32, 0x33, 0x39, 0x34, 0x63, 0x64, 0x31, 0x36, 0x37, 0x31, 0x33, 0x35, 0x37, 0x33, 0x32, 0x62, 0x32, 0x34, 0x31, 0x35, 0x37, 0x64, 0x30, 0x61, 0x63, 0x31, 0x66, 0x63, 0x33, 0x33, 0x35, 0x37, 0x36, 0x61, 0x64, 0x31, 0x38, 0x32, 0x33, 0x61, 0x65, 0x31, 0x64, 0x31, 0x39, 0x34, 0x61, 0x32, 0x30, 0x34, 0x64, 0x65, 0x64, 0x33, 0x34, 0x64, 0x66, 0x65, 0x34, 0x36, 0x39, 0x66, 0x66, 0x65, 0x62, 0x65, 0x37, 0x64, 0x63, 0x39, 0x39, 0x30, 0x62, 0x37, 0x32, 0x34, 0x38, 0x32, 0x65, 0x39, 0x62, 0x65, 0x37, 0x33, 0x35, 0x31, 0x37, 0x31, 0x37, 0x35, 0x39, 0x32, 0x66, 0x65, 0x32, 0x66, 0x32, 0x62, 0x65, 0x63, 0x35, 0x65, 0x63, 0x64, 0x63, 0x39, 0x31, 0x31, 0x32, 0x39, 0x39, 0x32, 0x37, 0x62, 0x32, 0x32, 0x31, 0x61, 0x64, 0x32, 0x34, 0x30, 0x31, 0x31, 0x63, 0x36, 0x64, 0x31, 0x31, 0x62, 0x66, 0x33, 0x61, 0x33, 0x35, 0x66, 0x33, 0x37, 0x32, 0x37, 0x66, 0x39, 0x33, 0x34, 0x33, 0x37, 0x32, 0x36, 0x31, 0x30, 0x31, 0x38, 0x34, 0x31, 0x61, 0x31, 0x38, 0x39, 0x37, 0x61, 0x65, 0x63, 0x38, 0x32, 0x64, 0x33, 0x63, 0x64, 0x33, 0x62, 0x30, 0x38, 0x63, 0x62, 0x39, 0x35, 0x66, 0x66, 0x37, 0x34, 0x31, 0x31, 0x35, 0x62, 0x32, 0x30, 0x32, 0x62, 0x30, 0x33, 0x36, 0x33, 0x37, 0x33, 0x61, 0x37, 0x32, 0x34, 0x31, 0x36, 0x62, 0x37, 0x32, 0x63, 0x31, 0x36, 0x65, 0x34, 0x66, 0x66, 0x64, 0x62, 0x36, 0x31, 0x32, 0x61, 0x36, 0x35, 0x39, 0x63, 0x65, 0x61, 0x66, 0x30, 0x30, 0x63, 0x34, 0x37, 0x37, 0x30, 0x37, 0x38, 0x62, 0x65, 0x39, 0x63, 0x62, 0x34, 0x61, 0x37, 0x34, 0x34, 0x62, 0x34, 0x35, 0x32, 0x33, 0x30, 0x62, 0x38, 0x65, 0x38, 0x32, 0x36, 0x39, 0x64, 0x32, 0x33, 0x63, 0x32, 0x32, 0x37, 0x36, 0x65, 0x66, 0x34, 0x38, 0x38, 0x38, 0x32, 0x35, 0x66, 0x65, 0x30, 0x34, 0x39, 0x35, 0x34, 0x64, 0x38, 0x35, 0x66, 0x65, 0x63, 0x65, 0x65, 0x32, 0x39, 0x64, 0x37, 0x32, 0x65, 0x64, 0x37, 0x31, 0x37, 0x34, 0x66, 0x38, 0x33, 0x36, 0x39, 0x62, 0x37, 0x63, 0x37, 0x61, 0x39, 0x32, 0x63, 0x64, 0x30, 0x61, 0x31, 0x31, 0x34, 0x36, 0x62, 0x38, 0x62, 0x30, 0x31, 0x62, 0x32, 0x39, 0x32, 0x61, 0x61, 0x34, 0x34, 0x35, 0x35, 0x36, 0x64, 0x33, 0x66, 0x34, 0x66, 0x30, 0x65, 0x62, 0x63, 0x64, 0x37, 0x63, 0x35, 0x35, 0x31, 0x64, 0x65, 0x32, 0x31, 0x34, 0x36, 0x32, 0x63, 0x33, 0x37, 0x65, 0x32, 0x66, 0x62, 0x32, 0x34, 0x38, 0x61, 0x35, 0x39, 0x34, 0x34, 0x66, 0x65, 0x65, 0x33, 0x62, 0x37, 0x33, 0x30, 0x62, 0x34, 0x62, 0x61, 0x64, 0x37, 0x63, 0x39, 0x38, 0x61, 0x30, 0x39, 0x35, 0x63, 0x36, 0x37, 0x32, 0x36, 0x62, 0x30, 0x35, 0x33, 0x63, 0x35, 0x35, 0x61, 0x35, 0x35, 0x39, 0x33, 0x39, 0x65, 0x30, 0x38, 0x33, 0x33, 0x38, 0x30, 0x32, 0x35, 0x63, 0x66, 0x62, 0x34, 0x31, 0x64, 0x32, 0x33, 0x39, 0x37, 0x63, 0x39, 0x31, 0x39, 0x61, 0x61, 0x39, 0x63, 0x61, 0x32, 0x34, 0x65, 0x39, 0x39, 0x61, 0x61, 0x64, 0x37, 0x65, 0x32, 0x36, 0x32, 0x65, 0x30, 0x34, 0x66, 0x33, 0x30, 0x37, 0x37, 0x32, 0x30, 0x63, 0x61, 0x30, 0x37, 0x66, 0x66, 0x31, 0x32, 0x31, 0x36, 0x61, 0x64, 0x66, 0x65, 0x39, 0x37, 0x36, 0x38, 0x63, 0x39, 0x35, 0x65, 0x61, 0x32, 0x66, 0x33, 0x31, 0x32, 0x36, 0x38, 0x62, 0x31, 0x35, 0x65, 0x35, 0x35, 0x34, 0x39, 0x36, 0x38, 0x65, 0x30, 0x64, 0x65, 0x37, 0x36, 0x39, 0x38, 0x64, 0x39, 0x32, 0x30, 0x65, 0x36, 0x62, 0x33, 0x63, 0x38, 0x38, 0x35, 0x61, 0x37, 0x32, 0x38, 0x39, 0x64, 0x66, 0x33, 0x63, 0x30, 0x36, 0x30, 0x35, 0x30, 0x31, 0x64, 0x31, 0x34, 0x38, 0x32, 0x32, 0x65, 0x62, 0x61, 0x39, 0x36, 0x33, 0x64, 0x62, 0x32, 0x36, 0x31, 0x62, 0x37, 0x61, 0x63, 0x39, 0x30, 0x62, 0x63, 0x30, 0x34, 0x62, 0x31, 0x31, 0x35, 0x33, 0x30, 0x36, 0x39, 0x35, 0x38, 0x30, 0x39, 0x36, 0x33, 0x61, 0x63, 0x62, 0x30, 0x61, 0x37, 0x65, 0x61, 0x61, 0x33, 0x35, 0x30, 0x32, 0x33, 0x62, 0x63, 0x37, 0x31, 0x30, 0x64, 0x35, 0x63, 0x66, 0x34, 0x62, 0x35, 0x37, 0x39, 0x35, 0x66, 0x36, 0x37, 0x33, 0x35, 0x66, 0x61, 0x30, 0x63, 0x38, 0x66, 0x65, 0x37, 0x62, 0x35, 0x62, 0x38, 0x63, 0x38, 0x32, 0x61, 0x39, 0x62, 0x32, 0x35, 0x62, 0x39, 0x39, 0x30, 0x32, 0x62, 0x32, 0x62, 0x65, 0x61, 0x65, 0x37, 0x34, 0x39, 0x63, 0x33, 0x30, 0x35, 0x61, 0x33, 0x66, 0x37, 0x33, 0x35, 0x30, 0x61, 0x38, 0x35, 0x64, 0x33, 0x39, 0x31, 0x33, 0x64, 0x35, 0x30, 0x63, 0x66, 0x32, 0x37, 0x37, 0x65, 0x33, 0x61, 0x30, 0x63, 0x62, 0x32, 0x62, 0x34, 0x63, 0x39, 0x37, 0x61, 0x62, 0x65, 0x37, 0x66, 0x36, 0x62, 0x37, 0x35, 0x31, 0x63, 0x37, 0x61, 0x35, 0x34, 0x31, 0x65, 0x32, 0x30, 0x61, 0x65, 0x38, 0x62, 0x39, 0x35, 0x63, 0x31, 0x31, 0x32, 0x66, 0x37, 0x32, 0x61, 0x35, 0x37, 0x61, 0x61, 0x32, 0x61, 0x37, 0x39, 0x33, 0x64, 0x39, 0x36, 0x62, 0x37, 0x33, 0x34, 0x34, 0x66, 0x63, 0x66, 0x61, 0x38, 0x66, 0x32, 0x61, 0x65, 0x37, 0x64, 0x63, 0x61, 0x33, 0x63, 0x37, 0x37, 0x62, 0x30, 0x30, 0x30, 0x32, 0x34, 0x38, 0x39, 0x62, 0x32, 0x62, 0x63, 0x39, 0x39, 0x38, 0x36, 0x62, 0x30, 0x38, 0x63, 0x39, 0x33, 0x62, 0x66, 0x31, 0x33, 0x66, 0x37, 0x32, 0x66, 0x62, 0x63, 0x63, 0x64, 0x36, 0x35, 0x39, 0x30, 0x35, 0x36, 0x61, 0x30, 0x37, 0x38, 0x64, 0x61, 0x35, 0x31, 0x66, 0x61, 0x64, 0x32, 0x62, 0x33, 0x65, 0x39, 0x33, 0x37, 0x34, 0x66, 0x65, 0x31, 0x66, 0x62, 0x66, 0x62, 0x35, 0x66, 0x61, 0x32, 0x63, 0x31, 0x62, 0x35, 0x64, 0x39, 0x32, 0x39, 0x65, 0x38, 0x30, 0x36, 0x66, 0x66, 0x31, 0x39, 0x63, 0x32, 0x33, 0x66, 0x66, 0x33, 0x30, 0x61, 0x33, 0x34, 0x63, 0x31, 0x37, 0x66, 0x62, 0x34, 0x32, 0x66, 0x65, 0x32, 0x63, 0x39, 0x37, 0x35, 0x38, 0x62, 0x30, 0x62, 0x36, 0x62, 0x39, 0x61, 0x64, 0x31, 0x31, 0x62, 0x36, 0x33, 0x63, 0x37, 0x30, 0x61, 0x39, 0x30, 0x36, 0x33, 0x35, 0x37, 0x62, 0x39, 0x35, 0x34, 0x35, 0x36, 0x38, 0x65, 0x31, 0x66, 0x36, 0x37, 0x61, 0x38, 0x36, 0x31, 0x38, 0x30, 0x63, 0x38, 0x62, 0x37, 0x32, 0x37, 0x61, 0x36, 0x64, 0x36, 0x31, 0x35, 0x33, 0x61, 0x61, 0x35, 0x34, 0x34, 0x65, 0x31, 0x66, 0x38, 0x38, 0x32, 0x35, 0x66, 0x36, 0x37, 0x64, 0x38, 0x64, 0x33, 0x65, 0x33, 0x34, 0x61, 0x35, 0x62, 0x32, 0x64, 0x65, 0x34, 0x38, 0x38, 0x31, 0x62, 0x62, 0x38, 0x66, 0x61, 0x36, 0x31, 0x32, 0x30, 0x64, 0x33, 0x38, 0x31, 0x37, 0x65, 0x61, 0x62, 0x62, 0x66, 0x38, 0x64, 0x64, 0x37, 0x32, 0x30, 0x30, 0x31, 0x32, 0x64, 0x38, 0x32, 0x39, 0x37, 0x35, 0x66, 0x33, 0x33, 0x34, 0x33, 0x62, 0x62, 0x32, 0x32, 0x31, 0x34, 0x63, 0x31, 0x33, 0x38, 0x62, 0x65, 0x62, 0x39, 0x31, 0x32, 0x62, 0x61, 0x38, 0x63, 0x38, 0x32, 0x33, 0x62, 0x39, 0x34, 0x35, 0x65, 0x38, 0x39, 0x62, 0x38, 0x37, 0x63, 0x33, 0x37, 0x37, 0x37, 0x66, 0x33, 0x30, 0x30, 0x65, 0x61, 0x34, 0x30, 0x31, 0x37, 0x32, 0x62, 0x32, 0x66, 0x35, 0x63, 0x36, 0x65, 0x39, 0x32, 0x64, 0x31, 0x66, 0x30, 0x38, 0x34, 0x65, 0x34, 0x38, 0x35, 0x66, 0x64, 0x37, 0x33, 0x31, 0x30, 0x34, 0x30, 0x38, 0x61, 0x37, 0x64, 0x64, 0x61, 0x63, 0x31, 0x31, 0x35, 0x32, 0x65, 0x31, 0x61, 0x65, 0x37, 0x61, 0x32, 0x61, 0x31, 0x38, 0x34, 0x32, 0x31, 0x32, 0x31, 0x64, 0x62, 0x36, 0x35, 0x64, 0x66, 0x65, 0x38, 0x66, 0x37, 0x32, 0x30, 0x35, 0x66, 0x35, 0x62, 0x63, 0x33, 0x34, 0x36, 0x61, 0x33, 0x35, 0x64, 0x33, 0x66, 0x38, 0x66, 0x65, 0x62, 0x31, 0x66, 0x31, 0x32, 0x62, 0x66, 0x36, 0x33, 0x37, 0x37, 0x33, 0x34, 0x31, 0x37, 0x34, 0x37, 0x39, 0x66, 0x38, 0x64, 0x37, 0x37, 0x62, 0x39, 0x31, 0x62, 0x35, 0x64, 0x30, 0x38, 0x63, 0x61, 0x33, 0x33, 0x63, 0x35, 0x66, 0x63, 0x34, 0x34, 0x38, 0x37, 0x32, 0x36, 0x61, 0x39, 0x65, 0x38, 0x37, 0x34, 0x61, 0x31, 0x38, 0x61, 0x63, 0x61, 0x30, 0x31, 0x33, 0x38, 0x34, 0x34, 0x36, 0x38, 0x37, 0x38, 0x38, 0x64, 0x31, 0x63, 0x37, 0x36, 0x61, 0x33, 0x37, 0x35, 0x39, 0x36, 0x30, 0x37, 0x30, 0x37, 0x65, 0x32, 0x37, 0x61, 0x39, 0x36, 0x66, 0x34, 0x31, 0x34, 0x64, 0x35, 0x36, 0x65, 0x37, 0x35, 0x64, 0x33, 0x30, 0x31, 0x36, 0x30, 0x39, 0x63, 0x31, 0x37, 0x32, 0x63, 0x66, 0x37, 0x33, 0x66, 0x38, 0x36, 0x37, 0x34, 0x62, 0x34, 0x34, 0x66, 0x63, 0x31, 0x39, 0x38, 0x38, 0x39, 0x64, 0x30, 0x32, 0x37, 0x36, 0x34, 0x37, 0x32, 0x37, 0x62, 0x33, 0x66, 0x30, 0x30, 0x62, 0x37, 0x32, 0x62, 0x31, 0x39, 0x63, 0x66, 0x62, 0x30, 0x31, 0x31, 0x38, 0x32, 0x31, 0x39, 0x38, 0x35, 0x62, 0x66, 0x35, 0x62, 0x36, 0x63, 0x34, 0x30, 0x34, 0x61, 0x38, 0x37, 0x32, 0x33, 0x38, 0x62, 0x36, 0x62, 0x34, 0x66, 0x35, 0x62, 0x35, 0x61, 0x65, 0x65, 0x63, 0x30, 0x33, 0x31, 0x61, 0x66, 0x30, 0x34, 0x33, 0x65, 0x30, 0x61, 0x64, 0x32, 0x34, 0x31, 0x62, 0x37, 0x35, 0x66, 0x32, 0x32, 0x31, 0x37, 0x64, 0x33, 0x39, 0x65, 0x33, 0x38, 0x38, 0x63, 0x38, 0x31, 0x39, 0x34, 0x63, 0x38, 0x31, 0x65, 0x31, 0x38, 0x36, 0x35, 0x37, 0x30, 0x37, 0x62, 0x31, 0x36, 0x36, 0x65, 0x38, 0x64, 0x33, 0x33, 0x30, 0x35, 0x64, 0x64, 0x61, 0x61, 0x62, 0x61, 0x35, 0x32, 0x32, 0x39, 0x38, 0x34, 0x63, 0x32, 0x66, 0x31, 0x36, 0x61, 0x64, 0x63, 0x39, 0x37, 0x61, 0x30, 0x65, 0x35, 0x62, 0x30, 0x33, 0x38, 0x30, 0x33, 0x37, 0x34, 0x38, 0x66, 0x34, 0x34, 0x30, 0x37, 0x63, 0x36, 0x64, 0x34, 0x34, 0x35, 0x38, 0x64, 0x33, 0x65, 0x66, 0x34, 0x64, 0x34, 0x33, 0x32, 0x34, 0x66, 0x65, 0x32, 0x34, 0x64, 0x66, 0x32, 0x61, 0x62, 0x34, 0x39, 0x37, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, 0x65, 0x30, 0x39, 0x35, 0x30, 0x63, 0x36, 0x64, 0x39, 0x64, 0x31, 0x35, 0x62, 0x63, 0x39, 0x65, 0x36, 0x32, 0x34, 0x34, 0x65, 0x36, 0x31, 0x31, 0x34, 0x62, 0x37, 0x31, 0x36, 0x34, 0x64, 0x39, 0x66, 0x39, 0x37, 0x38, 0x35, 0x65, 0x65, 0x37, 0x30, 0x30, 0x33, 0x31, 0x37, 0x32, 0x62, 0x33, 0x38, 0x31, 0x32, 0x38, 0x34, 0x61, 0x39, 0x61, 0x30, 0x34, 0x37, 0x65, 0x37, 0x38, 0x66, 0x66, 0x34, 0x66, 0x32, 0x34, 0x37, 0x30, 0x30, 0x61, 0x39, 0x36, 0x63, 0x62, 0x63, 0x32, 0x30, 0x34, 0x63, 0x34, 0x66, 0x64, 0x32, 0x35, 0x35, 0x31, 0x64, 0x62, 0x33, 0x30, 0x35, 0x33, 0x65, 0x33, 0x39, 0x65, 0x64, 0x39, 0x62, 0x34, 0x30, 0x61, 0x65, 0x35, 0x66, 0x37, 0x37, 0x32, 0x31, 0x39, 0x34, 0x32, 0x64, 0x63, 0x61, 0x39, 0x65, 0x36, 0x39, 0x64, 0x61, 0x33, 0x31, 0x65, 0x65, 0x37, 0x62, 0x35, 0x32, 0x35, 0x30, 0x31, 0x30, 0x66, 0x31, 0x62, 0x30, 0x35, 0x65, 0x35, 0x37, 0x34, 0x66, 0x61, 0x32, 0x62, 0x64, 0x30, 0x61, 0x63, 0x63, 0x63, 0x34, 0x39, 0x63, 0x33, 0x33, 0x32, 0x66, 0x65, 0x66, 0x38, 0x35, 0x63, 0x34, 0x61, 0x36, 0x32, 0x62, 0x39, 0x33, 0x34, 0x63, 0x32, 0x33, 0x62, 0x65, 0x34, 0x33, 0x64, 0x63, 0x35, 0x64, 0x35, 0x37, 0x64, 0x37, 0x36, 0x31, 0x36, 0x64, 0x33, 0x31, 0x35, 0x62, 0x38, 0x38, 0x37, 0x32, 0x66, 0x61, 0x32, 0x35, 0x63, 0x35, 0x36, 0x35, 0x62, 0x34, 0x32, 0x64, 0x61, 0x38, 0x61, 0x61, 0x63, 0x38, 0x34, 0x34, 0x31, 0x39, 0x66, 0x38, 0x39, 0x64, 0x38, 0x39, 0x31, 0x34, 0x30, 0x39, 0x39, 0x62, 0x63, 0x37, 0x32, 0x31, 0x65, 0x38, 0x61, 0x61, 0x36, 0x37, 0x66, 0x61, 0x39, 0x32, 0x32, 0x35, 0x37, 0x30, 0x63, 0x38, 0x65, 0x62, 0x62, 0x63, 0x66, 0x33, 0x32, 0x30, 0x36, 0x32, 0x64, 0x62, 0x31, 0x31, 0x65, 0x32, 0x35, 0x36, 0x34, 0x30, 0x32, 0x34, 0x37, 0x30, 0x37, 0x64, 0x63, 0x66, 0x66, 0x35, 0x66, 0x39, 0x66, 0x31, 0x63, 0x34, 0x34, 0x32, 0x66, 0x37, 0x66, 0x34, 0x30, 0x36, 0x32, 0x37, 0x32, 0x39, 0x65, 0x35, 0x61, 0x32, 0x31, 0x35, 0x34, 0x64, 0x31, 0x39, 0x30, 0x64, 0x39, 0x38, 0x62, 0x66, 0x33, 0x30, 0x65, 0x36, 0x30, 0x63, 0x39, 0x37, 0x31, 0x36, 0x39, 0x30, 0x35, 0x64, 0x61, 0x33, 0x63, 0x36, 0x63, 0x64, 0x35, 0x32, 0x36, 0x62, 0x34, 0x34, 0x64, 0x38, 0x34, 0x32, 0x34, 0x65, 0x31, 0x37, 0x65, 0x32, 0x36, 0x62, 0x32, 0x30, 0x38, 0x34, 0x33, 0x37, 0x30, 0x34, 0x61, 0x38, 0x62, 0x38, 0x37, 0x35, 0x37, 0x31, 0x33, 0x30, 0x66, 0x31, 0x38, 0x63, 0x38, 0x39, 0x66, 0x35, 0x33, 0x33, 0x31, 0x31, 0x38, 0x61, 0x34, 0x38, 0x39, 0x34, 0x66, 0x30, 0x61, 0x64, 0x32, 0x64, 0x66, 0x30, 0x39, 0x63, 0x35, 0x62, 0x64, 0x35, 0x66, 0x38, 0x66, 0x39, 0x66, 0x36, 0x39, 0x31, 0x33, 0x61, 0x35, 0x65, 0x36, 0x37, 0x64, 0x32, 0x62, 0x32, 0x65, 0x66, 0x32, 0x31, 0x35, 0x35, 0x37, 0x36, 0x64, 0x63, 0x33, 0x32, 0x32, 0x32, 0x37, 0x36, 0x31, 0x38, 0x31, 0x33, 0x36, 0x65, 0x36, 0x38, 0x30, 0x63, 0x31, 0x30, 0x38, 0x38, 0x63, 0x35, 0x66, 0x31, 0x34, 0x63, 0x66, 0x66, 0x35, 0x63, 0x62, 0x63, 0x37, 0x31, 0x37, 0x61, 0x39, 0x36, 0x33, 0x66, 0x63, 0x33, 0x38, 0x37, 0x64, 0x38, 0x62, 0x62, 0x31, 0x39, 0x65, 0x30, 0x31, 0x65, 0x37, 0x66, 0x64, 0x37, 0x32, 0x35, 0x36, 0x64, 0x30, 0x36, 0x39, 0x35, 0x39, 0x39, 0x35, 0x63, 0x61, 0x35, 0x34, 0x33, 0x36, 0x33, 0x33, 0x32, 0x38, 0x31, 0x39, 0x34, 0x61, 0x35, 0x66, 0x31, 0x36, 0x35, 0x30, 0x66, 0x61, 0x31, 0x33, 0x62, 0x35, 0x39, 0x34, 0x65, 0x63, 0x65, 0x36, 0x39, 0x61, 0x31, 0x33, 0x33, 0x66, 0x61, 0x35, 0x34, 0x35, 0x62, 0x64, 0x61, 0x66, 0x63, 0x32, 0x36, 0x66, 0x39, 0x33, 0x37, 0x32, 0x35, 0x61, 0x38, 0x37, 0x63, 0x63, 0x66, 0x32, 0x66, 0x36, 0x30, 0x30, 0x37, 0x32, 0x61, 0x38, 0x31, 0x33, 0x35, 0x62, 0x39, 0x34, 0x66, 0x35, 0x30, 0x62, 0x64, 0x64, 0x36, 0x62, 0x66, 0x35, 0x32, 0x35, 0x62, 0x32, 0x65, 0x35, 0x38, 0x34, 0x66, 0x32, 0x39, 0x32, 0x33, 0x62, 0x38, 0x65, 0x65, 0x38, 0x63, 0x32, 0x62, 0x35, 0x38, 0x33, 0x32, 0x38, 0x36, 0x64, 0x39, 0x39, 0x32, 0x38, 0x31, 0x31, 0x35, 0x65, 0x39, 0x31, 0x65, 0x30, 0x62, 0x62, 0x63, 0x30, 0x39, 0x37, 0x65, 0x35, 0x63, 0x31, 0x35, 0x38, 0x35, 0x33, 0x65, 0x33, 0x39, 0x66, 0x31, 0x62, 0x30, 0x37, 0x61, 0x35, 0x37, 0x30, 0x39, 0x64, 0x62, 0x38, 0x64, 0x36, 0x37, 0x65, 0x31, 0x39, 0x64, 0x37, 0x65, 0x62, 0x65, 0x38, 0x36, 0x66, 0x65, 0x62, 0x37, 0x34, 0x66, 0x64, 0x61, 0x62, 0x63, 0x63, 0x36, 0x35, 0x66, 0x30, 0x61, 0x62, 0x64, 0x61, 0x63, 0x30, 0x63, 0x31, 0x38, 0x62, 0x66, 0x38, 0x36, 0x35, 0x38, 0x35, 0x31, 0x36, 0x33, 0x39, 0x39, 0x35, 0x30, 0x36, 0x38, 0x30, 0x61, 0x34, 0x34, 0x61, 0x32, 0x64, 0x62, 0x61, 0x66, 0x63, 0x33, 0x62, 0x38, 0x32, 0x65, 0x35, 0x64, 0x39, 0x30, 0x31, 0x35, 0x31, 0x38, 0x37, 0x33, 0x34, 0x64, 0x38, 0x31, 0x30, 0x36, 0x33, 0x63, 0x36, 0x37, 0x32, 0x38, 0x34, 0x34, 0x32, 0x30, 0x38, 0x39, 0x31, 0x35, 0x30, 0x61, 0x65, 0x65, 0x65, 0x62, 0x36, 0x65, 0x31, 0x66, 0x64, 0x65, 0x36, 0x36, 0x39, 0x36, 0x36, 0x34, 0x35, 0x36, 0x35, 0x37, 0x30, 0x62, 0x66, 0x65, 0x61, 0x33, 0x30, 0x31, 0x63, 0x66, 0x39, 0x66, 0x32, 0x33, 0x31, 0x64, 0x34, 0x64, 0x39, 0x64, 0x38, 0x35, 0x61, 0x37, 0x66, 0x35, 0x30, 0x61, 0x39, 0x36, 0x34, 0x37, 0x32, 0x34, 0x38, 0x62, 0x32, 0x36, 0x64, 0x39, 0x33, 0x30, 0x64, 0x63, 0x36, 0x37, 0x62, 0x62, 0x33, 0x30, 0x31, 0x61, 0x34, 0x65, 0x65, 0x31, 0x35, 0x64, 0x62, 0x33, 0x63, 0x37, 0x33, 0x62, 0x63, 0x63, 0x63, 0x37, 0x63, 0x33, 0x34, 0x33, 0x30, 0x66, 0x35, 0x35, 0x38, 0x37, 0x62, 0x63, 0x66, 0x35, 0x35, 0x34, 0x34, 0x61, 0x37, 0x64, 0x33, 0x64, 0x63, 0x31, 0x36, 0x39, 0x39, 0x34, 0x61, 0x64, 0x38, 0x38, 0x61, 0x64, 0x61, 0x32, 0x65, 0x31, 0x66, 0x38, 0x36, 0x63, 0x30, 0x38, 0x63, 0x64, 0x31, 0x33, 0x61, 0x61, 0x39, 0x62, 0x66, 0x35, 0x39, 0x37, 0x34, 0x30, 0x63, 0x33, 0x64, 0x35, 0x33, 0x62, 0x35, 0x36, 0x37, 0x32, 0x39, 0x31, 0x33, 0x37, 0x65, 0x61, 0x66, 0x32, 0x37, 0x34, 0x65, 0x33, 0x62, 0x32, 0x31, 0x31, 0x63, 0x62, 0x65, 0x30, 0x39, 0x65, 0x66, 0x37, 0x32, 0x63, 0x37, 0x30, 0x64, 0x32, 0x65, 0x39, 0x37, 0x35, 0x61, 0x37, 0x39, 0x62, 0x64, 0x63, 0x37, 0x61, 0x63, 0x33, 0x33, 0x62, 0x36, 0x35, 0x64, 0x39, 0x31, 0x33, 0x61, 0x66, 0x30, 0x62, 0x61, 0x64, 0x37, 0x35, 0x39, 0x30, 0x39, 0x37, 0x64, 0x63, 0x36, 0x38, 0x39, 0x35, 0x30, 0x39, 0x61, 0x36, 0x65, 0x63, 0x33, 0x65, 0x61, 0x65, 0x37, 0x64, 0x65, 0x38, 0x37, 0x64, 0x36, 0x37, 0x32, 0x30, 0x34, 0x38, 0x34, 0x66, 0x37, 0x64, 0x33, 0x64, 0x66, 0x66, 0x36, 0x36, 0x37, 0x31, 0x63, 0x34, 0x63, 0x33, 0x34, 0x66, 0x38, 0x63, 0x31, 0x35, 0x34, 0x34, 0x36, 0x37, 0x63, 0x36, 0x61, 0x62, 0x38, 0x32, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x63, 0x61, 0x38, 0x33, 0x35, 0x35, 0x30, 0x37, 0x66, 0x39, 0x63, 0x30, 0x31, 0x62, 0x32, 0x39, 0x63, 0x36, 0x32, 0x34, 0x66, 0x34, 0x39, 0x38, 0x61, 0x32, 0x61, 0x31, 0x61, 0x34, 0x32, 0x32, 0x30, 0x31, 0x32, 0x38, 0x66, 0x39, 0x66, 0x62, 0x39, 0x34, 0x65, 0x30, 0x61, 0x62, 0x61, 0x36, 0x36, 0x33, 0x61, 0x65, 0x38, 0x31, 0x66, 0x38, 0x35, 0x33, 0x38, 0x64, 0x62, 0x38, 0x38, 0x62, 0x39, 0x36, 0x33, 0x37, 0x61, 0x35, 0x30, 0x37, 0x64, 0x37, 0x65, 0x31, 0x36, 0x30, 0x65, 0x63, 0x30, 0x37, 0x65, 0x30, 0x65, 0x30, 0x64, 0x65, 0x35, 0x38, 0x38, 0x36, 0x39, 0x32, 0x38, 0x31, 0x66, 0x63, 0x32, 0x35, 0x65, 0x36, 0x64, 0x35, 0x32, 0x33, 0x62, 0x63, 0x30, 0x39, 0x35, 0x38, 0x36, 0x38, 0x66, 0x33, 0x65, 0x38, 0x36, 0x39, 0x30, 0x32, 0x30, 0x39, 0x35, 0x64, 0x61, 0x63, 0x62, 0x65, 0x36, 0x32, 0x64, 0x61, 0x37, 0x32, 0x63, 0x35, 0x63, 0x66, 0x63, 0x61, 0x38, 0x61, 0x34, 0x36, 0x33, 0x34, 0x30, 0x36, 0x37, 0x65, 0x37, 0x66, 0x64, 0x38, 0x63, 0x39, 0x33, 0x32, 0x66, 0x64, 0x36, 0x35, 0x63, 0x61, 0x64, 0x33, 0x32, 0x36, 0x66, 0x35, 0x30, 0x35, 0x34, 0x61, 0x35, 0x63, 0x61, 0x31, 0x39, 0x65, 0x36, 0x35, 0x38, 0x63, 0x66, 0x31, 0x36, 0x65, 0x38, 0x64, 0x33, 0x38, 0x39, 0x64, 0x32, 0x62, 0x36, 0x37, 0x64, 0x30, 0x65, 0x64, 0x38, 0x39, 0x61, 0x39, 0x35, 0x39, 0x64, 0x33, 0x30, 0x37, 0x32, 0x37, 0x63, 0x38, 0x30, 0x34, 0x38, 0x34, 0x34, 0x63, 0x62, 0x30, 0x66, 0x37, 0x30, 0x39, 0x31, 0x64, 0x31, 0x38, 0x66, 0x35, 0x61, 0x37, 0x32, 0x37, 0x63, 0x66, 0x63, 0x35, 0x38, 0x32, 0x30, 0x37, 0x65, 0x33, 0x31, 0x35, 0x36, 0x61, 0x30, 0x65, 0x64, 0x62, 0x33, 0x64, 0x37, 0x39, 0x33, 0x34, 0x66, 0x64, 0x31, 0x62, 0x30, 0x34, 0x30, 0x61, 0x33, 0x65, 0x37, 0x34, 0x30, 0x37, 0x32, 0x35, 0x34, 0x35, 0x62, 0x37, 0x37, 0x64, 0x62, 0x66, 0x33, 0x34, 0x33, 0x30, 0x65, 0x65, 0x38, 0x38, 0x33, 0x61, 0x37, 0x31, 0x33, 0x39, 0x31, 0x37, 0x63, 0x38, 0x32, 0x61, 0x37, 0x32, 0x31, 0x37, 0x37, 0x33, 0x39, 0x33, 0x35, 0x61, 0x65, 0x33, 0x65, 0x34, 0x31, 0x36, 0x37, 0x62, 0x32, 0x37, 0x32, 0x63, 0x31, 0x63, 0x36, 0x62, 0x32, 0x61, 0x39, 0x31, 0x31, 0x65, 0x38, 0x37, 0x32, 0x65, 0x39, 0x35, 0x38, 0x30, 0x34, 0x65, 0x33, 0x65, 0x65, 0x36, 0x36, 0x37, 0x63, 0x36, 0x33, 0x63, 0x31, 0x63, 0x64, 0x34, 0x34, 0x62, 0x37, 0x62, 0x65, 0x33, 0x37, 0x31, 0x65, 0x62, 0x35, 0x32, 0x30, 0x36, 0x35, 0x35, 0x38, 0x66, 0x39, 0x32, 0x65, 0x65, 0x64, 0x63, 0x36, 0x33, 0x36, 0x32, 0x65, 0x37, 0x39, 0x33, 0x64, 0x35, 0x64, 0x36, 0x31, 0x36, 0x34, 0x64, 0x37, 0x34, 0x35, 0x66, 0x65, 0x31, 0x65, 0x36, 0x34, 0x34, 0x37, 0x61, 0x33, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, 0x39, 0x63, 0x34, 0x36, 0x64, 0x62, 0x32, 0x35, 0x38, 0x36, 0x35, 0x37, 0x30, 0x37, 0x62, 0x61, 0x31, 0x33, 0x37, 0x63, 0x35, 0x37, 0x64, 0x32, 0x61, 0x61, 0x34, 0x30, 0x39, 0x33, 0x31, 0x64, 0x61, 0x35, 0x37, 0x64, 0x36, 0x30, 0x33, 0x66, 0x35, 0x62, 0x32, 0x36, 0x38, 0x31, 0x37, 0x32, 0x38, 0x65, 0x64, 0x32, 0x39, 0x63, 0x39, 0x65, 0x33, 0x33, 0x66, 0x61, 0x30, 0x61, 0x32, 0x30, 0x63, 0x32, 0x63, 0x37, 0x37, 0x33, 0x38, 0x39, 0x37, 0x34, 0x66, 0x34, 0x30, 0x31, 0x30, 0x32, 0x36, 0x32, 0x62, 0x32, 0x39, 0x64, 0x64, 0x38, 0x30, 0x61, 0x31, 0x36, 0x64, 0x38, 0x39, 0x63, 0x35, 0x62, 0x36, 0x66, 0x36, 0x34, 0x37, 0x62, 0x63, 0x37, 0x34, 0x30, 0x66, 0x34, 0x34, 0x39, 0x32, 0x35, 0x62, 0x65, 0x33, 0x33, 0x64, 0x30, 0x66, 0x65, 0x32, 0x37, 0x34, 0x35, 0x66, 0x31, 0x66, 0x38, 0x35, 0x31, 0x64, 0x33, 0x33, 0x33, 0x35, 0x34, 0x32, 0x35, 0x32, 0x66, 0x36, 0x37, 0x38, 0x63, 0x34, 0x38, 0x61, 0x31, 0x32, 0x35, 0x61, 0x64, 0x36, 0x64, 0x66, 0x65, 0x36, 0x65, 0x34, 0x31, 0x35, 0x34, 0x38, 0x38, 0x63, 0x36, 0x63, 0x66, 0x35, 0x65, 0x35, 0x34, 0x37, 0x32, 0x61, 0x38, 0x65, 0x64, 0x64, 0x61, 0x62, 0x66, 0x33, 0x37, 0x64, 0x62, 0x34, 0x66, 0x33, 0x30, 0x38, 0x33, 0x37, 0x36, 0x36, 0x66, 0x65, 0x33, 0x31, 0x30, 0x37, 0x32, 0x63, 0x36, 0x38, 0x38, 0x36, 0x37, 0x31, 0x32, 0x32, 0x30, 0x38, 0x36, 0x64, 0x30, 0x35, 0x66, 0x35, 0x66, 0x34, 0x61, 0x37, 0x63, 0x61, 0x31, 0x38, 0x31, 0x36, 0x32, 0x30, 0x64, 0x65, 0x64, 0x35, 0x62, 0x32, 0x30, 0x39, 0x30, 0x37, 0x63, 0x62, 0x36, 0x36, 0x37, 0x35, 0x65, 0x33, 0x39, 0x32, 0x33, 0x65, 0x39, 0x62, 0x63, 0x39, 0x33, 0x30, 0x63, 0x64, 0x64, 0x62, 0x63, 0x33, 0x38, 0x61, 0x33, 0x35, 0x66, 0x31, 0x65, 0x35, 0x63, 0x34, 0x35, 0x66, 0x64, 0x64, 0x64, 0x37, 0x35, 0x34, 0x34, 0x37, 0x64, 0x36, 0x38, 0x38, 0x37, 0x32, 0x34, 0x32, 0x62, 0x30, 0x63, 0x36, 0x39, 0x65, 0x64, 0x37, 0x32, 0x65, 0x32, 0x66, 0x35, 0x64, 0x35, 0x37, 0x62, 0x66, 0x39, 0x37, 0x66, 0x35, 0x65, 0x63, 0x62, 0x39, 0x34, 0x65, 0x66, 0x32, 0x61, 0x39, 0x39, 0x38, 0x37, 0x30, 0x39, 0x36, 0x33, 0x64, 0x37, 0x66, 0x32, 0x65, 0x64, 0x33, 0x64, 0x35, 0x63, 0x36, 0x38, 0x32, 0x63, 0x64, 0x64, 0x62, 0x32, 0x65, 0x31, 0x32, 0x30, 0x37, 0x35, 0x32, 0x30, 0x30, 0x62, 0x37, 0x36, 0x32, 0x30, 0x37, 0x32, 0x30, 0x33, 0x31, 0x65, 0x61, 0x66, 0x61, 0x65, 0x33, 0x33, 0x62, 0x34, 0x30, 0x62, 0x38, 0x38, 0x66, 0x62, 0x38, 0x37, 0x31, 0x64, 0x32, 0x66, 0x62, 0x30, 0x63, 0x39, 0x35, 0x39, 0x39, 0x65, 0x61, 0x35, 0x39, 0x38, 0x62, 0x65, 0x62, 0x34, 0x62, 0x65, 0x34, 0x32, 0x36, 0x38, 0x39, 0x39, 0x31, 0x63, 0x34, 0x37, 0x32, 0x31, 0x38, 0x34, 0x38, 0x38, 0x31, 0x33, 0x33, 0x65, 0x37, 0x32, 0x39, 0x39, 0x65, 0x65, 0x34, 0x66, 0x34, 0x33, 0x66, 0x66, 0x62, 0x37, 0x66, 0x33, 0x63, 0x31, 0x34, 0x34, 0x63, 0x38, 0x62, 0x30, 0x39, 0x38, 0x34, 0x64, 0x66, 0x62, 0x37, 0x34, 0x34, 0x34, 0x38, 0x36, 0x39, 0x36, 0x61, 0x63, 0x37, 0x32, 0x66, 0x33, 0x37, 0x62, 0x36, 0x37, 0x38, 0x61, 0x65, 0x66, 0x31, 0x30, 0x32, 0x38, 0x34, 0x35, 0x63, 0x32, 0x37, 0x62, 0x39, 0x35, 0x31, 0x63, 0x30, 0x65, 0x63, 0x30, 0x33, 0x31, 0x66, 0x32, 0x35, 0x63, 0x31, 0x39, 0x32, 0x31, 0x37, 0x36, 0x62, 0x39, 0x32, 0x36, 0x32, 0x61, 0x32, 0x63, 0x38, 0x31, 0x62, 0x62, 0x35, 0x61, 0x64, 0x66, 0x62, 0x66, 0x35, 0x32, 0x63, 0x34, 0x36, 0x31, 0x37, 0x36, 0x37, 0x65, 0x38, 0x61, 0x36, 0x33, 0x64, 0x38, 0x30, 0x61, 0x38, 0x30, 0x62, 0x30, 0x64, 0x35, 0x31, 0x34, 0x39, 0x31, 0x35, 0x32, 0x31, 0x32, 0x31, 0x34, 0x62, 0x38, 0x34, 0x35, 0x63, 0x61, 0x33, 0x33, 0x33, 0x30, 0x35, 0x39, 0x66, 0x31, 0x37, 0x34, 0x64, 0x61, 0x65, 0x62, 0x39, 0x38, 0x37, 0x39, 0x39, 0x35, 0x32, 0x33, 0x34, 0x34, 0x64, 0x66, 0x66, 0x38, 0x65, 0x65, 0x62, 0x37, 0x63, 0x33, 0x35, 0x62, 0x33, 0x61, 0x31, 0x64, 0x34, 0x64, 0x34, 0x32, 0x36, 0x66, 0x62, 0x62, 0x63, 0x38, 0x62, 0x37, 0x37, 0x32, 0x61, 0x31, 0x66, 0x66, 0x30, 0x39, 0x31, 0x35, 0x37, 0x37, 0x66, 0x30, 0x33, 0x31, 0x34, 0x31, 0x33, 0x63, 0x62, 0x32, 0x66, 0x31, 0x39, 0x65, 0x39, 0x36, 0x64, 0x30, 0x34, 0x64, 0x64, 0x34, 0x62, 0x35, 0x33, 0x62, 0x65, 0x61, 0x37, 0x35, 0x37, 0x32, 0x33, 0x31, 0x30, 0x35, 0x37, 0x34, 0x36, 0x32, 0x34, 0x38, 0x65, 0x66, 0x36, 0x66, 0x39, 0x31, 0x64, 0x38, 0x30, 0x66, 0x34, 0x66, 0x32, 0x30, 0x30, 0x39, 0x65, 0x63, 0x33, 0x37, 0x30, 0x64, 0x65, 0x62, 0x61, 0x64, 0x31, 0x66, 0x64, 0x32, 0x66, 0x36, 0x34, 0x36, 0x63, 0x64, 0x35, 0x64, 0x66, 0x62, 0x30, 0x63, 0x32, 0x63, 0x31, 0x36, 0x32, 0x63, 0x61, 0x38, 0x61, 0x39, 0x32, 0x35, 0x33, 0x35, 0x62, 0x33, 0x35, 0x62, 0x63, 0x35, 0x32, 0x36, 0x31, 0x36, 0x31, 0x64, 0x33, 0x36, 0x34, 0x33, 0x35, 0x36, 0x31, 0x66, 0x65, 0x33, 0x61, 0x62, 0x64, 0x39, 0x35, 0x31, 0x61, 0x34, 0x66, 0x30, 0x30, 0x66, 0x61, 0x38, 0x61, 0x62, 0x62, 0x31, 0x39, 0x63, 0x65, 0x37, 0x63, 0x38, 0x64, 0x39, 0x37, 0x33, 0x33, 0x62, 0x32, 0x36, 0x32, 0x39, 0x66, 0x62, 0x39, 0x66, 0x66, 0x38, 0x63, 0x37, 0x66, 0x35, 0x63, 0x63, 0x36, 0x30, 0x33, 0x37, 0x63, 0x37, 0x30, 0x63, 0x32, 0x32, 0x38, 0x64, 0x63, 0x36, 0x32, 0x35, 0x36, 0x30, 0x36, 0x31, 0x30, 0x34, 0x65, 0x30, 0x31, 0x66, 0x39, 0x33, 0x63, 0x38, 0x31, 0x65, 0x39, 0x62, 0x63, 0x64, 0x63, 0x30, 0x37, 0x65, 0x32, 0x33, 0x37, 0x38, 0x61, 0x38, 0x64, 0x37, 0x39, 0x62, 0x62, 0x62, 0x61, 0x33, 0x35, 0x65, 0x37, 0x61, 0x35, 0x66, 0x61, 0x64, 0x34, 0x37, 0x32, 0x37, 0x39, 0x39, 0x33, 0x32, 0x63, 0x61, 0x30, 0x33, 0x65, 0x30, 0x30, 0x34, 0x37, 0x32, 0x64, 0x33, 0x36, 0x65, 0x36, 0x36, 0x66, 0x35, 0x35, 0x34, 0x39, 0x31, 0x63, 0x38, 0x36, 0x30, 0x62, 0x33, 0x61, 0x32, 0x62, 0x30, 0x61, 0x63, 0x33, 0x62, 0x38, 0x38, 0x36, 0x33, 0x64, 0x64, 0x34, 0x35, 0x33, 0x65, 0x32, 0x66, 0x36, 0x32, 0x65, 0x62, 0x61, 0x62, 0x37, 0x32, 0x38, 0x38, 0x66, 0x39, 0x65, 0x61, 0x33, 0x39, 0x35, 0x65, 0x37, 0x63, 0x31, 0x36, 0x35, 0x62, 0x37, 0x32, 0x31, 0x33, 0x39, 0x63, 0x39, 0x62, 0x35, 0x63, 0x35, 0x64, 0x61, 0x31, 0x66, 0x66, 0x39, 0x66, 0x33, 0x32, 0x30, 0x34, 0x62, 0x62, 0x30, 0x35, 0x61, 0x39, 0x64, 0x66, 0x30, 0x36, 0x39, 0x66, 0x66, 0x31, 0x32, 0x61, 0x39, 0x39, 0x30, 0x38, 0x62, 0x37, 0x35, 0x32, 0x64, 0x33, 0x64, 0x65, 0x33, 0x38, 0x63, 0x31, 0x37, 0x63, 0x38, 0x36, 0x35, 0x37, 0x39, 0x30, 0x63, 0x65, 0x36, 0x64, 0x61, 0x34, 0x33, 0x63, 0x65, 0x30, 0x31, 0x62, 0x65, 0x62, 0x35, 0x36, 0x35, 0x61, 0x62, 0x33, 0x64, 0x31, 0x38, 0x63, 0x36, 0x32, 0x32, 0x30, 0x64, 0x32, 0x63, 0x34, 0x33, 0x33, 0x35, 0x35, 0x32, 0x66, 0x34, 0x33, 0x31, 0x65, 0x35, 0x33, 0x36, 0x31, 0x35, 0x38, 0x66, 0x34, 0x62, 0x63, 0x33, 0x38, 0x63, 0x63, 0x34, 0x64, 0x36, 0x64, 0x63, 0x61, 0x31, 0x38, 0x64, 0x31, 0x37, 0x32, 0x63, 0x31, 0x34, 0x37, 0x35, 0x64, 0x62, 0x36, 0x64, 0x64, 0x31, 0x36, 0x62, 0x61, 0x37, 0x38, 0x38, 0x33, 0x37, 0x33, 0x62, 0x62, 0x30, 0x31, 0x39, 0x33, 0x30, 0x39, 0x34, 0x32, 0x30, 0x38, 0x62, 0x66, 0x35, 0x64, 0x65, 0x34, 0x64, 0x61, 0x37, 0x36, 0x64, 0x36, 0x38, 0x30, 0x32, 0x36, 0x34, 0x34, 0x38, 0x66, 0x65, 0x31, 0x36, 0x32, 0x35, 0x33, 0x32, 0x35, 0x63, 0x61, 0x37, 0x32, 0x64, 0x35, 0x31, 0x31, 0x61, 0x65, 0x64, 0x32, 0x66, 0x30, 0x63, 0x35, 0x63, 0x35, 0x38, 0x39, 0x31, 0x38, 0x63, 0x63, 0x30, 0x32, 0x30, 0x37, 0x31, 0x30, 0x36, 0x38, 0x35, 0x38, 0x61, 0x38, 0x30, 0x34, 0x64, 0x65, 0x31, 0x34, 0x32, 0x65, 0x63, 0x61, 0x39, 0x38, 0x38, 0x33, 0x35, 0x30, 0x34, 0x34, 0x34, 0x39, 0x63, 0x39, 0x35, 0x30, 0x34, 0x37, 0x39, 0x65, 0x37, 0x66, 0x37, 0x32, 0x35, 0x39, 0x30, 0x33, 0x61, 0x61, 0x61, 0x35, 0x35, 0x63, 0x35, 0x66, 0x63, 0x33, 0x63, 0x65, 0x30, 0x65, 0x37, 0x37, 0x65, 0x39, 0x62, 0x65, 0x34, 0x33, 0x64, 0x65, 0x31, 0x36, 0x66, 0x36, 0x33, 0x36, 0x65, 0x39, 0x65, 0x33, 0x33, 0x35, 0x32, 0x61, 0x61, 0x39, 0x63, 0x30, 0x66, 0x33, 0x66, 0x33, 0x63, 0x66, 0x65, 0x63, 0x61, 0x66, 0x39, 0x35, 0x62, 0x31, 0x35, 0x39, 0x37, 0x32, 0x34, 0x66, 0x61, 0x65, 0x63, 0x66, 0x66, 0x39, 0x36, 0x62, 0x35, 0x37, 0x35, 0x31, 0x34, 0x33, 0x61, 0x62, 0x32, 0x63, 0x34, 0x32, 0x34, 0x38, 0x39, 0x66, 0x33, 0x63, 0x33, 0x34, 0x64, 0x61, 0x66, 0x32, 0x31, 0x35, 0x62, 0x38, 0x35, 0x64, 0x36, 0x34, 0x66, 0x38, 0x62, 0x63, 0x34, 0x31, 0x66, 0x66, 0x34, 0x64, 0x64, 0x66, 0x30, 0x36, 0x35, 0x63, 0x36, 0x30, 0x35, 0x38, 0x37, 0x32, 0x65, 0x64, 0x65, 0x32, 0x34, 0x62, 0x65, 0x37, 0x31, 0x36, 0x62, 0x66, 0x35, 0x38, 0x38, 0x66, 0x61, 0x32, 0x62, 0x38, 0x63, 0x30, 0x34, 0x31, 0x36, 0x32, 0x62, 0x61, 0x65, 0x64, 0x61, 0x35, 0x65, 0x32, 0x64, 0x32, 0x30, 0x34, 0x65, 0x66, 0x64, 0x35, 0x62, 0x38, 0x33, 0x38, 0x38, 0x34, 0x32, 0x35, 0x30, 0x37, 0x62, 0x37, 0x62, 0x30, 0x36, 0x66, 0x36, 0x38, 0x65, 0x34, 0x37, 0x32, 0x31, 0x65, 0x61, 0x66, 0x33, 0x34, 0x62, 0x65, 0x37, 0x62, 0x31, 0x66, 0x36, 0x35, 0x37, 0x63, 0x65, 0x65, 0x62, 0x64, 0x39, 0x38, 0x31, 0x36, 0x32, 0x32, 0x64, 0x66, 0x38, 0x34, 0x64, 0x35, 0x33, 0x36, 0x65, 0x61, 0x36, 0x66, 0x34, 0x38, 0x33, 0x38, 0x62, 0x33, 0x36, 0x34, 0x33, 0x62, 0x34, 0x30, 0x33, 0x30, 0x34, 0x36, 0x36, 0x34, 0x36, 0x37, 0x33, 0x65, 0x63, 0x36, 0x34, 0x66, 0x62, 0x39, 0x31, 0x37, 0x34, 0x66, 0x33, 0x38, 0x35, 0x34, 0x37, 0x64, 0x32, 0x34, 0x38, 0x31, 0x65, 0x33, 0x65, 0x38, 0x35, 0x31, 0x66, 0x39, 0x62, 0x33, 0x63, 0x65, 0x64, 0x66, 0x37, 0x31, 0x33, 0x31, 0x30, 0x61, 0x39, 0x38, 0x33, 0x32, 0x64, 0x31, 0x63, 0x61, 0x64, 0x62, 0x39, 0x63, 0x36, 0x33, 0x63, 0x62, 0x38, 0x63, 0x38, 0x31, 0x35, 0x31, 0x36, 0x65, 0x65, 0x65, 0x37, 0x32, 0x66, 0x64, 0x61, 0x30, 0x30, 0x62, 0x37, 0x62, 0x64, 0x61, 0x33, 0x35, 0x33, 0x30, 0x31, 0x38, 0x34, 0x34, 0x63, 0x30, 0x63, 0x30, 0x32, 0x36, 0x61, 0x31, 0x36, 0x36, 0x65, 0x66, 0x38, 0x37, 0x31, 0x36, 0x36, 0x30, 0x38, 0x65, 0x35, 0x37, 0x62, 0x64, 0x30, 0x34, 0x30, 0x31, 0x33, 0x65, 0x37, 0x61, 0x38, 0x61, 0x61, 0x39, 0x33, 0x62, 0x32, 0x33, 0x63, 0x37, 0x30, 0x32, 0x37, 0x32, 0x62, 0x66, 0x32, 0x63, 0x31, 0x34, 0x35, 0x64, 0x36, 0x36, 0x38, 0x35, 0x31, 0x64, 0x32, 0x35, 0x37, 0x38, 0x33, 0x61, 0x65, 0x32, 0x36, 0x64, 0x61, 0x32, 0x32, 0x66, 0x65, 0x39, 0x61, 0x37, 0x35, 0x36, 0x64, 0x37, 0x39, 0x61, 0x63, 0x34, 0x32, 0x63, 0x38, 0x32, 0x66, 0x62, 0x30, 0x64, 0x66, 0x30, 0x65, 0x31, 0x35, 0x30, 0x63, 0x31, 0x66, 0x39, 0x65, 0x65, 0x38, 0x64, 0x37, 0x32, 0x62, 0x32, 0x31, 0x39, 0x30, 0x34, 0x36, 0x63, 0x34, 0x36, 0x32, 0x62, 0x31, 0x61, 0x62, 0x65, 0x38, 0x61, 0x32, 0x61, 0x63, 0x31, 0x37, 0x37, 0x33, 0x65, 0x66, 0x65, 0x31, 0x31, 0x33, 0x34, 0x62, 0x36, 0x63, 0x36, 0x63, 0x62, 0x61, 0x36, 0x33, 0x37, 0x61, 0x36, 0x63, 0x66, 0x65, 0x35, 0x33, 0x35, 0x39, 0x63, 0x35, 0x64, 0x38, 0x35, 0x33, 0x37, 0x37, 0x37, 0x64, 0x31, 0x33, 0x39, 0x61, 0x36, 0x36, 0x32, 0x61, 0x34, 0x63, 0x31, 0x39, 0x64, 0x30, 0x31, 0x34, 0x64, 0x35, 0x31, 0x35, 0x66, 0x30, 0x30, 0x64, 0x30, 0x32, 0x34, 0x36, 0x30, 0x39, 0x62, 0x61, 0x35, 0x34, 0x62, 0x31, 0x65, 0x31, 0x65, 0x63, 0x38, 0x34, 0x35, 0x63, 0x62, 0x34, 0x31, 0x34, 0x38, 0x32, 0x34, 0x64, 0x66, 0x64, 0x33, 0x61, 0x65, 0x65, 0x31, 0x33, 0x38, 0x31, 0x65, 0x61, 0x63, 0x36, 0x35, 0x63, 0x62, 0x65, 0x64, 0x37, 0x64, 0x30, 0x37, 0x36, 0x38, 0x66, 0x39, 0x34, 0x65, 0x31, 0x30, 0x32, 0x34, 0x37, 0x39, 0x36, 0x33, 0x39, 0x37, 0x66, 0x32, 0x66, 0x65, 0x63, 0x30, 0x30, 0x30, 0x65, 0x31, 0x38, 0x64, 0x65, 0x61, 0x62, 0x61, 0x34, 0x32, 0x65, 0x37, 0x65, 0x32, 0x37, 0x66, 0x36, 0x32, 0x66, 0x64, 0x63, 0x30, 0x32, 0x31, 0x33, 0x66, 0x63, 0x62, 0x31, 0x35, 0x37, 0x32, 0x30, 0x32, 0x31, 0x34, 0x61, 0x35, 0x31, 0x61, 0x31, 0x61, 0x65, 0x30, 0x65, 0x33, 0x61, 0x61, 0x30, 0x65, 0x66, 0x35, 0x64, 0x37, 0x32, 0x33, 0x62, 0x30, 0x31, 0x64, 0x36, 0x33, 0x62, 0x38, 0x63, 0x65, 0x61, 0x32, 0x33, 0x32, 0x34, 0x35, 0x34, 0x39, 0x62, 0x31, 0x63, 0x66, 0x31, 0x35, 0x33, 0x33, 0x36, 0x64, 0x33, 0x33, 0x31, 0x61, 0x39, 0x63, 0x66, 0x62, 0x32, 0x63, 0x37, 0x32, 0x37, 0x35, 0x30, 0x34, 0x39, 0x34, 0x37, 0x64, 0x62, 0x35, 0x61, 0x61, 0x61, 0x31, 0x61, 0x66, 0x35, 0x32, 0x61, 0x36, 0x66, 0x61, 0x31, 0x32, 0x32, 0x35, 0x62, 0x39, 0x65, 0x32, 0x30, 0x33, 0x31, 0x62, 0x34, 0x38, 0x66, 0x65, 0x35, 0x32, 0x36, 0x37, 0x61, 0x34, 0x34, 0x30, 0x37, 0x64, 0x30, 0x37, 0x38, 0x37, 0x34, 0x62, 0x35, 0x62, 0x31, 0x34, 0x37, 0x31, 0x35, 0x30, 0x34, 0x64, 0x34, 0x39, 0x35, 0x66, 0x35, 0x31, 0x64, 0x36, 0x65, 0x65, 0x36, 0x63, 0x38, 0x37, 0x36, 0x32, 0x34, 0x36, 0x37, 0x32, 0x66, 0x38, 0x66, 0x66, 0x38, 0x64, 0x31, 0x30, 0x66, 0x64, 0x63, 0x32, 0x30, 0x66, 0x66, 0x35, 0x33, 0x38, 0x62, 0x35, 0x31, 0x38, 0x66, 0x65, 0x65, 0x36, 0x32, 0x38, 0x36, 0x65, 0x34, 0x36, 0x30, 0x64, 0x66, 0x65, 0x38, 0x36, 0x31, 0x65, 0x65, 0x62, 0x37, 0x32, 0x64, 0x33, 0x31, 0x66, 0x61, 0x64, 0x33, 0x65, 0x64, 0x61, 0x65, 0x33, 0x62, 0x62, 0x66, 0x66, 0x64, 0x37, 0x32, 0x33, 0x31, 0x35, 0x33, 0x39, 0x33, 0x35, 0x62, 0x30, 0x35, 0x34, 0x61, 0x37, 0x30, 0x39, 0x66, 0x33, 0x63, 0x64, 0x34, 0x38, 0x66, 0x39, 0x34, 0x30, 0x30, 0x64, 0x37, 0x63, 0x61, 0x39, 0x34, 0x35, 0x38, 0x62, 0x65, 0x62, 0x36, 0x37, 0x61, 0x63, 0x64, 0x35, 0x34, 0x34, 0x34, 0x30, 0x36, 0x66, 0x66, 0x61, 0x65, 0x31, 0x38, 0x37, 0x64, 0x65, 0x34, 0x65, 0x31, 0x37, 0x34, 0x38, 0x30, 0x39, 0x39, 0x34, 0x63, 0x39, 0x37, 0x37, 0x37, 0x35, 0x61, 0x32, 0x66, 0x66, 0x31, 0x33, 0x37, 0x38, 0x33, 0x34, 0x32, 0x38, 0x32, 0x61, 0x32, 0x35, 0x30, 0x31, 0x30, 0x34, 0x32, 0x35, 0x34, 0x30, 0x37, 0x36, 0x62, 0x63, 0x66, 0x35, 0x30, 0x32, 0x30, 0x38, 0x34, 0x63, 0x33, 0x35, 0x63, 0x32, 0x34, 0x62, 0x32, 0x32, 0x33, 0x66, 0x36, 0x39, 0x62, 0x32, 0x64, 0x35, 0x31, 0x30, 0x38, 0x32, 0x39, 0x63, 0x38, 0x35, 0x32, 0x61, 0x30, 0x39, 0x66, 0x61, 0x63, 0x63, 0x32, 0x37, 0x64, 0x61, 0x35, 0x63, 0x62, 0x34, 0x37, 0x66, 0x61, 0x30, 0x32, 0x37, 0x65, 0x62, 0x32, 0x66, 0x33, 0x35, 0x38, 0x62, 0x36, 0x36, 0x65, 0x33, 0x38, 0x39, 0x30, 0x38, 0x35, 0x64, 0x66, 0x31, 0x38, 0x31, 0x66, 0x66, 0x64, 0x64, 0x34, 0x61, 0x39, 0x35, 0x37, 0x33, 0x38, 0x32, 0x65, 0x62, 0x63, 0x65, 0x34, 0x61, 0x31, 0x30, 0x63, 0x32, 0x61, 0x32, 0x66, 0x32, 0x37, 0x32, 0x61, 0x61, 0x62, 0x37, 0x66, 0x34, 0x35, 0x31, 0x61, 0x64, 0x38, 0x39, 0x65, 0x39, 0x66, 0x62, 0x31, 0x32, 0x61, 0x38, 0x38, 0x32, 0x33, 0x32, 0x36, 0x37, 0x64, 0x36, 0x65, 0x62, 0x36, 0x32, 0x36, 0x36, 0x32, 0x63, 0x61, 0x66, 0x35, 0x39, 0x34, 0x61, 0x62, 0x33, 0x61, 0x62, 0x31, 0x39, 0x36, 0x63, 0x37, 0x64, 0x36, 0x63, 0x38, 0x63, 0x37, 0x35, 0x37, 0x34, 0x39, 0x31, 0x62, 0x34, 0x31, 0x66, 0x32, 0x37, 0x38, 0x36, 0x31, 0x39, 0x63, 0x33, 0x66, 0x61, 0x30, 0x62, 0x62, 0x33, 0x62, 0x61, 0x64, 0x64, 0x39, 0x31, 0x66, 0x35, 0x38, 0x62, 0x65, 0x33, 0x36, 0x61, 0x32, 0x65, 0x66, 0x65, 0x66, 0x33, 0x64, 0x61, 0x64, 0x30, 0x35, 0x33, 0x31, 0x37, 0x64, 0x63, 0x30, 0x31, 0x38, 0x35, 0x32, 0x62, 0x30, 0x34, 0x32, 0x30, 0x39, 0x64, 0x34, 0x34, 0x32, 0x30, 0x62, 0x35, 0x63, 0x32, 0x61, 0x36, 0x31, 0x36, 0x31, 0x62, 0x39, 0x34, 0x61, 0x39, 0x65, 0x65, 0x35, 0x65, 0x36, 0x66, 0x35, 0x35, 0x63, 0x61, 0x66, 0x63, 0x37, 0x39, 0x36, 0x36, 0x30, 0x35, 0x37, 0x32, 0x65, 0x30, 0x32, 0x66, 0x32, 0x64, 0x34, 0x31, 0x33, 0x35, 0x38, 0x30, 0x30, 0x34, 0x63, 0x37, 0x35, 0x66, 0x35, 0x36, 0x34, 0x34, 0x38, 0x62, 0x64, 0x37, 0x30, 0x31, 0x36, 0x63, 0x38, 0x37, 0x61, 0x35, 0x39, 0x30, 0x64, 0x32, 0x62, 0x65, 0x65, 0x33, 0x38, 0x62, 0x32, 0x63, 0x66, 0x34, 0x64, 0x37, 0x63, 0x33, 0x30, 0x32, 0x63, 0x32, 0x63, 0x39, 0x34, 0x33, 0x30, 0x39, 0x37, 0x32, 0x61, 0x62, 0x30, 0x33, 0x64, 0x30, 0x37, 0x61, 0x38, 0x30, 0x39, 0x38, 0x62, 0x31, 0x36, 0x63, 0x30, 0x34, 0x36, 0x64, 0x30, 0x34, 0x63, 0x31, 0x34, 0x63, 0x63, 0x38, 0x30, 0x65, 0x35, 0x62, 0x35, 0x39, 0x65, 0x31, 0x36, 0x66, 0x66, 0x64, 0x38, 0x37, 0x30, 0x61, 0x35, 0x35, 0x32, 0x37, 0x37, 0x61, 0x30, 0x37, 0x34, 0x38, 0x34, 0x30, 0x61, 0x61, 0x32, 0x38, 0x63, 0x39, 0x37, 0x32, 0x37, 0x66, 0x36, 0x65, 0x37, 0x37, 0x39, 0x39, 0x37, 0x66, 0x32, 0x36, 0x31, 0x37, 0x30, 0x30, 0x35, 0x36, 0x31, 0x36, 0x64, 0x37, 0x39, 0x63, 0x32, 0x64, 0x64, 0x30, 0x33, 0x65, 0x37, 0x30, 0x31, 0x39, 0x30, 0x37, 0x38, 0x39, 0x31, 0x37, 0x64, 0x35, 0x65, 0x30, 0x65, 0x35, 0x64, 0x32, 0x65, 0x36, 0x33, 0x38, 0x65, 0x61, 0x33, 0x64, 0x32, 0x31, 0x34, 0x61, 0x33, 0x39, 0x31, 0x36, 0x37, 0x30, 0x63, 0x34, 0x35, 0x31, 0x32, 0x38, 0x31, 0x38, 0x61, 0x34, 0x63, 0x62, 0x38, 0x30, 0x34, 0x30, 0x64, 0x66, 0x63, 0x32, 0x35, 0x66, 0x64, 0x30, 0x32, 0x36, 0x34, 0x66, 0x61, 0x63, 0x36, 0x61, 0x62, 0x65, 0x64, 0x32, 0x66, 0x31, 0x33, 0x31, 0x63, 0x63, 0x65, 0x65, 0x30, 0x61, 0x64, 0x37, 0x66, 0x38, 0x63, 0x61, 0x61, 0x32, 0x36, 0x39, 0x35, 0x37, 0x64, 0x36, 0x34, 0x39, 0x38, 0x61, 0x33, 0x66, 0x32, 0x33, 0x30, 0x31, 0x35, 0x65, 0x66, 0x34, 0x64, 0x61, 0x31, 0x39, 0x65, 0x39, 0x31, 0x35, 0x64, 0x63, 0x65, 0x36, 0x65, 0x34, 0x30, 0x66, 0x30, 0x64, 0x65, 0x35, 0x62, 0x65, 0x31, 0x30, 0x31, 0x38, 0x35, 0x37, 0x61, 0x38, 0x34, 0x33, 0x64, 0x36, 0x64, 0x36, 0x30, 0x64, 0x63, 0x64, 0x32, 0x61, 0x31, 0x32, 0x65, 0x31, 0x64, 0x61, 0x64, 0x36, 0x35, 0x39, 0x63, 0x34, 0x61, 0x63, 0x33, 0x61, 0x65, 0x34, 0x39, 0x34, 0x65, 0x33, 0x38, 0x32, 0x61, 0x37, 0x33, 0x62, 0x32, 0x62, 0x33, 0x63, 0x38, 0x63, 0x65, 0x63, 0x35, 0x38, 0x65, 0x30, 0x66, 0x33, 0x35, 0x66, 0x37, 0x36, 0x38, 0x35, 0x32, 0x31, 0x65, 0x65, 0x38, 0x39, 0x65, 0x65, 0x33, 0x39, 0x66, 0x31, 0x35, 0x35, 0x66, 0x66, 0x64, 0x37, 0x34, 0x63, 0x65, 0x62, 0x35, 0x30, 0x32, 0x36, 0x32, 0x62, 0x63, 0x38, 0x36, 0x64, 0x66, 0x63, 0x33, 0x62, 0x30, 0x30, 0x65, 0x33, 0x62, 0x66, 0x63, 0x62, 0x63, 0x61, 0x33, 0x32, 0x36, 0x39, 0x34, 0x64, 0x32, 0x30, 0x65, 0x31, 0x66, 0x34, 0x31, 0x36, 0x37, 0x39, 0x35, 0x39, 0x32, 0x30, 0x36, 0x65, 0x31, 0x32, 0x38, 0x36, 0x34, 0x39, 0x32, 0x31, 0x63, 0x37, 0x36, 0x66, 0x38, 0x61, 0x64, 0x37, 0x66, 0x34, 0x36, 0x32, 0x37, 0x32, 0x33, 0x39, 0x37, 0x34, 0x32, 0x38, 0x62, 0x66, 0x38, 0x34, 0x62, 0x65, 0x62, 0x38, 0x62, 0x38, 0x36, 0x65, 0x34, 0x34, 0x31, 0x37, 0x30, 0x38, 0x36, 0x66, 0x61, 0x32, 0x39, 0x30, 0x35, 0x61, 0x37, 0x34, 0x34, 0x62, 0x63, 0x66, 0x63, 0x39, 0x64, 0x39, 0x64, 0x33, 0x32, 0x61, 0x33, 0x63, 0x39, 0x62, 0x39, 0x65, 0x62, 0x39, 0x32, 0x64, 0x61, 0x63, 0x39, 0x63, 0x66, 0x62, 0x32, 0x38, 0x33, 0x61, 0x63, 0x34, 0x39, 0x66, 0x34, 0x64, 0x63, 0x31, 0x37, 0x32, 0x65, 0x38, 0x63, 0x31, 0x62, 0x30, 0x35, 0x63, 0x36, 0x35, 0x39, 0x37, 0x64, 0x62, 0x65, 0x36, 0x61, 0x66, 0x64, 0x39, 0x32, 0x36, 0x30, 0x64, 0x36, 0x33, 0x33, 0x31, 0x37, 0x31, 0x34, 0x33, 0x64, 0x39, 0x36, 0x32, 0x65, 0x35, 0x36, 0x30, 0x32, 0x33, 0x65, 0x33, 0x34, 0x33, 0x36, 0x37, 0x31, 0x62, 0x37, 0x32, 0x35, 0x66, 0x32, 0x38, 0x61, 0x33, 0x61, 0x32, 0x61, 0x32, 0x64, 0x34, 0x38, 0x32, 0x62, 0x34, 0x30, 0x61, 0x39, 0x31, 0x39, 0x62, 0x38, 0x32, 0x37, 0x31, 0x34, 0x34, 0x33, 0x61, 0x36, 0x30, 0x38, 0x39, 0x64, 0x32, 0x38, 0x37, 0x33, 0x32, 0x62, 0x39, 0x39, 0x39, 0x65, 0x33, 0x35, 0x39, 0x65, 0x62, 0x64, 0x66, 0x62, 0x30, 0x32, 0x30, 0x32, 0x34, 0x30, 0x36, 0x31, 0x65, 0x31, 0x63, 0x33, 0x33, 0x66, 0x33, 0x38, 0x33, 0x61, 0x38, 0x66, 0x62, 0x66, 0x34, 0x62, 0x66, 0x63, 0x30, 0x38, 0x33, 0x38, 0x38, 0x35, 0x38, 0x31, 0x32, 0x63, 0x34, 0x37, 0x36, 0x31, 0x63, 0x65, 0x64, 0x38, 0x38, 0x34, 0x38, 0x39, 0x34, 0x36, 0x35, 0x37, 0x39, 0x32, 0x36, 0x35, 0x31, 0x62, 0x30, 0x66, 0x65, 0x65, 0x39, 0x65, 0x32, 0x30, 0x38, 0x64, 0x30, 0x65, 0x30, 0x34, 0x31, 0x37, 0x32, 0x61, 0x62, 0x64, 0x37, 0x32, 0x38, 0x61, 0x35, 0x62, 0x39, 0x64, 0x34, 0x63, 0x37, 0x35, 0x63, 0x32, 0x32, 0x31, 0x61, 0x64, 0x34, 0x61, 0x65, 0x61, 0x38, 0x37, 0x39, 0x32, 0x33, 0x38, 0x34, 0x66, 0x36, 0x61, 0x36, 0x31, 0x38, 0x34, 0x63, 0x31, 0x30, 0x32, 0x37, 0x61, 0x62, 0x33, 0x30, 0x65, 0x36, 0x62, 0x39, 0x34, 0x33, 0x32, 0x32, 0x37, 0x35, 0x31, 0x61, 0x64, 0x66, 0x37, 0x32, 0x34, 0x39, 0x33, 0x30, 0x61, 0x61, 0x37, 0x37, 0x63, 0x38, 0x66, 0x63, 0x63, 0x66, 0x64, 0x37, 0x66, 0x32, 0x37, 0x64, 0x35, 0x64, 0x66, 0x61, 0x38, 0x62, 0x62, 0x32, 0x61, 0x66, 0x61, 0x31, 0x30, 0x30, 0x64, 0x30, 0x30, 0x38, 0x38, 0x36, 0x34, 0x61, 0x64, 0x66, 0x30, 0x38, 0x37, 0x31, 0x36, 0x35, 0x63, 0x34, 0x30, 0x66, 0x37, 0x34, 0x38, 0x30, 0x36, 0x31, 0x34, 0x31, 0x37, 0x32, 0x33, 0x30, 0x34, 0x36, 0x38, 0x36, 0x65, 0x36, 0x39, 0x34, 0x37, 0x39, 0x36, 0x36, 0x36, 0x39, 0x61, 0x34, 0x66, 0x38, 0x61, 0x31, 0x31, 0x39, 0x35, 0x62, 0x39, 0x36, 0x61, 0x37, 0x61, 0x35, 0x35, 0x35, 0x38, 0x33, 0x63, 0x38, 0x37, 0x63, 0x39, 0x37, 0x62, 0x62, 0x64, 0x66, 0x64, 0x33, 0x66, 0x33, 0x38, 0x36, 0x37, 0x39, 0x62, 0x66, 0x31, 0x34, 0x33, 0x30, 0x62, 0x38, 0x37, 0x32, 0x34, 0x61, 0x37, 0x66, 0x32, 0x39, 0x66, 0x63, 0x32, 0x33, 0x62, 0x33, 0x36, 0x66, 0x62, 0x38, 0x61, 0x63, 0x34, 0x64, 0x63, 0x34, 0x32, 0x31, 0x62, 0x62, 0x38, 0x34, 0x38, 0x62, 0x64, 0x61, 0x62, 0x31, 0x38, 0x32, 0x33, 0x64, 0x34, 0x30, 0x30, 0x33, 0x61, 0x33, 0x39, 0x37, 0x33, 0x64, 0x34, 0x65, 0x63, 0x61, 0x65, 0x38, 0x38, 0x39, 0x34, 0x63, 0x64, 0x65, 0x62, 0x36, 0x37, 0x32, 0x32, 0x32, 0x65, 0x37, 0x30, 0x65, 0x33, 0x36, 0x61, 0x33, 0x64, 0x35, 0x61, 0x62, 0x39, 0x62, 0x65, 0x32, 0x39, 0x32, 0x62, 0x38, 0x63, 0x37, 0x38, 0x38, 0x37, 0x38, 0x63, 0x66, 0x32, 0x62, 0x36, 0x31, 0x32, 0x31, 0x30, 0x37, 0x32, 0x34, 0x64, 0x35, 0x63, 0x63, 0x31, 0x61, 0x32, 0x64, 0x38, 0x34, 0x36, 0x36, 0x65, 0x36, 0x35, 0x32, 0x36, 0x62, 0x37, 0x65, 0x33, 0x32, 0x35, 0x38, 0x33, 0x34, 0x36, 0x33, 0x35, 0x64, 0x36, 0x65, 0x66, 0x31, 0x31, 0x61, 0x32, 0x34, 0x33, 0x63, 0x31, 0x61, 0x66, 0x30, 0x32, 0x35, 0x31, 0x36, 0x34, 0x65, 0x61, 0x31, 0x30, 0x34, 0x30, 0x35, 0x31, 0x61, 0x66, 0x66, 0x30, 0x38, 0x66, 0x64, 0x37, 0x31, 0x33, 0x63, 0x31, 0x66, 0x64, 0x33, 0x38, 0x63, 0x33, 0x63, 0x30, 0x37, 0x64, 0x35, 0x63, 0x38, 0x65, 0x36, 0x62, 0x62, 0x31, 0x36, 0x31, 0x38, 0x63, 0x37, 0x36, 0x33, 0x38, 0x64, 0x37, 0x61, 0x35, 0x38, 0x34, 0x31, 0x32, 0x66, 0x61, 0x65, 0x35, 0x39, 0x64, 0x62, 0x36, 0x65, 0x65, 0x39, 0x64, 0x61, 0x63, 0x36, 0x66, 0x66, 0x37, 0x30, 0x66, 0x39, 0x30, 0x62, 0x33, 0x61, 0x65, 0x36, 0x62, 0x35, 0x33, 0x32, 0x32, 0x31, 0x35, 0x33, 0x36, 0x36, 0x33, 0x61, 0x62, 0x35, 0x62, 0x37, 0x32, 0x34, 0x62, 0x37, 0x37, 0x32, 0x37, 0x65, 0x36, 0x63, 0x37, 0x39, 0x63, 0x64, 0x39, 0x63, 0x64, 0x65, 0x62, 0x33, 0x65, 0x30, 0x34, 0x37, 0x63, 0x33, 0x35, 0x62, 0x64, 0x33, 0x64, 0x62, 0x38, 0x30, 0x35, 0x39, 0x34, 0x35, 0x36, 0x37, 0x30, 0x35, 0x30, 0x64, 0x35, 0x65, 0x30, 0x39, 0x37, 0x34, 0x64, 0x66, 0x37, 0x64, 0x66, 0x30, 0x34, 0x61, 0x31, 0x65, 0x34, 0x37, 0x34, 0x63, 0x31, 0x37, 0x61, 0x33, 0x35, 0x65, 0x38, 0x62, 0x61, 0x32, 0x37, 0x30, 0x38, 0x64, 0x37, 0x35, 0x37, 0x39, 0x62, 0x61, 0x65, 0x39, 0x35, 0x39, 0x66, 0x30, 0x63, 0x30, 0x61, 0x64, 0x35, 0x63, 0x32, 0x35, 0x35, 0x31, 0x33, 0x32, 0x62, 0x30, 0x63, 0x64, 0x36, 0x37, 0x30, 0x31, 0x61, 0x65, 0x30, 0x34, 0x35, 0x33, 0x63, 0x30, 0x39, 0x37, 0x62, 0x65, 0x61, 0x38, 0x37, 0x64, 0x34, 0x64, 0x66, 0x62, 0x33, 0x31, 0x30, 0x65, 0x63, 0x65, 0x30, 0x39, 0x63, 0x30, 0x38, 0x36, 0x65, 0x32, 0x62, 0x31, 0x61, 0x33, 0x37, 0x35, 0x61, 0x37, 0x39, 0x66, 0x36, 0x66, 0x31, 0x38, 0x31, 0x66, 0x31, 0x36, 0x61, 0x32, 0x63, 0x33, 0x35, 0x37, 0x34, 0x32, 0x65, 0x30, 0x39, 0x65, 0x64, 0x64, 0x37, 0x62, 0x30, 0x30, 0x33, 0x32, 0x39, 0x38, 0x65, 0x34, 0x62, 0x38, 0x30, 0x35, 0x64, 0x39, 0x38, 0x33, 0x61, 0x30, 0x37, 0x32, 0x35, 0x65, 0x38, 0x32, 0x35, 0x62, 0x33, 0x36, 0x64, 0x30, 0x32, 0x37, 0x63, 0x36, 0x61, 0x63, 0x30, 0x61, 0x61, 0x65, 0x30, 0x37, 0x39, 0x36, 0x32, 0x64, 0x63, 0x32, 0x30, 0x63, 0x39, 0x62, 0x33, 0x39, 0x39, 0x38, 0x39, 0x62, 0x66, 0x61, 0x62, 0x30, 0x35, 0x34, 0x66, 0x61, 0x62, 0x31, 0x37, 0x31, 0x33, 0x39, 0x64, 0x30, 0x35, 0x63, 0x65, 0x31, 0x34, 0x65, 0x33, 0x33, 0x36, 0x33, 0x63, 0x32, 0x30, 0x33, 0x36, 0x37, 0x38, 0x38, 0x33, 0x36, 0x32, 0x36, 0x32, 0x33, 0x31, 0x66, 0x37, 0x65, 0x36, 0x30, 0x32, 0x64, 0x35, 0x63, 0x37, 0x62, 0x66, 0x38, 0x61, 0x66, 0x62, 0x65, 0x30, 0x37, 0x61, 0x30, 0x62, 0x38, 0x63, 0x39, 0x30, 0x38, 0x35, 0x34, 0x65, 0x36, 0x66, 0x36, 0x65, 0x63, 0x33, 0x64, 0x38, 0x61, 0x66, 0x65, 0x61, 0x36, 0x31, 0x36, 0x33, 0x34, 0x30, 0x32, 0x36, 0x37, 0x65, 0x33, 0x62, 0x37, 0x35, 0x37, 0x64, 0x30, 0x66, 0x61, 0x63, 0x64, 0x34, 0x62, 0x37, 0x30, 0x31, 0x33, 0x31, 0x32, 0x33, 0x33, 0x32, 0x33, 0x32, 0x65, 0x39, 0x31, 0x61, 0x37, 0x34, 0x61, 0x38, 0x66, 0x39, 0x33, 0x35, 0x33, 0x39, 0x62, 0x63, 0x37, 0x64, 0x62, 0x64, 0x36, 0x36, 0x65, 0x65, 0x34, 0x39, 0x62, 0x64, 0x32, 0x63, 0x38, 0x35, 0x39, 0x34, 0x36, 0x36, 0x36, 0x31, 0x62, 0x33, 0x61, 0x31, 0x62, 0x36, 0x62, 0x31, 0x62, 0x32, 0x32, 0x32, 0x39, 0x65, 0x32, 0x32, 0x33, 0x64, 0x35, 0x39, 0x65, 0x63, 0x37, 0x65, 0x62, 0x37, 0x34, 0x32, 0x65, 0x39, 0x63, 0x36, 0x38, 0x61, 0x62, 0x61, 0x64, 0x39, 0x37, 0x61, 0x37, 0x63, 0x31, 0x62, 0x39, 0x36, 0x38, 0x65, 0x37, 0x65, 0x37, 0x62, 0x35, 0x35, 0x35, 0x64, 0x64, 0x34, 0x32, 0x62, 0x35, 0x36, 0x63, 0x38, 0x66, 0x66, 0x39, 0x64, 0x37, 0x38, 0x30, 0x33, 0x65, 0x66, 0x37, 0x37, 0x62, 0x31, 0x33, 0x36, 0x38, 0x65, 0x37, 0x39, 0x38, 0x61, 0x39, 0x38, 0x34, 0x62, 0x61, 0x62, 0x64, 0x31, 0x62, 0x62, 0x65, 0x34, 0x38, 0x38, 0x33, 0x36, 0x36, 0x66, 0x35, 0x61, 0x38, 0x62, 0x63, 0x31, 0x63, 0x65, 0x61, 0x30, 0x62, 0x36, 0x38, 0x37, 0x62, 0x38, 0x34, 0x66, 0x65, 0x66, 0x37, 0x37, 0x32, 0x32, 0x34, 0x64, 0x61, 0x62, 0x66, 0x34, 0x66, 0x61, 0x66, 0x61, 0x39, 0x39, 0x66, 0x61, 0x30, 0x61, 0x35, 0x33, 0x62, 0x39, 0x35, 0x65, 0x35, 0x62, 0x63, 0x35, 0x64, 0x38, 0x30, 0x34, 0x66, 0x63, 0x38, 0x30, 0x62, 0x32, 0x33, 0x37, 0x62, 0x31, 0x62, 0x39, 0x34, 0x31, 0x61, 0x37, 0x30, 0x39, 0x32, 0x31, 0x66, 0x61, 0x65, 0x37, 0x36, 0x61, 0x34, 0x65, 0x31, 0x30, 0x65, 0x36, 0x34, 0x36, 0x38, 0x66, 0x65, 0x66, 0x39, 0x65, 0x30, 0x34, 0x65, 0x34, 0x36, 0x63, 0x61, 0x31, 0x36, 0x63, 0x30, 0x30, 0x30, 0x38, 0x37, 0x61, 0x61, 0x33, 0x35, 0x36, 0x61, 0x61, 0x39, 0x30, 0x63, 0x62, 0x30, 0x64, 0x61, 0x62, 0x34, 0x62, 0x63, 0x37, 0x63, 0x63, 0x64, 0x64, 0x65, 0x62, 0x31, 0x61, 0x66, 0x37, 0x37, 0x34, 0x34, 0x64, 0x34, 0x36, 0x31, 0x61, 0x38, 0x62, 0x36, 0x37, 0x32, 0x65, 0x65, 0x33, 0x33, 0x32, 0x31, 0x61, 0x37, 0x31, 0x66, 0x36, 0x32, 0x62, 0x66, 0x65, 0x33, 0x63, 0x64, 0x64, 0x32, 0x31, 0x64, 0x33, 0x32, 0x66, 0x31, 0x38, 0x35, 0x62, 0x61, 0x35, 0x63, 0x32, 0x37, 0x30, 0x31, 0x66, 0x39, 0x65, 0x66, 0x62, 0x33, 0x32, 0x66, 0x32, 0x38, 0x30, 0x36, 0x33, 0x63, 0x34, 0x32, 0x39, 0x32, 0x35, 0x37, 0x35, 0x31, 0x65, 0x61, 0x38, 0x66, 0x33, 0x66, 0x33, 0x64, 0x36, 0x61, 0x34, 0x34, 0x36, 0x39, 0x66, 0x39, 0x34, 0x65, 0x30, 0x30, 0x34, 0x63, 0x66, 0x32, 0x62, 0x32, 0x31, 0x37, 0x33, 0x38, 0x62, 0x62, 0x32, 0x30, 0x36, 0x66, 0x34, 0x31, 0x30, 0x35, 0x32, 0x39, 0x61, 0x38, 0x34, 0x36, 0x64, 0x36, 0x37, 0x36, 0x35, 0x61, 0x64, 0x66, 0x34, 0x61, 0x32, 0x32, 0x61, 0x39, 0x31, 0x37, 0x39, 0x37, 0x37, 0x34, 0x65, 0x32, 0x34, 0x35, 0x65, 0x32, 0x34, 0x32, 0x64, 0x31, 0x33, 0x63, 0x32, 0x62, 0x65, 0x32, 0x37, 0x63, 0x36, 0x33, 0x31, 0x34, 0x31, 0x30, 0x61, 0x31, 0x36, 0x65, 0x37, 0x35, 0x34, 0x61, 0x63, 0x31, 0x38, 0x36, 0x39, 0x39, 0x62, 0x36, 0x66, 0x63, 0x38, 0x35, 0x33, 0x30, 0x63, 0x65, 0x37, 0x32, 0x39, 0x36, 0x37, 0x62, 0x62, 0x31, 0x34, 0x33, 0x32, 0x37, 0x61, 0x62, 0x32, 0x38, 0x36, 0x33, 0x37, 0x32, 0x62, 0x36, 0x35, 0x64, 0x37, 0x34, 0x30, 0x63, 0x65, 0x38, 0x64, 0x32, 0x35, 0x64, 0x35, 0x66, 0x64, 0x64, 0x32, 0x63, 0x34, 0x30, 0x33, 0x30, 0x63, 0x65, 0x37, 0x64, 0x32, 0x30, 0x64, 0x36, 0x37, 0x64, 0x39, 0x34, 0x35, 0x66, 0x62, 0x38, 0x35, 0x35, 0x38, 0x31, 0x34, 0x39, 0x65, 0x63, 0x65, 0x37, 0x35, 0x30, 0x30, 0x36, 0x32, 0x37, 0x34, 0x65, 0x35, 0x61, 0x64, 0x66, 0x37, 0x32, 0x64, 0x30, 0x37, 0x38, 0x35, 0x32, 0x32, 0x65, 0x38, 0x31, 0x61, 0x32, 0x36, 0x32, 0x33, 0x61, 0x61, 0x61, 0x63, 0x64, 0x34, 0x35, 0x61, 0x35, 0x65, 0x63, 0x65, 0x64, 0x37, 0x35, 0x36, 0x65, 0x61, 0x36, 0x63, 0x30, 0x61, 0x65, 0x66, 0x31, 0x36, 0x33, 0x38, 0x37, 0x31, 0x65, 0x35, 0x31, 0x34, 0x36, 0x38, 0x36, 0x61, 0x62, 0x37, 0x34, 0x32, 0x63, 0x30, 0x30, 0x30, 0x64, 0x37, 0x32, 0x36, 0x65, 0x62, 0x32, 0x64, 0x64, 0x36, 0x61, 0x31, 0x32, 0x37, 0x61, 0x33, 0x66, 0x35, 0x61, 0x61, 0x66, 0x61, 0x38, 0x65, 0x30, 0x63, 0x65, 0x36, 0x65, 0x64, 0x34, 0x39, 0x64, 0x33, 0x61, 0x61, 0x39, 0x36, 0x35, 0x32, 0x36, 0x65, 0x61, 0x61, 0x66, 0x36, 0x31, 0x39, 0x66, 0x39, 0x34, 0x30, 0x38, 0x32, 0x34, 0x61, 0x33, 0x34, 0x31, 0x63, 0x35, 0x63, 0x34, 0x34, 0x35, 0x30, 0x37, 0x32, 0x66, 0x63, 0x33, 0x34, 0x35, 0x63, 0x61, 0x37, 0x31, 0x66, 0x37, 0x37, 0x61, 0x32, 0x66, 0x65, 0x33, 0x31, 0x33, 0x65, 0x31, 0x31, 0x66, 0x32, 0x38, 0x31, 0x34, 0x31, 0x39, 0x31, 0x33, 0x36, 0x62, 0x37, 0x36, 0x34, 0x66, 0x61, 0x35, 0x31, 0x33, 0x30, 0x38, 0x32, 0x35, 0x62, 0x32, 0x63, 0x35, 0x31, 0x30, 0x39, 0x64, 0x66, 0x65, 0x33, 0x66, 0x65, 0x33, 0x38, 0x39, 0x31, 0x61, 0x37, 0x31, 0x61, 0x31, 0x38, 0x31, 0x61, 0x37, 0x61, 0x30, 0x35, 0x65, 0x61, 0x31, 0x63, 0x64, 0x36, 0x63, 0x30, 0x39, 0x38, 0x65, 0x64, 0x62, 0x61, 0x34, 0x64, 0x31, 0x62, 0x30, 0x34, 0x39, 0x66, 0x64, 0x35, 0x36, 0x32, 0x36, 0x65, 0x64, 0x64, 0x62, 0x33, 0x35, 0x66, 0x30, 0x64, 0x38, 0x32, 0x31, 0x34, 0x34, 0x32, 0x34, 0x64, 0x39, 0x65, 0x64, 0x36, 0x63, 0x30, 0x66, 0x37, 0x32, 0x30, 0x32, 0x65, 0x63, 0x33, 0x32, 0x35, 0x31, 0x39, 0x61, 0x34, 0x39, 0x63, 0x39, 0x63, 0x62, 0x34, 0x33, 0x35, 0x66, 0x37, 0x61, 0x38, 0x30, 0x39, 0x38, 0x36, 0x62, 0x36, 0x35, 0x34, 0x36, 0x39, 0x66, 0x38, 0x62, 0x35, 0x62, 0x38, 0x63, 0x32, 0x63, 0x62, 0x32, 0x31, 0x64, 0x30, 0x30, 0x62, 0x61, 0x34, 0x39, 0x39, 0x64, 0x65, 0x36, 0x31, 0x36, 0x30, 0x62, 0x33, 0x64, 0x31, 0x66, 0x66, 0x35, 0x63, 0x34, 0x62, 0x39, 0x34, 0x64, 0x64, 0x39, 0x31, 0x37, 0x64, 0x61, 0x38, 0x38, 0x66, 0x65, 0x66, 0x32, 0x61, 0x31, 0x31, 0x34, 0x39, 0x32, 0x64, 0x61, 0x38, 0x63, 0x39, 0x65, 0x63, 0x31, 0x30, 0x32, 0x30, 0x64, 0x65, 0x62, 0x62, 0x34, 0x62, 0x37, 0x34, 0x66, 0x30, 0x66, 0x66, 0x39, 0x32, 0x30, 0x66, 0x36, 0x32, 0x66, 0x39, 0x39, 0x37, 0x30, 0x35, 0x66, 0x37, 0x32, 0x36, 0x63, 0x36, 0x62, 0x37, 0x34, 0x62, 0x39, 0x37, 0x62, 0x36, 0x31, 0x37, 0x64, 0x65, 0x36, 0x39, 0x64, 0x34, 0x33, 0x33, 0x30, 0x65, 0x37, 0x32, 0x66, 0x33, 0x38, 0x35, 0x39, 0x66, 0x30, 0x32, 0x35, 0x30, 0x62, 0x38, 0x31, 0x63, 0x36, 0x64, 0x66, 0x62, 0x34, 0x35, 0x65, 0x65, 0x63, 0x37, 0x33, 0x37, 0x37, 0x36, 0x39, 0x63, 0x63, 0x32, 0x61, 0x66, 0x38, 0x38, 0x39, 0x35, 0x36, 0x64, 0x31, 0x32, 0x30, 0x35, 0x35, 0x32, 0x33, 0x61, 0x39, 0x35, 0x34, 0x63, 0x63, 0x66, 0x66, 0x31, 0x30, 0x65, 0x35, 0x63, 0x36, 0x34, 0x35, 0x35, 0x63, 0x33, 0x61, 0x63, 0x35, 0x33, 0x64, 0x61, 0x31, 0x39, 0x65, 0x32, 0x65, 0x65, 0x35, 0x65, 0x61, 0x30, 0x35, 0x34, 0x31, 0x38, 0x62, 0x34, 0x61, 0x61, 0x61, 0x39, 0x64, 0x38, 0x37, 0x30, 0x31, 0x34, 0x62, 0x39, 0x65, 0x37, 0x32, 0x33, 0x30, 0x37, 0x34, 0x63, 0x33, 0x30, 0x65, 0x35, 0x64, 0x63, 0x33, 0x32, 0x36, 0x39, 0x37, 0x37, 0x66, 0x33, 0x33, 0x35, 0x31, 0x63, 0x38, 0x38, 0x64, 0x64, 0x33, 0x64, 0x35, 0x63, 0x39, 0x33, 0x30, 0x62, 0x64, 0x62, 0x39, 0x63, 0x63, 0x35, 0x39, 0x32, 0x61, 0x30, 0x38, 0x62, 0x63, 0x33, 0x32, 0x36, 0x37, 0x64, 0x32, 0x35, 0x35, 0x64, 0x62, 0x61, 0x31, 0x38, 0x31, 0x37, 0x32, 0x38, 0x30, 0x39, 0x63, 0x39, 0x36, 0x62, 0x38, 0x33, 0x62, 0x38, 0x38, 0x66, 0x65, 0x65, 0x62, 0x38, 0x36, 0x36, 0x31, 0x39, 0x61, 0x62, 0x64, 0x31, 0x35, 0x66, 0x62, 0x65, 0x34, 0x66, 0x33, 0x33, 0x64, 0x38, 0x62, 0x63, 0x63, 0x36, 0x38, 0x62, 0x30, 0x61, 0x65, 0x34, 0x31, 0x39, 0x37, 0x37, 0x35, 0x31, 0x33, 0x31, 0x35, 0x31, 0x64, 0x36, 0x32, 0x33, 0x37, 0x62, 0x31, 0x37, 0x32, 0x30, 0x32, 0x33, 0x30, 0x35, 0x30, 0x37, 0x61, 0x61, 0x35, 0x39, 0x65, 0x34, 0x35, 0x33, 0x35, 0x63, 0x61, 0x31, 0x63, 0x34, 0x33, 0x33, 0x64, 0x63, 0x61, 0x33, 0x37, 0x64, 0x37, 0x61, 0x66, 0x66, 0x34, 0x33, 0x30, 0x65, 0x35, 0x34, 0x35, 0x36, 0x35, 0x39, 0x61, 0x35, 0x65, 0x64, 0x34, 0x35, 0x38, 0x66, 0x33, 0x33, 0x65, 0x66, 0x63, 0x38, 0x66, 0x38, 0x65, 0x34, 0x63, 0x33, 0x34, 0x32, 0x66, 0x66, 0x38, 0x65, 0x30, 0x65, 0x38, 0x64, 0x64, 0x38, 0x63, 0x66, 0x31, 0x39, 0x35, 0x30, 0x33, 0x64, 0x37, 0x31, 0x32, 0x37, 0x63, 0x61, 0x31, 0x63, 0x30, 0x31, 0x31, 0x32, 0x33, 0x31, 0x66, 0x65, 0x39, 0x39, 0x34, 0x35, 0x63, 0x38, 0x36, 0x63, 0x65, 0x37, 0x30, 0x32, 0x34, 0x36, 0x33, 0x66, 0x31, 0x35, 0x36, 0x34, 0x31, 0x66, 0x30, 0x36, 0x36, 0x65, 0x32, 0x36, 0x64, 0x31, 0x30, 0x65, 0x37, 0x34, 0x31, 0x37, 0x33, 0x66, 0x39, 0x64, 0x33, 0x37, 0x34, 0x65, 0x39, 0x66, 0x32, 0x30, 0x64, 0x32, 0x36, 0x38, 0x32, 0x31, 0x31, 0x34, 0x38, 0x37, 0x31, 0x31, 0x33, 0x35, 0x36, 0x38, 0x31, 0x37, 0x30, 0x37, 0x37, 0x32, 0x32, 0x30, 0x35, 0x64, 0x32, 0x65, 0x65, 0x39, 0x65, 0x61, 0x61, 0x65, 0x38, 0x38, 0x36, 0x37, 0x31, 0x61, 0x35, 0x32, 0x39, 0x37, 0x32, 0x34, 0x31, 0x31, 0x64, 0x35, 0x39, 0x31, 0x30, 0x63, 0x37, 0x65, 0x32, 0x62, 0x61, 0x34, 0x66, 0x35, 0x36, 0x38, 0x39, 0x64, 0x39, 0x64, 0x63, 0x37, 0x36, 0x61, 0x34, 0x33, 0x63, 0x33, 0x33, 0x62, 0x64, 0x33, 0x65, 0x35, 0x34, 0x32, 0x64, 0x38, 0x63, 0x37, 0x32, 0x64, 0x62, 0x30, 0x38, 0x62, 0x33, 0x62, 0x31, 0x36, 0x65, 0x32, 0x63, 0x62, 0x61, 0x30, 0x30, 0x39, 0x65, 0x37, 0x32, 0x31, 0x32, 0x63, 0x38, 0x30, 0x30, 0x62, 0x30, 0x32, 0x39, 0x32, 0x66, 0x35, 0x32, 0x36, 0x62, 0x36, 0x31, 0x65, 0x64, 0x33, 0x35, 0x30, 0x62, 0x63, 0x64, 0x35, 0x33, 0x31, 0x63, 0x35, 0x61, 0x36, 0x31, 0x63, 0x64, 0x64, 0x34, 0x36, 0x32, 0x34, 0x30, 0x35, 0x61, 0x35, 0x34, 0x33, 0x38, 0x61, 0x32, 0x31, 0x34, 0x39, 0x38, 0x36, 0x32, 0x39, 0x38, 0x35, 0x38, 0x32, 0x34, 0x37, 0x32, 0x37, 0x33, 0x31, 0x61, 0x64, 0x39, 0x38, 0x32, 0x66, 0x39, 0x63, 0x38, 0x65, 0x61, 0x31, 0x65, 0x30, 0x38, 0x39, 0x61, 0x62, 0x33, 0x33, 0x64, 0x37, 0x61, 0x31, 0x30, 0x35, 0x65, 0x38, 0x32, 0x34, 0x31, 0x33, 0x39, 0x32, 0x36, 0x31, 0x66, 0x63, 0x34, 0x30, 0x34, 0x36, 0x38, 0x38, 0x37, 0x30, 0x61, 0x37, 0x61, 0x36, 0x61, 0x35, 0x62, 0x39, 0x31, 0x30, 0x66, 0x32, 0x63, 0x32, 0x39, 0x66, 0x65, 0x61, 0x35, 0x31, 0x33, 0x64, 0x37, 0x33, 0x39, 0x36, 0x36, 0x65, 0x33, 0x62, 0x38, 0x65, 0x61, 0x33, 0x30, 0x36, 0x32, 0x61, 0x66, 0x37, 0x33, 0x66, 0x36, 0x31, 0x31, 0x39, 0x39, 0x32, 0x36, 0x36, 0x66, 0x36, 0x36, 0x38, 0x33, 0x65, 0x30, 0x64, 0x37, 0x63, 0x39, 0x39, 0x39, 0x38, 0x31, 0x61, 0x31, 0x35, 0x30, 0x62, 0x32, 0x30, 0x35, 0x64, 0x32, 0x30, 0x66, 0x37, 0x32, 0x32, 0x33, 0x63, 0x31, 0x39, 0x34, 0x62, 0x66, 0x65, 0x39, 0x30, 0x37, 0x31, 0x34, 0x63, 0x66, 0x35, 0x32, 0x39, 0x62, 0x64, 0x32, 0x38, 0x66, 0x38, 0x30, 0x38, 0x36, 0x64, 0x33, 0x38, 0x37, 0x62, 0x66, 0x61, 0x63, 0x32, 0x62, 0x65, 0x61, 0x30, 0x33, 0x63, 0x66, 0x36, 0x32, 0x35, 0x65, 0x66, 0x66, 0x35, 0x31, 0x32, 0x39, 0x31, 0x38, 0x33, 0x34, 0x34, 0x33, 0x37, 0x35, 0x32, 0x62, 0x34, 0x62, 0x38, 0x32, 0x33, 0x66, 0x30, 0x33, 0x66, 0x64, 0x31, 0x31, 0x38, 0x38, 0x66, 0x63, 0x35, 0x65, 0x39, 0x32, 0x62, 0x62, 0x32, 0x62, 0x66, 0x32, 0x66, 0x61, 0x31, 0x35, 0x33, 0x61, 0x35, 0x61, 0x65, 0x39, 0x35, 0x63, 0x64, 0x64, 0x63, 0x64, 0x34, 0x32, 0x32, 0x64, 0x36, 0x30, 0x30, 0x38, 0x64, 0x35, 0x32, 0x34, 0x33, 0x37, 0x36, 0x32, 0x30, 0x30, 0x37, 0x62, 0x30, 0x37, 0x37, 0x38, 0x39, 0x37, 0x61, 0x32, 0x37, 0x65, 0x32, 0x64, 0x30, 0x38, 0x33, 0x34, 0x63, 0x30, 0x61, 0x34, 0x36, 0x65, 0x64, 0x30, 0x62, 0x35, 0x64, 0x30, 0x39, 0x30, 0x62, 0x35, 0x31, 0x37, 0x34, 0x37, 0x36, 0x39, 0x36, 0x65, 0x33, 0x30, 0x39, 0x31, 0x31, 0x66, 0x64, 0x38, 0x38, 0x34, 0x35, 0x33, 0x65, 0x62, 0x30, 0x30, 0x32, 0x65, 0x31, 0x63, 0x30, 0x63, 0x38, 0x39, 0x32, 0x62, 0x62, 0x30, 0x61, 0x30, 0x65, 0x31, 0x39, 0x38, 0x36, 0x34, 0x62, 0x37, 0x65, 0x36, 0x30, 0x34, 0x65, 0x61, 0x30, 0x33, 0x35, 0x37, 0x38, 0x62, 0x35, 0x34, 0x32, 0x30, 0x62, 0x39, 0x33, 0x37, 0x63, 0x66, 0x64, 0x65, 0x31, 0x62, 0x34, 0x31, 0x66, 0x62, 0x66, 0x63, 0x65, 0x34, 0x65, 0x64, 0x34, 0x30, 0x66, 0x35, 0x31, 0x64, 0x34, 0x38, 0x31, 0x61, 0x34, 0x36, 0x38, 0x65, 0x37, 0x32, 0x33, 0x38, 0x30, 0x37, 0x37, 0x36, 0x33, 0x37, 0x65, 0x30, 0x31, 0x30, 0x64, 0x34, 0x63, 0x34, 0x61, 0x62, 0x31, 0x32, 0x32, 0x61, 0x35, 0x62, 0x32, 0x64, 0x35, 0x37, 0x33, 0x36, 0x63, 0x39, 0x64, 0x62, 0x62, 0x66, 0x32, 0x38, 0x37, 0x64, 0x64, 0x65, 0x32, 0x37, 0x34, 0x32, 0x31, 0x36, 0x64, 0x33, 0x31, 0x31, 0x66, 0x32, 0x34, 0x35, 0x38, 0x36, 0x30, 0x39, 0x33, 0x35, 0x37, 0x32, 0x66, 0x61, 0x62, 0x66, 0x61, 0x34, 0x66, 0x30, 0x31, 0x39, 0x61, 0x65, 0x34, 0x63, 0x32, 0x64, 0x37, 0x64, 0x62, 0x36, 0x30, 0x37, 0x34, 0x34, 0x64, 0x34, 0x39, 0x64, 0x65, 0x61, 0x66, 0x35, 0x66, 0x33, 0x32, 0x30, 0x64, 0x31, 0x61, 0x62, 0x61, 0x64, 0x64, 0x66, 0x30, 0x65, 0x31, 0x31, 0x62, 0x32, 0x64, 0x31, 0x37, 0x32, 0x37, 0x33, 0x38, 0x35, 0x31, 0x39, 0x38, 0x65, 0x37, 0x30, 0x66, 0x63, 0x65, 0x36, 0x65, 0x36, 0x61, 0x39, 0x63, 0x37, 0x66, 0x66, 0x32, 0x39, 0x63, 0x65, 0x65, 0x30, 0x37, 0x65, 0x33, 0x39, 0x63, 0x64, 0x31, 0x65, 0x66, 0x64, 0x32, 0x30, 0x65, 0x66, 0x65, 0x66, 0x38, 0x36, 0x36, 0x65, 0x38, 0x30, 0x36, 0x34, 0x65, 0x37, 0x34, 0x35, 0x39, 0x38, 0x34, 0x31, 0x33, 0x33, 0x65, 0x33, 0x39, 0x65, 0x32, 0x36, 0x61, 0x37, 0x31, 0x63, 0x30, 0x62, 0x38, 0x65, 0x62, 0x33, 0x65, 0x61, 0x32, 0x31, 0x61, 0x38, 0x39, 0x63, 0x32, 0x34, 0x34, 0x30, 0x63, 0x63, 0x66, 0x62, 0x34, 0x34, 0x64, 0x65, 0x38, 0x64, 0x64, 0x37, 0x34, 0x38, 0x39, 0x36, 0x32, 0x62, 0x30, 0x65, 0x62, 0x64, 0x33, 0x63, 0x39, 0x34, 0x32, 0x65, 0x38, 0x32, 0x66, 0x36, 0x35, 0x65, 0x30, 0x35, 0x66, 0x30, 0x37, 0x36, 0x39, 0x30, 0x32, 0x65, 0x37, 0x35, 0x37, 0x32, 0x38, 0x30, 0x39, 0x65, 0x38, 0x38, 0x66, 0x62, 0x31, 0x61, 0x61, 0x62, 0x63, 0x35, 0x66, 0x64, 0x33, 0x39, 0x61, 0x66, 0x64, 0x34, 0x32, 0x37, 0x33, 0x37, 0x39, 0x62, 0x66, 0x31, 0x33, 0x32, 0x64, 0x61, 0x38, 0x62, 0x38, 0x38, 0x37, 0x63, 0x38, 0x62, 0x35, 0x33, 0x38, 0x37, 0x30, 0x63, 0x36, 0x64, 0x34, 0x32, 0x66, 0x33, 0x32, 0x36, 0x66, 0x33, 0x37, 0x65, 0x35, 0x34, 0x33, 0x65, 0x61, 0x38, 0x36, 0x61, 0x32, 0x31, 0x62, 0x39, 0x62, 0x38, 0x61, 0x36, 0x65, 0x61, 0x65, 0x35, 0x62, 0x61, 0x31, 0x64, 0x30, 0x65, 0x64, 0x37, 0x66, 0x34, 0x31, 0x36, 0x66, 0x37, 0x30, 0x65, 0x61, 0x66, 0x33, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x36, 0x62, 0x30, 0x33, 0x63, 0x62, 0x61, 0x64, 0x30, 0x66, 0x63, 0x30, 0x31, 0x61, 0x37, 0x35, 0x31, 0x62, 0x64, 0x30, 0x61, 0x37, 0x32, 0x39, 0x66, 0x31, 0x65, 0x33, 0x39, 0x39, 0x34, 0x37, 0x39, 0x35, 0x62, 0x62, 0x64, 0x30, 0x65, 0x32, 0x35, 0x31, 0x36, 0x30, 0x36, 0x61, 0x35, 0x37, 0x61, 0x65, 0x65, 0x61, 0x37, 0x61, 0x39, 0x39, 0x64, 0x65, 0x35, 0x66, 0x30, 0x38, 0x62, 0x62, 0x63, 0x30, 0x39, 0x61, 0x34, 0x38, 0x36, 0x37, 0x36, 0x37, 0x65, 0x32, 0x38, 0x36, 0x35, 0x38, 0x30, 0x39, 0x31, 0x64, 0x34, 0x36, 0x38, 0x37, 0x61, 0x34, 0x35, 0x66, 0x35, 0x64, 0x33, 0x31, 0x63, 0x36, 0x32, 0x61, 0x33, 0x34, 0x30, 0x65, 0x39, 0x32, 0x66, 0x32, 0x38, 0x39, 0x66, 0x35, 0x39, 0x65, 0x66, 0x38, 0x61, 0x31, 0x36, 0x66, 0x38, 0x34, 0x62, 0x61, 0x35, 0x65, 0x39, 0x34, 0x66, 0x32, 0x62, 0x66, 0x31, 0x32, 0x39, 0x38, 0x31, 0x62, 0x63, 0x31, 0x63, 0x36, 0x63, 0x62, 0x38, 0x38, 0x33, 0x61, 0x66, 0x37, 0x32, 0x38, 0x33, 0x64, 0x39, 0x65, 0x32, 0x35, 0x65, 0x33, 0x31, 0x30, 0x38, 0x39, 0x62, 0x35, 0x31, 0x61, 0x66, 0x33, 0x39, 0x62, 0x38, 0x35, 0x66, 0x31, 0x65, 0x33, 0x63, 0x31, 0x30, 0x64, 0x38, 0x64, 0x65, 0x63, 0x65, 0x30, 0x34, 0x62, 0x37, 0x64, 0x66, 0x38, 0x30, 0x32, 0x31, 0x64, 0x30, 0x30, 0x39, 0x64, 0x64, 0x34, 0x37, 0x34, 0x38, 0x33, 0x39, 0x32, 0x38, 0x66, 0x30, 0x37, 0x32, 0x36, 0x30, 0x61, 0x63, 0x62, 0x63, 0x33, 0x35, 0x39, 0x64, 0x63, 0x38, 0x61, 0x62, 0x65, 0x35, 0x34, 0x36, 0x39, 0x39, 0x64, 0x38, 0x65, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x38, 0x65, 0x31, 0x36, 0x34, 0x61, 0x65, 0x39, 0x36, 0x38, 0x35, 0x65, 0x31, 0x34, 0x31, 0x61, 0x35, 0x36, 0x37, 0x65, 0x33, 0x63, 0x30, 0x38, 0x64, 0x61, 0x61, 0x30, 0x32, 0x62, 0x37, 0x37, 0x32, 0x31, 0x35, 0x64, 0x37, 0x63, 0x38, 0x65, 0x61, 0x66, 0x31, 0x32, 0x61, 0x37, 0x39, 0x31, 0x64, 0x35, 0x61, 0x66, 0x35, 0x61, 0x33, 0x63, 0x63, 0x37, 0x39, 0x64, 0x65, 0x38, 0x62, 0x33, 0x65, 0x34, 0x30, 0x65, 0x37, 0x33, 0x34, 0x38, 0x66, 0x31, 0x66, 0x33, 0x35, 0x62, 0x37, 0x63, 0x38, 0x34, 0x39, 0x38, 0x63, 0x61, 0x66, 0x64, 0x32, 0x64, 0x31, 0x33, 0x32, 0x30, 0x62, 0x37, 0x32, 0x30, 0x64, 0x38, 0x34, 0x65, 0x36, 0x66, 0x33, 0x38, 0x61, 0x62, 0x62, 0x38, 0x32, 0x34, 0x38, 0x63, 0x35, 0x37, 0x35, 0x35, 0x61, 0x39, 0x32, 0x32, 0x64, 0x34, 0x34, 0x32, 0x33, 0x65, 0x62, 0x36, 0x33, 0x39, 0x33, 0x30, 0x33, 0x36, 0x32, 0x34, 0x61, 0x36, 0x65, 0x62, 0x63, 0x39, 0x33, 0x64, 0x32, 0x61, 0x65, 0x37, 0x37, 0x31, 0x30, 0x63, 0x38, 0x65, 0x31, 0x61, 0x64, 0x35, 0x62, 0x66, 0x31, 0x65, 0x31, 0x66, 0x63, 0x35, 0x35, 0x63, 0x35, 0x34, 0x33, 0x61, 0x32, 0x61, 0x36, 0x30, 0x31, 0x36, 0x63, 0x32, 0x66, 0x34, 0x63, 0x39, 0x65, 0x34, 0x34, 0x61, 0x63, 0x31, 0x61, 0x31, 0x31, 0x37, 0x31, 0x30, 0x62, 0x61, 0x32, 0x61, 0x39, 0x62, 0x30, 0x63, 0x34, 0x31, 0x65, 0x64, 0x66, 0x35, 0x33, 0x61, 0x64, 0x62, 0x33, 0x33, 0x63, 0x30, 0x38, 0x61, 0x65, 0x37, 0x32, 0x39, 0x38, 0x39, 0x31, 0x61, 0x63, 0x34, 0x34, 0x38, 0x33, 0x61, 0x65, 0x36, 0x34, 0x38, 0x39, 0x34, 0x32, 0x62, 0x31, 0x34, 0x62, 0x38, 0x35, 0x31, 0x36, 0x64, 0x38, 0x30, 0x39, 0x36, 0x38, 0x34, 0x31, 0x31, 0x30, 0x36, 0x38, 0x61, 0x33, 0x66, 0x62, 0x36, 0x39, 0x38, 0x30, 0x38, 0x62, 0x65, 0x37, 0x64, 0x32, 0x38, 0x38, 0x39, 0x64, 0x61, 0x32, 0x61, 0x39, 0x36, 0x33, 0x33, 0x62, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x36, 0x66, 0x35, 0x66, 0x38, 0x66, 0x33, 0x35, 0x64, 0x63, 0x38, 0x62, 0x34, 0x34, 0x61, 0x37, 0x33, 0x39, 0x63, 0x30, 0x36, 0x35, 0x62, 0x35, 0x64, 0x33, 0x32, 0x64, 0x37, 0x65, 0x64, 0x37, 0x38, 0x66, 0x33, 0x63, 0x37, 0x35, 0x62, 0x36, 0x62, 0x35, 0x39, 0x31, 0x34, 0x38, 0x38, 0x38, 0x61, 0x36, 0x65, 0x36, 0x62, 0x38, 0x39, 0x39, 0x37, 0x32, 0x62, 0x61, 0x63, 0x61, 0x34, 0x63, 0x34, 0x62, 0x30, 0x34, 0x66, 0x34, 0x38, 0x66, 0x39, 0x64, 0x63, 0x34, 0x32, 0x66, 0x35, 0x33, 0x39, 0x64, 0x36, 0x39, 0x34, 0x62, 0x63, 0x37, 0x32, 0x66, 0x65, 0x36, 0x61, 0x64, 0x66, 0x34, 0x62, 0x38, 0x35, 0x35, 0x62, 0x34, 0x63, 0x63, 0x39, 0x30, 0x65, 0x39, 0x32, 0x32, 0x64, 0x33, 0x39, 0x36, 0x37, 0x65, 0x31, 0x37, 0x39, 0x39, 0x37, 0x32, 0x33, 0x30, 0x63, 0x65, 0x34, 0x32, 0x61, 0x63, 0x37, 0x32, 0x39, 0x38, 0x39, 0x63, 0x32, 0x65, 0x35, 0x37, 0x35, 0x63, 0x64, 0x35, 0x62, 0x36, 0x39, 0x63, 0x31, 0x62, 0x63, 0x39, 0x35, 0x34, 0x31, 0x36, 0x31, 0x37, 0x39, 0x36, 0x34, 0x61, 0x39, 0x31, 0x39, 0x65, 0x38, 0x30, 0x61, 0x32, 0x61, 0x63, 0x33, 0x66, 0x33, 0x35, 0x33, 0x66, 0x31, 0x35, 0x34, 0x31, 0x32, 0x35, 0x37, 0x32, 0x32, 0x35, 0x38, 0x36, 0x30, 0x32, 0x33, 0x31, 0x61, 0x36, 0x35, 0x36, 0x64, 0x37, 0x31, 0x34, 0x30, 0x38, 0x31, 0x38, 0x34, 0x66, 0x65, 0x61, 0x38, 0x31, 0x65, 0x30, 0x31, 0x37, 0x62, 0x34, 0x63, 0x33, 0x38, 0x30, 0x62, 0x64, 0x39, 0x31, 0x39, 0x37, 0x63, 0x34, 0x33, 0x66, 0x66, 0x32, 0x30, 0x31, 0x31, 0x66, 0x39, 0x36, 0x36, 0x64, 0x38, 0x33, 0x63, 0x35, 0x66, 0x30, 0x37, 0x32, 0x62, 0x33, 0x30, 0x39, 0x31, 0x39, 0x38, 0x38, 0x61, 0x38, 0x65, 0x30, 0x38, 0x37, 0x61, 0x36, 0x30, 0x34, 0x63, 0x30, 0x38, 0x33, 0x37, 0x61, 0x33, 0x32, 0x61, 0x30, 0x33, 0x62, 0x63, 0x36, 0x64, 0x30, 0x30, 0x35, 0x30, 0x65, 0x35, 0x32, 0x31, 0x63, 0x63, 0x61, 0x31, 0x62, 0x33, 0x63, 0x61, 0x66, 0x63, 0x62, 0x39, 0x30, 0x37, 0x33, 0x31, 0x64, 0x61, 0x62, 0x34, 0x31, 0x37, 0x32, 0x32, 0x38, 0x63, 0x35, 0x64, 0x66, 0x39, 0x37, 0x36, 0x30, 0x37, 0x37, 0x37, 0x65, 0x64, 0x62, 0x66, 0x62, 0x32, 0x30, 0x65, 0x31, 0x33, 0x34, 0x33, 0x30, 0x31, 0x65, 0x36, 0x65, 0x39, 0x39, 0x36, 0x35, 0x66, 0x62, 0x32, 0x38, 0x39, 0x63, 0x32, 0x61, 0x38, 0x35, 0x61, 0x32, 0x35, 0x35, 0x35, 0x32, 0x62, 0x32, 0x65, 0x63, 0x63, 0x30, 0x65, 0x30, 0x61, 0x31, 0x37, 0x30, 0x37, 0x32, 0x37, 0x31, 0x65, 0x36, 0x31, 0x39, 0x32, 0x30, 0x36, 0x35, 0x30, 0x64, 0x31, 0x61, 0x30, 0x64, 0x62, 0x66, 0x37, 0x38, 0x34, 0x31, 0x33, 0x36, 0x33, 0x65, 0x36, 0x37, 0x32, 0x39, 0x32, 0x63, 0x66, 0x32, 0x64, 0x66, 0x65, 0x61, 0x30, 0x36, 0x65, 0x65, 0x36, 0x66, 0x65, 0x66, 0x63, 0x33, 0x38, 0x61, 0x61, 0x35, 0x33, 0x61, 0x66, 0x63, 0x39, 0x36, 0x64, 0x35, 0x65, 0x61, 0x37, 0x32, 0x66, 0x64, 0x33, 0x30, 0x35, 0x31, 0x34, 0x35, 0x39, 0x31, 0x65, 0x66, 0x62, 0x34, 0x35, 0x39, 0x39, 0x31, 0x30, 0x30, 0x30, 0x65, 0x30, 0x66, 0x39, 0x34, 0x36, 0x35, 0x61, 0x33, 0x30, 0x66, 0x62, 0x39, 0x30, 0x65, 0x63, 0x36, 0x38, 0x62, 0x39, 0x38, 0x30, 0x32, 0x36, 0x62, 0x30, 0x32, 0x35, 0x32, 0x61, 0x65, 0x65, 0x31, 0x61, 0x64, 0x63, 0x33, 0x63, 0x63, 0x64, 0x37, 0x37, 0x32, 0x37, 0x33, 0x34, 0x61, 0x61, 0x33, 0x66, 0x35, 0x36, 0x36, 0x62, 0x62, 0x33, 0x63, 0x61, 0x32, 0x33, 0x35, 0x36, 0x33, 0x34, 0x64, 0x63, 0x32, 0x35, 0x63, 0x65, 0x37, 0x38, 0x65, 0x32, 0x64, 0x31, 0x31, 0x39, 0x66, 0x66, 0x64, 0x36, 0x64, 0x34, 0x34, 0x34, 0x33, 0x34, 0x36, 0x34, 0x31, 0x65, 0x36, 0x62, 0x61, 0x63, 0x39, 0x31, 0x37, 0x30, 0x65, 0x39, 0x37, 0x33, 0x39, 0x37, 0x32, 0x30, 0x37, 0x63, 0x36, 0x37, 0x63, 0x35, 0x37, 0x37, 0x61, 0x36, 0x61, 0x35, 0x36, 0x64, 0x66, 0x30, 0x37, 0x33, 0x37, 0x62, 0x36, 0x64, 0x39, 0x61, 0x35, 0x32, 0x34, 0x65, 0x30, 0x32, 0x30, 0x63, 0x31, 0x35, 0x61, 0x36, 0x39, 0x34, 0x33, 0x64, 0x61, 0x31, 0x39, 0x32, 0x64, 0x66, 0x65, 0x33, 0x32, 0x39, 0x33, 0x32, 0x61, 0x62, 0x32, 0x36, 0x66, 0x33, 0x66, 0x61, 0x62, 0x34, 0x64, 0x38, 0x64, 0x34, 0x37, 0x63, 0x64, 0x63, 0x30, 0x63, 0x31, 0x65, 0x31, 0x66, 0x66, 0x63, 0x62, 0x32, 0x32, 0x62, 0x33, 0x34, 0x38, 0x61, 0x63, 0x35, 0x66, 0x33, 0x31, 0x35, 0x36, 0x64, 0x34, 0x66, 0x36, 0x64, 0x63, 0x36, 0x65, 0x66, 0x38, 0x63, 0x30, 0x66, 0x33, 0x34, 0x39, 0x65, 0x38, 0x33, 0x34, 0x65, 0x64, 0x39, 0x61, 0x30, 0x61, 0x39, 0x61, 0x63, 0x34, 0x34, 0x66, 0x32, 0x63, 0x31, 0x63, 0x35, 0x31, 0x61, 0x63, 0x39, 0x38, 0x66, 0x64, 0x64, 0x37, 0x31, 0x38, 0x65, 0x63, 0x37, 0x39, 0x65, 0x63, 0x36, 0x36, 0x31, 0x37, 0x32, 0x66, 0x64, 0x66, 0x32, 0x65, 0x36, 0x37, 0x65, 0x62, 0x64, 0x36, 0x63, 0x35, 0x30, 0x35, 0x61, 0x63, 0x35, 0x35, 0x64, 0x33, 0x37, 0x38, 0x65, 0x34, 0x32, 0x31, 0x39, 0x39, 0x32, 0x35, 0x37, 0x32, 0x35, 0x63, 0x38, 0x38, 0x37, 0x32, 0x64, 0x66, 0x61, 0x63, 0x66, 0x31, 0x34, 0x39, 0x63, 0x33, 0x34, 0x33, 0x35, 0x61, 0x37, 0x31, 0x39, 0x39, 0x62, 0x36, 0x61, 0x36, 0x32, 0x62, 0x64, 0x63, 0x64, 0x33, 0x31, 0x36, 0x64, 0x61, 0x38, 0x63, 0x34, 0x36, 0x37, 0x65, 0x34, 0x65, 0x30, 0x65, 0x33, 0x31, 0x36, 0x37, 0x35, 0x37, 0x37, 0x33, 0x38, 0x38, 0x64, 0x63, 0x38, 0x31, 0x39, 0x39, 0x63, 0x36, 0x31, 0x35, 0x37, 0x32, 0x61, 0x65, 0x34, 0x66, 0x30, 0x31, 0x64, 0x38, 0x63, 0x32, 0x66, 0x38, 0x61, 0x39, 0x38, 0x37, 0x34, 0x30, 0x64, 0x34, 0x34, 0x64, 0x33, 0x61, 0x35, 0x38, 0x34, 0x63, 0x38, 0x63, 0x61, 0x34, 0x35, 0x39, 0x31, 0x65, 0x66, 0x64, 0x39, 0x30, 0x35, 0x32, 0x37, 0x35, 0x65, 0x30, 0x65, 0x65, 0x32, 0x62, 0x39, 0x62, 0x39, 0x38, 0x65, 0x36, 0x31, 0x63, 0x66, 0x34, 0x66, 0x39, 0x36, 0x64, 0x33, 0x64, 0x61, 0x33, 0x65, 0x37, 0x63, 0x38, 0x61, 0x36, 0x33, 0x36, 0x38, 0x37, 0x62, 0x62, 0x34, 0x63, 0x31, 0x65, 0x64, 0x66, 0x36, 0x33, 0x36, 0x64, 0x66, 0x32, 0x33, 0x65, 0x39, 0x31, 0x66, 0x63, 0x37, 0x31, 0x63, 0x33, 0x63, 0x65, 0x37, 0x61, 0x32, 0x66, 0x65, 0x33, 0x38, 0x34, 0x31, 0x36, 0x62, 0x62, 0x33, 0x31, 0x61, 0x39, 0x37, 0x34, 0x34, 0x65, 0x33, 0x39, 0x35, 0x33, 0x63, 0x63, 0x37, 0x66, 0x61, 0x63, 0x36, 0x63, 0x39, 0x31, 0x31, 0x39, 0x39, 0x37, 0x39, 0x38, 0x39, 0x30, 0x36, 0x62, 0x62, 0x35, 0x62, 0x35, 0x36, 0x64, 0x63, 0x63, 0x33, 0x36, 0x64, 0x37, 0x34, 0x34, 0x37, 0x32, 0x32, 0x35, 0x37, 0x61, 0x66, 0x63, 0x30, 0x65, 0x34, 0x31, 0x63, 0x63, 0x63, 0x65, 0x32, 0x64, 0x63, 0x63, 0x64, 0x35, 0x64, 0x61, 0x31, 0x36, 0x62, 0x61, 0x30, 0x34, 0x37, 0x34, 0x61, 0x34, 0x35, 0x33, 0x66, 0x65, 0x30, 0x37, 0x36, 0x61, 0x31, 0x36, 0x65, 0x35, 0x61, 0x66, 0x61, 0x36, 0x61, 0x65, 0x65, 0x39, 0x61, 0x35, 0x66, 0x34, 0x34, 0x37, 0x62, 0x66, 0x63, 0x34, 0x36, 0x36, 0x62, 0x65, 0x30, 0x31, 0x31, 0x32, 0x37, 0x61, 0x34, 0x61, 0x65, 0x30, 0x31, 0x66, 0x31, 0x30, 0x33, 0x39, 0x33, 0x34, 0x39, 0x61, 0x35, 0x64, 0x33, 0x33, 0x37, 0x32, 0x33, 0x30, 0x34, 0x35, 0x35, 0x33, 0x39, 0x61, 0x38, 0x37, 0x63, 0x37, 0x38, 0x39, 0x38, 0x64, 0x33, 0x66, 0x35, 0x63, 0x63, 0x31, 0x35, 0x62, 0x61, 0x38, 0x66, 0x33, 0x38, 0x63, 0x37, 0x35, 0x61, 0x39, 0x34, 0x39, 0x30, 0x31, 0x30, 0x61, 0x32, 0x61, 0x37, 0x65, 0x65, 0x30, 0x65, 0x33, 0x30, 0x65, 0x61, 0x63, 0x33, 0x38, 0x38, 0x32, 0x66, 0x30, 0x36, 0x37, 0x33, 0x63, 0x37, 0x32, 0x61, 0x62, 0x66, 0x66, 0x32, 0x34, 0x37, 0x39, 0x66, 0x36, 0x30, 0x30, 0x38, 0x36, 0x39, 0x65, 0x39, 0x38, 0x64, 0x36, 0x37, 0x63, 0x64, 0x66, 0x34, 0x37, 0x64, 0x37, 0x36, 0x65, 0x30, 0x37, 0x33, 0x35, 0x62, 0x38, 0x64, 0x34, 0x31, 0x66, 0x63, 0x30, 0x33, 0x38, 0x39, 0x39, 0x39, 0x62, 0x39, 0x33, 0x64, 0x35, 0x37, 0x34, 0x31, 0x61, 0x34, 0x36, 0x65, 0x33, 0x36, 0x62, 0x37, 0x32, 0x34, 0x65, 0x61, 0x64, 0x63, 0x62, 0x35, 0x36, 0x39, 0x62, 0x63, 0x64, 0x35, 0x63, 0x34, 0x62, 0x64, 0x64, 0x35, 0x30, 0x63, 0x61, 0x38, 0x64, 0x62, 0x36, 0x37, 0x39, 0x30, 0x35, 0x38, 0x33, 0x33, 0x31, 0x37, 0x66, 0x36, 0x62, 0x33, 0x36, 0x66, 0x33, 0x65, 0x36, 0x37, 0x61, 0x35, 0x38, 0x33, 0x38, 0x37, 0x31, 0x38, 0x33, 0x32, 0x35, 0x64, 0x63, 0x38, 0x35, 0x38, 0x34, 0x37, 0x32, 0x33, 0x66, 0x37, 0x64, 0x32, 0x62, 0x35, 0x65, 0x66, 0x30, 0x61, 0x31, 0x32, 0x61, 0x36, 0x36, 0x65, 0x63, 0x31, 0x31, 0x64, 0x33, 0x61, 0x32, 0x62, 0x63, 0x39, 0x63, 0x39, 0x33, 0x38, 0x33, 0x66, 0x33, 0x34, 0x66, 0x63, 0x30, 0x61, 0x37, 0x65, 0x61, 0x33, 0x36, 0x30, 0x63, 0x35, 0x32, 0x30, 0x37, 0x65, 0x36, 0x32, 0x62, 0x34, 0x33, 0x39, 0x39, 0x37, 0x66, 0x34, 0x34, 0x36, 0x64, 0x66, 0x66, 0x31, 0x31, 0x39, 0x33, 0x34, 0x35, 0x35, 0x34, 0x62, 0x35, 0x32, 0x33, 0x64, 0x65, 0x35, 0x36, 0x32, 0x61, 0x61, 0x33, 0x66, 0x62, 0x32, 0x37, 0x35, 0x31, 0x65, 0x37, 0x30, 0x32, 0x34, 0x38, 0x63, 0x65, 0x31, 0x36, 0x63, 0x38, 0x35, 0x63, 0x33, 0x31, 0x61, 0x36, 0x31, 0x32, 0x39, 0x32, 0x63, 0x30, 0x38, 0x66, 0x34, 0x32, 0x34, 0x63, 0x34, 0x63, 0x35, 0x38, 0x37, 0x32, 0x62, 0x34, 0x31, 0x32, 0x33, 0x31, 0x61, 0x39, 0x34, 0x32, 0x64, 0x38, 0x38, 0x39, 0x38, 0x39, 0x64, 0x36, 0x36, 0x66, 0x65, 0x62, 0x33, 0x63, 0x31, 0x30, 0x37, 0x30, 0x63, 0x33, 0x62, 0x62, 0x30, 0x30, 0x30, 0x35, 0x62, 0x34, 0x65, 0x35, 0x30, 0x39, 0x35, 0x64, 0x36, 0x32, 0x36, 0x39, 0x34, 0x33, 0x38, 0x64, 0x32, 0x34, 0x61, 0x35, 0x37, 0x32, 0x33, 0x64, 0x66, 0x65, 0x37, 0x32, 0x65, 0x31, 0x65, 0x32, 0x66, 0x62, 0x66, 0x37, 0x64, 0x64, 0x30, 0x30, 0x61, 0x35, 0x38, 0x39, 0x62, 0x65, 0x30, 0x34, 0x34, 0x31, 0x34, 0x63, 0x62, 0x32, 0x62, 0x36, 0x30, 0x66, 0x36, 0x64, 0x34, 0x31, 0x61, 0x32, 0x32, 0x38, 0x61, 0x65, 0x61, 0x39, 0x35, 0x31, 0x31, 0x65, 0x63, 0x32, 0x36, 0x31, 0x65, 0x61, 0x35, 0x34, 0x34, 0x61, 0x34, 0x65, 0x35, 0x61, 0x61, 0x31, 0x34, 0x63, 0x36, 0x30, 0x39, 0x66, 0x32, 0x63, 0x61, 0x35, 0x35, 0x35, 0x31, 0x37, 0x36, 0x31, 0x63, 0x31, 0x65, 0x65, 0x34, 0x66, 0x65, 0x34, 0x62, 0x63, 0x65, 0x65, 0x61, 0x32, 0x31, 0x61, 0x37, 0x65, 0x32, 0x32, 0x36, 0x33, 0x34, 0x39, 0x64, 0x37, 0x34, 0x65, 0x66, 0x66, 0x38, 0x63, 0x34, 0x32, 0x30, 0x64, 0x31, 0x64, 0x65, 0x38, 0x61, 0x37, 0x39, 0x63, 0x34, 0x31, 0x38, 0x65, 0x35, 0x62, 0x33, 0x36, 0x39, 0x32, 0x66, 0x39, 0x34, 0x38, 0x30, 0x35, 0x38, 0x64, 0x32, 0x64, 0x30, 0x63, 0x61, 0x65, 0x63, 0x32, 0x32, 0x30, 0x63, 0x64, 0x35, 0x30, 0x30, 0x32, 0x34, 0x34, 0x65, 0x32, 0x35, 0x39, 0x64, 0x39, 0x39, 0x39, 0x33, 0x65, 0x33, 0x62, 0x30, 0x35, 0x33, 0x66, 0x61, 0x39, 0x64, 0x37, 0x32, 0x35, 0x38, 0x62, 0x66, 0x33, 0x39, 0x36, 0x39, 0x39, 0x32, 0x38, 0x37, 0x32, 0x66, 0x37, 0x31, 0x36, 0x31, 0x31, 0x33, 0x61, 0x62, 0x32, 0x61, 0x35, 0x64, 0x62, 0x66, 0x36, 0x63, 0x37, 0x36, 0x30, 0x38, 0x65, 0x37, 0x31, 0x36, 0x63, 0x31, 0x64, 0x32, 0x66, 0x33, 0x35, 0x64, 0x35, 0x64, 0x37, 0x64, 0x65, 0x32, 0x34, 0x62, 0x66, 0x66, 0x33, 0x65, 0x39, 0x34, 0x32, 0x30, 0x63, 0x30, 0x39, 0x35, 0x33, 0x37, 0x30, 0x66, 0x33, 0x38, 0x34, 0x63, 0x38, 0x37, 0x32, 0x31, 0x36, 0x37, 0x36, 0x61, 0x38, 0x66, 0x32, 0x35, 0x32, 0x64, 0x32, 0x30, 0x32, 0x39, 0x34, 0x65, 0x31, 0x61, 0x64, 0x34, 0x36, 0x38, 0x63, 0x36, 0x31, 0x33, 0x36, 0x62, 0x39, 0x63, 0x62, 0x38, 0x37, 0x32, 0x66, 0x65, 0x39, 0x38, 0x66, 0x38, 0x35, 0x38, 0x38, 0x65, 0x39, 0x64, 0x65, 0x34, 0x37, 0x36, 0x38, 0x34, 0x35, 0x39, 0x39, 0x37, 0x66, 0x61, 0x32, 0x32, 0x33, 0x36, 0x61, 0x36, 0x62, 0x65, 0x61, 0x66, 0x66, 0x62, 0x39, 0x38, 0x33, 0x62, 0x34, 0x64, 0x63, 0x61, 0x31, 0x62, 0x32, 0x61, 0x39, 0x32, 0x38, 0x66, 0x34, 0x34, 0x63, 0x33, 0x35, 0x34, 0x62, 0x63, 0x30, 0x31, 0x65, 0x36, 0x35, 0x63, 0x64, 0x31, 0x61, 0x33, 0x34, 0x62, 0x34, 0x66, 0x35, 0x38, 0x66, 0x34, 0x30, 0x30, 0x61, 0x34, 0x30, 0x37, 0x38, 0x36, 0x32, 0x33, 0x33, 0x38, 0x62, 0x35, 0x66, 0x64, 0x33, 0x66, 0x62, 0x31, 0x35, 0x38, 0x35, 0x66, 0x39, 0x36, 0x34, 0x38, 0x62, 0x66, 0x39, 0x66, 0x34, 0x30, 0x34, 0x30, 0x61, 0x33, 0x62, 0x36, 0x63, 0x37, 0x33, 0x32, 0x31, 0x32, 0x38, 0x39, 0x36, 0x61, 0x37, 0x34, 0x38, 0x62, 0x35, 0x38, 0x35, 0x38, 0x39, 0x64, 0x65, 0x31, 0x61, 0x35, 0x39, 0x34, 0x36, 0x31, 0x33, 0x66, 0x65, 0x36, 0x38, 0x35, 0x32, 0x62, 0x39, 0x32, 0x62, 0x63, 0x61, 0x31, 0x65, 0x65, 0x64, 0x62, 0x66, 0x64, 0x32, 0x39, 0x65, 0x34, 0x66, 0x64, 0x39, 0x66, 0x64, 0x66, 0x66, 0x65, 0x38, 0x39, 0x30, 0x66, 0x66, 0x64, 0x61, 0x37, 0x63, 0x61, 0x34, 0x37, 0x31, 0x62, 0x65, 0x35, 0x64, 0x30, 0x65, 0x30, 0x37, 0x34, 0x39, 0x33, 0x64, 0x66, 0x39, 0x65, 0x32, 0x34, 0x31, 0x65, 0x62, 0x36, 0x38, 0x37, 0x32, 0x33, 0x61, 0x39, 0x65, 0x37, 0x32, 0x37, 0x32, 0x38, 0x32, 0x37, 0x35, 0x37, 0x66, 0x64, 0x65, 0x36, 0x63, 0x39, 0x66, 0x61, 0x66, 0x66, 0x62, 0x61, 0x63, 0x33, 0x37, 0x35, 0x66, 0x65, 0x62, 0x61, 0x35, 0x31, 0x31, 0x64, 0x62, 0x31, 0x38, 0x34, 0x38, 0x62, 0x63, 0x38, 0x32, 0x34, 0x62, 0x33, 0x33, 0x33, 0x34, 0x32, 0x34, 0x31, 0x38, 0x39, 0x64, 0x37, 0x39, 0x62, 0x35, 0x64, 0x62, 0x30, 0x63, 0x62, 0x61, 0x35, 0x36, 0x66, 0x38, 0x64, 0x38, 0x35, 0x63, 0x37, 0x32, 0x61, 0x31, 0x35, 0x34, 0x65, 0x39, 0x30, 0x35, 0x37, 0x39, 0x64, 0x62, 0x37, 0x65, 0x36, 0x33, 0x31, 0x35, 0x31, 0x34, 0x33, 0x61, 0x34, 0x66, 0x66, 0x30, 0x39, 0x61, 0x61, 0x30, 0x34, 0x31, 0x38, 0x32, 0x32, 0x37, 0x65, 0x66, 0x30, 0x66, 0x33, 0x38, 0x33, 0x37, 0x35, 0x66, 0x62, 0x63, 0x66, 0x65, 0x32, 0x38, 0x64, 0x30, 0x33, 0x65, 0x38, 0x61, 0x64, 0x37, 0x30, 0x31, 0x39, 0x38, 0x62, 0x65, 0x64, 0x35, 0x63, 0x33, 0x64, 0x30, 0x32, 0x34, 0x61, 0x38, 0x63, 0x38, 0x66, 0x31, 0x32, 0x31, 0x64, 0x36, 0x36, 0x34, 0x33, 0x31, 0x61, 0x65, 0x32, 0x65, 0x35, 0x34, 0x34, 0x64, 0x35, 0x30, 0x62, 0x62, 0x64, 0x64, 0x33, 0x30, 0x31, 0x32, 0x35, 0x34, 0x31, 0x64, 0x62, 0x37, 0x30, 0x33, 0x39, 0x39, 0x31, 0x35, 0x32, 0x31, 0x33, 0x33, 0x65, 0x62, 0x66, 0x62, 0x30, 0x32, 0x38, 0x33, 0x37, 0x37, 0x31, 0x61, 0x64, 0x61, 0x33, 0x32, 0x63, 0x66, 0x62, 0x30, 0x30, 0x34, 0x30, 0x31, 0x33, 0x32, 0x34, 0x61, 0x65, 0x37, 0x35, 0x30, 0x35, 0x30, 0x39, 0x35, 0x64, 0x64, 0x33, 0x33, 0x39, 0x31, 0x35, 0x32, 0x33, 0x30, 0x65, 0x62, 0x34, 0x62, 0x64, 0x39, 0x65, 0x61, 0x39, 0x36, 0x64, 0x36, 0x39, 0x63, 0x37, 0x32, 0x38, 0x38, 0x30, 0x65, 0x32, 0x38, 0x64, 0x61, 0x62, 0x65, 0x35, 0x32, 0x30, 0x38, 0x63, 0x65, 0x36, 0x38, 0x35, 0x62, 0x38, 0x32, 0x61, 0x62, 0x36, 0x63, 0x65, 0x30, 0x65, 0x30, 0x31, 0x37, 0x30, 0x65, 0x32, 0x35, 0x65, 0x32, 0x64, 0x61, 0x39, 0x37, 0x66, 0x66, 0x32, 0x61, 0x34, 0x39, 0x66, 0x36, 0x61, 0x61, 0x33, 0x37, 0x66, 0x36, 0x65, 0x65, 0x30, 0x64, 0x39, 0x35, 0x33, 0x37, 0x62, 0x63, 0x32, 0x66, 0x38, 0x35, 0x38, 0x65, 0x61, 0x65, 0x61, 0x61, 0x31, 0x61, 0x63, 0x66, 0x34, 0x62, 0x66, 0x62, 0x36, 0x61, 0x38, 0x64, 0x64, 0x66, 0x30, 0x38, 0x39, 0x34, 0x33, 0x63, 0x66, 0x37, 0x36, 0x33, 0x36, 0x63, 0x65, 0x61, 0x39, 0x35, 0x64, 0x31, 0x33, 0x31, 0x65, 0x30, 0x39, 0x65, 0x37, 0x31, 0x35, 0x37, 0x39, 0x64, 0x30, 0x37, 0x63, 0x31, 0x38, 0x39, 0x37, 0x32, 0x34, 0x65, 0x65, 0x66, 0x36, 0x32, 0x66, 0x39, 0x63, 0x39, 0x34, 0x63, 0x62, 0x62, 0x66, 0x63, 0x34, 0x37, 0x36, 0x36, 0x34, 0x30, 0x33, 0x64, 0x33, 0x62, 0x35, 0x66, 0x64, 0x66, 0x62, 0x30, 0x37, 0x61, 0x63, 0x30, 0x39, 0x36, 0x39, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x38, 0x30, 0x36, 0x63, 0x31, 0x63, 0x65, 0x64, 0x61, 0x33, 0x61, 0x34, 0x65, 0x39, 0x39, 0x65, 0x63, 0x37, 0x32, 0x65, 0x62, 0x34, 0x33, 0x64, 0x32, 0x65, 0x36, 0x39, 0x62, 0x61, 0x62, 0x64, 0x66, 0x33, 0x31, 0x31, 0x37, 0x36, 0x30, 0x62, 0x37, 0x37, 0x35, 0x34, 0x37, 0x33, 0x35, 0x39, 0x38, 0x62, 0x34, 0x35, 0x65, 0x37, 0x64, 0x64, 0x36, 0x32, 0x33, 0x64, 0x62, 0x65, 0x65, 0x31, 0x37, 0x64, 0x64, 0x63, 0x30, 0x62, 0x61, 0x39, 0x39, 0x61, 0x33, 0x32, 0x62, 0x65, 0x37, 0x32, 0x63, 0x37, 0x32, 0x35, 0x34, 0x30, 0x36, 0x30, 0x31, 0x37, 0x34, 0x30, 0x34, 0x34, 0x62, 0x39, 0x65, 0x39, 0x34, 0x33, 0x32, 0x38, 0x33, 0x31, 0x33, 0x33, 0x65, 0x33, 0x32, 0x36, 0x65, 0x64, 0x61, 0x34, 0x62, 0x30, 0x36, 0x36, 0x30, 0x30, 0x61, 0x36, 0x39, 0x32, 0x66, 0x38, 0x61, 0x34, 0x64, 0x62, 0x36, 0x37, 0x66, 0x62, 0x33, 0x66, 0x35, 0x36, 0x30, 0x65, 0x65, 0x31, 0x65, 0x66, 0x35, 0x37, 0x32, 0x65, 0x65, 0x39, 0x37, 0x65, 0x31, 0x35, 0x30, 0x32, 0x34, 0x36, 0x34, 0x30, 0x63, 0x36, 0x36, 0x33, 0x37, 0x30, 0x39, 0x37, 0x30, 0x65, 0x39, 0x39, 0x39, 0x62, 0x62, 0x65, 0x30, 0x39, 0x65, 0x32, 0x63, 0x33, 0x64, 0x35, 0x63, 0x31, 0x35, 0x34, 0x32, 0x34, 0x35, 0x62, 0x65, 0x34, 0x66, 0x61, 0x36, 0x30, 0x32, 0x33, 0x61, 0x33, 0x63, 0x62, 0x32, 0x35, 0x36, 0x31, 0x30, 0x37, 0x32, 0x62, 0x39, 0x36, 0x37, 0x39, 0x37, 0x65, 0x65, 0x31, 0x30, 0x36, 0x65, 0x64, 0x39, 0x39, 0x62, 0x64, 0x64, 0x34, 0x65, 0x61, 0x30, 0x66, 0x36, 0x66, 0x37, 0x64, 0x35, 0x35, 0x31, 0x30, 0x36, 0x66, 0x64, 0x36, 0x61, 0x64, 0x31, 0x35, 0x36, 0x30, 0x35, 0x63, 0x33, 0x35, 0x65, 0x31, 0x36, 0x35, 0x64, 0x31, 0x63, 0x65, 0x30, 0x38, 0x33, 0x38, 0x30, 0x35, 0x36, 0x65, 0x37, 0x34, 0x61, 0x36, 0x36, 0x61, 0x30, 0x32, 0x38, 0x30, 0x61, 0x62, 0x66, 0x31, 0x38, 0x36, 0x65, 0x65, 0x65, 0x62, 0x31, 0x31, 0x34, 0x38, 0x64, 0x38, 0x33, 0x66, 0x35, 0x63, 0x38, 0x61, 0x31, 0x37, 0x38, 0x62, 0x39, 0x35, 0x32, 0x33, 0x37, 0x35, 0x34, 0x35, 0x30, 0x35, 0x61, 0x33, 0x35, 0x30, 0x38, 0x32, 0x63, 0x62, 0x37, 0x30, 0x63, 0x39, 0x35, 0x65, 0x39, 0x32, 0x64, 0x34, 0x62, 0x30, 0x39, 0x30, 0x37, 0x65, 0x38, 0x39, 0x62, 0x65, 0x32, 0x33, 0x64, 0x65, 0x66, 0x31, 0x37, 0x64, 0x36, 0x30, 0x38, 0x62, 0x30, 0x65, 0x62, 0x65, 0x64, 0x66, 0x38, 0x39, 0x64, 0x66, 0x37, 0x62, 0x66, 0x31, 0x33, 0x34, 0x64, 0x62, 0x32, 0x61, 0x38, 0x38, 0x32, 0x63, 0x63, 0x33, 0x32, 0x37, 0x33, 0x35, 0x33, 0x66, 0x33, 0x33, 0x64, 0x66, 0x30, 0x33, 0x31, 0x30, 0x31, 0x30, 0x33, 0x37, 0x32, 0x31, 0x33, 0x39, 0x66, 0x39, 0x33, 0x33, 0x35, 0x39, 0x31, 0x34, 0x65, 0x61, 0x61, 0x35, 0x34, 0x38, 0x62, 0x36, 0x33, 0x63, 0x63, 0x39, 0x63, 0x65, 0x63, 0x64, 0x33, 0x64, 0x31, 0x65, 0x65, 0x61, 0x38, 0x38, 0x66, 0x39, 0x65, 0x62, 0x31, 0x64, 0x31, 0x64, 0x66, 0x62, 0x65, 0x32, 0x38, 0x30, 0x32, 0x35, 0x62, 0x34, 0x31, 0x61, 0x39, 0x32, 0x35, 0x35, 0x34, 0x37, 0x30, 0x31, 0x39, 0x39, 0x32, 0x66, 0x36, 0x61, 0x63, 0x61, 0x39, 0x65, 0x65, 0x36, 0x64, 0x33, 0x66, 0x62, 0x33, 0x39, 0x38, 0x65, 0x62, 0x33, 0x36, 0x64, 0x39, 0x35, 0x36, 0x33, 0x36, 0x66, 0x63, 0x37, 0x32, 0x62, 0x65, 0x30, 0x39, 0x35, 0x64, 0x37, 0x33, 0x31, 0x66, 0x66, 0x32, 0x66, 0x30, 0x64, 0x37, 0x61, 0x35, 0x33, 0x63, 0x35, 0x62, 0x62, 0x65, 0x31, 0x39, 0x30, 0x66, 0x64, 0x64, 0x37, 0x32, 0x36, 0x39, 0x32, 0x30, 0x33, 0x31, 0x61, 0x35, 0x31, 0x34, 0x37, 0x66, 0x36, 0x31, 0x62, 0x38, 0x65, 0x31, 0x62, 0x31, 0x37, 0x31, 0x37, 0x32, 0x30, 0x37, 0x35, 0x35, 0x39, 0x65, 0x66, 0x33, 0x39, 0x37, 0x61, 0x63, 0x34, 0x65, 0x32, 0x39, 0x30, 0x31, 0x66, 0x33, 0x30, 0x62, 0x62, 0x62, 0x38, 0x64, 0x37, 0x36, 0x66, 0x33, 0x34, 0x31, 0x66, 0x32, 0x36, 0x33, 0x66, 0x62, 0x37, 0x32, 0x62, 0x31, 0x38, 0x31, 0x34, 0x35, 0x32, 0x64, 0x62, 0x36, 0x61, 0x37, 0x66, 0x65, 0x65, 0x64, 0x61, 0x61, 0x35, 0x33, 0x64, 0x30, 0x64, 0x62, 0x33, 0x35, 0x39, 0x36, 0x66, 0x62, 0x63, 0x62, 0x38, 0x64, 0x63, 0x36, 0x30, 0x30, 0x64, 0x32, 0x35, 0x38, 0x31, 0x64, 0x36, 0x64, 0x33, 0x64, 0x33, 0x37, 0x38, 0x33, 0x32, 0x39, 0x36, 0x63, 0x31, 0x34, 0x61, 0x63, 0x66, 0x65, 0x37, 0x32, 0x66, 0x33, 0x34, 0x30, 0x61, 0x36, 0x64, 0x62, 0x35, 0x31, 0x64, 0x31, 0x38, 0x63, 0x34, 0x36, 0x38, 0x65, 0x62, 0x39, 0x37, 0x63, 0x65, 0x64, 0x31, 0x37, 0x37, 0x39, 0x35, 0x38, 0x62, 0x37, 0x31, 0x34, 0x33, 0x62, 0x38, 0x63, 0x61, 0x36, 0x35, 0x32, 0x39, 0x31, 0x37, 0x30, 0x37, 0x33, 0x65, 0x64, 0x35, 0x64, 0x33, 0x30, 0x61, 0x36, 0x34, 0x62, 0x61, 0x32, 0x66, 0x31, 0x33, 0x30, 0x64, 0x30, 0x63, 0x62, 0x30, 0x36, 0x61, 0x36, 0x32, 0x39, 0x39, 0x38, 0x64, 0x38, 0x62, 0x30, 0x31, 0x35, 0x38, 0x36, 0x32, 0x66, 0x36, 0x30, 0x36, 0x34, 0x61, 0x61, 0x63, 0x61, 0x30, 0x36, 0x32, 0x63, 0x63, 0x33, 0x62, 0x38, 0x34, 0x63, 0x62, 0x62, 0x31, 0x65, 0x31, 0x62, 0x34, 0x39, 0x39, 0x35, 0x30, 0x30, 0x64, 0x36, 0x31, 0x33, 0x38, 0x63, 0x34, 0x63, 0x63, 0x34, 0x32, 0x61, 0x37, 0x35, 0x35, 0x31, 0x35, 0x33, 0x34, 0x66, 0x37, 0x34, 0x63, 0x61, 0x62, 0x65, 0x33, 0x62, 0x36, 0x38, 0x66, 0x65, 0x61, 0x32, 0x63, 0x62, 0x64, 0x63, 0x36, 0x30, 0x33, 0x35, 0x63, 0x64, 0x36, 0x37, 0x31, 0x65, 0x34, 0x37, 0x35, 0x38, 0x30, 0x33, 0x61, 0x38, 0x38, 0x61, 0x34, 0x32, 0x63, 0x36, 0x39, 0x39, 0x31, 0x62, 0x61, 0x32, 0x37, 0x61, 0x63, 0x33, 0x30, 0x65, 0x37, 0x32, 0x63, 0x37, 0x34, 0x38, 0x32, 0x62, 0x30, 0x30, 0x33, 0x66, 0x65, 0x62, 0x65, 0x38, 0x62, 0x65, 0x36, 0x64, 0x62, 0x30, 0x66, 0x65, 0x30, 0x39, 0x36, 0x34, 0x61, 0x39, 0x34, 0x39, 0x61, 0x31, 0x38, 0x36, 0x33, 0x39, 0x63, 0x30, 0x64, 0x64, 0x33, 0x30, 0x62, 0x30, 0x30, 0x36, 0x31, 0x62, 0x35, 0x64, 0x66, 0x64, 0x37, 0x62, 0x63, 0x36, 0x62, 0x32, 0x63, 0x65, 0x33, 0x34, 0x37, 0x32, 0x36, 0x37, 0x34, 0x38, 0x39, 0x38, 0x31, 0x61, 0x33, 0x30, 0x35, 0x30, 0x30, 0x36, 0x30, 0x33, 0x64, 0x63, 0x30, 0x34, 0x62, 0x32, 0x63, 0x61, 0x36, 0x34, 0x66, 0x61, 0x39, 0x31, 0x65, 0x66, 0x34, 0x66, 0x64, 0x66, 0x65, 0x61, 0x31, 0x37, 0x30, 0x61, 0x66, 0x66, 0x34, 0x38, 0x35, 0x30, 0x37, 0x65, 0x63, 0x39, 0x64, 0x36, 0x33, 0x63, 0x61, 0x38, 0x31, 0x31, 0x61, 0x34, 0x35, 0x63, 0x34, 0x64, 0x32, 0x30, 0x31, 0x33, 0x61, 0x66, 0x32, 0x63, 0x63, 0x32, 0x61, 0x64, 0x62, 0x30, 0x66, 0x63, 0x37, 0x64, 0x32, 0x33, 0x34, 0x64, 0x33, 0x62, 0x63, 0x34, 0x38, 0x62, 0x64, 0x37, 0x62, 0x34, 0x62, 0x38, 0x32, 0x33, 0x34, 0x30, 0x31, 0x62, 0x36, 0x32, 0x64, 0x62, 0x35, 0x31, 0x62, 0x36, 0x64, 0x34, 0x30, 0x31, 0x65, 0x37, 0x34, 0x32, 0x37, 0x31, 0x31, 0x64, 0x37, 0x32, 0x66, 0x31, 0x31, 0x32, 0x32, 0x34, 0x66, 0x32, 0x61, 0x30, 0x65, 0x37, 0x34, 0x36, 0x38, 0x66, 0x61, 0x61, 0x66, 0x62, 0x63, 0x64, 0x31, 0x61, 0x31, 0x30, 0x33, 0x30, 0x31, 0x65, 0x63, 0x37, 0x65, 0x36, 0x38, 0x37, 0x38, 0x35, 0x32, 0x36, 0x35, 0x65, 0x64, 0x36, 0x65, 0x39, 0x32, 0x38, 0x64, 0x64, 0x65, 0x36, 0x38, 0x61, 0x64, 0x30, 0x35, 0x65, 0x36, 0x65, 0x36, 0x31, 0x37, 0x32, 0x31, 0x34, 0x65, 0x30, 0x39, 0x30, 0x37, 0x64, 0x38, 0x35, 0x34, 0x61, 0x39, 0x32, 0x66, 0x62, 0x34, 0x37, 0x36, 0x34, 0x39, 0x33, 0x65, 0x35, 0x61, 0x65, 0x37, 0x35, 0x37, 0x30, 0x36, 0x32, 0x38, 0x34, 0x66, 0x65, 0x37, 0x39, 0x33, 0x63, 0x37, 0x62, 0x39, 0x61, 0x62, 0x63, 0x62, 0x64, 0x31, 0x36, 0x62, 0x34, 0x64, 0x61, 0x61, 0x38, 0x63, 0x30, 0x61, 0x36, 0x38, 0x33, 0x36, 0x39, 0x62, 0x65, 0x36, 0x62, 0x31, 0x64, 0x61, 0x38, 0x61, 0x38, 0x63, 0x34, 0x62, 0x33, 0x34, 0x33, 0x64, 0x35, 0x61, 0x63, 0x63, 0x37, 0x31, 0x31, 0x36, 0x62, 0x34, 0x35, 0x36, 0x61, 0x65, 0x61, 0x63, 0x35, 0x66, 0x33, 0x35, 0x62, 0x32, 0x63, 0x62, 0x66, 0x39, 0x65, 0x33, 0x34, 0x37, 0x37, 0x66, 0x36, 0x63, 0x61, 0x62, 0x39, 0x63, 0x33, 0x62, 0x36, 0x62, 0x66, 0x34, 0x39, 0x37, 0x32, 0x38, 0x61, 0x63, 0x37, 0x36, 0x37, 0x32, 0x35, 0x66, 0x65, 0x33, 0x39, 0x32, 0x64, 0x63, 0x61, 0x31, 0x36, 0x34, 0x37, 0x39, 0x37, 0x62, 0x31, 0x37, 0x36, 0x35, 0x33, 0x31, 0x64, 0x35, 0x62, 0x38, 0x38, 0x39, 0x38, 0x33, 0x38, 0x65, 0x33, 0x32, 0x63, 0x34, 0x39, 0x64, 0x33, 0x62, 0x31, 0x63, 0x65, 0x66, 0x64, 0x34, 0x65, 0x38, 0x34, 0x39, 0x34, 0x66, 0x31, 0x35, 0x38, 0x37, 0x32, 0x32, 0x39, 0x38, 0x61, 0x64, 0x61, 0x37, 0x66, 0x61, 0x35, 0x66, 0x63, 0x66, 0x35, 0x34, 0x37, 0x39, 0x38, 0x38, 0x62, 0x38, 0x65, 0x36, 0x64, 0x36, 0x33, 0x35, 0x31, 0x38, 0x32, 0x30, 0x62, 0x37, 0x62, 0x33, 0x39, 0x30, 0x66, 0x63, 0x30, 0x65, 0x64, 0x31, 0x62, 0x37, 0x63, 0x61, 0x61, 0x66, 0x63, 0x66, 0x63, 0x37, 0x64, 0x33, 0x34, 0x32, 0x64, 0x31, 0x64, 0x66, 0x35, 0x37, 0x32, 0x37, 0x61, 0x65, 0x35, 0x35, 0x62, 0x31, 0x39, 0x34, 0x64, 0x36, 0x61, 0x31, 0x33, 0x30, 0x31, 0x36, 0x32, 0x32, 0x37, 0x39, 0x64, 0x64, 0x63, 0x65, 0x39, 0x62, 0x65, 0x66, 0x64, 0x30, 0x64, 0x63, 0x31, 0x39, 0x32, 0x61, 0x35, 0x31, 0x63, 0x35, 0x38, 0x64, 0x63, 0x37, 0x33, 0x61, 0x38, 0x33, 0x32, 0x38, 0x38, 0x65, 0x37, 0x35, 0x38, 0x65, 0x35, 0x37, 0x33, 0x62, 0x30, 0x37, 0x32, 0x33, 0x66, 0x39, 0x31, 0x33, 0x38, 0x39, 0x30, 0x35, 0x61, 0x32, 0x65, 0x62, 0x34, 0x34, 0x63, 0x36, 0x62, 0x39, 0x39, 0x33, 0x33, 0x33, 0x35, 0x34, 0x39, 0x33, 0x34, 0x31, 0x36, 0x37, 0x64, 0x39, 0x61, 0x63, 0x36, 0x39, 0x33, 0x62, 0x65, 0x35, 0x61, 0x30, 0x62, 0x33, 0x64, 0x66, 0x30, 0x64, 0x34, 0x38, 0x62, 0x64, 0x34, 0x35, 0x30, 0x33, 0x30, 0x65, 0x32, 0x34, 0x63, 0x37, 0x32, 0x30, 0x62, 0x34, 0x35, 0x61, 0x31, 0x61, 0x32, 0x61, 0x63, 0x39, 0x36, 0x34, 0x66, 0x65, 0x38, 0x31, 0x39, 0x39, 0x31, 0x37, 0x66, 0x66, 0x61, 0x37, 0x30, 0x34, 0x33, 0x37, 0x66, 0x37, 0x31, 0x30, 0x64, 0x36, 0x62, 0x64, 0x36, 0x39, 0x64, 0x62, 0x64, 0x38, 0x64, 0x39, 0x30, 0x64, 0x61, 0x35, 0x64, 0x66, 0x35, 0x66, 0x31, 0x62, 0x30, 0x30, 0x66, 0x35, 0x33, 0x31, 0x30, 0x37, 0x32, 0x34, 0x62, 0x31, 0x37, 0x64, 0x62, 0x34, 0x33, 0x33, 0x64, 0x33, 0x62, 0x39, 0x61, 0x65, 0x31, 0x31, 0x33, 0x64, 0x34, 0x65, 0x33, 0x31, 0x39, 0x35, 0x31, 0x34, 0x63, 0x64, 0x62, 0x32, 0x35, 0x32, 0x39, 0x38, 0x65, 0x30, 0x33, 0x32, 0x66, 0x32, 0x38, 0x38, 0x62, 0x66, 0x35, 0x38, 0x32, 0x66, 0x36, 0x62, 0x37, 0x39, 0x64, 0x63, 0x62, 0x36, 0x38, 0x66, 0x35, 0x64, 0x33, 0x34, 0x62, 0x65, 0x39, 0x31, 0x37, 0x38, 0x61, 0x36, 0x36, 0x31, 0x37, 0x64, 0x64, 0x35, 0x34, 0x38, 0x32, 0x33, 0x39, 0x63, 0x35, 0x34, 0x66, 0x30, 0x34, 0x34, 0x35, 0x30, 0x63, 0x31, 0x62, 0x37, 0x63, 0x64, 0x37, 0x34, 0x66, 0x66, 0x39, 0x37, 0x61, 0x32, 0x65, 0x38, 0x38, 0x61, 0x66, 0x63, 0x39, 0x62, 0x32, 0x66, 0x65, 0x34, 0x63, 0x36, 0x62, 0x32, 0x65, 0x64, 0x36, 0x30, 0x61, 0x34, 0x33, 0x64, 0x63, 0x39, 0x38, 0x32, 0x62, 0x31, 0x31, 0x30, 0x38, 0x38, 0x62, 0x36, 0x30, 0x62, 0x30, 0x30, 0x36, 0x38, 0x65, 0x34, 0x62, 0x31, 0x66, 0x61, 0x30, 0x62, 0x61, 0x30, 0x38, 0x36, 0x61, 0x65, 0x37, 0x65, 0x63, 0x37, 0x62, 0x66, 0x38, 0x63, 0x33, 0x61, 0x64, 0x33, 0x36, 0x30, 0x36, 0x31, 0x37, 0x38, 0x61, 0x39, 0x32, 0x32, 0x34, 0x35, 0x62, 0x34, 0x38, 0x66, 0x61, 0x37, 0x32, 0x32, 0x65, 0x38, 0x31, 0x35, 0x38, 0x63, 0x66, 0x31, 0x36, 0x39, 0x65, 0x65, 0x39, 0x34, 0x62, 0x31, 0x65, 0x39, 0x33, 0x39, 0x63, 0x32, 0x63, 0x64, 0x34, 0x37, 0x31, 0x34, 0x62, 0x38, 0x36, 0x35, 0x36, 0x32, 0x31, 0x34, 0x61, 0x61, 0x37, 0x66, 0x65, 0x32, 0x39, 0x35, 0x62, 0x31, 0x66, 0x30, 0x64, 0x62, 0x37, 0x66, 0x30, 0x31, 0x61, 0x35, 0x66, 0x65, 0x66, 0x36, 0x35, 0x30, 0x33, 0x66, 0x33, 0x33, 0x34, 0x36, 0x36, 0x37, 0x30, 0x36, 0x66, 0x39, 0x61, 0x35, 0x34, 0x64, 0x32, 0x30, 0x35, 0x31, 0x30, 0x36, 0x32, 0x61, 0x63, 0x61, 0x31, 0x36, 0x37, 0x30, 0x36, 0x35, 0x32, 0x63, 0x62, 0x34, 0x38, 0x66, 0x63, 0x61, 0x32, 0x64, 0x66, 0x32, 0x38, 0x33, 0x65, 0x65, 0x62, 0x36, 0x30, 0x31, 0x31, 0x36, 0x38, 0x34, 0x33, 0x61, 0x38, 0x66, 0x37, 0x33, 0x36, 0x37, 0x32, 0x30, 0x30, 0x33, 0x36, 0x39, 0x61, 0x30, 0x30, 0x66, 0x32, 0x64, 0x37, 0x38, 0x30, 0x31, 0x37, 0x61, 0x31, 0x63, 0x32, 0x61, 0x33, 0x63, 0x61, 0x39, 0x34, 0x36, 0x36, 0x36, 0x63, 0x32, 0x65, 0x37, 0x35, 0x33, 0x30, 0x61, 0x32, 0x36, 0x30, 0x35, 0x38, 0x38, 0x36, 0x37, 0x63, 0x37, 0x32, 0x35, 0x30, 0x39, 0x38, 0x64, 0x63, 0x34, 0x30, 0x64, 0x64, 0x36, 0x66, 0x32, 0x30, 0x31, 0x65, 0x39, 0x34, 0x63, 0x33, 0x61, 0x61, 0x66, 0x64, 0x61, 0x61, 0x65, 0x31, 0x30, 0x33, 0x30, 0x32, 0x65, 0x66, 0x62, 0x37, 0x64, 0x37, 0x61, 0x30, 0x63, 0x31, 0x31, 0x36, 0x31, 0x37, 0x63, 0x65, 0x34, 0x32, 0x64, 0x34, 0x64, 0x36, 0x65, 0x39, 0x65, 0x33, 0x65, 0x36, 0x39, 0x31, 0x31, 0x65, 0x61, 0x33, 0x63, 0x35, 0x66, 0x62, 0x34, 0x33, 0x31, 0x31, 0x62, 0x61, 0x35, 0x66, 0x31, 0x66, 0x65, 0x34, 0x66, 0x65, 0x63, 0x39, 0x64, 0x63, 0x39, 0x33, 0x33, 0x33, 0x34, 0x31, 0x36, 0x35, 0x35, 0x64, 0x63, 0x38, 0x61, 0x66, 0x61, 0x32, 0x36, 0x39, 0x35, 0x63, 0x38, 0x38, 0x38, 0x64, 0x61, 0x61, 0x66, 0x62, 0x36, 0x34, 0x63, 0x30, 0x32, 0x62, 0x38, 0x64, 0x31, 0x36, 0x61, 0x33, 0x64, 0x38, 0x66, 0x31, 0x66, 0x31, 0x37, 0x34, 0x33, 0x65, 0x30, 0x30, 0x66, 0x31, 0x34, 0x30, 0x39, 0x32, 0x63, 0x62, 0x36, 0x35, 0x30, 0x38, 0x30, 0x30, 0x64, 0x63, 0x64, 0x30, 0x37, 0x35, 0x63, 0x37, 0x61, 0x31, 0x65, 0x36, 0x61, 0x36, 0x39, 0x31, 0x30, 0x66, 0x30, 0x39, 0x62, 0x34, 0x32, 0x36, 0x39, 0x39, 0x31, 0x63, 0x31, 0x64, 0x36, 0x61, 0x61, 0x31, 0x35, 0x65, 0x33, 0x30, 0x39, 0x64, 0x36, 0x39, 0x37, 0x62, 0x34, 0x36, 0x64, 0x37, 0x35, 0x32, 0x30, 0x34, 0x37, 0x32, 0x36, 0x34, 0x65, 0x38, 0x35, 0x34, 0x66, 0x39, 0x62, 0x39, 0x32, 0x65, 0x32, 0x64, 0x33, 0x34, 0x63, 0x63, 0x63, 0x30, 0x64, 0x30, 0x31, 0x39, 0x64, 0x38, 0x64, 0x62, 0x36, 0x30, 0x62, 0x62, 0x34, 0x39, 0x37, 0x64, 0x33, 0x62, 0x37, 0x34, 0x39, 0x63, 0x39, 0x31, 0x35, 0x32, 0x34, 0x62, 0x64, 0x62, 0x35, 0x64, 0x66, 0x66, 0x38, 0x34, 0x62, 0x36, 0x31, 0x37, 0x37, 0x32, 0x37, 0x32, 0x35, 0x30, 0x62, 0x35, 0x31, 0x38, 0x34, 0x30, 0x33, 0x30, 0x38, 0x34, 0x35, 0x35, 0x63, 0x63, 0x65, 0x64, 0x62, 0x32, 0x33, 0x31, 0x33, 0x62, 0x31, 0x36, 0x35, 0x30, 0x61, 0x61, 0x61, 0x34, 0x31, 0x35, 0x66, 0x66, 0x61, 0x32, 0x65, 0x63, 0x32, 0x37, 0x63, 0x31, 0x32, 0x30, 0x31, 0x30, 0x64, 0x32, 0x34, 0x35, 0x30, 0x38, 0x64, 0x31, 0x35, 0x36, 0x66, 0x36, 0x61, 0x64, 0x37, 0x32, 0x30, 0x62, 0x64, 0x61, 0x65, 0x35, 0x32, 0x66, 0x34, 0x38, 0x39, 0x33, 0x61, 0x64, 0x36, 0x37, 0x33, 0x31, 0x61, 0x64, 0x35, 0x64, 0x64, 0x31, 0x65, 0x39, 0x33, 0x36, 0x35, 0x36, 0x35, 0x32, 0x65, 0x66, 0x61, 0x31, 0x34, 0x38, 0x62, 0x63, 0x32, 0x31, 0x32, 0x62, 0x65, 0x30, 0x35, 0x33, 0x31, 0x65, 0x66, 0x33, 0x35, 0x65, 0x32, 0x34, 0x36, 0x66, 0x38, 0x32, 0x35, 0x38, 0x37, 0x32, 0x32, 0x35, 0x37, 0x32, 0x64, 0x38, 0x30, 0x31, 0x36, 0x35, 0x63, 0x34, 0x62, 0x31, 0x65, 0x35, 0x66, 0x30, 0x32, 0x35, 0x36, 0x33, 0x61, 0x33, 0x34, 0x34, 0x65, 0x30, 0x35, 0x38, 0x32, 0x39, 0x31, 0x64, 0x31, 0x65, 0x35, 0x37, 0x64, 0x35, 0x34, 0x64, 0x65, 0x33, 0x65, 0x64, 0x61, 0x66, 0x32, 0x63, 0x31, 0x64, 0x61, 0x34, 0x66, 0x32, 0x62, 0x37, 0x30, 0x32, 0x64, 0x35, 0x37, 0x32, 0x37, 0x34, 0x31, 0x64, 0x33, 0x61, 0x35, 0x66, 0x39, 0x38, 0x32, 0x66, 0x35, 0x33, 0x38, 0x66, 0x62, 0x61, 0x31, 0x30, 0x62, 0x66, 0x30, 0x62, 0x62, 0x63, 0x61, 0x64, 0x37, 0x63, 0x62, 0x32, 0x38, 0x33, 0x65, 0x65, 0x63, 0x36, 0x33, 0x37, 0x35, 0x63, 0x63, 0x35, 0x61, 0x31, 0x34, 0x32, 0x62, 0x39, 0x30, 0x33, 0x33, 0x62, 0x31, 0x37, 0x62, 0x39, 0x38, 0x37, 0x61, 0x63, 0x37, 0x32, 0x61, 0x37, 0x31, 0x62, 0x31, 0x33, 0x62, 0x32, 0x31, 0x61, 0x32, 0x37, 0x66, 0x65, 0x33, 0x34, 0x33, 0x63, 0x37, 0x32, 0x34, 0x39, 0x33, 0x33, 0x39, 0x64, 0x38, 0x32, 0x65, 0x63, 0x64, 0x32, 0x37, 0x30, 0x64, 0x62, 0x63, 0x37, 0x65, 0x62, 0x61, 0x62, 0x30, 0x36, 0x34, 0x38, 0x66, 0x62, 0x30, 0x38, 0x39, 0x34, 0x35, 0x61, 0x33, 0x31, 0x32, 0x66, 0x36, 0x33, 0x62, 0x30, 0x37, 0x32, 0x61, 0x63, 0x33, 0x64, 0x31, 0x36, 0x65, 0x35, 0x62, 0x37, 0x30, 0x35, 0x38, 0x34, 0x33, 0x33, 0x62, 0x36, 0x32, 0x34, 0x35, 0x31, 0x30, 0x38, 0x37, 0x33, 0x65, 0x39, 0x30, 0x32, 0x30, 0x35, 0x38, 0x33, 0x39, 0x32, 0x35, 0x65, 0x36, 0x36, 0x36, 0x35, 0x36, 0x65, 0x61, 0x34, 0x66, 0x36, 0x32, 0x36, 0x34, 0x62, 0x36, 0x66, 0x36, 0x61, 0x36, 0x65, 0x31, 0x32, 0x39, 0x34, 0x30, 0x35, 0x38, 0x34, 0x31, 0x64, 0x62, 0x61, 0x63, 0x62, 0x33, 0x36, 0x65, 0x39, 0x61, 0x33, 0x65, 0x61, 0x39, 0x39, 0x37, 0x39, 0x32, 0x31, 0x33, 0x37, 0x66, 0x62, 0x61, 0x65, 0x30, 0x32, 0x62, 0x38, 0x66, 0x63, 0x64, 0x35, 0x35, 0x66, 0x63, 0x37, 0x62, 0x66, 0x33, 0x62, 0x31, 0x62, 0x65, 0x65, 0x38, 0x33, 0x37, 0x35, 0x64, 0x34, 0x63, 0x63, 0x34, 0x63, 0x65, 0x32, 0x65, 0x64, 0x37, 0x32, 0x66, 0x63, 0x66, 0x66, 0x38, 0x37, 0x66, 0x39, 0x30, 0x33, 0x37, 0x37, 0x30, 0x65, 0x35, 0x33, 0x62, 0x35, 0x30, 0x37, 0x33, 0x65, 0x62, 0x35, 0x36, 0x63, 0x30, 0x65, 0x31, 0x61, 0x33, 0x64, 0x64, 0x32, 0x38, 0x39, 0x62, 0x32, 0x38, 0x38, 0x31, 0x63, 0x63, 0x30, 0x65, 0x30, 0x63, 0x39, 0x65, 0x66, 0x37, 0x33, 0x63, 0x61, 0x36, 0x62, 0x30, 0x32, 0x35, 0x61, 0x37, 0x38, 0x35, 0x35, 0x36, 0x31, 0x63, 0x62, 0x34, 0x30, 0x64, 0x34, 0x32, 0x30, 0x31, 0x38, 0x36, 0x34, 0x37, 0x65, 0x35, 0x37, 0x33, 0x66, 0x65, 0x35, 0x30, 0x36, 0x33, 0x62, 0x31, 0x61, 0x36, 0x33, 0x31, 0x31, 0x36, 0x36, 0x65, 0x65, 0x66, 0x34, 0x34, 0x33, 0x39, 0x33, 0x62, 0x31, 0x66, 0x66, 0x38, 0x37, 0x66, 0x35, 0x65, 0x61, 0x35, 0x62, 0x32, 0x35, 0x30, 0x35, 0x61, 0x65, 0x65, 0x37, 0x37, 0x32, 0x36, 0x63, 0x33, 0x61, 0x64, 0x38, 0x65, 0x30, 0x37, 0x35, 0x31, 0x63, 0x65, 0x62, 0x31, 0x63, 0x31, 0x31, 0x30, 0x32, 0x61, 0x38, 0x32, 0x39, 0x66, 0x65, 0x31, 0x38, 0x33, 0x37, 0x36, 0x66, 0x65, 0x31, 0x35, 0x39, 0x39, 0x63, 0x39, 0x33, 0x36, 0x61, 0x35, 0x38, 0x65, 0x64, 0x39, 0x33, 0x39, 0x63, 0x61, 0x37, 0x66, 0x63, 0x30, 0x63, 0x62, 0x39, 0x66, 0x34, 0x36, 0x37, 0x35, 0x38, 0x35, 0x65, 0x35, 0x39, 0x34, 0x61, 0x33, 0x30, 0x32, 0x32, 0x62, 0x33, 0x34, 0x31, 0x66, 0x63, 0x32, 0x31, 0x37, 0x61, 0x66, 0x37, 0x32, 0x66, 0x38, 0x63, 0x62, 0x30, 0x62, 0x65, 0x36, 0x63, 0x64, 0x61, 0x64, 0x39, 0x38, 0x33, 0x65, 0x39, 0x39, 0x36, 0x30, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x30, 0x38, 0x37, 0x63, 0x64, 0x32, 0x36, 0x30, 0x36, 0x39, 0x66, 0x64, 0x34, 0x30, 0x64, 0x62, 0x36, 0x37, 0x64, 0x36, 0x30, 0x62, 0x35, 0x65, 0x32, 0x34, 0x38, 0x33, 0x65, 0x30, 0x61, 0x39, 0x63, 0x34, 0x37, 0x39, 0x66, 0x33, 0x30, 0x30, 0x31, 0x65, 0x66, 0x61, 0x39, 0x33, 0x63, 0x38, 0x37, 0x62, 0x37, 0x61, 0x66, 0x61, 0x32, 0x36, 0x65, 0x63, 0x32, 0x39, 0x33, 0x37, 0x35, 0x38, 0x30, 0x32, 0x39, 0x63, 0x37, 0x39, 0x32, 0x33, 0x39, 0x63, 0x39, 0x61, 0x36, 0x34, 0x61, 0x34, 0x38, 0x64, 0x33, 0x66, 0x65, 0x36, 0x30, 0x64, 0x36, 0x65, 0x61, 0x64, 0x39, 0x34, 0x33, 0x38, 0x39, 0x63, 0x61, 0x32, 0x32, 0x35, 0x35, 0x64, 0x65, 0x64, 0x35, 0x35, 0x38, 0x30, 0x37, 0x34, 0x32, 0x63, 0x61, 0x61, 0x35, 0x36, 0x36, 0x61, 0x32, 0x39, 0x63, 0x62, 0x61, 0x30, 0x30, 0x36, 0x39, 0x37, 0x65, 0x62, 0x66, 0x64, 0x31, 0x66, 0x37, 0x36, 0x64, 0x32, 0x34, 0x37, 0x32, 0x63, 0x64, 0x65, 0x30, 0x37, 0x38, 0x38, 0x61, 0x38, 0x38, 0x31, 0x38, 0x38, 0x38, 0x30, 0x37, 0x30, 0x63, 0x34, 0x30, 0x38, 0x65, 0x36, 0x31, 0x33, 0x64, 0x35, 0x36, 0x34, 0x36, 0x36, 0x33, 0x32, 0x63, 0x30, 0x34, 0x32, 0x32, 0x62, 0x61, 0x38, 0x62, 0x36, 0x39, 0x34, 0x33, 0x63, 0x30, 0x34, 0x32, 0x63, 0x31, 0x65, 0x38, 0x30, 0x31, 0x65, 0x31, 0x38, 0x61, 0x39, 0x39, 0x35, 0x33, 0x34, 0x32, 0x33, 0x38, 0x30, 0x66, 0x30, 0x63, 0x31, 0x38, 0x36, 0x33, 0x39, 0x66, 0x61, 0x36, 0x30, 0x33, 0x66, 0x61, 0x64, 0x39, 0x38, 0x62, 0x30, 0x63, 0x31, 0x30, 0x34, 0x36, 0x38, 0x38, 0x31, 0x66, 0x36, 0x65, 0x34, 0x32, 0x30, 0x31, 0x39, 0x30, 0x63, 0x61, 0x37, 0x38, 0x39, 0x36, 0x65, 0x32, 0x38, 0x37, 0x34, 0x63, 0x37, 0x32, 0x37, 0x65, 0x63, 0x35, 0x37, 0x30, 0x30, 0x33, 0x35, 0x62, 0x64, 0x61, 0x37, 0x31, 0x63, 0x64, 0x30, 0x65, 0x34, 0x61, 0x38, 0x65, 0x39, 0x63, 0x63, 0x33, 0x61, 0x65, 0x63, 0x63, 0x36, 0x35, 0x39, 0x65, 0x64, 0x66, 0x30, 0x33, 0x61, 0x34, 0x37, 0x34, 0x32, 0x33, 0x33, 0x64, 0x38, 0x61, 0x39, 0x62, 0x63, 0x64, 0x63, 0x65, 0x39, 0x32, 0x30, 0x65, 0x32, 0x62, 0x63, 0x65, 0x65, 0x64, 0x61, 0x31, 0x34, 0x62, 0x35, 0x61, 0x37, 0x32, 0x63, 0x32, 0x66, 0x31, 0x62, 0x34, 0x36, 0x35, 0x63, 0x34, 0x62, 0x32, 0x62, 0x61, 0x65, 0x38, 0x39, 0x31, 0x61, 0x62, 0x31, 0x31, 0x36, 0x30, 0x31, 0x64, 0x31, 0x35, 0x38, 0x66, 0x31, 0x65, 0x63, 0x61, 0x35, 0x61, 0x62, 0x63, 0x65, 0x30, 0x30, 0x65, 0x61, 0x38, 0x62, 0x33, 0x66, 0x31, 0x35, 0x33, 0x62, 0x38, 0x66, 0x66, 0x65, 0x30, 0x30, 0x35, 0x33, 0x32, 0x62, 0x63, 0x37, 0x32, 0x63, 0x65, 0x34, 0x35, 0x62, 0x30, 0x63, 0x31, 0x31, 0x38, 0x62, 0x62, 0x64, 0x66, 0x61, 0x32, 0x34, 0x63, 0x31, 0x39, 0x61, 0x38, 0x63, 0x33, 0x61, 0x31, 0x33, 0x34, 0x34, 0x32, 0x37, 0x36, 0x38, 0x65, 0x33, 0x61, 0x39, 0x35, 0x34, 0x30, 0x64, 0x36, 0x39, 0x35, 0x30, 0x65, 0x34, 0x30, 0x31, 0x39, 0x61, 0x38, 0x33, 0x33, 0x32, 0x62, 0x65, 0x65, 0x36, 0x61, 0x33, 0x31, 0x37, 0x32, 0x35, 0x31, 0x36, 0x37, 0x30, 0x66, 0x66, 0x61, 0x62, 0x39, 0x37, 0x38, 0x61, 0x66, 0x65, 0x34, 0x36, 0x36, 0x64, 0x31, 0x32, 0x35, 0x33, 0x33, 0x65, 0x62, 0x31, 0x62, 0x32, 0x65, 0x62, 0x61, 0x66, 0x36, 0x35, 0x61, 0x39, 0x35, 0x33, 0x30, 0x31, 0x34, 0x36, 0x31, 0x66, 0x65, 0x39, 0x36, 0x39, 0x66, 0x64, 0x66, 0x36, 0x66, 0x30, 0x63, 0x39, 0x66, 0x38, 0x62, 0x65, 0x35, 0x37, 0x32, 0x62, 0x33, 0x37, 0x37, 0x66, 0x37, 0x36, 0x32, 0x37, 0x66, 0x63, 0x61, 0x39, 0x37, 0x61, 0x62, 0x39, 0x63, 0x35, 0x66, 0x34, 0x37, 0x34, 0x31, 0x30, 0x62, 0x34, 0x39, 0x32, 0x33, 0x35, 0x30, 0x34, 0x31, 0x33, 0x33, 0x61, 0x36, 0x36, 0x36, 0x30, 0x65, 0x34, 0x33, 0x31, 0x36, 0x66, 0x63, 0x32, 0x63, 0x36, 0x63, 0x35, 0x39, 0x31, 0x66, 0x31, 0x36, 0x35, 0x36, 0x36, 0x36, 0x34, 0x63, 0x65, 0x33, 0x33, 0x62, 0x31, 0x62, 0x37, 0x39, 0x33, 0x30, 0x34, 0x62, 0x39, 0x65, 0x37, 0x66, 0x35, 0x36, 0x65, 0x30, 0x64, 0x35, 0x63, 0x35, 0x63, 0x65, 0x32, 0x30, 0x38, 0x30, 0x65, 0x35, 0x37, 0x61, 0x34, 0x64, 0x33, 0x32, 0x39, 0x30, 0x64, 0x63, 0x34, 0x33, 0x35, 0x36, 0x39, 0x38, 0x63, 0x31, 0x66, 0x62, 0x66, 0x62, 0x33, 0x39, 0x63, 0x62, 0x65, 0x32, 0x64, 0x62, 0x34, 0x64, 0x38, 0x62, 0x30, 0x66, 0x34, 0x62, 0x38, 0x31, 0x34, 0x65, 0x32, 0x36, 0x35, 0x35, 0x30, 0x36, 0x35, 0x33, 0x31, 0x65, 0x65, 0x30, 0x38, 0x33, 0x30, 0x36, 0x38, 0x39, 0x31, 0x33, 0x39, 0x62, 0x31, 0x33, 0x65, 0x30, 0x30, 0x33, 0x63, 0x35, 0x61, 0x36, 0x39, 0x31, 0x65, 0x35, 0x34, 0x64, 0x30, 0x65, 0x64, 0x64, 0x36, 0x36, 0x37, 0x63, 0x38, 0x66, 0x63, 0x63, 0x64, 0x33, 0x31, 0x64, 0x33, 0x35, 0x31, 0x31, 0x32, 0x62, 0x37, 0x63, 0x62, 0x31, 0x30, 0x62, 0x64, 0x61, 0x66, 0x65, 0x31, 0x63, 0x35, 0x31, 0x32, 0x64, 0x38, 0x62, 0x37, 0x61, 0x35, 0x31, 0x33, 0x34, 0x63, 0x36, 0x65, 0x31, 0x31, 0x31, 0x33, 0x37, 0x31, 0x30, 0x66, 0x35, 0x36, 0x61, 0x36, 0x66, 0x31, 0x36, 0x39, 0x35, 0x33, 0x64, 0x64, 0x34, 0x30, 0x39, 0x31, 0x33, 0x66, 0x32, 0x63, 0x30, 0x37, 0x32, 0x65, 0x34, 0x61, 0x38, 0x30, 0x63, 0x61, 0x39, 0x33, 0x38, 0x64, 0x34, 0x32, 0x35, 0x61, 0x33, 0x63, 0x64, 0x65, 0x37, 0x62, 0x39, 0x61, 0x61, 0x33, 0x30, 0x37, 0x30, 0x36, 0x34, 0x65, 0x33, 0x38, 0x33, 0x37, 0x34, 0x34, 0x61, 0x35, 0x34, 0x38, 0x33, 0x30, 0x32, 0x31, 0x36, 0x65, 0x38, 0x37, 0x32, 0x36, 0x34, 0x61, 0x64, 0x62, 0x62, 0x38, 0x39, 0x34, 0x66, 0x65, 0x30, 0x35, 0x38, 0x66, 0x36, 0x65, 0x31, 0x30, 0x65, 0x66, 0x39, 0x34, 0x30, 0x63, 0x38, 0x65, 0x35, 0x39, 0x39, 0x39, 0x34, 0x36, 0x30, 0x35, 0x33, 0x62, 0x32, 0x39, 0x65, 0x66, 0x37, 0x35, 0x34, 0x33, 0x65, 0x63, 0x61, 0x36, 0x33, 0x32, 0x33, 0x35, 0x31, 0x33, 0x61, 0x38, 0x31, 0x35, 0x61, 0x38, 0x33, 0x61, 0x38, 0x33, 0x63, 0x61, 0x35, 0x37, 0x30, 0x33, 0x37, 0x63, 0x61, 0x31, 0x33, 0x30, 0x36, 0x34, 0x37, 0x61, 0x65, 0x62, 0x65, 0x64, 0x35, 0x32, 0x39, 0x64, 0x33, 0x38, 0x30, 0x66, 0x64, 0x61, 0x61, 0x65, 0x65, 0x61, 0x30, 0x36, 0x65, 0x31, 0x31, 0x30, 0x38, 0x38, 0x34, 0x36, 0x64, 0x33, 0x39, 0x35, 0x33, 0x39, 0x36, 0x37, 0x34, 0x65, 0x33, 0x36, 0x36, 0x31, 0x39, 0x65, 0x31, 0x33, 0x32, 0x61, 0x63, 0x66, 0x36, 0x61, 0x34, 0x66, 0x35, 0x31, 0x64, 0x37, 0x35, 0x37, 0x32, 0x32, 0x62, 0x31, 0x39, 0x33, 0x32, 0x32, 0x31, 0x61, 0x64, 0x64, 0x39, 0x30, 0x31, 0x36, 0x35, 0x65, 0x31, 0x61, 0x61, 0x33, 0x33, 0x32, 0x62, 0x65, 0x38, 0x30, 0x30, 0x64, 0x61, 0x38, 0x31, 0x62, 0x65, 0x37, 0x32, 0x31, 0x38, 0x64, 0x63, 0x35, 0x61, 0x36, 0x39, 0x38, 0x63, 0x65, 0x62, 0x64, 0x39, 0x33, 0x30, 0x30, 0x63, 0x33, 0x65, 0x35, 0x63, 0x66, 0x38, 0x39, 0x64, 0x35, 0x33, 0x65, 0x64, 0x31, 0x61, 0x34, 0x35, 0x65, 0x65, 0x30, 0x38, 0x37, 0x61, 0x65, 0x61, 0x33, 0x63, 0x31, 0x33, 0x39, 0x64, 0x30, 0x64, 0x39, 0x39, 0x36, 0x61, 0x37, 0x39, 0x31, 0x63, 0x38, 0x32, 0x31, 0x62, 0x36, 0x33, 0x62, 0x39, 0x62, 0x31, 0x37, 0x65, 0x61, 0x37, 0x31, 0x30, 0x37, 0x31, 0x66, 0x33, 0x65, 0x36, 0x33, 0x32, 0x66, 0x35, 0x65, 0x35, 0x62, 0x64, 0x39, 0x62, 0x37, 0x32, 0x32, 0x61, 0x61, 0x35, 0x63, 0x66, 0x30, 0x38, 0x35, 0x35, 0x35, 0x35, 0x65, 0x34, 0x32, 0x31, 0x64, 0x34, 0x34, 0x38, 0x38, 0x39, 0x61, 0x63, 0x35, 0x65, 0x63, 0x31, 0x66, 0x38, 0x35, 0x34, 0x30, 0x63, 0x61, 0x64, 0x64, 0x64, 0x32, 0x36, 0x31, 0x38, 0x65, 0x66, 0x37, 0x62, 0x66, 0x66, 0x38, 0x62, 0x37, 0x35, 0x38, 0x64, 0x37, 0x65, 0x34, 0x38, 0x38, 0x31, 0x36, 0x65, 0x35, 0x37, 0x61, 0x64, 0x62, 0x63, 0x31, 0x31, 0x65, 0x65, 0x33, 0x33, 0x35, 0x63, 0x39, 0x30, 0x38, 0x32, 0x31, 0x30, 0x62, 0x36, 0x33, 0x34, 0x64, 0x37, 0x34, 0x38, 0x32, 0x64, 0x32, 0x34, 0x39, 0x35, 0x37, 0x33, 0x33, 0x66, 0x65, 0x39, 0x62, 0x62, 0x33, 0x62, 0x38, 0x39, 0x63, 0x65, 0x65, 0x61, 0x38, 0x30, 0x31, 0x30, 0x63, 0x35, 0x65, 0x35, 0x33, 0x32, 0x31, 0x34, 0x37, 0x30, 0x35, 0x62, 0x36, 0x30, 0x64, 0x31, 0x38, 0x32, 0x37, 0x61, 0x31, 0x30, 0x36, 0x63, 0x30, 0x66, 0x34, 0x38, 0x33, 0x37, 0x38, 0x32, 0x64, 0x39, 0x37, 0x64, 0x37, 0x65, 0x64, 0x35, 0x32, 0x35, 0x38, 0x37, 0x65, 0x36, 0x31, 0x31, 0x37, 0x62, 0x30, 0x64, 0x62, 0x61, 0x32, 0x61, 0x66, 0x37, 0x66, 0x65, 0x38, 0x64, 0x36, 0x64, 0x62, 0x38, 0x63, 0x35, 0x36, 0x34, 0x30, 0x36, 0x34, 0x63, 0x31, 0x61, 0x32, 0x38, 0x38, 0x32, 0x30, 0x65, 0x61, 0x63, 0x62, 0x66, 0x34, 0x66, 0x33, 0x30, 0x64, 0x65, 0x63, 0x37, 0x39, 0x33, 0x35, 0x37, 0x37, 0x65, 0x65, 0x66, 0x33, 0x66, 0x39, 0x30, 0x36, 0x38, 0x34, 0x38, 0x39, 0x30, 0x34, 0x64, 0x36, 0x37, 0x37, 0x34, 0x66, 0x35, 0x63, 0x37, 0x63, 0x39, 0x35, 0x35, 0x30, 0x39, 0x35, 0x31, 0x65, 0x39, 0x65, 0x36, 0x30, 0x62, 0x37, 0x65, 0x35, 0x64, 0x38, 0x32, 0x30, 0x33, 0x39, 0x34, 0x37, 0x39, 0x35, 0x32, 0x35, 0x37, 0x66, 0x65, 0x61, 0x36, 0x34, 0x61, 0x39, 0x32, 0x63, 0x62, 0x37, 0x39, 0x64, 0x32, 0x36, 0x36, 0x33, 0x37, 0x36, 0x62, 0x36, 0x65, 0x66, 0x31, 0x63, 0x36, 0x30, 0x30, 0x63, 0x34, 0x32, 0x35, 0x61, 0x35, 0x37, 0x35, 0x30, 0x36, 0x66, 0x33, 0x39, 0x61, 0x39, 0x31, 0x36, 0x35, 0x38, 0x38, 0x64, 0x33, 0x33, 0x31, 0x35, 0x63, 0x63, 0x32, 0x61, 0x38, 0x65, 0x36, 0x35, 0x61, 0x36, 0x65, 0x65, 0x33, 0x39, 0x35, 0x32, 0x62, 0x31, 0x35, 0x66, 0x31, 0x33, 0x39, 0x61, 0x38, 0x65, 0x39, 0x30, 0x66, 0x33, 0x65, 0x65, 0x35, 0x34, 0x63, 0x63, 0x39, 0x66, 0x62, 0x38, 0x35, 0x61, 0x66, 0x37, 0x31, 0x36, 0x63, 0x65, 0x34, 0x66, 0x34, 0x30, 0x30, 0x61, 0x61, 0x36, 0x61, 0x66, 0x33, 0x33, 0x63, 0x35, 0x32, 0x35, 0x66, 0x62, 0x30, 0x66, 0x35, 0x35, 0x65, 0x64, 0x34, 0x34, 0x64, 0x64, 0x31, 0x34, 0x62, 0x31, 0x33, 0x65, 0x31, 0x63, 0x38, 0x61, 0x30, 0x35, 0x37, 0x35, 0x63, 0x39, 0x34, 0x37, 0x30, 0x39, 0x32, 0x35, 0x30, 0x30, 0x62, 0x62, 0x34, 0x30, 0x62, 0x35, 0x34, 0x65, 0x34, 0x35, 0x61, 0x64, 0x39, 0x39, 0x61, 0x31, 0x61, 0x38, 0x33, 0x62, 0x61, 0x34, 0x64, 0x34, 0x66, 0x33, 0x64, 0x65, 0x63, 0x30, 0x65, 0x62, 0x61, 0x61, 0x37, 0x38, 0x30, 0x38, 0x33, 0x37, 0x62, 0x30, 0x32, 0x35, 0x66, 0x39, 0x64, 0x62, 0x30, 0x63, 0x39, 0x63, 0x39, 0x31, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x39, 0x31, 0x36, 0x61, 0x36, 0x65, 0x36, 0x31, 0x34, 0x35, 0x38, 0x35, 0x35, 0x39, 0x39, 0x61, 0x61, 0x32, 0x34, 0x61, 0x33, 0x30, 0x62, 0x38, 0x36, 0x61, 0x61, 0x32, 0x37, 0x34, 0x35, 0x36, 0x32, 0x35, 0x34, 0x64, 0x31, 0x39, 0x32, 0x38, 0x66, 0x36, 0x33, 0x38, 0x31, 0x33, 0x64, 0x32, 0x63, 0x39, 0x62, 0x63, 0x39, 0x36, 0x65, 0x37, 0x63, 0x37, 0x34, 0x37, 0x66, 0x65, 0x39, 0x61, 0x61, 0x34, 0x35, 0x35, 0x35, 0x65, 0x37, 0x34, 0x31, 0x37, 0x66, 0x31, 0x64, 0x34, 0x31, 0x64, 0x31, 0x38, 0x38, 0x38, 0x34, 0x66, 0x34, 0x61, 0x30, 0x36, 0x33, 0x33, 0x37, 0x33, 0x62, 0x36, 0x65, 0x33, 0x34, 0x65, 0x61, 0x61, 0x38, 0x30, 0x35, 0x34, 0x33, 0x31, 0x66, 0x61, 0x33, 0x31, 0x35, 0x61, 0x31, 0x30, 0x61, 0x64, 0x64, 0x36, 0x62, 0x33, 0x34, 0x63, 0x35, 0x61, 0x66, 0x64, 0x34, 0x63, 0x35, 0x62, 0x36, 0x66, 0x38, 0x35, 0x34, 0x35, 0x34, 0x64, 0x33, 0x36, 0x61, 0x62, 0x65, 0x34, 0x31, 0x30, 0x65, 0x65, 0x65, 0x34, 0x32, 0x66, 0x39, 0x66, 0x36, 0x32, 0x38, 0x65, 0x61, 0x31, 0x36, 0x34, 0x62, 0x61, 0x36, 0x33, 0x36, 0x65, 0x30, 0x65, 0x62, 0x62, 0x37, 0x65, 0x64, 0x37, 0x63, 0x65, 0x37, 0x38, 0x38, 0x66, 0x30, 0x65, 0x38, 0x64, 0x37, 0x61, 0x61, 0x34, 0x30, 0x36, 0x66, 0x65, 0x63, 0x34, 0x33, 0x63, 0x39, 0x35, 0x30, 0x39, 0x61, 0x65, 0x30, 0x65, 0x34, 0x65, 0x61, 0x31, 0x36, 0x61, 0x34, 0x39, 0x37, 0x32, 0x62, 0x64, 0x32, 0x37, 0x63, 0x35, 0x65, 0x37, 0x65, 0x63, 0x61, 0x36, 0x35, 0x61, 0x36, 0x36, 0x37, 0x33, 0x35, 0x64, 0x37, 0x38, 0x32, 0x61, 0x33, 0x35, 0x38, 0x33, 0x34, 0x63, 0x65, 0x38, 0x65, 0x34, 0x31, 0x31, 0x34, 0x64, 0x61, 0x31, 0x64, 0x34, 0x37, 0x61, 0x62, 0x61, 0x64, 0x31, 0x61, 0x61, 0x35, 0x66, 0x32, 0x35, 0x36, 0x32, 0x30, 0x62, 0x37, 0x65, 0x64, 0x36, 0x37, 0x32, 0x61, 0x37, 0x36, 0x31, 0x37, 0x35, 0x32, 0x61, 0x37, 0x64, 0x35, 0x34, 0x37, 0x65, 0x61, 0x33, 0x36, 0x65, 0x38, 0x39, 0x36, 0x65, 0x32, 0x65, 0x64, 0x35, 0x64, 0x33, 0x34, 0x61, 0x39, 0x32, 0x39, 0x33, 0x37, 0x31, 0x31, 0x39, 0x65, 0x62, 0x32, 0x62, 0x32, 0x30, 0x35, 0x39, 0x63, 0x64, 0x38, 0x36, 0x38, 0x36, 0x32, 0x61, 0x39, 0x32, 0x62, 0x64, 0x35, 0x62, 0x63, 0x34, 0x34, 0x38, 0x39, 0x64, 0x39, 0x31, 0x62, 0x66, 0x32, 0x65, 0x36, 0x30, 0x32, 0x38, 0x39, 0x36, 0x62, 0x62, 0x31, 0x31, 0x61, 0x64, 0x34, 0x36, 0x61, 0x39, 0x38, 0x37, 0x31, 0x35, 0x63, 0x34, 0x65, 0x36, 0x34, 0x34, 0x38, 0x64, 0x33, 0x36, 0x33, 0x34, 0x37, 0x32, 0x62, 0x35, 0x63, 0x33, 0x34, 0x34, 0x38, 0x66, 0x64, 0x66, 0x33, 0x39, 0x33, 0x32, 0x35, 0x34, 0x31, 0x32, 0x34, 0x64, 0x37, 0x32, 0x35, 0x38, 0x35, 0x64, 0x37, 0x30, 0x35, 0x64, 0x31, 0x63, 0x33, 0x33, 0x37, 0x39, 0x31, 0x33, 0x33, 0x66, 0x39, 0x66, 0x36, 0x32, 0x66, 0x66, 0x65, 0x32, 0x30, 0x39, 0x35, 0x65, 0x30, 0x64, 0x39, 0x37, 0x37, 0x66, 0x65, 0x63, 0x62, 0x63, 0x33, 0x36, 0x37, 0x33, 0x32, 0x30, 0x38, 0x65, 0x62, 0x30, 0x36, 0x31, 0x65, 0x33, 0x66, 0x61, 0x31, 0x32, 0x66, 0x62, 0x32, 0x30, 0x35, 0x38, 0x33, 0x32, 0x33, 0x31, 0x33, 0x62, 0x62, 0x38, 0x35, 0x30, 0x33, 0x65, 0x30, 0x63, 0x62, 0x63, 0x64, 0x64, 0x34, 0x35, 0x30, 0x38, 0x31, 0x66, 0x37, 0x35, 0x37, 0x33, 0x38, 0x32, 0x30, 0x34, 0x62, 0x36, 0x35, 0x35, 0x31, 0x61, 0x30, 0x37, 0x61, 0x61, 0x32, 0x66, 0x38, 0x36, 0x64, 0x63, 0x34, 0x39, 0x62, 0x66, 0x36, 0x33, 0x38, 0x61, 0x39, 0x39, 0x65, 0x38, 0x33, 0x33, 0x34, 0x61, 0x62, 0x33, 0x62, 0x66, 0x65, 0x35, 0x64, 0x64, 0x35, 0x34, 0x65, 0x39, 0x65, 0x34, 0x30, 0x38, 0x66, 0x62, 0x36, 0x33, 0x33, 0x63, 0x35, 0x35, 0x33, 0x37, 0x32, 0x64, 0x36, 0x31, 0x38, 0x32, 0x32, 0x34, 0x35, 0x31, 0x39, 0x38, 0x62, 0x30, 0x35, 0x34, 0x31, 0x39, 0x36, 0x62, 0x61, 0x32, 0x61, 0x64, 0x32, 0x38, 0x66, 0x62, 0x35, 0x35, 0x32, 0x38, 0x64, 0x62, 0x31, 0x61, 0x30, 0x38, 0x36, 0x35, 0x61, 0x62, 0x31, 0x66, 0x36, 0x39, 0x38, 0x34, 0x65, 0x35, 0x64, 0x62, 0x34, 0x61, 0x30, 0x63, 0x34, 0x32, 0x31, 0x64, 0x66, 0x35, 0x39, 0x66, 0x66, 0x34, 0x63, 0x36, 0x62, 0x65, 0x36, 0x66, 0x37, 0x39, 0x32, 0x61, 0x31, 0x31, 0x35, 0x63, 0x61, 0x30, 0x64, 0x32, 0x32, 0x31, 0x62, 0x63, 0x66, 0x33, 0x66, 0x32, 0x37, 0x61, 0x34, 0x32, 0x65, 0x35, 0x32, 0x64, 0x34, 0x33, 0x65, 0x66, 0x63, 0x62, 0x64, 0x31, 0x32, 0x38, 0x32, 0x37, 0x65, 0x35, 0x31, 0x39, 0x66, 0x34, 0x39, 0x61, 0x33, 0x37, 0x36, 0x66, 0x34, 0x66, 0x66, 0x63, 0x64, 0x35, 0x39, 0x63, 0x66, 0x61, 0x63, 0x38, 0x30, 0x62, 0x64, 0x31, 0x35, 0x65, 0x31, 0x34, 0x37, 0x62, 0x32, 0x66, 0x39, 0x63, 0x39, 0x64, 0x33, 0x64, 0x63, 0x38, 0x34, 0x64, 0x39, 0x66, 0x38, 0x31, 0x36, 0x62, 0x35, 0x39, 0x66, 0x61, 0x37, 0x65, 0x64, 0x36, 0x65, 0x36, 0x65, 0x34, 0x63, 0x61, 0x64, 0x30, 0x35, 0x31, 0x65, 0x33, 0x34, 0x38, 0x64, 0x66, 0x37, 0x33, 0x31, 0x37, 0x37, 0x62, 0x64, 0x62, 0x36, 0x34, 0x61, 0x33, 0x36, 0x38, 0x65, 0x33, 0x64, 0x37, 0x36, 0x36, 0x39, 0x66, 0x39, 0x64, 0x61, 0x37, 0x32, 0x64, 0x37, 0x65, 0x64, 0x35, 0x61, 0x34, 0x34, 0x35, 0x66, 0x38, 0x35, 0x31, 0x34, 0x39, 0x33, 0x62, 0x37, 0x32, 0x31, 0x34, 0x62, 0x61, 0x64, 0x38, 0x36, 0x35, 0x30, 0x64, 0x31, 0x65, 0x33, 0x34, 0x31, 0x66, 0x33, 0x39, 0x35, 0x35, 0x36, 0x63, 0x35, 0x36, 0x36, 0x31, 0x65, 0x33, 0x31, 0x34, 0x34, 0x65, 0x30, 0x61, 0x33, 0x34, 0x61, 0x63, 0x36, 0x64, 0x35, 0x37, 0x37, 0x33, 0x39, 0x66, 0x30, 0x37, 0x35, 0x65, 0x64, 0x66, 0x62, 0x31, 0x61, 0x66, 0x30, 0x30, 0x37, 0x32, 0x61, 0x66, 0x36, 0x36, 0x65, 0x37, 0x36, 0x62, 0x62, 0x62, 0x64, 0x33, 0x62, 0x32, 0x66, 0x35, 0x39, 0x31, 0x39, 0x32, 0x64, 0x37, 0x31, 0x37, 0x36, 0x33, 0x36, 0x34, 0x62, 0x65, 0x65, 0x63, 0x31, 0x64, 0x37, 0x30, 0x61, 0x37, 0x39, 0x65, 0x39, 0x37, 0x34, 0x63, 0x31, 0x61, 0x36, 0x65, 0x61, 0x33, 0x34, 0x66, 0x34, 0x38, 0x36, 0x30, 0x61, 0x63, 0x34, 0x30, 0x33, 0x31, 0x31, 0x32, 0x63, 0x31, 0x65, 0x64, 0x36, 0x61, 0x65, 0x61, 0x61, 0x63, 0x39, 0x66, 0x30, 0x35, 0x65, 0x62, 0x66, 0x33, 0x31, 0x33, 0x38, 0x64, 0x33, 0x34, 0x61, 0x65, 0x64, 0x31, 0x30, 0x39, 0x34, 0x65, 0x66, 0x66, 0x30, 0x34, 0x62, 0x35, 0x34, 0x39, 0x61, 0x30, 0x34, 0x38, 0x66, 0x36, 0x32, 0x66, 0x32, 0x66, 0x39, 0x36, 0x37, 0x33, 0x38, 0x36, 0x63, 0x39, 0x62, 0x39, 0x36, 0x66, 0x35, 0x62, 0x65, 0x62, 0x66, 0x39, 0x32, 0x38, 0x32, 0x35, 0x37, 0x37, 0x63, 0x31, 0x31, 0x61, 0x35, 0x35, 0x31, 0x64, 0x61, 0x33, 0x61, 0x34, 0x38, 0x33, 0x33, 0x39, 0x34, 0x33, 0x33, 0x34, 0x30, 0x37, 0x62, 0x62, 0x62, 0x33, 0x66, 0x35, 0x64, 0x66, 0x34, 0x66, 0x34, 0x61, 0x38, 0x61, 0x33, 0x33, 0x32, 0x35, 0x33, 0x66, 0x35, 0x64, 0x33, 0x32, 0x35, 0x63, 0x33, 0x66, 0x30, 0x34, 0x30, 0x31, 0x63, 0x39, 0x30, 0x61, 0x61, 0x62, 0x61, 0x38, 0x63, 0x64, 0x30, 0x65, 0x61, 0x35, 0x66, 0x38, 0x37, 0x33, 0x36, 0x62, 0x61, 0x36, 0x38, 0x30, 0x66, 0x31, 0x64, 0x33, 0x33, 0x63, 0x66, 0x64, 0x64, 0x38, 0x61, 0x32, 0x61, 0x61, 0x33, 0x30, 0x35, 0x61, 0x63, 0x62, 0x38, 0x33, 0x31, 0x65, 0x33, 0x31, 0x35, 0x63, 0x33, 0x36, 0x31, 0x61, 0x38, 0x36, 0x66, 0x62, 0x66, 0x33, 0x37, 0x32, 0x62, 0x34, 0x65, 0x32, 0x62, 0x38, 0x39, 0x39, 0x37, 0x31, 0x36, 0x31, 0x33, 0x66, 0x31, 0x62, 0x63, 0x32, 0x35, 0x30, 0x37, 0x34, 0x65, 0x33, 0x39, 0x62, 0x34, 0x64, 0x31, 0x66, 0x33, 0x61, 0x30, 0x61, 0x62, 0x66, 0x65, 0x32, 0x61, 0x63, 0x62, 0x31, 0x33, 0x33, 0x30, 0x39, 0x66, 0x33, 0x34, 0x35, 0x63, 0x36, 0x61, 0x62, 0x36, 0x38, 0x35, 0x62, 0x37, 0x36, 0x35, 0x33, 0x37, 0x32, 0x31, 0x65, 0x38, 0x33, 0x35, 0x39, 0x64, 0x31, 0x65, 0x32, 0x62, 0x61, 0x66, 0x34, 0x61, 0x65, 0x31, 0x34, 0x38, 0x31, 0x33, 0x62, 0x34, 0x65, 0x33, 0x61, 0x32, 0x32, 0x37, 0x61, 0x35, 0x66, 0x34, 0x61, 0x33, 0x64, 0x65, 0x66, 0x36, 0x66, 0x65, 0x37, 0x63, 0x61, 0x36, 0x35, 0x66, 0x32, 0x61, 0x65, 0x65, 0x66, 0x31, 0x30, 0x61, 0x63, 0x65, 0x61, 0x66, 0x62, 0x64, 0x39, 0x37, 0x32, 0x65, 0x30, 0x30, 0x30, 0x35, 0x61, 0x34, 0x35, 0x31, 0x61, 0x37, 0x63, 0x33, 0x30, 0x35, 0x32, 0x65, 0x30, 0x38, 0x61, 0x30, 0x34, 0x63, 0x36, 0x64, 0x30, 0x35, 0x31, 0x34, 0x66, 0x33, 0x65, 0x37, 0x65, 0x35, 0x34, 0x65, 0x30, 0x36, 0x30, 0x66, 0x66, 0x62, 0x64, 0x39, 0x39, 0x36, 0x34, 0x32, 0x66, 0x65, 0x30, 0x66, 0x64, 0x37, 0x65, 0x37, 0x61, 0x32, 0x35, 0x39, 0x35, 0x37, 0x32, 0x63, 0x32, 0x62, 0x36, 0x66, 0x34, 0x30, 0x35, 0x39, 0x36, 0x31, 0x30, 0x35, 0x63, 0x36, 0x34, 0x66, 0x37, 0x33, 0x35, 0x35, 0x62, 0x31, 0x39, 0x31, 0x33, 0x62, 0x63, 0x33, 0x37, 0x64, 0x38, 0x37, 0x34, 0x35, 0x64, 0x61, 0x66, 0x34, 0x65, 0x36, 0x38, 0x64, 0x34, 0x32, 0x61, 0x61, 0x66, 0x61, 0x38, 0x37, 0x35, 0x66, 0x36, 0x64, 0x30, 0x65, 0x63, 0x63, 0x35, 0x38, 0x38, 0x32, 0x62, 0x61, 0x39, 0x36, 0x35, 0x30, 0x39, 0x39, 0x31, 0x36, 0x32, 0x66, 0x62, 0x34, 0x32, 0x34, 0x33, 0x30, 0x34, 0x62, 0x37, 0x39, 0x34, 0x32, 0x64, 0x61, 0x38, 0x37, 0x30, 0x64, 0x31, 0x33, 0x30, 0x61, 0x34, 0x62, 0x39, 0x37, 0x62, 0x36, 0x63, 0x30, 0x64, 0x63, 0x33, 0x66, 0x63, 0x32, 0x30, 0x62, 0x37, 0x39, 0x32, 0x61, 0x34, 0x39, 0x33, 0x36, 0x38, 0x37, 0x32, 0x63, 0x64, 0x36, 0x62, 0x31, 0x36, 0x31, 0x34, 0x66, 0x33, 0x37, 0x35, 0x65, 0x31, 0x63, 0x32, 0x39, 0x62, 0x31, 0x34, 0x32, 0x39, 0x61, 0x64, 0x32, 0x31, 0x39, 0x33, 0x65, 0x66, 0x35, 0x38, 0x62, 0x34, 0x61, 0x38, 0x35, 0x61, 0x30, 0x35, 0x37, 0x66, 0x34, 0x35, 0x37, 0x38, 0x64, 0x34, 0x61, 0x36, 0x39, 0x35, 0x39, 0x66, 0x32, 0x62, 0x31, 0x34, 0x63, 0x37, 0x34, 0x64, 0x38, 0x66, 0x32, 0x35, 0x33, 0x65, 0x63, 0x37, 0x30, 0x36, 0x35, 0x61, 0x32, 0x66, 0x38, 0x65, 0x32, 0x31, 0x65, 0x66, 0x63, 0x32, 0x66, 0x66, 0x66, 0x63, 0x63, 0x63, 0x38, 0x37, 0x62, 0x30, 0x30, 0x65, 0x61, 0x61, 0x33, 0x38, 0x33, 0x65, 0x34, 0x31, 0x31, 0x66, 0x36, 0x39, 0x30, 0x31, 0x66, 0x61, 0x38, 0x32, 0x37, 0x38, 0x64, 0x62, 0x36, 0x66, 0x61, 0x36, 0x61, 0x30, 0x65, 0x31, 0x61, 0x65, 0x36, 0x61, 0x30, 0x61, 0x33, 0x39, 0x32, 0x65, 0x38, 0x34, 0x30, 0x62, 0x63, 0x63, 0x34, 0x39, 0x33, 0x33, 0x64, 0x63, 0x35, 0x62, 0x36, 0x39, 0x33, 0x32, 0x34, 0x32, 0x65, 0x31, 0x33, 0x30, 0x38, 0x39, 0x39, 0x39, 0x32, 0x64, 0x31, 0x36, 0x63, 0x34, 0x39, 0x34, 0x62, 0x64, 0x65, 0x30, 0x33, 0x36, 0x33, 0x61, 0x39, 0x33, 0x35, 0x66, 0x38, 0x64, 0x61, 0x32, 0x32, 0x62, 0x37, 0x65, 0x65, 0x39, 0x37, 0x32, 0x35, 0x36, 0x31, 0x66, 0x63, 0x35, 0x30, 0x63, 0x66, 0x66, 0x37, 0x64, 0x65, 0x31, 0x61, 0x36, 0x38, 0x33, 0x63, 0x31, 0x63, 0x63, 0x62, 0x61, 0x39, 0x30, 0x64, 0x39, 0x36, 0x66, 0x38, 0x36, 0x61, 0x61, 0x63, 0x37, 0x36, 0x34, 0x36, 0x36, 0x65, 0x30, 0x63, 0x62, 0x30, 0x35, 0x35, 0x38, 0x33, 0x33, 0x31, 0x66, 0x32, 0x32, 0x34, 0x64, 0x39, 0x39, 0x31, 0x34, 0x30, 0x35, 0x37, 0x32, 0x32, 0x35, 0x31, 0x32, 0x66, 0x32, 0x66, 0x66, 0x38, 0x66, 0x39, 0x66, 0x34, 0x36, 0x30, 0x64, 0x65, 0x37, 0x64, 0x65, 0x35, 0x33, 0x61, 0x62, 0x64, 0x31, 0x36, 0x34, 0x65, 0x38, 0x62, 0x64, 0x38, 0x38, 0x36, 0x64, 0x61, 0x35, 0x37, 0x64, 0x35, 0x62, 0x63, 0x36, 0x32, 0x36, 0x33, 0x32, 0x38, 0x61, 0x36, 0x35, 0x61, 0x32, 0x34, 0x62, 0x34, 0x39, 0x32, 0x37, 0x37, 0x61, 0x33, 0x33, 0x30, 0x38, 0x35, 0x61, 0x30, 0x62, 0x65, 0x65, 0x30, 0x39, 0x36, 0x39, 0x35, 0x65, 0x34, 0x61, 0x35, 0x31, 0x33, 0x63, 0x65, 0x38, 0x39, 0x39, 0x64, 0x31, 0x62, 0x66, 0x39, 0x32, 0x36, 0x33, 0x34, 0x64, 0x62, 0x36, 0x64, 0x31, 0x32, 0x61, 0x34, 0x61, 0x31, 0x37, 0x32, 0x33, 0x30, 0x66, 0x66, 0x30, 0x35, 0x36, 0x62, 0x37, 0x61, 0x36, 0x36, 0x66, 0x33, 0x34, 0x31, 0x66, 0x33, 0x63, 0x61, 0x36, 0x38, 0x37, 0x30, 0x65, 0x33, 0x37, 0x34, 0x35, 0x62, 0x34, 0x38, 0x32, 0x30, 0x35, 0x30, 0x37, 0x37, 0x35, 0x33, 0x37, 0x66, 0x36, 0x64, 0x32, 0x34, 0x61, 0x37, 0x35, 0x33, 0x32, 0x38, 0x30, 0x33, 0x36, 0x64, 0x64, 0x30, 0x61, 0x37, 0x38, 0x33, 0x66, 0x32, 0x66, 0x32, 0x37, 0x63, 0x34, 0x30, 0x37, 0x37, 0x64, 0x66, 0x64, 0x64, 0x35, 0x63, 0x33, 0x62, 0x61, 0x32, 0x33, 0x36, 0x37, 0x37, 0x33, 0x63, 0x32, 0x32, 0x31, 0x66, 0x37, 0x61, 0x39, 0x63, 0x61, 0x34, 0x66, 0x66, 0x38, 0x37, 0x37, 0x32, 0x35, 0x36, 0x36, 0x64, 0x66, 0x64, 0x38, 0x37, 0x31, 0x62, 0x61, 0x38, 0x35, 0x36, 0x39, 0x33, 0x37, 0x36, 0x64, 0x31, 0x33, 0x36, 0x65, 0x61, 0x32, 0x34, 0x34, 0x66, 0x65, 0x65, 0x30, 0x63, 0x35, 0x30, 0x63, 0x36, 0x64, 0x30, 0x31, 0x31, 0x34, 0x32, 0x66, 0x64, 0x32, 0x30, 0x36, 0x65, 0x61, 0x33, 0x63, 0x66, 0x64, 0x36, 0x33, 0x65, 0x62, 0x32, 0x62, 0x34, 0x30, 0x36, 0x35, 0x37, 0x65, 0x37, 0x30, 0x32, 0x31, 0x32, 0x32, 0x35, 0x66, 0x38, 0x64, 0x30, 0x32, 0x30, 0x36, 0x39, 0x37, 0x61, 0x61, 0x62, 0x39, 0x35, 0x61, 0x33, 0x63, 0x32, 0x31, 0x37, 0x38, 0x39, 0x63, 0x61, 0x65, 0x64, 0x38, 0x37, 0x37, 0x33, 0x38, 0x61, 0x38, 0x35, 0x65, 0x35, 0x36, 0x30, 0x62, 0x65, 0x37, 0x35, 0x62, 0x66, 0x32, 0x62, 0x66, 0x36, 0x35, 0x61, 0x63, 0x33, 0x64, 0x37, 0x66, 0x33, 0x34, 0x33, 0x32, 0x31, 0x35, 0x62, 0x31, 0x66, 0x30, 0x30, 0x65, 0x63, 0x64, 0x36, 0x65, 0x63, 0x65, 0x38, 0x33, 0x39, 0x64, 0x30, 0x30, 0x39, 0x63, 0x35, 0x61, 0x63, 0x65, 0x31, 0x35, 0x63, 0x61, 0x30, 0x33, 0x33, 0x61, 0x61, 0x62, 0x63, 0x35, 0x37, 0x32, 0x61, 0x65, 0x34, 0x35, 0x63, 0x38, 0x63, 0x32, 0x63, 0x30, 0x31, 0x63, 0x30, 0x33, 0x31, 0x65, 0x37, 0x61, 0x30, 0x66, 0x65, 0x35, 0x65, 0x38, 0x65, 0x38, 0x65, 0x36, 0x32, 0x30, 0x66, 0x37, 0x34, 0x35, 0x63, 0x38, 0x39, 0x38, 0x32, 0x30, 0x37, 0x64, 0x63, 0x35, 0x66, 0x33, 0x30, 0x37, 0x33, 0x30, 0x34, 0x63, 0x61, 0x35, 0x62, 0x39, 0x32, 0x31, 0x34, 0x31, 0x35, 0x30, 0x37, 0x32, 0x35, 0x33, 0x64, 0x33, 0x61, 0x34, 0x63, 0x31, 0x63, 0x36, 0x62, 0x36, 0x32, 0x66, 0x33, 0x62, 0x36, 0x35, 0x31, 0x65, 0x30, 0x61, 0x61, 0x35, 0x63, 0x61, 0x31, 0x64, 0x39, 0x39, 0x32, 0x39, 0x34, 0x62, 0x34, 0x30, 0x65, 0x33, 0x37, 0x37, 0x63, 0x65, 0x36, 0x38, 0x37, 0x61, 0x64, 0x37, 0x63, 0x34, 0x31, 0x36, 0x39, 0x65, 0x32, 0x63, 0x66, 0x64, 0x30, 0x38, 0x34, 0x36, 0x35, 0x38, 0x35, 0x61, 0x31, 0x34, 0x61, 0x62, 0x36, 0x61, 0x34, 0x35, 0x31, 0x37, 0x30, 0x33, 0x32, 0x36, 0x38, 0x66, 0x61, 0x37, 0x39, 0x34, 0x33, 0x32, 0x35, 0x64, 0x30, 0x30, 0x31, 0x65, 0x63, 0x37, 0x38, 0x30, 0x34, 0x61, 0x64, 0x63, 0x39, 0x33, 0x65, 0x66, 0x31, 0x62, 0x65, 0x31, 0x34, 0x34, 0x36, 0x66, 0x35, 0x30, 0x62, 0x63, 0x39, 0x65, 0x61, 0x61, 0x64, 0x37, 0x61, 0x62, 0x37, 0x32, 0x34, 0x31, 0x66, 0x36, 0x35, 0x63, 0x66, 0x36, 0x61, 0x30, 0x34, 0x32, 0x39, 0x33, 0x35, 0x32, 0x32, 0x31, 0x62, 0x36, 0x61, 0x38, 0x32, 0x66, 0x61, 0x37, 0x36, 0x35, 0x30, 0x30, 0x61, 0x37, 0x63, 0x38, 0x32, 0x37, 0x32, 0x39, 0x30, 0x36, 0x34, 0x61, 0x63, 0x32, 0x36, 0x39, 0x65, 0x63, 0x31, 0x35, 0x62, 0x37, 0x36, 0x30, 0x31, 0x34, 0x66, 0x64, 0x35, 0x35, 0x63, 0x37, 0x37, 0x32, 0x31, 0x61, 0x33, 0x66, 0x39, 0x62, 0x34, 0x38, 0x61, 0x63, 0x66, 0x61, 0x62, 0x62, 0x39, 0x62, 0x36, 0x35, 0x65, 0x38, 0x39, 0x61, 0x62, 0x34, 0x64, 0x33, 0x35, 0x38, 0x66, 0x31, 0x33, 0x36, 0x37, 0x64, 0x36, 0x39, 0x62, 0x62, 0x30, 0x35, 0x31, 0x64, 0x62, 0x35, 0x64, 0x34, 0x36, 0x32, 0x33, 0x36, 0x39, 0x35, 0x64, 0x34, 0x34, 0x34, 0x62, 0x65, 0x32, 0x38, 0x33, 0x38, 0x33, 0x37, 0x30, 0x61, 0x30, 0x30, 0x39, 0x33, 0x32, 0x64, 0x39, 0x66, 0x65, 0x38, 0x36, 0x35, 0x33, 0x64, 0x62, 0x31, 0x32, 0x62, 0x62, 0x35, 0x30, 0x61, 0x38, 0x61, 0x35, 0x35, 0x39, 0x37, 0x35, 0x62, 0x64, 0x36, 0x39, 0x64, 0x64, 0x39, 0x61, 0x37, 0x31, 0x34, 0x65, 0x35, 0x39, 0x31, 0x63, 0x66, 0x38, 0x30, 0x34, 0x34, 0x33, 0x32, 0x65, 0x61, 0x38, 0x37, 0x62, 0x30, 0x36, 0x61, 0x32, 0x36, 0x35, 0x64, 0x34, 0x62, 0x66, 0x34, 0x62, 0x33, 0x32, 0x37, 0x32, 0x63, 0x38, 0x34, 0x34, 0x32, 0x63, 0x30, 0x32, 0x38, 0x65, 0x39, 0x63, 0x64, 0x33, 0x38, 0x34, 0x32, 0x35, 0x39, 0x61, 0x37, 0x33, 0x37, 0x37, 0x37, 0x65, 0x63, 0x61, 0x34, 0x62, 0x39, 0x33, 0x37, 0x66, 0x63, 0x37, 0x36, 0x39, 0x34, 0x30, 0x39, 0x64, 0x62, 0x39, 0x32, 0x32, 0x31, 0x36, 0x35, 0x34, 0x62, 0x37, 0x32, 0x39, 0x64, 0x32, 0x30, 0x36, 0x36, 0x33, 0x62, 0x37, 0x35, 0x31, 0x37, 0x36, 0x37, 0x37, 0x63, 0x33, 0x31, 0x34, 0x65, 0x39, 0x30, 0x34, 0x35, 0x65, 0x37, 0x38, 0x65, 0x37, 0x32, 0x66, 0x63, 0x66, 0x36, 0x39, 0x39, 0x38, 0x63, 0x30, 0x38, 0x32, 0x36, 0x37, 0x36, 0x39, 0x32, 0x65, 0x38, 0x30, 0x34, 0x63, 0x65, 0x63, 0x64, 0x31, 0x31, 0x37, 0x61, 0x38, 0x66, 0x31, 0x63, 0x37, 0x32, 0x37, 0x62, 0x62, 0x61, 0x63, 0x63, 0x38, 0x62, 0x39, 0x39, 0x38, 0x38, 0x30, 0x35, 0x32, 0x30, 0x37, 0x30, 0x30, 0x62, 0x30, 0x63, 0x36, 0x37, 0x34, 0x34, 0x62, 0x32, 0x34, 0x34, 0x65, 0x30, 0x63, 0x39, 0x62, 0x32, 0x61, 0x31, 0x63, 0x39, 0x62, 0x38, 0x33, 0x30, 0x30, 0x63, 0x35, 0x39, 0x66, 0x65, 0x61, 0x37, 0x35, 0x37, 0x61, 0x39, 0x66, 0x31, 0x37, 0x38, 0x31, 0x66, 0x35, 0x36, 0x66, 0x66, 0x39, 0x33, 0x65, 0x31, 0x64, 0x31, 0x32, 0x63, 0x39, 0x38, 0x65, 0x34, 0x62, 0x36, 0x34, 0x64, 0x37, 0x36, 0x37, 0x37, 0x66, 0x65, 0x62, 0x65, 0x61, 0x32, 0x34, 0x64, 0x66, 0x34, 0x35, 0x31, 0x37, 0x65, 0x35, 0x62, 0x34, 0x38, 0x63, 0x33, 0x61, 0x30, 0x37, 0x35, 0x34, 0x64, 0x39, 0x37, 0x37, 0x30, 0x63, 0x39, 0x62, 0x62, 0x61, 0x33, 0x66, 0x61, 0x32, 0x39, 0x37, 0x32, 0x35, 0x32, 0x35, 0x37, 0x35, 0x38, 0x38, 0x35, 0x39, 0x62, 0x61, 0x30, 0x38, 0x62, 0x36, 0x35, 0x35, 0x32, 0x64, 0x62, 0x30, 0x33, 0x38, 0x63, 0x37, 0x35, 0x62, 0x66, 0x62, 0x32, 0x65, 0x31, 0x37, 0x30, 0x61, 0x32, 0x34, 0x34, 0x62, 0x39, 0x62, 0x38, 0x38, 0x66, 0x37, 0x33, 0x64, 0x63, 0x66, 0x38, 0x33, 0x64, 0x65, 0x37, 0x36, 0x66, 0x32, 0x65, 0x33, 0x38, 0x64, 0x65, 0x32, 0x30, 0x34, 0x39, 0x39, 0x30, 0x64, 0x36, 0x61, 0x61, 0x33, 0x38, 0x31, 0x63, 0x65, 0x37, 0x64, 0x65, 0x34, 0x33, 0x35, 0x35, 0x31, 0x35, 0x61, 0x37, 0x39, 0x62, 0x66, 0x34, 0x39, 0x35, 0x30, 0x34, 0x36, 0x66, 0x39, 0x32, 0x63, 0x64, 0x62, 0x32, 0x63, 0x66, 0x63, 0x31, 0x63, 0x64, 0x62, 0x34, 0x36, 0x61, 0x61, 0x36, 0x36, 0x65, 0x37, 0x30, 0x32, 0x64, 0x65, 0x65, 0x66, 0x36, 0x35, 0x35, 0x36, 0x35, 0x66, 0x36, 0x64, 0x39, 0x30, 0x30, 0x30, 0x39, 0x39, 0x31, 0x33, 0x37, 0x63, 0x62, 0x39, 0x34, 0x32, 0x38, 0x36, 0x39, 0x64, 0x35, 0x37, 0x37, 0x61, 0x38, 0x34, 0x36, 0x34, 0x32, 0x30, 0x38, 0x37, 0x34, 0x65, 0x64, 0x39, 0x33, 0x31, 0x61, 0x63, 0x30, 0x36, 0x36, 0x66, 0x34, 0x66, 0x38, 0x31, 0x62, 0x64, 0x34, 0x36, 0x32, 0x33, 0x30, 0x63, 0x32, 0x65, 0x36, 0x37, 0x32, 0x39, 0x31, 0x64, 0x38, 0x61, 0x38, 0x36, 0x37, 0x38, 0x39, 0x32, 0x31, 0x39, 0x34, 0x34, 0x37, 0x37, 0x34, 0x61, 0x34, 0x34, 0x30, 0x36, 0x39, 0x63, 0x32, 0x36, 0x32, 0x38, 0x34, 0x35, 0x36, 0x62, 0x36, 0x30, 0x39, 0x31, 0x65, 0x65, 0x33, 0x32, 0x39, 0x32, 0x30, 0x65, 0x63, 0x39, 0x66, 0x62, 0x33, 0x62, 0x66, 0x30, 0x37, 0x30, 0x38, 0x66, 0x31, 0x39, 0x36, 0x37, 0x66, 0x34, 0x33, 0x65, 0x32, 0x63, 0x66, 0x32, 0x63, 0x63, 0x64, 0x30, 0x62, 0x37, 0x35, 0x35, 0x31, 0x34, 0x32, 0x66, 0x66, 0x36, 0x35, 0x39, 0x66, 0x64, 0x37, 0x37, 0x30, 0x35, 0x30, 0x64, 0x34, 0x37, 0x37, 0x62, 0x62, 0x33, 0x62, 0x34, 0x30, 0x36, 0x39, 0x35, 0x32, 0x63, 0x34, 0x36, 0x37, 0x35, 0x35, 0x37, 0x65, 0x39, 0x34, 0x32, 0x61, 0x32, 0x34, 0x33, 0x63, 0x66, 0x36, 0x66, 0x66, 0x37, 0x32, 0x36, 0x62, 0x37, 0x34, 0x66, 0x63, 0x39, 0x33, 0x39, 0x63, 0x39, 0x30, 0x31, 0x62, 0x33, 0x66, 0x39, 0x32, 0x64, 0x31, 0x38, 0x31, 0x39, 0x64, 0x61, 0x37, 0x61, 0x33, 0x39, 0x37, 0x30, 0x62, 0x64, 0x61, 0x39, 0x39, 0x36, 0x62, 0x66, 0x61, 0x62, 0x66, 0x38, 0x33, 0x33, 0x34, 0x37, 0x33, 0x35, 0x38, 0x31, 0x38, 0x36, 0x37, 0x35, 0x37, 0x32, 0x31, 0x66, 0x33, 0x65, 0x66, 0x37, 0x32, 0x63, 0x65, 0x38, 0x33, 0x35, 0x35, 0x35, 0x37, 0x34, 0x33, 0x61, 0x62, 0x39, 0x37, 0x63, 0x35, 0x33, 0x61, 0x62, 0x36, 0x33, 0x32, 0x36, 0x34, 0x64, 0x36, 0x34, 0x65, 0x64, 0x37, 0x32, 0x32, 0x32, 0x37, 0x30, 0x30, 0x37, 0x34, 0x62, 0x61, 0x65, 0x34, 0x33, 0x62, 0x34, 0x30, 0x31, 0x64, 0x30, 0x35, 0x61, 0x34, 0x65, 0x39, 0x62, 0x34, 0x66, 0x66, 0x65, 0x30, 0x39, 0x35, 0x33, 0x35, 0x65, 0x36, 0x62, 0x63, 0x33, 0x30, 0x65, 0x62, 0x62, 0x38, 0x63, 0x33, 0x37, 0x34, 0x39, 0x36, 0x36, 0x66, 0x64, 0x62, 0x36, 0x32, 0x30, 0x31, 0x32, 0x61, 0x32, 0x66, 0x66, 0x37, 0x39, 0x30, 0x37, 0x38, 0x36, 0x35, 0x38, 0x66, 0x61, 0x64, 0x39, 0x30, 0x66, 0x31, 0x65, 0x32, 0x63, 0x62, 0x36, 0x63, 0x33, 0x63, 0x35, 0x36, 0x33, 0x63, 0x33, 0x62, 0x34, 0x32, 0x62, 0x62, 0x37, 0x32, 0x66, 0x63, 0x36, 0x39, 0x30, 0x32, 0x34, 0x65, 0x66, 0x35, 0x34, 0x34, 0x33, 0x39, 0x65, 0x62, 0x63, 0x33, 0x34, 0x36, 0x63, 0x33, 0x39, 0x36, 0x38, 0x34, 0x30, 0x30, 0x32, 0x33, 0x30, 0x35, 0x32, 0x34, 0x39, 0x63, 0x38, 0x63, 0x61, 0x31, 0x33, 0x38, 0x38, 0x34, 0x33, 0x32, 0x66, 0x32, 0x39, 0x39, 0x35, 0x35, 0x62, 0x34, 0x37, 0x39, 0x36, 0x32, 0x36, 0x36, 0x62, 0x66, 0x31, 0x65, 0x34, 0x63, 0x38, 0x39, 0x61, 0x63, 0x32, 0x66, 0x36, 0x34, 0x65, 0x66, 0x30, 0x33, 0x38, 0x37, 0x39, 0x34, 0x31, 0x65, 0x37, 0x34, 0x32, 0x32, 0x32, 0x33, 0x37, 0x37, 0x38, 0x33, 0x66, 0x65, 0x36, 0x38, 0x64, 0x37, 0x38, 0x62, 0x65, 0x39, 0x62, 0x37, 0x34, 0x34, 0x30, 0x36, 0x37, 0x36, 0x66, 0x31, 0x34, 0x36, 0x37, 0x62, 0x35, 0x61, 0x36, 0x66, 0x64, 0x65, 0x31, 0x61, 0x35, 0x39, 0x64, 0x63, 0x64, 0x31, 0x31, 0x62, 0x38, 0x30, 0x32, 0x36, 0x39, 0x35, 0x37, 0x33, 0x39, 0x61, 0x36, 0x35, 0x36, 0x30, 0x33, 0x39, 0x38, 0x36, 0x32, 0x35, 0x38, 0x66, 0x66, 0x34, 0x39, 0x38, 0x30, 0x63, 0x31, 0x34, 0x37, 0x31, 0x31, 0x30, 0x36, 0x32, 0x31, 0x64, 0x61, 0x33, 0x66, 0x32, 0x31, 0x30, 0x64, 0x34, 0x65, 0x64, 0x66, 0x31, 0x36, 0x30, 0x39, 0x62, 0x62, 0x61, 0x37, 0x32, 0x33, 0x34, 0x34, 0x31, 0x39, 0x30, 0x34, 0x62, 0x62, 0x34, 0x37, 0x63, 0x61, 0x37, 0x39, 0x65, 0x32, 0x32, 0x39, 0x31, 0x61, 0x64, 0x37, 0x33, 0x64, 0x30, 0x37, 0x65, 0x62, 0x63, 0x39, 0x34, 0x63, 0x64, 0x64, 0x37, 0x31, 0x64, 0x35, 0x65, 0x66, 0x33, 0x62, 0x30, 0x39, 0x62, 0x34, 0x34, 0x61, 0x62, 0x36, 0x62, 0x62, 0x32, 0x35, 0x30, 0x30, 0x63, 0x33, 0x36, 0x35, 0x61, 0x37, 0x32, 0x38, 0x30, 0x30, 0x36, 0x38, 0x39, 0x34, 0x39, 0x66, 0x37, 0x32, 0x63, 0x61, 0x35, 0x65, 0x39, 0x64, 0x36, 0x39, 0x64, 0x31, 0x64, 0x35, 0x64, 0x35, 0x32, 0x33, 0x65, 0x32, 0x33, 0x65, 0x30, 0x63, 0x61, 0x37, 0x35, 0x38, 0x61, 0x37, 0x37, 0x39, 0x62, 0x37, 0x30, 0x36, 0x32, 0x64, 0x66, 0x62, 0x38, 0x63, 0x65, 0x38, 0x64, 0x32, 0x65, 0x37, 0x39, 0x30, 0x33, 0x62, 0x39, 0x37, 0x32, 0x39, 0x38, 0x36, 0x63, 0x32, 0x66, 0x30, 0x30, 0x38, 0x61, 0x34, 0x37, 0x62, 0x66, 0x33, 0x61, 0x38, 0x38, 0x32, 0x39, 0x36, 0x35, 0x65, 0x63, 0x35, 0x64, 0x38, 0x39, 0x62, 0x63, 0x32, 0x64, 0x66, 0x38, 0x66, 0x35, 0x31, 0x36, 0x33, 0x35, 0x34, 0x34, 0x34, 0x37, 0x35, 0x38, 0x35, 0x37, 0x65, 0x36, 0x37, 0x34, 0x38, 0x32, 0x35, 0x36, 0x30, 0x35, 0x62, 0x31, 0x33, 0x66, 0x37, 0x32, 0x37, 0x34, 0x33, 0x32, 0x61, 0x65, 0x34, 0x37, 0x30, 0x65, 0x63, 0x30, 0x63, 0x34, 0x31, 0x37, 0x33, 0x63, 0x34, 0x66, 0x33, 0x36, 0x63, 0x38, 0x63, 0x33, 0x62, 0x35, 0x63, 0x34, 0x36, 0x38, 0x32, 0x39, 0x38, 0x34, 0x32, 0x65, 0x39, 0x62, 0x61, 0x35, 0x64, 0x38, 0x62, 0x66, 0x36, 0x66, 0x33, 0x34, 0x64, 0x63, 0x34, 0x30, 0x37, 0x33, 0x35, 0x39, 0x66, 0x33, 0x36, 0x33, 0x37, 0x32, 0x31, 0x36, 0x39, 0x34, 0x65, 0x33, 0x33, 0x33, 0x64, 0x33, 0x65, 0x62, 0x39, 0x61, 0x32, 0x34, 0x61, 0x62, 0x32, 0x31, 0x38, 0x36, 0x32, 0x34, 0x62, 0x35, 0x38, 0x32, 0x66, 0x33, 0x34, 0x32, 0x38, 0x39, 0x38, 0x37, 0x30, 0x32, 0x32, 0x64, 0x66, 0x63, 0x65, 0x37, 0x30, 0x61, 0x36, 0x62, 0x34, 0x62, 0x31, 0x36, 0x39, 0x39, 0x31, 0x35, 0x34, 0x36, 0x33, 0x61, 0x30, 0x35, 0x37, 0x32, 0x32, 0x36, 0x37, 0x64, 0x62, 0x34, 0x30, 0x35, 0x39, 0x34, 0x39, 0x36, 0x36, 0x63, 0x39, 0x36, 0x64, 0x34, 0x62, 0x61, 0x31, 0x34, 0x65, 0x62, 0x38, 0x63, 0x37, 0x65, 0x31, 0x38, 0x61, 0x32, 0x34, 0x62, 0x37, 0x38, 0x65, 0x36, 0x62, 0x30, 0x34, 0x64, 0x62, 0x62, 0x36, 0x35, 0x38, 0x37, 0x34, 0x61, 0x34, 0x65, 0x33, 0x31, 0x35, 0x65, 0x30, 0x30, 0x34, 0x37, 0x30, 0x35, 0x37, 0x32, 0x61, 0x35, 0x35, 0x36, 0x66, 0x32, 0x39, 0x31, 0x62, 0x37, 0x65, 0x35, 0x34, 0x39, 0x35, 0x66, 0x39, 0x31, 0x33, 0x30, 0x32, 0x32, 0x32, 0x31, 0x38, 0x35, 0x61, 0x63, 0x39, 0x32, 0x61, 0x66, 0x66, 0x32, 0x35, 0x64, 0x63, 0x36, 0x35, 0x30, 0x39, 0x31, 0x61, 0x37, 0x39, 0x61, 0x65, 0x66, 0x35, 0x33, 0x37, 0x65, 0x39, 0x35, 0x37, 0x37, 0x33, 0x33, 0x63, 0x33, 0x39, 0x61, 0x37, 0x32, 0x36, 0x39, 0x39, 0x31, 0x38, 0x31, 0x66, 0x61, 0x62, 0x34, 0x34, 0x35, 0x32, 0x65, 0x65, 0x34, 0x31, 0x39, 0x61, 0x61, 0x64, 0x66, 0x64, 0x39, 0x62, 0x34, 0x61, 0x39, 0x33, 0x39, 0x39, 0x37, 0x30, 0x64, 0x30, 0x66, 0x35, 0x39, 0x38, 0x35, 0x66, 0x37, 0x65, 0x66, 0x37, 0x63, 0x65, 0x61, 0x36, 0x65, 0x66, 0x63, 0x34, 0x65, 0x63, 0x64, 0x34, 0x32, 0x36, 0x35, 0x66, 0x39, 0x37, 0x32, 0x35, 0x31, 0x32, 0x64, 0x66, 0x38, 0x30, 0x35, 0x31, 0x36, 0x39, 0x38, 0x65, 0x63, 0x63, 0x36, 0x39, 0x33, 0x36, 0x33, 0x62, 0x63, 0x63, 0x31, 0x64, 0x31, 0x61, 0x37, 0x65, 0x37, 0x37, 0x61, 0x39, 0x64, 0x62, 0x36, 0x32, 0x66, 0x36, 0x62, 0x66, 0x33, 0x36, 0x35, 0x64, 0x63, 0x32, 0x36, 0x65, 0x65, 0x34, 0x30, 0x63, 0x63, 0x39, 0x39, 0x64, 0x64, 0x38, 0x30, 0x39, 0x31, 0x37, 0x32, 0x39, 0x38, 0x34, 0x36, 0x38, 0x37, 0x34, 0x31, 0x35, 0x37, 0x61, 0x36, 0x61, 0x61, 0x61, 0x62, 0x61, 0x65, 0x66, 0x63, 0x63, 0x34, 0x33, 0x62, 0x65, 0x65, 0x36, 0x66, 0x66, 0x66, 0x30, 0x39, 0x37, 0x33, 0x34, 0x65, 0x32, 0x34, 0x34, 0x37, 0x39, 0x31, 0x36, 0x35, 0x61, 0x31, 0x64, 0x61, 0x61, 0x65, 0x66, 0x36, 0x30, 0x33, 0x62, 0x64, 0x65, 0x34, 0x63, 0x64, 0x35, 0x35, 0x37, 0x32, 0x66, 0x33, 0x61, 0x31, 0x37, 0x39, 0x31, 0x34, 0x66, 0x33, 0x63, 0x66, 0x63, 0x32, 0x35, 0x33, 0x61, 0x31, 0x34, 0x35, 0x37, 0x31, 0x63, 0x66, 0x32, 0x37, 0x61, 0x38, 0x38, 0x33, 0x38, 0x37, 0x34, 0x64, 0x30, 0x30, 0x31, 0x63, 0x37, 0x30, 0x36, 0x31, 0x31, 0x35, 0x32, 0x35, 0x36, 0x33, 0x31, 0x61, 0x64, 0x66, 0x30, 0x61, 0x66, 0x64, 0x64, 0x63, 0x38, 0x31, 0x33, 0x36, 0x33, 0x65, 0x32, 0x32, 0x39, 0x32, 0x31, 0x36, 0x61, 0x36, 0x38, 0x35, 0x65, 0x62, 0x39, 0x33, 0x36, 0x63, 0x31, 0x38, 0x32, 0x64, 0x64, 0x34, 0x62, 0x32, 0x30, 0x63, 0x61, 0x32, 0x66, 0x33, 0x36, 0x31, 0x64, 0x31, 0x32, 0x61, 0x34, 0x36, 0x36, 0x31, 0x36, 0x33, 0x35, 0x64, 0x31, 0x33, 0x30, 0x35, 0x61, 0x35, 0x35, 0x65, 0x38, 0x34, 0x30, 0x38, 0x37, 0x37, 0x66, 0x63, 0x64, 0x31, 0x35, 0x38, 0x62, 0x64, 0x37, 0x62, 0x32, 0x62, 0x36, 0x62, 0x66, 0x37, 0x38, 0x36, 0x32, 0x36, 0x66, 0x65, 0x39, 0x62, 0x33, 0x64, 0x65, 0x61, 0x34, 0x32, 0x62, 0x61, 0x34, 0x36, 0x34, 0x66, 0x61, 0x38, 0x66, 0x34, 0x61, 0x34, 0x33, 0x37, 0x31, 0x35, 0x63, 0x35, 0x31, 0x32, 0x61, 0x32, 0x65, 0x33, 0x39, 0x66, 0x37, 0x32, 0x64, 0x63, 0x64, 0x36, 0x39, 0x63, 0x31, 0x66, 0x35, 0x63, 0x37, 0x32, 0x30, 0x30, 0x66, 0x32, 0x62, 0x62, 0x65, 0x36, 0x37, 0x39, 0x32, 0x38, 0x64, 0x64, 0x33, 0x39, 0x33, 0x32, 0x62, 0x64, 0x66, 0x65, 0x61, 0x64, 0x61, 0x33, 0x35, 0x66, 0x64, 0x37, 0x62, 0x62, 0x62, 0x38, 0x30, 0x66, 0x65, 0x34, 0x31, 0x66, 0x63, 0x62, 0x61, 0x39, 0x62, 0x30, 0x37, 0x34, 0x33, 0x38, 0x33, 0x64, 0x34, 0x63, 0x30, 0x39, 0x38, 0x39, 0x63, 0x39, 0x37, 0x63, 0x37, 0x32, 0x63, 0x32, 0x61, 0x37, 0x65, 0x35, 0x64, 0x33, 0x37, 0x38, 0x30, 0x35, 0x62, 0x61, 0x39, 0x63, 0x33, 0x32, 0x36, 0x66, 0x64, 0x37, 0x61, 0x30, 0x33, 0x33, 0x65, 0x37, 0x34, 0x34, 0x31, 0x30, 0x30, 0x63, 0x39, 0x39, 0x30, 0x35, 0x62, 0x33, 0x36, 0x34, 0x66, 0x66, 0x38, 0x61, 0x38, 0x36, 0x66, 0x31, 0x65, 0x61, 0x31, 0x66, 0x37, 0x65, 0x37, 0x63, 0x34, 0x32, 0x66, 0x37, 0x37, 0x32, 0x62, 0x32, 0x66, 0x61, 0x35, 0x61, 0x31, 0x31, 0x30, 0x32, 0x33, 0x35, 0x39, 0x64, 0x65, 0x33, 0x32, 0x64, 0x62, 0x32, 0x30, 0x33, 0x31, 0x66, 0x39, 0x31, 0x34, 0x38, 0x63, 0x63, 0x37, 0x66, 0x63, 0x33, 0x32, 0x66, 0x64, 0x31, 0x39, 0x61, 0x64, 0x61, 0x30, 0x30, 0x34, 0x62, 0x66, 0x30, 0x31, 0x31, 0x36, 0x63, 0x36, 0x36, 0x35, 0x65, 0x33, 0x61, 0x62, 0x31, 0x31, 0x31, 0x35, 0x64, 0x31, 0x61, 0x36, 0x35, 0x30, 0x36, 0x33, 0x64, 0x66, 0x33, 0x39, 0x36, 0x62, 0x31, 0x64, 0x37, 0x37, 0x65, 0x32, 0x31, 0x62, 0x36, 0x65, 0x37, 0x32, 0x31, 0x62, 0x66, 0x65, 0x34, 0x63, 0x36, 0x65, 0x65, 0x39, 0x36, 0x37, 0x39, 0x61, 0x36, 0x31, 0x62, 0x35, 0x32, 0x32, 0x63, 0x38, 0x30, 0x64, 0x36, 0x37, 0x39, 0x35, 0x35, 0x64, 0x61, 0x64, 0x65, 0x34, 0x62, 0x64, 0x37, 0x37, 0x32, 0x35, 0x62, 0x64, 0x63, 0x65, 0x36, 0x39, 0x62, 0x38, 0x64, 0x32, 0x34, 0x37, 0x35, 0x38, 0x62, 0x33, 0x61, 0x39, 0x62, 0x34, 0x63, 0x39, 0x32, 0x30, 0x31, 0x64, 0x61, 0x64, 0x31, 0x39, 0x36, 0x62, 0x35, 0x37, 0x32, 0x39, 0x36, 0x61, 0x62, 0x62, 0x32, 0x39, 0x63, 0x66, 0x61, 0x61, 0x66, 0x33, 0x34, 0x34, 0x38, 0x35, 0x66, 0x61, 0x31, 0x63, 0x31, 0x32, 0x62, 0x37, 0x39, 0x36, 0x39, 0x38, 0x35, 0x30, 0x38, 0x31, 0x33, 0x65, 0x61, 0x31, 0x39, 0x64, 0x31, 0x34, 0x61, 0x65, 0x31, 0x63, 0x63, 0x61, 0x36, 0x66, 0x38, 0x39, 0x34, 0x63, 0x38, 0x33, 0x38, 0x64, 0x33, 0x30, 0x33, 0x38, 0x36, 0x38, 0x30, 0x66, 0x66, 0x37, 0x38, 0x66, 0x32, 0x39, 0x38, 0x36, 0x62, 0x36, 0x62, 0x31, 0x37, 0x32, 0x30, 0x36, 0x66, 0x33, 0x39, 0x61, 0x35, 0x35, 0x32, 0x64, 0x31, 0x37, 0x32, 0x39, 0x32, 0x63, 0x34, 0x30, 0x62, 0x61, 0x38, 0x37, 0x39, 0x65, 0x35, 0x31, 0x31, 0x64, 0x62, 0x65, 0x34, 0x36, 0x36, 0x62, 0x34, 0x39, 0x32, 0x30, 0x30, 0x38, 0x33, 0x62, 0x35, 0x64, 0x64, 0x33, 0x65, 0x63, 0x65, 0x65, 0x39, 0x36, 0x37, 0x38, 0x37, 0x38, 0x62, 0x65, 0x39, 0x33, 0x30, 0x38, 0x37, 0x31, 0x31, 0x33, 0x39, 0x39, 0x33, 0x37, 0x36, 0x36, 0x33, 0x66, 0x36, 0x31, 0x61, 0x36, 0x65, 0x34, 0x64, 0x39, 0x38, 0x33, 0x31, 0x66, 0x65, 0x62, 0x30, 0x35, 0x36, 0x35, 0x36, 0x39, 0x32, 0x66, 0x63, 0x39, 0x64, 0x64, 0x38, 0x62, 0x35, 0x61, 0x62, 0x61, 0x66, 0x33, 0x64, 0x62, 0x32, 0x30, 0x64, 0x36, 0x62, 0x66, 0x30, 0x38, 0x37, 0x63, 0x38, 0x64, 0x64, 0x38, 0x65, 0x35, 0x38, 0x62, 0x30, 0x35, 0x34, 0x30, 0x39, 0x34, 0x63, 0x31, 0x33, 0x37, 0x61, 0x30, 0x30, 0x34, 0x66, 0x66, 0x64, 0x62, 0x65, 0x66, 0x32, 0x31, 0x38, 0x39, 0x34, 0x37, 0x63, 0x63, 0x63, 0x65, 0x35, 0x61, 0x63, 0x31, 0x30, 0x36, 0x38, 0x31, 0x30, 0x61, 0x35, 0x30, 0x30, 0x38, 0x64, 0x37, 0x36, 0x32, 0x38, 0x34, 0x62, 0x35, 0x39, 0x64, 0x64, 0x37, 0x32, 0x39, 0x65, 0x37, 0x34, 0x36, 0x30, 0x65, 0x37, 0x35, 0x39, 0x62, 0x31, 0x39, 0x36, 0x33, 0x37, 0x32, 0x33, 0x37, 0x32, 0x32, 0x66, 0x66, 0x31, 0x62, 0x34, 0x37, 0x65, 0x32, 0x38, 0x38, 0x64, 0x39, 0x63, 0x36, 0x37, 0x35, 0x33, 0x31, 0x65, 0x35, 0x65, 0x39, 0x64, 0x39, 0x63, 0x65, 0x30, 0x65, 0x64, 0x61, 0x39, 0x38, 0x32, 0x30, 0x62, 0x36, 0x31, 0x32, 0x32, 0x66, 0x62, 0x30, 0x39, 0x39, 0x34, 0x38, 0x38, 0x32, 0x36, 0x34, 0x31, 0x30, 0x63, 0x66, 0x61, 0x30, 0x64, 0x32, 0x32, 0x65, 0x33, 0x37, 0x32, 0x39, 0x62, 0x37, 0x30, 0x30, 0x62, 0x34, 0x64, 0x62, 0x33, 0x66, 0x36, 0x64, 0x61, 0x33, 0x63, 0x39, 0x39, 0x34, 0x64, 0x65, 0x35, 0x37, 0x33, 0x33, 0x31, 0x35, 0x61, 0x34, 0x35, 0x66, 0x30, 0x32, 0x38, 0x35, 0x65, 0x63, 0x66, 0x65, 0x31, 0x36, 0x34, 0x64, 0x38, 0x34, 0x34, 0x32, 0x38, 0x32, 0x31, 0x61, 0x62, 0x64, 0x33, 0x63, 0x61, 0x31, 0x32, 0x34, 0x37, 0x31, 0x64, 0x37, 0x32, 0x63, 0x61, 0x33, 0x65, 0x38, 0x30, 0x35, 0x38, 0x33, 0x33, 0x33, 0x66, 0x62, 0x37, 0x30, 0x62, 0x65, 0x32, 0x39, 0x34, 0x38, 0x66, 0x61, 0x65, 0x39, 0x62, 0x65, 0x66, 0x62, 0x63, 0x63, 0x63, 0x61, 0x62, 0x34, 0x61, 0x64, 0x33, 0x65, 0x32, 0x66, 0x62, 0x33, 0x62, 0x39, 0x39, 0x66, 0x63, 0x38, 0x33, 0x32, 0x61, 0x61, 0x62, 0x63, 0x65, 0x39, 0x61, 0x36, 0x37, 0x65, 0x66, 0x37, 0x32, 0x65, 0x61, 0x38, 0x39, 0x32, 0x38, 0x37, 0x33, 0x61, 0x36, 0x37, 0x35, 0x37, 0x66, 0x65, 0x33, 0x37, 0x65, 0x37, 0x34, 0x65, 0x36, 0x34, 0x66, 0x39, 0x31, 0x65, 0x34, 0x63, 0x30, 0x66, 0x31, 0x31, 0x37, 0x32, 0x31, 0x66, 0x38, 0x62, 0x32, 0x39, 0x35, 0x66, 0x35, 0x65, 0x65, 0x30, 0x62, 0x34, 0x34, 0x65, 0x66, 0x30, 0x62, 0x34, 0x37, 0x62, 0x65, 0x65, 0x36, 0x36, 0x31, 0x34, 0x31, 0x35, 0x33, 0x61, 0x64, 0x33, 0x39, 0x63, 0x39, 0x64, 0x33, 0x38, 0x61, 0x31, 0x64, 0x66, 0x32, 0x61, 0x66, 0x32, 0x66, 0x62, 0x35, 0x31, 0x62, 0x37, 0x38, 0x33, 0x37, 0x37, 0x35, 0x37, 0x65, 0x61, 0x64, 0x37, 0x62, 0x62, 0x32, 0x62, 0x39, 0x64, 0x64, 0x66, 0x39, 0x35, 0x39, 0x66, 0x63, 0x38, 0x66, 0x62, 0x61, 0x36, 0x65, 0x30, 0x37, 0x66, 0x38, 0x61, 0x30, 0x62, 0x66, 0x37, 0x32, 0x34, 0x61, 0x35, 0x32, 0x65, 0x33, 0x63, 0x63, 0x36, 0x66, 0x34, 0x33, 0x36, 0x36, 0x36, 0x35, 0x32, 0x66, 0x30, 0x65, 0x63, 0x31, 0x63, 0x33, 0x37, 0x35, 0x33, 0x31, 0x30, 0x38, 0x61, 0x65, 0x36, 0x61, 0x63, 0x66, 0x39, 0x63, 0x37, 0x66, 0x65, 0x63, 0x64, 0x62, 0x34, 0x34, 0x31, 0x65, 0x33, 0x62, 0x30, 0x31, 0x65, 0x61, 0x33, 0x37, 0x36, 0x65, 0x64, 0x32, 0x64, 0x63, 0x36, 0x62, 0x62, 0x37, 0x30, 0x37, 0x66, 0x38, 0x35, 0x65, 0x61, 0x30, 0x34, 0x39, 0x38, 0x36, 0x66, 0x63, 0x39, 0x30, 0x64, 0x65, 0x61, 0x34, 0x64, 0x35, 0x37, 0x64, 0x33, 0x64, 0x61, 0x31, 0x64, 0x37, 0x64, 0x31, 0x35, 0x39, 0x34, 0x33, 0x39, 0x63, 0x34, 0x33, 0x64, 0x62, 0x63, 0x65, 0x65, 0x33, 0x38, 0x33, 0x63, 0x36, 0x64, 0x39, 0x39, 0x32, 0x30, 0x36, 0x63, 0x35, 0x37, 0x32, 0x35, 0x65, 0x35, 0x34, 0x31, 0x35, 0x64, 0x35, 0x34, 0x38, 0x33, 0x33, 0x32, 0x32, 0x32, 0x36, 0x34, 0x37, 0x32, 0x37, 0x34, 0x31, 0x30, 0x35, 0x36, 0x64, 0x62, 0x61, 0x37, 0x36, 0x39, 0x61, 0x38, 0x36, 0x35, 0x65, 0x62, 0x39, 0x35, 0x38, 0x32, 0x32, 0x61, 0x32, 0x34, 0x63, 0x37, 0x39, 0x65, 0x33, 0x36, 0x66, 0x33, 0x33, 0x65, 0x39, 0x32, 0x34, 0x34, 0x30, 0x36, 0x62, 0x39, 0x36, 0x37, 0x32, 0x30, 0x65, 0x32, 0x62, 0x34, 0x36, 0x39, 0x65, 0x62, 0x35, 0x35, 0x36, 0x66, 0x32, 0x38, 0x36, 0x32, 0x39, 0x62, 0x30, 0x66, 0x30, 0x33, 0x63, 0x37, 0x65, 0x65, 0x61, 0x35, 0x65, 0x30, 0x33, 0x32, 0x39, 0x36, 0x31, 0x35, 0x39, 0x65, 0x36, 0x66, 0x30, 0x37, 0x33, 0x30, 0x62, 0x65, 0x31, 0x62, 0x66, 0x35, 0x33, 0x34, 0x34, 0x34, 0x38, 0x65, 0x37, 0x31, 0x65, 0x36, 0x64, 0x37, 0x32, 0x63, 0x65, 0x30, 0x36, 0x61, 0x36, 0x66, 0x30, 0x66, 0x33, 0x30, 0x62, 0x32, 0x37, 0x39, 0x33, 0x31, 0x38, 0x61, 0x33, 0x65, 0x64, 0x63, 0x38, 0x30, 0x65, 0x35, 0x39, 0x34, 0x37, 0x31, 0x33, 0x66, 0x65, 0x62, 0x35, 0x30, 0x34, 0x31, 0x32, 0x37, 0x39, 0x32, 0x30, 0x65, 0x66, 0x39, 0x64, 0x65, 0x36, 0x34, 0x31, 0x32, 0x37, 0x61, 0x38, 0x61, 0x32, 0x36, 0x32, 0x33, 0x32, 0x37, 0x31, 0x62, 0x30, 0x62, 0x33, 0x66, 0x34, 0x62, 0x31, 0x63, 0x66, 0x32, 0x30, 0x61, 0x37, 0x39, 0x65, 0x36, 0x32, 0x30, 0x66, 0x64, 0x38, 0x32, 0x64, 0x61, 0x37, 0x31, 0x36, 0x66, 0x34, 0x64, 0x65, 0x36, 0x62, 0x65, 0x34, 0x36, 0x66, 0x37, 0x36, 0x61, 0x34, 0x64, 0x64, 0x35, 0x39, 0x32, 0x62, 0x31, 0x38, 0x62, 0x64, 0x65, 0x38, 0x36, 0x33, 0x31, 0x34, 0x32, 0x38, 0x66, 0x35, 0x37, 0x32, 0x64, 0x30, 0x61, 0x35, 0x39, 0x38, 0x62, 0x33, 0x65, 0x31, 0x36, 0x38, 0x32, 0x30, 0x38, 0x61, 0x64, 0x62, 0x39, 0x34, 0x62, 0x66, 0x35, 0x31, 0x35, 0x39, 0x33, 0x63, 0x39, 0x39, 0x30, 0x32, 0x64, 0x34, 0x33, 0x63, 0x62, 0x62, 0x66, 0x35, 0x66, 0x31, 0x37, 0x39, 0x66, 0x30, 0x64, 0x30, 0x62, 0x33, 0x64, 0x66, 0x64, 0x62, 0x65, 0x32, 0x32, 0x30, 0x38, 0x30, 0x37, 0x62, 0x30, 0x38, 0x32, 0x31, 0x34, 0x31, 0x39, 0x30, 0x32, 0x62, 0x32, 0x63, 0x33, 0x39, 0x39, 0x62, 0x39, 0x35, 0x31, 0x37, 0x32, 0x62, 0x62, 0x63, 0x63, 0x62, 0x36, 0x65, 0x63, 0x66, 0x64, 0x65, 0x35, 0x61, 0x38, 0x36, 0x65, 0x30, 0x31, 0x65, 0x36, 0x66, 0x31, 0x65, 0x65, 0x64, 0x32, 0x37, 0x32, 0x63, 0x37, 0x35, 0x62, 0x36, 0x37, 0x35, 0x66, 0x38, 0x31, 0x30, 0x62, 0x38, 0x38, 0x62, 0x37, 0x32, 0x66, 0x35, 0x36, 0x66, 0x34, 0x64, 0x61, 0x64, 0x64, 0x38, 0x64, 0x39, 0x30, 0x30, 0x66, 0x62, 0x63, 0x33, 0x32, 0x32, 0x66, 0x36, 0x30, 0x33, 0x61, 0x63, 0x31, 0x65, 0x64, 0x35, 0x32, 0x63, 0x63, 0x62, 0x38, 0x32, 0x34, 0x61, 0x65, 0x39, 0x36, 0x33, 0x33, 0x38, 0x63, 0x61, 0x64, 0x65, 0x66, 0x34, 0x61, 0x36, 0x63, 0x66, 0x39, 0x38, 0x30, 0x62, 0x62, 0x63, 0x62, 0x63, 0x30, 0x35, 0x39, 0x36, 0x37, 0x35, 0x61, 0x65, 0x31, 0x66, 0x31, 0x65, 0x63, 0x33, 0x61, 0x38, 0x36, 0x39, 0x30, 0x38, 0x31, 0x62, 0x34, 0x64, 0x30, 0x64, 0x32, 0x31, 0x64, 0x65, 0x66, 0x39, 0x63, 0x64, 0x31, 0x62, 0x30, 0x66, 0x37, 0x64, 0x32, 0x32, 0x66, 0x39, 0x30, 0x31, 0x61, 0x31, 0x62, 0x64, 0x34, 0x66, 0x61, 0x62, 0x63, 0x38, 0x35, 0x61, 0x37, 0x30, 0x62, 0x39, 0x34, 0x62, 0x37, 0x32, 0x32, 0x39, 0x63, 0x63, 0x64, 0x31, 0x37, 0x66, 0x62, 0x66, 0x38, 0x34, 0x66, 0x38, 0x35, 0x38, 0x63, 0x36, 0x39, 0x33, 0x37, 0x39, 0x63, 0x32, 0x37, 0x30, 0x64, 0x66, 0x37, 0x64, 0x64, 0x34, 0x65, 0x62, 0x63, 0x34, 0x39, 0x65, 0x32, 0x39, 0x39, 0x30, 0x39, 0x62, 0x61, 0x62, 0x39, 0x37, 0x65, 0x62, 0x62, 0x65, 0x35, 0x32, 0x64, 0x34, 0x32, 0x61, 0x30, 0x64, 0x32, 0x66, 0x30, 0x37, 0x30, 0x33, 0x31, 0x39, 0x63, 0x39, 0x32, 0x35, 0x33, 0x30, 0x66, 0x33, 0x32, 0x36, 0x35, 0x34, 0x35, 0x38, 0x63, 0x65, 0x33, 0x39, 0x39, 0x61, 0x62, 0x65, 0x65, 0x63, 0x35, 0x65, 0x31, 0x39, 0x34, 0x31, 0x38, 0x33, 0x34, 0x66, 0x34, 0x33, 0x38, 0x36, 0x37, 0x38, 0x34, 0x38, 0x38, 0x37, 0x62, 0x65, 0x32, 0x62, 0x33, 0x35, 0x30, 0x35, 0x35, 0x62, 0x39, 0x34, 0x39, 0x64, 0x37, 0x32, 0x30, 0x38, 0x61, 0x32, 0x38, 0x37, 0x31, 0x65, 0x63, 0x30, 0x66, 0x33, 0x31, 0x31, 0x37, 0x37, 0x62, 0x63, 0x34, 0x63, 0x32, 0x35, 0x35, 0x64, 0x32, 0x35, 0x62, 0x31, 0x61, 0x32, 0x33, 0x30, 0x33, 0x64, 0x30, 0x31, 0x30, 0x35, 0x35, 0x66, 0x38, 0x37, 0x38, 0x35, 0x66, 0x63, 0x65, 0x61, 0x31, 0x32, 0x30, 0x39, 0x61, 0x33, 0x30, 0x34, 0x36, 0x61, 0x66, 0x35, 0x63, 0x35, 0x37, 0x32, 0x35, 0x66, 0x63, 0x66, 0x32, 0x65, 0x36, 0x34, 0x36, 0x32, 0x64, 0x61, 0x37, 0x63, 0x64, 0x66, 0x38, 0x33, 0x34, 0x32, 0x37, 0x62, 0x62, 0x34, 0x35, 0x65, 0x61, 0x39, 0x39, 0x34, 0x65, 0x63, 0x35, 0x35, 0x62, 0x35, 0x33, 0x61, 0x64, 0x30, 0x32, 0x34, 0x37, 0x32, 0x33, 0x38, 0x37, 0x61, 0x39, 0x39, 0x62, 0x63, 0x38, 0x35, 0x30, 0x30, 0x62, 0x35, 0x31, 0x62, 0x37, 0x32, 0x37, 0x32, 0x35, 0x66, 0x38, 0x35, 0x37, 0x36, 0x33, 0x37, 0x33, 0x66, 0x39, 0x32, 0x61, 0x61, 0x38, 0x31, 0x34, 0x37, 0x32, 0x66, 0x39, 0x31, 0x35, 0x62, 0x61, 0x38, 0x39, 0x64, 0x37, 0x35, 0x33, 0x31, 0x62, 0x32, 0x30, 0x32, 0x38, 0x38, 0x39, 0x62, 0x62, 0x61, 0x62, 0x35, 0x37, 0x62, 0x62, 0x63, 0x36, 0x35, 0x35, 0x65, 0x33, 0x61, 0x64, 0x39, 0x63, 0x30, 0x33, 0x35, 0x30, 0x65, 0x33, 0x61, 0x30, 0x37, 0x35, 0x64, 0x65, 0x31, 0x34, 0x63, 0x37, 0x64, 0x36, 0x62, 0x36, 0x37, 0x31, 0x30, 0x32, 0x34, 0x37, 0x32, 0x33, 0x61, 0x31, 0x31, 0x35, 0x39, 0x63, 0x65, 0x35, 0x63, 0x39, 0x36, 0x32, 0x62, 0x66, 0x64, 0x66, 0x66, 0x66, 0x65, 0x63, 0x35, 0x38, 0x31, 0x33, 0x36, 0x61, 0x36, 0x38, 0x61, 0x30, 0x37, 0x30, 0x39, 0x38, 0x35, 0x66, 0x38, 0x37, 0x64, 0x63, 0x32, 0x30, 0x39, 0x62, 0x34, 0x37, 0x35, 0x35, 0x66, 0x64, 0x66, 0x65, 0x66, 0x30, 0x36, 0x64, 0x37, 0x36, 0x35, 0x34, 0x36, 0x36, 0x38, 0x36, 0x64, 0x37, 0x62, 0x38, 0x39, 0x64, 0x38, 0x35, 0x63, 0x35, 0x66, 0x65, 0x31, 0x39, 0x33, 0x36, 0x63, 0x35, 0x37, 0x65, 0x35, 0x34, 0x62, 0x64, 0x64, 0x32, 0x37, 0x32, 0x66, 0x37, 0x61, 0x34, 0x32, 0x39, 0x38, 0x31, 0x65, 0x38, 0x30, 0x32, 0x65, 0x37, 0x32, 0x37, 0x33, 0x36, 0x38, 0x66, 0x65, 0x62, 0x34, 0x31, 0x30, 0x35, 0x31, 0x65, 0x34, 0x38, 0x37, 0x39, 0x30, 0x65, 0x30, 0x66, 0x33, 0x64, 0x61, 0x35, 0x35, 0x30, 0x30, 0x61, 0x34, 0x31, 0x33, 0x38, 0x33, 0x39, 0x32, 0x63, 0x35, 0x61, 0x63, 0x64, 0x32, 0x66, 0x63, 0x30, 0x65, 0x63, 0x33, 0x63, 0x37, 0x33, 0x62, 0x66, 0x61, 0x61, 0x36, 0x66, 0x36, 0x66, 0x32, 0x39, 0x32, 0x37, 0x32, 0x33, 0x30, 0x61, 0x63, 0x34, 0x38, 0x65, 0x37, 0x66, 0x33, 0x64, 0x38, 0x37, 0x37, 0x33, 0x63, 0x61, 0x33, 0x33, 0x38, 0x62, 0x66, 0x38, 0x61, 0x39, 0x63, 0x30, 0x64, 0x39, 0x39, 0x37, 0x62, 0x31, 0x30, 0x37, 0x31, 0x61, 0x33, 0x65, 0x62, 0x61, 0x32, 0x33, 0x64, 0x35, 0x62, 0x62, 0x30, 0x39, 0x32, 0x66, 0x63, 0x38, 0x66, 0x61, 0x32, 0x33, 0x36, 0x38, 0x64, 0x33, 0x32, 0x37, 0x32, 0x65, 0x31, 0x62, 0x65, 0x30, 0x65, 0x38, 0x38, 0x36, 0x64, 0x31, 0x62, 0x33, 0x63, 0x39, 0x35, 0x65, 0x63, 0x61, 0x65, 0x62, 0x34, 0x34, 0x62, 0x62, 0x31, 0x61, 0x36, 0x61, 0x66, 0x65, 0x39, 0x34, 0x36, 0x34, 0x61, 0x38, 0x30, 0x35, 0x63, 0x30, 0x64, 0x63, 0x38, 0x61, 0x63, 0x30, 0x61, 0x35, 0x66, 0x61, 0x31, 0x37, 0x30, 0x66, 0x30, 0x39, 0x64, 0x66, 0x61, 0x32, 0x31, 0x35, 0x34, 0x62, 0x38, 0x30, 0x62, 0x30, 0x37, 0x30, 0x39, 0x33, 0x30, 0x31, 0x36, 0x63, 0x65, 0x34, 0x30, 0x37, 0x38, 0x35, 0x30, 0x39, 0x32, 0x61, 0x33, 0x36, 0x65, 0x65, 0x36, 0x65, 0x65, 0x37, 0x34, 0x38, 0x36, 0x32, 0x63, 0x32, 0x32, 0x37, 0x66, 0x61, 0x66, 0x33, 0x66, 0x38, 0x35, 0x66, 0x30, 0x66, 0x62, 0x63, 0x61, 0x34, 0x63, 0x61, 0x64, 0x37, 0x34, 0x31, 0x34, 0x62, 0x61, 0x30, 0x34, 0x66, 0x30, 0x33, 0x63, 0x31, 0x36, 0x62, 0x36, 0x33, 0x32, 0x35, 0x62, 0x34, 0x38, 0x34, 0x32, 0x65, 0x33, 0x30, 0x38, 0x63, 0x35, 0x62, 0x31, 0x62, 0x31, 0x38, 0x38, 0x35, 0x32, 0x66, 0x65, 0x38, 0x39, 0x36, 0x34, 0x38, 0x30, 0x34, 0x37, 0x35, 0x38, 0x61, 0x39, 0x34, 0x35, 0x64, 0x61, 0x66, 0x37, 0x63, 0x37, 0x65, 0x38, 0x35, 0x34, 0x35, 0x61, 0x65, 0x32, 0x39, 0x63, 0x37, 0x32, 0x64, 0x31, 0x62, 0x36, 0x64, 0x30, 0x31, 0x35, 0x62, 0x38, 0x65, 0x66, 0x33, 0x38, 0x64, 0x39, 0x62, 0x64, 0x38, 0x38, 0x66, 0x61, 0x34, 0x33, 0x37, 0x32, 0x35, 0x65, 0x31, 0x39, 0x66, 0x30, 0x36, 0x39, 0x36, 0x30, 0x65, 0x32, 0x37, 0x61, 0x31, 0x38, 0x35, 0x33, 0x31, 0x61, 0x64, 0x30, 0x32, 0x38, 0x61, 0x36, 0x33, 0x62, 0x38, 0x39, 0x36, 0x65, 0x62, 0x62, 0x64, 0x61, 0x32, 0x30, 0x66, 0x63, 0x39, 0x61, 0x30, 0x36, 0x61, 0x33, 0x61, 0x61, 0x34, 0x33, 0x61, 0x30, 0x61, 0x63, 0x32, 0x62, 0x30, 0x31, 0x38, 0x65, 0x37, 0x33, 0x39, 0x35, 0x65, 0x35, 0x36, 0x30, 0x38, 0x62, 0x38, 0x38, 0x63, 0x66, 0x65, 0x33, 0x35, 0x37, 0x66, 0x63, 0x61, 0x37, 0x34, 0x36, 0x38, 0x33, 0x38, 0x35, 0x31, 0x33, 0x31, 0x32, 0x30, 0x61, 0x64, 0x63, 0x30, 0x33, 0x64, 0x32, 0x36, 0x33, 0x62, 0x64, 0x37, 0x64, 0x63, 0x65, 0x66, 0x39, 0x34, 0x31, 0x62, 0x33, 0x66, 0x64, 0x38, 0x61, 0x61, 0x37, 0x66, 0x37, 0x35, 0x37, 0x61, 0x61, 0x37, 0x39, 0x39, 0x63, 0x35, 0x35, 0x61, 0x64, 0x35, 0x66, 0x64, 0x33, 0x31, 0x63, 0x31, 0x63, 0x33, 0x64, 0x39, 0x37, 0x35, 0x31, 0x36, 0x66, 0x62, 0x65, 0x65, 0x30, 0x64, 0x64, 0x66, 0x39, 0x63, 0x64, 0x30, 0x33, 0x34, 0x35, 0x31, 0x31, 0x36, 0x32, 0x37, 0x34, 0x34, 0x62, 0x64, 0x31, 0x38, 0x62, 0x36, 0x66, 0x31, 0x35, 0x35, 0x63, 0x39, 0x31, 0x32, 0x38, 0x36, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x61, 0x66, 0x39, 0x36, 0x36, 0x30, 0x30, 0x64, 0x30, 0x36, 0x32, 0x30, 0x63, 0x63, 0x64, 0x39, 0x35, 0x31, 0x64, 0x39, 0x65, 0x62, 0x31, 0x30, 0x36, 0x33, 0x32, 0x64, 0x38, 0x32, 0x31, 0x65, 0x61, 0x61, 0x37, 0x32, 0x66, 0x34, 0x39, 0x61, 0x36, 0x38, 0x61, 0x38, 0x37, 0x38, 0x66, 0x33, 0x63, 0x39, 0x34, 0x39, 0x39, 0x37, 0x36, 0x62, 0x30, 0x30, 0x64, 0x65, 0x61, 0x33, 0x65, 0x38, 0x62, 0x32, 0x30, 0x39, 0x31, 0x37, 0x61, 0x36, 0x62, 0x32, 0x65, 0x38, 0x35, 0x36, 0x65, 0x65, 0x65, 0x34, 0x61, 0x65, 0x30, 0x66, 0x30, 0x66, 0x35, 0x37, 0x61, 0x62, 0x33, 0x31, 0x31, 0x32, 0x63, 0x62, 0x35, 0x30, 0x37, 0x36, 0x31, 0x63, 0x31, 0x62, 0x61, 0x37, 0x64, 0x35, 0x36, 0x61, 0x62, 0x33, 0x63, 0x32, 0x64, 0x65, 0x64, 0x66, 0x39, 0x63, 0x39, 0x34, 0x31, 0x39, 0x37, 0x35, 0x61, 0x61, 0x62, 0x37, 0x65, 0x63, 0x61, 0x65, 0x61, 0x64, 0x38, 0x39, 0x64, 0x63, 0x62, 0x64, 0x39, 0x30, 0x37, 0x66, 0x34, 0x31, 0x32, 0x62, 0x35, 0x66, 0x64, 0x62, 0x30, 0x61, 0x37, 0x66, 0x39, 0x61, 0x37, 0x32, 0x39, 0x66, 0x30, 0x65, 0x31, 0x37, 0x35, 0x63, 0x32, 0x39, 0x33, 0x38, 0x34, 0x35, 0x61, 0x31, 0x64, 0x36, 0x33, 0x66, 0x34, 0x30, 0x34, 0x38, 0x34, 0x34, 0x30, 0x66, 0x31, 0x31, 0x33, 0x33, 0x33, 0x36, 0x38, 0x38, 0x35, 0x30, 0x62, 0x61, 0x64, 0x35, 0x65, 0x31, 0x36, 0x30, 0x62, 0x34, 0x61, 0x38, 0x32, 0x37, 0x66, 0x64, 0x61, 0x32, 0x63, 0x32, 0x39, 0x38, 0x66, 0x32, 0x30, 0x34, 0x63, 0x32, 0x37, 0x62, 0x32, 0x39, 0x30, 0x65, 0x32, 0x38, 0x34, 0x61, 0x66, 0x38, 0x38, 0x33, 0x37, 0x63, 0x63, 0x36, 0x36, 0x63, 0x37, 0x39, 0x34, 0x64, 0x62, 0x32, 0x32, 0x31, 0x66, 0x61, 0x39, 0x62, 0x34, 0x65, 0x35, 0x39, 0x61, 0x32, 0x38, 0x63, 0x62, 0x66, 0x39, 0x32, 0x30, 0x32, 0x64, 0x37, 0x30, 0x34, 0x62, 0x63, 0x63, 0x64, 0x62, 0x66, 0x32, 0x32, 0x31, 0x66, 0x34, 0x63, 0x35, 0x66, 0x65, 0x66, 0x65, 0x38, 0x66, 0x30, 0x65, 0x30, 0x63, 0x34, 0x36, 0x32, 0x39, 0x32, 0x36, 0x61, 0x30, 0x34, 0x30, 0x30, 0x37, 0x38, 0x39, 0x34, 0x34, 0x39, 0x65, 0x34, 0x32, 0x35, 0x61, 0x31, 0x66, 0x32, 0x31, 0x64, 0x37, 0x31, 0x38, 0x30, 0x61, 0x34, 0x38, 0x37, 0x63, 0x38, 0x62, 0x30, 0x31, 0x63, 0x38, 0x32, 0x64, 0x64, 0x62, 0x36, 0x36, 0x30, 0x61, 0x34, 0x33, 0x35, 0x39, 0x64, 0x35, 0x64, 0x66, 0x63, 0x39, 0x66, 0x35, 0x33, 0x66, 0x63, 0x64, 0x36, 0x62, 0x65, 0x34, 0x36, 0x32, 0x63, 0x38, 0x62, 0x32, 0x39, 0x38, 0x39, 0x36, 0x38, 0x36, 0x34, 0x33, 0x62, 0x39, 0x34, 0x34, 0x30, 0x37, 0x32, 0x61, 0x38, 0x65, 0x65, 0x32, 0x39, 0x39, 0x66, 0x62, 0x39, 0x65, 0x63, 0x36, 0x66, 0x37, 0x66, 0x64, 0x36, 0x31, 0x35, 0x38, 0x30, 0x36, 0x65, 0x36, 0x65, 0x39, 0x35, 0x30, 0x35, 0x66, 0x30, 0x65, 0x36, 0x66, 0x36, 0x36, 0x65, 0x31, 0x39, 0x65, 0x38, 0x65, 0x30, 0x30, 0x36, 0x34, 0x66, 0x38, 0x33, 0x36, 0x30, 0x39, 0x36, 0x64, 0x38, 0x32, 0x61, 0x61, 0x62, 0x33, 0x62, 0x66, 0x35, 0x37, 0x62, 0x63, 0x61, 0x33, 0x35, 0x35, 0x35, 0x66, 0x30, 0x34, 0x39, 0x30, 0x37, 0x66, 0x63, 0x63, 0x31, 0x64, 0x65, 0x35, 0x39, 0x37, 0x31, 0x35, 0x37, 0x38, 0x32, 0x37, 0x31, 0x31, 0x32, 0x66, 0x61, 0x33, 0x61, 0x65, 0x36, 0x63, 0x63, 0x33, 0x61, 0x30, 0x61, 0x62, 0x31, 0x65, 0x37, 0x64, 0x64, 0x64, 0x38, 0x32, 0x33, 0x35, 0x66, 0x33, 0x38, 0x39, 0x32, 0x34, 0x39, 0x36, 0x61, 0x35, 0x39, 0x36, 0x61, 0x61, 0x31, 0x62, 0x39, 0x38, 0x38, 0x32, 0x36, 0x61, 0x64, 0x39, 0x31, 0x62, 0x33, 0x34, 0x35, 0x34, 0x35, 0x39, 0x64, 0x37, 0x30, 0x66, 0x39, 0x35, 0x39, 0x66, 0x62, 0x61, 0x33, 0x64, 0x65, 0x33, 0x63, 0x65, 0x32, 0x39, 0x61, 0x65, 0x31, 0x38, 0x37, 0x61, 0x37, 0x30, 0x31, 0x36, 0x62, 0x39, 0x32, 0x63, 0x38, 0x66, 0x33, 0x61, 0x36, 0x66, 0x62, 0x65, 0x32, 0x65, 0x36, 0x32, 0x39, 0x35, 0x66, 0x36, 0x33, 0x34, 0x63, 0x39, 0x31, 0x65, 0x62, 0x36, 0x39, 0x61, 0x63, 0x36, 0x38, 0x31, 0x61, 0x32, 0x34, 0x37, 0x32, 0x66, 0x34, 0x34, 0x63, 0x62, 0x33, 0x34, 0x30, 0x64, 0x33, 0x38, 0x63, 0x32, 0x30, 0x31, 0x66, 0x66, 0x30, 0x33, 0x62, 0x39, 0x36, 0x64, 0x33, 0x66, 0x34, 0x33, 0x63, 0x65, 0x30, 0x63, 0x36, 0x31, 0x65, 0x37, 0x35, 0x65, 0x39, 0x35, 0x30, 0x33, 0x32, 0x63, 0x32, 0x63, 0x31, 0x30, 0x39, 0x34, 0x63, 0x31, 0x36, 0x39, 0x66, 0x30, 0x30, 0x65, 0x35, 0x30, 0x63, 0x36, 0x61, 0x36, 0x62, 0x34, 0x32, 0x31, 0x61, 0x35, 0x36, 0x31, 0x32, 0x30, 0x65, 0x36, 0x38, 0x37, 0x33, 0x30, 0x32, 0x62, 0x38, 0x32, 0x38, 0x33, 0x39, 0x36, 0x66, 0x61, 0x66, 0x39, 0x63, 0x63, 0x38, 0x36, 0x38, 0x66, 0x33, 0x30, 0x32, 0x37, 0x65, 0x39, 0x32, 0x66, 0x33, 0x34, 0x34, 0x38, 0x35, 0x37, 0x34, 0x31, 0x38, 0x39, 0x33, 0x34, 0x38, 0x39, 0x30, 0x39, 0x61, 0x36, 0x62, 0x34, 0x61, 0x37, 0x32, 0x33, 0x61, 0x31, 0x30, 0x63, 0x34, 0x39, 0x63, 0x65, 0x36, 0x34, 0x65, 0x63, 0x64, 0x36, 0x36, 0x30, 0x63, 0x62, 0x62, 0x64, 0x62, 0x35, 0x34, 0x64, 0x37, 0x36, 0x61, 0x35, 0x35, 0x35, 0x31, 0x39, 0x63, 0x65, 0x37, 0x36, 0x32, 0x32, 0x34, 0x33, 0x66, 0x36, 0x32, 0x36, 0x64, 0x65, 0x31, 0x64, 0x33, 0x39, 0x30, 0x62, 0x31, 0x38, 0x62, 0x35, 0x61, 0x30, 0x61, 0x65, 0x32, 0x37, 0x32, 0x65, 0x38, 0x36, 0x32, 0x65, 0x62, 0x39, 0x62, 0x65, 0x33, 0x65, 0x31, 0x65, 0x62, 0x31, 0x36, 0x31, 0x66, 0x33, 0x64, 0x38, 0x34, 0x63, 0x36, 0x66, 0x62, 0x30, 0x66, 0x36, 0x34, 0x31, 0x66, 0x39, 0x35, 0x64, 0x31, 0x62, 0x61, 0x38, 0x36, 0x36, 0x38, 0x62, 0x63, 0x37, 0x38, 0x33, 0x39, 0x34, 0x32, 0x36, 0x32, 0x64, 0x30, 0x30, 0x36, 0x62, 0x63, 0x31, 0x62, 0x32, 0x35, 0x37, 0x32, 0x39, 0x31, 0x62, 0x65, 0x30, 0x36, 0x36, 0x39, 0x61, 0x62, 0x61, 0x34, 0x39, 0x37, 0x65, 0x63, 0x65, 0x35, 0x64, 0x61, 0x62, 0x37, 0x34, 0x39, 0x66, 0x36, 0x38, 0x62, 0x36, 0x34, 0x32, 0x63, 0x38, 0x33, 0x64, 0x31, 0x65, 0x64, 0x37, 0x36, 0x35, 0x64, 0x35, 0x65, 0x34, 0x35, 0x33, 0x38, 0x35, 0x66, 0x64, 0x62, 0x38, 0x65, 0x66, 0x66, 0x65, 0x64, 0x38, 0x34, 0x37, 0x35, 0x37, 0x32, 0x35, 0x31, 0x65, 0x65, 0x65, 0x61, 0x35, 0x65, 0x61, 0x63, 0x38, 0x36, 0x34, 0x38, 0x66, 0x64, 0x38, 0x61, 0x39, 0x37, 0x64, 0x32, 0x61, 0x39, 0x64, 0x39, 0x61, 0x36, 0x33, 0x63, 0x36, 0x61, 0x36, 0x62, 0x63, 0x37, 0x30, 0x38, 0x62, 0x36, 0x35, 0x61, 0x33, 0x39, 0x30, 0x64, 0x62, 0x65, 0x62, 0x32, 0x61, 0x33, 0x33, 0x63, 0x63, 0x34, 0x31, 0x37, 0x37, 0x39, 0x66, 0x37, 0x32, 0x31, 0x61, 0x66, 0x32, 0x33, 0x36, 0x33, 0x34, 0x62, 0x39, 0x31, 0x62, 0x38, 0x39, 0x66, 0x61, 0x61, 0x34, 0x39, 0x38, 0x35, 0x33, 0x63, 0x66, 0x33, 0x32, 0x61, 0x31, 0x62, 0x65, 0x62, 0x61, 0x30, 0x30, 0x37, 0x38, 0x38, 0x32, 0x31, 0x33, 0x36, 0x31, 0x63, 0x38, 0x63, 0x32, 0x63, 0x39, 0x63, 0x34, 0x64, 0x33, 0x30, 0x35, 0x63, 0x64, 0x64, 0x62, 0x39, 0x31, 0x61, 0x66, 0x66, 0x36, 0x37, 0x65, 0x38, 0x66, 0x31, 0x32, 0x30, 0x64, 0x34, 0x32, 0x35, 0x38, 0x37, 0x33, 0x33, 0x64, 0x39, 0x35, 0x65, 0x65, 0x66, 0x66, 0x62, 0x37, 0x37, 0x38, 0x32, 0x30, 0x38, 0x65, 0x61, 0x30, 0x38, 0x66, 0x34, 0x63, 0x39, 0x62, 0x30, 0x38, 0x39, 0x33, 0x65, 0x64, 0x31, 0x31, 0x36, 0x36, 0x64, 0x36, 0x61, 0x34, 0x64, 0x61, 0x65, 0x61, 0x35, 0x36, 0x31, 0x61, 0x32, 0x38, 0x34, 0x37, 0x32, 0x31, 0x32, 0x37, 0x36, 0x33, 0x35, 0x61, 0x38, 0x61, 0x66, 0x63, 0x66, 0x32, 0x38, 0x30, 0x33, 0x37, 0x64, 0x63, 0x61, 0x31, 0x36, 0x32, 0x33, 0x35, 0x33, 0x63, 0x34, 0x64, 0x33, 0x32, 0x35, 0x63, 0x32, 0x32, 0x66, 0x34, 0x64, 0x63, 0x63, 0x33, 0x30, 0x62, 0x32, 0x38, 0x61, 0x65, 0x39, 0x30, 0x65, 0x38, 0x34, 0x64, 0x38, 0x38, 0x34, 0x64, 0x31, 0x38, 0x31, 0x37, 0x64, 0x37, 0x32, 0x32, 0x34, 0x63, 0x30, 0x65, 0x65, 0x30, 0x35, 0x62, 0x63, 0x36, 0x33, 0x38, 0x64, 0x35, 0x34, 0x62, 0x30, 0x35, 0x61, 0x33, 0x30, 0x32, 0x34, 0x65, 0x36, 0x32, 0x34, 0x34, 0x61, 0x36, 0x62, 0x35, 0x66, 0x39, 0x34, 0x65, 0x37, 0x37, 0x38, 0x33, 0x66, 0x31, 0x31, 0x30, 0x34, 0x65, 0x33, 0x32, 0x61, 0x38, 0x34, 0x35, 0x61, 0x34, 0x33, 0x64, 0x66, 0x34, 0x66, 0x37, 0x66, 0x33, 0x32, 0x64, 0x32, 0x63, 0x66, 0x61, 0x37, 0x31, 0x36, 0x64, 0x31, 0x63, 0x63, 0x34, 0x62, 0x66, 0x37, 0x32, 0x36, 0x63, 0x64, 0x66, 0x38, 0x30, 0x63, 0x36, 0x65, 0x30, 0x65, 0x31, 0x36, 0x34, 0x64, 0x64, 0x32, 0x64, 0x65, 0x32, 0x30, 0x32, 0x63, 0x62, 0x62, 0x35, 0x32, 0x37, 0x37, 0x36, 0x32, 0x64, 0x36, 0x64, 0x63, 0x66, 0x36, 0x64, 0x32, 0x63, 0x30, 0x66, 0x66, 0x37, 0x32, 0x32, 0x65, 0x62, 0x32, 0x30, 0x31, 0x65, 0x38, 0x33, 0x61, 0x34, 0x39, 0x66, 0x63, 0x36, 0x38, 0x65, 0x32, 0x38, 0x33, 0x62, 0x62, 0x37, 0x36, 0x63, 0x36, 0x64, 0x35, 0x63, 0x34, 0x33, 0x39, 0x30, 0x33, 0x64, 0x31, 0x62, 0x38, 0x61, 0x37, 0x38, 0x66, 0x63, 0x31, 0x37, 0x66, 0x65, 0x36, 0x65, 0x62, 0x37, 0x36, 0x36, 0x31, 0x31, 0x39, 0x65, 0x37, 0x32, 0x32, 0x37, 0x36, 0x32, 0x36, 0x33, 0x36, 0x34, 0x31, 0x30, 0x39, 0x32, 0x38, 0x65, 0x30, 0x37, 0x63, 0x64, 0x65, 0x33, 0x63, 0x36, 0x30, 0x66, 0x31, 0x37, 0x63, 0x36, 0x38, 0x32, 0x39, 0x61, 0x65, 0x34, 0x33, 0x35, 0x31, 0x38, 0x34, 0x65, 0x38, 0x66, 0x33, 0x34, 0x63, 0x38, 0x61, 0x63, 0x34, 0x31, 0x34, 0x31, 0x36, 0x33, 0x66, 0x62, 0x61, 0x30, 0x35, 0x64, 0x63, 0x66, 0x30, 0x62, 0x66, 0x66, 0x61, 0x64, 0x35, 0x36, 0x39, 0x31, 0x35, 0x39, 0x30, 0x31, 0x32, 0x38, 0x66, 0x62, 0x63, 0x63, 0x33, 0x61, 0x30, 0x30, 0x66, 0x37, 0x61, 0x31, 0x38, 0x33, 0x62, 0x35, 0x65, 0x30, 0x33, 0x31, 0x65, 0x30, 0x39, 0x33, 0x62, 0x36, 0x62, 0x33, 0x37, 0x35, 0x37, 0x31, 0x61, 0x31, 0x64, 0x65, 0x63, 0x62, 0x36, 0x38, 0x61, 0x65, 0x33, 0x33, 0x34, 0x63, 0x32, 0x64, 0x36, 0x35, 0x64, 0x61, 0x61, 0x38, 0x35, 0x30, 0x62, 0x61, 0x32, 0x39, 0x36, 0x31, 0x31, 0x30, 0x66, 0x37, 0x66, 0x37, 0x37, 0x34, 0x64, 0x36, 0x32, 0x30, 0x65, 0x62, 0x65, 0x39, 0x32, 0x34, 0x38, 0x65, 0x65, 0x39, 0x30, 0x62, 0x33, 0x62, 0x32, 0x33, 0x33, 0x32, 0x34, 0x35, 0x39, 0x64, 0x63, 0x38, 0x30, 0x62, 0x64, 0x38, 0x66, 0x32, 0x64, 0x63, 0x61, 0x32, 0x38, 0x36, 0x32, 0x62, 0x35, 0x33, 0x34, 0x34, 0x66, 0x64, 0x38, 0x36, 0x33, 0x61, 0x39, 0x33, 0x31, 0x63, 0x30, 0x62, 0x63, 0x38, 0x64, 0x36, 0x64, 0x34, 0x63, 0x32, 0x64, 0x33, 0x32, 0x64, 0x31, 0x39, 0x33, 0x62, 0x39, 0x31, 0x38, 0x63, 0x37, 0x66, 0x32, 0x34, 0x37, 0x62, 0x33, 0x37, 0x36, 0x34, 0x32, 0x63, 0x38, 0x32, 0x30, 0x61, 0x35, 0x30, 0x35, 0x62, 0x62, 0x64, 0x61, 0x65, 0x36, 0x33, 0x66, 0x34, 0x63, 0x64, 0x31, 0x33, 0x31, 0x35, 0x65, 0x36, 0x65, 0x64, 0x64, 0x35, 0x30, 0x37, 0x61, 0x37, 0x34, 0x36, 0x62, 0x39, 0x31, 0x64, 0x31, 0x34, 0x34, 0x33, 0x30, 0x65, 0x34, 0x61, 0x30, 0x61, 0x33, 0x63, 0x31, 0x36, 0x37, 0x61, 0x62, 0x62, 0x37, 0x65, 0x62, 0x64, 0x37, 0x31, 0x66, 0x33, 0x61, 0x30, 0x31, 0x35, 0x36, 0x30, 0x32, 0x62, 0x32, 0x37, 0x63, 0x33, 0x62, 0x65, 0x35, 0x31, 0x65, 0x66, 0x62, 0x38, 0x63, 0x66, 0x39, 0x33, 0x62, 0x65, 0x30, 0x66, 0x38, 0x37, 0x61, 0x38, 0x33, 0x62, 0x65, 0x34, 0x30, 0x65, 0x62, 0x38, 0x36, 0x31, 0x64, 0x35, 0x61, 0x33, 0x37, 0x31, 0x38, 0x35, 0x63, 0x34, 0x35, 0x64, 0x39, 0x37, 0x65, 0x34, 0x61, 0x30, 0x39, 0x64, 0x37, 0x30, 0x33, 0x64, 0x30, 0x32, 0x65, 0x33, 0x30, 0x33, 0x34, 0x31, 0x64, 0x39, 0x37, 0x35, 0x66, 0x31, 0x30, 0x31, 0x33, 0x38, 0x32, 0x65, 0x30, 0x37, 0x32, 0x37, 0x66, 0x39, 0x63, 0x30, 0x65, 0x66, 0x38, 0x37, 0x34, 0x62, 0x34, 0x31, 0x65, 0x32, 0x64, 0x35, 0x38, 0x61, 0x35, 0x32, 0x33, 0x38, 0x61, 0x33, 0x36, 0x62, 0x30, 0x64, 0x33, 0x37, 0x66, 0x36, 0x33, 0x62, 0x66, 0x66, 0x66, 0x36, 0x33, 0x61, 0x62, 0x63, 0x62, 0x66, 0x34, 0x65, 0x63, 0x65, 0x65, 0x38, 0x65, 0x37, 0x66, 0x65, 0x33, 0x30, 0x31, 0x39, 0x65, 0x62, 0x38, 0x34, 0x30, 0x31, 0x63, 0x61, 0x35, 0x63, 0x64, 0x64, 0x66, 0x38, 0x63, 0x38, 0x65, 0x30, 0x39, 0x64, 0x38, 0x39, 0x38, 0x32, 0x30, 0x39, 0x61, 0x33, 0x39, 0x64, 0x38, 0x65, 0x36, 0x31, 0x61, 0x33, 0x30, 0x39, 0x39, 0x33, 0x39, 0x36, 0x33, 0x30, 0x31, 0x36, 0x39, 0x62, 0x33, 0x32, 0x64, 0x63, 0x31, 0x34, 0x65, 0x34, 0x61, 0x36, 0x66, 0x36, 0x61, 0x35, 0x65, 0x32, 0x30, 0x64, 0x63, 0x37, 0x32, 0x62, 0x63, 0x65, 0x37, 0x31, 0x62, 0x62, 0x62, 0x30, 0x61, 0x39, 0x62, 0x35, 0x32, 0x30, 0x31, 0x30, 0x36, 0x66, 0x38, 0x38, 0x61, 0x64, 0x35, 0x38, 0x36, 0x33, 0x39, 0x39, 0x66, 0x33, 0x39, 0x34, 0x30, 0x30, 0x65, 0x65, 0x36, 0x65, 0x36, 0x30, 0x38, 0x64, 0x32, 0x31, 0x35, 0x35, 0x36, 0x32, 0x63, 0x34, 0x38, 0x37, 0x65, 0x37, 0x30, 0x38, 0x61, 0x31, 0x62, 0x30, 0x61, 0x34, 0x31, 0x64, 0x61, 0x39, 0x33, 0x33, 0x39, 0x34, 0x31, 0x64, 0x33, 0x31, 0x64, 0x62, 0x65, 0x37, 0x30, 0x64, 0x36, 0x33, 0x39, 0x33, 0x65, 0x64, 0x39, 0x30, 0x34, 0x30, 0x39, 0x36, 0x34, 0x66, 0x66, 0x38, 0x64, 0x39, 0x34, 0x33, 0x65, 0x63, 0x30, 0x64, 0x66, 0x36, 0x61, 0x35, 0x32, 0x34, 0x64, 0x37, 0x37, 0x31, 0x66, 0x37, 0x63, 0x38, 0x64, 0x34, 0x37, 0x31, 0x61, 0x36, 0x61, 0x37, 0x32, 0x64, 0x34, 0x62, 0x32, 0x39, 0x66, 0x63, 0x62, 0x65, 0x31, 0x66, 0x66, 0x31, 0x30, 0x37, 0x30, 0x62, 0x32, 0x38, 0x35, 0x66, 0x32, 0x31, 0x34, 0x65, 0x34, 0x37, 0x37, 0x66, 0x32, 0x63, 0x35, 0x38, 0x30, 0x37, 0x32, 0x35, 0x31, 0x36, 0x61, 0x33, 0x61, 0x30, 0x62, 0x66, 0x36, 0x30, 0x61, 0x32, 0x66, 0x62, 0x34, 0x65, 0x61, 0x66, 0x37, 0x39, 0x65, 0x62, 0x30, 0x36, 0x65, 0x37, 0x32, 0x32, 0x64, 0x63, 0x31, 0x64, 0x34, 0x33, 0x65, 0x63, 0x62, 0x38, 0x32, 0x37, 0x31, 0x65, 0x39, 0x31, 0x64, 0x37, 0x36, 0x66, 0x66, 0x66, 0x37, 0x34, 0x35, 0x62, 0x39, 0x36, 0x34, 0x30, 0x34, 0x63, 0x33, 0x62, 0x65, 0x61, 0x31, 0x37, 0x36, 0x64, 0x30, 0x62, 0x34, 0x33, 0x38, 0x37, 0x30, 0x66, 0x65, 0x33, 0x35, 0x30, 0x62, 0x32, 0x32, 0x65, 0x32, 0x62, 0x31, 0x37, 0x39, 0x37, 0x32, 0x66, 0x38, 0x64, 0x63, 0x35, 0x61, 0x37, 0x36, 0x33, 0x30, 0x35, 0x64, 0x36, 0x36, 0x35, 0x30, 0x38, 0x38, 0x30, 0x39, 0x33, 0x33, 0x36, 0x64, 0x34, 0x31, 0x35, 0x33, 0x31, 0x32, 0x64, 0x65, 0x61, 0x35, 0x30, 0x32, 0x37, 0x39, 0x31, 0x66, 0x33, 0x36, 0x37, 0x62, 0x64, 0x37, 0x64, 0x64, 0x63, 0x64, 0x30, 0x65, 0x61, 0x38, 0x39, 0x31, 0x30, 0x64, 0x33, 0x63, 0x37, 0x66, 0x36, 0x63, 0x66, 0x32, 0x62, 0x34, 0x63, 0x35, 0x33, 0x61, 0x38, 0x35, 0x30, 0x61, 0x61, 0x31, 0x34, 0x32, 0x66, 0x39, 0x66, 0x62, 0x66, 0x32, 0x32, 0x61, 0x37, 0x39, 0x62, 0x65, 0x34, 0x33, 0x66, 0x62, 0x30, 0x61, 0x62, 0x30, 0x31, 0x34, 0x61, 0x38, 0x64, 0x36, 0x62, 0x61, 0x37, 0x30, 0x30, 0x35, 0x65, 0x39, 0x35, 0x39, 0x61, 0x38, 0x31, 0x65, 0x31, 0x66, 0x30, 0x32, 0x62, 0x66, 0x37, 0x32, 0x36, 0x64, 0x66, 0x63, 0x37, 0x66, 0x62, 0x38, 0x35, 0x64, 0x34, 0x33, 0x34, 0x34, 0x38, 0x34, 0x30, 0x35, 0x61, 0x32, 0x34, 0x33, 0x32, 0x61, 0x63, 0x64, 0x63, 0x34, 0x32, 0x65, 0x34, 0x31, 0x36, 0x61, 0x36, 0x35, 0x61, 0x33, 0x35, 0x63, 0x38, 0x61, 0x31, 0x36, 0x63, 0x35, 0x36, 0x66, 0x62, 0x31, 0x30, 0x37, 0x65, 0x63, 0x32, 0x36, 0x30, 0x34, 0x38, 0x37, 0x33, 0x61, 0x33, 0x66, 0x33, 0x61, 0x32, 0x38, 0x32, 0x39, 0x35, 0x61, 0x65, 0x66, 0x38, 0x37, 0x33, 0x66, 0x62, 0x65, 0x32, 0x34, 0x63, 0x38, 0x30, 0x65, 0x37, 0x39, 0x63, 0x33, 0x38, 0x32, 0x31, 0x31, 0x38, 0x31, 0x34, 0x32, 0x34, 0x35, 0x66, 0x32, 0x35, 0x62, 0x30, 0x61, 0x34, 0x62, 0x34, 0x37, 0x66, 0x39, 0x31, 0x62, 0x33, 0x35, 0x63, 0x35, 0x64, 0x63, 0x34, 0x30, 0x61, 0x61, 0x65, 0x61, 0x37, 0x32, 0x38, 0x39, 0x61, 0x35, 0x33, 0x61, 0x62, 0x33, 0x64, 0x33, 0x35, 0x66, 0x66, 0x61, 0x33, 0x66, 0x35, 0x35, 0x64, 0x66, 0x64, 0x37, 0x30, 0x61, 0x38, 0x32, 0x30, 0x33, 0x61, 0x31, 0x31, 0x38, 0x35, 0x37, 0x62, 0x65, 0x66, 0x34, 0x32, 0x34, 0x30, 0x39, 0x34, 0x39, 0x35, 0x32, 0x64, 0x32, 0x36, 0x66, 0x64, 0x33, 0x36, 0x34, 0x33, 0x34, 0x36, 0x33, 0x38, 0x38, 0x64, 0x61, 0x33, 0x30, 0x37, 0x31, 0x34, 0x35, 0x37, 0x65, 0x61, 0x65, 0x30, 0x63, 0x64, 0x66, 0x39, 0x37, 0x37, 0x66, 0x37, 0x39, 0x62, 0x35, 0x62, 0x62, 0x66, 0x39, 0x63, 0x63, 0x33, 0x64, 0x30, 0x64, 0x62, 0x36, 0x33, 0x66, 0x36, 0x63, 0x35, 0x30, 0x39, 0x64, 0x39, 0x30, 0x61, 0x38, 0x31, 0x62, 0x39, 0x34, 0x66, 0x31, 0x61, 0x36, 0x37, 0x66, 0x66, 0x31, 0x64, 0x39, 0x64, 0x39, 0x38, 0x35, 0x37, 0x32, 0x32, 0x37, 0x39, 0x32, 0x35, 0x32, 0x62, 0x38, 0x30, 0x31, 0x62, 0x61, 0x39, 0x38, 0x32, 0x39, 0x65, 0x38, 0x30, 0x65, 0x33, 0x61, 0x61, 0x38, 0x65, 0x64, 0x32, 0x62, 0x62, 0x64, 0x62, 0x33, 0x61, 0x39, 0x66, 0x32, 0x39, 0x35, 0x64, 0x64, 0x39, 0x37, 0x39, 0x39, 0x38, 0x63, 0x34, 0x63, 0x33, 0x64, 0x61, 0x39, 0x36, 0x62, 0x39, 0x61, 0x35, 0x33, 0x37, 0x63, 0x37, 0x31, 0x37, 0x32, 0x66, 0x38, 0x34, 0x61, 0x31, 0x64, 0x31, 0x38, 0x35, 0x32, 0x61, 0x32, 0x30, 0x35, 0x38, 0x62, 0x38, 0x66, 0x30, 0x31, 0x62, 0x64, 0x35, 0x61, 0x31, 0x35, 0x66, 0x63, 0x36, 0x64, 0x33, 0x33, 0x62, 0x38, 0x63, 0x36, 0x65, 0x64, 0x65, 0x30, 0x65, 0x33, 0x33, 0x31, 0x38, 0x30, 0x63, 0x64, 0x31, 0x36, 0x64, 0x64, 0x31, 0x37, 0x31, 0x31, 0x30, 0x31, 0x31, 0x64, 0x38, 0x66, 0x34, 0x64, 0x31, 0x34, 0x31, 0x62, 0x36, 0x35, 0x36, 0x64, 0x63, 0x32, 0x37, 0x39, 0x64, 0x63, 0x39, 0x64, 0x63, 0x38, 0x38, 0x61, 0x39, 0x39, 0x31, 0x62, 0x64, 0x33, 0x30, 0x37, 0x38, 0x39, 0x35, 0x64, 0x63, 0x38, 0x35, 0x36, 0x33, 0x32, 0x38, 0x39, 0x35, 0x33, 0x38, 0x32, 0x30, 0x63, 0x34, 0x64, 0x36, 0x33, 0x61, 0x30, 0x63, 0x39, 0x33, 0x63, 0x61, 0x38, 0x65, 0x62, 0x65, 0x31, 0x37, 0x32, 0x33, 0x65, 0x66, 0x37, 0x32, 0x33, 0x34, 0x35, 0x36, 0x31, 0x37, 0x32, 0x63, 0x61, 0x63, 0x35, 0x35, 0x65, 0x31, 0x34, 0x37, 0x33, 0x39, 0x31, 0x61, 0x66, 0x31, 0x39, 0x62, 0x32, 0x61, 0x36, 0x30, 0x31, 0x61, 0x61, 0x64, 0x38, 0x36, 0x64, 0x62, 0x33, 0x34, 0x37, 0x38, 0x32, 0x64, 0x34, 0x36, 0x30, 0x35, 0x34, 0x62, 0x61, 0x63, 0x35, 0x39, 0x31, 0x61, 0x64, 0x39, 0x37, 0x36, 0x32, 0x31, 0x65, 0x38, 0x33, 0x62, 0x38, 0x34, 0x37, 0x32, 0x64, 0x64, 0x39, 0x37, 0x35, 0x65, 0x34, 0x30, 0x30, 0x38, 0x31, 0x30, 0x32, 0x37, 0x65, 0x37, 0x66, 0x38, 0x33, 0x62, 0x64, 0x39, 0x38, 0x65, 0x38, 0x64, 0x30, 0x63, 0x30, 0x31, 0x37, 0x65, 0x30, 0x33, 0x61, 0x33, 0x62, 0x39, 0x66, 0x38, 0x31, 0x38, 0x65, 0x37, 0x34, 0x33, 0x34, 0x65, 0x66, 0x35, 0x35, 0x31, 0x33, 0x35, 0x61, 0x65, 0x37, 0x31, 0x34, 0x37, 0x37, 0x61, 0x31, 0x61, 0x63, 0x37, 0x38, 0x61, 0x39, 0x31, 0x66, 0x38, 0x35, 0x31, 0x30, 0x37, 0x31, 0x62, 0x61, 0x61, 0x63, 0x62, 0x31, 0x37, 0x35, 0x62, 0x38, 0x32, 0x65, 0x32, 0x32, 0x33, 0x39, 0x63, 0x32, 0x35, 0x61, 0x37, 0x39, 0x64, 0x61, 0x36, 0x32, 0x35, 0x65, 0x34, 0x61, 0x37, 0x36, 0x66, 0x30, 0x34, 0x32, 0x32, 0x35, 0x61, 0x65, 0x37, 0x32, 0x33, 0x39, 0x39, 0x31, 0x66, 0x37, 0x38, 0x64, 0x36, 0x37, 0x39, 0x66, 0x65, 0x34, 0x35, 0x33, 0x31, 0x38, 0x64, 0x65, 0x38, 0x64, 0x33, 0x32, 0x32, 0x37, 0x66, 0x33, 0x36, 0x65, 0x35, 0x35, 0x33, 0x65, 0x39, 0x32, 0x38, 0x66, 0x61, 0x36, 0x61, 0x65, 0x36, 0x61, 0x38, 0x39, 0x37, 0x64, 0x66, 0x38, 0x34, 0x65, 0x33, 0x31, 0x30, 0x62, 0x36, 0x39, 0x33, 0x66, 0x62, 0x63, 0x30, 0x30, 0x33, 0x39, 0x36, 0x38, 0x37, 0x61, 0x62, 0x63, 0x38, 0x65, 0x31, 0x66, 0x34, 0x36, 0x64, 0x33, 0x35, 0x64, 0x64, 0x35, 0x39, 0x33, 0x37, 0x61, 0x33, 0x31, 0x37, 0x63, 0x34, 0x33, 0x34, 0x61, 0x62, 0x65, 0x63, 0x31, 0x32, 0x36, 0x33, 0x35, 0x32, 0x30, 0x38, 0x39, 0x62, 0x39, 0x31, 0x36, 0x63, 0x64, 0x36, 0x34, 0x65, 0x64, 0x38, 0x64, 0x39, 0x39, 0x37, 0x32, 0x38, 0x63, 0x37, 0x32, 0x35, 0x32, 0x66, 0x34, 0x34, 0x63, 0x38, 0x62, 0x62, 0x30, 0x36, 0x32, 0x65, 0x34, 0x32, 0x32, 0x63, 0x38, 0x62, 0x30, 0x30, 0x64, 0x31, 0x35, 0x63, 0x31, 0x30, 0x32, 0x33, 0x30, 0x37, 0x39, 0x65, 0x30, 0x62, 0x62, 0x62, 0x36, 0x65, 0x38, 0x37, 0x35, 0x36, 0x31, 0x65, 0x30, 0x66, 0x34, 0x61, 0x66, 0x38, 0x33, 0x62, 0x66, 0x62, 0x66, 0x36, 0x30, 0x31, 0x33, 0x33, 0x38, 0x33, 0x30, 0x31, 0x34, 0x62, 0x66, 0x36, 0x30, 0x38, 0x62, 0x62, 0x66, 0x65, 0x33, 0x66, 0x37, 0x34, 0x30, 0x62, 0x38, 0x33, 0x39, 0x30, 0x64, 0x63, 0x62, 0x36, 0x32, 0x64, 0x65, 0x62, 0x61, 0x31, 0x33, 0x34, 0x64, 0x37, 0x33, 0x31, 0x37, 0x33, 0x65, 0x33, 0x35, 0x37, 0x38, 0x38, 0x34, 0x38, 0x64, 0x61, 0x62, 0x63, 0x35, 0x66, 0x66, 0x63, 0x64, 0x63, 0x36, 0x30, 0x30, 0x32, 0x31, 0x37, 0x32, 0x64, 0x39, 0x35, 0x64, 0x33, 0x65, 0x65, 0x34, 0x35, 0x32, 0x62, 0x31, 0x31, 0x61, 0x66, 0x33, 0x66, 0x65, 0x30, 0x65, 0x37, 0x38, 0x62, 0x35, 0x32, 0x64, 0x38, 0x32, 0x31, 0x35, 0x30, 0x65, 0x38, 0x34, 0x30, 0x34, 0x33, 0x37, 0x36, 0x34, 0x35, 0x32, 0x39, 0x62, 0x61, 0x32, 0x66, 0x61, 0x30, 0x33, 0x61, 0x30, 0x65, 0x39, 0x33, 0x64, 0x30, 0x38, 0x32, 0x33, 0x35, 0x62, 0x37, 0x32, 0x66, 0x30, 0x33, 0x38, 0x35, 0x37, 0x63, 0x33, 0x61, 0x39, 0x65, 0x62, 0x32, 0x32, 0x32, 0x36, 0x37, 0x66, 0x66, 0x63, 0x63, 0x36, 0x63, 0x63, 0x61, 0x34, 0x39, 0x66, 0x34, 0x39, 0x64, 0x34, 0x36, 0x32, 0x34, 0x33, 0x65, 0x36, 0x61, 0x31, 0x35, 0x35, 0x35, 0x36, 0x31, 0x66, 0x34, 0x30, 0x38, 0x62, 0x61, 0x36, 0x66, 0x32, 0x31, 0x34, 0x62, 0x65, 0x32, 0x66, 0x35, 0x35, 0x37, 0x32, 0x62, 0x65, 0x62, 0x31, 0x37, 0x64, 0x36, 0x38, 0x62, 0x32, 0x30, 0x65, 0x30, 0x66, 0x38, 0x64, 0x63, 0x32, 0x64, 0x61, 0x31, 0x39, 0x61, 0x35, 0x61, 0x38, 0x35, 0x32, 0x36, 0x30, 0x38, 0x37, 0x39, 0x37, 0x30, 0x61, 0x31, 0x34, 0x37, 0x39, 0x39, 0x39, 0x65, 0x39, 0x39, 0x64, 0x62, 0x63, 0x33, 0x34, 0x36, 0x38, 0x31, 0x66, 0x30, 0x61, 0x64, 0x61, 0x38, 0x63, 0x64, 0x34, 0x37, 0x32, 0x38, 0x65, 0x32, 0x36, 0x39, 0x39, 0x65, 0x39, 0x36, 0x34, 0x30, 0x38, 0x38, 0x62, 0x31, 0x36, 0x62, 0x38, 0x33, 0x37, 0x61, 0x37, 0x38, 0x62, 0x32, 0x39, 0x31, 0x33, 0x31, 0x64, 0x64, 0x66, 0x39, 0x30, 0x31, 0x37, 0x61, 0x34, 0x32, 0x62, 0x63, 0x32, 0x34, 0x30, 0x37, 0x37, 0x62, 0x61, 0x62, 0x66, 0x39, 0x39, 0x38, 0x34, 0x63, 0x30, 0x33, 0x61, 0x66, 0x30, 0x36, 0x32, 0x37, 0x32, 0x31, 0x39, 0x38, 0x38, 0x31, 0x32, 0x62, 0x32, 0x62, 0x61, 0x36, 0x65, 0x34, 0x65, 0x66, 0x63, 0x64, 0x61, 0x61, 0x35, 0x35, 0x37, 0x63, 0x33, 0x30, 0x35, 0x38, 0x65, 0x64, 0x64, 0x33, 0x65, 0x65, 0x30, 0x34, 0x31, 0x62, 0x62, 0x62, 0x37, 0x66, 0x32, 0x31, 0x34, 0x31, 0x61, 0x65, 0x30, 0x35, 0x66, 0x37, 0x33, 0x31, 0x30, 0x35, 0x62, 0x30, 0x35, 0x34, 0x36, 0x62, 0x33, 0x37, 0x32, 0x63, 0x36, 0x32, 0x31, 0x33, 0x61, 0x39, 0x66, 0x61, 0x35, 0x39, 0x33, 0x63, 0x66, 0x39, 0x62, 0x65, 0x61, 0x32, 0x37, 0x30, 0x36, 0x64, 0x30, 0x39, 0x32, 0x38, 0x32, 0x34, 0x64, 0x63, 0x64, 0x65, 0x61, 0x63, 0x31, 0x31, 0x66, 0x39, 0x64, 0x32, 0x33, 0x63, 0x33, 0x62, 0x34, 0x65, 0x35, 0x34, 0x32, 0x32, 0x65, 0x35, 0x36, 0x37, 0x39, 0x66, 0x66, 0x35, 0x63, 0x32, 0x30, 0x37, 0x32, 0x66, 0x66, 0x63, 0x37, 0x66, 0x64, 0x64, 0x63, 0x66, 0x32, 0x66, 0x63, 0x61, 0x65, 0x65, 0x66, 0x64, 0x32, 0x66, 0x30, 0x37, 0x33, 0x38, 0x30, 0x32, 0x39, 0x30, 0x34, 0x33, 0x37, 0x31, 0x38, 0x63, 0x30, 0x39, 0x38, 0x65, 0x62, 0x64, 0x31, 0x61, 0x61, 0x66, 0x39, 0x37, 0x32, 0x37, 0x62, 0x32, 0x31, 0x63, 0x35, 0x65, 0x33, 0x38, 0x37, 0x38, 0x34, 0x66, 0x37, 0x64, 0x32, 0x35, 0x63, 0x36, 0x64, 0x33, 0x33, 0x66, 0x64, 0x37, 0x64, 0x39, 0x36, 0x36, 0x63, 0x36, 0x39, 0x30, 0x36, 0x32, 0x30, 0x63, 0x66, 0x36, 0x37, 0x36, 0x65, 0x35, 0x37, 0x62, 0x64, 0x32, 0x65, 0x65, 0x33, 0x37, 0x66, 0x66, 0x64, 0x66, 0x62, 0x39, 0x62, 0x66, 0x33, 0x39, 0x31, 0x61, 0x36, 0x31, 0x36, 0x64, 0x37, 0x35, 0x35, 0x61, 0x36, 0x62, 0x64, 0x65, 0x61, 0x39, 0x32, 0x30, 0x37, 0x37, 0x32, 0x39, 0x39, 0x37, 0x64, 0x31, 0x63, 0x38, 0x37, 0x39, 0x62, 0x63, 0x36, 0x31, 0x31, 0x38, 0x39, 0x38, 0x65, 0x35, 0x32, 0x30, 0x37, 0x62, 0x37, 0x30, 0x65, 0x66, 0x37, 0x64, 0x32, 0x32, 0x62, 0x31, 0x35, 0x31, 0x63, 0x65, 0x35, 0x61, 0x33, 0x37, 0x39, 0x66, 0x31, 0x33, 0x66, 0x65, 0x34, 0x39, 0x37, 0x38, 0x38, 0x65, 0x35, 0x34, 0x38, 0x30, 0x33, 0x36, 0x37, 0x66, 0x61, 0x33, 0x61, 0x66, 0x35, 0x64, 0x64, 0x33, 0x39, 0x31, 0x65, 0x35, 0x30, 0x63, 0x63, 0x36, 0x39, 0x38, 0x33, 0x65, 0x63, 0x61, 0x34, 0x35, 0x63, 0x31, 0x31, 0x62, 0x30, 0x33, 0x30, 0x61, 0x36, 0x65, 0x34, 0x66, 0x30, 0x33, 0x64, 0x31, 0x34, 0x31, 0x37, 0x66, 0x30, 0x64, 0x35, 0x35, 0x31, 0x61, 0x64, 0x64, 0x64, 0x65, 0x61, 0x36, 0x33, 0x64, 0x36, 0x31, 0x62, 0x66, 0x39, 0x31, 0x32, 0x37, 0x32, 0x35, 0x61, 0x37, 0x64, 0x33, 0x35, 0x37, 0x31, 0x39, 0x62, 0x66, 0x37, 0x62, 0x30, 0x65, 0x64, 0x61, 0x61, 0x66, 0x39, 0x32, 0x65, 0x38, 0x30, 0x65, 0x36, 0x35, 0x65, 0x30, 0x33, 0x35, 0x61, 0x65, 0x35, 0x30, 0x66, 0x31, 0x64, 0x37, 0x61, 0x37, 0x63, 0x32, 0x38, 0x35, 0x34, 0x31, 0x61, 0x64, 0x30, 0x61, 0x31, 0x62, 0x37, 0x66, 0x34, 0x61, 0x39, 0x62, 0x36, 0x34, 0x62, 0x37, 0x32, 0x34, 0x63, 0x61, 0x33, 0x32, 0x33, 0x65, 0x39, 0x31, 0x64, 0x34, 0x65, 0x62, 0x36, 0x37, 0x33, 0x63, 0x36, 0x31, 0x37, 0x63, 0x33, 0x33, 0x39, 0x31, 0x38, 0x36, 0x31, 0x61, 0x65, 0x62, 0x35, 0x66, 0x36, 0x33, 0x30, 0x33, 0x65, 0x65, 0x38, 0x36, 0x62, 0x64, 0x32, 0x62, 0x34, 0x32, 0x34, 0x37, 0x39, 0x64, 0x64, 0x65, 0x31, 0x36, 0x61, 0x31, 0x63, 0x34, 0x37, 0x64, 0x66, 0x37, 0x32, 0x39, 0x65, 0x62, 0x34, 0x62, 0x32, 0x32, 0x62, 0x30, 0x38, 0x37, 0x63, 0x66, 0x61, 0x61, 0x31, 0x62, 0x62, 0x33, 0x31, 0x30, 0x62, 0x38, 0x63, 0x36, 0x38, 0x31, 0x64, 0x36, 0x39, 0x38, 0x34, 0x35, 0x65, 0x66, 0x63, 0x35, 0x30, 0x65, 0x30, 0x36, 0x36, 0x65, 0x35, 0x65, 0x39, 0x38, 0x65, 0x65, 0x32, 0x36, 0x34, 0x35, 0x64, 0x32, 0x36, 0x64, 0x37, 0x32, 0x62, 0x32, 0x39, 0x37, 0x32, 0x64, 0x62, 0x31, 0x39, 0x38, 0x31, 0x64, 0x31, 0x37, 0x62, 0x36, 0x65, 0x38, 0x66, 0x65, 0x62, 0x66, 0x35, 0x38, 0x66, 0x63, 0x34, 0x37, 0x31, 0x64, 0x34, 0x36, 0x34, 0x36, 0x32, 0x30, 0x36, 0x33, 0x38, 0x36, 0x34, 0x65, 0x63, 0x61, 0x39, 0x36, 0x36, 0x36, 0x63, 0x66, 0x31, 0x32, 0x36, 0x63, 0x66, 0x61, 0x33, 0x61, 0x63, 0x33, 0x63, 0x30, 0x39, 0x31, 0x63, 0x33, 0x65, 0x35, 0x65, 0x65, 0x62, 0x38, 0x31, 0x39, 0x39, 0x34, 0x35, 0x38, 0x66, 0x33, 0x30, 0x33, 0x38, 0x35, 0x32, 0x61, 0x61, 0x66, 0x66, 0x66, 0x65, 0x63, 0x39, 0x35, 0x62, 0x31, 0x66, 0x62, 0x64, 0x33, 0x64, 0x35, 0x62, 0x63, 0x63, 0x31, 0x62, 0x33, 0x36, 0x33, 0x32, 0x66, 0x64, 0x30, 0x35, 0x66, 0x33, 0x66, 0x64, 0x38, 0x64, 0x62, 0x63, 0x63, 0x34, 0x34, 0x61, 0x35, 0x36, 0x36, 0x63, 0x31, 0x34, 0x32, 0x38, 0x35, 0x61, 0x66, 0x33, 0x64, 0x66, 0x64, 0x65, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x34, 0x64, 0x34, 0x31, 0x37, 0x38, 0x64, 0x30, 0x61, 0x64, 0x63, 0x35, 0x64, 0x63, 0x31, 0x35, 0x37, 0x36, 0x63, 0x36, 0x34, 0x31, 0x31, 0x61, 0x32, 0x33, 0x66, 0x35, 0x38, 0x35, 0x65, 0x33, 0x63, 0x33, 0x39, 0x66, 0x35, 0x36, 0x33, 0x61, 0x37, 0x36, 0x33, 0x36, 0x30, 0x30, 0x30, 0x66, 0x63, 0x34, 0x30, 0x35, 0x32, 0x38, 0x37, 0x38, 0x64, 0x62, 0x35, 0x36, 0x32, 0x64, 0x66, 0x31, 0x34, 0x35, 0x63, 0x39, 0x64, 0x32, 0x66, 0x34, 0x31, 0x31, 0x36, 0x38, 0x65, 0x32, 0x31, 0x65, 0x64, 0x35, 0x35, 0x39, 0x31, 0x66, 0x62, 0x64, 0x32, 0x64, 0x64, 0x61, 0x64, 0x64, 0x34, 0x33, 0x33, 0x37, 0x33, 0x37, 0x36, 0x66, 0x63, 0x34, 0x36, 0x64, 0x66, 0x64, 0x38, 0x33, 0x32, 0x37, 0x61, 0x37, 0x62, 0x36, 0x34, 0x63, 0x30, 0x63, 0x64, 0x30, 0x37, 0x39, 0x35, 0x38, 0x38, 0x33, 0x62, 0x62, 0x37, 0x33, 0x39, 0x61, 0x35, 0x39, 0x64, 0x32, 0x61, 0x66, 0x65, 0x61, 0x34, 0x66, 0x66, 0x31, 0x64, 0x31, 0x38, 0x39, 0x32, 0x34, 0x32, 0x31, 0x36, 0x34, 0x64, 0x32, 0x35, 0x63, 0x66, 0x62, 0x64, 0x61, 0x63, 0x61, 0x38, 0x37, 0x38, 0x61, 0x36, 0x37, 0x62, 0x35, 0x37, 0x32, 0x30, 0x39, 0x30, 0x61, 0x37, 0x36, 0x30, 0x61, 0x62, 0x30, 0x63, 0x66, 0x66, 0x37, 0x61, 0x64, 0x66, 0x62, 0x31, 0x64, 0x32, 0x39, 0x33, 0x30, 0x32, 0x37, 0x62, 0x31, 0x35, 0x33, 0x39, 0x64, 0x38, 0x39, 0x31, 0x36, 0x38, 0x31, 0x36, 0x32, 0x34, 0x62, 0x38, 0x62, 0x32, 0x64, 0x38, 0x65, 0x62, 0x36, 0x61, 0x30, 0x30, 0x33, 0x64, 0x38, 0x64, 0x62, 0x61, 0x36, 0x62, 0x64, 0x32, 0x35, 0x62, 0x34, 0x38, 0x63, 0x65, 0x35, 0x33, 0x66, 0x31, 0x31, 0x34, 0x36, 0x30, 0x32, 0x33, 0x35, 0x37, 0x61, 0x33, 0x36, 0x36, 0x66, 0x65, 0x31, 0x39, 0x31, 0x30, 0x32, 0x62, 0x62, 0x63, 0x62, 0x32, 0x38, 0x66, 0x66, 0x62, 0x61, 0x37, 0x61, 0x38, 0x35, 0x64, 0x65, 0x36, 0x30, 0x38, 0x37, 0x38, 0x30, 0x38, 0x37, 0x30, 0x31, 0x62, 0x66, 0x32, 0x61, 0x33, 0x31, 0x30, 0x65, 0x32, 0x65, 0x32, 0x61, 0x34, 0x36, 0x30, 0x64, 0x36, 0x31, 0x38, 0x38, 0x39, 0x36, 0x63, 0x64, 0x61, 0x37, 0x37, 0x37, 0x66, 0x62, 0x30, 0x36, 0x37, 0x65, 0x38, 0x63, 0x37, 0x33, 0x33, 0x65, 0x38, 0x64, 0x39, 0x66, 0x66, 0x31, 0x66, 0x38, 0x38, 0x38, 0x61, 0x30, 0x35, 0x33, 0x34, 0x64, 0x66, 0x33, 0x63, 0x62, 0x31, 0x36, 0x31, 0x34, 0x37, 0x35, 0x31, 0x38, 0x38, 0x30, 0x36, 0x32, 0x37, 0x32, 0x32, 0x66, 0x63, 0x62, 0x37, 0x65, 0x31, 0x66, 0x64, 0x32, 0x37, 0x66, 0x30, 0x34, 0x31, 0x65, 0x65, 0x61, 0x64, 0x33, 0x32, 0x39, 0x39, 0x65, 0x38, 0x62, 0x30, 0x62, 0x30, 0x66, 0x64, 0x62, 0x33, 0x66, 0x63, 0x65, 0x61, 0x63, 0x65, 0x33, 0x38, 0x31, 0x31, 0x66, 0x32, 0x34, 0x63, 0x39, 0x61, 0x62, 0x36, 0x61, 0x37, 0x66, 0x33, 0x63, 0x39, 0x64, 0x38, 0x39, 0x64, 0x39, 0x30, 0x64, 0x61, 0x65, 0x63, 0x36, 0x39, 0x34, 0x34, 0x39, 0x32, 0x63, 0x62, 0x33, 0x66, 0x35, 0x61, 0x61, 0x66, 0x62, 0x64, 0x37, 0x30, 0x61, 0x35, 0x62, 0x64, 0x38, 0x64, 0x31, 0x36, 0x32, 0x32, 0x62, 0x33, 0x33, 0x38, 0x66, 0x32, 0x30, 0x33, 0x34, 0x39, 0x66, 0x63, 0x62, 0x62, 0x37, 0x61, 0x34, 0x30, 0x63, 0x32, 0x38, 0x34, 0x66, 0x65, 0x65, 0x65, 0x34, 0x66, 0x65, 0x62, 0x32, 0x37, 0x32, 0x63, 0x62, 0x61, 0x61, 0x66, 0x64, 0x37, 0x63, 0x32, 0x65, 0x38, 0x63, 0x63, 0x61, 0x65, 0x65, 0x30, 0x65, 0x35, 0x65, 0x36, 0x64, 0x65, 0x63, 0x31, 0x63, 0x32, 0x62, 0x35, 0x35, 0x63, 0x30, 0x66, 0x34, 0x39, 0x63, 0x37, 0x32, 0x64, 0x62, 0x33, 0x37, 0x30, 0x65, 0x37, 0x61, 0x61, 0x32, 0x38, 0x39, 0x61, 0x30, 0x31, 0x38, 0x34, 0x34, 0x33, 0x35, 0x34, 0x35, 0x38, 0x61, 0x37, 0x32, 0x65, 0x34, 0x66, 0x31, 0x30, 0x33, 0x32, 0x65, 0x30, 0x66, 0x38, 0x61, 0x63, 0x32, 0x34, 0x37, 0x30, 0x37, 0x35, 0x63, 0x62, 0x34, 0x34, 0x65, 0x30, 0x63, 0x31, 0x37, 0x64, 0x36, 0x34, 0x30, 0x65, 0x64, 0x32, 0x62, 0x36, 0x61, 0x36, 0x31, 0x32, 0x63, 0x31, 0x36, 0x63, 0x33, 0x39, 0x65, 0x65, 0x35, 0x66, 0x62, 0x31, 0x35, 0x39, 0x66, 0x31, 0x62, 0x66, 0x35, 0x66, 0x63, 0x37, 0x32, 0x32, 0x36, 0x33, 0x62, 0x30, 0x30, 0x66, 0x62, 0x37, 0x63, 0x38, 0x39, 0x35, 0x38, 0x35, 0x32, 0x34, 0x65, 0x34, 0x65, 0x61, 0x63, 0x61, 0x64, 0x38, 0x38, 0x30, 0x36, 0x63, 0x66, 0x37, 0x61, 0x30, 0x39, 0x64, 0x39, 0x61, 0x65, 0x38, 0x36, 0x38, 0x62, 0x36, 0x31, 0x62, 0x61, 0x39, 0x35, 0x38, 0x36, 0x39, 0x35, 0x35, 0x37, 0x62, 0x37, 0x66, 0x34, 0x38, 0x61, 0x61, 0x38, 0x30, 0x66, 0x37, 0x65, 0x63, 0x37, 0x64, 0x37, 0x32, 0x64, 0x31, 0x38, 0x34, 0x62, 0x61, 0x36, 0x61, 0x38, 0x63, 0x32, 0x66, 0x33, 0x37, 0x38, 0x65, 0x33, 0x31, 0x65, 0x62, 0x65, 0x32, 0x35, 0x39, 0x39, 0x65, 0x61, 0x37, 0x30, 0x37, 0x37, 0x36, 0x39, 0x63, 0x32, 0x65, 0x63, 0x39, 0x64, 0x38, 0x34, 0x36, 0x32, 0x39, 0x61, 0x36, 0x64, 0x61, 0x39, 0x63, 0x31, 0x30, 0x34, 0x36, 0x63, 0x30, 0x31, 0x32, 0x34, 0x35, 0x34, 0x34, 0x33, 0x36, 0x36, 0x37, 0x39, 0x61, 0x38, 0x38, 0x38, 0x65, 0x62, 0x32, 0x34, 0x63, 0x61, 0x64, 0x38, 0x30, 0x36, 0x62, 0x37, 0x32, 0x30, 0x66, 0x30, 0x31, 0x32, 0x65, 0x31, 0x37, 0x33, 0x35, 0x37, 0x31, 0x30, 0x66, 0x66, 0x34, 0x38, 0x63, 0x35, 0x63, 0x31, 0x33, 0x31, 0x65, 0x32, 0x31, 0x62, 0x32, 0x64, 0x65, 0x63, 0x63, 0x36, 0x62, 0x65, 0x32, 0x37, 0x61, 0x63, 0x30, 0x61, 0x31, 0x37, 0x65, 0x30, 0x31, 0x30, 0x35, 0x38, 0x36, 0x34, 0x30, 0x37, 0x65, 0x66, 0x65, 0x31, 0x32, 0x30, 0x62, 0x37, 0x65, 0x62, 0x64, 0x36, 0x36, 0x63, 0x62, 0x65, 0x34, 0x38, 0x36, 0x61, 0x30, 0x66, 0x66, 0x61, 0x35, 0x30, 0x36, 0x66, 0x62, 0x31, 0x35, 0x31, 0x35, 0x30, 0x63, 0x34, 0x37, 0x34, 0x62, 0x63, 0x62, 0x63, 0x64, 0x34, 0x63, 0x31, 0x37, 0x32, 0x39, 0x34, 0x32, 0x62, 0x62, 0x36, 0x34, 0x33, 0x66, 0x36, 0x30, 0x34, 0x33, 0x34, 0x62, 0x38, 0x30, 0x61, 0x33, 0x66, 0x36, 0x65, 0x34, 0x66, 0x66, 0x39, 0x30, 0x30, 0x61, 0x63, 0x34, 0x34, 0x61, 0x30, 0x62, 0x31, 0x31, 0x66, 0x35, 0x36, 0x34, 0x37, 0x65, 0x38, 0x64, 0x39, 0x35, 0x36, 0x32, 0x38, 0x63, 0x35, 0x39, 0x30, 0x36, 0x38, 0x63, 0x66, 0x38, 0x66, 0x66, 0x66, 0x35, 0x32, 0x34, 0x31, 0x38, 0x33, 0x66, 0x31, 0x35, 0x65, 0x62, 0x39, 0x39, 0x38, 0x31, 0x30, 0x65, 0x36, 0x64, 0x64, 0x33, 0x65, 0x36, 0x66, 0x31, 0x33, 0x64, 0x62, 0x61, 0x32, 0x31, 0x33, 0x63, 0x62, 0x32, 0x37, 0x30, 0x33, 0x62, 0x37, 0x66, 0x30, 0x31, 0x33, 0x31, 0x62, 0x65, 0x66, 0x37, 0x63, 0x66, 0x37, 0x35, 0x31, 0x36, 0x34, 0x63, 0x35, 0x39, 0x65, 0x63, 0x65, 0x62, 0x31, 0x32, 0x37, 0x37, 0x35, 0x33, 0x32, 0x32, 0x32, 0x37, 0x31, 0x36, 0x39, 0x31, 0x31, 0x34, 0x35, 0x35, 0x39, 0x61, 0x30, 0x33, 0x31, 0x62, 0x35, 0x37, 0x61, 0x64, 0x62, 0x61, 0x37, 0x38, 0x38, 0x61, 0x64, 0x66, 0x32, 0x31, 0x33, 0x39, 0x64, 0x35, 0x63, 0x33, 0x33, 0x31, 0x30, 0x32, 0x64, 0x33, 0x36, 0x38, 0x33, 0x31, 0x63, 0x36, 0x35, 0x31, 0x30, 0x61, 0x37, 0x37, 0x65, 0x35, 0x63, 0x37, 0x32, 0x66, 0x35, 0x64, 0x36, 0x66, 0x30, 0x32, 0x63, 0x38, 0x62, 0x36, 0x30, 0x30, 0x65, 0x63, 0x38, 0x36, 0x36, 0x62, 0x61, 0x31, 0x61, 0x35, 0x37, 0x63, 0x35, 0x30, 0x39, 0x32, 0x33, 0x35, 0x63, 0x31, 0x37, 0x37, 0x62, 0x39, 0x66, 0x64, 0x39, 0x31, 0x66, 0x37, 0x61, 0x31, 0x34, 0x37, 0x65, 0x33, 0x63, 0x34, 0x35, 0x31, 0x33, 0x33, 0x31, 0x62, 0x31, 0x63, 0x32, 0x63, 0x32, 0x37, 0x32, 0x34, 0x66, 0x32, 0x36, 0x32, 0x66, 0x39, 0x33, 0x37, 0x39, 0x30, 0x64, 0x62, 0x35, 0x38, 0x30, 0x33, 0x30, 0x33, 0x66, 0x39, 0x63, 0x63, 0x30, 0x37, 0x62, 0x63, 0x64, 0x31, 0x36, 0x38, 0x35, 0x37, 0x64, 0x62, 0x32, 0x32, 0x31, 0x32, 0x31, 0x32, 0x62, 0x32, 0x66, 0x63, 0x35, 0x33, 0x30, 0x31, 0x64, 0x66, 0x35, 0x64, 0x30, 0x61, 0x61, 0x33, 0x33, 0x38, 0x64, 0x37, 0x62, 0x37, 0x32, 0x66, 0x64, 0x31, 0x63, 0x38, 0x66, 0x37, 0x35, 0x33, 0x65, 0x66, 0x63, 0x38, 0x64, 0x61, 0x35, 0x64, 0x35, 0x61, 0x32, 0x61, 0x66, 0x66, 0x32, 0x30, 0x34, 0x32, 0x64, 0x39, 0x31, 0x38, 0x35, 0x64, 0x65, 0x38, 0x30, 0x39, 0x39, 0x61, 0x35, 0x31, 0x65, 0x62, 0x31, 0x62, 0x61, 0x32, 0x61, 0x37, 0x38, 0x30, 0x62, 0x32, 0x65, 0x30, 0x34, 0x64, 0x66, 0x65, 0x61, 0x66, 0x62, 0x33, 0x32, 0x64, 0x65, 0x62, 0x36, 0x36, 0x65, 0x39, 0x63, 0x35, 0x66, 0x38, 0x31, 0x62, 0x39, 0x39, 0x38, 0x30, 0x33, 0x39, 0x66, 0x64, 0x38, 0x31, 0x35, 0x65, 0x32, 0x34, 0x36, 0x32, 0x31, 0x37, 0x35, 0x39, 0x37, 0x36, 0x66, 0x66, 0x64, 0x35, 0x39, 0x61, 0x38, 0x61, 0x61, 0x39, 0x32, 0x30, 0x30, 0x62, 0x66, 0x31, 0x64, 0x30, 0x38, 0x37, 0x38, 0x66, 0x61, 0x37, 0x66, 0x39, 0x65, 0x33, 0x65, 0x38, 0x65, 0x63, 0x31, 0x62, 0x62, 0x36, 0x64, 0x37, 0x66, 0x35, 0x37, 0x38, 0x36, 0x36, 0x34, 0x34, 0x64, 0x62, 0x37, 0x33, 0x31, 0x30, 0x34, 0x61, 0x66, 0x32, 0x39, 0x36, 0x63, 0x35, 0x37, 0x39, 0x35, 0x32, 0x30, 0x31, 0x61, 0x33, 0x30, 0x37, 0x31, 0x33, 0x34, 0x30, 0x30, 0x34, 0x61, 0x39, 0x30, 0x62, 0x34, 0x34, 0x62, 0x66, 0x62, 0x61, 0x66, 0x62, 0x64, 0x31, 0x32, 0x32, 0x38, 0x66, 0x39, 0x32, 0x65, 0x39, 0x62, 0x33, 0x36, 0x36, 0x62, 0x39, 0x38, 0x66, 0x64, 0x66, 0x64, 0x61, 0x31, 0x31, 0x38, 0x33, 0x62, 0x61, 0x37, 0x63, 0x66, 0x65, 0x33, 0x30, 0x30, 0x64, 0x61, 0x65, 0x61, 0x38, 0x61, 0x38, 0x35, 0x38, 0x33, 0x35, 0x32, 0x66, 0x61, 0x35, 0x35, 0x35, 0x39, 0x30, 0x36, 0x39, 0x64, 0x30, 0x31, 0x32, 0x39, 0x65, 0x38, 0x39, 0x36, 0x64, 0x65, 0x37, 0x32, 0x38, 0x32, 0x66, 0x31, 0x65, 0x64, 0x30, 0x39, 0x30, 0x62, 0x66, 0x31, 0x61, 0x38, 0x61, 0x62, 0x37, 0x35, 0x66, 0x32, 0x66, 0x34, 0x30, 0x38, 0x32, 0x65, 0x37, 0x63, 0x63, 0x33, 0x63, 0x37, 0x34, 0x33, 0x36, 0x30, 0x32, 0x64, 0x31, 0x38, 0x33, 0x32, 0x33, 0x66, 0x33, 0x35, 0x36, 0x33, 0x64, 0x66, 0x31, 0x38, 0x38, 0x36, 0x62, 0x66, 0x37, 0x66, 0x61, 0x62, 0x61, 0x61, 0x32, 0x37, 0x33, 0x63, 0x36, 0x38, 0x36, 0x65, 0x32, 0x63, 0x38, 0x65, 0x65, 0x37, 0x37, 0x65, 0x37, 0x61, 0x33, 0x63, 0x63, 0x64, 0x63, 0x31, 0x62, 0x61, 0x65, 0x36, 0x65, 0x66, 0x33, 0x37, 0x36, 0x66, 0x37, 0x34, 0x31, 0x32, 0x35, 0x64, 0x64, 0x63, 0x30, 0x30, 0x31, 0x65, 0x30, 0x61, 0x64, 0x35, 0x35, 0x36, 0x35, 0x39, 0x62, 0x36, 0x36, 0x34, 0x30, 0x35, 0x39, 0x61, 0x36, 0x35, 0x37, 0x32, 0x39, 0x35, 0x35, 0x38, 0x61, 0x31, 0x38, 0x35, 0x33, 0x62, 0x63, 0x30, 0x39, 0x64, 0x32, 0x30, 0x30, 0x65, 0x66, 0x34, 0x31, 0x63, 0x63, 0x39, 0x30, 0x38, 0x36, 0x61, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x30, 0x30, 0x38, 0x36, 0x39, 0x35, 0x63, 0x34, 0x33, 0x63, 0x39, 0x37, 0x32, 0x64, 0x36, 0x38, 0x62, 0x65, 0x33, 0x38, 0x35, 0x64, 0x32, 0x34, 0x37, 0x64, 0x35, 0x66, 0x37, 0x32, 0x65, 0x34, 0x37, 0x37, 0x38, 0x35, 0x61, 0x32, 0x35, 0x33, 0x31, 0x34, 0x65, 0x34, 0x36, 0x62, 0x38, 0x61, 0x38, 0x64, 0x31, 0x35, 0x39, 0x35, 0x65, 0x62, 0x61, 0x34, 0x32, 0x36, 0x37, 0x66, 0x39, 0x30, 0x65, 0x31, 0x36, 0x62, 0x39, 0x37, 0x64, 0x39, 0x64, 0x32, 0x39, 0x32, 0x30, 0x30, 0x35, 0x34, 0x34, 0x32, 0x63, 0x61, 0x64, 0x65, 0x32, 0x39, 0x64, 0x38, 0x63, 0x37, 0x35, 0x64, 0x33, 0x34, 0x64, 0x39, 0x33, 0x65, 0x31, 0x31, 0x33, 0x38, 0x32, 0x38, 0x30, 0x64, 0x34, 0x34, 0x33, 0x36, 0x31, 0x37, 0x30, 0x39, 0x32, 0x34, 0x33, 0x32, 0x62, 0x64, 0x30, 0x36, 0x30, 0x36, 0x32, 0x38, 0x63, 0x30, 0x65, 0x36, 0x37, 0x34, 0x36, 0x34, 0x66, 0x35, 0x39, 0x64, 0x35, 0x63, 0x38, 0x37, 0x35, 0x34, 0x34, 0x66, 0x35, 0x31, 0x65, 0x37, 0x36, 0x30, 0x66, 0x30, 0x30, 0x62, 0x31, 0x30, 0x30, 0x64, 0x66, 0x33, 0x63, 0x61, 0x31, 0x66, 0x66, 0x32, 0x62, 0x38, 0x38, 0x38, 0x37, 0x38, 0x34, 0x31, 0x36, 0x65, 0x65, 0x32, 0x31, 0x64, 0x39, 0x38, 0x31, 0x64, 0x33, 0x37, 0x36, 0x33, 0x35, 0x31, 0x61, 0x66, 0x39, 0x62, 0x62, 0x30, 0x35, 0x36, 0x33, 0x33, 0x63, 0x65, 0x33, 0x63, 0x36, 0x66, 0x36, 0x34, 0x64, 0x37, 0x61, 0x63, 0x64, 0x61, 0x32, 0x30, 0x34, 0x31, 0x63, 0x65, 0x35, 0x36, 0x34, 0x61, 0x63, 0x31, 0x64, 0x66, 0x32, 0x61, 0x30, 0x63, 0x63, 0x61, 0x31, 0x36, 0x65, 0x65, 0x39, 0x63, 0x32, 0x36, 0x36, 0x34, 0x64, 0x33, 0x31, 0x33, 0x34, 0x30, 0x35, 0x30, 0x62, 0x36, 0x39, 0x32, 0x63, 0x37, 0x66, 0x38, 0x63, 0x35, 0x37, 0x31, 0x32, 0x66, 0x62, 0x30, 0x34, 0x62, 0x37, 0x30, 0x64, 0x39, 0x65, 0x36, 0x61, 0x37, 0x31, 0x66, 0x32, 0x30, 0x63, 0x38, 0x31, 0x31, 0x33, 0x30, 0x64, 0x65, 0x37, 0x36, 0x33, 0x36, 0x39, 0x62, 0x37, 0x39, 0x65, 0x30, 0x64, 0x39, 0x38, 0x63, 0x65, 0x66, 0x35, 0x31, 0x39, 0x37, 0x63, 0x35, 0x34, 0x65, 0x33, 0x32, 0x39, 0x65, 0x62, 0x31, 0x63, 0x33, 0x34, 0x36, 0x65, 0x31, 0x62, 0x63, 0x63, 0x61, 0x32, 0x38, 0x31, 0x34, 0x36, 0x30, 0x61, 0x33, 0x34, 0x36, 0x39, 0x65, 0x35, 0x63, 0x37, 0x32, 0x38, 0x38, 0x34, 0x62, 0x64, 0x63, 0x65, 0x66, 0x63, 0x38, 0x65, 0x31, 0x36, 0x62, 0x34, 0x63, 0x38, 0x61, 0x30, 0x61, 0x39, 0x37, 0x62, 0x36, 0x65, 0x65, 0x61, 0x31, 0x65, 0x39, 0x37, 0x37, 0x36, 0x65, 0x36, 0x32, 0x30, 0x38, 0x33, 0x65, 0x34, 0x62, 0x35, 0x36, 0x35, 0x32, 0x33, 0x65, 0x36, 0x61, 0x61, 0x30, 0x36, 0x39, 0x66, 0x33, 0x66, 0x39, 0x37, 0x38, 0x61, 0x33, 0x37, 0x32, 0x64, 0x66, 0x32, 0x30, 0x65, 0x36, 0x66, 0x33, 0x65, 0x61, 0x62, 0x31, 0x37, 0x33, 0x37, 0x65, 0x61, 0x36, 0x34, 0x37, 0x38, 0x35, 0x35, 0x62, 0x37, 0x39, 0x30, 0x37, 0x36, 0x65, 0x37, 0x38, 0x34, 0x65, 0x33, 0x39, 0x34, 0x36, 0x63, 0x39, 0x34, 0x39, 0x33, 0x62, 0x65, 0x38, 0x63, 0x38, 0x35, 0x63, 0x64, 0x36, 0x66, 0x65, 0x32, 0x65, 0x36, 0x34, 0x61, 0x32, 0x35, 0x30, 0x37, 0x32, 0x30, 0x32, 0x35, 0x36, 0x66, 0x32, 0x39, 0x35, 0x65, 0x38, 0x61, 0x65, 0x65, 0x36, 0x31, 0x38, 0x30, 0x35, 0x62, 0x34, 0x33, 0x62, 0x35, 0x34, 0x37, 0x63, 0x30, 0x66, 0x31, 0x34, 0x38, 0x30, 0x34, 0x65, 0x30, 0x61, 0x61, 0x31, 0x31, 0x61, 0x64, 0x37, 0x38, 0x32, 0x35, 0x34, 0x64, 0x34, 0x32, 0x62, 0x63, 0x35, 0x34, 0x64, 0x38, 0x65, 0x31, 0x61, 0x39, 0x32, 0x65, 0x39, 0x37, 0x32, 0x32, 0x62, 0x62, 0x33, 0x62, 0x30, 0x38, 0x32, 0x32, 0x63, 0x66, 0x33, 0x31, 0x36, 0x35, 0x33, 0x32, 0x39, 0x65, 0x33, 0x34, 0x64, 0x36, 0x30, 0x64, 0x39, 0x61, 0x63, 0x32, 0x61, 0x66, 0x32, 0x34, 0x39, 0x30, 0x63, 0x62, 0x65, 0x34, 0x33, 0x36, 0x37, 0x64, 0x36, 0x31, 0x39, 0x66, 0x34, 0x34, 0x61, 0x65, 0x62, 0x65, 0x36, 0x34, 0x65, 0x32, 0x62, 0x63, 0x35, 0x32, 0x38, 0x33, 0x31, 0x61, 0x35, 0x32, 0x64, 0x62, 0x32, 0x38, 0x64, 0x35, 0x32, 0x39, 0x33, 0x32, 0x31, 0x33, 0x31, 0x62, 0x36, 0x61, 0x62, 0x63, 0x35, 0x63, 0x38, 0x37, 0x31, 0x34, 0x63, 0x65, 0x30, 0x63, 0x37, 0x64, 0x31, 0x31, 0x33, 0x37, 0x61, 0x34, 0x39, 0x34, 0x38, 0x35, 0x32, 0x66, 0x61, 0x66, 0x65, 0x33, 0x66, 0x34, 0x35, 0x38, 0x66, 0x34, 0x63, 0x37, 0x34, 0x39, 0x39, 0x32, 0x34, 0x35, 0x64, 0x36, 0x32, 0x31, 0x33, 0x35, 0x64, 0x62, 0x38, 0x32, 0x39, 0x61, 0x36, 0x35, 0x33, 0x65, 0x36, 0x64, 0x61, 0x65, 0x39, 0x38, 0x32, 0x33, 0x33, 0x31, 0x31, 0x64, 0x33, 0x38, 0x32, 0x65, 0x62, 0x61, 0x62, 0x64, 0x61, 0x31, 0x64, 0x66, 0x66, 0x35, 0x63, 0x66, 0x35, 0x39, 0x34, 0x38, 0x62, 0x63, 0x39, 0x36, 0x30, 0x33, 0x36, 0x30, 0x64, 0x62, 0x37, 0x61, 0x37, 0x38, 0x37, 0x32, 0x34, 0x38, 0x64, 0x65, 0x33, 0x64, 0x32, 0x63, 0x61, 0x32, 0x36, 0x61, 0x36, 0x37, 0x64, 0x66, 0x61, 0x30, 0x36, 0x32, 0x62, 0x39, 0x33, 0x64, 0x34, 0x33, 0x37, 0x63, 0x32, 0x66, 0x35, 0x66, 0x61, 0x37, 0x31, 0x63, 0x36, 0x38, 0x38, 0x61, 0x35, 0x31, 0x33, 0x37, 0x35, 0x62, 0x32, 0x37, 0x32, 0x33, 0x37, 0x33, 0x30, 0x38, 0x31, 0x38, 0x30, 0x64, 0x39, 0x38, 0x37, 0x66, 0x33, 0x37, 0x32, 0x61, 0x31, 0x39, 0x38, 0x39, 0x36, 0x65, 0x36, 0x64, 0x62, 0x65, 0x33, 0x39, 0x31, 0x32, 0x34, 0x35, 0x35, 0x31, 0x31, 0x34, 0x64, 0x64, 0x31, 0x30, 0x38, 0x34, 0x33, 0x35, 0x31, 0x39, 0x37, 0x63, 0x33, 0x37, 0x38, 0x32, 0x33, 0x37, 0x62, 0x33, 0x36, 0x61, 0x35, 0x61, 0x30, 0x61, 0x36, 0x31, 0x37, 0x35, 0x62, 0x62, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x38, 0x61, 0x64, 0x37, 0x32, 0x66, 0x34, 0x61, 0x39, 0x35, 0x31, 0x30, 0x65, 0x37, 0x33, 0x35, 0x62, 0x65, 0x64, 0x35, 0x63, 0x65, 0x31, 0x33, 0x32, 0x30, 0x65, 0x36, 0x62, 0x37, 0x30, 0x35, 0x61, 0x62, 0x35, 0x64, 0x39, 0x33, 0x30, 0x36, 0x65, 0x63, 0x64, 0x39, 0x61, 0x39, 0x33, 0x35, 0x65, 0x36, 0x32, 0x64, 0x61, 0x64, 0x37, 0x36, 0x39, 0x39, 0x31, 0x30, 0x62, 0x32, 0x61, 0x37, 0x34, 0x61, 0x34, 0x37, 0x32, 0x30, 0x64, 0x32, 0x62, 0x39, 0x64, 0x61, 0x37, 0x61, 0x63, 0x65, 0x34, 0x66, 0x38, 0x66, 0x64, 0x31, 0x38, 0x38, 0x63, 0x37, 0x30, 0x33, 0x32, 0x63, 0x36, 0x66, 0x32, 0x62, 0x39, 0x66, 0x31, 0x62, 0x35, 0x30, 0x63, 0x33, 0x61, 0x36, 0x39, 0x37, 0x65, 0x63, 0x36, 0x31, 0x39, 0x32, 0x66, 0x62, 0x65, 0x39, 0x38, 0x37, 0x31, 0x36, 0x35, 0x36, 0x39, 0x37, 0x34, 0x38, 0x61, 0x36, 0x62, 0x66, 0x33, 0x65, 0x39, 0x31, 0x34, 0x37, 0x32, 0x32, 0x66, 0x35, 0x38, 0x64, 0x64, 0x64, 0x66, 0x64, 0x34, 0x61, 0x38, 0x32, 0x30, 0x64, 0x31, 0x32, 0x66, 0x61, 0x39, 0x65, 0x66, 0x38, 0x35, 0x65, 0x64, 0x62, 0x31, 0x38, 0x64, 0x30, 0x37, 0x34, 0x31, 0x36, 0x33, 0x66, 0x33, 0x34, 0x32, 0x66, 0x39, 0x35, 0x62, 0x36, 0x66, 0x62, 0x38, 0x30, 0x36, 0x62, 0x35, 0x38, 0x38, 0x37, 0x32, 0x62, 0x36, 0x35, 0x64, 0x36, 0x37, 0x32, 0x31, 0x34, 0x38, 0x38, 0x39, 0x32, 0x38, 0x34, 0x38, 0x30, 0x36, 0x34, 0x31, 0x31, 0x63, 0x64, 0x33, 0x34, 0x66, 0x62, 0x31, 0x31, 0x64, 0x31, 0x64, 0x63, 0x30, 0x39, 0x39, 0x31, 0x61, 0x66, 0x63, 0x34, 0x36, 0x62, 0x35, 0x66, 0x35, 0x33, 0x30, 0x37, 0x36, 0x36, 0x36, 0x66, 0x33, 0x35, 0x34, 0x33, 0x32, 0x37, 0x37, 0x34, 0x30, 0x37, 0x32, 0x65, 0x64, 0x66, 0x35, 0x36, 0x34, 0x32, 0x31, 0x62, 0x31, 0x34, 0x61, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, 0x66, 0x64, 0x61, 0x38, 0x39, 0x62, 0x36, 0x64, 0x32, 0x66, 0x64, 0x39, 0x30, 0x33, 0x32, 0x36, 0x38, 0x64, 0x65, 0x63, 0x32, 0x32, 0x39, 0x30, 0x34, 0x62, 0x32, 0x66, 0x38, 0x64, 0x61, 0x62, 0x36, 0x38, 0x30, 0x32, 0x62, 0x61, 0x62, 0x30, 0x35, 0x38, 0x38, 0x37, 0x32, 0x35, 0x64, 0x63, 0x33, 0x65, 0x63, 0x32, 0x34, 0x38, 0x64, 0x39, 0x37, 0x65, 0x36, 0x32, 0x37, 0x37, 0x64, 0x38, 0x64, 0x36, 0x39, 0x38, 0x39, 0x65, 0x63, 0x31, 0x32, 0x30, 0x34, 0x37, 0x32, 0x33, 0x35, 0x30, 0x30, 0x63, 0x34, 0x32, 0x34, 0x30, 0x66, 0x36, 0x33, 0x62, 0x61, 0x34, 0x35, 0x66, 0x32, 0x35, 0x38, 0x63, 0x39, 0x35, 0x63, 0x62, 0x32, 0x33, 0x36, 0x62, 0x39, 0x37, 0x32, 0x36, 0x38, 0x63, 0x35, 0x61, 0x61, 0x63, 0x39, 0x35, 0x32, 0x34, 0x34, 0x37, 0x39, 0x35, 0x39, 0x32, 0x30, 0x39, 0x66, 0x34, 0x30, 0x61, 0x66, 0x66, 0x36, 0x38, 0x62, 0x31, 0x34, 0x63, 0x31, 0x35, 0x32, 0x65, 0x33, 0x34, 0x66, 0x66, 0x66, 0x66, 0x63, 0x36, 0x63, 0x32, 0x35, 0x66, 0x39, 0x39, 0x64, 0x61, 0x35, 0x37, 0x39, 0x30, 0x31, 0x31, 0x39, 0x31, 0x62, 0x66, 0x39, 0x35, 0x61, 0x37, 0x34, 0x62, 0x62, 0x62, 0x30, 0x36, 0x37, 0x66, 0x62, 0x33, 0x35, 0x36, 0x66, 0x66, 0x65, 0x66, 0x63, 0x62, 0x66, 0x37, 0x64, 0x32, 0x37, 0x62, 0x66, 0x65, 0x64, 0x64, 0x39, 0x38, 0x33, 0x61, 0x61, 0x63, 0x36, 0x37, 0x39, 0x30, 0x37, 0x32, 0x36, 0x66, 0x39, 0x61, 0x35, 0x62, 0x64, 0x36, 0x63, 0x63, 0x62, 0x34, 0x39, 0x35, 0x63, 0x62, 0x34, 0x32, 0x66, 0x38, 0x36, 0x37, 0x32, 0x32, 0x30, 0x36, 0x37, 0x61, 0x32, 0x37, 0x34, 0x34, 0x63, 0x35, 0x35, 0x36, 0x31, 0x30, 0x32, 0x64, 0x39, 0x38, 0x38, 0x33, 0x38, 0x37, 0x33, 0x34, 0x37, 0x34, 0x32, 0x39, 0x33, 0x35, 0x65, 0x64, 0x35, 0x35, 0x62, 0x38, 0x66, 0x64, 0x30, 0x33, 0x61, 0x30, 0x34, 0x38, 0x35, 0x64, 0x30, 0x32, 0x62, 0x32, 0x39, 0x33, 0x32, 0x32, 0x37, 0x62, 0x38, 0x66, 0x63, 0x34, 0x36, 0x37, 0x32, 0x61, 0x39, 0x61, 0x32, 0x37, 0x31, 0x30, 0x62, 0x36, 0x39, 0x39, 0x34, 0x39, 0x33, 0x66, 0x35, 0x36, 0x36, 0x64, 0x38, 0x35, 0x66, 0x31, 0x36, 0x61, 0x34, 0x65, 0x65, 0x38, 0x36, 0x35, 0x34, 0x63, 0x62, 0x36, 0x32, 0x36, 0x63, 0x33, 0x38, 0x36, 0x66, 0x66, 0x31, 0x38, 0x35, 0x63, 0x61, 0x30, 0x30, 0x65, 0x35, 0x31, 0x63, 0x64, 0x38, 0x65, 0x39, 0x38, 0x35, 0x66, 0x33, 0x36, 0x33, 0x61, 0x65, 0x63, 0x33, 0x64, 0x63, 0x61, 0x33, 0x39, 0x32, 0x65, 0x36, 0x62, 0x62, 0x34, 0x31, 0x31, 0x36, 0x37, 0x34, 0x32, 0x66, 0x62, 0x37, 0x62, 0x31, 0x61, 0x33, 0x66, 0x61, 0x37, 0x37, 0x36, 0x33, 0x61, 0x33, 0x65, 0x65, 0x61, 0x65, 0x66, 0x63, 0x66, 0x36, 0x36, 0x31, 0x32, 0x62, 0x35, 0x33, 0x64, 0x30, 0x39, 0x65, 0x64, 0x66, 0x63, 0x39, 0x38, 0x34, 0x35, 0x35, 0x37, 0x32, 0x31, 0x64, 0x38, 0x30, 0x33, 0x34, 0x39, 0x38, 0x65, 0x33, 0x32, 0x34, 0x33, 0x38, 0x34, 0x33, 0x66, 0x62, 0x62, 0x38, 0x37, 0x63, 0x36, 0x32, 0x36, 0x34, 0x32, 0x35, 0x31, 0x39, 0x37, 0x34, 0x35, 0x66, 0x33, 0x36, 0x38, 0x38, 0x66, 0x31, 0x65, 0x31, 0x38, 0x32, 0x31, 0x63, 0x65, 0x64, 0x66, 0x32, 0x62, 0x35, 0x38, 0x39, 0x61, 0x63, 0x32, 0x61, 0x35, 0x64, 0x32, 0x65, 0x36, 0x38, 0x36, 0x36, 0x65, 0x33, 0x32, 0x64, 0x65, 0x37, 0x33, 0x31, 0x35, 0x38, 0x32, 0x65, 0x63, 0x65, 0x66, 0x35, 0x66, 0x32, 0x63, 0x61, 0x38, 0x33, 0x33, 0x34, 0x35, 0x65, 0x34, 0x65, 0x36, 0x38, 0x34, 0x34, 0x37, 0x66, 0x65, 0x64, 0x66, 0x32, 0x35, 0x33, 0x63, 0x31, 0x37, 0x35, 0x39, 0x65, 0x37, 0x30, 0x61, 0x66, 0x34, 0x35, 0x36, 0x66, 0x35, 0x64, 0x61, 0x63, 0x62, 0x36, 0x37, 0x32, 0x62, 0x66, 0x37, 0x61, 0x66, 0x33, 0x36, 0x39, 0x30, 0x36, 0x31, 0x66, 0x36, 0x35, 0x64, 0x62, 0x64, 0x66, 0x35, 0x35, 0x30, 0x64, 0x36, 0x66, 0x34, 0x31, 0x65, 0x30, 0x63, 0x33, 0x32, 0x65, 0x32, 0x63, 0x36, 0x61, 0x34, 0x36, 0x36, 0x62, 0x62, 0x36, 0x32, 0x64, 0x61, 0x61, 0x37, 0x64, 0x61, 0x62, 0x66, 0x36, 0x35, 0x38, 0x31, 0x35, 0x30, 0x35, 0x63, 0x33, 0x61, 0x63, 0x37, 0x32, 0x34, 0x39, 0x36, 0x38, 0x30, 0x65, 0x31, 0x64, 0x34, 0x64, 0x37, 0x38, 0x64, 0x65, 0x34, 0x63, 0x35, 0x32, 0x37, 0x62, 0x35, 0x31, 0x30, 0x65, 0x38, 0x30, 0x35, 0x33, 0x63, 0x34, 0x33, 0x63, 0x34, 0x62, 0x39, 0x39, 0x31, 0x63, 0x37, 0x37, 0x36, 0x64, 0x38, 0x38, 0x30, 0x66, 0x64, 0x31, 0x38, 0x33, 0x33, 0x64, 0x66, 0x38, 0x38, 0x33, 0x65, 0x30, 0x35, 0x63, 0x62, 0x33, 0x37, 0x32, 0x63, 0x37, 0x65, 0x36, 0x31, 0x61, 0x66, 0x32, 0x32, 0x36, 0x32, 0x61, 0x31, 0x34, 0x30, 0x33, 0x63, 0x63, 0x38, 0x65, 0x65, 0x38, 0x37, 0x30, 0x38, 0x32, 0x31, 0x38, 0x66, 0x32, 0x32, 0x32, 0x31, 0x39, 0x65, 0x39, 0x39, 0x36, 0x63, 0x34, 0x63, 0x62, 0x32, 0x33, 0x37, 0x65, 0x32, 0x61, 0x33, 0x61, 0x33, 0x31, 0x65, 0x31, 0x33, 0x62, 0x39, 0x64, 0x39, 0x32, 0x66, 0x38, 0x37, 0x32, 0x64, 0x32, 0x33, 0x30, 0x62, 0x39, 0x30, 0x31, 0x64, 0x62, 0x34, 0x35, 0x32, 0x31, 0x39, 0x38, 0x32, 0x65, 0x63, 0x38, 0x39, 0x32, 0x61, 0x33, 0x31, 0x30, 0x37, 0x35, 0x37, 0x32, 0x36, 0x36, 0x36, 0x34, 0x62, 0x37, 0x64, 0x38, 0x39, 0x34, 0x33, 0x31, 0x30, 0x31, 0x34, 0x66, 0x32, 0x39, 0x64, 0x63, 0x39, 0x36, 0x64, 0x62, 0x66, 0x66, 0x61, 0x62, 0x31, 0x36, 0x63, 0x36, 0x37, 0x32, 0x31, 0x35, 0x65, 0x61, 0x39, 0x66, 0x66, 0x64, 0x31, 0x37, 0x31, 0x35, 0x34, 0x35, 0x36, 0x38, 0x33, 0x39, 0x34, 0x33, 0x36, 0x31, 0x34, 0x38, 0x61, 0x61, 0x31, 0x62, 0x35, 0x31, 0x36, 0x36, 0x61, 0x32, 0x63, 0x65, 0x37, 0x64, 0x35, 0x61, 0x35, 0x33, 0x38, 0x39, 0x64, 0x33, 0x30, 0x32, 0x37, 0x63, 0x30, 0x37, 0x31, 0x61, 0x63, 0x39, 0x62, 0x33, 0x35, 0x35, 0x31, 0x34, 0x37, 0x32, 0x31, 0x34, 0x65, 0x64, 0x30, 0x36, 0x61, 0x65, 0x31, 0x64, 0x35, 0x37, 0x62, 0x35, 0x38, 0x38, 0x34, 0x33, 0x33, 0x30, 0x33, 0x64, 0x65, 0x37, 0x35, 0x30, 0x65, 0x31, 0x66, 0x38, 0x33, 0x31, 0x64, 0x30, 0x30, 0x36, 0x62, 0x30, 0x37, 0x62, 0x39, 0x65, 0x65, 0x39, 0x36, 0x31, 0x34, 0x37, 0x62, 0x62, 0x65, 0x35, 0x39, 0x64, 0x35, 0x36, 0x63, 0x34, 0x64, 0x38, 0x31, 0x38, 0x37, 0x32, 0x34, 0x36, 0x37, 0x36, 0x31, 0x65, 0x39, 0x39, 0x39, 0x63, 0x61, 0x36, 0x31, 0x65, 0x36, 0x35, 0x35, 0x38, 0x30, 0x37, 0x61, 0x36, 0x39, 0x39, 0x30, 0x39, 0x39, 0x39, 0x30, 0x36, 0x36, 0x61, 0x32, 0x31, 0x36, 0x35, 0x66, 0x35, 0x32, 0x36, 0x35, 0x61, 0x62, 0x64, 0x39, 0x62, 0x64, 0x65, 0x38, 0x61, 0x38, 0x61, 0x37, 0x31, 0x39, 0x66, 0x64, 0x30, 0x32, 0x66, 0x33, 0x63, 0x37, 0x32, 0x35, 0x32, 0x63, 0x32, 0x34, 0x35, 0x33, 0x39, 0x65, 0x37, 0x61, 0x39, 0x33, 0x34, 0x61, 0x39, 0x32, 0x37, 0x30, 0x34, 0x35, 0x66, 0x33, 0x63, 0x64, 0x37, 0x30, 0x38, 0x33, 0x37, 0x65, 0x32, 0x65, 0x38, 0x36, 0x65, 0x62, 0x63, 0x65, 0x63, 0x37, 0x62, 0x65, 0x39, 0x35, 0x39, 0x66, 0x65, 0x66, 0x30, 0x36, 0x61, 0x30, 0x66, 0x33, 0x32, 0x37, 0x39, 0x66, 0x35, 0x65, 0x66, 0x30, 0x65, 0x30, 0x33, 0x63, 0x62, 0x65, 0x33, 0x36, 0x37, 0x30, 0x37, 0x63, 0x63, 0x33, 0x36, 0x37, 0x39, 0x66, 0x64, 0x66, 0x63, 0x30, 0x32, 0x34, 0x63, 0x30, 0x32, 0x65, 0x65, 0x32, 0x31, 0x30, 0x61, 0x34, 0x30, 0x33, 0x39, 0x61, 0x39, 0x35, 0x32, 0x37, 0x31, 0x34, 0x63, 0x39, 0x32, 0x37, 0x35, 0x61, 0x64, 0x65, 0x31, 0x37, 0x36, 0x61, 0x62, 0x39, 0x31, 0x64, 0x61, 0x34, 0x64, 0x37, 0x32, 0x64, 0x34, 0x32, 0x38, 0x37, 0x31, 0x38, 0x35, 0x32, 0x61, 0x31, 0x30, 0x33, 0x34, 0x64, 0x36, 0x37, 0x66, 0x63, 0x37, 0x61, 0x64, 0x36, 0x38, 0x65, 0x65, 0x33, 0x63, 0x37, 0x30, 0x39, 0x35, 0x63, 0x61, 0x37, 0x32, 0x63, 0x63, 0x30, 0x64, 0x61, 0x32, 0x31, 0x37, 0x62, 0x65, 0x64, 0x35, 0x33, 0x33, 0x30, 0x36, 0x39, 0x36, 0x35, 0x63, 0x66, 0x62, 0x31, 0x66, 0x61, 0x39, 0x33, 0x31, 0x30, 0x61, 0x39, 0x38, 0x39, 0x61, 0x34, 0x37, 0x32, 0x30, 0x66, 0x64, 0x37, 0x39, 0x33, 0x34, 0x62, 0x65, 0x37, 0x39, 0x39, 0x39, 0x30, 0x32, 0x30, 0x64, 0x34, 0x31, 0x62, 0x32, 0x31, 0x33, 0x65, 0x32, 0x66, 0x31, 0x32, 0x35, 0x63, 0x62, 0x36, 0x39, 0x64, 0x64, 0x32, 0x38, 0x30, 0x36, 0x34, 0x65, 0x61, 0x34, 0x61, 0x31, 0x64, 0x30, 0x66, 0x63, 0x39, 0x62, 0x36, 0x32, 0x34, 0x62, 0x35, 0x37, 0x61, 0x32, 0x31, 0x36, 0x34, 0x31, 0x66, 0x37, 0x64, 0x36, 0x34, 0x33, 0x62, 0x32, 0x33, 0x39, 0x30, 0x65, 0x37, 0x33, 0x34, 0x38, 0x36, 0x66, 0x63, 0x64, 0x61, 0x31, 0x63, 0x36, 0x61, 0x64, 0x63, 0x30, 0x66, 0x33, 0x38, 0x37, 0x64, 0x37, 0x34, 0x62, 0x33, 0x63, 0x35, 0x63, 0x38, 0x30, 0x33, 0x32, 0x33, 0x64, 0x37, 0x66, 0x31, 0x31, 0x36, 0x66, 0x32, 0x66, 0x37, 0x32, 0x61, 0x61, 0x37, 0x36, 0x65, 0x66, 0x65, 0x63, 0x31, 0x65, 0x31, 0x32, 0x31, 0x36, 0x37, 0x32, 0x34, 0x39, 0x38, 0x34, 0x30, 0x65, 0x35, 0x61, 0x39, 0x38, 0x38, 0x35, 0x32, 0x31, 0x66, 0x61, 0x37, 0x33, 0x33, 0x66, 0x34, 0x35, 0x62, 0x39, 0x66, 0x31, 0x66, 0x30, 0x32, 0x39, 0x37, 0x33, 0x36, 0x66, 0x31, 0x33, 0x35, 0x30, 0x37, 0x63, 0x33, 0x34, 0x64, 0x31, 0x39, 0x32, 0x37, 0x32, 0x32, 0x31, 0x63, 0x63, 0x39, 0x36, 0x33, 0x30, 0x32, 0x37, 0x37, 0x39, 0x61, 0x33, 0x63, 0x33, 0x63, 0x37, 0x32, 0x36, 0x62, 0x37, 0x36, 0x39, 0x31, 0x36, 0x32, 0x35, 0x62, 0x65, 0x32, 0x66, 0x35, 0x66, 0x63, 0x35, 0x38, 0x63, 0x31, 0x38, 0x33, 0x34, 0x63, 0x37, 0x32, 0x36, 0x39, 0x35, 0x62, 0x39, 0x66, 0x37, 0x65, 0x38, 0x39, 0x38, 0x38, 0x33, 0x65, 0x39, 0x64, 0x36, 0x37, 0x32, 0x32, 0x31, 0x64, 0x62, 0x64, 0x33, 0x35, 0x39, 0x31, 0x30, 0x38, 0x64, 0x30, 0x66, 0x32, 0x37, 0x31, 0x37, 0x61, 0x30, 0x62, 0x63, 0x36, 0x66, 0x38, 0x35, 0x63, 0x31, 0x37, 0x30, 0x32, 0x30, 0x32, 0x35, 0x66, 0x32, 0x63, 0x34, 0x34, 0x35, 0x30, 0x37, 0x31, 0x36, 0x62, 0x62, 0x62, 0x37, 0x63, 0x64, 0x36, 0x34, 0x66, 0x63, 0x31, 0x32, 0x33, 0x62, 0x30, 0x32, 0x65, 0x36, 0x34, 0x31, 0x34, 0x34, 0x33, 0x64, 0x34, 0x38, 0x38, 0x35, 0x65, 0x38, 0x34, 0x61, 0x36, 0x33, 0x35, 0x66, 0x61, 0x61, 0x65, 0x30, 0x63, 0x33, 0x30, 0x34, 0x31, 0x36, 0x35, 0x63, 0x33, 0x32, 0x32, 0x36, 0x38, 0x63, 0x61, 0x39, 0x31, 0x64, 0x31, 0x30, 0x61, 0x34, 0x39, 0x66, 0x34, 0x36, 0x65, 0x65, 0x64, 0x63, 0x38, 0x30, 0x37, 0x63, 0x34, 0x35, 0x64, 0x66, 0x66, 0x65, 0x64, 0x62, 0x37, 0x32, 0x39, 0x39, 0x31, 0x35, 0x30, 0x35, 0x36, 0x63, 0x66, 0x64, 0x30, 0x63, 0x37, 0x32, 0x35, 0x37, 0x62, 0x35, 0x33, 0x31, 0x64, 0x38, 0x62, 0x63, 0x38, 0x33, 0x65, 0x37, 0x62, 0x33, 0x32, 0x30, 0x38, 0x31, 0x35, 0x62, 0x37, 0x62, 0x61, 0x35, 0x36, 0x33, 0x33, 0x64, 0x32, 0x37, 0x31, 0x38, 0x31, 0x66, 0x31, 0x65, 0x61, 0x34, 0x66, 0x36, 0x62, 0x64, 0x33, 0x32, 0x31, 0x62, 0x37, 0x32, 0x36, 0x34, 0x63, 0x61, 0x61, 0x31, 0x31, 0x31, 0x30, 0x33, 0x32, 0x31, 0x36, 0x33, 0x32, 0x64, 0x34, 0x38, 0x64, 0x64, 0x61, 0x62, 0x35, 0x66, 0x37, 0x31, 0x36, 0x64, 0x38, 0x34, 0x38, 0x36, 0x65, 0x34, 0x64, 0x61, 0x34, 0x38, 0x32, 0x35, 0x37, 0x66, 0x63, 0x33, 0x37, 0x62, 0x34, 0x62, 0x38, 0x38, 0x35, 0x36, 0x38, 0x61, 0x36, 0x32, 0x34, 0x31, 0x64, 0x38, 0x36, 0x64, 0x34, 0x36, 0x64, 0x34, 0x35, 0x63, 0x31, 0x39, 0x65, 0x30, 0x33, 0x32, 0x36, 0x34, 0x37, 0x65, 0x37, 0x36, 0x66, 0x33, 0x30, 0x62, 0x36, 0x32, 0x34, 0x34, 0x32, 0x33, 0x35, 0x37, 0x61, 0x34, 0x62, 0x30, 0x35, 0x63, 0x39, 0x31, 0x36, 0x31, 0x66, 0x36, 0x61, 0x38, 0x35, 0x39, 0x31, 0x64, 0x36, 0x65, 0x34, 0x61, 0x37, 0x34, 0x65, 0x34, 0x66, 0x37, 0x66, 0x31, 0x37, 0x62, 0x39, 0x35, 0x36, 0x38, 0x34, 0x39, 0x36, 0x30, 0x66, 0x37, 0x64, 0x61, 0x62, 0x65, 0x63, 0x39, 0x64, 0x37, 0x62, 0x62, 0x33, 0x65, 0x65, 0x62, 0x37, 0x31, 0x66, 0x32, 0x66, 0x66, 0x39, 0x36, 0x64, 0x30, 0x35, 0x32, 0x30, 0x34, 0x63, 0x35, 0x62, 0x38, 0x38, 0x64, 0x39, 0x62, 0x30, 0x64, 0x39, 0x64, 0x32, 0x63, 0x65, 0x65, 0x65, 0x36, 0x31, 0x61, 0x30, 0x36, 0x31, 0x31, 0x38, 0x34, 0x36, 0x36, 0x32, 0x35, 0x31, 0x36, 0x39, 0x31, 0x32, 0x32, 0x38, 0x32, 0x63, 0x36, 0x35, 0x30, 0x65, 0x38, 0x63, 0x33, 0x35, 0x37, 0x32, 0x33, 0x61, 0x61, 0x34, 0x64, 0x38, 0x39, 0x61, 0x30, 0x62, 0x34, 0x34, 0x64, 0x34, 0x30, 0x36, 0x33, 0x62, 0x66, 0x66, 0x64, 0x64, 0x62, 0x35, 0x30, 0x65, 0x38, 0x37, 0x64, 0x31, 0x39, 0x36, 0x36, 0x66, 0x63, 0x30, 0x35, 0x61, 0x65, 0x36, 0x37, 0x39, 0x63, 0x33, 0x34, 0x30, 0x39, 0x64, 0x38, 0x32, 0x37, 0x39, 0x63, 0x64, 0x39, 0x34, 0x31, 0x31, 0x33, 0x36, 0x34, 0x66, 0x38, 0x62, 0x63, 0x33, 0x33, 0x31, 0x33, 0x63, 0x63, 0x66, 0x34, 0x30, 0x62, 0x38, 0x32, 0x33, 0x31, 0x63, 0x64, 0x32, 0x39, 0x30, 0x66, 0x62, 0x61, 0x37, 0x63, 0x38, 0x38, 0x33, 0x34, 0x32, 0x66, 0x39, 0x34, 0x35, 0x66, 0x37, 0x37, 0x63, 0x66, 0x30, 0x31, 0x35, 0x31, 0x37, 0x32, 0x36, 0x34, 0x34, 0x31, 0x63, 0x35, 0x38, 0x66, 0x64, 0x38, 0x31, 0x30, 0x35, 0x63, 0x62, 0x38, 0x61, 0x64, 0x39, 0x37, 0x36, 0x31, 0x64, 0x61, 0x38, 0x61, 0x35, 0x33, 0x61, 0x66, 0x35, 0x61, 0x63, 0x32, 0x37, 0x62, 0x65, 0x38, 0x38, 0x39, 0x33, 0x36, 0x63, 0x62, 0x65, 0x65, 0x31, 0x65, 0x32, 0x66, 0x65, 0x33, 0x66, 0x38, 0x31, 0x35, 0x30, 0x34, 0x35, 0x35, 0x35, 0x36, 0x36, 0x61, 0x61, 0x36, 0x65, 0x36, 0x61, 0x62, 0x37, 0x62, 0x31, 0x63, 0x35, 0x36, 0x38, 0x66, 0x36, 0x38, 0x36, 0x63, 0x65, 0x30, 0x62, 0x61, 0x62, 0x62, 0x66, 0x63, 0x35, 0x34, 0x65, 0x34, 0x39, 0x66, 0x65, 0x64, 0x38, 0x37, 0x36, 0x36, 0x63, 0x34, 0x65, 0x30, 0x66, 0x62, 0x61, 0x37, 0x64, 0x37, 0x39, 0x38, 0x33, 0x31, 0x39, 0x32, 0x31, 0x61, 0x62, 0x30, 0x62, 0x30, 0x33, 0x62, 0x37, 0x32, 0x32, 0x34, 0x63, 0x66, 0x35, 0x30, 0x39, 0x62, 0x61, 0x61, 0x61, 0x39, 0x64, 0x37, 0x38, 0x30, 0x63, 0x63, 0x61, 0x31, 0x61, 0x62, 0x36, 0x38, 0x65, 0x39, 0x31, 0x33, 0x31, 0x32, 0x66, 0x63, 0x64, 0x32, 0x66, 0x36, 0x61, 0x66, 0x37, 0x37, 0x38, 0x65, 0x64, 0x39, 0x30, 0x34, 0x30, 0x64, 0x36, 0x65, 0x65, 0x31, 0x34, 0x34, 0x34, 0x36, 0x33, 0x62, 0x38, 0x39, 0x39, 0x61, 0x36, 0x33, 0x33, 0x32, 0x37, 0x63, 0x33, 0x66, 0x64, 0x34, 0x64, 0x35, 0x37, 0x37, 0x64, 0x37, 0x37, 0x31, 0x35, 0x36, 0x31, 0x66, 0x31, 0x39, 0x35, 0x62, 0x31, 0x32, 0x30, 0x66, 0x34, 0x65, 0x62, 0x34, 0x34, 0x33, 0x34, 0x64, 0x61, 0x39, 0x64, 0x34, 0x35, 0x38, 0x38, 0x37, 0x39, 0x37, 0x33, 0x36, 0x66, 0x35, 0x66, 0x64, 0x63, 0x61, 0x34, 0x30, 0x35, 0x33, 0x38, 0x63, 0x30, 0x32, 0x31, 0x34, 0x31, 0x31, 0x35, 0x39, 0x34, 0x37, 0x61, 0x30, 0x39, 0x63, 0x63, 0x32, 0x62, 0x30, 0x30, 0x35, 0x30, 0x31, 0x38, 0x34, 0x31, 0x61, 0x35, 0x37, 0x36, 0x61, 0x63, 0x38, 0x34, 0x65, 0x35, 0x65, 0x62, 0x37, 0x31, 0x63, 0x33, 0x37, 0x39, 0x33, 0x65, 0x63, 0x30, 0x66, 0x37, 0x63, 0x39, 0x64, 0x39, 0x35, 0x61, 0x36, 0x36, 0x32, 0x37, 0x64, 0x35, 0x61, 0x31, 0x35, 0x39, 0x33, 0x37, 0x32, 0x35, 0x38, 0x38, 0x61, 0x65, 0x36, 0x63, 0x34, 0x36, 0x63, 0x35, 0x38, 0x31, 0x35, 0x32, 0x32, 0x32, 0x30, 0x66, 0x36, 0x65, 0x30, 0x62, 0x34, 0x62, 0x36, 0x65, 0x61, 0x30, 0x30, 0x39, 0x38, 0x30, 0x64, 0x33, 0x34, 0x31, 0x33, 0x32, 0x65, 0x37, 0x36, 0x38, 0x65, 0x32, 0x62, 0x35, 0x61, 0x63, 0x33, 0x30, 0x36, 0x64, 0x62, 0x63, 0x34, 0x33, 0x37, 0x63, 0x33, 0x35, 0x35, 0x37, 0x32, 0x30, 0x38, 0x33, 0x39, 0x64, 0x32, 0x66, 0x64, 0x62, 0x34, 0x39, 0x61, 0x38, 0x32, 0x38, 0x65, 0x31, 0x64, 0x65, 0x66, 0x37, 0x30, 0x64, 0x64, 0x34, 0x32, 0x34, 0x36, 0x61, 0x38, 0x65, 0x62, 0x36, 0x35, 0x66, 0x39, 0x32, 0x32, 0x37, 0x66, 0x34, 0x30, 0x34, 0x33, 0x35, 0x38, 0x66, 0x65, 0x30, 0x61, 0x62, 0x65, 0x30, 0x65, 0x66, 0x66, 0x65, 0x37, 0x63, 0x64, 0x61, 0x38, 0x36, 0x33, 0x35, 0x63, 0x39, 0x31, 0x39, 0x66, 0x33, 0x66, 0x34, 0x34, 0x37, 0x36, 0x62, 0x30, 0x63, 0x36, 0x31, 0x62, 0x65, 0x35, 0x30, 0x65, 0x65, 0x61, 0x38, 0x63, 0x32, 0x65, 0x38, 0x62, 0x37, 0x63, 0x33, 0x30, 0x64, 0x34, 0x64, 0x62, 0x65, 0x63, 0x63, 0x33, 0x30, 0x36, 0x38, 0x37, 0x64, 0x66, 0x39, 0x33, 0x65, 0x65, 0x30, 0x38, 0x36, 0x34, 0x32, 0x66, 0x30, 0x64, 0x36, 0x30, 0x37, 0x32, 0x30, 0x37, 0x37, 0x32, 0x35, 0x65, 0x30, 0x64, 0x35, 0x39, 0x62, 0x63, 0x33, 0x62, 0x66, 0x66, 0x64, 0x63, 0x38, 0x62, 0x64, 0x37, 0x31, 0x35, 0x30, 0x34, 0x37, 0x61, 0x64, 0x64, 0x31, 0x65, 0x65, 0x64, 0x65, 0x61, 0x61, 0x63, 0x66, 0x63, 0x37, 0x39, 0x37, 0x30, 0x37, 0x62, 0x61, 0x38, 0x33, 0x64, 0x38, 0x33, 0x32, 0x36, 0x37, 0x38, 0x33, 0x64, 0x39, 0x33, 0x33, 0x62, 0x37, 0x32, 0x33, 0x30, 0x33, 0x36, 0x34, 0x32, 0x61, 0x33, 0x61, 0x66, 0x35, 0x32, 0x63, 0x64, 0x66, 0x37, 0x61, 0x35, 0x37, 0x34, 0x64, 0x61, 0x63, 0x31, 0x33, 0x66, 0x30, 0x37, 0x39, 0x34, 0x39, 0x61, 0x36, 0x34, 0x35, 0x36, 0x63, 0x62, 0x66, 0x62, 0x66, 0x62, 0x63, 0x34, 0x64, 0x62, 0x39, 0x65, 0x34, 0x66, 0x33, 0x39, 0x66, 0x30, 0x62, 0x39, 0x39, 0x31, 0x33, 0x64, 0x37, 0x66, 0x36, 0x63, 0x66, 0x35, 0x65, 0x64, 0x36, 0x33, 0x33, 0x61, 0x36, 0x66, 0x62, 0x36, 0x30, 0x63, 0x31, 0x64, 0x31, 0x34, 0x37, 0x37, 0x35, 0x31, 0x30, 0x31, 0x32, 0x33, 0x32, 0x61, 0x36, 0x66, 0x36, 0x31, 0x30, 0x35, 0x37, 0x64, 0x65, 0x39, 0x30, 0x35, 0x66, 0x37, 0x32, 0x35, 0x63, 0x66, 0x37, 0x64, 0x66, 0x32, 0x36, 0x36, 0x35, 0x62, 0x35, 0x33, 0x30, 0x31, 0x32, 0x63, 0x36, 0x31, 0x37, 0x32, 0x65, 0x66, 0x35, 0x30, 0x37, 0x61, 0x36, 0x65, 0x39, 0x63, 0x62, 0x32, 0x31, 0x39, 0x34, 0x37, 0x64, 0x34, 0x38, 0x61, 0x39, 0x30, 0x38, 0x35, 0x36, 0x38, 0x62, 0x35, 0x36, 0x66, 0x31, 0x30, 0x61, 0x62, 0x64, 0x32, 0x37, 0x65, 0x61, 0x66, 0x31, 0x66, 0x66, 0x38, 0x34, 0x36, 0x65, 0x62, 0x37, 0x61, 0x64, 0x30, 0x35, 0x66, 0x38, 0x35, 0x33, 0x66, 0x38, 0x66, 0x39, 0x65, 0x35, 0x39, 0x65, 0x38, 0x32, 0x62, 0x38, 0x36, 0x35, 0x65, 0x36, 0x32, 0x64, 0x33, 0x35, 0x30, 0x62, 0x30, 0x32, 0x66, 0x62, 0x66, 0x66, 0x66, 0x35, 0x32, 0x64, 0x63, 0x38, 0x36, 0x37, 0x39, 0x65, 0x38, 0x35, 0x36, 0x65, 0x66, 0x65, 0x38, 0x66, 0x32, 0x39, 0x31, 0x66, 0x65, 0x38, 0x37, 0x34, 0x38, 0x35, 0x32, 0x61, 0x35, 0x64, 0x39, 0x37, 0x31, 0x37, 0x63, 0x39, 0x65, 0x66, 0x63, 0x30, 0x31, 0x61, 0x62, 0x31, 0x37, 0x65, 0x61, 0x38, 0x65, 0x62, 0x35, 0x64, 0x31, 0x30, 0x65, 0x38, 0x39, 0x38, 0x37, 0x38, 0x31, 0x33, 0x62, 0x62, 0x34, 0x38, 0x63, 0x64, 0x63, 0x64, 0x38, 0x61, 0x61, 0x31, 0x65, 0x31, 0x63, 0x61, 0x34, 0x34, 0x61, 0x64, 0x36, 0x30, 0x35, 0x39, 0x34, 0x30, 0x39, 0x62, 0x30, 0x31, 0x35, 0x36, 0x63, 0x36, 0x36, 0x62, 0x34, 0x32, 0x35, 0x61, 0x62, 0x30, 0x66, 0x31, 0x34, 0x31, 0x63, 0x30, 0x35, 0x30, 0x61, 0x38, 0x63, 0x32, 0x34, 0x63, 0x31, 0x39, 0x66, 0x35, 0x62, 0x61, 0x39, 0x38, 0x66, 0x39, 0x30, 0x61, 0x32, 0x32, 0x61, 0x39, 0x36, 0x61, 0x61, 0x32, 0x36, 0x36, 0x63, 0x37, 0x34, 0x61, 0x32, 0x36, 0x61, 0x35, 0x35, 0x65, 0x66, 0x32, 0x66, 0x35, 0x31, 0x33, 0x36, 0x65, 0x35, 0x38, 0x35, 0x37, 0x33, 0x36, 0x37, 0x31, 0x65, 0x37, 0x32, 0x62, 0x65, 0x38, 0x34, 0x31, 0x34, 0x65, 0x61, 0x33, 0x32, 0x39, 0x65, 0x62, 0x37, 0x31, 0x64, 0x38, 0x35, 0x34, 0x34, 0x61, 0x66, 0x30, 0x34, 0x34, 0x63, 0x31, 0x63, 0x38, 0x39, 0x66, 0x65, 0x38, 0x64, 0x32, 0x38, 0x37, 0x38, 0x35, 0x38, 0x38, 0x32, 0x35, 0x31, 0x34, 0x33, 0x33, 0x64, 0x65, 0x39, 0x39, 0x66, 0x32, 0x38, 0x32, 0x31, 0x33, 0x35, 0x39, 0x66, 0x38, 0x30, 0x36, 0x65, 0x37, 0x62, 0x36, 0x38, 0x34, 0x35, 0x34, 0x61, 0x34, 0x65, 0x61, 0x66, 0x36, 0x63, 0x61, 0x32, 0x32, 0x37, 0x30, 0x36, 0x39, 0x66, 0x61, 0x38, 0x38, 0x33, 0x30, 0x37, 0x65, 0x35, 0x61, 0x37, 0x61, 0x31, 0x33, 0x30, 0x64, 0x65, 0x66, 0x62, 0x31, 0x62, 0x31, 0x38, 0x31, 0x37, 0x65, 0x66, 0x36, 0x39, 0x36, 0x33, 0x38, 0x62, 0x33, 0x63, 0x36, 0x61, 0x62, 0x33, 0x34, 0x63, 0x34, 0x37, 0x63, 0x34, 0x37, 0x61, 0x30, 0x36, 0x30, 0x38, 0x37, 0x32, 0x33, 0x37, 0x37, 0x62, 0x66, 0x39, 0x34, 0x65, 0x37, 0x65, 0x39, 0x34, 0x61, 0x63, 0x62, 0x64, 0x35, 0x37, 0x61, 0x31, 0x32, 0x34, 0x37, 0x31, 0x32, 0x31, 0x37, 0x37, 0x61, 0x36, 0x30, 0x36, 0x30, 0x63, 0x35, 0x31, 0x62, 0x30, 0x35, 0x62, 0x64, 0x65, 0x31, 0x34, 0x34, 0x33, 0x34, 0x63, 0x30, 0x61, 0x37, 0x65, 0x36, 0x36, 0x38, 0x38, 0x37, 0x30, 0x34, 0x65, 0x36, 0x33, 0x63, 0x63, 0x36, 0x61, 0x38, 0x37, 0x31, 0x34, 0x65, 0x36, 0x31, 0x32, 0x37, 0x62, 0x37, 0x30, 0x33, 0x32, 0x61, 0x38, 0x65, 0x34, 0x64, 0x64, 0x65, 0x63, 0x38, 0x34, 0x61, 0x38, 0x63, 0x62, 0x61, 0x66, 0x64, 0x62, 0x66, 0x36, 0x31, 0x30, 0x30, 0x32, 0x33, 0x65, 0x32, 0x33, 0x32, 0x34, 0x65, 0x61, 0x35, 0x30, 0x34, 0x63, 0x37, 0x32, 0x39, 0x35, 0x32, 0x32, 0x37, 0x66, 0x36, 0x62, 0x33, 0x39, 0x30, 0x61, 0x31, 0x65, 0x34, 0x36, 0x30, 0x61, 0x36, 0x39, 0x61, 0x66, 0x37, 0x63, 0x61, 0x32, 0x36, 0x33, 0x31, 0x64, 0x64, 0x33, 0x63, 0x32, 0x61, 0x64, 0x33, 0x38, 0x32, 0x31, 0x34, 0x31, 0x39, 0x34, 0x63, 0x32, 0x31, 0x30, 0x65, 0x65, 0x64, 0x39, 0x32, 0x38, 0x66, 0x61, 0x65, 0x63, 0x30, 0x63, 0x64, 0x33, 0x31, 0x65, 0x34, 0x33, 0x62, 0x32, 0x35, 0x32, 0x66, 0x32, 0x35, 0x34, 0x63, 0x62, 0x30, 0x35, 0x38, 0x34, 0x37, 0x64, 0x61, 0x61, 0x66, 0x36, 0x36, 0x63, 0x65, 0x33, 0x38, 0x61, 0x61, 0x35, 0x32, 0x34, 0x62, 0x61, 0x61, 0x36, 0x31, 0x33, 0x30, 0x34, 0x32, 0x37, 0x33, 0x34, 0x64, 0x31, 0x30, 0x65, 0x37, 0x62, 0x62, 0x31, 0x33, 0x61, 0x33, 0x34, 0x62, 0x64, 0x61, 0x31, 0x38, 0x34, 0x31, 0x63, 0x39, 0x37, 0x64, 0x30, 0x35, 0x62, 0x30, 0x66, 0x63, 0x38, 0x61, 0x32, 0x34, 0x39, 0x37, 0x64, 0x35, 0x61, 0x62, 0x63, 0x62, 0x32, 0x38, 0x65, 0x38, 0x33, 0x64, 0x31, 0x62, 0x63, 0x30, 0x37, 0x34, 0x63, 0x66, 0x62, 0x34, 0x33, 0x34, 0x66, 0x37, 0x61, 0x33, 0x37, 0x62, 0x64, 0x66, 0x62, 0x39, 0x61, 0x64, 0x34, 0x30, 0x33, 0x32, 0x61, 0x31, 0x64, 0x34, 0x38, 0x33, 0x63, 0x32, 0x65, 0x38, 0x31, 0x31, 0x32, 0x32, 0x39, 0x32, 0x63, 0x66, 0x30, 0x33, 0x30, 0x66, 0x32, 0x31, 0x35, 0x38, 0x62, 0x32, 0x64, 0x36, 0x31, 0x35, 0x32, 0x39, 0x37, 0x63, 0x63, 0x39, 0x38, 0x66, 0x38, 0x38, 0x30, 0x36, 0x65, 0x62, 0x64, 0x64, 0x34, 0x36, 0x63, 0x65, 0x32, 0x63, 0x65, 0x65, 0x65, 0x31, 0x39, 0x39, 0x34, 0x37, 0x61, 0x34, 0x62, 0x31, 0x34, 0x37, 0x62, 0x32, 0x62, 0x32, 0x30, 0x36, 0x36, 0x62, 0x33, 0x62, 0x34, 0x37, 0x66, 0x38, 0x65, 0x36, 0x33, 0x66, 0x61, 0x62, 0x64, 0x38, 0x63, 0x37, 0x33, 0x31, 0x39, 0x33, 0x66, 0x63, 0x37, 0x37, 0x65, 0x30, 0x62, 0x30, 0x65, 0x39, 0x66, 0x31, 0x64, 0x31, 0x34, 0x65, 0x38, 0x30, 0x37, 0x65, 0x32, 0x64, 0x33, 0x63, 0x38, 0x39, 0x64, 0x35, 0x61, 0x64, 0x61, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x63, 0x32, 0x31, 0x36, 0x31, 0x61, 0x36, 0x33, 0x66, 0x37, 0x64, 0x63, 0x62, 0x35, 0x62, 0x64, 0x38, 0x33, 0x61, 0x33, 0x39, 0x36, 0x61, 0x65, 0x64, 0x63, 0x36, 0x34, 0x64, 0x38, 0x62, 0x65, 0x33, 0x34, 0x37, 0x35, 0x66, 0x63, 0x34, 0x31, 0x34, 0x37, 0x32, 0x35, 0x31, 0x31, 0x66, 0x39, 0x66, 0x32, 0x33, 0x34, 0x65, 0x61, 0x30, 0x62, 0x64, 0x66, 0x62, 0x62, 0x31, 0x63, 0x31, 0x35, 0x34, 0x65, 0x37, 0x32, 0x37, 0x36, 0x63, 0x62, 0x61, 0x36, 0x32, 0x37, 0x64, 0x39, 0x33, 0x33, 0x37, 0x65, 0x34, 0x35, 0x62, 0x63, 0x66, 0x34, 0x35, 0x33, 0x64, 0x37, 0x37, 0x31, 0x36, 0x37, 0x34, 0x36, 0x31, 0x61, 0x37, 0x34, 0x33, 0x30, 0x62, 0x61, 0x38, 0x64, 0x63, 0x31, 0x66, 0x36, 0x38, 0x30, 0x61, 0x39, 0x65, 0x38, 0x34, 0x33, 0x37, 0x37, 0x62, 0x62, 0x64, 0x38, 0x32, 0x37, 0x38, 0x33, 0x31, 0x63, 0x35, 0x37, 0x66, 0x35, 0x65, 0x63, 0x62, 0x65, 0x61, 0x61, 0x31, 0x33, 0x39, 0x31, 0x37, 0x31, 0x38, 0x32, 0x66, 0x30, 0x39, 0x66, 0x65, 0x38, 0x33, 0x63, 0x36, 0x34, 0x66, 0x34, 0x66, 0x33, 0x61, 0x38, 0x34, 0x61, 0x62, 0x38, 0x36, 0x38, 0x36, 0x37, 0x35, 0x32, 0x63, 0x33, 0x63, 0x61, 0x65, 0x31, 0x39, 0x30, 0x66, 0x38, 0x66, 0x30, 0x65, 0x66, 0x36, 0x34, 0x32, 0x33, 0x30, 0x65, 0x39, 0x32, 0x32, 0x31, 0x35, 0x62, 0x39, 0x61, 0x65, 0x38, 0x35, 0x32, 0x37, 0x30, 0x34, 0x35, 0x65, 0x33, 0x32, 0x39, 0x66, 0x38, 0x39, 0x63, 0x64, 0x37, 0x32, 0x37, 0x36, 0x36, 0x30, 0x36, 0x65, 0x66, 0x33, 0x30, 0x33, 0x35, 0x65, 0x61, 0x61, 0x61, 0x66, 0x30, 0x31, 0x34, 0x31, 0x32, 0x66, 0x35, 0x32, 0x65, 0x38, 0x35, 0x36, 0x39, 0x37, 0x61, 0x31, 0x31, 0x31, 0x34, 0x36, 0x32, 0x33, 0x36, 0x32, 0x34, 0x34, 0x38, 0x32, 0x39, 0x31, 0x63, 0x66, 0x38, 0x37, 0x30, 0x31, 0x63, 0x61, 0x61, 0x65, 0x35, 0x32, 0x36, 0x39, 0x33, 0x61, 0x66, 0x35, 0x35, 0x31, 0x31, 0x33, 0x39, 0x61, 0x39, 0x61, 0x38, 0x33, 0x31, 0x36, 0x30, 0x31, 0x33, 0x34, 0x30, 0x65, 0x35, 0x32, 0x30, 0x32, 0x65, 0x30, 0x35, 0x31, 0x35, 0x30, 0x62, 0x30, 0x39, 0x64, 0x35, 0x63, 0x33, 0x37, 0x32, 0x30, 0x32, 0x39, 0x35, 0x32, 0x61, 0x61, 0x36, 0x35, 0x36, 0x36, 0x39, 0x37, 0x63, 0x65, 0x32, 0x62, 0x37, 0x32, 0x66, 0x30, 0x37, 0x36, 0x32, 0x35, 0x38, 0x36, 0x31, 0x63, 0x65, 0x37, 0x61, 0x33, 0x30, 0x30, 0x32, 0x39, 0x38, 0x36, 0x32, 0x32, 0x64, 0x66, 0x32, 0x39, 0x61, 0x63, 0x38, 0x64, 0x66, 0x64, 0x66, 0x38, 0x33, 0x65, 0x37, 0x31, 0x61, 0x38, 0x62, 0x63, 0x66, 0x32, 0x34, 0x31, 0x65, 0x64, 0x61, 0x32, 0x39, 0x32, 0x64, 0x66, 0x35, 0x65, 0x38, 0x61, 0x64, 0x66, 0x63, 0x62, 0x66, 0x37, 0x63, 0x61, 0x35, 0x34, 0x63, 0x63, 0x66, 0x32, 0x64, 0x34, 0x62, 0x62, 0x36, 0x37, 0x30, 0x63, 0x63, 0x30, 0x39, 0x63, 0x63, 0x61, 0x62, 0x35, 0x66, 0x39, 0x38, 0x34, 0x65, 0x36, 0x31, 0x34, 0x32, 0x36, 0x34, 0x66, 0x61, 0x64, 0x62, 0x64, 0x31, 0x30, 0x30, 0x37, 0x32, 0x66, 0x61, 0x32, 0x37, 0x66, 0x64, 0x62, 0x30, 0x39, 0x32, 0x65, 0x39, 0x38, 0x39, 0x38, 0x37, 0x65, 0x33, 0x38, 0x38, 0x31, 0x31, 0x30, 0x62, 0x35, 0x33, 0x61, 0x63, 0x36, 0x66, 0x35, 0x33, 0x38, 0x66, 0x38, 0x61, 0x63, 0x34, 0x63, 0x65, 0x65, 0x32, 0x31, 0x33, 0x39, 0x31, 0x37, 0x32, 0x35, 0x33, 0x62, 0x65, 0x62, 0x64, 0x36, 0x61, 0x66, 0x32, 0x37, 0x32, 0x36, 0x37, 0x37, 0x32, 0x63, 0x38, 0x32, 0x35, 0x63, 0x62, 0x66, 0x33, 0x36, 0x33, 0x35, 0x31, 0x31, 0x34, 0x65, 0x33, 0x61, 0x38, 0x65, 0x35, 0x39, 0x31, 0x66, 0x35, 0x61, 0x30, 0x65, 0x31, 0x64, 0x30, 0x32, 0x63, 0x65, 0x38, 0x62, 0x61, 0x62, 0x62, 0x33, 0x64, 0x33, 0x33, 0x33, 0x37, 0x62, 0x30, 0x37, 0x32, 0x33, 0x64, 0x31, 0x63, 0x31, 0x62, 0x64, 0x65, 0x37, 0x39, 0x62, 0x63, 0x33, 0x30, 0x35, 0x66, 0x30, 0x65, 0x33, 0x61, 0x35, 0x30, 0x63, 0x31, 0x33, 0x37, 0x62, 0x65, 0x61, 0x38, 0x66, 0x33, 0x66, 0x64, 0x37, 0x61, 0x36, 0x63, 0x31, 0x37, 0x65, 0x64, 0x61, 0x32, 0x38, 0x37, 0x65, 0x31, 0x65, 0x30, 0x34, 0x65, 0x34, 0x33, 0x30, 0x35, 0x30, 0x30, 0x38, 0x35, 0x63, 0x32, 0x62, 0x30, 0x61, 0x35, 0x36, 0x38, 0x34, 0x61, 0x38, 0x32, 0x38, 0x32, 0x66, 0x64, 0x37, 0x61, 0x37, 0x32, 0x66, 0x62, 0x39, 0x30, 0x66, 0x63, 0x39, 0x37, 0x35, 0x33, 0x35, 0x34, 0x37, 0x38, 0x62, 0x39, 0x30, 0x37, 0x33, 0x63, 0x65, 0x66, 0x38, 0x62, 0x65, 0x64, 0x38, 0x34, 0x34, 0x39, 0x64, 0x32, 0x66, 0x61, 0x31, 0x38, 0x30, 0x33, 0x36, 0x64, 0x34, 0x62, 0x31, 0x66, 0x39, 0x63, 0x36, 0x65, 0x34, 0x31, 0x63, 0x39, 0x62, 0x64, 0x34, 0x39, 0x63, 0x65, 0x66, 0x31, 0x31, 0x65, 0x37, 0x32, 0x64, 0x30, 0x66, 0x33, 0x33, 0x35, 0x65, 0x61, 0x63, 0x64, 0x37, 0x36, 0x32, 0x33, 0x34, 0x37, 0x64, 0x32, 0x38, 0x35, 0x38, 0x37, 0x35, 0x30, 0x39, 0x31, 0x34, 0x35, 0x31, 0x31, 0x39, 0x32, 0x33, 0x32, 0x39, 0x65, 0x66, 0x35, 0x38, 0x36, 0x64, 0x33, 0x39, 0x38, 0x62, 0x35, 0x62, 0x33, 0x62, 0x30, 0x34, 0x35, 0x61, 0x35, 0x64, 0x38, 0x65, 0x62, 0x39, 0x37, 0x36, 0x30, 0x37, 0x32, 0x38, 0x38, 0x62, 0x39, 0x64, 0x61, 0x36, 0x62, 0x62, 0x64, 0x32, 0x62, 0x30, 0x36, 0x62, 0x37, 0x61, 0x38, 0x39, 0x38, 0x61, 0x39, 0x36, 0x39, 0x34, 0x38, 0x64, 0x30, 0x34, 0x38, 0x36, 0x31, 0x31, 0x66, 0x66, 0x30, 0x35, 0x38, 0x61, 0x62, 0x62, 0x62, 0x37, 0x62, 0x38, 0x32, 0x30, 0x62, 0x37, 0x36, 0x65, 0x65, 0x38, 0x31, 0x65, 0x34, 0x61, 0x62, 0x38, 0x35, 0x36, 0x65, 0x37, 0x32, 0x62, 0x62, 0x63, 0x63, 0x31, 0x61, 0x64, 0x61, 0x61, 0x39, 0x66, 0x38, 0x36, 0x32, 0x63, 0x34, 0x62, 0x62, 0x61, 0x63, 0x30, 0x65, 0x37, 0x61, 0x31, 0x37, 0x36, 0x61, 0x34, 0x37, 0x65, 0x64, 0x39, 0x36, 0x37, 0x64, 0x63, 0x37, 0x33, 0x33, 0x65, 0x32, 0x64, 0x62, 0x37, 0x34, 0x33, 0x37, 0x66, 0x36, 0x66, 0x35, 0x61, 0x35, 0x63, 0x62, 0x62, 0x30, 0x34, 0x37, 0x30, 0x37, 0x37, 0x32, 0x62, 0x66, 0x36, 0x63, 0x36, 0x31, 0x31, 0x32, 0x30, 0x39, 0x61, 0x34, 0x30, 0x61, 0x39, 0x32, 0x65, 0x64, 0x30, 0x65, 0x30, 0x38, 0x36, 0x36, 0x32, 0x34, 0x64, 0x66, 0x64, 0x32, 0x66, 0x31, 0x36, 0x36, 0x36, 0x64, 0x35, 0x34, 0x39, 0x36, 0x35, 0x61, 0x64, 0x30, 0x62, 0x36, 0x31, 0x61, 0x61, 0x64, 0x36, 0x31, 0x34, 0x32, 0x62, 0x32, 0x34, 0x36, 0x38, 0x65, 0x33, 0x65, 0x34, 0x66, 0x32, 0x30, 0x61, 0x30, 0x37, 0x34, 0x66, 0x36, 0x34, 0x31, 0x35, 0x33, 0x38, 0x64, 0x37, 0x34, 0x62, 0x64, 0x35, 0x61, 0x34, 0x65, 0x63, 0x66, 0x61, 0x66, 0x66, 0x64, 0x33, 0x66, 0x63, 0x65, 0x37, 0x64, 0x66, 0x34, 0x33, 0x38, 0x62, 0x66, 0x62, 0x37, 0x39, 0x37, 0x62, 0x62, 0x39, 0x34, 0x65, 0x32, 0x35, 0x61, 0x30, 0x32, 0x39, 0x66, 0x33, 0x39, 0x39, 0x62, 0x30, 0x36, 0x37, 0x32, 0x37, 0x36, 0x30, 0x30, 0x65, 0x63, 0x32, 0x33, 0x36, 0x32, 0x63, 0x32, 0x66, 0x38, 0x65, 0x31, 0x64, 0x35, 0x64, 0x35, 0x63, 0x31, 0x66, 0x30, 0x63, 0x37, 0x34, 0x61, 0x61, 0x63, 0x38, 0x62, 0x64, 0x34, 0x36, 0x61, 0x31, 0x33, 0x38, 0x63, 0x64, 0x34, 0x64, 0x66, 0x32, 0x31, 0x37, 0x34, 0x33, 0x63, 0x37, 0x39, 0x63, 0x63, 0x36, 0x34, 0x63, 0x37, 0x64, 0x65, 0x32, 0x64, 0x37, 0x32, 0x65, 0x38, 0x64, 0x34, 0x62, 0x35, 0x38, 0x30, 0x62, 0x31, 0x33, 0x36, 0x37, 0x63, 0x33, 0x64, 0x37, 0x35, 0x39, 0x63, 0x31, 0x32, 0x33, 0x64, 0x61, 0x61, 0x39, 0x63, 0x61, 0x66, 0x37, 0x37, 0x65, 0x32, 0x64, 0x38, 0x66, 0x31, 0x63, 0x66, 0x39, 0x64, 0x63, 0x62, 0x32, 0x35, 0x30, 0x66, 0x36, 0x65, 0x34, 0x61, 0x66, 0x31, 0x36, 0x35, 0x32, 0x62, 0x36, 0x65, 0x35, 0x65, 0x33, 0x36, 0x33, 0x39, 0x36, 0x64, 0x33, 0x64, 0x35, 0x64, 0x62, 0x30, 0x31, 0x66, 0x35, 0x66, 0x34, 0x37, 0x36, 0x63, 0x31, 0x33, 0x31, 0x38, 0x64, 0x37, 0x61, 0x39, 0x37, 0x65, 0x35, 0x62, 0x35, 0x39, 0x31, 0x65, 0x34, 0x63, 0x64, 0x37, 0x30, 0x39, 0x63, 0x62, 0x34, 0x31, 0x32, 0x65, 0x31, 0x33, 0x66, 0x32, 0x34, 0x31, 0x64, 0x33, 0x35, 0x33, 0x61, 0x37, 0x39, 0x35, 0x61, 0x61, 0x31, 0x66, 0x37, 0x33, 0x38, 0x39, 0x33, 0x64, 0x35, 0x33, 0x64, 0x39, 0x66, 0x37, 0x61, 0x64, 0x35, 0x33, 0x38, 0x35, 0x34, 0x34, 0x30, 0x32, 0x31, 0x62, 0x35, 0x37, 0x31, 0x38, 0x39, 0x65, 0x33, 0x33, 0x30, 0x30, 0x32, 0x64, 0x30, 0x65, 0x63, 0x35, 0x34, 0x64, 0x33, 0x37, 0x66, 0x35, 0x37, 0x63, 0x37, 0x31, 0x36, 0x65, 0x64, 0x38, 0x33, 0x64, 0x34, 0x63, 0x64, 0x35, 0x33, 0x31, 0x37, 0x32, 0x39, 0x33, 0x32, 0x35, 0x37, 0x35, 0x31, 0x37, 0x37, 0x39, 0x39, 0x61, 0x64, 0x31, 0x35, 0x32, 0x62, 0x34, 0x32, 0x64, 0x61, 0x34, 0x32, 0x38, 0x61, 0x36, 0x64, 0x62, 0x62, 0x65, 0x65, 0x35, 0x61, 0x33, 0x34, 0x34, 0x34, 0x32, 0x33, 0x33, 0x30, 0x31, 0x34, 0x33, 0x66, 0x63, 0x38, 0x38, 0x37, 0x63, 0x30, 0x32, 0x62, 0x30, 0x65, 0x39, 0x39, 0x37, 0x39, 0x30, 0x31, 0x63, 0x37, 0x32, 0x32, 0x39, 0x63, 0x38, 0x39, 0x32, 0x66, 0x39, 0x36, 0x30, 0x64, 0x37, 0x64, 0x34, 0x61, 0x31, 0x37, 0x36, 0x34, 0x61, 0x62, 0x65, 0x61, 0x37, 0x39, 0x32, 0x37, 0x62, 0x66, 0x37, 0x32, 0x61, 0x38, 0x30, 0x38, 0x63, 0x33, 0x37, 0x37, 0x34, 0x64, 0x32, 0x36, 0x33, 0x62, 0x64, 0x36, 0x37, 0x36, 0x36, 0x34, 0x65, 0x39, 0x62, 0x31, 0x33, 0x39, 0x39, 0x30, 0x32, 0x39, 0x38, 0x37, 0x32, 0x32, 0x37, 0x33, 0x34, 0x33, 0x62, 0x61, 0x36, 0x36, 0x31, 0x31, 0x66, 0x63, 0x63, 0x63, 0x38, 0x32, 0x31, 0x32, 0x38, 0x31, 0x32, 0x37, 0x63, 0x39, 0x31, 0x36, 0x38, 0x39, 0x65, 0x39, 0x35, 0x33, 0x65, 0x65, 0x36, 0x62, 0x65, 0x31, 0x36, 0x32, 0x39, 0x37, 0x33, 0x37, 0x64, 0x61, 0x35, 0x66, 0x31, 0x64, 0x64, 0x61, 0x62, 0x64, 0x64, 0x34, 0x34, 0x38, 0x64, 0x63, 0x66, 0x37, 0x32, 0x36, 0x34, 0x63, 0x31, 0x38, 0x65, 0x62, 0x39, 0x35, 0x64, 0x37, 0x31, 0x31, 0x64, 0x34, 0x64, 0x34, 0x66, 0x37, 0x31, 0x62, 0x36, 0x64, 0x61, 0x65, 0x62, 0x37, 0x36, 0x35, 0x65, 0x63, 0x63, 0x65, 0x39, 0x63, 0x36, 0x30, 0x62, 0x61, 0x32, 0x38, 0x62, 0x32, 0x39, 0x66, 0x34, 0x34, 0x66, 0x37, 0x34, 0x65, 0x36, 0x30, 0x30, 0x65, 0x63, 0x31, 0x64, 0x35, 0x32, 0x30, 0x39, 0x32, 0x35, 0x39, 0x38, 0x64, 0x34, 0x33, 0x64, 0x32, 0x37, 0x32, 0x34, 0x64, 0x30, 0x34, 0x61, 0x32, 0x32, 0x31, 0x63, 0x37, 0x63, 0x61, 0x30, 0x31, 0x35, 0x39, 0x31, 0x30, 0x34, 0x33, 0x38, 0x33, 0x64, 0x61, 0x32, 0x64, 0x65, 0x37, 0x34, 0x36, 0x61, 0x37, 0x30, 0x30, 0x36, 0x30, 0x32, 0x33, 0x62, 0x35, 0x33, 0x37, 0x32, 0x36, 0x30, 0x34, 0x39, 0x30, 0x66, 0x62, 0x30, 0x63, 0x36, 0x37, 0x32, 0x63, 0x30, 0x36, 0x66, 0x38, 0x37, 0x32, 0x31, 0x39, 0x32, 0x65, 0x62, 0x34, 0x65, 0x64, 0x31, 0x38, 0x63, 0x62, 0x39, 0x33, 0x30, 0x32, 0x35, 0x62, 0x39, 0x61, 0x31, 0x31, 0x66, 0x63, 0x32, 0x33, 0x64, 0x39, 0x30, 0x37, 0x66, 0x37, 0x63, 0x61, 0x66, 0x62, 0x39, 0x61, 0x37, 0x65, 0x65, 0x62, 0x39, 0x63, 0x31, 0x32, 0x31, 0x35, 0x62, 0x37, 0x36, 0x37, 0x66, 0x65, 0x62, 0x33, 0x33, 0x64, 0x62, 0x66, 0x32, 0x33, 0x32, 0x37, 0x38, 0x62, 0x39, 0x61, 0x61, 0x61, 0x30, 0x30, 0x32, 0x35, 0x30, 0x37, 0x32, 0x31, 0x35, 0x31, 0x62, 0x63, 0x63, 0x63, 0x31, 0x62, 0x38, 0x34, 0x66, 0x36, 0x61, 0x34, 0x32, 0x35, 0x34, 0x38, 0x31, 0x38, 0x62, 0x38, 0x34, 0x35, 0x35, 0x37, 0x30, 0x39, 0x38, 0x31, 0x31, 0x64, 0x38, 0x39, 0x61, 0x63, 0x35, 0x66, 0x62, 0x34, 0x65, 0x35, 0x32, 0x32, 0x63, 0x64, 0x63, 0x30, 0x65, 0x34, 0x37, 0x64, 0x31, 0x31, 0x64, 0x35, 0x37, 0x35, 0x63, 0x66, 0x33, 0x38, 0x37, 0x35, 0x65, 0x65, 0x36, 0x65, 0x30, 0x61, 0x31, 0x64, 0x38, 0x33, 0x37, 0x39, 0x31, 0x35, 0x33, 0x38, 0x30, 0x65, 0x62, 0x66, 0x31, 0x62, 0x37, 0x62, 0x38, 0x62, 0x61, 0x34, 0x38, 0x64, 0x66, 0x36, 0x66, 0x64, 0x61, 0x63, 0x35, 0x38, 0x64, 0x39, 0x37, 0x37, 0x32, 0x63, 0x32, 0x38, 0x66, 0x64, 0x36, 0x33, 0x31, 0x39, 0x33, 0x65, 0x34, 0x64, 0x62, 0x35, 0x65, 0x30, 0x62, 0x37, 0x31, 0x33, 0x36, 0x35, 0x31, 0x32, 0x38, 0x37, 0x37, 0x31, 0x33, 0x37, 0x66, 0x38, 0x33, 0x30, 0x35, 0x31, 0x61, 0x31, 0x66, 0x38, 0x66, 0x33, 0x65, 0x39, 0x61, 0x65, 0x30, 0x37, 0x33, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x65, 0x63, 0x63, 0x32, 0x37, 0x32, 0x34, 0x63, 0x65, 0x61, 0x62, 0x33, 0x33, 0x38, 0x37, 0x63, 0x66, 0x61, 0x65, 0x62, 0x39, 0x34, 0x33, 0x37, 0x65, 0x34, 0x36, 0x31, 0x36, 0x33, 0x31, 0x63, 0x37, 0x61, 0x65, 0x63, 0x32, 0x35, 0x38, 0x33, 0x64, 0x39, 0x30, 0x63, 0x36, 0x33, 0x65, 0x30, 0x62, 0x35, 0x62, 0x33, 0x33, 0x35, 0x33, 0x31, 0x65, 0x30, 0x65, 0x33, 0x32, 0x66, 0x33, 0x39, 0x38, 0x36, 0x35, 0x36, 0x37, 0x30, 0x62, 0x36, 0x33, 0x65, 0x30, 0x61, 0x36, 0x37, 0x30, 0x63, 0x33, 0x34, 0x61, 0x31, 0x64, 0x63, 0x64, 0x63, 0x63, 0x30, 0x35, 0x32, 0x38, 0x38, 0x36, 0x62, 0x34, 0x39, 0x34, 0x66, 0x63, 0x65, 0x63, 0x35, 0x30, 0x39, 0x33, 0x31, 0x63, 0x63, 0x34, 0x33, 0x33, 0x30, 0x34, 0x39, 0x64, 0x32, 0x64, 0x32, 0x38, 0x32, 0x63, 0x36, 0x34, 0x65, 0x31, 0x39, 0x35, 0x39, 0x32, 0x31, 0x37, 0x32, 0x38, 0x64, 0x65, 0x66, 0x37, 0x65, 0x36, 0x30, 0x62, 0x31, 0x62, 0x62, 0x33, 0x38, 0x33, 0x31, 0x32, 0x66, 0x63, 0x63, 0x30, 0x66, 0x61, 0x38, 0x35, 0x65, 0x31, 0x62, 0x39, 0x65, 0x35, 0x30, 0x65, 0x64, 0x65, 0x31, 0x34, 0x34, 0x34, 0x37, 0x31, 0x33, 0x31, 0x38, 0x38, 0x65, 0x38, 0x34, 0x30, 0x64, 0x37, 0x32, 0x65, 0x66, 0x31, 0x31, 0x30, 0x64, 0x62, 0x37, 0x62, 0x36, 0x37, 0x32, 0x37, 0x63, 0x38, 0x61, 0x37, 0x38, 0x33, 0x36, 0x31, 0x31, 0x33, 0x38, 0x35, 0x63, 0x32, 0x63, 0x66, 0x64, 0x36, 0x35, 0x63, 0x34, 0x37, 0x36, 0x39, 0x38, 0x31, 0x38, 0x61, 0x64, 0x38, 0x37, 0x37, 0x61, 0x35, 0x30, 0x63, 0x37, 0x35, 0x66, 0x30, 0x36, 0x65, 0x62, 0x33, 0x66, 0x37, 0x61, 0x37, 0x62, 0x34, 0x34, 0x34, 0x61, 0x30, 0x34, 0x66, 0x39, 0x34, 0x36, 0x31, 0x37, 0x37, 0x32, 0x31, 0x34, 0x64, 0x36, 0x65, 0x62, 0x39, 0x30, 0x32, 0x36, 0x65, 0x33, 0x66, 0x33, 0x32, 0x36, 0x31, 0x35, 0x34, 0x35, 0x31, 0x34, 0x31, 0x34, 0x35, 0x63, 0x31, 0x65, 0x37, 0x65, 0x64, 0x34, 0x65, 0x64, 0x33, 0x31, 0x63, 0x65, 0x33, 0x65, 0x64, 0x39, 0x62, 0x32, 0x66, 0x64, 0x65, 0x39, 0x62, 0x37, 0x63, 0x38, 0x36, 0x37, 0x35, 0x31, 0x39, 0x36, 0x66, 0x39, 0x30, 0x65, 0x37, 0x32, 0x65, 0x62, 0x34, 0x35, 0x33, 0x61, 0x37, 0x36, 0x34, 0x64, 0x30, 0x31, 0x39, 0x37, 0x37, 0x63, 0x36, 0x30, 0x32, 0x64, 0x34, 0x64, 0x30, 0x64, 0x64, 0x33, 0x39, 0x37, 0x30, 0x32, 0x31, 0x34, 0x62, 0x35, 0x39, 0x62, 0x34, 0x38, 0x66, 0x34, 0x62, 0x64, 0x31, 0x38, 0x30, 0x35, 0x37, 0x64, 0x38, 0x36, 0x37, 0x30, 0x36, 0x35, 0x62, 0x33, 0x39, 0x64, 0x61, 0x31, 0x39, 0x32, 0x37, 0x32, 0x35, 0x61, 0x37, 0x61, 0x63, 0x61, 0x30, 0x31, 0x30, 0x66, 0x63, 0x63, 0x65, 0x34, 0x63, 0x32, 0x37, 0x62, 0x34, 0x62, 0x66, 0x39, 0x33, 0x31, 0x61, 0x37, 0x65, 0x64, 0x30, 0x30, 0x30, 0x39, 0x33, 0x30, 0x61, 0x30, 0x63, 0x35, 0x37, 0x61, 0x33, 0x61, 0x62, 0x66, 0x36, 0x35, 0x36, 0x38, 0x37, 0x30, 0x30, 0x35, 0x64, 0x38, 0x36, 0x36, 0x32, 0x30, 0x65, 0x34, 0x30, 0x63, 0x37, 0x32, 0x37, 0x31, 0x36, 0x62, 0x32, 0x66, 0x63, 0x35, 0x34, 0x64, 0x33, 0x36, 0x37, 0x35, 0x31, 0x34, 0x64, 0x66, 0x39, 0x66, 0x38, 0x38, 0x31, 0x35, 0x39, 0x64, 0x63, 0x64, 0x33, 0x30, 0x32, 0x64, 0x32, 0x62, 0x34, 0x31, 0x32, 0x32, 0x38, 0x65, 0x63, 0x30, 0x66, 0x37, 0x31, 0x61, 0x64, 0x36, 0x35, 0x39, 0x61, 0x62, 0x35, 0x36, 0x63, 0x36, 0x35, 0x64, 0x31, 0x66, 0x36, 0x39, 0x37, 0x32, 0x33, 0x33, 0x31, 0x38, 0x61, 0x31, 0x63, 0x39, 0x64, 0x66, 0x30, 0x65, 0x32, 0x37, 0x65, 0x38, 0x62, 0x36, 0x34, 0x39, 0x66, 0x64, 0x35, 0x62, 0x63, 0x37, 0x37, 0x30, 0x31, 0x65, 0x39, 0x34, 0x66, 0x35, 0x34, 0x34, 0x33, 0x38, 0x35, 0x32, 0x38, 0x65, 0x35, 0x36, 0x63, 0x65, 0x64, 0x65, 0x65, 0x66, 0x32, 0x34, 0x37, 0x31, 0x66, 0x31, 0x63, 0x31, 0x62, 0x35, 0x66, 0x31, 0x30, 0x61, 0x35, 0x34, 0x30, 0x61, 0x32, 0x62, 0x38, 0x34, 0x30, 0x30, 0x37, 0x31, 0x35, 0x30, 0x66, 0x30, 0x31, 0x37, 0x38, 0x38, 0x63, 0x61, 0x37, 0x38, 0x65, 0x63, 0x62, 0x64, 0x39, 0x62, 0x64, 0x64, 0x62, 0x64, 0x38, 0x32, 0x31, 0x34, 0x35, 0x31, 0x39, 0x37, 0x62, 0x36, 0x32, 0x63, 0x30, 0x31, 0x30, 0x31, 0x39, 0x38, 0x39, 0x38, 0x31, 0x64, 0x65, 0x32, 0x66, 0x31, 0x30, 0x30, 0x37, 0x32, 0x35, 0x61, 0x65, 0x62, 0x34, 0x38, 0x30, 0x65, 0x36, 0x65, 0x30, 0x61, 0x36, 0x61, 0x38, 0x36, 0x33, 0x66, 0x30, 0x65, 0x34, 0x39, 0x35, 0x38, 0x39, 0x36, 0x61, 0x33, 0x32, 0x32, 0x30, 0x66, 0x34, 0x66, 0x62, 0x35, 0x62, 0x30, 0x65, 0x34, 0x64, 0x65, 0x39, 0x38, 0x36, 0x31, 0x63, 0x64, 0x64, 0x39, 0x33, 0x37, 0x38, 0x36, 0x39, 0x32, 0x30, 0x63, 0x39, 0x65, 0x32, 0x35, 0x33, 0x32, 0x38, 0x38, 0x35, 0x33, 0x37, 0x37, 0x37, 0x30, 0x34, 0x37, 0x66, 0x38, 0x62, 0x31, 0x37, 0x64, 0x62, 0x39, 0x32, 0x65, 0x34, 0x33, 0x32, 0x39, 0x34, 0x31, 0x65, 0x66, 0x63, 0x35, 0x35, 0x38, 0x31, 0x38, 0x66, 0x35, 0x34, 0x32, 0x62, 0x35, 0x39, 0x37, 0x34, 0x64, 0x31, 0x63, 0x65, 0x64, 0x32, 0x37, 0x62, 0x36, 0x39, 0x65, 0x30, 0x63, 0x34, 0x30, 0x61, 0x66, 0x35, 0x35, 0x37, 0x32, 0x38, 0x63, 0x31, 0x66, 0x32, 0x30, 0x61, 0x37, 0x39, 0x38, 0x66, 0x65, 0x32, 0x66, 0x30, 0x37, 0x32, 0x36, 0x36, 0x39, 0x65, 0x39, 0x30, 0x64, 0x34, 0x38, 0x62, 0x39, 0x36, 0x30, 0x31, 0x66, 0x35, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, 0x64, 0x33, 0x64, 0x38, 0x38, 0x61, 0x61, 0x62, 0x64, 0x30, 0x35, 0x36, 0x38, 0x63, 0x65, 0x34, 0x34, 0x39, 0x37, 0x37, 0x65, 0x61, 0x61, 0x34, 0x66, 0x33, 0x31, 0x33, 0x38, 0x31, 0x65, 0x65, 0x30, 0x39, 0x63, 0x65, 0x33, 0x65, 0x62, 0x66, 0x65, 0x32, 0x32, 0x36, 0x65, 0x37, 0x30, 0x30, 0x39, 0x62, 0x65, 0x31, 0x39, 0x39, 0x30, 0x35, 0x64, 0x61, 0x32, 0x63, 0x34, 0x32, 0x66, 0x61, 0x66, 0x66, 0x38, 0x62, 0x33, 0x63, 0x34, 0x33, 0x38, 0x64, 0x37, 0x39, 0x32, 0x61, 0x34, 0x38, 0x37, 0x63, 0x30, 0x36, 0x39, 0x38, 0x31, 0x37, 0x32, 0x39, 0x66, 0x65, 0x61, 0x63, 0x38, 0x38, 0x30, 0x39, 0x63, 0x31, 0x65, 0x30, 0x34, 0x62, 0x38, 0x32, 0x64, 0x64, 0x65, 0x36, 0x38, 0x38, 0x36, 0x39, 0x62, 0x35, 0x33, 0x65, 0x63, 0x35, 0x32, 0x63, 0x31, 0x30, 0x30, 0x31, 0x39, 0x66, 0x32, 0x31, 0x32, 0x37, 0x63, 0x33, 0x35, 0x33, 0x33, 0x62, 0x38, 0x61, 0x39, 0x38, 0x37, 0x37, 0x35, 0x65, 0x62, 0x63, 0x32, 0x65, 0x62, 0x37, 0x32, 0x64, 0x38, 0x65, 0x38, 0x32, 0x64, 0x65, 0x36, 0x65, 0x35, 0x62, 0x33, 0x63, 0x32, 0x39, 0x36, 0x33, 0x32, 0x33, 0x31, 0x38, 0x34, 0x36, 0x39, 0x61, 0x38, 0x39, 0x62, 0x64, 0x35, 0x39, 0x66, 0x38, 0x37, 0x31, 0x63, 0x31, 0x36, 0x34, 0x66, 0x30, 0x39, 0x66, 0x39, 0x33, 0x36, 0x66, 0x39, 0x31, 0x35, 0x32, 0x38, 0x30, 0x39, 0x37, 0x63, 0x39, 0x30, 0x32, 0x61, 0x62, 0x34, 0x34, 0x38, 0x64, 0x66, 0x39, 0x32, 0x36, 0x62, 0x30, 0x66, 0x35, 0x62, 0x65, 0x36, 0x35, 0x61, 0x35, 0x36, 0x31, 0x35, 0x32, 0x62, 0x33, 0x38, 0x65, 0x66, 0x33, 0x61, 0x63, 0x36, 0x66, 0x31, 0x33, 0x64, 0x35, 0x62, 0x62, 0x65, 0x39, 0x39, 0x61, 0x38, 0x64, 0x35, 0x30, 0x38, 0x39, 0x38, 0x37, 0x61, 0x62, 0x38, 0x39, 0x39, 0x36, 0x35, 0x31, 0x39, 0x32, 0x37, 0x32, 0x63, 0x30, 0x32, 0x32, 0x66, 0x63, 0x33, 0x30, 0x62, 0x30, 0x35, 0x64, 0x63, 0x31, 0x32, 0x38, 0x62, 0x30, 0x64, 0x37, 0x38, 0x62, 0x34, 0x38, 0x36, 0x31, 0x35, 0x65, 0x64, 0x64, 0x30, 0x35, 0x64, 0x66, 0x63, 0x35, 0x39, 0x39, 0x66, 0x35, 0x37, 0x35, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x63, 0x38, 0x66, 0x66, 0x34, 0x39, 0x62, 0x66, 0x37, 0x66, 0x35, 0x35, 0x66, 0x63, 0x39, 0x63, 0x36, 0x39, 0x32, 0x37, 0x32, 0x33, 0x35, 0x64, 0x37, 0x61, 0x34, 0x34, 0x37, 0x35, 0x30, 0x34, 0x61, 0x38, 0x30, 0x30, 0x35, 0x38, 0x62, 0x33, 0x35, 0x30, 0x64, 0x66, 0x37, 0x30, 0x61, 0x38, 0x66, 0x35, 0x63, 0x31, 0x31, 0x62, 0x32, 0x39, 0x30, 0x66, 0x36, 0x36, 0x30, 0x30, 0x38, 0x33, 0x33, 0x30, 0x62, 0x36, 0x39, 0x30, 0x37, 0x35, 0x38, 0x36, 0x39, 0x61, 0x37, 0x34, 0x38, 0x38, 0x64, 0x31, 0x66, 0x30, 0x30, 0x32, 0x63, 0x39, 0x64, 0x65, 0x65, 0x37, 0x30, 0x32, 0x35, 0x31, 0x30, 0x33, 0x37, 0x61, 0x61, 0x38, 0x39, 0x39, 0x62, 0x33, 0x36, 0x63, 0x64, 0x66, 0x38, 0x39, 0x62, 0x66, 0x61, 0x39, 0x32, 0x35, 0x34, 0x39, 0x31, 0x36, 0x39, 0x61, 0x39, 0x33, 0x62, 0x31, 0x62, 0x65, 0x32, 0x64, 0x61, 0x35, 0x30, 0x62, 0x31, 0x30, 0x39, 0x36, 0x31, 0x66, 0x32, 0x65, 0x65, 0x62, 0x39, 0x37, 0x32, 0x62, 0x31, 0x33, 0x38, 0x64, 0x39, 0x66, 0x66, 0x32, 0x36, 0x61, 0x31, 0x30, 0x66, 0x64, 0x32, 0x61, 0x32, 0x66, 0x66, 0x64, 0x61, 0x34, 0x61, 0x33, 0x61, 0x62, 0x33, 0x34, 0x63, 0x35, 0x35, 0x36, 0x33, 0x33, 0x65, 0x35, 0x32, 0x34, 0x33, 0x62, 0x66, 0x35, 0x61, 0x66, 0x30, 0x31, 0x32, 0x37, 0x64, 0x34, 0x35, 0x66, 0x61, 0x38, 0x34, 0x35, 0x39, 0x61, 0x61, 0x31, 0x62, 0x37, 0x32, 0x33, 0x31, 0x64, 0x66, 0x32, 0x32, 0x31, 0x30, 0x35, 0x61, 0x65, 0x33, 0x64, 0x35, 0x37, 0x38, 0x31, 0x34, 0x33, 0x37, 0x32, 0x30, 0x36, 0x39, 0x66, 0x36, 0x61, 0x30, 0x38, 0x30, 0x32, 0x31, 0x38, 0x65, 0x31, 0x66, 0x35, 0x62, 0x62, 0x39, 0x35, 0x33, 0x30, 0x32, 0x38, 0x36, 0x33, 0x31, 0x37, 0x38, 0x32, 0x65, 0x63, 0x35, 0x34, 0x65, 0x34, 0x38, 0x66, 0x37, 0x37, 0x34, 0x37, 0x32, 0x37, 0x61, 0x64, 0x63, 0x62, 0x38, 0x34, 0x31, 0x37, 0x38, 0x65, 0x39, 0x62, 0x34, 0x65, 0x31, 0x31, 0x34, 0x64, 0x34, 0x64, 0x37, 0x32, 0x35, 0x62, 0x62, 0x38, 0x62, 0x63, 0x64, 0x61, 0x37, 0x31, 0x35, 0x32, 0x64, 0x30, 0x34, 0x64, 0x31, 0x66, 0x39, 0x33, 0x63, 0x38, 0x36, 0x31, 0x37, 0x39, 0x31, 0x34, 0x33, 0x61, 0x34, 0x63, 0x32, 0x32, 0x65, 0x39, 0x65, 0x32, 0x61, 0x37, 0x32, 0x30, 0x36, 0x66, 0x32, 0x66, 0x30, 0x35, 0x66, 0x35, 0x34, 0x61, 0x31, 0x65, 0x62, 0x36, 0x34, 0x66, 0x31, 0x36, 0x38, 0x32, 0x32, 0x35, 0x31, 0x65, 0x39, 0x63, 0x63, 0x64, 0x34, 0x30, 0x38, 0x37, 0x66, 0x64, 0x30, 0x38, 0x66, 0x63, 0x32, 0x39, 0x31, 0x38, 0x34, 0x36, 0x32, 0x34, 0x36, 0x39, 0x61, 0x33, 0x30, 0x63, 0x36, 0x33, 0x31, 0x33, 0x36, 0x36, 0x30, 0x34, 0x39, 0x37, 0x32, 0x37, 0x35, 0x39, 0x32, 0x63, 0x34, 0x39, 0x34, 0x65, 0x35, 0x62, 0x63, 0x64, 0x62, 0x32, 0x31, 0x32, 0x34, 0x35, 0x63, 0x64, 0x64, 0x66, 0x37, 0x64, 0x65, 0x39, 0x62, 0x30, 0x61, 0x30, 0x62, 0x32, 0x66, 0x61, 0x37, 0x34, 0x35, 0x31, 0x30, 0x38, 0x30, 0x65, 0x37, 0x64, 0x65, 0x39, 0x37, 0x32, 0x34, 0x61, 0x34, 0x64, 0x65, 0x64, 0x36, 0x37, 0x37, 0x30, 0x37, 0x38, 0x62, 0x37, 0x32, 0x39, 0x36, 0x33, 0x30, 0x39, 0x63, 0x35, 0x34, 0x35, 0x39, 0x30, 0x31, 0x65, 0x66, 0x64, 0x33, 0x64, 0x38, 0x37, 0x38, 0x66, 0x33, 0x35, 0x33, 0x33, 0x66, 0x38, 0x37, 0x31, 0x33, 0x38, 0x36, 0x39, 0x39, 0x36, 0x30, 0x62, 0x31, 0x34, 0x30, 0x61, 0x32, 0x66, 0x65, 0x62, 0x61, 0x31, 0x61, 0x65, 0x35, 0x65, 0x39, 0x64, 0x30, 0x64, 0x62, 0x35, 0x33, 0x37, 0x38, 0x35, 0x33, 0x37, 0x32, 0x30, 0x39, 0x63, 0x63, 0x31, 0x37, 0x35, 0x31, 0x36, 0x66, 0x61, 0x32, 0x62, 0x38, 0x38, 0x31, 0x61, 0x66, 0x63, 0x39, 0x36, 0x30, 0x62, 0x61, 0x37, 0x39, 0x63, 0x66, 0x30, 0x64, 0x32, 0x31, 0x63, 0x35, 0x39, 0x31, 0x62, 0x65, 0x39, 0x63, 0x65, 0x33, 0x66, 0x63, 0x62, 0x34, 0x33, 0x63, 0x34, 0x32, 0x39, 0x63, 0x39, 0x39, 0x61, 0x33, 0x35, 0x30, 0x36, 0x38, 0x64, 0x62, 0x37, 0x32, 0x62, 0x32, 0x35, 0x31, 0x32, 0x35, 0x32, 0x62, 0x30, 0x62, 0x33, 0x37, 0x37, 0x31, 0x34, 0x34, 0x38, 0x32, 0x32, 0x65, 0x37, 0x62, 0x34, 0x33, 0x62, 0x63, 0x39, 0x39, 0x66, 0x34, 0x34, 0x63, 0x36, 0x63, 0x61, 0x64, 0x64, 0x35, 0x30, 0x31, 0x65, 0x64, 0x61, 0x39, 0x62, 0x37, 0x64, 0x65, 0x31, 0x62, 0x39, 0x33, 0x61, 0x37, 0x32, 0x63, 0x63, 0x36, 0x62, 0x36, 0x38, 0x32, 0x37, 0x32, 0x39, 0x62, 0x36, 0x36, 0x36, 0x65, 0x38, 0x66, 0x38, 0x31, 0x37, 0x63, 0x66, 0x31, 0x36, 0x62, 0x64, 0x30, 0x32, 0x33, 0x37, 0x31, 0x39, 0x64, 0x34, 0x32, 0x63, 0x65, 0x33, 0x38, 0x37, 0x33, 0x38, 0x30, 0x61, 0x63, 0x38, 0x37, 0x64, 0x32, 0x33, 0x36, 0x32, 0x63, 0x34, 0x66, 0x33, 0x33, 0x30, 0x65, 0x34, 0x33, 0x39, 0x33, 0x64, 0x34, 0x65, 0x38, 0x61, 0x63, 0x65, 0x33, 0x37, 0x32, 0x64, 0x39, 0x33, 0x66, 0x30, 0x66, 0x36, 0x66, 0x33, 0x61, 0x36, 0x30, 0x62, 0x32, 0x30, 0x34, 0x38, 0x34, 0x34, 0x31, 0x36, 0x30, 0x62, 0x33, 0x33, 0x61, 0x61, 0x30, 0x36, 0x34, 0x35, 0x35, 0x31, 0x32, 0x30, 0x33, 0x64, 0x31, 0x37, 0x64, 0x35, 0x32, 0x65, 0x62, 0x37, 0x35, 0x39, 0x36, 0x37, 0x36, 0x62, 0x36, 0x36, 0x62, 0x34, 0x63, 0x39, 0x61, 0x63, 0x35, 0x61, 0x32, 0x37, 0x32, 0x66, 0x66, 0x64, 0x37, 0x62, 0x61, 0x38, 0x37, 0x61, 0x34, 0x39, 0x32, 0x39, 0x33, 0x30, 0x39, 0x34, 0x62, 0x37, 0x30, 0x36, 0x63, 0x37, 0x37, 0x62, 0x31, 0x33, 0x37, 0x66, 0x62, 0x62, 0x33, 0x39, 0x62, 0x64, 0x65, 0x35, 0x66, 0x35, 0x31, 0x35, 0x31, 0x33, 0x64, 0x38, 0x66, 0x65, 0x39, 0x38, 0x32, 0x36, 0x37, 0x62, 0x39, 0x36, 0x61, 0x66, 0x66, 0x38, 0x64, 0x30, 0x31, 0x31, 0x31, 0x32, 0x33, 0x66, 0x37, 0x32, 0x62, 0x37, 0x38, 0x37, 0x31, 0x37, 0x34, 0x33, 0x66, 0x36, 0x39, 0x30, 0x65, 0x62, 0x61, 0x64, 0x37, 0x35, 0x64, 0x36, 0x36, 0x38, 0x61, 0x38, 0x30, 0x66, 0x38, 0x61, 0x38, 0x39, 0x30, 0x33, 0x62, 0x39, 0x65, 0x63, 0x65, 0x39, 0x65, 0x61, 0x61, 0x37, 0x66, 0x33, 0x66, 0x35, 0x31, 0x62, 0x34, 0x66, 0x35, 0x33, 0x63, 0x36, 0x65, 0x35, 0x30, 0x35, 0x65, 0x33, 0x61, 0x34, 0x61, 0x32, 0x39, 0x65, 0x61, 0x36, 0x66, 0x39, 0x35, 0x39, 0x61, 0x39, 0x30, 0x65, 0x38, 0x64, 0x32, 0x62, 0x33, 0x35, 0x35, 0x32, 0x35, 0x36, 0x32, 0x37, 0x64, 0x37, 0x35, 0x30, 0x36, 0x36, 0x62, 0x62, 0x35, 0x63, 0x62, 0x38, 0x30, 0x34, 0x32, 0x37, 0x33, 0x65, 0x32, 0x66, 0x31, 0x31, 0x63, 0x39, 0x62, 0x33, 0x39, 0x36, 0x65, 0x39, 0x37, 0x39, 0x65, 0x35, 0x33, 0x63, 0x62, 0x33, 0x61, 0x31, 0x65, 0x63, 0x62, 0x64, 0x66, 0x34, 0x38, 0x62, 0x61, 0x63, 0x39, 0x36, 0x37, 0x64, 0x35, 0x62, 0x64, 0x31, 0x33, 0x63, 0x38, 0x66, 0x35, 0x31, 0x39, 0x66, 0x30, 0x66, 0x61, 0x37, 0x31, 0x62, 0x66, 0x35, 0x32, 0x39, 0x32, 0x31, 0x32, 0x35, 0x36, 0x61, 0x61, 0x65, 0x30, 0x39, 0x66, 0x65, 0x62, 0x35, 0x30, 0x66, 0x36, 0x36, 0x64, 0x64, 0x37, 0x37, 0x32, 0x62, 0x62, 0x31, 0x34, 0x37, 0x38, 0x34, 0x34, 0x66, 0x31, 0x38, 0x37, 0x61, 0x63, 0x62, 0x61, 0x37, 0x35, 0x30, 0x30, 0x62, 0x64, 0x35, 0x33, 0x33, 0x34, 0x30, 0x63, 0x63, 0x33, 0x37, 0x32, 0x34, 0x38, 0x65, 0x39, 0x38, 0x62, 0x39, 0x35, 0x66, 0x66, 0x66, 0x35, 0x61, 0x30, 0x34, 0x66, 0x31, 0x37, 0x39, 0x37, 0x61, 0x39, 0x66, 0x32, 0x61, 0x32, 0x35, 0x33, 0x37, 0x30, 0x37, 0x32, 0x62, 0x62, 0x32, 0x32, 0x30, 0x36, 0x39, 0x35, 0x66, 0x34, 0x66, 0x66, 0x38, 0x64, 0x35, 0x38, 0x61, 0x66, 0x62, 0x37, 0x34, 0x36, 0x37, 0x39, 0x36, 0x30, 0x65, 0x38, 0x63, 0x64, 0x39, 0x61, 0x36, 0x62, 0x32, 0x65, 0x38, 0x63, 0x31, 0x36, 0x34, 0x65, 0x36, 0x32, 0x34, 0x31, 0x32, 0x39, 0x63, 0x65, 0x35, 0x37, 0x34, 0x66, 0x34, 0x32, 0x64, 0x32, 0x38, 0x33, 0x63, 0x30, 0x37, 0x32, 0x38, 0x31, 0x33, 0x64, 0x32, 0x38, 0x34, 0x66, 0x65, 0x65, 0x36, 0x36, 0x65, 0x64, 0x39, 0x39, 0x36, 0x37, 0x65, 0x63, 0x30, 0x36, 0x64, 0x32, 0x36, 0x36, 0x64, 0x32, 0x34, 0x38, 0x36, 0x31, 0x34, 0x31, 0x36, 0x31, 0x31, 0x32, 0x34, 0x39, 0x31, 0x62, 0x65, 0x35, 0x30, 0x32, 0x30, 0x37, 0x64, 0x31, 0x34, 0x34, 0x64, 0x37, 0x65, 0x63, 0x36, 0x37, 0x65, 0x63, 0x66, 0x64, 0x37, 0x32, 0x38, 0x64, 0x62, 0x34, 0x63, 0x31, 0x38, 0x64, 0x38, 0x35, 0x32, 0x39, 0x32, 0x63, 0x36, 0x63, 0x62, 0x31, 0x62, 0x64, 0x33, 0x63, 0x37, 0x37, 0x61, 0x33, 0x39, 0x62, 0x35, 0x63, 0x38, 0x31, 0x65, 0x32, 0x66, 0x62, 0x63, 0x32, 0x65, 0x35, 0x33, 0x34, 0x66, 0x34, 0x33, 0x63, 0x63, 0x61, 0x64, 0x32, 0x33, 0x39, 0x36, 0x62, 0x39, 0x31, 0x30, 0x39, 0x33, 0x36, 0x35, 0x39, 0x37, 0x32, 0x61, 0x39, 0x38, 0x30, 0x37, 0x63, 0x37, 0x38, 0x61, 0x30, 0x32, 0x31, 0x33, 0x65, 0x62, 0x63, 0x30, 0x38, 0x35, 0x30, 0x38, 0x31, 0x65, 0x63, 0x33, 0x35, 0x38, 0x36, 0x35, 0x32, 0x61, 0x34, 0x66, 0x66, 0x65, 0x30, 0x65, 0x36, 0x66, 0x39, 0x32, 0x63, 0x64, 0x30, 0x33, 0x34, 0x32, 0x39, 0x61, 0x39, 0x31, 0x32, 0x37, 0x66, 0x63, 0x63, 0x38, 0x63, 0x32, 0x66, 0x63, 0x34, 0x37, 0x32, 0x38, 0x33, 0x31, 0x37, 0x31, 0x32, 0x32, 0x65, 0x63, 0x33, 0x30, 0x64, 0x35, 0x39, 0x37, 0x37, 0x61, 0x39, 0x38, 0x39, 0x62, 0x39, 0x33, 0x62, 0x63, 0x61, 0x64, 0x65, 0x35, 0x36, 0x66, 0x39, 0x62, 0x62, 0x38, 0x66, 0x66, 0x33, 0x39, 0x30, 0x30, 0x63, 0x62, 0x64, 0x31, 0x66, 0x62, 0x32, 0x30, 0x61, 0x30, 0x39, 0x66, 0x33, 0x64, 0x32, 0x32, 0x30, 0x39, 0x65, 0x33, 0x35, 0x33, 0x63, 0x30, 0x66, 0x66, 0x61, 0x33, 0x33, 0x35, 0x30, 0x36, 0x34, 0x64, 0x38, 0x36, 0x36, 0x66, 0x66, 0x63, 0x32, 0x33, 0x65, 0x35, 0x64, 0x37, 0x65, 0x36, 0x39, 0x36, 0x62, 0x63, 0x64, 0x63, 0x33, 0x34, 0x66, 0x64, 0x37, 0x37, 0x36, 0x30, 0x37, 0x64, 0x34, 0x32, 0x62, 0x33, 0x66, 0x39, 0x33, 0x62, 0x37, 0x31, 0x34, 0x66, 0x63, 0x37, 0x38, 0x38, 0x32, 0x65, 0x65, 0x37, 0x37, 0x36, 0x66, 0x37, 0x33, 0x36, 0x66, 0x64, 0x63, 0x38, 0x62, 0x36, 0x36, 0x62, 0x65, 0x30, 0x33, 0x33, 0x33, 0x31, 0x62, 0x61, 0x34, 0x61, 0x38, 0x37, 0x32, 0x62, 0x63, 0x64, 0x66, 0x63, 0x66, 0x66, 0x30, 0x61, 0x30, 0x63, 0x63, 0x35, 0x33, 0x38, 0x32, 0x32, 0x66, 0x34, 0x39, 0x37, 0x64, 0x64, 0x33, 0x35, 0x30, 0x39, 0x65, 0x33, 0x38, 0x61, 0x33, 0x64, 0x33, 0x34, 0x30, 0x66, 0x33, 0x37, 0x32, 0x38, 0x35, 0x32, 0x30, 0x36, 0x65, 0x66, 0x32, 0x64, 0x38, 0x64, 0x65, 0x39, 0x65, 0x64, 0x32, 0x36, 0x64, 0x32, 0x65, 0x37, 0x65, 0x38, 0x31, 0x38, 0x37, 0x36, 0x36, 0x62, 0x64, 0x64, 0x30, 0x31, 0x37, 0x36, 0x66, 0x36, 0x32, 0x61, 0x61, 0x63, 0x39, 0x62, 0x66, 0x32, 0x66, 0x38, 0x30, 0x32, 0x39, 0x33, 0x39, 0x34, 0x32, 0x35, 0x65, 0x64, 0x37, 0x37, 0x37, 0x35, 0x63, 0x37, 0x32, 0x66, 0x30, 0x31, 0x39, 0x37, 0x63, 0x39, 0x37, 0x35, 0x32, 0x66, 0x38, 0x62, 0x63, 0x36, 0x36, 0x32, 0x30, 0x61, 0x38, 0x35, 0x38, 0x30, 0x31, 0x63, 0x38, 0x39, 0x35, 0x65, 0x33, 0x33, 0x30, 0x34, 0x34, 0x30, 0x38, 0x66, 0x38, 0x37, 0x61, 0x32, 0x62, 0x61, 0x34, 0x33, 0x65, 0x66, 0x31, 0x34, 0x35, 0x31, 0x33, 0x61, 0x33, 0x62, 0x39, 0x38, 0x66, 0x31, 0x61, 0x64, 0x62, 0x34, 0x63, 0x63, 0x64, 0x62, 0x34, 0x63, 0x31, 0x30, 0x32, 0x31, 0x66, 0x35, 0x65, 0x32, 0x63, 0x34, 0x36, 0x63, 0x33, 0x64, 0x35, 0x33, 0x62, 0x33, 0x32, 0x65, 0x33, 0x65, 0x34, 0x34, 0x66, 0x61, 0x32, 0x37, 0x32, 0x39, 0x33, 0x66, 0x38, 0x38, 0x35, 0x64, 0x36, 0x63, 0x65, 0x61, 0x65, 0x39, 0x38, 0x62, 0x39, 0x39, 0x33, 0x62, 0x65, 0x30, 0x35, 0x39, 0x36, 0x38, 0x64, 0x65, 0x39, 0x37, 0x32, 0x64, 0x30, 0x65, 0x64, 0x63, 0x61, 0x65, 0x64, 0x65, 0x64, 0x65, 0x62, 0x31, 0x62, 0x35, 0x37, 0x62, 0x63, 0x64, 0x66, 0x30, 0x66, 0x64, 0x31, 0x66, 0x31, 0x61, 0x32, 0x30, 0x36, 0x37, 0x39, 0x66, 0x66, 0x65, 0x36, 0x36, 0x38, 0x61, 0x37, 0x64, 0x62, 0x31, 0x31, 0x31, 0x30, 0x36, 0x32, 0x35, 0x34, 0x30, 0x62, 0x33, 0x30, 0x36, 0x65, 0x38, 0x34, 0x65, 0x63, 0x30, 0x66, 0x36, 0x35, 0x65, 0x35, 0x34, 0x63, 0x37, 0x63, 0x36, 0x34, 0x39, 0x61, 0x34, 0x63, 0x37, 0x31, 0x36, 0x62, 0x36, 0x62, 0x39, 0x65, 0x35, 0x32, 0x32, 0x31, 0x30, 0x37, 0x66, 0x33, 0x37, 0x31, 0x38, 0x35, 0x31, 0x37, 0x37, 0x64, 0x36, 0x34, 0x62, 0x38, 0x61, 0x35, 0x62, 0x62, 0x31, 0x37, 0x32, 0x65, 0x36, 0x62, 0x38, 0x61, 0x30, 0x36, 0x61, 0x33, 0x37, 0x37, 0x39, 0x64, 0x31, 0x38, 0x37, 0x32, 0x33, 0x33, 0x62, 0x38, 0x33, 0x36, 0x39, 0x61, 0x32, 0x61, 0x36, 0x31, 0x30, 0x32, 0x62, 0x31, 0x34, 0x33, 0x38, 0x33, 0x30, 0x35, 0x39, 0x32, 0x32, 0x66, 0x39, 0x63, 0x34, 0x38, 0x38, 0x38, 0x61, 0x38, 0x35, 0x62, 0x37, 0x65, 0x64, 0x37, 0x39, 0x37, 0x39, 0x34, 0x64, 0x38, 0x39, 0x65, 0x36, 0x30, 0x30, 0x63, 0x34, 0x65, 0x36, 0x32, 0x64, 0x36, 0x34, 0x64, 0x65, 0x62, 0x30, 0x63, 0x38, 0x64, 0x36, 0x61, 0x34, 0x36, 0x37, 0x64, 0x62, 0x31, 0x61, 0x61, 0x30, 0x64, 0x64, 0x33, 0x34, 0x30, 0x35, 0x38, 0x34, 0x31, 0x64, 0x36, 0x39, 0x38, 0x30, 0x64, 0x62, 0x63, 0x39, 0x38, 0x65, 0x61, 0x33, 0x33, 0x61, 0x65, 0x38, 0x65, 0x66, 0x32, 0x64, 0x31, 0x35, 0x65, 0x34, 0x35, 0x31, 0x33, 0x65, 0x37, 0x33, 0x30, 0x63, 0x31, 0x66, 0x61, 0x63, 0x63, 0x62, 0x38, 0x37, 0x32, 0x31, 0x30, 0x62, 0x33, 0x62, 0x65, 0x34, 0x36, 0x33, 0x62, 0x31, 0x62, 0x30, 0x37, 0x61, 0x36, 0x65, 0x61, 0x32, 0x62, 0x38, 0x38, 0x66, 0x37, 0x64, 0x65, 0x31, 0x30, 0x37, 0x35, 0x33, 0x32, 0x66, 0x38, 0x61, 0x34, 0x62, 0x33, 0x62, 0x36, 0x65, 0x63, 0x64, 0x31, 0x31, 0x62, 0x30, 0x33, 0x61, 0x39, 0x33, 0x35, 0x63, 0x35, 0x63, 0x34, 0x31, 0x30, 0x61, 0x35, 0x38, 0x64, 0x37, 0x32, 0x31, 0x34, 0x62, 0x38, 0x63, 0x33, 0x33, 0x31, 0x65, 0x61, 0x37, 0x62, 0x35, 0x34, 0x36, 0x38, 0x34, 0x61, 0x38, 0x30, 0x30, 0x61, 0x39, 0x33, 0x34, 0x37, 0x37, 0x32, 0x65, 0x63, 0x34, 0x35, 0x62, 0x65, 0x35, 0x66, 0x62, 0x37, 0x32, 0x36, 0x63, 0x30, 0x39, 0x34, 0x63, 0x38, 0x35, 0x35, 0x33, 0x36, 0x66, 0x37, 0x63, 0x31, 0x35, 0x63, 0x66, 0x33, 0x30, 0x34, 0x32, 0x65, 0x31, 0x32, 0x61, 0x33, 0x37, 0x31, 0x39, 0x63, 0x62, 0x32, 0x35, 0x37, 0x36, 0x37, 0x66, 0x37, 0x36, 0x63, 0x61, 0x34, 0x65, 0x61, 0x37, 0x64, 0x35, 0x63, 0x37, 0x64, 0x62, 0x39, 0x63, 0x34, 0x32, 0x37, 0x30, 0x33, 0x36, 0x65, 0x36, 0x38, 0x34, 0x38, 0x30, 0x35, 0x35, 0x34, 0x35, 0x39, 0x62, 0x35, 0x36, 0x66, 0x61, 0x36, 0x65, 0x66, 0x30, 0x32, 0x31, 0x64, 0x65, 0x37, 0x38, 0x62, 0x35, 0x31, 0x38, 0x62, 0x36, 0x38, 0x63, 0x36, 0x33, 0x34, 0x63, 0x61, 0x30, 0x37, 0x36, 0x39, 0x37, 0x39, 0x39, 0x61, 0x39, 0x64, 0x63, 0x66, 0x33, 0x66, 0x33, 0x32, 0x37, 0x64, 0x34, 0x33, 0x35, 0x36, 0x39, 0x35, 0x32, 0x33, 0x64, 0x66, 0x66, 0x32, 0x33, 0x30, 0x30, 0x31, 0x62, 0x33, 0x36, 0x32, 0x32, 0x39, 0x37, 0x31, 0x36, 0x61, 0x37, 0x36, 0x37, 0x38, 0x62, 0x30, 0x38, 0x30, 0x37, 0x32, 0x64, 0x35, 0x31, 0x34, 0x37, 0x33, 0x65, 0x66, 0x35, 0x61, 0x33, 0x63, 0x30, 0x36, 0x34, 0x36, 0x64, 0x34, 0x37, 0x33, 0x62, 0x32, 0x38, 0x64, 0x34, 0x62, 0x38, 0x31, 0x62, 0x62, 0x39, 0x34, 0x36, 0x66, 0x32, 0x63, 0x61, 0x38, 0x66, 0x38, 0x65, 0x31, 0x65, 0x61, 0x33, 0x35, 0x33, 0x37, 0x39, 0x33, 0x65, 0x62, 0x35, 0x39, 0x36, 0x39, 0x30, 0x64, 0x31, 0x36, 0x39, 0x35, 0x37, 0x32, 0x61, 0x30, 0x63, 0x30, 0x31, 0x32, 0x63, 0x65, 0x64, 0x31, 0x39, 0x63, 0x64, 0x34, 0x62, 0x63, 0x61, 0x32, 0x36, 0x65, 0x32, 0x34, 0x31, 0x66, 0x34, 0x61, 0x31, 0x61, 0x34, 0x63, 0x30, 0x39, 0x37, 0x66, 0x61, 0x39, 0x61, 0x31, 0x36, 0x65, 0x35, 0x30, 0x33, 0x38, 0x35, 0x31, 0x63, 0x39, 0x30, 0x34, 0x37, 0x31, 0x62, 0x36, 0x34, 0x64, 0x34, 0x39, 0x64, 0x37, 0x37, 0x34, 0x37, 0x32, 0x32, 0x37, 0x30, 0x37, 0x39, 0x33, 0x64, 0x31, 0x31, 0x38, 0x38, 0x61, 0x31, 0x62, 0x65, 0x33, 0x31, 0x36, 0x62, 0x61, 0x65, 0x65, 0x64, 0x35, 0x64, 0x34, 0x31, 0x32, 0x66, 0x38, 0x36, 0x66, 0x39, 0x32, 0x35, 0x61, 0x38, 0x32, 0x34, 0x38, 0x65, 0x33, 0x35, 0x34, 0x30, 0x63, 0x35, 0x32, 0x37, 0x61, 0x39, 0x36, 0x31, 0x39, 0x65, 0x30, 0x36, 0x30, 0x36, 0x31, 0x65, 0x62, 0x33, 0x65, 0x63, 0x62, 0x36, 0x33, 0x33, 0x34, 0x33, 0x65, 0x62, 0x37, 0x66, 0x36, 0x62, 0x32, 0x38, 0x61, 0x34, 0x31, 0x30, 0x39, 0x31, 0x65, 0x36, 0x31, 0x37, 0x38, 0x32, 0x32, 0x30, 0x65, 0x64, 0x32, 0x66, 0x39, 0x38, 0x31, 0x62, 0x36, 0x35, 0x30, 0x39, 0x64, 0x62, 0x63, 0x65, 0x35, 0x38, 0x61, 0x61, 0x66, 0x36, 0x62, 0x61, 0x36, 0x64, 0x36, 0x31, 0x35, 0x39, 0x62, 0x33, 0x31, 0x37, 0x32, 0x34, 0x63, 0x38, 0x35, 0x65, 0x32, 0x37, 0x34, 0x30, 0x61, 0x35, 0x36, 0x33, 0x65, 0x39, 0x38, 0x30, 0x63, 0x36, 0x35, 0x37, 0x65, 0x34, 0x36, 0x62, 0x63, 0x37, 0x36, 0x62, 0x39, 0x38, 0x32, 0x66, 0x37, 0x33, 0x65, 0x39, 0x64, 0x38, 0x64, 0x64, 0x32, 0x63, 0x35, 0x66, 0x33, 0x34, 0x62, 0x63, 0x38, 0x35, 0x31, 0x38, 0x32, 0x39, 0x63, 0x38, 0x63, 0x62, 0x62, 0x33, 0x33, 0x37, 0x32, 0x37, 0x30, 0x36, 0x62, 0x33, 0x37, 0x63, 0x31, 0x34, 0x35, 0x32, 0x36, 0x63, 0x66, 0x34, 0x33, 0x30, 0x30, 0x34, 0x38, 0x32, 0x62, 0x33, 0x61, 0x61, 0x66, 0x38, 0x62, 0x63, 0x36, 0x31, 0x33, 0x63, 0x33, 0x62, 0x62, 0x65, 0x38, 0x30, 0x35, 0x32, 0x38, 0x35, 0x65, 0x39, 0x35, 0x32, 0x32, 0x39, 0x35, 0x65, 0x34, 0x66, 0x63, 0x31, 0x34, 0x33, 0x61, 0x38, 0x30, 0x32, 0x38, 0x37, 0x32, 0x39, 0x34, 0x33, 0x66, 0x66, 0x32, 0x61, 0x30, 0x38, 0x39, 0x66, 0x30, 0x35, 0x33, 0x30, 0x31, 0x34, 0x64, 0x62, 0x66, 0x62, 0x30, 0x36, 0x35, 0x36, 0x33, 0x36, 0x30, 0x31, 0x35, 0x37, 0x62, 0x37, 0x34, 0x34, 0x34, 0x66, 0x36, 0x62, 0x37, 0x37, 0x38, 0x31, 0x35, 0x37, 0x30, 0x38, 0x32, 0x37, 0x36, 0x63, 0x31, 0x61, 0x33, 0x36, 0x35, 0x65, 0x36, 0x39, 0x65, 0x62, 0x61, 0x30, 0x33, 0x61, 0x39, 0x31, 0x37, 0x61, 0x33, 0x35, 0x66, 0x65, 0x31, 0x65, 0x38, 0x35, 0x63, 0x32, 0x34, 0x64, 0x31, 0x62, 0x31, 0x36, 0x63, 0x32, 0x61, 0x61, 0x61, 0x35, 0x32, 0x32, 0x38, 0x38, 0x31, 0x30, 0x37, 0x32, 0x38, 0x36, 0x38, 0x35, 0x32, 0x38, 0x36, 0x33, 0x31, 0x30, 0x39, 0x64, 0x33, 0x34, 0x61, 0x62, 0x61, 0x62, 0x33, 0x65, 0x36, 0x34, 0x62, 0x30, 0x34, 0x37, 0x63, 0x34, 0x66, 0x31, 0x34, 0x64, 0x30, 0x35, 0x32, 0x31, 0x63, 0x30, 0x64, 0x38, 0x37, 0x64, 0x37, 0x35, 0x64, 0x34, 0x30, 0x64, 0x35, 0x38, 0x62, 0x31, 0x30, 0x38, 0x36, 0x37, 0x61, 0x31, 0x35, 0x36, 0x30, 0x36, 0x30, 0x63, 0x31, 0x34, 0x62, 0x39, 0x32, 0x39, 0x39, 0x63, 0x36, 0x37, 0x32, 0x61, 0x33, 0x39, 0x31, 0x38, 0x37, 0x31, 0x31, 0x36, 0x33, 0x31, 0x32, 0x61, 0x65, 0x30, 0x32, 0x30, 0x31, 0x39, 0x63, 0x62, 0x35, 0x38, 0x30, 0x32, 0x37, 0x34, 0x64, 0x35, 0x34, 0x64, 0x66, 0x36, 0x32, 0x38, 0x38, 0x63, 0x33, 0x34, 0x63, 0x65, 0x33, 0x38, 0x33, 0x35, 0x30, 0x66, 0x61, 0x35, 0x62, 0x64, 0x65, 0x31, 0x30, 0x39, 0x62, 0x62, 0x33, 0x63, 0x32, 0x31, 0x33, 0x34, 0x34, 0x31, 0x65, 0x31, 0x35, 0x61, 0x64, 0x34, 0x61, 0x62, 0x36, 0x61, 0x61, 0x37, 0x33, 0x36, 0x34, 0x34, 0x35, 0x61, 0x61, 0x33, 0x33, 0x37, 0x65, 0x65, 0x61, 0x64, 0x66, 0x34, 0x62, 0x31, 0x65, 0x39, 0x64, 0x64, 0x65, 0x33, 0x30, 0x38, 0x37, 0x62, 0x33, 0x37, 0x62, 0x65, 0x36, 0x32, 0x35, 0x37, 0x35, 0x38, 0x32, 0x62, 0x61, 0x62, 0x65, 0x33, 0x33, 0x66, 0x66, 0x65, 0x31, 0x62, 0x31, 0x66, 0x66, 0x66, 0x36, 0x63, 0x63, 0x61, 0x30, 0x35, 0x63, 0x66, 0x31, 0x66, 0x39, 0x61, 0x65, 0x37, 0x32, 0x62, 0x32, 0x61, 0x37, 0x38, 0x32, 0x39, 0x39, 0x38, 0x35, 0x31, 0x34, 0x37, 0x36, 0x36, 0x39, 0x37, 0x66, 0x34, 0x66, 0x35, 0x36, 0x66, 0x65, 0x34, 0x65, 0x33, 0x36, 0x64, 0x61, 0x38, 0x36, 0x38, 0x35, 0x37, 0x38, 0x33, 0x64, 0x63, 0x39, 0x35, 0x34, 0x63, 0x39, 0x66, 0x30, 0x30, 0x31, 0x61, 0x35, 0x36, 0x66, 0x37, 0x31, 0x36, 0x39, 0x32, 0x35, 0x64, 0x65, 0x66, 0x31, 0x32, 0x64, 0x66, 0x34, 0x31, 0x39, 0x33, 0x35, 0x32, 0x34, 0x38, 0x63, 0x37, 0x32, 0x62, 0x33, 0x35, 0x36, 0x61, 0x30, 0x66, 0x30, 0x35, 0x63, 0x32, 0x38, 0x66, 0x38, 0x39, 0x63, 0x36, 0x31, 0x61, 0x34, 0x61, 0x36, 0x36, 0x39, 0x39, 0x35, 0x64, 0x30, 0x34, 0x62, 0x31, 0x30, 0x30, 0x31, 0x63, 0x37, 0x61, 0x34, 0x38, 0x63, 0x30, 0x61, 0x33, 0x65, 0x33, 0x32, 0x35, 0x38, 0x61, 0x37, 0x36, 0x64, 0x36, 0x33, 0x65, 0x31, 0x33, 0x61, 0x35, 0x63, 0x65, 0x35, 0x32, 0x32, 0x38, 0x37, 0x30, 0x61, 0x66, 0x34, 0x31, 0x63, 0x37, 0x32, 0x64, 0x37, 0x62, 0x61, 0x34, 0x63, 0x36, 0x33, 0x39, 0x65, 0x35, 0x38, 0x32, 0x31, 0x64, 0x35, 0x65, 0x32, 0x30, 0x37, 0x37, 0x39, 0x32, 0x30, 0x32, 0x65, 0x34, 0x30, 0x35, 0x31, 0x61, 0x62, 0x30, 0x38, 0x62, 0x35, 0x35, 0x63, 0x33, 0x31, 0x37, 0x32, 0x65, 0x66, 0x37, 0x62, 0x37, 0x64, 0x37, 0x33, 0x61, 0x39, 0x30, 0x35, 0x33, 0x62, 0x34, 0x39, 0x34, 0x65, 0x63, 0x65, 0x64, 0x34, 0x32, 0x64, 0x65, 0x37, 0x37, 0x61, 0x65, 0x36, 0x63, 0x61, 0x31, 0x65, 0x35, 0x38, 0x31, 0x66, 0x38, 0x66, 0x33, 0x64, 0x37, 0x61, 0x35, 0x32, 0x39, 0x30, 0x32, 0x32, 0x33, 0x39, 0x30, 0x38, 0x32, 0x31, 0x37, 0x33, 0x63, 0x39, 0x32, 0x33, 0x36, 0x63, 0x63, 0x35, 0x36, 0x36, 0x34, 0x36, 0x39, 0x32, 0x33, 0x64, 0x35, 0x35, 0x38, 0x65, 0x37, 0x33, 0x66, 0x37, 0x61, 0x64, 0x65, 0x38, 0x32, 0x35, 0x31, 0x36, 0x64, 0x39, 0x30, 0x62, 0x65, 0x36, 0x63, 0x61, 0x65, 0x36, 0x39, 0x62, 0x32, 0x37, 0x36, 0x37, 0x36, 0x64, 0x33, 0x63, 0x39, 0x33, 0x35, 0x62, 0x64, 0x38, 0x35, 0x30, 0x61, 0x31, 0x33, 0x36, 0x33, 0x32, 0x61, 0x61, 0x37, 0x32, 0x61, 0x33, 0x62, 0x36, 0x32, 0x31, 0x63, 0x35, 0x31, 0x31, 0x31, 0x63, 0x65, 0x63, 0x38, 0x39, 0x37, 0x66, 0x37, 0x61, 0x36, 0x66, 0x66, 0x63, 0x62, 0x37, 0x64, 0x64, 0x65, 0x30, 0x34, 0x62, 0x64, 0x31, 0x33, 0x32, 0x39, 0x62, 0x33, 0x61, 0x31, 0x32, 0x37, 0x31, 0x36, 0x37, 0x33, 0x37, 0x38, 0x63, 0x32, 0x62, 0x38, 0x30, 0x62, 0x30, 0x38, 0x33, 0x30, 0x63, 0x35, 0x61, 0x37, 0x32, 0x66, 0x39, 0x35, 0x39, 0x32, 0x36, 0x35, 0x32, 0x63, 0x63, 0x38, 0x32, 0x36, 0x61, 0x36, 0x62, 0x37, 0x30, 0x39, 0x37, 0x39, 0x38, 0x61, 0x36, 0x63, 0x32, 0x63, 0x65, 0x33, 0x66, 0x32, 0x38, 0x38, 0x64, 0x30, 0x37, 0x64, 0x65, 0x36, 0x63, 0x38, 0x65, 0x63, 0x38, 0x31, 0x33, 0x66, 0x36, 0x35, 0x37, 0x63, 0x62, 0x61, 0x66, 0x39, 0x33, 0x33, 0x63, 0x31, 0x61, 0x33, 0x62, 0x37, 0x32, 0x34, 0x38, 0x36, 0x37, 0x39, 0x65, 0x32, 0x64, 0x36, 0x63, 0x39, 0x61, 0x64, 0x35, 0x62, 0x38, 0x62, 0x34, 0x62, 0x62, 0x39, 0x61, 0x38, 0x35, 0x31, 0x36, 0x38, 0x35, 0x35, 0x33, 0x30, 0x37, 0x38, 0x62, 0x63, 0x62, 0x34, 0x62, 0x37, 0x65, 0x62, 0x30, 0x62, 0x61, 0x38, 0x61, 0x37, 0x63, 0x34, 0x61, 0x36, 0x31, 0x37, 0x65, 0x66, 0x36, 0x63, 0x39, 0x66, 0x37, 0x34, 0x30, 0x37, 0x32, 0x62, 0x37, 0x64, 0x62, 0x61, 0x62, 0x30, 0x63, 0x62, 0x62, 0x36, 0x36, 0x36, 0x38, 0x65, 0x36, 0x32, 0x30, 0x34, 0x38, 0x66, 0x64, 0x36, 0x66, 0x38, 0x33, 0x61, 0x64, 0x38, 0x37, 0x66, 0x61, 0x38, 0x30, 0x33, 0x61, 0x38, 0x64, 0x38, 0x39, 0x33, 0x35, 0x62, 0x33, 0x63, 0x61, 0x33, 0x32, 0x33, 0x66, 0x39, 0x61, 0x37, 0x61, 0x64, 0x33, 0x32, 0x39, 0x39, 0x35, 0x66, 0x33, 0x36, 0x30, 0x62, 0x30, 0x65, 0x32, 0x36, 0x39, 0x32, 0x30, 0x37, 0x65, 0x33, 0x31, 0x32, 0x34, 0x36, 0x35, 0x33, 0x63, 0x34, 0x63, 0x61, 0x36, 0x34, 0x30, 0x30, 0x63, 0x39, 0x39, 0x33, 0x64, 0x34, 0x34, 0x32, 0x30, 0x36, 0x32, 0x32, 0x65, 0x63, 0x63, 0x62, 0x65, 0x63, 0x34, 0x31, 0x36, 0x65, 0x31, 0x35, 0x38, 0x62, 0x33, 0x35, 0x31, 0x32, 0x32, 0x35, 0x35, 0x66, 0x65, 0x61, 0x34, 0x37, 0x32, 0x35, 0x33, 0x61, 0x38, 0x66, 0x63, 0x35, 0x36, 0x66, 0x37, 0x64, 0x62, 0x65, 0x64, 0x64, 0x37, 0x33, 0x31, 0x61, 0x33, 0x62, 0x32, 0x39, 0x65, 0x30, 0x36, 0x66, 0x64, 0x33, 0x30, 0x37, 0x61, 0x36, 0x36, 0x62, 0x65, 0x65, 0x34, 0x62, 0x64, 0x65, 0x39, 0x61, 0x35, 0x31, 0x64, 0x31, 0x30, 0x64, 0x34, 0x34, 0x33, 0x36, 0x66, 0x37, 0x34, 0x30, 0x34, 0x61, 0x61, 0x35, 0x38, 0x34, 0x37, 0x35, 0x36, 0x38, 0x35, 0x61, 0x39, 0x34, 0x36, 0x34, 0x30, 0x61, 0x31, 0x31, 0x30, 0x63, 0x35, 0x34, 0x37, 0x34, 0x33, 0x39, 0x64, 0x30, 0x63, 0x65, 0x37, 0x61, 0x66, 0x65, 0x64, 0x37, 0x64, 0x33, 0x66, 0x34, 0x33, 0x34, 0x62, 0x66, 0x66, 0x39, 0x61, 0x38, 0x37, 0x65, 0x65, 0x66, 0x35, 0x39, 0x64, 0x31, 0x32, 0x39, 0x37, 0x31, 0x31, 0x37, 0x62, 0x39, 0x64, 0x33, 0x33, 0x37, 0x32, 0x33, 0x36, 0x37, 0x30, 0x66, 0x38, 0x36, 0x66, 0x66, 0x39, 0x64, 0x35, 0x30, 0x38, 0x38, 0x39, 0x37, 0x61, 0x38, 0x39, 0x63, 0x36, 0x63, 0x38, 0x36, 0x31, 0x31, 0x38, 0x34, 0x66, 0x33, 0x65, 0x62, 0x66, 0x38, 0x65, 0x61, 0x31, 0x36, 0x33, 0x35, 0x38, 0x31, 0x61, 0x65, 0x37, 0x34, 0x36, 0x35, 0x62, 0x65, 0x32, 0x38, 0x61, 0x65, 0x39, 0x31, 0x37, 0x36, 0x61, 0x35, 0x65, 0x34, 0x65, 0x63, 0x34, 0x61, 0x34, 0x32, 0x36, 0x64, 0x36, 0x34, 0x34, 0x61, 0x33, 0x38, 0x62, 0x39, 0x39, 0x35, 0x62, 0x33, 0x63, 0x39, 0x36, 0x61, 0x63, 0x64, 0x63, 0x61, 0x34, 0x63, 0x37, 0x64, 0x39, 0x61, 0x36, 0x33, 0x38, 0x37, 0x65, 0x64, 0x64, 0x34, 0x64, 0x66, 0x34, 0x63, 0x32, 0x35, 0x31, 0x66, 0x61, 0x63, 0x38, 0x35, 0x31, 0x30, 0x32, 0x66, 0x36, 0x32, 0x61, 0x31, 0x64, 0x37, 0x32, 0x35, 0x31, 0x31, 0x64, 0x64, 0x31, 0x35, 0x38, 0x32, 0x65, 0x66, 0x30, 0x61, 0x30, 0x39, 0x35, 0x64, 0x62, 0x32, 0x34, 0x39, 0x31, 0x37, 0x36, 0x31, 0x65, 0x32, 0x64, 0x31, 0x62, 0x31, 0x35, 0x32, 0x65, 0x62, 0x66, 0x38, 0x63, 0x63, 0x61, 0x62, 0x34, 0x34, 0x32, 0x66, 0x34, 0x38, 0x39, 0x36, 0x31, 0x36, 0x35, 0x61, 0x34, 0x63, 0x65, 0x63, 0x32, 0x63, 0x61, 0x64, 0x61, 0x37, 0x32, 0x62, 0x61, 0x64, 0x64, 0x33, 0x38, 0x32, 0x34, 0x65, 0x39, 0x38, 0x35, 0x31, 0x61, 0x36, 0x31, 0x63, 0x39, 0x34, 0x62, 0x31, 0x35, 0x33, 0x61, 0x34, 0x65, 0x37, 0x36, 0x64, 0x38, 0x33, 0x35, 0x31, 0x66, 0x31, 0x66, 0x65, 0x39, 0x30, 0x36, 0x38, 0x30, 0x30, 0x34, 0x33, 0x63, 0x37, 0x35, 0x32, 0x62, 0x62, 0x66, 0x32, 0x31, 0x35, 0x33, 0x34, 0x39, 0x35, 0x63, 0x33, 0x31, 0x37, 0x32, 0x63, 0x63, 0x64, 0x64, 0x65, 0x31, 0x36, 0x33, 0x31, 0x30, 0x65, 0x62, 0x66, 0x66, 0x64, 0x37, 0x62, 0x32, 0x33, 0x37, 0x62, 0x62, 0x35, 0x39, 0x66, 0x63, 0x37, 0x37, 0x39, 0x64, 0x61, 0x65, 0x65, 0x39, 0x37, 0x62, 0x33, 0x65, 0x32, 0x30, 0x35, 0x34, 0x30, 0x31, 0x33, 0x33, 0x61, 0x34, 0x61, 0x61, 0x37, 0x33, 0x38, 0x34, 0x65, 0x33, 0x36, 0x31, 0x38, 0x62, 0x36, 0x65, 0x34, 0x39, 0x31, 0x32, 0x65, 0x36, 0x36, 0x33, 0x65, 0x36, 0x38, 0x30, 0x35, 0x65, 0x35, 0x38, 0x33, 0x36, 0x34, 0x65, 0x31, 0x66, 0x33, 0x61, 0x34, 0x32, 0x30, 0x65, 0x32, 0x36, 0x34, 0x30, 0x66, 0x32, 0x39, 0x37, 0x63, 0x65, 0x33, 0x38, 0x38, 0x38, 0x31, 0x35, 0x66, 0x30, 0x36, 0x66, 0x30, 0x65, 0x61, 0x61, 0x33, 0x65, 0x37, 0x65, 0x64, 0x62, 0x35, 0x62, 0x36, 0x66, 0x33, 0x63, 0x37, 0x32, 0x38, 0x30, 0x33, 0x62, 0x38, 0x66, 0x39, 0x37, 0x64, 0x34, 0x32, 0x36, 0x61, 0x30, 0x39, 0x61, 0x35, 0x37, 0x36, 0x32, 0x62, 0x62, 0x36, 0x34, 0x62, 0x32, 0x31, 0x66, 0x34, 0x35, 0x34, 0x30, 0x63, 0x66, 0x63, 0x32, 0x36, 0x31, 0x33, 0x66, 0x38, 0x37, 0x35, 0x30, 0x38, 0x30, 0x62, 0x63, 0x66, 0x31, 0x31, 0x33, 0x65, 0x31, 0x39, 0x33, 0x62, 0x32, 0x33, 0x33, 0x39, 0x30, 0x37, 0x32, 0x31, 0x36, 0x36, 0x62, 0x38, 0x38, 0x32, 0x35, 0x30, 0x62, 0x38, 0x36, 0x36, 0x65, 0x64, 0x66, 0x36, 0x33, 0x32, 0x62, 0x65, 0x64, 0x37, 0x35, 0x64, 0x37, 0x65, 0x33, 0x65, 0x34, 0x63, 0x30, 0x63, 0x33, 0x32, 0x37, 0x36, 0x38, 0x66, 0x62, 0x64, 0x36, 0x36, 0x34, 0x36, 0x65, 0x32, 0x62, 0x62, 0x61, 0x31, 0x64, 0x31, 0x66, 0x31, 0x38, 0x39, 0x32, 0x33, 0x35, 0x38, 0x36, 0x37, 0x32, 0x37, 0x66, 0x61, 0x35, 0x66, 0x32, 0x39, 0x34, 0x30, 0x35, 0x61, 0x65, 0x66, 0x39, 0x65, 0x36, 0x61, 0x31, 0x38, 0x34, 0x31, 0x36, 0x61, 0x31, 0x37, 0x64, 0x34, 0x63, 0x33, 0x61, 0x36, 0x66, 0x64, 0x35, 0x62, 0x63, 0x39, 0x65, 0x65, 0x31, 0x39, 0x61, 0x34, 0x61, 0x32, 0x32, 0x30, 0x66, 0x36, 0x63, 0x38, 0x38, 0x30, 0x33, 0x65, 0x65, 0x39, 0x33, 0x39, 0x30, 0x31, 0x66, 0x32, 0x32, 0x64, 0x35, 0x65, 0x36, 0x66, 0x61, 0x33, 0x37, 0x38, 0x64, 0x30, 0x32, 0x63, 0x38, 0x61, 0x61, 0x61, 0x34, 0x62, 0x37, 0x35, 0x62, 0x33, 0x33, 0x33, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x62, 0x65, 0x63, 0x36, 0x37, 0x30, 0x36, 0x62, 0x64, 0x61, 0x35, 0x37, 0x39, 0x35, 0x65, 0x34, 0x33, 0x35, 0x30, 0x35, 0x33, 0x33, 0x39, 0x33, 0x32, 0x36, 0x65, 0x37, 0x65, 0x62, 0x36, 0x33, 0x66, 0x63, 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x63, 0x37, 0x35, 0x63, 0x32, 0x36, 0x30, 0x36, 0x64, 0x34, 0x37, 0x36, 0x38, 0x62, 0x62, 0x64, 0x34, 0x38, 0x30, 0x62, 0x33, 0x66, 0x31, 0x39, 0x37, 0x31, 0x31, 0x35, 0x39, 0x65, 0x31, 0x31, 0x31, 0x34, 0x63, 0x61, 0x62, 0x65, 0x36, 0x33, 0x32, 0x61, 0x31, 0x38, 0x33, 0x64, 0x36, 0x36, 0x63, 0x35, 0x36, 0x32, 0x36, 0x66, 0x31, 0x30, 0x33, 0x36, 0x36, 0x37, 0x39, 0x32, 0x39, 0x62, 0x30, 0x35, 0x35, 0x62, 0x39, 0x33, 0x32, 0x30, 0x39, 0x32, 0x34, 0x65, 0x37, 0x34, 0x38, 0x63, 0x64, 0x64, 0x39, 0x37, 0x62, 0x39, 0x63, 0x32, 0x31, 0x64, 0x35, 0x61, 0x37, 0x65, 0x63, 0x62, 0x38, 0x32, 0x63, 0x61, 0x63, 0x38, 0x64, 0x62, 0x63, 0x61, 0x65, 0x62, 0x66, 0x35, 0x32, 0x31, 0x36, 0x38, 0x31, 0x38, 0x30, 0x33, 0x64, 0x37, 0x32, 0x35, 0x39, 0x33, 0x36, 0x38, 0x61, 0x30, 0x30, 0x34, 0x66, 0x30, 0x35, 0x33, 0x61, 0x39, 0x65, 0x61, 0x33, 0x38, 0x30, 0x62, 0x34, 0x31, 0x32, 0x64, 0x63, 0x31, 0x61, 0x63, 0x62, 0x32, 0x34, 0x63, 0x63, 0x64, 0x64, 0x39, 0x64, 0x36, 0x63, 0x37, 0x64, 0x61, 0x65, 0x32, 0x30, 0x37, 0x31, 0x65, 0x62, 0x35, 0x39, 0x64, 0x30, 0x30, 0x35, 0x35, 0x35, 0x61, 0x66, 0x35, 0x32, 0x37, 0x32, 0x32, 0x30, 0x64, 0x32, 0x61, 0x66, 0x64, 0x63, 0x31, 0x61, 0x30, 0x34, 0x63, 0x35, 0x38, 0x63, 0x33, 0x31, 0x31, 0x31, 0x33, 0x32, 0x64, 0x63, 0x36, 0x63, 0x32, 0x66, 0x61, 0x39, 0x33, 0x61, 0x38, 0x39, 0x63, 0x38, 0x36, 0x38, 0x37, 0x63, 0x62, 0x37, 0x36, 0x63, 0x30, 0x64, 0x35, 0x33, 0x65, 0x35, 0x36, 0x35, 0x39, 0x61, 0x66, 0x65, 0x62, 0x32, 0x64, 0x66, 0x33, 0x63, 0x33, 0x39, 0x63, 0x33, 0x61, 0x37, 0x39, 0x35, 0x37, 0x38, 0x63, 0x39, 0x33, 0x64, 0x35, 0x30, 0x62, 0x37, 0x35, 0x35, 0x39, 0x36, 0x37, 0x62, 0x38, 0x37, 0x39, 0x65, 0x31, 0x65, 0x63, 0x31, 0x39, 0x66, 0x34, 0x66, 0x66, 0x38, 0x36, 0x64, 0x31, 0x63, 0x34, 0x33, 0x38, 0x65, 0x64, 0x64, 0x33, 0x62, 0x37, 0x38, 0x30, 0x65, 0x31, 0x65, 0x39, 0x62, 0x34, 0x66, 0x30, 0x31, 0x37, 0x63, 0x30, 0x32, 0x33, 0x65, 0x30, 0x31, 0x31, 0x63, 0x32, 0x30, 0x39, 0x35, 0x31, 0x31, 0x64, 0x66, 0x36, 0x30, 0x31, 0x62, 0x37, 0x64, 0x33, 0x37, 0x39, 0x62, 0x37, 0x34, 0x64, 0x38, 0x31, 0x39, 0x64, 0x35, 0x32, 0x36, 0x34, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x61, 0x30, 0x39, 0x65, 0x61, 0x38, 0x62, 0x62, 0x66, 0x36, 0x62, 0x64, 0x38, 0x62, 0x39, 0x32, 0x63, 0x31, 0x63, 0x33, 0x65, 0x37, 0x32, 0x37, 0x30, 0x36, 0x65, 0x33, 0x35, 0x37, 0x32, 0x64, 0x65, 0x32, 0x64, 0x64, 0x64, 0x31, 0x38, 0x33, 0x66, 0x33, 0x33, 0x61, 0x38, 0x32, 0x39, 0x39, 0x63, 0x31, 0x64, 0x65, 0x37, 0x32, 0x62, 0x66, 0x32, 0x37, 0x36, 0x39, 0x66, 0x61, 0x39, 0x61, 0x39, 0x38, 0x33, 0x36, 0x61, 0x39, 0x31, 0x33, 0x35, 0x35, 0x34, 0x30, 0x37, 0x32, 0x36, 0x33, 0x33, 0x62, 0x31, 0x61, 0x31, 0x37, 0x32, 0x62, 0x34, 0x38, 0x64, 0x66, 0x62, 0x36, 0x31, 0x64, 0x37, 0x30, 0x34, 0x31, 0x39, 0x62, 0x30, 0x37, 0x35, 0x31, 0x37, 0x63, 0x62, 0x36, 0x64, 0x38, 0x66, 0x33, 0x63, 0x37, 0x66, 0x34, 0x32, 0x65, 0x32, 0x66, 0x38, 0x30, 0x38, 0x64, 0x65, 0x36, 0x31, 0x61, 0x36, 0x64, 0x62, 0x31, 0x34, 0x38, 0x36, 0x63, 0x63, 0x38, 0x38, 0x30, 0x30, 0x30, 0x62, 0x31, 0x61, 0x32, 0x37, 0x30, 0x64, 0x39, 0x38, 0x30, 0x37, 0x36, 0x34, 0x34, 0x38, 0x37, 0x36, 0x61, 0x35, 0x33, 0x64, 0x39, 0x63, 0x62, 0x66, 0x35, 0x35, 0x38, 0x63, 0x66, 0x38, 0x61, 0x64, 0x61, 0x33, 0x37, 0x37, 0x62, 0x61, 0x65, 0x31, 0x36, 0x62, 0x38, 0x31, 0x31, 0x33, 0x38, 0x61, 0x65, 0x31, 0x33, 0x34, 0x34, 0x36, 0x34, 0x32, 0x65, 0x38, 0x37, 0x38, 0x30, 0x31, 0x63, 0x33, 0x33, 0x33, 0x62, 0x38, 0x30, 0x32, 0x65, 0x61, 0x30, 0x35, 0x65, 0x63, 0x32, 0x66, 0x39, 0x63, 0x36, 0x61, 0x61, 0x64, 0x36, 0x62, 0x30, 0x63, 0x32, 0x39, 0x66, 0x61, 0x31, 0x31, 0x30, 0x31, 0x38, 0x34, 0x31, 0x64, 0x38, 0x61, 0x36, 0x38, 0x36, 0x37, 0x32, 0x65, 0x39, 0x65, 0x34, 0x37, 0x36, 0x33, 0x32, 0x36, 0x35, 0x31, 0x64, 0x34, 0x37, 0x39, 0x62, 0x64, 0x65, 0x30, 0x33, 0x33, 0x65, 0x35, 0x34, 0x39, 0x33, 0x36, 0x30, 0x62, 0x39, 0x36, 0x38, 0x34, 0x33, 0x36, 0x33, 0x36, 0x32, 0x35, 0x30, 0x33, 0x62, 0x64, 0x30, 0x34, 0x36, 0x38, 0x34, 0x35, 0x38, 0x64, 0x34, 0x35, 0x34, 0x38, 0x33, 0x38, 0x38, 0x65, 0x66, 0x35, 0x31, 0x35, 0x65, 0x31, 0x64, 0x36, 0x32, 0x38, 0x34, 0x36, 0x61, 0x35, 0x31, 0x66, 0x38, 0x36, 0x61, 0x63, 0x35, 0x33, 0x32, 0x62, 0x36, 0x34, 0x39, 0x61, 0x61, 0x33, 0x35, 0x37, 0x32, 0x61, 0x30, 0x38, 0x64, 0x64, 0x66, 0x39, 0x31, 0x30, 0x36, 0x61, 0x31, 0x61, 0x62, 0x34, 0x65, 0x64, 0x66, 0x65, 0x33, 0x62, 0x34, 0x33, 0x62, 0x66, 0x32, 0x66, 0x37, 0x64, 0x38, 0x64, 0x31, 0x66, 0x34, 0x32, 0x65, 0x37, 0x33, 0x36, 0x37, 0x31, 0x64, 0x32, 0x66, 0x65, 0x32, 0x33, 0x32, 0x39, 0x33, 0x64, 0x34, 0x38, 0x63, 0x65, 0x32, 0x30, 0x63, 0x62, 0x36, 0x63, 0x36, 0x36, 0x33, 0x66, 0x61, 0x34, 0x37, 0x63, 0x32, 0x38, 0x31, 0x65, 0x62, 0x62, 0x37, 0x62, 0x63, 0x31, 0x39, 0x39, 0x39, 0x33, 0x39, 0x62, 0x33, 0x65, 0x61, 0x64, 0x66, 0x33, 0x38, 0x63, 0x64, 0x31, 0x62, 0x38, 0x38, 0x64, 0x34, 0x61, 0x62, 0x31, 0x61, 0x63, 0x65, 0x31, 0x33, 0x66, 0x33, 0x31, 0x34, 0x65, 0x37, 0x64, 0x65, 0x65, 0x34, 0x62, 0x65, 0x38, 0x36, 0x32, 0x65, 0x30, 0x37, 0x32, 0x32, 0x33, 0x38, 0x33, 0x30, 0x31, 0x62, 0x64, 0x33, 0x66, 0x66, 0x65, 0x63, 0x31, 0x63, 0x64, 0x64, 0x64, 0x65, 0x63, 0x36, 0x63, 0x61, 0x66, 0x31, 0x62, 0x31, 0x36, 0x35, 0x66, 0x32, 0x63, 0x36, 0x64, 0x35, 0x66, 0x65, 0x32, 0x35, 0x37, 0x64, 0x63, 0x32, 0x61, 0x66, 0x61, 0x32, 0x36, 0x32, 0x33, 0x37, 0x36, 0x63, 0x31, 0x63, 0x33, 0x39, 0x62, 0x38, 0x65, 0x35, 0x66, 0x32, 0x62, 0x62, 0x39, 0x37, 0x63, 0x36, 0x65, 0x30, 0x33, 0x30, 0x64, 0x66, 0x31, 0x63, 0x34, 0x35, 0x38, 0x64, 0x63, 0x37, 0x61, 0x64, 0x65, 0x64, 0x31, 0x32, 0x33, 0x63, 0x30, 0x31, 0x34, 0x33, 0x61, 0x64, 0x63, 0x62, 0x65, 0x36, 0x65, 0x36, 0x34, 0x62, 0x62, 0x61, 0x62, 0x32, 0x30, 0x36, 0x36, 0x39, 0x63, 0x37, 0x64, 0x38, 0x62, 0x39, 0x64, 0x62, 0x66, 0x39, 0x33, 0x30, 0x31, 0x36, 0x63, 0x61, 0x31, 0x36, 0x35, 0x36, 0x36, 0x65, 0x62, 0x34, 0x66, 0x65, 0x66, 0x39, 0x38, 0x31, 0x30, 0x31, 0x66, 0x64, 0x31, 0x36, 0x35, 0x37, 0x36, 0x32, 0x35, 0x35, 0x63, 0x34, 0x31, 0x32, 0x34, 0x34, 0x63, 0x66, 0x30, 0x38, 0x30, 0x36, 0x33, 0x33, 0x38, 0x31, 0x61, 0x66, 0x33, 0x32, 0x61, 0x37, 0x66, 0x66, 0x34, 0x63, 0x62, 0x36, 0x33, 0x63, 0x66, 0x34, 0x65, 0x32, 0x37, 0x37, 0x32, 0x65, 0x39, 0x64, 0x36, 0x33, 0x30, 0x61, 0x33, 0x65, 0x66, 0x39, 0x33, 0x63, 0x35, 0x37, 0x38, 0x38, 0x38, 0x36, 0x35, 0x34, 0x38, 0x65, 0x38, 0x30, 0x30, 0x35, 0x33, 0x39, 0x34, 0x36, 0x38, 0x32, 0x36, 0x31, 0x38, 0x36, 0x61, 0x32, 0x35, 0x32, 0x63, 0x61, 0x63, 0x63, 0x31, 0x31, 0x61, 0x63, 0x61, 0x66, 0x65, 0x32, 0x36, 0x38, 0x35, 0x66, 0x34, 0x63, 0x63, 0x62, 0x63, 0x37, 0x32, 0x61, 0x31, 0x33, 0x33, 0x33, 0x39, 0x31, 0x62, 0x61, 0x36, 0x34, 0x61, 0x61, 0x35, 0x32, 0x37, 0x32, 0x34, 0x36, 0x38, 0x36, 0x64, 0x32, 0x64, 0x32, 0x65, 0x33, 0x31, 0x39, 0x32, 0x36, 0x38, 0x63, 0x38, 0x66, 0x35, 0x64, 0x66, 0x31, 0x31, 0x63, 0x32, 0x35, 0x61, 0x36, 0x33, 0x34, 0x36, 0x61, 0x32, 0x65, 0x34, 0x30, 0x65, 0x61, 0x38, 0x39, 0x31, 0x63, 0x38, 0x31, 0x66, 0x33, 0x33, 0x37, 0x36, 0x63, 0x31, 0x31, 0x32, 0x66, 0x39, 0x33, 0x33, 0x62, 0x37, 0x39, 0x66, 0x35, 0x61, 0x38, 0x31, 0x66, 0x30, 0x31, 0x63, 0x39, 0x37, 0x37, 0x32, 0x39, 0x62, 0x62, 0x64, 0x30, 0x35, 0x61, 0x30, 0x64, 0x36, 0x63, 0x33, 0x31, 0x35, 0x65, 0x37, 0x33, 0x65, 0x38, 0x66, 0x31, 0x61, 0x33, 0x36, 0x65, 0x61, 0x64, 0x37, 0x37, 0x63, 0x63, 0x35, 0x33, 0x66, 0x33, 0x36, 0x33, 0x33, 0x63, 0x32, 0x38, 0x61, 0x39, 0x61, 0x66, 0x31, 0x35, 0x35, 0x63, 0x63, 0x34, 0x66, 0x35, 0x64, 0x34, 0x64, 0x31, 0x32, 0x61, 0x62, 0x63, 0x63, 0x31, 0x31, 0x32, 0x30, 0x66, 0x35, 0x35, 0x38, 0x39, 0x64, 0x39, 0x39, 0x66, 0x66, 0x62, 0x61, 0x33, 0x30, 0x63, 0x65, 0x63, 0x34, 0x31, 0x37, 0x34, 0x64, 0x35, 0x66, 0x65, 0x64, 0x38, 0x36, 0x38, 0x32, 0x39, 0x39, 0x62, 0x38, 0x37, 0x32, 0x38, 0x39, 0x39, 0x33, 0x32, 0x35, 0x66, 0x38, 0x34, 0x64, 0x66, 0x30, 0x64, 0x63, 0x61, 0x66, 0x64, 0x65, 0x36, 0x39, 0x34, 0x65, 0x33, 0x62, 0x31, 0x36, 0x62, 0x31, 0x30, 0x33, 0x66, 0x32, 0x35, 0x65, 0x31, 0x61, 0x33, 0x36, 0x61, 0x66, 0x65, 0x32, 0x66, 0x37, 0x39, 0x33, 0x63, 0x33, 0x65, 0x35, 0x30, 0x30, 0x30, 0x66, 0x33, 0x63, 0x36, 0x38, 0x39, 0x63, 0x36, 0x66, 0x37, 0x32, 0x64, 0x37, 0x38, 0x65, 0x66, 0x66, 0x35, 0x35, 0x32, 0x65, 0x35, 0x64, 0x63, 0x61, 0x33, 0x63, 0x62, 0x36, 0x62, 0x63, 0x32, 0x31, 0x38, 0x64, 0x33, 0x66, 0x32, 0x66, 0x65, 0x32, 0x66, 0x33, 0x63, 0x37, 0x65, 0x66, 0x31, 0x31, 0x37, 0x61, 0x62, 0x31, 0x30, 0x66, 0x36, 0x39, 0x61, 0x36, 0x35, 0x35, 0x64, 0x39, 0x35, 0x31, 0x66, 0x34, 0x64, 0x35, 0x63, 0x35, 0x62, 0x36, 0x35, 0x61, 0x30, 0x64, 0x32, 0x32, 0x35, 0x62, 0x61, 0x32, 0x37, 0x33, 0x32, 0x36, 0x63, 0x66, 0x30, 0x30, 0x32, 0x35, 0x32, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x63, 0x30, 0x65, 0x31, 0x33, 0x66, 0x36, 0x30, 0x64, 0x62, 0x34, 0x34, 0x37, 0x66, 0x34, 0x33, 0x63, 0x35, 0x37, 0x65, 0x34, 0x30, 0x38, 0x62, 0x61, 0x33, 0x30, 0x66, 0x32, 0x65, 0x64, 0x38, 0x64, 0x63, 0x65, 0x35, 0x62, 0x37, 0x32, 0x30, 0x66, 0x39, 0x65, 0x33, 0x31, 0x38, 0x34, 0x61, 0x30, 0x35, 0x33, 0x62, 0x38, 0x34, 0x31, 0x66, 0x32, 0x33, 0x66, 0x65, 0x37, 0x34, 0x62, 0x30, 0x31, 0x35, 0x66, 0x30, 0x39, 0x30, 0x36, 0x63, 0x36, 0x34, 0x31, 0x66, 0x37, 0x32, 0x38, 0x34, 0x39, 0x36, 0x35, 0x66, 0x66, 0x66, 0x34, 0x36, 0x64, 0x63, 0x36, 0x64, 0x61, 0x32, 0x33, 0x63, 0x66, 0x33, 0x61, 0x65, 0x31, 0x33, 0x31, 0x66, 0x33, 0x39, 0x63, 0x34, 0x30, 0x36, 0x64, 0x66, 0x64, 0x65, 0x62, 0x36, 0x39, 0x30, 0x64, 0x32, 0x30, 0x37, 0x64, 0x66, 0x33, 0x61, 0x38, 0x32, 0x64, 0x36, 0x38, 0x66, 0x36, 0x37, 0x33, 0x65, 0x65, 0x66, 0x35, 0x61, 0x65, 0x64, 0x62, 0x32, 0x35, 0x35, 0x36, 0x33, 0x62, 0x63, 0x66, 0x62, 0x32, 0x31, 0x32, 0x62, 0x66, 0x31, 0x36, 0x64, 0x39, 0x65, 0x33, 0x30, 0x66, 0x30, 0x36, 0x63, 0x66, 0x37, 0x33, 0x63, 0x37, 0x62, 0x33, 0x39, 0x32, 0x30, 0x36, 0x38, 0x63, 0x39, 0x65, 0x33, 0x33, 0x35, 0x65, 0x63, 0x35, 0x31, 0x65, 0x36, 0x66, 0x63, 0x30, 0x65, 0x61, 0x34, 0x63, 0x34, 0x61, 0x31, 0x63, 0x61, 0x66, 0x61, 0x61, 0x63, 0x62, 0x38, 0x61, 0x38, 0x66, 0x64, 0x32, 0x32, 0x62, 0x30, 0x63, 0x32, 0x64, 0x64, 0x33, 0x64, 0x30, 0x32, 0x65, 0x33, 0x30, 0x37, 0x32, 0x32, 0x64, 0x34, 0x37, 0x63, 0x38, 0x30, 0x65, 0x30, 0x30, 0x66, 0x32, 0x62, 0x34, 0x32, 0x37, 0x31, 0x61, 0x30, 0x32, 0x64, 0x37, 0x63, 0x63, 0x64, 0x35, 0x31, 0x64, 0x37, 0x30, 0x38, 0x32, 0x34, 0x39, 0x33, 0x61, 0x37, 0x64, 0x66, 0x61, 0x65, 0x32, 0x31, 0x62, 0x36, 0x37, 0x63, 0x63, 0x31, 0x39, 0x37, 0x31, 0x64, 0x66, 0x39, 0x30, 0x33, 0x39, 0x36, 0x39, 0x65, 0x36, 0x37, 0x32, 0x63, 0x63, 0x34, 0x32, 0x37, 0x66, 0x35, 0x61, 0x66, 0x64, 0x38, 0x64, 0x63, 0x66, 0x34, 0x62, 0x32, 0x33, 0x32, 0x65, 0x32, 0x32, 0x33, 0x62, 0x33, 0x32, 0x35, 0x30, 0x37, 0x34, 0x64, 0x36, 0x63, 0x37, 0x36, 0x63, 0x32, 0x63, 0x34, 0x32, 0x36, 0x32, 0x66, 0x39, 0x38, 0x33, 0x33, 0x38, 0x33, 0x31, 0x65, 0x65, 0x39, 0x30, 0x62, 0x33, 0x34, 0x37, 0x36, 0x35, 0x63, 0x37, 0x35, 0x35, 0x31, 0x38, 0x32, 0x61, 0x33, 0x64, 0x35, 0x63, 0x61, 0x62, 0x39, 0x61, 0x61, 0x64, 0x34, 0x61, 0x35, 0x61, 0x39, 0x64, 0x35, 0x62, 0x32, 0x38, 0x65, 0x39, 0x32, 0x62, 0x64, 0x32, 0x65, 0x35, 0x31, 0x35, 0x34, 0x64, 0x35, 0x35, 0x30, 0x36, 0x61, 0x37, 0x34, 0x64, 0x31, 0x37, 0x61, 0x32, 0x65, 0x63, 0x33, 0x31, 0x64, 0x64, 0x35, 0x62, 0x33, 0x35, 0x33, 0x38, 0x61, 0x32, 0x32, 0x66, 0x36, 0x66, 0x36, 0x36, 0x65, 0x66, 0x63, 0x31, 0x35, 0x37, 0x33, 0x37, 0x35, 0x30, 0x38, 0x64, 0x30, 0x39, 0x37, 0x62, 0x62, 0x38, 0x33, 0x36, 0x61, 0x62, 0x63, 0x31, 0x63, 0x35, 0x39, 0x38, 0x62, 0x61, 0x33, 0x62, 0x35, 0x61, 0x32, 0x36, 0x66, 0x33, 0x34, 0x30, 0x36, 0x64, 0x61, 0x62, 0x34, 0x32, 0x62, 0x61, 0x39, 0x33, 0x38, 0x30, 0x66, 0x65, 0x62, 0x35, 0x30, 0x66, 0x33, 0x61, 0x31, 0x37, 0x64, 0x38, 0x63, 0x61, 0x32, 0x38, 0x66, 0x61, 0x34, 0x63, 0x65, 0x33, 0x31, 0x37, 0x36, 0x34, 0x32, 0x65, 0x36, 0x31, 0x37, 0x36, 0x63, 0x34, 0x36, 0x36, 0x38, 0x34, 0x32, 0x63, 0x31, 0x33, 0x34, 0x30, 0x33, 0x36, 0x64, 0x31, 0x35, 0x65, 0x30, 0x36, 0x32, 0x61, 0x37, 0x65, 0x31, 0x34, 0x64, 0x36, 0x66, 0x34, 0x32, 0x39, 0x33, 0x66, 0x31, 0x62, 0x32, 0x34, 0x37, 0x32, 0x64, 0x61, 0x64, 0x34, 0x38, 0x63, 0x37, 0x63, 0x30, 0x39, 0x64, 0x35, 0x63, 0x61, 0x33, 0x32, 0x32, 0x30, 0x61, 0x33, 0x30, 0x35, 0x61, 0x66, 0x31, 0x39, 0x33, 0x31, 0x64, 0x32, 0x31, 0x36, 0x66, 0x64, 0x66, 0x36, 0x39, 0x34, 0x39, 0x35, 0x63, 0x32, 0x38, 0x62, 0x33, 0x34, 0x32, 0x30, 0x38, 0x65, 0x38, 0x34, 0x39, 0x37, 0x35, 0x33, 0x66, 0x34, 0x31, 0x61, 0x34, 0x61, 0x37, 0x32, 0x66, 0x66, 0x34, 0x38, 0x33, 0x30, 0x31, 0x35, 0x36, 0x33, 0x36, 0x37, 0x37, 0x38, 0x66, 0x31, 0x35, 0x39, 0x30, 0x34, 0x32, 0x32, 0x62, 0x37, 0x38, 0x33, 0x34, 0x39, 0x37, 0x35, 0x33, 0x39, 0x66, 0x36, 0x31, 0x39, 0x65, 0x33, 0x37, 0x62, 0x62, 0x33, 0x35, 0x62, 0x38, 0x61, 0x66, 0x39, 0x35, 0x61, 0x36, 0x64, 0x31, 0x31, 0x35, 0x31, 0x62, 0x31, 0x35, 0x35, 0x37, 0x64, 0x37, 0x32, 0x30, 0x64, 0x30, 0x31, 0x65, 0x65, 0x36, 0x39, 0x30, 0x33, 0x34, 0x37, 0x64, 0x39, 0x30, 0x32, 0x62, 0x31, 0x35, 0x63, 0x32, 0x34, 0x33, 0x33, 0x37, 0x63, 0x64, 0x30, 0x37, 0x33, 0x36, 0x32, 0x66, 0x63, 0x39, 0x31, 0x37, 0x35, 0x66, 0x63, 0x30, 0x65, 0x38, 0x61, 0x66, 0x37, 0x64, 0x38, 0x64, 0x33, 0x35, 0x39, 0x35, 0x30, 0x37, 0x66, 0x32, 0x33, 0x39, 0x36, 0x35, 0x36, 0x30, 0x36, 0x33, 0x35, 0x33, 0x37, 0x62, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x64, 0x61, 0x61, 0x63, 0x66, 0x39, 0x66, 0x35, 0x32, 0x32, 0x32, 0x33, 0x34, 0x31, 0x31, 0x62, 0x37, 0x63, 0x35, 0x63, 0x64, 0x38, 0x35, 0x65, 0x30, 0x34, 0x30, 0x65, 0x31, 0x39, 0x38, 0x33, 0x63, 0x31, 0x63, 0x32, 0x30, 0x35, 0x30, 0x36, 0x62, 0x34, 0x38, 0x61, 0x65, 0x38, 0x32, 0x37, 0x32, 0x34, 0x63, 0x36, 0x63, 0x66, 0x33, 0x32, 0x39, 0x64, 0x62, 0x39, 0x38, 0x33, 0x63, 0x32, 0x31, 0x35, 0x63, 0x30, 0x35, 0x35, 0x61, 0x30, 0x64, 0x37, 0x39, 0x36, 0x38, 0x35, 0x64, 0x37, 0x38, 0x32, 0x35, 0x65, 0x31, 0x63, 0x65, 0x65, 0x37, 0x61, 0x31, 0x34, 0x30, 0x30, 0x32, 0x62, 0x35, 0x37, 0x62, 0x65, 0x38, 0x31, 0x39, 0x62, 0x65, 0x32, 0x30, 0x38, 0x33, 0x31, 0x36, 0x37, 0x32, 0x32, 0x31, 0x35, 0x39, 0x39, 0x37, 0x33, 0x31, 0x63, 0x65, 0x31, 0x34, 0x38, 0x34, 0x33, 0x37, 0x38, 0x61, 0x30, 0x38, 0x30, 0x30, 0x35, 0x34, 0x62, 0x39, 0x37, 0x34, 0x34, 0x61, 0x38, 0x65, 0x63, 0x66, 0x39, 0x65, 0x31, 0x36, 0x61, 0x35, 0x36, 0x63, 0x38, 0x30, 0x33, 0x62, 0x37, 0x36, 0x64, 0x30, 0x66, 0x31, 0x64, 0x39, 0x64, 0x63, 0x36, 0x65, 0x30, 0x33, 0x39, 0x61, 0x36, 0x30, 0x63, 0x30, 0x37, 0x64, 0x62, 0x65, 0x33, 0x31, 0x61, 0x34, 0x37, 0x36, 0x31, 0x65, 0x33, 0x33, 0x65, 0x38, 0x61, 0x34, 0x31, 0x62, 0x34, 0x65, 0x65, 0x30, 0x36, 0x37, 0x37, 0x35, 0x33, 0x36, 0x63, 0x63, 0x35, 0x66, 0x63, 0x38, 0x63, 0x36, 0x66, 0x66, 0x61, 0x62, 0x62, 0x63, 0x66, 0x35, 0x38, 0x65, 0x37, 0x30, 0x37, 0x36, 0x61, 0x64, 0x38, 0x32, 0x66, 0x32, 0x63, 0x33, 0x34, 0x31, 0x32, 0x33, 0x62, 0x34, 0x32, 0x38, 0x62, 0x64, 0x62, 0x32, 0x66, 0x34, 0x31, 0x36, 0x65, 0x32, 0x37, 0x38, 0x64, 0x39, 0x35, 0x34, 0x37, 0x34, 0x64, 0x61, 0x63, 0x35, 0x30, 0x34, 0x39, 0x62, 0x63, 0x33, 0x35, 0x38, 0x36, 0x31, 0x34, 0x66, 0x30, 0x35, 0x33, 0x36, 0x35, 0x64, 0x36, 0x30, 0x35, 0x31, 0x36, 0x32, 0x66, 0x33, 0x37, 0x31, 0x61, 0x36, 0x63, 0x62, 0x39, 0x39, 0x37, 0x32, 0x65, 0x66, 0x66, 0x65, 0x31, 0x31, 0x30, 0x34, 0x62, 0x32, 0x65, 0x38, 0x37, 0x33, 0x35, 0x32, 0x61, 0x66, 0x38, 0x61, 0x34, 0x31, 0x38, 0x30, 0x35, 0x65, 0x30, 0x61, 0x32, 0x32, 0x37, 0x63, 0x35, 0x35, 0x36, 0x63, 0x64, 0x63, 0x32, 0x38, 0x33, 0x38, 0x64, 0x33, 0x31, 0x38, 0x37, 0x35, 0x37, 0x34, 0x64, 0x37, 0x38, 0x62, 0x63, 0x66, 0x36, 0x65, 0x30, 0x33, 0x66, 0x63, 0x37, 0x32, 0x39, 0x62, 0x66, 0x63, 0x30, 0x61, 0x38, 0x30, 0x30, 0x64, 0x65, 0x37, 0x62, 0x39, 0x31, 0x35, 0x64, 0x61, 0x65, 0x37, 0x61, 0x39, 0x66, 0x33, 0x64, 0x33, 0x35, 0x39, 0x35, 0x33, 0x36, 0x65, 0x36, 0x33, 0x31, 0x37, 0x32, 0x39, 0x66, 0x32, 0x65, 0x39, 0x34, 0x35, 0x34, 0x61, 0x33, 0x35, 0x37, 0x37, 0x38, 0x61, 0x31, 0x34, 0x31, 0x64, 0x38, 0x36, 0x36, 0x36, 0x31, 0x34, 0x34, 0x33, 0x66, 0x35, 0x62, 0x33, 0x62, 0x66, 0x34, 0x66, 0x34, 0x30, 0x32, 0x62, 0x36, 0x62, 0x64, 0x30, 0x38, 0x32, 0x66, 0x63, 0x38, 0x33, 0x66, 0x38, 0x39, 0x37, 0x39, 0x33, 0x38, 0x61, 0x32, 0x36, 0x39, 0x37, 0x39, 0x35, 0x63, 0x38, 0x30, 0x64, 0x34, 0x62, 0x66, 0x65, 0x33, 0x34, 0x32, 0x62, 0x34, 0x36, 0x62, 0x65, 0x64, 0x61, 0x66, 0x65, 0x33, 0x36, 0x31, 0x62, 0x65, 0x61, 0x37, 0x32, 0x35, 0x65, 0x39, 0x39, 0x63, 0x38, 0x66, 0x32, 0x66, 0x61, 0x31, 0x64, 0x30, 0x30, 0x63, 0x38, 0x61, 0x34, 0x65, 0x30, 0x34, 0x61, 0x33, 0x38, 0x65, 0x64, 0x61, 0x64, 0x39, 0x65, 0x61, 0x62, 0x36, 0x32, 0x36, 0x37, 0x64, 0x65, 0x34, 0x35, 0x39, 0x66, 0x64, 0x38, 0x36, 0x33, 0x35, 0x63, 0x65, 0x32, 0x30, 0x35, 0x62, 0x63, 0x39, 0x32, 0x62, 0x32, 0x65, 0x34, 0x38, 0x38, 0x30, 0x33, 0x37, 0x64, 0x32, 0x33, 0x35, 0x35, 0x39, 0x63, 0x30, 0x30, 0x37, 0x63, 0x63, 0x37, 0x35, 0x62, 0x65, 0x34, 0x35, 0x65, 0x38, 0x63, 0x64, 0x61, 0x62, 0x32, 0x63, 0x38, 0x61, 0x37, 0x64, 0x32, 0x36, 0x31, 0x61, 0x33, 0x65, 0x64, 0x33, 0x32, 0x64, 0x62, 0x62, 0x34, 0x37, 0x62, 0x64, 0x30, 0x35, 0x32, 0x34, 0x36, 0x36, 0x34, 0x35, 0x32, 0x64, 0x36, 0x30, 0x64, 0x31, 0x63, 0x37, 0x32, 0x62, 0x38, 0x36, 0x33, 0x37, 0x39, 0x61, 0x33, 0x66, 0x65, 0x36, 0x32, 0x30, 0x35, 0x31, 0x33, 0x38, 0x38, 0x35, 0x36, 0x37, 0x62, 0x33, 0x33, 0x39, 0x63, 0x66, 0x66, 0x34, 0x35, 0x35, 0x61, 0x32, 0x37, 0x36, 0x65, 0x37, 0x64, 0x36, 0x65, 0x65, 0x35, 0x30, 0x37, 0x35, 0x61, 0x66, 0x36, 0x34, 0x62, 0x66, 0x35, 0x32, 0x37, 0x34, 0x36, 0x39, 0x61, 0x36, 0x31, 0x36, 0x30, 0x34, 0x39, 0x37, 0x38, 0x36, 0x30, 0x37, 0x30, 0x65, 0x65, 0x66, 0x33, 0x36, 0x36, 0x66, 0x37, 0x33, 0x39, 0x65, 0x34, 0x37, 0x38, 0x37, 0x61, 0x63, 0x35, 0x32, 0x34, 0x32, 0x39, 0x64, 0x65, 0x61, 0x35, 0x33, 0x61, 0x32, 0x31, 0x35, 0x33, 0x36, 0x32, 0x62, 0x30, 0x66, 0x66, 0x61, 0x37, 0x32, 0x63, 0x39, 0x34, 0x30, 0x39, 0x33, 0x64, 0x66, 0x37, 0x66, 0x37, 0x35, 0x31, 0x61, 0x34, 0x30, 0x30, 0x30, 0x64, 0x33, 0x64, 0x66, 0x38, 0x31, 0x65, 0x61, 0x34, 0x31, 0x31, 0x34, 0x61, 0x65, 0x36, 0x34, 0x66, 0x39, 0x33, 0x30, 0x31, 0x31, 0x61, 0x31, 0x32, 0x66, 0x35, 0x32, 0x66, 0x38, 0x61, 0x38, 0x37, 0x36, 0x62, 0x64, 0x34, 0x33, 0x63, 0x65, 0x64, 0x64, 0x62, 0x63, 0x36, 0x33, 0x30, 0x34, 0x63, 0x64, 0x35, 0x64, 0x35, 0x64, 0x39, 0x61, 0x39, 0x33, 0x36, 0x30, 0x64, 0x34, 0x38, 0x64, 0x31, 0x37, 0x66, 0x62, 0x65, 0x38, 0x66, 0x63, 0x38, 0x31, 0x34, 0x62, 0x39, 0x37, 0x65, 0x61, 0x31, 0x64, 0x64, 0x62, 0x62, 0x62, 0x34, 0x30, 0x34, 0x30, 0x62, 0x62, 0x61, 0x66, 0x64, 0x34, 0x38, 0x36, 0x38, 0x35, 0x32, 0x37, 0x36, 0x30, 0x62, 0x64, 0x31, 0x35, 0x63, 0x32, 0x38, 0x35, 0x32, 0x30, 0x36, 0x32, 0x37, 0x36, 0x63, 0x36, 0x66, 0x30, 0x37, 0x36, 0x34, 0x37, 0x32, 0x39, 0x63, 0x65, 0x38, 0x38, 0x36, 0x39, 0x64, 0x32, 0x34, 0x30, 0x33, 0x63, 0x31, 0x38, 0x38, 0x62, 0x34, 0x64, 0x34, 0x32, 0x31, 0x37, 0x34, 0x61, 0x34, 0x65, 0x31, 0x30, 0x36, 0x31, 0x62, 0x62, 0x64, 0x31, 0x30, 0x62, 0x64, 0x61, 0x61, 0x30, 0x37, 0x30, 0x38, 0x32, 0x65, 0x65, 0x36, 0x34, 0x66, 0x66, 0x66, 0x30, 0x63, 0x35, 0x66, 0x64, 0x63, 0x65, 0x64, 0x64, 0x66, 0x37, 0x32, 0x30, 0x31, 0x37, 0x63, 0x34, 0x31, 0x62, 0x64, 0x66, 0x63, 0x64, 0x34, 0x66, 0x36, 0x32, 0x34, 0x39, 0x66, 0x65, 0x63, 0x39, 0x33, 0x62, 0x36, 0x35, 0x63, 0x61, 0x37, 0x63, 0x31, 0x36, 0x64, 0x66, 0x35, 0x61, 0x65, 0x37, 0x34, 0x62, 0x37, 0x38, 0x35, 0x37, 0x30, 0x32, 0x62, 0x31, 0x66, 0x63, 0x65, 0x64, 0x30, 0x38, 0x62, 0x36, 0x32, 0x37, 0x35, 0x63, 0x32, 0x64, 0x33, 0x37, 0x32, 0x30, 0x66, 0x31, 0x38, 0x36, 0x39, 0x62, 0x64, 0x33, 0x31, 0x37, 0x36, 0x30, 0x63, 0x65, 0x31, 0x30, 0x37, 0x30, 0x62, 0x63, 0x61, 0x64, 0x62, 0x61, 0x30, 0x64, 0x36, 0x33, 0x65, 0x37, 0x38, 0x34, 0x64, 0x38, 0x33, 0x39, 0x32, 0x62, 0x35, 0x30, 0x64, 0x35, 0x38, 0x66, 0x65, 0x31, 0x36, 0x32, 0x33, 0x66, 0x62, 0x31, 0x66, 0x31, 0x31, 0x36, 0x38, 0x61, 0x35, 0x31, 0x31, 0x30, 0x39, 0x66, 0x64, 0x64, 0x61, 0x34, 0x66, 0x36, 0x34, 0x66, 0x65, 0x38, 0x37, 0x35, 0x66, 0x31, 0x61, 0x65, 0x37, 0x35, 0x65, 0x33, 0x63, 0x63, 0x38, 0x34, 0x37, 0x66, 0x33, 0x38, 0x63, 0x35, 0x36, 0x35, 0x30, 0x64, 0x37, 0x35, 0x31, 0x62, 0x65, 0x31, 0x37, 0x63, 0x34, 0x64, 0x37, 0x64, 0x64, 0x66, 0x38, 0x31, 0x64, 0x66, 0x61, 0x36, 0x34, 0x39, 0x30, 0x39, 0x63, 0x39, 0x65, 0x30, 0x38, 0x61, 0x63, 0x65, 0x34, 0x33, 0x38, 0x61, 0x63, 0x61, 0x65, 0x33, 0x30, 0x37, 0x37, 0x61, 0x61, 0x34, 0x32, 0x64, 0x31, 0x37, 0x62, 0x62, 0x37, 0x31, 0x66, 0x31, 0x35, 0x38, 0x35, 0x37, 0x39, 0x65, 0x66, 0x64, 0x30, 0x63, 0x66, 0x39, 0x35, 0x66, 0x39, 0x66, 0x37, 0x64, 0x62, 0x37, 0x39, 0x65, 0x33, 0x63, 0x37, 0x33, 0x64, 0x63, 0x64, 0x38, 0x35, 0x65, 0x32, 0x37, 0x30, 0x32, 0x33, 0x63, 0x39, 0x66, 0x31, 0x31, 0x61, 0x34, 0x34, 0x65, 0x35, 0x64, 0x39, 0x64, 0x31, 0x37, 0x66, 0x32, 0x33, 0x62, 0x37, 0x64, 0x62, 0x32, 0x34, 0x65, 0x35, 0x31, 0x63, 0x65, 0x61, 0x39, 0x64, 0x65, 0x35, 0x32, 0x61, 0x35, 0x37, 0x31, 0x64, 0x63, 0x30, 0x39, 0x37, 0x64, 0x31, 0x64, 0x36, 0x31, 0x31, 0x62, 0x63, 0x65, 0x34, 0x31, 0x61, 0x39, 0x34, 0x65, 0x36, 0x36, 0x36, 0x37, 0x32, 0x30, 0x35, 0x34, 0x62, 0x30, 0x30, 0x62, 0x37, 0x36, 0x62, 0x64, 0x64, 0x39, 0x66, 0x37, 0x39, 0x34, 0x37, 0x34, 0x39, 0x64, 0x65, 0x35, 0x64, 0x36, 0x32, 0x33, 0x34, 0x62, 0x64, 0x39, 0x39, 0x35, 0x38, 0x30, 0x30, 0x32, 0x32, 0x32, 0x61, 0x65, 0x62, 0x66, 0x38, 0x32, 0x37, 0x32, 0x62, 0x36, 0x30, 0x38, 0x34, 0x37, 0x62, 0x64, 0x34, 0x31, 0x39, 0x30, 0x62, 0x63, 0x38, 0x35, 0x32, 0x63, 0x31, 0x32, 0x61, 0x33, 0x65, 0x65, 0x63, 0x37, 0x39, 0x63, 0x63, 0x65, 0x39, 0x63, 0x31, 0x65, 0x35, 0x64, 0x63, 0x63, 0x36, 0x31, 0x61, 0x63, 0x32, 0x62, 0x33, 0x62, 0x36, 0x31, 0x30, 0x32, 0x61, 0x61, 0x61, 0x32, 0x36, 0x31, 0x62, 0x64, 0x35, 0x63, 0x38, 0x34, 0x31, 0x35, 0x32, 0x62, 0x62, 0x62, 0x31, 0x33, 0x32, 0x65, 0x61, 0x32, 0x65, 0x36, 0x34, 0x66, 0x63, 0x35, 0x36, 0x34, 0x36, 0x32, 0x32, 0x66, 0x37, 0x37, 0x39, 0x32, 0x31, 0x38, 0x33, 0x62, 0x34, 0x66, 0x65, 0x31, 0x31, 0x34, 0x35, 0x38, 0x34, 0x38, 0x38, 0x31, 0x35, 0x31, 0x64, 0x65, 0x66, 0x35, 0x62, 0x30, 0x38, 0x37, 0x64, 0x38, 0x32, 0x34, 0x66, 0x33, 0x36, 0x38, 0x61, 0x31, 0x38, 0x38, 0x30, 0x32, 0x65, 0x65, 0x36, 0x32, 0x32, 0x33, 0x61, 0x32, 0x62, 0x64, 0x61, 0x37, 0x36, 0x35, 0x39, 0x36, 0x37, 0x35, 0x39, 0x34, 0x32, 0x33, 0x65, 0x32, 0x30, 0x37, 0x39, 0x37, 0x65, 0x30, 0x63, 0x35, 0x64, 0x32, 0x34, 0x34, 0x32, 0x63, 0x64, 0x63, 0x65, 0x31, 0x37, 0x35, 0x37, 0x32, 0x35, 0x63, 0x66, 0x64, 0x33, 0x33, 0x36, 0x33, 0x38, 0x33, 0x36, 0x66, 0x38, 0x65, 0x32, 0x32, 0x37, 0x31, 0x64, 0x36, 0x62, 0x33, 0x64, 0x30, 0x63, 0x34, 0x36, 0x32, 0x32, 0x63, 0x34, 0x37, 0x32, 0x36, 0x63, 0x34, 0x32, 0x64, 0x63, 0x33, 0x39, 0x66, 0x31, 0x35, 0x36, 0x35, 0x35, 0x37, 0x37, 0x62, 0x66, 0x39, 0x39, 0x62, 0x38, 0x65, 0x64, 0x39, 0x66, 0x38, 0x61, 0x32, 0x36, 0x39, 0x64, 0x36, 0x63, 0x32, 0x33, 0x65, 0x31, 0x62, 0x31, 0x37, 0x34, 0x62, 0x62, 0x35, 0x37, 0x36, 0x38, 0x37, 0x39, 0x35, 0x30, 0x34, 0x39, 0x64, 0x31, 0x31, 0x65, 0x39, 0x30, 0x31, 0x64, 0x37, 0x32, 0x66, 0x34, 0x36, 0x61, 0x39, 0x30, 0x66, 0x31, 0x66, 0x61, 0x61, 0x34, 0x66, 0x64, 0x64, 0x31, 0x61, 0x63, 0x39, 0x32, 0x32, 0x39, 0x61, 0x36, 0x66, 0x63, 0x36, 0x32, 0x61, 0x38, 0x34, 0x36, 0x63, 0x62, 0x34, 0x30, 0x37, 0x61, 0x31, 0x37, 0x33, 0x63, 0x36, 0x34, 0x33, 0x30, 0x33, 0x37, 0x66, 0x37, 0x35, 0x37, 0x37, 0x36, 0x66, 0x38, 0x63, 0x63, 0x35, 0x34, 0x65, 0x32, 0x34, 0x65, 0x30, 0x37, 0x39, 0x37, 0x32, 0x38, 0x33, 0x30, 0x39, 0x63, 0x62, 0x63, 0x65, 0x63, 0x36, 0x61, 0x32, 0x63, 0x32, 0x63, 0x39, 0x34, 0x62, 0x63, 0x32, 0x64, 0x62, 0x36, 0x66, 0x31, 0x62, 0x35, 0x38, 0x61, 0x38, 0x33, 0x65, 0x38, 0x65, 0x32, 0x65, 0x61, 0x66, 0x39, 0x38, 0x36, 0x61, 0x33, 0x62, 0x32, 0x31, 0x63, 0x36, 0x63, 0x61, 0x31, 0x34, 0x33, 0x34, 0x38, 0x64, 0x66, 0x33, 0x31, 0x64, 0x31, 0x66, 0x34, 0x37, 0x39, 0x31, 0x31, 0x30, 0x39, 0x30, 0x66, 0x39, 0x61, 0x35, 0x63, 0x61, 0x64, 0x36, 0x38, 0x37, 0x66, 0x31, 0x61, 0x66, 0x64, 0x30, 0x33, 0x30, 0x30, 0x61, 0x64, 0x39, 0x32, 0x37, 0x62, 0x38, 0x39, 0x37, 0x39, 0x39, 0x64, 0x30, 0x65, 0x32, 0x62, 0x35, 0x66, 0x36, 0x32, 0x31, 0x65, 0x63, 0x64, 0x37, 0x34, 0x62, 0x66, 0x35, 0x64, 0x39, 0x36, 0x34, 0x35, 0x37, 0x37, 0x31, 0x64, 0x61, 0x38, 0x65, 0x62, 0x34, 0x32, 0x61, 0x36, 0x34, 0x36, 0x32, 0x39, 0x31, 0x34, 0x62, 0x32, 0x65, 0x32, 0x37, 0x39, 0x32, 0x65, 0x63, 0x63, 0x30, 0x33, 0x35, 0x38, 0x66, 0x37, 0x62, 0x64, 0x31, 0x64, 0x63, 0x34, 0x63, 0x39, 0x63, 0x31, 0x32, 0x66, 0x62, 0x31, 0x65, 0x63, 0x38, 0x37, 0x64, 0x35, 0x62, 0x38, 0x33, 0x34, 0x65, 0x33, 0x30, 0x34, 0x37, 0x32, 0x65, 0x37, 0x33, 0x36, 0x34, 0x37, 0x30, 0x62, 0x33, 0x63, 0x32, 0x37, 0x35, 0x33, 0x66, 0x39, 0x66, 0x37, 0x33, 0x62, 0x64, 0x32, 0x62, 0x34, 0x62, 0x62, 0x64, 0x32, 0x34, 0x30, 0x36, 0x66, 0x61, 0x66, 0x31, 0x39, 0x61, 0x65, 0x63, 0x62, 0x30, 0x34, 0x37, 0x34, 0x38, 0x36, 0x39, 0x65, 0x63, 0x30, 0x39, 0x36, 0x36, 0x61, 0x34, 0x61, 0x66, 0x66, 0x63, 0x31, 0x33, 0x35, 0x37, 0x32, 0x65, 0x39, 0x39, 0x64, 0x63, 0x30, 0x31, 0x39, 0x61, 0x31, 0x37, 0x66, 0x38, 0x39, 0x63, 0x62, 0x35, 0x38, 0x35, 0x33, 0x66, 0x39, 0x32, 0x66, 0x61, 0x65, 0x30, 0x61, 0x63, 0x30, 0x34, 0x31, 0x38, 0x32, 0x39, 0x64, 0x62, 0x31, 0x62, 0x66, 0x66, 0x31, 0x39, 0x30, 0x31, 0x61, 0x65, 0x31, 0x39, 0x34, 0x39, 0x35, 0x33, 0x32, 0x64, 0x37, 0x32, 0x34, 0x37, 0x63, 0x33, 0x61, 0x35, 0x61, 0x32, 0x39, 0x63, 0x36, 0x61, 0x63, 0x38, 0x33, 0x30, 0x37, 0x38, 0x30, 0x35, 0x66, 0x35, 0x35, 0x66, 0x36, 0x36, 0x66, 0x65, 0x62, 0x66, 0x32, 0x38, 0x32, 0x31, 0x30, 0x66, 0x32, 0x66, 0x36, 0x31, 0x39, 0x36, 0x30, 0x36, 0x33, 0x66, 0x38, 0x65, 0x37, 0x64, 0x33, 0x32, 0x66, 0x63, 0x62, 0x65, 0x34, 0x61, 0x32, 0x33, 0x61, 0x61, 0x62, 0x36, 0x36, 0x30, 0x34, 0x33, 0x66, 0x35, 0x31, 0x33, 0x37, 0x64, 0x39, 0x31, 0x38, 0x34, 0x34, 0x63, 0x37, 0x35, 0x34, 0x38, 0x61, 0x36, 0x39, 0x63, 0x35, 0x32, 0x33, 0x64, 0x62, 0x32, 0x39, 0x63, 0x37, 0x36, 0x66, 0x34, 0x30, 0x61, 0x36, 0x65, 0x35, 0x65, 0x61, 0x37, 0x31, 0x61, 0x37, 0x61, 0x32, 0x36, 0x61, 0x37, 0x31, 0x38, 0x35, 0x63, 0x62, 0x64, 0x36, 0x30, 0x36, 0x37, 0x30, 0x30, 0x30, 0x31, 0x63, 0x34, 0x36, 0x30, 0x61, 0x65, 0x61, 0x64, 0x32, 0x37, 0x65, 0x34, 0x61, 0x31, 0x31, 0x66, 0x30, 0x64, 0x65, 0x37, 0x34, 0x62, 0x36, 0x36, 0x35, 0x32, 0x65, 0x63, 0x30, 0x63, 0x63, 0x62, 0x30, 0x37, 0x39, 0x63, 0x34, 0x35, 0x39, 0x63, 0x35, 0x33, 0x61, 0x64, 0x37, 0x31, 0x64, 0x36, 0x66, 0x37, 0x61, 0x34, 0x66, 0x65, 0x37, 0x38, 0x36, 0x66, 0x37, 0x64, 0x39, 0x39, 0x39, 0x31, 0x31, 0x62, 0x35, 0x37, 0x32, 0x64, 0x64, 0x37, 0x62, 0x63, 0x37, 0x34, 0x32, 0x39, 0x34, 0x36, 0x32, 0x63, 0x61, 0x30, 0x31, 0x63, 0x66, 0x61, 0x35, 0x62, 0x33, 0x33, 0x31, 0x66, 0x61, 0x34, 0x61, 0x66, 0x37, 0x65, 0x36, 0x61, 0x64, 0x37, 0x38, 0x37, 0x34, 0x36, 0x33, 0x64, 0x35, 0x66, 0x64, 0x66, 0x35, 0x34, 0x30, 0x36, 0x35, 0x35, 0x35, 0x64, 0x30, 0x66, 0x34, 0x33, 0x32, 0x31, 0x66, 0x37, 0x30, 0x32, 0x30, 0x64, 0x39, 0x38, 0x34, 0x37, 0x65, 0x31, 0x64, 0x39, 0x61, 0x34, 0x66, 0x61, 0x61, 0x31, 0x32, 0x65, 0x62, 0x33, 0x32, 0x63, 0x30, 0x38, 0x32, 0x39, 0x37, 0x36, 0x36, 0x38, 0x30, 0x35, 0x36, 0x63, 0x64, 0x32, 0x30, 0x61, 0x66, 0x34, 0x32, 0x34, 0x63, 0x36, 0x64, 0x61, 0x65, 0x30, 0x62, 0x30, 0x37, 0x62, 0x30, 0x65, 0x34, 0x62, 0x63, 0x32, 0x34, 0x65, 0x31, 0x33, 0x33, 0x34, 0x63, 0x62, 0x66, 0x66, 0x64, 0x33, 0x66, 0x31, 0x31, 0x64, 0x39, 0x34, 0x38, 0x65, 0x66, 0x32, 0x37, 0x63, 0x61, 0x33, 0x33, 0x63, 0x61, 0x64, 0x62, 0x33, 0x32, 0x38, 0x30, 0x63, 0x38, 0x33, 0x36, 0x34, 0x33, 0x39, 0x32, 0x33, 0x39, 0x34, 0x36, 0x35, 0x32, 0x61, 0x33, 0x37, 0x38, 0x33, 0x37, 0x31, 0x63, 0x33, 0x64, 0x31, 0x32, 0x39, 0x35, 0x35, 0x39, 0x66, 0x37, 0x62, 0x30, 0x34, 0x31, 0x61, 0x66, 0x37, 0x30, 0x62, 0x37, 0x63, 0x63, 0x33, 0x30, 0x61, 0x61, 0x32, 0x31, 0x61, 0x65, 0x63, 0x30, 0x64, 0x36, 0x63, 0x65, 0x38, 0x62, 0x63, 0x63, 0x39, 0x35, 0x35, 0x66, 0x38, 0x38, 0x38, 0x37, 0x61, 0x39, 0x35, 0x32, 0x66, 0x36, 0x39, 0x38, 0x30, 0x36, 0x32, 0x32, 0x64, 0x34, 0x35, 0x39, 0x35, 0x66, 0x30, 0x63, 0x35, 0x61, 0x35, 0x35, 0x65, 0x31, 0x35, 0x39, 0x37, 0x32, 0x33, 0x62, 0x34, 0x64, 0x36, 0x35, 0x35, 0x39, 0x62, 0x66, 0x36, 0x66, 0x39, 0x38, 0x31, 0x34, 0x31, 0x37, 0x34, 0x31, 0x61, 0x38, 0x64, 0x37, 0x30, 0x37, 0x31, 0x38, 0x35, 0x65, 0x61, 0x34, 0x31, 0x36, 0x66, 0x62, 0x36, 0x62, 0x63, 0x63, 0x30, 0x34, 0x61, 0x30, 0x35, 0x64, 0x30, 0x61, 0x31, 0x38, 0x34, 0x37, 0x63, 0x66, 0x37, 0x38, 0x64, 0x30, 0x35, 0x36, 0x31, 0x38, 0x33, 0x62, 0x34, 0x32, 0x38, 0x34, 0x34, 0x33, 0x64, 0x66, 0x36, 0x61, 0x31, 0x62, 0x35, 0x33, 0x39, 0x62, 0x62, 0x39, 0x62, 0x31, 0x65, 0x61, 0x66, 0x30, 0x65, 0x61, 0x32, 0x61, 0x36, 0x64, 0x61, 0x64, 0x35, 0x61, 0x34, 0x33, 0x36, 0x31, 0x65, 0x34, 0x66, 0x64, 0x30, 0x32, 0x34, 0x33, 0x30, 0x31, 0x37, 0x30, 0x33, 0x61, 0x64, 0x33, 0x39, 0x39, 0x66, 0x38, 0x66, 0x35, 0x32, 0x32, 0x37, 0x32, 0x34, 0x38, 0x66, 0x38, 0x38, 0x38, 0x38, 0x32, 0x38, 0x64, 0x30, 0x66, 0x39, 0x31, 0x37, 0x35, 0x32, 0x39, 0x38, 0x63, 0x66, 0x61, 0x32, 0x62, 0x32, 0x36, 0x35, 0x63, 0x36, 0x39, 0x63, 0x62, 0x37, 0x62, 0x38, 0x30, 0x39, 0x64, 0x34, 0x30, 0x32, 0x61, 0x62, 0x31, 0x31, 0x66, 0x33, 0x65, 0x64, 0x36, 0x32, 0x31, 0x32, 0x63, 0x32, 0x34, 0x66, 0x63, 0x63, 0x64, 0x32, 0x35, 0x37, 0x32, 0x63, 0x38, 0x65, 0x34, 0x31, 0x34, 0x61, 0x38, 0x39, 0x39, 0x33, 0x64, 0x61, 0x34, 0x33, 0x35, 0x63, 0x36, 0x34, 0x31, 0x63, 0x63, 0x38, 0x30, 0x32, 0x37, 0x64, 0x32, 0x66, 0x39, 0x37, 0x38, 0x36, 0x33, 0x35, 0x33, 0x66, 0x31, 0x35, 0x39, 0x38, 0x32, 0x64, 0x66, 0x64, 0x36, 0x63, 0x62, 0x63, 0x39, 0x38, 0x66, 0x64, 0x31, 0x38, 0x30, 0x37, 0x36, 0x38, 0x38, 0x35, 0x39, 0x37, 0x32, 0x66, 0x36, 0x37, 0x63, 0x37, 0x65, 0x33, 0x65, 0x63, 0x32, 0x38, 0x66, 0x64, 0x64, 0x32, 0x33, 0x32, 0x63, 0x30, 0x62, 0x33, 0x34, 0x61, 0x65, 0x31, 0x30, 0x63, 0x65, 0x31, 0x32, 0x36, 0x34, 0x35, 0x33, 0x61, 0x32, 0x39, 0x66, 0x34, 0x64, 0x36, 0x66, 0x39, 0x37, 0x36, 0x39, 0x36, 0x61, 0x61, 0x31, 0x63, 0x36, 0x39, 0x34, 0x35, 0x66, 0x64, 0x34, 0x34, 0x33, 0x62, 0x63, 0x37, 0x32, 0x64, 0x38, 0x34, 0x38, 0x36, 0x32, 0x39, 0x31, 0x37, 0x33, 0x33, 0x65, 0x30, 0x30, 0x33, 0x64, 0x33, 0x35, 0x38, 0x38, 0x34, 0x31, 0x61, 0x65, 0x37, 0x34, 0x31, 0x65, 0x66, 0x61, 0x61, 0x62, 0x30, 0x34, 0x35, 0x66, 0x32, 0x65, 0x37, 0x62, 0x31, 0x63, 0x32, 0x32, 0x37, 0x38, 0x39, 0x62, 0x34, 0x30, 0x61, 0x33, 0x63, 0x66, 0x30, 0x63, 0x39, 0x38, 0x39, 0x62, 0x38, 0x63, 0x37, 0x32, 0x66, 0x65, 0x62, 0x36, 0x34, 0x35, 0x62, 0x35, 0x38, 0x36, 0x31, 0x61, 0x62, 0x39, 0x63, 0x64, 0x33, 0x33, 0x63, 0x36, 0x66, 0x63, 0x66, 0x37, 0x30, 0x66, 0x66, 0x30, 0x35, 0x35, 0x30, 0x39, 0x62, 0x30, 0x64, 0x34, 0x34, 0x66, 0x63, 0x62, 0x36, 0x38, 0x62, 0x63, 0x64, 0x64, 0x63, 0x37, 0x61, 0x63, 0x30, 0x38, 0x39, 0x35, 0x61, 0x34, 0x63, 0x64, 0x35, 0x65, 0x31, 0x32, 0x37, 0x32, 0x38, 0x36, 0x65, 0x35, 0x38, 0x36, 0x66, 0x61, 0x32, 0x35, 0x39, 0x39, 0x36, 0x39, 0x34, 0x63, 0x31, 0x33, 0x66, 0x30, 0x32, 0x63, 0x35, 0x30, 0x64, 0x63, 0x33, 0x32, 0x35, 0x39, 0x61, 0x36, 0x32, 0x62, 0x33, 0x61, 0x35, 0x32, 0x35, 0x39, 0x32, 0x62, 0x39, 0x34, 0x32, 0x66, 0x63, 0x30, 0x37, 0x61, 0x33, 0x61, 0x63, 0x33, 0x31, 0x38, 0x31, 0x38, 0x32, 0x39, 0x32, 0x36, 0x37, 0x32, 0x32, 0x39, 0x34, 0x33, 0x36, 0x34, 0x66, 0x33, 0x39, 0x38, 0x39, 0x35, 0x38, 0x63, 0x36, 0x62, 0x33, 0x31, 0x33, 0x63, 0x37, 0x36, 0x39, 0x31, 0x37, 0x36, 0x63, 0x34, 0x34, 0x66, 0x65, 0x61, 0x39, 0x63, 0x34, 0x32, 0x65, 0x39, 0x38, 0x32, 0x30, 0x33, 0x35, 0x34, 0x34, 0x32, 0x66, 0x65, 0x35, 0x30, 0x63, 0x61, 0x34, 0x37, 0x39, 0x30, 0x33, 0x38, 0x61, 0x31, 0x62, 0x62, 0x35, 0x33, 0x62, 0x32, 0x64, 0x61, 0x62, 0x31, 0x31, 0x64, 0x66, 0x31, 0x32, 0x30, 0x62, 0x35, 0x39, 0x61, 0x62, 0x32, 0x33, 0x66, 0x35, 0x61, 0x32, 0x30, 0x65, 0x33, 0x66, 0x39, 0x30, 0x63, 0x62, 0x30, 0x31, 0x35, 0x35, 0x33, 0x61, 0x39, 0x32, 0x61, 0x62, 0x65, 0x39, 0x34, 0x37, 0x64, 0x61, 0x31, 0x31, 0x39, 0x30, 0x65, 0x66, 0x32, 0x62, 0x31, 0x30, 0x34, 0x36, 0x32, 0x30, 0x34, 0x30, 0x32, 0x39, 0x37, 0x39, 0x39, 0x66, 0x31, 0x36, 0x32, 0x63, 0x39, 0x65, 0x39, 0x62, 0x32, 0x38, 0x39, 0x35, 0x37, 0x36, 0x34, 0x34, 0x38, 0x39, 0x37, 0x36, 0x30, 0x35, 0x64, 0x38, 0x62, 0x37, 0x33, 0x62, 0x37, 0x65, 0x66, 0x66, 0x37, 0x33, 0x62, 0x62, 0x62, 0x38, 0x37, 0x35, 0x32, 0x38, 0x39, 0x63, 0x37, 0x64, 0x39, 0x64, 0x34, 0x62, 0x38, 0x64, 0x31, 0x62, 0x31, 0x38, 0x35, 0x36, 0x65, 0x33, 0x30, 0x65, 0x30, 0x65, 0x31, 0x62, 0x31, 0x64, 0x34, 0x62, 0x30, 0x37, 0x30, 0x30, 0x32, 0x35, 0x66, 0x37, 0x63, 0x65, 0x39, 0x63, 0x61, 0x62, 0x63, 0x36, 0x31, 0x33, 0x63, 0x36, 0x62, 0x34, 0x39, 0x66, 0x64, 0x34, 0x34, 0x66, 0x31, 0x36, 0x66, 0x36, 0x31, 0x32, 0x30, 0x65, 0x37, 0x31, 0x64, 0x66, 0x34, 0x33, 0x33, 0x64, 0x30, 0x30, 0x36, 0x34, 0x64, 0x33, 0x35, 0x37, 0x32, 0x62, 0x32, 0x34, 0x61, 0x32, 0x64, 0x30, 0x32, 0x30, 0x61, 0x34, 0x65, 0x39, 0x32, 0x64, 0x35, 0x65, 0x62, 0x37, 0x37, 0x34, 0x36, 0x31, 0x63, 0x62, 0x38, 0x32, 0x39, 0x61, 0x33, 0x61, 0x62, 0x63, 0x33, 0x65, 0x35, 0x38, 0x66, 0x35, 0x33, 0x63, 0x33, 0x36, 0x64, 0x61, 0x32, 0x37, 0x33, 0x35, 0x39, 0x37, 0x62, 0x39, 0x36, 0x37, 0x30, 0x62, 0x66, 0x34, 0x31, 0x33, 0x31, 0x37, 0x32, 0x65, 0x62, 0x38, 0x30, 0x62, 0x63, 0x64, 0x63, 0x31, 0x31, 0x31, 0x31, 0x62, 0x37, 0x64, 0x35, 0x36, 0x37, 0x35, 0x31, 0x66, 0x32, 0x35, 0x63, 0x66, 0x35, 0x31, 0x36, 0x34, 0x66, 0x66, 0x62, 0x36, 0x35, 0x62, 0x63, 0x38, 0x61, 0x38, 0x61, 0x61, 0x34, 0x32, 0x31, 0x31, 0x61, 0x39, 0x38, 0x63, 0x38, 0x32, 0x31, 0x39, 0x39, 0x63, 0x34, 0x38, 0x36, 0x37, 0x33, 0x34, 0x66, 0x32, 0x36, 0x33, 0x32, 0x64, 0x65, 0x66, 0x61, 0x65, 0x39, 0x38, 0x34, 0x30, 0x66, 0x33, 0x38, 0x66, 0x66, 0x64, 0x39, 0x64, 0x64, 0x64, 0x61, 0x30, 0x36, 0x30, 0x35, 0x62, 0x34, 0x32, 0x63, 0x31, 0x34, 0x64, 0x33, 0x38, 0x30, 0x37, 0x65, 0x64, 0x39, 0x64, 0x64, 0x34, 0x62, 0x37, 0x36, 0x34, 0x63, 0x64, 0x66, 0x65, 0x61, 0x38, 0x37, 0x65, 0x37, 0x30, 0x32, 0x34, 0x39, 0x33, 0x39, 0x37, 0x32, 0x37, 0x66, 0x33, 0x34, 0x61, 0x36, 0x61, 0x65, 0x30, 0x64, 0x37, 0x38, 0x34, 0x62, 0x35, 0x63, 0x39, 0x62, 0x32, 0x66, 0x62, 0x39, 0x32, 0x62, 0x37, 0x36, 0x64, 0x63, 0x39, 0x35, 0x63, 0x36, 0x30, 0x63, 0x34, 0x33, 0x38, 0x39, 0x34, 0x64, 0x38, 0x30, 0x65, 0x38, 0x37, 0x36, 0x37, 0x39, 0x31, 0x62, 0x31, 0x66, 0x39, 0x61, 0x61, 0x37, 0x30, 0x62, 0x62, 0x30, 0x63, 0x30, 0x37, 0x32, 0x35, 0x35, 0x37, 0x65, 0x34, 0x31, 0x64, 0x37, 0x62, 0x38, 0x37, 0x38, 0x65, 0x64, 0x62, 0x63, 0x64, 0x38, 0x64, 0x34, 0x66, 0x66, 0x62, 0x38, 0x37, 0x33, 0x34, 0x37, 0x65, 0x36, 0x64, 0x33, 0x65, 0x33, 0x30, 0x61, 0x34, 0x63, 0x32, 0x66, 0x38, 0x66, 0x33, 0x62, 0x66, 0x64, 0x62, 0x34, 0x61, 0x36, 0x35, 0x36, 0x33, 0x61, 0x62, 0x36, 0x32, 0x66, 0x32, 0x33, 0x38, 0x61, 0x37, 0x32, 0x36, 0x66, 0x62, 0x64, 0x66, 0x32, 0x39, 0x37, 0x33, 0x63, 0x66, 0x38, 0x61, 0x38, 0x33, 0x37, 0x37, 0x35, 0x30, 0x30, 0x64, 0x62, 0x33, 0x30, 0x65, 0x33, 0x37, 0x36, 0x33, 0x39, 0x34, 0x31, 0x37, 0x30, 0x37, 0x31, 0x65, 0x37, 0x34, 0x34, 0x37, 0x36, 0x65, 0x64, 0x38, 0x32, 0x38, 0x39, 0x34, 0x62, 0x38, 0x37, 0x65, 0x33, 0x30, 0x64, 0x66, 0x33, 0x39, 0x38, 0x39, 0x33, 0x36, 0x38, 0x30, 0x34, 0x64, 0x62, 0x33, 0x38, 0x30, 0x31, 0x39, 0x37, 0x35, 0x64, 0x37, 0x30, 0x63, 0x36, 0x32, 0x32, 0x35, 0x62, 0x31, 0x33, 0x37, 0x37, 0x34, 0x63, 0x62, 0x63, 0x31, 0x65, 0x32, 0x36, 0x35, 0x64, 0x33, 0x39, 0x61, 0x32, 0x33, 0x62, 0x64, 0x64, 0x33, 0x39, 0x38, 0x36, 0x36, 0x63, 0x64, 0x31, 0x61, 0x34, 0x63, 0x39, 0x39, 0x61, 0x34, 0x32, 0x35, 0x31, 0x63, 0x32, 0x34, 0x36, 0x66, 0x36, 0x38, 0x66, 0x64, 0x31, 0x30, 0x61, 0x30, 0x30, 0x35, 0x65, 0x63, 0x30, 0x66, 0x36, 0x61, 0x35, 0x34, 0x64, 0x32, 0x33, 0x36, 0x61, 0x65, 0x35, 0x39, 0x32, 0x66, 0x66, 0x32, 0x64, 0x36, 0x33, 0x30, 0x61, 0x63, 0x30, 0x61, 0x34, 0x38, 0x31, 0x63, 0x36, 0x33, 0x39, 0x62, 0x38, 0x35, 0x33, 0x62, 0x34, 0x38, 0x38, 0x37, 0x36, 0x34, 0x64, 0x31, 0x30, 0x34, 0x37, 0x34, 0x62, 0x64, 0x37, 0x35, 0x33, 0x66, 0x33, 0x33, 0x65, 0x62, 0x66, 0x30, 0x35, 0x35, 0x65, 0x38, 0x35, 0x36, 0x62, 0x34, 0x36, 0x63, 0x37, 0x63, 0x37, 0x32, 0x30, 0x31, 0x65, 0x64, 0x31, 0x30, 0x37, 0x34, 0x30, 0x39, 0x34, 0x31, 0x37, 0x62, 0x64, 0x34, 0x63, 0x32, 0x63, 0x64, 0x39, 0x63, 0x37, 0x34, 0x39, 0x33, 0x63, 0x65, 0x36, 0x32, 0x34, 0x34, 0x34, 0x65, 0x61, 0x38, 0x66, 0x37, 0x32, 0x34, 0x63, 0x66, 0x35, 0x36, 0x31, 0x34, 0x64, 0x37, 0x36, 0x32, 0x35, 0x36, 0x36, 0x35, 0x36, 0x38, 0x65, 0x63, 0x65, 0x33, 0x39, 0x65, 0x30, 0x33, 0x33, 0x38, 0x35, 0x64, 0x37, 0x30, 0x34, 0x36, 0x33, 0x39, 0x30, 0x62, 0x33, 0x38, 0x65, 0x31, 0x39, 0x65, 0x32, 0x37, 0x62, 0x32, 0x33, 0x63, 0x62, 0x35, 0x64, 0x38, 0x38, 0x38, 0x38, 0x62, 0x35, 0x62, 0x61, 0x63, 0x32, 0x37, 0x32, 0x31, 0x61, 0x66, 0x61, 0x32, 0x37, 0x33, 0x38, 0x62, 0x66, 0x38, 0x36, 0x65, 0x65, 0x37, 0x31, 0x32, 0x62, 0x66, 0x63, 0x65, 0x36, 0x65, 0x34, 0x38, 0x31, 0x63, 0x34, 0x39, 0x61, 0x63, 0x62, 0x32, 0x39, 0x63, 0x35, 0x30, 0x65, 0x62, 0x33, 0x64, 0x61, 0x38, 0x31, 0x66, 0x37, 0x61, 0x64, 0x33, 0x38, 0x39, 0x61, 0x31, 0x61, 0x30, 0x37, 0x65, 0x36, 0x38, 0x66, 0x63, 0x38, 0x37, 0x32, 0x37, 0x62, 0x61, 0x64, 0x38, 0x35, 0x35, 0x32, 0x65, 0x30, 0x32, 0x32, 0x62, 0x34, 0x61, 0x36, 0x34, 0x35, 0x63, 0x64, 0x34, 0x37, 0x32, 0x35, 0x64, 0x66, 0x35, 0x66, 0x32, 0x37, 0x64, 0x36, 0x33, 0x33, 0x31, 0x66, 0x32, 0x35, 0x36, 0x62, 0x39, 0x33, 0x32, 0x30, 0x38, 0x39, 0x33, 0x33, 0x61, 0x66, 0x65, 0x63, 0x37, 0x34, 0x39, 0x31, 0x31, 0x63, 0x61, 0x31, 0x61, 0x33, 0x37, 0x32, 0x61, 0x38, 0x64, 0x64, 0x63, 0x36, 0x36, 0x38, 0x65, 0x37, 0x35, 0x36, 0x63, 0x64, 0x62, 0x30, 0x32, 0x36, 0x39, 0x31, 0x37, 0x61, 0x36, 0x62, 0x36, 0x36, 0x37, 0x32, 0x30, 0x39, 0x36, 0x66, 0x33, 0x61, 0x35, 0x61, 0x63, 0x35, 0x66, 0x63, 0x34, 0x62, 0x62, 0x39, 0x34, 0x37, 0x30, 0x31, 0x38, 0x33, 0x64, 0x38, 0x63, 0x33, 0x66, 0x66, 0x34, 0x30, 0x66, 0x34, 0x31, 0x31, 0x35, 0x35, 0x63, 0x38, 0x62, 0x64, 0x66, 0x31, 0x64, 0x31, 0x39, 0x35, 0x31, 0x61, 0x36, 0x36, 0x30, 0x35, 0x32, 0x65, 0x65, 0x37, 0x38, 0x35, 0x33, 0x61, 0x63, 0x65, 0x37, 0x61, 0x63, 0x63, 0x62, 0x61, 0x37, 0x39, 0x31, 0x38, 0x33, 0x39, 0x32, 0x32, 0x63, 0x33, 0x63, 0x33, 0x64, 0x64, 0x38, 0x30, 0x39, 0x65, 0x65, 0x64, 0x34, 0x65, 0x34, 0x34, 0x38, 0x35, 0x36, 0x61, 0x65, 0x62, 0x37, 0x32, 0x65, 0x65, 0x66, 0x62, 0x39, 0x62, 0x65, 0x64, 0x65, 0x37, 0x33, 0x66, 0x37, 0x34, 0x37, 0x65, 0x35, 0x61, 0x62, 0x34, 0x65, 0x61, 0x30, 0x37, 0x30, 0x33, 0x63, 0x62, 0x62, 0x34, 0x36, 0x39, 0x37, 0x37, 0x62, 0x66, 0x62, 0x32, 0x65, 0x37, 0x63, 0x38, 0x39, 0x36, 0x66, 0x39, 0x62, 0x31, 0x36, 0x31, 0x34, 0x61, 0x37, 0x62, 0x66, 0x35, 0x36, 0x39, 0x61, 0x62, 0x64, 0x65, 0x31, 0x33, 0x38, 0x32, 0x64, 0x33, 0x30, 0x39, 0x34, 0x36, 0x34, 0x30, 0x65, 0x34, 0x39, 0x64, 0x31, 0x37, 0x33, 0x31, 0x35, 0x32, 0x38, 0x33, 0x62, 0x31, 0x37, 0x37, 0x61, 0x38, 0x62, 0x31, 0x35, 0x35, 0x34, 0x61, 0x66, 0x35, 0x31, 0x39, 0x39, 0x64, 0x37, 0x34, 0x63, 0x64, 0x63, 0x64, 0x35, 0x32, 0x31, 0x35, 0x35, 0x66, 0x63, 0x30, 0x35, 0x61, 0x63, 0x63, 0x35, 0x33, 0x35, 0x61, 0x37, 0x32, 0x34, 0x32, 0x33, 0x35, 0x30, 0x38, 0x36, 0x31, 0x32, 0x37, 0x33, 0x31, 0x32, 0x37, 0x33, 0x35, 0x37, 0x63, 0x35, 0x32, 0x65, 0x34, 0x62, 0x62, 0x33, 0x38, 0x31, 0x37, 0x38, 0x32, 0x63, 0x64, 0x36, 0x65, 0x38, 0x32, 0x39, 0x34, 0x35, 0x31, 0x31, 0x35, 0x34, 0x63, 0x33, 0x33, 0x63, 0x65, 0x35, 0x39, 0x31, 0x31, 0x65, 0x32, 0x62, 0x63, 0x36, 0x62, 0x65, 0x30, 0x30, 0x64, 0x37, 0x32, 0x66, 0x63, 0x34, 0x38, 0x37, 0x35, 0x39, 0x34, 0x33, 0x64, 0x65, 0x66, 0x39, 0x30, 0x35, 0x64, 0x32, 0x31, 0x34, 0x32, 0x65, 0x32, 0x37, 0x36, 0x37, 0x37, 0x36, 0x64, 0x34, 0x39, 0x62, 0x35, 0x64, 0x38, 0x35, 0x36, 0x36, 0x35, 0x30, 0x38, 0x61, 0x66, 0x37, 0x38, 0x34, 0x39, 0x34, 0x64, 0x31, 0x61, 0x34, 0x37, 0x36, 0x36, 0x32, 0x66, 0x39, 0x33, 0x39, 0x34, 0x39, 0x65, 0x34, 0x32, 0x36, 0x30, 0x36, 0x64, 0x31, 0x64, 0x33, 0x31, 0x30, 0x34, 0x31, 0x62, 0x65, 0x38, 0x31, 0x61, 0x38, 0x66, 0x35, 0x32, 0x64, 0x61, 0x34, 0x37, 0x36, 0x64, 0x32, 0x33, 0x38, 0x31, 0x30, 0x33, 0x33, 0x65, 0x31, 0x66, 0x38, 0x35, 0x36, 0x61, 0x32, 0x33, 0x63, 0x62, 0x63, 0x32, 0x32, 0x62, 0x36, 0x39, 0x37, 0x35, 0x64, 0x30, 0x61, 0x38, 0x39, 0x30, 0x36, 0x61, 0x64, 0x36, 0x37, 0x32, 0x64, 0x64, 0x32, 0x37, 0x33, 0x31, 0x36, 0x37, 0x65, 0x62, 0x31, 0x30, 0x31, 0x33, 0x33, 0x34, 0x61, 0x31, 0x63, 0x63, 0x34, 0x37, 0x61, 0x62, 0x39, 0x33, 0x63, 0x38, 0x62, 0x37, 0x64, 0x62, 0x31, 0x37, 0x34, 0x37, 0x39, 0x66, 0x35, 0x30, 0x39, 0x61, 0x65, 0x34, 0x63, 0x63, 0x65, 0x34, 0x65, 0x61, 0x34, 0x35, 0x30, 0x63, 0x36, 0x33, 0x61, 0x31, 0x65, 0x65, 0x33, 0x62, 0x37, 0x32, 0x38, 0x34, 0x36, 0x32, 0x39, 0x65, 0x38, 0x37, 0x37, 0x35, 0x61, 0x66, 0x64, 0x32, 0x62, 0x32, 0x64, 0x62, 0x63, 0x36, 0x38, 0x62, 0x64, 0x36, 0x31, 0x36, 0x37, 0x66, 0x33, 0x33, 0x65, 0x32, 0x37, 0x37, 0x35, 0x30, 0x39, 0x31, 0x63, 0x30, 0x36, 0x35, 0x38, 0x62, 0x61, 0x38, 0x33, 0x32, 0x32, 0x30, 0x36, 0x37, 0x66, 0x61, 0x64, 0x38, 0x66, 0x62, 0x61, 0x63, 0x35, 0x32, 0x37, 0x32, 0x62, 0x66, 0x65, 0x61, 0x37, 0x35, 0x61, 0x64, 0x38, 0x32, 0x31, 0x38, 0x61, 0x65, 0x63, 0x65, 0x35, 0x30, 0x32, 0x35, 0x33, 0x35, 0x34, 0x66, 0x65, 0x39, 0x66, 0x37, 0x32, 0x63, 0x38, 0x32, 0x33, 0x34, 0x61, 0x65, 0x31, 0x31, 0x36, 0x33, 0x39, 0x37, 0x63, 0x65, 0x30, 0x38, 0x30, 0x63, 0x32, 0x38, 0x31, 0x64, 0x33, 0x38, 0x37, 0x62, 0x32, 0x38, 0x38, 0x61, 0x63, 0x33, 0x37, 0x32, 0x64, 0x62, 0x31, 0x30, 0x33, 0x63, 0x64, 0x66, 0x66, 0x31, 0x36, 0x64, 0x61, 0x32, 0x33, 0x66, 0x61, 0x31, 0x35, 0x61, 0x32, 0x66, 0x31, 0x64, 0x37, 0x33, 0x37, 0x64, 0x32, 0x63, 0x39, 0x65, 0x34, 0x32, 0x39, 0x66, 0x32, 0x36, 0x36, 0x31, 0x65, 0x64, 0x35, 0x34, 0x61, 0x34, 0x66, 0x65, 0x64, 0x32, 0x31, 0x31, 0x66, 0x34, 0x30, 0x64, 0x37, 0x35, 0x34, 0x63, 0x64, 0x32, 0x37, 0x32, 0x34, 0x39, 0x65, 0x37, 0x39, 0x35, 0x30, 0x66, 0x62, 0x64, 0x33, 0x63, 0x33, 0x34, 0x61, 0x61, 0x34, 0x30, 0x64, 0x32, 0x34, 0x63, 0x30, 0x62, 0x39, 0x62, 0x66, 0x35, 0x34, 0x33, 0x35, 0x35, 0x32, 0x34, 0x37, 0x32, 0x30, 0x63, 0x38, 0x63, 0x34, 0x32, 0x33, 0x35, 0x37, 0x36, 0x37, 0x32, 0x34, 0x33, 0x64, 0x35, 0x33, 0x38, 0x31, 0x62, 0x38, 0x63, 0x37, 0x36, 0x37, 0x38, 0x37, 0x32, 0x32, 0x39, 0x35, 0x65, 0x31, 0x66, 0x34, 0x38, 0x35, 0x66, 0x36, 0x39, 0x31, 0x37, 0x34, 0x64, 0x64, 0x66, 0x31, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x38, 0x33, 0x30, 0x38, 0x31, 0x36, 0x30, 0x37, 0x64, 0x36, 0x34, 0x63, 0x37, 0x35, 0x62, 0x61, 0x33, 0x63, 0x35, 0x61, 0x61, 0x65, 0x63, 0x35, 0x32, 0x32, 0x30, 0x36, 0x61, 0x37, 0x36, 0x34, 0x64, 0x65, 0x32, 0x34, 0x65, 0x37, 0x32, 0x66, 0x61, 0x31, 0x32, 0x30, 0x33, 0x63, 0x65, 0x38, 0x62, 0x39, 0x62, 0x32, 0x37, 0x31, 0x36, 0x32, 0x33, 0x63, 0x33, 0x34, 0x32, 0x61, 0x63, 0x65, 0x63, 0x36, 0x64, 0x65, 0x35, 0x63, 0x36, 0x36, 0x63, 0x39, 0x36, 0x35, 0x65, 0x38, 0x66, 0x39, 0x66, 0x36, 0x66, 0x31, 0x36, 0x31, 0x31, 0x61, 0x62, 0x36, 0x30, 0x38, 0x63, 0x64, 0x63, 0x63, 0x61, 0x34, 0x65, 0x61, 0x34, 0x35, 0x31, 0x31, 0x32, 0x32, 0x66, 0x34, 0x34, 0x35, 0x63, 0x39, 0x39, 0x66, 0x63, 0x63, 0x65, 0x34, 0x31, 0x65, 0x65, 0x64, 0x61, 0x38, 0x66, 0x38, 0x32, 0x35, 0x63, 0x65, 0x38, 0x39, 0x35, 0x37, 0x39, 0x39, 0x66, 0x65, 0x37, 0x30, 0x37, 0x35, 0x63, 0x65, 0x37, 0x38, 0x36, 0x37, 0x30, 0x63, 0x65, 0x31, 0x31, 0x61, 0x64, 0x36, 0x39, 0x62, 0x61, 0x39, 0x38, 0x66, 0x66, 0x32, 0x30, 0x37, 0x32, 0x39, 0x62, 0x34, 0x36, 0x31, 0x33, 0x38, 0x38, 0x34, 0x63, 0x61, 0x64, 0x36, 0x64, 0x36, 0x38, 0x65, 0x34, 0x63, 0x30, 0x38, 0x31, 0x32, 0x34, 0x31, 0x66, 0x35, 0x64, 0x37, 0x63, 0x65, 0x33, 0x63, 0x66, 0x33, 0x66, 0x32, 0x39, 0x61, 0x65, 0x34, 0x33, 0x64, 0x31, 0x30, 0x39, 0x35, 0x66, 0x38, 0x65, 0x39, 0x64, 0x32, 0x61, 0x63, 0x66, 0x62, 0x65, 0x61, 0x64, 0x31, 0x37, 0x35, 0x33, 0x63, 0x35, 0x66, 0x65, 0x34, 0x62, 0x37, 0x34, 0x39, 0x30, 0x30, 0x61, 0x38, 0x63, 0x37, 0x37, 0x62, 0x61, 0x39, 0x34, 0x64, 0x38, 0x32, 0x33, 0x62, 0x65, 0x33, 0x33, 0x38, 0x64, 0x31, 0x38, 0x32, 0x34, 0x63, 0x30, 0x62, 0x32, 0x36, 0x39, 0x34, 0x35, 0x33, 0x62, 0x39, 0x39, 0x61, 0x36, 0x35, 0x31, 0x39, 0x35, 0x32, 0x63, 0x62, 0x62, 0x31, 0x64, 0x64, 0x33, 0x38, 0x62, 0x37, 0x32, 0x63, 0x30, 0x39, 0x33, 0x64, 0x65, 0x38, 0x30, 0x32, 0x65, 0x32, 0x66, 0x66, 0x33, 0x35, 0x31, 0x66, 0x35, 0x64, 0x63, 0x66, 0x62, 0x62, 0x36, 0x63, 0x32, 0x31, 0x38, 0x37, 0x36, 0x31, 0x65, 0x36, 0x33, 0x34, 0x63, 0x62, 0x66, 0x33, 0x33, 0x39, 0x38, 0x33, 0x33, 0x37, 0x33, 0x39, 0x39, 0x61, 0x66, 0x35, 0x37, 0x64, 0x36, 0x62, 0x62, 0x65, 0x63, 0x64, 0x61, 0x36, 0x36, 0x31, 0x62, 0x31, 0x39, 0x61, 0x35, 0x66, 0x32, 0x30, 0x33, 0x63, 0x35, 0x35, 0x39, 0x61, 0x33, 0x61, 0x35, 0x30, 0x39, 0x37, 0x37, 0x31, 0x62, 0x39, 0x36, 0x64, 0x35, 0x35, 0x38, 0x35, 0x33, 0x63, 0x34, 0x65, 0x62, 0x30, 0x38, 0x64, 0x34, 0x39, 0x32, 0x65, 0x61, 0x34, 0x32, 0x62, 0x63, 0x33, 0x65, 0x64, 0x36, 0x64, 0x66, 0x62, 0x36, 0x63, 0x30, 0x39, 0x37, 0x65, 0x63, 0x35, 0x33, 0x30, 0x62, 0x66, 0x36, 0x36, 0x34, 0x38, 0x39, 0x38, 0x62, 0x35, 0x62, 0x33, 0x32, 0x63, 0x66, 0x38, 0x65, 0x32, 0x31, 0x33, 0x38, 0x64, 0x64, 0x36, 0x64, 0x62, 0x61, 0x64, 0x66, 0x65, 0x64, 0x38, 0x32, 0x61, 0x61, 0x36, 0x35, 0x61, 0x30, 0x61, 0x62, 0x64, 0x30, 0x33, 0x65, 0x39, 0x62, 0x32, 0x33, 0x63, 0x37, 0x36, 0x62, 0x34, 0x65, 0x62, 0x62, 0x61, 0x33, 0x33, 0x39, 0x62, 0x64, 0x37, 0x32, 0x39, 0x37, 0x30, 0x65, 0x30, 0x64, 0x30, 0x63, 0x65, 0x62, 0x37, 0x31, 0x66, 0x32, 0x63, 0x35, 0x32, 0x39, 0x65, 0x64, 0x39, 0x31, 0x64, 0x35, 0x30, 0x36, 0x37, 0x64, 0x33, 0x62, 0x39, 0x66, 0x63, 0x30, 0x65, 0x37, 0x38, 0x65, 0x62, 0x64, 0x39, 0x31, 0x64, 0x31, 0x61, 0x63, 0x36, 0x30, 0x65, 0x30, 0x30, 0x63, 0x36, 0x33, 0x61, 0x34, 0x31, 0x32, 0x61, 0x38, 0x65, 0x35, 0x37, 0x32, 0x39, 0x62, 0x38, 0x38, 0x34, 0x36, 0x63, 0x39, 0x33, 0x36, 0x37, 0x31, 0x38, 0x65, 0x33, 0x39, 0x30, 0x36, 0x66, 0x33, 0x34, 0x35, 0x64, 0x35, 0x63, 0x33, 0x66, 0x31, 0x61, 0x65, 0x61, 0x38, 0x39, 0x66, 0x63, 0x34, 0x66, 0x34, 0x62, 0x61, 0x62, 0x35, 0x32, 0x39, 0x37, 0x65, 0x38, 0x38, 0x34, 0x62, 0x65, 0x32, 0x30, 0x65, 0x61, 0x33, 0x61, 0x61, 0x63, 0x38, 0x33, 0x66, 0x37, 0x32, 0x36, 0x39, 0x61, 0x35, 0x62, 0x66, 0x37, 0x34, 0x34, 0x63, 0x36, 0x62, 0x38, 0x30, 0x35, 0x63, 0x32, 0x61, 0x61, 0x35, 0x61, 0x35, 0x32, 0x38, 0x37, 0x61, 0x66, 0x39, 0x30, 0x30, 0x63, 0x63, 0x61, 0x36, 0x34, 0x35, 0x35, 0x39, 0x36, 0x33, 0x37, 0x37, 0x65, 0x32, 0x61, 0x39, 0x61, 0x66, 0x66, 0x33, 0x33, 0x63, 0x36, 0x32, 0x31, 0x62, 0x33, 0x34, 0x38, 0x34, 0x36, 0x37, 0x37, 0x31, 0x61, 0x30, 0x36, 0x34, 0x30, 0x34, 0x31, 0x64, 0x30, 0x65, 0x34, 0x35, 0x35, 0x65, 0x38, 0x65, 0x34, 0x66, 0x37, 0x65, 0x31, 0x34, 0x63, 0x35, 0x61, 0x36, 0x37, 0x31, 0x66, 0x39, 0x64, 0x32, 0x39, 0x33, 0x37, 0x61, 0x31, 0x38, 0x62, 0x31, 0x65, 0x65, 0x65, 0x62, 0x36, 0x35, 0x36, 0x63, 0x35, 0x33, 0x65, 0x66, 0x32, 0x66, 0x31, 0x36, 0x34, 0x63, 0x30, 0x66, 0x32, 0x61, 0x37, 0x32, 0x31, 0x32, 0x65, 0x37, 0x63, 0x66, 0x37, 0x65, 0x35, 0x31, 0x62, 0x32, 0x64, 0x36, 0x38, 0x31, 0x36, 0x66, 0x35, 0x65, 0x62, 0x61, 0x63, 0x30, 0x38, 0x64, 0x32, 0x65, 0x38, 0x64, 0x36, 0x38, 0x31, 0x66, 0x63, 0x62, 0x62, 0x63, 0x33, 0x37, 0x32, 0x61, 0x32, 0x30, 0x65, 0x31, 0x36, 0x39, 0x64, 0x35, 0x34, 0x64, 0x35, 0x31, 0x37, 0x39, 0x36, 0x61, 0x61, 0x37, 0x39, 0x63, 0x31, 0x32, 0x39, 0x64, 0x33, 0x38, 0x39, 0x34, 0x34, 0x63, 0x66, 0x33, 0x34, 0x38, 0x39, 0x66, 0x66, 0x33, 0x35, 0x32, 0x31, 0x37, 0x39, 0x64, 0x33, 0x39, 0x62, 0x37, 0x31, 0x33, 0x65, 0x32, 0x63, 0x32, 0x32, 0x31, 0x62, 0x61, 0x66, 0x31, 0x34, 0x66, 0x65, 0x30, 0x63, 0x35, 0x62, 0x61, 0x66, 0x37, 0x38, 0x35, 0x65, 0x63, 0x31, 0x30, 0x62, 0x63, 0x35, 0x35, 0x30, 0x33, 0x66, 0x31, 0x35, 0x32, 0x34, 0x32, 0x38, 0x65, 0x64, 0x33, 0x65, 0x36, 0x63, 0x33, 0x65, 0x37, 0x66, 0x66, 0x62, 0x62, 0x63, 0x38, 0x63, 0x62, 0x38, 0x38, 0x33, 0x62, 0x33, 0x31, 0x30, 0x31, 0x65, 0x36, 0x66, 0x30, 0x36, 0x36, 0x34, 0x30, 0x38, 0x39, 0x31, 0x34, 0x30, 0x36, 0x65, 0x63, 0x66, 0x66, 0x33, 0x39, 0x61, 0x38, 0x65, 0x30, 0x30, 0x34, 0x37, 0x63, 0x31, 0x34, 0x32, 0x34, 0x33, 0x61, 0x37, 0x32, 0x39, 0x61, 0x34, 0x65, 0x39, 0x63, 0x66, 0x33, 0x31, 0x37, 0x64, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x63, 0x38, 0x64, 0x66, 0x30, 0x31, 0x65, 0x63, 0x31, 0x66, 0x64, 0x37, 0x64, 0x66, 0x35, 0x38, 0x36, 0x39, 0x30, 0x32, 0x32, 0x35, 0x31, 0x36, 0x65, 0x63, 0x30, 0x64, 0x35, 0x34, 0x32, 0x31, 0x37, 0x65, 0x66, 0x64, 0x39, 0x31, 0x35, 0x61, 0x39, 0x66, 0x38, 0x64, 0x30, 0x37, 0x32, 0x61, 0x35, 0x66, 0x31, 0x65, 0x38, 0x61, 0x30, 0x39, 0x33, 0x64, 0x33, 0x30, 0x31, 0x30, 0x62, 0x38, 0x65, 0x62, 0x36, 0x38, 0x64, 0x64, 0x36, 0x62, 0x37, 0x33, 0x35, 0x33, 0x30, 0x66, 0x65, 0x62, 0x31, 0x33, 0x32, 0x63, 0x37, 0x34, 0x65, 0x34, 0x38, 0x33, 0x31, 0x34, 0x66, 0x65, 0x33, 0x34, 0x35, 0x39, 0x37, 0x62, 0x63, 0x65, 0x30, 0x61, 0x31, 0x31, 0x34, 0x38, 0x34, 0x34, 0x38, 0x63, 0x65, 0x32, 0x64, 0x66, 0x36, 0x30, 0x32, 0x32, 0x66, 0x32, 0x33, 0x37, 0x38, 0x66, 0x37, 0x61, 0x62, 0x62, 0x64, 0x61, 0x65, 0x33, 0x39, 0x63, 0x65, 0x61, 0x66, 0x65, 0x63, 0x36, 0x36, 0x32, 0x31, 0x36, 0x38, 0x63, 0x37, 0x31, 0x32, 0x63, 0x66, 0x62, 0x66, 0x31, 0x32, 0x63, 0x30, 0x32, 0x30, 0x64, 0x64, 0x33, 0x31, 0x61, 0x32, 0x39, 0x65, 0x31, 0x34, 0x30, 0x65, 0x33, 0x30, 0x39, 0x64, 0x61, 0x34, 0x65, 0x39, 0x61, 0x66, 0x38, 0x35, 0x30, 0x34, 0x35, 0x37, 0x33, 0x30, 0x66, 0x63, 0x30, 0x36, 0x33, 0x64, 0x39, 0x62, 0x62, 0x66, 0x35, 0x30, 0x32, 0x66, 0x36, 0x35, 0x32, 0x34, 0x34, 0x66, 0x30, 0x66, 0x32, 0x33, 0x63, 0x66, 0x63, 0x65, 0x36, 0x62, 0x33, 0x36, 0x64, 0x61, 0x31, 0x38, 0x33, 0x39, 0x37, 0x34, 0x64, 0x39, 0x66, 0x36, 0x65, 0x31, 0x35, 0x61, 0x63, 0x63, 0x38, 0x36, 0x36, 0x34, 0x39, 0x36, 0x31, 0x65, 0x32, 0x65, 0x34, 0x37, 0x35, 0x36, 0x63, 0x34, 0x33, 0x35, 0x33, 0x39, 0x39, 0x32, 0x34, 0x39, 0x32, 0x63, 0x38, 0x33, 0x64, 0x62, 0x35, 0x34, 0x62, 0x32, 0x38, 0x39, 0x31, 0x31, 0x34, 0x33, 0x31, 0x63, 0x39, 0x37, 0x33, 0x30, 0x61, 0x62, 0x33, 0x35, 0x39, 0x62, 0x63, 0x33, 0x32, 0x64, 0x37, 0x32, 0x62, 0x36, 0x37, 0x32, 0x32, 0x34, 0x33, 0x36, 0x34, 0x31, 0x66, 0x65, 0x33, 0x37, 0x38, 0x65, 0x33, 0x35, 0x64, 0x37, 0x31, 0x34, 0x32, 0x38, 0x36, 0x66, 0x33, 0x36, 0x64, 0x31, 0x62, 0x65, 0x31, 0x64, 0x65, 0x39, 0x63, 0x39, 0x61, 0x62, 0x35, 0x63, 0x33, 0x61, 0x32, 0x36, 0x31, 0x65, 0x38, 0x31, 0x37, 0x66, 0x33, 0x66, 0x61, 0x66, 0x34, 0x31, 0x39, 0x66, 0x31, 0x34, 0x66, 0x61, 0x39, 0x33, 0x31, 0x66, 0x34, 0x65, 0x66, 0x30, 0x38, 0x32, 0x30, 0x30, 0x62, 0x33, 0x63, 0x33, 0x61, 0x32, 0x35, 0x62, 0x63, 0x30, 0x66, 0x65, 0x30, 0x36, 0x37, 0x35, 0x30, 0x66, 0x62, 0x61, 0x61, 0x31, 0x64, 0x34, 0x61, 0x38, 0x62, 0x64, 0x66, 0x66, 0x36, 0x34, 0x61, 0x31, 0x30, 0x61, 0x38, 0x32, 0x36, 0x66, 0x31, 0x36, 0x36, 0x65, 0x35, 0x65, 0x35, 0x61, 0x33, 0x61, 0x64, 0x31, 0x32, 0x65, 0x37, 0x32, 0x66, 0x38, 0x30, 0x38, 0x66, 0x34, 0x37, 0x30, 0x36, 0x66, 0x62, 0x36, 0x61, 0x31, 0x37, 0x38, 0x66, 0x66, 0x34, 0x62, 0x33, 0x61, 0x30, 0x37, 0x30, 0x62, 0x63, 0x63, 0x32, 0x65, 0x64, 0x30, 0x66, 0x64, 0x63, 0x37, 0x65, 0x64, 0x36, 0x66, 0x39, 0x62, 0x39, 0x61, 0x64, 0x34, 0x37, 0x38, 0x32, 0x63, 0x35, 0x61, 0x37, 0x35, 0x61, 0x65, 0x63, 0x63, 0x62, 0x30, 0x63, 0x35, 0x37, 0x32, 0x37, 0x36, 0x62, 0x38, 0x38, 0x64, 0x32, 0x65, 0x61, 0x35, 0x35, 0x36, 0x32, 0x61, 0x39, 0x34, 0x38, 0x64, 0x64, 0x36, 0x61, 0x64, 0x65, 0x35, 0x63, 0x30, 0x32, 0x35, 0x31, 0x30, 0x63, 0x33, 0x36, 0x65, 0x30, 0x37, 0x32, 0x66, 0x62, 0x63, 0x39, 0x64, 0x38, 0x37, 0x65, 0x63, 0x63, 0x63, 0x39, 0x63, 0x36, 0x39, 0x33, 0x61, 0x32, 0x65, 0x34, 0x36, 0x35, 0x61, 0x31, 0x63, 0x37, 0x32, 0x64, 0x62, 0x36, 0x61, 0x65, 0x37, 0x37, 0x32, 0x39, 0x33, 0x66, 0x31, 0x31, 0x36, 0x39, 0x36, 0x36, 0x36, 0x34, 0x37, 0x64, 0x38, 0x65, 0x65, 0x31, 0x34, 0x61, 0x61, 0x30, 0x61, 0x65, 0x63, 0x33, 0x66, 0x36, 0x65, 0x37, 0x30, 0x37, 0x32, 0x37, 0x30, 0x37, 0x33, 0x35, 0x34, 0x30, 0x65, 0x33, 0x30, 0x64, 0x61, 0x62, 0x36, 0x39, 0x62, 0x61, 0x66, 0x36, 0x61, 0x39, 0x35, 0x37, 0x32, 0x65, 0x31, 0x62, 0x64, 0x36, 0x65, 0x36, 0x37, 0x61, 0x66, 0x66, 0x35, 0x35, 0x34, 0x61, 0x30, 0x34, 0x65, 0x30, 0x65, 0x66, 0x30, 0x32, 0x66, 0x61, 0x38, 0x31, 0x62, 0x66, 0x37, 0x30, 0x31, 0x35, 0x36, 0x39, 0x35, 0x36, 0x39, 0x64, 0x32, 0x37, 0x35, 0x65, 0x39, 0x38, 0x37, 0x66, 0x63, 0x33, 0x37, 0x62, 0x35, 0x30, 0x33, 0x61, 0x31, 0x33, 0x33, 0x39, 0x37, 0x35, 0x63, 0x32, 0x63, 0x37, 0x61, 0x35, 0x37, 0x63, 0x31, 0x63, 0x63, 0x39, 0x63, 0x34, 0x31, 0x33, 0x36, 0x33, 0x32, 0x30, 0x65, 0x63, 0x63, 0x65, 0x34, 0x39, 0x34, 0x37, 0x33, 0x66, 0x64, 0x31, 0x34, 0x33, 0x65, 0x64, 0x61, 0x35, 0x34, 0x38, 0x31, 0x30, 0x66, 0x37, 0x38, 0x61, 0x30, 0x38, 0x66, 0x39, 0x30, 0x36, 0x61, 0x32, 0x37, 0x36, 0x35, 0x32, 0x33, 0x64, 0x64, 0x33, 0x30, 0x63, 0x37, 0x37, 0x30, 0x66, 0x63, 0x61, 0x62, 0x63, 0x66, 0x38, 0x64, 0x33, 0x37, 0x32, 0x63, 0x35, 0x62, 0x35, 0x62, 0x30, 0x63, 0x66, 0x61, 0x61, 0x33, 0x38, 0x31, 0x32, 0x64, 0x35, 0x64, 0x62, 0x32, 0x31, 0x36, 0x61, 0x30, 0x35, 0x33, 0x38, 0x61, 0x64, 0x37, 0x63, 0x38, 0x34, 0x32, 0x63, 0x63, 0x36, 0x39, 0x31, 0x32, 0x63, 0x63, 0x30, 0x34, 0x62, 0x66, 0x33, 0x36, 0x62, 0x30, 0x37, 0x66, 0x34, 0x39, 0x34, 0x35, 0x61, 0x38, 0x33, 0x65, 0x35, 0x65, 0x66, 0x39, 0x39, 0x37, 0x30, 0x66, 0x63, 0x32, 0x65, 0x35, 0x39, 0x38, 0x65, 0x66, 0x32, 0x35, 0x61, 0x38, 0x66, 0x63, 0x65, 0x61, 0x32, 0x35, 0x31, 0x65, 0x61, 0x30, 0x37, 0x63, 0x31, 0x63, 0x36, 0x61, 0x39, 0x31, 0x31, 0x65, 0x63, 0x66, 0x31, 0x61, 0x64, 0x36, 0x32, 0x35, 0x35, 0x65, 0x31, 0x65, 0x38, 0x37, 0x61, 0x34, 0x30, 0x39, 0x31, 0x30, 0x39, 0x66, 0x61, 0x61, 0x35, 0x39, 0x36, 0x35, 0x63, 0x39, 0x66, 0x32, 0x64, 0x61, 0x32, 0x33, 0x32, 0x64, 0x38, 0x34, 0x62, 0x33, 0x63, 0x33, 0x33, 0x62, 0x65, 0x63, 0x32, 0x35, 0x35, 0x38, 0x66, 0x38, 0x61, 0x31, 0x63, 0x64, 0x30, 0x62, 0x38, 0x61, 0x37, 0x36, 0x62, 0x32, 0x66, 0x64, 0x61, 0x62, 0x30, 0x62, 0x30, 0x39, 0x30, 0x64, 0x32, 0x65, 0x34, 0x32, 0x31, 0x36, 0x62, 0x66, 0x65, 0x34, 0x39, 0x37, 0x34, 0x34, 0x32, 0x33, 0x65, 0x62, 0x31, 0x65, 0x62, 0x34, 0x30, 0x35, 0x39, 0x63, 0x32, 0x35, 0x63, 0x62, 0x66, 0x65, 0x36, 0x62, 0x61, 0x66, 0x32, 0x37, 0x30, 0x30, 0x30, 0x36, 0x64, 0x32, 0x31, 0x65, 0x63, 0x34, 0x31, 0x31, 0x33, 0x31, 0x39, 0x61, 0x37, 0x61, 0x30, 0x62, 0x31, 0x37, 0x64, 0x38, 0x39, 0x61, 0x33, 0x32, 0x39, 0x62, 0x36, 0x32, 0x65, 0x31, 0x62, 0x36, 0x63, 0x62, 0x36, 0x33, 0x38, 0x63, 0x35, 0x34, 0x36, 0x35, 0x38, 0x31, 0x65, 0x39, 0x65, 0x33, 0x62, 0x64, 0x62, 0x35, 0x33, 0x35, 0x64, 0x63, 0x31, 0x35, 0x62, 0x34, 0x31, 0x66, 0x39, 0x35, 0x36, 0x37, 0x61, 0x36, 0x34, 0x38, 0x34, 0x30, 0x31, 0x38, 0x37, 0x37, 0x62, 0x37, 0x62, 0x37, 0x32, 0x32, 0x35, 0x63, 0x39, 0x32, 0x31, 0x35, 0x31, 0x31, 0x32, 0x33, 0x63, 0x61, 0x31, 0x39, 0x65, 0x32, 0x63, 0x30, 0x66, 0x65, 0x34, 0x66, 0x34, 0x63, 0x65, 0x34, 0x63, 0x31, 0x63, 0x62, 0x32, 0x35, 0x31, 0x38, 0x31, 0x34, 0x66, 0x31, 0x33, 0x30, 0x64, 0x34, 0x32, 0x63, 0x32, 0x37, 0x34, 0x33, 0x61, 0x36, 0x66, 0x62, 0x32, 0x66, 0x31, 0x35, 0x64, 0x63, 0x32, 0x65, 0x30, 0x36, 0x62, 0x65, 0x38, 0x64, 0x63, 0x30, 0x64, 0x37, 0x63, 0x66, 0x32, 0x61, 0x30, 0x61, 0x65, 0x38, 0x64, 0x33, 0x30, 0x64, 0x38, 0x39, 0x32, 0x32, 0x36, 0x36, 0x30, 0x33, 0x38, 0x34, 0x30, 0x66, 0x62, 0x34, 0x66, 0x30, 0x38, 0x30, 0x33, 0x62, 0x64, 0x61, 0x38, 0x38, 0x61, 0x36, 0x36, 0x39, 0x35, 0x37, 0x33, 0x37, 0x64, 0x36, 0x62, 0x35, 0x34, 0x31, 0x31, 0x38, 0x31, 0x37, 0x38, 0x63, 0x30, 0x38, 0x62, 0x66, 0x37, 0x62, 0x38, 0x30, 0x34, 0x31, 0x37, 0x32, 0x66, 0x35, 0x35, 0x38, 0x34, 0x31, 0x61, 0x33, 0x63, 0x35, 0x33, 0x32, 0x36, 0x37, 0x66, 0x30, 0x34, 0x65, 0x36, 0x34, 0x65, 0x33, 0x63, 0x36, 0x33, 0x61, 0x39, 0x61, 0x35, 0x35, 0x38, 0x31, 0x39, 0x32, 0x62, 0x34, 0x64, 0x63, 0x33, 0x62, 0x32, 0x33, 0x38, 0x39, 0x64, 0x31, 0x30, 0x33, 0x33, 0x37, 0x34, 0x64, 0x34, 0x31, 0x66, 0x30, 0x31, 0x39, 0x34, 0x31, 0x36, 0x38, 0x32, 0x66, 0x38, 0x38, 0x66, 0x62, 0x64, 0x38, 0x30, 0x33, 0x30, 0x32, 0x30, 0x33, 0x61, 0x37, 0x37, 0x38, 0x32, 0x38, 0x64, 0x31, 0x38, 0x38, 0x62, 0x65, 0x63, 0x36, 0x32, 0x32, 0x65, 0x65, 0x65, 0x38, 0x66, 0x36, 0x31, 0x65, 0x30, 0x63, 0x31, 0x63, 0x31, 0x30, 0x66, 0x38, 0x36, 0x32, 0x30, 0x31, 0x37, 0x39, 0x63, 0x61, 0x35, 0x35, 0x66, 0x38, 0x34, 0x63, 0x39, 0x34, 0x30, 0x36, 0x37, 0x32, 0x65, 0x30, 0x61, 0x34, 0x31, 0x65, 0x37, 0x62, 0x38, 0x62, 0x30, 0x66, 0x61, 0x31, 0x66, 0x36, 0x64, 0x33, 0x35, 0x64, 0x34, 0x30, 0x35, 0x62, 0x35, 0x63, 0x39, 0x32, 0x33, 0x64, 0x35, 0x37, 0x64, 0x37, 0x34, 0x37, 0x61, 0x39, 0x66, 0x34, 0x39, 0x34, 0x66, 0x64, 0x30, 0x36, 0x34, 0x34, 0x34, 0x37, 0x30, 0x61, 0x31, 0x62, 0x38, 0x66, 0x62, 0x64, 0x65, 0x31, 0x30, 0x32, 0x37, 0x32, 0x61, 0x61, 0x39, 0x66, 0x65, 0x61, 0x33, 0x61, 0x65, 0x33, 0x35, 0x62, 0x39, 0x65, 0x31, 0x38, 0x37, 0x65, 0x36, 0x36, 0x35, 0x33, 0x31, 0x36, 0x37, 0x33, 0x37, 0x61, 0x38, 0x35, 0x34, 0x61, 0x61, 0x35, 0x33, 0x37, 0x33, 0x35, 0x64, 0x35, 0x62, 0x31, 0x39, 0x66, 0x32, 0x32, 0x30, 0x30, 0x37, 0x36, 0x36, 0x33, 0x34, 0x62, 0x30, 0x33, 0x64, 0x37, 0x61, 0x35, 0x38, 0x62, 0x37, 0x32, 0x30, 0x31, 0x32, 0x32, 0x31, 0x35, 0x35, 0x36, 0x38, 0x63, 0x63, 0x36, 0x64, 0x64, 0x65, 0x63, 0x66, 0x35, 0x62, 0x39, 0x34, 0x63, 0x30, 0x30, 0x63, 0x37, 0x37, 0x38, 0x38, 0x66, 0x65, 0x61, 0x37, 0x35, 0x62, 0x31, 0x38, 0x65, 0x65, 0x32, 0x39, 0x62, 0x37, 0x66, 0x66, 0x34, 0x63, 0x35, 0x33, 0x38, 0x36, 0x33, 0x38, 0x61, 0x35, 0x38, 0x30, 0x33, 0x32, 0x37, 0x64, 0x63, 0x31, 0x62, 0x36, 0x63, 0x37, 0x62, 0x39, 0x36, 0x35, 0x66, 0x63, 0x34, 0x66, 0x33, 0x66, 0x30, 0x35, 0x33, 0x65, 0x35, 0x64, 0x65, 0x62, 0x38, 0x34, 0x33, 0x64, 0x36, 0x30, 0x33, 0x39, 0x33, 0x38, 0x63, 0x37, 0x33, 0x30, 0x36, 0x39, 0x63, 0x61, 0x36, 0x65, 0x36, 0x36, 0x34, 0x64, 0x30, 0x30, 0x61, 0x66, 0x65, 0x36, 0x32, 0x66, 0x33, 0x38, 0x32, 0x63, 0x38, 0x35, 0x31, 0x36, 0x66, 0x37, 0x32, 0x65, 0x34, 0x30, 0x32, 0x36, 0x66, 0x37, 0x31, 0x32, 0x66, 0x65, 0x34, 0x39, 0x30, 0x61, 0x64, 0x37, 0x64, 0x61, 0x62, 0x38, 0x32, 0x34, 0x39, 0x32, 0x30, 0x30, 0x38, 0x61, 0x36, 0x37, 0x36, 0x66, 0x34, 0x64, 0x30, 0x36, 0x35, 0x65, 0x65, 0x37, 0x36, 0x30, 0x34, 0x35, 0x39, 0x34, 0x66, 0x31, 0x64, 0x61, 0x31, 0x62, 0x66, 0x61, 0x66, 0x63, 0x32, 0x62, 0x36, 0x30, 0x30, 0x32, 0x33, 0x66, 0x61, 0x31, 0x64, 0x62, 0x32, 0x37, 0x63, 0x36, 0x36, 0x31, 0x35, 0x37, 0x36, 0x65, 0x33, 0x32, 0x30, 0x64, 0x64, 0x65, 0x32, 0x34, 0x61, 0x32, 0x66, 0x36, 0x64, 0x31, 0x33, 0x64, 0x34, 0x35, 0x39, 0x30, 0x63, 0x33, 0x65, 0x35, 0x33, 0x37, 0x38, 0x34, 0x36, 0x36, 0x33, 0x64, 0x37, 0x35, 0x30, 0x37, 0x64, 0x63, 0x32, 0x39, 0x32, 0x30, 0x35, 0x31, 0x33, 0x35, 0x38, 0x35, 0x64, 0x62, 0x64, 0x39, 0x32, 0x37, 0x37, 0x37, 0x33, 0x34, 0x30, 0x36, 0x37, 0x33, 0x34, 0x34, 0x34, 0x65, 0x32, 0x66, 0x65, 0x66, 0x36, 0x64, 0x35, 0x61, 0x32, 0x62, 0x64, 0x62, 0x63, 0x32, 0x66, 0x38, 0x30, 0x30, 0x35, 0x35, 0x35, 0x37, 0x65, 0x63, 0x30, 0x35, 0x65, 0x38, 0x34, 0x33, 0x38, 0x35, 0x31, 0x66, 0x38, 0x34, 0x39, 0x62, 0x32, 0x35, 0x33, 0x63, 0x66, 0x63, 0x32, 0x33, 0x66, 0x66, 0x34, 0x61, 0x32, 0x33, 0x65, 0x61, 0x65, 0x63, 0x38, 0x36, 0x64, 0x34, 0x33, 0x38, 0x66, 0x31, 0x35, 0x64, 0x34, 0x66, 0x62, 0x38, 0x34, 0x63, 0x66, 0x37, 0x35, 0x39, 0x36, 0x32, 0x39, 0x34, 0x62, 0x35, 0x37, 0x65, 0x39, 0x65, 0x61, 0x36, 0x33, 0x38, 0x36, 0x64, 0x30, 0x63, 0x66, 0x38, 0x39, 0x66, 0x32, 0x65, 0x65, 0x39, 0x36, 0x65, 0x37, 0x39, 0x62, 0x39, 0x34, 0x37, 0x32, 0x36, 0x35, 0x36, 0x37, 0x66, 0x31, 0x36, 0x31, 0x39, 0x39, 0x63, 0x36, 0x36, 0x35, 0x39, 0x33, 0x31, 0x31, 0x30, 0x35, 0x38, 0x62, 0x62, 0x37, 0x36, 0x30, 0x65, 0x64, 0x64, 0x62, 0x61, 0x66, 0x38, 0x34, 0x64, 0x34, 0x32, 0x62, 0x66, 0x34, 0x35, 0x38, 0x64, 0x37, 0x66, 0x39, 0x61, 0x32, 0x61, 0x66, 0x38, 0x31, 0x62, 0x32, 0x62, 0x30, 0x38, 0x35, 0x66, 0x39, 0x66, 0x62, 0x37, 0x32, 0x34, 0x35, 0x66, 0x37, 0x38, 0x63, 0x65, 0x62, 0x33, 0x65, 0x33, 0x32, 0x64, 0x37, 0x62, 0x30, 0x34, 0x36, 0x39, 0x34, 0x38, 0x39, 0x31, 0x36, 0x63, 0x38, 0x34, 0x64, 0x65, 0x38, 0x62, 0x63, 0x31, 0x62, 0x61, 0x62, 0x32, 0x62, 0x39, 0x36, 0x65, 0x37, 0x64, 0x33, 0x66, 0x62, 0x65, 0x62, 0x31, 0x31, 0x61, 0x66, 0x30, 0x35, 0x64, 0x30, 0x37, 0x65, 0x63, 0x38, 0x39, 0x63, 0x37, 0x32, 0x33, 0x33, 0x64, 0x61, 0x63, 0x31, 0x33, 0x66, 0x61, 0x32, 0x30, 0x63, 0x36, 0x32, 0x66, 0x62, 0x65, 0x39, 0x30, 0x33, 0x31, 0x61, 0x35, 0x31, 0x66, 0x34, 0x35, 0x63, 0x62, 0x31, 0x63, 0x38, 0x35, 0x37, 0x34, 0x37, 0x64, 0x38, 0x38, 0x64, 0x37, 0x65, 0x63, 0x64, 0x37, 0x32, 0x38, 0x34, 0x32, 0x35, 0x37, 0x34, 0x36, 0x36, 0x32, 0x36, 0x38, 0x38, 0x36, 0x33, 0x63, 0x38, 0x31, 0x30, 0x36, 0x35, 0x35, 0x33, 0x34, 0x38, 0x30, 0x61, 0x64, 0x63, 0x31, 0x39, 0x31, 0x39, 0x61, 0x38, 0x39, 0x35, 0x30, 0x62, 0x39, 0x32, 0x35, 0x30, 0x36, 0x66, 0x62, 0x63, 0x64, 0x33, 0x62, 0x62, 0x38, 0x32, 0x32, 0x30, 0x32, 0x64, 0x63, 0x33, 0x61, 0x39, 0x31, 0x61, 0x38, 0x63, 0x37, 0x34, 0x63, 0x64, 0x37, 0x30, 0x64, 0x37, 0x38, 0x63, 0x64, 0x33, 0x33, 0x38, 0x66, 0x31, 0x34, 0x61, 0x34, 0x64, 0x36, 0x30, 0x38, 0x34, 0x61, 0x33, 0x35, 0x34, 0x36, 0x32, 0x34, 0x64, 0x33, 0x38, 0x32, 0x36, 0x31, 0x38, 0x65, 0x61, 0x33, 0x34, 0x37, 0x64, 0x38, 0x31, 0x64, 0x36, 0x65, 0x64, 0x63, 0x34, 0x61, 0x31, 0x32, 0x66, 0x36, 0x35, 0x63, 0x37, 0x64, 0x30, 0x34, 0x39, 0x63, 0x32, 0x36, 0x61, 0x31, 0x61, 0x65, 0x36, 0x33, 0x62, 0x36, 0x32, 0x62, 0x30, 0x63, 0x66, 0x32, 0x66, 0x37, 0x64, 0x66, 0x63, 0x32, 0x61, 0x30, 0x31, 0x36, 0x65, 0x36, 0x34, 0x66, 0x61, 0x31, 0x65, 0x33, 0x34, 0x61, 0x36, 0x36, 0x37, 0x33, 0x38, 0x37, 0x37, 0x63, 0x35, 0x37, 0x38, 0x36, 0x39, 0x37, 0x65, 0x32, 0x38, 0x61, 0x35, 0x37, 0x34, 0x30, 0x37, 0x36, 0x66, 0x31, 0x33, 0x66, 0x35, 0x61, 0x35, 0x37, 0x37, 0x32, 0x65, 0x37, 0x34, 0x64, 0x64, 0x64, 0x64, 0x65, 0x32, 0x36, 0x33, 0x66, 0x33, 0x39, 0x35, 0x38, 0x39, 0x65, 0x37, 0x62, 0x64, 0x65, 0x63, 0x31, 0x35, 0x36, 0x66, 0x39, 0x31, 0x35, 0x31, 0x62, 0x30, 0x39, 0x65, 0x66, 0x31, 0x63, 0x34, 0x31, 0x33, 0x63, 0x31, 0x64, 0x34, 0x39, 0x62, 0x35, 0x30, 0x64, 0x31, 0x64, 0x34, 0x63, 0x62, 0x63, 0x32, 0x62, 0x30, 0x61, 0x39, 0x32, 0x63, 0x35, 0x61, 0x64, 0x66, 0x33, 0x39, 0x32, 0x66, 0x61, 0x65, 0x37, 0x32, 0x33, 0x64, 0x37, 0x64, 0x38, 0x34, 0x65, 0x37, 0x64, 0x63, 0x34, 0x34, 0x30, 0x36, 0x30, 0x36, 0x31, 0x65, 0x32, 0x66, 0x64, 0x39, 0x62, 0x65, 0x30, 0x34, 0x33, 0x66, 0x37, 0x61, 0x65, 0x62, 0x37, 0x33, 0x33, 0x62, 0x63, 0x61, 0x34, 0x39, 0x61, 0x62, 0x35, 0x34, 0x32, 0x30, 0x61, 0x39, 0x38, 0x34, 0x30, 0x34, 0x62, 0x35, 0x34, 0x37, 0x66, 0x61, 0x36, 0x36, 0x37, 0x36, 0x34, 0x61, 0x34, 0x34, 0x38, 0x31, 0x63, 0x66, 0x63, 0x36, 0x63, 0x30, 0x30, 0x33, 0x31, 0x39, 0x31, 0x63, 0x35, 0x38, 0x32, 0x38, 0x61, 0x61, 0x65, 0x32, 0x36, 0x36, 0x61, 0x64, 0x33, 0x34, 0x36, 0x38, 0x31, 0x63, 0x66, 0x34, 0x39, 0x31, 0x66, 0x65, 0x63, 0x64, 0x37, 0x63, 0x37, 0x38, 0x64, 0x33, 0x30, 0x39, 0x65, 0x63, 0x37, 0x35, 0x37, 0x62, 0x39, 0x32, 0x30, 0x36, 0x65, 0x63, 0x37, 0x32, 0x31, 0x31, 0x37, 0x39, 0x34, 0x31, 0x36, 0x35, 0x36, 0x36, 0x65, 0x61, 0x65, 0x62, 0x33, 0x66, 0x31, 0x61, 0x37, 0x30, 0x64, 0x30, 0x34, 0x36, 0x32, 0x66, 0x35, 0x64, 0x34, 0x35, 0x63, 0x31, 0x30, 0x62, 0x32, 0x36, 0x33, 0x66, 0x65, 0x62, 0x33, 0x61, 0x37, 0x36, 0x39, 0x32, 0x64, 0x61, 0x36, 0x63, 0x64, 0x33, 0x64, 0x37, 0x37, 0x37, 0x37, 0x34, 0x34, 0x63, 0x65, 0x31, 0x33, 0x61, 0x65, 0x30, 0x62, 0x30, 0x62, 0x32, 0x31, 0x64, 0x66, 0x66, 0x34, 0x38, 0x63, 0x33, 0x65, 0x33, 0x33, 0x30, 0x31, 0x62, 0x63, 0x66, 0x61, 0x39, 0x30, 0x36, 0x36, 0x36, 0x61, 0x66, 0x31, 0x65, 0x62, 0x36, 0x62, 0x32, 0x63, 0x65, 0x35, 0x35, 0x38, 0x65, 0x61, 0x61, 0x36, 0x39, 0x39, 0x33, 0x30, 0x61, 0x39, 0x36, 0x33, 0x64, 0x66, 0x61, 0x30, 0x37, 0x64, 0x62, 0x34, 0x38, 0x34, 0x30, 0x31, 0x35, 0x39, 0x35, 0x34, 0x65, 0x33, 0x35, 0x33, 0x38, 0x32, 0x61, 0x66, 0x34, 0x39, 0x61, 0x32, 0x66, 0x63, 0x31, 0x35, 0x61, 0x36, 0x61, 0x38, 0x34, 0x31, 0x63, 0x33, 0x30, 0x36, 0x63, 0x66, 0x36, 0x34, 0x65, 0x38, 0x33, 0x37, 0x63, 0x32, 0x38, 0x32, 0x63, 0x36, 0x62, 0x36, 0x39, 0x39, 0x63, 0x63, 0x63, 0x66, 0x38, 0x37, 0x35, 0x31, 0x65, 0x35, 0x38, 0x66, 0x65, 0x32, 0x61, 0x31, 0x32, 0x62, 0x66, 0x38, 0x64, 0x38, 0x63, 0x64, 0x35, 0x33, 0x32, 0x61, 0x31, 0x36, 0x64, 0x61, 0x36, 0x38, 0x36, 0x64, 0x34, 0x62, 0x61, 0x63, 0x30, 0x63, 0x36, 0x65, 0x64, 0x31, 0x63, 0x32, 0x64, 0x34, 0x66, 0x37, 0x62, 0x37, 0x66, 0x30, 0x39, 0x30, 0x35, 0x35, 0x63, 0x31, 0x64, 0x30, 0x32, 0x31, 0x39, 0x36, 0x66, 0x63, 0x38, 0x61, 0x34, 0x35, 0x62, 0x35, 0x63, 0x37, 0x32, 0x32, 0x31, 0x31, 0x63, 0x34, 0x37, 0x30, 0x66, 0x64, 0x34, 0x61, 0x38, 0x32, 0x36, 0x64, 0x63, 0x66, 0x35, 0x39, 0x35, 0x65, 0x61, 0x66, 0x34, 0x66, 0x64, 0x62, 0x32, 0x61, 0x62, 0x65, 0x35, 0x34, 0x38, 0x64, 0x36, 0x34, 0x66, 0x32, 0x34, 0x63, 0x39, 0x66, 0x38, 0x36, 0x64, 0x30, 0x30, 0x31, 0x38, 0x66, 0x64, 0x32, 0x64, 0x34, 0x31, 0x64, 0x64, 0x63, 0x62, 0x62, 0x30, 0x35, 0x30, 0x31, 0x63, 0x65, 0x38, 0x64, 0x31, 0x37, 0x38, 0x31, 0x35, 0x66, 0x63, 0x39, 0x39, 0x65, 0x64, 0x32, 0x39, 0x61, 0x64, 0x63, 0x36, 0x39, 0x38, 0x33, 0x65, 0x61, 0x35, 0x66, 0x32, 0x39, 0x61, 0x39, 0x39, 0x34, 0x39, 0x32, 0x64, 0x32, 0x63, 0x63, 0x33, 0x66, 0x34, 0x32, 0x31, 0x65, 0x62, 0x34, 0x62, 0x36, 0x39, 0x39, 0x39, 0x39, 0x34, 0x38, 0x34, 0x64, 0x35, 0x31, 0x66, 0x35, 0x37, 0x61, 0x31, 0x63, 0x34, 0x34, 0x32, 0x66, 0x65, 0x32, 0x66, 0x31, 0x63, 0x36, 0x62, 0x32, 0x61, 0x64, 0x38, 0x32, 0x30, 0x39, 0x38, 0x64, 0x38, 0x37, 0x34, 0x39, 0x35, 0x61, 0x62, 0x65, 0x33, 0x38, 0x38, 0x65, 0x39, 0x65, 0x35, 0x38, 0x66, 0x62, 0x35, 0x37, 0x64, 0x37, 0x66, 0x37, 0x37, 0x38, 0x65, 0x61, 0x38, 0x36, 0x31, 0x30, 0x63, 0x34, 0x39, 0x34, 0x36, 0x66, 0x64, 0x35, 0x38, 0x37, 0x66, 0x63, 0x36, 0x61, 0x36, 0x36, 0x61, 0x64, 0x62, 0x38, 0x37, 0x36, 0x34, 0x64, 0x66, 0x65, 0x39, 0x61, 0x34, 0x39, 0x37, 0x62, 0x35, 0x65, 0x33, 0x34, 0x64, 0x36, 0x62, 0x63, 0x33, 0x32, 0x64, 0x61, 0x38, 0x66, 0x39, 0x36, 0x38, 0x30, 0x30, 0x64, 0x37, 0x35, 0x62, 0x33, 0x66, 0x63, 0x61, 0x38, 0x37, 0x63, 0x37, 0x36, 0x32, 0x34, 0x62, 0x64, 0x35, 0x64, 0x30, 0x37, 0x32, 0x63, 0x33, 0x63, 0x66, 0x64, 0x34, 0x64, 0x62, 0x66, 0x35, 0x65, 0x62, 0x64, 0x38, 0x37, 0x35, 0x64, 0x62, 0x63, 0x35, 0x38, 0x31, 0x36, 0x38, 0x63, 0x35, 0x61, 0x30, 0x38, 0x30, 0x31, 0x66, 0x61, 0x30, 0x36, 0x39, 0x31, 0x62, 0x39, 0x32, 0x35, 0x61, 0x66, 0x36, 0x62, 0x33, 0x30, 0x34, 0x37, 0x35, 0x64, 0x36, 0x34, 0x61, 0x32, 0x39, 0x62, 0x38, 0x66, 0x62, 0x65, 0x64, 0x37, 0x32, 0x61, 0x62, 0x65, 0x64, 0x31, 0x38, 0x31, 0x30, 0x36, 0x66, 0x38, 0x65, 0x64, 0x38, 0x32, 0x64, 0x30, 0x38, 0x66, 0x33, 0x63, 0x30, 0x39, 0x30, 0x63, 0x30, 0x35, 0x63, 0x36, 0x62, 0x34, 0x39, 0x32, 0x65, 0x32, 0x38, 0x63, 0x32, 0x61, 0x37, 0x36, 0x34, 0x31, 0x65, 0x36, 0x61, 0x32, 0x64, 0x33, 0x39, 0x39, 0x37, 0x64, 0x66, 0x34, 0x65, 0x65, 0x37, 0x65, 0x64, 0x34, 0x31, 0x33, 0x35, 0x66, 0x62, 0x33, 0x37, 0x36, 0x39, 0x33, 0x34, 0x63, 0x33, 0x33, 0x62, 0x35, 0x62, 0x33, 0x30, 0x39, 0x31, 0x36, 0x63, 0x38, 0x66, 0x64, 0x37, 0x38, 0x35, 0x64, 0x33, 0x62, 0x39, 0x63, 0x63, 0x64, 0x37, 0x61, 0x34, 0x65, 0x35, 0x35, 0x32, 0x33, 0x38, 0x34, 0x33, 0x62, 0x37, 0x32, 0x61, 0x63, 0x61, 0x61, 0x62, 0x35, 0x65, 0x63, 0x61, 0x37, 0x30, 0x61, 0x62, 0x62, 0x35, 0x37, 0x32, 0x31, 0x63, 0x34, 0x31, 0x65, 0x65, 0x66, 0x36, 0x38, 0x65, 0x35, 0x38, 0x62, 0x66, 0x36, 0x62, 0x36, 0x39, 0x62, 0x31, 0x64, 0x32, 0x37, 0x35, 0x61, 0x36, 0x34, 0x34, 0x32, 0x34, 0x39, 0x34, 0x64, 0x39, 0x38, 0x62, 0x39, 0x63, 0x64, 0x31, 0x39, 0x35, 0x66, 0x31, 0x62, 0x62, 0x63, 0x32, 0x65, 0x62, 0x61, 0x37, 0x30, 0x64, 0x65, 0x61, 0x30, 0x35, 0x61, 0x37, 0x65, 0x35, 0x30, 0x37, 0x34, 0x35, 0x38, 0x36, 0x31, 0x61, 0x66, 0x33, 0x32, 0x32, 0x33, 0x66, 0x32, 0x32, 0x30, 0x39, 0x31, 0x65, 0x33, 0x31, 0x64, 0x30, 0x32, 0x37, 0x34, 0x34, 0x37, 0x64, 0x32, 0x65, 0x64, 0x32, 0x34, 0x32, 0x32, 0x61, 0x33, 0x30, 0x64, 0x63, 0x62, 0x37, 0x31, 0x61, 0x38, 0x36, 0x34, 0x63, 0x66, 0x61, 0x31, 0x36, 0x31, 0x37, 0x30, 0x37, 0x62, 0x30, 0x39, 0x31, 0x64, 0x37, 0x37, 0x32, 0x31, 0x36, 0x37, 0x34, 0x35, 0x32, 0x63, 0x38, 0x66, 0x37, 0x36, 0x31, 0x38, 0x39, 0x39, 0x32, 0x35, 0x62, 0x65, 0x62, 0x32, 0x32, 0x66, 0x30, 0x66, 0x37, 0x64, 0x62, 0x38, 0x37, 0x32, 0x38, 0x61, 0x34, 0x35, 0x36, 0x63, 0x34, 0x33, 0x31, 0x39, 0x63, 0x31, 0x66, 0x30, 0x65, 0x31, 0x66, 0x37, 0x66, 0x63, 0x35, 0x31, 0x34, 0x37, 0x34, 0x66, 0x33, 0x66, 0x38, 0x64, 0x38, 0x30, 0x37, 0x33, 0x33, 0x39, 0x35, 0x37, 0x32, 0x64, 0x30, 0x66, 0x35, 0x33, 0x34, 0x37, 0x37, 0x66, 0x35, 0x61, 0x62, 0x33, 0x33, 0x33, 0x37, 0x30, 0x31, 0x38, 0x30, 0x30, 0x61, 0x35, 0x36, 0x31, 0x63, 0x32, 0x61, 0x39, 0x65, 0x31, 0x65, 0x66, 0x34, 0x36, 0x30, 0x36, 0x38, 0x66, 0x63, 0x61, 0x30, 0x63, 0x35, 0x64, 0x34, 0x30, 0x30, 0x31, 0x30, 0x62, 0x66, 0x63, 0x39, 0x64, 0x30, 0x37, 0x32, 0x39, 0x66, 0x31, 0x39, 0x32, 0x35, 0x35, 0x34, 0x66, 0x39, 0x65, 0x37, 0x62, 0x61, 0x31, 0x61, 0x30, 0x37, 0x64, 0x30, 0x35, 0x62, 0x34, 0x39, 0x38, 0x62, 0x37, 0x64, 0x62, 0x65, 0x66, 0x36, 0x34, 0x35, 0x33, 0x63, 0x36, 0x63, 0x65, 0x37, 0x65, 0x65, 0x66, 0x61, 0x63, 0x61, 0x38, 0x36, 0x63, 0x63, 0x30, 0x63, 0x65, 0x30, 0x61, 0x38, 0x61, 0x31, 0x31, 0x65, 0x62, 0x35, 0x34, 0x30, 0x38, 0x61, 0x61, 0x34, 0x65, 0x61, 0x30, 0x38, 0x38, 0x30, 0x34, 0x65, 0x62, 0x36, 0x38, 0x66, 0x61, 0x37, 0x36, 0x30, 0x36, 0x31, 0x35, 0x66, 0x65, 0x66, 0x64, 0x66, 0x37, 0x31, 0x38, 0x37, 0x35, 0x30, 0x62, 0x65, 0x65, 0x62, 0x36, 0x38, 0x61, 0x32, 0x35, 0x33, 0x35, 0x31, 0x37, 0x35, 0x66, 0x37, 0x32, 0x30, 0x63, 0x66, 0x64, 0x34, 0x36, 0x66, 0x35, 0x35, 0x34, 0x39, 0x32, 0x32, 0x31, 0x39, 0x35, 0x65, 0x33, 0x63, 0x34, 0x33, 0x35, 0x35, 0x32, 0x39, 0x61, 0x61, 0x38, 0x62, 0x39, 0x37, 0x30, 0x34, 0x37, 0x38, 0x65, 0x36, 0x33, 0x35, 0x63, 0x62, 0x33, 0x65, 0x38, 0x37, 0x35, 0x31, 0x66, 0x62, 0x30, 0x33, 0x37, 0x66, 0x30, 0x33, 0x39, 0x64, 0x63, 0x32, 0x35, 0x33, 0x61, 0x35, 0x62, 0x37, 0x66, 0x64, 0x32, 0x62, 0x32, 0x33, 0x38, 0x39, 0x63, 0x31, 0x35, 0x61, 0x35, 0x38, 0x38, 0x63, 0x32, 0x62, 0x61, 0x36, 0x30, 0x35, 0x30, 0x34, 0x38, 0x34, 0x30, 0x64, 0x36, 0x36, 0x38, 0x31, 0x61, 0x39, 0x32, 0x35, 0x62, 0x38, 0x37, 0x35, 0x34, 0x63, 0x33, 0x35, 0x66, 0x62, 0x62, 0x37, 0x62, 0x30, 0x36, 0x38, 0x32, 0x34, 0x61, 0x63, 0x66, 0x36, 0x61, 0x64, 0x38, 0x64, 0x30, 0x32, 0x66, 0x63, 0x65, 0x31, 0x37, 0x61, 0x34, 0x32, 0x34, 0x61, 0x37, 0x32, 0x64, 0x38, 0x31, 0x62, 0x35, 0x30, 0x61, 0x33, 0x62, 0x37, 0x30, 0x65, 0x36, 0x37, 0x65, 0x30, 0x63, 0x63, 0x31, 0x63, 0x30, 0x34, 0x31, 0x30, 0x62, 0x38, 0x30, 0x33, 0x66, 0x36, 0x35, 0x35, 0x64, 0x62, 0x62, 0x33, 0x63, 0x34, 0x64, 0x65, 0x37, 0x65, 0x63, 0x39, 0x36, 0x62, 0x66, 0x35, 0x37, 0x62, 0x63, 0x33, 0x35, 0x35, 0x31, 0x63, 0x65, 0x63, 0x61, 0x39, 0x30, 0x30, 0x32, 0x32, 0x32, 0x65, 0x35, 0x63, 0x34, 0x32, 0x65, 0x66, 0x35, 0x62, 0x37, 0x33, 0x33, 0x35, 0x38, 0x34, 0x30, 0x30, 0x62, 0x66, 0x31, 0x66, 0x35, 0x33, 0x36, 0x37, 0x31, 0x32, 0x66, 0x30, 0x36, 0x33, 0x61, 0x31, 0x38, 0x39, 0x34, 0x31, 0x31, 0x32, 0x39, 0x38, 0x30, 0x34, 0x35, 0x36, 0x61, 0x62, 0x33, 0x63, 0x31, 0x63, 0x65, 0x39, 0x62, 0x62, 0x37, 0x35, 0x34, 0x61, 0x62, 0x61, 0x37, 0x32, 0x63, 0x62, 0x64, 0x34, 0x35, 0x32, 0x32, 0x63, 0x34, 0x36, 0x35, 0x30, 0x37, 0x32, 0x38, 0x31, 0x34, 0x34, 0x38, 0x65, 0x65, 0x38, 0x62, 0x37, 0x37, 0x30, 0x32, 0x63, 0x66, 0x32, 0x61, 0x37, 0x38, 0x31, 0x32, 0x32, 0x65, 0x32, 0x36, 0x63, 0x61, 0x34, 0x63, 0x30, 0x31, 0x33, 0x65, 0x66, 0x66, 0x61, 0x66, 0x36, 0x66, 0x32, 0x32, 0x35, 0x33, 0x37, 0x34, 0x38, 0x64, 0x37, 0x32, 0x66, 0x37, 0x30, 0x65, 0x61, 0x63, 0x66, 0x39, 0x63, 0x35, 0x30, 0x37, 0x36, 0x66, 0x39, 0x65, 0x34, 0x65, 0x31, 0x63, 0x36, 0x38, 0x37, 0x62, 0x38, 0x35, 0x33, 0x65, 0x36, 0x61, 0x39, 0x33, 0x61, 0x61, 0x33, 0x36, 0x31, 0x62, 0x32, 0x63, 0x65, 0x62, 0x34, 0x39, 0x32, 0x39, 0x38, 0x30, 0x35, 0x30, 0x64, 0x65, 0x34, 0x32, 0x37, 0x61, 0x66, 0x38, 0x66, 0x34, 0x32, 0x35, 0x37, 0x37, 0x32, 0x61, 0x61, 0x36, 0x39, 0x35, 0x37, 0x64, 0x30, 0x39, 0x64, 0x63, 0x36, 0x64, 0x36, 0x63, 0x34, 0x36, 0x31, 0x35, 0x34, 0x62, 0x30, 0x66, 0x65, 0x33, 0x35, 0x31, 0x65, 0x33, 0x64, 0x61, 0x61, 0x34, 0x31, 0x30, 0x34, 0x34, 0x36, 0x30, 0x64, 0x34, 0x31, 0x39, 0x39, 0x31, 0x66, 0x63, 0x35, 0x66, 0x64, 0x38, 0x37, 0x64, 0x66, 0x32, 0x34, 0x35, 0x36, 0x64, 0x36, 0x65, 0x38, 0x37, 0x32, 0x39, 0x36, 0x64, 0x61, 0x36, 0x32, 0x30, 0x38, 0x36, 0x62, 0x65, 0x34, 0x66, 0x37, 0x33, 0x39, 0x37, 0x31, 0x35, 0x63, 0x63, 0x64, 0x34, 0x35, 0x61, 0x32, 0x30, 0x35, 0x36, 0x30, 0x35, 0x33, 0x65, 0x66, 0x32, 0x38, 0x38, 0x31, 0x63, 0x34, 0x63, 0x35, 0x33, 0x34, 0x34, 0x66, 0x32, 0x63, 0x30, 0x35, 0x63, 0x34, 0x62, 0x38, 0x63, 0x38, 0x36, 0x64, 0x66, 0x32, 0x65, 0x30, 0x37, 0x32, 0x66, 0x62, 0x33, 0x38, 0x35, 0x65, 0x61, 0x36, 0x62, 0x37, 0x66, 0x36, 0x61, 0x32, 0x64, 0x65, 0x36, 0x35, 0x63, 0x66, 0x38, 0x61, 0x33, 0x33, 0x64, 0x37, 0x37, 0x37, 0x39, 0x62, 0x38, 0x30, 0x66, 0x62, 0x64, 0x61, 0x38, 0x62, 0x39, 0x32, 0x65, 0x38, 0x33, 0x37, 0x34, 0x65, 0x61, 0x35, 0x37, 0x37, 0x35, 0x38, 0x32, 0x39, 0x61, 0x36, 0x35, 0x64, 0x30, 0x63, 0x30, 0x61, 0x37, 0x32, 0x35, 0x35, 0x37, 0x31, 0x62, 0x36, 0x32, 0x37, 0x32, 0x63, 0x61, 0x35, 0x66, 0x32, 0x31, 0x35, 0x63, 0x38, 0x33, 0x65, 0x34, 0x37, 0x65, 0x65, 0x63, 0x36, 0x36, 0x31, 0x32, 0x39, 0x61, 0x33, 0x62, 0x37, 0x61, 0x64, 0x36, 0x37, 0x65, 0x66, 0x31, 0x35, 0x65, 0x30, 0x61, 0x33, 0x30, 0x61, 0x38, 0x62, 0x39, 0x37, 0x62, 0x61, 0x62, 0x33, 0x63, 0x61, 0x61, 0x35, 0x63, 0x38, 0x30, 0x31, 0x37, 0x33, 0x32, 0x65, 0x63, 0x33, 0x32, 0x66, 0x62, 0x66, 0x31, 0x62, 0x37, 0x32, 0x61, 0x65, 0x62, 0x34, 0x61, 0x34, 0x64, 0x31, 0x65, 0x63, 0x38, 0x65, 0x64, 0x63, 0x34, 0x33, 0x63, 0x61, 0x30, 0x31, 0x34, 0x66, 0x65, 0x38, 0x65, 0x65, 0x35, 0x65, 0x30, 0x33, 0x37, 0x37, 0x64, 0x33, 0x36, 0x36, 0x66, 0x37, 0x65, 0x31, 0x30, 0x32, 0x34, 0x39, 0x32, 0x32, 0x39, 0x61, 0x35, 0x64, 0x38, 0x33, 0x30, 0x35, 0x33, 0x61, 0x34, 0x64, 0x36, 0x30, 0x38, 0x33, 0x34, 0x65, 0x31, 0x35, 0x62, 0x61, 0x38, 0x37, 0x62, 0x62, 0x37, 0x65, 0x65, 0x32, 0x36, 0x64, 0x36, 0x34, 0x39, 0x65, 0x38, 0x36, 0x37, 0x39, 0x62, 0x30, 0x30, 0x61, 0x31, 0x33, 0x38, 0x37, 0x30, 0x34, 0x63, 0x32, 0x38, 0x34, 0x34, 0x32, 0x30, 0x32, 0x33, 0x65, 0x31, 0x31, 0x34, 0x38, 0x62, 0x66, 0x37, 0x32, 0x64, 0x38, 0x63, 0x35, 0x32, 0x64, 0x65, 0x34, 0x32, 0x66, 0x33, 0x32, 0x30, 0x62, 0x33, 0x34, 0x31, 0x63, 0x33, 0x37, 0x37, 0x61, 0x31, 0x33, 0x39, 0x66, 0x37, 0x62, 0x31, 0x63, 0x32, 0x36, 0x62, 0x62, 0x39, 0x32, 0x32, 0x33, 0x36, 0x61, 0x64, 0x61, 0x32, 0x65, 0x65, 0x65, 0x62, 0x36, 0x31, 0x32, 0x65, 0x35, 0x64, 0x66, 0x30, 0x64, 0x35, 0x36, 0x31, 0x38, 0x34, 0x33, 0x34, 0x30, 0x32, 0x37, 0x38, 0x33, 0x35, 0x66, 0x33, 0x36, 0x34, 0x61, 0x64, 0x33, 0x39, 0x33, 0x31, 0x66, 0x36, 0x39, 0x39, 0x61, 0x34, 0x38, 0x35, 0x31, 0x65, 0x36, 0x65, 0x31, 0x39, 0x33, 0x36, 0x62, 0x34, 0x65, 0x31, 0x65, 0x35, 0x65, 0x35, 0x66, 0x32, 0x37, 0x65, 0x30, 0x63, 0x30, 0x30, 0x64, 0x30, 0x36, 0x64, 0x39, 0x32, 0x65, 0x64, 0x34, 0x34, 0x30, 0x63, 0x39, 0x63, 0x36, 0x31, 0x30, 0x38, 0x65, 0x65, 0x37, 0x39, 0x31, 0x30, 0x33, 0x34, 0x35, 0x66, 0x39, 0x37, 0x65, 0x31, 0x62, 0x35, 0x63, 0x63, 0x36, 0x33, 0x36, 0x34, 0x38, 0x62, 0x33, 0x34, 0x31, 0x36, 0x36, 0x36, 0x34, 0x62, 0x62, 0x37, 0x65, 0x30, 0x61, 0x36, 0x39, 0x32, 0x30, 0x64, 0x33, 0x30, 0x63, 0x35, 0x35, 0x65, 0x64, 0x35, 0x35, 0x35, 0x63, 0x65, 0x32, 0x33, 0x39, 0x62, 0x65, 0x61, 0x65, 0x34, 0x31, 0x66, 0x37, 0x36, 0x66, 0x63, 0x32, 0x31, 0x66, 0x36, 0x30, 0x39, 0x64, 0x37, 0x38, 0x35, 0x38, 0x33, 0x62, 0x31, 0x33, 0x31, 0x37, 0x38, 0x38, 0x65, 0x64, 0x63, 0x36, 0x61, 0x34, 0x65, 0x61, 0x34, 0x35, 0x62, 0x31, 0x62, 0x38, 0x30, 0x34, 0x39, 0x64, 0x64, 0x37, 0x32, 0x36, 0x31, 0x34, 0x62, 0x37, 0x63, 0x36, 0x63, 0x31, 0x37, 0x62, 0x34, 0x64, 0x33, 0x35, 0x37, 0x39, 0x37, 0x32, 0x62, 0x35, 0x32, 0x66, 0x32, 0x63, 0x61, 0x31, 0x33, 0x65, 0x32, 0x36, 0x32, 0x61, 0x66, 0x31, 0x61, 0x64, 0x36, 0x66, 0x38, 0x62, 0x65, 0x61, 0x33, 0x33, 0x37, 0x65, 0x37, 0x64, 0x34, 0x61, 0x32, 0x33, 0x64, 0x33, 0x30, 0x61, 0x30, 0x34, 0x64, 0x33, 0x65, 0x36, 0x66, 0x63, 0x34, 0x31, 0x37, 0x36, 0x62, 0x64, 0x39, 0x64, 0x33, 0x61, 0x64, 0x66, 0x66, 0x32, 0x61, 0x61, 0x33, 0x31, 0x32, 0x39, 0x33, 0x38, 0x32, 0x39, 0x38, 0x62, 0x61, 0x61, 0x62, 0x61, 0x34, 0x31, 0x37, 0x30, 0x36, 0x66, 0x62, 0x36, 0x65, 0x61, 0x31, 0x66, 0x64, 0x32, 0x61, 0x66, 0x64, 0x37, 0x36, 0x64, 0x39, 0x32, 0x64, 0x31, 0x39, 0x38, 0x35, 0x38, 0x30, 0x61, 0x61, 0x38, 0x61, 0x63, 0x63, 0x65, 0x34, 0x62, 0x34, 0x30, 0x39, 0x62, 0x39, 0x65, 0x65, 0x35, 0x66, 0x62, 0x66, 0x30, 0x37, 0x32, 0x31, 0x34, 0x61, 0x62, 0x65, 0x33, 0x34, 0x31, 0x39, 0x35, 0x64, 0x33, 0x33, 0x35, 0x63, 0x31, 0x36, 0x61, 0x65, 0x33, 0x65, 0x31, 0x63, 0x36, 0x64, 0x34, 0x32, 0x38, 0x66, 0x34, 0x35, 0x31, 0x66, 0x65, 0x34, 0x32, 0x65, 0x32, 0x62, 0x65, 0x63, 0x66, 0x31, 0x31, 0x31, 0x65, 0x30, 0x35, 0x31, 0x31, 0x35, 0x63, 0x32, 0x35, 0x63, 0x34, 0x65, 0x34, 0x62, 0x33, 0x64, 0x39, 0x37, 0x32, 0x38, 0x64, 0x65, 0x36, 0x62, 0x35, 0x63, 0x34, 0x66, 0x62, 0x38, 0x30, 0x63, 0x66, 0x64, 0x61, 0x66, 0x66, 0x32, 0x33, 0x66, 0x36, 0x61, 0x30, 0x37, 0x63, 0x35, 0x30, 0x30, 0x34, 0x30, 0x62, 0x34, 0x34, 0x33, 0x65, 0x64, 0x62, 0x35, 0x65, 0x30, 0x64, 0x38, 0x61, 0x36, 0x64, 0x64, 0x39, 0x35, 0x62, 0x61, 0x65, 0x30, 0x32, 0x61, 0x36, 0x65, 0x31, 0x35, 0x66, 0x36, 0x33, 0x35, 0x65, 0x35, 0x34, 0x39, 0x65, 0x38, 0x61, 0x38, 0x38, 0x31, 0x32, 0x66, 0x34, 0x37, 0x61, 0x61, 0x33, 0x31, 0x37, 0x33, 0x66, 0x31, 0x33, 0x65, 0x32, 0x36, 0x66, 0x61, 0x30, 0x36, 0x35, 0x37, 0x32, 0x61, 0x32, 0x32, 0x62, 0x33, 0x62, 0x35, 0x30, 0x66, 0x64, 0x62, 0x32, 0x37, 0x63, 0x30, 0x38, 0x63, 0x34, 0x31, 0x39, 0x61, 0x32, 0x33, 0x37, 0x64, 0x35, 0x38, 0x62, 0x61, 0x66, 0x37, 0x32, 0x37, 0x37, 0x64, 0x30, 0x38, 0x39, 0x62, 0x65, 0x33, 0x63, 0x33, 0x63, 0x37, 0x34, 0x36, 0x30, 0x39, 0x65, 0x65, 0x62, 0x35, 0x65, 0x38, 0x64, 0x37, 0x35, 0x34, 0x61, 0x64, 0x65, 0x37, 0x64, 0x34, 0x62, 0x32, 0x33, 0x66, 0x30, 0x36, 0x62, 0x30, 0x33, 0x39, 0x33, 0x32, 0x39, 0x31, 0x31, 0x39, 0x62, 0x65, 0x64, 0x37, 0x61, 0x66, 0x64, 0x37, 0x39, 0x32, 0x33, 0x31, 0x34, 0x34, 0x37, 0x63, 0x62, 0x36, 0x39, 0x32, 0x66, 0x35, 0x33, 0x36, 0x34, 0x32, 0x38, 0x35, 0x34, 0x61, 0x63, 0x66, 0x62, 0x66, 0x35, 0x62, 0x65, 0x38, 0x65, 0x38, 0x31, 0x35, 0x37, 0x37, 0x33, 0x37, 0x31, 0x32, 0x39, 0x32, 0x35, 0x33, 0x62, 0x35, 0x64, 0x32, 0x30, 0x66, 0x39, 0x33, 0x62, 0x34, 0x35, 0x64, 0x61, 0x39, 0x62, 0x36, 0x64, 0x61, 0x66, 0x62, 0x63, 0x63, 0x38, 0x30, 0x66, 0x32, 0x39, 0x36, 0x31, 0x37, 0x34, 0x33, 0x63, 0x61, 0x31, 0x61, 0x61, 0x35, 0x36, 0x34, 0x37, 0x34, 0x39, 0x61, 0x32, 0x31, 0x35, 0x32, 0x39, 0x34, 0x66, 0x66, 0x35, 0x33, 0x66, 0x35, 0x35, 0x61, 0x36, 0x37, 0x36, 0x39, 0x64, 0x61, 0x36, 0x33, 0x35, 0x35, 0x35, 0x37, 0x31, 0x62, 0x37, 0x35, 0x63, 0x61, 0x39, 0x65, 0x62, 0x31, 0x66, 0x35, 0x37, 0x64, 0x61, 0x33, 0x65, 0x30, 0x38, 0x35, 0x30, 0x32, 0x37, 0x66, 0x64, 0x61, 0x64, 0x62, 0x61, 0x37, 0x31, 0x61, 0x35, 0x37, 0x61, 0x33, 0x31, 0x32, 0x66, 0x64, 0x39, 0x38, 0x33, 0x37, 0x37, 0x32, 0x65, 0x30, 0x37, 0x62, 0x38, 0x63, 0x63, 0x37, 0x34, 0x35, 0x61, 0x34, 0x39, 0x30, 0x37, 0x33, 0x63, 0x37, 0x61, 0x64, 0x39, 0x62, 0x30, 0x61, 0x63, 0x30, 0x30, 0x31, 0x34, 0x61, 0x66, 0x37, 0x31, 0x63, 0x34, 0x39, 0x30, 0x36, 0x31, 0x66, 0x61, 0x38, 0x36, 0x38, 0x39, 0x32, 0x63, 0x31, 0x32, 0x34, 0x34, 0x34, 0x62, 0x31, 0x31, 0x39, 0x62, 0x31, 0x61, 0x32, 0x64, 0x30, 0x33, 0x35, 0x30, 0x37, 0x61, 0x65, 0x64, 0x36, 0x34, 0x32, 0x62, 0x61, 0x62, 0x66, 0x33, 0x37, 0x65, 0x35, 0x61, 0x63, 0x39, 0x65, 0x62, 0x32, 0x38, 0x64, 0x66, 0x62, 0x66, 0x32, 0x32, 0x64, 0x36, 0x35, 0x30, 0x65, 0x38, 0x38, 0x35, 0x37, 0x32, 0x30, 0x35, 0x37, 0x32, 0x32, 0x65, 0x35, 0x33, 0x30, 0x39, 0x32, 0x64, 0x35, 0x35, 0x36, 0x61, 0x63, 0x62, 0x63, 0x62, 0x37, 0x65, 0x65, 0x63, 0x33, 0x63, 0x31, 0x37, 0x32, 0x65, 0x39, 0x65, 0x34, 0x61, 0x39, 0x38, 0x35, 0x64, 0x30, 0x65, 0x34, 0x35, 0x65, 0x63, 0x65, 0x36, 0x63, 0x33, 0x38, 0x62, 0x63, 0x61, 0x30, 0x32, 0x31, 0x38, 0x30, 0x35, 0x66, 0x34, 0x35, 0x65, 0x31, 0x35, 0x35, 0x38, 0x35, 0x36, 0x63, 0x36, 0x39, 0x30, 0x61, 0x64, 0x37, 0x62, 0x36, 0x32, 0x30, 0x62, 0x65, 0x37, 0x38, 0x66, 0x39, 0x35, 0x39, 0x36, 0x34, 0x37, 0x63, 0x36, 0x62, 0x38, 0x63, 0x36, 0x34, 0x30, 0x37, 0x39, 0x34, 0x63, 0x62, 0x39, 0x61, 0x32, 0x32, 0x63, 0x32, 0x35, 0x61, 0x38, 0x61, 0x62, 0x65, 0x35, 0x34, 0x35, 0x61, 0x31, 0x33, 0x38, 0x36, 0x36, 0x66, 0x36, 0x33, 0x31, 0x31, 0x33, 0x62, 0x34, 0x63, 0x66, 0x61, 0x61, 0x63, 0x65, 0x66, 0x35, 0x30, 0x65, 0x32, 0x34, 0x39, 0x39, 0x37, 0x33, 0x35, 0x33, 0x38, 0x64, 0x39, 0x66, 0x33, 0x34, 0x32, 0x63, 0x65, 0x39, 0x38, 0x62, 0x36, 0x36, 0x63, 0x31, 0x63, 0x30, 0x64, 0x36, 0x65, 0x63, 0x32, 0x36, 0x62, 0x34, 0x66, 0x61, 0x37, 0x66, 0x61, 0x36, 0x38, 0x34, 0x31, 0x38, 0x35, 0x30, 0x39, 0x36, 0x35, 0x31, 0x30, 0x65, 0x39, 0x64, 0x62, 0x31, 0x31, 0x39, 0x30, 0x62, 0x36, 0x36, 0x33, 0x63, 0x39, 0x36, 0x66, 0x63, 0x35, 0x62, 0x66, 0x34, 0x64, 0x31, 0x64, 0x34, 0x63, 0x30, 0x34, 0x34, 0x38, 0x37, 0x32, 0x39, 0x61, 0x64, 0x66, 0x65, 0x61, 0x36, 0x38, 0x31, 0x37, 0x39, 0x63, 0x34, 0x66, 0x64, 0x36, 0x65, 0x36, 0x35, 0x64, 0x66, 0x35, 0x38, 0x30, 0x34, 0x33, 0x34, 0x34, 0x61, 0x37, 0x32, 0x39, 0x36, 0x39, 0x63, 0x35, 0x33, 0x36, 0x62, 0x34, 0x36, 0x65, 0x38, 0x31, 0x35, 0x32, 0x61, 0x36, 0x37, 0x39, 0x38, 0x65, 0x61, 0x32, 0x63, 0x36, 0x65, 0x66, 0x35, 0x36, 0x66, 0x39, 0x34, 0x66, 0x31, 0x38, 0x30, 0x34, 0x64, 0x38, 0x35, 0x64, 0x39, 0x66, 0x66, 0x34, 0x66, 0x37, 0x66, 0x31, 0x38, 0x36, 0x30, 0x61, 0x30, 0x32, 0x31, 0x61, 0x65, 0x31, 0x31, 0x65, 0x65, 0x30, 0x35, 0x31, 0x33, 0x34, 0x32, 0x30, 0x30, 0x65, 0x33, 0x66, 0x33, 0x34, 0x31, 0x30, 0x65, 0x37, 0x63, 0x66, 0x38, 0x30, 0x34, 0x32, 0x36, 0x30, 0x66, 0x31, 0x35, 0x31, 0x30, 0x39, 0x36, 0x34, 0x39, 0x62, 0x33, 0x37, 0x36, 0x33, 0x36, 0x38, 0x65, 0x37, 0x32, 0x35, 0x30, 0x31, 0x36, 0x34, 0x66, 0x61, 0x36, 0x39, 0x37, 0x65, 0x36, 0x30, 0x31, 0x66, 0x38, 0x39, 0x37, 0x61, 0x64, 0x37, 0x32, 0x66, 0x64, 0x39, 0x64, 0x37, 0x37, 0x65, 0x64, 0x63, 0x65, 0x32, 0x61, 0x64, 0x33, 0x36, 0x63, 0x35, 0x64, 0x30, 0x36, 0x31, 0x38, 0x33, 0x37, 0x65, 0x62, 0x39, 0x35, 0x38, 0x66, 0x65, 0x33, 0x62, 0x62, 0x61, 0x35, 0x62, 0x61, 0x36, 0x37, 0x37, 0x64, 0x63, 0x66, 0x35, 0x33, 0x65, 0x62, 0x35, 0x63, 0x32, 0x62, 0x32, 0x66, 0x36, 0x39, 0x33, 0x31, 0x37, 0x33, 0x62, 0x66, 0x37, 0x32, 0x61, 0x62, 0x63, 0x66, 0x62, 0x34, 0x32, 0x38, 0x38, 0x33, 0x39, 0x64, 0x34, 0x33, 0x64, 0x34, 0x65, 0x34, 0x63, 0x30, 0x38, 0x31, 0x35, 0x64, 0x32, 0x37, 0x65, 0x64, 0x63, 0x38, 0x64, 0x37, 0x37, 0x66, 0x36, 0x36, 0x31, 0x37, 0x30, 0x66, 0x32, 0x37, 0x38, 0x30, 0x30, 0x63, 0x37, 0x65, 0x38, 0x66, 0x39, 0x38, 0x35, 0x61, 0x62, 0x37, 0x66, 0x33, 0x34, 0x36, 0x38, 0x35, 0x37, 0x32, 0x64, 0x30, 0x64, 0x30, 0x31, 0x63, 0x66, 0x30, 0x37, 0x37, 0x66, 0x39, 0x32, 0x61, 0x34, 0x32, 0x39, 0x34, 0x63, 0x30, 0x39, 0x39, 0x62, 0x36, 0x30, 0x33, 0x62, 0x36, 0x33, 0x63, 0x63, 0x33, 0x61, 0x62, 0x62, 0x65, 0x61, 0x31, 0x38, 0x63, 0x63, 0x35, 0x66, 0x37, 0x34, 0x35, 0x36, 0x66, 0x34, 0x66, 0x63, 0x65, 0x37, 0x31, 0x34, 0x38, 0x38, 0x35, 0x36, 0x39, 0x62, 0x39, 0x32, 0x35, 0x38, 0x35, 0x64, 0x32, 0x32, 0x31, 0x35, 0x32, 0x61, 0x64, 0x32, 0x32, 0x31, 0x30, 0x30, 0x37, 0x63, 0x66, 0x32, 0x33, 0x35, 0x36, 0x32, 0x32, 0x39, 0x65, 0x33, 0x39, 0x33, 0x61, 0x38, 0x33, 0x31, 0x35, 0x30, 0x61, 0x63, 0x66, 0x39, 0x30, 0x64, 0x32, 0x36, 0x65, 0x33, 0x35, 0x66, 0x33, 0x37, 0x35, 0x30, 0x61, 0x32, 0x66, 0x35, 0x31, 0x31, 0x39, 0x31, 0x61, 0x65, 0x33, 0x30, 0x66, 0x34, 0x34, 0x32, 0x35, 0x34, 0x66, 0x64, 0x63, 0x64, 0x61, 0x34, 0x65, 0x32, 0x63, 0x65, 0x31, 0x38, 0x32, 0x39, 0x61, 0x61, 0x63, 0x61, 0x63, 0x30, 0x37, 0x36, 0x61, 0x34, 0x66, 0x62, 0x32, 0x36, 0x33, 0x33, 0x39, 0x35, 0x31, 0x65, 0x65, 0x31, 0x31, 0x61, 0x62, 0x33, 0x32, 0x62, 0x33, 0x66, 0x39, 0x61, 0x38, 0x30, 0x39, 0x38, 0x37, 0x31, 0x61, 0x35, 0x35, 0x38, 0x32, 0x37, 0x32, 0x38, 0x62, 0x63, 0x64, 0x31, 0x35, 0x30, 0x35, 0x34, 0x65, 0x39, 0x62, 0x32, 0x34, 0x33, 0x30, 0x33, 0x37, 0x39, 0x30, 0x37, 0x34, 0x38, 0x30, 0x66, 0x30, 0x65, 0x63, 0x63, 0x34, 0x64, 0x63, 0x34, 0x31, 0x37, 0x65, 0x64, 0x36, 0x31, 0x64, 0x63, 0x32, 0x34, 0x30, 0x62, 0x65, 0x63, 0x66, 0x61, 0x35, 0x63, 0x31, 0x38, 0x38, 0x65, 0x34, 0x66, 0x31, 0x31, 0x39, 0x65, 0x34, 0x34, 0x36, 0x39, 0x63, 0x39, 0x61, 0x38, 0x31, 0x38, 0x38, 0x38, 0x62, 0x33, 0x36, 0x38, 0x65, 0x38, 0x30, 0x61, 0x30, 0x34, 0x63, 0x35, 0x33, 0x31, 0x34, 0x33, 0x39, 0x39, 0x61, 0x38, 0x39, 0x38, 0x38, 0x31, 0x36, 0x30, 0x66, 0x31, 0x66, 0x34, 0x30, 0x30, 0x63, 0x36, 0x34, 0x65, 0x63, 0x63, 0x63, 0x30, 0x61, 0x33, 0x34, 0x33, 0x65, 0x64, 0x37, 0x33, 0x37, 0x39, 0x33, 0x38, 0x37, 0x30, 0x31, 0x36, 0x32, 0x32, 0x62, 0x65, 0x63, 0x36, 0x34, 0x39, 0x65, 0x35, 0x36, 0x38, 0x39, 0x36, 0x31, 0x63, 0x61, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x62, 0x38, 0x37, 0x64, 0x31, 0x30, 0x31, 0x31, 0x37, 0x61, 0x61, 0x39, 0x37, 0x65, 0x61, 0x63, 0x63, 0x63, 0x39, 0x34, 0x65, 0x66, 0x33, 0x61, 0x37, 0x39, 0x37, 0x39, 0x33, 0x38, 0x30, 0x64, 0x63, 0x61, 0x61, 0x31, 0x32, 0x30, 0x35, 0x36, 0x39, 0x63, 0x61, 0x30, 0x36, 0x39, 0x37, 0x35, 0x64, 0x61, 0x35, 0x31, 0x35, 0x33, 0x36, 0x62, 0x31, 0x38, 0x31, 0x64, 0x63, 0x33, 0x35, 0x63, 0x62, 0x36, 0x38, 0x63, 0x33, 0x30, 0x63, 0x30, 0x39, 0x30, 0x66, 0x37, 0x65, 0x66, 0x32, 0x30, 0x37, 0x38, 0x63, 0x32, 0x66, 0x65, 0x30, 0x32, 0x31, 0x32, 0x65, 0x61, 0x37, 0x32, 0x30, 0x61, 0x32, 0x31, 0x62, 0x30, 0x30, 0x61, 0x37, 0x32, 0x34, 0x61, 0x31, 0x32, 0x39, 0x36, 0x32, 0x65, 0x63, 0x30, 0x62, 0x39, 0x62, 0x34, 0x34, 0x35, 0x34, 0x65, 0x37, 0x38, 0x64, 0x38, 0x61, 0x37, 0x65, 0x63, 0x33, 0x32, 0x38, 0x65, 0x61, 0x61, 0x63, 0x38, 0x39, 0x31, 0x35, 0x36, 0x38, 0x32, 0x61, 0x39, 0x35, 0x63, 0x38, 0x36, 0x32, 0x61, 0x63, 0x34, 0x64, 0x37, 0x30, 0x65, 0x34, 0x34, 0x65, 0x64, 0x63, 0x30, 0x66, 0x61, 0x37, 0x32, 0x65, 0x34, 0x36, 0x33, 0x33, 0x35, 0x64, 0x34, 0x61, 0x31, 0x30, 0x62, 0x38, 0x32, 0x34, 0x65, 0x65, 0x38, 0x63, 0x32, 0x61, 0x30, 0x62, 0x35, 0x63, 0x30, 0x33, 0x37, 0x65, 0x63, 0x64, 0x39, 0x61, 0x36, 0x32, 0x30, 0x30, 0x30, 0x32, 0x39, 0x38, 0x62, 0x65, 0x65, 0x38, 0x64, 0x65, 0x62, 0x65, 0x35, 0x39, 0x62, 0x30, 0x65, 0x32, 0x61, 0x65, 0x33, 0x32, 0x38, 0x32, 0x33, 0x37, 0x32, 0x65, 0x31, 0x63, 0x37, 0x36, 0x34, 0x65, 0x62, 0x38, 0x38, 0x34, 0x65, 0x65, 0x61, 0x61, 0x38, 0x36, 0x66, 0x33, 0x32, 0x31, 0x32, 0x66, 0x36, 0x38, 0x32, 0x30, 0x37, 0x62, 0x62, 0x31, 0x30, 0x31, 0x33, 0x62, 0x63, 0x37, 0x37, 0x34, 0x61, 0x61, 0x38, 0x38, 0x32, 0x30, 0x39, 0x39, 0x33, 0x30, 0x65, 0x35, 0x33, 0x33, 0x38, 0x30, 0x38, 0x63, 0x39, 0x35, 0x61, 0x62, 0x30, 0x37, 0x32, 0x36, 0x34, 0x65, 0x62, 0x39, 0x30, 0x30, 0x66, 0x37, 0x33, 0x33, 0x63, 0x35, 0x37, 0x36, 0x66, 0x37, 0x36, 0x30, 0x32, 0x39, 0x64, 0x63, 0x63, 0x35, 0x31, 0x38, 0x62, 0x62, 0x37, 0x38, 0x65, 0x30, 0x65, 0x64, 0x31, 0x64, 0x32, 0x33, 0x39, 0x35, 0x32, 0x37, 0x63, 0x32, 0x32, 0x36, 0x34, 0x35, 0x33, 0x36, 0x32, 0x37, 0x64, 0x66, 0x39, 0x37, 0x36, 0x39, 0x38, 0x66, 0x39, 0x37, 0x32, 0x37, 0x63, 0x64, 0x30, 0x38, 0x61, 0x61, 0x38, 0x33, 0x33, 0x34, 0x35, 0x63, 0x63, 0x65, 0x39, 0x62, 0x30, 0x62, 0x38, 0x35, 0x34, 0x30, 0x61, 0x31, 0x65, 0x33, 0x36, 0x32, 0x62, 0x62, 0x34, 0x63, 0x38, 0x62, 0x33, 0x31, 0x61, 0x65, 0x62, 0x32, 0x35, 0x38, 0x38, 0x37, 0x65, 0x64, 0x38, 0x66, 0x62, 0x37, 0x66, 0x66, 0x32, 0x32, 0x61, 0x66, 0x39, 0x32, 0x65, 0x34, 0x39, 0x37, 0x32, 0x33, 0x35, 0x62, 0x35, 0x35, 0x38, 0x37, 0x31, 0x30, 0x32, 0x63, 0x61, 0x36, 0x39, 0x34, 0x30, 0x34, 0x61, 0x33, 0x36, 0x32, 0x33, 0x61, 0x63, 0x37, 0x63, 0x65, 0x38, 0x35, 0x61, 0x38, 0x30, 0x32, 0x66, 0x62, 0x61, 0x63, 0x38, 0x66, 0x61, 0x33, 0x64, 0x61, 0x39, 0x32, 0x62, 0x65, 0x62, 0x63, 0x39, 0x66, 0x33, 0x66, 0x33, 0x30, 0x34, 0x66, 0x63, 0x63, 0x66, 0x66, 0x33, 0x37, 0x32, 0x66, 0x66, 0x64, 0x34, 0x30, 0x37, 0x34, 0x34, 0x31, 0x30, 0x62, 0x65, 0x66, 0x37, 0x30, 0x39, 0x31, 0x66, 0x35, 0x31, 0x65, 0x63, 0x30, 0x61, 0x38, 0x66, 0x61, 0x65, 0x65, 0x32, 0x66, 0x35, 0x38, 0x37, 0x61, 0x33, 0x30, 0x38, 0x30, 0x33, 0x34, 0x62, 0x36, 0x39, 0x30, 0x37, 0x39, 0x64, 0x66, 0x63, 0x31, 0x32, 0x62, 0x38, 0x38, 0x33, 0x63, 0x36, 0x33, 0x66, 0x37, 0x65, 0x37, 0x32, 0x38, 0x38, 0x32, 0x35, 0x30, 0x38, 0x30, 0x32, 0x65, 0x33, 0x64, 0x64, 0x39, 0x66, 0x65, 0x61, 0x65, 0x66, 0x63, 0x35, 0x35, 0x66, 0x66, 0x34, 0x62, 0x33, 0x37, 0x65, 0x61, 0x66, 0x64, 0x30, 0x62, 0x66, 0x64, 0x38, 0x35, 0x39, 0x31, 0x62, 0x63, 0x65, 0x62, 0x62, 0x66, 0x30, 0x31, 0x30, 0x30, 0x65, 0x63, 0x61, 0x39, 0x34, 0x31, 0x64, 0x39, 0x61, 0x37, 0x34, 0x66, 0x38, 0x30, 0x30, 0x37, 0x66, 0x62, 0x32, 0x66, 0x64, 0x34, 0x37, 0x32, 0x33, 0x30, 0x39, 0x65, 0x62, 0x34, 0x38, 0x38, 0x63, 0x34, 0x64, 0x37, 0x63, 0x34, 0x65, 0x62, 0x65, 0x62, 0x35, 0x65, 0x64, 0x63, 0x35, 0x63, 0x66, 0x32, 0x66, 0x32, 0x34, 0x66, 0x37, 0x61, 0x34, 0x35, 0x31, 0x33, 0x66, 0x38, 0x37, 0x63, 0x39, 0x65, 0x32, 0x31, 0x32, 0x30, 0x66, 0x35, 0x34, 0x62, 0x62, 0x31, 0x31, 0x33, 0x38, 0x30, 0x35, 0x61, 0x63, 0x38, 0x65, 0x32, 0x33, 0x63, 0x36, 0x39, 0x35, 0x61, 0x39, 0x33, 0x64, 0x30, 0x38, 0x39, 0x32, 0x66, 0x63, 0x61, 0x39, 0x38, 0x66, 0x62, 0x36, 0x35, 0x37, 0x35, 0x39, 0x61, 0x30, 0x31, 0x64, 0x66, 0x31, 0x64, 0x62, 0x36, 0x66, 0x62, 0x37, 0x66, 0x35, 0x33, 0x65, 0x35, 0x37, 0x34, 0x63, 0x61, 0x66, 0x61, 0x38, 0x62, 0x31, 0x62, 0x31, 0x32, 0x65, 0x37, 0x32, 0x61, 0x33, 0x35, 0x61, 0x30, 0x65, 0x36, 0x37, 0x66, 0x37, 0x35, 0x62, 0x64, 0x61, 0x34, 0x34, 0x30, 0x34, 0x34, 0x35, 0x30, 0x34, 0x65, 0x34, 0x31, 0x63, 0x30, 0x66, 0x36, 0x66, 0x36, 0x63, 0x62, 0x37, 0x37, 0x61, 0x30, 0x33, 0x66, 0x64, 0x31, 0x32, 0x37, 0x36, 0x31, 0x61, 0x37, 0x64, 0x35, 0x34, 0x34, 0x34, 0x31, 0x63, 0x33, 0x30, 0x39, 0x66, 0x39, 0x33, 0x39, 0x32, 0x37, 0x32, 0x31, 0x32, 0x63, 0x61, 0x34, 0x35, 0x65, 0x35, 0x34, 0x62, 0x37, 0x37, 0x36, 0x39, 0x61, 0x37, 0x39, 0x34, 0x36, 0x61, 0x61, 0x33, 0x34, 0x63, 0x64, 0x66, 0x38, 0x31, 0x39, 0x61, 0x31, 0x62, 0x66, 0x64, 0x37, 0x35, 0x33, 0x30, 0x61, 0x62, 0x64, 0x63, 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x31, 0x39, 0x35, 0x61, 0x38, 0x36, 0x31, 0x38, 0x31, 0x33, 0x62, 0x31, 0x66, 0x37, 0x30, 0x66, 0x62, 0x30, 0x66, 0x63, 0x31, 0x35, 0x39, 0x37, 0x62, 0x35, 0x33, 0x61, 0x39, 0x64, 0x61, 0x33, 0x61, 0x38, 0x61, 0x64, 0x64, 0x63, 0x66, 0x32, 0x33, 0x31, 0x66, 0x61, 0x62, 0x33, 0x39, 0x39, 0x32, 0x34, 0x30, 0x62, 0x63, 0x33, 0x37, 0x37, 0x30, 0x37, 0x65, 0x34, 0x31, 0x35, 0x32, 0x65, 0x34, 0x30, 0x33, 0x30, 0x35, 0x62, 0x34, 0x64, 0x36, 0x30, 0x35, 0x38, 0x65, 0x65, 0x37, 0x32, 0x38, 0x61, 0x64, 0x35, 0x34, 0x36, 0x30, 0x39, 0x39, 0x65, 0x37, 0x30, 0x64, 0x64, 0x36, 0x38, 0x66, 0x66, 0x30, 0x61, 0x32, 0x30, 0x31, 0x36, 0x61, 0x35, 0x37, 0x32, 0x36, 0x62, 0x37, 0x33, 0x30, 0x34, 0x30, 0x31, 0x31, 0x63, 0x37, 0x37, 0x30, 0x38, 0x65, 0x31, 0x63, 0x65, 0x34, 0x30, 0x62, 0x31, 0x63, 0x65, 0x38, 0x63, 0x64, 0x31, 0x35, 0x32, 0x62, 0x66, 0x33, 0x63, 0x37, 0x32, 0x66, 0x39, 0x34, 0x30, 0x65, 0x36, 0x62, 0x38, 0x35, 0x62, 0x32, 0x39, 0x37, 0x31, 0x65, 0x63, 0x64, 0x66, 0x63, 0x62, 0x62, 0x61, 0x34, 0x38, 0x35, 0x37, 0x35, 0x39, 0x64, 0x66, 0x66, 0x36, 0x61, 0x62, 0x35, 0x31, 0x62, 0x61, 0x35, 0x33, 0x34, 0x31, 0x66, 0x64, 0x36, 0x38, 0x34, 0x65, 0x63, 0x36, 0x62, 0x62, 0x38, 0x64, 0x65, 0x66, 0x66, 0x61, 0x62, 0x37, 0x34, 0x32, 0x30, 0x39, 0x37, 0x35, 0x36, 0x30, 0x63, 0x37, 0x66, 0x61, 0x62, 0x36, 0x63, 0x35, 0x37, 0x64, 0x34, 0x32, 0x66, 0x36, 0x36, 0x30, 0x32, 0x37, 0x66, 0x63, 0x30, 0x33, 0x31, 0x30, 0x36, 0x32, 0x63, 0x61, 0x33, 0x38, 0x38, 0x64, 0x36, 0x35, 0x33, 0x65, 0x34, 0x33, 0x33, 0x35, 0x65, 0x63, 0x34, 0x62, 0x64, 0x63, 0x64, 0x65, 0x33, 0x32, 0x32, 0x63, 0x66, 0x34, 0x66, 0x37, 0x34, 0x38, 0x36, 0x32, 0x30, 0x36, 0x33, 0x31, 0x61, 0x64, 0x37, 0x64, 0x65, 0x62, 0x30, 0x34, 0x32, 0x36, 0x62, 0x38, 0x36, 0x38, 0x61, 0x30, 0x39, 0x39, 0x61, 0x38, 0x61, 0x35, 0x37, 0x63, 0x33, 0x65, 0x32, 0x34, 0x39, 0x32, 0x35, 0x35, 0x30, 0x36, 0x66, 0x64, 0x63, 0x62, 0x36, 0x30, 0x36, 0x35, 0x61, 0x35, 0x34, 0x63, 0x63, 0x33, 0x31, 0x66, 0x38, 0x35, 0x36, 0x63, 0x34, 0x61, 0x65, 0x38, 0x37, 0x32, 0x61, 0x30, 0x65, 0x65, 0x34, 0x32, 0x30, 0x61, 0x63, 0x64, 0x32, 0x65, 0x37, 0x61, 0x38, 0x35, 0x62, 0x66, 0x63, 0x65, 0x34, 0x39, 0x36, 0x37, 0x32, 0x34, 0x62, 0x31, 0x64, 0x63, 0x61, 0x31, 0x39, 0x66, 0x35, 0x64, 0x32, 0x63, 0x37, 0x36, 0x32, 0x33, 0x62, 0x62, 0x63, 0x31, 0x32, 0x30, 0x65, 0x34, 0x32, 0x35, 0x37, 0x34, 0x35, 0x64, 0x33, 0x65, 0x37, 0x35, 0x61, 0x61, 0x37, 0x32, 0x36, 0x36, 0x36, 0x62, 0x61, 0x63, 0x38, 0x32, 0x37, 0x36, 0x38, 0x35, 0x38, 0x38, 0x64, 0x61, 0x35, 0x64, 0x38, 0x62, 0x65, 0x65, 0x37, 0x38, 0x38, 0x65, 0x37, 0x63, 0x66, 0x65, 0x35, 0x38, 0x64, 0x36, 0x64, 0x30, 0x35, 0x64, 0x35, 0x39, 0x36, 0x37, 0x66, 0x34, 0x63, 0x35, 0x33, 0x65, 0x35, 0x62, 0x35, 0x36, 0x37, 0x31, 0x63, 0x33, 0x32, 0x31, 0x31, 0x32, 0x66, 0x66, 0x37, 0x32, 0x66, 0x31, 0x36, 0x39, 0x63, 0x37, 0x32, 0x66, 0x30, 0x35, 0x31, 0x63, 0x38, 0x61, 0x34, 0x31, 0x64, 0x34, 0x38, 0x36, 0x36, 0x31, 0x35, 0x34, 0x61, 0x31, 0x35, 0x37, 0x37, 0x33, 0x62, 0x39, 0x62, 0x32, 0x62, 0x65, 0x38, 0x35, 0x33, 0x65, 0x35, 0x37, 0x39, 0x34, 0x31, 0x65, 0x33, 0x37, 0x63, 0x36, 0x63, 0x35, 0x64, 0x38, 0x31, 0x37, 0x66, 0x32, 0x65, 0x31, 0x38, 0x64, 0x34, 0x38, 0x66, 0x36, 0x37, 0x31, 0x34, 0x65, 0x35, 0x38, 0x66, 0x38, 0x37, 0x64, 0x65, 0x31, 0x39, 0x62, 0x35, 0x33, 0x36, 0x39, 0x63, 0x66, 0x35, 0x64, 0x32, 0x39, 0x66, 0x32, 0x31, 0x63, 0x39, 0x35, 0x36, 0x66, 0x66, 0x36, 0x37, 0x61, 0x65, 0x63, 0x61, 0x65, 0x65, 0x35, 0x35, 0x32, 0x63, 0x39, 0x63, 0x65, 0x39, 0x38, 0x36, 0x65, 0x33, 0x65, 0x65, 0x38, 0x35, 0x31, 0x30, 0x39, 0x33, 0x65, 0x62, 0x61, 0x32, 0x33, 0x34, 0x39, 0x64, 0x62, 0x34, 0x35, 0x36, 0x63, 0x35, 0x34, 0x65, 0x62, 0x36, 0x35, 0x62, 0x65, 0x62, 0x33, 0x65, 0x63, 0x63, 0x31, 0x64, 0x33, 0x33, 0x33, 0x39, 0x37, 0x30, 0x64, 0x36, 0x62, 0x35, 0x62, 0x63, 0x61, 0x65, 0x38, 0x34, 0x61, 0x38, 0x39, 0x35, 0x31, 0x39, 0x61, 0x64, 0x64, 0x35, 0x36, 0x65, 0x36, 0x37, 0x35, 0x35, 0x64, 0x37, 0x61, 0x33, 0x32, 0x30, 0x30, 0x64, 0x61, 0x64, 0x33, 0x37, 0x30, 0x35, 0x65, 0x36, 0x38, 0x65, 0x36, 0x37, 0x32, 0x38, 0x36, 0x62, 0x37, 0x61, 0x37, 0x63, 0x65, 0x62, 0x66, 0x30, 0x36, 0x62, 0x32, 0x38, 0x31, 0x65, 0x34, 0x31, 0x66, 0x61, 0x66, 0x62, 0x37, 0x34, 0x31, 0x31, 0x32, 0x66, 0x33, 0x38, 0x39, 0x37, 0x37, 0x36, 0x66, 0x61, 0x34, 0x61, 0x37, 0x39, 0x32, 0x30, 0x66, 0x61, 0x31, 0x37, 0x32, 0x39, 0x61, 0x37, 0x34, 0x34, 0x65, 0x64, 0x64, 0x31, 0x37, 0x39, 0x63, 0x39, 0x66, 0x30, 0x64, 0x33, 0x30, 0x65, 0x64, 0x34, 0x36, 0x31, 0x31, 0x30, 0x35, 0x30, 0x66, 0x37, 0x37, 0x30, 0x35, 0x35, 0x65, 0x66, 0x32, 0x32, 0x33, 0x62, 0x33, 0x63, 0x34, 0x35, 0x39, 0x65, 0x36, 0x62, 0x36, 0x31, 0x65, 0x34, 0x64, 0x39, 0x38, 0x34, 0x62, 0x37, 0x35, 0x37, 0x61, 0x37, 0x62, 0x36, 0x64, 0x63, 0x64, 0x38, 0x31, 0x66, 0x36, 0x34, 0x39, 0x31, 0x36, 0x36, 0x61, 0x34, 0x63, 0x32, 0x30, 0x37, 0x32, 0x36, 0x65, 0x30, 0x39, 0x61, 0x62, 0x34, 0x65, 0x61, 0x31, 0x32, 0x39, 0x35, 0x32, 0x65, 0x34, 0x31, 0x32, 0x32, 0x35, 0x37, 0x38, 0x30, 0x66, 0x35, 0x61, 0x61, 0x31, 0x66, 0x31, 0x62, 0x35, 0x32, 0x32, 0x66, 0x37, 0x35, 0x31, 0x37, 0x36, 0x61, 0x32, 0x35, 0x35, 0x30, 0x36, 0x34, 0x30, 0x31, 0x65, 0x63, 0x38, 0x61, 0x38, 0x63, 0x33, 0x37, 0x36, 0x38, 0x36, 0x31, 0x65, 0x37, 0x32, 0x30, 0x30, 0x33, 0x35, 0x62, 0x38, 0x35, 0x39, 0x64, 0x31, 0x32, 0x39, 0x36, 0x38, 0x61, 0x36, 0x39, 0x61, 0x34, 0x34, 0x66, 0x32, 0x32, 0x63, 0x36, 0x30, 0x62, 0x63, 0x34, 0x34, 0x30, 0x63, 0x61, 0x63, 0x63, 0x35, 0x39, 0x38, 0x36, 0x30, 0x66, 0x35, 0x61, 0x64, 0x37, 0x32, 0x66, 0x36, 0x63, 0x39, 0x65, 0x36, 0x64, 0x33, 0x32, 0x34, 0x39, 0x63, 0x30, 0x30, 0x31, 0x64, 0x63, 0x38, 0x31, 0x64, 0x31, 0x32, 0x34, 0x61, 0x63, 0x66, 0x64, 0x63, 0x62, 0x31, 0x35, 0x30, 0x64, 0x31, 0x37, 0x30, 0x61, 0x61, 0x62, 0x37, 0x33, 0x35, 0x32, 0x64, 0x33, 0x61, 0x36, 0x33, 0x32, 0x31, 0x32, 0x30, 0x63, 0x62, 0x33, 0x63, 0x34, 0x64, 0x61, 0x39, 0x64, 0x39, 0x37, 0x32, 0x62, 0x61, 0x37, 0x66, 0x37, 0x35, 0x33, 0x35, 0x30, 0x64, 0x37, 0x63, 0x33, 0x61, 0x66, 0x36, 0x39, 0x33, 0x65, 0x66, 0x32, 0x39, 0x34, 0x34, 0x35, 0x31, 0x32, 0x35, 0x35, 0x33, 0x35, 0x39, 0x36, 0x34, 0x30, 0x30, 0x66, 0x61, 0x62, 0x36, 0x66, 0x62, 0x61, 0x36, 0x32, 0x64, 0x35, 0x36, 0x37, 0x37, 0x65, 0x37, 0x37, 0x35, 0x32, 0x61, 0x63, 0x34, 0x63, 0x65, 0x34, 0x39, 0x37, 0x32, 0x36, 0x62, 0x61, 0x34, 0x64, 0x39, 0x66, 0x34, 0x32, 0x33, 0x39, 0x38, 0x30, 0x36, 0x64, 0x64, 0x63, 0x32, 0x62, 0x66, 0x62, 0x31, 0x64, 0x33, 0x32, 0x35, 0x62, 0x36, 0x64, 0x62, 0x32, 0x61, 0x63, 0x62, 0x62, 0x39, 0x30, 0x62, 0x61, 0x35, 0x39, 0x38, 0x64, 0x37, 0x61, 0x31, 0x64, 0x34, 0x65, 0x30, 0x62, 0x38, 0x30, 0x36, 0x39, 0x31, 0x63, 0x35, 0x65, 0x66, 0x31, 0x36, 0x37, 0x31, 0x32, 0x38, 0x36, 0x66, 0x64, 0x34, 0x62, 0x34, 0x66, 0x32, 0x34, 0x61, 0x36, 0x62, 0x30, 0x66, 0x39, 0x35, 0x61, 0x33, 0x63, 0x64, 0x63, 0x63, 0x62, 0x35, 0x64, 0x65, 0x61, 0x31, 0x64, 0x36, 0x61, 0x33, 0x62, 0x62, 0x63, 0x62, 0x62, 0x62, 0x64, 0x37, 0x37, 0x34, 0x39, 0x35, 0x63, 0x62, 0x62, 0x34, 0x63, 0x31, 0x35, 0x32, 0x63, 0x64, 0x65, 0x37, 0x64, 0x38, 0x63, 0x33, 0x37, 0x32, 0x35, 0x30, 0x37, 0x37, 0x38, 0x33, 0x31, 0x36, 0x34, 0x38, 0x31, 0x33, 0x34, 0x32, 0x33, 0x64, 0x36, 0x36, 0x64, 0x35, 0x61, 0x38, 0x38, 0x32, 0x66, 0x32, 0x65, 0x32, 0x31, 0x39, 0x34, 0x35, 0x30, 0x32, 0x31, 0x37, 0x39, 0x65, 0x61, 0x36, 0x61, 0x66, 0x38, 0x66, 0x38, 0x39, 0x62, 0x37, 0x64, 0x66, 0x33, 0x32, 0x36, 0x35, 0x34, 0x39, 0x34, 0x33, 0x37, 0x65, 0x33, 0x63, 0x33, 0x63, 0x61, 0x36, 0x66, 0x37, 0x30, 0x38, 0x65, 0x32, 0x34, 0x35, 0x32, 0x39, 0x39, 0x37, 0x62, 0x65, 0x31, 0x62, 0x39, 0x62, 0x61, 0x37, 0x38, 0x35, 0x65, 0x39, 0x38, 0x37, 0x63, 0x34, 0x30, 0x34, 0x62, 0x63, 0x66, 0x64, 0x64, 0x36, 0x39, 0x39, 0x65, 0x39, 0x36, 0x65, 0x39, 0x38, 0x62, 0x37, 0x64, 0x35, 0x61, 0x63, 0x61, 0x35, 0x33, 0x34, 0x37, 0x66, 0x65, 0x65, 0x39, 0x65, 0x37, 0x32, 0x37, 0x64, 0x37, 0x35, 0x63, 0x37, 0x31, 0x32, 0x61, 0x63, 0x34, 0x61, 0x61, 0x61, 0x61, 0x33, 0x33, 0x30, 0x36, 0x31, 0x63, 0x35, 0x63, 0x61, 0x66, 0x39, 0x63, 0x32, 0x61, 0x35, 0x63, 0x33, 0x31, 0x62, 0x65, 0x37, 0x30, 0x35, 0x66, 0x33, 0x39, 0x37, 0x61, 0x32, 0x39, 0x38, 0x33, 0x35, 0x33, 0x39, 0x30, 0x39, 0x66, 0x61, 0x39, 0x62, 0x62, 0x61, 0x38, 0x32, 0x64, 0x62, 0x37, 0x32, 0x32, 0x37, 0x65, 0x63, 0x61, 0x30, 0x33, 0x37, 0x34, 0x65, 0x62, 0x30, 0x30, 0x62, 0x62, 0x37, 0x64, 0x39, 0x35, 0x38, 0x36, 0x32, 0x34, 0x39, 0x30, 0x39, 0x33, 0x33, 0x33, 0x38, 0x31, 0x39, 0x66, 0x33, 0x63, 0x37, 0x66, 0x39, 0x33, 0x66, 0x32, 0x35, 0x34, 0x36, 0x64, 0x66, 0x61, 0x32, 0x34, 0x38, 0x36, 0x37, 0x33, 0x33, 0x35, 0x37, 0x35, 0x34, 0x31, 0x35, 0x66, 0x37, 0x37, 0x32, 0x36, 0x33, 0x38, 0x61, 0x65, 0x30, 0x30, 0x31, 0x30, 0x30, 0x65, 0x39, 0x39, 0x36, 0x63, 0x37, 0x39, 0x36, 0x66, 0x39, 0x61, 0x62, 0x36, 0x61, 0x62, 0x34, 0x62, 0x35, 0x62, 0x35, 0x36, 0x38, 0x30, 0x63, 0x31, 0x37, 0x34, 0x64, 0x36, 0x61, 0x35, 0x35, 0x35, 0x33, 0x39, 0x62, 0x35, 0x34, 0x31, 0x32, 0x31, 0x63, 0x66, 0x30, 0x39, 0x38, 0x64, 0x32, 0x38, 0x36, 0x64, 0x63, 0x32, 0x64, 0x65, 0x34, 0x66, 0x63, 0x39, 0x30, 0x38, 0x37, 0x35, 0x39, 0x34, 0x36, 0x38, 0x39, 0x63, 0x64, 0x30, 0x30, 0x37, 0x30, 0x65, 0x62, 0x36, 0x65, 0x39, 0x34, 0x63, 0x34, 0x61, 0x63, 0x30, 0x63, 0x34, 0x63, 0x30, 0x32, 0x34, 0x35, 0x65, 0x64, 0x33, 0x39, 0x65, 0x61, 0x39, 0x35, 0x39, 0x31, 0x31, 0x66, 0x32, 0x63, 0x33, 0x37, 0x38, 0x65, 0x66, 0x30, 0x39, 0x31, 0x64, 0x36, 0x35, 0x64, 0x35, 0x35, 0x33, 0x65, 0x39, 0x65, 0x30, 0x32, 0x32, 0x61, 0x66, 0x30, 0x30, 0x39, 0x62, 0x66, 0x36, 0x66, 0x63, 0x33, 0x37, 0x37, 0x66, 0x61, 0x34, 0x39, 0x64, 0x36, 0x33, 0x39, 0x32, 0x66, 0x35, 0x33, 0x66, 0x37, 0x65, 0x36, 0x33, 0x38, 0x33, 0x30, 0x63, 0x37, 0x64, 0x62, 0x63, 0x61, 0x35, 0x33, 0x37, 0x34, 0x65, 0x36, 0x32, 0x34, 0x38, 0x33, 0x36, 0x64, 0x65, 0x63, 0x37, 0x32, 0x34, 0x66, 0x36, 0x64, 0x37, 0x37, 0x63, 0x64, 0x34, 0x33, 0x66, 0x61, 0x66, 0x32, 0x34, 0x36, 0x38, 0x33, 0x34, 0x62, 0x39, 0x31, 0x64, 0x37, 0x36, 0x31, 0x36, 0x33, 0x64, 0x38, 0x36, 0x31, 0x39, 0x32, 0x65, 0x38, 0x30, 0x31, 0x30, 0x63, 0x63, 0x32, 0x31, 0x63, 0x66, 0x65, 0x35, 0x35, 0x38, 0x65, 0x36, 0x39, 0x66, 0x35, 0x62, 0x31, 0x62, 0x64, 0x30, 0x34, 0x63, 0x66, 0x37, 0x32, 0x66, 0x38, 0x36, 0x39, 0x35, 0x32, 0x34, 0x39, 0x61, 0x63, 0x37, 0x63, 0x32, 0x36, 0x65, 0x62, 0x62, 0x34, 0x39, 0x33, 0x63, 0x37, 0x37, 0x64, 0x66, 0x30, 0x62, 0x38, 0x61, 0x31, 0x64, 0x32, 0x39, 0x35, 0x61, 0x35, 0x30, 0x33, 0x61, 0x39, 0x63, 0x30, 0x34, 0x32, 0x33, 0x37, 0x66, 0x31, 0x32, 0x36, 0x66, 0x32, 0x32, 0x63, 0x31, 0x66, 0x64, 0x39, 0x32, 0x31, 0x35, 0x34, 0x37, 0x32, 0x33, 0x38, 0x38, 0x38, 0x31, 0x35, 0x64, 0x39, 0x65, 0x65, 0x33, 0x35, 0x30, 0x62, 0x34, 0x66, 0x30, 0x65, 0x34, 0x39, 0x39, 0x36, 0x65, 0x30, 0x30, 0x34, 0x65, 0x30, 0x36, 0x61, 0x34, 0x37, 0x34, 0x61, 0x65, 0x33, 0x34, 0x38, 0x34, 0x31, 0x35, 0x64, 0x37, 0x64, 0x63, 0x35, 0x62, 0x36, 0x61, 0x39, 0x37, 0x62, 0x61, 0x65, 0x36, 0x38, 0x36, 0x64, 0x32, 0x33, 0x37, 0x66, 0x34, 0x31, 0x33, 0x34, 0x63, 0x39, 0x65, 0x36, 0x32, 0x62, 0x35, 0x65, 0x66, 0x34, 0x31, 0x30, 0x64, 0x33, 0x65, 0x38, 0x66, 0x36, 0x34, 0x34, 0x32, 0x32, 0x64, 0x32, 0x66, 0x35, 0x31, 0x64, 0x39, 0x66, 0x30, 0x65, 0x66, 0x38, 0x33, 0x32, 0x62, 0x34, 0x64, 0x33, 0x63, 0x31, 0x39, 0x38, 0x62, 0x63, 0x35, 0x37, 0x39, 0x31, 0x34, 0x32, 0x34, 0x63, 0x61, 0x30, 0x32, 0x34, 0x38, 0x62, 0x37, 0x32, 0x35, 0x35, 0x61, 0x62, 0x37, 0x61, 0x35, 0x39, 0x61, 0x62, 0x65, 0x66, 0x36, 0x33, 0x38, 0x34, 0x37, 0x63, 0x30, 0x37, 0x36, 0x39, 0x62, 0x37, 0x38, 0x39, 0x30, 0x39, 0x38, 0x37, 0x30, 0x33, 0x33, 0x34, 0x66, 0x36, 0x38, 0x61, 0x37, 0x36, 0x32, 0x66, 0x33, 0x66, 0x38, 0x65, 0x36, 0x64, 0x34, 0x31, 0x37, 0x30, 0x32, 0x38, 0x64, 0x63, 0x38, 0x34, 0x34, 0x35, 0x35, 0x39, 0x35, 0x39, 0x36, 0x30, 0x63, 0x32, 0x39, 0x32, 0x66, 0x35, 0x65, 0x65, 0x61, 0x30, 0x64, 0x39, 0x63, 0x36, 0x35, 0x32, 0x64, 0x36, 0x31, 0x66, 0x33, 0x38, 0x62, 0x62, 0x33, 0x33, 0x36, 0x34, 0x65, 0x39, 0x37, 0x32, 0x63, 0x33, 0x64, 0x39, 0x34, 0x36, 0x64, 0x66, 0x61, 0x31, 0x30, 0x30, 0x65, 0x38, 0x66, 0x35, 0x39, 0x63, 0x64, 0x66, 0x39, 0x38, 0x33, 0x32, 0x33, 0x61, 0x30, 0x64, 0x31, 0x39, 0x33, 0x30, 0x31, 0x62, 0x36, 0x37, 0x39, 0x66, 0x64, 0x32, 0x30, 0x39, 0x36, 0x64, 0x35, 0x35, 0x37, 0x37, 0x61, 0x36, 0x32, 0x36, 0x62, 0x31, 0x36, 0x37, 0x36, 0x36, 0x38, 0x66, 0x62, 0x38, 0x36, 0x33, 0x32, 0x61, 0x62, 0x37, 0x30, 0x39, 0x35, 0x37, 0x34, 0x61, 0x38, 0x62, 0x39, 0x38, 0x31, 0x35, 0x31, 0x64, 0x30, 0x35, 0x35, 0x64, 0x36, 0x36, 0x36, 0x35, 0x31, 0x66, 0x31, 0x30, 0x32, 0x33, 0x39, 0x36, 0x34, 0x39, 0x37, 0x35, 0x37, 0x37, 0x37, 0x33, 0x63, 0x64, 0x32, 0x62, 0x34, 0x34, 0x32, 0x33, 0x37, 0x33, 0x38, 0x65, 0x63, 0x36, 0x39, 0x32, 0x39, 0x33, 0x32, 0x36, 0x65, 0x34, 0x35, 0x31, 0x65, 0x34, 0x64, 0x62, 0x39, 0x32, 0x34, 0x38, 0x35, 0x66, 0x64, 0x38, 0x36, 0x65, 0x66, 0x63, 0x61, 0x32, 0x64, 0x35, 0x61, 0x32, 0x66, 0x64, 0x65, 0x39, 0x31, 0x62, 0x37, 0x39, 0x33, 0x64, 0x61, 0x33, 0x32, 0x34, 0x32, 0x30, 0x30, 0x32, 0x34, 0x34, 0x62, 0x37, 0x62, 0x35, 0x34, 0x34, 0x66, 0x61, 0x31, 0x36, 0x35, 0x39, 0x64, 0x33, 0x39, 0x36, 0x39, 0x62, 0x31, 0x30, 0x63, 0x66, 0x38, 0x30, 0x39, 0x38, 0x38, 0x65, 0x33, 0x36, 0x35, 0x38, 0x34, 0x64, 0x35, 0x31, 0x34, 0x37, 0x32, 0x37, 0x64, 0x65, 0x32, 0x34, 0x34, 0x32, 0x30, 0x32, 0x37, 0x32, 0x33, 0x31, 0x66, 0x30, 0x65, 0x36, 0x65, 0x35, 0x39, 0x31, 0x33, 0x66, 0x32, 0x37, 0x32, 0x33, 0x38, 0x35, 0x38, 0x36, 0x34, 0x62, 0x34, 0x35, 0x66, 0x64, 0x34, 0x37, 0x62, 0x31, 0x64, 0x32, 0x64, 0x64, 0x33, 0x30, 0x63, 0x37, 0x64, 0x30, 0x35, 0x30, 0x62, 0x62, 0x62, 0x64, 0x39, 0x31, 0x65, 0x33, 0x35, 0x32, 0x36, 0x63, 0x62, 0x64, 0x38, 0x36, 0x66, 0x31, 0x61, 0x64, 0x37, 0x32, 0x61, 0x39, 0x38, 0x36, 0x37, 0x62, 0x64, 0x61, 0x31, 0x61, 0x63, 0x63, 0x33, 0x62, 0x31, 0x33, 0x34, 0x38, 0x32, 0x62, 0x33, 0x64, 0x36, 0x37, 0x65, 0x61, 0x33, 0x31, 0x61, 0x31, 0x62, 0x32, 0x39, 0x31, 0x37, 0x35, 0x35, 0x35, 0x31, 0x33, 0x33, 0x62, 0x31, 0x61, 0x37, 0x65, 0x37, 0x33, 0x63, 0x34, 0x30, 0x62, 0x64, 0x39, 0x39, 0x35, 0x66, 0x38, 0x38, 0x65, 0x38, 0x39, 0x37, 0x32, 0x31, 0x37, 0x30, 0x33, 0x64, 0x64, 0x34, 0x31, 0x30, 0x61, 0x64, 0x33, 0x61, 0x63, 0x65, 0x66, 0x32, 0x63, 0x37, 0x63, 0x32, 0x35, 0x36, 0x31, 0x63, 0x31, 0x64, 0x65, 0x61, 0x61, 0x65, 0x34, 0x34, 0x31, 0x38, 0x39, 0x32, 0x32, 0x66, 0x63, 0x34, 0x61, 0x36, 0x34, 0x61, 0x31, 0x38, 0x65, 0x30, 0x32, 0x32, 0x38, 0x33, 0x62, 0x38, 0x33, 0x38, 0x32, 0x38, 0x30, 0x61, 0x65, 0x34, 0x31, 0x35, 0x62, 0x36, 0x30, 0x36, 0x36, 0x64, 0x35, 0x35, 0x63, 0x34, 0x34, 0x62, 0x39, 0x39, 0x36, 0x30, 0x39, 0x62, 0x62, 0x63, 0x37, 0x33, 0x38, 0x39, 0x34, 0x30, 0x39, 0x65, 0x34, 0x33, 0x32, 0x63, 0x36, 0x32, 0x65, 0x63, 0x30, 0x36, 0x32, 0x34, 0x32, 0x61, 0x30, 0x61, 0x61, 0x31, 0x66, 0x62, 0x36, 0x65, 0x37, 0x34, 0x30, 0x36, 0x36, 0x66, 0x66, 0x63, 0x38, 0x32, 0x36, 0x37, 0x32, 0x36, 0x37, 0x66, 0x66, 0x30, 0x66, 0x64, 0x36, 0x64, 0x31, 0x35, 0x62, 0x35, 0x66, 0x36, 0x32, 0x37, 0x31, 0x38, 0x32, 0x34, 0x62, 0x61, 0x36, 0x64, 0x61, 0x66, 0x35, 0x34, 0x34, 0x30, 0x31, 0x64, 0x34, 0x66, 0x62, 0x36, 0x65, 0x34, 0x38, 0x36, 0x62, 0x37, 0x62, 0x37, 0x64, 0x34, 0x38, 0x38, 0x39, 0x39, 0x37, 0x33, 0x30, 0x39, 0x34, 0x63, 0x35, 0x31, 0x63, 0x61, 0x38, 0x34, 0x61, 0x63, 0x37, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x61, 0x39, 0x35, 0x33, 0x66, 0x34, 0x62, 0x34, 0x36, 0x39, 0x62, 0x63, 0x38, 0x65, 0x33, 0x62, 0x37, 0x35, 0x64, 0x33, 0x66, 0x61, 0x61, 0x65, 0x63, 0x66, 0x38, 0x32, 0x65, 0x37, 0x62, 0x30, 0x38, 0x32, 0x61, 0x66, 0x30, 0x65, 0x36, 0x36, 0x32, 0x31, 0x31, 0x32, 0x35, 0x30, 0x30, 0x61, 0x38, 0x35, 0x63, 0x37, 0x34, 0x36, 0x37, 0x32, 0x35, 0x35, 0x39, 0x32, 0x38, 0x37, 0x32, 0x62, 0x31, 0x35, 0x66, 0x34, 0x62, 0x35, 0x35, 0x63, 0x39, 0x37, 0x35, 0x34, 0x39, 0x38, 0x32, 0x39, 0x32, 0x64, 0x65, 0x31, 0x30, 0x32, 0x37, 0x38, 0x61, 0x35, 0x30, 0x65, 0x65, 0x39, 0x30, 0x65, 0x38, 0x31, 0x38, 0x34, 0x34, 0x34, 0x34, 0x64, 0x32, 0x37, 0x35, 0x31, 0x37, 0x30, 0x37, 0x33, 0x64, 0x61, 0x61, 0x39, 0x61, 0x34, 0x37, 0x32, 0x34, 0x30, 0x39, 0x30, 0x39, 0x34, 0x61, 0x62, 0x37, 0x66, 0x34, 0x34, 0x38, 0x31, 0x34, 0x32, 0x62, 0x64, 0x37, 0x63, 0x63, 0x39, 0x63, 0x39, 0x35, 0x33, 0x64, 0x31, 0x30, 0x66, 0x66, 0x66, 0x61, 0x39, 0x32, 0x63, 0x62, 0x35, 0x66, 0x61, 0x35, 0x31, 0x38, 0x36, 0x62, 0x33, 0x30, 0x37, 0x30, 0x32, 0x39, 0x64, 0x35, 0x65, 0x61, 0x65, 0x36, 0x65, 0x37, 0x35, 0x63, 0x63, 0x35, 0x64, 0x36, 0x33, 0x61, 0x35, 0x32, 0x64, 0x32, 0x30, 0x64, 0x37, 0x37, 0x39, 0x35, 0x33, 0x37, 0x66, 0x34, 0x39, 0x65, 0x37, 0x38, 0x36, 0x37, 0x38, 0x33, 0x35, 0x39, 0x66, 0x61, 0x35, 0x62, 0x39, 0x64, 0x38, 0x35, 0x30, 0x34, 0x33, 0x33, 0x30, 0x35, 0x38, 0x30, 0x32, 0x30, 0x31, 0x33, 0x30, 0x65, 0x63, 0x65, 0x36, 0x34, 0x65, 0x35, 0x34, 0x62, 0x65, 0x30, 0x30, 0x36, 0x63, 0x34, 0x61, 0x38, 0x66, 0x66, 0x65, 0x35, 0x37, 0x32, 0x33, 0x64, 0x33, 0x32, 0x36, 0x38, 0x33, 0x31, 0x63, 0x39, 0x34, 0x31, 0x35, 0x30, 0x64, 0x39, 0x33, 0x30, 0x39, 0x37, 0x63, 0x63, 0x33, 0x32, 0x33, 0x34, 0x65, 0x35, 0x33, 0x38, 0x37, 0x37, 0x61, 0x61, 0x65, 0x35, 0x38, 0x39, 0x39, 0x62, 0x64, 0x36, 0x35, 0x64, 0x36, 0x34, 0x38, 0x63, 0x61, 0x31, 0x31, 0x33, 0x62, 0x37, 0x37, 0x34, 0x36, 0x63, 0x62, 0x61, 0x31, 0x64, 0x61, 0x38, 0x34, 0x34, 0x30, 0x34, 0x32, 0x61, 0x64, 0x63, 0x64, 0x35, 0x33, 0x39, 0x37, 0x33, 0x32, 0x66, 0x38, 0x61, 0x66, 0x66, 0x65, 0x33, 0x38, 0x32, 0x66, 0x62, 0x65, 0x38, 0x32, 0x63, 0x65, 0x39, 0x37, 0x30, 0x32, 0x63, 0x66, 0x62, 0x37, 0x32, 0x63, 0x63, 0x61, 0x35, 0x35, 0x34, 0x31, 0x36, 0x61, 0x31, 0x33, 0x36, 0x62, 0x30, 0x36, 0x36, 0x38, 0x30, 0x64, 0x62, 0x64, 0x31, 0x61, 0x66, 0x36, 0x62, 0x33, 0x33, 0x35, 0x39, 0x36, 0x65, 0x32, 0x36, 0x66, 0x65, 0x65, 0x30, 0x32, 0x31, 0x36, 0x64, 0x64, 0x64, 0x33, 0x34, 0x63, 0x34, 0x37, 0x33, 0x39, 0x30, 0x61, 0x37, 0x61, 0x38, 0x30, 0x34, 0x30, 0x63, 0x65, 0x66, 0x39, 0x30, 0x30, 0x66, 0x65, 0x62, 0x66, 0x66, 0x37, 0x64, 0x39, 0x32, 0x39, 0x38, 0x62, 0x32, 0x62, 0x37, 0x32, 0x33, 0x33, 0x33, 0x33, 0x65, 0x39, 0x36, 0x34, 0x39, 0x32, 0x36, 0x32, 0x64, 0x35, 0x33, 0x61, 0x34, 0x61, 0x34, 0x37, 0x31, 0x39, 0x66, 0x64, 0x35, 0x38, 0x63, 0x62, 0x36, 0x38, 0x65, 0x36, 0x32, 0x36, 0x34, 0x33, 0x37, 0x31, 0x37, 0x63, 0x61, 0x32, 0x66, 0x31, 0x61, 0x31, 0x65, 0x36, 0x34, 0x38, 0x31, 0x38, 0x30, 0x37, 0x65, 0x30, 0x66, 0x35, 0x32, 0x65, 0x38, 0x34, 0x31, 0x37, 0x63, 0x39, 0x61, 0x38, 0x65, 0x37, 0x37, 0x30, 0x39, 0x66, 0x61, 0x64, 0x32, 0x36, 0x62, 0x33, 0x32, 0x36, 0x62, 0x38, 0x37, 0x33, 0x61, 0x33, 0x39, 0x61, 0x32, 0x34, 0x61, 0x65, 0x36, 0x66, 0x30, 0x34, 0x35, 0x30, 0x64, 0x38, 0x65, 0x33, 0x63, 0x39, 0x66, 0x62, 0x36, 0x39, 0x61, 0x30, 0x34, 0x37, 0x31, 0x31, 0x37, 0x31, 0x63, 0x38, 0x37, 0x66, 0x66, 0x65, 0x33, 0x65, 0x37, 0x32, 0x36, 0x66, 0x30, 0x63, 0x61, 0x38, 0x35, 0x36, 0x63, 0x39, 0x39, 0x31, 0x66, 0x39, 0x33, 0x65, 0x62, 0x63, 0x34, 0x30, 0x39, 0x35, 0x38, 0x65, 0x34, 0x31, 0x66, 0x30, 0x36, 0x34, 0x66, 0x65, 0x32, 0x36, 0x36, 0x62, 0x36, 0x62, 0x63, 0x30, 0x33, 0x31, 0x39, 0x30, 0x34, 0x31, 0x32, 0x61, 0x65, 0x33, 0x65, 0x39, 0x35, 0x62, 0x65, 0x66, 0x38, 0x30, 0x38, 0x33, 0x33, 0x31, 0x37, 0x32, 0x37, 0x30, 0x35, 0x65, 0x31, 0x62, 0x36, 0x61, 0x34, 0x65, 0x36, 0x66, 0x34, 0x38, 0x32, 0x34, 0x36, 0x61, 0x34, 0x37, 0x66, 0x61, 0x34, 0x32, 0x37, 0x65, 0x64, 0x34, 0x39, 0x32, 0x36, 0x38, 0x32, 0x34, 0x63, 0x35, 0x35, 0x62, 0x37, 0x65, 0x36, 0x61, 0x64, 0x32, 0x38, 0x37, 0x61, 0x35, 0x37, 0x37, 0x35, 0x64, 0x34, 0x34, 0x33, 0x39, 0x33, 0x64, 0x34, 0x37, 0x35, 0x33, 0x37, 0x32, 0x33, 0x37, 0x33, 0x39, 0x35, 0x66, 0x61, 0x37, 0x37, 0x61, 0x34, 0x31, 0x39, 0x30, 0x31, 0x39, 0x37, 0x37, 0x64, 0x30, 0x61, 0x34, 0x38, 0x30, 0x32, 0x37, 0x64, 0x65, 0x39, 0x36, 0x34, 0x35, 0x63, 0x39, 0x36, 0x39, 0x66, 0x62, 0x63, 0x32, 0x31, 0x34, 0x34, 0x38, 0x32, 0x39, 0x64, 0x61, 0x38, 0x62, 0x64, 0x38, 0x36, 0x38, 0x64, 0x39, 0x32, 0x38, 0x30, 0x38, 0x62, 0x34, 0x37, 0x32, 0x64, 0x61, 0x39, 0x32, 0x34, 0x62, 0x37, 0x35, 0x37, 0x63, 0x38, 0x36, 0x65, 0x61, 0x39, 0x36, 0x64, 0x36, 0x39, 0x63, 0x31, 0x37, 0x63, 0x32, 0x30, 0x62, 0x64, 0x38, 0x35, 0x65, 0x63, 0x36, 0x63, 0x65, 0x33, 0x34, 0x36, 0x35, 0x32, 0x31, 0x38, 0x39, 0x64, 0x34, 0x31, 0x36, 0x30, 0x34, 0x66, 0x39, 0x33, 0x39, 0x38, 0x64, 0x63, 0x35, 0x35, 0x35, 0x63, 0x65, 0x37, 0x62, 0x37, 0x32, 0x35, 0x64, 0x65, 0x66, 0x33, 0x37, 0x33, 0x65, 0x39, 0x62, 0x61, 0x33, 0x61, 0x62, 0x62, 0x62, 0x63, 0x38, 0x66, 0x36, 0x61, 0x36, 0x33, 0x33, 0x37, 0x62, 0x64, 0x32, 0x37, 0x33, 0x33, 0x30, 0x39, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x39, 0x37, 0x39, 0x64, 0x63, 0x64, 0x38, 0x65, 0x37, 0x36, 0x35, 0x65, 0x30, 0x31, 0x37, 0x31, 0x34, 0x33, 0x32, 0x66, 0x33, 0x32, 0x33, 0x30, 0x35, 0x62, 0x33, 0x61, 0x31, 0x62, 0x30, 0x30, 0x30, 0x66, 0x32, 0x64, 0x63, 0x38, 0x39, 0x39, 0x62, 0x32, 0x39, 0x61, 0x33, 0x61, 0x32, 0x31, 0x39, 0x35, 0x64, 0x64, 0x33, 0x61, 0x38, 0x61, 0x64, 0x65, 0x39, 0x65, 0x33, 0x62, 0x39, 0x36, 0x32, 0x30, 0x31, 0x30, 0x64, 0x31, 0x32, 0x34, 0x30, 0x39, 0x62, 0x65, 0x61, 0x34, 0x31, 0x31, 0x31, 0x63, 0x35, 0x38, 0x63, 0x33, 0x33, 0x37, 0x32, 0x31, 0x66, 0x65, 0x66, 0x33, 0x34, 0x62, 0x63, 0x34, 0x30, 0x30, 0x37, 0x61, 0x34, 0x64, 0x38, 0x33, 0x34, 0x30, 0x62, 0x65, 0x31, 0x63, 0x31, 0x35, 0x31, 0x64, 0x30, 0x61, 0x30, 0x35, 0x66, 0x65, 0x37, 0x38, 0x63, 0x31, 0x63, 0x66, 0x38, 0x38, 0x34, 0x62, 0x61, 0x61, 0x65, 0x38, 0x64, 0x32, 0x39, 0x34, 0x35, 0x32, 0x65, 0x32, 0x64, 0x64, 0x36, 0x35, 0x31, 0x62, 0x36, 0x32, 0x31, 0x35, 0x32, 0x31, 0x61, 0x35, 0x61, 0x62, 0x34, 0x63, 0x66, 0x63, 0x34, 0x65, 0x35, 0x36, 0x35, 0x33, 0x64, 0x36, 0x63, 0x65, 0x38, 0x37, 0x30, 0x39, 0x31, 0x66, 0x65, 0x35, 0x65, 0x30, 0x32, 0x34, 0x32, 0x39, 0x32, 0x37, 0x35, 0x62, 0x34, 0x35, 0x38, 0x63, 0x37, 0x36, 0x37, 0x30, 0x34, 0x39, 0x30, 0x62, 0x66, 0x31, 0x61, 0x62, 0x64, 0x65, 0x30, 0x65, 0x62, 0x64, 0x30, 0x35, 0x39, 0x38, 0x33, 0x62, 0x63, 0x31, 0x64, 0x65, 0x31, 0x66, 0x30, 0x31, 0x65, 0x34, 0x36, 0x66, 0x65, 0x62, 0x34, 0x38, 0x39, 0x32, 0x62, 0x61, 0x30, 0x31, 0x36, 0x63, 0x33, 0x63, 0x61, 0x38, 0x64, 0x37, 0x32, 0x66, 0x38, 0x33, 0x33, 0x61, 0x37, 0x62, 0x31, 0x61, 0x39, 0x35, 0x66, 0x38, 0x35, 0x61, 0x30, 0x34, 0x32, 0x66, 0x33, 0x39, 0x63, 0x32, 0x39, 0x36, 0x66, 0x36, 0x65, 0x37, 0x32, 0x61, 0x34, 0x62, 0x30, 0x32, 0x32, 0x37, 0x30, 0x61, 0x34, 0x37, 0x30, 0x36, 0x37, 0x35, 0x38, 0x32, 0x64, 0x30, 0x34, 0x65, 0x36, 0x32, 0x61, 0x31, 0x34, 0x33, 0x63, 0x30, 0x35, 0x62, 0x38, 0x63, 0x30, 0x37, 0x30, 0x65, 0x31, 0x31, 0x32, 0x38, 0x35, 0x63, 0x38, 0x37, 0x30, 0x61, 0x32, 0x35, 0x30, 0x61, 0x32, 0x64, 0x38, 0x35, 0x62, 0x36, 0x65, 0x34, 0x63, 0x37, 0x35, 0x37, 0x32, 0x37, 0x31, 0x36, 0x64, 0x39, 0x62, 0x33, 0x61, 0x66, 0x34, 0x34, 0x65, 0x66, 0x34, 0x64, 0x39, 0x37, 0x65, 0x31, 0x33, 0x64, 0x32, 0x37, 0x36, 0x65, 0x30, 0x65, 0x62, 0x33, 0x33, 0x65, 0x65, 0x66, 0x30, 0x37, 0x66, 0x36, 0x30, 0x32, 0x65, 0x33, 0x33, 0x35, 0x32, 0x66, 0x30, 0x62, 0x36, 0x30, 0x31, 0x39, 0x35, 0x35, 0x64, 0x35, 0x61, 0x37, 0x62, 0x36, 0x63, 0x61, 0x64, 0x37, 0x32, 0x32, 0x66, 0x36, 0x32, 0x64, 0x65, 0x38, 0x61, 0x34, 0x39, 0x32, 0x66, 0x30, 0x38, 0x65, 0x34, 0x35, 0x37, 0x36, 0x38, 0x64, 0x35, 0x65, 0x35, 0x31, 0x30, 0x36, 0x66, 0x37, 0x38, 0x61, 0x66, 0x64, 0x39, 0x32, 0x31, 0x64, 0x65, 0x66, 0x38, 0x61, 0x32, 0x39, 0x62, 0x34, 0x34, 0x30, 0x66, 0x66, 0x64, 0x35, 0x33, 0x62, 0x63, 0x31, 0x34, 0x32, 0x31, 0x31, 0x62, 0x33, 0x30, 0x35, 0x32, 0x62, 0x64, 0x65, 0x33, 0x33, 0x36, 0x63, 0x65, 0x37, 0x38, 0x64, 0x38, 0x33, 0x63, 0x38, 0x37, 0x35, 0x64, 0x31, 0x63, 0x31, 0x31, 0x37, 0x36, 0x39, 0x36, 0x64, 0x32, 0x32, 0x39, 0x37, 0x65, 0x65, 0x31, 0x33, 0x39, 0x38, 0x32, 0x65, 0x39, 0x33, 0x35, 0x64, 0x39, 0x33, 0x66, 0x33, 0x31, 0x39, 0x33, 0x37, 0x39, 0x66, 0x31, 0x32, 0x38, 0x31, 0x30, 0x30, 0x37, 0x61, 0x31, 0x37, 0x32, 0x33, 0x36, 0x33, 0x65, 0x33, 0x64, 0x33, 0x33, 0x31, 0x66, 0x39, 0x61, 0x32, 0x39, 0x39, 0x35, 0x64, 0x36, 0x66, 0x39, 0x30, 0x35, 0x38, 0x31, 0x65, 0x39, 0x33, 0x36, 0x32, 0x39, 0x33, 0x32, 0x31, 0x33, 0x65, 0x38, 0x30, 0x37, 0x35, 0x37, 0x37, 0x39, 0x39, 0x36, 0x34, 0x32, 0x61, 0x37, 0x65, 0x39, 0x61, 0x32, 0x65, 0x36, 0x30, 0x64, 0x66, 0x30, 0x31, 0x34, 0x66, 0x37, 0x37, 0x32, 0x30, 0x32, 0x39, 0x61, 0x39, 0x31, 0x61, 0x37, 0x61, 0x39, 0x61, 0x38, 0x62, 0x33, 0x61, 0x66, 0x34, 0x38, 0x63, 0x35, 0x39, 0x33, 0x39, 0x61, 0x35, 0x35, 0x32, 0x61, 0x66, 0x35, 0x66, 0x35, 0x65, 0x61, 0x37, 0x31, 0x61, 0x37, 0x32, 0x39, 0x62, 0x35, 0x35, 0x36, 0x65, 0x64, 0x62, 0x36, 0x37, 0x63, 0x63, 0x32, 0x33, 0x36, 0x31, 0x31, 0x31, 0x30, 0x35, 0x64, 0x61, 0x37, 0x30, 0x30, 0x31, 0x37, 0x39, 0x33, 0x37, 0x63, 0x35, 0x62, 0x36, 0x63, 0x65, 0x38, 0x33, 0x39, 0x64, 0x63, 0x36, 0x63, 0x63, 0x66, 0x38, 0x34, 0x36, 0x33, 0x66, 0x36, 0x37, 0x63, 0x33, 0x66, 0x66, 0x63, 0x34, 0x34, 0x65, 0x30, 0x64, 0x38, 0x31, 0x34, 0x33, 0x62, 0x38, 0x38, 0x34, 0x37, 0x32, 0x32, 0x30, 0x30, 0x33, 0x34, 0x62, 0x37, 0x63, 0x35, 0x32, 0x61, 0x32, 0x34, 0x33, 0x61, 0x37, 0x32, 0x39, 0x34, 0x61, 0x34, 0x37, 0x66, 0x39, 0x31, 0x39, 0x37, 0x64, 0x64, 0x31, 0x62, 0x65, 0x61, 0x36, 0x64, 0x30, 0x62, 0x32, 0x66, 0x61, 0x63, 0x32, 0x36, 0x30, 0x62, 0x31, 0x61, 0x38, 0x33, 0x62, 0x34, 0x62, 0x66, 0x33, 0x35, 0x31, 0x33, 0x30, 0x62, 0x37, 0x33, 0x39, 0x31, 0x61, 0x62, 0x35, 0x36, 0x37, 0x30, 0x32, 0x65, 0x63, 0x34, 0x61, 0x61, 0x39, 0x31, 0x39, 0x31, 0x37, 0x32, 0x66, 0x32, 0x30, 0x33, 0x65, 0x61, 0x31, 0x32, 0x66, 0x38, 0x64, 0x38, 0x62, 0x66, 0x66, 0x35, 0x63, 0x66, 0x63, 0x39, 0x64, 0x66, 0x37, 0x31, 0x32, 0x34, 0x63, 0x30, 0x64, 0x31, 0x30, 0x34, 0x33, 0x35, 0x62, 0x34, 0x36, 0x32, 0x62, 0x62, 0x31, 0x66, 0x66, 0x30, 0x62, 0x35, 0x63, 0x39, 0x35, 0x33, 0x65, 0x65, 0x61, 0x38, 0x32, 0x61, 0x31, 0x64, 0x33, 0x66, 0x30, 0x63, 0x34, 0x33, 0x66, 0x33, 0x33, 0x35, 0x39, 0x34, 0x37, 0x66, 0x65, 0x66, 0x37, 0x66, 0x63, 0x63, 0x64, 0x65, 0x66, 0x65, 0x30, 0x38, 0x32, 0x39, 0x63, 0x30, 0x31, 0x33, 0x31, 0x39, 0x34, 0x38, 0x31, 0x36, 0x61, 0x31, 0x61, 0x64, 0x61, 0x34, 0x31, 0x32, 0x31, 0x37, 0x34, 0x38, 0x32, 0x64, 0x31, 0x64, 0x31, 0x38, 0x35, 0x36, 0x31, 0x38, 0x38, 0x38, 0x66, 0x66, 0x37, 0x63, 0x33, 0x63, 0x31, 0x35, 0x62, 0x32, 0x37, 0x65, 0x31, 0x32, 0x33, 0x66, 0x37, 0x64, 0x32, 0x62, 0x34, 0x34, 0x63, 0x66, 0x37, 0x39, 0x65, 0x33, 0x34, 0x61, 0x62, 0x30, 0x62, 0x63, 0x32, 0x34, 0x30, 0x66, 0x38, 0x64, 0x62, 0x38, 0x64, 0x64, 0x39, 0x63, 0x31, 0x66, 0x31, 0x35, 0x33, 0x61, 0x64, 0x36, 0x30, 0x61, 0x37, 0x66, 0x30, 0x39, 0x33, 0x64, 0x35, 0x31, 0x61, 0x32, 0x61, 0x31, 0x66, 0x37, 0x31, 0x30, 0x33, 0x37, 0x32, 0x31, 0x64, 0x37, 0x34, 0x33, 0x61, 0x34, 0x32, 0x30, 0x33, 0x30, 0x34, 0x65, 0x35, 0x66, 0x39, 0x64, 0x30, 0x33, 0x36, 0x63, 0x66, 0x64, 0x66, 0x37, 0x39, 0x65, 0x34, 0x38, 0x30, 0x31, 0x35, 0x37, 0x63, 0x62, 0x61, 0x63, 0x34, 0x34, 0x61, 0x30, 0x32, 0x61, 0x30, 0x31, 0x64, 0x34, 0x61, 0x63, 0x61, 0x36, 0x38, 0x38, 0x37, 0x30, 0x61, 0x35, 0x32, 0x39, 0x37, 0x32, 0x31, 0x38, 0x65, 0x62, 0x33, 0x63, 0x38, 0x35, 0x32, 0x33, 0x31, 0x35, 0x39, 0x33, 0x62, 0x33, 0x63, 0x64, 0x64, 0x37, 0x32, 0x62, 0x33, 0x31, 0x35, 0x38, 0x35, 0x62, 0x65, 0x33, 0x36, 0x39, 0x63, 0x66, 0x65, 0x32, 0x37, 0x62, 0x32, 0x33, 0x61, 0x31, 0x64, 0x30, 0x64, 0x38, 0x35, 0x36, 0x65, 0x32, 0x32, 0x30, 0x30, 0x36, 0x31, 0x39, 0x31, 0x31, 0x64, 0x33, 0x38, 0x61, 0x35, 0x38, 0x35, 0x31, 0x61, 0x34, 0x65, 0x35, 0x31, 0x38, 0x33, 0x39, 0x61, 0x62, 0x39, 0x64, 0x32, 0x30, 0x63, 0x64, 0x39, 0x35, 0x33, 0x34, 0x35, 0x33, 0x66, 0x36, 0x31, 0x30, 0x31, 0x39, 0x64, 0x33, 0x34, 0x30, 0x64, 0x63, 0x33, 0x33, 0x66, 0x31, 0x34, 0x30, 0x33, 0x39, 0x39, 0x64, 0x34, 0x34, 0x31, 0x64, 0x64, 0x62, 0x38, 0x31, 0x62, 0x33, 0x65, 0x37, 0x37, 0x30, 0x31, 0x35, 0x37, 0x32, 0x39, 0x61, 0x65, 0x33, 0x38, 0x65, 0x34, 0x34, 0x33, 0x36, 0x31, 0x35, 0x33, 0x38, 0x64, 0x36, 0x35, 0x32, 0x65, 0x38, 0x38, 0x35, 0x62, 0x35, 0x38, 0x65, 0x39, 0x65, 0x31, 0x66, 0x39, 0x30, 0x61, 0x34, 0x64, 0x31, 0x34, 0x36, 0x39, 0x36, 0x38, 0x32, 0x36, 0x37, 0x66, 0x30, 0x35, 0x34, 0x30, 0x66, 0x66, 0x38, 0x36, 0x66, 0x64, 0x39, 0x65, 0x33, 0x36, 0x66, 0x30, 0x61, 0x37, 0x32, 0x37, 0x35, 0x32, 0x66, 0x34, 0x64, 0x66, 0x39, 0x33, 0x61, 0x39, 0x31, 0x37, 0x33, 0x36, 0x36, 0x32, 0x36, 0x30, 0x62, 0x31, 0x32, 0x32, 0x66, 0x37, 0x37, 0x64, 0x39, 0x65, 0x31, 0x30, 0x65, 0x38, 0x30, 0x35, 0x38, 0x63, 0x32, 0x38, 0x31, 0x61, 0x65, 0x63, 0x36, 0x62, 0x34, 0x30, 0x31, 0x32, 0x65, 0x36, 0x63, 0x32, 0x30, 0x36, 0x35, 0x62, 0x62, 0x65, 0x36, 0x33, 0x35, 0x37, 0x32, 0x30, 0x31, 0x38, 0x31, 0x35, 0x37, 0x39, 0x62, 0x34, 0x30, 0x31, 0x34, 0x30, 0x62, 0x65, 0x30, 0x30, 0x36, 0x32, 0x62, 0x62, 0x63, 0x66, 0x32, 0x38, 0x33, 0x33, 0x33, 0x65, 0x62, 0x35, 0x35, 0x36, 0x63, 0x38, 0x36, 0x33, 0x35, 0x38, 0x30, 0x38, 0x64, 0x63, 0x62, 0x35, 0x61, 0x34, 0x34, 0x65, 0x66, 0x31, 0x34, 0x31, 0x39, 0x64, 0x38, 0x34, 0x32, 0x39, 0x36, 0x38, 0x37, 0x34, 0x63, 0x63, 0x65, 0x37, 0x62, 0x33, 0x64, 0x32, 0x31, 0x33, 0x62, 0x37, 0x35, 0x33, 0x65, 0x34, 0x35, 0x64, 0x31, 0x37, 0x62, 0x37, 0x36, 0x66, 0x64, 0x66, 0x38, 0x65, 0x64, 0x37, 0x62, 0x66, 0x39, 0x31, 0x38, 0x37, 0x32, 0x36, 0x34, 0x31, 0x32, 0x38, 0x64, 0x64, 0x61, 0x62, 0x62, 0x37, 0x37, 0x33, 0x30, 0x39, 0x62, 0x34, 0x31, 0x64, 0x30, 0x36, 0x62, 0x33, 0x35, 0x30, 0x36, 0x37, 0x32, 0x65, 0x39, 0x33, 0x38, 0x30, 0x33, 0x35, 0x35, 0x61, 0x62, 0x34, 0x34, 0x65, 0x38, 0x64, 0x36, 0x31, 0x37, 0x63, 0x35, 0x39, 0x39, 0x32, 0x32, 0x30, 0x32, 0x66, 0x35, 0x32, 0x34, 0x30, 0x33, 0x31, 0x62, 0x34, 0x62, 0x63, 0x66, 0x32, 0x32, 0x63, 0x39, 0x36, 0x62, 0x36, 0x64, 0x62, 0x65, 0x33, 0x38, 0x38, 0x36, 0x66, 0x36, 0x62, 0x35, 0x63, 0x66, 0x31, 0x35, 0x63, 0x66, 0x32, 0x33, 0x36, 0x63, 0x36, 0x64, 0x65, 0x30, 0x61, 0x65, 0x63, 0x61, 0x30, 0x34, 0x61, 0x64, 0x64, 0x36, 0x62, 0x37, 0x30, 0x62, 0x38, 0x31, 0x62, 0x30, 0x32, 0x35, 0x36, 0x39, 0x61, 0x39, 0x38, 0x61, 0x63, 0x33, 0x65, 0x64, 0x32, 0x63, 0x36, 0x66, 0x66, 0x62, 0x36, 0x63, 0x35, 0x38, 0x33, 0x37, 0x31, 0x64, 0x61, 0x65, 0x65, 0x31, 0x64, 0x62, 0x31, 0x65, 0x30, 0x36, 0x34, 0x39, 0x36, 0x62, 0x32, 0x62, 0x35, 0x37, 0x34, 0x36, 0x30, 0x63, 0x65, 0x65, 0x36, 0x63, 0x30, 0x62, 0x35, 0x35, 0x32, 0x36, 0x62, 0x37, 0x64, 0x34, 0x38, 0x65, 0x32, 0x37, 0x63, 0x33, 0x63, 0x66, 0x37, 0x66, 0x65, 0x30, 0x32, 0x66, 0x61, 0x61, 0x66, 0x62, 0x64, 0x39, 0x39, 0x65, 0x63, 0x36, 0x36, 0x36, 0x30, 0x37, 0x64, 0x38, 0x65, 0x62, 0x39, 0x62, 0x64, 0x36, 0x39, 0x65, 0x63, 0x65, 0x34, 0x31, 0x35, 0x35, 0x62, 0x39, 0x36, 0x64, 0x36, 0x66, 0x36, 0x63, 0x66, 0x37, 0x34, 0x30, 0x63, 0x30, 0x33, 0x35, 0x33, 0x64, 0x33, 0x38, 0x66, 0x65, 0x35, 0x64, 0x63, 0x37, 0x65, 0x61, 0x34, 0x65, 0x62, 0x37, 0x34, 0x66, 0x39, 0x63, 0x63, 0x32, 0x65, 0x35, 0x39, 0x34, 0x38, 0x32, 0x65, 0x35, 0x63, 0x33, 0x39, 0x61, 0x39, 0x61, 0x61, 0x63, 0x64, 0x36, 0x61, 0x38, 0x38, 0x39, 0x33, 0x64, 0x66, 0x37, 0x30, 0x38, 0x38, 0x33, 0x39, 0x32, 0x38, 0x38, 0x61, 0x36, 0x34, 0x33, 0x65, 0x66, 0x30, 0x65, 0x64, 0x31, 0x37, 0x62, 0x35, 0x32, 0x33, 0x33, 0x30, 0x38, 0x38, 0x30, 0x66, 0x38, 0x65, 0x37, 0x63, 0x66, 0x30, 0x37, 0x34, 0x34, 0x61, 0x63, 0x64, 0x39, 0x32, 0x35, 0x34, 0x65, 0x61, 0x63, 0x62, 0x64, 0x36, 0x34, 0x34, 0x65, 0x34, 0x63, 0x31, 0x63, 0x32, 0x33, 0x37, 0x32, 0x34, 0x33, 0x37, 0x61, 0x64, 0x34, 0x36, 0x36, 0x33, 0x31, 0x66, 0x31, 0x65, 0x35, 0x66, 0x32, 0x34, 0x64, 0x34, 0x30, 0x30, 0x64, 0x64, 0x64, 0x62, 0x36, 0x66, 0x30, 0x34, 0x32, 0x30, 0x34, 0x66, 0x36, 0x61, 0x32, 0x37, 0x33, 0x64, 0x31, 0x30, 0x33, 0x61, 0x39, 0x38, 0x30, 0x33, 0x32, 0x62, 0x34, 0x30, 0x62, 0x35, 0x38, 0x66, 0x66, 0x63, 0x37, 0x61, 0x37, 0x65, 0x38, 0x33, 0x61, 0x63, 0x39, 0x36, 0x30, 0x64, 0x32, 0x65, 0x64, 0x34, 0x38, 0x39, 0x32, 0x31, 0x32, 0x63, 0x61, 0x61, 0x64, 0x36, 0x37, 0x34, 0x66, 0x66, 0x38, 0x63, 0x65, 0x65, 0x63, 0x63, 0x37, 0x34, 0x63, 0x35, 0x38, 0x64, 0x62, 0x35, 0x66, 0x35, 0x62, 0x37, 0x35, 0x63, 0x33, 0x30, 0x38, 0x65, 0x38, 0x32, 0x39, 0x66, 0x31, 0x38, 0x34, 0x63, 0x34, 0x30, 0x39, 0x65, 0x64, 0x31, 0x38, 0x36, 0x35, 0x65, 0x33, 0x66, 0x39, 0x36, 0x34, 0x63, 0x31, 0x62, 0x30, 0x36, 0x62, 0x62, 0x38, 0x38, 0x39, 0x63, 0x64, 0x66, 0x36, 0x31, 0x38, 0x33, 0x63, 0x32, 0x33, 0x61, 0x64, 0x35, 0x35, 0x33, 0x35, 0x61, 0x32, 0x33, 0x32, 0x39, 0x63, 0x34, 0x37, 0x35, 0x32, 0x62, 0x31, 0x36, 0x37, 0x32, 0x31, 0x63, 0x31, 0x61, 0x39, 0x39, 0x33, 0x35, 0x65, 0x62, 0x32, 0x62, 0x39, 0x64, 0x66, 0x32, 0x39, 0x61, 0x37, 0x37, 0x34, 0x31, 0x66, 0x61, 0x64, 0x38, 0x31, 0x39, 0x62, 0x66, 0x61, 0x31, 0x32, 0x64, 0x32, 0x65, 0x65, 0x33, 0x62, 0x39, 0x39, 0x35, 0x34, 0x36, 0x31, 0x39, 0x39, 0x37, 0x62, 0x64, 0x66, 0x66, 0x39, 0x32, 0x38, 0x36, 0x64, 0x34, 0x33, 0x30, 0x65, 0x33, 0x39, 0x38, 0x35, 0x63, 0x32, 0x63, 0x30, 0x32, 0x63, 0x35, 0x35, 0x61, 0x63, 0x36, 0x36, 0x33, 0x32, 0x35, 0x35, 0x61, 0x34, 0x35, 0x64, 0x61, 0x63, 0x38, 0x33, 0x64, 0x63, 0x65, 0x63, 0x37, 0x38, 0x31, 0x37, 0x35, 0x30, 0x32, 0x32, 0x39, 0x64, 0x63, 0x66, 0x39, 0x34, 0x63, 0x31, 0x64, 0x38, 0x66, 0x39, 0x61, 0x39, 0x30, 0x62, 0x61, 0x66, 0x65, 0x63, 0x62, 0x64, 0x65, 0x30, 0x33, 0x61, 0x34, 0x64, 0x30, 0x66, 0x61, 0x36, 0x63, 0x38, 0x32, 0x33, 0x31, 0x35, 0x30, 0x36, 0x36, 0x62, 0x37, 0x32, 0x63, 0x33, 0x31, 0x33, 0x33, 0x64, 0x38, 0x30, 0x37, 0x34, 0x34, 0x37, 0x39, 0x38, 0x36, 0x65, 0x66, 0x37, 0x66, 0x34, 0x34, 0x63, 0x32, 0x66, 0x64, 0x35, 0x62, 0x63, 0x62, 0x37, 0x65, 0x34, 0x64, 0x36, 0x66, 0x32, 0x66, 0x33, 0x65, 0x38, 0x32, 0x31, 0x66, 0x32, 0x61, 0x32, 0x62, 0x34, 0x62, 0x33, 0x31, 0x30, 0x66, 0x34, 0x61, 0x64, 0x31, 0x38, 0x34, 0x65, 0x34, 0x30, 0x35, 0x30, 0x37, 0x66, 0x64, 0x38, 0x35, 0x33, 0x33, 0x34, 0x31, 0x36, 0x65, 0x65, 0x65, 0x36, 0x61, 0x66, 0x64, 0x39, 0x35, 0x61, 0x37, 0x35, 0x34, 0x32, 0x62, 0x63, 0x34, 0x62, 0x66, 0x39, 0x30, 0x65, 0x61, 0x35, 0x65, 0x37, 0x36, 0x37, 0x36, 0x39, 0x64, 0x65, 0x66, 0x30, 0x36, 0x63, 0x66, 0x31, 0x33, 0x30, 0x33, 0x65, 0x62, 0x37, 0x32, 0x62, 0x63, 0x63, 0x37, 0x32, 0x61, 0x37, 0x33, 0x63, 0x31, 0x32, 0x33, 0x31, 0x61, 0x62, 0x31, 0x31, 0x66, 0x61, 0x31, 0x36, 0x38, 0x65, 0x62, 0x30, 0x65, 0x39, 0x35, 0x64, 0x31, 0x32, 0x38, 0x34, 0x36, 0x64, 0x61, 0x61, 0x61, 0x35, 0x39, 0x31, 0x33, 0x61, 0x63, 0x65, 0x34, 0x39, 0x65, 0x36, 0x37, 0x30, 0x66, 0x64, 0x38, 0x32, 0x61, 0x36, 0x61, 0x38, 0x31, 0x35, 0x34, 0x30, 0x32, 0x33, 0x39, 0x62, 0x38, 0x63, 0x33, 0x64, 0x37, 0x32, 0x33, 0x65, 0x61, 0x66, 0x37, 0x34, 0x63, 0x37, 0x32, 0x61, 0x32, 0x61, 0x62, 0x32, 0x65, 0x65, 0x33, 0x34, 0x64, 0x66, 0x34, 0x35, 0x65, 0x33, 0x66, 0x62, 0x34, 0x35, 0x37, 0x32, 0x63, 0x34, 0x30, 0x36, 0x64, 0x62, 0x32, 0x64, 0x39, 0x37, 0x32, 0x36, 0x31, 0x33, 0x35, 0x37, 0x62, 0x35, 0x31, 0x34, 0x35, 0x30, 0x39, 0x66, 0x64, 0x30, 0x34, 0x65, 0x36, 0x39, 0x33, 0x32, 0x36, 0x34, 0x33, 0x65, 0x36, 0x64, 0x30, 0x36, 0x34, 0x63, 0x61, 0x37, 0x32, 0x65, 0x37, 0x66, 0x66, 0x62, 0x36, 0x62, 0x31, 0x36, 0x30, 0x36, 0x63, 0x62, 0x35, 0x62, 0x34, 0x30, 0x61, 0x66, 0x36, 0x36, 0x31, 0x62, 0x38, 0x66, 0x33, 0x32, 0x64, 0x37, 0x30, 0x36, 0x36, 0x65, 0x36, 0x38, 0x30, 0x39, 0x62, 0x34, 0x33, 0x62, 0x37, 0x63, 0x64, 0x61, 0x61, 0x64, 0x32, 0x37, 0x32, 0x62, 0x37, 0x32, 0x36, 0x62, 0x33, 0x37, 0x31, 0x34, 0x65, 0x35, 0x32, 0x37, 0x35, 0x35, 0x62, 0x34, 0x61, 0x64, 0x34, 0x30, 0x32, 0x37, 0x30, 0x30, 0x38, 0x30, 0x61, 0x35, 0x37, 0x65, 0x65, 0x35, 0x38, 0x34, 0x39, 0x64, 0x32, 0x33, 0x64, 0x62, 0x38, 0x37, 0x61, 0x63, 0x32, 0x33, 0x39, 0x65, 0x37, 0x39, 0x66, 0x61, 0x37, 0x35, 0x31, 0x30, 0x39, 0x30, 0x63, 0x62, 0x32, 0x31, 0x61, 0x65, 0x31, 0x61, 0x38, 0x31, 0x30, 0x65, 0x65, 0x37, 0x33, 0x31, 0x38, 0x30, 0x61, 0x33, 0x34, 0x63, 0x63, 0x33, 0x37, 0x36, 0x61, 0x30, 0x30, 0x62, 0x61, 0x31, 0x63, 0x32, 0x31, 0x39, 0x31, 0x35, 0x37, 0x38, 0x38, 0x36, 0x61, 0x36, 0x32, 0x66, 0x64, 0x32, 0x32, 0x31, 0x36, 0x30, 0x61, 0x38, 0x62, 0x32, 0x65, 0x30, 0x61, 0x39, 0x37, 0x37, 0x64, 0x64, 0x34, 0x35, 0x35, 0x37, 0x39, 0x34, 0x36, 0x33, 0x61, 0x34, 0x65, 0x64, 0x33, 0x64, 0x31, 0x34, 0x39, 0x36, 0x66, 0x39, 0x38, 0x63, 0x66, 0x61, 0x31, 0x63, 0x35, 0x34, 0x33, 0x39, 0x61, 0x38, 0x35, 0x66, 0x65, 0x61, 0x31, 0x66, 0x65, 0x61, 0x65, 0x31, 0x30, 0x61, 0x36, 0x30, 0x31, 0x62, 0x31, 0x31, 0x33, 0x31, 0x63, 0x38, 0x30, 0x38, 0x65, 0x31, 0x30, 0x38, 0x38, 0x39, 0x32, 0x65, 0x35, 0x66, 0x38, 0x35, 0x64, 0x31, 0x37, 0x32, 0x39, 0x31, 0x39, 0x38, 0x63, 0x62, 0x31, 0x63, 0x39, 0x39, 0x35, 0x32, 0x39, 0x36, 0x35, 0x34, 0x37, 0x33, 0x62, 0x66, 0x37, 0x33, 0x33, 0x65, 0x37, 0x35, 0x34, 0x62, 0x61, 0x36, 0x30, 0x35, 0x30, 0x35, 0x61, 0x65, 0x35, 0x38, 0x33, 0x33, 0x39, 0x39, 0x33, 0x65, 0x39, 0x36, 0x30, 0x31, 0x32, 0x63, 0x66, 0x39, 0x62, 0x31, 0x39, 0x35, 0x32, 0x39, 0x33, 0x31, 0x30, 0x36, 0x37, 0x32, 0x35, 0x66, 0x38, 0x64, 0x39, 0x61, 0x34, 0x39, 0x33, 0x34, 0x64, 0x38, 0x62, 0x37, 0x64, 0x34, 0x33, 0x33, 0x34, 0x35, 0x61, 0x36, 0x37, 0x37, 0x65, 0x36, 0x36, 0x32, 0x32, 0x35, 0x39, 0x33, 0x66, 0x65, 0x36, 0x30, 0x66, 0x33, 0x61, 0x32, 0x32, 0x32, 0x36, 0x66, 0x64, 0x31, 0x61, 0x37, 0x30, 0x32, 0x63, 0x37, 0x62, 0x39, 0x36, 0x35, 0x30, 0x35, 0x61, 0x35, 0x66, 0x33, 0x32, 0x30, 0x63, 0x31, 0x31, 0x34, 0x62, 0x35, 0x61, 0x65, 0x33, 0x33, 0x38, 0x38, 0x39, 0x61, 0x33, 0x64, 0x62, 0x38, 0x38, 0x36, 0x61, 0x34, 0x65, 0x31, 0x37, 0x65, 0x36, 0x39, 0x30, 0x65, 0x34, 0x31, 0x33, 0x62, 0x33, 0x66, 0x33, 0x32, 0x66, 0x31, 0x39, 0x63, 0x31, 0x34, 0x61, 0x65, 0x62, 0x33, 0x33, 0x61, 0x65, 0x36, 0x37, 0x38, 0x35, 0x32, 0x62, 0x63, 0x38, 0x39, 0x35, 0x38, 0x32, 0x33, 0x31, 0x36, 0x38, 0x38, 0x31, 0x35, 0x63, 0x34, 0x36, 0x36, 0x30, 0x33, 0x35, 0x32, 0x61, 0x31, 0x37, 0x37, 0x34, 0x61, 0x38, 0x66, 0x35, 0x33, 0x37, 0x38, 0x63, 0x38, 0x62, 0x36, 0x64, 0x36, 0x63, 0x33, 0x66, 0x65, 0x38, 0x39, 0x66, 0x37, 0x36, 0x64, 0x66, 0x63, 0x63, 0x64, 0x37, 0x38, 0x34, 0x35, 0x35, 0x37, 0x66, 0x36, 0x34, 0x35, 0x64, 0x65, 0x63, 0x65, 0x31, 0x39, 0x34, 0x36, 0x31, 0x36, 0x38, 0x61, 0x66, 0x39, 0x66, 0x65, 0x64, 0x31, 0x35, 0x61, 0x33, 0x30, 0x31, 0x61, 0x32, 0x62, 0x31, 0x63, 0x34, 0x63, 0x39, 0x62, 0x37, 0x66, 0x33, 0x30, 0x39, 0x30, 0x32, 0x31, 0x35, 0x66, 0x35, 0x66, 0x64, 0x39, 0x38, 0x65, 0x65, 0x33, 0x35, 0x66, 0x63, 0x32, 0x63, 0x36, 0x33, 0x65, 0x32, 0x64, 0x61, 0x36, 0x39, 0x64, 0x34, 0x63, 0x36, 0x33, 0x62, 0x62, 0x37, 0x32, 0x32, 0x36, 0x61, 0x36, 0x34, 0x36, 0x30, 0x36, 0x32, 0x61, 0x62, 0x39, 0x34, 0x65, 0x66, 0x63, 0x38, 0x34, 0x35, 0x32, 0x37, 0x39, 0x31, 0x65, 0x62, 0x65, 0x63, 0x61, 0x31, 0x39, 0x30, 0x63, 0x66, 0x61, 0x65, 0x39, 0x35, 0x36, 0x33, 0x35, 0x30, 0x32, 0x66, 0x38, 0x39, 0x37, 0x34, 0x66, 0x30, 0x31, 0x35, 0x65, 0x61, 0x35, 0x34, 0x32, 0x30, 0x32, 0x37, 0x63, 0x65, 0x62, 0x37, 0x32, 0x35, 0x36, 0x65, 0x32, 0x37, 0x33, 0x62, 0x32, 0x63, 0x61, 0x65, 0x66, 0x61, 0x62, 0x36, 0x63, 0x30, 0x33, 0x38, 0x38, 0x66, 0x33, 0x39, 0x66, 0x37, 0x65, 0x62, 0x65, 0x63, 0x64, 0x38, 0x37, 0x35, 0x34, 0x36, 0x38, 0x31, 0x64, 0x37, 0x65, 0x30, 0x37, 0x62, 0x31, 0x36, 0x38, 0x66, 0x37, 0x36, 0x65, 0x33, 0x61, 0x65, 0x38, 0x32, 0x64, 0x34, 0x39, 0x34, 0x37, 0x38, 0x32, 0x37, 0x32, 0x37, 0x61, 0x37, 0x62, 0x62, 0x31, 0x35, 0x35, 0x32, 0x38, 0x33, 0x64, 0x31, 0x64, 0x63, 0x66, 0x61, 0x38, 0x36, 0x31, 0x37, 0x37, 0x33, 0x61, 0x62, 0x33, 0x32, 0x61, 0x31, 0x37, 0x65, 0x39, 0x39, 0x61, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x33, 0x34, 0x64, 0x66, 0x36, 0x63, 0x64, 0x30, 0x36, 0x34, 0x37, 0x66, 0x39, 0x33, 0x37, 0x64, 0x64, 0x64, 0x32, 0x32, 0x38, 0x35, 0x37, 0x32, 0x63, 0x32, 0x30, 0x39, 0x63, 0x39, 0x63, 0x36, 0x30, 0x66, 0x30, 0x34, 0x61, 0x35, 0x36, 0x62, 0x61, 0x39, 0x31, 0x39, 0x66, 0x62, 0x35, 0x36, 0x63, 0x33, 0x38, 0x64, 0x37, 0x31, 0x64, 0x38, 0x35, 0x65, 0x38, 0x61, 0x32, 0x38, 0x66, 0x34, 0x65, 0x61, 0x39, 0x32, 0x36, 0x35, 0x61, 0x39, 0x36, 0x62, 0x38, 0x33, 0x39, 0x63, 0x34, 0x66, 0x32, 0x33, 0x32, 0x31, 0x39, 0x35, 0x37, 0x32, 0x62, 0x65, 0x64, 0x65, 0x31, 0x62, 0x63, 0x64, 0x31, 0x62, 0x35, 0x30, 0x38, 0x61, 0x66, 0x62, 0x37, 0x30, 0x38, 0x36, 0x30, 0x66, 0x66, 0x32, 0x61, 0x31, 0x32, 0x64, 0x61, 0x38, 0x61, 0x35, 0x31, 0x65, 0x66, 0x39, 0x37, 0x64, 0x65, 0x30, 0x63, 0x37, 0x35, 0x39, 0x64, 0x30, 0x34, 0x61, 0x65, 0x30, 0x30, 0x34, 0x32, 0x39, 0x33, 0x38, 0x62, 0x32, 0x35, 0x35, 0x31, 0x39, 0x37, 0x32, 0x37, 0x38, 0x66, 0x66, 0x37, 0x31, 0x38, 0x35, 0x35, 0x33, 0x32, 0x65, 0x63, 0x63, 0x31, 0x34, 0x36, 0x30, 0x38, 0x37, 0x33, 0x65, 0x32, 0x33, 0x39, 0x38, 0x63, 0x36, 0x63, 0x62, 0x66, 0x63, 0x38, 0x36, 0x61, 0x34, 0x64, 0x34, 0x35, 0x36, 0x63, 0x39, 0x35, 0x36, 0x61, 0x66, 0x66, 0x34, 0x39, 0x61, 0x32, 0x30, 0x33, 0x61, 0x38, 0x63, 0x32, 0x30, 0x62, 0x35, 0x34, 0x65, 0x35, 0x36, 0x34, 0x65, 0x62, 0x34, 0x65, 0x32, 0x65, 0x66, 0x35, 0x33, 0x33, 0x64, 0x36, 0x35, 0x30, 0x31, 0x32, 0x66, 0x30, 0x38, 0x63, 0x39, 0x36, 0x66, 0x34, 0x35, 0x30, 0x39, 0x31, 0x65, 0x37, 0x31, 0x66, 0x63, 0x35, 0x65, 0x38, 0x33, 0x33, 0x31, 0x66, 0x31, 0x39, 0x33, 0x62, 0x37, 0x32, 0x63, 0x35, 0x30, 0x37, 0x39, 0x37, 0x65, 0x66, 0x34, 0x31, 0x32, 0x36, 0x36, 0x34, 0x38, 0x37, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x36, 0x32, 0x64, 0x66, 0x34, 0x34, 0x35, 0x66, 0x65, 0x38, 0x31, 0x65, 0x35, 0x33, 0x37, 0x66, 0x30, 0x63, 0x37, 0x35, 0x62, 0x39, 0x33, 0x36, 0x65, 0x33, 0x63, 0x39, 0x64, 0x65, 0x32, 0x38, 0x66, 0x32, 0x65, 0x61, 0x35, 0x38, 0x30, 0x38, 0x33, 0x62, 0x34, 0x62, 0x63, 0x63, 0x61, 0x35, 0x34, 0x34, 0x38, 0x31, 0x32, 0x39, 0x30, 0x32, 0x30, 0x37, 0x32, 0x32, 0x34, 0x36, 0x36, 0x37, 0x31, 0x66, 0x33, 0x32, 0x31, 0x65, 0x36, 0x62, 0x38, 0x35, 0x33, 0x36, 0x34, 0x39, 0x35, 0x39, 0x30, 0x35, 0x66, 0x65, 0x63, 0x31, 0x38, 0x37, 0x39, 0x65, 0x39, 0x64, 0x61, 0x30, 0x32, 0x37, 0x63, 0x39, 0x62, 0x66, 0x31, 0x32, 0x64, 0x65, 0x32, 0x31, 0x63, 0x38, 0x61, 0x62, 0x36, 0x37, 0x62, 0x30, 0x32, 0x65, 0x65, 0x63, 0x33, 0x61, 0x62, 0x37, 0x32, 0x38, 0x30, 0x32, 0x32, 0x35, 0x37, 0x64, 0x31, 0x64, 0x37, 0x38, 0x30, 0x37, 0x35, 0x30, 0x39, 0x64, 0x62, 0x34, 0x38, 0x66, 0x65, 0x36, 0x30, 0x61, 0x36, 0x37, 0x30, 0x65, 0x36, 0x38, 0x39, 0x63, 0x33, 0x36, 0x33, 0x34, 0x63, 0x37, 0x34, 0x32, 0x36, 0x64, 0x62, 0x37, 0x39, 0x34, 0x37, 0x63, 0x66, 0x63, 0x63, 0x33, 0x37, 0x62, 0x65, 0x39, 0x35, 0x62, 0x31, 0x34, 0x32, 0x32, 0x39, 0x39, 0x32, 0x31, 0x66, 0x33, 0x34, 0x32, 0x35, 0x64, 0x35, 0x66, 0x38, 0x31, 0x32, 0x33, 0x33, 0x37, 0x32, 0x62, 0x39, 0x66, 0x35, 0x34, 0x31, 0x38, 0x30, 0x32, 0x39, 0x64, 0x30, 0x34, 0x38, 0x33, 0x32, 0x61, 0x66, 0x39, 0x37, 0x35, 0x36, 0x32, 0x35, 0x38, 0x38, 0x33, 0x63, 0x37, 0x39, 0x30, 0x31, 0x38, 0x64, 0x37, 0x37, 0x62, 0x63, 0x63, 0x35, 0x33, 0x30, 0x39, 0x36, 0x37, 0x32, 0x65, 0x62, 0x64, 0x33, 0x64, 0x30, 0x30, 0x64, 0x38, 0x35, 0x31, 0x62, 0x61, 0x63, 0x32, 0x35, 0x37, 0x66, 0x66, 0x34, 0x65, 0x32, 0x65, 0x66, 0x34, 0x37, 0x37, 0x62, 0x35, 0x34, 0x32, 0x30, 0x33, 0x30, 0x64, 0x34, 0x62, 0x32, 0x61, 0x35, 0x32, 0x36, 0x35, 0x63, 0x65, 0x61, 0x30, 0x63, 0x63, 0x39, 0x34, 0x63, 0x34, 0x34, 0x63, 0x64, 0x63, 0x65, 0x62, 0x30, 0x36, 0x65, 0x33, 0x33, 0x35, 0x64, 0x38, 0x66, 0x32, 0x66, 0x37, 0x64, 0x63, 0x35, 0x30, 0x34, 0x61, 0x35, 0x65, 0x32, 0x30, 0x31, 0x62, 0x61, 0x63, 0x63, 0x37, 0x35, 0x38, 0x39, 0x61, 0x34, 0x62, 0x39, 0x39, 0x31, 0x37, 0x31, 0x36, 0x64, 0x35, 0x65, 0x39, 0x63, 0x35, 0x35, 0x63, 0x63, 0x63, 0x66, 0x38, 0x61, 0x30, 0x32, 0x31, 0x65, 0x33, 0x30, 0x38, 0x63, 0x64, 0x32, 0x64, 0x36, 0x34, 0x63, 0x37, 0x32, 0x66, 0x66, 0x34, 0x65, 0x38, 0x61, 0x66, 0x61, 0x34, 0x65, 0x32, 0x61, 0x38, 0x63, 0x37, 0x35, 0x33, 0x64, 0x65, 0x32, 0x64, 0x62, 0x61, 0x63, 0x66, 0x39, 0x61, 0x30, 0x63, 0x30, 0x38, 0x62, 0x36, 0x64, 0x64, 0x35, 0x66, 0x66, 0x32, 0x64, 0x35, 0x37, 0x64, 0x65, 0x64, 0x35, 0x35, 0x64, 0x62, 0x35, 0x33, 0x35, 0x36, 0x30, 0x66, 0x62, 0x61, 0x61, 0x66, 0x65, 0x62, 0x35, 0x37, 0x32, 0x37, 0x38, 0x64, 0x30, 0x33, 0x36, 0x63, 0x62, 0x65, 0x35, 0x38, 0x61, 0x32, 0x65, 0x61, 0x31, 0x37, 0x62, 0x33, 0x36, 0x33, 0x65, 0x33, 0x32, 0x64, 0x33, 0x39, 0x32, 0x64, 0x33, 0x62, 0x38, 0x30, 0x38, 0x38, 0x35, 0x39, 0x63, 0x30, 0x66, 0x62, 0x35, 0x30, 0x62, 0x39, 0x61, 0x61, 0x38, 0x30, 0x35, 0x30, 0x35, 0x37, 0x38, 0x35, 0x39, 0x63, 0x39, 0x64, 0x36, 0x61, 0x61, 0x37, 0x32, 0x61, 0x30, 0x38, 0x66, 0x66, 0x38, 0x61, 0x31, 0x31, 0x31, 0x30, 0x35, 0x34, 0x38, 0x33, 0x62, 0x32, 0x30, 0x65, 0x64, 0x66, 0x61, 0x30, 0x30, 0x36, 0x65, 0x61, 0x38, 0x35, 0x61, 0x39, 0x64, 0x35, 0x37, 0x36, 0x34, 0x36, 0x61, 0x62, 0x64, 0x66, 0x31, 0x65, 0x63, 0x38, 0x65, 0x66, 0x62, 0x35, 0x63, 0x65, 0x61, 0x31, 0x36, 0x37, 0x36, 0x63, 0x62, 0x39, 0x32, 0x37, 0x65, 0x32, 0x37, 0x33, 0x37, 0x38, 0x35, 0x37, 0x39, 0x66, 0x66, 0x36, 0x35, 0x38, 0x37, 0x38, 0x65, 0x35, 0x34, 0x34, 0x63, 0x62, 0x33, 0x34, 0x31, 0x34, 0x66, 0x30, 0x32, 0x64, 0x61, 0x62, 0x38, 0x61, 0x32, 0x64, 0x65, 0x66, 0x31, 0x32, 0x33, 0x61, 0x33, 0x62, 0x33, 0x33, 0x61, 0x64, 0x62, 0x62, 0x37, 0x64, 0x37, 0x39, 0x32, 0x65, 0x63, 0x39, 0x30, 0x62, 0x39, 0x63, 0x66, 0x35, 0x61, 0x30, 0x32, 0x62, 0x38, 0x37, 0x30, 0x39, 0x63, 0x61, 0x38, 0x32, 0x38, 0x63, 0x38, 0x32, 0x63, 0x38, 0x61, 0x35, 0x32, 0x31, 0x32, 0x64, 0x63, 0x36, 0x35, 0x32, 0x35, 0x37, 0x61, 0x63, 0x31, 0x37, 0x65, 0x63, 0x37, 0x64, 0x38, 0x62, 0x33, 0x61, 0x34, 0x37, 0x39, 0x34, 0x64, 0x36, 0x62, 0x30, 0x34, 0x31, 0x62, 0x31, 0x39, 0x65, 0x33, 0x31, 0x32, 0x66, 0x33, 0x36, 0x32, 0x39, 0x38, 0x36, 0x35, 0x34, 0x32, 0x39, 0x39, 0x34, 0x39, 0x32, 0x63, 0x39, 0x35, 0x61, 0x31, 0x31, 0x65, 0x30, 0x65, 0x31, 0x63, 0x63, 0x66, 0x64, 0x39, 0x37, 0x38, 0x32, 0x38, 0x30, 0x63, 0x37, 0x66, 0x35, 0x30, 0x31, 0x37, 0x37, 0x66, 0x63, 0x35, 0x64, 0x38, 0x61, 0x66, 0x34, 0x62, 0x34, 0x65, 0x36, 0x61, 0x37, 0x34, 0x34, 0x31, 0x66, 0x34, 0x38, 0x35, 0x66, 0x31, 0x39, 0x38, 0x35, 0x32, 0x37, 0x32, 0x65, 0x36, 0x34, 0x32, 0x31, 0x30, 0x36, 0x30, 0x66, 0x39, 0x66, 0x35, 0x32, 0x30, 0x66, 0x32, 0x35, 0x39, 0x63, 0x37, 0x37, 0x36, 0x63, 0x63, 0x30, 0x39, 0x35, 0x30, 0x31, 0x64, 0x66, 0x34, 0x64, 0x38, 0x34, 0x37, 0x39, 0x34, 0x38, 0x38, 0x35, 0x66, 0x65, 0x37, 0x62, 0x64, 0x64, 0x36, 0x64, 0x39, 0x63, 0x31, 0x34, 0x63, 0x65, 0x66, 0x62, 0x35, 0x63, 0x38, 0x39, 0x34, 0x31, 0x64, 0x36, 0x62, 0x37, 0x31, 0x34, 0x37, 0x34, 0x33, 0x62, 0x62, 0x30, 0x38, 0x63, 0x30, 0x62, 0x32, 0x33, 0x66, 0x31, 0x39, 0x37, 0x64, 0x34, 0x37, 0x39, 0x65, 0x39, 0x61, 0x61, 0x31, 0x62, 0x66, 0x31, 0x39, 0x30, 0x65, 0x36, 0x64, 0x62, 0x64, 0x61, 0x62, 0x35, 0x30, 0x64, 0x30, 0x64, 0x32, 0x61, 0x64, 0x32, 0x36, 0x39, 0x39, 0x33, 0x36, 0x35, 0x37, 0x35, 0x32, 0x36, 0x32, 0x35, 0x64, 0x34, 0x33, 0x39, 0x62, 0x31, 0x65, 0x30, 0x33, 0x38, 0x65, 0x63, 0x31, 0x65, 0x38, 0x30, 0x30, 0x63, 0x62, 0x32, 0x64, 0x36, 0x62, 0x36, 0x64, 0x36, 0x65, 0x34, 0x32, 0x65, 0x33, 0x35, 0x33, 0x31, 0x36, 0x64, 0x65, 0x31, 0x65, 0x32, 0x63, 0x38, 0x63, 0x66, 0x33, 0x39, 0x66, 0x36, 0x35, 0x38, 0x36, 0x64, 0x38, 0x65, 0x38, 0x61, 0x62, 0x38, 0x64, 0x30, 0x63, 0x38, 0x37, 0x37, 0x32, 0x64, 0x31, 0x30, 0x39, 0x30, 0x34, 0x36, 0x63, 0x32, 0x33, 0x66, 0x62, 0x31, 0x32, 0x65, 0x37, 0x61, 0x37, 0x30, 0x37, 0x36, 0x64, 0x61, 0x39, 0x61, 0x62, 0x63, 0x32, 0x62, 0x64, 0x32, 0x39, 0x30, 0x64, 0x64, 0x30, 0x38, 0x39, 0x33, 0x61, 0x35, 0x34, 0x34, 0x34, 0x65, 0x35, 0x34, 0x32, 0x35, 0x64, 0x37, 0x32, 0x36, 0x64, 0x37, 0x35, 0x34, 0x34, 0x66, 0x63, 0x37, 0x63, 0x32, 0x33, 0x36, 0x35, 0x36, 0x65, 0x35, 0x30, 0x65, 0x30, 0x33, 0x33, 0x32, 0x65, 0x35, 0x61, 0x38, 0x34, 0x34, 0x39, 0x37, 0x39, 0x66, 0x64, 0x66, 0x37, 0x37, 0x64, 0x34, 0x65, 0x64, 0x37, 0x31, 0x33, 0x37, 0x61, 0x61, 0x35, 0x65, 0x34, 0x30, 0x35, 0x34, 0x31, 0x34, 0x35, 0x31, 0x37, 0x34, 0x36, 0x31, 0x36, 0x33, 0x61, 0x32, 0x30, 0x33, 0x62, 0x61, 0x31, 0x34, 0x38, 0x32, 0x65, 0x35, 0x63, 0x31, 0x31, 0x32, 0x66, 0x63, 0x63, 0x62, 0x61, 0x65, 0x63, 0x32, 0x35, 0x38, 0x38, 0x63, 0x31, 0x64, 0x35, 0x31, 0x33, 0x39, 0x64, 0x38, 0x65, 0x34, 0x62, 0x61, 0x35, 0x33, 0x63, 0x38, 0x33, 0x61, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x38, 0x32, 0x63, 0x38, 0x33, 0x33, 0x39, 0x34, 0x38, 0x62, 0x35, 0x63, 0x35, 0x37, 0x37, 0x65, 0x66, 0x34, 0x32, 0x36, 0x36, 0x32, 0x30, 0x36, 0x31, 0x35, 0x31, 0x30, 0x38, 0x34, 0x63, 0x62, 0x62, 0x62, 0x37, 0x63, 0x32, 0x36, 0x61, 0x34, 0x32, 0x38, 0x62, 0x32, 0x62, 0x32, 0x38, 0x61, 0x34, 0x30, 0x34, 0x62, 0x66, 0x39, 0x65, 0x66, 0x65, 0x30, 0x64, 0x66, 0x62, 0x31, 0x32, 0x66, 0x35, 0x30, 0x38, 0x37, 0x64, 0x61, 0x32, 0x33, 0x32, 0x65, 0x30, 0x35, 0x61, 0x33, 0x34, 0x61, 0x31, 0x38, 0x38, 0x35, 0x31, 0x61, 0x39, 0x37, 0x32, 0x36, 0x33, 0x37, 0x62, 0x37, 0x35, 0x36, 0x31, 0x33, 0x30, 0x36, 0x35, 0x63, 0x38, 0x32, 0x62, 0x30, 0x35, 0x31, 0x61, 0x35, 0x34, 0x62, 0x31, 0x37, 0x33, 0x61, 0x35, 0x36, 0x61, 0x34, 0x36, 0x66, 0x33, 0x66, 0x35, 0x65, 0x65, 0x32, 0x39, 0x39, 0x66, 0x39, 0x33, 0x31, 0x32, 0x39, 0x34, 0x64, 0x39, 0x36, 0x33, 0x31, 0x38, 0x37, 0x65, 0x62, 0x61, 0x65, 0x64, 0x38, 0x62, 0x37, 0x32, 0x65, 0x38, 0x61, 0x32, 0x32, 0x65, 0x33, 0x33, 0x35, 0x37, 0x30, 0x38, 0x37, 0x30, 0x66, 0x61, 0x30, 0x36, 0x61, 0x33, 0x33, 0x62, 0x36, 0x64, 0x35, 0x37, 0x30, 0x38, 0x32, 0x39, 0x62, 0x38, 0x30, 0x62, 0x31, 0x62, 0x31, 0x61, 0x39, 0x30, 0x62, 0x37, 0x37, 0x61, 0x39, 0x39, 0x61, 0x61, 0x31, 0x61, 0x38, 0x33, 0x61, 0x66, 0x39, 0x31, 0x64, 0x39, 0x33, 0x38, 0x66, 0x33, 0x37, 0x32, 0x30, 0x31, 0x37, 0x63, 0x63, 0x31, 0x62, 0x35, 0x62, 0x36, 0x63, 0x38, 0x31, 0x66, 0x64, 0x65, 0x30, 0x38, 0x66, 0x34, 0x64, 0x36, 0x62, 0x64, 0x35, 0x34, 0x32, 0x33, 0x66, 0x66, 0x64, 0x32, 0x39, 0x38, 0x63, 0x64, 0x36, 0x66, 0x34, 0x62, 0x31, 0x31, 0x33, 0x37, 0x37, 0x65, 0x61, 0x32, 0x31, 0x36, 0x63, 0x38, 0x30, 0x32, 0x38, 0x34, 0x39, 0x64, 0x36, 0x64, 0x34, 0x30, 0x34, 0x36, 0x61, 0x30, 0x35, 0x63, 0x39, 0x66, 0x37, 0x62, 0x34, 0x33, 0x66, 0x62, 0x66, 0x34, 0x62, 0x30, 0x37, 0x39, 0x64, 0x64, 0x36, 0x36, 0x33, 0x39, 0x36, 0x33, 0x64, 0x38, 0x39, 0x65, 0x38, 0x64, 0x32, 0x63, 0x31, 0x66, 0x64, 0x38, 0x36, 0x63, 0x34, 0x31, 0x63, 0x36, 0x34, 0x36, 0x32, 0x37, 0x37, 0x33, 0x35, 0x64, 0x32, 0x34, 0x61, 0x61, 0x63, 0x37, 0x63, 0x39, 0x39, 0x63, 0x37, 0x32, 0x39, 0x61, 0x35, 0x39, 0x33, 0x34, 0x66, 0x35, 0x30, 0x34, 0x33, 0x30, 0x34, 0x66, 0x37, 0x64, 0x65, 0x39, 0x61, 0x39, 0x30, 0x36, 0x64, 0x63, 0x39, 0x35, 0x39, 0x38, 0x33, 0x62, 0x62, 0x64, 0x38, 0x31, 0x33, 0x32, 0x34, 0x33, 0x66, 0x36, 0x65, 0x39, 0x38, 0x65, 0x38, 0x65, 0x38, 0x35, 0x61, 0x33, 0x66, 0x38, 0x38, 0x30, 0x64, 0x61, 0x34, 0x61, 0x35, 0x37, 0x61, 0x32, 0x37, 0x32, 0x35, 0x30, 0x38, 0x35, 0x32, 0x38, 0x31, 0x37, 0x36, 0x63, 0x34, 0x62, 0x62, 0x32, 0x39, 0x66, 0x62, 0x66, 0x63, 0x36, 0x66, 0x65, 0x64, 0x39, 0x39, 0x65, 0x66, 0x39, 0x33, 0x35, 0x31, 0x32, 0x32, 0x65, 0x37, 0x30, 0x32, 0x33, 0x32, 0x35, 0x32, 0x31, 0x37, 0x38, 0x62, 0x63, 0x63, 0x35, 0x34, 0x30, 0x62, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x32, 0x62, 0x65, 0x36, 0x65, 0x37, 0x32, 0x37, 0x66, 0x65, 0x30, 0x64, 0x31, 0x39, 0x37, 0x61, 0x30, 0x61, 0x32, 0x38, 0x61, 0x36, 0x64, 0x35, 0x63, 0x31, 0x30, 0x61, 0x66, 0x33, 0x63, 0x62, 0x33, 0x64, 0x66, 0x38, 0x35, 0x62, 0x34, 0x39, 0x64, 0x32, 0x33, 0x33, 0x39, 0x37, 0x63, 0x32, 0x32, 0x35, 0x32, 0x31, 0x39, 0x61, 0x36, 0x33, 0x36, 0x32, 0x37, 0x62, 0x35, 0x64, 0x34, 0x66, 0x31, 0x61, 0x64, 0x66, 0x63, 0x30, 0x34, 0x65, 0x38, 0x30, 0x37, 0x33, 0x63, 0x64, 0x36, 0x30, 0x62, 0x66, 0x62, 0x30, 0x39, 0x31, 0x32, 0x35, 0x62, 0x62, 0x37, 0x39, 0x34, 0x33, 0x64, 0x33, 0x61, 0x36, 0x36, 0x37, 0x31, 0x37, 0x32, 0x62, 0x62, 0x33, 0x33, 0x34, 0x35, 0x61, 0x36, 0x63, 0x32, 0x65, 0x62, 0x39, 0x32, 0x32, 0x35, 0x32, 0x34, 0x36, 0x61, 0x30, 0x39, 0x38, 0x37, 0x32, 0x66, 0x30, 0x37, 0x30, 0x34, 0x35, 0x31, 0x39, 0x61, 0x62, 0x61, 0x32, 0x62, 0x33, 0x34, 0x32, 0x34, 0x62, 0x39, 0x33, 0x66, 0x35, 0x33, 0x66, 0x62, 0x62, 0x34, 0x39, 0x38, 0x65, 0x66, 0x32, 0x31, 0x63, 0x62, 0x37, 0x36, 0x34, 0x33, 0x33, 0x34, 0x31, 0x32, 0x35, 0x32, 0x35, 0x61, 0x65, 0x31, 0x34, 0x30, 0x38, 0x64, 0x63, 0x35, 0x30, 0x35, 0x33, 0x39, 0x64, 0x66, 0x36, 0x65, 0x38, 0x30, 0x38, 0x63, 0x38, 0x65, 0x37, 0x32, 0x61, 0x36, 0x66, 0x38, 0x39, 0x61, 0x34, 0x64, 0x37, 0x30, 0x64, 0x31, 0x35, 0x66, 0x31, 0x62, 0x34, 0x34, 0x66, 0x62, 0x31, 0x37, 0x31, 0x30, 0x62, 0x36, 0x36, 0x64, 0x36, 0x38, 0x33, 0x63, 0x63, 0x34, 0x35, 0x38, 0x37, 0x37, 0x34, 0x31, 0x62, 0x30, 0x38, 0x32, 0x36, 0x61, 0x33, 0x31, 0x33, 0x63, 0x36, 0x61, 0x31, 0x31, 0x34, 0x37, 0x34, 0x63, 0x38, 0x66, 0x65, 0x38, 0x30, 0x30, 0x32, 0x33, 0x37, 0x66, 0x36, 0x35, 0x64, 0x34, 0x35, 0x65, 0x38, 0x31, 0x61, 0x39, 0x63, 0x66, 0x33, 0x30, 0x62, 0x31, 0x31, 0x34, 0x38, 0x38, 0x30, 0x61, 0x39, 0x62, 0x31, 0x35, 0x66, 0x31, 0x66, 0x63, 0x34, 0x33, 0x62, 0x63, 0x65, 0x39, 0x30, 0x34, 0x63, 0x62, 0x35, 0x62, 0x38, 0x39, 0x34, 0x62, 0x63, 0x39, 0x39, 0x64, 0x39, 0x62, 0x63, 0x64, 0x61, 0x31, 0x64, 0x35, 0x37, 0x32, 0x30, 0x37, 0x30, 0x65, 0x39, 0x65, 0x37, 0x61, 0x33, 0x32, 0x35, 0x32, 0x30, 0x38, 0x34, 0x30, 0x37, 0x36, 0x66, 0x36, 0x64, 0x39, 0x38, 0x62, 0x35, 0x31, 0x38, 0x65, 0x33, 0x39, 0x61, 0x34, 0x63, 0x65, 0x39, 0x38, 0x34, 0x34, 0x36, 0x61, 0x38, 0x65, 0x30, 0x33, 0x31, 0x39, 0x62, 0x35, 0x66, 0x33, 0x34, 0x64, 0x30, 0x38, 0x63, 0x38, 0x32, 0x34, 0x66, 0x62, 0x30, 0x33, 0x33, 0x32, 0x62, 0x34, 0x37, 0x34, 0x35, 0x32, 0x33, 0x33, 0x62, 0x30, 0x63, 0x30, 0x66, 0x33, 0x63, 0x34, 0x31, 0x37, 0x65, 0x30, 0x39, 0x36, 0x33, 0x66, 0x63, 0x33, 0x33, 0x30, 0x37, 0x39, 0x34, 0x33, 0x35, 0x64, 0x31, 0x34, 0x36, 0x34, 0x32, 0x31, 0x39, 0x62, 0x34, 0x63, 0x38, 0x61, 0x32, 0x31, 0x34, 0x62, 0x31, 0x30, 0x34, 0x32, 0x39, 0x37, 0x61, 0x63, 0x35, 0x65, 0x32, 0x37, 0x33, 0x64, 0x66, 0x62, 0x38, 0x61, 0x30, 0x35, 0x31, 0x62, 0x38, 0x63, 0x65, 0x35, 0x63, 0x37, 0x38, 0x39, 0x30, 0x33, 0x65, 0x66, 0x64, 0x35, 0x63, 0x39, 0x62, 0x32, 0x36, 0x66, 0x61, 0x63, 0x34, 0x62, 0x64, 0x30, 0x33, 0x64, 0x37, 0x32, 0x36, 0x65, 0x35, 0x31, 0x32, 0x65, 0x32, 0x30, 0x30, 0x32, 0x66, 0x66, 0x64, 0x62, 0x65, 0x63, 0x61, 0x38, 0x33, 0x66, 0x39, 0x32, 0x32, 0x64, 0x37, 0x32, 0x34, 0x64, 0x61, 0x63, 0x39, 0x33, 0x32, 0x39, 0x65, 0x31, 0x33, 0x30, 0x30, 0x66, 0x37, 0x30, 0x61, 0x39, 0x62, 0x63, 0x66, 0x62, 0x64, 0x35, 0x33, 0x64, 0x66, 0x66, 0x34, 0x32, 0x39, 0x64, 0x64, 0x34, 0x31, 0x31, 0x37, 0x66, 0x61, 0x38, 0x37, 0x64, 0x38, 0x35, 0x33, 0x30, 0x37, 0x34, 0x31, 0x63, 0x34, 0x64, 0x66, 0x39, 0x38, 0x35, 0x39, 0x38, 0x36, 0x62, 0x61, 0x35, 0x37, 0x32, 0x61, 0x66, 0x64, 0x65, 0x33, 0x32, 0x36, 0x32, 0x39, 0x36, 0x34, 0x39, 0x64, 0x33, 0x30, 0x36, 0x65, 0x31, 0x63, 0x62, 0x61, 0x66, 0x35, 0x39, 0x34, 0x66, 0x31, 0x63, 0x38, 0x32, 0x65, 0x33, 0x32, 0x39, 0x66, 0x38, 0x32, 0x34, 0x35, 0x31, 0x37, 0x38, 0x32, 0x37, 0x66, 0x30, 0x64, 0x37, 0x34, 0x62, 0x35, 0x30, 0x64, 0x65, 0x34, 0x32, 0x37, 0x66, 0x34, 0x66, 0x65, 0x30, 0x37, 0x32, 0x32, 0x37, 0x65, 0x34, 0x38, 0x62, 0x33, 0x61, 0x63, 0x36, 0x34, 0x61, 0x37, 0x38, 0x63, 0x32, 0x33, 0x37, 0x64, 0x31, 0x30, 0x34, 0x33, 0x32, 0x65, 0x65, 0x38, 0x32, 0x66, 0x34, 0x38, 0x35, 0x34, 0x62, 0x30, 0x35, 0x62, 0x38, 0x38, 0x63, 0x65, 0x65, 0x62, 0x61, 0x30, 0x35, 0x38, 0x37, 0x33, 0x65, 0x38, 0x66, 0x63, 0x65, 0x62, 0x63, 0x31, 0x34, 0x30, 0x36, 0x61, 0x36, 0x37, 0x32, 0x65, 0x37, 0x36, 0x37, 0x30, 0x37, 0x39, 0x34, 0x63, 0x34, 0x66, 0x38, 0x34, 0x33, 0x31, 0x34, 0x36, 0x62, 0x36, 0x36, 0x38, 0x61, 0x63, 0x64, 0x66, 0x63, 0x39, 0x34, 0x30, 0x63, 0x32, 0x63, 0x66, 0x62, 0x36, 0x31, 0x37, 0x65, 0x61, 0x65, 0x65, 0x31, 0x66, 0x32, 0x34, 0x30, 0x38, 0x66, 0x35, 0x30, 0x63, 0x30, 0x31, 0x66, 0x61, 0x62, 0x32, 0x38, 0x38, 0x36, 0x39, 0x31, 0x33, 0x39, 0x32, 0x33, 0x32, 0x65, 0x65, 0x37, 0x32, 0x64, 0x66, 0x32, 0x61, 0x33, 0x38, 0x37, 0x34, 0x30, 0x36, 0x38, 0x63, 0x32, 0x62, 0x61, 0x65, 0x33, 0x64, 0x64, 0x32, 0x63, 0x36, 0x39, 0x34, 0x39, 0x63, 0x64, 0x63, 0x34, 0x34, 0x31, 0x37, 0x36, 0x32, 0x33, 0x31, 0x37, 0x30, 0x64, 0x35, 0x34, 0x63, 0x62, 0x63, 0x61, 0x32, 0x33, 0x61, 0x37, 0x63, 0x36, 0x35, 0x35, 0x33, 0x36, 0x34, 0x64, 0x31, 0x32, 0x61, 0x65, 0x32, 0x63, 0x64, 0x64, 0x33, 0x66, 0x37, 0x62, 0x38, 0x66, 0x30, 0x62, 0x62, 0x63, 0x37, 0x39, 0x36, 0x64, 0x37, 0x32, 0x34, 0x36, 0x38, 0x37, 0x34, 0x65, 0x30, 0x63, 0x65, 0x37, 0x31, 0x34, 0x38, 0x61, 0x62, 0x35, 0x64, 0x66, 0x66, 0x34, 0x36, 0x66, 0x64, 0x64, 0x63, 0x38, 0x64, 0x63, 0x37, 0x65, 0x30, 0x32, 0x65, 0x36, 0x63, 0x39, 0x36, 0x61, 0x37, 0x32, 0x66, 0x33, 0x30, 0x31, 0x34, 0x33, 0x66, 0x37, 0x66, 0x34, 0x34, 0x65, 0x32, 0x39, 0x65, 0x38, 0x39, 0x38, 0x36, 0x64, 0x63, 0x38, 0x61, 0x30, 0x35, 0x62, 0x37, 0x30, 0x65, 0x61, 0x35, 0x31, 0x66, 0x32, 0x30, 0x35, 0x62, 0x35, 0x62, 0x66, 0x36, 0x35, 0x31, 0x64, 0x65, 0x31, 0x33, 0x38, 0x36, 0x39, 0x31, 0x33, 0x64, 0x34, 0x39, 0x39, 0x37, 0x62, 0x66, 0x66, 0x39, 0x33, 0x31, 0x31, 0x32, 0x31, 0x61, 0x31, 0x35, 0x36, 0x33, 0x61, 0x34, 0x36, 0x65, 0x37, 0x66, 0x34, 0x33, 0x39, 0x33, 0x39, 0x30, 0x61, 0x35, 0x34, 0x66, 0x64, 0x32, 0x66, 0x39, 0x31, 0x62, 0x33, 0x37, 0x38, 0x64, 0x62, 0x30, 0x64, 0x39, 0x31, 0x37, 0x35, 0x31, 0x32, 0x65, 0x39, 0x64, 0x65, 0x61, 0x63, 0x34, 0x61, 0x66, 0x37, 0x32, 0x37, 0x64, 0x31, 0x37, 0x32, 0x64, 0x32, 0x32, 0x30, 0x37, 0x32, 0x32, 0x64, 0x61, 0x61, 0x36, 0x35, 0x65, 0x66, 0x61, 0x66, 0x63, 0x65, 0x34, 0x38, 0x63, 0x32, 0x38, 0x63, 0x66, 0x34, 0x38, 0x34, 0x39, 0x32, 0x35, 0x66, 0x31, 0x65, 0x39, 0x65, 0x30, 0x62, 0x65, 0x34, 0x63, 0x38, 0x61, 0x37, 0x33, 0x39, 0x62, 0x32, 0x31, 0x32, 0x34, 0x66, 0x30, 0x36, 0x30, 0x64, 0x66, 0x66, 0x39, 0x66, 0x31, 0x64, 0x35, 0x65, 0x33, 0x34, 0x61, 0x37, 0x32, 0x36, 0x35, 0x35, 0x66, 0x33, 0x36, 0x35, 0x63, 0x66, 0x30, 0x30, 0x39, 0x64, 0x62, 0x62, 0x66, 0x61, 0x63, 0x66, 0x30, 0x64, 0x35, 0x36, 0x35, 0x63, 0x61, 0x35, 0x38, 0x30, 0x34, 0x62, 0x37, 0x35, 0x30, 0x38, 0x38, 0x30, 0x66, 0x38, 0x30, 0x38, 0x38, 0x66, 0x34, 0x65, 0x63, 0x30, 0x37, 0x34, 0x63, 0x63, 0x63, 0x62, 0x30, 0x36, 0x30, 0x33, 0x37, 0x61, 0x37, 0x62, 0x62, 0x64, 0x37, 0x32, 0x38, 0x65, 0x30, 0x65, 0x34, 0x30, 0x32, 0x63, 0x62, 0x38, 0x35, 0x37, 0x35, 0x31, 0x37, 0x38, 0x31, 0x35, 0x62, 0x36, 0x63, 0x33, 0x31, 0x63, 0x63, 0x66, 0x30, 0x39, 0x37, 0x33, 0x31, 0x39, 0x39, 0x37, 0x39, 0x31, 0x66, 0x62, 0x31, 0x61, 0x66, 0x65, 0x39, 0x36, 0x65, 0x37, 0x34, 0x35, 0x39, 0x37, 0x63, 0x61, 0x35, 0x30, 0x64, 0x35, 0x35, 0x33, 0x35, 0x39, 0x33, 0x30, 0x32, 0x35, 0x38, 0x62, 0x38, 0x65, 0x66, 0x30, 0x66, 0x33, 0x30, 0x65, 0x63, 0x61, 0x32, 0x36, 0x34, 0x62, 0x61, 0x65, 0x37, 0x64, 0x39, 0x30, 0x38, 0x65, 0x33, 0x66, 0x32, 0x35, 0x38, 0x37, 0x34, 0x31, 0x61, 0x39, 0x66, 0x34, 0x65, 0x31, 0x31, 0x63, 0x62, 0x30, 0x62, 0x36, 0x35, 0x36, 0x32, 0x66, 0x33, 0x30, 0x64, 0x34, 0x61, 0x31, 0x39, 0x61, 0x37, 0x64, 0x35, 0x64, 0x32, 0x34, 0x37, 0x32, 0x39, 0x66, 0x34, 0x39, 0x32, 0x38, 0x37, 0x35, 0x33, 0x36, 0x35, 0x31, 0x39, 0x37, 0x30, 0x31, 0x33, 0x35, 0x66, 0x38, 0x33, 0x65, 0x65, 0x34, 0x39, 0x62, 0x65, 0x66, 0x62, 0x62, 0x39, 0x35, 0x30, 0x64, 0x38, 0x39, 0x64, 0x61, 0x31, 0x38, 0x38, 0x33, 0x34, 0x62, 0x61, 0x36, 0x35, 0x62, 0x33, 0x38, 0x30, 0x37, 0x37, 0x32, 0x33, 0x65, 0x64, 0x65, 0x64, 0x32, 0x34, 0x34, 0x37, 0x32, 0x36, 0x35, 0x31, 0x37, 0x61, 0x62, 0x39, 0x37, 0x31, 0x36, 0x61, 0x66, 0x30, 0x63, 0x34, 0x31, 0x33, 0x65, 0x34, 0x30, 0x38, 0x33, 0x64, 0x61, 0x35, 0x65, 0x31, 0x38, 0x39, 0x63, 0x66, 0x35, 0x39, 0x66, 0x62, 0x64, 0x66, 0x32, 0x64, 0x30, 0x32, 0x63, 0x39, 0x65, 0x62, 0x66, 0x61, 0x61, 0x30, 0x39, 0x61, 0x66, 0x30, 0x32, 0x62, 0x32, 0x39, 0x37, 0x62, 0x65, 0x64, 0x34, 0x37, 0x32, 0x36, 0x63, 0x65, 0x61, 0x63, 0x64, 0x61, 0x32, 0x33, 0x63, 0x62, 0x33, 0x31, 0x65, 0x63, 0x62, 0x31, 0x35, 0x34, 0x37, 0x65, 0x65, 0x66, 0x38, 0x64, 0x38, 0x34, 0x33, 0x30, 0x63, 0x33, 0x62, 0x37, 0x39, 0x64, 0x66, 0x33, 0x31, 0x34, 0x31, 0x62, 0x34, 0x34, 0x64, 0x66, 0x39, 0x35, 0x32, 0x31, 0x61, 0x66, 0x38, 0x36, 0x61, 0x36, 0x64, 0x62, 0x66, 0x65, 0x31, 0x36, 0x32, 0x31, 0x35, 0x32, 0x64, 0x39, 0x36, 0x61, 0x33, 0x37, 0x35, 0x34, 0x38, 0x61, 0x65, 0x38, 0x31, 0x62, 0x61, 0x33, 0x39, 0x32, 0x35, 0x64, 0x39, 0x39, 0x36, 0x63, 0x64, 0x61, 0x61, 0x39, 0x35, 0x36, 0x66, 0x37, 0x64, 0x66, 0x39, 0x38, 0x31, 0x37, 0x32, 0x39, 0x35, 0x64, 0x33, 0x38, 0x32, 0x61, 0x65, 0x62, 0x38, 0x64, 0x36, 0x34, 0x38, 0x35, 0x31, 0x61, 0x64, 0x61, 0x66, 0x36, 0x31, 0x37, 0x32, 0x66, 0x31, 0x62, 0x30, 0x65, 0x62, 0x61, 0x33, 0x64, 0x30, 0x65, 0x66, 0x62, 0x64, 0x33, 0x32, 0x63, 0x33, 0x61, 0x63, 0x63, 0x36, 0x30, 0x64, 0x63, 0x34, 0x64, 0x39, 0x65, 0x34, 0x30, 0x35, 0x39, 0x31, 0x33, 0x37, 0x37, 0x30, 0x35, 0x35, 0x36, 0x65, 0x65, 0x36, 0x33, 0x31, 0x61, 0x39, 0x32, 0x36, 0x64, 0x31, 0x34, 0x38, 0x35, 0x31, 0x65, 0x39, 0x34, 0x35, 0x34, 0x35, 0x36, 0x34, 0x63, 0x62, 0x36, 0x35, 0x37, 0x66, 0x66, 0x62, 0x37, 0x33, 0x36, 0x64, 0x31, 0x32, 0x33, 0x33, 0x66, 0x30, 0x64, 0x33, 0x61, 0x64, 0x37, 0x31, 0x38, 0x37, 0x32, 0x33, 0x34, 0x61, 0x30, 0x65, 0x65, 0x38, 0x34, 0x66, 0x33, 0x31, 0x34, 0x33, 0x35, 0x64, 0x65, 0x61, 0x37, 0x62, 0x32, 0x37, 0x33, 0x37, 0x37, 0x65, 0x31, 0x37, 0x63, 0x33, 0x65, 0x39, 0x35, 0x34, 0x36, 0x36, 0x37, 0x32, 0x33, 0x65, 0x66, 0x32, 0x65, 0x35, 0x32, 0x61, 0x34, 0x37, 0x61, 0x31, 0x35, 0x35, 0x32, 0x36, 0x33, 0x34, 0x36, 0x63, 0x33, 0x65, 0x33, 0x35, 0x35, 0x33, 0x61, 0x31, 0x37, 0x65, 0x62, 0x63, 0x37, 0x33, 0x63, 0x64, 0x66, 0x33, 0x31, 0x31, 0x64, 0x63, 0x35, 0x63, 0x66, 0x31, 0x38, 0x34, 0x33, 0x38, 0x30, 0x31, 0x30, 0x31, 0x61, 0x38, 0x62, 0x65, 0x64, 0x36, 0x62, 0x61, 0x37, 0x32, 0x34, 0x39, 0x64, 0x65, 0x37, 0x62, 0x38, 0x35, 0x33, 0x35, 0x37, 0x61, 0x31, 0x34, 0x61, 0x38, 0x31, 0x61, 0x38, 0x30, 0x65, 0x39, 0x31, 0x37, 0x66, 0x38, 0x34, 0x33, 0x30, 0x64, 0x33, 0x62, 0x65, 0x61, 0x30, 0x38, 0x65, 0x38, 0x62, 0x30, 0x39, 0x37, 0x35, 0x39, 0x31, 0x65, 0x62, 0x65, 0x65, 0x30, 0x63, 0x66, 0x34, 0x37, 0x32, 0x38, 0x33, 0x38, 0x63, 0x35, 0x61, 0x39, 0x35, 0x34, 0x62, 0x31, 0x61, 0x35, 0x36, 0x66, 0x30, 0x33, 0x61, 0x66, 0x34, 0x63, 0x38, 0x66, 0x39, 0x30, 0x32, 0x35, 0x33, 0x39, 0x61, 0x38, 0x31, 0x61, 0x36, 0x39, 0x65, 0x62, 0x61, 0x34, 0x61, 0x32, 0x66, 0x37, 0x31, 0x62, 0x62, 0x66, 0x35, 0x66, 0x64, 0x37, 0x35, 0x66, 0x34, 0x64, 0x62, 0x39, 0x38, 0x34, 0x31, 0x36, 0x36, 0x36, 0x39, 0x61, 0x39, 0x36, 0x63, 0x36, 0x38, 0x65, 0x37, 0x32, 0x30, 0x65, 0x62, 0x32, 0x32, 0x30, 0x36, 0x33, 0x33, 0x36, 0x34, 0x34, 0x37, 0x38, 0x36, 0x30, 0x39, 0x36, 0x36, 0x64, 0x34, 0x66, 0x34, 0x64, 0x65, 0x65, 0x66, 0x33, 0x37, 0x33, 0x37, 0x61, 0x33, 0x33, 0x31, 0x36, 0x32, 0x31, 0x37, 0x33, 0x63, 0x64, 0x39, 0x31, 0x39, 0x64, 0x64, 0x38, 0x32, 0x62, 0x31, 0x32, 0x31, 0x61, 0x32, 0x31, 0x66, 0x35, 0x62, 0x33, 0x63, 0x30, 0x34, 0x66, 0x64, 0x38, 0x63, 0x31, 0x31, 0x30, 0x30, 0x66, 0x34, 0x37, 0x38, 0x31, 0x65, 0x63, 0x32, 0x66, 0x62, 0x33, 0x34, 0x61, 0x66, 0x61, 0x66, 0x37, 0x38, 0x65, 0x62, 0x61, 0x62, 0x63, 0x36, 0x62, 0x33, 0x64, 0x65, 0x31, 0x38, 0x36, 0x31, 0x64, 0x62, 0x36, 0x39, 0x34, 0x62, 0x38, 0x34, 0x38, 0x38, 0x65, 0x61, 0x39, 0x64, 0x38, 0x64, 0x39, 0x61, 0x37, 0x64, 0x34, 0x32, 0x33, 0x37, 0x32, 0x62, 0x32, 0x31, 0x34, 0x61, 0x62, 0x35, 0x36, 0x31, 0x37, 0x65, 0x39, 0x37, 0x64, 0x31, 0x31, 0x63, 0x33, 0x30, 0x37, 0x39, 0x61, 0x36, 0x35, 0x35, 0x64, 0x32, 0x35, 0x61, 0x62, 0x64, 0x32, 0x30, 0x65, 0x33, 0x38, 0x33, 0x39, 0x36, 0x36, 0x61, 0x64, 0x62, 0x31, 0x31, 0x33, 0x32, 0x36, 0x63, 0x31, 0x62, 0x63, 0x61, 0x61, 0x63, 0x31, 0x66, 0x35, 0x38, 0x30, 0x61, 0x36, 0x37, 0x32, 0x34, 0x36, 0x30, 0x38, 0x62, 0x64, 0x64, 0x63, 0x66, 0x37, 0x32, 0x64, 0x36, 0x34, 0x38, 0x37, 0x65, 0x33, 0x64, 0x64, 0x62, 0x34, 0x39, 0x31, 0x63, 0x62, 0x39, 0x39, 0x61, 0x37, 0x62, 0x64, 0x37, 0x33, 0x34, 0x65, 0x38, 0x33, 0x35, 0x62, 0x65, 0x33, 0x33, 0x39, 0x63, 0x33, 0x61, 0x39, 0x64, 0x62, 0x35, 0x36, 0x63, 0x31, 0x39, 0x66, 0x31, 0x36, 0x32, 0x37, 0x35, 0x62, 0x36, 0x63, 0x33, 0x61, 0x38, 0x32, 0x38, 0x37, 0x64, 0x61, 0x37, 0x38, 0x66, 0x39, 0x65, 0x30, 0x37, 0x30, 0x33, 0x31, 0x35, 0x30, 0x62, 0x38, 0x61, 0x31, 0x39, 0x34, 0x64, 0x31, 0x32, 0x39, 0x31, 0x35, 0x36, 0x38, 0x37, 0x61, 0x38, 0x63, 0x62, 0x64, 0x35, 0x32, 0x33, 0x66, 0x66, 0x39, 0x30, 0x66, 0x39, 0x62, 0x30, 0x34, 0x61, 0x30, 0x31, 0x31, 0x35, 0x64, 0x36, 0x62, 0x34, 0x35, 0x37, 0x32, 0x32, 0x36, 0x30, 0x34, 0x64, 0x38, 0x36, 0x37, 0x63, 0x61, 0x63, 0x35, 0x62, 0x65, 0x32, 0x35, 0x35, 0x34, 0x63, 0x62, 0x38, 0x61, 0x38, 0x32, 0x39, 0x33, 0x65, 0x37, 0x65, 0x34, 0x62, 0x38, 0x36, 0x66, 0x38, 0x62, 0x30, 0x38, 0x36, 0x38, 0x39, 0x39, 0x33, 0x61, 0x37, 0x37, 0x64, 0x34, 0x66, 0x63, 0x35, 0x62, 0x31, 0x62, 0x38, 0x38, 0x62, 0x32, 0x34, 0x61, 0x38, 0x35, 0x37, 0x32, 0x38, 0x39, 0x34, 0x30, 0x30, 0x30, 0x33, 0x61, 0x30, 0x31, 0x33, 0x64, 0x30, 0x61, 0x65, 0x39, 0x36, 0x65, 0x61, 0x37, 0x32, 0x66, 0x66, 0x30, 0x34, 0x34, 0x32, 0x37, 0x62, 0x31, 0x64, 0x32, 0x61, 0x64, 0x30, 0x36, 0x30, 0x33, 0x31, 0x36, 0x30, 0x61, 0x31, 0x32, 0x33, 0x39, 0x34, 0x62, 0x31, 0x38, 0x64, 0x62, 0x65, 0x31, 0x30, 0x33, 0x35, 0x63, 0x30, 0x34, 0x31, 0x36, 0x37, 0x32, 0x61, 0x30, 0x30, 0x32, 0x64, 0x36, 0x31, 0x36, 0x30, 0x65, 0x66, 0x35, 0x30, 0x62, 0x65, 0x31, 0x63, 0x30, 0x34, 0x64, 0x34, 0x37, 0x31, 0x65, 0x36, 0x63, 0x39, 0x65, 0x36, 0x61, 0x64, 0x35, 0x36, 0x66, 0x36, 0x39, 0x30, 0x63, 0x34, 0x63, 0x65, 0x34, 0x32, 0x39, 0x64, 0x36, 0x35, 0x31, 0x63, 0x36, 0x32, 0x65, 0x62, 0x30, 0x39, 0x36, 0x66, 0x36, 0x63, 0x61, 0x38, 0x65, 0x33, 0x64, 0x37, 0x38, 0x65, 0x66, 0x36, 0x34, 0x64, 0x30, 0x62, 0x62, 0x31, 0x66, 0x33, 0x36, 0x64, 0x66, 0x62, 0x61, 0x39, 0x63, 0x39, 0x30, 0x38, 0x32, 0x34, 0x32, 0x33, 0x63, 0x38, 0x30, 0x65, 0x33, 0x35, 0x39, 0x39, 0x38, 0x63, 0x37, 0x63, 0x61, 0x38, 0x64, 0x38, 0x34, 0x61, 0x65, 0x62, 0x39, 0x64, 0x31, 0x39, 0x36, 0x62, 0x65, 0x32, 0x37, 0x65, 0x33, 0x63, 0x64, 0x35, 0x37, 0x37, 0x32, 0x37, 0x34, 0x62, 0x37, 0x33, 0x64, 0x39, 0x64, 0x62, 0x62, 0x65, 0x35, 0x32, 0x66, 0x31, 0x31, 0x30, 0x35, 0x62, 0x64, 0x64, 0x30, 0x61, 0x36, 0x66, 0x38, 0x32, 0x34, 0x33, 0x61, 0x38, 0x65, 0x63, 0x35, 0x33, 0x64, 0x61, 0x36, 0x35, 0x38, 0x35, 0x63, 0x63, 0x31, 0x39, 0x35, 0x38, 0x64, 0x34, 0x64, 0x30, 0x66, 0x35, 0x30, 0x62, 0x34, 0x61, 0x37, 0x65, 0x63, 0x36, 0x39, 0x32, 0x38, 0x37, 0x32, 0x31, 0x33, 0x35, 0x61, 0x32, 0x65, 0x39, 0x61, 0x63, 0x62, 0x63, 0x61, 0x36, 0x32, 0x66, 0x66, 0x39, 0x34, 0x33, 0x66, 0x65, 0x64, 0x35, 0x65, 0x32, 0x37, 0x33, 0x34, 0x63, 0x64, 0x30, 0x66, 0x37, 0x62, 0x35, 0x63, 0x39, 0x38, 0x34, 0x30, 0x36, 0x38, 0x64, 0x38, 0x63, 0x37, 0x30, 0x38, 0x39, 0x64, 0x66, 0x34, 0x36, 0x61, 0x32, 0x38, 0x63, 0x63, 0x66, 0x33, 0x37, 0x32, 0x66, 0x33, 0x61, 0x31, 0x37, 0x38, 0x66, 0x34, 0x62, 0x64, 0x62, 0x63, 0x65, 0x35, 0x38, 0x31, 0x33, 0x36, 0x37, 0x35, 0x37, 0x66, 0x35, 0x30, 0x62, 0x33, 0x64, 0x30, 0x64, 0x38, 0x36, 0x65, 0x37, 0x65, 0x63, 0x65, 0x30, 0x63, 0x65, 0x37, 0x64, 0x65, 0x61, 0x39, 0x30, 0x33, 0x62, 0x61, 0x66, 0x31, 0x34, 0x63, 0x38, 0x63, 0x34, 0x37, 0x33, 0x37, 0x65, 0x63, 0x35, 0x30, 0x37, 0x32, 0x31, 0x34, 0x39, 0x34, 0x64, 0x38, 0x36, 0x38, 0x33, 0x36, 0x35, 0x30, 0x33, 0x62, 0x36, 0x38, 0x36, 0x63, 0x66, 0x31, 0x35, 0x32, 0x62, 0x36, 0x33, 0x61, 0x35, 0x31, 0x36, 0x30, 0x62, 0x37, 0x32, 0x33, 0x63, 0x66, 0x35, 0x32, 0x33, 0x30, 0x38, 0x34, 0x61, 0x65, 0x32, 0x37, 0x37, 0x30, 0x38, 0x37, 0x62, 0x33, 0x36, 0x66, 0x34, 0x30, 0x36, 0x37, 0x37, 0x39, 0x32, 0x32, 0x37, 0x32, 0x31, 0x38, 0x65, 0x38, 0x39, 0x34, 0x38, 0x39, 0x32, 0x37, 0x64, 0x35, 0x61, 0x30, 0x34, 0x36, 0x30, 0x39, 0x66, 0x38, 0x32, 0x62, 0x35, 0x34, 0x38, 0x63, 0x30, 0x35, 0x36, 0x33, 0x33, 0x39, 0x63, 0x66, 0x65, 0x35, 0x32, 0x33, 0x35, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x30, 0x64, 0x65, 0x34, 0x30, 0x34, 0x63, 0x63, 0x64, 0x32, 0x65, 0x36, 0x62, 0x63, 0x65, 0x38, 0x61, 0x37, 0x32, 0x36, 0x37, 0x66, 0x64, 0x31, 0x35, 0x38, 0x62, 0x63, 0x63, 0x39, 0x33, 0x39, 0x62, 0x34, 0x30, 0x32, 0x34, 0x66, 0x35, 0x65, 0x33, 0x61, 0x31, 0x63, 0x36, 0x63, 0x30, 0x63, 0x36, 0x30, 0x36, 0x36, 0x62, 0x31, 0x32, 0x36, 0x36, 0x64, 0x64, 0x65, 0x37, 0x36, 0x38, 0x61, 0x33, 0x61, 0x64, 0x64, 0x32, 0x31, 0x36, 0x33, 0x63, 0x64, 0x32, 0x65, 0x36, 0x62, 0x65, 0x64, 0x33, 0x33, 0x32, 0x39, 0x36, 0x34, 0x34, 0x32, 0x63, 0x37, 0x63, 0x37, 0x34, 0x64, 0x65, 0x62, 0x61, 0x36, 0x34, 0x39, 0x34, 0x31, 0x61, 0x36, 0x62, 0x33, 0x64, 0x35, 0x61, 0x61, 0x64, 0x32, 0x66, 0x36, 0x36, 0x65, 0x39, 0x64, 0x37, 0x38, 0x65, 0x34, 0x61, 0x39, 0x63, 0x63, 0x65, 0x63, 0x64, 0x38, 0x30, 0x64, 0x34, 0x64, 0x62, 0x33, 0x35, 0x61, 0x39, 0x39, 0x37, 0x38, 0x34, 0x61, 0x38, 0x37, 0x32, 0x62, 0x30, 0x37, 0x61, 0x33, 0x30, 0x35, 0x65, 0x36, 0x34, 0x63, 0x63, 0x37, 0x61, 0x64, 0x34, 0x39, 0x64, 0x37, 0x62, 0x36, 0x30, 0x66, 0x64, 0x65, 0x62, 0x62, 0x39, 0x62, 0x35, 0x65, 0x30, 0x63, 0x37, 0x64, 0x64, 0x38, 0x30, 0x66, 0x34, 0x65, 0x36, 0x38, 0x65, 0x31, 0x35, 0x39, 0x36, 0x34, 0x62, 0x39, 0x39, 0x38, 0x61, 0x65, 0x65, 0x32, 0x33, 0x33, 0x35, 0x62, 0x65, 0x32, 0x34, 0x62, 0x38, 0x34, 0x61, 0x33, 0x36, 0x35, 0x38, 0x33, 0x62, 0x65, 0x30, 0x33, 0x64, 0x38, 0x61, 0x63, 0x61, 0x65, 0x32, 0x63, 0x35, 0x34, 0x36, 0x66, 0x37, 0x31, 0x32, 0x32, 0x61, 0x30, 0x38, 0x39, 0x36, 0x34, 0x31, 0x65, 0x32, 0x64, 0x33, 0x63, 0x31, 0x31, 0x30, 0x34, 0x62, 0x38, 0x35, 0x39, 0x32, 0x38, 0x36, 0x30, 0x64, 0x65, 0x61, 0x34, 0x33, 0x33, 0x36, 0x62, 0x37, 0x37, 0x32, 0x32, 0x62, 0x64, 0x64, 0x38, 0x32, 0x33, 0x34, 0x32, 0x36, 0x38, 0x33, 0x32, 0x36, 0x61, 0x34, 0x35, 0x34, 0x63, 0x39, 0x61, 0x65, 0x62, 0x66, 0x36, 0x31, 0x38, 0x62, 0x65, 0x64, 0x66, 0x66, 0x39, 0x35, 0x61, 0x34, 0x36, 0x66, 0x36, 0x64, 0x34, 0x30, 0x62, 0x65, 0x31, 0x36, 0x63, 0x32, 0x61, 0x37, 0x34, 0x39, 0x38, 0x32, 0x32, 0x61, 0x35, 0x33, 0x36, 0x34, 0x33, 0x38, 0x37, 0x32, 0x38, 0x64, 0x66, 0x30, 0x30, 0x64, 0x31, 0x30, 0x33, 0x33, 0x32, 0x31, 0x32, 0x33, 0x38, 0x65, 0x62, 0x63, 0x30, 0x30, 0x35, 0x34, 0x32, 0x30, 0x32, 0x61, 0x30, 0x30, 0x33, 0x32, 0x31, 0x36, 0x65, 0x64, 0x66, 0x65, 0x31, 0x34, 0x35, 0x34, 0x63, 0x30, 0x35, 0x39, 0x66, 0x61, 0x62, 0x61, 0x36, 0x31, 0x39, 0x66, 0x65, 0x63, 0x63, 0x32, 0x61, 0x65, 0x64, 0x63, 0x65, 0x66, 0x37, 0x32, 0x37, 0x63, 0x35, 0x30, 0x32, 0x32, 0x32, 0x66, 0x35, 0x33, 0x31, 0x65, 0x61, 0x34, 0x33, 0x37, 0x63, 0x35, 0x30, 0x32, 0x35, 0x65, 0x35, 0x32, 0x36, 0x63, 0x35, 0x64, 0x36, 0x61, 0x30, 0x33, 0x35, 0x36, 0x64, 0x62, 0x62, 0x32, 0x38, 0x36, 0x65, 0x34, 0x39, 0x32, 0x33, 0x61, 0x32, 0x66, 0x39, 0x38, 0x66, 0x31, 0x39, 0x39, 0x31, 0x39, 0x37, 0x35, 0x38, 0x62, 0x64, 0x65, 0x32, 0x33, 0x37, 0x39, 0x35, 0x64, 0x38, 0x33, 0x32, 0x32, 0x39, 0x39, 0x30, 0x64, 0x35, 0x63, 0x65, 0x32, 0x31, 0x37, 0x66, 0x34, 0x39, 0x64, 0x66, 0x62, 0x61, 0x36, 0x39, 0x64, 0x31, 0x32, 0x34, 0x36, 0x33, 0x33, 0x38, 0x65, 0x66, 0x65, 0x64, 0x62, 0x65, 0x30, 0x62, 0x31, 0x63, 0x62, 0x66, 0x31, 0x34, 0x64, 0x35, 0x30, 0x64, 0x62, 0x62, 0x35, 0x35, 0x61, 0x35, 0x64, 0x63, 0x34, 0x34, 0x62, 0x66, 0x34, 0x66, 0x62, 0x33, 0x36, 0x31, 0x34, 0x36, 0x39, 0x30, 0x66, 0x30, 0x64, 0x31, 0x37, 0x34, 0x65, 0x34, 0x33, 0x65, 0x64, 0x37, 0x33, 0x34, 0x63, 0x66, 0x31, 0x65, 0x66, 0x63, 0x61, 0x33, 0x65, 0x32, 0x34, 0x35, 0x63, 0x62, 0x34, 0x31, 0x37, 0x64, 0x36, 0x31, 0x34, 0x35, 0x35, 0x34, 0x34, 0x37, 0x34, 0x37, 0x36, 0x34, 0x33, 0x38, 0x61, 0x36, 0x33, 0x64, 0x66, 0x34, 0x63, 0x36, 0x37, 0x39, 0x33, 0x30, 0x35, 0x32, 0x30, 0x63, 0x32, 0x39, 0x33, 0x66, 0x37, 0x31, 0x63, 0x33, 0x38, 0x31, 0x31, 0x66, 0x66, 0x66, 0x30, 0x66, 0x39, 0x30, 0x37, 0x32, 0x63, 0x35, 0x31, 0x36, 0x38, 0x35, 0x39, 0x30, 0x35, 0x64, 0x38, 0x37, 0x64, 0x38, 0x32, 0x33, 0x37, 0x63, 0x39, 0x64, 0x34, 0x33, 0x31, 0x31, 0x61, 0x61, 0x33, 0x61, 0x61, 0x33, 0x37, 0x39, 0x61, 0x37, 0x32, 0x32, 0x61, 0x65, 0x34, 0x64, 0x61, 0x31, 0x33, 0x32, 0x62, 0x39, 0x35, 0x38, 0x39, 0x31, 0x62, 0x31, 0x65, 0x34, 0x66, 0x34, 0x37, 0x65, 0x36, 0x62, 0x36, 0x31, 0x35, 0x38, 0x63, 0x62, 0x36, 0x32, 0x61, 0x35, 0x38, 0x62, 0x66, 0x30, 0x31, 0x36, 0x63, 0x39, 0x37, 0x63, 0x61, 0x30, 0x66, 0x37, 0x37, 0x30, 0x30, 0x61, 0x66, 0x30, 0x61, 0x61, 0x30, 0x66, 0x36, 0x63, 0x37, 0x37, 0x32, 0x39, 0x62, 0x30, 0x37, 0x34, 0x63, 0x33, 0x36, 0x37, 0x36, 0x62, 0x62, 0x63, 0x37, 0x35, 0x66, 0x63, 0x37, 0x31, 0x62, 0x64, 0x35, 0x32, 0x64, 0x61, 0x37, 0x36, 0x62, 0x31, 0x61, 0x63, 0x30, 0x38, 0x33, 0x34, 0x33, 0x65, 0x66, 0x31, 0x30, 0x66, 0x30, 0x30, 0x31, 0x33, 0x64, 0x64, 0x30, 0x35, 0x35, 0x35, 0x31, 0x65, 0x63, 0x30, 0x64, 0x32, 0x33, 0x32, 0x63, 0x35, 0x30, 0x37, 0x32, 0x62, 0x63, 0x30, 0x37, 0x36, 0x33, 0x31, 0x37, 0x38, 0x63, 0x35, 0x32, 0x34, 0x37, 0x66, 0x65, 0x31, 0x61, 0x61, 0x36, 0x33, 0x64, 0x37, 0x36, 0x34, 0x31, 0x61, 0x31, 0x34, 0x34, 0x33, 0x64, 0x64, 0x30, 0x64, 0x34, 0x66, 0x32, 0x38, 0x61, 0x62, 0x62, 0x64, 0x62, 0x31, 0x34, 0x34, 0x35, 0x36, 0x32, 0x38, 0x66, 0x37, 0x39, 0x31, 0x65, 0x34, 0x33, 0x37, 0x37, 0x32, 0x63, 0x37, 0x32, 0x63, 0x31, 0x30, 0x64, 0x31, 0x35, 0x33, 0x62, 0x36, 0x63, 0x31, 0x62, 0x38, 0x37, 0x32, 0x64, 0x30, 0x37, 0x34, 0x39, 0x37, 0x62, 0x35, 0x31, 0x64, 0x65, 0x30, 0x64, 0x31, 0x63, 0x37, 0x34, 0x35, 0x35, 0x34, 0x33, 0x38, 0x66, 0x61, 0x37, 0x37, 0x63, 0x32, 0x35, 0x34, 0x38, 0x62, 0x35, 0x30, 0x66, 0x31, 0x32, 0x62, 0x37, 0x61, 0x39, 0x62, 0x33, 0x33, 0x39, 0x38, 0x35, 0x35, 0x64, 0x37, 0x63, 0x35, 0x35, 0x63, 0x61, 0x36, 0x39, 0x33, 0x30, 0x34, 0x33, 0x34, 0x65, 0x37, 0x31, 0x35, 0x31, 0x30, 0x62, 0x36, 0x65, 0x33, 0x66, 0x31, 0x37, 0x39, 0x63, 0x62, 0x64, 0x30, 0x36, 0x34, 0x66, 0x65, 0x38, 0x34, 0x34, 0x33, 0x63, 0x65, 0x35, 0x62, 0x62, 0x32, 0x64, 0x31, 0x37, 0x37, 0x33, 0x36, 0x35, 0x39, 0x39, 0x35, 0x64, 0x38, 0x39, 0x61, 0x31, 0x32, 0x61, 0x37, 0x32, 0x33, 0x38, 0x38, 0x62, 0x37, 0x64, 0x33, 0x64, 0x65, 0x65, 0x32, 0x37, 0x66, 0x33, 0x33, 0x63, 0x66, 0x65, 0x34, 0x36, 0x31, 0x37, 0x35, 0x38, 0x32, 0x66, 0x64, 0x63, 0x64, 0x64, 0x34, 0x62, 0x32, 0x65, 0x66, 0x39, 0x64, 0x35, 0x35, 0x38, 0x61, 0x36, 0x31, 0x64, 0x36, 0x35, 0x61, 0x65, 0x34, 0x35, 0x62, 0x35, 0x34, 0x33, 0x66, 0x37, 0x63, 0x36, 0x32, 0x61, 0x65, 0x34, 0x34, 0x64, 0x34, 0x30, 0x61, 0x30, 0x66, 0x62, 0x36, 0x35, 0x32, 0x63, 0x34, 0x39, 0x66, 0x33, 0x63, 0x35, 0x62, 0x66, 0x63, 0x65, 0x32, 0x39, 0x38, 0x34, 0x61, 0x62, 0x33, 0x38, 0x32, 0x30, 0x64, 0x36, 0x34, 0x31, 0x38, 0x37, 0x35, 0x39, 0x31, 0x64, 0x32, 0x66, 0x37, 0x37, 0x62, 0x30, 0x36, 0x65, 0x36, 0x31, 0x64, 0x30, 0x37, 0x31, 0x36, 0x63, 0x65, 0x66, 0x65, 0x61, 0x31, 0x65, 0x37, 0x32, 0x61, 0x30, 0x30, 0x38, 0x64, 0x31, 0x39, 0x33, 0x36, 0x61, 0x37, 0x61, 0x36, 0x63, 0x64, 0x35, 0x37, 0x63, 0x30, 0x66, 0x39, 0x39, 0x61, 0x64, 0x39, 0x32, 0x38, 0x35, 0x38, 0x39, 0x30, 0x30, 0x33, 0x30, 0x36, 0x65, 0x39, 0x39, 0x63, 0x34, 0x63, 0x38, 0x66, 0x31, 0x31, 0x39, 0x33, 0x37, 0x64, 0x34, 0x35, 0x30, 0x63, 0x38, 0x38, 0x36, 0x31, 0x62, 0x62, 0x66, 0x61, 0x64, 0x37, 0x32, 0x64, 0x64, 0x32, 0x61, 0x32, 0x66, 0x64, 0x64, 0x36, 0x38, 0x39, 0x30, 0x66, 0x31, 0x30, 0x38, 0x38, 0x30, 0x35, 0x30, 0x64, 0x33, 0x34, 0x33, 0x38, 0x31, 0x39, 0x39, 0x39, 0x62, 0x38, 0x38, 0x36, 0x66, 0x64, 0x36, 0x66, 0x30, 0x31, 0x64, 0x66, 0x65, 0x64, 0x34, 0x66, 0x33, 0x33, 0x31, 0x65, 0x34, 0x31, 0x30, 0x64, 0x64, 0x38, 0x34, 0x35, 0x63, 0x66, 0x38, 0x61, 0x36, 0x37, 0x32, 0x39, 0x37, 0x31, 0x33, 0x34, 0x36, 0x62, 0x36, 0x39, 0x37, 0x36, 0x66, 0x64, 0x66, 0x65, 0x33, 0x36, 0x62, 0x62, 0x35, 0x65, 0x35, 0x65, 0x39, 0x32, 0x36, 0x36, 0x33, 0x64, 0x39, 0x31, 0x62, 0x35, 0x61, 0x35, 0x61, 0x35, 0x37, 0x64, 0x32, 0x36, 0x39, 0x65, 0x61, 0x66, 0x30, 0x61, 0x64, 0x38, 0x36, 0x62, 0x35, 0x63, 0x66, 0x66, 0x65, 0x62, 0x30, 0x30, 0x31, 0x38, 0x38, 0x30, 0x64, 0x30, 0x38, 0x65, 0x65, 0x38, 0x33, 0x38, 0x36, 0x36, 0x66, 0x65, 0x36, 0x35, 0x31, 0x35, 0x35, 0x34, 0x66, 0x38, 0x64, 0x65, 0x33, 0x38, 0x39, 0x64, 0x37, 0x62, 0x66, 0x66, 0x34, 0x64, 0x64, 0x62, 0x64, 0x37, 0x36, 0x66, 0x63, 0x35, 0x36, 0x31, 0x34, 0x38, 0x39, 0x32, 0x31, 0x36, 0x32, 0x32, 0x33, 0x61, 0x64, 0x35, 0x33, 0x36, 0x64, 0x38, 0x32, 0x65, 0x37, 0x63, 0x61, 0x32, 0x65, 0x31, 0x38, 0x32, 0x36, 0x31, 0x65, 0x62, 0x36, 0x35, 0x39, 0x30, 0x31, 0x33, 0x36, 0x30, 0x32, 0x62, 0x63, 0x34, 0x64, 0x65, 0x34, 0x33, 0x30, 0x34, 0x38, 0x37, 0x65, 0x63, 0x66, 0x39, 0x64, 0x37, 0x37, 0x37, 0x62, 0x64, 0x61, 0x66, 0x32, 0x33, 0x65, 0x65, 0x64, 0x33, 0x64, 0x36, 0x33, 0x34, 0x30, 0x35, 0x62, 0x35, 0x66, 0x34, 0x38, 0x37, 0x35, 0x66, 0x39, 0x36, 0x61, 0x31, 0x64, 0x32, 0x65, 0x31, 0x38, 0x31, 0x31, 0x31, 0x31, 0x33, 0x31, 0x35, 0x62, 0x33, 0x65, 0x30, 0x31, 0x32, 0x36, 0x39, 0x33, 0x66, 0x37, 0x35, 0x37, 0x32, 0x64, 0x35, 0x62, 0x32, 0x35, 0x61, 0x36, 0x65, 0x35, 0x65, 0x63, 0x38, 0x61, 0x66, 0x64, 0x62, 0x63, 0x61, 0x30, 0x32, 0x32, 0x30, 0x35, 0x61, 0x31, 0x64, 0x31, 0x35, 0x37, 0x31, 0x61, 0x66, 0x62, 0x37, 0x61, 0x32, 0x66, 0x37, 0x32, 0x66, 0x61, 0x32, 0x34, 0x62, 0x64, 0x65, 0x39, 0x36, 0x31, 0x36, 0x33, 0x36, 0x35, 0x30, 0x36, 0x39, 0x62, 0x32, 0x33, 0x30, 0x61, 0x37, 0x34, 0x34, 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x63, 0x64, 0x65, 0x31, 0x64, 0x35, 0x63, 0x38, 0x66, 0x36, 0x30, 0x64, 0x30, 0x31, 0x62, 0x36, 0x34, 0x63, 0x37, 0x65, 0x62, 0x31, 0x64, 0x31, 0x31, 0x63, 0x34, 0x36, 0x38, 0x66, 0x30, 0x36, 0x35, 0x63, 0x62, 0x37, 0x30, 0x64, 0x30, 0x37, 0x32, 0x31, 0x33, 0x36, 0x61, 0x64, 0x35, 0x33, 0x34, 0x62, 0x63, 0x31, 0x32, 0x33, 0x66, 0x30, 0x36, 0x39, 0x39, 0x63, 0x33, 0x64, 0x37, 0x64, 0x39, 0x36, 0x63, 0x32, 0x31, 0x38, 0x31, 0x31, 0x32, 0x38, 0x30, 0x62, 0x31, 0x34, 0x64, 0x30, 0x63, 0x36, 0x32, 0x38, 0x63, 0x32, 0x30, 0x64, 0x32, 0x65, 0x38, 0x34, 0x31, 0x34, 0x66, 0x37, 0x32, 0x64, 0x64, 0x65, 0x38, 0x33, 0x39, 0x64, 0x36, 0x66, 0x31, 0x36, 0x61, 0x63, 0x36, 0x66, 0x38, 0x34, 0x62, 0x66, 0x31, 0x61, 0x37, 0x30, 0x32, 0x61, 0x36, 0x63, 0x61, 0x36, 0x66, 0x31, 0x36, 0x35, 0x64, 0x35, 0x31, 0x61, 0x66, 0x64, 0x36, 0x63, 0x36, 0x33, 0x61, 0x62, 0x39, 0x33, 0x34, 0x39, 0x34, 0x37, 0x38, 0x65, 0x63, 0x35, 0x61, 0x34, 0x36, 0x39, 0x61, 0x62, 0x66, 0x37, 0x32, 0x31, 0x66, 0x38, 0x39, 0x62, 0x32, 0x38, 0x64, 0x34, 0x65, 0x32, 0x33, 0x38, 0x35, 0x38, 0x31, 0x65, 0x63, 0x33, 0x61, 0x35, 0x36, 0x66, 0x66, 0x31, 0x34, 0x32, 0x36, 0x39, 0x38, 0x66, 0x36, 0x64, 0x30, 0x64, 0x63, 0x63, 0x37, 0x38, 0x39, 0x36, 0x61, 0x37, 0x37, 0x38, 0x39, 0x37, 0x35, 0x31, 0x63, 0x30, 0x39, 0x37, 0x37, 0x63, 0x30, 0x32, 0x61, 0x31, 0x32, 0x64, 0x62, 0x37, 0x32, 0x32, 0x37, 0x32, 0x35, 0x35, 0x30, 0x35, 0x39, 0x37, 0x35, 0x64, 0x36, 0x65, 0x64, 0x32, 0x63, 0x63, 0x34, 0x61, 0x36, 0x35, 0x32, 0x65, 0x33, 0x39, 0x65, 0x38, 0x62, 0x33, 0x63, 0x61, 0x34, 0x63, 0x63, 0x63, 0x33, 0x64, 0x36, 0x35, 0x65, 0x36, 0x30, 0x35, 0x35, 0x63, 0x32, 0x64, 0x33, 0x32, 0x62, 0x34, 0x31, 0x38, 0x65, 0x65, 0x64, 0x66, 0x61, 0x61, 0x31, 0x37, 0x61, 0x37, 0x32, 0x30, 0x38, 0x32, 0x36, 0x38, 0x30, 0x35, 0x30, 0x33, 0x63, 0x65, 0x38, 0x38, 0x38, 0x38, 0x37, 0x36, 0x65, 0x31, 0x62, 0x64, 0x37, 0x33, 0x63, 0x32, 0x37, 0x34, 0x32, 0x39, 0x63, 0x35, 0x35, 0x61, 0x38, 0x61, 0x37, 0x31, 0x35, 0x62, 0x33, 0x64, 0x36, 0x65, 0x65, 0x33, 0x39, 0x65, 0x64, 0x66, 0x65, 0x65, 0x39, 0x39, 0x38, 0x35, 0x34, 0x63, 0x36, 0x34, 0x34, 0x64, 0x61, 0x33, 0x35, 0x32, 0x62, 0x61, 0x39, 0x34, 0x66, 0x61, 0x65, 0x62, 0x66, 0x61, 0x66, 0x65, 0x33, 0x34, 0x31, 0x32, 0x32, 0x33, 0x36, 0x64, 0x62, 0x63, 0x62, 0x31, 0x65, 0x30, 0x61, 0x66, 0x65, 0x63, 0x34, 0x37, 0x38, 0x30, 0x34, 0x37, 0x66, 0x33, 0x35, 0x63, 0x65, 0x35, 0x30, 0x64, 0x61, 0x36, 0x66, 0x35, 0x63, 0x36, 0x64, 0x37, 0x39, 0x34, 0x66, 0x33, 0x36, 0x63, 0x38, 0x36, 0x66, 0x37, 0x32, 0x39, 0x38, 0x35, 0x35, 0x34, 0x63, 0x31, 0x62, 0x63, 0x35, 0x66, 0x38, 0x37, 0x64, 0x62, 0x31, 0x62, 0x36, 0x63, 0x38, 0x65, 0x64, 0x30, 0x64, 0x65, 0x31, 0x34, 0x65, 0x35, 0x64, 0x64, 0x61, 0x37, 0x63, 0x32, 0x30, 0x30, 0x62, 0x65, 0x66, 0x33, 0x34, 0x35, 0x31, 0x33, 0x65, 0x66, 0x37, 0x37, 0x64, 0x37, 0x39, 0x34, 0x31, 0x34, 0x32, 0x63, 0x34, 0x32, 0x34, 0x32, 0x37, 0x37, 0x32, 0x61, 0x31, 0x34, 0x39, 0x66, 0x39, 0x66, 0x33, 0x34, 0x62, 0x62, 0x61, 0x62, 0x35, 0x65, 0x39, 0x39, 0x38, 0x30, 0x63, 0x33, 0x32, 0x64, 0x34, 0x65, 0x63, 0x38, 0x64, 0x38, 0x65, 0x32, 0x66, 0x30, 0x66, 0x32, 0x32, 0x30, 0x61, 0x33, 0x30, 0x30, 0x64, 0x64, 0x63, 0x31, 0x34, 0x63, 0x65, 0x35, 0x30, 0x61, 0x64, 0x33, 0x33, 0x35, 0x63, 0x38, 0x63, 0x66, 0x35, 0x32, 0x36, 0x35, 0x37, 0x38, 0x61, 0x38, 0x39, 0x30, 0x38, 0x37, 0x62, 0x37, 0x34, 0x62, 0x39, 0x32, 0x31, 0x65, 0x63, 0x62, 0x38, 0x34, 0x63, 0x63, 0x35, 0x63, 0x31, 0x36, 0x63, 0x30, 0x33, 0x35, 0x64, 0x66, 0x62, 0x30, 0x38, 0x34, 0x66, 0x64, 0x33, 0x64, 0x66, 0x34, 0x34, 0x64, 0x62, 0x30, 0x65, 0x64, 0x37, 0x35, 0x34, 0x32, 0x35, 0x31, 0x30, 0x66, 0x38, 0x62, 0x35, 0x36, 0x66, 0x66, 0x39, 0x37, 0x32, 0x38, 0x34, 0x30, 0x38, 0x31, 0x37, 0x38, 0x30, 0x36, 0x37, 0x62, 0x63, 0x37, 0x31, 0x37, 0x61, 0x31, 0x35, 0x37, 0x37, 0x64, 0x61, 0x39, 0x36, 0x31, 0x63, 0x36, 0x66, 0x36, 0x35, 0x38, 0x39, 0x34, 0x33, 0x32, 0x34, 0x31, 0x61, 0x36, 0x39, 0x63, 0x38, 0x32, 0x39, 0x39, 0x62, 0x64, 0x39, 0x38, 0x65, 0x30, 0x38, 0x37, 0x38, 0x33, 0x31, 0x62, 0x36, 0x34, 0x63, 0x61, 0x37, 0x37, 0x32, 0x32, 0x35, 0x64, 0x36, 0x37, 0x62, 0x30, 0x39, 0x61, 0x64, 0x61, 0x34, 0x33, 0x33, 0x37, 0x62, 0x65, 0x35, 0x38, 0x39, 0x31, 0x33, 0x62, 0x63, 0x33, 0x35, 0x31, 0x32, 0x63, 0x35, 0x33, 0x37, 0x64, 0x66, 0x37, 0x32, 0x65, 0x31, 0x66, 0x35, 0x31, 0x34, 0x31, 0x63, 0x34, 0x39, 0x34, 0x33, 0x65, 0x32, 0x62, 0x34, 0x66, 0x63, 0x61, 0x64, 0x32, 0x66, 0x36, 0x31, 0x62, 0x30, 0x37, 0x32, 0x31, 0x66, 0x35, 0x38, 0x65, 0x61, 0x36, 0x32, 0x32, 0x39, 0x62, 0x37, 0x64, 0x31, 0x64, 0x66, 0x39, 0x32, 0x62, 0x65, 0x35, 0x35, 0x36, 0x36, 0x38, 0x62, 0x66, 0x65, 0x33, 0x39, 0x63, 0x65, 0x36, 0x62, 0x31, 0x62, 0x32, 0x36, 0x33, 0x36, 0x65, 0x66, 0x64, 0x63, 0x33, 0x34, 0x30, 0x32, 0x33, 0x32, 0x39, 0x33, 0x32, 0x62, 0x36, 0x38, 0x61, 0x39, 0x61, 0x39, 0x38, 0x63, 0x37, 0x32, 0x62, 0x38, 0x30, 0x33, 0x66, 0x66, 0x35, 0x32, 0x32, 0x33, 0x36, 0x30, 0x39, 0x31, 0x33, 0x64, 0x63, 0x61, 0x36, 0x32, 0x33, 0x39, 0x39, 0x39, 0x64, 0x38, 0x36, 0x30, 0x31, 0x37, 0x31, 0x66, 0x62, 0x33, 0x65, 0x65, 0x34, 0x35, 0x39, 0x34, 0x32, 0x62, 0x32, 0x36, 0x61, 0x34, 0x62, 0x36, 0x61, 0x36, 0x36, 0x33, 0x36, 0x34, 0x66, 0x61, 0x33, 0x35, 0x37, 0x31, 0x65, 0x61, 0x37, 0x32, 0x32, 0x37, 0x38, 0x39, 0x66, 0x31, 0x36, 0x38, 0x37, 0x35, 0x32, 0x37, 0x39, 0x31, 0x35, 0x30, 0x63, 0x32, 0x64, 0x63, 0x33, 0x30, 0x66, 0x65, 0x38, 0x34, 0x64, 0x65, 0x39, 0x34, 0x65, 0x34, 0x32, 0x38, 0x63, 0x34, 0x64, 0x37, 0x64, 0x62, 0x61, 0x36, 0x62, 0x61, 0x39, 0x63, 0x31, 0x66, 0x66, 0x37, 0x61, 0x62, 0x37, 0x62, 0x38, 0x61, 0x33, 0x30, 0x30, 0x66, 0x35, 0x34, 0x31, 0x37, 0x32, 0x66, 0x32, 0x38, 0x33, 0x30, 0x37, 0x35, 0x62, 0x33, 0x66, 0x38, 0x34, 0x61, 0x36, 0x33, 0x32, 0x30, 0x30, 0x61, 0x37, 0x31, 0x36, 0x38, 0x64, 0x35, 0x37, 0x64, 0x33, 0x61, 0x39, 0x34, 0x35, 0x38, 0x66, 0x65, 0x30, 0x36, 0x35, 0x33, 0x38, 0x35, 0x63, 0x66, 0x63, 0x30, 0x61, 0x30, 0x62, 0x33, 0x61, 0x39, 0x64, 0x36, 0x65, 0x37, 0x66, 0x37, 0x65, 0x38, 0x33, 0x62, 0x37, 0x32, 0x38, 0x66, 0x63, 0x36, 0x64, 0x61, 0x36, 0x63, 0x62, 0x66, 0x36, 0x32, 0x66, 0x34, 0x33, 0x65, 0x37, 0x30, 0x30, 0x65, 0x35, 0x38, 0x36, 0x35, 0x62, 0x37, 0x65, 0x66, 0x34, 0x32, 0x30, 0x30, 0x39, 0x63, 0x39, 0x66, 0x65, 0x34, 0x34, 0x64, 0x66, 0x36, 0x32, 0x33, 0x34, 0x31, 0x34, 0x37, 0x35, 0x37, 0x64, 0x34, 0x38, 0x35, 0x32, 0x65, 0x35, 0x64, 0x31, 0x61, 0x61, 0x34, 0x37, 0x32, 0x37, 0x66, 0x37, 0x37, 0x36, 0x36, 0x62, 0x32, 0x36, 0x31, 0x37, 0x35, 0x65, 0x33, 0x31, 0x30, 0x32, 0x39, 0x30, 0x35, 0x33, 0x39, 0x36, 0x64, 0x36, 0x62, 0x30, 0x63, 0x35, 0x65, 0x30, 0x66, 0x31, 0x34, 0x62, 0x31, 0x35, 0x33, 0x35, 0x38, 0x34, 0x30, 0x65, 0x61, 0x63, 0x33, 0x61, 0x63, 0x66, 0x31, 0x36, 0x66, 0x39, 0x63, 0x37, 0x62, 0x65, 0x32, 0x63, 0x31, 0x63, 0x31, 0x32, 0x30, 0x65, 0x30, 0x39, 0x33, 0x33, 0x33, 0x32, 0x33, 0x63, 0x65, 0x36, 0x65, 0x39, 0x63, 0x63, 0x64, 0x30, 0x64, 0x36, 0x66, 0x66, 0x63, 0x32, 0x33, 0x63, 0x30, 0x37, 0x30, 0x37, 0x30, 0x34, 0x66, 0x38, 0x39, 0x65, 0x37, 0x37, 0x61, 0x36, 0x63, 0x61, 0x37, 0x35, 0x33, 0x65, 0x39, 0x37, 0x37, 0x32, 0x39, 0x63, 0x65, 0x65, 0x31, 0x35, 0x33, 0x32, 0x31, 0x35, 0x61, 0x65, 0x62, 0x37, 0x32, 0x66, 0x35, 0x36, 0x37, 0x32, 0x62, 0x37, 0x38, 0x32, 0x31, 0x35, 0x33, 0x39, 0x63, 0x33, 0x38, 0x33, 0x33, 0x39, 0x62, 0x34, 0x61, 0x34, 0x66, 0x62, 0x65, 0x66, 0x39, 0x66, 0x33, 0x32, 0x30, 0x63, 0x64, 0x39, 0x36, 0x64, 0x39, 0x33, 0x34, 0x66, 0x64, 0x64, 0x31, 0x61, 0x63, 0x33, 0x33, 0x38, 0x33, 0x38, 0x64, 0x35, 0x61, 0x63, 0x37, 0x36, 0x64, 0x61, 0x30, 0x35, 0x37, 0x33, 0x37, 0x33, 0x34, 0x37, 0x31, 0x64, 0x62, 0x34, 0x39, 0x31, 0x37, 0x32, 0x39, 0x65, 0x34, 0x66, 0x64, 0x37, 0x62, 0x38, 0x39, 0x37, 0x36, 0x34, 0x36, 0x38, 0x66, 0x35, 0x35, 0x30, 0x62, 0x30, 0x62, 0x37, 0x37, 0x39, 0x31, 0x63, 0x30, 0x35, 0x38, 0x65, 0x34, 0x37, 0x34, 0x35, 0x66, 0x33, 0x64, 0x39, 0x64, 0x61, 0x33, 0x64, 0x36, 0x66, 0x37, 0x31, 0x34, 0x65, 0x39, 0x31, 0x66, 0x37, 0x32, 0x35, 0x30, 0x63, 0x66, 0x61, 0x66, 0x35, 0x32, 0x39, 0x34, 0x61, 0x63, 0x63, 0x66, 0x37, 0x33, 0x37, 0x63, 0x62, 0x33, 0x65, 0x34, 0x36, 0x65, 0x64, 0x32, 0x61, 0x33, 0x32, 0x64, 0x30, 0x61, 0x66, 0x66, 0x34, 0x66, 0x62, 0x32, 0x35, 0x31, 0x62, 0x61, 0x33, 0x31, 0x36, 0x61, 0x33, 0x30, 0x65, 0x32, 0x63, 0x65, 0x36, 0x61, 0x62, 0x38, 0x30, 0x39, 0x37, 0x66, 0x31, 0x39, 0x37, 0x32, 0x31, 0x63, 0x39, 0x35, 0x62, 0x35, 0x37, 0x30, 0x37, 0x62, 0x64, 0x32, 0x36, 0x37, 0x33, 0x64, 0x30, 0x32, 0x62, 0x30, 0x31, 0x38, 0x34, 0x31, 0x66, 0x33, 0x36, 0x32, 0x34, 0x61, 0x33, 0x39, 0x34, 0x33, 0x32, 0x61, 0x66, 0x33, 0x62, 0x38, 0x33, 0x30, 0x31, 0x66, 0x37, 0x37, 0x35, 0x36, 0x65, 0x37, 0x35, 0x63, 0x36, 0x32, 0x64, 0x66, 0x63, 0x32, 0x33, 0x38, 0x32, 0x61, 0x32, 0x63, 0x33, 0x31, 0x39, 0x31, 0x35, 0x61, 0x33, 0x63, 0x30, 0x39, 0x64, 0x65, 0x34, 0x31, 0x35, 0x34, 0x63, 0x64, 0x61, 0x32, 0x61, 0x62, 0x32, 0x36, 0x65, 0x31, 0x34, 0x31, 0x39, 0x62, 0x37, 0x66, 0x39, 0x33, 0x36, 0x33, 0x61, 0x39, 0x38, 0x66, 0x64, 0x36, 0x37, 0x36, 0x34, 0x61, 0x30, 0x38, 0x33, 0x36, 0x66, 0x39, 0x61, 0x64, 0x39, 0x36, 0x64, 0x66, 0x61, 0x36, 0x39, 0x32, 0x37, 0x32, 0x62, 0x32, 0x35, 0x37, 0x34, 0x65, 0x66, 0x34, 0x31, 0x64, 0x31, 0x39, 0x33, 0x35, 0x31, 0x63, 0x35, 0x37, 0x32, 0x35, 0x31, 0x36, 0x35, 0x62, 0x37, 0x30, 0x64, 0x36, 0x64, 0x37, 0x64, 0x66, 0x63, 0x63, 0x32, 0x38, 0x38, 0x32, 0x39, 0x39, 0x33, 0x31, 0x34, 0x33, 0x66, 0x36, 0x61, 0x31, 0x34, 0x66, 0x30, 0x65, 0x34, 0x36, 0x30, 0x36, 0x30, 0x36, 0x35, 0x61, 0x33, 0x32, 0x33, 0x34, 0x39, 0x32, 0x33, 0x61, 0x33, 0x65, 0x37, 0x36, 0x34, 0x34, 0x33, 0x37, 0x36, 0x38, 0x62, 0x65, 0x37, 0x38, 0x63, 0x39, 0x39, 0x35, 0x37, 0x65, 0x31, 0x63, 0x66, 0x37, 0x65, 0x62, 0x63, 0x38, 0x64, 0x37, 0x36, 0x38, 0x31, 0x62, 0x35, 0x64, 0x37, 0x37, 0x34, 0x33, 0x62, 0x33, 0x34, 0x38, 0x34, 0x33, 0x32, 0x64, 0x61, 0x62, 0x34, 0x61, 0x33, 0x37, 0x63, 0x36, 0x36, 0x34, 0x37, 0x32, 0x63, 0x38, 0x61, 0x65, 0x65, 0x64, 0x66, 0x37, 0x37, 0x37, 0x63, 0x36, 0x62, 0x33, 0x31, 0x63, 0x61, 0x36, 0x66, 0x64, 0x65, 0x39, 0x32, 0x39, 0x63, 0x36, 0x34, 0x35, 0x61, 0x65, 0x30, 0x64, 0x33, 0x37, 0x30, 0x34, 0x36, 0x39, 0x31, 0x62, 0x33, 0x64, 0x65, 0x34, 0x39, 0x34, 0x63, 0x61, 0x33, 0x65, 0x38, 0x34, 0x35, 0x39, 0x31, 0x33, 0x37, 0x30, 0x31, 0x61, 0x37, 0x36, 0x37, 0x32, 0x35, 0x34, 0x32, 0x30, 0x30, 0x66, 0x33, 0x66, 0x65, 0x66, 0x38, 0x38, 0x31, 0x37, 0x30, 0x61, 0x38, 0x35, 0x31, 0x31, 0x66, 0x62, 0x36, 0x64, 0x36, 0x39, 0x31, 0x61, 0x34, 0x64, 0x37, 0x30, 0x37, 0x33, 0x61, 0x32, 0x65, 0x65, 0x37, 0x35, 0x33, 0x64, 0x36, 0x61, 0x66, 0x62, 0x33, 0x64, 0x63, 0x66, 0x33, 0x65, 0x31, 0x62, 0x63, 0x64, 0x35, 0x36, 0x37, 0x39, 0x61, 0x63, 0x30, 0x31, 0x61, 0x38, 0x61, 0x63, 0x64, 0x39, 0x61, 0x30, 0x63, 0x39, 0x62, 0x63, 0x61, 0x38, 0x37, 0x32, 0x30, 0x34, 0x62, 0x63, 0x37, 0x32, 0x66, 0x33, 0x39, 0x38, 0x64, 0x36, 0x66, 0x37, 0x61, 0x30, 0x61, 0x33, 0x62, 0x66, 0x39, 0x33, 0x38, 0x64, 0x63, 0x33, 0x33, 0x63, 0x34, 0x31, 0x33, 0x66, 0x33, 0x33, 0x63, 0x64, 0x37, 0x30, 0x39, 0x39, 0x38, 0x38, 0x61, 0x65, 0x65, 0x65, 0x33, 0x36, 0x39, 0x64, 0x37, 0x61, 0x32, 0x38, 0x32, 0x30, 0x63, 0x31, 0x34, 0x66, 0x30, 0x63, 0x38, 0x37, 0x37, 0x37, 0x37, 0x62, 0x38, 0x64, 0x35, 0x32, 0x63, 0x61, 0x33, 0x34, 0x38, 0x35, 0x66, 0x61, 0x38, 0x65, 0x35, 0x63, 0x32, 0x35, 0x63, 0x39, 0x62, 0x61, 0x30, 0x39, 0x64, 0x37, 0x62, 0x34, 0x33, 0x31, 0x38, 0x34, 0x66, 0x61, 0x38, 0x63, 0x61, 0x65, 0x33, 0x31, 0x31, 0x34, 0x37, 0x32, 0x39, 0x64, 0x39, 0x31, 0x37, 0x62, 0x66, 0x30, 0x30, 0x33, 0x63, 0x38, 0x34, 0x66, 0x33, 0x62, 0x31, 0x61, 0x35, 0x66, 0x31, 0x34, 0x36, 0x66, 0x31, 0x30, 0x37, 0x30, 0x64, 0x36, 0x66, 0x31, 0x34, 0x36, 0x30, 0x62, 0x66, 0x64, 0x66, 0x31, 0x65, 0x31, 0x65, 0x62, 0x30, 0x38, 0x34, 0x32, 0x31, 0x35, 0x64, 0x32, 0x36, 0x38, 0x61, 0x35, 0x61, 0x62, 0x35, 0x66, 0x30, 0x32, 0x37, 0x32, 0x37, 0x38, 0x66, 0x66, 0x65, 0x63, 0x33, 0x38, 0x65, 0x35, 0x65, 0x37, 0x31, 0x61, 0x34, 0x35, 0x38, 0x35, 0x30, 0x65, 0x35, 0x35, 0x33, 0x64, 0x61, 0x32, 0x30, 0x37, 0x36, 0x64, 0x31, 0x61, 0x30, 0x66, 0x39, 0x66, 0x31, 0x39, 0x34, 0x38, 0x33, 0x62, 0x34, 0x39, 0x30, 0x64, 0x33, 0x65, 0x64, 0x61, 0x38, 0x30, 0x33, 0x64, 0x61, 0x61, 0x36, 0x30, 0x30, 0x33, 0x39, 0x34, 0x37, 0x32, 0x62, 0x31, 0x62, 0x37, 0x38, 0x61, 0x64, 0x65, 0x32, 0x65, 0x65, 0x64, 0x66, 0x37, 0x30, 0x38, 0x38, 0x36, 0x35, 0x34, 0x61, 0x65, 0x37, 0x33, 0x32, 0x62, 0x61, 0x39, 0x35, 0x38, 0x64, 0x66, 0x66, 0x30, 0x36, 0x38, 0x31, 0x62, 0x30, 0x34, 0x36, 0x61, 0x38, 0x36, 0x36, 0x35, 0x32, 0x65, 0x30, 0x30, 0x31, 0x30, 0x30, 0x62, 0x64, 0x61, 0x31, 0x63, 0x64, 0x37, 0x62, 0x30, 0x30, 0x38, 0x62, 0x35, 0x61, 0x65, 0x36, 0x66, 0x34, 0x39, 0x33, 0x35, 0x62, 0x36, 0x37, 0x39, 0x37, 0x64, 0x38, 0x37, 0x30, 0x63, 0x35, 0x30, 0x37, 0x38, 0x39, 0x32, 0x39, 0x37, 0x31, 0x31, 0x34, 0x65, 0x36, 0x62, 0x38, 0x35, 0x33, 0x37, 0x36, 0x30, 0x66, 0x36, 0x33, 0x36, 0x30, 0x33, 0x31, 0x31, 0x33, 0x64, 0x33, 0x61, 0x37, 0x31, 0x61, 0x62, 0x62, 0x39, 0x66, 0x38, 0x34, 0x37, 0x37, 0x32, 0x32, 0x39, 0x37, 0x31, 0x35, 0x66, 0x34, 0x39, 0x66, 0x37, 0x62, 0x35, 0x62, 0x34, 0x37, 0x31, 0x61, 0x38, 0x62, 0x66, 0x32, 0x65, 0x66, 0x32, 0x37, 0x61, 0x65, 0x62, 0x35, 0x32, 0x61, 0x37, 0x35, 0x32, 0x64, 0x34, 0x31, 0x31, 0x33, 0x38, 0x37, 0x39, 0x30, 0x37, 0x35, 0x37, 0x34, 0x36, 0x33, 0x31, 0x61, 0x38, 0x33, 0x31, 0x36, 0x33, 0x35, 0x63, 0x62, 0x32, 0x39, 0x66, 0x37, 0x32, 0x36, 0x33, 0x64, 0x37, 0x63, 0x37, 0x66, 0x30, 0x61, 0x33, 0x63, 0x33, 0x31, 0x64, 0x66, 0x33, 0x38, 0x33, 0x33, 0x35, 0x66, 0x38, 0x34, 0x33, 0x35, 0x65, 0x30, 0x36, 0x35, 0x62, 0x62, 0x63, 0x34, 0x63, 0x63, 0x62, 0x32, 0x38, 0x32, 0x31, 0x64, 0x35, 0x31, 0x33, 0x33, 0x30, 0x37, 0x36, 0x33, 0x38, 0x63, 0x30, 0x32, 0x32, 0x63, 0x38, 0x66, 0x32, 0x36, 0x62, 0x34, 0x30, 0x36, 0x64, 0x33, 0x64, 0x37, 0x34, 0x32, 0x61, 0x30, 0x38, 0x31, 0x66, 0x35, 0x30, 0x37, 0x35, 0x33, 0x30, 0x30, 0x61, 0x31, 0x39, 0x37, 0x36, 0x66, 0x62, 0x31, 0x63, 0x66, 0x63, 0x63, 0x34, 0x65, 0x61, 0x38, 0x61, 0x66, 0x31, 0x35, 0x37, 0x30, 0x65, 0x66, 0x33, 0x39, 0x63, 0x30, 0x63, 0x37, 0x66, 0x62, 0x39, 0x38, 0x35, 0x66, 0x39, 0x64, 0x65, 0x64, 0x32, 0x64, 0x37, 0x66, 0x32, 0x37, 0x32, 0x33, 0x34, 0x34, 0x36, 0x61, 0x66, 0x38, 0x63, 0x66, 0x62, 0x63, 0x36, 0x61, 0x32, 0x63, 0x32, 0x61, 0x31, 0x32, 0x35, 0x32, 0x37, 0x31, 0x30, 0x35, 0x33, 0x32, 0x38, 0x33, 0x38, 0x66, 0x37, 0x30, 0x62, 0x36, 0x37, 0x61, 0x35, 0x62, 0x33, 0x35, 0x34, 0x34, 0x33, 0x61, 0x37, 0x38, 0x39, 0x31, 0x62, 0x30, 0x32, 0x62, 0x34, 0x31, 0x35, 0x39, 0x63, 0x36, 0x39, 0x65, 0x32, 0x37, 0x32, 0x61, 0x64, 0x34, 0x66, 0x35, 0x34, 0x39, 0x32, 0x37, 0x38, 0x66, 0x61, 0x31, 0x63, 0x65, 0x35, 0x62, 0x39, 0x33, 0x30, 0x39, 0x33, 0x65, 0x64, 0x39, 0x37, 0x33, 0x36, 0x39, 0x33, 0x65, 0x33, 0x31, 0x35, 0x66, 0x63, 0x36, 0x34, 0x63, 0x62, 0x66, 0x62, 0x66, 0x66, 0x66, 0x35, 0x66, 0x66, 0x65, 0x32, 0x32, 0x66, 0x36, 0x31, 0x37, 0x37, 0x33, 0x33, 0x65, 0x35, 0x66, 0x65, 0x36, 0x66, 0x32, 0x30, 0x30, 0x65, 0x37, 0x34, 0x63, 0x61, 0x30, 0x37, 0x35, 0x39, 0x62, 0x64, 0x31, 0x38, 0x32, 0x38, 0x63, 0x66, 0x32, 0x34, 0x31, 0x35, 0x66, 0x38, 0x65, 0x34, 0x34, 0x64, 0x64, 0x65, 0x62, 0x61, 0x33, 0x30, 0x32, 0x66, 0x39, 0x35, 0x32, 0x35, 0x65, 0x66, 0x34, 0x32, 0x37, 0x65, 0x65, 0x64, 0x66, 0x64, 0x36, 0x61, 0x30, 0x39, 0x66, 0x39, 0x36, 0x32, 0x61, 0x32, 0x35, 0x37, 0x37, 0x66, 0x32, 0x38, 0x64, 0x36, 0x37, 0x32, 0x61, 0x34, 0x62, 0x34, 0x64, 0x34, 0x32, 0x31, 0x62, 0x32, 0x66, 0x63, 0x37, 0x64, 0x65, 0x33, 0x36, 0x61, 0x37, 0x66, 0x32, 0x64, 0x63, 0x61, 0x37, 0x37, 0x63, 0x35, 0x62, 0x32, 0x64, 0x39, 0x65, 0x32, 0x39, 0x66, 0x37, 0x31, 0x66, 0x62, 0x66, 0x30, 0x32, 0x32, 0x64, 0x38, 0x32, 0x62, 0x36, 0x64, 0x30, 0x65, 0x61, 0x63, 0x33, 0x33, 0x61, 0x63, 0x33, 0x30, 0x32, 0x34, 0x35, 0x64, 0x37, 0x65, 0x63, 0x32, 0x31, 0x38, 0x62, 0x63, 0x34, 0x32, 0x32, 0x30, 0x30, 0x31, 0x31, 0x32, 0x65, 0x30, 0x62, 0x38, 0x37, 0x39, 0x34, 0x39, 0x39, 0x35, 0x37, 0x33, 0x64, 0x31, 0x32, 0x64, 0x34, 0x65, 0x30, 0x35, 0x61, 0x66, 0x38, 0x61, 0x39, 0x39, 0x35, 0x39, 0x61, 0x33, 0x32, 0x62, 0x65, 0x30, 0x38, 0x31, 0x37, 0x66, 0x37, 0x32, 0x61, 0x62, 0x33, 0x64, 0x35, 0x66, 0x39, 0x38, 0x36, 0x61, 0x31, 0x39, 0x33, 0x37, 0x33, 0x62, 0x30, 0x35, 0x63, 0x65, 0x31, 0x39, 0x32, 0x35, 0x33, 0x65, 0x62, 0x35, 0x61, 0x65, 0x65, 0x63, 0x34, 0x37, 0x33, 0x62, 0x39, 0x32, 0x34, 0x31, 0x62, 0x32, 0x61, 0x36, 0x36, 0x32, 0x61, 0x31, 0x34, 0x62, 0x39, 0x63, 0x35, 0x39, 0x66, 0x38, 0x61, 0x66, 0x30, 0x30, 0x37, 0x61, 0x35, 0x62, 0x37, 0x33, 0x31, 0x33, 0x37, 0x39, 0x33, 0x61, 0x37, 0x33, 0x35, 0x37, 0x33, 0x34, 0x62, 0x30, 0x38, 0x33, 0x30, 0x65, 0x65, 0x31, 0x31, 0x36, 0x61, 0x33, 0x32, 0x37, 0x62, 0x62, 0x34, 0x62, 0x65, 0x34, 0x32, 0x31, 0x36, 0x39, 0x61, 0x64, 0x36, 0x36, 0x62, 0x65, 0x39, 0x66, 0x35, 0x64, 0x37, 0x37, 0x39, 0x32, 0x34, 0x63, 0x65, 0x64, 0x33, 0x35, 0x62, 0x65, 0x31, 0x36, 0x37, 0x32, 0x31, 0x65, 0x35, 0x31, 0x32, 0x34, 0x65, 0x62, 0x65, 0x66, 0x66, 0x66, 0x35, 0x66, 0x39, 0x34, 0x62, 0x32, 0x37, 0x38, 0x36, 0x64, 0x31, 0x65, 0x63, 0x37, 0x38, 0x32, 0x32, 0x65, 0x31, 0x39, 0x65, 0x38, 0x31, 0x36, 0x34, 0x35, 0x30, 0x64, 0x61, 0x35, 0x33, 0x63, 0x62, 0x37, 0x30, 0x34, 0x62, 0x38, 0x39, 0x66, 0x61, 0x37, 0x33, 0x37, 0x30, 0x35, 0x63, 0x33, 0x32, 0x31, 0x35, 0x35, 0x31, 0x37, 0x36, 0x31, 0x33, 0x37, 0x65, 0x36, 0x35, 0x39, 0x30, 0x36, 0x64, 0x33, 0x36, 0x31, 0x61, 0x38, 0x61, 0x64, 0x30, 0x34, 0x39, 0x65, 0x33, 0x34, 0x39, 0x36, 0x63, 0x64, 0x39, 0x64, 0x63, 0x66, 0x39, 0x35, 0x63, 0x38, 0x39, 0x61, 0x62, 0x34, 0x61, 0x62, 0x38, 0x30, 0x66, 0x31, 0x62, 0x61, 0x32, 0x34, 0x37, 0x31, 0x31, 0x61, 0x63, 0x34, 0x31, 0x35, 0x62, 0x66, 0x37, 0x32, 0x34, 0x62, 0x37, 0x33, 0x33, 0x33, 0x31, 0x36, 0x33, 0x31, 0x36, 0x63, 0x63, 0x30, 0x30, 0x30, 0x39, 0x63, 0x38, 0x62, 0x38, 0x33, 0x37, 0x38, 0x64, 0x62, 0x37, 0x30, 0x30, 0x65, 0x31, 0x35, 0x37, 0x30, 0x30, 0x37, 0x34, 0x30, 0x36, 0x38, 0x37, 0x31, 0x62, 0x34, 0x30, 0x66, 0x65, 0x64, 0x37, 0x31, 0x36, 0x34, 0x31, 0x62, 0x38, 0x65, 0x34, 0x65, 0x33, 0x64, 0x63, 0x32, 0x37, 0x32, 0x39, 0x35, 0x35, 0x32, 0x37, 0x30, 0x36, 0x64, 0x39, 0x61, 0x61, 0x34, 0x30, 0x35, 0x65, 0x65, 0x34, 0x66, 0x32, 0x37, 0x65, 0x66, 0x31, 0x30, 0x63, 0x30, 0x30, 0x66, 0x35, 0x34, 0x63, 0x63, 0x66, 0x62, 0x34, 0x65, 0x33, 0x61, 0x30, 0x36, 0x66, 0x63, 0x37, 0x31, 0x66, 0x39, 0x30, 0x32, 0x34, 0x34, 0x35, 0x38, 0x37, 0x65, 0x66, 0x61, 0x36, 0x63, 0x37, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x31, 0x34, 0x31, 0x30, 0x63, 0x39, 0x62, 0x62, 0x34, 0x61, 0x65, 0x38, 0x38, 0x36, 0x39, 0x65, 0x35, 0x37, 0x64, 0x31, 0x33, 0x39, 0x65, 0x30, 0x35, 0x32, 0x30, 0x32, 0x36, 0x64, 0x66, 0x36, 0x66, 0x33, 0x66, 0x33, 0x34, 0x61, 0x35, 0x35, 0x32, 0x38, 0x32, 0x37, 0x39, 0x66, 0x62, 0x35, 0x39, 0x62, 0x39, 0x63, 0x33, 0x31, 0x39, 0x38, 0x32, 0x66, 0x64, 0x37, 0x33, 0x37, 0x32, 0x30, 0x33, 0x61, 0x63, 0x37, 0x34, 0x32, 0x61, 0x36, 0x31, 0x64, 0x34, 0x36, 0x33, 0x38, 0x31, 0x39, 0x64, 0x65, 0x64, 0x62, 0x63, 0x35, 0x36, 0x62, 0x36, 0x62, 0x63, 0x33, 0x64, 0x36, 0x35, 0x63, 0x34, 0x35, 0x37, 0x31, 0x65, 0x38, 0x36, 0x61, 0x61, 0x35, 0x64, 0x37, 0x35, 0x37, 0x63, 0x33, 0x37, 0x34, 0x61, 0x33, 0x39, 0x39, 0x66, 0x33, 0x61, 0x38, 0x30, 0x33, 0x30, 0x35, 0x63, 0x63, 0x63, 0x31, 0x31, 0x32, 0x62, 0x62, 0x34, 0x64, 0x30, 0x31, 0x66, 0x39, 0x31, 0x35, 0x37, 0x37, 0x30, 0x62, 0x39, 0x61, 0x35, 0x36, 0x66, 0x39, 0x63, 0x65, 0x38, 0x38, 0x33, 0x63, 0x62, 0x33, 0x64, 0x34, 0x38, 0x64, 0x30, 0x38, 0x35, 0x65, 0x31, 0x64, 0x62, 0x36, 0x61, 0x37, 0x34, 0x66, 0x62, 0x36, 0x66, 0x63, 0x32, 0x33, 0x30, 0x64, 0x64, 0x32, 0x32, 0x33, 0x65, 0x37, 0x32, 0x36, 0x31, 0x35, 0x63, 0x66, 0x66, 0x37, 0x63, 0x33, 0x32, 0x63, 0x32, 0x63, 0x37, 0x30, 0x33, 0x61, 0x64, 0x61, 0x66, 0x64, 0x35, 0x39, 0x63, 0x63, 0x61, 0x32, 0x37, 0x31, 0x61, 0x66, 0x61, 0x35, 0x36, 0x34, 0x33, 0x38, 0x63, 0x62, 0x37, 0x31, 0x30, 0x64, 0x31, 0x39, 0x38, 0x63, 0x61, 0x35, 0x38, 0x37, 0x33, 0x38, 0x61, 0x33, 0x34, 0x36, 0x61, 0x39, 0x36, 0x66, 0x31, 0x37, 0x32, 0x32, 0x66, 0x33, 0x32, 0x65, 0x33, 0x36, 0x33, 0x61, 0x37, 0x65, 0x34, 0x31, 0x62, 0x32, 0x32, 0x38, 0x35, 0x34, 0x32, 0x34, 0x66, 0x37, 0x31, 0x37, 0x39, 0x36, 0x38, 0x31, 0x31, 0x36, 0x64, 0x36, 0x65, 0x38, 0x38, 0x31, 0x34, 0x34, 0x35, 0x32, 0x30, 0x39, 0x34, 0x39, 0x38, 0x62, 0x31, 0x39, 0x64, 0x62, 0x39, 0x62, 0x39, 0x36, 0x30, 0x63, 0x32, 0x37, 0x34, 0x64, 0x36, 0x30, 0x62, 0x38, 0x64, 0x34, 0x65, 0x33, 0x61, 0x61, 0x36, 0x34, 0x63, 0x65, 0x63, 0x38, 0x30, 0x30, 0x32, 0x33, 0x61, 0x64, 0x66, 0x35, 0x35, 0x32, 0x34, 0x66, 0x62, 0x63, 0x62, 0x66, 0x33, 0x35, 0x61, 0x62, 0x36, 0x34, 0x38, 0x36, 0x31, 0x34, 0x38, 0x64, 0x61, 0x66, 0x66, 0x65, 0x64, 0x66, 0x65, 0x62, 0x36, 0x36, 0x64, 0x30, 0x35, 0x35, 0x62, 0x30, 0x64, 0x34, 0x34, 0x35, 0x34, 0x31, 0x35, 0x35, 0x36, 0x64, 0x62, 0x38, 0x39, 0x62, 0x37, 0x35, 0x36, 0x39, 0x61, 0x34, 0x31, 0x61, 0x63, 0x63, 0x36, 0x65, 0x30, 0x62, 0x38, 0x30, 0x35, 0x63, 0x31, 0x35, 0x61, 0x61, 0x34, 0x34, 0x64, 0x64, 0x65, 0x61, 0x37, 0x65, 0x31, 0x39, 0x65, 0x62, 0x30, 0x65, 0x65, 0x62, 0x63, 0x65, 0x35, 0x39, 0x64, 0x61, 0x39, 0x65, 0x38, 0x36, 0x65, 0x62, 0x31, 0x31, 0x61, 0x65, 0x34, 0x37, 0x32, 0x62, 0x34, 0x66, 0x35, 0x39, 0x32, 0x64, 0x64, 0x30, 0x32, 0x37, 0x65, 0x63, 0x34, 0x35, 0x31, 0x64, 0x34, 0x61, 0x37, 0x32, 0x62, 0x34, 0x35, 0x32, 0x36, 0x61, 0x35, 0x31, 0x36, 0x38, 0x31, 0x33, 0x63, 0x35, 0x39, 0x64, 0x64, 0x37, 0x61, 0x61, 0x38, 0x37, 0x33, 0x39, 0x36, 0x38, 0x31, 0x64, 0x34, 0x63, 0x37, 0x39, 0x31, 0x64, 0x37, 0x32, 0x35, 0x39, 0x36, 0x35, 0x30, 0x37, 0x32, 0x66, 0x64, 0x32, 0x32, 0x35, 0x36, 0x31, 0x36, 0x61, 0x39, 0x61, 0x30, 0x66, 0x33, 0x63, 0x30, 0x65, 0x31, 0x39, 0x35, 0x36, 0x38, 0x38, 0x30, 0x33, 0x36, 0x32, 0x64, 0x62, 0x66, 0x34, 0x33, 0x64, 0x39, 0x32, 0x62, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x34, 0x31, 0x37, 0x61, 0x33, 0x37, 0x35, 0x37, 0x66, 0x66, 0x61, 0x66, 0x64, 0x61, 0x32, 0x65, 0x65, 0x30, 0x61, 0x35, 0x37, 0x32, 0x39, 0x66, 0x65, 0x62, 0x35, 0x63, 0x65, 0x33, 0x63, 0x35, 0x61, 0x33, 0x63, 0x62, 0x31, 0x38, 0x36, 0x62, 0x31, 0x35, 0x35, 0x38, 0x35, 0x33, 0x31, 0x32, 0x63, 0x34, 0x30, 0x63, 0x65, 0x65, 0x37, 0x62, 0x36, 0x63, 0x31, 0x66, 0x61, 0x34, 0x32, 0x32, 0x65, 0x32, 0x62, 0x66, 0x62, 0x37, 0x34, 0x30, 0x38, 0x38, 0x30, 0x36, 0x32, 0x37, 0x30, 0x35, 0x38, 0x32, 0x35, 0x34, 0x37, 0x32, 0x62, 0x31, 0x66, 0x30, 0x61, 0x62, 0x33, 0x33, 0x65, 0x37, 0x66, 0x30, 0x63, 0x32, 0x35, 0x65, 0x66, 0x65, 0x30, 0x64, 0x61, 0x66, 0x36, 0x34, 0x39, 0x38, 0x61, 0x64, 0x64, 0x63, 0x65, 0x36, 0x66, 0x30, 0x66, 0x30, 0x63, 0x61, 0x36, 0x37, 0x31, 0x61, 0x33, 0x31, 0x66, 0x32, 0x66, 0x39, 0x39, 0x36, 0x36, 0x37, 0x32, 0x65, 0x64, 0x31, 0x61, 0x36, 0x33, 0x62, 0x37, 0x64, 0x37, 0x32, 0x32, 0x38, 0x32, 0x66, 0x30, 0x31, 0x65, 0x38, 0x65, 0x39, 0x38, 0x39, 0x39, 0x35, 0x35, 0x31, 0x39, 0x34, 0x32, 0x61, 0x62, 0x30, 0x30, 0x35, 0x64, 0x35, 0x30, 0x32, 0x64, 0x39, 0x33, 0x66, 0x37, 0x64, 0x62, 0x34, 0x31, 0x32, 0x37, 0x65, 0x66, 0x65, 0x38, 0x64, 0x39, 0x63, 0x39, 0x65, 0x64, 0x35, 0x61, 0x39, 0x61, 0x38, 0x38, 0x33, 0x32, 0x37, 0x39, 0x36, 0x62, 0x34, 0x37, 0x32, 0x36, 0x39, 0x38, 0x38, 0x31, 0x66, 0x34, 0x37, 0x35, 0x38, 0x63, 0x33, 0x34, 0x32, 0x32, 0x32, 0x64, 0x32, 0x64, 0x38, 0x63, 0x38, 0x64, 0x65, 0x30, 0x39, 0x34, 0x38, 0x61, 0x32, 0x34, 0x63, 0x38, 0x61, 0x65, 0x38, 0x64, 0x61, 0x66, 0x31, 0x31, 0x64, 0x33, 0x66, 0x35, 0x66, 0x38, 0x61, 0x30, 0x65, 0x37, 0x37, 0x65, 0x66, 0x66, 0x66, 0x61, 0x32, 0x63, 0x64, 0x64, 0x65, 0x37, 0x32, 0x65, 0x34, 0x65, 0x34, 0x65, 0x33, 0x63, 0x37, 0x35, 0x63, 0x36, 0x30, 0x33, 0x34, 0x61, 0x63, 0x64, 0x64, 0x61, 0x61, 0x63, 0x61, 0x34, 0x34, 0x37, 0x63, 0x62, 0x34, 0x66, 0x31, 0x39, 0x63, 0x31, 0x64, 0x61, 0x32, 0x36, 0x62, 0x37, 0x36, 0x32, 0x63, 0x64, 0x63, 0x36, 0x34, 0x38, 0x39, 0x37, 0x39, 0x30, 0x61, 0x31, 0x33, 0x36, 0x30, 0x63, 0x63, 0x32, 0x33, 0x63, 0x61, 0x35, 0x38, 0x38, 0x64, 0x62, 0x64, 0x64, 0x66, 0x31, 0x34, 0x35, 0x38, 0x37, 0x37, 0x31, 0x63, 0x65, 0x35, 0x32, 0x30, 0x62, 0x64, 0x32, 0x37, 0x39, 0x32, 0x38, 0x33, 0x32, 0x62, 0x39, 0x36, 0x62, 0x64, 0x38, 0x36, 0x33, 0x35, 0x36, 0x37, 0x39, 0x64, 0x66, 0x38, 0x38, 0x31, 0x37, 0x65, 0x39, 0x64, 0x66, 0x37, 0x31, 0x39, 0x37, 0x36, 0x36, 0x32, 0x30, 0x33, 0x65, 0x66, 0x36, 0x33, 0x37, 0x32, 0x35, 0x38, 0x65, 0x62, 0x30, 0x34, 0x37, 0x35, 0x62, 0x39, 0x33, 0x61, 0x34, 0x35, 0x32, 0x63, 0x30, 0x37, 0x62, 0x38, 0x36, 0x65, 0x66, 0x37, 0x37, 0x61, 0x63, 0x36, 0x36, 0x31, 0x62, 0x32, 0x36, 0x62, 0x64, 0x34, 0x33, 0x39, 0x32, 0x64, 0x65, 0x36, 0x31, 0x61, 0x36, 0x33, 0x37, 0x66, 0x39, 0x37, 0x38, 0x32, 0x64, 0x35, 0x65, 0x63, 0x64, 0x33, 0x39, 0x30, 0x39, 0x31, 0x37, 0x32, 0x30, 0x35, 0x35, 0x34, 0x62, 0x66, 0x30, 0x38, 0x33, 0x30, 0x34, 0x32, 0x31, 0x64, 0x39, 0x38, 0x31, 0x63, 0x32, 0x66, 0x63, 0x38, 0x62, 0x38, 0x63, 0x61, 0x34, 0x33, 0x34, 0x33, 0x36, 0x31, 0x33, 0x39, 0x39, 0x31, 0x34, 0x63, 0x66, 0x32, 0x34, 0x31, 0x35, 0x34, 0x63, 0x32, 0x65, 0x32, 0x66, 0x36, 0x34, 0x39, 0x61, 0x65, 0x61, 0x66, 0x38, 0x66, 0x30, 0x64, 0x30, 0x63, 0x37, 0x32, 0x31, 0x62, 0x34, 0x64, 0x64, 0x66, 0x63, 0x36, 0x34, 0x64, 0x61, 0x64, 0x36, 0x30, 0x37, 0x30, 0x36, 0x61, 0x62, 0x31, 0x30, 0x32, 0x64, 0x35, 0x30, 0x31, 0x66, 0x35, 0x63, 0x33, 0x35, 0x33, 0x32, 0x35, 0x63, 0x39, 0x38, 0x34, 0x37, 0x35, 0x34, 0x65, 0x30, 0x65, 0x61, 0x38, 0x32, 0x35, 0x33, 0x62, 0x33, 0x66, 0x39, 0x39, 0x66, 0x35, 0x32, 0x66, 0x62, 0x65, 0x37, 0x66, 0x37, 0x32, 0x34, 0x37, 0x66, 0x37, 0x30, 0x38, 0x65, 0x66, 0x63, 0x31, 0x36, 0x64, 0x32, 0x33, 0x65, 0x62, 0x65, 0x65, 0x39, 0x64, 0x30, 0x36, 0x63, 0x35, 0x35, 0x62, 0x61, 0x64, 0x33, 0x64, 0x32, 0x36, 0x37, 0x39, 0x31, 0x35, 0x36, 0x66, 0x31, 0x38, 0x31, 0x63, 0x33, 0x33, 0x39, 0x37, 0x34, 0x61, 0x39, 0x32, 0x64, 0x63, 0x62, 0x34, 0x61, 0x62, 0x34, 0x38, 0x63, 0x62, 0x35, 0x65, 0x37, 0x32, 0x65, 0x35, 0x31, 0x39, 0x35, 0x32, 0x65, 0x30, 0x61, 0x32, 0x37, 0x30, 0x63, 0x36, 0x65, 0x36, 0x32, 0x39, 0x38, 0x37, 0x64, 0x36, 0x35, 0x35, 0x34, 0x38, 0x35, 0x31, 0x66, 0x34, 0x33, 0x37, 0x35, 0x66, 0x33, 0x62, 0x62, 0x39, 0x31, 0x32, 0x62, 0x30, 0x30, 0x62, 0x37, 0x36, 0x65, 0x36, 0x30, 0x30, 0x39, 0x31, 0x64, 0x63, 0x39, 0x35, 0x33, 0x35, 0x61, 0x30, 0x30, 0x61, 0x32, 0x62, 0x62, 0x32, 0x63, 0x63, 0x64, 0x31, 0x65, 0x30, 0x36, 0x37, 0x34, 0x61, 0x36, 0x33, 0x32, 0x36, 0x36, 0x36, 0x30, 0x66, 0x39, 0x33, 0x30, 0x32, 0x64, 0x39, 0x62, 0x61, 0x35, 0x36, 0x32, 0x38, 0x62, 0x35, 0x30, 0x66, 0x35, 0x63, 0x36, 0x38, 0x34, 0x31, 0x66, 0x30, 0x33, 0x30, 0x38, 0x36, 0x61, 0x63, 0x62, 0x35, 0x64, 0x38, 0x66, 0x62, 0x63, 0x38, 0x61, 0x39, 0x62, 0x39, 0x37, 0x32, 0x63, 0x39, 0x62, 0x64, 0x30, 0x34, 0x39, 0x65, 0x66, 0x32, 0x36, 0x38, 0x35, 0x31, 0x34, 0x39, 0x30, 0x61, 0x64, 0x64, 0x31, 0x32, 0x64, 0x30, 0x66, 0x65, 0x39, 0x31, 0x33, 0x37, 0x64, 0x33, 0x36, 0x62, 0x64, 0x63, 0x35, 0x63, 0x66, 0x33, 0x36, 0x36, 0x64, 0x30, 0x39, 0x33, 0x36, 0x30, 0x31, 0x31, 0x33, 0x30, 0x34, 0x36, 0x63, 0x38, 0x63, 0x35, 0x62, 0x35, 0x31, 0x32, 0x36, 0x37, 0x63, 0x61, 0x62, 0x61, 0x33, 0x61, 0x62, 0x64, 0x31, 0x61, 0x33, 0x66, 0x30, 0x35, 0x65, 0x65, 0x64, 0x31, 0x34, 0x30, 0x38, 0x31, 0x35, 0x63, 0x30, 0x36, 0x64, 0x30, 0x37, 0x62, 0x33, 0x36, 0x34, 0x37, 0x34, 0x36, 0x37, 0x36, 0x37, 0x35, 0x61, 0x64, 0x36, 0x65, 0x35, 0x39, 0x39, 0x65, 0x34, 0x63, 0x36, 0x62, 0x38, 0x63, 0x38, 0x35, 0x35, 0x63, 0x62, 0x38, 0x33, 0x37, 0x33, 0x66, 0x64, 0x39, 0x63, 0x33, 0x32, 0x61, 0x35, 0x61, 0x34, 0x31, 0x38, 0x38, 0x38, 0x62, 0x32, 0x64, 0x31, 0x66, 0x34, 0x32, 0x63, 0x61, 0x38, 0x63, 0x34, 0x66, 0x62, 0x37, 0x65, 0x31, 0x32, 0x39, 0x39, 0x63, 0x33, 0x64, 0x62, 0x63, 0x35, 0x66, 0x66, 0x31, 0x32, 0x65, 0x32, 0x33, 0x66, 0x30, 0x30, 0x66, 0x39, 0x30, 0x66, 0x66, 0x63, 0x35, 0x63, 0x66, 0x35, 0x65, 0x63, 0x62, 0x37, 0x32, 0x65, 0x63, 0x33, 0x36, 0x33, 0x66, 0x35, 0x30, 0x39, 0x66, 0x31, 0x37, 0x62, 0x30, 0x66, 0x32, 0x33, 0x37, 0x34, 0x36, 0x66, 0x65, 0x38, 0x66, 0x31, 0x63, 0x66, 0x39, 0x35, 0x65, 0x33, 0x30, 0x34, 0x39, 0x63, 0x61, 0x39, 0x31, 0x37, 0x64, 0x31, 0x34, 0x38, 0x63, 0x38, 0x65, 0x36, 0x65, 0x35, 0x64, 0x35, 0x66, 0x38, 0x31, 0x63, 0x35, 0x38, 0x63, 0x63, 0x36, 0x61, 0x34, 0x37, 0x32, 0x35, 0x30, 0x32, 0x63, 0x65, 0x61, 0x30, 0x31, 0x64, 0x63, 0x34, 0x61, 0x36, 0x61, 0x31, 0x66, 0x37, 0x34, 0x33, 0x36, 0x63, 0x65, 0x35, 0x63, 0x31, 0x35, 0x34, 0x39, 0x61, 0x32, 0x38, 0x61, 0x39, 0x66, 0x31, 0x66, 0x32, 0x30, 0x65, 0x33, 0x62, 0x31, 0x38, 0x32, 0x66, 0x64, 0x64, 0x34, 0x65, 0x63, 0x39, 0x39, 0x35, 0x36, 0x34, 0x36, 0x65, 0x64, 0x61, 0x36, 0x38, 0x62, 0x37, 0x32, 0x62, 0x61, 0x31, 0x35, 0x31, 0x30, 0x66, 0x34, 0x39, 0x39, 0x31, 0x62, 0x36, 0x32, 0x66, 0x35, 0x33, 0x61, 0x31, 0x36, 0x66, 0x62, 0x37, 0x37, 0x63, 0x61, 0x65, 0x30, 0x66, 0x31, 0x64, 0x33, 0x32, 0x64, 0x38, 0x38, 0x39, 0x39, 0x30, 0x31, 0x33, 0x31, 0x66, 0x34, 0x64, 0x36, 0x66, 0x65, 0x64, 0x30, 0x65, 0x64, 0x35, 0x31, 0x31, 0x30, 0x38, 0x62, 0x31, 0x65, 0x35, 0x30, 0x36, 0x64, 0x39, 0x32, 0x37, 0x33, 0x30, 0x63, 0x61, 0x33, 0x62, 0x30, 0x39, 0x36, 0x63, 0x35, 0x30, 0x66, 0x63, 0x30, 0x39, 0x33, 0x31, 0x36, 0x36, 0x30, 0x35, 0x66, 0x34, 0x35, 0x36, 0x64, 0x63, 0x65, 0x36, 0x39, 0x36, 0x39, 0x30, 0x34, 0x62, 0x66, 0x37, 0x66, 0x30, 0x38, 0x31, 0x36, 0x38, 0x36, 0x64, 0x66, 0x66, 0x62, 0x36, 0x30, 0x31, 0x61, 0x32, 0x34, 0x39, 0x61, 0x36, 0x38, 0x31, 0x64, 0x34, 0x35, 0x62, 0x33, 0x33, 0x37, 0x35, 0x35, 0x39, 0x35, 0x62, 0x33, 0x64, 0x37, 0x63, 0x36, 0x66, 0x63, 0x35, 0x35, 0x63, 0x30, 0x38, 0x65, 0x32, 0x39, 0x66, 0x30, 0x66, 0x31, 0x32, 0x37, 0x34, 0x66, 0x62, 0x38, 0x38, 0x35, 0x32, 0x39, 0x62, 0x31, 0x39, 0x64, 0x31, 0x66, 0x62, 0x32, 0x62, 0x30, 0x36, 0x37, 0x64, 0x62, 0x37, 0x39, 0x37, 0x62, 0x36, 0x32, 0x37, 0x31, 0x37, 0x32, 0x32, 0x35, 0x62, 0x64, 0x66, 0x62, 0x64, 0x66, 0x64, 0x30, 0x32, 0x36, 0x66, 0x34, 0x63, 0x30, 0x36, 0x30, 0x33, 0x64, 0x35, 0x38, 0x64, 0x36, 0x37, 0x65, 0x32, 0x35, 0x63, 0x66, 0x36, 0x64, 0x63, 0x33, 0x61, 0x65, 0x38, 0x37, 0x34, 0x31, 0x36, 0x35, 0x34, 0x32, 0x63, 0x32, 0x66, 0x33, 0x39, 0x34, 0x36, 0x30, 0x65, 0x39, 0x31, 0x38, 0x36, 0x61, 0x33, 0x33, 0x31, 0x38, 0x37, 0x32, 0x33, 0x32, 0x38, 0x32, 0x63, 0x65, 0x35, 0x61, 0x33, 0x30, 0x30, 0x37, 0x65, 0x37, 0x35, 0x66, 0x38, 0x38, 0x62, 0x66, 0x64, 0x34, 0x64, 0x36, 0x32, 0x31, 0x61, 0x63, 0x64, 0x37, 0x38, 0x32, 0x66, 0x38, 0x65, 0x38, 0x39, 0x31, 0x66, 0x36, 0x34, 0x32, 0x65, 0x37, 0x32, 0x39, 0x61, 0x63, 0x30, 0x37, 0x63, 0x36, 0x39, 0x66, 0x32, 0x61, 0x39, 0x30, 0x38, 0x32, 0x33, 0x36, 0x37, 0x32, 0x61, 0x33, 0x64, 0x62, 0x38, 0x31, 0x34, 0x36, 0x65, 0x39, 0x32, 0x65, 0x39, 0x66, 0x39, 0x37, 0x65, 0x64, 0x34, 0x30, 0x64, 0x63, 0x34, 0x30, 0x32, 0x39, 0x64, 0x34, 0x35, 0x66, 0x65, 0x34, 0x34, 0x30, 0x64, 0x34, 0x63, 0x36, 0x39, 0x37, 0x61, 0x37, 0x30, 0x37, 0x38, 0x65, 0x64, 0x61, 0x66, 0x31, 0x34, 0x36, 0x39, 0x37, 0x38, 0x38, 0x63, 0x36, 0x62, 0x31, 0x37, 0x35, 0x34, 0x66, 0x32, 0x34, 0x39, 0x34, 0x63, 0x35, 0x34, 0x34, 0x38, 0x64, 0x66, 0x66, 0x62, 0x39, 0x31, 0x33, 0x64, 0x37, 0x30, 0x31, 0x37, 0x30, 0x63, 0x61, 0x38, 0x31, 0x66, 0x36, 0x31, 0x66, 0x66, 0x63, 0x38, 0x61, 0x32, 0x35, 0x35, 0x66, 0x38, 0x66, 0x63, 0x61, 0x33, 0x62, 0x38, 0x35, 0x64, 0x63, 0x36, 0x31, 0x63, 0x33, 0x61, 0x30, 0x64, 0x62, 0x35, 0x30, 0x64, 0x64, 0x62, 0x66, 0x37, 0x32, 0x34, 0x31, 0x62, 0x38, 0x33, 0x32, 0x63, 0x32, 0x36, 0x34, 0x61, 0x61, 0x30, 0x65, 0x62, 0x31, 0x37, 0x63, 0x61, 0x63, 0x65, 0x30, 0x65, 0x64, 0x64, 0x34, 0x63, 0x39, 0x64, 0x61, 0x32, 0x32, 0x35, 0x31, 0x36, 0x66, 0x36, 0x31, 0x31, 0x33, 0x31, 0x35, 0x32, 0x32, 0x31, 0x32, 0x61, 0x35, 0x61, 0x66, 0x36, 0x64, 0x37, 0x39, 0x35, 0x64, 0x62, 0x35, 0x37, 0x36, 0x61, 0x37, 0x32, 0x39, 0x64, 0x32, 0x37, 0x64, 0x30, 0x63, 0x33, 0x37, 0x39, 0x36, 0x35, 0x34, 0x64, 0x66, 0x64, 0x38, 0x61, 0x37, 0x35, 0x30, 0x39, 0x37, 0x63, 0x36, 0x37, 0x39, 0x66, 0x31, 0x65, 0x63, 0x62, 0x63, 0x32, 0x36, 0x31, 0x38, 0x31, 0x36, 0x34, 0x36, 0x34, 0x63, 0x32, 0x62, 0x31, 0x37, 0x32, 0x38, 0x39, 0x34, 0x66, 0x34, 0x39, 0x37, 0x38, 0x61, 0x61, 0x65, 0x30, 0x36, 0x34, 0x36, 0x33, 0x37, 0x38, 0x39, 0x37, 0x37, 0x64, 0x62, 0x34, 0x36, 0x37, 0x62, 0x30, 0x30, 0x35, 0x35, 0x37, 0x37, 0x39, 0x61, 0x63, 0x30, 0x30, 0x63, 0x38, 0x33, 0x36, 0x38, 0x65, 0x64, 0x66, 0x61, 0x34, 0x32, 0x61, 0x30, 0x31, 0x39, 0x63, 0x66, 0x39, 0x34, 0x35, 0x66, 0x30, 0x62, 0x33, 0x64, 0x31, 0x38, 0x65, 0x36, 0x32, 0x31, 0x64, 0x36, 0x36, 0x39, 0x32, 0x30, 0x63, 0x66, 0x32, 0x30, 0x37, 0x32, 0x32, 0x30, 0x62, 0x39, 0x64, 0x35, 0x39, 0x35, 0x39, 0x66, 0x35, 0x63, 0x39, 0x64, 0x37, 0x33, 0x30, 0x33, 0x61, 0x36, 0x64, 0x30, 0x37, 0x66, 0x65, 0x64, 0x35, 0x66, 0x62, 0x62, 0x39, 0x34, 0x30, 0x32, 0x65, 0x63, 0x34, 0x63, 0x36, 0x31, 0x32, 0x38, 0x64, 0x36, 0x63, 0x61, 0x33, 0x36, 0x30, 0x31, 0x39, 0x63, 0x38, 0x38, 0x66, 0x35, 0x33, 0x39, 0x36, 0x61, 0x66, 0x32, 0x37, 0x32, 0x66, 0x63, 0x34, 0x38, 0x32, 0x64, 0x63, 0x34, 0x36, 0x32, 0x37, 0x36, 0x66, 0x38, 0x65, 0x63, 0x64, 0x30, 0x35, 0x61, 0x62, 0x32, 0x39, 0x35, 0x35, 0x36, 0x32, 0x30, 0x35, 0x31, 0x34, 0x36, 0x64, 0x31, 0x62, 0x38, 0x39, 0x38, 0x33, 0x65, 0x38, 0x62, 0x64, 0x64, 0x36, 0x33, 0x62, 0x37, 0x31, 0x64, 0x31, 0x62, 0x62, 0x36, 0x64, 0x31, 0x62, 0x31, 0x32, 0x65, 0x61, 0x64, 0x35, 0x32, 0x64, 0x62, 0x63, 0x32, 0x36, 0x39, 0x64, 0x30, 0x31, 0x31, 0x64, 0x61, 0x35, 0x63, 0x33, 0x62, 0x30, 0x34, 0x66, 0x64, 0x38, 0x65, 0x38, 0x37, 0x39, 0x32, 0x62, 0x39, 0x65, 0x62, 0x38, 0x30, 0x31, 0x39, 0x62, 0x65, 0x31, 0x64, 0x34, 0x36, 0x30, 0x63, 0x32, 0x64, 0x31, 0x61, 0x65, 0x32, 0x37, 0x39, 0x31, 0x39, 0x39, 0x31, 0x37, 0x62, 0x33, 0x31, 0x31, 0x62, 0x38, 0x64, 0x37, 0x32, 0x32, 0x64, 0x63, 0x37, 0x30, 0x63, 0x39, 0x33, 0x61, 0x30, 0x62, 0x62, 0x65, 0x62, 0x38, 0x33, 0x39, 0x37, 0x36, 0x33, 0x38, 0x37, 0x61, 0x31, 0x35, 0x37, 0x30, 0x64, 0x61, 0x33, 0x63, 0x32, 0x37, 0x66, 0x33, 0x34, 0x36, 0x35, 0x62, 0x65, 0x35, 0x34, 0x64, 0x64, 0x33, 0x33, 0x35, 0x32, 0x36, 0x63, 0x64, 0x63, 0x63, 0x32, 0x66, 0x31, 0x31, 0x65, 0x61, 0x37, 0x36, 0x66, 0x37, 0x32, 0x37, 0x62, 0x62, 0x37, 0x65, 0x62, 0x66, 0x38, 0x38, 0x64, 0x63, 0x64, 0x37, 0x65, 0x38, 0x30, 0x38, 0x36, 0x38, 0x63, 0x30, 0x65, 0x30, 0x66, 0x32, 0x65, 0x65, 0x61, 0x65, 0x32, 0x65, 0x37, 0x38, 0x36, 0x34, 0x35, 0x62, 0x32, 0x32, 0x35, 0x38, 0x65, 0x37, 0x38, 0x30, 0x62, 0x31, 0x30, 0x33, 0x62, 0x61, 0x36, 0x64, 0x65, 0x39, 0x65, 0x31, 0x39, 0x38, 0x36, 0x34, 0x31, 0x37, 0x32, 0x65, 0x38, 0x34, 0x30, 0x65, 0x66, 0x34, 0x30, 0x30, 0x65, 0x66, 0x61, 0x39, 0x31, 0x33, 0x37, 0x35, 0x32, 0x61, 0x65, 0x34, 0x65, 0x37, 0x62, 0x64, 0x64, 0x36, 0x33, 0x64, 0x64, 0x34, 0x64, 0x61, 0x61, 0x30, 0x66, 0x61, 0x63, 0x33, 0x62, 0x36, 0x64, 0x63, 0x30, 0x32, 0x37, 0x35, 0x36, 0x34, 0x39, 0x31, 0x62, 0x33, 0x37, 0x65, 0x61, 0x34, 0x66, 0x38, 0x65, 0x31, 0x38, 0x31, 0x61, 0x38, 0x31, 0x64, 0x34, 0x62, 0x62, 0x39, 0x38, 0x33, 0x38, 0x30, 0x39, 0x32, 0x61, 0x34, 0x33, 0x30, 0x38, 0x30, 0x38, 0x32, 0x66, 0x35, 0x39, 0x61, 0x31, 0x37, 0x62, 0x36, 0x39, 0x32, 0x35, 0x63, 0x66, 0x34, 0x38, 0x37, 0x31, 0x63, 0x63, 0x63, 0x39, 0x39, 0x32, 0x38, 0x31, 0x32, 0x64, 0x39, 0x66, 0x31, 0x31, 0x33, 0x39, 0x64, 0x39, 0x62, 0x62, 0x32, 0x65, 0x33, 0x31, 0x37, 0x32, 0x31, 0x38, 0x30, 0x36, 0x32, 0x64, 0x30, 0x63, 0x65, 0x66, 0x62, 0x63, 0x33, 0x36, 0x62, 0x35, 0x65, 0x39, 0x32, 0x63, 0x36, 0x30, 0x64, 0x35, 0x64, 0x37, 0x37, 0x34, 0x36, 0x32, 0x37, 0x39, 0x35, 0x33, 0x66, 0x63, 0x36, 0x39, 0x66, 0x65, 0x35, 0x63, 0x33, 0x64, 0x61, 0x35, 0x37, 0x62, 0x64, 0x32, 0x36, 0x63, 0x62, 0x30, 0x35, 0x39, 0x37, 0x63, 0x32, 0x66, 0x38, 0x35, 0x31, 0x36, 0x66, 0x66, 0x35, 0x30, 0x39, 0x61, 0x65, 0x33, 0x34, 0x34, 0x37, 0x66, 0x63, 0x62, 0x65, 0x66, 0x31, 0x64, 0x30, 0x61, 0x30, 0x34, 0x34, 0x34, 0x63, 0x63, 0x34, 0x62, 0x38, 0x32, 0x62, 0x64, 0x66, 0x39, 0x35, 0x34, 0x32, 0x35, 0x39, 0x63, 0x66, 0x64, 0x33, 0x34, 0x34, 0x37, 0x32, 0x38, 0x37, 0x38, 0x33, 0x66, 0x65, 0x37, 0x62, 0x34, 0x35, 0x66, 0x65, 0x33, 0x32, 0x37, 0x37, 0x32, 0x61, 0x36, 0x34, 0x34, 0x37, 0x64, 0x37, 0x34, 0x63, 0x66, 0x34, 0x33, 0x37, 0x31, 0x62, 0x34, 0x61, 0x34, 0x65, 0x36, 0x39, 0x36, 0x30, 0x30, 0x30, 0x32, 0x35, 0x36, 0x35, 0x39, 0x39, 0x31, 0x30, 0x31, 0x62, 0x31, 0x38, 0x32, 0x39, 0x38, 0x62, 0x35, 0x32, 0x64, 0x33, 0x62, 0x65, 0x36, 0x32, 0x62, 0x38, 0x63, 0x31, 0x36, 0x33, 0x36, 0x35, 0x32, 0x61, 0x39, 0x63, 0x36, 0x33, 0x63, 0x32, 0x39, 0x38, 0x39, 0x65, 0x36, 0x32, 0x34, 0x36, 0x39, 0x64, 0x62, 0x62, 0x65, 0x36, 0x34, 0x66, 0x66, 0x34, 0x39, 0x32, 0x30, 0x38, 0x38, 0x62, 0x64, 0x66, 0x37, 0x61, 0x64, 0x32, 0x61, 0x65, 0x31, 0x38, 0x62, 0x63, 0x35, 0x33, 0x30, 0x30, 0x33, 0x61, 0x39, 0x31, 0x37, 0x35, 0x31, 0x66, 0x32, 0x66, 0x64, 0x33, 0x35, 0x31, 0x35, 0x38, 0x64, 0x61, 0x32, 0x31, 0x64, 0x32, 0x35, 0x36, 0x37, 0x34, 0x31, 0x30, 0x31, 0x65, 0x30, 0x65, 0x30, 0x64, 0x30, 0x32, 0x36, 0x38, 0x39, 0x33, 0x34, 0x39, 0x64, 0x31, 0x65, 0x32, 0x63, 0x62, 0x37, 0x32, 0x34, 0x62, 0x35, 0x32, 0x35, 0x38, 0x62, 0x62, 0x34, 0x63, 0x65, 0x38, 0x33, 0x30, 0x64, 0x62, 0x39, 0x66, 0x39, 0x32, 0x39, 0x36, 0x39, 0x62, 0x62, 0x64, 0x66, 0x37, 0x36, 0x64, 0x62, 0x36, 0x35, 0x65, 0x61, 0x31, 0x63, 0x31, 0x66, 0x63, 0x35, 0x31, 0x38, 0x38, 0x32, 0x35, 0x62, 0x33, 0x62, 0x31, 0x31, 0x65, 0x38, 0x35, 0x37, 0x39, 0x61, 0x31, 0x64, 0x31, 0x33, 0x33, 0x30, 0x33, 0x34, 0x61, 0x61, 0x31, 0x32, 0x65, 0x33, 0x32, 0x39, 0x37, 0x39, 0x63, 0x63, 0x34, 0x31, 0x61, 0x62, 0x38, 0x64, 0x38, 0x63, 0x62, 0x61, 0x66, 0x34, 0x63, 0x32, 0x39, 0x39, 0x65, 0x64, 0x64, 0x35, 0x33, 0x35, 0x34, 0x34, 0x32, 0x65, 0x66, 0x31, 0x34, 0x32, 0x62, 0x32, 0x38, 0x32, 0x66, 0x65, 0x32, 0x36, 0x31, 0x37, 0x30, 0x31, 0x35, 0x32, 0x30, 0x37, 0x62, 0x34, 0x34, 0x66, 0x64, 0x35, 0x31, 0x65, 0x66, 0x37, 0x63, 0x38, 0x31, 0x31, 0x36, 0x65, 0x36, 0x63, 0x64, 0x39, 0x39, 0x66, 0x64, 0x33, 0x66, 0x61, 0x64, 0x35, 0x33, 0x64, 0x35, 0x35, 0x65, 0x37, 0x63, 0x33, 0x66, 0x32, 0x66, 0x66, 0x33, 0x64, 0x66, 0x37, 0x33, 0x34, 0x64, 0x62, 0x32, 0x37, 0x31, 0x31, 0x37, 0x30, 0x65, 0x63, 0x31, 0x65, 0x66, 0x66, 0x31, 0x35, 0x36, 0x31, 0x32, 0x64, 0x62, 0x31, 0x38, 0x35, 0x61, 0x34, 0x61, 0x63, 0x32, 0x65, 0x38, 0x65, 0x63, 0x30, 0x30, 0x61, 0x63, 0x64, 0x30, 0x61, 0x32, 0x38, 0x33, 0x34, 0x38, 0x36, 0x30, 0x38, 0x61, 0x61, 0x34, 0x61, 0x66, 0x30, 0x62, 0x33, 0x39, 0x66, 0x30, 0x33, 0x63, 0x35, 0x31, 0x61, 0x62, 0x32, 0x63, 0x36, 0x65, 0x35, 0x30, 0x31, 0x66, 0x37, 0x63, 0x32, 0x39, 0x31, 0x30, 0x39, 0x36, 0x63, 0x61, 0x32, 0x33, 0x30, 0x62, 0x64, 0x63, 0x66, 0x34, 0x32, 0x62, 0x39, 0x66, 0x65, 0x62, 0x33, 0x61, 0x65, 0x64, 0x35, 0x61, 0x34, 0x62, 0x64, 0x65, 0x35, 0x32, 0x38, 0x32, 0x30, 0x61, 0x31, 0x38, 0x36, 0x66, 0x32, 0x30, 0x37, 0x31, 0x36, 0x36, 0x36, 0x33, 0x35, 0x30, 0x31, 0x38, 0x61, 0x33, 0x36, 0x64, 0x37, 0x36, 0x30, 0x35, 0x66, 0x37, 0x37, 0x35, 0x33, 0x32, 0x66, 0x36, 0x61, 0x62, 0x61, 0x64, 0x36, 0x65, 0x61, 0x30, 0x64, 0x32, 0x34, 0x30, 0x35, 0x63, 0x32, 0x39, 0x34, 0x62, 0x39, 0x33, 0x36, 0x32, 0x37, 0x33, 0x64, 0x37, 0x36, 0x32, 0x33, 0x61, 0x36, 0x37, 0x36, 0x61, 0x34, 0x38, 0x39, 0x38, 0x33, 0x61, 0x32, 0x36, 0x61, 0x63, 0x39, 0x32, 0x65, 0x66, 0x38, 0x62, 0x35, 0x38, 0x39, 0x30, 0x39, 0x35, 0x64, 0x64, 0x38, 0x32, 0x64, 0x30, 0x38, 0x38, 0x35, 0x64, 0x35, 0x33, 0x65, 0x31, 0x35, 0x34, 0x65, 0x37, 0x34, 0x65, 0x30, 0x61, 0x62, 0x64, 0x30, 0x30, 0x66, 0x64, 0x33, 0x37, 0x63, 0x36, 0x64, 0x63, 0x61, 0x38, 0x64, 0x35, 0x38, 0x30, 0x39, 0x61, 0x35, 0x33, 0x38, 0x38, 0x30, 0x33, 0x64, 0x34, 0x36, 0x66, 0x64, 0x65, 0x65, 0x64, 0x61, 0x61, 0x32, 0x62, 0x39, 0x62, 0x36, 0x39, 0x30, 0x35, 0x65, 0x64, 0x66, 0x32, 0x62, 0x34, 0x64, 0x61, 0x65, 0x37, 0x63, 0x33, 0x36, 0x32, 0x33, 0x36, 0x39, 0x32, 0x65, 0x30, 0x66, 0x61, 0x64, 0x64, 0x30, 0x39, 0x30, 0x35, 0x39, 0x33, 0x36, 0x35, 0x37, 0x62, 0x38, 0x34, 0x37, 0x34, 0x62, 0x38, 0x39, 0x61, 0x36, 0x33, 0x30, 0x61, 0x30, 0x37, 0x32, 0x30, 0x63, 0x63, 0x36, 0x63, 0x31, 0x30, 0x39, 0x39, 0x62, 0x66, 0x38, 0x32, 0x37, 0x38, 0x36, 0x66, 0x62, 0x61, 0x33, 0x36, 0x39, 0x33, 0x61, 0x33, 0x63, 0x65, 0x31, 0x39, 0x66, 0x33, 0x38, 0x64, 0x30, 0x34, 0x35, 0x65, 0x38, 0x61, 0x66, 0x30, 0x62, 0x63, 0x36, 0x30, 0x61, 0x32, 0x66, 0x33, 0x66, 0x63, 0x38, 0x36, 0x39, 0x65, 0x66, 0x37, 0x31, 0x35, 0x33, 0x62, 0x30, 0x37, 0x32, 0x39, 0x39, 0x39, 0x34, 0x37, 0x34, 0x65, 0x37, 0x31, 0x64, 0x62, 0x37, 0x62, 0x39, 0x32, 0x32, 0x62, 0x37, 0x37, 0x32, 0x63, 0x66, 0x62, 0x66, 0x36, 0x61, 0x66, 0x62, 0x32, 0x35, 0x63, 0x38, 0x63, 0x31, 0x31, 0x38, 0x33, 0x66, 0x33, 0x37, 0x34, 0x34, 0x37, 0x64, 0x62, 0x34, 0x37, 0x39, 0x38, 0x30, 0x37, 0x38, 0x34, 0x36, 0x62, 0x61, 0x38, 0x34, 0x34, 0x62, 0x37, 0x30, 0x36, 0x64, 0x35, 0x34, 0x65, 0x39, 0x31, 0x33, 0x61, 0x37, 0x38, 0x38, 0x61, 0x34, 0x66, 0x32, 0x30, 0x36, 0x32, 0x65, 0x30, 0x62, 0x30, 0x35, 0x35, 0x37, 0x39, 0x62, 0x37, 0x66, 0x35, 0x36, 0x64, 0x39, 0x33, 0x32, 0x61, 0x35, 0x34, 0x32, 0x64, 0x34, 0x38, 0x31, 0x39, 0x64, 0x33, 0x37, 0x34, 0x32, 0x37, 0x64, 0x39, 0x35, 0x66, 0x62, 0x32, 0x65, 0x66, 0x30, 0x37, 0x38, 0x66, 0x34, 0x37, 0x32, 0x30, 0x63, 0x39, 0x33, 0x33, 0x39, 0x38, 0x38, 0x62, 0x31, 0x33, 0x66, 0x39, 0x30, 0x65, 0x65, 0x65, 0x64, 0x65, 0x30, 0x63, 0x37, 0x65, 0x38, 0x61, 0x37, 0x32, 0x39, 0x64, 0x31, 0x33, 0x64, 0x64, 0x62, 0x35, 0x61, 0x64, 0x39, 0x62, 0x63, 0x35, 0x65, 0x31, 0x32, 0x39, 0x31, 0x36, 0x31, 0x37, 0x37, 0x38, 0x38, 0x65, 0x66, 0x31, 0x30, 0x62, 0x61, 0x37, 0x33, 0x32, 0x65, 0x37, 0x32, 0x30, 0x36, 0x61, 0x64, 0x32, 0x37, 0x30, 0x36, 0x62, 0x36, 0x64, 0x62, 0x32, 0x61, 0x37, 0x32, 0x63, 0x61, 0x37, 0x30, 0x64, 0x61, 0x65, 0x61, 0x62, 0x61, 0x35, 0x33, 0x37, 0x33, 0x65, 0x63, 0x63, 0x66, 0x65, 0x65, 0x61, 0x32, 0x31, 0x38, 0x63, 0x66, 0x35, 0x31, 0x30, 0x64, 0x34, 0x32, 0x62, 0x31, 0x38, 0x38, 0x37, 0x34, 0x64, 0x66, 0x63, 0x32, 0x66, 0x35, 0x34, 0x66, 0x30, 0x37, 0x66, 0x62, 0x66, 0x35, 0x33, 0x30, 0x64, 0x38, 0x39, 0x30, 0x38, 0x38, 0x64, 0x63, 0x33, 0x62, 0x31, 0x38, 0x66, 0x30, 0x38, 0x38, 0x36, 0x30, 0x39, 0x64, 0x33, 0x38, 0x34, 0x61, 0x31, 0x31, 0x31, 0x63, 0x33, 0x62, 0x34, 0x34, 0x64, 0x64, 0x64, 0x61, 0x62, 0x35, 0x62, 0x66, 0x36, 0x30, 0x33, 0x66, 0x38, 0x61, 0x38, 0x66, 0x37, 0x33, 0x30, 0x39, 0x30, 0x31, 0x34, 0x64, 0x34, 0x36, 0x34, 0x34, 0x61, 0x62, 0x33, 0x30, 0x38, 0x38, 0x36, 0x65, 0x38, 0x66, 0x39, 0x66, 0x35, 0x66, 0x30, 0x38, 0x36, 0x35, 0x63, 0x34, 0x63, 0x65, 0x66, 0x39, 0x61, 0x66, 0x61, 0x36, 0x37, 0x61, 0x66, 0x33, 0x36, 0x30, 0x35, 0x30, 0x33, 0x38, 0x66, 0x62, 0x61, 0x31, 0x31, 0x63, 0x39, 0x35, 0x39, 0x30, 0x38, 0x39, 0x37, 0x31, 0x39, 0x36, 0x63, 0x39, 0x36, 0x65, 0x31, 0x33, 0x37, 0x32, 0x66, 0x30, 0x31, 0x65, 0x33, 0x34, 0x39, 0x64, 0x37, 0x38, 0x65, 0x61, 0x30, 0x62, 0x64, 0x33, 0x35, 0x64, 0x37, 0x62, 0x36, 0x61, 0x35, 0x37, 0x61, 0x30, 0x66, 0x37, 0x66, 0x39, 0x35, 0x34, 0x38, 0x37, 0x31, 0x38, 0x36, 0x39, 0x63, 0x33, 0x37, 0x62, 0x63, 0x35, 0x39, 0x32, 0x36, 0x37, 0x35, 0x30, 0x61, 0x61, 0x64, 0x38, 0x37, 0x37, 0x34, 0x38, 0x62, 0x38, 0x61, 0x61, 0x36, 0x31, 0x62, 0x38, 0x66, 0x39, 0x36, 0x64, 0x61, 0x37, 0x63, 0x38, 0x33, 0x65, 0x63, 0x33, 0x62, 0x36, 0x37, 0x36, 0x38, 0x64, 0x65, 0x37, 0x35, 0x39, 0x32, 0x30, 0x65, 0x62, 0x38, 0x35, 0x38, 0x32, 0x33, 0x38, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x34, 0x31, 0x66, 0x61, 0x37, 0x65, 0x37, 0x39, 0x31, 0x30, 0x61, 0x32, 0x36, 0x38, 0x31, 0x64, 0x61, 0x63, 0x35, 0x31, 0x64, 0x62, 0x31, 0x36, 0x39, 0x33, 0x34, 0x64, 0x36, 0x38, 0x31, 0x61, 0x61, 0x34, 0x33, 0x63, 0x31, 0x32, 0x33, 0x39, 0x34, 0x32, 0x36, 0x64, 0x33, 0x35, 0x32, 0x66, 0x30, 0x62, 0x36, 0x36, 0x39, 0x34, 0x66, 0x62, 0x37, 0x61, 0x33, 0x37, 0x30, 0x64, 0x65, 0x64, 0x62, 0x66, 0x36, 0x33, 0x62, 0x37, 0x61, 0x64, 0x65, 0x31, 0x30, 0x35, 0x32, 0x34, 0x33, 0x64, 0x39, 0x35, 0x33, 0x35, 0x63, 0x38, 0x35, 0x34, 0x35, 0x39, 0x63, 0x34, 0x39, 0x34, 0x65, 0x65, 0x61, 0x37, 0x39, 0x34, 0x65, 0x62, 0x31, 0x63, 0x33, 0x39, 0x39, 0x65, 0x36, 0x62, 0x37, 0x39, 0x35, 0x63, 0x37, 0x61, 0x35, 0x65, 0x37, 0x63, 0x62, 0x65, 0x35, 0x37, 0x38, 0x33, 0x65, 0x61, 0x37, 0x33, 0x32, 0x35, 0x62, 0x62, 0x39, 0x61, 0x35, 0x65, 0x32, 0x65, 0x35, 0x33, 0x37, 0x37, 0x33, 0x39, 0x65, 0x35, 0x35, 0x38, 0x37, 0x32, 0x66, 0x64, 0x33, 0x35, 0x31, 0x31, 0x30, 0x37, 0x31, 0x63, 0x37, 0x39, 0x66, 0x30, 0x38, 0x62, 0x37, 0x66, 0x64, 0x64, 0x33, 0x61, 0x66, 0x37, 0x39, 0x33, 0x66, 0x32, 0x65, 0x38, 0x66, 0x36, 0x37, 0x30, 0x39, 0x31, 0x33, 0x32, 0x62, 0x39, 0x38, 0x63, 0x39, 0x32, 0x62, 0x30, 0x30, 0x62, 0x65, 0x62, 0x39, 0x37, 0x38, 0x38, 0x64, 0x32, 0x39, 0x31, 0x64, 0x39, 0x65, 0x36, 0x37, 0x32, 0x33, 0x38, 0x65, 0x30, 0x65, 0x63, 0x61, 0x63, 0x63, 0x36, 0x30, 0x33, 0x63, 0x63, 0x61, 0x36, 0x38, 0x62, 0x37, 0x63, 0x36, 0x32, 0x37, 0x32, 0x63, 0x36, 0x65, 0x39, 0x33, 0x66, 0x38, 0x64, 0x61, 0x30, 0x63, 0x63, 0x30, 0x61, 0x33, 0x62, 0x64, 0x66, 0x30, 0x65, 0x34, 0x66, 0x61, 0x34, 0x63, 0x35, 0x38, 0x36, 0x36, 0x31, 0x65, 0x64, 0x32, 0x32, 0x65, 0x61, 0x32, 0x30, 0x37, 0x32, 0x30, 0x37, 0x35, 0x31, 0x62, 0x32, 0x34, 0x37, 0x63, 0x65, 0x38, 0x37, 0x35, 0x66, 0x62, 0x37, 0x34, 0x63, 0x64, 0x65, 0x61, 0x33, 0x65, 0x30, 0x64, 0x62, 0x35, 0x65, 0x66, 0x33, 0x36, 0x33, 0x38, 0x36, 0x39, 0x66, 0x61, 0x66, 0x36, 0x37, 0x63, 0x35, 0x64, 0x31, 0x36, 0x30, 0x31, 0x62, 0x61, 0x62, 0x38, 0x35, 0x65, 0x38, 0x65, 0x38, 0x61, 0x34, 0x66, 0x37, 0x65, 0x38, 0x37, 0x32, 0x66, 0x33, 0x64, 0x62, 0x34, 0x32, 0x35, 0x61, 0x66, 0x63, 0x31, 0x66, 0x37, 0x66, 0x32, 0x30, 0x65, 0x63, 0x62, 0x39, 0x61, 0x35, 0x36, 0x38, 0x35, 0x38, 0x61, 0x39, 0x61, 0x31, 0x64, 0x33, 0x34, 0x30, 0x31, 0x33, 0x62, 0x32, 0x65, 0x39, 0x61, 0x34, 0x35, 0x37, 0x30, 0x33, 0x37, 0x39, 0x37, 0x32, 0x61, 0x32, 0x61, 0x61, 0x63, 0x62, 0x61, 0x35, 0x36, 0x66, 0x35, 0x62, 0x33, 0x35, 0x61, 0x39, 0x37, 0x62, 0x61, 0x66, 0x66, 0x65, 0x36, 0x65, 0x35, 0x63, 0x34, 0x37, 0x62, 0x64, 0x66, 0x64, 0x33, 0x36, 0x37, 0x31, 0x65, 0x65, 0x30, 0x31, 0x32, 0x34, 0x35, 0x30, 0x33, 0x63, 0x31, 0x30, 0x35, 0x35, 0x36, 0x61, 0x30, 0x61, 0x31, 0x30, 0x37, 0x36, 0x62, 0x30, 0x36, 0x63, 0x63, 0x65, 0x34, 0x30, 0x61, 0x30, 0x30, 0x62, 0x35, 0x38, 0x35, 0x33, 0x31, 0x32, 0x37, 0x32, 0x30, 0x64, 0x64, 0x66, 0x35, 0x61, 0x33, 0x35, 0x64, 0x32, 0x66, 0x64, 0x30, 0x34, 0x65, 0x66, 0x31, 0x31, 0x37, 0x31, 0x36, 0x38, 0x33, 0x32, 0x39, 0x37, 0x31, 0x61, 0x65, 0x31, 0x64, 0x36, 0x34, 0x65, 0x30, 0x37, 0x34, 0x37, 0x61, 0x35, 0x65, 0x61, 0x31, 0x62, 0x65, 0x61, 0x39, 0x66, 0x36, 0x64, 0x30, 0x36, 0x31, 0x37, 0x65, 0x34, 0x66, 0x35, 0x64, 0x63, 0x39, 0x61, 0x33, 0x39, 0x31, 0x61, 0x34, 0x61, 0x37, 0x66, 0x35, 0x37, 0x66, 0x64, 0x35, 0x38, 0x31, 0x37, 0x61, 0x37, 0x38, 0x32, 0x63, 0x62, 0x35, 0x66, 0x66, 0x64, 0x30, 0x35, 0x61, 0x61, 0x39, 0x39, 0x63, 0x63, 0x65, 0x37, 0x65, 0x39, 0x61, 0x35, 0x63, 0x61, 0x30, 0x38, 0x64, 0x33, 0x34, 0x65, 0x33, 0x37, 0x31, 0x32, 0x33, 0x36, 0x65, 0x30, 0x37, 0x34, 0x33, 0x35, 0x31, 0x37, 0x64, 0x39, 0x37, 0x32, 0x31, 0x62, 0x36, 0x64, 0x66, 0x35, 0x30, 0x63, 0x66, 0x66, 0x66, 0x36, 0x65, 0x66, 0x34, 0x32, 0x34, 0x63, 0x30, 0x61, 0x63, 0x37, 0x33, 0x34, 0x62, 0x36, 0x36, 0x66, 0x33, 0x64, 0x66, 0x64, 0x66, 0x37, 0x35, 0x39, 0x33, 0x31, 0x38, 0x35, 0x38, 0x66, 0x38, 0x37, 0x33, 0x63, 0x37, 0x62, 0x31, 0x62, 0x39, 0x62, 0x65, 0x62, 0x37, 0x61, 0x30, 0x35, 0x36, 0x66, 0x35, 0x38, 0x37, 0x32, 0x39, 0x61, 0x38, 0x31, 0x31, 0x36, 0x61, 0x38, 0x37, 0x66, 0x65, 0x66, 0x33, 0x65, 0x63, 0x62, 0x66, 0x34, 0x62, 0x37, 0x35, 0x32, 0x31, 0x64, 0x36, 0x66, 0x66, 0x63, 0x38, 0x61, 0x61, 0x63, 0x37, 0x38, 0x62, 0x65, 0x33, 0x63, 0x64, 0x62, 0x35, 0x34, 0x30, 0x35, 0x39, 0x66, 0x35, 0x36, 0x66, 0x37, 0x64, 0x34, 0x30, 0x31, 0x64, 0x32, 0x64, 0x39, 0x64, 0x65, 0x63, 0x64, 0x37, 0x32, 0x35, 0x30, 0x66, 0x64, 0x62, 0x35, 0x31, 0x62, 0x35, 0x34, 0x37, 0x66, 0x35, 0x32, 0x30, 0x32, 0x33, 0x66, 0x33, 0x30, 0x64, 0x32, 0x64, 0x65, 0x39, 0x30, 0x34, 0x63, 0x39, 0x62, 0x64, 0x33, 0x36, 0x63, 0x64, 0x32, 0x65, 0x64, 0x62, 0x38, 0x63, 0x34, 0x36, 0x62, 0x30, 0x65, 0x64, 0x62, 0x65, 0x64, 0x36, 0x30, 0x63, 0x65, 0x39, 0x65, 0x35, 0x30, 0x34, 0x35, 0x65, 0x35, 0x30, 0x33, 0x62, 0x63, 0x64, 0x32, 0x64, 0x30, 0x38, 0x65, 0x61, 0x61, 0x38, 0x38, 0x65, 0x61, 0x39, 0x35, 0x30, 0x62, 0x62, 0x34, 0x38, 0x35, 0x34, 0x33, 0x62, 0x31, 0x62, 0x65, 0x63, 0x66, 0x65, 0x39, 0x38, 0x30, 0x62, 0x32, 0x39, 0x38, 0x63, 0x31, 0x36, 0x32, 0x39, 0x34, 0x39, 0x65, 0x36, 0x37, 0x39, 0x63, 0x64, 0x36, 0x36, 0x63, 0x30, 0x37, 0x65, 0x37, 0x39, 0x39, 0x39, 0x62, 0x37, 0x32, 0x65, 0x30, 0x64, 0x33, 0x63, 0x66, 0x39, 0x34, 0x33, 0x65, 0x34, 0x37, 0x35, 0x36, 0x63, 0x34, 0x66, 0x39, 0x32, 0x63, 0x35, 0x62, 0x62, 0x65, 0x35, 0x64, 0x38, 0x37, 0x62, 0x35, 0x65, 0x35, 0x63, 0x39, 0x36, 0x65, 0x33, 0x33, 0x38, 0x66, 0x35, 0x32, 0x63, 0x34, 0x61, 0x39, 0x31, 0x30, 0x35, 0x64, 0x64, 0x66, 0x63, 0x64, 0x39, 0x30, 0x61, 0x33, 0x66, 0x31, 0x32, 0x38, 0x37, 0x32, 0x63, 0x31, 0x64, 0x36, 0x62, 0x35, 0x30, 0x66, 0x64, 0x36, 0x33, 0x32, 0x64, 0x30, 0x64, 0x64, 0x66, 0x61, 0x61, 0x66, 0x30, 0x35, 0x63, 0x35, 0x36, 0x63, 0x39, 0x61, 0x64, 0x65, 0x38, 0x35, 0x66, 0x38, 0x64, 0x61, 0x39, 0x64, 0x62, 0x31, 0x37, 0x31, 0x66, 0x66, 0x63, 0x63, 0x34, 0x34, 0x61, 0x32, 0x34, 0x63, 0x34, 0x33, 0x32, 0x30, 0x65, 0x39, 0x32, 0x38, 0x35, 0x63, 0x36, 0x66, 0x62, 0x38, 0x31, 0x63, 0x66, 0x61, 0x39, 0x32, 0x61, 0x30, 0x62, 0x66, 0x63, 0x30, 0x61, 0x31, 0x32, 0x64, 0x32, 0x31, 0x66, 0x33, 0x30, 0x63, 0x35, 0x38, 0x38, 0x61, 0x66, 0x38, 0x62, 0x39, 0x66, 0x32, 0x62, 0x32, 0x32, 0x64, 0x62, 0x35, 0x66, 0x65, 0x63, 0x32, 0x37, 0x34, 0x66, 0x33, 0x62, 0x38, 0x32, 0x61, 0x38, 0x62, 0x61, 0x31, 0x61, 0x32, 0x61, 0x36, 0x36, 0x38, 0x37, 0x32, 0x38, 0x39, 0x33, 0x37, 0x31, 0x38, 0x30, 0x39, 0x35, 0x37, 0x37, 0x64, 0x30, 0x61, 0x31, 0x30, 0x34, 0x66, 0x63, 0x33, 0x62, 0x66, 0x31, 0x66, 0x65, 0x31, 0x33, 0x32, 0x61, 0x65, 0x38, 0x62, 0x64, 0x30, 0x37, 0x38, 0x35, 0x32, 0x37, 0x30, 0x31, 0x34, 0x35, 0x34, 0x30, 0x61, 0x35, 0x30, 0x61, 0x63, 0x65, 0x36, 0x31, 0x30, 0x34, 0x36, 0x37, 0x35, 0x63, 0x62, 0x32, 0x65, 0x36, 0x31, 0x65, 0x38, 0x64, 0x32, 0x39, 0x32, 0x65, 0x66, 0x66, 0x65, 0x65, 0x30, 0x38, 0x64, 0x32, 0x63, 0x39, 0x37, 0x66, 0x31, 0x34, 0x34, 0x61, 0x34, 0x37, 0x35, 0x39, 0x61, 0x64, 0x62, 0x39, 0x63, 0x61, 0x65, 0x34, 0x39, 0x31, 0x61, 0x33, 0x36, 0x39, 0x36, 0x30, 0x65, 0x38, 0x32, 0x63, 0x65, 0x32, 0x36, 0x30, 0x34, 0x66, 0x33, 0x31, 0x32, 0x62, 0x64, 0x65, 0x36, 0x38, 0x36, 0x37, 0x32, 0x61, 0x32, 0x61, 0x61, 0x63, 0x63, 0x35, 0x39, 0x39, 0x36, 0x38, 0x31, 0x64, 0x33, 0x38, 0x33, 0x33, 0x38, 0x37, 0x38, 0x66, 0x38, 0x37, 0x39, 0x66, 0x64, 0x66, 0x62, 0x66, 0x63, 0x34, 0x62, 0x37, 0x30, 0x37, 0x34, 0x37, 0x37, 0x30, 0x31, 0x66, 0x37, 0x33, 0x38, 0x61, 0x33, 0x38, 0x37, 0x32, 0x37, 0x33, 0x63, 0x65, 0x39, 0x31, 0x32, 0x39, 0x66, 0x63, 0x32, 0x64, 0x65, 0x31, 0x61, 0x39, 0x66, 0x32, 0x64, 0x38, 0x64, 0x39, 0x31, 0x64, 0x34, 0x34, 0x61, 0x65, 0x61, 0x38, 0x38, 0x35, 0x33, 0x64, 0x34, 0x62, 0x35, 0x38, 0x64, 0x31, 0x65, 0x33, 0x34, 0x63, 0x35, 0x34, 0x32, 0x36, 0x32, 0x63, 0x34, 0x66, 0x65, 0x38, 0x34, 0x61, 0x37, 0x33, 0x34, 0x36, 0x39, 0x62, 0x33, 0x63, 0x33, 0x35, 0x36, 0x30, 0x33, 0x38, 0x35, 0x35, 0x64, 0x30, 0x38, 0x64, 0x38, 0x34, 0x32, 0x37, 0x39, 0x32, 0x39, 0x64, 0x38, 0x64, 0x30, 0x63, 0x38, 0x30, 0x36, 0x62, 0x32, 0x38, 0x66, 0x38, 0x37, 0x61, 0x39, 0x33, 0x38, 0x62, 0x62, 0x39, 0x62, 0x62, 0x32, 0x36, 0x34, 0x34, 0x32, 0x61, 0x37, 0x63, 0x61, 0x63, 0x35, 0x66, 0x35, 0x61, 0x63, 0x35, 0x66, 0x32, 0x65, 0x64, 0x61, 0x37, 0x63, 0x38, 0x38, 0x38, 0x30, 0x33, 0x39, 0x34, 0x36, 0x35, 0x38, 0x38, 0x38, 0x37, 0x32, 0x31, 0x34, 0x64, 0x39, 0x39, 0x38, 0x35, 0x39, 0x35, 0x63, 0x65, 0x61, 0x61, 0x65, 0x37, 0x32, 0x30, 0x64, 0x64, 0x35, 0x36, 0x33, 0x31, 0x32, 0x65, 0x65, 0x64, 0x36, 0x31, 0x34, 0x65, 0x63, 0x32, 0x30, 0x36, 0x66, 0x34, 0x30, 0x38, 0x66, 0x65, 0x33, 0x64, 0x64, 0x65, 0x61, 0x39, 0x65, 0x65, 0x31, 0x64, 0x63, 0x37, 0x33, 0x37, 0x36, 0x63, 0x63, 0x37, 0x39, 0x38, 0x36, 0x35, 0x35, 0x64, 0x36, 0x35, 0x37, 0x33, 0x37, 0x30, 0x62, 0x34, 0x66, 0x65, 0x38, 0x37, 0x35, 0x31, 0x39, 0x30, 0x31, 0x62, 0x30, 0x39, 0x36, 0x36, 0x36, 0x31, 0x66, 0x63, 0x33, 0x31, 0x64, 0x64, 0x35, 0x38, 0x37, 0x33, 0x31, 0x37, 0x61, 0x36, 0x33, 0x31, 0x36, 0x32, 0x35, 0x32, 0x36, 0x34, 0x36, 0x38, 0x31, 0x37, 0x34, 0x30, 0x37, 0x65, 0x30, 0x61, 0x34, 0x63, 0x66, 0x65, 0x39, 0x32, 0x35, 0x39, 0x66, 0x30, 0x64, 0x34, 0x62, 0x34, 0x62, 0x66, 0x64, 0x35, 0x62, 0x30, 0x66, 0x64, 0x36, 0x31, 0x35, 0x33, 0x32, 0x61, 0x65, 0x31, 0x66, 0x32, 0x30, 0x36, 0x30, 0x38, 0x32, 0x62, 0x39, 0x63, 0x31, 0x66, 0x37, 0x38, 0x39, 0x66, 0x36, 0x65, 0x64, 0x38, 0x33, 0x61, 0x33, 0x62, 0x39, 0x65, 0x63, 0x33, 0x63, 0x37, 0x32, 0x34, 0x63, 0x64, 0x36, 0x35, 0x37, 0x39, 0x31, 0x37, 0x32, 0x32, 0x33, 0x34, 0x61, 0x64, 0x39, 0x35, 0x35, 0x61, 0x39, 0x35, 0x39, 0x30, 0x61, 0x35, 0x38, 0x39, 0x65, 0x62, 0x36, 0x63, 0x35, 0x37, 0x35, 0x34, 0x65, 0x66, 0x30, 0x34, 0x62, 0x34, 0x39, 0x35, 0x32, 0x63, 0x65, 0x38, 0x61, 0x61, 0x37, 0x30, 0x37, 0x34, 0x38, 0x32, 0x37, 0x31, 0x63, 0x37, 0x31, 0x38, 0x34, 0x35, 0x65, 0x64, 0x36, 0x65, 0x34, 0x35, 0x33, 0x66, 0x66, 0x35, 0x64, 0x33, 0x65, 0x62, 0x33, 0x62, 0x62, 0x65, 0x35, 0x32, 0x66, 0x38, 0x36, 0x37, 0x33, 0x62, 0x62, 0x37, 0x32, 0x31, 0x35, 0x39, 0x32, 0x65, 0x34, 0x63, 0x35, 0x66, 0x39, 0x38, 0x63, 0x35, 0x39, 0x39, 0x38, 0x31, 0x39, 0x34, 0x32, 0x38, 0x31, 0x35, 0x63, 0x64, 0x63, 0x38, 0x39, 0x36, 0x31, 0x64, 0x66, 0x33, 0x64, 0x37, 0x38, 0x37, 0x34, 0x33, 0x30, 0x66, 0x31, 0x31, 0x39, 0x37, 0x32, 0x33, 0x38, 0x62, 0x33, 0x38, 0x66, 0x30, 0x32, 0x33, 0x33, 0x37, 0x32, 0x65, 0x37, 0x64, 0x66, 0x61, 0x66, 0x31, 0x35, 0x39, 0x37, 0x35, 0x66, 0x61, 0x38, 0x61, 0x34, 0x63, 0x34, 0x61, 0x31, 0x35, 0x61, 0x37, 0x62, 0x30, 0x65, 0x65, 0x36, 0x34, 0x36, 0x35, 0x33, 0x62, 0x61, 0x37, 0x61, 0x35, 0x64, 0x61, 0x63, 0x33, 0x62, 0x34, 0x30, 0x63, 0x33, 0x64, 0x33, 0x61, 0x64, 0x37, 0x32, 0x32, 0x63, 0x65, 0x39, 0x62, 0x62, 0x61, 0x63, 0x39, 0x39, 0x30, 0x66, 0x31, 0x34, 0x32, 0x30, 0x35, 0x33, 0x62, 0x36, 0x37, 0x63, 0x32, 0x39, 0x30, 0x64, 0x33, 0x65, 0x65, 0x64, 0x35, 0x35, 0x66, 0x61, 0x31, 0x33, 0x38, 0x36, 0x66, 0x33, 0x64, 0x33, 0x31, 0x63, 0x64, 0x66, 0x36, 0x66, 0x35, 0x31, 0x35, 0x38, 0x31, 0x65, 0x66, 0x39, 0x34, 0x32, 0x61, 0x31, 0x38, 0x38, 0x35, 0x34, 0x66, 0x66, 0x38, 0x64, 0x35, 0x35, 0x35, 0x31, 0x38, 0x37, 0x39, 0x61, 0x34, 0x61, 0x35, 0x62, 0x38, 0x66, 0x32, 0x31, 0x66, 0x62, 0x63, 0x35, 0x61, 0x33, 0x32, 0x32, 0x64, 0x32, 0x31, 0x35, 0x36, 0x34, 0x65, 0x63, 0x64, 0x62, 0x36, 0x62, 0x66, 0x37, 0x30, 0x62, 0x39, 0x30, 0x30, 0x33, 0x35, 0x33, 0x38, 0x37, 0x30, 0x38, 0x34, 0x65, 0x36, 0x35, 0x39, 0x61, 0x34, 0x36, 0x32, 0x32, 0x38, 0x38, 0x64, 0x35, 0x36, 0x62, 0x31, 0x36, 0x31, 0x37, 0x33, 0x34, 0x35, 0x37, 0x35, 0x36, 0x65, 0x30, 0x37, 0x33, 0x39, 0x39, 0x66, 0x34, 0x66, 0x65, 0x33, 0x31, 0x61, 0x63, 0x39, 0x65, 0x35, 0x36, 0x30, 0x34, 0x64, 0x63, 0x62, 0x33, 0x62, 0x33, 0x66, 0x37, 0x30, 0x34, 0x37, 0x34, 0x35, 0x33, 0x36, 0x31, 0x34, 0x36, 0x65, 0x65, 0x39, 0x35, 0x39, 0x61, 0x35, 0x62, 0x36, 0x35, 0x66, 0x38, 0x30, 0x36, 0x63, 0x34, 0x30, 0x32, 0x64, 0x34, 0x33, 0x64, 0x35, 0x66, 0x35, 0x32, 0x64, 0x34, 0x62, 0x63, 0x33, 0x65, 0x38, 0x30, 0x61, 0x38, 0x34, 0x65, 0x36, 0x30, 0x61, 0x30, 0x64, 0x38, 0x34, 0x63, 0x30, 0x64, 0x65, 0x62, 0x65, 0x34, 0x61, 0x34, 0x30, 0x39, 0x66, 0x35, 0x66, 0x65, 0x34, 0x34, 0x35, 0x33, 0x31, 0x35, 0x31, 0x61, 0x30, 0x63, 0x32, 0x62, 0x31, 0x30, 0x35, 0x66, 0x34, 0x35, 0x65, 0x33, 0x65, 0x63, 0x36, 0x32, 0x31, 0x39, 0x62, 0x30, 0x63, 0x65, 0x38, 0x36, 0x30, 0x36, 0x34, 0x33, 0x61, 0x37, 0x33, 0x33, 0x33, 0x37, 0x65, 0x62, 0x64, 0x38, 0x32, 0x37, 0x35, 0x65, 0x38, 0x64, 0x39, 0x66, 0x63, 0x66, 0x35, 0x37, 0x62, 0x34, 0x36, 0x30, 0x37, 0x63, 0x36, 0x61, 0x34, 0x38, 0x33, 0x39, 0x39, 0x34, 0x61, 0x62, 0x33, 0x32, 0x33, 0x62, 0x63, 0x64, 0x30, 0x65, 0x39, 0x39, 0x37, 0x30, 0x64, 0x39, 0x38, 0x39, 0x31, 0x39, 0x64, 0x65, 0x32, 0x38, 0x61, 0x35, 0x63, 0x64, 0x65, 0x33, 0x39, 0x30, 0x33, 0x31, 0x31, 0x61, 0x63, 0x61, 0x38, 0x31, 0x32, 0x39, 0x38, 0x64, 0x64, 0x63, 0x35, 0x39, 0x35, 0x35, 0x32, 0x31, 0x37, 0x34, 0x38, 0x30, 0x64, 0x66, 0x37, 0x65, 0x37, 0x63, 0x35, 0x34, 0x33, 0x30, 0x38, 0x33, 0x37, 0x32, 0x36, 0x33, 0x30, 0x39, 0x34, 0x34, 0x36, 0x37, 0x63, 0x61, 0x32, 0x63, 0x30, 0x63, 0x62, 0x63, 0x63, 0x37, 0x65, 0x39, 0x65, 0x37, 0x36, 0x36, 0x36, 0x32, 0x33, 0x39, 0x66, 0x30, 0x63, 0x66, 0x35, 0x35, 0x36, 0x34, 0x66, 0x37, 0x30, 0x35, 0x64, 0x32, 0x65, 0x61, 0x38, 0x65, 0x64, 0x61, 0x35, 0x30, 0x39, 0x62, 0x37, 0x37, 0x36, 0x35, 0x38, 0x37, 0x61, 0x36, 0x66, 0x33, 0x34, 0x30, 0x66, 0x37, 0x30, 0x34, 0x66, 0x65, 0x34, 0x33, 0x39, 0x61, 0x63, 0x65, 0x61, 0x63, 0x37, 0x62, 0x62, 0x61, 0x65, 0x39, 0x34, 0x38, 0x30, 0x36, 0x31, 0x34, 0x31, 0x31, 0x65, 0x61, 0x62, 0x31, 0x31, 0x32, 0x33, 0x30, 0x36, 0x33, 0x39, 0x39, 0x35, 0x37, 0x34, 0x37, 0x39, 0x38, 0x65, 0x61, 0x65, 0x38, 0x61, 0x31, 0x39, 0x63, 0x31, 0x35, 0x37, 0x66, 0x61, 0x37, 0x32, 0x37, 0x35, 0x39, 0x30, 0x39, 0x66, 0x61, 0x30, 0x62, 0x38, 0x61, 0x66, 0x36, 0x61, 0x30, 0x30, 0x66, 0x61, 0x32, 0x39, 0x34, 0x34, 0x36, 0x35, 0x31, 0x65, 0x34, 0x35, 0x66, 0x66, 0x36, 0x62, 0x35, 0x36, 0x66, 0x62, 0x62, 0x61, 0x64, 0x35, 0x65, 0x32, 0x37, 0x65, 0x36, 0x32, 0x65, 0x31, 0x30, 0x65, 0x30, 0x39, 0x65, 0x33, 0x36, 0x38, 0x36, 0x35, 0x30, 0x66, 0x36, 0x35, 0x64, 0x39, 0x39, 0x37, 0x32, 0x33, 0x61, 0x34, 0x64, 0x34, 0x33, 0x65, 0x63, 0x37, 0x34, 0x36, 0x33, 0x30, 0x30, 0x62, 0x64, 0x65, 0x39, 0x34, 0x65, 0x30, 0x61, 0x35, 0x62, 0x30, 0x31, 0x61, 0x32, 0x30, 0x64, 0x64, 0x38, 0x63, 0x64, 0x37, 0x38, 0x66, 0x36, 0x31, 0x66, 0x61, 0x39, 0x65, 0x65, 0x63, 0x32, 0x37, 0x61, 0x63, 0x30, 0x63, 0x36, 0x62, 0x30, 0x30, 0x31, 0x35, 0x35, 0x39, 0x35, 0x65, 0x61, 0x33, 0x31, 0x66, 0x38, 0x36, 0x33, 0x30, 0x66, 0x65, 0x32, 0x36, 0x31, 0x35, 0x34, 0x61, 0x39, 0x66, 0x65, 0x36, 0x31, 0x35, 0x63, 0x35, 0x39, 0x35, 0x32, 0x35, 0x33, 0x38, 0x35, 0x65, 0x31, 0x38, 0x62, 0x65, 0x33, 0x32, 0x30, 0x32, 0x66, 0x66, 0x66, 0x63, 0x33, 0x36, 0x37, 0x62, 0x65, 0x64, 0x35, 0x39, 0x34, 0x36, 0x33, 0x39, 0x63, 0x39, 0x62, 0x63, 0x64, 0x31, 0x38, 0x63, 0x36, 0x32, 0x35, 0x64, 0x34, 0x33, 0x34, 0x65, 0x34, 0x61, 0x63, 0x30, 0x34, 0x61, 0x38, 0x37, 0x34, 0x32, 0x62, 0x63, 0x39, 0x34, 0x65, 0x61, 0x37, 0x37, 0x30, 0x65, 0x38, 0x32, 0x64, 0x62, 0x63, 0x36, 0x36, 0x39, 0x64, 0x32, 0x34, 0x65, 0x39, 0x32, 0x36, 0x33, 0x64, 0x63, 0x63, 0x31, 0x30, 0x38, 0x35, 0x66, 0x62, 0x65, 0x61, 0x61, 0x39, 0x39, 0x61, 0x66, 0x64, 0x61, 0x39, 0x30, 0x64, 0x37, 0x32, 0x32, 0x66, 0x63, 0x31, 0x30, 0x32, 0x37, 0x35, 0x64, 0x30, 0x35, 0x32, 0x34, 0x31, 0x39, 0x38, 0x34, 0x34, 0x36, 0x63, 0x37, 0x66, 0x37, 0x32, 0x35, 0x30, 0x36, 0x63, 0x34, 0x66, 0x65, 0x37, 0x66, 0x39, 0x38, 0x39, 0x61, 0x64, 0x33, 0x35, 0x31, 0x66, 0x39, 0x37, 0x35, 0x62, 0x63, 0x35, 0x37, 0x32, 0x63, 0x35, 0x35, 0x38, 0x32, 0x66, 0x65, 0x38, 0x66, 0x34, 0x66, 0x36, 0x34, 0x37, 0x31, 0x33, 0x66, 0x38, 0x33, 0x66, 0x36, 0x35, 0x36, 0x64, 0x37, 0x34, 0x35, 0x62, 0x62, 0x61, 0x63, 0x65, 0x32, 0x66, 0x32, 0x35, 0x65, 0x64, 0x36, 0x35, 0x32, 0x39, 0x61, 0x35, 0x63, 0x38, 0x34, 0x38, 0x66, 0x33, 0x39, 0x38, 0x33, 0x36, 0x64, 0x66, 0x33, 0x35, 0x33, 0x31, 0x66, 0x31, 0x64, 0x36, 0x32, 0x38, 0x31, 0x39, 0x66, 0x39, 0x64, 0x37, 0x36, 0x39, 0x38, 0x32, 0x30, 0x36, 0x65, 0x31, 0x38, 0x38, 0x30, 0x31, 0x32, 0x37, 0x31, 0x39, 0x64, 0x62, 0x65, 0x35, 0x31, 0x33, 0x31, 0x66, 0x35, 0x30, 0x33, 0x63, 0x31, 0x62, 0x38, 0x64, 0x37, 0x62, 0x39, 0x34, 0x37, 0x32, 0x36, 0x35, 0x38, 0x65, 0x62, 0x62, 0x36, 0x38, 0x30, 0x66, 0x62, 0x36, 0x64, 0x32, 0x66, 0x63, 0x32, 0x66, 0x31, 0x65, 0x61, 0x39, 0x64, 0x35, 0x33, 0x33, 0x31, 0x65, 0x33, 0x35, 0x37, 0x32, 0x33, 0x39, 0x37, 0x64, 0x37, 0x63, 0x30, 0x30, 0x33, 0x34, 0x32, 0x63, 0x66, 0x32, 0x30, 0x65, 0x64, 0x33, 0x32, 0x64, 0x33, 0x63, 0x39, 0x63, 0x34, 0x65, 0x31, 0x62, 0x32, 0x30, 0x35, 0x64, 0x64, 0x33, 0x31, 0x61, 0x35, 0x64, 0x61, 0x62, 0x38, 0x36, 0x64, 0x37, 0x33, 0x61, 0x32, 0x61, 0x35, 0x39, 0x36, 0x37, 0x64, 0x33, 0x65, 0x61, 0x63, 0x61, 0x37, 0x31, 0x66, 0x39, 0x37, 0x32, 0x64, 0x64, 0x31, 0x33, 0x32, 0x34, 0x39, 0x35, 0x37, 0x36, 0x30, 0x37, 0x32, 0x65, 0x64, 0x66, 0x36, 0x38, 0x36, 0x36, 0x31, 0x34, 0x65, 0x34, 0x34, 0x61, 0x32, 0x37, 0x62, 0x37, 0x65, 0x35, 0x63, 0x39, 0x30, 0x30, 0x64, 0x33, 0x61, 0x61, 0x62, 0x37, 0x30, 0x33, 0x37, 0x39, 0x39, 0x65, 0x65, 0x66, 0x38, 0x34, 0x37, 0x61, 0x35, 0x65, 0x65, 0x61, 0x63, 0x33, 0x61, 0x63, 0x37, 0x32, 0x31, 0x62, 0x62, 0x61, 0x35, 0x34, 0x33, 0x62, 0x38, 0x61, 0x34, 0x32, 0x63, 0x37, 0x66, 0x36, 0x64, 0x62, 0x32, 0x30, 0x66, 0x64, 0x31, 0x65, 0x35, 0x32, 0x33, 0x34, 0x37, 0x34, 0x38, 0x39, 0x34, 0x38, 0x63, 0x32, 0x63, 0x37, 0x63, 0x66, 0x32, 0x30, 0x33, 0x62, 0x34, 0x36, 0x34, 0x61, 0x35, 0x30, 0x35, 0x35, 0x37, 0x37, 0x32, 0x65, 0x39, 0x34, 0x36, 0x63, 0x62, 0x63, 0x34, 0x62, 0x38, 0x33, 0x62, 0x64, 0x66, 0x35, 0x61, 0x64, 0x32, 0x32, 0x37, 0x65, 0x35, 0x31, 0x36, 0x62, 0x34, 0x66, 0x65, 0x38, 0x62, 0x32, 0x65, 0x61, 0x31, 0x30, 0x31, 0x37, 0x66, 0x31, 0x31, 0x62, 0x34, 0x33, 0x64, 0x65, 0x64, 0x35, 0x30, 0x33, 0x35, 0x32, 0x33, 0x63, 0x34, 0x30, 0x37, 0x62, 0x35, 0x32, 0x31, 0x66, 0x63, 0x36, 0x38, 0x65, 0x35, 0x36, 0x32, 0x36, 0x65, 0x37, 0x37, 0x32, 0x34, 0x36, 0x34, 0x38, 0x35, 0x33, 0x66, 0x63, 0x34, 0x39, 0x39, 0x64, 0x30, 0x66, 0x36, 0x37, 0x36, 0x35, 0x66, 0x38, 0x62, 0x63, 0x32, 0x62, 0x64, 0x64, 0x34, 0x35, 0x35, 0x62, 0x38, 0x66, 0x65, 0x33, 0x37, 0x33, 0x61, 0x35, 0x33, 0x61, 0x38, 0x62, 0x65, 0x38, 0x39, 0x65, 0x34, 0x32, 0x38, 0x62, 0x30, 0x65, 0x30, 0x66, 0x64, 0x64, 0x30, 0x36, 0x39, 0x32, 0x66, 0x61, 0x37, 0x32, 0x31, 0x62, 0x31, 0x39, 0x61, 0x65, 0x64, 0x35, 0x63, 0x64, 0x37, 0x38, 0x35, 0x33, 0x63, 0x35, 0x38, 0x63, 0x30, 0x64, 0x66, 0x38, 0x38, 0x31, 0x63, 0x38, 0x38, 0x63, 0x30, 0x36, 0x61, 0x66, 0x62, 0x34, 0x32, 0x39, 0x39, 0x33, 0x38, 0x38, 0x62, 0x31, 0x66, 0x62, 0x38, 0x38, 0x36, 0x61, 0x39, 0x63, 0x31, 0x62, 0x37, 0x38, 0x31, 0x35, 0x37, 0x36, 0x64, 0x65, 0x35, 0x35, 0x34, 0x34, 0x62, 0x62, 0x65, 0x34, 0x37, 0x62, 0x64, 0x62, 0x33, 0x34, 0x33, 0x65, 0x65, 0x37, 0x36, 0x37, 0x37, 0x66, 0x38, 0x34, 0x39, 0x37, 0x37, 0x65, 0x62, 0x37, 0x65, 0x31, 0x39, 0x37, 0x38, 0x36, 0x66, 0x34, 0x38, 0x33, 0x61, 0x61, 0x33, 0x61, 0x63, 0x65, 0x62, 0x34, 0x66, 0x35, 0x33, 0x39, 0x35, 0x31, 0x37, 0x62, 0x36, 0x61, 0x31, 0x37, 0x33, 0x34, 0x31, 0x65, 0x64, 0x34, 0x37, 0x32, 0x33, 0x30, 0x61, 0x34, 0x31, 0x30, 0x64, 0x64, 0x66, 0x64, 0x37, 0x39, 0x37, 0x62, 0x36, 0x33, 0x38, 0x38, 0x31, 0x65, 0x61, 0x33, 0x66, 0x35, 0x64, 0x38, 0x65, 0x66, 0x38, 0x62, 0x32, 0x35, 0x35, 0x66, 0x37, 0x31, 0x64, 0x64, 0x33, 0x64, 0x36, 0x36, 0x37, 0x65, 0x65, 0x37, 0x37, 0x64, 0x34, 0x61, 0x33, 0x63, 0x61, 0x38, 0x37, 0x39, 0x35, 0x30, 0x36, 0x33, 0x63, 0x35, 0x37, 0x32, 0x65, 0x32, 0x39, 0x61, 0x39, 0x32, 0x38, 0x66, 0x33, 0x65, 0x63, 0x33, 0x32, 0x31, 0x61, 0x38, 0x33, 0x39, 0x63, 0x35, 0x38, 0x31, 0x66, 0x61, 0x36, 0x36, 0x63, 0x35, 0x38, 0x65, 0x61, 0x61, 0x65, 0x63, 0x32, 0x31, 0x30, 0x32, 0x64, 0x61, 0x62, 0x33, 0x64, 0x66, 0x32, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x65, 0x31, 0x30, 0x38, 0x38, 0x31, 0x33, 0x35, 0x36, 0x65, 0x61, 0x37, 0x32, 0x32, 0x63, 0x30, 0x34, 0x62, 0x31, 0x65, 0x30, 0x64, 0x36, 0x36, 0x33, 0x39, 0x37, 0x39, 0x62, 0x33, 0x64, 0x36, 0x64, 0x32, 0x30, 0x39, 0x34, 0x63, 0x66, 0x65, 0x37, 0x61, 0x32, 0x38, 0x34, 0x65, 0x65, 0x31, 0x36, 0x30, 0x63, 0x37, 0x64, 0x61, 0x32, 0x30, 0x35, 0x37, 0x64, 0x66, 0x63, 0x35, 0x63, 0x34, 0x33, 0x65, 0x30, 0x34, 0x33, 0x38, 0x66, 0x31, 0x39, 0x63, 0x30, 0x37, 0x32, 0x61, 0x35, 0x35, 0x66, 0x66, 0x31, 0x63, 0x37, 0x35, 0x38, 0x61, 0x36, 0x64, 0x36, 0x33, 0x39, 0x32, 0x65, 0x61, 0x35, 0x38, 0x64, 0x34, 0x35, 0x36, 0x31, 0x35, 0x66, 0x38, 0x63, 0x37, 0x61, 0x64, 0x66, 0x66, 0x63, 0x61, 0x62, 0x64, 0x66, 0x33, 0x30, 0x35, 0x65, 0x38, 0x65, 0x36, 0x33, 0x62, 0x63, 0x63, 0x64, 0x35, 0x61, 0x33, 0x35, 0x64, 0x66, 0x37, 0x61, 0x31, 0x39, 0x32, 0x63, 0x37, 0x33, 0x61, 0x32, 0x34, 0x65, 0x33, 0x63, 0x31, 0x34, 0x64, 0x39, 0x66, 0x39, 0x33, 0x65, 0x63, 0x32, 0x65, 0x61, 0x32, 0x31, 0x63, 0x63, 0x64, 0x64, 0x33, 0x65, 0x32, 0x66, 0x38, 0x66, 0x33, 0x33, 0x33, 0x30, 0x33, 0x64, 0x33, 0x36, 0x62, 0x37, 0x39, 0x63, 0x64, 0x66, 0x36, 0x39, 0x63, 0x61, 0x61, 0x34, 0x61, 0x63, 0x39, 0x64, 0x32, 0x63, 0x37, 0x31, 0x64, 0x63, 0x35, 0x38, 0x39, 0x37, 0x32, 0x66, 0x39, 0x63, 0x37, 0x66, 0x61, 0x37, 0x34, 0x37, 0x64, 0x33, 0x34, 0x33, 0x33, 0x37, 0x63, 0x39, 0x35, 0x65, 0x34, 0x39, 0x31, 0x63, 0x35, 0x37, 0x31, 0x64, 0x38, 0x36, 0x63, 0x64, 0x61, 0x64, 0x39, 0x34, 0x39, 0x35, 0x38, 0x61, 0x39, 0x61, 0x37, 0x31, 0x30, 0x36, 0x31, 0x32, 0x63, 0x33, 0x64, 0x35, 0x61, 0x63, 0x33, 0x65, 0x64, 0x35, 0x37, 0x37, 0x37, 0x32, 0x34, 0x38, 0x38, 0x37, 0x61, 0x66, 0x32, 0x39, 0x64, 0x61, 0x39, 0x35, 0x36, 0x31, 0x35, 0x39, 0x31, 0x30, 0x64, 0x64, 0x35, 0x30, 0x66, 0x36, 0x64, 0x63, 0x64, 0x30, 0x66, 0x61, 0x32, 0x34, 0x62, 0x38, 0x33, 0x38, 0x35, 0x31, 0x37, 0x62, 0x37, 0x65, 0x34, 0x37, 0x65, 0x32, 0x65, 0x61, 0x31, 0x35, 0x33, 0x35, 0x62, 0x33, 0x31, 0x34, 0x64, 0x36, 0x63, 0x31, 0x38, 0x66, 0x37, 0x32, 0x65, 0x65, 0x65, 0x64, 0x35, 0x65, 0x66, 0x38, 0x35, 0x61, 0x34, 0x38, 0x33, 0x39, 0x30, 0x63, 0x39, 0x37, 0x64, 0x36, 0x31, 0x32, 0x30, 0x32, 0x34, 0x64, 0x61, 0x38, 0x61, 0x38, 0x32, 0x61, 0x62, 0x30, 0x37, 0x38, 0x63, 0x62, 0x39, 0x33, 0x39, 0x64, 0x65, 0x62, 0x33, 0x33, 0x63, 0x31, 0x32, 0x64, 0x30, 0x32, 0x64, 0x66, 0x31, 0x31, 0x34, 0x33, 0x62, 0x35, 0x62, 0x63, 0x36, 0x35, 0x63, 0x63, 0x63, 0x39, 0x61, 0x65, 0x39, 0x61, 0x36, 0x62, 0x62, 0x35, 0x62, 0x39, 0x33, 0x33, 0x61, 0x62, 0x61, 0x38, 0x34, 0x30, 0x33, 0x38, 0x38, 0x36, 0x63, 0x63, 0x66, 0x36, 0x63, 0x65, 0x32, 0x63, 0x39, 0x39, 0x30, 0x32, 0x36, 0x31, 0x66, 0x62, 0x34, 0x33, 0x30, 0x34, 0x37, 0x62, 0x30, 0x61, 0x66, 0x37, 0x63, 0x65, 0x32, 0x30, 0x63, 0x63, 0x36, 0x65, 0x38, 0x65, 0x34, 0x37, 0x38, 0x33, 0x37, 0x36, 0x65, 0x31, 0x62, 0x33, 0x39, 0x66, 0x66, 0x66, 0x66, 0x30, 0x61, 0x63, 0x36, 0x63, 0x32, 0x32, 0x35, 0x38, 0x65, 0x39, 0x62, 0x38, 0x37, 0x34, 0x66, 0x33, 0x30, 0x35, 0x34, 0x63, 0x30, 0x63, 0x30, 0x64, 0x37, 0x31, 0x62, 0x32, 0x61, 0x32, 0x63, 0x38, 0x65, 0x39, 0x32, 0x36, 0x34, 0x30, 0x36, 0x33, 0x35, 0x34, 0x64, 0x63, 0x37, 0x63, 0x38, 0x36, 0x32, 0x33, 0x30, 0x35, 0x66, 0x63, 0x36, 0x33, 0x62, 0x36, 0x35, 0x33, 0x36, 0x38, 0x63, 0x35, 0x64, 0x61, 0x31, 0x65, 0x65, 0x62, 0x31, 0x38, 0x65, 0x31, 0x38, 0x30, 0x30, 0x33, 0x65, 0x37, 0x31, 0x65, 0x35, 0x36, 0x37, 0x66, 0x33, 0x61, 0x34, 0x39, 0x66, 0x62, 0x62, 0x38, 0x63, 0x62, 0x38, 0x35, 0x36, 0x39, 0x37, 0x65, 0x61, 0x39, 0x64, 0x64, 0x33, 0x30, 0x63, 0x35, 0x35, 0x34, 0x35, 0x32, 0x61, 0x62, 0x35, 0x38, 0x30, 0x34, 0x34, 0x37, 0x34, 0x30, 0x34, 0x31, 0x65, 0x32, 0x64, 0x34, 0x34, 0x64, 0x33, 0x64, 0x32, 0x65, 0x36, 0x66, 0x37, 0x37, 0x37, 0x31, 0x34, 0x63, 0x65, 0x38, 0x36, 0x33, 0x37, 0x31, 0x32, 0x32, 0x33, 0x30, 0x66, 0x65, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, 0x61, 0x65, 0x34, 0x33, 0x32, 0x38, 0x66, 0x31, 0x66, 0x61, 0x31, 0x37, 0x61, 0x37, 0x35, 0x34, 0x65, 0x64, 0x62, 0x63, 0x64, 0x32, 0x62, 0x34, 0x65, 0x33, 0x38, 0x31, 0x33, 0x39, 0x38, 0x33, 0x33, 0x30, 0x39, 0x34, 0x62, 0x61, 0x66, 0x64, 0x62, 0x62, 0x64, 0x35, 0x38, 0x30, 0x32, 0x38, 0x38, 0x64, 0x65, 0x31, 0x62, 0x37, 0x31, 0x63, 0x39, 0x62, 0x30, 0x39, 0x31, 0x65, 0x63, 0x66, 0x34, 0x66, 0x63, 0x34, 0x30, 0x64, 0x34, 0x38, 0x37, 0x65, 0x38, 0x35, 0x64, 0x38, 0x37, 0x32, 0x30, 0x31, 0x35, 0x66, 0x38, 0x66, 0x33, 0x30, 0x38, 0x63, 0x34, 0x65, 0x33, 0x38, 0x33, 0x64, 0x39, 0x63, 0x65, 0x35, 0x37, 0x39, 0x38, 0x30, 0x63, 0x33, 0x31, 0x33, 0x36, 0x33, 0x63, 0x61, 0x37, 0x30, 0x65, 0x35, 0x63, 0x63, 0x39, 0x30, 0x37, 0x31, 0x33, 0x63, 0x36, 0x63, 0x66, 0x62, 0x39, 0x36, 0x39, 0x33, 0x61, 0x36, 0x61, 0x62, 0x37, 0x65, 0x64, 0x35, 0x30, 0x31, 0x37, 0x32, 0x38, 0x63, 0x36, 0x64, 0x33, 0x64, 0x64, 0x36, 0x36, 0x36, 0x66, 0x64, 0x30, 0x65, 0x63, 0x61, 0x38, 0x38, 0x30, 0x31, 0x63, 0x38, 0x66, 0x65, 0x64, 0x61, 0x61, 0x37, 0x64, 0x39, 0x33, 0x63, 0x63, 0x64, 0x32, 0x66, 0x36, 0x36, 0x30, 0x30, 0x65, 0x31, 0x65, 0x37, 0x37, 0x63, 0x37, 0x65, 0x33, 0x38, 0x39, 0x62, 0x38, 0x39, 0x37, 0x66, 0x35, 0x34, 0x63, 0x63, 0x30, 0x37, 0x37, 0x32, 0x33, 0x66, 0x61, 0x37, 0x65, 0x65, 0x63, 0x63, 0x39, 0x65, 0x32, 0x31, 0x63, 0x61, 0x36, 0x31, 0x62, 0x36, 0x37, 0x64, 0x30, 0x36, 0x34, 0x39, 0x37, 0x32, 0x62, 0x62, 0x31, 0x39, 0x64, 0x37, 0x66, 0x63, 0x64, 0x37, 0x30, 0x33, 0x61, 0x32, 0x32, 0x34, 0x37, 0x61, 0x64, 0x62, 0x39, 0x32, 0x63, 0x31, 0x37, 0x35, 0x36, 0x37, 0x65, 0x32, 0x39, 0x37, 0x62, 0x33, 0x38, 0x35, 0x37, 0x32, 0x30, 0x35, 0x62, 0x34, 0x62, 0x33, 0x66, 0x38, 0x64, 0x34, 0x36, 0x37, 0x65, 0x32, 0x66, 0x62, 0x33, 0x61, 0x31, 0x65, 0x38, 0x30, 0x32, 0x63, 0x66, 0x62, 0x30, 0x37, 0x37, 0x61, 0x38, 0x35, 0x35, 0x35, 0x65, 0x31, 0x35, 0x37, 0x30, 0x61, 0x61, 0x36, 0x66, 0x31, 0x62, 0x34, 0x62, 0x61, 0x34, 0x37, 0x32, 0x66, 0x39, 0x39, 0x34, 0x64, 0x38, 0x34, 0x65, 0x33, 0x32, 0x32, 0x32, 0x34, 0x31, 0x34, 0x37, 0x35, 0x66, 0x31, 0x37, 0x38, 0x66, 0x33, 0x39, 0x31, 0x34, 0x61, 0x31, 0x64, 0x61, 0x63, 0x31, 0x37, 0x30, 0x34, 0x34, 0x31, 0x31, 0x65, 0x30, 0x63, 0x65, 0x31, 0x61, 0x34, 0x35, 0x34, 0x35, 0x33, 0x39, 0x39, 0x31, 0x35, 0x34, 0x39, 0x32, 0x38, 0x32, 0x36, 0x63, 0x33, 0x63, 0x30, 0x66, 0x34, 0x32, 0x34, 0x34, 0x39, 0x63, 0x30, 0x64, 0x62, 0x37, 0x38, 0x33, 0x63, 0x36, 0x32, 0x61, 0x38, 0x35, 0x65, 0x36, 0x63, 0x30, 0x66, 0x65, 0x37, 0x36, 0x36, 0x66, 0x31, 0x30, 0x64, 0x32, 0x35, 0x34, 0x31, 0x66, 0x34, 0x38, 0x38, 0x36, 0x62, 0x36, 0x35, 0x36, 0x35, 0x36, 0x64, 0x38, 0x61, 0x33, 0x32, 0x65, 0x39, 0x32, 0x37, 0x37, 0x38, 0x33, 0x38, 0x39, 0x36, 0x35, 0x37, 0x37, 0x62, 0x61, 0x34, 0x31, 0x65, 0x30, 0x33, 0x34, 0x36, 0x34, 0x64, 0x35, 0x61, 0x34, 0x35, 0x64, 0x33, 0x38, 0x39, 0x36, 0x64, 0x65, 0x31, 0x38, 0x34, 0x64, 0x33, 0x34, 0x65, 0x61, 0x33, 0x39, 0x35, 0x38, 0x33, 0x61, 0x31, 0x62, 0x36, 0x37, 0x62, 0x65, 0x33, 0x30, 0x33, 0x38, 0x62, 0x33, 0x38, 0x63, 0x34, 0x32, 0x65, 0x61, 0x61, 0x33, 0x62, 0x66, 0x37, 0x37, 0x64, 0x34, 0x30, 0x66, 0x33, 0x62, 0x32, 0x31, 0x32, 0x37, 0x37, 0x36, 0x35, 0x31, 0x36, 0x37, 0x32, 0x30, 0x33, 0x39, 0x35, 0x36, 0x61, 0x30, 0x36, 0x32, 0x39, 0x31, 0x36, 0x33, 0x38, 0x61, 0x30, 0x34, 0x33, 0x37, 0x39, 0x61, 0x32, 0x37, 0x32, 0x63, 0x34, 0x37, 0x36, 0x66, 0x35, 0x37, 0x34, 0x61, 0x39, 0x61, 0x64, 0x30, 0x61, 0x32, 0x39, 0x61, 0x66, 0x35, 0x31, 0x38, 0x65, 0x31, 0x36, 0x35, 0x36, 0x36, 0x36, 0x33, 0x38, 0x31, 0x64, 0x63, 0x35, 0x30, 0x33, 0x30, 0x32, 0x32, 0x38, 0x31, 0x38, 0x30, 0x66, 0x38, 0x36, 0x30, 0x38, 0x32, 0x61, 0x36, 0x30, 0x63, 0x33, 0x38, 0x61, 0x65, 0x61, 0x34, 0x61, 0x35, 0x30, 0x36, 0x33, 0x38, 0x34, 0x64, 0x62, 0x33, 0x34, 0x33, 0x35, 0x33, 0x33, 0x66, 0x32, 0x66, 0x30, 0x31, 0x35, 0x66, 0x31, 0x33, 0x34, 0x37, 0x32, 0x35, 0x63, 0x64, 0x36, 0x66, 0x62, 0x38, 0x37, 0x38, 0x62, 0x32, 0x33, 0x66, 0x38, 0x66, 0x38, 0x30, 0x35, 0x66, 0x37, 0x65, 0x36, 0x36, 0x62, 0x36, 0x61, 0x35, 0x36, 0x33, 0x62, 0x35, 0x32, 0x38, 0x64, 0x61, 0x36, 0x66, 0x31, 0x33, 0x63, 0x62, 0x63, 0x35, 0x32, 0x30, 0x33, 0x32, 0x63, 0x64, 0x33, 0x30, 0x63, 0x62, 0x32, 0x62, 0x65, 0x34, 0x66, 0x37, 0x37, 0x65, 0x61, 0x62, 0x35, 0x63, 0x65, 0x35, 0x39, 0x30, 0x33, 0x66, 0x36, 0x34, 0x33, 0x34, 0x39, 0x66, 0x61, 0x32, 0x33, 0x37, 0x32, 0x39, 0x35, 0x63, 0x64, 0x34, 0x33, 0x66, 0x64, 0x62, 0x37, 0x35, 0x63, 0x66, 0x37, 0x63, 0x36, 0x63, 0x30, 0x38, 0x37, 0x61, 0x66, 0x31, 0x62, 0x66, 0x31, 0x30, 0x30, 0x39, 0x39, 0x33, 0x31, 0x33, 0x36, 0x33, 0x62, 0x37, 0x66, 0x36, 0x65, 0x34, 0x34, 0x36, 0x33, 0x37, 0x37, 0x35, 0x33, 0x64, 0x62, 0x36, 0x31, 0x64, 0x61, 0x66, 0x36, 0x66, 0x65, 0x32, 0x64, 0x38, 0x61, 0x34, 0x65, 0x38, 0x39, 0x35, 0x62, 0x33, 0x33, 0x31, 0x31, 0x33, 0x61, 0x34, 0x37, 0x65, 0x36, 0x63, 0x37, 0x32, 0x64, 0x33, 0x33, 0x61, 0x39, 0x30, 0x39, 0x31, 0x64, 0x65, 0x35, 0x38, 0x64, 0x35, 0x37, 0x61, 0x65, 0x66, 0x66, 0x33, 0x65, 0x32, 0x65, 0x66, 0x39, 0x61, 0x39, 0x65, 0x61, 0x65, 0x38, 0x31, 0x65, 0x61, 0x39, 0x64, 0x38, 0x62, 0x32, 0x63, 0x31, 0x37, 0x61, 0x35, 0x37, 0x31, 0x66, 0x34, 0x62, 0x31, 0x30, 0x35, 0x37, 0x39, 0x37, 0x63, 0x30, 0x61, 0x33, 0x35, 0x32, 0x39, 0x36, 0x31, 0x34, 0x31, 0x35, 0x61, 0x39, 0x61, 0x61, 0x34, 0x35, 0x37, 0x37, 0x36, 0x31, 0x63, 0x38, 0x66, 0x61, 0x39, 0x30, 0x39, 0x37, 0x66, 0x33, 0x37, 0x34, 0x37, 0x65, 0x39, 0x32, 0x35, 0x39, 0x65, 0x33, 0x39, 0x38, 0x63, 0x63, 0x34, 0x61, 0x31, 0x65, 0x31, 0x62, 0x66, 0x32, 0x37, 0x32, 0x63, 0x33, 0x61, 0x66, 0x38, 0x66, 0x39, 0x63, 0x36, 0x37, 0x65, 0x34, 0x39, 0x34, 0x33, 0x62, 0x36, 0x36, 0x64, 0x64, 0x64, 0x32, 0x36, 0x63, 0x32, 0x35, 0x62, 0x34, 0x30, 0x61, 0x38, 0x30, 0x66, 0x30, 0x63, 0x34, 0x38, 0x34, 0x62, 0x64, 0x31, 0x37, 0x32, 0x34, 0x39, 0x34, 0x37, 0x37, 0x34, 0x31, 0x61, 0x64, 0x61, 0x39, 0x36, 0x61, 0x38, 0x36, 0x63, 0x63, 0x31, 0x66, 0x37, 0x32, 0x30, 0x66, 0x62, 0x38, 0x34, 0x34, 0x37, 0x39, 0x65, 0x38, 0x32, 0x33, 0x66, 0x65, 0x30, 0x61, 0x31, 0x62, 0x34, 0x65, 0x66, 0x31, 0x30, 0x30, 0x33, 0x33, 0x30, 0x66, 0x34, 0x35, 0x34, 0x37, 0x62, 0x35, 0x61, 0x35, 0x33, 0x61, 0x39, 0x64, 0x38, 0x34, 0x34, 0x34, 0x39, 0x61, 0x39, 0x63, 0x36, 0x31, 0x65, 0x63, 0x32, 0x35, 0x65, 0x63, 0x32, 0x61, 0x61, 0x34, 0x63, 0x61, 0x37, 0x32, 0x32, 0x31, 0x39, 0x37, 0x32, 0x62, 0x31, 0x32, 0x33, 0x65, 0x65, 0x32, 0x39, 0x39, 0x39, 0x31, 0x32, 0x31, 0x33, 0x37, 0x38, 0x66, 0x31, 0x63, 0x39, 0x32, 0x61, 0x35, 0x62, 0x33, 0x64, 0x62, 0x61, 0x66, 0x36, 0x61, 0x61, 0x66, 0x64, 0x35, 0x34, 0x39, 0x66, 0x32, 0x32, 0x65, 0x33, 0x65, 0x37, 0x66, 0x39, 0x65, 0x62, 0x61, 0x61, 0x62, 0x63, 0x66, 0x62, 0x37, 0x37, 0x66, 0x37, 0x32, 0x64, 0x35, 0x32, 0x32, 0x31, 0x64, 0x64, 0x32, 0x61, 0x32, 0x37, 0x39, 0x38, 0x63, 0x62, 0x36, 0x30, 0x62, 0x66, 0x37, 0x37, 0x37, 0x32, 0x65, 0x34, 0x31, 0x62, 0x35, 0x33, 0x31, 0x30, 0x64, 0x35, 0x31, 0x32, 0x36, 0x61, 0x32, 0x35, 0x30, 0x33, 0x30, 0x32, 0x32, 0x36, 0x63, 0x30, 0x34, 0x66, 0x36, 0x39, 0x65, 0x36, 0x35, 0x38, 0x39, 0x34, 0x37, 0x37, 0x37, 0x30, 0x39, 0x37, 0x32, 0x37, 0x31, 0x64, 0x34, 0x33, 0x65, 0x32, 0x64, 0x64, 0x31, 0x38, 0x61, 0x63, 0x31, 0x63, 0x34, 0x38, 0x64, 0x62, 0x39, 0x30, 0x66, 0x34, 0x65, 0x38, 0x34, 0x34, 0x66, 0x32, 0x31, 0x61, 0x64, 0x31, 0x37, 0x62, 0x65, 0x36, 0x36, 0x62, 0x39, 0x37, 0x65, 0x38, 0x61, 0x33, 0x39, 0x35, 0x66, 0x33, 0x38, 0x61, 0x31, 0x30, 0x30, 0x62, 0x61, 0x32, 0x66, 0x61, 0x66, 0x33, 0x35, 0x33, 0x66, 0x62, 0x35, 0x35, 0x61, 0x64, 0x36, 0x30, 0x63, 0x36, 0x62, 0x65, 0x33, 0x34, 0x34, 0x62, 0x30, 0x61, 0x62, 0x61, 0x38, 0x63, 0x33, 0x36, 0x39, 0x61, 0x62, 0x64, 0x62, 0x34, 0x64, 0x39, 0x61, 0x34, 0x63, 0x62, 0x37, 0x63, 0x65, 0x64, 0x66, 0x38, 0x33, 0x30, 0x36, 0x32, 0x33, 0x61, 0x32, 0x37, 0x39, 0x39, 0x62, 0x63, 0x66, 0x64, 0x61, 0x32, 0x34, 0x33, 0x35, 0x32, 0x35, 0x36, 0x66, 0x37, 0x66, 0x38, 0x66, 0x39, 0x36, 0x63, 0x33, 0x34, 0x62, 0x66, 0x66, 0x32, 0x38, 0x39, 0x31, 0x34, 0x39, 0x34, 0x37, 0x66, 0x39, 0x65, 0x65, 0x39, 0x61, 0x37, 0x39, 0x39, 0x62, 0x37, 0x38, 0x32, 0x34, 0x31, 0x32, 0x38, 0x32, 0x66, 0x32, 0x61, 0x66, 0x33, 0x61, 0x64, 0x31, 0x64, 0x32, 0x37, 0x33, 0x66, 0x65, 0x31, 0x65, 0x35, 0x63, 0x39, 0x37, 0x64, 0x31, 0x65, 0x34, 0x37, 0x32, 0x32, 0x62, 0x35, 0x36, 0x37, 0x65, 0x64, 0x31, 0x34, 0x32, 0x66, 0x33, 0x36, 0x37, 0x31, 0x33, 0x63, 0x33, 0x31, 0x32, 0x31, 0x30, 0x37, 0x39, 0x61, 0x66, 0x30, 0x66, 0x66, 0x38, 0x36, 0x38, 0x63, 0x32, 0x32, 0x66, 0x61, 0x33, 0x37, 0x65, 0x31, 0x37, 0x37, 0x64, 0x30, 0x30, 0x35, 0x64, 0x64, 0x31, 0x62, 0x36, 0x61, 0x63, 0x35, 0x36, 0x64, 0x63, 0x62, 0x39, 0x66, 0x33, 0x37, 0x32, 0x61, 0x32, 0x63, 0x62, 0x66, 0x32, 0x39, 0x35, 0x36, 0x64, 0x31, 0x37, 0x66, 0x37, 0x32, 0x32, 0x65, 0x61, 0x39, 0x30, 0x34, 0x30, 0x38, 0x35, 0x34, 0x61, 0x62, 0x39, 0x37, 0x31, 0x32, 0x33, 0x62, 0x63, 0x39, 0x32, 0x39, 0x31, 0x64, 0x31, 0x65, 0x65, 0x61, 0x64, 0x63, 0x64, 0x37, 0x61, 0x33, 0x32, 0x61, 0x37, 0x32, 0x63, 0x33, 0x63, 0x37, 0x39, 0x38, 0x38, 0x63, 0x64, 0x37, 0x32, 0x39, 0x62, 0x63, 0x31, 0x38, 0x35, 0x32, 0x31, 0x30, 0x62, 0x32, 0x36, 0x36, 0x35, 0x38, 0x61, 0x37, 0x65, 0x37, 0x31, 0x36, 0x39, 0x34, 0x35, 0x38, 0x64, 0x66, 0x64, 0x33, 0x66, 0x34, 0x66, 0x31, 0x64, 0x35, 0x35, 0x66, 0x33, 0x31, 0x35, 0x38, 0x64, 0x66, 0x38, 0x37, 0x34, 0x35, 0x36, 0x39, 0x33, 0x36, 0x38, 0x35, 0x66, 0x39, 0x31, 0x32, 0x61, 0x39, 0x63, 0x31, 0x63, 0x32, 0x66, 0x66, 0x34, 0x61, 0x38, 0x39, 0x64, 0x63, 0x39, 0x62, 0x35, 0x33, 0x63, 0x34, 0x66, 0x34, 0x32, 0x38, 0x66, 0x64, 0x31, 0x36, 0x66, 0x62, 0x65, 0x38, 0x62, 0x63, 0x63, 0x34, 0x32, 0x62, 0x38, 0x38, 0x66, 0x36, 0x31, 0x34, 0x30, 0x63, 0x32, 0x38, 0x36, 0x32, 0x64, 0x66, 0x63, 0x62, 0x63, 0x32, 0x35, 0x32, 0x63, 0x35, 0x30, 0x64, 0x62, 0x39, 0x38, 0x61, 0x35, 0x65, 0x38, 0x37, 0x32, 0x65, 0x36, 0x66, 0x39, 0x31, 0x36, 0x30, 0x62, 0x31, 0x38, 0x39, 0x65, 0x38, 0x36, 0x66, 0x34, 0x36, 0x64, 0x63, 0x64, 0x36, 0x63, 0x32, 0x34, 0x37, 0x63, 0x31, 0x64, 0x35, 0x31, 0x35, 0x33, 0x62, 0x35, 0x65, 0x39, 0x31, 0x61, 0x63, 0x39, 0x30, 0x34, 0x38, 0x37, 0x37, 0x64, 0x65, 0x63, 0x32, 0x30, 0x37, 0x35, 0x37, 0x37, 0x64, 0x66, 0x32, 0x38, 0x31, 0x62, 0x61, 0x30, 0x31, 0x63, 0x35, 0x34, 0x66, 0x37, 0x63, 0x66, 0x34, 0x35, 0x65, 0x34, 0x62, 0x32, 0x32, 0x34, 0x63, 0x38, 0x63, 0x30, 0x64, 0x32, 0x63, 0x62, 0x63, 0x64, 0x65, 0x33, 0x65, 0x31, 0x66, 0x62, 0x37, 0x62, 0x32, 0x33, 0x65, 0x38, 0x39, 0x61, 0x35, 0x33, 0x62, 0x63, 0x31, 0x61, 0x64, 0x34, 0x66, 0x37, 0x66, 0x32, 0x32, 0x35, 0x65, 0x62, 0x30, 0x32, 0x35, 0x31, 0x65, 0x65, 0x65, 0x31, 0x32, 0x63, 0x63, 0x30, 0x31, 0x64, 0x65, 0x31, 0x35, 0x31, 0x61, 0x62, 0x32, 0x31, 0x62, 0x62, 0x30, 0x33, 0x62, 0x66, 0x34, 0x35, 0x30, 0x66, 0x66, 0x30, 0x31, 0x62, 0x38, 0x62, 0x33, 0x63, 0x32, 0x32, 0x34, 0x30, 0x33, 0x61, 0x37, 0x36, 0x30, 0x64, 0x31, 0x66, 0x31, 0x39, 0x32, 0x61, 0x32, 0x33, 0x31, 0x61, 0x31, 0x31, 0x39, 0x38, 0x62, 0x36, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x36, 0x38, 0x61, 0x62, 0x37, 0x33, 0x31, 0x37, 0x62, 0x34, 0x63, 0x34, 0x34, 0x37, 0x39, 0x31, 0x30, 0x31, 0x33, 0x63, 0x62, 0x38, 0x32, 0x37, 0x64, 0x63, 0x35, 0x35, 0x34, 0x39, 0x65, 0x33, 0x37, 0x33, 0x35, 0x63, 0x64, 0x33, 0x65, 0x32, 0x62, 0x65, 0x63, 0x37, 0x64, 0x32, 0x66, 0x65, 0x39, 0x61, 0x35, 0x65, 0x66, 0x61, 0x34, 0x34, 0x34, 0x35, 0x61, 0x32, 0x64, 0x64, 0x36, 0x66, 0x32, 0x61, 0x35, 0x61, 0x63, 0x38, 0x63, 0x32, 0x35, 0x66, 0x34, 0x32, 0x37, 0x65, 0x36, 0x34, 0x32, 0x36, 0x32, 0x34, 0x39, 0x61, 0x65, 0x37, 0x33, 0x37, 0x34, 0x31, 0x32, 0x35, 0x65, 0x37, 0x34, 0x38, 0x37, 0x33, 0x38, 0x36, 0x31, 0x35, 0x35, 0x30, 0x39, 0x35, 0x34, 0x61, 0x38, 0x33, 0x38, 0x36, 0x38, 0x37, 0x61, 0x35, 0x32, 0x63, 0x61, 0x34, 0x34, 0x37, 0x37, 0x32, 0x34, 0x65, 0x37, 0x32, 0x62, 0x65, 0x62, 0x34, 0x66, 0x37, 0x33, 0x35, 0x37, 0x66, 0x34, 0x35, 0x35, 0x66, 0x61, 0x32, 0x62, 0x35, 0x32, 0x31, 0x61, 0x63, 0x32, 0x37, 0x32, 0x33, 0x30, 0x38, 0x35, 0x36, 0x32, 0x34, 0x38, 0x39, 0x63, 0x37, 0x64, 0x32, 0x63, 0x30, 0x65, 0x33, 0x62, 0x61, 0x32, 0x36, 0x36, 0x32, 0x64, 0x34, 0x36, 0x38, 0x61, 0x66, 0x30, 0x61, 0x64, 0x36, 0x61, 0x39, 0x31, 0x33, 0x37, 0x32, 0x31, 0x39, 0x63, 0x61, 0x33, 0x33, 0x30, 0x35, 0x31, 0x31, 0x62, 0x30, 0x35, 0x34, 0x30, 0x65, 0x33, 0x63, 0x33, 0x64, 0x30, 0x31, 0x64, 0x39, 0x65, 0x32, 0x30, 0x36, 0x34, 0x39, 0x33, 0x34, 0x66, 0x35, 0x66, 0x32, 0x35, 0x33, 0x30, 0x34, 0x36, 0x61, 0x32, 0x63, 0x63, 0x37, 0x62, 0x31, 0x63, 0x65, 0x37, 0x66, 0x38, 0x36, 0x63, 0x37, 0x32, 0x37, 0x66, 0x62, 0x35, 0x63, 0x35, 0x65, 0x38, 0x38, 0x32, 0x39, 0x63, 0x64, 0x30, 0x36, 0x63, 0x63, 0x39, 0x33, 0x37, 0x63, 0x34, 0x33, 0x63, 0x33, 0x37, 0x31, 0x36, 0x37, 0x32, 0x34, 0x33, 0x34, 0x65, 0x30, 0x66, 0x33, 0x35, 0x33, 0x65, 0x30, 0x62, 0x63, 0x36, 0x38, 0x38, 0x66, 0x65, 0x33, 0x61, 0x35, 0x63, 0x32, 0x39, 0x38, 0x65, 0x66, 0x36, 0x39, 0x30, 0x35, 0x36, 0x36, 0x30, 0x31, 0x31, 0x39, 0x37, 0x39, 0x37, 0x32, 0x37, 0x31, 0x64, 0x61, 0x36, 0x63, 0x66, 0x65, 0x39, 0x30, 0x62, 0x66, 0x66, 0x64, 0x38, 0x64, 0x32, 0x37, 0x37, 0x30, 0x33, 0x63, 0x33, 0x39, 0x61, 0x38, 0x35, 0x37, 0x31, 0x38, 0x63, 0x34, 0x39, 0x62, 0x65, 0x30, 0x33, 0x31, 0x31, 0x65, 0x37, 0x38, 0x39, 0x61, 0x32, 0x30, 0x32, 0x62, 0x61, 0x64, 0x63, 0x32, 0x32, 0x39, 0x31, 0x39, 0x37, 0x34, 0x65, 0x33, 0x33, 0x62, 0x30, 0x32, 0x38, 0x64, 0x35, 0x33, 0x39, 0x65, 0x63, 0x64, 0x36, 0x63, 0x34, 0x33, 0x34, 0x37, 0x63, 0x62, 0x38, 0x37, 0x62, 0x39, 0x36, 0x38, 0x64, 0x33, 0x33, 0x33, 0x36, 0x35, 0x37, 0x32, 0x39, 0x66, 0x63, 0x32, 0x39, 0x64, 0x39, 0x36, 0x61, 0x32, 0x66, 0x61, 0x38, 0x39, 0x32, 0x65, 0x63, 0x33, 0x38, 0x34, 0x31, 0x33, 0x38, 0x32, 0x64, 0x38, 0x31, 0x37, 0x30, 0x36, 0x35, 0x63, 0x35, 0x38, 0x34, 0x38, 0x37, 0x33, 0x64, 0x64, 0x35, 0x36, 0x62, 0x62, 0x65, 0x66, 0x33, 0x62, 0x62, 0x32, 0x66, 0x61, 0x61, 0x36, 0x33, 0x32, 0x63, 0x34, 0x62, 0x35, 0x33, 0x31, 0x32, 0x37, 0x61, 0x36, 0x30, 0x65, 0x66, 0x32, 0x31, 0x33, 0x61, 0x65, 0x34, 0x65, 0x35, 0x61, 0x65, 0x34, 0x62, 0x36, 0x35, 0x61, 0x63, 0x33, 0x64, 0x66, 0x31, 0x36, 0x33, 0x30, 0x35, 0x34, 0x36, 0x38, 0x35, 0x65, 0x36, 0x33, 0x65, 0x65, 0x63, 0x36, 0x34, 0x64, 0x33, 0x30, 0x36, 0x32, 0x65, 0x38, 0x37, 0x66, 0x39, 0x61, 0x35, 0x62, 0x38, 0x30, 0x31, 0x33, 0x33, 0x31, 0x38, 0x39, 0x36, 0x61, 0x61, 0x36, 0x62, 0x30, 0x35, 0x34, 0x61, 0x39, 0x66, 0x33, 0x66, 0x37, 0x30, 0x63, 0x38, 0x65, 0x61, 0x30, 0x31, 0x34, 0x30, 0x32, 0x34, 0x34, 0x36, 0x39, 0x61, 0x64, 0x35, 0x39, 0x63, 0x39, 0x37, 0x32, 0x33, 0x36, 0x30, 0x37, 0x30, 0x34, 0x34, 0x39, 0x36, 0x35, 0x64, 0x32, 0x65, 0x33, 0x66, 0x37, 0x33, 0x33, 0x66, 0x38, 0x64, 0x61, 0x66, 0x37, 0x37, 0x39, 0x66, 0x31, 0x33, 0x34, 0x61, 0x30, 0x66, 0x38, 0x37, 0x34, 0x39, 0x36, 0x36, 0x65, 0x32, 0x34, 0x39, 0x36, 0x39, 0x36, 0x61, 0x38, 0x36, 0x39, 0x39, 0x38, 0x37, 0x64, 0x33, 0x62, 0x65, 0x32, 0x31, 0x63, 0x34, 0x33, 0x37, 0x32, 0x32, 0x63, 0x38, 0x37, 0x38, 0x36, 0x63, 0x35, 0x36, 0x65, 0x65, 0x61, 0x31, 0x66, 0x64, 0x66, 0x33, 0x36, 0x61, 0x63, 0x35, 0x33, 0x65, 0x63, 0x35, 0x62, 0x32, 0x37, 0x36, 0x64, 0x63, 0x33, 0x63, 0x37, 0x66, 0x38, 0x35, 0x65, 0x39, 0x61, 0x66, 0x37, 0x34, 0x37, 0x61, 0x63, 0x62, 0x62, 0x34, 0x30, 0x38, 0x64, 0x37, 0x33, 0x37, 0x35, 0x61, 0x33, 0x30, 0x32, 0x62, 0x33, 0x34, 0x33, 0x66, 0x32, 0x34, 0x65, 0x66, 0x36, 0x30, 0x63, 0x66, 0x37, 0x31, 0x61, 0x38, 0x33, 0x30, 0x65, 0x38, 0x33, 0x38, 0x37, 0x64, 0x33, 0x32, 0x34, 0x36, 0x66, 0x61, 0x33, 0x61, 0x37, 0x34, 0x32, 0x38, 0x38, 0x33, 0x61, 0x31, 0x64, 0x39, 0x62, 0x39, 0x66, 0x36, 0x65, 0x34, 0x38, 0x64, 0x66, 0x66, 0x65, 0x36, 0x31, 0x38, 0x64, 0x33, 0x63, 0x63, 0x38, 0x32, 0x31, 0x36, 0x39, 0x32, 0x39, 0x62, 0x31, 0x63, 0x35, 0x32, 0x61, 0x33, 0x32, 0x65, 0x31, 0x30, 0x39, 0x33, 0x33, 0x33, 0x63, 0x30, 0x37, 0x66, 0x64, 0x61, 0x31, 0x36, 0x64, 0x31, 0x31, 0x36, 0x39, 0x63, 0x61, 0x38, 0x64, 0x65, 0x38, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x65, 0x38, 0x64, 0x64, 0x31, 0x36, 0x31, 0x32, 0x63, 0x65, 0x63, 0x37, 0x31, 0x61, 0x34, 0x64, 0x30, 0x35, 0x31, 0x30, 0x66, 0x35, 0x36, 0x33, 0x32, 0x36, 0x64, 0x32, 0x64, 0x65, 0x65, 0x62, 0x62, 0x31, 0x38, 0x65, 0x61, 0x64, 0x32, 0x36, 0x37, 0x31, 0x32, 0x66, 0x39, 0x37, 0x35, 0x66, 0x65, 0x62, 0x64, 0x32, 0x33, 0x61, 0x34, 0x35, 0x36, 0x39, 0x30, 0x35, 0x66, 0x30, 0x39, 0x62, 0x39, 0x31, 0x37, 0x62, 0x66, 0x37, 0x38, 0x34, 0x31, 0x61, 0x64, 0x37, 0x32, 0x61, 0x63, 0x30, 0x66, 0x33, 0x36, 0x61, 0x66, 0x33, 0x30, 0x66, 0x66, 0x31, 0x66, 0x62, 0x31, 0x65, 0x30, 0x63, 0x62, 0x61, 0x62, 0x65, 0x30, 0x31, 0x38, 0x61, 0x33, 0x33, 0x34, 0x36, 0x62, 0x34, 0x36, 0x35, 0x31, 0x33, 0x39, 0x30, 0x30, 0x30, 0x32, 0x31, 0x32, 0x33, 0x30, 0x62, 0x37, 0x37, 0x38, 0x33, 0x62, 0x36, 0x65, 0x33, 0x37, 0x65, 0x31, 0x65, 0x64, 0x63, 0x63, 0x35, 0x35, 0x65, 0x32, 0x30, 0x37, 0x38, 0x32, 0x30, 0x65, 0x38, 0x34, 0x33, 0x38, 0x31, 0x33, 0x62, 0x37, 0x66, 0x30, 0x62, 0x64, 0x35, 0x31, 0x65, 0x35, 0x31, 0x33, 0x35, 0x39, 0x37, 0x39, 0x39, 0x35, 0x66, 0x30, 0x33, 0x62, 0x34, 0x35, 0x38, 0x38, 0x34, 0x38, 0x38, 0x36, 0x66, 0x65, 0x36, 0x30, 0x66, 0x61, 0x38, 0x65, 0x63, 0x39, 0x32, 0x34, 0x65, 0x38, 0x31, 0x34, 0x34, 0x64, 0x64, 0x36, 0x61, 0x36, 0x30, 0x63, 0x34, 0x37, 0x36, 0x66, 0x66, 0x30, 0x63, 0x30, 0x61, 0x30, 0x39, 0x37, 0x38, 0x31, 0x37, 0x38, 0x33, 0x61, 0x62, 0x35, 0x65, 0x35, 0x32, 0x32, 0x32, 0x38, 0x33, 0x30, 0x37, 0x37, 0x63, 0x63, 0x35, 0x38, 0x39, 0x38, 0x31, 0x64, 0x35, 0x33, 0x31, 0x35, 0x66, 0x33, 0x64, 0x33, 0x66, 0x35, 0x33, 0x38, 0x64, 0x35, 0x32, 0x31, 0x32, 0x39, 0x36, 0x61, 0x35, 0x35, 0x64, 0x36, 0x65, 0x32, 0x32, 0x61, 0x38, 0x63, 0x63, 0x37, 0x32, 0x64, 0x34, 0x33, 0x37, 0x65, 0x31, 0x61, 0x39, 0x66, 0x35, 0x66, 0x64, 0x31, 0x62, 0x66, 0x30, 0x35, 0x34, 0x33, 0x31, 0x33, 0x62, 0x65, 0x65, 0x35, 0x32, 0x34, 0x63, 0x32, 0x62, 0x34, 0x36, 0x65, 0x38, 0x38, 0x34, 0x66, 0x64, 0x39, 0x64, 0x62, 0x37, 0x37, 0x66, 0x64, 0x63, 0x30, 0x30, 0x34, 0x61, 0x36, 0x38, 0x30, 0x39, 0x32, 0x33, 0x34, 0x34, 0x62, 0x34, 0x32, 0x35, 0x33, 0x31, 0x64, 0x63, 0x65, 0x36, 0x64, 0x32, 0x63, 0x62, 0x38, 0x65, 0x33, 0x36, 0x64, 0x37, 0x36, 0x30, 0x63, 0x38, 0x39, 0x34, 0x32, 0x65, 0x62, 0x65, 0x61, 0x34, 0x66, 0x39, 0x30, 0x32, 0x63, 0x64, 0x61, 0x31, 0x30, 0x37, 0x39, 0x62, 0x65, 0x63, 0x34, 0x38, 0x66, 0x61, 0x36, 0x35, 0x62, 0x33, 0x61, 0x66, 0x62, 0x30, 0x31, 0x39, 0x61, 0x35, 0x66, 0x30, 0x34, 0x37, 0x37, 0x35, 0x35, 0x64, 0x33, 0x61, 0x33, 0x30, 0x61, 0x38, 0x30, 0x38, 0x61, 0x34, 0x61, 0x66, 0x31, 0x37, 0x33, 0x65, 0x65, 0x65, 0x61, 0x65, 0x38, 0x63, 0x34, 0x62, 0x34, 0x63, 0x30, 0x35, 0x38, 0x34, 0x38, 0x64, 0x64, 0x63, 0x30, 0x33, 0x37, 0x33, 0x63, 0x36, 0x30, 0x35, 0x63, 0x38, 0x37, 0x37, 0x37, 0x65, 0x61, 0x38, 0x36, 0x63, 0x34, 0x64, 0x62, 0x34, 0x65, 0x32, 0x63, 0x36, 0x36, 0x31, 0x37, 0x32, 0x35, 0x39, 0x62, 0x66, 0x61, 0x30, 0x65, 0x31, 0x65, 0x34, 0x33, 0x36, 0x32, 0x39, 0x31, 0x66, 0x30, 0x33, 0x38, 0x38, 0x61, 0x66, 0x31, 0x63, 0x35, 0x64, 0x66, 0x35, 0x31, 0x62, 0x35, 0x38, 0x35, 0x64, 0x63, 0x62, 0x39, 0x61, 0x64, 0x61, 0x36, 0x33, 0x62, 0x37, 0x37, 0x39, 0x39, 0x30, 0x35, 0x65, 0x63, 0x36, 0x38, 0x35, 0x34, 0x63, 0x63, 0x33, 0x37, 0x62, 0x37, 0x63, 0x37, 0x32, 0x38, 0x35, 0x66, 0x63, 0x66, 0x66, 0x65, 0x66, 0x34, 0x35, 0x39, 0x63, 0x61, 0x61, 0x65, 0x61, 0x65, 0x38, 0x31, 0x62, 0x35, 0x36, 0x32, 0x66, 0x39, 0x63, 0x65, 0x38, 0x39, 0x34, 0x38, 0x32, 0x37, 0x39, 0x64, 0x34, 0x31, 0x66, 0x63, 0x64, 0x37, 0x39, 0x35, 0x34, 0x31, 0x61, 0x61, 0x37, 0x61, 0x65, 0x37, 0x64, 0x62, 0x66, 0x35, 0x31, 0x38, 0x31, 0x30, 0x63, 0x38, 0x64, 0x37, 0x32, 0x30, 0x65, 0x33, 0x62, 0x31, 0x64, 0x64, 0x31, 0x31, 0x39, 0x32, 0x30, 0x62, 0x32, 0x36, 0x39, 0x62, 0x30, 0x63, 0x61, 0x66, 0x33, 0x35, 0x36, 0x66, 0x39, 0x61, 0x30, 0x32, 0x30, 0x65, 0x30, 0x37, 0x65, 0x38, 0x63, 0x63, 0x35, 0x66, 0x34, 0x36, 0x62, 0x65, 0x66, 0x66, 0x30, 0x64, 0x35, 0x62, 0x65, 0x35, 0x62, 0x33, 0x62, 0x35, 0x38, 0x32, 0x61, 0x35, 0x33, 0x37, 0x37, 0x37, 0x32, 0x61, 0x34, 0x61, 0x34, 0x30, 0x39, 0x38, 0x35, 0x31, 0x34, 0x61, 0x65, 0x32, 0x33, 0x65, 0x66, 0x66, 0x39, 0x65, 0x31, 0x33, 0x32, 0x39, 0x31, 0x63, 0x64, 0x37, 0x33, 0x30, 0x34, 0x37, 0x64, 0x62, 0x39, 0x65, 0x33, 0x34, 0x30, 0x36, 0x65, 0x62, 0x65, 0x30, 0x34, 0x64, 0x37, 0x37, 0x61, 0x64, 0x33, 0x66, 0x33, 0x62, 0x32, 0x64, 0x31, 0x35, 0x38, 0x32, 0x35, 0x33, 0x37, 0x34, 0x31, 0x65, 0x65, 0x34, 0x38, 0x33, 0x30, 0x38, 0x64, 0x65, 0x31, 0x34, 0x62, 0x36, 0x64, 0x34, 0x39, 0x33, 0x36, 0x62, 0x36, 0x66, 0x30, 0x62, 0x32, 0x34, 0x62, 0x30, 0x65, 0x37, 0x63, 0x33, 0x36, 0x62, 0x34, 0x37, 0x30, 0x63, 0x63, 0x32, 0x66, 0x61, 0x63, 0x63, 0x65, 0x61, 0x37, 0x64, 0x34, 0x38, 0x30, 0x35, 0x33, 0x61, 0x33, 0x35, 0x33, 0x33, 0x34, 0x36, 0x33, 0x34, 0x38, 0x37, 0x32, 0x34, 0x31, 0x32, 0x65, 0x30, 0x36, 0x37, 0x32, 0x30, 0x66, 0x37, 0x36, 0x64, 0x38, 0x36, 0x33, 0x32, 0x34, 0x62, 0x64, 0x63, 0x30, 0x66, 0x37, 0x65, 0x66, 0x31, 0x32, 0x34, 0x36, 0x34, 0x37, 0x37, 0x64, 0x36, 0x31, 0x63, 0x65, 0x31, 0x34, 0x34, 0x39, 0x66, 0x61, 0x38, 0x32, 0x31, 0x66, 0x33, 0x39, 0x61, 0x38, 0x36, 0x65, 0x33, 0x61, 0x30, 0x30, 0x36, 0x66, 0x35, 0x61, 0x37, 0x32, 0x65, 0x64, 0x34, 0x33, 0x32, 0x30, 0x62, 0x30, 0x66, 0x31, 0x65, 0x63, 0x65, 0x35, 0x64, 0x30, 0x34, 0x34, 0x34, 0x66, 0x65, 0x61, 0x63, 0x62, 0x64, 0x30, 0x36, 0x64, 0x65, 0x35, 0x35, 0x64, 0x32, 0x33, 0x65, 0x65, 0x39, 0x36, 0x33, 0x36, 0x64, 0x35, 0x37, 0x37, 0x34, 0x61, 0x62, 0x32, 0x62, 0x61, 0x63, 0x66, 0x32, 0x39, 0x35, 0x37, 0x35, 0x32, 0x62, 0x37, 0x39, 0x34, 0x33, 0x38, 0x38, 0x34, 0x62, 0x35, 0x33, 0x31, 0x35, 0x39, 0x39, 0x37, 0x32, 0x30, 0x65, 0x33, 0x66, 0x32, 0x65, 0x66, 0x39, 0x39, 0x39, 0x31, 0x39, 0x61, 0x34, 0x34, 0x62, 0x31, 0x33, 0x62, 0x62, 0x33, 0x38, 0x63, 0x32, 0x37, 0x37, 0x37, 0x37, 0x31, 0x64, 0x62, 0x37, 0x35, 0x35, 0x38, 0x32, 0x66, 0x61, 0x66, 0x65, 0x36, 0x36, 0x39, 0x31, 0x61, 0x66, 0x32, 0x31, 0x32, 0x36, 0x38, 0x37, 0x32, 0x65, 0x32, 0x34, 0x63, 0x62, 0x39, 0x38, 0x65, 0x30, 0x65, 0x33, 0x62, 0x62, 0x32, 0x36, 0x33, 0x32, 0x61, 0x39, 0x63, 0x31, 0x32, 0x36, 0x65, 0x37, 0x64, 0x38, 0x34, 0x65, 0x66, 0x30, 0x66, 0x66, 0x62, 0x35, 0x33, 0x30, 0x63, 0x64, 0x30, 0x39, 0x63, 0x36, 0x65, 0x65, 0x62, 0x34, 0x31, 0x39, 0x32, 0x65, 0x61, 0x65, 0x61, 0x39, 0x61, 0x37, 0x37, 0x37, 0x65, 0x65, 0x65, 0x34, 0x37, 0x36, 0x65, 0x65, 0x36, 0x66, 0x32, 0x62, 0x63, 0x63, 0x64, 0x63, 0x39, 0x39, 0x65, 0x31, 0x39, 0x64, 0x64, 0x34, 0x62, 0x31, 0x38, 0x30, 0x66, 0x32, 0x38, 0x61, 0x39, 0x38, 0x36, 0x38, 0x34, 0x65, 0x34, 0x35, 0x35, 0x61, 0x30, 0x63, 0x38, 0x31, 0x62, 0x31, 0x31, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x30, 0x65, 0x62, 0x38, 0x33, 0x62, 0x30, 0x32, 0x62, 0x62, 0x33, 0x30, 0x33, 0x30, 0x37, 0x39, 0x34, 0x63, 0x33, 0x32, 0x36, 0x61, 0x63, 0x61, 0x65, 0x30, 0x65, 0x62, 0x65, 0x31, 0x35, 0x35, 0x38, 0x37, 0x61, 0x64, 0x63, 0x61, 0x66, 0x61, 0x34, 0x64, 0x36, 0x65, 0x64, 0x32, 0x37, 0x34, 0x37, 0x38, 0x35, 0x33, 0x30, 0x61, 0x37, 0x65, 0x62, 0x66, 0x30, 0x33, 0x64, 0x30, 0x35, 0x39, 0x34, 0x37, 0x63, 0x35, 0x33, 0x30, 0x39, 0x65, 0x39, 0x65, 0x32, 0x36, 0x36, 0x63, 0x31, 0x39, 0x34, 0x33, 0x63, 0x33, 0x30, 0x33, 0x37, 0x38, 0x30, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x32, 0x61, 0x39, 0x38, 0x33, 0x33, 0x31, 0x30, 0x36, 0x36, 0x63, 0x61, 0x31, 0x36, 0x37, 0x36, 0x64, 0x65, 0x61, 0x66, 0x34, 0x33, 0x36, 0x64, 0x38, 0x61, 0x65, 0x30, 0x61, 0x62, 0x36, 0x63, 0x64, 0x63, 0x66, 0x38, 0x62, 0x34, 0x38, 0x38, 0x32, 0x61, 0x39, 0x37, 0x32, 0x35, 0x63, 0x38, 0x62, 0x33, 0x34, 0x62, 0x33, 0x37, 0x64, 0x62, 0x63, 0x30, 0x36, 0x32, 0x63, 0x66, 0x63, 0x35, 0x38, 0x30, 0x30, 0x30, 0x37, 0x65, 0x65, 0x64, 0x35, 0x39, 0x37, 0x39, 0x33, 0x66, 0x30, 0x31, 0x31, 0x61, 0x66, 0x30, 0x38, 0x37, 0x30, 0x39, 0x33, 0x39, 0x35, 0x61, 0x35, 0x61, 0x39, 0x62, 0x66, 0x34, 0x31, 0x61, 0x38, 0x62, 0x61, 0x63, 0x36, 0x36, 0x38, 0x31, 0x39, 0x39, 0x36, 0x31, 0x61, 0x36, 0x37, 0x39, 0x30, 0x64, 0x31, 0x30, 0x37, 0x36, 0x61, 0x63, 0x30, 0x63, 0x37, 0x61, 0x37, 0x36, 0x66, 0x66, 0x39, 0x35, 0x62, 0x62, 0x33, 0x66, 0x39, 0x31, 0x34, 0x62, 0x33, 0x34, 0x31, 0x64, 0x62, 0x30, 0x63, 0x61, 0x30, 0x62, 0x35, 0x32, 0x66, 0x38, 0x32, 0x34, 0x63, 0x31, 0x32, 0x63, 0x64, 0x65, 0x31, 0x65, 0x65, 0x33, 0x66, 0x31, 0x36, 0x37, 0x32, 0x37, 0x62, 0x65, 0x34, 0x37, 0x62, 0x62, 0x39, 0x62, 0x39, 0x30, 0x66, 0x61, 0x65, 0x37, 0x65, 0x35, 0x34, 0x36, 0x33, 0x66, 0x33, 0x61, 0x65, 0x66, 0x39, 0x61, 0x33, 0x32, 0x39, 0x61, 0x34, 0x35, 0x32, 0x39, 0x36, 0x33, 0x37, 0x66, 0x61, 0x63, 0x62, 0x37, 0x62, 0x30, 0x33, 0x37, 0x63, 0x36, 0x65, 0x33, 0x31, 0x32, 0x37, 0x35, 0x63, 0x35, 0x37, 0x64, 0x65, 0x32, 0x30, 0x37, 0x32, 0x62, 0x31, 0x39, 0x64, 0x33, 0x37, 0x64, 0x35, 0x64, 0x33, 0x35, 0x33, 0x33, 0x35, 0x36, 0x62, 0x32, 0x33, 0x37, 0x37, 0x32, 0x35, 0x34, 0x62, 0x61, 0x33, 0x65, 0x32, 0x33, 0x38, 0x62, 0x65, 0x35, 0x36, 0x62, 0x30, 0x38, 0x30, 0x36, 0x64, 0x62, 0x32, 0x66, 0x61, 0x31, 0x65, 0x30, 0x31, 0x63, 0x33, 0x64, 0x62, 0x62, 0x63, 0x64, 0x32, 0x66, 0x33, 0x33, 0x36, 0x30, 0x30, 0x37, 0x32, 0x31, 0x36, 0x61, 0x36, 0x31, 0x65, 0x30, 0x37, 0x35, 0x34, 0x65, 0x34, 0x64, 0x63, 0x61, 0x30, 0x64, 0x34, 0x31, 0x61, 0x36, 0x66, 0x36, 0x39, 0x39, 0x38, 0x38, 0x36, 0x37, 0x39, 0x63, 0x32, 0x63, 0x31, 0x35, 0x39, 0x63, 0x63, 0x38, 0x64, 0x31, 0x30, 0x32, 0x33, 0x31, 0x66, 0x33, 0x35, 0x64, 0x33, 0x65, 0x31, 0x33, 0x37, 0x62, 0x35, 0x64, 0x63, 0x62, 0x64, 0x38, 0x61, 0x37, 0x32, 0x61, 0x31, 0x62, 0x30, 0x39, 0x38, 0x39, 0x63, 0x34, 0x32, 0x39, 0x33, 0x61, 0x30, 0x30, 0x37, 0x33, 0x36, 0x38, 0x39, 0x30, 0x65, 0x39, 0x61, 0x30, 0x62, 0x37, 0x34, 0x38, 0x62, 0x65, 0x38, 0x38, 0x36, 0x38, 0x62, 0x34, 0x30, 0x63, 0x31, 0x65, 0x36, 0x39, 0x39, 0x36, 0x34, 0x61, 0x63, 0x65, 0x35, 0x30, 0x61, 0x37, 0x32, 0x63, 0x31, 0x32, 0x61, 0x64, 0x63, 0x61, 0x30, 0x37, 0x32, 0x39, 0x38, 0x34, 0x32, 0x66, 0x63, 0x35, 0x64, 0x62, 0x37, 0x63, 0x62, 0x65, 0x31, 0x34, 0x64, 0x64, 0x34, 0x39, 0x35, 0x62, 0x35, 0x66, 0x65, 0x39, 0x62, 0x39, 0x31, 0x37, 0x31, 0x37, 0x35, 0x32, 0x66, 0x34, 0x37, 0x61, 0x62, 0x64, 0x66, 0x35, 0x35, 0x66, 0x64, 0x30, 0x32, 0x66, 0x62, 0x63, 0x33, 0x63, 0x35, 0x36, 0x65, 0x35, 0x61, 0x31, 0x66, 0x38, 0x37, 0x30, 0x35, 0x37, 0x32, 0x30, 0x32, 0x61, 0x63, 0x65, 0x30, 0x34, 0x65, 0x37, 0x63, 0x33, 0x63, 0x34, 0x39, 0x62, 0x33, 0x61, 0x37, 0x37, 0x61, 0x63, 0x62, 0x36, 0x65, 0x61, 0x36, 0x34, 0x63, 0x64, 0x66, 0x64, 0x31, 0x62, 0x31, 0x34, 0x36, 0x62, 0x30, 0x65, 0x33, 0x33, 0x39, 0x36, 0x37, 0x62, 0x36, 0x31, 0x30, 0x36, 0x65, 0x64, 0x31, 0x61, 0x32, 0x35, 0x64, 0x31, 0x31, 0x37, 0x32, 0x30, 0x37, 0x37, 0x32, 0x34, 0x36, 0x32, 0x61, 0x38, 0x36, 0x62, 0x61, 0x36, 0x65, 0x35, 0x31, 0x32, 0x34, 0x65, 0x61, 0x64, 0x38, 0x31, 0x66, 0x33, 0x66, 0x39, 0x66, 0x33, 0x62, 0x61, 0x34, 0x63, 0x31, 0x30, 0x61, 0x66, 0x34, 0x66, 0x61, 0x64, 0x34, 0x30, 0x62, 0x36, 0x32, 0x37, 0x39, 0x39, 0x64, 0x65, 0x61, 0x61, 0x34, 0x38, 0x34, 0x62, 0x62, 0x37, 0x31, 0x34, 0x31, 0x63, 0x35, 0x32, 0x31, 0x36, 0x62, 0x38, 0x62, 0x62, 0x64, 0x63, 0x39, 0x36, 0x36, 0x64, 0x31, 0x63, 0x35, 0x61, 0x63, 0x61, 0x32, 0x35, 0x63, 0x64, 0x63, 0x66, 0x64, 0x64, 0x32, 0x64, 0x32, 0x36, 0x65, 0x37, 0x37, 0x33, 0x34, 0x62, 0x65, 0x61, 0x31, 0x64, 0x32, 0x34, 0x39, 0x63, 0x66, 0x62, 0x35, 0x36, 0x61, 0x65, 0x39, 0x63, 0x38, 0x38, 0x32, 0x33, 0x36, 0x36, 0x64, 0x64, 0x31, 0x33, 0x33, 0x61, 0x66, 0x37, 0x32, 0x31, 0x31, 0x64, 0x66, 0x37, 0x33, 0x38, 0x39, 0x36, 0x31, 0x64, 0x65, 0x34, 0x63, 0x64, 0x36, 0x39, 0x64, 0x62, 0x64, 0x31, 0x61, 0x38, 0x66, 0x34, 0x35, 0x39, 0x64, 0x36, 0x61, 0x62, 0x63, 0x65, 0x62, 0x66, 0x34, 0x31, 0x64, 0x32, 0x33, 0x61, 0x34, 0x32, 0x32, 0x36, 0x65, 0x65, 0x61, 0x34, 0x37, 0x31, 0x35, 0x30, 0x37, 0x34, 0x66, 0x64, 0x62, 0x35, 0x35, 0x35, 0x37, 0x37, 0x32, 0x62, 0x31, 0x35, 0x66, 0x62, 0x32, 0x34, 0x61, 0x38, 0x64, 0x31, 0x34, 0x34, 0x36, 0x62, 0x30, 0x38, 0x33, 0x32, 0x61, 0x34, 0x33, 0x33, 0x32, 0x37, 0x61, 0x32, 0x36, 0x30, 0x34, 0x35, 0x64, 0x34, 0x65, 0x39, 0x35, 0x38, 0x30, 0x35, 0x61, 0x61, 0x33, 0x38, 0x64, 0x37, 0x34, 0x35, 0x62, 0x30, 0x65, 0x61, 0x35, 0x31, 0x39, 0x63, 0x34, 0x36, 0x36, 0x35, 0x36, 0x35, 0x31, 0x30, 0x66, 0x31, 0x62, 0x32, 0x32, 0x37, 0x39, 0x63, 0x30, 0x31, 0x36, 0x63, 0x63, 0x38, 0x66, 0x61, 0x66, 0x30, 0x38, 0x65, 0x38, 0x34, 0x62, 0x65, 0x64, 0x38, 0x64, 0x64, 0x30, 0x66, 0x36, 0x63, 0x31, 0x36, 0x32, 0x33, 0x65, 0x35, 0x33, 0x66, 0x39, 0x66, 0x64, 0x32, 0x38, 0x34, 0x33, 0x39, 0x31, 0x65, 0x38, 0x34, 0x64, 0x65, 0x38, 0x65, 0x31, 0x34, 0x62, 0x64, 0x31, 0x62, 0x66, 0x33, 0x65, 0x30, 0x66, 0x34, 0x39, 0x30, 0x35, 0x34, 0x37, 0x66, 0x61, 0x34, 0x36, 0x31, 0x63, 0x65, 0x33, 0x34, 0x30, 0x61, 0x36, 0x66, 0x34, 0x31, 0x30, 0x33, 0x62, 0x31, 0x66, 0x36, 0x61, 0x39, 0x32, 0x30, 0x64, 0x35, 0x64, 0x34, 0x35, 0x62, 0x30, 0x63, 0x66, 0x37, 0x37, 0x63, 0x31, 0x64, 0x63, 0x64, 0x36, 0x65, 0x65, 0x63, 0x63, 0x62, 0x35, 0x66, 0x31, 0x31, 0x35, 0x32, 0x61, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x35, 0x30, 0x63, 0x31, 0x62, 0x65, 0x62, 0x36, 0x39, 0x32, 0x65, 0x32, 0x62, 0x63, 0x34, 0x30, 0x35, 0x37, 0x38, 0x37, 0x66, 0x37, 0x31, 0x31, 0x66, 0x31, 0x61, 0x34, 0x39, 0x61, 0x38, 0x34, 0x66, 0x34, 0x31, 0x32, 0x32, 0x61, 0x61, 0x66, 0x38, 0x36, 0x61, 0x62, 0x38, 0x35, 0x64, 0x39, 0x35, 0x37, 0x39, 0x62, 0x33, 0x63, 0x65, 0x35, 0x35, 0x64, 0x37, 0x32, 0x30, 0x63, 0x33, 0x63, 0x37, 0x64, 0x39, 0x39, 0x66, 0x63, 0x63, 0x61, 0x35, 0x33, 0x31, 0x64, 0x39, 0x62, 0x65, 0x31, 0x37, 0x33, 0x32, 0x64, 0x34, 0x62, 0x62, 0x65, 0x34, 0x30, 0x31, 0x31, 0x34, 0x36, 0x63, 0x64, 0x32, 0x39, 0x35, 0x62, 0x64, 0x35, 0x64, 0x33, 0x65, 0x32, 0x35, 0x63, 0x66, 0x31, 0x32, 0x35, 0x64, 0x62, 0x31, 0x34, 0x32, 0x39, 0x38, 0x30, 0x36, 0x63, 0x37, 0x32, 0x61, 0x64, 0x65, 0x31, 0x34, 0x30, 0x63, 0x32, 0x66, 0x64, 0x36, 0x33, 0x61, 0x38, 0x38, 0x61, 0x38, 0x38, 0x37, 0x64, 0x35, 0x39, 0x34, 0x36, 0x33, 0x62, 0x35, 0x30, 0x37, 0x32, 0x33, 0x63, 0x61, 0x66, 0x66, 0x66, 0x33, 0x64, 0x37, 0x35, 0x65, 0x30, 0x30, 0x35, 0x38, 0x64, 0x35, 0x37, 0x38, 0x30, 0x65, 0x30, 0x64, 0x32, 0x39, 0x30, 0x32, 0x37, 0x35, 0x61, 0x39, 0x65, 0x37, 0x30, 0x31, 0x38, 0x38, 0x62, 0x65, 0x33, 0x32, 0x32, 0x33, 0x37, 0x39, 0x34, 0x64, 0x63, 0x66, 0x34, 0x35, 0x35, 0x36, 0x64, 0x30, 0x33, 0x39, 0x66, 0x66, 0x32, 0x32, 0x34, 0x37, 0x38, 0x30, 0x32, 0x61, 0x34, 0x62, 0x35, 0x62, 0x66, 0x39, 0x35, 0x30, 0x62, 0x35, 0x35, 0x62, 0x37, 0x31, 0x32, 0x32, 0x64, 0x33, 0x34, 0x35, 0x39, 0x33, 0x35, 0x31, 0x32, 0x33, 0x39, 0x33, 0x32, 0x32, 0x61, 0x36, 0x39, 0x65, 0x38, 0x33, 0x62, 0x34, 0x33, 0x61, 0x32, 0x63, 0x65, 0x32, 0x34, 0x34, 0x62, 0x34, 0x37, 0x64, 0x39, 0x36, 0x32, 0x31, 0x34, 0x63, 0x38, 0x39, 0x37, 0x66, 0x62, 0x30, 0x63, 0x32, 0x32, 0x65, 0x33, 0x30, 0x30, 0x30, 0x30, 0x66, 0x62, 0x61, 0x37, 0x39, 0x35, 0x64, 0x66, 0x35, 0x30, 0x63, 0x31, 0x63, 0x36, 0x30, 0x31, 0x61, 0x32, 0x64, 0x34, 0x36, 0x36, 0x37, 0x32, 0x33, 0x34, 0x65, 0x64, 0x34, 0x39, 0x65, 0x65, 0x36, 0x31, 0x36, 0x38, 0x34, 0x61, 0x32, 0x34, 0x34, 0x38, 0x66, 0x34, 0x37, 0x65, 0x65, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x35, 0x61, 0x36, 0x32, 0x31, 0x66, 0x37, 0x30, 0x62, 0x31, 0x30, 0x33, 0x34, 0x36, 0x62, 0x64, 0x65, 0x65, 0x34, 0x31, 0x34, 0x30, 0x33, 0x63, 0x33, 0x63, 0x38, 0x31, 0x37, 0x62, 0x35, 0x35, 0x62, 0x30, 0x38, 0x36, 0x65, 0x63, 0x34, 0x61, 0x62, 0x31, 0x64, 0x61, 0x39, 0x31, 0x63, 0x38, 0x30, 0x65, 0x62, 0x36, 0x31, 0x39, 0x37, 0x37, 0x30, 0x35, 0x63, 0x37, 0x65, 0x62, 0x31, 0x63, 0x32, 0x38, 0x65, 0x63, 0x30, 0x37, 0x66, 0x38, 0x32, 0x61, 0x34, 0x32, 0x65, 0x64, 0x61, 0x39, 0x30, 0x39, 0x33, 0x33, 0x33, 0x31, 0x62, 0x63, 0x34, 0x31, 0x33, 0x66, 0x65, 0x66, 0x36, 0x39, 0x35, 0x37, 0x32, 0x30, 0x30, 0x32, 0x64, 0x63, 0x62, 0x34, 0x35, 0x38, 0x65, 0x62, 0x33, 0x39, 0x34, 0x65, 0x64, 0x38, 0x37, 0x34, 0x64, 0x35, 0x36, 0x31, 0x65, 0x61, 0x39, 0x33, 0x31, 0x31, 0x33, 0x39, 0x34, 0x64, 0x63, 0x61, 0x37, 0x64, 0x31, 0x34, 0x35, 0x30, 0x64, 0x30, 0x36, 0x39, 0x30, 0x35, 0x37, 0x62, 0x33, 0x32, 0x66, 0x32, 0x31, 0x65, 0x64, 0x66, 0x38, 0x30, 0x62, 0x65, 0x66, 0x36, 0x32, 0x35, 0x31, 0x61, 0x39, 0x31, 0x32, 0x33, 0x61, 0x34, 0x33, 0x66, 0x62, 0x63, 0x37, 0x36, 0x66, 0x63, 0x61, 0x62, 0x37, 0x31, 0x34, 0x32, 0x65, 0x63, 0x33, 0x36, 0x62, 0x35, 0x30, 0x30, 0x36, 0x61, 0x35, 0x35, 0x33, 0x31, 0x61, 0x31, 0x36, 0x35, 0x38, 0x61, 0x38, 0x32, 0x32, 0x66, 0x35, 0x34, 0x66, 0x30, 0x33, 0x31, 0x34, 0x32, 0x62, 0x36, 0x35, 0x61, 0x63, 0x62, 0x37, 0x33, 0x65, 0x38, 0x65, 0x65, 0x31, 0x62, 0x30, 0x36, 0x61, 0x62, 0x34, 0x37, 0x32, 0x36, 0x32, 0x38, 0x66, 0x31, 0x64, 0x63, 0x36, 0x33, 0x35, 0x36, 0x32, 0x31, 0x63, 0x33, 0x66, 0x31, 0x35, 0x39, 0x35, 0x31, 0x62, 0x37, 0x38, 0x62, 0x61, 0x64, 0x30, 0x31, 0x31, 0x39, 0x32, 0x62, 0x32, 0x31, 0x30, 0x65, 0x37, 0x36, 0x64, 0x30, 0x32, 0x38, 0x32, 0x62, 0x65, 0x62, 0x33, 0x33, 0x35, 0x36, 0x65, 0x38, 0x34, 0x30, 0x63, 0x65, 0x65, 0x32, 0x30, 0x61, 0x34, 0x64, 0x63, 0x35, 0x63, 0x35, 0x66, 0x65, 0x37, 0x63, 0x61, 0x66, 0x62, 0x32, 0x34, 0x64, 0x62, 0x31, 0x63, 0x64, 0x33, 0x39, 0x63, 0x65, 0x35, 0x62, 0x34, 0x65, 0x65, 0x31, 0x63, 0x65, 0x30, 0x33, 0x32, 0x36, 0x36, 0x31, 0x37, 0x32, 0x38, 0x31, 0x31, 0x66, 0x31, 0x33, 0x37, 0x31, 0x32, 0x30, 0x33, 0x33, 0x31, 0x35, 0x61, 0x30, 0x63, 0x34, 0x31, 0x34, 0x65, 0x66, 0x38, 0x63, 0x31, 0x35, 0x38, 0x37, 0x62, 0x66, 0x31, 0x36, 0x35, 0x65, 0x66, 0x32, 0x36, 0x62, 0x65, 0x30, 0x65, 0x62, 0x36, 0x34, 0x66, 0x37, 0x62, 0x37, 0x34, 0x35, 0x30, 0x30, 0x66, 0x65, 0x39, 0x61, 0x33, 0x38, 0x36, 0x65, 0x30, 0x63, 0x61, 0x35, 0x36, 0x31, 0x63, 0x64, 0x61, 0x63, 0x61, 0x64, 0x62, 0x61, 0x39, 0x34, 0x64, 0x35, 0x61, 0x32, 0x30, 0x66, 0x32, 0x32, 0x33, 0x64, 0x33, 0x64, 0x62, 0x30, 0x31, 0x64, 0x34, 0x37, 0x62, 0x39, 0x65, 0x35, 0x39, 0x31, 0x64, 0x31, 0x65, 0x62, 0x37, 0x32, 0x64, 0x35, 0x34, 0x31, 0x39, 0x39, 0x31, 0x39, 0x30, 0x34, 0x32, 0x32, 0x35, 0x65, 0x34, 0x34, 0x30, 0x34, 0x64, 0x33, 0x35, 0x35, 0x30, 0x37, 0x66, 0x39, 0x38, 0x35, 0x38, 0x66, 0x65, 0x37, 0x36, 0x63, 0x34, 0x37, 0x32, 0x37, 0x65, 0x61, 0x35, 0x32, 0x35, 0x65, 0x36, 0x37, 0x61, 0x37, 0x34, 0x31, 0x63, 0x38, 0x64, 0x30, 0x36, 0x34, 0x32, 0x62, 0x30, 0x66, 0x62, 0x37, 0x66, 0x64, 0x61, 0x30, 0x34, 0x30, 0x39, 0x32, 0x62, 0x38, 0x65, 0x31, 0x64, 0x38, 0x61, 0x64, 0x30, 0x37, 0x64, 0x35, 0x34, 0x32, 0x32, 0x37, 0x38, 0x38, 0x37, 0x38, 0x31, 0x37, 0x32, 0x31, 0x39, 0x38, 0x63, 0x36, 0x64, 0x30, 0x33, 0x64, 0x63, 0x34, 0x36, 0x64, 0x32, 0x37, 0x32, 0x39, 0x66, 0x33, 0x61, 0x33, 0x62, 0x35, 0x65, 0x39, 0x61, 0x64, 0x66, 0x32, 0x35, 0x65, 0x38, 0x32, 0x65, 0x33, 0x32, 0x61, 0x63, 0x32, 0x39, 0x65, 0x61, 0x32, 0x61, 0x31, 0x31, 0x62, 0x39, 0x36, 0x39, 0x38, 0x30, 0x62, 0x31, 0x36, 0x32, 0x34, 0x61, 0x61, 0x37, 0x31, 0x36, 0x32, 0x37, 0x31, 0x38, 0x61, 0x63, 0x36, 0x37, 0x37, 0x32, 0x39, 0x35, 0x30, 0x39, 0x37, 0x66, 0x38, 0x38, 0x36, 0x31, 0x63, 0x62, 0x66, 0x36, 0x66, 0x30, 0x35, 0x35, 0x35, 0x62, 0x36, 0x63, 0x39, 0x32, 0x32, 0x30, 0x34, 0x36, 0x32, 0x64, 0x30, 0x32, 0x33, 0x64, 0x34, 0x65, 0x36, 0x66, 0x63, 0x34, 0x66, 0x33, 0x62, 0x31, 0x31, 0x37, 0x30, 0x33, 0x31, 0x37, 0x37, 0x66, 0x39, 0x30, 0x34, 0x61, 0x62, 0x63, 0x35, 0x66, 0x37, 0x66, 0x37, 0x32, 0x66, 0x39, 0x65, 0x61, 0x33, 0x37, 0x39, 0x33, 0x34, 0x31, 0x38, 0x31, 0x36, 0x34, 0x30, 0x65, 0x36, 0x63, 0x39, 0x66, 0x66, 0x36, 0x65, 0x65, 0x38, 0x64, 0x33, 0x32, 0x35, 0x35, 0x38, 0x39, 0x39, 0x39, 0x38, 0x61, 0x36, 0x36, 0x66, 0x62, 0x30, 0x64, 0x32, 0x30, 0x33, 0x38, 0x62, 0x35, 0x63, 0x38, 0x36, 0x33, 0x63, 0x38, 0x63, 0x66, 0x31, 0x64, 0x39, 0x39, 0x30, 0x61, 0x31, 0x30, 0x64, 0x34, 0x63, 0x37, 0x39, 0x36, 0x32, 0x66, 0x38, 0x61, 0x35, 0x30, 0x33, 0x31, 0x35, 0x65, 0x34, 0x63, 0x61, 0x64, 0x64, 0x33, 0x30, 0x65, 0x66, 0x36, 0x39, 0x34, 0x38, 0x30, 0x63, 0x30, 0x66, 0x38, 0x33, 0x65, 0x32, 0x39, 0x61, 0x32, 0x32, 0x30, 0x33, 0x32, 0x31, 0x61, 0x35, 0x32, 0x31, 0x37, 0x31, 0x64, 0x38, 0x31, 0x37, 0x38, 0x30, 0x61, 0x35, 0x65, 0x31, 0x63, 0x34, 0x39, 0x65, 0x64, 0x62, 0x39, 0x31, 0x33, 0x32, 0x65, 0x66, 0x66, 0x35, 0x38, 0x35, 0x34, 0x64, 0x37, 0x31, 0x31, 0x38, 0x38, 0x64, 0x62, 0x36, 0x33, 0x33, 0x35, 0x37, 0x65, 0x32, 0x34, 0x63, 0x37, 0x63, 0x63, 0x65, 0x62, 0x31, 0x64, 0x36, 0x61, 0x30, 0x33, 0x32, 0x62, 0x61, 0x30, 0x63, 0x32, 0x37, 0x37, 0x32, 0x38, 0x33, 0x35, 0x63, 0x64, 0x31, 0x65, 0x32, 0x30, 0x31, 0x39, 0x35, 0x33, 0x66, 0x36, 0x38, 0x38, 0x33, 0x64, 0x31, 0x36, 0x64, 0x37, 0x63, 0x34, 0x66, 0x37, 0x33, 0x61, 0x39, 0x36, 0x32, 0x36, 0x66, 0x62, 0x64, 0x62, 0x66, 0x64, 0x39, 0x62, 0x34, 0x64, 0x63, 0x62, 0x38, 0x35, 0x38, 0x64, 0x38, 0x66, 0x32, 0x38, 0x34, 0x63, 0x39, 0x61, 0x61, 0x39, 0x33, 0x39, 0x34, 0x35, 0x34, 0x31, 0x66, 0x66, 0x35, 0x65, 0x63, 0x61, 0x62, 0x39, 0x62, 0x64, 0x37, 0x32, 0x66, 0x34, 0x65, 0x33, 0x39, 0x64, 0x32, 0x30, 0x39, 0x39, 0x30, 0x34, 0x61, 0x65, 0x39, 0x65, 0x36, 0x35, 0x37, 0x61, 0x33, 0x64, 0x62, 0x31, 0x37, 0x62, 0x37, 0x63, 0x38, 0x33, 0x34, 0x38, 0x34, 0x39, 0x34, 0x31, 0x33, 0x63, 0x39, 0x38, 0x66, 0x66, 0x39, 0x37, 0x61, 0x61, 0x39, 0x31, 0x36, 0x38, 0x65, 0x35, 0x32, 0x64, 0x61, 0x65, 0x66, 0x33, 0x39, 0x64, 0x62, 0x64, 0x36, 0x30, 0x39, 0x64, 0x34, 0x65, 0x38, 0x37, 0x35, 0x62, 0x63, 0x64, 0x38, 0x66, 0x38, 0x35, 0x61, 0x62, 0x35, 0x32, 0x38, 0x61, 0x63, 0x36, 0x32, 0x33, 0x32, 0x32, 0x38, 0x35, 0x65, 0x33, 0x33, 0x62, 0x38, 0x39, 0x36, 0x36, 0x65, 0x33, 0x34, 0x64, 0x66, 0x61, 0x38, 0x65, 0x34, 0x64, 0x61, 0x33, 0x36, 0x33, 0x30, 0x34, 0x32, 0x64, 0x62, 0x38, 0x39, 0x33, 0x66, 0x36, 0x61, 0x35, 0x37, 0x32, 0x35, 0x62, 0x61, 0x61, 0x39, 0x38, 0x32, 0x35, 0x38, 0x64, 0x39, 0x38, 0x38, 0x38, 0x62, 0x34, 0x30, 0x30, 0x61, 0x37, 0x32, 0x62, 0x39, 0x61, 0x65, 0x37, 0x33, 0x62, 0x34, 0x65, 0x31, 0x30, 0x66, 0x63, 0x65, 0x34, 0x37, 0x63, 0x39, 0x39, 0x30, 0x62, 0x63, 0x64, 0x62, 0x61, 0x36, 0x35, 0x38, 0x37, 0x39, 0x38, 0x30, 0x32, 0x64, 0x35, 0x64, 0x34, 0x33, 0x66, 0x63, 0x37, 0x36, 0x32, 0x38, 0x36, 0x31, 0x32, 0x62, 0x37, 0x63, 0x34, 0x38, 0x37, 0x63, 0x62, 0x64, 0x31, 0x39, 0x35, 0x36, 0x39, 0x65, 0x65, 0x37, 0x33, 0x38, 0x39, 0x37, 0x34, 0x35, 0x35, 0x35, 0x61, 0x63, 0x33, 0x65, 0x66, 0x31, 0x64, 0x63, 0x63, 0x63, 0x61, 0x34, 0x65, 0x64, 0x63, 0x61, 0x35, 0x36, 0x31, 0x35, 0x62, 0x39, 0x38, 0x35, 0x32, 0x34, 0x65, 0x63, 0x34, 0x39, 0x31, 0x33, 0x64, 0x37, 0x32, 0x36, 0x63, 0x64, 0x32, 0x62, 0x34, 0x32, 0x63, 0x64, 0x30, 0x37, 0x39, 0x34, 0x65, 0x61, 0x63, 0x66, 0x31, 0x38, 0x35, 0x64, 0x64, 0x38, 0x37, 0x36, 0x66, 0x64, 0x33, 0x63, 0x64, 0x64, 0x37, 0x31, 0x62, 0x62, 0x34, 0x65, 0x37, 0x37, 0x65, 0x31, 0x34, 0x36, 0x32, 0x65, 0x32, 0x61, 0x62, 0x33, 0x31, 0x30, 0x66, 0x36, 0x39, 0x36, 0x31, 0x37, 0x34, 0x62, 0x61, 0x36, 0x66, 0x37, 0x32, 0x36, 0x33, 0x32, 0x64, 0x30, 0x34, 0x36, 0x31, 0x36, 0x35, 0x31, 0x63, 0x32, 0x30, 0x66, 0x63, 0x30, 0x34, 0x64, 0x32, 0x62, 0x34, 0x66, 0x33, 0x35, 0x64, 0x35, 0x33, 0x65, 0x31, 0x36, 0x38, 0x36, 0x37, 0x38, 0x32, 0x30, 0x65, 0x64, 0x34, 0x35, 0x38, 0x63, 0x31, 0x35, 0x66, 0x35, 0x36, 0x36, 0x63, 0x63, 0x38, 0x61, 0x30, 0x33, 0x65, 0x39, 0x39, 0x37, 0x31, 0x66, 0x61, 0x35, 0x65, 0x64, 0x37, 0x62, 0x30, 0x35, 0x61, 0x64, 0x33, 0x61, 0x66, 0x38, 0x66, 0x36, 0x39, 0x64, 0x30, 0x66, 0x33, 0x66, 0x38, 0x39, 0x36, 0x65, 0x35, 0x35, 0x35, 0x65, 0x38, 0x61, 0x33, 0x61, 0x33, 0x37, 0x36, 0x64, 0x39, 0x36, 0x37, 0x32, 0x66, 0x66, 0x66, 0x36, 0x38, 0x65, 0x32, 0x35, 0x35, 0x35, 0x64, 0x39, 0x33, 0x63, 0x35, 0x33, 0x35, 0x31, 0x30, 0x36, 0x64, 0x38, 0x66, 0x37, 0x32, 0x33, 0x66, 0x34, 0x64, 0x37, 0x35, 0x32, 0x30, 0x34, 0x34, 0x62, 0x33, 0x36, 0x64, 0x36, 0x38, 0x39, 0x66, 0x62, 0x38, 0x66, 0x39, 0x39, 0x37, 0x30, 0x39, 0x65, 0x39, 0x37, 0x39, 0x62, 0x35, 0x64, 0x64, 0x61, 0x62, 0x35, 0x33, 0x63, 0x64, 0x62, 0x39, 0x36, 0x34, 0x36, 0x31, 0x30, 0x30, 0x64, 0x37, 0x31, 0x37, 0x65, 0x31, 0x39, 0x63, 0x39, 0x30, 0x63, 0x32, 0x31, 0x33, 0x37, 0x32, 0x66, 0x39, 0x66, 0x35, 0x33, 0x63, 0x34, 0x64, 0x63, 0x64, 0x37, 0x61, 0x64, 0x66, 0x36, 0x33, 0x39, 0x39, 0x38, 0x30, 0x35, 0x37, 0x32, 0x37, 0x34, 0x61, 0x32, 0x37, 0x31, 0x31, 0x39, 0x65, 0x30, 0x31, 0x38, 0x63, 0x32, 0x32, 0x38, 0x38, 0x61, 0x37, 0x34, 0x38, 0x63, 0x33, 0x65, 0x65, 0x38, 0x61, 0x66, 0x36, 0x38, 0x32, 0x65, 0x36, 0x63, 0x39, 0x38, 0x38, 0x36, 0x31, 0x31, 0x38, 0x61, 0x62, 0x65, 0x62, 0x31, 0x36, 0x64, 0x32, 0x33, 0x30, 0x61, 0x34, 0x32, 0x65, 0x30, 0x61, 0x30, 0x31, 0x33, 0x38, 0x34, 0x63, 0x37, 0x64, 0x66, 0x61, 0x63, 0x63, 0x66, 0x64, 0x65, 0x34, 0x64, 0x30, 0x34, 0x65, 0x33, 0x36, 0x37, 0x64, 0x64, 0x37, 0x65, 0x34, 0x39, 0x64, 0x33, 0x61, 0x61, 0x37, 0x66, 0x63, 0x38, 0x32, 0x36, 0x32, 0x31, 0x64, 0x38, 0x63, 0x66, 0x62, 0x37, 0x32, 0x30, 0x39, 0x31, 0x35, 0x30, 0x66, 0x65, 0x35, 0x38, 0x61, 0x61, 0x37, 0x30, 0x64, 0x61, 0x34, 0x30, 0x36, 0x38, 0x65, 0x63, 0x32, 0x35, 0x34, 0x35, 0x63, 0x35, 0x33, 0x64, 0x39, 0x38, 0x64, 0x30, 0x61, 0x65, 0x62, 0x39, 0x38, 0x33, 0x38, 0x64, 0x39, 0x32, 0x66, 0x30, 0x31, 0x38, 0x35, 0x38, 0x35, 0x66, 0x36, 0x34, 0x30, 0x34, 0x37, 0x36, 0x36, 0x64, 0x30, 0x65, 0x61, 0x30, 0x65, 0x34, 0x62, 0x64, 0x64, 0x32, 0x34, 0x65, 0x65, 0x32, 0x35, 0x64, 0x61, 0x34, 0x36, 0x39, 0x61, 0x63, 0x66, 0x31, 0x32, 0x31, 0x38, 0x61, 0x62, 0x64, 0x30, 0x34, 0x62, 0x34, 0x39, 0x36, 0x66, 0x32, 0x64, 0x35, 0x65, 0x38, 0x65, 0x61, 0x66, 0x30, 0x32, 0x61, 0x39, 0x32, 0x30, 0x31, 0x64, 0x61, 0x61, 0x61, 0x33, 0x35, 0x30, 0x39, 0x61, 0x32, 0x62, 0x30, 0x66, 0x66, 0x33, 0x37, 0x32, 0x66, 0x63, 0x33, 0x35, 0x38, 0x61, 0x31, 0x61, 0x66, 0x34, 0x30, 0x37, 0x39, 0x63, 0x34, 0x63, 0x66, 0x30, 0x34, 0x63, 0x36, 0x31, 0x37, 0x32, 0x61, 0x63, 0x32, 0x64, 0x39, 0x66, 0x39, 0x63, 0x65, 0x38, 0x64, 0x32, 0x36, 0x34, 0x35, 0x31, 0x36, 0x63, 0x62, 0x38, 0x65, 0x35, 0x65, 0x66, 0x61, 0x38, 0x61, 0x38, 0x64, 0x31, 0x38, 0x34, 0x38, 0x31, 0x65, 0x62, 0x66, 0x33, 0x30, 0x31, 0x61, 0x65, 0x62, 0x63, 0x37, 0x64, 0x65, 0x38, 0x31, 0x61, 0x61, 0x35, 0x32, 0x64, 0x64, 0x33, 0x61, 0x66, 0x31, 0x31, 0x65, 0x36, 0x38, 0x33, 0x38, 0x37, 0x30, 0x35, 0x35, 0x66, 0x33, 0x34, 0x65, 0x30, 0x30, 0x35, 0x38, 0x61, 0x34, 0x66, 0x61, 0x34, 0x63, 0x32, 0x65, 0x62, 0x33, 0x35, 0x66, 0x37, 0x65, 0x34, 0x34, 0x31, 0x36, 0x63, 0x30, 0x33, 0x64, 0x34, 0x32, 0x61, 0x30, 0x61, 0x63, 0x39, 0x64, 0x66, 0x32, 0x64, 0x66, 0x36, 0x38, 0x35, 0x38, 0x34, 0x32, 0x66, 0x62, 0x39, 0x65, 0x37, 0x38, 0x62, 0x36, 0x62, 0x65, 0x39, 0x33, 0x39, 0x66, 0x32, 0x62, 0x65, 0x38, 0x34, 0x36, 0x39, 0x64, 0x32, 0x38, 0x65, 0x31, 0x32, 0x38, 0x62, 0x63, 0x37, 0x61, 0x32, 0x39, 0x61, 0x63, 0x39, 0x39, 0x31, 0x33, 0x30, 0x36, 0x34, 0x31, 0x36, 0x33, 0x62, 0x35, 0x66, 0x37, 0x32, 0x30, 0x30, 0x33, 0x32, 0x32, 0x39, 0x66, 0x33, 0x62, 0x36, 0x36, 0x34, 0x33, 0x62, 0x63, 0x35, 0x61, 0x65, 0x30, 0x33, 0x36, 0x63, 0x34, 0x34, 0x33, 0x32, 0x37, 0x33, 0x39, 0x61, 0x36, 0x65, 0x61, 0x63, 0x37, 0x32, 0x36, 0x64, 0x64, 0x32, 0x65, 0x33, 0x30, 0x36, 0x30, 0x61, 0x37, 0x37, 0x32, 0x32, 0x62, 0x35, 0x33, 0x65, 0x65, 0x37, 0x63, 0x34, 0x33, 0x34, 0x35, 0x66, 0x35, 0x35, 0x39, 0x33, 0x32, 0x32, 0x38, 0x63, 0x31, 0x63, 0x65, 0x31, 0x63, 0x63, 0x65, 0x32, 0x32, 0x38, 0x32, 0x30, 0x38, 0x33, 0x63, 0x62, 0x38, 0x64, 0x64, 0x39, 0x34, 0x36, 0x34, 0x37, 0x62, 0x38, 0x33, 0x33, 0x38, 0x65, 0x61, 0x66, 0x63, 0x63, 0x36, 0x34, 0x65, 0x30, 0x65, 0x32, 0x62, 0x62, 0x36, 0x35, 0x39, 0x31, 0x66, 0x66, 0x65, 0x64, 0x66, 0x31, 0x36, 0x62, 0x65, 0x62, 0x32, 0x65, 0x39, 0x63, 0x34, 0x65, 0x61, 0x38, 0x64, 0x65, 0x38, 0x61, 0x62, 0x39, 0x65, 0x39, 0x34, 0x39, 0x31, 0x66, 0x38, 0x37, 0x39, 0x64, 0x30, 0x36, 0x33, 0x31, 0x63, 0x39, 0x33, 0x33, 0x32, 0x38, 0x66, 0x65, 0x64, 0x32, 0x31, 0x36, 0x66, 0x38, 0x63, 0x66, 0x32, 0x34, 0x62, 0x66, 0x32, 0x39, 0x36, 0x31, 0x64, 0x35, 0x39, 0x36, 0x32, 0x61, 0x63, 0x62, 0x61, 0x34, 0x65, 0x39, 0x37, 0x32, 0x65, 0x65, 0x33, 0x31, 0x33, 0x32, 0x30, 0x65, 0x34, 0x63, 0x64, 0x32, 0x64, 0x63, 0x63, 0x66, 0x31, 0x32, 0x30, 0x34, 0x36, 0x35, 0x63, 0x33, 0x36, 0x35, 0x62, 0x65, 0x32, 0x66, 0x32, 0x34, 0x39, 0x31, 0x37, 0x37, 0x66, 0x30, 0x62, 0x35, 0x63, 0x37, 0x62, 0x38, 0x39, 0x63, 0x32, 0x33, 0x35, 0x34, 0x36, 0x31, 0x34, 0x35, 0x33, 0x66, 0x66, 0x61, 0x37, 0x64, 0x35, 0x37, 0x37, 0x32, 0x37, 0x36, 0x66, 0x39, 0x62, 0x30, 0x35, 0x30, 0x66, 0x34, 0x66, 0x65, 0x63, 0x39, 0x32, 0x35, 0x32, 0x63, 0x64, 0x31, 0x66, 0x65, 0x30, 0x66, 0x37, 0x33, 0x38, 0x63, 0x61, 0x35, 0x63, 0x65, 0x37, 0x36, 0x32, 0x30, 0x38, 0x65, 0x34, 0x34, 0x39, 0x39, 0x62, 0x37, 0x61, 0x61, 0x32, 0x31, 0x36, 0x66, 0x35, 0x36, 0x62, 0x37, 0x36, 0x61, 0x65, 0x35, 0x38, 0x37, 0x36, 0x36, 0x37, 0x32, 0x34, 0x35, 0x63, 0x31, 0x38, 0x65, 0x39, 0x61, 0x37, 0x31, 0x63, 0x64, 0x65, 0x31, 0x62, 0x62, 0x34, 0x31, 0x35, 0x32, 0x63, 0x62, 0x64, 0x32, 0x32, 0x61, 0x39, 0x66, 0x62, 0x35, 0x61, 0x65, 0x61, 0x34, 0x38, 0x30, 0x66, 0x65, 0x65, 0x62, 0x31, 0x38, 0x35, 0x66, 0x38, 0x62, 0x34, 0x62, 0x38, 0x66, 0x32, 0x66, 0x37, 0x61, 0x37, 0x38, 0x63, 0x61, 0x65, 0x36, 0x38, 0x33, 0x37, 0x32, 0x33, 0x37, 0x37, 0x37, 0x32, 0x63, 0x35, 0x31, 0x61, 0x39, 0x30, 0x63, 0x61, 0x34, 0x34, 0x66, 0x61, 0x36, 0x30, 0x65, 0x62, 0x64, 0x61, 0x37, 0x39, 0x63, 0x39, 0x36, 0x62, 0x31, 0x35, 0x32, 0x33, 0x31, 0x36, 0x31, 0x32, 0x63, 0x30, 0x33, 0x63, 0x34, 0x64, 0x34, 0x65, 0x62, 0x66, 0x64, 0x65, 0x34, 0x61, 0x63, 0x39, 0x35, 0x62, 0x64, 0x65, 0x31, 0x62, 0x31, 0x64, 0x37, 0x37, 0x32, 0x62, 0x61, 0x36, 0x63, 0x30, 0x35, 0x64, 0x30, 0x30, 0x66, 0x38, 0x61, 0x30, 0x38, 0x30, 0x32, 0x31, 0x61, 0x62, 0x66, 0x62, 0x32, 0x30, 0x35, 0x31, 0x34, 0x63, 0x39, 0x64, 0x37, 0x36, 0x61, 0x38, 0x63, 0x38, 0x30, 0x34, 0x66, 0x35, 0x66, 0x64, 0x36, 0x37, 0x37, 0x66, 0x37, 0x32, 0x32, 0x38, 0x32, 0x63, 0x37, 0x33, 0x34, 0x34, 0x36, 0x31, 0x61, 0x34, 0x31, 0x37, 0x39, 0x30, 0x36, 0x31, 0x65, 0x30, 0x61, 0x33, 0x62, 0x37, 0x66, 0x30, 0x39, 0x34, 0x39, 0x65, 0x63, 0x64, 0x38, 0x38, 0x34, 0x31, 0x33, 0x36, 0x33, 0x39, 0x37, 0x31, 0x39, 0x61, 0x65, 0x39, 0x62, 0x36, 0x33, 0x30, 0x64, 0x31, 0x33, 0x35, 0x36, 0x34, 0x36, 0x62, 0x37, 0x35, 0x37, 0x36, 0x64, 0x61, 0x31, 0x30, 0x31, 0x64, 0x36, 0x61, 0x39, 0x36, 0x35, 0x65, 0x35, 0x66, 0x30, 0x34, 0x33, 0x35, 0x38, 0x39, 0x34, 0x32, 0x37, 0x64, 0x64, 0x32, 0x65, 0x35, 0x30, 0x37, 0x66, 0x64, 0x39, 0x36, 0x36, 0x38, 0x35, 0x64, 0x30, 0x66, 0x62, 0x33, 0x36, 0x63, 0x64, 0x35, 0x64, 0x32, 0x63, 0x35, 0x62, 0x61, 0x62, 0x34, 0x33, 0x38, 0x64, 0x33, 0x34, 0x66, 0x36, 0x31, 0x38, 0x66, 0x37, 0x36, 0x61, 0x61, 0x33, 0x30, 0x65, 0x38, 0x34, 0x30, 0x37, 0x65, 0x64, 0x63, 0x66, 0x65, 0x31, 0x32, 0x64, 0x34, 0x66, 0x33, 0x65, 0x65, 0x34, 0x64, 0x64, 0x39, 0x34, 0x39, 0x35, 0x63, 0x61, 0x36, 0x61, 0x38, 0x33, 0x32, 0x64, 0x31, 0x61, 0x36, 0x65, 0x30, 0x31, 0x65, 0x62, 0x37, 0x66, 0x32, 0x64, 0x34, 0x36, 0x38, 0x33, 0x66, 0x34, 0x32, 0x65, 0x61, 0x34, 0x61, 0x65, 0x65, 0x38, 0x32, 0x64, 0x30, 0x64, 0x32, 0x64, 0x37, 0x34, 0x63, 0x63, 0x34, 0x64, 0x66, 0x62, 0x64, 0x34, 0x32, 0x36, 0x64, 0x63, 0x65, 0x32, 0x35, 0x38, 0x65, 0x36, 0x62, 0x30, 0x61, 0x38, 0x32, 0x34, 0x32, 0x34, 0x62, 0x32, 0x61, 0x33, 0x36, 0x32, 0x36, 0x35, 0x62, 0x62, 0x39, 0x30, 0x38, 0x32, 0x34, 0x65, 0x32, 0x33, 0x61, 0x36, 0x62, 0x30, 0x37, 0x64, 0x33, 0x32, 0x65, 0x36, 0x37, 0x32, 0x66, 0x31, 0x32, 0x61, 0x33, 0x33, 0x30, 0x39, 0x36, 0x61, 0x38, 0x64, 0x33, 0x65, 0x34, 0x65, 0x37, 0x32, 0x34, 0x33, 0x31, 0x39, 0x37, 0x66, 0x35, 0x62, 0x64, 0x32, 0x61, 0x33, 0x36, 0x33, 0x36, 0x36, 0x62, 0x61, 0x33, 0x61, 0x62, 0x34, 0x30, 0x66, 0x31, 0x35, 0x38, 0x37, 0x36, 0x31, 0x30, 0x66, 0x34, 0x34, 0x31, 0x36, 0x30, 0x36, 0x35, 0x62, 0x33, 0x35, 0x33, 0x32, 0x35, 0x33, 0x39, 0x65, 0x30, 0x65, 0x64, 0x66, 0x33, 0x35, 0x66, 0x37, 0x33, 0x64, 0x35, 0x31, 0x63, 0x65, 0x34, 0x63, 0x36, 0x39, 0x39, 0x30, 0x39, 0x65, 0x63, 0x66, 0x31, 0x35, 0x39, 0x37, 0x39, 0x30, 0x30, 0x37, 0x36, 0x66, 0x31, 0x39, 0x31, 0x38, 0x39, 0x66, 0x66, 0x34, 0x32, 0x32, 0x33, 0x63, 0x34, 0x62, 0x33, 0x30, 0x34, 0x62, 0x63, 0x31, 0x32, 0x32, 0x33, 0x61, 0x39, 0x34, 0x64, 0x64, 0x61, 0x34, 0x61, 0x64, 0x61, 0x33, 0x36, 0x33, 0x35, 0x34, 0x34, 0x31, 0x66, 0x30, 0x65, 0x65, 0x37, 0x32, 0x37, 0x61, 0x63, 0x66, 0x30, 0x39, 0x62, 0x31, 0x32, 0x34, 0x38, 0x35, 0x64, 0x33, 0x38, 0x38, 0x38, 0x62, 0x64, 0x37, 0x37, 0x64, 0x61, 0x38, 0x32, 0x39, 0x37, 0x39, 0x66, 0x62, 0x64, 0x39, 0x36, 0x61, 0x64, 0x62, 0x62, 0x32, 0x66, 0x37, 0x37, 0x39, 0x30, 0x38, 0x65, 0x32, 0x31, 0x33, 0x63, 0x62, 0x66, 0x64, 0x34, 0x38, 0x38, 0x63, 0x65, 0x61, 0x38, 0x39, 0x65, 0x65, 0x37, 0x32, 0x38, 0x65, 0x37, 0x65, 0x65, 0x35, 0x39, 0x33, 0x30, 0x30, 0x31, 0x31, 0x31, 0x61, 0x36, 0x32, 0x66, 0x38, 0x35, 0x38, 0x30, 0x32, 0x39, 0x34, 0x32, 0x38, 0x33, 0x62, 0x35, 0x32, 0x32, 0x31, 0x38, 0x39, 0x61, 0x64, 0x30, 0x39, 0x30, 0x63, 0x30, 0x36, 0x37, 0x62, 0x62, 0x62, 0x30, 0x66, 0x66, 0x65, 0x63, 0x66, 0x38, 0x31, 0x63, 0x61, 0x65, 0x34, 0x33, 0x35, 0x31, 0x38, 0x30, 0x39, 0x62, 0x36, 0x35, 0x61, 0x66, 0x38, 0x61, 0x32, 0x66, 0x34, 0x30, 0x32, 0x33, 0x31, 0x33, 0x66, 0x65, 0x36, 0x34, 0x39, 0x61, 0x30, 0x36, 0x62, 0x30, 0x61, 0x61, 0x66, 0x30, 0x64, 0x38, 0x66, 0x38, 0x36, 0x37, 0x38, 0x30, 0x32, 0x62, 0x33, 0x63, 0x66, 0x38, 0x30, 0x32, 0x36, 0x36, 0x38, 0x30, 0x39, 0x63, 0x38, 0x65, 0x61, 0x64, 0x35, 0x61, 0x34, 0x66, 0x62, 0x30, 0x64, 0x31, 0x34, 0x30, 0x62, 0x36, 0x36, 0x62, 0x64, 0x31, 0x65, 0x65, 0x37, 0x33, 0x38, 0x36, 0x64, 0x36, 0x38, 0x32, 0x39, 0x38, 0x34, 0x65, 0x39, 0x34, 0x34, 0x33, 0x33, 0x63, 0x38, 0x31, 0x66, 0x61, 0x32, 0x34, 0x34, 0x61, 0x33, 0x38, 0x32, 0x39, 0x61, 0x33, 0x35, 0x62, 0x61, 0x34, 0x37, 0x38, 0x39, 0x33, 0x66, 0x64, 0x33, 0x36, 0x32, 0x36, 0x37, 0x63, 0x62, 0x63, 0x39, 0x64, 0x63, 0x37, 0x32, 0x66, 0x32, 0x65, 0x34, 0x35, 0x32, 0x31, 0x62, 0x30, 0x61, 0x32, 0x36, 0x61, 0x65, 0x30, 0x37, 0x64, 0x32, 0x30, 0x33, 0x33, 0x34, 0x61, 0x39, 0x64, 0x61, 0x38, 0x66, 0x62, 0x39, 0x38, 0x32, 0x33, 0x39, 0x37, 0x38, 0x32, 0x64, 0x30, 0x38, 0x33, 0x36, 0x32, 0x65, 0x30, 0x30, 0x36, 0x36, 0x31, 0x36, 0x66, 0x62, 0x63, 0x37, 0x63, 0x38, 0x36, 0x33, 0x38, 0x61, 0x39, 0x35, 0x37, 0x32, 0x64, 0x38, 0x31, 0x62, 0x37, 0x38, 0x64, 0x39, 0x62, 0x34, 0x35, 0x36, 0x30, 0x66, 0x39, 0x63, 0x66, 0x39, 0x32, 0x63, 0x64, 0x62, 0x31, 0x61, 0x35, 0x34, 0x37, 0x62, 0x65, 0x35, 0x61, 0x33, 0x64, 0x38, 0x39, 0x37, 0x31, 0x64, 0x32, 0x62, 0x38, 0x37, 0x39, 0x38, 0x30, 0x64, 0x35, 0x39, 0x35, 0x66, 0x30, 0x65, 0x37, 0x35, 0x65, 0x62, 0x30, 0x39, 0x32, 0x62, 0x34, 0x37, 0x32, 0x65, 0x62, 0x36, 0x35, 0x62, 0x38, 0x66, 0x66, 0x30, 0x62, 0x32, 0x63, 0x64, 0x62, 0x35, 0x39, 0x34, 0x64, 0x66, 0x65, 0x34, 0x37, 0x63, 0x38, 0x32, 0x31, 0x30, 0x35, 0x63, 0x36, 0x34, 0x33, 0x61, 0x61, 0x63, 0x30, 0x63, 0x63, 0x38, 0x34, 0x65, 0x34, 0x62, 0x34, 0x66, 0x63, 0x36, 0x61, 0x35, 0x36, 0x37, 0x62, 0x36, 0x65, 0x61, 0x62, 0x62, 0x62, 0x62, 0x63, 0x34, 0x61, 0x32, 0x34, 0x61, 0x65, 0x62, 0x36, 0x37, 0x33, 0x34, 0x33, 0x37, 0x61, 0x32, 0x39, 0x64, 0x34, 0x34, 0x65, 0x30, 0x61, 0x64, 0x66, 0x39, 0x66, 0x38, 0x62, 0x38, 0x33, 0x38, 0x61, 0x62, 0x62, 0x38, 0x31, 0x36, 0x32, 0x30, 0x31, 0x33, 0x38, 0x33, 0x31, 0x30, 0x62, 0x66, 0x66, 0x32, 0x34, 0x32, 0x34, 0x31, 0x65, 0x63, 0x62, 0x30, 0x34, 0x66, 0x39, 0x38, 0x38, 0x63, 0x33, 0x38, 0x34, 0x65, 0x33, 0x33, 0x34, 0x30, 0x38, 0x61, 0x39, 0x33, 0x37, 0x62, 0x39, 0x65, 0x63, 0x39, 0x65, 0x33, 0x34, 0x32, 0x61, 0x33, 0x62, 0x38, 0x63, 0x65, 0x39, 0x66, 0x32, 0x34, 0x38, 0x39, 0x66, 0x37, 0x36, 0x33, 0x38, 0x33, 0x31, 0x39, 0x34, 0x31, 0x36, 0x35, 0x61, 0x37, 0x37, 0x65, 0x64, 0x66, 0x39, 0x37, 0x66, 0x61, 0x64, 0x30, 0x38, 0x34, 0x34, 0x62, 0x33, 0x37, 0x31, 0x38, 0x32, 0x38, 0x37, 0x32, 0x36, 0x62, 0x33, 0x63, 0x35, 0x36, 0x63, 0x65, 0x65, 0x39, 0x61, 0x65, 0x38, 0x37, 0x30, 0x64, 0x36, 0x33, 0x63, 0x37, 0x35, 0x38, 0x35, 0x65, 0x65, 0x32, 0x65, 0x31, 0x37, 0x38, 0x37, 0x65, 0x38, 0x38, 0x61, 0x62, 0x34, 0x30, 0x33, 0x61, 0x66, 0x32, 0x34, 0x65, 0x32, 0x39, 0x30, 0x35, 0x32, 0x61, 0x32, 0x31, 0x66, 0x33, 0x34, 0x66, 0x65, 0x39, 0x35, 0x32, 0x61, 0x35, 0x33, 0x65, 0x65, 0x38, 0x65, 0x31, 0x37, 0x61, 0x30, 0x64, 0x35, 0x35, 0x39, 0x30, 0x34, 0x36, 0x33, 0x37, 0x66, 0x31, 0x61, 0x38, 0x34, 0x38, 0x64, 0x64, 0x30, 0x66, 0x37, 0x30, 0x39, 0x63, 0x61, 0x61, 0x61, 0x66, 0x62, 0x66, 0x39, 0x33, 0x34, 0x35, 0x31, 0x33, 0x38, 0x63, 0x64, 0x38, 0x64, 0x61, 0x66, 0x30, 0x35, 0x39, 0x64, 0x39, 0x35, 0x30, 0x64, 0x31, 0x66, 0x33, 0x37, 0x34, 0x37, 0x32, 0x35, 0x37, 0x35, 0x66, 0x65, 0x30, 0x62, 0x34, 0x62, 0x33, 0x30, 0x62, 0x30, 0x31, 0x63, 0x38, 0x62, 0x63, 0x38, 0x37, 0x31, 0x36, 0x32, 0x63, 0x65, 0x30, 0x62, 0x62, 0x61, 0x66, 0x37, 0x32, 0x37, 0x38, 0x31, 0x63, 0x64, 0x65, 0x38, 0x65, 0x30, 0x38, 0x35, 0x62, 0x64, 0x32, 0x38, 0x33, 0x35, 0x66, 0x66, 0x30, 0x39, 0x64, 0x64, 0x36, 0x36, 0x37, 0x65, 0x30, 0x65, 0x66, 0x37, 0x32, 0x33, 0x66, 0x61, 0x65, 0x65, 0x31, 0x65, 0x30, 0x62, 0x66, 0x36, 0x33, 0x36, 0x61, 0x65, 0x32, 0x30, 0x64, 0x37, 0x37, 0x63, 0x65, 0x34, 0x32, 0x61, 0x31, 0x39, 0x33, 0x61, 0x63, 0x39, 0x64, 0x37, 0x66, 0x39, 0x62, 0x33, 0x33, 0x31, 0x36, 0x32, 0x34, 0x61, 0x61, 0x35, 0x64, 0x34, 0x32, 0x66, 0x63, 0x37, 0x36, 0x37, 0x62, 0x62, 0x33, 0x33, 0x38, 0x64, 0x36, 0x63, 0x36, 0x37, 0x32, 0x62, 0x37, 0x30, 0x35, 0x65, 0x32, 0x33, 0x30, 0x30, 0x66, 0x65, 0x65, 0x39, 0x32, 0x62, 0x33, 0x63, 0x64, 0x63, 0x31, 0x66, 0x33, 0x31, 0x61, 0x64, 0x39, 0x66, 0x35, 0x31, 0x35, 0x38, 0x61, 0x38, 0x64, 0x38, 0x30, 0x38, 0x33, 0x65, 0x35, 0x33, 0x63, 0x65, 0x65, 0x31, 0x36, 0x39, 0x33, 0x36, 0x31, 0x38, 0x32, 0x33, 0x34, 0x65, 0x63, 0x61, 0x66, 0x33, 0x63, 0x34, 0x61, 0x36, 0x31, 0x36, 0x34, 0x37, 0x64, 0x65, 0x65, 0x61, 0x39, 0x31, 0x64, 0x31, 0x38, 0x37, 0x34, 0x30, 0x31, 0x37, 0x33, 0x30, 0x39, 0x30, 0x63, 0x30, 0x65, 0x33, 0x35, 0x37, 0x34, 0x35, 0x34, 0x33, 0x36, 0x65, 0x39, 0x30, 0x66, 0x32, 0x63, 0x36, 0x31, 0x64, 0x35, 0x33, 0x31, 0x36, 0x38, 0x35, 0x66, 0x61, 0x64, 0x66, 0x38, 0x36, 0x32, 0x35, 0x31, 0x63, 0x63, 0x32, 0x35, 0x32, 0x61, 0x37, 0x32, 0x33, 0x37, 0x30, 0x37, 0x62, 0x66, 0x30, 0x33, 0x37, 0x64, 0x61, 0x62, 0x62, 0x61, 0x32, 0x39, 0x64, 0x63, 0x35, 0x64, 0x36, 0x30, 0x34, 0x62, 0x31, 0x65, 0x37, 0x30, 0x34, 0x63, 0x38, 0x37, 0x38, 0x63, 0x61, 0x36, 0x39, 0x37, 0x30, 0x65, 0x64, 0x38, 0x30, 0x66, 0x31, 0x31, 0x34, 0x31, 0x66, 0x65, 0x33, 0x35, 0x64, 0x65, 0x66, 0x35, 0x62, 0x30, 0x32, 0x63, 0x62, 0x66, 0x34, 0x38, 0x33, 0x39, 0x35, 0x34, 0x66, 0x35, 0x65, 0x36, 0x33, 0x38, 0x62, 0x63, 0x39, 0x38, 0x38, 0x61, 0x63, 0x31, 0x63, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x64, 0x62, 0x38, 0x30, 0x63, 0x63, 0x35, 0x37, 0x35, 0x33, 0x35, 0x36, 0x39, 0x35, 0x65, 0x34, 0x34, 0x38, 0x38, 0x61, 0x37, 0x62, 0x64, 0x33, 0x66, 0x37, 0x33, 0x66, 0x38, 0x31, 0x35, 0x66, 0x34, 0x38, 0x35, 0x62, 0x38, 0x32, 0x64, 0x35, 0x38, 0x31, 0x30, 0x39, 0x39, 0x31, 0x30, 0x32, 0x32, 0x36, 0x62, 0x33, 0x38, 0x38, 0x35, 0x32, 0x38, 0x65, 0x39, 0x61, 0x39, 0x38, 0x30, 0x34, 0x65, 0x31, 0x66, 0x64, 0x33, 0x33, 0x32, 0x35, 0x61, 0x36, 0x32, 0x39, 0x35, 0x36, 0x33, 0x37, 0x36, 0x30, 0x64, 0x35, 0x32, 0x63, 0x38, 0x35, 0x36, 0x37, 0x35, 0x63, 0x38, 0x66, 0x31, 0x63, 0x39, 0x34, 0x32, 0x36, 0x65, 0x31, 0x31, 0x30, 0x32, 0x37, 0x65, 0x64, 0x36, 0x37, 0x37, 0x66, 0x66, 0x36, 0x35, 0x65, 0x65, 0x36, 0x34, 0x33, 0x66, 0x39, 0x30, 0x63, 0x61, 0x37, 0x35, 0x33, 0x38, 0x35, 0x36, 0x30, 0x38, 0x31, 0x33, 0x61, 0x66, 0x66, 0x33, 0x34, 0x62, 0x32, 0x36, 0x64, 0x39, 0x30, 0x33, 0x36, 0x63, 0x33, 0x63, 0x32, 0x39, 0x39, 0x32, 0x35, 0x38, 0x32, 0x31, 0x34, 0x63, 0x30, 0x66, 0x64, 0x39, 0x32, 0x64, 0x63, 0x34, 0x37, 0x30, 0x62, 0x39, 0x31, 0x31, 0x36, 0x66, 0x30, 0x32, 0x31, 0x66, 0x32, 0x63, 0x36, 0x38, 0x61, 0x61, 0x66, 0x65, 0x36, 0x38, 0x64, 0x39, 0x63, 0x32, 0x37, 0x66, 0x34, 0x37, 0x61, 0x66, 0x33, 0x36, 0x34, 0x62, 0x61, 0x38, 0x34, 0x64, 0x64, 0x64, 0x65, 0x63, 0x61, 0x64, 0x37, 0x37, 0x35, 0x36, 0x32, 0x63, 0x62, 0x66, 0x32, 0x62, 0x35, 0x30, 0x32, 0x62, 0x36, 0x34, 0x36, 0x62, 0x65, 0x38, 0x66, 0x66, 0x33, 0x35, 0x35, 0x35, 0x61, 0x36, 0x33, 0x63, 0x34, 0x32, 0x37, 0x30, 0x32, 0x31, 0x66, 0x62, 0x66, 0x35, 0x61, 0x36, 0x35, 0x66, 0x32, 0x32, 0x63, 0x32, 0x63, 0x66, 0x35, 0x64, 0x35, 0x62, 0x61, 0x32, 0x66, 0x66, 0x33, 0x37, 0x30, 0x36, 0x37, 0x37, 0x33, 0x38, 0x63, 0x38, 0x34, 0x61, 0x39, 0x36, 0x37, 0x36, 0x31, 0x63, 0x38, 0x62, 0x34, 0x34, 0x61, 0x65, 0x32, 0x39, 0x63, 0x62, 0x34, 0x62, 0x65, 0x62, 0x38, 0x63, 0x65, 0x30, 0x62, 0x37, 0x63, 0x31, 0x65, 0x35, 0x37, 0x35, 0x65, 0x33, 0x33, 0x36, 0x64, 0x62, 0x36, 0x39, 0x65, 0x65, 0x61, 0x37, 0x31, 0x38, 0x39, 0x37, 0x64, 0x35, 0x36, 0x36, 0x36, 0x37, 0x37, 0x38, 0x61, 0x36, 0x66, 0x63, 0x38, 0x62, 0x65, 0x65, 0x34, 0x34, 0x39, 0x30, 0x65, 0x30, 0x30, 0x38, 0x36, 0x38, 0x34, 0x32, 0x35, 0x37, 0x31, 0x33, 0x32, 0x35, 0x32, 0x65, 0x33, 0x65, 0x32, 0x35, 0x64, 0x31, 0x39, 0x64, 0x38, 0x66, 0x64, 0x62, 0x61, 0x66, 0x32, 0x39, 0x65, 0x38, 0x36, 0x32, 0x37, 0x63, 0x39, 0x61, 0x64, 0x35, 0x31, 0x61, 0x61, 0x30, 0x31, 0x31, 0x33, 0x66, 0x31, 0x39, 0x30, 0x61, 0x62, 0x30, 0x36, 0x62, 0x31, 0x32, 0x37, 0x39, 0x36, 0x33, 0x37, 0x30, 0x32, 0x33, 0x32, 0x37, 0x30, 0x66, 0x35, 0x35, 0x34, 0x39, 0x64, 0x61, 0x37, 0x37, 0x34, 0x61, 0x35, 0x39, 0x36, 0x38, 0x35, 0x37, 0x62, 0x61, 0x39, 0x37, 0x39, 0x39, 0x35, 0x65, 0x39, 0x31, 0x33, 0x32, 0x63, 0x65, 0x38, 0x31, 0x33, 0x63, 0x31, 0x31, 0x38, 0x65, 0x65, 0x63, 0x62, 0x38, 0x63, 0x36, 0x66, 0x66, 0x34, 0x65, 0x33, 0x65, 0x32, 0x61, 0x66, 0x65, 0x33, 0x34, 0x65, 0x62, 0x35, 0x63, 0x37, 0x32, 0x37, 0x62, 0x39, 0x39, 0x32, 0x31, 0x38, 0x63, 0x38, 0x33, 0x30, 0x61, 0x37, 0x61, 0x64, 0x38, 0x62, 0x30, 0x39, 0x61, 0x34, 0x64, 0x32, 0x38, 0x62, 0x61, 0x36, 0x31, 0x65, 0x63, 0x36, 0x31, 0x61, 0x61, 0x62, 0x36, 0x38, 0x32, 0x36, 0x66, 0x36, 0x36, 0x62, 0x66, 0x30, 0x37, 0x64, 0x66, 0x64, 0x36, 0x31, 0x31, 0x66, 0x38, 0x35, 0x36, 0x63, 0x63, 0x31, 0x36, 0x35, 0x64, 0x37, 0x32, 0x30, 0x63, 0x61, 0x30, 0x64, 0x35, 0x32, 0x64, 0x63, 0x62, 0x35, 0x36, 0x62, 0x63, 0x64, 0x37, 0x62, 0x34, 0x62, 0x63, 0x30, 0x34, 0x38, 0x61, 0x30, 0x31, 0x63, 0x35, 0x32, 0x35, 0x35, 0x33, 0x64, 0x31, 0x37, 0x61, 0x65, 0x66, 0x66, 0x35, 0x35, 0x66, 0x30, 0x35, 0x30, 0x61, 0x35, 0x35, 0x33, 0x33, 0x65, 0x37, 0x62, 0x30, 0x39, 0x62, 0x62, 0x38, 0x38, 0x61, 0x33, 0x65, 0x37, 0x32, 0x31, 0x33, 0x64, 0x36, 0x30, 0x62, 0x62, 0x66, 0x32, 0x63, 0x32, 0x39, 0x61, 0x30, 0x39, 0x62, 0x35, 0x61, 0x35, 0x35, 0x36, 0x63, 0x31, 0x36, 0x65, 0x34, 0x30, 0x37, 0x65, 0x62, 0x30, 0x37, 0x66, 0x33, 0x33, 0x31, 0x30, 0x31, 0x62, 0x32, 0x39, 0x65, 0x34, 0x34, 0x65, 0x63, 0x36, 0x38, 0x62, 0x33, 0x61, 0x62, 0x65, 0x36, 0x65, 0x31, 0x63, 0x62, 0x63, 0x66, 0x31, 0x38, 0x32, 0x37, 0x31, 0x37, 0x34, 0x34, 0x35, 0x36, 0x38, 0x32, 0x38, 0x34, 0x64, 0x65, 0x34, 0x30, 0x34, 0x30, 0x37, 0x34, 0x33, 0x34, 0x31, 0x35, 0x37, 0x33, 0x62, 0x35, 0x66, 0x37, 0x61, 0x34, 0x63, 0x33, 0x65, 0x34, 0x30, 0x65, 0x36, 0x31, 0x39, 0x65, 0x61, 0x33, 0x37, 0x64, 0x36, 0x39, 0x38, 0x36, 0x63, 0x32, 0x34, 0x66, 0x64, 0x66, 0x63, 0x34, 0x37, 0x63, 0x37, 0x33, 0x34, 0x32, 0x32, 0x36, 0x30, 0x31, 0x64, 0x33, 0x33, 0x65, 0x64, 0x34, 0x32, 0x36, 0x36, 0x36, 0x35, 0x31, 0x33, 0x31, 0x38, 0x64, 0x61, 0x35, 0x35, 0x31, 0x34, 0x39, 0x65, 0x31, 0x66, 0x65, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x32, 0x64, 0x66, 0x39, 0x30, 0x30, 0x64, 0x30, 0x65, 0x30, 0x39, 0x64, 0x37, 0x66, 0x39, 0x38, 0x38, 0x32, 0x36, 0x33, 0x36, 0x33, 0x35, 0x33, 0x37, 0x31, 0x33, 0x39, 0x32, 0x38, 0x61, 0x62, 0x32, 0x63, 0x33, 0x61, 0x36, 0x33, 0x34, 0x62, 0x35, 0x66, 0x63, 0x65, 0x66, 0x65, 0x65, 0x32, 0x63, 0x33, 0x39, 0x34, 0x38, 0x38, 0x36, 0x32, 0x66, 0x34, 0x37, 0x65, 0x39, 0x64, 0x66, 0x38, 0x37, 0x63, 0x39, 0x38, 0x61, 0x65, 0x31, 0x64, 0x30, 0x63, 0x38, 0x30, 0x64, 0x64, 0x39, 0x65, 0x33, 0x39, 0x30, 0x39, 0x35, 0x34, 0x66, 0x37, 0x39, 0x64, 0x39, 0x61, 0x31, 0x39, 0x37, 0x36, 0x30, 0x35, 0x36, 0x39, 0x37, 0x66, 0x39, 0x36, 0x65, 0x64, 0x37, 0x38, 0x63, 0x35, 0x33, 0x63, 0x37, 0x61, 0x66, 0x66, 0x30, 0x31, 0x30, 0x37, 0x62, 0x31, 0x63, 0x32, 0x33, 0x31, 0x62, 0x62, 0x30, 0x65, 0x33, 0x62, 0x37, 0x33, 0x36, 0x66, 0x30, 0x38, 0x61, 0x39, 0x35, 0x63, 0x32, 0x35, 0x35, 0x36, 0x31, 0x65, 0x30, 0x39, 0x37, 0x34, 0x33, 0x30, 0x34, 0x31, 0x37, 0x32, 0x37, 0x61, 0x36, 0x33, 0x36, 0x64, 0x35, 0x38, 0x36, 0x65, 0x62, 0x34, 0x35, 0x63, 0x38, 0x64, 0x62, 0x38, 0x39, 0x64, 0x64, 0x37, 0x31, 0x66, 0x38, 0x33, 0x38, 0x37, 0x39, 0x34, 0x34, 0x38, 0x66, 0x63, 0x64, 0x39, 0x34, 0x36, 0x61, 0x61, 0x39, 0x65, 0x62, 0x31, 0x34, 0x31, 0x34, 0x36, 0x66, 0x36, 0x35, 0x62, 0x30, 0x36, 0x64, 0x37, 0x65, 0x64, 0x32, 0x61, 0x66, 0x64, 0x37, 0x32, 0x62, 0x61, 0x66, 0x32, 0x34, 0x64, 0x37, 0x37, 0x36, 0x35, 0x30, 0x65, 0x32, 0x32, 0x63, 0x63, 0x66, 0x61, 0x64, 0x64, 0x36, 0x39, 0x35, 0x61, 0x66, 0x36, 0x62, 0x37, 0x62, 0x63, 0x61, 0x39, 0x33, 0x63, 0x65, 0x64, 0x36, 0x30, 0x31, 0x63, 0x33, 0x37, 0x32, 0x38, 0x64, 0x39, 0x65, 0x31, 0x32, 0x65, 0x38, 0x64, 0x37, 0x35, 0x31, 0x31, 0x35, 0x66, 0x61, 0x34, 0x35, 0x62, 0x37, 0x32, 0x36, 0x30, 0x37, 0x36, 0x35, 0x65, 0x34, 0x36, 0x39, 0x65, 0x38, 0x39, 0x39, 0x33, 0x38, 0x38, 0x35, 0x66, 0x66, 0x30, 0x32, 0x30, 0x31, 0x65, 0x30, 0x30, 0x31, 0x63, 0x31, 0x64, 0x66, 0x61, 0x65, 0x34, 0x36, 0x33, 0x30, 0x36, 0x38, 0x63, 0x38, 0x31, 0x37, 0x32, 0x34, 0x62, 0x38, 0x37, 0x65, 0x63, 0x39, 0x62, 0x63, 0x37, 0x34, 0x31, 0x66, 0x62, 0x62, 0x65, 0x66, 0x34, 0x36, 0x37, 0x66, 0x34, 0x35, 0x62, 0x31, 0x62, 0x61, 0x34, 0x33, 0x35, 0x32, 0x31, 0x65, 0x63, 0x31, 0x32, 0x32, 0x64, 0x30, 0x66, 0x37, 0x63, 0x32, 0x65, 0x66, 0x66, 0x62, 0x39, 0x32, 0x61, 0x66, 0x34, 0x36, 0x37, 0x37, 0x65, 0x65, 0x30, 0x37, 0x62, 0x31, 0x61, 0x63, 0x65, 0x38, 0x61, 0x38, 0x61, 0x31, 0x37, 0x34, 0x65, 0x61, 0x61, 0x64, 0x37, 0x62, 0x39, 0x66, 0x38, 0x65, 0x63, 0x37, 0x32, 0x38, 0x61, 0x35, 0x35, 0x66, 0x32, 0x36, 0x37, 0x31, 0x33, 0x36, 0x30, 0x38, 0x34, 0x35, 0x38, 0x33, 0x34, 0x64, 0x64, 0x63, 0x61, 0x37, 0x65, 0x64, 0x38, 0x61, 0x30, 0x32, 0x30, 0x34, 0x39, 0x33, 0x66, 0x31, 0x37, 0x65, 0x34, 0x66, 0x31, 0x37, 0x32, 0x35, 0x35, 0x65, 0x30, 0x66, 0x64, 0x37, 0x30, 0x63, 0x39, 0x64, 0x36, 0x34, 0x35, 0x65, 0x66, 0x30, 0x63, 0x63, 0x30, 0x34, 0x30, 0x30, 0x36, 0x65, 0x33, 0x30, 0x38, 0x61, 0x37, 0x36, 0x30, 0x66, 0x30, 0x34, 0x36, 0x62, 0x62, 0x61, 0x31, 0x30, 0x37, 0x34, 0x35, 0x62, 0x33, 0x62, 0x32, 0x34, 0x39, 0x31, 0x38, 0x34, 0x35, 0x62, 0x62, 0x64, 0x62, 0x31, 0x38, 0x62, 0x36, 0x31, 0x34, 0x37, 0x62, 0x30, 0x38, 0x37, 0x39, 0x64, 0x35, 0x65, 0x39, 0x31, 0x34, 0x38, 0x32, 0x30, 0x32, 0x39, 0x31, 0x36, 0x30, 0x31, 0x65, 0x37, 0x35, 0x39, 0x34, 0x63, 0x31, 0x34, 0x65, 0x34, 0x30, 0x62, 0x61, 0x33, 0x33, 0x61, 0x32, 0x30, 0x64, 0x63, 0x35, 0x64, 0x63, 0x32, 0x39, 0x61, 0x31, 0x33, 0x36, 0x32, 0x32, 0x62, 0x31, 0x31, 0x33, 0x35, 0x39, 0x31, 0x33, 0x31, 0x36, 0x66, 0x36, 0x35, 0x39, 0x64, 0x36, 0x30, 0x64, 0x31, 0x62, 0x38, 0x30, 0x63, 0x30, 0x34, 0x63, 0x35, 0x36, 0x37, 0x64, 0x64, 0x33, 0x37, 0x32, 0x37, 0x32, 0x65, 0x38, 0x36, 0x30, 0x34, 0x33, 0x34, 0x35, 0x37, 0x64, 0x35, 0x61, 0x35, 0x62, 0x62, 0x34, 0x33, 0x38, 0x65, 0x64, 0x35, 0x32, 0x65, 0x62, 0x65, 0x39, 0x37, 0x35, 0x63, 0x61, 0x31, 0x34, 0x37, 0x39, 0x64, 0x61, 0x37, 0x37, 0x65, 0x62, 0x63, 0x66, 0x33, 0x35, 0x66, 0x61, 0x33, 0x66, 0x65, 0x62, 0x31, 0x39, 0x39, 0x34, 0x62, 0x65, 0x38, 0x63, 0x31, 0x30, 0x37, 0x32, 0x30, 0x34, 0x62, 0x34, 0x66, 0x30, 0x30, 0x62, 0x36, 0x32, 0x65, 0x65, 0x63, 0x33, 0x32, 0x65, 0x63, 0x61, 0x65, 0x30, 0x64, 0x35, 0x39, 0x38, 0x33, 0x35, 0x65, 0x39, 0x36, 0x38, 0x62, 0x36, 0x62, 0x34, 0x65, 0x63, 0x30, 0x30, 0x39, 0x66, 0x35, 0x35, 0x38, 0x64, 0x37, 0x34, 0x64, 0x64, 0x39, 0x33, 0x37, 0x65, 0x30, 0x33, 0x30, 0x38, 0x62, 0x31, 0x33, 0x62, 0x31, 0x36, 0x37, 0x32, 0x33, 0x33, 0x30, 0x37, 0x34, 0x39, 0x66, 0x33, 0x38, 0x38, 0x39, 0x33, 0x35, 0x34, 0x64, 0x62, 0x38, 0x64, 0x61, 0x31, 0x38, 0x64, 0x36, 0x33, 0x35, 0x30, 0x62, 0x61, 0x39, 0x32, 0x31, 0x61, 0x65, 0x66, 0x62, 0x34, 0x65, 0x35, 0x63, 0x37, 0x35, 0x32, 0x39, 0x33, 0x66, 0x30, 0x30, 0x66, 0x61, 0x66, 0x64, 0x66, 0x64, 0x34, 0x35, 0x35, 0x66, 0x30, 0x64, 0x32, 0x30, 0x62, 0x37, 0x32, 0x62, 0x65, 0x36, 0x31, 0x30, 0x61, 0x32, 0x36, 0x65, 0x65, 0x63, 0x64, 0x31, 0x35, 0x36, 0x36, 0x36, 0x34, 0x32, 0x62, 0x64, 0x65, 0x63, 0x33, 0x37, 0x62, 0x32, 0x64, 0x39, 0x66, 0x38, 0x65, 0x37, 0x63, 0x37, 0x66, 0x64, 0x64, 0x34, 0x37, 0x34, 0x30, 0x66, 0x37, 0x33, 0x35, 0x30, 0x32, 0x39, 0x35, 0x63, 0x33, 0x63, 0x32, 0x30, 0x37, 0x66, 0x35, 0x36, 0x39, 0x63, 0x30, 0x30, 0x38, 0x34, 0x37, 0x30, 0x61, 0x31, 0x38, 0x31, 0x33, 0x61, 0x33, 0x32, 0x31, 0x65, 0x38, 0x35, 0x30, 0x39, 0x63, 0x33, 0x61, 0x30, 0x39, 0x37, 0x36, 0x30, 0x30, 0x61, 0x37, 0x63, 0x32, 0x38, 0x66, 0x63, 0x35, 0x61, 0x64, 0x62, 0x63, 0x32, 0x62, 0x31, 0x63, 0x64, 0x32, 0x62, 0x33, 0x64, 0x66, 0x34, 0x61, 0x38, 0x66, 0x65, 0x64, 0x35, 0x37, 0x33, 0x33, 0x63, 0x31, 0x38, 0x30, 0x33, 0x34, 0x62, 0x38, 0x38, 0x32, 0x36, 0x31, 0x39, 0x31, 0x38, 0x35, 0x32, 0x34, 0x32, 0x35, 0x34, 0x34, 0x65, 0x31, 0x36, 0x32, 0x63, 0x63, 0x37, 0x65, 0x64, 0x65, 0x61, 0x30, 0x62, 0x61, 0x34, 0x34, 0x38, 0x65, 0x39, 0x35, 0x36, 0x38, 0x31, 0x65, 0x38, 0x33, 0x38, 0x37, 0x38, 0x61, 0x37, 0x38, 0x61, 0x38, 0x64, 0x66, 0x66, 0x39, 0x61, 0x37, 0x35, 0x35, 0x65, 0x32, 0x66, 0x66, 0x37, 0x32, 0x36, 0x62, 0x63, 0x33, 0x34, 0x33, 0x39, 0x33, 0x30, 0x34, 0x66, 0x31, 0x31, 0x66, 0x39, 0x64, 0x63, 0x34, 0x32, 0x34, 0x63, 0x31, 0x62, 0x38, 0x66, 0x30, 0x30, 0x66, 0x37, 0x65, 0x31, 0x32, 0x33, 0x31, 0x64, 0x33, 0x65, 0x30, 0x65, 0x65, 0x39, 0x61, 0x63, 0x33, 0x65, 0x64, 0x32, 0x61, 0x35, 0x65, 0x37, 0x38, 0x36, 0x36, 0x37, 0x31, 0x32, 0x63, 0x34, 0x62, 0x34, 0x64, 0x34, 0x61, 0x64, 0x66, 0x63, 0x39, 0x30, 0x66, 0x37, 0x63, 0x34, 0x31, 0x31, 0x34, 0x32, 0x36, 0x30, 0x33, 0x63, 0x36, 0x63, 0x30, 0x30, 0x36, 0x63, 0x34, 0x65, 0x37, 0x36, 0x63, 0x33, 0x38, 0x32, 0x62, 0x65, 0x38, 0x63, 0x30, 0x62, 0x30, 0x36, 0x64, 0x65, 0x64, 0x30, 0x66, 0x30, 0x32, 0x39, 0x33, 0x66, 0x30, 0x62, 0x39, 0x62, 0x33, 0x34, 0x36, 0x62, 0x32, 0x34, 0x34, 0x30, 0x31, 0x31, 0x37, 0x37, 0x38, 0x38, 0x38, 0x34, 0x64, 0x63, 0x34, 0x66, 0x62, 0x63, 0x33, 0x61, 0x34, 0x32, 0x62, 0x30, 0x38, 0x62, 0x64, 0x37, 0x63, 0x38, 0x64, 0x61, 0x62, 0x37, 0x65, 0x33, 0x31, 0x30, 0x39, 0x35, 0x35, 0x36, 0x39, 0x36, 0x61, 0x37, 0x34, 0x61, 0x30, 0x31, 0x65, 0x66, 0x37, 0x31, 0x33, 0x36, 0x30, 0x63, 0x37, 0x31, 0x66, 0x32, 0x35, 0x39, 0x33, 0x61, 0x38, 0x37, 0x37, 0x37, 0x32, 0x39, 0x36, 0x30, 0x64, 0x63, 0x37, 0x39, 0x61, 0x66, 0x32, 0x66, 0x34, 0x36, 0x35, 0x65, 0x38, 0x32, 0x61, 0x33, 0x39, 0x33, 0x37, 0x39, 0x38, 0x61, 0x34, 0x34, 0x65, 0x62, 0x39, 0x63, 0x39, 0x66, 0x35, 0x64, 0x66, 0x63, 0x32, 0x65, 0x61, 0x31, 0x31, 0x32, 0x66, 0x33, 0x34, 0x38, 0x63, 0x61, 0x38, 0x39, 0x35, 0x38, 0x64, 0x34, 0x61, 0x37, 0x32, 0x35, 0x38, 0x66, 0x65, 0x37, 0x32, 0x38, 0x64, 0x37, 0x38, 0x63, 0x31, 0x39, 0x64, 0x61, 0x36, 0x39, 0x35, 0x37, 0x66, 0x63, 0x37, 0x35, 0x64, 0x64, 0x61, 0x61, 0x31, 0x61, 0x63, 0x63, 0x64, 0x34, 0x33, 0x64, 0x39, 0x39, 0x35, 0x64, 0x65, 0x65, 0x36, 0x39, 0x63, 0x33, 0x63, 0x62, 0x61, 0x39, 0x63, 0x38, 0x64, 0x30, 0x33, 0x63, 0x35, 0x39, 0x31, 0x36, 0x64, 0x64, 0x38, 0x35, 0x63, 0x30, 0x64, 0x35, 0x37, 0x37, 0x32, 0x35, 0x31, 0x37, 0x31, 0x34, 0x66, 0x66, 0x65, 0x32, 0x38, 0x35, 0x61, 0x36, 0x34, 0x63, 0x37, 0x36, 0x38, 0x31, 0x64, 0x65, 0x61, 0x62, 0x37, 0x34, 0x66, 0x62, 0x37, 0x31, 0x64, 0x63, 0x34, 0x37, 0x33, 0x39, 0x39, 0x32, 0x35, 0x39, 0x32, 0x65, 0x37, 0x64, 0x39, 0x36, 0x38, 0x30, 0x62, 0x63, 0x36, 0x35, 0x32, 0x32, 0x61, 0x36, 0x30, 0x30, 0x31, 0x36, 0x38, 0x63, 0x37, 0x37, 0x32, 0x65, 0x36, 0x39, 0x62, 0x30, 0x32, 0x34, 0x34, 0x64, 0x66, 0x65, 0x65, 0x39, 0x65, 0x38, 0x38, 0x37, 0x35, 0x64, 0x30, 0x32, 0x66, 0x33, 0x35, 0x36, 0x31, 0x36, 0x65, 0x36, 0x39, 0x62, 0x62, 0x65, 0x30, 0x30, 0x30, 0x31, 0x36, 0x64, 0x36, 0x30, 0x63, 0x38, 0x64, 0x36, 0x39, 0x66, 0x62, 0x32, 0x37, 0x32, 0x61, 0x64, 0x61, 0x63, 0x61, 0x31, 0x37, 0x61, 0x38, 0x61, 0x64, 0x37, 0x32, 0x31, 0x39, 0x31, 0x65, 0x33, 0x64, 0x62, 0x64, 0x62, 0x37, 0x31, 0x62, 0x33, 0x66, 0x37, 0x35, 0x63, 0x37, 0x63, 0x35, 0x30, 0x36, 0x66, 0x30, 0x64, 0x30, 0x61, 0x38, 0x62, 0x65, 0x30, 0x65, 0x39, 0x37, 0x30, 0x35, 0x30, 0x35, 0x32, 0x36, 0x30, 0x61, 0x63, 0x32, 0x35, 0x38, 0x65, 0x66, 0x31, 0x38, 0x64, 0x30, 0x66, 0x38, 0x38, 0x31, 0x33, 0x37, 0x32, 0x37, 0x34, 0x64, 0x32, 0x36, 0x35, 0x36, 0x65, 0x33, 0x36, 0x39, 0x33, 0x63, 0x32, 0x35, 0x64, 0x30, 0x32, 0x64, 0x62, 0x32, 0x64, 0x36, 0x64, 0x61, 0x65, 0x36, 0x33, 0x32, 0x34, 0x64, 0x62, 0x35, 0x32, 0x33, 0x37, 0x33, 0x32, 0x36, 0x31, 0x62, 0x62, 0x66, 0x31, 0x38, 0x66, 0x61, 0x35, 0x66, 0x62, 0x65, 0x39, 0x31, 0x37, 0x64, 0x39, 0x64, 0x39, 0x65, 0x66, 0x37, 0x34, 0x65, 0x34, 0x36, 0x39, 0x31, 0x30, 0x62, 0x61, 0x34, 0x37, 0x35, 0x64, 0x65, 0x34, 0x34, 0x36, 0x35, 0x34, 0x64, 0x64, 0x64, 0x32, 0x37, 0x66, 0x33, 0x30, 0x30, 0x63, 0x39, 0x63, 0x62, 0x61, 0x35, 0x65, 0x35, 0x36, 0x38, 0x38, 0x37, 0x32, 0x35, 0x62, 0x32, 0x34, 0x33, 0x65, 0x39, 0x39, 0x39, 0x63, 0x62, 0x39, 0x63, 0x66, 0x65, 0x62, 0x65, 0x38, 0x31, 0x64, 0x34, 0x34, 0x39, 0x64, 0x64, 0x31, 0x65, 0x38, 0x61, 0x31, 0x66, 0x63, 0x62, 0x64, 0x32, 0x61, 0x37, 0x61, 0x64, 0x32, 0x63, 0x36, 0x30, 0x35, 0x62, 0x31, 0x31, 0x38, 0x37, 0x64, 0x30, 0x30, 0x35, 0x65, 0x34, 0x63, 0x65, 0x64, 0x65, 0x35, 0x37, 0x65, 0x30, 0x65, 0x62, 0x37, 0x32, 0x64, 0x31, 0x65, 0x39, 0x30, 0x36, 0x35, 0x63, 0x65, 0x36, 0x34, 0x38, 0x33, 0x34, 0x30, 0x63, 0x31, 0x39, 0x64, 0x66, 0x63, 0x35, 0x33, 0x61, 0x31, 0x38, 0x34, 0x61, 0x65, 0x66, 0x35, 0x33, 0x63, 0x65, 0x64, 0x64, 0x61, 0x33, 0x31, 0x61, 0x31, 0x66, 0x36, 0x35, 0x31, 0x65, 0x34, 0x38, 0x37, 0x35, 0x65, 0x66, 0x36, 0x33, 0x39, 0x35, 0x37, 0x64, 0x61, 0x35, 0x34, 0x39, 0x62, 0x66, 0x64, 0x33, 0x36, 0x39, 0x37, 0x33, 0x32, 0x66, 0x39, 0x66, 0x33, 0x61, 0x34, 0x39, 0x32, 0x35, 0x32, 0x30, 0x31, 0x35, 0x32, 0x63, 0x37, 0x61, 0x38, 0x37, 0x36, 0x65, 0x30, 0x66, 0x38, 0x64, 0x61, 0x66, 0x61, 0x37, 0x66, 0x63, 0x34, 0x35, 0x30, 0x64, 0x39, 0x32, 0x33, 0x37, 0x37, 0x31, 0x39, 0x36, 0x65, 0x38, 0x37, 0x37, 0x39, 0x31, 0x36, 0x35, 0x38, 0x64, 0x64, 0x62, 0x61, 0x65, 0x66, 0x33, 0x62, 0x61, 0x37, 0x37, 0x34, 0x34, 0x31, 0x30, 0x63, 0x32, 0x35, 0x65, 0x61, 0x62, 0x36, 0x62, 0x32, 0x32, 0x34, 0x37, 0x37, 0x38, 0x65, 0x30, 0x37, 0x32, 0x66, 0x66, 0x65, 0x33, 0x37, 0x39, 0x37, 0x62, 0x37, 0x61, 0x62, 0x34, 0x31, 0x64, 0x66, 0x37, 0x35, 0x65, 0x38, 0x37, 0x64, 0x31, 0x38, 0x36, 0x37, 0x64, 0x34, 0x30, 0x35, 0x66, 0x34, 0x65, 0x37, 0x62, 0x65, 0x61, 0x30, 0x33, 0x31, 0x61, 0x65, 0x61, 0x30, 0x39, 0x36, 0x63, 0x66, 0x36, 0x32, 0x32, 0x30, 0x32, 0x63, 0x35, 0x30, 0x62, 0x62, 0x62, 0x32, 0x61, 0x39, 0x34, 0x35, 0x64, 0x66, 0x39, 0x38, 0x30, 0x32, 0x32, 0x63, 0x34, 0x34, 0x34, 0x35, 0x32, 0x66, 0x36, 0x32, 0x39, 0x64, 0x35, 0x30, 0x38, 0x66, 0x34, 0x33, 0x36, 0x32, 0x34, 0x36, 0x34, 0x32, 0x61, 0x35, 0x34, 0x33, 0x39, 0x66, 0x31, 0x35, 0x33, 0x37, 0x38, 0x30, 0x37, 0x31, 0x38, 0x38, 0x31, 0x32, 0x65, 0x63, 0x39, 0x62, 0x35, 0x62, 0x30, 0x64, 0x31, 0x30, 0x32, 0x38, 0x37, 0x61, 0x64, 0x37, 0x32, 0x63, 0x37, 0x34, 0x61, 0x36, 0x33, 0x65, 0x39, 0x63, 0x61, 0x35, 0x61, 0x39, 0x34, 0x34, 0x61, 0x63, 0x36, 0x61, 0x35, 0x33, 0x32, 0x66, 0x65, 0x61, 0x34, 0x32, 0x37, 0x66, 0x32, 0x32, 0x65, 0x31, 0x63, 0x38, 0x37, 0x32, 0x33, 0x38, 0x34, 0x61, 0x35, 0x32, 0x62, 0x38, 0x30, 0x37, 0x33, 0x35, 0x33, 0x32, 0x39, 0x64, 0x39, 0x32, 0x66, 0x63, 0x65, 0x66, 0x32, 0x33, 0x64, 0x37, 0x32, 0x65, 0x63, 0x31, 0x64, 0x39, 0x63, 0x36, 0x37, 0x64, 0x37, 0x66, 0x64, 0x34, 0x35, 0x61, 0x37, 0x39, 0x30, 0x34, 0x31, 0x39, 0x38, 0x37, 0x64, 0x37, 0x66, 0x35, 0x35, 0x34, 0x34, 0x39, 0x33, 0x37, 0x32, 0x35, 0x39, 0x63, 0x33, 0x35, 0x30, 0x62, 0x36, 0x64, 0x39, 0x31, 0x35, 0x62, 0x36, 0x61, 0x38, 0x37, 0x30, 0x33, 0x31, 0x33, 0x38, 0x31, 0x30, 0x38, 0x39, 0x36, 0x33, 0x37, 0x32, 0x32, 0x34, 0x34, 0x30, 0x32, 0x31, 0x32, 0x35, 0x61, 0x35, 0x65, 0x39, 0x65, 0x64, 0x32, 0x61, 0x66, 0x33, 0x35, 0x35, 0x32, 0x38, 0x62, 0x30, 0x35, 0x36, 0x64, 0x34, 0x36, 0x33, 0x33, 0x38, 0x63, 0x66, 0x36, 0x35, 0x38, 0x36, 0x38, 0x65, 0x66, 0x33, 0x36, 0x31, 0x31, 0x63, 0x63, 0x64, 0x34, 0x66, 0x33, 0x65, 0x66, 0x64, 0x38, 0x39, 0x36, 0x63, 0x38, 0x39, 0x32, 0x36, 0x31, 0x36, 0x32, 0x65, 0x31, 0x64, 0x33, 0x61, 0x62, 0x61, 0x39, 0x62, 0x66, 0x31, 0x35, 0x33, 0x39, 0x66, 0x64, 0x38, 0x33, 0x34, 0x38, 0x31, 0x37, 0x65, 0x36, 0x62, 0x34, 0x64, 0x39, 0x39, 0x36, 0x37, 0x33, 0x38, 0x65, 0x65, 0x61, 0x39, 0x38, 0x63, 0x65, 0x64, 0x32, 0x39, 0x33, 0x63, 0x63, 0x62, 0x64, 0x62, 0x34, 0x32, 0x31, 0x31, 0x66, 0x30, 0x30, 0x39, 0x39, 0x31, 0x31, 0x64, 0x31, 0x64, 0x30, 0x36, 0x62, 0x32, 0x38, 0x34, 0x36, 0x34, 0x61, 0x33, 0x66, 0x37, 0x35, 0x63, 0x35, 0x36, 0x39, 0x30, 0x38, 0x33, 0x31, 0x36, 0x63, 0x32, 0x30, 0x66, 0x37, 0x61, 0x66, 0x30, 0x39, 0x32, 0x66, 0x33, 0x34, 0x62, 0x39, 0x66, 0x65, 0x34, 0x35, 0x32, 0x62, 0x66, 0x62, 0x62, 0x30, 0x37, 0x32, 0x30, 0x35, 0x65, 0x34, 0x61, 0x30, 0x35, 0x38, 0x61, 0x37, 0x65, 0x32, 0x35, 0x34, 0x62, 0x35, 0x63, 0x39, 0x34, 0x36, 0x64, 0x35, 0x38, 0x66, 0x35, 0x35, 0x39, 0x35, 0x63, 0x39, 0x32, 0x66, 0x30, 0x36, 0x37, 0x32, 0x63, 0x34, 0x32, 0x34, 0x65, 0x34, 0x62, 0x61, 0x33, 0x30, 0x63, 0x33, 0x62, 0x35, 0x30, 0x66, 0x63, 0x32, 0x31, 0x35, 0x35, 0x30, 0x61, 0x37, 0x64, 0x65, 0x37, 0x31, 0x35, 0x33, 0x36, 0x62, 0x64, 0x62, 0x62, 0x39, 0x33, 0x31, 0x34, 0x33, 0x62, 0x37, 0x32, 0x61, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x62, 0x61, 0x38, 0x65, 0x39, 0x39, 0x64, 0x36, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x32, 0x64, 0x35, 0x33, 0x30, 0x36, 0x36, 0x64, 0x39, 0x38, 0x35, 0x30, 0x36, 0x31, 0x37, 0x61, 0x35, 0x31, 0x66, 0x62, 0x36, 0x62, 0x65, 0x66, 0x33, 0x36, 0x33, 0x33, 0x32, 0x37, 0x33, 0x63, 0x64, 0x39, 0x32, 0x30, 0x33, 0x63, 0x34, 0x61, 0x65, 0x37, 0x31, 0x61, 0x34, 0x35, 0x38, 0x61, 0x36, 0x62, 0x65, 0x62, 0x35, 0x61, 0x62, 0x66, 0x32, 0x35, 0x36, 0x32, 0x38, 0x62, 0x64, 0x30, 0x32, 0x36, 0x34, 0x33, 0x33, 0x38, 0x39, 0x30, 0x61, 0x64, 0x31, 0x62, 0x32, 0x38, 0x65, 0x61, 0x65, 0x62, 0x39, 0x31, 0x34, 0x62, 0x39, 0x34, 0x33, 0x65, 0x64, 0x62, 0x36, 0x36, 0x30, 0x32, 0x33, 0x66, 0x61, 0x66, 0x36, 0x65, 0x35, 0x33, 0x31, 0x36, 0x38, 0x32, 0x33, 0x65, 0x33, 0x64, 0x66, 0x35, 0x64, 0x61, 0x65, 0x66, 0x62, 0x65, 0x37, 0x62, 0x65, 0x64, 0x34, 0x33, 0x34, 0x64, 0x65, 0x35, 0x30, 0x65, 0x30, 0x39, 0x31, 0x35, 0x62, 0x39, 0x66, 0x34, 0x65, 0x34, 0x34, 0x31, 0x63, 0x33, 0x36, 0x34, 0x66, 0x65, 0x38, 0x63, 0x34, 0x64, 0x35, 0x34, 0x39, 0x63, 0x33, 0x61, 0x66, 0x62, 0x66, 0x63, 0x36, 0x35, 0x34, 0x38, 0x39, 0x37, 0x32, 0x64, 0x65, 0x64, 0x32, 0x39, 0x34, 0x32, 0x38, 0x37, 0x37, 0x36, 0x66, 0x30, 0x62, 0x62, 0x62, 0x65, 0x62, 0x31, 0x31, 0x32, 0x64, 0x62, 0x33, 0x61, 0x30, 0x31, 0x61, 0x36, 0x63, 0x63, 0x65, 0x32, 0x63, 0x65, 0x31, 0x62, 0x38, 0x62, 0x30, 0x62, 0x36, 0x38, 0x38, 0x64, 0x39, 0x63, 0x32, 0x39, 0x64, 0x33, 0x39, 0x61, 0x32, 0x61, 0x62, 0x30, 0x63, 0x33, 0x63, 0x38, 0x61, 0x32, 0x36, 0x33, 0x38, 0x66, 0x66, 0x34, 0x30, 0x36, 0x35, 0x64, 0x38, 0x66, 0x66, 0x64, 0x39, 0x38, 0x35, 0x32, 0x36, 0x30, 0x30, 0x32, 0x32, 0x31, 0x64, 0x34, 0x33, 0x30, 0x39, 0x30, 0x37, 0x37, 0x34, 0x34, 0x37, 0x30, 0x30, 0x39, 0x35, 0x61, 0x38, 0x35, 0x64, 0x64, 0x34, 0x61, 0x31, 0x33, 0x37, 0x37, 0x37, 0x36, 0x39, 0x65, 0x66, 0x62, 0x31, 0x31, 0x33, 0x65, 0x65, 0x63, 0x65, 0x30, 0x32, 0x61, 0x30, 0x38, 0x37, 0x39, 0x31, 0x64, 0x32, 0x37, 0x65, 0x35, 0x33, 0x37, 0x34, 0x34, 0x36, 0x65, 0x66, 0x64, 0x33, 0x30, 0x62, 0x35, 0x32, 0x65, 0x39, 0x64, 0x35, 0x36, 0x31, 0x64, 0x32, 0x65, 0x64, 0x62, 0x66, 0x31, 0x35, 0x32, 0x39, 0x37, 0x62, 0x62, 0x63, 0x66, 0x30, 0x65, 0x34, 0x62, 0x61, 0x32, 0x33, 0x38, 0x30, 0x63, 0x63, 0x30, 0x61, 0x61, 0x31, 0x64, 0x61, 0x37, 0x32, 0x32, 0x62, 0x65, 0x30, 0x65, 0x39, 0x66, 0x37, 0x35, 0x32, 0x62, 0x35, 0x35, 0x38, 0x37, 0x64, 0x39, 0x61, 0x32, 0x65, 0x65, 0x62, 0x38, 0x34, 0x36, 0x62, 0x64, 0x62, 0x32, 0x64, 0x65, 0x36, 0x34, 0x37, 0x34, 0x64, 0x65, 0x62, 0x62, 0x62, 0x63, 0x65, 0x32, 0x66, 0x35, 0x31, 0x66, 0x61, 0x39, 0x61, 0x37, 0x65, 0x35, 0x62, 0x64, 0x62, 0x34, 0x37, 0x33, 0x37, 0x35, 0x66, 0x37, 0x32, 0x37, 0x32, 0x65, 0x33, 0x39, 0x30, 0x65, 0x65, 0x62, 0x30, 0x30, 0x31, 0x34, 0x35, 0x61, 0x33, 0x37, 0x31, 0x39, 0x31, 0x34, 0x35, 0x61, 0x30, 0x34, 0x32, 0x35, 0x36, 0x66, 0x33, 0x65, 0x33, 0x30, 0x38, 0x65, 0x64, 0x63, 0x65, 0x33, 0x65, 0x36, 0x34, 0x37, 0x38, 0x62, 0x65, 0x30, 0x65, 0x37, 0x61, 0x34, 0x32, 0x36, 0x64, 0x33, 0x39, 0x38, 0x33, 0x62, 0x38, 0x64, 0x31, 0x37, 0x32, 0x34, 0x65, 0x32, 0x32, 0x31, 0x65, 0x33, 0x35, 0x35, 0x61, 0x38, 0x30, 0x30, 0x30, 0x61, 0x36, 0x32, 0x31, 0x66, 0x63, 0x32, 0x64, 0x37, 0x63, 0x62, 0x61, 0x38, 0x33, 0x66, 0x35, 0x39, 0x30, 0x36, 0x38, 0x64, 0x30, 0x64, 0x64, 0x38, 0x38, 0x37, 0x38, 0x36, 0x32, 0x63, 0x30, 0x30, 0x62, 0x35, 0x64, 0x31, 0x38, 0x65, 0x62, 0x38, 0x61, 0x63, 0x38, 0x61, 0x33, 0x35, 0x37, 0x37, 0x32, 0x66, 0x31, 0x31, 0x61, 0x66, 0x64, 0x33, 0x34, 0x39, 0x38, 0x65, 0x39, 0x31, 0x32, 0x63, 0x38, 0x31, 0x33, 0x34, 0x31, 0x39, 0x61, 0x35, 0x35, 0x61, 0x38, 0x35, 0x38, 0x39, 0x66, 0x34, 0x31, 0x32, 0x64, 0x37, 0x66, 0x62, 0x61, 0x30, 0x39, 0x35, 0x33, 0x33, 0x35, 0x64, 0x34, 0x65, 0x37, 0x34, 0x35, 0x36, 0x62, 0x34, 0x61, 0x38, 0x38, 0x38, 0x35, 0x62, 0x38, 0x38, 0x62, 0x37, 0x32, 0x66, 0x36, 0x64, 0x61, 0x39, 0x64, 0x64, 0x63, 0x37, 0x32, 0x31, 0x65, 0x32, 0x36, 0x39, 0x38, 0x31, 0x37, 0x33, 0x36, 0x34, 0x35, 0x34, 0x65, 0x30, 0x37, 0x32, 0x34, 0x65, 0x38, 0x66, 0x30, 0x38, 0x39, 0x65, 0x61, 0x36, 0x65, 0x61, 0x31, 0x33, 0x63, 0x64, 0x36, 0x61, 0x61, 0x39, 0x30, 0x64, 0x61, 0x34, 0x34, 0x33, 0x39, 0x64, 0x32, 0x66, 0x32, 0x62, 0x37, 0x39, 0x33, 0x36, 0x63, 0x38, 0x62, 0x39, 0x30, 0x66, 0x30, 0x61, 0x62, 0x31, 0x64, 0x62, 0x33, 0x33, 0x66, 0x62, 0x64, 0x66, 0x34, 0x66, 0x38, 0x33, 0x35, 0x64, 0x30, 0x32, 0x64, 0x33, 0x66, 0x35, 0x36, 0x32, 0x37, 0x64, 0x66, 0x61, 0x65, 0x62, 0x63, 0x37, 0x38, 0x62, 0x35, 0x31, 0x65, 0x38, 0x34, 0x38, 0x63, 0x64, 0x34, 0x30, 0x62, 0x64, 0x65, 0x38, 0x39, 0x61, 0x31, 0x31, 0x37, 0x31, 0x30, 0x37, 0x32, 0x31, 0x63, 0x36, 0x61, 0x34, 0x34, 0x31, 0x33, 0x65, 0x34, 0x65, 0x64, 0x38, 0x33, 0x30, 0x39, 0x39, 0x33, 0x36, 0x33, 0x30, 0x61, 0x66, 0x66, 0x37, 0x62, 0x35, 0x36, 0x37, 0x61, 0x39, 0x36, 0x64, 0x63, 0x32, 0x63, 0x30, 0x32, 0x36, 0x30, 0x63, 0x33, 0x32, 0x65, 0x31, 0x62, 0x35, 0x61, 0x34, 0x37, 0x65, 0x61, 0x61, 0x32, 0x33, 0x62, 0x31, 0x35, 0x33, 0x33, 0x62, 0x33, 0x37, 0x32, 0x32, 0x34, 0x61, 0x34, 0x62, 0x31, 0x39, 0x38, 0x32, 0x64, 0x61, 0x39, 0x34, 0x36, 0x33, 0x63, 0x61, 0x34, 0x64, 0x37, 0x37, 0x39, 0x30, 0x65, 0x63, 0x64, 0x38, 0x35, 0x32, 0x62, 0x33, 0x38, 0x35, 0x34, 0x64, 0x38, 0x35, 0x39, 0x35, 0x63, 0x65, 0x32, 0x63, 0x36, 0x36, 0x36, 0x30, 0x39, 0x39, 0x34, 0x32, 0x31, 0x32, 0x35, 0x36, 0x37, 0x30, 0x38, 0x39, 0x64, 0x35, 0x39, 0x37, 0x32, 0x63, 0x38, 0x65, 0x37, 0x31, 0x38, 0x61, 0x33, 0x63, 0x64, 0x63, 0x36, 0x37, 0x34, 0x30, 0x35, 0x61, 0x62, 0x36, 0x32, 0x39, 0x64, 0x32, 0x32, 0x61, 0x65, 0x62, 0x63, 0x34, 0x34, 0x65, 0x34, 0x30, 0x66, 0x62, 0x61, 0x65, 0x61, 0x30, 0x38, 0x33, 0x35, 0x65, 0x38, 0x30, 0x39, 0x66, 0x39, 0x32, 0x34, 0x36, 0x30, 0x34, 0x65, 0x37, 0x63, 0x61, 0x39, 0x63, 0x63, 0x32, 0x62, 0x37, 0x32, 0x35, 0x34, 0x38, 0x31, 0x38, 0x65, 0x39, 0x65, 0x61, 0x35, 0x62, 0x64, 0x66, 0x30, 0x39, 0x65, 0x35, 0x61, 0x39, 0x32, 0x39, 0x36, 0x30, 0x65, 0x34, 0x35, 0x37, 0x37, 0x39, 0x65, 0x64, 0x33, 0x36, 0x30, 0x65, 0x64, 0x35, 0x66, 0x61, 0x30, 0x33, 0x31, 0x66, 0x64, 0x65, 0x65, 0x63, 0x35, 0x36, 0x66, 0x38, 0x38, 0x66, 0x37, 0x35, 0x63, 0x62, 0x35, 0x36, 0x35, 0x36, 0x31, 0x36, 0x36, 0x34, 0x62, 0x64, 0x61, 0x30, 0x61, 0x65, 0x35, 0x63, 0x61, 0x33, 0x65, 0x35, 0x61, 0x37, 0x34, 0x63, 0x38, 0x30, 0x61, 0x64, 0x38, 0x32, 0x33, 0x39, 0x63, 0x63, 0x63, 0x35, 0x65, 0x37, 0x31, 0x64, 0x32, 0x37, 0x66, 0x35, 0x35, 0x31, 0x65, 0x62, 0x31, 0x30, 0x62, 0x62, 0x39, 0x64, 0x64, 0x64, 0x38, 0x33, 0x38, 0x30, 0x35, 0x32, 0x66, 0x38, 0x64, 0x33, 0x32, 0x63, 0x66, 0x35, 0x37, 0x32, 0x30, 0x39, 0x62, 0x61, 0x63, 0x34, 0x62, 0x36, 0x38, 0x33, 0x36, 0x64, 0x63, 0x35, 0x61, 0x61, 0x63, 0x34, 0x63, 0x62, 0x62, 0x61, 0x38, 0x37, 0x63, 0x38, 0x38, 0x66, 0x37, 0x38, 0x66, 0x36, 0x61, 0x32, 0x34, 0x32, 0x36, 0x30, 0x66, 0x37, 0x37, 0x61, 0x32, 0x31, 0x61, 0x33, 0x34, 0x38, 0x65, 0x33, 0x63, 0x34, 0x35, 0x32, 0x64, 0x38, 0x35, 0x66, 0x66, 0x65, 0x39, 0x37, 0x32, 0x35, 0x38, 0x30, 0x34, 0x63, 0x31, 0x62, 0x63, 0x38, 0x33, 0x35, 0x65, 0x34, 0x37, 0x36, 0x38, 0x61, 0x35, 0x34, 0x36, 0x30, 0x63, 0x65, 0x66, 0x63, 0x39, 0x62, 0x64, 0x65, 0x35, 0x36, 0x35, 0x66, 0x37, 0x66, 0x61, 0x61, 0x38, 0x31, 0x39, 0x61, 0x38, 0x61, 0x64, 0x34, 0x38, 0x63, 0x39, 0x36, 0x32, 0x65, 0x61, 0x37, 0x39, 0x61, 0x38, 0x38, 0x35, 0x62, 0x35, 0x35, 0x61, 0x37, 0x32, 0x34, 0x61, 0x32, 0x31, 0x36, 0x61, 0x32, 0x65, 0x64, 0x30, 0x34, 0x64, 0x61, 0x33, 0x63, 0x38, 0x30, 0x35, 0x63, 0x62, 0x36, 0x30, 0x37, 0x64, 0x39, 0x33, 0x33, 0x62, 0x66, 0x33, 0x36, 0x33, 0x34, 0x39, 0x63, 0x39, 0x65, 0x62, 0x62, 0x32, 0x35, 0x64, 0x36, 0x61, 0x39, 0x34, 0x39, 0x64, 0x34, 0x31, 0x66, 0x38, 0x31, 0x63, 0x33, 0x31, 0x61, 0x37, 0x61, 0x66, 0x32, 0x38, 0x37, 0x32, 0x32, 0x61, 0x61, 0x61, 0x35, 0x64, 0x66, 0x61, 0x61, 0x33, 0x61, 0x61, 0x35, 0x63, 0x66, 0x64, 0x66, 0x61, 0x61, 0x30, 0x63, 0x33, 0x37, 0x38, 0x62, 0x33, 0x62, 0x38, 0x64, 0x62, 0x64, 0x32, 0x64, 0x37, 0x62, 0x63, 0x62, 0x65, 0x36, 0x30, 0x33, 0x62, 0x32, 0x66, 0x31, 0x32, 0x32, 0x65, 0x31, 0x37, 0x38, 0x39, 0x37, 0x61, 0x35, 0x65, 0x34, 0x64, 0x35, 0x61, 0x32, 0x34, 0x37, 0x32, 0x36, 0x61, 0x62, 0x36, 0x63, 0x62, 0x32, 0x63, 0x36, 0x65, 0x37, 0x37, 0x35, 0x30, 0x39, 0x61, 0x32, 0x36, 0x65, 0x32, 0x66, 0x38, 0x38, 0x31, 0x38, 0x32, 0x63, 0x33, 0x63, 0x62, 0x31, 0x64, 0x65, 0x66, 0x66, 0x32, 0x39, 0x62, 0x66, 0x33, 0x34, 0x32, 0x37, 0x38, 0x36, 0x38, 0x34, 0x39, 0x30, 0x34, 0x64, 0x34, 0x35, 0x32, 0x66, 0x62, 0x30, 0x35, 0x34, 0x33, 0x39, 0x33, 0x37, 0x32, 0x65, 0x30, 0x66, 0x62, 0x34, 0x62, 0x35, 0x32, 0x62, 0x62, 0x64, 0x65, 0x35, 0x31, 0x30, 0x37, 0x32, 0x39, 0x31, 0x31, 0x39, 0x62, 0x62, 0x35, 0x33, 0x31, 0x39, 0x63, 0x37, 0x35, 0x34, 0x61, 0x63, 0x64, 0x66, 0x32, 0x34, 0x62, 0x64, 0x35, 0x62, 0x32, 0x38, 0x38, 0x31, 0x31, 0x39, 0x39, 0x39, 0x64, 0x39, 0x63, 0x62, 0x31, 0x38, 0x38, 0x34, 0x66, 0x63, 0x31, 0x66, 0x36, 0x37, 0x32, 0x35, 0x62, 0x30, 0x63, 0x35, 0x37, 0x38, 0x38, 0x39, 0x33, 0x33, 0x35, 0x34, 0x64, 0x32, 0x61, 0x63, 0x62, 0x38, 0x32, 0x36, 0x31, 0x61, 0x32, 0x32, 0x66, 0x39, 0x64, 0x35, 0x62, 0x66, 0x62, 0x32, 0x33, 0x64, 0x64, 0x33, 0x64, 0x64, 0x32, 0x66, 0x32, 0x61, 0x33, 0x31, 0x30, 0x39, 0x36, 0x64, 0x31, 0x30, 0x66, 0x63, 0x61, 0x37, 0x31, 0x62, 0x33, 0x30, 0x37, 0x61, 0x30, 0x33, 0x64, 0x36, 0x36, 0x35, 0x61, 0x35, 0x37, 0x66, 0x38, 0x36, 0x35, 0x64, 0x32, 0x31, 0x62, 0x38, 0x37, 0x65, 0x64, 0x66, 0x36, 0x66, 0x37, 0x64, 0x61, 0x64, 0x64, 0x32, 0x62, 0x39, 0x38, 0x39, 0x31, 0x38, 0x35, 0x31, 0x34, 0x65, 0x33, 0x31, 0x64, 0x32, 0x31, 0x63, 0x63, 0x62, 0x30, 0x66, 0x36, 0x34, 0x39, 0x64, 0x64, 0x62, 0x34, 0x37, 0x36, 0x35, 0x61, 0x35, 0x38, 0x31, 0x61, 0x30, 0x64, 0x63, 0x38, 0x38, 0x66, 0x36, 0x38, 0x65, 0x61, 0x31, 0x30, 0x34, 0x61, 0x30, 0x31, 0x34, 0x38, 0x31, 0x39, 0x37, 0x30, 0x63, 0x36, 0x63, 0x32, 0x64, 0x38, 0x32, 0x39, 0x30, 0x62, 0x63, 0x62, 0x63, 0x64, 0x65, 0x31, 0x64, 0x35, 0x39, 0x63, 0x38, 0x36, 0x34, 0x32, 0x35, 0x37, 0x35, 0x64, 0x62, 0x30, 0x61, 0x61, 0x38, 0x38, 0x32, 0x65, 0x31, 0x66, 0x65, 0x65, 0x37, 0x33, 0x37, 0x32, 0x30, 0x36, 0x65, 0x32, 0x65, 0x32, 0x38, 0x63, 0x66, 0x65, 0x36, 0x30, 0x35, 0x61, 0x61, 0x38, 0x39, 0x38, 0x34, 0x36, 0x33, 0x39, 0x32, 0x39, 0x36, 0x36, 0x36, 0x63, 0x66, 0x62, 0x63, 0x31, 0x65, 0x65, 0x32, 0x65, 0x30, 0x34, 0x61, 0x37, 0x63, 0x35, 0x62, 0x31, 0x30, 0x66, 0x64, 0x64, 0x33, 0x37, 0x65, 0x64, 0x38, 0x33, 0x64, 0x33, 0x63, 0x38, 0x30, 0x31, 0x65, 0x32, 0x37, 0x32, 0x38, 0x32, 0x61, 0x30, 0x36, 0x36, 0x35, 0x31, 0x37, 0x63, 0x30, 0x37, 0x62, 0x66, 0x32, 0x65, 0x62, 0x30, 0x34, 0x61, 0x38, 0x32, 0x30, 0x65, 0x39, 0x30, 0x35, 0x64, 0x39, 0x62, 0x66, 0x38, 0x36, 0x31, 0x64, 0x36, 0x62, 0x32, 0x65, 0x31, 0x38, 0x31, 0x31, 0x37, 0x35, 0x65, 0x64, 0x35, 0x38, 0x66, 0x36, 0x36, 0x31, 0x35, 0x64, 0x32, 0x37, 0x33, 0x35, 0x61, 0x32, 0x30, 0x37, 0x32, 0x66, 0x65, 0x33, 0x62, 0x62, 0x61, 0x38, 0x35, 0x65, 0x63, 0x38, 0x38, 0x31, 0x39, 0x62, 0x66, 0x31, 0x33, 0x62, 0x61, 0x32, 0x66, 0x38, 0x63, 0x36, 0x34, 0x30, 0x33, 0x38, 0x33, 0x31, 0x39, 0x34, 0x64, 0x62, 0x37, 0x61, 0x36, 0x63, 0x35, 0x31, 0x66, 0x39, 0x35, 0x39, 0x63, 0x39, 0x37, 0x38, 0x34, 0x31, 0x38, 0x62, 0x36, 0x39, 0x63, 0x31, 0x62, 0x65, 0x63, 0x35, 0x62, 0x33, 0x65, 0x35, 0x35, 0x64, 0x66, 0x37, 0x39, 0x37, 0x39, 0x65, 0x39, 0x65, 0x62, 0x30, 0x34, 0x33, 0x31, 0x61, 0x34, 0x65, 0x61, 0x65, 0x32, 0x65, 0x66, 0x38, 0x30, 0x64, 0x37, 0x39, 0x34, 0x64, 0x39, 0x63, 0x65, 0x38, 0x37, 0x39, 0x65, 0x64, 0x31, 0x38, 0x39, 0x62, 0x63, 0x65, 0x63, 0x39, 0x31, 0x33, 0x33, 0x36, 0x61, 0x66, 0x63, 0x61, 0x32, 0x34, 0x39, 0x34, 0x36, 0x62, 0x64, 0x37, 0x32, 0x32, 0x65, 0x36, 0x62, 0x64, 0x35, 0x39, 0x32, 0x38, 0x61, 0x65, 0x37, 0x64, 0x30, 0x66, 0x63, 0x34, 0x62, 0x65, 0x63, 0x33, 0x31, 0x61, 0x62, 0x36, 0x39, 0x37, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x63, 0x36, 0x39, 0x32, 0x33, 0x63, 0x62, 0x62, 0x64, 0x37, 0x62, 0x65, 0x63, 0x35, 0x37, 0x31, 0x38, 0x36, 0x31, 0x61, 0x32, 0x35, 0x64, 0x61, 0x35, 0x31, 0x33, 0x37, 0x39, 0x36, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x31, 0x34, 0x39, 0x33, 0x63, 0x35, 0x31, 0x38, 0x36, 0x39, 0x32, 0x66, 0x30, 0x30, 0x64, 0x35, 0x34, 0x39, 0x35, 0x64, 0x39, 0x31, 0x65, 0x32, 0x63, 0x30, 0x37, 0x34, 0x33, 0x37, 0x34, 0x36, 0x33, 0x62, 0x35, 0x37, 0x37, 0x63, 0x30, 0x35, 0x32, 0x62, 0x37, 0x34, 0x37, 0x61, 0x37, 0x37, 0x33, 0x34, 0x39, 0x37, 0x33, 0x32, 0x64, 0x38, 0x37, 0x32, 0x36, 0x39, 0x35, 0x64, 0x39, 0x33, 0x30, 0x38, 0x38, 0x63, 0x38, 0x64, 0x38, 0x65, 0x61, 0x35, 0x61, 0x63, 0x39, 0x38, 0x31, 0x62, 0x30, 0x62, 0x35, 0x64, 0x66, 0x30, 0x63, 0x31, 0x33, 0x30, 0x39, 0x66, 0x30, 0x62, 0x62, 0x66, 0x62, 0x62, 0x33, 0x61, 0x39, 0x61, 0x30, 0x39, 0x35, 0x34, 0x36, 0x35, 0x35, 0x35, 0x30, 0x62, 0x37, 0x65, 0x37, 0x36, 0x34, 0x63, 0x32, 0x34, 0x36, 0x34, 0x63, 0x34, 0x64, 0x38, 0x39, 0x34, 0x64, 0x33, 0x61, 0x65, 0x38, 0x66, 0x65, 0x30, 0x37, 0x35, 0x64, 0x33, 0x63, 0x37, 0x64, 0x63, 0x33, 0x32, 0x66, 0x62, 0x34, 0x34, 0x34, 0x63, 0x61, 0x66, 0x33, 0x36, 0x30, 0x63, 0x61, 0x38, 0x33, 0x37, 0x30, 0x32, 0x35, 0x66, 0x63, 0x65, 0x66, 0x65, 0x34, 0x63, 0x30, 0x62, 0x30, 0x63, 0x30, 0x62, 0x63, 0x36, 0x38, 0x63, 0x65, 0x35, 0x33, 0x35, 0x30, 0x61, 0x33, 0x37, 0x33, 0x37, 0x32, 0x32, 0x30, 0x64, 0x64, 0x38, 0x65, 0x64, 0x30, 0x62, 0x64, 0x33, 0x30, 0x62, 0x36, 0x62, 0x61, 0x64, 0x33, 0x30, 0x35, 0x36, 0x64, 0x66, 0x66, 0x39, 0x64, 0x61, 0x38, 0x34, 0x34, 0x35, 0x36, 0x64, 0x34, 0x32, 0x63, 0x37, 0x64, 0x36, 0x31, 0x33, 0x32, 0x65, 0x37, 0x31, 0x61, 0x64, 0x64, 0x65, 0x63, 0x35, 0x33, 0x31, 0x32, 0x62, 0x37, 0x32, 0x33, 0x36, 0x32, 0x34, 0x32, 0x33, 0x62, 0x33, 0x31, 0x38, 0x63, 0x36, 0x66, 0x33, 0x31, 0x39, 0x37, 0x66, 0x62, 0x61, 0x62, 0x36, 0x61, 0x34, 0x37, 0x36, 0x30, 0x66, 0x66, 0x34, 0x38, 0x33, 0x36, 0x38, 0x62, 0x66, 0x66, 0x32, 0x36, 0x38, 0x38, 0x66, 0x33, 0x36, 0x36, 0x38, 0x37, 0x62, 0x31, 0x64, 0x37, 0x39, 0x61, 0x30, 0x62, 0x33, 0x35, 0x35, 0x65, 0x33, 0x36, 0x33, 0x37, 0x32, 0x63, 0x34, 0x35, 0x34, 0x65, 0x63, 0x32, 0x37, 0x64, 0x65, 0x66, 0x31, 0x65, 0x35, 0x66, 0x35, 0x34, 0x35, 0x64, 0x35, 0x63, 0x61, 0x63, 0x35, 0x30, 0x37, 0x36, 0x38, 0x63, 0x38, 0x61, 0x30, 0x65, 0x35, 0x36, 0x65, 0x65, 0x62, 0x39, 0x30, 0x65, 0x64, 0x33, 0x31, 0x39, 0x33, 0x33, 0x32, 0x62, 0x33, 0x39, 0x37, 0x31, 0x66, 0x66, 0x64, 0x32, 0x62, 0x36, 0x33, 0x65, 0x30, 0x37, 0x32, 0x32, 0x37, 0x33, 0x64, 0x39, 0x35, 0x34, 0x63, 0x65, 0x30, 0x33, 0x64, 0x38, 0x66, 0x30, 0x61, 0x30, 0x33, 0x36, 0x65, 0x32, 0x31, 0x61, 0x36, 0x63, 0x33, 0x62, 0x34, 0x34, 0x31, 0x37, 0x65, 0x31, 0x66, 0x62, 0x35, 0x66, 0x63, 0x64, 0x34, 0x61, 0x66, 0x37, 0x38, 0x32, 0x66, 0x33, 0x36, 0x39, 0x35, 0x33, 0x38, 0x66, 0x38, 0x65, 0x37, 0x65, 0x32, 0x39, 0x34, 0x36, 0x66, 0x37, 0x32, 0x62, 0x64, 0x30, 0x35, 0x63, 0x37, 0x36, 0x62, 0x64, 0x66, 0x66, 0x30, 0x34, 0x64, 0x63, 0x62, 0x30, 0x66, 0x63, 0x36, 0x31, 0x34, 0x30, 0x39, 0x31, 0x61, 0x30, 0x66, 0x62, 0x32, 0x33, 0x37, 0x38, 0x32, 0x39, 0x66, 0x61, 0x39, 0x33, 0x65, 0x64, 0x37, 0x31, 0x63, 0x66, 0x63, 0x36, 0x34, 0x36, 0x66, 0x32, 0x35, 0x35, 0x30, 0x37, 0x64, 0x62, 0x66, 0x32, 0x30, 0x37, 0x66, 0x36, 0x66, 0x37, 0x62, 0x36, 0x66, 0x61, 0x35, 0x33, 0x38, 0x61, 0x65, 0x62, 0x37, 0x37, 0x33, 0x61, 0x37, 0x61, 0x63, 0x62, 0x65, 0x31, 0x61, 0x37, 0x37, 0x64, 0x63, 0x63, 0x66, 0x32, 0x65, 0x62, 0x65, 0x30, 0x63, 0x39, 0x64, 0x32, 0x66, 0x31, 0x31, 0x38, 0x30, 0x31, 0x32, 0x61, 0x31, 0x36, 0x33, 0x31, 0x66, 0x61, 0x31, 0x35, 0x34, 0x64, 0x30, 0x65, 0x31, 0x63, 0x34, 0x63, 0x36, 0x37, 0x32, 0x39, 0x35, 0x35, 0x62, 0x62, 0x64, 0x39, 0x37, 0x65, 0x31, 0x65, 0x34, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x65, 0x35, 0x35, 0x31, 0x64, 0x37, 0x31, 0x38, 0x63, 0x38, 0x61, 0x36, 0x61, 0x33, 0x32, 0x65, 0x37, 0x66, 0x31, 0x34, 0x66, 0x39, 0x35, 0x64, 0x63, 0x31, 0x62, 0x31, 0x37, 0x63, 0x36, 0x37, 0x65, 0x62, 0x39, 0x61, 0x32, 0x65, 0x30, 0x31, 0x61, 0x65, 0x66, 0x34, 0x35, 0x64, 0x63, 0x30, 0x37, 0x30, 0x37, 0x65, 0x39, 0x36, 0x36, 0x62, 0x31, 0x32, 0x39, 0x36, 0x39, 0x62, 0x35, 0x35, 0x32, 0x39, 0x34, 0x61, 0x32, 0x63, 0x62, 0x66, 0x62, 0x35, 0x36, 0x36, 0x36, 0x66, 0x62, 0x61, 0x39, 0x31, 0x63, 0x33, 0x39, 0x32, 0x36, 0x38, 0x31, 0x37, 0x39, 0x32, 0x37, 0x61, 0x36, 0x31, 0x63, 0x34, 0x65, 0x65, 0x37, 0x36, 0x39, 0x63, 0x34, 0x33, 0x39, 0x36, 0x37, 0x32, 0x63, 0x65, 0x63, 0x62, 0x33, 0x63, 0x66, 0x34, 0x62, 0x66, 0x35, 0x65, 0x65, 0x63, 0x63, 0x35, 0x62, 0x61, 0x64, 0x66, 0x33, 0x31, 0x63, 0x32, 0x39, 0x62, 0x63, 0x34, 0x30, 0x33, 0x34, 0x34, 0x64, 0x34, 0x61, 0x63, 0x32, 0x36, 0x31, 0x35, 0x38, 0x38, 0x32, 0x31, 0x33, 0x65, 0x30, 0x37, 0x36, 0x37, 0x61, 0x31, 0x61, 0x36, 0x30, 0x35, 0x33, 0x63, 0x38, 0x38, 0x33, 0x38, 0x37, 0x32, 0x34, 0x63, 0x38, 0x61, 0x38, 0x65, 0x63, 0x65, 0x66, 0x37, 0x36, 0x37, 0x64, 0x39, 0x33, 0x33, 0x30, 0x61, 0x35, 0x37, 0x35, 0x33, 0x30, 0x61, 0x63, 0x62, 0x38, 0x63, 0x39, 0x66, 0x64, 0x31, 0x65, 0x36, 0x66, 0x35, 0x62, 0x33, 0x63, 0x62, 0x61, 0x61, 0x39, 0x30, 0x30, 0x38, 0x39, 0x61, 0x66, 0x62, 0x34, 0x35, 0x35, 0x32, 0x30, 0x63, 0x32, 0x32, 0x32, 0x34, 0x32, 0x36, 0x32, 0x39, 0x38, 0x38, 0x63, 0x33, 0x34, 0x32, 0x37, 0x35, 0x61, 0x35, 0x36, 0x37, 0x38, 0x33, 0x65, 0x31, 0x63, 0x62, 0x63, 0x34, 0x32, 0x30, 0x37, 0x39, 0x62, 0x30, 0x37, 0x61, 0x62, 0x66, 0x34, 0x31, 0x34, 0x65, 0x35, 0x39, 0x32, 0x31, 0x39, 0x33, 0x36, 0x38, 0x36, 0x34, 0x33, 0x66, 0x31, 0x63, 0x32, 0x62, 0x64, 0x36, 0x61, 0x64, 0x39, 0x37, 0x34, 0x36, 0x33, 0x62, 0x31, 0x38, 0x33, 0x39, 0x62, 0x31, 0x66, 0x65, 0x62, 0x63, 0x35, 0x37, 0x38, 0x34, 0x35, 0x39, 0x62, 0x61, 0x35, 0x35, 0x61, 0x30, 0x31, 0x66, 0x39, 0x31, 0x34, 0x30, 0x36, 0x38, 0x32, 0x66, 0x61, 0x35, 0x35, 0x65, 0x30, 0x61, 0x61, 0x66, 0x35, 0x66, 0x32, 0x38, 0x61, 0x34, 0x37, 0x65, 0x36, 0x38, 0x33, 0x32, 0x63, 0x63, 0x61, 0x62, 0x31, 0x31, 0x38, 0x36, 0x39, 0x64, 0x35, 0x66, 0x34, 0x36, 0x33, 0x65, 0x34, 0x32, 0x35, 0x30, 0x38, 0x66, 0x65, 0x66, 0x39, 0x32, 0x33, 0x30, 0x64, 0x30, 0x63, 0x64, 0x63, 0x32, 0x66, 0x32, 0x65, 0x34, 0x63, 0x38, 0x64, 0x30, 0x30, 0x61, 0x30, 0x35, 0x62, 0x37, 0x62, 0x34, 0x31, 0x35, 0x37, 0x66, 0x65, 0x30, 0x37, 0x36, 0x65, 0x61, 0x65, 0x65, 0x31, 0x66, 0x61, 0x61, 0x34, 0x30, 0x34, 0x39, 0x66, 0x64, 0x64, 0x39, 0x32, 0x64, 0x61, 0x35, 0x37, 0x32, 0x65, 0x32, 0x34, 0x34, 0x32, 0x36, 0x33, 0x32, 0x64, 0x37, 0x63, 0x36, 0x36, 0x31, 0x39, 0x38, 0x39, 0x31, 0x61, 0x38, 0x31, 0x61, 0x64, 0x31, 0x36, 0x38, 0x39, 0x65, 0x65, 0x33, 0x35, 0x34, 0x65, 0x34, 0x62, 0x38, 0x65, 0x38, 0x64, 0x31, 0x37, 0x66, 0x32, 0x32, 0x64, 0x36, 0x62, 0x32, 0x37, 0x34, 0x62, 0x39, 0x35, 0x30, 0x64, 0x34, 0x36, 0x36, 0x64, 0x37, 0x33, 0x66, 0x32, 0x34, 0x31, 0x35, 0x65, 0x33, 0x31, 0x64, 0x65, 0x64, 0x33, 0x35, 0x31, 0x32, 0x65, 0x33, 0x31, 0x35, 0x64, 0x30, 0x33, 0x65, 0x61, 0x66, 0x34, 0x39, 0x62, 0x37, 0x61, 0x30, 0x35, 0x62, 0x31, 0x33, 0x35, 0x66, 0x63, 0x65, 0x61, 0x39, 0x32, 0x65, 0x65, 0x39, 0x33, 0x63, 0x66, 0x66, 0x62, 0x32, 0x34, 0x66, 0x37, 0x38, 0x30, 0x33, 0x34, 0x65, 0x66, 0x37, 0x31, 0x35, 0x64, 0x65, 0x33, 0x38, 0x36, 0x39, 0x30, 0x38, 0x39, 0x65, 0x62, 0x37, 0x62, 0x32, 0x65, 0x32, 0x34, 0x36, 0x36, 0x33, 0x66, 0x31, 0x62, 0x36, 0x64, 0x63, 0x61, 0x33, 0x30, 0x61, 0x38, 0x62, 0x63, 0x61, 0x39, 0x35, 0x35, 0x64, 0x39, 0x30, 0x62, 0x35, 0x63, 0x31, 0x35, 0x39, 0x64, 0x34, 0x33, 0x32, 0x37, 0x38, 0x39, 0x36, 0x64, 0x30, 0x32, 0x37, 0x32, 0x33, 0x36, 0x31, 0x38, 0x64, 0x30, 0x35, 0x37, 0x32, 0x39, 0x65, 0x39, 0x38, 0x64, 0x34, 0x64, 0x37, 0x62, 0x37, 0x30, 0x34, 0x30, 0x36, 0x34, 0x61, 0x30, 0x61, 0x31, 0x62, 0x64, 0x65, 0x64, 0x61, 0x66, 0x39, 0x65, 0x66, 0x31, 0x30, 0x37, 0x33, 0x35, 0x33, 0x63, 0x62, 0x64, 0x35, 0x62, 0x32, 0x36, 0x33, 0x32, 0x31, 0x31, 0x36, 0x66, 0x38, 0x33, 0x34, 0x63, 0x34, 0x64, 0x64, 0x30, 0x64, 0x34, 0x36, 0x36, 0x30, 0x37, 0x36, 0x37, 0x32, 0x30, 0x66, 0x65, 0x34, 0x32, 0x63, 0x30, 0x62, 0x30, 0x35, 0x64, 0x36, 0x30, 0x35, 0x63, 0x61, 0x37, 0x61, 0x35, 0x30, 0x37, 0x61, 0x37, 0x62, 0x63, 0x66, 0x64, 0x32, 0x38, 0x32, 0x63, 0x35, 0x39, 0x62, 0x34, 0x38, 0x61, 0x65, 0x34, 0x35, 0x66, 0x39, 0x35, 0x64, 0x33, 0x62, 0x34, 0x34, 0x37, 0x62, 0x32, 0x65, 0x38, 0x36, 0x33, 0x61, 0x32, 0x33, 0x37, 0x33, 0x35, 0x38, 0x37, 0x32, 0x62, 0x66, 0x31, 0x37, 0x35, 0x34, 0x36, 0x39, 0x62, 0x31, 0x62, 0x33, 0x65, 0x34, 0x38, 0x35, 0x33, 0x30, 0x32, 0x63, 0x38, 0x63, 0x62, 0x36, 0x32, 0x66, 0x35, 0x66, 0x32, 0x64, 0x39, 0x33, 0x63, 0x32, 0x38, 0x34, 0x31, 0x65, 0x62, 0x38, 0x63, 0x34, 0x30, 0x32, 0x65, 0x34, 0x66, 0x33, 0x39, 0x36, 0x31, 0x64, 0x32, 0x63, 0x30, 0x36, 0x64, 0x63, 0x31, 0x31, 0x31, 0x62, 0x37, 0x32, 0x31, 0x34, 0x63, 0x61, 0x36, 0x39, 0x35, 0x61, 0x65, 0x31, 0x65, 0x65, 0x38, 0x66, 0x66, 0x32, 0x34, 0x61, 0x32, 0x66, 0x32, 0x36, 0x64, 0x64, 0x35, 0x38, 0x62, 0x36, 0x65, 0x65, 0x37, 0x37, 0x35, 0x35, 0x36, 0x37, 0x63, 0x34, 0x35, 0x34, 0x64, 0x62, 0x65, 0x61, 0x37, 0x39, 0x34, 0x33, 0x64, 0x64, 0x32, 0x37, 0x65, 0x62, 0x62, 0x34, 0x35, 0x37, 0x31, 0x61, 0x33, 0x37, 0x36, 0x33, 0x38, 0x31, 0x61, 0x64, 0x35, 0x35, 0x34, 0x66, 0x65, 0x32, 0x37, 0x35, 0x61, 0x37, 0x63, 0x33, 0x63, 0x65, 0x38, 0x38, 0x34, 0x38, 0x65, 0x62, 0x39, 0x62, 0x38, 0x35, 0x63, 0x33, 0x33, 0x33, 0x36, 0x35, 0x30, 0x64, 0x31, 0x32, 0x34, 0x61, 0x66, 0x34, 0x34, 0x32, 0x38, 0x33, 0x30, 0x39, 0x66, 0x30, 0x66, 0x62, 0x31, 0x35, 0x38, 0x62, 0x64, 0x39, 0x66, 0x37, 0x37, 0x37, 0x37, 0x32, 0x35, 0x36, 0x33, 0x38, 0x39, 0x32, 0x65, 0x65, 0x62, 0x36, 0x35, 0x31, 0x36, 0x66, 0x32, 0x35, 0x64, 0x39, 0x64, 0x31, 0x65, 0x36, 0x35, 0x35, 0x64, 0x63, 0x37, 0x33, 0x35, 0x35, 0x39, 0x37, 0x61, 0x32, 0x36, 0x66, 0x32, 0x64, 0x66, 0x35, 0x66, 0x63, 0x36, 0x39, 0x36, 0x61, 0x35, 0x32, 0x62, 0x38, 0x30, 0x34, 0x65, 0x30, 0x39, 0x62, 0x35, 0x64, 0x39, 0x30, 0x34, 0x62, 0x37, 0x32, 0x34, 0x61, 0x63, 0x35, 0x65, 0x35, 0x64, 0x36, 0x65, 0x66, 0x33, 0x37, 0x63, 0x36, 0x65, 0x65, 0x62, 0x63, 0x35, 0x33, 0x61, 0x38, 0x35, 0x34, 0x37, 0x33, 0x32, 0x31, 0x39, 0x64, 0x34, 0x31, 0x34, 0x31, 0x38, 0x61, 0x34, 0x38, 0x31, 0x31, 0x64, 0x66, 0x38, 0x61, 0x34, 0x33, 0x33, 0x36, 0x30, 0x31, 0x37, 0x31, 0x35, 0x61, 0x39, 0x62, 0x66, 0x35, 0x66, 0x36, 0x35, 0x64, 0x37, 0x32, 0x31, 0x62, 0x34, 0x38, 0x36, 0x66, 0x36, 0x37, 0x33, 0x31, 0x35, 0x32, 0x65, 0x35, 0x64, 0x39, 0x65, 0x66, 0x32, 0x30, 0x31, 0x37, 0x34, 0x39, 0x36, 0x35, 0x33, 0x32, 0x62, 0x63, 0x31, 0x36, 0x61, 0x33, 0x65, 0x35, 0x66, 0x65, 0x66, 0x65, 0x61, 0x64, 0x31, 0x36, 0x32, 0x38, 0x62, 0x66, 0x35, 0x62, 0x62, 0x31, 0x32, 0x37, 0x39, 0x62, 0x33, 0x36, 0x39, 0x37, 0x32, 0x61, 0x35, 0x34, 0x64, 0x31, 0x66, 0x32, 0x31, 0x62, 0x38, 0x62, 0x31, 0x32, 0x35, 0x35, 0x34, 0x32, 0x33, 0x38, 0x33, 0x30, 0x33, 0x31, 0x31, 0x35, 0x64, 0x34, 0x34, 0x66, 0x62, 0x33, 0x36, 0x64, 0x32, 0x37, 0x33, 0x31, 0x31, 0x65, 0x34, 0x33, 0x66, 0x33, 0x30, 0x65, 0x36, 0x62, 0x63, 0x33, 0x39, 0x64, 0x38, 0x63, 0x30, 0x63, 0x62, 0x33, 0x66, 0x61, 0x31, 0x30, 0x65, 0x65, 0x35, 0x62, 0x37, 0x32, 0x39, 0x36, 0x32, 0x30, 0x38, 0x34, 0x33, 0x63, 0x34, 0x34, 0x38, 0x38, 0x39, 0x39, 0x61, 0x30, 0x38, 0x39, 0x38, 0x39, 0x61, 0x35, 0x61, 0x38, 0x30, 0x38, 0x38, 0x32, 0x61, 0x38, 0x35, 0x61, 0x37, 0x65, 0x36, 0x39, 0x66, 0x39, 0x33, 0x34, 0x65, 0x66, 0x62, 0x32, 0x62, 0x39, 0x37, 0x65, 0x32, 0x36, 0x39, 0x32, 0x32, 0x61, 0x34, 0x65, 0x35, 0x31, 0x65, 0x37, 0x32, 0x66, 0x37, 0x32, 0x39, 0x63, 0x36, 0x38, 0x65, 0x32, 0x61, 0x65, 0x61, 0x36, 0x38, 0x36, 0x37, 0x34, 0x38, 0x38, 0x32, 0x39, 0x65, 0x34, 0x65, 0x62, 0x32, 0x61, 0x32, 0x37, 0x37, 0x63, 0x63, 0x39, 0x34, 0x36, 0x61, 0x31, 0x36, 0x31, 0x62, 0x34, 0x38, 0x63, 0x32, 0x61, 0x34, 0x64, 0x61, 0x30, 0x62, 0x31, 0x64, 0x34, 0x63, 0x35, 0x30, 0x30, 0x36, 0x35, 0x32, 0x32, 0x32, 0x61, 0x66, 0x63, 0x32, 0x37, 0x61, 0x63, 0x30, 0x30, 0x34, 0x37, 0x63, 0x64, 0x31, 0x31, 0x39, 0x32, 0x66, 0x65, 0x37, 0x66, 0x36, 0x30, 0x36, 0x32, 0x30, 0x64, 0x31, 0x30, 0x30, 0x61, 0x36, 0x37, 0x66, 0x31, 0x32, 0x35, 0x33, 0x38, 0x37, 0x32, 0x30, 0x37, 0x64, 0x38, 0x63, 0x34, 0x33, 0x35, 0x31, 0x36, 0x32, 0x33, 0x31, 0x36, 0x31, 0x66, 0x63, 0x63, 0x38, 0x66, 0x34, 0x61, 0x66, 0x63, 0x34, 0x35, 0x37, 0x32, 0x35, 0x61, 0x36, 0x66, 0x32, 0x30, 0x33, 0x38, 0x66, 0x65, 0x66, 0x31, 0x63, 0x35, 0x63, 0x65, 0x38, 0x39, 0x66, 0x65, 0x34, 0x63, 0x61, 0x35, 0x39, 0x61, 0x31, 0x39, 0x33, 0x65, 0x32, 0x30, 0x62, 0x64, 0x63, 0x39, 0x35, 0x61, 0x61, 0x38, 0x65, 0x38, 0x37, 0x33, 0x62, 0x30, 0x66, 0x32, 0x39, 0x34, 0x37, 0x35, 0x38, 0x65, 0x65, 0x61, 0x62, 0x33, 0x30, 0x32, 0x31, 0x35, 0x36, 0x62, 0x61, 0x32, 0x39, 0x34, 0x63, 0x38, 0x61, 0x38, 0x66, 0x66, 0x65, 0x66, 0x34, 0x63, 0x35, 0x30, 0x33, 0x34, 0x64, 0x66, 0x63, 0x64, 0x38, 0x31, 0x34, 0x66, 0x66, 0x37, 0x30, 0x36, 0x61, 0x39, 0x35, 0x62, 0x65, 0x38, 0x65, 0x31, 0x63, 0x64, 0x31, 0x61, 0x32, 0x62, 0x37, 0x64, 0x30, 0x66, 0x37, 0x35, 0x32, 0x32, 0x62, 0x62, 0x37, 0x62, 0x61, 0x36, 0x33, 0x39, 0x66, 0x39, 0x37, 0x32, 0x30, 0x30, 0x32, 0x36, 0x38, 0x33, 0x33, 0x38, 0x34, 0x63, 0x33, 0x62, 0x31, 0x36, 0x64, 0x32, 0x62, 0x39, 0x31, 0x39, 0x66, 0x38, 0x63, 0x66, 0x36, 0x36, 0x64, 0x34, 0x38, 0x37, 0x63, 0x33, 0x34, 0x65, 0x39, 0x63, 0x38, 0x35, 0x32, 0x35, 0x66, 0x39, 0x31, 0x30, 0x35, 0x65, 0x61, 0x66, 0x31, 0x38, 0x63, 0x30, 0x37, 0x66, 0x30, 0x35, 0x31, 0x33, 0x64, 0x35, 0x35, 0x30, 0x35, 0x64, 0x64, 0x61, 0x35, 0x32, 0x31, 0x66, 0x36, 0x61, 0x62, 0x34, 0x66, 0x36, 0x62, 0x62, 0x38, 0x64, 0x61, 0x30, 0x33, 0x61, 0x34, 0x38, 0x35, 0x37, 0x39, 0x35, 0x30, 0x65, 0x34, 0x33, 0x30, 0x33, 0x33, 0x31, 0x39, 0x35, 0x63, 0x38, 0x63, 0x38, 0x32, 0x63, 0x30, 0x34, 0x66, 0x39, 0x61, 0x37, 0x63, 0x61, 0x33, 0x38, 0x34, 0x36, 0x37, 0x34, 0x35, 0x63, 0x61, 0x36, 0x64, 0x65, 0x37, 0x32, 0x39, 0x62, 0x66, 0x31, 0x32, 0x34, 0x66, 0x39, 0x35, 0x32, 0x36, 0x35, 0x33, 0x63, 0x63, 0x36, 0x34, 0x31, 0x36, 0x61, 0x65, 0x66, 0x31, 0x34, 0x37, 0x37, 0x61, 0x32, 0x32, 0x31, 0x33, 0x38, 0x38, 0x39, 0x34, 0x33, 0x62, 0x64, 0x38, 0x32, 0x37, 0x30, 0x66, 0x39, 0x65, 0x30, 0x33, 0x35, 0x39, 0x66, 0x33, 0x32, 0x61, 0x66, 0x39, 0x30, 0x37, 0x64, 0x65, 0x61, 0x33, 0x63, 0x37, 0x32, 0x31, 0x31, 0x30, 0x36, 0x64, 0x35, 0x39, 0x33, 0x30, 0x36, 0x39, 0x65, 0x64, 0x30, 0x37, 0x34, 0x66, 0x35, 0x66, 0x61, 0x30, 0x31, 0x32, 0x35, 0x36, 0x63, 0x38, 0x35, 0x64, 0x61, 0x39, 0x30, 0x38, 0x33, 0x31, 0x63, 0x34, 0x38, 0x37, 0x61, 0x61, 0x63, 0x31, 0x66, 0x39, 0x34, 0x35, 0x61, 0x66, 0x62, 0x36, 0x32, 0x34, 0x65, 0x32, 0x36, 0x39, 0x30, 0x39, 0x36, 0x31, 0x35, 0x36, 0x38, 0x38, 0x30, 0x33, 0x65, 0x32, 0x34, 0x31, 0x38, 0x35, 0x64, 0x61, 0x33, 0x32, 0x38, 0x64, 0x63, 0x65, 0x63, 0x37, 0x35, 0x34, 0x33, 0x34, 0x32, 0x34, 0x39, 0x65, 0x34, 0x35, 0x32, 0x39, 0x30, 0x31, 0x30, 0x30, 0x31, 0x34, 0x62, 0x64, 0x65, 0x62, 0x38, 0x35, 0x65, 0x30, 0x61, 0x61, 0x65, 0x66, 0x33, 0x34, 0x37, 0x30, 0x64, 0x35, 0x65, 0x63, 0x34, 0x30, 0x39, 0x66, 0x36, 0x37, 0x32, 0x36, 0x30, 0x31, 0x61, 0x38, 0x39, 0x33, 0x34, 0x66, 0x39, 0x35, 0x32, 0x34, 0x30, 0x33, 0x30, 0x65, 0x31, 0x35, 0x63, 0x33, 0x63, 0x63, 0x35, 0x39, 0x38, 0x33, 0x62, 0x36, 0x32, 0x65, 0x66, 0x32, 0x31, 0x35, 0x62, 0x65, 0x33, 0x64, 0x35, 0x34, 0x30, 0x32, 0x39, 0x65, 0x31, 0x61, 0x32, 0x65, 0x39, 0x66, 0x35, 0x32, 0x30, 0x62, 0x35, 0x34, 0x32, 0x38, 0x37, 0x39, 0x37, 0x35, 0x36, 0x61, 0x33, 0x66, 0x64, 0x37, 0x61, 0x30, 0x37, 0x65, 0x63, 0x31, 0x63, 0x31, 0x36, 0x66, 0x64, 0x35, 0x36, 0x30, 0x37, 0x64, 0x39, 0x64, 0x31, 0x32, 0x33, 0x65, 0x62, 0x31, 0x35, 0x32, 0x35, 0x32, 0x61, 0x35, 0x39, 0x65, 0x34, 0x33, 0x35, 0x66, 0x66, 0x33, 0x32, 0x37, 0x35, 0x37, 0x37, 0x34, 0x36, 0x37, 0x39, 0x66, 0x66, 0x63, 0x63, 0x32, 0x65, 0x37, 0x31, 0x37, 0x32, 0x37, 0x32, 0x39, 0x64, 0x31, 0x33, 0x61, 0x35, 0x38, 0x31, 0x66, 0x33, 0x37, 0x61, 0x35, 0x39, 0x39, 0x33, 0x38, 0x35, 0x35, 0x61, 0x65, 0x65, 0x38, 0x37, 0x37, 0x38, 0x31, 0x61, 0x32, 0x33, 0x35, 0x61, 0x30, 0x38, 0x30, 0x37, 0x62, 0x31, 0x39, 0x33, 0x64, 0x66, 0x32, 0x39, 0x37, 0x36, 0x39, 0x30, 0x64, 0x37, 0x38, 0x32, 0x30, 0x63, 0x39, 0x63, 0x37, 0x66, 0x34, 0x34, 0x35, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x37, 0x65, 0x32, 0x30, 0x66, 0x64, 0x31, 0x61, 0x31, 0x33, 0x65, 0x63, 0x65, 0x31, 0x61, 0x37, 0x37, 0x38, 0x61, 0x37, 0x34, 0x66, 0x66, 0x30, 0x34, 0x62, 0x61, 0x63, 0x37, 0x61, 0x38, 0x34, 0x37, 0x36, 0x33, 0x33, 0x66, 0x61, 0x37, 0x36, 0x65, 0x61, 0x66, 0x30, 0x63, 0x65, 0x64, 0x66, 0x33, 0x65, 0x39, 0x39, 0x34, 0x66, 0x64, 0x33, 0x33, 0x63, 0x35, 0x32, 0x32, 0x35, 0x30, 0x65, 0x36, 0x39, 0x63, 0x35, 0x63, 0x37, 0x64, 0x35, 0x30, 0x33, 0x62, 0x39, 0x33, 0x62, 0x62, 0x62, 0x33, 0x65, 0x62, 0x65, 0x38, 0x33, 0x66, 0x32, 0x36, 0x33, 0x35, 0x64, 0x30, 0x32, 0x38, 0x64, 0x31, 0x34, 0x34, 0x37, 0x63, 0x61, 0x32, 0x33, 0x37, 0x61, 0x36, 0x34, 0x62, 0x62, 0x65, 0x64, 0x63, 0x31, 0x32, 0x31, 0x66, 0x30, 0x66, 0x37, 0x39, 0x39, 0x31, 0x37, 0x32, 0x31, 0x31, 0x63, 0x35, 0x38, 0x30, 0x39, 0x64, 0x31, 0x36, 0x64, 0x33, 0x65, 0x66, 0x61, 0x63, 0x39, 0x66, 0x35, 0x63, 0x61, 0x63, 0x39, 0x34, 0x30, 0x38, 0x36, 0x66, 0x66, 0x37, 0x31, 0x36, 0x34, 0x66, 0x31, 0x35, 0x37, 0x39, 0x63, 0x63, 0x66, 0x39, 0x64, 0x38, 0x37, 0x38, 0x30, 0x62, 0x36, 0x33, 0x35, 0x39, 0x38, 0x64, 0x37, 0x33, 0x38, 0x39, 0x35, 0x36, 0x61, 0x62, 0x37, 0x32, 0x36, 0x63, 0x35, 0x38, 0x62, 0x33, 0x62, 0x33, 0x65, 0x31, 0x30, 0x31, 0x64, 0x61, 0x32, 0x39, 0x64, 0x62, 0x38, 0x35, 0x64, 0x33, 0x62, 0x65, 0x39, 0x31, 0x61, 0x30, 0x39, 0x64, 0x61, 0x36, 0x63, 0x61, 0x36, 0x62, 0x36, 0x61, 0x32, 0x33, 0x39, 0x35, 0x64, 0x32, 0x64, 0x62, 0x64, 0x30, 0x37, 0x65, 0x30, 0x39, 0x33, 0x65, 0x64, 0x63, 0x38, 0x34, 0x38, 0x31, 0x33, 0x35, 0x37, 0x32, 0x62, 0x36, 0x36, 0x63, 0x63, 0x38, 0x61, 0x30, 0x63, 0x33, 0x66, 0x32, 0x65, 0x31, 0x33, 0x32, 0x65, 0x32, 0x61, 0x34, 0x65, 0x65, 0x36, 0x34, 0x61, 0x37, 0x66, 0x31, 0x39, 0x66, 0x33, 0x64, 0x38, 0x30, 0x34, 0x64, 0x36, 0x63, 0x35, 0x36, 0x62, 0x65, 0x33, 0x66, 0x66, 0x37, 0x62, 0x36, 0x32, 0x38, 0x30, 0x62, 0x38, 0x34, 0x65, 0x35, 0x61, 0x32, 0x30, 0x62, 0x33, 0x33, 0x35, 0x34, 0x39, 0x39, 0x37, 0x35, 0x37, 0x63, 0x30, 0x38, 0x65, 0x32, 0x39, 0x31, 0x32, 0x62, 0x66, 0x63, 0x38, 0x32, 0x65, 0x38, 0x66, 0x36, 0x30, 0x35, 0x64, 0x35, 0x66, 0x33, 0x31, 0x64, 0x33, 0x30, 0x39, 0x66, 0x61, 0x61, 0x37, 0x64, 0x35, 0x62, 0x37, 0x31, 0x64, 0x63, 0x33, 0x32, 0x33, 0x63, 0x61, 0x30, 0x33, 0x30, 0x62, 0x61, 0x38, 0x65, 0x64, 0x38, 0x32, 0x61, 0x66, 0x32, 0x34, 0x36, 0x61, 0x61, 0x66, 0x38, 0x39, 0x61, 0x61, 0x62, 0x34, 0x62, 0x61, 0x34, 0x37, 0x62, 0x37, 0x34, 0x38, 0x33, 0x37, 0x31, 0x37, 0x31, 0x62, 0x37, 0x31, 0x64, 0x61, 0x32, 0x30, 0x39, 0x37, 0x63, 0x32, 0x64, 0x63, 0x61, 0x34, 0x33, 0x62, 0x38, 0x31, 0x39, 0x33, 0x62, 0x33, 0x61, 0x36, 0x31, 0x61, 0x31, 0x64, 0x37, 0x64, 0x30, 0x36, 0x33, 0x62, 0x30, 0x66, 0x31, 0x39, 0x63, 0x37, 0x32, 0x37, 0x33, 0x65, 0x32, 0x30, 0x35, 0x61, 0x66, 0x64, 0x38, 0x34, 0x63, 0x66, 0x64, 0x39, 0x30, 0x62, 0x61, 0x30, 0x39, 0x32, 0x61, 0x66, 0x37, 0x39, 0x36, 0x33, 0x65, 0x66, 0x37, 0x38, 0x65, 0x63, 0x64, 0x33, 0x63, 0x30, 0x36, 0x62, 0x61, 0x61, 0x66, 0x31, 0x38, 0x32, 0x33, 0x33, 0x64, 0x63, 0x64, 0x64, 0x35, 0x31, 0x39, 0x33, 0x39, 0x32, 0x62, 0x38, 0x38, 0x31, 0x33, 0x35, 0x66, 0x61, 0x34, 0x61, 0x36, 0x32, 0x39, 0x30, 0x38, 0x38, 0x38, 0x30, 0x36, 0x30, 0x39, 0x33, 0x36, 0x30, 0x35, 0x30, 0x36, 0x32, 0x38, 0x61, 0x32, 0x35, 0x66, 0x64, 0x36, 0x35, 0x38, 0x65, 0x65, 0x63, 0x65, 0x62, 0x34, 0x66, 0x35, 0x64, 0x39, 0x63, 0x32, 0x63, 0x35, 0x32, 0x32, 0x38, 0x34, 0x32, 0x61, 0x32, 0x38, 0x66, 0x61, 0x61, 0x39, 0x63, 0x62, 0x66, 0x33, 0x61, 0x63, 0x37, 0x32, 0x66, 0x30, 0x65, 0x34, 0x35, 0x34, 0x31, 0x32, 0x30, 0x31, 0x66, 0x34, 0x32, 0x32, 0x31, 0x66, 0x61, 0x66, 0x31, 0x36, 0x62, 0x66, 0x64, 0x37, 0x63, 0x63, 0x64, 0x32, 0x32, 0x32, 0x66, 0x62, 0x30, 0x31, 0x37, 0x63, 0x64, 0x65, 0x33, 0x32, 0x31, 0x36, 0x62, 0x36, 0x33, 0x66, 0x62, 0x35, 0x32, 0x31, 0x65, 0x37, 0x39, 0x61, 0x33, 0x37, 0x38, 0x64, 0x39, 0x31, 0x65, 0x31, 0x35, 0x35, 0x61, 0x32, 0x32, 0x61, 0x37, 0x37, 0x35, 0x30, 0x65, 0x61, 0x66, 0x61, 0x63, 0x61, 0x64, 0x36, 0x66, 0x31, 0x34, 0x66, 0x35, 0x34, 0x36, 0x35, 0x30, 0x31, 0x36, 0x32, 0x38, 0x64, 0x34, 0x30, 0x31, 0x64, 0x38, 0x66, 0x36, 0x64, 0x35, 0x38, 0x32, 0x33, 0x63, 0x61, 0x63, 0x39, 0x65, 0x37, 0x61, 0x37, 0x66, 0x30, 0x61, 0x66, 0x66, 0x62, 0x61, 0x62, 0x32, 0x33, 0x31, 0x65, 0x37, 0x32, 0x36, 0x65, 0x62, 0x39, 0x34, 0x66, 0x61, 0x65, 0x63, 0x31, 0x37, 0x64, 0x32, 0x35, 0x30, 0x33, 0x30, 0x64, 0x33, 0x30, 0x34, 0x61, 0x31, 0x64, 0x61, 0x39, 0x65, 0x34, 0x33, 0x64, 0x30, 0x30, 0x35, 0x36, 0x63, 0x36, 0x62, 0x62, 0x33, 0x34, 0x66, 0x34, 0x35, 0x31, 0x63, 0x31, 0x64, 0x66, 0x35, 0x35, 0x34, 0x36, 0x63, 0x39, 0x33, 0x35, 0x33, 0x36, 0x61, 0x31, 0x64, 0x34, 0x37, 0x32, 0x66, 0x61, 0x64, 0x62, 0x62, 0x39, 0x36, 0x33, 0x30, 0x33, 0x34, 0x32, 0x37, 0x33, 0x32, 0x66, 0x61, 0x65, 0x31, 0x62, 0x32, 0x37, 0x63, 0x62, 0x32, 0x66, 0x61, 0x34, 0x31, 0x34, 0x37, 0x32, 0x61, 0x34, 0x38, 0x38, 0x36, 0x63, 0x66, 0x37, 0x65, 0x36, 0x38, 0x35, 0x62, 0x35, 0x65, 0x37, 0x61, 0x34, 0x37, 0x38, 0x34, 0x35, 0x66, 0x33, 0x61, 0x36, 0x64, 0x37, 0x62, 0x34, 0x33, 0x62, 0x61, 0x62, 0x64, 0x62, 0x30, 0x66, 0x37, 0x62, 0x61, 0x65, 0x61, 0x39, 0x38, 0x39, 0x66, 0x31, 0x36, 0x39, 0x65, 0x66, 0x31, 0x63, 0x33, 0x32, 0x62, 0x34, 0x62, 0x33, 0x32, 0x62, 0x36, 0x35, 0x38, 0x63, 0x63, 0x61, 0x63, 0x32, 0x32, 0x37, 0x33, 0x35, 0x38, 0x61, 0x37, 0x65, 0x36, 0x38, 0x35, 0x33, 0x61, 0x61, 0x36, 0x64, 0x63, 0x38, 0x34, 0x38, 0x66, 0x38, 0x31, 0x33, 0x37, 0x32, 0x37, 0x37, 0x37, 0x30, 0x35, 0x39, 0x65, 0x64, 0x65, 0x63, 0x34, 0x61, 0x37, 0x39, 0x35, 0x34, 0x65, 0x39, 0x61, 0x31, 0x33, 0x65, 0x33, 0x61, 0x66, 0x37, 0x34, 0x31, 0x39, 0x65, 0x35, 0x63, 0x30, 0x62, 0x38, 0x61, 0x62, 0x62, 0x61, 0x61, 0x64, 0x33, 0x32, 0x33, 0x33, 0x66, 0x63, 0x61, 0x32, 0x35, 0x35, 0x64, 0x38, 0x38, 0x62, 0x34, 0x39, 0x61, 0x30, 0x65, 0x66, 0x64, 0x37, 0x32, 0x61, 0x31, 0x39, 0x32, 0x35, 0x35, 0x34, 0x62, 0x31, 0x65, 0x61, 0x61, 0x33, 0x63, 0x30, 0x36, 0x63, 0x32, 0x35, 0x38, 0x37, 0x36, 0x32, 0x63, 0x65, 0x31, 0x31, 0x36, 0x31, 0x30, 0x66, 0x32, 0x33, 0x61, 0x35, 0x39, 0x64, 0x35, 0x65, 0x64, 0x34, 0x38, 0x65, 0x31, 0x39, 0x39, 0x38, 0x38, 0x64, 0x66, 0x63, 0x61, 0x37, 0x35, 0x37, 0x65, 0x34, 0x38, 0x37, 0x39, 0x32, 0x36, 0x35, 0x39, 0x38, 0x30, 0x63, 0x62, 0x31, 0x64, 0x63, 0x35, 0x62, 0x30, 0x30, 0x34, 0x39, 0x30, 0x61, 0x61, 0x30, 0x61, 0x35, 0x62, 0x32, 0x33, 0x61, 0x37, 0x36, 0x37, 0x38, 0x31, 0x63, 0x62, 0x63, 0x65, 0x34, 0x62, 0x33, 0x30, 0x37, 0x33, 0x34, 0x62, 0x35, 0x65, 0x31, 0x66, 0x66, 0x64, 0x66, 0x39, 0x30, 0x35, 0x36, 0x39, 0x32, 0x36, 0x36, 0x61, 0x65, 0x35, 0x63, 0x31, 0x32, 0x38, 0x37, 0x32, 0x62, 0x39, 0x63, 0x32, 0x66, 0x63, 0x35, 0x30, 0x39, 0x33, 0x38, 0x63, 0x63, 0x65, 0x37, 0x31, 0x65, 0x38, 0x39, 0x64, 0x37, 0x66, 0x61, 0x30, 0x32, 0x38, 0x61, 0x31, 0x35, 0x30, 0x33, 0x34, 0x31, 0x38, 0x31, 0x64, 0x34, 0x37, 0x66, 0x65, 0x36, 0x66, 0x36, 0x65, 0x65, 0x32, 0x65, 0x33, 0x31, 0x33, 0x63, 0x33, 0x64, 0x31, 0x38, 0x38, 0x31, 0x38, 0x34, 0x36, 0x65, 0x33, 0x31, 0x62, 0x32, 0x37, 0x37, 0x65, 0x37, 0x37, 0x35, 0x36, 0x32, 0x64, 0x65, 0x31, 0x33, 0x66, 0x65, 0x37, 0x37, 0x33, 0x33, 0x61, 0x32, 0x38, 0x63, 0x66, 0x37, 0x30, 0x63, 0x61, 0x32, 0x64, 0x30, 0x38, 0x32, 0x32, 0x31, 0x31, 0x34, 0x31, 0x64, 0x37, 0x62, 0x37, 0x37, 0x33, 0x32, 0x61, 0x31, 0x65, 0x36, 0x36, 0x31, 0x33, 0x35, 0x38, 0x64, 0x65, 0x37, 0x33, 0x33, 0x35, 0x39, 0x66, 0x37, 0x32, 0x30, 0x62, 0x62, 0x33, 0x30, 0x37, 0x32, 0x37, 0x36, 0x62, 0x31, 0x36, 0x38, 0x63, 0x33, 0x33, 0x35, 0x30, 0x31, 0x33, 0x37, 0x35, 0x39, 0x33, 0x34, 0x63, 0x63, 0x63, 0x35, 0x31, 0x34, 0x30, 0x64, 0x35, 0x65, 0x38, 0x33, 0x63, 0x65, 0x61, 0x66, 0x35, 0x37, 0x30, 0x62, 0x35, 0x35, 0x36, 0x65, 0x66, 0x38, 0x34, 0x34, 0x61, 0x65, 0x36, 0x63, 0x63, 0x34, 0x31, 0x37, 0x62, 0x37, 0x32, 0x34, 0x65, 0x36, 0x66, 0x66, 0x65, 0x65, 0x30, 0x30, 0x33, 0x35, 0x66, 0x33, 0x34, 0x38, 0x37, 0x38, 0x30, 0x30, 0x31, 0x30, 0x37, 0x33, 0x34, 0x36, 0x63, 0x30, 0x36, 0x39, 0x64, 0x31, 0x31, 0x39, 0x35, 0x31, 0x31, 0x61, 0x62, 0x31, 0x61, 0x30, 0x33, 0x63, 0x31, 0x66, 0x38, 0x64, 0x62, 0x32, 0x65, 0x65, 0x37, 0x33, 0x36, 0x66, 0x61, 0x62, 0x65, 0x64, 0x34, 0x63, 0x39, 0x37, 0x32, 0x37, 0x66, 0x38, 0x38, 0x39, 0x32, 0x37, 0x64, 0x34, 0x35, 0x66, 0x35, 0x36, 0x66, 0x37, 0x62, 0x65, 0x35, 0x30, 0x38, 0x38, 0x32, 0x34, 0x30, 0x66, 0x65, 0x38, 0x61, 0x30, 0x65, 0x63, 0x62, 0x32, 0x31, 0x66, 0x61, 0x30, 0x33, 0x66, 0x33, 0x31, 0x33, 0x66, 0x38, 0x64, 0x65, 0x30, 0x64, 0x62, 0x35, 0x65, 0x32, 0x33, 0x34, 0x39, 0x66, 0x31, 0x34, 0x36, 0x64, 0x66, 0x32, 0x37, 0x32, 0x39, 0x62, 0x38, 0x39, 0x36, 0x33, 0x61, 0x37, 0x38, 0x30, 0x37, 0x38, 0x33, 0x31, 0x31, 0x33, 0x65, 0x61, 0x31, 0x33, 0x66, 0x36, 0x33, 0x32, 0x63, 0x65, 0x62, 0x61, 0x65, 0x39, 0x66, 0x36, 0x62, 0x35, 0x66, 0x33, 0x65, 0x66, 0x65, 0x38, 0x33, 0x62, 0x62, 0x35, 0x62, 0x31, 0x39, 0x38, 0x30, 0x37, 0x35, 0x66, 0x61, 0x31, 0x64, 0x37, 0x62, 0x61, 0x62, 0x39, 0x32, 0x30, 0x35, 0x63, 0x35, 0x36, 0x33, 0x36, 0x37, 0x33, 0x32, 0x37, 0x32, 0x64, 0x63, 0x35, 0x63, 0x31, 0x35, 0x36, 0x66, 0x35, 0x61, 0x61, 0x34, 0x35, 0x61, 0x31, 0x36, 0x64, 0x64, 0x37, 0x36, 0x39, 0x32, 0x66, 0x32, 0x30, 0x30, 0x37, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x35, 0x39, 0x39, 0x35, 0x36, 0x36, 0x31, 0x33, 0x33, 0x66, 0x39, 0x35, 0x33, 0x33, 0x35, 0x33, 0x65, 0x66, 0x37, 0x32, 0x66, 0x64, 0x61, 0x37, 0x38, 0x34, 0x36, 0x33, 0x37, 0x38, 0x39, 0x65, 0x35, 0x32, 0x32, 0x62, 0x65, 0x34, 0x33, 0x66, 0x62, 0x30, 0x38, 0x37, 0x64, 0x61, 0x37, 0x63, 0x66, 0x63, 0x39, 0x64, 0x37, 0x31, 0x34, 0x62, 0x30, 0x37, 0x63, 0x33, 0x66, 0x38, 0x39, 0x65, 0x63, 0x39, 0x36, 0x33, 0x61, 0x64, 0x38, 0x33, 0x62, 0x65, 0x64, 0x63, 0x62, 0x32, 0x37, 0x36, 0x65, 0x38, 0x35, 0x32, 0x62, 0x62, 0x33, 0x35, 0x35, 0x64, 0x63, 0x37, 0x39, 0x37, 0x61, 0x35, 0x36, 0x30, 0x31, 0x61, 0x39, 0x35, 0x62, 0x64, 0x32, 0x35, 0x37, 0x66, 0x63, 0x62, 0x32, 0x65, 0x66, 0x38, 0x65, 0x65, 0x34, 0x36, 0x61, 0x31, 0x33, 0x34, 0x33, 0x34, 0x32, 0x33, 0x64, 0x33, 0x61, 0x34, 0x37, 0x36, 0x63, 0x63, 0x37, 0x34, 0x34, 0x36, 0x30, 0x37, 0x34, 0x64, 0x65, 0x36, 0x66, 0x30, 0x37, 0x32, 0x33, 0x66, 0x34, 0x38, 0x30, 0x30, 0x38, 0x62, 0x65, 0x30, 0x34, 0x63, 0x65, 0x62, 0x37, 0x64, 0x62, 0x61, 0x31, 0x32, 0x37, 0x38, 0x37, 0x63, 0x64, 0x62, 0x38, 0x34, 0x65, 0x64, 0x62, 0x37, 0x30, 0x36, 0x61, 0x32, 0x30, 0x34, 0x62, 0x31, 0x37, 0x30, 0x62, 0x37, 0x38, 0x35, 0x36, 0x32, 0x35, 0x30, 0x63, 0x34, 0x62, 0x38, 0x31, 0x62, 0x33, 0x66, 0x37, 0x61, 0x65, 0x66, 0x37, 0x32, 0x38, 0x31, 0x30, 0x33, 0x35, 0x39, 0x33, 0x62, 0x66, 0x34, 0x62, 0x33, 0x37, 0x62, 0x35, 0x61, 0x37, 0x33, 0x64, 0x38, 0x39, 0x39, 0x31, 0x30, 0x32, 0x39, 0x36, 0x39, 0x39, 0x66, 0x61, 0x37, 0x63, 0x36, 0x66, 0x30, 0x63, 0x30, 0x30, 0x38, 0x38, 0x30, 0x38, 0x38, 0x30, 0x61, 0x36, 0x31, 0x63, 0x63, 0x38, 0x61, 0x62, 0x34, 0x66, 0x36, 0x31, 0x34, 0x66, 0x35, 0x64, 0x33, 0x36, 0x39, 0x61, 0x31, 0x63, 0x37, 0x36, 0x66, 0x62, 0x33, 0x38, 0x30, 0x31, 0x33, 0x63, 0x33, 0x64, 0x66, 0x65, 0x31, 0x30, 0x65, 0x35, 0x31, 0x64, 0x33, 0x34, 0x38, 0x30, 0x35, 0x35, 0x64, 0x33, 0x64, 0x36, 0x30, 0x32, 0x32, 0x32, 0x30, 0x61, 0x37, 0x65, 0x38, 0x61, 0x64, 0x33, 0x35, 0x30, 0x34, 0x33, 0x31, 0x65, 0x63, 0x32, 0x61, 0x35, 0x65, 0x36, 0x66, 0x62, 0x62, 0x62, 0x36, 0x37, 0x32, 0x38, 0x36, 0x33, 0x36, 0x64, 0x34, 0x38, 0x37, 0x32, 0x66, 0x36, 0x33, 0x35, 0x36, 0x34, 0x36, 0x33, 0x30, 0x38, 0x38, 0x35, 0x31, 0x32, 0x33, 0x33, 0x30, 0x38, 0x35, 0x64, 0x32, 0x64, 0x36, 0x65, 0x63, 0x32, 0x39, 0x34, 0x65, 0x33, 0x61, 0x31, 0x39, 0x37, 0x31, 0x38, 0x35, 0x35, 0x64, 0x31, 0x61, 0x31, 0x33, 0x62, 0x61, 0x33, 0x63, 0x63, 0x31, 0x34, 0x66, 0x61, 0x62, 0x37, 0x32, 0x64, 0x33, 0x65, 0x39, 0x30, 0x65, 0x36, 0x37, 0x37, 0x36, 0x39, 0x39, 0x35, 0x32, 0x38, 0x32, 0x34, 0x32, 0x62, 0x32, 0x63, 0x34, 0x34, 0x38, 0x30, 0x37, 0x34, 0x35, 0x36, 0x64, 0x37, 0x61, 0x35, 0x61, 0x30, 0x66, 0x32, 0x37, 0x33, 0x65, 0x62, 0x34, 0x61, 0x35, 0x30, 0x36, 0x63, 0x62, 0x34, 0x66, 0x65, 0x66, 0x33, 0x63, 0x32, 0x61, 0x36, 0x34, 0x62, 0x33, 0x35, 0x36, 0x37, 0x32, 0x32, 0x35, 0x63, 0x64, 0x30, 0x34, 0x31, 0x61, 0x63, 0x65, 0x31, 0x32, 0x38, 0x39, 0x64, 0x36, 0x62, 0x31, 0x64, 0x65, 0x65, 0x32, 0x65, 0x34, 0x62, 0x63, 0x31, 0x65, 0x64, 0x62, 0x61, 0x36, 0x39, 0x61, 0x65, 0x63, 0x32, 0x66, 0x38, 0x37, 0x65, 0x30, 0x34, 0x65, 0x32, 0x61, 0x61, 0x35, 0x66, 0x37, 0x31, 0x33, 0x31, 0x66, 0x39, 0x39, 0x31, 0x63, 0x32, 0x61, 0x33, 0x34, 0x37, 0x32, 0x66, 0x39, 0x61, 0x66, 0x36, 0x62, 0x66, 0x31, 0x66, 0x31, 0x37, 0x66, 0x65, 0x34, 0x31, 0x32, 0x36, 0x30, 0x64, 0x38, 0x66, 0x66, 0x33, 0x33, 0x63, 0x38, 0x33, 0x63, 0x31, 0x30, 0x30, 0x64, 0x31, 0x35, 0x66, 0x34, 0x39, 0x32, 0x31, 0x36, 0x34, 0x30, 0x66, 0x62, 0x30, 0x62, 0x30, 0x36, 0x37, 0x63, 0x65, 0x38, 0x31, 0x64, 0x62, 0x36, 0x32, 0x34, 0x36, 0x35, 0x36, 0x33, 0x35, 0x64, 0x39, 0x30, 0x36, 0x61, 0x61, 0x65, 0x65, 0x36, 0x31, 0x39, 0x64, 0x37, 0x30, 0x65, 0x31, 0x64, 0x63, 0x62, 0x61, 0x62, 0x62, 0x39, 0x31, 0x38, 0x33, 0x35, 0x38, 0x31, 0x32, 0x35, 0x32, 0x36, 0x39, 0x35, 0x30, 0x38, 0x62, 0x36, 0x30, 0x35, 0x64, 0x37, 0x39, 0x30, 0x38, 0x30, 0x63, 0x32, 0x66, 0x34, 0x32, 0x62, 0x35, 0x30, 0x65, 0x35, 0x36, 0x63, 0x32, 0x31, 0x31, 0x64, 0x37, 0x32, 0x37, 0x34, 0x64, 0x32, 0x61, 0x38, 0x36, 0x36, 0x65, 0x39, 0x62, 0x35, 0x65, 0x31, 0x65, 0x35, 0x62, 0x38, 0x61, 0x63, 0x38, 0x32, 0x31, 0x38, 0x63, 0x62, 0x36, 0x32, 0x33, 0x31, 0x33, 0x39, 0x66, 0x36, 0x64, 0x35, 0x30, 0x30, 0x37, 0x66, 0x63, 0x35, 0x38, 0x31, 0x66, 0x35, 0x35, 0x39, 0x32, 0x30, 0x36, 0x32, 0x31, 0x34, 0x33, 0x39, 0x38, 0x32, 0x66, 0x32, 0x36, 0x34, 0x37, 0x32, 0x33, 0x30, 0x63, 0x34, 0x61, 0x30, 0x30, 0x35, 0x30, 0x33, 0x63, 0x35, 0x30, 0x65, 0x35, 0x64, 0x63, 0x63, 0x61, 0x63, 0x37, 0x39, 0x33, 0x39, 0x36, 0x64, 0x61, 0x64, 0x66, 0x61, 0x63, 0x30, 0x31, 0x39, 0x36, 0x32, 0x38, 0x64, 0x65, 0x66, 0x36, 0x61, 0x61, 0x35, 0x32, 0x65, 0x36, 0x34, 0x62, 0x62, 0x34, 0x62, 0x33, 0x39, 0x63, 0x38, 0x36, 0x65, 0x30, 0x34, 0x61, 0x39, 0x34, 0x31, 0x30, 0x37, 0x62, 0x66, 0x65, 0x36, 0x34, 0x30, 0x31, 0x63, 0x61, 0x31, 0x31, 0x31, 0x31, 0x34, 0x33, 0x64, 0x64, 0x38, 0x66, 0x62, 0x35, 0x34, 0x38, 0x65, 0x31, 0x64, 0x66, 0x64, 0x64, 0x31, 0x37, 0x37, 0x34, 0x38, 0x32, 0x66, 0x31, 0x64, 0x64, 0x37, 0x61, 0x63, 0x35, 0x32, 0x35, 0x33, 0x65, 0x34, 0x35, 0x63, 0x32, 0x61, 0x39, 0x31, 0x37, 0x39, 0x36, 0x36, 0x65, 0x32, 0x37, 0x32, 0x64, 0x65, 0x62, 0x38, 0x34, 0x63, 0x33, 0x36, 0x61, 0x36, 0x63, 0x36, 0x63, 0x62, 0x31, 0x39, 0x34, 0x32, 0x32, 0x39, 0x63, 0x66, 0x30, 0x65, 0x32, 0x65, 0x33, 0x64, 0x63, 0x33, 0x65, 0x64, 0x64, 0x36, 0x64, 0x32, 0x36, 0x38, 0x31, 0x36, 0x30, 0x66, 0x63, 0x62, 0x34, 0x63, 0x39, 0x32, 0x37, 0x61, 0x33, 0x37, 0x30, 0x32, 0x61, 0x65, 0x32, 0x62, 0x38, 0x32, 0x37, 0x34, 0x37, 0x30, 0x39, 0x62, 0x38, 0x62, 0x39, 0x35, 0x65, 0x66, 0x37, 0x61, 0x66, 0x39, 0x30, 0x66, 0x37, 0x65, 0x62, 0x65, 0x31, 0x36, 0x30, 0x38, 0x62, 0x33, 0x39, 0x65, 0x61, 0x61, 0x61, 0x66, 0x31, 0x62, 0x63, 0x65, 0x30, 0x65, 0x63, 0x35, 0x37, 0x32, 0x30, 0x35, 0x63, 0x62, 0x61, 0x35, 0x32, 0x30, 0x32, 0x63, 0x33, 0x33, 0x63, 0x38, 0x39, 0x64, 0x64, 0x61, 0x65, 0x34, 0x34, 0x62, 0x34, 0x36, 0x65, 0x32, 0x31, 0x39, 0x37, 0x62, 0x33, 0x66, 0x63, 0x66, 0x33, 0x35, 0x33, 0x38, 0x33, 0x65, 0x30, 0x66, 0x37, 0x30, 0x36, 0x32, 0x38, 0x64, 0x37, 0x32, 0x66, 0x65, 0x66, 0x34, 0x34, 0x31, 0x61, 0x34, 0x31, 0x33, 0x35, 0x36, 0x38, 0x31, 0x38, 0x65, 0x31, 0x30, 0x36, 0x38, 0x63, 0x39, 0x66, 0x65, 0x61, 0x62, 0x38, 0x63, 0x65, 0x31, 0x38, 0x32, 0x35, 0x64, 0x33, 0x61, 0x37, 0x32, 0x34, 0x64, 0x36, 0x66, 0x37, 0x39, 0x38, 0x31, 0x63, 0x66, 0x62, 0x37, 0x30, 0x37, 0x61, 0x33, 0x62, 0x34, 0x66, 0x63, 0x66, 0x39, 0x66, 0x61, 0x31, 0x31, 0x66, 0x31, 0x33, 0x34, 0x65, 0x66, 0x63, 0x31, 0x34, 0x62, 0x32, 0x36, 0x62, 0x64, 0x37, 0x63, 0x31, 0x34, 0x31, 0x38, 0x35, 0x39, 0x63, 0x64, 0x61, 0x31, 0x39, 0x32, 0x30, 0x36, 0x31, 0x62, 0x64, 0x63, 0x63, 0x39, 0x37, 0x32, 0x36, 0x62, 0x64, 0x61, 0x64, 0x36, 0x61, 0x30, 0x33, 0x30, 0x62, 0x34, 0x36, 0x61, 0x63, 0x38, 0x34, 0x34, 0x30, 0x31, 0x37, 0x64, 0x36, 0x33, 0x34, 0x34, 0x66, 0x30, 0x31, 0x37, 0x34, 0x63, 0x35, 0x36, 0x63, 0x61, 0x38, 0x35, 0x39, 0x30, 0x64, 0x37, 0x37, 0x63, 0x30, 0x34, 0x65, 0x30, 0x37, 0x30, 0x37, 0x37, 0x30, 0x63, 0x30, 0x61, 0x62, 0x62, 0x38, 0x32, 0x64, 0x36, 0x37, 0x32, 0x65, 0x36, 0x39, 0x30, 0x64, 0x32, 0x34, 0x65, 0x31, 0x30, 0x63, 0x63, 0x36, 0x32, 0x38, 0x31, 0x64, 0x66, 0x34, 0x38, 0x66, 0x63, 0x32, 0x39, 0x37, 0x61, 0x35, 0x66, 0x35, 0x36, 0x39, 0x65, 0x39, 0x62, 0x66, 0x37, 0x35, 0x65, 0x35, 0x38, 0x33, 0x66, 0x39, 0x30, 0x61, 0x62, 0x39, 0x32, 0x35, 0x37, 0x38, 0x32, 0x34, 0x65, 0x31, 0x34, 0x30, 0x66, 0x63, 0x63, 0x34, 0x62, 0x37, 0x32, 0x35, 0x38, 0x61, 0x66, 0x62, 0x31, 0x66, 0x31, 0x30, 0x37, 0x36, 0x38, 0x31, 0x62, 0x37, 0x61, 0x31, 0x61, 0x38, 0x32, 0x34, 0x36, 0x35, 0x34, 0x38, 0x39, 0x34, 0x64, 0x36, 0x65, 0x30, 0x37, 0x64, 0x61, 0x31, 0x38, 0x62, 0x30, 0x30, 0x65, 0x65, 0x39, 0x33, 0x65, 0x66, 0x35, 0x34, 0x35, 0x61, 0x33, 0x62, 0x38, 0x62, 0x62, 0x66, 0x37, 0x37, 0x37, 0x66, 0x65, 0x64, 0x32, 0x35, 0x34, 0x65, 0x38, 0x37, 0x38, 0x38, 0x37, 0x61, 0x62, 0x34, 0x63, 0x35, 0x31, 0x34, 0x63, 0x62, 0x36, 0x61, 0x36, 0x37, 0x61, 0x33, 0x62, 0x30, 0x62, 0x33, 0x31, 0x36, 0x30, 0x39, 0x62, 0x36, 0x38, 0x65, 0x61, 0x64, 0x38, 0x31, 0x39, 0x31, 0x32, 0x64, 0x35, 0x39, 0x65, 0x34, 0x62, 0x34, 0x38, 0x34, 0x37, 0x62, 0x30, 0x39, 0x39, 0x30, 0x61, 0x35, 0x32, 0x33, 0x66, 0x64, 0x31, 0x37, 0x32, 0x39, 0x35, 0x34, 0x34, 0x62, 0x32, 0x32, 0x36, 0x66, 0x34, 0x63, 0x33, 0x65, 0x66, 0x61, 0x37, 0x61, 0x64, 0x61, 0x37, 0x30, 0x64, 0x30, 0x65, 0x64, 0x64, 0x34, 0x62, 0x34, 0x66, 0x31, 0x34, 0x33, 0x32, 0x62, 0x30, 0x61, 0x32, 0x63, 0x65, 0x39, 0x37, 0x36, 0x36, 0x36, 0x63, 0x39, 0x64, 0x32, 0x62, 0x33, 0x62, 0x61, 0x33, 0x32, 0x64, 0x39, 0x33, 0x35, 0x35, 0x66, 0x39, 0x36, 0x64, 0x64, 0x30, 0x65, 0x38, 0x61, 0x35, 0x39, 0x36, 0x31, 0x35, 0x30, 0x39, 0x32, 0x33, 0x63, 0x63, 0x36, 0x37, 0x30, 0x64, 0x37, 0x32, 0x39, 0x64, 0x66, 0x33, 0x35, 0x65, 0x33, 0x62, 0x66, 0x66, 0x39, 0x64, 0x64, 0x30, 0x31, 0x38, 0x32, 0x33, 0x39, 0x39, 0x37, 0x66, 0x65, 0x37, 0x34, 0x35, 0x66, 0x32, 0x65, 0x61, 0x64, 0x30, 0x37, 0x63, 0x38, 0x35, 0x61, 0x62, 0x31, 0x33, 0x37, 0x32, 0x32, 0x38, 0x64, 0x37, 0x32, 0x33, 0x61, 0x34, 0x63, 0x38, 0x33, 0x30, 0x64, 0x33, 0x34, 0x65, 0x39, 0x63, 0x64, 0x34, 0x64, 0x65, 0x32, 0x64, 0x63, 0x33, 0x64, 0x65, 0x65, 0x61, 0x38, 0x31, 0x38, 0x30, 0x37, 0x63, 0x36, 0x34, 0x61, 0x35, 0x34, 0x32, 0x65, 0x34, 0x35, 0x36, 0x61, 0x33, 0x66, 0x34, 0x62, 0x31, 0x32, 0x66, 0x35, 0x31, 0x38, 0x30, 0x32, 0x36, 0x30, 0x34, 0x37, 0x32, 0x33, 0x61, 0x33, 0x66, 0x33, 0x30, 0x64, 0x37, 0x30, 0x66, 0x32, 0x65, 0x35, 0x66, 0x35, 0x34, 0x37, 0x64, 0x63, 0x32, 0x32, 0x36, 0x33, 0x66, 0x32, 0x64, 0x66, 0x39, 0x32, 0x35, 0x61, 0x35, 0x61, 0x36, 0x36, 0x39, 0x39, 0x65, 0x31, 0x61, 0x66, 0x66, 0x31, 0x34, 0x33, 0x64, 0x32, 0x61, 0x37, 0x62, 0x32, 0x39, 0x64, 0x31, 0x62, 0x64, 0x35, 0x39, 0x66, 0x37, 0x31, 0x32, 0x34, 0x36, 0x36, 0x66, 0x34, 0x35, 0x37, 0x39, 0x38, 0x61, 0x34, 0x35, 0x37, 0x61, 0x34, 0x65, 0x30, 0x37, 0x64, 0x35, 0x38, 0x38, 0x39, 0x32, 0x61, 0x62, 0x32, 0x62, 0x35, 0x33, 0x39, 0x31, 0x36, 0x65, 0x38, 0x66, 0x39, 0x35, 0x31, 0x66, 0x65, 0x37, 0x34, 0x36, 0x66, 0x32, 0x31, 0x64, 0x66, 0x66, 0x38, 0x30, 0x31, 0x35, 0x66, 0x62, 0x66, 0x31, 0x61, 0x65, 0x63, 0x32, 0x39, 0x62, 0x37, 0x32, 0x36, 0x32, 0x39, 0x34, 0x34, 0x65, 0x32, 0x66, 0x61, 0x35, 0x39, 0x32, 0x32, 0x37, 0x62, 0x30, 0x66, 0x36, 0x36, 0x36, 0x39, 0x62, 0x32, 0x65, 0x39, 0x30, 0x32, 0x64, 0x61, 0x66, 0x34, 0x65, 0x32, 0x33, 0x37, 0x65, 0x31, 0x65, 0x30, 0x34, 0x66, 0x66, 0x32, 0x31, 0x31, 0x35, 0x32, 0x31, 0x62, 0x65, 0x63, 0x63, 0x39, 0x61, 0x66, 0x35, 0x61, 0x36, 0x30, 0x37, 0x37, 0x64, 0x37, 0x32, 0x63, 0x39, 0x31, 0x32, 0x61, 0x64, 0x64, 0x30, 0x66, 0x62, 0x39, 0x61, 0x35, 0x34, 0x63, 0x38, 0x64, 0x36, 0x32, 0x65, 0x61, 0x61, 0x38, 0x61, 0x62, 0x36, 0x39, 0x39, 0x37, 0x38, 0x31, 0x36, 0x32, 0x39, 0x64, 0x35, 0x32, 0x35, 0x33, 0x61, 0x31, 0x62, 0x39, 0x32, 0x65, 0x66, 0x65, 0x38, 0x32, 0x34, 0x30, 0x62, 0x61, 0x36, 0x36, 0x34, 0x63, 0x30, 0x65, 0x34, 0x63, 0x63, 0x37, 0x32, 0x64, 0x61, 0x38, 0x36, 0x30, 0x33, 0x62, 0x31, 0x64, 0x32, 0x65, 0x62, 0x30, 0x32, 0x62, 0x36, 0x31, 0x35, 0x36, 0x64, 0x64, 0x32, 0x30, 0x39, 0x38, 0x36, 0x37, 0x63, 0x66, 0x64, 0x39, 0x38, 0x35, 0x65, 0x64, 0x62, 0x30, 0x61, 0x33, 0x35, 0x61, 0x33, 0x62, 0x63, 0x39, 0x34, 0x38, 0x39, 0x31, 0x61, 0x38, 0x32, 0x33, 0x33, 0x61, 0x62, 0x35, 0x65, 0x61, 0x61, 0x32, 0x63, 0x33, 0x30, 0x38, 0x39, 0x39, 0x31, 0x32, 0x35, 0x38, 0x31, 0x37, 0x34, 0x38, 0x66, 0x37, 0x39, 0x62, 0x63, 0x39, 0x65, 0x65, 0x38, 0x65, 0x30, 0x37, 0x61, 0x63, 0x35, 0x30, 0x39, 0x31, 0x31, 0x34, 0x34, 0x32, 0x39, 0x65, 0x63, 0x66, 0x36, 0x62, 0x36, 0x39, 0x31, 0x31, 0x37, 0x37, 0x31, 0x38, 0x36, 0x31, 0x32, 0x39, 0x39, 0x63, 0x62, 0x33, 0x63, 0x31, 0x64, 0x39, 0x31, 0x65, 0x34, 0x37, 0x32, 0x63, 0x63, 0x32, 0x33, 0x32, 0x63, 0x63, 0x37, 0x61, 0x34, 0x31, 0x36, 0x62, 0x30, 0x66, 0x33, 0x33, 0x65, 0x37, 0x62, 0x34, 0x65, 0x39, 0x38, 0x38, 0x61, 0x33, 0x35, 0x30, 0x31, 0x65, 0x61, 0x61, 0x62, 0x34, 0x31, 0x64, 0x33, 0x63, 0x63, 0x61, 0x38, 0x38, 0x36, 0x62, 0x31, 0x33, 0x36, 0x38, 0x36, 0x65, 0x31, 0x31, 0x31, 0x39, 0x30, 0x63, 0x39, 0x62, 0x35, 0x37, 0x38, 0x37, 0x32, 0x32, 0x33, 0x62, 0x62, 0x35, 0x65, 0x37, 0x66, 0x33, 0x36, 0x39, 0x38, 0x37, 0x35, 0x37, 0x30, 0x63, 0x38, 0x61, 0x62, 0x37, 0x66, 0x32, 0x65, 0x38, 0x66, 0x37, 0x31, 0x32, 0x31, 0x35, 0x31, 0x34, 0x30, 0x38, 0x66, 0x38, 0x66, 0x63, 0x66, 0x64, 0x61, 0x61, 0x39, 0x34, 0x31, 0x62, 0x63, 0x66, 0x32, 0x34, 0x35, 0x63, 0x61, 0x31, 0x39, 0x61, 0x36, 0x61, 0x61, 0x38, 0x32, 0x37, 0x32, 0x65, 0x31, 0x62, 0x64, 0x66, 0x65, 0x62, 0x62, 0x33, 0x64, 0x62, 0x33, 0x66, 0x38, 0x34, 0x36, 0x63, 0x37, 0x63, 0x62, 0x65, 0x65, 0x61, 0x37, 0x34, 0x31, 0x33, 0x35, 0x66, 0x33, 0x64, 0x37, 0x33, 0x64, 0x39, 0x62, 0x35, 0x39, 0x38, 0x33, 0x38, 0x36, 0x65, 0x38, 0x31, 0x66, 0x38, 0x30, 0x31, 0x34, 0x34, 0x31, 0x66, 0x35, 0x36, 0x33, 0x63, 0x32, 0x62, 0x65, 0x37, 0x65, 0x37, 0x32, 0x64, 0x33, 0x64, 0x34, 0x34, 0x63, 0x30, 0x35, 0x61, 0x31, 0x38, 0x66, 0x36, 0x33, 0x66, 0x63, 0x37, 0x66, 0x34, 0x65, 0x35, 0x38, 0x35, 0x37, 0x38, 0x38, 0x30, 0x64, 0x36, 0x63, 0x31, 0x34, 0x34, 0x38, 0x33, 0x64, 0x30, 0x32, 0x61, 0x35, 0x63, 0x35, 0x64, 0x62, 0x63, 0x66, 0x61, 0x31, 0x66, 0x33, 0x35, 0x61, 0x39, 0x65, 0x62, 0x61, 0x38, 0x30, 0x65, 0x37, 0x65, 0x66, 0x34, 0x62, 0x33, 0x39, 0x32, 0x35, 0x62, 0x64, 0x65, 0x63, 0x39, 0x31, 0x62, 0x63, 0x35, 0x35, 0x32, 0x37, 0x34, 0x30, 0x35, 0x38, 0x33, 0x33, 0x62, 0x66, 0x62, 0x36, 0x62, 0x33, 0x33, 0x36, 0x62, 0x34, 0x34, 0x38, 0x63, 0x64, 0x36, 0x33, 0x37, 0x63, 0x32, 0x66, 0x62, 0x38, 0x39, 0x63, 0x36, 0x38, 0x65, 0x32, 0x35, 0x39, 0x34, 0x30, 0x35, 0x38, 0x61, 0x61, 0x63, 0x33, 0x65, 0x35, 0x37, 0x32, 0x39, 0x36, 0x38, 0x30, 0x30, 0x61, 0x66, 0x65, 0x31, 0x65, 0x64, 0x32, 0x39, 0x64, 0x61, 0x65, 0x63, 0x37, 0x35, 0x64, 0x61, 0x64, 0x61, 0x63, 0x65, 0x64, 0x64, 0x37, 0x65, 0x36, 0x37, 0x36, 0x36, 0x30, 0x64, 0x30, 0x61, 0x65, 0x66, 0x39, 0x61, 0x62, 0x36, 0x63, 0x35, 0x36, 0x31, 0x36, 0x32, 0x33, 0x30, 0x33, 0x39, 0x64, 0x30, 0x65, 0x33, 0x33, 0x61, 0x36, 0x39, 0x32, 0x37, 0x32, 0x65, 0x34, 0x38, 0x32, 0x66, 0x36, 0x38, 0x61, 0x32, 0x32, 0x36, 0x33, 0x37, 0x32, 0x37, 0x66, 0x61, 0x66, 0x63, 0x64, 0x63, 0x30, 0x33, 0x34, 0x66, 0x62, 0x38, 0x66, 0x64, 0x66, 0x61, 0x38, 0x38, 0x36, 0x36, 0x62, 0x61, 0x36, 0x31, 0x33, 0x61, 0x61, 0x61, 0x39, 0x66, 0x31, 0x34, 0x35, 0x35, 0x64, 0x30, 0x34, 0x34, 0x36, 0x64, 0x31, 0x33, 0x38, 0x32, 0x61, 0x61, 0x30, 0x37, 0x32, 0x39, 0x39, 0x62, 0x64, 0x34, 0x39, 0x34, 0x37, 0x37, 0x33, 0x37, 0x66, 0x30, 0x64, 0x31, 0x61, 0x66, 0x38, 0x32, 0x64, 0x38, 0x35, 0x66, 0x37, 0x61, 0x61, 0x33, 0x32, 0x62, 0x64, 0x62, 0x39, 0x39, 0x37, 0x62, 0x36, 0x37, 0x39, 0x37, 0x35, 0x64, 0x66, 0x38, 0x35, 0x32, 0x30, 0x36, 0x31, 0x62, 0x61, 0x33, 0x30, 0x39, 0x61, 0x33, 0x34, 0x62, 0x36, 0x37, 0x65, 0x64, 0x39, 0x37, 0x32, 0x32, 0x34, 0x31, 0x31, 0x31, 0x30, 0x38, 0x34, 0x33, 0x65, 0x62, 0x37, 0x62, 0x31, 0x37, 0x32, 0x37, 0x31, 0x38, 0x34, 0x34, 0x39, 0x62, 0x65, 0x33, 0x65, 0x64, 0x32, 0x30, 0x62, 0x33, 0x30, 0x66, 0x35, 0x30, 0x63, 0x33, 0x30, 0x63, 0x34, 0x63, 0x30, 0x35, 0x39, 0x36, 0x33, 0x38, 0x30, 0x32, 0x32, 0x65, 0x36, 0x30, 0x32, 0x61, 0x32, 0x31, 0x66, 0x32, 0x38, 0x36, 0x33, 0x33, 0x65, 0x30, 0x65, 0x61, 0x63, 0x31, 0x39, 0x65, 0x31, 0x62, 0x36, 0x39, 0x33, 0x64, 0x34, 0x37, 0x63, 0x30, 0x64, 0x62, 0x33, 0x66, 0x36, 0x62, 0x61, 0x63, 0x30, 0x39, 0x61, 0x65, 0x66, 0x63, 0x62, 0x32, 0x65, 0x32, 0x34, 0x64, 0x62, 0x62, 0x31, 0x61, 0x63, 0x61, 0x65, 0x63, 0x32, 0x31, 0x36, 0x35, 0x32, 0x63, 0x37, 0x66, 0x31, 0x66, 0x32, 0x31, 0x63, 0x61, 0x35, 0x63, 0x31, 0x37, 0x32, 0x32, 0x63, 0x62, 0x64, 0x66, 0x37, 0x36, 0x64, 0x31, 0x33, 0x32, 0x39, 0x61, 0x37, 0x37, 0x34, 0x65, 0x32, 0x38, 0x64, 0x61, 0x39, 0x65, 0x32, 0x36, 0x36, 0x66, 0x36, 0x30, 0x64, 0x62, 0x66, 0x63, 0x35, 0x32, 0x62, 0x30, 0x64, 0x32, 0x64, 0x32, 0x38, 0x62, 0x64, 0x38, 0x35, 0x39, 0x34, 0x37, 0x66, 0x33, 0x33, 0x34, 0x61, 0x32, 0x37, 0x35, 0x61, 0x34, 0x33, 0x33, 0x36, 0x37, 0x32, 0x63, 0x61, 0x36, 0x66, 0x61, 0x65, 0x66, 0x31, 0x30, 0x35, 0x31, 0x37, 0x31, 0x65, 0x31, 0x31, 0x30, 0x64, 0x65, 0x30, 0x64, 0x62, 0x64, 0x65, 0x30, 0x66, 0x61, 0x39, 0x63, 0x33, 0x66, 0x34, 0x66, 0x62, 0x33, 0x36, 0x37, 0x61, 0x66, 0x32, 0x32, 0x33, 0x64, 0x37, 0x37, 0x66, 0x62, 0x31, 0x36, 0x66, 0x31, 0x66, 0x38, 0x32, 0x37, 0x34, 0x65, 0x38, 0x36, 0x30, 0x33, 0x36, 0x37, 0x32, 0x32, 0x34, 0x65, 0x34, 0x30, 0x31, 0x31, 0x37, 0x33, 0x37, 0x61, 0x31, 0x37, 0x36, 0x65, 0x66, 0x64, 0x36, 0x64, 0x62, 0x39, 0x35, 0x35, 0x34, 0x66, 0x62, 0x64, 0x64, 0x38, 0x64, 0x61, 0x64, 0x63, 0x64, 0x36, 0x63, 0x38, 0x37, 0x37, 0x63, 0x61, 0x62, 0x30, 0x35, 0x33, 0x35, 0x37, 0x62, 0x39, 0x64, 0x64, 0x36, 0x63, 0x38, 0x62, 0x61, 0x32, 0x33, 0x64, 0x36, 0x35, 0x63, 0x36, 0x66, 0x38, 0x33, 0x62, 0x61, 0x61, 0x32, 0x34, 0x63, 0x31, 0x32, 0x39, 0x65, 0x39, 0x62, 0x63, 0x35, 0x36, 0x39, 0x36, 0x34, 0x63, 0x65, 0x30, 0x62, 0x64, 0x35, 0x39, 0x61, 0x61, 0x63, 0x38, 0x34, 0x38, 0x62, 0x36, 0x35, 0x66, 0x37, 0x30, 0x38, 0x64, 0x35, 0x63, 0x61, 0x35, 0x62, 0x63, 0x34, 0x37, 0x61, 0x36, 0x34, 0x35, 0x61, 0x33, 0x39, 0x61, 0x61, 0x35, 0x39, 0x38, 0x39, 0x32, 0x65, 0x30, 0x36, 0x66, 0x61, 0x32, 0x66, 0x61, 0x39, 0x66, 0x31, 0x34, 0x37, 0x64, 0x37, 0x64, 0x32, 0x34, 0x63, 0x62, 0x63, 0x36, 0x62, 0x30, 0x39, 0x37, 0x30, 0x63, 0x37, 0x31, 0x32, 0x32, 0x32, 0x61, 0x33, 0x36, 0x34, 0x38, 0x31, 0x63, 0x39, 0x34, 0x35, 0x34, 0x39, 0x62, 0x30, 0x31, 0x30, 0x65, 0x64, 0x30, 0x31, 0x33, 0x33, 0x61, 0x37, 0x63, 0x31, 0x65, 0x39, 0x31, 0x65, 0x37, 0x32, 0x34, 0x32, 0x38, 0x62, 0x30, 0x63, 0x37, 0x36, 0x31, 0x63, 0x33, 0x61, 0x64, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x35, 0x34, 0x33, 0x62, 0x62, 0x38, 0x66, 0x31, 0x33, 0x66, 0x65, 0x33, 0x31, 0x61, 0x36, 0x66, 0x33, 0x64, 0x62, 0x63, 0x33, 0x66, 0x37, 0x64, 0x39, 0x63, 0x39, 0x30, 0x35, 0x39, 0x37, 0x61, 0x63, 0x34, 0x30, 0x36, 0x64, 0x65, 0x61, 0x61, 0x31, 0x30, 0x35, 0x37, 0x32, 0x62, 0x63, 0x33, 0x39, 0x36, 0x34, 0x30, 0x65, 0x37, 0x32, 0x34, 0x36, 0x36, 0x63, 0x66, 0x63, 0x30, 0x63, 0x63, 0x61, 0x38, 0x34, 0x39, 0x66, 0x32, 0x39, 0x62, 0x61, 0x30, 0x65, 0x39, 0x37, 0x31, 0x35, 0x38, 0x37, 0x38, 0x39, 0x38, 0x62, 0x35, 0x63, 0x34, 0x65, 0x37, 0x64, 0x39, 0x31, 0x65, 0x35, 0x38, 0x35, 0x35, 0x64, 0x61, 0x31, 0x63, 0x63, 0x65, 0x64, 0x63, 0x35, 0x37, 0x32, 0x63, 0x66, 0x66, 0x31, 0x64, 0x34, 0x37, 0x32, 0x33, 0x35, 0x36, 0x35, 0x64, 0x31, 0x62, 0x39, 0x63, 0x63, 0x65, 0x34, 0x32, 0x34, 0x34, 0x32, 0x34, 0x63, 0x64, 0x62, 0x37, 0x62, 0x30, 0x32, 0x31, 0x63, 0x65, 0x38, 0x63, 0x36, 0x64, 0x63, 0x62, 0x39, 0x33, 0x31, 0x63, 0x36, 0x64, 0x33, 0x63, 0x62, 0x63, 0x33, 0x65, 0x34, 0x38, 0x37, 0x31, 0x32, 0x30, 0x37, 0x39, 0x37, 0x31, 0x61, 0x64, 0x62, 0x36, 0x63, 0x39, 0x33, 0x62, 0x61, 0x39, 0x30, 0x31, 0x35, 0x61, 0x65, 0x36, 0x36, 0x30, 0x31, 0x65, 0x31, 0x65, 0x33, 0x30, 0x34, 0x30, 0x37, 0x30, 0x33, 0x61, 0x35, 0x66, 0x33, 0x38, 0x30, 0x66, 0x35, 0x37, 0x30, 0x39, 0x31, 0x64, 0x35, 0x35, 0x62, 0x38, 0x33, 0x37, 0x38, 0x38, 0x38, 0x34, 0x63, 0x65, 0x62, 0x38, 0x36, 0x33, 0x35, 0x31, 0x35, 0x32, 0x39, 0x32, 0x61, 0x64, 0x31, 0x35, 0x61, 0x61, 0x36, 0x31, 0x39, 0x36, 0x37, 0x33, 0x30, 0x35, 0x36, 0x65, 0x36, 0x31, 0x39, 0x37, 0x30, 0x66, 0x39, 0x37, 0x32, 0x34, 0x31, 0x33, 0x39, 0x33, 0x65, 0x33, 0x39, 0x62, 0x31, 0x62, 0x38, 0x63, 0x64, 0x65, 0x33, 0x36, 0x61, 0x66, 0x34, 0x37, 0x36, 0x34, 0x32, 0x64, 0x62, 0x65, 0x30, 0x35, 0x31, 0x33, 0x62, 0x37, 0x36, 0x62, 0x62, 0x62, 0x30, 0x31, 0x39, 0x63, 0x37, 0x32, 0x39, 0x39, 0x64, 0x61, 0x66, 0x30, 0x64, 0x36, 0x66, 0x65, 0x31, 0x62, 0x31, 0x34, 0x62, 0x63, 0x39, 0x65, 0x31, 0x66, 0x61, 0x36, 0x66, 0x62, 0x64, 0x36, 0x39, 0x33, 0x63, 0x38, 0x36, 0x37, 0x65, 0x63, 0x30, 0x66, 0x38, 0x39, 0x65, 0x62, 0x31, 0x66, 0x37, 0x36, 0x34, 0x38, 0x66, 0x35, 0x65, 0x39, 0x61, 0x39, 0x61, 0x30, 0x33, 0x32, 0x63, 0x65, 0x33, 0x31, 0x65, 0x35, 0x31, 0x62, 0x37, 0x64, 0x38, 0x33, 0x32, 0x65, 0x34, 0x61, 0x37, 0x39, 0x61, 0x61, 0x62, 0x65, 0x63, 0x61, 0x30, 0x39, 0x32, 0x38, 0x36, 0x35, 0x63, 0x32, 0x36, 0x66, 0x62, 0x31, 0x38, 0x61, 0x38, 0x35, 0x62, 0x61, 0x66, 0x61, 0x63, 0x37, 0x32, 0x34, 0x35, 0x31, 0x39, 0x61, 0x33, 0x33, 0x30, 0x32, 0x30, 0x33, 0x66, 0x38, 0x36, 0x63, 0x38, 0x35, 0x38, 0x36, 0x65, 0x33, 0x66, 0x35, 0x37, 0x35, 0x65, 0x32, 0x36, 0x39, 0x38, 0x32, 0x37, 0x63, 0x65, 0x65, 0x31, 0x34, 0x33, 0x31, 0x39, 0x63, 0x31, 0x38, 0x35, 0x64, 0x32, 0x30, 0x36, 0x66, 0x37, 0x63, 0x62, 0x39, 0x38, 0x32, 0x62, 0x63, 0x66, 0x63, 0x30, 0x63, 0x33, 0x30, 0x63, 0x61, 0x33, 0x37, 0x39, 0x31, 0x39, 0x39, 0x32, 0x66, 0x64, 0x35, 0x64, 0x36, 0x66, 0x37, 0x30, 0x38, 0x65, 0x38, 0x34, 0x36, 0x34, 0x64, 0x33, 0x64, 0x61, 0x31, 0x33, 0x34, 0x63, 0x65, 0x65, 0x38, 0x33, 0x62, 0x39, 0x64, 0x31, 0x34, 0x34, 0x66, 0x34, 0x32, 0x65, 0x66, 0x61, 0x37, 0x37, 0x65, 0x64, 0x39, 0x38, 0x32, 0x62, 0x61, 0x66, 0x64, 0x36, 0x37, 0x62, 0x37, 0x38, 0x39, 0x66, 0x37, 0x36, 0x36, 0x32, 0x31, 0x65, 0x34, 0x62, 0x37, 0x35, 0x34, 0x34, 0x63, 0x66, 0x65, 0x34, 0x33, 0x38, 0x38, 0x38, 0x37, 0x32, 0x66, 0x61, 0x30, 0x33, 0x33, 0x37, 0x65, 0x64, 0x34, 0x34, 0x63, 0x39, 0x62, 0x34, 0x31, 0x38, 0x35, 0x39, 0x32, 0x32, 0x37, 0x65, 0x33, 0x63, 0x38, 0x66, 0x36, 0x39, 0x63, 0x64, 0x63, 0x63, 0x37, 0x39, 0x33, 0x35, 0x61, 0x63, 0x32, 0x39, 0x39, 0x38, 0x66, 0x66, 0x38, 0x65, 0x36, 0x37, 0x30, 0x38, 0x64, 0x65, 0x36, 0x32, 0x37, 0x30, 0x64, 0x31, 0x66, 0x37, 0x33, 0x61, 0x37, 0x32, 0x30, 0x30, 0x38, 0x31, 0x63, 0x64, 0x64, 0x36, 0x30, 0x65, 0x64, 0x66, 0x65, 0x36, 0x66, 0x66, 0x32, 0x30, 0x65, 0x38, 0x30, 0x30, 0x32, 0x37, 0x32, 0x62, 0x39, 0x36, 0x35, 0x39, 0x64, 0x36, 0x39, 0x38, 0x30, 0x63, 0x37, 0x35, 0x61, 0x37, 0x33, 0x39, 0x63, 0x34, 0x35, 0x34, 0x32, 0x37, 0x33, 0x62, 0x64, 0x38, 0x65, 0x36, 0x62, 0x65, 0x38, 0x33, 0x36, 0x62, 0x33, 0x62, 0x37, 0x32, 0x65, 0x35, 0x31, 0x61, 0x36, 0x34, 0x64, 0x32, 0x62, 0x38, 0x34, 0x61, 0x33, 0x62, 0x64, 0x33, 0x39, 0x64, 0x34, 0x62, 0x63, 0x63, 0x62, 0x30, 0x38, 0x61, 0x62, 0x65, 0x33, 0x37, 0x66, 0x37, 0x66, 0x38, 0x38, 0x35, 0x36, 0x36, 0x33, 0x30, 0x64, 0x65, 0x36, 0x61, 0x30, 0x64, 0x30, 0x37, 0x30, 0x32, 0x37, 0x64, 0x62, 0x38, 0x62, 0x33, 0x35, 0x64, 0x64, 0x65, 0x63, 0x66, 0x32, 0x31, 0x63, 0x65, 0x38, 0x39, 0x39, 0x64, 0x38, 0x34, 0x66, 0x39, 0x62, 0x36, 0x39, 0x35, 0x65, 0x34, 0x33, 0x36, 0x63, 0x34, 0x63, 0x33, 0x37, 0x35, 0x33, 0x65, 0x33, 0x35, 0x35, 0x32, 0x61, 0x32, 0x35, 0x65, 0x37, 0x66, 0x39, 0x37, 0x37, 0x64, 0x39, 0x66, 0x66, 0x38, 0x64, 0x30, 0x34, 0x62, 0x64, 0x33, 0x39, 0x37, 0x66, 0x63, 0x35, 0x31, 0x30, 0x61, 0x64, 0x61, 0x65, 0x33, 0x37, 0x32, 0x34, 0x31, 0x65, 0x33, 0x61, 0x61, 0x33, 0x37, 0x66, 0x38, 0x31, 0x36, 0x61, 0x34, 0x36, 0x30, 0x37, 0x65, 0x34, 0x31, 0x62, 0x34, 0x65, 0x33, 0x38, 0x63, 0x30, 0x61, 0x38, 0x33, 0x64, 0x37, 0x62, 0x32, 0x64, 0x61, 0x35, 0x36, 0x32, 0x34, 0x35, 0x32, 0x32, 0x32, 0x30, 0x31, 0x32, 0x62, 0x34, 0x63, 0x33, 0x39, 0x66, 0x36, 0x39, 0x33, 0x35, 0x66, 0x33, 0x39, 0x34, 0x64, 0x33, 0x33, 0x64, 0x61, 0x34, 0x30, 0x65, 0x34, 0x36, 0x66, 0x61, 0x35, 0x34, 0x38, 0x38, 0x37, 0x64, 0x65, 0x37, 0x36, 0x30, 0x32, 0x39, 0x66, 0x64, 0x39, 0x39, 0x34, 0x61, 0x34, 0x66, 0x31, 0x64, 0x32, 0x66, 0x36, 0x35, 0x64, 0x35, 0x61, 0x34, 0x61, 0x32, 0x64, 0x63, 0x63, 0x66, 0x64, 0x32, 0x39, 0x33, 0x62, 0x38, 0x66, 0x31, 0x65, 0x35, 0x32, 0x31, 0x35, 0x35, 0x39, 0x62, 0x31, 0x37, 0x32, 0x38, 0x37, 0x61, 0x66, 0x66, 0x32, 0x30, 0x63, 0x33, 0x39, 0x61, 0x66, 0x34, 0x66, 0x32, 0x64, 0x30, 0x37, 0x39, 0x61, 0x35, 0x30, 0x32, 0x36, 0x33, 0x63, 0x61, 0x30, 0x63, 0x33, 0x39, 0x32, 0x39, 0x30, 0x34, 0x35, 0x65, 0x63, 0x37, 0x64, 0x39, 0x30, 0x37, 0x64, 0x39, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x31, 0x61, 0x31, 0x39, 0x64, 0x30, 0x32, 0x66, 0x30, 0x32, 0x38, 0x32, 0x66, 0x63, 0x32, 0x35, 0x61, 0x31, 0x64, 0x63, 0x62, 0x65, 0x32, 0x64, 0x33, 0x33, 0x36, 0x30, 0x38, 0x63, 0x31, 0x31, 0x39, 0x36, 0x61, 0x35, 0x33, 0x36, 0x61, 0x64, 0x30, 0x39, 0x31, 0x33, 0x39, 0x30, 0x38, 0x65, 0x36, 0x62, 0x33, 0x38, 0x61, 0x65, 0x33, 0x61, 0x66, 0x34, 0x62, 0x35, 0x39, 0x30, 0x37, 0x62, 0x30, 0x34, 0x32, 0x32, 0x62, 0x65, 0x35, 0x65, 0x35, 0x35, 0x64, 0x37, 0x32, 0x61, 0x30, 0x63, 0x62, 0x30, 0x61, 0x66, 0x34, 0x34, 0x30, 0x63, 0x61, 0x36, 0x34, 0x32, 0x39, 0x66, 0x37, 0x32, 0x65, 0x38, 0x39, 0x62, 0x63, 0x30, 0x65, 0x61, 0x32, 0x37, 0x35, 0x30, 0x62, 0x38, 0x35, 0x63, 0x39, 0x62, 0x39, 0x37, 0x30, 0x31, 0x65, 0x63, 0x34, 0x65, 0x34, 0x33, 0x31, 0x33, 0x36, 0x64, 0x37, 0x33, 0x64, 0x31, 0x38, 0x64, 0x62, 0x38, 0x38, 0x32, 0x36, 0x35, 0x63, 0x31, 0x30, 0x65, 0x39, 0x62, 0x32, 0x32, 0x61, 0x34, 0x34, 0x39, 0x38, 0x65, 0x65, 0x39, 0x34, 0x37, 0x36, 0x33, 0x36, 0x63, 0x30, 0x61, 0x39, 0x38, 0x63, 0x33, 0x36, 0x63, 0x64, 0x31, 0x66, 0x37, 0x38, 0x62, 0x39, 0x63, 0x66, 0x37, 0x36, 0x61, 0x33, 0x62, 0x62, 0x36, 0x32, 0x65, 0x32, 0x66, 0x64, 0x63, 0x66, 0x31, 0x64, 0x36, 0x33, 0x36, 0x65, 0x65, 0x30, 0x62, 0x36, 0x36, 0x34, 0x66, 0x63, 0x35, 0x35, 0x65, 0x66, 0x38, 0x30, 0x38, 0x62, 0x30, 0x64, 0x32, 0x39, 0x62, 0x65, 0x31, 0x65, 0x36, 0x39, 0x36, 0x63, 0x64, 0x35, 0x33, 0x31, 0x66, 0x31, 0x33, 0x39, 0x66, 0x37, 0x61, 0x33, 0x30, 0x63, 0x32, 0x66, 0x64, 0x66, 0x65, 0x39, 0x61, 0x35, 0x65, 0x64, 0x65, 0x61, 0x64, 0x37, 0x30, 0x36, 0x33, 0x64, 0x66, 0x31, 0x37, 0x34, 0x37, 0x63, 0x62, 0x62, 0x30, 0x35, 0x32, 0x62, 0x38, 0x31, 0x32, 0x30, 0x66, 0x35, 0x35, 0x62, 0x64, 0x38, 0x39, 0x65, 0x36, 0x39, 0x32, 0x64, 0x66, 0x61, 0x66, 0x61, 0x30, 0x33, 0x39, 0x32, 0x33, 0x32, 0x64, 0x32, 0x62, 0x65, 0x38, 0x30, 0x61, 0x32, 0x64, 0x34, 0x37, 0x32, 0x32, 0x37, 0x38, 0x34, 0x33, 0x36, 0x63, 0x37, 0x30, 0x32, 0x35, 0x63, 0x31, 0x64, 0x39, 0x39, 0x39, 0x38, 0x61, 0x61, 0x31, 0x61, 0x37, 0x32, 0x34, 0x32, 0x30, 0x65, 0x37, 0x35, 0x65, 0x33, 0x32, 0x61, 0x37, 0x31, 0x39, 0x61, 0x33, 0x34, 0x30, 0x39, 0x61, 0x33, 0x34, 0x37, 0x34, 0x65, 0x36, 0x33, 0x30, 0x31, 0x32, 0x62, 0x63, 0x63, 0x66, 0x66, 0x34, 0x65, 0x31, 0x31, 0x36, 0x66, 0x61, 0x64, 0x35, 0x33, 0x33, 0x64, 0x39, 0x31, 0x35, 0x38, 0x30, 0x66, 0x63, 0x31, 0x66, 0x36, 0x32, 0x65, 0x37, 0x39, 0x39, 0x63, 0x32, 0x63, 0x34, 0x36, 0x32, 0x38, 0x32, 0x66, 0x35, 0x33, 0x62, 0x62, 0x65, 0x66, 0x34, 0x36, 0x30, 0x38, 0x30, 0x63, 0x33, 0x36, 0x37, 0x36, 0x32, 0x66, 0x36, 0x65, 0x61, 0x64, 0x38, 0x65, 0x61, 0x39, 0x64, 0x66, 0x39, 0x34, 0x30, 0x33, 0x61, 0x66, 0x66, 0x66, 0x35, 0x36, 0x30, 0x61, 0x64, 0x62, 0x37, 0x64, 0x61, 0x66, 0x38, 0x39, 0x37, 0x66, 0x33, 0x38, 0x32, 0x66, 0x63, 0x61, 0x37, 0x32, 0x31, 0x30, 0x37, 0x61, 0x62, 0x33, 0x61, 0x32, 0x64, 0x63, 0x62, 0x38, 0x33, 0x39, 0x32, 0x39, 0x34, 0x38, 0x33, 0x63, 0x36, 0x62, 0x63, 0x38, 0x38, 0x31, 0x35, 0x38, 0x66, 0x63, 0x36, 0x65, 0x64, 0x64, 0x39, 0x66, 0x62, 0x31, 0x39, 0x38, 0x37, 0x64, 0x30, 0x39, 0x36, 0x37, 0x31, 0x34, 0x39, 0x65, 0x30, 0x66, 0x32, 0x38, 0x64, 0x64, 0x33, 0x39, 0x38, 0x35, 0x63, 0x30, 0x37, 0x32, 0x61, 0x63, 0x63, 0x65, 0x39, 0x37, 0x32, 0x37, 0x30, 0x32, 0x66, 0x33, 0x30, 0x61, 0x36, 0x33, 0x31, 0x62, 0x32, 0x39, 0x36, 0x38, 0x61, 0x33, 0x32, 0x32, 0x62, 0x38, 0x64, 0x33, 0x62, 0x65, 0x62, 0x65, 0x64, 0x31, 0x34, 0x62, 0x64, 0x36, 0x30, 0x65, 0x63, 0x31, 0x63, 0x35, 0x30, 0x35, 0x65, 0x32, 0x33, 0x38, 0x39, 0x39, 0x37, 0x39, 0x30, 0x37, 0x38, 0x38, 0x61, 0x61, 0x37, 0x32, 0x31, 0x34, 0x62, 0x35, 0x30, 0x30, 0x63, 0x36, 0x35, 0x39, 0x34, 0x32, 0x34, 0x66, 0x38, 0x37, 0x35, 0x37, 0x34, 0x39, 0x37, 0x38, 0x65, 0x37, 0x32, 0x62, 0x62, 0x61, 0x30, 0x38, 0x66, 0x38, 0x65, 0x32, 0x62, 0x66, 0x37, 0x61, 0x31, 0x37, 0x37, 0x37, 0x61, 0x66, 0x38, 0x36, 0x63, 0x32, 0x35, 0x31, 0x65, 0x36, 0x38, 0x35, 0x32, 0x63, 0x33, 0x30, 0x30, 0x31, 0x64, 0x33, 0x37, 0x32, 0x35, 0x31, 0x38, 0x31, 0x37, 0x33, 0x32, 0x35, 0x66, 0x64, 0x38, 0x37, 0x63, 0x38, 0x32, 0x38, 0x31, 0x30, 0x36, 0x34, 0x66, 0x61, 0x61, 0x35, 0x31, 0x37, 0x30, 0x32, 0x39, 0x64, 0x33, 0x36, 0x33, 0x66, 0x38, 0x62, 0x31, 0x63, 0x33, 0x63, 0x61, 0x65, 0x65, 0x65, 0x64, 0x62, 0x63, 0x36, 0x63, 0x35, 0x36, 0x62, 0x36, 0x33, 0x63, 0x39, 0x33, 0x31, 0x38, 0x62, 0x31, 0x34, 0x33, 0x37, 0x32, 0x33, 0x65, 0x63, 0x35, 0x63, 0x39, 0x35, 0x30, 0x33, 0x61, 0x66, 0x32, 0x66, 0x30, 0x32, 0x32, 0x66, 0x31, 0x61, 0x38, 0x66, 0x64, 0x37, 0x32, 0x39, 0x66, 0x33, 0x65, 0x39, 0x66, 0x35, 0x34, 0x33, 0x33, 0x39, 0x33, 0x34, 0x31, 0x35, 0x37, 0x36, 0x62, 0x36, 0x37, 0x61, 0x31, 0x61, 0x38, 0x31, 0x66, 0x31, 0x30, 0x62, 0x36, 0x37, 0x63, 0x36, 0x33, 0x63, 0x61, 0x61, 0x32, 0x64, 0x31, 0x62, 0x32, 0x61, 0x65, 0x32, 0x66, 0x36, 0x33, 0x34, 0x30, 0x34, 0x32, 0x31, 0x61, 0x37, 0x31, 0x62, 0x36, 0x31, 0x38, 0x63, 0x36, 0x30, 0x65, 0x36, 0x65, 0x65, 0x65, 0x37, 0x33, 0x65, 0x65, 0x30, 0x34, 0x34, 0x66, 0x63, 0x65, 0x36, 0x34, 0x63, 0x33, 0x33, 0x35, 0x37, 0x31, 0x34, 0x65, 0x32, 0x63, 0x39, 0x62, 0x32, 0x34, 0x33, 0x39, 0x31, 0x65, 0x64, 0x38, 0x31, 0x36, 0x38, 0x38, 0x61, 0x64, 0x63, 0x34, 0x63, 0x64, 0x62, 0x32, 0x65, 0x65, 0x32, 0x62, 0x33, 0x62, 0x35, 0x37, 0x33, 0x38, 0x64, 0x36, 0x32, 0x31, 0x36, 0x38, 0x34, 0x35, 0x38, 0x66, 0x63, 0x63, 0x39, 0x33, 0x61, 0x30, 0x39, 0x33, 0x36, 0x65, 0x62, 0x61, 0x35, 0x62, 0x64, 0x30, 0x64, 0x31, 0x65, 0x63, 0x63, 0x37, 0x64, 0x63, 0x63, 0x39, 0x34, 0x64, 0x39, 0x33, 0x65, 0x30, 0x39, 0x31, 0x35, 0x36, 0x62, 0x33, 0x61, 0x33, 0x39, 0x61, 0x62, 0x38, 0x65, 0x64, 0x65, 0x39, 0x37, 0x37, 0x66, 0x63, 0x66, 0x61, 0x32, 0x32, 0x39, 0x65, 0x39, 0x65, 0x63, 0x37, 0x66, 0x36, 0x36, 0x66, 0x38, 0x30, 0x32, 0x38, 0x36, 0x35, 0x32, 0x30, 0x39, 0x31, 0x34, 0x36, 0x30, 0x31, 0x63, 0x64, 0x31, 0x39, 0x66, 0x36, 0x32, 0x65, 0x33, 0x37, 0x61, 0x62, 0x35, 0x33, 0x65, 0x64, 0x66, 0x32, 0x38, 0x65, 0x64, 0x62, 0x34, 0x65, 0x35, 0x65, 0x62, 0x38, 0x64, 0x63, 0x62, 0x30, 0x34, 0x65, 0x35, 0x31, 0x66, 0x37, 0x66, 0x38, 0x62, 0x65, 0x64, 0x33, 0x34, 0x65, 0x61, 0x38, 0x36, 0x62, 0x30, 0x62, 0x34, 0x66, 0x36, 0x39, 0x31, 0x64, 0x62, 0x33, 0x38, 0x35, 0x64, 0x38, 0x39, 0x32, 0x65, 0x64, 0x38, 0x61, 0x39, 0x35, 0x63, 0x61, 0x33, 0x39, 0x63, 0x31, 0x64, 0x65, 0x37, 0x37, 0x32, 0x32, 0x35, 0x61, 0x65, 0x34, 0x33, 0x37, 0x62, 0x32, 0x36, 0x62, 0x37, 0x63, 0x31, 0x34, 0x36, 0x35, 0x33, 0x66, 0x35, 0x33, 0x65, 0x63, 0x31, 0x37, 0x64, 0x64, 0x30, 0x30, 0x36, 0x64, 0x36, 0x36, 0x39, 0x63, 0x39, 0x34, 0x38, 0x35, 0x62, 0x64, 0x30, 0x35, 0x33, 0x66, 0x61, 0x66, 0x66, 0x66, 0x65, 0x36, 0x32, 0x30, 0x35, 0x35, 0x32, 0x61, 0x62, 0x32, 0x30, 0x37, 0x30, 0x37, 0x32, 0x62, 0x39, 0x38, 0x37, 0x33, 0x66, 0x62, 0x62, 0x38, 0x32, 0x65, 0x33, 0x36, 0x61, 0x32, 0x65, 0x64, 0x30, 0x30, 0x62, 0x62, 0x33, 0x65, 0x35, 0x38, 0x65, 0x64, 0x62, 0x37, 0x64, 0x30, 0x63, 0x37, 0x38, 0x31, 0x34, 0x34, 0x64, 0x64, 0x61, 0x39, 0x36, 0x35, 0x37, 0x35, 0x63, 0x31, 0x63, 0x61, 0x39, 0x39, 0x62, 0x38, 0x39, 0x31, 0x61, 0x66, 0x38, 0x63, 0x66, 0x36, 0x61, 0x31, 0x65, 0x32, 0x33, 0x39, 0x66, 0x64, 0x35, 0x34, 0x35, 0x39, 0x63, 0x62, 0x35, 0x66, 0x31, 0x39, 0x62, 0x66, 0x61, 0x61, 0x33, 0x66, 0x65, 0x65, 0x64, 0x36, 0x30, 0x63, 0x64, 0x32, 0x61, 0x65, 0x33, 0x62, 0x64, 0x62, 0x62, 0x63, 0x35, 0x35, 0x62, 0x31, 0x65, 0x64, 0x30, 0x31, 0x66, 0x36, 0x32, 0x35, 0x39, 0x31, 0x61, 0x64, 0x33, 0x31, 0x63, 0x32, 0x38, 0x66, 0x39, 0x39, 0x64, 0x37, 0x32, 0x61, 0x63, 0x66, 0x31, 0x63, 0x33, 0x31, 0x33, 0x63, 0x38, 0x61, 0x31, 0x31, 0x39, 0x31, 0x38, 0x39, 0x64, 0x30, 0x37, 0x35, 0x31, 0x33, 0x65, 0x38, 0x65, 0x38, 0x38, 0x65, 0x32, 0x64, 0x64, 0x30, 0x35, 0x34, 0x33, 0x30, 0x63, 0x31, 0x39, 0x37, 0x38, 0x65, 0x65, 0x61, 0x35, 0x62, 0x62, 0x63, 0x64, 0x36, 0x35, 0x37, 0x32, 0x32, 0x61, 0x38, 0x61, 0x61, 0x32, 0x30, 0x32, 0x37, 0x32, 0x35, 0x34, 0x64, 0x36, 0x31, 0x61, 0x38, 0x39, 0x64, 0x62, 0x30, 0x66, 0x66, 0x33, 0x37, 0x35, 0x36, 0x36, 0x66, 0x37, 0x61, 0x31, 0x37, 0x65, 0x66, 0x30, 0x38, 0x39, 0x31, 0x34, 0x65, 0x61, 0x36, 0x62, 0x62, 0x36, 0x36, 0x34, 0x34, 0x36, 0x37, 0x62, 0x31, 0x36, 0x36, 0x61, 0x35, 0x36, 0x34, 0x35, 0x36, 0x63, 0x35, 0x34, 0x32, 0x30, 0x34, 0x61, 0x65, 0x66, 0x34, 0x62, 0x37, 0x32, 0x62, 0x33, 0x37, 0x39, 0x34, 0x37, 0x37, 0x33, 0x37, 0x35, 0x34, 0x30, 0x34, 0x65, 0x39, 0x32, 0x65, 0x62, 0x36, 0x62, 0x37, 0x66, 0x61, 0x31, 0x31, 0x32, 0x66, 0x39, 0x64, 0x36, 0x31, 0x30, 0x66, 0x61, 0x39, 0x61, 0x65, 0x35, 0x35, 0x64, 0x38, 0x33, 0x65, 0x64, 0x63, 0x66, 0x38, 0x39, 0x64, 0x38, 0x30, 0x35, 0x66, 0x65, 0x30, 0x35, 0x32, 0x39, 0x35, 0x64, 0x30, 0x32, 0x30, 0x30, 0x64, 0x38, 0x62, 0x36, 0x66, 0x61, 0x66, 0x32, 0x32, 0x35, 0x66, 0x66, 0x61, 0x62, 0x35, 0x63, 0x66, 0x35, 0x34, 0x34, 0x37, 0x63, 0x39, 0x61, 0x32, 0x34, 0x62, 0x61, 0x66, 0x33, 0x33, 0x32, 0x37, 0x66, 0x36, 0x33, 0x34, 0x37, 0x62, 0x34, 0x66, 0x37, 0x37, 0x38, 0x62, 0x63, 0x32, 0x38, 0x66, 0x38, 0x62, 0x32, 0x61, 0x37, 0x66, 0x37, 0x36, 0x33, 0x34, 0x31, 0x39, 0x31, 0x35, 0x66, 0x62, 0x37, 0x33, 0x65, 0x36, 0x38, 0x61, 0x63, 0x35, 0x63, 0x66, 0x63, 0x63, 0x65, 0x63, 0x30, 0x63, 0x65, 0x31, 0x30, 0x66, 0x64, 0x65, 0x38, 0x34, 0x34, 0x65, 0x30, 0x34, 0x38, 0x33, 0x66, 0x33, 0x37, 0x61, 0x33, 0x63, 0x66, 0x65, 0x38, 0x31, 0x35, 0x35, 0x30, 0x36, 0x63, 0x33, 0x33, 0x66, 0x65, 0x34, 0x34, 0x63, 0x66, 0x61, 0x65, 0x63, 0x31, 0x62, 0x34, 0x30, 0x64, 0x37, 0x32, 0x33, 0x39, 0x38, 0x65, 0x39, 0x62, 0x35, 0x30, 0x31, 0x64, 0x35, 0x31, 0x62, 0x30, 0x61, 0x65, 0x37, 0x63, 0x64, 0x63, 0x30, 0x65, 0x63, 0x61, 0x35, 0x30, 0x37, 0x34, 0x64, 0x38, 0x37, 0x37, 0x39, 0x35, 0x61, 0x30, 0x33, 0x30, 0x61, 0x37, 0x35, 0x33, 0x37, 0x62, 0x62, 0x32, 0x30, 0x65, 0x36, 0x34, 0x61, 0x62, 0x66, 0x62, 0x31, 0x38, 0x33, 0x36, 0x37, 0x35, 0x31, 0x39, 0x37, 0x32, 0x65, 0x66, 0x35, 0x36, 0x34, 0x32, 0x39, 0x30, 0x38, 0x63, 0x33, 0x66, 0x63, 0x65, 0x35, 0x66, 0x37, 0x32, 0x30, 0x39, 0x33, 0x35, 0x39, 0x61, 0x33, 0x37, 0x63, 0x30, 0x39, 0x33, 0x65, 0x64, 0x65, 0x63, 0x31, 0x62, 0x62, 0x63, 0x31, 0x61, 0x38, 0x63, 0x39, 0x34, 0x32, 0x62, 0x35, 0x34, 0x63, 0x38, 0x66, 0x37, 0x39, 0x36, 0x63, 0x37, 0x30, 0x62, 0x66, 0x39, 0x64, 0x39, 0x37, 0x32, 0x39, 0x30, 0x61, 0x63, 0x35, 0x34, 0x32, 0x33, 0x39, 0x66, 0x62, 0x33, 0x39, 0x65, 0x32, 0x34, 0x66, 0x39, 0x63, 0x65, 0x32, 0x66, 0x30, 0x64, 0x31, 0x32, 0x64, 0x39, 0x66, 0x36, 0x66, 0x61, 0x38, 0x37, 0x66, 0x64, 0x63, 0x64, 0x35, 0x66, 0x31, 0x62, 0x66, 0x31, 0x36, 0x35, 0x32, 0x62, 0x63, 0x31, 0x31, 0x63, 0x30, 0x63, 0x64, 0x62, 0x61, 0x62, 0x33, 0x30, 0x36, 0x39, 0x35, 0x35, 0x33, 0x38, 0x64, 0x37, 0x31, 0x66, 0x64, 0x37, 0x38, 0x34, 0x66, 0x39, 0x30, 0x65, 0x36, 0x30, 0x66, 0x39, 0x61, 0x39, 0x30, 0x65, 0x66, 0x37, 0x63, 0x64, 0x30, 0x32, 0x61, 0x37, 0x61, 0x37, 0x36, 0x32, 0x30, 0x33, 0x38, 0x32, 0x32, 0x37, 0x37, 0x31, 0x63, 0x61, 0x34, 0x61, 0x30, 0x38, 0x37, 0x64, 0x36, 0x62, 0x63, 0x38, 0x31, 0x38, 0x39, 0x37, 0x65, 0x37, 0x30, 0x32, 0x37, 0x32, 0x64, 0x39, 0x36, 0x64, 0x33, 0x64, 0x64, 0x38, 0x30, 0x30, 0x36, 0x65, 0x63, 0x66, 0x33, 0x36, 0x63, 0x65, 0x33, 0x66, 0x65, 0x32, 0x35, 0x35, 0x63, 0x33, 0x39, 0x62, 0x36, 0x30, 0x66, 0x37, 0x36, 0x64, 0x31, 0x33, 0x33, 0x31, 0x36, 0x66, 0x61, 0x37, 0x64, 0x62, 0x62, 0x33, 0x33, 0x61, 0x33, 0x65, 0x39, 0x39, 0x33, 0x33, 0x39, 0x35, 0x39, 0x34, 0x33, 0x35, 0x38, 0x63, 0x37, 0x32, 0x66, 0x33, 0x65, 0x31, 0x34, 0x35, 0x61, 0x31, 0x34, 0x64, 0x37, 0x66, 0x30, 0x35, 0x61, 0x35, 0x36, 0x65, 0x31, 0x34, 0x32, 0x33, 0x30, 0x64, 0x37, 0x37, 0x36, 0x31, 0x38, 0x33, 0x33, 0x35, 0x62, 0x33, 0x32, 0x34, 0x36, 0x66, 0x38, 0x39, 0x66, 0x35, 0x38, 0x63, 0x33, 0x65, 0x39, 0x30, 0x64, 0x33, 0x39, 0x64, 0x62, 0x65, 0x64, 0x63, 0x66, 0x65, 0x34, 0x39, 0x32, 0x36, 0x37, 0x32, 0x65, 0x65, 0x31, 0x32, 0x31, 0x34, 0x38, 0x61, 0x30, 0x39, 0x65, 0x61, 0x63, 0x39, 0x61, 0x63, 0x33, 0x61, 0x61, 0x66, 0x36, 0x37, 0x30, 0x65, 0x32, 0x63, 0x36, 0x37, 0x36, 0x34, 0x35, 0x37, 0x31, 0x32, 0x37, 0x32, 0x34, 0x35, 0x35, 0x30, 0x61, 0x64, 0x65, 0x37, 0x37, 0x64, 0x62, 0x39, 0x61, 0x32, 0x30, 0x39, 0x34, 0x62, 0x61, 0x38, 0x64, 0x30, 0x61, 0x65, 0x62, 0x30, 0x37, 0x32, 0x61, 0x32, 0x38, 0x61, 0x35, 0x38, 0x61, 0x38, 0x35, 0x34, 0x30, 0x39, 0x65, 0x32, 0x66, 0x36, 0x62, 0x39, 0x63, 0x37, 0x38, 0x33, 0x35, 0x37, 0x65, 0x33, 0x32, 0x64, 0x39, 0x62, 0x33, 0x33, 0x33, 0x34, 0x37, 0x39, 0x31, 0x35, 0x63, 0x65, 0x33, 0x30, 0x39, 0x34, 0x63, 0x63, 0x35, 0x30, 0x37, 0x30, 0x39, 0x61, 0x66, 0x39, 0x32, 0x65, 0x65, 0x37, 0x32, 0x38, 0x38, 0x38, 0x37, 0x32, 0x66, 0x65, 0x39, 0x32, 0x66, 0x62, 0x63, 0x63, 0x62, 0x35, 0x37, 0x31, 0x66, 0x34, 0x36, 0x32, 0x36, 0x33, 0x63, 0x66, 0x61, 0x61, 0x36, 0x65, 0x64, 0x37, 0x65, 0x33, 0x37, 0x65, 0x33, 0x34, 0x66, 0x37, 0x38, 0x34, 0x36, 0x34, 0x36, 0x36, 0x39, 0x62, 0x31, 0x36, 0x66, 0x37, 0x63, 0x61, 0x37, 0x33, 0x66, 0x39, 0x39, 0x36, 0x33, 0x31, 0x33, 0x32, 0x66, 0x34, 0x33, 0x38, 0x32, 0x61, 0x38, 0x61, 0x63, 0x34, 0x35, 0x64, 0x30, 0x32, 0x63, 0x31, 0x37, 0x66, 0x37, 0x33, 0x34, 0x62, 0x34, 0x64, 0x65, 0x64, 0x61, 0x66, 0x36, 0x61, 0x35, 0x33, 0x35, 0x66, 0x64, 0x34, 0x62, 0x34, 0x39, 0x38, 0x30, 0x31, 0x61, 0x35, 0x61, 0x34, 0x61, 0x37, 0x65, 0x35, 0x38, 0x30, 0x64, 0x30, 0x36, 0x61, 0x64, 0x33, 0x63, 0x61, 0x63, 0x37, 0x64, 0x36, 0x32, 0x62, 0x30, 0x35, 0x34, 0x30, 0x61, 0x34, 0x64, 0x62, 0x37, 0x32, 0x66, 0x32, 0x32, 0x63, 0x37, 0x33, 0x62, 0x34, 0x62, 0x35, 0x38, 0x61, 0x34, 0x61, 0x36, 0x61, 0x31, 0x30, 0x32, 0x61, 0x34, 0x66, 0x63, 0x39, 0x37, 0x38, 0x34, 0x64, 0x39, 0x39, 0x62, 0x31, 0x32, 0x33, 0x31, 0x62, 0x35, 0x31, 0x64, 0x39, 0x63, 0x31, 0x62, 0x65, 0x38, 0x38, 0x30, 0x62, 0x39, 0x39, 0x34, 0x31, 0x34, 0x32, 0x66, 0x65, 0x37, 0x32, 0x35, 0x31, 0x32, 0x32, 0x38, 0x63, 0x63, 0x32, 0x30, 0x31, 0x30, 0x32, 0x62, 0x38, 0x61, 0x35, 0x34, 0x63, 0x63, 0x39, 0x65, 0x31, 0x61, 0x65, 0x33, 0x33, 0x65, 0x38, 0x64, 0x32, 0x31, 0x64, 0x36, 0x35, 0x35, 0x35, 0x63, 0x64, 0x35, 0x62, 0x35, 0x61, 0x62, 0x39, 0x36, 0x30, 0x63, 0x37, 0x33, 0x34, 0x36, 0x65, 0x62, 0x33, 0x33, 0x61, 0x65, 0x37, 0x36, 0x38, 0x63, 0x30, 0x37, 0x32, 0x39, 0x34, 0x32, 0x37, 0x36, 0x36, 0x36, 0x61, 0x33, 0x36, 0x34, 0x34, 0x63, 0x35, 0x30, 0x32, 0x38, 0x31, 0x31, 0x32, 0x62, 0x30, 0x66, 0x32, 0x64, 0x30, 0x66, 0x63, 0x66, 0x65, 0x34, 0x31, 0x38, 0x35, 0x66, 0x63, 0x66, 0x38, 0x37, 0x33, 0x64, 0x66, 0x64, 0x65, 0x33, 0x61, 0x61, 0x33, 0x61, 0x39, 0x62, 0x36, 0x34, 0x63, 0x62, 0x33, 0x36, 0x64, 0x32, 0x37, 0x64, 0x66, 0x37, 0x32, 0x62, 0x30, 0x32, 0x37, 0x61, 0x62, 0x37, 0x34, 0x34, 0x65, 0x62, 0x31, 0x34, 0x38, 0x66, 0x61, 0x32, 0x34, 0x63, 0x66, 0x62, 0x64, 0x36, 0x62, 0x63, 0x34, 0x33, 0x62, 0x38, 0x62, 0x30, 0x38, 0x66, 0x65, 0x61, 0x66, 0x32, 0x38, 0x39, 0x32, 0x31, 0x34, 0x36, 0x30, 0x33, 0x66, 0x38, 0x35, 0x65, 0x30, 0x36, 0x61, 0x30, 0x66, 0x33, 0x61, 0x65, 0x61, 0x65, 0x39, 0x32, 0x33, 0x37, 0x32, 0x35, 0x31, 0x39, 0x63, 0x37, 0x38, 0x32, 0x37, 0x34, 0x65, 0x62, 0x33, 0x39, 0x33, 0x63, 0x36, 0x39, 0x34, 0x65, 0x32, 0x32, 0x32, 0x39, 0x34, 0x32, 0x63, 0x34, 0x38, 0x32, 0x31, 0x38, 0x32, 0x63, 0x31, 0x39, 0x65, 0x32, 0x35, 0x37, 0x66, 0x62, 0x30, 0x62, 0x61, 0x32, 0x39, 0x34, 0x30, 0x62, 0x38, 0x37, 0x30, 0x34, 0x31, 0x64, 0x36, 0x34, 0x64, 0x30, 0x65, 0x65, 0x63, 0x34, 0x65, 0x30, 0x34, 0x64, 0x63, 0x33, 0x33, 0x32, 0x34, 0x36, 0x65, 0x62, 0x36, 0x61, 0x65, 0x33, 0x61, 0x36, 0x32, 0x61, 0x66, 0x61, 0x38, 0x66, 0x62, 0x62, 0x32, 0x32, 0x66, 0x32, 0x65, 0x61, 0x34, 0x65, 0x37, 0x33, 0x34, 0x36, 0x31, 0x36, 0x63, 0x62, 0x35, 0x62, 0x62, 0x63, 0x66, 0x64, 0x33, 0x62, 0x38, 0x31, 0x37, 0x61, 0x31, 0x37, 0x32, 0x63, 0x62, 0x34, 0x30, 0x31, 0x63, 0x37, 0x32, 0x61, 0x38, 0x63, 0x33, 0x64, 0x39, 0x33, 0x65, 0x31, 0x61, 0x31, 0x35, 0x65, 0x66, 0x64, 0x38, 0x61, 0x36, 0x62, 0x36, 0x39, 0x30, 0x33, 0x36, 0x32, 0x36, 0x62, 0x34, 0x62, 0x33, 0x65, 0x61, 0x65, 0x32, 0x64, 0x64, 0x61, 0x66, 0x63, 0x36, 0x34, 0x32, 0x35, 0x63, 0x63, 0x31, 0x64, 0x31, 0x34, 0x62, 0x64, 0x34, 0x31, 0x65, 0x33, 0x30, 0x65, 0x65, 0x63, 0x64, 0x37, 0x36, 0x37, 0x32, 0x30, 0x38, 0x36, 0x61, 0x37, 0x66, 0x38, 0x62, 0x66, 0x39, 0x35, 0x64, 0x63, 0x39, 0x64, 0x34, 0x63, 0x39, 0x37, 0x30, 0x65, 0x62, 0x36, 0x62, 0x31, 0x66, 0x32, 0x30, 0x66, 0x66, 0x36, 0x34, 0x30, 0x32, 0x37, 0x34, 0x33, 0x35, 0x63, 0x63, 0x31, 0x39, 0x66, 0x33, 0x61, 0x30, 0x37, 0x36, 0x34, 0x65, 0x39, 0x35, 0x38, 0x63, 0x34, 0x63, 0x34, 0x34, 0x65, 0x36, 0x63, 0x64, 0x34, 0x66, 0x61, 0x36, 0x37, 0x30, 0x32, 0x36, 0x66, 0x62, 0x39, 0x33, 0x37, 0x62, 0x66, 0x30, 0x62, 0x32, 0x63, 0x61, 0x32, 0x33, 0x39, 0x37, 0x37, 0x32, 0x65, 0x63, 0x35, 0x32, 0x33, 0x35, 0x65, 0x63, 0x63, 0x36, 0x38, 0x39, 0x31, 0x65, 0x30, 0x39, 0x33, 0x61, 0x31, 0x31, 0x36, 0x37, 0x33, 0x36, 0x35, 0x38, 0x38, 0x30, 0x37, 0x33, 0x61, 0x62, 0x38, 0x62, 0x31, 0x32, 0x63, 0x33, 0x37, 0x32, 0x37, 0x30, 0x36, 0x37, 0x66, 0x32, 0x36, 0x66, 0x61, 0x36, 0x33, 0x64, 0x39, 0x63, 0x30, 0x33, 0x64, 0x63, 0x38, 0x36, 0x32, 0x63, 0x30, 0x61, 0x65, 0x65, 0x66, 0x37, 0x36, 0x62, 0x64, 0x66, 0x32, 0x61, 0x61, 0x31, 0x39, 0x36, 0x64, 0x30, 0x35, 0x64, 0x61, 0x37, 0x35, 0x62, 0x36, 0x37, 0x62, 0x34, 0x66, 0x62, 0x61, 0x62, 0x37, 0x64, 0x34, 0x38, 0x35, 0x35, 0x66, 0x39, 0x37, 0x32, 0x62, 0x66, 0x39, 0x63, 0x38, 0x33, 0x33, 0x62, 0x31, 0x64, 0x30, 0x38, 0x61, 0x63, 0x63, 0x62, 0x61, 0x34, 0x65, 0x62, 0x33, 0x63, 0x30, 0x38, 0x36, 0x33, 0x38, 0x30, 0x34, 0x63, 0x31, 0x62, 0x33, 0x38, 0x63, 0x34, 0x32, 0x33, 0x61, 0x66, 0x35, 0x35, 0x31, 0x62, 0x66, 0x35, 0x66, 0x32, 0x39, 0x37, 0x37, 0x32, 0x30, 0x34, 0x32, 0x31, 0x35, 0x65, 0x61, 0x36, 0x36, 0x30, 0x35, 0x36, 0x37, 0x61, 0x34, 0x35, 0x66, 0x62, 0x30, 0x35, 0x61, 0x37, 0x66, 0x38, 0x36, 0x32, 0x39, 0x38, 0x65, 0x61, 0x30, 0x35, 0x32, 0x64, 0x65, 0x37, 0x36, 0x62, 0x36, 0x34, 0x65, 0x32, 0x31, 0x66, 0x65, 0x30, 0x34, 0x66, 0x61, 0x61, 0x30, 0x30, 0x31, 0x35, 0x61, 0x39, 0x30, 0x35, 0x63, 0x37, 0x31, 0x35, 0x35, 0x31, 0x35, 0x34, 0x37, 0x33, 0x31, 0x62, 0x32, 0x66, 0x62, 0x34, 0x37, 0x32, 0x30, 0x30, 0x38, 0x36, 0x37, 0x31, 0x65, 0x31, 0x34, 0x65, 0x61, 0x65, 0x34, 0x37, 0x63, 0x32, 0x31, 0x62, 0x31, 0x36, 0x65, 0x35, 0x62, 0x34, 0x30, 0x66, 0x39, 0x31, 0x66, 0x31, 0x37, 0x30, 0x34, 0x62, 0x66, 0x66, 0x38, 0x30, 0x38, 0x38, 0x66, 0x36, 0x32, 0x62, 0x35, 0x62, 0x63, 0x61, 0x32, 0x32, 0x62, 0x30, 0x33, 0x30, 0x62, 0x62, 0x31, 0x66, 0x61, 0x62, 0x36, 0x31, 0x37, 0x32, 0x37, 0x62, 0x38, 0x61, 0x39, 0x61, 0x37, 0x38, 0x35, 0x36, 0x36, 0x64, 0x38, 0x31, 0x38, 0x38, 0x31, 0x32, 0x37, 0x31, 0x37, 0x66, 0x66, 0x31, 0x32, 0x33, 0x62, 0x65, 0x39, 0x63, 0x34, 0x64, 0x64, 0x36, 0x39, 0x33, 0x66, 0x66, 0x61, 0x31, 0x61, 0x36, 0x66, 0x30, 0x35, 0x36, 0x65, 0x32, 0x36, 0x61, 0x62, 0x32, 0x37, 0x31, 0x61, 0x66, 0x39, 0x61, 0x38, 0x65, 0x62, 0x65, 0x37, 0x32, 0x64, 0x61, 0x63, 0x62, 0x38, 0x65, 0x30, 0x39, 0x35, 0x63, 0x64, 0x66, 0x65, 0x32, 0x61, 0x35, 0x62, 0x31, 0x66, 0x63, 0x31, 0x34, 0x65, 0x62, 0x30, 0x31, 0x39, 0x33, 0x35, 0x63, 0x37, 0x32, 0x61, 0x62, 0x37, 0x61, 0x37, 0x64, 0x30, 0x65, 0x65, 0x66, 0x32, 0x32, 0x36, 0x36, 0x37, 0x65, 0x34, 0x33, 0x34, 0x34, 0x62, 0x31, 0x31, 0x62, 0x34, 0x36, 0x61, 0x61, 0x33, 0x64, 0x37, 0x32, 0x31, 0x66, 0x34, 0x65, 0x36, 0x66, 0x35, 0x39, 0x61, 0x63, 0x39, 0x39, 0x62, 0x30, 0x33, 0x37, 0x39, 0x39, 0x62, 0x35, 0x63, 0x31, 0x61, 0x39, 0x65, 0x31, 0x36, 0x34, 0x64, 0x32, 0x34, 0x64, 0x32, 0x32, 0x36, 0x66, 0x30, 0x33, 0x34, 0x32, 0x38, 0x64, 0x39, 0x39, 0x63, 0x34, 0x33, 0x63, 0x34, 0x65, 0x34, 0x64, 0x32, 0x37, 0x37, 0x39, 0x34, 0x36, 0x61, 0x34, 0x63, 0x35, 0x31, 0x35, 0x64, 0x31, 0x36, 0x30, 0x61, 0x30, 0x32, 0x32, 0x65, 0x64, 0x36, 0x36, 0x62, 0x63, 0x64, 0x37, 0x39, 0x32, 0x38, 0x34, 0x64, 0x35, 0x62, 0x62, 0x30, 0x36, 0x66, 0x62, 0x36, 0x35, 0x66, 0x32, 0x65, 0x32, 0x62, 0x32, 0x64, 0x66, 0x31, 0x31, 0x61, 0x66, 0x37, 0x65, 0x62, 0x62, 0x37, 0x37, 0x65, 0x38, 0x32, 0x65, 0x37, 0x32, 0x36, 0x66, 0x63, 0x36, 0x34, 0x30, 0x35, 0x33, 0x34, 0x32, 0x35, 0x30, 0x66, 0x62, 0x33, 0x37, 0x62, 0x63, 0x61, 0x31, 0x62, 0x30, 0x64, 0x65, 0x36, 0x34, 0x30, 0x31, 0x63, 0x38, 0x39, 0x31, 0x39, 0x65, 0x64, 0x34, 0x35, 0x33, 0x36, 0x34, 0x64, 0x66, 0x64, 0x30, 0x61, 0x37, 0x31, 0x32, 0x66, 0x61, 0x66, 0x64, 0x61, 0x65, 0x36, 0x35, 0x38, 0x36, 0x36, 0x66, 0x66, 0x37, 0x33, 0x37, 0x64, 0x36, 0x63, 0x30, 0x36, 0x61, 0x65, 0x39, 0x36, 0x39, 0x34, 0x32, 0x31, 0x63, 0x30, 0x30, 0x38, 0x36, 0x61, 0x34, 0x31, 0x61, 0x34, 0x35, 0x39, 0x63, 0x34, 0x35, 0x66, 0x64, 0x36, 0x37, 0x34, 0x30, 0x36, 0x65, 0x30, 0x34, 0x36, 0x66, 0x65, 0x36, 0x33, 0x65, 0x66, 0x66, 0x63, 0x65, 0x33, 0x64, 0x36, 0x62, 0x36, 0x30, 0x35, 0x39, 0x30, 0x38, 0x38, 0x64, 0x31, 0x38, 0x65, 0x37, 0x61, 0x36, 0x32, 0x36, 0x65, 0x63, 0x33, 0x39, 0x37, 0x32, 0x64, 0x63, 0x64, 0x62, 0x35, 0x35, 0x62, 0x64, 0x39, 0x31, 0x36, 0x63, 0x62, 0x66, 0x63, 0x63, 0x66, 0x34, 0x38, 0x37, 0x33, 0x32, 0x38, 0x65, 0x36, 0x61, 0x62, 0x62, 0x37, 0x32, 0x34, 0x63, 0x64, 0x33, 0x36, 0x39, 0x61, 0x65, 0x34, 0x30, 0x39, 0x61, 0x64, 0x64, 0x62, 0x39, 0x38, 0x62, 0x32, 0x38, 0x61, 0x31, 0x37, 0x38, 0x36, 0x62, 0x63, 0x37, 0x37, 0x65, 0x39, 0x37, 0x31, 0x37, 0x30, 0x38, 0x63, 0x37, 0x39, 0x38, 0x36, 0x63, 0x63, 0x35, 0x66, 0x61, 0x66, 0x63, 0x37, 0x30, 0x39, 0x30, 0x39, 0x37, 0x32, 0x64, 0x30, 0x37, 0x30, 0x62, 0x64, 0x66, 0x62, 0x34, 0x62, 0x65, 0x33, 0x66, 0x31, 0x36, 0x30, 0x66, 0x65, 0x62, 0x65, 0x32, 0x36, 0x37, 0x66, 0x37, 0x63, 0x38, 0x34, 0x37, 0x36, 0x38, 0x31, 0x63, 0x39, 0x63, 0x66, 0x61, 0x30, 0x37, 0x30, 0x65, 0x37, 0x32, 0x36, 0x38, 0x61, 0x39, 0x65, 0x38, 0x39, 0x31, 0x34, 0x61, 0x38, 0x38, 0x38, 0x31, 0x35, 0x38, 0x66, 0x33, 0x35, 0x39, 0x39, 0x65, 0x34, 0x33, 0x30, 0x64, 0x61, 0x65, 0x65, 0x37, 0x30, 0x34, 0x64, 0x66, 0x62, 0x65, 0x36, 0x61, 0x65, 0x30, 0x30, 0x61, 0x33, 0x62, 0x31, 0x34, 0x35, 0x30, 0x62, 0x39, 0x32, 0x64, 0x61, 0x38, 0x62, 0x34, 0x31, 0x38, 0x65, 0x30, 0x39, 0x35, 0x31, 0x35, 0x66, 0x61, 0x65, 0x37, 0x35, 0x30, 0x32, 0x64, 0x33, 0x36, 0x34, 0x62, 0x64, 0x66, 0x33, 0x34, 0x33, 0x38, 0x39, 0x30, 0x36, 0x32, 0x38, 0x36, 0x38, 0x36, 0x64, 0x30, 0x62, 0x63, 0x64, 0x64, 0x31, 0x37, 0x63, 0x65, 0x35, 0x37, 0x37, 0x64, 0x64, 0x62, 0x61, 0x33, 0x63, 0x39, 0x31, 0x39, 0x38, 0x34, 0x66, 0x31, 0x65, 0x37, 0x62, 0x64, 0x39, 0x38, 0x64, 0x34, 0x65, 0x66, 0x37, 0x32, 0x39, 0x36, 0x36, 0x34, 0x37, 0x31, 0x32, 0x38, 0x30, 0x64, 0x39, 0x66, 0x37, 0x37, 0x64, 0x36, 0x36, 0x35, 0x38, 0x36, 0x32, 0x37, 0x30, 0x33, 0x30, 0x37, 0x38, 0x32, 0x36, 0x38, 0x34, 0x65, 0x32, 0x37, 0x66, 0x38, 0x36, 0x66, 0x62, 0x31, 0x36, 0x62, 0x30, 0x63, 0x63, 0x65, 0x34, 0x36, 0x31, 0x31, 0x61, 0x34, 0x35, 0x36, 0x37, 0x65, 0x34, 0x33, 0x30, 0x39, 0x35, 0x62, 0x34, 0x31, 0x36, 0x37, 0x33, 0x65, 0x30, 0x64, 0x30, 0x35, 0x62, 0x64, 0x62, 0x62, 0x66, 0x33, 0x33, 0x62, 0x62, 0x33, 0x35, 0x61, 0x31, 0x65, 0x37, 0x34, 0x32, 0x64, 0x65, 0x66, 0x65, 0x31, 0x39, 0x33, 0x32, 0x66, 0x65, 0x65, 0x64, 0x61, 0x31, 0x30, 0x34, 0x32, 0x66, 0x61, 0x34, 0x62, 0x64, 0x36, 0x30, 0x38, 0x36, 0x64, 0x32, 0x62, 0x62, 0x34, 0x34, 0x37, 0x36, 0x37, 0x33, 0x65, 0x33, 0x64, 0x32, 0x31, 0x33, 0x34, 0x66, 0x61, 0x33, 0x32, 0x38, 0x65, 0x65, 0x35, 0x30, 0x36, 0x30, 0x38, 0x64, 0x35, 0x34, 0x33, 0x39, 0x66, 0x36, 0x35, 0x37, 0x66, 0x66, 0x30, 0x34, 0x35, 0x63, 0x39, 0x33, 0x64, 0x33, 0x30, 0x34, 0x37, 0x34, 0x61, 0x36, 0x31, 0x66, 0x33, 0x64, 0x34, 0x32, 0x32, 0x61, 0x36, 0x38, 0x34, 0x61, 0x37, 0x31, 0x64, 0x34, 0x61, 0x31, 0x65, 0x66, 0x30, 0x37, 0x32, 0x37, 0x62, 0x32, 0x34, 0x32, 0x31, 0x33, 0x61, 0x35, 0x66, 0x31, 0x38, 0x31, 0x64, 0x37, 0x35, 0x64, 0x63, 0x65, 0x32, 0x62, 0x31, 0x30, 0x33, 0x32, 0x30, 0x38, 0x66, 0x37, 0x63, 0x62, 0x36, 0x61, 0x37, 0x64, 0x62, 0x66, 0x33, 0x38, 0x62, 0x37, 0x64, 0x61, 0x65, 0x63, 0x65, 0x63, 0x35, 0x33, 0x34, 0x64, 0x31, 0x39, 0x35, 0x62, 0x34, 0x38, 0x34, 0x66, 0x35, 0x65, 0x36, 0x31, 0x38, 0x34, 0x37, 0x63, 0x61, 0x62, 0x64, 0x62, 0x39, 0x63, 0x36, 0x61, 0x32, 0x65, 0x33, 0x31, 0x32, 0x37, 0x64, 0x38, 0x64, 0x31, 0x65, 0x30, 0x31, 0x64, 0x30, 0x30, 0x62, 0x34, 0x32, 0x65, 0x31, 0x30, 0x66, 0x34, 0x32, 0x32, 0x34, 0x32, 0x64, 0x38, 0x66, 0x65, 0x64, 0x62, 0x33, 0x65, 0x38, 0x30, 0x61, 0x61, 0x64, 0x33, 0x64, 0x36, 0x35, 0x32, 0x39, 0x34, 0x38, 0x36, 0x39, 0x34, 0x32, 0x36, 0x37, 0x34, 0x36, 0x38, 0x62, 0x30, 0x64, 0x39, 0x65, 0x38, 0x35, 0x36, 0x31, 0x38, 0x36, 0x32, 0x63, 0x63, 0x33, 0x33, 0x35, 0x65, 0x37, 0x37, 0x38, 0x38, 0x38, 0x35, 0x64, 0x36, 0x35, 0x31, 0x37, 0x31, 0x36, 0x64, 0x65, 0x32, 0x64, 0x39, 0x34, 0x33, 0x36, 0x63, 0x38, 0x33, 0x65, 0x36, 0x36, 0x64, 0x33, 0x31, 0x39, 0x64, 0x30, 0x38, 0x62, 0x66, 0x63, 0x35, 0x30, 0x30, 0x31, 0x39, 0x32, 0x31, 0x36, 0x39, 0x61, 0x34, 0x37, 0x66, 0x38, 0x32, 0x61, 0x30, 0x31, 0x34, 0x35, 0x37, 0x32, 0x36, 0x30, 0x66, 0x62, 0x31, 0x38, 0x37, 0x35, 0x38, 0x65, 0x61, 0x63, 0x61, 0x63, 0x63, 0x64, 0x62, 0x35, 0x62, 0x61, 0x37, 0x35, 0x63, 0x33, 0x35, 0x34, 0x34, 0x31, 0x63, 0x62, 0x64, 0x35, 0x39, 0x39, 0x30, 0x62, 0x64, 0x64, 0x63, 0x33, 0x63, 0x61, 0x39, 0x32, 0x35, 0x36, 0x33, 0x63, 0x37, 0x63, 0x34, 0x36, 0x31, 0x63, 0x32, 0x65, 0x66, 0x63, 0x33, 0x37, 0x39, 0x61, 0x37, 0x39, 0x34, 0x35, 0x35, 0x34, 0x32, 0x30, 0x62, 0x34, 0x38, 0x32, 0x61, 0x39, 0x62, 0x36, 0x61, 0x61, 0x33, 0x35, 0x35, 0x66, 0x32, 0x35, 0x30, 0x31, 0x31, 0x34, 0x65, 0x66, 0x32, 0x33, 0x61, 0x63, 0x65, 0x38, 0x62, 0x32, 0x61, 0x33, 0x61, 0x66, 0x62, 0x66, 0x61, 0x35, 0x37, 0x32, 0x31, 0x30, 0x31, 0x35, 0x37, 0x64, 0x64, 0x38, 0x36, 0x66, 0x33, 0x32, 0x65, 0x64, 0x37, 0x32, 0x31, 0x30, 0x66, 0x32, 0x37, 0x35, 0x33, 0x64, 0x37, 0x65, 0x63, 0x30, 0x63, 0x37, 0x31, 0x30, 0x30, 0x39, 0x39, 0x31, 0x64, 0x61, 0x32, 0x37, 0x33, 0x34, 0x33, 0x66, 0x31, 0x62, 0x38, 0x36, 0x63, 0x33, 0x32, 0x34, 0x32, 0x36, 0x33, 0x33, 0x30, 0x66, 0x64, 0x62, 0x39, 0x63, 0x34, 0x31, 0x33, 0x31, 0x65, 0x66, 0x33, 0x63, 0x31, 0x39, 0x31, 0x35, 0x63, 0x65, 0x63, 0x39, 0x33, 0x32, 0x39, 0x66, 0x30, 0x63, 0x63, 0x35, 0x63, 0x62, 0x39, 0x31, 0x33, 0x32, 0x64, 0x30, 0x32, 0x64, 0x63, 0x32, 0x62, 0x32, 0x34, 0x31, 0x63, 0x62, 0x35, 0x63, 0x34, 0x36, 0x64, 0x39, 0x37, 0x34, 0x63, 0x63, 0x34, 0x34, 0x35, 0x32, 0x66, 0x35, 0x61, 0x32, 0x61, 0x36, 0x63, 0x32, 0x31, 0x32, 0x65, 0x31, 0x64, 0x66, 0x39, 0x37, 0x30, 0x33, 0x65, 0x63, 0x63, 0x33, 0x34, 0x33, 0x38, 0x37, 0x32, 0x36, 0x65, 0x36, 0x37, 0x62, 0x36, 0x39, 0x32, 0x62, 0x38, 0x36, 0x33, 0x63, 0x63, 0x66, 0x36, 0x62, 0x39, 0x66, 0x61, 0x62, 0x65, 0x62, 0x62, 0x31, 0x30, 0x64, 0x62, 0x61, 0x63, 0x34, 0x31, 0x33, 0x30, 0x35, 0x64, 0x64, 0x64, 0x66, 0x30, 0x30, 0x34, 0x33, 0x34, 0x35, 0x37, 0x32, 0x66, 0x34, 0x61, 0x66, 0x36, 0x64, 0x35, 0x66, 0x63, 0x30, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x38, 0x34, 0x39, 0x66, 0x31, 0x36, 0x61, 0x61, 0x62, 0x66, 0x66, 0x63, 0x38, 0x63, 0x33, 0x64, 0x32, 0x61, 0x39, 0x34, 0x30, 0x33, 0x36, 0x65, 0x39, 0x65, 0x64, 0x38, 0x38, 0x63, 0x38, 0x64, 0x61, 0x30, 0x66, 0x33, 0x36, 0x37, 0x62, 0x64, 0x61, 0x32, 0x31, 0x33, 0x31, 0x66, 0x37, 0x32, 0x36, 0x35, 0x32, 0x64, 0x64, 0x62, 0x33, 0x65, 0x37, 0x31, 0x66, 0x63, 0x39, 0x61, 0x64, 0x37, 0x65, 0x61, 0x61, 0x66, 0x65, 0x64, 0x61, 0x30, 0x66, 0x39, 0x63, 0x37, 0x33, 0x37, 0x33, 0x36, 0x66, 0x61, 0x63, 0x63, 0x31, 0x39, 0x30, 0x61, 0x31, 0x66, 0x63, 0x39, 0x62, 0x34, 0x30, 0x65, 0x61, 0x39, 0x65, 0x33, 0x33, 0x65, 0x33, 0x30, 0x33, 0x38, 0x39, 0x64, 0x63, 0x33, 0x37, 0x32, 0x33, 0x32, 0x31, 0x32, 0x37, 0x30, 0x38, 0x64, 0x37, 0x34, 0x36, 0x33, 0x64, 0x30, 0x63, 0x34, 0x34, 0x31, 0x66, 0x65, 0x37, 0x63, 0x31, 0x31, 0x31, 0x64, 0x33, 0x37, 0x30, 0x32, 0x36, 0x34, 0x62, 0x66, 0x37, 0x33, 0x62, 0x37, 0x61, 0x65, 0x37, 0x30, 0x34, 0x39, 0x37, 0x39, 0x31, 0x31, 0x34, 0x31, 0x65, 0x61, 0x32, 0x32, 0x65, 0x33, 0x38, 0x39, 0x34, 0x38, 0x37, 0x32, 0x37, 0x32, 0x33, 0x39, 0x64, 0x37, 0x64, 0x36, 0x63, 0x64, 0x30, 0x34, 0x35, 0x36, 0x62, 0x66, 0x63, 0x63, 0x32, 0x31, 0x33, 0x32, 0x34, 0x61, 0x65, 0x33, 0x33, 0x38, 0x30, 0x66, 0x31, 0x37, 0x35, 0x36, 0x34, 0x31, 0x38, 0x63, 0x37, 0x34, 0x30, 0x63, 0x66, 0x34, 0x35, 0x62, 0x30, 0x61, 0x64, 0x33, 0x66, 0x35, 0x61, 0x33, 0x38, 0x66, 0x33, 0x63, 0x62, 0x61, 0x31, 0x34, 0x34, 0x64, 0x37, 0x32, 0x32, 0x65, 0x33, 0x35, 0x62, 0x63, 0x39, 0x61, 0x32, 0x39, 0x64, 0x38, 0x62, 0x30, 0x30, 0x63, 0x35, 0x64, 0x63, 0x39, 0x64, 0x34, 0x35, 0x65, 0x37, 0x30, 0x66, 0x38, 0x38, 0x64, 0x33, 0x65, 0x33, 0x61, 0x33, 0x37, 0x32, 0x30, 0x39, 0x63, 0x32, 0x62, 0x36, 0x37, 0x66, 0x64, 0x38, 0x62, 0x35, 0x62, 0x39, 0x33, 0x64, 0x30, 0x66, 0x37, 0x63, 0x61, 0x31, 0x34, 0x33, 0x62, 0x34, 0x39, 0x64, 0x33, 0x33, 0x62, 0x31, 0x65, 0x32, 0x33, 0x36, 0x34, 0x35, 0x39, 0x34, 0x37, 0x32, 0x32, 0x30, 0x31, 0x30, 0x35, 0x64, 0x33, 0x33, 0x65, 0x38, 0x64, 0x64, 0x30, 0x38, 0x39, 0x65, 0x39, 0x65, 0x35, 0x65, 0x31, 0x36, 0x61, 0x36, 0x35, 0x37, 0x62, 0x37, 0x33, 0x65, 0x66, 0x38, 0x34, 0x32, 0x62, 0x36, 0x39, 0x37, 0x30, 0x62, 0x33, 0x64, 0x61, 0x30, 0x32, 0x33, 0x63, 0x32, 0x63, 0x62, 0x35, 0x30, 0x35, 0x65, 0x65, 0x38, 0x31, 0x35, 0x35, 0x61, 0x61, 0x30, 0x63, 0x61, 0x65, 0x66, 0x65, 0x30, 0x33, 0x61, 0x64, 0x38, 0x66, 0x33, 0x36, 0x31, 0x30, 0x36, 0x65, 0x31, 0x62, 0x66, 0x36, 0x35, 0x37, 0x63, 0x34, 0x31, 0x35, 0x31, 0x39, 0x38, 0x62, 0x37, 0x34, 0x39, 0x33, 0x39, 0x61, 0x38, 0x65, 0x34, 0x38, 0x39, 0x32, 0x63, 0x61, 0x64, 0x61, 0x32, 0x61, 0x37, 0x32, 0x32, 0x36, 0x61, 0x62, 0x64, 0x65, 0x34, 0x39, 0x36, 0x62, 0x65, 0x66, 0x64, 0x32, 0x37, 0x35, 0x34, 0x64, 0x36, 0x36, 0x65, 0x34, 0x65, 0x34, 0x32, 0x31, 0x33, 0x63, 0x34, 0x62, 0x32, 0x64, 0x39, 0x65, 0x35, 0x34, 0x62, 0x64, 0x38, 0x35, 0x30, 0x36, 0x34, 0x62, 0x38, 0x32, 0x38, 0x62, 0x61, 0x37, 0x64, 0x66, 0x32, 0x36, 0x63, 0x35, 0x38, 0x35, 0x64, 0x37, 0x33, 0x39, 0x31, 0x66, 0x66, 0x31, 0x38, 0x65, 0x33, 0x61, 0x66, 0x35, 0x31, 0x36, 0x30, 0x31, 0x64, 0x61, 0x64, 0x62, 0x33, 0x64, 0x30, 0x30, 0x37, 0x32, 0x30, 0x33, 0x36, 0x64, 0x32, 0x36, 0x63, 0x61, 0x31, 0x31, 0x32, 0x37, 0x36, 0x66, 0x33, 0x65, 0x65, 0x62, 0x30, 0x65, 0x66, 0x66, 0x30, 0x34, 0x63, 0x62, 0x38, 0x62, 0x61, 0x35, 0x64, 0x62, 0x63, 0x34, 0x31, 0x38, 0x33, 0x32, 0x31, 0x39, 0x37, 0x32, 0x64, 0x36, 0x35, 0x32, 0x30, 0x61, 0x38, 0x30, 0x64, 0x66, 0x61, 0x37, 0x63, 0x38, 0x35, 0x36, 0x36, 0x39, 0x39, 0x30, 0x31, 0x30, 0x66, 0x36, 0x35, 0x66, 0x39, 0x37, 0x30, 0x61, 0x39, 0x32, 0x35, 0x38, 0x66, 0x66, 0x62, 0x30, 0x62, 0x30, 0x30, 0x61, 0x34, 0x39, 0x37, 0x33, 0x66, 0x66, 0x36, 0x39, 0x33, 0x66, 0x64, 0x65, 0x32, 0x33, 0x30, 0x30, 0x61, 0x37, 0x32, 0x31, 0x37, 0x30, 0x66, 0x33, 0x63, 0x37, 0x36, 0x39, 0x33, 0x61, 0x39, 0x30, 0x62, 0x38, 0x32, 0x39, 0x34, 0x62, 0x34, 0x34, 0x35, 0x62, 0x39, 0x32, 0x63, 0x39, 0x31, 0x65, 0x65, 0x38, 0x37, 0x61, 0x35, 0x65, 0x39, 0x62, 0x35, 0x37, 0x31, 0x38, 0x39, 0x39, 0x36, 0x63, 0x31, 0x64, 0x64, 0x38, 0x61, 0x64, 0x62, 0x63, 0x33, 0x30, 0x33, 0x33, 0x37, 0x61, 0x61, 0x61, 0x32, 0x61, 0x38, 0x32, 0x34, 0x31, 0x65, 0x38, 0x63, 0x31, 0x35, 0x39, 0x62, 0x34, 0x65, 0x35, 0x62, 0x38, 0x66, 0x34, 0x62, 0x65, 0x62, 0x32, 0x33, 0x33, 0x38, 0x62, 0x33, 0x62, 0x64, 0x61, 0x31, 0x35, 0x37, 0x36, 0x39, 0x30, 0x35, 0x66, 0x38, 0x66, 0x65, 0x37, 0x62, 0x30, 0x39, 0x65, 0x38, 0x31, 0x61, 0x65, 0x38, 0x65, 0x37, 0x63, 0x30, 0x62, 0x32, 0x66, 0x39, 0x30, 0x62, 0x66, 0x61, 0x31, 0x63, 0x64, 0x37, 0x32, 0x33, 0x32, 0x34, 0x61, 0x65, 0x63, 0x33, 0x32, 0x64, 0x62, 0x66, 0x62, 0x62, 0x30, 0x31, 0x32, 0x39, 0x32, 0x61, 0x63, 0x66, 0x61, 0x37, 0x36, 0x30, 0x66, 0x34, 0x37, 0x63, 0x62, 0x66, 0x37, 0x64, 0x38, 0x30, 0x30, 0x38, 0x39, 0x38, 0x34, 0x31, 0x66, 0x64, 0x37, 0x32, 0x36, 0x38, 0x62, 0x34, 0x36, 0x31, 0x36, 0x34, 0x65, 0x66, 0x31, 0x63, 0x62, 0x37, 0x37, 0x32, 0x39, 0x37, 0x32, 0x35, 0x64, 0x66, 0x34, 0x30, 0x39, 0x39, 0x35, 0x39, 0x37, 0x33, 0x32, 0x64, 0x39, 0x31, 0x31, 0x66, 0x34, 0x64, 0x33, 0x61, 0x37, 0x63, 0x34, 0x65, 0x66, 0x64, 0x37, 0x64, 0x32, 0x38, 0x35, 0x30, 0x36, 0x37, 0x63, 0x35, 0x37, 0x64, 0x33, 0x30, 0x63, 0x36, 0x63, 0x62, 0x63, 0x39, 0x38, 0x66, 0x34, 0x64, 0x64, 0x64, 0x32, 0x36, 0x64, 0x37, 0x30, 0x64, 0x31, 0x66, 0x64, 0x37, 0x32, 0x61, 0x36, 0x66, 0x65, 0x61, 0x64, 0x62, 0x38, 0x30, 0x31, 0x35, 0x39, 0x66, 0x32, 0x38, 0x65, 0x65, 0x61, 0x62, 0x61, 0x65, 0x64, 0x37, 0x32, 0x35, 0x30, 0x32, 0x39, 0x30, 0x32, 0x39, 0x66, 0x34, 0x33, 0x38, 0x38, 0x61, 0x31, 0x61, 0x33, 0x65, 0x30, 0x66, 0x37, 0x35, 0x61, 0x35, 0x62, 0x65, 0x32, 0x35, 0x33, 0x64, 0x35, 0x32, 0x34, 0x63, 0x34, 0x35, 0x37, 0x32, 0x34, 0x37, 0x32, 0x33, 0x65, 0x32, 0x35, 0x64, 0x33, 0x66, 0x62, 0x36, 0x35, 0x32, 0x38, 0x36, 0x63, 0x39, 0x66, 0x36, 0x64, 0x34, 0x33, 0x66, 0x36, 0x61, 0x64, 0x62, 0x36, 0x66, 0x66, 0x65, 0x32, 0x36, 0x36, 0x36, 0x65, 0x66, 0x31, 0x36, 0x38, 0x37, 0x64, 0x39, 0x62, 0x39, 0x63, 0x30, 0x66, 0x31, 0x64, 0x66, 0x33, 0x36, 0x62, 0x63, 0x62, 0x32, 0x35, 0x66, 0x32, 0x38, 0x35, 0x39, 0x30, 0x37, 0x32, 0x61, 0x66, 0x31, 0x63, 0x36, 0x38, 0x61, 0x63, 0x32, 0x63, 0x38, 0x36, 0x37, 0x66, 0x33, 0x66, 0x33, 0x65, 0x63, 0x32, 0x64, 0x33, 0x36, 0x62, 0x32, 0x36, 0x66, 0x65, 0x35, 0x32, 0x39, 0x30, 0x64, 0x36, 0x38, 0x39, 0x30, 0x61, 0x65, 0x38, 0x62, 0x32, 0x33, 0x34, 0x30, 0x65, 0x63, 0x37, 0x33, 0x63, 0x30, 0x31, 0x39, 0x34, 0x34, 0x35, 0x61, 0x64, 0x63, 0x61, 0x35, 0x63, 0x37, 0x32, 0x61, 0x65, 0x31, 0x64, 0x39, 0x31, 0x38, 0x63, 0x37, 0x32, 0x36, 0x36, 0x30, 0x33, 0x63, 0x30, 0x34, 0x61, 0x32, 0x32, 0x66, 0x39, 0x31, 0x39, 0x39, 0x61, 0x35, 0x39, 0x31, 0x39, 0x64, 0x36, 0x34, 0x66, 0x61, 0x38, 0x36, 0x37, 0x35, 0x37, 0x39, 0x35, 0x39, 0x32, 0x62, 0x66, 0x64, 0x34, 0x62, 0x37, 0x37, 0x30, 0x33, 0x35, 0x31, 0x32, 0x32, 0x61, 0x39, 0x63, 0x65, 0x31, 0x37, 0x32, 0x34, 0x64, 0x31, 0x36, 0x34, 0x65, 0x62, 0x38, 0x35, 0x37, 0x35, 0x61, 0x38, 0x66, 0x65, 0x63, 0x61, 0x36, 0x36, 0x38, 0x65, 0x38, 0x38, 0x31, 0x36, 0x61, 0x30, 0x32, 0x31, 0x65, 0x39, 0x31, 0x37, 0x38, 0x39, 0x37, 0x36, 0x37, 0x66, 0x63, 0x38, 0x34, 0x61, 0x63, 0x33, 0x33, 0x64, 0x33, 0x34, 0x30, 0x64, 0x32, 0x35, 0x66, 0x66, 0x30, 0x66, 0x62, 0x38, 0x31, 0x61, 0x65, 0x31, 0x33, 0x64, 0x35, 0x34, 0x38, 0x37, 0x61, 0x65, 0x31, 0x35, 0x38, 0x64, 0x34, 0x65, 0x62, 0x32, 0x38, 0x35, 0x32, 0x66, 0x30, 0x30, 0x36, 0x34, 0x32, 0x34, 0x66, 0x31, 0x65, 0x38, 0x35, 0x33, 0x32, 0x39, 0x65, 0x66, 0x65, 0x38, 0x38, 0x32, 0x33, 0x63, 0x65, 0x64, 0x64, 0x30, 0x63, 0x35, 0x35, 0x62, 0x34, 0x62, 0x34, 0x32, 0x37, 0x62, 0x61, 0x36, 0x30, 0x33, 0x66, 0x64, 0x37, 0x34, 0x30, 0x35, 0x62, 0x34, 0x36, 0x34, 0x35, 0x38, 0x63, 0x30, 0x63, 0x32, 0x61, 0x32, 0x38, 0x65, 0x34, 0x39, 0x63, 0x64, 0x33, 0x32, 0x30, 0x35, 0x61, 0x38, 0x34, 0x38, 0x31, 0x36, 0x61, 0x37, 0x33, 0x63, 0x31, 0x61, 0x65, 0x31, 0x30, 0x36, 0x66, 0x65, 0x39, 0x63, 0x39, 0x34, 0x66, 0x66, 0x30, 0x61, 0x36, 0x36, 0x39, 0x30, 0x32, 0x30, 0x65, 0x34, 0x61, 0x38, 0x34, 0x30, 0x35, 0x32, 0x36, 0x33, 0x63, 0x64, 0x38, 0x33, 0x38, 0x65, 0x61, 0x33, 0x64, 0x61, 0x38, 0x64, 0x31, 0x66, 0x35, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x37, 0x37, 0x62, 0x65, 0x63, 0x37, 0x66, 0x65, 0x62, 0x39, 0x33, 0x39, 0x65, 0x32, 0x66, 0x61, 0x38, 0x34, 0x61, 0x65, 0x64, 0x64, 0x34, 0x30, 0x66, 0x65, 0x34, 0x35, 0x65, 0x36, 0x32, 0x32, 0x63, 0x64, 0x63, 0x32, 0x30, 0x34, 0x39, 0x33, 0x35, 0x34, 0x39, 0x30, 0x64, 0x35, 0x62, 0x32, 0x39, 0x30, 0x30, 0x32, 0x33, 0x32, 0x39, 0x35, 0x37, 0x61, 0x39, 0x34, 0x33, 0x37, 0x36, 0x33, 0x36, 0x32, 0x31, 0x64, 0x31, 0x30, 0x65, 0x35, 0x62, 0x66, 0x38, 0x35, 0x30, 0x37, 0x30, 0x32, 0x30, 0x31, 0x38, 0x61, 0x32, 0x37, 0x61, 0x33, 0x37, 0x31, 0x34, 0x66, 0x31, 0x65, 0x66, 0x66, 0x66, 0x39, 0x31, 0x37, 0x30, 0x36, 0x33, 0x34, 0x37, 0x32, 0x39, 0x32, 0x37, 0x65, 0x38, 0x38, 0x35, 0x66, 0x30, 0x30, 0x31, 0x31, 0x62, 0x64, 0x39, 0x30, 0x38, 0x35, 0x39, 0x63, 0x62, 0x63, 0x62, 0x31, 0x35, 0x33, 0x61, 0x66, 0x34, 0x65, 0x33, 0x61, 0x38, 0x34, 0x32, 0x39, 0x36, 0x35, 0x65, 0x63, 0x61, 0x36, 0x37, 0x66, 0x33, 0x35, 0x34, 0x35, 0x35, 0x64, 0x35, 0x63, 0x33, 0x37, 0x63, 0x39, 0x63, 0x63, 0x34, 0x39, 0x66, 0x30, 0x37, 0x32, 0x32, 0x33, 0x35, 0x65, 0x32, 0x37, 0x33, 0x30, 0x32, 0x30, 0x31, 0x35, 0x36, 0x63, 0x63, 0x66, 0x63, 0x65, 0x31, 0x65, 0x39, 0x34, 0x36, 0x34, 0x36, 0x64, 0x31, 0x62, 0x34, 0x32, 0x30, 0x66, 0x63, 0x33, 0x36, 0x30, 0x63, 0x36, 0x32, 0x31, 0x61, 0x33, 0x37, 0x37, 0x39, 0x36, 0x37, 0x30, 0x37, 0x61, 0x30, 0x38, 0x32, 0x32, 0x62, 0x63, 0x62, 0x32, 0x63, 0x38, 0x35, 0x64, 0x32, 0x63, 0x36, 0x62, 0x31, 0x64, 0x65, 0x32, 0x34, 0x30, 0x34, 0x36, 0x34, 0x32, 0x31, 0x34, 0x61, 0x33, 0x33, 0x63, 0x34, 0x31, 0x32, 0x35, 0x33, 0x62, 0x32, 0x35, 0x61, 0x36, 0x63, 0x36, 0x30, 0x34, 0x63, 0x32, 0x65, 0x33, 0x33, 0x65, 0x34, 0x38, 0x64, 0x63, 0x39, 0x63, 0x30, 0x63, 0x66, 0x33, 0x30, 0x30, 0x32, 0x61, 0x34, 0x63, 0x38, 0x35, 0x33, 0x64, 0x38, 0x33, 0x65, 0x34, 0x37, 0x32, 0x38, 0x34, 0x64, 0x64, 0x34, 0x63, 0x61, 0x37, 0x36, 0x61, 0x32, 0x38, 0x64, 0x31, 0x62, 0x39, 0x61, 0x63, 0x30, 0x36, 0x66, 0x61, 0x61, 0x66, 0x38, 0x33, 0x35, 0x31, 0x34, 0x39, 0x35, 0x38, 0x36, 0x37, 0x62, 0x36, 0x34, 0x66, 0x32, 0x39, 0x65, 0x35, 0x36, 0x34, 0x31, 0x33, 0x62, 0x34, 0x31, 0x38, 0x66, 0x34, 0x32, 0x32, 0x63, 0x30, 0x66, 0x33, 0x64, 0x33, 0x37, 0x30, 0x37, 0x32, 0x32, 0x62, 0x33, 0x31, 0x34, 0x32, 0x62, 0x37, 0x38, 0x62, 0x65, 0x31, 0x63, 0x62, 0x37, 0x33, 0x66, 0x66, 0x33, 0x66, 0x32, 0x36, 0x38, 0x30, 0x32, 0x34, 0x30, 0x61, 0x61, 0x62, 0x34, 0x38, 0x30, 0x64, 0x65, 0x39, 0x39, 0x32, 0x61, 0x62, 0x34, 0x38, 0x30, 0x36, 0x39, 0x39, 0x63, 0x64, 0x35, 0x34, 0x37, 0x39, 0x33, 0x35, 0x64, 0x31, 0x35, 0x38, 0x38, 0x37, 0x32, 0x65, 0x33, 0x30, 0x64, 0x62, 0x38, 0x33, 0x65, 0x35, 0x33, 0x36, 0x63, 0x66, 0x63, 0x64, 0x34, 0x66, 0x30, 0x38, 0x34, 0x62, 0x37, 0x39, 0x30, 0x38, 0x30, 0x65, 0x65, 0x62, 0x35, 0x30, 0x65, 0x32, 0x64, 0x31, 0x35, 0x34, 0x37, 0x30, 0x61, 0x37, 0x37, 0x65, 0x30, 0x36, 0x63, 0x31, 0x65, 0x32, 0x64, 0x37, 0x38, 0x64, 0x32, 0x37, 0x61, 0x64, 0x65, 0x36, 0x36, 0x35, 0x61, 0x63, 0x61, 0x39, 0x37, 0x32, 0x32, 0x63, 0x65, 0x37, 0x37, 0x38, 0x35, 0x63, 0x32, 0x30, 0x62, 0x37, 0x37, 0x65, 0x37, 0x39, 0x37, 0x34, 0x31, 0x33, 0x66, 0x62, 0x65, 0x32, 0x31, 0x33, 0x37, 0x31, 0x37, 0x38, 0x62, 0x63, 0x66, 0x31, 0x33, 0x66, 0x38, 0x63, 0x39, 0x66, 0x35, 0x39, 0x64, 0x38, 0x61, 0x39, 0x30, 0x33, 0x34, 0x36, 0x31, 0x64, 0x64, 0x62, 0x31, 0x36, 0x66, 0x37, 0x37, 0x39, 0x33, 0x34, 0x37, 0x32, 0x61, 0x37, 0x34, 0x65, 0x30, 0x39, 0x39, 0x33, 0x63, 0x31, 0x65, 0x61, 0x31, 0x65, 0x62, 0x32, 0x63, 0x34, 0x62, 0x34, 0x64, 0x66, 0x32, 0x30, 0x36, 0x39, 0x63, 0x63, 0x32, 0x66, 0x31, 0x31, 0x30, 0x37, 0x37, 0x35, 0x30, 0x66, 0x31, 0x38, 0x63, 0x35, 0x63, 0x34, 0x61, 0x35, 0x61, 0x31, 0x64, 0x36, 0x35, 0x63, 0x64, 0x33, 0x31, 0x35, 0x61, 0x63, 0x64, 0x35, 0x36, 0x38, 0x37, 0x32, 0x30, 0x34, 0x39, 0x61, 0x30, 0x35, 0x66, 0x62, 0x62, 0x35, 0x39, 0x32, 0x62, 0x30, 0x34, 0x62, 0x63, 0x66, 0x30, 0x35, 0x32, 0x38, 0x36, 0x34, 0x66, 0x34, 0x61, 0x38, 0x39, 0x36, 0x61, 0x30, 0x31, 0x33, 0x37, 0x32, 0x36, 0x32, 0x62, 0x39, 0x65, 0x35, 0x66, 0x34, 0x31, 0x36, 0x31, 0x32, 0x32, 0x39, 0x38, 0x64, 0x32, 0x35, 0x66, 0x31, 0x32, 0x32, 0x31, 0x63, 0x63, 0x62, 0x37, 0x32, 0x39, 0x30, 0x35, 0x32, 0x34, 0x34, 0x37, 0x38, 0x65, 0x62, 0x64, 0x35, 0x61, 0x64, 0x38, 0x62, 0x37, 0x31, 0x30, 0x37, 0x31, 0x64, 0x63, 0x38, 0x30, 0x36, 0x36, 0x36, 0x62, 0x31, 0x33, 0x63, 0x37, 0x39, 0x36, 0x35, 0x66, 0x30, 0x31, 0x31, 0x39, 0x61, 0x33, 0x63, 0x38, 0x34, 0x33, 0x36, 0x62, 0x62, 0x63, 0x31, 0x31, 0x66, 0x66, 0x37, 0x38, 0x62, 0x34, 0x35, 0x64, 0x61, 0x34, 0x30, 0x36, 0x61, 0x37, 0x31, 0x39, 0x35, 0x61, 0x37, 0x39, 0x34, 0x64, 0x38, 0x37, 0x34, 0x30, 0x34, 0x62, 0x33, 0x61, 0x65, 0x35, 0x35, 0x65, 0x66, 0x64, 0x39, 0x35, 0x32, 0x36, 0x35, 0x66, 0x63, 0x64, 0x66, 0x33, 0x38, 0x35, 0x37, 0x63, 0x35, 0x37, 0x61, 0x38, 0x30, 0x31, 0x30, 0x39, 0x31, 0x65, 0x64, 0x33, 0x38, 0x62, 0x34, 0x63, 0x65, 0x62, 0x64, 0x30, 0x34, 0x66, 0x32, 0x33, 0x66, 0x61, 0x35, 0x30, 0x31, 0x34, 0x39, 0x34, 0x66, 0x31, 0x38, 0x66, 0x35, 0x34, 0x39, 0x61, 0x33, 0x36, 0x37, 0x64, 0x34, 0x36, 0x35, 0x61, 0x62, 0x65, 0x63, 0x36, 0x39, 0x64, 0x39, 0x63, 0x65, 0x34, 0x62, 0x61, 0x34, 0x35, 0x61, 0x38, 0x64, 0x33, 0x39, 0x62, 0x61, 0x64, 0x35, 0x39, 0x31, 0x66, 0x35, 0x66, 0x30, 0x36, 0x35, 0x66, 0x63, 0x34, 0x61, 0x36, 0x32, 0x36, 0x61, 0x37, 0x32, 0x37, 0x66, 0x66, 0x62, 0x63, 0x61, 0x30, 0x66, 0x65, 0x61, 0x66, 0x66, 0x38, 0x61, 0x65, 0x37, 0x32, 0x61, 0x38, 0x38, 0x62, 0x33, 0x30, 0x66, 0x32, 0x31, 0x32, 0x66, 0x61, 0x36, 0x38, 0x38, 0x65, 0x31, 0x39, 0x39, 0x63, 0x65, 0x65, 0x63, 0x66, 0x64, 0x62, 0x66, 0x36, 0x64, 0x64, 0x37, 0x63, 0x64, 0x65, 0x30, 0x30, 0x37, 0x37, 0x64, 0x30, 0x66, 0x39, 0x35, 0x35, 0x65, 0x37, 0x32, 0x62, 0x61, 0x63, 0x66, 0x32, 0x61, 0x37, 0x64, 0x62, 0x39, 0x66, 0x62, 0x39, 0x35, 0x62, 0x37, 0x62, 0x61, 0x37, 0x33, 0x32, 0x33, 0x65, 0x31, 0x32, 0x65, 0x65, 0x65, 0x36, 0x33, 0x34, 0x63, 0x38, 0x37, 0x64, 0x64, 0x30, 0x39, 0x33, 0x62, 0x32, 0x61, 0x64, 0x64, 0x39, 0x35, 0x65, 0x65, 0x66, 0x62, 0x30, 0x64, 0x65, 0x65, 0x34, 0x65, 0x39, 0x37, 0x36, 0x32, 0x38, 0x34, 0x37, 0x32, 0x30, 0x32, 0x63, 0x30, 0x31, 0x39, 0x35, 0x63, 0x65, 0x65, 0x30, 0x66, 0x35, 0x33, 0x31, 0x38, 0x65, 0x38, 0x65, 0x38, 0x33, 0x62, 0x37, 0x34, 0x32, 0x34, 0x62, 0x37, 0x32, 0x30, 0x61, 0x62, 0x63, 0x37, 0x64, 0x61, 0x38, 0x39, 0x64, 0x62, 0x37, 0x39, 0x63, 0x36, 0x63, 0x34, 0x37, 0x61, 0x38, 0x34, 0x37, 0x65, 0x64, 0x38, 0x36, 0x37, 0x36, 0x38, 0x31, 0x38, 0x34, 0x63, 0x37, 0x32, 0x37, 0x30, 0x33, 0x62, 0x34, 0x36, 0x32, 0x62, 0x34, 0x31, 0x64, 0x63, 0x63, 0x35, 0x31, 0x39, 0x33, 0x38, 0x35, 0x36, 0x64, 0x34, 0x32, 0x36, 0x62, 0x61, 0x30, 0x32, 0x33, 0x31, 0x61, 0x34, 0x30, 0x37, 0x65, 0x39, 0x38, 0x61, 0x36, 0x31, 0x37, 0x34, 0x33, 0x35, 0x32, 0x61, 0x39, 0x61, 0x33, 0x61, 0x65, 0x30, 0x34, 0x34, 0x64, 0x32, 0x66, 0x36, 0x35, 0x65, 0x30, 0x38, 0x32, 0x61, 0x35, 0x64, 0x30, 0x31, 0x37, 0x37, 0x35, 0x66, 0x64, 0x30, 0x62, 0x38, 0x33, 0x34, 0x62, 0x34, 0x66, 0x66, 0x61, 0x62, 0x35, 0x34, 0x61, 0x64, 0x66, 0x65, 0x61, 0x32, 0x64, 0x65, 0x62, 0x35, 0x62, 0x30, 0x31, 0x32, 0x30, 0x63, 0x65, 0x31, 0x36, 0x38, 0x32, 0x31, 0x39, 0x30, 0x32, 0x62, 0x32, 0x37, 0x37, 0x61, 0x33, 0x33, 0x37, 0x32, 0x64, 0x35, 0x30, 0x62, 0x33, 0x66, 0x37, 0x32, 0x32, 0x36, 0x64, 0x31, 0x32, 0x32, 0x64, 0x33, 0x31, 0x61, 0x39, 0x63, 0x33, 0x35, 0x33, 0x61, 0x65, 0x64, 0x62, 0x64, 0x33, 0x34, 0x37, 0x34, 0x35, 0x36, 0x33, 0x32, 0x33, 0x65, 0x39, 0x62, 0x62, 0x33, 0x33, 0x32, 0x38, 0x30, 0x32, 0x62, 0x39, 0x66, 0x33, 0x36, 0x35, 0x31, 0x33, 0x32, 0x34, 0x64, 0x62, 0x38, 0x35, 0x35, 0x33, 0x33, 0x64, 0x38, 0x62, 0x62, 0x66, 0x38, 0x37, 0x32, 0x38, 0x32, 0x37, 0x30, 0x39, 0x35, 0x30, 0x38, 0x61, 0x31, 0x31, 0x64, 0x31, 0x30, 0x63, 0x35, 0x30, 0x31, 0x31, 0x61, 0x37, 0x63, 0x32, 0x64, 0x33, 0x66, 0x31, 0x35, 0x66, 0x36, 0x37, 0x61, 0x62, 0x36, 0x34, 0x37, 0x32, 0x66, 0x66, 0x37, 0x65, 0x62, 0x32, 0x35, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x31, 0x64, 0x31, 0x37, 0x34, 0x61, 0x61, 0x32, 0x31, 0x65, 0x34, 0x32, 0x37, 0x32, 0x39, 0x65, 0x35, 0x35, 0x36, 0x30, 0x64, 0x61, 0x64, 0x64, 0x66, 0x64, 0x34, 0x66, 0x37, 0x61, 0x61, 0x31, 0x62, 0x65, 0x38, 0x65, 0x39, 0x33, 0x61, 0x62, 0x32, 0x63, 0x30, 0x30, 0x37, 0x38, 0x61, 0x38, 0x37, 0x38, 0x33, 0x63, 0x33, 0x35, 0x63, 0x37, 0x35, 0x62, 0x37, 0x63, 0x38, 0x65, 0x66, 0x37, 0x35, 0x66, 0x38, 0x31, 0x65, 0x37, 0x36, 0x38, 0x65, 0x31, 0x31, 0x31, 0x37, 0x32, 0x62, 0x36, 0x61, 0x34, 0x38, 0x62, 0x63, 0x30, 0x62, 0x30, 0x65, 0x36, 0x65, 0x61, 0x39, 0x65, 0x36, 0x63, 0x65, 0x35, 0x62, 0x37, 0x34, 0x61, 0x37, 0x33, 0x31, 0x36, 0x64, 0x31, 0x34, 0x64, 0x30, 0x34, 0x37, 0x39, 0x32, 0x62, 0x37, 0x33, 0x32, 0x38, 0x62, 0x38, 0x61, 0x31, 0x30, 0x39, 0x38, 0x37, 0x61, 0x63, 0x38, 0x62, 0x30, 0x35, 0x62, 0x35, 0x31, 0x32, 0x37, 0x65, 0x37, 0x32, 0x34, 0x32, 0x39, 0x38, 0x30, 0x61, 0x37, 0x34, 0x38, 0x39, 0x32, 0x36, 0x39, 0x64, 0x62, 0x64, 0x66, 0x38, 0x36, 0x36, 0x35, 0x32, 0x31, 0x37, 0x33, 0x38, 0x62, 0x34, 0x31, 0x32, 0x39, 0x65, 0x30, 0x33, 0x61, 0x35, 0x35, 0x34, 0x36, 0x32, 0x31, 0x65, 0x39, 0x39, 0x37, 0x64, 0x61, 0x63, 0x31, 0x30, 0x38, 0x65, 0x37, 0x64, 0x37, 0x31, 0x36, 0x35, 0x63, 0x38, 0x65, 0x38, 0x33, 0x34, 0x64, 0x35, 0x66, 0x30, 0x31, 0x30, 0x39, 0x34, 0x38, 0x35, 0x62, 0x63, 0x38, 0x64, 0x31, 0x34, 0x39, 0x35, 0x61, 0x64, 0x65, 0x33, 0x66, 0x31, 0x32, 0x33, 0x39, 0x64, 0x33, 0x66, 0x32, 0x34, 0x65, 0x37, 0x35, 0x37, 0x32, 0x30, 0x31, 0x63, 0x39, 0x61, 0x63, 0x64, 0x36, 0x39, 0x33, 0x66, 0x33, 0x37, 0x66, 0x36, 0x37, 0x36, 0x37, 0x33, 0x30, 0x35, 0x32, 0x39, 0x39, 0x62, 0x37, 0x32, 0x33, 0x61, 0x35, 0x31, 0x35, 0x37, 0x65, 0x61, 0x65, 0x39, 0x37, 0x63, 0x37, 0x35, 0x37, 0x31, 0x65, 0x36, 0x61, 0x34, 0x33, 0x62, 0x39, 0x34, 0x62, 0x62, 0x32, 0x30, 0x31, 0x64, 0x30, 0x37, 0x63, 0x63, 0x35, 0x62, 0x64, 0x61, 0x35, 0x62, 0x62, 0x32, 0x61, 0x63, 0x61, 0x61, 0x34, 0x66, 0x32, 0x30, 0x38, 0x61, 0x30, 0x61, 0x39, 0x33, 0x66, 0x39, 0x63, 0x64, 0x34, 0x64, 0x36, 0x64, 0x38, 0x31, 0x39, 0x39, 0x62, 0x31, 0x30, 0x30, 0x62, 0x30, 0x32, 0x66, 0x64, 0x64, 0x65, 0x64, 0x38, 0x62, 0x33, 0x36, 0x35, 0x34, 0x30, 0x35, 0x35, 0x30, 0x66, 0x62, 0x38, 0x64, 0x61, 0x65, 0x33, 0x65, 0x65, 0x31, 0x64, 0x37, 0x34, 0x33, 0x64, 0x63, 0x61, 0x63, 0x34, 0x33, 0x34, 0x39, 0x34, 0x61, 0x36, 0x64, 0x30, 0x61, 0x62, 0x66, 0x30, 0x66, 0x66, 0x39, 0x38, 0x35, 0x37, 0x32, 0x63, 0x37, 0x66, 0x37, 0x34, 0x34, 0x35, 0x66, 0x34, 0x65, 0x31, 0x62, 0x65, 0x62, 0x30, 0x34, 0x38, 0x37, 0x33, 0x30, 0x61, 0x35, 0x33, 0x37, 0x32, 0x63, 0x34, 0x65, 0x65, 0x39, 0x31, 0x37, 0x66, 0x63, 0x37, 0x31, 0x30, 0x36, 0x65, 0x35, 0x30, 0x34, 0x62, 0x30, 0x32, 0x61, 0x65, 0x65, 0x34, 0x34, 0x65, 0x30, 0x61, 0x35, 0x35, 0x61, 0x35, 0x35, 0x35, 0x30, 0x63, 0x30, 0x37, 0x32, 0x64, 0x36, 0x36, 0x36, 0x30, 0x37, 0x61, 0x35, 0x66, 0x61, 0x65, 0x66, 0x66, 0x62, 0x30, 0x34, 0x35, 0x30, 0x31, 0x32, 0x39, 0x66, 0x32, 0x31, 0x33, 0x36, 0x63, 0x66, 0x31, 0x64, 0x32, 0x35, 0x36, 0x61, 0x31, 0x61, 0x35, 0x33, 0x38, 0x37, 0x31, 0x32, 0x37, 0x37, 0x35, 0x36, 0x39, 0x35, 0x34, 0x65, 0x63, 0x37, 0x66, 0x33, 0x30, 0x35, 0x61, 0x34, 0x65, 0x65, 0x34, 0x35, 0x37, 0x32, 0x32, 0x34, 0x37, 0x37, 0x62, 0x37, 0x62, 0x62, 0x39, 0x30, 0x65, 0x39, 0x65, 0x38, 0x63, 0x38, 0x36, 0x38, 0x39, 0x30, 0x33, 0x34, 0x62, 0x31, 0x35, 0x66, 0x37, 0x34, 0x32, 0x65, 0x33, 0x34, 0x37, 0x64, 0x64, 0x66, 0x32, 0x63, 0x35, 0x64, 0x62, 0x31, 0x62, 0x33, 0x35, 0x32, 0x30, 0x39, 0x38, 0x33, 0x63, 0x33, 0x62, 0x31, 0x30, 0x36, 0x31, 0x39, 0x35, 0x30, 0x31, 0x30, 0x34, 0x36, 0x33, 0x64, 0x35, 0x33, 0x32, 0x34, 0x35, 0x64, 0x62, 0x37, 0x39, 0x65, 0x38, 0x34, 0x39, 0x65, 0x61, 0x65, 0x65, 0x37, 0x30, 0x63, 0x31, 0x32, 0x38, 0x39, 0x61, 0x61, 0x37, 0x31, 0x30, 0x35, 0x62, 0x35, 0x63, 0x39, 0x63, 0x32, 0x32, 0x33, 0x63, 0x66, 0x35, 0x31, 0x61, 0x30, 0x35, 0x35, 0x31, 0x39, 0x37, 0x66, 0x61, 0x38, 0x38, 0x64, 0x66, 0x36, 0x61, 0x61, 0x66, 0x30, 0x37, 0x32, 0x65, 0x61, 0x30, 0x33, 0x66, 0x35, 0x37, 0x35, 0x33, 0x39, 0x34, 0x65, 0x36, 0x34, 0x61, 0x32, 0x64, 0x65, 0x61, 0x30, 0x31, 0x30, 0x38, 0x36, 0x64, 0x35, 0x36, 0x30, 0x34, 0x66, 0x36, 0x36, 0x66, 0x31, 0x34, 0x32, 0x38, 0x66, 0x36, 0x65, 0x62, 0x32, 0x63, 0x36, 0x31, 0x30, 0x63, 0x39, 0x32, 0x66, 0x63, 0x63, 0x66, 0x63, 0x65, 0x37, 0x61, 0x66, 0x35, 0x38, 0x35, 0x65, 0x37, 0x32, 0x64, 0x32, 0x66, 0x32, 0x63, 0x66, 0x33, 0x65, 0x33, 0x32, 0x66, 0x66, 0x39, 0x34, 0x39, 0x38, 0x37, 0x62, 0x35, 0x65, 0x39, 0x31, 0x36, 0x65, 0x30, 0x31, 0x63, 0x62, 0x30, 0x34, 0x66, 0x37, 0x63, 0x31, 0x30, 0x36, 0x37, 0x64, 0x39, 0x39, 0x32, 0x62, 0x36, 0x31, 0x66, 0x65, 0x63, 0x61, 0x65, 0x31, 0x31, 0x66, 0x36, 0x65, 0x37, 0x33, 0x33, 0x61, 0x32, 0x39, 0x33, 0x30, 0x37, 0x32, 0x64, 0x31, 0x62, 0x64, 0x66, 0x34, 0x37, 0x34, 0x39, 0x30, 0x62, 0x65, 0x66, 0x64, 0x63, 0x33, 0x33, 0x64, 0x65, 0x39, 0x64, 0x32, 0x31, 0x65, 0x34, 0x64, 0x38, 0x39, 0x35, 0x63, 0x30, 0x62, 0x39, 0x30, 0x35, 0x37, 0x36, 0x36, 0x61, 0x37, 0x65, 0x37, 0x35, 0x63, 0x31, 0x37, 0x63, 0x36, 0x38, 0x32, 0x63, 0x61, 0x64, 0x66, 0x35, 0x32, 0x66, 0x39, 0x31, 0x32, 0x34, 0x34, 0x37, 0x32, 0x32, 0x36, 0x39, 0x30, 0x61, 0x32, 0x65, 0x33, 0x33, 0x35, 0x65, 0x62, 0x62, 0x61, 0x34, 0x62, 0x62, 0x36, 0x35, 0x64, 0x30, 0x37, 0x30, 0x39, 0x33, 0x35, 0x64, 0x62, 0x65, 0x61, 0x36, 0x62, 0x33, 0x36, 0x31, 0x31, 0x35, 0x66, 0x65, 0x30, 0x31, 0x34, 0x62, 0x65, 0x64, 0x34, 0x66, 0x39, 0x31, 0x39, 0x61, 0x66, 0x34, 0x33, 0x66, 0x39, 0x61, 0x64, 0x63, 0x36, 0x37, 0x63, 0x36, 0x36, 0x36, 0x38, 0x30, 0x65, 0x30, 0x66, 0x31, 0x64, 0x33, 0x36, 0x63, 0x61, 0x38, 0x31, 0x64, 0x34, 0x64, 0x33, 0x66, 0x34, 0x62, 0x65, 0x35, 0x62, 0x66, 0x64, 0x34, 0x66, 0x63, 0x35, 0x38, 0x66, 0x39, 0x33, 0x35, 0x61, 0x34, 0x36, 0x32, 0x32, 0x32, 0x64, 0x38, 0x32, 0x65, 0x32, 0x36, 0x38, 0x61, 0x62, 0x63, 0x36, 0x63, 0x66, 0x33, 0x64, 0x34, 0x31, 0x66, 0x31, 0x35, 0x31, 0x37, 0x32, 0x38, 0x35, 0x38, 0x64, 0x62, 0x61, 0x62, 0x61, 0x62, 0x34, 0x62, 0x34, 0x33, 0x33, 0x30, 0x33, 0x30, 0x33, 0x30, 0x36, 0x35, 0x64, 0x33, 0x64, 0x35, 0x39, 0x38, 0x64, 0x65, 0x61, 0x35, 0x32, 0x32, 0x34, 0x33, 0x61, 0x39, 0x61, 0x37, 0x39, 0x32, 0x30, 0x66, 0x66, 0x33, 0x63, 0x36, 0x63, 0x33, 0x63, 0x65, 0x32, 0x34, 0x36, 0x61, 0x37, 0x30, 0x39, 0x39, 0x37, 0x64, 0x33, 0x31, 0x30, 0x39, 0x35, 0x38, 0x32, 0x33, 0x65, 0x37, 0x34, 0x35, 0x62, 0x63, 0x35, 0x61, 0x62, 0x39, 0x64, 0x38, 0x62, 0x39, 0x30, 0x36, 0x36, 0x35, 0x38, 0x38, 0x35, 0x36, 0x37, 0x66, 0x39, 0x38, 0x38, 0x62, 0x31, 0x37, 0x63, 0x34, 0x66, 0x33, 0x39, 0x30, 0x35, 0x32, 0x62, 0x39, 0x36, 0x32, 0x36, 0x64, 0x39, 0x33, 0x63, 0x62, 0x39, 0x39, 0x39, 0x39, 0x31, 0x36, 0x62, 0x62, 0x31, 0x33, 0x37, 0x65, 0x34, 0x37, 0x65, 0x32, 0x34, 0x66, 0x34, 0x65, 0x32, 0x63, 0x30, 0x62, 0x31, 0x66, 0x61, 0x31, 0x33, 0x31, 0x63, 0x35, 0x64, 0x65, 0x33, 0x30, 0x66, 0x33, 0x33, 0x61, 0x66, 0x37, 0x30, 0x32, 0x35, 0x61, 0x34, 0x36, 0x37, 0x61, 0x34, 0x30, 0x30, 0x32, 0x30, 0x36, 0x38, 0x62, 0x62, 0x35, 0x30, 0x30, 0x66, 0x33, 0x65, 0x63, 0x63, 0x31, 0x33, 0x37, 0x61, 0x37, 0x65, 0x37, 0x32, 0x37, 0x65, 0x38, 0x61, 0x36, 0x30, 0x30, 0x30, 0x31, 0x64, 0x39, 0x34, 0x38, 0x39, 0x66, 0x39, 0x63, 0x65, 0x31, 0x38, 0x30, 0x63, 0x34, 0x64, 0x39, 0x62, 0x33, 0x63, 0x64, 0x63, 0x30, 0x62, 0x39, 0x66, 0x30, 0x34, 0x32, 0x31, 0x34, 0x30, 0x31, 0x62, 0x61, 0x65, 0x64, 0x64, 0x65, 0x39, 0x32, 0x30, 0x66, 0x64, 0x39, 0x37, 0x63, 0x39, 0x61, 0x34, 0x61, 0x36, 0x65, 0x37, 0x32, 0x63, 0x34, 0x30, 0x36, 0x66, 0x31, 0x36, 0x35, 0x63, 0x32, 0x31, 0x36, 0x37, 0x65, 0x64, 0x37, 0x39, 0x61, 0x39, 0x31, 0x64, 0x36, 0x64, 0x66, 0x66, 0x33, 0x62, 0x38, 0x39, 0x35, 0x36, 0x33, 0x37, 0x63, 0x34, 0x63, 0x30, 0x35, 0x35, 0x34, 0x32, 0x38, 0x64, 0x38, 0x31, 0x61, 0x63, 0x35, 0x35, 0x66, 0x36, 0x32, 0x65, 0x35, 0x64, 0x33, 0x32, 0x65, 0x33, 0x64, 0x32, 0x34, 0x37, 0x36, 0x39, 0x64, 0x32, 0x33, 0x38, 0x62, 0x65, 0x38, 0x64, 0x36, 0x63, 0x63, 0x34, 0x34, 0x34, 0x39, 0x37, 0x30, 0x32, 0x34, 0x34, 0x37, 0x37, 0x33, 0x38, 0x31, 0x61, 0x63, 0x65, 0x64, 0x35, 0x36, 0x31, 0x61, 0x35, 0x63, 0x34, 0x38, 0x34, 0x37, 0x63, 0x31, 0x37, 0x38, 0x61, 0x65, 0x62, 0x37, 0x66, 0x66, 0x32, 0x61, 0x62, 0x32, 0x38, 0x33, 0x65, 0x66, 0x30, 0x65, 0x63, 0x31, 0x62, 0x33, 0x62, 0x31, 0x65, 0x65, 0x37, 0x32, 0x37, 0x63, 0x62, 0x65, 0x30, 0x36, 0x64, 0x38, 0x36, 0x30, 0x62, 0x63, 0x35, 0x31, 0x39, 0x61, 0x39, 0x38, 0x39, 0x65, 0x31, 0x62, 0x36, 0x66, 0x34, 0x65, 0x62, 0x32, 0x65, 0x37, 0x66, 0x32, 0x63, 0x66, 0x33, 0x38, 0x33, 0x37, 0x62, 0x65, 0x31, 0x36, 0x31, 0x39, 0x39, 0x39, 0x61, 0x33, 0x31, 0x32, 0x36, 0x38, 0x38, 0x33, 0x38, 0x61, 0x32, 0x37, 0x32, 0x37, 0x65, 0x39, 0x36, 0x65, 0x37, 0x65, 0x65, 0x66, 0x36, 0x30, 0x38, 0x65, 0x33, 0x36, 0x35, 0x39, 0x32, 0x39, 0x35, 0x30, 0x31, 0x35, 0x39, 0x35, 0x33, 0x35, 0x65, 0x30, 0x34, 0x38, 0x35, 0x37, 0x66, 0x33, 0x61, 0x63, 0x62, 0x35, 0x61, 0x37, 0x64, 0x37, 0x64, 0x36, 0x36, 0x38, 0x35, 0x66, 0x66, 0x61, 0x61, 0x62, 0x32, 0x64, 0x32, 0x36, 0x64, 0x64, 0x31, 0x31, 0x39, 0x37, 0x32, 0x62, 0x33, 0x39, 0x65, 0x35, 0x61, 0x63, 0x65, 0x38, 0x32, 0x64, 0x30, 0x63, 0x61, 0x37, 0x63, 0x36, 0x32, 0x65, 0x39, 0x30, 0x32, 0x65, 0x30, 0x39, 0x61, 0x33, 0x39, 0x35, 0x62, 0x62, 0x32, 0x65, 0x63, 0x39, 0x61, 0x31, 0x35, 0x33, 0x62, 0x34, 0x35, 0x33, 0x34, 0x33, 0x65, 0x37, 0x39, 0x37, 0x36, 0x36, 0x36, 0x31, 0x66, 0x32, 0x66, 0x61, 0x64, 0x63, 0x63, 0x33, 0x63, 0x37, 0x32, 0x33, 0x36, 0x65, 0x38, 0x62, 0x30, 0x33, 0x30, 0x35, 0x63, 0x64, 0x37, 0x35, 0x38, 0x30, 0x36, 0x38, 0x34, 0x30, 0x31, 0x37, 0x36, 0x62, 0x34, 0x36, 0x62, 0x35, 0x38, 0x66, 0x61, 0x35, 0x37, 0x63, 0x61, 0x63, 0x31, 0x32, 0x39, 0x66, 0x62, 0x39, 0x62, 0x32, 0x66, 0x34, 0x36, 0x64, 0x63, 0x63, 0x38, 0x66, 0x34, 0x37, 0x34, 0x31, 0x31, 0x62, 0x64, 0x36, 0x34, 0x65, 0x38, 0x37, 0x32, 0x65, 0x34, 0x38, 0x37, 0x37, 0x31, 0x35, 0x37, 0x66, 0x65, 0x35, 0x30, 0x39, 0x61, 0x38, 0x37, 0x61, 0x31, 0x30, 0x35, 0x38, 0x66, 0x63, 0x35, 0x39, 0x34, 0x32, 0x61, 0x62, 0x34, 0x64, 0x39, 0x35, 0x61, 0x33, 0x64, 0x32, 0x33, 0x35, 0x39, 0x62, 0x64, 0x30, 0x38, 0x37, 0x38, 0x31, 0x39, 0x61, 0x31, 0x38, 0x65, 0x38, 0x31, 0x30, 0x65, 0x31, 0x62, 0x34, 0x61, 0x32, 0x37, 0x31, 0x38, 0x61, 0x39, 0x33, 0x33, 0x66, 0x62, 0x36, 0x31, 0x33, 0x64, 0x36, 0x66, 0x66, 0x63, 0x64, 0x64, 0x38, 0x65, 0x65, 0x32, 0x36, 0x35, 0x38, 0x33, 0x35, 0x34, 0x61, 0x38, 0x39, 0x66, 0x62, 0x65, 0x37, 0x65, 0x62, 0x35, 0x30, 0x30, 0x32, 0x65, 0x31, 0x66, 0x37, 0x34, 0x39, 0x39, 0x63, 0x64, 0x36, 0x63, 0x37, 0x35, 0x65, 0x35, 0x39, 0x65, 0x64, 0x66, 0x39, 0x61, 0x31, 0x39, 0x37, 0x32, 0x32, 0x34, 0x38, 0x35, 0x32, 0x32, 0x63, 0x61, 0x37, 0x65, 0x34, 0x64, 0x61, 0x30, 0x35, 0x31, 0x39, 0x35, 0x61, 0x66, 0x35, 0x32, 0x32, 0x39, 0x39, 0x31, 0x64, 0x63, 0x62, 0x61, 0x62, 0x39, 0x34, 0x62, 0x65, 0x63, 0x35, 0x31, 0x30, 0x33, 0x35, 0x32, 0x39, 0x35, 0x65, 0x30, 0x63, 0x63, 0x32, 0x36, 0x38, 0x38, 0x30, 0x66, 0x61, 0x31, 0x61, 0x64, 0x31, 0x33, 0x38, 0x38, 0x37, 0x32, 0x63, 0x33, 0x36, 0x38, 0x37, 0x63, 0x66, 0x33, 0x34, 0x33, 0x63, 0x38, 0x31, 0x33, 0x34, 0x66, 0x30, 0x32, 0x37, 0x63, 0x65, 0x62, 0x36, 0x64, 0x30, 0x37, 0x63, 0x63, 0x63, 0x65, 0x65, 0x32, 0x62, 0x61, 0x38, 0x64, 0x37, 0x35, 0x63, 0x63, 0x35, 0x32, 0x39, 0x64, 0x33, 0x64, 0x65, 0x31, 0x36, 0x35, 0x65, 0x32, 0x32, 0x30, 0x61, 0x66, 0x31, 0x65, 0x65, 0x65, 0x35, 0x35, 0x35, 0x37, 0x63, 0x65, 0x61, 0x64, 0x36, 0x34, 0x31, 0x66, 0x35, 0x39, 0x64, 0x34, 0x38, 0x34, 0x30, 0x65, 0x39, 0x30, 0x35, 0x31, 0x31, 0x34, 0x61, 0x33, 0x33, 0x33, 0x36, 0x35, 0x31, 0x34, 0x34, 0x39, 0x34, 0x34, 0x31, 0x63, 0x62, 0x65, 0x34, 0x62, 0x31, 0x33, 0x37, 0x62, 0x35, 0x64, 0x38, 0x64, 0x33, 0x36, 0x62, 0x34, 0x34, 0x34, 0x31, 0x62, 0x63, 0x39, 0x31, 0x34, 0x61, 0x32, 0x34, 0x38, 0x64, 0x32, 0x62, 0x33, 0x62, 0x35, 0x39, 0x34, 0x38, 0x31, 0x34, 0x34, 0x63, 0x30, 0x32, 0x62, 0x36, 0x39, 0x31, 0x39, 0x35, 0x38, 0x30, 0x63, 0x32, 0x62, 0x37, 0x32, 0x38, 0x33, 0x36, 0x63, 0x64, 0x37, 0x31, 0x36, 0x62, 0x31, 0x63, 0x35, 0x39, 0x61, 0x66, 0x64, 0x30, 0x66, 0x38, 0x39, 0x38, 0x31, 0x33, 0x32, 0x31, 0x38, 0x34, 0x33, 0x37, 0x36, 0x39, 0x33, 0x33, 0x65, 0x36, 0x39, 0x36, 0x35, 0x66, 0x34, 0x64, 0x37, 0x33, 0x36, 0x32, 0x39, 0x34, 0x30, 0x66, 0x31, 0x36, 0x66, 0x37, 0x62, 0x31, 0x37, 0x36, 0x64, 0x34, 0x31, 0x34, 0x36, 0x31, 0x36, 0x35, 0x63, 0x35, 0x36, 0x35, 0x65, 0x30, 0x37, 0x30, 0x34, 0x39, 0x31, 0x31, 0x32, 0x36, 0x34, 0x34, 0x30, 0x39, 0x39, 0x61, 0x32, 0x39, 0x63, 0x65, 0x62, 0x30, 0x35, 0x65, 0x32, 0x39, 0x36, 0x33, 0x33, 0x37, 0x32, 0x33, 0x34, 0x38, 0x32, 0x39, 0x31, 0x37, 0x34, 0x37, 0x38, 0x34, 0x37, 0x35, 0x36, 0x63, 0x39, 0x33, 0x66, 0x63, 0x31, 0x61, 0x64, 0x37, 0x33, 0x66, 0x66, 0x33, 0x36, 0x61, 0x37, 0x34, 0x32, 0x31, 0x65, 0x61, 0x30, 0x33, 0x38, 0x61, 0x66, 0x61, 0x66, 0x38, 0x38, 0x63, 0x66, 0x37, 0x38, 0x36, 0x63, 0x35, 0x36, 0x37, 0x33, 0x64, 0x31, 0x35, 0x61, 0x32, 0x63, 0x62, 0x37, 0x36, 0x33, 0x63, 0x38, 0x37, 0x65, 0x33, 0x62, 0x37, 0x33, 0x65, 0x65, 0x39, 0x65, 0x66, 0x65, 0x61, 0x37, 0x38, 0x64, 0x61, 0x61, 0x37, 0x63, 0x30, 0x30, 0x64, 0x61, 0x31, 0x32, 0x34, 0x61, 0x32, 0x33, 0x33, 0x39, 0x36, 0x30, 0x32, 0x65, 0x34, 0x61, 0x32, 0x33, 0x39, 0x64, 0x64, 0x62, 0x30, 0x33, 0x62, 0x30, 0x34, 0x66, 0x65, 0x30, 0x61, 0x66, 0x61, 0x61, 0x38, 0x39, 0x61, 0x63, 0x35, 0x66, 0x36, 0x32, 0x33, 0x37, 0x66, 0x36, 0x66, 0x31, 0x31, 0x62, 0x39, 0x64, 0x37, 0x62, 0x65, 0x35, 0x35, 0x61, 0x65, 0x38, 0x63, 0x39, 0x31, 0x63, 0x32, 0x65, 0x30, 0x33, 0x32, 0x30, 0x36, 0x37, 0x39, 0x37, 0x30, 0x31, 0x32, 0x65, 0x38, 0x31, 0x34, 0x38, 0x33, 0x66, 0x30, 0x39, 0x66, 0x33, 0x64, 0x32, 0x62, 0x39, 0x38, 0x36, 0x62, 0x34, 0x35, 0x66, 0x35, 0x61, 0x66, 0x62, 0x37, 0x32, 0x31, 0x64, 0x37, 0x33, 0x36, 0x30, 0x62, 0x31, 0x37, 0x34, 0x39, 0x37, 0x33, 0x66, 0x39, 0x63, 0x30, 0x33, 0x32, 0x38, 0x33, 0x33, 0x61, 0x39, 0x34, 0x36, 0x39, 0x38, 0x65, 0x64, 0x62, 0x34, 0x37, 0x36, 0x66, 0x37, 0x65, 0x61, 0x65, 0x36, 0x35, 0x39, 0x37, 0x34, 0x61, 0x63, 0x35, 0x30, 0x31, 0x34, 0x34, 0x33, 0x36, 0x31, 0x61, 0x32, 0x31, 0x34, 0x30, 0x39, 0x65, 0x61, 0x37, 0x32, 0x35, 0x39, 0x32, 0x37, 0x30, 0x35, 0x65, 0x32, 0x35, 0x61, 0x35, 0x37, 0x35, 0x63, 0x30, 0x64, 0x31, 0x35, 0x30, 0x35, 0x61, 0x36, 0x34, 0x62, 0x63, 0x37, 0x64, 0x32, 0x39, 0x35, 0x38, 0x34, 0x33, 0x64, 0x63, 0x64, 0x35, 0x34, 0x39, 0x36, 0x30, 0x62, 0x66, 0x65, 0x66, 0x61, 0x66, 0x30, 0x36, 0x31, 0x33, 0x65, 0x33, 0x30, 0x65, 0x63, 0x37, 0x34, 0x39, 0x65, 0x37, 0x30, 0x37, 0x32, 0x39, 0x37, 0x64, 0x33, 0x38, 0x62, 0x35, 0x63, 0x63, 0x39, 0x30, 0x35, 0x65, 0x62, 0x38, 0x61, 0x63, 0x65, 0x64, 0x33, 0x62, 0x64, 0x33, 0x62, 0x30, 0x30, 0x36, 0x37, 0x66, 0x30, 0x39, 0x62, 0x39, 0x65, 0x34, 0x34, 0x38, 0x32, 0x63, 0x66, 0x64, 0x34, 0x65, 0x63, 0x37, 0x38, 0x32, 0x62, 0x37, 0x38, 0x30, 0x65, 0x36, 0x30, 0x61, 0x35, 0x30, 0x39, 0x66, 0x30, 0x65, 0x37, 0x34, 0x61, 0x61, 0x64, 0x34, 0x61, 0x36, 0x30, 0x30, 0x35, 0x65, 0x61, 0x31, 0x31, 0x64, 0x31, 0x31, 0x34, 0x62, 0x64, 0x64, 0x61, 0x33, 0x65, 0x39, 0x65, 0x65, 0x39, 0x39, 0x36, 0x31, 0x39, 0x37, 0x66, 0x31, 0x32, 0x63, 0x65, 0x30, 0x31, 0x34, 0x64, 0x30, 0x63, 0x66, 0x34, 0x37, 0x33, 0x61, 0x34, 0x31, 0x35, 0x65, 0x34, 0x66, 0x30, 0x61, 0x66, 0x62, 0x65, 0x62, 0x31, 0x32, 0x37, 0x37, 0x32, 0x36, 0x31, 0x31, 0x38, 0x65, 0x62, 0x66, 0x66, 0x32, 0x63, 0x61, 0x66, 0x30, 0x34, 0x32, 0x33, 0x61, 0x30, 0x32, 0x65, 0x38, 0x30, 0x65, 0x61, 0x32, 0x61, 0x32, 0x36, 0x31, 0x63, 0x32, 0x61, 0x37, 0x33, 0x61, 0x66, 0x32, 0x65, 0x61, 0x65, 0x39, 0x39, 0x66, 0x66, 0x61, 0x39, 0x66, 0x34, 0x65, 0x63, 0x63, 0x36, 0x37, 0x31, 0x30, 0x62, 0x61, 0x38, 0x39, 0x62, 0x34, 0x39, 0x35, 0x36, 0x33, 0x31, 0x38, 0x62, 0x66, 0x34, 0x64, 0x39, 0x62, 0x65, 0x64, 0x61, 0x37, 0x34, 0x34, 0x64, 0x35, 0x30, 0x31, 0x35, 0x64, 0x62, 0x65, 0x62, 0x61, 0x61, 0x62, 0x62, 0x61, 0x31, 0x66, 0x66, 0x31, 0x64, 0x30, 0x63, 0x62, 0x63, 0x66, 0x64, 0x39, 0x65, 0x64, 0x31, 0x38, 0x33, 0x36, 0x33, 0x32, 0x34, 0x63, 0x62, 0x64, 0x62, 0x63, 0x37, 0x33, 0x35, 0x32, 0x62, 0x34, 0x34, 0x32, 0x39, 0x33, 0x33, 0x35, 0x66, 0x61, 0x32, 0x61, 0x36, 0x32, 0x30, 0x32, 0x39, 0x64, 0x38, 0x37, 0x62, 0x34, 0x31, 0x34, 0x63, 0x38, 0x30, 0x33, 0x39, 0x34, 0x61, 0x37, 0x35, 0x61, 0x64, 0x31, 0x39, 0x61, 0x39, 0x31, 0x34, 0x34, 0x65, 0x38, 0x35, 0x37, 0x65, 0x39, 0x65, 0x64, 0x35, 0x35, 0x33, 0x62, 0x34, 0x66, 0x64, 0x31, 0x32, 0x36, 0x34, 0x31, 0x31, 0x64, 0x66, 0x33, 0x64, 0x31, 0x34, 0x63, 0x34, 0x63, 0x39, 0x64, 0x32, 0x38, 0x33, 0x34, 0x33, 0x66, 0x34, 0x36, 0x63, 0x34, 0x39, 0x64, 0x31, 0x32, 0x37, 0x38, 0x64, 0x33, 0x31, 0x64, 0x66, 0x36, 0x63, 0x30, 0x39, 0x66, 0x38, 0x38, 0x63, 0x39, 0x62, 0x35, 0x36, 0x61, 0x32, 0x38, 0x37, 0x62, 0x62, 0x31, 0x61, 0x38, 0x66, 0x62, 0x62, 0x37, 0x64, 0x39, 0x36, 0x61, 0x62, 0x62, 0x62, 0x36, 0x37, 0x35, 0x61, 0x37, 0x32, 0x37, 0x63, 0x39, 0x31, 0x31, 0x30, 0x36, 0x39, 0x66, 0x64, 0x33, 0x37, 0x30, 0x37, 0x63, 0x64, 0x35, 0x63, 0x62, 0x66, 0x35, 0x35, 0x32, 0x38, 0x33, 0x63, 0x64, 0x65, 0x32, 0x38, 0x35, 0x31, 0x64, 0x35, 0x32, 0x65, 0x64, 0x66, 0x38, 0x61, 0x30, 0x34, 0x38, 0x36, 0x38, 0x35, 0x36, 0x36, 0x66, 0x37, 0x33, 0x38, 0x38, 0x31, 0x33, 0x33, 0x66, 0x35, 0x39, 0x35, 0x30, 0x36, 0x37, 0x32, 0x62, 0x65, 0x37, 0x62, 0x39, 0x38, 0x35, 0x64, 0x66, 0x63, 0x33, 0x63, 0x30, 0x39, 0x38, 0x31, 0x63, 0x37, 0x37, 0x36, 0x39, 0x30, 0x36, 0x37, 0x31, 0x35, 0x32, 0x62, 0x39, 0x63, 0x62, 0x63, 0x31, 0x35, 0x66, 0x32, 0x33, 0x66, 0x37, 0x34, 0x66, 0x38, 0x64, 0x61, 0x32, 0x64, 0x66, 0x39, 0x31, 0x30, 0x35, 0x63, 0x62, 0x64, 0x36, 0x61, 0x30, 0x31, 0x33, 0x32, 0x63, 0x64, 0x30, 0x62, 0x63, 0x39, 0x31, 0x39, 0x64, 0x63, 0x30, 0x64, 0x64, 0x38, 0x34, 0x38, 0x38, 0x39, 0x31, 0x35, 0x65, 0x35, 0x32, 0x66, 0x37, 0x36, 0x65, 0x36, 0x39, 0x62, 0x31, 0x31, 0x39, 0x62, 0x34, 0x37, 0x30, 0x39, 0x39, 0x65, 0x39, 0x30, 0x37, 0x37, 0x62, 0x37, 0x30, 0x66, 0x35, 0x65, 0x63, 0x35, 0x31, 0x62, 0x32, 0x66, 0x66, 0x34, 0x66, 0x62, 0x33, 0x62, 0x66, 0x39, 0x39, 0x32, 0x37, 0x32, 0x63, 0x37, 0x38, 0x66, 0x37, 0x36, 0x63, 0x33, 0x62, 0x64, 0x65, 0x38, 0x36, 0x31, 0x35, 0x34, 0x31, 0x61, 0x30, 0x34, 0x61, 0x34, 0x38, 0x32, 0x35, 0x39, 0x33, 0x62, 0x34, 0x30, 0x30, 0x63, 0x30, 0x62, 0x63, 0x38, 0x36, 0x31, 0x61, 0x34, 0x30, 0x62, 0x34, 0x35, 0x37, 0x63, 0x64, 0x61, 0x63, 0x62, 0x32, 0x30, 0x65, 0x34, 0x66, 0x39, 0x61, 0x62, 0x31, 0x31, 0x61, 0x66, 0x37, 0x32, 0x38, 0x62, 0x35, 0x39, 0x38, 0x33, 0x66, 0x33, 0x64, 0x37, 0x62, 0x64, 0x36, 0x66, 0x66, 0x66, 0x61, 0x30, 0x62, 0x66, 0x32, 0x31, 0x38, 0x66, 0x38, 0x33, 0x35, 0x34, 0x63, 0x64, 0x39, 0x36, 0x30, 0x63, 0x35, 0x63, 0x30, 0x32, 0x62, 0x34, 0x38, 0x66, 0x65, 0x35, 0x38, 0x30, 0x64, 0x38, 0x62, 0x33, 0x36, 0x62, 0x38, 0x38, 0x63, 0x38, 0x63, 0x30, 0x37, 0x31, 0x66, 0x39, 0x31, 0x34, 0x38, 0x64, 0x30, 0x37, 0x33, 0x65, 0x33, 0x66, 0x61, 0x34, 0x62, 0x30, 0x61, 0x37, 0x65, 0x66, 0x66, 0x39, 0x38, 0x39, 0x38, 0x37, 0x34, 0x34, 0x61, 0x33, 0x31, 0x65, 0x62, 0x63, 0x37, 0x34, 0x64, 0x32, 0x39, 0x38, 0x35, 0x35, 0x63, 0x39, 0x32, 0x64, 0x62, 0x38, 0x39, 0x32, 0x64, 0x31, 0x31, 0x33, 0x64, 0x36, 0x65, 0x35, 0x33, 0x33, 0x65, 0x35, 0x30, 0x33, 0x34, 0x65, 0x37, 0x32, 0x62, 0x36, 0x61, 0x31, 0x39, 0x65, 0x37, 0x62, 0x36, 0x64, 0x30, 0x62, 0x63, 0x61, 0x37, 0x30, 0x37, 0x66, 0x65, 0x31, 0x65, 0x62, 0x65, 0x65, 0x66, 0x32, 0x31, 0x36, 0x61, 0x61, 0x37, 0x31, 0x34, 0x37, 0x33, 0x33, 0x30, 0x63, 0x33, 0x35, 0x32, 0x37, 0x65, 0x63, 0x65, 0x34, 0x65, 0x62, 0x30, 0x31, 0x35, 0x66, 0x39, 0x36, 0x35, 0x62, 0x36, 0x31, 0x62, 0x39, 0x33, 0x62, 0x37, 0x32, 0x35, 0x34, 0x64, 0x65, 0x31, 0x66, 0x31, 0x61, 0x61, 0x31, 0x61, 0x35, 0x61, 0x36, 0x38, 0x37, 0x61, 0x31, 0x31, 0x37, 0x30, 0x65, 0x35, 0x39, 0x62, 0x61, 0x36, 0x36, 0x38, 0x30, 0x33, 0x35, 0x38, 0x65, 0x32, 0x32, 0x31, 0x65, 0x31, 0x36, 0x65, 0x38, 0x31, 0x30, 0x31, 0x33, 0x61, 0x34, 0x63, 0x62, 0x66, 0x65, 0x32, 0x31, 0x34, 0x30, 0x64, 0x30, 0x34, 0x62, 0x39, 0x32, 0x30, 0x32, 0x31, 0x64, 0x37, 0x39, 0x35, 0x30, 0x35, 0x32, 0x66, 0x33, 0x35, 0x33, 0x31, 0x65, 0x66, 0x65, 0x32, 0x66, 0x30, 0x30, 0x30, 0x34, 0x38, 0x62, 0x38, 0x65, 0x62, 0x66, 0x63, 0x61, 0x36, 0x39, 0x39, 0x37, 0x36, 0x66, 0x66, 0x38, 0x35, 0x33, 0x37, 0x30, 0x30, 0x62, 0x34, 0x63, 0x64, 0x35, 0x66, 0x37, 0x63, 0x64, 0x36, 0x65, 0x32, 0x33, 0x63, 0x36, 0x39, 0x38, 0x62, 0x33, 0x37, 0x32, 0x34, 0x39, 0x34, 0x62, 0x34, 0x33, 0x36, 0x62, 0x36, 0x65, 0x38, 0x37, 0x30, 0x33, 0x64, 0x61, 0x35, 0x36, 0x39, 0x62, 0x65, 0x33, 0x31, 0x31, 0x39, 0x31, 0x36, 0x63, 0x66, 0x65, 0x34, 0x64, 0x35, 0x31, 0x35, 0x30, 0x32, 0x64, 0x63, 0x32, 0x63, 0x39, 0x34, 0x39, 0x65, 0x35, 0x30, 0x65, 0x65, 0x39, 0x63, 0x64, 0x33, 0x31, 0x64, 0x65, 0x35, 0x66, 0x64, 0x37, 0x65, 0x33, 0x37, 0x32, 0x63, 0x64, 0x39, 0x33, 0x36, 0x39, 0x65, 0x32, 0x36, 0x61, 0x35, 0x37, 0x62, 0x33, 0x39, 0x32, 0x65, 0x33, 0x66, 0x31, 0x32, 0x33, 0x37, 0x37, 0x38, 0x31, 0x65, 0x35, 0x35, 0x31, 0x66, 0x35, 0x37, 0x34, 0x64, 0x66, 0x31, 0x35, 0x63, 0x33, 0x35, 0x31, 0x63, 0x30, 0x61, 0x30, 0x61, 0x66, 0x34, 0x32, 0x32, 0x38, 0x36, 0x38, 0x37, 0x37, 0x61, 0x35, 0x38, 0x64, 0x33, 0x39, 0x37, 0x32, 0x36, 0x35, 0x66, 0x66, 0x35, 0x31, 0x65, 0x31, 0x63, 0x63, 0x32, 0x62, 0x34, 0x63, 0x64, 0x61, 0x39, 0x39, 0x65, 0x32, 0x30, 0x31, 0x34, 0x64, 0x65, 0x35, 0x63, 0x62, 0x34, 0x64, 0x62, 0x66, 0x66, 0x61, 0x32, 0x31, 0x63, 0x39, 0x64, 0x35, 0x34, 0x39, 0x61, 0x38, 0x63, 0x61, 0x31, 0x32, 0x62, 0x34, 0x39, 0x34, 0x63, 0x65, 0x65, 0x61, 0x33, 0x63, 0x62, 0x30, 0x38, 0x38, 0x35, 0x36, 0x39, 0x65, 0x61, 0x35, 0x63, 0x32, 0x34, 0x33, 0x64, 0x33, 0x64, 0x31, 0x32, 0x32, 0x31, 0x66, 0x39, 0x61, 0x32, 0x66, 0x65, 0x65, 0x65, 0x38, 0x39, 0x33, 0x34, 0x31, 0x63, 0x64, 0x64, 0x65, 0x65, 0x64, 0x63, 0x38, 0x35, 0x66, 0x34, 0x38, 0x63, 0x63, 0x31, 0x31, 0x38, 0x36, 0x31, 0x32, 0x31, 0x63, 0x32, 0x64, 0x66, 0x66, 0x62, 0x66, 0x33, 0x33, 0x35, 0x64, 0x36, 0x64, 0x37, 0x32, 0x31, 0x34, 0x35, 0x31, 0x31, 0x31, 0x65, 0x35, 0x31, 0x32, 0x38, 0x63, 0x30, 0x66, 0x30, 0x66, 0x30, 0x66, 0x39, 0x64, 0x31, 0x33, 0x32, 0x34, 0x30, 0x34, 0x31, 0x34, 0x66, 0x66, 0x34, 0x63, 0x63, 0x61, 0x66, 0x66, 0x61, 0x37, 0x32, 0x64, 0x33, 0x32, 0x37, 0x30, 0x32, 0x35, 0x38, 0x64, 0x34, 0x39, 0x66, 0x32, 0x38, 0x36, 0x36, 0x35, 0x34, 0x33, 0x62, 0x33, 0x31, 0x62, 0x37, 0x32, 0x35, 0x62, 0x31, 0x64, 0x32, 0x39, 0x63, 0x32, 0x34, 0x63, 0x37, 0x61, 0x35, 0x64, 0x64, 0x32, 0x64, 0x34, 0x37, 0x64, 0x31, 0x30, 0x63, 0x35, 0x65, 0x66, 0x31, 0x35, 0x64, 0x37, 0x38, 0x65, 0x39, 0x64, 0x34, 0x30, 0x39, 0x32, 0x39, 0x37, 0x33, 0x62, 0x66, 0x36, 0x63, 0x38, 0x35, 0x30, 0x35, 0x63, 0x61, 0x66, 0x63, 0x32, 0x61, 0x64, 0x31, 0x63, 0x66, 0x31, 0x61, 0x37, 0x33, 0x62, 0x61, 0x31, 0x34, 0x65, 0x66, 0x62, 0x61, 0x30, 0x66, 0x31, 0x63, 0x33, 0x65, 0x65, 0x65, 0x35, 0x66, 0x36, 0x31, 0x30, 0x32, 0x33, 0x38, 0x34, 0x63, 0x33, 0x65, 0x33, 0x35, 0x34, 0x38, 0x66, 0x33, 0x38, 0x64, 0x64, 0x33, 0x33, 0x35, 0x30, 0x65, 0x30, 0x36, 0x37, 0x63, 0x34, 0x37, 0x61, 0x33, 0x32, 0x61, 0x34, 0x66, 0x37, 0x64, 0x66, 0x35, 0x39, 0x35, 0x35, 0x31, 0x36, 0x37, 0x32, 0x32, 0x34, 0x30, 0x65, 0x31, 0x38, 0x66, 0x30, 0x32, 0x61, 0x63, 0x65, 0x65, 0x31, 0x61, 0x33, 0x63, 0x34, 0x62, 0x62, 0x39, 0x35, 0x34, 0x64, 0x38, 0x38, 0x62, 0x39, 0x32, 0x39, 0x66, 0x32, 0x36, 0x38, 0x36, 0x33, 0x65, 0x65, 0x38, 0x34, 0x65, 0x35, 0x32, 0x63, 0x35, 0x65, 0x36, 0x38, 0x32, 0x35, 0x31, 0x39, 0x38, 0x64, 0x35, 0x31, 0x66, 0x31, 0x35, 0x65, 0x66, 0x64, 0x37, 0x32, 0x34, 0x62, 0x34, 0x32, 0x36, 0x38, 0x61, 0x33, 0x30, 0x61, 0x65, 0x35, 0x39, 0x65, 0x31, 0x39, 0x38, 0x63, 0x36, 0x39, 0x30, 0x36, 0x64, 0x65, 0x37, 0x62, 0x62, 0x32, 0x30, 0x34, 0x35, 0x38, 0x31, 0x33, 0x30, 0x34, 0x36, 0x64, 0x33, 0x66, 0x37, 0x64, 0x64, 0x64, 0x32, 0x36, 0x37, 0x33, 0x66, 0x65, 0x30, 0x32, 0x66, 0x33, 0x66, 0x33, 0x38, 0x30, 0x32, 0x33, 0x61, 0x32, 0x37, 0x32, 0x36, 0x34, 0x38, 0x33, 0x65, 0x65, 0x31, 0x37, 0x62, 0x30, 0x61, 0x39, 0x31, 0x32, 0x31, 0x64, 0x34, 0x39, 0x33, 0x38, 0x31, 0x37, 0x37, 0x62, 0x64, 0x66, 0x31, 0x66, 0x65, 0x66, 0x34, 0x62, 0x62, 0x61, 0x38, 0x38, 0x38, 0x63, 0x31, 0x39, 0x63, 0x33, 0x31, 0x36, 0x63, 0x30, 0x31, 0x30, 0x65, 0x33, 0x37, 0x32, 0x33, 0x61, 0x36, 0x33, 0x64, 0x30, 0x32, 0x62, 0x38, 0x64, 0x37, 0x32, 0x38, 0x32, 0x66, 0x63, 0x64, 0x35, 0x32, 0x39, 0x30, 0x61, 0x65, 0x34, 0x65, 0x31, 0x30, 0x34, 0x66, 0x63, 0x66, 0x36, 0x36, 0x34, 0x36, 0x38, 0x36, 0x36, 0x61, 0x38, 0x31, 0x64, 0x63, 0x64, 0x35, 0x31, 0x65, 0x38, 0x36, 0x65, 0x63, 0x37, 0x39, 0x62, 0x62, 0x62, 0x35, 0x34, 0x31, 0x36, 0x66, 0x33, 0x62, 0x32, 0x32, 0x34, 0x63, 0x63, 0x35, 0x65, 0x62, 0x35, 0x38, 0x64, 0x35, 0x66, 0x61, 0x65, 0x34, 0x30, 0x63, 0x65, 0x36, 0x38, 0x34, 0x61, 0x37, 0x33, 0x32, 0x38, 0x62, 0x63, 0x30, 0x37, 0x38, 0x35, 0x35, 0x31, 0x62, 0x32, 0x62, 0x32, 0x30, 0x30, 0x37, 0x61, 0x64, 0x65, 0x38, 0x31, 0x62, 0x31, 0x39, 0x39, 0x65, 0x65, 0x35, 0x35, 0x37, 0x33, 0x61, 0x38, 0x35, 0x34, 0x35, 0x37, 0x37, 0x65, 0x32, 0x63, 0x31, 0x61, 0x38, 0x62, 0x31, 0x38, 0x65, 0x38, 0x37, 0x32, 0x61, 0x35, 0x63, 0x32, 0x31, 0x34, 0x39, 0x31, 0x37, 0x62, 0x62, 0x64, 0x35, 0x38, 0x35, 0x63, 0x61, 0x35, 0x35, 0x66, 0x38, 0x36, 0x30, 0x38, 0x65, 0x38, 0x66, 0x32, 0x62, 0x66, 0x62, 0x64, 0x37, 0x63, 0x37, 0x61, 0x64, 0x63, 0x66, 0x33, 0x33, 0x34, 0x35, 0x64, 0x35, 0x33, 0x63, 0x65, 0x30, 0x66, 0x37, 0x30, 0x38, 0x38, 0x37, 0x30, 0x65, 0x39, 0x36, 0x38, 0x66, 0x64, 0x37, 0x32, 0x62, 0x37, 0x34, 0x63, 0x63, 0x65, 0x31, 0x34, 0x38, 0x61, 0x33, 0x61, 0x39, 0x36, 0x30, 0x30, 0x37, 0x31, 0x39, 0x30, 0x62, 0x62, 0x38, 0x61, 0x30, 0x38, 0x39, 0x33, 0x30, 0x34, 0x65, 0x33, 0x64, 0x35, 0x37, 0x36, 0x62, 0x35, 0x38, 0x32, 0x61, 0x31, 0x30, 0x34, 0x39, 0x64, 0x65, 0x37, 0x66, 0x33, 0x32, 0x38, 0x39, 0x34, 0x37, 0x32, 0x61, 0x64, 0x35, 0x32, 0x62, 0x34, 0x35, 0x66, 0x39, 0x34, 0x39, 0x32, 0x62, 0x35, 0x32, 0x61, 0x63, 0x64, 0x63, 0x32, 0x62, 0x63, 0x62, 0x33, 0x63, 0x32, 0x33, 0x35, 0x61, 0x31, 0x35, 0x62, 0x31, 0x65, 0x61, 0x64, 0x66, 0x37, 0x36, 0x38, 0x36, 0x35, 0x33, 0x37, 0x32, 0x34, 0x39, 0x31, 0x38, 0x36, 0x31, 0x61, 0x38, 0x62, 0x37, 0x65, 0x36, 0x31, 0x32, 0x37, 0x65, 0x33, 0x63, 0x31, 0x32, 0x32, 0x35, 0x31, 0x35, 0x35, 0x37, 0x32, 0x61, 0x31, 0x31, 0x38, 0x30, 0x34, 0x64, 0x65, 0x36, 0x63, 0x62, 0x33, 0x35, 0x63, 0x66, 0x65, 0x65, 0x32, 0x63, 0x61, 0x61, 0x62, 0x32, 0x62, 0x30, 0x62, 0x37, 0x36, 0x65, 0x63, 0x66, 0x35, 0x32, 0x30, 0x38, 0x63, 0x66, 0x64, 0x64, 0x65, 0x36, 0x39, 0x34, 0x36, 0x65, 0x30, 0x65, 0x34, 0x38, 0x62, 0x37, 0x34, 0x66, 0x61, 0x38, 0x65, 0x35, 0x61, 0x35, 0x66, 0x31, 0x35, 0x32, 0x35, 0x33, 0x63, 0x31, 0x37, 0x61, 0x32, 0x33, 0x62, 0x39, 0x30, 0x32, 0x34, 0x35, 0x30, 0x37, 0x66, 0x32, 0x30, 0x66, 0x36, 0x64, 0x36, 0x32, 0x38, 0x63, 0x62, 0x61, 0x35, 0x31, 0x63, 0x35, 0x64, 0x62, 0x35, 0x31, 0x64, 0x63, 0x63, 0x31, 0x61, 0x35, 0x66, 0x31, 0x62, 0x30, 0x31, 0x32, 0x63, 0x65, 0x37, 0x32, 0x63, 0x31, 0x66, 0x30, 0x62, 0x33, 0x66, 0x39, 0x30, 0x30, 0x32, 0x37, 0x32, 0x63, 0x65, 0x35, 0x66, 0x63, 0x38, 0x38, 0x66, 0x38, 0x61, 0x35, 0x34, 0x37, 0x35, 0x37, 0x39, 0x36, 0x61, 0x38, 0x34, 0x66, 0x61, 0x66, 0x34, 0x64, 0x39, 0x32, 0x62, 0x30, 0x61, 0x64, 0x38, 0x62, 0x31, 0x36, 0x64, 0x34, 0x36, 0x62, 0x36, 0x39, 0x38, 0x35, 0x37, 0x37, 0x33, 0x63, 0x36, 0x33, 0x30, 0x36, 0x62, 0x37, 0x32, 0x32, 0x61, 0x62, 0x35, 0x37, 0x31, 0x61, 0x39, 0x37, 0x32, 0x63, 0x62, 0x33, 0x33, 0x36, 0x61, 0x30, 0x31, 0x61, 0x62, 0x61, 0x38, 0x61, 0x36, 0x38, 0x64, 0x39, 0x65, 0x61, 0x32, 0x37, 0x63, 0x32, 0x31, 0x61, 0x33, 0x61, 0x63, 0x39, 0x66, 0x61, 0x66, 0x62, 0x65, 0x66, 0x63, 0x63, 0x62, 0x36, 0x37, 0x38, 0x34, 0x36, 0x33, 0x33, 0x62, 0x65, 0x65, 0x31, 0x38, 0x61, 0x61, 0x63, 0x34, 0x38, 0x36, 0x34, 0x30, 0x66, 0x66, 0x62, 0x64, 0x34, 0x31, 0x62, 0x61, 0x39, 0x30, 0x65, 0x34, 0x39, 0x30, 0x35, 0x63, 0x39, 0x61, 0x61, 0x30, 0x37, 0x38, 0x32, 0x35, 0x37, 0x66, 0x64, 0x63, 0x61, 0x37, 0x39, 0x33, 0x65, 0x33, 0x62, 0x65, 0x38, 0x31, 0x32, 0x30, 0x39, 0x37, 0x31, 0x35, 0x31, 0x31, 0x32, 0x37, 0x65, 0x30, 0x65, 0x64, 0x36, 0x31, 0x33, 0x66, 0x61, 0x35, 0x30, 0x63, 0x61, 0x64, 0x34, 0x66, 0x39, 0x62, 0x32, 0x31, 0x35, 0x35, 0x64, 0x61, 0x34, 0x64, 0x36, 0x64, 0x35, 0x35, 0x34, 0x62, 0x38, 0x30, 0x36, 0x36, 0x35, 0x35, 0x61, 0x31, 0x35, 0x37, 0x66, 0x66, 0x65, 0x39, 0x62, 0x31, 0x38, 0x37, 0x35, 0x37, 0x36, 0x32, 0x33, 0x61, 0x31, 0x64, 0x38, 0x63, 0x65, 0x38, 0x36, 0x64, 0x61, 0x37, 0x36, 0x36, 0x30, 0x35, 0x30, 0x39, 0x39, 0x32, 0x36, 0x33, 0x66, 0x61, 0x37, 0x63, 0x31, 0x33, 0x65, 0x36, 0x37, 0x32, 0x65, 0x61, 0x37, 0x34, 0x63, 0x32, 0x65, 0x34, 0x61, 0x61, 0x63, 0x32, 0x37, 0x31, 0x35, 0x34, 0x30, 0x33, 0x62, 0x64, 0x34, 0x64, 0x37, 0x34, 0x35, 0x39, 0x30, 0x33, 0x38, 0x30, 0x66, 0x39, 0x38, 0x64, 0x37, 0x35, 0x31, 0x64, 0x31, 0x39, 0x65, 0x31, 0x37, 0x36, 0x64, 0x61, 0x39, 0x36, 0x33, 0x38, 0x32, 0x36, 0x62, 0x37, 0x61, 0x35, 0x35, 0x30, 0x31, 0x30, 0x32, 0x36, 0x37, 0x32, 0x32, 0x36, 0x34, 0x38, 0x30, 0x39, 0x37, 0x64, 0x62, 0x64, 0x65, 0x66, 0x65, 0x65, 0x39, 0x30, 0x62, 0x61, 0x30, 0x61, 0x39, 0x36, 0x34, 0x39, 0x64, 0x32, 0x30, 0x36, 0x32, 0x65, 0x33, 0x33, 0x36, 0x61, 0x38, 0x33, 0x61, 0x34, 0x34, 0x62, 0x31, 0x32, 0x64, 0x62, 0x62, 0x30, 0x38, 0x32, 0x30, 0x66, 0x39, 0x34, 0x34, 0x64, 0x32, 0x36, 0x34, 0x36, 0x63, 0x32, 0x61, 0x37, 0x36, 0x64, 0x33, 0x66, 0x63, 0x39, 0x31, 0x35, 0x63, 0x61, 0x62, 0x36, 0x65, 0x35, 0x66, 0x63, 0x35, 0x62, 0x66, 0x35, 0x37, 0x65, 0x65, 0x39, 0x39, 0x37, 0x33, 0x31, 0x33, 0x65, 0x63, 0x39, 0x64, 0x38, 0x31, 0x34, 0x63, 0x64, 0x31, 0x61, 0x31, 0x37, 0x39, 0x66, 0x37, 0x39, 0x35, 0x64, 0x34, 0x39, 0x64, 0x31, 0x65, 0x61, 0x66, 0x30, 0x30, 0x37, 0x30, 0x63, 0x63, 0x33, 0x32, 0x37, 0x30, 0x63, 0x61, 0x66, 0x39, 0x66, 0x35, 0x66, 0x33, 0x32, 0x64, 0x30, 0x63, 0x37, 0x36, 0x31, 0x30, 0x38, 0x36, 0x39, 0x36, 0x30, 0x35, 0x31, 0x61, 0x63, 0x65, 0x33, 0x39, 0x37, 0x37, 0x61, 0x30, 0x32, 0x30, 0x37, 0x34, 0x37, 0x31, 0x32, 0x66, 0x64, 0x32, 0x30, 0x33, 0x32, 0x37, 0x39, 0x34, 0x64, 0x34, 0x30, 0x34, 0x34, 0x66, 0x34, 0x39, 0x34, 0x66, 0x38, 0x65, 0x39, 0x64, 0x32, 0x35, 0x65, 0x39, 0x36, 0x65, 0x66, 0x39, 0x63, 0x39, 0x38, 0x33, 0x32, 0x30, 0x34, 0x62, 0x66, 0x39, 0x38, 0x35, 0x31, 0x38, 0x38, 0x61, 0x63, 0x61, 0x65, 0x36, 0x64, 0x30, 0x66, 0x61, 0x32, 0x32, 0x61, 0x62, 0x36, 0x33, 0x38, 0x66, 0x61, 0x63, 0x35, 0x65, 0x34, 0x36, 0x63, 0x65, 0x65, 0x31, 0x30, 0x30, 0x61, 0x36, 0x65, 0x65, 0x63, 0x36, 0x35, 0x63, 0x64, 0x34, 0x37, 0x35, 0x32, 0x30, 0x61, 0x64, 0x32, 0x31, 0x37, 0x33, 0x32, 0x63, 0x39, 0x62, 0x66, 0x34, 0x35, 0x35, 0x32, 0x34, 0x36, 0x32, 0x66, 0x64, 0x61, 0x32, 0x38, 0x33, 0x34, 0x36, 0x64, 0x64, 0x34, 0x33, 0x38, 0x35, 0x30, 0x34, 0x36, 0x37, 0x38, 0x65, 0x62, 0x66, 0x66, 0x64, 0x31, 0x35, 0x30, 0x37, 0x31, 0x31, 0x66, 0x64, 0x65, 0x31, 0x35, 0x62, 0x61, 0x35, 0x37, 0x31, 0x33, 0x33, 0x39, 0x31, 0x63, 0x37, 0x32, 0x37, 0x66, 0x32, 0x65, 0x34, 0x63, 0x38, 0x35, 0x65, 0x64, 0x63, 0x36, 0x65, 0x37, 0x39, 0x35, 0x66, 0x66, 0x35, 0x32, 0x39, 0x39, 0x34, 0x37, 0x34, 0x61, 0x62, 0x33, 0x35, 0x64, 0x33, 0x33, 0x66, 0x36, 0x64, 0x63, 0x34, 0x30, 0x34, 0x37, 0x39, 0x63, 0x64, 0x34, 0x31, 0x63, 0x36, 0x37, 0x38, 0x63, 0x65, 0x31, 0x37, 0x39, 0x61, 0x62, 0x63, 0x39, 0x32, 0x34, 0x37, 0x63, 0x33, 0x62, 0x30, 0x39, 0x39, 0x33, 0x32, 0x61, 0x65, 0x34, 0x38, 0x32, 0x61, 0x34, 0x38, 0x38, 0x34, 0x30, 0x61, 0x30, 0x61, 0x62, 0x62, 0x30, 0x61, 0x31, 0x62, 0x39, 0x34, 0x66, 0x63, 0x65, 0x36, 0x62, 0x36, 0x64, 0x35, 0x34, 0x35, 0x34, 0x61, 0x31, 0x63, 0x64, 0x64, 0x32, 0x62, 0x33, 0x66, 0x65, 0x30, 0x32, 0x64, 0x63, 0x62, 0x36, 0x35, 0x36, 0x61, 0x63, 0x38, 0x65, 0x61, 0x62, 0x35, 0x34, 0x37, 0x33, 0x63, 0x62, 0x33, 0x31, 0x35, 0x64, 0x62, 0x64, 0x63, 0x61, 0x38, 0x62, 0x65, 0x62, 0x66, 0x61, 0x34, 0x32, 0x61, 0x65, 0x35, 0x31, 0x32, 0x39, 0x63, 0x36, 0x65, 0x62, 0x66, 0x35, 0x30, 0x30, 0x61, 0x33, 0x37, 0x62, 0x63, 0x65, 0x65, 0x65, 0x31, 0x66, 0x31, 0x66, 0x64, 0x37, 0x37, 0x31, 0x31, 0x63, 0x38, 0x30, 0x63, 0x61, 0x36, 0x36, 0x36, 0x37, 0x36, 0x37, 0x35, 0x30, 0x63, 0x63, 0x32, 0x36, 0x34, 0x39, 0x31, 0x31, 0x61, 0x34, 0x66, 0x36, 0x35, 0x36, 0x65, 0x38, 0x66, 0x34, 0x38, 0x30, 0x61, 0x65, 0x33, 0x31, 0x62, 0x65, 0x61, 0x66, 0x62, 0x34, 0x34, 0x38, 0x32, 0x64, 0x65, 0x65, 0x38, 0x64, 0x63, 0x35, 0x39, 0x31, 0x39, 0x30, 0x63, 0x31, 0x35, 0x34, 0x62, 0x39, 0x63, 0x64, 0x38, 0x39, 0x34, 0x34, 0x63, 0x32, 0x32, 0x39, 0x31, 0x34, 0x32, 0x39, 0x64, 0x38, 0x62, 0x37, 0x65, 0x32, 0x32, 0x36, 0x65, 0x39, 0x34, 0x64, 0x66, 0x39, 0x31, 0x64, 0x61, 0x32, 0x35, 0x62, 0x38, 0x63, 0x37, 0x34, 0x37, 0x34, 0x36, 0x33, 0x35, 0x31, 0x35, 0x65, 0x31, 0x34, 0x30, 0x33, 0x31, 0x33, 0x62, 0x39, 0x38, 0x64, 0x31, 0x31, 0x61, 0x39, 0x35, 0x33, 0x39, 0x65, 0x61, 0x62, 0x35, 0x32, 0x37, 0x33, 0x38, 0x64, 0x30, 0x38, 0x31, 0x31, 0x31, 0x61, 0x33, 0x66, 0x31, 0x38, 0x31, 0x32, 0x37, 0x38, 0x62, 0x36, 0x37, 0x66, 0x33, 0x37, 0x30, 0x61, 0x64, 0x61, 0x62, 0x63, 0x35, 0x38, 0x36, 0x32, 0x30, 0x39, 0x61, 0x37, 0x37, 0x30, 0x64, 0x32, 0x32, 0x64, 0x62, 0x61, 0x61, 0x38, 0x35, 0x32, 0x31, 0x34, 0x36, 0x33, 0x33, 0x34, 0x39, 0x39, 0x36, 0x61, 0x39, 0x63, 0x36, 0x37, 0x36, 0x35, 0x66, 0x35, 0x33, 0x35, 0x36, 0x31, 0x37, 0x32, 0x63, 0x34, 0x37, 0x32, 0x37, 0x37, 0x31, 0x33, 0x33, 0x66, 0x66, 0x37, 0x37, 0x61, 0x36, 0x34, 0x31, 0x31, 0x30, 0x35, 0x32, 0x38, 0x38, 0x64, 0x31, 0x32, 0x33, 0x33, 0x62, 0x38, 0x33, 0x35, 0x66, 0x31, 0x33, 0x64, 0x34, 0x32, 0x38, 0x64, 0x34, 0x38, 0x37, 0x65, 0x65, 0x32, 0x33, 0x34, 0x30, 0x34, 0x31, 0x33, 0x39, 0x61, 0x33, 0x30, 0x62, 0x64, 0x34, 0x31, 0x32, 0x32, 0x34, 0x35, 0x37, 0x31, 0x62, 0x61, 0x35, 0x37, 0x36, 0x64, 0x38, 0x34, 0x63, 0x37, 0x39, 0x62, 0x37, 0x62, 0x62, 0x66, 0x38, 0x31, 0x30, 0x39, 0x36, 0x39, 0x64, 0x64, 0x33, 0x62, 0x63, 0x36, 0x61, 0x30, 0x66, 0x62, 0x32, 0x64, 0x31, 0x62, 0x65, 0x34, 0x62, 0x33, 0x33, 0x39, 0x64, 0x33, 0x65, 0x37, 0x34, 0x65, 0x35, 0x34, 0x61, 0x37, 0x36, 0x66, 0x39, 0x34, 0x38, 0x62, 0x62, 0x65, 0x35, 0x30, 0x63, 0x32, 0x36, 0x34, 0x63, 0x61, 0x61, 0x66, 0x63, 0x35, 0x66, 0x31, 0x36, 0x61, 0x34, 0x37, 0x64, 0x63, 0x31, 0x36, 0x34, 0x35, 0x32, 0x62, 0x34, 0x61, 0x33, 0x63, 0x39, 0x35, 0x63, 0x36, 0x63, 0x36, 0x65, 0x37, 0x32, 0x64, 0x65, 0x62, 0x65, 0x61, 0x63, 0x33, 0x35, 0x33, 0x63, 0x37, 0x31, 0x62, 0x64, 0x63, 0x33, 0x36, 0x31, 0x36, 0x37, 0x32, 0x37, 0x37, 0x63, 0x30, 0x34, 0x38, 0x36, 0x34, 0x36, 0x65, 0x66, 0x35, 0x65, 0x62, 0x33, 0x31, 0x32, 0x64, 0x62, 0x39, 0x62, 0x32, 0x32, 0x64, 0x66, 0x63, 0x66, 0x35, 0x38, 0x64, 0x38, 0x62, 0x38, 0x34, 0x33, 0x61, 0x62, 0x65, 0x37, 0x37, 0x34, 0x37, 0x37, 0x31, 0x39, 0x39, 0x34, 0x35, 0x31, 0x63, 0x33, 0x37, 0x62, 0x31, 0x33, 0x32, 0x38, 0x62, 0x34, 0x65, 0x66, 0x61, 0x35, 0x66, 0x36, 0x66, 0x65, 0x65, 0x35, 0x36, 0x61, 0x31, 0x64, 0x31, 0x64, 0x66, 0x61, 0x30, 0x65, 0x39, 0x65, 0x36, 0x35, 0x35, 0x32, 0x35, 0x38, 0x63, 0x36, 0x61, 0x64, 0x37, 0x62, 0x66, 0x62, 0x30, 0x39, 0x39, 0x30, 0x36, 0x66, 0x34, 0x62, 0x66, 0x36, 0x62, 0x39, 0x63, 0x62, 0x35, 0x63, 0x38, 0x36, 0x65, 0x31, 0x32, 0x35, 0x31, 0x31, 0x35, 0x65, 0x39, 0x30, 0x33, 0x37, 0x30, 0x61, 0x35, 0x37, 0x63, 0x65, 0x30, 0x37, 0x32, 0x62, 0x34, 0x38, 0x35, 0x36, 0x35, 0x37, 0x65, 0x64, 0x35, 0x38, 0x37, 0x36, 0x30, 0x36, 0x66, 0x30, 0x66, 0x30, 0x30, 0x33, 0x65, 0x63, 0x36, 0x62, 0x62, 0x37, 0x37, 0x66, 0x31, 0x31, 0x38, 0x31, 0x36, 0x37, 0x64, 0x65, 0x64, 0x33, 0x34, 0x31, 0x61, 0x36, 0x34, 0x31, 0x62, 0x36, 0x31, 0x31, 0x35, 0x36, 0x31, 0x66, 0x34, 0x30, 0x61, 0x33, 0x34, 0x63, 0x64, 0x37, 0x31, 0x37, 0x32, 0x61, 0x66, 0x64, 0x62, 0x64, 0x62, 0x35, 0x32, 0x65, 0x65, 0x39, 0x31, 0x39, 0x64, 0x61, 0x33, 0x38, 0x30, 0x33, 0x38, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x64, 0x35, 0x32, 0x62, 0x37, 0x39, 0x62, 0x65, 0x32, 0x37, 0x30, 0x30, 0x34, 0x66, 0x62, 0x64, 0x34, 0x32, 0x33, 0x34, 0x61, 0x66, 0x33, 0x36, 0x32, 0x63, 0x32, 0x65, 0x36, 0x33, 0x37, 0x32, 0x31, 0x31, 0x33, 0x66, 0x32, 0x33, 0x34, 0x66, 0x38, 0x31, 0x38, 0x31, 0x66, 0x63, 0x30, 0x65, 0x36, 0x64, 0x62, 0x30, 0x39, 0x33, 0x38, 0x32, 0x32, 0x65, 0x65, 0x64, 0x66, 0x31, 0x33, 0x62, 0x66, 0x32, 0x34, 0x66, 0x65, 0x35, 0x62, 0x39, 0x65, 0x34, 0x64, 0x34, 0x61, 0x34, 0x33, 0x61, 0x63, 0x36, 0x61, 0x35, 0x65, 0x63, 0x38, 0x66, 0x30, 0x33, 0x65, 0x61, 0x32, 0x31, 0x34, 0x38, 0x32, 0x61, 0x63, 0x62, 0x37, 0x32, 0x30, 0x65, 0x65, 0x30, 0x32, 0x38, 0x34, 0x30, 0x37, 0x31, 0x66, 0x39, 0x38, 0x62, 0x36, 0x34, 0x37, 0x66, 0x65, 0x36, 0x66, 0x31, 0x63, 0x32, 0x35, 0x35, 0x38, 0x32, 0x66, 0x30, 0x34, 0x37, 0x63, 0x37, 0x62, 0x34, 0x64, 0x61, 0x64, 0x35, 0x39, 0x30, 0x35, 0x31, 0x61, 0x61, 0x37, 0x63, 0x37, 0x63, 0x65, 0x66, 0x35, 0x65, 0x32, 0x66, 0x37, 0x65, 0x63, 0x62, 0x62, 0x64, 0x36, 0x39, 0x31, 0x62, 0x34, 0x34, 0x61, 0x32, 0x61, 0x38, 0x63, 0x62, 0x33, 0x36, 0x66, 0x63, 0x61, 0x62, 0x31, 0x64, 0x66, 0x39, 0x63, 0x39, 0x30, 0x34, 0x37, 0x61, 0x32, 0x38, 0x64, 0x32, 0x37, 0x37, 0x38, 0x34, 0x31, 0x66, 0x35, 0x63, 0x36, 0x34, 0x62, 0x34, 0x32, 0x37, 0x37, 0x37, 0x36, 0x34, 0x36, 0x38, 0x63, 0x30, 0x30, 0x32, 0x38, 0x38, 0x37, 0x37, 0x37, 0x31, 0x30, 0x34, 0x37, 0x32, 0x64, 0x65, 0x36, 0x64, 0x32, 0x35, 0x32, 0x30, 0x65, 0x30, 0x35, 0x33, 0x31, 0x62, 0x64, 0x32, 0x33, 0x39, 0x34, 0x62, 0x35, 0x61, 0x31, 0x32, 0x31, 0x39, 0x31, 0x31, 0x37, 0x34, 0x30, 0x61, 0x33, 0x63, 0x33, 0x32, 0x38, 0x33, 0x38, 0x39, 0x33, 0x62, 0x36, 0x31, 0x39, 0x65, 0x37, 0x64, 0x64, 0x34, 0x31, 0x63, 0x31, 0x39, 0x31, 0x64, 0x64, 0x30, 0x64, 0x38, 0x65, 0x64, 0x37, 0x32, 0x37, 0x61, 0x64, 0x36, 0x61, 0x34, 0x32, 0x34, 0x36, 0x37, 0x31, 0x37, 0x38, 0x31, 0x37, 0x66, 0x65, 0x36, 0x33, 0x33, 0x33, 0x34, 0x35, 0x36, 0x62, 0x65, 0x36, 0x63, 0x30, 0x66, 0x66, 0x30, 0x38, 0x35, 0x32, 0x63, 0x36, 0x32, 0x33, 0x62, 0x34, 0x33, 0x66, 0x32, 0x63, 0x64, 0x66, 0x62, 0x61, 0x36, 0x64, 0x33, 0x66, 0x64, 0x66, 0x66, 0x62, 0x61, 0x39, 0x31, 0x33, 0x38, 0x31, 0x63, 0x34, 0x38, 0x62, 0x34, 0x31, 0x37, 0x39, 0x37, 0x32, 0x35, 0x30, 0x37, 0x34, 0x33, 0x64, 0x62, 0x62, 0x39, 0x33, 0x66, 0x65, 0x62, 0x38, 0x62, 0x64, 0x31, 0x38, 0x62, 0x64, 0x64, 0x30, 0x62, 0x30, 0x31, 0x36, 0x63, 0x33, 0x34, 0x62, 0x62, 0x34, 0x39, 0x35, 0x33, 0x35, 0x36, 0x64, 0x61, 0x32, 0x66, 0x63, 0x31, 0x33, 0x36, 0x31, 0x30, 0x62, 0x66, 0x37, 0x66, 0x35, 0x61, 0x37, 0x32, 0x37, 0x30, 0x63, 0x33, 0x66, 0x66, 0x66, 0x33, 0x61, 0x64, 0x62, 0x33, 0x37, 0x33, 0x66, 0x39, 0x36, 0x33, 0x31, 0x31, 0x39, 0x62, 0x33, 0x62, 0x30, 0x31, 0x64, 0x65, 0x62, 0x30, 0x38, 0x66, 0x35, 0x32, 0x62, 0x66, 0x30, 0x63, 0x36, 0x66, 0x36, 0x36, 0x64, 0x38, 0x31, 0x38, 0x66, 0x35, 0x32, 0x66, 0x36, 0x66, 0x66, 0x32, 0x62, 0x61, 0x63, 0x32, 0x37, 0x62, 0x62, 0x30, 0x32, 0x36, 0x65, 0x38, 0x34, 0x66, 0x33, 0x38, 0x61, 0x34, 0x34, 0x31, 0x37, 0x33, 0x64, 0x64, 0x34, 0x38, 0x36, 0x66, 0x34, 0x31, 0x65, 0x66, 0x31, 0x32, 0x34, 0x33, 0x38, 0x34, 0x63, 0x36, 0x35, 0x64, 0x65, 0x32, 0x35, 0x65, 0x30, 0x63, 0x31, 0x35, 0x32, 0x32, 0x33, 0x62, 0x34, 0x33, 0x65, 0x65, 0x31, 0x34, 0x64, 0x34, 0x62, 0x34, 0x63, 0x61, 0x62, 0x62, 0x61, 0x39, 0x36, 0x34, 0x37, 0x32, 0x33, 0x39, 0x64, 0x35, 0x38, 0x34, 0x38, 0x36, 0x32, 0x33, 0x65, 0x36, 0x61, 0x36, 0x65, 0x38, 0x31, 0x62, 0x32, 0x31, 0x30, 0x39, 0x39, 0x32, 0x38, 0x32, 0x38, 0x31, 0x33, 0x63, 0x63, 0x35, 0x63, 0x30, 0x35, 0x37, 0x65, 0x37, 0x33, 0x66, 0x31, 0x64, 0x39, 0x38, 0x39, 0x38, 0x37, 0x33, 0x65, 0x39, 0x38, 0x32, 0x64, 0x61, 0x66, 0x37, 0x34, 0x35, 0x34, 0x65, 0x36, 0x37, 0x37, 0x32, 0x37, 0x30, 0x34, 0x34, 0x63, 0x32, 0x38, 0x37, 0x37, 0x32, 0x35, 0x38, 0x32, 0x34, 0x38, 0x61, 0x38, 0x31, 0x62, 0x38, 0x61, 0x62, 0x64, 0x34, 0x31, 0x30, 0x31, 0x39, 0x64, 0x30, 0x30, 0x39, 0x32, 0x63, 0x37, 0x39, 0x33, 0x63, 0x31, 0x31, 0x65, 0x33, 0x66, 0x39, 0x65, 0x62, 0x33, 0x36, 0x64, 0x64, 0x63, 0x63, 0x35, 0x61, 0x64, 0x39, 0x31, 0x63, 0x35, 0x32, 0x32, 0x66, 0x36, 0x64, 0x31, 0x33, 0x36, 0x35, 0x66, 0x35, 0x61, 0x63, 0x39, 0x31, 0x34, 0x64, 0x31, 0x65, 0x36, 0x63, 0x63, 0x33, 0x31, 0x64, 0x63, 0x37, 0x64, 0x31, 0x38, 0x64, 0x32, 0x36, 0x66, 0x64, 0x30, 0x66, 0x38, 0x31, 0x31, 0x33, 0x63, 0x65, 0x61, 0x66, 0x31, 0x63, 0x38, 0x65, 0x37, 0x35, 0x66, 0x31, 0x35, 0x32, 0x35, 0x66, 0x33, 0x66, 0x66, 0x61, 0x65, 0x35, 0x63, 0x32, 0x36, 0x31, 0x32, 0x66, 0x63, 0x33, 0x64, 0x30, 0x62, 0x36, 0x61, 0x62, 0x31, 0x30, 0x36, 0x63, 0x36, 0x61, 0x38, 0x37, 0x65, 0x31, 0x30, 0x32, 0x36, 0x30, 0x61, 0x65, 0x35, 0x39, 0x66, 0x37, 0x39, 0x36, 0x38, 0x38, 0x65, 0x64, 0x33, 0x39, 0x37, 0x31, 0x64, 0x62, 0x33, 0x35, 0x39, 0x31, 0x36, 0x36, 0x66, 0x30, 0x65, 0x64, 0x61, 0x35, 0x31, 0x35, 0x39, 0x36, 0x64, 0x34, 0x64, 0x66, 0x63, 0x37, 0x35, 0x39, 0x31, 0x34, 0x32, 0x31, 0x64, 0x63, 0x61, 0x33, 0x65, 0x37, 0x66, 0x65, 0x34, 0x35, 0x32, 0x34, 0x62, 0x64, 0x35, 0x31, 0x64, 0x61, 0x32, 0x30, 0x34, 0x66, 0x30, 0x61, 0x62, 0x66, 0x35, 0x61, 0x33, 0x61, 0x33, 0x39, 0x36, 0x66, 0x65, 0x34, 0x31, 0x63, 0x62, 0x36, 0x34, 0x30, 0x30, 0x30, 0x35, 0x37, 0x65, 0x63, 0x31, 0x61, 0x63, 0x38, 0x61, 0x31, 0x61, 0x30, 0x32, 0x61, 0x35, 0x36, 0x32, 0x30, 0x35, 0x65, 0x65, 0x37, 0x33, 0x61, 0x63, 0x62, 0x39, 0x32, 0x36, 0x66, 0x34, 0x65, 0x30, 0x62, 0x30, 0x38, 0x36, 0x34, 0x64, 0x33, 0x36, 0x64, 0x63, 0x62, 0x38, 0x62, 0x38, 0x35, 0x39, 0x31, 0x30, 0x34, 0x63, 0x36, 0x65, 0x35, 0x32, 0x35, 0x35, 0x31, 0x62, 0x32, 0x39, 0x35, 0x37, 0x63, 0x31, 0x33, 0x36, 0x37, 0x61, 0x61, 0x63, 0x63, 0x62, 0x65, 0x34, 0x39, 0x31, 0x66, 0x39, 0x65, 0x62, 0x31, 0x38, 0x36, 0x61, 0x35, 0x65, 0x34, 0x32, 0x62, 0x66, 0x38, 0x61, 0x64, 0x65, 0x63, 0x33, 0x66, 0x66, 0x30, 0x34, 0x65, 0x65, 0x65, 0x34, 0x37, 0x37, 0x65, 0x34, 0x33, 0x66, 0x31, 0x66, 0x37, 0x62, 0x62, 0x39, 0x65, 0x64, 0x36, 0x63, 0x34, 0x38, 0x30, 0x35, 0x33, 0x63, 0x32, 0x36, 0x66, 0x62, 0x34, 0x39, 0x35, 0x38, 0x64, 0x38, 0x35, 0x38, 0x31, 0x37, 0x32, 0x35, 0x62, 0x36, 0x63, 0x65, 0x65, 0x62, 0x33, 0x65, 0x32, 0x65, 0x34, 0x63, 0x62, 0x35, 0x36, 0x34, 0x34, 0x63, 0x31, 0x30, 0x63, 0x32, 0x38, 0x35, 0x34, 0x39, 0x65, 0x66, 0x61, 0x62, 0x62, 0x30, 0x34, 0x35, 0x35, 0x65, 0x38, 0x62, 0x32, 0x30, 0x37, 0x63, 0x35, 0x35, 0x34, 0x37, 0x61, 0x39, 0x61, 0x34, 0x63, 0x32, 0x31, 0x33, 0x62, 0x30, 0x36, 0x31, 0x66, 0x64, 0x39, 0x37, 0x32, 0x37, 0x61, 0x32, 0x36, 0x38, 0x34, 0x66, 0x64, 0x30, 0x62, 0x65, 0x66, 0x39, 0x33, 0x37, 0x64, 0x38, 0x30, 0x36, 0x34, 0x64, 0x66, 0x35, 0x63, 0x36, 0x31, 0x36, 0x62, 0x30, 0x64, 0x32, 0x39, 0x36, 0x30, 0x30, 0x66, 0x33, 0x32, 0x37, 0x39, 0x66, 0x66, 0x62, 0x32, 0x31, 0x65, 0x32, 0x36, 0x32, 0x66, 0x38, 0x36, 0x34, 0x38, 0x32, 0x34, 0x63, 0x38, 0x34, 0x65, 0x66, 0x39, 0x30, 0x36, 0x61, 0x32, 0x64, 0x62, 0x64, 0x62, 0x30, 0x32, 0x37, 0x39, 0x31, 0x33, 0x66, 0x61, 0x37, 0x33, 0x39, 0x65, 0x32, 0x35, 0x30, 0x61, 0x39, 0x30, 0x37, 0x31, 0x32, 0x34, 0x33, 0x33, 0x33, 0x30, 0x66, 0x36, 0x39, 0x61, 0x61, 0x32, 0x64, 0x32, 0x30, 0x65, 0x37, 0x31, 0x38, 0x39, 0x39, 0x64, 0x35, 0x39, 0x66, 0x64, 0x37, 0x66, 0x38, 0x32, 0x34, 0x30, 0x62, 0x35, 0x64, 0x61, 0x37, 0x32, 0x63, 0x62, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x63, 0x66, 0x63, 0x37, 0x36, 0x65, 0x36, 0x62, 0x64, 0x33, 0x32, 0x36, 0x65, 0x38, 0x33, 0x39, 0x39, 0x66, 0x31, 0x38, 0x35, 0x63, 0x36, 0x33, 0x39, 0x32, 0x63, 0x37, 0x31, 0x37, 0x65, 0x32, 0x36, 0x38, 0x36, 0x34, 0x64, 0x66, 0x35, 0x37, 0x66, 0x35, 0x66, 0x30, 0x62, 0x35, 0x39, 0x30, 0x64, 0x66, 0x31, 0x37, 0x32, 0x36, 0x37, 0x32, 0x62, 0x38, 0x33, 0x38, 0x34, 0x62, 0x37, 0x66, 0x36, 0x63, 0x32, 0x66, 0x31, 0x36, 0x39, 0x35, 0x65, 0x31, 0x30, 0x64, 0x31, 0x63, 0x66, 0x66, 0x30, 0x61, 0x61, 0x61, 0x63, 0x30, 0x32, 0x65, 0x63, 0x37, 0x37, 0x66, 0x37, 0x62, 0x66, 0x30, 0x66, 0x33, 0x30, 0x65, 0x38, 0x30, 0x37, 0x65, 0x36, 0x30, 0x37, 0x34, 0x62, 0x39, 0x31, 0x39, 0x32, 0x65, 0x32, 0x66, 0x66, 0x65, 0x37, 0x32, 0x34, 0x63, 0x34, 0x38, 0x64, 0x61, 0x64, 0x33, 0x36, 0x64, 0x63, 0x62, 0x33, 0x34, 0x32, 0x32, 0x32, 0x32, 0x61, 0x64, 0x34, 0x31, 0x34, 0x30, 0x62, 0x62, 0x34, 0x65, 0x36, 0x36, 0x34, 0x30, 0x62, 0x36, 0x39, 0x35, 0x31, 0x33, 0x62, 0x30, 0x31, 0x37, 0x37, 0x31, 0x31, 0x65, 0x66, 0x61, 0x31, 0x32, 0x32, 0x38, 0x35, 0x66, 0x34, 0x61, 0x65, 0x39, 0x35, 0x35, 0x61, 0x31, 0x33, 0x65, 0x39, 0x39, 0x63, 0x36, 0x30, 0x35, 0x35, 0x62, 0x30, 0x65, 0x62, 0x34, 0x34, 0x34, 0x63, 0x37, 0x64, 0x62, 0x36, 0x32, 0x66, 0x61, 0x38, 0x61, 0x35, 0x36, 0x30, 0x39, 0x37, 0x30, 0x31, 0x38, 0x61, 0x66, 0x30, 0x38, 0x66, 0x61, 0x61, 0x31, 0x35, 0x38, 0x31, 0x62, 0x39, 0x64, 0x63, 0x32, 0x31, 0x32, 0x34, 0x33, 0x37, 0x62, 0x38, 0x39, 0x34, 0x63, 0x35, 0x36, 0x62, 0x38, 0x30, 0x38, 0x36, 0x30, 0x63, 0x61, 0x39, 0x36, 0x37, 0x65, 0x61, 0x34, 0x62, 0x64, 0x63, 0x33, 0x30, 0x61, 0x35, 0x38, 0x62, 0x34, 0x37, 0x65, 0x65, 0x35, 0x30, 0x36, 0x38, 0x37, 0x39, 0x36, 0x37, 0x61, 0x32, 0x61, 0x33, 0x63, 0x34, 0x66, 0x31, 0x62, 0x30, 0x31, 0x32, 0x64, 0x38, 0x39, 0x36, 0x66, 0x63, 0x33, 0x37, 0x36, 0x61, 0x33, 0x30, 0x36, 0x32, 0x34, 0x37, 0x62, 0x61, 0x36, 0x37, 0x32, 0x32, 0x64, 0x30, 0x31, 0x62, 0x63, 0x61, 0x39, 0x63, 0x32, 0x39, 0x30, 0x39, 0x35, 0x62, 0x36, 0x63, 0x37, 0x64, 0x36, 0x38, 0x64, 0x39, 0x65, 0x30, 0x62, 0x33, 0x63, 0x62, 0x33, 0x37, 0x38, 0x31, 0x34, 0x32, 0x62, 0x30, 0x39, 0x33, 0x38, 0x39, 0x36, 0x30, 0x61, 0x37, 0x65, 0x62, 0x32, 0x38, 0x66, 0x64, 0x37, 0x39, 0x65, 0x63, 0x31, 0x62, 0x32, 0x39, 0x61, 0x32, 0x38, 0x37, 0x32, 0x66, 0x63, 0x32, 0x62, 0x32, 0x33, 0x36, 0x38, 0x31, 0x36, 0x63, 0x36, 0x39, 0x61, 0x66, 0x65, 0x63, 0x34, 0x66, 0x66, 0x32, 0x32, 0x62, 0x38, 0x62, 0x38, 0x64, 0x32, 0x64, 0x39, 0x36, 0x39, 0x66, 0x30, 0x62, 0x38, 0x32, 0x62, 0x30, 0x61, 0x66, 0x32, 0x64, 0x35, 0x39, 0x39, 0x63, 0x65, 0x30, 0x65, 0x39, 0x32, 0x61, 0x37, 0x33, 0x62, 0x61, 0x65, 0x65, 0x63, 0x65, 0x35, 0x37, 0x32, 0x38, 0x32, 0x38, 0x66, 0x62, 0x32, 0x35, 0x37, 0x65, 0x35, 0x38, 0x61, 0x63, 0x32, 0x36, 0x34, 0x39, 0x62, 0x30, 0x35, 0x31, 0x65, 0x36, 0x65, 0x35, 0x33, 0x39, 0x64, 0x65, 0x33, 0x36, 0x37, 0x36, 0x66, 0x35, 0x37, 0x34, 0x35, 0x61, 0x37, 0x63, 0x38, 0x37, 0x61, 0x32, 0x38, 0x61, 0x33, 0x30, 0x37, 0x64, 0x65, 0x63, 0x32, 0x34, 0x33, 0x31, 0x37, 0x39, 0x63, 0x39, 0x35, 0x36, 0x35, 0x30, 0x37, 0x64, 0x32, 0x37, 0x34, 0x61, 0x62, 0x39, 0x31, 0x61, 0x61, 0x62, 0x31, 0x38, 0x33, 0x33, 0x31, 0x31, 0x38, 0x65, 0x32, 0x62, 0x34, 0x31, 0x39, 0x33, 0x35, 0x38, 0x33, 0x32, 0x39, 0x63, 0x32, 0x66, 0x61, 0x37, 0x62, 0x63, 0x66, 0x37, 0x36, 0x36, 0x61, 0x38, 0x34, 0x34, 0x38, 0x66, 0x65, 0x66, 0x31, 0x35, 0x32, 0x36, 0x39, 0x62, 0x31, 0x31, 0x37, 0x35, 0x30, 0x37, 0x32, 0x62, 0x30, 0x38, 0x32, 0x35, 0x33, 0x38, 0x37, 0x37, 0x65, 0x38, 0x64, 0x33, 0x62, 0x65, 0x35, 0x38, 0x66, 0x37, 0x39, 0x39, 0x31, 0x33, 0x39, 0x39, 0x37, 0x64, 0x30, 0x37, 0x65, 0x35, 0x64, 0x38, 0x38, 0x65, 0x65, 0x64, 0x37, 0x34, 0x35, 0x35, 0x65, 0x61, 0x33, 0x31, 0x32, 0x37, 0x30, 0x36, 0x64, 0x30, 0x32, 0x35, 0x39, 0x65, 0x63, 0x34, 0x33, 0x66, 0x62, 0x35, 0x33, 0x37, 0x32, 0x64, 0x31, 0x35, 0x36, 0x39, 0x38, 0x64, 0x65, 0x66, 0x37, 0x31, 0x65, 0x65, 0x63, 0x38, 0x66, 0x38, 0x62, 0x32, 0x31, 0x31, 0x34, 0x62, 0x39, 0x36, 0x37, 0x61, 0x30, 0x63, 0x33, 0x35, 0x33, 0x32, 0x31, 0x61, 0x32, 0x30, 0x34, 0x64, 0x65, 0x65, 0x35, 0x63, 0x66, 0x30, 0x64, 0x66, 0x64, 0x61, 0x63, 0x38, 0x63, 0x38, 0x66, 0x61, 0x32, 0x30, 0x32, 0x32, 0x39, 0x38, 0x65, 0x33, 0x61, 0x64, 0x33, 0x37, 0x62, 0x66, 0x64, 0x62, 0x31, 0x63, 0x32, 0x34, 0x65, 0x38, 0x64, 0x30, 0x32, 0x38, 0x32, 0x63, 0x32, 0x38, 0x32, 0x65, 0x34, 0x37, 0x33, 0x38, 0x61, 0x33, 0x61, 0x33, 0x37, 0x65, 0x31, 0x61, 0x38, 0x35, 0x32, 0x32, 0x31, 0x64, 0x36, 0x34, 0x66, 0x31, 0x62, 0x39, 0x63, 0x38, 0x63, 0x35, 0x37, 0x66, 0x64, 0x30, 0x30, 0x36, 0x37, 0x33, 0x35, 0x37, 0x65, 0x37, 0x32, 0x63, 0x65, 0x30, 0x31, 0x37, 0x39, 0x32, 0x39, 0x64, 0x36, 0x63, 0x30, 0x63, 0x38, 0x64, 0x31, 0x36, 0x63, 0x65, 0x36, 0x64, 0x63, 0x64, 0x33, 0x65, 0x66, 0x38, 0x66, 0x61, 0x31, 0x30, 0x38, 0x32, 0x32, 0x61, 0x32, 0x33, 0x33, 0x30, 0x61, 0x33, 0x32, 0x35, 0x36, 0x61, 0x38, 0x31, 0x36, 0x66, 0x39, 0x37, 0x30, 0x61, 0x65, 0x34, 0x62, 0x63, 0x65, 0x34, 0x36, 0x61, 0x65, 0x37, 0x32, 0x65, 0x35, 0x32, 0x33, 0x31, 0x64, 0x37, 0x30, 0x33, 0x36, 0x39, 0x64, 0x63, 0x36, 0x36, 0x33, 0x32, 0x66, 0x37, 0x31, 0x37, 0x35, 0x36, 0x33, 0x33, 0x32, 0x37, 0x61, 0x33, 0x36, 0x65, 0x31, 0x61, 0x39, 0x38, 0x63, 0x35, 0x38, 0x33, 0x35, 0x31, 0x62, 0x37, 0x34, 0x65, 0x36, 0x33, 0x33, 0x63, 0x39, 0x65, 0x31, 0x30, 0x66, 0x33, 0x32, 0x37, 0x39, 0x30, 0x64, 0x31, 0x37, 0x37, 0x32, 0x65, 0x33, 0x66, 0x66, 0x35, 0x38, 0x65, 0x31, 0x34, 0x31, 0x34, 0x65, 0x65, 0x34, 0x35, 0x62, 0x35, 0x66, 0x36, 0x61, 0x38, 0x37, 0x61, 0x35, 0x39, 0x35, 0x34, 0x34, 0x65, 0x38, 0x36, 0x37, 0x66, 0x36, 0x34, 0x64, 0x62, 0x66, 0x30, 0x34, 0x39, 0x31, 0x65, 0x38, 0x61, 0x33, 0x36, 0x63, 0x30, 0x37, 0x31, 0x64, 0x36, 0x61, 0x61, 0x32, 0x35, 0x39, 0x32, 0x32, 0x64, 0x34, 0x37, 0x32, 0x36, 0x31, 0x37, 0x31, 0x35, 0x37, 0x65, 0x31, 0x61, 0x33, 0x38, 0x37, 0x31, 0x64, 0x37, 0x63, 0x39, 0x35, 0x62, 0x32, 0x65, 0x38, 0x64, 0x31, 0x30, 0x38, 0x38, 0x34, 0x30, 0x30, 0x39, 0x66, 0x39, 0x65, 0x37, 0x30, 0x37, 0x62, 0x31, 0x38, 0x64, 0x61, 0x65, 0x65, 0x65, 0x32, 0x66, 0x33, 0x62, 0x63, 0x61, 0x36, 0x66, 0x33, 0x36, 0x66, 0x32, 0x36, 0x34, 0x35, 0x35, 0x64, 0x37, 0x32, 0x65, 0x66, 0x34, 0x34, 0x62, 0x62, 0x37, 0x36, 0x39, 0x39, 0x63, 0x30, 0x30, 0x66, 0x38, 0x37, 0x39, 0x37, 0x62, 0x64, 0x30, 0x35, 0x33, 0x36, 0x63, 0x63, 0x39, 0x32, 0x34, 0x64, 0x61, 0x63, 0x36, 0x65, 0x65, 0x66, 0x38, 0x38, 0x38, 0x63, 0x37, 0x36, 0x61, 0x64, 0x36, 0x37, 0x32, 0x61, 0x37, 0x31, 0x66, 0x33, 0x33, 0x64, 0x66, 0x36, 0x62, 0x33, 0x63, 0x63, 0x31, 0x66, 0x37, 0x32, 0x31, 0x38, 0x38, 0x63, 0x35, 0x63, 0x36, 0x37, 0x34, 0x31, 0x64, 0x35, 0x38, 0x36, 0x32, 0x39, 0x34, 0x33, 0x32, 0x62, 0x38, 0x35, 0x61, 0x38, 0x64, 0x63, 0x30, 0x38, 0x39, 0x36, 0x62, 0x66, 0x63, 0x61, 0x31, 0x64, 0x32, 0x31, 0x32, 0x32, 0x33, 0x33, 0x32, 0x63, 0x34, 0x33, 0x35, 0x35, 0x62, 0x61, 0x30, 0x37, 0x32, 0x37, 0x39, 0x61, 0x32, 0x30, 0x38, 0x31, 0x36, 0x34, 0x37, 0x32, 0x38, 0x64, 0x38, 0x62, 0x63, 0x31, 0x39, 0x35, 0x31, 0x34, 0x34, 0x66, 0x61, 0x34, 0x38, 0x63, 0x35, 0x66, 0x39, 0x33, 0x37, 0x31, 0x36, 0x61, 0x63, 0x62, 0x62, 0x34, 0x65, 0x38, 0x39, 0x61, 0x31, 0x61, 0x32, 0x38, 0x64, 0x65, 0x62, 0x30, 0x66, 0x39, 0x39, 0x66, 0x61, 0x32, 0x32, 0x39, 0x35, 0x32, 0x30, 0x66, 0x31, 0x36, 0x32, 0x36, 0x30, 0x38, 0x32, 0x65, 0x36, 0x34, 0x31, 0x64, 0x31, 0x65, 0x34, 0x61, 0x31, 0x32, 0x63, 0x30, 0x66, 0x36, 0x61, 0x38, 0x66, 0x35, 0x63, 0x32, 0x64, 0x66, 0x33, 0x30, 0x35, 0x39, 0x65, 0x36, 0x36, 0x36, 0x33, 0x38, 0x31, 0x63, 0x65, 0x30, 0x35, 0x62, 0x61, 0x37, 0x31, 0x31, 0x66, 0x62, 0x64, 0x66, 0x36, 0x65, 0x64, 0x62, 0x61, 0x31, 0x66, 0x32, 0x35, 0x65, 0x37, 0x64, 0x35, 0x63, 0x64, 0x36, 0x62, 0x30, 0x35, 0x33, 0x37, 0x32, 0x35, 0x33, 0x30, 0x39, 0x35, 0x37, 0x38, 0x36, 0x38, 0x63, 0x37, 0x37, 0x39, 0x34, 0x39, 0x65, 0x38, 0x31, 0x38, 0x62, 0x34, 0x35, 0x32, 0x63, 0x38, 0x65, 0x35, 0x64, 0x37, 0x37, 0x64, 0x66, 0x32, 0x63, 0x37, 0x63, 0x66, 0x38, 0x32, 0x66, 0x39, 0x30, 0x66, 0x32, 0x33, 0x31, 0x32, 0x38, 0x62, 0x64, 0x34, 0x37, 0x33, 0x66, 0x32, 0x64, 0x63, 0x37, 0x65, 0x32, 0x64, 0x30, 0x37, 0x32, 0x66, 0x66, 0x30, 0x34, 0x30, 0x39, 0x65, 0x32, 0x35, 0x35, 0x30, 0x62, 0x33, 0x61, 0x36, 0x39, 0x30, 0x35, 0x38, 0x32, 0x33, 0x65, 0x31, 0x62, 0x63, 0x63, 0x36, 0x66, 0x61, 0x39, 0x30, 0x63, 0x65, 0x63, 0x39, 0x64, 0x61, 0x34, 0x35, 0x66, 0x32, 0x39, 0x30, 0x36, 0x34, 0x33, 0x39, 0x32, 0x61, 0x38, 0x34, 0x64, 0x39, 0x62, 0x38, 0x36, 0x64, 0x62, 0x66, 0x39, 0x63, 0x39, 0x34, 0x63, 0x61, 0x65, 0x63, 0x32, 0x61, 0x36, 0x39, 0x33, 0x65, 0x31, 0x66, 0x66, 0x31, 0x35, 0x65, 0x33, 0x62, 0x37, 0x66, 0x36, 0x38, 0x38, 0x63, 0x65, 0x34, 0x37, 0x30, 0x66, 0x35, 0x63, 0x35, 0x33, 0x62, 0x30, 0x32, 0x62, 0x34, 0x36, 0x30, 0x30, 0x35, 0x39, 0x62, 0x35, 0x31, 0x39, 0x32, 0x64, 0x34, 0x63, 0x39, 0x39, 0x65, 0x65, 0x31, 0x66, 0x65, 0x61, 0x62, 0x64, 0x33, 0x61, 0x34, 0x31, 0x32, 0x39, 0x39, 0x33, 0x30, 0x64, 0x65, 0x32, 0x61, 0x61, 0x39, 0x37, 0x38, 0x35, 0x39, 0x39, 0x31, 0x39, 0x66, 0x37, 0x36, 0x35, 0x34, 0x32, 0x65, 0x31, 0x34, 0x65, 0x31, 0x66, 0x36, 0x39, 0x63, 0x31, 0x61, 0x38, 0x35, 0x31, 0x64, 0x33, 0x34, 0x32, 0x32, 0x65, 0x61, 0x35, 0x65, 0x66, 0x65, 0x63, 0x37, 0x31, 0x38, 0x31, 0x64, 0x65, 0x36, 0x31, 0x35, 0x31, 0x31, 0x63, 0x37, 0x32, 0x30, 0x31, 0x64, 0x39, 0x35, 0x37, 0x62, 0x30, 0x31, 0x65, 0x63, 0x32, 0x38, 0x36, 0x66, 0x35, 0x62, 0x31, 0x37, 0x34, 0x36, 0x65, 0x30, 0x34, 0x66, 0x63, 0x66, 0x66, 0x31, 0x39, 0x64, 0x34, 0x39, 0x39, 0x36, 0x64, 0x30, 0x35, 0x34, 0x61, 0x66, 0x34, 0x39, 0x62, 0x34, 0x64, 0x36, 0x64, 0x33, 0x37, 0x32, 0x38, 0x38, 0x62, 0x65, 0x62, 0x37, 0x61, 0x65, 0x64, 0x31, 0x39, 0x35, 0x36, 0x37, 0x35, 0x39, 0x34, 0x63, 0x31, 0x38, 0x31, 0x66, 0x31, 0x64, 0x39, 0x34, 0x62, 0x38, 0x61, 0x62, 0x34, 0x30, 0x65, 0x33, 0x32, 0x63, 0x30, 0x39, 0x32, 0x30, 0x65, 0x34, 0x61, 0x35, 0x32, 0x30, 0x64, 0x35, 0x32, 0x32, 0x63, 0x61, 0x31, 0x33, 0x31, 0x31, 0x61, 0x64, 0x62, 0x61, 0x33, 0x31, 0x39, 0x63, 0x30, 0x36, 0x33, 0x32, 0x66, 0x31, 0x32, 0x65, 0x63, 0x37, 0x32, 0x31, 0x38, 0x35, 0x32, 0x34, 0x65, 0x39, 0x64, 0x38, 0x64, 0x62, 0x35, 0x33, 0x36, 0x33, 0x37, 0x36, 0x62, 0x32, 0x38, 0x63, 0x64, 0x33, 0x30, 0x39, 0x61, 0x61, 0x34, 0x61, 0x33, 0x33, 0x37, 0x37, 0x63, 0x65, 0x61, 0x62, 0x33, 0x39, 0x31, 0x33, 0x33, 0x30, 0x30, 0x34, 0x30, 0x61, 0x63, 0x36, 0x64, 0x30, 0x34, 0x36, 0x32, 0x37, 0x34, 0x36, 0x63, 0x33, 0x38, 0x33, 0x35, 0x38, 0x66, 0x36, 0x63, 0x66, 0x30, 0x36, 0x61, 0x30, 0x35, 0x30, 0x65, 0x36, 0x33, 0x63, 0x38, 0x39, 0x35, 0x32, 0x39, 0x37, 0x34, 0x64, 0x34, 0x63, 0x65, 0x66, 0x36, 0x30, 0x38, 0x63, 0x39, 0x35, 0x36, 0x63, 0x39, 0x30, 0x63, 0x35, 0x37, 0x35, 0x39, 0x35, 0x62, 0x30, 0x33, 0x65, 0x64, 0x38, 0x32, 0x31, 0x38, 0x62, 0x34, 0x36, 0x63, 0x32, 0x35, 0x30, 0x34, 0x31, 0x35, 0x37, 0x34, 0x66, 0x63, 0x35, 0x66, 0x34, 0x30, 0x66, 0x30, 0x61, 0x36, 0x64, 0x63, 0x33, 0x30, 0x37, 0x33, 0x32, 0x30, 0x36, 0x66, 0x36, 0x30, 0x33, 0x61, 0x61, 0x66, 0x38, 0x38, 0x32, 0x63, 0x64, 0x33, 0x31, 0x33, 0x63, 0x64, 0x30, 0x39, 0x61, 0x32, 0x35, 0x61, 0x66, 0x34, 0x35, 0x66, 0x64, 0x65, 0x39, 0x30, 0x63, 0x35, 0x65, 0x35, 0x62, 0x36, 0x39, 0x39, 0x30, 0x65, 0x66, 0x31, 0x37, 0x34, 0x37, 0x32, 0x37, 0x32, 0x32, 0x39, 0x34, 0x32, 0x63, 0x62, 0x61, 0x35, 0x33, 0x62, 0x30, 0x61, 0x66, 0x30, 0x34, 0x31, 0x65, 0x37, 0x65, 0x35, 0x34, 0x35, 0x30, 0x35, 0x36, 0x37, 0x37, 0x31, 0x61, 0x63, 0x65, 0x31, 0x32, 0x31, 0x39, 0x62, 0x30, 0x34, 0x61, 0x36, 0x64, 0x34, 0x39, 0x62, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x39, 0x36, 0x36, 0x34, 0x35, 0x63, 0x64, 0x36, 0x35, 0x65, 0x62, 0x38, 0x37, 0x32, 0x32, 0x32, 0x64, 0x64, 0x37, 0x30, 0x61, 0x37, 0x30, 0x38, 0x31, 0x30, 0x65, 0x62, 0x32, 0x35, 0x63, 0x30, 0x62, 0x38, 0x66, 0x65, 0x33, 0x64, 0x31, 0x61, 0x33, 0x34, 0x36, 0x65, 0x32, 0x37, 0x38, 0x35, 0x63, 0x65, 0x32, 0x61, 0x31, 0x63, 0x33, 0x38, 0x66, 0x31, 0x38, 0x34, 0x37, 0x64, 0x34, 0x32, 0x61, 0x64, 0x33, 0x63, 0x39, 0x65, 0x30, 0x64, 0x38, 0x65, 0x38, 0x36, 0x37, 0x32, 0x32, 0x31, 0x30, 0x39, 0x39, 0x38, 0x61, 0x64, 0x31, 0x62, 0x35, 0x38, 0x36, 0x37, 0x66, 0x63, 0x31, 0x39, 0x36, 0x32, 0x30, 0x63, 0x39, 0x31, 0x61, 0x38, 0x36, 0x30, 0x62, 0x63, 0x32, 0x30, 0x34, 0x36, 0x61, 0x37, 0x33, 0x61, 0x37, 0x36, 0x36, 0x63, 0x30, 0x61, 0x64, 0x35, 0x63, 0x61, 0x32, 0x35, 0x38, 0x36, 0x63, 0x32, 0x39, 0x35, 0x39, 0x64, 0x30, 0x64, 0x36, 0x36, 0x33, 0x37, 0x38, 0x61, 0x35, 0x36, 0x31, 0x64, 0x63, 0x39, 0x66, 0x35, 0x65, 0x37, 0x61, 0x64, 0x33, 0x37, 0x30, 0x33, 0x35, 0x65, 0x34, 0x30, 0x31, 0x35, 0x37, 0x33, 0x30, 0x32, 0x64, 0x61, 0x30, 0x34, 0x63, 0x64, 0x35, 0x36, 0x61, 0x30, 0x66, 0x37, 0x33, 0x37, 0x33, 0x65, 0x64, 0x66, 0x65, 0x35, 0x39, 0x30, 0x61, 0x33, 0x34, 0x33, 0x31, 0x37, 0x63, 0x32, 0x62, 0x35, 0x66, 0x66, 0x36, 0x61, 0x63, 0x30, 0x38, 0x38, 0x65, 0x37, 0x30, 0x32, 0x63, 0x64, 0x39, 0x35, 0x61, 0x65, 0x63, 0x32, 0x36, 0x36, 0x64, 0x61, 0x34, 0x35, 0x39, 0x64, 0x31, 0x63, 0x31, 0x38, 0x38, 0x66, 0x34, 0x37, 0x31, 0x36, 0x38, 0x35, 0x39, 0x65, 0x62, 0x37, 0x65, 0x61, 0x30, 0x30, 0x33, 0x62, 0x35, 0x34, 0x33, 0x33, 0x61, 0x37, 0x31, 0x66, 0x65, 0x61, 0x31, 0x31, 0x38, 0x33, 0x31, 0x65, 0x37, 0x32, 0x32, 0x65, 0x38, 0x33, 0x65, 0x33, 0x35, 0x31, 0x61, 0x31, 0x37, 0x39, 0x31, 0x62, 0x61, 0x39, 0x37, 0x63, 0x63, 0x32, 0x65, 0x62, 0x66, 0x31, 0x36, 0x35, 0x33, 0x30, 0x30, 0x61, 0x39, 0x36, 0x33, 0x32, 0x61, 0x61, 0x66, 0x62, 0x33, 0x35, 0x35, 0x33, 0x38, 0x39, 0x63, 0x39, 0x63, 0x30, 0x31, 0x31, 0x64, 0x30, 0x31, 0x62, 0x38, 0x31, 0x66, 0x37, 0x63, 0x31, 0x36, 0x61, 0x37, 0x32, 0x34, 0x37, 0x36, 0x34, 0x39, 0x37, 0x66, 0x32, 0x62, 0x30, 0x39, 0x34, 0x66, 0x34, 0x38, 0x31, 0x66, 0x35, 0x66, 0x36, 0x66, 0x33, 0x39, 0x33, 0x64, 0x36, 0x31, 0x62, 0x39, 0x39, 0x64, 0x36, 0x30, 0x64, 0x33, 0x63, 0x64, 0x36, 0x64, 0x30, 0x63, 0x66, 0x34, 0x62, 0x32, 0x34, 0x64, 0x66, 0x34, 0x64, 0x37, 0x31, 0x35, 0x37, 0x37, 0x37, 0x39, 0x62, 0x61, 0x35, 0x62, 0x61, 0x37, 0x32, 0x34, 0x36, 0x38, 0x39, 0x35, 0x35, 0x66, 0x36, 0x65, 0x37, 0x36, 0x64, 0x31, 0x35, 0x64, 0x34, 0x32, 0x39, 0x64, 0x31, 0x37, 0x36, 0x64, 0x63, 0x38, 0x62, 0x65, 0x34, 0x33, 0x31, 0x66, 0x33, 0x37, 0x31, 0x62, 0x66, 0x62, 0x39, 0x39, 0x34, 0x34, 0x66, 0x39, 0x33, 0x31, 0x31, 0x64, 0x64, 0x65, 0x35, 0x35, 0x61, 0x33, 0x64, 0x32, 0x35, 0x37, 0x38, 0x66, 0x65, 0x66, 0x62, 0x37, 0x32, 0x61, 0x34, 0x61, 0x32, 0x32, 0x33, 0x34, 0x32, 0x30, 0x33, 0x62, 0x31, 0x35, 0x35, 0x37, 0x64, 0x37, 0x37, 0x61, 0x39, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x66, 0x34, 0x34, 0x32, 0x61, 0x31, 0x61, 0x61, 0x37, 0x39, 0x37, 0x37, 0x36, 0x65, 0x32, 0x36, 0x61, 0x62, 0x32, 0x35, 0x32, 0x64, 0x34, 0x31, 0x34, 0x66, 0x30, 0x35, 0x36, 0x31, 0x38, 0x34, 0x36, 0x65, 0x61, 0x34, 0x33, 0x34, 0x33, 0x62, 0x33, 0x65, 0x63, 0x66, 0x38, 0x35, 0x63, 0x62, 0x37, 0x31, 0x64, 0x30, 0x62, 0x34, 0x31, 0x34, 0x65, 0x62, 0x65, 0x39, 0x63, 0x62, 0x39, 0x64, 0x36, 0x64, 0x32, 0x34, 0x35, 0x30, 0x31, 0x64, 0x36, 0x30, 0x35, 0x33, 0x36, 0x64, 0x39, 0x34, 0x34, 0x66, 0x61, 0x36, 0x31, 0x34, 0x38, 0x33, 0x61, 0x31, 0x62, 0x61, 0x65, 0x39, 0x32, 0x65, 0x39, 0x64, 0x33, 0x32, 0x37, 0x32, 0x30, 0x37, 0x34, 0x39, 0x35, 0x31, 0x62, 0x34, 0x34, 0x39, 0x33, 0x36, 0x64, 0x66, 0x65, 0x38, 0x33, 0x31, 0x30, 0x32, 0x39, 0x36, 0x33, 0x62, 0x30, 0x62, 0x34, 0x61, 0x31, 0x63, 0x32, 0x30, 0x66, 0x65, 0x33, 0x61, 0x63, 0x33, 0x30, 0x33, 0x34, 0x65, 0x39, 0x63, 0x63, 0x37, 0x65, 0x32, 0x63, 0x32, 0x62, 0x61, 0x62, 0x61, 0x32, 0x39, 0x34, 0x38, 0x30, 0x66, 0x31, 0x30, 0x36, 0x34, 0x35, 0x31, 0x65, 0x63, 0x64, 0x34, 0x38, 0x33, 0x65, 0x35, 0x34, 0x38, 0x66, 0x31, 0x61, 0x38, 0x36, 0x62, 0x33, 0x66, 0x35, 0x37, 0x61, 0x34, 0x33, 0x31, 0x63, 0x62, 0x64, 0x30, 0x62, 0x38, 0x36, 0x31, 0x30, 0x34, 0x63, 0x65, 0x64, 0x30, 0x37, 0x35, 0x37, 0x61, 0x34, 0x65, 0x38, 0x38, 0x64, 0x36, 0x36, 0x37, 0x62, 0x34, 0x34, 0x31, 0x61, 0x37, 0x36, 0x35, 0x31, 0x36, 0x37, 0x32, 0x34, 0x64, 0x31, 0x39, 0x38, 0x62, 0x61, 0x37, 0x62, 0x37, 0x63, 0x64, 0x37, 0x36, 0x30, 0x33, 0x66, 0x37, 0x66, 0x33, 0x32, 0x61, 0x30, 0x65, 0x32, 0x63, 0x66, 0x62, 0x65, 0x65, 0x35, 0x35, 0x61, 0x65, 0x30, 0x37, 0x38, 0x33, 0x35, 0x37, 0x31, 0x31, 0x64, 0x64, 0x35, 0x37, 0x35, 0x34, 0x31, 0x30, 0x61, 0x64, 0x65, 0x38, 0x61, 0x38, 0x64, 0x33, 0x30, 0x35, 0x31, 0x36, 0x37, 0x32, 0x38, 0x37, 0x62, 0x31, 0x37, 0x33, 0x64, 0x35, 0x39, 0x34, 0x65, 0x62, 0x33, 0x65, 0x36, 0x38, 0x63, 0x32, 0x35, 0x61, 0x34, 0x64, 0x34, 0x65, 0x30, 0x36, 0x33, 0x39, 0x30, 0x34, 0x61, 0x33, 0x61, 0x31, 0x64, 0x32, 0x34, 0x65, 0x32, 0x61, 0x32, 0x64, 0x38, 0x39, 0x35, 0x38, 0x36, 0x66, 0x39, 0x36, 0x61, 0x33, 0x33, 0x33, 0x37, 0x39, 0x32, 0x33, 0x34, 0x61, 0x62, 0x37, 0x37, 0x32, 0x63, 0x33, 0x65, 0x34, 0x39, 0x39, 0x31, 0x63, 0x30, 0x34, 0x31, 0x34, 0x32, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x38, 0x65, 0x34, 0x36, 0x30, 0x32, 0x61, 0x32, 0x37, 0x33, 0x31, 0x34, 0x38, 0x61, 0x39, 0x31, 0x36, 0x32, 0x65, 0x62, 0x35, 0x36, 0x62, 0x64, 0x33, 0x36, 0x64, 0x63, 0x35, 0x38, 0x32, 0x61, 0x61, 0x65, 0x36, 0x65, 0x61, 0x64, 0x64, 0x32, 0x37, 0x32, 0x35, 0x37, 0x32, 0x61, 0x38, 0x61, 0x64, 0x37, 0x64, 0x38, 0x66, 0x39, 0x64, 0x34, 0x62, 0x35, 0x65, 0x36, 0x30, 0x33, 0x63, 0x35, 0x30, 0x34, 0x34, 0x65, 0x38, 0x63, 0x39, 0x37, 0x66, 0x35, 0x31, 0x37, 0x32, 0x63, 0x30, 0x38, 0x64, 0x61, 0x66, 0x37, 0x65, 0x34, 0x65, 0x30, 0x63, 0x39, 0x35, 0x62, 0x33, 0x38, 0x61, 0x38, 0x31, 0x31, 0x38, 0x66, 0x31, 0x30, 0x65, 0x32, 0x32, 0x37, 0x34, 0x36, 0x32, 0x64, 0x31, 0x30, 0x36, 0x31, 0x61, 0x64, 0x63, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x34, 0x63, 0x32, 0x31, 0x34, 0x32, 0x66, 0x61, 0x66, 0x63, 0x66, 0x66, 0x31, 0x34, 0x62, 0x64, 0x36, 0x33, 0x32, 0x62, 0x39, 0x66, 0x61, 0x39, 0x37, 0x32, 0x36, 0x65, 0x37, 0x31, 0x31, 0x66, 0x33, 0x62, 0x33, 0x61, 0x35, 0x32, 0x65, 0x32, 0x65, 0x61, 0x65, 0x32, 0x32, 0x35, 0x61, 0x32, 0x33, 0x36, 0x63, 0x64, 0x32, 0x63, 0x64, 0x32, 0x37, 0x36, 0x36, 0x34, 0x34, 0x63, 0x33, 0x64, 0x31, 0x33, 0x38, 0x37, 0x32, 0x33, 0x39, 0x65, 0x34, 0x39, 0x65, 0x30, 0x34, 0x62, 0x62, 0x30, 0x36, 0x35, 0x64, 0x30, 0x37, 0x64, 0x35, 0x31, 0x64, 0x62, 0x38, 0x33, 0x33, 0x31, 0x32, 0x32, 0x33, 0x63, 0x66, 0x37, 0x61, 0x35, 0x61, 0x66, 0x38, 0x64, 0x38, 0x36, 0x37, 0x63, 0x31, 0x32, 0x34, 0x62, 0x63, 0x32, 0x63, 0x31, 0x36, 0x33, 0x35, 0x64, 0x63, 0x33, 0x37, 0x30, 0x35, 0x63, 0x65, 0x62, 0x31, 0x66, 0x61, 0x66, 0x61, 0x33, 0x63, 0x62, 0x31, 0x34, 0x36, 0x36, 0x61, 0x30, 0x64, 0x33, 0x34, 0x34, 0x30, 0x38, 0x66, 0x64, 0x36, 0x30, 0x64, 0x32, 0x62, 0x36, 0x39, 0x66, 0x38, 0x65, 0x62, 0x63, 0x33, 0x62, 0x38, 0x32, 0x35, 0x64, 0x36, 0x62, 0x64, 0x66, 0x36, 0x61, 0x37, 0x32, 0x37, 0x64, 0x30, 0x63, 0x66, 0x38, 0x36, 0x38, 0x34, 0x37, 0x37, 0x35, 0x38, 0x34, 0x33, 0x36, 0x34, 0x63, 0x31, 0x34, 0x36, 0x39, 0x30, 0x61, 0x30, 0x30, 0x63, 0x32, 0x65, 0x32, 0x37, 0x39, 0x33, 0x61, 0x38, 0x31, 0x64, 0x33, 0x37, 0x33, 0x34, 0x35, 0x31, 0x34, 0x36, 0x31, 0x61, 0x34, 0x30, 0x35, 0x34, 0x38, 0x35, 0x37, 0x30, 0x31, 0x35, 0x36, 0x62, 0x32, 0x39, 0x39, 0x32, 0x64, 0x34, 0x31, 0x65, 0x65, 0x36, 0x63, 0x38, 0x66, 0x36, 0x64, 0x35, 0x65, 0x32, 0x63, 0x33, 0x38, 0x33, 0x65, 0x37, 0x64, 0x34, 0x65, 0x63, 0x62, 0x35, 0x34, 0x62, 0x65, 0x65, 0x38, 0x64, 0x65, 0x37, 0x32, 0x61, 0x33, 0x63, 0x66, 0x63, 0x32, 0x66, 0x63, 0x61, 0x63, 0x38, 0x35, 0x62, 0x65, 0x36, 0x62, 0x30, 0x30, 0x34, 0x37, 0x30, 0x62, 0x38, 0x38, 0x34, 0x31, 0x36, 0x32, 0x37, 0x32, 0x32, 0x37, 0x33, 0x31, 0x66, 0x30, 0x39, 0x36, 0x33, 0x37, 0x36, 0x66, 0x62, 0x65, 0x31, 0x31, 0x39, 0x39, 0x64, 0x38, 0x36, 0x65, 0x37, 0x63, 0x66, 0x31, 0x66, 0x33, 0x35, 0x31, 0x35, 0x36, 0x36, 0x62, 0x64, 0x37, 0x33, 0x64, 0x37, 0x38, 0x66, 0x66, 0x62, 0x30, 0x37, 0x32, 0x35, 0x38, 0x36, 0x63, 0x65, 0x62, 0x66, 0x66, 0x36, 0x63, 0x33, 0x31, 0x63, 0x38, 0x63, 0x33, 0x37, 0x32, 0x61, 0x35, 0x31, 0x61, 0x63, 0x36, 0x30, 0x37, 0x36, 0x32, 0x37, 0x64, 0x31, 0x33, 0x35, 0x31, 0x66, 0x32, 0x32, 0x63, 0x61, 0x39, 0x38, 0x39, 0x33, 0x32, 0x32, 0x64, 0x33, 0x65, 0x36, 0x31, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x34, 0x39, 0x35, 0x66, 0x64, 0x63, 0x63, 0x39, 0x35, 0x38, 0x66, 0x36, 0x39, 0x37, 0x36, 0x34, 0x65, 0x66, 0x64, 0x32, 0x61, 0x31, 0x66, 0x37, 0x34, 0x65, 0x61, 0x65, 0x61, 0x35, 0x62, 0x38, 0x36, 0x39, 0x61, 0x34, 0x66, 0x65, 0x30, 0x62, 0x34, 0x34, 0x66, 0x36, 0x63, 0x36, 0x37, 0x63, 0x32, 0x61, 0x62, 0x35, 0x64, 0x38, 0x64, 0x63, 0x65, 0x61, 0x65, 0x65, 0x65, 0x30, 0x31, 0x35, 0x65, 0x64, 0x62, 0x31, 0x30, 0x31, 0x38, 0x38, 0x31, 0x31, 0x65, 0x66, 0x62, 0x65, 0x38, 0x61, 0x37, 0x33, 0x35, 0x66, 0x37, 0x33, 0x31, 0x35, 0x34, 0x37, 0x38, 0x33, 0x35, 0x32, 0x30, 0x65, 0x61, 0x33, 0x37, 0x35, 0x39, 0x61, 0x36, 0x61, 0x63, 0x62, 0x36, 0x36, 0x37, 0x31, 0x31, 0x31, 0x31, 0x63, 0x39, 0x35, 0x36, 0x65, 0x37, 0x35, 0x63, 0x31, 0x35, 0x63, 0x39, 0x34, 0x66, 0x31, 0x38, 0x37, 0x33, 0x30, 0x36, 0x65, 0x65, 0x62, 0x30, 0x39, 0x61, 0x38, 0x63, 0x33, 0x34, 0x34, 0x66, 0x64, 0x31, 0x37, 0x62, 0x32, 0x62, 0x62, 0x37, 0x32, 0x62, 0x38, 0x64, 0x63, 0x31, 0x35, 0x37, 0x35, 0x62, 0x34, 0x35, 0x65, 0x37, 0x30, 0x32, 0x32, 0x63, 0x63, 0x34, 0x34, 0x34, 0x36, 0x39, 0x39, 0x65, 0x36, 0x63, 0x38, 0x64, 0x33, 0x36, 0x63, 0x30, 0x32, 0x30, 0x31, 0x37, 0x63, 0x36, 0x32, 0x37, 0x38, 0x36, 0x32, 0x31, 0x36, 0x36, 0x63, 0x61, 0x34, 0x62, 0x35, 0x34, 0x36, 0x34, 0x37, 0x36, 0x65, 0x62, 0x39, 0x63, 0x38, 0x37, 0x32, 0x65, 0x38, 0x36, 0x62, 0x62, 0x64, 0x61, 0x37, 0x39, 0x62, 0x33, 0x66, 0x61, 0x31, 0x62, 0x39, 0x65, 0x32, 0x39, 0x32, 0x31, 0x66, 0x61, 0x38, 0x34, 0x35, 0x31, 0x66, 0x32, 0x62, 0x32, 0x32, 0x62, 0x37, 0x61, 0x36, 0x30, 0x30, 0x66, 0x38, 0x39, 0x65, 0x30, 0x35, 0x30, 0x37, 0x62, 0x33, 0x30, 0x31, 0x30, 0x66, 0x38, 0x65, 0x31, 0x39, 0x37, 0x32, 0x30, 0x61, 0x61, 0x37, 0x37, 0x32, 0x36, 0x37, 0x32, 0x62, 0x34, 0x34, 0x64, 0x63, 0x37, 0x38, 0x64, 0x63, 0x63, 0x35, 0x63, 0x37, 0x37, 0x35, 0x31, 0x30, 0x37, 0x62, 0x38, 0x33, 0x31, 0x65, 0x39, 0x39, 0x38, 0x38, 0x33, 0x33, 0x36, 0x64, 0x61, 0x33, 0x64, 0x35, 0x32, 0x32, 0x31, 0x34, 0x38, 0x39, 0x66, 0x34, 0x35, 0x34, 0x33, 0x32, 0x35, 0x39, 0x30, 0x62, 0x32, 0x31, 0x64, 0x35, 0x31, 0x31, 0x39, 0x63, 0x35, 0x63, 0x32, 0x37, 0x61, 0x37, 0x62, 0x30, 0x35, 0x31, 0x37, 0x31, 0x36, 0x39, 0x64, 0x62, 0x37, 0x34, 0x37, 0x61, 0x64, 0x34, 0x30, 0x38, 0x30, 0x63, 0x66, 0x31, 0x34, 0x34, 0x65, 0x34, 0x30, 0x31, 0x36, 0x65, 0x62, 0x31, 0x37, 0x30, 0x32, 0x39, 0x63, 0x61, 0x37, 0x38, 0x36, 0x31, 0x64, 0x39, 0x65, 0x65, 0x33, 0x61, 0x61, 0x65, 0x35, 0x39, 0x33, 0x66, 0x63, 0x62, 0x32, 0x65, 0x37, 0x32, 0x36, 0x34, 0x39, 0x37, 0x39, 0x63, 0x33, 0x33, 0x35, 0x32, 0x39, 0x62, 0x36, 0x36, 0x34, 0x37, 0x35, 0x66, 0x34, 0x33, 0x63, 0x30, 0x65, 0x36, 0x35, 0x30, 0x35, 0x37, 0x32, 0x66, 0x35, 0x33, 0x66, 0x30, 0x35, 0x65, 0x35, 0x63, 0x66, 0x66, 0x31, 0x65, 0x64, 0x30, 0x34, 0x63, 0x65, 0x31, 0x38, 0x66, 0x32, 0x33, 0x61, 0x36, 0x62, 0x61, 0x32, 0x64, 0x30, 0x31, 0x62, 0x34, 0x37, 0x32, 0x62, 0x66, 0x64, 0x33, 0x37, 0x65, 0x65, 0x39, 0x32, 0x36, 0x61, 0x63, 0x32, 0x64, 0x33, 0x37, 0x38, 0x34, 0x61, 0x64, 0x33, 0x37, 0x37, 0x62, 0x36, 0x38, 0x63, 0x33, 0x33, 0x62, 0x65, 0x39, 0x30, 0x61, 0x32, 0x31, 0x63, 0x34, 0x64, 0x37, 0x31, 0x30, 0x31, 0x38, 0x66, 0x64, 0x37, 0x36, 0x62, 0x62, 0x37, 0x39, 0x32, 0x66, 0x33, 0x30, 0x65, 0x31, 0x37, 0x39, 0x39, 0x34, 0x37, 0x32, 0x64, 0x34, 0x33, 0x63, 0x65, 0x62, 0x66, 0x39, 0x37, 0x62, 0x64, 0x38, 0x32, 0x32, 0x65, 0x34, 0x37, 0x35, 0x36, 0x66, 0x34, 0x63, 0x65, 0x34, 0x65, 0x35, 0x65, 0x61, 0x33, 0x36, 0x65, 0x38, 0x36, 0x62, 0x66, 0x66, 0x38, 0x33, 0x37, 0x31, 0x37, 0x37, 0x39, 0x66, 0x65, 0x39, 0x64, 0x64, 0x37, 0x63, 0x38, 0x65, 0x30, 0x35, 0x36, 0x61, 0x38, 0x33, 0x39, 0x31, 0x37, 0x31, 0x37, 0x32, 0x62, 0x32, 0x39, 0x66, 0x65, 0x32, 0x63, 0x36, 0x34, 0x39, 0x30, 0x62, 0x35, 0x39, 0x39, 0x33, 0x31, 0x36, 0x30, 0x64, 0x63, 0x37, 0x64, 0x33, 0x65, 0x34, 0x33, 0x31, 0x38, 0x65, 0x39, 0x33, 0x38, 0x33, 0x65, 0x35, 0x31, 0x63, 0x37, 0x39, 0x31, 0x64, 0x36, 0x37, 0x33, 0x31, 0x31, 0x66, 0x30, 0x33, 0x31, 0x66, 0x30, 0x63, 0x37, 0x33, 0x30, 0x35, 0x35, 0x36, 0x30, 0x33, 0x35, 0x61, 0x65, 0x64, 0x33, 0x37, 0x31, 0x65, 0x36, 0x39, 0x34, 0x34, 0x38, 0x36, 0x39, 0x33, 0x39, 0x31, 0x32, 0x66, 0x31, 0x33, 0x34, 0x36, 0x34, 0x31, 0x33, 0x38, 0x66, 0x31, 0x63, 0x34, 0x65, 0x63, 0x31, 0x35, 0x30, 0x32, 0x62, 0x32, 0x30, 0x31, 0x62, 0x63, 0x64, 0x32, 0x31, 0x37, 0x30, 0x62, 0x37, 0x64, 0x61, 0x35, 0x33, 0x61, 0x31, 0x33, 0x64, 0x65, 0x61, 0x30, 0x31, 0x39, 0x36, 0x62, 0x66, 0x66, 0x31, 0x63, 0x38, 0x36, 0x39, 0x64, 0x38, 0x31, 0x38, 0x66, 0x64, 0x35, 0x34, 0x39, 0x35, 0x62, 0x66, 0x63, 0x36, 0x34, 0x30, 0x33, 0x61, 0x34, 0x33, 0x64, 0x32, 0x65, 0x37, 0x35, 0x39, 0x39, 0x63, 0x65, 0x61, 0x37, 0x61, 0x38, 0x35, 0x64, 0x36, 0x66, 0x32, 0x35, 0x32, 0x33, 0x61, 0x64, 0x61, 0x38, 0x36, 0x30, 0x39, 0x30, 0x36, 0x62, 0x65, 0x31, 0x31, 0x61, 0x37, 0x32, 0x39, 0x31, 0x33, 0x64, 0x36, 0x34, 0x39, 0x35, 0x64, 0x63, 0x34, 0x37, 0x62, 0x33, 0x63, 0x36, 0x37, 0x31, 0x65, 0x64, 0x63, 0x66, 0x66, 0x30, 0x63, 0x34, 0x36, 0x64, 0x35, 0x63, 0x64, 0x62, 0x63, 0x37, 0x37, 0x37, 0x66, 0x66, 0x63, 0x63, 0x39, 0x37, 0x63, 0x31, 0x39, 0x37, 0x38, 0x62, 0x61, 0x35, 0x65, 0x39, 0x66, 0x34, 0x66, 0x64, 0x66, 0x33, 0x33, 0x36, 0x36, 0x63, 0x34, 0x39, 0x36, 0x30, 0x33, 0x36, 0x36, 0x66, 0x66, 0x63, 0x63, 0x34, 0x63, 0x63, 0x32, 0x33, 0x37, 0x31, 0x33, 0x32, 0x34, 0x35, 0x62, 0x61, 0x63, 0x33, 0x61, 0x66, 0x30, 0x39, 0x31, 0x36, 0x38, 0x63, 0x30, 0x61, 0x62, 0x63, 0x37, 0x35, 0x61, 0x37, 0x65, 0x30, 0x34, 0x61, 0x36, 0x31, 0x65, 0x37, 0x39, 0x33, 0x35, 0x39, 0x31, 0x64, 0x39, 0x37, 0x34, 0x66, 0x63, 0x66, 0x31, 0x30, 0x32, 0x35, 0x36, 0x37, 0x31, 0x64, 0x39, 0x62, 0x36, 0x31, 0x61, 0x39, 0x64, 0x36, 0x30, 0x62, 0x37, 0x30, 0x66, 0x38, 0x37, 0x35, 0x38, 0x66, 0x38, 0x66, 0x39, 0x37, 0x32, 0x34, 0x32, 0x38, 0x31, 0x65, 0x35, 0x33, 0x61, 0x64, 0x39, 0x62, 0x30, 0x31, 0x39, 0x38, 0x36, 0x64, 0x33, 0x66, 0x34, 0x61, 0x61, 0x37, 0x36, 0x38, 0x65, 0x66, 0x38, 0x37, 0x64, 0x38, 0x37, 0x31, 0x66, 0x38, 0x35, 0x34, 0x65, 0x39, 0x32, 0x64, 0x38, 0x38, 0x61, 0x64, 0x36, 0x65, 0x62, 0x61, 0x39, 0x34, 0x33, 0x34, 0x62, 0x63, 0x37, 0x39, 0x30, 0x31, 0x39, 0x64, 0x31, 0x65, 0x64, 0x34, 0x35, 0x32, 0x30, 0x61, 0x64, 0x66, 0x39, 0x62, 0x36, 0x37, 0x30, 0x37, 0x35, 0x33, 0x30, 0x33, 0x31, 0x66, 0x30, 0x66, 0x61, 0x39, 0x65, 0x64, 0x64, 0x63, 0x63, 0x33, 0x36, 0x65, 0x63, 0x62, 0x37, 0x63, 0x37, 0x32, 0x65, 0x34, 0x39, 0x65, 0x34, 0x31, 0x34, 0x38, 0x35, 0x62, 0x64, 0x36, 0x31, 0x63, 0x31, 0x31, 0x33, 0x33, 0x33, 0x61, 0x31, 0x64, 0x33, 0x33, 0x30, 0x31, 0x33, 0x32, 0x35, 0x30, 0x66, 0x33, 0x63, 0x61, 0x66, 0x37, 0x36, 0x64, 0x61, 0x38, 0x62, 0x32, 0x62, 0x36, 0x37, 0x64, 0x34, 0x36, 0x63, 0x37, 0x34, 0x37, 0x64, 0x32, 0x36, 0x61, 0x30, 0x64, 0x66, 0x37, 0x35, 0x61, 0x35, 0x33, 0x61, 0x63, 0x35, 0x33, 0x64, 0x35, 0x38, 0x66, 0x31, 0x61, 0x39, 0x31, 0x62, 0x31, 0x65, 0x37, 0x37, 0x63, 0x35, 0x36, 0x38, 0x63, 0x61, 0x65, 0x63, 0x35, 0x33, 0x62, 0x38, 0x38, 0x61, 0x63, 0x33, 0x62, 0x66, 0x33, 0x39, 0x36, 0x36, 0x30, 0x61, 0x63, 0x38, 0x39, 0x64, 0x65, 0x36, 0x63, 0x65, 0x34, 0x66, 0x66, 0x66, 0x37, 0x64, 0x33, 0x39, 0x33, 0x62, 0x36, 0x61, 0x61, 0x37, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x61, 0x62, 0x63, 0x63, 0x34, 0x30, 0x62, 0x35, 0x33, 0x30, 0x38, 0x37, 0x35, 0x33, 0x66, 0x66, 0x64, 0x63, 0x36, 0x35, 0x31, 0x31, 0x65, 0x65, 0x35, 0x31, 0x61, 0x62, 0x65, 0x37, 0x64, 0x31, 0x65, 0x35, 0x33, 0x62, 0x35, 0x65, 0x39, 0x39, 0x63, 0x64, 0x37, 0x39, 0x62, 0x61, 0x33, 0x37, 0x36, 0x37, 0x62, 0x33, 0x35, 0x66, 0x38, 0x31, 0x37, 0x32, 0x61, 0x33, 0x36, 0x39, 0x38, 0x35, 0x38, 0x37, 0x65, 0x65, 0x33, 0x35, 0x62, 0x63, 0x66, 0x65, 0x37, 0x31, 0x31, 0x33, 0x31, 0x63, 0x36, 0x32, 0x62, 0x33, 0x31, 0x63, 0x33, 0x37, 0x33, 0x61, 0x61, 0x65, 0x34, 0x61, 0x37, 0x61, 0x35, 0x39, 0x30, 0x34, 0x65, 0x66, 0x34, 0x31, 0x35, 0x62, 0x63, 0x32, 0x66, 0x65, 0x63, 0x31, 0x39, 0x61, 0x65, 0x38, 0x61, 0x64, 0x35, 0x30, 0x37, 0x32, 0x36, 0x32, 0x35, 0x37, 0x30, 0x61, 0x61, 0x64, 0x36, 0x39, 0x65, 0x39, 0x38, 0x39, 0x30, 0x37, 0x33, 0x62, 0x33, 0x33, 0x31, 0x63, 0x36, 0x62, 0x31, 0x33, 0x30, 0x39, 0x64, 0x66, 0x32, 0x31, 0x33, 0x37, 0x35, 0x34, 0x62, 0x61, 0x31, 0x38, 0x37, 0x32, 0x64, 0x65, 0x36, 0x61, 0x36, 0x32, 0x64, 0x33, 0x63, 0x62, 0x32, 0x32, 0x36, 0x32, 0x61, 0x38, 0x34, 0x35, 0x39, 0x63, 0x37, 0x32, 0x38, 0x30, 0x62, 0x31, 0x37, 0x34, 0x66, 0x39, 0x35, 0x35, 0x36, 0x37, 0x61, 0x38, 0x62, 0x30, 0x36, 0x63, 0x35, 0x39, 0x33, 0x36, 0x39, 0x63, 0x39, 0x37, 0x62, 0x62, 0x31, 0x37, 0x32, 0x62, 0x37, 0x31, 0x34, 0x34, 0x38, 0x37, 0x38, 0x61, 0x63, 0x63, 0x30, 0x30, 0x39, 0x35, 0x38, 0x38, 0x34, 0x66, 0x63, 0x66, 0x30, 0x30, 0x63, 0x30, 0x37, 0x65, 0x38, 0x31, 0x31, 0x32, 0x34, 0x39, 0x65, 0x61, 0x38, 0x37, 0x62, 0x63, 0x63, 0x34, 0x31, 0x64, 0x62, 0x33, 0x65, 0x37, 0x34, 0x34, 0x37, 0x34, 0x32, 0x32, 0x37, 0x36, 0x39, 0x31, 0x65, 0x39, 0x30, 0x65, 0x63, 0x31, 0x65, 0x38, 0x36, 0x35, 0x30, 0x31, 0x65, 0x34, 0x61, 0x64, 0x65, 0x61, 0x66, 0x62, 0x34, 0x33, 0x66, 0x35, 0x31, 0x65, 0x35, 0x37, 0x31, 0x33, 0x65, 0x61, 0x66, 0x31, 0x39, 0x34, 0x37, 0x30, 0x37, 0x32, 0x34, 0x33, 0x30, 0x63, 0x61, 0x64, 0x62, 0x30, 0x66, 0x36, 0x62, 0x61, 0x64, 0x30, 0x66, 0x61, 0x32, 0x39, 0x65, 0x38, 0x35, 0x32, 0x63, 0x30, 0x39, 0x38, 0x64, 0x30, 0x34, 0x32, 0x61, 0x63, 0x61, 0x64, 0x63, 0x37, 0x30, 0x62, 0x62, 0x32, 0x34, 0x31, 0x34, 0x37, 0x34, 0x32, 0x33, 0x36, 0x65, 0x66, 0x34, 0x31, 0x66, 0x34, 0x31, 0x33, 0x31, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x32, 0x64, 0x33, 0x31, 0x65, 0x65, 0x33, 0x32, 0x39, 0x37, 0x34, 0x31, 0x66, 0x32, 0x33, 0x33, 0x32, 0x37, 0x37, 0x62, 0x62, 0x64, 0x63, 0x34, 0x39, 0x61, 0x63, 0x34, 0x32, 0x34, 0x30, 0x34, 0x30, 0x32, 0x35, 0x38, 0x62, 0x38, 0x65, 0x38, 0x32, 0x64, 0x63, 0x66, 0x64, 0x63, 0x37, 0x65, 0x63, 0x38, 0x64, 0x61, 0x61, 0x37, 0x39, 0x39, 0x63, 0x38, 0x61, 0x61, 0x65, 0x38, 0x34, 0x37, 0x32, 0x33, 0x32, 0x62, 0x64, 0x66, 0x34, 0x63, 0x35, 0x34, 0x65, 0x61, 0x64, 0x31, 0x63, 0x61, 0x62, 0x35, 0x33, 0x38, 0x31, 0x30, 0x65, 0x62, 0x64, 0x35, 0x63, 0x63, 0x37, 0x65, 0x61, 0x32, 0x61, 0x32, 0x65, 0x37, 0x64, 0x66, 0x66, 0x38, 0x34, 0x37, 0x64, 0x65, 0x35, 0x61, 0x31, 0x36, 0x62, 0x36, 0x33, 0x66, 0x35, 0x62, 0x34, 0x66, 0x36, 0x62, 0x37, 0x34, 0x61, 0x64, 0x32, 0x30, 0x62, 0x61, 0x61, 0x30, 0x63, 0x64, 0x61, 0x65, 0x32, 0x35, 0x64, 0x63, 0x63, 0x31, 0x33, 0x63, 0x30, 0x61, 0x35, 0x37, 0x33, 0x61, 0x30, 0x31, 0x62, 0x62, 0x33, 0x66, 0x63, 0x32, 0x34, 0x64, 0x31, 0x38, 0x62, 0x35, 0x65, 0x36, 0x63, 0x34, 0x30, 0x64, 0x66, 0x36, 0x38, 0x30, 0x63, 0x65, 0x64, 0x31, 0x64, 0x64, 0x30, 0x39, 0x37, 0x34, 0x33, 0x34, 0x62, 0x63, 0x32, 0x64, 0x36, 0x31, 0x36, 0x35, 0x66, 0x65, 0x32, 0x38, 0x38, 0x62, 0x30, 0x65, 0x39, 0x63, 0x61, 0x32, 0x61, 0x35, 0x39, 0x62, 0x65, 0x66, 0x64, 0x39, 0x31, 0x30, 0x39, 0x64, 0x34, 0x38, 0x32, 0x38, 0x34, 0x37, 0x63, 0x39, 0x39, 0x62, 0x65, 0x33, 0x66, 0x39, 0x38, 0x63, 0x31, 0x34, 0x36, 0x38, 0x65, 0x32, 0x64, 0x34, 0x66, 0x37, 0x62, 0x30, 0x37, 0x34, 0x31, 0x61, 0x62, 0x32, 0x64, 0x39, 0x66, 0x35, 0x63, 0x66, 0x30, 0x38, 0x34, 0x34, 0x30, 0x37, 0x36, 0x35, 0x34, 0x63, 0x63, 0x39, 0x37, 0x35, 0x64, 0x35, 0x35, 0x32, 0x64, 0x39, 0x61, 0x38, 0x33, 0x62, 0x66, 0x38, 0x66, 0x33, 0x31, 0x62, 0x64, 0x61, 0x65, 0x61, 0x31, 0x63, 0x33, 0x36, 0x64, 0x39, 0x31, 0x33, 0x38, 0x38, 0x36, 0x35, 0x39, 0x35, 0x62, 0x36, 0x31, 0x32, 0x30, 0x37, 0x62, 0x61, 0x31, 0x35, 0x62, 0x32, 0x30, 0x34, 0x62, 0x32, 0x31, 0x30, 0x64, 0x36, 0x33, 0x33, 0x65, 0x63, 0x34, 0x36, 0x61, 0x31, 0x61, 0x36, 0x64, 0x39, 0x31, 0x61, 0x34, 0x37, 0x62, 0x62, 0x34, 0x63, 0x36, 0x32, 0x64, 0x63, 0x36, 0x39, 0x38, 0x30, 0x38, 0x63, 0x31, 0x62, 0x34, 0x39, 0x64, 0x64, 0x38, 0x65, 0x32, 0x36, 0x61, 0x61, 0x31, 0x37, 0x32, 0x64, 0x30, 0x65, 0x38, 0x64, 0x35, 0x32, 0x30, 0x65, 0x30, 0x38, 0x34, 0x37, 0x32, 0x63, 0x62, 0x39, 0x39, 0x66, 0x66, 0x37, 0x61, 0x63, 0x36, 0x31, 0x31, 0x31, 0x66, 0x34, 0x62, 0x62, 0x37, 0x61, 0x31, 0x66, 0x62, 0x37, 0x61, 0x33, 0x33, 0x62, 0x35, 0x61, 0x33, 0x66, 0x62, 0x36, 0x33, 0x35, 0x38, 0x39, 0x37, 0x32, 0x37, 0x36, 0x65, 0x34, 0x39, 0x62, 0x32, 0x66, 0x30, 0x66, 0x35, 0x37, 0x61, 0x39, 0x35, 0x61, 0x39, 0x31, 0x37, 0x66, 0x37, 0x62, 0x32, 0x37, 0x32, 0x64, 0x65, 0x37, 0x66, 0x32, 0x39, 0x36, 0x39, 0x30, 0x32, 0x35, 0x61, 0x62, 0x63, 0x65, 0x39, 0x36, 0x39, 0x61, 0x66, 0x34, 0x61, 0x65, 0x39, 0x66, 0x34, 0x37, 0x35, 0x32, 0x66, 0x31, 0x62, 0x63, 0x38, 0x36, 0x35, 0x33, 0x62, 0x30, 0x61, 0x66, 0x31, 0x35, 0x38, 0x63, 0x31, 0x38, 0x64, 0x39, 0x35, 0x62, 0x33, 0x32, 0x37, 0x39, 0x66, 0x31, 0x35, 0x38, 0x66, 0x35, 0x31, 0x37, 0x32, 0x34, 0x62, 0x33, 0x61, 0x37, 0x36, 0x36, 0x30, 0x63, 0x39, 0x63, 0x38, 0x34, 0x63, 0x62, 0x38, 0x64, 0x66, 0x65, 0x34, 0x31, 0x66, 0x64, 0x31, 0x64, 0x36, 0x32, 0x63, 0x37, 0x64, 0x30, 0x66, 0x35, 0x66, 0x36, 0x33, 0x63, 0x35, 0x62, 0x64, 0x32, 0x64, 0x35, 0x66, 0x30, 0x66, 0x33, 0x30, 0x61, 0x36, 0x39, 0x38, 0x37, 0x36, 0x39, 0x38, 0x66, 0x39, 0x35, 0x61, 0x36, 0x64, 0x37, 0x32, 0x31, 0x66, 0x36, 0x35, 0x64, 0x62, 0x35, 0x34, 0x66, 0x32, 0x62, 0x34, 0x32, 0x61, 0x34, 0x66, 0x64, 0x61, 0x66, 0x62, 0x66, 0x33, 0x39, 0x66, 0x33, 0x35, 0x37, 0x34, 0x33, 0x62, 0x37, 0x65, 0x65, 0x38, 0x34, 0x35, 0x66, 0x30, 0x32, 0x65, 0x39, 0x64, 0x34, 0x63, 0x33, 0x30, 0x32, 0x66, 0x62, 0x61, 0x30, 0x35, 0x37, 0x38, 0x38, 0x64, 0x30, 0x66, 0x65, 0x39, 0x37, 0x66, 0x37, 0x32, 0x62, 0x37, 0x34, 0x65, 0x39, 0x64, 0x36, 0x36, 0x64, 0x35, 0x38, 0x62, 0x35, 0x61, 0x33, 0x38, 0x35, 0x38, 0x66, 0x30, 0x39, 0x62, 0x63, 0x61, 0x66, 0x33, 0x32, 0x31, 0x62, 0x32, 0x61, 0x32, 0x64, 0x63, 0x33, 0x64, 0x35, 0x63, 0x34, 0x63, 0x62, 0x61, 0x65, 0x30, 0x66, 0x33, 0x33, 0x35, 0x61, 0x39, 0x65, 0x39, 0x34, 0x31, 0x62, 0x32, 0x63, 0x37, 0x62, 0x39, 0x38, 0x33, 0x37, 0x32, 0x36, 0x37, 0x37, 0x61, 0x34, 0x35, 0x39, 0x37, 0x34, 0x66, 0x36, 0x35, 0x37, 0x39, 0x35, 0x65, 0x34, 0x63, 0x30, 0x65, 0x30, 0x33, 0x32, 0x30, 0x38, 0x38, 0x35, 0x37, 0x63, 0x37, 0x35, 0x66, 0x30, 0x38, 0x31, 0x66, 0x35, 0x36, 0x33, 0x66, 0x35, 0x30, 0x37, 0x34, 0x61, 0x35, 0x62, 0x64, 0x31, 0x63, 0x35, 0x65, 0x65, 0x31, 0x32, 0x30, 0x30, 0x31, 0x36, 0x37, 0x62, 0x38, 0x37, 0x32, 0x35, 0x63, 0x39, 0x39, 0x38, 0x34, 0x63, 0x64, 0x31, 0x61, 0x64, 0x34, 0x34, 0x32, 0x63, 0x33, 0x32, 0x64, 0x39, 0x66, 0x66, 0x34, 0x66, 0x66, 0x62, 0x34, 0x66, 0x65, 0x65, 0x34, 0x37, 0x64, 0x64, 0x61, 0x32, 0x33, 0x39, 0x34, 0x61, 0x37, 0x61, 0x37, 0x36, 0x34, 0x63, 0x30, 0x31, 0x38, 0x38, 0x62, 0x65, 0x39, 0x62, 0x32, 0x62, 0x32, 0x65, 0x34, 0x38, 0x30, 0x30, 0x64, 0x36, 0x35, 0x38, 0x65, 0x34, 0x39, 0x31, 0x36, 0x36, 0x37, 0x34, 0x36, 0x31, 0x61, 0x33, 0x31, 0x62, 0x36, 0x63, 0x37, 0x39, 0x37, 0x39, 0x61, 0x38, 0x64, 0x62, 0x37, 0x65, 0x38, 0x37, 0x61, 0x65, 0x63, 0x38, 0x35, 0x35, 0x32, 0x61, 0x34, 0x30, 0x62, 0x36, 0x66, 0x38, 0x37, 0x36, 0x61, 0x35, 0x32, 0x39, 0x33, 0x33, 0x62, 0x61, 0x34, 0x33, 0x62, 0x37, 0x35, 0x61, 0x31, 0x63, 0x39, 0x34, 0x61, 0x31, 0x30, 0x62, 0x30, 0x66, 0x61, 0x32, 0x33, 0x37, 0x36, 0x37, 0x66, 0x30, 0x34, 0x61, 0x38, 0x61, 0x65, 0x32, 0x34, 0x64, 0x38, 0x39, 0x61, 0x35, 0x36, 0x63, 0x36, 0x63, 0x33, 0x32, 0x66, 0x32, 0x65, 0x35, 0x30, 0x32, 0x64, 0x63, 0x30, 0x32, 0x35, 0x32, 0x30, 0x36, 0x64, 0x35, 0x38, 0x36, 0x37, 0x34, 0x66, 0x39, 0x65, 0x64, 0x39, 0x34, 0x30, 0x35, 0x30, 0x36, 0x31, 0x37, 0x32, 0x63, 0x38, 0x65, 0x37, 0x38, 0x61, 0x39, 0x33, 0x38, 0x35, 0x64, 0x37, 0x38, 0x66, 0x36, 0x61, 0x61, 0x34, 0x65, 0x62, 0x31, 0x39, 0x32, 0x61, 0x64, 0x63, 0x66, 0x34, 0x39, 0x37, 0x63, 0x39, 0x62, 0x38, 0x37, 0x39, 0x30, 0x31, 0x39, 0x64, 0x34, 0x30, 0x65, 0x64, 0x63, 0x32, 0x62, 0x61, 0x65, 0x66, 0x35, 0x65, 0x62, 0x30, 0x31, 0x62, 0x61, 0x66, 0x31, 0x31, 0x32, 0x31, 0x37, 0x32, 0x64, 0x32, 0x61, 0x32, 0x38, 0x63, 0x33, 0x62, 0x62, 0x66, 0x39, 0x39, 0x32, 0x65, 0x34, 0x30, 0x64, 0x34, 0x66, 0x30, 0x39, 0x65, 0x66, 0x33, 0x32, 0x65, 0x34, 0x37, 0x64, 0x37, 0x31, 0x62, 0x35, 0x34, 0x32, 0x36, 0x62, 0x64, 0x62, 0x32, 0x36, 0x37, 0x33, 0x31, 0x32, 0x62, 0x31, 0x34, 0x31, 0x65, 0x34, 0x35, 0x30, 0x32, 0x32, 0x32, 0x34, 0x36, 0x31, 0x65, 0x35, 0x39, 0x37, 0x32, 0x36, 0x36, 0x31, 0x34, 0x61, 0x38, 0x34, 0x33, 0x36, 0x63, 0x63, 0x35, 0x62, 0x63, 0x37, 0x63, 0x30, 0x38, 0x35, 0x64, 0x36, 0x38, 0x39, 0x64, 0x35, 0x64, 0x32, 0x33, 0x62, 0x33, 0x37, 0x31, 0x37, 0x33, 0x32, 0x61, 0x34, 0x38, 0x37, 0x35, 0x38, 0x39, 0x38, 0x36, 0x32, 0x38, 0x63, 0x39, 0x61, 0x63, 0x66, 0x33, 0x33, 0x39, 0x62, 0x34, 0x34, 0x64, 0x38, 0x37, 0x31, 0x32, 0x37, 0x32, 0x34, 0x38, 0x65, 0x33, 0x30, 0x37, 0x37, 0x32, 0x35, 0x64, 0x33, 0x34, 0x36, 0x35, 0x62, 0x63, 0x62, 0x37, 0x36, 0x31, 0x36, 0x35, 0x35, 0x31, 0x65, 0x37, 0x62, 0x61, 0x65, 0x66, 0x32, 0x66, 0x34, 0x33, 0x62, 0x30, 0x36, 0x61, 0x66, 0x62, 0x63, 0x61, 0x33, 0x32, 0x64, 0x66, 0x37, 0x38, 0x37, 0x63, 0x38, 0x30, 0x37, 0x38, 0x32, 0x66, 0x62, 0x63, 0x37, 0x36, 0x38, 0x62, 0x31, 0x35, 0x65, 0x61, 0x36, 0x62, 0x39, 0x38, 0x35, 0x38, 0x61, 0x63, 0x32, 0x65, 0x38, 0x36, 0x38, 0x63, 0x35, 0x65, 0x34, 0x63, 0x65, 0x38, 0x33, 0x32, 0x66, 0x62, 0x36, 0x30, 0x36, 0x37, 0x62, 0x35, 0x66, 0x31, 0x64, 0x64, 0x38, 0x37, 0x34, 0x38, 0x30, 0x61, 0x63, 0x35, 0x63, 0x65, 0x66, 0x61, 0x64, 0x30, 0x61, 0x64, 0x34, 0x62, 0x65, 0x62, 0x36, 0x36, 0x65, 0x37, 0x63, 0x62, 0x31, 0x34, 0x64, 0x35, 0x37, 0x37, 0x65, 0x39, 0x62, 0x63, 0x34, 0x64, 0x63, 0x64, 0x31, 0x38, 0x31, 0x39, 0x35, 0x31, 0x37, 0x63, 0x61, 0x61, 0x36, 0x38, 0x32, 0x61, 0x66, 0x35, 0x37, 0x35, 0x33, 0x39, 0x32, 0x66, 0x64, 0x30, 0x38, 0x65, 0x32, 0x30, 0x35, 0x30, 0x31, 0x31, 0x36, 0x63, 0x66, 0x61, 0x37, 0x61, 0x64, 0x39, 0x35, 0x61, 0x31, 0x36, 0x32, 0x62, 0x33, 0x38, 0x32, 0x35, 0x35, 0x63, 0x61, 0x65, 0x33, 0x39, 0x66, 0x31, 0x34, 0x32, 0x63, 0x30, 0x33, 0x65, 0x32, 0x61, 0x65, 0x33, 0x62, 0x64, 0x65, 0x63, 0x38, 0x34, 0x30, 0x61, 0x63, 0x34, 0x61, 0x62, 0x62, 0x63, 0x38, 0x63, 0x63, 0x39, 0x32, 0x32, 0x62, 0x61, 0x62, 0x63, 0x33, 0x65, 0x65, 0x65, 0x31, 0x61, 0x38, 0x63, 0x62, 0x34, 0x38, 0x37, 0x38, 0x61, 0x61, 0x31, 0x31, 0x31, 0x61, 0x36, 0x34, 0x35, 0x37, 0x32, 0x39, 0x35, 0x62, 0x64, 0x35, 0x36, 0x66, 0x33, 0x65, 0x35, 0x37, 0x37, 0x30, 0x31, 0x64, 0x33, 0x33, 0x66, 0x31, 0x36, 0x34, 0x34, 0x31, 0x36, 0x64, 0x61, 0x30, 0x65, 0x65, 0x38, 0x39, 0x37, 0x35, 0x33, 0x30, 0x66, 0x32, 0x30, 0x37, 0x63, 0x32, 0x66, 0x63, 0x35, 0x65, 0x38, 0x39, 0x31, 0x31, 0x32, 0x37, 0x35, 0x62, 0x66, 0x31, 0x35, 0x38, 0x34, 0x34, 0x38, 0x62, 0x35, 0x30, 0x36, 0x65, 0x34, 0x64, 0x35, 0x37, 0x64, 0x62, 0x32, 0x38, 0x38, 0x35, 0x62, 0x38, 0x62, 0x34, 0x34, 0x37, 0x34, 0x64, 0x39, 0x35, 0x37, 0x37, 0x35, 0x66, 0x65, 0x33, 0x66, 0x65, 0x33, 0x32, 0x66, 0x61, 0x64, 0x62, 0x65, 0x32, 0x39, 0x64, 0x35, 0x62, 0x31, 0x34, 0x37, 0x33, 0x32, 0x34, 0x37, 0x34, 0x34, 0x31, 0x61, 0x62, 0x32, 0x63, 0x32, 0x64, 0x35, 0x66, 0x33, 0x32, 0x37, 0x30, 0x63, 0x30, 0x34, 0x65, 0x31, 0x62, 0x31, 0x61, 0x66, 0x32, 0x36, 0x35, 0x64, 0x34, 0x65, 0x61, 0x35, 0x38, 0x33, 0x63, 0x64, 0x39, 0x31, 0x33, 0x37, 0x30, 0x35, 0x30, 0x61, 0x62, 0x30, 0x38, 0x63, 0x36, 0x64, 0x37, 0x63, 0x66, 0x65, 0x63, 0x35, 0x61, 0x61, 0x31, 0x33, 0x66, 0x35, 0x31, 0x34, 0x64, 0x64, 0x38, 0x30, 0x31, 0x37, 0x31, 0x65, 0x32, 0x61, 0x34, 0x38, 0x62, 0x64, 0x37, 0x32, 0x30, 0x34, 0x33, 0x36, 0x30, 0x33, 0x37, 0x30, 0x37, 0x33, 0x61, 0x37, 0x39, 0x33, 0x66, 0x31, 0x64, 0x36, 0x65, 0x36, 0x31, 0x36, 0x37, 0x38, 0x35, 0x33, 0x32, 0x32, 0x39, 0x36, 0x64, 0x37, 0x36, 0x61, 0x65, 0x33, 0x62, 0x32, 0x62, 0x35, 0x62, 0x33, 0x30, 0x66, 0x63, 0x31, 0x33, 0x63, 0x30, 0x31, 0x61, 0x31, 0x66, 0x37, 0x33, 0x30, 0x65, 0x65, 0x36, 0x63, 0x61, 0x35, 0x31, 0x37, 0x64, 0x37, 0x35, 0x63, 0x31, 0x64, 0x66, 0x66, 0x33, 0x63, 0x32, 0x65, 0x34, 0x38, 0x63, 0x61, 0x65, 0x35, 0x62, 0x38, 0x38, 0x63, 0x33, 0x32, 0x35, 0x34, 0x61, 0x66, 0x62, 0x37, 0x31, 0x64, 0x30, 0x39, 0x31, 0x65, 0x32, 0x62, 0x32, 0x36, 0x38, 0x30, 0x37, 0x39, 0x31, 0x64, 0x35, 0x65, 0x36, 0x64, 0x66, 0x61, 0x33, 0x32, 0x37, 0x30, 0x37, 0x31, 0x33, 0x32, 0x39, 0x30, 0x37, 0x32, 0x33, 0x33, 0x33, 0x33, 0x66, 0x35, 0x65, 0x33, 0x37, 0x33, 0x64, 0x31, 0x34, 0x35, 0x32, 0x62, 0x34, 0x34, 0x61, 0x33, 0x37, 0x36, 0x33, 0x35, 0x32, 0x39, 0x38, 0x39, 0x30, 0x35, 0x32, 0x31, 0x34, 0x63, 0x61, 0x61, 0x39, 0x63, 0x66, 0x38, 0x30, 0x39, 0x38, 0x33, 0x34, 0x66, 0x63, 0x36, 0x65, 0x36, 0x39, 0x61, 0x31, 0x31, 0x39, 0x37, 0x33, 0x34, 0x35, 0x65, 0x64, 0x32, 0x37, 0x32, 0x35, 0x33, 0x32, 0x30, 0x34, 0x34, 0x32, 0x65, 0x37, 0x37, 0x39, 0x61, 0x30, 0x38, 0x33, 0x61, 0x33, 0x30, 0x31, 0x30, 0x61, 0x63, 0x65, 0x37, 0x62, 0x36, 0x61, 0x35, 0x30, 0x33, 0x38, 0x61, 0x64, 0x66, 0x31, 0x35, 0x63, 0x30, 0x31, 0x64, 0x35, 0x66, 0x31, 0x35, 0x37, 0x38, 0x65, 0x61, 0x33, 0x31, 0x37, 0x39, 0x38, 0x32, 0x63, 0x33, 0x61, 0x61, 0x35, 0x65, 0x39, 0x36, 0x30, 0x62, 0x64, 0x38, 0x32, 0x65, 0x61, 0x34, 0x39, 0x30, 0x36, 0x32, 0x38, 0x63, 0x34, 0x35, 0x61, 0x36, 0x63, 0x34, 0x38, 0x33, 0x66, 0x31, 0x64, 0x32, 0x64, 0x39, 0x35, 0x37, 0x61, 0x39, 0x36, 0x62, 0x63, 0x36, 0x39, 0x33, 0x36, 0x66, 0x39, 0x35, 0x61, 0x39, 0x38, 0x31, 0x35, 0x36, 0x39, 0x65, 0x65, 0x35, 0x35, 0x37, 0x36, 0x39, 0x66, 0x63, 0x34, 0x62, 0x33, 0x37, 0x61, 0x33, 0x37, 0x32, 0x30, 0x62, 0x31, 0x63, 0x35, 0x65, 0x30, 0x32, 0x34, 0x63, 0x33, 0x36, 0x35, 0x37, 0x66, 0x33, 0x31, 0x63, 0x63, 0x66, 0x31, 0x30, 0x37, 0x63, 0x66, 0x35, 0x65, 0x37, 0x62, 0x35, 0x65, 0x66, 0x34, 0x35, 0x38, 0x61, 0x30, 0x39, 0x37, 0x38, 0x65, 0x34, 0x36, 0x39, 0x63, 0x37, 0x30, 0x33, 0x33, 0x35, 0x38, 0x32, 0x64, 0x65, 0x65, 0x31, 0x30, 0x34, 0x63, 0x34, 0x37, 0x62, 0x37, 0x32, 0x34, 0x63, 0x38, 0x65, 0x63, 0x32, 0x36, 0x34, 0x63, 0x35, 0x65, 0x36, 0x39, 0x34, 0x30, 0x38, 0x38, 0x64, 0x66, 0x37, 0x38, 0x35, 0x34, 0x64, 0x33, 0x38, 0x34, 0x33, 0x64, 0x33, 0x61, 0x30, 0x31, 0x36, 0x32, 0x64, 0x39, 0x38, 0x66, 0x65, 0x61, 0x33, 0x63, 0x37, 0x36, 0x61, 0x63, 0x66, 0x37, 0x36, 0x36, 0x38, 0x62, 0x39, 0x62, 0x66, 0x34, 0x65, 0x62, 0x39, 0x38, 0x66, 0x31, 0x39, 0x32, 0x30, 0x31, 0x35, 0x30, 0x61, 0x38, 0x35, 0x35, 0x33, 0x61, 0x66, 0x31, 0x62, 0x34, 0x35, 0x32, 0x33, 0x38, 0x33, 0x34, 0x61, 0x32, 0x62, 0x65, 0x35, 0x62, 0x37, 0x62, 0x35, 0x31, 0x62, 0x61, 0x63, 0x62, 0x38, 0x30, 0x30, 0x62, 0x33, 0x65, 0x64, 0x62, 0x64, 0x66, 0x62, 0x35, 0x38, 0x35, 0x66, 0x64, 0x30, 0x61, 0x64, 0x63, 0x35, 0x37, 0x35, 0x61, 0x62, 0x66, 0x38, 0x37, 0x32, 0x38, 0x33, 0x33, 0x63, 0x35, 0x38, 0x65, 0x32, 0x36, 0x36, 0x63, 0x35, 0x39, 0x66, 0x34, 0x61, 0x37, 0x61, 0x62, 0x35, 0x34, 0x66, 0x38, 0x36, 0x32, 0x64, 0x65, 0x39, 0x31, 0x33, 0x39, 0x38, 0x36, 0x66, 0x36, 0x35, 0x63, 0x38, 0x34, 0x36, 0x61, 0x66, 0x34, 0x66, 0x33, 0x66, 0x37, 0x63, 0x39, 0x39, 0x62, 0x35, 0x33, 0x63, 0x32, 0x32, 0x64, 0x61, 0x65, 0x38, 0x65, 0x31, 0x32, 0x35, 0x35, 0x37, 0x30, 0x30, 0x62, 0x62, 0x34, 0x33, 0x62, 0x39, 0x33, 0x33, 0x61, 0x38, 0x32, 0x30, 0x32, 0x35, 0x61, 0x31, 0x64, 0x35, 0x33, 0x65, 0x64, 0x30, 0x37, 0x61, 0x39, 0x39, 0x32, 0x32, 0x38, 0x36, 0x63, 0x33, 0x39, 0x63, 0x34, 0x32, 0x39, 0x64, 0x33, 0x37, 0x64, 0x64, 0x30, 0x30, 0x30, 0x66, 0x37, 0x65, 0x65, 0x66, 0x31, 0x63, 0x38, 0x36, 0x64, 0x35, 0x65, 0x37, 0x37, 0x32, 0x32, 0x31, 0x38, 0x39, 0x37, 0x39, 0x62, 0x66, 0x31, 0x36, 0x33, 0x39, 0x39, 0x64, 0x34, 0x61, 0x32, 0x61, 0x63, 0x35, 0x30, 0x62, 0x66, 0x65, 0x32, 0x33, 0x34, 0x35, 0x34, 0x35, 0x64, 0x30, 0x37, 0x64, 0x30, 0x62, 0x65, 0x32, 0x33, 0x39, 0x30, 0x65, 0x37, 0x39, 0x62, 0x39, 0x62, 0x39, 0x65, 0x38, 0x64, 0x33, 0x31, 0x35, 0x66, 0x33, 0x33, 0x30, 0x64, 0x61, 0x34, 0x63, 0x37, 0x32, 0x34, 0x38, 0x31, 0x64, 0x62, 0x63, 0x66, 0x63, 0x39, 0x66, 0x35, 0x66, 0x34, 0x36, 0x35, 0x34, 0x32, 0x61, 0x34, 0x35, 0x61, 0x35, 0x65, 0x32, 0x38, 0x31, 0x65, 0x64, 0x36, 0x37, 0x30, 0x37, 0x30, 0x39, 0x36, 0x63, 0x39, 0x33, 0x39, 0x63, 0x65, 0x35, 0x62, 0x66, 0x34, 0x35, 0x33, 0x39, 0x37, 0x34, 0x30, 0x61, 0x37, 0x64, 0x66, 0x30, 0x33, 0x39, 0x39, 0x32, 0x36, 0x38, 0x37, 0x32, 0x64, 0x37, 0x38, 0x36, 0x37, 0x34, 0x31, 0x36, 0x37, 0x39, 0x33, 0x64, 0x31, 0x30, 0x61, 0x62, 0x31, 0x65, 0x61, 0x31, 0x36, 0x31, 0x61, 0x33, 0x63, 0x38, 0x31, 0x39, 0x37, 0x39, 0x38, 0x66, 0x30, 0x32, 0x63, 0x34, 0x65, 0x34, 0x61, 0x34, 0x39, 0x37, 0x66, 0x33, 0x34, 0x38, 0x64, 0x38, 0x31, 0x61, 0x33, 0x34, 0x38, 0x34, 0x36, 0x32, 0x35, 0x66, 0x34, 0x33, 0x34, 0x36, 0x37, 0x32, 0x63, 0x30, 0x30, 0x61, 0x37, 0x32, 0x35, 0x39, 0x37, 0x32, 0x31, 0x35, 0x63, 0x35, 0x30, 0x30, 0x33, 0x39, 0x61, 0x62, 0x33, 0x36, 0x31, 0x30, 0x32, 0x36, 0x62, 0x39, 0x37, 0x62, 0x38, 0x38, 0x61, 0x66, 0x61, 0x39, 0x39, 0x32, 0x35, 0x34, 0x38, 0x37, 0x35, 0x37, 0x36, 0x62, 0x30, 0x34, 0x37, 0x62, 0x63, 0x66, 0x37, 0x32, 0x31, 0x36, 0x63, 0x32, 0x39, 0x33, 0x35, 0x38, 0x37, 0x32, 0x62, 0x65, 0x39, 0x61, 0x38, 0x62, 0x64, 0x33, 0x33, 0x62, 0x30, 0x62, 0x36, 0x34, 0x36, 0x65, 0x66, 0x65, 0x31, 0x38, 0x36, 0x35, 0x39, 0x38, 0x35, 0x62, 0x39, 0x64, 0x63, 0x31, 0x32, 0x62, 0x66, 0x63, 0x30, 0x64, 0x62, 0x30, 0x63, 0x34, 0x33, 0x62, 0x36, 0x33, 0x61, 0x32, 0x61, 0x35, 0x66, 0x30, 0x64, 0x66, 0x37, 0x62, 0x33, 0x37, 0x66, 0x33, 0x31, 0x64, 0x35, 0x36, 0x37, 0x32, 0x36, 0x62, 0x34, 0x65, 0x31, 0x32, 0x35, 0x61, 0x31, 0x66, 0x62, 0x38, 0x34, 0x38, 0x38, 0x37, 0x31, 0x39, 0x35, 0x65, 0x62, 0x34, 0x35, 0x39, 0x31, 0x61, 0x33, 0x62, 0x38, 0x38, 0x64, 0x33, 0x38, 0x32, 0x32, 0x30, 0x37, 0x32, 0x32, 0x39, 0x33, 0x39, 0x39, 0x36, 0x31, 0x30, 0x32, 0x35, 0x31, 0x34, 0x66, 0x33, 0x31, 0x35, 0x62, 0x36, 0x64, 0x31, 0x64, 0x65, 0x64, 0x38, 0x32, 0x35, 0x66, 0x37, 0x66, 0x30, 0x36, 0x66, 0x39, 0x34, 0x32, 0x31, 0x39, 0x37, 0x38, 0x64, 0x35, 0x39, 0x38, 0x31, 0x66, 0x61, 0x66, 0x34, 0x66, 0x35, 0x66, 0x34, 0x64, 0x35, 0x32, 0x34, 0x38, 0x38, 0x64, 0x32, 0x31, 0x66, 0x66, 0x63, 0x66, 0x66, 0x36, 0x62, 0x31, 0x34, 0x62, 0x30, 0x34, 0x38, 0x37, 0x30, 0x36, 0x34, 0x32, 0x62, 0x62, 0x66, 0x35, 0x30, 0x65, 0x63, 0x63, 0x66, 0x35, 0x66, 0x64, 0x38, 0x32, 0x34, 0x61, 0x36, 0x34, 0x38, 0x30, 0x32, 0x37, 0x32, 0x35, 0x31, 0x66, 0x39, 0x34, 0x62, 0x63, 0x36, 0x62, 0x32, 0x30, 0x64, 0x33, 0x39, 0x36, 0x66, 0x35, 0x30, 0x39, 0x32, 0x63, 0x34, 0x34, 0x66, 0x32, 0x32, 0x63, 0x34, 0x31, 0x62, 0x66, 0x30, 0x38, 0x31, 0x63, 0x39, 0x62, 0x38, 0x62, 0x32, 0x35, 0x33, 0x61, 0x37, 0x65, 0x33, 0x39, 0x61, 0x37, 0x39, 0x37, 0x32, 0x64, 0x62, 0x36, 0x61, 0x62, 0x61, 0x37, 0x62, 0x66, 0x65, 0x35, 0x66, 0x61, 0x61, 0x31, 0x34, 0x33, 0x31, 0x31, 0x61, 0x30, 0x30, 0x33, 0x64, 0x65, 0x64, 0x32, 0x37, 0x65, 0x36, 0x61, 0x35, 0x30, 0x31, 0x63, 0x39, 0x39, 0x62, 0x37, 0x66, 0x31, 0x33, 0x37, 0x63, 0x33, 0x36, 0x34, 0x35, 0x36, 0x32, 0x65, 0x34, 0x64, 0x35, 0x62, 0x34, 0x65, 0x34, 0x30, 0x39, 0x30, 0x64, 0x37, 0x32, 0x39, 0x30, 0x61, 0x39, 0x34, 0x66, 0x34, 0x61, 0x66, 0x62, 0x33, 0x35, 0x35, 0x39, 0x39, 0x39, 0x37, 0x65, 0x34, 0x36, 0x37, 0x36, 0x63, 0x32, 0x31, 0x34, 0x66, 0x34, 0x37, 0x63, 0x34, 0x32, 0x63, 0x65, 0x63, 0x38, 0x66, 0x31, 0x65, 0x64, 0x35, 0x33, 0x39, 0x38, 0x31, 0x37, 0x62, 0x30, 0x37, 0x36, 0x39, 0x33, 0x34, 0x63, 0x63, 0x30, 0x35, 0x30, 0x30, 0x33, 0x37, 0x63, 0x37, 0x32, 0x39, 0x34, 0x30, 0x33, 0x34, 0x34, 0x33, 0x35, 0x61, 0x61, 0x34, 0x37, 0x36, 0x37, 0x38, 0x66, 0x66, 0x66, 0x39, 0x66, 0x31, 0x35, 0x36, 0x36, 0x37, 0x35, 0x61, 0x38, 0x34, 0x35, 0x65, 0x66, 0x33, 0x62, 0x62, 0x35, 0x30, 0x65, 0x35, 0x63, 0x66, 0x36, 0x33, 0x39, 0x34, 0x36, 0x64, 0x36, 0x62, 0x30, 0x65, 0x35, 0x33, 0x63, 0x30, 0x39, 0x63, 0x61, 0x63, 0x65, 0x30, 0x30, 0x37, 0x32, 0x31, 0x34, 0x64, 0x66, 0x63, 0x66, 0x30, 0x65, 0x66, 0x30, 0x36, 0x32, 0x35, 0x65, 0x31, 0x61, 0x66, 0x34, 0x33, 0x39, 0x32, 0x36, 0x37, 0x35, 0x32, 0x62, 0x37, 0x37, 0x32, 0x30, 0x32, 0x37, 0x39, 0x37, 0x34, 0x39, 0x37, 0x34, 0x38, 0x66, 0x33, 0x36, 0x65, 0x38, 0x34, 0x30, 0x39, 0x61, 0x62, 0x63, 0x37, 0x32, 0x39, 0x62, 0x64, 0x31, 0x61, 0x31, 0x62, 0x39, 0x61, 0x65, 0x30, 0x36, 0x64, 0x61, 0x65, 0x63, 0x39, 0x65, 0x61, 0x35, 0x36, 0x34, 0x65, 0x34, 0x65, 0x64, 0x33, 0x30, 0x31, 0x61, 0x37, 0x37, 0x65, 0x64, 0x37, 0x63, 0x33, 0x33, 0x39, 0x31, 0x31, 0x65, 0x63, 0x30, 0x34, 0x34, 0x64, 0x38, 0x32, 0x65, 0x39, 0x63, 0x34, 0x32, 0x39, 0x36, 0x63, 0x63, 0x31, 0x37, 0x33, 0x63, 0x30, 0x66, 0x30, 0x31, 0x32, 0x39, 0x38, 0x35, 0x30, 0x36, 0x63, 0x39, 0x37, 0x32, 0x65, 0x63, 0x63, 0x37, 0x39, 0x30, 0x65, 0x62, 0x30, 0x61, 0x36, 0x33, 0x66, 0x61, 0x62, 0x61, 0x37, 0x34, 0x61, 0x64, 0x62, 0x31, 0x66, 0x37, 0x37, 0x66, 0x61, 0x36, 0x34, 0x30, 0x36, 0x38, 0x65, 0x62, 0x61, 0x62, 0x38, 0x65, 0x33, 0x63, 0x39, 0x38, 0x34, 0x30, 0x62, 0x65, 0x37, 0x34, 0x32, 0x37, 0x34, 0x33, 0x37, 0x34, 0x61, 0x66, 0x30, 0x32, 0x35, 0x30, 0x66, 0x33, 0x37, 0x32, 0x38, 0x64, 0x63, 0x64, 0x34, 0x66, 0x33, 0x35, 0x30, 0x62, 0x35, 0x37, 0x31, 0x33, 0x30, 0x36, 0x32, 0x37, 0x38, 0x63, 0x37, 0x66, 0x62, 0x65, 0x63, 0x63, 0x39, 0x35, 0x63, 0x36, 0x61, 0x39, 0x38, 0x64, 0x37, 0x61, 0x31, 0x36, 0x66, 0x61, 0x65, 0x65, 0x38, 0x35, 0x39, 0x38, 0x38, 0x30, 0x31, 0x64, 0x31, 0x30, 0x31, 0x62, 0x66, 0x30, 0x63, 0x65, 0x39, 0x30, 0x34, 0x37, 0x31, 0x63, 0x31, 0x31, 0x33, 0x65, 0x31, 0x32, 0x32, 0x32, 0x33, 0x36, 0x30, 0x34, 0x65, 0x34, 0x63, 0x64, 0x30, 0x64, 0x33, 0x32, 0x34, 0x64, 0x37, 0x39, 0x36, 0x65, 0x61, 0x35, 0x63, 0x35, 0x32, 0x61, 0x38, 0x37, 0x31, 0x38, 0x34, 0x64, 0x61, 0x34, 0x61, 0x61, 0x61, 0x34, 0x39, 0x30, 0x63, 0x35, 0x66, 0x65, 0x30, 0x38, 0x61, 0x30, 0x30, 0x64, 0x62, 0x66, 0x63, 0x66, 0x66, 0x33, 0x30, 0x32, 0x66, 0x30, 0x63, 0x34, 0x61, 0x39, 0x34, 0x66, 0x66, 0x39, 0x34, 0x66, 0x39, 0x38, 0x65, 0x65, 0x33, 0x62, 0x30, 0x64, 0x61, 0x34, 0x32, 0x35, 0x62, 0x31, 0x33, 0x36, 0x66, 0x62, 0x65, 0x65, 0x38, 0x30, 0x34, 0x30, 0x63, 0x62, 0x63, 0x30, 0x36, 0x37, 0x30, 0x61, 0x36, 0x66, 0x34, 0x32, 0x31, 0x35, 0x30, 0x34, 0x62, 0x32, 0x32, 0x30, 0x35, 0x63, 0x66, 0x66, 0x36, 0x64, 0x34, 0x37, 0x39, 0x37, 0x31, 0x32, 0x34, 0x64, 0x33, 0x33, 0x36, 0x30, 0x33, 0x37, 0x37, 0x30, 0x61, 0x32, 0x64, 0x31, 0x64, 0x39, 0x65, 0x37, 0x39, 0x63, 0x66, 0x65, 0x39, 0x30, 0x66, 0x66, 0x34, 0x33, 0x64, 0x66, 0x39, 0x38, 0x63, 0x62, 0x34, 0x33, 0x65, 0x30, 0x61, 0x64, 0x30, 0x38, 0x35, 0x38, 0x65, 0x31, 0x62, 0x33, 0x39, 0x63, 0x32, 0x62, 0x64, 0x31, 0x37, 0x31, 0x33, 0x64, 0x37, 0x32, 0x31, 0x62, 0x32, 0x32, 0x32, 0x32, 0x66, 0x37, 0x31, 0x61, 0x39, 0x31, 0x65, 0x32, 0x36, 0x63, 0x30, 0x63, 0x37, 0x32, 0x32, 0x61, 0x62, 0x61, 0x39, 0x30, 0x61, 0x32, 0x32, 0x65, 0x64, 0x35, 0x65, 0x66, 0x66, 0x33, 0x33, 0x36, 0x30, 0x31, 0x38, 0x37, 0x34, 0x64, 0x37, 0x62, 0x65, 0x36, 0x30, 0x63, 0x63, 0x36, 0x62, 0x64, 0x66, 0x35, 0x62, 0x39, 0x38, 0x65, 0x30, 0x34, 0x35, 0x62, 0x32, 0x37, 0x34, 0x34, 0x39, 0x36, 0x64, 0x39, 0x35, 0x35, 0x61, 0x66, 0x33, 0x64, 0x62, 0x39, 0x31, 0x39, 0x36, 0x30, 0x31, 0x31, 0x66, 0x65, 0x30, 0x62, 0x63, 0x37, 0x33, 0x64, 0x37, 0x61, 0x64, 0x30, 0x37, 0x37, 0x61, 0x34, 0x33, 0x33, 0x36, 0x38, 0x64, 0x39, 0x32, 0x65, 0x31, 0x66, 0x32, 0x30, 0x65, 0x37, 0x65, 0x32, 0x33, 0x61, 0x34, 0x66, 0x36, 0x30, 0x65, 0x62, 0x35, 0x63, 0x63, 0x37, 0x66, 0x34, 0x32, 0x66, 0x62, 0x31, 0x32, 0x36, 0x62, 0x36, 0x35, 0x39, 0x65, 0x31, 0x34, 0x31, 0x65, 0x63, 0x65, 0x35, 0x63, 0x32, 0x62, 0x63, 0x33, 0x63, 0x39, 0x38, 0x34, 0x66, 0x32, 0x37, 0x37, 0x37, 0x63, 0x38, 0x63, 0x63, 0x66, 0x37, 0x61, 0x63, 0x35, 0x35, 0x63, 0x66, 0x65, 0x38, 0x35, 0x62, 0x65, 0x64, 0x31, 0x39, 0x64, 0x31, 0x35, 0x63, 0x30, 0x34, 0x35, 0x38, 0x32, 0x31, 0x32, 0x62, 0x33, 0x30, 0x34, 0x31, 0x37, 0x61, 0x37, 0x34, 0x62, 0x66, 0x65, 0x31, 0x39, 0x39, 0x34, 0x39, 0x62, 0x63, 0x63, 0x33, 0x66, 0x66, 0x32, 0x62, 0x66, 0x37, 0x30, 0x62, 0x64, 0x30, 0x63, 0x66, 0x62, 0x32, 0x62, 0x39, 0x32, 0x64, 0x66, 0x38, 0x38, 0x62, 0x36, 0x32, 0x37, 0x63, 0x30, 0x38, 0x36, 0x64, 0x38, 0x31, 0x34, 0x65, 0x63, 0x65, 0x34, 0x61, 0x37, 0x32, 0x63, 0x34, 0x37, 0x62, 0x30, 0x34, 0x31, 0x62, 0x62, 0x63, 0x30, 0x37, 0x34, 0x30, 0x61, 0x32, 0x35, 0x35, 0x64, 0x39, 0x38, 0x34, 0x65, 0x37, 0x32, 0x39, 0x63, 0x62, 0x36, 0x64, 0x62, 0x31, 0x35, 0x35, 0x31, 0x63, 0x62, 0x65, 0x66, 0x65, 0x64, 0x37, 0x62, 0x33, 0x31, 0x65, 0x32, 0x66, 0x64, 0x35, 0x61, 0x36, 0x37, 0x33, 0x34, 0x30, 0x31, 0x62, 0x63, 0x32, 0x34, 0x65, 0x35, 0x33, 0x65, 0x35, 0x39, 0x34, 0x33, 0x33, 0x62, 0x63, 0x64, 0x64, 0x62, 0x34, 0x66, 0x64, 0x36, 0x36, 0x39, 0x66, 0x30, 0x35, 0x36, 0x64, 0x34, 0x33, 0x37, 0x64, 0x31, 0x63, 0x33, 0x61, 0x32, 0x36, 0x34, 0x34, 0x63, 0x37, 0x35, 0x64, 0x33, 0x66, 0x63, 0x37, 0x62, 0x66, 0x65, 0x31, 0x35, 0x31, 0x31, 0x63, 0x34, 0x33, 0x63, 0x66, 0x39, 0x62, 0x35, 0x63, 0x36, 0x62, 0x35, 0x64, 0x34, 0x35, 0x34, 0x66, 0x63, 0x37, 0x66, 0x36, 0x65, 0x63, 0x33, 0x38, 0x35, 0x32, 0x64, 0x63, 0x34, 0x63, 0x32, 0x66, 0x33, 0x38, 0x62, 0x37, 0x34, 0x32, 0x66, 0x39, 0x34, 0x35, 0x39, 0x38, 0x63, 0x39, 0x32, 0x36, 0x37, 0x62, 0x38, 0x64, 0x35, 0x32, 0x34, 0x33, 0x34, 0x66, 0x33, 0x34, 0x64, 0x38, 0x38, 0x64, 0x36, 0x36, 0x33, 0x39, 0x62, 0x36, 0x66, 0x38, 0x35, 0x38, 0x34, 0x63, 0x35, 0x63, 0x34, 0x66, 0x33, 0x63, 0x63, 0x30, 0x30, 0x61, 0x30, 0x31, 0x66, 0x63, 0x63, 0x62, 0x33, 0x31, 0x65, 0x66, 0x65, 0x30, 0x39, 0x31, 0x33, 0x34, 0x62, 0x62, 0x32, 0x65, 0x63, 0x66, 0x32, 0x30, 0x61, 0x65, 0x36, 0x64, 0x33, 0x35, 0x61, 0x35, 0x63, 0x30, 0x39, 0x62, 0x62, 0x30, 0x37, 0x36, 0x65, 0x61, 0x37, 0x38, 0x63, 0x31, 0x38, 0x30, 0x32, 0x34, 0x33, 0x34, 0x62, 0x62, 0x37, 0x32, 0x63, 0x65, 0x37, 0x61, 0x37, 0x65, 0x65, 0x30, 0x61, 0x66, 0x66, 0x34, 0x64, 0x35, 0x38, 0x62, 0x34, 0x34, 0x39, 0x34, 0x64, 0x39, 0x32, 0x37, 0x33, 0x36, 0x31, 0x34, 0x66, 0x65, 0x30, 0x35, 0x34, 0x61, 0x66, 0x35, 0x63, 0x62, 0x62, 0x33, 0x65, 0x64, 0x63, 0x64, 0x63, 0x65, 0x31, 0x30, 0x63, 0x33, 0x64, 0x66, 0x34, 0x30, 0x32, 0x32, 0x30, 0x39, 0x66, 0x64, 0x30, 0x66, 0x34, 0x32, 0x33, 0x36, 0x34, 0x61, 0x32, 0x61, 0x63, 0x65, 0x66, 0x39, 0x61, 0x62, 0x36, 0x33, 0x33, 0x63, 0x65, 0x34, 0x62, 0x65, 0x66, 0x63, 0x36, 0x66, 0x63, 0x65, 0x31, 0x35, 0x32, 0x34, 0x34, 0x33, 0x65, 0x33, 0x36, 0x63, 0x39, 0x32, 0x66, 0x38, 0x35, 0x33, 0x64, 0x62, 0x35, 0x35, 0x38, 0x33, 0x66, 0x39, 0x61, 0x32, 0x37, 0x33, 0x64, 0x65, 0x39, 0x37, 0x36, 0x38, 0x35, 0x61, 0x37, 0x32, 0x35, 0x31, 0x62, 0x39, 0x34, 0x62, 0x37, 0x63, 0x33, 0x61, 0x36, 0x34, 0x37, 0x36, 0x61, 0x31, 0x61, 0x30, 0x36, 0x33, 0x65, 0x38, 0x30, 0x31, 0x64, 0x33, 0x34, 0x64, 0x66, 0x37, 0x66, 0x34, 0x33, 0x38, 0x32, 0x33, 0x31, 0x35, 0x30, 0x63, 0x64, 0x32, 0x63, 0x34, 0x33, 0x33, 0x38, 0x30, 0x33, 0x62, 0x38, 0x63, 0x31, 0x30, 0x34, 0x64, 0x38, 0x38, 0x36, 0x39, 0x30, 0x61, 0x37, 0x32, 0x31, 0x35, 0x39, 0x61, 0x32, 0x63, 0x64, 0x30, 0x37, 0x63, 0x62, 0x63, 0x39, 0x33, 0x35, 0x66, 0x30, 0x61, 0x63, 0x36, 0x63, 0x33, 0x64, 0x33, 0x32, 0x31, 0x33, 0x62, 0x66, 0x65, 0x39, 0x31, 0x39, 0x38, 0x31, 0x38, 0x30, 0x38, 0x63, 0x32, 0x63, 0x39, 0x32, 0x32, 0x34, 0x30, 0x62, 0x66, 0x66, 0x34, 0x30, 0x32, 0x32, 0x31, 0x35, 0x38, 0x37, 0x62, 0x31, 0x63, 0x66, 0x34, 0x37, 0x32, 0x66, 0x38, 0x35, 0x65, 0x33, 0x32, 0x63, 0x65, 0x36, 0x64, 0x30, 0x39, 0x33, 0x31, 0x31, 0x37, 0x36, 0x37, 0x32, 0x65, 0x34, 0x66, 0x63, 0x34, 0x31, 0x64, 0x66, 0x61, 0x64, 0x36, 0x65, 0x37, 0x39, 0x65, 0x34, 0x31, 0x33, 0x64, 0x33, 0x66, 0x30, 0x37, 0x38, 0x30, 0x34, 0x37, 0x38, 0x64, 0x66, 0x63, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35, 0x64, 0x39, 0x33, 0x65, 0x39, 0x63, 0x37, 0x32, 0x66, 0x37, 0x36, 0x34, 0x34, 0x37, 0x66, 0x36, 0x62, 0x63, 0x33, 0x32, 0x33, 0x66, 0x66, 0x66, 0x62, 0x61, 0x61, 0x37, 0x39, 0x38, 0x33, 0x65, 0x63, 0x63, 0x30, 0x37, 0x61, 0x36, 0x65, 0x36, 0x31, 0x34, 0x63, 0x30, 0x61, 0x31, 0x62, 0x31, 0x38, 0x30, 0x65, 0x65, 0x34, 0x31, 0x64, 0x66, 0x63, 0x62, 0x35, 0x65, 0x63, 0x31, 0x66, 0x62, 0x63, 0x65, 0x32, 0x63, 0x65, 0x34, 0x30, 0x62, 0x61, 0x65, 0x39, 0x36, 0x38, 0x33, 0x30, 0x30, 0x35, 0x36, 0x31, 0x61, 0x31, 0x66, 0x31, 0x33, 0x66, 0x62, 0x35, 0x65, 0x63, 0x64, 0x35, 0x31, 0x62, 0x39, 0x61, 0x62, 0x33, 0x30, 0x66, 0x37, 0x64, 0x65, 0x34, 0x35, 0x65, 0x64, 0x35, 0x36, 0x31, 0x65, 0x37, 0x38, 0x66, 0x32, 0x61, 0x32, 0x30, 0x66, 0x31, 0x65, 0x31, 0x35, 0x34, 0x33, 0x65, 0x37, 0x32, 0x66, 0x32, 0x35, 0x37, 0x32, 0x33, 0x64, 0x65, 0x38, 0x37, 0x62, 0x33, 0x64, 0x33, 0x39, 0x34, 0x38, 0x30, 0x63, 0x35, 0x35, 0x39, 0x30, 0x65, 0x62, 0x66, 0x37, 0x66, 0x61, 0x32, 0x31, 0x66, 0x34, 0x39, 0x34, 0x39, 0x31, 0x35, 0x37, 0x36, 0x36, 0x37, 0x32, 0x36, 0x37, 0x34, 0x38, 0x33, 0x33, 0x33, 0x35, 0x31, 0x32, 0x63, 0x61, 0x35, 0x33, 0x32, 0x64, 0x64, 0x38, 0x39, 0x61, 0x31, 0x35, 0x66, 0x62, 0x30, 0x39, 0x66, 0x36, 0x32, 0x64, 0x36, 0x32, 0x34, 0x65, 0x39, 0x35, 0x65, 0x61, 0x65, 0x33, 0x37, 0x32, 0x30, 0x36, 0x35, 0x36, 0x61, 0x37, 0x39, 0x65, 0x62, 0x38, 0x31, 0x34, 0x61, 0x63, 0x39, 0x36, 0x62, 0x62, 0x62, 0x37, 0x39, 0x63, 0x33, 0x39, 0x30, 0x39, 0x32, 0x35, 0x31, 0x32, 0x30, 0x35, 0x64, 0x34, 0x32, 0x37, 0x35, 0x34, 0x32, 0x62, 0x30, 0x64, 0x33, 0x66, 0x39, 0x62, 0x31, 0x61, 0x65, 0x33, 0x39, 0x64, 0x37, 0x31, 0x31, 0x63, 0x31, 0x32, 0x34, 0x33, 0x34, 0x31, 0x32, 0x62, 0x64, 0x34, 0x39, 0x34, 0x38, 0x64, 0x62, 0x65, 0x32, 0x36, 0x34, 0x63, 0x66, 0x64, 0x62, 0x62, 0x66, 0x65, 0x30, 0x66, 0x63, 0x30, 0x33, 0x62, 0x37, 0x32, 0x35, 0x35, 0x38, 0x32, 0x66, 0x65, 0x64, 0x34, 0x36, 0x32, 0x62, 0x33, 0x38, 0x36, 0x63, 0x65, 0x61, 0x63, 0x38, 0x64, 0x37, 0x32, 0x39, 0x62, 0x65, 0x34, 0x65, 0x62, 0x62, 0x38, 0x66, 0x39, 0x32, 0x63, 0x37, 0x64, 0x34, 0x66, 0x39, 0x34, 0x32, 0x37, 0x39, 0x66, 0x38, 0x66, 0x34, 0x36, 0x65, 0x32, 0x66, 0x63, 0x30, 0x61, 0x31, 0x63, 0x37, 0x36, 0x37, 0x31, 0x32, 0x62, 0x66, 0x62, 0x39, 0x65, 0x63, 0x34, 0x65, 0x64, 0x61, 0x37, 0x38, 0x39, 0x31, 0x62, 0x36, 0x62, 0x65, 0x63, 0x32, 0x35, 0x30, 0x64, 0x37, 0x32, 0x30, 0x34, 0x64, 0x63, 0x33, 0x32, 0x66, 0x61, 0x34, 0x33, 0x30, 0x31, 0x32, 0x32, 0x31, 0x39, 0x37, 0x34, 0x30, 0x66, 0x61, 0x61, 0x37, 0x31, 0x39, 0x38, 0x37, 0x62, 0x30, 0x65, 0x33, 0x39, 0x31, 0x33, 0x34, 0x36, 0x66, 0x63, 0x36, 0x33, 0x37, 0x37, 0x63, 0x64, 0x31, 0x63, 0x65, 0x35, 0x64, 0x65, 0x38, 0x65, 0x38, 0x34, 0x33, 0x64, 0x65, 0x62, 0x34, 0x61, 0x30, 0x64, 0x35, 0x64, 0x36, 0x30, 0x30, 0x65, 0x62, 0x31, 0x36, 0x34, 0x63, 0x32, 0x34, 0x66, 0x64, 0x36, 0x36, 0x33, 0x39, 0x61, 0x31, 0x36, 0x36, 0x35, 0x31, 0x34, 0x35, 0x62, 0x61, 0x33, 0x61, 0x33, 0x31, 0x64, 0x35, 0x33, 0x31, 0x63, 0x30, 0x35, 0x61, 0x63, 0x31, 0x65, 0x65, 0x65, 0x61, 0x63, 0x64, 0x65, 0x62, 0x66, 0x62, 0x39, 0x63, 0x37, 0x63, 0x35, 0x38, 0x61, 0x33, 0x61, 0x66, 0x63, 0x32, 0x62, 0x37, 0x33, 0x36, 0x65, 0x35, 0x34, 0x62, 0x61, 0x35, 0x32, 0x30, 0x34, 0x64, 0x37, 0x66, 0x38, 0x64, 0x39, 0x34, 0x36, 0x64, 0x62, 0x33, 0x61, 0x64, 0x38, 0x39, 0x62, 0x63, 0x63, 0x38, 0x62, 0x30, 0x65, 0x34, 0x63, 0x30, 0x30, 0x66, 0x38, 0x30, 0x33, 0x37, 0x63, 0x63, 0x34, 0x62, 0x39, 0x37, 0x37, 0x63, 0x30, 0x30, 0x66, 0x39, 0x34, 0x62, 0x32, 0x62, 0x36, 0x30, 0x63, 0x37, 0x32, 0x33, 0x36, 0x31, 0x38, 0x66, 0x33, 0x66, 0x31, 0x63, 0x33, 0x33, 0x63, 0x31, 0x32, 0x31, 0x62, 0x32, 0x38, 0x35, 0x32, 0x30, 0x66, 0x65, 0x35, 0x66, 0x61, 0x62, 0x37, 0x66, 0x62, 0x63, 0x65, 0x65, 0x61, 0x33, 0x38, 0x65, 0x37, 0x61, 0x38, 0x63, 0x33, 0x34, 0x33, 0x32, 0x39, 0x35, 0x38, 0x63, 0x38, 0x61, 0x33, 0x31, 0x31, 0x61, 0x61, 0x38, 0x39, 0x30, 0x31, 0x35, 0x30, 0x36, 0x37, 0x35, 0x32, 0x65, 0x37, 0x61, 0x31, 0x62, 0x61, 0x64, 0x31, 0x37, 0x63, 0x35, 0x37, 0x37, 0x61, 0x65, 0x38, 0x35, 0x39, 0x31, 0x65, 0x62, 0x32, 0x36, 0x63, 0x33, 0x33, 0x62, 0x65, 0x61, 0x37, 0x37, 0x38, 0x61, 0x65, 0x63, 0x36, 0x35, 0x31, 0x36, 0x37, 0x33, 0x33, 0x34, 0x62, 0x66, 0x64, 0x30, 0x38, 0x39, 0x31, 0x39, 0x30, 0x36, 0x36, 0x34, 0x36, 0x62, 0x61, 0x66, 0x32, 0x37, 0x32, 0x35, 0x66, 0x30, 0x33, 0x62, 0x38, 0x33, 0x63, 0x33, 0x65, 0x31, 0x66, 0x31, 0x39, 0x66, 0x34, 0x37, 0x66, 0x39, 0x36, 0x62, 0x37, 0x62, 0x39, 0x63, 0x34, 0x35, 0x39, 0x66, 0x61, 0x37, 0x30, 0x36, 0x38, 0x37, 0x34, 0x33, 0x34, 0x65, 0x31, 0x39, 0x39, 0x64, 0x32, 0x31, 0x33, 0x39, 0x36, 0x38, 0x30, 0x38, 0x36, 0x64, 0x34, 0x64, 0x39, 0x64, 0x34, 0x31, 0x34, 0x39, 0x30, 0x30, 0x39, 0x32, 0x37, 0x31, 0x33, 0x38, 0x62, 0x31, 0x61, 0x32, 0x61, 0x66, 0x33, 0x36, 0x65, 0x33, 0x38, 0x37, 0x33, 0x31, 0x35, 0x37, 0x63, 0x63, 0x65, 0x31, 0x63, 0x62, 0x63, 0x65, 0x61, 0x31, 0x66, 0x30, 0x61, 0x66, 0x63, 0x38, 0x65, 0x30, 0x37, 0x36, 0x39, 0x31, 0x66, 0x37, 0x31, 0x64, 0x61, 0x64, 0x35, 0x33, 0x66, 0x36, 0x36, 0x30, 0x64, 0x37, 0x63, 0x65, 0x65, 0x38, 0x31, 0x37, 0x32, 0x31, 0x36, 0x37, 0x33, 0x34, 0x38, 0x61, 0x31, 0x31, 0x62, 0x36, 0x62, 0x37, 0x31, 0x61, 0x39, 0x62, 0x62, 0x32, 0x38, 0x31, 0x37, 0x30, 0x32, 0x35, 0x32, 0x36, 0x63, 0x66, 0x38, 0x32, 0x66, 0x64, 0x65, 0x37, 0x30, 0x34, 0x31, 0x62, 0x62, 0x65, 0x31, 0x30, 0x38, 0x63, 0x39, 0x33, 0x34, 0x63, 0x32, 0x35, 0x63, 0x64, 0x32, 0x33, 0x37, 0x63, 0x35, 0x64, 0x39, 0x64, 0x33, 0x31, 0x31, 0x61, 0x36, 0x63, 0x35, 0x34, 0x61, 0x32, 0x34, 0x66, 0x34, 0x61, 0x36, 0x35, 0x39, 0x65, 0x30, 0x64, 0x63, 0x66, 0x30, 0x65, 0x32, 0x39, 0x39, 0x35, 0x38, 0x31, 0x64, 0x32, 0x33, 0x62, 0x63, 0x62, 0x37, 0x32, 0x37, 0x32, 0x37, 0x34, 0x64, 0x34, 0x62, 0x65, 0x31, 0x39, 0x64, 0x66, 0x30, 0x64, 0x63, 0x63, 0x35, 0x33, 0x36, 0x62, 0x30, 0x39, 0x37, 0x64, 0x39, 0x32, 0x35, 0x32, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x62, 0x34, 0x30, 0x64, 0x62, 0x36, 0x62, 0x63, 0x38, 0x37, 0x37, 0x65, 0x38, 0x36, 0x64, 0x65, 0x38, 0x37, 0x39, 0x61, 0x66, 0x36, 0x31, 0x34, 0x65, 0x65, 0x65, 0x30, 0x64, 0x63, 0x62, 0x66, 0x65, 0x34, 0x35, 0x30, 0x39, 0x61, 0x39, 0x35, 0x33, 0x36, 0x36, 0x63, 0x38, 0x62, 0x30, 0x66, 0x33, 0x32, 0x36, 0x34, 0x34, 0x36, 0x37, 0x63, 0x64, 0x37, 0x32, 0x65, 0x62, 0x64, 0x38, 0x31, 0x33, 0x63, 0x61, 0x31, 0x64, 0x39, 0x34, 0x30, 0x31, 0x65, 0x36, 0x63, 0x37, 0x63, 0x63, 0x35, 0x32, 0x61, 0x34, 0x36, 0x38, 0x31, 0x30, 0x62, 0x61, 0x62, 0x65, 0x34, 0x62, 0x37, 0x64, 0x34, 0x61, 0x30, 0x65, 0x61, 0x61, 0x35, 0x61, 0x66, 0x35, 0x30, 0x33, 0x36, 0x33, 0x33, 0x62, 0x66, 0x37, 0x33, 0x33, 0x33, 0x31, 0x61, 0x31, 0x65, 0x35, 0x37, 0x32, 0x30, 0x30, 0x65, 0x64, 0x38, 0x35, 0x61, 0x34, 0x33, 0x33, 0x39, 0x61, 0x66, 0x62, 0x64, 0x34, 0x34, 0x62, 0x64, 0x39, 0x31, 0x63, 0x61, 0x63, 0x30, 0x31, 0x66, 0x32, 0x32, 0x65, 0x36, 0x33, 0x62, 0x38, 0x37, 0x33, 0x65, 0x33, 0x36, 0x33, 0x31, 0x33, 0x33, 0x37, 0x35, 0x62, 0x37, 0x32, 0x62, 0x32, 0x38, 0x39, 0x37, 0x39, 0x31, 0x32, 0x31, 0x32, 0x37, 0x61, 0x31, 0x62, 0x35, 0x63, 0x33, 0x33, 0x65, 0x61, 0x38, 0x36, 0x36, 0x61, 0x65, 0x38, 0x64, 0x36, 0x31, 0x65, 0x66, 0x30, 0x36, 0x35, 0x33, 0x65, 0x34, 0x37, 0x36, 0x37, 0x33, 0x66, 0x31, 0x35, 0x64, 0x62, 0x32, 0x36, 0x38, 0x38, 0x38, 0x32, 0x65, 0x30, 0x63, 0x65, 0x33, 0x65, 0x63, 0x36, 0x65, 0x36, 0x63, 0x65, 0x37, 0x64, 0x30, 0x64, 0x61, 0x36, 0x65, 0x31, 0x61, 0x39, 0x62, 0x39, 0x31, 0x37, 0x32, 0x35, 0x65, 0x32, 0x31, 0x35, 0x38, 0x32, 0x64, 0x36, 0x61, 0x30, 0x39, 0x32, 0x64, 0x38, 0x33, 0x63, 0x33, 0x65, 0x38, 0x34, 0x31, 0x62, 0x37, 0x38, 0x61, 0x30, 0x62, 0x66, 0x36, 0x33, 0x39, 0x66, 0x63, 0x38, 0x33, 0x64, 0x33, 0x61, 0x61, 0x30, 0x38, 0x31, 0x38, 0x33, 0x35, 0x63, 0x39, 0x36, 0x35, 0x31, 0x39, 0x65, 0x39, 0x64, 0x65, 0x62, 0x36, 0x63, 0x64, 0x31, 0x31, 0x62, 0x37, 0x32, 0x36, 0x63, 0x33, 0x63, 0x63, 0x32, 0x39, 0x61, 0x31, 0x32, 0x66, 0x37, 0x66, 0x62, 0x37, 0x32, 0x36, 0x35, 0x65, 0x33, 0x30, 0x66, 0x62, 0x65, 0x33, 0x65, 0x39, 0x36, 0x33, 0x64, 0x35, 0x63, 0x35, 0x33, 0x61, 0x30, 0x34, 0x38, 0x61, 0x33, 0x38, 0x35, 0x66, 0x30, 0x62, 0x64, 0x37, 0x30, 0x32, 0x62, 0x35, 0x65, 0x66, 0x35, 0x31, 0x66, 0x31, 0x66, 0x35, 0x39, 0x66, 0x34, 0x37, 0x32, 0x36, 0x30, 0x63, 0x32, 0x66, 0x63, 0x39, 0x38, 0x37, 0x31, 0x66, 0x36, 0x36, 0x38, 0x34, 0x38, 0x65, 0x36, 0x63, 0x32, 0x61, 0x38, 0x32, 0x32, 0x31, 0x31, 0x33, 0x34, 0x66, 0x64, 0x63, 0x38, 0x66, 0x62, 0x33, 0x39, 0x62, 0x66, 0x65, 0x64, 0x39, 0x34, 0x61, 0x31, 0x31, 0x62, 0x61, 0x34, 0x36, 0x34, 0x35, 0x66, 0x65, 0x61, 0x62, 0x30, 0x64, 0x61, 0x35, 0x33, 0x61, 0x35, 0x37, 0x32, 0x64, 0x66, 0x33, 0x61, 0x35, 0x63, 0x33, 0x62, 0x39, 0x35, 0x66, 0x37, 0x61, 0x37, 0x65, 0x63, 0x33, 0x30, 0x61, 0x34, 0x33, 0x30, 0x33, 0x34, 0x37, 0x34, 0x63, 0x32, 0x31, 0x64, 0x63, 0x66, 0x31, 0x31, 0x32, 0x34, 0x39, 0x62, 0x36, 0x65, 0x62, 0x30, 0x36, 0x38, 0x32, 0x66, 0x62, 0x34, 0x39, 0x32, 0x35, 0x39, 0x32, 0x64, 0x31, 0x36, 0x65, 0x62, 0x35, 0x36, 0x31, 0x61, 0x37, 0x32, 0x36, 0x35, 0x34, 0x37, 0x64, 0x66, 0x65, 0x61, 0x38, 0x36, 0x36, 0x39, 0x35, 0x63, 0x66, 0x35, 0x33, 0x61, 0x37, 0x65, 0x35, 0x35, 0x63, 0x35, 0x38, 0x32, 0x61, 0x31, 0x31, 0x61, 0x32, 0x64, 0x64, 0x37, 0x34, 0x33, 0x35, 0x30, 0x66, 0x32, 0x65, 0x66, 0x33, 0x34, 0x65, 0x38, 0x38, 0x66, 0x33, 0x39, 0x65, 0x35, 0x35, 0x64, 0x34, 0x33, 0x32, 0x31, 0x66, 0x30, 0x38, 0x38, 0x33, 0x31, 0x37, 0x66, 0x35, 0x36, 0x63, 0x66, 0x35, 0x63, 0x38, 0x37, 0x65, 0x65, 0x61, 0x63, 0x33, 0x64, 0x65, 0x34, 0x39, 0x38, 0x30, 0x36, 0x30, 0x32, 0x65, 0x36, 0x39, 0x64, 0x64, 0x33, 0x62, 0x62, 0x35, 0x35, 0x63, 0x64, 0x37, 0x31, 0x64, 0x35, 0x66, 0x35, 0x37, 0x34, 0x61, 0x36, 0x38, 0x31, 0x62, 0x63, 0x30, 0x39, 0x39, 0x64, 0x36, 0x62, 0x31, 0x63, 0x39, 0x33, 0x39, 0x32, 0x37, 0x32, 0x35, 0x33, 0x37, 0x37, 0x31, 0x30, 0x39, 0x35, 0x36, 0x66, 0x65, 0x65, 0x32, 0x34, 0x61, 0x61, 0x34, 0x62, 0x33, 0x33, 0x62, 0x62, 0x39, 0x38, 0x65, 0x31, 0x32, 0x65, 0x65, 0x66, 0x65, 0x63, 0x30, 0x61, 0x64, 0x61, 0x39, 0x31, 0x37, 0x66, 0x62, 0x65, 0x35, 0x33, 0x32, 0x32, 0x64, 0x64, 0x30, 0x38, 0x35, 0x65, 0x63, 0x32, 0x64, 0x33, 0x62, 0x39, 0x61, 0x37, 0x37, 0x39, 0x37, 0x32, 0x63, 0x30, 0x65, 0x33, 0x63, 0x37, 0x35, 0x39, 0x38, 0x66, 0x33, 0x34, 0x36, 0x63, 0x61, 0x34, 0x65, 0x39, 0x64, 0x31, 0x37, 0x33, 0x34, 0x34, 0x30, 0x61, 0x65, 0x31, 0x62, 0x33, 0x36, 0x63, 0x30, 0x31, 0x66, 0x32, 0x31, 0x32, 0x63, 0x66, 0x38, 0x38, 0x35, 0x32, 0x30, 0x66, 0x66, 0x35, 0x33, 0x63, 0x66, 0x66, 0x65, 0x38, 0x63, 0x34, 0x35, 0x66, 0x65, 0x62, 0x37, 0x39, 0x37, 0x32, 0x61, 0x63, 0x33, 0x33, 0x64, 0x34, 0x62, 0x30, 0x62, 0x66, 0x31, 0x35, 0x37, 0x39, 0x62, 0x63, 0x36, 0x66, 0x38, 0x37, 0x34, 0x65, 0x35, 0x63, 0x38, 0x37, 0x36, 0x36, 0x38, 0x31, 0x34, 0x63, 0x39, 0x33, 0x35, 0x39, 0x66, 0x31, 0x37, 0x37, 0x30, 0x36, 0x62, 0x62, 0x36, 0x66, 0x33, 0x62, 0x38, 0x62, 0x66, 0x65, 0x62, 0x36, 0x36, 0x65, 0x64, 0x66, 0x34, 0x66, 0x63, 0x31, 0x37, 0x32, 0x61, 0x63, 0x32, 0x65, 0x35, 0x35, 0x33, 0x38, 0x32, 0x66, 0x36, 0x64, 0x61, 0x32, 0x65, 0x33, 0x31, 0x39, 0x65, 0x38, 0x31, 0x34, 0x37, 0x39, 0x62, 0x34, 0x37, 0x36, 0x34, 0x32, 0x36, 0x66, 0x66, 0x34, 0x30, 0x33, 0x63, 0x30, 0x31, 0x65, 0x63, 0x64, 0x64, 0x35, 0x36, 0x35, 0x65, 0x64, 0x63, 0x63, 0x31, 0x33, 0x65, 0x34, 0x39, 0x65, 0x32, 0x34, 0x32, 0x38, 0x62, 0x65, 0x37, 0x32, 0x64, 0x64, 0x64, 0x35, 0x65, 0x66, 0x62, 0x66, 0x32, 0x64, 0x37, 0x66, 0x66, 0x38, 0x33, 0x34, 0x36, 0x65, 0x39, 0x62, 0x63, 0x64, 0x34, 0x64, 0x35, 0x62, 0x39, 0x31, 0x61, 0x65, 0x38, 0x65, 0x38, 0x38, 0x36, 0x30, 0x37, 0x61, 0x63, 0x34, 0x62, 0x36, 0x62, 0x66, 0x35, 0x62, 0x38, 0x63, 0x31, 0x39, 0x31, 0x38, 0x63, 0x64, 0x30, 0x66, 0x33, 0x31, 0x34, 0x64, 0x61, 0x64, 0x33, 0x64, 0x61, 0x66, 0x37, 0x37, 0x64, 0x32, 0x31, 0x39, 0x36, 0x63, 0x39, 0x32, 0x61, 0x32, 0x36, 0x62, 0x30, 0x30, 0x65, 0x39, 0x62, 0x36, 0x31, 0x36, 0x64, 0x61, 0x36, 0x63, 0x30, 0x34, 0x64, 0x34, 0x39, 0x61, 0x31, 0x36, 0x30, 0x61, 0x37, 0x37, 0x36, 0x64, 0x63, 0x63, 0x33, 0x30, 0x64, 0x36, 0x34, 0x32, 0x62, 0x34, 0x63, 0x39, 0x37, 0x33, 0x66, 0x30, 0x39, 0x32, 0x65, 0x32, 0x37, 0x32, 0x30, 0x32, 0x39, 0x30, 0x61, 0x66, 0x39, 0x34, 0x66, 0x61, 0x35, 0x65, 0x35, 0x39, 0x31, 0x39, 0x66, 0x36, 0x61, 0x63, 0x63, 0x61, 0x36, 0x36, 0x32, 0x32, 0x33, 0x63, 0x34, 0x30, 0x31, 0x36, 0x33, 0x63, 0x33, 0x35, 0x66, 0x66, 0x37, 0x62, 0x64, 0x34, 0x38, 0x32, 0x36, 0x38, 0x36, 0x30, 0x33, 0x66, 0x66, 0x31, 0x30, 0x64, 0x34, 0x32, 0x33, 0x33, 0x37, 0x66, 0x32, 0x36, 0x36, 0x30, 0x35, 0x66, 0x32, 0x62, 0x63, 0x32, 0x64, 0x30, 0x38, 0x36, 0x36, 0x65, 0x62, 0x32, 0x37, 0x65, 0x65, 0x65, 0x30, 0x61, 0x37, 0x37, 0x61, 0x32, 0x61, 0x36, 0x31, 0x37, 0x38, 0x63, 0x63, 0x39, 0x31, 0x34, 0x65, 0x37, 0x37, 0x66, 0x35, 0x63, 0x34, 0x31, 0x65, 0x65, 0x31, 0x36, 0x39, 0x32, 0x62, 0x39, 0x31, 0x35, 0x62, 0x39, 0x62, 0x61, 0x39, 0x34, 0x30, 0x37, 0x65, 0x66, 0x36, 0x65, 0x39, 0x61, 0x31, 0x32, 0x63, 0x62, 0x39, 0x35, 0x34, 0x39, 0x35, 0x33, 0x35, 0x38, 0x61, 0x33, 0x38, 0x33, 0x65, 0x35, 0x38, 0x39, 0x31, 0x32, 0x35, 0x61, 0x34, 0x62, 0x36, 0x61, 0x39, 0x36, 0x63, 0x62, 0x63, 0x34, 0x31, 0x34, 0x63, 0x61, 0x63, 0x63, 0x64, 0x35, 0x39, 0x66, 0x38, 0x36, 0x65, 0x39, 0x65, 0x36, 0x39, 0x61, 0x65, 0x38, 0x62, 0x37, 0x33, 0x30, 0x34, 0x37, 0x31, 0x61, 0x34, 0x32, 0x65, 0x34, 0x34, 0x61, 0x36, 0x33, 0x36, 0x31, 0x64, 0x64, 0x62, 0x30, 0x32, 0x33, 0x32, 0x66, 0x31, 0x36, 0x62, 0x36, 0x62, 0x65, 0x63, 0x61, 0x33, 0x30, 0x38, 0x37, 0x63, 0x36, 0x36, 0x30, 0x31, 0x31, 0x36, 0x64, 0x37, 0x32, 0x65, 0x37, 0x64, 0x39, 0x35, 0x61, 0x39, 0x31, 0x63, 0x36, 0x36, 0x37, 0x36, 0x64, 0x63, 0x63, 0x39, 0x65, 0x65, 0x34, 0x66, 0x38, 0x37, 0x32, 0x66, 0x39, 0x62, 0x31, 0x63, 0x33, 0x34, 0x34, 0x65, 0x30, 0x62, 0x34, 0x39, 0x33, 0x37, 0x35, 0x31, 0x39, 0x65, 0x63, 0x35, 0x36, 0x61, 0x30, 0x37, 0x64, 0x35, 0x38, 0x38, 0x39, 0x37, 0x37, 0x34, 0x39, 0x66, 0x38, 0x66, 0x32, 0x66, 0x32, 0x35, 0x33, 0x39, 0x33, 0x31, 0x65, 0x33, 0x31, 0x30, 0x39, 0x36, 0x38, 0x39, 0x64, 0x31, 0x34, 0x62, 0x65, 0x61, 0x66, 0x61, 0x37, 0x31, 0x64, 0x30, 0x66, 0x61, 0x34, 0x64, 0x33, 0x38, 0x64, 0x37, 0x62, 0x34, 0x35, 0x34, 0x34, 0x33, 0x61, 0x32, 0x33, 0x38, 0x61, 0x34, 0x38, 0x35, 0x64, 0x34, 0x63, 0x65, 0x61, 0x62, 0x37, 0x33, 0x35, 0x38, 0x35, 0x34, 0x33, 0x36, 0x36, 0x33, 0x62, 0x35, 0x39, 0x30, 0x65, 0x32, 0x36, 0x64, 0x34, 0x30, 0x63, 0x39, 0x32, 0x63, 0x33, 0x34, 0x32, 0x63, 0x38, 0x61, 0x39, 0x37, 0x64, 0x31, 0x39, 0x36, 0x32, 0x63, 0x62, 0x36, 0x64, 0x62, 0x61, 0x30, 0x34, 0x31, 0x31, 0x64, 0x32, 0x62, 0x35, 0x38, 0x36, 0x63, 0x33, 0x30, 0x31, 0x31, 0x34, 0x64, 0x61, 0x62, 0x61, 0x36, 0x65, 0x66, 0x33, 0x39, 0x35, 0x63, 0x64, 0x61, 0x66, 0x66, 0x33, 0x66, 0x38, 0x65, 0x61, 0x34, 0x38, 0x35, 0x30, 0x63, 0x66, 0x63, 0x65, 0x32, 0x30, 0x35, 0x30, 0x66, 0x34, 0x39, 0x37, 0x32, 0x62, 0x34, 0x33, 0x64, 0x31, 0x62, 0x65, 0x38, 0x65, 0x33, 0x39, 0x65, 0x37, 0x35, 0x39, 0x30, 0x36, 0x35, 0x30, 0x32, 0x34, 0x61, 0x35, 0x64, 0x32, 0x63, 0x37, 0x38, 0x62, 0x61, 0x63, 0x61, 0x33, 0x66, 0x35, 0x31, 0x62, 0x64, 0x62, 0x35, 0x66, 0x63, 0x39, 0x35, 0x36, 0x37, 0x35, 0x38, 0x65, 0x64, 0x36, 0x31, 0x37, 0x63, 0x37, 0x34, 0x35, 0x37, 0x63, 0x33, 0x32, 0x64, 0x33, 0x62, 0x38, 0x37, 0x30, 0x30, 0x32, 0x35, 0x37, 0x64, 0x63, 0x61, 0x30, 0x33, 0x38, 0x65, 0x61, 0x65, 0x38, 0x31, 0x30, 0x64, 0x39, 0x35, 0x62, 0x34, 0x34, 0x61, 0x64, 0x38, 0x32, 0x66, 0x63, 0x36, 0x37, 0x33, 0x62, 0x38, 0x37, 0x63, 0x38, 0x65, 0x33, 0x33, 0x66, 0x35, 0x35, 0x34, 0x30, 0x63, 0x64, 0x63, 0x61, 0x31, 0x31, 0x64, 0x33, 0x36, 0x66, 0x62, 0x39, 0x36, 0x30, 0x39, 0x31, 0x36, 0x39, 0x37, 0x32, 0x39, 0x34, 0x39, 0x35, 0x36, 0x32, 0x39, 0x65, 0x39, 0x35, 0x36, 0x62, 0x37, 0x35, 0x64, 0x61, 0x62, 0x31, 0x32, 0x62, 0x30, 0x36, 0x31, 0x36, 0x30, 0x66, 0x64, 0x33, 0x65, 0x33, 0x64, 0x39, 0x39, 0x34, 0x39, 0x62, 0x31, 0x65, 0x37, 0x33, 0x32, 0x39, 0x30, 0x62, 0x66, 0x31, 0x35, 0x36, 0x38, 0x33, 0x66, 0x32, 0x64, 0x35, 0x32, 0x37, 0x30, 0x63, 0x39, 0x62, 0x66, 0x33, 0x37, 0x32, 0x39, 0x34, 0x39, 0x38, 0x36, 0x34, 0x39, 0x36, 0x39, 0x64, 0x35, 0x30, 0x38, 0x38, 0x33, 0x32, 0x61, 0x32, 0x64, 0x65, 0x32, 0x32, 0x64, 0x32, 0x39, 0x66, 0x64, 0x66, 0x39, 0x37, 0x36, 0x35, 0x31, 0x65, 0x32, 0x31, 0x65, 0x32, 0x63, 0x33, 0x32, 0x39, 0x31, 0x38, 0x65, 0x37, 0x65, 0x63, 0x63, 0x39, 0x62, 0x34, 0x30, 0x33, 0x36, 0x64, 0x34, 0x31, 0x66, 0x32, 0x33, 0x33, 0x34, 0x37, 0x34, 0x35, 0x64, 0x34, 0x32, 0x31, 0x39, 0x63, 0x61, 0x37, 0x31, 0x37, 0x62, 0x38, 0x64, 0x63, 0x32, 0x34, 0x39, 0x64, 0x33, 0x61, 0x39, 0x63, 0x65, 0x61, 0x63, 0x35, 0x39, 0x62, 0x35, 0x30, 0x30, 0x38, 0x65, 0x63, 0x36, 0x32, 0x37, 0x36, 0x30, 0x66, 0x35, 0x31, 0x38, 0x34, 0x34, 0x36, 0x31, 0x65, 0x61, 0x65, 0x66, 0x65, 0x31, 0x33, 0x61, 0x34, 0x63, 0x35, 0x66, 0x61, 0x37, 0x32, 0x31, 0x38, 0x39, 0x30, 0x39, 0x33, 0x33, 0x32, 0x38, 0x32, 0x37, 0x39, 0x36, 0x31, 0x37, 0x34, 0x34, 0x31, 0x36, 0x62, 0x37, 0x61, 0x34, 0x34, 0x30, 0x64, 0x37, 0x34, 0x65, 0x61, 0x39, 0x33, 0x65, 0x31, 0x33, 0x36, 0x61, 0x64, 0x30, 0x32, 0x36, 0x36, 0x31, 0x30, 0x64, 0x63, 0x63, 0x65, 0x38, 0x62, 0x31, 0x65, 0x64, 0x31, 0x37, 0x37, 0x30, 0x38, 0x63, 0x64, 0x39, 0x31, 0x35, 0x64, 0x31, 0x37, 0x61, 0x36, 0x62, 0x61, 0x35, 0x64, 0x63, 0x39, 0x63, 0x32, 0x64, 0x62, 0x62, 0x38, 0x38, 0x30, 0x35, 0x37, 0x37, 0x34, 0x39, 0x65, 0x66, 0x63, 0x39, 0x64, 0x66, 0x65, 0x39, 0x33, 0x32, 0x63, 0x39, 0x33, 0x30, 0x30, 0x32, 0x63, 0x39, 0x35, 0x31, 0x33, 0x64, 0x31, 0x61, 0x38, 0x63, 0x33, 0x39, 0x61, 0x33, 0x35, 0x39, 0x64, 0x65, 0x65, 0x38, 0x32, 0x39, 0x63, 0x37, 0x32, 0x33, 0x35, 0x31, 0x37, 0x33, 0x63, 0x30, 0x34, 0x65, 0x30, 0x62, 0x66, 0x31, 0x63, 0x36, 0x31, 0x35, 0x63, 0x38, 0x34, 0x61, 0x37, 0x65, 0x36, 0x64, 0x30, 0x34, 0x32, 0x65, 0x35, 0x66, 0x62, 0x33, 0x37, 0x37, 0x30, 0x30, 0x36, 0x34, 0x30, 0x38, 0x33, 0x62, 0x38, 0x36, 0x32, 0x65, 0x39, 0x65, 0x39, 0x35, 0x34, 0x37, 0x62, 0x32, 0x35, 0x37, 0x65, 0x37, 0x35, 0x66, 0x33, 0x30, 0x62, 0x33, 0x64, 0x65, 0x33, 0x32, 0x64, 0x30, 0x62, 0x65, 0x35, 0x64, 0x30, 0x38, 0x61, 0x65, 0x66, 0x63, 0x61, 0x31, 0x37, 0x33, 0x33, 0x64, 0x36, 0x39, 0x35, 0x65, 0x38, 0x32, 0x66, 0x33, 0x64, 0x35, 0x63, 0x32, 0x32, 0x30, 0x32, 0x38, 0x61, 0x64, 0x33, 0x66, 0x32, 0x64, 0x30, 0x33, 0x66, 0x61, 0x39, 0x64, 0x61, 0x62, 0x64, 0x32, 0x36, 0x61, 0x62, 0x62, 0x66, 0x61, 0x35, 0x37, 0x32, 0x38, 0x36, 0x61, 0x35, 0x61, 0x33, 0x33, 0x38, 0x35, 0x39, 0x66, 0x66, 0x39, 0x30, 0x62, 0x64, 0x64, 0x31, 0x37, 0x30, 0x61, 0x30, 0x38, 0x39, 0x63, 0x31, 0x30, 0x37, 0x31, 0x61, 0x61, 0x35, 0x66, 0x64, 0x35, 0x30, 0x38, 0x36, 0x32, 0x61, 0x63, 0x31, 0x35, 0x65, 0x36, 0x38, 0x65, 0x39, 0x34, 0x37, 0x63, 0x61, 0x37, 0x32, 0x36, 0x37, 0x35, 0x38, 0x62, 0x32, 0x63, 0x64, 0x37, 0x32, 0x63, 0x64, 0x37, 0x64, 0x35, 0x32, 0x33, 0x34, 0x64, 0x35, 0x34, 0x64, 0x63, 0x33, 0x32, 0x35, 0x36, 0x61, 0x62, 0x63, 0x64, 0x66, 0x31, 0x30, 0x64, 0x64, 0x62, 0x62, 0x39, 0x65, 0x39, 0x36, 0x65, 0x34, 0x63, 0x64, 0x30, 0x33, 0x37, 0x39, 0x37, 0x36, 0x35, 0x34, 0x66, 0x64, 0x32, 0x35, 0x61, 0x32, 0x32, 0x35, 0x30, 0x32, 0x34, 0x39, 0x37, 0x32, 0x35, 0x39, 0x64, 0x30, 0x37, 0x32, 0x37, 0x61, 0x32, 0x63, 0x35, 0x65, 0x39, 0x66, 0x34, 0x35, 0x38, 0x32, 0x38, 0x35, 0x61, 0x64, 0x65, 0x31, 0x36, 0x36, 0x65, 0x35, 0x35, 0x33, 0x30, 0x62, 0x64, 0x65, 0x31, 0x34, 0x30, 0x31, 0x63, 0x65, 0x62, 0x64, 0x37, 0x66, 0x66, 0x35, 0x64, 0x62, 0x39, 0x33, 0x37, 0x32, 0x33, 0x36, 0x38, 0x34, 0x61, 0x64, 0x36, 0x34, 0x37, 0x31, 0x63, 0x30, 0x31, 0x32, 0x64, 0x66, 0x37, 0x32, 0x38, 0x62, 0x34, 0x64, 0x64, 0x62, 0x32, 0x34, 0x62, 0x66, 0x31, 0x35, 0x31, 0x63, 0x62, 0x37, 0x64, 0x31, 0x62, 0x62, 0x39, 0x31, 0x30, 0x63, 0x61, 0x30, 0x35, 0x62, 0x63, 0x66, 0x32, 0x39, 0x31, 0x39, 0x38, 0x35, 0x31, 0x39, 0x39, 0x64, 0x39, 0x32, 0x39, 0x63, 0x61, 0x63, 0x32, 0x63, 0x62, 0x37, 0x37, 0x38, 0x65, 0x38, 0x65, 0x62, 0x65, 0x38, 0x30, 0x31, 0x34, 0x65, 0x37, 0x32, 0x32, 0x36, 0x34, 0x65, 0x34, 0x63, 0x31, 0x64, 0x39, 0x66, 0x66, 0x35, 0x31, 0x31, 0x35, 0x33, 0x65, 0x30, 0x37, 0x63, 0x37, 0x65, 0x32, 0x32, 0x38, 0x61, 0x32, 0x32, 0x61, 0x38, 0x32, 0x31, 0x62, 0x63, 0x39, 0x66, 0x32, 0x37, 0x31, 0x35, 0x39, 0x61, 0x34, 0x64, 0x37, 0x34, 0x64, 0x61, 0x36, 0x65, 0x32, 0x35, 0x39, 0x65, 0x61, 0x33, 0x66, 0x62, 0x66, 0x39, 0x37, 0x37, 0x37, 0x32, 0x62, 0x36, 0x37, 0x32, 0x63, 0x61, 0x32, 0x30, 0x35, 0x63, 0x36, 0x33, 0x63, 0x36, 0x39, 0x33, 0x37, 0x61, 0x30, 0x39, 0x39, 0x32, 0x37, 0x66, 0x35, 0x32, 0x36, 0x37, 0x38, 0x65, 0x35, 0x36, 0x65, 0x34, 0x61, 0x36, 0x66, 0x62, 0x37, 0x61, 0x65, 0x64, 0x32, 0x63, 0x36, 0x31, 0x30, 0x37, 0x34, 0x38, 0x32, 0x35, 0x62, 0x36, 0x65, 0x39, 0x61, 0x30, 0x63, 0x32, 0x39, 0x62, 0x34, 0x38, 0x63, 0x38, 0x32, 0x62, 0x64, 0x31, 0x66, 0x33, 0x63, 0x65, 0x38, 0x66, 0x38, 0x66, 0x61, 0x37, 0x39, 0x33, 0x37, 0x61, 0x65, 0x61, 0x65, 0x32, 0x63, 0x34, 0x61, 0x65, 0x37, 0x65, 0x61, 0x66, 0x62, 0x65, 0x33, 0x63, 0x32, 0x34, 0x64, 0x34, 0x32, 0x35, 0x33, 0x35, 0x35, 0x62, 0x30, 0x37, 0x31, 0x61, 0x63, 0x36, 0x31, 0x66, 0x37, 0x61, 0x63, 0x66, 0x31, 0x37, 0x62, 0x36, 0x37, 0x32, 0x34, 0x33, 0x34, 0x61, 0x39, 0x39, 0x30, 0x34, 0x66, 0x30, 0x33, 0x31, 0x34, 0x31, 0x39, 0x34, 0x38, 0x61, 0x39, 0x30, 0x33, 0x61, 0x32, 0x66, 0x62, 0x66, 0x39, 0x33, 0x65, 0x65, 0x33, 0x66, 0x63, 0x32, 0x33, 0x66, 0x63, 0x61, 0x33, 0x36, 0x31, 0x34, 0x31, 0x33, 0x63, 0x37, 0x63, 0x65, 0x64, 0x66, 0x64, 0x32, 0x38, 0x32, 0x32, 0x36, 0x64, 0x30, 0x32, 0x62, 0x34, 0x38, 0x36, 0x33, 0x63, 0x63, 0x37, 0x30, 0x30, 0x35, 0x36, 0x66, 0x35, 0x35, 0x63, 0x61, 0x30, 0x30, 0x62, 0x38, 0x61, 0x37, 0x65, 0x63, 0x39, 0x35, 0x66, 0x31, 0x36, 0x65, 0x32, 0x65, 0x34, 0x37, 0x62, 0x31, 0x39, 0x30, 0x64, 0x65, 0x64, 0x62, 0x38, 0x33, 0x61, 0x35, 0x31, 0x31, 0x36, 0x64, 0x32, 0x38, 0x62, 0x33, 0x62, 0x37, 0x35, 0x35, 0x39, 0x38, 0x39, 0x35, 0x34, 0x30, 0x38, 0x36, 0x36, 0x39, 0x30, 0x61, 0x33, 0x62, 0x37, 0x33, 0x61, 0x35, 0x39, 0x36, 0x35, 0x36, 0x33, 0x61, 0x37, 0x39, 0x36, 0x36, 0x38, 0x61, 0x37, 0x36, 0x34, 0x34, 0x35, 0x33, 0x65, 0x62, 0x38, 0x61, 0x64, 0x61, 0x64, 0x37, 0x37, 0x32, 0x61, 0x39, 0x38, 0x61, 0x30, 0x65, 0x65, 0x62, 0x39, 0x37, 0x39, 0x32, 0x38, 0x66, 0x31, 0x37, 0x64, 0x39, 0x35, 0x38, 0x63, 0x61, 0x35, 0x31, 0x31, 0x61, 0x37, 0x32, 0x33, 0x35, 0x62, 0x35, 0x30, 0x65, 0x33, 0x36, 0x63, 0x39, 0x31, 0x38, 0x65, 0x33, 0x33, 0x34, 0x34, 0x37, 0x33, 0x32, 0x63, 0x38, 0x65, 0x39, 0x39, 0x61, 0x39, 0x38, 0x36, 0x65, 0x64, 0x31, 0x36, 0x63, 0x36, 0x36, 0x39, 0x33, 0x30, 0x35, 0x30, 0x62, 0x61, 0x32, 0x30, 0x63, 0x38, 0x37, 0x31, 0x33, 0x36, 0x31, 0x66, 0x30, 0x31, 0x65, 0x66, 0x64, 0x36, 0x63, 0x63, 0x37, 0x31, 0x33, 0x32, 0x37, 0x39, 0x30, 0x30, 0x36, 0x35, 0x66, 0x62, 0x32, 0x37, 0x31, 0x63, 0x39, 0x36, 0x63, 0x39, 0x37, 0x31, 0x65, 0x65, 0x33, 0x65, 0x63, 0x66, 0x64, 0x39, 0x61, 0x36, 0x62, 0x37, 0x61, 0x31, 0x30, 0x33, 0x33, 0x39, 0x39, 0x64, 0x62, 0x32, 0x61, 0x39, 0x64, 0x32, 0x34, 0x31, 0x33, 0x37, 0x37, 0x30, 0x37, 0x62, 0x63, 0x66, 0x63, 0x32, 0x64, 0x30, 0x62, 0x30, 0x37, 0x37, 0x32, 0x37, 0x64, 0x61, 0x38, 0x38, 0x34, 0x66, 0x64, 0x35, 0x30, 0x31, 0x38, 0x31, 0x30, 0x64, 0x37, 0x31, 0x38, 0x65, 0x61, 0x35, 0x66, 0x31, 0x34, 0x34, 0x30, 0x34, 0x31, 0x30, 0x62, 0x32, 0x32, 0x32, 0x62, 0x33, 0x33, 0x62, 0x39, 0x35, 0x39, 0x65, 0x32, 0x35, 0x66, 0x33, 0x64, 0x39, 0x39, 0x65, 0x30, 0x38, 0x33, 0x34, 0x33, 0x33, 0x65, 0x33, 0x38, 0x31, 0x36, 0x30, 0x35, 0x37, 0x32, 0x63, 0x39, 0x35, 0x63, 0x35, 0x31, 0x30, 0x34, 0x39, 0x30, 0x61, 0x35, 0x62, 0x31, 0x38, 0x38, 0x62, 0x39, 0x32, 0x65, 0x38, 0x66, 0x61, 0x30, 0x39, 0x33, 0x31, 0x64, 0x62, 0x35, 0x36, 0x33, 0x36, 0x37, 0x62, 0x32, 0x63, 0x66, 0x37, 0x34, 0x32, 0x31, 0x37, 0x36, 0x30, 0x62, 0x30, 0x65, 0x61, 0x34, 0x63, 0x30, 0x63, 0x62, 0x31, 0x39, 0x36, 0x61, 0x30, 0x38, 0x61, 0x35, 0x37, 0x32, 0x61, 0x65, 0x33, 0x61, 0x32, 0x36, 0x33, 0x36, 0x37, 0x33, 0x62, 0x34, 0x66, 0x64, 0x65, 0x62, 0x30, 0x64, 0x31, 0x61, 0x31, 0x62, 0x66, 0x64, 0x37, 0x61, 0x66, 0x38, 0x63, 0x66, 0x31, 0x36, 0x33, 0x64, 0x30, 0x36, 0x35, 0x65, 0x31, 0x65, 0x33, 0x39, 0x31, 0x37, 0x31, 0x38, 0x39, 0x66, 0x62, 0x39, 0x66, 0x64, 0x30, 0x36, 0x63, 0x32, 0x63, 0x65, 0x33, 0x38, 0x32, 0x66, 0x36, 0x61, 0x62, 0x63, 0x62, 0x38, 0x30, 0x66, 0x36, 0x35, 0x33, 0x38, 0x35, 0x66, 0x38, 0x33, 0x32, 0x35, 0x63, 0x32, 0x30, 0x31, 0x34, 0x66, 0x61, 0x66, 0x35, 0x30, 0x64, 0x35, 0x36, 0x30, 0x30, 0x35, 0x37, 0x34, 0x62, 0x63, 0x30, 0x39, 0x31, 0x36, 0x61, 0x37, 0x61, 0x65, 0x31, 0x37, 0x30, 0x65, 0x36, 0x64, 0x61, 0x35, 0x66, 0x34, 0x39, 0x32, 0x34, 0x62, 0x66, 0x33, 0x34, 0x62, 0x30, 0x39, 0x37, 0x37, 0x35, 0x31, 0x62, 0x37, 0x31, 0x61, 0x37, 0x34, 0x37, 0x33, 0x30, 0x65, 0x30, 0x33, 0x33, 0x36, 0x31, 0x37, 0x34, 0x64, 0x34, 0x35, 0x36, 0x30, 0x36, 0x36, 0x63, 0x31, 0x62, 0x66, 0x33, 0x33, 0x64, 0x31, 0x32, 0x36, 0x30, 0x39, 0x38, 0x34, 0x30, 0x34, 0x37, 0x37, 0x61, 0x30, 0x38, 0x63, 0x62, 0x34, 0x61, 0x63, 0x66, 0x38, 0x64, 0x64, 0x35, 0x66, 0x36, 0x36, 0x37, 0x32, 0x31, 0x61, 0x36, 0x66, 0x31, 0x39, 0x34, 0x38, 0x62, 0x62, 0x30, 0x33, 0x31, 0x37, 0x64, 0x65, 0x32, 0x66, 0x66, 0x33, 0x31, 0x30, 0x37, 0x64, 0x65, 0x63, 0x62, 0x39, 0x30, 0x36, 0x36, 0x64, 0x61, 0x39, 0x39, 0x39, 0x65, 0x30, 0x34, 0x35, 0x34, 0x62, 0x37, 0x33, 0x30, 0x63, 0x35, 0x32, 0x35, 0x62, 0x35, 0x37, 0x66, 0x62, 0x64, 0x33, 0x64, 0x34, 0x64, 0x32, 0x66, 0x66, 0x30, 0x61, 0x39, 0x37, 0x36, 0x32, 0x30, 0x32, 0x66, 0x36, 0x33, 0x37, 0x37, 0x30, 0x63, 0x36, 0x66, 0x37, 0x61, 0x34, 0x34, 0x66, 0x33, 0x33, 0x34, 0x63, 0x65, 0x39, 0x31, 0x30, 0x31, 0x35, 0x33, 0x35, 0x30, 0x61, 0x65, 0x35, 0x66, 0x65, 0x66, 0x62, 0x34, 0x32, 0x62, 0x39, 0x33, 0x66, 0x32, 0x31, 0x39, 0x66, 0x64, 0x39, 0x65, 0x38, 0x36, 0x33, 0x36, 0x36, 0x65, 0x62, 0x39, 0x65, 0x31, 0x30, 0x63, 0x35, 0x63, 0x32, 0x30, 0x30, 0x35, 0x38, 0x33, 0x64, 0x38, 0x62, 0x62, 0x36, 0x31, 0x36, 0x63, 0x38, 0x33, 0x34, 0x31, 0x35, 0x65, 0x39, 0x64, 0x66, 0x63, 0x38, 0x37, 0x36, 0x64, 0x38, 0x36, 0x64, 0x66, 0x30, 0x30, 0x32, 0x35, 0x39, 0x32, 0x33, 0x66, 0x31, 0x39, 0x66, 0x35, 0x33, 0x61, 0x35, 0x66, 0x36, 0x36, 0x64, 0x61, 0x66, 0x61, 0x39, 0x62, 0x66, 0x61, 0x64, 0x37, 0x32, 0x62, 0x36, 0x35, 0x34, 0x32, 0x32, 0x65, 0x64, 0x64, 0x32, 0x61, 0x30, 0x32, 0x61, 0x36, 0x39, 0x62, 0x32, 0x39, 0x36, 0x66, 0x38, 0x61, 0x33, 0x62, 0x62, 0x36, 0x34, 0x38, 0x30, 0x35, 0x33, 0x63, 0x37, 0x64, 0x61, 0x38, 0x35, 0x32, 0x30, 0x36, 0x34, 0x35, 0x33, 0x65, 0x38, 0x39, 0x39, 0x61, 0x33, 0x38, 0x62, 0x64, 0x36, 0x65, 0x31, 0x34, 0x65, 0x34, 0x39, 0x66, 0x30, 0x31, 0x33, 0x32, 0x62, 0x61, 0x32, 0x66, 0x35, 0x61, 0x35, 0x34, 0x33, 0x35, 0x32, 0x36, 0x36, 0x61, 0x38, 0x63, 0x66, 0x62, 0x35, 0x63, 0x33, 0x33, 0x38, 0x63, 0x31, 0x39, 0x32, 0x65, 0x33, 0x63, 0x37, 0x65, 0x61, 0x63, 0x35, 0x31, 0x34, 0x33, 0x63, 0x62, 0x31, 0x64, 0x38, 0x33, 0x38, 0x65, 0x63, 0x61, 0x66, 0x33, 0x62, 0x35, 0x62, 0x35, 0x65, 0x65, 0x35, 0x62, 0x34, 0x39, 0x31, 0x35, 0x30, 0x63, 0x30, 0x61, 0x32, 0x32, 0x35, 0x31, 0x65, 0x35, 0x30, 0x35, 0x31, 0x35, 0x34, 0x32, 0x32, 0x33, 0x32, 0x66, 0x65, 0x37, 0x66, 0x36, 0x61, 0x30, 0x62, 0x30, 0x36, 0x36, 0x32, 0x35, 0x34, 0x66, 0x38, 0x61, 0x66, 0x31, 0x39, 0x30, 0x31, 0x30, 0x30, 0x34, 0x63, 0x30, 0x62, 0x38, 0x64, 0x39, 0x33, 0x34, 0x31, 0x39, 0x65, 0x34, 0x64, 0x35, 0x62, 0x34, 0x38, 0x30, 0x61, 0x30, 0x63, 0x37, 0x36, 0x65, 0x30, 0x62, 0x63, 0x65, 0x37, 0x30, 0x33, 0x31, 0x63, 0x64, 0x63, 0x32, 0x33, 0x66, 0x63, 0x62, 0x35, 0x66, 0x34, 0x63, 0x33, 0x36, 0x31, 0x66, 0x65, 0x31, 0x63, 0x37, 0x62, 0x64, 0x35, 0x31, 0x38, 0x63, 0x35, 0x63, 0x62, 0x33, 0x33, 0x32, 0x64, 0x38, 0x62, 0x30, 0x63, 0x34, 0x33, 0x37, 0x37, 0x65, 0x30, 0x63, 0x33, 0x63, 0x66, 0x39, 0x31, 0x34, 0x62, 0x37, 0x32, 0x36, 0x61, 0x36, 0x62, 0x62, 0x37, 0x63, 0x39, 0x37, 0x66, 0x36, 0x65, 0x32, 0x61, 0x36, 0x33, 0x38, 0x36, 0x36, 0x61, 0x65, 0x38, 0x39, 0x38, 0x36, 0x37, 0x61, 0x61, 0x31, 0x31, 0x63, 0x37, 0x39, 0x61, 0x39, 0x63, 0x35, 0x34, 0x35, 0x36, 0x62, 0x34, 0x61, 0x37, 0x31, 0x61, 0x66, 0x33, 0x39, 0x66, 0x39, 0x63, 0x61, 0x39, 0x36, 0x32, 0x33, 0x34, 0x65, 0x64, 0x30, 0x66, 0x37, 0x32, 0x61, 0x33, 0x64, 0x66, 0x34, 0x33, 0x38, 0x30, 0x64, 0x31, 0x66, 0x39, 0x36, 0x36, 0x38, 0x36, 0x39, 0x38, 0x65, 0x65, 0x37, 0x31, 0x33, 0x66, 0x66, 0x36, 0x66, 0x39, 0x62, 0x63, 0x36, 0x62, 0x62, 0x38, 0x66, 0x62, 0x34, 0x61, 0x64, 0x64, 0x36, 0x35, 0x32, 0x62, 0x35, 0x37, 0x65, 0x33, 0x34, 0x62, 0x61, 0x64, 0x62, 0x66, 0x31, 0x33, 0x65, 0x30, 0x63, 0x39, 0x35, 0x38, 0x36, 0x38, 0x64, 0x66, 0x63, 0x33, 0x36, 0x37, 0x61, 0x33, 0x61, 0x66, 0x63, 0x31, 0x39, 0x63, 0x64, 0x36, 0x30, 0x33, 0x30, 0x38, 0x39, 0x62, 0x34, 0x32, 0x35, 0x64, 0x37, 0x66, 0x63, 0x63, 0x37, 0x36, 0x64, 0x65, 0x64, 0x66, 0x66, 0x32, 0x65, 0x66, 0x61, 0x39, 0x39, 0x30, 0x65, 0x31, 0x38, 0x62, 0x63, 0x34, 0x64, 0x64, 0x65, 0x63, 0x64, 0x39, 0x30, 0x64, 0x31, 0x32, 0x65, 0x62, 0x37, 0x32, 0x66, 0x35, 0x33, 0x39, 0x38, 0x33, 0x37, 0x36, 0x35, 0x65, 0x33, 0x33, 0x64, 0x39, 0x36, 0x38, 0x64, 0x34, 0x32, 0x64, 0x37, 0x35, 0x35, 0x30, 0x39, 0x32, 0x62, 0x30, 0x35, 0x64, 0x33, 0x63, 0x30, 0x61, 0x62, 0x34, 0x36, 0x36, 0x66, 0x31, 0x62, 0x35, 0x38, 0x38, 0x39, 0x37, 0x33, 0x33, 0x61, 0x33, 0x32, 0x34, 0x30, 0x63, 0x36, 0x61, 0x38, 0x65, 0x34, 0x36, 0x38, 0x62, 0x33, 0x39, 0x31, 0x32, 0x35, 0x31, 0x64, 0x37, 0x30, 0x64, 0x32, 0x66, 0x38, 0x62, 0x64, 0x35, 0x36, 0x64, 0x35, 0x63, 0x32, 0x64, 0x65, 0x33, 0x66, 0x31, 0x37, 0x36, 0x33, 0x61, 0x61, 0x34, 0x62, 0x39, 0x65, 0x63, 0x35, 0x36, 0x63, 0x65, 0x30, 0x34, 0x61, 0x33, 0x63, 0x61, 0x34, 0x32, 0x66, 0x39, 0x36, 0x63, 0x36, 0x64, 0x30, 0x35, 0x31, 0x35, 0x66, 0x62, 0x65, 0x65, 0x35, 0x34, 0x35, 0x33, 0x36, 0x31, 0x36, 0x35, 0x38, 0x38, 0x30, 0x34, 0x39, 0x65, 0x38, 0x65, 0x63, 0x35, 0x65, 0x61, 0x63, 0x34, 0x34, 0x66, 0x38, 0x30, 0x30, 0x31, 0x36, 0x36, 0x37, 0x37, 0x37, 0x62, 0x64, 0x64, 0x66, 0x33, 0x33, 0x37, 0x34, 0x34, 0x64, 0x31, 0x62, 0x61, 0x66, 0x36, 0x61, 0x39, 0x34, 0x33, 0x36, 0x38, 0x62, 0x35, 0x64, 0x62, 0x35, 0x34, 0x37, 0x64, 0x63, 0x37, 0x66, 0x66, 0x31, 0x33, 0x34, 0x66, 0x38, 0x30, 0x36, 0x36, 0x34, 0x63, 0x30, 0x64, 0x30, 0x30, 0x35, 0x63, 0x37, 0x33, 0x32, 0x61, 0x30, 0x63, 0x66, 0x35, 0x34, 0x39, 0x39, 0x35, 0x63, 0x39, 0x35, 0x37, 0x34, 0x61, 0x63, 0x34, 0x62, 0x34, 0x61, 0x65, 0x65, 0x31, 0x33, 0x31, 0x33, 0x32, 0x62, 0x64, 0x33, 0x61, 0x30, 0x36, 0x31, 0x36, 0x61, 0x39, 0x34, 0x62, 0x35, 0x31, 0x64, 0x34, 0x39, 0x61, 0x32, 0x31, 0x35, 0x33, 0x66, 0x61, 0x36, 0x35, 0x36, 0x64, 0x61, 0x39, 0x39, 0x37, 0x35, 0x35, 0x66, 0x65, 0x35, 0x35, 0x66, 0x35, 0x66, 0x31, 0x63, 0x32, 0x34, 0x64, 0x64, 0x31, 0x34, 0x65, 0x66, 0x65, 0x62, 0x32, 0x30, 0x61, 0x61, 0x66, 0x33, 0x61, 0x64, 0x62, 0x37, 0x33, 0x39, 0x36, 0x33, 0x37, 0x30, 0x33, 0x31, 0x64, 0x30, 0x33, 0x32, 0x63, 0x65, 0x32, 0x30, 0x33, 0x63, 0x30, 0x36, 0x36, 0x30, 0x64, 0x37, 0x64, 0x36, 0x64, 0x66, 0x39, 0x37, 0x62, 0x38, 0x35, 0x63, 0x31, 0x35, 0x64, 0x64, 0x64, 0x32, 0x32, 0x38, 0x61, 0x66, 0x32, 0x30, 0x35, 0x38, 0x66, 0x35, 0x35, 0x30, 0x38, 0x38, 0x63, 0x32, 0x33, 0x66, 0x34, 0x32, 0x33, 0x62, 0x66, 0x30, 0x32, 0x39, 0x36, 0x61, 0x30, 0x39, 0x39, 0x64, 0x61, 0x62, 0x63, 0x31, 0x39, 0x66, 0x62, 0x35, 0x31, 0x66, 0x30, 0x37, 0x32, 0x32, 0x34, 0x35, 0x36, 0x32, 0x36, 0x30, 0x34, 0x35, 0x30, 0x38, 0x36, 0x31, 0x62, 0x62, 0x32, 0x38, 0x31, 0x65, 0x66, 0x62, 0x32, 0x30, 0x34, 0x32, 0x30, 0x33, 0x39, 0x63, 0x63, 0x36, 0x39, 0x32, 0x34, 0x32, 0x61, 0x65, 0x63, 0x37, 0x65, 0x64, 0x66, 0x64, 0x32, 0x35, 0x38, 0x37, 0x35, 0x63, 0x37, 0x66, 0x61, 0x35, 0x37, 0x61, 0x37, 0x64, 0x37, 0x33, 0x33, 0x31, 0x65, 0x34, 0x66, 0x33, 0x66, 0x39, 0x38, 0x64, 0x61, 0x61, 0x63, 0x37, 0x32, 0x65, 0x36, 0x63, 0x64, 0x35, 0x35, 0x32, 0x62, 0x37, 0x37, 0x39, 0x64, 0x63, 0x31, 0x33, 0x37, 0x34, 0x65, 0x61, 0x37, 0x39, 0x39, 0x31, 0x32, 0x39, 0x66, 0x62, 0x61, 0x34, 0x32, 0x65, 0x35, 0x61, 0x62, 0x66, 0x31, 0x31, 0x62, 0x35, 0x31, 0x65, 0x61, 0x66, 0x34, 0x33, 0x31, 0x64, 0x61, 0x39, 0x66, 0x39, 0x31, 0x31, 0x31, 0x36, 0x30, 0x30, 0x65, 0x38, 0x35, 0x35, 0x65, 0x37, 0x30, 0x33, 0x66, 0x37, 0x34, 0x30, 0x39, 0x64, 0x31, 0x39, 0x38, 0x66, 0x39, 0x31, 0x33, 0x35, 0x62, 0x30, 0x33, 0x63, 0x38, 0x65, 0x34, 0x30, 0x62, 0x39, 0x63, 0x61, 0x64, 0x39, 0x33, 0x64, 0x65, 0x64, 0x61, 0x38, 0x31, 0x65, 0x32, 0x36, 0x33, 0x65, 0x35, 0x38, 0x61, 0x34, 0x39, 0x63, 0x35, 0x38, 0x34, 0x34, 0x31, 0x37, 0x32, 0x38, 0x61, 0x36, 0x31, 0x38, 0x65, 0x31, 0x31, 0x37, 0x33, 0x34, 0x65, 0x62, 0x37, 0x31, 0x38, 0x33, 0x38, 0x38, 0x33, 0x61, 0x66, 0x36, 0x61, 0x63, 0x39, 0x31, 0x37, 0x65, 0x31, 0x31, 0x33, 0x65, 0x35, 0x63, 0x36, 0x35, 0x31, 0x31, 0x35, 0x64, 0x65, 0x65, 0x62, 0x63, 0x37, 0x66, 0x66, 0x33, 0x30, 0x35, 0x64, 0x36, 0x31, 0x62, 0x32, 0x37, 0x63, 0x35, 0x35, 0x31, 0x36, 0x36, 0x32, 0x66, 0x32, 0x37, 0x63, 0x38, 0x34, 0x62, 0x34, 0x64, 0x65, 0x64, 0x64, 0x63, 0x35, 0x65, 0x34, 0x30, 0x39, 0x35, 0x62, 0x33, 0x64, 0x31, 0x30, 0x65, 0x64, 0x35, 0x33, 0x31, 0x35, 0x31, 0x30, 0x35, 0x31, 0x66, 0x31, 0x61, 0x38, 0x32, 0x38, 0x39, 0x63, 0x62, 0x64, 0x66, 0x31, 0x66, 0x66, 0x64, 0x37, 0x39, 0x34, 0x32, 0x65, 0x35, 0x35, 0x61, 0x35, 0x66, 0x32, 0x33, 0x62, 0x37, 0x32, 0x66, 0x33, 0x61, 0x66, 0x61, 0x33, 0x66, 0x64, 0x39, 0x37, 0x30, 0x36, 0x66, 0x38, 0x64, 0x39, 0x30, 0x39, 0x30, 0x39, 0x36, 0x63, 0x64, 0x62, 0x33, 0x35, 0x31, 0x39, 0x31, 0x35, 0x37, 0x64, 0x32, 0x34, 0x39, 0x32, 0x66, 0x32, 0x61, 0x36, 0x37, 0x61, 0x34, 0x35, 0x65, 0x31, 0x39, 0x35, 0x62, 0x31, 0x37, 0x30, 0x39, 0x66, 0x36, 0x35, 0x31, 0x62, 0x37, 0x38, 0x63, 0x66, 0x37, 0x32, 0x66, 0x63, 0x61, 0x34, 0x62, 0x34, 0x31, 0x65, 0x36, 0x61, 0x31, 0x31, 0x38, 0x38, 0x36, 0x66, 0x34, 0x37, 0x39, 0x39, 0x39, 0x39, 0x61, 0x33, 0x37, 0x66, 0x33, 0x64, 0x38, 0x32, 0x37, 0x36, 0x39, 0x31, 0x30, 0x32, 0x66, 0x34, 0x36, 0x65, 0x34, 0x65, 0x39, 0x64, 0x64, 0x61, 0x30, 0x39, 0x33, 0x33, 0x39, 0x31, 0x34, 0x35, 0x61, 0x32, 0x30, 0x30, 0x36, 0x64, 0x34, 0x30, 0x37, 0x32, 0x61, 0x39, 0x64, 0x65, 0x36, 0x33, 0x62, 0x31, 0x30, 0x63, 0x36, 0x64, 0x64, 0x35, 0x64, 0x34, 0x30, 0x34, 0x37, 0x62, 0x38, 0x63, 0x65, 0x61, 0x62, 0x36, 0x62, 0x64, 0x62, 0x36, 0x63, 0x35, 0x62, 0x37, 0x39, 0x66, 0x35, 0x30, 0x35, 0x32, 0x65, 0x35, 0x62, 0x38, 0x38, 0x33, 0x36, 0x63, 0x31, 0x63, 0x35, 0x35, 0x62, 0x38, 0x34, 0x39, 0x33, 0x66, 0x63, 0x38, 0x37, 0x35, 0x37, 0x32, 0x62, 0x66, 0x61, 0x38, 0x61, 0x36, 0x64, 0x38, 0x66, 0x37, 0x32, 0x31, 0x36, 0x35, 0x36, 0x31, 0x64, 0x63, 0x38, 0x64, 0x30, 0x35, 0x65, 0x31, 0x31, 0x37, 0x37, 0x65, 0x35, 0x36, 0x63, 0x65, 0x38, 0x32, 0x36, 0x35, 0x66, 0x34, 0x35, 0x62, 0x63, 0x64, 0x31, 0x62, 0x35, 0x33, 0x39, 0x32, 0x61, 0x65, 0x34, 0x63, 0x33, 0x65, 0x34, 0x61, 0x66, 0x35, 0x39, 0x30, 0x61, 0x62, 0x33, 0x36, 0x32, 0x38, 0x33, 0x38, 0x66, 0x61, 0x34, 0x34, 0x65, 0x34, 0x62, 0x63, 0x64, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, 0x35, 0x37, 0x34, 0x64, 0x63, 0x63, 0x36, 0x61, 0x35, 0x33, 0x34, 0x35, 0x31, 0x36, 0x64, 0x31, 0x36, 0x37, 0x66, 0x34, 0x32, 0x34, 0x62, 0x33, 0x63, 0x63, 0x37, 0x61, 0x66, 0x38, 0x31, 0x36, 0x35, 0x61, 0x33, 0x64, 0x37, 0x31, 0x38, 0x63, 0x31, 0x31, 0x39, 0x37, 0x32, 0x62, 0x37, 0x35, 0x66, 0x35, 0x36, 0x31, 0x63, 0x31, 0x31, 0x66, 0x64, 0x31, 0x38, 0x37, 0x31, 0x33, 0x33, 0x64, 0x62, 0x34, 0x63, 0x39, 0x64, 0x64, 0x34, 0x63, 0x36, 0x66, 0x62, 0x33, 0x36, 0x35, 0x61, 0x31, 0x38, 0x31, 0x39, 0x35, 0x31, 0x63, 0x31, 0x30, 0x63, 0x34, 0x30, 0x39, 0x38, 0x61, 0x63, 0x63, 0x33, 0x38, 0x38, 0x37, 0x33, 0x63, 0x39, 0x37, 0x64, 0x37, 0x39, 0x31, 0x35, 0x65, 0x35, 0x33, 0x66, 0x33, 0x32, 0x66, 0x37, 0x32, 0x36, 0x31, 0x61, 0x65, 0x63, 0x63, 0x31, 0x38, 0x66, 0x30, 0x66, 0x66, 0x32, 0x30, 0x64, 0x61, 0x35, 0x33, 0x63, 0x32, 0x61, 0x64, 0x39, 0x38, 0x36, 0x35, 0x66, 0x64, 0x35, 0x30, 0x61, 0x36, 0x37, 0x37, 0x62, 0x65, 0x32, 0x31, 0x64, 0x32, 0x30, 0x62, 0x62, 0x39, 0x30, 0x61, 0x65, 0x62, 0x64, 0x30, 0x32, 0x61, 0x34, 0x37, 0x32, 0x30, 0x32, 0x65, 0x35, 0x63, 0x37, 0x34, 0x36, 0x62, 0x37, 0x37, 0x61, 0x62, 0x63, 0x36, 0x37, 0x64, 0x36, 0x36, 0x37, 0x33, 0x62, 0x35, 0x32, 0x35, 0x37, 0x62, 0x66, 0x37, 0x66, 0x34, 0x39, 0x64, 0x38, 0x37, 0x35, 0x65, 0x61, 0x39, 0x39, 0x39, 0x62, 0x34, 0x34, 0x64, 0x36, 0x64, 0x65, 0x37, 0x37, 0x31, 0x66, 0x33, 0x63, 0x62, 0x39, 0x63, 0x39, 0x36, 0x38, 0x37, 0x33, 0x37, 0x32, 0x38, 0x63, 0x36, 0x32, 0x65, 0x32, 0x64, 0x66, 0x35, 0x30, 0x64, 0x38, 0x39, 0x65, 0x66, 0x66, 0x31, 0x65, 0x32, 0x63, 0x36, 0x37, 0x61, 0x39, 0x65, 0x35, 0x33, 0x39, 0x66, 0x66, 0x31, 0x38, 0x31, 0x61, 0x37, 0x64, 0x64, 0x63, 0x30, 0x66, 0x66, 0x63, 0x66, 0x32, 0x62, 0x37, 0x66, 0x34, 0x36, 0x31, 0x30, 0x32, 0x35, 0x31, 0x61, 0x63, 0x63, 0x38, 0x63, 0x66, 0x35, 0x61, 0x37, 0x32, 0x66, 0x38, 0x61, 0x32, 0x37, 0x35, 0x31, 0x31, 0x30, 0x64, 0x63, 0x38, 0x32, 0x66, 0x39, 0x62, 0x66, 0x31, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x37, 0x30, 0x36, 0x64, 0x63, 0x61, 0x33, 0x33, 0x30, 0x32, 0x33, 0x64, 0x30, 0x62, 0x33, 0x33, 0x31, 0x39, 0x37, 0x33, 0x39, 0x31, 0x64, 0x37, 0x37, 0x61, 0x33, 0x32, 0x30, 0x65, 0x66, 0x39, 0x32, 0x34, 0x34, 0x35, 0x35, 0x31, 0x37, 0x32, 0x35, 0x64, 0x35, 0x38, 0x36, 0x33, 0x31, 0x38, 0x61, 0x38, 0x39, 0x31, 0x65, 0x65, 0x63, 0x37, 0x31, 0x33, 0x66, 0x34, 0x36, 0x30, 0x66, 0x32, 0x30, 0x66, 0x66, 0x35, 0x35, 0x30, 0x38, 0x39, 0x37, 0x61, 0x65, 0x33, 0x66, 0x63, 0x37, 0x34, 0x65, 0x32, 0x33, 0x37, 0x62, 0x61, 0x35, 0x34, 0x62, 0x39, 0x39, 0x35, 0x37, 0x64, 0x33, 0x36, 0x30, 0x35, 0x30, 0x30, 0x39, 0x64, 0x37, 0x32, 0x36, 0x38, 0x33, 0x61, 0x66, 0x64, 0x32, 0x64, 0x62, 0x38, 0x64, 0x61, 0x30, 0x64, 0x39, 0x64, 0x33, 0x37, 0x65, 0x39, 0x32, 0x35, 0x32, 0x36, 0x33, 0x32, 0x64, 0x32, 0x63, 0x32, 0x66, 0x35, 0x32, 0x65, 0x30, 0x62, 0x62, 0x35, 0x30, 0x38, 0x34, 0x36, 0x30, 0x34, 0x66, 0x64, 0x65, 0x62, 0x34, 0x38, 0x34, 0x34, 0x30, 0x35, 0x63, 0x65, 0x32, 0x66, 0x33, 0x34, 0x62, 0x39, 0x31, 0x63, 0x38, 0x62, 0x38, 0x33, 0x62, 0x66, 0x63, 0x61, 0x33, 0x64, 0x30, 0x33, 0x65, 0x33, 0x30, 0x35, 0x36, 0x61, 0x33, 0x31, 0x36, 0x37, 0x62, 0x63, 0x39, 0x33, 0x66, 0x65, 0x61, 0x64, 0x62, 0x34, 0x34, 0x36, 0x33, 0x35, 0x34, 0x33, 0x35, 0x61, 0x64, 0x39, 0x35, 0x39, 0x64, 0x38, 0x37, 0x38, 0x34, 0x63, 0x34, 0x33, 0x35, 0x32, 0x65, 0x31, 0x66, 0x38, 0x64, 0x32, 0x35, 0x38, 0x36, 0x38, 0x65, 0x34, 0x65, 0x63, 0x63, 0x63, 0x37, 0x31, 0x36, 0x64, 0x62, 0x64, 0x38, 0x33, 0x37, 0x37, 0x63, 0x65, 0x62, 0x39, 0x33, 0x39, 0x39, 0x33, 0x33, 0x61, 0x34, 0x33, 0x65, 0x35, 0x30, 0x66, 0x35, 0x33, 0x33, 0x63, 0x38, 0x63, 0x30, 0x62, 0x64, 0x64, 0x64, 0x33, 0x39, 0x35, 0x39, 0x61, 0x38, 0x65, 0x31, 0x36, 0x32, 0x31, 0x36, 0x33, 0x65, 0x61, 0x33, 0x62, 0x32, 0x63, 0x32, 0x66, 0x37, 0x35, 0x35, 0x31, 0x61, 0x39, 0x33, 0x39, 0x32, 0x30, 0x61, 0x65, 0x62, 0x36, 0x35, 0x65, 0x33, 0x35, 0x35, 0x35, 0x62, 0x64, 0x33, 0x35, 0x65, 0x34, 0x39, 0x37, 0x37, 0x63, 0x62, 0x30, 0x36, 0x33, 0x35, 0x63, 0x62, 0x66, 0x61, 0x33, 0x65, 0x37, 0x61, 0x64, 0x61, 0x65, 0x34, 0x37, 0x61, 0x64, 0x31, 0x36, 0x66, 0x61, 0x61, 0x38, 0x62, 0x37, 0x61, 0x61, 0x38, 0x65, 0x37, 0x32, 0x35, 0x30, 0x65, 0x36, 0x65, 0x63, 0x63, 0x34, 0x37, 0x62, 0x62, 0x31, 0x35, 0x61, 0x31, 0x30, 0x38, 0x62, 0x30, 0x61, 0x66, 0x63, 0x65, 0x66, 0x31, 0x63, 0x32, 0x34, 0x36, 0x32, 0x32, 0x62, 0x63, 0x65, 0x66, 0x61, 0x39, 0x33, 0x39, 0x62, 0x62, 0x30, 0x32, 0x63, 0x30, 0x35, 0x65, 0x30, 0x61, 0x66, 0x36, 0x66, 0x36, 0x30, 0x35, 0x35, 0x63, 0x38, 0x35, 0x30, 0x35, 0x62, 0x37, 0x32, 0x62, 0x35, 0x39, 0x39, 0x37, 0x33, 0x36, 0x30, 0x62, 0x32, 0x35, 0x33, 0x32, 0x39, 0x38, 0x65, 0x63, 0x33, 0x63, 0x39, 0x33, 0x31, 0x31, 0x33, 0x63, 0x30, 0x31, 0x64, 0x65, 0x38, 0x65, 0x33, 0x33, 0x33, 0x36, 0x61, 0x39, 0x39, 0x39, 0x34, 0x34, 0x38, 0x66, 0x30, 0x66, 0x33, 0x35, 0x33, 0x38, 0x32, 0x64, 0x64, 0x66, 0x38, 0x30, 0x63, 0x39, 0x65, 0x61, 0x34, 0x65, 0x33, 0x35, 0x61, 0x31, 0x63, 0x31, 0x63, 0x64, 0x30, 0x33, 0x62, 0x62, 0x37, 0x61, 0x30, 0x31, 0x30, 0x33, 0x65, 0x65, 0x37, 0x33, 0x30, 0x34, 0x61, 0x63, 0x31, 0x62, 0x34, 0x66, 0x38, 0x65, 0x36, 0x33, 0x66, 0x62, 0x61, 0x39, 0x37, 0x66, 0x66, 0x31, 0x66, 0x30, 0x39, 0x61, 0x65, 0x37, 0x31, 0x36, 0x32, 0x64, 0x35, 0x36, 0x32, 0x39, 0x66, 0x63, 0x38, 0x30, 0x34, 0x33, 0x34, 0x38, 0x34, 0x37, 0x32, 0x65, 0x61, 0x64, 0x37, 0x39, 0x39, 0x61, 0x39, 0x38, 0x32, 0x32, 0x62, 0x63, 0x34, 0x32, 0x64, 0x31, 0x31, 0x65, 0x38, 0x65, 0x66, 0x34, 0x63, 0x35, 0x34, 0x32, 0x36, 0x31, 0x61, 0x31, 0x63, 0x35, 0x33, 0x66, 0x62, 0x36, 0x62, 0x34, 0x63, 0x32, 0x64, 0x37, 0x34, 0x62, 0x61, 0x32, 0x65, 0x62, 0x64, 0x37, 0x38, 0x37, 0x31, 0x37, 0x63, 0x66, 0x62, 0x32, 0x34, 0x64, 0x33, 0x37, 0x32, 0x66, 0x64, 0x36, 0x36, 0x33, 0x33, 0x63, 0x65, 0x35, 0x62, 0x62, 0x66, 0x62, 0x63, 0x33, 0x61, 0x30, 0x36, 0x33, 0x35, 0x64, 0x66, 0x31, 0x38, 0x63, 0x39, 0x39, 0x33, 0x32, 0x62, 0x32, 0x33, 0x30, 0x63, 0x63, 0x35, 0x34, 0x37, 0x64, 0x30, 0x64, 0x61, 0x39, 0x30, 0x30, 0x34, 0x65, 0x63, 0x32, 0x63, 0x65, 0x32, 0x36, 0x63, 0x30, 0x36, 0x65, 0x66, 0x39, 0x35, 0x63, 0x36, 0x32, 0x38, 0x30, 0x36, 0x37, 0x63, 0x64, 0x30, 0x30, 0x38, 0x32, 0x61, 0x30, 0x36, 0x66, 0x37, 0x63, 0x65, 0x66, 0x34, 0x65, 0x65, 0x64, 0x39, 0x39, 0x37, 0x30, 0x63, 0x32, 0x64, 0x38, 0x63, 0x37, 0x63, 0x63, 0x36, 0x30, 0x61, 0x62, 0x34, 0x66, 0x62, 0x35, 0x64, 0x36, 0x65, 0x63, 0x37, 0x62, 0x62, 0x30, 0x38, 0x61, 0x64, 0x65, 0x36, 0x63, 0x62, 0x66, 0x35, 0x63, 0x65, 0x61, 0x62, 0x34, 0x36, 0x39, 0x37, 0x66, 0x37, 0x35, 0x64, 0x62, 0x30, 0x61, 0x62, 0x35, 0x38, 0x64, 0x36, 0x35, 0x38, 0x35, 0x62, 0x38, 0x65, 0x35, 0x37, 0x33, 0x32, 0x39, 0x36, 0x33, 0x64, 0x35, 0x38, 0x63, 0x33, 0x37, 0x62, 0x36, 0x39, 0x30, 0x34, 0x62, 0x66, 0x37, 0x64, 0x33, 0x63, 0x64, 0x35, 0x37, 0x32, 0x31, 0x35, 0x37, 0x32, 0x35, 0x31, 0x31, 0x31, 0x66, 0x62, 0x64, 0x32, 0x33, 0x31, 0x32, 0x30, 0x32, 0x31, 0x34, 0x61, 0x63, 0x38, 0x33, 0x63, 0x33, 0x63, 0x38, 0x31, 0x30, 0x63, 0x39, 0x66, 0x33, 0x64, 0x34, 0x61, 0x39, 0x61, 0x31, 0x65, 0x34, 0x33, 0x32, 0x38, 0x36, 0x66, 0x66, 0x62, 0x33, 0x38, 0x33, 0x35, 0x39, 0x37, 0x32, 0x62, 0x62, 0x36, 0x66, 0x62, 0x30, 0x35, 0x32, 0x31, 0x63, 0x31, 0x30, 0x37, 0x61, 0x36, 0x61, 0x36, 0x37, 0x36, 0x39, 0x36, 0x66, 0x30, 0x34, 0x34, 0x39, 0x30, 0x39, 0x35, 0x66, 0x35, 0x30, 0x34, 0x66, 0x66, 0x31, 0x63, 0x37, 0x35, 0x64, 0x30, 0x36, 0x36, 0x39, 0x30, 0x35, 0x32, 0x63, 0x36, 0x61, 0x34, 0x35, 0x65, 0x64, 0x32, 0x63, 0x36, 0x37, 0x64, 0x31, 0x63, 0x35, 0x39, 0x61, 0x37, 0x39, 0x32, 0x65, 0x64, 0x32, 0x62, 0x39, 0x62, 0x64, 0x66, 0x61, 0x30, 0x39, 0x64, 0x36, 0x66, 0x62, 0x66, 0x38, 0x35, 0x36, 0x37, 0x37, 0x32, 0x39, 0x36, 0x30, 0x36, 0x33, 0x33, 0x66, 0x66, 0x66, 0x39, 0x33, 0x39, 0x39, 0x63, 0x30, 0x66, 0x38, 0x36, 0x62, 0x30, 0x32, 0x65, 0x31, 0x36, 0x30, 0x32, 0x35, 0x62, 0x37, 0x31, 0x37, 0x36, 0x61, 0x63, 0x37, 0x34, 0x35, 0x31, 0x62, 0x33, 0x65, 0x62, 0x66, 0x33, 0x38, 0x34, 0x37, 0x39, 0x32, 0x65, 0x39, 0x38, 0x65, 0x39, 0x36, 0x36, 0x36, 0x30, 0x61, 0x39, 0x64, 0x38, 0x37, 0x32, 0x62, 0x34, 0x63, 0x61, 0x35, 0x61, 0x63, 0x61, 0x35, 0x34, 0x36, 0x38, 0x31, 0x64, 0x36, 0x63, 0x34, 0x37, 0x66, 0x31, 0x64, 0x62, 0x32, 0x31, 0x38, 0x61, 0x35, 0x38, 0x38, 0x33, 0x34, 0x31, 0x64, 0x66, 0x37, 0x37, 0x39, 0x66, 0x63, 0x32, 0x30, 0x32, 0x66, 0x38, 0x61, 0x39, 0x37, 0x32, 0x36, 0x61, 0x35, 0x36, 0x37, 0x64, 0x30, 0x65, 0x61, 0x31, 0x61, 0x37, 0x62, 0x32, 0x33, 0x61, 0x66, 0x37, 0x64, 0x31, 0x34, 0x62, 0x61, 0x65, 0x39, 0x30, 0x65, 0x38, 0x36, 0x64, 0x35, 0x63, 0x32, 0x37, 0x39, 0x38, 0x65, 0x37, 0x65, 0x30, 0x32, 0x30, 0x37, 0x63, 0x36, 0x61, 0x36, 0x33, 0x64, 0x39, 0x39, 0x65, 0x30, 0x66, 0x36, 0x39, 0x38, 0x65, 0x31, 0x39, 0x65, 0x38, 0x66, 0x64, 0x32, 0x66, 0x38, 0x37, 0x36, 0x62, 0x35, 0x35, 0x30, 0x35, 0x63, 0x33, 0x66, 0x62, 0x37, 0x32, 0x65, 0x64, 0x34, 0x62, 0x34, 0x39, 0x65, 0x33, 0x32, 0x33, 0x62, 0x32, 0x36, 0x66, 0x34, 0x63, 0x64, 0x34, 0x62, 0x34, 0x32, 0x30, 0x38, 0x30, 0x66, 0x35, 0x31, 0x33, 0x65, 0x65, 0x62, 0x62, 0x65, 0x62, 0x32, 0x66, 0x62, 0x38, 0x65, 0x33, 0x39, 0x63, 0x33, 0x31, 0x65, 0x61, 0x33, 0x34, 0x37, 0x33, 0x30, 0x38, 0x37, 0x33, 0x39, 0x38, 0x39, 0x63, 0x34, 0x36, 0x31, 0x32, 0x30, 0x30, 0x66, 0x39, 0x39, 0x64, 0x31, 0x66, 0x64, 0x33, 0x64, 0x63, 0x34, 0x30, 0x63, 0x61, 0x63, 0x62, 0x36, 0x65, 0x34, 0x38, 0x61, 0x35, 0x32, 0x33, 0x61, 0x35, 0x33, 0x64, 0x30, 0x63, 0x36, 0x38, 0x30, 0x36, 0x61, 0x62, 0x36, 0x36, 0x34, 0x32, 0x33, 0x64, 0x61, 0x39, 0x33, 0x64, 0x65, 0x32, 0x33, 0x65, 0x35, 0x30, 0x33, 0x66, 0x34, 0x65, 0x39, 0x34, 0x64, 0x32, 0x34, 0x34, 0x32, 0x33, 0x66, 0x38, 0x30, 0x31, 0x65, 0x37, 0x38, 0x38, 0x39, 0x38, 0x37, 0x61, 0x39, 0x65, 0x63, 0x34, 0x35, 0x39, 0x38, 0x37, 0x61, 0x63, 0x33, 0x63, 0x61, 0x30, 0x36, 0x39, 0x35, 0x64, 0x64, 0x35, 0x33, 0x35, 0x33, 0x37, 0x35, 0x63, 0x32, 0x38, 0x30, 0x32, 0x35, 0x38, 0x39, 0x31, 0x32, 0x38, 0x36, 0x65, 0x35, 0x61, 0x61, 0x66, 0x38, 0x30, 0x63, 0x39, 0x39, 0x35, 0x65, 0x65, 0x32, 0x65, 0x61, 0x30, 0x63, 0x64, 0x38, 0x31, 0x64, 0x31, 0x33, 0x63, 0x32, 0x38, 0x32, 0x62, 0x38, 0x61, 0x32, 0x39, 0x62, 0x36, 0x61, 0x63, 0x64, 0x31, 0x31, 0x65, 0x36, 0x61, 0x65, 0x62, 0x66, 0x32, 0x33, 0x31, 0x31, 0x33, 0x35, 0x63, 0x65, 0x30, 0x36, 0x37, 0x33, 0x35, 0x33, 0x36, 0x65, 0x34, 0x38, 0x64, 0x61, 0x65, 0x33, 0x37, 0x39, 0x32, 0x38, 0x34, 0x33, 0x39, 0x61, 0x62, 0x37, 0x32, 0x62, 0x31, 0x30, 0x65, 0x36, 0x30, 0x62, 0x34, 0x37, 0x30, 0x63, 0x66, 0x38, 0x64, 0x36, 0x36, 0x64, 0x63, 0x64, 0x39, 0x64, 0x33, 0x34, 0x32, 0x32, 0x61, 0x64, 0x34, 0x37, 0x64, 0x30, 0x63, 0x39, 0x35, 0x66, 0x36, 0x61, 0x32, 0x35, 0x66, 0x31, 0x37, 0x65, 0x34, 0x39, 0x36, 0x33, 0x33, 0x64, 0x63, 0x62, 0x30, 0x61, 0x35, 0x32, 0x61, 0x32, 0x30, 0x39, 0x65, 0x66, 0x32, 0x34, 0x38, 0x32, 0x65, 0x65, 0x32, 0x34, 0x36, 0x37, 0x63, 0x63, 0x62, 0x62, 0x63, 0x38, 0x61, 0x39, 0x37, 0x65, 0x36, 0x36, 0x35, 0x62, 0x30, 0x61, 0x64, 0x37, 0x61, 0x32, 0x39, 0x61, 0x38, 0x31, 0x31, 0x66, 0x31, 0x62, 0x64, 0x34, 0x64, 0x63, 0x37, 0x36, 0x61, 0x66, 0x36, 0x36, 0x32, 0x65, 0x63, 0x63, 0x36, 0x64, 0x38, 0x32, 0x34, 0x61, 0x33, 0x39, 0x64, 0x35, 0x38, 0x62, 0x35, 0x30, 0x66, 0x33, 0x61, 0x35, 0x34, 0x65, 0x32, 0x39, 0x64, 0x31, 0x34, 0x34, 0x61, 0x31, 0x64, 0x34, 0x37, 0x62, 0x66, 0x34, 0x65, 0x38, 0x38, 0x61, 0x36, 0x37, 0x32, 0x61, 0x66, 0x30, 0x37, 0x33, 0x35, 0x39, 0x36, 0x62, 0x66, 0x30, 0x36, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x65, 0x35, 0x35, 0x62, 0x35, 0x30, 0x34, 0x33, 0x30, 0x37, 0x62, 0x34, 0x38, 0x66, 0x61, 0x37, 0x64, 0x35, 0x37, 0x32, 0x64, 0x32, 0x64, 0x62, 0x32, 0x35, 0x63, 0x33, 0x39, 0x35, 0x35, 0x34, 0x65, 0x38, 0x33, 0x33, 0x36, 0x36, 0x62, 0x37, 0x34, 0x35, 0x65, 0x34, 0x61, 0x30, 0x65, 0x32, 0x35, 0x64, 0x32, 0x34, 0x66, 0x39, 0x35, 0x61, 0x36, 0x33, 0x37, 0x33, 0x31, 0x38, 0x30, 0x34, 0x36, 0x34, 0x37, 0x66, 0x65, 0x63, 0x32, 0x36, 0x64, 0x36, 0x62, 0x39, 0x30, 0x34, 0x37, 0x65, 0x36, 0x37, 0x37, 0x32, 0x63, 0x37, 0x36, 0x63, 0x30, 0x31, 0x62, 0x32, 0x38, 0x37, 0x63, 0x32, 0x62, 0x63, 0x39, 0x38, 0x61, 0x39, 0x64, 0x65, 0x30, 0x61, 0x66, 0x35, 0x61, 0x64, 0x30, 0x35, 0x36, 0x34, 0x64, 0x66, 0x36, 0x62, 0x37, 0x64, 0x32, 0x31, 0x63, 0x34, 0x33, 0x31, 0x34, 0x36, 0x34, 0x38, 0x38, 0x38, 0x38, 0x34, 0x39, 0x65, 0x36, 0x34, 0x35, 0x62, 0x39, 0x31, 0x36, 0x64, 0x61, 0x39, 0x37, 0x32, 0x64, 0x61, 0x34, 0x63, 0x65, 0x32, 0x34, 0x61, 0x66, 0x33, 0x38, 0x36, 0x64, 0x64, 0x63, 0x66, 0x39, 0x38, 0x31, 0x31, 0x65, 0x64, 0x63, 0x30, 0x39, 0x65, 0x61, 0x64, 0x66, 0x62, 0x31, 0x36, 0x37, 0x31, 0x33, 0x63, 0x61, 0x31, 0x36, 0x63, 0x63, 0x66, 0x39, 0x35, 0x63, 0x64, 0x61, 0x34, 0x66, 0x63, 0x35, 0x36, 0x32, 0x30, 0x36, 0x65, 0x38, 0x34, 0x39, 0x30, 0x36, 0x66, 0x31, 0x61, 0x61, 0x63, 0x33, 0x30, 0x62, 0x33, 0x31, 0x37, 0x31, 0x36, 0x62, 0x66, 0x30, 0x33, 0x35, 0x61, 0x64, 0x35, 0x36, 0x34, 0x62, 0x39, 0x64, 0x66, 0x63, 0x35, 0x62, 0x62, 0x65, 0x39, 0x62, 0x66, 0x63, 0x38, 0x35, 0x30, 0x39, 0x35, 0x35, 0x35, 0x34, 0x64, 0x32, 0x38, 0x38, 0x35, 0x32, 0x31, 0x34, 0x39, 0x66, 0x37, 0x31, 0x32, 0x31, 0x33, 0x35, 0x64, 0x30, 0x33, 0x36, 0x64, 0x37, 0x32, 0x38, 0x32, 0x32, 0x30, 0x36, 0x64, 0x34, 0x38, 0x31, 0x39, 0x66, 0x38, 0x39, 0x37, 0x30, 0x31, 0x61, 0x37, 0x63, 0x65, 0x34, 0x31, 0x61, 0x61, 0x33, 0x64, 0x64, 0x34, 0x33, 0x34, 0x64, 0x31, 0x39, 0x38, 0x34, 0x39, 0x34, 0x34, 0x30, 0x39, 0x33, 0x31, 0x31, 0x66, 0x34, 0x66, 0x30, 0x35, 0x34, 0x33, 0x31, 0x61, 0x62, 0x32, 0x31, 0x32, 0x34, 0x65, 0x37, 0x38, 0x39, 0x64, 0x31, 0x35, 0x61, 0x61, 0x37, 0x61, 0x35, 0x61, 0x39, 0x33, 0x64, 0x38, 0x39, 0x37, 0x33, 0x64, 0x62, 0x61, 0x64, 0x32, 0x39, 0x65, 0x65, 0x64, 0x39, 0x30, 0x33, 0x62, 0x65, 0x61, 0x32, 0x39, 0x62, 0x61, 0x32, 0x33, 0x33, 0x63, 0x32, 0x30, 0x36, 0x34, 0x31, 0x64, 0x61, 0x34, 0x32, 0x37, 0x66, 0x32, 0x33, 0x31, 0x63, 0x30, 0x62, 0x66, 0x31, 0x32, 0x63, 0x31, 0x61, 0x63, 0x34, 0x32, 0x35, 0x34, 0x64, 0x63, 0x31, 0x61, 0x39, 0x64, 0x34, 0x64, 0x39, 0x61, 0x32, 0x63, 0x66, 0x32, 0x32, 0x38, 0x36, 0x35, 0x33, 0x62, 0x64, 0x33, 0x38, 0x36, 0x66, 0x39, 0x64, 0x63, 0x30, 0x63, 0x32, 0x38, 0x33, 0x66, 0x30, 0x34, 0x61, 0x34, 0x65, 0x39, 0x31, 0x65, 0x65, 0x33, 0x61, 0x32, 0x64, 0x36, 0x63, 0x30, 0x33, 0x61, 0x61, 0x62, 0x35, 0x30, 0x63, 0x30, 0x61, 0x62, 0x66, 0x39, 0x36, 0x34, 0x37, 0x64, 0x30, 0x37, 0x32, 0x31, 0x62, 0x34, 0x37, 0x31, 0x38, 0x64, 0x35, 0x34, 0x64, 0x62, 0x34, 0x33, 0x33, 0x32, 0x34, 0x61, 0x39, 0x34, 0x34, 0x38, 0x31, 0x32, 0x62, 0x39, 0x36, 0x62, 0x36, 0x66, 0x38, 0x34, 0x34, 0x61, 0x39, 0x61, 0x36, 0x35, 0x36, 0x66, 0x64, 0x33, 0x64, 0x39, 0x63, 0x34, 0x61, 0x63, 0x63, 0x38, 0x66, 0x30, 0x66, 0x32, 0x31, 0x64, 0x38, 0x36, 0x37, 0x32, 0x34, 0x31, 0x61, 0x65, 0x38, 0x62, 0x63, 0x65, 0x37, 0x30, 0x66, 0x63, 0x39, 0x38, 0x66, 0x64, 0x31, 0x66, 0x35, 0x37, 0x37, 0x64, 0x37, 0x62, 0x64, 0x37, 0x64, 0x61, 0x32, 0x66, 0x33, 0x30, 0x39, 0x65, 0x64, 0x37, 0x63, 0x34, 0x35, 0x66, 0x36, 0x65, 0x62, 0x38, 0x38, 0x39, 0x66, 0x31, 0x61, 0x36, 0x38, 0x62, 0x66, 0x32, 0x35, 0x66, 0x33, 0x63, 0x65, 0x31, 0x64, 0x31, 0x33, 0x38, 0x37, 0x31, 0x65, 0x62, 0x33, 0x66, 0x33, 0x31, 0x62, 0x61, 0x39, 0x37, 0x37, 0x66, 0x32, 0x30, 0x63, 0x63, 0x37, 0x31, 0x39, 0x36, 0x63, 0x66, 0x34, 0x66, 0x64, 0x32, 0x65, 0x32, 0x62, 0x62, 0x30, 0x35, 0x35, 0x66, 0x39, 0x61, 0x37, 0x37, 0x39, 0x65, 0x30, 0x30, 0x33, 0x34, 0x65, 0x64, 0x35, 0x36, 0x35, 0x39, 0x32, 0x36, 0x30, 0x31, 0x62, 0x37, 0x65, 0x39, 0x31, 0x35, 0x31, 0x30, 0x37, 0x30, 0x32, 0x65, 0x33, 0x30, 0x35, 0x38, 0x37, 0x36, 0x37, 0x62, 0x39, 0x35, 0x64, 0x65, 0x62, 0x65, 0x64, 0x33, 0x35, 0x39, 0x31, 0x37, 0x61, 0x33, 0x33, 0x34, 0x64, 0x61, 0x62, 0x32, 0x65, 0x31, 0x34, 0x66, 0x66, 0x39, 0x62, 0x30, 0x61, 0x38, 0x33, 0x34, 0x64, 0x61, 0x66, 0x32, 0x62, 0x63, 0x32, 0x64, 0x35, 0x61, 0x32, 0x37, 0x66, 0x35, 0x31, 0x64, 0x33, 0x32, 0x37, 0x32, 0x66, 0x38, 0x36, 0x64, 0x37, 0x63, 0x63, 0x37, 0x30, 0x30, 0x31, 0x61, 0x63, 0x65, 0x64, 0x37, 0x35, 0x35, 0x66, 0x30, 0x37, 0x30, 0x39, 0x30, 0x61, 0x66, 0x37, 0x37, 0x36, 0x35, 0x65, 0x62, 0x32, 0x62, 0x37, 0x37, 0x65, 0x36, 0x36, 0x62, 0x35, 0x62, 0x63, 0x39, 0x35, 0x62, 0x33, 0x36, 0x61, 0x61, 0x30, 0x32, 0x38, 0x37, 0x38, 0x64, 0x38, 0x31, 0x35, 0x36, 0x63, 0x33, 0x32, 0x38, 0x39, 0x35, 0x66, 0x63, 0x66, 0x64, 0x66, 0x62, 0x61, 0x66, 0x39, 0x63, 0x36, 0x39, 0x65, 0x35, 0x34, 0x30, 0x39, 0x65, 0x34, 0x38, 0x38, 0x38, 0x34, 0x64, 0x36, 0x37, 0x37, 0x34, 0x66, 0x33, 0x32, 0x34, 0x38, 0x39, 0x62, 0x39, 0x62, 0x62, 0x64, 0x61, 0x36, 0x35, 0x66, 0x35, 0x38, 0x31, 0x65, 0x33, 0x36, 0x30, 0x31, 0x62, 0x63, 0x65, 0x35, 0x63, 0x39, 0x35, 0x30, 0x61, 0x37, 0x32, 0x37, 0x66, 0x32, 0x37, 0x36, 0x62, 0x33, 0x35, 0x36, 0x38, 0x32, 0x31, 0x66, 0x62, 0x61, 0x38, 0x63, 0x34, 0x31, 0x65, 0x63, 0x62, 0x35, 0x33, 0x36, 0x62, 0x33, 0x36, 0x62, 0x32, 0x65, 0x36, 0x33, 0x32, 0x66, 0x62, 0x62, 0x34, 0x65, 0x39, 0x39, 0x38, 0x64, 0x30, 0x31, 0x64, 0x35, 0x63, 0x31, 0x30, 0x39, 0x61, 0x31, 0x61, 0x64, 0x31, 0x64, 0x37, 0x37, 0x39, 0x32, 0x36, 0x37, 0x32, 0x63, 0x66, 0x37, 0x33, 0x31, 0x63, 0x62, 0x64, 0x61, 0x35, 0x66, 0x31, 0x33, 0x61, 0x33, 0x30, 0x66, 0x39, 0x31, 0x33, 0x65, 0x34, 0x65, 0x32, 0x64, 0x62, 0x64, 0x61, 0x35, 0x32, 0x34, 0x35, 0x64, 0x32, 0x31, 0x66, 0x30, 0x39, 0x38, 0x37, 0x38, 0x32, 0x32, 0x32, 0x61, 0x62, 0x31, 0x62, 0x63, 0x33, 0x37, 0x65, 0x66, 0x61, 0x33, 0x37, 0x33, 0x38, 0x66, 0x36, 0x35, 0x32, 0x34, 0x37, 0x31, 0x37, 0x39, 0x37, 0x65, 0x33, 0x33, 0x33, 0x65, 0x36, 0x66, 0x35, 0x33, 0x36, 0x35, 0x31, 0x65, 0x36, 0x36, 0x32, 0x33, 0x62, 0x66, 0x38, 0x62, 0x61, 0x36, 0x31, 0x61, 0x61, 0x30, 0x33, 0x66, 0x65, 0x31, 0x39, 0x30, 0x66, 0x61, 0x39, 0x36, 0x64, 0x35, 0x64, 0x31, 0x32, 0x39, 0x30, 0x38, 0x35, 0x34, 0x64, 0x64, 0x63, 0x36, 0x30, 0x62, 0x36, 0x65, 0x64, 0x33, 0x38, 0x37, 0x32, 0x31, 0x65, 0x31, 0x38, 0x34, 0x66, 0x30, 0x66, 0x62, 0x62, 0x65, 0x62, 0x63, 0x63, 0x35, 0x62, 0x66, 0x35, 0x30, 0x38, 0x37, 0x31, 0x65, 0x35, 0x61, 0x64, 0x38, 0x32, 0x36, 0x65, 0x65, 0x39, 0x66, 0x35, 0x61, 0x31, 0x39, 0x38, 0x66, 0x30, 0x37, 0x31, 0x61, 0x35, 0x37, 0x64, 0x66, 0x65, 0x32, 0x31, 0x66, 0x62, 0x38, 0x65, 0x62, 0x61, 0x32, 0x30, 0x38, 0x33, 0x65, 0x37, 0x31, 0x63, 0x39, 0x63, 0x34, 0x39, 0x64, 0x39, 0x64, 0x34, 0x65, 0x30, 0x62, 0x63, 0x61, 0x32, 0x36, 0x38, 0x38, 0x32, 0x65, 0x64, 0x33, 0x63, 0x32, 0x62, 0x32, 0x62, 0x37, 0x35, 0x37, 0x36, 0x39, 0x36, 0x63, 0x30, 0x37, 0x61, 0x31, 0x36, 0x62, 0x37, 0x33, 0x34, 0x32, 0x62, 0x64, 0x38, 0x62, 0x33, 0x62, 0x31, 0x31, 0x65, 0x31, 0x30, 0x64, 0x33, 0x33, 0x39, 0x65, 0x63, 0x65, 0x38, 0x32, 0x33, 0x36, 0x37, 0x63, 0x37, 0x31, 0x61, 0x30, 0x66, 0x63, 0x32, 0x35, 0x35, 0x64, 0x65, 0x65, 0x37, 0x36, 0x34, 0x61, 0x35, 0x34, 0x35, 0x37, 0x63, 0x64, 0x35, 0x33, 0x34, 0x64, 0x34, 0x33, 0x30, 0x39, 0x30, 0x63, 0x38, 0x37, 0x37, 0x35, 0x30, 0x65, 0x61, 0x64, 0x33, 0x34, 0x32, 0x31, 0x31, 0x64, 0x32, 0x64, 0x34, 0x37, 0x66, 0x63, 0x38, 0x34, 0x64, 0x63, 0x32, 0x63, 0x66, 0x37, 0x32, 0x30, 0x37, 0x63, 0x66, 0x66, 0x63, 0x37, 0x37, 0x62, 0x30, 0x65, 0x38, 0x39, 0x30, 0x38, 0x30, 0x33, 0x65, 0x31, 0x63, 0x64, 0x32, 0x36, 0x62, 0x66, 0x32, 0x30, 0x61, 0x30, 0x66, 0x32, 0x64, 0x32, 0x32, 0x61, 0x63, 0x65, 0x66, 0x37, 0x36, 0x34, 0x36, 0x62, 0x35, 0x66, 0x39, 0x62, 0x66, 0x30, 0x39, 0x30, 0x63, 0x34, 0x62, 0x64, 0x36, 0x64, 0x31, 0x35, 0x64, 0x36, 0x63, 0x37, 0x32, 0x64, 0x61, 0x31, 0x34, 0x39, 0x33, 0x38, 0x62, 0x36, 0x61, 0x37, 0x62, 0x36, 0x33, 0x38, 0x31, 0x38, 0x66, 0x32, 0x61, 0x31, 0x37, 0x33, 0x65, 0x36, 0x37, 0x39, 0x61, 0x35, 0x36, 0x32, 0x34, 0x64, 0x35, 0x36, 0x35, 0x38, 0x38, 0x65, 0x36, 0x61, 0x62, 0x35, 0x65, 0x36, 0x30, 0x38, 0x65, 0x39, 0x63, 0x39, 0x33, 0x31, 0x63, 0x66, 0x33, 0x36, 0x33, 0x34, 0x33, 0x66, 0x32, 0x36, 0x61, 0x63, 0x30, 0x36, 0x63, 0x34, 0x63, 0x36, 0x61, 0x38, 0x64, 0x31, 0x38, 0x30, 0x33, 0x39, 0x63, 0x36, 0x39, 0x63, 0x32, 0x30, 0x64, 0x34, 0x61, 0x63, 0x37, 0x32, 0x65, 0x34, 0x38, 0x38, 0x31, 0x35, 0x31, 0x32, 0x65, 0x61, 0x31, 0x61, 0x66, 0x61, 0x62, 0x39, 0x64, 0x33, 0x36, 0x30, 0x31, 0x62, 0x36, 0x36, 0x63, 0x35, 0x63, 0x31, 0x34, 0x31, 0x31, 0x36, 0x66, 0x34, 0x30, 0x31, 0x37, 0x34, 0x39, 0x64, 0x66, 0x37, 0x37, 0x61, 0x39, 0x35, 0x35, 0x31, 0x63, 0x37, 0x30, 0x62, 0x34, 0x62, 0x64, 0x39, 0x64, 0x65, 0x33, 0x38, 0x62, 0x37, 0x35, 0x31, 0x30, 0x33, 0x30, 0x65, 0x62, 0x37, 0x65, 0x62, 0x61, 0x63, 0x65, 0x30, 0x31, 0x61, 0x33, 0x30, 0x34, 0x64, 0x66, 0x39, 0x32, 0x65, 0x37, 0x38, 0x33, 0x39, 0x37, 0x65, 0x32, 0x63, 0x61, 0x63, 0x63, 0x34, 0x33, 0x36, 0x38, 0x66, 0x35, 0x62, 0x32, 0x62, 0x66, 0x33, 0x38, 0x32, 0x37, 0x61, 0x35, 0x36, 0x39, 0x62, 0x33, 0x65, 0x66, 0x30, 0x37, 0x63, 0x35, 0x66, 0x66, 0x65, 0x31, 0x33, 0x39, 0x36, 0x64, 0x37, 0x65, 0x39, 0x66, 0x62, 0x64, 0x63, 0x61, 0x30, 0x62, 0x38, 0x34, 0x31, 0x35, 0x37, 0x30, 0x64, 0x33, 0x30, 0x32, 0x63, 0x30, 0x35, 0x63, 0x31, 0x34, 0x32, 0x62, 0x64, 0x31, 0x66, 0x63, 0x37, 0x32, 0x63, 0x37, 0x35, 0x39, 0x66, 0x63, 0x64, 0x64, 0x64, 0x37, 0x36, 0x37, 0x63, 0x32, 0x36, 0x33, 0x61, 0x61, 0x37, 0x39, 0x33, 0x38, 0x34, 0x61, 0x37, 0x63, 0x65, 0x36, 0x36, 0x34, 0x63, 0x33, 0x63, 0x33, 0x31, 0x39, 0x34, 0x32, 0x66, 0x66, 0x39, 0x36, 0x34, 0x35, 0x39, 0x33, 0x37, 0x64, 0x35, 0x34, 0x65, 0x63, 0x38, 0x65, 0x37, 0x65, 0x66, 0x62, 0x36, 0x31, 0x34, 0x31, 0x30, 0x63, 0x37, 0x39, 0x66, 0x37, 0x65, 0x62, 0x36, 0x34, 0x30, 0x61, 0x62, 0x36, 0x37, 0x66, 0x39, 0x62, 0x33, 0x33, 0x37, 0x35, 0x35, 0x65, 0x36, 0x61, 0x66, 0x35, 0x65, 0x36, 0x66, 0x38, 0x64, 0x32, 0x39, 0x30, 0x30, 0x66, 0x65, 0x30, 0x38, 0x63, 0x31, 0x36, 0x64, 0x38, 0x38, 0x35, 0x66, 0x31, 0x36, 0x32, 0x64, 0x61, 0x62, 0x61, 0x36, 0x30, 0x39, 0x38, 0x34, 0x32, 0x65, 0x39, 0x34, 0x37, 0x37, 0x36, 0x63, 0x30, 0x38, 0x32, 0x32, 0x65, 0x35, 0x30, 0x33, 0x35, 0x31, 0x34, 0x35, 0x66, 0x62, 0x30, 0x30, 0x32, 0x36, 0x64, 0x64, 0x62, 0x37, 0x61, 0x31, 0x35, 0x30, 0x38, 0x32, 0x63, 0x35, 0x66, 0x64, 0x66, 0x63, 0x65, 0x65, 0x31, 0x39, 0x64, 0x32, 0x34, 0x62, 0x62, 0x32, 0x32, 0x30, 0x37, 0x30, 0x34, 0x61, 0x35, 0x64, 0x64, 0x31, 0x33, 0x36, 0x61, 0x65, 0x61, 0x37, 0x32, 0x33, 0x37, 0x65, 0x33, 0x66, 0x63, 0x64, 0x63, 0x37, 0x33, 0x63, 0x30, 0x30, 0x63, 0x65, 0x61, 0x65, 0x62, 0x37, 0x65, 0x31, 0x33, 0x33, 0x37, 0x35, 0x30, 0x33, 0x33, 0x66, 0x36, 0x33, 0x62, 0x38, 0x63, 0x32, 0x38, 0x62, 0x61, 0x66, 0x34, 0x36, 0x33, 0x64, 0x32, 0x65, 0x38, 0x65, 0x35, 0x34, 0x65, 0x38, 0x30, 0x39, 0x65, 0x64, 0x37, 0x62, 0x32, 0x34, 0x61, 0x64, 0x32, 0x37, 0x32, 0x38, 0x61, 0x34, 0x38, 0x36, 0x64, 0x34, 0x36, 0x30, 0x31, 0x64, 0x32, 0x63, 0x30, 0x34, 0x34, 0x64, 0x34, 0x31, 0x38, 0x38, 0x66, 0x62, 0x61, 0x38, 0x63, 0x66, 0x32, 0x63, 0x61, 0x31, 0x63, 0x32, 0x31, 0x62, 0x33, 0x33, 0x32, 0x38, 0x39, 0x65, 0x63, 0x30, 0x37, 0x37, 0x30, 0x65, 0x30, 0x66, 0x34, 0x66, 0x63, 0x65, 0x32, 0x35, 0x61, 0x66, 0x30, 0x66, 0x35, 0x66, 0x62, 0x37, 0x32, 0x36, 0x36, 0x39, 0x61, 0x35, 0x35, 0x63, 0x37, 0x37, 0x36, 0x36, 0x38, 0x62, 0x63, 0x30, 0x33, 0x61, 0x31, 0x36, 0x62, 0x38, 0x30, 0x63, 0x37, 0x31, 0x38, 0x63, 0x35, 0x66, 0x62, 0x38, 0x66, 0x64, 0x61, 0x61, 0x35, 0x39, 0x62, 0x38, 0x61, 0x64, 0x65, 0x61, 0x63, 0x65, 0x33, 0x61, 0x37, 0x32, 0x63, 0x65, 0x61, 0x39, 0x30, 0x35, 0x61, 0x65, 0x61, 0x30, 0x39, 0x39, 0x63, 0x36, 0x32, 0x33, 0x62, 0x36, 0x30, 0x37, 0x34, 0x33, 0x35, 0x62, 0x35, 0x63, 0x63, 0x33, 0x36, 0x34, 0x63, 0x35, 0x63, 0x63, 0x63, 0x65, 0x37, 0x35, 0x64, 0x36, 0x36, 0x37, 0x65, 0x61, 0x30, 0x34, 0x62, 0x64, 0x63, 0x34, 0x61, 0x34, 0x61, 0x64, 0x63, 0x33, 0x35, 0x61, 0x63, 0x62, 0x31, 0x38, 0x65, 0x64, 0x30, 0x39, 0x39, 0x63, 0x61, 0x38, 0x34, 0x38, 0x63, 0x30, 0x63, 0x36, 0x37, 0x37, 0x32, 0x61, 0x34, 0x66, 0x66, 0x35, 0x39, 0x36, 0x64, 0x34, 0x33, 0x32, 0x30, 0x61, 0x35, 0x30, 0x61, 0x35, 0x34, 0x35, 0x62, 0x36, 0x64, 0x65, 0x39, 0x33, 0x65, 0x66, 0x62, 0x64, 0x38, 0x36, 0x64, 0x66, 0x36, 0x38, 0x33, 0x30, 0x65, 0x30, 0x36, 0x66, 0x61, 0x63, 0x34, 0x37, 0x61, 0x63, 0x39, 0x35, 0x35, 0x35, 0x35, 0x64, 0x65, 0x61, 0x61, 0x34, 0x64, 0x32, 0x61, 0x33, 0x36, 0x37, 0x32, 0x34, 0x36, 0x35, 0x61, 0x36, 0x63, 0x64, 0x65, 0x38, 0x62, 0x64, 0x63, 0x65, 0x62, 0x64, 0x39, 0x36, 0x32, 0x31, 0x64, 0x36, 0x36, 0x64, 0x33, 0x39, 0x61, 0x65, 0x63, 0x65, 0x62, 0x30, 0x33, 0x32, 0x61, 0x61, 0x65, 0x37, 0x39, 0x30, 0x30, 0x65, 0x66, 0x32, 0x35, 0x36, 0x63, 0x35, 0x66, 0x64, 0x63, 0x64, 0x63, 0x32, 0x66, 0x34, 0x37, 0x64, 0x62, 0x31, 0x32, 0x61, 0x30, 0x37, 0x32, 0x32, 0x37, 0x30, 0x65, 0x39, 0x66, 0x65, 0x31, 0x33, 0x37, 0x36, 0x38, 0x30, 0x64, 0x33, 0x30, 0x31, 0x36, 0x62, 0x65, 0x33, 0x65, 0x61, 0x35, 0x30, 0x35, 0x33, 0x32, 0x37, 0x63, 0x31, 0x65, 0x31, 0x62, 0x64, 0x30, 0x39, 0x34, 0x31, 0x34, 0x32, 0x35, 0x62, 0x65, 0x61, 0x31, 0x62, 0x66, 0x31, 0x63, 0x35, 0x63, 0x66, 0x37, 0x32, 0x36, 0x34, 0x38, 0x38, 0x37, 0x30, 0x61, 0x37, 0x32, 0x64, 0x32, 0x31, 0x33, 0x64, 0x39, 0x39, 0x63, 0x65, 0x31, 0x34, 0x36, 0x31, 0x63, 0x31, 0x64, 0x62, 0x35, 0x39, 0x61, 0x32, 0x35, 0x33, 0x65, 0x65, 0x38, 0x62, 0x36, 0x39, 0x32, 0x30, 0x35, 0x36, 0x30, 0x65, 0x61, 0x39, 0x62, 0x37, 0x65, 0x61, 0x35, 0x61, 0x62, 0x31, 0x36, 0x37, 0x30, 0x30, 0x37, 0x38, 0x63, 0x62, 0x61, 0x32, 0x62, 0x37, 0x35, 0x63, 0x35, 0x34, 0x64, 0x33, 0x30, 0x39, 0x62, 0x34, 0x31, 0x61, 0x38, 0x35, 0x30, 0x61, 0x65, 0x34, 0x39, 0x32, 0x66, 0x66, 0x33, 0x63, 0x39, 0x35, 0x63, 0x32, 0x37, 0x35, 0x38, 0x34, 0x37, 0x34, 0x64, 0x35, 0x64, 0x39, 0x61, 0x35, 0x34, 0x65, 0x30, 0x35, 0x39, 0x38, 0x37, 0x66, 0x65, 0x62, 0x65, 0x33, 0x31, 0x31, 0x31, 0x38, 0x36, 0x33, 0x37, 0x65, 0x65, 0x38, 0x65, 0x66, 0x35, 0x66, 0x31, 0x64, 0x39, 0x37, 0x32, 0x36, 0x33, 0x36, 0x63, 0x65, 0x63, 0x62, 0x65, 0x63, 0x66, 0x39, 0x63, 0x34, 0x38, 0x66, 0x66, 0x39, 0x39, 0x34, 0x37, 0x33, 0x66, 0x62, 0x38, 0x37, 0x37, 0x33, 0x63, 0x31, 0x36, 0x32, 0x63, 0x32, 0x61, 0x32, 0x39, 0x30, 0x37, 0x64, 0x62, 0x62, 0x62, 0x35, 0x63, 0x62, 0x34, 0x35, 0x39, 0x38, 0x37, 0x38, 0x65, 0x63, 0x38, 0x31, 0x65, 0x32, 0x33, 0x36, 0x37, 0x33, 0x36, 0x37, 0x32, 0x64, 0x66, 0x34, 0x66, 0x66, 0x35, 0x38, 0x37, 0x34, 0x31, 0x61, 0x64, 0x35, 0x35, 0x38, 0x33, 0x32, 0x63, 0x35, 0x61, 0x34, 0x37, 0x37, 0x33, 0x35, 0x66, 0x34, 0x35, 0x62, 0x61, 0x38, 0x38, 0x63, 0x37, 0x65, 0x39, 0x34, 0x64, 0x39, 0x61, 0x61, 0x36, 0x37, 0x35, 0x62, 0x34, 0x63, 0x37, 0x34, 0x31, 0x32, 0x38, 0x31, 0x39, 0x38, 0x37, 0x38, 0x37, 0x33, 0x30, 0x62, 0x62, 0x34, 0x33, 0x31, 0x31, 0x32, 0x36, 0x36, 0x39, 0x34, 0x33, 0x39, 0x63, 0x39, 0x37, 0x34, 0x63, 0x30, 0x37, 0x35, 0x61, 0x61, 0x36, 0x32, 0x38, 0x31, 0x33, 0x63, 0x32, 0x39, 0x65, 0x66, 0x64, 0x63, 0x39, 0x62, 0x64, 0x61, 0x30, 0x63, 0x37, 0x33, 0x33, 0x32, 0x39, 0x62, 0x61, 0x31, 0x63, 0x32, 0x37, 0x31, 0x30, 0x32, 0x35, 0x39, 0x32, 0x30, 0x63, 0x36, 0x31, 0x31, 0x30, 0x35, 0x38, 0x37, 0x32, 0x65, 0x38, 0x63, 0x64, 0x65, 0x33, 0x37, 0x31, 0x38, 0x64, 0x64, 0x30, 0x62, 0x37, 0x61, 0x37, 0x38, 0x62, 0x62, 0x35, 0x31, 0x37, 0x37, 0x33, 0x63, 0x36, 0x37, 0x61, 0x66, 0x37, 0x34, 0x65, 0x30, 0x61, 0x33, 0x30, 0x34, 0x32, 0x35, 0x32, 0x38, 0x65, 0x63, 0x35, 0x30, 0x34, 0x34, 0x32, 0x35, 0x38, 0x37, 0x30, 0x30, 0x62, 0x64, 0x34, 0x39, 0x30, 0x36, 0x31, 0x64, 0x33, 0x32, 0x63, 0x32, 0x63, 0x62, 0x61, 0x30, 0x61, 0x66, 0x31, 0x62, 0x37, 0x37, 0x37, 0x31, 0x37, 0x38, 0x31, 0x65, 0x61, 0x35, 0x35, 0x30, 0x30, 0x37, 0x35, 0x37, 0x31, 0x36, 0x37, 0x34, 0x31, 0x38, 0x31, 0x35, 0x66, 0x36, 0x37, 0x65, 0x64, 0x30, 0x65, 0x62, 0x64, 0x34, 0x35, 0x33, 0x32, 0x61, 0x65, 0x33, 0x36, 0x36, 0x32, 0x33, 0x66, 0x32, 0x36, 0x31, 0x33, 0x61, 0x64, 0x36, 0x30, 0x37, 0x32, 0x30, 0x31, 0x64, 0x36, 0x65, 0x38, 0x31, 0x35, 0x35, 0x66, 0x30, 0x66, 0x38, 0x34, 0x34, 0x33, 0x32, 0x66, 0x35, 0x66, 0x63, 0x34, 0x38, 0x31, 0x31, 0x65, 0x39, 0x38, 0x63, 0x61, 0x62, 0x36, 0x30, 0x33, 0x63, 0x34, 0x30, 0x62, 0x63, 0x65, 0x62, 0x36, 0x30, 0x39, 0x31, 0x61, 0x62, 0x64, 0x66, 0x65, 0x36, 0x62, 0x38, 0x63, 0x33, 0x31, 0x33, 0x66, 0x38, 0x65, 0x63, 0x38, 0x35, 0x66, 0x61, 0x31, 0x36, 0x62, 0x65, 0x36, 0x36, 0x61, 0x63, 0x39, 0x37, 0x31, 0x37, 0x37, 0x63, 0x37, 0x33, 0x34, 0x64, 0x35, 0x65, 0x37, 0x65, 0x30, 0x38, 0x66, 0x66, 0x33, 0x66, 0x35, 0x34, 0x61, 0x39, 0x37, 0x30, 0x61, 0x34, 0x39, 0x35, 0x30, 0x35, 0x64, 0x36, 0x36, 0x38, 0x39, 0x36, 0x33, 0x32, 0x62, 0x65, 0x66, 0x36, 0x65, 0x39, 0x32, 0x61, 0x32, 0x31, 0x34, 0x39, 0x61, 0x30, 0x65, 0x65, 0x63, 0x32, 0x38, 0x34, 0x30, 0x30, 0x65, 0x37, 0x39, 0x64, 0x65, 0x33, 0x33, 0x31, 0x39, 0x33, 0x64, 0x32, 0x61, 0x39, 0x62, 0x65, 0x31, 0x37, 0x33, 0x36, 0x65, 0x39, 0x30, 0x34, 0x39, 0x35, 0x31, 0x37, 0x39, 0x30, 0x38, 0x35, 0x30, 0x36, 0x33, 0x35, 0x34, 0x39, 0x32, 0x36, 0x30, 0x39, 0x62, 0x39, 0x33, 0x36, 0x66, 0x30, 0x37, 0x36, 0x30, 0x63, 0x36, 0x61, 0x62, 0x37, 0x32, 0x39, 0x33, 0x61, 0x66, 0x39, 0x38, 0x62, 0x65, 0x35, 0x37, 0x34, 0x39, 0x34, 0x36, 0x61, 0x35, 0x61, 0x31, 0x32, 0x38, 0x35, 0x35, 0x61, 0x30, 0x31, 0x38, 0x31, 0x36, 0x61, 0x39, 0x30, 0x66, 0x31, 0x36, 0x32, 0x32, 0x30, 0x30, 0x65, 0x38, 0x30, 0x63, 0x34, 0x34, 0x65, 0x64, 0x65, 0x36, 0x34, 0x34, 0x33, 0x64, 0x62, 0x33, 0x33, 0x63, 0x34, 0x61, 0x33, 0x66, 0x66, 0x64, 0x37, 0x32, 0x62, 0x63, 0x61, 0x37, 0x61, 0x34, 0x63, 0x39, 0x38, 0x35, 0x33, 0x31, 0x37, 0x38, 0x37, 0x30, 0x65, 0x32, 0x32, 0x61, 0x35, 0x65, 0x33, 0x64, 0x34, 0x62, 0x39, 0x65, 0x32, 0x39, 0x39, 0x37, 0x65, 0x30, 0x38, 0x33, 0x30, 0x31, 0x34, 0x34, 0x36, 0x61, 0x39, 0x33, 0x34, 0x64, 0x35, 0x39, 0x62, 0x61, 0x61, 0x63, 0x62, 0x61, 0x32, 0x33, 0x61, 0x66, 0x34, 0x34, 0x66, 0x34, 0x37, 0x32, 0x62, 0x34, 0x32, 0x37, 0x37, 0x34, 0x65, 0x39, 0x61, 0x61, 0x32, 0x63, 0x32, 0x33, 0x61, 0x61, 0x62, 0x63, 0x39, 0x36, 0x64, 0x63, 0x36, 0x62, 0x39, 0x63, 0x32, 0x38, 0x39, 0x39, 0x36, 0x38, 0x37, 0x34, 0x64, 0x36, 0x65, 0x39, 0x34, 0x32, 0x62, 0x30, 0x38, 0x66, 0x62, 0x33, 0x32, 0x36, 0x33, 0x61, 0x32, 0x61, 0x32, 0x32, 0x33, 0x61, 0x36, 0x31, 0x66, 0x30, 0x36, 0x33, 0x37, 0x32, 0x30, 0x34, 0x64, 0x61, 0x38, 0x34, 0x32, 0x66, 0x63, 0x31, 0x36, 0x33, 0x62, 0x36, 0x39, 0x65, 0x63, 0x30, 0x36, 0x33, 0x63, 0x35, 0x64, 0x30, 0x37, 0x33, 0x39, 0x30, 0x34, 0x36, 0x31, 0x63, 0x38, 0x30, 0x64, 0x30, 0x63, 0x35, 0x35, 0x63, 0x32, 0x66, 0x63, 0x34, 0x35, 0x33, 0x63, 0x61, 0x35, 0x65, 0x65, 0x37, 0x34, 0x32, 0x35, 0x33, 0x65, 0x66, 0x32, 0x36, 0x63, 0x63, 0x37, 0x32, 0x66, 0x37, 0x64, 0x33, 0x39, 0x65, 0x66, 0x32, 0x66, 0x64, 0x38, 0x37, 0x31, 0x61, 0x65, 0x64, 0x30, 0x39, 0x38, 0x35, 0x39, 0x63, 0x36, 0x66, 0x62, 0x65, 0x61, 0x38, 0x36, 0x64, 0x37, 0x63, 0x61, 0x65, 0x36, 0x35, 0x36, 0x64, 0x35, 0x34, 0x39, 0x65, 0x31, 0x33, 0x62, 0x65, 0x64, 0x38, 0x30, 0x32, 0x62, 0x39, 0x62, 0x32, 0x35, 0x32, 0x62, 0x32, 0x65, 0x62, 0x36, 0x66, 0x30, 0x61, 0x32, 0x34, 0x38, 0x38, 0x64, 0x30, 0x33, 0x66, 0x62, 0x63, 0x37, 0x39, 0x35, 0x36, 0x61, 0x61, 0x37, 0x30, 0x36, 0x32, 0x66, 0x37, 0x37, 0x30, 0x63, 0x36, 0x39, 0x39, 0x39, 0x37, 0x31, 0x61, 0x39, 0x39, 0x31, 0x30, 0x37, 0x63, 0x39, 0x66, 0x36, 0x64, 0x62, 0x61, 0x38, 0x37, 0x61, 0x65, 0x33, 0x33, 0x34, 0x64, 0x32, 0x62, 0x66, 0x31, 0x36, 0x61, 0x30, 0x35, 0x37, 0x30, 0x33, 0x35, 0x34, 0x37, 0x35, 0x64, 0x32, 0x38, 0x36, 0x36, 0x30, 0x36, 0x37, 0x31, 0x36, 0x32, 0x30, 0x62, 0x38, 0x32, 0x66, 0x39, 0x32, 0x31, 0x62, 0x61, 0x32, 0x37, 0x33, 0x66, 0x39, 0x37, 0x33, 0x64, 0x34, 0x35, 0x63, 0x61, 0x37, 0x35, 0x37, 0x30, 0x37, 0x38, 0x36, 0x37, 0x36, 0x33, 0x30, 0x64, 0x61, 0x39, 0x34, 0x39, 0x31, 0x64, 0x30, 0x62, 0x30, 0x61, 0x39, 0x65, 0x33, 0x61, 0x31, 0x39, 0x35, 0x39, 0x34, 0x33, 0x32, 0x64, 0x34, 0x34, 0x37, 0x34, 0x32, 0x36, 0x35, 0x30, 0x36, 0x35, 0x63, 0x65, 0x34, 0x35, 0x34, 0x64, 0x34, 0x64, 0x39, 0x66, 0x32, 0x38, 0x35, 0x62, 0x64, 0x64, 0x31, 0x32, 0x64, 0x39, 0x38, 0x63, 0x32, 0x35, 0x38, 0x62, 0x62, 0x31, 0x37, 0x61, 0x33, 0x37, 0x35, 0x34, 0x65, 0x30, 0x32, 0x38, 0x62, 0x38, 0x30, 0x61, 0x34, 0x32, 0x37, 0x36, 0x37, 0x32, 0x32, 0x62, 0x34, 0x35, 0x65, 0x34, 0x35, 0x36, 0x35, 0x34, 0x66, 0x32, 0x31, 0x64, 0x64, 0x36, 0x38, 0x34, 0x37, 0x39, 0x37, 0x36, 0x64, 0x39, 0x62, 0x34, 0x63, 0x39, 0x66, 0x64, 0x62, 0x35, 0x38, 0x39, 0x63, 0x33, 0x34, 0x66, 0x38, 0x33, 0x34, 0x32, 0x36, 0x61, 0x31, 0x35, 0x39, 0x32, 0x32, 0x30, 0x31, 0x33, 0x63, 0x66, 0x61, 0x63, 0x32, 0x34, 0x64, 0x37, 0x65, 0x39, 0x37, 0x32, 0x65, 0x31, 0x62, 0x38, 0x37, 0x38, 0x39, 0x35, 0x66, 0x66, 0x63, 0x61, 0x64, 0x63, 0x37, 0x36, 0x36, 0x64, 0x36, 0x36, 0x65, 0x34, 0x64, 0x39, 0x33, 0x39, 0x39, 0x61, 0x66, 0x31, 0x37, 0x36, 0x61, 0x37, 0x34, 0x37, 0x63, 0x37, 0x65, 0x32, 0x31, 0x36, 0x66, 0x63, 0x34, 0x36, 0x31, 0x31, 0x32, 0x62, 0x38, 0x31, 0x35, 0x30, 0x34, 0x38, 0x37, 0x34, 0x66, 0x63, 0x30, 0x38, 0x36, 0x66, 0x33, 0x64, 0x32, 0x63, 0x35, 0x36, 0x36, 0x37, 0x37, 0x62, 0x30, 0x65, 0x30, 0x62, 0x63, 0x64, 0x38, 0x37, 0x63, 0x35, 0x34, 0x65, 0x31, 0x65, 0x64, 0x32, 0x30, 0x61, 0x33, 0x64, 0x64, 0x39, 0x39, 0x39, 0x64, 0x30, 0x38, 0x62, 0x63, 0x39, 0x31, 0x61, 0x36, 0x63, 0x34, 0x34, 0x65, 0x38, 0x34, 0x66, 0x31, 0x30, 0x32, 0x35, 0x34, 0x30, 0x36, 0x61, 0x33, 0x30, 0x32, 0x64, 0x37, 0x32, 0x34, 0x62, 0x65, 0x66, 0x61, 0x63, 0x38, 0x35, 0x62, 0x34, 0x33, 0x65, 0x35, 0x31, 0x35, 0x36, 0x30, 0x36, 0x66, 0x66, 0x36, 0x65, 0x35, 0x32, 0x63, 0x33, 0x36, 0x62, 0x39, 0x34, 0x64, 0x33, 0x35, 0x32, 0x62, 0x37, 0x64, 0x65, 0x34, 0x35, 0x65, 0x66, 0x32, 0x33, 0x64, 0x64, 0x62, 0x65, 0x30, 0x37, 0x63, 0x35, 0x64, 0x34, 0x31, 0x64, 0x62, 0x32, 0x64, 0x37, 0x39, 0x33, 0x36, 0x33, 0x34, 0x64, 0x39, 0x62, 0x38, 0x36, 0x30, 0x37, 0x36, 0x31, 0x65, 0x30, 0x30, 0x34, 0x35, 0x39, 0x64, 0x39, 0x36, 0x63, 0x62, 0x37, 0x30, 0x62, 0x39, 0x39, 0x38, 0x31, 0x33, 0x36, 0x38, 0x31, 0x37, 0x31, 0x30, 0x37, 0x32, 0x65, 0x39, 0x34, 0x35, 0x64, 0x64, 0x66, 0x31, 0x32, 0x35, 0x35, 0x31, 0x66, 0x34, 0x35, 0x66, 0x63, 0x61, 0x35, 0x34, 0x65, 0x65, 0x39, 0x63, 0x62, 0x37, 0x32, 0x65, 0x62, 0x36, 0x65, 0x35, 0x34, 0x30, 0x65, 0x62, 0x39, 0x30, 0x66, 0x34, 0x65, 0x30, 0x38, 0x32, 0x32, 0x31, 0x61, 0x35, 0x31, 0x64, 0x61, 0x31, 0x37, 0x35, 0x32, 0x38, 0x33, 0x34, 0x39, 0x38, 0x66, 0x38, 0x65, 0x64, 0x33, 0x37, 0x34, 0x34, 0x31, 0x39, 0x62, 0x39, 0x30, 0x35, 0x32, 0x33, 0x38, 0x62, 0x34, 0x39, 0x65, 0x34, 0x65, 0x30, 0x64, 0x39, 0x34, 0x36, 0x65, 0x37, 0x32, 0x61, 0x64, 0x33, 0x31, 0x65, 0x65, 0x35, 0x34, 0x62, 0x34, 0x63, 0x39, 0x30, 0x36, 0x39, 0x61, 0x63, 0x65, 0x61, 0x35, 0x66, 0x66, 0x63, 0x39, 0x39, 0x30, 0x38, 0x35, 0x31, 0x65, 0x34, 0x30, 0x31, 0x35, 0x30, 0x66, 0x34, 0x36, 0x66, 0x34, 0x37, 0x39, 0x33, 0x39, 0x32, 0x34, 0x65, 0x37, 0x37, 0x61, 0x30, 0x63, 0x62, 0x35, 0x38, 0x62, 0x34, 0x66, 0x64, 0x62, 0x36, 0x39, 0x35, 0x30, 0x62, 0x62, 0x33, 0x37, 0x37, 0x34, 0x32, 0x64, 0x65, 0x33, 0x32, 0x63, 0x33, 0x65, 0x32, 0x34, 0x30, 0x31, 0x34, 0x36, 0x37, 0x65, 0x32, 0x39, 0x35, 0x31, 0x33, 0x61, 0x32, 0x65, 0x61, 0x31, 0x37, 0x34, 0x31, 0x63, 0x64, 0x31, 0x31, 0x32, 0x38, 0x64, 0x34, 0x31, 0x64, 0x33, 0x61, 0x38, 0x31, 0x35, 0x31, 0x32, 0x38, 0x65, 0x34, 0x61, 0x65, 0x30, 0x62, 0x33, 0x30, 0x65, 0x37, 0x32, 0x36, 0x32, 0x36, 0x36, 0x38, 0x61, 0x39, 0x36, 0x66, 0x65, 0x32, 0x37, 0x35, 0x36, 0x65, 0x65, 0x36, 0x32, 0x39, 0x33, 0x34, 0x33, 0x36, 0x36, 0x39, 0x30, 0x64, 0x32, 0x63, 0x39, 0x64, 0x38, 0x37, 0x64, 0x65, 0x63, 0x61, 0x30, 0x62, 0x36, 0x36, 0x61, 0x65, 0x64, 0x62, 0x30, 0x38, 0x33, 0x33, 0x38, 0x38, 0x66, 0x39, 0x31, 0x35, 0x39, 0x37, 0x35, 0x31, 0x61, 0x31, 0x61, 0x37, 0x32, 0x63, 0x34, 0x37, 0x34, 0x38, 0x63, 0x31, 0x34, 0x35, 0x30, 0x65, 0x38, 0x65, 0x33, 0x32, 0x65, 0x66, 0x33, 0x38, 0x32, 0x66, 0x30, 0x34, 0x33, 0x33, 0x61, 0x36, 0x30, 0x37, 0x63, 0x31, 0x65, 0x33, 0x64, 0x36, 0x39, 0x63, 0x35, 0x34, 0x32, 0x64, 0x37, 0x37, 0x31, 0x61, 0x63, 0x64, 0x63, 0x37, 0x34, 0x34, 0x65, 0x39, 0x32, 0x64, 0x35, 0x64, 0x39, 0x34, 0x38, 0x34, 0x66, 0x30, 0x31, 0x63, 0x62, 0x64, 0x66, 0x31, 0x61, 0x37, 0x62, 0x38, 0x32, 0x34, 0x38, 0x66, 0x34, 0x36, 0x34, 0x33, 0x62, 0x65, 0x37, 0x63, 0x38, 0x32, 0x61, 0x62, 0x63, 0x65, 0x34, 0x35, 0x31, 0x36, 0x35, 0x38, 0x39, 0x39, 0x64, 0x37, 0x30, 0x66, 0x32, 0x37, 0x37, 0x62, 0x30, 0x38, 0x34, 0x35, 0x39, 0x61, 0x37, 0x38, 0x34, 0x32, 0x30, 0x38, 0x33, 0x61, 0x38, 0x63, 0x32, 0x38, 0x34, 0x37, 0x32, 0x39, 0x65, 0x65, 0x37, 0x38, 0x33, 0x33, 0x38, 0x39, 0x33, 0x31, 0x39, 0x64, 0x62, 0x61, 0x65, 0x37, 0x36, 0x38, 0x30, 0x36, 0x66, 0x63, 0x62, 0x36, 0x64, 0x62, 0x65, 0x36, 0x39, 0x62, 0x36, 0x31, 0x38, 0x30, 0x39, 0x62, 0x35, 0x36, 0x33, 0x66, 0x36, 0x30, 0x65, 0x64, 0x66, 0x35, 0x64, 0x62, 0x64, 0x31, 0x66, 0x38, 0x33, 0x65, 0x30, 0x35, 0x39, 0x61, 0x62, 0x33, 0x64, 0x34, 0x32, 0x66, 0x33, 0x66, 0x37, 0x34, 0x37, 0x32, 0x36, 0x38, 0x34, 0x31, 0x61, 0x62, 0x65, 0x30, 0x35, 0x35, 0x39, 0x32, 0x36, 0x66, 0x34, 0x38, 0x33, 0x64, 0x37, 0x63, 0x36, 0x63, 0x65, 0x39, 0x30, 0x31, 0x65, 0x66, 0x36, 0x37, 0x32, 0x38, 0x33, 0x39, 0x66, 0x32, 0x30, 0x65, 0x36, 0x62, 0x63, 0x35, 0x35, 0x33, 0x64, 0x66, 0x30, 0x65, 0x64, 0x37, 0x39, 0x63, 0x30, 0x64, 0x30, 0x37, 0x32, 0x62, 0x66, 0x38, 0x31, 0x30, 0x32, 0x35, 0x61, 0x64, 0x35, 0x66, 0x66, 0x61, 0x35, 0x33, 0x37, 0x63, 0x36, 0x33, 0x36, 0x33, 0x64, 0x62, 0x30, 0x34, 0x61, 0x31, 0x30, 0x36, 0x64, 0x66, 0x61, 0x30, 0x31, 0x61, 0x34, 0x62, 0x30, 0x39, 0x35, 0x31, 0x62, 0x32, 0x39, 0x36, 0x62, 0x35, 0x63, 0x65, 0x61, 0x63, 0x61, 0x66, 0x31, 0x30, 0x33, 0x34, 0x65, 0x33, 0x32, 0x33, 0x65, 0x30, 0x30, 0x64, 0x35, 0x33, 0x64, 0x35, 0x38, 0x30, 0x32, 0x64, 0x33, 0x32, 0x36, 0x31, 0x30, 0x32, 0x66, 0x39, 0x35, 0x66, 0x35, 0x33, 0x62, 0x34, 0x32, 0x35, 0x37, 0x34, 0x33, 0x36, 0x63, 0x35, 0x61, 0x37, 0x36, 0x61, 0x61, 0x63, 0x61, 0x61, 0x34, 0x65, 0x66, 0x37, 0x30, 0x38, 0x36, 0x34, 0x35, 0x65, 0x32, 0x38, 0x32, 0x31, 0x39, 0x31, 0x63, 0x39, 0x66, 0x66, 0x30, 0x33, 0x39, 0x33, 0x39, 0x36, 0x65, 0x39, 0x33, 0x30, 0x65, 0x62, 0x65, 0x61, 0x36, 0x30, 0x33, 0x36, 0x62, 0x33, 0x63, 0x64, 0x64, 0x34, 0x62, 0x38, 0x62, 0x37, 0x30, 0x62, 0x39, 0x38, 0x64, 0x32, 0x64, 0x39, 0x65, 0x35, 0x31, 0x35, 0x38, 0x36, 0x64, 0x63, 0x61, 0x38, 0x66, 0x66, 0x34, 0x31, 0x62, 0x34, 0x61, 0x65, 0x32, 0x31, 0x34, 0x63, 0x61, 0x63, 0x37, 0x62, 0x66, 0x37, 0x63, 0x61, 0x64, 0x37, 0x32, 0x33, 0x32, 0x61, 0x32, 0x38, 0x61, 0x36, 0x30, 0x37, 0x37, 0x63, 0x66, 0x39, 0x62, 0x33, 0x37, 0x32, 0x31, 0x37, 0x65, 0x39, 0x34, 0x33, 0x62, 0x34, 0x66, 0x30, 0x32, 0x66, 0x35, 0x64, 0x64, 0x63, 0x37, 0x66, 0x38, 0x39, 0x31, 0x30, 0x36, 0x63, 0x63, 0x64, 0x38, 0x33, 0x34, 0x64, 0x39, 0x66, 0x39, 0x66, 0x64, 0x34, 0x36, 0x30, 0x34, 0x63, 0x33, 0x39, 0x64, 0x39, 0x34, 0x37, 0x32, 0x62, 0x31, 0x64, 0x66, 0x63, 0x32, 0x30, 0x37, 0x33, 0x35, 0x66, 0x62, 0x39, 0x38, 0x37, 0x62, 0x62, 0x64, 0x66, 0x38, 0x61, 0x33, 0x35, 0x39, 0x63, 0x31, 0x63, 0x36, 0x34, 0x63, 0x36, 0x64, 0x66, 0x33, 0x65, 0x66, 0x66, 0x62, 0x33, 0x63, 0x66, 0x33, 0x64, 0x36, 0x35, 0x38, 0x33, 0x66, 0x39, 0x66, 0x65, 0x62, 0x30, 0x62, 0x66, 0x37, 0x64, 0x62, 0x64, 0x30, 0x33, 0x39, 0x37, 0x32, 0x63, 0x64, 0x64, 0x34, 0x62, 0x37, 0x65, 0x30, 0x37, 0x36, 0x36, 0x36, 0x30, 0x65, 0x62, 0x61, 0x65, 0x61, 0x36, 0x30, 0x38, 0x65, 0x64, 0x63, 0x36, 0x37, 0x33, 0x36, 0x38, 0x30, 0x31, 0x35, 0x33, 0x64, 0x36, 0x31, 0x63, 0x35, 0x39, 0x36, 0x33, 0x64, 0x30, 0x37, 0x38, 0x66, 0x37, 0x61, 0x32, 0x30, 0x65, 0x37, 0x30, 0x36, 0x63, 0x39, 0x38, 0x34, 0x36, 0x35, 0x62, 0x32, 0x37, 0x32, 0x63, 0x37, 0x37, 0x31, 0x62, 0x61, 0x30, 0x37, 0x64, 0x39, 0x32, 0x32, 0x31, 0x39, 0x37, 0x66, 0x62, 0x38, 0x35, 0x36, 0x34, 0x31, 0x35, 0x30, 0x39, 0x66, 0x36, 0x65, 0x36, 0x65, 0x39, 0x66, 0x30, 0x63, 0x64, 0x66, 0x32, 0x35, 0x31, 0x31, 0x35, 0x65, 0x38, 0x63, 0x39, 0x66, 0x62, 0x36, 0x38, 0x32, 0x61, 0x33, 0x39, 0x37, 0x61, 0x62, 0x38, 0x30, 0x32, 0x31, 0x34, 0x33, 0x34, 0x38, 0x63, 0x39, 0x39, 0x62, 0x63, 0x32, 0x35, 0x34, 0x38, 0x66, 0x33, 0x32, 0x31, 0x62, 0x32, 0x35, 0x62, 0x30, 0x63, 0x62, 0x34, 0x37, 0x62, 0x37, 0x62, 0x30, 0x65, 0x31, 0x61, 0x37, 0x35, 0x66, 0x65, 0x65, 0x31, 0x66, 0x39, 0x37, 0x33, 0x64, 0x61, 0x35, 0x61, 0x39, 0x30, 0x30, 0x64, 0x31, 0x35, 0x64, 0x66, 0x39, 0x36, 0x37, 0x64, 0x30, 0x62, 0x63, 0x33, 0x34, 0x63, 0x39, 0x37, 0x32, 0x33, 0x31, 0x38, 0x37, 0x35, 0x65, 0x30, 0x39, 0x62, 0x30, 0x65, 0x64, 0x36, 0x34, 0x30, 0x31, 0x36, 0x63, 0x35, 0x63, 0x65, 0x39, 0x64, 0x37, 0x37, 0x64, 0x30, 0x63, 0x62, 0x63, 0x37, 0x39, 0x31, 0x35, 0x63, 0x35, 0x38, 0x31, 0x37, 0x39, 0x38, 0x37, 0x39, 0x33, 0x38, 0x38, 0x32, 0x37, 0x34, 0x36, 0x35, 0x61, 0x34, 0x64, 0x65, 0x66, 0x38, 0x30, 0x31, 0x63, 0x33, 0x61, 0x33, 0x62, 0x62, 0x62, 0x30, 0x62, 0x63, 0x66, 0x62, 0x65, 0x33, 0x38, 0x35, 0x64, 0x62, 0x61, 0x61, 0x64, 0x33, 0x64, 0x39, 0x30, 0x35, 0x34, 0x31, 0x39, 0x38, 0x39, 0x31, 0x33, 0x65, 0x39, 0x34, 0x35, 0x38, 0x38, 0x33, 0x61, 0x39, 0x61, 0x35, 0x37, 0x37, 0x63, 0x35, 0x66, 0x31, 0x63, 0x64, 0x65, 0x65, 0x33, 0x38, 0x34, 0x39, 0x32, 0x34, 0x37, 0x63, 0x39, 0x61, 0x36, 0x64, 0x34, 0x36, 0x36, 0x37, 0x62, 0x34, 0x63, 0x35, 0x36, 0x33, 0x33, 0x34, 0x30, 0x61, 0x62, 0x36, 0x62, 0x63, 0x34, 0x39, 0x64, 0x31, 0x30, 0x31, 0x33, 0x61, 0x66, 0x31, 0x32, 0x32, 0x34, 0x66, 0x38, 0x39, 0x30, 0x62, 0x65, 0x63, 0x31, 0x36, 0x30, 0x65, 0x32, 0x37, 0x39, 0x37, 0x37, 0x61, 0x32, 0x30, 0x33, 0x32, 0x61, 0x33, 0x62, 0x35, 0x30, 0x34, 0x35, 0x65, 0x33, 0x65, 0x31, 0x66, 0x63, 0x37, 0x32, 0x32, 0x63, 0x65, 0x32, 0x66, 0x38, 0x63, 0x64, 0x61, 0x35, 0x61, 0x64, 0x65, 0x62, 0x31, 0x32, 0x30, 0x38, 0x61, 0x66, 0x65, 0x39, 0x61, 0x66, 0x36, 0x39, 0x34, 0x37, 0x37, 0x31, 0x61, 0x35, 0x39, 0x65, 0x66, 0x37, 0x38, 0x61, 0x66, 0x63, 0x32, 0x65, 0x61, 0x30, 0x62, 0x63, 0x63, 0x61, 0x62, 0x35, 0x36, 0x32, 0x34, 0x61, 0x34, 0x33, 0x31, 0x62, 0x32, 0x34, 0x39, 0x36, 0x37, 0x32, 0x30, 0x63, 0x34, 0x36, 0x64, 0x38, 0x30, 0x31, 0x39, 0x33, 0x35, 0x62, 0x63, 0x37, 0x30, 0x31, 0x33, 0x39, 0x65, 0x34, 0x34, 0x64, 0x32, 0x65, 0x66, 0x64, 0x63, 0x38, 0x34, 0x36, 0x35, 0x66, 0x39, 0x35, 0x65, 0x32, 0x33, 0x36, 0x39, 0x35, 0x36, 0x31, 0x37, 0x66, 0x32, 0x35, 0x36, 0x64, 0x62, 0x38, 0x66, 0x33, 0x38, 0x36, 0x35, 0x37, 0x65, 0x36, 0x35, 0x65, 0x66, 0x33, 0x37, 0x32, 0x37, 0x66, 0x33, 0x33, 0x64, 0x38, 0x36, 0x33, 0x35, 0x35, 0x31, 0x37, 0x65, 0x31, 0x66, 0x36, 0x34, 0x33, 0x39, 0x33, 0x63, 0x34, 0x34, 0x36, 0x33, 0x37, 0x65, 0x37, 0x61, 0x62, 0x62, 0x63, 0x62, 0x33, 0x39, 0x34, 0x37, 0x39, 0x34, 0x38, 0x37, 0x38, 0x64, 0x65, 0x64, 0x62, 0x33, 0x63, 0x31, 0x62, 0x61, 0x66, 0x61, 0x66, 0x37, 0x32, 0x62, 0x64, 0x61, 0x36, 0x35, 0x34, 0x37, 0x32, 0x33, 0x32, 0x39, 0x38, 0x39, 0x64, 0x36, 0x38, 0x35, 0x37, 0x61, 0x64, 0x32, 0x65, 0x39, 0x33, 0x31, 0x64, 0x35, 0x31, 0x34, 0x35, 0x64, 0x37, 0x32, 0x64, 0x65, 0x30, 0x35, 0x65, 0x64, 0x37, 0x65, 0x34, 0x39, 0x30, 0x62, 0x36, 0x66, 0x63, 0x30, 0x66, 0x62, 0x65, 0x65, 0x33, 0x36, 0x31, 0x35, 0x35, 0x34, 0x32, 0x36, 0x33, 0x34, 0x63, 0x64, 0x30, 0x61, 0x63, 0x63, 0x65, 0x35, 0x30, 0x31, 0x62, 0x39, 0x65, 0x39, 0x61, 0x36, 0x35, 0x35, 0x38, 0x61, 0x66, 0x30, 0x30, 0x31, 0x64, 0x34, 0x64, 0x34, 0x34, 0x65, 0x38, 0x66, 0x31, 0x35, 0x65, 0x33, 0x33, 0x63, 0x38, 0x62, 0x62, 0x35, 0x31, 0x33, 0x39, 0x32, 0x63, 0x62, 0x30, 0x32, 0x64, 0x34, 0x33, 0x36, 0x38, 0x30, 0x30, 0x32, 0x32, 0x36, 0x65, 0x33, 0x65, 0x63, 0x36, 0x31, 0x66, 0x38, 0x31, 0x66, 0x61, 0x37, 0x32, 0x64, 0x65, 0x30, 0x63, 0x35, 0x31, 0x34, 0x30, 0x35, 0x33, 0x34, 0x39, 0x35, 0x31, 0x32, 0x39, 0x36, 0x35, 0x31, 0x31, 0x65, 0x65, 0x37, 0x64, 0x34, 0x33, 0x33, 0x32, 0x63, 0x61, 0x39, 0x35, 0x65, 0x37, 0x62, 0x62, 0x61, 0x30, 0x63, 0x64, 0x36, 0x63, 0x30, 0x66, 0x38, 0x66, 0x61, 0x62, 0x30, 0x31, 0x61, 0x30, 0x61, 0x32, 0x32, 0x37, 0x39, 0x38, 0x35, 0x62, 0x38, 0x63, 0x37, 0x32, 0x64, 0x66, 0x30, 0x65, 0x31, 0x36, 0x62, 0x35, 0x30, 0x64, 0x62, 0x61, 0x38, 0x37, 0x32, 0x66, 0x39, 0x37, 0x31, 0x62, 0x31, 0x30, 0x61, 0x33, 0x61, 0x37, 0x38, 0x31, 0x39, 0x62, 0x62, 0x32, 0x61, 0x34, 0x30, 0x35, 0x61, 0x61, 0x39, 0x62, 0x64, 0x65, 0x31, 0x36, 0x31, 0x38, 0x35, 0x35, 0x39, 0x31, 0x62, 0x34, 0x34, 0x63, 0x38, 0x35, 0x34, 0x66, 0x63, 0x64, 0x34, 0x31, 0x37, 0x32, 0x36, 0x36, 0x62, 0x64, 0x63, 0x30, 0x37, 0x37, 0x34, 0x39, 0x35, 0x64, 0x38, 0x32, 0x35, 0x34, 0x35, 0x39, 0x62, 0x36, 0x64, 0x35, 0x65, 0x30, 0x38, 0x64, 0x33, 0x31, 0x38, 0x33, 0x64, 0x38, 0x35, 0x64, 0x63, 0x34, 0x31, 0x66, 0x35, 0x38, 0x33, 0x37, 0x31, 0x63, 0x61, 0x37, 0x36, 0x63, 0x33, 0x38, 0x35, 0x34, 0x34, 0x63, 0x38, 0x31, 0x63, 0x39, 0x39, 0x35, 0x66, 0x30, 0x32, 0x66, 0x32, 0x32, 0x39, 0x63, 0x30, 0x61, 0x66, 0x64, 0x62, 0x62, 0x64, 0x32, 0x65, 0x63, 0x62, 0x32, 0x66, 0x66, 0x66, 0x32, 0x62, 0x35, 0x62, 0x38, 0x31, 0x64, 0x66, 0x32, 0x31, 0x39, 0x64, 0x32, 0x37, 0x33, 0x33, 0x31, 0x30, 0x64, 0x66, 0x66, 0x34, 0x37, 0x31, 0x33, 0x63, 0x63, 0x62, 0x66, 0x62, 0x34, 0x30, 0x63, 0x66, 0x32, 0x33, 0x34, 0x62, 0x31, 0x35, 0x38, 0x37, 0x61, 0x36, 0x38, 0x30, 0x65, 0x33, 0x62, 0x34, 0x36, 0x61, 0x36, 0x61, 0x64, 0x34, 0x64, 0x30, 0x64, 0x64, 0x38, 0x32, 0x37, 0x34, 0x30, 0x35, 0x34, 0x65, 0x38, 0x36, 0x33, 0x37, 0x63, 0x33, 0x31, 0x63, 0x65, 0x66, 0x30, 0x35, 0x39, 0x31, 0x38, 0x61, 0x32, 0x37, 0x65, 0x32, 0x62, 0x31, 0x62, 0x36, 0x37, 0x63, 0x32, 0x34, 0x37, 0x37, 0x37, 0x36, 0x37, 0x36, 0x61, 0x37, 0x31, 0x34, 0x35, 0x36, 0x61, 0x65, 0x39, 0x33, 0x66, 0x37, 0x66, 0x62, 0x39, 0x38, 0x32, 0x63, 0x36, 0x32, 0x62, 0x39, 0x65, 0x32, 0x63, 0x32, 0x65, 0x63, 0x63, 0x35, 0x34, 0x36, 0x33, 0x34, 0x64, 0x35, 0x65, 0x38, 0x64, 0x34, 0x37, 0x64, 0x63, 0x37, 0x31, 0x32, 0x36, 0x65, 0x64, 0x65, 0x36, 0x65, 0x66, 0x61, 0x65, 0x66, 0x30, 0x37, 0x32, 0x38, 0x37, 0x65, 0x37, 0x61, 0x64, 0x34, 0x30, 0x33, 0x31, 0x32, 0x37, 0x35, 0x34, 0x33, 0x39, 0x34, 0x34, 0x64, 0x66, 0x36, 0x36, 0x65, 0x34, 0x64, 0x39, 0x34, 0x32, 0x62, 0x62, 0x64, 0x37, 0x62, 0x65, 0x62, 0x34, 0x62, 0x34, 0x63, 0x31, 0x30, 0x30, 0x66, 0x35, 0x37, 0x38, 0x64, 0x32, 0x36, 0x65, 0x34, 0x66, 0x30, 0x33, 0x63, 0x64, 0x61, 0x32, 0x65, 0x61, 0x35, 0x32, 0x62, 0x66, 0x35, 0x33, 0x35, 0x33, 0x64, 0x63, 0x39, 0x37, 0x64, 0x33, 0x35, 0x61, 0x63, 0x62, 0x61, 0x33, 0x32, 0x63, 0x35, 0x62, 0x33, 0x38, 0x66, 0x36, 0x38, 0x34, 0x62, 0x34, 0x63, 0x62, 0x37, 0x63, 0x34, 0x33, 0x66, 0x36, 0x30, 0x62, 0x34, 0x33, 0x37, 0x34, 0x37, 0x35, 0x63, 0x37, 0x65, 0x39, 0x66, 0x63, 0x63, 0x65, 0x37, 0x31, 0x30, 0x35, 0x62, 0x37, 0x38, 0x39, 0x34, 0x37, 0x32, 0x36, 0x62, 0x33, 0x37, 0x34, 0x62, 0x62, 0x36, 0x61, 0x65, 0x31, 0x37, 0x32, 0x63, 0x36, 0x62, 0x30, 0x39, 0x62, 0x35, 0x38, 0x61, 0x35, 0x38, 0x61, 0x65, 0x62, 0x32, 0x66, 0x64, 0x38, 0x35, 0x32, 0x39, 0x35, 0x62, 0x62, 0x63, 0x63, 0x32, 0x36, 0x33, 0x31, 0x33, 0x32, 0x66, 0x39, 0x61, 0x38, 0x63, 0x34, 0x36, 0x61, 0x37, 0x64, 0x36, 0x39, 0x37, 0x66, 0x36, 0x64, 0x35, 0x37, 0x65, 0x35, 0x61, 0x31, 0x38, 0x63, 0x31, 0x36, 0x62, 0x62, 0x64, 0x65, 0x35, 0x38, 0x63, 0x64, 0x64, 0x31, 0x63, 0x65, 0x34, 0x64, 0x64, 0x61, 0x30, 0x32, 0x31, 0x65, 0x62, 0x31, 0x37, 0x34, 0x34, 0x37, 0x63, 0x39, 0x66, 0x66, 0x61, 0x65, 0x38, 0x35, 0x37, 0x64, 0x34, 0x30, 0x64, 0x38, 0x37, 0x66, 0x33, 0x34, 0x37, 0x34, 0x36, 0x38, 0x65, 0x31, 0x64, 0x66, 0x61, 0x63, 0x63, 0x32, 0x37, 0x39, 0x39, 0x62, 0x33, 0x61, 0x36, 0x39, 0x63, 0x32, 0x61, 0x30, 0x31, 0x33, 0x32, 0x39, 0x62, 0x34, 0x32, 0x33, 0x62, 0x39, 0x62, 0x38, 0x65, 0x65, 0x38, 0x63, 0x32, 0x61, 0x30, 0x37, 0x39, 0x61, 0x62, 0x64, 0x61, 0x30, 0x64, 0x36, 0x66, 0x30, 0x62, 0x63, 0x62, 0x65, 0x36, 0x39, 0x61, 0x34, 0x34, 0x61, 0x30, 0x33, 0x31, 0x39, 0x35, 0x66, 0x62, 0x31, 0x35, 0x30, 0x33, 0x61, 0x37, 0x33, 0x64, 0x32, 0x31, 0x30, 0x61, 0x39, 0x66, 0x38, 0x30, 0x37, 0x36, 0x39, 0x36, 0x38, 0x34, 0x38, 0x34, 0x65, 0x61, 0x66, 0x38, 0x37, 0x66, 0x62, 0x61, 0x34, 0x30, 0x33, 0x61, 0x39, 0x35, 0x36, 0x36, 0x30, 0x39, 0x65, 0x63, 0x33, 0x61, 0x38, 0x36, 0x63, 0x33, 0x66, 0x37, 0x62, 0x36, 0x33, 0x64, 0x66, 0x32, 0x33, 0x38, 0x65, 0x32, 0x33, 0x39, 0x36, 0x35, 0x38, 0x36, 0x66, 0x31, 0x30, 0x66, 0x32, 0x36, 0x30, 0x66, 0x63, 0x61, 0x39, 0x62, 0x61, 0x35, 0x61, 0x37, 0x33, 0x34, 0x32, 0x37, 0x32, 0x63, 0x64, 0x35, 0x34, 0x34, 0x34, 0x62, 0x64, 0x62, 0x61, 0x61, 0x35, 0x35, 0x63, 0x38, 0x38, 0x38, 0x35, 0x38, 0x63, 0x30, 0x65, 0x34, 0x37, 0x33, 0x30, 0x36, 0x32, 0x39, 0x37, 0x36, 0x66, 0x66, 0x61, 0x61, 0x65, 0x32, 0x33, 0x65, 0x62, 0x63, 0x31, 0x34, 0x64, 0x32, 0x39, 0x37, 0x32, 0x39, 0x33, 0x33, 0x32, 0x35, 0x33, 0x38, 0x31, 0x37, 0x32, 0x65, 0x39, 0x34, 0x36, 0x32, 0x39, 0x66, 0x39, 0x61, 0x36, 0x38, 0x37, 0x39, 0x63, 0x31, 0x31, 0x37, 0x61, 0x62, 0x33, 0x33, 0x63, 0x30, 0x34, 0x65, 0x38, 0x31, 0x39, 0x61, 0x34, 0x33, 0x39, 0x35, 0x65, 0x63, 0x37, 0x30, 0x63, 0x37, 0x36, 0x36, 0x30, 0x32, 0x62, 0x64, 0x36, 0x62, 0x63, 0x33, 0x36, 0x63, 0x39, 0x66, 0x39, 0x65, 0x31, 0x65, 0x33, 0x63, 0x38, 0x30, 0x65, 0x37, 0x32, 0x62, 0x39, 0x61, 0x65, 0x62, 0x66, 0x39, 0x37, 0x33, 0x32, 0x66, 0x63, 0x33, 0x62, 0x63, 0x64, 0x30, 0x32, 0x35, 0x64, 0x35, 0x39, 0x36, 0x30, 0x30, 0x36, 0x37, 0x39, 0x36, 0x62, 0x37, 0x31, 0x32, 0x30, 0x37, 0x37, 0x37, 0x38, 0x35, 0x65, 0x37, 0x64, 0x30, 0x65, 0x38, 0x37, 0x62, 0x37, 0x33, 0x37, 0x66, 0x30, 0x61, 0x33, 0x65, 0x35, 0x63, 0x34, 0x33, 0x38, 0x30, 0x65, 0x33, 0x61, 0x65, 0x62, 0x36, 0x37, 0x65, 0x36, 0x36, 0x34, 0x65, 0x65, 0x63, 0x65, 0x64, 0x35, 0x62, 0x33, 0x30, 0x33, 0x39, 0x66, 0x36, 0x33, 0x31, 0x62, 0x38, 0x30, 0x39, 0x39, 0x33, 0x32, 0x33, 0x35, 0x33, 0x39, 0x66, 0x35, 0x63, 0x39, 0x63, 0x38, 0x36, 0x34, 0x61, 0x32, 0x62, 0x34, 0x66, 0x38, 0x31, 0x30, 0x32, 0x63, 0x32, 0x62, 0x64, 0x33, 0x38, 0x65, 0x66, 0x39, 0x64, 0x33, 0x37, 0x32, 0x31, 0x36, 0x64, 0x31, 0x36, 0x36, 0x32, 0x64, 0x30, 0x34, 0x33, 0x66, 0x35, 0x39, 0x66, 0x30, 0x32, 0x35, 0x64, 0x39, 0x33, 0x37, 0x39, 0x64, 0x36, 0x63, 0x34, 0x32, 0x30, 0x66, 0x32, 0x37, 0x39, 0x34, 0x35, 0x37, 0x39, 0x66, 0x63, 0x61, 0x62, 0x30, 0x30, 0x33, 0x61, 0x62, 0x66, 0x38, 0x33, 0x61, 0x32, 0x31, 0x36, 0x61, 0x65, 0x64, 0x65, 0x33, 0x37, 0x65, 0x64, 0x34, 0x37, 0x32, 0x64, 0x65, 0x39, 0x31, 0x37, 0x34, 0x38, 0x33, 0x64, 0x37, 0x64, 0x63, 0x62, 0x31, 0x66, 0x64, 0x36, 0x37, 0x31, 0x38, 0x34, 0x63, 0x36, 0x30, 0x32, 0x61, 0x65, 0x63, 0x32, 0x38, 0x32, 0x32, 0x64, 0x37, 0x32, 0x37, 0x65, 0x63, 0x64, 0x62, 0x65, 0x39, 0x39, 0x36, 0x64, 0x62, 0x66, 0x66, 0x66, 0x36, 0x37, 0x34, 0x61, 0x62, 0x30, 0x61, 0x63, 0x65, 0x33, 0x39, 0x31, 0x62, 0x31, 0x37, 0x62, 0x65, 0x36, 0x66, 0x64, 0x31, 0x38, 0x32, 0x37, 0x39, 0x39, 0x63, 0x38, 0x36, 0x66, 0x31, 0x38, 0x31, 0x32, 0x66, 0x63, 0x66, 0x35, 0x39, 0x31, 0x63, 0x37, 0x30, 0x33, 0x66, 0x63, 0x65, 0x30, 0x33, 0x36, 0x30, 0x61, 0x35, 0x65, 0x62, 0x34, 0x64, 0x37, 0x35, 0x38, 0x32, 0x64, 0x31, 0x33, 0x32, 0x32, 0x63, 0x33, 0x38, 0x62, 0x32, 0x32, 0x32, 0x66, 0x63, 0x61, 0x35, 0x37, 0x32, 0x39, 0x32, 0x37, 0x66, 0x36, 0x62, 0x35, 0x63, 0x64, 0x63, 0x38, 0x36, 0x31, 0x36, 0x39, 0x36, 0x34, 0x32, 0x66, 0x63, 0x37, 0x33, 0x61, 0x30, 0x32, 0x37, 0x33, 0x66, 0x32, 0x61, 0x35, 0x32, 0x64, 0x30, 0x61, 0x62, 0x63, 0x35, 0x30, 0x37, 0x64, 0x62, 0x37, 0x35, 0x35, 0x30, 0x37, 0x66, 0x64, 0x61, 0x34, 0x63, 0x37, 0x38, 0x37, 0x35, 0x37, 0x38, 0x39, 0x39, 0x64, 0x36, 0x31, 0x35, 0x64, 0x63, 0x37, 0x33, 0x64, 0x65, 0x34, 0x61, 0x64, 0x31, 0x31, 0x31, 0x65, 0x39, 0x63, 0x64, 0x64, 0x66, 0x37, 0x37, 0x61, 0x65, 0x37, 0x64, 0x63, 0x62, 0x34, 0x61, 0x66, 0x36, 0x64, 0x34, 0x63, 0x32, 0x37, 0x62, 0x66, 0x38, 0x37, 0x62, 0x38, 0x34, 0x36, 0x31, 0x66, 0x63, 0x38, 0x61, 0x34, 0x38, 0x35, 0x34, 0x31, 0x37, 0x62, 0x64, 0x63, 0x38, 0x36, 0x64, 0x62, 0x65, 0x37, 0x32, 0x31, 0x37, 0x31, 0x38, 0x35, 0x34, 0x31, 0x62, 0x63, 0x61, 0x63, 0x36, 0x61, 0x32, 0x34, 0x65, 0x65, 0x32, 0x35, 0x34, 0x30, 0x66, 0x34, 0x66, 0x62, 0x39, 0x65, 0x38, 0x32, 0x62, 0x66, 0x62, 0x63, 0x34, 0x32, 0x62, 0x35, 0x65, 0x32, 0x61, 0x35, 0x63, 0x37, 0x36, 0x31, 0x39, 0x66, 0x34, 0x64, 0x30, 0x39, 0x35, 0x31, 0x63, 0x36, 0x36, 0x37, 0x63, 0x64, 0x31, 0x33, 0x31, 0x34, 0x30, 0x62, 0x35, 0x39, 0x39, 0x34, 0x38, 0x37, 0x63, 0x62, 0x61, 0x31, 0x34, 0x36, 0x35, 0x31, 0x30, 0x36, 0x61, 0x31, 0x30, 0x63, 0x30, 0x61, 0x38, 0x35, 0x30, 0x65, 0x35, 0x63, 0x35, 0x65, 0x66, 0x34, 0x66, 0x66, 0x30, 0x64, 0x36, 0x62, 0x31, 0x66, 0x33, 0x31, 0x38, 0x34, 0x37, 0x63, 0x64, 0x36, 0x62, 0x37, 0x35, 0x61, 0x62, 0x62, 0x33, 0x34, 0x30, 0x38, 0x63, 0x61, 0x37, 0x37, 0x32, 0x34, 0x33, 0x38, 0x34, 0x32, 0x35, 0x61, 0x62, 0x38, 0x32, 0x33, 0x66, 0x32, 0x36, 0x31, 0x39, 0x66, 0x32, 0x33, 0x66, 0x31, 0x65, 0x30, 0x36, 0x30, 0x38, 0x66, 0x62, 0x64, 0x35, 0x30, 0x39, 0x61, 0x66, 0x62, 0x38, 0x37, 0x33, 0x61, 0x65, 0x30, 0x37, 0x61, 0x62, 0x33, 0x34, 0x65, 0x36, 0x62, 0x34, 0x62, 0x66, 0x66, 0x35, 0x37, 0x39, 0x66, 0x37, 0x62, 0x37, 0x33, 0x34, 0x31, 0x38, 0x36, 0x39, 0x32, 0x61, 0x65, 0x63, 0x64, 0x34, 0x66, 0x39, 0x36, 0x64, 0x61, 0x61, 0x34, 0x34, 0x32, 0x65, 0x39, 0x31, 0x30, 0x37, 0x63, 0x62, 0x66, 0x30, 0x33, 0x66, 0x35, 0x36, 0x35, 0x35, 0x65, 0x33, 0x38, 0x30, 0x62, 0x33, 0x63, 0x39, 0x64, 0x35, 0x38, 0x61, 0x66, 0x65, 0x66, 0x65, 0x61, 0x39, 0x38, 0x34, 0x63, 0x30, 0x34, 0x61, 0x64, 0x66, 0x34, 0x31, 0x38, 0x33, 0x35, 0x64, 0x33, 0x63, 0x31, 0x31, 0x62, 0x34, 0x61, 0x38, 0x30, 0x34, 0x36, 0x61, 0x39, 0x66, 0x64, 0x64, 0x64, 0x39, 0x34, 0x61, 0x33, 0x32, 0x32, 0x35, 0x37, 0x37, 0x63, 0x62, 0x33, 0x35, 0x39, 0x36, 0x30, 0x31, 0x65, 0x64, 0x33, 0x32, 0x39, 0x66, 0x65, 0x65, 0x32, 0x66, 0x38, 0x61, 0x37, 0x62, 0x34, 0x33, 0x63, 0x61, 0x38, 0x66, 0x63, 0x65, 0x35, 0x32, 0x34, 0x66, 0x66, 0x63, 0x34, 0x32, 0x33, 0x30, 0x61, 0x66, 0x31, 0x63, 0x31, 0x66, 0x65, 0x35, 0x34, 0x64, 0x35, 0x35, 0x62, 0x62, 0x61, 0x39, 0x34, 0x33, 0x63, 0x61, 0x34, 0x66, 0x35, 0x65, 0x32, 0x64, 0x37, 0x62, 0x62, 0x37, 0x35, 0x65, 0x34, 0x36, 0x66, 0x36, 0x34, 0x62, 0x34, 0x37, 0x30, 0x61, 0x31, 0x32, 0x63, 0x33, 0x61, 0x36, 0x30, 0x62, 0x32, 0x63, 0x35, 0x65, 0x36, 0x65, 0x32, 0x62, 0x33, 0x61, 0x32, 0x34, 0x64, 0x32, 0x63, 0x34, 0x36, 0x66, 0x30, 0x35, 0x65, 0x31, 0x36, 0x31, 0x34, 0x37, 0x39, 0x33, 0x61, 0x30, 0x38, 0x63, 0x65, 0x34, 0x64, 0x30, 0x35, 0x35, 0x34, 0x38, 0x33, 0x63, 0x31, 0x65, 0x32, 0x31, 0x37, 0x38, 0x62, 0x31, 0x62, 0x34, 0x61, 0x64, 0x31, 0x61, 0x33, 0x62, 0x34, 0x39, 0x63, 0x38, 0x65, 0x37, 0x63, 0x31, 0x34, 0x31, 0x61, 0x32, 0x32, 0x31, 0x32, 0x63, 0x37, 0x32, 0x65, 0x38, 0x32, 0x33, 0x36, 0x35, 0x36, 0x32, 0x62, 0x66, 0x63, 0x35, 0x33, 0x65, 0x38, 0x62, 0x62, 0x30, 0x64, 0x39, 0x34, 0x35, 0x65, 0x64, 0x35, 0x30, 0x35, 0x64, 0x39, 0x64, 0x34, 0x30, 0x64, 0x33, 0x62, 0x39, 0x30, 0x32, 0x61, 0x35, 0x33, 0x63, 0x66, 0x31, 0x37, 0x62, 0x33, 0x65, 0x30, 0x36, 0x38, 0x37, 0x61, 0x36, 0x34, 0x37, 0x62, 0x30, 0x31, 0x35, 0x63, 0x30, 0x37, 0x32, 0x33, 0x63, 0x36, 0x36, 0x62, 0x32, 0x30, 0x63, 0x33, 0x32, 0x37, 0x32, 0x36, 0x66, 0x33, 0x37, 0x31, 0x62, 0x38, 0x39, 0x31, 0x36, 0x38, 0x34, 0x63, 0x62, 0x39, 0x62, 0x30, 0x61, 0x39, 0x35, 0x37, 0x36, 0x31, 0x35, 0x31, 0x61, 0x35, 0x66, 0x35, 0x62, 0x39, 0x31, 0x62, 0x34, 0x38, 0x62, 0x33, 0x62, 0x66, 0x36, 0x61, 0x63, 0x32, 0x38, 0x38, 0x63, 0x63, 0x66, 0x65, 0x33, 0x37, 0x32, 0x65, 0x39, 0x37, 0x38, 0x63, 0x35, 0x62, 0x33, 0x33, 0x63, 0x35, 0x35, 0x65, 0x32, 0x63, 0x65, 0x35, 0x38, 0x32, 0x65, 0x65, 0x62, 0x36, 0x63, 0x35, 0x36, 0x36, 0x61, 0x35, 0x62, 0x30, 0x36, 0x63, 0x63, 0x35, 0x37, 0x63, 0x62, 0x30, 0x61, 0x38, 0x65, 0x33, 0x62, 0x66, 0x38, 0x62, 0x31, 0x39, 0x65, 0x33, 0x31, 0x39, 0x34, 0x33, 0x36, 0x36, 0x63, 0x31, 0x38, 0x61, 0x62, 0x37, 0x32, 0x63, 0x35, 0x32, 0x37, 0x35, 0x33, 0x33, 0x66, 0x37, 0x36, 0x33, 0x37, 0x35, 0x66, 0x32, 0x63, 0x36, 0x66, 0x32, 0x39, 0x66, 0x61, 0x64, 0x35, 0x31, 0x38, 0x37, 0x62, 0x31, 0x62, 0x65, 0x33, 0x62, 0x65, 0x39, 0x32, 0x36, 0x61, 0x32, 0x39, 0x39, 0x63, 0x62, 0x36, 0x34, 0x65, 0x37, 0x31, 0x63, 0x39, 0x62, 0x62, 0x61, 0x30, 0x39, 0x34, 0x62, 0x31, 0x61, 0x61, 0x66, 0x64, 0x32, 0x37, 0x64, 0x63, 0x62, 0x33, 0x34, 0x64, 0x34, 0x30, 0x33, 0x36, 0x62, 0x63, 0x32, 0x62, 0x30, 0x34, 0x33, 0x39, 0x61, 0x37, 0x36, 0x66, 0x63, 0x66, 0x61, 0x33, 0x39, 0x36, 0x32, 0x62, 0x35, 0x37, 0x64, 0x39, 0x32, 0x63, 0x34, 0x33, 0x66, 0x34, 0x32, 0x32, 0x33, 0x39, 0x34, 0x65, 0x63, 0x62, 0x38, 0x34, 0x31, 0x63, 0x63, 0x64, 0x38, 0x61, 0x62, 0x32, 0x31, 0x65, 0x37, 0x33, 0x31, 0x34, 0x39, 0x63, 0x35, 0x36, 0x34, 0x63, 0x34, 0x64, 0x39, 0x33, 0x34, 0x35, 0x33, 0x62, 0x61, 0x37, 0x35, 0x62, 0x36, 0x66, 0x34, 0x33, 0x66, 0x62, 0x35, 0x64, 0x33, 0x63, 0x64, 0x61, 0x63, 0x37, 0x33, 0x65, 0x61, 0x35, 0x31, 0x31, 0x37, 0x32, 0x35, 0x33, 0x33, 0x36, 0x34, 0x37, 0x32, 0x65, 0x61, 0x63, 0x33, 0x66, 0x32, 0x38, 0x64, 0x64, 0x37, 0x38, 0x33, 0x36, 0x38, 0x30, 0x37, 0x32, 0x34, 0x32, 0x35, 0x39, 0x32, 0x33, 0x38, 0x38, 0x38, 0x38, 0x37, 0x65, 0x61, 0x63, 0x32, 0x37, 0x33, 0x33, 0x32, 0x31, 0x61, 0x38, 0x66, 0x33, 0x66, 0x66, 0x32, 0x34, 0x34, 0x36, 0x37, 0x34, 0x62, 0x39, 0x39, 0x64, 0x66, 0x65, 0x32, 0x39, 0x34, 0x65, 0x39, 0x62, 0x61, 0x63, 0x65, 0x36, 0x37, 0x34, 0x32, 0x32, 0x66, 0x62, 0x34, 0x36, 0x64, 0x37, 0x61, 0x31, 0x62, 0x61, 0x37, 0x32, 0x33, 0x31, 0x64, 0x66, 0x32, 0x30, 0x30, 0x66, 0x39, 0x63, 0x33, 0x30, 0x62, 0x65, 0x36, 0x36, 0x64, 0x65, 0x39, 0x61, 0x63, 0x65, 0x34, 0x63, 0x66, 0x36, 0x32, 0x31, 0x35, 0x34, 0x62, 0x32, 0x32, 0x38, 0x65, 0x38, 0x66, 0x32, 0x33, 0x64, 0x33, 0x66, 0x38, 0x36, 0x33, 0x33, 0x31, 0x39, 0x30, 0x35, 0x63, 0x64, 0x37, 0x31, 0x33, 0x36, 0x62, 0x35, 0x34, 0x66, 0x63, 0x37, 0x37, 0x32, 0x61, 0x30, 0x38, 0x64, 0x31, 0x61, 0x35, 0x38, 0x31, 0x39, 0x38, 0x39, 0x62, 0x37, 0x30, 0x32, 0x62, 0x65, 0x66, 0x39, 0x66, 0x61, 0x63, 0x64, 0x35, 0x66, 0x30, 0x31, 0x33, 0x62, 0x61, 0x37, 0x37, 0x64, 0x32, 0x66, 0x65, 0x39, 0x64, 0x35, 0x39, 0x33, 0x30, 0x32, 0x66, 0x36, 0x33, 0x33, 0x64, 0x34, 0x39, 0x37, 0x38, 0x36, 0x32, 0x64, 0x31, 0x61, 0x64, 0x66, 0x62, 0x39, 0x34, 0x39, 0x63, 0x30, 0x39, 0x35, 0x37, 0x66, 0x64, 0x34, 0x38, 0x63, 0x38, 0x65, 0x37, 0x65, 0x30, 0x32, 0x62, 0x65, 0x61, 0x63, 0x61, 0x63, 0x38, 0x62, 0x37, 0x61, 0x30, 0x36, 0x30, 0x62, 0x34, 0x37, 0x36, 0x38, 0x39, 0x35, 0x36, 0x38, 0x63, 0x35, 0x63, 0x36, 0x64, 0x39, 0x31, 0x36, 0x63, 0x30, 0x64, 0x63, 0x64, 0x62, 0x38, 0x64, 0x61, 0x61, 0x35, 0x66, 0x66, 0x38, 0x64, 0x34, 0x31, 0x31, 0x31, 0x34, 0x38, 0x33, 0x31, 0x30, 0x37, 0x32, 0x30, 0x37, 0x37, 0x64, 0x32, 0x65, 0x35, 0x30, 0x36, 0x32, 0x32, 0x36, 0x32, 0x66, 0x39, 0x36, 0x63, 0x38, 0x32, 0x32, 0x32, 0x30, 0x35, 0x37, 0x38, 0x65, 0x63, 0x30, 0x38, 0x32, 0x31, 0x32, 0x37, 0x38, 0x65, 0x30, 0x30, 0x30, 0x34, 0x36, 0x34, 0x34, 0x37, 0x61, 0x33, 0x38, 0x66, 0x63, 0x39, 0x32, 0x61, 0x30, 0x66, 0x61, 0x37, 0x32, 0x38, 0x30, 0x64, 0x39, 0x65, 0x63, 0x37, 0x66, 0x37, 0x64, 0x66, 0x37, 0x63, 0x31, 0x61, 0x34, 0x36, 0x36, 0x32, 0x31, 0x34, 0x37, 0x63, 0x38, 0x65, 0x33, 0x31, 0x62, 0x39, 0x64, 0x32, 0x63, 0x38, 0x65, 0x61, 0x35, 0x36, 0x30, 0x35, 0x61, 0x65, 0x38, 0x34, 0x61, 0x37, 0x33, 0x39, 0x36, 0x34, 0x33, 0x38, 0x63, 0x30, 0x33, 0x30, 0x61, 0x65, 0x63, 0x37, 0x39, 0x30, 0x66, 0x37, 0x32, 0x37, 0x63, 0x64, 0x36, 0x36, 0x64, 0x32, 0x34, 0x36, 0x61, 0x31, 0x31, 0x39, 0x32, 0x62, 0x33, 0x34, 0x31, 0x33, 0x34, 0x63, 0x38, 0x39, 0x31, 0x63, 0x39, 0x66, 0x62, 0x63, 0x63, 0x66, 0x34, 0x33, 0x66, 0x61, 0x37, 0x61, 0x33, 0x65, 0x62, 0x37, 0x36, 0x63, 0x32, 0x61, 0x39, 0x34, 0x37, 0x65, 0x37, 0x33, 0x65, 0x66, 0x38, 0x37, 0x38, 0x62, 0x62, 0x65, 0x30, 0x65, 0x64, 0x33, 0x65, 0x32, 0x39, 0x65, 0x61, 0x37, 0x62, 0x62, 0x36, 0x62, 0x31, 0x30, 0x38, 0x31, 0x33, 0x35, 0x31, 0x66, 0x34, 0x30, 0x63, 0x33, 0x31, 0x63, 0x39, 0x63, 0x33, 0x63, 0x34, 0x35, 0x66, 0x65, 0x36, 0x65, 0x61, 0x39, 0x63, 0x39, 0x66, 0x38, 0x65, 0x39, 0x36, 0x32, 0x64, 0x33, 0x32, 0x32, 0x36, 0x61, 0x34, 0x31, 0x31, 0x33, 0x36, 0x39, 0x36, 0x35, 0x30, 0x39, 0x35, 0x33, 0x61, 0x37, 0x32, 0x39, 0x36, 0x64, 0x38, 0x31, 0x39, 0x38, 0x38, 0x66, 0x34, 0x65, 0x30, 0x65, 0x62, 0x31, 0x65, 0x61, 0x62, 0x30, 0x32, 0x38, 0x37, 0x64, 0x64, 0x62, 0x36, 0x31, 0x34, 0x63, 0x61, 0x66, 0x36, 0x32, 0x33, 0x61, 0x37, 0x34, 0x63, 0x39, 0x31, 0x37, 0x64, 0x37, 0x35, 0x36, 0x30, 0x39, 0x30, 0x30, 0x39, 0x33, 0x35, 0x65, 0x64, 0x34, 0x30, 0x33, 0x37, 0x36, 0x32, 0x30, 0x35, 0x31, 0x39, 0x37, 0x35, 0x64, 0x35, 0x30, 0x33, 0x62, 0x32, 0x34, 0x61, 0x30, 0x63, 0x38, 0x39, 0x35, 0x38, 0x34, 0x61, 0x34, 0x35, 0x36, 0x64, 0x39, 0x66, 0x63, 0x33, 0x66, 0x39, 0x30, 0x66, 0x65, 0x63, 0x66, 0x66, 0x38, 0x63, 0x32, 0x62, 0x39, 0x39, 0x33, 0x66, 0x66, 0x35, 0x36, 0x64, 0x35, 0x33, 0x66, 0x32, 0x65, 0x31, 0x32, 0x34, 0x33, 0x34, 0x36, 0x66, 0x34, 0x34, 0x61, 0x63, 0x34, 0x34, 0x39, 0x37, 0x38, 0x62, 0x38, 0x61, 0x65, 0x39, 0x34, 0x61, 0x61, 0x34, 0x32, 0x61, 0x37, 0x61, 0x63, 0x62, 0x39, 0x62, 0x66, 0x30, 0x61, 0x33, 0x63, 0x65, 0x39, 0x65, 0x33, 0x39, 0x32, 0x30, 0x37, 0x61, 0x63, 0x63, 0x65, 0x61, 0x31, 0x39, 0x62, 0x61, 0x62, 0x39, 0x30, 0x32, 0x65, 0x64, 0x39, 0x61, 0x62, 0x34, 0x63, 0x36, 0x64, 0x33, 0x61, 0x61, 0x62, 0x36, 0x63, 0x30, 0x37, 0x32, 0x38, 0x64, 0x62, 0x33, 0x62, 0x31, 0x30, 0x35, 0x30, 0x31, 0x39, 0x32, 0x33, 0x39, 0x61, 0x64, 0x35, 0x33, 0x39, 0x35, 0x65, 0x33, 0x32, 0x35, 0x66, 0x33, 0x63, 0x37, 0x37, 0x33, 0x36, 0x37, 0x63, 0x34, 0x35, 0x62, 0x33, 0x37, 0x30, 0x33, 0x63, 0x38, 0x38, 0x38, 0x63, 0x34, 0x64, 0x32, 0x64, 0x39, 0x36, 0x35, 0x32, 0x64, 0x62, 0x39, 0x63, 0x34, 0x33, 0x31, 0x62, 0x61, 0x37, 0x32, 0x39, 0x39, 0x61, 0x38, 0x31, 0x30, 0x61, 0x38, 0x39, 0x37, 0x37, 0x34, 0x39, 0x39, 0x30, 0x30, 0x31, 0x66, 0x65, 0x33, 0x63, 0x66, 0x33, 0x37, 0x65, 0x36, 0x30, 0x32, 0x65, 0x64, 0x39, 0x33, 0x38, 0x65, 0x62, 0x35, 0x30, 0x34, 0x32, 0x63, 0x38, 0x66, 0x64, 0x33, 0x37, 0x64, 0x66, 0x31, 0x32, 0x64, 0x61, 0x31, 0x31, 0x38, 0x32, 0x65, 0x64, 0x31, 0x65, 0x61, 0x30, 0x31, 0x32, 0x65, 0x39, 0x63, 0x30, 0x38, 0x36, 0x34, 0x61, 0x34, 0x66, 0x36, 0x63, 0x31, 0x61, 0x30, 0x64, 0x35, 0x31, 0x32, 0x65, 0x32, 0x63, 0x65, 0x33, 0x39, 0x34, 0x37, 0x66, 0x62, 0x61, 0x36, 0x34, 0x34, 0x30, 0x32, 0x30, 0x39, 0x36, 0x38, 0x64, 0x38, 0x34, 0x38, 0x33, 0x62, 0x64, 0x62, 0x35, 0x64, 0x38, 0x32, 0x38, 0x61, 0x35, 0x38, 0x61, 0x61, 0x36, 0x39, 0x62, 0x35, 0x64, 0x61, 0x31, 0x30, 0x65, 0x38, 0x35, 0x61, 0x66, 0x34, 0x30, 0x34, 0x39, 0x62, 0x34, 0x34, 0x32, 0x34, 0x61, 0x37, 0x36, 0x39, 0x63, 0x37, 0x30, 0x30, 0x36, 0x65, 0x31, 0x33, 0x30, 0x36, 0x37, 0x61, 0x34, 0x65, 0x64, 0x34, 0x39, 0x32, 0x66, 0x36, 0x32, 0x35, 0x65, 0x61, 0x61, 0x61, 0x62, 0x61, 0x65, 0x38, 0x63, 0x38, 0x33, 0x34, 0x62, 0x37, 0x65, 0x38, 0x62, 0x61, 0x66, 0x31, 0x66, 0x64, 0x33, 0x62, 0x64, 0x62, 0x38, 0x65, 0x38, 0x63, 0x32, 0x62, 0x65, 0x35, 0x61, 0x37, 0x31, 0x65, 0x66, 0x33, 0x36, 0x65, 0x39, 0x62, 0x64, 0x35, 0x63, 0x33, 0x65, 0x63, 0x63, 0x34, 0x36, 0x65, 0x62, 0x33, 0x31, 0x63, 0x61, 0x34, 0x31, 0x37, 0x39, 0x32, 0x30, 0x31, 0x65, 0x62, 0x65, 0x34, 0x61, 0x66, 0x38, 0x63, 0x33, 0x33, 0x62, 0x32, 0x39, 0x39, 0x38, 0x33, 0x31, 0x64, 0x32, 0x33, 0x35, 0x64, 0x61, 0x38, 0x31, 0x62, 0x30, 0x63, 0x62, 0x61, 0x61, 0x61, 0x64, 0x30, 0x64, 0x61, 0x63, 0x37, 0x33, 0x35, 0x30, 0x30, 0x65, 0x62, 0x38, 0x62, 0x34, 0x62, 0x30, 0x63, 0x34, 0x61, 0x63, 0x38, 0x34, 0x62, 0x39, 0x30, 0x62, 0x63, 0x35, 0x63, 0x61, 0x64, 0x64, 0x66, 0x64, 0x37, 0x32, 0x38, 0x31, 0x30, 0x61, 0x65, 0x36, 0x36, 0x39, 0x32, 0x63, 0x61, 0x38, 0x37, 0x62, 0x30, 0x37, 0x32, 0x63, 0x65, 0x39, 0x64, 0x62, 0x33, 0x32, 0x38, 0x66, 0x66, 0x62, 0x64, 0x66, 0x30, 0x37, 0x34, 0x64, 0x34, 0x63, 0x62, 0x61, 0x36, 0x62, 0x38, 0x35, 0x33, 0x37, 0x64, 0x33, 0x35, 0x35, 0x36, 0x61, 0x31, 0x32, 0x64, 0x35, 0x33, 0x34, 0x34, 0x64, 0x61, 0x66, 0x61, 0x61, 0x64, 0x30, 0x33, 0x62, 0x34, 0x34, 0x32, 0x35, 0x34, 0x37, 0x35, 0x31, 0x61, 0x64, 0x63, 0x31, 0x36, 0x31, 0x30, 0x64, 0x65, 0x37, 0x31, 0x66, 0x35, 0x66, 0x33, 0x35, 0x38, 0x66, 0x34, 0x66, 0x33, 0x37, 0x30, 0x34, 0x30, 0x62, 0x66, 0x63, 0x36, 0x34, 0x30, 0x30, 0x66, 0x63, 0x63, 0x61, 0x64, 0x34, 0x64, 0x61, 0x39, 0x36, 0x36, 0x36, 0x35, 0x34, 0x32, 0x37, 0x66, 0x65, 0x66, 0x64, 0x34, 0x31, 0x63, 0x33, 0x36, 0x61, 0x64, 0x64, 0x64, 0x31, 0x61, 0x63, 0x66, 0x30, 0x36, 0x32, 0x36, 0x33, 0x34, 0x32, 0x39, 0x31, 0x30, 0x64, 0x38, 0x35, 0x31, 0x65, 0x66, 0x32, 0x62, 0x62, 0x61, 0x38, 0x62, 0x32, 0x38, 0x31, 0x39, 0x62, 0x30, 0x30, 0x32, 0x35, 0x65, 0x38, 0x36, 0x38, 0x30, 0x33, 0x34, 0x32, 0x30, 0x31, 0x36, 0x36, 0x30, 0x34, 0x34, 0x38, 0x64, 0x64, 0x61, 0x65, 0x33, 0x65, 0x35, 0x63, 0x36, 0x65, 0x31, 0x61, 0x64, 0x34, 0x62, 0x37, 0x35, 0x63, 0x64, 0x64, 0x61, 0x34, 0x32, 0x31, 0x32, 0x30, 0x32, 0x62, 0x61, 0x39, 0x31, 0x33, 0x64, 0x36, 0x39, 0x30, 0x36, 0x30, 0x63, 0x65, 0x33, 0x34, 0x63, 0x35, 0x37, 0x35, 0x65, 0x63, 0x36, 0x65, 0x62, 0x62, 0x34, 0x31, 0x64, 0x30, 0x33, 0x64, 0x66, 0x30, 0x38, 0x61, 0x35, 0x63, 0x62, 0x63, 0x30, 0x63, 0x38, 0x38, 0x30, 0x33, 0x34, 0x62, 0x36, 0x61, 0x33, 0x66, 0x65, 0x37, 0x34, 0x62, 0x38, 0x34, 0x30, 0x37, 0x32, 0x39, 0x35, 0x66, 0x33, 0x34, 0x65, 0x66, 0x64, 0x35, 0x30, 0x66, 0x39, 0x63, 0x32, 0x38, 0x39, 0x65, 0x64, 0x39, 0x33, 0x36, 0x65, 0x64, 0x32, 0x30, 0x32, 0x63, 0x30, 0x37, 0x32, 0x36, 0x66, 0x30, 0x65, 0x63, 0x62, 0x31, 0x35, 0x37, 0x66, 0x34, 0x61, 0x31, 0x30, 0x30, 0x32, 0x65, 0x30, 0x30, 0x35, 0x34, 0x62, 0x36, 0x37, 0x31, 0x65, 0x31, 0x34, 0x32, 0x35, 0x39, 0x39, 0x32, 0x34, 0x65, 0x61, 0x30, 0x37, 0x36, 0x66, 0x32, 0x36, 0x35, 0x32, 0x66, 0x36, 0x66, 0x37, 0x35, 0x64, 0x30, 0x34, 0x39, 0x63, 0x63, 0x35, 0x30, 0x38, 0x34, 0x66, 0x64, 0x34, 0x65, 0x39, 0x34, 0x31, 0x36, 0x32, 0x65, 0x33, 0x62, 0x39, 0x31, 0x63, 0x35, 0x64, 0x62, 0x32, 0x30, 0x30, 0x66, 0x39, 0x38, 0x66, 0x66, 0x65, 0x36, 0x39, 0x31, 0x61, 0x61, 0x30, 0x39, 0x36, 0x34, 0x34, 0x30, 0x61, 0x63, 0x63, 0x38, 0x31, 0x39, 0x62, 0x30, 0x33, 0x66, 0x62, 0x66, 0x63, 0x35, 0x37, 0x30, 0x30, 0x30, 0x63, 0x39, 0x33, 0x37, 0x36, 0x37, 0x61, 0x66, 0x36, 0x34, 0x62, 0x38, 0x32, 0x34, 0x61, 0x36, 0x61, 0x39, 0x35, 0x39, 0x36, 0x39, 0x31, 0x66, 0x62, 0x63, 0x38, 0x38, 0x30, 0x34, 0x31, 0x38, 0x38, 0x31, 0x32, 0x36, 0x61, 0x66, 0x64, 0x37, 0x61, 0x66, 0x37, 0x61, 0x39, 0x30, 0x34, 0x38, 0x34, 0x33, 0x33, 0x32, 0x39, 0x34, 0x34, 0x65, 0x31, 0x65, 0x33, 0x37, 0x36, 0x34, 0x37, 0x37, 0x35, 0x61, 0x63, 0x62, 0x39, 0x32, 0x30, 0x37, 0x31, 0x33, 0x39, 0x61, 0x62, 0x37, 0x31, 0x38, 0x30, 0x62, 0x64, 0x36, 0x37, 0x36, 0x34, 0x32, 0x32, 0x36, 0x66, 0x63, 0x39, 0x36, 0x32, 0x64, 0x35, 0x65, 0x61, 0x66, 0x31, 0x36, 0x61, 0x61, 0x33, 0x61, 0x65, 0x34, 0x36, 0x33, 0x30, 0x37, 0x32, 0x61, 0x38, 0x31, 0x37, 0x64, 0x66, 0x35, 0x64, 0x62, 0x64, 0x39, 0x33, 0x36, 0x39, 0x61, 0x36, 0x39, 0x37, 0x36, 0x35, 0x35, 0x30, 0x37, 0x64, 0x37, 0x39, 0x39, 0x39, 0x36, 0x61, 0x66, 0x64, 0x61, 0x63, 0x38, 0x37, 0x63, 0x37, 0x34, 0x63, 0x66, 0x30, 0x65, 0x31, 0x32, 0x62, 0x61, 0x37, 0x33, 0x63, 0x33, 0x34, 0x62, 0x66, 0x64, 0x38, 0x38, 0x66, 0x34, 0x34, 0x30, 0x61, 0x33, 0x35, 0x31, 0x30, 0x66, 0x36, 0x66, 0x65, 0x63, 0x63, 0x34, 0x66, 0x39, 0x65, 0x31, 0x62, 0x62, 0x64, 0x32, 0x38, 0x64, 0x31, 0x34, 0x35, 0x39, 0x31, 0x65, 0x61, 0x30, 0x37, 0x66, 0x38, 0x33, 0x34, 0x34, 0x37, 0x66, 0x62, 0x33, 0x31, 0x34, 0x31, 0x37, 0x61, 0x38, 0x63, 0x36, 0x63, 0x35, 0x38, 0x35, 0x61, 0x33, 0x33, 0x39, 0x65, 0x33, 0x61, 0x62, 0x34, 0x32, 0x33, 0x35, 0x35, 0x33, 0x61, 0x63, 0x64, 0x34, 0x63, 0x66, 0x31, 0x38, 0x38, 0x31, 0x39, 0x65, 0x61, 0x31, 0x38, 0x66, 0x38, 0x65, 0x38, 0x39, 0x34, 0x63, 0x65, 0x33, 0x31, 0x39, 0x39, 0x30, 0x32, 0x32, 0x38, 0x35, 0x30, 0x32, 0x33, 0x63, 0x37, 0x33, 0x36, 0x37, 0x61, 0x63, 0x66, 0x32, 0x33, 0x65, 0x32, 0x64, 0x30, 0x65, 0x32, 0x36, 0x66, 0x30, 0x35, 0x36, 0x39, 0x64, 0x66, 0x30, 0x64, 0x37, 0x32, 0x34, 0x38, 0x65, 0x61, 0x63, 0x34, 0x64, 0x37, 0x38, 0x30, 0x30, 0x64, 0x39, 0x36, 0x39, 0x35, 0x30, 0x39, 0x31, 0x66, 0x36, 0x33, 0x36, 0x34, 0x37, 0x39, 0x37, 0x66, 0x36, 0x63, 0x33, 0x63, 0x30, 0x64, 0x32, 0x38, 0x37, 0x38, 0x38, 0x39, 0x61, 0x37, 0x35, 0x66, 0x36, 0x32, 0x61, 0x35, 0x33, 0x30, 0x61, 0x36, 0x30, 0x66, 0x38, 0x64, 0x38, 0x64, 0x65, 0x38, 0x63, 0x31, 0x37, 0x32, 0x38, 0x38, 0x30, 0x61, 0x33, 0x32, 0x39, 0x61, 0x65, 0x62, 0x64, 0x61, 0x66, 0x62, 0x63, 0x34, 0x36, 0x61, 0x61, 0x38, 0x32, 0x35, 0x38, 0x39, 0x61, 0x38, 0x35, 0x62, 0x66, 0x30, 0x61, 0x38, 0x32, 0x34, 0x33, 0x34, 0x65, 0x39, 0x62, 0x35, 0x31, 0x34, 0x32, 0x30, 0x34, 0x36, 0x36, 0x64, 0x30, 0x35, 0x36, 0x36, 0x32, 0x66, 0x32, 0x61, 0x64, 0x34, 0x35, 0x65, 0x34, 0x66, 0x37, 0x32, 0x36, 0x34, 0x30, 0x37, 0x36, 0x33, 0x38, 0x32, 0x32, 0x32, 0x32, 0x64, 0x36, 0x37, 0x63, 0x35, 0x36, 0x30, 0x65, 0x39, 0x33, 0x66, 0x38, 0x36, 0x66, 0x30, 0x62, 0x63, 0x64, 0x62, 0x31, 0x33, 0x35, 0x38, 0x35, 0x33, 0x31, 0x31, 0x34, 0x39, 0x65, 0x65, 0x61, 0x66, 0x34, 0x64, 0x32, 0x39, 0x31, 0x65, 0x65, 0x32, 0x38, 0x36, 0x64, 0x66, 0x37, 0x34, 0x65, 0x39, 0x39, 0x31, 0x34, 0x32, 0x31, 0x64, 0x65, 0x35, 0x64, 0x61, 0x37, 0x33, 0x30, 0x33, 0x39, 0x36, 0x65, 0x35, 0x65, 0x36, 0x30, 0x34, 0x66, 0x34, 0x32, 0x30, 0x32, 0x33, 0x31, 0x32, 0x37, 0x32, 0x30, 0x62, 0x30, 0x38, 0x30, 0x61, 0x63, 0x64, 0x39, 0x30, 0x31, 0x66, 0x62, 0x64, 0x65, 0x66, 0x38, 0x63, 0x64, 0x34, 0x36, 0x33, 0x64, 0x33, 0x37, 0x30, 0x36, 0x31, 0x35, 0x39, 0x65, 0x31, 0x66, 0x62, 0x37, 0x32, 0x39, 0x34, 0x62, 0x33, 0x36, 0x63, 0x37, 0x64, 0x31, 0x39, 0x33, 0x37, 0x35, 0x38, 0x34, 0x38, 0x61, 0x32, 0x37, 0x37, 0x36, 0x38, 0x37, 0x36, 0x62, 0x64, 0x62, 0x32, 0x31, 0x64, 0x34, 0x33, 0x33, 0x62, 0x64, 0x32, 0x33, 0x34, 0x64, 0x30, 0x31, 0x39, 0x61, 0x39, 0x62, 0x64, 0x64, 0x39, 0x37, 0x38, 0x36, 0x39, 0x31, 0x35, 0x34, 0x31, 0x62, 0x38, 0x39, 0x62, 0x62, 0x38, 0x30, 0x65, 0x64, 0x64, 0x38, 0x39, 0x65, 0x64, 0x32, 0x66, 0x33, 0x30, 0x38, 0x35, 0x36, 0x39, 0x32, 0x31, 0x66, 0x31, 0x38, 0x30, 0x37, 0x66, 0x63, 0x38, 0x62, 0x30, 0x61, 0x33, 0x63, 0x30, 0x36, 0x65, 0x62, 0x66, 0x65, 0x31, 0x38, 0x37, 0x31, 0x66, 0x38, 0x63, 0x39, 0x35, 0x38, 0x64, 0x39, 0x65, 0x36, 0x32, 0x36, 0x62, 0x33, 0x62, 0x37, 0x39, 0x37, 0x64, 0x33, 0x64, 0x38, 0x61, 0x37, 0x32, 0x37, 0x39, 0x65, 0x61, 0x39, 0x64, 0x31, 0x39, 0x61, 0x39, 0x36, 0x62, 0x36, 0x39, 0x30, 0x63, 0x33, 0x61, 0x66, 0x35, 0x33, 0x31, 0x65, 0x62, 0x35, 0x64, 0x64, 0x36, 0x35, 0x33, 0x38, 0x31, 0x31, 0x36, 0x63, 0x38, 0x64, 0x31, 0x31, 0x64, 0x39, 0x36, 0x62, 0x64, 0x64, 0x36, 0x65, 0x64, 0x66, 0x66, 0x31, 0x35, 0x33, 0x38, 0x61, 0x38, 0x66, 0x64, 0x61, 0x65, 0x62, 0x34, 0x36, 0x63, 0x64, 0x63, 0x63, 0x31, 0x62, 0x62, 0x33, 0x63, 0x39, 0x66, 0x61, 0x38, 0x62, 0x64, 0x30, 0x34, 0x39, 0x38, 0x64, 0x37, 0x34, 0x63, 0x66, 0x34, 0x31, 0x38, 0x64, 0x31, 0x62, 0x35, 0x30, 0x38, 0x36, 0x30, 0x33, 0x35, 0x39, 0x36, 0x31, 0x39, 0x66, 0x33, 0x31, 0x30, 0x66, 0x33, 0x38, 0x62, 0x61, 0x61, 0x63, 0x35, 0x66, 0x66, 0x30, 0x65, 0x62, 0x64, 0x65, 0x36, 0x62, 0x31, 0x37, 0x32, 0x37, 0x64, 0x35, 0x33, 0x65, 0x32, 0x32, 0x31, 0x61, 0x64, 0x38, 0x31, 0x33, 0x63, 0x62, 0x65, 0x37, 0x64, 0x62, 0x35, 0x62, 0x36, 0x34, 0x36, 0x37, 0x37, 0x35, 0x37, 0x36, 0x66, 0x64, 0x62, 0x37, 0x34, 0x64, 0x38, 0x37, 0x38, 0x62, 0x36, 0x61, 0x33, 0x34, 0x65, 0x61, 0x61, 0x36, 0x35, 0x37, 0x37, 0x63, 0x31, 0x65, 0x61, 0x38, 0x36, 0x66, 0x36, 0x37, 0x39, 0x61, 0x64, 0x37, 0x32, 0x37, 0x63, 0x32, 0x65, 0x66, 0x64, 0x33, 0x62, 0x64, 0x32, 0x35, 0x65, 0x37, 0x38, 0x30, 0x64, 0x34, 0x35, 0x66, 0x37, 0x61, 0x61, 0x33, 0x63, 0x34, 0x34, 0x37, 0x62, 0x34, 0x39, 0x66, 0x38, 0x62, 0x36, 0x35, 0x65, 0x37, 0x37, 0x61, 0x35, 0x31, 0x37, 0x34, 0x65, 0x37, 0x38, 0x38, 0x63, 0x33, 0x36, 0x34, 0x32, 0x33, 0x39, 0x30, 0x62, 0x32, 0x65, 0x32, 0x35, 0x64, 0x64, 0x37, 0x32, 0x38, 0x34, 0x30, 0x33, 0x39, 0x63, 0x37, 0x66, 0x65, 0x63, 0x63, 0x62, 0x31, 0x32, 0x31, 0x39, 0x37, 0x66, 0x37, 0x61, 0x62, 0x62, 0x61, 0x66, 0x31, 0x61, 0x39, 0x62, 0x64, 0x35, 0x33, 0x33, 0x33, 0x38, 0x35, 0x62, 0x66, 0x37, 0x62, 0x35, 0x33, 0x37, 0x64, 0x61, 0x62, 0x31, 0x63, 0x37, 0x62, 0x64, 0x61, 0x36, 0x64, 0x66, 0x38, 0x39, 0x33, 0x35, 0x30, 0x32, 0x39, 0x39, 0x37, 0x32, 0x36, 0x61, 0x62, 0x65, 0x33, 0x61, 0x61, 0x63, 0x61, 0x64, 0x38, 0x63, 0x62, 0x62, 0x62, 0x37, 0x63, 0x31, 0x34, 0x39, 0x61, 0x66, 0x63, 0x37, 0x61, 0x37, 0x36, 0x37, 0x30, 0x33, 0x32, 0x63, 0x30, 0x36, 0x63, 0x35, 0x32, 0x38, 0x34, 0x64, 0x32, 0x35, 0x61, 0x30, 0x62, 0x30, 0x34, 0x66, 0x63, 0x38, 0x39, 0x65, 0x32, 0x36, 0x30, 0x30, 0x32, 0x63, 0x30, 0x31, 0x65, 0x62, 0x37, 0x32, 0x34, 0x32, 0x63, 0x63, 0x65, 0x66, 0x61, 0x62, 0x32, 0x61, 0x38, 0x66, 0x64, 0x37, 0x33, 0x36, 0x38, 0x63, 0x66, 0x37, 0x65, 0x31, 0x33, 0x38, 0x38, 0x33, 0x34, 0x38, 0x31, 0x39, 0x64, 0x35, 0x30, 0x30, 0x61, 0x33, 0x65, 0x38, 0x32, 0x39, 0x61, 0x37, 0x31, 0x35, 0x31, 0x37, 0x35, 0x64, 0x31, 0x62, 0x66, 0x30, 0x34, 0x37, 0x62, 0x38, 0x35, 0x30, 0x35, 0x61, 0x64, 0x31, 0x31, 0x34, 0x62, 0x61, 0x34, 0x32, 0x38, 0x62, 0x66, 0x34, 0x65, 0x62, 0x61, 0x63, 0x30, 0x31, 0x66, 0x62, 0x30, 0x30, 0x66, 0x30, 0x31, 0x33, 0x34, 0x61, 0x30, 0x66, 0x65, 0x39, 0x62, 0x31, 0x65, 0x37, 0x32, 0x38, 0x39, 0x65, 0x37, 0x35, 0x32, 0x63, 0x63, 0x61, 0x66, 0x31, 0x37, 0x64, 0x33, 0x64, 0x33, 0x32, 0x62, 0x65, 0x63, 0x61, 0x37, 0x31, 0x35, 0x65, 0x64, 0x38, 0x61, 0x31, 0x37, 0x32, 0x64, 0x32, 0x32, 0x33, 0x33, 0x62, 0x63, 0x34, 0x61, 0x61, 0x36, 0x61, 0x34, 0x37, 0x30, 0x65, 0x39, 0x30, 0x30, 0x62, 0x37, 0x30, 0x33, 0x63, 0x33, 0x31, 0x37, 0x32, 0x35, 0x66, 0x62, 0x62, 0x61, 0x61, 0x31, 0x32, 0x39, 0x62, 0x37, 0x61, 0x37, 0x37, 0x37, 0x34, 0x38, 0x63, 0x62, 0x35, 0x66, 0x37, 0x38, 0x66, 0x37, 0x38, 0x66, 0x66, 0x39, 0x61, 0x38, 0x38, 0x62, 0x64, 0x37, 0x32, 0x31, 0x36, 0x30, 0x66, 0x33, 0x35, 0x33, 0x38, 0x33, 0x31, 0x30, 0x37, 0x33, 0x39, 0x36, 0x39, 0x61, 0x37, 0x62, 0x36, 0x34, 0x31, 0x63, 0x32, 0x64, 0x36, 0x35, 0x37, 0x61, 0x61, 0x33, 0x31, 0x62, 0x65, 0x31, 0x35, 0x39, 0x66, 0x61, 0x66, 0x30, 0x31, 0x30, 0x31, 0x33, 0x66, 0x32, 0x36, 0x64, 0x37, 0x32, 0x63, 0x32, 0x65, 0x64, 0x61, 0x63, 0x65, 0x33, 0x66, 0x31, 0x39, 0x36, 0x35, 0x66, 0x65, 0x64, 0x33, 0x31, 0x35, 0x65, 0x33, 0x65, 0x37, 0x63, 0x37, 0x63, 0x61, 0x66, 0x62, 0x30, 0x62, 0x38, 0x65, 0x37, 0x39, 0x33, 0x66, 0x34, 0x38, 0x38, 0x32, 0x35, 0x36, 0x64, 0x37, 0x39, 0x39, 0x33, 0x32, 0x35, 0x37, 0x34, 0x34, 0x65, 0x35, 0x30, 0x38, 0x61, 0x35, 0x64, 0x38, 0x30, 0x61, 0x30, 0x32, 0x30, 0x31, 0x66, 0x64, 0x36, 0x30, 0x36, 0x62, 0x65, 0x39, 0x31, 0x62, 0x31, 0x61, 0x31, 0x35, 0x38, 0x32, 0x34, 0x65, 0x35, 0x31, 0x65, 0x38, 0x34, 0x36, 0x37, 0x39, 0x31, 0x63, 0x39, 0x33, 0x61, 0x39, 0x38, 0x36, 0x38, 0x32, 0x65, 0x37, 0x34, 0x35, 0x61, 0x61, 0x62, 0x64, 0x66, 0x64, 0x61, 0x37, 0x30, 0x66, 0x66, 0x66, 0x62, 0x30, 0x35, 0x34, 0x65, 0x62, 0x63, 0x64, 0x35, 0x37, 0x33, 0x65, 0x36, 0x34, 0x65, 0x30, 0x63, 0x35, 0x31, 0x65, 0x37, 0x32, 0x31, 0x36, 0x37, 0x38, 0x65, 0x36, 0x39, 0x39, 0x33, 0x36, 0x65, 0x39, 0x39, 0x31, 0x63, 0x31, 0x62, 0x63, 0x37, 0x31, 0x62, 0x64, 0x66, 0x37, 0x35, 0x31, 0x39, 0x36, 0x65, 0x31, 0x38, 0x31, 0x30, 0x38, 0x37, 0x30, 0x65, 0x65, 0x63, 0x31, 0x37, 0x39, 0x30, 0x35, 0x30, 0x61, 0x33, 0x30, 0x63, 0x62, 0x63, 0x63, 0x30, 0x64, 0x63, 0x33, 0x35, 0x34, 0x39, 0x30, 0x37, 0x35, 0x37, 0x32, 0x33, 0x30, 0x66, 0x36, 0x66, 0x39, 0x65, 0x62, 0x33, 0x62, 0x30, 0x64, 0x65, 0x62, 0x63, 0x63, 0x63, 0x32, 0x37, 0x65, 0x31, 0x31, 0x37, 0x63, 0x30, 0x37, 0x30, 0x63, 0x34, 0x66, 0x62, 0x30, 0x31, 0x61, 0x37, 0x30, 0x39, 0x36, 0x62, 0x61, 0x65, 0x62, 0x33, 0x61, 0x35, 0x36, 0x64, 0x36, 0x66, 0x34, 0x31, 0x34, 0x30, 0x64, 0x39, 0x37, 0x61, 0x37, 0x32, 0x66, 0x32, 0x62, 0x32, 0x64, 0x36, 0x32, 0x34, 0x66, 0x64, 0x65, 0x66, 0x39, 0x32, 0x63, 0x38, 0x31, 0x61, 0x30, 0x36, 0x33, 0x63, 0x61, 0x39, 0x34, 0x38, 0x30, 0x63, 0x62, 0x37, 0x61, 0x31, 0x63, 0x65, 0x61, 0x61, 0x37, 0x65, 0x61, 0x66, 0x38, 0x61, 0x35, 0x37, 0x35, 0x30, 0x37, 0x66, 0x35, 0x33, 0x62, 0x32, 0x35, 0x63, 0x65, 0x38, 0x35, 0x31, 0x36, 0x37, 0x32, 0x31, 0x33, 0x66, 0x38, 0x37, 0x66, 0x31, 0x61, 0x62, 0x62, 0x34, 0x61, 0x36, 0x37, 0x31, 0x66, 0x35, 0x64, 0x36, 0x38, 0x61, 0x63, 0x62, 0x63, 0x39, 0x39, 0x64, 0x66, 0x39, 0x62, 0x37, 0x35, 0x30, 0x62, 0x34, 0x63, 0x30, 0x61, 0x35, 0x30, 0x32, 0x35, 0x61, 0x38, 0x30, 0x35, 0x39, 0x63, 0x32, 0x36, 0x31, 0x37, 0x62, 0x36, 0x32, 0x61, 0x35, 0x64, 0x65, 0x66, 0x61, 0x63, 0x65, 0x37, 0x64, 0x37, 0x61, 0x36, 0x61, 0x38, 0x37, 0x32, 0x31, 0x34, 0x62, 0x31, 0x35, 0x30, 0x62, 0x39, 0x65, 0x34, 0x38, 0x63, 0x62, 0x65, 0x61, 0x32, 0x33, 0x31, 0x62, 0x64, 0x39, 0x63, 0x38, 0x30, 0x30, 0x66, 0x62, 0x39, 0x36, 0x66, 0x33, 0x62, 0x63, 0x36, 0x30, 0x33, 0x36, 0x62, 0x30, 0x33, 0x33, 0x38, 0x38, 0x33, 0x65, 0x62, 0x39, 0x65, 0x34, 0x31, 0x63, 0x30, 0x30, 0x37, 0x37, 0x35, 0x62, 0x63, 0x31, 0x61, 0x35, 0x39, 0x37, 0x32, 0x31, 0x35, 0x64, 0x62, 0x38, 0x39, 0x35, 0x62, 0x64, 0x35, 0x31, 0x30, 0x31, 0x32, 0x33, 0x38, 0x65, 0x38, 0x36, 0x36, 0x66, 0x32, 0x33, 0x36, 0x33, 0x64, 0x36, 0x31, 0x61, 0x30, 0x65, 0x32, 0x66, 0x37, 0x39, 0x39, 0x63, 0x36, 0x35, 0x66, 0x62, 0x33, 0x63, 0x38, 0x38, 0x39, 0x61, 0x63, 0x63, 0x65, 0x31, 0x39, 0x35, 0x39, 0x31, 0x32, 0x31, 0x34, 0x35, 0x33, 0x65, 0x36, 0x36, 0x38, 0x65, 0x39, 0x33, 0x63, 0x62, 0x61, 0x63, 0x37, 0x31, 0x38, 0x32, 0x39, 0x32, 0x34, 0x34, 0x61, 0x64, 0x64, 0x31, 0x66, 0x34, 0x36, 0x64, 0x33, 0x65, 0x65, 0x33, 0x66, 0x33, 0x39, 0x35, 0x34, 0x39, 0x64, 0x65, 0x64, 0x36, 0x32, 0x62, 0x61, 0x64, 0x37, 0x61, 0x31, 0x30, 0x37, 0x38, 0x39, 0x62, 0x66, 0x30, 0x37, 0x33, 0x36, 0x34, 0x35, 0x64, 0x35, 0x31, 0x30, 0x38, 0x38, 0x37, 0x32, 0x39, 0x30, 0x62, 0x38, 0x33, 0x37, 0x39, 0x30, 0x65, 0x36, 0x62, 0x63, 0x34, 0x36, 0x66, 0x35, 0x38, 0x33, 0x32, 0x64, 0x63, 0x34, 0x39, 0x64, 0x65, 0x39, 0x30, 0x61, 0x62, 0x31, 0x66, 0x31, 0x39, 0x64, 0x31, 0x62, 0x62, 0x31, 0x33, 0x66, 0x65, 0x64, 0x38, 0x64, 0x35, 0x38, 0x32, 0x65, 0x35, 0x62, 0x66, 0x62, 0x35, 0x31, 0x34, 0x33, 0x30, 0x31, 0x39, 0x37, 0x64, 0x65, 0x37, 0x32, 0x65, 0x64, 0x37, 0x31, 0x33, 0x33, 0x62, 0x37, 0x61, 0x35, 0x61, 0x64, 0x65, 0x62, 0x35, 0x36, 0x31, 0x63, 0x66, 0x34, 0x62, 0x39, 0x61, 0x32, 0x37, 0x62, 0x66, 0x30, 0x32, 0x38, 0x36, 0x33, 0x35, 0x64, 0x37, 0x35, 0x36, 0x39, 0x62, 0x61, 0x35, 0x32, 0x36, 0x36, 0x36, 0x32, 0x38, 0x66, 0x39, 0x62, 0x66, 0x63, 0x62, 0x37, 0x62, 0x32, 0x35, 0x33, 0x65, 0x62, 0x37, 0x35, 0x37, 0x32, 0x37, 0x33, 0x34, 0x62, 0x31, 0x37, 0x64, 0x30, 0x64, 0x34, 0x63, 0x62, 0x63, 0x36, 0x33, 0x65, 0x34, 0x32, 0x63, 0x36, 0x38, 0x38, 0x35, 0x33, 0x63, 0x66, 0x64, 0x38, 0x64, 0x32, 0x35, 0x62, 0x30, 0x36, 0x36, 0x39, 0x36, 0x31, 0x35, 0x38, 0x30, 0x32, 0x66, 0x32, 0x64, 0x39, 0x32, 0x66, 0x38, 0x63, 0x33, 0x35, 0x61, 0x39, 0x33, 0x65, 0x62, 0x32, 0x66, 0x66, 0x39, 0x36, 0x37, 0x32, 0x36, 0x37, 0x61, 0x65, 0x36, 0x35, 0x66, 0x32, 0x62, 0x65, 0x35, 0x38, 0x62, 0x65, 0x39, 0x32, 0x39, 0x64, 0x65, 0x38, 0x64, 0x63, 0x62, 0x66, 0x33, 0x61, 0x65, 0x37, 0x36, 0x33, 0x39, 0x30, 0x37, 0x36, 0x38, 0x66, 0x61, 0x35, 0x39, 0x63, 0x63, 0x32, 0x61, 0x35, 0x38, 0x38, 0x34, 0x64, 0x62, 0x30, 0x31, 0x61, 0x35, 0x38, 0x65, 0x34, 0x33, 0x35, 0x65, 0x65, 0x39, 0x63, 0x37, 0x32, 0x65, 0x31, 0x39, 0x33, 0x33, 0x61, 0x33, 0x62, 0x38, 0x30, 0x35, 0x30, 0x35, 0x32, 0x66, 0x63, 0x62, 0x32, 0x37, 0x63, 0x63, 0x63, 0x31, 0x64, 0x30, 0x64, 0x33, 0x65, 0x37, 0x38, 0x38, 0x61, 0x35, 0x30, 0x34, 0x39, 0x37, 0x39, 0x37, 0x35, 0x39, 0x34, 0x37, 0x32, 0x66, 0x62, 0x63, 0x64, 0x61, 0x35, 0x35, 0x34, 0x65, 0x62, 0x39, 0x31, 0x34, 0x35, 0x35, 0x65, 0x34, 0x37, 0x33, 0x66, 0x30, 0x30, 0x66, 0x39, 0x35, 0x32, 0x36, 0x35, 0x63, 0x34, 0x39, 0x30, 0x38, 0x35, 0x35, 0x35, 0x61, 0x38, 0x65, 0x38, 0x39, 0x32, 0x61, 0x66, 0x30, 0x66, 0x33, 0x31, 0x63, 0x65, 0x32, 0x61, 0x39, 0x30, 0x65, 0x36, 0x31, 0x63, 0x63, 0x39, 0x36, 0x62, 0x36, 0x37, 0x34, 0x31, 0x64, 0x39, 0x33, 0x36, 0x64, 0x65, 0x62, 0x35, 0x36, 0x39, 0x66, 0x66, 0x39, 0x38, 0x62, 0x30, 0x35, 0x39, 0x34, 0x37, 0x32, 0x39, 0x61, 0x33, 0x61, 0x32, 0x62, 0x36, 0x36, 0x35, 0x39, 0x33, 0x31, 0x61, 0x33, 0x39, 0x61, 0x63, 0x65, 0x32, 0x61, 0x30, 0x64, 0x61, 0x63, 0x32, 0x34, 0x62, 0x66, 0x65, 0x63, 0x61, 0x36, 0x30, 0x65, 0x31, 0x63, 0x65, 0x64, 0x35, 0x32, 0x65, 0x31, 0x32, 0x64, 0x30, 0x34, 0x37, 0x33, 0x39, 0x32, 0x37, 0x66, 0x61, 0x61, 0x32, 0x64, 0x31, 0x30, 0x32, 0x31, 0x66, 0x64, 0x31, 0x38, 0x30, 0x63, 0x38, 0x36, 0x39, 0x30, 0x38, 0x63, 0x30, 0x63, 0x35, 0x64, 0x32, 0x38, 0x65, 0x39, 0x64, 0x38, 0x61, 0x38, 0x65, 0x64, 0x34, 0x65, 0x31, 0x32, 0x33, 0x34, 0x31, 0x63, 0x36, 0x31, 0x64, 0x66, 0x62, 0x65, 0x35, 0x32, 0x35, 0x65, 0x61, 0x36, 0x32, 0x33, 0x39, 0x32, 0x30, 0x64, 0x38, 0x38, 0x64, 0x34, 0x64, 0x38, 0x30, 0x62, 0x31, 0x65, 0x61, 0x37, 0x32, 0x38, 0x63, 0x35, 0x34, 0x30, 0x62, 0x38, 0x36, 0x66, 0x37, 0x34, 0x34, 0x39, 0x33, 0x31, 0x64, 0x39, 0x32, 0x61, 0x38, 0x35, 0x35, 0x38, 0x32, 0x31, 0x35, 0x64, 0x33, 0x37, 0x32, 0x34, 0x39, 0x36, 0x65, 0x30, 0x38, 0x34, 0x36, 0x63, 0x65, 0x63, 0x30, 0x36, 0x63, 0x34, 0x31, 0x30, 0x65, 0x38, 0x36, 0x62, 0x64, 0x65, 0x62, 0x63, 0x62, 0x39, 0x38, 0x38, 0x31, 0x64, 0x30, 0x32, 0x61, 0x63, 0x63, 0x32, 0x34, 0x38, 0x30, 0x33, 0x32, 0x37, 0x32, 0x66, 0x64, 0x33, 0x62, 0x64, 0x65, 0x32, 0x37, 0x34, 0x37, 0x30, 0x34, 0x66, 0x62, 0x62, 0x65, 0x66, 0x39, 0x35, 0x64, 0x39, 0x31, 0x32, 0x31, 0x61, 0x37, 0x66, 0x33, 0x33, 0x32, 0x61, 0x65, 0x64, 0x64, 0x32, 0x30, 0x64, 0x39, 0x35, 0x61, 0x31, 0x37, 0x62, 0x36, 0x35, 0x65, 0x61, 0x31, 0x65, 0x32, 0x32, 0x35, 0x37, 0x32, 0x63, 0x32, 0x64, 0x62, 0x38, 0x63, 0x33, 0x34, 0x37, 0x62, 0x37, 0x62, 0x34, 0x31, 0x37, 0x35, 0x37, 0x66, 0x65, 0x65, 0x64, 0x30, 0x64, 0x36, 0x36, 0x31, 0x32, 0x63, 0x38, 0x39, 0x66, 0x38, 0x38, 0x34, 0x39, 0x63, 0x33, 0x33, 0x34, 0x64, 0x39, 0x35, 0x61, 0x39, 0x36, 0x64, 0x32, 0x66, 0x33, 0x63, 0x63, 0x63, 0x66, 0x31, 0x63, 0x31, 0x63, 0x63, 0x66, 0x38, 0x35, 0x61, 0x32, 0x63, 0x65, 0x32, 0x31, 0x37, 0x33, 0x35, 0x65, 0x32, 0x33, 0x34, 0x62, 0x30, 0x64, 0x37, 0x64, 0x30, 0x63, 0x35, 0x64, 0x37, 0x33, 0x61, 0x36, 0x38, 0x36, 0x31, 0x39, 0x33, 0x38, 0x39, 0x33, 0x39, 0x38, 0x64, 0x65, 0x35, 0x62, 0x36, 0x38, 0x61, 0x65, 0x63, 0x38, 0x35, 0x65, 0x32, 0x35, 0x63, 0x38, 0x34, 0x63, 0x35, 0x39, 0x34, 0x33, 0x63, 0x37, 0x31, 0x39, 0x65, 0x30, 0x37, 0x37, 0x32, 0x30, 0x38, 0x37, 0x64, 0x66, 0x65, 0x38, 0x66, 0x39, 0x35, 0x37, 0x38, 0x61, 0x62, 0x64, 0x34, 0x39, 0x63, 0x61, 0x61, 0x63, 0x34, 0x36, 0x63, 0x33, 0x66, 0x30, 0x36, 0x34, 0x36, 0x33, 0x35, 0x65, 0x36, 0x33, 0x39, 0x38, 0x32, 0x38, 0x66, 0x36, 0x35, 0x38, 0x34, 0x64, 0x61, 0x65, 0x66, 0x39, 0x37, 0x66, 0x65, 0x34, 0x32, 0x32, 0x39, 0x33, 0x32, 0x32, 0x32, 0x36, 0x35, 0x37, 0x32, 0x62, 0x61, 0x62, 0x34, 0x34, 0x39, 0x32, 0x30, 0x66, 0x31, 0x37, 0x37, 0x35, 0x35, 0x38, 0x31, 0x66, 0x33, 0x61, 0x34, 0x66, 0x62, 0x37, 0x38, 0x61, 0x61, 0x33, 0x36, 0x32, 0x39, 0x31, 0x38, 0x66, 0x32, 0x35, 0x36, 0x65, 0x63, 0x61, 0x36, 0x61, 0x35, 0x38, 0x63, 0x61, 0x35, 0x62, 0x30, 0x36, 0x65, 0x66, 0x32, 0x31, 0x63, 0x30, 0x32, 0x39, 0x39, 0x63, 0x39, 0x66, 0x32, 0x35, 0x38, 0x64, 0x33, 0x34, 0x38, 0x32, 0x61, 0x34, 0x36, 0x30, 0x64, 0x31, 0x38, 0x31, 0x37, 0x37, 0x65, 0x31, 0x35, 0x32, 0x38, 0x31, 0x36, 0x35, 0x64, 0x37, 0x63, 0x35, 0x37, 0x37, 0x65, 0x39, 0x30, 0x37, 0x38, 0x39, 0x62, 0x35, 0x61, 0x30, 0x37, 0x61, 0x66, 0x34, 0x65, 0x61, 0x64, 0x63, 0x64, 0x66, 0x37, 0x37, 0x36, 0x65, 0x61, 0x33, 0x34, 0x65, 0x38, 0x37, 0x63, 0x66, 0x39, 0x30, 0x38, 0x32, 0x30, 0x64, 0x32, 0x31, 0x37, 0x62, 0x31, 0x36, 0x61, 0x65, 0x63, 0x38, 0x37, 0x63, 0x38, 0x39, 0x63, 0x32, 0x34, 0x39, 0x38, 0x38, 0x64, 0x34, 0x31, 0x33, 0x35, 0x35, 0x33, 0x33, 0x35, 0x30, 0x31, 0x37, 0x35, 0x38, 0x30, 0x38, 0x66, 0x38, 0x30, 0x39, 0x36, 0x62, 0x65, 0x31, 0x64, 0x35, 0x31, 0x39, 0x61, 0x33, 0x62, 0x38, 0x64, 0x32, 0x38, 0x39, 0x30, 0x38, 0x34, 0x37, 0x32, 0x38, 0x61, 0x62, 0x37, 0x62, 0x64, 0x64, 0x30, 0x36, 0x33, 0x66, 0x63, 0x37, 0x61, 0x33, 0x34, 0x38, 0x35, 0x62, 0x35, 0x31, 0x34, 0x33, 0x36, 0x65, 0x38, 0x37, 0x31, 0x66, 0x65, 0x30, 0x37, 0x61, 0x35, 0x62, 0x64, 0x36, 0x63, 0x62, 0x66, 0x37, 0x61, 0x61, 0x33, 0x39, 0x64, 0x31, 0x39, 0x66, 0x33, 0x61, 0x65, 0x31, 0x35, 0x61, 0x36, 0x33, 0x61, 0x32, 0x65, 0x64, 0x66, 0x37, 0x32, 0x34, 0x38, 0x39, 0x62, 0x36, 0x33, 0x37, 0x37, 0x64, 0x30, 0x63, 0x37, 0x64, 0x30, 0x63, 0x32, 0x61, 0x63, 0x61, 0x33, 0x61, 0x37, 0x32, 0x39, 0x64, 0x38, 0x61, 0x31, 0x63, 0x30, 0x66, 0x30, 0x35, 0x37, 0x35, 0x62, 0x65, 0x32, 0x38, 0x35, 0x37, 0x39, 0x39, 0x66, 0x61, 0x39, 0x37, 0x64, 0x65, 0x30, 0x63, 0x34, 0x38, 0x35, 0x38, 0x63, 0x61, 0x37, 0x64, 0x38, 0x33, 0x35, 0x37, 0x32, 0x39, 0x31, 0x39, 0x32, 0x63, 0x61, 0x36, 0x61, 0x39, 0x37, 0x34, 0x32, 0x36, 0x37, 0x36, 0x34, 0x62, 0x34, 0x35, 0x38, 0x35, 0x38, 0x39, 0x37, 0x35, 0x62, 0x66, 0x34, 0x38, 0x34, 0x66, 0x63, 0x33, 0x63, 0x66, 0x37, 0x64, 0x62, 0x37, 0x32, 0x31, 0x38, 0x62, 0x65, 0x65, 0x30, 0x30, 0x31, 0x63, 0x62, 0x61, 0x36, 0x64, 0x34, 0x66, 0x64, 0x64, 0x63, 0x61, 0x32, 0x66, 0x39, 0x35, 0x62, 0x36, 0x39, 0x32, 0x66, 0x39, 0x35, 0x66, 0x32, 0x61, 0x36, 0x34, 0x64, 0x35, 0x66, 0x65, 0x37, 0x39, 0x65, 0x38, 0x30, 0x32, 0x62, 0x39, 0x61, 0x39, 0x38, 0x62, 0x31, 0x39, 0x61, 0x39, 0x63, 0x65, 0x65, 0x36, 0x64, 0x61, 0x38, 0x30, 0x32, 0x38, 0x37, 0x63, 0x36, 0x31, 0x66, 0x36, 0x66, 0x34, 0x61, 0x31, 0x37, 0x35, 0x34, 0x66, 0x34, 0x30, 0x38, 0x62, 0x63, 0x36, 0x39, 0x31, 0x61, 0x63, 0x30, 0x38, 0x34, 0x39, 0x33, 0x31, 0x63, 0x34, 0x63, 0x61, 0x63, 0x31, 0x62, 0x33, 0x37, 0x61, 0x35, 0x66, 0x62, 0x66, 0x61, 0x63, 0x66, 0x36, 0x35, 0x32, 0x38, 0x31, 0x38, 0x36, 0x39, 0x37, 0x35, 0x39, 0x35, 0x33, 0x35, 0x62, 0x63, 0x31, 0x33, 0x38, 0x65, 0x36, 0x37, 0x38, 0x61, 0x64, 0x33, 0x35, 0x63, 0x36, 0x62, 0x36, 0x34, 0x39, 0x61, 0x32, 0x36, 0x31, 0x33, 0x33, 0x33, 0x35, 0x66, 0x64, 0x36, 0x62, 0x63, 0x65, 0x32, 0x61, 0x63, 0x38, 0x30, 0x37, 0x34, 0x30, 0x34, 0x33, 0x30, 0x32, 0x34, 0x35, 0x39, 0x39, 0x62, 0x64, 0x63, 0x34, 0x33, 0x38, 0x64, 0x36, 0x66, 0x31, 0x32, 0x66, 0x66, 0x37, 0x63, 0x35, 0x61, 0x32, 0x39, 0x66, 0x30, 0x63, 0x35, 0x63, 0x36, 0x36, 0x64, 0x66, 0x34, 0x31, 0x39, 0x65, 0x64, 0x64, 0x34, 0x38, 0x30, 0x62, 0x38, 0x31, 0x64, 0x63, 0x35, 0x39, 0x64, 0x38, 0x35, 0x38, 0x61, 0x38, 0x65, 0x65, 0x30, 0x66, 0x35, 0x37, 0x63, 0x65, 0x36, 0x31, 0x37, 0x62, 0x63, 0x63, 0x65, 0x30, 0x64, 0x61, 0x38, 0x31, 0x64, 0x38, 0x31, 0x34, 0x66, 0x31, 0x31, 0x66, 0x30, 0x63, 0x63, 0x30, 0x35, 0x65, 0x39, 0x38, 0x63, 0x30, 0x66, 0x35, 0x39, 0x39, 0x61, 0x35, 0x36, 0x31, 0x37, 0x63, 0x61, 0x35, 0x39, 0x63, 0x35, 0x37, 0x32, 0x62, 0x34, 0x62, 0x38, 0x34, 0x36, 0x38, 0x31, 0x35, 0x37, 0x35, 0x33, 0x38, 0x33, 0x66, 0x31, 0x39, 0x61, 0x32, 0x34, 0x63, 0x39, 0x61, 0x61, 0x64, 0x30, 0x35, 0x31, 0x38, 0x30, 0x66, 0x30, 0x61, 0x35, 0x64, 0x61, 0x38, 0x61, 0x38, 0x32, 0x64, 0x39, 0x64, 0x39, 0x35, 0x66, 0x38, 0x36, 0x31, 0x64, 0x33, 0x30, 0x63, 0x65, 0x39, 0x61, 0x34, 0x64, 0x37, 0x64, 0x38, 0x61, 0x37, 0x31, 0x36, 0x31, 0x33, 0x66, 0x37, 0x35, 0x37, 0x30, 0x36, 0x63, 0x33, 0x61, 0x39, 0x36, 0x38, 0x35, 0x65, 0x32, 0x39, 0x31, 0x61, 0x30, 0x39, 0x62, 0x35, 0x63, 0x63, 0x64, 0x34, 0x34, 0x31, 0x66, 0x61, 0x62, 0x32, 0x64, 0x36, 0x36, 0x36, 0x64, 0x39, 0x64, 0x38, 0x62, 0x34, 0x63, 0x34, 0x64, 0x61, 0x30, 0x66, 0x65, 0x62, 0x64, 0x31, 0x33, 0x62, 0x37, 0x62, 0x65, 0x35, 0x62, 0x37, 0x32, 0x32, 0x64, 0x36, 0x63, 0x65, 0x66, 0x61, 0x64, 0x39, 0x37, 0x37, 0x39, 0x66, 0x62, 0x31, 0x65, 0x39, 0x61, 0x63, 0x62, 0x62, 0x63, 0x34, 0x61, 0x33, 0x34, 0x37, 0x62, 0x33, 0x63, 0x37, 0x30, 0x32, 0x65, 0x30, 0x38, 0x66, 0x36, 0x66, 0x35, 0x35, 0x34, 0x34, 0x37, 0x66, 0x63, 0x32, 0x34, 0x61, 0x66, 0x38, 0x64, 0x61, 0x34, 0x39, 0x66, 0x35, 0x66, 0x63, 0x62, 0x65, 0x34, 0x37, 0x32, 0x66, 0x37, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x33, 0x66, 0x30, 0x33, 0x30, 0x30, 0x35, 0x61, 0x39, 0x61, 0x32, 0x31, 0x62, 0x34, 0x64, 0x66, 0x38, 0x63, 0x32, 0x62, 0x39, 0x33, 0x39, 0x64, 0x63, 0x66, 0x30, 0x35, 0x61, 0x35, 0x30, 0x30, 0x31, 0x35, 0x62, 0x64, 0x37, 0x61, 0x33, 0x66, 0x31, 0x30, 0x63, 0x65, 0x34, 0x38, 0x32, 0x61, 0x63, 0x33, 0x62, 0x33, 0x32, 0x34, 0x37, 0x32, 0x62, 0x39, 0x37, 0x30, 0x61, 0x62, 0x64, 0x63, 0x34, 0x31, 0x33, 0x30, 0x30, 0x63, 0x37, 0x31, 0x62, 0x30, 0x34, 0x30, 0x62, 0x37, 0x39, 0x65, 0x65, 0x33, 0x61, 0x33, 0x30, 0x62, 0x38, 0x63, 0x61, 0x37, 0x35, 0x31, 0x39, 0x33, 0x36, 0x38, 0x37, 0x61, 0x37, 0x36, 0x63, 0x64, 0x66, 0x62, 0x34, 0x66, 0x63, 0x34, 0x39, 0x32, 0x31, 0x38, 0x63, 0x61, 0x37, 0x32, 0x66, 0x64, 0x37, 0x32, 0x34, 0x64, 0x65, 0x65, 0x31, 0x35, 0x61, 0x61, 0x39, 0x61, 0x32, 0x34, 0x62, 0x63, 0x37, 0x38, 0x61, 0x64, 0x37, 0x61, 0x39, 0x37, 0x31, 0x39, 0x33, 0x33, 0x63, 0x65, 0x38, 0x37, 0x66, 0x33, 0x37, 0x33, 0x35, 0x30, 0x35, 0x31, 0x62, 0x64, 0x31, 0x30, 0x33, 0x33, 0x30, 0x34, 0x35, 0x32, 0x64, 0x62, 0x37, 0x38, 0x34, 0x66, 0x38, 0x33, 0x66, 0x66, 0x37, 0x30, 0x62, 0x66, 0x31, 0x30, 0x33, 0x61, 0x30, 0x62, 0x64, 0x36, 0x65, 0x36, 0x33, 0x36, 0x35, 0x39, 0x64, 0x32, 0x31, 0x30, 0x63, 0x33, 0x37, 0x30, 0x39, 0x35, 0x35, 0x61, 0x35, 0x34, 0x63, 0x34, 0x61, 0x63, 0x64, 0x33, 0x30, 0x31, 0x37, 0x66, 0x63, 0x39, 0x38, 0x62, 0x30, 0x64, 0x33, 0x61, 0x65, 0x38, 0x63, 0x35, 0x36, 0x62, 0x33, 0x30, 0x32, 0x36, 0x37, 0x31, 0x39, 0x38, 0x66, 0x36, 0x37, 0x39, 0x37, 0x32, 0x36, 0x33, 0x65, 0x61, 0x36, 0x36, 0x32, 0x34, 0x63, 0x66, 0x61, 0x30, 0x31, 0x35, 0x63, 0x34, 0x66, 0x39, 0x64, 0x32, 0x38, 0x65, 0x35, 0x30, 0x33, 0x32, 0x37, 0x34, 0x36, 0x64, 0x39, 0x33, 0x38, 0x33, 0x33, 0x36, 0x30, 0x63, 0x63, 0x35, 0x30, 0x39, 0x33, 0x38, 0x31, 0x64, 0x64, 0x63, 0x64, 0x61, 0x38, 0x62, 0x34, 0x36, 0x32, 0x36, 0x37, 0x31, 0x64, 0x33, 0x36, 0x39, 0x34, 0x38, 0x30, 0x65, 0x35, 0x32, 0x39, 0x62, 0x38, 0x65, 0x66, 0x34, 0x66, 0x36, 0x65, 0x39, 0x34, 0x63, 0x66, 0x65, 0x31, 0x61, 0x30, 0x34, 0x38, 0x36, 0x64, 0x34, 0x61, 0x65, 0x33, 0x61, 0x38, 0x38, 0x37, 0x31, 0x32, 0x65, 0x39, 0x33, 0x38, 0x35, 0x64, 0x37, 0x65, 0x38, 0x35, 0x38, 0x30, 0x38, 0x39, 0x36, 0x33, 0x35, 0x31, 0x33, 0x37, 0x33, 0x30, 0x39, 0x66, 0x62, 0x37, 0x62, 0x37, 0x32, 0x36, 0x65, 0x35, 0x31, 0x66, 0x31, 0x38, 0x30, 0x61, 0x62, 0x30, 0x39, 0x38, 0x63, 0x37, 0x63, 0x32, 0x62, 0x62, 0x32, 0x66, 0x36, 0x37, 0x36, 0x61, 0x66, 0x36, 0x63, 0x32, 0x63, 0x62, 0x66, 0x34, 0x30, 0x31, 0x37, 0x36, 0x30, 0x64, 0x34, 0x35, 0x32, 0x66, 0x38, 0x66, 0x65, 0x63, 0x30, 0x65, 0x33, 0x30, 0x64, 0x38, 0x39, 0x30, 0x63, 0x37, 0x63, 0x65, 0x64, 0x33, 0x32, 0x30, 0x36, 0x64, 0x37, 0x30, 0x66, 0x66, 0x63, 0x65, 0x38, 0x61, 0x30, 0x35, 0x36, 0x30, 0x30, 0x61, 0x31, 0x66, 0x35, 0x30, 0x66, 0x64, 0x61, 0x33, 0x35, 0x61, 0x64, 0x33, 0x34, 0x30, 0x30, 0x66, 0x38, 0x31, 0x35, 0x34, 0x65, 0x34, 0x65, 0x65, 0x64, 0x62, 0x61, 0x61, 0x33, 0x63, 0x30, 0x38, 0x62, 0x63, 0x64, 0x65, 0x64, 0x63, 0x32, 0x34, 0x30, 0x64, 0x32, 0x63, 0x36, 0x37, 0x36, 0x37, 0x32, 0x30, 0x34, 0x30, 0x30, 0x63, 0x64, 0x66, 0x64, 0x65, 0x64, 0x35, 0x34, 0x61, 0x38, 0x35, 0x63, 0x30, 0x61, 0x61, 0x63, 0x38, 0x66, 0x63, 0x30, 0x38, 0x36, 0x31, 0x31, 0x38, 0x33, 0x32, 0x30, 0x39, 0x30, 0x38, 0x34, 0x66, 0x37, 0x33, 0x33, 0x62, 0x61, 0x66, 0x62, 0x35, 0x63, 0x35, 0x64, 0x65, 0x37, 0x35, 0x62, 0x36, 0x64, 0x30, 0x30, 0x32, 0x64, 0x37, 0x39, 0x61, 0x35, 0x37, 0x32, 0x63, 0x33, 0x63, 0x61, 0x62, 0x65, 0x35, 0x61, 0x38, 0x38, 0x37, 0x38, 0x35, 0x62, 0x62, 0x34, 0x34, 0x66, 0x39, 0x34, 0x64, 0x61, 0x61, 0x61, 0x30, 0x37, 0x34, 0x35, 0x37, 0x62, 0x31, 0x34, 0x63, 0x34, 0x34, 0x63, 0x31, 0x38, 0x65, 0x33, 0x34, 0x31, 0x33, 0x32, 0x64, 0x66, 0x35, 0x37, 0x32, 0x61, 0x38, 0x39, 0x38, 0x63, 0x30, 0x36, 0x38, 0x32, 0x61, 0x31, 0x37, 0x33, 0x37, 0x32, 0x64, 0x63, 0x32, 0x62, 0x65, 0x36, 0x36, 0x34, 0x62, 0x66, 0x64, 0x62, 0x30, 0x66, 0x31, 0x39, 0x61, 0x30, 0x39, 0x30, 0x61, 0x39, 0x31, 0x31, 0x31, 0x34, 0x61, 0x62, 0x64, 0x39, 0x62, 0x38, 0x39, 0x35, 0x66, 0x66, 0x31, 0x64, 0x33, 0x36, 0x65, 0x37, 0x62, 0x37, 0x30, 0x61, 0x31, 0x37, 0x31, 0x37, 0x62, 0x32, 0x30, 0x61, 0x30, 0x39, 0x63, 0x64, 0x66, 0x35, 0x38, 0x32, 0x37, 0x32, 0x38, 0x33, 0x36, 0x32, 0x64, 0x64, 0x63, 0x61, 0x66, 0x64, 0x37, 0x30, 0x33, 0x66, 0x36, 0x36, 0x35, 0x33, 0x62, 0x35, 0x37, 0x37, 0x35, 0x35, 0x61, 0x64, 0x35, 0x62, 0x36, 0x39, 0x38, 0x35, 0x64, 0x64, 0x35, 0x36, 0x33, 0x39, 0x65, 0x62, 0x34, 0x36, 0x63, 0x39, 0x34, 0x37, 0x63, 0x39, 0x31, 0x35, 0x31, 0x64, 0x35, 0x65, 0x39, 0x37, 0x61, 0x61, 0x62, 0x31, 0x63, 0x66, 0x37, 0x32, 0x30, 0x61, 0x66, 0x32, 0x66, 0x63, 0x31, 0x34, 0x64, 0x39, 0x64, 0x37, 0x36, 0x34, 0x61, 0x64, 0x65, 0x61, 0x65, 0x35, 0x38, 0x66, 0x35, 0x63, 0x30, 0x38, 0x30, 0x36, 0x35, 0x66, 0x32, 0x31, 0x64, 0x64, 0x34, 0x63, 0x64, 0x34, 0x65, 0x36, 0x65, 0x34, 0x39, 0x64, 0x33, 0x38, 0x33, 0x31, 0x34, 0x32, 0x36, 0x61, 0x39, 0x33, 0x38, 0x66, 0x61, 0x32, 0x32, 0x33, 0x31, 0x66, 0x34, 0x64, 0x30, 0x30, 0x62, 0x35, 0x37, 0x36, 0x35, 0x35, 0x61, 0x35, 0x36, 0x36, 0x39, 0x64, 0x30, 0x38, 0x39, 0x37, 0x63, 0x65, 0x63, 0x39, 0x35, 0x64, 0x66, 0x30, 0x65, 0x38, 0x61, 0x61, 0x36, 0x61, 0x62, 0x36, 0x35, 0x62, 0x66, 0x63, 0x37, 0x38, 0x65, 0x37, 0x66, 0x34, 0x39, 0x31, 0x35, 0x37, 0x62, 0x33, 0x34, 0x32, 0x62, 0x63, 0x32, 0x61, 0x34, 0x62, 0x61, 0x37, 0x38, 0x66, 0x37, 0x32, 0x66, 0x31, 0x63, 0x34, 0x66, 0x31, 0x33, 0x39, 0x34, 0x35, 0x63, 0x62, 0x63, 0x63, 0x65, 0x39, 0x36, 0x32, 0x39, 0x38, 0x39, 0x64, 0x30, 0x66, 0x31, 0x62, 0x33, 0x64, 0x30, 0x66, 0x32, 0x65, 0x31, 0x62, 0x34, 0x66, 0x34, 0x63, 0x63, 0x36, 0x65, 0x30, 0x37, 0x31, 0x39, 0x37, 0x35, 0x38, 0x31, 0x34, 0x66, 0x34, 0x62, 0x35, 0x61, 0x39, 0x38, 0x38, 0x64, 0x37, 0x30, 0x37, 0x37, 0x32, 0x32, 0x33, 0x61, 0x39, 0x36, 0x64, 0x61, 0x38, 0x61, 0x32, 0x62, 0x63, 0x32, 0x30, 0x62, 0x36, 0x30, 0x37, 0x33, 0x37, 0x35, 0x30, 0x66, 0x36, 0x34, 0x32, 0x39, 0x37, 0x31, 0x31, 0x63, 0x35, 0x30, 0x66, 0x35, 0x39, 0x62, 0x34, 0x61, 0x66, 0x33, 0x36, 0x65, 0x64, 0x36, 0x30, 0x30, 0x66, 0x32, 0x63, 0x63, 0x39, 0x31, 0x30, 0x33, 0x63, 0x31, 0x36, 0x64, 0x37, 0x38, 0x39, 0x30, 0x39, 0x66, 0x65, 0x64, 0x39, 0x35, 0x32, 0x33, 0x34, 0x63, 0x61, 0x38, 0x64, 0x31, 0x38, 0x38, 0x61, 0x31, 0x62, 0x61, 0x34, 0x61, 0x37, 0x30, 0x32, 0x33, 0x33, 0x38, 0x62, 0x32, 0x61, 0x35, 0x32, 0x65, 0x34, 0x35, 0x34, 0x38, 0x61, 0x64, 0x35, 0x36, 0x34, 0x35, 0x61, 0x66, 0x61, 0x32, 0x39, 0x30, 0x61, 0x36, 0x30, 0x34, 0x35, 0x32, 0x38, 0x64, 0x31, 0x30, 0x62, 0x65, 0x38, 0x37, 0x32, 0x65, 0x35, 0x35, 0x31, 0x36, 0x37, 0x37, 0x61, 0x30, 0x62, 0x37, 0x32, 0x63, 0x32, 0x31, 0x33, 0x37, 0x32, 0x66, 0x63, 0x39, 0x39, 0x33, 0x33, 0x30, 0x65, 0x33, 0x31, 0x30, 0x66, 0x34, 0x30, 0x39, 0x30, 0x64, 0x63, 0x37, 0x65, 0x30, 0x39, 0x32, 0x65, 0x37, 0x30, 0x37, 0x38, 0x35, 0x36, 0x64, 0x62, 0x34, 0x34, 0x37, 0x33, 0x30, 0x37, 0x33, 0x33, 0x32, 0x35, 0x37, 0x32, 0x37, 0x32, 0x39, 0x31, 0x33, 0x64, 0x66, 0x65, 0x66, 0x66, 0x62, 0x36, 0x39, 0x38, 0x65, 0x31, 0x35, 0x34, 0x62, 0x33, 0x32, 0x62, 0x61, 0x38, 0x38, 0x66, 0x62, 0x39, 0x34, 0x62, 0x35, 0x65, 0x30, 0x65, 0x64, 0x66, 0x63, 0x35, 0x65, 0x66, 0x61, 0x33, 0x35, 0x31, 0x31, 0x37, 0x37, 0x38, 0x61, 0x61, 0x33, 0x63, 0x62, 0x35, 0x39, 0x61, 0x34, 0x36, 0x39, 0x61, 0x36, 0x63, 0x37, 0x63, 0x37, 0x32, 0x37, 0x63, 0x36, 0x64, 0x33, 0x30, 0x33, 0x64, 0x37, 0x33, 0x63, 0x36, 0x61, 0x36, 0x64, 0x30, 0x64, 0x63, 0x39, 0x31, 0x62, 0x30, 0x61, 0x32, 0x39, 0x36, 0x33, 0x39, 0x64, 0x61, 0x30, 0x37, 0x61, 0x62, 0x36, 0x61, 0x32, 0x39, 0x65, 0x31, 0x30, 0x64, 0x34, 0x62, 0x66, 0x39, 0x65, 0x63, 0x66, 0x33, 0x32, 0x66, 0x37, 0x36, 0x34, 0x34, 0x65, 0x36, 0x66, 0x64, 0x65, 0x33, 0x37, 0x32, 0x33, 0x30, 0x33, 0x30, 0x34, 0x61, 0x62, 0x32, 0x61, 0x32, 0x32, 0x39, 0x63, 0x35, 0x32, 0x33, 0x34, 0x64, 0x36, 0x33, 0x39, 0x32, 0x62, 0x39, 0x61, 0x34, 0x64, 0x62, 0x32, 0x61, 0x61, 0x65, 0x33, 0x34, 0x64, 0x66, 0x62, 0x64, 0x62, 0x65, 0x64, 0x35, 0x63, 0x39, 0x62, 0x38, 0x39, 0x61, 0x61, 0x63, 0x34, 0x61, 0x35, 0x64, 0x66, 0x35, 0x37, 0x38, 0x30, 0x35, 0x34, 0x38, 0x37, 0x32, 0x35, 0x35, 0x63, 0x38, 0x62, 0x33, 0x30, 0x62, 0x62, 0x31, 0x66, 0x62, 0x65, 0x65, 0x37, 0x64, 0x63, 0x30, 0x61, 0x62, 0x34, 0x35, 0x39, 0x62, 0x32, 0x36, 0x30, 0x38, 0x62, 0x65, 0x34, 0x38, 0x64, 0x38, 0x33, 0x32, 0x62, 0x34, 0x33, 0x32, 0x33, 0x64, 0x31, 0x37, 0x66, 0x62, 0x30, 0x66, 0x34, 0x65, 0x64, 0x64, 0x65, 0x61, 0x63, 0x38, 0x61, 0x63, 0x61, 0x62, 0x62, 0x63, 0x33, 0x30, 0x32, 0x34, 0x66, 0x64, 0x36, 0x37, 0x33, 0x31, 0x62, 0x38, 0x66, 0x66, 0x65, 0x32, 0x36, 0x31, 0x39, 0x66, 0x32, 0x35, 0x38, 0x30, 0x31, 0x32, 0x61, 0x65, 0x37, 0x33, 0x66, 0x61, 0x36, 0x62, 0x32, 0x30, 0x32, 0x64, 0x65, 0x66, 0x33, 0x35, 0x34, 0x36, 0x32, 0x30, 0x37, 0x62, 0x63, 0x62, 0x62, 0x65, 0x37, 0x61, 0x36, 0x63, 0x34, 0x33, 0x35, 0x38, 0x39, 0x33, 0x36, 0x36, 0x35, 0x37, 0x30, 0x65, 0x61, 0x31, 0x62, 0x38, 0x37, 0x38, 0x36, 0x30, 0x64, 0x65, 0x36, 0x30, 0x34, 0x35, 0x35, 0x35, 0x64, 0x31, 0x33, 0x61, 0x36, 0x61, 0x63, 0x39, 0x63, 0x34, 0x65, 0x33, 0x34, 0x62, 0x38, 0x32, 0x39, 0x37, 0x30, 0x30, 0x36, 0x30, 0x35, 0x37, 0x33, 0x39, 0x33, 0x30, 0x63, 0x36, 0x38, 0x39, 0x36, 0x34, 0x30, 0x33, 0x36, 0x36, 0x38, 0x61, 0x61, 0x64, 0x30, 0x31, 0x37, 0x32, 0x31, 0x66, 0x64, 0x64, 0x30, 0x62, 0x39, 0x38, 0x65, 0x33, 0x66, 0x62, 0x64, 0x66, 0x65, 0x39, 0x63, 0x65, 0x63, 0x33, 0x61, 0x32, 0x62, 0x64, 0x62, 0x30, 0x63, 0x33, 0x64, 0x63, 0x34, 0x61, 0x65, 0x35, 0x32, 0x35, 0x39, 0x35, 0x32, 0x62, 0x36, 0x37, 0x33, 0x34, 0x39, 0x35, 0x37, 0x30, 0x66, 0x65, 0x37, 0x38, 0x39, 0x38, 0x35, 0x35, 0x38, 0x64, 0x31, 0x31, 0x65, 0x64, 0x37, 0x32, 0x63, 0x31, 0x34, 0x34, 0x31, 0x65, 0x38, 0x35, 0x64, 0x35, 0x39, 0x34, 0x63, 0x35, 0x35, 0x32, 0x37, 0x38, 0x38, 0x33, 0x64, 0x36, 0x37, 0x35, 0x30, 0x32, 0x38, 0x32, 0x32, 0x32, 0x63, 0x33, 0x63, 0x64, 0x36, 0x63, 0x35, 0x31, 0x62, 0x35, 0x34, 0x32, 0x36, 0x33, 0x36, 0x35, 0x65, 0x34, 0x62, 0x38, 0x30, 0x61, 0x36, 0x38, 0x34, 0x66, 0x64, 0x64, 0x64, 0x30, 0x65, 0x38, 0x37, 0x32, 0x31, 0x62, 0x65, 0x34, 0x31, 0x62, 0x35, 0x61, 0x30, 0x64, 0x61, 0x64, 0x38, 0x30, 0x30, 0x36, 0x33, 0x61, 0x64, 0x36, 0x66, 0x33, 0x34, 0x63, 0x34, 0x64, 0x33, 0x34, 0x31, 0x36, 0x66, 0x66, 0x62, 0x30, 0x63, 0x63, 0x31, 0x33, 0x62, 0x38, 0x62, 0x64, 0x30, 0x34, 0x35, 0x65, 0x39, 0x39, 0x66, 0x35, 0x37, 0x37, 0x37, 0x32, 0x35, 0x38, 0x61, 0x35, 0x30, 0x37, 0x38, 0x31, 0x33, 0x32, 0x62, 0x64, 0x64, 0x36, 0x32, 0x31, 0x38, 0x30, 0x62, 0x37, 0x30, 0x62, 0x38, 0x64, 0x33, 0x63, 0x36, 0x34, 0x30, 0x37, 0x35, 0x36, 0x65, 0x39, 0x32, 0x33, 0x64, 0x38, 0x33, 0x38, 0x61, 0x37, 0x34, 0x31, 0x65, 0x30, 0x64, 0x66, 0x39, 0x61, 0x66, 0x66, 0x63, 0x38, 0x35, 0x62, 0x39, 0x38, 0x34, 0x61, 0x62, 0x38, 0x38, 0x65, 0x33, 0x39, 0x62, 0x65, 0x30, 0x65, 0x64, 0x66, 0x32, 0x66, 0x35, 0x33, 0x62, 0x30, 0x64, 0x61, 0x31, 0x65, 0x36, 0x33, 0x32, 0x61, 0x32, 0x66, 0x64, 0x62, 0x38, 0x38, 0x30, 0x64, 0x38, 0x64, 0x33, 0x34, 0x37, 0x62, 0x39, 0x64, 0x61, 0x34, 0x63, 0x33, 0x33, 0x36, 0x64, 0x32, 0x32, 0x35, 0x61, 0x63, 0x66, 0x39, 0x37, 0x33, 0x65, 0x31, 0x66, 0x61, 0x62, 0x35, 0x37, 0x64, 0x66, 0x38, 0x64, 0x61, 0x38, 0x62, 0x65, 0x61, 0x66, 0x63, 0x37, 0x32, 0x31, 0x32, 0x39, 0x61, 0x64, 0x64, 0x38, 0x30, 0x61, 0x37, 0x32, 0x30, 0x35, 0x39, 0x38, 0x35, 0x66, 0x31, 0x32, 0x30, 0x63, 0x31, 0x63, 0x34, 0x66, 0x31, 0x65, 0x66, 0x34, 0x61, 0x38, 0x63, 0x62, 0x34, 0x64, 0x39, 0x66, 0x39, 0x35, 0x61, 0x61, 0x37, 0x65, 0x63, 0x36, 0x36, 0x36, 0x66, 0x61, 0x62, 0x64, 0x39, 0x31, 0x34, 0x36, 0x32, 0x61, 0x37, 0x39, 0x30, 0x32, 0x36, 0x32, 0x62, 0x65, 0x33, 0x36, 0x36, 0x33, 0x65, 0x34, 0x32, 0x32, 0x37, 0x33, 0x31, 0x33, 0x34, 0x37, 0x65, 0x62, 0x35, 0x38, 0x63, 0x32, 0x66, 0x32, 0x39, 0x66, 0x35, 0x64, 0x61, 0x64, 0x33, 0x63, 0x32, 0x31, 0x65, 0x30, 0x62, 0x39, 0x65, 0x32, 0x64, 0x33, 0x61, 0x31, 0x32, 0x64, 0x39, 0x33, 0x63, 0x62, 0x32, 0x61, 0x35, 0x30, 0x64, 0x31, 0x39, 0x66, 0x32, 0x37, 0x35, 0x35, 0x62, 0x30, 0x31, 0x65, 0x33, 0x64, 0x38, 0x31, 0x38, 0x66, 0x33, 0x34, 0x37, 0x33, 0x64, 0x63, 0x64, 0x33, 0x38, 0x66, 0x34, 0x30, 0x34, 0x64, 0x37, 0x30, 0x62, 0x38, 0x37, 0x35, 0x33, 0x34, 0x33, 0x65, 0x33, 0x38, 0x32, 0x66, 0x65, 0x31, 0x32, 0x30, 0x38, 0x36, 0x31, 0x39, 0x65, 0x65, 0x32, 0x63, 0x37, 0x36, 0x37, 0x61, 0x62, 0x39, 0x37, 0x63, 0x33, 0x34, 0x63, 0x39, 0x34, 0x63, 0x62, 0x37, 0x32, 0x62, 0x32, 0x66, 0x33, 0x39, 0x30, 0x61, 0x66, 0x62, 0x39, 0x61, 0x39, 0x38, 0x64, 0x38, 0x35, 0x63, 0x61, 0x39, 0x64, 0x33, 0x30, 0x64, 0x30, 0x35, 0x62, 0x30, 0x30, 0x36, 0x65, 0x39, 0x62, 0x63, 0x39, 0x30, 0x64, 0x63, 0x34, 0x33, 0x34, 0x65, 0x34, 0x30, 0x63, 0x61, 0x35, 0x66, 0x38, 0x35, 0x35, 0x38, 0x31, 0x34, 0x65, 0x35, 0x38, 0x39, 0x39, 0x62, 0x35, 0x30, 0x38, 0x32, 0x30, 0x66, 0x37, 0x38, 0x62, 0x31, 0x36, 0x61, 0x64, 0x61, 0x38, 0x33, 0x62, 0x36, 0x61, 0x38, 0x66, 0x31, 0x66, 0x38, 0x30, 0x30, 0x35, 0x38, 0x62, 0x36, 0x64, 0x35, 0x65, 0x33, 0x37, 0x64, 0x64, 0x64, 0x33, 0x61, 0x34, 0x62, 0x66, 0x65, 0x39, 0x39, 0x65, 0x33, 0x37, 0x38, 0x36, 0x66, 0x63, 0x32, 0x37, 0x34, 0x32, 0x63, 0x32, 0x34, 0x37, 0x34, 0x32, 0x37, 0x33, 0x35, 0x34, 0x32, 0x35, 0x33, 0x34, 0x65, 0x30, 0x66, 0x63, 0x35, 0x34, 0x65, 0x30, 0x62, 0x62, 0x36, 0x33, 0x61, 0x63, 0x30, 0x39, 0x61, 0x30, 0x33, 0x39, 0x36, 0x34, 0x35, 0x35, 0x66, 0x64, 0x62, 0x35, 0x65, 0x35, 0x32, 0x36, 0x39, 0x32, 0x32, 0x63, 0x66, 0x34, 0x31, 0x36, 0x33, 0x35, 0x31, 0x34, 0x64, 0x33, 0x61, 0x31, 0x37, 0x38, 0x65, 0x65, 0x62, 0x65, 0x65, 0x31, 0x37, 0x33, 0x34, 0x39, 0x37, 0x32, 0x39, 0x32, 0x31, 0x66, 0x30, 0x39, 0x32, 0x62, 0x35, 0x39, 0x32, 0x33, 0x35, 0x37, 0x30, 0x32, 0x31, 0x63, 0x38, 0x38, 0x34, 0x34, 0x32, 0x31, 0x30, 0x37, 0x66, 0x61, 0x31, 0x39, 0x64, 0x35, 0x63, 0x63, 0x31, 0x35, 0x62, 0x36, 0x31, 0x64, 0x34, 0x37, 0x33, 0x66, 0x32, 0x39, 0x63, 0x33, 0x38, 0x33, 0x32, 0x61, 0x34, 0x39, 0x64, 0x35, 0x32, 0x62, 0x65, 0x62, 0x66, 0x61, 0x37, 0x32, 0x34, 0x35, 0x33, 0x35, 0x33, 0x61, 0x35, 0x66, 0x35, 0x38, 0x64, 0x37, 0x37, 0x62, 0x61, 0x31, 0x38, 0x62, 0x37, 0x37, 0x37, 0x32, 0x34, 0x66, 0x30, 0x32, 0x66, 0x30, 0x37, 0x36, 0x65, 0x35, 0x63, 0x63, 0x64, 0x33, 0x63, 0x63, 0x38, 0x61, 0x39, 0x61, 0x64, 0x66, 0x64, 0x62, 0x30, 0x62, 0x32, 0x30, 0x64, 0x66, 0x34, 0x34, 0x62, 0x61, 0x38, 0x31, 0x36, 0x35, 0x61, 0x61, 0x37, 0x32, 0x35, 0x63, 0x36, 0x37, 0x30, 0x37, 0x64, 0x34, 0x38, 0x32, 0x31, 0x38, 0x33, 0x38, 0x65, 0x66, 0x35, 0x30, 0x38, 0x34, 0x39, 0x36, 0x32, 0x35, 0x62, 0x65, 0x34, 0x31, 0x34, 0x62, 0x30, 0x62, 0x31, 0x31, 0x35, 0x64, 0x64, 0x65, 0x61, 0x37, 0x36, 0x62, 0x30, 0x66, 0x62, 0x32, 0x66, 0x36, 0x34, 0x30, 0x65, 0x30, 0x35, 0x35, 0x66, 0x61, 0x61, 0x64, 0x35, 0x37, 0x30, 0x36, 0x34, 0x65, 0x65, 0x33, 0x32, 0x37, 0x32, 0x37, 0x61, 0x63, 0x61, 0x65, 0x66, 0x65, 0x33, 0x39, 0x38, 0x36, 0x64, 0x61, 0x65, 0x30, 0x31, 0x61, 0x33, 0x66, 0x64, 0x35, 0x63, 0x31, 0x36, 0x66, 0x30, 0x61, 0x33, 0x30, 0x38, 0x32, 0x35, 0x34, 0x32, 0x37, 0x32, 0x32, 0x61, 0x37, 0x37, 0x65, 0x37, 0x33, 0x34, 0x66, 0x37, 0x65, 0x30, 0x33, 0x39, 0x62, 0x63, 0x34, 0x38, 0x36, 0x37, 0x30, 0x37, 0x32, 0x39, 0x37, 0x31, 0x31, 0x64, 0x32, 0x34, 0x38, 0x61, 0x35, 0x38, 0x37, 0x61, 0x35, 0x30, 0x38, 0x63, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x31, 0x37, 0x30, 0x37, 0x63, 0x39, 0x37, 0x65, 0x62, 0x33, 0x62, 0x38, 0x65, 0x63, 0x65, 0x62, 0x63, 0x63, 0x33, 0x63, 0x66, 0x33, 0x35, 0x30, 0x30, 0x61, 0x33, 0x66, 0x32, 0x32, 0x62, 0x65, 0x37, 0x34, 0x36, 0x30, 0x33, 0x63, 0x38, 0x37, 0x32, 0x34, 0x32, 0x61, 0x38, 0x65, 0x36, 0x38, 0x61, 0x64, 0x35, 0x65, 0x36, 0x63, 0x62, 0x33, 0x31, 0x61, 0x66, 0x39, 0x30, 0x32, 0x39, 0x65, 0x36, 0x31, 0x66, 0x36, 0x35, 0x38, 0x30, 0x65, 0x63, 0x38, 0x33, 0x65, 0x63, 0x34, 0x32, 0x36, 0x35, 0x32, 0x31, 0x63, 0x65, 0x63, 0x35, 0x37, 0x62, 0x36, 0x66, 0x36, 0x64, 0x33, 0x32, 0x34, 0x31, 0x35, 0x35, 0x61, 0x38, 0x62, 0x65, 0x31, 0x35, 0x66, 0x35, 0x31, 0x30, 0x39, 0x65, 0x64, 0x36, 0x34, 0x63, 0x36, 0x65, 0x30, 0x66, 0x34, 0x35, 0x62, 0x61, 0x30, 0x36, 0x35, 0x33, 0x37, 0x30, 0x61, 0x30, 0x64, 0x31, 0x31, 0x36, 0x38, 0x37, 0x65, 0x32, 0x36, 0x31, 0x64, 0x30, 0x34, 0x34, 0x61, 0x65, 0x31, 0x34, 0x61, 0x35, 0x65, 0x38, 0x66, 0x37, 0x34, 0x65, 0x62, 0x64, 0x63, 0x37, 0x62, 0x65, 0x38, 0x37, 0x39, 0x64, 0x37, 0x32, 0x34, 0x37, 0x38, 0x62, 0x61, 0x64, 0x38, 0x62, 0x64, 0x65, 0x34, 0x38, 0x38, 0x64, 0x61, 0x35, 0x37, 0x35, 0x38, 0x33, 0x61, 0x38, 0x34, 0x34, 0x34, 0x30, 0x64, 0x30, 0x38, 0x33, 0x37, 0x38, 0x66, 0x32, 0x39, 0x62, 0x30, 0x62, 0x35, 0x39, 0x36, 0x37, 0x32, 0x39, 0x63, 0x34, 0x34, 0x33, 0x35, 0x65, 0x66, 0x32, 0x65, 0x61, 0x66, 0x64, 0x34, 0x37, 0x64, 0x66, 0x65, 0x33, 0x34, 0x37, 0x62, 0x61, 0x32, 0x32, 0x64, 0x35, 0x65, 0x30, 0x34, 0x64, 0x38, 0x63, 0x38, 0x61, 0x33, 0x31, 0x61, 0x65, 0x64, 0x37, 0x38, 0x38, 0x33, 0x30, 0x37, 0x36, 0x65, 0x31, 0x36, 0x38, 0x63, 0x63, 0x63, 0x32, 0x38, 0x64, 0x30, 0x36, 0x33, 0x36, 0x61, 0x38, 0x66, 0x66, 0x65, 0x63, 0x66, 0x39, 0x63, 0x34, 0x30, 0x38, 0x38, 0x35, 0x61, 0x37, 0x32, 0x30, 0x33, 0x37, 0x39, 0x32, 0x37, 0x32, 0x34, 0x36, 0x34, 0x39, 0x31, 0x66, 0x30, 0x38, 0x36, 0x62, 0x31, 0x33, 0x38, 0x63, 0x63, 0x62, 0x30, 0x34, 0x66, 0x30, 0x31, 0x63, 0x37, 0x30, 0x39, 0x35, 0x64, 0x34, 0x66, 0x34, 0x39, 0x66, 0x36, 0x31, 0x61, 0x33, 0x65, 0x62, 0x39, 0x64, 0x33, 0x39, 0x31, 0x63, 0x35, 0x66, 0x61, 0x61, 0x33, 0x30, 0x34, 0x33, 0x39, 0x32, 0x63, 0x35, 0x62, 0x36, 0x34, 0x30, 0x31, 0x33, 0x37, 0x32, 0x62, 0x66, 0x61, 0x38, 0x61, 0x32, 0x34, 0x66, 0x63, 0x36, 0x61, 0x30, 0x38, 0x39, 0x61, 0x38, 0x62, 0x61, 0x66, 0x39, 0x30, 0x38, 0x39, 0x35, 0x31, 0x61, 0x62, 0x39, 0x63, 0x33, 0x36, 0x35, 0x65, 0x33, 0x63, 0x61, 0x61, 0x64, 0x38, 0x30, 0x66, 0x35, 0x61, 0x35, 0x62, 0x65, 0x30, 0x63, 0x62, 0x64, 0x62, 0x38, 0x38, 0x34, 0x66, 0x31, 0x34, 0x64, 0x36, 0x38, 0x37, 0x37, 0x37, 0x32, 0x32, 0x62, 0x36, 0x31, 0x31, 0x62, 0x38, 0x37, 0x33, 0x38, 0x39, 0x33, 0x33, 0x34, 0x61, 0x66, 0x38, 0x61, 0x31, 0x34, 0x37, 0x36, 0x66, 0x32, 0x63, 0x61, 0x62, 0x37, 0x62, 0x32, 0x35, 0x65, 0x39, 0x63, 0x61, 0x32, 0x32, 0x34, 0x32, 0x62, 0x62, 0x31, 0x31, 0x33, 0x64, 0x37, 0x37, 0x64, 0x38, 0x32, 0x62, 0x63, 0x64, 0x36, 0x30, 0x34, 0x32, 0x30, 0x31, 0x63, 0x34, 0x37, 0x32, 0x34, 0x35, 0x32, 0x66, 0x39, 0x31, 0x34, 0x38, 0x36, 0x36, 0x33, 0x66, 0x66, 0x62, 0x33, 0x34, 0x61, 0x38, 0x65, 0x61, 0x64, 0x31, 0x33, 0x63, 0x64, 0x61, 0x39, 0x38, 0x65, 0x61, 0x38, 0x32, 0x31, 0x35, 0x35, 0x37, 0x36, 0x38, 0x36, 0x31, 0x38, 0x35, 0x34, 0x35, 0x30, 0x64, 0x63, 0x62, 0x37, 0x39, 0x36, 0x39, 0x38, 0x37, 0x66, 0x36, 0x31, 0x31, 0x30, 0x63, 0x64, 0x62, 0x38, 0x37, 0x32, 0x66, 0x61, 0x61, 0x36, 0x31, 0x37, 0x32, 0x61, 0x62, 0x34, 0x30, 0x31, 0x63, 0x35, 0x31, 0x65, 0x33, 0x66, 0x66, 0x35, 0x62, 0x62, 0x34, 0x36, 0x35, 0x38, 0x31, 0x35, 0x33, 0x34, 0x39, 0x36, 0x36, 0x64, 0x34, 0x33, 0x65, 0x30, 0x37, 0x37, 0x33, 0x33, 0x66, 0x34, 0x37, 0x63, 0x63, 0x39, 0x34, 0x35, 0x66, 0x30, 0x61, 0x63, 0x38, 0x36, 0x63, 0x35, 0x33, 0x36, 0x63, 0x30, 0x36, 0x32, 0x66, 0x62, 0x37, 0x62, 0x63, 0x61, 0x37, 0x66, 0x38, 0x36, 0x37, 0x37, 0x33, 0x39, 0x65, 0x32, 0x31, 0x63, 0x65, 0x64, 0x62, 0x38, 0x66, 0x35, 0x61, 0x32, 0x65, 0x37, 0x30, 0x38, 0x31, 0x34, 0x33, 0x63, 0x34, 0x65, 0x62, 0x38, 0x65, 0x64, 0x38, 0x61, 0x32, 0x65, 0x30, 0x34, 0x31, 0x39, 0x36, 0x65, 0x31, 0x62, 0x38, 0x66, 0x65, 0x62, 0x34, 0x35, 0x30, 0x36, 0x39, 0x37, 0x35, 0x65, 0x62, 0x38, 0x32, 0x30, 0x35, 0x65, 0x66, 0x36, 0x33, 0x35, 0x65, 0x38, 0x66, 0x61, 0x61, 0x66, 0x62, 0x64, 0x35, 0x63, 0x65, 0x66, 0x38, 0x33, 0x30, 0x62, 0x66, 0x66, 0x66, 0x38, 0x30, 0x63, 0x61, 0x34, 0x33, 0x63, 0x63, 0x38, 0x34, 0x36, 0x37, 0x33, 0x30, 0x64, 0x33, 0x35, 0x65, 0x33, 0x35, 0x61, 0x64, 0x32, 0x61, 0x39, 0x31, 0x34, 0x65, 0x35, 0x37, 0x32, 0x65, 0x31, 0x37, 0x32, 0x63, 0x37, 0x33, 0x39, 0x65, 0x31, 0x38, 0x31, 0x61, 0x62, 0x39, 0x63, 0x36, 0x61, 0x62, 0x65, 0x63, 0x35, 0x31, 0x63, 0x30, 0x33, 0x33, 0x66, 0x37, 0x62, 0x64, 0x62, 0x62, 0x37, 0x63, 0x63, 0x37, 0x63, 0x63, 0x30, 0x30, 0x30, 0x39, 0x63, 0x33, 0x35, 0x33, 0x39, 0x66, 0x65, 0x35, 0x34, 0x34, 0x32, 0x36, 0x30, 0x65, 0x65, 0x64, 0x39, 0x39, 0x32, 0x31, 0x39, 0x30, 0x33, 0x37, 0x32, 0x63, 0x37, 0x37, 0x32, 0x65, 0x63, 0x33, 0x64, 0x65, 0x63, 0x30, 0x31, 0x65, 0x65, 0x37, 0x31, 0x38, 0x34, 0x34, 0x34, 0x30, 0x37, 0x35, 0x30, 0x32, 0x65, 0x38, 0x30, 0x66, 0x63, 0x39, 0x33, 0x37, 0x35, 0x39, 0x64, 0x36, 0x64, 0x39, 0x37, 0x66, 0x35, 0x33, 0x65, 0x63, 0x64, 0x31, 0x32, 0x31, 0x30, 0x38, 0x38, 0x31, 0x39, 0x38, 0x38, 0x36, 0x65, 0x36, 0x30, 0x61, 0x39, 0x37, 0x32, 0x32, 0x36, 0x37, 0x65, 0x64, 0x61, 0x61, 0x31, 0x33, 0x30, 0x39, 0x64, 0x31, 0x64, 0x33, 0x38, 0x62, 0x33, 0x38, 0x39, 0x31, 0x30, 0x66, 0x31, 0x35, 0x62, 0x31, 0x63, 0x35, 0x65, 0x33, 0x38, 0x37, 0x35, 0x62, 0x38, 0x30, 0x65, 0x65, 0x33, 0x32, 0x32, 0x64, 0x37, 0x39, 0x63, 0x35, 0x66, 0x61, 0x34, 0x34, 0x34, 0x35, 0x39, 0x30, 0x31, 0x32, 0x66, 0x39, 0x31, 0x38, 0x31, 0x37, 0x32, 0x32, 0x63, 0x34, 0x62, 0x66, 0x66, 0x30, 0x37, 0x64, 0x61, 0x35, 0x33, 0x66, 0x39, 0x66, 0x37, 0x37, 0x65, 0x35, 0x30, 0x31, 0x35, 0x34, 0x65, 0x36, 0x34, 0x61, 0x63, 0x31, 0x64, 0x31, 0x39, 0x39, 0x65, 0x66, 0x66, 0x38, 0x64, 0x62, 0x34, 0x64, 0x38, 0x64, 0x30, 0x66, 0x39, 0x35, 0x30, 0x65, 0x30, 0x34, 0x33, 0x63, 0x36, 0x35, 0x66, 0x63, 0x63, 0x37, 0x62, 0x31, 0x35, 0x37, 0x32, 0x38, 0x66, 0x65, 0x38, 0x61, 0x64, 0x36, 0x64, 0x32, 0x30, 0x61, 0x30, 0x64, 0x61, 0x62, 0x64, 0x33, 0x37, 0x39, 0x38, 0x65, 0x64, 0x63, 0x65, 0x31, 0x61, 0x30, 0x36, 0x36, 0x30, 0x38, 0x31, 0x31, 0x33, 0x33, 0x63, 0x66, 0x65, 0x64, 0x35, 0x37, 0x38, 0x33, 0x37, 0x38, 0x36, 0x36, 0x64, 0x63, 0x33, 0x39, 0x31, 0x36, 0x63, 0x33, 0x63, 0x32, 0x38, 0x35, 0x36, 0x61, 0x37, 0x37, 0x32, 0x31, 0x65, 0x34, 0x35, 0x63, 0x32, 0x37, 0x35, 0x35, 0x32, 0x32, 0x32, 0x30, 0x32, 0x64, 0x34, 0x34, 0x36, 0x66, 0x32, 0x39, 0x62, 0x34, 0x35, 0x66, 0x37, 0x34, 0x32, 0x33, 0x61, 0x65, 0x65, 0x32, 0x31, 0x34, 0x63, 0x31, 0x34, 0x66, 0x36, 0x30, 0x66, 0x30, 0x63, 0x38, 0x62, 0x66, 0x65, 0x64, 0x65, 0x30, 0x62, 0x66, 0x32, 0x34, 0x35, 0x35, 0x31, 0x61, 0x35, 0x38, 0x33, 0x37, 0x32, 0x65, 0x36, 0x33, 0x39, 0x34, 0x30, 0x31, 0x63, 0x36, 0x64, 0x66, 0x34, 0x36, 0x37, 0x39, 0x64, 0x32, 0x31, 0x66, 0x63, 0x61, 0x35, 0x32, 0x65, 0x65, 0x66, 0x32, 0x34, 0x65, 0x30, 0x64, 0x64, 0x66, 0x33, 0x38, 0x30, 0x36, 0x34, 0x32, 0x66, 0x31, 0x63, 0x63, 0x33, 0x36, 0x35, 0x36, 0x66, 0x31, 0x31, 0x30, 0x65, 0x37, 0x38, 0x37, 0x61, 0x32, 0x36, 0x65, 0x64, 0x35, 0x36, 0x33, 0x36, 0x61, 0x34, 0x65, 0x30, 0x66, 0x61, 0x35, 0x32, 0x35, 0x39, 0x37, 0x33, 0x31, 0x35, 0x36, 0x32, 0x31, 0x61, 0x33, 0x63, 0x32, 0x35, 0x33, 0x39, 0x64, 0x33, 0x37, 0x62, 0x32, 0x62, 0x36, 0x38, 0x62, 0x39, 0x63, 0x31, 0x34, 0x36, 0x65, 0x35, 0x32, 0x39, 0x35, 0x63, 0x36, 0x30, 0x64, 0x61, 0x30, 0x33, 0x64, 0x37, 0x61, 0x30, 0x62, 0x31, 0x66, 0x32, 0x34, 0x33, 0x37, 0x32, 0x36, 0x61, 0x64, 0x32, 0x36, 0x37, 0x33, 0x30, 0x61, 0x30, 0x35, 0x38, 0x66, 0x38, 0x37, 0x63, 0x32, 0x65, 0x39, 0x62, 0x39, 0x33, 0x64, 0x31, 0x62, 0x33, 0x37, 0x32, 0x38, 0x63, 0x64, 0x32, 0x31, 0x31, 0x37, 0x65, 0x64, 0x38, 0x66, 0x35, 0x63, 0x61, 0x63, 0x33, 0x66, 0x63, 0x66, 0x64, 0x33, 0x31, 0x64, 0x65, 0x61, 0x33, 0x66, 0x38, 0x34, 0x36, 0x33, 0x65, 0x66, 0x64, 0x66, 0x37, 0x37, 0x32, 0x39, 0x32, 0x34, 0x34, 0x62, 0x36, 0x39, 0x31, 0x63, 0x37, 0x63, 0x63, 0x38, 0x64, 0x31, 0x65, 0x39, 0x33, 0x34, 0x39, 0x37, 0x61, 0x35, 0x63, 0x30, 0x37, 0x66, 0x39, 0x30, 0x62, 0x64, 0x62, 0x33, 0x36, 0x65, 0x39, 0x39, 0x37, 0x63, 0x31, 0x36, 0x63, 0x62, 0x30, 0x38, 0x33, 0x35, 0x31, 0x37, 0x61, 0x64, 0x31, 0x30, 0x65, 0x66, 0x32, 0x37, 0x32, 0x63, 0x61, 0x61, 0x39, 0x31, 0x31, 0x35, 0x37, 0x31, 0x31, 0x34, 0x35, 0x38, 0x33, 0x64, 0x33, 0x30, 0x35, 0x35, 0x38, 0x62, 0x66, 0x62, 0x66, 0x39, 0x66, 0x64, 0x35, 0x66, 0x32, 0x63, 0x35, 0x62, 0x35, 0x62, 0x63, 0x30, 0x33, 0x33, 0x61, 0x30, 0x66, 0x64, 0x36, 0x66, 0x66, 0x37, 0x35, 0x32, 0x63, 0x38, 0x32, 0x32, 0x63, 0x62, 0x66, 0x39, 0x32, 0x39, 0x64, 0x31, 0x65, 0x35, 0x62, 0x39, 0x62, 0x66, 0x33, 0x36, 0x36, 0x32, 0x39, 0x38, 0x30, 0x64, 0x61, 0x32, 0x61, 0x35, 0x63, 0x34, 0x62, 0x38, 0x30, 0x66, 0x32, 0x64, 0x62, 0x62, 0x39, 0x39, 0x39, 0x35, 0x31, 0x34, 0x64, 0x30, 0x33, 0x65, 0x36, 0x33, 0x63, 0x39, 0x39, 0x32, 0x35, 0x33, 0x38, 0x63, 0x34, 0x32, 0x64, 0x61, 0x36, 0x33, 0x31, 0x63, 0x32, 0x36, 0x63, 0x39, 0x36, 0x36, 0x65, 0x39, 0x38, 0x66, 0x37, 0x33, 0x37, 0x32, 0x61, 0x37, 0x32, 0x37, 0x62, 0x31, 0x66, 0x65, 0x37, 0x31, 0x30, 0x34, 0x65, 0x35, 0x39, 0x35, 0x36, 0x62, 0x64, 0x36, 0x35, 0x33, 0x62, 0x36, 0x61, 0x34, 0x31, 0x35, 0x32, 0x38, 0x39, 0x35, 0x63, 0x35, 0x62, 0x34, 0x36, 0x61, 0x65, 0x66, 0x38, 0x66, 0x61, 0x66, 0x37, 0x34, 0x30, 0x36, 0x63, 0x65, 0x64, 0x64, 0x65, 0x63, 0x65, 0x65, 0x61, 0x37, 0x38, 0x36, 0x38, 0x30, 0x36, 0x63, 0x65, 0x30, 0x35, 0x35, 0x33, 0x30, 0x66, 0x62, 0x66, 0x63, 0x62, 0x30, 0x66, 0x31, 0x38, 0x66, 0x32, 0x65, 0x39, 0x38, 0x38, 0x39, 0x37, 0x66, 0x64, 0x36, 0x32, 0x30, 0x30, 0x65, 0x38, 0x31, 0x39, 0x66, 0x38, 0x36, 0x35, 0x65, 0x39, 0x31, 0x30, 0x63, 0x31, 0x31, 0x66, 0x37, 0x66, 0x36, 0x62, 0x66, 0x39, 0x33, 0x36, 0x62, 0x39, 0x36, 0x62, 0x30, 0x64, 0x37, 0x66, 0x31, 0x37, 0x31, 0x39, 0x37, 0x32, 0x66, 0x65, 0x32, 0x33, 0x64, 0x34, 0x39, 0x35, 0x31, 0x64, 0x66, 0x30, 0x64, 0x31, 0x39, 0x36, 0x38, 0x39, 0x34, 0x30, 0x65, 0x39, 0x38, 0x38, 0x65, 0x66, 0x34, 0x63, 0x35, 0x31, 0x64, 0x38, 0x36, 0x30, 0x38, 0x66, 0x66, 0x35, 0x39, 0x63, 0x30, 0x37, 0x33, 0x36, 0x32, 0x61, 0x63, 0x31, 0x64, 0x38, 0x32, 0x65, 0x35, 0x38, 0x36, 0x64, 0x62, 0x61, 0x65, 0x38, 0x38, 0x31, 0x37, 0x32, 0x37, 0x32, 0x39, 0x30, 0x31, 0x61, 0x35, 0x61, 0x63, 0x62, 0x39, 0x30, 0x36, 0x61, 0x38, 0x32, 0x37, 0x65, 0x61, 0x35, 0x66, 0x32, 0x30, 0x35, 0x30, 0x37, 0x38, 0x63, 0x37, 0x35, 0x34, 0x62, 0x35, 0x63, 0x39, 0x63, 0x36, 0x62, 0x30, 0x63, 0x35, 0x64, 0x39, 0x33, 0x66, 0x62, 0x38, 0x66, 0x61, 0x37, 0x65, 0x30, 0x31, 0x66, 0x36, 0x39, 0x64, 0x33, 0x66, 0x63, 0x66, 0x39, 0x36, 0x32, 0x37, 0x64, 0x64, 0x33, 0x65, 0x32, 0x65, 0x34, 0x34, 0x35, 0x64, 0x62, 0x33, 0x32, 0x65, 0x66, 0x35, 0x62, 0x62, 0x35, 0x64, 0x62, 0x64, 0x36, 0x30, 0x37, 0x38, 0x32, 0x31, 0x62, 0x32, 0x66, 0x38, 0x36, 0x36, 0x65, 0x35, 0x33, 0x62, 0x38, 0x63, 0x31, 0x31, 0x39, 0x63, 0x62, 0x35, 0x30, 0x39, 0x37, 0x33, 0x38, 0x37, 0x37, 0x32, 0x39, 0x32, 0x36, 0x37, 0x66, 0x32, 0x34, 0x32, 0x32, 0x66, 0x32, 0x62, 0x66, 0x38, 0x63, 0x35, 0x39, 0x32, 0x32, 0x39, 0x31, 0x63, 0x37, 0x65, 0x38, 0x37, 0x31, 0x33, 0x35, 0x64, 0x39, 0x65, 0x34, 0x31, 0x63, 0x32, 0x35, 0x61, 0x30, 0x63, 0x30, 0x31, 0x39, 0x36, 0x64, 0x35, 0x31, 0x37, 0x65, 0x34, 0x66, 0x31, 0x37, 0x31, 0x62, 0x32, 0x35, 0x62, 0x62, 0x63, 0x36, 0x62, 0x61, 0x32, 0x36, 0x66, 0x38, 0x39, 0x33, 0x32, 0x38, 0x37, 0x32, 0x34, 0x61, 0x62, 0x63, 0x32, 0x65, 0x37, 0x61, 0x39, 0x63, 0x30, 0x39, 0x31, 0x31, 0x37, 0x30, 0x62, 0x31, 0x66, 0x30, 0x61, 0x62, 0x39, 0x61, 0x33, 0x30, 0x35, 0x66, 0x31, 0x63, 0x32, 0x63, 0x38, 0x35, 0x36, 0x62, 0x66, 0x65, 0x64, 0x37, 0x65, 0x66, 0x31, 0x64, 0x63, 0x36, 0x38, 0x34, 0x66, 0x35, 0x37, 0x64, 0x65, 0x34, 0x61, 0x63, 0x34, 0x66, 0x34, 0x33, 0x34, 0x34, 0x37, 0x32, 0x62, 0x64, 0x64, 0x37, 0x34, 0x35, 0x35, 0x32, 0x35, 0x62, 0x64, 0x65, 0x62, 0x62, 0x30, 0x66, 0x37, 0x66, 0x62, 0x65, 0x63, 0x62, 0x66, 0x63, 0x61, 0x61, 0x37, 0x30, 0x38, 0x33, 0x65, 0x32, 0x38, 0x36, 0x31, 0x35, 0x61, 0x33, 0x36, 0x61, 0x33, 0x66, 0x33, 0x31, 0x31, 0x34, 0x38, 0x63, 0x63, 0x64, 0x31, 0x63, 0x64, 0x61, 0x33, 0x31, 0x36, 0x36, 0x35, 0x63, 0x64, 0x34, 0x37, 0x32, 0x38, 0x62, 0x66, 0x35, 0x33, 0x37, 0x36, 0x33, 0x38, 0x37, 0x37, 0x32, 0x66, 0x64, 0x38, 0x66, 0x36, 0x65, 0x38, 0x65, 0x64, 0x66, 0x32, 0x66, 0x64, 0x63, 0x32, 0x30, 0x63, 0x36, 0x63, 0x33, 0x63, 0x30, 0x32, 0x63, 0x61, 0x66, 0x31, 0x36, 0x36, 0x63, 0x30, 0x65, 0x36, 0x32, 0x66, 0x61, 0x35, 0x36, 0x31, 0x62, 0x34, 0x35, 0x30, 0x36, 0x37, 0x33, 0x37, 0x36, 0x39, 0x32, 0x34, 0x36, 0x37, 0x31, 0x63, 0x62, 0x61, 0x32, 0x35, 0x35, 0x36, 0x34, 0x32, 0x63, 0x63, 0x30, 0x36, 0x31, 0x33, 0x31, 0x64, 0x34, 0x30, 0x33, 0x30, 0x39, 0x35, 0x35, 0x33, 0x36, 0x31, 0x62, 0x38, 0x39, 0x65, 0x62, 0x64, 0x64, 0x63, 0x62, 0x62, 0x31, 0x64, 0x34, 0x32, 0x35, 0x30, 0x62, 0x35, 0x61, 0x35, 0x63, 0x35, 0x31, 0x61, 0x37, 0x32, 0x63, 0x63, 0x64, 0x31, 0x33, 0x39, 0x33, 0x37, 0x32, 0x33, 0x64, 0x34, 0x65, 0x63, 0x33, 0x32, 0x62, 0x38, 0x38, 0x31, 0x34, 0x34, 0x31, 0x62, 0x66, 0x66, 0x33, 0x66, 0x64, 0x39, 0x37, 0x35, 0x65, 0x62, 0x35, 0x32, 0x65, 0x36, 0x31, 0x65, 0x37, 0x37, 0x64, 0x37, 0x63, 0x65, 0x38, 0x34, 0x31, 0x63, 0x30, 0x30, 0x34, 0x39, 0x65, 0x66, 0x37, 0x30, 0x33, 0x63, 0x39, 0x64, 0x63, 0x63, 0x32, 0x61, 0x38, 0x32, 0x37, 0x64, 0x39, 0x37, 0x32, 0x35, 0x33, 0x32, 0x62, 0x61, 0x36, 0x36, 0x64, 0x36, 0x34, 0x39, 0x31, 0x39, 0x37, 0x37, 0x39, 0x36, 0x31, 0x33, 0x65, 0x39, 0x38, 0x37, 0x39, 0x63, 0x38, 0x32, 0x37, 0x35, 0x63, 0x62, 0x36, 0x66, 0x62, 0x65, 0x66, 0x32, 0x39, 0x66, 0x31, 0x62, 0x39, 0x30, 0x65, 0x35, 0x39, 0x66, 0x63, 0x32, 0x37, 0x38, 0x35, 0x62, 0x63, 0x63, 0x66, 0x38, 0x37, 0x65, 0x62, 0x62, 0x38, 0x37, 0x32, 0x35, 0x66, 0x62, 0x61, 0x65, 0x33, 0x61, 0x66, 0x34, 0x66, 0x33, 0x62, 0x36, 0x30, 0x64, 0x63, 0x32, 0x33, 0x32, 0x62, 0x31, 0x32, 0x32, 0x65, 0x62, 0x32, 0x32, 0x66, 0x37, 0x66, 0x63, 0x31, 0x65, 0x32, 0x64, 0x38, 0x34, 0x31, 0x61, 0x34, 0x65, 0x39, 0x38, 0x38, 0x66, 0x39, 0x34, 0x37, 0x31, 0x31, 0x37, 0x66, 0x66, 0x31, 0x66, 0x37, 0x36, 0x36, 0x36, 0x31, 0x37, 0x64, 0x37, 0x32, 0x33, 0x32, 0x64, 0x65, 0x32, 0x33, 0x33, 0x62, 0x37, 0x36, 0x34, 0x37, 0x38, 0x30, 0x37, 0x30, 0x65, 0x33, 0x34, 0x34, 0x62, 0x66, 0x30, 0x30, 0x38, 0x66, 0x34, 0x36, 0x61, 0x33, 0x63, 0x37, 0x33, 0x33, 0x63, 0x35, 0x34, 0x63, 0x33, 0x62, 0x31, 0x32, 0x66, 0x30, 0x36, 0x31, 0x33, 0x30, 0x64, 0x31, 0x38, 0x34, 0x62, 0x61, 0x38, 0x39, 0x34, 0x65, 0x39, 0x37, 0x66, 0x32, 0x36, 0x64, 0x65, 0x61, 0x62, 0x31, 0x32, 0x33, 0x64, 0x34, 0x32, 0x62, 0x62, 0x62, 0x36, 0x34, 0x33, 0x30, 0x66, 0x65, 0x30, 0x61, 0x31, 0x31, 0x35, 0x30, 0x31, 0x30, 0x64, 0x36, 0x61, 0x39, 0x34, 0x66, 0x62, 0x65, 0x39, 0x39, 0x64, 0x39, 0x35, 0x64, 0x62, 0x32, 0x32, 0x36, 0x33, 0x66, 0x63, 0x39, 0x66, 0x34, 0x32, 0x66, 0x32, 0x32, 0x62, 0x35, 0x32, 0x33, 0x36, 0x34, 0x34, 0x36, 0x37, 0x32, 0x39, 0x66, 0x63, 0x37, 0x37, 0x66, 0x30, 0x32, 0x64, 0x39, 0x31, 0x65, 0x30, 0x38, 0x35, 0x30, 0x32, 0x35, 0x31, 0x64, 0x35, 0x39, 0x66, 0x63, 0x32, 0x30, 0x34, 0x38, 0x35, 0x32, 0x65, 0x66, 0x64, 0x32, 0x36, 0x34, 0x63, 0x61, 0x30, 0x65, 0x30, 0x64, 0x62, 0x63, 0x66, 0x30, 0x61, 0x62, 0x62, 0x36, 0x39, 0x32, 0x32, 0x63, 0x61, 0x31, 0x62, 0x38, 0x32, 0x62, 0x63, 0x32, 0x37, 0x32, 0x34, 0x34, 0x39, 0x31, 0x35, 0x61, 0x65, 0x62, 0x33, 0x64, 0x64, 0x35, 0x65, 0x62, 0x61, 0x36, 0x35, 0x36, 0x64, 0x63, 0x66, 0x35, 0x34, 0x36, 0x38, 0x32, 0x64, 0x37, 0x65, 0x63, 0x32, 0x65, 0x61, 0x63, 0x34, 0x64, 0x31, 0x32, 0x32, 0x63, 0x65, 0x33, 0x32, 0x62, 0x62, 0x32, 0x36, 0x33, 0x30, 0x31, 0x34, 0x35, 0x65, 0x35, 0x39, 0x61, 0x31, 0x34, 0x35, 0x37, 0x66, 0x33, 0x35, 0x38, 0x37, 0x37, 0x66, 0x63, 0x39, 0x62, 0x32, 0x33, 0x37, 0x34, 0x34, 0x31, 0x39, 0x31, 0x35, 0x32, 0x66, 0x37, 0x30, 0x64, 0x35, 0x35, 0x39, 0x61, 0x35, 0x66, 0x39, 0x31, 0x39, 0x66, 0x38, 0x62, 0x61, 0x35, 0x38, 0x66, 0x38, 0x65, 0x34, 0x35, 0x39, 0x65, 0x33, 0x38, 0x31, 0x34, 0x65, 0x65, 0x64, 0x64, 0x39, 0x30, 0x30, 0x32, 0x38, 0x65, 0x36, 0x31, 0x35, 0x66, 0x36, 0x38, 0x32, 0x61, 0x30, 0x35, 0x39, 0x32, 0x36, 0x36, 0x63, 0x62, 0x39, 0x30, 0x66, 0x34, 0x39, 0x34, 0x37, 0x33, 0x62, 0x31, 0x39, 0x35, 0x37, 0x34, 0x30, 0x33, 0x64, 0x35, 0x63, 0x34, 0x62, 0x36, 0x35, 0x36, 0x36, 0x33, 0x30, 0x32, 0x31, 0x34, 0x31, 0x32, 0x65, 0x61, 0x34, 0x36, 0x65, 0x31, 0x64, 0x31, 0x61, 0x64, 0x61, 0x30, 0x36, 0x30, 0x62, 0x62, 0x66, 0x64, 0x30, 0x39, 0x62, 0x66, 0x37, 0x32, 0x34, 0x62, 0x32, 0x33, 0x35, 0x30, 0x65, 0x35, 0x33, 0x63, 0x66, 0x32, 0x64, 0x64, 0x31, 0x32, 0x62, 0x63, 0x61, 0x34, 0x33, 0x61, 0x64, 0x62, 0x33, 0x65, 0x37, 0x39, 0x38, 0x36, 0x38, 0x31, 0x37, 0x38, 0x64, 0x30, 0x35, 0x37, 0x32, 0x31, 0x64, 0x32, 0x37, 0x32, 0x35, 0x62, 0x62, 0x63, 0x38, 0x65, 0x30, 0x35, 0x33, 0x33, 0x39, 0x63, 0x33, 0x31, 0x33, 0x38, 0x30, 0x33, 0x37, 0x32, 0x38, 0x34, 0x30, 0x61, 0x63, 0x38, 0x66, 0x31, 0x63, 0x64, 0x39, 0x64, 0x34, 0x34, 0x34, 0x36, 0x64, 0x38, 0x34, 0x31, 0x36, 0x64, 0x35, 0x39, 0x65, 0x30, 0x66, 0x66, 0x63, 0x64, 0x39, 0x38, 0x62, 0x65, 0x65, 0x38, 0x38, 0x63, 0x63, 0x37, 0x39, 0x30, 0x39, 0x37, 0x32, 0x39, 0x34, 0x62, 0x34, 0x38, 0x37, 0x37, 0x32, 0x62, 0x34, 0x62, 0x36, 0x61, 0x65, 0x61, 0x32, 0x33, 0x36, 0x62, 0x33, 0x38, 0x62, 0x36, 0x61, 0x62, 0x62, 0x61, 0x39, 0x39, 0x38, 0x33, 0x37, 0x38, 0x34, 0x37, 0x61, 0x39, 0x62, 0x63, 0x39, 0x64, 0x62, 0x35, 0x65, 0x34, 0x65, 0x66, 0x34, 0x33, 0x39, 0x63, 0x38, 0x61, 0x30, 0x61, 0x31, 0x63, 0x36, 0x32, 0x36, 0x37, 0x66, 0x33, 0x39, 0x32, 0x39, 0x33, 0x37, 0x39, 0x64, 0x37, 0x62, 0x37, 0x31, 0x64, 0x39, 0x33, 0x39, 0x64, 0x63, 0x61, 0x37, 0x32, 0x39, 0x61, 0x35, 0x65, 0x35, 0x34, 0x32, 0x33, 0x33, 0x37, 0x32, 0x31, 0x63, 0x36, 0x63, 0x39, 0x61, 0x37, 0x30, 0x35, 0x37, 0x65, 0x30, 0x30, 0x66, 0x33, 0x39, 0x31, 0x61, 0x33, 0x65, 0x30, 0x65, 0x38, 0x34, 0x36, 0x32, 0x36, 0x65, 0x35, 0x30, 0x37, 0x39, 0x38, 0x37, 0x32, 0x66, 0x33, 0x35, 0x37, 0x31, 0x62, 0x38, 0x37, 0x38, 0x39, 0x65, 0x33, 0x34, 0x61, 0x66, 0x31, 0x37, 0x32, 0x32, 0x39, 0x34, 0x34, 0x32, 0x36, 0x30, 0x62, 0x36, 0x63, 0x64, 0x65, 0x35, 0x34, 0x34, 0x37, 0x31, 0x31, 0x35, 0x62, 0x63, 0x66, 0x32, 0x34, 0x66, 0x66, 0x36, 0x30, 0x61, 0x37, 0x36, 0x37, 0x37, 0x33, 0x30, 0x33, 0x30, 0x34, 0x38, 0x33, 0x32, 0x36, 0x62, 0x64, 0x34, 0x63, 0x61, 0x39, 0x33, 0x61, 0x30, 0x64, 0x37, 0x38, 0x31, 0x39, 0x38, 0x65, 0x65, 0x62, 0x36, 0x31, 0x37, 0x32, 0x32, 0x36, 0x36, 0x66, 0x61, 0x66, 0x63, 0x32, 0x39, 0x65, 0x66, 0x37, 0x66, 0x34, 0x36, 0x32, 0x66, 0x66, 0x37, 0x64, 0x35, 0x33, 0x61, 0x32, 0x34, 0x66, 0x61, 0x61, 0x31, 0x31, 0x61, 0x32, 0x33, 0x31, 0x64, 0x37, 0x32, 0x33, 0x64, 0x38, 0x66, 0x36, 0x37, 0x62, 0x61, 0x39, 0x38, 0x38, 0x62, 0x31, 0x64, 0x37, 0x35, 0x39, 0x35, 0x33, 0x62, 0x39, 0x35, 0x38, 0x37, 0x38, 0x37, 0x32, 0x37, 0x30, 0x32, 0x35, 0x35, 0x61, 0x32, 0x62, 0x33, 0x63, 0x62, 0x35, 0x30, 0x61, 0x36, 0x31, 0x37, 0x34, 0x64, 0x66, 0x32, 0x65, 0x37, 0x66, 0x38, 0x31, 0x34, 0x38, 0x30, 0x66, 0x33, 0x37, 0x64, 0x61, 0x65, 0x64, 0x30, 0x31, 0x64, 0x39, 0x66, 0x39, 0x31, 0x38, 0x35, 0x32, 0x62, 0x63, 0x65, 0x64, 0x65, 0x38, 0x61, 0x34, 0x30, 0x31, 0x39, 0x62, 0x39, 0x63, 0x32, 0x38, 0x37, 0x32, 0x64, 0x30, 0x38, 0x36, 0x39, 0x31, 0x35, 0x32, 0x32, 0x31, 0x66, 0x63, 0x37, 0x62, 0x39, 0x65, 0x33, 0x61, 0x35, 0x39, 0x31, 0x62, 0x30, 0x32, 0x39, 0x31, 0x64, 0x38, 0x37, 0x36, 0x31, 0x36, 0x33, 0x61, 0x39, 0x31, 0x36, 0x30, 0x33, 0x30, 0x35, 0x66, 0x61, 0x61, 0x64, 0x38, 0x32, 0x38, 0x63, 0x32, 0x33, 0x36, 0x63, 0x66, 0x64, 0x39, 0x30, 0x65, 0x31, 0x37, 0x66, 0x33, 0x36, 0x32, 0x31, 0x31, 0x63, 0x34, 0x33, 0x33, 0x36, 0x38, 0x38, 0x38, 0x34, 0x32, 0x30, 0x37, 0x66, 0x39, 0x37, 0x66, 0x65, 0x33, 0x33, 0x63, 0x62, 0x62, 0x66, 0x65, 0x61, 0x32, 0x66, 0x37, 0x35, 0x37, 0x38, 0x63, 0x38, 0x37, 0x35, 0x38, 0x39, 0x39, 0x35, 0x31, 0x65, 0x37, 0x62, 0x62, 0x39, 0x63, 0x62, 0x33, 0x31, 0x36, 0x37, 0x32, 0x31, 0x62, 0x61, 0x37, 0x35, 0x33, 0x31, 0x36, 0x35, 0x33, 0x64, 0x35, 0x34, 0x62, 0x33, 0x62, 0x38, 0x64, 0x35, 0x65, 0x62, 0x63, 0x39, 0x35, 0x61, 0x35, 0x65, 0x37, 0x30, 0x66, 0x34, 0x31, 0x61, 0x31, 0x31, 0x32, 0x39, 0x64, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, 0x32, 0x66, 0x33, 0x38, 0x35, 0x63, 0x63, 0x32, 0x34, 0x65, 0x35, 0x63, 0x62, 0x38, 0x62, 0x63, 0x62, 0x65, 0x61, 0x31, 0x33, 0x62, 0x34, 0x36, 0x62, 0x38, 0x65, 0x31, 0x33, 0x32, 0x35, 0x63, 0x61, 0x37, 0x32, 0x32, 0x62, 0x31, 0x32, 0x37, 0x39, 0x36, 0x64, 0x35, 0x61, 0x64, 0x38, 0x36, 0x61, 0x33, 0x61, 0x34, 0x33, 0x38, 0x34, 0x31, 0x35, 0x61, 0x32, 0x39, 0x36, 0x34, 0x63, 0x32, 0x33, 0x39, 0x66, 0x34, 0x33, 0x34, 0x38, 0x34, 0x38, 0x32, 0x39, 0x37, 0x37, 0x33, 0x63, 0x31, 0x39, 0x36, 0x32, 0x31, 0x32, 0x33, 0x66, 0x62, 0x37, 0x32, 0x35, 0x37, 0x37, 0x32, 0x35, 0x31, 0x37, 0x64, 0x64, 0x61, 0x65, 0x63, 0x32, 0x30, 0x36, 0x39, 0x36, 0x37, 0x61, 0x63, 0x64, 0x32, 0x63, 0x32, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x63, 0x35, 0x39, 0x64, 0x64, 0x65, 0x62, 0x64, 0x62, 0x63, 0x32, 0x32, 0x30, 0x61, 0x62, 0x32, 0x36, 0x65, 0x33, 0x66, 0x34, 0x64, 0x36, 0x66, 0x34, 0x32, 0x30, 0x62, 0x65, 0x61, 0x30, 0x33, 0x37, 0x64, 0x65, 0x31, 0x32, 0x36, 0x36, 0x61, 0x66, 0x31, 0x64, 0x61, 0x34, 0x62, 0x35, 0x32, 0x64, 0x61, 0x30, 0x65, 0x30, 0x66, 0x38, 0x38, 0x35, 0x37, 0x66, 0x32, 0x33, 0x39, 0x32, 0x32, 0x31, 0x66, 0x33, 0x35, 0x65, 0x33, 0x34, 0x31, 0x61, 0x39, 0x62, 0x63, 0x62, 0x31, 0x34, 0x31, 0x65, 0x37, 0x63, 0x35, 0x33, 0x37, 0x35, 0x30, 0x31, 0x65, 0x33, 0x63, 0x36, 0x39, 0x33, 0x61, 0x31, 0x31, 0x30, 0x65, 0x31, 0x30, 0x34, 0x31, 0x64, 0x32, 0x38, 0x37, 0x61, 0x64, 0x32, 0x66, 0x64, 0x32, 0x32, 0x66, 0x65, 0x35, 0x63, 0x37, 0x31, 0x65, 0x38, 0x62, 0x30, 0x33, 0x33, 0x31, 0x32, 0x32, 0x66, 0x31, 0x30, 0x38, 0x39, 0x30, 0x62, 0x38, 0x62, 0x62, 0x34, 0x63, 0x37, 0x62, 0x33, 0x33, 0x34, 0x35, 0x62, 0x62, 0x39, 0x31, 0x35, 0x65, 0x35, 0x31, 0x66, 0x66, 0x62, 0x36, 0x66, 0x32, 0x65, 0x38, 0x35, 0x36, 0x30, 0x61, 0x62, 0x30, 0x62, 0x31, 0x65, 0x66, 0x30, 0x61, 0x35, 0x35, 0x32, 0x31, 0x35, 0x38, 0x66, 0x65, 0x62, 0x33, 0x39, 0x33, 0x37, 0x30, 0x34, 0x39, 0x61, 0x65, 0x36, 0x63, 0x61, 0x64, 0x34, 0x34, 0x38, 0x36, 0x64, 0x32, 0x64, 0x32, 0x63, 0x61, 0x32, 0x66, 0x31, 0x64, 0x30, 0x31, 0x30, 0x61, 0x62, 0x32, 0x66, 0x38, 0x39, 0x63, 0x65, 0x65, 0x32, 0x38, 0x62, 0x35, 0x30, 0x66, 0x34, 0x35, 0x65, 0x34, 0x33, 0x38, 0x35, 0x35, 0x33, 0x66, 0x33, 0x66, 0x63, 0x33, 0x62, 0x30, 0x39, 0x37, 0x37, 0x30, 0x30, 0x64, 0x63, 0x37, 0x34, 0x39, 0x37, 0x38, 0x31, 0x61, 0x37, 0x30, 0x32, 0x31, 0x32, 0x64, 0x66, 0x65, 0x66, 0x36, 0x38, 0x36, 0x65, 0x34, 0x38, 0x39, 0x63, 0x37, 0x66, 0x65, 0x66, 0x62, 0x38, 0x34, 0x31, 0x34, 0x64, 0x62, 0x33, 0x32, 0x63, 0x37, 0x37, 0x32, 0x64, 0x32, 0x37, 0x33, 0x39, 0x34, 0x30, 0x62, 0x36, 0x34, 0x61, 0x65, 0x61, 0x38, 0x32, 0x37, 0x63, 0x63, 0x65, 0x33, 0x32, 0x36, 0x30, 0x33, 0x61, 0x66, 0x33, 0x30, 0x65, 0x35, 0x38, 0x31, 0x63, 0x34, 0x35, 0x31, 0x33, 0x64, 0x30, 0x35, 0x61, 0x65, 0x33, 0x38, 0x34, 0x34, 0x33, 0x62, 0x63, 0x64, 0x32, 0x38, 0x39, 0x63, 0x64, 0x39, 0x35, 0x34, 0x32, 0x33, 0x34, 0x30, 0x37, 0x32, 0x62, 0x65, 0x30, 0x32, 0x66, 0x31, 0x31, 0x38, 0x34, 0x64, 0x64, 0x31, 0x36, 0x62, 0x38, 0x37, 0x31, 0x66, 0x30, 0x33, 0x31, 0x30, 0x35, 0x33, 0x31, 0x32, 0x33, 0x65, 0x62, 0x64, 0x39, 0x34, 0x36, 0x35, 0x61, 0x65, 0x64, 0x32, 0x61, 0x31, 0x35, 0x61, 0x36, 0x65, 0x30, 0x63, 0x30, 0x33, 0x39, 0x38, 0x36, 0x64, 0x31, 0x32, 0x65, 0x65, 0x35, 0x37, 0x33, 0x30, 0x30, 0x38, 0x30, 0x31, 0x37, 0x39, 0x32, 0x31, 0x35, 0x31, 0x32, 0x62, 0x30, 0x32, 0x33, 0x63, 0x37, 0x66, 0x30, 0x66, 0x63, 0x32, 0x36, 0x36, 0x62, 0x66, 0x36, 0x34, 0x33, 0x39, 0x37, 0x30, 0x38, 0x39, 0x33, 0x63, 0x33, 0x39, 0x65, 0x34, 0x31, 0x31, 0x61, 0x35, 0x30, 0x65, 0x62, 0x66, 0x30, 0x36, 0x33, 0x63, 0x39, 0x35, 0x35, 0x63, 0x36, 0x39, 0x33, 0x38, 0x36, 0x66, 0x37, 0x32, 0x38, 0x63, 0x37, 0x32, 0x33, 0x30, 0x36, 0x65, 0x33, 0x30, 0x32, 0x37, 0x37, 0x30, 0x37, 0x32, 0x34, 0x36, 0x65, 0x66, 0x36, 0x63, 0x66, 0x62, 0x65, 0x32, 0x38, 0x33, 0x66, 0x37, 0x38, 0x36, 0x31, 0x37, 0x38, 0x36, 0x66, 0x35, 0x38, 0x61, 0x39, 0x61, 0x34, 0x39, 0x34, 0x61, 0x61, 0x65, 0x66, 0x63, 0x61, 0x36, 0x61, 0x30, 0x34, 0x64, 0x31, 0x61, 0x30, 0x66, 0x39, 0x66, 0x31, 0x39, 0x63, 0x30, 0x37, 0x32, 0x37, 0x62, 0x37, 0x31, 0x38, 0x61, 0x39, 0x32, 0x61, 0x37, 0x33, 0x65, 0x38, 0x33, 0x31, 0x34, 0x35, 0x37, 0x35, 0x64, 0x37, 0x36, 0x30, 0x61, 0x64, 0x32, 0x65, 0x30, 0x38, 0x39, 0x31, 0x65, 0x39, 0x38, 0x32, 0x31, 0x36, 0x37, 0x32, 0x35, 0x64, 0x33, 0x34, 0x31, 0x62, 0x63, 0x63, 0x66, 0x65, 0x32, 0x33, 0x33, 0x30, 0x65, 0x37, 0x61, 0x30, 0x32, 0x35, 0x32, 0x62, 0x31, 0x30, 0x30, 0x64, 0x37, 0x37, 0x64, 0x38, 0x63, 0x34, 0x66, 0x36, 0x37, 0x35, 0x35, 0x33, 0x39, 0x31, 0x61, 0x65, 0x35, 0x66, 0x64, 0x66, 0x66, 0x63, 0x36, 0x65, 0x65, 0x34, 0x37, 0x37, 0x35, 0x37, 0x32, 0x37, 0x31, 0x64, 0x66, 0x30, 0x33, 0x36, 0x64, 0x39, 0x65, 0x62, 0x37, 0x33, 0x62, 0x35, 0x37, 0x64, 0x62, 0x66, 0x34, 0x31, 0x30, 0x31, 0x30, 0x33, 0x63, 0x38, 0x32, 0x30, 0x37, 0x37, 0x32, 0x39, 0x39, 0x31, 0x63, 0x34, 0x64, 0x34, 0x33, 0x63, 0x39, 0x34, 0x31, 0x30, 0x37, 0x63, 0x30, 0x36, 0x39, 0x37, 0x33, 0x65, 0x33, 0x32, 0x30, 0x36, 0x30, 0x64, 0x62, 0x65, 0x39, 0x30, 0x36, 0x39, 0x39, 0x63, 0x36, 0x36, 0x61, 0x63, 0x65, 0x64, 0x31, 0x64, 0x66, 0x37, 0x65, 0x39, 0x33, 0x33, 0x61, 0x37, 0x35, 0x36, 0x39, 0x31, 0x66, 0x61, 0x61, 0x62, 0x36, 0x39, 0x36, 0x37, 0x32, 0x33, 0x38, 0x31, 0x34, 0x65, 0x61, 0x66, 0x63, 0x65, 0x34, 0x37, 0x39, 0x36, 0x64, 0x35, 0x39, 0x39, 0x36, 0x38, 0x31, 0x36, 0x62, 0x34, 0x32, 0x37, 0x65, 0x66, 0x66, 0x37, 0x37, 0x39, 0x61, 0x66, 0x61, 0x36, 0x38, 0x36, 0x64, 0x62, 0x30, 0x34, 0x62, 0x63, 0x33, 0x31, 0x34, 0x36, 0x62, 0x31, 0x31, 0x62, 0x65, 0x62, 0x32, 0x33, 0x30, 0x36, 0x63, 0x34, 0x38, 0x66, 0x65, 0x30, 0x63, 0x63, 0x32, 0x39, 0x34, 0x33, 0x39, 0x66, 0x38, 0x63, 0x63, 0x38, 0x32, 0x30, 0x34, 0x66, 0x63, 0x31, 0x39, 0x33, 0x35, 0x34, 0x32, 0x35, 0x30, 0x31, 0x66, 0x66, 0x63, 0x64, 0x34, 0x64, 0x30, 0x31, 0x30, 0x33, 0x36, 0x62, 0x66, 0x34, 0x65, 0x31, 0x63, 0x35, 0x34, 0x63, 0x39, 0x63, 0x66, 0x34, 0x35, 0x31, 0x34, 0x33, 0x64, 0x62, 0x66, 0x34, 0x62, 0x35, 0x64, 0x35, 0x33, 0x37, 0x32, 0x35, 0x64, 0x38, 0x61, 0x66, 0x37, 0x32, 0x37, 0x62, 0x64, 0x35, 0x32, 0x36, 0x36, 0x33, 0x61, 0x63, 0x32, 0x31, 0x63, 0x31, 0x36, 0x61, 0x33, 0x63, 0x61, 0x63, 0x66, 0x30, 0x61, 0x66, 0x63, 0x63, 0x37, 0x64, 0x31, 0x30, 0x36, 0x37, 0x31, 0x62, 0x36, 0x63, 0x38, 0x63, 0x30, 0x66, 0x31, 0x35, 0x63, 0x30, 0x63, 0x32, 0x35, 0x33, 0x37, 0x64, 0x37, 0x31, 0x34, 0x30, 0x31, 0x37, 0x32, 0x35, 0x33, 0x66, 0x34, 0x39, 0x37, 0x65, 0x34, 0x32, 0x65, 0x65, 0x33, 0x65, 0x62, 0x35, 0x39, 0x39, 0x64, 0x63, 0x36, 0x36, 0x33, 0x36, 0x31, 0x37, 0x63, 0x37, 0x66, 0x39, 0x62, 0x37, 0x36, 0x65, 0x38, 0x61, 0x39, 0x38, 0x65, 0x61, 0x39, 0x35, 0x37, 0x30, 0x32, 0x39, 0x39, 0x63, 0x62, 0x34, 0x33, 0x35, 0x66, 0x34, 0x31, 0x35, 0x30, 0x32, 0x33, 0x35, 0x37, 0x31, 0x61, 0x37, 0x32, 0x37, 0x65, 0x63, 0x66, 0x61, 0x64, 0x35, 0x33, 0x33, 0x37, 0x39, 0x34, 0x39, 0x66, 0x34, 0x65, 0x34, 0x31, 0x31, 0x63, 0x39, 0x38, 0x38, 0x65, 0x33, 0x33, 0x37, 0x33, 0x32, 0x30, 0x65, 0x34, 0x39, 0x34, 0x39, 0x31, 0x62, 0x64, 0x37, 0x34, 0x35, 0x30, 0x30, 0x61, 0x34, 0x32, 0x63, 0x63, 0x38, 0x65, 0x65, 0x32, 0x31, 0x39, 0x35, 0x39, 0x39, 0x36, 0x32, 0x34, 0x63, 0x62, 0x33, 0x35, 0x66, 0x63, 0x30, 0x64, 0x36, 0x32, 0x37, 0x38, 0x64, 0x63, 0x35, 0x31, 0x61, 0x37, 0x38, 0x39, 0x63, 0x30, 0x37, 0x33, 0x61, 0x33, 0x66, 0x66, 0x62, 0x31, 0x66, 0x36, 0x65, 0x63, 0x64, 0x61, 0x65, 0x62, 0x63, 0x61, 0x38, 0x32, 0x61, 0x66, 0x34, 0x38, 0x36, 0x66, 0x66, 0x37, 0x39, 0x32, 0x65, 0x61, 0x30, 0x37, 0x61, 0x37, 0x66, 0x66, 0x35, 0x30, 0x61, 0x63, 0x64, 0x34, 0x37, 0x32, 0x63, 0x30, 0x62, 0x39, 0x34, 0x66, 0x30, 0x63, 0x37, 0x32, 0x36, 0x65, 0x35, 0x38, 0x33, 0x32, 0x30, 0x34, 0x32, 0x62, 0x61, 0x61, 0x32, 0x63, 0x37, 0x61, 0x30, 0x65, 0x63, 0x37, 0x30, 0x37, 0x65, 0x62, 0x63, 0x38, 0x64, 0x34, 0x66, 0x62, 0x37, 0x66, 0x31, 0x66, 0x30, 0x62, 0x64, 0x63, 0x66, 0x64, 0x30, 0x64, 0x38, 0x38, 0x63, 0x62, 0x34, 0x61, 0x63, 0x32, 0x31, 0x35, 0x35, 0x39, 0x65, 0x33, 0x34, 0x30, 0x32, 0x33, 0x31, 0x36, 0x33, 0x39, 0x66, 0x37, 0x32, 0x61, 0x32, 0x30, 0x62, 0x33, 0x65, 0x38, 0x31, 0x35, 0x39, 0x61, 0x64, 0x30, 0x36, 0x66, 0x32, 0x62, 0x31, 0x30, 0x33, 0x35, 0x32, 0x34, 0x38, 0x34, 0x30, 0x35, 0x33, 0x62, 0x35, 0x65, 0x35, 0x64, 0x33, 0x61, 0x64, 0x33, 0x32, 0x31, 0x33, 0x39, 0x33, 0x63, 0x39, 0x33, 0x39, 0x32, 0x66, 0x61, 0x37, 0x32, 0x35, 0x39, 0x37, 0x35, 0x31, 0x65, 0x62, 0x38, 0x30, 0x37, 0x38, 0x61, 0x62, 0x30, 0x38, 0x34, 0x39, 0x62, 0x36, 0x31, 0x32, 0x37, 0x30, 0x63, 0x62, 0x35, 0x65, 0x63, 0x64, 0x64, 0x35, 0x36, 0x31, 0x64, 0x30, 0x64, 0x62, 0x33, 0x38, 0x36, 0x64, 0x31, 0x33, 0x36, 0x32, 0x39, 0x38, 0x31, 0x35, 0x31, 0x36, 0x63, 0x61, 0x62, 0x38, 0x33, 0x30, 0x35, 0x66, 0x66, 0x35, 0x38, 0x32, 0x65, 0x65, 0x33, 0x39, 0x61, 0x36, 0x64, 0x32, 0x32, 0x64, 0x62, 0x65, 0x35, 0x63, 0x30, 0x66, 0x61, 0x65, 0x30, 0x63, 0x34, 0x34, 0x62, 0x66, 0x33, 0x66, 0x32, 0x30, 0x34, 0x38, 0x33, 0x30, 0x37, 0x63, 0x31, 0x37, 0x62, 0x64, 0x31, 0x34, 0x39, 0x66, 0x63, 0x65, 0x65, 0x66, 0x33, 0x34, 0x30, 0x62, 0x33, 0x37, 0x37, 0x65, 0x37, 0x62, 0x65, 0x34, 0x64, 0x38, 0x38, 0x63, 0x33, 0x30, 0x61, 0x66, 0x64, 0x32, 0x33, 0x64, 0x31, 0x64, 0x39, 0x35, 0x66, 0x35, 0x34, 0x37, 0x34, 0x63, 0x39, 0x66, 0x31, 0x61, 0x66, 0x62, 0x65, 0x66, 0x66, 0x31, 0x64, 0x30, 0x61, 0x63, 0x36, 0x38, 0x62, 0x35, 0x39, 0x36, 0x61, 0x39, 0x35, 0x63, 0x63, 0x35, 0x34, 0x35, 0x65, 0x38, 0x39, 0x35, 0x62, 0x32, 0x38, 0x36, 0x31, 0x30, 0x66, 0x36, 0x33, 0x63, 0x62, 0x34, 0x36, 0x31, 0x62, 0x37, 0x32, 0x62, 0x63, 0x33, 0x38, 0x37, 0x63, 0x62, 0x30, 0x65, 0x35, 0x39, 0x32, 0x31, 0x32, 0x35, 0x63, 0x38, 0x35, 0x36, 0x62, 0x66, 0x35, 0x32, 0x35, 0x62, 0x34, 0x39, 0x62, 0x33, 0x36, 0x37, 0x66, 0x61, 0x38, 0x63, 0x30, 0x66, 0x39, 0x61, 0x62, 0x31, 0x35, 0x30, 0x65, 0x64, 0x61, 0x32, 0x39, 0x36, 0x33, 0x62, 0x39, 0x63, 0x64, 0x64, 0x34, 0x63, 0x62, 0x33, 0x32, 0x62, 0x65, 0x37, 0x32, 0x62, 0x39, 0x30, 0x36, 0x66, 0x39, 0x62, 0x36, 0x30, 0x39, 0x62, 0x61, 0x33, 0x65, 0x30, 0x37, 0x36, 0x32, 0x35, 0x64, 0x66, 0x37, 0x32, 0x61, 0x30, 0x36, 0x64, 0x30, 0x32, 0x65, 0x33, 0x36, 0x38, 0x30, 0x35, 0x66, 0x37, 0x30, 0x35, 0x39, 0x63, 0x63, 0x31, 0x36, 0x37, 0x39, 0x63, 0x31, 0x37, 0x38, 0x39, 0x35, 0x34, 0x35, 0x66, 0x38, 0x39, 0x33, 0x64, 0x61, 0x30, 0x36, 0x37, 0x32, 0x38, 0x61, 0x66, 0x33, 0x31, 0x31, 0x35, 0x66, 0x34, 0x61, 0x32, 0x61, 0x62, 0x36, 0x61, 0x39, 0x33, 0x38, 0x31, 0x34, 0x34, 0x30, 0x65, 0x64, 0x33, 0x39, 0x35, 0x62, 0x30, 0x61, 0x64, 0x37, 0x61, 0x30, 0x34, 0x66, 0x38, 0x37, 0x34, 0x61, 0x38, 0x34, 0x31, 0x33, 0x30, 0x32, 0x30, 0x66, 0x30, 0x33, 0x61, 0x63, 0x66, 0x34, 0x62, 0x62, 0x39, 0x38, 0x34, 0x37, 0x36, 0x63, 0x37, 0x32, 0x30, 0x37, 0x66, 0x35, 0x64, 0x32, 0x36, 0x37, 0x63, 0x63, 0x62, 0x66, 0x64, 0x33, 0x35, 0x62, 0x30, 0x39, 0x36, 0x31, 0x64, 0x36, 0x35, 0x35, 0x65, 0x63, 0x36, 0x34, 0x64, 0x64, 0x62, 0x34, 0x66, 0x37, 0x63, 0x33, 0x31, 0x64, 0x37, 0x61, 0x31, 0x38, 0x62, 0x61, 0x38, 0x66, 0x66, 0x61, 0x34, 0x62, 0x31, 0x31, 0x62, 0x38, 0x63, 0x33, 0x32, 0x39, 0x31, 0x34, 0x38, 0x64, 0x33, 0x61, 0x30, 0x31, 0x39, 0x37, 0x33, 0x35, 0x34, 0x39, 0x32, 0x62, 0x39, 0x38, 0x62, 0x39, 0x34, 0x65, 0x61, 0x62, 0x39, 0x32, 0x36, 0x34, 0x39, 0x32, 0x63, 0x30, 0x35, 0x30, 0x31, 0x38, 0x63, 0x63, 0x36, 0x37, 0x65, 0x38, 0x39, 0x39, 0x36, 0x65, 0x35, 0x33, 0x38, 0x62, 0x32, 0x63, 0x66, 0x36, 0x66, 0x38, 0x32, 0x64, 0x64, 0x37, 0x61, 0x64, 0x33, 0x30, 0x66, 0x63, 0x39, 0x37, 0x34, 0x64, 0x61, 0x33, 0x35, 0x36, 0x36, 0x34, 0x36, 0x35, 0x63, 0x39, 0x63, 0x31, 0x62, 0x61, 0x37, 0x33, 0x31, 0x36, 0x61, 0x61, 0x64, 0x36, 0x39, 0x66, 0x37, 0x34, 0x62, 0x30, 0x61, 0x65, 0x61, 0x35, 0x36, 0x65, 0x36, 0x30, 0x35, 0x65, 0x61, 0x32, 0x66, 0x61, 0x33, 0x61, 0x31, 0x36, 0x37, 0x38, 0x65, 0x32, 0x65, 0x35, 0x39, 0x62, 0x61, 0x39, 0x39, 0x37, 0x66, 0x63, 0x35, 0x64, 0x30, 0x37, 0x63, 0x33, 0x65, 0x31, 0x31, 0x35, 0x61, 0x31, 0x37, 0x36, 0x35, 0x64, 0x38, 0x30, 0x30, 0x63, 0x66, 0x31, 0x61, 0x39, 0x35, 0x33, 0x66, 0x30, 0x38, 0x38, 0x64, 0x36, 0x64, 0x62, 0x33, 0x30, 0x31, 0x63, 0x37, 0x38, 0x65, 0x61, 0x64, 0x37, 0x31, 0x34, 0x33, 0x34, 0x65, 0x61, 0x33, 0x62, 0x37, 0x64, 0x65, 0x61, 0x34, 0x61, 0x34, 0x37, 0x34, 0x36, 0x62, 0x62, 0x63, 0x30, 0x37, 0x32, 0x30, 0x36, 0x61, 0x33, 0x30, 0x36, 0x35, 0x61, 0x63, 0x61, 0x35, 0x66, 0x33, 0x64, 0x31, 0x66, 0x61, 0x64, 0x65, 0x64, 0x64, 0x64, 0x31, 0x65, 0x37, 0x65, 0x31, 0x63, 0x37, 0x37, 0x62, 0x38, 0x38, 0x63, 0x62, 0x30, 0x31, 0x32, 0x34, 0x66, 0x61, 0x66, 0x62, 0x64, 0x33, 0x32, 0x66, 0x32, 0x35, 0x35, 0x36, 0x32, 0x62, 0x32, 0x66, 0x61, 0x39, 0x35, 0x61, 0x34, 0x39, 0x35, 0x35, 0x31, 0x38, 0x35, 0x38, 0x39, 0x64, 0x64, 0x64, 0x34, 0x65, 0x30, 0x34, 0x34, 0x65, 0x37, 0x39, 0x63, 0x63, 0x38, 0x64, 0x38, 0x64, 0x34, 0x61, 0x63, 0x37, 0x66, 0x34, 0x30, 0x66, 0x33, 0x30, 0x65, 0x34, 0x36, 0x35, 0x62, 0x32, 0x35, 0x34, 0x35, 0x36, 0x33, 0x34, 0x61, 0x31, 0x64, 0x62, 0x36, 0x30, 0x64, 0x37, 0x39, 0x61, 0x31, 0x62, 0x32, 0x66, 0x34, 0x37, 0x62, 0x61, 0x33, 0x37, 0x32, 0x32, 0x63, 0x66, 0x31, 0x63, 0x30, 0x34, 0x64, 0x63, 0x64, 0x32, 0x38, 0x61, 0x64, 0x35, 0x37, 0x30, 0x64, 0x37, 0x31, 0x65, 0x30, 0x31, 0x62, 0x35, 0x37, 0x38, 0x30, 0x30, 0x35, 0x39, 0x38, 0x34, 0x31, 0x64, 0x37, 0x36, 0x62, 0x62, 0x66, 0x36, 0x38, 0x37, 0x65, 0x35, 0x35, 0x31, 0x35, 0x37, 0x39, 0x34, 0x63, 0x34, 0x64, 0x35, 0x32, 0x66, 0x33, 0x65, 0x65, 0x32, 0x32, 0x31, 0x39, 0x65, 0x33, 0x39, 0x37, 0x38, 0x63, 0x39, 0x38, 0x65, 0x31, 0x31, 0x30, 0x33, 0x66, 0x31, 0x35, 0x63, 0x65, 0x33, 0x36, 0x63, 0x34, 0x36, 0x65, 0x34, 0x61, 0x36, 0x33, 0x66, 0x66, 0x61, 0x62, 0x39, 0x61, 0x61, 0x66, 0x34, 0x30, 0x38, 0x65, 0x66, 0x30, 0x30, 0x66, 0x66, 0x64, 0x36, 0x39, 0x39, 0x33, 0x32, 0x62, 0x64, 0x62, 0x35, 0x32, 0x38, 0x33, 0x65, 0x63, 0x39, 0x33, 0x30, 0x33, 0x63, 0x62, 0x38, 0x31, 0x30, 0x64, 0x32, 0x37, 0x35, 0x65, 0x65, 0x62, 0x38, 0x61, 0x63, 0x34, 0x64, 0x61, 0x34, 0x36, 0x65, 0x39, 0x39, 0x32, 0x30, 0x62, 0x61, 0x31, 0x39, 0x38, 0x34, 0x36, 0x30, 0x36, 0x37, 0x36, 0x62, 0x62, 0x34, 0x64, 0x65, 0x32, 0x61, 0x33, 0x61, 0x61, 0x39, 0x39, 0x37, 0x64, 0x34, 0x64, 0x36, 0x64, 0x65, 0x33, 0x38, 0x35, 0x34, 0x62, 0x38, 0x39, 0x37, 0x32, 0x38, 0x62, 0x64, 0x36, 0x35, 0x65, 0x61, 0x65, 0x37, 0x31, 0x37, 0x36, 0x38, 0x39, 0x66, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x34, 0x35, 0x35, 0x35, 0x62, 0x62, 0x30, 0x32, 0x30, 0x32, 0x35, 0x63, 0x35, 0x36, 0x31, 0x33, 0x64, 0x39, 0x33, 0x32, 0x30, 0x33, 0x34, 0x32, 0x37, 0x65, 0x66, 0x36, 0x35, 0x33, 0x31, 0x30, 0x30, 0x34, 0x61, 0x32, 0x62, 0x37, 0x32, 0x33, 0x64, 0x31, 0x63, 0x38, 0x33, 0x65, 0x65, 0x31, 0x65, 0x62, 0x37, 0x32, 0x35, 0x32, 0x34, 0x61, 0x31, 0x39, 0x30, 0x30, 0x36, 0x38, 0x61, 0x36, 0x32, 0x31, 0x64, 0x63, 0x35, 0x64, 0x33, 0x34, 0x62, 0x33, 0x62, 0x61, 0x38, 0x36, 0x63, 0x35, 0x61, 0x36, 0x64, 0x31, 0x62, 0x66, 0x61, 0x38, 0x61, 0x61, 0x62, 0x65, 0x63, 0x37, 0x36, 0x61, 0x32, 0x32, 0x35, 0x37, 0x64, 0x62, 0x34, 0x66, 0x37, 0x33, 0x62, 0x30, 0x65, 0x62, 0x36, 0x65, 0x37, 0x31, 0x31, 0x39, 0x31, 0x62, 0x64, 0x32, 0x32, 0x37, 0x31, 0x34, 0x31, 0x66, 0x64, 0x36, 0x31, 0x66, 0x30, 0x66, 0x35, 0x35, 0x61, 0x62, 0x65, 0x32, 0x61, 0x37, 0x37, 0x65, 0x32, 0x30, 0x30, 0x65, 0x66, 0x63, 0x35, 0x37, 0x36, 0x61, 0x61, 0x38, 0x36, 0x63, 0x61, 0x62, 0x34, 0x39, 0x34, 0x34, 0x35, 0x36, 0x30, 0x64, 0x62, 0x66, 0x30, 0x37, 0x32, 0x39, 0x34, 0x34, 0x32, 0x35, 0x33, 0x62, 0x35, 0x32, 0x31, 0x30, 0x64, 0x66, 0x34, 0x36, 0x32, 0x35, 0x36, 0x32, 0x32, 0x37, 0x31, 0x39, 0x31, 0x65, 0x36, 0x61, 0x31, 0x35, 0x31, 0x35, 0x35, 0x30, 0x37, 0x33, 0x31, 0x64, 0x63, 0x39, 0x34, 0x36, 0x64, 0x39, 0x36, 0x37, 0x62, 0x64, 0x34, 0x31, 0x34, 0x35, 0x38, 0x37, 0x34, 0x38, 0x63, 0x61, 0x61, 0x61, 0x65, 0x64, 0x32, 0x37, 0x32, 0x66, 0x37, 0x61, 0x61, 0x39, 0x65, 0x36, 0x38, 0x35, 0x34, 0x65, 0x62, 0x65, 0x35, 0x39, 0x38, 0x62, 0x38, 0x32, 0x39, 0x61, 0x65, 0x33, 0x65, 0x63, 0x34, 0x31, 0x39, 0x37, 0x66, 0x30, 0x31, 0x64, 0x36, 0x30, 0x36, 0x61, 0x33, 0x62, 0x61, 0x34, 0x61, 0x64, 0x37, 0x62, 0x61, 0x63, 0x63, 0x34, 0x64, 0x38, 0x37, 0x36, 0x30, 0x38, 0x32, 0x66, 0x65, 0x64, 0x64, 0x61, 0x66, 0x35, 0x30, 0x61, 0x33, 0x33, 0x36, 0x38, 0x33, 0x33, 0x66, 0x38, 0x36, 0x34, 0x65, 0x65, 0x32, 0x30, 0x61, 0x33, 0x35, 0x64, 0x64, 0x35, 0x31, 0x37, 0x32, 0x64, 0x38, 0x34, 0x32, 0x64, 0x39, 0x66, 0x38, 0x33, 0x30, 0x63, 0x66, 0x35, 0x37, 0x64, 0x62, 0x39, 0x32, 0x38, 0x30, 0x36, 0x65, 0x38, 0x62, 0x31, 0x36, 0x63, 0x61, 0x34, 0x62, 0x35, 0x37, 0x61, 0x37, 0x35, 0x35, 0x30, 0x30, 0x30, 0x62, 0x30, 0x31, 0x32, 0x32, 0x35, 0x31, 0x34, 0x36, 0x64, 0x34, 0x63, 0x37, 0x33, 0x66, 0x36, 0x65, 0x38, 0x65, 0x64, 0x65, 0x61, 0x38, 0x36, 0x38, 0x38, 0x38, 0x63, 0x64, 0x65, 0x37, 0x38, 0x30, 0x32, 0x38, 0x36, 0x38, 0x39, 0x33, 0x31, 0x65, 0x66, 0x62, 0x33, 0x38, 0x39, 0x39, 0x61, 0x37, 0x35, 0x66, 0x62, 0x37, 0x34, 0x64, 0x33, 0x61, 0x33, 0x62, 0x38, 0x62, 0x37, 0x36, 0x37, 0x32, 0x62, 0x36, 0x64, 0x61, 0x38, 0x36, 0x34, 0x62, 0x66, 0x61, 0x39, 0x38, 0x30, 0x36, 0x64, 0x64, 0x32, 0x35, 0x32, 0x31, 0x33, 0x30, 0x39, 0x64, 0x33, 0x39, 0x63, 0x62, 0x34, 0x38, 0x35, 0x38, 0x36, 0x31, 0x37, 0x34, 0x33, 0x66, 0x63, 0x31, 0x62, 0x66, 0x62, 0x32, 0x38, 0x66, 0x38, 0x62, 0x37, 0x63, 0x37, 0x37, 0x65, 0x35, 0x38, 0x38, 0x63, 0x38, 0x38, 0x66, 0x34, 0x62, 0x35, 0x63, 0x35, 0x39, 0x63, 0x30, 0x33, 0x66, 0x65, 0x61, 0x35, 0x64, 0x36, 0x62, 0x34, 0x64, 0x35, 0x32, 0x65, 0x39, 0x33, 0x62, 0x35, 0x39, 0x65, 0x63, 0x63, 0x35, 0x38, 0x36, 0x61, 0x30, 0x33, 0x32, 0x63, 0x33, 0x37, 0x34, 0x35, 0x30, 0x30, 0x66, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x62, 0x64, 0x32, 0x37, 0x39, 0x66, 0x35, 0x61, 0x31, 0x37, 0x62, 0x31, 0x35, 0x32, 0x66, 0x36, 0x30, 0x33, 0x30, 0x39, 0x39, 0x36, 0x37, 0x34, 0x34, 0x36, 0x32, 0x31, 0x39, 0x31, 0x64, 0x38, 0x38, 0x33, 0x38, 0x64, 0x32, 0x61, 0x39, 0x37, 0x34, 0x39, 0x65, 0x61, 0x32, 0x36, 0x62, 0x65, 0x35, 0x65, 0x66, 0x64, 0x61, 0x65, 0x38, 0x66, 0x65, 0x38, 0x65, 0x32, 0x35, 0x33, 0x31, 0x38, 0x38, 0x30, 0x30, 0x34, 0x35, 0x65, 0x61, 0x31, 0x63, 0x61, 0x34, 0x64, 0x31, 0x39, 0x33, 0x64, 0x37, 0x32, 0x35, 0x39, 0x34, 0x32, 0x64, 0x30, 0x35, 0x37, 0x34, 0x64, 0x62, 0x61, 0x65, 0x36, 0x31, 0x30, 0x31, 0x30, 0x39, 0x32, 0x38, 0x62, 0x33, 0x64, 0x34, 0x63, 0x34, 0x36, 0x35, 0x32, 0x39, 0x61, 0x31, 0x39, 0x33, 0x30, 0x32, 0x36, 0x65, 0x65, 0x37, 0x61, 0x62, 0x39, 0x32, 0x63, 0x66, 0x35, 0x36, 0x36, 0x31, 0x38, 0x36, 0x61, 0x63, 0x64, 0x31, 0x66, 0x34, 0x32, 0x61, 0x66, 0x37, 0x32, 0x32, 0x65, 0x37, 0x62, 0x30, 0x34, 0x39, 0x37, 0x31, 0x33, 0x63, 0x36, 0x35, 0x37, 0x32, 0x66, 0x38, 0x37, 0x61, 0x30, 0x63, 0x36, 0x66, 0x61, 0x65, 0x36, 0x32, 0x34, 0x37, 0x34, 0x38, 0x35, 0x61, 0x31, 0x64, 0x31, 0x36, 0x38, 0x65, 0x30, 0x61, 0x64, 0x36, 0x66, 0x32, 0x65, 0x32, 0x36, 0x34, 0x65, 0x65, 0x31, 0x38, 0x38, 0x65, 0x38, 0x37, 0x30, 0x38, 0x36, 0x66, 0x30, 0x32, 0x65, 0x66, 0x61, 0x38, 0x38, 0x31, 0x64, 0x37, 0x31, 0x62, 0x31, 0x35, 0x39, 0x64, 0x37, 0x66, 0x31, 0x37, 0x37, 0x35, 0x30, 0x65, 0x39, 0x64, 0x32, 0x31, 0x39, 0x36, 0x64, 0x31, 0x31, 0x32, 0x32, 0x39, 0x37, 0x37, 0x39, 0x65, 0x63, 0x36, 0x65, 0x36, 0x33, 0x61, 0x36, 0x31, 0x63, 0x34, 0x64, 0x39, 0x34, 0x32, 0x38, 0x33, 0x63, 0x31, 0x30, 0x34, 0x65, 0x36, 0x61, 0x39, 0x30, 0x35, 0x65, 0x39, 0x31, 0x66, 0x65, 0x66, 0x30, 0x63, 0x64, 0x35, 0x62, 0x61, 0x36, 0x34, 0x64, 0x37, 0x36, 0x61, 0x39, 0x39, 0x33, 0x34, 0x36, 0x31, 0x34, 0x38, 0x38, 0x62, 0x62, 0x36, 0x31, 0x33, 0x32, 0x63, 0x39, 0x64, 0x33, 0x63, 0x30, 0x64, 0x66, 0x64, 0x38, 0x61, 0x65, 0x33, 0x62, 0x35, 0x35, 0x37, 0x33, 0x37, 0x30, 0x33, 0x32, 0x39, 0x30, 0x62, 0x37, 0x38, 0x32, 0x65, 0x39, 0x31, 0x35, 0x63, 0x61, 0x32, 0x33, 0x38, 0x31, 0x66, 0x66, 0x65, 0x64, 0x32, 0x35, 0x61, 0x64, 0x62, 0x37, 0x35, 0x35, 0x61, 0x32, 0x64, 0x65, 0x65, 0x61, 0x34, 0x64, 0x66, 0x30, 0x39, 0x35, 0x38, 0x36, 0x35, 0x62, 0x31, 0x63, 0x33, 0x34, 0x36, 0x39, 0x39, 0x32, 0x30, 0x31, 0x39, 0x37, 0x32, 0x61, 0x63, 0x35, 0x32, 0x36, 0x36, 0x63, 0x33, 0x63, 0x33, 0x38, 0x34, 0x64, 0x35, 0x61, 0x37, 0x32, 0x63, 0x66, 0x62, 0x30, 0x66, 0x62, 0x34, 0x32, 0x37, 0x31, 0x61, 0x34, 0x35, 0x65, 0x30, 0x31, 0x64, 0x31, 0x30, 0x64, 0x63, 0x66, 0x37, 0x37, 0x65, 0x32, 0x65, 0x30, 0x31, 0x35, 0x61, 0x65, 0x65, 0x63, 0x35, 0x30, 0x38, 0x34, 0x39, 0x66, 0x37, 0x66, 0x65, 0x63, 0x66, 0x33, 0x61, 0x66, 0x39, 0x64, 0x63, 0x35, 0x37, 0x64, 0x37, 0x66, 0x63, 0x37, 0x64, 0x66, 0x33, 0x30, 0x32, 0x66, 0x34, 0x39, 0x35, 0x35, 0x62, 0x38, 0x63, 0x32, 0x33, 0x30, 0x61, 0x39, 0x61, 0x39, 0x38, 0x63, 0x31, 0x62, 0x38, 0x38, 0x32, 0x31, 0x65, 0x66, 0x65, 0x62, 0x65, 0x38, 0x66, 0x37, 0x63, 0x32, 0x66, 0x32, 0x35, 0x32, 0x65, 0x35, 0x32, 0x38, 0x38, 0x39, 0x39, 0x39, 0x36, 0x66, 0x37, 0x38, 0x38, 0x64, 0x30, 0x30, 0x62, 0x66, 0x65, 0x34, 0x64, 0x64, 0x62, 0x31, 0x62, 0x39, 0x33, 0x31, 0x61, 0x66, 0x32, 0x35, 0x61, 0x65, 0x30, 0x62, 0x61, 0x36, 0x35, 0x36, 0x35, 0x34, 0x64, 0x64, 0x33, 0x33, 0x65, 0x33, 0x32, 0x36, 0x35, 0x34, 0x32, 0x63, 0x61, 0x63, 0x39, 0x62, 0x34, 0x36, 0x31, 0x33, 0x35, 0x31, 0x31, 0x62, 0x62, 0x36, 0x30, 0x30, 0x32, 0x66, 0x63, 0x34, 0x37, 0x31, 0x64, 0x64, 0x35, 0x37, 0x30, 0x38, 0x35, 0x66, 0x36, 0x37, 0x38, 0x65, 0x34, 0x37, 0x33, 0x34, 0x32, 0x61, 0x31, 0x36, 0x64, 0x37, 0x64, 0x36, 0x35, 0x30, 0x65, 0x62, 0x32, 0x36, 0x30, 0x63, 0x36, 0x37, 0x33, 0x61, 0x34, 0x31, 0x65, 0x35, 0x34, 0x32, 0x39, 0x31, 0x65, 0x66, 0x30, 0x62, 0x36, 0x61, 0x65, 0x32, 0x34, 0x33, 0x34, 0x30, 0x61, 0x36, 0x38, 0x39, 0x37, 0x63, 0x37, 0x64, 0x37, 0x30, 0x66, 0x39, 0x65, 0x66, 0x61, 0x65, 0x37, 0x30, 0x35, 0x66, 0x36, 0x61, 0x37, 0x32, 0x61, 0x30, 0x63, 0x35, 0x63, 0x36, 0x32, 0x61, 0x66, 0x35, 0x62, 0x62, 0x33, 0x31, 0x32, 0x61, 0x39, 0x38, 0x38, 0x64, 0x35, 0x35, 0x30, 0x39, 0x61, 0x36, 0x34, 0x62, 0x64, 0x64, 0x34, 0x64, 0x64, 0x63, 0x39, 0x34, 0x33, 0x66, 0x38, 0x32, 0x35, 0x32, 0x34, 0x37, 0x61, 0x38, 0x31, 0x32, 0x36, 0x30, 0x31, 0x64, 0x64, 0x66, 0x32, 0x63, 0x63, 0x33, 0x33, 0x37, 0x64, 0x62, 0x37, 0x32, 0x65, 0x36, 0x66, 0x35, 0x35, 0x37, 0x39, 0x64, 0x35, 0x32, 0x31, 0x31, 0x34, 0x64, 0x61, 0x64, 0x34, 0x37, 0x33, 0x64, 0x61, 0x33, 0x36, 0x34, 0x61, 0x32, 0x64, 0x31, 0x38, 0x35, 0x34, 0x66, 0x31, 0x34, 0x34, 0x66, 0x34, 0x66, 0x65, 0x61, 0x38, 0x65, 0x34, 0x35, 0x63, 0x37, 0x33, 0x38, 0x62, 0x66, 0x30, 0x65, 0x39, 0x30, 0x31, 0x65, 0x63, 0x65, 0x31, 0x31, 0x66, 0x30, 0x37, 0x32, 0x39, 0x34, 0x39, 0x39, 0x39, 0x62, 0x32, 0x30, 0x39, 0x38, 0x34, 0x36, 0x31, 0x33, 0x32, 0x30, 0x64, 0x34, 0x33, 0x61, 0x34, 0x35, 0x35, 0x66, 0x39, 0x38, 0x66, 0x37, 0x66, 0x64, 0x62, 0x35, 0x30, 0x61, 0x38, 0x37, 0x37, 0x64, 0x66, 0x65, 0x62, 0x33, 0x37, 0x36, 0x35, 0x33, 0x35, 0x65, 0x65, 0x33, 0x38, 0x35, 0x35, 0x63, 0x64, 0x32, 0x34, 0x38, 0x62, 0x62, 0x63, 0x64, 0x37, 0x31, 0x34, 0x61, 0x30, 0x65, 0x33, 0x30, 0x63, 0x31, 0x33, 0x63, 0x34, 0x30, 0x63, 0x39, 0x64, 0x31, 0x61, 0x39, 0x33, 0x32, 0x33, 0x64, 0x62, 0x36, 0x64, 0x63, 0x33, 0x30, 0x37, 0x31, 0x36, 0x32, 0x65, 0x61, 0x62, 0x61, 0x66, 0x39, 0x39, 0x36, 0x37, 0x37, 0x35, 0x34, 0x62, 0x32, 0x38, 0x30, 0x61, 0x33, 0x31, 0x65, 0x33, 0x33, 0x63, 0x39, 0x35, 0x64, 0x65, 0x36, 0x30, 0x33, 0x37, 0x32, 0x38, 0x30, 0x61, 0x63, 0x36, 0x32, 0x30, 0x66, 0x37, 0x33, 0x31, 0x30, 0x32, 0x32, 0x65, 0x30, 0x64, 0x39, 0x62, 0x37, 0x62, 0x33, 0x61, 0x66, 0x34, 0x64, 0x63, 0x38, 0x62, 0x37, 0x64, 0x36, 0x37, 0x34, 0x66, 0x64, 0x62, 0x37, 0x65, 0x65, 0x65, 0x62, 0x37, 0x61, 0x33, 0x61, 0x33, 0x36, 0x64, 0x30, 0x63, 0x65, 0x39, 0x66, 0x62, 0x66, 0x35, 0x61, 0x39, 0x61, 0x34, 0x32, 0x36, 0x64, 0x64, 0x64, 0x36, 0x31, 0x34, 0x64, 0x33, 0x66, 0x36, 0x62, 0x65, 0x65, 0x31, 0x63, 0x64, 0x34, 0x35, 0x31, 0x38, 0x36, 0x37, 0x32, 0x63, 0x64, 0x37, 0x63, 0x30, 0x31, 0x66, 0x37, 0x30, 0x38, 0x64, 0x61, 0x37, 0x35, 0x66, 0x64, 0x66, 0x35, 0x36, 0x64, 0x35, 0x34, 0x66, 0x31, 0x61, 0x36, 0x37, 0x30, 0x39, 0x63, 0x35, 0x32, 0x39, 0x38, 0x66, 0x31, 0x32, 0x38, 0x61, 0x32, 0x37, 0x32, 0x61, 0x65, 0x31, 0x39, 0x30, 0x65, 0x30, 0x62, 0x30, 0x36, 0x34, 0x34, 0x65, 0x30, 0x34, 0x31, 0x30, 0x36, 0x35, 0x34, 0x64, 0x34, 0x39, 0x65, 0x31, 0x62, 0x34, 0x66, 0x62, 0x65, 0x36, 0x63, 0x32, 0x34, 0x36, 0x30, 0x63, 0x31, 0x32, 0x62, 0x35, 0x61, 0x31, 0x65, 0x66, 0x39, 0x63, 0x65, 0x63, 0x37, 0x33, 0x30, 0x32, 0x31, 0x31, 0x38, 0x37, 0x31, 0x61, 0x34, 0x64, 0x35, 0x37, 0x32, 0x30, 0x63, 0x62, 0x38, 0x65, 0x39, 0x63, 0x37, 0x32, 0x62, 0x39, 0x31, 0x30, 0x39, 0x36, 0x63, 0x65, 0x65, 0x39, 0x36, 0x38, 0x35, 0x62, 0x63, 0x64, 0x30, 0x63, 0x33, 0x34, 0x62, 0x34, 0x63, 0x39, 0x65, 0x32, 0x36, 0x39, 0x35, 0x64, 0x63, 0x64, 0x64, 0x63, 0x39, 0x32, 0x35, 0x65, 0x30, 0x38, 0x37, 0x63, 0x64, 0x34, 0x34, 0x36, 0x33, 0x37, 0x31, 0x61, 0x65, 0x63, 0x30, 0x35, 0x36, 0x66, 0x63, 0x61, 0x39, 0x36, 0x33, 0x65, 0x66, 0x35, 0x32, 0x61, 0x34, 0x36, 0x30, 0x34, 0x37, 0x36, 0x63, 0x34, 0x32, 0x32, 0x66, 0x36, 0x34, 0x38, 0x61, 0x31, 0x39, 0x65, 0x62, 0x39, 0x37, 0x36, 0x35, 0x33, 0x39, 0x31, 0x62, 0x38, 0x39, 0x34, 0x36, 0x65, 0x65, 0x39, 0x63, 0x33, 0x34, 0x37, 0x34, 0x38, 0x36, 0x37, 0x34, 0x35, 0x64, 0x38, 0x63, 0x30, 0x37, 0x61, 0x37, 0x37, 0x32, 0x30, 0x39, 0x34, 0x33, 0x33, 0x63, 0x61, 0x34, 0x32, 0x36, 0x30, 0x35, 0x65, 0x33, 0x39, 0x36, 0x35, 0x39, 0x38, 0x65, 0x33, 0x63, 0x37, 0x66, 0x35, 0x62, 0x31, 0x37, 0x33, 0x61, 0x30, 0x38, 0x35, 0x32, 0x66, 0x32, 0x36, 0x62, 0x33, 0x62, 0x65, 0x62, 0x64, 0x65, 0x31, 0x36, 0x65, 0x38, 0x32, 0x34, 0x34, 0x39, 0x39, 0x33, 0x34, 0x37, 0x33, 0x38, 0x61, 0x32, 0x63, 0x37, 0x37, 0x32, 0x66, 0x30, 0x30, 0x33, 0x33, 0x31, 0x38, 0x31, 0x37, 0x37, 0x66, 0x65, 0x38, 0x32, 0x32, 0x64, 0x31, 0x65, 0x62, 0x30, 0x32, 0x32, 0x62, 0x65, 0x31, 0x37, 0x38, 0x61, 0x30, 0x65, 0x61, 0x37, 0x30, 0x64, 0x63, 0x33, 0x33, 0x36, 0x31, 0x35, 0x31, 0x63, 0x31, 0x62, 0x30, 0x38, 0x38, 0x35, 0x62, 0x62, 0x39, 0x66, 0x32, 0x61, 0x32, 0x39, 0x30, 0x30, 0x39, 0x66, 0x65, 0x30, 0x37, 0x32, 0x38, 0x64, 0x31, 0x36, 0x37, 0x64, 0x37, 0x35, 0x32, 0x64, 0x64, 0x35, 0x36, 0x38, 0x39, 0x32, 0x34, 0x30, 0x38, 0x63, 0x65, 0x37, 0x65, 0x32, 0x65, 0x39, 0x65, 0x64, 0x38, 0x64, 0x66, 0x32, 0x62, 0x37, 0x64, 0x38, 0x65, 0x37, 0x30, 0x66, 0x64, 0x65, 0x34, 0x30, 0x33, 0x62, 0x33, 0x37, 0x35, 0x64, 0x30, 0x64, 0x38, 0x34, 0x63, 0x66, 0x64, 0x62, 0x66, 0x34, 0x64, 0x33, 0x33, 0x39, 0x36, 0x35, 0x64, 0x34, 0x37, 0x39, 0x62, 0x65, 0x30, 0x62, 0x30, 0x66, 0x39, 0x31, 0x34, 0x39, 0x66, 0x38, 0x64, 0x64, 0x64, 0x64, 0x62, 0x64, 0x36, 0x36, 0x37, 0x38, 0x63, 0x37, 0x62, 0x30, 0x30, 0x36, 0x38, 0x64, 0x30, 0x32, 0x63, 0x65, 0x30, 0x37, 0x33, 0x34, 0x36, 0x31, 0x65, 0x39, 0x61, 0x35, 0x39, 0x39, 0x39, 0x30, 0x36, 0x62, 0x66, 0x30, 0x37, 0x63, 0x66, 0x66, 0x32, 0x38, 0x34, 0x32, 0x66, 0x30, 0x64, 0x39, 0x64, 0x32, 0x39, 0x31, 0x62, 0x37, 0x34, 0x38, 0x61, 0x34, 0x37, 0x66, 0x62, 0x33, 0x38, 0x33, 0x63, 0x35, 0x33, 0x31, 0x37, 0x35, 0x39, 0x65, 0x36, 0x35, 0x66, 0x39, 0x32, 0x33, 0x64, 0x33, 0x64, 0x35, 0x62, 0x31, 0x33, 0x30, 0x33, 0x66, 0x32, 0x36, 0x34, 0x62, 0x34, 0x35, 0x61, 0x64, 0x36, 0x31, 0x39, 0x63, 0x31, 0x33, 0x36, 0x37, 0x37, 0x32, 0x38, 0x37, 0x37, 0x38, 0x31, 0x61, 0x34, 0x35, 0x62, 0x64, 0x61, 0x37, 0x33, 0x34, 0x32, 0x63, 0x63, 0x34, 0x38, 0x31, 0x33, 0x36, 0x62, 0x63, 0x66, 0x33, 0x36, 0x36, 0x35, 0x64, 0x38, 0x63, 0x62, 0x64, 0x38, 0x31, 0x38, 0x30, 0x35, 0x30, 0x64, 0x35, 0x65, 0x34, 0x32, 0x61, 0x31, 0x63, 0x32, 0x31, 0x30, 0x63, 0x32, 0x61, 0x65, 0x39, 0x30, 0x30, 0x64, 0x64, 0x39, 0x35, 0x37, 0x32, 0x35, 0x64, 0x61, 0x61, 0x61, 0x30, 0x62, 0x32, 0x33, 0x38, 0x38, 0x65, 0x66, 0x63, 0x65, 0x64, 0x61, 0x35, 0x33, 0x61, 0x39, 0x37, 0x64, 0x64, 0x32, 0x39, 0x63, 0x63, 0x32, 0x32, 0x62, 0x36, 0x30, 0x33, 0x34, 0x31, 0x39, 0x62, 0x36, 0x61, 0x30, 0x64, 0x31, 0x31, 0x37, 0x39, 0x65, 0x34, 0x64, 0x36, 0x31, 0x65, 0x39, 0x37, 0x62, 0x62, 0x39, 0x61, 0x31, 0x36, 0x65, 0x61, 0x37, 0x32, 0x65, 0x64, 0x65, 0x61, 0x38, 0x38, 0x62, 0x30, 0x61, 0x35, 0x39, 0x65, 0x32, 0x66, 0x35, 0x39, 0x38, 0x62, 0x32, 0x38, 0x33, 0x36, 0x39, 0x32, 0x37, 0x30, 0x64, 0x30, 0x34, 0x39, 0x31, 0x38, 0x64, 0x39, 0x30, 0x62, 0x33, 0x61, 0x61, 0x66, 0x62, 0x38, 0x31, 0x31, 0x35, 0x61, 0x35, 0x33, 0x35, 0x62, 0x33, 0x30, 0x32, 0x38, 0x39, 0x39, 0x36, 0x61, 0x65, 0x64, 0x35, 0x66, 0x33, 0x37, 0x34, 0x61, 0x38, 0x30, 0x65, 0x65, 0x65, 0x36, 0x33, 0x37, 0x32, 0x36, 0x65, 0x65, 0x66, 0x62, 0x64, 0x39, 0x37, 0x30, 0x63, 0x31, 0x62, 0x66, 0x30, 0x38, 0x65, 0x37, 0x33, 0x32, 0x34, 0x36, 0x63, 0x61, 0x30, 0x35, 0x39, 0x65, 0x30, 0x32, 0x61, 0x38, 0x38, 0x35, 0x30, 0x65, 0x66, 0x65, 0x64, 0x63, 0x34, 0x37, 0x36, 0x34, 0x64, 0x31, 0x33, 0x31, 0x66, 0x64, 0x33, 0x38, 0x37, 0x32, 0x65, 0x31, 0x34, 0x31, 0x36, 0x62, 0x35, 0x34, 0x35, 0x30, 0x65, 0x64, 0x30, 0x66, 0x32, 0x34, 0x36, 0x31, 0x61, 0x65, 0x35, 0x63, 0x34, 0x66, 0x65, 0x66, 0x36, 0x36, 0x65, 0x31, 0x66, 0x62, 0x63, 0x30, 0x36, 0x39, 0x63, 0x35, 0x35, 0x36, 0x37, 0x66, 0x35, 0x32, 0x63, 0x37, 0x65, 0x35, 0x36, 0x37, 0x64, 0x65, 0x66, 0x61, 0x34, 0x30, 0x33, 0x65, 0x33, 0x65, 0x30, 0x62, 0x37, 0x32, 0x32, 0x62, 0x33, 0x33, 0x64, 0x34, 0x63, 0x62, 0x31, 0x65, 0x35, 0x39, 0x38, 0x35, 0x30, 0x61, 0x63, 0x39, 0x35, 0x65, 0x33, 0x30, 0x65, 0x35, 0x34, 0x62, 0x62, 0x35, 0x36, 0x31, 0x34, 0x33, 0x37, 0x32, 0x36, 0x30, 0x31, 0x34, 0x36, 0x34, 0x61, 0x62, 0x63, 0x39, 0x61, 0x36, 0x61, 0x65, 0x64, 0x65, 0x30, 0x31, 0x33, 0x36, 0x63, 0x64, 0x38, 0x35, 0x62, 0x37, 0x35, 0x32, 0x37, 0x32, 0x63, 0x31, 0x37, 0x31, 0x37, 0x65, 0x63, 0x61, 0x65, 0x61, 0x35, 0x32, 0x30, 0x37, 0x31, 0x35, 0x66, 0x30, 0x62, 0x35, 0x61, 0x32, 0x37, 0x35, 0x31, 0x31, 0x65, 0x36, 0x36, 0x65, 0x32, 0x34, 0x62, 0x62, 0x34, 0x37, 0x61, 0x62, 0x35, 0x63, 0x31, 0x63, 0x30, 0x61, 0x30, 0x64, 0x66, 0x33, 0x30, 0x30, 0x32, 0x63, 0x32, 0x37, 0x38, 0x36, 0x38, 0x35, 0x63, 0x38, 0x30, 0x62, 0x34, 0x38, 0x65, 0x35, 0x39, 0x66, 0x39, 0x34, 0x64, 0x33, 0x30, 0x66, 0x35, 0x30, 0x38, 0x65, 0x64, 0x33, 0x65, 0x64, 0x62, 0x65, 0x66, 0x31, 0x31, 0x38, 0x32, 0x30, 0x62, 0x61, 0x32, 0x35, 0x33, 0x65, 0x30, 0x33, 0x64, 0x62, 0x32, 0x37, 0x62, 0x66, 0x65, 0x63, 0x63, 0x35, 0x65, 0x38, 0x65, 0x32, 0x36, 0x64, 0x31, 0x61, 0x32, 0x64, 0x37, 0x64, 0x32, 0x31, 0x63, 0x37, 0x37, 0x33, 0x37, 0x32, 0x38, 0x34, 0x39, 0x32, 0x36, 0x64, 0x39, 0x37, 0x62, 0x65, 0x31, 0x64, 0x37, 0x30, 0x62, 0x36, 0x62, 0x61, 0x39, 0x38, 0x64, 0x38, 0x30, 0x39, 0x61, 0x65, 0x31, 0x64, 0x65, 0x61, 0x30, 0x31, 0x36, 0x34, 0x64, 0x35, 0x35, 0x64, 0x30, 0x33, 0x62, 0x65, 0x38, 0x37, 0x66, 0x32, 0x38, 0x62, 0x33, 0x35, 0x35, 0x30, 0x32, 0x37, 0x38, 0x34, 0x35, 0x61, 0x36, 0x30, 0x31, 0x30, 0x37, 0x32, 0x33, 0x62, 0x64, 0x31, 0x64, 0x35, 0x35, 0x63, 0x65, 0x39, 0x66, 0x34, 0x34, 0x38, 0x61, 0x63, 0x61, 0x64, 0x39, 0x61, 0x31, 0x31, 0x62, 0x31, 0x36, 0x39, 0x30, 0x37, 0x34, 0x65, 0x64, 0x38, 0x39, 0x31, 0x34, 0x64, 0x61, 0x66, 0x66, 0x61, 0x64, 0x36, 0x37, 0x39, 0x34, 0x39, 0x32, 0x32, 0x31, 0x36, 0x63, 0x32, 0x64, 0x32, 0x35, 0x38, 0x36, 0x39, 0x31, 0x37, 0x38, 0x31, 0x37, 0x32, 0x34, 0x64, 0x34, 0x32, 0x31, 0x62, 0x61, 0x63, 0x39, 0x64, 0x32, 0x37, 0x30, 0x63, 0x61, 0x39, 0x62, 0x31, 0x66, 0x36, 0x62, 0x62, 0x63, 0x63, 0x30, 0x39, 0x30, 0x34, 0x66, 0x32, 0x65, 0x32, 0x31, 0x66, 0x39, 0x64, 0x64, 0x31, 0x65, 0x65, 0x39, 0x35, 0x61, 0x64, 0x39, 0x34, 0x64, 0x66, 0x62, 0x61, 0x62, 0x32, 0x62, 0x34, 0x65, 0x36, 0x33, 0x65, 0x35, 0x33, 0x62, 0x61, 0x33, 0x30, 0x65, 0x66, 0x38, 0x64, 0x35, 0x31, 0x32, 0x39, 0x38, 0x30, 0x62, 0x36, 0x34, 0x65, 0x35, 0x65, 0x62, 0x36, 0x34, 0x35, 0x64, 0x31, 0x34, 0x37, 0x62, 0x35, 0x35, 0x38, 0x61, 0x38, 0x36, 0x66, 0x30, 0x35, 0x62, 0x64, 0x33, 0x36, 0x64, 0x62, 0x61, 0x61, 0x66, 0x36, 0x36, 0x35, 0x33, 0x33, 0x39, 0x36, 0x30, 0x62, 0x36, 0x38, 0x33, 0x62, 0x64, 0x39, 0x62, 0x38, 0x32, 0x33, 0x36, 0x32, 0x32, 0x66, 0x33, 0x61, 0x36, 0x35, 0x61, 0x63, 0x36, 0x64, 0x36, 0x62, 0x37, 0x64, 0x33, 0x38, 0x39, 0x62, 0x37, 0x38, 0x65, 0x38, 0x31, 0x61, 0x32, 0x64, 0x62, 0x32, 0x36, 0x35, 0x37, 0x37, 0x33, 0x32, 0x30, 0x66, 0x33, 0x37, 0x65, 0x37, 0x35, 0x39, 0x62, 0x35, 0x64, 0x33, 0x65, 0x34, 0x36, 0x34, 0x37, 0x31, 0x39, 0x61, 0x30, 0x66, 0x33, 0x39, 0x30, 0x38, 0x31, 0x33, 0x31, 0x38, 0x30, 0x63, 0x38, 0x36, 0x63, 0x65, 0x65, 0x66, 0x38, 0x33, 0x31, 0x30, 0x64, 0x66, 0x36, 0x39, 0x66, 0x30, 0x65, 0x63, 0x64, 0x38, 0x36, 0x65, 0x36, 0x31, 0x63, 0x32, 0x64, 0x65, 0x64, 0x61, 0x38, 0x33, 0x62, 0x30, 0x30, 0x36, 0x34, 0x33, 0x62, 0x66, 0x38, 0x38, 0x30, 0x35, 0x32, 0x31, 0x38, 0x37, 0x30, 0x31, 0x63, 0x35, 0x35, 0x39, 0x66, 0x66, 0x35, 0x39, 0x62, 0x38, 0x37, 0x31, 0x35, 0x64, 0x64, 0x39, 0x33, 0x35, 0x31, 0x64, 0x30, 0x30, 0x30, 0x66, 0x33, 0x35, 0x32, 0x62, 0x33, 0x39, 0x33, 0x66, 0x65, 0x34, 0x33, 0x62, 0x35, 0x37, 0x38, 0x39, 0x61, 0x34, 0x35, 0x62, 0x62, 0x30, 0x36, 0x63, 0x31, 0x63, 0x66, 0x36, 0x64, 0x66, 0x65, 0x34, 0x62, 0x33, 0x62, 0x37, 0x32, 0x32, 0x66, 0x32, 0x39, 0x62, 0x64, 0x64, 0x63, 0x32, 0x63, 0x61, 0x39, 0x32, 0x36, 0x62, 0x30, 0x33, 0x37, 0x38, 0x30, 0x37, 0x33, 0x37, 0x62, 0x33, 0x30, 0x63, 0x65, 0x61, 0x30, 0x32, 0x36, 0x62, 0x38, 0x30, 0x32, 0x38, 0x38, 0x64, 0x36, 0x33, 0x61, 0x63, 0x34, 0x32, 0x39, 0x30, 0x37, 0x39, 0x34, 0x30, 0x38, 0x33, 0x62, 0x63, 0x32, 0x61, 0x64, 0x63, 0x38, 0x35, 0x35, 0x36, 0x32, 0x65, 0x64, 0x35, 0x37, 0x64, 0x66, 0x62, 0x65, 0x36, 0x61, 0x30, 0x38, 0x62, 0x37, 0x32, 0x35, 0x37, 0x66, 0x63, 0x37, 0x61, 0x61, 0x37, 0x30, 0x31, 0x38, 0x35, 0x32, 0x35, 0x63, 0x37, 0x31, 0x65, 0x30, 0x36, 0x65, 0x38, 0x39, 0x35, 0x65, 0x36, 0x35, 0x33, 0x66, 0x37, 0x31, 0x38, 0x32, 0x61, 0x62, 0x65, 0x38, 0x63, 0x63, 0x64, 0x39, 0x38, 0x36, 0x38, 0x33, 0x33, 0x30, 0x66, 0x34, 0x33, 0x33, 0x36, 0x32, 0x39, 0x33, 0x39, 0x64, 0x30, 0x32, 0x65, 0x66, 0x33, 0x32, 0x34, 0x31, 0x37, 0x36, 0x38, 0x63, 0x62, 0x62, 0x31, 0x39, 0x33, 0x66, 0x35, 0x39, 0x62, 0x65, 0x32, 0x62, 0x64, 0x35, 0x35, 0x64, 0x65, 0x62, 0x32, 0x66, 0x37, 0x36, 0x61, 0x34, 0x62, 0x64, 0x37, 0x66, 0x39, 0x33, 0x33, 0x38, 0x66, 0x34, 0x64, 0x32, 0x36, 0x62, 0x66, 0x65, 0x30, 0x63, 0x38, 0x37, 0x63, 0x65, 0x66, 0x34, 0x63, 0x36, 0x65, 0x30, 0x32, 0x31, 0x31, 0x33, 0x33, 0x36, 0x33, 0x63, 0x63, 0x34, 0x63, 0x37, 0x64, 0x34, 0x34, 0x61, 0x65, 0x63, 0x39, 0x66, 0x39, 0x61, 0x34, 0x61, 0x64, 0x30, 0x66, 0x37, 0x34, 0x38, 0x64, 0x62, 0x38, 0x36, 0x61, 0x39, 0x33, 0x66, 0x63, 0x30, 0x34, 0x33, 0x65, 0x39, 0x65, 0x61, 0x38, 0x37, 0x65, 0x34, 0x32, 0x66, 0x33, 0x62, 0x64, 0x61, 0x61, 0x61, 0x65, 0x31, 0x32, 0x30, 0x36, 0x36, 0x64, 0x38, 0x61, 0x61, 0x62, 0x37, 0x32, 0x31, 0x66, 0x39, 0x37, 0x33, 0x63, 0x66, 0x37, 0x63, 0x38, 0x33, 0x31, 0x62, 0x63, 0x64, 0x34, 0x32, 0x30, 0x32, 0x33, 0x61, 0x35, 0x36, 0x65, 0x64, 0x38, 0x61, 0x62, 0x63, 0x61, 0x32, 0x64, 0x63, 0x65, 0x63, 0x63, 0x66, 0x65, 0x66, 0x65, 0x62, 0x35, 0x30, 0x32, 0x66, 0x62, 0x30, 0x34, 0x39, 0x66, 0x62, 0x65, 0x31, 0x35, 0x63, 0x38, 0x31, 0x36, 0x66, 0x65, 0x35, 0x63, 0x37, 0x32, 0x36, 0x31, 0x36, 0x39, 0x63, 0x66, 0x37, 0x30, 0x63, 0x38, 0x30, 0x66, 0x34, 0x36, 0x37, 0x37, 0x36, 0x64, 0x38, 0x36, 0x36, 0x30, 0x30, 0x65, 0x34, 0x61, 0x61, 0x66, 0x31, 0x65, 0x62, 0x34, 0x38, 0x64, 0x38, 0x32, 0x37, 0x35, 0x37, 0x38, 0x38, 0x35, 0x64, 0x32, 0x30, 0x66, 0x66, 0x64, 0x36, 0x66, 0x64, 0x64, 0x34, 0x36, 0x38, 0x30, 0x38, 0x66, 0x37, 0x36, 0x64, 0x65, 0x34, 0x66, 0x39, 0x38, 0x35, 0x33, 0x38, 0x32, 0x61, 0x64, 0x65, 0x64, 0x65, 0x64, 0x37, 0x36, 0x38, 0x66, 0x34, 0x62, 0x64, 0x64, 0x30, 0x37, 0x33, 0x30, 0x34, 0x64, 0x33, 0x34, 0x36, 0x31, 0x62, 0x62, 0x39, 0x66, 0x66, 0x39, 0x64, 0x39, 0x62, 0x34, 0x32, 0x63, 0x62, 0x63, 0x61, 0x30, 0x63, 0x64, 0x63, 0x61, 0x36, 0x64, 0x61, 0x63, 0x65, 0x34, 0x61, 0x63, 0x34, 0x37, 0x35, 0x63, 0x30, 0x33, 0x37, 0x39, 0x34, 0x37, 0x30, 0x61, 0x39, 0x63, 0x65, 0x35, 0x39, 0x62, 0x39, 0x30, 0x32, 0x30, 0x66, 0x31, 0x31, 0x30, 0x33, 0x39, 0x38, 0x39, 0x63, 0x61, 0x33, 0x34, 0x32, 0x35, 0x39, 0x62, 0x66, 0x37, 0x32, 0x64, 0x63, 0x36, 0x34, 0x38, 0x65, 0x64, 0x64, 0x66, 0x30, 0x31, 0x65, 0x32, 0x32, 0x63, 0x66, 0x63, 0x63, 0x30, 0x30, 0x30, 0x62, 0x31, 0x64, 0x35, 0x61, 0x36, 0x32, 0x32, 0x38, 0x63, 0x62, 0x61, 0x35, 0x31, 0x35, 0x31, 0x39, 0x65, 0x64, 0x63, 0x32, 0x62, 0x31, 0x64, 0x37, 0x65, 0x30, 0x35, 0x30, 0x35, 0x39, 0x61, 0x39, 0x37, 0x38, 0x37, 0x31, 0x31, 0x39, 0x65, 0x61, 0x66, 0x34, 0x30, 0x63, 0x39, 0x37, 0x64, 0x37, 0x34, 0x61, 0x62, 0x37, 0x64, 0x36, 0x30, 0x66, 0x61, 0x36, 0x33, 0x64, 0x37, 0x35, 0x62, 0x39, 0x66, 0x34, 0x63, 0x38, 0x64, 0x30, 0x62, 0x61, 0x36, 0x66, 0x62, 0x38, 0x31, 0x35, 0x32, 0x63, 0x38, 0x30, 0x62, 0x36, 0x39, 0x38, 0x33, 0x38, 0x32, 0x61, 0x32, 0x39, 0x30, 0x30, 0x37, 0x63, 0x66, 0x31, 0x63, 0x30, 0x65, 0x37, 0x35, 0x65, 0x66, 0x62, 0x37, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x38, 0x37, 0x39, 0x61, 0x39, 0x32, 0x30, 0x62, 0x33, 0x66, 0x31, 0x32, 0x38, 0x34, 0x63, 0x64, 0x39, 0x63, 0x33, 0x39, 0x32, 0x66, 0x39, 0x39, 0x33, 0x32, 0x62, 0x36, 0x38, 0x62, 0x62, 0x39, 0x65, 0x33, 0x66, 0x32, 0x61, 0x37, 0x31, 0x36, 0x32, 0x35, 0x64, 0x30, 0x33, 0x39, 0x34, 0x33, 0x66, 0x64, 0x63, 0x38, 0x63, 0x32, 0x37, 0x38, 0x36, 0x39, 0x39, 0x65, 0x63, 0x32, 0x63, 0x34, 0x62, 0x61, 0x63, 0x30, 0x33, 0x66, 0x64, 0x32, 0x64, 0x64, 0x64, 0x62, 0x62, 0x62, 0x38, 0x61, 0x61, 0x36, 0x31, 0x62, 0x37, 0x32, 0x35, 0x39, 0x35, 0x38, 0x64, 0x39, 0x66, 0x35, 0x37, 0x66, 0x61, 0x36, 0x34, 0x32, 0x37, 0x30, 0x31, 0x39, 0x37, 0x63, 0x35, 0x36, 0x35, 0x33, 0x66, 0x34, 0x37, 0x34, 0x32, 0x38, 0x66, 0x64, 0x35, 0x32, 0x36, 0x35, 0x36, 0x33, 0x32, 0x33, 0x35, 0x36, 0x36, 0x37, 0x35, 0x36, 0x65, 0x31, 0x37, 0x32, 0x39, 0x36, 0x30, 0x66, 0x37, 0x62, 0x32, 0x61, 0x63, 0x64, 0x61, 0x38, 0x37, 0x32, 0x34, 0x30, 0x37, 0x33, 0x31, 0x64, 0x66, 0x34, 0x37, 0x31, 0x66, 0x61, 0x31, 0x35, 0x62, 0x38, 0x33, 0x62, 0x38, 0x39, 0x34, 0x66, 0x38, 0x62, 0x38, 0x38, 0x61, 0x62, 0x38, 0x64, 0x62, 0x66, 0x63, 0x30, 0x64, 0x30, 0x39, 0x66, 0x34, 0x62, 0x30, 0x35, 0x63, 0x36, 0x65, 0x35, 0x65, 0x33, 0x37, 0x37, 0x66, 0x36, 0x35, 0x62, 0x61, 0x34, 0x39, 0x30, 0x33, 0x62, 0x63, 0x30, 0x37, 0x32, 0x38, 0x34, 0x33, 0x33, 0x37, 0x35, 0x66, 0x39, 0x33, 0x63, 0x33, 0x35, 0x65, 0x63, 0x39, 0x38, 0x61, 0x38, 0x63, 0x37, 0x63, 0x38, 0x61, 0x39, 0x30, 0x31, 0x65, 0x36, 0x32, 0x65, 0x39, 0x62, 0x62, 0x30, 0x38, 0x61, 0x32, 0x33, 0x37, 0x34, 0x32, 0x38, 0x30, 0x37, 0x30, 0x39, 0x31, 0x39, 0x64, 0x30, 0x38, 0x39, 0x39, 0x63, 0x62, 0x62, 0x61, 0x35, 0x63, 0x66, 0x34, 0x35, 0x35, 0x63, 0x34, 0x66, 0x66, 0x33, 0x61, 0x33, 0x39, 0x66, 0x65, 0x38, 0x64, 0x34, 0x38, 0x62, 0x62, 0x36, 0x34, 0x32, 0x32, 0x31, 0x66, 0x38, 0x31, 0x30, 0x37, 0x61, 0x34, 0x32, 0x65, 0x34, 0x32, 0x35, 0x30, 0x63, 0x36, 0x35, 0x30, 0x65, 0x33, 0x61, 0x61, 0x37, 0x66, 0x37, 0x36, 0x64, 0x30, 0x61, 0x37, 0x30, 0x36, 0x64, 0x34, 0x30, 0x36, 0x61, 0x39, 0x64, 0x65, 0x34, 0x31, 0x35, 0x37, 0x32, 0x37, 0x66, 0x61, 0x66, 0x30, 0x35, 0x35, 0x33, 0x39, 0x64, 0x37, 0x66, 0x37, 0x62, 0x61, 0x38, 0x36, 0x30, 0x65, 0x30, 0x62, 0x39, 0x32, 0x39, 0x62, 0x37, 0x35, 0x32, 0x39, 0x37, 0x33, 0x63, 0x32, 0x39, 0x30, 0x35, 0x33, 0x38, 0x38, 0x38, 0x31, 0x39, 0x33, 0x66, 0x62, 0x64, 0x38, 0x32, 0x39, 0x62, 0x66, 0x31, 0x36, 0x35, 0x63, 0x37, 0x35, 0x33, 0x34, 0x33, 0x35, 0x63, 0x37, 0x32, 0x34, 0x36, 0x61, 0x65, 0x38, 0x35, 0x38, 0x35, 0x62, 0x36, 0x64, 0x61, 0x36, 0x63, 0x34, 0x33, 0x33, 0x34, 0x66, 0x33, 0x38, 0x36, 0x30, 0x38, 0x64, 0x34, 0x31, 0x63, 0x61, 0x38, 0x36, 0x35, 0x34, 0x61, 0x66, 0x65, 0x63, 0x65, 0x31, 0x31, 0x63, 0x61, 0x66, 0x39, 0x64, 0x64, 0x30, 0x36, 0x33, 0x66, 0x63, 0x37, 0x33, 0x31, 0x39, 0x65, 0x61, 0x35, 0x64, 0x34, 0x37, 0x63, 0x37, 0x32, 0x31, 0x35, 0x64, 0x31, 0x65, 0x34, 0x64, 0x62, 0x34, 0x39, 0x64, 0x37, 0x62, 0x66, 0x64, 0x64, 0x39, 0x33, 0x37, 0x32, 0x35, 0x64, 0x64, 0x64, 0x30, 0x38, 0x39, 0x63, 0x39, 0x37, 0x61, 0x61, 0x62, 0x34, 0x66, 0x36, 0x39, 0x30, 0x64, 0x64, 0x61, 0x34, 0x66, 0x65, 0x36, 0x36, 0x36, 0x66, 0x64, 0x65, 0x38, 0x62, 0x65, 0x64, 0x33, 0x37, 0x30, 0x30, 0x35, 0x36, 0x63, 0x35, 0x37, 0x32, 0x38, 0x35, 0x39, 0x31, 0x37, 0x61, 0x66, 0x37, 0x39, 0x63, 0x61, 0x61, 0x39, 0x39, 0x38, 0x30, 0x32, 0x31, 0x66, 0x39, 0x33, 0x66, 0x62, 0x34, 0x66, 0x63, 0x33, 0x38, 0x35, 0x39, 0x38, 0x33, 0x31, 0x37, 0x37, 0x66, 0x62, 0x31, 0x33, 0x32, 0x39, 0x32, 0x62, 0x39, 0x37, 0x61, 0x32, 0x36, 0x33, 0x65, 0x62, 0x31, 0x30, 0x38, 0x62, 0x39, 0x64, 0x30, 0x34, 0x39, 0x33, 0x61, 0x32, 0x35, 0x32, 0x37, 0x31, 0x65, 0x35, 0x31, 0x38, 0x33, 0x61, 0x38, 0x31, 0x61, 0x65, 0x32, 0x35, 0x32, 0x39, 0x37, 0x61, 0x32, 0x36, 0x37, 0x63, 0x64, 0x34, 0x32, 0x36, 0x39, 0x32, 0x38, 0x37, 0x35, 0x34, 0x61, 0x32, 0x66, 0x36, 0x39, 0x64, 0x32, 0x64, 0x61, 0x38, 0x61, 0x33, 0x36, 0x62, 0x65, 0x66, 0x38, 0x34, 0x32, 0x37, 0x37, 0x33, 0x62, 0x39, 0x37, 0x38, 0x62, 0x39, 0x39, 0x32, 0x36, 0x30, 0x66, 0x34, 0x62, 0x38, 0x64, 0x38, 0x30, 0x31, 0x38, 0x34, 0x38, 0x34, 0x65, 0x39, 0x35, 0x62, 0x36, 0x33, 0x38, 0x32, 0x35, 0x37, 0x39, 0x39, 0x65, 0x34, 0x31, 0x36, 0x61, 0x65, 0x38, 0x37, 0x32, 0x31, 0x37, 0x65, 0x30, 0x38, 0x66, 0x64, 0x66, 0x32, 0x39, 0x36, 0x61, 0x66, 0x66, 0x39, 0x36, 0x62, 0x61, 0x30, 0x64, 0x65, 0x39, 0x65, 0x63, 0x63, 0x62, 0x36, 0x66, 0x37, 0x32, 0x65, 0x34, 0x61, 0x62, 0x63, 0x63, 0x64, 0x30, 0x39, 0x33, 0x35, 0x39, 0x35, 0x36, 0x39, 0x34, 0x66, 0x37, 0x30, 0x30, 0x30, 0x65, 0x32, 0x62, 0x35, 0x31, 0x37, 0x62, 0x31, 0x35, 0x37, 0x66, 0x33, 0x61, 0x30, 0x64, 0x34, 0x64, 0x39, 0x38, 0x63, 0x66, 0x61, 0x38, 0x34, 0x31, 0x36, 0x36, 0x39, 0x35, 0x37, 0x63, 0x64, 0x65, 0x33, 0x30, 0x39, 0x65, 0x62, 0x61, 0x66, 0x38, 0x37, 0x32, 0x36, 0x36, 0x61, 0x66, 0x61, 0x63, 0x30, 0x35, 0x30, 0x65, 0x64, 0x34, 0x39, 0x30, 0x64, 0x31, 0x34, 0x31, 0x33, 0x37, 0x39, 0x61, 0x31, 0x63, 0x32, 0x63, 0x30, 0x62, 0x65, 0x63, 0x36, 0x31, 0x34, 0x35, 0x31, 0x62, 0x37, 0x39, 0x39, 0x65, 0x63, 0x66, 0x38, 0x37, 0x35, 0x64, 0x37, 0x34, 0x39, 0x64, 0x30, 0x66, 0x61, 0x35, 0x66, 0x35, 0x62, 0x61, 0x31, 0x37, 0x38, 0x38, 0x37, 0x32, 0x61, 0x31, 0x37, 0x39, 0x66, 0x66, 0x37, 0x37, 0x36, 0x33, 0x31, 0x35, 0x36, 0x61, 0x66, 0x35, 0x33, 0x31, 0x30, 0x35, 0x33, 0x37, 0x39, 0x35, 0x37, 0x30, 0x32, 0x61, 0x63, 0x32, 0x64, 0x34, 0x62, 0x30, 0x31, 0x65, 0x66, 0x35, 0x61, 0x65, 0x37, 0x39, 0x39, 0x30, 0x63, 0x65, 0x31, 0x35, 0x37, 0x64, 0x31, 0x33, 0x32, 0x61, 0x37, 0x38, 0x65, 0x33, 0x37, 0x37, 0x65, 0x39, 0x31, 0x38, 0x37, 0x30, 0x35, 0x39, 0x64, 0x35, 0x62, 0x30, 0x64, 0x35, 0x38, 0x64, 0x33, 0x37, 0x38, 0x39, 0x61, 0x61, 0x31, 0x30, 0x36, 0x37, 0x62, 0x63, 0x66, 0x37, 0x34, 0x37, 0x34, 0x33, 0x30, 0x37, 0x35, 0x63, 0x31, 0x62, 0x34, 0x37, 0x62, 0x63, 0x34, 0x37, 0x62, 0x39, 0x38, 0x31, 0x66, 0x35, 0x64, 0x38, 0x63, 0x35, 0x38, 0x30, 0x34, 0x37, 0x63, 0x39, 0x38, 0x34, 0x62, 0x39, 0x30, 0x62, 0x33, 0x32, 0x63, 0x37, 0x61, 0x63, 0x32, 0x35, 0x65, 0x65, 0x34, 0x34, 0x35, 0x66, 0x62, 0x36, 0x63, 0x62, 0x64, 0x63, 0x38, 0x38, 0x33, 0x30, 0x31, 0x37, 0x38, 0x65, 0x39, 0x36, 0x32, 0x64, 0x31, 0x32, 0x64, 0x33, 0x35, 0x32, 0x34, 0x64, 0x33, 0x39, 0x38, 0x65, 0x66, 0x34, 0x37, 0x38, 0x30, 0x61, 0x39, 0x66, 0x37, 0x35, 0x39, 0x34, 0x34, 0x30, 0x36, 0x33, 0x35, 0x62, 0x35, 0x37, 0x65, 0x36, 0x65, 0x39, 0x35, 0x63, 0x36, 0x36, 0x33, 0x66, 0x39, 0x35, 0x38, 0x35, 0x65, 0x64, 0x31, 0x61, 0x65, 0x33, 0x37, 0x39, 0x39, 0x38, 0x65, 0x61, 0x30, 0x65, 0x63, 0x30, 0x66, 0x63, 0x34, 0x61, 0x31, 0x37, 0x30, 0x38, 0x36, 0x34, 0x31, 0x64, 0x63, 0x65, 0x37, 0x30, 0x39, 0x38, 0x64, 0x63, 0x37, 0x61, 0x31, 0x64, 0x34, 0x32, 0x31, 0x39, 0x36, 0x61, 0x63, 0x37, 0x37, 0x32, 0x37, 0x64, 0x30, 0x32, 0x64, 0x38, 0x36, 0x62, 0x33, 0x66, 0x38, 0x31, 0x32, 0x37, 0x33, 0x34, 0x39, 0x64, 0x33, 0x66, 0x63, 0x34, 0x37, 0x30, 0x64, 0x37, 0x38, 0x32, 0x62, 0x66, 0x66, 0x62, 0x36, 0x32, 0x64, 0x31, 0x66, 0x30, 0x65, 0x34, 0x32, 0x36, 0x62, 0x31, 0x31, 0x64, 0x38, 0x31, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x31, 0x34, 0x37, 0x39, 0x61, 0x31, 0x65, 0x31, 0x30, 0x34, 0x64, 0x64, 0x65, 0x33, 0x62, 0x63, 0x63, 0x33, 0x38, 0x63, 0x31, 0x30, 0x63, 0x61, 0x39, 0x33, 0x37, 0x37, 0x66, 0x34, 0x34, 0x35, 0x34, 0x33, 0x65, 0x38, 0x64, 0x66, 0x32, 0x63, 0x61, 0x66, 0x66, 0x30, 0x63, 0x35, 0x39, 0x38, 0x30, 0x30, 0x38, 0x33, 0x61, 0x38, 0x33, 0x61, 0x39, 0x34, 0x39, 0x39, 0x64, 0x35, 0x65, 0x66, 0x36, 0x63, 0x38, 0x39, 0x66, 0x64, 0x33, 0x35, 0x30, 0x37, 0x31, 0x35, 0x33, 0x39, 0x37, 0x62, 0x31, 0x35, 0x37, 0x62, 0x66, 0x63, 0x33, 0x36, 0x62, 0x38, 0x33, 0x65, 0x30, 0x31, 0x34, 0x35, 0x35, 0x37, 0x39, 0x34, 0x65, 0x33, 0x34, 0x30, 0x31, 0x61, 0x37, 0x61, 0x38, 0x39, 0x35, 0x63, 0x66, 0x65, 0x63, 0x66, 0x33, 0x35, 0x31, 0x32, 0x64, 0x37, 0x37, 0x64, 0x33, 0x66, 0x38, 0x65, 0x35, 0x31, 0x37, 0x38, 0x63, 0x31, 0x64, 0x38, 0x37, 0x32, 0x33, 0x31, 0x31, 0x32, 0x64, 0x35, 0x62, 0x63, 0x30, 0x66, 0x35, 0x31, 0x36, 0x64, 0x33, 0x37, 0x31, 0x64, 0x62, 0x36, 0x34, 0x37, 0x64, 0x62, 0x38, 0x32, 0x65, 0x32, 0x63, 0x30, 0x64, 0x32, 0x35, 0x66, 0x36, 0x36, 0x31, 0x66, 0x65, 0x32, 0x31, 0x63, 0x61, 0x31, 0x37, 0x65, 0x62, 0x34, 0x34, 0x32, 0x63, 0x63, 0x36, 0x35, 0x37, 0x31, 0x39, 0x66, 0x65, 0x31, 0x62, 0x62, 0x31, 0x61, 0x61, 0x61, 0x30, 0x30, 0x38, 0x61, 0x63, 0x38, 0x66, 0x36, 0x31, 0x37, 0x37, 0x37, 0x65, 0x62, 0x62, 0x31, 0x66, 0x38, 0x61, 0x34, 0x34, 0x31, 0x61, 0x36, 0x62, 0x32, 0x31, 0x37, 0x62, 0x63, 0x30, 0x62, 0x62, 0x63, 0x65, 0x34, 0x31, 0x39, 0x66, 0x62, 0x39, 0x66, 0x34, 0x64, 0x65, 0x34, 0x36, 0x65, 0x37, 0x34, 0x62, 0x39, 0x65, 0x31, 0x30, 0x64, 0x33, 0x62, 0x64, 0x35, 0x30, 0x65, 0x64, 0x33, 0x35, 0x62, 0x64, 0x65, 0x33, 0x66, 0x36, 0x31, 0x30, 0x62, 0x38, 0x61, 0x37, 0x30, 0x38, 0x39, 0x36, 0x33, 0x63, 0x61, 0x39, 0x32, 0x34, 0x31, 0x62, 0x37, 0x30, 0x32, 0x66, 0x32, 0x36, 0x35, 0x30, 0x30, 0x36, 0x61, 0x37, 0x37, 0x61, 0x30, 0x34, 0x31, 0x32, 0x30, 0x64, 0x31, 0x34, 0x66, 0x32, 0x64, 0x36, 0x38, 0x64, 0x37, 0x36, 0x66, 0x34, 0x66, 0x65, 0x30, 0x37, 0x32, 0x30, 0x64, 0x35, 0x36, 0x37, 0x36, 0x64, 0x36, 0x64, 0x61, 0x64, 0x33, 0x39, 0x64, 0x38, 0x33, 0x33, 0x36, 0x63, 0x34, 0x35, 0x30, 0x65, 0x30, 0x34, 0x63, 0x31, 0x65, 0x65, 0x38, 0x37, 0x31, 0x37, 0x62, 0x37, 0x66, 0x33, 0x39, 0x30, 0x37, 0x63, 0x30, 0x62, 0x62, 0x35, 0x38, 0x64, 0x34, 0x61, 0x36, 0x66, 0x38, 0x34, 0x62, 0x64, 0x37, 0x39, 0x35, 0x39, 0x37, 0x61, 0x39, 0x37, 0x32, 0x32, 0x66, 0x63, 0x64, 0x33, 0x63, 0x31, 0x37, 0x66, 0x36, 0x31, 0x33, 0x32, 0x62, 0x34, 0x64, 0x39, 0x36, 0x64, 0x65, 0x65, 0x34, 0x32, 0x34, 0x65, 0x31, 0x64, 0x61, 0x61, 0x32, 0x33, 0x30, 0x65, 0x63, 0x65, 0x37, 0x34, 0x62, 0x61, 0x65, 0x34, 0x36, 0x36, 0x39, 0x37, 0x30, 0x62, 0x30, 0x35, 0x35, 0x64, 0x39, 0x36, 0x64, 0x66, 0x34, 0x39, 0x62, 0x37, 0x37, 0x35, 0x32, 0x37, 0x32, 0x62, 0x32, 0x63, 0x32, 0x62, 0x62, 0x39, 0x66, 0x33, 0x36, 0x63, 0x34, 0x34, 0x38, 0x34, 0x39, 0x35, 0x35, 0x34, 0x66, 0x31, 0x38, 0x39, 0x32, 0x32, 0x64, 0x37, 0x65, 0x33, 0x32, 0x33, 0x38, 0x37, 0x64, 0x63, 0x32, 0x39, 0x65, 0x39, 0x32, 0x39, 0x61, 0x31, 0x61, 0x62, 0x37, 0x62, 0x30, 0x34, 0x62, 0x38, 0x61, 0x61, 0x36, 0x35, 0x38, 0x35, 0x35, 0x31, 0x63, 0x37, 0x32, 0x37, 0x32, 0x38, 0x33, 0x32, 0x65, 0x64, 0x31, 0x34, 0x36, 0x35, 0x66, 0x61, 0x61, 0x39, 0x37, 0x34, 0x66, 0x61, 0x34, 0x37, 0x66, 0x65, 0x65, 0x34, 0x36, 0x34, 0x61, 0x36, 0x34, 0x33, 0x39, 0x63, 0x31, 0x63, 0x33, 0x38, 0x39, 0x36, 0x66, 0x36, 0x33, 0x65, 0x39, 0x38, 0x66, 0x66, 0x61, 0x38, 0x39, 0x66, 0x64, 0x30, 0x33, 0x31, 0x38, 0x34, 0x38, 0x33, 0x36, 0x35, 0x34, 0x38, 0x31, 0x37, 0x32, 0x31, 0x62, 0x32, 0x63, 0x35, 0x34, 0x36, 0x63, 0x35, 0x65, 0x30, 0x39, 0x30, 0x36, 0x66, 0x32, 0x34, 0x31, 0x30, 0x31, 0x66, 0x36, 0x33, 0x39, 0x63, 0x36, 0x34, 0x39, 0x61, 0x38, 0x38, 0x64, 0x65, 0x34, 0x30, 0x64, 0x62, 0x64, 0x30, 0x64, 0x61, 0x33, 0x61, 0x33, 0x65, 0x33, 0x61, 0x36, 0x35, 0x65, 0x34, 0x39, 0x62, 0x63, 0x65, 0x32, 0x38, 0x31, 0x62, 0x30, 0x35, 0x31, 0x35, 0x33, 0x39, 0x36, 0x31, 0x61, 0x66, 0x66, 0x34, 0x31, 0x33, 0x63, 0x62, 0x66, 0x64, 0x32, 0x38, 0x66, 0x63, 0x65, 0x39, 0x63, 0x61, 0x34, 0x31, 0x30, 0x66, 0x31, 0x34, 0x33, 0x39, 0x65, 0x35, 0x64, 0x36, 0x61, 0x64, 0x31, 0x34, 0x31, 0x30, 0x33, 0x38, 0x66, 0x36, 0x64, 0x34, 0x63, 0x31, 0x35, 0x63, 0x39, 0x61, 0x39, 0x61, 0x34, 0x62, 0x61, 0x61, 0x61, 0x38, 0x65, 0x30, 0x39, 0x37, 0x32, 0x35, 0x30, 0x32, 0x64, 0x38, 0x33, 0x64, 0x64, 0x39, 0x32, 0x31, 0x62, 0x33, 0x61, 0x36, 0x64, 0x33, 0x62, 0x38, 0x34, 0x39, 0x37, 0x39, 0x65, 0x33, 0x61, 0x36, 0x61, 0x61, 0x38, 0x66, 0x64, 0x32, 0x30, 0x35, 0x38, 0x38, 0x37, 0x63, 0x37, 0x35, 0x37, 0x30, 0x64, 0x31, 0x38, 0x65, 0x65, 0x36, 0x38, 0x30, 0x32, 0x65, 0x62, 0x34, 0x35, 0x32, 0x37, 0x30, 0x39, 0x66, 0x34, 0x31, 0x63, 0x65, 0x37, 0x39, 0x38, 0x61, 0x37, 0x31, 0x32, 0x36, 0x35, 0x65, 0x62, 0x61, 0x35, 0x38, 0x31, 0x37, 0x66, 0x39, 0x38, 0x33, 0x63, 0x61, 0x30, 0x62, 0x34, 0x35, 0x35, 0x36, 0x64, 0x31, 0x34, 0x34, 0x35, 0x65, 0x64, 0x35, 0x63, 0x61, 0x35, 0x62, 0x61, 0x34, 0x37, 0x32, 0x32, 0x39, 0x36, 0x65, 0x66, 0x31, 0x34, 0x63, 0x62, 0x35, 0x38, 0x66, 0x65, 0x39, 0x64, 0x30, 0x37, 0x32, 0x32, 0x66, 0x62, 0x65, 0x36, 0x37, 0x35, 0x31, 0x39, 0x66, 0x36, 0x31, 0x65, 0x64, 0x66, 0x31, 0x39, 0x30, 0x33, 0x35, 0x30, 0x61, 0x62, 0x66, 0x31, 0x38, 0x34, 0x61, 0x31, 0x35, 0x63, 0x66, 0x31, 0x31, 0x66, 0x31, 0x35, 0x36, 0x31, 0x65, 0x38, 0x36, 0x38, 0x39, 0x64, 0x35, 0x30, 0x33, 0x66, 0x31, 0x63, 0x35, 0x66, 0x39, 0x65, 0x33, 0x66, 0x30, 0x62, 0x63, 0x31, 0x30, 0x39, 0x37, 0x32, 0x65, 0x63, 0x64, 0x61, 0x61, 0x66, 0x32, 0x65, 0x39, 0x30, 0x35, 0x37, 0x62, 0x32, 0x66, 0x30, 0x66, 0x38, 0x62, 0x36, 0x65, 0x36, 0x31, 0x64, 0x35, 0x61, 0x61, 0x34, 0x30, 0x30, 0x39, 0x35, 0x64, 0x38, 0x66, 0x63, 0x30, 0x63, 0x62, 0x36, 0x30, 0x65, 0x66, 0x31, 0x33, 0x63, 0x61, 0x33, 0x61, 0x61, 0x65, 0x65, 0x66, 0x38, 0x34, 0x34, 0x66, 0x32, 0x32, 0x38, 0x64, 0x35, 0x34, 0x61, 0x62, 0x31, 0x34, 0x33, 0x30, 0x34, 0x36, 0x61, 0x64, 0x35, 0x39, 0x66, 0x36, 0x61, 0x36, 0x36, 0x66, 0x61, 0x36, 0x61, 0x35, 0x66, 0x61, 0x35, 0x37, 0x35, 0x30, 0x39, 0x61, 0x34, 0x61, 0x30, 0x35, 0x65, 0x37, 0x62, 0x34, 0x39, 0x32, 0x38, 0x64, 0x38, 0x34, 0x35, 0x30, 0x37, 0x61, 0x65, 0x36, 0x65, 0x63, 0x63, 0x32, 0x37, 0x64, 0x36, 0x66, 0x62, 0x36, 0x65, 0x62, 0x64, 0x34, 0x36, 0x33, 0x32, 0x64, 0x33, 0x35, 0x66, 0x66, 0x35, 0x61, 0x37, 0x65, 0x66, 0x34, 0x33, 0x64, 0x35, 0x33, 0x61, 0x64, 0x37, 0x30, 0x39, 0x36, 0x64, 0x61, 0x38, 0x64, 0x63, 0x31, 0x64, 0x61, 0x39, 0x36, 0x62, 0x64, 0x64, 0x39, 0x34, 0x65, 0x30, 0x35, 0x36, 0x35, 0x37, 0x37, 0x64, 0x31, 0x33, 0x31, 0x61, 0x38, 0x32, 0x35, 0x30, 0x35, 0x35, 0x61, 0x62, 0x66, 0x36, 0x34, 0x65, 0x37, 0x32, 0x34, 0x30, 0x34, 0x31, 0x65, 0x62, 0x62, 0x63, 0x33, 0x34, 0x61, 0x38, 0x34, 0x65, 0x38, 0x33, 0x34, 0x35, 0x35, 0x38, 0x30, 0x66, 0x37, 0x30, 0x30, 0x35, 0x37, 0x64, 0x31, 0x37, 0x37, 0x34, 0x37, 0x63, 0x30, 0x65, 0x62, 0x66, 0x34, 0x32, 0x30, 0x35, 0x66, 0x37, 0x36, 0x33, 0x36, 0x37, 0x61, 0x33, 0x32, 0x36, 0x33, 0x64, 0x65, 0x32, 0x64, 0x65, 0x36, 0x30, 0x34, 0x63, 0x36, 0x31, 0x61, 0x36, 0x35, 0x39, 0x63, 0x37, 0x32, 0x36, 0x36, 0x32, 0x32, 0x31, 0x31, 0x63, 0x66, 0x66, 0x63, 0x35, 0x61, 0x30, 0x62, 0x66, 0x63, 0x36, 0x39, 0x33, 0x66, 0x35, 0x33, 0x32, 0x32, 0x34, 0x36, 0x36, 0x66, 0x33, 0x64, 0x66, 0x61, 0x61, 0x64, 0x66, 0x32, 0x66, 0x30, 0x39, 0x36, 0x35, 0x30, 0x62, 0x31, 0x61, 0x37, 0x37, 0x37, 0x30, 0x35, 0x65, 0x30, 0x38, 0x33, 0x61, 0x37, 0x32, 0x66, 0x64, 0x65, 0x34, 0x31, 0x35, 0x63, 0x33, 0x36, 0x38, 0x39, 0x62, 0x33, 0x65, 0x63, 0x38, 0x32, 0x61, 0x66, 0x61, 0x31, 0x64, 0x37, 0x35, 0x37, 0x32, 0x32, 0x32, 0x65, 0x38, 0x36, 0x32, 0x37, 0x61, 0x30, 0x37, 0x37, 0x64, 0x30, 0x37, 0x30, 0x62, 0x39, 0x62, 0x33, 0x64, 0x62, 0x38, 0x36, 0x34, 0x37, 0x37, 0x35, 0x39, 0x62, 0x62, 0x62, 0x32, 0x39, 0x31, 0x38, 0x62, 0x31, 0x36, 0x30, 0x63, 0x39, 0x65, 0x30, 0x35, 0x38, 0x62, 0x62, 0x35, 0x37, 0x38, 0x36, 0x33, 0x62, 0x62, 0x36, 0x64, 0x65, 0x62, 0x62, 0x31, 0x63, 0x61, 0x32, 0x36, 0x30, 0x64, 0x63, 0x63, 0x32, 0x32, 0x62, 0x66, 0x38, 0x32, 0x32, 0x62, 0x37, 0x64, 0x64, 0x37, 0x30, 0x38, 0x61, 0x61, 0x31, 0x33, 0x66, 0x61, 0x37, 0x30, 0x36, 0x33, 0x35, 0x35, 0x30, 0x31, 0x66, 0x37, 0x37, 0x35, 0x30, 0x63, 0x30, 0x66, 0x63, 0x32, 0x63, 0x66, 0x36, 0x31, 0x38, 0x62, 0x34, 0x66, 0x65, 0x37, 0x61, 0x66, 0x65, 0x36, 0x34, 0x65, 0x64, 0x65, 0x35, 0x35, 0x31, 0x63, 0x37, 0x64, 0x63, 0x30, 0x64, 0x37, 0x34, 0x62, 0x39, 0x63, 0x31, 0x61, 0x33, 0x34, 0x62, 0x30, 0x65, 0x35, 0x61, 0x30, 0x36, 0x62, 0x65, 0x63, 0x34, 0x39, 0x33, 0x35, 0x62, 0x39, 0x61, 0x31, 0x35, 0x62, 0x32, 0x35, 0x37, 0x32, 0x33, 0x64, 0x35, 0x66, 0x37, 0x62, 0x36, 0x38, 0x31, 0x33, 0x33, 0x37, 0x63, 0x63, 0x31, 0x35, 0x38, 0x37, 0x33, 0x37, 0x32, 0x34, 0x35, 0x34, 0x30, 0x64, 0x35, 0x32, 0x32, 0x34, 0x34, 0x66, 0x34, 0x31, 0x64, 0x63, 0x61, 0x64, 0x36, 0x37, 0x36, 0x35, 0x39, 0x32, 0x34, 0x39, 0x33, 0x63, 0x66, 0x32, 0x39, 0x32, 0x36, 0x34, 0x37, 0x34, 0x35, 0x35, 0x34, 0x36, 0x36, 0x61, 0x35, 0x64, 0x65, 0x31, 0x64, 0x39, 0x30, 0x66, 0x34, 0x30, 0x61, 0x66, 0x64, 0x32, 0x61, 0x35, 0x38, 0x33, 0x64, 0x64, 0x38, 0x34, 0x31, 0x66, 0x30, 0x33, 0x39, 0x35, 0x35, 0x32, 0x64, 0x31, 0x63, 0x36, 0x35, 0x66, 0x37, 0x34, 0x37, 0x33, 0x66, 0x30, 0x34, 0x66, 0x33, 0x65, 0x35, 0x39, 0x34, 0x39, 0x31, 0x62, 0x32, 0x35, 0x33, 0x34, 0x32, 0x38, 0x30, 0x38, 0x39, 0x31, 0x31, 0x38, 0x37, 0x32, 0x66, 0x39, 0x66, 0x63, 0x30, 0x61, 0x61, 0x64, 0x36, 0x32, 0x36, 0x63, 0x35, 0x33, 0x35, 0x36, 0x39, 0x63, 0x34, 0x65, 0x66, 0x63, 0x39, 0x33, 0x65, 0x38, 0x38, 0x61, 0x30, 0x63, 0x61, 0x34, 0x65, 0x64, 0x61, 0x39, 0x63, 0x65, 0x34, 0x38, 0x38, 0x37, 0x65, 0x39, 0x33, 0x33, 0x34, 0x65, 0x62, 0x64, 0x36, 0x35, 0x65, 0x32, 0x34, 0x33, 0x31, 0x37, 0x63, 0x66, 0x61, 0x37, 0x37, 0x32, 0x32, 0x35, 0x66, 0x63, 0x30, 0x65, 0x37, 0x30, 0x33, 0x38, 0x62, 0x63, 0x30, 0x36, 0x64, 0x33, 0x62, 0x62, 0x66, 0x62, 0x31, 0x66, 0x34, 0x63, 0x62, 0x36, 0x37, 0x30, 0x63, 0x33, 0x64, 0x65, 0x37, 0x64, 0x35, 0x37, 0x63, 0x36, 0x32, 0x35, 0x37, 0x38, 0x62, 0x64, 0x64, 0x38, 0x65, 0x35, 0x36, 0x65, 0x66, 0x63, 0x65, 0x38, 0x38, 0x61, 0x65, 0x33, 0x62, 0x39, 0x30, 0x38, 0x37, 0x32, 0x62, 0x30, 0x63, 0x30, 0x32, 0x63, 0x65, 0x34, 0x61, 0x30, 0x39, 0x31, 0x34, 0x65, 0x33, 0x66, 0x39, 0x33, 0x38, 0x36, 0x64, 0x38, 0x36, 0x38, 0x37, 0x34, 0x66, 0x61, 0x39, 0x66, 0x30, 0x62, 0x61, 0x31, 0x30, 0x31, 0x62, 0x63, 0x62, 0x39, 0x32, 0x35, 0x36, 0x30, 0x35, 0x61, 0x63, 0x62, 0x31, 0x63, 0x32, 0x32, 0x30, 0x31, 0x31, 0x64, 0x36, 0x30, 0x32, 0x35, 0x61, 0x63, 0x37, 0x32, 0x38, 0x38, 0x35, 0x64, 0x61, 0x34, 0x64, 0x33, 0x31, 0x37, 0x31, 0x32, 0x35, 0x33, 0x30, 0x34, 0x33, 0x33, 0x63, 0x64, 0x36, 0x66, 0x38, 0x38, 0x63, 0x36, 0x39, 0x62, 0x35, 0x32, 0x38, 0x34, 0x66, 0x34, 0x64, 0x36, 0x66, 0x35, 0x39, 0x63, 0x39, 0x33, 0x36, 0x61, 0x38, 0x63, 0x62, 0x66, 0x65, 0x62, 0x35, 0x35, 0x61, 0x35, 0x64, 0x32, 0x66, 0x64, 0x37, 0x33, 0x62, 0x38, 0x31, 0x37, 0x61, 0x66, 0x37, 0x36, 0x62, 0x32, 0x32, 0x62, 0x63, 0x35, 0x30, 0x65, 0x62, 0x61, 0x36, 0x66, 0x30, 0x35, 0x65, 0x34, 0x64, 0x63, 0x38, 0x34, 0x36, 0x39, 0x66, 0x32, 0x34, 0x61, 0x65, 0x37, 0x38, 0x30, 0x33, 0x30, 0x30, 0x37, 0x31, 0x36, 0x61, 0x39, 0x36, 0x33, 0x62, 0x66, 0x66, 0x63, 0x63, 0x31, 0x36, 0x62, 0x34, 0x34, 0x65, 0x63, 0x30, 0x30, 0x31, 0x64, 0x34, 0x34, 0x37, 0x32, 0x30, 0x32, 0x31, 0x36, 0x36, 0x63, 0x33, 0x63, 0x61, 0x63, 0x32, 0x34, 0x30, 0x39, 0x35, 0x61, 0x66, 0x39, 0x31, 0x61, 0x62, 0x30, 0x63, 0x61, 0x65, 0x62, 0x64, 0x65, 0x39, 0x37, 0x63, 0x61, 0x62, 0x65, 0x31, 0x30, 0x33, 0x63, 0x66, 0x32, 0x30, 0x36, 0x64, 0x31, 0x34, 0x65, 0x63, 0x64, 0x63, 0x32, 0x31, 0x30, 0x34, 0x61, 0x35, 0x31, 0x39, 0x64, 0x66, 0x65, 0x62, 0x32, 0x32, 0x31, 0x38, 0x31, 0x33, 0x33, 0x30, 0x35, 0x33, 0x39, 0x63, 0x66, 0x31, 0x37, 0x33, 0x30, 0x31, 0x66, 0x35, 0x34, 0x66, 0x66, 0x65, 0x62, 0x37, 0x61, 0x34, 0x32, 0x30, 0x65, 0x36, 0x61, 0x66, 0x66, 0x62, 0x65, 0x66, 0x38, 0x31, 0x37, 0x66, 0x61, 0x30, 0x31, 0x37, 0x64, 0x32, 0x30, 0x63, 0x62, 0x30, 0x63, 0x66, 0x33, 0x35, 0x62, 0x66, 0x39, 0x30, 0x66, 0x61, 0x66, 0x36, 0x39, 0x34, 0x61, 0x35, 0x34, 0x37, 0x31, 0x33, 0x31, 0x64, 0x36, 0x66, 0x39, 0x65, 0x36, 0x34, 0x34, 0x63, 0x32, 0x37, 0x35, 0x62, 0x66, 0x30, 0x61, 0x62, 0x63, 0x33, 0x35, 0x37, 0x34, 0x61, 0x33, 0x32, 0x38, 0x34, 0x35, 0x35, 0x35, 0x38, 0x61, 0x62, 0x62, 0x33, 0x63, 0x38, 0x39, 0x65, 0x61, 0x34, 0x35, 0x66, 0x64, 0x64, 0x65, 0x64, 0x30, 0x38, 0x61, 0x62, 0x32, 0x33, 0x62, 0x37, 0x36, 0x37, 0x32, 0x35, 0x62, 0x61, 0x30, 0x64, 0x33, 0x36, 0x65, 0x62, 0x35, 0x62, 0x38, 0x61, 0x65, 0x32, 0x61, 0x33, 0x61, 0x62, 0x30, 0x63, 0x63, 0x30, 0x61, 0x30, 0x37, 0x61, 0x63, 0x34, 0x63, 0x32, 0x63, 0x63, 0x64, 0x37, 0x34, 0x37, 0x37, 0x39, 0x37, 0x39, 0x38, 0x62, 0x31, 0x39, 0x30, 0x36, 0x31, 0x66, 0x61, 0x35, 0x31, 0x31, 0x38, 0x30, 0x65, 0x66, 0x34, 0x34, 0x65, 0x66, 0x34, 0x37, 0x32, 0x34, 0x39, 0x32, 0x61, 0x36, 0x37, 0x39, 0x31, 0x63, 0x62, 0x37, 0x36, 0x32, 0x30, 0x65, 0x38, 0x30, 0x61, 0x64, 0x65, 0x34, 0x62, 0x36, 0x64, 0x31, 0x30, 0x35, 0x30, 0x33, 0x66, 0x38, 0x37, 0x62, 0x61, 0x32, 0x36, 0x34, 0x32, 0x62, 0x30, 0x63, 0x65, 0x35, 0x62, 0x64, 0x34, 0x35, 0x33, 0x61, 0x34, 0x35, 0x62, 0x35, 0x38, 0x36, 0x64, 0x39, 0x35, 0x30, 0x36, 0x63, 0x33, 0x37, 0x32, 0x37, 0x35, 0x32, 0x39, 0x66, 0x65, 0x35, 0x31, 0x34, 0x30, 0x32, 0x38, 0x62, 0x33, 0x30, 0x61, 0x62, 0x32, 0x65, 0x35, 0x65, 0x31, 0x37, 0x65, 0x32, 0x64, 0x34, 0x61, 0x65, 0x63, 0x30, 0x65, 0x33, 0x33, 0x64, 0x38, 0x30, 0x30, 0x39, 0x63, 0x37, 0x34, 0x39, 0x39, 0x35, 0x66, 0x66, 0x66, 0x38, 0x62, 0x61, 0x66, 0x35, 0x34, 0x30, 0x31, 0x33, 0x38, 0x38, 0x38, 0x31, 0x66, 0x37, 0x32, 0x64, 0x33, 0x37, 0x66, 0x62, 0x63, 0x66, 0x35, 0x36, 0x31, 0x31, 0x66, 0x63, 0x30, 0x33, 0x38, 0x39, 0x66, 0x63, 0x65, 0x31, 0x31, 0x65, 0x31, 0x62, 0x63, 0x64, 0x33, 0x66, 0x31, 0x38, 0x38, 0x35, 0x66, 0x66, 0x35, 0x32, 0x38, 0x30, 0x61, 0x31, 0x31, 0x35, 0x30, 0x38, 0x65, 0x34, 0x66, 0x61, 0x34, 0x37, 0x61, 0x39, 0x39, 0x33, 0x64, 0x33, 0x37, 0x30, 0x36, 0x30, 0x36, 0x37, 0x32, 0x36, 0x34, 0x63, 0x61, 0x33, 0x34, 0x38, 0x32, 0x62, 0x30, 0x32, 0x63, 0x38, 0x36, 0x39, 0x32, 0x63, 0x66, 0x39, 0x38, 0x61, 0x63, 0x63, 0x38, 0x38, 0x32, 0x31, 0x30, 0x35, 0x31, 0x36, 0x37, 0x37, 0x61, 0x36, 0x36, 0x38, 0x38, 0x31, 0x38, 0x64, 0x35, 0x62, 0x65, 0x37, 0x61, 0x32, 0x38, 0x38, 0x38, 0x64, 0x64, 0x37, 0x31, 0x39, 0x36, 0x36, 0x33, 0x30, 0x61, 0x30, 0x39, 0x35, 0x64, 0x33, 0x30, 0x64, 0x65, 0x33, 0x32, 0x34, 0x33, 0x39, 0x30, 0x65, 0x35, 0x35, 0x34, 0x61, 0x31, 0x64, 0x62, 0x35, 0x31, 0x34, 0x31, 0x32, 0x33, 0x35, 0x65, 0x35, 0x35, 0x62, 0x62, 0x66, 0x62, 0x35, 0x37, 0x35, 0x31, 0x66, 0x64, 0x64, 0x66, 0x37, 0x30, 0x61, 0x38, 0x66, 0x61, 0x65, 0x32, 0x33, 0x64, 0x37, 0x35, 0x38, 0x31, 0x31, 0x37, 0x66, 0x37, 0x31, 0x61, 0x33, 0x35, 0x37, 0x32, 0x38, 0x37, 0x37, 0x34, 0x63, 0x64, 0x32, 0x36, 0x30, 0x39, 0x33, 0x39, 0x32, 0x37, 0x31, 0x39, 0x39, 0x64, 0x63, 0x63, 0x39, 0x61, 0x65, 0x32, 0x65, 0x35, 0x63, 0x61, 0x31, 0x32, 0x64, 0x63, 0x61, 0x39, 0x36, 0x64, 0x38, 0x31, 0x37, 0x36, 0x34, 0x61, 0x64, 0x33, 0x66, 0x33, 0x63, 0x63, 0x37, 0x34, 0x39, 0x33, 0x32, 0x33, 0x39, 0x65, 0x64, 0x39, 0x32, 0x37, 0x61, 0x65, 0x37, 0x32, 0x66, 0x35, 0x31, 0x35, 0x61, 0x33, 0x66, 0x63, 0x30, 0x39, 0x33, 0x38, 0x63, 0x63, 0x33, 0x63, 0x32, 0x36, 0x38, 0x32, 0x31, 0x33, 0x33, 0x65, 0x35, 0x38, 0x61, 0x61, 0x65, 0x33, 0x61, 0x62, 0x33, 0x38, 0x66, 0x30, 0x62, 0x64, 0x62, 0x35, 0x30, 0x66, 0x39, 0x65, 0x62, 0x32, 0x64, 0x37, 0x36, 0x30, 0x35, 0x64, 0x33, 0x30, 0x34, 0x37, 0x37, 0x36, 0x66, 0x35, 0x33, 0x65, 0x37, 0x32, 0x63, 0x35, 0x66, 0x33, 0x61, 0x64, 0x36, 0x33, 0x63, 0x32, 0x37, 0x64, 0x33, 0x38, 0x61, 0x63, 0x63, 0x30, 0x33, 0x63, 0x34, 0x35, 0x32, 0x31, 0x34, 0x31, 0x61, 0x63, 0x63, 0x33, 0x36, 0x33, 0x63, 0x31, 0x37, 0x63, 0x66, 0x65, 0x37, 0x32, 0x39, 0x30, 0x64, 0x61, 0x39, 0x66, 0x63, 0x33, 0x62, 0x61, 0x62, 0x61, 0x36, 0x32, 0x62, 0x32, 0x63, 0x66, 0x33, 0x30, 0x31, 0x64, 0x36, 0x64, 0x63, 0x66, 0x63, 0x34, 0x36, 0x32, 0x36, 0x30, 0x31, 0x34, 0x61, 0x65, 0x38, 0x66, 0x35, 0x65, 0x33, 0x30, 0x36, 0x39, 0x34, 0x66, 0x36, 0x30, 0x34, 0x34, 0x31, 0x32, 0x66, 0x61, 0x65, 0x62, 0x61, 0x36, 0x38, 0x35, 0x66, 0x31, 0x39, 0x61, 0x34, 0x34, 0x62, 0x37, 0x64, 0x62, 0x34, 0x63, 0x30, 0x33, 0x36, 0x63, 0x33, 0x63, 0x36, 0x63, 0x30, 0x35, 0x34, 0x30, 0x62, 0x65, 0x37, 0x32, 0x30, 0x30, 0x61, 0x30, 0x32, 0x63, 0x65, 0x30, 0x64, 0x33, 0x34, 0x31, 0x35, 0x34, 0x66, 0x62, 0x31, 0x61, 0x35, 0x61, 0x65, 0x38, 0x39, 0x30, 0x62, 0x32, 0x62, 0x63, 0x32, 0x64, 0x35, 0x62, 0x36, 0x63, 0x64, 0x64, 0x62, 0x61, 0x63, 0x66, 0x61, 0x34, 0x37, 0x61, 0x34, 0x38, 0x39, 0x38, 0x63, 0x33, 0x35, 0x62, 0x62, 0x31, 0x39, 0x32, 0x30, 0x62, 0x63, 0x35, 0x37, 0x62, 0x37, 0x32, 0x65, 0x65, 0x65, 0x33, 0x32, 0x63, 0x34, 0x38, 0x65, 0x36, 0x38, 0x36, 0x37, 0x33, 0x66, 0x61, 0x35, 0x34, 0x64, 0x39, 0x33, 0x63, 0x35, 0x64, 0x32, 0x32, 0x62, 0x62, 0x38, 0x35, 0x61, 0x31, 0x61, 0x34, 0x65, 0x39, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x38, 0x65, 0x63, 0x64, 0x64, 0x33, 0x35, 0x62, 0x30, 0x34, 0x32, 0x37, 0x64, 0x32, 0x33, 0x31, 0x31, 0x37, 0x30, 0x36, 0x30, 0x33, 0x39, 0x64, 0x39, 0x31, 0x30, 0x33, 0x34, 0x34, 0x35, 0x36, 0x31, 0x62, 0x36, 0x31, 0x35, 0x34, 0x30, 0x36, 0x65, 0x37, 0x63, 0x37, 0x39, 0x30, 0x64, 0x34, 0x66, 0x35, 0x30, 0x65, 0x33, 0x37, 0x64, 0x39, 0x35, 0x63, 0x30, 0x65, 0x31, 0x35, 0x66, 0x63, 0x65, 0x35, 0x65, 0x34, 0x38, 0x34, 0x38, 0x36, 0x31, 0x31, 0x31, 0x34, 0x66, 0x61, 0x38, 0x38, 0x61, 0x62, 0x63, 0x36, 0x32, 0x65, 0x34, 0x34, 0x36, 0x63, 0x66, 0x62, 0x36, 0x64, 0x36, 0x38, 0x32, 0x61, 0x36, 0x62, 0x61, 0x32, 0x33, 0x36, 0x65, 0x33, 0x30, 0x39, 0x37, 0x32, 0x66, 0x33, 0x61, 0x61, 0x38, 0x63, 0x37, 0x36, 0x64, 0x33, 0x39, 0x64, 0x61, 0x33, 0x31, 0x65, 0x64, 0x36, 0x61, 0x32, 0x34, 0x61, 0x36, 0x30, 0x64, 0x33, 0x32, 0x34, 0x34, 0x65, 0x33, 0x64, 0x33, 0x34, 0x37, 0x36, 0x32, 0x32, 0x34, 0x35, 0x38, 0x30, 0x63, 0x39, 0x66, 0x61, 0x38, 0x36, 0x66, 0x37, 0x61, 0x39, 0x61, 0x64, 0x63, 0x32, 0x66, 0x32, 0x33, 0x37, 0x37, 0x38, 0x35, 0x66, 0x66, 0x65, 0x36, 0x35, 0x36, 0x61, 0x37, 0x34, 0x61, 0x37, 0x39, 0x31, 0x62, 0x34, 0x35, 0x63, 0x34, 0x38, 0x36, 0x64, 0x38, 0x33, 0x33, 0x36, 0x39, 0x35, 0x64, 0x36, 0x38, 0x65, 0x62, 0x34, 0x35, 0x64, 0x64, 0x38, 0x30, 0x61, 0x37, 0x32, 0x35, 0x34, 0x62, 0x32, 0x32, 0x39, 0x39, 0x36, 0x61, 0x65, 0x65, 0x38, 0x62, 0x63, 0x31, 0x64, 0x36, 0x63, 0x64, 0x65, 0x31, 0x35, 0x31, 0x34, 0x32, 0x64, 0x39, 0x32, 0x35, 0x62, 0x33, 0x63, 0x61, 0x31, 0x61, 0x33, 0x36, 0x64, 0x38, 0x66, 0x34, 0x38, 0x30, 0x33, 0x34, 0x35, 0x30, 0x35, 0x66, 0x38, 0x65, 0x61, 0x38, 0x38, 0x63, 0x33, 0x38, 0x39, 0x36, 0x33, 0x65, 0x62, 0x37, 0x32, 0x64, 0x65, 0x62, 0x65, 0x61, 0x65, 0x30, 0x66, 0x37, 0x36, 0x34, 0x34, 0x30, 0x34, 0x34, 0x34, 0x38, 0x34, 0x62, 0x37, 0x31, 0x38, 0x37, 0x65, 0x33, 0x38, 0x64, 0x63, 0x30, 0x33, 0x36, 0x36, 0x64, 0x31, 0x35, 0x64, 0x31, 0x62, 0x61, 0x64, 0x66, 0x63, 0x61, 0x61, 0x37, 0x35, 0x66, 0x65, 0x62, 0x65, 0x36, 0x36, 0x30, 0x33, 0x36, 0x32, 0x30, 0x64, 0x62, 0x36, 0x34, 0x38, 0x37, 0x32, 0x36, 0x31, 0x33, 0x37, 0x35, 0x64, 0x65, 0x39, 0x30, 0x30, 0x30, 0x39, 0x35, 0x31, 0x36, 0x33, 0x32, 0x66, 0x65, 0x36, 0x32, 0x65, 0x35, 0x32, 0x66, 0x65, 0x65, 0x34, 0x38, 0x32, 0x31, 0x35, 0x66, 0x39, 0x36, 0x30, 0x31, 0x32, 0x38, 0x64, 0x62, 0x36, 0x62, 0x37, 0x66, 0x63, 0x61, 0x61, 0x36, 0x63, 0x30, 0x36, 0x65, 0x34, 0x62, 0x30, 0x38, 0x30, 0x64, 0x32, 0x65, 0x63, 0x37, 0x32, 0x64, 0x31, 0x65, 0x62, 0x34, 0x65, 0x36, 0x39, 0x64, 0x30, 0x31, 0x32, 0x66, 0x30, 0x66, 0x65, 0x62, 0x38, 0x35, 0x38, 0x64, 0x63, 0x37, 0x32, 0x61, 0x39, 0x63, 0x61, 0x30, 0x63, 0x32, 0x30, 0x38, 0x39, 0x37, 0x33, 0x63, 0x36, 0x35, 0x35, 0x63, 0x36, 0x33, 0x63, 0x37, 0x63, 0x63, 0x65, 0x39, 0x66, 0x39, 0x37, 0x30, 0x31, 0x32, 0x63, 0x34, 0x61, 0x30, 0x63, 0x30, 0x61, 0x37, 0x32, 0x30, 0x35, 0x33, 0x36, 0x37, 0x37, 0x37, 0x39, 0x65, 0x39, 0x35, 0x39, 0x33, 0x30, 0x35, 0x61, 0x36, 0x35, 0x33, 0x32, 0x36, 0x32, 0x64, 0x35, 0x64, 0x33, 0x37, 0x35, 0x61, 0x37, 0x62, 0x31, 0x33, 0x32, 0x32, 0x36, 0x66, 0x30, 0x62, 0x32, 0x32, 0x64, 0x66, 0x38, 0x64, 0x61, 0x35, 0x63, 0x63, 0x30, 0x30, 0x37, 0x39, 0x35, 0x61, 0x34, 0x30, 0x61, 0x30, 0x31, 0x63, 0x66, 0x37, 0x32, 0x66, 0x37, 0x64, 0x31, 0x36, 0x33, 0x32, 0x62, 0x65, 0x31, 0x61, 0x35, 0x65, 0x65, 0x31, 0x30, 0x31, 0x62, 0x37, 0x65, 0x37, 0x65, 0x64, 0x37, 0x61, 0x62, 0x64, 0x32, 0x32, 0x36, 0x35, 0x35, 0x63, 0x38, 0x64, 0x30, 0x30, 0x62, 0x34, 0x39, 0x34, 0x35, 0x37, 0x63, 0x36, 0x65, 0x31, 0x38, 0x64, 0x33, 0x30, 0x66, 0x34, 0x34, 0x32, 0x35, 0x65, 0x66, 0x61, 0x37, 0x65, 0x39, 0x37, 0x32, 0x35, 0x61, 0x36, 0x62, 0x66, 0x34, 0x62, 0x65, 0x63, 0x66, 0x30, 0x65, 0x34, 0x66, 0x62, 0x34, 0x35, 0x38, 0x30, 0x66, 0x61, 0x37, 0x66, 0x33, 0x33, 0x62, 0x62, 0x36, 0x33, 0x64, 0x37, 0x35, 0x31, 0x33, 0x62, 0x61, 0x37, 0x63, 0x65, 0x30, 0x31, 0x33, 0x63, 0x36, 0x66, 0x38, 0x37, 0x37, 0x33, 0x34, 0x35, 0x39, 0x65, 0x31, 0x36, 0x34, 0x62, 0x39, 0x38, 0x64, 0x30, 0x34, 0x36, 0x33, 0x63, 0x65, 0x31, 0x38, 0x63, 0x31, 0x36, 0x38, 0x65, 0x31, 0x33, 0x38, 0x31, 0x64, 0x38, 0x61, 0x37, 0x35, 0x64, 0x64, 0x66, 0x34, 0x62, 0x37, 0x38, 0x64, 0x36, 0x63, 0x66, 0x33, 0x33, 0x34, 0x63, 0x36, 0x32, 0x30, 0x62, 0x36, 0x31, 0x62, 0x65, 0x33, 0x35, 0x33, 0x64, 0x63, 0x64, 0x32, 0x33, 0x33, 0x34, 0x33, 0x61, 0x30, 0x33, 0x63, 0x66, 0x35, 0x30, 0x37, 0x35, 0x30, 0x37, 0x32, 0x30, 0x62, 0x61, 0x37, 0x37, 0x63, 0x33, 0x38, 0x30, 0x65, 0x63, 0x34, 0x63, 0x39, 0x64, 0x31, 0x65, 0x39, 0x39, 0x66, 0x38, 0x30, 0x36, 0x34, 0x32, 0x63, 0x32, 0x34, 0x34, 0x66, 0x37, 0x35, 0x62, 0x62, 0x32, 0x38, 0x65, 0x39, 0x66, 0x31, 0x32, 0x65, 0x30, 0x62, 0x31, 0x35, 0x34, 0x61, 0x63, 0x61, 0x30, 0x63, 0x38, 0x30, 0x34, 0x31, 0x31, 0x39, 0x38, 0x64, 0x38, 0x37, 0x33, 0x62, 0x36, 0x62, 0x37, 0x35, 0x39, 0x63, 0x64, 0x33, 0x66, 0x30, 0x62, 0x30, 0x30, 0x64, 0x31, 0x34, 0x64, 0x65, 0x35, 0x36, 0x33, 0x33, 0x64, 0x65, 0x66, 0x31, 0x36, 0x64, 0x61, 0x32, 0x35, 0x64, 0x30, 0x39, 0x65, 0x62, 0x32, 0x35, 0x62, 0x64, 0x31, 0x61, 0x62, 0x37, 0x39, 0x66, 0x38, 0x61, 0x64, 0x61, 0x32, 0x62, 0x39, 0x62, 0x65, 0x34, 0x66, 0x33, 0x65, 0x30, 0x66, 0x62, 0x37, 0x32, 0x61, 0x31, 0x62, 0x37, 0x63, 0x32, 0x33, 0x62, 0x37, 0x38, 0x30, 0x30, 0x30, 0x66, 0x33, 0x33, 0x30, 0x31, 0x64, 0x39, 0x31, 0x62, 0x35, 0x64, 0x65, 0x66, 0x39, 0x36, 0x39, 0x65, 0x38, 0x34, 0x39, 0x39, 0x36, 0x33, 0x62, 0x66, 0x39, 0x38, 0x38, 0x38, 0x63, 0x35, 0x36, 0x61, 0x35, 0x30, 0x66, 0x35, 0x66, 0x34, 0x64, 0x66, 0x36, 0x32, 0x62, 0x63, 0x37, 0x33, 0x63, 0x63, 0x37, 0x32, 0x33, 0x65, 0x36, 0x32, 0x35, 0x34, 0x63, 0x39, 0x30, 0x33, 0x30, 0x32, 0x64, 0x31, 0x37, 0x66, 0x34, 0x65, 0x38, 0x62, 0x66, 0x38, 0x61, 0x66, 0x64, 0x65, 0x37, 0x30, 0x36, 0x39, 0x38, 0x65, 0x61, 0x37, 0x35, 0x34, 0x34, 0x39, 0x62, 0x62, 0x36, 0x65, 0x65, 0x36, 0x65, 0x33, 0x34, 0x38, 0x38, 0x39, 0x38, 0x32, 0x64, 0x32, 0x31, 0x39, 0x64, 0x36, 0x39, 0x37, 0x34, 0x61, 0x36, 0x36, 0x36, 0x63, 0x65, 0x37, 0x37, 0x64, 0x61, 0x66, 0x63, 0x62, 0x37, 0x61, 0x31, 0x61, 0x65, 0x30, 0x61, 0x35, 0x30, 0x62, 0x62, 0x61, 0x34, 0x36, 0x65, 0x30, 0x39, 0x64, 0x65, 0x33, 0x37, 0x63, 0x39, 0x66, 0x30, 0x30, 0x62, 0x63, 0x65, 0x32, 0x34, 0x38, 0x33, 0x35, 0x65, 0x39, 0x32, 0x61, 0x30, 0x32, 0x36, 0x61, 0x39, 0x61, 0x34, 0x36, 0x63, 0x64, 0x65, 0x65, 0x32, 0x63, 0x37, 0x32, 0x34, 0x65, 0x62, 0x61, 0x39, 0x37, 0x33, 0x63, 0x34, 0x30, 0x37, 0x61, 0x65, 0x39, 0x62, 0x34, 0x62, 0x39, 0x61, 0x61, 0x61, 0x30, 0x63, 0x39, 0x65, 0x63, 0x62, 0x37, 0x64, 0x39, 0x66, 0x65, 0x36, 0x39, 0x34, 0x62, 0x31, 0x33, 0x39, 0x39, 0x64, 0x34, 0x38, 0x65, 0x33, 0x39, 0x37, 0x37, 0x38, 0x31, 0x64, 0x63, 0x38, 0x62, 0x30, 0x36, 0x64, 0x36, 0x62, 0x37, 0x38, 0x31, 0x37, 0x32, 0x35, 0x32, 0x32, 0x66, 0x33, 0x64, 0x30, 0x30, 0x65, 0x34, 0x61, 0x33, 0x61, 0x33, 0x33, 0x62, 0x65, 0x31, 0x31, 0x63, 0x36, 0x37, 0x34, 0x36, 0x64, 0x65, 0x32, 0x33, 0x63, 0x37, 0x63, 0x66, 0x37, 0x65, 0x35, 0x63, 0x38, 0x62, 0x63, 0x66, 0x34, 0x33, 0x38, 0x31, 0x64, 0x35, 0x61, 0x63, 0x38, 0x66, 0x66, 0x32, 0x36, 0x34, 0x33, 0x65, 0x65, 0x63, 0x61, 0x36, 0x34, 0x38, 0x37, 0x32, 0x38, 0x31, 0x64, 0x38, 0x37, 0x36, 0x62, 0x36, 0x31, 0x63, 0x30, 0x31, 0x66, 0x33, 0x31, 0x34, 0x63, 0x33, 0x37, 0x35, 0x61, 0x66, 0x38, 0x37, 0x62, 0x38, 0x33, 0x65, 0x36, 0x64, 0x62, 0x35, 0x34, 0x61, 0x63, 0x36, 0x65, 0x37, 0x64, 0x37, 0x64, 0x65, 0x64, 0x35, 0x30, 0x34, 0x61, 0x66, 0x38, 0x64, 0x65, 0x62, 0x66, 0x36, 0x32, 0x62, 0x66, 0x35, 0x37, 0x35, 0x66, 0x37, 0x36, 0x35, 0x31, 0x31, 0x65, 0x31, 0x33, 0x33, 0x37, 0x37, 0x30, 0x30, 0x39, 0x61, 0x36, 0x63, 0x63, 0x61, 0x36, 0x61, 0x36, 0x34, 0x32, 0x62, 0x62, 0x64, 0x61, 0x30, 0x39, 0x36, 0x66, 0x31, 0x63, 0x65, 0x34, 0x63, 0x64, 0x61, 0x35, 0x31, 0x31, 0x37, 0x33, 0x36, 0x31, 0x34, 0x32, 0x36, 0x62, 0x31, 0x33, 0x61, 0x37, 0x37, 0x63, 0x37, 0x34, 0x35, 0x30, 0x32, 0x37, 0x61, 0x37, 0x38, 0x32, 0x30, 0x32, 0x61, 0x37, 0x37, 0x64, 0x61, 0x66, 0x36, 0x35, 0x63, 0x66, 0x38, 0x32, 0x63, 0x62, 0x62, 0x31, 0x39, 0x33, 0x38, 0x62, 0x30, 0x64, 0x32, 0x61, 0x62, 0x64, 0x64, 0x62, 0x64, 0x39, 0x64, 0x63, 0x32, 0x64, 0x62, 0x36, 0x64, 0x63, 0x31, 0x33, 0x33, 0x63, 0x34, 0x62, 0x39, 0x63, 0x39, 0x36, 0x36, 0x64, 0x61, 0x31, 0x65, 0x31, 0x30, 0x33, 0x63, 0x62, 0x31, 0x30, 0x31, 0x32, 0x33, 0x36, 0x63, 0x62, 0x30, 0x61, 0x30, 0x38, 0x36, 0x61, 0x64, 0x34, 0x39, 0x39, 0x66, 0x30, 0x65, 0x63, 0x61, 0x39, 0x61, 0x39, 0x34, 0x34, 0x61, 0x63, 0x65, 0x63, 0x64, 0x38, 0x64, 0x62, 0x62, 0x36, 0x32, 0x30, 0x65, 0x34, 0x63, 0x62, 0x35, 0x33, 0x37, 0x39, 0x62, 0x63, 0x32, 0x33, 0x37, 0x36, 0x31, 0x63, 0x36, 0x37, 0x32, 0x39, 0x33, 0x31, 0x39, 0x33, 0x65, 0x30, 0x32, 0x37, 0x32, 0x30, 0x37, 0x34, 0x34, 0x63, 0x62, 0x61, 0x62, 0x31, 0x62, 0x66, 0x65, 0x62, 0x39, 0x31, 0x64, 0x65, 0x30, 0x34, 0x34, 0x63, 0x38, 0x32, 0x39, 0x31, 0x32, 0x30, 0x34, 0x35, 0x65, 0x66, 0x65, 0x39, 0x32, 0x66, 0x33, 0x38, 0x35, 0x38, 0x35, 0x31, 0x35, 0x63, 0x37, 0x34, 0x64, 0x37, 0x63, 0x31, 0x64, 0x66, 0x30, 0x38, 0x66, 0x34, 0x35, 0x37, 0x65, 0x39, 0x64, 0x34, 0x63, 0x37, 0x32, 0x62, 0x34, 0x30, 0x39, 0x36, 0x39, 0x62, 0x32, 0x33, 0x31, 0x63, 0x36, 0x32, 0x64, 0x34, 0x66, 0x31, 0x61, 0x37, 0x62, 0x61, 0x39, 0x37, 0x61, 0x66, 0x31, 0x36, 0x30, 0x65, 0x33, 0x65, 0x39, 0x63, 0x61, 0x64, 0x37, 0x37, 0x32, 0x66, 0x39, 0x66, 0x31, 0x32, 0x39, 0x37, 0x61, 0x65, 0x31, 0x35, 0x65, 0x32, 0x33, 0x38, 0x38, 0x66, 0x35, 0x35, 0x39, 0x63, 0x64, 0x64, 0x39, 0x32, 0x36, 0x66, 0x62, 0x32, 0x36, 0x31, 0x34, 0x39, 0x61, 0x30, 0x35, 0x34, 0x36, 0x62, 0x33, 0x35, 0x35, 0x35, 0x66, 0x39, 0x65, 0x33, 0x31, 0x64, 0x31, 0x37, 0x34, 0x31, 0x38, 0x34, 0x66, 0x65, 0x34, 0x37, 0x65, 0x36, 0x30, 0x61, 0x35, 0x64, 0x31, 0x65, 0x39, 0x61, 0x64, 0x63, 0x39, 0x65, 0x38, 0x31, 0x61, 0x62, 0x33, 0x39, 0x31, 0x30, 0x63, 0x32, 0x63, 0x64, 0x37, 0x62, 0x38, 0x37, 0x32, 0x37, 0x33, 0x33, 0x30, 0x66, 0x39, 0x34, 0x61, 0x64, 0x39, 0x39, 0x35, 0x38, 0x33, 0x64, 0x30, 0x36, 0x65, 0x36, 0x33, 0x66, 0x30, 0x64, 0x37, 0x65, 0x39, 0x61, 0x32, 0x63, 0x62, 0x35, 0x62, 0x39, 0x62, 0x37, 0x64, 0x31, 0x34, 0x32, 0x30, 0x39, 0x35, 0x30, 0x62, 0x37, 0x38, 0x32, 0x31, 0x36, 0x32, 0x33, 0x30, 0x39, 0x39, 0x32, 0x65, 0x39, 0x64, 0x32, 0x36, 0x31, 0x34, 0x37, 0x32, 0x65, 0x66, 0x35, 0x63, 0x37, 0x33, 0x61, 0x38, 0x63, 0x36, 0x31, 0x38, 0x32, 0x32, 0x63, 0x38, 0x37, 0x61, 0x35, 0x39, 0x64, 0x37, 0x38, 0x62, 0x36, 0x66, 0x31, 0x64, 0x66, 0x36, 0x38, 0x39, 0x39, 0x66, 0x64, 0x63, 0x39, 0x35, 0x39, 0x33, 0x33, 0x61, 0x39, 0x34, 0x62, 0x35, 0x65, 0x64, 0x35, 0x66, 0x65, 0x64, 0x64, 0x33, 0x61, 0x34, 0x35, 0x61, 0x33, 0x33, 0x65, 0x33, 0x37, 0x32, 0x66, 0x37, 0x65, 0x65, 0x66, 0x66, 0x62, 0x31, 0x30, 0x61, 0x30, 0x37, 0x37, 0x66, 0x32, 0x34, 0x66, 0x32, 0x39, 0x66, 0x31, 0x36, 0x64, 0x36, 0x65, 0x32, 0x61, 0x37, 0x65, 0x61, 0x66, 0x64, 0x38, 0x36, 0x35, 0x36, 0x31, 0x38, 0x65, 0x31, 0x30, 0x34, 0x66, 0x33, 0x66, 0x61, 0x33, 0x31, 0x30, 0x63, 0x39, 0x38, 0x30, 0x39, 0x36, 0x39, 0x34, 0x36, 0x34, 0x66, 0x38, 0x61, 0x36, 0x36, 0x31, 0x30, 0x63, 0x37, 0x64, 0x65, 0x39, 0x66, 0x37, 0x63, 0x35, 0x34, 0x64, 0x61, 0x31, 0x30, 0x66, 0x39, 0x33, 0x39, 0x66, 0x64, 0x39, 0x65, 0x65, 0x62, 0x66, 0x62, 0x61, 0x36, 0x62, 0x36, 0x35, 0x37, 0x38, 0x35, 0x33, 0x31, 0x62, 0x33, 0x36, 0x35, 0x34, 0x66, 0x38, 0x36, 0x36, 0x39, 0x30, 0x30, 0x35, 0x35, 0x35, 0x34, 0x38, 0x62, 0x65, 0x65, 0x62, 0x66, 0x65, 0x37, 0x37, 0x32, 0x31, 0x66, 0x39, 0x35, 0x31, 0x63, 0x62, 0x33, 0x33, 0x35, 0x62, 0x66, 0x34, 0x39, 0x36, 0x62, 0x34, 0x33, 0x37, 0x64, 0x64, 0x66, 0x65, 0x33, 0x62, 0x61, 0x31, 0x66, 0x65, 0x64, 0x63, 0x39, 0x35, 0x64, 0x64, 0x61, 0x39, 0x30, 0x63, 0x39, 0x62, 0x32, 0x38, 0x38, 0x35, 0x62, 0x32, 0x32, 0x62, 0x66, 0x61, 0x65, 0x66, 0x36, 0x30, 0x65, 0x30, 0x38, 0x62, 0x31, 0x30, 0x63, 0x37, 0x32, 0x65, 0x65, 0x37, 0x65, 0x31, 0x37, 0x39, 0x64, 0x38, 0x62, 0x66, 0x31, 0x37, 0x37, 0x37, 0x36, 0x33, 0x37, 0x65, 0x61, 0x66, 0x30, 0x66, 0x62, 0x31, 0x62, 0x64, 0x62, 0x34, 0x36, 0x32, 0x39, 0x31, 0x39, 0x63, 0x63, 0x37, 0x32, 0x32, 0x31, 0x36, 0x35, 0x36, 0x64, 0x34, 0x34, 0x63, 0x38, 0x61, 0x65, 0x36, 0x39, 0x36, 0x33, 0x37, 0x38, 0x65, 0x66, 0x31, 0x35, 0x63, 0x66, 0x37, 0x32, 0x33, 0x37, 0x61, 0x30, 0x32, 0x30, 0x31, 0x62, 0x35, 0x38, 0x35, 0x62, 0x31, 0x39, 0x34, 0x33, 0x63, 0x63, 0x65, 0x31, 0x61, 0x64, 0x30, 0x34, 0x65, 0x34, 0x39, 0x39, 0x31, 0x66, 0x38, 0x33, 0x32, 0x66, 0x65, 0x37, 0x62, 0x63, 0x32, 0x63, 0x35, 0x63, 0x61, 0x36, 0x66, 0x30, 0x66, 0x65, 0x30, 0x61, 0x62, 0x35, 0x38, 0x31, 0x33, 0x65, 0x66, 0x39, 0x39, 0x62, 0x37, 0x66, 0x37, 0x32, 0x32, 0x37, 0x36, 0x31, 0x66, 0x34, 0x61, 0x34, 0x39, 0x37, 0x39, 0x64, 0x31, 0x64, 0x37, 0x37, 0x38, 0x64, 0x36, 0x36, 0x63, 0x31, 0x64, 0x65, 0x30, 0x37, 0x35, 0x61, 0x33, 0x66, 0x61, 0x36, 0x61, 0x33, 0x64, 0x65, 0x37, 0x37, 0x31, 0x62, 0x37, 0x31, 0x34, 0x65, 0x36, 0x66, 0x39, 0x66, 0x62, 0x38, 0x64, 0x64, 0x38, 0x36, 0x32, 0x65, 0x34, 0x65, 0x36, 0x38, 0x64, 0x36, 0x37, 0x32, 0x63, 0x64, 0x38, 0x64, 0x37, 0x35, 0x65, 0x37, 0x61, 0x33, 0x65, 0x34, 0x31, 0x39, 0x65, 0x37, 0x63, 0x64, 0x30, 0x63, 0x36, 0x62, 0x34, 0x38, 0x39, 0x33, 0x62, 0x39, 0x33, 0x39, 0x66, 0x65, 0x62, 0x35, 0x64, 0x34, 0x38, 0x66, 0x39, 0x35, 0x66, 0x38, 0x65, 0x36, 0x39, 0x65, 0x62, 0x30, 0x61, 0x35, 0x63, 0x62, 0x34, 0x62, 0x33, 0x38, 0x63, 0x65, 0x61, 0x64, 0x35, 0x62, 0x32, 0x61, 0x35, 0x39, 0x63, 0x63, 0x30, 0x62, 0x64, 0x39, 0x62, 0x62, 0x64, 0x39, 0x33, 0x65, 0x66, 0x31, 0x66, 0x36, 0x30, 0x62, 0x64, 0x65, 0x36, 0x31, 0x63, 0x33, 0x61, 0x37, 0x35, 0x36, 0x35, 0x64, 0x37, 0x32, 0x37, 0x66, 0x33, 0x34, 0x63, 0x30, 0x66, 0x62, 0x63, 0x62, 0x61, 0x63, 0x63, 0x61, 0x37, 0x32, 0x39, 0x38, 0x36, 0x38, 0x30, 0x39, 0x30, 0x30, 0x38, 0x62, 0x37, 0x39, 0x35, 0x31, 0x31, 0x36, 0x31, 0x37, 0x35, 0x63, 0x63, 0x39, 0x35, 0x66, 0x65, 0x34, 0x38, 0x33, 0x63, 0x38, 0x62, 0x33, 0x39, 0x64, 0x65, 0x37, 0x36, 0x33, 0x61, 0x36, 0x36, 0x65, 0x65, 0x35, 0x31, 0x37, 0x64, 0x31, 0x35, 0x35, 0x66, 0x61, 0x61, 0x64, 0x32, 0x61, 0x61, 0x36, 0x31, 0x32, 0x39, 0x62, 0x66, 0x39, 0x65, 0x32, 0x61, 0x61, 0x37, 0x61, 0x39, 0x34, 0x35, 0x36, 0x65, 0x32, 0x37, 0x32, 0x39, 0x39, 0x33, 0x36, 0x61, 0x30, 0x37, 0x65, 0x35, 0x32, 0x63, 0x35, 0x33, 0x61, 0x37, 0x61, 0x33, 0x36, 0x38, 0x38, 0x61, 0x61, 0x37, 0x62, 0x61, 0x64, 0x31, 0x39, 0x34, 0x34, 0x65, 0x34, 0x31, 0x62, 0x61, 0x32, 0x33, 0x64, 0x61, 0x33, 0x32, 0x65, 0x36, 0x64, 0x36, 0x38, 0x30, 0x33, 0x37, 0x64, 0x37, 0x35, 0x63, 0x66, 0x38, 0x30, 0x61, 0x34, 0x35, 0x31, 0x32, 0x34, 0x37, 0x32, 0x38, 0x63, 0x66, 0x65, 0x35, 0x65, 0x38, 0x37, 0x31, 0x36, 0x32, 0x30, 0x30, 0x63, 0x61, 0x62, 0x66, 0x62, 0x33, 0x63, 0x36, 0x37, 0x39, 0x34, 0x35, 0x62, 0x33, 0x32, 0x65, 0x36, 0x61, 0x62, 0x38, 0x30, 0x32, 0x65, 0x61, 0x35, 0x32, 0x31, 0x33, 0x65, 0x66, 0x38, 0x63, 0x38, 0x64, 0x32, 0x39, 0x37, 0x36, 0x33, 0x64, 0x65, 0x35, 0x39, 0x66, 0x32, 0x37, 0x63, 0x64, 0x65, 0x32, 0x35, 0x33, 0x33, 0x39, 0x36, 0x65, 0x62, 0x38, 0x35, 0x38, 0x33, 0x34, 0x63, 0x30, 0x61, 0x63, 0x36, 0x64, 0x37, 0x62, 0x37, 0x32, 0x39, 0x66, 0x35, 0x31, 0x65, 0x39, 0x66, 0x62, 0x35, 0x66, 0x61, 0x30, 0x37, 0x33, 0x31, 0x36, 0x37, 0x30, 0x66, 0x38, 0x33, 0x66, 0x37, 0x31, 0x64, 0x36, 0x39, 0x38, 0x38, 0x39, 0x33, 0x37, 0x66, 0x61, 0x31, 0x30, 0x39, 0x34, 0x30, 0x66, 0x32, 0x37, 0x32, 0x66, 0x32, 0x37, 0x62, 0x61, 0x33, 0x35, 0x34, 0x30, 0x36, 0x64, 0x34, 0x30, 0x31, 0x30, 0x33, 0x34, 0x37, 0x33, 0x39, 0x37, 0x37, 0x63, 0x34, 0x34, 0x64, 0x63, 0x61, 0x61, 0x63, 0x33, 0x32, 0x33, 0x61, 0x66, 0x37, 0x31, 0x32, 0x39, 0x66, 0x33, 0x64, 0x65, 0x63, 0x66, 0x33, 0x32, 0x63, 0x39, 0x65, 0x35, 0x36, 0x61, 0x32, 0x34, 0x37, 0x36, 0x36, 0x35, 0x38, 0x30, 0x63, 0x30, 0x38, 0x62, 0x36, 0x64, 0x65, 0x37, 0x39, 0x36, 0x37, 0x65, 0x62, 0x64, 0x65, 0x31, 0x62, 0x32, 0x64, 0x39, 0x61, 0x65, 0x63, 0x32, 0x64, 0x32, 0x66, 0x31, 0x63, 0x61, 0x32, 0x37, 0x39, 0x34, 0x39, 0x66, 0x38, 0x39, 0x64, 0x33, 0x39, 0x62, 0x31, 0x33, 0x64, 0x63, 0x64, 0x66, 0x30, 0x34, 0x33, 0x37, 0x64, 0x63, 0x64, 0x33, 0x31, 0x33, 0x66, 0x65, 0x37, 0x62, 0x64, 0x34, 0x36, 0x36, 0x33, 0x62, 0x34, 0x62, 0x38, 0x38, 0x61, 0x38, 0x32, 0x33, 0x33, 0x34, 0x65, 0x64, 0x32, 0x37, 0x39, 0x64, 0x37, 0x61, 0x64, 0x35, 0x65, 0x64, 0x38, 0x39, 0x61, 0x32, 0x62, 0x62, 0x39, 0x33, 0x35, 0x34, 0x63, 0x30, 0x32, 0x66, 0x33, 0x35, 0x32, 0x34, 0x66, 0x35, 0x66, 0x39, 0x30, 0x64, 0x37, 0x63, 0x66, 0x65, 0x37, 0x61, 0x61, 0x65, 0x35, 0x36, 0x39, 0x65, 0x31, 0x64, 0x36, 0x36, 0x31, 0x61, 0x63, 0x64, 0x63, 0x64, 0x37, 0x34, 0x66, 0x64, 0x63, 0x37, 0x34, 0x39, 0x38, 0x33, 0x31, 0x65, 0x36, 0x62, 0x30, 0x38, 0x39, 0x66, 0x31, 0x35, 0x30, 0x32, 0x34, 0x36, 0x35, 0x64, 0x39, 0x32, 0x32, 0x38, 0x62, 0x31, 0x39, 0x35, 0x61, 0x64, 0x30, 0x32, 0x38, 0x31, 0x36, 0x33, 0x31, 0x30, 0x64, 0x62, 0x34, 0x66, 0x61, 0x66, 0x65, 0x64, 0x34, 0x66, 0x32, 0x66, 0x33, 0x37, 0x32, 0x31, 0x37, 0x30, 0x36, 0x63, 0x65, 0x32, 0x31, 0x66, 0x36, 0x31, 0x34, 0x33, 0x37, 0x39, 0x61, 0x32, 0x33, 0x36, 0x32, 0x30, 0x32, 0x37, 0x64, 0x61, 0x32, 0x35, 0x32, 0x38, 0x66, 0x30, 0x63, 0x36, 0x32, 0x37, 0x34, 0x38, 0x33, 0x37, 0x31, 0x38, 0x39, 0x62, 0x63, 0x64, 0x32, 0x36, 0x31, 0x35, 0x38, 0x34, 0x64, 0x36, 0x63, 0x30, 0x33, 0x66, 0x63, 0x34, 0x39, 0x36, 0x63, 0x36, 0x61, 0x38, 0x65, 0x30, 0x64, 0x32, 0x64, 0x32, 0x37, 0x37, 0x37, 0x34, 0x38, 0x36, 0x35, 0x35, 0x30, 0x34, 0x39, 0x36, 0x61, 0x31, 0x64, 0x31, 0x35, 0x34, 0x37, 0x63, 0x63, 0x37, 0x62, 0x63, 0x36, 0x30, 0x30, 0x31, 0x65, 0x32, 0x34, 0x63, 0x33, 0x34, 0x36, 0x30, 0x34, 0x31, 0x33, 0x33, 0x31, 0x63, 0x38, 0x39, 0x39, 0x65, 0x32, 0x39, 0x32, 0x31, 0x34, 0x66, 0x38, 0x38, 0x38, 0x37, 0x32, 0x66, 0x33, 0x61, 0x34, 0x32, 0x30, 0x66, 0x34, 0x30, 0x64, 0x31, 0x33, 0x66, 0x32, 0x31, 0x64, 0x37, 0x31, 0x66, 0x61, 0x33, 0x39, 0x32, 0x36, 0x64, 0x31, 0x39, 0x62, 0x31, 0x34, 0x38, 0x37, 0x30, 0x35, 0x32, 0x34, 0x61, 0x66, 0x65, 0x64, 0x34, 0x33, 0x38, 0x31, 0x62, 0x63, 0x66, 0x36, 0x37, 0x61, 0x64, 0x30, 0x34, 0x38, 0x65, 0x34, 0x30, 0x32, 0x38, 0x61, 0x34, 0x62, 0x37, 0x32, 0x32, 0x36, 0x64, 0x30, 0x65, 0x38, 0x33, 0x33, 0x65, 0x62, 0x64, 0x38, 0x38, 0x34, 0x64, 0x34, 0x31, 0x30, 0x63, 0x31, 0x38, 0x61, 0x31, 0x31, 0x31, 0x31, 0x64, 0x37, 0x32, 0x39, 0x33, 0x33, 0x66, 0x65, 0x33, 0x33, 0x61, 0x36, 0x32, 0x38, 0x63, 0x31, 0x61, 0x65, 0x62, 0x66, 0x33, 0x64, 0x35, 0x39, 0x33, 0x63, 0x62, 0x62, 0x63, 0x61, 0x37, 0x31, 0x30, 0x38, 0x64, 0x33, 0x33, 0x64, 0x32, 0x61, 0x62, 0x35, 0x64, 0x31, 0x61, 0x64, 0x37, 0x31, 0x38, 0x64, 0x63, 0x63, 0x62, 0x39, 0x32, 0x35, 0x32, 0x38, 0x63, 0x61, 0x32, 0x34, 0x30, 0x62, 0x66, 0x38, 0x36, 0x62, 0x35, 0x62, 0x30, 0x66, 0x30, 0x39, 0x34, 0x66, 0x61, 0x35, 0x63, 0x39, 0x35, 0x36, 0x33, 0x35, 0x36, 0x62, 0x34, 0x64, 0x35, 0x36, 0x62, 0x36, 0x66, 0x38, 0x64, 0x64, 0x34, 0x65, 0x63, 0x37, 0x34, 0x37, 0x66, 0x66, 0x38, 0x35, 0x38, 0x34, 0x31, 0x63, 0x62, 0x62, 0x62, 0x30, 0x38, 0x30, 0x35, 0x34, 0x37, 0x64, 0x62, 0x39, 0x32, 0x66, 0x61, 0x66, 0x31, 0x61, 0x64, 0x62, 0x64, 0x62, 0x30, 0x39, 0x30, 0x37, 0x66, 0x61, 0x36, 0x35, 0x63, 0x32, 0x65, 0x37, 0x63, 0x36, 0x63, 0x33, 0x30, 0x62, 0x35, 0x37, 0x63, 0x39, 0x61, 0x62, 0x38, 0x66, 0x37, 0x62, 0x30, 0x39, 0x36, 0x37, 0x37, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x38, 0x37, 0x62, 0x31, 0x37, 0x63, 0x36, 0x63, 0x61, 0x65, 0x62, 0x66, 0x32, 0x35, 0x66, 0x32, 0x37, 0x62, 0x35, 0x38, 0x65, 0x64, 0x31, 0x39, 0x66, 0x38, 0x38, 0x31, 0x38, 0x65, 0x39, 0x39, 0x39, 0x36, 0x35, 0x61, 0x64, 0x66, 0x63, 0x39, 0x37, 0x35, 0x66, 0x62, 0x30, 0x66, 0x61, 0x31, 0x34, 0x63, 0x31, 0x35, 0x38, 0x33, 0x61, 0x36, 0x34, 0x33, 0x63, 0x35, 0x61, 0x64, 0x65, 0x61, 0x32, 0x30, 0x64, 0x66, 0x30, 0x33, 0x66, 0x30, 0x36, 0x66, 0x37, 0x34, 0x31, 0x65, 0x37, 0x66, 0x31, 0x39, 0x66, 0x30, 0x38, 0x64, 0x63, 0x66, 0x37, 0x38, 0x31, 0x31, 0x62, 0x31, 0x31, 0x66, 0x38, 0x62, 0x66, 0x61, 0x39, 0x34, 0x37, 0x63, 0x63, 0x63, 0x34, 0x66, 0x64, 0x30, 0x63, 0x33, 0x39, 0x38, 0x37, 0x63, 0x65, 0x34, 0x63, 0x65, 0x37, 0x32, 0x63, 0x35, 0x32, 0x36, 0x36, 0x30, 0x34, 0x61, 0x30, 0x64, 0x65, 0x66, 0x65, 0x34, 0x65, 0x30, 0x62, 0x61, 0x34, 0x65, 0x61, 0x61, 0x35, 0x37, 0x63, 0x35, 0x62, 0x36, 0x65, 0x65, 0x30, 0x62, 0x39, 0x61, 0x38, 0x38, 0x39, 0x62, 0x61, 0x36, 0x36, 0x32, 0x36, 0x35, 0x64, 0x32, 0x30, 0x63, 0x65, 0x34, 0x61, 0x62, 0x65, 0x39, 0x30, 0x36, 0x32, 0x64, 0x31, 0x61, 0x36, 0x35, 0x37, 0x32, 0x36, 0x62, 0x65, 0x34, 0x63, 0x37, 0x62, 0x36, 0x33, 0x31, 0x31, 0x39, 0x36, 0x61, 0x32, 0x64, 0x62, 0x33, 0x34, 0x33, 0x62, 0x63, 0x31, 0x34, 0x62, 0x38, 0x64, 0x33, 0x33, 0x36, 0x34, 0x30, 0x35, 0x34, 0x62, 0x39, 0x33, 0x32, 0x38, 0x31, 0x62, 0x63, 0x61, 0x38, 0x62, 0x64, 0x33, 0x63, 0x33, 0x64, 0x64, 0x32, 0x39, 0x62, 0x31, 0x61, 0x38, 0x64, 0x62, 0x39, 0x62, 0x31, 0x30, 0x36, 0x34, 0x62, 0x61, 0x35, 0x37, 0x61, 0x61, 0x63, 0x35, 0x36, 0x35, 0x35, 0x30, 0x62, 0x38, 0x31, 0x62, 0x30, 0x31, 0x35, 0x65, 0x32, 0x30, 0x63, 0x65, 0x66, 0x61, 0x63, 0x35, 0x34, 0x35, 0x62, 0x39, 0x32, 0x66, 0x33, 0x65, 0x34, 0x37, 0x33, 0x65, 0x37, 0x35, 0x37, 0x31, 0x61, 0x37, 0x33, 0x35, 0x36, 0x33, 0x30, 0x39, 0x62, 0x62, 0x37, 0x35, 0x66, 0x63, 0x32, 0x39, 0x37, 0x34, 0x66, 0x36, 0x32, 0x62, 0x66, 0x37, 0x39, 0x65, 0x35, 0x31, 0x36, 0x39, 0x66, 0x63, 0x64, 0x38, 0x32, 0x61, 0x65, 0x63, 0x32, 0x35, 0x66, 0x65, 0x38, 0x36, 0x32, 0x30, 0x33, 0x35, 0x65, 0x32, 0x34, 0x34, 0x64, 0x62, 0x63, 0x37, 0x34, 0x66, 0x33, 0x33, 0x30, 0x34, 0x30, 0x38, 0x64, 0x39, 0x34, 0x37, 0x31, 0x61, 0x34, 0x61, 0x65, 0x61, 0x38, 0x62, 0x36, 0x33, 0x33, 0x33, 0x39, 0x37, 0x32, 0x66, 0x34, 0x39, 0x64, 0x66, 0x35, 0x34, 0x63, 0x32, 0x31, 0x30, 0x38, 0x39, 0x35, 0x31, 0x62, 0x37, 0x36, 0x31, 0x66, 0x63, 0x38, 0x66, 0x38, 0x31, 0x62, 0x64, 0x36, 0x61, 0x31, 0x38, 0x63, 0x36, 0x65, 0x30, 0x37, 0x36, 0x65, 0x31, 0x61, 0x34, 0x35, 0x64, 0x39, 0x34, 0x34, 0x36, 0x63, 0x38, 0x65, 0x65, 0x39, 0x61, 0x33, 0x37, 0x33, 0x36, 0x37, 0x65, 0x34, 0x64, 0x65, 0x37, 0x32, 0x65, 0x66, 0x37, 0x30, 0x65, 0x31, 0x32, 0x61, 0x65, 0x39, 0x32, 0x32, 0x62, 0x65, 0x61, 0x34, 0x64, 0x33, 0x34, 0x36, 0x34, 0x65, 0x35, 0x62, 0x34, 0x36, 0x34, 0x62, 0x39, 0x33, 0x32, 0x36, 0x65, 0x66, 0x66, 0x35, 0x33, 0x30, 0x33, 0x31, 0x36, 0x66, 0x30, 0x64, 0x31, 0x32, 0x37, 0x33, 0x30, 0x33, 0x36, 0x31, 0x65, 0x32, 0x37, 0x35, 0x39, 0x38, 0x32, 0x39, 0x35, 0x34, 0x33, 0x39, 0x39, 0x65, 0x33, 0x61, 0x62, 0x32, 0x65, 0x31, 0x33, 0x66, 0x32, 0x31, 0x31, 0x61, 0x65, 0x65, 0x66, 0x64, 0x30, 0x34, 0x33, 0x37, 0x39, 0x62, 0x36, 0x38, 0x64, 0x33, 0x38, 0x30, 0x36, 0x66, 0x61, 0x64, 0x36, 0x32, 0x66, 0x63, 0x35, 0x32, 0x37, 0x65, 0x62, 0x61, 0x31, 0x66, 0x66, 0x36, 0x35, 0x32, 0x37, 0x63, 0x37, 0x34, 0x65, 0x34, 0x66, 0x64, 0x31, 0x38, 0x64, 0x62, 0x34, 0x65, 0x30, 0x30, 0x64, 0x62, 0x65, 0x63, 0x32, 0x35, 0x34, 0x38, 0x66, 0x37, 0x63, 0x62, 0x34, 0x64, 0x37, 0x33, 0x36, 0x65, 0x39, 0x38, 0x62, 0x37, 0x36, 0x64, 0x34, 0x38, 0x63, 0x32, 0x63, 0x39, 0x63, 0x63, 0x33, 0x32, 0x35, 0x64, 0x66, 0x35, 0x35, 0x62, 0x38, 0x64, 0x63, 0x39, 0x39, 0x36, 0x38, 0x65, 0x34, 0x37, 0x36, 0x66, 0x30, 0x38, 0x30, 0x66, 0x33, 0x36, 0x32, 0x65, 0x37, 0x32, 0x38, 0x38, 0x36, 0x65, 0x64, 0x61, 0x66, 0x36, 0x30, 0x36, 0x64, 0x32, 0x31, 0x63, 0x34, 0x35, 0x38, 0x37, 0x63, 0x36, 0x39, 0x62, 0x61, 0x31, 0x31, 0x64, 0x62, 0x37, 0x37, 0x30, 0x64, 0x39, 0x31, 0x32, 0x37, 0x61, 0x38, 0x66, 0x30, 0x33, 0x30, 0x32, 0x65, 0x36, 0x66, 0x39, 0x35, 0x63, 0x39, 0x64, 0x39, 0x37, 0x39, 0x32, 0x32, 0x64, 0x62, 0x64, 0x34, 0x33, 0x33, 0x37, 0x37, 0x32, 0x34, 0x39, 0x65, 0x64, 0x65, 0x36, 0x38, 0x32, 0x62, 0x66, 0x38, 0x66, 0x31, 0x65, 0x33, 0x38, 0x64, 0x64, 0x32, 0x66, 0x31, 0x65, 0x62, 0x33, 0x35, 0x64, 0x61, 0x61, 0x32, 0x39, 0x63, 0x65, 0x65, 0x64, 0x65, 0x63, 0x65, 0x63, 0x37, 0x32, 0x64, 0x33, 0x61, 0x33, 0x63, 0x62, 0x34, 0x65, 0x36, 0x35, 0x31, 0x63, 0x36, 0x39, 0x30, 0x39, 0x30, 0x34, 0x38, 0x32, 0x30, 0x38, 0x35, 0x32, 0x35, 0x32, 0x63, 0x32, 0x34, 0x30, 0x35, 0x30, 0x30, 0x64, 0x65, 0x63, 0x33, 0x31, 0x65, 0x62, 0x36, 0x32, 0x37, 0x65, 0x64, 0x61, 0x64, 0x65, 0x65, 0x30, 0x37, 0x36, 0x61, 0x65, 0x64, 0x33, 0x63, 0x62, 0x35, 0x30, 0x61, 0x31, 0x33, 0x35, 0x62, 0x37, 0x64, 0x32, 0x32, 0x61, 0x38, 0x62, 0x35, 0x38, 0x63, 0x64, 0x34, 0x33, 0x66, 0x31, 0x61, 0x63, 0x39, 0x39, 0x61, 0x36, 0x37, 0x32, 0x62, 0x39, 0x38, 0x62, 0x38, 0x33, 0x34, 0x63, 0x61, 0x64, 0x36, 0x30, 0x35, 0x31, 0x64, 0x61, 0x66, 0x64, 0x31, 0x63, 0x38, 0x66, 0x66, 0x62, 0x32, 0x30, 0x30, 0x33, 0x36, 0x33, 0x36, 0x64, 0x32, 0x31, 0x65, 0x38, 0x64, 0x63, 0x36, 0x34, 0x62, 0x35, 0x30, 0x63, 0x63, 0x32, 0x65, 0x61, 0x37, 0x61, 0x37, 0x36, 0x30, 0x34, 0x31, 0x63, 0x30, 0x66, 0x65, 0x62, 0x35, 0x35, 0x37, 0x32, 0x39, 0x34, 0x62, 0x66, 0x32, 0x30, 0x34, 0x32, 0x65, 0x39, 0x30, 0x39, 0x38, 0x35, 0x35, 0x62, 0x34, 0x66, 0x37, 0x34, 0x37, 0x35, 0x30, 0x62, 0x63, 0x63, 0x39, 0x38, 0x63, 0x33, 0x62, 0x63, 0x63, 0x63, 0x62, 0x32, 0x33, 0x32, 0x63, 0x64, 0x63, 0x31, 0x36, 0x64, 0x34, 0x38, 0x31, 0x36, 0x64, 0x38, 0x32, 0x32, 0x31, 0x37, 0x66, 0x35, 0x36, 0x31, 0x32, 0x33, 0x39, 0x64, 0x30, 0x65, 0x62, 0x65, 0x62, 0x65, 0x33, 0x65, 0x32, 0x37, 0x38, 0x66, 0x63, 0x39, 0x31, 0x38, 0x36, 0x36, 0x30, 0x64, 0x61, 0x31, 0x35, 0x37, 0x34, 0x35, 0x62, 0x63, 0x30, 0x34, 0x63, 0x35, 0x61, 0x63, 0x33, 0x35, 0x34, 0x36, 0x38, 0x38, 0x64, 0x33, 0x36, 0x33, 0x35, 0x63, 0x32, 0x64, 0x64, 0x37, 0x34, 0x33, 0x31, 0x31, 0x37, 0x38, 0x39, 0x63, 0x64, 0x62, 0x32, 0x35, 0x39, 0x38, 0x34, 0x62, 0x63, 0x39, 0x65, 0x39, 0x39, 0x61, 0x35, 0x37, 0x65, 0x35, 0x39, 0x30, 0x63, 0x35, 0x35, 0x35, 0x66, 0x62, 0x62, 0x63, 0x35, 0x36, 0x61, 0x63, 0x66, 0x35, 0x32, 0x30, 0x32, 0x64, 0x39, 0x61, 0x63, 0x63, 0x34, 0x32, 0x62, 0x34, 0x65, 0x63, 0x61, 0x39, 0x64, 0x65, 0x35, 0x33, 0x32, 0x38, 0x39, 0x61, 0x39, 0x35, 0x35, 0x39, 0x66, 0x38, 0x35, 0x35, 0x37, 0x31, 0x62, 0x35, 0x33, 0x64, 0x30, 0x62, 0x63, 0x65, 0x37, 0x66, 0x30, 0x64, 0x61, 0x36, 0x33, 0x32, 0x36, 0x39, 0x61, 0x35, 0x61, 0x64, 0x65, 0x39, 0x31, 0x66, 0x62, 0x63, 0x39, 0x36, 0x35, 0x66, 0x39, 0x37, 0x64, 0x35, 0x65, 0x64, 0x63, 0x65, 0x65, 0x30, 0x38, 0x35, 0x32, 0x35, 0x31, 0x62, 0x65, 0x61, 0x61, 0x33, 0x30, 0x31, 0x66, 0x33, 0x64, 0x61, 0x30, 0x37, 0x62, 0x32, 0x63, 0x63, 0x30, 0x37, 0x30, 0x65, 0x37, 0x61, 0x30, 0x33, 0x64, 0x36, 0x66, 0x62, 0x33, 0x39, 0x30, 0x33, 0x62, 0x33, 0x36, 0x64, 0x34, 0x64, 0x65, 0x37, 0x32, 0x30, 0x64, 0x66, 0x37, 0x65, 0x62, 0x35, 0x37, 0x30, 0x62, 0x36, 0x30, 0x33, 0x30, 0x30, 0x38, 0x32, 0x61, 0x64, 0x36, 0x38, 0x61, 0x34, 0x34, 0x37, 0x33, 0x61, 0x35, 0x66, 0x64, 0x33, 0x38, 0x62, 0x65, 0x39, 0x32, 0x31, 0x35, 0x35, 0x33, 0x33, 0x37, 0x32, 0x37, 0x30, 0x34, 0x30, 0x62, 0x32, 0x63, 0x30, 0x62, 0x36, 0x34, 0x34, 0x61, 0x61, 0x30, 0x39, 0x63, 0x62, 0x64, 0x35, 0x66, 0x31, 0x66, 0x65, 0x37, 0x35, 0x31, 0x63, 0x63, 0x39, 0x38, 0x35, 0x32, 0x61, 0x64, 0x34, 0x63, 0x36, 0x36, 0x37, 0x64, 0x32, 0x36, 0x34, 0x34, 0x65, 0x35, 0x33, 0x61, 0x37, 0x39, 0x35, 0x33, 0x66, 0x34, 0x30, 0x35, 0x32, 0x62, 0x37, 0x66, 0x65, 0x37, 0x32, 0x35, 0x38, 0x35, 0x65, 0x31, 0x62, 0x62, 0x30, 0x31, 0x63, 0x66, 0x34, 0x31, 0x32, 0x32, 0x31, 0x64, 0x39, 0x36, 0x34, 0x38, 0x64, 0x62, 0x35, 0x65, 0x38, 0x31, 0x66, 0x65, 0x65, 0x38, 0x38, 0x36, 0x64, 0x38, 0x38, 0x30, 0x65, 0x32, 0x36, 0x37, 0x62, 0x35, 0x35, 0x64, 0x36, 0x36, 0x30, 0x65, 0x66, 0x65, 0x36, 0x35, 0x63, 0x36, 0x66, 0x66, 0x30, 0x62, 0x62, 0x32, 0x31, 0x30, 0x64, 0x32, 0x61, 0x66, 0x38, 0x32, 0x37, 0x38, 0x64, 0x34, 0x33, 0x63, 0x65, 0x36, 0x33, 0x65, 0x63, 0x34, 0x66, 0x65, 0x38, 0x32, 0x38, 0x64, 0x30, 0x65, 0x63, 0x62, 0x65, 0x64, 0x61, 0x34, 0x38, 0x63, 0x32, 0x35, 0x32, 0x33, 0x33, 0x35, 0x36, 0x34, 0x39, 0x61, 0x32, 0x61, 0x33, 0x34, 0x39, 0x35, 0x65, 0x38, 0x39, 0x63, 0x39, 0x66, 0x61, 0x30, 0x31, 0x37, 0x63, 0x66, 0x31, 0x37, 0x32, 0x33, 0x31, 0x66, 0x38, 0x38, 0x34, 0x35, 0x62, 0x32, 0x65, 0x30, 0x62, 0x34, 0x35, 0x31, 0x30, 0x66, 0x37, 0x63, 0x36, 0x30, 0x38, 0x64, 0x61, 0x32, 0x65, 0x34, 0x38, 0x33, 0x31, 0x38, 0x36, 0x62, 0x32, 0x34, 0x33, 0x37, 0x34, 0x62, 0x38, 0x65, 0x64, 0x35, 0x31, 0x64, 0x33, 0x31, 0x63, 0x35, 0x39, 0x65, 0x39, 0x39, 0x33, 0x62, 0x31, 0x62, 0x61, 0x36, 0x61, 0x37, 0x31, 0x37, 0x32, 0x65, 0x39, 0x34, 0x34, 0x36, 0x30, 0x38, 0x30, 0x62, 0x36, 0x39, 0x39, 0x63, 0x38, 0x66, 0x64, 0x61, 0x61, 0x35, 0x62, 0x35, 0x37, 0x32, 0x32, 0x33, 0x64, 0x64, 0x65, 0x62, 0x65, 0x63, 0x37, 0x63, 0x38, 0x30, 0x36, 0x64, 0x66, 0x66, 0x61, 0x39, 0x62, 0x30, 0x30, 0x37, 0x34, 0x63, 0x62, 0x65, 0x37, 0x65, 0x66, 0x64, 0x38, 0x33, 0x31, 0x62, 0x64, 0x31, 0x64, 0x64, 0x62, 0x30, 0x66, 0x66, 0x30, 0x61, 0x63, 0x66, 0x31, 0x61, 0x37, 0x63, 0x61, 0x65, 0x64, 0x64, 0x39, 0x65, 0x63, 0x36, 0x38, 0x63, 0x65, 0x66, 0x30, 0x38, 0x39, 0x35, 0x39, 0x33, 0x39, 0x65, 0x63, 0x34, 0x30, 0x39, 0x33, 0x63, 0x35, 0x33, 0x37, 0x35, 0x32, 0x62, 0x32, 0x33, 0x64, 0x65, 0x62, 0x64, 0x31, 0x63, 0x32, 0x37, 0x61, 0x34, 0x38, 0x36, 0x31, 0x34, 0x30, 0x66, 0x34, 0x35, 0x63, 0x37, 0x32, 0x30, 0x37, 0x38, 0x64, 0x35, 0x61, 0x31, 0x61, 0x63, 0x30, 0x30, 0x39, 0x36, 0x63, 0x66, 0x38, 0x30, 0x65, 0x33, 0x33, 0x38, 0x39, 0x33, 0x64, 0x39, 0x33, 0x31, 0x37, 0x33, 0x61, 0x33, 0x31, 0x34, 0x31, 0x30, 0x64, 0x61, 0x65, 0x33, 0x30, 0x39, 0x62, 0x61, 0x62, 0x38, 0x64, 0x38, 0x39, 0x65, 0x65, 0x62, 0x32, 0x36, 0x39, 0x64, 0x33, 0x31, 0x36, 0x64, 0x33, 0x30, 0x64, 0x37, 0x30, 0x64, 0x35, 0x37, 0x37, 0x61, 0x31, 0x36, 0x63, 0x31, 0x66, 0x33, 0x34, 0x61, 0x35, 0x65, 0x36, 0x65, 0x32, 0x34, 0x37, 0x64, 0x39, 0x37, 0x33, 0x36, 0x61, 0x30, 0x36, 0x62, 0x34, 0x36, 0x65, 0x61, 0x37, 0x66, 0x38, 0x39, 0x66, 0x36, 0x39, 0x32, 0x61, 0x62, 0x33, 0x65, 0x38, 0x64, 0x35, 0x38, 0x31, 0x65, 0x37, 0x62, 0x31, 0x61, 0x30, 0x30, 0x31, 0x37, 0x64, 0x64, 0x34, 0x36, 0x35, 0x32, 0x38, 0x39, 0x66, 0x36, 0x35, 0x33, 0x65, 0x61, 0x39, 0x33, 0x30, 0x36, 0x36, 0x36, 0x61, 0x34, 0x39, 0x30, 0x38, 0x33, 0x38, 0x30, 0x62, 0x39, 0x37, 0x62, 0x31, 0x64, 0x38, 0x39, 0x30, 0x37, 0x62, 0x64, 0x39, 0x36, 0x31, 0x30, 0x35, 0x30, 0x65, 0x39, 0x63, 0x31, 0x32, 0x64, 0x62, 0x37, 0x62, 0x64, 0x38, 0x39, 0x64, 0x63, 0x66, 0x65, 0x38, 0x32, 0x35, 0x33, 0x34, 0x33, 0x30, 0x38, 0x32, 0x66, 0x38, 0x38, 0x38, 0x37, 0x31, 0x31, 0x64, 0x36, 0x63, 0x65, 0x38, 0x32, 0x62, 0x33, 0x38, 0x64, 0x62, 0x36, 0x36, 0x64, 0x39, 0x63, 0x31, 0x64, 0x37, 0x62, 0x35, 0x32, 0x63, 0x39, 0x66, 0x66, 0x61, 0x35, 0x35, 0x63, 0x64, 0x31, 0x65, 0x35, 0x63, 0x32, 0x33, 0x61, 0x38, 0x66, 0x61, 0x39, 0x32, 0x63, 0x61, 0x61, 0x32, 0x66, 0x63, 0x33, 0x33, 0x31, 0x39, 0x31, 0x34, 0x36, 0x38, 0x66, 0x66, 0x33, 0x37, 0x37, 0x33, 0x66, 0x35, 0x65, 0x35, 0x36, 0x33, 0x38, 0x33, 0x62, 0x39, 0x36, 0x66, 0x65, 0x61, 0x35, 0x39, 0x33, 0x66, 0x35, 0x63, 0x35, 0x37, 0x31, 0x62, 0x65, 0x32, 0x66, 0x65, 0x63, 0x34, 0x33, 0x39, 0x31, 0x62, 0x36, 0x34, 0x34, 0x66, 0x33, 0x33, 0x34, 0x37, 0x36, 0x38, 0x37, 0x66, 0x62, 0x63, 0x37, 0x63, 0x31, 0x33, 0x37, 0x36, 0x30, 0x32, 0x36, 0x38, 0x65, 0x66, 0x63, 0x63, 0x61, 0x39, 0x62, 0x35, 0x33, 0x64, 0x65, 0x38, 0x61, 0x34, 0x66, 0x65, 0x63, 0x37, 0x63, 0x37, 0x31, 0x38, 0x61, 0x66, 0x38, 0x37, 0x38, 0x37, 0x39, 0x38, 0x32, 0x32, 0x38, 0x36, 0x36, 0x63, 0x65, 0x30, 0x63, 0x32, 0x35, 0x39, 0x36, 0x36, 0x65, 0x35, 0x33, 0x35, 0x63, 0x63, 0x61, 0x36, 0x65, 0x63, 0x35, 0x37, 0x32, 0x34, 0x30, 0x30, 0x36, 0x31, 0x35, 0x35, 0x34, 0x62, 0x35, 0x63, 0x64, 0x62, 0x30, 0x34, 0x61, 0x64, 0x37, 0x36, 0x37, 0x33, 0x32, 0x36, 0x39, 0x61, 0x63, 0x64, 0x30, 0x38, 0x32, 0x65, 0x33, 0x63, 0x62, 0x34, 0x32, 0x66, 0x35, 0x65, 0x62, 0x34, 0x32, 0x33, 0x61, 0x66, 0x32, 0x32, 0x39, 0x32, 0x38, 0x38, 0x39, 0x64, 0x65, 0x66, 0x38, 0x63, 0x61, 0x39, 0x30, 0x65, 0x65, 0x35, 0x31, 0x65, 0x65, 0x62, 0x37, 0x32, 0x34, 0x37, 0x61, 0x32, 0x35, 0x33, 0x63, 0x62, 0x65, 0x64, 0x38, 0x31, 0x61, 0x32, 0x30, 0x61, 0x31, 0x32, 0x38, 0x38, 0x32, 0x66, 0x33, 0x31, 0x61, 0x30, 0x31, 0x62, 0x31, 0x61, 0x38, 0x31, 0x34, 0x65, 0x32, 0x35, 0x62, 0x63, 0x64, 0x65, 0x31, 0x66, 0x35, 0x30, 0x39, 0x64, 0x65, 0x38, 0x38, 0x37, 0x66, 0x35, 0x35, 0x37, 0x37, 0x36, 0x32, 0x31, 0x63, 0x63, 0x61, 0x35, 0x37, 0x32, 0x38, 0x62, 0x66, 0x34, 0x32, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x32, 0x38, 0x61, 0x61, 0x33, 0x32, 0x65, 0x34, 0x37, 0x31, 0x37, 0x31, 0x66, 0x38, 0x34, 0x64, 0x37, 0x37, 0x34, 0x64, 0x66, 0x32, 0x61, 0x65, 0x31, 0x61, 0x39, 0x38, 0x31, 0x66, 0x32, 0x31, 0x35, 0x35, 0x63, 0x61, 0x36, 0x32, 0x34, 0x61, 0x33, 0x63, 0x66, 0x30, 0x61, 0x35, 0x30, 0x39, 0x31, 0x33, 0x66, 0x30, 0x35, 0x36, 0x62, 0x37, 0x63, 0x62, 0x32, 0x66, 0x32, 0x61, 0x33, 0x38, 0x32, 0x65, 0x32, 0x34, 0x31, 0x33, 0x39, 0x38, 0x35, 0x37, 0x34, 0x64, 0x65, 0x62, 0x35, 0x64, 0x61, 0x30, 0x38, 0x33, 0x39, 0x39, 0x35, 0x61, 0x30, 0x63, 0x30, 0x61, 0x34, 0x34, 0x66, 0x39, 0x30, 0x62, 0x32, 0x65, 0x65, 0x34, 0x65, 0x61, 0x32, 0x35, 0x65, 0x31, 0x37, 0x65, 0x35, 0x30, 0x30, 0x66, 0x38, 0x33, 0x64, 0x33, 0x37, 0x34, 0x33, 0x61, 0x61, 0x30, 0x37, 0x38, 0x31, 0x36, 0x34, 0x63, 0x38, 0x65, 0x37, 0x66, 0x64, 0x66, 0x37, 0x39, 0x34, 0x37, 0x34, 0x35, 0x31, 0x37, 0x39, 0x38, 0x31, 0x39, 0x31, 0x32, 0x39, 0x33, 0x37, 0x39, 0x36, 0x66, 0x37, 0x37, 0x61, 0x66, 0x65, 0x61, 0x65, 0x62, 0x66, 0x66, 0x62, 0x65, 0x65, 0x61, 0x65, 0x61, 0x64, 0x39, 0x63, 0x38, 0x31, 0x64, 0x30, 0x33, 0x64, 0x33, 0x37, 0x65, 0x39, 0x31, 0x65, 0x37, 0x32, 0x35, 0x33, 0x34, 0x37, 0x34, 0x31, 0x31, 0x34, 0x36, 0x64, 0x34, 0x62, 0x66, 0x38, 0x62, 0x65, 0x37, 0x36, 0x39, 0x64, 0x66, 0x32, 0x31, 0x34, 0x32, 0x61, 0x61, 0x37, 0x39, 0x39, 0x37, 0x35, 0x37, 0x33, 0x61, 0x62, 0x64, 0x36, 0x37, 0x64, 0x33, 0x37, 0x66, 0x37, 0x37, 0x63, 0x62, 0x33, 0x61, 0x39, 0x33, 0x35, 0x33, 0x30, 0x32, 0x31, 0x35, 0x34, 0x61, 0x39, 0x31, 0x39, 0x38, 0x62, 0x63, 0x32, 0x65, 0x66, 0x64, 0x39, 0x32, 0x33, 0x35, 0x38, 0x32, 0x66, 0x30, 0x37, 0x65, 0x31, 0x63, 0x39, 0x63, 0x36, 0x33, 0x34, 0x63, 0x31, 0x31, 0x62, 0x36, 0x61, 0x36, 0x30, 0x31, 0x66, 0x37, 0x35, 0x66, 0x34, 0x63, 0x62, 0x39, 0x61, 0x35, 0x30, 0x64, 0x35, 0x64, 0x66, 0x37, 0x36, 0x37, 0x61, 0x38, 0x34, 0x66, 0x39, 0x34, 0x34, 0x65, 0x33, 0x63, 0x32, 0x31, 0x66, 0x32, 0x31, 0x66, 0x35, 0x32, 0x33, 0x34, 0x61, 0x63, 0x35, 0x33, 0x63, 0x66, 0x36, 0x61, 0x31, 0x34, 0x63, 0x66, 0x65, 0x61, 0x63, 0x37, 0x65, 0x34, 0x36, 0x62, 0x31, 0x64, 0x61, 0x64, 0x63, 0x65, 0x30, 0x33, 0x34, 0x65, 0x62, 0x65, 0x63, 0x36, 0x36, 0x37, 0x39, 0x65, 0x30, 0x36, 0x33, 0x34, 0x66, 0x35, 0x32, 0x61, 0x33, 0x66, 0x35, 0x35, 0x63, 0x32, 0x64, 0x35, 0x37, 0x37, 0x65, 0x30, 0x35, 0x30, 0x61, 0x38, 0x37, 0x33, 0x35, 0x64, 0x31, 0x36, 0x39, 0x32, 0x31, 0x33, 0x65, 0x33, 0x34, 0x36, 0x38, 0x63, 0x62, 0x65, 0x63, 0x37, 0x36, 0x65, 0x65, 0x32, 0x61, 0x34, 0x33, 0x35, 0x39, 0x30, 0x30, 0x63, 0x36, 0x32, 0x33, 0x32, 0x36, 0x33, 0x31, 0x35, 0x39, 0x38, 0x64, 0x38, 0x64, 0x39, 0x61, 0x34, 0x34, 0x31, 0x64, 0x33, 0x62, 0x32, 0x35, 0x34, 0x32, 0x66, 0x61, 0x65, 0x63, 0x65, 0x39, 0x36, 0x64, 0x63, 0x63, 0x65, 0x35, 0x64, 0x30, 0x61, 0x32, 0x63, 0x63, 0x62, 0x30, 0x33, 0x34, 0x32, 0x32, 0x66, 0x61, 0x32, 0x63, 0x35, 0x61, 0x66, 0x34, 0x61, 0x37, 0x66, 0x36, 0x37, 0x61, 0x30, 0x35, 0x30, 0x66, 0x33, 0x66, 0x63, 0x62, 0x39, 0x61, 0x31, 0x64, 0x37, 0x34, 0x38, 0x38, 0x64, 0x38, 0x65, 0x32, 0x36, 0x31, 0x32, 0x64, 0x33, 0x34, 0x38, 0x38, 0x35, 0x36, 0x61, 0x61, 0x30, 0x65, 0x33, 0x63, 0x65, 0x62, 0x30, 0x36, 0x62, 0x64, 0x34, 0x64, 0x33, 0x35, 0x61, 0x66, 0x37, 0x39, 0x38, 0x65, 0x62, 0x36, 0x39, 0x31, 0x31, 0x36, 0x33, 0x37, 0x66, 0x32, 0x37, 0x39, 0x66, 0x66, 0x30, 0x65, 0x32, 0x30, 0x37, 0x35, 0x38, 0x62, 0x62, 0x65, 0x34, 0x63, 0x63, 0x65, 0x33, 0x66, 0x34, 0x66, 0x37, 0x32, 0x34, 0x64, 0x62, 0x35, 0x39, 0x63, 0x39, 0x33, 0x37, 0x66, 0x64, 0x65, 0x62, 0x30, 0x37, 0x31, 0x39, 0x34, 0x38, 0x36, 0x63, 0x39, 0x33, 0x38, 0x65, 0x64, 0x36, 0x35, 0x31, 0x31, 0x63, 0x34, 0x37, 0x32, 0x64, 0x32, 0x37, 0x64, 0x35, 0x33, 0x62, 0x32, 0x37, 0x66, 0x36, 0x63, 0x64, 0x33, 0x30, 0x63, 0x36, 0x36, 0x66, 0x35, 0x66, 0x33, 0x38, 0x36, 0x66, 0x61, 0x34, 0x66, 0x37, 0x32, 0x35, 0x35, 0x39, 0x39, 0x30, 0x61, 0x65, 0x63, 0x61, 0x34, 0x39, 0x38, 0x65, 0x64, 0x33, 0x31, 0x66, 0x32, 0x31, 0x66, 0x38, 0x33, 0x34, 0x34, 0x32, 0x66, 0x30, 0x37, 0x36, 0x31, 0x37, 0x61, 0x36, 0x37, 0x61, 0x61, 0x34, 0x64, 0x38, 0x32, 0x32, 0x30, 0x65, 0x35, 0x34, 0x64, 0x35, 0x30, 0x35, 0x63, 0x35, 0x38, 0x64, 0x39, 0x66, 0x61, 0x30, 0x30, 0x30, 0x36, 0x64, 0x31, 0x37, 0x32, 0x65, 0x36, 0x36, 0x61, 0x30, 0x30, 0x37, 0x33, 0x33, 0x38, 0x62, 0x37, 0x65, 0x36, 0x36, 0x38, 0x63, 0x39, 0x62, 0x37, 0x38, 0x61, 0x34, 0x30, 0x64, 0x34, 0x61, 0x63, 0x38, 0x63, 0x31, 0x38, 0x35, 0x64, 0x34, 0x62, 0x63, 0x61, 0x62, 0x31, 0x39, 0x33, 0x33, 0x63, 0x39, 0x61, 0x66, 0x34, 0x31, 0x65, 0x34, 0x31, 0x35, 0x62, 0x34, 0x37, 0x32, 0x34, 0x33, 0x63, 0x61, 0x62, 0x37, 0x32, 0x34, 0x31, 0x34, 0x63, 0x66, 0x30, 0x30, 0x31, 0x62, 0x62, 0x65, 0x33, 0x64, 0x36, 0x33, 0x37, 0x36, 0x31, 0x62, 0x37, 0x65, 0x37, 0x36, 0x32, 0x36, 0x64, 0x37, 0x35, 0x38, 0x66, 0x32, 0x37, 0x64, 0x64, 0x65, 0x32, 0x61, 0x63, 0x61, 0x66, 0x63, 0x31, 0x36, 0x66, 0x64, 0x35, 0x30, 0x36, 0x36, 0x38, 0x39, 0x66, 0x64, 0x34, 0x64, 0x36, 0x66, 0x63, 0x34, 0x34, 0x31, 0x34, 0x37, 0x32, 0x37, 0x32, 0x65, 0x62, 0x30, 0x30, 0x65, 0x39, 0x31, 0x65, 0x32, 0x37, 0x31, 0x66, 0x63, 0x38, 0x34, 0x62, 0x37, 0x39, 0x36, 0x37, 0x32, 0x36, 0x66, 0x65, 0x37, 0x62, 0x62, 0x38, 0x63, 0x63, 0x39, 0x35, 0x34, 0x63, 0x32, 0x34, 0x64, 0x61, 0x35, 0x36, 0x62, 0x65, 0x32, 0x32, 0x64, 0x65, 0x38, 0x32, 0x66, 0x61, 0x33, 0x61, 0x30, 0x65, 0x38, 0x36, 0x33, 0x32, 0x64, 0x35, 0x37, 0x32, 0x34, 0x65, 0x61, 0x33, 0x64, 0x30, 0x30, 0x64, 0x33, 0x38, 0x61, 0x37, 0x62, 0x61, 0x34, 0x39, 0x34, 0x37, 0x30, 0x66, 0x37, 0x38, 0x38, 0x63, 0x39, 0x62, 0x39, 0x63, 0x34, 0x61, 0x36, 0x34, 0x64, 0x65, 0x33, 0x33, 0x31, 0x36, 0x34, 0x39, 0x34, 0x38, 0x64, 0x36, 0x33, 0x37, 0x36, 0x65, 0x66, 0x31, 0x39, 0x65, 0x36, 0x66, 0x64, 0x61, 0x65, 0x63, 0x62, 0x65, 0x34, 0x62, 0x36, 0x39, 0x38, 0x64, 0x36, 0x36, 0x61, 0x30, 0x30, 0x35, 0x65, 0x31, 0x31, 0x61, 0x61, 0x34, 0x31, 0x64, 0x39, 0x63, 0x33, 0x33, 0x63, 0x62, 0x39, 0x34, 0x35, 0x62, 0x39, 0x65, 0x34, 0x35, 0x61, 0x38, 0x34, 0x62, 0x66, 0x36, 0x65, 0x30, 0x33, 0x64, 0x62, 0x35, 0x62, 0x66, 0x61, 0x61, 0x37, 0x61, 0x31, 0x33, 0x66, 0x61, 0x62, 0x34, 0x36, 0x66, 0x61, 0x63, 0x35, 0x32, 0x62, 0x33, 0x30, 0x32, 0x35, 0x35, 0x32, 0x38, 0x36, 0x36, 0x62, 0x36, 0x66, 0x63, 0x64, 0x38, 0x39, 0x31, 0x32, 0x32, 0x38, 0x35, 0x38, 0x35, 0x30, 0x30, 0x62, 0x30, 0x34, 0x66, 0x33, 0x35, 0x34, 0x64, 0x35, 0x63, 0x65, 0x35, 0x32, 0x32, 0x35, 0x35, 0x37, 0x35, 0x62, 0x30, 0x32, 0x35, 0x33, 0x33, 0x39, 0x34, 0x32, 0x39, 0x38, 0x64, 0x35, 0x31, 0x36, 0x32, 0x31, 0x64, 0x63, 0x66, 0x63, 0x37, 0x37, 0x32, 0x66, 0x64, 0x30, 0x34, 0x66, 0x30, 0x37, 0x38, 0x39, 0x37, 0x35, 0x33, 0x35, 0x64, 0x39, 0x38, 0x62, 0x61, 0x35, 0x65, 0x32, 0x62, 0x63, 0x34, 0x64, 0x64, 0x61, 0x35, 0x66, 0x35, 0x30, 0x32, 0x34, 0x34, 0x33, 0x35, 0x35, 0x66, 0x61, 0x32, 0x39, 0x36, 0x30, 0x64, 0x33, 0x63, 0x30, 0x66, 0x30, 0x64, 0x62, 0x36, 0x63, 0x33, 0x35, 0x33, 0x33, 0x66, 0x30, 0x66, 0x62, 0x63, 0x37, 0x32, 0x38, 0x66, 0x35, 0x66, 0x37, 0x31, 0x38, 0x65, 0x63, 0x38, 0x39, 0x35, 0x33, 0x39, 0x64, 0x64, 0x31, 0x36, 0x64, 0x39, 0x32, 0x31, 0x38, 0x37, 0x35, 0x31, 0x64, 0x35, 0x38, 0x32, 0x36, 0x65, 0x38, 0x36, 0x38, 0x38, 0x30, 0x64, 0x61, 0x66, 0x34, 0x34, 0x62, 0x30, 0x31, 0x36, 0x62, 0x33, 0x31, 0x64, 0x37, 0x63, 0x36, 0x31, 0x37, 0x33, 0x34, 0x37, 0x39, 0x62, 0x37, 0x36, 0x37, 0x32, 0x31, 0x35, 0x61, 0x39, 0x33, 0x36, 0x33, 0x30, 0x31, 0x62, 0x65, 0x65, 0x32, 0x34, 0x64, 0x62, 0x39, 0x30, 0x61, 0x65, 0x61, 0x61, 0x32, 0x63, 0x37, 0x63, 0x38, 0x34, 0x34, 0x30, 0x64, 0x38, 0x61, 0x65, 0x33, 0x39, 0x34, 0x65, 0x32, 0x66, 0x39, 0x66, 0x63, 0x30, 0x64, 0x33, 0x30, 0x65, 0x38, 0x39, 0x62, 0x31, 0x32, 0x66, 0x36, 0x63, 0x64, 0x34, 0x38, 0x32, 0x65, 0x32, 0x37, 0x32, 0x34, 0x39, 0x36, 0x63, 0x61, 0x34, 0x38, 0x64, 0x62, 0x62, 0x61, 0x39, 0x34, 0x65, 0x30, 0x31, 0x30, 0x64, 0x35, 0x35, 0x30, 0x39, 0x63, 0x66, 0x30, 0x38, 0x66, 0x62, 0x34, 0x36, 0x31, 0x64, 0x38, 0x33, 0x33, 0x34, 0x62, 0x65, 0x32, 0x34, 0x36, 0x35, 0x39, 0x39, 0x62, 0x62, 0x66, 0x33, 0x39, 0x34, 0x35, 0x66, 0x33, 0x62, 0x38, 0x65, 0x37, 0x36, 0x63, 0x63, 0x66, 0x64, 0x36, 0x38, 0x39, 0x36, 0x63, 0x61, 0x39, 0x32, 0x37, 0x31, 0x31, 0x64, 0x61, 0x31, 0x34, 0x35, 0x64, 0x31, 0x62, 0x63, 0x37, 0x66, 0x61, 0x62, 0x38, 0x63, 0x62, 0x62, 0x34, 0x33, 0x66, 0x36, 0x38, 0x39, 0x34, 0x63, 0x34, 0x34, 0x62, 0x31, 0x37, 0x64, 0x31, 0x39, 0x30, 0x39, 0x38, 0x39, 0x33, 0x34, 0x31, 0x36, 0x36, 0x65, 0x35, 0x30, 0x64, 0x65, 0x61, 0x62, 0x66, 0x65, 0x62, 0x66, 0x37, 0x32, 0x32, 0x61, 0x64, 0x64, 0x37, 0x38, 0x34, 0x32, 0x32, 0x32, 0x32, 0x36, 0x63, 0x37, 0x39, 0x61, 0x31, 0x62, 0x34, 0x34, 0x63, 0x39, 0x33, 0x34, 0x66, 0x34, 0x30, 0x38, 0x36, 0x66, 0x39, 0x30, 0x35, 0x33, 0x32, 0x65, 0x39, 0x65, 0x64, 0x64, 0x30, 0x39, 0x38, 0x61, 0x63, 0x37, 0x63, 0x34, 0x62, 0x32, 0x39, 0x66, 0x33, 0x33, 0x66, 0x35, 0x37, 0x33, 0x31, 0x64, 0x39, 0x37, 0x37, 0x32, 0x39, 0x66, 0x63, 0x65, 0x31, 0x61, 0x31, 0x32, 0x33, 0x32, 0x61, 0x39, 0x66, 0x30, 0x61, 0x63, 0x36, 0x36, 0x30, 0x62, 0x32, 0x34, 0x37, 0x30, 0x36, 0x38, 0x31, 0x30, 0x66, 0x37, 0x32, 0x65, 0x38, 0x61, 0x32, 0x35, 0x65, 0x61, 0x30, 0x39, 0x62, 0x33, 0x30, 0x65, 0x30, 0x63, 0x61, 0x62, 0x62, 0x34, 0x33, 0x34, 0x38, 0x65, 0x30, 0x32, 0x35, 0x36, 0x35, 0x37, 0x34, 0x31, 0x37, 0x32, 0x34, 0x65, 0x35, 0x64, 0x63, 0x63, 0x35, 0x36, 0x66, 0x65, 0x66, 0x36, 0x62, 0x63, 0x66, 0x32, 0x39, 0x61, 0x64, 0x61, 0x34, 0x35, 0x38, 0x64, 0x66, 0x35, 0x39, 0x37, 0x36, 0x32, 0x33, 0x35, 0x32, 0x33, 0x30, 0x32, 0x37, 0x34, 0x30, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, 0x39, 0x66, 0x38, 0x61, 0x32, 0x34, 0x36, 0x33, 0x33, 0x33, 0x30, 0x66, 0x30, 0x65, 0x62, 0x38, 0x62, 0x32, 0x32, 0x30, 0x30, 0x35, 0x37, 0x33, 0x30, 0x36, 0x34, 0x31, 0x63, 0x61, 0x64, 0x32, 0x30, 0x30, 0x31, 0x34, 0x36, 0x63, 0x33, 0x33, 0x65, 0x62, 0x64, 0x37, 0x65, 0x61, 0x31, 0x62, 0x62, 0x35, 0x32, 0x35, 0x34, 0x33, 0x36, 0x30, 0x36, 0x37, 0x35, 0x62, 0x62, 0x63, 0x32, 0x65, 0x64, 0x63, 0x30, 0x31, 0x61, 0x65, 0x39, 0x37, 0x37, 0x65, 0x65, 0x31, 0x34, 0x31, 0x64, 0x31, 0x34, 0x30, 0x32, 0x37, 0x66, 0x34, 0x31, 0x64, 0x34, 0x39, 0x61, 0x62, 0x64, 0x63, 0x62, 0x39, 0x39, 0x33, 0x62, 0x63, 0x66, 0x31, 0x35, 0x65, 0x66, 0x62, 0x38, 0x34, 0x37, 0x61, 0x33, 0x36, 0x38, 0x64, 0x36, 0x36, 0x30, 0x39, 0x32, 0x34, 0x61, 0x37, 0x30, 0x66, 0x64, 0x34, 0x37, 0x37, 0x37, 0x33, 0x39, 0x37, 0x61, 0x32, 0x31, 0x62, 0x38, 0x38, 0x32, 0x33, 0x61, 0x32, 0x32, 0x65, 0x31, 0x31, 0x64, 0x61, 0x37, 0x39, 0x34, 0x30, 0x61, 0x61, 0x64, 0x36, 0x35, 0x37, 0x63, 0x39, 0x36, 0x39, 0x64, 0x35, 0x35, 0x65, 0x62, 0x30, 0x64, 0x61, 0x64, 0x36, 0x63, 0x35, 0x35, 0x62, 0x39, 0x33, 0x66, 0x35, 0x38, 0x38, 0x61, 0x64, 0x62, 0x63, 0x34, 0x35, 0x30, 0x65, 0x37, 0x37, 0x39, 0x31, 0x37, 0x38, 0x38, 0x37, 0x34, 0x66, 0x37, 0x63, 0x36, 0x31, 0x62, 0x39, 0x32, 0x35, 0x39, 0x37, 0x32, 0x32, 0x32, 0x65, 0x34, 0x66, 0x31, 0x34, 0x61, 0x31, 0x34, 0x31, 0x37, 0x39, 0x62, 0x62, 0x30, 0x35, 0x31, 0x30, 0x35, 0x35, 0x34, 0x62, 0x63, 0x64, 0x38, 0x36, 0x61, 0x62, 0x33, 0x39, 0x39, 0x35, 0x36, 0x38, 0x61, 0x39, 0x30, 0x61, 0x65, 0x65, 0x62, 0x62, 0x36, 0x31, 0x63, 0x64, 0x39, 0x39, 0x64, 0x30, 0x65, 0x36, 0x36, 0x32, 0x37, 0x34, 0x31, 0x37, 0x63, 0x38, 0x33, 0x34, 0x33, 0x35, 0x37, 0x30, 0x64, 0x32, 0x30, 0x66, 0x65, 0x65, 0x32, 0x65, 0x35, 0x37, 0x31, 0x38, 0x64, 0x66, 0x34, 0x36, 0x30, 0x63, 0x65, 0x61, 0x37, 0x37, 0x34, 0x64, 0x35, 0x39, 0x38, 0x37, 0x62, 0x37, 0x34, 0x65, 0x31, 0x65, 0x38, 0x31, 0x31, 0x31, 0x62, 0x35, 0x65, 0x39, 0x34, 0x34, 0x66, 0x32, 0x61, 0x33, 0x66, 0x35, 0x38, 0x33, 0x62, 0x65, 0x39, 0x37, 0x61, 0x30, 0x39, 0x30, 0x64, 0x32, 0x36, 0x39, 0x33, 0x34, 0x35, 0x34, 0x35, 0x33, 0x66, 0x34, 0x39, 0x61, 0x39, 0x30, 0x39, 0x65, 0x62, 0x64, 0x31, 0x32, 0x33, 0x34, 0x35, 0x30, 0x61, 0x39, 0x63, 0x66, 0x31, 0x36, 0x34, 0x38, 0x37, 0x32, 0x34, 0x38, 0x64, 0x38, 0x65, 0x66, 0x61, 0x61, 0x35, 0x32, 0x30, 0x34, 0x33, 0x33, 0x63, 0x37, 0x61, 0x35, 0x36, 0x37, 0x34, 0x36, 0x63, 0x62, 0x38, 0x66, 0x61, 0x37, 0x32, 0x35, 0x39, 0x34, 0x63, 0x36, 0x63, 0x34, 0x66, 0x34, 0x34, 0x34, 0x31, 0x31, 0x35, 0x32, 0x35, 0x35, 0x62, 0x33, 0x61, 0x61, 0x39, 0x64, 0x34, 0x31, 0x66, 0x38, 0x65, 0x61, 0x39, 0x37, 0x34, 0x63, 0x37, 0x31, 0x34, 0x36, 0x33, 0x34, 0x38, 0x38, 0x34, 0x61, 0x61, 0x66, 0x38, 0x32, 0x39, 0x62, 0x61, 0x34, 0x30, 0x33, 0x38, 0x63, 0x38, 0x65, 0x64, 0x32, 0x66, 0x33, 0x64, 0x37, 0x32, 0x34, 0x62, 0x37, 0x32, 0x35, 0x31, 0x66, 0x65, 0x37, 0x62, 0x38, 0x65, 0x36, 0x31, 0x30, 0x30, 0x33, 0x34, 0x64, 0x37, 0x65, 0x66, 0x61, 0x34, 0x32, 0x31, 0x66, 0x65, 0x30, 0x64, 0x36, 0x33, 0x61, 0x63, 0x66, 0x66, 0x32, 0x61, 0x33, 0x31, 0x31, 0x38, 0x35, 0x63, 0x37, 0x39, 0x65, 0x30, 0x36, 0x34, 0x65, 0x37, 0x65, 0x38, 0x35, 0x64, 0x37, 0x39, 0x39, 0x34, 0x34, 0x33, 0x37, 0x32, 0x39, 0x37, 0x36, 0x39, 0x30, 0x31, 0x66, 0x64, 0x61, 0x36, 0x39, 0x61, 0x61, 0x34, 0x34, 0x63, 0x63, 0x61, 0x37, 0x36, 0x66, 0x35, 0x65, 0x64, 0x30, 0x35, 0x33, 0x34, 0x62, 0x31, 0x34, 0x62, 0x31, 0x37, 0x39, 0x35, 0x32, 0x63, 0x36, 0x37, 0x35, 0x32, 0x35, 0x65, 0x64, 0x39, 0x64, 0x66, 0x39, 0x62, 0x61, 0x34, 0x62, 0x32, 0x30, 0x30, 0x61, 0x64, 0x63, 0x38, 0x31, 0x39, 0x32, 0x65, 0x39, 0x35, 0x63, 0x65, 0x32, 0x62, 0x33, 0x63, 0x63, 0x30, 0x38, 0x33, 0x35, 0x33, 0x33, 0x66, 0x38, 0x31, 0x65, 0x62, 0x33, 0x64, 0x61, 0x35, 0x64, 0x31, 0x37, 0x37, 0x31, 0x31, 0x66, 0x61, 0x33, 0x63, 0x65, 0x63, 0x38, 0x35, 0x63, 0x34, 0x34, 0x66, 0x64, 0x65, 0x65, 0x35, 0x33, 0x37, 0x35, 0x64, 0x65, 0x64, 0x62, 0x34, 0x62, 0x61, 0x32, 0x66, 0x61, 0x66, 0x37, 0x35, 0x34, 0x33, 0x61, 0x63, 0x38, 0x63, 0x61, 0x38, 0x33, 0x62, 0x61, 0x62, 0x39, 0x65, 0x39, 0x33, 0x62, 0x31, 0x30, 0x36, 0x38, 0x32, 0x31, 0x37, 0x34, 0x32, 0x36, 0x36, 0x34, 0x61, 0x34, 0x31, 0x37, 0x66, 0x35, 0x31, 0x65, 0x62, 0x37, 0x35, 0x34, 0x39, 0x37, 0x39, 0x65, 0x63, 0x35, 0x63, 0x65, 0x37, 0x30, 0x61, 0x35, 0x30, 0x63, 0x36, 0x62, 0x39, 0x63, 0x38, 0x62, 0x38, 0x30, 0x31, 0x37, 0x32, 0x62, 0x32, 0x34, 0x39, 0x33, 0x32, 0x36, 0x32, 0x30, 0x36, 0x35, 0x36, 0x66, 0x65, 0x61, 0x38, 0x37, 0x63, 0x61, 0x33, 0x33, 0x31, 0x63, 0x62, 0x35, 0x38, 0x34, 0x31, 0x66, 0x34, 0x33, 0x63, 0x31, 0x62, 0x35, 0x36, 0x38, 0x66, 0x61, 0x64, 0x63, 0x61, 0x37, 0x30, 0x38, 0x64, 0x66, 0x33, 0x32, 0x62, 0x34, 0x30, 0x34, 0x37, 0x66, 0x65, 0x36, 0x63, 0x31, 0x62, 0x64, 0x39, 0x37, 0x32, 0x63, 0x61, 0x63, 0x38, 0x62, 0x36, 0x63, 0x61, 0x63, 0x64, 0x66, 0x34, 0x64, 0x34, 0x39, 0x33, 0x38, 0x33, 0x39, 0x61, 0x65, 0x39, 0x63, 0x38, 0x65, 0x37, 0x39, 0x66, 0x63, 0x32, 0x33, 0x64, 0x66, 0x65, 0x36, 0x33, 0x65, 0x65, 0x66, 0x39, 0x33, 0x38, 0x37, 0x32, 0x65, 0x65, 0x33, 0x66, 0x34, 0x32, 0x31, 0x39, 0x36, 0x37, 0x61, 0x32, 0x64, 0x33, 0x37, 0x32, 0x66, 0x63, 0x37, 0x30, 0x38, 0x65, 0x61, 0x33, 0x61, 0x36, 0x37, 0x35, 0x30, 0x66, 0x62, 0x32, 0x34, 0x66, 0x38, 0x30, 0x61, 0x36, 0x62, 0x66, 0x35, 0x63, 0x30, 0x37, 0x61, 0x36, 0x37, 0x38, 0x37, 0x35, 0x37, 0x61, 0x61, 0x31, 0x35, 0x66, 0x66, 0x34, 0x38, 0x61, 0x64, 0x61, 0x65, 0x63, 0x31, 0x64, 0x32, 0x38, 0x37, 0x32, 0x37, 0x30, 0x63, 0x33, 0x65, 0x63, 0x30, 0x66, 0x61, 0x37, 0x33, 0x61, 0x33, 0x32, 0x62, 0x61, 0x30, 0x65, 0x36, 0x66, 0x36, 0x34, 0x33, 0x33, 0x37, 0x36, 0x64, 0x38, 0x66, 0x63, 0x33, 0x62, 0x32, 0x31, 0x31, 0x34, 0x62, 0x33, 0x64, 0x62, 0x33, 0x61, 0x30, 0x64, 0x37, 0x64, 0x63, 0x30, 0x62, 0x66, 0x32, 0x35, 0x66, 0x63, 0x37, 0x62, 0x64, 0x34, 0x62, 0x34, 0x31, 0x62, 0x39, 0x39, 0x65, 0x35, 0x34, 0x66, 0x36, 0x63, 0x31, 0x32, 0x63, 0x66, 0x37, 0x62, 0x33, 0x35, 0x39, 0x37, 0x39, 0x61, 0x35, 0x63, 0x34, 0x61, 0x62, 0x65, 0x30, 0x33, 0x38, 0x62, 0x39, 0x62, 0x65, 0x65, 0x32, 0x64, 0x33, 0x35, 0x64, 0x34, 0x36, 0x39, 0x32, 0x32, 0x37, 0x39, 0x38, 0x32, 0x65, 0x37, 0x33, 0x66, 0x30, 0x37, 0x34, 0x64, 0x66, 0x62, 0x38, 0x65, 0x38, 0x35, 0x61, 0x38, 0x39, 0x64, 0x35, 0x66, 0x66, 0x31, 0x64, 0x37, 0x32, 0x36, 0x36, 0x30, 0x39, 0x36, 0x32, 0x63, 0x33, 0x61, 0x36, 0x63, 0x61, 0x32, 0x35, 0x32, 0x61, 0x63, 0x63, 0x36, 0x32, 0x37, 0x32, 0x30, 0x38, 0x37, 0x66, 0x64, 0x64, 0x35, 0x37, 0x61, 0x63, 0x33, 0x65, 0x37, 0x33, 0x32, 0x38, 0x38, 0x33, 0x32, 0x63, 0x31, 0x36, 0x62, 0x63, 0x37, 0x35, 0x31, 0x36, 0x37, 0x32, 0x34, 0x66, 0x33, 0x36, 0x61, 0x62, 0x61, 0x37, 0x61, 0x30, 0x61, 0x36, 0x61, 0x30, 0x64, 0x62, 0x38, 0x37, 0x32, 0x61, 0x38, 0x65, 0x39, 0x37, 0x38, 0x62, 0x37, 0x66, 0x33, 0x64, 0x34, 0x64, 0x38, 0x37, 0x65, 0x30, 0x37, 0x66, 0x37, 0x36, 0x33, 0x63, 0x32, 0x32, 0x39, 0x36, 0x31, 0x63, 0x38, 0x35, 0x64, 0x65, 0x38, 0x61, 0x35, 0x35, 0x36, 0x63, 0x38, 0x63, 0x66, 0x62, 0x36, 0x37, 0x30, 0x66, 0x65, 0x39, 0x35, 0x36, 0x39, 0x63, 0x30, 0x32, 0x31, 0x65, 0x32, 0x36, 0x38, 0x32, 0x64, 0x33, 0x61, 0x31, 0x32, 0x62, 0x39, 0x33, 0x61, 0x31, 0x34, 0x37, 0x63, 0x30, 0x37, 0x34, 0x61, 0x61, 0x64, 0x30, 0x37, 0x30, 0x65, 0x32, 0x33, 0x34, 0x65, 0x31, 0x62, 0x34, 0x61, 0x63, 0x34, 0x30, 0x63, 0x64, 0x39, 0x36, 0x61, 0x35, 0x62, 0x62, 0x37, 0x36, 0x65, 0x64, 0x66, 0x64, 0x34, 0x63, 0x62, 0x62, 0x38, 0x61, 0x66, 0x65, 0x66, 0x38, 0x66, 0x61, 0x34, 0x36, 0x36, 0x64, 0x33, 0x36, 0x31, 0x32, 0x62, 0x36, 0x65, 0x30, 0x37, 0x64, 0x65, 0x30, 0x65, 0x32, 0x61, 0x65, 0x36, 0x34, 0x30, 0x64, 0x61, 0x32, 0x64, 0x61, 0x32, 0x35, 0x61, 0x62, 0x32, 0x37, 0x33, 0x64, 0x30, 0x64, 0x33, 0x38, 0x65, 0x62, 0x39, 0x34, 0x30, 0x31, 0x65, 0x35, 0x34, 0x31, 0x34, 0x34, 0x65, 0x31, 0x64, 0x62, 0x65, 0x39, 0x64, 0x36, 0x31, 0x66, 0x33, 0x34, 0x30, 0x37, 0x64, 0x31, 0x35, 0x32, 0x39, 0x63, 0x35, 0x30, 0x63, 0x37, 0x30, 0x39, 0x30, 0x34, 0x38, 0x39, 0x33, 0x32, 0x36, 0x63, 0x32, 0x31, 0x31, 0x38, 0x39, 0x38, 0x32, 0x30, 0x30, 0x66, 0x34, 0x65, 0x64, 0x62, 0x39, 0x61, 0x61, 0x35, 0x30, 0x66, 0x37, 0x32, 0x62, 0x39, 0x32, 0x36, 0x37, 0x38, 0x61, 0x66, 0x63, 0x62, 0x38, 0x32, 0x31, 0x30, 0x38, 0x62, 0x65, 0x65, 0x33, 0x66, 0x35, 0x31, 0x63, 0x64, 0x31, 0x37, 0x32, 0x36, 0x63, 0x34, 0x62, 0x37, 0x34, 0x64, 0x38, 0x66, 0x63, 0x37, 0x65, 0x38, 0x32, 0x64, 0x36, 0x61, 0x66, 0x36, 0x35, 0x65, 0x30, 0x33, 0x37, 0x65, 0x62, 0x34, 0x39, 0x34, 0x35, 0x65, 0x37, 0x35, 0x30, 0x31, 0x30, 0x34, 0x39, 0x64, 0x39, 0x63, 0x35, 0x63, 0x35, 0x66, 0x31, 0x32, 0x64, 0x33, 0x36, 0x65, 0x39, 0x33, 0x64, 0x36, 0x63, 0x31, 0x66, 0x34, 0x39, 0x31, 0x39, 0x37, 0x32, 0x65, 0x30, 0x35, 0x33, 0x38, 0x32, 0x32, 0x64, 0x33, 0x36, 0x66, 0x64, 0x34, 0x63, 0x33, 0x63, 0x31, 0x39, 0x38, 0x39, 0x62, 0x39, 0x30, 0x34, 0x66, 0x31, 0x30, 0x66, 0x66, 0x65, 0x33, 0x38, 0x31, 0x34, 0x30, 0x61, 0x65, 0x33, 0x64, 0x39, 0x63, 0x39, 0x30, 0x33, 0x37, 0x62, 0x63, 0x37, 0x65, 0x39, 0x31, 0x66, 0x62, 0x63, 0x33, 0x34, 0x66, 0x65, 0x39, 0x32, 0x65, 0x37, 0x37, 0x32, 0x66, 0x63, 0x33, 0x61, 0x31, 0x66, 0x37, 0x39, 0x35, 0x30, 0x34, 0x61, 0x31, 0x36, 0x34, 0x34, 0x38, 0x36, 0x63, 0x63, 0x66, 0x34, 0x62, 0x32, 0x64, 0x37, 0x61, 0x65, 0x61, 0x66, 0x63, 0x62, 0x39, 0x61, 0x65, 0x36, 0x66, 0x33, 0x62, 0x32, 0x66, 0x37, 0x31, 0x66, 0x62, 0x63, 0x63, 0x36, 0x38, 0x35, 0x38, 0x61, 0x38, 0x39, 0x61, 0x39, 0x39, 0x65, 0x36, 0x30, 0x30, 0x65, 0x37, 0x32, 0x34, 0x61, 0x30, 0x32, 0x62, 0x37, 0x66, 0x66, 0x34, 0x38, 0x30, 0x38, 0x33, 0x39, 0x63, 0x65, 0x30, 0x33, 0x32, 0x39, 0x34, 0x66, 0x31, 0x35, 0x61, 0x32, 0x64, 0x31, 0x35, 0x35, 0x33, 0x33, 0x30, 0x33, 0x36, 0x65, 0x33, 0x63, 0x34, 0x62, 0x32, 0x31, 0x62, 0x38, 0x61, 0x65, 0x31, 0x30, 0x37, 0x63, 0x36, 0x63, 0x64, 0x38, 0x32, 0x37, 0x34, 0x64, 0x34, 0x32, 0x39, 0x32, 0x37, 0x32, 0x65, 0x62, 0x38, 0x30, 0x63, 0x64, 0x37, 0x34, 0x66, 0x30, 0x63, 0x39, 0x64, 0x35, 0x35, 0x37, 0x65, 0x64, 0x65, 0x32, 0x38, 0x36, 0x63, 0x61, 0x61, 0x34, 0x31, 0x61, 0x35, 0x38, 0x39, 0x62, 0x62, 0x33, 0x66, 0x31, 0x61, 0x36, 0x65, 0x36, 0x34, 0x31, 0x38, 0x62, 0x32, 0x39, 0x36, 0x63, 0x30, 0x32, 0x35, 0x33, 0x61, 0x64, 0x63, 0x32, 0x62, 0x31, 0x34, 0x33, 0x66, 0x63, 0x37, 0x32, 0x38, 0x30, 0x37, 0x38, 0x63, 0x62, 0x65, 0x37, 0x61, 0x33, 0x62, 0x30, 0x35, 0x32, 0x36, 0x61, 0x65, 0x36, 0x36, 0x31, 0x30, 0x63, 0x65, 0x64, 0x36, 0x61, 0x65, 0x66, 0x64, 0x62, 0x65, 0x66, 0x34, 0x34, 0x66, 0x33, 0x64, 0x37, 0x65, 0x31, 0x30, 0x33, 0x30, 0x63, 0x62, 0x35, 0x38, 0x66, 0x37, 0x32, 0x64, 0x37, 0x36, 0x35, 0x35, 0x64, 0x35, 0x32, 0x63, 0x38, 0x38, 0x63, 0x37, 0x32, 0x37, 0x30, 0x35, 0x61, 0x34, 0x34, 0x61, 0x63, 0x66, 0x64, 0x31, 0x64, 0x66, 0x62, 0x34, 0x65, 0x36, 0x38, 0x30, 0x64, 0x38, 0x35, 0x32, 0x65, 0x63, 0x36, 0x61, 0x61, 0x38, 0x36, 0x35, 0x37, 0x61, 0x63, 0x65, 0x32, 0x38, 0x30, 0x36, 0x31, 0x34, 0x63, 0x34, 0x37, 0x65, 0x30, 0x66, 0x38, 0x64, 0x36, 0x66, 0x39, 0x66, 0x37, 0x61, 0x36, 0x65, 0x39, 0x34, 0x38, 0x35, 0x37, 0x37, 0x32, 0x32, 0x33, 0x38, 0x37, 0x61, 0x35, 0x66, 0x31, 0x32, 0x63, 0x31, 0x30, 0x63, 0x32, 0x34, 0x65, 0x35, 0x62, 0x64, 0x32, 0x65, 0x63, 0x63, 0x62, 0x33, 0x62, 0x65, 0x37, 0x66, 0x64, 0x34, 0x39, 0x65, 0x38, 0x32, 0x64, 0x38, 0x35, 0x31, 0x30, 0x39, 0x34, 0x66, 0x33, 0x63, 0x35, 0x32, 0x30, 0x35, 0x37, 0x31, 0x38, 0x62, 0x63, 0x61, 0x63, 0x34, 0x34, 0x33, 0x33, 0x38, 0x34, 0x34, 0x35, 0x36, 0x62, 0x32, 0x32, 0x62, 0x34, 0x64, 0x38, 0x38, 0x37, 0x30, 0x31, 0x37, 0x36, 0x33, 0x65, 0x37, 0x62, 0x34, 0x30, 0x63, 0x64, 0x65, 0x64, 0x31, 0x61, 0x62, 0x33, 0x33, 0x37, 0x37, 0x66, 0x66, 0x61, 0x38, 0x62, 0x65, 0x39, 0x66, 0x39, 0x39, 0x63, 0x33, 0x32, 0x39, 0x64, 0x38, 0x61, 0x62, 0x66, 0x36, 0x31, 0x38, 0x38, 0x33, 0x30, 0x34, 0x33, 0x66, 0x30, 0x38, 0x38, 0x35, 0x35, 0x62, 0x34, 0x63, 0x63, 0x63, 0x66, 0x30, 0x39, 0x65, 0x33, 0x35, 0x30, 0x39, 0x61, 0x65, 0x61, 0x64, 0x34, 0x36, 0x64, 0x63, 0x37, 0x66, 0x65, 0x61, 0x61, 0x65, 0x61, 0x66, 0x33, 0x39, 0x33, 0x37, 0x64, 0x65, 0x31, 0x61, 0x36, 0x66, 0x66, 0x34, 0x63, 0x30, 0x35, 0x34, 0x30, 0x64, 0x65, 0x63, 0x39, 0x30, 0x64, 0x66, 0x31, 0x63, 0x35, 0x37, 0x37, 0x34, 0x37, 0x37, 0x36, 0x37, 0x32, 0x65, 0x65, 0x38, 0x33, 0x62, 0x30, 0x30, 0x37, 0x30, 0x63, 0x37, 0x31, 0x37, 0x63, 0x34, 0x65, 0x31, 0x62, 0x38, 0x31, 0x35, 0x35, 0x30, 0x62, 0x38, 0x66, 0x63, 0x62, 0x35, 0x37, 0x65, 0x37, 0x61, 0x33, 0x39, 0x61, 0x62, 0x35, 0x65, 0x33, 0x63, 0x39, 0x38, 0x31, 0x32, 0x62, 0x34, 0x66, 0x34, 0x32, 0x62, 0x63, 0x37, 0x33, 0x31, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x66, 0x37, 0x32, 0x31, 0x37, 0x65, 0x37, 0x32, 0x33, 0x33, 0x30, 0x61, 0x37, 0x63, 0x63, 0x37, 0x36, 0x66, 0x33, 0x30, 0x63, 0x62, 0x62, 0x65, 0x33, 0x66, 0x31, 0x62, 0x61, 0x39, 0x35, 0x30, 0x66, 0x39, 0x65, 0x36, 0x65, 0x61, 0x31, 0x36, 0x38, 0x64, 0x39, 0x36, 0x61, 0x34, 0x34, 0x32, 0x35, 0x37, 0x62, 0x39, 0x38, 0x62, 0x66, 0x38, 0x62, 0x62, 0x31, 0x36, 0x65, 0x63, 0x37, 0x34, 0x37, 0x37, 0x32, 0x32, 0x35, 0x30, 0x33, 0x37, 0x36, 0x65, 0x39, 0x38, 0x36, 0x33, 0x65, 0x38, 0x38, 0x66, 0x37, 0x63, 0x34, 0x37, 0x31, 0x39, 0x62, 0x65, 0x63, 0x66, 0x39, 0x36, 0x64, 0x61, 0x32, 0x61, 0x66, 0x64, 0x62, 0x37, 0x63, 0x35, 0x37, 0x34, 0x35, 0x30, 0x38, 0x36, 0x66, 0x35, 0x66, 0x65, 0x39, 0x62, 0x37, 0x39, 0x38, 0x39, 0x65, 0x36, 0x35, 0x63, 0x34, 0x30, 0x35, 0x37, 0x65, 0x37, 0x32, 0x39, 0x31, 0x37, 0x31, 0x36, 0x34, 0x39, 0x34, 0x34, 0x31, 0x31, 0x38, 0x65, 0x34, 0x38, 0x36, 0x31, 0x65, 0x63, 0x37, 0x34, 0x64, 0x33, 0x65, 0x32, 0x32, 0x30, 0x63, 0x65, 0x31, 0x38, 0x66, 0x37, 0x65, 0x35, 0x31, 0x65, 0x36, 0x37, 0x34, 0x37, 0x39, 0x64, 0x62, 0x34, 0x32, 0x30, 0x64, 0x39, 0x61, 0x62, 0x39, 0x36, 0x62, 0x31, 0x30, 0x37, 0x32, 0x38, 0x38, 0x32, 0x65, 0x37, 0x31, 0x65, 0x65, 0x35, 0x33, 0x37, 0x63, 0x65, 0x66, 0x31, 0x37, 0x31, 0x63, 0x37, 0x36, 0x32, 0x35, 0x30, 0x61, 0x38, 0x31, 0x65, 0x62, 0x63, 0x35, 0x39, 0x39, 0x32, 0x64, 0x32, 0x35, 0x38, 0x66, 0x63, 0x31, 0x39, 0x34, 0x35, 0x39, 0x65, 0x63, 0x32, 0x65, 0x66, 0x39, 0x38, 0x34, 0x38, 0x30, 0x39, 0x35, 0x35, 0x36, 0x65, 0x31, 0x34, 0x31, 0x62, 0x32, 0x33, 0x63, 0x62, 0x32, 0x34, 0x34, 0x61, 0x64, 0x63, 0x31, 0x64, 0x61, 0x39, 0x62, 0x62, 0x65, 0x62, 0x31, 0x37, 0x34, 0x64, 0x63, 0x61, 0x34, 0x62, 0x66, 0x61, 0x37, 0x32, 0x31, 0x33, 0x37, 0x37, 0x39, 0x34, 0x35, 0x30, 0x63, 0x64, 0x37, 0x65, 0x62, 0x61, 0x35, 0x63, 0x64, 0x66, 0x62, 0x34, 0x31, 0x33, 0x34, 0x32, 0x62, 0x65, 0x39, 0x66, 0x36, 0x33, 0x30, 0x62, 0x34, 0x35, 0x39, 0x36, 0x63, 0x65, 0x66, 0x33, 0x65, 0x66, 0x38, 0x32, 0x32, 0x64, 0x66, 0x39, 0x33, 0x61, 0x30, 0x64, 0x62, 0x39, 0x61, 0x31, 0x31, 0x64, 0x37, 0x35, 0x33, 0x63, 0x63, 0x64, 0x38, 0x37, 0x63, 0x38, 0x65, 0x65, 0x33, 0x32, 0x39, 0x30, 0x30, 0x31, 0x63, 0x39, 0x65, 0x63, 0x38, 0x63, 0x66, 0x39, 0x37, 0x65, 0x35, 0x66, 0x61, 0x39, 0x65, 0x37, 0x61, 0x37, 0x36, 0x64, 0x65, 0x33, 0x34, 0x34, 0x32, 0x66, 0x35, 0x30, 0x33, 0x32, 0x30, 0x61, 0x61, 0x31, 0x38, 0x39, 0x36, 0x66, 0x61, 0x65, 0x62, 0x64, 0x66, 0x65, 0x34, 0x35, 0x32, 0x66, 0x31, 0x65, 0x62, 0x61, 0x30, 0x61, 0x61, 0x33, 0x65, 0x35, 0x64, 0x61, 0x62, 0x63, 0x66, 0x66, 0x35, 0x32, 0x36, 0x38, 0x38, 0x61, 0x32, 0x31, 0x39, 0x35, 0x33, 0x39, 0x64, 0x62, 0x34, 0x39, 0x63, 0x33, 0x61, 0x64, 0x63, 0x65, 0x30, 0x35, 0x39, 0x64, 0x34, 0x37, 0x32, 0x36, 0x66, 0x64, 0x39, 0x66, 0x33, 0x31, 0x63, 0x32, 0x36, 0x64, 0x30, 0x66, 0x32, 0x37, 0x66, 0x36, 0x62, 0x38, 0x34, 0x30, 0x38, 0x64, 0x61, 0x30, 0x64, 0x38, 0x63, 0x32, 0x31, 0x33, 0x31, 0x37, 0x63, 0x64, 0x31, 0x33, 0x62, 0x30, 0x32, 0x35, 0x35, 0x34, 0x64, 0x30, 0x61, 0x39, 0x38, 0x30, 0x30, 0x66, 0x39, 0x62, 0x36, 0x37, 0x33, 0x37, 0x61, 0x61, 0x32, 0x63, 0x32, 0x37, 0x32, 0x63, 0x64, 0x61, 0x34, 0x66, 0x66, 0x66, 0x32, 0x39, 0x36, 0x38, 0x61, 0x30, 0x38, 0x35, 0x30, 0x66, 0x30, 0x66, 0x62, 0x65, 0x66, 0x39, 0x39, 0x62, 0x66, 0x36, 0x65, 0x65, 0x39, 0x64, 0x38, 0x63, 0x34, 0x65, 0x39, 0x66, 0x38, 0x36, 0x61, 0x31, 0x36, 0x30, 0x63, 0x63, 0x34, 0x38, 0x64, 0x35, 0x66, 0x66, 0x39, 0x33, 0x61, 0x39, 0x61, 0x64, 0x38, 0x32, 0x39, 0x61, 0x36, 0x36, 0x32, 0x34, 0x35, 0x66, 0x38, 0x66, 0x62, 0x33, 0x39, 0x63, 0x33, 0x34, 0x61, 0x33, 0x63, 0x61, 0x36, 0x33, 0x36, 0x31, 0x30, 0x35, 0x62, 0x35, 0x33, 0x61, 0x38, 0x35, 0x33, 0x65, 0x63, 0x32, 0x37, 0x35, 0x31, 0x36, 0x34, 0x64, 0x35, 0x36, 0x61, 0x30, 0x39, 0x62, 0x62, 0x30, 0x36, 0x65, 0x36, 0x66, 0x34, 0x32, 0x37, 0x61, 0x34, 0x35, 0x34, 0x33, 0x37, 0x64, 0x62, 0x64, 0x30, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x66, 0x37, 0x35, 0x63, 0x63, 0x30, 0x34, 0x31, 0x39, 0x62, 0x65, 0x38, 0x63, 0x61, 0x61, 0x33, 0x34, 0x35, 0x65, 0x38, 0x62, 0x33, 0x36, 0x39, 0x62, 0x36, 0x39, 0x65, 0x64, 0x61, 0x39, 0x61, 0x65, 0x61, 0x32, 0x62, 0x61, 0x37, 0x64, 0x39, 0x35, 0x32, 0x63, 0x39, 0x31, 0x64, 0x34, 0x61, 0x36, 0x39, 0x37, 0x61, 0x30, 0x66, 0x62, 0x32, 0x64, 0x65, 0x64, 0x35, 0x37, 0x65, 0x63, 0x64, 0x39, 0x33, 0x62, 0x61, 0x36, 0x37, 0x30, 0x38, 0x65, 0x62, 0x33, 0x36, 0x63, 0x36, 0x36, 0x33, 0x33, 0x37, 0x34, 0x39, 0x66, 0x38, 0x63, 0x64, 0x63, 0x66, 0x65, 0x38, 0x34, 0x62, 0x65, 0x35, 0x33, 0x38, 0x66, 0x38, 0x61, 0x38, 0x35, 0x66, 0x39, 0x32, 0x65, 0x65, 0x65, 0x62, 0x65, 0x32, 0x38, 0x61, 0x30, 0x30, 0x33, 0x63, 0x36, 0x35, 0x32, 0x64, 0x36, 0x64, 0x35, 0x30, 0x65, 0x33, 0x62, 0x35, 0x32, 0x32, 0x62, 0x39, 0x35, 0x34, 0x32, 0x31, 0x33, 0x64, 0x35, 0x30, 0x65, 0x30, 0x65, 0x37, 0x65, 0x35, 0x66, 0x33, 0x61, 0x63, 0x35, 0x35, 0x63, 0x64, 0x33, 0x38, 0x61, 0x39, 0x33, 0x33, 0x38, 0x64, 0x34, 0x30, 0x38, 0x37, 0x34, 0x63, 0x63, 0x31, 0x30, 0x66, 0x62, 0x64, 0x34, 0x65, 0x63, 0x38, 0x63, 0x64, 0x37, 0x37, 0x32, 0x66, 0x32, 0x66, 0x62, 0x63, 0x30, 0x35, 0x37, 0x39, 0x37, 0x38, 0x36, 0x36, 0x62, 0x65, 0x65, 0x37, 0x39, 0x66, 0x65, 0x31, 0x62, 0x38, 0x37, 0x37, 0x33, 0x64, 0x34, 0x34, 0x30, 0x65, 0x35, 0x62, 0x35, 0x36, 0x32, 0x34, 0x66, 0x36, 0x32, 0x35, 0x63, 0x32, 0x38, 0x30, 0x66, 0x66, 0x33, 0x34, 0x63, 0x35, 0x39, 0x34, 0x61, 0x38, 0x64, 0x38, 0x64, 0x35, 0x32, 0x61, 0x32, 0x30, 0x31, 0x35, 0x31, 0x62, 0x63, 0x33, 0x34, 0x32, 0x63, 0x38, 0x39, 0x64, 0x62, 0x63, 0x62, 0x62, 0x61, 0x34, 0x34, 0x36, 0x33, 0x31, 0x30, 0x61, 0x65, 0x37, 0x61, 0x62, 0x39, 0x63, 0x62, 0x38, 0x62, 0x66, 0x34, 0x36, 0x62, 0x34, 0x63, 0x64, 0x35, 0x34, 0x37, 0x61, 0x63, 0x36, 0x63, 0x65, 0x34, 0x30, 0x65, 0x35, 0x65, 0x61, 0x34, 0x64, 0x33, 0x31, 0x36, 0x37, 0x31, 0x38, 0x36, 0x37, 0x32, 0x65, 0x63, 0x65, 0x31, 0x36, 0x62, 0x35, 0x66, 0x33, 0x34, 0x38, 0x63, 0x65, 0x65, 0x32, 0x65, 0x61, 0x61, 0x39, 0x35, 0x33, 0x66, 0x34, 0x33, 0x65, 0x38, 0x38, 0x33, 0x36, 0x62, 0x63, 0x38, 0x63, 0x34, 0x35, 0x64, 0x36, 0x66, 0x33, 0x39, 0x62, 0x36, 0x36, 0x64, 0x37, 0x62, 0x36, 0x62, 0x65, 0x65, 0x66, 0x30, 0x37, 0x33, 0x66, 0x63, 0x35, 0x31, 0x30, 0x36, 0x32, 0x66, 0x35, 0x30, 0x66, 0x66, 0x63, 0x34, 0x64, 0x61, 0x62, 0x39, 0x65, 0x35, 0x39, 0x35, 0x33, 0x31, 0x32, 0x38, 0x34, 0x38, 0x63, 0x62, 0x66, 0x39, 0x30, 0x63, 0x35, 0x35, 0x39, 0x62, 0x30, 0x62, 0x35, 0x63, 0x31, 0x30, 0x65, 0x38, 0x31, 0x37, 0x33, 0x61, 0x65, 0x64, 0x66, 0x31, 0x66, 0x31, 0x65, 0x30, 0x35, 0x63, 0x34, 0x64, 0x36, 0x30, 0x38, 0x32, 0x31, 0x36, 0x65, 0x64, 0x62, 0x65, 0x37, 0x32, 0x63, 0x31, 0x38, 0x31, 0x33, 0x36, 0x34, 0x30, 0x36, 0x61, 0x31, 0x33, 0x35, 0x63, 0x37, 0x62, 0x64, 0x61, 0x66, 0x64, 0x64, 0x37, 0x65, 0x36, 0x65, 0x36, 0x32, 0x34, 0x32, 0x31, 0x61, 0x61, 0x39, 0x39, 0x62, 0x61, 0x39, 0x37, 0x62, 0x37, 0x62, 0x30, 0x31, 0x34, 0x63, 0x36, 0x39, 0x31, 0x34, 0x65, 0x61, 0x33, 0x38, 0x33, 0x32, 0x36, 0x36, 0x32, 0x38, 0x30, 0x38, 0x64, 0x35, 0x37, 0x30, 0x62, 0x65, 0x62, 0x65, 0x30, 0x38, 0x36, 0x30, 0x36, 0x38, 0x32, 0x63, 0x37, 0x35, 0x61, 0x62, 0x62, 0x33, 0x34, 0x35, 0x39, 0x65, 0x62, 0x35, 0x61, 0x61, 0x38, 0x34, 0x39, 0x31, 0x64, 0x30, 0x64, 0x32, 0x38, 0x66, 0x64, 0x63, 0x38, 0x61, 0x34, 0x64, 0x35, 0x36, 0x62, 0x61, 0x32, 0x63, 0x39, 0x66, 0x38, 0x65, 0x33, 0x35, 0x32, 0x33, 0x36, 0x64, 0x65, 0x34, 0x31, 0x32, 0x36, 0x31, 0x37, 0x39, 0x32, 0x66, 0x38, 0x65, 0x64, 0x33, 0x39, 0x30, 0x34, 0x62, 0x32, 0x65, 0x37, 0x64, 0x39, 0x37, 0x37, 0x33, 0x31, 0x63, 0x30, 0x64, 0x30, 0x32, 0x31, 0x30, 0x37, 0x63, 0x31, 0x64, 0x36, 0x62, 0x32, 0x30, 0x31, 0x30, 0x39, 0x31, 0x38, 0x65, 0x39, 0x36, 0x61, 0x61, 0x37, 0x64, 0x32, 0x64, 0x34, 0x37, 0x39, 0x36, 0x39, 0x34, 0x66, 0x66, 0x32, 0x33, 0x66, 0x31, 0x37, 0x66, 0x32, 0x39, 0x34, 0x39, 0x34, 0x30, 0x66, 0x62, 0x66, 0x32, 0x31, 0x66, 0x30, 0x34, 0x66, 0x31, 0x36, 0x36, 0x35, 0x63, 0x66, 0x61, 0x36, 0x66, 0x37, 0x65, 0x33, 0x61, 0x62, 0x36, 0x34, 0x62, 0x30, 0x34, 0x31, 0x33, 0x35, 0x32, 0x35, 0x61, 0x66, 0x62, 0x65, 0x62, 0x66, 0x34, 0x38, 0x36, 0x65, 0x65, 0x38, 0x63, 0x65, 0x35, 0x64, 0x30, 0x63, 0x65, 0x33, 0x64, 0x33, 0x31, 0x39, 0x63, 0x61, 0x38, 0x36, 0x63, 0x39, 0x36, 0x65, 0x66, 0x65, 0x38, 0x36, 0x39, 0x62, 0x30, 0x31, 0x61, 0x31, 0x62, 0x61, 0x63, 0x61, 0x66, 0x36, 0x64, 0x33, 0x30, 0x32, 0x63, 0x64, 0x36, 0x66, 0x63, 0x32, 0x62, 0x63, 0x30, 0x34, 0x35, 0x30, 0x33, 0x64, 0x61, 0x31, 0x34, 0x63, 0x62, 0x61, 0x64, 0x33, 0x30, 0x38, 0x62, 0x38, 0x63, 0x61, 0x61, 0x63, 0x39, 0x62, 0x66, 0x39, 0x31, 0x33, 0x64, 0x63, 0x30, 0x39, 0x35, 0x66, 0x63, 0x65, 0x65, 0x34, 0x65, 0x30, 0x30, 0x63, 0x32, 0x62, 0x62, 0x34, 0x66, 0x66, 0x36, 0x66, 0x63, 0x33, 0x38, 0x61, 0x66, 0x63, 0x62, 0x30, 0x37, 0x38, 0x66, 0x34, 0x37, 0x34, 0x36, 0x36, 0x36, 0x63, 0x63, 0x32, 0x32, 0x30, 0x34, 0x37, 0x39, 0x33, 0x35, 0x31, 0x65, 0x39, 0x66, 0x65, 0x39, 0x34, 0x39, 0x66, 0x31, 0x35, 0x33, 0x61, 0x37, 0x32, 0x39, 0x34, 0x30, 0x31, 0x66, 0x37, 0x62, 0x39, 0x62, 0x32, 0x33, 0x66, 0x31, 0x31, 0x38, 0x30, 0x36, 0x30, 0x33, 0x37, 0x64, 0x39, 0x39, 0x64, 0x64, 0x66, 0x65, 0x32, 0x66, 0x34, 0x63, 0x62, 0x63, 0x38, 0x33, 0x35, 0x39, 0x33, 0x36, 0x34, 0x39, 0x65, 0x39, 0x33, 0x32, 0x61, 0x31, 0x63, 0x37, 0x63, 0x65, 0x65, 0x65, 0x35, 0x38, 0x34, 0x63, 0x64, 0x37, 0x61, 0x37, 0x30, 0x37, 0x32, 0x62, 0x35, 0x65, 0x37, 0x63, 0x62, 0x65, 0x39, 0x30, 0x65, 0x61, 0x35, 0x38, 0x36, 0x36, 0x36, 0x33, 0x38, 0x63, 0x63, 0x31, 0x61, 0x61, 0x38, 0x35, 0x61, 0x65, 0x37, 0x63, 0x64, 0x34, 0x35, 0x31, 0x65, 0x33, 0x37, 0x65, 0x37, 0x35, 0x31, 0x66, 0x66, 0x35, 0x30, 0x30, 0x65, 0x35, 0x38, 0x39, 0x33, 0x36, 0x32, 0x39, 0x65, 0x32, 0x37, 0x32, 0x36, 0x35, 0x37, 0x38, 0x65, 0x37, 0x32, 0x37, 0x65, 0x32, 0x63, 0x64, 0x34, 0x34, 0x31, 0x36, 0x37, 0x37, 0x65, 0x35, 0x61, 0x61, 0x30, 0x30, 0x33, 0x33, 0x38, 0x36, 0x37, 0x35, 0x39, 0x39, 0x34, 0x61, 0x39, 0x63, 0x36, 0x34, 0x38, 0x38, 0x31, 0x62, 0x39, 0x64, 0x61, 0x34, 0x65, 0x38, 0x61, 0x33, 0x31, 0x64, 0x36, 0x38, 0x65, 0x63, 0x61, 0x64, 0x39, 0x35, 0x63, 0x61, 0x38, 0x32, 0x33, 0x33, 0x66, 0x33, 0x33, 0x37, 0x32, 0x37, 0x61, 0x35, 0x30, 0x38, 0x35, 0x34, 0x39, 0x63, 0x32, 0x64, 0x36, 0x38, 0x37, 0x61, 0x33, 0x38, 0x63, 0x35, 0x30, 0x66, 0x66, 0x39, 0x66, 0x36, 0x33, 0x39, 0x64, 0x32, 0x30, 0x35, 0x37, 0x61, 0x63, 0x61, 0x63, 0x38, 0x64, 0x38, 0x65, 0x39, 0x35, 0x61, 0x32, 0x66, 0x31, 0x61, 0x36, 0x62, 0x37, 0x36, 0x37, 0x65, 0x63, 0x34, 0x31, 0x63, 0x32, 0x63, 0x37, 0x36, 0x36, 0x32, 0x39, 0x33, 0x61, 0x31, 0x65, 0x33, 0x62, 0x30, 0x64, 0x30, 0x32, 0x37, 0x37, 0x33, 0x61, 0x62, 0x32, 0x32, 0x38, 0x39, 0x32, 0x61, 0x38, 0x61, 0x30, 0x39, 0x32, 0x34, 0x32, 0x30, 0x39, 0x62, 0x34, 0x31, 0x32, 0x64, 0x31, 0x35, 0x39, 0x34, 0x35, 0x33, 0x36, 0x62, 0x33, 0x61, 0x37, 0x36, 0x39, 0x66, 0x38, 0x38, 0x38, 0x66, 0x39, 0x35, 0x39, 0x35, 0x34, 0x33, 0x30, 0x39, 0x65, 0x36, 0x65, 0x33, 0x35, 0x35, 0x61, 0x38, 0x32, 0x30, 0x38, 0x34, 0x39, 0x39, 0x30, 0x61, 0x32, 0x36, 0x36, 0x37, 0x30, 0x63, 0x38, 0x31, 0x35, 0x64, 0x64, 0x34, 0x62, 0x34, 0x32, 0x39, 0x66, 0x33, 0x31, 0x34, 0x66, 0x30, 0x66, 0x63, 0x61, 0x64, 0x66, 0x63, 0x33, 0x62, 0x33, 0x64, 0x65, 0x65, 0x33, 0x35, 0x61, 0x31, 0x61, 0x30, 0x64, 0x31, 0x31, 0x36, 0x35, 0x64, 0x65, 0x38, 0x31, 0x30, 0x39, 0x64, 0x63, 0x62, 0x34, 0x37, 0x64, 0x66, 0x64, 0x39, 0x63, 0x37, 0x35, 0x63, 0x61, 0x33, 0x62, 0x33, 0x62, 0x37, 0x35, 0x66, 0x64, 0x61, 0x61, 0x62, 0x61, 0x37, 0x34, 0x36, 0x37, 0x39, 0x30, 0x65, 0x65, 0x31, 0x62, 0x63, 0x38, 0x63, 0x65, 0x30, 0x31, 0x64, 0x39, 0x32, 0x37, 0x36, 0x63, 0x61, 0x37, 0x30, 0x66, 0x39, 0x33, 0x36, 0x63, 0x62, 0x35, 0x62, 0x33, 0x62, 0x62, 0x30, 0x39, 0x34, 0x33, 0x32, 0x63, 0x66, 0x62, 0x32, 0x35, 0x62, 0x30, 0x66, 0x33, 0x34, 0x38, 0x30, 0x62, 0x32, 0x32, 0x39, 0x65, 0x30, 0x61, 0x31, 0x36, 0x64, 0x66, 0x32, 0x33, 0x63, 0x31, 0x61, 0x35, 0x62, 0x32, 0x37, 0x37, 0x38, 0x65, 0x36, 0x64, 0x38, 0x63, 0x64, 0x65, 0x39, 0x36, 0x38, 0x63, 0x36, 0x31, 0x61, 0x37, 0x62, 0x63, 0x32, 0x36, 0x33, 0x34, 0x66, 0x35, 0x64, 0x61, 0x37, 0x32, 0x66, 0x62, 0x34, 0x64, 0x30, 0x34, 0x65, 0x39, 0x66, 0x66, 0x63, 0x66, 0x66, 0x36, 0x63, 0x33, 0x33, 0x37, 0x37, 0x36, 0x64, 0x38, 0x63, 0x32, 0x38, 0x38, 0x34, 0x38, 0x38, 0x65, 0x32, 0x39, 0x37, 0x61, 0x64, 0x61, 0x64, 0x38, 0x36, 0x30, 0x31, 0x66, 0x62, 0x39, 0x31, 0x36, 0x39, 0x35, 0x33, 0x63, 0x32, 0x66, 0x34, 0x32, 0x63, 0x38, 0x38, 0x66, 0x31, 0x32, 0x38, 0x61, 0x37, 0x32, 0x37, 0x66, 0x62, 0x36, 0x37, 0x61, 0x33, 0x61, 0x33, 0x61, 0x32, 0x64, 0x33, 0x38, 0x33, 0x32, 0x39, 0x35, 0x34, 0x38, 0x62, 0x38, 0x32, 0x35, 0x38, 0x65, 0x38, 0x37, 0x61, 0x39, 0x33, 0x37, 0x33, 0x63, 0x34, 0x66, 0x63, 0x38, 0x66, 0x30, 0x36, 0x62, 0x38, 0x37, 0x30, 0x35, 0x38, 0x65, 0x37, 0x62, 0x35, 0x35, 0x36, 0x39, 0x37, 0x37, 0x32, 0x31, 0x64, 0x62, 0x32, 0x61, 0x37, 0x32, 0x39, 0x32, 0x61, 0x37, 0x34, 0x33, 0x35, 0x36, 0x33, 0x32, 0x33, 0x32, 0x65, 0x65, 0x61, 0x32, 0x65, 0x36, 0x35, 0x66, 0x33, 0x63, 0x34, 0x34, 0x63, 0x30, 0x31, 0x35, 0x39, 0x31, 0x33, 0x66, 0x32, 0x35, 0x36, 0x34, 0x61, 0x36, 0x35, 0x39, 0x39, 0x61, 0x35, 0x66, 0x34, 0x34, 0x65, 0x35, 0x39, 0x66, 0x63, 0x30, 0x36, 0x36, 0x38, 0x62, 0x35, 0x38, 0x38, 0x35, 0x37, 0x35, 0x37, 0x32, 0x64, 0x35, 0x36, 0x37, 0x39, 0x65, 0x33, 0x38, 0x37, 0x63, 0x36, 0x35, 0x34, 0x31, 0x34, 0x65, 0x62, 0x31, 0x32, 0x33, 0x61, 0x33, 0x30, 0x35, 0x63, 0x30, 0x34, 0x64, 0x37, 0x33, 0x37, 0x64, 0x30, 0x34, 0x34, 0x36, 0x30, 0x30, 0x37, 0x66, 0x33, 0x39, 0x32, 0x32, 0x64, 0x33, 0x34, 0x63, 0x39, 0x62, 0x36, 0x37, 0x30, 0x32, 0x33, 0x62, 0x61, 0x65, 0x34, 0x37, 0x35, 0x63, 0x37, 0x32, 0x66, 0x36, 0x39, 0x30, 0x62, 0x31, 0x65, 0x36, 0x34, 0x30, 0x64, 0x34, 0x61, 0x30, 0x61, 0x38, 0x34, 0x64, 0x30, 0x38, 0x31, 0x34, 0x63, 0x32, 0x66, 0x65, 0x31, 0x36, 0x65, 0x32, 0x35, 0x35, 0x33, 0x32, 0x37, 0x37, 0x34, 0x30, 0x65, 0x66, 0x32, 0x38, 0x39, 0x39, 0x66, 0x63, 0x64, 0x31, 0x37, 0x66, 0x34, 0x33, 0x37, 0x30, 0x65, 0x36, 0x33, 0x38, 0x34, 0x31, 0x33, 0x30, 0x37, 0x32, 0x66, 0x62, 0x62, 0x31, 0x39, 0x30, 0x30, 0x66, 0x36, 0x65, 0x34, 0x62, 0x30, 0x34, 0x62, 0x66, 0x31, 0x33, 0x35, 0x64, 0x37, 0x62, 0x31, 0x65, 0x65, 0x34, 0x62, 0x64, 0x30, 0x33, 0x32, 0x36, 0x34, 0x31, 0x64, 0x30, 0x35, 0x35, 0x33, 0x37, 0x65, 0x31, 0x33, 0x62, 0x31, 0x62, 0x32, 0x61, 0x33, 0x39, 0x37, 0x36, 0x34, 0x30, 0x31, 0x32, 0x30, 0x34, 0x61, 0x66, 0x38, 0x35, 0x37, 0x32, 0x35, 0x63, 0x38, 0x33, 0x35, 0x65, 0x36, 0x35, 0x33, 0x34, 0x34, 0x65, 0x37, 0x34, 0x35, 0x30, 0x35, 0x31, 0x38, 0x35, 0x37, 0x32, 0x35, 0x62, 0x31, 0x32, 0x35, 0x62, 0x34, 0x33, 0x32, 0x65, 0x32, 0x35, 0x33, 0x62, 0x63, 0x65, 0x62, 0x64, 0x65, 0x32, 0x31, 0x37, 0x32, 0x37, 0x62, 0x63, 0x31, 0x62, 0x35, 0x33, 0x34, 0x62, 0x61, 0x62, 0x38, 0x65, 0x33, 0x64, 0x61, 0x62, 0x34, 0x61, 0x33, 0x64, 0x32, 0x64, 0x39, 0x31, 0x38, 0x33, 0x64, 0x38, 0x61, 0x34, 0x61, 0x36, 0x35, 0x30, 0x30, 0x65, 0x64, 0x32, 0x36, 0x30, 0x39, 0x37, 0x35, 0x33, 0x63, 0x32, 0x37, 0x37, 0x38, 0x65, 0x31, 0x39, 0x61, 0x62, 0x66, 0x32, 0x31, 0x63, 0x34, 0x65, 0x37, 0x37, 0x66, 0x30, 0x31, 0x36, 0x61, 0x30, 0x36, 0x31, 0x38, 0x63, 0x65, 0x34, 0x64, 0x34, 0x38, 0x33, 0x33, 0x32, 0x30, 0x61, 0x38, 0x33, 0x39, 0x65, 0x65, 0x38, 0x39, 0x35, 0x32, 0x30, 0x65, 0x36, 0x63, 0x37, 0x38, 0x32, 0x32, 0x32, 0x39, 0x62, 0x61, 0x34, 0x64, 0x61, 0x30, 0x66, 0x64, 0x64, 0x30, 0x30, 0x31, 0x32, 0x32, 0x33, 0x38, 0x35, 0x66, 0x35, 0x35, 0x65, 0x39, 0x34, 0x64, 0x32, 0x37, 0x65, 0x33, 0x61, 0x35, 0x65, 0x35, 0x34, 0x33, 0x30, 0x65, 0x36, 0x39, 0x66, 0x65, 0x35, 0x65, 0x33, 0x32, 0x39, 0x33, 0x31, 0x36, 0x39, 0x34, 0x33, 0x35, 0x66, 0x30, 0x62, 0x64, 0x61, 0x38, 0x66, 0x65, 0x34, 0x63, 0x34, 0x34, 0x35, 0x65, 0x31, 0x31, 0x65, 0x32, 0x62, 0x33, 0x32, 0x37, 0x33, 0x62, 0x32, 0x34, 0x63, 0x64, 0x31, 0x35, 0x61, 0x31, 0x32, 0x64, 0x64, 0x36, 0x37, 0x30, 0x36, 0x64, 0x61, 0x63, 0x63, 0x64, 0x30, 0x30, 0x39, 0x33, 0x31, 0x33, 0x33, 0x63, 0x33, 0x30, 0x36, 0x37, 0x32, 0x34, 0x31, 0x64, 0x32, 0x31, 0x35, 0x32, 0x37, 0x37, 0x31, 0x30, 0x35, 0x36, 0x63, 0x30, 0x31, 0x66, 0x66, 0x38, 0x37, 0x35, 0x30, 0x37, 0x65, 0x33, 0x64, 0x61, 0x39, 0x37, 0x34, 0x32, 0x37, 0x32, 0x33, 0x32, 0x33, 0x36, 0x61, 0x34, 0x33, 0x34, 0x61, 0x64, 0x39, 0x31, 0x65, 0x35, 0x38, 0x34, 0x61, 0x66, 0x63, 0x30, 0x32, 0x37, 0x39, 0x65, 0x38, 0x37, 0x36, 0x37, 0x35, 0x32, 0x31, 0x31, 0x30, 0x34, 0x31, 0x31, 0x64, 0x64, 0x39, 0x65, 0x61, 0x32, 0x32, 0x37, 0x36, 0x61, 0x31, 0x30, 0x32, 0x31, 0x37, 0x61, 0x32, 0x66, 0x39, 0x30, 0x31, 0x66, 0x63, 0x62, 0x36, 0x66, 0x66, 0x66, 0x66, 0x62, 0x39, 0x66, 0x32, 0x31, 0x30, 0x38, 0x64, 0x39, 0x65, 0x30, 0x63, 0x62, 0x33, 0x38, 0x64, 0x36, 0x66, 0x64, 0x65, 0x37, 0x61, 0x34, 0x32, 0x35, 0x31, 0x61, 0x36, 0x37, 0x32, 0x66, 0x38, 0x62, 0x63, 0x64, 0x33, 0x32, 0x36, 0x64, 0x34, 0x34, 0x64, 0x39, 0x36, 0x35, 0x64, 0x38, 0x33, 0x64, 0x32, 0x65, 0x33, 0x62, 0x34, 0x62, 0x62, 0x34, 0x36, 0x32, 0x30, 0x66, 0x35, 0x61, 0x35, 0x39, 0x64, 0x64, 0x30, 0x62, 0x64, 0x34, 0x30, 0x30, 0x34, 0x38, 0x31, 0x31, 0x66, 0x36, 0x62, 0x30, 0x38, 0x34, 0x33, 0x35, 0x36, 0x61, 0x65, 0x38, 0x63, 0x39, 0x38, 0x37, 0x32, 0x39, 0x63, 0x39, 0x30, 0x66, 0x30, 0x61, 0x34, 0x39, 0x34, 0x32, 0x30, 0x63, 0x62, 0x38, 0x31, 0x35, 0x66, 0x61, 0x38, 0x36, 0x62, 0x31, 0x36, 0x65, 0x37, 0x31, 0x38, 0x33, 0x61, 0x32, 0x31, 0x36, 0x32, 0x31, 0x38, 0x64, 0x61, 0x64, 0x39, 0x38, 0x30, 0x63, 0x35, 0x63, 0x61, 0x65, 0x62, 0x63, 0x33, 0x31, 0x65, 0x65, 0x38, 0x33, 0x64, 0x32, 0x39, 0x32, 0x38, 0x33, 0x66, 0x37, 0x32, 0x62, 0x30, 0x65, 0x35, 0x30, 0x65, 0x64, 0x39, 0x66, 0x65, 0x39, 0x35, 0x32, 0x61, 0x33, 0x65, 0x31, 0x66, 0x36, 0x38, 0x31, 0x34, 0x30, 0x61, 0x35, 0x39, 0x36, 0x36, 0x39, 0x39, 0x30, 0x37, 0x64, 0x64, 0x38, 0x65, 0x37, 0x38, 0x62, 0x66, 0x38, 0x35, 0x39, 0x61, 0x39, 0x65, 0x37, 0x65, 0x30, 0x34, 0x61, 0x36, 0x61, 0x30, 0x38, 0x37, 0x63, 0x39, 0x34, 0x38, 0x35, 0x31, 0x37, 0x32, 0x61, 0x36, 0x34, 0x32, 0x38, 0x63, 0x36, 0x37, 0x30, 0x33, 0x38, 0x62, 0x36, 0x33, 0x61, 0x37, 0x66, 0x39, 0x37, 0x39, 0x63, 0x64, 0x36, 0x35, 0x31, 0x31, 0x37, 0x65, 0x32, 0x37, 0x37, 0x35, 0x35, 0x30, 0x30, 0x66, 0x34, 0x64, 0x32, 0x39, 0x30, 0x39, 0x61, 0x34, 0x35, 0x38, 0x36, 0x30, 0x33, 0x30, 0x64, 0x35, 0x66, 0x61, 0x63, 0x30, 0x38, 0x37, 0x62, 0x63, 0x30, 0x32, 0x37, 0x32, 0x63, 0x63, 0x65, 0x64, 0x64, 0x35, 0x30, 0x63, 0x35, 0x64, 0x37, 0x34, 0x65, 0x62, 0x64, 0x32, 0x36, 0x37, 0x61, 0x62, 0x64, 0x30, 0x63, 0x66, 0x38, 0x34, 0x61, 0x31, 0x62, 0x63, 0x37, 0x32, 0x64, 0x33, 0x65, 0x66, 0x30, 0x32, 0x33, 0x62, 0x33, 0x31, 0x30, 0x64, 0x38, 0x34, 0x36, 0x64, 0x37, 0x34, 0x63, 0x38, 0x38, 0x32, 0x32, 0x30, 0x35, 0x34, 0x35, 0x64, 0x38, 0x34, 0x37, 0x32, 0x33, 0x65, 0x35, 0x39, 0x38, 0x63, 0x64, 0x35, 0x35, 0x30, 0x62, 0x32, 0x30, 0x61, 0x39, 0x65, 0x32, 0x36, 0x64, 0x30, 0x32, 0x33, 0x35, 0x33, 0x64, 0x33, 0x35, 0x66, 0x63, 0x66, 0x32, 0x37, 0x36, 0x32, 0x63, 0x63, 0x61, 0x61, 0x37, 0x63, 0x30, 0x38, 0x31, 0x61, 0x37, 0x64, 0x31, 0x37, 0x64, 0x35, 0x66, 0x63, 0x37, 0x32, 0x36, 0x32, 0x61, 0x37, 0x61, 0x32, 0x39, 0x65, 0x37, 0x31, 0x63, 0x64, 0x64, 0x35, 0x34, 0x35, 0x34, 0x35, 0x34, 0x31, 0x31, 0x31, 0x30, 0x62, 0x37, 0x37, 0x32, 0x34, 0x33, 0x34, 0x36, 0x64, 0x61, 0x33, 0x63, 0x31, 0x39, 0x38, 0x35, 0x30, 0x39, 0x61, 0x61, 0x38, 0x38, 0x62, 0x30, 0x33, 0x64, 0x62, 0x31, 0x64, 0x33, 0x30, 0x33, 0x31, 0x63, 0x35, 0x31, 0x61, 0x61, 0x30, 0x32, 0x31, 0x32, 0x37, 0x63, 0x34, 0x36, 0x32, 0x36, 0x39, 0x30, 0x62, 0x35, 0x30, 0x35, 0x37, 0x37, 0x30, 0x30, 0x35, 0x38, 0x63, 0x64, 0x38, 0x62, 0x38, 0x39, 0x64, 0x35, 0x34, 0x61, 0x39, 0x65, 0x34, 0x61, 0x31, 0x31, 0x33, 0x38, 0x37, 0x33, 0x63, 0x31, 0x32, 0x31, 0x63, 0x36, 0x66, 0x63, 0x31, 0x35, 0x65, 0x66, 0x35, 0x61, 0x31, 0x37, 0x33, 0x35, 0x30, 0x32, 0x39, 0x62, 0x66, 0x65, 0x31, 0x32, 0x35, 0x66, 0x62, 0x37, 0x33, 0x36, 0x30, 0x37, 0x32, 0x63, 0x30, 0x37, 0x38, 0x61, 0x62, 0x64, 0x37, 0x31, 0x32, 0x62, 0x36, 0x37, 0x30, 0x30, 0x61, 0x31, 0x36, 0x66, 0x36, 0x36, 0x61, 0x62, 0x61, 0x32, 0x63, 0x62, 0x62, 0x36, 0x37, 0x65, 0x65, 0x37, 0x31, 0x31, 0x32, 0x38, 0x31, 0x63, 0x66, 0x33, 0x35, 0x38, 0x32, 0x31, 0x31, 0x38, 0x30, 0x63, 0x63, 0x33, 0x35, 0x61, 0x32, 0x31, 0x64, 0x37, 0x64, 0x33, 0x66, 0x37, 0x33, 0x37, 0x32, 0x39, 0x32, 0x61, 0x62, 0x62, 0x64, 0x39, 0x33, 0x64, 0x64, 0x38, 0x35, 0x62, 0x64, 0x61, 0x64, 0x34, 0x31, 0x64, 0x64, 0x35, 0x37, 0x34, 0x33, 0x33, 0x30, 0x37, 0x63, 0x35, 0x36, 0x61, 0x32, 0x65, 0x64, 0x37, 0x37, 0x64, 0x32, 0x66, 0x62, 0x66, 0x35, 0x38, 0x61, 0x35, 0x64, 0x63, 0x32, 0x62, 0x66, 0x65, 0x66, 0x37, 0x32, 0x31, 0x35, 0x39, 0x61, 0x31, 0x31, 0x62, 0x34, 0x37, 0x32, 0x36, 0x37, 0x63, 0x63, 0x37, 0x31, 0x34, 0x37, 0x65, 0x63, 0x30, 0x37, 0x39, 0x30, 0x38, 0x30, 0x62, 0x61, 0x39, 0x62, 0x66, 0x30, 0x32, 0x39, 0x31, 0x63, 0x65, 0x39, 0x36, 0x65, 0x37, 0x30, 0x36, 0x62, 0x31, 0x36, 0x32, 0x38, 0x65, 0x35, 0x34, 0x63, 0x65, 0x66, 0x38, 0x37, 0x62, 0x32, 0x62, 0x39, 0x34, 0x34, 0x62, 0x36, 0x37, 0x32, 0x63, 0x32, 0x63, 0x33, 0x65, 0x31, 0x37, 0x32, 0x34, 0x31, 0x38, 0x61, 0x62, 0x32, 0x62, 0x31, 0x35, 0x30, 0x66, 0x38, 0x35, 0x32, 0x39, 0x35, 0x30, 0x31, 0x33, 0x36, 0x35, 0x39, 0x36, 0x65, 0x32, 0x61, 0x37, 0x36, 0x37, 0x35, 0x37, 0x36, 0x66, 0x32, 0x61, 0x33, 0x63, 0x38, 0x32, 0x62, 0x35, 0x66, 0x62, 0x33, 0x66, 0x37, 0x64, 0x61, 0x61, 0x36, 0x30, 0x32, 0x39, 0x66, 0x37, 0x30, 0x63, 0x36, 0x61, 0x31, 0x64, 0x66, 0x37, 0x32, 0x30, 0x33, 0x30, 0x36, 0x37, 0x63, 0x62, 0x38, 0x33, 0x36, 0x38, 0x34, 0x37, 0x63, 0x31, 0x30, 0x32, 0x61, 0x37, 0x36, 0x64, 0x63, 0x66, 0x66, 0x33, 0x64, 0x33, 0x30, 0x66, 0x39, 0x63, 0x39, 0x33, 0x65, 0x64, 0x35, 0x35, 0x63, 0x34, 0x31, 0x32, 0x36, 0x30, 0x30, 0x34, 0x65, 0x36, 0x65, 0x62, 0x30, 0x36, 0x64, 0x38, 0x32, 0x34, 0x30, 0x38, 0x35, 0x32, 0x65, 0x35, 0x63, 0x31, 0x61, 0x33, 0x36, 0x33, 0x32, 0x33, 0x64, 0x32, 0x65, 0x66, 0x64, 0x65, 0x39, 0x30, 0x63, 0x34, 0x34, 0x38, 0x38, 0x66, 0x36, 0x65, 0x64, 0x62, 0x66, 0x65, 0x30, 0x63, 0x31, 0x35, 0x66, 0x39, 0x66, 0x30, 0x65, 0x62, 0x38, 0x36, 0x35, 0x62, 0x63, 0x38, 0x63, 0x34, 0x36, 0x36, 0x62, 0x34, 0x36, 0x38, 0x34, 0x66, 0x65, 0x33, 0x61, 0x64, 0x64, 0x37, 0x63, 0x38, 0x62, 0x33, 0x39, 0x36, 0x66, 0x61, 0x63, 0x39, 0x39, 0x62, 0x35, 0x33, 0x38, 0x39, 0x37, 0x62, 0x64, 0x35, 0x37, 0x35, 0x38, 0x34, 0x39, 0x30, 0x32, 0x64, 0x63, 0x34, 0x36, 0x65, 0x30, 0x66, 0x33, 0x30, 0x36, 0x35, 0x65, 0x35, 0x36, 0x39, 0x35, 0x36, 0x33, 0x37, 0x37, 0x35, 0x64, 0x62, 0x61, 0x35, 0x35, 0x37, 0x32, 0x37, 0x63, 0x61, 0x38, 0x31, 0x33, 0x34, 0x66, 0x34, 0x63, 0x36, 0x39, 0x62, 0x38, 0x37, 0x32, 0x34, 0x39, 0x35, 0x65, 0x32, 0x35, 0x65, 0x36, 0x32, 0x64, 0x35, 0x64, 0x37, 0x39, 0x39, 0x35, 0x66, 0x36, 0x63, 0x39, 0x66, 0x37, 0x61, 0x65, 0x33, 0x30, 0x35, 0x34, 0x39, 0x38, 0x63, 0x36, 0x32, 0x66, 0x31, 0x31, 0x38, 0x33, 0x39, 0x34, 0x36, 0x62, 0x39, 0x66, 0x62, 0x37, 0x34, 0x31, 0x30, 0x65, 0x65, 0x61, 0x39, 0x38, 0x35, 0x38, 0x31, 0x30, 0x62, 0x65, 0x38, 0x30, 0x37, 0x32, 0x39, 0x39, 0x62, 0x35, 0x36, 0x64, 0x39, 0x31, 0x34, 0x63, 0x33, 0x30, 0x63, 0x32, 0x62, 0x32, 0x35, 0x66, 0x33, 0x37, 0x66, 0x61, 0x38, 0x31, 0x39, 0x35, 0x30, 0x62, 0x64, 0x66, 0x66, 0x39, 0x61, 0x32, 0x34, 0x30, 0x66, 0x36, 0x30, 0x30, 0x39, 0x36, 0x36, 0x66, 0x64, 0x61, 0x36, 0x32, 0x33, 0x33, 0x37, 0x65, 0x39, 0x64, 0x32, 0x33, 0x31, 0x32, 0x61, 0x64, 0x39, 0x63, 0x34, 0x66, 0x34, 0x31, 0x65, 0x65, 0x34, 0x62, 0x30, 0x32, 0x37, 0x34, 0x63, 0x30, 0x63, 0x36, 0x31, 0x33, 0x37, 0x33, 0x34, 0x33, 0x33, 0x33, 0x32, 0x61, 0x66, 0x37, 0x31, 0x30, 0x36, 0x32, 0x62, 0x65, 0x37, 0x32, 0x33, 0x38, 0x33, 0x36, 0x33, 0x37, 0x35, 0x34, 0x39, 0x65, 0x35, 0x62, 0x64, 0x34, 0x61, 0x32, 0x35, 0x35, 0x36, 0x66, 0x65, 0x33, 0x30, 0x62, 0x64, 0x37, 0x38, 0x39, 0x37, 0x32, 0x65, 0x31, 0x37, 0x30, 0x31, 0x37, 0x37, 0x64, 0x66, 0x35, 0x38, 0x35, 0x64, 0x36, 0x38, 0x37, 0x31, 0x64, 0x63, 0x63, 0x39, 0x63, 0x35, 0x66, 0x65, 0x39, 0x38, 0x63, 0x39, 0x32, 0x30, 0x33, 0x37, 0x66, 0x61, 0x34, 0x38, 0x62, 0x66, 0x39, 0x30, 0x30, 0x39, 0x35, 0x30, 0x61, 0x63, 0x39, 0x33, 0x34, 0x38, 0x62, 0x66, 0x36, 0x63, 0x33, 0x30, 0x36, 0x35, 0x62, 0x61, 0x38, 0x37, 0x32, 0x37, 0x62, 0x64, 0x64, 0x35, 0x30, 0x62, 0x61, 0x30, 0x36, 0x34, 0x33, 0x39, 0x65, 0x32, 0x61, 0x33, 0x35, 0x62, 0x35, 0x64, 0x62, 0x66, 0x66, 0x30, 0x61, 0x33, 0x33, 0x62, 0x39, 0x37, 0x38, 0x61, 0x61, 0x65, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x39, 0x66, 0x64, 0x66, 0x61, 0x63, 0x30, 0x39, 0x34, 0x39, 0x32, 0x38, 0x66, 0x61, 0x34, 0x37, 0x38, 0x30, 0x31, 0x30, 0x33, 0x36, 0x35, 0x65, 0x66, 0x37, 0x63, 0x65, 0x34, 0x39, 0x64, 0x36, 0x32, 0x39, 0x31, 0x39, 0x35, 0x66, 0x61, 0x61, 0x36, 0x34, 0x65, 0x62, 0x36, 0x34, 0x65, 0x61, 0x38, 0x32, 0x36, 0x38, 0x36, 0x61, 0x34, 0x30, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x31, 0x65, 0x64, 0x36, 0x30, 0x38, 0x31, 0x38, 0x36, 0x34, 0x34, 0x66, 0x32, 0x61, 0x64, 0x39, 0x30, 0x63, 0x66, 0x32, 0x31, 0x65, 0x37, 0x32, 0x61, 0x37, 0x38, 0x32, 0x31, 0x63, 0x63, 0x35, 0x63, 0x39, 0x66, 0x36, 0x32, 0x38, 0x33, 0x63, 0x36, 0x61, 0x37, 0x65, 0x61, 0x37, 0x37, 0x35, 0x31, 0x39, 0x61, 0x39, 0x63, 0x62, 0x62, 0x39, 0x66, 0x36, 0x39, 0x34, 0x63, 0x65, 0x36, 0x32, 0x33, 0x63, 0x63, 0x61, 0x35, 0x35, 0x65, 0x37, 0x64, 0x33, 0x31, 0x66, 0x61, 0x38, 0x37, 0x62, 0x62, 0x64, 0x31, 0x63, 0x31, 0x33, 0x37, 0x32, 0x34, 0x66, 0x61, 0x36, 0x35, 0x36, 0x38, 0x38, 0x31, 0x64, 0x65, 0x61, 0x62, 0x64, 0x62, 0x64, 0x38, 0x66, 0x30, 0x63, 0x65, 0x38, 0x62, 0x64, 0x64, 0x34, 0x37, 0x38, 0x36, 0x64, 0x30, 0x34, 0x38, 0x61, 0x37, 0x31, 0x32, 0x34, 0x39, 0x36, 0x30, 0x30, 0x32, 0x35, 0x36, 0x63, 0x37, 0x64, 0x31, 0x63, 0x30, 0x38, 0x62, 0x39, 0x34, 0x33, 0x61, 0x34, 0x65, 0x61, 0x38, 0x64, 0x37, 0x32, 0x65, 0x37, 0x38, 0x33, 0x31, 0x39, 0x38, 0x32, 0x65, 0x36, 0x64, 0x65, 0x34, 0x38, 0x30, 0x64, 0x37, 0x65, 0x38, 0x34, 0x37, 0x63, 0x35, 0x37, 0x37, 0x64, 0x31, 0x63, 0x61, 0x39, 0x34, 0x63, 0x61, 0x66, 0x35, 0x38, 0x33, 0x63, 0x32, 0x37, 0x64, 0x64, 0x65, 0x62, 0x38, 0x36, 0x32, 0x64, 0x39, 0x61, 0x64, 0x31, 0x36, 0x32, 0x36, 0x35, 0x65, 0x38, 0x35, 0x66, 0x38, 0x32, 0x34, 0x63, 0x35, 0x33, 0x66, 0x36, 0x34, 0x38, 0x38, 0x33, 0x62, 0x35, 0x61, 0x31, 0x38, 0x39, 0x63, 0x37, 0x63, 0x33, 0x61, 0x30, 0x37, 0x66, 0x33, 0x35, 0x66, 0x30, 0x64, 0x36, 0x35, 0x31, 0x31, 0x65, 0x37, 0x33, 0x66, 0x64, 0x38, 0x61, 0x64, 0x63, 0x34, 0x64, 0x36, 0x36, 0x31, 0x63, 0x66, 0x36, 0x31, 0x34, 0x36, 0x34, 0x33, 0x30, 0x38, 0x36, 0x66, 0x33, 0x64, 0x36, 0x37, 0x30, 0x37, 0x32, 0x63, 0x66, 0x33, 0x64, 0x63, 0x34, 0x31, 0x32, 0x30, 0x34, 0x37, 0x32, 0x34, 0x61, 0x35, 0x38, 0x64, 0x30, 0x30, 0x35, 0x35, 0x36, 0x37, 0x39, 0x32, 0x65, 0x33, 0x66, 0x38, 0x63, 0x61, 0x35, 0x30, 0x35, 0x36, 0x33, 0x30, 0x61, 0x63, 0x31, 0x30, 0x30, 0x37, 0x65, 0x62, 0x37, 0x37, 0x64, 0x38, 0x32, 0x37, 0x39, 0x32, 0x30, 0x37, 0x33, 0x30, 0x30, 0x64, 0x37, 0x62, 0x39, 0x37, 0x32, 0x33, 0x30, 0x32, 0x31, 0x36, 0x33, 0x34, 0x66, 0x63, 0x36, 0x31, 0x63, 0x35, 0x31, 0x35, 0x34, 0x65, 0x34, 0x33, 0x62, 0x39, 0x31, 0x35, 0x31, 0x34, 0x64, 0x30, 0x61, 0x32, 0x38, 0x34, 0x39, 0x36, 0x31, 0x64, 0x30, 0x62, 0x65, 0x62, 0x31, 0x37, 0x35, 0x62, 0x32, 0x35, 0x32, 0x37, 0x38, 0x61, 0x61, 0x30, 0x31, 0x37, 0x30, 0x34, 0x34, 0x37, 0x64, 0x38, 0x39, 0x65, 0x61, 0x37, 0x32, 0x36, 0x31, 0x33, 0x36, 0x61, 0x36, 0x33, 0x62, 0x61, 0x62, 0x36, 0x36, 0x61, 0x38, 0x62, 0x36, 0x38, 0x38, 0x36, 0x64, 0x66, 0x38, 0x30, 0x30, 0x64, 0x37, 0x38, 0x39, 0x35, 0x64, 0x62, 0x39, 0x35, 0x34, 0x30, 0x64, 0x35, 0x62, 0x62, 0x36, 0x35, 0x33, 0x31, 0x61, 0x39, 0x38, 0x33, 0x33, 0x65, 0x37, 0x30, 0x39, 0x62, 0x30, 0x64, 0x34, 0x33, 0x38, 0x38, 0x34, 0x33, 0x37, 0x34, 0x37, 0x65, 0x39, 0x37, 0x37, 0x64, 0x35, 0x65, 0x32, 0x63, 0x61, 0x31, 0x39, 0x63, 0x38, 0x33, 0x33, 0x64, 0x33, 0x61, 0x36, 0x63, 0x63, 0x35, 0x36, 0x66, 0x66, 0x66, 0x31, 0x33, 0x33, 0x35, 0x63, 0x34, 0x62, 0x36, 0x37, 0x63, 0x66, 0x36, 0x65, 0x38, 0x61, 0x65, 0x32, 0x36, 0x62, 0x30, 0x30, 0x61, 0x33, 0x36, 0x37, 0x31, 0x64, 0x39, 0x33, 0x39, 0x35, 0x37, 0x66, 0x30, 0x36, 0x37, 0x32, 0x35, 0x34, 0x32, 0x65, 0x62, 0x62, 0x63, 0x62, 0x33, 0x36, 0x62, 0x35, 0x63, 0x33, 0x31, 0x36, 0x63, 0x64, 0x37, 0x36, 0x63, 0x33, 0x32, 0x31, 0x38, 0x63, 0x39, 0x62, 0x39, 0x63, 0x33, 0x66, 0x66, 0x34, 0x36, 0x38, 0x39, 0x65, 0x38, 0x61, 0x37, 0x35, 0x33, 0x39, 0x36, 0x66, 0x38, 0x64, 0x34, 0x30, 0x31, 0x36, 0x38, 0x36, 0x63, 0x32, 0x31, 0x33, 0x32, 0x65, 0x64, 0x30, 0x37, 0x32, 0x66, 0x64, 0x32, 0x39, 0x33, 0x31, 0x30, 0x32, 0x63, 0x37, 0x65, 0x62, 0x39, 0x61, 0x62, 0x63, 0x65, 0x64, 0x33, 0x31, 0x65, 0x33, 0x31, 0x35, 0x64, 0x32, 0x65, 0x34, 0x31, 0x35, 0x63, 0x39, 0x31, 0x66, 0x32, 0x64, 0x31, 0x65, 0x31, 0x31, 0x66, 0x38, 0x37, 0x33, 0x31, 0x30, 0x34, 0x36, 0x64, 0x63, 0x39, 0x63, 0x32, 0x62, 0x35, 0x37, 0x35, 0x35, 0x35, 0x32, 0x34, 0x36, 0x37, 0x32, 0x65, 0x35, 0x63, 0x34, 0x35, 0x34, 0x32, 0x36, 0x38, 0x63, 0x63, 0x65, 0x65, 0x30, 0x35, 0x35, 0x62, 0x34, 0x34, 0x63, 0x63, 0x64, 0x35, 0x39, 0x32, 0x33, 0x35, 0x65, 0x37, 0x37, 0x33, 0x30, 0x61, 0x39, 0x39, 0x32, 0x66, 0x33, 0x63, 0x63, 0x30, 0x63, 0x33, 0x39, 0x33, 0x39, 0x37, 0x63, 0x36, 0x64, 0x62, 0x31, 0x63, 0x34, 0x65, 0x38, 0x37, 0x38, 0x32, 0x62, 0x37, 0x65, 0x37, 0x32, 0x30, 0x66, 0x39, 0x37, 0x63, 0x33, 0x37, 0x38, 0x33, 0x62, 0x39, 0x39, 0x31, 0x63, 0x62, 0x38, 0x31, 0x37, 0x32, 0x34, 0x37, 0x39, 0x63, 0x38, 0x33, 0x33, 0x65, 0x39, 0x38, 0x38, 0x36, 0x62, 0x31, 0x35, 0x35, 0x37, 0x36, 0x66, 0x64, 0x64, 0x37, 0x38, 0x64, 0x31, 0x62, 0x36, 0x34, 0x31, 0x38, 0x38, 0x38, 0x32, 0x62, 0x33, 0x33, 0x33, 0x64, 0x33, 0x63, 0x39, 0x64, 0x39, 0x37, 0x32, 0x39, 0x39, 0x34, 0x38, 0x66, 0x32, 0x31, 0x32, 0x65, 0x37, 0x62, 0x65, 0x39, 0x38, 0x65, 0x37, 0x31, 0x30, 0x62, 0x37, 0x36, 0x35, 0x39, 0x66, 0x63, 0x65, 0x31, 0x30, 0x30, 0x30, 0x63, 0x35, 0x38, 0x30, 0x31, 0x63, 0x30, 0x32, 0x62, 0x38, 0x33, 0x65, 0x32, 0x32, 0x32, 0x32, 0x33, 0x61, 0x36, 0x35, 0x30, 0x35, 0x62, 0x37, 0x62, 0x34, 0x64, 0x66, 0x64, 0x39, 0x62, 0x36, 0x37, 0x32, 0x65, 0x38, 0x63, 0x61, 0x64, 0x62, 0x32, 0x33, 0x64, 0x32, 0x37, 0x34, 0x36, 0x31, 0x30, 0x30, 0x34, 0x35, 0x61, 0x30, 0x30, 0x62, 0x63, 0x38, 0x32, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x36, 0x63, 0x33, 0x33, 0x64, 0x31, 0x31, 0x62, 0x33, 0x61, 0x65, 0x62, 0x34, 0x38, 0x38, 0x30, 0x63, 0x34, 0x38, 0x34, 0x64, 0x64, 0x61, 0x32, 0x35, 0x64, 0x32, 0x65, 0x63, 0x38, 0x37, 0x36, 0x65, 0x30, 0x64, 0x36, 0x37, 0x33, 0x31, 0x31, 0x65, 0x63, 0x37, 0x36, 0x65, 0x38, 0x30, 0x34, 0x39, 0x62, 0x36, 0x36, 0x65, 0x35, 0x36, 0x36, 0x62, 0x66, 0x39, 0x30, 0x61, 0x31, 0x39, 0x32, 0x37, 0x39, 0x33, 0x61, 0x36, 0x66, 0x39, 0x36, 0x39, 0x35, 0x65, 0x34, 0x35, 0x37, 0x39, 0x62, 0x36, 0x33, 0x36, 0x32, 0x37, 0x62, 0x34, 0x65, 0x35, 0x66, 0x62, 0x39, 0x34, 0x64, 0x37, 0x34, 0x65, 0x64, 0x63, 0x61, 0x32, 0x34, 0x34, 0x66, 0x63, 0x37, 0x36, 0x65, 0x38, 0x34, 0x65, 0x61, 0x30, 0x65, 0x39, 0x38, 0x39, 0x38, 0x64, 0x36, 0x64, 0x35, 0x39, 0x36, 0x39, 0x30, 0x65, 0x34, 0x31, 0x30, 0x35, 0x37, 0x37, 0x30, 0x63, 0x38, 0x36, 0x30, 0x37, 0x61, 0x63, 0x39, 0x36, 0x36, 0x34, 0x65, 0x62, 0x34, 0x39, 0x33, 0x66, 0x64, 0x34, 0x37, 0x35, 0x63, 0x31, 0x35, 0x37, 0x37, 0x32, 0x32, 0x35, 0x33, 0x62, 0x61, 0x62, 0x38, 0x65, 0x39, 0x32, 0x30, 0x66, 0x66, 0x61, 0x38, 0x31, 0x37, 0x36, 0x37, 0x31, 0x31, 0x37, 0x39, 0x37, 0x39, 0x39, 0x62, 0x36, 0x36, 0x37, 0x65, 0x63, 0x34, 0x37, 0x31, 0x36, 0x36, 0x32, 0x39, 0x65, 0x66, 0x61, 0x36, 0x37, 0x37, 0x34, 0x32, 0x62, 0x32, 0x32, 0x64, 0x66, 0x39, 0x32, 0x64, 0x63, 0x36, 0x35, 0x32, 0x38, 0x32, 0x64, 0x36, 0x65, 0x64, 0x37, 0x62, 0x32, 0x37, 0x34, 0x33, 0x63, 0x30, 0x34, 0x34, 0x62, 0x37, 0x31, 0x37, 0x64, 0x30, 0x62, 0x30, 0x66, 0x64, 0x63, 0x30, 0x36, 0x32, 0x35, 0x62, 0x33, 0x37, 0x31, 0x39, 0x31, 0x38, 0x38, 0x63, 0x36, 0x32, 0x66, 0x61, 0x39, 0x37, 0x62, 0x65, 0x30, 0x34, 0x37, 0x32, 0x32, 0x34, 0x38, 0x64, 0x31, 0x32, 0x65, 0x30, 0x33, 0x39, 0x64, 0x32, 0x61, 0x34, 0x63, 0x37, 0x32, 0x39, 0x35, 0x38, 0x35, 0x30, 0x39, 0x35, 0x63, 0x34, 0x32, 0x34, 0x32, 0x32, 0x63, 0x39, 0x33, 0x33, 0x66, 0x61, 0x64, 0x38, 0x38, 0x38, 0x39, 0x38, 0x62, 0x38, 0x36, 0x37, 0x33, 0x61, 0x65, 0x66, 0x66, 0x61, 0x64, 0x66, 0x30, 0x36, 0x63, 0x65, 0x33, 0x63, 0x34, 0x34, 0x37, 0x35, 0x35, 0x34, 0x36, 0x33, 0x66, 0x35, 0x38, 0x66, 0x61, 0x31, 0x38, 0x31, 0x34, 0x39, 0x62, 0x37, 0x32, 0x38, 0x35, 0x31, 0x32, 0x62, 0x35, 0x32, 0x64, 0x33, 0x31, 0x37, 0x37, 0x34, 0x34, 0x61, 0x37, 0x61, 0x32, 0x34, 0x32, 0x39, 0x65, 0x36, 0x33, 0x63, 0x61, 0x66, 0x38, 0x36, 0x34, 0x64, 0x31, 0x38, 0x32, 0x30, 0x63, 0x34, 0x66, 0x63, 0x33, 0x37, 0x66, 0x32, 0x38, 0x32, 0x66, 0x30, 0x64, 0x63, 0x39, 0x39, 0x63, 0x38, 0x31, 0x32, 0x38, 0x61, 0x63, 0x36, 0x66, 0x31, 0x66, 0x37, 0x32, 0x39, 0x64, 0x35, 0x32, 0x39, 0x66, 0x66, 0x39, 0x30, 0x32, 0x62, 0x30, 0x31, 0x34, 0x65, 0x61, 0x39, 0x63, 0x38, 0x65, 0x66, 0x39, 0x66, 0x63, 0x66, 0x35, 0x66, 0x31, 0x39, 0x66, 0x37, 0x31, 0x66, 0x62, 0x63, 0x64, 0x38, 0x35, 0x61, 0x35, 0x64, 0x63, 0x38, 0x35, 0x62, 0x64, 0x35, 0x36, 0x63, 0x38, 0x62, 0x37, 0x38, 0x63, 0x30, 0x64, 0x30, 0x36, 0x35, 0x65, 0x38, 0x38, 0x33, 0x38, 0x37, 0x32, 0x35, 0x62, 0x62, 0x61, 0x36, 0x64, 0x39, 0x30, 0x65, 0x36, 0x35, 0x61, 0x64, 0x31, 0x35, 0x31, 0x63, 0x38, 0x37, 0x32, 0x35, 0x37, 0x34, 0x32, 0x65, 0x61, 0x35, 0x61, 0x62, 0x63, 0x63, 0x36, 0x34, 0x35, 0x61, 0x36, 0x36, 0x65, 0x32, 0x39, 0x34, 0x62, 0x32, 0x64, 0x30, 0x33, 0x30, 0x39, 0x65, 0x65, 0x31, 0x30, 0x33, 0x30, 0x34, 0x39, 0x39, 0x39, 0x65, 0x37, 0x35, 0x33, 0x64, 0x37, 0x37, 0x38, 0x34, 0x31, 0x32, 0x37, 0x34, 0x34, 0x31, 0x33, 0x65, 0x38, 0x37, 0x39, 0x35, 0x38, 0x31, 0x37, 0x62, 0x66, 0x64, 0x66, 0x38, 0x31, 0x66, 0x66, 0x61, 0x31, 0x64, 0x35, 0x35, 0x32, 0x31, 0x62, 0x64, 0x65, 0x63, 0x38, 0x39, 0x32, 0x30, 0x32, 0x35, 0x31, 0x30, 0x38, 0x33, 0x35, 0x62, 0x32, 0x64, 0x39, 0x38, 0x63, 0x37, 0x37, 0x61, 0x31, 0x31, 0x33, 0x30, 0x32, 0x33, 0x36, 0x62, 0x35, 0x62, 0x35, 0x65, 0x33, 0x32, 0x39, 0x34, 0x63, 0x62, 0x64, 0x64, 0x34, 0x34, 0x65, 0x34, 0x62, 0x30, 0x35, 0x30, 0x39, 0x31, 0x36, 0x66, 0x61, 0x38, 0x38, 0x35, 0x35, 0x33, 0x37, 0x38, 0x34, 0x33, 0x30, 0x63, 0x37, 0x32, 0x61, 0x62, 0x62, 0x65, 0x66, 0x65, 0x33, 0x32, 0x66, 0x65, 0x32, 0x36, 0x62, 0x39, 0x36, 0x30, 0x34, 0x32, 0x33, 0x65, 0x61, 0x37, 0x32, 0x65, 0x32, 0x39, 0x34, 0x61, 0x33, 0x63, 0x62, 0x37, 0x62, 0x34, 0x39, 0x30, 0x35, 0x36, 0x36, 0x32, 0x39, 0x39, 0x66, 0x66, 0x65, 0x66, 0x34, 0x34, 0x31, 0x31, 0x63, 0x31, 0x31, 0x64, 0x38, 0x33, 0x61, 0x66, 0x39, 0x61, 0x34, 0x39, 0x37, 0x65, 0x33, 0x39, 0x63, 0x36, 0x66, 0x38, 0x63, 0x61, 0x61, 0x66, 0x62, 0x65, 0x61, 0x64, 0x34, 0x62, 0x34, 0x65, 0x32, 0x64, 0x35, 0x37, 0x32, 0x65, 0x65, 0x61, 0x39, 0x64, 0x33, 0x32, 0x32, 0x38, 0x33, 0x35, 0x37, 0x64, 0x33, 0x61, 0x66, 0x35, 0x35, 0x33, 0x38, 0x65, 0x31, 0x34, 0x35, 0x39, 0x66, 0x64, 0x66, 0x33, 0x31, 0x37, 0x33, 0x62, 0x62, 0x36, 0x37, 0x38, 0x62, 0x34, 0x33, 0x37, 0x31, 0x38, 0x64, 0x39, 0x32, 0x33, 0x32, 0x39, 0x30, 0x30, 0x36, 0x31, 0x37, 0x37, 0x62, 0x62, 0x34, 0x64, 0x64, 0x63, 0x32, 0x37, 0x32, 0x37, 0x37, 0x38, 0x36, 0x65, 0x38, 0x35, 0x33, 0x62, 0x37, 0x62, 0x33, 0x35, 0x33, 0x65, 0x36, 0x30, 0x31, 0x34, 0x32, 0x31, 0x37, 0x63, 0x65, 0x65, 0x31, 0x33, 0x36, 0x63, 0x62, 0x66, 0x39, 0x62, 0x66, 0x61, 0x66, 0x35, 0x38, 0x39, 0x61, 0x61, 0x62, 0x37, 0x37, 0x64, 0x64, 0x32, 0x61, 0x32, 0x32, 0x30, 0x36, 0x39, 0x38, 0x66, 0x31, 0x37, 0x63, 0x39, 0x32, 0x39, 0x65, 0x37, 0x32, 0x37, 0x61, 0x32, 0x64, 0x66, 0x64, 0x66, 0x66, 0x31, 0x33, 0x65, 0x33, 0x32, 0x36, 0x32, 0x32, 0x39, 0x62, 0x66, 0x61, 0x37, 0x36, 0x65, 0x30, 0x31, 0x38, 0x66, 0x35, 0x62, 0x36, 0x37, 0x36, 0x39, 0x30, 0x31, 0x38, 0x61, 0x63, 0x31, 0x38, 0x65, 0x39, 0x62, 0x33, 0x65, 0x66, 0x65, 0x34, 0x31, 0x31, 0x30, 0x37, 0x35, 0x30, 0x37, 0x33, 0x35, 0x66, 0x35, 0x61, 0x34, 0x64, 0x32, 0x37, 0x64, 0x34, 0x34, 0x32, 0x63, 0x61, 0x62, 0x35, 0x31, 0x34, 0x61, 0x36, 0x65, 0x30, 0x61, 0x34, 0x65, 0x33, 0x61, 0x36, 0x61, 0x36, 0x63, 0x38, 0x61, 0x62, 0x32, 0x66, 0x37, 0x64, 0x61, 0x64, 0x61, 0x63, 0x35, 0x61, 0x33, 0x37, 0x32, 0x38, 0x62, 0x64, 0x37, 0x35, 0x38, 0x32, 0x61, 0x35, 0x39, 0x32, 0x61, 0x66, 0x38, 0x63, 0x32, 0x31, 0x36, 0x36, 0x63, 0x31, 0x30, 0x36, 0x37, 0x32, 0x37, 0x39, 0x37, 0x66, 0x31, 0x38, 0x64, 0x39, 0x36, 0x39, 0x63, 0x34, 0x65, 0x34, 0x34, 0x30, 0x65, 0x32, 0x64, 0x39, 0x32, 0x34, 0x61, 0x30, 0x65, 0x38, 0x65, 0x64, 0x64, 0x36, 0x34, 0x39, 0x63, 0x39, 0x30, 0x39, 0x34, 0x30, 0x62, 0x37, 0x35, 0x64, 0x61, 0x35, 0x36, 0x66, 0x34, 0x36, 0x30, 0x31, 0x62, 0x32, 0x30, 0x33, 0x38, 0x33, 0x34, 0x34, 0x66, 0x61, 0x63, 0x39, 0x30, 0x30, 0x65, 0x63, 0x32, 0x39, 0x32, 0x36, 0x34, 0x64, 0x66, 0x38, 0x39, 0x34, 0x64, 0x64, 0x30, 0x33, 0x35, 0x38, 0x65, 0x63, 0x39, 0x64, 0x63, 0x62, 0x38, 0x65, 0x33, 0x33, 0x65, 0x30, 0x37, 0x30, 0x32, 0x37, 0x66, 0x62, 0x30, 0x64, 0x63, 0x30, 0x62, 0x30, 0x61, 0x62, 0x34, 0x61, 0x65, 0x64, 0x65, 0x36, 0x35, 0x65, 0x66, 0x32, 0x66, 0x62, 0x37, 0x31, 0x36, 0x38, 0x64, 0x62, 0x34, 0x30, 0x65, 0x33, 0x32, 0x63, 0x62, 0x38, 0x39, 0x36, 0x39, 0x62, 0x30, 0x37, 0x33, 0x64, 0x38, 0x62, 0x34, 0x39, 0x35, 0x65, 0x34, 0x33, 0x30, 0x36, 0x32, 0x66, 0x37, 0x61, 0x38, 0x34, 0x65, 0x36, 0x35, 0x66, 0x36, 0x39, 0x39, 0x63, 0x35, 0x37, 0x37, 0x31, 0x39, 0x61, 0x66, 0x66, 0x34, 0x34, 0x31, 0x34, 0x38, 0x32, 0x35, 0x64, 0x63, 0x65, 0x63, 0x31, 0x65, 0x65, 0x37, 0x65, 0x37, 0x32, 0x38, 0x31, 0x61, 0x31, 0x35, 0x38, 0x66, 0x36, 0x31, 0x65, 0x63, 0x37, 0x36, 0x65, 0x39, 0x30, 0x64, 0x30, 0x63, 0x31, 0x36, 0x30, 0x38, 0x33, 0x65, 0x39, 0x62, 0x35, 0x62, 0x32, 0x34, 0x38, 0x36, 0x30, 0x37, 0x38, 0x62, 0x37, 0x37, 0x34, 0x66, 0x36, 0x64, 0x30, 0x62, 0x35, 0x66, 0x31, 0x64, 0x61, 0x63, 0x32, 0x30, 0x64, 0x64, 0x64, 0x33, 0x66, 0x63, 0x66, 0x31, 0x39, 0x30, 0x64, 0x63, 0x66, 0x33, 0x35, 0x66, 0x65, 0x66, 0x63, 0x30, 0x63, 0x39, 0x62, 0x36, 0x66, 0x30, 0x37, 0x30, 0x35, 0x66, 0x65, 0x32, 0x64, 0x62, 0x61, 0x36, 0x31, 0x33, 0x32, 0x35, 0x36, 0x65, 0x36, 0x35, 0x38, 0x30, 0x39, 0x62, 0x61, 0x61, 0x66, 0x62, 0x37, 0x38, 0x36, 0x63, 0x65, 0x65, 0x34, 0x64, 0x31, 0x35, 0x64, 0x61, 0x38, 0x31, 0x32, 0x62, 0x35, 0x66, 0x34, 0x65, 0x61, 0x30, 0x66, 0x63, 0x66, 0x65, 0x62, 0x34, 0x38, 0x32, 0x39, 0x38, 0x62, 0x35, 0x30, 0x63, 0x31, 0x61, 0x39, 0x61, 0x34, 0x30, 0x66, 0x63, 0x38, 0x65, 0x34, 0x39, 0x35, 0x38, 0x33, 0x63, 0x63, 0x61, 0x36, 0x61, 0x35, 0x37, 0x33, 0x62, 0x61, 0x34, 0x36, 0x31, 0x30, 0x61, 0x65, 0x66, 0x37, 0x37, 0x36, 0x35, 0x66, 0x65, 0x63, 0x35, 0x63, 0x38, 0x35, 0x61, 0x32, 0x32, 0x38, 0x62, 0x61, 0x32, 0x63, 0x34, 0x62, 0x37, 0x65, 0x31, 0x33, 0x31, 0x30, 0x31, 0x36, 0x31, 0x36, 0x33, 0x65, 0x38, 0x31, 0x61, 0x36, 0x36, 0x36, 0x61, 0x35, 0x33, 0x34, 0x37, 0x32, 0x39, 0x63, 0x37, 0x33, 0x31, 0x62, 0x62, 0x39, 0x62, 0x62, 0x62, 0x61, 0x31, 0x64, 0x38, 0x38, 0x34, 0x62, 0x61, 0x31, 0x31, 0x34, 0x66, 0x37, 0x64, 0x35, 0x35, 0x62, 0x37, 0x35, 0x39, 0x61, 0x30, 0x35, 0x62, 0x65, 0x37, 0x32, 0x62, 0x39, 0x66, 0x39, 0x64, 0x39, 0x39, 0x62, 0x66, 0x33, 0x64, 0x36, 0x62, 0x39, 0x38, 0x64, 0x63, 0x37, 0x30, 0x32, 0x62, 0x39, 0x63, 0x61, 0x32, 0x39, 0x33, 0x37, 0x30, 0x32, 0x31, 0x32, 0x61, 0x36, 0x30, 0x66, 0x32, 0x31, 0x38, 0x30, 0x37, 0x30, 0x35, 0x38, 0x33, 0x37, 0x30, 0x39, 0x30, 0x32, 0x64, 0x64, 0x62, 0x63, 0x36, 0x61, 0x37, 0x33, 0x62, 0x39, 0x32, 0x38, 0x34, 0x63, 0x34, 0x66, 0x64, 0x66, 0x33, 0x35, 0x65, 0x38, 0x64, 0x64, 0x31, 0x37, 0x37, 0x33, 0x35, 0x35, 0x30, 0x31, 0x33, 0x65, 0x35, 0x34, 0x64, 0x32, 0x30, 0x37, 0x31, 0x36, 0x39, 0x34, 0x61, 0x38, 0x38, 0x61, 0x62, 0x64, 0x31, 0x61, 0x65, 0x37, 0x39, 0x65, 0x62, 0x38, 0x38, 0x36, 0x39, 0x38, 0x30, 0x61, 0x37, 0x62, 0x62, 0x30, 0x31, 0x39, 0x33, 0x65, 0x37, 0x65, 0x34, 0x33, 0x33, 0x35, 0x32, 0x38, 0x36, 0x62, 0x32, 0x34, 0x38, 0x66, 0x32, 0x62, 0x66, 0x32, 0x34, 0x37, 0x61, 0x64, 0x31, 0x62, 0x33, 0x31, 0x30, 0x65, 0x37, 0x62, 0x30, 0x35, 0x65, 0x39, 0x66, 0x36, 0x62, 0x66, 0x61, 0x63, 0x61, 0x66, 0x35, 0x62, 0x39, 0x32, 0x65, 0x33, 0x37, 0x65, 0x35, 0x36, 0x64, 0x36, 0x31, 0x33, 0x62, 0x64, 0x34, 0x35, 0x30, 0x63, 0x30, 0x36, 0x35, 0x63, 0x37, 0x32, 0x34, 0x61, 0x36, 0x66, 0x64, 0x37, 0x61, 0x61, 0x63, 0x61, 0x66, 0x37, 0x35, 0x36, 0x31, 0x65, 0x38, 0x30, 0x62, 0x61, 0x31, 0x30, 0x30, 0x63, 0x36, 0x66, 0x34, 0x30, 0x61, 0x31, 0x33, 0x30, 0x39, 0x36, 0x66, 0x62, 0x62, 0x34, 0x37, 0x30, 0x35, 0x33, 0x63, 0x62, 0x64, 0x31, 0x37, 0x38, 0x37, 0x34, 0x39, 0x37, 0x64, 0x66, 0x32, 0x31, 0x33, 0x61, 0x66, 0x38, 0x36, 0x38, 0x63, 0x66, 0x37, 0x32, 0x30, 0x32, 0x34, 0x34, 0x63, 0x61, 0x33, 0x61, 0x37, 0x33, 0x63, 0x34, 0x64, 0x39, 0x65, 0x37, 0x66, 0x39, 0x30, 0x31, 0x62, 0x37, 0x37, 0x37, 0x31, 0x33, 0x66, 0x62, 0x63, 0x39, 0x38, 0x33, 0x34, 0x63, 0x63, 0x38, 0x64, 0x65, 0x65, 0x30, 0x31, 0x33, 0x32, 0x32, 0x63, 0x35, 0x36, 0x66, 0x33, 0x61, 0x32, 0x33, 0x37, 0x61, 0x62, 0x37, 0x34, 0x64, 0x34, 0x33, 0x31, 0x64, 0x37, 0x32, 0x65, 0x62, 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x36, 0x63, 0x38, 0x61, 0x65, 0x35, 0x37, 0x35, 0x35, 0x32, 0x31, 0x34, 0x33, 0x32, 0x63, 0x61, 0x39, 0x38, 0x33, 0x39, 0x31, 0x39, 0x66, 0x61, 0x33, 0x35, 0x34, 0x33, 0x62, 0x30, 0x32, 0x39, 0x62, 0x66, 0x38, 0x30, 0x34, 0x32, 0x66, 0x62, 0x35, 0x37, 0x35, 0x34, 0x30, 0x36, 0x62, 0x31, 0x63, 0x38, 0x34, 0x61, 0x30, 0x37, 0x32, 0x30, 0x66, 0x64, 0x65, 0x64, 0x32, 0x30, 0x63, 0x31, 0x38, 0x35, 0x39, 0x64, 0x30, 0x31, 0x34, 0x62, 0x32, 0x37, 0x66, 0x39, 0x31, 0x33, 0x30, 0x35, 0x61, 0x38, 0x30, 0x35, 0x32, 0x63, 0x63, 0x37, 0x33, 0x34, 0x33, 0x65, 0x34, 0x37, 0x36, 0x36, 0x65, 0x65, 0x30, 0x32, 0x37, 0x61, 0x66, 0x36, 0x61, 0x36, 0x30, 0x61, 0x32, 0x34, 0x66, 0x34, 0x62, 0x32, 0x30, 0x33, 0x36, 0x33, 0x36, 0x62, 0x62, 0x36, 0x66, 0x37, 0x30, 0x63, 0x34, 0x34, 0x30, 0x62, 0x31, 0x61, 0x66, 0x30, 0x31, 0x35, 0x33, 0x36, 0x33, 0x36, 0x66, 0x66, 0x32, 0x36, 0x30, 0x38, 0x64, 0x31, 0x65, 0x31, 0x33, 0x31, 0x65, 0x32, 0x39, 0x64, 0x34, 0x35, 0x61, 0x65, 0x64, 0x30, 0x34, 0x62, 0x38, 0x35, 0x34, 0x37, 0x37, 0x34, 0x39, 0x64, 0x36, 0x32, 0x38, 0x62, 0x36, 0x65, 0x33, 0x32, 0x37, 0x30, 0x65, 0x63, 0x62, 0x37, 0x35, 0x61, 0x37, 0x61, 0x63, 0x62, 0x33, 0x36, 0x62, 0x31, 0x31, 0x39, 0x61, 0x64, 0x30, 0x37, 0x38, 0x32, 0x31, 0x65, 0x37, 0x66, 0x62, 0x35, 0x36, 0x35, 0x63, 0x30, 0x63, 0x65, 0x66, 0x37, 0x39, 0x33, 0x33, 0x62, 0x36, 0x31, 0x39, 0x65, 0x64, 0x30, 0x34, 0x62, 0x61, 0x34, 0x36, 0x65, 0x62, 0x34, 0x36, 0x33, 0x34, 0x63, 0x32, 0x34, 0x64, 0x61, 0x32, 0x37, 0x32, 0x64, 0x63, 0x35, 0x39, 0x36, 0x31, 0x37, 0x65, 0x33, 0x65, 0x33, 0x37, 0x32, 0x33, 0x66, 0x37, 0x34, 0x31, 0x39, 0x34, 0x35, 0x37, 0x31, 0x39, 0x37, 0x39, 0x35, 0x33, 0x31, 0x31, 0x37, 0x30, 0x37, 0x37, 0x66, 0x61, 0x36, 0x63, 0x39, 0x39, 0x65, 0x66, 0x33, 0x33, 0x34, 0x65, 0x31, 0x64, 0x33, 0x33, 0x32, 0x35, 0x66, 0x38, 0x37, 0x66, 0x35, 0x35, 0x39, 0x35, 0x32, 0x61, 0x37, 0x32, 0x66, 0x31, 0x31, 0x36, 0x65, 0x63, 0x36, 0x34, 0x31, 0x61, 0x37, 0x31, 0x39, 0x63, 0x35, 0x37, 0x32, 0x64, 0x61, 0x61, 0x32, 0x62, 0x34, 0x66, 0x38, 0x32, 0x63, 0x36, 0x63, 0x65, 0x36, 0x39, 0x38, 0x39, 0x31, 0x37, 0x30, 0x63, 0x62, 0x61, 0x62, 0x63, 0x39, 0x66, 0x66, 0x38, 0x36, 0x35, 0x32, 0x39, 0x35, 0x64, 0x35, 0x33, 0x32, 0x64, 0x64, 0x32, 0x61, 0x63, 0x38, 0x65, 0x37, 0x31, 0x39, 0x39, 0x39, 0x32, 0x64, 0x66, 0x65, 0x34, 0x35, 0x39, 0x37, 0x32, 0x33, 0x33, 0x37, 0x33, 0x36, 0x30, 0x62, 0x35, 0x31, 0x37, 0x38, 0x36, 0x37, 0x33, 0x35, 0x34, 0x32, 0x30, 0x32, 0x61, 0x61, 0x62, 0x32, 0x35, 0x34, 0x65, 0x65, 0x35, 0x33, 0x34, 0x61, 0x35, 0x36, 0x31, 0x35, 0x65, 0x39, 0x38, 0x39, 0x38, 0x31, 0x37, 0x32, 0x63, 0x39, 0x34, 0x33, 0x34, 0x39, 0x31, 0x37, 0x32, 0x63, 0x32, 0x39, 0x31, 0x34, 0x32, 0x66, 0x36, 0x31, 0x64, 0x39, 0x33, 0x33, 0x31, 0x65, 0x66, 0x64, 0x30, 0x31, 0x63, 0x36, 0x35, 0x39, 0x32, 0x66, 0x31, 0x64, 0x33, 0x38, 0x35, 0x33, 0x34, 0x37, 0x39, 0x34, 0x66, 0x66, 0x30, 0x33, 0x64, 0x64, 0x61, 0x35, 0x66, 0x64, 0x34, 0x32, 0x62, 0x63, 0x34, 0x39, 0x61, 0x33, 0x61, 0x65, 0x33, 0x38, 0x34, 0x31, 0x36, 0x64, 0x65, 0x37, 0x32, 0x38, 0x39, 0x37, 0x31, 0x31, 0x36, 0x61, 0x38, 0x63, 0x39, 0x39, 0x31, 0x61, 0x62, 0x65, 0x35, 0x33, 0x31, 0x61, 0x33, 0x34, 0x38, 0x39, 0x61, 0x61, 0x66, 0x64, 0x39, 0x39, 0x30, 0x63, 0x30, 0x37, 0x32, 0x34, 0x39, 0x35, 0x30, 0x39, 0x36, 0x36, 0x64, 0x36, 0x39, 0x66, 0x39, 0x34, 0x38, 0x61, 0x39, 0x63, 0x65, 0x65, 0x33, 0x63, 0x35, 0x39, 0x37, 0x37, 0x32, 0x61, 0x38, 0x37, 0x32, 0x32, 0x32, 0x39, 0x32, 0x35, 0x32, 0x62, 0x66, 0x64, 0x36, 0x30, 0x31, 0x31, 0x37, 0x62, 0x34, 0x64, 0x37, 0x64, 0x31, 0x31, 0x64, 0x36, 0x37, 0x30, 0x64, 0x62, 0x35, 0x37, 0x61, 0x63, 0x39, 0x61, 0x35, 0x32, 0x61, 0x31, 0x36, 0x63, 0x32, 0x35, 0x34, 0x33, 0x64, 0x33, 0x63, 0x36, 0x64, 0x34, 0x63, 0x64, 0x33, 0x34, 0x31, 0x65, 0x33, 0x30, 0x39, 0x64, 0x63, 0x62, 0x33, 0x37, 0x32, 0x30, 0x34, 0x63, 0x63, 0x32, 0x38, 0x65, 0x34, 0x65, 0x32, 0x66, 0x34, 0x66, 0x32, 0x30, 0x37, 0x31, 0x64, 0x39, 0x63, 0x31, 0x61, 0x36, 0x61, 0x66, 0x37, 0x34, 0x64, 0x38, 0x38, 0x36, 0x63, 0x38, 0x63, 0x37, 0x39, 0x37, 0x37, 0x39, 0x35, 0x61, 0x64, 0x38, 0x63, 0x64, 0x31, 0x62, 0x33, 0x35, 0x35, 0x61, 0x30, 0x33, 0x33, 0x36, 0x65, 0x61, 0x34, 0x32, 0x38, 0x32, 0x62, 0x37, 0x32, 0x64, 0x61, 0x31, 0x66, 0x37, 0x35, 0x32, 0x64, 0x30, 0x62, 0x63, 0x65, 0x32, 0x36, 0x33, 0x31, 0x64, 0x62, 0x62, 0x30, 0x62, 0x39, 0x64, 0x61, 0x63, 0x66, 0x64, 0x66, 0x63, 0x65, 0x36, 0x62, 0x66, 0x31, 0x30, 0x62, 0x34, 0x38, 0x34, 0x34, 0x63, 0x39, 0x36, 0x35, 0x65, 0x37, 0x39, 0x33, 0x30, 0x61, 0x63, 0x39, 0x31, 0x34, 0x38, 0x35, 0x65, 0x38, 0x31, 0x30, 0x61, 0x63, 0x37, 0x32, 0x66, 0x65, 0x64, 0x66, 0x34, 0x65, 0x38, 0x33, 0x37, 0x63, 0x35, 0x64, 0x62, 0x63, 0x36, 0x64, 0x63, 0x38, 0x65, 0x36, 0x31, 0x66, 0x64, 0x63, 0x30, 0x32, 0x34, 0x30, 0x35, 0x61, 0x64, 0x35, 0x30, 0x30, 0x63, 0x33, 0x38, 0x64, 0x65, 0x30, 0x61, 0x33, 0x62, 0x30, 0x64, 0x39, 0x39, 0x64, 0x39, 0x62, 0x39, 0x30, 0x34, 0x33, 0x61, 0x64, 0x64, 0x64, 0x35, 0x39, 0x61, 0x37, 0x37, 0x32, 0x64, 0x34, 0x63, 0x38, 0x39, 0x65, 0x66, 0x34, 0x38, 0x66, 0x61, 0x62, 0x38, 0x62, 0x66, 0x38, 0x65, 0x34, 0x37, 0x66, 0x30, 0x31, 0x30, 0x32, 0x64, 0x30, 0x61, 0x63, 0x38, 0x64, 0x65, 0x32, 0x65, 0x37, 0x63, 0x66, 0x65, 0x65, 0x33, 0x37, 0x32, 0x34, 0x62, 0x32, 0x30, 0x39, 0x35, 0x39, 0x35, 0x38, 0x66, 0x64, 0x64, 0x35, 0x37, 0x30, 0x31, 0x30, 0x37, 0x61, 0x31, 0x38, 0x37, 0x32, 0x39, 0x61, 0x38, 0x64, 0x35, 0x62, 0x64, 0x32, 0x37, 0x35, 0x39, 0x32, 0x64, 0x63, 0x36, 0x39, 0x32, 0x39, 0x32, 0x65, 0x37, 0x33, 0x39, 0x30, 0x35, 0x35, 0x31, 0x34, 0x62, 0x32, 0x64, 0x32, 0x32, 0x32, 0x34, 0x33, 0x31, 0x31, 0x35, 0x39, 0x63, 0x32, 0x37, 0x63, 0x66, 0x30, 0x64, 0x30, 0x31, 0x64, 0x35, 0x63, 0x33, 0x38, 0x63, 0x31, 0x30, 0x36, 0x34, 0x61, 0x33, 0x62, 0x37, 0x32, 0x36, 0x37, 0x61, 0x31, 0x31, 0x63, 0x64, 0x61, 0x66, 0x31, 0x32, 0x66, 0x32, 0x63, 0x33, 0x35, 0x35, 0x64, 0x39, 0x63, 0x37, 0x62, 0x64, 0x64, 0x61, 0x31, 0x31, 0x65, 0x31, 0x39, 0x39, 0x37, 0x38, 0x61, 0x64, 0x35, 0x32, 0x64, 0x30, 0x37, 0x32, 0x32, 0x63, 0x61, 0x34, 0x34, 0x61, 0x39, 0x35, 0x66, 0x37, 0x32, 0x63, 0x62, 0x32, 0x37, 0x64, 0x35, 0x65, 0x34, 0x32, 0x61, 0x37, 0x32, 0x38, 0x63, 0x31, 0x64, 0x64, 0x61, 0x34, 0x39, 0x31, 0x33, 0x35, 0x30, 0x38, 0x36, 0x66, 0x35, 0x31, 0x31, 0x35, 0x36, 0x35, 0x37, 0x31, 0x64, 0x32, 0x38, 0x66, 0x62, 0x61, 0x35, 0x65, 0x33, 0x63, 0x35, 0x65, 0x37, 0x30, 0x39, 0x36, 0x64, 0x62, 0x34, 0x64, 0x66, 0x31, 0x30, 0x37, 0x64, 0x31, 0x64, 0x36, 0x37, 0x37, 0x33, 0x61, 0x38, 0x39, 0x61, 0x35, 0x61, 0x61, 0x33, 0x37, 0x32, 0x37, 0x38, 0x62, 0x66, 0x63, 0x31, 0x63, 0x33, 0x37, 0x34, 0x30, 0x61, 0x31, 0x30, 0x61, 0x31, 0x62, 0x66, 0x31, 0x61, 0x36, 0x63, 0x38, 0x34, 0x64, 0x66, 0x37, 0x34, 0x34, 0x35, 0x62, 0x37, 0x63, 0x36, 0x35, 0x65, 0x39, 0x33, 0x62, 0x34, 0x31, 0x61, 0x31, 0x35, 0x39, 0x32, 0x66, 0x64, 0x30, 0x35, 0x61, 0x62, 0x65, 0x62, 0x38, 0x33, 0x32, 0x61, 0x62, 0x63, 0x39, 0x34, 0x37, 0x32, 0x63, 0x36, 0x66, 0x38, 0x61, 0x34, 0x37, 0x38, 0x65, 0x32, 0x63, 0x36, 0x36, 0x63, 0x66, 0x30, 0x65, 0x64, 0x32, 0x39, 0x31, 0x38, 0x30, 0x37, 0x66, 0x30, 0x65, 0x38, 0x33, 0x62, 0x66, 0x65, 0x31, 0x62, 0x32, 0x64, 0x61, 0x66, 0x66, 0x35, 0x34, 0x31, 0x65, 0x63, 0x62, 0x65, 0x63, 0x62, 0x38, 0x66, 0x39, 0x39, 0x32, 0x36, 0x38, 0x39, 0x62, 0x61, 0x63, 0x36, 0x33, 0x32, 0x37, 0x32, 0x37, 0x38, 0x62, 0x31, 0x35, 0x38, 0x64, 0x65, 0x32, 0x35, 0x33, 0x32, 0x34, 0x32, 0x30, 0x37, 0x65, 0x34, 0x37, 0x37, 0x35, 0x62, 0x61, 0x37, 0x61, 0x34, 0x61, 0x65, 0x36, 0x34, 0x61, 0x38, 0x37, 0x31, 0x64, 0x62, 0x31, 0x63, 0x34, 0x36, 0x61, 0x38, 0x38, 0x37, 0x66, 0x37, 0x39, 0x66, 0x65, 0x34, 0x62, 0x36, 0x39, 0x36, 0x33, 0x34, 0x32, 0x39, 0x32, 0x63, 0x31, 0x35, 0x37, 0x32, 0x38, 0x62, 0x30, 0x66, 0x37, 0x35, 0x62, 0x62, 0x61, 0x63, 0x33, 0x33, 0x64, 0x65, 0x37, 0x35, 0x31, 0x65, 0x65, 0x32, 0x35, 0x63, 0x65, 0x37, 0x64, 0x34, 0x38, 0x30, 0x30, 0x63, 0x30, 0x35, 0x31, 0x36, 0x62, 0x63, 0x65, 0x33, 0x37, 0x34, 0x61, 0x61, 0x34, 0x65, 0x65, 0x63, 0x33, 0x64, 0x62, 0x38, 0x39, 0x65, 0x30, 0x65, 0x31, 0x63, 0x38, 0x64, 0x65, 0x64, 0x64, 0x30, 0x32, 0x61, 0x34, 0x31, 0x34, 0x66, 0x35, 0x35, 0x34, 0x30, 0x61, 0x36, 0x66, 0x66, 0x39, 0x34, 0x39, 0x36, 0x39, 0x34, 0x62, 0x32, 0x36, 0x62, 0x39, 0x35, 0x65, 0x34, 0x38, 0x33, 0x66, 0x66, 0x31, 0x37, 0x64, 0x63, 0x33, 0x62, 0x39, 0x62, 0x36, 0x36, 0x37, 0x32, 0x33, 0x64, 0x31, 0x37, 0x32, 0x31, 0x36, 0x37, 0x35, 0x63, 0x62, 0x37, 0x32, 0x65, 0x35, 0x61, 0x31, 0x65, 0x64, 0x39, 0x37, 0x32, 0x37, 0x39, 0x37, 0x30, 0x30, 0x36, 0x39, 0x34, 0x34, 0x65, 0x65, 0x32, 0x37, 0x66, 0x33, 0x62, 0x39, 0x37, 0x65, 0x37, 0x66, 0x34, 0x66, 0x35, 0x36, 0x37, 0x34, 0x66, 0x66, 0x61, 0x66, 0x37, 0x39, 0x36, 0x34, 0x35, 0x65, 0x32, 0x61, 0x65, 0x66, 0x34, 0x36, 0x31, 0x61, 0x37, 0x30, 0x62, 0x36, 0x64, 0x63, 0x63, 0x30, 0x65, 0x33, 0x34, 0x65, 0x65, 0x63, 0x66, 0x36, 0x34, 0x37, 0x32, 0x36, 0x62, 0x38, 0x32, 0x65, 0x34, 0x32, 0x35, 0x30, 0x64, 0x61, 0x32, 0x64, 0x61, 0x36, 0x65, 0x32, 0x64, 0x36, 0x38, 0x36, 0x66, 0x39, 0x62, 0x61, 0x36, 0x38, 0x37, 0x62, 0x66, 0x32, 0x63, 0x31, 0x63, 0x62, 0x34, 0x31, 0x34, 0x66, 0x35, 0x63, 0x38, 0x62, 0x39, 0x33, 0x33, 0x33, 0x64, 0x31, 0x61, 0x34, 0x34, 0x38, 0x37, 0x34, 0x34, 0x31, 0x63, 0x38, 0x38, 0x66, 0x61, 0x33, 0x65, 0x30, 0x62, 0x64, 0x30, 0x65, 0x35, 0x63, 0x62, 0x30, 0x65, 0x31, 0x39, 0x39, 0x64, 0x30, 0x66, 0x62, 0x39, 0x61, 0x39, 0x33, 0x64, 0x62, 0x32, 0x38, 0x30, 0x33, 0x36, 0x31, 0x30, 0x66, 0x33, 0x35, 0x64, 0x39, 0x65, 0x32, 0x37, 0x65, 0x36, 0x61, 0x39, 0x32, 0x65, 0x39, 0x37, 0x34, 0x37, 0x36, 0x38, 0x37, 0x64, 0x62, 0x35, 0x33, 0x39, 0x31, 0x33, 0x33, 0x34, 0x33, 0x30, 0x37, 0x32, 0x32, 0x65, 0x38, 0x39, 0x61, 0x62, 0x31, 0x31, 0x64, 0x61, 0x39, 0x63, 0x36, 0x30, 0x65, 0x38, 0x63, 0x31, 0x64, 0x63, 0x63, 0x61, 0x32, 0x32, 0x31, 0x66, 0x61, 0x32, 0x37, 0x38, 0x36, 0x39, 0x64, 0x30, 0x33, 0x38, 0x33, 0x64, 0x66, 0x65, 0x62, 0x61, 0x61, 0x34, 0x38, 0x34, 0x64, 0x39, 0x39, 0x39, 0x34, 0x61, 0x63, 0x66, 0x37, 0x39, 0x35, 0x38, 0x35, 0x37, 0x66, 0x65, 0x34, 0x65, 0x38, 0x61, 0x35, 0x30, 0x64, 0x66, 0x62, 0x30, 0x62, 0x34, 0x63, 0x33, 0x39, 0x33, 0x62, 0x63, 0x61, 0x38, 0x35, 0x64, 0x30, 0x64, 0x37, 0x39, 0x32, 0x64, 0x31, 0x64, 0x37, 0x63, 0x38, 0x61, 0x37, 0x37, 0x34, 0x64, 0x30, 0x61, 0x66, 0x38, 0x39, 0x63, 0x63, 0x36, 0x39, 0x33, 0x31, 0x35, 0x33, 0x34, 0x38, 0x66, 0x64, 0x30, 0x61, 0x32, 0x66, 0x33, 0x64, 0x63, 0x30, 0x65, 0x30, 0x32, 0x32, 0x33, 0x34, 0x33, 0x38, 0x36, 0x38, 0x38, 0x65, 0x30, 0x63, 0x33, 0x66, 0x37, 0x64, 0x37, 0x32, 0x34, 0x37, 0x35, 0x31, 0x31, 0x37, 0x33, 0x61, 0x66, 0x35, 0x39, 0x31, 0x32, 0x63, 0x34, 0x30, 0x32, 0x61, 0x63, 0x37, 0x37, 0x63, 0x61, 0x38, 0x31, 0x66, 0x61, 0x61, 0x65, 0x61, 0x62, 0x36, 0x66, 0x34, 0x34, 0x31, 0x66, 0x31, 0x37, 0x61, 0x33, 0x63, 0x37, 0x37, 0x62, 0x37, 0x32, 0x66, 0x31, 0x61, 0x34, 0x36, 0x66, 0x66, 0x39, 0x35, 0x31, 0x39, 0x32, 0x65, 0x62, 0x62, 0x36, 0x62, 0x62, 0x30, 0x30, 0x65, 0x33, 0x33, 0x35, 0x30, 0x39, 0x62, 0x32, 0x30, 0x31, 0x61, 0x38, 0x32, 0x37, 0x62, 0x36, 0x38, 0x33, 0x34, 0x32, 0x31, 0x31, 0x61, 0x62, 0x61, 0x32, 0x37, 0x65, 0x30, 0x38, 0x34, 0x32, 0x35, 0x66, 0x37, 0x32, 0x63, 0x33, 0x66, 0x64, 0x64, 0x65, 0x37, 0x32, 0x34, 0x62, 0x63, 0x32, 0x36, 0x38, 0x66, 0x62, 0x65, 0x30, 0x31, 0x39, 0x63, 0x34, 0x30, 0x34, 0x63, 0x36, 0x36, 0x31, 0x31, 0x35, 0x36, 0x39, 0x66, 0x62, 0x65, 0x32, 0x30, 0x33, 0x63, 0x31, 0x31, 0x30, 0x65, 0x39, 0x38, 0x63, 0x39, 0x66, 0x36, 0x32, 0x33, 0x64, 0x36, 0x39, 0x35, 0x31, 0x32, 0x37, 0x32, 0x64, 0x61, 0x64, 0x64, 0x64, 0x66, 0x65, 0x34, 0x33, 0x35, 0x37, 0x37, 0x32, 0x64, 0x30, 0x35, 0x37, 0x34, 0x61, 0x66, 0x35, 0x61, 0x31, 0x61, 0x65, 0x30, 0x65, 0x31, 0x64, 0x61, 0x35, 0x64, 0x62, 0x37, 0x33, 0x63, 0x34, 0x38, 0x31, 0x36, 0x61, 0x32, 0x38, 0x61, 0x63, 0x36, 0x64, 0x30, 0x63, 0x32, 0x33, 0x33, 0x64, 0x39, 0x39, 0x66, 0x34, 0x36, 0x30, 0x35, 0x33, 0x64, 0x39, 0x37, 0x65, 0x32, 0x61, 0x34, 0x62, 0x31, 0x63, 0x33, 0x65, 0x37, 0x36, 0x37, 0x32, 0x39, 0x66, 0x37, 0x36, 0x39, 0x34, 0x65, 0x37, 0x66, 0x63, 0x65, 0x39, 0x32, 0x33, 0x34, 0x35, 0x33, 0x61, 0x34, 0x64, 0x38, 0x62, 0x66, 0x63, 0x62, 0x61, 0x32, 0x63, 0x36, 0x30, 0x64, 0x31, 0x37, 0x39, 0x63, 0x35, 0x62, 0x38, 0x64, 0x65, 0x30, 0x31, 0x65, 0x61, 0x34, 0x63, 0x65, 0x31, 0x66, 0x31, 0x33, 0x36, 0x37, 0x34, 0x34, 0x62, 0x61, 0x30, 0x39, 0x36, 0x62, 0x35, 0x37, 0x32, 0x36, 0x31, 0x30, 0x36, 0x36, 0x66, 0x36, 0x64, 0x62, 0x33, 0x63, 0x61, 0x34, 0x31, 0x66, 0x62, 0x32, 0x34, 0x38, 0x38, 0x32, 0x36, 0x62, 0x64, 0x39, 0x33, 0x30, 0x32, 0x31, 0x30, 0x65, 0x38, 0x61, 0x34, 0x61, 0x31, 0x63, 0x61, 0x62, 0x36, 0x35, 0x36, 0x63, 0x39, 0x66, 0x37, 0x31, 0x65, 0x38, 0x32, 0x66, 0x65, 0x62, 0x34, 0x34, 0x31, 0x37, 0x65, 0x30, 0x34, 0x34, 0x63, 0x37, 0x32, 0x37, 0x30, 0x36, 0x36, 0x64, 0x61, 0x64, 0x32, 0x38, 0x66, 0x34, 0x36, 0x63, 0x32, 0x62, 0x38, 0x32, 0x30, 0x31, 0x64, 0x37, 0x62, 0x32, 0x32, 0x37, 0x61, 0x61, 0x33, 0x34, 0x64, 0x36, 0x36, 0x34, 0x39, 0x33, 0x38, 0x31, 0x65, 0x61, 0x61, 0x34, 0x37, 0x36, 0x39, 0x66, 0x38, 0x66, 0x30, 0x30, 0x35, 0x39, 0x66, 0x35, 0x37, 0x33, 0x39, 0x39, 0x31, 0x33, 0x65, 0x63, 0x62, 0x35, 0x62, 0x39, 0x32, 0x38, 0x34, 0x31, 0x65, 0x65, 0x61, 0x34, 0x37, 0x36, 0x39, 0x37, 0x65, 0x31, 0x66, 0x34, 0x63, 0x33, 0x39, 0x34, 0x33, 0x64, 0x39, 0x66, 0x61, 0x64, 0x30, 0x34, 0x32, 0x37, 0x66, 0x38, 0x31, 0x64, 0x63, 0x35, 0x37, 0x36, 0x63, 0x66, 0x39, 0x31, 0x38, 0x39, 0x35, 0x39, 0x65, 0x33, 0x31, 0x65, 0x63, 0x30, 0x32, 0x37, 0x64, 0x31, 0x65, 0x61, 0x63, 0x34, 0x62, 0x37, 0x32, 0x37, 0x34, 0x65, 0x66, 0x66, 0x38, 0x31, 0x39, 0x61, 0x31, 0x38, 0x36, 0x65, 0x33, 0x39, 0x62, 0x64, 0x65, 0x39, 0x63, 0x31, 0x34, 0x38, 0x39, 0x66, 0x62, 0x30, 0x33, 0x36, 0x66, 0x66, 0x63, 0x66, 0x36, 0x61, 0x34, 0x32, 0x39, 0x63, 0x64, 0x66, 0x66, 0x30, 0x66, 0x35, 0x37, 0x34, 0x65, 0x62, 0x64, 0x32, 0x38, 0x30, 0x38, 0x64, 0x63, 0x38, 0x38, 0x33, 0x39, 0x65, 0x35, 0x37, 0x32, 0x36, 0x65, 0x38, 0x31, 0x63, 0x61, 0x32, 0x66, 0x38, 0x39, 0x32, 0x32, 0x66, 0x35, 0x64, 0x35, 0x39, 0x36, 0x64, 0x64, 0x39, 0x31, 0x62, 0x37, 0x66, 0x32, 0x31, 0x39, 0x62, 0x39, 0x66, 0x35, 0x64, 0x34, 0x66, 0x64, 0x31, 0x34, 0x37, 0x30, 0x30, 0x32, 0x37, 0x33, 0x35, 0x62, 0x64, 0x65, 0x30, 0x39, 0x33, 0x35, 0x35, 0x35, 0x31, 0x63, 0x39, 0x33, 0x34, 0x66, 0x30, 0x33, 0x37, 0x32, 0x36, 0x63, 0x33, 0x31, 0x62, 0x31, 0x32, 0x30, 0x36, 0x33, 0x64, 0x35, 0x31, 0x36, 0x39, 0x61, 0x36, 0x34, 0x36, 0x37, 0x37, 0x33, 0x30, 0x37, 0x39, 0x32, 0x38, 0x35, 0x33, 0x36, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x62, 0x66, 0x63, 0x30, 0x34, 0x32, 0x65, 0x39, 0x31, 0x38, 0x30, 0x63, 0x36, 0x32, 0x63, 0x62, 0x62, 0x32, 0x35, 0x62, 0x34, 0x35, 0x34, 0x35, 0x37, 0x30, 0x32, 0x39, 0x61, 0x32, 0x66, 0x35, 0x30, 0x62, 0x35, 0x31, 0x62, 0x30, 0x36, 0x32, 0x37, 0x37, 0x38, 0x62, 0x39, 0x63, 0x36, 0x37, 0x63, 0x64, 0x61, 0x66, 0x39, 0x34, 0x38, 0x66, 0x36, 0x64, 0x62, 0x65, 0x63, 0x35, 0x33, 0x38, 0x35, 0x65, 0x36, 0x63, 0x37, 0x39, 0x64, 0x38, 0x31, 0x38, 0x34, 0x33, 0x62, 0x33, 0x35, 0x30, 0x38, 0x66, 0x39, 0x63, 0x64, 0x31, 0x32, 0x65, 0x64, 0x31, 0x37, 0x32, 0x66, 0x34, 0x64, 0x36, 0x61, 0x31, 0x61, 0x64, 0x39, 0x30, 0x65, 0x35, 0x30, 0x31, 0x62, 0x31, 0x63, 0x64, 0x66, 0x32, 0x65, 0x31, 0x61, 0x63, 0x32, 0x32, 0x63, 0x33, 0x64, 0x61, 0x35, 0x30, 0x30, 0x34, 0x63, 0x33, 0x39, 0x62, 0x31, 0x62, 0x31, 0x63, 0x35, 0x35, 0x37, 0x36, 0x32, 0x63, 0x31, 0x38, 0x38, 0x66, 0x64, 0x32, 0x39, 0x64, 0x66, 0x31, 0x66, 0x30, 0x36, 0x62, 0x33, 0x34, 0x61, 0x36, 0x39, 0x33, 0x39, 0x61, 0x64, 0x37, 0x30, 0x62, 0x65, 0x62, 0x62, 0x62, 0x31, 0x37, 0x30, 0x35, 0x66, 0x35, 0x62, 0x66, 0x35, 0x37, 0x36, 0x33, 0x33, 0x31, 0x31, 0x33, 0x30, 0x34, 0x65, 0x37, 0x38, 0x31, 0x61, 0x63, 0x38, 0x63, 0x31, 0x30, 0x66, 0x64, 0x66, 0x35, 0x35, 0x38, 0x62, 0x37, 0x31, 0x66, 0x39, 0x39, 0x35, 0x39, 0x32, 0x33, 0x63, 0x32, 0x32, 0x37, 0x37, 0x32, 0x36, 0x35, 0x35, 0x62, 0x34, 0x33, 0x30, 0x66, 0x63, 0x64, 0x66, 0x35, 0x64, 0x61, 0x63, 0x62, 0x30, 0x33, 0x37, 0x64, 0x36, 0x38, 0x38, 0x63, 0x38, 0x64, 0x36, 0x37, 0x33, 0x65, 0x31, 0x64, 0x32, 0x32, 0x30, 0x35, 0x35, 0x30, 0x37, 0x35, 0x33, 0x36, 0x38, 0x62, 0x66, 0x62, 0x31, 0x30, 0x66, 0x64, 0x36, 0x30, 0x61, 0x64, 0x63, 0x38, 0x33, 0x63, 0x63, 0x35, 0x39, 0x63, 0x30, 0x33, 0x35, 0x31, 0x66, 0x61, 0x33, 0x32, 0x66, 0x34, 0x35, 0x31, 0x62, 0x36, 0x65, 0x64, 0x32, 0x35, 0x65, 0x62, 0x37, 0x61, 0x39, 0x66, 0x61, 0x37, 0x66, 0x66, 0x65, 0x65, 0x32, 0x62, 0x36, 0x38, 0x36, 0x31, 0x62, 0x30, 0x66, 0x34, 0x30, 0x39, 0x62, 0x37, 0x62, 0x30, 0x34, 0x65, 0x64, 0x32, 0x33, 0x66, 0x37, 0x65, 0x34, 0x64, 0x34, 0x65, 0x65, 0x31, 0x63, 0x62, 0x61, 0x34, 0x37, 0x32, 0x30, 0x38, 0x62, 0x30, 0x64, 0x31, 0x63, 0x32, 0x66, 0x39, 0x64, 0x37, 0x62, 0x34, 0x63, 0x63, 0x35, 0x66, 0x31, 0x33, 0x63, 0x65, 0x61, 0x30, 0x37, 0x66, 0x32, 0x39, 0x63, 0x39, 0x64, 0x34, 0x62, 0x35, 0x32, 0x38, 0x39, 0x36, 0x34, 0x64, 0x39, 0x37, 0x31, 0x39, 0x66, 0x61, 0x61, 0x33, 0x62, 0x33, 0x63, 0x38, 0x63, 0x61, 0x36, 0x36, 0x32, 0x61, 0x30, 0x64, 0x37, 0x38, 0x37, 0x32, 0x37, 0x38, 0x62, 0x35, 0x38, 0x36, 0x36, 0x36, 0x36, 0x39, 0x30, 0x37, 0x65, 0x33, 0x39, 0x61, 0x35, 0x35, 0x66, 0x39, 0x39, 0x32, 0x34, 0x64, 0x36, 0x39, 0x33, 0x64, 0x39, 0x34, 0x63, 0x31, 0x31, 0x38, 0x65, 0x36, 0x64, 0x66, 0x61, 0x35, 0x34, 0x34, 0x34, 0x61, 0x66, 0x33, 0x30, 0x66, 0x30, 0x61, 0x33, 0x61, 0x32, 0x63, 0x35, 0x38, 0x64, 0x63, 0x66, 0x65, 0x37, 0x38, 0x37, 0x32, 0x30, 0x38, 0x37, 0x31, 0x37, 0x34, 0x33, 0x64, 0x31, 0x36, 0x34, 0x30, 0x31, 0x61, 0x63, 0x65, 0x39, 0x31, 0x34, 0x32, 0x38, 0x63, 0x63, 0x36, 0x38, 0x66, 0x38, 0x63, 0x63, 0x65, 0x32, 0x36, 0x30, 0x63, 0x61, 0x64, 0x64, 0x36, 0x38, 0x32, 0x61, 0x37, 0x39, 0x66, 0x33, 0x63, 0x39, 0x39, 0x37, 0x34, 0x38, 0x36, 0x34, 0x36, 0x66, 0x33, 0x61, 0x36, 0x38, 0x63, 0x34, 0x30, 0x35, 0x61, 0x38, 0x38, 0x34, 0x39, 0x30, 0x63, 0x61, 0x34, 0x38, 0x62, 0x31, 0x39, 0x65, 0x39, 0x30, 0x36, 0x62, 0x62, 0x32, 0x37, 0x62, 0x36, 0x65, 0x61, 0x33, 0x33, 0x33, 0x31, 0x64, 0x64, 0x38, 0x33, 0x32, 0x31, 0x35, 0x62, 0x37, 0x32, 0x32, 0x64, 0x34, 0x62, 0x36, 0x64, 0x65, 0x66, 0x30, 0x32, 0x63, 0x64, 0x36, 0x62, 0x32, 0x66, 0x36, 0x37, 0x33, 0x36, 0x39, 0x35, 0x66, 0x38, 0x31, 0x65, 0x38, 0x64, 0x63, 0x33, 0x36, 0x36, 0x37, 0x38, 0x34, 0x65, 0x66, 0x36, 0x63, 0x33, 0x65, 0x39, 0x39, 0x35, 0x64, 0x39, 0x33, 0x37, 0x36, 0x36, 0x65, 0x34, 0x31, 0x61, 0x30, 0x63, 0x34, 0x39, 0x32, 0x61, 0x39, 0x32, 0x37, 0x37, 0x62, 0x33, 0x36, 0x32, 0x66, 0x34, 0x31, 0x39, 0x33, 0x33, 0x31, 0x62, 0x38, 0x64, 0x30, 0x65, 0x66, 0x31, 0x35, 0x35, 0x37, 0x36, 0x35, 0x34, 0x37, 0x32, 0x34, 0x35, 0x66, 0x62, 0x31, 0x37, 0x31, 0x39, 0x33, 0x39, 0x38, 0x32, 0x30, 0x64, 0x35, 0x35, 0x62, 0x31, 0x35, 0x32, 0x32, 0x37, 0x64, 0x62, 0x37, 0x30, 0x63, 0x33, 0x38, 0x38, 0x37, 0x30, 0x30, 0x31, 0x32, 0x34, 0x33, 0x61, 0x31, 0x34, 0x34, 0x34, 0x34, 0x39, 0x33, 0x38, 0x66, 0x33, 0x61, 0x62, 0x35, 0x66, 0x66, 0x63, 0x37, 0x34, 0x37, 0x31, 0x31, 0x35, 0x33, 0x33, 0x37, 0x32, 0x34, 0x33, 0x38, 0x38, 0x63, 0x62, 0x61, 0x62, 0x30, 0x61, 0x33, 0x61, 0x66, 0x32, 0x38, 0x61, 0x37, 0x38, 0x61, 0x61, 0x66, 0x62, 0x39, 0x38, 0x61, 0x35, 0x31, 0x33, 0x39, 0x63, 0x30, 0x32, 0x33, 0x35, 0x36, 0x35, 0x62, 0x63, 0x32, 0x65, 0x39, 0x37, 0x65, 0x36, 0x61, 0x31, 0x36, 0x36, 0x66, 0x39, 0x63, 0x61, 0x63, 0x35, 0x35, 0x31, 0x65, 0x64, 0x32, 0x32, 0x33, 0x34, 0x37, 0x32, 0x32, 0x34, 0x66, 0x35, 0x33, 0x65, 0x34, 0x39, 0x31, 0x65, 0x37, 0x39, 0x64, 0x30, 0x65, 0x61, 0x63, 0x36, 0x63, 0x30, 0x38, 0x62, 0x35, 0x38, 0x35, 0x34, 0x61, 0x39, 0x35, 0x37, 0x35, 0x38, 0x62, 0x33, 0x32, 0x38, 0x66, 0x62, 0x63, 0x30, 0x37, 0x66, 0x64, 0x34, 0x35, 0x66, 0x35, 0x39, 0x61, 0x35, 0x39, 0x34, 0x65, 0x63, 0x33, 0x66, 0x33, 0x32, 0x63, 0x35, 0x37, 0x30, 0x30, 0x64, 0x35, 0x65, 0x33, 0x66, 0x36, 0x35, 0x38, 0x32, 0x65, 0x35, 0x62, 0x37, 0x35, 0x30, 0x64, 0x35, 0x64, 0x35, 0x63, 0x32, 0x37, 0x66, 0x35, 0x32, 0x37, 0x34, 0x39, 0x32, 0x33, 0x64, 0x64, 0x30, 0x62, 0x66, 0x66, 0x37, 0x36, 0x63, 0x36, 0x61, 0x62, 0x34, 0x61, 0x38, 0x64, 0x36, 0x62, 0x36, 0x63, 0x37, 0x66, 0x61, 0x62, 0x63, 0x34, 0x35, 0x32, 0x39, 0x38, 0x62, 0x37, 0x39, 0x34, 0x39, 0x37, 0x39, 0x35, 0x63, 0x34, 0x32, 0x65, 0x32, 0x39, 0x39, 0x64, 0x36, 0x36, 0x62, 0x66, 0x65, 0x34, 0x64, 0x36, 0x65, 0x34, 0x32, 0x62, 0x66, 0x35, 0x39, 0x61, 0x38, 0x64, 0x34, 0x39, 0x39, 0x30, 0x65, 0x32, 0x36, 0x35, 0x65, 0x32, 0x62, 0x31, 0x65, 0x34, 0x37, 0x38, 0x64, 0x63, 0x64, 0x66, 0x39, 0x64, 0x35, 0x39, 0x33, 0x33, 0x37, 0x66, 0x66, 0x32, 0x36, 0x31, 0x62, 0x35, 0x65, 0x39, 0x36, 0x31, 0x39, 0x33, 0x39, 0x66, 0x34, 0x61, 0x39, 0x30, 0x62, 0x66, 0x63, 0x34, 0x32, 0x35, 0x65, 0x64, 0x34, 0x66, 0x36, 0x66, 0x62, 0x34, 0x61, 0x65, 0x33, 0x38, 0x38, 0x37, 0x38, 0x32, 0x63, 0x64, 0x64, 0x33, 0x30, 0x37, 0x35, 0x34, 0x62, 0x62, 0x36, 0x38, 0x34, 0x34, 0x38, 0x66, 0x34, 0x31, 0x61, 0x32, 0x39, 0x63, 0x39, 0x65, 0x38, 0x63, 0x64, 0x35, 0x34, 0x34, 0x33, 0x64, 0x38, 0x35, 0x65, 0x31, 0x62, 0x35, 0x36, 0x62, 0x35, 0x31, 0x64, 0x30, 0x63, 0x35, 0x64, 0x33, 0x62, 0x34, 0x32, 0x38, 0x33, 0x35, 0x65, 0x38, 0x35, 0x38, 0x64, 0x39, 0x36, 0x33, 0x35, 0x31, 0x37, 0x65, 0x34, 0x65, 0x64, 0x30, 0x61, 0x62, 0x65, 0x30, 0x30, 0x62, 0x37, 0x39, 0x39, 0x38, 0x62, 0x66, 0x31, 0x36, 0x64, 0x36, 0x61, 0x61, 0x31, 0x64, 0x31, 0x39, 0x32, 0x35, 0x38, 0x63, 0x31, 0x38, 0x62, 0x63, 0x66, 0x66, 0x36, 0x39, 0x63, 0x30, 0x66, 0x61, 0x65, 0x32, 0x33, 0x35, 0x38, 0x34, 0x39, 0x64, 0x35, 0x64, 0x38, 0x33, 0x30, 0x63, 0x34, 0x35, 0x62, 0x38, 0x62, 0x65, 0x31, 0x38, 0x38, 0x37, 0x31, 0x37, 0x32, 0x66, 0x32, 0x66, 0x34, 0x31, 0x64, 0x32, 0x32, 0x39, 0x61, 0x65, 0x63, 0x33, 0x33, 0x66, 0x37, 0x65, 0x31, 0x33, 0x37, 0x32, 0x35, 0x37, 0x32, 0x34, 0x65, 0x65, 0x36, 0x34, 0x63, 0x61, 0x65, 0x30, 0x64, 0x32, 0x62, 0x31, 0x35, 0x37, 0x63, 0x31, 0x64, 0x31, 0x32, 0x62, 0x64, 0x39, 0x33, 0x65, 0x64, 0x32, 0x37, 0x32, 0x31, 0x33, 0x39, 0x34, 0x38, 0x38, 0x33, 0x64, 0x34, 0x32, 0x33, 0x65, 0x34, 0x66, 0x66, 0x33, 0x31, 0x37, 0x61, 0x33, 0x38, 0x63, 0x38, 0x39, 0x33, 0x39, 0x33, 0x34, 0x61, 0x66, 0x64, 0x61, 0x62, 0x37, 0x32, 0x30, 0x35, 0x65, 0x39, 0x64, 0x65, 0x66, 0x31, 0x39, 0x37, 0x63, 0x39, 0x31, 0x39, 0x33, 0x64, 0x65, 0x33, 0x33, 0x65, 0x36, 0x37, 0x64, 0x64, 0x32, 0x31, 0x31, 0x35, 0x62, 0x62, 0x33, 0x31, 0x30, 0x37, 0x64, 0x32, 0x63, 0x37, 0x35, 0x61, 0x36, 0x30, 0x35, 0x30, 0x64, 0x63, 0x63, 0x36, 0x64, 0x62, 0x30, 0x38, 0x63, 0x30, 0x31, 0x33, 0x30, 0x35, 0x66, 0x33, 0x32, 0x63, 0x37, 0x32, 0x32, 0x62, 0x37, 0x30, 0x31, 0x31, 0x34, 0x63, 0x31, 0x32, 0x62, 0x30, 0x36, 0x61, 0x34, 0x37, 0x66, 0x62, 0x65, 0x33, 0x61, 0x31, 0x39, 0x38, 0x64, 0x34, 0x63, 0x35, 0x65, 0x64, 0x39, 0x37, 0x36, 0x39, 0x35, 0x36, 0x30, 0x62, 0x61, 0x39, 0x65, 0x33, 0x66, 0x61, 0x30, 0x31, 0x38, 0x32, 0x63, 0x63, 0x39, 0x37, 0x30, 0x62, 0x62, 0x32, 0x65, 0x32, 0x31, 0x32, 0x32, 0x39, 0x37, 0x32, 0x31, 0x64, 0x31, 0x31, 0x36, 0x35, 0x32, 0x31, 0x35, 0x30, 0x62, 0x34, 0x36, 0x39, 0x37, 0x35, 0x38, 0x37, 0x66, 0x65, 0x33, 0x31, 0x39, 0x30, 0x61, 0x33, 0x63, 0x61, 0x33, 0x64, 0x61, 0x33, 0x63, 0x65, 0x36, 0x61, 0x64, 0x36, 0x36, 0x64, 0x66, 0x38, 0x33, 0x36, 0x66, 0x31, 0x62, 0x63, 0x34, 0x39, 0x30, 0x32, 0x33, 0x39, 0x39, 0x32, 0x37, 0x30, 0x32, 0x62, 0x37, 0x35, 0x37, 0x32, 0x64, 0x36, 0x64, 0x31, 0x35, 0x34, 0x64, 0x65, 0x33, 0x66, 0x62, 0x38, 0x36, 0x33, 0x32, 0x62, 0x38, 0x61, 0x39, 0x33, 0x64, 0x36, 0x31, 0x39, 0x37, 0x31, 0x39, 0x34, 0x34, 0x33, 0x63, 0x30, 0x34, 0x30, 0x61, 0x36, 0x64, 0x33, 0x38, 0x65, 0x31, 0x33, 0x35, 0x32, 0x30, 0x34, 0x64, 0x62, 0x64, 0x30, 0x66, 0x61, 0x32, 0x31, 0x38, 0x32, 0x61, 0x65, 0x64, 0x33, 0x34, 0x32, 0x35, 0x39, 0x65, 0x33, 0x31, 0x62, 0x37, 0x31, 0x33, 0x34, 0x66, 0x34, 0x36, 0x31, 0x34, 0x37, 0x65, 0x34, 0x37, 0x65, 0x65, 0x34, 0x32, 0x63, 0x61, 0x34, 0x31, 0x32, 0x30, 0x32, 0x36, 0x65, 0x63, 0x33, 0x31, 0x62, 0x37, 0x63, 0x33, 0x63, 0x61, 0x63, 0x32, 0x62, 0x62, 0x32, 0x33, 0x31, 0x36, 0x63, 0x39, 0x66, 0x62, 0x65, 0x62, 0x36, 0x35, 0x61, 0x63, 0x61, 0x33, 0x63, 0x66, 0x65, 0x37, 0x32, 0x63, 0x39, 0x63, 0x35, 0x30, 0x32, 0x34, 0x39, 0x65, 0x30, 0x66, 0x62, 0x64, 0x65, 0x30, 0x35, 0x34, 0x38, 0x39, 0x64, 0x65, 0x65, 0x38, 0x39, 0x32, 0x34, 0x61, 0x63, 0x65, 0x61, 0x64, 0x34, 0x39, 0x30, 0x32, 0x31, 0x37, 0x35, 0x38, 0x32, 0x38, 0x62, 0x66, 0x62, 0x64, 0x31, 0x32, 0x35, 0x35, 0x61, 0x66, 0x35, 0x65, 0x64, 0x37, 0x35, 0x36, 0x36, 0x31, 0x65, 0x37, 0x30, 0x35, 0x65, 0x65, 0x30, 0x37, 0x64, 0x37, 0x37, 0x35, 0x65, 0x61, 0x31, 0x62, 0x33, 0x37, 0x33, 0x30, 0x34, 0x63, 0x36, 0x63, 0x37, 0x31, 0x62, 0x30, 0x30, 0x32, 0x66, 0x38, 0x65, 0x32, 0x37, 0x62, 0x34, 0x32, 0x31, 0x65, 0x35, 0x32, 0x35, 0x63, 0x39, 0x38, 0x34, 0x33, 0x63, 0x33, 0x66, 0x61, 0x34, 0x64, 0x33, 0x63, 0x63, 0x66, 0x63, 0x64, 0x39, 0x34, 0x63, 0x66, 0x38, 0x34, 0x33, 0x30, 0x39, 0x35, 0x38, 0x30, 0x64, 0x35, 0x65, 0x64, 0x30, 0x61, 0x64, 0x31, 0x34, 0x31, 0x34, 0x36, 0x34, 0x34, 0x30, 0x61, 0x64, 0x31, 0x34, 0x34, 0x36, 0x30, 0x63, 0x36, 0x38, 0x64, 0x38, 0x63, 0x36, 0x32, 0x36, 0x66, 0x63, 0x64, 0x61, 0x38, 0x65, 0x39, 0x61, 0x38, 0x31, 0x39, 0x33, 0x30, 0x32, 0x30, 0x39, 0x61, 0x35, 0x30, 0x30, 0x64, 0x38, 0x65, 0x61, 0x62, 0x32, 0x38, 0x30, 0x35, 0x37, 0x34, 0x34, 0x64, 0x62, 0x64, 0x66, 0x34, 0x65, 0x38, 0x30, 0x33, 0x35, 0x35, 0x36, 0x65, 0x35, 0x30, 0x32, 0x64, 0x34, 0x63, 0x35, 0x32, 0x39, 0x66, 0x37, 0x64, 0x30, 0x36, 0x66, 0x37, 0x31, 0x38, 0x36, 0x66, 0x31, 0x39, 0x66, 0x66, 0x36, 0x65, 0x35, 0x63, 0x66, 0x31, 0x31, 0x66, 0x38, 0x34, 0x34, 0x33, 0x64, 0x36, 0x34, 0x33, 0x39, 0x34, 0x34, 0x32, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x64, 0x65, 0x34, 0x62, 0x61, 0x39, 0x66, 0x34, 0x36, 0x32, 0x61, 0x34, 0x38, 0x38, 0x37, 0x34, 0x33, 0x30, 0x65, 0x61, 0x62, 0x30, 0x35, 0x36, 0x34, 0x66, 0x63, 0x32, 0x35, 0x66, 0x33, 0x33, 0x36, 0x35, 0x39, 0x65, 0x66, 0x31, 0x63, 0x32, 0x37, 0x39, 0x66, 0x34, 0x32, 0x66, 0x32, 0x66, 0x30, 0x34, 0x30, 0x30, 0x32, 0x31, 0x62, 0x32, 0x38, 0x38, 0x66, 0x32, 0x64, 0x35, 0x62, 0x39, 0x38, 0x63, 0x33, 0x39, 0x39, 0x61, 0x64, 0x34, 0x64, 0x61, 0x64, 0x61, 0x37, 0x66, 0x34, 0x62, 0x37, 0x65, 0x66, 0x63, 0x62, 0x65, 0x33, 0x31, 0x33, 0x64, 0x38, 0x62, 0x63, 0x38, 0x33, 0x61, 0x61, 0x34, 0x35, 0x61, 0x62, 0x39, 0x35, 0x62, 0x36, 0x39, 0x39, 0x31, 0x31, 0x34, 0x62, 0x30, 0x34, 0x34, 0x38, 0x30, 0x31, 0x35, 0x35, 0x62, 0x37, 0x64, 0x63, 0x38, 0x30, 0x37, 0x32, 0x30, 0x65, 0x64, 0x64, 0x39, 0x30, 0x65, 0x66, 0x66, 0x33, 0x34, 0x30, 0x31, 0x66, 0x61, 0x63, 0x66, 0x37, 0x64, 0x38, 0x38, 0x63, 0x63, 0x62, 0x35, 0x39, 0x35, 0x38, 0x61, 0x32, 0x34, 0x39, 0x34, 0x36, 0x65, 0x38, 0x30, 0x39, 0x33, 0x37, 0x64, 0x31, 0x63, 0x36, 0x35, 0x64, 0x66, 0x38, 0x66, 0x36, 0x37, 0x36, 0x39, 0x63, 0x36, 0x64, 0x61, 0x65, 0x61, 0x31, 0x62, 0x63, 0x31, 0x39, 0x65, 0x62, 0x66, 0x39, 0x32, 0x36, 0x36, 0x64, 0x38, 0x62, 0x33, 0x63, 0x32, 0x61, 0x66, 0x30, 0x61, 0x63, 0x30, 0x30, 0x66, 0x30, 0x32, 0x63, 0x37, 0x31, 0x37, 0x62, 0x35, 0x30, 0x66, 0x37, 0x30, 0x37, 0x35, 0x33, 0x36, 0x38, 0x37, 0x36, 0x32, 0x63, 0x63, 0x34, 0x33, 0x61, 0x65, 0x32, 0x39, 0x32, 0x63, 0x64, 0x33, 0x34, 0x32, 0x39, 0x39, 0x63, 0x65, 0x62, 0x66, 0x62, 0x37, 0x32, 0x34, 0x65, 0x38, 0x61, 0x36, 0x64, 0x38, 0x63, 0x31, 0x31, 0x30, 0x63, 0x62, 0x35, 0x64, 0x35, 0x39, 0x35, 0x66, 0x38, 0x65, 0x38, 0x32, 0x38, 0x35, 0x66, 0x64, 0x62, 0x38, 0x39, 0x38, 0x61, 0x39, 0x35, 0x30, 0x31, 0x33, 0x66, 0x39, 0x35, 0x34, 0x39, 0x62, 0x64, 0x33, 0x31, 0x66, 0x33, 0x30, 0x33, 0x31, 0x35, 0x31, 0x61, 0x39, 0x36, 0x62, 0x63, 0x63, 0x37, 0x36, 0x65, 0x33, 0x34, 0x65, 0x30, 0x39, 0x65, 0x63, 0x66, 0x65, 0x31, 0x36, 0x63, 0x66, 0x30, 0x36, 0x37, 0x33, 0x39, 0x35, 0x65, 0x65, 0x35, 0x31, 0x62, 0x39, 0x64, 0x35, 0x66, 0x36, 0x61, 0x31, 0x61, 0x66, 0x62, 0x30, 0x39, 0x35, 0x31, 0x32, 0x63, 0x62, 0x63, 0x34, 0x32, 0x34, 0x39, 0x62, 0x34, 0x62, 0x64, 0x33, 0x36, 0x30, 0x66, 0x62, 0x30, 0x64, 0x30, 0x63, 0x37, 0x38, 0x39, 0x62, 0x31, 0x30, 0x35, 0x64, 0x65, 0x64, 0x62, 0x61, 0x38, 0x32, 0x37, 0x38, 0x64, 0x31, 0x39, 0x64, 0x61, 0x66, 0x31, 0x63, 0x32, 0x63, 0x33, 0x39, 0x64, 0x35, 0x39, 0x35, 0x34, 0x35, 0x37, 0x64, 0x31, 0x31, 0x35, 0x62, 0x39, 0x36, 0x62, 0x33, 0x39, 0x38, 0x31, 0x64, 0x37, 0x32, 0x63, 0x33, 0x32, 0x38, 0x63, 0x32, 0x34, 0x31, 0x31, 0x65, 0x36, 0x61, 0x30, 0x63, 0x33, 0x32, 0x39, 0x61, 0x37, 0x31, 0x30, 0x35, 0x33, 0x32, 0x30, 0x63, 0x63, 0x33, 0x39, 0x65, 0x64, 0x39, 0x62, 0x35, 0x64, 0x39, 0x61, 0x30, 0x61, 0x37, 0x66, 0x64, 0x65, 0x32, 0x30, 0x32, 0x30, 0x66, 0x62, 0x30, 0x32, 0x63, 0x61, 0x65, 0x35, 0x35, 0x35, 0x32, 0x35, 0x30, 0x34, 0x33, 0x61, 0x36, 0x34, 0x39, 0x61, 0x38, 0x38, 0x63, 0x35, 0x31, 0x33, 0x66, 0x36, 0x62, 0x63, 0x32, 0x33, 0x64, 0x35, 0x32, 0x30, 0x37, 0x32, 0x37, 0x36, 0x63, 0x66, 0x31, 0x37, 0x64, 0x64, 0x35, 0x38, 0x66, 0x64, 0x33, 0x37, 0x39, 0x62, 0x65, 0x62, 0x32, 0x36, 0x30, 0x33, 0x33, 0x36, 0x66, 0x64, 0x61, 0x31, 0x63, 0x31, 0x39, 0x36, 0x32, 0x38, 0x62, 0x64, 0x61, 0x64, 0x37, 0x64, 0x66, 0x39, 0x63, 0x36, 0x66, 0x61, 0x35, 0x36, 0x63, 0x38, 0x66, 0x64, 0x37, 0x61, 0x64, 0x36, 0x34, 0x65, 0x32, 0x63, 0x32, 0x39, 0x37, 0x32, 0x33, 0x30, 0x64, 0x31, 0x65, 0x37, 0x36, 0x61, 0x33, 0x36, 0x35, 0x32, 0x38, 0x63, 0x32, 0x35, 0x37, 0x35, 0x32, 0x62, 0x36, 0x37, 0x61, 0x62, 0x39, 0x37, 0x33, 0x65, 0x61, 0x39, 0x37, 0x38, 0x31, 0x36, 0x39, 0x35, 0x31, 0x62, 0x30, 0x34, 0x36, 0x63, 0x35, 0x62, 0x38, 0x61, 0x65, 0x62, 0x39, 0x32, 0x36, 0x35, 0x62, 0x34, 0x63, 0x65, 0x62, 0x34, 0x66, 0x36, 0x63, 0x33, 0x31, 0x30, 0x33, 0x32, 0x39, 0x39, 0x31, 0x63, 0x65, 0x33, 0x64, 0x36, 0x34, 0x62, 0x63, 0x31, 0x32, 0x64, 0x36, 0x64, 0x63, 0x66, 0x38, 0x65, 0x37, 0x63, 0x37, 0x33, 0x31, 0x62, 0x33, 0x35, 0x36, 0x36, 0x64, 0x64, 0x39, 0x65, 0x35, 0x38, 0x61, 0x31, 0x61, 0x66, 0x65, 0x39, 0x31, 0x64, 0x38, 0x37, 0x64, 0x63, 0x61, 0x61, 0x37, 0x30, 0x39, 0x32, 0x39, 0x30, 0x39, 0x65, 0x62, 0x37, 0x30, 0x31, 0x33, 0x35, 0x61, 0x30, 0x66, 0x39, 0x30, 0x61, 0x32, 0x38, 0x62, 0x34, 0x35, 0x62, 0x31, 0x35, 0x63, 0x31, 0x35, 0x35, 0x34, 0x32, 0x35, 0x36, 0x61, 0x65, 0x32, 0x61, 0x35, 0x33, 0x34, 0x62, 0x66, 0x31, 0x30, 0x66, 0x33, 0x33, 0x37, 0x38, 0x32, 0x64, 0x39, 0x31, 0x63, 0x32, 0x62, 0x32, 0x63, 0x65, 0x64, 0x66, 0x65, 0x64, 0x35, 0x39, 0x36, 0x31, 0x35, 0x34, 0x65, 0x35, 0x34, 0x64, 0x30, 0x32, 0x64, 0x38, 0x37, 0x37, 0x39, 0x61, 0x37, 0x30, 0x30, 0x62, 0x62, 0x34, 0x30, 0x61, 0x38, 0x65, 0x64, 0x62, 0x38, 0x38, 0x30, 0x31, 0x39, 0x32, 0x30, 0x34, 0x36, 0x31, 0x62, 0x66, 0x37, 0x61, 0x62, 0x63, 0x63, 0x62, 0x34, 0x34, 0x31, 0x31, 0x38, 0x37, 0x66, 0x33, 0x38, 0x34, 0x64, 0x31, 0x35, 0x61, 0x33, 0x36, 0x66, 0x33, 0x31, 0x61, 0x64, 0x61, 0x30, 0x34, 0x35, 0x65, 0x36, 0x32, 0x63, 0x39, 0x34, 0x30, 0x62, 0x36, 0x30, 0x64, 0x38, 0x30, 0x65, 0x37, 0x61, 0x66, 0x66, 0x31, 0x36, 0x64, 0x62, 0x34, 0x39, 0x39, 0x33, 0x65, 0x30, 0x66, 0x31, 0x35, 0x65, 0x34, 0x33, 0x66, 0x65, 0x64, 0x32, 0x31, 0x65, 0x66, 0x35, 0x62, 0x61, 0x38, 0x38, 0x65, 0x61, 0x35, 0x32, 0x61, 0x61, 0x35, 0x66, 0x61, 0x37, 0x30, 0x61, 0x34, 0x33, 0x32, 0x35, 0x30, 0x32, 0x38, 0x63, 0x33, 0x33, 0x64, 0x63, 0x36, 0x37, 0x30, 0x32, 0x63, 0x30, 0x33, 0x37, 0x31, 0x62, 0x64, 0x37, 0x35, 0x34, 0x33, 0x32, 0x35, 0x37, 0x33, 0x62, 0x36, 0x64, 0x37, 0x63, 0x37, 0x62, 0x33, 0x63, 0x36, 0x32, 0x35, 0x65, 0x65, 0x65, 0x34, 0x64, 0x64, 0x62, 0x64, 0x61, 0x37, 0x62, 0x38, 0x36, 0x31, 0x66, 0x38, 0x38, 0x65, 0x32, 0x66, 0x36, 0x66, 0x62, 0x65, 0x31, 0x62, 0x35, 0x39, 0x38, 0x34, 0x39, 0x66, 0x65, 0x63, 0x65, 0x30, 0x36, 0x65, 0x33, 0x37, 0x63, 0x36, 0x61, 0x62, 0x35, 0x30, 0x66, 0x38, 0x64, 0x36, 0x66, 0x66, 0x65, 0x63, 0x63, 0x65, 0x32, 0x33, 0x39, 0x34, 0x63, 0x32, 0x32, 0x35, 0x63, 0x65, 0x37, 0x30, 0x64, 0x33, 0x34, 0x35, 0x62, 0x33, 0x32, 0x36, 0x33, 0x30, 0x32, 0x36, 0x39, 0x34, 0x64, 0x65, 0x39, 0x66, 0x66, 0x65, 0x33, 0x66, 0x32, 0x34, 0x39, 0x30, 0x32, 0x35, 0x32, 0x65, 0x64, 0x38, 0x64, 0x65, 0x64, 0x62, 0x64, 0x39, 0x37, 0x64, 0x31, 0x63, 0x36, 0x65, 0x36, 0x64, 0x38, 0x36, 0x38, 0x66, 0x61, 0x31, 0x61, 0x34, 0x66, 0x33, 0x30, 0x30, 0x39, 0x35, 0x66, 0x63, 0x65, 0x33, 0x66, 0x35, 0x30, 0x39, 0x66, 0x64, 0x36, 0x62, 0x31, 0x37, 0x61, 0x32, 0x37, 0x37, 0x35, 0x38, 0x66, 0x66, 0x35, 0x33, 0x66, 0x30, 0x36, 0x34, 0x30, 0x63, 0x64, 0x35, 0x34, 0x38, 0x62, 0x62, 0x34, 0x32, 0x32, 0x34, 0x32, 0x61, 0x35, 0x32, 0x35, 0x65, 0x30, 0x33, 0x62, 0x34, 0x37, 0x61, 0x61, 0x32, 0x66, 0x38, 0x65, 0x36, 0x35, 0x39, 0x33, 0x37, 0x36, 0x62, 0x37, 0x39, 0x37, 0x63, 0x61, 0x36, 0x62, 0x63, 0x62, 0x35, 0x64, 0x61, 0x37, 0x31, 0x63, 0x32, 0x61, 0x35, 0x34, 0x66, 0x38, 0x65, 0x32, 0x31, 0x34, 0x65, 0x32, 0x32, 0x61, 0x65, 0x30, 0x62, 0x31, 0x64, 0x35, 0x30, 0x62, 0x64, 0x32, 0x61, 0x66, 0x63, 0x37, 0x66, 0x30, 0x31, 0x36, 0x33, 0x66, 0x31, 0x35, 0x30, 0x65, 0x66, 0x64, 0x38, 0x61, 0x34, 0x37, 0x61, 0x33, 0x38, 0x32, 0x31, 0x36, 0x33, 0x32, 0x35, 0x61, 0x62, 0x65, 0x64, 0x63, 0x64, 0x30, 0x31, 0x65, 0x62, 0x66, 0x62, 0x66, 0x37, 0x37, 0x38, 0x34, 0x63, 0x32, 0x65, 0x63, 0x34, 0x37, 0x32, 0x65, 0x38, 0x36, 0x62, 0x33, 0x34, 0x36, 0x32, 0x62, 0x35, 0x32, 0x65, 0x33, 0x32, 0x34, 0x30, 0x61, 0x66, 0x64, 0x62, 0x37, 0x33, 0x34, 0x38, 0x61, 0x30, 0x63, 0x38, 0x32, 0x64, 0x33, 0x38, 0x63, 0x61, 0x33, 0x37, 0x62, 0x64, 0x36, 0x63, 0x65, 0x37, 0x65, 0x30, 0x37, 0x63, 0x39, 0x35, 0x39, 0x36, 0x64, 0x61, 0x66, 0x39, 0x33, 0x38, 0x66, 0x36, 0x34, 0x63, 0x33, 0x65, 0x30, 0x66, 0x32, 0x32, 0x62, 0x37, 0x61, 0x32, 0x35, 0x65, 0x35, 0x39, 0x39, 0x32, 0x30, 0x65, 0x64, 0x61, 0x34, 0x37, 0x39, 0x33, 0x30, 0x31, 0x37, 0x63, 0x32, 0x32, 0x34, 0x33, 0x62, 0x62, 0x61, 0x36, 0x66, 0x36, 0x34, 0x34, 0x35, 0x61, 0x36, 0x37, 0x30, 0x65, 0x35, 0x35, 0x38, 0x37, 0x64, 0x64, 0x33, 0x36, 0x38, 0x30, 0x63, 0x66, 0x30, 0x37, 0x61, 0x35, 0x39, 0x37, 0x61, 0x36, 0x37, 0x32, 0x65, 0x38, 0x31, 0x38, 0x36, 0x38, 0x62, 0x32, 0x32, 0x36, 0x62, 0x39, 0x33, 0x30, 0x64, 0x35, 0x66, 0x31, 0x36, 0x63, 0x66, 0x61, 0x66, 0x31, 0x31, 0x65, 0x65, 0x36, 0x31, 0x31, 0x34, 0x32, 0x33, 0x34, 0x66, 0x61, 0x65, 0x34, 0x38, 0x33, 0x31, 0x35, 0x39, 0x62, 0x39, 0x61, 0x35, 0x63, 0x61, 0x34, 0x63, 0x31, 0x34, 0x39, 0x38, 0x30, 0x35, 0x38, 0x64, 0x32, 0x35, 0x34, 0x32, 0x66, 0x37, 0x34, 0x33, 0x32, 0x32, 0x31, 0x32, 0x38, 0x61, 0x66, 0x63, 0x32, 0x36, 0x38, 0x38, 0x64, 0x31, 0x33, 0x31, 0x36, 0x65, 0x62, 0x64, 0x30, 0x30, 0x32, 0x39, 0x39, 0x64, 0x33, 0x34, 0x34, 0x34, 0x32, 0x61, 0x33, 0x64, 0x61, 0x62, 0x32, 0x39, 0x37, 0x61, 0x62, 0x37, 0x66, 0x64, 0x36, 0x61, 0x64, 0x62, 0x66, 0x63, 0x35, 0x62, 0x35, 0x35, 0x66, 0x31, 0x37, 0x34, 0x63, 0x31, 0x30, 0x61, 0x61, 0x64, 0x64, 0x66, 0x35, 0x30, 0x38, 0x36, 0x33, 0x30, 0x63, 0x30, 0x30, 0x36, 0x61, 0x39, 0x32, 0x33, 0x66, 0x31, 0x37, 0x64, 0x38, 0x34, 0x63, 0x62, 0x34, 0x33, 0x37, 0x30, 0x37, 0x63, 0x64, 0x62, 0x61, 0x35, 0x31, 0x32, 0x38, 0x38, 0x61, 0x34, 0x35, 0x32, 0x63, 0x34, 0x30, 0x63, 0x65, 0x39, 0x39, 0x62, 0x31, 0x34, 0x61, 0x64, 0x30, 0x33, 0x34, 0x39, 0x63, 0x37, 0x32, 0x66, 0x62, 0x34, 0x37, 0x34, 0x33, 0x39, 0x36, 0x31, 0x33, 0x36, 0x30, 0x32, 0x34, 0x36, 0x38, 0x35, 0x36, 0x38, 0x38, 0x62, 0x37, 0x34, 0x62, 0x33, 0x32, 0x31, 0x37, 0x36, 0x30, 0x34, 0x37, 0x65, 0x33, 0x35, 0x39, 0x36, 0x31, 0x63, 0x66, 0x38, 0x66, 0x66, 0x34, 0x38, 0x31, 0x63, 0x65, 0x38, 0x30, 0x61, 0x32, 0x64, 0x33, 0x32, 0x65, 0x30, 0x36, 0x35, 0x32, 0x38, 0x63, 0x37, 0x32, 0x34, 0x36, 0x66, 0x31, 0x61, 0x30, 0x63, 0x65, 0x61, 0x38, 0x61, 0x30, 0x36, 0x61, 0x36, 0x31, 0x35, 0x38, 0x32, 0x61, 0x66, 0x32, 0x64, 0x31, 0x66, 0x61, 0x34, 0x35, 0x31, 0x61, 0x63, 0x31, 0x37, 0x33, 0x65, 0x30, 0x38, 0x31, 0x64, 0x65, 0x63, 0x62, 0x39, 0x32, 0x35, 0x33, 0x34, 0x35, 0x62, 0x38, 0x61, 0x31, 0x37, 0x36, 0x33, 0x61, 0x34, 0x66, 0x64, 0x36, 0x37, 0x31, 0x37, 0x32, 0x32, 0x64, 0x35, 0x66, 0x33, 0x31, 0x31, 0x32, 0x38, 0x65, 0x30, 0x33, 0x30, 0x66, 0x35, 0x62, 0x32, 0x35, 0x66, 0x62, 0x61, 0x61, 0x34, 0x65, 0x65, 0x33, 0x36, 0x61, 0x32, 0x32, 0x33, 0x33, 0x33, 0x38, 0x61, 0x32, 0x31, 0x65, 0x32, 0x34, 0x35, 0x39, 0x38, 0x33, 0x31, 0x63, 0x34, 0x33, 0x37, 0x35, 0x64, 0x30, 0x62, 0x35, 0x37, 0x32, 0x64, 0x34, 0x39, 0x64, 0x39, 0x62, 0x37, 0x32, 0x37, 0x61, 0x62, 0x64, 0x34, 0x36, 0x33, 0x36, 0x34, 0x30, 0x63, 0x39, 0x65, 0x32, 0x62, 0x62, 0x30, 0x38, 0x63, 0x34, 0x66, 0x61, 0x62, 0x36, 0x64, 0x31, 0x30, 0x31, 0x31, 0x35, 0x31, 0x35, 0x63, 0x30, 0x35, 0x36, 0x39, 0x31, 0x34, 0x39, 0x30, 0x66, 0x32, 0x32, 0x35, 0x62, 0x33, 0x37, 0x32, 0x38, 0x34, 0x32, 0x36, 0x65, 0x65, 0x32, 0x32, 0x38, 0x63, 0x65, 0x65, 0x65, 0x30, 0x32, 0x33, 0x63, 0x33, 0x64, 0x63, 0x38, 0x64, 0x31, 0x37, 0x65, 0x37, 0x30, 0x31, 0x37, 0x35, 0x64, 0x36, 0x30, 0x62, 0x35, 0x36, 0x61, 0x39, 0x32, 0x37, 0x33, 0x37, 0x35, 0x31, 0x33, 0x33, 0x63, 0x63, 0x36, 0x39, 0x63, 0x34, 0x35, 0x66, 0x61, 0x39, 0x35, 0x32, 0x32, 0x63, 0x35, 0x36, 0x64, 0x63, 0x35, 0x64, 0x61, 0x65, 0x32, 0x30, 0x62, 0x35, 0x62, 0x38, 0x66, 0x62, 0x63, 0x34, 0x62, 0x62, 0x37, 0x39, 0x36, 0x37, 0x34, 0x61, 0x64, 0x32, 0x33, 0x63, 0x30, 0x37, 0x63, 0x36, 0x38, 0x31, 0x61, 0x35, 0x65, 0x31, 0x31, 0x30, 0x65, 0x31, 0x62, 0x39, 0x30, 0x31, 0x34, 0x33, 0x64, 0x64, 0x30, 0x65, 0x37, 0x65, 0x64, 0x35, 0x66, 0x32, 0x37, 0x35, 0x63, 0x33, 0x64, 0x62, 0x65, 0x30, 0x32, 0x62, 0x35, 0x31, 0x63, 0x66, 0x33, 0x61, 0x65, 0x33, 0x30, 0x32, 0x63, 0x35, 0x30, 0x64, 0x64, 0x62, 0x36, 0x62, 0x66, 0x38, 0x61, 0x34, 0x34, 0x36, 0x62, 0x33, 0x32, 0x38, 0x63, 0x36, 0x62, 0x65, 0x64, 0x31, 0x39, 0x61, 0x34, 0x64, 0x63, 0x65, 0x39, 0x64, 0x31, 0x38, 0x37, 0x31, 0x61, 0x62, 0x38, 0x35, 0x34, 0x32, 0x31, 0x39, 0x66, 0x62, 0x36, 0x61, 0x64, 0x38, 0x66, 0x64, 0x32, 0x30, 0x36, 0x66, 0x31, 0x34, 0x62, 0x66, 0x32, 0x62, 0x33, 0x38, 0x63, 0x37, 0x32, 0x37, 0x39, 0x63, 0x65, 0x33, 0x64, 0x64, 0x39, 0x65, 0x65, 0x30, 0x30, 0x37, 0x38, 0x30, 0x32, 0x65, 0x38, 0x66, 0x35, 0x36, 0x34, 0x32, 0x31, 0x62, 0x32, 0x30, 0x36, 0x32, 0x66, 0x38, 0x62, 0x62, 0x61, 0x30, 0x36, 0x32, 0x64, 0x61, 0x62, 0x32, 0x37, 0x66, 0x32, 0x32, 0x31, 0x64, 0x39, 0x38, 0x32, 0x62, 0x34, 0x34, 0x34, 0x36, 0x34, 0x65, 0x35, 0x33, 0x35, 0x37, 0x38, 0x31, 0x35, 0x61, 0x37, 0x32, 0x64, 0x30, 0x65, 0x32, 0x37, 0x39, 0x62, 0x33, 0x31, 0x32, 0x33, 0x65, 0x39, 0x38, 0x63, 0x61, 0x34, 0x64, 0x63, 0x61, 0x62, 0x34, 0x37, 0x63, 0x37, 0x30, 0x63, 0x32, 0x66, 0x63, 0x35, 0x61, 0x66, 0x35, 0x34, 0x37, 0x38, 0x37, 0x63, 0x35, 0x63, 0x34, 0x31, 0x33, 0x34, 0x31, 0x35, 0x35, 0x36, 0x66, 0x31, 0x39, 0x30, 0x64, 0x65, 0x64, 0x37, 0x38, 0x30, 0x37, 0x32, 0x31, 0x35, 0x65, 0x63, 0x35, 0x33, 0x64, 0x31, 0x34, 0x31, 0x62, 0x32, 0x31, 0x35, 0x30, 0x32, 0x33, 0x35, 0x33, 0x66, 0x31, 0x34, 0x31, 0x66, 0x39, 0x30, 0x63, 0x34, 0x31, 0x34, 0x37, 0x30, 0x35, 0x63, 0x64, 0x36, 0x66, 0x30, 0x37, 0x33, 0x66, 0x37, 0x30, 0x34, 0x32, 0x36, 0x34, 0x66, 0x31, 0x63, 0x64, 0x34, 0x65, 0x65, 0x66, 0x66, 0x63, 0x64, 0x63, 0x35, 0x65, 0x66, 0x37, 0x32, 0x32, 0x33, 0x39, 0x63, 0x64, 0x61, 0x35, 0x38, 0x62, 0x63, 0x61, 0x37, 0x61, 0x35, 0x32, 0x38, 0x37, 0x65, 0x61, 0x30, 0x61, 0x61, 0x36, 0x62, 0x65, 0x33, 0x38, 0x66, 0x31, 0x39, 0x31, 0x61, 0x33, 0x31, 0x39, 0x31, 0x30, 0x62, 0x32, 0x63, 0x30, 0x33, 0x34, 0x65, 0x39, 0x30, 0x39, 0x63, 0x35, 0x33, 0x64, 0x66, 0x36, 0x31, 0x36, 0x33, 0x36, 0x35, 0x30, 0x63, 0x65, 0x66, 0x36, 0x35, 0x61, 0x65, 0x65, 0x32, 0x35, 0x30, 0x31, 0x33, 0x38, 0x61, 0x63, 0x33, 0x31, 0x38, 0x39, 0x38, 0x39, 0x66, 0x66, 0x37, 0x34, 0x33, 0x34, 0x35, 0x30, 0x34, 0x32, 0x66, 0x62, 0x33, 0x38, 0x66, 0x39, 0x62, 0x36, 0x37, 0x65, 0x37, 0x34, 0x66, 0x63, 0x62, 0x34, 0x36, 0x64, 0x37, 0x65, 0x38, 0x64, 0x36, 0x62, 0x33, 0x39, 0x30, 0x36, 0x32, 0x32, 0x36, 0x65, 0x36, 0x37, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x34, 0x61, 0x66, 0x32, 0x35, 0x64, 0x35, 0x34, 0x64, 0x32, 0x63, 0x63, 0x34, 0x30, 0x65, 0x64, 0x37, 0x32, 0x32, 0x33, 0x39, 0x35, 0x37, 0x38, 0x63, 0x62, 0x62, 0x61, 0x30, 0x35, 0x34, 0x39, 0x39, 0x62, 0x66, 0x36, 0x66, 0x35, 0x38, 0x33, 0x62, 0x34, 0x30, 0x33, 0x33, 0x37, 0x35, 0x66, 0x34, 0x63, 0x61, 0x38, 0x66, 0x62, 0x35, 0x38, 0x65, 0x37, 0x30, 0x36, 0x30, 0x39, 0x64, 0x61, 0x35, 0x32, 0x31, 0x66, 0x66, 0x34, 0x65, 0x39, 0x63, 0x66, 0x39, 0x62, 0x33, 0x64, 0x32, 0x34, 0x62, 0x37, 0x38, 0x66, 0x31, 0x31, 0x34, 0x34, 0x36, 0x39, 0x36, 0x66, 0x61, 0x63, 0x66, 0x61, 0x36, 0x37, 0x32, 0x33, 0x64, 0x64, 0x38, 0x32, 0x66, 0x39, 0x36, 0x33, 0x61, 0x30, 0x35, 0x61, 0x32, 0x38, 0x32, 0x61, 0x65, 0x62, 0x30, 0x65, 0x36, 0x32, 0x38, 0x37, 0x32, 0x63, 0x38, 0x63, 0x37, 0x64, 0x30, 0x30, 0x31, 0x62, 0x39, 0x36, 0x36, 0x62, 0x30, 0x62, 0x30, 0x63, 0x66, 0x39, 0x35, 0x39, 0x34, 0x39, 0x63, 0x33, 0x38, 0x30, 0x39, 0x36, 0x64, 0x37, 0x63, 0x37, 0x64, 0x31, 0x62, 0x36, 0x62, 0x39, 0x64, 0x63, 0x33, 0x31, 0x32, 0x39, 0x31, 0x39, 0x36, 0x33, 0x61, 0x30, 0x62, 0x32, 0x33, 0x34, 0x35, 0x30, 0x39, 0x65, 0x39, 0x61, 0x39, 0x37, 0x32, 0x63, 0x37, 0x34, 0x61, 0x32, 0x65, 0x31, 0x63, 0x66, 0x61, 0x36, 0x62, 0x31, 0x63, 0x33, 0x64, 0x64, 0x30, 0x39, 0x65, 0x61, 0x30, 0x61, 0x36, 0x31, 0x64, 0x65, 0x64, 0x31, 0x63, 0x39, 0x63, 0x33, 0x32, 0x38, 0x36, 0x31, 0x31, 0x30, 0x61, 0x35, 0x61, 0x35, 0x36, 0x39, 0x64, 0x37, 0x62, 0x32, 0x65, 0x36, 0x33, 0x36, 0x63, 0x30, 0x62, 0x35, 0x62, 0x62, 0x62, 0x34, 0x62, 0x34, 0x31, 0x63, 0x63, 0x65, 0x36, 0x32, 0x62, 0x39, 0x33, 0x61, 0x61, 0x36, 0x37, 0x30, 0x33, 0x34, 0x65, 0x35, 0x39, 0x34, 0x34, 0x33, 0x64, 0x35, 0x37, 0x30, 0x64, 0x65, 0x38, 0x61, 0x35, 0x63, 0x63, 0x37, 0x33, 0x33, 0x61, 0x61, 0x35, 0x34, 0x37, 0x34, 0x61, 0x32, 0x31, 0x30, 0x62, 0x34, 0x36, 0x34, 0x63, 0x34, 0x35, 0x31, 0x35, 0x36, 0x34, 0x38, 0x38, 0x61, 0x33, 0x32, 0x39, 0x37, 0x32, 0x62, 0x39, 0x36, 0x32, 0x37, 0x35, 0x62, 0x62, 0x37, 0x62, 0x63, 0x35, 0x30, 0x61, 0x62, 0x62, 0x31, 0x31, 0x36, 0x33, 0x38, 0x32, 0x37, 0x65, 0x61, 0x65, 0x31, 0x39, 0x62, 0x34, 0x61, 0x65, 0x31, 0x36, 0x61, 0x33, 0x61, 0x62, 0x34, 0x33, 0x33, 0x34, 0x34, 0x36, 0x64, 0x30, 0x35, 0x65, 0x32, 0x30, 0x66, 0x36, 0x62, 0x32, 0x31, 0x66, 0x65, 0x30, 0x38, 0x64, 0x64, 0x33, 0x37, 0x32, 0x61, 0x63, 0x64, 0x66, 0x37, 0x34, 0x38, 0x38, 0x30, 0x61, 0x64, 0x66, 0x65, 0x38, 0x65, 0x38, 0x37, 0x34, 0x35, 0x66, 0x34, 0x62, 0x34, 0x36, 0x64, 0x61, 0x31, 0x36, 0x65, 0x62, 0x30, 0x39, 0x36, 0x34, 0x64, 0x38, 0x31, 0x62, 0x62, 0x66, 0x35, 0x35, 0x63, 0x35, 0x38, 0x32, 0x37, 0x64, 0x36, 0x62, 0x61, 0x39, 0x34, 0x38, 0x36, 0x62, 0x34, 0x35, 0x33, 0x63, 0x39, 0x64, 0x37, 0x32, 0x39, 0x33, 0x63, 0x66, 0x35, 0x64, 0x66, 0x64, 0x64, 0x36, 0x31, 0x64, 0x30, 0x32, 0x35, 0x39, 0x39, 0x31, 0x32, 0x66, 0x37, 0x32, 0x31, 0x33, 0x33, 0x65, 0x35, 0x30, 0x39, 0x39, 0x66, 0x39, 0x61, 0x64, 0x37, 0x63, 0x62, 0x39, 0x35, 0x61, 0x64, 0x61, 0x65, 0x30, 0x30, 0x37, 0x63, 0x39, 0x34, 0x33, 0x32, 0x61, 0x36, 0x64, 0x33, 0x32, 0x38, 0x39, 0x30, 0x35, 0x66, 0x31, 0x37, 0x32, 0x36, 0x35, 0x36, 0x39, 0x38, 0x32, 0x33, 0x64, 0x63, 0x65, 0x65, 0x35, 0x62, 0x39, 0x63, 0x32, 0x30, 0x34, 0x32, 0x66, 0x37, 0x39, 0x33, 0x37, 0x30, 0x64, 0x30, 0x38, 0x61, 0x33, 0x65, 0x31, 0x32, 0x30, 0x63, 0x30, 0x32, 0x30, 0x63, 0x32, 0x64, 0x38, 0x66, 0x34, 0x63, 0x30, 0x33, 0x64, 0x63, 0x35, 0x62, 0x32, 0x39, 0x30, 0x63, 0x31, 0x61, 0x37, 0x66, 0x39, 0x63, 0x63, 0x37, 0x32, 0x32, 0x62, 0x38, 0x63, 0x33, 0x37, 0x39, 0x64, 0x37, 0x39, 0x38, 0x65, 0x36, 0x65, 0x38, 0x64, 0x64, 0x61, 0x36, 0x39, 0x33, 0x62, 0x34, 0x34, 0x66, 0x66, 0x37, 0x34, 0x65, 0x34, 0x66, 0x34, 0x66, 0x66, 0x63, 0x35, 0x33, 0x33, 0x64, 0x35, 0x33, 0x30, 0x63, 0x34, 0x64, 0x65, 0x66, 0x66, 0x62, 0x33, 0x66, 0x34, 0x62, 0x35, 0x37, 0x33, 0x36, 0x61, 0x38, 0x62, 0x33, 0x62, 0x34, 0x61, 0x31, 0x63, 0x64, 0x31, 0x62, 0x34, 0x36, 0x39, 0x62, 0x34, 0x35, 0x35, 0x37, 0x30, 0x61, 0x30, 0x34, 0x61, 0x61, 0x39, 0x37, 0x65, 0x63, 0x63, 0x34, 0x34, 0x37, 0x34, 0x35, 0x63, 0x37, 0x61, 0x30, 0x66, 0x34, 0x36, 0x65, 0x64, 0x38, 0x65, 0x38, 0x38, 0x36, 0x39, 0x61, 0x64, 0x39, 0x65, 0x34, 0x33, 0x38, 0x34, 0x38, 0x30, 0x34, 0x63, 0x34, 0x62, 0x36, 0x66, 0x33, 0x30, 0x36, 0x65, 0x38, 0x34, 0x38, 0x32, 0x62, 0x39, 0x39, 0x30, 0x37, 0x36, 0x61, 0x35, 0x33, 0x33, 0x32, 0x63, 0x36, 0x37, 0x34, 0x63, 0x33, 0x31, 0x30, 0x61, 0x64, 0x34, 0x32, 0x33, 0x38, 0x63, 0x39, 0x66, 0x32, 0x32, 0x61, 0x66, 0x62, 0x39, 0x35, 0x66, 0x37, 0x34, 0x31, 0x64, 0x66, 0x64, 0x30, 0x66, 0x39, 0x38, 0x62, 0x65, 0x37, 0x62, 0x65, 0x30, 0x62, 0x38, 0x36, 0x37, 0x35, 0x34, 0x37, 0x32, 0x63, 0x64, 0x66, 0x34, 0x31, 0x31, 0x62, 0x61, 0x66, 0x30, 0x31, 0x33, 0x64, 0x30, 0x61, 0x30, 0x31, 0x39, 0x39, 0x30, 0x63, 0x36, 0x31, 0x64, 0x32, 0x66, 0x33, 0x35, 0x30, 0x39, 0x39, 0x31, 0x37, 0x34, 0x30, 0x63, 0x66, 0x63, 0x34, 0x30, 0x33, 0x37, 0x33, 0x31, 0x32, 0x65, 0x62, 0x33, 0x39, 0x66, 0x66, 0x31, 0x31, 0x32, 0x65, 0x38, 0x66, 0x34, 0x32, 0x33, 0x64, 0x30, 0x37, 0x32, 0x31, 0x37, 0x65, 0x38, 0x36, 0x32, 0x36, 0x37, 0x62, 0x33, 0x39, 0x37, 0x38, 0x62, 0x38, 0x62, 0x62, 0x62, 0x32, 0x35, 0x36, 0x36, 0x30, 0x33, 0x36, 0x36, 0x30, 0x38, 0x39, 0x31, 0x31, 0x30, 0x61, 0x33, 0x37, 0x65, 0x38, 0x39, 0x38, 0x34, 0x31, 0x30, 0x63, 0x65, 0x65, 0x62, 0x63, 0x35, 0x37, 0x66, 0x61, 0x30, 0x61, 0x61, 0x36, 0x32, 0x30, 0x65, 0x30, 0x63, 0x34, 0x39, 0x37, 0x32, 0x62, 0x66, 0x31, 0x61, 0x62, 0x35, 0x33, 0x35, 0x31, 0x66, 0x34, 0x63, 0x32, 0x32, 0x38, 0x63, 0x64, 0x66, 0x63, 0x32, 0x31, 0x30, 0x63, 0x39, 0x34, 0x37, 0x35, 0x34, 0x62, 0x34, 0x32, 0x34, 0x66, 0x31, 0x39, 0x32, 0x38, 0x30, 0x37, 0x31, 0x31, 0x37, 0x62, 0x61, 0x34, 0x33, 0x35, 0x30, 0x32, 0x39, 0x61, 0x36, 0x34, 0x66, 0x66, 0x36, 0x62, 0x39, 0x31, 0x30, 0x66, 0x63, 0x37, 0x32, 0x65, 0x36, 0x65, 0x38, 0x65, 0x61, 0x65, 0x31, 0x64, 0x66, 0x39, 0x65, 0x61, 0x65, 0x66, 0x37, 0x64, 0x61, 0x37, 0x37, 0x61, 0x34, 0x66, 0x62, 0x34, 0x31, 0x64, 0x63, 0x39, 0x66, 0x31, 0x63, 0x37, 0x63, 0x63, 0x64, 0x37, 0x62, 0x32, 0x37, 0x32, 0x37, 0x35, 0x65, 0x39, 0x62, 0x33, 0x35, 0x33, 0x38, 0x34, 0x34, 0x62, 0x36, 0x63, 0x37, 0x33, 0x37, 0x31, 0x32, 0x30, 0x34, 0x31, 0x63, 0x63, 0x30, 0x39, 0x32, 0x38, 0x38, 0x33, 0x61, 0x30, 0x32, 0x66, 0x37, 0x62, 0x65, 0x65, 0x62, 0x63, 0x34, 0x35, 0x64, 0x37, 0x62, 0x36, 0x33, 0x35, 0x38, 0x35, 0x34, 0x32, 0x36, 0x35, 0x64, 0x38, 0x62, 0x30, 0x30, 0x32, 0x65, 0x37, 0x37, 0x32, 0x33, 0x66, 0x30, 0x66, 0x31, 0x32, 0x65, 0x39, 0x36, 0x63, 0x65, 0x65, 0x37, 0x37, 0x66, 0x65, 0x64, 0x63, 0x34, 0x36, 0x33, 0x32, 0x66, 0x34, 0x39, 0x63, 0x34, 0x66, 0x61, 0x33, 0x63, 0x37, 0x63, 0x31, 0x65, 0x64, 0x38, 0x63, 0x30, 0x61, 0x37, 0x64, 0x66, 0x38, 0x66, 0x62, 0x66, 0x30, 0x37, 0x37, 0x32, 0x30, 0x36, 0x32, 0x37, 0x65, 0x38, 0x61, 0x30, 0x66, 0x39, 0x39, 0x66, 0x62, 0x65, 0x34, 0x32, 0x35, 0x62, 0x33, 0x62, 0x62, 0x30, 0x61, 0x39, 0x36, 0x31, 0x63, 0x38, 0x39, 0x64, 0x37, 0x32, 0x32, 0x33, 0x37, 0x32, 0x66, 0x33, 0x38, 0x35, 0x61, 0x34, 0x30, 0x32, 0x37, 0x66, 0x65, 0x32, 0x34, 0x32, 0x38, 0x36, 0x65, 0x34, 0x62, 0x66, 0x61, 0x65, 0x33, 0x31, 0x64, 0x62, 0x66, 0x39, 0x31, 0x35, 0x31, 0x30, 0x63, 0x33, 0x31, 0x33, 0x38, 0x64, 0x30, 0x33, 0x36, 0x64, 0x32, 0x39, 0x31, 0x66, 0x35, 0x63, 0x34, 0x30, 0x61, 0x38, 0x36, 0x31, 0x64, 0x31, 0x64, 0x31, 0x65, 0x65, 0x34, 0x37, 0x33, 0x32, 0x30, 0x63, 0x36, 0x61, 0x32, 0x30, 0x38, 0x31, 0x32, 0x32, 0x63, 0x39, 0x31, 0x65, 0x32, 0x64, 0x38, 0x35, 0x65, 0x33, 0x32, 0x64, 0x61, 0x37, 0x37, 0x35, 0x39, 0x37, 0x32, 0x30, 0x32, 0x31, 0x33, 0x31, 0x63, 0x62, 0x33, 0x63, 0x30, 0x63, 0x32, 0x31, 0x38, 0x63, 0x36, 0x65, 0x61, 0x37, 0x61, 0x63, 0x66, 0x61, 0x32, 0x37, 0x38, 0x30, 0x64, 0x39, 0x39, 0x34, 0x37, 0x65, 0x35, 0x65, 0x37, 0x35, 0x38, 0x30, 0x36, 0x30, 0x65, 0x62, 0x34, 0x65, 0x36, 0x62, 0x65, 0x33, 0x66, 0x34, 0x39, 0x36, 0x61, 0x64, 0x30, 0x62, 0x35, 0x66, 0x64, 0x66, 0x38, 0x64, 0x36, 0x35, 0x37, 0x61, 0x32, 0x31, 0x63, 0x61, 0x61, 0x62, 0x65, 0x65, 0x62, 0x38, 0x34, 0x37, 0x34, 0x33, 0x30, 0x33, 0x36, 0x66, 0x61, 0x38, 0x65, 0x36, 0x66, 0x65, 0x34, 0x65, 0x37, 0x61, 0x31, 0x66, 0x35, 0x30, 0x32, 0x64, 0x38, 0x36, 0x31, 0x38, 0x66, 0x36, 0x34, 0x61, 0x61, 0x34, 0x37, 0x33, 0x32, 0x37, 0x63, 0x63, 0x38, 0x62, 0x38, 0x38, 0x62, 0x62, 0x35, 0x39, 0x38, 0x31, 0x35, 0x37, 0x61, 0x36, 0x31, 0x61, 0x34, 0x37, 0x39, 0x31, 0x66, 0x36, 0x39, 0x34, 0x31, 0x65, 0x38, 0x63, 0x37, 0x36, 0x61, 0x30, 0x38, 0x31, 0x61, 0x37, 0x61, 0x38, 0x39, 0x35, 0x31, 0x36, 0x35, 0x61, 0x37, 0x32, 0x37, 0x61, 0x33, 0x32, 0x65, 0x37, 0x30, 0x37, 0x32, 0x36, 0x37, 0x33, 0x31, 0x36, 0x32, 0x30, 0x64, 0x35, 0x32, 0x64, 0x31, 0x65, 0x39, 0x31, 0x66, 0x61, 0x64, 0x30, 0x62, 0x32, 0x37, 0x63, 0x35, 0x34, 0x31, 0x66, 0x37, 0x61, 0x34, 0x33, 0x34, 0x65, 0x34, 0x63, 0x66, 0x66, 0x61, 0x37, 0x38, 0x33, 0x64, 0x34, 0x62, 0x37, 0x38, 0x65, 0x30, 0x36, 0x33, 0x61, 0x63, 0x61, 0x37, 0x32, 0x38, 0x35, 0x64, 0x66, 0x38, 0x38, 0x39, 0x31, 0x62, 0x34, 0x36, 0x35, 0x32, 0x33, 0x32, 0x66, 0x33, 0x39, 0x36, 0x65, 0x37, 0x63, 0x35, 0x35, 0x62, 0x37, 0x34, 0x65, 0x35, 0x64, 0x36, 0x35, 0x30, 0x65, 0x32, 0x66, 0x65, 0x66, 0x36, 0x62, 0x62, 0x63, 0x38, 0x36, 0x61, 0x34, 0x65, 0x65, 0x63, 0x32, 0x33, 0x39, 0x30, 0x64, 0x66, 0x65, 0x62, 0x39, 0x35, 0x62, 0x66, 0x32, 0x37, 0x32, 0x62, 0x36, 0x61, 0x39, 0x36, 0x35, 0x66, 0x62, 0x34, 0x64, 0x34, 0x39, 0x63, 0x63, 0x34, 0x63, 0x31, 0x65, 0x63, 0x30, 0x63, 0x61, 0x34, 0x30, 0x34, 0x32, 0x39, 0x61, 0x61, 0x32, 0x39, 0x31, 0x37, 0x63, 0x32, 0x61, 0x30, 0x32, 0x62, 0x39, 0x32, 0x36, 0x62, 0x62, 0x35, 0x39, 0x65, 0x65, 0x62, 0x32, 0x32, 0x31, 0x33, 0x31, 0x31, 0x34, 0x33, 0x34, 0x63, 0x35, 0x61, 0x31, 0x34, 0x38, 0x34, 0x63, 0x30, 0x35, 0x63, 0x65, 0x35, 0x66, 0x33, 0x30, 0x36, 0x64, 0x31, 0x35, 0x31, 0x31, 0x38, 0x65, 0x66, 0x37, 0x63, 0x39, 0x38, 0x32, 0x38, 0x38, 0x35, 0x65, 0x63, 0x66, 0x61, 0x33, 0x38, 0x35, 0x61, 0x32, 0x61, 0x31, 0x33, 0x63, 0x37, 0x31, 0x65, 0x37, 0x64, 0x35, 0x37, 0x38, 0x66, 0x32, 0x32, 0x63, 0x34, 0x36, 0x37, 0x35, 0x64, 0x35, 0x65, 0x37, 0x39, 0x37, 0x37, 0x32, 0x39, 0x33, 0x31, 0x65, 0x66, 0x37, 0x37, 0x31, 0x30, 0x39, 0x36, 0x65, 0x66, 0x32, 0x33, 0x65, 0x30, 0x32, 0x38, 0x36, 0x30, 0x66, 0x38, 0x32, 0x30, 0x36, 0x65, 0x61, 0x35, 0x32, 0x66, 0x65, 0x64, 0x36, 0x66, 0x65, 0x32, 0x36, 0x39, 0x36, 0x35, 0x61, 0x33, 0x64, 0x62, 0x31, 0x34, 0x33, 0x33, 0x39, 0x65, 0x62, 0x36, 0x64, 0x39, 0x34, 0x65, 0x32, 0x33, 0x33, 0x64, 0x32, 0x37, 0x32, 0x35, 0x34, 0x64, 0x37, 0x31, 0x31, 0x33, 0x36, 0x33, 0x30, 0x62, 0x36, 0x37, 0x36, 0x66, 0x61, 0x66, 0x38, 0x30, 0x62, 0x35, 0x61, 0x66, 0x38, 0x34, 0x66, 0x64, 0x64, 0x36, 0x62, 0x61, 0x34, 0x35, 0x62, 0x31, 0x34, 0x36, 0x39, 0x39, 0x64, 0x34, 0x33, 0x61, 0x61, 0x38, 0x30, 0x39, 0x32, 0x65, 0x36, 0x35, 0x33, 0x39, 0x65, 0x36, 0x39, 0x32, 0x34, 0x61, 0x33, 0x61, 0x61, 0x37, 0x32, 0x37, 0x66, 0x63, 0x30, 0x30, 0x31, 0x35, 0x38, 0x65, 0x65, 0x37, 0x33, 0x62, 0x38, 0x61, 0x30, 0x34, 0x30, 0x61, 0x65, 0x61, 0x65, 0x32, 0x63, 0x66, 0x38, 0x65, 0x62, 0x62, 0x37, 0x64, 0x65, 0x66, 0x39, 0x33, 0x34, 0x64, 0x62, 0x38, 0x62, 0x34, 0x38, 0x66, 0x38, 0x38, 0x38, 0x37, 0x33, 0x64, 0x33, 0x32, 0x37, 0x62, 0x61, 0x63, 0x61, 0x36, 0x62, 0x35, 0x33, 0x64, 0x66, 0x34, 0x39, 0x66, 0x30, 0x61, 0x31, 0x34, 0x39, 0x39, 0x66, 0x36, 0x37, 0x30, 0x36, 0x63, 0x62, 0x64, 0x61, 0x30, 0x38, 0x38, 0x34, 0x38, 0x66, 0x66, 0x62, 0x39, 0x64, 0x32, 0x36, 0x33, 0x39, 0x65, 0x38, 0x30, 0x32, 0x63, 0x35, 0x32, 0x35, 0x32, 0x63, 0x64, 0x34, 0x64, 0x64, 0x34, 0x39, 0x62, 0x64, 0x62, 0x66, 0x38, 0x30, 0x37, 0x39, 0x38, 0x65, 0x65, 0x38, 0x30, 0x32, 0x61, 0x62, 0x32, 0x36, 0x32, 0x36, 0x65, 0x35, 0x36, 0x32, 0x39, 0x65, 0x62, 0x32, 0x66, 0x64, 0x33, 0x36, 0x34, 0x36, 0x30, 0x34, 0x33, 0x35, 0x38, 0x62, 0x38, 0x64, 0x33, 0x38, 0x66, 0x30, 0x39, 0x38, 0x33, 0x61, 0x30, 0x34, 0x61, 0x30, 0x63, 0x66, 0x35, 0x30, 0x31, 0x31, 0x65, 0x66, 0x30, 0x33, 0x37, 0x65, 0x32, 0x34, 0x65, 0x37, 0x30, 0x63, 0x37, 0x64, 0x66, 0x64, 0x35, 0x35, 0x32, 0x31, 0x37, 0x32, 0x33, 0x32, 0x65, 0x30, 0x38, 0x64, 0x61, 0x61, 0x66, 0x62, 0x64, 0x37, 0x66, 0x39, 0x63, 0x37, 0x61, 0x30, 0x36, 0x61, 0x66, 0x39, 0x33, 0x36, 0x39, 0x66, 0x32, 0x63, 0x31, 0x30, 0x36, 0x61, 0x30, 0x30, 0x38, 0x65, 0x63, 0x38, 0x36, 0x64, 0x37, 0x31, 0x32, 0x30, 0x33, 0x62, 0x65, 0x35, 0x30, 0x35, 0x39, 0x65, 0x63, 0x30, 0x64, 0x39, 0x33, 0x37, 0x33, 0x39, 0x36, 0x36, 0x36, 0x39, 0x39, 0x65, 0x63, 0x37, 0x34, 0x38, 0x36, 0x37, 0x38, 0x62, 0x39, 0x62, 0x37, 0x36, 0x38, 0x64, 0x63, 0x34, 0x65, 0x61, 0x61, 0x37, 0x35, 0x37, 0x61, 0x38, 0x66, 0x37, 0x66, 0x32, 0x66, 0x33, 0x31, 0x66, 0x62, 0x62, 0x63, 0x38, 0x32, 0x38, 0x64, 0x64, 0x62, 0x64, 0x34, 0x30, 0x34, 0x34, 0x64, 0x36, 0x66, 0x66, 0x33, 0x34, 0x38, 0x33, 0x34, 0x37, 0x61, 0x61, 0x30, 0x39, 0x34, 0x32, 0x64, 0x31, 0x34, 0x31, 0x37, 0x34, 0x30, 0x30, 0x31, 0x36, 0x36, 0x66, 0x61, 0x65, 0x34, 0x35, 0x35, 0x35, 0x33, 0x38, 0x37, 0x32, 0x33, 0x35, 0x37, 0x62, 0x39, 0x62, 0x35, 0x38, 0x65, 0x39, 0x32, 0x31, 0x65, 0x62, 0x32, 0x36, 0x38, 0x37, 0x31, 0x30, 0x35, 0x39, 0x37, 0x34, 0x33, 0x33, 0x61, 0x30, 0x32, 0x32, 0x38, 0x30, 0x61, 0x35, 0x36, 0x32, 0x33, 0x64, 0x63, 0x61, 0x37, 0x32, 0x33, 0x35, 0x64, 0x64, 0x34, 0x39, 0x62, 0x39, 0x66, 0x65, 0x36, 0x65, 0x61, 0x30, 0x63, 0x64, 0x38, 0x36, 0x39, 0x39, 0x31, 0x38, 0x66, 0x36, 0x36, 0x64, 0x34, 0x64, 0x66, 0x39, 0x33, 0x62, 0x33, 0x61, 0x39, 0x34, 0x64, 0x62, 0x61, 0x61, 0x63, 0x30, 0x30, 0x61, 0x62, 0x62, 0x65, 0x66, 0x34, 0x32, 0x64, 0x30, 0x64, 0x33, 0x61, 0x33, 0x37, 0x37, 0x66, 0x65, 0x30, 0x34, 0x37, 0x32, 0x35, 0x36, 0x63, 0x65, 0x61, 0x66, 0x64, 0x64, 0x38, 0x65, 0x63, 0x36, 0x37, 0x61, 0x37, 0x37, 0x62, 0x36, 0x64, 0x66, 0x37, 0x39, 0x62, 0x37, 0x30, 0x61, 0x39, 0x33, 0x34, 0x35, 0x38, 0x33, 0x63, 0x38, 0x66, 0x32, 0x64, 0x38, 0x37, 0x63, 0x35, 0x34, 0x66, 0x33, 0x35, 0x30, 0x39, 0x33, 0x31, 0x64, 0x61, 0x31, 0x38, 0x63, 0x32, 0x39, 0x62, 0x65, 0x33, 0x38, 0x37, 0x39, 0x37, 0x32, 0x39, 0x38, 0x37, 0x37, 0x34, 0x64, 0x32, 0x32, 0x66, 0x38, 0x63, 0x36, 0x64, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x64, 0x30, 0x30, 0x61, 0x37, 0x30, 0x61, 0x39, 0x62, 0x65, 0x62, 0x39, 0x38, 0x65, 0x39, 0x30, 0x64, 0x63, 0x30, 0x62, 0x31, 0x39, 0x61, 0x63, 0x37, 0x32, 0x32, 0x65, 0x61, 0x33, 0x65, 0x61, 0x65, 0x35, 0x33, 0x35, 0x66, 0x37, 0x63, 0x36, 0x35, 0x37, 0x33, 0x31, 0x63, 0x62, 0x61, 0x63, 0x63, 0x66, 0x37, 0x66, 0x31, 0x31, 0x36, 0x36, 0x32, 0x34, 0x32, 0x31, 0x62, 0x34, 0x39, 0x33, 0x31, 0x32, 0x63, 0x39, 0x38, 0x35, 0x38, 0x65, 0x64, 0x32, 0x66, 0x66, 0x63, 0x61, 0x66, 0x66, 0x30, 0x30, 0x65, 0x61, 0x32, 0x61, 0x34, 0x63, 0x65, 0x65, 0x66, 0x32, 0x30, 0x65, 0x38, 0x38, 0x65, 0x36, 0x33, 0x31, 0x36, 0x63, 0x35, 0x64, 0x34, 0x31, 0x38, 0x35, 0x31, 0x32, 0x32, 0x36, 0x64, 0x35, 0x37, 0x35, 0x66, 0x37, 0x61, 0x33, 0x63, 0x64, 0x63, 0x39, 0x32, 0x63, 0x36, 0x31, 0x32, 0x64, 0x35, 0x34, 0x64, 0x66, 0x32, 0x37, 0x30, 0x30, 0x37, 0x34, 0x30, 0x33, 0x62, 0x62, 0x33, 0x66, 0x65, 0x36, 0x38, 0x35, 0x65, 0x30, 0x64, 0x37, 0x30, 0x61, 0x66, 0x65, 0x32, 0x61, 0x30, 0x39, 0x35, 0x30, 0x34, 0x30, 0x33, 0x33, 0x66, 0x30, 0x36, 0x37, 0x30, 0x39, 0x62, 0x31, 0x35, 0x63, 0x30, 0x62, 0x62, 0x66, 0x39, 0x36, 0x38, 0x30, 0x36, 0x35, 0x61, 0x64, 0x36, 0x35, 0x33, 0x35, 0x31, 0x30, 0x36, 0x30, 0x32, 0x32, 0x33, 0x66, 0x31, 0x30, 0x63, 0x63, 0x61, 0x37, 0x33, 0x38, 0x34, 0x62, 0x61, 0x33, 0x64, 0x61, 0x32, 0x38, 0x39, 0x36, 0x64, 0x30, 0x31, 0x32, 0x61, 0x61, 0x38, 0x61, 0x65, 0x37, 0x39, 0x39, 0x64, 0x31, 0x36, 0x36, 0x66, 0x34, 0x66, 0x31, 0x66, 0x30, 0x38, 0x30, 0x30, 0x64, 0x32, 0x62, 0x32, 0x34, 0x34, 0x35, 0x65, 0x66, 0x31, 0x61, 0x38, 0x61, 0x37, 0x31, 0x63, 0x62, 0x63, 0x34, 0x31, 0x35, 0x37, 0x35, 0x64, 0x33, 0x39, 0x63, 0x32, 0x32, 0x62, 0x38, 0x63, 0x36, 0x33, 0x35, 0x63, 0x37, 0x30, 0x36, 0x65, 0x37, 0x39, 0x31, 0x31, 0x34, 0x39, 0x38, 0x64, 0x63, 0x63, 0x66, 0x36, 0x65, 0x36, 0x37, 0x32, 0x33, 0x33, 0x38, 0x33, 0x61, 0x38, 0x65, 0x36, 0x31, 0x30, 0x62, 0x36, 0x64, 0x34, 0x62, 0x35, 0x30, 0x30, 0x39, 0x65, 0x63, 0x34, 0x65, 0x37, 0x65, 0x35, 0x39, 0x64, 0x63, 0x65, 0x38, 0x37, 0x38, 0x31, 0x36, 0x62, 0x37, 0x61, 0x31, 0x35, 0x65, 0x39, 0x38, 0x64, 0x66, 0x36, 0x31, 0x31, 0x30, 0x39, 0x37, 0x37, 0x66, 0x33, 0x32, 0x61, 0x38, 0x31, 0x66, 0x36, 0x33, 0x33, 0x37, 0x32, 0x37, 0x33, 0x36, 0x39, 0x65, 0x61, 0x36, 0x30, 0x35, 0x32, 0x31, 0x62, 0x64, 0x31, 0x64, 0x36, 0x39, 0x66, 0x62, 0x63, 0x39, 0x61, 0x37, 0x30, 0x64, 0x63, 0x62, 0x63, 0x63, 0x36, 0x61, 0x32, 0x62, 0x39, 0x31, 0x39, 0x62, 0x35, 0x34, 0x30, 0x34, 0x30, 0x37, 0x65, 0x63, 0x38, 0x66, 0x64, 0x34, 0x38, 0x61, 0x66, 0x61, 0x36, 0x33, 0x35, 0x66, 0x33, 0x65, 0x36, 0x63, 0x30, 0x31, 0x34, 0x30, 0x39, 0x37, 0x36, 0x30, 0x66, 0x36, 0x64, 0x34, 0x63, 0x66, 0x35, 0x61, 0x66, 0x38, 0x32, 0x36, 0x36, 0x62, 0x33, 0x63, 0x34, 0x63, 0x31, 0x32, 0x63, 0x33, 0x35, 0x39, 0x62, 0x62, 0x32, 0x66, 0x64, 0x35, 0x35, 0x66, 0x62, 0x65, 0x36, 0x31, 0x32, 0x32, 0x39, 0x62, 0x32, 0x34, 0x63, 0x36, 0x62, 0x34, 0x39, 0x38, 0x35, 0x37, 0x37, 0x34, 0x31, 0x30, 0x62, 0x39, 0x33, 0x30, 0x35, 0x34, 0x65, 0x31, 0x31, 0x63, 0x34, 0x63, 0x35, 0x66, 0x32, 0x61, 0x39, 0x39, 0x66, 0x66, 0x34, 0x38, 0x32, 0x65, 0x63, 0x35, 0x64, 0x38, 0x64, 0x31, 0x31, 0x36, 0x34, 0x65, 0x39, 0x61, 0x38, 0x33, 0x32, 0x63, 0x37, 0x30, 0x39, 0x33, 0x33, 0x39, 0x32, 0x37, 0x32, 0x37, 0x32, 0x30, 0x66, 0x30, 0x35, 0x65, 0x36, 0x38, 0x37, 0x62, 0x63, 0x30, 0x30, 0x64, 0x33, 0x62, 0x66, 0x37, 0x32, 0x35, 0x33, 0x38, 0x31, 0x64, 0x62, 0x64, 0x34, 0x33, 0x64, 0x38, 0x39, 0x61, 0x64, 0x38, 0x34, 0x38, 0x35, 0x36, 0x66, 0x65, 0x66, 0x32, 0x34, 0x32, 0x36, 0x66, 0x36, 0x64, 0x38, 0x37, 0x37, 0x39, 0x30, 0x37, 0x31, 0x33, 0x62, 0x39, 0x30, 0x31, 0x38, 0x34, 0x61, 0x30, 0x31, 0x66, 0x32, 0x62, 0x65, 0x33, 0x37, 0x31, 0x30, 0x37, 0x63, 0x36, 0x65, 0x39, 0x34, 0x64, 0x38, 0x33, 0x30, 0x38, 0x33, 0x39, 0x64, 0x39, 0x33, 0x66, 0x66, 0x61, 0x32, 0x61, 0x61, 0x64, 0x36, 0x61, 0x64, 0x31, 0x62, 0x34, 0x63, 0x36, 0x38, 0x37, 0x65, 0x63, 0x61, 0x32, 0x31, 0x39, 0x39, 0x39, 0x36, 0x35, 0x32, 0x65, 0x34, 0x34, 0x34, 0x39, 0x34, 0x61, 0x34, 0x66, 0x36, 0x63, 0x33, 0x37, 0x35, 0x37, 0x61, 0x35, 0x35, 0x65, 0x64, 0x32, 0x62, 0x33, 0x66, 0x35, 0x64, 0x36, 0x65, 0x31, 0x38, 0x33, 0x64, 0x33, 0x35, 0x64, 0x30, 0x66, 0x39, 0x38, 0x33, 0x33, 0x64, 0x66, 0x62, 0x32, 0x32, 0x61, 0x37, 0x62, 0x39, 0x36, 0x36, 0x32, 0x32, 0x33, 0x36, 0x64, 0x36, 0x62, 0x65, 0x36, 0x39, 0x38, 0x61, 0x31, 0x65, 0x65, 0x34, 0x36, 0x35, 0x36, 0x66, 0x61, 0x31, 0x30, 0x64, 0x33, 0x37, 0x32, 0x65, 0x36, 0x31, 0x32, 0x31, 0x30, 0x38, 0x35, 0x35, 0x61, 0x36, 0x34, 0x64, 0x33, 0x35, 0x36, 0x65, 0x34, 0x62, 0x61, 0x63, 0x34, 0x38, 0x36, 0x32, 0x30, 0x66, 0x62, 0x31, 0x34, 0x66, 0x31, 0x63, 0x63, 0x63, 0x30, 0x38, 0x65, 0x65, 0x65, 0x31, 0x64, 0x64, 0x36, 0x35, 0x64, 0x30, 0x30, 0x64, 0x32, 0x32, 0x34, 0x30, 0x61, 0x62, 0x34, 0x31, 0x30, 0x36, 0x62, 0x64, 0x39, 0x62, 0x34, 0x39, 0x62, 0x37, 0x33, 0x66, 0x33, 0x34, 0x30, 0x64, 0x66, 0x36, 0x31, 0x63, 0x37, 0x32, 0x33, 0x35, 0x37, 0x33, 0x38, 0x62, 0x62, 0x39, 0x37, 0x64, 0x32, 0x35, 0x34, 0x63, 0x64, 0x34, 0x66, 0x31, 0x34, 0x39, 0x62, 0x61, 0x64, 0x33, 0x63, 0x33, 0x61, 0x61, 0x35, 0x63, 0x66, 0x66, 0x37, 0x38, 0x61, 0x62, 0x63, 0x34, 0x30, 0x66, 0x36, 0x62, 0x38, 0x66, 0x62, 0x61, 0x62, 0x66, 0x34, 0x65, 0x62, 0x61, 0x33, 0x32, 0x39, 0x66, 0x39, 0x32, 0x39, 0x63, 0x32, 0x34, 0x37, 0x32, 0x63, 0x31, 0x35, 0x65, 0x37, 0x63, 0x62, 0x62, 0x65, 0x63, 0x62, 0x36, 0x32, 0x65, 0x62, 0x62, 0x63, 0x38, 0x36, 0x64, 0x66, 0x36, 0x33, 0x36, 0x30, 0x39, 0x34, 0x39, 0x36, 0x36, 0x63, 0x66, 0x62, 0x61, 0x34, 0x38, 0x30, 0x39, 0x31, 0x63, 0x65, 0x66, 0x39, 0x32, 0x33, 0x62, 0x66, 0x62, 0x63, 0x38, 0x34, 0x65, 0x38, 0x31, 0x62, 0x37, 0x34, 0x31, 0x61, 0x35, 0x37, 0x66, 0x35, 0x32, 0x39, 0x34, 0x61, 0x62, 0x62, 0x32, 0x36, 0x62, 0x62, 0x31, 0x31, 0x33, 0x36, 0x61, 0x37, 0x39, 0x65, 0x38, 0x33, 0x37, 0x63, 0x65, 0x39, 0x36, 0x33, 0x66, 0x38, 0x36, 0x62, 0x62, 0x64, 0x61, 0x32, 0x34, 0x66, 0x66, 0x62, 0x65, 0x33, 0x38, 0x37, 0x39, 0x64, 0x61, 0x38, 0x30, 0x34, 0x64, 0x61, 0x39, 0x63, 0x66, 0x66, 0x37, 0x31, 0x61, 0x35, 0x31, 0x39, 0x63, 0x64, 0x36, 0x37, 0x32, 0x39, 0x65, 0x31, 0x32, 0x62, 0x32, 0x62, 0x33, 0x38, 0x63, 0x33, 0x66, 0x35, 0x36, 0x39, 0x62, 0x31, 0x33, 0x61, 0x34, 0x65, 0x66, 0x30, 0x35, 0x32, 0x38, 0x32, 0x38, 0x64, 0x66, 0x32, 0x31, 0x64, 0x38, 0x65, 0x64, 0x33, 0x31, 0x33, 0x39, 0x63, 0x32, 0x38, 0x64, 0x35, 0x30, 0x31, 0x65, 0x34, 0x33, 0x62, 0x30, 0x33, 0x62, 0x65, 0x61, 0x36, 0x64, 0x35, 0x62, 0x32, 0x32, 0x37, 0x32, 0x36, 0x38, 0x37, 0x32, 0x31, 0x66, 0x38, 0x65, 0x35, 0x39, 0x38, 0x66, 0x62, 0x62, 0x63, 0x66, 0x65, 0x33, 0x39, 0x34, 0x32, 0x38, 0x65, 0x61, 0x30, 0x33, 0x37, 0x64, 0x63, 0x63, 0x32, 0x39, 0x35, 0x65, 0x62, 0x34, 0x61, 0x36, 0x33, 0x62, 0x37, 0x34, 0x61, 0x65, 0x62, 0x32, 0x38, 0x35, 0x33, 0x38, 0x34, 0x38, 0x38, 0x38, 0x35, 0x36, 0x37, 0x34, 0x32, 0x64, 0x64, 0x30, 0x33, 0x66, 0x66, 0x63, 0x32, 0x32, 0x38, 0x30, 0x64, 0x64, 0x65, 0x65, 0x38, 0x30, 0x64, 0x31, 0x65, 0x35, 0x37, 0x63, 0x30, 0x61, 0x36, 0x30, 0x35, 0x65, 0x33, 0x36, 0x66, 0x33, 0x63, 0x61, 0x34, 0x38, 0x36, 0x36, 0x62, 0x33, 0x61, 0x66, 0x64, 0x36, 0x38, 0x62, 0x65, 0x39, 0x34, 0x35, 0x38, 0x34, 0x66, 0x36, 0x36, 0x38, 0x64, 0x65, 0x62, 0x30, 0x38, 0x37, 0x61, 0x34, 0x62, 0x32, 0x30, 0x64, 0x65, 0x33, 0x37, 0x36, 0x39, 0x64, 0x63, 0x66, 0x39, 0x66, 0x32, 0x63, 0x30, 0x65, 0x66, 0x34, 0x33, 0x38, 0x64, 0x30, 0x31, 0x62, 0x31, 0x65, 0x35, 0x34, 0x35, 0x31, 0x66, 0x35, 0x66, 0x32, 0x33, 0x39, 0x34, 0x37, 0x36, 0x62, 0x61, 0x66, 0x63, 0x66, 0x35, 0x36, 0x65, 0x62, 0x36, 0x34, 0x35, 0x33, 0x34, 0x62, 0x65, 0x32, 0x30, 0x34, 0x61, 0x30, 0x37, 0x36, 0x36, 0x62, 0x36, 0x31, 0x31, 0x38, 0x30, 0x65, 0x31, 0x39, 0x33, 0x35, 0x65, 0x30, 0x30, 0x34, 0x62, 0x33, 0x30, 0x38, 0x30, 0x33, 0x65, 0x39, 0x32, 0x65, 0x37, 0x36, 0x61, 0x63, 0x33, 0x35, 0x38, 0x64, 0x38, 0x63, 0x37, 0x36, 0x66, 0x62, 0x33, 0x62, 0x65, 0x32, 0x38, 0x65, 0x61, 0x36, 0x37, 0x66, 0x62, 0x33, 0x39, 0x64, 0x31, 0x66, 0x65, 0x66, 0x33, 0x34, 0x38, 0x38, 0x36, 0x66, 0x30, 0x65, 0x37, 0x32, 0x38, 0x36, 0x65, 0x36, 0x35, 0x36, 0x34, 0x65, 0x32, 0x37, 0x36, 0x63, 0x34, 0x62, 0x65, 0x35, 0x38, 0x65, 0x37, 0x39, 0x36, 0x61, 0x39, 0x39, 0x30, 0x37, 0x64, 0x63, 0x35, 0x37, 0x61, 0x36, 0x61, 0x62, 0x33, 0x38, 0x63, 0x61, 0x66, 0x63, 0x63, 0x61, 0x39, 0x35, 0x31, 0x65, 0x30, 0x36, 0x37, 0x32, 0x62, 0x39, 0x62, 0x30, 0x33, 0x38, 0x38, 0x62, 0x37, 0x66, 0x34, 0x35, 0x37, 0x32, 0x39, 0x64, 0x64, 0x36, 0x66, 0x31, 0x63, 0x36, 0x38, 0x37, 0x61, 0x32, 0x34, 0x38, 0x36, 0x35, 0x62, 0x64, 0x64, 0x30, 0x38, 0x66, 0x63, 0x65, 0x66, 0x30, 0x38, 0x30, 0x66, 0x30, 0x30, 0x66, 0x31, 0x32, 0x32, 0x32, 0x37, 0x38, 0x63, 0x61, 0x65, 0x38, 0x38, 0x64, 0x33, 0x30, 0x62, 0x33, 0x33, 0x39, 0x31, 0x61, 0x32, 0x38, 0x63, 0x36, 0x63, 0x33, 0x62, 0x66, 0x32, 0x34, 0x37, 0x32, 0x30, 0x65, 0x32, 0x38, 0x36, 0x32, 0x30, 0x30, 0x38, 0x66, 0x38, 0x37, 0x35, 0x38, 0x30, 0x63, 0x33, 0x66, 0x35, 0x30, 0x61, 0x61, 0x39, 0x65, 0x62, 0x64, 0x62, 0x39, 0x35, 0x35, 0x30, 0x31, 0x66, 0x35, 0x62, 0x61, 0x65, 0x64, 0x61, 0x37, 0x34, 0x65, 0x37, 0x66, 0x31, 0x63, 0x64, 0x66, 0x36, 0x65, 0x66, 0x37, 0x36, 0x36, 0x66, 0x65, 0x39, 0x34, 0x65, 0x66, 0x61, 0x32, 0x36, 0x64, 0x37, 0x31, 0x32, 0x39, 0x36, 0x66, 0x33, 0x62, 0x39, 0x31, 0x32, 0x66, 0x35, 0x34, 0x63, 0x38, 0x32, 0x32, 0x37, 0x32, 0x38, 0x36, 0x38, 0x63, 0x38, 0x62, 0x32, 0x38, 0x63, 0x39, 0x39, 0x65, 0x33, 0x66, 0x32, 0x33, 0x32, 0x35, 0x37, 0x39, 0x30, 0x38, 0x66, 0x39, 0x30, 0x32, 0x38, 0x36, 0x66, 0x65, 0x65, 0x35, 0x38, 0x31, 0x62, 0x36, 0x64, 0x38, 0x32, 0x63, 0x61, 0x38, 0x31, 0x34, 0x33, 0x66, 0x31, 0x61, 0x37, 0x66, 0x36, 0x30, 0x38, 0x63, 0x64, 0x36, 0x38, 0x37, 0x34, 0x30, 0x31, 0x36, 0x31, 0x35, 0x35, 0x61, 0x36, 0x38, 0x64, 0x34, 0x37, 0x34, 0x37, 0x61, 0x38, 0x30, 0x37, 0x31, 0x61, 0x63, 0x66, 0x62, 0x34, 0x61, 0x65, 0x65, 0x61, 0x65, 0x38, 0x36, 0x36, 0x37, 0x35, 0x35, 0x64, 0x36, 0x30, 0x64, 0x38, 0x64, 0x30, 0x36, 0x35, 0x32, 0x33, 0x36, 0x37, 0x32, 0x32, 0x65, 0x39, 0x33, 0x31, 0x35, 0x38, 0x39, 0x61, 0x32, 0x35, 0x63, 0x38, 0x36, 0x38, 0x30, 0x31, 0x30, 0x34, 0x38, 0x38, 0x36, 0x64, 0x30, 0x66, 0x33, 0x62, 0x36, 0x63, 0x61, 0x61, 0x61, 0x37, 0x33, 0x32, 0x63, 0x30, 0x64, 0x31, 0x32, 0x64, 0x64, 0x36, 0x65, 0x31, 0x63, 0x30, 0x61, 0x65, 0x62, 0x33, 0x30, 0x63, 0x66, 0x32, 0x63, 0x65, 0x38, 0x36, 0x66, 0x34, 0x65, 0x37, 0x32, 0x61, 0x63, 0x38, 0x33, 0x36, 0x34, 0x31, 0x35, 0x62, 0x38, 0x64, 0x66, 0x30, 0x37, 0x34, 0x63, 0x64, 0x33, 0x33, 0x64, 0x34, 0x37, 0x32, 0x65, 0x36, 0x32, 0x37, 0x36, 0x38, 0x32, 0x36, 0x66, 0x36, 0x34, 0x35, 0x33, 0x32, 0x31, 0x63, 0x33, 0x34, 0x61, 0x61, 0x36, 0x33, 0x39, 0x36, 0x37, 0x37, 0x32, 0x61, 0x35, 0x35, 0x30, 0x64, 0x37, 0x38, 0x36, 0x33, 0x62, 0x33, 0x63, 0x37, 0x32, 0x64, 0x30, 0x37, 0x38, 0x35, 0x64, 0x30, 0x66, 0x32, 0x66, 0x37, 0x64, 0x63, 0x32, 0x32, 0x64, 0x37, 0x30, 0x64, 0x33, 0x39, 0x37, 0x33, 0x32, 0x36, 0x35, 0x38, 0x38, 0x36, 0x38, 0x33, 0x31, 0x38, 0x39, 0x36, 0x35, 0x32, 0x33, 0x61, 0x30, 0x30, 0x66, 0x66, 0x34, 0x63, 0x61, 0x38, 0x34, 0x35, 0x61, 0x64, 0x62, 0x37, 0x33, 0x33, 0x35, 0x32, 0x61, 0x65, 0x30, 0x31, 0x63, 0x32, 0x65, 0x31, 0x35, 0x35, 0x65, 0x35, 0x61, 0x31, 0x39, 0x30, 0x39, 0x66, 0x38, 0x63, 0x33, 0x31, 0x65, 0x36, 0x33, 0x66, 0x34, 0x62, 0x62, 0x31, 0x30, 0x61, 0x33, 0x64, 0x34, 0x38, 0x65, 0x66, 0x65, 0x37, 0x36, 0x37, 0x31, 0x65, 0x61, 0x63, 0x39, 0x38, 0x30, 0x37, 0x65, 0x62, 0x38, 0x36, 0x65, 0x32, 0x66, 0x38, 0x63, 0x64, 0x31, 0x62, 0x61, 0x32, 0x36, 0x62, 0x66, 0x39, 0x30, 0x31, 0x38, 0x34, 0x35, 0x39, 0x34, 0x62, 0x63, 0x61, 0x66, 0x32, 0x32, 0x32, 0x62, 0x63, 0x62, 0x61, 0x37, 0x35, 0x65, 0x37, 0x64, 0x63, 0x34, 0x62, 0x39, 0x32, 0x37, 0x37, 0x64, 0x38, 0x64, 0x31, 0x38, 0x64, 0x65, 0x39, 0x31, 0x33, 0x31, 0x62, 0x39, 0x63, 0x39, 0x63, 0x36, 0x62, 0x39, 0x32, 0x36, 0x65, 0x37, 0x63, 0x61, 0x38, 0x32, 0x62, 0x66, 0x35, 0x66, 0x63, 0x38, 0x61, 0x34, 0x34, 0x33, 0x33, 0x37, 0x37, 0x36, 0x36, 0x66, 0x36, 0x61, 0x65, 0x65, 0x39, 0x34, 0x34, 0x36, 0x61, 0x37, 0x34, 0x37, 0x39, 0x64, 0x34, 0x32, 0x65, 0x36, 0x37, 0x35, 0x37, 0x38, 0x39, 0x36, 0x65, 0x30, 0x66, 0x39, 0x64, 0x33, 0x31, 0x61, 0x63, 0x65, 0x61, 0x36, 0x38, 0x31, 0x30, 0x34, 0x34, 0x34, 0x30, 0x32, 0x61, 0x61, 0x65, 0x39, 0x35, 0x65, 0x37, 0x31, 0x65, 0x33, 0x32, 0x34, 0x33, 0x31, 0x37, 0x34, 0x64, 0x31, 0x64, 0x30, 0x63, 0x35, 0x37, 0x34, 0x37, 0x61, 0x38, 0x66, 0x64, 0x66, 0x66, 0x34, 0x63, 0x38, 0x61, 0x33, 0x34, 0x31, 0x39, 0x62, 0x30, 0x32, 0x34, 0x37, 0x64, 0x30, 0x66, 0x63, 0x35, 0x63, 0x66, 0x35, 0x31, 0x32, 0x33, 0x38, 0x39, 0x64, 0x39, 0x32, 0x32, 0x34, 0x65, 0x62, 0x64, 0x35, 0x30, 0x64, 0x65, 0x63, 0x33, 0x30, 0x63, 0x39, 0x39, 0x33, 0x36, 0x66, 0x38, 0x32, 0x64, 0x39, 0x66, 0x65, 0x66, 0x36, 0x36, 0x34, 0x32, 0x33, 0x31, 0x32, 0x30, 0x30, 0x34, 0x34, 0x65, 0x37, 0x39, 0x63, 0x61, 0x36, 0x34, 0x34, 0x35, 0x64, 0x30, 0x63, 0x63, 0x37, 0x31, 0x38, 0x39, 0x66, 0x63, 0x62, 0x65, 0x30, 0x37, 0x30, 0x36, 0x64, 0x62, 0x63, 0x30, 0x30, 0x34, 0x38, 0x30, 0x39, 0x61, 0x38, 0x36, 0x31, 0x35, 0x34, 0x65, 0x63, 0x38, 0x37, 0x37, 0x32, 0x65, 0x61, 0x65, 0x64, 0x65, 0x37, 0x66, 0x34, 0x37, 0x37, 0x37, 0x39, 0x30, 0x35, 0x37, 0x34, 0x34, 0x33, 0x31, 0x39, 0x61, 0x39, 0x61, 0x34, 0x62, 0x31, 0x61, 0x64, 0x63, 0x63, 0x39, 0x35, 0x62, 0x30, 0x34, 0x38, 0x36, 0x63, 0x39, 0x39, 0x38, 0x61, 0x62, 0x38, 0x31, 0x64, 0x35, 0x37, 0x39, 0x37, 0x62, 0x39, 0x63, 0x33, 0x66, 0x64, 0x64, 0x66, 0x31, 0x64, 0x35, 0x35, 0x30, 0x31, 0x66, 0x35, 0x61, 0x37, 0x63, 0x32, 0x33, 0x34, 0x33, 0x32, 0x63, 0x37, 0x62, 0x64, 0x33, 0x37, 0x66, 0x35, 0x64, 0x61, 0x35, 0x61, 0x64, 0x36, 0x33, 0x66, 0x39, 0x31, 0x35, 0x30, 0x36, 0x64, 0x62, 0x38, 0x61, 0x31, 0x62, 0x35, 0x38, 0x66, 0x62, 0x39, 0x66, 0x39, 0x65, 0x64, 0x38, 0x32, 0x39, 0x34, 0x34, 0x36, 0x31, 0x62, 0x62, 0x38, 0x64, 0x32, 0x33, 0x64, 0x33, 0x61, 0x31, 0x38, 0x35, 0x64, 0x65, 0x34, 0x33, 0x35, 0x65, 0x32, 0x31, 0x64, 0x33, 0x30, 0x37, 0x36, 0x61, 0x37, 0x61, 0x66, 0x66, 0x31, 0x33, 0x36, 0x33, 0x30, 0x66, 0x39, 0x33, 0x64, 0x63, 0x31, 0x38, 0x38, 0x61, 0x37, 0x38, 0x64, 0x65, 0x36, 0x39, 0x37, 0x39, 0x61, 0x35, 0x62, 0x61, 0x63, 0x33, 0x32, 0x62, 0x65, 0x33, 0x31, 0x39, 0x37, 0x35, 0x38, 0x39, 0x38, 0x65, 0x31, 0x33, 0x33, 0x35, 0x66, 0x35, 0x62, 0x62, 0x63, 0x38, 0x61, 0x38, 0x30, 0x32, 0x64, 0x61, 0x35, 0x61, 0x30, 0x33, 0x66, 0x35, 0x65, 0x39, 0x61, 0x39, 0x34, 0x36, 0x65, 0x30, 0x30, 0x66, 0x64, 0x35, 0x66, 0x35, 0x35, 0x36, 0x64, 0x66, 0x36, 0x61, 0x34, 0x38, 0x38, 0x37, 0x31, 0x32, 0x30, 0x32, 0x61, 0x62, 0x64, 0x36, 0x36, 0x31, 0x35, 0x32, 0x65, 0x32, 0x31, 0x63, 0x35, 0x35, 0x37, 0x63, 0x39, 0x37, 0x32, 0x39, 0x64, 0x37, 0x30, 0x31, 0x35, 0x37, 0x33, 0x63, 0x31, 0x37, 0x38, 0x34, 0x39, 0x35, 0x66, 0x62, 0x30, 0x39, 0x66, 0x37, 0x36, 0x62, 0x61, 0x38, 0x66, 0x38, 0x39, 0x38, 0x66, 0x38, 0x34, 0x64, 0x64, 0x32, 0x65, 0x61, 0x38, 0x38, 0x64, 0x62, 0x64, 0x36, 0x33, 0x64, 0x32, 0x39, 0x38, 0x61, 0x34, 0x33, 0x39, 0x35, 0x65, 0x37, 0x34, 0x39, 0x64, 0x62, 0x37, 0x62, 0x63, 0x37, 0x32, 0x36, 0x36, 0x36, 0x35, 0x65, 0x36, 0x61, 0x32, 0x38, 0x30, 0x30, 0x66, 0x39, 0x32, 0x32, 0x33, 0x63, 0x66, 0x37, 0x66, 0x33, 0x65, 0x65, 0x36, 0x61, 0x61, 0x30, 0x65, 0x30, 0x63, 0x63, 0x38, 0x30, 0x30, 0x66, 0x30, 0x66, 0x66, 0x65, 0x36, 0x65, 0x62, 0x62, 0x34, 0x65, 0x63, 0x61, 0x64, 0x30, 0x66, 0x39, 0x38, 0x62, 0x65, 0x30, 0x34, 0x64, 0x62, 0x32, 0x34, 0x32, 0x61, 0x36, 0x65, 0x63, 0x32, 0x33, 0x65, 0x63, 0x61, 0x61, 0x36, 0x61, 0x31, 0x63, 0x32, 0x34, 0x64, 0x62, 0x63, 0x61, 0x37, 0x37, 0x36, 0x36, 0x61, 0x61, 0x37, 0x30, 0x30, 0x66, 0x36, 0x65, 0x61, 0x66, 0x33, 0x66, 0x32, 0x65, 0x34, 0x39, 0x61, 0x35, 0x31, 0x37, 0x36, 0x63, 0x33, 0x62, 0x65, 0x65, 0x30, 0x64, 0x66, 0x38, 0x62, 0x30, 0x30, 0x32, 0x35, 0x30, 0x37, 0x34, 0x61, 0x39, 0x34, 0x36, 0x65, 0x36, 0x32, 0x65, 0x37, 0x37, 0x36, 0x66, 0x33, 0x31, 0x37, 0x34, 0x66, 0x64, 0x62, 0x31, 0x65, 0x39, 0x32, 0x35, 0x64, 0x61, 0x32, 0x63, 0x36, 0x32, 0x39, 0x62, 0x61, 0x34, 0x32, 0x32, 0x63, 0x35, 0x33, 0x34, 0x38, 0x66, 0x62, 0x38, 0x33, 0x63, 0x35, 0x62, 0x36, 0x39, 0x30, 0x35, 0x30, 0x64, 0x61, 0x64, 0x62, 0x65, 0x39, 0x62, 0x63, 0x35, 0x31, 0x38, 0x31, 0x65, 0x34, 0x32, 0x30, 0x33, 0x62, 0x63, 0x36, 0x38, 0x35, 0x65, 0x35, 0x66, 0x38, 0x34, 0x64, 0x62, 0x35, 0x32, 0x65, 0x32, 0x33, 0x34, 0x35, 0x38, 0x32, 0x65, 0x38, 0x38, 0x39, 0x36, 0x34, 0x32, 0x31, 0x37, 0x37, 0x66, 0x65, 0x63, 0x32, 0x62, 0x38, 0x33, 0x30, 0x61, 0x39, 0x30, 0x39, 0x66, 0x39, 0x36, 0x62, 0x30, 0x65, 0x63, 0x65, 0x36, 0x61, 0x32, 0x35, 0x31, 0x66, 0x37, 0x35, 0x37, 0x38, 0x37, 0x32, 0x63, 0x36, 0x63, 0x62, 0x33, 0x37, 0x38, 0x39, 0x63, 0x64, 0x34, 0x37, 0x63, 0x62, 0x61, 0x30, 0x37, 0x64, 0x39, 0x33, 0x66, 0x61, 0x37, 0x30, 0x65, 0x33, 0x33, 0x61, 0x63, 0x39, 0x37, 0x36, 0x64, 0x66, 0x35, 0x35, 0x37, 0x32, 0x36, 0x63, 0x31, 0x61, 0x63, 0x64, 0x39, 0x38, 0x65, 0x35, 0x32, 0x66, 0x39, 0x32, 0x63, 0x66, 0x65, 0x64, 0x32, 0x31, 0x65, 0x33, 0x33, 0x65, 0x37, 0x32, 0x31, 0x62, 0x66, 0x64, 0x64, 0x38, 0x31, 0x64, 0x34, 0x34, 0x35, 0x38, 0x63, 0x63, 0x65, 0x39, 0x66, 0x61, 0x64, 0x32, 0x35, 0x65, 0x35, 0x36, 0x35, 0x35, 0x37, 0x63, 0x37, 0x36, 0x33, 0x38, 0x38, 0x39, 0x64, 0x31, 0x36, 0x62, 0x37, 0x34, 0x66, 0x62, 0x30, 0x62, 0x64, 0x62, 0x31, 0x66, 0x39, 0x31, 0x38, 0x34, 0x33, 0x31, 0x63, 0x34, 0x35, 0x33, 0x64, 0x30, 0x39, 0x63, 0x35, 0x35, 0x65, 0x65, 0x61, 0x33, 0x66, 0x66, 0x66, 0x65, 0x66, 0x38, 0x64, 0x30, 0x30, 0x63, 0x62, 0x35, 0x37, 0x61, 0x64, 0x36, 0x64, 0x65, 0x34, 0x64, 0x61, 0x34, 0x38, 0x64, 0x35, 0x35, 0x61, 0x63, 0x66, 0x66, 0x39, 0x34, 0x34, 0x39, 0x66, 0x32, 0x32, 0x34, 0x39, 0x64, 0x65, 0x33, 0x64, 0x61, 0x63, 0x66, 0x30, 0x65, 0x31, 0x65, 0x39, 0x65, 0x62, 0x64, 0x36, 0x66, 0x64, 0x32, 0x37, 0x32, 0x61, 0x33, 0x66, 0x39, 0x61, 0x64, 0x31, 0x37, 0x35, 0x30, 0x36, 0x61, 0x64, 0x66, 0x35, 0x38, 0x33, 0x36, 0x36, 0x63, 0x61, 0x37, 0x36, 0x34, 0x31, 0x36, 0x61, 0x30, 0x66, 0x35, 0x66, 0x35, 0x39, 0x63, 0x62, 0x39, 0x38, 0x66, 0x61, 0x35, 0x64, 0x36, 0x35, 0x35, 0x39, 0x35, 0x39, 0x34, 0x62, 0x33, 0x37, 0x39, 0x35, 0x34, 0x30, 0x31, 0x39, 0x37, 0x31, 0x62, 0x37, 0x65, 0x37, 0x32, 0x66, 0x33, 0x64, 0x37, 0x62, 0x34, 0x36, 0x61, 0x62, 0x61, 0x31, 0x39, 0x65, 0x33, 0x31, 0x61, 0x37, 0x63, 0x33, 0x64, 0x61, 0x34, 0x35, 0x35, 0x66, 0x31, 0x64, 0x39, 0x31, 0x38, 0x61, 0x34, 0x62, 0x31, 0x64, 0x34, 0x61, 0x62, 0x37, 0x39, 0x65, 0x30, 0x65, 0x32, 0x66, 0x35, 0x64, 0x37, 0x34, 0x63, 0x38, 0x32, 0x32, 0x30, 0x62, 0x30, 0x66, 0x36, 0x64, 0x38, 0x62, 0x30, 0x37, 0x31, 0x34, 0x33, 0x39, 0x32, 0x33, 0x38, 0x34, 0x39, 0x35, 0x63, 0x35, 0x38, 0x64, 0x37, 0x39, 0x62, 0x32, 0x33, 0x37, 0x33, 0x32, 0x31, 0x61, 0x35, 0x62, 0x66, 0x39, 0x63, 0x63, 0x36, 0x37, 0x66, 0x30, 0x63, 0x36, 0x62, 0x33, 0x65, 0x33, 0x36, 0x38, 0x64, 0x36, 0x33, 0x62, 0x30, 0x33, 0x39, 0x38, 0x39, 0x37, 0x61, 0x37, 0x64, 0x39, 0x66, 0x39, 0x64, 0x30, 0x30, 0x31, 0x33, 0x35, 0x39, 0x64, 0x63, 0x33, 0x32, 0x64, 0x66, 0x65, 0x33, 0x31, 0x34, 0x38, 0x39, 0x32, 0x62, 0x37, 0x30, 0x35, 0x31, 0x61, 0x65, 0x64, 0x64, 0x30, 0x63, 0x64, 0x33, 0x39, 0x38, 0x32, 0x64, 0x30, 0x38, 0x37, 0x34, 0x36, 0x37, 0x34, 0x61, 0x34, 0x62, 0x32, 0x39, 0x37, 0x64, 0x38, 0x33, 0x37, 0x39, 0x62, 0x39, 0x36, 0x63, 0x35, 0x35, 0x62, 0x66, 0x32, 0x39, 0x32, 0x62, 0x38, 0x30, 0x37, 0x32, 0x33, 0x32, 0x38, 0x38, 0x36, 0x35, 0x31, 0x37, 0x37, 0x66, 0x63, 0x65, 0x37, 0x31, 0x35, 0x38, 0x39, 0x30, 0x63, 0x32, 0x37, 0x63, 0x37, 0x61, 0x64, 0x34, 0x62, 0x64, 0x30, 0x30, 0x38, 0x39, 0x65, 0x64, 0x61, 0x37, 0x31, 0x31, 0x65, 0x66, 0x32, 0x65, 0x30, 0x66, 0x66, 0x39, 0x37, 0x31, 0x36, 0x63, 0x62, 0x38, 0x66, 0x35, 0x30, 0x64, 0x63, 0x35, 0x35, 0x30, 0x32, 0x39, 0x37, 0x32, 0x65, 0x65, 0x35, 0x32, 0x64, 0x36, 0x37, 0x66, 0x35, 0x65, 0x34, 0x38, 0x31, 0x33, 0x39, 0x36, 0x66, 0x33, 0x63, 0x31, 0x33, 0x62, 0x64, 0x39, 0x35, 0x62, 0x32, 0x30, 0x36, 0x32, 0x37, 0x39, 0x37, 0x30, 0x36, 0x62, 0x65, 0x65, 0x65, 0x37, 0x32, 0x64, 0x65, 0x30, 0x65, 0x32, 0x66, 0x33, 0x63, 0x35, 0x30, 0x33, 0x34, 0x61, 0x37, 0x65, 0x31, 0x30, 0x31, 0x37, 0x34, 0x66, 0x30, 0x64, 0x36, 0x35, 0x38, 0x35, 0x32, 0x61, 0x34, 0x35, 0x61, 0x38, 0x64, 0x63, 0x34, 0x32, 0x32, 0x31, 0x39, 0x35, 0x34, 0x34, 0x61, 0x38, 0x62, 0x37, 0x38, 0x38, 0x36, 0x39, 0x37, 0x30, 0x34, 0x36, 0x39, 0x66, 0x32, 0x30, 0x36, 0x33, 0x35, 0x30, 0x38, 0x31, 0x66, 0x63, 0x35, 0x66, 0x64, 0x34, 0x30, 0x33, 0x64, 0x61, 0x32, 0x37, 0x35, 0x63, 0x63, 0x61, 0x34, 0x63, 0x63, 0x63, 0x35, 0x61, 0x66, 0x64, 0x30, 0x33, 0x63, 0x64, 0x30, 0x35, 0x33, 0x32, 0x38, 0x33, 0x65, 0x64, 0x39, 0x39, 0x63, 0x35, 0x36, 0x62, 0x36, 0x35, 0x39, 0x66, 0x61, 0x61, 0x62, 0x64, 0x32, 0x62, 0x35, 0x32, 0x39, 0x31, 0x35, 0x38, 0x62, 0x65, 0x34, 0x63, 0x33, 0x34, 0x61, 0x61, 0x66, 0x32, 0x30, 0x35, 0x61, 0x63, 0x65, 0x37, 0x39, 0x65, 0x32, 0x63, 0x38, 0x30, 0x38, 0x64, 0x65, 0x33, 0x30, 0x63, 0x65, 0x33, 0x62, 0x61, 0x65, 0x30, 0x65, 0x37, 0x33, 0x62, 0x65, 0x35, 0x33, 0x38, 0x64, 0x65, 0x66, 0x64, 0x31, 0x33, 0x33, 0x37, 0x62, 0x38, 0x66, 0x65, 0x34, 0x39, 0x32, 0x37, 0x36, 0x31, 0x65, 0x36, 0x33, 0x38, 0x39, 0x63, 0x31, 0x31, 0x38, 0x35, 0x33, 0x36, 0x61, 0x39, 0x66, 0x35, 0x36, 0x62, 0x31, 0x65, 0x63, 0x61, 0x61, 0x65, 0x30, 0x61, 0x38, 0x64, 0x63, 0x66, 0x31, 0x32, 0x32, 0x61, 0x63, 0x39, 0x33, 0x33, 0x30, 0x34, 0x66, 0x61, 0x63, 0x63, 0x65, 0x61, 0x31, 0x31, 0x61, 0x37, 0x37, 0x36, 0x62, 0x39, 0x34, 0x63, 0x39, 0x63, 0x37, 0x32, 0x63, 0x33, 0x32, 0x34, 0x39, 0x33, 0x31, 0x64, 0x38, 0x63, 0x32, 0x34, 0x30, 0x32, 0x34, 0x61, 0x31, 0x36, 0x32, 0x63, 0x35, 0x33, 0x35, 0x62, 0x66, 0x39, 0x64, 0x62, 0x61, 0x30, 0x35, 0x31, 0x61, 0x62, 0x37, 0x32, 0x35, 0x34, 0x31, 0x36, 0x33, 0x30, 0x31, 0x32, 0x37, 0x36, 0x35, 0x35, 0x37, 0x63, 0x33, 0x30, 0x32, 0x64, 0x38, 0x63, 0x31, 0x65, 0x31, 0x35, 0x37, 0x64, 0x63, 0x64, 0x30, 0x34, 0x65, 0x31, 0x36, 0x64, 0x62, 0x39, 0x65, 0x33, 0x65, 0x63, 0x37, 0x61, 0x39, 0x61, 0x64, 0x61, 0x34, 0x30, 0x63, 0x39, 0x66, 0x65, 0x31, 0x64, 0x33, 0x30, 0x37, 0x62, 0x33, 0x62, 0x34, 0x37, 0x37, 0x32, 0x34, 0x31, 0x39, 0x39, 0x31, 0x62, 0x35, 0x37, 0x61, 0x36, 0x35, 0x38, 0x30, 0x36, 0x34, 0x32, 0x65, 0x61, 0x31, 0x66, 0x38, 0x33, 0x31, 0x64, 0x37, 0x65, 0x33, 0x39, 0x32, 0x32, 0x36, 0x62, 0x65, 0x61, 0x35, 0x37, 0x65, 0x36, 0x37, 0x35, 0x37, 0x65, 0x32, 0x33, 0x32, 0x33, 0x64, 0x39, 0x37, 0x37, 0x62, 0x35, 0x35, 0x32, 0x66, 0x64, 0x36, 0x65, 0x64, 0x38, 0x35, 0x39, 0x37, 0x32, 0x33, 0x31, 0x62, 0x36, 0x61, 0x63, 0x36, 0x61, 0x64, 0x62, 0x37, 0x30, 0x35, 0x30, 0x39, 0x62, 0x30, 0x64, 0x34, 0x32, 0x65, 0x63, 0x33, 0x63, 0x65, 0x62, 0x62, 0x66, 0x31, 0x31, 0x64, 0x64, 0x32, 0x35, 0x39, 0x34, 0x62, 0x32, 0x38, 0x63, 0x31, 0x34, 0x33, 0x61, 0x37, 0x39, 0x33, 0x39, 0x36, 0x34, 0x37, 0x61, 0x66, 0x39, 0x30, 0x31, 0x63, 0x33, 0x66, 0x30, 0x30, 0x37, 0x37, 0x32, 0x61, 0x36, 0x62, 0x31, 0x36, 0x35, 0x66, 0x62, 0x36, 0x66, 0x34, 0x30, 0x65, 0x37, 0x32, 0x32, 0x61, 0x39, 0x63, 0x39, 0x32, 0x34, 0x61, 0x61, 0x30, 0x34, 0x61, 0x61, 0x64, 0x64, 0x34, 0x34, 0x39, 0x61, 0x61, 0x66, 0x62, 0x35, 0x31, 0x33, 0x64, 0x62, 0x62, 0x35, 0x62, 0x36, 0x33, 0x31, 0x34, 0x31, 0x63, 0x65, 0x36, 0x30, 0x34, 0x31, 0x66, 0x31, 0x38, 0x66, 0x38, 0x66, 0x37, 0x32, 0x33, 0x38, 0x37, 0x64, 0x39, 0x65, 0x34, 0x34, 0x35, 0x65, 0x64, 0x63, 0x37, 0x32, 0x62, 0x37, 0x62, 0x39, 0x32, 0x39, 0x63, 0x38, 0x64, 0x65, 0x64, 0x36, 0x34, 0x33, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x66, 0x32, 0x39, 0x31, 0x36, 0x39, 0x37, 0x62, 0x66, 0x31, 0x64, 0x64, 0x32, 0x37, 0x38, 0x37, 0x33, 0x37, 0x62, 0x38, 0x65, 0x63, 0x63, 0x30, 0x33, 0x31, 0x30, 0x30, 0x39, 0x33, 0x36, 0x65, 0x64, 0x65, 0x37, 0x33, 0x63, 0x61, 0x39, 0x61, 0x35, 0x39, 0x32, 0x30, 0x63, 0x63, 0x34, 0x61, 0x36, 0x39, 0x32, 0x39, 0x32, 0x38, 0x32, 0x39, 0x33, 0x39, 0x33, 0x36, 0x64, 0x33, 0x31, 0x38, 0x31, 0x62, 0x39, 0x38, 0x35, 0x30, 0x32, 0x34, 0x64, 0x64, 0x30, 0x31, 0x61, 0x39, 0x30, 0x30, 0x32, 0x37, 0x33, 0x36, 0x35, 0x35, 0x34, 0x36, 0x66, 0x36, 0x65, 0x36, 0x34, 0x39, 0x32, 0x33, 0x66, 0x66, 0x61, 0x35, 0x61, 0x62, 0x34, 0x37, 0x30, 0x66, 0x31, 0x39, 0x38, 0x30, 0x66, 0x38, 0x37, 0x34, 0x37, 0x38, 0x30, 0x37, 0x31, 0x32, 0x61, 0x64, 0x61, 0x38, 0x30, 0x30, 0x31, 0x39, 0x39, 0x32, 0x38, 0x36, 0x64, 0x36, 0x63, 0x37, 0x37, 0x39, 0x66, 0x33, 0x66, 0x66, 0x30, 0x66, 0x61, 0x35, 0x30, 0x64, 0x37, 0x61, 0x66, 0x63, 0x65, 0x66, 0x64, 0x37, 0x32, 0x30, 0x32, 0x66, 0x31, 0x62, 0x30, 0x65, 0x31, 0x33, 0x64, 0x62, 0x63, 0x63, 0x64, 0x31, 0x35, 0x61, 0x65, 0x35, 0x61, 0x32, 0x39, 0x62, 0x35, 0x62, 0x36, 0x34, 0x66, 0x33, 0x37, 0x61, 0x30, 0x30, 0x62, 0x37, 0x61, 0x34, 0x38, 0x61, 0x66, 0x39, 0x37, 0x37, 0x38, 0x31, 0x37, 0x33, 0x62, 0x61, 0x64, 0x61, 0x61, 0x39, 0x61, 0x32, 0x33, 0x31, 0x63, 0x36, 0x61, 0x38, 0x31, 0x37, 0x32, 0x65, 0x38, 0x35, 0x63, 0x37, 0x39, 0x31, 0x39, 0x37, 0x64, 0x36, 0x37, 0x64, 0x63, 0x37, 0x32, 0x62, 0x65, 0x64, 0x65, 0x36, 0x39, 0x35, 0x38, 0x61, 0x35, 0x66, 0x66, 0x36, 0x61, 0x30, 0x36, 0x38, 0x33, 0x62, 0x63, 0x31, 0x38, 0x66, 0x65, 0x30, 0x31, 0x33, 0x62, 0x62, 0x61, 0x65, 0x32, 0x63, 0x39, 0x31, 0x63, 0x61, 0x64, 0x35, 0x33, 0x64, 0x61, 0x35, 0x35, 0x65, 0x64, 0x37, 0x32, 0x31, 0x66, 0x64, 0x66, 0x66, 0x39, 0x62, 0x35, 0x65, 0x35, 0x39, 0x31, 0x66, 0x33, 0x65, 0x66, 0x38, 0x61, 0x31, 0x39, 0x32, 0x61, 0x61, 0x63, 0x34, 0x34, 0x30, 0x66, 0x66, 0x34, 0x61, 0x33, 0x66, 0x31, 0x38, 0x64, 0x31, 0x30, 0x61, 0x31, 0x36, 0x34, 0x63, 0x36, 0x34, 0x37, 0x66, 0x64, 0x38, 0x36, 0x66, 0x65, 0x63, 0x62, 0x61, 0x38, 0x38, 0x63, 0x36, 0x36, 0x62, 0x39, 0x37, 0x32, 0x37, 0x38, 0x32, 0x31, 0x32, 0x30, 0x36, 0x62, 0x33, 0x37, 0x64, 0x38, 0x33, 0x33, 0x66, 0x66, 0x35, 0x39, 0x39, 0x35, 0x39, 0x37, 0x64, 0x31, 0x63, 0x66, 0x62, 0x33, 0x32, 0x33, 0x39, 0x39, 0x39, 0x35, 0x61, 0x37, 0x62, 0x36, 0x66, 0x31, 0x35, 0x63, 0x65, 0x37, 0x62, 0x65, 0x61, 0x66, 0x62, 0x65, 0x61, 0x61, 0x37, 0x36, 0x39, 0x33, 0x35, 0x61, 0x34, 0x64, 0x34, 0x65, 0x33, 0x39, 0x66, 0x61, 0x31, 0x31, 0x34, 0x64, 0x65, 0x31, 0x34, 0x63, 0x36, 0x32, 0x66, 0x34, 0x39, 0x36, 0x35, 0x34, 0x63, 0x37, 0x33, 0x66, 0x30, 0x33, 0x65, 0x30, 0x30, 0x34, 0x64, 0x65, 0x36, 0x37, 0x33, 0x32, 0x65, 0x65, 0x35, 0x33, 0x63, 0x30, 0x33, 0x38, 0x37, 0x35, 0x38, 0x31, 0x66, 0x30, 0x63, 0x38, 0x36, 0x39, 0x31, 0x65, 0x31, 0x35, 0x39, 0x36, 0x38, 0x37, 0x65, 0x65, 0x32, 0x63, 0x36, 0x65, 0x37, 0x30, 0x30, 0x30, 0x64, 0x35, 0x35, 0x37, 0x32, 0x65, 0x37, 0x64, 0x66, 0x62, 0x64, 0x33, 0x39, 0x35, 0x35, 0x35, 0x66, 0x64, 0x61, 0x31, 0x62, 0x33, 0x36, 0x63, 0x37, 0x65, 0x34, 0x31, 0x32, 0x36, 0x63, 0x62, 0x66, 0x36, 0x66, 0x36, 0x32, 0x32, 0x66, 0x36, 0x34, 0x38, 0x66, 0x32, 0x62, 0x32, 0x31, 0x64, 0x38, 0x31, 0x64, 0x66, 0x61, 0x65, 0x36, 0x38, 0x37, 0x32, 0x38, 0x32, 0x31, 0x38, 0x38, 0x34, 0x34, 0x35, 0x66, 0x37, 0x35, 0x61, 0x61, 0x33, 0x35, 0x30, 0x33, 0x37, 0x30, 0x32, 0x32, 0x30, 0x36, 0x37, 0x62, 0x30, 0x32, 0x63, 0x31, 0x35, 0x65, 0x34, 0x33, 0x37, 0x33, 0x31, 0x31, 0x36, 0x64, 0x32, 0x65, 0x65, 0x39, 0x62, 0x31, 0x63, 0x30, 0x31, 0x65, 0x63, 0x63, 0x35, 0x61, 0x65, 0x34, 0x39, 0x36, 0x37, 0x65, 0x34, 0x31, 0x64, 0x31, 0x37, 0x64, 0x30, 0x33, 0x38, 0x36, 0x64, 0x35, 0x66, 0x66, 0x37, 0x61, 0x30, 0x33, 0x61, 0x61, 0x61, 0x32, 0x63, 0x66, 0x62, 0x62, 0x35, 0x37, 0x31, 0x61, 0x30, 0x62, 0x66, 0x33, 0x65, 0x61, 0x61, 0x66, 0x62, 0x35, 0x39, 0x66, 0x35, 0x34, 0x37, 0x61, 0x32, 0x32, 0x65, 0x35, 0x62, 0x38, 0x37, 0x66, 0x61, 0x64, 0x35, 0x30, 0x34, 0x63, 0x31, 0x35, 0x32, 0x64, 0x32, 0x37, 0x32, 0x35, 0x38, 0x34, 0x61, 0x35, 0x65, 0x32, 0x61, 0x35, 0x31, 0x66, 0x32, 0x38, 0x31, 0x30, 0x32, 0x63, 0x62, 0x30, 0x35, 0x64, 0x62, 0x66, 0x63, 0x37, 0x35, 0x63, 0x62, 0x32, 0x63, 0x35, 0x37, 0x30, 0x31, 0x65, 0x31, 0x38, 0x35, 0x34, 0x62, 0x32, 0x36, 0x65, 0x63, 0x33, 0x39, 0x65, 0x34, 0x39, 0x31, 0x37, 0x34, 0x64, 0x31, 0x62, 0x38, 0x37, 0x61, 0x61, 0x33, 0x66, 0x32, 0x66, 0x65, 0x36, 0x34, 0x37, 0x64, 0x38, 0x39, 0x37, 0x66, 0x37, 0x63, 0x33, 0x34, 0x61, 0x36, 0x39, 0x64, 0x30, 0x34, 0x39, 0x32, 0x36, 0x33, 0x36, 0x31, 0x65, 0x36, 0x30, 0x31, 0x32, 0x31, 0x30, 0x63, 0x35, 0x61, 0x31, 0x32, 0x37, 0x66, 0x63, 0x37, 0x32, 0x61, 0x31, 0x36, 0x64, 0x64, 0x66, 0x30, 0x32, 0x32, 0x35, 0x37, 0x33, 0x37, 0x63, 0x37, 0x61, 0x61, 0x62, 0x30, 0x61, 0x64, 0x64, 0x30, 0x34, 0x32, 0x39, 0x37, 0x35, 0x34, 0x63, 0x63, 0x37, 0x35, 0x30, 0x62, 0x32, 0x39, 0x62, 0x62, 0x33, 0x66, 0x33, 0x64, 0x64, 0x31, 0x66, 0x39, 0x39, 0x38, 0x31, 0x33, 0x63, 0x64, 0x35, 0x39, 0x30, 0x64, 0x62, 0x66, 0x62, 0x31, 0x32, 0x35, 0x30, 0x31, 0x62, 0x31, 0x62, 0x66, 0x39, 0x66, 0x38, 0x65, 0x33, 0x63, 0x37, 0x38, 0x62, 0x38, 0x38, 0x34, 0x66, 0x31, 0x39, 0x65, 0x35, 0x62, 0x37, 0x32, 0x39, 0x35, 0x32, 0x64, 0x61, 0x66, 0x33, 0x32, 0x63, 0x38, 0x62, 0x65, 0x32, 0x35, 0x39, 0x63, 0x34, 0x37, 0x35, 0x36, 0x38, 0x37, 0x61, 0x32, 0x64, 0x35, 0x35, 0x32, 0x38, 0x37, 0x66, 0x31, 0x38, 0x64, 0x64, 0x38, 0x34, 0x34, 0x64, 0x33, 0x63, 0x64, 0x38, 0x39, 0x35, 0x62, 0x38, 0x36, 0x34, 0x66, 0x30, 0x37, 0x61, 0x61, 0x64, 0x35, 0x64, 0x30, 0x36, 0x63, 0x35, 0x30, 0x37, 0x32, 0x64, 0x35, 0x63, 0x35, 0x38, 0x34, 0x63, 0x31, 0x65, 0x38, 0x66, 0x33, 0x32, 0x39, 0x34, 0x39, 0x65, 0x62, 0x65, 0x38, 0x35, 0x38, 0x32, 0x66, 0x61, 0x31, 0x39, 0x65, 0x31, 0x36, 0x65, 0x32, 0x65, 0x35, 0x38, 0x32, 0x31, 0x35, 0x66, 0x35, 0x61, 0x36, 0x63, 0x32, 0x32, 0x35, 0x63, 0x37, 0x63, 0x64, 0x36, 0x63, 0x31, 0x34, 0x63, 0x37, 0x37, 0x39, 0x64, 0x38, 0x64, 0x36, 0x37, 0x32, 0x33, 0x31, 0x37, 0x37, 0x37, 0x33, 0x31, 0x62, 0x63, 0x66, 0x34, 0x33, 0x39, 0x62, 0x35, 0x39, 0x63, 0x35, 0x64, 0x30, 0x61, 0x36, 0x37, 0x35, 0x35, 0x39, 0x64, 0x65, 0x61, 0x38, 0x66, 0x66, 0x61, 0x30, 0x32, 0x36, 0x30, 0x30, 0x66, 0x38, 0x62, 0x30, 0x66, 0x32, 0x66, 0x33, 0x38, 0x32, 0x34, 0x66, 0x34, 0x33, 0x36, 0x61, 0x32, 0x32, 0x32, 0x35, 0x32, 0x66, 0x31, 0x38, 0x36, 0x66, 0x38, 0x34, 0x63, 0x66, 0x38, 0x65, 0x32, 0x35, 0x35, 0x30, 0x36, 0x32, 0x34, 0x62, 0x32, 0x66, 0x31, 0x64, 0x33, 0x32, 0x32, 0x37, 0x30, 0x31, 0x61, 0x36, 0x39, 0x66, 0x31, 0x38, 0x66, 0x62, 0x62, 0x34, 0x62, 0x30, 0x38, 0x31, 0x62, 0x30, 0x38, 0x61, 0x66, 0x65, 0x30, 0x39, 0x30, 0x38, 0x34, 0x31, 0x37, 0x31, 0x31, 0x61, 0x34, 0x32, 0x34, 0x35, 0x63, 0x66, 0x61, 0x35, 0x37, 0x32, 0x32, 0x35, 0x36, 0x66, 0x36, 0x65, 0x35, 0x38, 0x36, 0x65, 0x63, 0x65, 0x32, 0x32, 0x65, 0x64, 0x33, 0x30, 0x61, 0x36, 0x37, 0x37, 0x39, 0x32, 0x61, 0x38, 0x34, 0x38, 0x62, 0x33, 0x34, 0x39, 0x31, 0x35, 0x38, 0x64, 0x38, 0x66, 0x63, 0x37, 0x65, 0x62, 0x63, 0x30, 0x37, 0x63, 0x35, 0x36, 0x63, 0x33, 0x30, 0x32, 0x63, 0x62, 0x36, 0x66, 0x37, 0x36, 0x63, 0x36, 0x35, 0x66, 0x32, 0x33, 0x62, 0x64, 0x38, 0x66, 0x34, 0x38, 0x38, 0x61, 0x63, 0x30, 0x66, 0x37, 0x34, 0x65, 0x35, 0x37, 0x35, 0x66, 0x62, 0x63, 0x61, 0x33, 0x61, 0x32, 0x31, 0x63, 0x36, 0x65, 0x37, 0x31, 0x35, 0x33, 0x31, 0x36, 0x61, 0x31, 0x31, 0x61, 0x38, 0x37, 0x62, 0x39, 0x65, 0x34, 0x34, 0x39, 0x63, 0x34, 0x33, 0x32, 0x31, 0x34, 0x36, 0x62, 0x34, 0x34, 0x62, 0x33, 0x65, 0x63, 0x36, 0x35, 0x32, 0x64, 0x35, 0x62, 0x30, 0x39, 0x37, 0x30, 0x39, 0x61, 0x62, 0x61, 0x65, 0x65, 0x37, 0x32, 0x35, 0x65, 0x62, 0x37, 0x39, 0x37, 0x31, 0x61, 0x36, 0x34, 0x62, 0x37, 0x33, 0x65, 0x64, 0x65, 0x61, 0x36, 0x30, 0x35, 0x39, 0x36, 0x30, 0x65, 0x66, 0x30, 0x65, 0x65, 0x30, 0x65, 0x65, 0x38, 0x38, 0x37, 0x30, 0x39, 0x39, 0x30, 0x37, 0x34, 0x35, 0x63, 0x30, 0x31, 0x39, 0x64, 0x39, 0x31, 0x31, 0x34, 0x37, 0x30, 0x37, 0x39, 0x65, 0x33, 0x30, 0x32, 0x37, 0x34, 0x30, 0x33, 0x36, 0x34, 0x31, 0x34, 0x37, 0x65, 0x35, 0x63, 0x38, 0x63, 0x64, 0x63, 0x66, 0x31, 0x61, 0x61, 0x38, 0x35, 0x34, 0x33, 0x31, 0x64, 0x32, 0x30, 0x39, 0x63, 0x64, 0x37, 0x37, 0x37, 0x38, 0x37, 0x63, 0x36, 0x64, 0x32, 0x64, 0x39, 0x31, 0x63, 0x31, 0x65, 0x39, 0x39, 0x38, 0x63, 0x38, 0x62, 0x62, 0x64, 0x37, 0x32, 0x31, 0x66, 0x37, 0x34, 0x61, 0x32, 0x34, 0x62, 0x61, 0x32, 0x37, 0x38, 0x64, 0x62, 0x34, 0x63, 0x65, 0x62, 0x64, 0x62, 0x36, 0x38, 0x37, 0x37, 0x65, 0x61, 0x30, 0x31, 0x30, 0x62, 0x63, 0x62, 0x33, 0x30, 0x62, 0x65, 0x32, 0x65, 0x38, 0x64, 0x38, 0x35, 0x65, 0x66, 0x31, 0x30, 0x33, 0x30, 0x64, 0x32, 0x65, 0x62, 0x61, 0x62, 0x35, 0x39, 0x35, 0x37, 0x66, 0x31, 0x37, 0x37, 0x37, 0x32, 0x37, 0x39, 0x35, 0x35, 0x62, 0x62, 0x63, 0x63, 0x34, 0x36, 0x62, 0x65, 0x32, 0x63, 0x64, 0x33, 0x33, 0x62, 0x37, 0x63, 0x63, 0x62, 0x34, 0x36, 0x61, 0x32, 0x31, 0x65, 0x36, 0x61, 0x32, 0x36, 0x36, 0x38, 0x66, 0x39, 0x37, 0x37, 0x33, 0x33, 0x32, 0x65, 0x36, 0x35, 0x33, 0x63, 0x35, 0x64, 0x38, 0x31, 0x63, 0x38, 0x38, 0x64, 0x62, 0x37, 0x65, 0x36, 0x62, 0x39, 0x35, 0x65, 0x37, 0x32, 0x35, 0x32, 0x36, 0x34, 0x62, 0x35, 0x39, 0x38, 0x32, 0x35, 0x64, 0x34, 0x61, 0x34, 0x31, 0x33, 0x30, 0x62, 0x30, 0x66, 0x34, 0x64, 0x35, 0x30, 0x31, 0x32, 0x63, 0x62, 0x63, 0x33, 0x30, 0x64, 0x66, 0x32, 0x34, 0x37, 0x34, 0x35, 0x62, 0x32, 0x61, 0x66, 0x30, 0x38, 0x39, 0x66, 0x39, 0x35, 0x35, 0x63, 0x65, 0x32, 0x32, 0x35, 0x39, 0x66, 0x64, 0x37, 0x35, 0x36, 0x36, 0x30, 0x32, 0x36, 0x62, 0x36, 0x65, 0x35, 0x61, 0x65, 0x36, 0x33, 0x63, 0x65, 0x33, 0x64, 0x35, 0x33, 0x31, 0x32, 0x38, 0x64, 0x61, 0x37, 0x64, 0x30, 0x31, 0x35, 0x31, 0x34, 0x33, 0x66, 0x63, 0x64, 0x62, 0x32, 0x30, 0x66, 0x35, 0x31, 0x65, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x30, 0x64, 0x35, 0x63, 0x30, 0x66, 0x37, 0x36, 0x35, 0x30, 0x61, 0x31, 0x33, 0x36, 0x66, 0x33, 0x38, 0x39, 0x64, 0x36, 0x30, 0x65, 0x35, 0x61, 0x61, 0x61, 0x61, 0x34, 0x35, 0x39, 0x63, 0x62, 0x35, 0x39, 0x32, 0x31, 0x38, 0x64, 0x32, 0x30, 0x35, 0x64, 0x30, 0x31, 0x32, 0x38, 0x63, 0x63, 0x30, 0x63, 0x31, 0x36, 0x65, 0x30, 0x38, 0x66, 0x65, 0x37, 0x66, 0x34, 0x38, 0x66, 0x33, 0x38, 0x33, 0x64, 0x66, 0x62, 0x66, 0x61, 0x35, 0x61, 0x38, 0x35, 0x37, 0x66, 0x64, 0x33, 0x62, 0x66, 0x32, 0x33, 0x61, 0x37, 0x32, 0x64, 0x39, 0x65, 0x63, 0x32, 0x63, 0x31, 0x33, 0x33, 0x37, 0x35, 0x37, 0x39, 0x39, 0x66, 0x38, 0x31, 0x62, 0x34, 0x35, 0x35, 0x64, 0x31, 0x35, 0x63, 0x64, 0x62, 0x36, 0x36, 0x63, 0x30, 0x30, 0x36, 0x38, 0x65, 0x65, 0x62, 0x33, 0x30, 0x65, 0x65, 0x66, 0x32, 0x64, 0x31, 0x64, 0x37, 0x64, 0x39, 0x37, 0x66, 0x31, 0x31, 0x62, 0x61, 0x35, 0x32, 0x31, 0x30, 0x66, 0x37, 0x65, 0x37, 0x32, 0x66, 0x30, 0x36, 0x34, 0x30, 0x64, 0x35, 0x66, 0x32, 0x37, 0x39, 0x30, 0x30, 0x66, 0x33, 0x64, 0x38, 0x36, 0x61, 0x36, 0x63, 0x30, 0x61, 0x66, 0x65, 0x32, 0x30, 0x37, 0x35, 0x35, 0x33, 0x62, 0x66, 0x62, 0x63, 0x34, 0x38, 0x30, 0x64, 0x39, 0x65, 0x38, 0x34, 0x65, 0x30, 0x34, 0x65, 0x64, 0x62, 0x66, 0x31, 0x66, 0x38, 0x63, 0x39, 0x66, 0x65, 0x64, 0x37, 0x30, 0x32, 0x35, 0x33, 0x31, 0x34, 0x35, 0x37, 0x37, 0x66, 0x30, 0x30, 0x30, 0x33, 0x39, 0x39, 0x64, 0x36, 0x64, 0x66, 0x30, 0x66, 0x66, 0x34, 0x66, 0x39, 0x32, 0x63, 0x64, 0x39, 0x31, 0x38, 0x37, 0x31, 0x31, 0x37, 0x37, 0x38, 0x61, 0x31, 0x63, 0x31, 0x66, 0x39, 0x33, 0x66, 0x34, 0x34, 0x35, 0x34, 0x33, 0x66, 0x66, 0x63, 0x31, 0x33, 0x31, 0x39, 0x66, 0x62, 0x34, 0x62, 0x62, 0x35, 0x62, 0x30, 0x66, 0x33, 0x30, 0x66, 0x32, 0x36, 0x63, 0x32, 0x34, 0x36, 0x62, 0x66, 0x30, 0x62, 0x66, 0x66, 0x35, 0x66, 0x35, 0x31, 0x64, 0x35, 0x62, 0x63, 0x38, 0x61, 0x33, 0x37, 0x30, 0x35, 0x35, 0x61, 0x66, 0x65, 0x33, 0x32, 0x30, 0x66, 0x38, 0x39, 0x61, 0x64, 0x35, 0x37, 0x39, 0x63, 0x66, 0x62, 0x34, 0x37, 0x33, 0x66, 0x31, 0x64, 0x65, 0x64, 0x33, 0x34, 0x38, 0x36, 0x34, 0x30, 0x66, 0x64, 0x36, 0x37, 0x32, 0x31, 0x34, 0x38, 0x35, 0x30, 0x66, 0x37, 0x64, 0x63, 0x30, 0x33, 0x39, 0x66, 0x64, 0x36, 0x62, 0x65, 0x39, 0x61, 0x63, 0x37, 0x61, 0x64, 0x34, 0x36, 0x32, 0x66, 0x62, 0x66, 0x62, 0x32, 0x35, 0x34, 0x34, 0x30, 0x38, 0x36, 0x63, 0x32, 0x37, 0x33, 0x38, 0x32, 0x31, 0x66, 0x30, 0x63, 0x37, 0x37, 0x34, 0x61, 0x36, 0x64, 0x65, 0x36, 0x38, 0x32, 0x65, 0x63, 0x33, 0x33, 0x30, 0x37, 0x32, 0x34, 0x32, 0x36, 0x34, 0x61, 0x62, 0x34, 0x31, 0x37, 0x31, 0x31, 0x37, 0x32, 0x39, 0x62, 0x61, 0x64, 0x37, 0x66, 0x34, 0x37, 0x39, 0x34, 0x64, 0x37, 0x38, 0x62, 0x38, 0x36, 0x39, 0x33, 0x64, 0x32, 0x65, 0x66, 0x35, 0x39, 0x61, 0x31, 0x64, 0x39, 0x36, 0x33, 0x33, 0x36, 0x61, 0x66, 0x33, 0x64, 0x34, 0x39, 0x38, 0x65, 0x36, 0x38, 0x33, 0x35, 0x38, 0x38, 0x36, 0x36, 0x36, 0x31, 0x33, 0x34, 0x39, 0x38, 0x66, 0x35, 0x39, 0x64, 0x65, 0x62, 0x66, 0x38, 0x38, 0x66, 0x61, 0x33, 0x36, 0x65, 0x61, 0x34, 0x37, 0x30, 0x63, 0x38, 0x38, 0x39, 0x36, 0x37, 0x61, 0x36, 0x62, 0x63, 0x63, 0x63, 0x32, 0x39, 0x31, 0x39, 0x35, 0x37, 0x31, 0x36, 0x32, 0x65, 0x34, 0x38, 0x38, 0x33, 0x65, 0x30, 0x66, 0x65, 0x31, 0x37, 0x33, 0x34, 0x34, 0x39, 0x61, 0x35, 0x62, 0x61, 0x31, 0x33, 0x63, 0x63, 0x36, 0x37, 0x61, 0x66, 0x62, 0x30, 0x34, 0x63, 0x30, 0x66, 0x32, 0x36, 0x62, 0x64, 0x63, 0x37, 0x31, 0x65, 0x32, 0x33, 0x39, 0x66, 0x37, 0x64, 0x36, 0x66, 0x31, 0x32, 0x37, 0x62, 0x62, 0x66, 0x61, 0x36, 0x33, 0x36, 0x39, 0x65, 0x65, 0x31, 0x62, 0x62, 0x34, 0x36, 0x66, 0x64, 0x39, 0x64, 0x33, 0x63, 0x66, 0x38, 0x31, 0x64, 0x61, 0x35, 0x62, 0x30, 0x36, 0x30, 0x32, 0x37, 0x32, 0x65, 0x39, 0x62, 0x65, 0x64, 0x39, 0x62, 0x37, 0x37, 0x64, 0x39, 0x36, 0x34, 0x37, 0x31, 0x35, 0x62, 0x38, 0x31, 0x30, 0x36, 0x61, 0x30, 0x32, 0x62, 0x30, 0x32, 0x39, 0x37, 0x39, 0x66, 0x33, 0x30, 0x62, 0x39, 0x35, 0x30, 0x39, 0x61, 0x37, 0x63, 0x63, 0x39, 0x62, 0x63, 0x36, 0x31, 0x35, 0x32, 0x34, 0x32, 0x63, 0x39, 0x37, 0x63, 0x37, 0x31, 0x31, 0x64, 0x65, 0x61, 0x37, 0x33, 0x30, 0x30, 0x30, 0x62, 0x37, 0x32, 0x37, 0x61, 0x64, 0x37, 0x66, 0x37, 0x34, 0x65, 0x65, 0x34, 0x35, 0x33, 0x32, 0x32, 0x34, 0x64, 0x30, 0x31, 0x61, 0x64, 0x32, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x31, 0x38, 0x61, 0x36, 0x65, 0x65, 0x63, 0x39, 0x35, 0x37, 0x64, 0x38, 0x64, 0x65, 0x33, 0x66, 0x63, 0x65, 0x34, 0x32, 0x63, 0x36, 0x39, 0x62, 0x30, 0x65, 0x37, 0x32, 0x30, 0x65, 0x37, 0x32, 0x64, 0x35, 0x64, 0x63, 0x31, 0x36, 0x35, 0x37, 0x39, 0x62, 0x63, 0x61, 0x31, 0x32, 0x30, 0x66, 0x36, 0x33, 0x65, 0x61, 0x64, 0x38, 0x65, 0x34, 0x32, 0x30, 0x39, 0x30, 0x32, 0x62, 0x35, 0x64, 0x65, 0x61, 0x34, 0x39, 0x64, 0x64, 0x33, 0x39, 0x39, 0x61, 0x37, 0x36, 0x37, 0x65, 0x32, 0x61, 0x36, 0x39, 0x38, 0x34, 0x64, 0x65, 0x62, 0x63, 0x65, 0x33, 0x31, 0x36, 0x30, 0x66, 0x37, 0x32, 0x36, 0x30, 0x63, 0x61, 0x39, 0x62, 0x66, 0x31, 0x35, 0x39, 0x32, 0x33, 0x34, 0x33, 0x66, 0x32, 0x32, 0x62, 0x31, 0x30, 0x65, 0x65, 0x32, 0x61, 0x36, 0x39, 0x32, 0x36, 0x38, 0x37, 0x39, 0x31, 0x33, 0x33, 0x39, 0x34, 0x32, 0x31, 0x65, 0x63, 0x36, 0x33, 0x62, 0x36, 0x31, 0x30, 0x36, 0x38, 0x31, 0x65, 0x64, 0x39, 0x37, 0x36, 0x36, 0x32, 0x38, 0x66, 0x39, 0x38, 0x61, 0x61, 0x37, 0x32, 0x34, 0x32, 0x37, 0x31, 0x36, 0x30, 0x61, 0x34, 0x31, 0x63, 0x61, 0x30, 0x38, 0x64, 0x38, 0x66, 0x63, 0x37, 0x35, 0x32, 0x37, 0x32, 0x61, 0x36, 0x65, 0x31, 0x31, 0x65, 0x61, 0x63, 0x30, 0x38, 0x36, 0x64, 0x61, 0x64, 0x64, 0x65, 0x39, 0x65, 0x63, 0x35, 0x63, 0x34, 0x61, 0x34, 0x63, 0x65, 0x36, 0x30, 0x32, 0x35, 0x36, 0x32, 0x62, 0x37, 0x62, 0x31, 0x63, 0x65, 0x63, 0x64, 0x36, 0x31, 0x62, 0x34, 0x35, 0x34, 0x64, 0x61, 0x38, 0x33, 0x32, 0x37, 0x65, 0x62, 0x62, 0x33, 0x31, 0x66, 0x37, 0x31, 0x30, 0x32, 0x35, 0x66, 0x61, 0x39, 0x64, 0x30, 0x30, 0x36, 0x36, 0x39, 0x62, 0x61, 0x61, 0x34, 0x66, 0x61, 0x62, 0x63, 0x35, 0x37, 0x36, 0x36, 0x62, 0x61, 0x64, 0x64, 0x39, 0x36, 0x32, 0x32, 0x66, 0x37, 0x62, 0x37, 0x65, 0x65, 0x32, 0x31, 0x63, 0x38, 0x38, 0x64, 0x37, 0x32, 0x32, 0x66, 0x61, 0x32, 0x36, 0x65, 0x66, 0x66, 0x64, 0x65, 0x39, 0x62, 0x62, 0x63, 0x34, 0x66, 0x30, 0x38, 0x37, 0x65, 0x31, 0x35, 0x62, 0x39, 0x64, 0x32, 0x39, 0x38, 0x61, 0x36, 0x65, 0x30, 0x30, 0x61, 0x30, 0x32, 0x39, 0x32, 0x33, 0x37, 0x35, 0x34, 0x37, 0x64, 0x39, 0x64, 0x34, 0x66, 0x62, 0x34, 0x30, 0x33, 0x62, 0x38, 0x62, 0x36, 0x38, 0x32, 0x63, 0x65, 0x33, 0x38, 0x37, 0x32, 0x64, 0x35, 0x30, 0x39, 0x64, 0x63, 0x65, 0x32, 0x33, 0x35, 0x61, 0x61, 0x34, 0x61, 0x64, 0x61, 0x34, 0x66, 0x31, 0x36, 0x66, 0x65, 0x61, 0x61, 0x33, 0x62, 0x37, 0x66, 0x38, 0x31, 0x62, 0x36, 0x36, 0x34, 0x36, 0x31, 0x66, 0x33, 0x36, 0x31, 0x61, 0x37, 0x32, 0x39, 0x31, 0x61, 0x39, 0x63, 0x61, 0x30, 0x62, 0x37, 0x35, 0x32, 0x61, 0x33, 0x36, 0x34, 0x32, 0x36, 0x36, 0x64, 0x37, 0x32, 0x33, 0x38, 0x36, 0x32, 0x66, 0x64, 0x38, 0x37, 0x63, 0x30, 0x31, 0x36, 0x31, 0x62, 0x32, 0x31, 0x35, 0x63, 0x36, 0x39, 0x36, 0x36, 0x66, 0x34, 0x65, 0x63, 0x31, 0x36, 0x39, 0x38, 0x64, 0x62, 0x37, 0x66, 0x37, 0x31, 0x39, 0x31, 0x30, 0x64, 0x36, 0x66, 0x36, 0x31, 0x63, 0x38, 0x30, 0x61, 0x62, 0x34, 0x37, 0x35, 0x38, 0x32, 0x33, 0x66, 0x32, 0x36, 0x35, 0x65, 0x62, 0x32, 0x37, 0x32, 0x35, 0x62, 0x62, 0x30, 0x66, 0x32, 0x64, 0x36, 0x63, 0x34, 0x62, 0x31, 0x62, 0x36, 0x35, 0x37, 0x31, 0x36, 0x65, 0x61, 0x62, 0x32, 0x33, 0x62, 0x34, 0x34, 0x34, 0x35, 0x30, 0x35, 0x34, 0x39, 0x61, 0x37, 0x32, 0x34, 0x32, 0x32, 0x61, 0x35, 0x65, 0x31, 0x31, 0x31, 0x39, 0x66, 0x32, 0x33, 0x39, 0x32, 0x61, 0x63, 0x35, 0x35, 0x64, 0x32, 0x62, 0x39, 0x33, 0x37, 0x39, 0x33, 0x37, 0x32, 0x64, 0x34, 0x38, 0x66, 0x61, 0x35, 0x65, 0x63, 0x39, 0x31, 0x63, 0x31, 0x35, 0x62, 0x66, 0x37, 0x64, 0x62, 0x32, 0x65, 0x63, 0x33, 0x66, 0x34, 0x37, 0x39, 0x35, 0x63, 0x64, 0x39, 0x36, 0x37, 0x65, 0x39, 0x64, 0x61, 0x31, 0x63, 0x62, 0x63, 0x34, 0x30, 0x38, 0x33, 0x36, 0x63, 0x62, 0x37, 0x61, 0x62, 0x35, 0x39, 0x39, 0x35, 0x62, 0x39, 0x61, 0x34, 0x65, 0x63, 0x30, 0x31, 0x37, 0x32, 0x37, 0x66, 0x36, 0x34, 0x34, 0x31, 0x37, 0x33, 0x37, 0x39, 0x31, 0x61, 0x65, 0x31, 0x38, 0x33, 0x32, 0x64, 0x62, 0x36, 0x36, 0x35, 0x31, 0x30, 0x65, 0x65, 0x31, 0x32, 0x37, 0x31, 0x65, 0x31, 0x39, 0x66, 0x34, 0x38, 0x64, 0x39, 0x34, 0x35, 0x61, 0x62, 0x39, 0x62, 0x35, 0x65, 0x61, 0x37, 0x38, 0x33, 0x32, 0x32, 0x66, 0x61, 0x66, 0x38, 0x63, 0x33, 0x31, 0x61, 0x35, 0x33, 0x37, 0x32, 0x33, 0x32, 0x38, 0x30, 0x32, 0x30, 0x35, 0x31, 0x32, 0x30, 0x38, 0x37, 0x61, 0x34, 0x35, 0x30, 0x38, 0x62, 0x35, 0x65, 0x61, 0x34, 0x36, 0x62, 0x61, 0x37, 0x35, 0x35, 0x38, 0x65, 0x62, 0x30, 0x64, 0x33, 0x65, 0x64, 0x31, 0x32, 0x66, 0x65, 0x66, 0x34, 0x63, 0x63, 0x66, 0x63, 0x64, 0x66, 0x65, 0x66, 0x64, 0x38, 0x62, 0x61, 0x63, 0x65, 0x66, 0x36, 0x64, 0x37, 0x61, 0x32, 0x37, 0x32, 0x61, 0x64, 0x33, 0x65, 0x61, 0x66, 0x32, 0x39, 0x36, 0x64, 0x36, 0x31, 0x34, 0x34, 0x61, 0x39, 0x34, 0x30, 0x33, 0x61, 0x62, 0x38, 0x65, 0x30, 0x38, 0x34, 0x64, 0x38, 0x37, 0x64, 0x65, 0x37, 0x30, 0x34, 0x62, 0x30, 0x34, 0x66, 0x39, 0x39, 0x39, 0x66, 0x65, 0x61, 0x32, 0x62, 0x63, 0x30, 0x35, 0x31, 0x36, 0x37, 0x39, 0x65, 0x31, 0x62, 0x34, 0x30, 0x36, 0x64, 0x37, 0x33, 0x37, 0x32, 0x38, 0x62, 0x38, 0x37, 0x64, 0x62, 0x36, 0x62, 0x61, 0x63, 0x33, 0x30, 0x30, 0x63, 0x31, 0x39, 0x36, 0x38, 0x31, 0x36, 0x33, 0x61, 0x38, 0x66, 0x30, 0x33, 0x37, 0x64, 0x63, 0x62, 0x61, 0x65, 0x34, 0x62, 0x61, 0x31, 0x66, 0x34, 0x64, 0x35, 0x63, 0x65, 0x32, 0x37, 0x37, 0x61, 0x64, 0x61, 0x31, 0x63, 0x37, 0x64, 0x64, 0x65, 0x37, 0x35, 0x66, 0x38, 0x36, 0x33, 0x66, 0x31, 0x31, 0x37, 0x36, 0x30, 0x38, 0x38, 0x38, 0x62, 0x32, 0x30, 0x64, 0x62, 0x33, 0x37, 0x65, 0x37, 0x37, 0x34, 0x37, 0x34, 0x38, 0x63, 0x33, 0x62, 0x30, 0x64, 0x62, 0x39, 0x31, 0x64, 0x61, 0x62, 0x62, 0x38, 0x32, 0x34, 0x34, 0x37, 0x34, 0x33, 0x61, 0x62, 0x63, 0x38, 0x30, 0x63, 0x35, 0x39, 0x66, 0x34, 0x31, 0x61, 0x39, 0x33, 0x33, 0x36, 0x30, 0x34, 0x34, 0x34, 0x65, 0x31, 0x66, 0x63, 0x37, 0x32, 0x66, 0x62, 0x37, 0x39, 0x39, 0x61, 0x35, 0x33, 0x38, 0x61, 0x32, 0x39, 0x38, 0x65, 0x37, 0x34, 0x30, 0x34, 0x37, 0x32, 0x36, 0x61, 0x37, 0x35, 0x64, 0x36, 0x62, 0x33, 0x39, 0x30, 0x30, 0x36, 0x38, 0x61, 0x30, 0x61, 0x63, 0x33, 0x66, 0x37, 0x39, 0x38, 0x36, 0x64, 0x37, 0x61, 0x35, 0x34, 0x31, 0x34, 0x35, 0x33, 0x30, 0x33, 0x61, 0x63, 0x62, 0x31, 0x39, 0x64, 0x63, 0x35, 0x37, 0x32, 0x33, 0x39, 0x66, 0x63, 0x62, 0x36, 0x36, 0x34, 0x65, 0x65, 0x65, 0x34, 0x66, 0x38, 0x31, 0x30, 0x30, 0x64, 0x62, 0x64, 0x64, 0x30, 0x32, 0x65, 0x66, 0x33, 0x61, 0x31, 0x35, 0x39, 0x30, 0x30, 0x32, 0x31, 0x33, 0x66, 0x35, 0x63, 0x32, 0x33, 0x36, 0x35, 0x65, 0x36, 0x31, 0x38, 0x33, 0x65, 0x65, 0x64, 0x62, 0x39, 0x34, 0x64, 0x35, 0x61, 0x36, 0x33, 0x33, 0x65, 0x64, 0x39, 0x37, 0x32, 0x38, 0x34, 0x35, 0x36, 0x61, 0x62, 0x61, 0x61, 0x37, 0x61, 0x35, 0x34, 0x38, 0x31, 0x39, 0x30, 0x38, 0x37, 0x34, 0x64, 0x35, 0x66, 0x64, 0x64, 0x34, 0x37, 0x35, 0x36, 0x64, 0x64, 0x33, 0x31, 0x33, 0x31, 0x34, 0x35, 0x61, 0x66, 0x61, 0x62, 0x61, 0x61, 0x38, 0x38, 0x37, 0x32, 0x63, 0x65, 0x33, 0x38, 0x64, 0x61, 0x63, 0x61, 0x35, 0x30, 0x62, 0x64, 0x38, 0x38, 0x30, 0x36, 0x37, 0x32, 0x37, 0x32, 0x62, 0x62, 0x37, 0x62, 0x30, 0x66, 0x39, 0x39, 0x37, 0x61, 0x36, 0x34, 0x31, 0x35, 0x33, 0x30, 0x64, 0x30, 0x39, 0x62, 0x32, 0x33, 0x34, 0x35, 0x32, 0x66, 0x35, 0x31, 0x37, 0x36, 0x61, 0x33, 0x34, 0x32, 0x66, 0x33, 0x32, 0x38, 0x34, 0x62, 0x34, 0x33, 0x37, 0x37, 0x33, 0x31, 0x36, 0x33, 0x32, 0x34, 0x32, 0x39, 0x31, 0x64, 0x62, 0x31, 0x37, 0x62, 0x34, 0x62, 0x37, 0x32, 0x34, 0x30, 0x66, 0x37, 0x33, 0x33, 0x36, 0x66, 0x63, 0x36, 0x33, 0x32, 0x34, 0x39, 0x62, 0x37, 0x65, 0x66, 0x30, 0x39, 0x65, 0x31, 0x64, 0x30, 0x66, 0x34, 0x62, 0x66, 0x39, 0x38, 0x37, 0x38, 0x38, 0x35, 0x37, 0x38, 0x34, 0x37, 0x63, 0x38, 0x38, 0x32, 0x31, 0x65, 0x66, 0x64, 0x66, 0x35, 0x39, 0x34, 0x63, 0x38, 0x64, 0x32, 0x63, 0x63, 0x38, 0x62, 0x38, 0x63, 0x39, 0x63, 0x37, 0x32, 0x64, 0x39, 0x34, 0x31, 0x38, 0x34, 0x63, 0x66, 0x65, 0x32, 0x34, 0x65, 0x36, 0x61, 0x39, 0x31, 0x65, 0x66, 0x61, 0x37, 0x61, 0x36, 0x61, 0x64, 0x63, 0x63, 0x36, 0x34, 0x39, 0x34, 0x64, 0x30, 0x61, 0x35, 0x30, 0x38, 0x33, 0x35, 0x30, 0x32, 0x63, 0x31, 0x64, 0x63, 0x63, 0x35, 0x37, 0x34, 0x38, 0x33, 0x64, 0x31, 0x39, 0x36, 0x36, 0x65, 0x66, 0x30, 0x38, 0x34, 0x36, 0x66, 0x34, 0x39, 0x66, 0x36, 0x63, 0x35, 0x34, 0x64, 0x65, 0x61, 0x36, 0x32, 0x35, 0x32, 0x66, 0x31, 0x37, 0x32, 0x38, 0x33, 0x33, 0x33, 0x34, 0x30, 0x35, 0x62, 0x38, 0x66, 0x66, 0x34, 0x65, 0x30, 0x34, 0x31, 0x34, 0x32, 0x38, 0x35, 0x65, 0x31, 0x65, 0x63, 0x35, 0x64, 0x37, 0x62, 0x36, 0x65, 0x66, 0x35, 0x34, 0x37, 0x30, 0x62, 0x34, 0x63, 0x65, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x33, 0x31, 0x32, 0x64, 0x66, 0x35, 0x33, 0x63, 0x30, 0x33, 0x33, 0x64, 0x64, 0x66, 0x38, 0x61, 0x36, 0x61, 0x35, 0x37, 0x36, 0x37, 0x63, 0x33, 0x30, 0x64, 0x37, 0x66, 0x61, 0x38, 0x36, 0x35, 0x63, 0x37, 0x36, 0x38, 0x38, 0x62, 0x32, 0x30, 0x33, 0x34, 0x34, 0x35, 0x33, 0x39, 0x38, 0x61, 0x34, 0x65, 0x30, 0x65, 0x65, 0x63, 0x65, 0x64, 0x37, 0x36, 0x62, 0x35, 0x31, 0x31, 0x39, 0x38, 0x31, 0x37, 0x32, 0x66, 0x32, 0x36, 0x33, 0x66, 0x31, 0x65, 0x65, 0x31, 0x30, 0x34, 0x61, 0x64, 0x35, 0x30, 0x35, 0x35, 0x31, 0x37, 0x65, 0x37, 0x63, 0x63, 0x30, 0x63, 0x33, 0x37, 0x35, 0x30, 0x35, 0x63, 0x32, 0x35, 0x34, 0x30, 0x33, 0x32, 0x62, 0x37, 0x62, 0x61, 0x38, 0x33, 0x62, 0x62, 0x64, 0x37, 0x63, 0x65, 0x62, 0x62, 0x36, 0x62, 0x39, 0x65, 0x62, 0x39, 0x61, 0x62, 0x32, 0x35, 0x33, 0x37, 0x32, 0x38, 0x38, 0x35, 0x63, 0x32, 0x66, 0x64, 0x36, 0x65, 0x33, 0x34, 0x36, 0x64, 0x32, 0x35, 0x37, 0x62, 0x33, 0x39, 0x35, 0x33, 0x62, 0x30, 0x63, 0x33, 0x31, 0x34, 0x65, 0x33, 0x66, 0x65, 0x34, 0x35, 0x35, 0x61, 0x30, 0x37, 0x38, 0x33, 0x66, 0x39, 0x37, 0x62, 0x66, 0x66, 0x64, 0x31, 0x38, 0x65, 0x62, 0x35, 0x35, 0x65, 0x39, 0x34, 0x38, 0x33, 0x34, 0x33, 0x66, 0x34, 0x33, 0x31, 0x30, 0x32, 0x32, 0x65, 0x34, 0x31, 0x37, 0x38, 0x61, 0x65, 0x34, 0x64, 0x36, 0x61, 0x31, 0x62, 0x32, 0x38, 0x39, 0x37, 0x38, 0x30, 0x64, 0x35, 0x30, 0x62, 0x65, 0x61, 0x39, 0x33, 0x33, 0x63, 0x30, 0x31, 0x31, 0x66, 0x37, 0x61, 0x61, 0x33, 0x36, 0x63, 0x66, 0x38, 0x61, 0x61, 0x31, 0x62, 0x30, 0x62, 0x33, 0x35, 0x35, 0x66, 0x65, 0x65, 0x35, 0x65, 0x63, 0x32, 0x35, 0x38, 0x61, 0x37, 0x32, 0x66, 0x65, 0x66, 0x39, 0x63, 0x35, 0x61, 0x63, 0x33, 0x30, 0x30, 0x65, 0x31, 0x38, 0x61, 0x64, 0x35, 0x30, 0x33, 0x38, 0x34, 0x62, 0x65, 0x34, 0x34, 0x33, 0x66, 0x32, 0x35, 0x39, 0x33, 0x36, 0x63, 0x33, 0x35, 0x62, 0x31, 0x32, 0x30, 0x38, 0x62, 0x30, 0x62, 0x61, 0x61, 0x62, 0x62, 0x38, 0x37, 0x61, 0x66, 0x65, 0x61, 0x39, 0x38, 0x32, 0x32, 0x37, 0x30, 0x38, 0x38, 0x63, 0x31, 0x37, 0x32, 0x61, 0x36, 0x63, 0x38, 0x62, 0x34, 0x31, 0x62, 0x62, 0x35, 0x64, 0x30, 0x64, 0x65, 0x32, 0x34, 0x37, 0x36, 0x31, 0x30, 0x61, 0x32, 0x65, 0x38, 0x64, 0x61, 0x38, 0x39, 0x62, 0x37, 0x66, 0x33, 0x36, 0x35, 0x39, 0x30, 0x33, 0x34, 0x61, 0x31, 0x34, 0x38, 0x36, 0x62, 0x36, 0x34, 0x65, 0x33, 0x38, 0x64, 0x61, 0x61, 0x63, 0x33, 0x62, 0x65, 0x66, 0x66, 0x32, 0x36, 0x62, 0x37, 0x32, 0x38, 0x34, 0x36, 0x65, 0x34, 0x63, 0x35, 0x66, 0x37, 0x30, 0x61, 0x64, 0x31, 0x39, 0x62, 0x63, 0x65, 0x62, 0x36, 0x35, 0x61, 0x35, 0x34, 0x33, 0x64, 0x66, 0x38, 0x62, 0x34, 0x36, 0x61, 0x36, 0x34, 0x37, 0x61, 0x31, 0x33, 0x65, 0x63, 0x36, 0x37, 0x65, 0x66, 0x37, 0x31, 0x36, 0x37, 0x32, 0x63, 0x63, 0x32, 0x31, 0x36, 0x39, 0x32, 0x34, 0x64, 0x32, 0x32, 0x34, 0x39, 0x31, 0x33, 0x38, 0x36, 0x34, 0x63, 0x35, 0x39, 0x34, 0x31, 0x61, 0x35, 0x35, 0x34, 0x63, 0x62, 0x38, 0x63, 0x32, 0x37, 0x37, 0x61, 0x62, 0x33, 0x38, 0x64, 0x34, 0x35, 0x66, 0x30, 0x31, 0x34, 0x35, 0x32, 0x30, 0x66, 0x65, 0x37, 0x39, 0x32, 0x35, 0x33, 0x63, 0x62, 0x39, 0x37, 0x30, 0x31, 0x34, 0x65, 0x33, 0x36, 0x64, 0x65, 0x38, 0x35, 0x61, 0x35, 0x31, 0x37, 0x62, 0x65, 0x65, 0x61, 0x32, 0x30, 0x64, 0x61, 0x33, 0x39, 0x39, 0x34, 0x38, 0x35, 0x31, 0x66, 0x39, 0x30, 0x34, 0x61, 0x31, 0x37, 0x35, 0x35, 0x36, 0x62, 0x38, 0x34, 0x66, 0x64, 0x61, 0x38, 0x38, 0x38, 0x31, 0x33, 0x62, 0x36, 0x62, 0x64, 0x33, 0x64, 0x36, 0x63, 0x35, 0x30, 0x61, 0x65, 0x33, 0x64, 0x65, 0x65, 0x63, 0x36, 0x39, 0x64, 0x33, 0x65, 0x64, 0x37, 0x31, 0x31, 0x61, 0x32, 0x39, 0x64, 0x31, 0x37, 0x65, 0x31, 0x64, 0x64, 0x33, 0x38, 0x64, 0x39, 0x65, 0x31, 0x32, 0x66, 0x37, 0x62, 0x36, 0x65, 0x32, 0x66, 0x30, 0x64, 0x61, 0x33, 0x66, 0x31, 0x32, 0x32, 0x33, 0x64, 0x63, 0x35, 0x61, 0x62, 0x65, 0x35, 0x62, 0x37, 0x32, 0x65, 0x37, 0x39, 0x37, 0x66, 0x34, 0x39, 0x33, 0x61, 0x61, 0x64, 0x61, 0x62, 0x30, 0x38, 0x66, 0x64, 0x32, 0x34, 0x34, 0x64, 0x66, 0x31, 0x32, 0x31, 0x62, 0x34, 0x64, 0x36, 0x35, 0x63, 0x63, 0x31, 0x65, 0x35, 0x32, 0x65, 0x66, 0x38, 0x38, 0x66, 0x33, 0x33, 0x38, 0x30, 0x64, 0x38, 0x64, 0x31, 0x35, 0x64, 0x65, 0x65, 0x61, 0x36, 0x36, 0x62, 0x61, 0x37, 0x31, 0x39, 0x34, 0x31, 0x39, 0x61, 0x30, 0x32, 0x66, 0x65, 0x30, 0x31, 0x30, 0x63, 0x66, 0x66, 0x63, 0x33, 0x65, 0x37, 0x64, 0x35, 0x31, 0x61, 0x34, 0x62, 0x64, 0x63, 0x34, 0x63, 0x31, 0x34, 0x66, 0x31, 0x39, 0x36, 0x37, 0x34, 0x32, 0x39, 0x64, 0x64, 0x30, 0x62, 0x63, 0x34, 0x65, 0x30, 0x37, 0x62, 0x66, 0x36, 0x63, 0x39, 0x34, 0x65, 0x66, 0x35, 0x37, 0x36, 0x32, 0x66, 0x63, 0x37, 0x38, 0x33, 0x64, 0x37, 0x62, 0x34, 0x64, 0x33, 0x66, 0x33, 0x65, 0x62, 0x37, 0x33, 0x65, 0x35, 0x62, 0x63, 0x64, 0x35, 0x37, 0x63, 0x66, 0x35, 0x64, 0x39, 0x32, 0x36, 0x35, 0x37, 0x33, 0x31, 0x35, 0x37, 0x32, 0x35, 0x63, 0x66, 0x64, 0x39, 0x63, 0x34, 0x38, 0x32, 0x32, 0x32, 0x31, 0x36, 0x34, 0x63, 0x38, 0x62, 0x35, 0x37, 0x62, 0x63, 0x61, 0x65, 0x61, 0x62, 0x37, 0x64, 0x64, 0x30, 0x61, 0x31, 0x30, 0x62, 0x63, 0x30, 0x38, 0x31, 0x38, 0x65, 0x34, 0x38, 0x65, 0x36, 0x61, 0x62, 0x66, 0x33, 0x32, 0x38, 0x33, 0x38, 0x34, 0x34, 0x62, 0x61, 0x31, 0x33, 0x66, 0x36, 0x61, 0x63, 0x61, 0x37, 0x32, 0x63, 0x37, 0x33, 0x63, 0x65, 0x64, 0x63, 0x62, 0x61, 0x62, 0x65, 0x30, 0x39, 0x39, 0x39, 0x32, 0x33, 0x63, 0x37, 0x37, 0x39, 0x39, 0x36, 0x38, 0x30, 0x61, 0x30, 0x37, 0x33, 0x66, 0x64, 0x39, 0x62, 0x37, 0x31, 0x63, 0x31, 0x38, 0x34, 0x30, 0x64, 0x35, 0x37, 0x36, 0x61, 0x62, 0x34, 0x63, 0x37, 0x63, 0x63, 0x32, 0x62, 0x61, 0x64, 0x64, 0x36, 0x33, 0x32, 0x37, 0x66, 0x32, 0x33, 0x62, 0x35, 0x64, 0x36, 0x35, 0x31, 0x62, 0x65, 0x31, 0x39, 0x35, 0x61, 0x33, 0x37, 0x65, 0x34, 0x64, 0x61, 0x31, 0x61, 0x31, 0x65, 0x32, 0x31, 0x35, 0x63, 0x65, 0x37, 0x64, 0x34, 0x61, 0x66, 0x39, 0x63, 0x30, 0x33, 0x35, 0x34, 0x62, 0x32, 0x63, 0x63, 0x31, 0x36, 0x39, 0x32, 0x61, 0x37, 0x35, 0x36, 0x62, 0x36, 0x31, 0x35, 0x64, 0x37, 0x31, 0x61, 0x34, 0x34, 0x38, 0x33, 0x32, 0x37, 0x32, 0x37, 0x38, 0x63, 0x34, 0x37, 0x39, 0x30, 0x30, 0x39, 0x35, 0x32, 0x34, 0x35, 0x39, 0x64, 0x64, 0x36, 0x30, 0x36, 0x61, 0x30, 0x66, 0x38, 0x38, 0x34, 0x32, 0x35, 0x64, 0x32, 0x65, 0x37, 0x64, 0x35, 0x62, 0x36, 0x31, 0x61, 0x62, 0x31, 0x35, 0x30, 0x36, 0x66, 0x31, 0x33, 0x36, 0x66, 0x36, 0x62, 0x31, 0x39, 0x34, 0x66, 0x37, 0x64, 0x31, 0x64, 0x34, 0x65, 0x33, 0x63, 0x30, 0x37, 0x32, 0x31, 0x38, 0x66, 0x66, 0x37, 0x65, 0x37, 0x34, 0x66, 0x38, 0x61, 0x34, 0x61, 0x37, 0x61, 0x38, 0x34, 0x62, 0x62, 0x31, 0x64, 0x64, 0x63, 0x64, 0x63, 0x64, 0x36, 0x36, 0x66, 0x63, 0x30, 0x38, 0x34, 0x63, 0x38, 0x34, 0x33, 0x37, 0x66, 0x39, 0x34, 0x63, 0x39, 0x36, 0x37, 0x63, 0x62, 0x39, 0x35, 0x33, 0x34, 0x32, 0x39, 0x66, 0x33, 0x36, 0x32, 0x37, 0x62, 0x37, 0x39, 0x65, 0x31, 0x65, 0x31, 0x36, 0x34, 0x30, 0x38, 0x39, 0x64, 0x35, 0x64, 0x65, 0x64, 0x38, 0x33, 0x30, 0x38, 0x33, 0x30, 0x30, 0x64, 0x30, 0x63, 0x66, 0x65, 0x62, 0x37, 0x35, 0x31, 0x66, 0x66, 0x31, 0x37, 0x65, 0x33, 0x31, 0x35, 0x36, 0x38, 0x39, 0x37, 0x64, 0x33, 0x39, 0x65, 0x32, 0x66, 0x39, 0x64, 0x66, 0x35, 0x39, 0x61, 0x65, 0x64, 0x33, 0x63, 0x34, 0x31, 0x37, 0x62, 0x35, 0x35, 0x35, 0x32, 0x36, 0x63, 0x34, 0x32, 0x62, 0x35, 0x64, 0x39, 0x34, 0x65, 0x61, 0x36, 0x62, 0x66, 0x30, 0x32, 0x65, 0x34, 0x63, 0x32, 0x39, 0x61, 0x66, 0x61, 0x33, 0x39, 0x33, 0x61, 0x62, 0x39, 0x63, 0x61, 0x65, 0x33, 0x64, 0x66, 0x30, 0x31, 0x32, 0x64, 0x35, 0x62, 0x65, 0x38, 0x37, 0x37, 0x39, 0x34, 0x62, 0x33, 0x64, 0x35, 0x65, 0x37, 0x61, 0x30, 0x66, 0x64, 0x35, 0x36, 0x30, 0x33, 0x64, 0x34, 0x64, 0x30, 0x35, 0x65, 0x62, 0x62, 0x39, 0x64, 0x38, 0x36, 0x35, 0x31, 0x31, 0x38, 0x64, 0x35, 0x36, 0x30, 0x63, 0x65, 0x30, 0x65, 0x62, 0x37, 0x36, 0x39, 0x35, 0x30, 0x63, 0x37, 0x61, 0x65, 0x38, 0x37, 0x64, 0x62, 0x65, 0x39, 0x66, 0x62, 0x33, 0x63, 0x35, 0x38, 0x32, 0x33, 0x63, 0x36, 0x63, 0x38, 0x30, 0x61, 0x39, 0x33, 0x65, 0x64, 0x35, 0x32, 0x34, 0x63, 0x38, 0x64, 0x61, 0x37, 0x32, 0x62, 0x36, 0x39, 0x32, 0x37, 0x36, 0x36, 0x30, 0x36, 0x32, 0x39, 0x64, 0x32, 0x62, 0x37, 0x39, 0x34, 0x35, 0x66, 0x35, 0x35, 0x65, 0x66, 0x36, 0x32, 0x65, 0x34, 0x36, 0x65, 0x32, 0x33, 0x30, 0x31, 0x34, 0x38, 0x35, 0x31, 0x31, 0x66, 0x35, 0x35, 0x65, 0x32, 0x35, 0x31, 0x38, 0x61, 0x33, 0x30, 0x33, 0x34, 0x62, 0x63, 0x38, 0x64, 0x62, 0x63, 0x30, 0x61, 0x62, 0x34, 0x39, 0x31, 0x30, 0x37, 0x39, 0x62, 0x33, 0x61, 0x30, 0x39, 0x61, 0x35, 0x33, 0x33, 0x36, 0x38, 0x38, 0x33, 0x34, 0x37, 0x32, 0x31, 0x36, 0x64, 0x30, 0x62, 0x39, 0x33, 0x39, 0x31, 0x61, 0x61, 0x31, 0x65, 0x30, 0x33, 0x63, 0x64, 0x33, 0x61, 0x39, 0x30, 0x32, 0x32, 0x32, 0x37, 0x33, 0x39, 0x61, 0x33, 0x36, 0x62, 0x30, 0x34, 0x63, 0x36, 0x33, 0x35, 0x36, 0x32, 0x39, 0x39, 0x61, 0x64, 0x63, 0x36, 0x63, 0x31, 0x36, 0x64, 0x32, 0x39, 0x37, 0x31, 0x65, 0x37, 0x63, 0x65, 0x61, 0x64, 0x36, 0x30, 0x63, 0x65, 0x32, 0x64, 0x31, 0x62, 0x33, 0x30, 0x34, 0x30, 0x62, 0x62, 0x61, 0x64, 0x61, 0x61, 0x34, 0x61, 0x30, 0x66, 0x31, 0x38, 0x65, 0x30, 0x38, 0x31, 0x30, 0x32, 0x35, 0x34, 0x34, 0x63, 0x61, 0x38, 0x64, 0x62, 0x38, 0x65, 0x34, 0x36, 0x32, 0x39, 0x61, 0x32, 0x64, 0x31, 0x62, 0x37, 0x32, 0x64, 0x32, 0x62, 0x61, 0x30, 0x62, 0x63, 0x62, 0x35, 0x30, 0x35, 0x61, 0x36, 0x39, 0x64, 0x39, 0x31, 0x65, 0x64, 0x37, 0x36, 0x33, 0x66, 0x34, 0x35, 0x34, 0x63, 0x35, 0x36, 0x62, 0x38, 0x65, 0x62, 0x34, 0x34, 0x38, 0x32, 0x30, 0x32, 0x65, 0x39, 0x61, 0x33, 0x61, 0x32, 0x31, 0x63, 0x37, 0x38, 0x37, 0x37, 0x33, 0x31, 0x63, 0x38, 0x34, 0x30, 0x30, 0x35, 0x65, 0x65, 0x30, 0x30, 0x32, 0x34, 0x31, 0x32, 0x38, 0x61, 0x37, 0x66, 0x30, 0x63, 0x66, 0x64, 0x63, 0x61, 0x64, 0x38, 0x35, 0x32, 0x65, 0x62, 0x35, 0x33, 0x31, 0x65, 0x63, 0x65, 0x64, 0x66, 0x61, 0x39, 0x63, 0x66, 0x33, 0x34, 0x62, 0x63, 0x61, 0x37, 0x35, 0x65, 0x66, 0x36, 0x31, 0x34, 0x64, 0x30, 0x33, 0x34, 0x66, 0x37, 0x63, 0x34, 0x38, 0x39, 0x66, 0x65, 0x64, 0x34, 0x34, 0x65, 0x31, 0x32, 0x65, 0x37, 0x32, 0x34, 0x65, 0x31, 0x63, 0x63, 0x33, 0x30, 0x35, 0x62, 0x63, 0x39, 0x62, 0x37, 0x32, 0x36, 0x35, 0x62, 0x35, 0x38, 0x66, 0x37, 0x31, 0x37, 0x37, 0x39, 0x37, 0x65, 0x35, 0x62, 0x30, 0x33, 0x35, 0x32, 0x31, 0x66, 0x33, 0x30, 0x31, 0x33, 0x35, 0x38, 0x34, 0x61, 0x37, 0x38, 0x66, 0x30, 0x31, 0x30, 0x36, 0x66, 0x35, 0x61, 0x33, 0x61, 0x66, 0x33, 0x39, 0x33, 0x37, 0x31, 0x36, 0x30, 0x63, 0x63, 0x33, 0x36, 0x65, 0x39, 0x66, 0x65, 0x39, 0x34, 0x61, 0x66, 0x64, 0x37, 0x37, 0x39, 0x30, 0x38, 0x32, 0x35, 0x38, 0x33, 0x33, 0x31, 0x62, 0x30, 0x63, 0x35, 0x31, 0x62, 0x35, 0x37, 0x38, 0x63, 0x62, 0x34, 0x65, 0x61, 0x63, 0x39, 0x34, 0x34, 0x34, 0x66, 0x61, 0x63, 0x62, 0x34, 0x65, 0x35, 0x31, 0x62, 0x64, 0x31, 0x38, 0x64, 0x32, 0x63, 0x65, 0x39, 0x37, 0x64, 0x65, 0x35, 0x37, 0x36, 0x33, 0x65, 0x35, 0x61, 0x37, 0x66, 0x33, 0x61, 0x33, 0x64, 0x64, 0x35, 0x35, 0x30, 0x33, 0x64, 0x33, 0x36, 0x63, 0x37, 0x35, 0x33, 0x37, 0x65, 0x34, 0x38, 0x34, 0x62, 0x65, 0x61, 0x36, 0x32, 0x34, 0x32, 0x65, 0x38, 0x36, 0x39, 0x34, 0x31, 0x66, 0x66, 0x64, 0x36, 0x61, 0x64, 0x35, 0x32, 0x31, 0x32, 0x37, 0x66, 0x63, 0x37, 0x61, 0x66, 0x64, 0x38, 0x38, 0x64, 0x34, 0x37, 0x32, 0x36, 0x33, 0x35, 0x36, 0x31, 0x38, 0x33, 0x33, 0x38, 0x32, 0x64, 0x61, 0x32, 0x37, 0x31, 0x37, 0x32, 0x31, 0x33, 0x32, 0x62, 0x61, 0x30, 0x31, 0x35, 0x37, 0x34, 0x64, 0x38, 0x30, 0x61, 0x38, 0x61, 0x63, 0x37, 0x62, 0x31, 0x63, 0x63, 0x37, 0x39, 0x39, 0x36, 0x33, 0x32, 0x35, 0x35, 0x62, 0x30, 0x34, 0x30, 0x37, 0x64, 0x30, 0x30, 0x63, 0x36, 0x31, 0x32, 0x63, 0x37, 0x65, 0x37, 0x32, 0x37, 0x66, 0x62, 0x31, 0x35, 0x34, 0x31, 0x30, 0x31, 0x66, 0x30, 0x30, 0x30, 0x36, 0x37, 0x62, 0x36, 0x33, 0x30, 0x33, 0x37, 0x30, 0x66, 0x33, 0x64, 0x35, 0x34, 0x38, 0x36, 0x62, 0x32, 0x39, 0x65, 0x34, 0x36, 0x39, 0x63, 0x33, 0x62, 0x38, 0x32, 0x64, 0x63, 0x65, 0x33, 0x63, 0x33, 0x63, 0x62, 0x34, 0x33, 0x30, 0x61, 0x39, 0x62, 0x63, 0x65, 0x37, 0x64, 0x30, 0x66, 0x33, 0x37, 0x32, 0x63, 0x37, 0x63, 0x38, 0x63, 0x35, 0x31, 0x32, 0x65, 0x31, 0x34, 0x61, 0x35, 0x38, 0x63, 0x66, 0x31, 0x34, 0x63, 0x66, 0x39, 0x65, 0x66, 0x33, 0x34, 0x37, 0x62, 0x35, 0x65, 0x36, 0x66, 0x61, 0x66, 0x35, 0x65, 0x61, 0x36, 0x64, 0x61, 0x38, 0x62, 0x33, 0x33, 0x65, 0x63, 0x30, 0x32, 0x61, 0x39, 0x38, 0x31, 0x33, 0x64, 0x39, 0x34, 0x35, 0x35, 0x63, 0x33, 0x61, 0x64, 0x32, 0x37, 0x32, 0x37, 0x33, 0x34, 0x39, 0x64, 0x31, 0x39, 0x66, 0x66, 0x64, 0x30, 0x64, 0x36, 0x39, 0x33, 0x37, 0x63, 0x62, 0x36, 0x32, 0x32, 0x38, 0x61, 0x32, 0x36, 0x32, 0x34, 0x64, 0x37, 0x63, 0x31, 0x33, 0x34, 0x66, 0x63, 0x35, 0x32, 0x32, 0x34, 0x36, 0x30, 0x32, 0x34, 0x38, 0x39, 0x38, 0x31, 0x64, 0x31, 0x63, 0x30, 0x36, 0x33, 0x36, 0x62, 0x32, 0x66, 0x63, 0x65, 0x63, 0x65, 0x35, 0x31, 0x63, 0x37, 0x35, 0x32, 0x62, 0x30, 0x37, 0x35, 0x66, 0x35, 0x61, 0x31, 0x61, 0x38, 0x62, 0x33, 0x31, 0x38, 0x62, 0x35, 0x32, 0x64, 0x61, 0x36, 0x35, 0x34, 0x32, 0x33, 0x63, 0x31, 0x65, 0x64, 0x66, 0x37, 0x62, 0x31, 0x66, 0x33, 0x37, 0x62, 0x61, 0x35, 0x32, 0x38, 0x35, 0x63, 0x65, 0x64, 0x30, 0x34, 0x35, 0x62, 0x37, 0x63, 0x65, 0x66, 0x64, 0x38, 0x63, 0x36, 0x63, 0x61, 0x38, 0x33, 0x39, 0x35, 0x37, 0x38, 0x66, 0x32, 0x65, 0x37, 0x63, 0x62, 0x32, 0x62, 0x61, 0x33, 0x30, 0x31, 0x34, 0x64, 0x64, 0x33, 0x37, 0x30, 0x30, 0x34, 0x37, 0x34, 0x65, 0x36, 0x32, 0x35, 0x62, 0x34, 0x66, 0x38, 0x39, 0x31, 0x35, 0x38, 0x65, 0x39, 0x37, 0x63, 0x32, 0x64, 0x33, 0x65, 0x66, 0x64, 0x66, 0x31, 0x33, 0x64, 0x39, 0x38, 0x30, 0x33, 0x31, 0x64, 0x39, 0x32, 0x31, 0x37, 0x36, 0x37, 0x32, 0x66, 0x35, 0x35, 0x63, 0x36, 0x31, 0x32, 0x64, 0x37, 0x35, 0x64, 0x35, 0x31, 0x63, 0x63, 0x63, 0x36, 0x66, 0x66, 0x64, 0x62, 0x35, 0x37, 0x35, 0x39, 0x61, 0x36, 0x35, 0x38, 0x31, 0x36, 0x61, 0x30, 0x35, 0x61, 0x61, 0x65, 0x36, 0x62, 0x34, 0x38, 0x30, 0x30, 0x35, 0x39, 0x39, 0x36, 0x37, 0x39, 0x39, 0x66, 0x34, 0x35, 0x36, 0x38, 0x63, 0x66, 0x63, 0x31, 0x61, 0x37, 0x63, 0x37, 0x32, 0x62, 0x39, 0x63, 0x36, 0x31, 0x31, 0x32, 0x34, 0x63, 0x39, 0x65, 0x66, 0x37, 0x35, 0x39, 0x35, 0x36, 0x31, 0x33, 0x30, 0x38, 0x61, 0x62, 0x31, 0x36, 0x62, 0x32, 0x37, 0x32, 0x31, 0x61, 0x61, 0x66, 0x36, 0x66, 0x31, 0x32, 0x30, 0x30, 0x39, 0x36, 0x38, 0x30, 0x31, 0x32, 0x30, 0x35, 0x38, 0x31, 0x38, 0x61, 0x30, 0x33, 0x38, 0x63, 0x32, 0x30, 0x39, 0x37, 0x36, 0x36, 0x66, 0x32, 0x64, 0x39, 0x34, 0x64, 0x30, 0x35, 0x34, 0x66, 0x63, 0x37, 0x33, 0x32, 0x38, 0x63, 0x62, 0x35, 0x66, 0x37, 0x35, 0x36, 0x63, 0x63, 0x66, 0x65, 0x61, 0x65, 0x34, 0x34, 0x36, 0x36, 0x35, 0x37, 0x30, 0x36, 0x32, 0x38, 0x34, 0x33, 0x61, 0x39, 0x34, 0x34, 0x35, 0x32, 0x36, 0x31, 0x33, 0x38, 0x65, 0x64, 0x34, 0x37, 0x64, 0x38, 0x37, 0x38, 0x37, 0x66, 0x31, 0x33, 0x64, 0x31, 0x33, 0x37, 0x32, 0x36, 0x33, 0x61, 0x64, 0x65, 0x39, 0x66, 0x35, 0x33, 0x39, 0x37, 0x34, 0x66, 0x34, 0x66, 0x66, 0x31, 0x32, 0x66, 0x30, 0x66, 0x31, 0x39, 0x61, 0x37, 0x32, 0x37, 0x35, 0x38, 0x64, 0x36, 0x36, 0x64, 0x35, 0x38, 0x34, 0x32, 0x38, 0x66, 0x61, 0x64, 0x37, 0x61, 0x37, 0x61, 0x65, 0x34, 0x39, 0x39, 0x64, 0x66, 0x30, 0x64, 0x33, 0x39, 0x38, 0x31, 0x39, 0x31, 0x62, 0x62, 0x37, 0x37, 0x32, 0x39, 0x32, 0x61, 0x34, 0x37, 0x32, 0x39, 0x34, 0x31, 0x33, 0x38, 0x32, 0x36, 0x34, 0x63, 0x66, 0x62, 0x30, 0x36, 0x35, 0x36, 0x63, 0x65, 0x34, 0x62, 0x30, 0x31, 0x33, 0x62, 0x32, 0x34, 0x61, 0x61, 0x62, 0x33, 0x63, 0x37, 0x39, 0x33, 0x64, 0x34, 0x34, 0x32, 0x35, 0x38, 0x36, 0x31, 0x36, 0x31, 0x38, 0x62, 0x32, 0x61, 0x33, 0x34, 0x37, 0x65, 0x32, 0x30, 0x34, 0x62, 0x33, 0x32, 0x34, 0x35, 0x31, 0x38, 0x66, 0x63, 0x63, 0x62, 0x35, 0x36, 0x61, 0x33, 0x61, 0x63, 0x66, 0x36, 0x32, 0x38, 0x38, 0x39, 0x35, 0x64, 0x35, 0x33, 0x66, 0x34, 0x31, 0x31, 0x31, 0x30, 0x36, 0x34, 0x61, 0x63, 0x36, 0x38, 0x64, 0x33, 0x36, 0x36, 0x66, 0x33, 0x61, 0x66, 0x33, 0x38, 0x35, 0x63, 0x63, 0x66, 0x30, 0x33, 0x65, 0x35, 0x35, 0x63, 0x35, 0x63, 0x38, 0x66, 0x30, 0x34, 0x38, 0x31, 0x61, 0x65, 0x61, 0x36, 0x39, 0x66, 0x62, 0x35, 0x63, 0x35, 0x31, 0x65, 0x65, 0x38, 0x36, 0x61, 0x66, 0x30, 0x37, 0x35, 0x30, 0x62, 0x35, 0x32, 0x66, 0x62, 0x34, 0x39, 0x37, 0x38, 0x63, 0x32, 0x65, 0x31, 0x31, 0x30, 0x39, 0x66, 0x35, 0x32, 0x63, 0x35, 0x30, 0x65, 0x32, 0x66, 0x34, 0x31, 0x66, 0x34, 0x61, 0x39, 0x32, 0x65, 0x33, 0x35, 0x37, 0x64, 0x62, 0x61, 0x66, 0x31, 0x65, 0x37, 0x32, 0x64, 0x36, 0x31, 0x66, 0x37, 0x33, 0x65, 0x39, 0x35, 0x66, 0x62, 0x65, 0x66, 0x64, 0x64, 0x34, 0x39, 0x61, 0x37, 0x34, 0x37, 0x37, 0x31, 0x33, 0x31, 0x66, 0x32, 0x65, 0x64, 0x63, 0x30, 0x39, 0x31, 0x36, 0x61, 0x36, 0x31, 0x66, 0x64, 0x34, 0x30, 0x37, 0x63, 0x32, 0x33, 0x65, 0x31, 0x64, 0x36, 0x36, 0x30, 0x33, 0x37, 0x36, 0x65, 0x31, 0x34, 0x39, 0x35, 0x66, 0x61, 0x37, 0x37, 0x32, 0x35, 0x36, 0x34, 0x61, 0x35, 0x62, 0x63, 0x61, 0x64, 0x36, 0x36, 0x63, 0x34, 0x34, 0x65, 0x63, 0x61, 0x34, 0x61, 0x61, 0x39, 0x63, 0x32, 0x33, 0x32, 0x34, 0x34, 0x61, 0x36, 0x39, 0x35, 0x34, 0x35, 0x66, 0x38, 0x36, 0x38, 0x33, 0x64, 0x35, 0x36, 0x64, 0x38, 0x63, 0x61, 0x33, 0x30, 0x35, 0x62, 0x39, 0x33, 0x63, 0x63, 0x39, 0x66, 0x38, 0x32, 0x35, 0x36, 0x62, 0x30, 0x66, 0x35, 0x62, 0x64, 0x36, 0x39, 0x61, 0x31, 0x37, 0x32, 0x65, 0x30, 0x38, 0x37, 0x61, 0x66, 0x32, 0x65, 0x66, 0x36, 0x36, 0x63, 0x61, 0x38, 0x33, 0x39, 0x38, 0x34, 0x37, 0x34, 0x66, 0x39, 0x36, 0x61, 0x64, 0x36, 0x35, 0x32, 0x34, 0x62, 0x38, 0x31, 0x63, 0x34, 0x32, 0x36, 0x36, 0x65, 0x65, 0x32, 0x39, 0x34, 0x66, 0x39, 0x63, 0x33, 0x31, 0x30, 0x65, 0x35, 0x61, 0x34, 0x35, 0x37, 0x63, 0x37, 0x32, 0x35, 0x37, 0x31, 0x37, 0x37, 0x39, 0x64, 0x66, 0x39, 0x36, 0x30, 0x38, 0x63, 0x61, 0x32, 0x64, 0x31, 0x66, 0x32, 0x61, 0x33, 0x64, 0x61, 0x63, 0x64, 0x61, 0x39, 0x36, 0x30, 0x62, 0x34, 0x63, 0x39, 0x38, 0x31, 0x38, 0x38, 0x66, 0x39, 0x31, 0x34, 0x63, 0x66, 0x34, 0x32, 0x30, 0x63, 0x66, 0x66, 0x34, 0x36, 0x39, 0x63, 0x62, 0x37, 0x32, 0x36, 0x64, 0x37, 0x31, 0x32, 0x35, 0x36, 0x61, 0x63, 0x33, 0x33, 0x34, 0x36, 0x31, 0x35, 0x62, 0x38, 0x36, 0x32, 0x66, 0x61, 0x62, 0x36, 0x63, 0x39, 0x36, 0x30, 0x33, 0x66, 0x37, 0x62, 0x33, 0x36, 0x39, 0x31, 0x64, 0x63, 0x30, 0x66, 0x61, 0x39, 0x38, 0x65, 0x63, 0x37, 0x62, 0x66, 0x37, 0x66, 0x37, 0x34, 0x62, 0x30, 0x30, 0x30, 0x61, 0x36, 0x35, 0x39, 0x61, 0x63, 0x61, 0x30, 0x34, 0x34, 0x38, 0x35, 0x35, 0x36, 0x63, 0x37, 0x32, 0x34, 0x36, 0x30, 0x35, 0x33, 0x32, 0x62, 0x37, 0x32, 0x38, 0x32, 0x34, 0x39, 0x33, 0x36, 0x65, 0x35, 0x66, 0x31, 0x62, 0x39, 0x64, 0x30, 0x31, 0x61, 0x32, 0x34, 0x65, 0x61, 0x66, 0x64, 0x36, 0x62, 0x32, 0x38, 0x62, 0x32, 0x65, 0x63, 0x31, 0x35, 0x66, 0x34, 0x36, 0x63, 0x62, 0x39, 0x65, 0x31, 0x39, 0x35, 0x33, 0x62, 0x64, 0x64, 0x39, 0x32, 0x62, 0x37, 0x31, 0x65, 0x32, 0x34, 0x37, 0x31, 0x35, 0x36, 0x66, 0x31, 0x64, 0x30, 0x34, 0x62, 0x38, 0x38, 0x61, 0x66, 0x36, 0x66, 0x39, 0x62, 0x64, 0x38, 0x38, 0x35, 0x33, 0x30, 0x65, 0x37, 0x66, 0x34, 0x33, 0x61, 0x31, 0x31, 0x38, 0x63, 0x36, 0x65, 0x31, 0x65, 0x33, 0x34, 0x37, 0x62, 0x65, 0x37, 0x65, 0x39, 0x61, 0x37, 0x35, 0x39, 0x35, 0x38, 0x37, 0x39, 0x39, 0x30, 0x36, 0x62, 0x66, 0x36, 0x66, 0x61, 0x61, 0x32, 0x30, 0x64, 0x38, 0x64, 0x31, 0x34, 0x39, 0x66, 0x64, 0x39, 0x64, 0x64, 0x35, 0x61, 0x38, 0x32, 0x32, 0x39, 0x34, 0x65, 0x63, 0x66, 0x34, 0x64, 0x33, 0x66, 0x37, 0x35, 0x64, 0x39, 0x30, 0x63, 0x61, 0x33, 0x63, 0x64, 0x64, 0x65, 0x64, 0x36, 0x31, 0x39, 0x66, 0x31, 0x34, 0x34, 0x32, 0x62, 0x62, 0x63, 0x64, 0x37, 0x35, 0x33, 0x62, 0x37, 0x30, 0x35, 0x65, 0x66, 0x33, 0x39, 0x64, 0x32, 0x62, 0x30, 0x61, 0x64, 0x30, 0x31, 0x30, 0x63, 0x65, 0x64, 0x66, 0x64, 0x62, 0x30, 0x62, 0x64, 0x37, 0x61, 0x65, 0x39, 0x36, 0x39, 0x65, 0x35, 0x62, 0x36, 0x39, 0x32, 0x35, 0x66, 0x63, 0x35, 0x30, 0x64, 0x39, 0x31, 0x37, 0x36, 0x34, 0x32, 0x32, 0x62, 0x66, 0x37, 0x36, 0x62, 0x30, 0x33, 0x39, 0x31, 0x66, 0x32, 0x65, 0x62, 0x36, 0x32, 0x36, 0x64, 0x35, 0x34, 0x61, 0x61, 0x32, 0x37, 0x32, 0x35, 0x30, 0x62, 0x37, 0x34, 0x64, 0x37, 0x33, 0x37, 0x31, 0x61, 0x39, 0x37, 0x35, 0x62, 0x36, 0x32, 0x32, 0x31, 0x32, 0x63, 0x36, 0x66, 0x32, 0x61, 0x31, 0x37, 0x32, 0x31, 0x35, 0x30, 0x37, 0x36, 0x35, 0x38, 0x35, 0x64, 0x38, 0x65, 0x33, 0x31, 0x32, 0x61, 0x62, 0x34, 0x39, 0x38, 0x33, 0x62, 0x65, 0x33, 0x63, 0x36, 0x37, 0x64, 0x63, 0x39, 0x62, 0x65, 0x39, 0x62, 0x39, 0x37, 0x32, 0x32, 0x38, 0x30, 0x38, 0x63, 0x61, 0x37, 0x36, 0x62, 0x35, 0x63, 0x66, 0x34, 0x65, 0x64, 0x34, 0x32, 0x66, 0x33, 0x34, 0x33, 0x63, 0x30, 0x36, 0x32, 0x38, 0x64, 0x37, 0x66, 0x62, 0x38, 0x38, 0x64, 0x30, 0x35, 0x32, 0x33, 0x64, 0x36, 0x38, 0x63, 0x34, 0x63, 0x38, 0x31, 0x66, 0x66, 0x62, 0x37, 0x38, 0x61, 0x62, 0x65, 0x31, 0x63, 0x35, 0x33, 0x62, 0x31, 0x33, 0x39, 0x34, 0x37, 0x32, 0x63, 0x35, 0x32, 0x39, 0x37, 0x39, 0x61, 0x39, 0x38, 0x33, 0x66, 0x34, 0x64, 0x31, 0x66, 0x38, 0x64, 0x63, 0x34, 0x39, 0x36, 0x39, 0x36, 0x38, 0x33, 0x66, 0x62, 0x63, 0x37, 0x66, 0x36, 0x36, 0x64, 0x39, 0x63, 0x36, 0x39, 0x66, 0x66, 0x62, 0x31, 0x37, 0x65, 0x38, 0x38, 0x30, 0x36, 0x35, 0x38, 0x35, 0x61, 0x39, 0x65, 0x35, 0x34, 0x33, 0x65, 0x64, 0x66, 0x66, 0x61, 0x33, 0x32, 0x61, 0x35, 0x65, 0x64, 0x31, 0x65, 0x34, 0x62, 0x33, 0x34, 0x36, 0x61, 0x34, 0x36, 0x35, 0x64, 0x64, 0x65, 0x30, 0x33, 0x37, 0x39, 0x63, 0x62, 0x62, 0x39, 0x33, 0x32, 0x33, 0x64, 0x66, 0x34, 0x61, 0x36, 0x34, 0x66, 0x37, 0x34, 0x39, 0x65, 0x39, 0x63, 0x32, 0x36, 0x30, 0x63, 0x61, 0x38, 0x35, 0x30, 0x66, 0x33, 0x66, 0x62, 0x34, 0x32, 0x34, 0x65, 0x38, 0x62, 0x66, 0x65, 0x32, 0x32, 0x31, 0x37, 0x38, 0x61, 0x37, 0x39, 0x37, 0x65, 0x62, 0x37, 0x35, 0x37, 0x35, 0x38, 0x38, 0x32, 0x39, 0x38, 0x38, 0x35, 0x38, 0x36, 0x30, 0x37, 0x38, 0x64, 0x31, 0x38, 0x31, 0x62, 0x33, 0x37, 0x66, 0x65, 0x65, 0x31, 0x61, 0x62, 0x33, 0x34, 0x33, 0x38, 0x66, 0x63, 0x37, 0x38, 0x34, 0x39, 0x62, 0x65, 0x32, 0x37, 0x62, 0x31, 0x30, 0x34, 0x35, 0x66, 0x65, 0x34, 0x34, 0x63, 0x64, 0x37, 0x32, 0x39, 0x30, 0x37, 0x36, 0x38, 0x35, 0x63, 0x34, 0x61, 0x36, 0x66, 0x66, 0x65, 0x38, 0x65, 0x63, 0x65, 0x31, 0x65, 0x32, 0x64, 0x65, 0x64, 0x63, 0x33, 0x31, 0x62, 0x31, 0x34, 0x32, 0x34, 0x65, 0x33, 0x32, 0x33, 0x36, 0x62, 0x33, 0x62, 0x63, 0x31, 0x65, 0x34, 0x30, 0x35, 0x31, 0x63, 0x38, 0x39, 0x33, 0x39, 0x36, 0x35, 0x33, 0x38, 0x30, 0x36, 0x34, 0x65, 0x62, 0x34, 0x65, 0x36, 0x39, 0x36, 0x61, 0x30, 0x33, 0x37, 0x30, 0x62, 0x64, 0x36, 0x37, 0x63, 0x32, 0x66, 0x37, 0x33, 0x65, 0x64, 0x65, 0x39, 0x39, 0x35, 0x65, 0x39, 0x31, 0x39, 0x64, 0x32, 0x63, 0x64, 0x39, 0x30, 0x34, 0x65, 0x30, 0x35, 0x32, 0x37, 0x35, 0x33, 0x37, 0x65, 0x35, 0x61, 0x63, 0x36, 0x38, 0x33, 0x64, 0x63, 0x35, 0x62, 0x36, 0x39, 0x37, 0x63, 0x37, 0x30, 0x37, 0x32, 0x33, 0x63, 0x36, 0x37, 0x32, 0x61, 0x61, 0x38, 0x63, 0x31, 0x30, 0x32, 0x66, 0x30, 0x38, 0x37, 0x32, 0x63, 0x31, 0x30, 0x65, 0x62, 0x32, 0x33, 0x63, 0x66, 0x33, 0x30, 0x35, 0x31, 0x64, 0x61, 0x66, 0x35, 0x30, 0x34, 0x35, 0x32, 0x34, 0x32, 0x37, 0x61, 0x33, 0x32, 0x65, 0x38, 0x32, 0x38, 0x65, 0x61, 0x62, 0x32, 0x39, 0x66, 0x64, 0x39, 0x61, 0x33, 0x35, 0x36, 0x30, 0x61, 0x62, 0x38, 0x35, 0x32, 0x39, 0x31, 0x32, 0x38, 0x62, 0x30, 0x39, 0x66, 0x38, 0x65, 0x65, 0x34, 0x38, 0x30, 0x32, 0x61, 0x64, 0x36, 0x39, 0x33, 0x38, 0x30, 0x65, 0x31, 0x38, 0x37, 0x32, 0x33, 0x38, 0x66, 0x39, 0x34, 0x36, 0x37, 0x63, 0x64, 0x36, 0x38, 0x61, 0x37, 0x34, 0x34, 0x66, 0x35, 0x39, 0x63, 0x39, 0x63, 0x35, 0x66, 0x39, 0x35, 0x61, 0x63, 0x66, 0x35, 0x34, 0x34, 0x63, 0x64, 0x33, 0x65, 0x39, 0x36, 0x36, 0x34, 0x36, 0x63, 0x34, 0x33, 0x64, 0x64, 0x38, 0x33, 0x63, 0x64, 0x34, 0x66, 0x33, 0x64, 0x37, 0x33, 0x39, 0x39, 0x38, 0x33, 0x34, 0x62, 0x35, 0x34, 0x38, 0x31, 0x66, 0x32, 0x32, 0x39, 0x37, 0x35, 0x33, 0x35, 0x30, 0x31, 0x39, 0x66, 0x39, 0x31, 0x33, 0x34, 0x33, 0x66, 0x30, 0x66, 0x33, 0x39, 0x35, 0x63, 0x62, 0x30, 0x35, 0x61, 0x64, 0x30, 0x39, 0x61, 0x33, 0x31, 0x31, 0x36, 0x33, 0x37, 0x32, 0x35, 0x34, 0x65, 0x32, 0x37, 0x35, 0x62, 0x33, 0x34, 0x66, 0x64, 0x64, 0x38, 0x65, 0x64, 0x35, 0x32, 0x61, 0x31, 0x39, 0x37, 0x37, 0x33, 0x61, 0x34, 0x38, 0x63, 0x65, 0x36, 0x61, 0x36, 0x37, 0x65, 0x34, 0x35, 0x61, 0x37, 0x65, 0x39, 0x64, 0x64, 0x63, 0x33, 0x37, 0x62, 0x65, 0x64, 0x36, 0x30, 0x63, 0x32, 0x38, 0x39, 0x37, 0x33, 0x65, 0x37, 0x33, 0x37, 0x39, 0x63, 0x36, 0x33, 0x62, 0x64, 0x63, 0x64, 0x37, 0x30, 0x35, 0x63, 0x37, 0x65, 0x65, 0x65, 0x62, 0x35, 0x38, 0x31, 0x37, 0x34, 0x66, 0x64, 0x64, 0x32, 0x36, 0x30, 0x38, 0x38, 0x36, 0x34, 0x32, 0x63, 0x31, 0x37, 0x31, 0x62, 0x61, 0x30, 0x63, 0x32, 0x37, 0x32, 0x35, 0x31, 0x61, 0x64, 0x30, 0x63, 0x61, 0x33, 0x30, 0x35, 0x34, 0x32, 0x33, 0x32, 0x38, 0x39, 0x38, 0x32, 0x32, 0x37, 0x63, 0x64, 0x32, 0x37, 0x32, 0x30, 0x36, 0x66, 0x31, 0x65, 0x33, 0x61, 0x37, 0x34, 0x36, 0x35, 0x32, 0x63, 0x30, 0x63, 0x38, 0x35, 0x35, 0x36, 0x36, 0x32, 0x30, 0x31, 0x62, 0x65, 0x39, 0x36, 0x33, 0x30, 0x37, 0x30, 0x34, 0x35, 0x32, 0x34, 0x62, 0x32, 0x38, 0x36, 0x38, 0x38, 0x39, 0x35, 0x64, 0x61, 0x32, 0x37, 0x36, 0x39, 0x33, 0x35, 0x30, 0x36, 0x62, 0x39, 0x62, 0x31, 0x35, 0x63, 0x30, 0x35, 0x35, 0x30, 0x62, 0x62, 0x34, 0x38, 0x38, 0x39, 0x64, 0x65, 0x35, 0x66, 0x64, 0x64, 0x32, 0x36, 0x38, 0x34, 0x65, 0x62, 0x62, 0x35, 0x64, 0x37, 0x64, 0x36, 0x66, 0x30, 0x65, 0x61, 0x62, 0x38, 0x65, 0x31, 0x34, 0x62, 0x34, 0x39, 0x66, 0x64, 0x34, 0x36, 0x33, 0x37, 0x31, 0x66, 0x65, 0x34, 0x39, 0x62, 0x63, 0x33, 0x35, 0x31, 0x36, 0x65, 0x63, 0x62, 0x62, 0x66, 0x34, 0x61, 0x32, 0x31, 0x65, 0x37, 0x32, 0x64, 0x66, 0x64, 0x62, 0x39, 0x61, 0x63, 0x65, 0x61, 0x39, 0x39, 0x32, 0x31, 0x62, 0x31, 0x31, 0x65, 0x64, 0x30, 0x63, 0x31, 0x62, 0x37, 0x63, 0x37, 0x32, 0x31, 0x39, 0x61, 0x66, 0x31, 0x33, 0x32, 0x62, 0x37, 0x65, 0x65, 0x63, 0x64, 0x32, 0x39, 0x31, 0x64, 0x66, 0x37, 0x38, 0x65, 0x36, 0x63, 0x61, 0x63, 0x64, 0x39, 0x31, 0x34, 0x31, 0x66, 0x62, 0x32, 0x33, 0x34, 0x66, 0x37, 0x32, 0x38, 0x37, 0x36, 0x61, 0x39, 0x36, 0x62, 0x30, 0x63, 0x62, 0x39, 0x34, 0x65, 0x30, 0x65, 0x32, 0x62, 0x32, 0x32, 0x30, 0x34, 0x34, 0x37, 0x34, 0x66, 0x31, 0x64, 0x37, 0x31, 0x39, 0x61, 0x33, 0x30, 0x38, 0x35, 0x32, 0x36, 0x36, 0x32, 0x33, 0x36, 0x35, 0x64, 0x64, 0x65, 0x30, 0x62, 0x35, 0x63, 0x61, 0x64, 0x64, 0x33, 0x62, 0x62, 0x66, 0x64, 0x35, 0x32, 0x36, 0x31, 0x30, 0x37, 0x32, 0x31, 0x63, 0x65, 0x65, 0x39, 0x36, 0x61, 0x37, 0x36, 0x62, 0x65, 0x31, 0x34, 0x31, 0x35, 0x35, 0x32, 0x39, 0x63, 0x37, 0x63, 0x37, 0x37, 0x36, 0x31, 0x64, 0x36, 0x39, 0x35, 0x64, 0x63, 0x35, 0x32, 0x31, 0x31, 0x34, 0x61, 0x33, 0x63, 0x39, 0x35, 0x35, 0x37, 0x39, 0x64, 0x66, 0x31, 0x64, 0x30, 0x61, 0x64, 0x32, 0x31, 0x63, 0x35, 0x39, 0x66, 0x30, 0x37, 0x61, 0x31, 0x31, 0x34, 0x62, 0x64, 0x38, 0x33, 0x30, 0x31, 0x34, 0x37, 0x32, 0x31, 0x63, 0x62, 0x61, 0x34, 0x34, 0x36, 0x34, 0x61, 0x65, 0x35, 0x35, 0x66, 0x30, 0x61, 0x35, 0x36, 0x64, 0x31, 0x32, 0x32, 0x33, 0x34, 0x66, 0x31, 0x62, 0x39, 0x37, 0x39, 0x63, 0x35, 0x64, 0x35, 0x64, 0x31, 0x35, 0x35, 0x35, 0x64, 0x36, 0x37, 0x61, 0x63, 0x30, 0x37, 0x64, 0x34, 0x30, 0x63, 0x34, 0x36, 0x38, 0x31, 0x64, 0x37, 0x32, 0x39, 0x34, 0x32, 0x66, 0x66, 0x62, 0x32, 0x38, 0x32, 0x31, 0x61, 0x32, 0x38, 0x61, 0x66, 0x31, 0x37, 0x37, 0x33, 0x30, 0x31, 0x63, 0x39, 0x33, 0x30, 0x32, 0x63, 0x64, 0x64, 0x39, 0x32, 0x34, 0x33, 0x33, 0x33, 0x30, 0x35, 0x65, 0x30, 0x32, 0x61, 0x35, 0x66, 0x65, 0x39, 0x61, 0x31, 0x39, 0x64, 0x37, 0x37, 0x36, 0x63, 0x64, 0x39, 0x64, 0x63, 0x34, 0x62, 0x38, 0x63, 0x64, 0x37, 0x32, 0x65, 0x62, 0x39, 0x31, 0x36, 0x31, 0x34, 0x34, 0x32, 0x65, 0x61, 0x33, 0x62, 0x65, 0x66, 0x36, 0x39, 0x36, 0x64, 0x66, 0x36, 0x34, 0x39, 0x39, 0x63, 0x64, 0x30, 0x36, 0x61, 0x65, 0x66, 0x66, 0x39, 0x38, 0x32, 0x35, 0x34, 0x39, 0x66, 0x36, 0x39, 0x63, 0x36, 0x61, 0x64, 0x66, 0x39, 0x38, 0x34, 0x62, 0x37, 0x36, 0x39, 0x34, 0x66, 0x38, 0x65, 0x61, 0x63, 0x33, 0x30, 0x39, 0x37, 0x32, 0x65, 0x39, 0x32, 0x39, 0x64, 0x39, 0x62, 0x31, 0x63, 0x63, 0x34, 0x63, 0x63, 0x63, 0x31, 0x39, 0x36, 0x30, 0x32, 0x30, 0x61, 0x63, 0x32, 0x30, 0x33, 0x65, 0x64, 0x37, 0x61, 0x34, 0x66, 0x66, 0x32, 0x37, 0x61, 0x37, 0x39, 0x37, 0x33, 0x65, 0x66, 0x38, 0x66, 0x38, 0x61, 0x62, 0x38, 0x38, 0x64, 0x63, 0x39, 0x65, 0x62, 0x38, 0x39, 0x38, 0x36, 0x33, 0x38, 0x63, 0x35, 0x36, 0x35, 0x39, 0x38, 0x61, 0x36, 0x37, 0x31, 0x34, 0x33, 0x34, 0x30, 0x31, 0x30, 0x33, 0x31, 0x65, 0x33, 0x65, 0x39, 0x61, 0x34, 0x62, 0x61, 0x34, 0x31, 0x30, 0x35, 0x62, 0x32, 0x37, 0x61, 0x34, 0x33, 0x66, 0x35, 0x35, 0x63, 0x31, 0x61, 0x63, 0x35, 0x64, 0x30, 0x37, 0x64, 0x64, 0x32, 0x63, 0x38, 0x62, 0x65, 0x36, 0x30, 0x33, 0x33, 0x61, 0x31, 0x35, 0x66, 0x62, 0x32, 0x37, 0x37, 0x61, 0x36, 0x35, 0x62, 0x61, 0x30, 0x31, 0x31, 0x33, 0x32, 0x35, 0x33, 0x66, 0x66, 0x38, 0x61, 0x38, 0x35, 0x33, 0x35, 0x65, 0x31, 0x62, 0x37, 0x32, 0x65, 0x32, 0x31, 0x66, 0x61, 0x66, 0x64, 0x65, 0x34, 0x33, 0x38, 0x31, 0x35, 0x62, 0x66, 0x37, 0x36, 0x62, 0x62, 0x65, 0x37, 0x31, 0x39, 0x36, 0x38, 0x37, 0x31, 0x36, 0x39, 0x33, 0x62, 0x31, 0x34, 0x34, 0x33, 0x64, 0x31, 0x65, 0x66, 0x65, 0x37, 0x32, 0x34, 0x36, 0x62, 0x38, 0x39, 0x63, 0x37, 0x38, 0x61, 0x30, 0x64, 0x32, 0x32, 0x37, 0x64, 0x33, 0x39, 0x38, 0x65, 0x63, 0x37, 0x39, 0x62, 0x62, 0x33, 0x61, 0x64, 0x37, 0x37, 0x62, 0x38, 0x61, 0x31, 0x38, 0x37, 0x65, 0x62, 0x30, 0x66, 0x31, 0x61, 0x35, 0x30, 0x31, 0x61, 0x35, 0x39, 0x39, 0x37, 0x35, 0x32, 0x30, 0x62, 0x35, 0x36, 0x33, 0x35, 0x63, 0x33, 0x61, 0x64, 0x61, 0x33, 0x38, 0x33, 0x37, 0x38, 0x61, 0x34, 0x31, 0x34, 0x64, 0x34, 0x38, 0x63, 0x38, 0x34, 0x38, 0x64, 0x35, 0x64, 0x36, 0x30, 0x34, 0x64, 0x34, 0x33, 0x35, 0x61, 0x63, 0x33, 0x33, 0x31, 0x65, 0x33, 0x65, 0x64, 0x34, 0x63, 0x32, 0x61, 0x30, 0x31, 0x64, 0x30, 0x38, 0x39, 0x33, 0x35, 0x36, 0x30, 0x31, 0x38, 0x38, 0x33, 0x63, 0x35, 0x65, 0x62, 0x35, 0x62, 0x38, 0x33, 0x62, 0x38, 0x32, 0x37, 0x32, 0x62, 0x63, 0x38, 0x34, 0x31, 0x31, 0x31, 0x32, 0x35, 0x39, 0x64, 0x65, 0x38, 0x34, 0x66, 0x33, 0x37, 0x31, 0x30, 0x61, 0x33, 0x63, 0x65, 0x36, 0x37, 0x34, 0x34, 0x35, 0x31, 0x65, 0x66, 0x66, 0x36, 0x38, 0x36, 0x31, 0x31, 0x30, 0x63, 0x36, 0x37, 0x62, 0x31, 0x36, 0x66, 0x65, 0x35, 0x61, 0x36, 0x65, 0x64, 0x32, 0x61, 0x37, 0x33, 0x39, 0x31, 0x66, 0x37, 0x33, 0x66, 0x33, 0x37, 0x32, 0x30, 0x65, 0x65, 0x31, 0x32, 0x65, 0x33, 0x37, 0x61, 0x63, 0x64, 0x66, 0x61, 0x36, 0x32, 0x38, 0x31, 0x35, 0x34, 0x33, 0x32, 0x38, 0x64, 0x65, 0x30, 0x38, 0x35, 0x38, 0x35, 0x31, 0x35, 0x61, 0x37, 0x61, 0x38, 0x30, 0x38, 0x63, 0x35, 0x34, 0x65, 0x32, 0x33, 0x35, 0x30, 0x35, 0x38, 0x65, 0x62, 0x62, 0x35, 0x37, 0x63, 0x64, 0x34, 0x31, 0x37, 0x63, 0x34, 0x39, 0x30, 0x64, 0x37, 0x32, 0x33, 0x33, 0x38, 0x32, 0x33, 0x31, 0x39, 0x31, 0x30, 0x66, 0x63, 0x31, 0x39, 0x34, 0x30, 0x37, 0x39, 0x38, 0x34, 0x36, 0x65, 0x36, 0x64, 0x39, 0x61, 0x64, 0x62, 0x61, 0x31, 0x61, 0x65, 0x64, 0x32, 0x38, 0x31, 0x38, 0x35, 0x35, 0x62, 0x36, 0x62, 0x32, 0x39, 0x39, 0x61, 0x35, 0x66, 0x38, 0x38, 0x64, 0x61, 0x36, 0x36, 0x32, 0x64, 0x62, 0x30, 0x64, 0x39, 0x34, 0x33, 0x35, 0x37, 0x32, 0x35, 0x64, 0x66, 0x65, 0x39, 0x33, 0x34, 0x30, 0x37, 0x65, 0x31, 0x31, 0x35, 0x66, 0x65, 0x35, 0x61, 0x30, 0x34, 0x38, 0x64, 0x31, 0x37, 0x39, 0x62, 0x31, 0x37, 0x30, 0x34, 0x34, 0x38, 0x35, 0x62, 0x38, 0x33, 0x39, 0x65, 0x36, 0x61, 0x61, 0x30, 0x62, 0x31, 0x38, 0x39, 0x61, 0x33, 0x31, 0x32, 0x34, 0x32, 0x32, 0x64, 0x38, 0x39, 0x62, 0x33, 0x61, 0x39, 0x34, 0x66, 0x30, 0x32, 0x61, 0x30, 0x63, 0x34, 0x64, 0x37, 0x33, 0x34, 0x63, 0x64, 0x33, 0x66, 0x37, 0x31, 0x35, 0x31, 0x66, 0x33, 0x39, 0x31, 0x39, 0x62, 0x61, 0x34, 0x66, 0x34, 0x65, 0x36, 0x34, 0x34, 0x32, 0x61, 0x33, 0x62, 0x33, 0x37, 0x61, 0x63, 0x38, 0x32, 0x39, 0x63, 0x66, 0x31, 0x38, 0x36, 0x66, 0x61, 0x35, 0x39, 0x61, 0x35, 0x61, 0x36, 0x33, 0x30, 0x39, 0x36, 0x35, 0x35, 0x63, 0x33, 0x65, 0x31, 0x36, 0x34, 0x38, 0x34, 0x36, 0x62, 0x39, 0x64, 0x64, 0x61, 0x65, 0x35, 0x33, 0x30, 0x30, 0x37, 0x38, 0x35, 0x37, 0x66, 0x35, 0x64, 0x64, 0x63, 0x33, 0x34, 0x63, 0x33, 0x32, 0x64, 0x39, 0x33, 0x35, 0x31, 0x31, 0x36, 0x34, 0x61, 0x62, 0x30, 0x38, 0x64, 0x64, 0x32, 0x62, 0x64, 0x38, 0x38, 0x33, 0x63, 0x63, 0x39, 0x63, 0x63, 0x38, 0x38, 0x64, 0x36, 0x62, 0x66, 0x33, 0x32, 0x66, 0x37, 0x32, 0x31, 0x64, 0x35, 0x34, 0x66, 0x33, 0x65, 0x37, 0x38, 0x66, 0x36, 0x37, 0x64, 0x39, 0x34, 0x34, 0x38, 0x63, 0x66, 0x39, 0x30, 0x30, 0x35, 0x65, 0x64, 0x35, 0x66, 0x63, 0x64, 0x30, 0x39, 0x66, 0x66, 0x64, 0x32, 0x63, 0x63, 0x62, 0x32, 0x63, 0x34, 0x61, 0x66, 0x66, 0x35, 0x32, 0x33, 0x63, 0x38, 0x63, 0x35, 0x62, 0x39, 0x35, 0x31, 0x30, 0x66, 0x37, 0x39, 0x33, 0x36, 0x61, 0x37, 0x32, 0x63, 0x37, 0x36, 0x62, 0x31, 0x66, 0x39, 0x32, 0x32, 0x33, 0x63, 0x31, 0x37, 0x32, 0x39, 0x65, 0x64, 0x66, 0x38, 0x33, 0x39, 0x65, 0x65, 0x62, 0x35, 0x36, 0x33, 0x62, 0x30, 0x64, 0x34, 0x32, 0x64, 0x66, 0x62, 0x38, 0x32, 0x61, 0x63, 0x34, 0x65, 0x39, 0x64, 0x34, 0x32, 0x66, 0x34, 0x36, 0x63, 0x64, 0x39, 0x39, 0x64, 0x34, 0x62, 0x31, 0x33, 0x65, 0x62, 0x33, 0x38, 0x36, 0x37, 0x32, 0x61, 0x64, 0x65, 0x63, 0x63, 0x33, 0x30, 0x36, 0x62, 0x65, 0x31, 0x30, 0x39, 0x34, 0x32, 0x61, 0x36, 0x34, 0x38, 0x32, 0x63, 0x38, 0x32, 0x34, 0x39, 0x37, 0x38, 0x33, 0x66, 0x32, 0x62, 0x64, 0x39, 0x36, 0x39, 0x30, 0x35, 0x62, 0x64, 0x32, 0x64, 0x32, 0x64, 0x63, 0x66, 0x64, 0x61, 0x66, 0x62, 0x62, 0x30, 0x36, 0x36, 0x63, 0x66, 0x39, 0x37, 0x64, 0x36, 0x61, 0x30, 0x31, 0x37, 0x32, 0x35, 0x36, 0x66, 0x30, 0x61, 0x61, 0x65, 0x62, 0x31, 0x30, 0x32, 0x36, 0x31, 0x37, 0x38, 0x39, 0x38, 0x61, 0x66, 0x39, 0x64, 0x63, 0x32, 0x39, 0x66, 0x64, 0x62, 0x37, 0x39, 0x34, 0x35, 0x35, 0x34, 0x61, 0x34, 0x39, 0x34, 0x66, 0x37, 0x66, 0x37, 0x64, 0x35, 0x65, 0x66, 0x65, 0x61, 0x32, 0x30, 0x38, 0x61, 0x62, 0x64, 0x64, 0x37, 0x61, 0x65, 0x66, 0x39, 0x31, 0x30, 0x64, 0x37, 0x32, 0x30, 0x66, 0x30, 0x31, 0x64, 0x38, 0x34, 0x31, 0x63, 0x35, 0x66, 0x37, 0x64, 0x32, 0x66, 0x31, 0x65, 0x36, 0x62, 0x31, 0x36, 0x39, 0x61, 0x30, 0x64, 0x37, 0x35, 0x66, 0x37, 0x37, 0x63, 0x37, 0x62, 0x30, 0x62, 0x32, 0x63, 0x63, 0x32, 0x66, 0x64, 0x66, 0x63, 0x63, 0x66, 0x33, 0x65, 0x33, 0x30, 0x38, 0x33, 0x33, 0x64, 0x63, 0x36, 0x64, 0x34, 0x33, 0x64, 0x34, 0x65, 0x65, 0x33, 0x30, 0x37, 0x61, 0x39, 0x31, 0x62, 0x63, 0x32, 0x62, 0x66, 0x32, 0x38, 0x32, 0x34, 0x38, 0x39, 0x34, 0x33, 0x35, 0x36, 0x35, 0x65, 0x38, 0x31, 0x64, 0x62, 0x65, 0x66, 0x64, 0x61, 0x38, 0x32, 0x30, 0x39, 0x38, 0x39, 0x33, 0x38, 0x61, 0x66, 0x64, 0x33, 0x38, 0x64, 0x39, 0x61, 0x63, 0x30, 0x66, 0x35, 0x35, 0x33, 0x66, 0x30, 0x38, 0x61, 0x64, 0x32, 0x66, 0x32, 0x32, 0x31, 0x61, 0x37, 0x32, 0x62, 0x32, 0x30, 0x65, 0x63, 0x33, 0x33, 0x63, 0x61, 0x36, 0x37, 0x63, 0x37, 0x36, 0x39, 0x38, 0x63, 0x31, 0x38, 0x36, 0x30, 0x61, 0x39, 0x65, 0x64, 0x33, 0x37, 0x37, 0x31, 0x64, 0x34, 0x65, 0x31, 0x36, 0x34, 0x62, 0x64, 0x63, 0x36, 0x36, 0x30, 0x39, 0x63, 0x32, 0x30, 0x66, 0x37, 0x36, 0x32, 0x33, 0x38, 0x39, 0x39, 0x37, 0x34, 0x36, 0x34, 0x64, 0x34, 0x35, 0x36, 0x37, 0x30, 0x34, 0x38, 0x33, 0x31, 0x66, 0x65, 0x65, 0x61, 0x32, 0x39, 0x64, 0x63, 0x63, 0x34, 0x38, 0x38, 0x30, 0x34, 0x35, 0x33, 0x62, 0x61, 0x37, 0x31, 0x38, 0x64, 0x61, 0x39, 0x36, 0x38, 0x39, 0x33, 0x66, 0x65, 0x33, 0x39, 0x66, 0x37, 0x63, 0x65, 0x35, 0x31, 0x34, 0x32, 0x37, 0x36, 0x64, 0x32, 0x63, 0x66, 0x37, 0x64, 0x37, 0x38, 0x35, 0x66, 0x62, 0x61, 0x66, 0x62, 0x30, 0x64, 0x66, 0x37, 0x32, 0x64, 0x66, 0x39, 0x35, 0x65, 0x64, 0x34, 0x62, 0x62, 0x65, 0x61, 0x62, 0x64, 0x36, 0x37, 0x63, 0x33, 0x65, 0x33, 0x36, 0x31, 0x30, 0x62, 0x36, 0x34, 0x33, 0x39, 0x65, 0x30, 0x32, 0x33, 0x34, 0x32, 0x34, 0x39, 0x34, 0x62, 0x61, 0x38, 0x37, 0x35, 0x37, 0x35, 0x39, 0x61, 0x30, 0x36, 0x61, 0x32, 0x62, 0x30, 0x66, 0x32, 0x62, 0x64, 0x62, 0x36, 0x62, 0x30, 0x31, 0x33, 0x39, 0x37, 0x32, 0x37, 0x32, 0x37, 0x33, 0x35, 0x33, 0x63, 0x63, 0x37, 0x66, 0x61, 0x34, 0x65, 0x62, 0x33, 0x64, 0x63, 0x32, 0x61, 0x66, 0x38, 0x32, 0x37, 0x31, 0x65, 0x36, 0x30, 0x35, 0x38, 0x35, 0x66, 0x63, 0x65, 0x65, 0x33, 0x32, 0x61, 0x63, 0x35, 0x39, 0x65, 0x37, 0x32, 0x64, 0x31, 0x32, 0x35, 0x37, 0x64, 0x35, 0x39, 0x65, 0x39, 0x34, 0x35, 0x61, 0x31, 0x32, 0x38, 0x37, 0x38, 0x62, 0x37, 0x32, 0x32, 0x36, 0x30, 0x32, 0x63, 0x32, 0x39, 0x31, 0x66, 0x61, 0x31, 0x35, 0x63, 0x37, 0x37, 0x37, 0x34, 0x37, 0x66, 0x65, 0x38, 0x66, 0x37, 0x37, 0x37, 0x37, 0x32, 0x34, 0x34, 0x66, 0x35, 0x32, 0x30, 0x64, 0x62, 0x61, 0x35, 0x36, 0x65, 0x30, 0x62, 0x30, 0x31, 0x65, 0x66, 0x62, 0x66, 0x31, 0x30, 0x32, 0x30, 0x65, 0x33, 0x31, 0x32, 0x37, 0x30, 0x32, 0x35, 0x66, 0x34, 0x37, 0x37, 0x32, 0x37, 0x64, 0x34, 0x36, 0x30, 0x31, 0x36, 0x32, 0x39, 0x30, 0x34, 0x62, 0x64, 0x66, 0x39, 0x63, 0x62, 0x39, 0x61, 0x66, 0x37, 0x34, 0x33, 0x66, 0x33, 0x63, 0x65, 0x36, 0x32, 0x62, 0x64, 0x36, 0x65, 0x37, 0x34, 0x38, 0x65, 0x64, 0x39, 0x39, 0x35, 0x30, 0x36, 0x32, 0x66, 0x30, 0x30, 0x62, 0x30, 0x66, 0x36, 0x62, 0x61, 0x36, 0x35, 0x62, 0x32, 0x33, 0x38, 0x34, 0x62, 0x30, 0x37, 0x32, 0x30, 0x64, 0x30, 0x36, 0x32, 0x30, 0x39, 0x37, 0x30, 0x39, 0x36, 0x37, 0x66, 0x31, 0x61, 0x30, 0x62, 0x66, 0x63, 0x34, 0x36, 0x38, 0x34, 0x66, 0x39, 0x64, 0x31, 0x31, 0x39, 0x64, 0x34, 0x35, 0x35, 0x65, 0x39, 0x62, 0x64, 0x31, 0x65, 0x35, 0x66, 0x31, 0x36, 0x64, 0x31, 0x64, 0x65, 0x35, 0x37, 0x61, 0x33, 0x32, 0x63, 0x32, 0x63, 0x39, 0x64, 0x35, 0x34, 0x36, 0x30, 0x36, 0x33, 0x34, 0x35, 0x30, 0x31, 0x63, 0x34, 0x61, 0x63, 0x39, 0x64, 0x30, 0x62, 0x32, 0x66, 0x32, 0x39, 0x37, 0x36, 0x39, 0x36, 0x36, 0x62, 0x30, 0x66, 0x31, 0x62, 0x37, 0x65, 0x65, 0x39, 0x63, 0x37, 0x35, 0x35, 0x63, 0x37, 0x31, 0x38, 0x38, 0x64, 0x35, 0x65, 0x35, 0x65, 0x36, 0x37, 0x37, 0x39, 0x38, 0x39, 0x31, 0x38, 0x35, 0x34, 0x65, 0x32, 0x39, 0x30, 0x62, 0x33, 0x37, 0x66, 0x33, 0x37, 0x32, 0x38, 0x64, 0x37, 0x36, 0x38, 0x30, 0x61, 0x66, 0x34, 0x66, 0x39, 0x32, 0x61, 0x61, 0x65, 0x66, 0x38, 0x61, 0x62, 0x36, 0x61, 0x65, 0x63, 0x61, 0x62, 0x37, 0x64, 0x65, 0x30, 0x62, 0x37, 0x31, 0x65, 0x66, 0x65, 0x34, 0x34, 0x30, 0x31, 0x32, 0x35, 0x31, 0x63, 0x37, 0x63, 0x39, 0x66, 0x33, 0x64, 0x34, 0x31, 0x35, 0x34, 0x35, 0x63, 0x61, 0x61, 0x35, 0x64, 0x39, 0x37, 0x66, 0x37, 0x30, 0x65, 0x65, 0x61, 0x65, 0x32, 0x36, 0x39, 0x62, 0x39, 0x32, 0x36, 0x33, 0x65, 0x39, 0x30, 0x64, 0x62, 0x66, 0x66, 0x63, 0x39, 0x39, 0x30, 0x38, 0x63, 0x32, 0x34, 0x64, 0x30, 0x38, 0x32, 0x31, 0x64, 0x63, 0x31, 0x32, 0x65, 0x66, 0x39, 0x38, 0x32, 0x31, 0x64, 0x63, 0x30, 0x63, 0x36, 0x63, 0x38, 0x61, 0x39, 0x65, 0x63, 0x39, 0x35, 0x39, 0x36, 0x37, 0x61, 0x63, 0x32, 0x37, 0x37, 0x32, 0x33, 0x38, 0x66, 0x36, 0x37, 0x61, 0x64, 0x30, 0x36, 0x31, 0x66, 0x62, 0x36, 0x37, 0x37, 0x33, 0x35, 0x38, 0x66, 0x61, 0x30, 0x37, 0x39, 0x31, 0x65, 0x33, 0x65, 0x35, 0x38, 0x63, 0x63, 0x33, 0x61, 0x65, 0x31, 0x38, 0x31, 0x30, 0x30, 0x39, 0x65, 0x35, 0x64, 0x61, 0x35, 0x34, 0x62, 0x65, 0x33, 0x63, 0x65, 0x64, 0x62, 0x39, 0x65, 0x62, 0x62, 0x39, 0x36, 0x35, 0x61, 0x36, 0x30, 0x35, 0x34, 0x66, 0x62, 0x33, 0x38, 0x31, 0x33, 0x63, 0x66, 0x66, 0x34, 0x38, 0x36, 0x35, 0x39, 0x36, 0x66, 0x32, 0x66, 0x37, 0x61, 0x31, 0x30, 0x34, 0x39, 0x38, 0x33, 0x34, 0x61, 0x34, 0x33, 0x38, 0x30, 0x31, 0x37, 0x38, 0x37, 0x36, 0x66, 0x63, 0x65, 0x38, 0x31, 0x62, 0x62, 0x35, 0x64, 0x39, 0x39, 0x34, 0x30, 0x39, 0x61, 0x32, 0x62, 0x33, 0x33, 0x63, 0x38, 0x37, 0x33, 0x36, 0x37, 0x32, 0x65, 0x66, 0x32, 0x33, 0x30, 0x62, 0x31, 0x63, 0x32, 0x34, 0x31, 0x65, 0x65, 0x33, 0x39, 0x39, 0x61, 0x31, 0x39, 0x32, 0x39, 0x63, 0x36, 0x33, 0x35, 0x36, 0x37, 0x34, 0x33, 0x38, 0x39, 0x35, 0x39, 0x38, 0x33, 0x36, 0x39, 0x31, 0x62, 0x31, 0x64, 0x30, 0x32, 0x64, 0x66, 0x36, 0x62, 0x35, 0x38, 0x36, 0x61, 0x33, 0x38, 0x38, 0x32, 0x66, 0x36, 0x35, 0x34, 0x66, 0x64, 0x33, 0x32, 0x32, 0x64, 0x39, 0x64, 0x34, 0x30, 0x61, 0x35, 0x33, 0x31, 0x34, 0x37, 0x30, 0x33, 0x36, 0x30, 0x37, 0x38, 0x62, 0x30, 0x34, 0x65, 0x64, 0x61, 0x33, 0x64, 0x34, 0x34, 0x38, 0x65, 0x64, 0x33, 0x63, 0x34, 0x61, 0x65, 0x65, 0x31, 0x61, 0x66, 0x30, 0x32, 0x30, 0x32, 0x65, 0x32, 0x63, 0x62, 0x65, 0x31, 0x30, 0x64, 0x62, 0x32, 0x35, 0x61, 0x33, 0x66, 0x37, 0x62, 0x35, 0x39, 0x64, 0x37, 0x32, 0x37, 0x35, 0x33, 0x38, 0x38, 0x66, 0x35, 0x66, 0x39, 0x39, 0x39, 0x31, 0x34, 0x66, 0x65, 0x62, 0x64, 0x33, 0x66, 0x38, 0x64, 0x35, 0x37, 0x39, 0x39, 0x37, 0x32, 0x34, 0x62, 0x65, 0x66, 0x34, 0x37, 0x32, 0x37, 0x33, 0x33, 0x39, 0x61, 0x34, 0x34, 0x36, 0x37, 0x32, 0x61, 0x62, 0x36, 0x66, 0x33, 0x36, 0x33, 0x33, 0x37, 0x32, 0x39, 0x31, 0x33, 0x66, 0x66, 0x66, 0x64, 0x39, 0x37, 0x32, 0x65, 0x33, 0x30, 0x32, 0x36, 0x35, 0x31, 0x35, 0x39, 0x34, 0x65, 0x61, 0x64, 0x37, 0x38, 0x32, 0x38, 0x37, 0x31, 0x63, 0x33, 0x30, 0x65, 0x36, 0x39, 0x64, 0x39, 0x31, 0x38, 0x35, 0x34, 0x35, 0x32, 0x34, 0x33, 0x66, 0x34, 0x33, 0x39, 0x39, 0x31, 0x34, 0x35, 0x37, 0x37, 0x37, 0x64, 0x32, 0x35, 0x33, 0x33, 0x34, 0x31, 0x34, 0x66, 0x64, 0x61, 0x65, 0x31, 0x64, 0x65, 0x31, 0x32, 0x66, 0x64, 0x38, 0x35, 0x35, 0x33, 0x66, 0x32, 0x63, 0x35, 0x39, 0x39, 0x66, 0x32, 0x65, 0x64, 0x66, 0x65, 0x32, 0x61, 0x34, 0x30, 0x39, 0x36, 0x65, 0x64, 0x65, 0x33, 0x36, 0x66, 0x34, 0x39, 0x63, 0x34, 0x35, 0x61, 0x39, 0x39, 0x62, 0x32, 0x37, 0x64, 0x61, 0x66, 0x35, 0x33, 0x63, 0x37, 0x37, 0x35, 0x65, 0x38, 0x35, 0x31, 0x36, 0x66, 0x33, 0x63, 0x37, 0x62, 0x62, 0x31, 0x30, 0x30, 0x63, 0x32, 0x35, 0x39, 0x39, 0x35, 0x65, 0x37, 0x35, 0x33, 0x37, 0x33, 0x38, 0x33, 0x66, 0x31, 0x32, 0x32, 0x33, 0x32, 0x63, 0x37, 0x64, 0x37, 0x37, 0x33, 0x35, 0x31, 0x33, 0x33, 0x35, 0x35, 0x38, 0x64, 0x31, 0x39, 0x61, 0x35, 0x65, 0x36, 0x62, 0x34, 0x37, 0x38, 0x65, 0x36, 0x36, 0x32, 0x61, 0x62, 0x38, 0x38, 0x36, 0x62, 0x35, 0x31, 0x63, 0x63, 0x30, 0x63, 0x30, 0x30, 0x35, 0x37, 0x32, 0x62, 0x35, 0x64, 0x38, 0x66, 0x35, 0x35, 0x38, 0x31, 0x32, 0x61, 0x32, 0x30, 0x33, 0x61, 0x37, 0x33, 0x31, 0x39, 0x39, 0x64, 0x33, 0x39, 0x61, 0x36, 0x38, 0x33, 0x38, 0x30, 0x36, 0x34, 0x63, 0x34, 0x63, 0x39, 0x38, 0x65, 0x36, 0x63, 0x37, 0x66, 0x33, 0x37, 0x30, 0x66, 0x66, 0x66, 0x64, 0x39, 0x39, 0x36, 0x38, 0x33, 0x34, 0x37, 0x35, 0x34, 0x36, 0x62, 0x33, 0x36, 0x38, 0x36, 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x33, 0x35, 0x64, 0x62, 0x66, 0x65, 0x66, 0x30, 0x63, 0x64, 0x62, 0x64, 0x39, 0x36, 0x31, 0x36, 0x33, 0x66, 0x31, 0x32, 0x39, 0x33, 0x34, 0x34, 0x30, 0x64, 0x36, 0x38, 0x38, 0x64, 0x65, 0x35, 0x35, 0x32, 0x62, 0x37, 0x33, 0x62, 0x64, 0x66, 0x62, 0x66, 0x37, 0x61, 0x64, 0x33, 0x61, 0x62, 0x63, 0x32, 0x61, 0x38, 0x65, 0x65, 0x66, 0x65, 0x38, 0x37, 0x32, 0x62, 0x32, 0x35, 0x36, 0x33, 0x39, 0x64, 0x65, 0x32, 0x36, 0x33, 0x61, 0x61, 0x61, 0x34, 0x30, 0x63, 0x64, 0x37, 0x38, 0x63, 0x33, 0x61, 0x34, 0x32, 0x65, 0x31, 0x63, 0x66, 0x34, 0x62, 0x65, 0x65, 0x35, 0x32, 0x61, 0x34, 0x39, 0x38, 0x65, 0x37, 0x66, 0x34, 0x63, 0x38, 0x32, 0x65, 0x33, 0x36, 0x33, 0x65, 0x62, 0x65, 0x37, 0x39, 0x37, 0x36, 0x66, 0x64, 0x63, 0x63, 0x64, 0x37, 0x32, 0x62, 0x63, 0x33, 0x34, 0x38, 0x33, 0x33, 0x35, 0x62, 0x64, 0x66, 0x32, 0x37, 0x65, 0x64, 0x62, 0x64, 0x65, 0x38, 0x61, 0x35, 0x61, 0x31, 0x31, 0x64, 0x63, 0x37, 0x30, 0x36, 0x64, 0x64, 0x39, 0x30, 0x66, 0x36, 0x38, 0x64, 0x66, 0x38, 0x62, 0x63, 0x66, 0x31, 0x66, 0x30, 0x61, 0x65, 0x37, 0x33, 0x31, 0x65, 0x64, 0x62, 0x39, 0x37, 0x61, 0x64, 0x31, 0x31, 0x38, 0x38, 0x39, 0x37, 0x32, 0x37, 0x62, 0x61, 0x66, 0x36, 0x30, 0x61, 0x39, 0x62, 0x37, 0x66, 0x30, 0x34, 0x38, 0x65, 0x64, 0x34, 0x62, 0x32, 0x63, 0x35, 0x31, 0x35, 0x36, 0x32, 0x63, 0x63, 0x38, 0x32, 0x62, 0x38, 0x32, 0x63, 0x34, 0x66, 0x37, 0x38, 0x61, 0x30, 0x38, 0x66, 0x61, 0x38, 0x65, 0x32, 0x34, 0x32, 0x35, 0x38, 0x31, 0x38, 0x66, 0x64, 0x35, 0x64, 0x38, 0x64, 0x63, 0x32, 0x39, 0x37, 0x33, 0x36, 0x31, 0x61, 0x33, 0x35, 0x39, 0x35, 0x61, 0x30, 0x35, 0x38, 0x35, 0x65, 0x35, 0x31, 0x66, 0x31, 0x61, 0x39, 0x61, 0x65, 0x37, 0x38, 0x61, 0x35, 0x62, 0x37, 0x64, 0x30, 0x64, 0x38, 0x32, 0x61, 0x64, 0x64, 0x64, 0x30, 0x39, 0x33, 0x37, 0x32, 0x36, 0x35, 0x64, 0x34, 0x39, 0x65, 0x35, 0x32, 0x37, 0x35, 0x35, 0x66, 0x35, 0x36, 0x63, 0x36, 0x38, 0x36, 0x35, 0x33, 0x39, 0x35, 0x37, 0x37, 0x32, 0x36, 0x31, 0x31, 0x61, 0x31, 0x38, 0x39, 0x62, 0x34, 0x62, 0x64, 0x39, 0x31, 0x62, 0x61, 0x37, 0x38, 0x30, 0x33, 0x63, 0x62, 0x64, 0x66, 0x30, 0x37, 0x34, 0x65, 0x64, 0x65, 0x32, 0x31, 0x37, 0x30, 0x61, 0x36, 0x62, 0x39, 0x39, 0x37, 0x30, 0x32, 0x37, 0x31, 0x61, 0x31, 0x38, 0x62, 0x63, 0x62, 0x32, 0x39, 0x66, 0x65, 0x38, 0x36, 0x39, 0x35, 0x61, 0x39, 0x35, 0x64, 0x64, 0x37, 0x32, 0x35, 0x63, 0x30, 0x32, 0x63, 0x33, 0x34, 0x31, 0x66, 0x32, 0x38, 0x37, 0x61, 0x32, 0x63, 0x62, 0x35, 0x37, 0x32, 0x39, 0x61, 0x34, 0x39, 0x37, 0x61, 0x63, 0x33, 0x66, 0x35, 0x63, 0x63, 0x32, 0x66, 0x61, 0x30, 0x65, 0x32, 0x63, 0x35, 0x62, 0x61, 0x65, 0x30, 0x61, 0x35, 0x36, 0x30, 0x64, 0x31, 0x63, 0x66, 0x31, 0x39, 0x62, 0x39, 0x37, 0x37, 0x34, 0x66, 0x39, 0x66, 0x64, 0x36, 0x63, 0x33, 0x62, 0x62, 0x35, 0x30, 0x32, 0x39, 0x32, 0x62, 0x62, 0x33, 0x30, 0x33, 0x61, 0x38, 0x34, 0x37, 0x66, 0x65, 0x33, 0x61, 0x63, 0x63, 0x30, 0x34, 0x37, 0x30, 0x37, 0x38, 0x63, 0x30, 0x32, 0x39, 0x63, 0x38, 0x33, 0x63, 0x64, 0x37, 0x64, 0x35, 0x36, 0x38, 0x33, 0x62, 0x38, 0x66, 0x62, 0x64, 0x62, 0x65, 0x61, 0x65, 0x39, 0x39, 0x32, 0x33, 0x37, 0x66, 0x65, 0x65, 0x32, 0x32, 0x35, 0x63, 0x31, 0x31, 0x65, 0x35, 0x39, 0x61, 0x64, 0x62, 0x61, 0x36, 0x36, 0x36, 0x63, 0x66, 0x33, 0x62, 0x39, 0x30, 0x66, 0x33, 0x38, 0x66, 0x66, 0x65, 0x64, 0x32, 0x63, 0x37, 0x37, 0x65, 0x38, 0x36, 0x37, 0x36, 0x37, 0x35, 0x37, 0x66, 0x64, 0x39, 0x38, 0x66, 0x37, 0x31, 0x35, 0x31, 0x31, 0x36, 0x33, 0x65, 0x34, 0x35, 0x36, 0x34, 0x38, 0x65, 0x62, 0x31, 0x38, 0x32, 0x66, 0x32, 0x30, 0x37, 0x30, 0x36, 0x32, 0x63, 0x38, 0x64, 0x30, 0x62, 0x37, 0x33, 0x66, 0x61, 0x35, 0x64, 0x30, 0x65, 0x63, 0x34, 0x30, 0x64, 0x39, 0x32, 0x38, 0x37, 0x39, 0x64, 0x36, 0x63, 0x65, 0x63, 0x36, 0x38, 0x33, 0x63, 0x34, 0x34, 0x34, 0x34, 0x33, 0x65, 0x37, 0x38, 0x34, 0x33, 0x65, 0x61, 0x30, 0x64, 0x65, 0x36, 0x30, 0x34, 0x33, 0x63, 0x31, 0x61, 0x62, 0x32, 0x66, 0x66, 0x34, 0x37, 0x32, 0x66, 0x34, 0x61, 0x32, 0x35, 0x61, 0x39, 0x30, 0x62, 0x32, 0x31, 0x66, 0x66, 0x38, 0x32, 0x38, 0x34, 0x64, 0x65, 0x66, 0x66, 0x66, 0x34, 0x38, 0x32, 0x62, 0x65, 0x36, 0x66, 0x33, 0x37, 0x36, 0x37, 0x39, 0x66, 0x64, 0x37, 0x32, 0x33, 0x65, 0x31, 0x38, 0x66, 0x61, 0x38, 0x66, 0x64, 0x35, 0x35, 0x36, 0x34, 0x35, 0x37, 0x39, 0x64, 0x37, 0x62, 0x31, 0x66, 0x30, 0x32, 0x39, 0x37, 0x32, 0x37, 0x30, 0x36, 0x34, 0x64, 0x36, 0x64, 0x63, 0x30, 0x39, 0x61, 0x33, 0x64, 0x30, 0x30, 0x65, 0x65, 0x33, 0x30, 0x61, 0x34, 0x30, 0x34, 0x30, 0x39, 0x39, 0x63, 0x65, 0x31, 0x62, 0x33, 0x34, 0x38, 0x38, 0x36, 0x65, 0x63, 0x37, 0x36, 0x65, 0x35, 0x30, 0x32, 0x32, 0x39, 0x65, 0x38, 0x32, 0x39, 0x31, 0x61, 0x37, 0x37, 0x39, 0x30, 0x63, 0x36, 0x62, 0x34, 0x36, 0x66, 0x61, 0x35, 0x62, 0x39, 0x63, 0x30, 0x39, 0x65, 0x64, 0x36, 0x61, 0x31, 0x30, 0x62, 0x32, 0x36, 0x33, 0x37, 0x63, 0x62, 0x65, 0x63, 0x62, 0x38, 0x65, 0x63, 0x38, 0x32, 0x61, 0x30, 0x37, 0x61, 0x38, 0x32, 0x66, 0x37, 0x33, 0x66, 0x31, 0x63, 0x31, 0x35, 0x34, 0x62, 0x39, 0x37, 0x61, 0x31, 0x34, 0x62, 0x31, 0x34, 0x32, 0x32, 0x63, 0x31, 0x64, 0x36, 0x65, 0x62, 0x66, 0x64, 0x32, 0x30, 0x64, 0x37, 0x31, 0x31, 0x30, 0x39, 0x36, 0x65, 0x66, 0x66, 0x32, 0x34, 0x65, 0x35, 0x65, 0x64, 0x62, 0x30, 0x35, 0x35, 0x33, 0x61, 0x66, 0x64, 0x64, 0x65, 0x38, 0x33, 0x65, 0x64, 0x35, 0x39, 0x62, 0x32, 0x33, 0x32, 0x64, 0x66, 0x39, 0x32, 0x36, 0x39, 0x64, 0x63, 0x65, 0x34, 0x62, 0x62, 0x31, 0x37, 0x33, 0x36, 0x31, 0x30, 0x30, 0x38, 0x66, 0x37, 0x62, 0x37, 0x33, 0x31, 0x62, 0x62, 0x34, 0x35, 0x66, 0x34, 0x33, 0x31, 0x64, 0x65, 0x30, 0x37, 0x35, 0x66, 0x31, 0x34, 0x31, 0x35, 0x39, 0x36, 0x62, 0x66, 0x65, 0x34, 0x61, 0x30, 0x38, 0x66, 0x63, 0x38, 0x66, 0x37, 0x30, 0x37, 0x61, 0x38, 0x62, 0x37, 0x65, 0x34, 0x66, 0x63, 0x63, 0x61, 0x63, 0x36, 0x66, 0x36, 0x30, 0x34, 0x38, 0x39, 0x65, 0x62, 0x38, 0x38, 0x30, 0x30, 0x38, 0x37, 0x32, 0x33, 0x64, 0x38, 0x31, 0x64, 0x37, 0x37, 0x32, 0x36, 0x31, 0x62, 0x37, 0x64, 0x32, 0x64, 0x64, 0x36, 0x63, 0x66, 0x34, 0x62, 0x32, 0x36, 0x62, 0x31, 0x62, 0x65, 0x34, 0x37, 0x31, 0x63, 0x63, 0x35, 0x35, 0x66, 0x37, 0x37, 0x34, 0x63, 0x34, 0x37, 0x39, 0x65, 0x66, 0x61, 0x36, 0x32, 0x39, 0x66, 0x66, 0x61, 0x35, 0x38, 0x30, 0x35, 0x30, 0x32, 0x39, 0x36, 0x34, 0x63, 0x36, 0x31, 0x61, 0x38, 0x39, 0x62, 0x39, 0x39, 0x38, 0x34, 0x30, 0x62, 0x61, 0x33, 0x36, 0x34, 0x38, 0x33, 0x63, 0x66, 0x63, 0x35, 0x66, 0x32, 0x61, 0x66, 0x39, 0x63, 0x62, 0x31, 0x64, 0x63, 0x37, 0x33, 0x36, 0x66, 0x33, 0x39, 0x38, 0x39, 0x66, 0x64, 0x61, 0x65, 0x32, 0x32, 0x33, 0x66, 0x34, 0x35, 0x61, 0x62, 0x30, 0x30, 0x66, 0x65, 0x63, 0x66, 0x66, 0x31, 0x39, 0x61, 0x39, 0x63, 0x37, 0x63, 0x35, 0x39, 0x61, 0x35, 0x39, 0x33, 0x33, 0x37, 0x32, 0x35, 0x33, 0x35, 0x65, 0x64, 0x63, 0x39, 0x66, 0x30, 0x33, 0x30, 0x36, 0x65, 0x32, 0x65, 0x61, 0x38, 0x35, 0x64, 0x33, 0x37, 0x63, 0x66, 0x64, 0x36, 0x36, 0x32, 0x66, 0x36, 0x33, 0x36, 0x35, 0x33, 0x63, 0x63, 0x61, 0x36, 0x35, 0x38, 0x62, 0x66, 0x64, 0x36, 0x37, 0x37, 0x31, 0x30, 0x32, 0x62, 0x30, 0x35, 0x64, 0x64, 0x35, 0x65, 0x61, 0x33, 0x39, 0x61, 0x31, 0x66, 0x30, 0x34, 0x30, 0x65, 0x62, 0x66, 0x33, 0x37, 0x31, 0x37, 0x61, 0x34, 0x66, 0x37, 0x34, 0x33, 0x39, 0x34, 0x61, 0x32, 0x35, 0x63, 0x61, 0x65, 0x35, 0x37, 0x63, 0x61, 0x32, 0x65, 0x30, 0x31, 0x33, 0x64, 0x38, 0x39, 0x37, 0x65, 0x65, 0x31, 0x30, 0x37, 0x63, 0x38, 0x30, 0x62, 0x65, 0x62, 0x66, 0x63, 0x62, 0x38, 0x30, 0x63, 0x65, 0x64, 0x38, 0x61, 0x64, 0x64, 0x30, 0x62, 0x33, 0x35, 0x35, 0x32, 0x33, 0x65, 0x36, 0x66, 0x39, 0x38, 0x61, 0x64, 0x33, 0x61, 0x39, 0x64, 0x66, 0x39, 0x38, 0x62, 0x33, 0x37, 0x37, 0x61, 0x32, 0x34, 0x31, 0x32, 0x65, 0x66, 0x61, 0x64, 0x39, 0x66, 0x37, 0x63, 0x30, 0x61, 0x61, 0x38, 0x36, 0x33, 0x36, 0x37, 0x36, 0x35, 0x64, 0x37, 0x66, 0x61, 0x38, 0x31, 0x33, 0x63, 0x30, 0x32, 0x37, 0x66, 0x63, 0x35, 0x39, 0x30, 0x63, 0x30, 0x31, 0x34, 0x39, 0x37, 0x32, 0x33, 0x62, 0x64, 0x65, 0x33, 0x63, 0x65, 0x38, 0x65, 0x63, 0x38, 0x38, 0x63, 0x62, 0x64, 0x32, 0x39, 0x31, 0x37, 0x37, 0x64, 0x37, 0x61, 0x33, 0x38, 0x63, 0x32, 0x33, 0x65, 0x61, 0x66, 0x66, 0x64, 0x65, 0x34, 0x37, 0x38, 0x31, 0x66, 0x33, 0x62, 0x64, 0x38, 0x34, 0x61, 0x64, 0x66, 0x35, 0x65, 0x63, 0x38, 0x39, 0x36, 0x62, 0x34, 0x34, 0x33, 0x32, 0x32, 0x30, 0x66, 0x36, 0x37, 0x32, 0x34, 0x37, 0x66, 0x62, 0x63, 0x38, 0x32, 0x64, 0x61, 0x62, 0x61, 0x32, 0x62, 0x35, 0x62, 0x63, 0x32, 0x62, 0x31, 0x65, 0x64, 0x62, 0x63, 0x30, 0x64, 0x31, 0x30, 0x64, 0x39, 0x63, 0x38, 0x64, 0x65, 0x38, 0x33, 0x32, 0x62, 0x32, 0x31, 0x36, 0x35, 0x63, 0x39, 0x33, 0x66, 0x31, 0x32, 0x36, 0x37, 0x36, 0x39, 0x32, 0x33, 0x35, 0x36, 0x37, 0x66, 0x64, 0x63, 0x63, 0x34, 0x65, 0x37, 0x32, 0x63, 0x39, 0x37, 0x31, 0x39, 0x66, 0x30, 0x31, 0x30, 0x64, 0x31, 0x37, 0x39, 0x61, 0x61, 0x39, 0x35, 0x39, 0x64, 0x65, 0x34, 0x66, 0x65, 0x30, 0x35, 0x35, 0x65, 0x33, 0x62, 0x61, 0x35, 0x30, 0x66, 0x31, 0x62, 0x37, 0x39, 0x34, 0x37, 0x37, 0x65, 0x31, 0x38, 0x63, 0x35, 0x34, 0x64, 0x65, 0x31, 0x62, 0x37, 0x66, 0x65, 0x33, 0x63, 0x62, 0x37, 0x33, 0x31, 0x65, 0x66, 0x33, 0x37, 0x32, 0x33, 0x64, 0x37, 0x34, 0x33, 0x39, 0x30, 0x37, 0x30, 0x61, 0x35, 0x62, 0x66, 0x39, 0x36, 0x62, 0x35, 0x38, 0x65, 0x63, 0x35, 0x39, 0x37, 0x39, 0x37, 0x33, 0x34, 0x61, 0x32, 0x34, 0x62, 0x63, 0x32, 0x64, 0x39, 0x35, 0x61, 0x66, 0x65, 0x66, 0x30, 0x39, 0x63, 0x38, 0x62, 0x64, 0x37, 0x39, 0x31, 0x65, 0x30, 0x63, 0x64, 0x30, 0x39, 0x38, 0x61, 0x30, 0x61, 0x61, 0x35, 0x39, 0x30, 0x39, 0x65, 0x30, 0x35, 0x35, 0x62, 0x61, 0x36, 0x35, 0x65, 0x64, 0x61, 0x65, 0x64, 0x66, 0x33, 0x38, 0x31, 0x32, 0x36, 0x30, 0x31, 0x31, 0x61, 0x62, 0x39, 0x62, 0x65, 0x33, 0x66, 0x39, 0x37, 0x63, 0x65, 0x32, 0x65, 0x33, 0x64, 0x66, 0x35, 0x62, 0x66, 0x64, 0x62, 0x65, 0x34, 0x32, 0x66, 0x35, 0x61, 0x32, 0x66, 0x65, 0x35, 0x63, 0x63, 0x61, 0x39, 0x61, 0x33, 0x30, 0x36, 0x61, 0x37, 0x32, 0x63, 0x39, 0x64, 0x33, 0x65, 0x35, 0x66, 0x62, 0x32, 0x39, 0x35, 0x63, 0x64, 0x37, 0x33, 0x33, 0x66, 0x65, 0x35, 0x38, 0x31, 0x64, 0x38, 0x62, 0x38, 0x34, 0x32, 0x39, 0x35, 0x35, 0x66, 0x63, 0x35, 0x39, 0x34, 0x61, 0x33, 0x38, 0x31, 0x62, 0x62, 0x64, 0x37, 0x38, 0x35, 0x61, 0x36, 0x61, 0x33, 0x66, 0x31, 0x38, 0x36, 0x38, 0x64, 0x35, 0x38, 0x38, 0x36, 0x63, 0x63, 0x36, 0x37, 0x32, 0x32, 0x61, 0x30, 0x66, 0x62, 0x33, 0x34, 0x35, 0x31, 0x61, 0x64, 0x65, 0x61, 0x64, 0x64, 0x34, 0x61, 0x65, 0x62, 0x33, 0x32, 0x34, 0x30, 0x62, 0x31, 0x31, 0x30, 0x63, 0x33, 0x38, 0x64, 0x65, 0x38, 0x34, 0x30, 0x39, 0x36, 0x36, 0x32, 0x35, 0x33, 0x34, 0x35, 0x65, 0x62, 0x30, 0x66, 0x66, 0x31, 0x33, 0x35, 0x33, 0x36, 0x61, 0x66, 0x35, 0x38, 0x34, 0x35, 0x63, 0x35, 0x30, 0x37, 0x32, 0x37, 0x34, 0x63, 0x62, 0x36, 0x30, 0x30, 0x34, 0x65, 0x32, 0x62, 0x65, 0x33, 0x37, 0x66, 0x61, 0x30, 0x30, 0x62, 0x62, 0x30, 0x37, 0x33, 0x64, 0x61, 0x62, 0x35, 0x36, 0x32, 0x36, 0x65, 0x30, 0x64, 0x63, 0x61, 0x34, 0x63, 0x61, 0x37, 0x32, 0x66, 0x61, 0x33, 0x31, 0x35, 0x66, 0x65, 0x38, 0x35, 0x66, 0x38, 0x33, 0x33, 0x38, 0x62, 0x39, 0x39, 0x31, 0x31, 0x64, 0x65, 0x61, 0x37, 0x30, 0x30, 0x33, 0x34, 0x35, 0x36, 0x66, 0x33, 0x62, 0x38, 0x38, 0x62, 0x35, 0x62, 0x64, 0x39, 0x32, 0x61, 0x32, 0x32, 0x37, 0x37, 0x34, 0x38, 0x61, 0x61, 0x32, 0x33, 0x35, 0x65, 0x38, 0x31, 0x63, 0x63, 0x31, 0x39, 0x65, 0x64, 0x35, 0x39, 0x38, 0x61, 0x65, 0x61, 0x31, 0x65, 0x65, 0x31, 0x65, 0x31, 0x35, 0x64, 0x35, 0x35, 0x30, 0x39, 0x34, 0x30, 0x64, 0x38, 0x36, 0x36, 0x31, 0x37, 0x32, 0x32, 0x30, 0x31, 0x65, 0x33, 0x32, 0x36, 0x33, 0x39, 0x66, 0x61, 0x65, 0x31, 0x36, 0x37, 0x33, 0x65, 0x38, 0x34, 0x64, 0x35, 0x35, 0x32, 0x64, 0x37, 0x35, 0x38, 0x61, 0x32, 0x34, 0x38, 0x64, 0x32, 0x30, 0x34, 0x33, 0x32, 0x61, 0x33, 0x62, 0x35, 0x35, 0x63, 0x62, 0x38, 0x61, 0x34, 0x63, 0x65, 0x31, 0x65, 0x66, 0x61, 0x34, 0x65, 0x38, 0x61, 0x66, 0x63, 0x32, 0x36, 0x36, 0x32, 0x39, 0x32, 0x62, 0x66, 0x34, 0x36, 0x38, 0x35, 0x63, 0x31, 0x39, 0x30, 0x38, 0x34, 0x63, 0x33, 0x39, 0x37, 0x63, 0x39, 0x33, 0x66, 0x61, 0x65, 0x34, 0x34, 0x35, 0x34, 0x64, 0x31, 0x34, 0x65, 0x65, 0x32, 0x62, 0x66, 0x64, 0x34, 0x34, 0x61, 0x61, 0x31, 0x63, 0x64, 0x33, 0x35, 0x66, 0x31, 0x31, 0x39, 0x32, 0x35, 0x38, 0x61, 0x32, 0x62, 0x39, 0x65, 0x39, 0x33, 0x36, 0x66, 0x66, 0x37, 0x32, 0x31, 0x34, 0x63, 0x65, 0x37, 0x65, 0x37, 0x38, 0x39, 0x32, 0x65, 0x63, 0x36, 0x61, 0x35, 0x32, 0x32, 0x30, 0x35, 0x61, 0x36, 0x62, 0x31, 0x61, 0x30, 0x64, 0x35, 0x36, 0x61, 0x31, 0x36, 0x32, 0x63, 0x66, 0x39, 0x38, 0x31, 0x37, 0x34, 0x32, 0x65, 0x64, 0x38, 0x37, 0x65, 0x34, 0x61, 0x36, 0x61, 0x32, 0x37, 0x63, 0x65, 0x36, 0x33, 0x64, 0x64, 0x33, 0x37, 0x32, 0x30, 0x63, 0x31, 0x35, 0x63, 0x66, 0x38, 0x61, 0x39, 0x38, 0x37, 0x66, 0x64, 0x31, 0x62, 0x31, 0x38, 0x36, 0x63, 0x66, 0x32, 0x33, 0x31, 0x64, 0x39, 0x38, 0x37, 0x36, 0x33, 0x62, 0x66, 0x35, 0x66, 0x63, 0x34, 0x33, 0x30, 0x30, 0x34, 0x66, 0x64, 0x38, 0x64, 0x38, 0x37, 0x38, 0x35, 0x65, 0x61, 0x64, 0x33, 0x62, 0x36, 0x37, 0x61, 0x61, 0x34, 0x61, 0x64, 0x30, 0x34, 0x61, 0x37, 0x30, 0x63, 0x37, 0x37, 0x32, 0x64, 0x36, 0x32, 0x38, 0x39, 0x61, 0x35, 0x35, 0x31, 0x65, 0x62, 0x34, 0x36, 0x33, 0x30, 0x38, 0x39, 0x63, 0x32, 0x61, 0x63, 0x64, 0x66, 0x65, 0x61, 0x34, 0x63, 0x37, 0x37, 0x66, 0x63, 0x37, 0x33, 0x35, 0x33, 0x65, 0x37, 0x35, 0x63, 0x66, 0x30, 0x37, 0x65, 0x36, 0x39, 0x63, 0x35, 0x33, 0x66, 0x38, 0x35, 0x32, 0x31, 0x33, 0x63, 0x30, 0x66, 0x62, 0x34, 0x61, 0x65, 0x35, 0x37, 0x32, 0x37, 0x30, 0x61, 0x66, 0x32, 0x61, 0x39, 0x66, 0x37, 0x30, 0x64, 0x64, 0x31, 0x31, 0x30, 0x35, 0x36, 0x38, 0x35, 0x65, 0x61, 0x66, 0x63, 0x35, 0x65, 0x62, 0x63, 0x62, 0x38, 0x64, 0x38, 0x37, 0x33, 0x37, 0x64, 0x34, 0x35, 0x34, 0x63, 0x64, 0x34, 0x65, 0x61, 0x31, 0x31, 0x63, 0x32, 0x30, 0x34, 0x35, 0x66, 0x36, 0x64, 0x32, 0x32, 0x62, 0x65, 0x38, 0x35, 0x63, 0x63, 0x38, 0x34, 0x64, 0x34, 0x35, 0x65, 0x38, 0x64, 0x65, 0x36, 0x64, 0x66, 0x64, 0x65, 0x37, 0x63, 0x66, 0x34, 0x62, 0x61, 0x65, 0x61, 0x36, 0x64, 0x62, 0x38, 0x66, 0x33, 0x30, 0x39, 0x63, 0x65, 0x38, 0x35, 0x37, 0x35, 0x66, 0x61, 0x63, 0x62, 0x61, 0x64, 0x37, 0x65, 0x63, 0x33, 0x61, 0x62, 0x35, 0x63, 0x38, 0x63, 0x63, 0x39, 0x35, 0x36, 0x34, 0x33, 0x31, 0x30, 0x31, 0x62, 0x33, 0x63, 0x64, 0x36, 0x37, 0x38, 0x64, 0x31, 0x36, 0x61, 0x35, 0x34, 0x65, 0x38, 0x35, 0x37, 0x63, 0x62, 0x37, 0x65, 0x32, 0x37, 0x66, 0x65, 0x37, 0x32, 0x35, 0x36, 0x62, 0x61, 0x30, 0x37, 0x35, 0x35, 0x64, 0x64, 0x38, 0x30, 0x34, 0x64, 0x36, 0x61, 0x61, 0x36, 0x62, 0x39, 0x37, 0x62, 0x36, 0x38, 0x36, 0x61, 0x30, 0x31, 0x31, 0x32, 0x61, 0x65, 0x36, 0x32, 0x61, 0x63, 0x30, 0x36, 0x33, 0x33, 0x61, 0x31, 0x62, 0x36, 0x32, 0x37, 0x34, 0x33, 0x65, 0x36, 0x63, 0x35, 0x36, 0x36, 0x37, 0x39, 0x35, 0x36, 0x66, 0x31, 0x37, 0x65, 0x39, 0x38, 0x65, 0x62, 0x64, 0x65, 0x62, 0x66, 0x33, 0x65, 0x32, 0x65, 0x36, 0x33, 0x66, 0x38, 0x33, 0x38, 0x34, 0x33, 0x31, 0x62, 0x30, 0x31, 0x66, 0x65, 0x35, 0x32, 0x38, 0x37, 0x38, 0x66, 0x64, 0x63, 0x38, 0x32, 0x39, 0x39, 0x33, 0x65, 0x64, 0x63, 0x34, 0x33, 0x65, 0x65, 0x61, 0x31, 0x35, 0x30, 0x64, 0x65, 0x36, 0x34, 0x32, 0x37, 0x66, 0x61, 0x37, 0x63, 0x62, 0x34, 0x61, 0x64, 0x36, 0x62, 0x31, 0x63, 0x37, 0x37, 0x39, 0x66, 0x66, 0x30, 0x33, 0x33, 0x32, 0x34, 0x65, 0x38, 0x61, 0x34, 0x39, 0x36, 0x39, 0x30, 0x36, 0x35, 0x31, 0x63, 0x64, 0x35, 0x38, 0x31, 0x35, 0x32, 0x33, 0x64, 0x64, 0x37, 0x62, 0x34, 0x63, 0x65, 0x62, 0x39, 0x33, 0x36, 0x62, 0x65, 0x34, 0x62, 0x30, 0x30, 0x35, 0x35, 0x33, 0x61, 0x66, 0x34, 0x38, 0x33, 0x37, 0x64, 0x36, 0x36, 0x37, 0x66, 0x65, 0x65, 0x31, 0x62, 0x34, 0x63, 0x66, 0x37, 0x33, 0x65, 0x31, 0x65, 0x35, 0x36, 0x64, 0x62, 0x35, 0x64, 0x61, 0x63, 0x62, 0x66, 0x37, 0x35, 0x32, 0x34, 0x64, 0x36, 0x38, 0x65, 0x61, 0x30, 0x34, 0x64, 0x34, 0x64, 0x35, 0x62, 0x61, 0x35, 0x33, 0x30, 0x62, 0x34, 0x30, 0x38, 0x66, 0x31, 0x36, 0x65, 0x61, 0x32, 0x65, 0x37, 0x30, 0x30, 0x63, 0x33, 0x36, 0x37, 0x34, 0x36, 0x63, 0x66, 0x39, 0x62, 0x33, 0x39, 0x64, 0x39, 0x36, 0x37, 0x33, 0x61, 0x62, 0x66, 0x31, 0x37, 0x64, 0x66, 0x38, 0x38, 0x63, 0x62, 0x30, 0x63, 0x36, 0x63, 0x39, 0x39, 0x64, 0x61, 0x34, 0x63, 0x36, 0x63, 0x62, 0x36, 0x37, 0x65, 0x61, 0x62, 0x63, 0x66, 0x33, 0x63, 0x33, 0x35, 0x37, 0x66, 0x38, 0x31, 0x36, 0x66, 0x64, 0x38, 0x62, 0x61, 0x65, 0x39, 0x33, 0x35, 0x39, 0x66, 0x39, 0x39, 0x62, 0x36, 0x39, 0x35, 0x62, 0x31, 0x36, 0x62, 0x65, 0x31, 0x32, 0x30, 0x62, 0x36, 0x37, 0x38, 0x31, 0x35, 0x33, 0x32, 0x35, 0x37, 0x31, 0x35, 0x63, 0x61, 0x39, 0x30, 0x34, 0x65, 0x34, 0x66, 0x35, 0x61, 0x30, 0x32, 0x36, 0x65, 0x32, 0x65, 0x33, 0x30, 0x66, 0x39, 0x32, 0x32, 0x37, 0x63, 0x33, 0x35, 0x63, 0x31, 0x64, 0x62, 0x35, 0x32, 0x32, 0x33, 0x32, 0x61, 0x64, 0x62, 0x33, 0x37, 0x65, 0x62, 0x39, 0x64, 0x33, 0x38, 0x35, 0x36, 0x63, 0x37, 0x37, 0x33, 0x35, 0x31, 0x64, 0x34, 0x65, 0x32, 0x35, 0x34, 0x35, 0x62, 0x61, 0x35, 0x35, 0x35, 0x62, 0x34, 0x39, 0x33, 0x35, 0x63, 0x63, 0x64, 0x35, 0x34, 0x38, 0x64, 0x37, 0x61, 0x64, 0x37, 0x32, 0x63, 0x36, 0x36, 0x34, 0x30, 0x66, 0x34, 0x37, 0x61, 0x65, 0x39, 0x36, 0x39, 0x33, 0x35, 0x36, 0x66, 0x61, 0x64, 0x30, 0x34, 0x66, 0x31, 0x37, 0x34, 0x32, 0x66, 0x30, 0x66, 0x34, 0x63, 0x66, 0x61, 0x36, 0x32, 0x35, 0x31, 0x34, 0x30, 0x31, 0x33, 0x66, 0x66, 0x34, 0x37, 0x62, 0x66, 0x31, 0x33, 0x33, 0x64, 0x38, 0x38, 0x35, 0x66, 0x65, 0x38, 0x36, 0x38, 0x37, 0x32, 0x65, 0x38, 0x64, 0x62, 0x62, 0x35, 0x32, 0x61, 0x32, 0x38, 0x66, 0x62, 0x66, 0x30, 0x34, 0x38, 0x63, 0x30, 0x30, 0x35, 0x31, 0x34, 0x65, 0x34, 0x33, 0x61, 0x61, 0x31, 0x31, 0x32, 0x31, 0x66, 0x34, 0x36, 0x38, 0x35, 0x30, 0x61, 0x34, 0x63, 0x62, 0x37, 0x66, 0x64, 0x32, 0x33, 0x61, 0x38, 0x38, 0x61, 0x61, 0x62, 0x64, 0x31, 0x37, 0x35, 0x64, 0x35, 0x35, 0x30, 0x38, 0x64, 0x61, 0x62, 0x34, 0x33, 0x66, 0x65, 0x61, 0x37, 0x32, 0x66, 0x62, 0x63, 0x33, 0x33, 0x64, 0x61, 0x30, 0x30, 0x63, 0x62, 0x63, 0x38, 0x65, 0x34, 0x37, 0x31, 0x33, 0x61, 0x65, 0x66, 0x35, 0x30, 0x35, 0x35, 0x63, 0x63, 0x35, 0x33, 0x38, 0x39, 0x66, 0x38, 0x32, 0x30, 0x38, 0x32, 0x30, 0x36, 0x64, 0x61, 0x39, 0x30, 0x35, 0x36, 0x62, 0x65, 0x38, 0x38, 0x30, 0x38, 0x34, 0x31, 0x31, 0x39, 0x31, 0x36, 0x65, 0x62, 0x37, 0x64, 0x39, 0x37, 0x32, 0x33, 0x35, 0x31, 0x32, 0x65, 0x36, 0x31, 0x39, 0x32, 0x33, 0x38, 0x66, 0x63, 0x64, 0x34, 0x31, 0x32, 0x33, 0x39, 0x33, 0x31, 0x36, 0x36, 0x30, 0x64, 0x63, 0x66, 0x34, 0x65, 0x64, 0x65, 0x38, 0x36, 0x37, 0x62, 0x61, 0x32, 0x64, 0x37, 0x30, 0x30, 0x64, 0x64, 0x30, 0x39, 0x35, 0x63, 0x62, 0x31, 0x36, 0x62, 0x32, 0x34, 0x35, 0x65, 0x34, 0x39, 0x64, 0x33, 0x36, 0x31, 0x64, 0x33, 0x30, 0x65, 0x32, 0x65, 0x66, 0x32, 0x66, 0x39, 0x39, 0x33, 0x33, 0x32, 0x37, 0x63, 0x30, 0x66, 0x63, 0x39, 0x38, 0x66, 0x66, 0x61, 0x34, 0x64, 0x35, 0x63, 0x65, 0x61, 0x66, 0x66, 0x39, 0x31, 0x39, 0x61, 0x64, 0x37, 0x34, 0x33, 0x38, 0x35, 0x38, 0x61, 0x39, 0x62, 0x36, 0x32, 0x63, 0x33, 0x35, 0x33, 0x37, 0x61, 0x66, 0x34, 0x61, 0x66, 0x38, 0x37, 0x37, 0x30, 0x64, 0x64, 0x61, 0x37, 0x32, 0x32, 0x65, 0x65, 0x34, 0x66, 0x66, 0x36, 0x37, 0x66, 0x38, 0x62, 0x37, 0x33, 0x33, 0x62, 0x32, 0x32, 0x31, 0x35, 0x32, 0x63, 0x65, 0x37, 0x35, 0x33, 0x31, 0x64, 0x63, 0x38, 0x39, 0x38, 0x65, 0x32, 0x31, 0x33, 0x39, 0x35, 0x30, 0x63, 0x34, 0x39, 0x38, 0x63, 0x63, 0x63, 0x31, 0x35, 0x63, 0x33, 0x37, 0x34, 0x37, 0x34, 0x61, 0x37, 0x37, 0x32, 0x37, 0x36, 0x61, 0x32, 0x62, 0x37, 0x32, 0x65, 0x38, 0x66, 0x34, 0x61, 0x32, 0x61, 0x65, 0x36, 0x39, 0x61, 0x30, 0x63, 0x66, 0x39, 0x30, 0x65, 0x36, 0x38, 0x66, 0x61, 0x35, 0x30, 0x31, 0x31, 0x36, 0x65, 0x37, 0x35, 0x33, 0x39, 0x62, 0x34, 0x35, 0x66, 0x63, 0x61, 0x64, 0x66, 0x34, 0x61, 0x39, 0x39, 0x38, 0x66, 0x38, 0x31, 0x38, 0x33, 0x31, 0x30, 0x37, 0x33, 0x61, 0x37, 0x66, 0x62, 0x38, 0x61, 0x33, 0x31, 0x62, 0x32, 0x62, 0x38, 0x33, 0x35, 0x39, 0x36, 0x39, 0x32, 0x32, 0x37, 0x33, 0x64, 0x62, 0x35, 0x65, 0x35, 0x65, 0x30, 0x62, 0x34, 0x65, 0x61, 0x65, 0x38, 0x65, 0x35, 0x61, 0x33, 0x33, 0x63, 0x62, 0x65, 0x65, 0x36, 0x35, 0x65, 0x64, 0x31, 0x31, 0x35, 0x31, 0x30, 0x32, 0x66, 0x38, 0x32, 0x63, 0x36, 0x61, 0x61, 0x39, 0x33, 0x38, 0x64, 0x36, 0x39, 0x36, 0x62, 0x64, 0x65, 0x30, 0x65, 0x35, 0x37, 0x32, 0x30, 0x63, 0x35, 0x64, 0x62, 0x36, 0x39, 0x34, 0x34, 0x66, 0x37, 0x62, 0x34, 0x37, 0x34, 0x34, 0x31, 0x35, 0x65, 0x37, 0x31, 0x32, 0x65, 0x35, 0x64, 0x32, 0x30, 0x30, 0x30, 0x36, 0x37, 0x38, 0x38, 0x37, 0x34, 0x64, 0x63, 0x36, 0x65, 0x66, 0x31, 0x34, 0x65, 0x32, 0x34, 0x62, 0x38, 0x38, 0x37, 0x66, 0x39, 0x31, 0x34, 0x32, 0x65, 0x34, 0x61, 0x36, 0x39, 0x32, 0x64, 0x66, 0x30, 0x37, 0x34, 0x66, 0x39, 0x65, 0x62, 0x36, 0x65, 0x39, 0x62, 0x37, 0x38, 0x65, 0x37, 0x38, 0x31, 0x31, 0x32, 0x62, 0x61, 0x33, 0x66, 0x39, 0x64, 0x30, 0x62, 0x62, 0x36, 0x65, 0x63, 0x62, 0x64, 0x61, 0x65, 0x31, 0x62, 0x36, 0x37, 0x61, 0x31, 0x62, 0x30, 0x61, 0x31, 0x63, 0x62, 0x35, 0x34, 0x34, 0x30, 0x31, 0x65, 0x39, 0x63, 0x64, 0x32, 0x62, 0x32, 0x65, 0x36, 0x39, 0x36, 0x39, 0x37, 0x32, 0x36, 0x65, 0x34, 0x30, 0x65, 0x31, 0x65, 0x61, 0x31, 0x35, 0x61, 0x33, 0x66, 0x33, 0x33, 0x35, 0x36, 0x31, 0x37, 0x64, 0x30, 0x64, 0x33, 0x61, 0x62, 0x61, 0x32, 0x37, 0x35, 0x36, 0x61, 0x34, 0x31, 0x39, 0x61, 0x37, 0x62, 0x62, 0x34, 0x36, 0x62, 0x34, 0x65, 0x66, 0x63, 0x65, 0x35, 0x65, 0x66, 0x66, 0x61, 0x63, 0x37, 0x64, 0x38, 0x37, 0x65, 0x30, 0x37, 0x63, 0x63, 0x66, 0x37, 0x32, 0x38, 0x38, 0x37, 0x63, 0x38, 0x64, 0x36, 0x32, 0x64, 0x39, 0x62, 0x65, 0x39, 0x38, 0x63, 0x30, 0x61, 0x37, 0x33, 0x36, 0x62, 0x38, 0x65, 0x39, 0x32, 0x61, 0x36, 0x39, 0x35, 0x34, 0x34, 0x66, 0x66, 0x34, 0x31, 0x63, 0x30, 0x64, 0x33, 0x61, 0x65, 0x34, 0x64, 0x36, 0x37, 0x39, 0x64, 0x34, 0x37, 0x33, 0x39, 0x38, 0x61, 0x37, 0x36, 0x33, 0x64, 0x37, 0x39, 0x35, 0x39, 0x30, 0x35, 0x32, 0x38, 0x32, 0x33, 0x33, 0x63, 0x33, 0x35, 0x36, 0x33, 0x31, 0x31, 0x36, 0x35, 0x38, 0x36, 0x32, 0x62, 0x62, 0x34, 0x63, 0x37, 0x36, 0x32, 0x36, 0x61, 0x34, 0x62, 0x36, 0x31, 0x35, 0x36, 0x34, 0x62, 0x33, 0x35, 0x31, 0x36, 0x31, 0x36, 0x39, 0x35, 0x35, 0x39, 0x64, 0x39, 0x66, 0x39, 0x34, 0x61, 0x34, 0x62, 0x39, 0x65, 0x35, 0x63, 0x33, 0x37, 0x33, 0x63, 0x63, 0x61, 0x33, 0x33, 0x32, 0x30, 0x61, 0x33, 0x65, 0x62, 0x66, 0x39, 0x65, 0x66, 0x35, 0x34, 0x38, 0x65, 0x34, 0x61, 0x65, 0x31, 0x30, 0x31, 0x66, 0x66, 0x64, 0x31, 0x35, 0x35, 0x66, 0x31, 0x39, 0x33, 0x65, 0x35, 0x65, 0x38, 0x64, 0x35, 0x62, 0x35, 0x33, 0x33, 0x38, 0x34, 0x34, 0x37, 0x66, 0x34, 0x32, 0x39, 0x36, 0x62, 0x34, 0x33, 0x38, 0x36, 0x34, 0x63, 0x37, 0x35, 0x39, 0x39, 0x38, 0x65, 0x62, 0x37, 0x32, 0x30, 0x33, 0x33, 0x62, 0x64, 0x32, 0x34, 0x32, 0x30, 0x61, 0x66, 0x32, 0x30, 0x35, 0x61, 0x65, 0x62, 0x61, 0x39, 0x66, 0x63, 0x65, 0x35, 0x34, 0x38, 0x61, 0x66, 0x36, 0x65, 0x39, 0x36, 0x38, 0x65, 0x33, 0x63, 0x30, 0x39, 0x33, 0x65, 0x31, 0x31, 0x61, 0x31, 0x34, 0x63, 0x63, 0x34, 0x66, 0x61, 0x63, 0x38, 0x38, 0x64, 0x39, 0x39, 0x37, 0x66, 0x62, 0x66, 0x63, 0x36, 0x64, 0x37, 0x32, 0x39, 0x39, 0x38, 0x32, 0x39, 0x62, 0x39, 0x62, 0x38, 0x34, 0x61, 0x32, 0x33, 0x33, 0x36, 0x63, 0x34, 0x34, 0x34, 0x32, 0x36, 0x65, 0x33, 0x36, 0x63, 0x63, 0x62, 0x66, 0x63, 0x36, 0x61, 0x30, 0x36, 0x33, 0x63, 0x66, 0x63, 0x65, 0x39, 0x32, 0x32, 0x39, 0x30, 0x38, 0x30, 0x62, 0x64, 0x61, 0x64, 0x61, 0x65, 0x61, 0x64, 0x33, 0x61, 0x36, 0x33, 0x35, 0x30, 0x37, 0x33, 0x37, 0x36, 0x38, 0x64, 0x39, 0x37, 0x39, 0x39, 0x37, 0x36, 0x61, 0x61, 0x34, 0x61, 0x30, 0x63, 0x30, 0x34, 0x31, 0x33, 0x62, 0x38, 0x62, 0x39, 0x33, 0x36, 0x66, 0x39, 0x39, 0x38, 0x31, 0x65, 0x63, 0x65, 0x63, 0x38, 0x33, 0x62, 0x63, 0x35, 0x33, 0x37, 0x64, 0x66, 0x30, 0x33, 0x37, 0x65, 0x65, 0x33, 0x66, 0x36, 0x61, 0x64, 0x65, 0x63, 0x36, 0x39, 0x37, 0x63, 0x61, 0x38, 0x32, 0x63, 0x33, 0x35, 0x61, 0x35, 0x31, 0x61, 0x33, 0x32, 0x33, 0x66, 0x64, 0x64, 0x65, 0x37, 0x35, 0x34, 0x35, 0x32, 0x32, 0x66, 0x38, 0x33, 0x31, 0x33, 0x61, 0x30, 0x64, 0x32, 0x34, 0x64, 0x35, 0x63, 0x32, 0x62, 0x39, 0x30, 0x30, 0x65, 0x65, 0x66, 0x66, 0x65, 0x64, 0x62, 0x63, 0x65, 0x62, 0x35, 0x65, 0x64, 0x63, 0x36, 0x66, 0x38, 0x31, 0x62, 0x34, 0x37, 0x65, 0x65, 0x39, 0x36, 0x38, 0x66, 0x34, 0x37, 0x32, 0x61, 0x34, 0x37, 0x61, 0x31, 0x63, 0x34, 0x38, 0x35, 0x63, 0x62, 0x36, 0x35, 0x33, 0x30, 0x32, 0x38, 0x39, 0x66, 0x30, 0x32, 0x38, 0x37, 0x64, 0x65, 0x64, 0x61, 0x31, 0x39, 0x36, 0x39, 0x35, 0x66, 0x34, 0x31, 0x64, 0x32, 0x38, 0x37, 0x35, 0x39, 0x37, 0x30, 0x65, 0x63, 0x39, 0x63, 0x35, 0x64, 0x61, 0x63, 0x32, 0x37, 0x39, 0x30, 0x39, 0x39, 0x62, 0x34, 0x32, 0x34, 0x38, 0x36, 0x35, 0x63, 0x65, 0x65, 0x34, 0x36, 0x30, 0x37, 0x31, 0x66, 0x61, 0x33, 0x38, 0x64, 0x37, 0x38, 0x32, 0x31, 0x66, 0x36, 0x36, 0x33, 0x35, 0x34, 0x63, 0x38, 0x37, 0x66, 0x39, 0x30, 0x65, 0x37, 0x33, 0x66, 0x30, 0x39, 0x31, 0x32, 0x61, 0x38, 0x62, 0x35, 0x37, 0x37, 0x37, 0x61, 0x64, 0x32, 0x36, 0x65, 0x62, 0x62, 0x37, 0x31, 0x65, 0x33, 0x33, 0x37, 0x37, 0x37, 0x35, 0x39, 0x34, 0x37, 0x32, 0x37, 0x34, 0x36, 0x63, 0x31, 0x34, 0x36, 0x62, 0x36, 0x37, 0x32, 0x36, 0x32, 0x64, 0x66, 0x33, 0x39, 0x30, 0x31, 0x62, 0x65, 0x38, 0x64, 0x64, 0x33, 0x35, 0x65, 0x66, 0x65, 0x31, 0x62, 0x32, 0x36, 0x62, 0x63, 0x61, 0x61, 0x30, 0x35, 0x35, 0x37, 0x64, 0x37, 0x34, 0x61, 0x32, 0x31, 0x35, 0x33, 0x66, 0x66, 0x31, 0x30, 0x32, 0x62, 0x63, 0x37, 0x66, 0x30, 0x62, 0x61, 0x32, 0x37, 0x32, 0x64, 0x62, 0x38, 0x36, 0x64, 0x66, 0x37, 0x33, 0x37, 0x30, 0x34, 0x65, 0x63, 0x33, 0x38, 0x35, 0x36, 0x62, 0x62, 0x33, 0x39, 0x39, 0x31, 0x34, 0x32, 0x30, 0x30, 0x38, 0x38, 0x61, 0x62, 0x31, 0x32, 0x65, 0x37, 0x30, 0x39, 0x63, 0x37, 0x62, 0x34, 0x65, 0x61, 0x37, 0x64, 0x39, 0x32, 0x35, 0x35, 0x63, 0x63, 0x30, 0x35, 0x61, 0x63, 0x37, 0x38, 0x63, 0x63, 0x62, 0x35, 0x37, 0x37, 0x32, 0x34, 0x63, 0x30, 0x34, 0x34, 0x37, 0x66, 0x39, 0x64, 0x66, 0x39, 0x33, 0x35, 0x38, 0x36, 0x37, 0x63, 0x38, 0x64, 0x38, 0x31, 0x63, 0x35, 0x37, 0x31, 0x37, 0x64, 0x61, 0x33, 0x37, 0x36, 0x61, 0x39, 0x30, 0x34, 0x37, 0x32, 0x33, 0x62, 0x34, 0x33, 0x62, 0x64, 0x31, 0x32, 0x37, 0x34, 0x66, 0x62, 0x33, 0x36, 0x34, 0x30, 0x31, 0x39, 0x32, 0x33, 0x32, 0x34, 0x31, 0x36, 0x36, 0x37, 0x32, 0x64, 0x31, 0x61, 0x64, 0x30, 0x38, 0x32, 0x63, 0x63, 0x38, 0x35, 0x35, 0x61, 0x66, 0x66, 0x38, 0x34, 0x39, 0x35, 0x36, 0x63, 0x66, 0x63, 0x30, 0x38, 0x37, 0x61, 0x64, 0x32, 0x64, 0x36, 0x61, 0x32, 0x37, 0x38, 0x65, 0x39, 0x63, 0x33, 0x39, 0x36, 0x65, 0x31, 0x37, 0x62, 0x62, 0x35, 0x64, 0x64, 0x33, 0x32, 0x65, 0x39, 0x65, 0x34, 0x38, 0x35, 0x30, 0x37, 0x36, 0x34, 0x63, 0x30, 0x31, 0x30, 0x34, 0x33, 0x66, 0x39, 0x64, 0x34, 0x62, 0x37, 0x66, 0x34, 0x30, 0x61, 0x62, 0x64, 0x66, 0x64, 0x32, 0x32, 0x31, 0x39, 0x64, 0x31, 0x32, 0x64, 0x37, 0x33, 0x65, 0x34, 0x39, 0x38, 0x32, 0x63, 0x38, 0x34, 0x62, 0x36, 0x64, 0x33, 0x62, 0x38, 0x37, 0x64, 0x63, 0x31, 0x61, 0x36, 0x33, 0x61, 0x36, 0x66, 0x31, 0x38, 0x32, 0x32, 0x62, 0x38, 0x39, 0x33, 0x63, 0x32, 0x65, 0x37, 0x32, 0x66, 0x33, 0x37, 0x66, 0x38, 0x33, 0x32, 0x30, 0x36, 0x35, 0x38, 0x31, 0x36, 0x35, 0x34, 0x35, 0x63, 0x36, 0x62, 0x37, 0x62, 0x34, 0x61, 0x61, 0x64, 0x35, 0x37, 0x61, 0x34, 0x31, 0x63, 0x64, 0x31, 0x32, 0x63, 0x35, 0x38, 0x39, 0x38, 0x35, 0x38, 0x34, 0x34, 0x66, 0x30, 0x63, 0x63, 0x39, 0x37, 0x31, 0x63, 0x66, 0x30, 0x38, 0x38, 0x32, 0x33, 0x33, 0x36, 0x39, 0x32, 0x63, 0x33, 0x31, 0x36, 0x63, 0x62, 0x33, 0x66, 0x64, 0x33, 0x64, 0x63, 0x35, 0x35, 0x66, 0x64, 0x65, 0x36, 0x34, 0x33, 0x64, 0x30, 0x36, 0x38, 0x36, 0x63, 0x61, 0x30, 0x35, 0x36, 0x33, 0x38, 0x37, 0x30, 0x39, 0x31, 0x61, 0x61, 0x38, 0x61, 0x62, 0x63, 0x61, 0x63, 0x66, 0x61, 0x62, 0x61, 0x34, 0x35, 0x37, 0x30, 0x63, 0x30, 0x38, 0x64, 0x61, 0x34, 0x30, 0x37, 0x30, 0x37, 0x39, 0x62, 0x32, 0x37, 0x32, 0x30, 0x61, 0x31, 0x34, 0x33, 0x65, 0x65, 0x65, 0x63, 0x33, 0x36, 0x30, 0x34, 0x61, 0x39, 0x39, 0x33, 0x37, 0x33, 0x66, 0x30, 0x61, 0x64, 0x38, 0x37, 0x30, 0x37, 0x62, 0x65, 0x32, 0x34, 0x63, 0x33, 0x61, 0x37, 0x63, 0x65, 0x39, 0x39, 0x65, 0x31, 0x30, 0x62, 0x65, 0x30, 0x39, 0x33, 0x62, 0x61, 0x65, 0x35, 0x63, 0x35, 0x34, 0x30, 0x34, 0x33, 0x65, 0x36, 0x34, 0x34, 0x38, 0x30, 0x38, 0x36, 0x39, 0x35, 0x30, 0x61, 0x30, 0x31, 0x32, 0x39, 0x30, 0x39, 0x37, 0x39, 0x34, 0x63, 0x30, 0x34, 0x32, 0x63, 0x64, 0x66, 0x38, 0x33, 0x35, 0x38, 0x63, 0x31, 0x61, 0x65, 0x31, 0x35, 0x66, 0x33, 0x63, 0x35, 0x37, 0x33, 0x39, 0x30, 0x64, 0x65, 0x62, 0x64, 0x63, 0x30, 0x37, 0x39, 0x38, 0x61, 0x39, 0x37, 0x36, 0x37, 0x61, 0x34, 0x62, 0x30, 0x64, 0x66, 0x34, 0x32, 0x35, 0x31, 0x61, 0x38, 0x64, 0x36, 0x31, 0x39, 0x35, 0x36, 0x65, 0x33, 0x38, 0x66, 0x62, 0x34, 0x33, 0x63, 0x37, 0x33, 0x36, 0x34, 0x32, 0x35, 0x36, 0x35, 0x64, 0x64, 0x34, 0x30, 0x36, 0x38, 0x66, 0x39, 0x34, 0x61, 0x66, 0x32, 0x31, 0x36, 0x62, 0x34, 0x63, 0x31, 0x37, 0x65, 0x37, 0x61, 0x61, 0x66, 0x66, 0x36, 0x33, 0x38, 0x38, 0x65, 0x66, 0x65, 0x35, 0x38, 0x61, 0x66, 0x32, 0x32, 0x34, 0x37, 0x32, 0x38, 0x65, 0x33, 0x33, 0x33, 0x63, 0x62, 0x64, 0x64, 0x31, 0x33, 0x38, 0x64, 0x35, 0x61, 0x61, 0x36, 0x32, 0x36, 0x36, 0x34, 0x66, 0x38, 0x62, 0x39, 0x62, 0x66, 0x64, 0x63, 0x63, 0x32, 0x32, 0x36, 0x30, 0x65, 0x32, 0x36, 0x37, 0x34, 0x37, 0x32, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x63, 0x64, 0x65, 0x32, 0x32, 0x30, 0x35, 0x66, 0x61, 0x30, 0x37, 0x64, 0x34, 0x39, 0x62, 0x37, 0x32, 0x65, 0x31, 0x63, 0x32, 0x34, 0x66, 0x61, 0x39, 0x32, 0x65, 0x61, 0x35, 0x34, 0x36, 0x39, 0x61, 0x32, 0x61, 0x31, 0x30, 0x66, 0x64, 0x64, 0x64, 0x30, 0x62, 0x37, 0x66, 0x37, 0x38, 0x38, 0x32, 0x63, 0x66, 0x39, 0x35, 0x64, 0x64, 0x36, 0x32, 0x36, 0x63, 0x62, 0x66, 0x34, 0x32, 0x34, 0x62, 0x31, 0x38, 0x65, 0x30, 0x62, 0x34, 0x36, 0x35, 0x64, 0x35, 0x39, 0x38, 0x38, 0x65, 0x32, 0x61, 0x35, 0x36, 0x37, 0x35, 0x63, 0x35, 0x33, 0x63, 0x34, 0x65, 0x30, 0x34, 0x66, 0x36, 0x30, 0x63, 0x38, 0x65, 0x35, 0x32, 0x31, 0x63, 0x39, 0x38, 0x62, 0x34, 0x66, 0x64, 0x30, 0x33, 0x38, 0x36, 0x61, 0x31, 0x64, 0x31, 0x34, 0x34, 0x34, 0x61, 0x62, 0x39, 0x39, 0x30, 0x36, 0x65, 0x65, 0x30, 0x65, 0x64, 0x36, 0x38, 0x61, 0x38, 0x36, 0x66, 0x62, 0x39, 0x63, 0x63, 0x34, 0x38, 0x33, 0x35, 0x62, 0x35, 0x39, 0x65, 0x30, 0x36, 0x63, 0x39, 0x33, 0x34, 0x63, 0x31, 0x34, 0x33, 0x31, 0x64, 0x39, 0x66, 0x35, 0x30, 0x34, 0x34, 0x62, 0x32, 0x35, 0x64, 0x38, 0x62, 0x37, 0x34, 0x62, 0x31, 0x33, 0x35, 0x32, 0x65, 0x66, 0x35, 0x30, 0x31, 0x33, 0x39, 0x63, 0x65, 0x35, 0x30, 0x62, 0x65, 0x33, 0x64, 0x64, 0x61, 0x34, 0x36, 0x35, 0x63, 0x65, 0x34, 0x32, 0x34, 0x63, 0x39, 0x37, 0x32, 0x38, 0x39, 0x39, 0x34, 0x37, 0x38, 0x38, 0x32, 0x61, 0x62, 0x31, 0x30, 0x63, 0x38, 0x38, 0x35, 0x61, 0x62, 0x64, 0x33, 0x64, 0x62, 0x66, 0x65, 0x32, 0x64, 0x62, 0x39, 0x62, 0x66, 0x65, 0x32, 0x37, 0x36, 0x66, 0x62, 0x32, 0x39, 0x37, 0x63, 0x35, 0x32, 0x63, 0x30, 0x37, 0x63, 0x37, 0x33, 0x39, 0x62, 0x31, 0x64, 0x39, 0x31, 0x34, 0x32, 0x33, 0x35, 0x63, 0x63, 0x64, 0x37, 0x36, 0x62, 0x30, 0x62, 0x62, 0x30, 0x36, 0x65, 0x38, 0x35, 0x66, 0x61, 0x33, 0x39, 0x62, 0x63, 0x38, 0x61, 0x32, 0x39, 0x34, 0x36, 0x61, 0x33, 0x36, 0x61, 0x61, 0x35, 0x65, 0x62, 0x62, 0x65, 0x35, 0x32, 0x64, 0x62, 0x37, 0x62, 0x31, 0x63, 0x35, 0x66, 0x33, 0x39, 0x64, 0x33, 0x61, 0x30, 0x30, 0x31, 0x36, 0x66, 0x37, 0x35, 0x64, 0x33, 0x32, 0x39, 0x62, 0x61, 0x62, 0x66, 0x38, 0x33, 0x30, 0x30, 0x63, 0x38, 0x39, 0x64, 0x36, 0x34, 0x62, 0x35, 0x35, 0x38, 0x37, 0x31, 0x62, 0x37, 0x37, 0x33, 0x63, 0x35, 0x38, 0x37, 0x64, 0x63, 0x63, 0x33, 0x39, 0x30, 0x37, 0x37, 0x34, 0x35, 0x31, 0x35, 0x64, 0x36, 0x34, 0x65, 0x33, 0x63, 0x66, 0x36, 0x35, 0x39, 0x63, 0x61, 0x62, 0x38, 0x37, 0x33, 0x37, 0x66, 0x33, 0x65, 0x36, 0x38, 0x34, 0x64, 0x63, 0x63, 0x38, 0x61, 0x34, 0x34, 0x31, 0x36, 0x61, 0x32, 0x64, 0x35, 0x34, 0x38, 0x37, 0x38, 0x34, 0x34, 0x37, 0x30, 0x30, 0x37, 0x37, 0x39, 0x39, 0x61, 0x64, 0x65, 0x64, 0x37, 0x37, 0x38, 0x33, 0x39, 0x37, 0x33, 0x39, 0x66, 0x66, 0x30, 0x62, 0x35, 0x37, 0x66, 0x30, 0x64, 0x61, 0x66, 0x33, 0x38, 0x37, 0x39, 0x38, 0x31, 0x63, 0x37, 0x30, 0x39, 0x64, 0x30, 0x37, 0x38, 0x61, 0x65, 0x38, 0x61, 0x37, 0x61, 0x37, 0x33, 0x36, 0x33, 0x31, 0x36, 0x33, 0x66, 0x30, 0x31, 0x33, 0x39, 0x34, 0x30, 0x35, 0x33, 0x62, 0x33, 0x37, 0x33, 0x32, 0x34, 0x33, 0x36, 0x64, 0x33, 0x63, 0x33, 0x66, 0x30, 0x65, 0x38, 0x32, 0x36, 0x37, 0x64, 0x38, 0x39, 0x39, 0x39, 0x34, 0x38, 0x37, 0x34, 0x32, 0x39, 0x33, 0x63, 0x61, 0x37, 0x32, 0x66, 0x33, 0x38, 0x35, 0x31, 0x34, 0x64, 0x31, 0x65, 0x38, 0x63, 0x34, 0x34, 0x36, 0x31, 0x37, 0x32, 0x30, 0x66, 0x64, 0x33, 0x37, 0x32, 0x65, 0x64, 0x39, 0x65, 0x34, 0x35, 0x62, 0x36, 0x32, 0x61, 0x37, 0x31, 0x31, 0x33, 0x36, 0x61, 0x65, 0x36, 0x39, 0x30, 0x63, 0x33, 0x61, 0x36, 0x30, 0x61, 0x30, 0x33, 0x35, 0x32, 0x62, 0x36, 0x63, 0x65, 0x35, 0x33, 0x63, 0x35, 0x32, 0x31, 0x30, 0x36, 0x38, 0x62, 0x33, 0x30, 0x31, 0x62, 0x34, 0x63, 0x63, 0x31, 0x39, 0x62, 0x39, 0x61, 0x36, 0x31, 0x32, 0x65, 0x66, 0x38, 0x34, 0x35, 0x32, 0x31, 0x37, 0x38, 0x61, 0x32, 0x64, 0x63, 0x38, 0x36, 0x39, 0x33, 0x32, 0x63, 0x64, 0x37, 0x35, 0x34, 0x36, 0x66, 0x65, 0x62, 0x38, 0x62, 0x38, 0x63, 0x33, 0x62, 0x65, 0x31, 0x32, 0x63, 0x32, 0x34, 0x61, 0x34, 0x34, 0x38, 0x35, 0x33, 0x30, 0x38, 0x61, 0x61, 0x34, 0x33, 0x37, 0x35, 0x65, 0x35, 0x30, 0x39, 0x37, 0x36, 0x63, 0x30, 0x31, 0x30, 0x34, 0x63, 0x31, 0x39, 0x38, 0x36, 0x63, 0x36, 0x64, 0x61, 0x30, 0x65, 0x31, 0x65, 0x61, 0x33, 0x36, 0x34, 0x37, 0x30, 0x39, 0x33, 0x31, 0x31, 0x62, 0x35, 0x64, 0x39, 0x35, 0x34, 0x63, 0x63, 0x32, 0x63, 0x66, 0x30, 0x32, 0x31, 0x34, 0x66, 0x62, 0x66, 0x33, 0x32, 0x37, 0x65, 0x61, 0x35, 0x36, 0x65, 0x38, 0x32, 0x31, 0x37, 0x39, 0x36, 0x32, 0x35, 0x32, 0x31, 0x37, 0x30, 0x37, 0x32, 0x37, 0x36, 0x32, 0x62, 0x30, 0x39, 0x39, 0x32, 0x66, 0x30, 0x37, 0x66, 0x30, 0x66, 0x63, 0x39, 0x64, 0x36, 0x30, 0x64, 0x30, 0x39, 0x37, 0x38, 0x34, 0x35, 0x66, 0x35, 0x37, 0x39, 0x39, 0x61, 0x31, 0x64, 0x38, 0x36, 0x61, 0x33, 0x66, 0x38, 0x65, 0x61, 0x38, 0x63, 0x33, 0x30, 0x62, 0x61, 0x32, 0x30, 0x32, 0x66, 0x37, 0x65, 0x63, 0x32, 0x66, 0x36, 0x33, 0x36, 0x61, 0x62, 0x37, 0x32, 0x36, 0x37, 0x34, 0x32, 0x31, 0x66, 0x32, 0x61, 0x35, 0x34, 0x39, 0x39, 0x35, 0x64, 0x30, 0x61, 0x65, 0x30, 0x31, 0x32, 0x63, 0x37, 0x62, 0x34, 0x66, 0x34, 0x64, 0x32, 0x64, 0x61, 0x35, 0x30, 0x37, 0x39, 0x66, 0x61, 0x39, 0x37, 0x32, 0x65, 0x32, 0x33, 0x30, 0x39, 0x61, 0x63, 0x34, 0x36, 0x37, 0x34, 0x33, 0x34, 0x32, 0x31, 0x64, 0x64, 0x32, 0x38, 0x62, 0x32, 0x33, 0x63, 0x36, 0x66, 0x36, 0x63, 0x35, 0x32, 0x38, 0x38, 0x61, 0x62, 0x30, 0x35, 0x63, 0x31, 0x38, 0x36, 0x30, 0x31, 0x32, 0x61, 0x32, 0x37, 0x35, 0x65, 0x30, 0x34, 0x64, 0x37, 0x35, 0x63, 0x32, 0x33, 0x31, 0x66, 0x35, 0x36, 0x33, 0x61, 0x35, 0x64, 0x62, 0x63, 0x39, 0x62, 0x34, 0x36, 0x39, 0x63, 0x30, 0x65, 0x38, 0x34, 0x37, 0x39, 0x33, 0x34, 0x30, 0x39, 0x63, 0x33, 0x63, 0x66, 0x64, 0x33, 0x37, 0x32, 0x37, 0x63, 0x62, 0x65, 0x37, 0x38, 0x31, 0x37, 0x62, 0x63, 0x62, 0x61, 0x37, 0x37, 0x62, 0x39, 0x32, 0x38, 0x30, 0x63, 0x66, 0x37, 0x65, 0x38, 0x65, 0x61, 0x37, 0x33, 0x38, 0x33, 0x37, 0x33, 0x63, 0x62, 0x62, 0x36, 0x62, 0x32, 0x66, 0x63, 0x31, 0x36, 0x39, 0x63, 0x38, 0x64, 0x66, 0x38, 0x62, 0x32, 0x65, 0x34, 0x35, 0x63, 0x30, 0x63, 0x64, 0x62, 0x38, 0x66, 0x34, 0x35, 0x33, 0x62, 0x32, 0x34, 0x35, 0x66, 0x62, 0x65, 0x39, 0x66, 0x64, 0x34, 0x30, 0x34, 0x38, 0x37, 0x31, 0x34, 0x63, 0x61, 0x39, 0x35, 0x62, 0x63, 0x30, 0x34, 0x64, 0x61, 0x38, 0x34, 0x34, 0x32, 0x39, 0x34, 0x31, 0x33, 0x34, 0x61, 0x31, 0x66, 0x63, 0x33, 0x66, 0x66, 0x65, 0x62, 0x33, 0x37, 0x38, 0x61, 0x33, 0x36, 0x62, 0x36, 0x32, 0x38, 0x31, 0x65, 0x39, 0x65, 0x37, 0x66, 0x36, 0x34, 0x31, 0x31, 0x34, 0x30, 0x36, 0x30, 0x36, 0x38, 0x66, 0x31, 0x66, 0x35, 0x36, 0x30, 0x62, 0x66, 0x32, 0x36, 0x34, 0x35, 0x34, 0x64, 0x35, 0x31, 0x39, 0x63, 0x34, 0x37, 0x34, 0x31, 0x30, 0x34, 0x62, 0x36, 0x30, 0x62, 0x62, 0x32, 0x64, 0x35, 0x35, 0x63, 0x39, 0x39, 0x30, 0x38, 0x37, 0x31, 0x30, 0x38, 0x63, 0x66, 0x34, 0x35, 0x37, 0x62, 0x61, 0x65, 0x65, 0x66, 0x35, 0x61, 0x35, 0x63, 0x33, 0x38, 0x30, 0x32, 0x34, 0x37, 0x33, 0x34, 0x66, 0x39, 0x37, 0x61, 0x37, 0x65, 0x35, 0x64, 0x30, 0x66, 0x62, 0x30, 0x63, 0x61, 0x65, 0x37, 0x63, 0x35, 0x33, 0x38, 0x34, 0x65, 0x65, 0x31, 0x32, 0x36, 0x39, 0x36, 0x36, 0x61, 0x34, 0x31, 0x32, 0x65, 0x32, 0x66, 0x36, 0x62, 0x32, 0x31, 0x61, 0x38, 0x64, 0x61, 0x31, 0x38, 0x39, 0x37, 0x66, 0x36, 0x35, 0x35, 0x63, 0x33, 0x32, 0x61, 0x37, 0x32, 0x65, 0x64, 0x61, 0x34, 0x62, 0x31, 0x36, 0x34, 0x64, 0x66, 0x66, 0x65, 0x64, 0x37, 0x66, 0x30, 0x62, 0x36, 0x36, 0x37, 0x62, 0x36, 0x64, 0x37, 0x66, 0x63, 0x62, 0x32, 0x32, 0x34, 0x36, 0x61, 0x65, 0x65, 0x64, 0x37, 0x62, 0x34, 0x36, 0x63, 0x37, 0x34, 0x30, 0x64, 0x61, 0x62, 0x64, 0x34, 0x61, 0x36, 0x63, 0x37, 0x31, 0x61, 0x30, 0x65, 0x61, 0x63, 0x39, 0x63, 0x66, 0x64, 0x37, 0x32, 0x34, 0x31, 0x36, 0x61, 0x65, 0x32, 0x65, 0x31, 0x39, 0x30, 0x62, 0x35, 0x39, 0x32, 0x65, 0x33, 0x38, 0x36, 0x62, 0x33, 0x32, 0x36, 0x33, 0x32, 0x65, 0x63, 0x39, 0x65, 0x63, 0x65, 0x30, 0x34, 0x36, 0x32, 0x33, 0x30, 0x61, 0x36, 0x66, 0x31, 0x37, 0x34, 0x65, 0x66, 0x38, 0x34, 0x34, 0x66, 0x65, 0x31, 0x62, 0x63, 0x32, 0x62, 0x61, 0x30, 0x32, 0x63, 0x32, 0x34, 0x30, 0x66, 0x37, 0x32, 0x63, 0x66, 0x37, 0x32, 0x36, 0x61, 0x66, 0x66, 0x36, 0x38, 0x30, 0x32, 0x66, 0x37, 0x30, 0x61, 0x32, 0x61, 0x33, 0x30, 0x38, 0x36, 0x39, 0x38, 0x36, 0x64, 0x62, 0x30, 0x38, 0x66, 0x66, 0x32, 0x35, 0x62, 0x38, 0x31, 0x30, 0x35, 0x37, 0x33, 0x32, 0x31, 0x36, 0x34, 0x65, 0x66, 0x66, 0x39, 0x61, 0x30, 0x63, 0x61, 0x66, 0x62, 0x61, 0x38, 0x35, 0x37, 0x63, 0x31, 0x30, 0x66, 0x37, 0x32, 0x64, 0x32, 0x39, 0x38, 0x31, 0x64, 0x63, 0x66, 0x37, 0x64, 0x30, 0x35, 0x32, 0x64, 0x33, 0x62, 0x34, 0x65, 0x32, 0x36, 0x39, 0x65, 0x32, 0x34, 0x31, 0x30, 0x35, 0x30, 0x38, 0x66, 0x62, 0x64, 0x62, 0x61, 0x34, 0x61, 0x36, 0x62, 0x63, 0x30, 0x35, 0x36, 0x64, 0x39, 0x61, 0x32, 0x32, 0x36, 0x30, 0x65, 0x31, 0x32, 0x66, 0x37, 0x61, 0x37, 0x34, 0x65, 0x38, 0x65, 0x34, 0x66, 0x37, 0x32, 0x62, 0x34, 0x33, 0x37, 0x37, 0x66, 0x33, 0x37, 0x66, 0x62, 0x38, 0x62, 0x31, 0x30, 0x65, 0x66, 0x38, 0x64, 0x36, 0x33, 0x61, 0x61, 0x37, 0x35, 0x37, 0x36, 0x66, 0x32, 0x35, 0x63, 0x30, 0x35, 0x32, 0x64, 0x32, 0x64, 0x39, 0x39, 0x31, 0x35, 0x32, 0x64, 0x38, 0x38, 0x33, 0x62, 0x34, 0x62, 0x37, 0x61, 0x38, 0x39, 0x63, 0x34, 0x34, 0x62, 0x62, 0x65, 0x66, 0x64, 0x34, 0x66, 0x37, 0x32, 0x31, 0x35, 0x34, 0x39, 0x62, 0x36, 0x30, 0x66, 0x38, 0x36, 0x32, 0x32, 0x32, 0x32, 0x66, 0x35, 0x33, 0x30, 0x30, 0x35, 0x66, 0x35, 0x65, 0x64, 0x30, 0x38, 0x62, 0x65, 0x36, 0x30, 0x32, 0x66, 0x35, 0x39, 0x30, 0x37, 0x38, 0x63, 0x33, 0x36, 0x34, 0x33, 0x61, 0x33, 0x38, 0x62, 0x34, 0x37, 0x32, 0x31, 0x64, 0x33, 0x38, 0x35, 0x62, 0x36, 0x38, 0x64, 0x39, 0x36, 0x31, 0x39, 0x35, 0x39, 0x39, 0x31, 0x35, 0x36, 0x32, 0x38, 0x35, 0x32, 0x33, 0x63, 0x63, 0x32, 0x66, 0x64, 0x37, 0x39, 0x66, 0x62, 0x33, 0x61, 0x30, 0x33, 0x33, 0x32, 0x38, 0x65, 0x32, 0x64, 0x38, 0x33, 0x65, 0x36, 0x34, 0x63, 0x36, 0x36, 0x36, 0x39, 0x34, 0x61, 0x66, 0x61, 0x62, 0x30, 0x35, 0x62, 0x62, 0x34, 0x64, 0x37, 0x39, 0x33, 0x35, 0x32, 0x32, 0x37, 0x61, 0x39, 0x38, 0x65, 0x30, 0x33, 0x37, 0x32, 0x32, 0x61, 0x61, 0x38, 0x62, 0x38, 0x62, 0x30, 0x34, 0x64, 0x65, 0x64, 0x31, 0x32, 0x35, 0x32, 0x66, 0x38, 0x63, 0x39, 0x66, 0x64, 0x66, 0x34, 0x33, 0x32, 0x39, 0x64, 0x32, 0x31, 0x33, 0x30, 0x61, 0x32, 0x31, 0x36, 0x30, 0x33, 0x34, 0x66, 0x37, 0x30, 0x36, 0x31, 0x33, 0x37, 0x35, 0x38, 0x31, 0x33, 0x63, 0x34, 0x37, 0x38, 0x37, 0x38, 0x61, 0x33, 0x64, 0x35, 0x32, 0x62, 0x37, 0x32, 0x62, 0x65, 0x61, 0x61, 0x65, 0x30, 0x35, 0x32, 0x66, 0x64, 0x33, 0x39, 0x66, 0x31, 0x35, 0x61, 0x35, 0x33, 0x30, 0x37, 0x61, 0x31, 0x38, 0x61, 0x39, 0x32, 0x37, 0x37, 0x35, 0x62, 0x36, 0x30, 0x63, 0x38, 0x35, 0x32, 0x38, 0x30, 0x37, 0x34, 0x34, 0x66, 0x63, 0x39, 0x33, 0x33, 0x32, 0x36, 0x64, 0x63, 0x39, 0x62, 0x38, 0x62, 0x66, 0x63, 0x30, 0x61, 0x34, 0x63, 0x31, 0x30, 0x31, 0x65, 0x66, 0x31, 0x64, 0x31, 0x37, 0x64, 0x31, 0x37, 0x33, 0x38, 0x36, 0x39, 0x39, 0x36, 0x33, 0x62, 0x39, 0x65, 0x63, 0x66, 0x35, 0x30, 0x31, 0x34, 0x63, 0x30, 0x37, 0x33, 0x30, 0x38, 0x66, 0x39, 0x66, 0x64, 0x62, 0x64, 0x31, 0x35, 0x65, 0x31, 0x38, 0x64, 0x33, 0x34, 0x34, 0x30, 0x32, 0x34, 0x30, 0x31, 0x36, 0x39, 0x33, 0x30, 0x30, 0x32, 0x30, 0x31, 0x32, 0x61, 0x63, 0x33, 0x37, 0x32, 0x34, 0x39, 0x65, 0x30, 0x33, 0x64, 0x65, 0x34, 0x37, 0x34, 0x35, 0x66, 0x39, 0x65, 0x34, 0x32, 0x30, 0x62, 0x36, 0x66, 0x61, 0x66, 0x61, 0x38, 0x62, 0x63, 0x36, 0x37, 0x66, 0x32, 0x32, 0x31, 0x61, 0x63, 0x35, 0x66, 0x64, 0x66, 0x31, 0x66, 0x65, 0x32, 0x65, 0x35, 0x37, 0x32, 0x36, 0x31, 0x63, 0x66, 0x64, 0x61, 0x66, 0x63, 0x66, 0x30, 0x32, 0x63, 0x36, 0x63, 0x31, 0x31, 0x33, 0x64, 0x39, 0x32, 0x31, 0x61, 0x62, 0x38, 0x33, 0x33, 0x64, 0x36, 0x33, 0x36, 0x64, 0x37, 0x66, 0x35, 0x30, 0x38, 0x39, 0x31, 0x35, 0x38, 0x32, 0x61, 0x30, 0x37, 0x63, 0x35, 0x65, 0x66, 0x39, 0x30, 0x31, 0x34, 0x34, 0x62, 0x36, 0x37, 0x39, 0x30, 0x32, 0x66, 0x61, 0x37, 0x66, 0x32, 0x65, 0x34, 0x30, 0x64, 0x36, 0x32, 0x37, 0x31, 0x36, 0x35, 0x61, 0x33, 0x38, 0x37, 0x35, 0x65, 0x32, 0x61, 0x34, 0x62, 0x37, 0x66, 0x64, 0x33, 0x38, 0x31, 0x65, 0x61, 0x35, 0x64, 0x63, 0x66, 0x33, 0x35, 0x36, 0x66, 0x61, 0x34, 0x32, 0x61, 0x37, 0x30, 0x65, 0x66, 0x39, 0x34, 0x64, 0x33, 0x31, 0x38, 0x39, 0x66, 0x30, 0x38, 0x31, 0x65, 0x62, 0x38, 0x63, 0x35, 0x30, 0x31, 0x65, 0x62, 0x63, 0x33, 0x61, 0x66, 0x64, 0x66, 0x35, 0x65, 0x63, 0x65, 0x37, 0x34, 0x38, 0x65, 0x30, 0x64, 0x37, 0x32, 0x31, 0x65, 0x37, 0x38, 0x62, 0x36, 0x65, 0x37, 0x30, 0x63, 0x33, 0x65, 0x62, 0x38, 0x36, 0x31, 0x64, 0x30, 0x64, 0x61, 0x64, 0x37, 0x63, 0x30, 0x63, 0x35, 0x35, 0x38, 0x37, 0x36, 0x35, 0x38, 0x33, 0x37, 0x37, 0x63, 0x39, 0x34, 0x64, 0x63, 0x35, 0x35, 0x38, 0x62, 0x61, 0x39, 0x31, 0x61, 0x61, 0x62, 0x35, 0x36, 0x38, 0x36, 0x35, 0x64, 0x64, 0x65, 0x62, 0x65, 0x38, 0x33, 0x34, 0x64, 0x30, 0x30, 0x32, 0x62, 0x36, 0x38, 0x61, 0x61, 0x39, 0x65, 0x34, 0x38, 0x33, 0x36, 0x37, 0x61, 0x65, 0x32, 0x61, 0x66, 0x66, 0x36, 0x39, 0x35, 0x34, 0x66, 0x36, 0x32, 0x35, 0x65, 0x34, 0x32, 0x63, 0x36, 0x39, 0x32, 0x66, 0x66, 0x39, 0x65, 0x35, 0x34, 0x62, 0x62, 0x61, 0x33, 0x34, 0x30, 0x30, 0x62, 0x33, 0x32, 0x31, 0x64, 0x39, 0x31, 0x66, 0x37, 0x63, 0x35, 0x64, 0x37, 0x37, 0x32, 0x31, 0x36, 0x33, 0x64, 0x64, 0x37, 0x34, 0x37, 0x31, 0x37, 0x36, 0x63, 0x34, 0x31, 0x63, 0x39, 0x34, 0x65, 0x39, 0x66, 0x66, 0x65, 0x64, 0x35, 0x65, 0x66, 0x34, 0x63, 0x32, 0x63, 0x33, 0x65, 0x33, 0x33, 0x30, 0x31, 0x31, 0x64, 0x39, 0x33, 0x32, 0x38, 0x30, 0x65, 0x39, 0x32, 0x63, 0x38, 0x61, 0x34, 0x66, 0x35, 0x38, 0x38, 0x32, 0x33, 0x38, 0x65, 0x37, 0x32, 0x37, 0x33, 0x35, 0x61, 0x36, 0x32, 0x32, 0x39, 0x30, 0x33, 0x31, 0x37, 0x37, 0x30, 0x61, 0x62, 0x38, 0x62, 0x36, 0x35, 0x39, 0x31, 0x63, 0x66, 0x33, 0x33, 0x31, 0x31, 0x64, 0x35, 0x61, 0x63, 0x35, 0x34, 0x64, 0x62, 0x30, 0x30, 0x66, 0x65, 0x36, 0x37, 0x34, 0x66, 0x38, 0x66, 0x35, 0x30, 0x61, 0x32, 0x62, 0x62, 0x64, 0x37, 0x34, 0x65, 0x33, 0x33, 0x33, 0x64, 0x37, 0x33, 0x37, 0x38, 0x36, 0x39, 0x37, 0x32, 0x64, 0x62, 0x30, 0x32, 0x37, 0x32, 0x32, 0x66, 0x66, 0x39, 0x35, 0x30, 0x32, 0x35, 0x63, 0x64, 0x62, 0x32, 0x35, 0x34, 0x37, 0x65, 0x36, 0x62, 0x64, 0x65, 0x30, 0x36, 0x31, 0x64, 0x31, 0x35, 0x33, 0x38, 0x30, 0x35, 0x61, 0x37, 0x62, 0x61, 0x37, 0x30, 0x62, 0x30, 0x66, 0x65, 0x30, 0x65, 0x66, 0x64, 0x32, 0x64, 0x31, 0x62, 0x36, 0x65, 0x32, 0x37, 0x35, 0x38, 0x39, 0x31, 0x30, 0x31, 0x62, 0x61, 0x63, 0x65, 0x38, 0x30, 0x63, 0x61, 0x32, 0x32, 0x65, 0x65, 0x35, 0x38, 0x35, 0x39, 0x32, 0x34, 0x34, 0x38, 0x39, 0x64, 0x64, 0x63, 0x61, 0x34, 0x62, 0x64, 0x32, 0x64, 0x33, 0x63, 0x39, 0x39, 0x63, 0x62, 0x62, 0x62, 0x33, 0x65, 0x33, 0x65, 0x65, 0x63, 0x30, 0x37, 0x62, 0x66, 0x35, 0x66, 0x39, 0x31, 0x66, 0x36, 0x32, 0x37, 0x30, 0x65, 0x32, 0x33, 0x39, 0x37, 0x35, 0x34, 0x66, 0x39, 0x34, 0x65, 0x36, 0x36, 0x61, 0x31, 0x34, 0x34, 0x39, 0x65, 0x61, 0x35, 0x31, 0x35, 0x38, 0x38, 0x62, 0x63, 0x35, 0x30, 0x63, 0x31, 0x37, 0x66, 0x62, 0x38, 0x37, 0x37, 0x64, 0x35, 0x31, 0x37, 0x34, 0x65, 0x37, 0x65, 0x32, 0x65, 0x62, 0x32, 0x64, 0x30, 0x33, 0x38, 0x30, 0x66, 0x31, 0x34, 0x65, 0x66, 0x65, 0x38, 0x31, 0x35, 0x62, 0x37, 0x37, 0x63, 0x63, 0x36, 0x37, 0x32, 0x31, 0x63, 0x32, 0x38, 0x63, 0x35, 0x35, 0x38, 0x38, 0x36, 0x65, 0x34, 0x36, 0x66, 0x63, 0x37, 0x64, 0x32, 0x37, 0x30, 0x32, 0x61, 0x35, 0x32, 0x34, 0x36, 0x65, 0x34, 0x34, 0x63, 0x30, 0x34, 0x38, 0x32, 0x30, 0x30, 0x64, 0x34, 0x33, 0x33, 0x39, 0x32, 0x61, 0x34, 0x61, 0x66, 0x38, 0x64, 0x32, 0x34, 0x34, 0x62, 0x64, 0x39, 0x32, 0x62, 0x37, 0x65, 0x32, 0x65, 0x65, 0x33, 0x37, 0x32, 0x30, 0x66, 0x33, 0x36, 0x30, 0x36, 0x62, 0x30, 0x34, 0x38, 0x63, 0x62, 0x32, 0x38, 0x31, 0x31, 0x64, 0x62, 0x61, 0x34, 0x62, 0x30, 0x64, 0x62, 0x31, 0x38, 0x30, 0x63, 0x38, 0x35, 0x62, 0x30, 0x38, 0x37, 0x38, 0x32, 0x31, 0x61, 0x30, 0x65, 0x34, 0x62, 0x39, 0x32, 0x33, 0x35, 0x62, 0x31, 0x63, 0x61, 0x39, 0x64, 0x36, 0x64, 0x32, 0x61, 0x65, 0x62, 0x33, 0x30, 0x38, 0x63, 0x37, 0x32, 0x61, 0x66, 0x31, 0x65, 0x38, 0x34, 0x62, 0x61, 0x31, 0x63, 0x38, 0x38, 0x64, 0x32, 0x63, 0x35, 0x63, 0x32, 0x36, 0x38, 0x37, 0x38, 0x35, 0x64, 0x65, 0x35, 0x39, 0x38, 0x32, 0x39, 0x65, 0x34, 0x65, 0x31, 0x38, 0x38, 0x38, 0x61, 0x31, 0x35, 0x36, 0x33, 0x62, 0x33, 0x33, 0x36, 0x64, 0x32, 0x39, 0x63, 0x35, 0x35, 0x61, 0x34, 0x66, 0x31, 0x34, 0x61, 0x66, 0x31, 0x38, 0x32, 0x30, 0x64, 0x37, 0x30, 0x35, 0x64, 0x39, 0x31, 0x32, 0x37, 0x33, 0x33, 0x31, 0x63, 0x66, 0x32, 0x37, 0x32, 0x35, 0x32, 0x66, 0x63, 0x65, 0x65, 0x66, 0x64, 0x61, 0x34, 0x65, 0x36, 0x35, 0x62, 0x62, 0x39, 0x64, 0x36, 0x30, 0x38, 0x31, 0x33, 0x35, 0x64, 0x66, 0x34, 0x37, 0x38, 0x36, 0x64, 0x62, 0x37, 0x62, 0x37, 0x62, 0x36, 0x62, 0x61, 0x31, 0x36, 0x36, 0x36, 0x66, 0x30, 0x61, 0x38, 0x37, 0x32, 0x31, 0x65, 0x31, 0x34, 0x39, 0x31, 0x36, 0x30, 0x33, 0x36, 0x65, 0x31, 0x35, 0x30, 0x61, 0x64, 0x35, 0x30, 0x31, 0x32, 0x33, 0x63, 0x35, 0x64, 0x39, 0x64, 0x62, 0x36, 0x39, 0x66, 0x65, 0x33, 0x62, 0x65, 0x31, 0x63, 0x65, 0x66, 0x64, 0x65, 0x31, 0x31, 0x65, 0x31, 0x32, 0x31, 0x63, 0x64, 0x62, 0x61, 0x64, 0x66, 0x30, 0x65, 0x30, 0x64, 0x66, 0x63, 0x32, 0x30, 0x36, 0x32, 0x37, 0x32, 0x34, 0x64, 0x37, 0x32, 0x61, 0x34, 0x66, 0x63, 0x35, 0x39, 0x61, 0x61, 0x63, 0x31, 0x34, 0x33, 0x36, 0x35, 0x62, 0x64, 0x61, 0x38, 0x35, 0x37, 0x66, 0x61, 0x34, 0x39, 0x35, 0x61, 0x36, 0x36, 0x32, 0x33, 0x35, 0x65, 0x37, 0x66, 0x36, 0x38, 0x35, 0x61, 0x35, 0x35, 0x65, 0x38, 0x30, 0x61, 0x61, 0x34, 0x33, 0x37, 0x34, 0x33, 0x30, 0x38, 0x30, 0x61, 0x35, 0x37, 0x36, 0x35, 0x37, 0x32, 0x36, 0x64, 0x62, 0x64, 0x32, 0x36, 0x36, 0x65, 0x63, 0x30, 0x36, 0x63, 0x34, 0x65, 0x65, 0x33, 0x65, 0x35, 0x32, 0x31, 0x33, 0x35, 0x33, 0x64, 0x39, 0x64, 0x36, 0x35, 0x63, 0x37, 0x65, 0x32, 0x33, 0x35, 0x39, 0x66, 0x33, 0x65, 0x66, 0x33, 0x63, 0x62, 0x30, 0x37, 0x61, 0x35, 0x31, 0x63, 0x63, 0x64, 0x31, 0x35, 0x33, 0x61, 0x37, 0x61, 0x34, 0x31, 0x64, 0x65, 0x63, 0x66, 0x36, 0x61, 0x39, 0x36, 0x65, 0x35, 0x62, 0x34, 0x62, 0x30, 0x66, 0x66, 0x32, 0x30, 0x38, 0x39, 0x61, 0x65, 0x37, 0x36, 0x39, 0x34, 0x32, 0x63, 0x64, 0x64, 0x36, 0x64, 0x64, 0x64, 0x65, 0x65, 0x39, 0x31, 0x33, 0x38, 0x66, 0x33, 0x62, 0x38, 0x66, 0x37, 0x36, 0x30, 0x38, 0x37, 0x64, 0x66, 0x63, 0x32, 0x61, 0x31, 0x66, 0x63, 0x34, 0x66, 0x65, 0x36, 0x39, 0x31, 0x31, 0x64, 0x36, 0x36, 0x37, 0x32, 0x37, 0x64, 0x33, 0x63, 0x32, 0x61, 0x35, 0x38, 0x39, 0x38, 0x61, 0x65, 0x31, 0x34, 0x65, 0x36, 0x63, 0x33, 0x62, 0x30, 0x63, 0x63, 0x30, 0x61, 0x65, 0x37, 0x30, 0x34, 0x35, 0x32, 0x39, 0x38, 0x31, 0x39, 0x31, 0x35, 0x66, 0x30, 0x33, 0x37, 0x31, 0x36, 0x38, 0x36, 0x33, 0x66, 0x33, 0x61, 0x37, 0x36, 0x34, 0x30, 0x62, 0x66, 0x31, 0x30, 0x39, 0x31, 0x36, 0x64, 0x33, 0x39, 0x32, 0x65, 0x63, 0x33, 0x30, 0x38, 0x32, 0x63, 0x37, 0x62, 0x39, 0x38, 0x35, 0x39, 0x61, 0x61, 0x34, 0x39, 0x66, 0x61, 0x34, 0x36, 0x66, 0x31, 0x63, 0x64, 0x62, 0x37, 0x33, 0x61, 0x63, 0x65, 0x66, 0x33, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x63, 0x63, 0x64, 0x33, 0x32, 0x32, 0x37, 0x37, 0x33, 0x36, 0x38, 0x30, 0x31, 0x37, 0x32, 0x31, 0x39, 0x39, 0x33, 0x35, 0x66, 0x36, 0x37, 0x32, 0x39, 0x65, 0x62, 0x32, 0x36, 0x61, 0x63, 0x65, 0x32, 0x65, 0x37, 0x39, 0x65, 0x33, 0x34, 0x62, 0x35, 0x31, 0x65, 0x62, 0x65, 0x64, 0x31, 0x36, 0x32, 0x37, 0x66, 0x64, 0x35, 0x39, 0x34, 0x63, 0x63, 0x66, 0x34, 0x33, 0x65, 0x38, 0x63, 0x62, 0x32, 0x39, 0x31, 0x30, 0x61, 0x62, 0x65, 0x32, 0x34, 0x31, 0x62, 0x62, 0x65, 0x33, 0x30, 0x35, 0x65, 0x66, 0x64, 0x37, 0x66, 0x63, 0x37, 0x32, 0x30, 0x30, 0x39, 0x39, 0x61, 0x38, 0x38, 0x35, 0x30, 0x33, 0x61, 0x30, 0x62, 0x64, 0x30, 0x38, 0x31, 0x33, 0x35, 0x31, 0x63, 0x36, 0x64, 0x33, 0x36, 0x65, 0x34, 0x33, 0x31, 0x39, 0x36, 0x65, 0x61, 0x66, 0x63, 0x63, 0x66, 0x65, 0x32, 0x36, 0x35, 0x65, 0x39, 0x33, 0x37, 0x37, 0x39, 0x36, 0x64, 0x33, 0x39, 0x63, 0x64, 0x33, 0x66, 0x31, 0x38, 0x30, 0x34, 0x31, 0x34, 0x35, 0x37, 0x32, 0x30, 0x30, 0x62, 0x36, 0x36, 0x33, 0x39, 0x66, 0x66, 0x35, 0x32, 0x65, 0x61, 0x30, 0x39, 0x38, 0x32, 0x32, 0x64, 0x34, 0x31, 0x31, 0x64, 0x37, 0x65, 0x63, 0x38, 0x64, 0x31, 0x62, 0x30, 0x63, 0x65, 0x63, 0x37, 0x30, 0x62, 0x34, 0x37, 0x31, 0x37, 0x36, 0x39, 0x61, 0x34, 0x30, 0x32, 0x61, 0x34, 0x31, 0x61, 0x39, 0x30, 0x66, 0x32, 0x33, 0x36, 0x66, 0x32, 0x64, 0x62, 0x64, 0x37, 0x32, 0x33, 0x66, 0x35, 0x64, 0x62, 0x62, 0x63, 0x66, 0x35, 0x66, 0x37, 0x64, 0x39, 0x66, 0x33, 0x37, 0x65, 0x61, 0x38, 0x38, 0x62, 0x38, 0x33, 0x35, 0x30, 0x61, 0x63, 0x66, 0x65, 0x38, 0x35, 0x39, 0x35, 0x64, 0x38, 0x64, 0x64, 0x34, 0x38, 0x32, 0x33, 0x37, 0x35, 0x30, 0x66, 0x37, 0x35, 0x30, 0x36, 0x38, 0x31, 0x37, 0x61, 0x61, 0x35, 0x37, 0x37, 0x39, 0x35, 0x35, 0x33, 0x30, 0x37, 0x32, 0x38, 0x38, 0x30, 0x62, 0x39, 0x38, 0x37, 0x32, 0x65, 0x39, 0x36, 0x66, 0x31, 0x62, 0x31, 0x62, 0x65, 0x33, 0x38, 0x36, 0x66, 0x35, 0x33, 0x36, 0x39, 0x30, 0x35, 0x30, 0x35, 0x37, 0x35, 0x39, 0x36, 0x66, 0x36, 0x32, 0x36, 0x61, 0x63, 0x65, 0x36, 0x64, 0x65, 0x35, 0x65, 0x34, 0x32, 0x34, 0x35, 0x34, 0x61, 0x33, 0x38, 0x35, 0x66, 0x64, 0x33, 0x30, 0x34, 0x36, 0x36, 0x35, 0x30, 0x31, 0x34, 0x32, 0x65, 0x33, 0x31, 0x39, 0x32, 0x37, 0x33, 0x32, 0x31, 0x63, 0x35, 0x38, 0x39, 0x33, 0x64, 0x30, 0x32, 0x30, 0x61, 0x37, 0x39, 0x32, 0x36, 0x61, 0x63, 0x30, 0x31, 0x36, 0x30, 0x65, 0x38, 0x33, 0x31, 0x35, 0x39, 0x30, 0x35, 0x64, 0x64, 0x34, 0x36, 0x30, 0x65, 0x66, 0x62, 0x64, 0x32, 0x34, 0x36, 0x64, 0x36, 0x37, 0x33, 0x37, 0x63, 0x63, 0x38, 0x66, 0x34, 0x31, 0x37, 0x32, 0x38, 0x39, 0x31, 0x31, 0x61, 0x64, 0x34, 0x35, 0x62, 0x36, 0x33, 0x65, 0x61, 0x64, 0x32, 0x39, 0x61, 0x38, 0x63, 0x34, 0x64, 0x32, 0x32, 0x39, 0x66, 0x62, 0x30, 0x32, 0x64, 0x66, 0x63, 0x36, 0x37, 0x61, 0x62, 0x30, 0x34, 0x38, 0x38, 0x35, 0x37, 0x35, 0x31, 0x64, 0x66, 0x62, 0x30, 0x36, 0x66, 0x37, 0x65, 0x37, 0x38, 0x31, 0x36, 0x30, 0x39, 0x38, 0x62, 0x30, 0x38, 0x36, 0x37, 0x32, 0x34, 0x62, 0x32, 0x31, 0x37, 0x38, 0x34, 0x66, 0x30, 0x34, 0x36, 0x31, 0x36, 0x34, 0x36, 0x63, 0x34, 0x31, 0x65, 0x30, 0x64, 0x33, 0x35, 0x65, 0x39, 0x37, 0x38, 0x61, 0x31, 0x63, 0x33, 0x61, 0x66, 0x63, 0x31, 0x63, 0x36, 0x61, 0x65, 0x65, 0x37, 0x66, 0x61, 0x64, 0x36, 0x36, 0x35, 0x33, 0x36, 0x32, 0x37, 0x65, 0x34, 0x37, 0x61, 0x39, 0x39, 0x37, 0x31, 0x33, 0x34, 0x32, 0x37, 0x32, 0x62, 0x61, 0x34, 0x36, 0x36, 0x37, 0x33, 0x64, 0x61, 0x33, 0x32, 0x39, 0x66, 0x30, 0x61, 0x32, 0x30, 0x62, 0x66, 0x31, 0x39, 0x65, 0x39, 0x30, 0x34, 0x66, 0x38, 0x39, 0x64, 0x65, 0x38, 0x65, 0x38, 0x30, 0x36, 0x36, 0x32, 0x64, 0x37, 0x39, 0x61, 0x37, 0x33, 0x34, 0x36, 0x37, 0x61, 0x39, 0x64, 0x61, 0x66, 0x36, 0x30, 0x32, 0x30, 0x65, 0x64, 0x62, 0x34, 0x38, 0x38, 0x61, 0x37, 0x32, 0x37, 0x62, 0x31, 0x61, 0x62, 0x33, 0x39, 0x31, 0x61, 0x30, 0x37, 0x31, 0x33, 0x61, 0x33, 0x64, 0x36, 0x34, 0x65, 0x66, 0x34, 0x61, 0x34, 0x31, 0x61, 0x39, 0x63, 0x38, 0x38, 0x39, 0x33, 0x37, 0x32, 0x63, 0x63, 0x66, 0x63, 0x31, 0x37, 0x39, 0x62, 0x39, 0x64, 0x63, 0x38, 0x33, 0x33, 0x36, 0x34, 0x64, 0x34, 0x61, 0x33, 0x36, 0x30, 0x31, 0x33, 0x38, 0x63, 0x65, 0x33, 0x63, 0x32, 0x38, 0x32, 0x31, 0x39, 0x34, 0x37, 0x34, 0x38, 0x39, 0x39, 0x33, 0x61, 0x30, 0x37, 0x66, 0x37, 0x33, 0x35, 0x64, 0x36, 0x64, 0x35, 0x65, 0x35, 0x31, 0x66, 0x33, 0x36, 0x61, 0x33, 0x33, 0x62, 0x63, 0x37, 0x65, 0x33, 0x66, 0x35, 0x34, 0x32, 0x61, 0x30, 0x33, 0x61, 0x61, 0x36, 0x32, 0x64, 0x30, 0x32, 0x37, 0x38, 0x32, 0x63, 0x63, 0x65, 0x39, 0x32, 0x39, 0x39, 0x32, 0x63, 0x65, 0x35, 0x39, 0x35, 0x33, 0x37, 0x32, 0x39, 0x35, 0x32, 0x37, 0x32, 0x34, 0x30, 0x63, 0x36, 0x38, 0x39, 0x31, 0x62, 0x66, 0x38, 0x35, 0x34, 0x32, 0x62, 0x36, 0x65, 0x30, 0x66, 0x33, 0x34, 0x33, 0x39, 0x33, 0x64, 0x66, 0x61, 0x33, 0x36, 0x36, 0x35, 0x30, 0x37, 0x38, 0x31, 0x37, 0x34, 0x32, 0x66, 0x66, 0x36, 0x30, 0x30, 0x66, 0x62, 0x35, 0x34, 0x34, 0x37, 0x64, 0x31, 0x39, 0x39, 0x34, 0x31, 0x31, 0x30, 0x37, 0x33, 0x31, 0x38, 0x33, 0x31, 0x31, 0x36, 0x65, 0x64, 0x63, 0x35, 0x34, 0x31, 0x31, 0x64, 0x36, 0x30, 0x63, 0x38, 0x63, 0x61, 0x35, 0x38, 0x32, 0x34, 0x61, 0x39, 0x33, 0x63, 0x39, 0x38, 0x66, 0x31, 0x32, 0x66, 0x34, 0x39, 0x31, 0x64, 0x63, 0x39, 0x36, 0x63, 0x66, 0x63, 0x30, 0x66, 0x62, 0x35, 0x32, 0x36, 0x39, 0x66, 0x34, 0x37, 0x32, 0x35, 0x37, 0x30, 0x38, 0x37, 0x32, 0x34, 0x65, 0x36, 0x32, 0x61, 0x62, 0x62, 0x34, 0x38, 0x36, 0x37, 0x62, 0x33, 0x61, 0x34, 0x65, 0x31, 0x35, 0x62, 0x61, 0x65, 0x31, 0x38, 0x37, 0x37, 0x61, 0x36, 0x36, 0x34, 0x32, 0x34, 0x61, 0x62, 0x65, 0x31, 0x65, 0x62, 0x30, 0x61, 0x61, 0x39, 0x39, 0x39, 0x62, 0x31, 0x36, 0x37, 0x61, 0x32, 0x35, 0x30, 0x37, 0x65, 0x65, 0x64, 0x38, 0x39, 0x61, 0x30, 0x65, 0x34, 0x35, 0x34, 0x38, 0x30, 0x66, 0x35, 0x65, 0x38, 0x31, 0x36, 0x32, 0x62, 0x64, 0x66, 0x31, 0x62, 0x64, 0x31, 0x65, 0x66, 0x34, 0x63, 0x39, 0x64, 0x37, 0x66, 0x38, 0x39, 0x32, 0x39, 0x37, 0x36, 0x36, 0x37, 0x38, 0x39, 0x39, 0x30, 0x61, 0x64, 0x65, 0x65, 0x33, 0x66, 0x30, 0x30, 0x30, 0x34, 0x39, 0x39, 0x33, 0x34, 0x36, 0x65, 0x63, 0x30, 0x32, 0x66, 0x62, 0x62, 0x39, 0x37, 0x62, 0x36, 0x62, 0x30, 0x37, 0x63, 0x65, 0x63, 0x39, 0x65, 0x33, 0x38, 0x34, 0x30, 0x35, 0x61, 0x36, 0x61, 0x37, 0x61, 0x65, 0x31, 0x61, 0x61, 0x65, 0x63, 0x35, 0x38, 0x36, 0x32, 0x64, 0x66, 0x62, 0x62, 0x33, 0x39, 0x37, 0x30, 0x39, 0x34, 0x61, 0x61, 0x33, 0x63, 0x36, 0x37, 0x65, 0x65, 0x34, 0x66, 0x64, 0x39, 0x66, 0x33, 0x30, 0x31, 0x64, 0x66, 0x34, 0x36, 0x65, 0x32, 0x63, 0x63, 0x36, 0x31, 0x63, 0x37, 0x32, 0x37, 0x38, 0x31, 0x61, 0x65, 0x65, 0x32, 0x64, 0x65, 0x38, 0x64, 0x64, 0x66, 0x65, 0x62, 0x61, 0x33, 0x30, 0x33, 0x34, 0x63, 0x35, 0x62, 0x39, 0x30, 0x35, 0x39, 0x39, 0x62, 0x62, 0x62, 0x31, 0x38, 0x63, 0x30, 0x66, 0x34, 0x66, 0x36, 0x37, 0x62, 0x37, 0x35, 0x65, 0x31, 0x62, 0x32, 0x31, 0x64, 0x36, 0x33, 0x31, 0x33, 0x37, 0x39, 0x32, 0x38, 0x34, 0x39, 0x31, 0x64, 0x36, 0x33, 0x36, 0x34, 0x35, 0x64, 0x39, 0x36, 0x38, 0x32, 0x65, 0x61, 0x66, 0x33, 0x38, 0x38, 0x64, 0x66, 0x63, 0x62, 0x39, 0x39, 0x38, 0x30, 0x32, 0x33, 0x32, 0x33, 0x65, 0x39, 0x32, 0x37, 0x35, 0x34, 0x64, 0x34, 0x31, 0x63, 0x39, 0x65, 0x63, 0x66, 0x30, 0x64, 0x36, 0x39, 0x35, 0x66, 0x65, 0x31, 0x33, 0x66, 0x65, 0x66, 0x35, 0x34, 0x37, 0x30, 0x35, 0x62, 0x33, 0x34, 0x64, 0x30, 0x66, 0x34, 0x61, 0x63, 0x32, 0x36, 0x63, 0x34, 0x39, 0x61, 0x64, 0x35, 0x62, 0x62, 0x31, 0x31, 0x62, 0x34, 0x61, 0x38, 0x35, 0x39, 0x64, 0x39, 0x30, 0x38, 0x63, 0x66, 0x30, 0x33, 0x38, 0x38, 0x32, 0x39, 0x33, 0x39, 0x34, 0x66, 0x31, 0x65, 0x37, 0x62, 0x63, 0x34, 0x34, 0x30, 0x35, 0x31, 0x63, 0x39, 0x37, 0x34, 0x37, 0x38, 0x62, 0x65, 0x38, 0x61, 0x35, 0x36, 0x33, 0x36, 0x31, 0x64, 0x30, 0x37, 0x32, 0x63, 0x65, 0x32, 0x35, 0x34, 0x33, 0x61, 0x39, 0x64, 0x66, 0x63, 0x61, 0x32, 0x38, 0x38, 0x34, 0x35, 0x34, 0x64, 0x61, 0x33, 0x62, 0x63, 0x65, 0x39, 0x62, 0x62, 0x30, 0x39, 0x64, 0x37, 0x65, 0x30, 0x61, 0x63, 0x31, 0x65, 0x35, 0x34, 0x36, 0x64, 0x64, 0x35, 0x30, 0x61, 0x36, 0x36, 0x38, 0x61, 0x32, 0x66, 0x63, 0x65, 0x34, 0x62, 0x36, 0x63, 0x64, 0x35, 0x61, 0x62, 0x37, 0x33, 0x33, 0x35, 0x37, 0x65, 0x35, 0x39, 0x31, 0x34, 0x34, 0x62, 0x33, 0x32, 0x61, 0x38, 0x34, 0x62, 0x62, 0x65, 0x64, 0x66, 0x36, 0x31, 0x66, 0x63, 0x66, 0x61, 0x37, 0x38, 0x61, 0x38, 0x31, 0x37, 0x63, 0x30, 0x64, 0x34, 0x35, 0x39, 0x61, 0x66, 0x34, 0x33, 0x30, 0x64, 0x34, 0x65, 0x34, 0x38, 0x32, 0x66, 0x38, 0x32, 0x65, 0x32, 0x66, 0x31, 0x39, 0x34, 0x65, 0x65, 0x36, 0x39, 0x65, 0x32, 0x35, 0x39, 0x34, 0x30, 0x34, 0x65, 0x33, 0x66, 0x63, 0x34, 0x38, 0x63, 0x63, 0x38, 0x61, 0x62, 0x33, 0x35, 0x36, 0x66, 0x31, 0x30, 0x35, 0x38, 0x36, 0x39, 0x66, 0x39, 0x63, 0x31, 0x36, 0x64, 0x65, 0x36, 0x39, 0x38, 0x36, 0x63, 0x36, 0x37, 0x34, 0x34, 0x36, 0x32, 0x64, 0x32, 0x34, 0x61, 0x30, 0x64, 0x35, 0x65, 0x39, 0x31, 0x31, 0x63, 0x31, 0x32, 0x36, 0x65, 0x36, 0x65, 0x34, 0x37, 0x32, 0x33, 0x62, 0x34, 0x36, 0x37, 0x66, 0x65, 0x63, 0x62, 0x38, 0x34, 0x31, 0x64, 0x30, 0x63, 0x61, 0x65, 0x35, 0x36, 0x37, 0x65, 0x61, 0x39, 0x63, 0x64, 0x38, 0x35, 0x65, 0x31, 0x66, 0x63, 0x64, 0x32, 0x63, 0x33, 0x66, 0x62, 0x61, 0x33, 0x34, 0x65, 0x35, 0x65, 0x38, 0x32, 0x32, 0x30, 0x33, 0x63, 0x62, 0x65, 0x33, 0x35, 0x61, 0x35, 0x33, 0x61, 0x34, 0x64, 0x38, 0x37, 0x39, 0x37, 0x32, 0x63, 0x66, 0x65, 0x62, 0x34, 0x32, 0x37, 0x36, 0x37, 0x32, 0x34, 0x35, 0x61, 0x37, 0x66, 0x30, 0x64, 0x30, 0x63, 0x39, 0x33, 0x37, 0x61, 0x39, 0x35, 0x39, 0x62, 0x34, 0x63, 0x32, 0x30, 0x64, 0x33, 0x38, 0x38, 0x66, 0x35, 0x31, 0x36, 0x31, 0x39, 0x33, 0x64, 0x33, 0x64, 0x65, 0x64, 0x36, 0x34, 0x36, 0x32, 0x34, 0x31, 0x37, 0x32, 0x38, 0x63, 0x34, 0x62, 0x38, 0x63, 0x66, 0x37, 0x32, 0x63, 0x35, 0x35, 0x37, 0x66, 0x38, 0x30, 0x34, 0x66, 0x35, 0x62, 0x34, 0x34, 0x63, 0x32, 0x37, 0x66, 0x61, 0x33, 0x64, 0x38, 0x38, 0x35, 0x35, 0x32, 0x61, 0x36, 0x66, 0x36, 0x31, 0x32, 0x34, 0x31, 0x65, 0x61, 0x34, 0x39, 0x30, 0x31, 0x38, 0x37, 0x61, 0x62, 0x32, 0x65, 0x63, 0x65, 0x65, 0x61, 0x61, 0x36, 0x31, 0x30, 0x65, 0x32, 0x34, 0x33, 0x35, 0x33, 0x61, 0x36, 0x62, 0x37, 0x32, 0x62, 0x63, 0x31, 0x62, 0x37, 0x39, 0x30, 0x31, 0x36, 0x31, 0x61, 0x34, 0x38, 0x33, 0x31, 0x65, 0x35, 0x39, 0x33, 0x32, 0x62, 0x61, 0x63, 0x61, 0x64, 0x63, 0x31, 0x39, 0x37, 0x61, 0x61, 0x37, 0x38, 0x66, 0x35, 0x30, 0x38, 0x37, 0x31, 0x66, 0x35, 0x33, 0x61, 0x34, 0x33, 0x63, 0x31, 0x34, 0x36, 0x62, 0x32, 0x30, 0x35, 0x62, 0x30, 0x32, 0x62, 0x64, 0x37, 0x36, 0x35, 0x63, 0x37, 0x32, 0x61, 0x31, 0x33, 0x62, 0x30, 0x38, 0x34, 0x38, 0x64, 0x36, 0x63, 0x34, 0x30, 0x62, 0x34, 0x37, 0x33, 0x34, 0x32, 0x39, 0x65, 0x39, 0x61, 0x37, 0x36, 0x62, 0x64, 0x34, 0x39, 0x33, 0x31, 0x31, 0x33, 0x35, 0x39, 0x36, 0x37, 0x64, 0x35, 0x62, 0x30, 0x63, 0x64, 0x62, 0x66, 0x30, 0x66, 0x31, 0x35, 0x30, 0x62, 0x38, 0x63, 0x37, 0x61, 0x66, 0x30, 0x36, 0x61, 0x62, 0x32, 0x65, 0x36, 0x31, 0x66, 0x62, 0x36, 0x34, 0x36, 0x38, 0x38, 0x32, 0x62, 0x30, 0x37, 0x61, 0x34, 0x35, 0x33, 0x38, 0x36, 0x39, 0x61, 0x38, 0x33, 0x66, 0x37, 0x33, 0x33, 0x61, 0x32, 0x38, 0x33, 0x33, 0x37, 0x61, 0x61, 0x38, 0x36, 0x37, 0x31, 0x62, 0x39, 0x39, 0x65, 0x35, 0x64, 0x30, 0x32, 0x66, 0x35, 0x61, 0x61, 0x35, 0x31, 0x35, 0x61, 0x66, 0x33, 0x61, 0x39, 0x62, 0x33, 0x39, 0x35, 0x32, 0x37, 0x32, 0x30, 0x30, 0x61, 0x38, 0x33, 0x62, 0x34, 0x35, 0x30, 0x35, 0x61, 0x63, 0x33, 0x61, 0x30, 0x63, 0x31, 0x63, 0x32, 0x35, 0x34, 0x64, 0x30, 0x61, 0x35, 0x34, 0x33, 0x64, 0x65, 0x65, 0x32, 0x37, 0x35, 0x36, 0x32, 0x38, 0x61, 0x61, 0x63, 0x65, 0x64, 0x38, 0x32, 0x30, 0x30, 0x36, 0x30, 0x32, 0x63, 0x61, 0x34, 0x61, 0x39, 0x61, 0x32, 0x33, 0x64, 0x37, 0x38, 0x62, 0x38, 0x61, 0x30, 0x34, 0x32, 0x35, 0x31, 0x30, 0x35, 0x38, 0x66, 0x31, 0x32, 0x62, 0x39, 0x62, 0x37, 0x61, 0x61, 0x66, 0x39, 0x62, 0x39, 0x35, 0x66, 0x62, 0x62, 0x65, 0x39, 0x32, 0x31, 0x66, 0x34, 0x65, 0x36, 0x37, 0x32, 0x36, 0x63, 0x36, 0x33, 0x33, 0x37, 0x63, 0x38, 0x36, 0x30, 0x33, 0x38, 0x31, 0x39, 0x33, 0x66, 0x39, 0x37, 0x64, 0x62, 0x32, 0x61, 0x36, 0x63, 0x37, 0x39, 0x65, 0x33, 0x66, 0x37, 0x32, 0x35, 0x63, 0x37, 0x31, 0x61, 0x37, 0x63, 0x61, 0x65, 0x35, 0x66, 0x33, 0x65, 0x39, 0x37, 0x30, 0x31, 0x36, 0x61, 0x62, 0x63, 0x62, 0x38, 0x62, 0x32, 0x30, 0x66, 0x32, 0x38, 0x33, 0x62, 0x31, 0x33, 0x66, 0x30, 0x64, 0x65, 0x65, 0x66, 0x37, 0x30, 0x34, 0x63, 0x34, 0x35, 0x65, 0x62, 0x63, 0x35, 0x36, 0x66, 0x38, 0x61, 0x33, 0x39, 0x66, 0x32, 0x35, 0x64, 0x65, 0x64, 0x38, 0x37, 0x32, 0x30, 0x37, 0x30, 0x63, 0x63, 0x34, 0x36, 0x37, 0x61, 0x30, 0x30, 0x35, 0x61, 0x34, 0x39, 0x34, 0x62, 0x31, 0x38, 0x36, 0x62, 0x37, 0x65, 0x62, 0x38, 0x33, 0x30, 0x62, 0x30, 0x39, 0x31, 0x66, 0x65, 0x30, 0x35, 0x33, 0x32, 0x62, 0x38, 0x38, 0x30, 0x31, 0x62, 0x62, 0x30, 0x61, 0x30, 0x35, 0x65, 0x35, 0x62, 0x62, 0x39, 0x63, 0x63, 0x39, 0x36, 0x38, 0x32, 0x64, 0x32, 0x64, 0x37, 0x32, 0x38, 0x34, 0x65, 0x37, 0x30, 0x38, 0x30, 0x63, 0x62, 0x63, 0x30, 0x32, 0x62, 0x36, 0x64, 0x30, 0x66, 0x62, 0x39, 0x31, 0x34, 0x63, 0x32, 0x37, 0x34, 0x62, 0x33, 0x66, 0x36, 0x36, 0x35, 0x31, 0x65, 0x66, 0x34, 0x35, 0x39, 0x35, 0x35, 0x38, 0x61, 0x66, 0x32, 0x38, 0x62, 0x61, 0x32, 0x61, 0x38, 0x66, 0x34, 0x62, 0x36, 0x64, 0x65, 0x39, 0x38, 0x39, 0x31, 0x39, 0x62, 0x37, 0x37, 0x32, 0x32, 0x30, 0x61, 0x36, 0x65, 0x35, 0x65, 0x61, 0x34, 0x62, 0x33, 0x30, 0x62, 0x63, 0x66, 0x34, 0x61, 0x30, 0x38, 0x38, 0x62, 0x66, 0x33, 0x62, 0x32, 0x37, 0x65, 0x37, 0x65, 0x33, 0x66, 0x37, 0x32, 0x31, 0x66, 0x62, 0x33, 0x35, 0x64, 0x63, 0x34, 0x30, 0x63, 0x66, 0x39, 0x31, 0x33, 0x65, 0x66, 0x66, 0x66, 0x31, 0x62, 0x38, 0x39, 0x32, 0x63, 0x66, 0x37, 0x62, 0x36, 0x63, 0x32, 0x34, 0x33, 0x39, 0x32, 0x30, 0x63, 0x62, 0x62, 0x66, 0x38, 0x36, 0x31, 0x36, 0x32, 0x34, 0x64, 0x66, 0x35, 0x34, 0x31, 0x39, 0x62, 0x34, 0x34, 0x34, 0x32, 0x61, 0x38, 0x33, 0x39, 0x65, 0x62, 0x34, 0x37, 0x31, 0x36, 0x34, 0x32, 0x35, 0x32, 0x31, 0x62, 0x39, 0x31, 0x63, 0x61, 0x30, 0x31, 0x61, 0x66, 0x65, 0x35, 0x32, 0x32, 0x37, 0x32, 0x65, 0x33, 0x39, 0x30, 0x62, 0x36, 0x66, 0x36, 0x33, 0x31, 0x39, 0x36, 0x35, 0x31, 0x33, 0x66, 0x35, 0x36, 0x36, 0x62, 0x33, 0x39, 0x37, 0x35, 0x37, 0x66, 0x65, 0x65, 0x36, 0x37, 0x30, 0x61, 0x37, 0x64, 0x36, 0x38, 0x33, 0x39, 0x39, 0x38, 0x64, 0x38, 0x37, 0x34, 0x66, 0x39, 0x61, 0x64, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x36, 0x35, 0x38, 0x64, 0x65, 0x34, 0x34, 0x38, 0x66, 0x37, 0x39, 0x61, 0x37, 0x64, 0x35, 0x39, 0x38, 0x38, 0x38, 0x32, 0x36, 0x30, 0x65, 0x66, 0x66, 0x38, 0x33, 0x35, 0x62, 0x62, 0x61, 0x31, 0x65, 0x32, 0x38, 0x62, 0x39, 0x66, 0x38, 0x61, 0x63, 0x63, 0x62, 0x66, 0x63, 0x64, 0x34, 0x35, 0x63, 0x35, 0x65, 0x37, 0x37, 0x37, 0x33, 0x31, 0x61, 0x61, 0x62, 0x31, 0x63, 0x30, 0x65, 0x34, 0x38, 0x36, 0x31, 0x35, 0x36, 0x65, 0x62, 0x61, 0x35, 0x37, 0x36, 0x31, 0x64, 0x35, 0x36, 0x37, 0x62, 0x66, 0x62, 0x39, 0x32, 0x62, 0x65, 0x62, 0x38, 0x38, 0x32, 0x31, 0x33, 0x34, 0x62, 0x65, 0x66, 0x36, 0x64, 0x66, 0x36, 0x61, 0x66, 0x37, 0x66, 0x33, 0x61, 0x65, 0x33, 0x63, 0x30, 0x38, 0x65, 0x33, 0x37, 0x32, 0x31, 0x34, 0x34, 0x62, 0x33, 0x32, 0x62, 0x39, 0x38, 0x64, 0x39, 0x66, 0x30, 0x65, 0x33, 0x62, 0x61, 0x37, 0x34, 0x31, 0x38, 0x34, 0x35, 0x34, 0x66, 0x36, 0x37, 0x32, 0x65, 0x66, 0x33, 0x66, 0x31, 0x34, 0x39, 0x63, 0x35, 0x38, 0x30, 0x38, 0x34, 0x37, 0x33, 0x37, 0x38, 0x33, 0x32, 0x63, 0x33, 0x33, 0x31, 0x30, 0x36, 0x38, 0x62, 0x63, 0x39, 0x32, 0x65, 0x61, 0x63, 0x39, 0x38, 0x37, 0x63, 0x63, 0x66, 0x63, 0x64, 0x65, 0x31, 0x38, 0x31, 0x64, 0x62, 0x38, 0x32, 0x66, 0x39, 0x64, 0x30, 0x32, 0x30, 0x35, 0x62, 0x65, 0x66, 0x62, 0x31, 0x62, 0x37, 0x32, 0x30, 0x37, 0x38, 0x61, 0x64, 0x34, 0x39, 0x38, 0x37, 0x62, 0x37, 0x39, 0x30, 0x63, 0x64, 0x63, 0x37, 0x61, 0x37, 0x37, 0x36, 0x66, 0x38, 0x33, 0x37, 0x34, 0x39, 0x32, 0x37, 0x35, 0x62, 0x38, 0x34, 0x35, 0x39, 0x62, 0x64, 0x62, 0x31, 0x63, 0x64, 0x30, 0x31, 0x30, 0x62, 0x36, 0x65, 0x63, 0x33, 0x33, 0x64, 0x66, 0x30, 0x64, 0x32, 0x35, 0x39, 0x34, 0x61, 0x37, 0x38, 0x32, 0x33, 0x31, 0x32, 0x62, 0x38, 0x37, 0x32, 0x30, 0x64, 0x32, 0x33, 0x66, 0x35, 0x39, 0x64, 0x64, 0x64, 0x34, 0x31, 0x65, 0x32, 0x36, 0x37, 0x35, 0x39, 0x36, 0x32, 0x36, 0x33, 0x37, 0x31, 0x31, 0x31, 0x61, 0x37, 0x31, 0x37, 0x64, 0x33, 0x38, 0x34, 0x30, 0x62, 0x65, 0x31, 0x34, 0x32, 0x36, 0x64, 0x64, 0x61, 0x62, 0x31, 0x66, 0x34, 0x31, 0x30, 0x66, 0x37, 0x63, 0x33, 0x37, 0x66, 0x31, 0x34, 0x35, 0x66, 0x61, 0x39, 0x37, 0x38, 0x35, 0x61, 0x65, 0x34, 0x66, 0x38, 0x30, 0x37, 0x32, 0x63, 0x37, 0x38, 0x36, 0x66, 0x62, 0x33, 0x33, 0x32, 0x35, 0x32, 0x65, 0x63, 0x62, 0x63, 0x33, 0x36, 0x35, 0x65, 0x37, 0x38, 0x64, 0x37, 0x35, 0x62, 0x37, 0x31, 0x31, 0x32, 0x33, 0x66, 0x62, 0x66, 0x34, 0x34, 0x38, 0x36, 0x34, 0x64, 0x39, 0x61, 0x30, 0x37, 0x38, 0x32, 0x66, 0x37, 0x34, 0x37, 0x32, 0x30, 0x61, 0x65, 0x37, 0x34, 0x38, 0x33, 0x30, 0x32, 0x35, 0x61, 0x31, 0x66, 0x32, 0x38, 0x65, 0x65, 0x63, 0x37, 0x37, 0x64, 0x64, 0x38, 0x36, 0x31, 0x31, 0x38, 0x64, 0x64, 0x33, 0x66, 0x66, 0x63, 0x36, 0x62, 0x33, 0x39, 0x39, 0x37, 0x39, 0x65, 0x63, 0x61, 0x34, 0x32, 0x66, 0x35, 0x38, 0x33, 0x37, 0x61, 0x39, 0x65, 0x37, 0x64, 0x33, 0x32, 0x64, 0x38, 0x65, 0x61, 0x36, 0x30, 0x62, 0x38, 0x31, 0x61, 0x37, 0x38, 0x37, 0x39, 0x35, 0x61, 0x30, 0x31, 0x37, 0x39, 0x32, 0x32, 0x32, 0x64, 0x61, 0x34, 0x38, 0x31, 0x38, 0x65, 0x65, 0x37, 0x65, 0x31, 0x63, 0x36, 0x30, 0x61, 0x30, 0x35, 0x33, 0x36, 0x38, 0x62, 0x61, 0x31, 0x30, 0x64, 0x39, 0x33, 0x37, 0x61, 0x38, 0x30, 0x63, 0x63, 0x65, 0x66, 0x35, 0x32, 0x32, 0x61, 0x61, 0x32, 0x66, 0x37, 0x34, 0x61, 0x39, 0x32, 0x62, 0x39, 0x30, 0x38, 0x38, 0x36, 0x37, 0x36, 0x36, 0x63, 0x39, 0x65, 0x30, 0x31, 0x38, 0x64, 0x35, 0x63, 0x62, 0x35, 0x37, 0x34, 0x39, 0x32, 0x32, 0x63, 0x66, 0x37, 0x39, 0x31, 0x66, 0x66, 0x33, 0x62, 0x62, 0x39, 0x37, 0x30, 0x34, 0x32, 0x35, 0x36, 0x62, 0x33, 0x38, 0x31, 0x33, 0x32, 0x63, 0x64, 0x39, 0x64, 0x36, 0x38, 0x63, 0x64, 0x31, 0x36, 0x34, 0x33, 0x63, 0x62, 0x37, 0x37, 0x32, 0x38, 0x36, 0x36, 0x62, 0x34, 0x61, 0x66, 0x33, 0x61, 0x63, 0x39, 0x62, 0x35, 0x30, 0x38, 0x38, 0x63, 0x32, 0x39, 0x31, 0x34, 0x30, 0x34, 0x37, 0x32, 0x32, 0x36, 0x62, 0x31, 0x63, 0x30, 0x39, 0x38, 0x31, 0x33, 0x37, 0x66, 0x34, 0x62, 0x61, 0x64, 0x38, 0x61, 0x31, 0x38, 0x34, 0x34, 0x31, 0x37, 0x35, 0x31, 0x63, 0x32, 0x65, 0x66, 0x32, 0x63, 0x66, 0x39, 0x30, 0x32, 0x64, 0x36, 0x30, 0x31, 0x61, 0x32, 0x39, 0x34, 0x37, 0x61, 0x36, 0x66, 0x61, 0x65, 0x31, 0x65, 0x37, 0x35, 0x37, 0x31, 0x64, 0x64, 0x38, 0x63, 0x32, 0x64, 0x65, 0x31, 0x31, 0x35, 0x37, 0x35, 0x63, 0x33, 0x34, 0x32, 0x63, 0x32, 0x62, 0x30, 0x33, 0x36, 0x39, 0x36, 0x37, 0x33, 0x32, 0x36, 0x61, 0x38, 0x65, 0x64, 0x61, 0x30, 0x63, 0x30, 0x39, 0x37, 0x33, 0x62, 0x36, 0x33, 0x64, 0x35, 0x31, 0x35, 0x66, 0x31, 0x32, 0x62, 0x65, 0x34, 0x64, 0x38, 0x33, 0x38, 0x36, 0x64, 0x35, 0x65, 0x39, 0x39, 0x33, 0x63, 0x63, 0x61, 0x30, 0x37, 0x33, 0x30, 0x35, 0x38, 0x36, 0x32, 0x38, 0x63, 0x62, 0x34, 0x33, 0x38, 0x62, 0x36, 0x65, 0x39, 0x34, 0x35, 0x65, 0x38, 0x38, 0x39, 0x30, 0x39, 0x61, 0x31, 0x31, 0x65, 0x33, 0x30, 0x34, 0x65, 0x66, 0x64, 0x64, 0x63, 0x63, 0x65, 0x64, 0x33, 0x36, 0x30, 0x31, 0x36, 0x34, 0x63, 0x36, 0x36, 0x66, 0x30, 0x33, 0x39, 0x61, 0x33, 0x66, 0x34, 0x61, 0x31, 0x65, 0x35, 0x30, 0x63, 0x63, 0x64, 0x36, 0x30, 0x38, 0x37, 0x36, 0x36, 0x39, 0x34, 0x62, 0x33, 0x66, 0x65, 0x63, 0x63, 0x33, 0x63, 0x33, 0x64, 0x37, 0x37, 0x33, 0x32, 0x30, 0x32, 0x62, 0x38, 0x64, 0x34, 0x31, 0x35, 0x63, 0x30, 0x66, 0x65, 0x35, 0x66, 0x65, 0x37, 0x34, 0x39, 0x39, 0x30, 0x32, 0x66, 0x62, 0x63, 0x30, 0x61, 0x33, 0x66, 0x62, 0x33, 0x39, 0x66, 0x31, 0x62, 0x64, 0x35, 0x63, 0x65, 0x62, 0x65, 0x32, 0x37, 0x65, 0x39, 0x63, 0x30, 0x35, 0x35, 0x34, 0x33, 0x31, 0x34, 0x39, 0x63, 0x61, 0x37, 0x32, 0x61, 0x66, 0x34, 0x63, 0x62, 0x37, 0x39, 0x31, 0x64, 0x37, 0x31, 0x30, 0x38, 0x65, 0x32, 0x61, 0x34, 0x30, 0x30, 0x37, 0x30, 0x38, 0x64, 0x65, 0x32, 0x32, 0x37, 0x32, 0x61, 0x31, 0x63, 0x66, 0x63, 0x32, 0x35, 0x39, 0x33, 0x38, 0x63, 0x30, 0x35, 0x38, 0x38, 0x38, 0x33, 0x35, 0x62, 0x35, 0x33, 0x36, 0x63, 0x30, 0x65, 0x33, 0x36, 0x66, 0x33, 0x39, 0x31, 0x63, 0x64, 0x65, 0x39, 0x65, 0x38, 0x30, 0x30, 0x62, 0x61, 0x66, 0x39, 0x62, 0x39, 0x32, 0x38, 0x38, 0x66, 0x34, 0x39, 0x36, 0x39, 0x66, 0x33, 0x61, 0x37, 0x30, 0x35, 0x61, 0x38, 0x33, 0x30, 0x33, 0x38, 0x32, 0x64, 0x32, 0x30, 0x64, 0x37, 0x30, 0x31, 0x63, 0x63, 0x66, 0x31, 0x34, 0x63, 0x38, 0x37, 0x63, 0x34, 0x30, 0x61, 0x31, 0x66, 0x38, 0x32, 0x65, 0x30, 0x61, 0x38, 0x64, 0x61, 0x64, 0x61, 0x61, 0x64, 0x66, 0x65, 0x39, 0x61, 0x66, 0x66, 0x62, 0x36, 0x32, 0x39, 0x33, 0x39, 0x33, 0x30, 0x38, 0x31, 0x31, 0x35, 0x38, 0x35, 0x39, 0x32, 0x37, 0x38, 0x39, 0x66, 0x66, 0x37, 0x32, 0x39, 0x61, 0x38, 0x66, 0x34, 0x34, 0x30, 0x61, 0x64, 0x62, 0x64, 0x66, 0x64, 0x31, 0x34, 0x37, 0x39, 0x34, 0x36, 0x37, 0x63, 0x63, 0x37, 0x66, 0x36, 0x36, 0x64, 0x63, 0x34, 0x33, 0x66, 0x66, 0x34, 0x36, 0x38, 0x33, 0x37, 0x63, 0x35, 0x37, 0x62, 0x64, 0x39, 0x39, 0x62, 0x31, 0x34, 0x30, 0x35, 0x39, 0x38, 0x37, 0x65, 0x63, 0x37, 0x66, 0x35, 0x32, 0x64, 0x39, 0x39, 0x31, 0x36, 0x36, 0x34, 0x32, 0x36, 0x64, 0x65, 0x34, 0x36, 0x30, 0x31, 0x30, 0x66, 0x65, 0x33, 0x34, 0x35, 0x64, 0x66, 0x31, 0x34, 0x38, 0x39, 0x37, 0x66, 0x66, 0x31, 0x32, 0x39, 0x36, 0x33, 0x62, 0x36, 0x61, 0x38, 0x37, 0x32, 0x64, 0x61, 0x37, 0x39, 0x37, 0x30, 0x65, 0x36, 0x30, 0x36, 0x38, 0x66, 0x64, 0x32, 0x35, 0x32, 0x33, 0x32, 0x64, 0x30, 0x34, 0x31, 0x64, 0x38, 0x33, 0x32, 0x38, 0x33, 0x37, 0x30, 0x64, 0x61, 0x33, 0x61, 0x31, 0x39, 0x63, 0x64, 0x38, 0x35, 0x66, 0x31, 0x64, 0x33, 0x64, 0x37, 0x37, 0x66, 0x36, 0x38, 0x30, 0x39, 0x38, 0x34, 0x36, 0x33, 0x31, 0x38, 0x39, 0x32, 0x36, 0x61, 0x34, 0x39, 0x38, 0x34, 0x64, 0x62, 0x34, 0x63, 0x65, 0x36, 0x61, 0x32, 0x63, 0x35, 0x36, 0x39, 0x30, 0x63, 0x63, 0x35, 0x62, 0x38, 0x61, 0x64, 0x62, 0x64, 0x32, 0x38, 0x63, 0x37, 0x32, 0x36, 0x39, 0x35, 0x63, 0x39, 0x31, 0x34, 0x36, 0x31, 0x36, 0x30, 0x63, 0x65, 0x38, 0x34, 0x30, 0x37, 0x30, 0x65, 0x65, 0x39, 0x33, 0x35, 0x31, 0x63, 0x34, 0x66, 0x39, 0x32, 0x66, 0x31, 0x32, 0x63, 0x38, 0x62, 0x30, 0x31, 0x66, 0x62, 0x61, 0x33, 0x62, 0x64, 0x35, 0x62, 0x63, 0x62, 0x64, 0x38, 0x65, 0x35, 0x36, 0x38, 0x35, 0x36, 0x63, 0x66, 0x39, 0x65, 0x63, 0x37, 0x65, 0x31, 0x39, 0x33, 0x37, 0x37, 0x63, 0x31, 0x30, 0x31, 0x39, 0x37, 0x33, 0x31, 0x30, 0x63, 0x39, 0x62, 0x66, 0x64, 0x31, 0x61, 0x39, 0x64, 0x61, 0x37, 0x37, 0x31, 0x62, 0x38, 0x36, 0x64, 0x64, 0x39, 0x34, 0x35, 0x37, 0x30, 0x63, 0x66, 0x31, 0x37, 0x66, 0x39, 0x36, 0x63, 0x63, 0x30, 0x32, 0x31, 0x34, 0x34, 0x65, 0x61, 0x31, 0x62, 0x39, 0x35, 0x64, 0x65, 0x39, 0x61, 0x36, 0x37, 0x37, 0x31, 0x62, 0x33, 0x64, 0x62, 0x64, 0x33, 0x62, 0x39, 0x34, 0x63, 0x64, 0x65, 0x31, 0x30, 0x34, 0x34, 0x30, 0x31, 0x63, 0x32, 0x62, 0x35, 0x61, 0x34, 0x31, 0x63, 0x33, 0x32, 0x33, 0x39, 0x33, 0x62, 0x34, 0x66, 0x62, 0x65, 0x32, 0x31, 0x61, 0x64, 0x39, 0x31, 0x36, 0x36, 0x32, 0x36, 0x61, 0x64, 0x31, 0x36, 0x32, 0x30, 0x64, 0x63, 0x34, 0x36, 0x62, 0x32, 0x62, 0x36, 0x62, 0x63, 0x36, 0x30, 0x64, 0x61, 0x63, 0x36, 0x66, 0x38, 0x34, 0x32, 0x34, 0x38, 0x36, 0x66, 0x65, 0x61, 0x32, 0x30, 0x64, 0x32, 0x66, 0x39, 0x62, 0x62, 0x66, 0x38, 0x35, 0x34, 0x31, 0x65, 0x65, 0x33, 0x64, 0x30, 0x62, 0x35, 0x39, 0x63, 0x31, 0x35, 0x61, 0x32, 0x63, 0x63, 0x38, 0x65, 0x39, 0x39, 0x64, 0x66, 0x34, 0x37, 0x31, 0x30, 0x34, 0x39, 0x36, 0x30, 0x65, 0x32, 0x39, 0x32, 0x61, 0x30, 0x36, 0x37, 0x32, 0x65, 0x37, 0x38, 0x63, 0x31, 0x63, 0x36, 0x37, 0x30, 0x64, 0x63, 0x66, 0x65, 0x37, 0x34, 0x32, 0x34, 0x36, 0x33, 0x32, 0x63, 0x31, 0x39, 0x39, 0x65, 0x63, 0x39, 0x64, 0x39, 0x38, 0x38, 0x32, 0x65, 0x64, 0x62, 0x36, 0x61, 0x62, 0x38, 0x34, 0x61, 0x31, 0x34, 0x62, 0x66, 0x64, 0x62, 0x66, 0x32, 0x66, 0x30, 0x36, 0x33, 0x35, 0x33, 0x34, 0x30, 0x31, 0x34, 0x66, 0x31, 0x36, 0x37, 0x32, 0x65, 0x36, 0x36, 0x35, 0x63, 0x65, 0x39, 0x32, 0x31, 0x31, 0x65, 0x63, 0x30, 0x64, 0x64, 0x31, 0x34, 0x35, 0x36, 0x33, 0x66, 0x65, 0x34, 0x61, 0x39, 0x32, 0x61, 0x65, 0x30, 0x39, 0x32, 0x39, 0x65, 0x31, 0x37, 0x30, 0x65, 0x30, 0x35, 0x63, 0x38, 0x35, 0x36, 0x38, 0x37, 0x33, 0x32, 0x33, 0x61, 0x65, 0x36, 0x65, 0x66, 0x61, 0x66, 0x30, 0x32, 0x63, 0x62, 0x64, 0x64, 0x66, 0x37, 0x32, 0x63, 0x31, 0x36, 0x34, 0x38, 0x62, 0x62, 0x35, 0x31, 0x35, 0x35, 0x34, 0x66, 0x31, 0x39, 0x66, 0x36, 0x35, 0x39, 0x36, 0x34, 0x30, 0x37, 0x34, 0x66, 0x35, 0x34, 0x61, 0x36, 0x66, 0x62, 0x30, 0x32, 0x65, 0x39, 0x36, 0x35, 0x36, 0x61, 0x62, 0x64, 0x65, 0x61, 0x66, 0x37, 0x66, 0x64, 0x65, 0x64, 0x35, 0x65, 0x37, 0x37, 0x31, 0x35, 0x63, 0x61, 0x36, 0x39, 0x65, 0x35, 0x63, 0x37, 0x32, 0x38, 0x34, 0x30, 0x30, 0x66, 0x62, 0x32, 0x61, 0x63, 0x64, 0x66, 0x65, 0x35, 0x65, 0x38, 0x62, 0x34, 0x39, 0x62, 0x33, 0x35, 0x35, 0x63, 0x39, 0x35, 0x36, 0x30, 0x65, 0x65, 0x39, 0x30, 0x66, 0x33, 0x65, 0x36, 0x31, 0x36, 0x63, 0x62, 0x31, 0x63, 0x63, 0x39, 0x37, 0x64, 0x38, 0x34, 0x34, 0x39, 0x37, 0x32, 0x38, 0x37, 0x37, 0x36, 0x31, 0x61, 0x35, 0x38, 0x63, 0x37, 0x35, 0x37, 0x32, 0x30, 0x34, 0x66, 0x61, 0x36, 0x32, 0x37, 0x66, 0x36, 0x65, 0x34, 0x63, 0x36, 0x62, 0x64, 0x62, 0x37, 0x35, 0x65, 0x31, 0x34, 0x64, 0x39, 0x34, 0x62, 0x34, 0x33, 0x66, 0x34, 0x35, 0x34, 0x63, 0x32, 0x36, 0x63, 0x33, 0x30, 0x30, 0x66, 0x38, 0x37, 0x37, 0x39, 0x36, 0x64, 0x39, 0x65, 0x30, 0x62, 0x33, 0x33, 0x61, 0x34, 0x63, 0x65, 0x36, 0x36, 0x63, 0x38, 0x37, 0x33, 0x31, 0x37, 0x32, 0x36, 0x39, 0x62, 0x64, 0x37, 0x62, 0x64, 0x62, 0x62, 0x35, 0x64, 0x32, 0x37, 0x33, 0x62, 0x34, 0x37, 0x62, 0x66, 0x37, 0x65, 0x64, 0x39, 0x35, 0x32, 0x32, 0x61, 0x37, 0x30, 0x34, 0x37, 0x65, 0x30, 0x33, 0x39, 0x61, 0x66, 0x66, 0x63, 0x63, 0x63, 0x65, 0x34, 0x36, 0x62, 0x38, 0x32, 0x38, 0x61, 0x37, 0x31, 0x64, 0x35, 0x32, 0x61, 0x30, 0x37, 0x66, 0x35, 0x38, 0x33, 0x30, 0x35, 0x38, 0x39, 0x62, 0x34, 0x38, 0x36, 0x37, 0x35, 0x65, 0x62, 0x65, 0x35, 0x62, 0x30, 0x36, 0x63, 0x32, 0x34, 0x62, 0x38, 0x37, 0x33, 0x34, 0x34, 0x63, 0x33, 0x64, 0x64, 0x35, 0x38, 0x63, 0x66, 0x61, 0x39, 0x31, 0x38, 0x34, 0x63, 0x34, 0x30, 0x31, 0x32, 0x62, 0x34, 0x34, 0x33, 0x36, 0x63, 0x36, 0x65, 0x33, 0x36, 0x33, 0x64, 0x30, 0x62, 0x31, 0x61, 0x62, 0x61, 0x35, 0x38, 0x39, 0x31, 0x61, 0x63, 0x64, 0x36, 0x63, 0x66, 0x39, 0x31, 0x65, 0x65, 0x31, 0x34, 0x31, 0x34, 0x34, 0x62, 0x32, 0x39, 0x31, 0x38, 0x30, 0x32, 0x62, 0x39, 0x65, 0x61, 0x66, 0x37, 0x36, 0x61, 0x33, 0x63, 0x39, 0x33, 0x36, 0x66, 0x65, 0x63, 0x64, 0x30, 0x30, 0x34, 0x64, 0x65, 0x32, 0x63, 0x33, 0x38, 0x33, 0x38, 0x39, 0x61, 0x30, 0x32, 0x38, 0x32, 0x34, 0x37, 0x64, 0x62, 0x33, 0x63, 0x37, 0x37, 0x32, 0x63, 0x64, 0x35, 0x31, 0x38, 0x63, 0x32, 0x63, 0x36, 0x39, 0x39, 0x66, 0x32, 0x31, 0x61, 0x36, 0x63, 0x65, 0x38, 0x37, 0x66, 0x36, 0x62, 0x66, 0x34, 0x32, 0x35, 0x66, 0x38, 0x66, 0x66, 0x64, 0x65, 0x30, 0x63, 0x31, 0x38, 0x64, 0x32, 0x37, 0x39, 0x63, 0x34, 0x62, 0x35, 0x63, 0x33, 0x65, 0x36, 0x62, 0x35, 0x61, 0x31, 0x37, 0x31, 0x64, 0x37, 0x34, 0x31, 0x61, 0x38, 0x30, 0x37, 0x32, 0x34, 0x37, 0x33, 0x37, 0x61, 0x66, 0x61, 0x39, 0x33, 0x38, 0x39, 0x61, 0x32, 0x61, 0x36, 0x38, 0x64, 0x65, 0x35, 0x61, 0x37, 0x34, 0x62, 0x65, 0x63, 0x62, 0x61, 0x34, 0x37, 0x31, 0x62, 0x38, 0x63, 0x62, 0x34, 0x66, 0x35, 0x63, 0x65, 0x61, 0x36, 0x62, 0x64, 0x63, 0x62, 0x64, 0x36, 0x66, 0x63, 0x64, 0x64, 0x63, 0x62, 0x32, 0x38, 0x64, 0x63, 0x34, 0x61, 0x63, 0x33, 0x66, 0x37, 0x32, 0x38, 0x32, 0x64, 0x33, 0x65, 0x37, 0x62, 0x35, 0x34, 0x66, 0x65, 0x34, 0x63, 0x32, 0x34, 0x65, 0x61, 0x39, 0x34, 0x35, 0x37, 0x65, 0x39, 0x62, 0x61, 0x36, 0x66, 0x31, 0x65, 0x65, 0x65, 0x32, 0x64, 0x66, 0x32, 0x32, 0x38, 0x64, 0x34, 0x31, 0x34, 0x65, 0x63, 0x65, 0x38, 0x62, 0x30, 0x32, 0x34, 0x39, 0x31, 0x30, 0x65, 0x65, 0x33, 0x35, 0x32, 0x33, 0x30, 0x63, 0x30, 0x36, 0x33, 0x32, 0x66, 0x64, 0x38, 0x64, 0x36, 0x32, 0x39, 0x37, 0x64, 0x62, 0x62, 0x30, 0x31, 0x36, 0x31, 0x63, 0x37, 0x30, 0x36, 0x30, 0x61, 0x39, 0x36, 0x30, 0x65, 0x39, 0x30, 0x32, 0x30, 0x62, 0x62, 0x36, 0x64, 0x62, 0x35, 0x63, 0x62, 0x38, 0x34, 0x36, 0x34, 0x38, 0x64, 0x65, 0x62, 0x37, 0x32, 0x39, 0x65, 0x31, 0x61, 0x64, 0x63, 0x36, 0x36, 0x38, 0x32, 0x36, 0x39, 0x64, 0x32, 0x30, 0x37, 0x32, 0x62, 0x34, 0x38, 0x39, 0x63, 0x37, 0x34, 0x63, 0x33, 0x38, 0x65, 0x61, 0x62, 0x31, 0x61, 0x39, 0x39, 0x35, 0x38, 0x31, 0x63, 0x38, 0x31, 0x65, 0x63, 0x66, 0x39, 0x32, 0x30, 0x34, 0x33, 0x32, 0x64, 0x66, 0x63, 0x66, 0x34, 0x66, 0x66, 0x63, 0x34, 0x35, 0x33, 0x66, 0x39, 0x65, 0x62, 0x31, 0x66, 0x30, 0x32, 0x34, 0x62, 0x30, 0x33, 0x36, 0x33, 0x33, 0x65, 0x62, 0x33, 0x36, 0x37, 0x32, 0x30, 0x36, 0x36, 0x61, 0x37, 0x64, 0x35, 0x31, 0x66, 0x36, 0x61, 0x64, 0x64, 0x31, 0x36, 0x64, 0x35, 0x38, 0x63, 0x63, 0x30, 0x39, 0x36, 0x35, 0x31, 0x37, 0x66, 0x39, 0x31, 0x64, 0x66, 0x32, 0x61, 0x31, 0x61, 0x32, 0x34, 0x65, 0x30, 0x62, 0x36, 0x61, 0x39, 0x64, 0x32, 0x64, 0x39, 0x65, 0x35, 0x35, 0x36, 0x66, 0x66, 0x32, 0x38, 0x39, 0x38, 0x66, 0x39, 0x33, 0x33, 0x30, 0x37, 0x32, 0x37, 0x35, 0x61, 0x35, 0x39, 0x62, 0x36, 0x64, 0x36, 0x39, 0x32, 0x61, 0x62, 0x37, 0x62, 0x31, 0x61, 0x32, 0x64, 0x38, 0x35, 0x65, 0x61, 0x66, 0x62, 0x65, 0x30, 0x39, 0x39, 0x64, 0x64, 0x35, 0x65, 0x63, 0x33, 0x64, 0x65, 0x64, 0x66, 0x61, 0x36, 0x39, 0x38, 0x38, 0x30, 0x62, 0x35, 0x64, 0x66, 0x65, 0x65, 0x66, 0x31, 0x35, 0x37, 0x30, 0x37, 0x39, 0x37, 0x37, 0x30, 0x64, 0x33, 0x32, 0x66, 0x64, 0x30, 0x31, 0x63, 0x36, 0x64, 0x38, 0x30, 0x38, 0x64, 0x30, 0x35, 0x37, 0x32, 0x62, 0x30, 0x64, 0x65, 0x65, 0x63, 0x31, 0x61, 0x61, 0x39, 0x61, 0x65, 0x62, 0x37, 0x35, 0x30, 0x33, 0x63, 0x32, 0x30, 0x30, 0x31, 0x34, 0x64, 0x30, 0x64, 0x33, 0x63, 0x37, 0x39, 0x34, 0x30, 0x66, 0x32, 0x32, 0x62, 0x33, 0x64, 0x33, 0x62, 0x64, 0x30, 0x33, 0x62, 0x31, 0x30, 0x34, 0x37, 0x32, 0x38, 0x62, 0x65, 0x64, 0x64, 0x33, 0x32, 0x32, 0x36, 0x31, 0x64, 0x61, 0x64, 0x65, 0x37, 0x63, 0x34, 0x64, 0x35, 0x61, 0x33, 0x35, 0x38, 0x37, 0x39, 0x32, 0x33, 0x33, 0x64, 0x31, 0x63, 0x62, 0x37, 0x39, 0x61, 0x61, 0x37, 0x32, 0x39, 0x63, 0x66, 0x33, 0x33, 0x66, 0x32, 0x34, 0x64, 0x65, 0x61, 0x61, 0x63, 0x36, 0x35, 0x32, 0x37, 0x33, 0x36, 0x33, 0x35, 0x34, 0x35, 0x34, 0x37, 0x32, 0x34, 0x34, 0x62, 0x66, 0x62, 0x33, 0x35, 0x30, 0x34, 0x66, 0x39, 0x39, 0x38, 0x36, 0x65, 0x63, 0x62, 0x38, 0x30, 0x39, 0x38, 0x31, 0x31, 0x65, 0x34, 0x36, 0x38, 0x37, 0x65, 0x37, 0x35, 0x64, 0x31, 0x38, 0x34, 0x61, 0x62, 0x63, 0x32, 0x37, 0x34, 0x30, 0x31, 0x62, 0x61, 0x36, 0x30, 0x65, 0x64, 0x30, 0x32, 0x30, 0x36, 0x32, 0x34, 0x39, 0x63, 0x39, 0x30, 0x61, 0x30, 0x37, 0x37, 0x32, 0x64, 0x36, 0x31, 0x62, 0x38, 0x61, 0x62, 0x38, 0x34, 0x37, 0x61, 0x33, 0x65, 0x30, 0x30, 0x61, 0x34, 0x30, 0x38, 0x63, 0x61, 0x35, 0x36, 0x64, 0x64, 0x64, 0x64, 0x33, 0x30, 0x30, 0x34, 0x63, 0x37, 0x63, 0x63, 0x66, 0x64, 0x66, 0x61, 0x35, 0x38, 0x61, 0x33, 0x30, 0x37, 0x31, 0x30, 0x37, 0x66, 0x66, 0x63, 0x35, 0x35, 0x31, 0x63, 0x36, 0x63, 0x61, 0x63, 0x63, 0x34, 0x39, 0x37, 0x32, 0x34, 0x33, 0x32, 0x34, 0x64, 0x30, 0x38, 0x37, 0x37, 0x32, 0x39, 0x30, 0x37, 0x36, 0x65, 0x32, 0x64, 0x64, 0x38, 0x39, 0x35, 0x33, 0x65, 0x39, 0x35, 0x61, 0x64, 0x65, 0x66, 0x61, 0x39, 0x36, 0x66, 0x61, 0x34, 0x66, 0x36, 0x36, 0x39, 0x36, 0x32, 0x38, 0x63, 0x31, 0x33, 0x32, 0x38, 0x39, 0x37, 0x66, 0x66, 0x62, 0x30, 0x34, 0x32, 0x32, 0x36, 0x36, 0x36, 0x63, 0x38, 0x62, 0x30, 0x30, 0x38, 0x66, 0x64, 0x39, 0x36, 0x30, 0x36, 0x63, 0x66, 0x65, 0x32, 0x63, 0x37, 0x62, 0x65, 0x39, 0x36, 0x63, 0x32, 0x63, 0x31, 0x37, 0x66, 0x62, 0x39, 0x61, 0x32, 0x63, 0x62, 0x34, 0x62, 0x62, 0x33, 0x33, 0x38, 0x63, 0x36, 0x63, 0x34, 0x38, 0x38, 0x63, 0x62, 0x65, 0x30, 0x61, 0x36, 0x36, 0x30, 0x64, 0x39, 0x31, 0x62, 0x62, 0x36, 0x34, 0x35, 0x38, 0x61, 0x35, 0x36, 0x66, 0x37, 0x32, 0x61, 0x66, 0x38, 0x64, 0x32, 0x32, 0x39, 0x66, 0x64, 0x32, 0x34, 0x36, 0x62, 0x66, 0x37, 0x61, 0x37, 0x36, 0x36, 0x62, 0x34, 0x36, 0x66, 0x36, 0x32, 0x63, 0x39, 0x33, 0x63, 0x32, 0x34, 0x36, 0x61, 0x66, 0x66, 0x38, 0x65, 0x65, 0x63, 0x39, 0x61, 0x37, 0x63, 0x32, 0x39, 0x30, 0x64, 0x36, 0x66, 0x33, 0x38, 0x61, 0x38, 0x66, 0x62, 0x33, 0x66, 0x62, 0x39, 0x63, 0x36, 0x66, 0x33, 0x36, 0x32, 0x61, 0x39, 0x64, 0x30, 0x37, 0x63, 0x63, 0x35, 0x65, 0x38, 0x62, 0x33, 0x66, 0x39, 0x36, 0x33, 0x32, 0x32, 0x33, 0x35, 0x62, 0x38, 0x64, 0x64, 0x61, 0x37, 0x30, 0x61, 0x34, 0x32, 0x64, 0x31, 0x35, 0x65, 0x66, 0x39, 0x37, 0x38, 0x31, 0x37, 0x31, 0x39, 0x37, 0x65, 0x33, 0x33, 0x63, 0x33, 0x61, 0x35, 0x64, 0x34, 0x33, 0x34, 0x37, 0x36, 0x37, 0x65, 0x34, 0x39, 0x61, 0x36, 0x33, 0x64, 0x39, 0x37, 0x37, 0x37, 0x38, 0x65, 0x37, 0x37, 0x63, 0x62, 0x31, 0x32, 0x64, 0x33, 0x63, 0x38, 0x66, 0x63, 0x36, 0x36, 0x35, 0x33, 0x39, 0x33, 0x33, 0x37, 0x39, 0x39, 0x61, 0x38, 0x36, 0x34, 0x65, 0x66, 0x34, 0x31, 0x39, 0x39, 0x31, 0x62, 0x38, 0x33, 0x66, 0x36, 0x66, 0x36, 0x63, 0x63, 0x61, 0x32, 0x39, 0x39, 0x62, 0x33, 0x62, 0x61, 0x30, 0x65, 0x38, 0x32, 0x61, 0x35, 0x66, 0x33, 0x38, 0x37, 0x30, 0x36, 0x37, 0x33, 0x61, 0x66, 0x65, 0x63, 0x37, 0x38, 0x30, 0x35, 0x35, 0x39, 0x61, 0x65, 0x36, 0x37, 0x35, 0x63, 0x33, 0x37, 0x65, 0x39, 0x30, 0x36, 0x64, 0x38, 0x66, 0x32, 0x32, 0x63, 0x34, 0x37, 0x65, 0x37, 0x31, 0x35, 0x65, 0x39, 0x37, 0x36, 0x32, 0x35, 0x65, 0x38, 0x37, 0x33, 0x38, 0x62, 0x66, 0x66, 0x66, 0x35, 0x31, 0x31, 0x65, 0x33, 0x32, 0x37, 0x32, 0x32, 0x63, 0x38, 0x64, 0x31, 0x30, 0x38, 0x65, 0x63, 0x62, 0x61, 0x63, 0x32, 0x66, 0x64, 0x35, 0x30, 0x33, 0x33, 0x37, 0x38, 0x30, 0x64, 0x32, 0x64, 0x64, 0x66, 0x34, 0x35, 0x30, 0x63, 0x66, 0x32, 0x34, 0x31, 0x38, 0x66, 0x33, 0x33, 0x39, 0x30, 0x35, 0x65, 0x31, 0x30, 0x63, 0x30, 0x33, 0x63, 0x63, 0x61, 0x61, 0x34, 0x33, 0x32, 0x61, 0x30, 0x63, 0x31, 0x66, 0x39, 0x61, 0x37, 0x32, 0x38, 0x66, 0x30, 0x34, 0x65, 0x65, 0x32, 0x30, 0x34, 0x65, 0x65, 0x31, 0x64, 0x38, 0x30, 0x32, 0x63, 0x37, 0x36, 0x64, 0x62, 0x66, 0x30, 0x65, 0x36, 0x34, 0x63, 0x30, 0x31, 0x36, 0x35, 0x37, 0x32, 0x64, 0x62, 0x33, 0x36, 0x62, 0x32, 0x64, 0x37, 0x37, 0x39, 0x33, 0x35, 0x37, 0x30, 0x32, 0x62, 0x38, 0x66, 0x62, 0x63, 0x32, 0x61, 0x35, 0x39, 0x38, 0x39, 0x64, 0x63, 0x35, 0x37, 0x32, 0x33, 0x64, 0x33, 0x65, 0x35, 0x37, 0x36, 0x66, 0x34, 0x33, 0x32, 0x61, 0x36, 0x34, 0x31, 0x65, 0x61, 0x37, 0x33, 0x33, 0x63, 0x35, 0x64, 0x66, 0x62, 0x30, 0x66, 0x35, 0x32, 0x32, 0x36, 0x36, 0x63, 0x66, 0x33, 0x31, 0x38, 0x64, 0x65, 0x32, 0x66, 0x35, 0x32, 0x66, 0x34, 0x35, 0x61, 0x37, 0x39, 0x64, 0x32, 0x33, 0x32, 0x37, 0x38, 0x31, 0x31, 0x39, 0x30, 0x34, 0x31, 0x63, 0x37, 0x32, 0x32, 0x65, 0x35, 0x64, 0x32, 0x63, 0x61, 0x30, 0x63, 0x30, 0x66, 0x31, 0x37, 0x63, 0x39, 0x31, 0x35, 0x62, 0x62, 0x65, 0x37, 0x62, 0x65, 0x62, 0x64, 0x36, 0x39, 0x31, 0x61, 0x37, 0x32, 0x30, 0x32, 0x66, 0x61, 0x35, 0x63, 0x64, 0x64, 0x35, 0x61, 0x61, 0x31, 0x61, 0x39, 0x62, 0x35, 0x61, 0x65, 0x38, 0x32, 0x63, 0x62, 0x65, 0x61, 0x37, 0x32, 0x35, 0x31, 0x33, 0x62, 0x61, 0x37, 0x32, 0x64, 0x35, 0x30, 0x36, 0x36, 0x39, 0x66, 0x33, 0x66, 0x32, 0x61, 0x34, 0x38, 0x33, 0x30, 0x65, 0x64, 0x61, 0x62, 0x39, 0x37, 0x36, 0x38, 0x61, 0x61, 0x66, 0x37, 0x33, 0x30, 0x32, 0x65, 0x35, 0x38, 0x38, 0x35, 0x39, 0x39, 0x39, 0x64, 0x65, 0x37, 0x31, 0x35, 0x33, 0x36, 0x35, 0x36, 0x63, 0x62, 0x62, 0x63, 0x62, 0x65, 0x36, 0x34, 0x36, 0x33, 0x65, 0x35, 0x31, 0x38, 0x61, 0x37, 0x32, 0x65, 0x33, 0x64, 0x36, 0x39, 0x31, 0x37, 0x34, 0x66, 0x31, 0x35, 0x34, 0x37, 0x38, 0x65, 0x61, 0x36, 0x64, 0x38, 0x30, 0x62, 0x30, 0x31, 0x61, 0x33, 0x62, 0x66, 0x36, 0x33, 0x36, 0x66, 0x62, 0x34, 0x38, 0x64, 0x66, 0x38, 0x65, 0x30, 0x36, 0x65, 0x64, 0x64, 0x61, 0x39, 0x63, 0x62, 0x63, 0x65, 0x30, 0x35, 0x65, 0x62, 0x61, 0x64, 0x30, 0x34, 0x36, 0x34, 0x66, 0x65, 0x63, 0x37, 0x30, 0x64, 0x61, 0x65, 0x39, 0x30, 0x64, 0x37, 0x35, 0x32, 0x32, 0x36, 0x66, 0x34, 0x35, 0x35, 0x38, 0x39, 0x35, 0x39, 0x61, 0x63, 0x34, 0x33, 0x62, 0x64, 0x39, 0x37, 0x32, 0x35, 0x32, 0x33, 0x32, 0x32, 0x33, 0x38, 0x61, 0x39, 0x31, 0x32, 0x39, 0x65, 0x61, 0x63, 0x34, 0x38, 0x31, 0x65, 0x66, 0x61, 0x62, 0x64, 0x61, 0x64, 0x61, 0x33, 0x32, 0x64, 0x37, 0x65, 0x35, 0x62, 0x37, 0x37, 0x32, 0x38, 0x30, 0x64, 0x65, 0x62, 0x61, 0x61, 0x36, 0x61, 0x63, 0x30, 0x33, 0x34, 0x34, 0x34, 0x66, 0x65, 0x64, 0x66, 0x38, 0x33, 0x30, 0x62, 0x63, 0x32, 0x37, 0x66, 0x31, 0x30, 0x33, 0x64, 0x38, 0x61, 0x34, 0x61, 0x34, 0x31, 0x33, 0x33, 0x64, 0x33, 0x38, 0x31, 0x39, 0x39, 0x39, 0x64, 0x33, 0x34, 0x31, 0x64, 0x35, 0x61, 0x63, 0x64, 0x61, 0x64, 0x34, 0x65, 0x35, 0x65, 0x63, 0x30, 0x62, 0x65, 0x39, 0x32, 0x32, 0x66, 0x32, 0x62, 0x37, 0x35, 0x36, 0x32, 0x64, 0x31, 0x64, 0x63, 0x33, 0x35, 0x32, 0x34, 0x64, 0x62, 0x30, 0x32, 0x61, 0x36, 0x38, 0x39, 0x65, 0x64, 0x30, 0x63, 0x65, 0x32, 0x63, 0x31, 0x35, 0x61, 0x61, 0x37, 0x30, 0x31, 0x61, 0x31, 0x33, 0x33, 0x37, 0x31, 0x34, 0x34, 0x65, 0x66, 0x66, 0x37, 0x30, 0x33, 0x30, 0x34, 0x64, 0x62, 0x38, 0x32, 0x34, 0x32, 0x30, 0x30, 0x30, 0x35, 0x34, 0x37, 0x37, 0x62, 0x30, 0x62, 0x31, 0x66, 0x63, 0x36, 0x30, 0x34, 0x31, 0x66, 0x34, 0x65, 0x65, 0x35, 0x33, 0x34, 0x65, 0x37, 0x35, 0x61, 0x37, 0x38, 0x36, 0x34, 0x34, 0x36, 0x61, 0x65, 0x65, 0x63, 0x61, 0x32, 0x66, 0x66, 0x38, 0x65, 0x61, 0x30, 0x30, 0x65, 0x66, 0x62, 0x33, 0x63, 0x37, 0x61, 0x30, 0x63, 0x38, 0x37, 0x39, 0x37, 0x35, 0x36, 0x66, 0x37, 0x32, 0x62, 0x33, 0x35, 0x31, 0x61, 0x66, 0x37, 0x66, 0x65, 0x32, 0x34, 0x35, 0x31, 0x36, 0x38, 0x39, 0x33, 0x61, 0x32, 0x66, 0x32, 0x64, 0x34, 0x36, 0x37, 0x65, 0x33, 0x66, 0x31, 0x64, 0x61, 0x34, 0x34, 0x30, 0x30, 0x32, 0x66, 0x63, 0x65, 0x33, 0x34, 0x30, 0x30, 0x35, 0x30, 0x37, 0x38, 0x36, 0x65, 0x34, 0x38, 0x61, 0x39, 0x38, 0x34, 0x61, 0x33, 0x30, 0x36, 0x61, 0x61, 0x31, 0x37, 0x30, 0x31, 0x37, 0x35, 0x36, 0x39, 0x64, 0x37, 0x32, 0x38, 0x30, 0x62, 0x39, 0x39, 0x66, 0x31, 0x39, 0x33, 0x36, 0x61, 0x32, 0x34, 0x65, 0x36, 0x64, 0x66, 0x37, 0x39, 0x65, 0x33, 0x35, 0x32, 0x33, 0x32, 0x38, 0x61, 0x32, 0x31, 0x33, 0x62, 0x64, 0x32, 0x61, 0x61, 0x31, 0x31, 0x39, 0x39, 0x33, 0x62, 0x37, 0x36, 0x39, 0x62, 0x32, 0x38, 0x32, 0x62, 0x34, 0x61, 0x65, 0x33, 0x31, 0x36, 0x31, 0x61, 0x61, 0x62, 0x39, 0x32, 0x64, 0x65, 0x32, 0x61, 0x38, 0x30, 0x37, 0x61, 0x30, 0x65, 0x61, 0x38, 0x62, 0x31, 0x62, 0x30, 0x64, 0x61, 0x37, 0x63, 0x32, 0x31, 0x38, 0x64, 0x64, 0x32, 0x35, 0x64, 0x38, 0x63, 0x31, 0x35, 0x35, 0x63, 0x63, 0x62, 0x33, 0x66, 0x35, 0x62, 0x32, 0x34, 0x30, 0x64, 0x62, 0x30, 0x62, 0x38, 0x38, 0x31, 0x66, 0x36, 0x33, 0x34, 0x38, 0x37, 0x62, 0x31, 0x61, 0x33, 0x37, 0x32, 0x65, 0x35, 0x62, 0x32, 0x34, 0x65, 0x31, 0x31, 0x61, 0x35, 0x33, 0x36, 0x62, 0x38, 0x66, 0x33, 0x62, 0x30, 0x34, 0x66, 0x62, 0x37, 0x39, 0x30, 0x36, 0x65, 0x39, 0x39, 0x35, 0x35, 0x61, 0x63, 0x32, 0x32, 0x35, 0x35, 0x37, 0x61, 0x32, 0x33, 0x64, 0x62, 0x38, 0x31, 0x38, 0x38, 0x30, 0x65, 0x36, 0x37, 0x66, 0x30, 0x31, 0x38, 0x63, 0x65, 0x32, 0x63, 0x64, 0x37, 0x32, 0x31, 0x36, 0x62, 0x39, 0x64, 0x30, 0x37, 0x33, 0x33, 0x64, 0x32, 0x66, 0x66, 0x30, 0x31, 0x64, 0x39, 0x63, 0x31, 0x36, 0x63, 0x34, 0x35, 0x36, 0x37, 0x62, 0x62, 0x61, 0x35, 0x61, 0x66, 0x66, 0x61, 0x66, 0x38, 0x30, 0x32, 0x34, 0x36, 0x36, 0x30, 0x34, 0x36, 0x39, 0x34, 0x35, 0x30, 0x66, 0x66, 0x62, 0x62, 0x35, 0x38, 0x39, 0x37, 0x37, 0x61, 0x30, 0x31, 0x64, 0x30, 0x61, 0x37, 0x32, 0x63, 0x31, 0x39, 0x31, 0x66, 0x34, 0x62, 0x36, 0x39, 0x66, 0x65, 0x36, 0x31, 0x35, 0x37, 0x39, 0x34, 0x63, 0x34, 0x38, 0x32, 0x62, 0x36, 0x38, 0x63, 0x32, 0x39, 0x36, 0x38, 0x62, 0x63, 0x65, 0x64, 0x66, 0x36, 0x38, 0x63, 0x31, 0x37, 0x62, 0x36, 0x37, 0x64, 0x64, 0x38, 0x65, 0x66, 0x37, 0x64, 0x37, 0x35, 0x34, 0x35, 0x38, 0x32, 0x64, 0x38, 0x35, 0x66, 0x64, 0x30, 0x35, 0x37, 0x32, 0x33, 0x62, 0x38, 0x38, 0x39, 0x34, 0x61, 0x32, 0x31, 0x65, 0x63, 0x36, 0x61, 0x65, 0x32, 0x32, 0x33, 0x61, 0x65, 0x39, 0x34, 0x31, 0x39, 0x33, 0x33, 0x35, 0x61, 0x32, 0x37, 0x65, 0x30, 0x63, 0x39, 0x62, 0x63, 0x30, 0x37, 0x32, 0x38, 0x61, 0x35, 0x31, 0x35, 0x37, 0x64, 0x64, 0x61, 0x30, 0x38, 0x62, 0x37, 0x64, 0x66, 0x39, 0x39, 0x36, 0x64, 0x63, 0x66, 0x37, 0x63, 0x63, 0x34, 0x37, 0x34, 0x31, 0x31, 0x37, 0x64, 0x35, 0x32, 0x63, 0x32, 0x66, 0x62, 0x34, 0x64, 0x36, 0x62, 0x39, 0x34, 0x31, 0x38, 0x37, 0x61, 0x38, 0x39, 0x32, 0x37, 0x36, 0x35, 0x62, 0x61, 0x63, 0x38, 0x37, 0x63, 0x63, 0x32, 0x30, 0x66, 0x30, 0x39, 0x36, 0x61, 0x61, 0x66, 0x31, 0x64, 0x64, 0x38, 0x38, 0x61, 0x31, 0x37, 0x65, 0x64, 0x35, 0x62, 0x39, 0x63, 0x36, 0x30, 0x33, 0x30, 0x61, 0x37, 0x32, 0x39, 0x38, 0x31, 0x39, 0x65, 0x38, 0x39, 0x63, 0x36, 0x32, 0x36, 0x33, 0x66, 0x62, 0x38, 0x39, 0x63, 0x34, 0x62, 0x39, 0x32, 0x39, 0x33, 0x38, 0x34, 0x61, 0x30, 0x61, 0x32, 0x63, 0x32, 0x34, 0x34, 0x32, 0x36, 0x33, 0x65, 0x38, 0x34, 0x36, 0x61, 0x34, 0x32, 0x31, 0x62, 0x65, 0x38, 0x35, 0x39, 0x65, 0x66, 0x33, 0x38, 0x63, 0x61, 0x66, 0x30, 0x33, 0x38, 0x36, 0x37, 0x31, 0x37, 0x32, 0x64, 0x31, 0x34, 0x61, 0x37, 0x64, 0x64, 0x62, 0x66, 0x31, 0x33, 0x31, 0x34, 0x61, 0x65, 0x30, 0x34, 0x34, 0x38, 0x31, 0x31, 0x39, 0x61, 0x63, 0x30, 0x30, 0x66, 0x33, 0x61, 0x35, 0x33, 0x34, 0x37, 0x31, 0x39, 0x65, 0x64, 0x38, 0x32, 0x65, 0x61, 0x38, 0x35, 0x66, 0x64, 0x33, 0x39, 0x33, 0x34, 0x39, 0x34, 0x63, 0x31, 0x61, 0x39, 0x61, 0x35, 0x35, 0x33, 0x34, 0x38, 0x62, 0x37, 0x32, 0x61, 0x36, 0x62, 0x35, 0x32, 0x32, 0x36, 0x62, 0x61, 0x61, 0x31, 0x65, 0x36, 0x35, 0x34, 0x63, 0x64, 0x32, 0x31, 0x32, 0x30, 0x38, 0x30, 0x31, 0x62, 0x36, 0x35, 0x64, 0x34, 0x65, 0x37, 0x62, 0x61, 0x62, 0x31, 0x32, 0x39, 0x33, 0x32, 0x63, 0x39, 0x35, 0x36, 0x35, 0x38, 0x66, 0x61, 0x65, 0x64, 0x62, 0x33, 0x30, 0x38, 0x38, 0x30, 0x62, 0x62, 0x63, 0x64, 0x65, 0x34, 0x33, 0x37, 0x32, 0x39, 0x32, 0x35, 0x35, 0x37, 0x61, 0x35, 0x34, 0x33, 0x39, 0x33, 0x33, 0x66, 0x64, 0x38, 0x32, 0x30, 0x62, 0x33, 0x37, 0x37, 0x36, 0x65, 0x34, 0x35, 0x31, 0x65, 0x33, 0x38, 0x32, 0x61, 0x61, 0x31, 0x35, 0x38, 0x39, 0x37, 0x30, 0x64, 0x66, 0x63, 0x33, 0x35, 0x63, 0x37, 0x39, 0x30, 0x34, 0x36, 0x39, 0x38, 0x34, 0x32, 0x39, 0x36, 0x34, 0x31, 0x31, 0x66, 0x32, 0x31, 0x33, 0x37, 0x32, 0x66, 0x65, 0x61, 0x35, 0x30, 0x38, 0x61, 0x37, 0x34, 0x35, 0x35, 0x31, 0x36, 0x66, 0x30, 0x32, 0x63, 0x30, 0x65, 0x62, 0x61, 0x66, 0x33, 0x31, 0x32, 0x36, 0x33, 0x30, 0x30, 0x33, 0x37, 0x33, 0x39, 0x64, 0x63, 0x36, 0x35, 0x36, 0x65, 0x62, 0x37, 0x64, 0x62, 0x63, 0x32, 0x31, 0x39, 0x37, 0x30, 0x32, 0x36, 0x34, 0x65, 0x30, 0x62, 0x36, 0x34, 0x62, 0x34, 0x39, 0x65, 0x35, 0x33, 0x63, 0x61, 0x31, 0x39, 0x61, 0x38, 0x35, 0x38, 0x38, 0x35, 0x31, 0x32, 0x35, 0x62, 0x65, 0x32, 0x39, 0x36, 0x39, 0x66, 0x33, 0x39, 0x64, 0x34, 0x38, 0x34, 0x36, 0x33, 0x31, 0x39, 0x33, 0x36, 0x66, 0x36, 0x31, 0x36, 0x64, 0x33, 0x36, 0x61, 0x30, 0x30, 0x32, 0x65, 0x31, 0x30, 0x35, 0x34, 0x31, 0x34, 0x35, 0x36, 0x37, 0x36, 0x65, 0x35, 0x61, 0x35, 0x33, 0x32, 0x33, 0x37, 0x61, 0x37, 0x32, 0x34, 0x63, 0x32, 0x62, 0x30, 0x37, 0x34, 0x65, 0x38, 0x37, 0x65, 0x62, 0x65, 0x62, 0x63, 0x65, 0x61, 0x65, 0x62, 0x34, 0x66, 0x38, 0x36, 0x34, 0x65, 0x35, 0x39, 0x35, 0x64, 0x39, 0x65, 0x61, 0x34, 0x66, 0x65, 0x62, 0x31, 0x31, 0x39, 0x65, 0x39, 0x66, 0x39, 0x32, 0x66, 0x31, 0x35, 0x64, 0x36, 0x39, 0x66, 0x65, 0x32, 0x37, 0x66, 0x64, 0x30, 0x35, 0x64, 0x33, 0x38, 0x62, 0x37, 0x32, 0x65, 0x35, 0x36, 0x37, 0x35, 0x35, 0x32, 0x63, 0x63, 0x62, 0x63, 0x63, 0x62, 0x31, 0x33, 0x33, 0x34, 0x63, 0x63, 0x31, 0x37, 0x61, 0x66, 0x63, 0x38, 0x66, 0x63, 0x62, 0x37, 0x32, 0x38, 0x39, 0x61, 0x63, 0x64, 0x35, 0x62, 0x37, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x39, 0x64, 0x66, 0x30, 0x30, 0x32, 0x63, 0x35, 0x37, 0x38, 0x38, 0x37, 0x35, 0x37, 0x61, 0x63, 0x61, 0x62, 0x37, 0x32, 0x38, 0x64, 0x64, 0x61, 0x64, 0x37, 0x31, 0x36, 0x63, 0x32, 0x39, 0x39, 0x62, 0x65, 0x63, 0x63, 0x33, 0x63, 0x30, 0x63, 0x32, 0x66, 0x63, 0x31, 0x34, 0x62, 0x62, 0x34, 0x34, 0x37, 0x30, 0x36, 0x32, 0x31, 0x31, 0x36, 0x37, 0x35, 0x33, 0x38, 0x32, 0x62, 0x32, 0x32, 0x66, 0x35, 0x39, 0x63, 0x66, 0x37, 0x39, 0x66, 0x35, 0x66, 0x61, 0x62, 0x32, 0x62, 0x39, 0x30, 0x63, 0x37, 0x31, 0x65, 0x66, 0x61, 0x36, 0x61, 0x65, 0x36, 0x61, 0x34, 0x32, 0x39, 0x62, 0x63, 0x34, 0x39, 0x36, 0x64, 0x62, 0x62, 0x64, 0x39, 0x35, 0x32, 0x64, 0x33, 0x63, 0x33, 0x36, 0x66, 0x31, 0x65, 0x35, 0x32, 0x37, 0x35, 0x31, 0x64, 0x38, 0x37, 0x63, 0x34, 0x34, 0x35, 0x64, 0x39, 0x64, 0x33, 0x65, 0x39, 0x66, 0x61, 0x32, 0x30, 0x65, 0x61, 0x62, 0x30, 0x39, 0x34, 0x63, 0x37, 0x38, 0x32, 0x30, 0x33, 0x32, 0x38, 0x31, 0x64, 0x32, 0x35, 0x63, 0x38, 0x38, 0x32, 0x31, 0x30, 0x63, 0x31, 0x31, 0x36, 0x61, 0x61, 0x63, 0x63, 0x37, 0x30, 0x64, 0x30, 0x62, 0x63, 0x63, 0x66, 0x66, 0x65, 0x38, 0x39, 0x63, 0x33, 0x31, 0x30, 0x31, 0x30, 0x62, 0x37, 0x62, 0x35, 0x32, 0x30, 0x33, 0x33, 0x36, 0x39, 0x34, 0x37, 0x38, 0x38, 0x62, 0x35, 0x64, 0x34, 0x65, 0x32, 0x61, 0x36, 0x38, 0x32, 0x37, 0x32, 0x61, 0x36, 0x66, 0x66, 0x38, 0x36, 0x38, 0x38, 0x64, 0x39, 0x62, 0x37, 0x65, 0x62, 0x63, 0x31, 0x35, 0x37, 0x37, 0x30, 0x31, 0x65, 0x38, 0x36, 0x37, 0x65, 0x33, 0x37, 0x64, 0x35, 0x38, 0x65, 0x35, 0x65, 0x30, 0x33, 0x35, 0x62, 0x64, 0x39, 0x61, 0x39, 0x38, 0x30, 0x37, 0x62, 0x37, 0x63, 0x62, 0x30, 0x37, 0x66, 0x66, 0x65, 0x31, 0x33, 0x61, 0x34, 0x64, 0x64, 0x38, 0x61, 0x31, 0x38, 0x61, 0x63, 0x34, 0x62, 0x34, 0x64, 0x64, 0x62, 0x38, 0x33, 0x31, 0x39, 0x39, 0x35, 0x61, 0x32, 0x35, 0x32, 0x31, 0x39, 0x65, 0x30, 0x31, 0x34, 0x38, 0x66, 0x63, 0x61, 0x63, 0x31, 0x34, 0x31, 0x37, 0x38, 0x63, 0x31, 0x63, 0x63, 0x31, 0x34, 0x36, 0x63, 0x31, 0x37, 0x30, 0x34, 0x30, 0x65, 0x37, 0x34, 0x61, 0x31, 0x39, 0x61, 0x38, 0x33, 0x36, 0x63, 0x32, 0x32, 0x64, 0x34, 0x37, 0x32, 0x62, 0x36, 0x35, 0x61, 0x36, 0x34, 0x34, 0x35, 0x39, 0x61, 0x62, 0x32, 0x30, 0x37, 0x34, 0x37, 0x65, 0x36, 0x62, 0x62, 0x36, 0x36, 0x32, 0x33, 0x30, 0x38, 0x33, 0x66, 0x30, 0x63, 0x61, 0x33, 0x62, 0x64, 0x66, 0x61, 0x64, 0x62, 0x33, 0x63, 0x63, 0x61, 0x38, 0x65, 0x31, 0x35, 0x39, 0x37, 0x61, 0x66, 0x33, 0x32, 0x31, 0x34, 0x37, 0x34, 0x63, 0x30, 0x35, 0x32, 0x36, 0x64, 0x36, 0x63, 0x62, 0x64, 0x31, 0x65, 0x37, 0x66, 0x33, 0x61, 0x33, 0x38, 0x32, 0x34, 0x35, 0x31, 0x36, 0x66, 0x65, 0x64, 0x31, 0x64, 0x65, 0x31, 0x38, 0x64, 0x63, 0x64, 0x30, 0x66, 0x38, 0x64, 0x66, 0x65, 0x39, 0x33, 0x39, 0x61, 0x32, 0x39, 0x34, 0x30, 0x32, 0x65, 0x38, 0x66, 0x38, 0x62, 0x34, 0x32, 0x62, 0x65, 0x62, 0x63, 0x32, 0x31, 0x38, 0x66, 0x61, 0x35, 0x38, 0x61, 0x33, 0x31, 0x37, 0x32, 0x61, 0x61, 0x37, 0x33, 0x65, 0x32, 0x32, 0x39, 0x64, 0x63, 0x32, 0x30, 0x65, 0x37, 0x33, 0x38, 0x37, 0x38, 0x65, 0x31, 0x61, 0x61, 0x62, 0x65, 0x34, 0x37, 0x66, 0x30, 0x65, 0x30, 0x66, 0x30, 0x37, 0x63, 0x61, 0x61, 0x30, 0x30, 0x62, 0x32, 0x32, 0x65, 0x62, 0x38, 0x33, 0x61, 0x38, 0x33, 0x34, 0x62, 0x35, 0x33, 0x63, 0x35, 0x30, 0x35, 0x66, 0x37, 0x65, 0x66, 0x32, 0x62, 0x37, 0x32, 0x62, 0x35, 0x33, 0x39, 0x61, 0x62, 0x34, 0x34, 0x30, 0x61, 0x35, 0x38, 0x37, 0x65, 0x63, 0x63, 0x39, 0x35, 0x63, 0x63, 0x37, 0x64, 0x38, 0x64, 0x35, 0x36, 0x63, 0x64, 0x30, 0x30, 0x33, 0x38, 0x34, 0x33, 0x36, 0x31, 0x34, 0x64, 0x64, 0x62, 0x34, 0x31, 0x61, 0x62, 0x62, 0x35, 0x34, 0x62, 0x63, 0x39, 0x36, 0x30, 0x38, 0x62, 0x63, 0x66, 0x31, 0x31, 0x65, 0x30, 0x39, 0x37, 0x32, 0x36, 0x63, 0x30, 0x39, 0x66, 0x37, 0x37, 0x66, 0x61, 0x64, 0x61, 0x61, 0x33, 0x37, 0x34, 0x31, 0x62, 0x30, 0x63, 0x65, 0x32, 0x31, 0x34, 0x61, 0x66, 0x30, 0x62, 0x64, 0x30, 0x39, 0x34, 0x63, 0x62, 0x65, 0x34, 0x63, 0x33, 0x64, 0x66, 0x35, 0x32, 0x34, 0x66, 0x64, 0x39, 0x36, 0x65, 0x64, 0x62, 0x37, 0x30, 0x37, 0x30, 0x32, 0x37, 0x39, 0x33, 0x64, 0x65, 0x63, 0x65, 0x62, 0x66, 0x33, 0x34, 0x31, 0x61, 0x37, 0x66, 0x32, 0x36, 0x61, 0x32, 0x65, 0x63, 0x66, 0x39, 0x35, 0x32, 0x30, 0x38, 0x37, 0x34, 0x64, 0x37, 0x37, 0x63, 0x37, 0x32, 0x37, 0x30, 0x61, 0x66, 0x64, 0x66, 0x30, 0x32, 0x37, 0x39, 0x31, 0x38, 0x30, 0x30, 0x39, 0x31, 0x36, 0x37, 0x39, 0x32, 0x37, 0x31, 0x33, 0x34, 0x37, 0x62, 0x30, 0x33, 0x31, 0x61, 0x35, 0x34, 0x63, 0x38, 0x39, 0x35, 0x33, 0x64, 0x31, 0x66, 0x36, 0x30, 0x65, 0x62, 0x34, 0x63, 0x64, 0x35, 0x39, 0x34, 0x63, 0x62, 0x64, 0x33, 0x37, 0x32, 0x39, 0x30, 0x30, 0x31, 0x66, 0x62, 0x30, 0x61, 0x38, 0x31, 0x61, 0x64, 0x31, 0x36, 0x61, 0x35, 0x63, 0x34, 0x37, 0x30, 0x32, 0x32, 0x37, 0x37, 0x35, 0x34, 0x33, 0x62, 0x32, 0x63, 0x36, 0x65, 0x34, 0x66, 0x39, 0x62, 0x33, 0x32, 0x66, 0x66, 0x35, 0x31, 0x32, 0x33, 0x66, 0x62, 0x30, 0x39, 0x64, 0x65, 0x39, 0x62, 0x31, 0x65, 0x65, 0x64, 0x61, 0x31, 0x66, 0x37, 0x39, 0x64, 0x63, 0x66, 0x64, 0x32, 0x61, 0x38, 0x33, 0x38, 0x62, 0x30, 0x35, 0x36, 0x38, 0x63, 0x39, 0x35, 0x36, 0x30, 0x35, 0x66, 0x62, 0x30, 0x36, 0x63, 0x64, 0x34, 0x33, 0x35, 0x32, 0x39, 0x30, 0x61, 0x32, 0x35, 0x38, 0x36, 0x31, 0x62, 0x31, 0x63, 0x36, 0x64, 0x34, 0x35, 0x38, 0x62, 0x65, 0x33, 0x34, 0x63, 0x64, 0x33, 0x31, 0x39, 0x64, 0x64, 0x35, 0x30, 0x38, 0x31, 0x37, 0x32, 0x65, 0x33, 0x66, 0x38, 0x33, 0x32, 0x31, 0x32, 0x66, 0x30, 0x32, 0x65, 0x36, 0x65, 0x38, 0x66, 0x63, 0x66, 0x36, 0x31, 0x65, 0x61, 0x61, 0x36, 0x36, 0x61, 0x30, 0x39, 0x61, 0x33, 0x32, 0x33, 0x39, 0x66, 0x63, 0x31, 0x33, 0x34, 0x30, 0x32, 0x38, 0x30, 0x32, 0x62, 0x31, 0x31, 0x30, 0x36, 0x34, 0x38, 0x37, 0x32, 0x35, 0x65, 0x39, 0x62, 0x37, 0x65, 0x36, 0x33, 0x62, 0x63, 0x63, 0x38, 0x38, 0x64, 0x34, 0x62, 0x63, 0x30, 0x65, 0x36, 0x66, 0x37, 0x30, 0x61, 0x66, 0x32, 0x38, 0x65, 0x63, 0x33, 0x63, 0x63, 0x32, 0x31, 0x62, 0x35, 0x34, 0x30, 0x66, 0x33, 0x65, 0x66, 0x62, 0x36, 0x34, 0x33, 0x37, 0x33, 0x38, 0x38, 0x66, 0x34, 0x62, 0x35, 0x39, 0x31, 0x36, 0x32, 0x62, 0x32, 0x61, 0x31, 0x37, 0x32, 0x38, 0x62, 0x65, 0x37, 0x65, 0x66, 0x39, 0x32, 0x37, 0x35, 0x32, 0x33, 0x37, 0x35, 0x36, 0x62, 0x35, 0x61, 0x37, 0x35, 0x35, 0x36, 0x62, 0x61, 0x32, 0x65, 0x35, 0x64, 0x30, 0x62, 0x30, 0x64, 0x38, 0x33, 0x61, 0x64, 0x61, 0x31, 0x31, 0x30, 0x63, 0x61, 0x63, 0x62, 0x32, 0x64, 0x36, 0x66, 0x61, 0x33, 0x65, 0x32, 0x37, 0x39, 0x32, 0x63, 0x35, 0x64, 0x61, 0x33, 0x37, 0x30, 0x37, 0x32, 0x66, 0x37, 0x37, 0x31, 0x35, 0x62, 0x38, 0x33, 0x62, 0x38, 0x30, 0x39, 0x39, 0x63, 0x66, 0x65, 0x35, 0x34, 0x31, 0x37, 0x34, 0x37, 0x34, 0x33, 0x61, 0x31, 0x37, 0x39, 0x38, 0x65, 0x66, 0x30, 0x33, 0x64, 0x38, 0x38, 0x31, 0x36, 0x33, 0x38, 0x37, 0x63, 0x63, 0x65, 0x63, 0x62, 0x63, 0x39, 0x36, 0x65, 0x64, 0x65, 0x62, 0x39, 0x36, 0x66, 0x35, 0x32, 0x62, 0x33, 0x32, 0x34, 0x37, 0x32, 0x33, 0x62, 0x37, 0x61, 0x37, 0x33, 0x31, 0x34, 0x37, 0x65, 0x37, 0x34, 0x33, 0x32, 0x32, 0x38, 0x62, 0x30, 0x32, 0x34, 0x30, 0x30, 0x63, 0x62, 0x30, 0x36, 0x39, 0x61, 0x32, 0x62, 0x38, 0x39, 0x62, 0x39, 0x61, 0x61, 0x65, 0x65, 0x61, 0x66, 0x37, 0x64, 0x37, 0x63, 0x31, 0x66, 0x66, 0x62, 0x39, 0x36, 0x37, 0x31, 0x37, 0x62, 0x32, 0x66, 0x35, 0x39, 0x39, 0x63, 0x63, 0x62, 0x37, 0x32, 0x39, 0x62, 0x38, 0x64, 0x66, 0x66, 0x66, 0x64, 0x31, 0x66, 0x64, 0x33, 0x33, 0x38, 0x36, 0x63, 0x34, 0x31, 0x37, 0x39, 0x65, 0x33, 0x61, 0x39, 0x30, 0x30, 0x31, 0x31, 0x38, 0x37, 0x34, 0x31, 0x30, 0x39, 0x62, 0x33, 0x31, 0x31, 0x30, 0x36, 0x61, 0x65, 0x34, 0x35, 0x35, 0x38, 0x37, 0x65, 0x33, 0x35, 0x38, 0x33, 0x39, 0x37, 0x37, 0x37, 0x37, 0x37, 0x36, 0x62, 0x30, 0x63, 0x37, 0x32, 0x36, 0x36, 0x65, 0x65, 0x37, 0x63, 0x38, 0x35, 0x36, 0x36, 0x35, 0x61, 0x64, 0x64, 0x62, 0x61, 0x65, 0x32, 0x31, 0x65, 0x38, 0x34, 0x38, 0x62, 0x34, 0x38, 0x34, 0x64, 0x63, 0x65, 0x37, 0x33, 0x34, 0x37, 0x32, 0x31, 0x62, 0x31, 0x32, 0x34, 0x66, 0x65, 0x39, 0x34, 0x63, 0x30, 0x31, 0x37, 0x38, 0x35, 0x64, 0x35, 0x62, 0x62, 0x63, 0x36, 0x31, 0x39, 0x63, 0x66, 0x36, 0x36, 0x37, 0x32, 0x65, 0x39, 0x34, 0x35, 0x61, 0x63, 0x35, 0x33, 0x30, 0x33, 0x64, 0x35, 0x35, 0x35, 0x38, 0x33, 0x36, 0x65, 0x31, 0x61, 0x62, 0x35, 0x39, 0x31, 0x31, 0x30, 0x64, 0x66, 0x37, 0x65, 0x61, 0x63, 0x34, 0x66, 0x35, 0x62, 0x37, 0x34, 0x65, 0x33, 0x64, 0x38, 0x30, 0x33, 0x35, 0x65, 0x64, 0x36, 0x30, 0x36, 0x38, 0x39, 0x30, 0x32, 0x62, 0x34, 0x61, 0x63, 0x37, 0x36, 0x65, 0x62, 0x37, 0x32, 0x66, 0x39, 0x64, 0x65, 0x65, 0x66, 0x35, 0x63, 0x32, 0x30, 0x31, 0x39, 0x33, 0x37, 0x65, 0x32, 0x30, 0x32, 0x63, 0x33, 0x63, 0x61, 0x34, 0x64, 0x63, 0x63, 0x35, 0x66, 0x36, 0x31, 0x39, 0x61, 0x36, 0x65, 0x39, 0x37, 0x64, 0x37, 0x65, 0x34, 0x63, 0x64, 0x37, 0x33, 0x36, 0x64, 0x62, 0x66, 0x61, 0x36, 0x62, 0x30, 0x32, 0x62, 0x32, 0x33, 0x37, 0x63, 0x33, 0x36, 0x35, 0x65, 0x30, 0x39, 0x62, 0x64, 0x37, 0x39, 0x62, 0x61, 0x30, 0x31, 0x66, 0x35, 0x61, 0x62, 0x64, 0x30, 0x34, 0x36, 0x63, 0x35, 0x32, 0x65, 0x64, 0x35, 0x61, 0x35, 0x64, 0x31, 0x33, 0x35, 0x35, 0x38, 0x32, 0x39, 0x35, 0x37, 0x62, 0x32, 0x64, 0x37, 0x64, 0x31, 0x30, 0x61, 0x35, 0x38, 0x39, 0x33, 0x35, 0x65, 0x39, 0x66, 0x30, 0x32, 0x65, 0x31, 0x32, 0x38, 0x61, 0x66, 0x66, 0x33, 0x30, 0x63, 0x30, 0x33, 0x35, 0x38, 0x30, 0x65, 0x61, 0x32, 0x33, 0x39, 0x36, 0x38, 0x32, 0x33, 0x32, 0x33, 0x65, 0x38, 0x39, 0x37, 0x66, 0x64, 0x33, 0x32, 0x30, 0x34, 0x35, 0x35, 0x62, 0x38, 0x63, 0x37, 0x37, 0x65, 0x33, 0x34, 0x32, 0x30, 0x31, 0x34, 0x32, 0x30, 0x31, 0x36, 0x31, 0x37, 0x65, 0x34, 0x61, 0x65, 0x64, 0x39, 0x34, 0x35, 0x30, 0x34, 0x64, 0x39, 0x34, 0x65, 0x36, 0x32, 0x66, 0x66, 0x37, 0x32, 0x38, 0x36, 0x30, 0x31, 0x34, 0x63, 0x30, 0x64, 0x32, 0x37, 0x61, 0x63, 0x66, 0x66, 0x31, 0x33, 0x37, 0x63, 0x62, 0x62, 0x37, 0x62, 0x38, 0x38, 0x64, 0x32, 0x64, 0x31, 0x37, 0x33, 0x34, 0x63, 0x33, 0x62, 0x34, 0x61, 0x33, 0x37, 0x38, 0x36, 0x33, 0x32, 0x30, 0x66, 0x38, 0x34, 0x62, 0x39, 0x64, 0x64, 0x39, 0x33, 0x61, 0x31, 0x64, 0x36, 0x65, 0x31, 0x33, 0x63, 0x33, 0x30, 0x37, 0x32, 0x34, 0x36, 0x35, 0x61, 0x34, 0x37, 0x38, 0x65, 0x34, 0x61, 0x39, 0x63, 0x33, 0x62, 0x63, 0x62, 0x35, 0x66, 0x63, 0x35, 0x32, 0x63, 0x62, 0x32, 0x31, 0x34, 0x31, 0x34, 0x39, 0x36, 0x30, 0x30, 0x64, 0x61, 0x39, 0x61, 0x64, 0x36, 0x31, 0x34, 0x38, 0x61, 0x64, 0x31, 0x38, 0x38, 0x38, 0x39, 0x32, 0x32, 0x37, 0x33, 0x37, 0x33, 0x35, 0x61, 0x63, 0x34, 0x61, 0x38, 0x32, 0x36, 0x36, 0x63, 0x32, 0x31, 0x35, 0x32, 0x66, 0x66, 0x38, 0x32, 0x33, 0x36, 0x34, 0x37, 0x38, 0x61, 0x66, 0x30, 0x39, 0x32, 0x32, 0x61, 0x36, 0x65, 0x31, 0x38, 0x39, 0x36, 0x38, 0x63, 0x37, 0x61, 0x31, 0x39, 0x32, 0x62, 0x66, 0x62, 0x36, 0x34, 0x30, 0x61, 0x65, 0x32, 0x63, 0x34, 0x65, 0x63, 0x61, 0x37, 0x30, 0x34, 0x62, 0x37, 0x35, 0x31, 0x61, 0x61, 0x33, 0x62, 0x63, 0x39, 0x66, 0x31, 0x33, 0x61, 0x35, 0x36, 0x39, 0x37, 0x62, 0x37, 0x36, 0x30, 0x61, 0x31, 0x34, 0x30, 0x35, 0x33, 0x30, 0x34, 0x31, 0x38, 0x62, 0x39, 0x66, 0x30, 0x34, 0x64, 0x65, 0x63, 0x61, 0x31, 0x66, 0x66, 0x38, 0x38, 0x38, 0x30, 0x30, 0x66, 0x61, 0x34, 0x63, 0x38, 0x33, 0x62, 0x31, 0x64, 0x38, 0x65, 0x32, 0x35, 0x30, 0x64, 0x66, 0x39, 0x34, 0x39, 0x61, 0x32, 0x64, 0x32, 0x32, 0x63, 0x37, 0x34, 0x31, 0x38, 0x33, 0x66, 0x66, 0x66, 0x64, 0x35, 0x34, 0x66, 0x65, 0x36, 0x38, 0x65, 0x32, 0x62, 0x35, 0x62, 0x37, 0x31, 0x33, 0x63, 0x38, 0x66, 0x31, 0x37, 0x35, 0x32, 0x66, 0x65, 0x35, 0x31, 0x38, 0x34, 0x61, 0x34, 0x36, 0x63, 0x31, 0x39, 0x31, 0x36, 0x39, 0x32, 0x62, 0x61, 0x37, 0x37, 0x62, 0x36, 0x39, 0x36, 0x30, 0x62, 0x30, 0x62, 0x65, 0x30, 0x30, 0x39, 0x39, 0x64, 0x35, 0x61, 0x37, 0x32, 0x30, 0x61, 0x62, 0x65, 0x39, 0x32, 0x33, 0x61, 0x32, 0x33, 0x31, 0x39, 0x36, 0x32, 0x66, 0x65, 0x37, 0x62, 0x36, 0x31, 0x38, 0x38, 0x39, 0x63, 0x61, 0x33, 0x65, 0x35, 0x65, 0x66, 0x30, 0x37, 0x34, 0x30, 0x30, 0x34, 0x36, 0x65, 0x33, 0x37, 0x63, 0x36, 0x31, 0x30, 0x33, 0x62, 0x35, 0x37, 0x65, 0x62, 0x34, 0x65, 0x32, 0x34, 0x65, 0x61, 0x31, 0x64, 0x65, 0x32, 0x64, 0x63, 0x37, 0x32, 0x63, 0x64, 0x31, 0x36, 0x63, 0x38, 0x61, 0x39, 0x31, 0x66, 0x37, 0x37, 0x62, 0x35, 0x33, 0x38, 0x37, 0x35, 0x66, 0x38, 0x31, 0x32, 0x62, 0x31, 0x32, 0x63, 0x32, 0x32, 0x64, 0x32, 0x65, 0x31, 0x63, 0x61, 0x31, 0x64, 0x39, 0x31, 0x62, 0x36, 0x61, 0x33, 0x33, 0x32, 0x32, 0x39, 0x37, 0x30, 0x36, 0x33, 0x37, 0x65, 0x61, 0x34, 0x64, 0x30, 0x63, 0x37, 0x35, 0x61, 0x63, 0x33, 0x31, 0x31, 0x38, 0x64, 0x65, 0x39, 0x35, 0x30, 0x36, 0x39, 0x61, 0x66, 0x38, 0x62, 0x65, 0x61, 0x39, 0x65, 0x33, 0x38, 0x31, 0x62, 0x65, 0x34, 0x36, 0x36, 0x64, 0x35, 0x37, 0x61, 0x32, 0x35, 0x63, 0x62, 0x32, 0x64, 0x32, 0x37, 0x39, 0x30, 0x62, 0x34, 0x65, 0x33, 0x64, 0x36, 0x64, 0x33, 0x32, 0x63, 0x30, 0x33, 0x39, 0x61, 0x32, 0x31, 0x36, 0x65, 0x38, 0x35, 0x34, 0x36, 0x38, 0x36, 0x37, 0x32, 0x62, 0x64, 0x31, 0x63, 0x31, 0x30, 0x62, 0x38, 0x34, 0x34, 0x35, 0x63, 0x61, 0x38, 0x66, 0x39, 0x33, 0x38, 0x65, 0x36, 0x65, 0x62, 0x32, 0x37, 0x35, 0x31, 0x39, 0x33, 0x37, 0x35, 0x37, 0x31, 0x32, 0x63, 0x62, 0x34, 0x65, 0x35, 0x61, 0x65, 0x33, 0x32, 0x32, 0x66, 0x64, 0x39, 0x32, 0x63, 0x63, 0x38, 0x63, 0x33, 0x65, 0x31, 0x30, 0x61, 0x38, 0x63, 0x36, 0x35, 0x32, 0x34, 0x37, 0x32, 0x61, 0x63, 0x65, 0x37, 0x33, 0x31, 0x64, 0x37, 0x33, 0x33, 0x34, 0x39, 0x37, 0x63, 0x61, 0x33, 0x61, 0x62, 0x35, 0x66, 0x64, 0x31, 0x61, 0x32, 0x38, 0x31, 0x66, 0x35, 0x61, 0x64, 0x32, 0x39, 0x35, 0x30, 0x30, 0x38, 0x33, 0x37, 0x31, 0x65, 0x63, 0x61, 0x32, 0x30, 0x33, 0x36, 0x36, 0x62, 0x35, 0x30, 0x38, 0x62, 0x37, 0x36, 0x39, 0x34, 0x39, 0x35, 0x66, 0x65, 0x63, 0x39, 0x37, 0x32, 0x66, 0x61, 0x34, 0x65, 0x34, 0x61, 0x63, 0x62, 0x39, 0x39, 0x31, 0x39, 0x31, 0x34, 0x33, 0x35, 0x62, 0x39, 0x34, 0x32, 0x61, 0x62, 0x64, 0x66, 0x35, 0x33, 0x35, 0x35, 0x35, 0x34, 0x64, 0x62, 0x66, 0x37, 0x34, 0x36, 0x66, 0x38, 0x62, 0x37, 0x36, 0x36, 0x65, 0x64, 0x38, 0x37, 0x61, 0x31, 0x65, 0x35, 0x37, 0x39, 0x39, 0x39, 0x37, 0x66, 0x36, 0x36, 0x36, 0x35, 0x34, 0x64, 0x30, 0x35, 0x32, 0x61, 0x37, 0x34, 0x66, 0x66, 0x31, 0x31, 0x37, 0x62, 0x66, 0x30, 0x33, 0x36, 0x34, 0x65, 0x65, 0x35, 0x61, 0x61, 0x31, 0x64, 0x32, 0x38, 0x38, 0x30, 0x66, 0x64, 0x30, 0x65, 0x31, 0x61, 0x32, 0x63, 0x38, 0x63, 0x31, 0x37, 0x65, 0x66, 0x65, 0x66, 0x62, 0x61, 0x32, 0x31, 0x35, 0x33, 0x36, 0x36, 0x66, 0x36, 0x64, 0x39, 0x32, 0x65, 0x31, 0x63, 0x31, 0x63, 0x64, 0x31, 0x37, 0x32, 0x62, 0x36, 0x33, 0x35, 0x33, 0x36, 0x62, 0x34, 0x61, 0x61, 0x35, 0x31, 0x33, 0x33, 0x38, 0x38, 0x38, 0x35, 0x35, 0x61, 0x30, 0x66, 0x63, 0x65, 0x31, 0x66, 0x66, 0x64, 0x65, 0x34, 0x35, 0x31, 0x65, 0x39, 0x64, 0x39, 0x39, 0x35, 0x64, 0x62, 0x37, 0x31, 0x37, 0x34, 0x36, 0x66, 0x33, 0x62, 0x33, 0x39, 0x33, 0x64, 0x61, 0x33, 0x64, 0x61, 0x66, 0x38, 0x61, 0x32, 0x64, 0x30, 0x37, 0x32, 0x66, 0x33, 0x35, 0x61, 0x36, 0x62, 0x35, 0x65, 0x32, 0x35, 0x39, 0x32, 0x64, 0x61, 0x36, 0x64, 0x34, 0x30, 0x34, 0x65, 0x61, 0x38, 0x62, 0x63, 0x38, 0x64, 0x31, 0x65, 0x37, 0x63, 0x62, 0x65, 0x61, 0x35, 0x32, 0x64, 0x30, 0x34, 0x34, 0x35, 0x35, 0x36, 0x32, 0x36, 0x39, 0x63, 0x62, 0x33, 0x31, 0x36, 0x37, 0x37, 0x30, 0x33, 0x37, 0x64, 0x33, 0x39, 0x31, 0x34, 0x34, 0x31, 0x37, 0x32, 0x64, 0x63, 0x35, 0x36, 0x38, 0x38, 0x35, 0x32, 0x64, 0x38, 0x61, 0x34, 0x39, 0x61, 0x35, 0x61, 0x62, 0x65, 0x39, 0x31, 0x61, 0x62, 0x35, 0x31, 0x62, 0x65, 0x64, 0x61, 0x66, 0x30, 0x32, 0x66, 0x36, 0x30, 0x62, 0x38, 0x62, 0x39, 0x38, 0x30, 0x62, 0x33, 0x33, 0x32, 0x30, 0x66, 0x39, 0x34, 0x31, 0x35, 0x33, 0x34, 0x64, 0x34, 0x32, 0x63, 0x62, 0x61, 0x61, 0x66, 0x64, 0x38, 0x36, 0x64, 0x31, 0x35, 0x61, 0x32, 0x39, 0x39, 0x31, 0x31, 0x35, 0x31, 0x64, 0x37, 0x31, 0x62, 0x65, 0x36, 0x33, 0x34, 0x32, 0x31, 0x33, 0x65, 0x33, 0x64, 0x64, 0x32, 0x35, 0x37, 0x63, 0x31, 0x33, 0x31, 0x36, 0x61, 0x31, 0x30, 0x65, 0x35, 0x38, 0x63, 0x35, 0x63, 0x35, 0x39, 0x63, 0x31, 0x34, 0x66, 0x38, 0x36, 0x30, 0x64, 0x32, 0x61, 0x36, 0x64, 0x39, 0x63, 0x66, 0x32, 0x32, 0x35, 0x34, 0x31, 0x64, 0x37, 0x35, 0x37, 0x38, 0x65, 0x66, 0x66, 0x32, 0x32, 0x36, 0x66, 0x66, 0x33, 0x33, 0x38, 0x34, 0x31, 0x31, 0x65, 0x37, 0x62, 0x36, 0x64, 0x39, 0x61, 0x33, 0x33, 0x64, 0x61, 0x32, 0x65, 0x31, 0x64, 0x34, 0x33, 0x36, 0x61, 0x35, 0x61, 0x63, 0x35, 0x31, 0x35, 0x32, 0x37, 0x63, 0x63, 0x37, 0x37, 0x34, 0x36, 0x38, 0x31, 0x35, 0x66, 0x31, 0x37, 0x32, 0x61, 0x64, 0x61, 0x34, 0x65, 0x30, 0x63, 0x33, 0x39, 0x39, 0x32, 0x33, 0x64, 0x63, 0x32, 0x34, 0x34, 0x63, 0x35, 0x61, 0x35, 0x31, 0x36, 0x34, 0x62, 0x34, 0x61, 0x34, 0x65, 0x61, 0x65, 0x37, 0x31, 0x66, 0x32, 0x64, 0x34, 0x39, 0x38, 0x36, 0x34, 0x33, 0x33, 0x31, 0x32, 0x64, 0x64, 0x39, 0x63, 0x38, 0x36, 0x64, 0x65, 0x32, 0x32, 0x66, 0x65, 0x61, 0x63, 0x61, 0x35, 0x39, 0x31, 0x38, 0x35, 0x36, 0x38, 0x37, 0x32, 0x36, 0x30, 0x38, 0x64, 0x63, 0x31, 0x30, 0x61, 0x34, 0x33, 0x61, 0x35, 0x64, 0x30, 0x35, 0x35, 0x66, 0x63, 0x38, 0x65, 0x36, 0x33, 0x65, 0x30, 0x34, 0x66, 0x37, 0x32, 0x39, 0x31, 0x30, 0x31, 0x36, 0x32, 0x32, 0x37, 0x34, 0x35, 0x35, 0x63, 0x32, 0x61, 0x38, 0x64, 0x64, 0x62, 0x32, 0x33, 0x64, 0x39, 0x66, 0x62, 0x65, 0x61, 0x66, 0x30, 0x64, 0x31, 0x39, 0x63, 0x35, 0x63, 0x37, 0x32, 0x37, 0x64, 0x37, 0x39, 0x65, 0x62, 0x31, 0x36, 0x63, 0x32, 0x64, 0x34, 0x64, 0x34, 0x64, 0x36, 0x35, 0x30, 0x66, 0x32, 0x38, 0x36, 0x37, 0x37, 0x34, 0x39, 0x61, 0x35, 0x33, 0x36, 0x31, 0x65, 0x37, 0x39, 0x61, 0x32, 0x34, 0x63, 0x31, 0x36, 0x63, 0x31, 0x36, 0x61, 0x32, 0x34, 0x61, 0x35, 0x36, 0x37, 0x32, 0x35, 0x62, 0x61, 0x64, 0x63, 0x30, 0x33, 0x61, 0x35, 0x33, 0x38, 0x37, 0x32, 0x31, 0x35, 0x32, 0x65, 0x33, 0x39, 0x65, 0x33, 0x37, 0x38, 0x38, 0x66, 0x62, 0x63, 0x64, 0x64, 0x38, 0x35, 0x34, 0x35, 0x65, 0x64, 0x37, 0x62, 0x39, 0x61, 0x31, 0x66, 0x38, 0x64, 0x35, 0x64, 0x64, 0x66, 0x34, 0x64, 0x63, 0x37, 0x62, 0x38, 0x66, 0x63, 0x36, 0x31, 0x31, 0x64, 0x31, 0x39, 0x36, 0x31, 0x64, 0x61, 0x35, 0x38, 0x61, 0x30, 0x36, 0x37, 0x30, 0x36, 0x63, 0x66, 0x37, 0x32, 0x39, 0x65, 0x37, 0x32, 0x33, 0x30, 0x31, 0x31, 0x30, 0x37, 0x61, 0x30, 0x33, 0x31, 0x63, 0x65, 0x64, 0x36, 0x32, 0x65, 0x62, 0x66, 0x37, 0x38, 0x62, 0x66, 0x62, 0x61, 0x32, 0x33, 0x39, 0x32, 0x31, 0x33, 0x36, 0x31, 0x61, 0x64, 0x33, 0x66, 0x30, 0x34, 0x31, 0x38, 0x66, 0x31, 0x66, 0x37, 0x37, 0x36, 0x38, 0x32, 0x35, 0x36, 0x62, 0x34, 0x38, 0x38, 0x66, 0x65, 0x32, 0x63, 0x37, 0x32, 0x37, 0x32, 0x66, 0x35, 0x63, 0x36, 0x36, 0x32, 0x31, 0x34, 0x34, 0x37, 0x66, 0x65, 0x33, 0x66, 0x31, 0x66, 0x64, 0x66, 0x62, 0x36, 0x30, 0x33, 0x33, 0x39, 0x64, 0x66, 0x38, 0x38, 0x30, 0x30, 0x39, 0x39, 0x38, 0x33, 0x33, 0x31, 0x31, 0x33, 0x31, 0x30, 0x62, 0x39, 0x35, 0x34, 0x31, 0x32, 0x35, 0x63, 0x37, 0x34, 0x39, 0x36, 0x61, 0x36, 0x31, 0x63, 0x31, 0x65, 0x31, 0x62, 0x34, 0x38, 0x66, 0x63, 0x39, 0x39, 0x61, 0x37, 0x62, 0x36, 0x62, 0x39, 0x65, 0x30, 0x30, 0x38, 0x38, 0x39, 0x38, 0x31, 0x30, 0x35, 0x31, 0x30, 0x65, 0x66, 0x64, 0x66, 0x37, 0x39, 0x64, 0x32, 0x30, 0x34, 0x37, 0x33, 0x62, 0x34, 0x36, 0x38, 0x62, 0x32, 0x34, 0x32, 0x36, 0x61, 0x62, 0x31, 0x66, 0x30, 0x36, 0x33, 0x61, 0x62, 0x64, 0x39, 0x39, 0x35, 0x66, 0x35, 0x35, 0x39, 0x31, 0x36, 0x37, 0x32, 0x39, 0x61, 0x63, 0x62, 0x62, 0x61, 0x66, 0x63, 0x32, 0x30, 0x65, 0x63, 0x35, 0x65, 0x30, 0x39, 0x31, 0x66, 0x38, 0x64, 0x33, 0x64, 0x37, 0x64, 0x66, 0x63, 0x66, 0x36, 0x33, 0x62, 0x65, 0x31, 0x31, 0x32, 0x32, 0x30, 0x64, 0x35, 0x61, 0x36, 0x30, 0x34, 0x65, 0x38, 0x39, 0x38, 0x61, 0x61, 0x30, 0x39, 0x36, 0x37, 0x65, 0x61, 0x30, 0x63, 0x63, 0x62, 0x33, 0x37, 0x62, 0x62, 0x37, 0x32, 0x33, 0x38, 0x36, 0x62, 0x39, 0x63, 0x63, 0x65, 0x62, 0x33, 0x31, 0x30, 0x35, 0x66, 0x37, 0x39, 0x31, 0x39, 0x36, 0x32, 0x36, 0x39, 0x62, 0x34, 0x37, 0x30, 0x39, 0x34, 0x64, 0x61, 0x35, 0x32, 0x39, 0x35, 0x62, 0x32, 0x61, 0x36, 0x37, 0x35, 0x65, 0x39, 0x33, 0x36, 0x65, 0x30, 0x31, 0x61, 0x39, 0x39, 0x39, 0x30, 0x64, 0x61, 0x39, 0x34, 0x62, 0x62, 0x64, 0x31, 0x66, 0x31, 0x37, 0x32, 0x63, 0x35, 0x62, 0x39, 0x34, 0x39, 0x32, 0x61, 0x66, 0x63, 0x34, 0x63, 0x33, 0x64, 0x61, 0x63, 0x65, 0x63, 0x35, 0x31, 0x63, 0x65, 0x63, 0x65, 0x62, 0x61, 0x36, 0x62, 0x62, 0x36, 0x36, 0x61, 0x62, 0x32, 0x62, 0x61, 0x32, 0x63, 0x32, 0x31, 0x35, 0x33, 0x39, 0x37, 0x64, 0x66, 0x65, 0x39, 0x39, 0x30, 0x30, 0x35, 0x62, 0x61, 0x31, 0x39, 0x37, 0x37, 0x37, 0x31, 0x35, 0x33, 0x37, 0x32, 0x31, 0x39, 0x34, 0x64, 0x35, 0x33, 0x61, 0x66, 0x33, 0x64, 0x31, 0x33, 0x33, 0x62, 0x34, 0x64, 0x39, 0x65, 0x35, 0x39, 0x34, 0x39, 0x33, 0x30, 0x36, 0x35, 0x34, 0x32, 0x65, 0x65, 0x37, 0x62, 0x62, 0x62, 0x33, 0x39, 0x37, 0x32, 0x64, 0x65, 0x37, 0x65, 0x37, 0x66, 0x37, 0x39, 0x38, 0x35, 0x39, 0x32, 0x33, 0x33, 0x62, 0x37, 0x33, 0x37, 0x32, 0x36, 0x63, 0x65, 0x30, 0x39, 0x37, 0x32, 0x65, 0x66, 0x62, 0x65, 0x31, 0x30, 0x33, 0x34, 0x30, 0x36, 0x38, 0x31, 0x34, 0x62, 0x37, 0x34, 0x39, 0x32, 0x37, 0x63, 0x39, 0x35, 0x36, 0x31, 0x61, 0x30, 0x37, 0x62, 0x39, 0x36, 0x61, 0x63, 0x61, 0x38, 0x65, 0x64, 0x31, 0x35, 0x38, 0x35, 0x36, 0x31, 0x30, 0x36, 0x32, 0x35, 0x34, 0x39, 0x32, 0x39, 0x35, 0x62, 0x38, 0x64, 0x63, 0x30, 0x32, 0x61, 0x30, 0x33, 0x66, 0x66, 0x31, 0x61, 0x62, 0x39, 0x61, 0x38, 0x65, 0x34, 0x34, 0x63, 0x38, 0x31, 0x65, 0x64, 0x66, 0x65, 0x33, 0x36, 0x39, 0x37, 0x38, 0x65, 0x65, 0x39, 0x30, 0x32, 0x31, 0x36, 0x30, 0x36, 0x31, 0x64, 0x63, 0x36, 0x31, 0x38, 0x63, 0x62, 0x35, 0x62, 0x65, 0x61, 0x65, 0x33, 0x39, 0x64, 0x64, 0x66, 0x66, 0x32, 0x63, 0x63, 0x66, 0x62, 0x63, 0x63, 0x37, 0x66, 0x31, 0x61, 0x30, 0x61, 0x66, 0x36, 0x37, 0x32, 0x66, 0x33, 0x37, 0x62, 0x35, 0x39, 0x66, 0x63, 0x31, 0x64, 0x61, 0x64, 0x33, 0x64, 0x37, 0x31, 0x32, 0x37, 0x30, 0x63, 0x65, 0x65, 0x64, 0x61, 0x35, 0x66, 0x65, 0x38, 0x33, 0x65, 0x33, 0x35, 0x65, 0x63, 0x63, 0x36, 0x37, 0x66, 0x62, 0x37, 0x32, 0x38, 0x66, 0x38, 0x35, 0x36, 0x39, 0x39, 0x34, 0x37, 0x64, 0x37, 0x37, 0x31, 0x65, 0x66, 0x61, 0x32, 0x32, 0x39, 0x39, 0x31, 0x35, 0x65, 0x65, 0x32, 0x62, 0x65, 0x65, 0x35, 0x34, 0x30, 0x36, 0x66, 0x64, 0x64, 0x66, 0x66, 0x37, 0x39, 0x32, 0x34, 0x38, 0x62, 0x64, 0x31, 0x38, 0x34, 0x61, 0x38, 0x38, 0x38, 0x62, 0x38, 0x61, 0x39, 0x63, 0x34, 0x39, 0x66, 0x33, 0x36, 0x65, 0x38, 0x39, 0x62, 0x30, 0x62, 0x34, 0x39, 0x32, 0x33, 0x61, 0x63, 0x36, 0x32, 0x61, 0x31, 0x30, 0x36, 0x64, 0x61, 0x62, 0x37, 0x62, 0x37, 0x37, 0x32, 0x35, 0x62, 0x66, 0x31, 0x33, 0x39, 0x63, 0x33, 0x39, 0x65, 0x65, 0x32, 0x63, 0x62, 0x35, 0x39, 0x39, 0x66, 0x38, 0x66, 0x65, 0x37, 0x34, 0x63, 0x33, 0x34, 0x30, 0x32, 0x33, 0x30, 0x31, 0x63, 0x64, 0x33, 0x36, 0x34, 0x64, 0x34, 0x31, 0x64, 0x32, 0x36, 0x33, 0x35, 0x39, 0x30, 0x62, 0x33, 0x38, 0x61, 0x61, 0x30, 0x66, 0x37, 0x36, 0x34, 0x64, 0x36, 0x39, 0x37, 0x34, 0x66, 0x36, 0x37, 0x33, 0x61, 0x36, 0x35, 0x64, 0x62, 0x36, 0x36, 0x35, 0x64, 0x62, 0x38, 0x37, 0x66, 0x66, 0x38, 0x35, 0x62, 0x64, 0x33, 0x62, 0x35, 0x65, 0x65, 0x66, 0x33, 0x66, 0x34, 0x61, 0x61, 0x31, 0x30, 0x62, 0x33, 0x65, 0x32, 0x33, 0x62, 0x33, 0x62, 0x63, 0x61, 0x33, 0x66, 0x30, 0x65, 0x37, 0x30, 0x39, 0x39, 0x34, 0x61, 0x65, 0x35, 0x65, 0x31, 0x37, 0x31, 0x31, 0x30, 0x38, 0x66, 0x37, 0x32, 0x63, 0x64, 0x34, 0x36, 0x61, 0x64, 0x66, 0x37, 0x31, 0x61, 0x35, 0x65, 0x37, 0x39, 0x34, 0x61, 0x66, 0x61, 0x34, 0x33, 0x32, 0x34, 0x64, 0x63, 0x33, 0x35, 0x65, 0x30, 0x32, 0x33, 0x37, 0x64, 0x61, 0x62, 0x66, 0x30, 0x64, 0x63, 0x63, 0x61, 0x65, 0x63, 0x31, 0x34, 0x64, 0x36, 0x64, 0x30, 0x65, 0x66, 0x63, 0x37, 0x30, 0x37, 0x38, 0x63, 0x31, 0x31, 0x39, 0x36, 0x35, 0x61, 0x32, 0x66, 0x63, 0x39, 0x37, 0x31, 0x63, 0x36, 0x36, 0x31, 0x66, 0x33, 0x31, 0x38, 0x63, 0x63, 0x65, 0x33, 0x32, 0x64, 0x63, 0x34, 0x36, 0x65, 0x63, 0x33, 0x66, 0x35, 0x64, 0x61, 0x63, 0x63, 0x33, 0x39, 0x34, 0x65, 0x64, 0x63, 0x31, 0x38, 0x64, 0x37, 0x39, 0x66, 0x33, 0x64, 0x39, 0x62, 0x61, 0x38, 0x61, 0x64, 0x32, 0x36, 0x37, 0x62, 0x38, 0x64, 0x30, 0x34, 0x31, 0x30, 0x64, 0x33, 0x37, 0x32, 0x35, 0x33, 0x35, 0x31, 0x32, 0x64, 0x65, 0x30, 0x33, 0x61, 0x62, 0x32, 0x63, 0x30, 0x61, 0x66, 0x66, 0x32, 0x36, 0x66, 0x32, 0x65, 0x39, 0x30, 0x32, 0x36, 0x61, 0x37, 0x62, 0x64, 0x36, 0x33, 0x34, 0x66, 0x30, 0x33, 0x39, 0x39, 0x65, 0x63, 0x35, 0x36, 0x66, 0x33, 0x38, 0x33, 0x35, 0x38, 0x62, 0x39, 0x63, 0x65, 0x36, 0x39, 0x36, 0x32, 0x32, 0x37, 0x61, 0x36, 0x66, 0x34, 0x33, 0x36, 0x32, 0x35, 0x31, 0x36, 0x61, 0x31, 0x62, 0x33, 0x61, 0x34, 0x30, 0x65, 0x30, 0x30, 0x38, 0x30, 0x37, 0x63, 0x38, 0x66, 0x37, 0x62, 0x30, 0x63, 0x32, 0x62, 0x34, 0x38, 0x66, 0x61, 0x32, 0x65, 0x38, 0x32, 0x39, 0x62, 0x37, 0x35, 0x34, 0x66, 0x35, 0x37, 0x37, 0x34, 0x65, 0x31, 0x66, 0x30, 0x34, 0x35, 0x38, 0x66, 0x35, 0x30, 0x66, 0x31, 0x65, 0x39, 0x30, 0x63, 0x30, 0x62, 0x30, 0x62, 0x31, 0x36, 0x61, 0x66, 0x32, 0x36, 0x64, 0x38, 0x36, 0x62, 0x34, 0x65, 0x34, 0x31, 0x61, 0x64, 0x38, 0x37, 0x37, 0x65, 0x62, 0x31, 0x33, 0x33, 0x31, 0x31, 0x65, 0x35, 0x34, 0x64, 0x39, 0x66, 0x33, 0x64, 0x34, 0x64, 0x65, 0x35, 0x32, 0x37, 0x38, 0x38, 0x33, 0x64, 0x61, 0x38, 0x32, 0x37, 0x33, 0x39, 0x66, 0x38, 0x38, 0x65, 0x31, 0x65, 0x37, 0x39, 0x63, 0x65, 0x31, 0x66, 0x34, 0x37, 0x34, 0x35, 0x38, 0x38, 0x31, 0x31, 0x64, 0x66, 0x36, 0x62, 0x65, 0x63, 0x30, 0x63, 0x65, 0x66, 0x66, 0x64, 0x64, 0x66, 0x66, 0x63, 0x39, 0x61, 0x64, 0x33, 0x30, 0x63, 0x36, 0x33, 0x39, 0x34, 0x65, 0x33, 0x65, 0x35, 0x31, 0x65, 0x62, 0x35, 0x64, 0x38, 0x62, 0x33, 0x33, 0x65, 0x37, 0x32, 0x64, 0x65, 0x62, 0x30, 0x64, 0x35, 0x37, 0x31, 0x65, 0x61, 0x62, 0x62, 0x36, 0x31, 0x36, 0x66, 0x65, 0x65, 0x35, 0x34, 0x63, 0x33, 0x62, 0x38, 0x62, 0x30, 0x66, 0x36, 0x65, 0x62, 0x39, 0x36, 0x62, 0x66, 0x39, 0x30, 0x35, 0x35, 0x63, 0x63, 0x30, 0x37, 0x31, 0x34, 0x66, 0x66, 0x33, 0x37, 0x35, 0x62, 0x36, 0x36, 0x61, 0x64, 0x34, 0x38, 0x37, 0x63, 0x64, 0x38, 0x34, 0x36, 0x61, 0x63, 0x30, 0x63, 0x36, 0x64, 0x34, 0x36, 0x32, 0x62, 0x34, 0x64, 0x38, 0x30, 0x31, 0x32, 0x37, 0x32, 0x38, 0x37, 0x31, 0x30, 0x66, 0x35, 0x62, 0x33, 0x62, 0x30, 0x30, 0x66, 0x36, 0x61, 0x37, 0x65, 0x34, 0x61, 0x35, 0x30, 0x33, 0x66, 0x35, 0x63, 0x36, 0x36, 0x31, 0x36, 0x35, 0x39, 0x65, 0x39, 0x66, 0x33, 0x32, 0x62, 0x65, 0x66, 0x66, 0x61, 0x38, 0x30, 0x35, 0x32, 0x62, 0x34, 0x66, 0x62, 0x33, 0x31, 0x37, 0x64, 0x39, 0x36, 0x37, 0x30, 0x32, 0x63, 0x36, 0x38, 0x35, 0x34, 0x37, 0x32, 0x32, 0x65, 0x36, 0x61, 0x33, 0x65, 0x37, 0x34, 0x32, 0x35, 0x37, 0x37, 0x65, 0x39, 0x63, 0x32, 0x35, 0x39, 0x34, 0x62, 0x33, 0x39, 0x35, 0x32, 0x38, 0x37, 0x33, 0x33, 0x39, 0x32, 0x65, 0x62, 0x35, 0x34, 0x39, 0x30, 0x39, 0x35, 0x63, 0x63, 0x35, 0x65, 0x39, 0x64, 0x38, 0x31, 0x66, 0x30, 0x63, 0x65, 0x38, 0x33, 0x33, 0x66, 0x33, 0x31, 0x31, 0x32, 0x63, 0x64, 0x65, 0x30, 0x33, 0x31, 0x32, 0x35, 0x66, 0x36, 0x35, 0x36, 0x30, 0x33, 0x33, 0x62, 0x39, 0x66, 0x65, 0x33, 0x36, 0x62, 0x35, 0x33, 0x35, 0x39, 0x37, 0x39, 0x32, 0x62, 0x39, 0x62, 0x63, 0x36, 0x65, 0x66, 0x63, 0x36, 0x61, 0x64, 0x32, 0x35, 0x66, 0x30, 0x30, 0x30, 0x37, 0x64, 0x65, 0x34, 0x61, 0x36, 0x30, 0x37, 0x32, 0x34, 0x30, 0x37, 0x62, 0x66, 0x65, 0x65, 0x62, 0x31, 0x64, 0x65, 0x61, 0x39, 0x32, 0x32, 0x36, 0x33, 0x35, 0x61, 0x39, 0x33, 0x36, 0x35, 0x62, 0x32, 0x36, 0x33, 0x62, 0x63, 0x31, 0x38, 0x63, 0x35, 0x33, 0x32, 0x61, 0x34, 0x33, 0x32, 0x34, 0x33, 0x38, 0x65, 0x33, 0x33, 0x65, 0x37, 0x31, 0x30, 0x39, 0x33, 0x32, 0x33, 0x33, 0x38, 0x64, 0x34, 0x38, 0x37, 0x36, 0x36, 0x35, 0x30, 0x32, 0x64, 0x33, 0x37, 0x65, 0x39, 0x36, 0x39, 0x34, 0x32, 0x32, 0x63, 0x62, 0x39, 0x37, 0x32, 0x33, 0x61, 0x63, 0x31, 0x34, 0x37, 0x66, 0x32, 0x61, 0x66, 0x34, 0x62, 0x64, 0x62, 0x66, 0x62, 0x32, 0x63, 0x61, 0x39, 0x64, 0x65, 0x30, 0x30, 0x30, 0x66, 0x64, 0x63, 0x64, 0x34, 0x63, 0x34, 0x37, 0x38, 0x62, 0x37, 0x35, 0x36, 0x61, 0x39, 0x36, 0x36, 0x36, 0x39, 0x65, 0x61, 0x30, 0x63, 0x36, 0x65, 0x30, 0x38, 0x36, 0x39, 0x61, 0x32, 0x38, 0x64, 0x66, 0x64, 0x36, 0x36, 0x36, 0x36, 0x66, 0x34, 0x36, 0x37, 0x31, 0x65, 0x31, 0x36, 0x63, 0x61, 0x37, 0x31, 0x32, 0x37, 0x65, 0x33, 0x34, 0x36, 0x65, 0x32, 0x33, 0x35, 0x34, 0x30, 0x35, 0x63, 0x37, 0x66, 0x33, 0x33, 0x39, 0x32, 0x63, 0x36, 0x65, 0x62, 0x65, 0x34, 0x32, 0x38, 0x66, 0x62, 0x62, 0x61, 0x63, 0x31, 0x64, 0x64, 0x35, 0x35, 0x64, 0x35, 0x36, 0x32, 0x65, 0x62, 0x66, 0x61, 0x64, 0x33, 0x31, 0x62, 0x37, 0x32, 0x32, 0x66, 0x62, 0x64, 0x62, 0x65, 0x31, 0x35, 0x37, 0x39, 0x30, 0x65, 0x34, 0x31, 0x35, 0x63, 0x66, 0x39, 0x64, 0x64, 0x65, 0x66, 0x35, 0x31, 0x35, 0x62, 0x33, 0x65, 0x30, 0x35, 0x62, 0x66, 0x64, 0x61, 0x63, 0x64, 0x31, 0x32, 0x31, 0x62, 0x30, 0x37, 0x31, 0x35, 0x39, 0x34, 0x35, 0x38, 0x61, 0x31, 0x31, 0x35, 0x62, 0x33, 0x34, 0x32, 0x39, 0x62, 0x35, 0x39, 0x37, 0x35, 0x37, 0x32, 0x33, 0x38, 0x38, 0x64, 0x39, 0x30, 0x33, 0x36, 0x39, 0x39, 0x31, 0x36, 0x36, 0x35, 0x31, 0x64, 0x61, 0x35, 0x39, 0x30, 0x66, 0x61, 0x32, 0x33, 0x31, 0x62, 0x32, 0x36, 0x63, 0x31, 0x64, 0x62, 0x31, 0x63, 0x62, 0x37, 0x34, 0x35, 0x36, 0x64, 0x63, 0x32, 0x61, 0x39, 0x39, 0x66, 0x63, 0x36, 0x64, 0x31, 0x63, 0x31, 0x33, 0x39, 0x66, 0x61, 0x62, 0x62, 0x34, 0x64, 0x64, 0x37, 0x37, 0x32, 0x32, 0x62, 0x37, 0x30, 0x38, 0x66, 0x34, 0x65, 0x31, 0x34, 0x31, 0x33, 0x64, 0x31, 0x34, 0x65, 0x30, 0x33, 0x36, 0x37, 0x37, 0x34, 0x37, 0x35, 0x35, 0x32, 0x36, 0x35, 0x64, 0x31, 0x36, 0x37, 0x62, 0x34, 0x62, 0x37, 0x38, 0x30, 0x36, 0x63, 0x30, 0x36, 0x31, 0x38, 0x33, 0x39, 0x30, 0x62, 0x35, 0x63, 0x32, 0x36, 0x64, 0x31, 0x30, 0x31, 0x63, 0x63, 0x63, 0x30, 0x38, 0x61, 0x37, 0x32, 0x39, 0x31, 0x34, 0x37, 0x35, 0x39, 0x37, 0x63, 0x39, 0x63, 0x38, 0x65, 0x66, 0x35, 0x38, 0x62, 0x32, 0x62, 0x65, 0x65, 0x64, 0x39, 0x62, 0x30, 0x31, 0x30, 0x33, 0x39, 0x38, 0x37, 0x31, 0x31, 0x33, 0x33, 0x64, 0x62, 0x64, 0x61, 0x66, 0x31, 0x63, 0x66, 0x39, 0x31, 0x36, 0x36, 0x33, 0x37, 0x32, 0x30, 0x33, 0x33, 0x61, 0x31, 0x63, 0x61, 0x33, 0x35, 0x66, 0x66, 0x33, 0x61, 0x33, 0x64, 0x39, 0x35, 0x30, 0x66, 0x34, 0x33, 0x64, 0x34, 0x62, 0x62, 0x39, 0x66, 0x65, 0x33, 0x61, 0x33, 0x35, 0x34, 0x32, 0x34, 0x36, 0x66, 0x39, 0x31, 0x61, 0x35, 0x31, 0x64, 0x38, 0x36, 0x62, 0x38, 0x39, 0x30, 0x66, 0x61, 0x32, 0x39, 0x65, 0x61, 0x38, 0x30, 0x37, 0x34, 0x66, 0x66, 0x33, 0x62, 0x63, 0x63, 0x65, 0x35, 0x66, 0x30, 0x64, 0x34, 0x38, 0x31, 0x66, 0x64, 0x34, 0x61, 0x37, 0x32, 0x33, 0x63, 0x34, 0x36, 0x33, 0x34, 0x38, 0x65, 0x33, 0x39, 0x34, 0x38, 0x61, 0x35, 0x66, 0x35, 0x36, 0x35, 0x30, 0x64, 0x37, 0x34, 0x63, 0x61, 0x36, 0x36, 0x64, 0x63, 0x61, 0x32, 0x65, 0x37, 0x31, 0x62, 0x33, 0x32, 0x63, 0x61, 0x61, 0x37, 0x33, 0x63, 0x32, 0x62, 0x35, 0x33, 0x61, 0x64, 0x39, 0x64, 0x35, 0x30, 0x62, 0x37, 0x33, 0x30, 0x35, 0x34, 0x62, 0x31, 0x66, 0x39, 0x37, 0x32, 0x30, 0x31, 0x61, 0x65, 0x61, 0x38, 0x37, 0x37, 0x64, 0x31, 0x31, 0x63, 0x65, 0x39, 0x31, 0x66, 0x35, 0x37, 0x61, 0x36, 0x37, 0x35, 0x66, 0x32, 0x35, 0x36, 0x33, 0x37, 0x33, 0x30, 0x38, 0x32, 0x66, 0x61, 0x31, 0x66, 0x35, 0x61, 0x61, 0x32, 0x36, 0x62, 0x62, 0x61, 0x31, 0x35, 0x35, 0x62, 0x65, 0x39, 0x64, 0x62, 0x63, 0x32, 0x35, 0x38, 0x37, 0x62, 0x31, 0x62, 0x31, 0x33, 0x32, 0x33, 0x31, 0x63, 0x65, 0x39, 0x37, 0x31, 0x36, 0x61, 0x61, 0x61, 0x32, 0x39, 0x30, 0x34, 0x64, 0x63, 0x61, 0x32, 0x38, 0x37, 0x34, 0x32, 0x38, 0x33, 0x34, 0x63, 0x61, 0x65, 0x33, 0x34, 0x32, 0x61, 0x33, 0x34, 0x37, 0x38, 0x33, 0x61, 0x30, 0x34, 0x35, 0x39, 0x34, 0x30, 0x31, 0x38, 0x35, 0x32, 0x39, 0x32, 0x63, 0x64, 0x30, 0x30, 0x35, 0x65, 0x32, 0x62, 0x66, 0x36, 0x61, 0x36, 0x37, 0x32, 0x31, 0x63, 0x32, 0x65, 0x30, 0x63, 0x31, 0x31, 0x39, 0x34, 0x64, 0x63, 0x64, 0x30, 0x63, 0x33, 0x30, 0x35, 0x66, 0x38, 0x39, 0x66, 0x38, 0x33, 0x34, 0x63, 0x30, 0x37, 0x66, 0x36, 0x66, 0x65, 0x33, 0x30, 0x62, 0x31, 0x34, 0x36, 0x30, 0x66, 0x65, 0x38, 0x31, 0x64, 0x36, 0x35, 0x34, 0x31, 0x31, 0x31, 0x65, 0x62, 0x61, 0x66, 0x39, 0x34, 0x34, 0x36, 0x63, 0x66, 0x30, 0x31, 0x36, 0x30, 0x39, 0x30, 0x33, 0x30, 0x31, 0x33, 0x66, 0x30, 0x36, 0x61, 0x63, 0x32, 0x33, 0x39, 0x65, 0x61, 0x36, 0x65, 0x64, 0x30, 0x64, 0x30, 0x65, 0x31, 0x35, 0x61, 0x63, 0x30, 0x65, 0x37, 0x61, 0x36, 0x62, 0x38, 0x63, 0x38, 0x31, 0x33, 0x34, 0x35, 0x61, 0x32, 0x38, 0x62, 0x65, 0x64, 0x32, 0x31, 0x36, 0x66, 0x33, 0x39, 0x61, 0x61, 0x61, 0x64, 0x65, 0x33, 0x38, 0x32, 0x65, 0x32, 0x37, 0x32, 0x65, 0x63, 0x37, 0x32, 0x64, 0x30, 0x36, 0x33, 0x35, 0x66, 0x61, 0x62, 0x32, 0x35, 0x65, 0x31, 0x34, 0x33, 0x31, 0x61, 0x39, 0x33, 0x33, 0x64, 0x37, 0x37, 0x66, 0x33, 0x63, 0x66, 0x35, 0x32, 0x34, 0x31, 0x39, 0x64, 0x61, 0x30, 0x35, 0x37, 0x32, 0x61, 0x64, 0x35, 0x64, 0x38, 0x64, 0x63, 0x63, 0x32, 0x65, 0x66, 0x62, 0x62, 0x33, 0x61, 0x31, 0x61, 0x32, 0x65, 0x36, 0x63, 0x37, 0x32, 0x38, 0x30, 0x30, 0x64, 0x38, 0x33, 0x34, 0x64, 0x31, 0x31, 0x36, 0x33, 0x30, 0x66, 0x30, 0x37, 0x37, 0x38, 0x62, 0x62, 0x65, 0x65, 0x37, 0x65, 0x35, 0x39, 0x31, 0x62, 0x34, 0x34, 0x37, 0x39, 0x34, 0x33, 0x33, 0x66, 0x62, 0x39, 0x66, 0x38, 0x32, 0x30, 0x66, 0x35, 0x36, 0x39, 0x62, 0x30, 0x62, 0x36, 0x36, 0x65, 0x34, 0x66, 0x38, 0x39, 0x35, 0x64, 0x37, 0x64, 0x63, 0x36, 0x34, 0x63, 0x64, 0x39, 0x31, 0x31, 0x33, 0x64, 0x63, 0x30, 0x37, 0x63, 0x64, 0x37, 0x33, 0x30, 0x39, 0x62, 0x39, 0x38, 0x61, 0x63, 0x66, 0x65, 0x64, 0x39, 0x61, 0x39, 0x65, 0x36, 0x36, 0x37, 0x37, 0x38, 0x66, 0x30, 0x34, 0x31, 0x63, 0x35, 0x64, 0x65, 0x62, 0x66, 0x64, 0x61, 0x66, 0x31, 0x34, 0x31, 0x33, 0x34, 0x65, 0x34, 0x30, 0x62, 0x39, 0x30, 0x34, 0x62, 0x61, 0x63, 0x65, 0x30, 0x30, 0x39, 0x35, 0x62, 0x35, 0x34, 0x65, 0x65, 0x30, 0x31, 0x38, 0x36, 0x39, 0x33, 0x34, 0x36, 0x39, 0x36, 0x66, 0x30, 0x39, 0x33, 0x36, 0x63, 0x31, 0x62, 0x32, 0x30, 0x64, 0x31, 0x38, 0x30, 0x38, 0x64, 0x39, 0x36, 0x31, 0x65, 0x31, 0x37, 0x61, 0x61, 0x65, 0x61, 0x65, 0x34, 0x64, 0x39, 0x37, 0x39, 0x32, 0x65, 0x33, 0x65, 0x36, 0x34, 0x30, 0x61, 0x33, 0x36, 0x36, 0x30, 0x62, 0x37, 0x30, 0x31, 0x35, 0x33, 0x33, 0x33, 0x30, 0x36, 0x63, 0x65, 0x37, 0x63, 0x62, 0x36, 0x65, 0x32, 0x34, 0x64, 0x37, 0x37, 0x37, 0x31, 0x30, 0x31, 0x38, 0x36, 0x34, 0x33, 0x30, 0x31, 0x33, 0x38, 0x64, 0x32, 0x66, 0x62, 0x36, 0x63, 0x37, 0x32, 0x31, 0x62, 0x63, 0x63, 0x62, 0x34, 0x64, 0x32, 0x66, 0x35, 0x36, 0x34, 0x33, 0x37, 0x34, 0x34, 0x64, 0x34, 0x62, 0x34, 0x34, 0x36, 0x35, 0x62, 0x37, 0x32, 0x63, 0x66, 0x38, 0x61, 0x63, 0x35, 0x33, 0x63, 0x61, 0x37, 0x33, 0x31, 0x31, 0x33, 0x63, 0x61, 0x32, 0x35, 0x31, 0x64, 0x36, 0x30, 0x33, 0x37, 0x35, 0x65, 0x63, 0x34, 0x30, 0x35, 0x33, 0x36, 0x31, 0x64, 0x61, 0x66, 0x38, 0x30, 0x31, 0x33, 0x39, 0x39, 0x65, 0x31, 0x37, 0x35, 0x30, 0x62, 0x33, 0x61, 0x62, 0x30, 0x38, 0x34, 0x35, 0x32, 0x35, 0x36, 0x66, 0x35, 0x64, 0x38, 0x37, 0x32, 0x37, 0x32, 0x62, 0x38, 0x31, 0x36, 0x31, 0x34, 0x65, 0x62, 0x34, 0x34, 0x30, 0x31, 0x61, 0x61, 0x36, 0x34, 0x38, 0x33, 0x37, 0x61, 0x36, 0x30, 0x37, 0x62, 0x65, 0x34, 0x65, 0x32, 0x37, 0x31, 0x37, 0x65, 0x39, 0x64, 0x63, 0x65, 0x38, 0x62, 0x31, 0x62, 0x36, 0x37, 0x34, 0x61, 0x39, 0x31, 0x65, 0x37, 0x39, 0x39, 0x34, 0x38, 0x64, 0x32, 0x63, 0x34, 0x65, 0x39, 0x36, 0x30, 0x31, 0x64, 0x36, 0x66, 0x34, 0x66, 0x66, 0x38, 0x37, 0x30, 0x33, 0x30, 0x65, 0x61, 0x62, 0x37, 0x39, 0x64, 0x36, 0x35, 0x65, 0x64, 0x37, 0x31, 0x30, 0x64, 0x37, 0x66, 0x38, 0x31, 0x64, 0x66, 0x37, 0x61, 0x63, 0x34, 0x35, 0x37, 0x37, 0x30, 0x65, 0x37, 0x61, 0x31, 0x65, 0x39, 0x64, 0x37, 0x37, 0x64, 0x61, 0x32, 0x38, 0x33, 0x38, 0x39, 0x36, 0x61, 0x33, 0x62, 0x61, 0x39, 0x61, 0x33, 0x37, 0x32, 0x61, 0x35, 0x31, 0x38, 0x61, 0x31, 0x61, 0x30, 0x62, 0x62, 0x64, 0x62, 0x66, 0x33, 0x34, 0x34, 0x32, 0x34, 0x37, 0x31, 0x33, 0x62, 0x37, 0x35, 0x35, 0x34, 0x66, 0x32, 0x39, 0x35, 0x39, 0x64, 0x32, 0x39, 0x33, 0x34, 0x34, 0x62, 0x32, 0x62, 0x36, 0x65, 0x37, 0x30, 0x64, 0x34, 0x37, 0x36, 0x66, 0x66, 0x66, 0x66, 0x33, 0x32, 0x30, 0x35, 0x66, 0x34, 0x63, 0x66, 0x34, 0x64, 0x37, 0x32, 0x37, 0x64, 0x61, 0x36, 0x30, 0x39, 0x66, 0x64, 0x33, 0x35, 0x30, 0x36, 0x31, 0x34, 0x30, 0x63, 0x63, 0x36, 0x36, 0x64, 0x36, 0x39, 0x35, 0x37, 0x33, 0x33, 0x38, 0x36, 0x33, 0x64, 0x37, 0x35, 0x61, 0x32, 0x62, 0x31, 0x65, 0x33, 0x38, 0x37, 0x66, 0x31, 0x62, 0x63, 0x33, 0x66, 0x64, 0x65, 0x33, 0x64, 0x39, 0x37, 0x38, 0x31, 0x66, 0x32, 0x35, 0x36, 0x32, 0x61, 0x65, 0x61, 0x35, 0x64, 0x32, 0x36, 0x34, 0x39, 0x34, 0x39, 0x39, 0x61, 0x37, 0x63, 0x38, 0x32, 0x33, 0x33, 0x66, 0x31, 0x31, 0x62, 0x31, 0x30, 0x32, 0x61, 0x36, 0x34, 0x63, 0x66, 0x39, 0x64, 0x32, 0x38, 0x62, 0x38, 0x31, 0x36, 0x37, 0x38, 0x39, 0x33, 0x63, 0x61, 0x63, 0x35, 0x38, 0x31, 0x62, 0x66, 0x31, 0x61, 0x62, 0x38, 0x61, 0x30, 0x32, 0x64, 0x64, 0x30, 0x34, 0x33, 0x35, 0x61, 0x33, 0x36, 0x37, 0x32, 0x36, 0x31, 0x33, 0x31, 0x66, 0x65, 0x35, 0x30, 0x61, 0x39, 0x37, 0x61, 0x34, 0x34, 0x64, 0x35, 0x37, 0x64, 0x33, 0x65, 0x65, 0x34, 0x63, 0x33, 0x39, 0x33, 0x34, 0x62, 0x32, 0x61, 0x38, 0x61, 0x65, 0x66, 0x30, 0x66, 0x66, 0x64, 0x62, 0x66, 0x65, 0x39, 0x35, 0x34, 0x38, 0x64, 0x37, 0x34, 0x38, 0x62, 0x36, 0x32, 0x37, 0x37, 0x33, 0x34, 0x32, 0x38, 0x62, 0x63, 0x65, 0x63, 0x37, 0x32, 0x33, 0x37, 0x35, 0x30, 0x38, 0x61, 0x38, 0x33, 0x64, 0x63, 0x64, 0x39, 0x61, 0x31, 0x62, 0x37, 0x62, 0x63, 0x62, 0x32, 0x65, 0x65, 0x35, 0x31, 0x32, 0x64, 0x62, 0x31, 0x32, 0x32, 0x38, 0x64, 0x38, 0x65, 0x66, 0x35, 0x34, 0x63, 0x36, 0x30, 0x63, 0x30, 0x32, 0x38, 0x31, 0x63, 0x35, 0x38, 0x31, 0x34, 0x33, 0x32, 0x31, 0x63, 0x36, 0x34, 0x35, 0x32, 0x35, 0x36, 0x38, 0x31, 0x35, 0x62, 0x34, 0x38, 0x66, 0x64, 0x62, 0x65, 0x31, 0x36, 0x37, 0x35, 0x66, 0x66, 0x64, 0x35, 0x62, 0x62, 0x65, 0x66, 0x34, 0x32, 0x36, 0x66, 0x31, 0x34, 0x64, 0x61, 0x63, 0x36, 0x34, 0x39, 0x30, 0x61, 0x61, 0x31, 0x34, 0x33, 0x37, 0x39, 0x62, 0x62, 0x66, 0x61, 0x35, 0x38, 0x34, 0x34, 0x36, 0x30, 0x38, 0x36, 0x61, 0x64, 0x33, 0x61, 0x36, 0x38, 0x65, 0x30, 0x33, 0x61, 0x34, 0x34, 0x37, 0x32, 0x66, 0x61, 0x32, 0x31, 0x35, 0x33, 0x63, 0x61, 0x35, 0x63, 0x38, 0x38, 0x61, 0x33, 0x33, 0x32, 0x63, 0x62, 0x34, 0x35, 0x30, 0x35, 0x35, 0x34, 0x36, 0x62, 0x61, 0x64, 0x35, 0x61, 0x31, 0x66, 0x34, 0x62, 0x33, 0x63, 0x35, 0x36, 0x31, 0x66, 0x34, 0x33, 0x38, 0x62, 0x35, 0x66, 0x36, 0x62, 0x33, 0x35, 0x63, 0x32, 0x31, 0x34, 0x62, 0x66, 0x39, 0x35, 0x33, 0x35, 0x64, 0x32, 0x36, 0x65, 0x62, 0x34, 0x65, 0x64, 0x66, 0x30, 0x38, 0x66, 0x34, 0x35, 0x33, 0x38, 0x38, 0x66, 0x39, 0x66, 0x34, 0x32, 0x66, 0x62, 0x35, 0x30, 0x66, 0x39, 0x62, 0x39, 0x35, 0x66, 0x30, 0x38, 0x39, 0x63, 0x35, 0x35, 0x63, 0x33, 0x33, 0x64, 0x61, 0x65, 0x38, 0x65, 0x36, 0x38, 0x32, 0x65, 0x65, 0x63, 0x34, 0x36, 0x35, 0x30, 0x31, 0x38, 0x37, 0x61, 0x64, 0x38, 0x39, 0x36, 0x64, 0x36, 0x37, 0x32, 0x38, 0x65, 0x64, 0x61, 0x66, 0x61, 0x39, 0x63, 0x38, 0x36, 0x61, 0x64, 0x39, 0x62, 0x66, 0x64, 0x64, 0x38, 0x33, 0x31, 0x34, 0x35, 0x33, 0x34, 0x32, 0x35, 0x30, 0x64, 0x38, 0x34, 0x39, 0x32, 0x63, 0x61, 0x65, 0x33, 0x34, 0x31, 0x62, 0x32, 0x64, 0x34, 0x61, 0x33, 0x32, 0x61, 0x35, 0x62, 0x38, 0x63, 0x30, 0x35, 0x33, 0x38, 0x39, 0x32, 0x64, 0x63, 0x35, 0x31, 0x30, 0x61, 0x31, 0x33, 0x36, 0x38, 0x61, 0x65, 0x32, 0x65, 0x64, 0x39, 0x38, 0x35, 0x66, 0x65, 0x30, 0x61, 0x35, 0x33, 0x32, 0x36, 0x35, 0x32, 0x63, 0x62, 0x63, 0x30, 0x31, 0x39, 0x32, 0x35, 0x34, 0x35, 0x63, 0x61, 0x65, 0x36, 0x31, 0x34, 0x30, 0x38, 0x33, 0x39, 0x62, 0x31, 0x66, 0x37, 0x66, 0x66, 0x33, 0x33, 0x38, 0x39, 0x38, 0x65, 0x30, 0x32, 0x35, 0x38, 0x34, 0x37, 0x62, 0x34, 0x65, 0x61, 0x31, 0x37, 0x66, 0x36, 0x63, 0x33, 0x37, 0x32, 0x64, 0x32, 0x39, 0x32, 0x66, 0x65, 0x63, 0x61, 0x65, 0x64, 0x31, 0x34, 0x61, 0x33, 0x62, 0x35, 0x64, 0x39, 0x64, 0x62, 0x34, 0x38, 0x64, 0x30, 0x35, 0x31, 0x65, 0x38, 0x31, 0x64, 0x38, 0x62, 0x34, 0x36, 0x39, 0x35, 0x33, 0x35, 0x66, 0x31, 0x34, 0x62, 0x63, 0x36, 0x64, 0x36, 0x63, 0x66, 0x66, 0x32, 0x34, 0x31, 0x35, 0x62, 0x36, 0x30, 0x37, 0x32, 0x32, 0x32, 0x66, 0x63, 0x66, 0x32, 0x32, 0x66, 0x31, 0x39, 0x30, 0x66, 0x32, 0x33, 0x36, 0x63, 0x62, 0x61, 0x33, 0x64, 0x31, 0x38, 0x38, 0x66, 0x62, 0x30, 0x65, 0x63, 0x61, 0x63, 0x65, 0x32, 0x63, 0x34, 0x63, 0x39, 0x65, 0x35, 0x35, 0x31, 0x64, 0x36, 0x36, 0x61, 0x38, 0x31, 0x37, 0x31, 0x32, 0x36, 0x65, 0x64, 0x64, 0x63, 0x66, 0x64, 0x65, 0x64, 0x37, 0x65, 0x39, 0x37, 0x32, 0x36, 0x39, 0x66, 0x31, 0x37, 0x36, 0x61, 0x37, 0x65, 0x39, 0x31, 0x65, 0x64, 0x61, 0x61, 0x65, 0x34, 0x62, 0x39, 0x30, 0x34, 0x66, 0x64, 0x36, 0x32, 0x33, 0x38, 0x39, 0x33, 0x37, 0x61, 0x33, 0x62, 0x37, 0x37, 0x39, 0x32, 0x63, 0x36, 0x38, 0x36, 0x34, 0x64, 0x66, 0x37, 0x34, 0x63, 0x66, 0x31, 0x32, 0x63, 0x35, 0x39, 0x30, 0x33, 0x38, 0x62, 0x65, 0x30, 0x61, 0x31, 0x63, 0x37, 0x36, 0x64, 0x37, 0x63, 0x64, 0x62, 0x63, 0x38, 0x31, 0x38, 0x63, 0x34, 0x61, 0x65, 0x39, 0x65, 0x63, 0x64, 0x64, 0x30, 0x35, 0x65, 0x30, 0x33, 0x35, 0x31, 0x62, 0x36, 0x35, 0x38, 0x36, 0x35, 0x63, 0x34, 0x30, 0x31, 0x33, 0x36, 0x37, 0x65, 0x65, 0x63, 0x66, 0x38, 0x62, 0x39, 0x38, 0x30, 0x34, 0x36, 0x37, 0x37, 0x61, 0x36, 0x61, 0x33, 0x35, 0x33, 0x36, 0x66, 0x66, 0x34, 0x33, 0x66, 0x36, 0x38, 0x34, 0x61, 0x61, 0x38, 0x32, 0x39, 0x35, 0x39, 0x32, 0x38, 0x35, 0x31, 0x33, 0x37, 0x31, 0x63, 0x62, 0x63, 0x63, 0x64, 0x31, 0x65, 0x64, 0x31, 0x39, 0x66, 0x37, 0x36, 0x31, 0x37, 0x65, 0x66, 0x33, 0x61, 0x61, 0x62, 0x38, 0x39, 0x37, 0x33, 0x39, 0x65, 0x34, 0x62, 0x38, 0x33, 0x61, 0x33, 0x65, 0x31, 0x36, 0x61, 0x61, 0x32, 0x66, 0x38, 0x36, 0x30, 0x35, 0x65, 0x32, 0x61, 0x31, 0x39, 0x66, 0x33, 0x33, 0x65, 0x31, 0x61, 0x61, 0x36, 0x34, 0x62, 0x38, 0x62, 0x33, 0x33, 0x61, 0x37, 0x61, 0x39, 0x38, 0x39, 0x65, 0x66, 0x62, 0x33, 0x31, 0x63, 0x36, 0x64, 0x31, 0x37, 0x31, 0x63, 0x31, 0x61, 0x32, 0x62, 0x66, 0x37, 0x33, 0x34, 0x36, 0x37, 0x31, 0x64, 0x64, 0x30, 0x36, 0x66, 0x61, 0x38, 0x30, 0x65, 0x36, 0x62, 0x62, 0x62, 0x32, 0x61, 0x31, 0x34, 0x64, 0x63, 0x36, 0x34, 0x64, 0x63, 0x35, 0x36, 0x30, 0x37, 0x61, 0x35, 0x30, 0x36, 0x62, 0x37, 0x39, 0x30, 0x39, 0x34, 0x65, 0x66, 0x34, 0x38, 0x39, 0x33, 0x32, 0x64, 0x61, 0x33, 0x66, 0x66, 0x35, 0x33, 0x65, 0x62, 0x37, 0x64, 0x35, 0x33, 0x36, 0x62, 0x32, 0x36, 0x62, 0x61, 0x38, 0x38, 0x64, 0x30, 0x39, 0x37, 0x31, 0x31, 0x38, 0x34, 0x38, 0x33, 0x66, 0x35, 0x30, 0x34, 0x32, 0x37, 0x38, 0x61, 0x37, 0x32, 0x32, 0x66, 0x35, 0x66, 0x32, 0x63, 0x33, 0x38, 0x31, 0x32, 0x63, 0x32, 0x62, 0x32, 0x38, 0x66, 0x31, 0x39, 0x37, 0x35, 0x36, 0x63, 0x65, 0x30, 0x32, 0x65, 0x64, 0x35, 0x36, 0x39, 0x36, 0x35, 0x32, 0x37, 0x30, 0x66, 0x39, 0x62, 0x35, 0x35, 0x63, 0x35, 0x38, 0x62, 0x62, 0x30, 0x30, 0x33, 0x62, 0x35, 0x63, 0x36, 0x63, 0x61, 0x61, 0x35, 0x65, 0x34, 0x31, 0x34, 0x62, 0x31, 0x37, 0x32, 0x33, 0x62, 0x63, 0x64, 0x30, 0x66, 0x35, 0x36, 0x31, 0x36, 0x32, 0x36, 0x39, 0x62, 0x31, 0x61, 0x38, 0x65, 0x38, 0x37, 0x32, 0x32, 0x65, 0x63, 0x62, 0x33, 0x33, 0x31, 0x66, 0x31, 0x38, 0x30, 0x62, 0x38, 0x64, 0x62, 0x65, 0x33, 0x38, 0x62, 0x33, 0x38, 0x36, 0x66, 0x32, 0x61, 0x65, 0x65, 0x39, 0x32, 0x62, 0x63, 0x34, 0x63, 0x32, 0x35, 0x36, 0x38, 0x33, 0x38, 0x31, 0x35, 0x37, 0x32, 0x62, 0x38, 0x35, 0x34, 0x36, 0x37, 0x30, 0x32, 0x66, 0x30, 0x63, 0x66, 0x65, 0x37, 0x64, 0x35, 0x34, 0x63, 0x39, 0x32, 0x63, 0x34, 0x66, 0x61, 0x36, 0x37, 0x36, 0x35, 0x61, 0x33, 0x31, 0x38, 0x36, 0x65, 0x61, 0x33, 0x66, 0x39, 0x35, 0x31, 0x65, 0x61, 0x35, 0x65, 0x35, 0x31, 0x38, 0x30, 0x38, 0x38, 0x37, 0x34, 0x31, 0x38, 0x35, 0x62, 0x35, 0x37, 0x36, 0x64, 0x37, 0x31, 0x32, 0x32, 0x32, 0x33, 0x30, 0x37, 0x37, 0x34, 0x66, 0x34, 0x35, 0x62, 0x31, 0x32, 0x61, 0x63, 0x30, 0x61, 0x37, 0x36, 0x36, 0x30, 0x64, 0x37, 0x38, 0x32, 0x38, 0x30, 0x35, 0x62, 0x63, 0x65, 0x63, 0x31, 0x62, 0x38, 0x63, 0x38, 0x61, 0x31, 0x65, 0x65, 0x38, 0x38, 0x35, 0x38, 0x63, 0x64, 0x36, 0x35, 0x65, 0x63, 0x36, 0x31, 0x62, 0x61, 0x62, 0x63, 0x63, 0x65, 0x36, 0x32, 0x37, 0x61, 0x31, 0x34, 0x62, 0x30, 0x33, 0x61, 0x61, 0x39, 0x35, 0x38, 0x64, 0x64, 0x62, 0x32, 0x39, 0x61, 0x66, 0x37, 0x35, 0x32, 0x35, 0x31, 0x30, 0x65, 0x66, 0x36, 0x31, 0x34, 0x36, 0x65, 0x36, 0x65, 0x33, 0x39, 0x33, 0x64, 0x34, 0x64, 0x36, 0x62, 0x62, 0x38, 0x66, 0x38, 0x63, 0x61, 0x66, 0x65, 0x31, 0x30, 0x34, 0x64, 0x33, 0x39, 0x66, 0x34, 0x64, 0x65, 0x35, 0x65, 0x33, 0x38, 0x31, 0x36, 0x37, 0x32, 0x39, 0x61, 0x31, 0x33, 0x37, 0x64, 0x38, 0x31, 0x66, 0x64, 0x34, 0x31, 0x38, 0x35, 0x66, 0x62, 0x64, 0x30, 0x35, 0x62, 0x36, 0x33, 0x64, 0x35, 0x62, 0x65, 0x64, 0x31, 0x31, 0x36, 0x35, 0x31, 0x32, 0x38, 0x31, 0x37, 0x64, 0x63, 0x31, 0x63, 0x66, 0x38, 0x64, 0x38, 0x66, 0x61, 0x64, 0x30, 0x37, 0x33, 0x37, 0x38, 0x61, 0x35, 0x63, 0x36, 0x37, 0x33, 0x33, 0x64, 0x62, 0x63, 0x37, 0x32, 0x37, 0x62, 0x36, 0x34, 0x38, 0x66, 0x66, 0x32, 0x32, 0x32, 0x30, 0x38, 0x30, 0x64, 0x36, 0x30, 0x64, 0x34, 0x32, 0x66, 0x66, 0x65, 0x64, 0x65, 0x35, 0x36, 0x65, 0x62, 0x64, 0x39, 0x33, 0x64, 0x35, 0x34, 0x34, 0x32, 0x30, 0x65, 0x32, 0x35, 0x32, 0x33, 0x62, 0x66, 0x64, 0x62, 0x62, 0x37, 0x36, 0x34, 0x63, 0x31, 0x37, 0x66, 0x36, 0x65, 0x64, 0x64, 0x33, 0x30, 0x38, 0x63, 0x37, 0x32, 0x62, 0x65, 0x32, 0x64, 0x35, 0x31, 0x65, 0x36, 0x31, 0x66, 0x63, 0x34, 0x62, 0x32, 0x63, 0x36, 0x30, 0x66, 0x37, 0x38, 0x33, 0x35, 0x32, 0x66, 0x35, 0x39, 0x66, 0x34, 0x66, 0x30, 0x64, 0x30, 0x36, 0x30, 0x65, 0x63, 0x66, 0x38, 0x64, 0x32, 0x31, 0x62, 0x35, 0x65, 0x66, 0x33, 0x38, 0x65, 0x32, 0x31, 0x38, 0x32, 0x30, 0x34, 0x36, 0x33, 0x37, 0x31, 0x66, 0x33, 0x62, 0x63, 0x37, 0x32, 0x63, 0x39, 0x62, 0x35, 0x37, 0x34, 0x31, 0x37, 0x66, 0x39, 0x33, 0x35, 0x35, 0x37, 0x35, 0x30, 0x39, 0x30, 0x61, 0x61, 0x39, 0x34, 0x38, 0x36, 0x33, 0x31, 0x35, 0x33, 0x32, 0x36, 0x36, 0x65, 0x64, 0x32, 0x30, 0x36, 0x39, 0x65, 0x38, 0x63, 0x32, 0x61, 0x61, 0x38, 0x33, 0x37, 0x34, 0x63, 0x61, 0x39, 0x66, 0x34, 0x61, 0x35, 0x39, 0x32, 0x32, 0x63, 0x34, 0x66, 0x66, 0x38, 0x37, 0x32, 0x36, 0x30, 0x62, 0x39, 0x34, 0x32, 0x31, 0x61, 0x31, 0x61, 0x66, 0x63, 0x37, 0x65, 0x30, 0x30, 0x30, 0x31, 0x65, 0x37, 0x31, 0x64, 0x62, 0x32, 0x63, 0x62, 0x30, 0x32, 0x38, 0x63, 0x35, 0x37, 0x34, 0x35, 0x32, 0x37, 0x34, 0x31, 0x37, 0x32, 0x61, 0x31, 0x35, 0x63, 0x64, 0x36, 0x64, 0x30, 0x63, 0x62, 0x30, 0x30, 0x36, 0x32, 0x65, 0x64, 0x39, 0x33, 0x39, 0x36, 0x66, 0x32, 0x37, 0x32, 0x30, 0x36, 0x35, 0x39, 0x63, 0x30, 0x63, 0x36, 0x34, 0x30, 0x66, 0x63, 0x65, 0x34, 0x39, 0x66, 0x30, 0x63, 0x61, 0x34, 0x61, 0x30, 0x35, 0x65, 0x33, 0x32, 0x30, 0x36, 0x33, 0x36, 0x36, 0x34, 0x62, 0x37, 0x32, 0x37, 0x66, 0x34, 0x64, 0x38, 0x62, 0x37, 0x31, 0x35, 0x38, 0x30, 0x65, 0x64, 0x35, 0x35, 0x61, 0x64, 0x38, 0x37, 0x39, 0x62, 0x30, 0x37, 0x62, 0x30, 0x30, 0x35, 0x37, 0x32, 0x62, 0x66, 0x65, 0x39, 0x37, 0x30, 0x65, 0x30, 0x66, 0x63, 0x33, 0x33, 0x62, 0x39, 0x35, 0x37, 0x61, 0x31, 0x39, 0x33, 0x62, 0x38, 0x65, 0x31, 0x31, 0x66, 0x39, 0x62, 0x62, 0x35, 0x32, 0x32, 0x32, 0x33, 0x30, 0x62, 0x61, 0x38, 0x62, 0x62, 0x34, 0x30, 0x64, 0x34, 0x33, 0x66, 0x36, 0x35, 0x62, 0x38, 0x36, 0x32, 0x64, 0x32, 0x35, 0x37, 0x37, 0x34, 0x64, 0x37, 0x65, 0x34, 0x30, 0x39, 0x38, 0x34, 0x66, 0x66, 0x65, 0x36, 0x65, 0x39, 0x64, 0x64, 0x63, 0x61, 0x65, 0x32, 0x63, 0x32, 0x64, 0x38, 0x36, 0x31, 0x34, 0x33, 0x34, 0x61, 0x34, 0x35, 0x66, 0x38, 0x65, 0x30, 0x34, 0x35, 0x64, 0x31, 0x66, 0x62, 0x33, 0x63, 0x62, 0x64, 0x36, 0x34, 0x34, 0x34, 0x61, 0x61, 0x65, 0x64, 0x37, 0x63, 0x30, 0x63, 0x66, 0x32, 0x66, 0x33, 0x62, 0x35, 0x61, 0x63, 0x61, 0x65, 0x37, 0x32, 0x64, 0x30, 0x61, 0x32, 0x66, 0x32, 0x63, 0x30, 0x64, 0x61, 0x31, 0x64, 0x35, 0x37, 0x35, 0x30, 0x65, 0x34, 0x39, 0x35, 0x38, 0x36, 0x65, 0x32, 0x61, 0x61, 0x37, 0x31, 0x61, 0x39, 0x37, 0x33, 0x32, 0x39, 0x63, 0x39, 0x31, 0x63, 0x63, 0x31, 0x61, 0x31, 0x37, 0x65, 0x33, 0x39, 0x65, 0x34, 0x33, 0x30, 0x63, 0x65, 0x61, 0x30, 0x30, 0x35, 0x65, 0x37, 0x39, 0x34, 0x66, 0x35, 0x30, 0x37, 0x63, 0x39, 0x63, 0x61, 0x31, 0x38, 0x62, 0x35, 0x61, 0x64, 0x31, 0x66, 0x61, 0x34, 0x37, 0x33, 0x30, 0x35, 0x62, 0x64, 0x35, 0x31, 0x33, 0x65, 0x37, 0x64, 0x39, 0x62, 0x39, 0x62, 0x33, 0x30, 0x66, 0x38, 0x35, 0x65, 0x38, 0x34, 0x35, 0x33, 0x63, 0x36, 0x63, 0x35, 0x33, 0x30, 0x32, 0x39, 0x61, 0x62, 0x65, 0x36, 0x65, 0x65, 0x32, 0x35, 0x39, 0x66, 0x38, 0x35, 0x65, 0x64, 0x37, 0x32, 0x36, 0x62, 0x63, 0x63, 0x32, 0x30, 0x37, 0x66, 0x35, 0x61, 0x62, 0x62, 0x61, 0x36, 0x38, 0x37, 0x35, 0x34, 0x35, 0x37, 0x35, 0x65, 0x37, 0x34, 0x64, 0x39, 0x32, 0x61, 0x36, 0x37, 0x39, 0x62, 0x63, 0x36, 0x34, 0x61, 0x37, 0x33, 0x62, 0x36, 0x38, 0x38, 0x62, 0x33, 0x33, 0x61, 0x63, 0x64, 0x61, 0x39, 0x61, 0x65, 0x33, 0x39, 0x38, 0x34, 0x36, 0x36, 0x33, 0x35, 0x36, 0x64, 0x32, 0x39, 0x31, 0x61, 0x66, 0x36, 0x64, 0x35, 0x36, 0x35, 0x36, 0x64, 0x65, 0x64, 0x61, 0x62, 0x31, 0x33, 0x61, 0x31, 0x37, 0x66, 0x66, 0x66, 0x62, 0x32, 0x38, 0x39, 0x31, 0x61, 0x38, 0x66, 0x38, 0x37, 0x34, 0x61, 0x37, 0x34, 0x38, 0x35, 0x63, 0x30, 0x30, 0x63, 0x33, 0x35, 0x32, 0x37, 0x64, 0x66, 0x66, 0x32, 0x30, 0x63, 0x34, 0x61, 0x61, 0x62, 0x62, 0x37, 0x37, 0x65, 0x30, 0x34, 0x37, 0x32, 0x64, 0x39, 0x61, 0x36, 0x33, 0x66, 0x36, 0x31, 0x38, 0x39, 0x66, 0x36, 0x61, 0x36, 0x36, 0x37, 0x30, 0x30, 0x32, 0x39, 0x31, 0x37, 0x66, 0x33, 0x36, 0x64, 0x30, 0x31, 0x39, 0x32, 0x37, 0x65, 0x62, 0x66, 0x65, 0x39, 0x63, 0x64, 0x35, 0x37, 0x34, 0x34, 0x65, 0x61, 0x66, 0x39, 0x63, 0x62, 0x31, 0x38, 0x38, 0x61, 0x61, 0x31, 0x61, 0x31, 0x64, 0x39, 0x64, 0x39, 0x32, 0x35, 0x37, 0x32, 0x36, 0x66, 0x38, 0x65, 0x34, 0x63, 0x64, 0x38, 0x30, 0x33, 0x66, 0x34, 0x31, 0x30, 0x35, 0x36, 0x65, 0x37, 0x62, 0x35, 0x35, 0x39, 0x62, 0x66, 0x37, 0x63, 0x34, 0x37, 0x32, 0x61, 0x37, 0x64, 0x62, 0x34, 0x61, 0x66, 0x33, 0x34, 0x65, 0x35, 0x35, 0x38, 0x32, 0x31, 0x34, 0x35, 0x63, 0x32, 0x64, 0x62, 0x63, 0x31, 0x33, 0x66, 0x32, 0x62, 0x32, 0x35, 0x61, 0x31, 0x35, 0x35, 0x36, 0x62, 0x33, 0x61, 0x33, 0x33, 0x35, 0x62, 0x64, 0x65, 0x32, 0x61, 0x34, 0x66, 0x61, 0x32, 0x33, 0x38, 0x38, 0x61, 0x35, 0x36, 0x63, 0x31, 0x66, 0x39, 0x38, 0x34, 0x66, 0x38, 0x33, 0x33, 0x36, 0x34, 0x62, 0x65, 0x62, 0x64, 0x61, 0x38, 0x33, 0x35, 0x38, 0x34, 0x37, 0x35, 0x34, 0x36, 0x36, 0x30, 0x33, 0x64, 0x39, 0x64, 0x64, 0x38, 0x37, 0x64, 0x38, 0x63, 0x38, 0x64, 0x38, 0x36, 0x36, 0x37, 0x39, 0x61, 0x31, 0x64, 0x35, 0x30, 0x34, 0x35, 0x64, 0x65, 0x63, 0x32, 0x65, 0x36, 0x64, 0x34, 0x64, 0x38, 0x62, 0x39, 0x33, 0x33, 0x35, 0x39, 0x32, 0x62, 0x35, 0x63, 0x64, 0x33, 0x39, 0x37, 0x61, 0x37, 0x38, 0x36, 0x32, 0x31, 0x62, 0x34, 0x33, 0x31, 0x66, 0x65, 0x38, 0x31, 0x30, 0x35, 0x66, 0x34, 0x66, 0x61, 0x66, 0x64, 0x34, 0x35, 0x31, 0x39, 0x64, 0x31, 0x36, 0x38, 0x37, 0x32, 0x66, 0x66, 0x66, 0x35, 0x34, 0x39, 0x33, 0x35, 0x31, 0x62, 0x66, 0x62, 0x34, 0x38, 0x35, 0x34, 0x61, 0x35, 0x66, 0x39, 0x31, 0x63, 0x63, 0x38, 0x34, 0x64, 0x64, 0x38, 0x36, 0x30, 0x65, 0x65, 0x64, 0x32, 0x32, 0x36, 0x31, 0x35, 0x38, 0x33, 0x39, 0x35, 0x63, 0x38, 0x35, 0x63, 0x30, 0x64, 0x39, 0x36, 0x65, 0x63, 0x66, 0x36, 0x33, 0x31, 0x35, 0x38, 0x36, 0x62, 0x37, 0x65, 0x37, 0x32, 0x32, 0x38, 0x33, 0x32, 0x39, 0x61, 0x36, 0x34, 0x66, 0x66, 0x33, 0x64, 0x65, 0x64, 0x62, 0x33, 0x32, 0x61, 0x61, 0x39, 0x63, 0x37, 0x33, 0x63, 0x61, 0x31, 0x30, 0x66, 0x65, 0x35, 0x64, 0x30, 0x32, 0x39, 0x64, 0x65, 0x32, 0x34, 0x39, 0x31, 0x66, 0x61, 0x32, 0x32, 0x39, 0x33, 0x38, 0x62, 0x38, 0x39, 0x39, 0x66, 0x37, 0x34, 0x65, 0x33, 0x39, 0x30, 0x31, 0x63, 0x65, 0x38, 0x37, 0x32, 0x39, 0x39, 0x37, 0x30, 0x65, 0x65, 0x39, 0x65, 0x32, 0x64, 0x36, 0x33, 0x66, 0x61, 0x61, 0x62, 0x64, 0x38, 0x37, 0x36, 0x39, 0x33, 0x35, 0x63, 0x61, 0x61, 0x61, 0x63, 0x65, 0x36, 0x66, 0x62, 0x39, 0x35, 0x34, 0x63, 0x63, 0x37, 0x32, 0x66, 0x64, 0x36, 0x61, 0x30, 0x35, 0x37, 0x31, 0x35, 0x64, 0x30, 0x34, 0x63, 0x38, 0x32, 0x36, 0x35, 0x61, 0x34, 0x31, 0x37, 0x61, 0x38, 0x32, 0x30, 0x65, 0x33, 0x63, 0x35, 0x31, 0x61, 0x38, 0x66, 0x36, 0x39, 0x37, 0x35, 0x36, 0x66, 0x39, 0x63, 0x33, 0x62, 0x34, 0x34, 0x36, 0x66, 0x34, 0x66, 0x66, 0x63, 0x32, 0x31, 0x35, 0x39, 0x64, 0x31, 0x31, 0x65, 0x66, 0x39, 0x36, 0x32, 0x37, 0x32, 0x30, 0x64, 0x63, 0x31, 0x64, 0x39, 0x37, 0x63, 0x39, 0x35, 0x62, 0x61, 0x33, 0x38, 0x36, 0x32, 0x30, 0x61, 0x63, 0x32, 0x32, 0x34, 0x37, 0x32, 0x34, 0x30, 0x30, 0x36, 0x32, 0x31, 0x38, 0x62, 0x62, 0x66, 0x63, 0x31, 0x38, 0x63, 0x34, 0x66, 0x32, 0x33, 0x39, 0x38, 0x35, 0x34, 0x31, 0x64, 0x30, 0x39, 0x33, 0x32, 0x63, 0x34, 0x37, 0x63, 0x65, 0x66, 0x37, 0x61, 0x31, 0x64, 0x65, 0x62, 0x63, 0x34, 0x36, 0x35, 0x63, 0x32, 0x39, 0x64, 0x36, 0x39, 0x30, 0x61, 0x39, 0x61, 0x61, 0x35, 0x35, 0x31, 0x33, 0x39, 0x34, 0x30, 0x33, 0x64, 0x38, 0x39, 0x30, 0x37, 0x66, 0x31, 0x35, 0x66, 0x34, 0x31, 0x33, 0x62, 0x30, 0x34, 0x36, 0x31, 0x36, 0x62, 0x37, 0x35, 0x33, 0x62, 0x65, 0x36, 0x65, 0x37, 0x31, 0x62, 0x35, 0x65, 0x63, 0x61, 0x30, 0x63, 0x62, 0x66, 0x39, 0x62, 0x37, 0x31, 0x65, 0x32, 0x30, 0x34, 0x39, 0x61, 0x36, 0x37, 0x39, 0x65, 0x37, 0x65, 0x64, 0x35, 0x34, 0x38, 0x38, 0x65, 0x31, 0x33, 0x65, 0x30, 0x37, 0x32, 0x62, 0x32, 0x30, 0x38, 0x35, 0x31, 0x63, 0x37, 0x65, 0x39, 0x31, 0x32, 0x31, 0x65, 0x33, 0x32, 0x35, 0x33, 0x63, 0x37, 0x31, 0x65, 0x65, 0x63, 0x39, 0x66, 0x33, 0x63, 0x36, 0x61, 0x33, 0x37, 0x61, 0x63, 0x35, 0x64, 0x35, 0x37, 0x33, 0x39, 0x33, 0x39, 0x66, 0x32, 0x66, 0x35, 0x31, 0x31, 0x30, 0x35, 0x32, 0x32, 0x38, 0x38, 0x62, 0x38, 0x30, 0x34, 0x35, 0x61, 0x64, 0x35, 0x37, 0x32, 0x33, 0x34, 0x34, 0x32, 0x65, 0x34, 0x61, 0x61, 0x32, 0x65, 0x33, 0x64, 0x64, 0x39, 0x62, 0x33, 0x35, 0x34, 0x34, 0x65, 0x66, 0x31, 0x38, 0x65, 0x36, 0x62, 0x61, 0x31, 0x66, 0x34, 0x61, 0x35, 0x64, 0x37, 0x38, 0x30, 0x62, 0x34, 0x37, 0x35, 0x61, 0x30, 0x61, 0x37, 0x33, 0x37, 0x61, 0x62, 0x66, 0x37, 0x63, 0x35, 0x35, 0x66, 0x34, 0x34, 0x65, 0x63, 0x36, 0x30, 0x31, 0x66, 0x37, 0x32, 0x65, 0x30, 0x35, 0x35, 0x31, 0x39, 0x63, 0x30, 0x37, 0x39, 0x38, 0x61, 0x31, 0x64, 0x33, 0x66, 0x63, 0x31, 0x31, 0x64, 0x32, 0x37, 0x66, 0x34, 0x61, 0x35, 0x35, 0x30, 0x37, 0x30, 0x34, 0x37, 0x31, 0x65, 0x65, 0x30, 0x62, 0x38, 0x33, 0x38, 0x31, 0x65, 0x62, 0x36, 0x65, 0x62, 0x34, 0x66, 0x63, 0x65, 0x30, 0x38, 0x37, 0x62, 0x64, 0x32, 0x63, 0x30, 0x32, 0x64, 0x31, 0x66, 0x33, 0x34, 0x66, 0x38, 0x66, 0x32, 0x34, 0x65, 0x30, 0x31, 0x66, 0x66, 0x39, 0x33, 0x64, 0x32, 0x35, 0x35, 0x34, 0x35, 0x61, 0x30, 0x61, 0x36, 0x36, 0x61, 0x38, 0x35, 0x61, 0x30, 0x64, 0x31, 0x35, 0x35, 0x39, 0x62, 0x33, 0x32, 0x62, 0x61, 0x31, 0x37, 0x34, 0x65, 0x61, 0x65, 0x66, 0x31, 0x39, 0x35, 0x35, 0x61, 0x33, 0x66, 0x32, 0x39, 0x62, 0x30, 0x63, 0x32, 0x36, 0x35, 0x64, 0x37, 0x37, 0x32, 0x66, 0x30, 0x33, 0x61, 0x35, 0x35, 0x36, 0x38, 0x35, 0x66, 0x38, 0x30, 0x38, 0x35, 0x64, 0x37, 0x37, 0x31, 0x36, 0x31, 0x65, 0x64, 0x30, 0x62, 0x62, 0x66, 0x38, 0x65, 0x61, 0x30, 0x39, 0x31, 0x38, 0x33, 0x66, 0x39, 0x37, 0x37, 0x33, 0x32, 0x35, 0x38, 0x38, 0x31, 0x32, 0x34, 0x61, 0x65, 0x61, 0x32, 0x64, 0x30, 0x33, 0x34, 0x32, 0x61, 0x34, 0x31, 0x37, 0x32, 0x36, 0x31, 0x37, 0x32, 0x34, 0x63, 0x62, 0x32, 0x66, 0x35, 0x38, 0x34, 0x62, 0x32, 0x64, 0x31, 0x65, 0x31, 0x64, 0x36, 0x31, 0x38, 0x30, 0x61, 0x33, 0x66, 0x62, 0x34, 0x64, 0x39, 0x38, 0x32, 0x32, 0x30, 0x37, 0x64, 0x62, 0x34, 0x66, 0x32, 0x39, 0x64, 0x34, 0x64, 0x63, 0x62, 0x31, 0x36, 0x30, 0x34, 0x35, 0x62, 0x39, 0x30, 0x34, 0x36, 0x33, 0x64, 0x33, 0x36, 0x38, 0x34, 0x64, 0x66, 0x31, 0x31, 0x37, 0x32, 0x32, 0x61, 0x64, 0x61, 0x64, 0x34, 0x65, 0x64, 0x64, 0x32, 0x39, 0x38, 0x31, 0x31, 0x65, 0x37, 0x33, 0x30, 0x39, 0x33, 0x35, 0x35, 0x31, 0x35, 0x61, 0x38, 0x61, 0x39, 0x33, 0x61, 0x36, 0x61, 0x34, 0x63, 0x31, 0x66, 0x32, 0x63, 0x39, 0x39, 0x36, 0x62, 0x33, 0x30, 0x63, 0x64, 0x30, 0x32, 0x31, 0x65, 0x31, 0x36, 0x62, 0x35, 0x34, 0x37, 0x36, 0x63, 0x62, 0x66, 0x36, 0x64, 0x30, 0x37, 0x34, 0x63, 0x39, 0x38, 0x30, 0x37, 0x30, 0x38, 0x39, 0x64, 0x31, 0x34, 0x63, 0x65, 0x31, 0x65, 0x32, 0x34, 0x36, 0x37, 0x64, 0x34, 0x39, 0x35, 0x37, 0x34, 0x35, 0x66, 0x63, 0x34, 0x63, 0x37, 0x31, 0x36, 0x63, 0x36, 0x36, 0x33, 0x39, 0x30, 0x32, 0x66, 0x36, 0x35, 0x31, 0x35, 0x36, 0x30, 0x33, 0x64, 0x36, 0x39, 0x38, 0x31, 0x30, 0x37, 0x36, 0x38, 0x65, 0x66, 0x65, 0x38, 0x37, 0x32, 0x63, 0x32, 0x31, 0x61, 0x31, 0x39, 0x39, 0x33, 0x66, 0x66, 0x34, 0x34, 0x33, 0x39, 0x36, 0x39, 0x64, 0x36, 0x61, 0x62, 0x66, 0x34, 0x36, 0x39, 0x62, 0x63, 0x64, 0x37, 0x38, 0x32, 0x65, 0x30, 0x66, 0x35, 0x39, 0x31, 0x63, 0x65, 0x30, 0x31, 0x31, 0x62, 0x63, 0x63, 0x37, 0x37, 0x39, 0x33, 0x61, 0x61, 0x62, 0x38, 0x36, 0x35, 0x31, 0x62, 0x65, 0x33, 0x36, 0x64, 0x35, 0x65, 0x30, 0x39, 0x39, 0x39, 0x33, 0x34, 0x37, 0x64, 0x38, 0x32, 0x39, 0x34, 0x31, 0x39, 0x62, 0x64, 0x35, 0x38, 0x30, 0x63, 0x33, 0x38, 0x61, 0x37, 0x34, 0x35, 0x37, 0x33, 0x39, 0x37, 0x33, 0x34, 0x30, 0x66, 0x32, 0x35, 0x34, 0x65, 0x61, 0x37, 0x31, 0x38, 0x33, 0x36, 0x64, 0x32, 0x30, 0x64, 0x30, 0x34, 0x62, 0x32, 0x33, 0x61, 0x38, 0x65, 0x38, 0x62, 0x61, 0x38, 0x30, 0x39, 0x64, 0x33, 0x31, 0x36, 0x37, 0x66, 0x34, 0x63, 0x39, 0x39, 0x39, 0x33, 0x63, 0x63, 0x35, 0x35, 0x38, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x33, 0x36, 0x62, 0x65, 0x37, 0x37, 0x35, 0x35, 0x34, 0x30, 0x66, 0x33, 0x34, 0x61, 0x37, 0x33, 0x30, 0x36, 0x39, 0x32, 0x64, 0x38, 0x38, 0x66, 0x38, 0x31, 0x65, 0x66, 0x32, 0x31, 0x30, 0x34, 0x61, 0x34, 0x38, 0x64, 0x66, 0x39, 0x37, 0x34, 0x37, 0x66, 0x64, 0x37, 0x32, 0x32, 0x66, 0x65, 0x31, 0x36, 0x62, 0x32, 0x38, 0x32, 0x36, 0x63, 0x36, 0x34, 0x66, 0x32, 0x39, 0x62, 0x37, 0x35, 0x37, 0x38, 0x36, 0x35, 0x30, 0x33, 0x30, 0x34, 0x34, 0x34, 0x31, 0x38, 0x36, 0x61, 0x65, 0x61, 0x33, 0x30, 0x33, 0x33, 0x33, 0x33, 0x62, 0x38, 0x32, 0x38, 0x30, 0x30, 0x31, 0x30, 0x62, 0x35, 0x38, 0x66, 0x37, 0x63, 0x64, 0x35, 0x66, 0x61, 0x64, 0x35, 0x32, 0x37, 0x32, 0x33, 0x38, 0x63, 0x36, 0x65, 0x31, 0x64, 0x62, 0x30, 0x35, 0x38, 0x64, 0x32, 0x36, 0x64, 0x33, 0x32, 0x37, 0x66, 0x36, 0x30, 0x61, 0x64, 0x31, 0x37, 0x31, 0x63, 0x32, 0x35, 0x61, 0x36, 0x38, 0x36, 0x31, 0x64, 0x66, 0x38, 0x62, 0x37, 0x65, 0x62, 0x38, 0x38, 0x36, 0x65, 0x30, 0x63, 0x35, 0x33, 0x66, 0x37, 0x63, 0x37, 0x63, 0x30, 0x63, 0x38, 0x33, 0x65, 0x62, 0x30, 0x39, 0x35, 0x36, 0x61, 0x65, 0x31, 0x35, 0x64, 0x33, 0x65, 0x64, 0x62, 0x30, 0x33, 0x63, 0x39, 0x36, 0x34, 0x30, 0x31, 0x35, 0x63, 0x63, 0x39, 0x62, 0x30, 0x66, 0x62, 0x32, 0x63, 0x30, 0x34, 0x35, 0x36, 0x37, 0x35, 0x65, 0x33, 0x32, 0x65, 0x66, 0x34, 0x61, 0x66, 0x63, 0x34, 0x65, 0x63, 0x39, 0x33, 0x38, 0x36, 0x65, 0x63, 0x63, 0x63, 0x62, 0x63, 0x37, 0x63, 0x38, 0x34, 0x61, 0x63, 0x35, 0x37, 0x32, 0x35, 0x66, 0x32, 0x64, 0x64, 0x38, 0x62, 0x35, 0x64, 0x61, 0x61, 0x66, 0x65, 0x30, 0x39, 0x64, 0x36, 0x32, 0x62, 0x65, 0x38, 0x61, 0x62, 0x34, 0x35, 0x35, 0x66, 0x61, 0x37, 0x37, 0x38, 0x63, 0x39, 0x31, 0x32, 0x33, 0x30, 0x37, 0x36, 0x37, 0x66, 0x39, 0x39, 0x65, 0x61, 0x62, 0x37, 0x34, 0x35, 0x33, 0x64, 0x33, 0x32, 0x37, 0x61, 0x30, 0x32, 0x38, 0x37, 0x66, 0x37, 0x31, 0x37, 0x32, 0x30, 0x63, 0x30, 0x62, 0x30, 0x34, 0x63, 0x30, 0x36, 0x33, 0x62, 0x33, 0x37, 0x62, 0x33, 0x61, 0x62, 0x65, 0x63, 0x62, 0x35, 0x33, 0x30, 0x63, 0x33, 0x39, 0x31, 0x36, 0x39, 0x62, 0x66, 0x39, 0x65, 0x34, 0x30, 0x33, 0x38, 0x35, 0x31, 0x65, 0x38, 0x64, 0x31, 0x31, 0x35, 0x32, 0x34, 0x64, 0x35, 0x33, 0x31, 0x39, 0x66, 0x62, 0x33, 0x66, 0x35, 0x65, 0x33, 0x34, 0x32, 0x30, 0x37, 0x32, 0x35, 0x64, 0x66, 0x30, 0x33, 0x64, 0x63, 0x64, 0x64, 0x39, 0x66, 0x38, 0x35, 0x39, 0x64, 0x36, 0x31, 0x66, 0x39, 0x38, 0x37, 0x62, 0x66, 0x34, 0x33, 0x36, 0x63, 0x31, 0x32, 0x65, 0x39, 0x33, 0x38, 0x36, 0x38, 0x62, 0x31, 0x38, 0x66, 0x63, 0x38, 0x66, 0x61, 0x63, 0x64, 0x66, 0x66, 0x65, 0x61, 0x38, 0x31, 0x35, 0x64, 0x63, 0x34, 0x39, 0x65, 0x62, 0x62, 0x32, 0x37, 0x62, 0x34, 0x36, 0x31, 0x37, 0x65, 0x66, 0x33, 0x61, 0x32, 0x38, 0x31, 0x61, 0x37, 0x66, 0x31, 0x34, 0x37, 0x31, 0x65, 0x66, 0x34, 0x61, 0x63, 0x31, 0x66, 0x31, 0x64, 0x33, 0x38, 0x65, 0x62, 0x34, 0x62, 0x37, 0x61, 0x30, 0x66, 0x64, 0x33, 0x33, 0x37, 0x35, 0x33, 0x32, 0x65, 0x36, 0x30, 0x39, 0x34, 0x35, 0x63, 0x62, 0x35, 0x38, 0x30, 0x64, 0x32, 0x32, 0x63, 0x62, 0x31, 0x30, 0x39, 0x62, 0x37, 0x32, 0x30, 0x61, 0x63, 0x39, 0x62, 0x39, 0x35, 0x64, 0x63, 0x34, 0x31, 0x32, 0x36, 0x66, 0x31, 0x31, 0x39, 0x61, 0x31, 0x65, 0x38, 0x64, 0x31, 0x63, 0x33, 0x33, 0x31, 0x37, 0x65, 0x66, 0x39, 0x66, 0x62, 0x64, 0x34, 0x65, 0x34, 0x36, 0x30, 0x38, 0x37, 0x35, 0x39, 0x39, 0x38, 0x34, 0x35, 0x32, 0x31, 0x31, 0x30, 0x65, 0x64, 0x30, 0x37, 0x36, 0x37, 0x30, 0x34, 0x35, 0x37, 0x39, 0x37, 0x32, 0x34, 0x30, 0x31, 0x38, 0x34, 0x32, 0x34, 0x66, 0x63, 0x39, 0x34, 0x63, 0x65, 0x39, 0x61, 0x39, 0x63, 0x63, 0x37, 0x63, 0x61, 0x31, 0x31, 0x61, 0x66, 0x31, 0x65, 0x61, 0x63, 0x61, 0x62, 0x62, 0x63, 0x64, 0x30, 0x63, 0x34, 0x62, 0x32, 0x66, 0x36, 0x39, 0x34, 0x35, 0x37, 0x66, 0x65, 0x37, 0x62, 0x37, 0x38, 0x63, 0x62, 0x62, 0x64, 0x37, 0x30, 0x33, 0x31, 0x36, 0x61, 0x35, 0x34, 0x34, 0x33, 0x63, 0x36, 0x33, 0x63, 0x31, 0x38, 0x31, 0x38, 0x38, 0x64, 0x30, 0x39, 0x39, 0x30, 0x34, 0x33, 0x38, 0x66, 0x33, 0x62, 0x64, 0x61, 0x37, 0x36, 0x32, 0x34, 0x36, 0x34, 0x63, 0x63, 0x35, 0x36, 0x30, 0x65, 0x33, 0x32, 0x36, 0x39, 0x66, 0x62, 0x62, 0x62, 0x66, 0x61, 0x30, 0x35, 0x34, 0x35, 0x35, 0x38, 0x63, 0x33, 0x63, 0x38, 0x38, 0x35, 0x64, 0x36, 0x65, 0x37, 0x32, 0x37, 0x32, 0x61, 0x64, 0x61, 0x30, 0x35, 0x61, 0x35, 0x32, 0x61, 0x64, 0x30, 0x30, 0x38, 0x38, 0x33, 0x34, 0x62, 0x38, 0x30, 0x62, 0x33, 0x33, 0x37, 0x31, 0x36, 0x65, 0x61, 0x32, 0x65, 0x62, 0x33, 0x37, 0x35, 0x62, 0x65, 0x37, 0x30, 0x63, 0x62, 0x31, 0x39, 0x35, 0x65, 0x39, 0x34, 0x38, 0x65, 0x35, 0x39, 0x66, 0x32, 0x62, 0x30, 0x63, 0x31, 0x34, 0x33, 0x35, 0x35, 0x33, 0x32, 0x64, 0x37, 0x32, 0x33, 0x62, 0x64, 0x34, 0x37, 0x37, 0x31, 0x32, 0x32, 0x36, 0x64, 0x39, 0x31, 0x65, 0x64, 0x35, 0x32, 0x30, 0x33, 0x34, 0x37, 0x36, 0x30, 0x66, 0x36, 0x62, 0x66, 0x38, 0x65, 0x30, 0x63, 0x61, 0x64, 0x36, 0x39, 0x33, 0x33, 0x32, 0x34, 0x65, 0x35, 0x34, 0x33, 0x64, 0x36, 0x64, 0x31, 0x32, 0x35, 0x61, 0x39, 0x61, 0x31, 0x64, 0x38, 0x38, 0x66, 0x39, 0x63, 0x65, 0x66, 0x32, 0x35, 0x63, 0x32, 0x37, 0x66, 0x64, 0x34, 0x32, 0x65, 0x39, 0x64, 0x65, 0x35, 0x39, 0x35, 0x33, 0x37, 0x61, 0x33, 0x36, 0x65, 0x30, 0x36, 0x61, 0x62, 0x66, 0x33, 0x63, 0x65, 0x37, 0x38, 0x31, 0x30, 0x31, 0x66, 0x62, 0x63, 0x30, 0x63, 0x65, 0x39, 0x36, 0x39, 0x34, 0x35, 0x30, 0x66, 0x33, 0x32, 0x37, 0x66, 0x36, 0x36, 0x36, 0x64, 0x32, 0x34, 0x36, 0x63, 0x62, 0x30, 0x38, 0x61, 0x62, 0x35, 0x66, 0x30, 0x63, 0x38, 0x33, 0x64, 0x61, 0x62, 0x64, 0x61, 0x65, 0x35, 0x32, 0x32, 0x31, 0x37, 0x34, 0x32, 0x30, 0x35, 0x64, 0x61, 0x66, 0x63, 0x32, 0x35, 0x32, 0x62, 0x36, 0x33, 0x38, 0x65, 0x65, 0x65, 0x32, 0x66, 0x35, 0x30, 0x36, 0x66, 0x30, 0x39, 0x39, 0x65, 0x33, 0x63, 0x65, 0x36, 0x39, 0x66, 0x62, 0x32, 0x36, 0x61, 0x39, 0x36, 0x34, 0x38, 0x38, 0x32, 0x32, 0x62, 0x37, 0x37, 0x32, 0x63, 0x33, 0x33, 0x30, 0x34, 0x66, 0x30, 0x35, 0x39, 0x36, 0x37, 0x66, 0x39, 0x38, 0x30, 0x34, 0x31, 0x35, 0x62, 0x36, 0x31, 0x35, 0x33, 0x36, 0x36, 0x64, 0x38, 0x30, 0x61, 0x35, 0x34, 0x66, 0x35, 0x33, 0x61, 0x33, 0x36, 0x33, 0x62, 0x38, 0x31, 0x35, 0x34, 0x37, 0x38, 0x65, 0x33, 0x63, 0x37, 0x34, 0x31, 0x38, 0x64, 0x62, 0x63, 0x35, 0x34, 0x38, 0x33, 0x34, 0x34, 0x36, 0x37, 0x32, 0x35, 0x64, 0x38, 0x39, 0x63, 0x63, 0x37, 0x32, 0x33, 0x30, 0x61, 0x31, 0x36, 0x37, 0x35, 0x36, 0x34, 0x33, 0x63, 0x35, 0x64, 0x35, 0x63, 0x35, 0x30, 0x63, 0x66, 0x36, 0x32, 0x34, 0x31, 0x37, 0x61, 0x36, 0x39, 0x38, 0x32, 0x36, 0x38, 0x31, 0x39, 0x38, 0x62, 0x31, 0x64, 0x63, 0x64, 0x37, 0x61, 0x30, 0x37, 0x30, 0x31, 0x66, 0x37, 0x35, 0x38, 0x37, 0x65, 0x35, 0x33, 0x65, 0x34, 0x34, 0x39, 0x63, 0x61, 0x36, 0x30, 0x32, 0x31, 0x66, 0x65, 0x39, 0x65, 0x39, 0x65, 0x30, 0x33, 0x31, 0x65, 0x66, 0x64, 0x38, 0x31, 0x63, 0x30, 0x62, 0x35, 0x32, 0x33, 0x64, 0x30, 0x33, 0x32, 0x37, 0x34, 0x35, 0x30, 0x37, 0x66, 0x37, 0x38, 0x30, 0x33, 0x38, 0x34, 0x63, 0x63, 0x30, 0x32, 0x61, 0x62, 0x39, 0x61, 0x61, 0x31, 0x34, 0x65, 0x31, 0x35, 0x37, 0x36, 0x61, 0x39, 0x35, 0x37, 0x32, 0x65, 0x37, 0x64, 0x31, 0x35, 0x34, 0x34, 0x30, 0x64, 0x62, 0x37, 0x63, 0x66, 0x30, 0x37, 0x62, 0x31, 0x38, 0x33, 0x64, 0x33, 0x39, 0x37, 0x38, 0x36, 0x35, 0x34, 0x37, 0x66, 0x37, 0x65, 0x65, 0x64, 0x61, 0x34, 0x61, 0x35, 0x39, 0x32, 0x61, 0x61, 0x31, 0x36, 0x61, 0x37, 0x33, 0x64, 0x37, 0x61, 0x30, 0x35, 0x35, 0x39, 0x37, 0x33, 0x37, 0x65, 0x39, 0x38, 0x35, 0x66, 0x33, 0x31, 0x30, 0x65, 0x61, 0x34, 0x34, 0x36, 0x31, 0x30, 0x62, 0x32, 0x65, 0x65, 0x62, 0x62, 0x39, 0x34, 0x33, 0x39, 0x34, 0x32, 0x65, 0x30, 0x31, 0x38, 0x30, 0x33, 0x62, 0x31, 0x30, 0x63, 0x62, 0x34, 0x33, 0x37, 0x30, 0x32, 0x63, 0x33, 0x37, 0x31, 0x39, 0x32, 0x30, 0x31, 0x37, 0x39, 0x64, 0x33, 0x39, 0x33, 0x64, 0x62, 0x32, 0x63, 0x63, 0x31, 0x65, 0x38, 0x33, 0x65, 0x31, 0x36, 0x39, 0x37, 0x32, 0x39, 0x66, 0x64, 0x64, 0x30, 0x63, 0x64, 0x37, 0x61, 0x36, 0x33, 0x32, 0x31, 0x39, 0x36, 0x62, 0x61, 0x31, 0x63, 0x66, 0x36, 0x38, 0x39, 0x36, 0x39, 0x61, 0x32, 0x62, 0x37, 0x66, 0x64, 0x34, 0x31, 0x33, 0x63, 0x65, 0x39, 0x30, 0x36, 0x32, 0x33, 0x62, 0x65, 0x64, 0x36, 0x62, 0x34, 0x32, 0x30, 0x36, 0x64, 0x61, 0x39, 0x30, 0x64, 0x36, 0x37, 0x35, 0x36, 0x34, 0x64, 0x34, 0x37, 0x32, 0x37, 0x61, 0x38, 0x30, 0x36, 0x39, 0x65, 0x65, 0x38, 0x31, 0x38, 0x39, 0x61, 0x35, 0x62, 0x38, 0x65, 0x37, 0x61, 0x66, 0x63, 0x63, 0x62, 0x33, 0x33, 0x64, 0x35, 0x64, 0x66, 0x64, 0x34, 0x38, 0x33, 0x39, 0x36, 0x36, 0x39, 0x37, 0x61, 0x61, 0x34, 0x30, 0x64, 0x30, 0x65, 0x35, 0x35, 0x30, 0x65, 0x62, 0x33, 0x32, 0x64, 0x38, 0x66, 0x33, 0x33, 0x35, 0x38, 0x39, 0x39, 0x34, 0x34, 0x35, 0x32, 0x38, 0x33, 0x65, 0x62, 0x61, 0x62, 0x66, 0x36, 0x66, 0x34, 0x32, 0x64, 0x31, 0x31, 0x62, 0x66, 0x65, 0x37, 0x31, 0x37, 0x36, 0x61, 0x64, 0x36, 0x38, 0x65, 0x30, 0x66, 0x65, 0x35, 0x38, 0x63, 0x38, 0x38, 0x66, 0x30, 0x38, 0x61, 0x30, 0x61, 0x32, 0x38, 0x63, 0x36, 0x35, 0x35, 0x64, 0x64, 0x32, 0x37, 0x32, 0x61, 0x66, 0x36, 0x62, 0x64, 0x61, 0x31, 0x64, 0x64, 0x65, 0x37, 0x32, 0x34, 0x33, 0x64, 0x37, 0x64, 0x64, 0x31, 0x62, 0x31, 0x35, 0x64, 0x37, 0x65, 0x35, 0x30, 0x61, 0x35, 0x61, 0x31, 0x61, 0x32, 0x61, 0x34, 0x31, 0x62, 0x65, 0x32, 0x35, 0x38, 0x31, 0x64, 0x61, 0x32, 0x38, 0x36, 0x38, 0x30, 0x61, 0x64, 0x62, 0x32, 0x37, 0x62, 0x30, 0x39, 0x34, 0x63, 0x64, 0x30, 0x33, 0x64, 0x31, 0x36, 0x64, 0x66, 0x30, 0x66, 0x62, 0x32, 0x37, 0x35, 0x65, 0x30, 0x32, 0x31, 0x61, 0x30, 0x37, 0x36, 0x34, 0x38, 0x32, 0x61, 0x66, 0x35, 0x30, 0x63, 0x37, 0x31, 0x30, 0x63, 0x31, 0x35, 0x66, 0x66, 0x39, 0x33, 0x61, 0x62, 0x30, 0x63, 0x35, 0x33, 0x61, 0x63, 0x36, 0x39, 0x65, 0x34, 0x61, 0x37, 0x31, 0x61, 0x33, 0x64, 0x64, 0x34, 0x38, 0x36, 0x65, 0x62, 0x39, 0x30, 0x36, 0x35, 0x63, 0x62, 0x66, 0x34, 0x62, 0x31, 0x34, 0x32, 0x65, 0x31, 0x32, 0x37, 0x32, 0x39, 0x61, 0x62, 0x38, 0x30, 0x37, 0x61, 0x33, 0x33, 0x66, 0x37, 0x30, 0x39, 0x39, 0x39, 0x37, 0x30, 0x32, 0x63, 0x64, 0x63, 0x34, 0x34, 0x30, 0x66, 0x31, 0x32, 0x35, 0x61, 0x36, 0x61, 0x37, 0x31, 0x35, 0x31, 0x65, 0x34, 0x31, 0x34, 0x38, 0x33, 0x31, 0x65, 0x61, 0x32, 0x34, 0x39, 0x31, 0x30, 0x37, 0x30, 0x37, 0x64, 0x36, 0x39, 0x31, 0x31, 0x61, 0x36, 0x63, 0x35, 0x37, 0x32, 0x39, 0x66, 0x35, 0x34, 0x30, 0x63, 0x39, 0x34, 0x31, 0x34, 0x64, 0x36, 0x31, 0x36, 0x35, 0x38, 0x64, 0x38, 0x31, 0x32, 0x63, 0x64, 0x38, 0x35, 0x37, 0x66, 0x39, 0x65, 0x30, 0x34, 0x37, 0x66, 0x37, 0x39, 0x31, 0x36, 0x65, 0x62, 0x66, 0x32, 0x63, 0x37, 0x63, 0x30, 0x61, 0x30, 0x35, 0x62, 0x36, 0x38, 0x31, 0x34, 0x66, 0x33, 0x63, 0x38, 0x32, 0x63, 0x64, 0x66, 0x63, 0x32, 0x62, 0x31, 0x38, 0x34, 0x62, 0x61, 0x36, 0x30, 0x38, 0x34, 0x35, 0x63, 0x39, 0x33, 0x63, 0x33, 0x31, 0x66, 0x31, 0x64, 0x33, 0x34, 0x36, 0x35, 0x30, 0x33, 0x37, 0x34, 0x35, 0x62, 0x30, 0x38, 0x34, 0x63, 0x61, 0x31, 0x66, 0x35, 0x31, 0x35, 0x31, 0x65, 0x61, 0x34, 0x38, 0x35, 0x66, 0x62, 0x36, 0x37, 0x65, 0x61, 0x35, 0x35, 0x63, 0x39, 0x62, 0x33, 0x31, 0x39, 0x34, 0x30, 0x39, 0x30, 0x38, 0x37, 0x32, 0x65, 0x35, 0x64, 0x63, 0x62, 0x66, 0x35, 0x36, 0x36, 0x37, 0x66, 0x62, 0x66, 0x37, 0x61, 0x66, 0x66, 0x30, 0x35, 0x66, 0x36, 0x30, 0x33, 0x32, 0x62, 0x36, 0x30, 0x39, 0x35, 0x34, 0x64, 0x64, 0x30, 0x37, 0x66, 0x33, 0x65, 0x35, 0x65, 0x30, 0x39, 0x34, 0x63, 0x32, 0x38, 0x31, 0x38, 0x38, 0x65, 0x36, 0x39, 0x30, 0x65, 0x37, 0x33, 0x33, 0x33, 0x65, 0x65, 0x37, 0x64, 0x33, 0x37, 0x32, 0x37, 0x39, 0x61, 0x64, 0x63, 0x33, 0x61, 0x39, 0x37, 0x37, 0x63, 0x65, 0x66, 0x36, 0x36, 0x62, 0x34, 0x32, 0x39, 0x35, 0x66, 0x63, 0x61, 0x64, 0x31, 0x33, 0x39, 0x62, 0x36, 0x39, 0x39, 0x63, 0x62, 0x63, 0x63, 0x39, 0x33, 0x37, 0x62, 0x37, 0x61, 0x33, 0x65, 0x37, 0x64, 0x37, 0x35, 0x35, 0x30, 0x39, 0x39, 0x33, 0x61, 0x66, 0x37, 0x65, 0x65, 0x30, 0x61, 0x61, 0x37, 0x31, 0x31, 0x39, 0x64, 0x34, 0x64, 0x39, 0x63, 0x35, 0x64, 0x38, 0x31, 0x65, 0x38, 0x38, 0x66, 0x39, 0x65, 0x65, 0x66, 0x37, 0x38, 0x39, 0x32, 0x34, 0x38, 0x62, 0x65, 0x61, 0x34, 0x32, 0x63, 0x30, 0x64, 0x37, 0x33, 0x63, 0x33, 0x37, 0x30, 0x61, 0x30, 0x31, 0x33, 0x37, 0x65, 0x64, 0x66, 0x36, 0x64, 0x30, 0x35, 0x62, 0x66, 0x65, 0x36, 0x61, 0x38, 0x37, 0x33, 0x64, 0x62, 0x36, 0x65, 0x63, 0x32, 0x32, 0x65, 0x36, 0x34, 0x31, 0x61, 0x36, 0x63, 0x61, 0x66, 0x31, 0x62, 0x61, 0x37, 0x66, 0x66, 0x65, 0x36, 0x63, 0x61, 0x64, 0x39, 0x64, 0x63, 0x39, 0x63, 0x31, 0x34, 0x36, 0x36, 0x66, 0x64, 0x64, 0x34, 0x61, 0x30, 0x64, 0x39, 0x34, 0x34, 0x39, 0x37, 0x36, 0x38, 0x30, 0x32, 0x36, 0x32, 0x61, 0x64, 0x66, 0x63, 0x63, 0x65, 0x64, 0x38, 0x38, 0x64, 0x36, 0x31, 0x65, 0x66, 0x33, 0x36, 0x36, 0x36, 0x64, 0x31, 0x35, 0x37, 0x38, 0x66, 0x63, 0x38, 0x35, 0x65, 0x62, 0x65, 0x38, 0x62, 0x61, 0x31, 0x65, 0x37, 0x31, 0x34, 0x64, 0x30, 0x30, 0x33, 0x32, 0x62, 0x32, 0x30, 0x33, 0x36, 0x65, 0x39, 0x32, 0x62, 0x37, 0x31, 0x38, 0x30, 0x35, 0x30, 0x61, 0x65, 0x36, 0x61, 0x35, 0x61, 0x65, 0x61, 0x30, 0x38, 0x65, 0x34, 0x39, 0x35, 0x62, 0x37, 0x66, 0x39, 0x65, 0x36, 0x31, 0x37, 0x32, 0x37, 0x61, 0x38, 0x31, 0x64, 0x34, 0x38, 0x66, 0x35, 0x35, 0x33, 0x64, 0x37, 0x66, 0x65, 0x36, 0x62, 0x39, 0x62, 0x66, 0x62, 0x38, 0x66, 0x65, 0x38, 0x31, 0x64, 0x32, 0x63, 0x37, 0x38, 0x32, 0x36, 0x65, 0x32, 0x33, 0x62, 0x32, 0x33, 0x63, 0x31, 0x63, 0x61, 0x64, 0x66, 0x33, 0x61, 0x37, 0x32, 0x61, 0x30, 0x32, 0x38, 0x36, 0x65, 0x65, 0x66, 0x35, 0x30, 0x64, 0x34, 0x37, 0x32, 0x36, 0x65, 0x36, 0x61, 0x39, 0x61, 0x30, 0x33, 0x64, 0x38, 0x65, 0x30, 0x65, 0x62, 0x34, 0x61, 0x34, 0x36, 0x64, 0x34, 0x36, 0x35, 0x36, 0x37, 0x31, 0x33, 0x37, 0x34, 0x32, 0x31, 0x36, 0x63, 0x37, 0x30, 0x39, 0x38, 0x33, 0x37, 0x31, 0x32, 0x34, 0x32, 0x36, 0x63, 0x36, 0x62, 0x34, 0x34, 0x37, 0x65, 0x31, 0x35, 0x39, 0x37, 0x30, 0x31, 0x37, 0x63, 0x36, 0x39, 0x66, 0x30, 0x32, 0x33, 0x35, 0x65, 0x33, 0x65, 0x61, 0x64, 0x32, 0x61, 0x62, 0x33, 0x30, 0x65, 0x33, 0x39, 0x35, 0x36, 0x37, 0x65, 0x33, 0x36, 0x31, 0x37, 0x64, 0x37, 0x33, 0x62, 0x39, 0x32, 0x66, 0x34, 0x61, 0x38, 0x62, 0x63, 0x34, 0x36, 0x65, 0x62, 0x31, 0x39, 0x35, 0x61, 0x34, 0x35, 0x31, 0x35, 0x39, 0x30, 0x37, 0x36, 0x65, 0x61, 0x62, 0x32, 0x30, 0x34, 0x65, 0x30, 0x39, 0x61, 0x61, 0x37, 0x39, 0x37, 0x32, 0x63, 0x36, 0x38, 0x32, 0x61, 0x37, 0x32, 0x62, 0x36, 0x37, 0x62, 0x30, 0x33, 0x33, 0x37, 0x33, 0x37, 0x63, 0x35, 0x37, 0x61, 0x32, 0x36, 0x33, 0x34, 0x64, 0x38, 0x32, 0x34, 0x37, 0x62, 0x65, 0x31, 0x36, 0x64, 0x30, 0x31, 0x61, 0x64, 0x64, 0x61, 0x36, 0x63, 0x61, 0x38, 0x35, 0x61, 0x35, 0x39, 0x61, 0x62, 0x30, 0x33, 0x37, 0x35, 0x36, 0x66, 0x35, 0x63, 0x34, 0x34, 0x38, 0x36, 0x39, 0x31, 0x33, 0x35, 0x32, 0x32, 0x65, 0x34, 0x37, 0x64, 0x36, 0x66, 0x36, 0x37, 0x63, 0x32, 0x64, 0x31, 0x63, 0x64, 0x30, 0x35, 0x38, 0x63, 0x39, 0x34, 0x30, 0x34, 0x62, 0x31, 0x64, 0x63, 0x36, 0x33, 0x32, 0x32, 0x65, 0x31, 0x62, 0x36, 0x65, 0x33, 0x62, 0x31, 0x39, 0x30, 0x38, 0x30, 0x39, 0x66, 0x33, 0x30, 0x37, 0x65, 0x66, 0x35, 0x33, 0x66, 0x31, 0x38, 0x66, 0x35, 0x39, 0x37, 0x32, 0x34, 0x36, 0x38, 0x61, 0x36, 0x66, 0x36, 0x37, 0x31, 0x32, 0x35, 0x37, 0x33, 0x34, 0x34, 0x65, 0x31, 0x30, 0x32, 0x37, 0x39, 0x66, 0x30, 0x36, 0x35, 0x35, 0x65, 0x66, 0x37, 0x39, 0x32, 0x37, 0x32, 0x32, 0x66, 0x62, 0x63, 0x32, 0x31, 0x33, 0x39, 0x30, 0x36, 0x63, 0x38, 0x36, 0x36, 0x62, 0x32, 0x62, 0x32, 0x35, 0x66, 0x63, 0x61, 0x32, 0x31, 0x30, 0x38, 0x66, 0x61, 0x35, 0x37, 0x32, 0x64, 0x32, 0x66, 0x61, 0x30, 0x31, 0x64, 0x35, 0x37, 0x38, 0x36, 0x66, 0x63, 0x62, 0x31, 0x35, 0x37, 0x30, 0x34, 0x62, 0x61, 0x63, 0x63, 0x39, 0x64, 0x33, 0x38, 0x35, 0x39, 0x33, 0x36, 0x33, 0x36, 0x35, 0x34, 0x33, 0x30, 0x62, 0x33, 0x65, 0x35, 0x34, 0x62, 0x34, 0x64, 0x38, 0x37, 0x66, 0x37, 0x38, 0x38, 0x31, 0x34, 0x30, 0x39, 0x32, 0x63, 0x32, 0x64, 0x30, 0x64, 0x62, 0x37, 0x32, 0x35, 0x66, 0x33, 0x36, 0x61, 0x38, 0x64, 0x31, 0x62, 0x63, 0x37, 0x37, 0x32, 0x61, 0x32, 0x62, 0x34, 0x38, 0x35, 0x63, 0x36, 0x66, 0x30, 0x34, 0x33, 0x30, 0x64, 0x39, 0x33, 0x38, 0x30, 0x62, 0x36, 0x36, 0x32, 0x30, 0x32, 0x36, 0x32, 0x62, 0x63, 0x33, 0x33, 0x36, 0x35, 0x37, 0x32, 0x36, 0x65, 0x66, 0x39, 0x31, 0x31, 0x35, 0x37, 0x33, 0x39, 0x33, 0x33, 0x39, 0x30, 0x33, 0x34, 0x64, 0x65, 0x33, 0x64, 0x33, 0x33, 0x37, 0x35, 0x31, 0x30, 0x66, 0x37, 0x34, 0x66, 0x30, 0x65, 0x62, 0x66, 0x66, 0x33, 0x64, 0x65, 0x35, 0x63, 0x39, 0x63, 0x62, 0x39, 0x39, 0x66, 0x35, 0x32, 0x34, 0x37, 0x30, 0x31, 0x36, 0x61, 0x38, 0x31, 0x33, 0x34, 0x38, 0x62, 0x33, 0x31, 0x64, 0x30, 0x65, 0x37, 0x30, 0x66, 0x39, 0x65, 0x39, 0x37, 0x35, 0x66, 0x62, 0x33, 0x35, 0x30, 0x64, 0x37, 0x32, 0x62, 0x33, 0x65, 0x34, 0x30, 0x35, 0x36, 0x36, 0x64, 0x33, 0x30, 0x35, 0x66, 0x38, 0x62, 0x66, 0x66, 0x61, 0x36, 0x32, 0x36, 0x63, 0x61, 0x36, 0x30, 0x64, 0x63, 0x38, 0x66, 0x35, 0x64, 0x36, 0x30, 0x63, 0x66, 0x38, 0x34, 0x36, 0x36, 0x34, 0x64, 0x63, 0x66, 0x31, 0x32, 0x36, 0x38, 0x62, 0x32, 0x33, 0x30, 0x62, 0x34, 0x36, 0x35, 0x62, 0x62, 0x61, 0x65, 0x30, 0x61, 0x35, 0x37, 0x32, 0x33, 0x64, 0x38, 0x66, 0x33, 0x34, 0x30, 0x33, 0x64, 0x36, 0x38, 0x35, 0x61, 0x66, 0x62, 0x37, 0x61, 0x66, 0x66, 0x61, 0x62, 0x33, 0x34, 0x38, 0x39, 0x38, 0x34, 0x36, 0x37, 0x32, 0x62, 0x33, 0x65, 0x36, 0x31, 0x61, 0x33, 0x61, 0x30, 0x35, 0x31, 0x37, 0x33, 0x35, 0x32, 0x64, 0x35, 0x63, 0x37, 0x36, 0x61, 0x32, 0x37, 0x36, 0x66, 0x33, 0x62, 0x65, 0x30, 0x66, 0x38, 0x61, 0x37, 0x32, 0x32, 0x38, 0x37, 0x37, 0x39, 0x34, 0x34, 0x32, 0x34, 0x63, 0x31, 0x37, 0x61, 0x31, 0x65, 0x36, 0x33, 0x66, 0x37, 0x30, 0x33, 0x32, 0x35, 0x37, 0x37, 0x38, 0x35, 0x63, 0x37, 0x37, 0x37, 0x63, 0x62, 0x38, 0x62, 0x33, 0x37, 0x34, 0x34, 0x38, 0x65, 0x61, 0x33, 0x37, 0x37, 0x33, 0x36, 0x34, 0x38, 0x37, 0x64, 0x34, 0x62, 0x31, 0x38, 0x62, 0x61, 0x34, 0x61, 0x34, 0x37, 0x66, 0x36, 0x35, 0x36, 0x66, 0x61, 0x39, 0x62, 0x32, 0x38, 0x35, 0x36, 0x33, 0x30, 0x61, 0x38, 0x39, 0x34, 0x31, 0x65, 0x31, 0x36, 0x37, 0x37, 0x31, 0x64, 0x65, 0x35, 0x36, 0x66, 0x65, 0x34, 0x32, 0x33, 0x61, 0x65, 0x33, 0x61, 0x33, 0x39, 0x35, 0x65, 0x38, 0x37, 0x66, 0x30, 0x63, 0x36, 0x64, 0x64, 0x33, 0x63, 0x66, 0x30, 0x31, 0x66, 0x33, 0x64, 0x62, 0x39, 0x36, 0x61, 0x37, 0x37, 0x35, 0x35, 0x32, 0x66, 0x38, 0x31, 0x36, 0x38, 0x61, 0x63, 0x64, 0x35, 0x32, 0x64, 0x33, 0x61, 0x37, 0x32, 0x38, 0x39, 0x66, 0x31, 0x65, 0x36, 0x61, 0x61, 0x31, 0x61, 0x63, 0x37, 0x36, 0x34, 0x34, 0x62, 0x37, 0x31, 0x30, 0x65, 0x64, 0x66, 0x61, 0x64, 0x38, 0x30, 0x64, 0x37, 0x64, 0x61, 0x62, 0x65, 0x63, 0x31, 0x63, 0x39, 0x64, 0x64, 0x62, 0x36, 0x36, 0x65, 0x39, 0x63, 0x66, 0x39, 0x66, 0x32, 0x62, 0x33, 0x32, 0x31, 0x36, 0x34, 0x62, 0x33, 0x34, 0x33, 0x65, 0x61, 0x61, 0x66, 0x35, 0x64, 0x63, 0x34, 0x30, 0x64, 0x39, 0x30, 0x39, 0x38, 0x66, 0x39, 0x64, 0x65, 0x65, 0x37, 0x39, 0x65, 0x35, 0x32, 0x66, 0x64, 0x37, 0x66, 0x39, 0x66, 0x33, 0x37, 0x62, 0x38, 0x65, 0x38, 0x61, 0x66, 0x31, 0x61, 0x64, 0x38, 0x30, 0x38, 0x33, 0x65, 0x32, 0x39, 0x31, 0x64, 0x63, 0x65, 0x39, 0x37, 0x32, 0x63, 0x39, 0x63, 0x30, 0x33, 0x63, 0x66, 0x33, 0x62, 0x30, 0x63, 0x33, 0x31, 0x37, 0x38, 0x35, 0x63, 0x31, 0x39, 0x31, 0x34, 0x34, 0x36, 0x63, 0x30, 0x35, 0x61, 0x36, 0x34, 0x37, 0x38, 0x38, 0x37, 0x34, 0x66, 0x66, 0x36, 0x35, 0x34, 0x65, 0x65, 0x31, 0x38, 0x33, 0x36, 0x64, 0x31, 0x64, 0x66, 0x35, 0x66, 0x30, 0x39, 0x31, 0x61, 0x65, 0x62, 0x30, 0x66, 0x37, 0x65, 0x66, 0x34, 0x61, 0x38, 0x33, 0x33, 0x38, 0x65, 0x64, 0x61, 0x39, 0x39, 0x37, 0x33, 0x34, 0x64, 0x30, 0x37, 0x66, 0x62, 0x30, 0x35, 0x34, 0x31, 0x39, 0x39, 0x63, 0x65, 0x62, 0x66, 0x30, 0x32, 0x36, 0x37, 0x65, 0x63, 0x30, 0x66, 0x33, 0x38, 0x62, 0x34, 0x33, 0x39, 0x35, 0x63, 0x38, 0x62, 0x65, 0x32, 0x66, 0x35, 0x61, 0x30, 0x31, 0x65, 0x38, 0x32, 0x31, 0x62, 0x61, 0x31, 0x35, 0x65, 0x63, 0x36, 0x31, 0x38, 0x38, 0x64, 0x35, 0x39, 0x37, 0x64, 0x65, 0x65, 0x32, 0x34, 0x36, 0x63, 0x64, 0x35, 0x35, 0x64, 0x37, 0x63, 0x66, 0x61, 0x34, 0x30, 0x65, 0x34, 0x34, 0x39, 0x39, 0x37, 0x62, 0x66, 0x34, 0x36, 0x37, 0x37, 0x35, 0x62, 0x61, 0x32, 0x63, 0x66, 0x62, 0x30, 0x32, 0x32, 0x39, 0x33, 0x62, 0x33, 0x31, 0x62, 0x36, 0x62, 0x35, 0x38, 0x34, 0x36, 0x61, 0x31, 0x35, 0x31, 0x64, 0x37, 0x32, 0x61, 0x37, 0x35, 0x66, 0x30, 0x33, 0x33, 0x65, 0x64, 0x32, 0x38, 0x36, 0x64, 0x38, 0x65, 0x63, 0x35, 0x32, 0x65, 0x38, 0x35, 0x65, 0x36, 0x65, 0x34, 0x36, 0x63, 0x62, 0x30, 0x35, 0x33, 0x31, 0x30, 0x63, 0x37, 0x31, 0x39, 0x63, 0x63, 0x35, 0x32, 0x61, 0x38, 0x33, 0x30, 0x61, 0x33, 0x37, 0x36, 0x30, 0x38, 0x36, 0x65, 0x61, 0x63, 0x39, 0x35, 0x63, 0x30, 0x31, 0x38, 0x32, 0x37, 0x32, 0x38, 0x34, 0x36, 0x38, 0x38, 0x34, 0x63, 0x32, 0x36, 0x61, 0x39, 0x65, 0x63, 0x66, 0x36, 0x32, 0x35, 0x36, 0x62, 0x31, 0x30, 0x63, 0x36, 0x66, 0x33, 0x65, 0x32, 0x38, 0x64, 0x37, 0x35, 0x32, 0x62, 0x37, 0x31, 0x30, 0x65, 0x37, 0x63, 0x34, 0x34, 0x64, 0x63, 0x36, 0x31, 0x34, 0x66, 0x66, 0x33, 0x61, 0x65, 0x63, 0x38, 0x63, 0x39, 0x35, 0x65, 0x36, 0x62, 0x65, 0x35, 0x33, 0x37, 0x32, 0x38, 0x30, 0x66, 0x34, 0x35, 0x39, 0x35, 0x66, 0x65, 0x30, 0x63, 0x36, 0x65, 0x62, 0x62, 0x35, 0x31, 0x65, 0x39, 0x36, 0x65, 0x61, 0x62, 0x62, 0x31, 0x61, 0x34, 0x37, 0x39, 0x38, 0x32, 0x36, 0x63, 0x61, 0x65, 0x32, 0x62, 0x33, 0x39, 0x34, 0x37, 0x38, 0x63, 0x63, 0x61, 0x66, 0x36, 0x61, 0x64, 0x62, 0x65, 0x65, 0x31, 0x63, 0x38, 0x39, 0x37, 0x65, 0x32, 0x35, 0x35, 0x32, 0x37, 0x32, 0x39, 0x36, 0x36, 0x65, 0x63, 0x32, 0x38, 0x64, 0x65, 0x66, 0x37, 0x35, 0x33, 0x31, 0x64, 0x31, 0x37, 0x64, 0x66, 0x36, 0x33, 0x64, 0x65, 0x65, 0x33, 0x36, 0x31, 0x35, 0x34, 0x64, 0x63, 0x64, 0x34, 0x31, 0x61, 0x33, 0x39, 0x64, 0x64, 0x65, 0x38, 0x61, 0x38, 0x33, 0x63, 0x36, 0x62, 0x38, 0x37, 0x30, 0x35, 0x61, 0x38, 0x37, 0x63, 0x37, 0x65, 0x32, 0x34, 0x64, 0x36, 0x34, 0x37, 0x32, 0x34, 0x63, 0x30, 0x65, 0x39, 0x39, 0x38, 0x63, 0x39, 0x63, 0x64, 0x38, 0x31, 0x37, 0x34, 0x30, 0x30, 0x39, 0x37, 0x32, 0x37, 0x37, 0x64, 0x63, 0x66, 0x66, 0x35, 0x38, 0x63, 0x34, 0x64, 0x33, 0x62, 0x36, 0x33, 0x30, 0x62, 0x35, 0x32, 0x63, 0x62, 0x39, 0x37, 0x62, 0x62, 0x38, 0x33, 0x66, 0x32, 0x33, 0x31, 0x65, 0x35, 0x61, 0x31, 0x34, 0x31, 0x36, 0x32, 0x36, 0x34, 0x34, 0x37, 0x32, 0x64, 0x61, 0x63, 0x64, 0x35, 0x35, 0x63, 0x66, 0x36, 0x35, 0x31, 0x35, 0x66, 0x33, 0x63, 0x31, 0x39, 0x38, 0x64, 0x31, 0x34, 0x34, 0x66, 0x38, 0x30, 0x36, 0x62, 0x37, 0x32, 0x31, 0x35, 0x61, 0x33, 0x30, 0x63, 0x61, 0x37, 0x35, 0x34, 0x65, 0x30, 0x34, 0x39, 0x36, 0x30, 0x61, 0x64, 0x62, 0x30, 0x33, 0x32, 0x64, 0x31, 0x32, 0x64, 0x35, 0x63, 0x36, 0x36, 0x62, 0x33, 0x36, 0x34, 0x33, 0x66, 0x37, 0x30, 0x64, 0x30, 0x39, 0x32, 0x61, 0x30, 0x33, 0x63, 0x36, 0x32, 0x37, 0x64, 0x64, 0x63, 0x61, 0x66, 0x62, 0x38, 0x64, 0x30, 0x61, 0x34, 0x66, 0x39, 0x34, 0x31, 0x30, 0x62, 0x66, 0x38, 0x39, 0x31, 0x38, 0x66, 0x63, 0x30, 0x63, 0x61, 0x34, 0x39, 0x35, 0x61, 0x33, 0x64, 0x34, 0x61, 0x62, 0x30, 0x36, 0x63, 0x35, 0x64, 0x32, 0x35, 0x38, 0x65, 0x31, 0x35, 0x31, 0x37, 0x32, 0x39, 0x33, 0x65, 0x64, 0x63, 0x37, 0x36, 0x30, 0x66, 0x34, 0x33, 0x38, 0x38, 0x65, 0x32, 0x66, 0x63, 0x35, 0x30, 0x39, 0x65, 0x37, 0x61, 0x30, 0x37, 0x64, 0x63, 0x34, 0x34, 0x36, 0x66, 0x31, 0x31, 0x33, 0x30, 0x34, 0x38, 0x37, 0x61, 0x38, 0x30, 0x38, 0x35, 0x33, 0x36, 0x65, 0x39, 0x61, 0x65, 0x38, 0x31, 0x65, 0x65, 0x63, 0x31, 0x33, 0x32, 0x33, 0x33, 0x35, 0x66, 0x33, 0x37, 0x32, 0x35, 0x34, 0x61, 0x33, 0x33, 0x34, 0x32, 0x66, 0x36, 0x33, 0x31, 0x37, 0x32, 0x66, 0x34, 0x63, 0x31, 0x66, 0x30, 0x33, 0x36, 0x34, 0x65, 0x32, 0x33, 0x35, 0x30, 0x37, 0x63, 0x31, 0x35, 0x33, 0x39, 0x65, 0x64, 0x30, 0x39, 0x34, 0x30, 0x64, 0x62, 0x33, 0x63, 0x64, 0x37, 0x35, 0x36, 0x37, 0x35, 0x36, 0x39, 0x64, 0x63, 0x35, 0x61, 0x30, 0x64, 0x65, 0x63, 0x31, 0x63, 0x66, 0x34, 0x36, 0x36, 0x38, 0x61, 0x63, 0x33, 0x66, 0x34, 0x36, 0x65, 0x64, 0x64, 0x61, 0x32, 0x35, 0x65, 0x65, 0x34, 0x61, 0x31, 0x37, 0x31, 0x66, 0x33, 0x33, 0x64, 0x35, 0x34, 0x62, 0x37, 0x35, 0x65, 0x31, 0x39, 0x39, 0x66, 0x66, 0x31, 0x63, 0x35, 0x61, 0x31, 0x36, 0x33, 0x63, 0x34, 0x64, 0x39, 0x36, 0x36, 0x61, 0x66, 0x62, 0x39, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x35, 0x39, 0x35, 0x37, 0x32, 0x32, 0x63, 0x35, 0x64, 0x31, 0x34, 0x36, 0x32, 0x64, 0x66, 0x34, 0x62, 0x38, 0x39, 0x64, 0x31, 0x35, 0x37, 0x34, 0x63, 0x64, 0x30, 0x31, 0x39, 0x61, 0x64, 0x38, 0x34, 0x61, 0x36, 0x37, 0x38, 0x62, 0x33, 0x65, 0x38, 0x63, 0x64, 0x62, 0x63, 0x30, 0x39, 0x30, 0x61, 0x33, 0x38, 0x64, 0x62, 0x34, 0x36, 0x65, 0x66, 0x31, 0x33, 0x33, 0x64, 0x66, 0x66, 0x36, 0x35, 0x37, 0x62, 0x37, 0x32, 0x65, 0x66, 0x33, 0x64, 0x34, 0x35, 0x32, 0x39, 0x38, 0x37, 0x35, 0x36, 0x36, 0x33, 0x35, 0x38, 0x34, 0x35, 0x61, 0x36, 0x30, 0x37, 0x36, 0x36, 0x31, 0x37, 0x31, 0x34, 0x65, 0x37, 0x61, 0x31, 0x33, 0x38, 0x37, 0x32, 0x63, 0x36, 0x66, 0x39, 0x65, 0x33, 0x34, 0x39, 0x30, 0x65, 0x34, 0x62, 0x63, 0x30, 0x66, 0x65, 0x66, 0x34, 0x37, 0x64, 0x39, 0x36, 0x64, 0x32, 0x64, 0x33, 0x37, 0x32, 0x65, 0x63, 0x63, 0x63, 0x33, 0x61, 0x62, 0x66, 0x31, 0x33, 0x35, 0x39, 0x62, 0x33, 0x34, 0x38, 0x37, 0x37, 0x62, 0x61, 0x33, 0x62, 0x39, 0x64, 0x66, 0x61, 0x64, 0x31, 0x30, 0x64, 0x65, 0x65, 0x39, 0x63, 0x37, 0x39, 0x32, 0x33, 0x65, 0x33, 0x32, 0x37, 0x64, 0x30, 0x66, 0x34, 0x36, 0x34, 0x66, 0x38, 0x66, 0x33, 0x66, 0x31, 0x63, 0x66, 0x39, 0x32, 0x62, 0x65, 0x66, 0x34, 0x35, 0x63, 0x65, 0x62, 0x36, 0x65, 0x64, 0x34, 0x65, 0x38, 0x30, 0x32, 0x32, 0x36, 0x62, 0x64, 0x66, 0x32, 0x37, 0x31, 0x33, 0x39, 0x35, 0x38, 0x63, 0x62, 0x31, 0x31, 0x66, 0x35, 0x62, 0x61, 0x36, 0x61, 0x63, 0x32, 0x39, 0x33, 0x37, 0x31, 0x66, 0x62, 0x30, 0x66, 0x62, 0x61, 0x37, 0x32, 0x61, 0x63, 0x31, 0x62, 0x33, 0x30, 0x33, 0x32, 0x33, 0x31, 0x61, 0x62, 0x37, 0x63, 0x30, 0x32, 0x37, 0x32, 0x39, 0x32, 0x34, 0x37, 0x36, 0x34, 0x63, 0x36, 0x64, 0x37, 0x33, 0x65, 0x33, 0x35, 0x35, 0x63, 0x36, 0x34, 0x39, 0x33, 0x33, 0x33, 0x37, 0x62, 0x63, 0x31, 0x61, 0x31, 0x66, 0x37, 0x30, 0x61, 0x39, 0x31, 0x32, 0x37, 0x65, 0x39, 0x64, 0x63, 0x62, 0x31, 0x33, 0x36, 0x36, 0x62, 0x63, 0x38, 0x38, 0x34, 0x38, 0x30, 0x66, 0x61, 0x32, 0x65, 0x31, 0x35, 0x66, 0x65, 0x37, 0x61, 0x37, 0x32, 0x66, 0x63, 0x33, 0x32, 0x36, 0x32, 0x36, 0x39, 0x36, 0x30, 0x33, 0x37, 0x62, 0x32, 0x38, 0x32, 0x66, 0x30, 0x39, 0x64, 0x39, 0x64, 0x62, 0x36, 0x66, 0x37, 0x35, 0x65, 0x66, 0x62, 0x39, 0x35, 0x65, 0x65, 0x64, 0x38, 0x64, 0x35, 0x63, 0x39, 0x61, 0x32, 0x62, 0x32, 0x34, 0x36, 0x35, 0x31, 0x64, 0x33, 0x31, 0x35, 0x32, 0x64, 0x62, 0x30, 0x63, 0x63, 0x64, 0x65, 0x66, 0x37, 0x37, 0x32, 0x36, 0x64, 0x39, 0x61, 0x62, 0x39, 0x38, 0x34, 0x30, 0x30, 0x66, 0x31, 0x61, 0x36, 0x39, 0x36, 0x36, 0x61, 0x66, 0x34, 0x63, 0x36, 0x62, 0x34, 0x66, 0x32, 0x37, 0x35, 0x66, 0x35, 0x37, 0x35, 0x61, 0x62, 0x30, 0x64, 0x37, 0x63, 0x66, 0x31, 0x39, 0x30, 0x30, 0x37, 0x34, 0x32, 0x30, 0x38, 0x32, 0x64, 0x63, 0x32, 0x63, 0x37, 0x33, 0x62, 0x37, 0x31, 0x31, 0x32, 0x38, 0x66, 0x32, 0x37, 0x38, 0x62, 0x61, 0x37, 0x32, 0x34, 0x34, 0x36, 0x66, 0x30, 0x61, 0x32, 0x35, 0x33, 0x30, 0x35, 0x39, 0x65, 0x39, 0x31, 0x39, 0x32, 0x64, 0x35, 0x34, 0x38, 0x35, 0x64, 0x34, 0x66, 0x33, 0x35, 0x38, 0x35, 0x36, 0x63, 0x31, 0x37, 0x39, 0x63, 0x39, 0x31, 0x31, 0x66, 0x39, 0x33, 0x31, 0x66, 0x35, 0x65, 0x64, 0x36, 0x36, 0x32, 0x31, 0x32, 0x32, 0x31, 0x66, 0x35, 0x34, 0x61, 0x30, 0x31, 0x62, 0x34, 0x62, 0x61, 0x38, 0x37, 0x33, 0x35, 0x35, 0x33, 0x32, 0x66, 0x38, 0x39, 0x32, 0x30, 0x34, 0x39, 0x32, 0x35, 0x38, 0x32, 0x62, 0x36, 0x65, 0x33, 0x32, 0x31, 0x37, 0x34, 0x35, 0x31, 0x37, 0x63, 0x36, 0x32, 0x33, 0x39, 0x64, 0x61, 0x63, 0x37, 0x35, 0x31, 0x65, 0x34, 0x38, 0x35, 0x62, 0x33, 0x62, 0x30, 0x30, 0x31, 0x32, 0x35, 0x35, 0x39, 0x31, 0x63, 0x65, 0x32, 0x31, 0x39, 0x39, 0x36, 0x32, 0x34, 0x62, 0x66, 0x35, 0x32, 0x62, 0x33, 0x33, 0x66, 0x30, 0x64, 0x35, 0x35, 0x63, 0x33, 0x33, 0x31, 0x62, 0x32, 0x63, 0x61, 0x32, 0x39, 0x35, 0x36, 0x39, 0x30, 0x38, 0x65, 0x32, 0x34, 0x39, 0x64, 0x63, 0x64, 0x33, 0x37, 0x34, 0x38, 0x33, 0x36, 0x65, 0x61, 0x64, 0x33, 0x34, 0x31, 0x38, 0x63, 0x31, 0x37, 0x62, 0x39, 0x39, 0x66, 0x34, 0x61, 0x35, 0x61, 0x33, 0x31, 0x64, 0x66, 0x61, 0x64, 0x35, 0x62, 0x38, 0x34, 0x39, 0x31, 0x31, 0x63, 0x36, 0x35, 0x33, 0x39, 0x33, 0x34, 0x66, 0x36, 0x34, 0x66, 0x62, 0x30, 0x63, 0x32, 0x64, 0x34, 0x34, 0x34, 0x39, 0x36, 0x62, 0x38, 0x64, 0x33, 0x33, 0x63, 0x35, 0x62, 0x63, 0x64, 0x64, 0x34, 0x33, 0x63, 0x39, 0x65, 0x36, 0x35, 0x66, 0x61, 0x34, 0x62, 0x31, 0x34, 0x36, 0x61, 0x37, 0x37, 0x30, 0x61, 0x37, 0x32, 0x38, 0x65, 0x33, 0x35, 0x61, 0x64, 0x61, 0x34, 0x63, 0x38, 0x31, 0x66, 0x65, 0x39, 0x61, 0x62, 0x64, 0x30, 0x36, 0x34, 0x32, 0x66, 0x31, 0x39, 0x31, 0x31, 0x64, 0x30, 0x39, 0x66, 0x31, 0x63, 0x33, 0x35, 0x32, 0x39, 0x30, 0x62, 0x63, 0x36, 0x65, 0x39, 0x39, 0x65, 0x63, 0x38, 0x63, 0x35, 0x61, 0x39, 0x61, 0x62, 0x34, 0x64, 0x62, 0x36, 0x36, 0x32, 0x63, 0x66, 0x35, 0x64, 0x35, 0x66, 0x34, 0x37, 0x37, 0x61, 0x35, 0x38, 0x31, 0x32, 0x64, 0x38, 0x32, 0x33, 0x34, 0x66, 0x63, 0x34, 0x35, 0x65, 0x64, 0x30, 0x39, 0x62, 0x39, 0x62, 0x39, 0x31, 0x35, 0x64, 0x32, 0x39, 0x66, 0x33, 0x63, 0x34, 0x36, 0x62, 0x38, 0x64, 0x37, 0x64, 0x35, 0x34, 0x35, 0x38, 0x33, 0x36, 0x65, 0x30, 0x30, 0x39, 0x65, 0x32, 0x66, 0x33, 0x33, 0x65, 0x30, 0x37, 0x35, 0x35, 0x39, 0x37, 0x33, 0x34, 0x38, 0x35, 0x66, 0x31, 0x38, 0x37, 0x65, 0x36, 0x63, 0x37, 0x35, 0x34, 0x65, 0x38, 0x61, 0x32, 0x32, 0x64, 0x62, 0x30, 0x35, 0x34, 0x39, 0x64, 0x65, 0x64, 0x32, 0x39, 0x38, 0x65, 0x38, 0x63, 0x30, 0x33, 0x32, 0x61, 0x62, 0x38, 0x64, 0x65, 0x33, 0x38, 0x62, 0x39, 0x32, 0x30, 0x62, 0x66, 0x31, 0x39, 0x34, 0x37, 0x64, 0x39, 0x32, 0x31, 0x64, 0x36, 0x32, 0x62, 0x37, 0x39, 0x34, 0x38, 0x37, 0x39, 0x66, 0x31, 0x64, 0x31, 0x34, 0x66, 0x65, 0x39, 0x31, 0x30, 0x39, 0x66, 0x64, 0x34, 0x35, 0x39, 0x35, 0x35, 0x66, 0x64, 0x32, 0x37, 0x33, 0x37, 0x65, 0x32, 0x33, 0x39, 0x65, 0x65, 0x31, 0x30, 0x64, 0x61, 0x35, 0x36, 0x32, 0x39, 0x31, 0x31, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x30, 0x34, 0x63, 0x38, 0x66, 0x36, 0x34, 0x38, 0x66, 0x34, 0x31, 0x38, 0x30, 0x36, 0x37, 0x32, 0x33, 0x37, 0x65, 0x61, 0x63, 0x37, 0x35, 0x31, 0x65, 0x35, 0x33, 0x30, 0x61, 0x34, 0x38, 0x35, 0x66, 0x62, 0x66, 0x63, 0x34, 0x33, 0x32, 0x31, 0x33, 0x35, 0x39, 0x31, 0x62, 0x35, 0x62, 0x64, 0x63, 0x35, 0x65, 0x64, 0x62, 0x35, 0x32, 0x31, 0x39, 0x65, 0x33, 0x32, 0x36, 0x64, 0x66, 0x37, 0x34, 0x62, 0x32, 0x36, 0x39, 0x31, 0x38, 0x35, 0x64, 0x61, 0x31, 0x39, 0x61, 0x39, 0x34, 0x39, 0x34, 0x66, 0x33, 0x62, 0x32, 0x66, 0x63, 0x30, 0x38, 0x34, 0x36, 0x33, 0x31, 0x35, 0x63, 0x65, 0x62, 0x37, 0x35, 0x62, 0x37, 0x31, 0x65, 0x30, 0x36, 0x35, 0x32, 0x38, 0x36, 0x33, 0x33, 0x34, 0x65, 0x33, 0x34, 0x62, 0x31, 0x65, 0x36, 0x30, 0x64, 0x66, 0x62, 0x39, 0x33, 0x34, 0x62, 0x31, 0x34, 0x38, 0x36, 0x61, 0x32, 0x33, 0x65, 0x37, 0x35, 0x31, 0x33, 0x38, 0x63, 0x31, 0x37, 0x32, 0x64, 0x31, 0x31, 0x62, 0x30, 0x35, 0x64, 0x63, 0x64, 0x35, 0x37, 0x34, 0x37, 0x33, 0x31, 0x38, 0x65, 0x64, 0x34, 0x33, 0x32, 0x64, 0x65, 0x35, 0x63, 0x65, 0x64, 0x66, 0x33, 0x31, 0x36, 0x61, 0x30, 0x64, 0x61, 0x62, 0x63, 0x31, 0x36, 0x64, 0x62, 0x62, 0x38, 0x62, 0x64, 0x35, 0x34, 0x39, 0x37, 0x35, 0x64, 0x33, 0x62, 0x30, 0x30, 0x64, 0x32, 0x65, 0x39, 0x31, 0x34, 0x62, 0x30, 0x30, 0x31, 0x37, 0x65, 0x30, 0x62, 0x63, 0x62, 0x61, 0x33, 0x33, 0x63, 0x32, 0x36, 0x61, 0x32, 0x34, 0x65, 0x65, 0x65, 0x62, 0x61, 0x63, 0x66, 0x33, 0x64, 0x62, 0x64, 0x65, 0x33, 0x39, 0x38, 0x63, 0x61, 0x31, 0x64, 0x39, 0x32, 0x65, 0x65, 0x37, 0x62, 0x31, 0x36, 0x66, 0x32, 0x37, 0x62, 0x63, 0x63, 0x30, 0x30, 0x63, 0x32, 0x63, 0x32, 0x61, 0x64, 0x63, 0x31, 0x34, 0x32, 0x30, 0x37, 0x32, 0x39, 0x35, 0x39, 0x35, 0x31, 0x34, 0x30, 0x63, 0x34, 0x38, 0x64, 0x37, 0x63, 0x36, 0x38, 0x62, 0x39, 0x32, 0x61, 0x64, 0x66, 0x39, 0x65, 0x32, 0x61, 0x65, 0x61, 0x38, 0x66, 0x65, 0x63, 0x61, 0x39, 0x34, 0x31, 0x36, 0x66, 0x38, 0x33, 0x62, 0x63, 0x38, 0x35, 0x33, 0x61, 0x62, 0x66, 0x36, 0x65, 0x38, 0x34, 0x39, 0x66, 0x33, 0x35, 0x34, 0x34, 0x31, 0x32, 0x33, 0x37, 0x39, 0x36, 0x32, 0x37, 0x64, 0x38, 0x31, 0x36, 0x36, 0x63, 0x33, 0x38, 0x34, 0x34, 0x62, 0x66, 0x36, 0x30, 0x63, 0x63, 0x36, 0x39, 0x63, 0x64, 0x37, 0x31, 0x63, 0x61, 0x65, 0x62, 0x38, 0x35, 0x64, 0x32, 0x37, 0x31, 0x35, 0x37, 0x30, 0x38, 0x66, 0x33, 0x38, 0x36, 0x66, 0x35, 0x61, 0x64, 0x31, 0x66, 0x61, 0x30, 0x38, 0x31, 0x34, 0x64, 0x30, 0x37, 0x33, 0x34, 0x66, 0x37, 0x65, 0x64, 0x62, 0x33, 0x62, 0x39, 0x35, 0x65, 0x63, 0x38, 0x63, 0x62, 0x61, 0x66, 0x32, 0x31, 0x37, 0x33, 0x65, 0x37, 0x63, 0x34, 0x31, 0x30, 0x35, 0x61, 0x37, 0x61, 0x38, 0x30, 0x61, 0x66, 0x37, 0x32, 0x62, 0x61, 0x64, 0x35, 0x35, 0x35, 0x31, 0x35, 0x64, 0x65, 0x38, 0x35, 0x31, 0x38, 0x39, 0x34, 0x35, 0x65, 0x39, 0x62, 0x31, 0x34, 0x39, 0x65, 0x35, 0x33, 0x30, 0x36, 0x66, 0x66, 0x66, 0x65, 0x35, 0x37, 0x32, 0x62, 0x32, 0x36, 0x31, 0x34, 0x32, 0x62, 0x32, 0x39, 0x38, 0x35, 0x65, 0x35, 0x35, 0x66, 0x34, 0x38, 0x37, 0x66, 0x30, 0x31, 0x38, 0x65, 0x32, 0x65, 0x36, 0x61, 0x32, 0x61, 0x30, 0x61, 0x64, 0x62, 0x37, 0x33, 0x38, 0x64, 0x64, 0x33, 0x61, 0x33, 0x37, 0x32, 0x62, 0x61, 0x65, 0x30, 0x30, 0x65, 0x63, 0x64, 0x38, 0x63, 0x33, 0x30, 0x30, 0x33, 0x36, 0x61, 0x38, 0x62, 0x30, 0x30, 0x66, 0x36, 0x35, 0x37, 0x39, 0x66, 0x38, 0x66, 0x63, 0x37, 0x32, 0x63, 0x37, 0x66, 0x38, 0x63, 0x32, 0x38, 0x39, 0x30, 0x65, 0x37, 0x37, 0x61, 0x30, 0x32, 0x62, 0x30, 0x34, 0x38, 0x34, 0x36, 0x38, 0x30, 0x61, 0x66, 0x35, 0x33, 0x30, 0x61, 0x64, 0x35, 0x36, 0x39, 0x38, 0x30, 0x35, 0x31, 0x30, 0x39, 0x32, 0x63, 0x64, 0x38, 0x65, 0x64, 0x63, 0x32, 0x37, 0x61, 0x61, 0x39, 0x62, 0x37, 0x32, 0x33, 0x65, 0x33, 0x36, 0x37, 0x62, 0x33, 0x37, 0x30, 0x33, 0x32, 0x63, 0x31, 0x30, 0x66, 0x35, 0x30, 0x34, 0x66, 0x34, 0x65, 0x32, 0x30, 0x37, 0x37, 0x38, 0x61, 0x36, 0x65, 0x66, 0x34, 0x65, 0x64, 0x61, 0x61, 0x65, 0x37, 0x33, 0x34, 0x38, 0x63, 0x36, 0x38, 0x38, 0x32, 0x36, 0x64, 0x66, 0x65, 0x37, 0x62, 0x37, 0x65, 0x65, 0x64, 0x39, 0x35, 0x37, 0x65, 0x31, 0x64, 0x61, 0x35, 0x38, 0x64, 0x63, 0x65, 0x63, 0x65, 0x35, 0x32, 0x33, 0x64, 0x32, 0x36, 0x30, 0x35, 0x62, 0x31, 0x37, 0x35, 0x32, 0x61, 0x32, 0x32, 0x66, 0x32, 0x63, 0x36, 0x36, 0x35, 0x64, 0x33, 0x33, 0x62, 0x64, 0x38, 0x63, 0x36, 0x66, 0x33, 0x30, 0x62, 0x35, 0x32, 0x62, 0x34, 0x30, 0x61, 0x34, 0x38, 0x65, 0x32, 0x39, 0x37, 0x63, 0x66, 0x61, 0x65, 0x63, 0x33, 0x66, 0x31, 0x66, 0x63, 0x31, 0x37, 0x32, 0x61, 0x31, 0x36, 0x62, 0x30, 0x62, 0x37, 0x65, 0x31, 0x65, 0x63, 0x33, 0x33, 0x34, 0x37, 0x38, 0x34, 0x31, 0x37, 0x31, 0x63, 0x39, 0x34, 0x35, 0x38, 0x39, 0x39, 0x63, 0x64, 0x32, 0x38, 0x65, 0x34, 0x32, 0x62, 0x65, 0x62, 0x36, 0x32, 0x30, 0x65, 0x37, 0x62, 0x65, 0x36, 0x63, 0x63, 0x61, 0x63, 0x37, 0x38, 0x31, 0x37, 0x64, 0x32, 0x39, 0x66, 0x64, 0x31, 0x63, 0x35, 0x66, 0x32, 0x61, 0x64, 0x34, 0x38, 0x35, 0x66, 0x38, 0x62, 0x34, 0x61, 0x34, 0x34, 0x66, 0x65, 0x30, 0x30, 0x39, 0x34, 0x38, 0x34, 0x33, 0x30, 0x63, 0x36, 0x36, 0x30, 0x34, 0x66, 0x66, 0x66, 0x65, 0x35, 0x32, 0x66, 0x66, 0x63, 0x61, 0x38, 0x33, 0x35, 0x35, 0x65, 0x61, 0x34, 0x64, 0x34, 0x65, 0x33, 0x32, 0x62, 0x30, 0x33, 0x39, 0x35, 0x61, 0x65, 0x38, 0x34, 0x33, 0x65, 0x61, 0x61, 0x61, 0x37, 0x32, 0x30, 0x35, 0x65, 0x30, 0x30, 0x37, 0x30, 0x64, 0x30, 0x65, 0x63, 0x61, 0x66, 0x36, 0x37, 0x31, 0x35, 0x63, 0x64, 0x34, 0x65, 0x34, 0x35, 0x34, 0x36, 0x62, 0x61, 0x30, 0x66, 0x38, 0x35, 0x63, 0x61, 0x34, 0x34, 0x36, 0x66, 0x36, 0x63, 0x37, 0x62, 0x61, 0x39, 0x35, 0x38, 0x64, 0x64, 0x31, 0x32, 0x64, 0x31, 0x35, 0x33, 0x66, 0x38, 0x66, 0x31, 0x37, 0x64, 0x32, 0x34, 0x38, 0x37, 0x32, 0x34, 0x61, 0x65, 0x38, 0x64, 0x35, 0x36, 0x39, 0x66, 0x33, 0x63, 0x37, 0x63, 0x35, 0x64, 0x35, 0x31, 0x30, 0x65, 0x38, 0x39, 0x32, 0x35, 0x31, 0x39, 0x36, 0x34, 0x34, 0x66, 0x38, 0x39, 0x64, 0x38, 0x66, 0x63, 0x64, 0x39, 0x36, 0x63, 0x30, 0x33, 0x35, 0x32, 0x36, 0x38, 0x33, 0x35, 0x39, 0x63, 0x66, 0x35, 0x34, 0x38, 0x31, 0x32, 0x63, 0x31, 0x30, 0x64, 0x65, 0x35, 0x38, 0x37, 0x32, 0x62, 0x65, 0x66, 0x35, 0x38, 0x39, 0x63, 0x39, 0x35, 0x65, 0x64, 0x65, 0x65, 0x64, 0x35, 0x33, 0x64, 0x62, 0x65, 0x37, 0x38, 0x61, 0x36, 0x63, 0x63, 0x64, 0x38, 0x35, 0x34, 0x32, 0x65, 0x63, 0x62, 0x31, 0x35, 0x34, 0x63, 0x36, 0x61, 0x33, 0x38, 0x66, 0x33, 0x39, 0x32, 0x65, 0x61, 0x61, 0x36, 0x32, 0x63, 0x36, 0x30, 0x63, 0x36, 0x66, 0x31, 0x39, 0x62, 0x66, 0x37, 0x32, 0x37, 0x32, 0x38, 0x39, 0x38, 0x62, 0x65, 0x39, 0x64, 0x35, 0x61, 0x30, 0x35, 0x36, 0x32, 0x38, 0x64, 0x66, 0x35, 0x33, 0x31, 0x30, 0x62, 0x33, 0x34, 0x32, 0x65, 0x65, 0x39, 0x66, 0x31, 0x65, 0x35, 0x62, 0x32, 0x34, 0x37, 0x62, 0x37, 0x33, 0x35, 0x35, 0x34, 0x62, 0x35, 0x39, 0x33, 0x38, 0x35, 0x36, 0x66, 0x37, 0x34, 0x62, 0x32, 0x63, 0x62, 0x66, 0x32, 0x35, 0x37, 0x63, 0x34, 0x66, 0x30, 0x61, 0x34, 0x35, 0x33, 0x37, 0x31, 0x64, 0x63, 0x30, 0x33, 0x64, 0x34, 0x66, 0x34, 0x31, 0x31, 0x34, 0x37, 0x64, 0x62, 0x31, 0x33, 0x66, 0x65, 0x39, 0x31, 0x66, 0x61, 0x37, 0x61, 0x65, 0x35, 0x36, 0x39, 0x38, 0x32, 0x62, 0x34, 0x62, 0x39, 0x35, 0x39, 0x31, 0x39, 0x39, 0x63, 0x64, 0x35, 0x38, 0x30, 0x36, 0x35, 0x65, 0x32, 0x37, 0x36, 0x66, 0x35, 0x39, 0x38, 0x31, 0x37, 0x35, 0x32, 0x33, 0x39, 0x61, 0x37, 0x32, 0x36, 0x35, 0x35, 0x61, 0x62, 0x35, 0x32, 0x62, 0x34, 0x34, 0x36, 0x31, 0x61, 0x30, 0x34, 0x33, 0x64, 0x61, 0x34, 0x30, 0x33, 0x33, 0x65, 0x62, 0x62, 0x38, 0x63, 0x64, 0x37, 0x37, 0x38, 0x61, 0x38, 0x35, 0x33, 0x38, 0x65, 0x35, 0x34, 0x63, 0x38, 0x66, 0x38, 0x35, 0x36, 0x31, 0x30, 0x36, 0x63, 0x62, 0x30, 0x35, 0x66, 0x32, 0x35, 0x63, 0x37, 0x66, 0x35, 0x63, 0x38, 0x63, 0x65, 0x31, 0x32, 0x64, 0x37, 0x33, 0x61, 0x65, 0x65, 0x37, 0x64, 0x62, 0x35, 0x32, 0x34, 0x64, 0x31, 0x36, 0x61, 0x65, 0x36, 0x31, 0x63, 0x34, 0x39, 0x63, 0x33, 0x33, 0x35, 0x32, 0x30, 0x65, 0x34, 0x32, 0x61, 0x32, 0x32, 0x39, 0x35, 0x36, 0x31, 0x35, 0x30, 0x66, 0x62, 0x64, 0x63, 0x39, 0x63, 0x33, 0x31, 0x32, 0x63, 0x61, 0x34, 0x30, 0x63, 0x65, 0x35, 0x65, 0x30, 0x36, 0x31, 0x65, 0x63, 0x64, 0x35, 0x35, 0x35, 0x34, 0x30, 0x63, 0x38, 0x61, 0x32, 0x32, 0x37, 0x35, 0x36, 0x38, 0x64, 0x36, 0x65, 0x62, 0x35, 0x31, 0x39, 0x30, 0x35, 0x65, 0x31, 0x39, 0x33, 0x62, 0x63, 0x36, 0x62, 0x32, 0x30, 0x36, 0x39, 0x35, 0x61, 0x64, 0x62, 0x61, 0x39, 0x66, 0x39, 0x64, 0x33, 0x64, 0x66, 0x62, 0x61, 0x38, 0x34, 0x62, 0x35, 0x32, 0x61, 0x35, 0x64, 0x64, 0x36, 0x64, 0x36, 0x63, 0x36, 0x38, 0x31, 0x34, 0x38, 0x62, 0x61, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x34, 0x34, 0x65, 0x31, 0x32, 0x37, 0x37, 0x62, 0x30, 0x63, 0x35, 0x34, 0x36, 0x65, 0x33, 0x30, 0x38, 0x37, 0x33, 0x33, 0x39, 0x34, 0x66, 0x35, 0x31, 0x66, 0x38, 0x65, 0x34, 0x32, 0x39, 0x33, 0x64, 0x61, 0x35, 0x32, 0x31, 0x61, 0x37, 0x37, 0x34, 0x36, 0x35, 0x62, 0x38, 0x37, 0x61, 0x30, 0x35, 0x39, 0x33, 0x37, 0x38, 0x37, 0x64, 0x64, 0x64, 0x37, 0x31, 0x63, 0x63, 0x66, 0x39, 0x36, 0x36, 0x33, 0x64, 0x34, 0x34, 0x36, 0x33, 0x66, 0x61, 0x65, 0x30, 0x64, 0x63, 0x38, 0x62, 0x35, 0x38, 0x63, 0x36, 0x62, 0x65, 0x32, 0x61, 0x39, 0x35, 0x33, 0x33, 0x63, 0x61, 0x63, 0x35, 0x33, 0x66, 0x61, 0x65, 0x39, 0x37, 0x31, 0x32, 0x63, 0x36, 0x38, 0x65, 0x39, 0x62, 0x35, 0x31, 0x37, 0x32, 0x62, 0x31, 0x37, 0x61, 0x31, 0x65, 0x65, 0x62, 0x38, 0x36, 0x62, 0x65, 0x62, 0x31, 0x39, 0x61, 0x34, 0x63, 0x63, 0x61, 0x37, 0x33, 0x65, 0x34, 0x30, 0x39, 0x65, 0x38, 0x39, 0x39, 0x36, 0x36, 0x32, 0x61, 0x61, 0x32, 0x33, 0x33, 0x66, 0x39, 0x32, 0x61, 0x61, 0x61, 0x34, 0x32, 0x30, 0x30, 0x36, 0x64, 0x36, 0x65, 0x30, 0x61, 0x63, 0x62, 0x35, 0x32, 0x39, 0x35, 0x33, 0x62, 0x33, 0x64, 0x63, 0x63, 0x32, 0x30, 0x64, 0x37, 0x37, 0x66, 0x34, 0x36, 0x35, 0x33, 0x36, 0x65, 0x39, 0x37, 0x34, 0x32, 0x63, 0x66, 0x34, 0x63, 0x31, 0x38, 0x38, 0x31, 0x61, 0x36, 0x39, 0x39, 0x32, 0x31, 0x63, 0x34, 0x34, 0x61, 0x35, 0x37, 0x66, 0x33, 0x39, 0x64, 0x35, 0x62, 0x34, 0x65, 0x36, 0x36, 0x66, 0x64, 0x39, 0x30, 0x30, 0x31, 0x35, 0x34, 0x35, 0x63, 0x36, 0x64, 0x66, 0x35, 0x30, 0x34, 0x38, 0x37, 0x33, 0x39, 0x31, 0x64, 0x31, 0x38, 0x33, 0x64, 0x39, 0x62, 0x37, 0x37, 0x65, 0x65, 0x66, 0x63, 0x37, 0x31, 0x35, 0x66, 0x34, 0x32, 0x31, 0x32, 0x39, 0x34, 0x65, 0x39, 0x37, 0x39, 0x36, 0x32, 0x63, 0x36, 0x61, 0x66, 0x39, 0x39, 0x65, 0x35, 0x34, 0x32, 0x66, 0x34, 0x33, 0x66, 0x62, 0x37, 0x39, 0x64, 0x36, 0x32, 0x66, 0x64, 0x31, 0x35, 0x61, 0x64, 0x63, 0x34, 0x35, 0x36, 0x32, 0x31, 0x30, 0x31, 0x61, 0x65, 0x37, 0x34, 0x65, 0x64, 0x66, 0x66, 0x64, 0x66, 0x33, 0x63, 0x63, 0x34, 0x65, 0x39, 0x30, 0x35, 0x64, 0x65, 0x39, 0x38, 0x39, 0x36, 0x38, 0x35, 0x64, 0x38, 0x31, 0x34, 0x30, 0x64, 0x38, 0x63, 0x32, 0x66, 0x31, 0x39, 0x64, 0x66, 0x37, 0x35, 0x30, 0x32, 0x36, 0x31, 0x30, 0x35, 0x62, 0x66, 0x64, 0x33, 0x62, 0x66, 0x31, 0x32, 0x64, 0x61, 0x37, 0x32, 0x61, 0x64, 0x30, 0x64, 0x36, 0x65, 0x35, 0x65, 0x62, 0x31, 0x31, 0x62, 0x37, 0x66, 0x65, 0x34, 0x39, 0x35, 0x31, 0x33, 0x62, 0x63, 0x32, 0x36, 0x64, 0x64, 0x30, 0x36, 0x31, 0x61, 0x35, 0x30, 0x33, 0x32, 0x66, 0x62, 0x36, 0x39, 0x35, 0x31, 0x66, 0x39, 0x31, 0x33, 0x32, 0x34, 0x64, 0x33, 0x37, 0x38, 0x36, 0x37, 0x66, 0x30, 0x62, 0x37, 0x30, 0x63, 0x37, 0x30, 0x32, 0x38, 0x37, 0x32, 0x34, 0x32, 0x63, 0x63, 0x65, 0x61, 0x63, 0x36, 0x38, 0x31, 0x36, 0x30, 0x66, 0x63, 0x31, 0x62, 0x30, 0x37, 0x33, 0x62, 0x39, 0x34, 0x65, 0x66, 0x33, 0x32, 0x66, 0x39, 0x66, 0x30, 0x35, 0x65, 0x36, 0x63, 0x63, 0x61, 0x61, 0x61, 0x33, 0x38, 0x37, 0x33, 0x61, 0x30, 0x64, 0x65, 0x36, 0x62, 0x37, 0x39, 0x66, 0x31, 0x35, 0x31, 0x31, 0x62, 0x65, 0x32, 0x35, 0x38, 0x30, 0x32, 0x31, 0x62, 0x33, 0x32, 0x30, 0x62, 0x37, 0x62, 0x33, 0x39, 0x39, 0x64, 0x32, 0x65, 0x62, 0x64, 0x36, 0x62, 0x31, 0x30, 0x30, 0x32, 0x34, 0x33, 0x33, 0x66, 0x33, 0x61, 0x34, 0x38, 0x65, 0x66, 0x63, 0x66, 0x31, 0x32, 0x30, 0x33, 0x64, 0x62, 0x33, 0x34, 0x66, 0x38, 0x30, 0x36, 0x38, 0x65, 0x33, 0x35, 0x64, 0x63, 0x33, 0x32, 0x33, 0x33, 0x65, 0x66, 0x32, 0x64, 0x66, 0x32, 0x36, 0x39, 0x37, 0x32, 0x30, 0x36, 0x37, 0x38, 0x39, 0x36, 0x66, 0x33, 0x66, 0x65, 0x33, 0x37, 0x64, 0x65, 0x30, 0x39, 0x65, 0x35, 0x36, 0x31, 0x65, 0x63, 0x62, 0x62, 0x61, 0x35, 0x33, 0x30, 0x34, 0x63, 0x37, 0x61, 0x61, 0x66, 0x39, 0x64, 0x65, 0x64, 0x62, 0x38, 0x63, 0x37, 0x31, 0x39, 0x35, 0x31, 0x31, 0x31, 0x66, 0x61, 0x31, 0x30, 0x35, 0x37, 0x35, 0x66, 0x31, 0x33, 0x61, 0x64, 0x64, 0x35, 0x34, 0x38, 0x64, 0x38, 0x62, 0x38, 0x38, 0x33, 0x62, 0x36, 0x34, 0x66, 0x66, 0x64, 0x65, 0x62, 0x63, 0x39, 0x31, 0x39, 0x36, 0x39, 0x66, 0x38, 0x63, 0x38, 0x35, 0x63, 0x30, 0x33, 0x61, 0x39, 0x30, 0x62, 0x39, 0x39, 0x61, 0x36, 0x62, 0x31, 0x31, 0x65, 0x66, 0x61, 0x30, 0x39, 0x32, 0x65, 0x65, 0x65, 0x38, 0x33, 0x66, 0x66, 0x33, 0x61, 0x38, 0x31, 0x32, 0x63, 0x38, 0x39, 0x33, 0x66, 0x37, 0x32, 0x35, 0x35, 0x65, 0x32, 0x32, 0x61, 0x30, 0x39, 0x38, 0x32, 0x61, 0x61, 0x66, 0x61, 0x63, 0x66, 0x34, 0x64, 0x64, 0x65, 0x64, 0x32, 0x36, 0x32, 0x30, 0x39, 0x32, 0x64, 0x61, 0x64, 0x61, 0x36, 0x30, 0x63, 0x36, 0x30, 0x31, 0x64, 0x62, 0x61, 0x66, 0x63, 0x39, 0x31, 0x63, 0x34, 0x66, 0x34, 0x30, 0x36, 0x65, 0x65, 0x31, 0x38, 0x37, 0x65, 0x64, 0x65, 0x66, 0x61, 0x33, 0x30, 0x37, 0x32, 0x32, 0x31, 0x37, 0x66, 0x32, 0x36, 0x37, 0x65, 0x65, 0x39, 0x37, 0x61, 0x35, 0x62, 0x63, 0x30, 0x36, 0x37, 0x61, 0x39, 0x62, 0x65, 0x62, 0x62, 0x39, 0x65, 0x65, 0x37, 0x36, 0x30, 0x38, 0x38, 0x34, 0x64, 0x61, 0x66, 0x33, 0x31, 0x34, 0x64, 0x38, 0x64, 0x35, 0x65, 0x31, 0x35, 0x62, 0x38, 0x64, 0x33, 0x66, 0x33, 0x66, 0x33, 0x33, 0x37, 0x32, 0x62, 0x63, 0x34, 0x65, 0x32, 0x36, 0x30, 0x63, 0x35, 0x65, 0x65, 0x62, 0x63, 0x35, 0x61, 0x33, 0x36, 0x66, 0x35, 0x37, 0x32, 0x61, 0x37, 0x33, 0x66, 0x35, 0x34, 0x65, 0x32, 0x38, 0x33, 0x66, 0x30, 0x38, 0x35, 0x31, 0x65, 0x37, 0x38, 0x33, 0x36, 0x61, 0x35, 0x30, 0x35, 0x64, 0x38, 0x63, 0x30, 0x34, 0x35, 0x32, 0x35, 0x39, 0x35, 0x65, 0x65, 0x64, 0x37, 0x66, 0x64, 0x65, 0x63, 0x39, 0x39, 0x30, 0x61, 0x63, 0x38, 0x36, 0x34, 0x61, 0x36, 0x32, 0x63, 0x62, 0x33, 0x65, 0x61, 0x39, 0x37, 0x31, 0x38, 0x33, 0x64, 0x39, 0x64, 0x34, 0x35, 0x37, 0x65, 0x65, 0x37, 0x38, 0x63, 0x37, 0x66, 0x37, 0x34, 0x37, 0x64, 0x31, 0x30, 0x32, 0x34, 0x36, 0x30, 0x39, 0x66, 0x66, 0x39, 0x31, 0x39, 0x30, 0x65, 0x37, 0x62, 0x33, 0x38, 0x66, 0x35, 0x38, 0x32, 0x65, 0x35, 0x62, 0x33, 0x39, 0x63, 0x62, 0x66, 0x37, 0x35, 0x37, 0x32, 0x31, 0x32, 0x32, 0x33, 0x65, 0x33, 0x65, 0x31, 0x64, 0x65, 0x38, 0x64, 0x34, 0x34, 0x64, 0x38, 0x32, 0x37, 0x33, 0x63, 0x37, 0x65, 0x31, 0x66, 0x38, 0x32, 0x39, 0x31, 0x31, 0x62, 0x38, 0x32, 0x33, 0x64, 0x31, 0x39, 0x66, 0x63, 0x37, 0x36, 0x61, 0x65, 0x38, 0x63, 0x61, 0x38, 0x62, 0x38, 0x64, 0x63, 0x65, 0x32, 0x38, 0x66, 0x36, 0x63, 0x32, 0x30, 0x64, 0x34, 0x38, 0x63, 0x37, 0x32, 0x65, 0x37, 0x32, 0x34, 0x32, 0x39, 0x65, 0x66, 0x33, 0x36, 0x61, 0x37, 0x34, 0x38, 0x37, 0x36, 0x38, 0x30, 0x64, 0x61, 0x39, 0x35, 0x31, 0x32, 0x32, 0x39, 0x34, 0x34, 0x36, 0x37, 0x39, 0x66, 0x64, 0x31, 0x34, 0x64, 0x33, 0x63, 0x36, 0x64, 0x32, 0x38, 0x63, 0x38, 0x31, 0x35, 0x31, 0x38, 0x37, 0x39, 0x35, 0x62, 0x62, 0x64, 0x63, 0x38, 0x31, 0x31, 0x66, 0x31, 0x63, 0x61, 0x36, 0x31, 0x31, 0x36, 0x64, 0x62, 0x63, 0x65, 0x63, 0x32, 0x34, 0x62, 0x32, 0x36, 0x63, 0x37, 0x30, 0x38, 0x61, 0x65, 0x30, 0x37, 0x64, 0x38, 0x32, 0x62, 0x38, 0x66, 0x37, 0x32, 0x38, 0x34, 0x37, 0x37, 0x33, 0x66, 0x32, 0x33, 0x33, 0x34, 0x39, 0x34, 0x36, 0x66, 0x31, 0x35, 0x62, 0x63, 0x32, 0x33, 0x63, 0x39, 0x35, 0x37, 0x32, 0x38, 0x31, 0x31, 0x30, 0x32, 0x32, 0x39, 0x35, 0x35, 0x33, 0x62, 0x32, 0x61, 0x62, 0x65, 0x35, 0x38, 0x39, 0x32, 0x34, 0x32, 0x32, 0x34, 0x65, 0x64, 0x30, 0x64, 0x64, 0x64, 0x61, 0x34, 0x37, 0x35, 0x36, 0x33, 0x61, 0x38, 0x62, 0x34, 0x35, 0x61, 0x63, 0x38, 0x30, 0x35, 0x62, 0x38, 0x66, 0x65, 0x64, 0x35, 0x35, 0x38, 0x34, 0x62, 0x37, 0x33, 0x37, 0x32, 0x62, 0x62, 0x66, 0x64, 0x33, 0x62, 0x35, 0x65, 0x36, 0x30, 0x37, 0x30, 0x66, 0x36, 0x36, 0x63, 0x62, 0x34, 0x38, 0x37, 0x31, 0x34, 0x66, 0x33, 0x62, 0x34, 0x32, 0x64, 0x61, 0x33, 0x31, 0x63, 0x62, 0x30, 0x31, 0x31, 0x34, 0x38, 0x33, 0x31, 0x65, 0x34, 0x64, 0x31, 0x39, 0x34, 0x62, 0x38, 0x36, 0x39, 0x61, 0x35, 0x34, 0x30, 0x61, 0x36, 0x35, 0x30, 0x36, 0x30, 0x36, 0x32, 0x32, 0x65, 0x61, 0x33, 0x39, 0x65, 0x34, 0x38, 0x62, 0x34, 0x62, 0x32, 0x62, 0x35, 0x33, 0x39, 0x37, 0x32, 0x38, 0x31, 0x64, 0x63, 0x37, 0x66, 0x65, 0x64, 0x39, 0x31, 0x66, 0x34, 0x32, 0x64, 0x31, 0x63, 0x33, 0x39, 0x63, 0x31, 0x63, 0x65, 0x38, 0x36, 0x62, 0x34, 0x33, 0x37, 0x32, 0x35, 0x37, 0x34, 0x38, 0x63, 0x61, 0x32, 0x65, 0x65, 0x65, 0x64, 0x37, 0x31, 0x37, 0x31, 0x33, 0x33, 0x39, 0x32, 0x34, 0x35, 0x62, 0x32, 0x30, 0x31, 0x65, 0x64, 0x31, 0x32, 0x63, 0x36, 0x35, 0x63, 0x31, 0x37, 0x37, 0x63, 0x65, 0x34, 0x65, 0x39, 0x30, 0x38, 0x34, 0x64, 0x38, 0x65, 0x65, 0x36, 0x66, 0x34, 0x31, 0x32, 0x32, 0x34, 0x36, 0x66, 0x65, 0x35, 0x64, 0x30, 0x35, 0x38, 0x64, 0x32, 0x64, 0x33, 0x61, 0x65, 0x36, 0x33, 0x38, 0x64, 0x62, 0x39, 0x31, 0x31, 0x37, 0x30, 0x38, 0x34, 0x62, 0x35, 0x63, 0x61, 0x64, 0x31, 0x39, 0x36, 0x38, 0x36, 0x33, 0x65, 0x62, 0x39, 0x37, 0x33, 0x35, 0x63, 0x35, 0x37, 0x32, 0x33, 0x31, 0x66, 0x39, 0x62, 0x65, 0x31, 0x30, 0x31, 0x31, 0x31, 0x38, 0x33, 0x30, 0x31, 0x33, 0x63, 0x33, 0x39, 0x65, 0x32, 0x64, 0x32, 0x64, 0x30, 0x32, 0x62, 0x62, 0x36, 0x63, 0x66, 0x39, 0x61, 0x61, 0x34, 0x61, 0x37, 0x36, 0x35, 0x31, 0x38, 0x36, 0x61, 0x36, 0x38, 0x30, 0x34, 0x62, 0x36, 0x61, 0x38, 0x39, 0x33, 0x65, 0x65, 0x63, 0x36, 0x62, 0x66, 0x37, 0x32, 0x34, 0x34, 0x33, 0x38, 0x65, 0x64, 0x64, 0x63, 0x37, 0x63, 0x36, 0x31, 0x39, 0x36, 0x64, 0x34, 0x61, 0x31, 0x33, 0x39, 0x65, 0x62, 0x64, 0x36, 0x39, 0x38, 0x38, 0x61, 0x31, 0x62, 0x61, 0x62, 0x30, 0x65, 0x34, 0x31, 0x64, 0x65, 0x36, 0x38, 0x35, 0x62, 0x31, 0x33, 0x30, 0x32, 0x34, 0x38, 0x30, 0x61, 0x39, 0x65, 0x30, 0x62, 0x39, 0x36, 0x34, 0x37, 0x31, 0x35, 0x64, 0x66, 0x36, 0x64, 0x34, 0x39, 0x65, 0x39, 0x34, 0x62, 0x39, 0x62, 0x37, 0x65, 0x62, 0x33, 0x63, 0x63, 0x31, 0x37, 0x31, 0x31, 0x64, 0x37, 0x38, 0x30, 0x64, 0x31, 0x33, 0x62, 0x62, 0x31, 0x36, 0x33, 0x31, 0x31, 0x63, 0x36, 0x66, 0x36, 0x37, 0x65, 0x63, 0x35, 0x34, 0x32, 0x31, 0x65, 0x63, 0x36, 0x62, 0x36, 0x30, 0x38, 0x64, 0x62, 0x64, 0x36, 0x66, 0x33, 0x37, 0x64, 0x31, 0x33, 0x64, 0x64, 0x32, 0x61, 0x63, 0x38, 0x66, 0x65, 0x35, 0x38, 0x35, 0x39, 0x63, 0x36, 0x62, 0x37, 0x30, 0x35, 0x64, 0x30, 0x38, 0x34, 0x35, 0x33, 0x34, 0x63, 0x63, 0x61, 0x33, 0x31, 0x63, 0x66, 0x30, 0x38, 0x62, 0x32, 0x64, 0x30, 0x63, 0x37, 0x38, 0x36, 0x64, 0x31, 0x36, 0x33, 0x31, 0x62, 0x38, 0x33, 0x31, 0x39, 0x37, 0x62, 0x32, 0x33, 0x65, 0x63, 0x63, 0x36, 0x61, 0x61, 0x35, 0x33, 0x30, 0x30, 0x37, 0x32, 0x36, 0x39, 0x39, 0x34, 0x62, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x34, 0x62, 0x35, 0x33, 0x31, 0x62, 0x36, 0x30, 0x30, 0x61, 0x65, 0x62, 0x32, 0x30, 0x38, 0x63, 0x65, 0x35, 0x33, 0x35, 0x34, 0x36, 0x64, 0x63, 0x36, 0x30, 0x36, 0x39, 0x30, 0x37, 0x62, 0x63, 0x35, 0x65, 0x33, 0x34, 0x30, 0x31, 0x39, 0x35, 0x62, 0x36, 0x66, 0x38, 0x32, 0x38, 0x34, 0x33, 0x34, 0x31, 0x61, 0x37, 0x32, 0x30, 0x30, 0x35, 0x38, 0x63, 0x66, 0x33, 0x61, 0x36, 0x34, 0x34, 0x63, 0x62, 0x39, 0x63, 0x30, 0x33, 0x30, 0x63, 0x33, 0x62, 0x65, 0x39, 0x30, 0x62, 0x38, 0x62, 0x31, 0x30, 0x63, 0x37, 0x37, 0x39, 0x65, 0x64, 0x63, 0x66, 0x31, 0x65, 0x63, 0x30, 0x61, 0x65, 0x30, 0x30, 0x65, 0x31, 0x35, 0x32, 0x34, 0x35, 0x62, 0x66, 0x39, 0x36, 0x34, 0x64, 0x34, 0x31, 0x63, 0x65, 0x37, 0x37, 0x32, 0x63, 0x65, 0x35, 0x36, 0x65, 0x39, 0x36, 0x36, 0x66, 0x63, 0x64, 0x63, 0x64, 0x38, 0x63, 0x62, 0x36, 0x63, 0x37, 0x64, 0x30, 0x34, 0x30, 0x62, 0x31, 0x32, 0x34, 0x35, 0x61, 0x66, 0x35, 0x64, 0x30, 0x38, 0x34, 0x64, 0x31, 0x38, 0x39, 0x32, 0x64, 0x37, 0x34, 0x36, 0x36, 0x64, 0x34, 0x33, 0x64, 0x30, 0x32, 0x66, 0x63, 0x32, 0x65, 0x64, 0x31, 0x34, 0x62, 0x63, 0x62, 0x36, 0x37, 0x32, 0x61, 0x65, 0x31, 0x34, 0x64, 0x62, 0x38, 0x66, 0x32, 0x33, 0x37, 0x37, 0x61, 0x62, 0x32, 0x31, 0x36, 0x66, 0x32, 0x34, 0x62, 0x35, 0x31, 0x39, 0x62, 0x39, 0x39, 0x35, 0x37, 0x65, 0x34, 0x39, 0x61, 0x39, 0x61, 0x63, 0x30, 0x32, 0x32, 0x35, 0x34, 0x33, 0x61, 0x33, 0x63, 0x33, 0x36, 0x33, 0x30, 0x62, 0x31, 0x38, 0x33, 0x35, 0x61, 0x36, 0x36, 0x35, 0x30, 0x62, 0x35, 0x31, 0x37, 0x32, 0x33, 0x61, 0x64, 0x34, 0x66, 0x61, 0x66, 0x38, 0x63, 0x36, 0x32, 0x63, 0x62, 0x65, 0x38, 0x37, 0x62, 0x37, 0x35, 0x32, 0x34, 0x36, 0x31, 0x35, 0x36, 0x36, 0x39, 0x36, 0x33, 0x34, 0x32, 0x63, 0x63, 0x37, 0x66, 0x36, 0x36, 0x35, 0x34, 0x37, 0x35, 0x30, 0x65, 0x32, 0x32, 0x36, 0x62, 0x32, 0x61, 0x33, 0x38, 0x66, 0x62, 0x38, 0x33, 0x32, 0x38, 0x37, 0x66, 0x35, 0x30, 0x30, 0x37, 0x32, 0x30, 0x33, 0x30, 0x62, 0x64, 0x63, 0x36, 0x64, 0x66, 0x66, 0x35, 0x62, 0x64, 0x37, 0x36, 0x32, 0x33, 0x63, 0x39, 0x33, 0x61, 0x61, 0x63, 0x32, 0x37, 0x37, 0x64, 0x61, 0x39, 0x32, 0x35, 0x37, 0x64, 0x34, 0x61, 0x30, 0x65, 0x35, 0x37, 0x34, 0x64, 0x39, 0x31, 0x65, 0x34, 0x39, 0x32, 0x63, 0x30, 0x35, 0x62, 0x34, 0x39, 0x65, 0x63, 0x61, 0x61, 0x62, 0x33, 0x62, 0x36, 0x66, 0x36, 0x36, 0x62, 0x31, 0x32, 0x66, 0x39, 0x31, 0x31, 0x62, 0x38, 0x31, 0x65, 0x34, 0x33, 0x39, 0x32, 0x62, 0x33, 0x37, 0x32, 0x61, 0x35, 0x34, 0x61, 0x64, 0x35, 0x36, 0x37, 0x62, 0x31, 0x31, 0x36, 0x36, 0x31, 0x64, 0x35, 0x38, 0x34, 0x35, 0x39, 0x38, 0x66, 0x30, 0x61, 0x34, 0x30, 0x37, 0x64, 0x61, 0x33, 0x66, 0x36, 0x38, 0x34, 0x38, 0x37, 0x66, 0x35, 0x61, 0x33, 0x36, 0x39, 0x61, 0x37, 0x32, 0x38, 0x62, 0x34, 0x33, 0x61, 0x30, 0x36, 0x35, 0x30, 0x64, 0x61, 0x66, 0x64, 0x63, 0x66, 0x35, 0x38, 0x65, 0x66, 0x65, 0x33, 0x31, 0x64, 0x62, 0x32, 0x65, 0x33, 0x35, 0x64, 0x36, 0x30, 0x33, 0x64, 0x36, 0x31, 0x64, 0x34, 0x62, 0x37, 0x63, 0x37, 0x37, 0x36, 0x63, 0x33, 0x38, 0x32, 0x31, 0x63, 0x39, 0x66, 0x33, 0x65, 0x66, 0x62, 0x37, 0x65, 0x66, 0x36, 0x65, 0x33, 0x65, 0x37, 0x32, 0x30, 0x62, 0x32, 0x36, 0x37, 0x64, 0x33, 0x38, 0x36, 0x33, 0x65, 0x37, 0x61, 0x38, 0x36, 0x32, 0x64, 0x66, 0x66, 0x64, 0x30, 0x31, 0x62, 0x31, 0x63, 0x39, 0x33, 0x32, 0x30, 0x66, 0x34, 0x63, 0x66, 0x33, 0x32, 0x37, 0x35, 0x39, 0x65, 0x32, 0x32, 0x66, 0x61, 0x37, 0x33, 0x62, 0x35, 0x66, 0x32, 0x31, 0x33, 0x36, 0x31, 0x63, 0x36, 0x33, 0x36, 0x36, 0x33, 0x62, 0x63, 0x33, 0x37, 0x32, 0x35, 0x61, 0x32, 0x36, 0x36, 0x37, 0x39, 0x62, 0x66, 0x32, 0x64, 0x65, 0x65, 0x66, 0x33, 0x61, 0x39, 0x61, 0x35, 0x36, 0x62, 0x39, 0x30, 0x65, 0x62, 0x64, 0x38, 0x34, 0x34, 0x65, 0x65, 0x66, 0x62, 0x63, 0x63, 0x66, 0x63, 0x34, 0x37, 0x66, 0x38, 0x38, 0x39, 0x39, 0x34, 0x34, 0x63, 0x31, 0x62, 0x39, 0x31, 0x64, 0x66, 0x39, 0x38, 0x32, 0x31, 0x33, 0x37, 0x62, 0x38, 0x31, 0x37, 0x32, 0x36, 0x35, 0x32, 0x61, 0x64, 0x39, 0x38, 0x34, 0x63, 0x39, 0x31, 0x30, 0x35, 0x37, 0x38, 0x37, 0x65, 0x36, 0x32, 0x38, 0x37, 0x34, 0x32, 0x33, 0x63, 0x66, 0x34, 0x32, 0x33, 0x37, 0x61, 0x31, 0x31, 0x62, 0x35, 0x63, 0x35, 0x61, 0x36, 0x35, 0x65, 0x38, 0x35, 0x33, 0x33, 0x65, 0x31, 0x36, 0x31, 0x31, 0x61, 0x38, 0x30, 0x35, 0x30, 0x35, 0x66, 0x32, 0x61, 0x31, 0x34, 0x38, 0x37, 0x32, 0x30, 0x35, 0x38, 0x62, 0x65, 0x38, 0x33, 0x64, 0x32, 0x38, 0x64, 0x33, 0x62, 0x62, 0x31, 0x61, 0x64, 0x34, 0x65, 0x65, 0x63, 0x36, 0x37, 0x62, 0x61, 0x35, 0x33, 0x37, 0x65, 0x36, 0x30, 0x31, 0x64, 0x61, 0x34, 0x37, 0x34, 0x33, 0x35, 0x33, 0x31, 0x39, 0x64, 0x32, 0x30, 0x31, 0x65, 0x34, 0x65, 0x36, 0x65, 0x32, 0x37, 0x30, 0x36, 0x66, 0x38, 0x62, 0x62, 0x63, 0x33, 0x37, 0x37, 0x32, 0x61, 0x37, 0x65, 0x63, 0x37, 0x36, 0x66, 0x35, 0x37, 0x30, 0x63, 0x32, 0x39, 0x37, 0x30, 0x37, 0x36, 0x31, 0x64, 0x64, 0x33, 0x36, 0x37, 0x36, 0x65, 0x32, 0x32, 0x64, 0x30, 0x64, 0x61, 0x38, 0x61, 0x61, 0x61, 0x64, 0x66, 0x62, 0x65, 0x31, 0x32, 0x30, 0x62, 0x36, 0x65, 0x66, 0x63, 0x62, 0x38, 0x66, 0x31, 0x65, 0x37, 0x64, 0x34, 0x39, 0x63, 0x31, 0x37, 0x64, 0x35, 0x62, 0x37, 0x32, 0x66, 0x37, 0x36, 0x38, 0x62, 0x30, 0x39, 0x39, 0x36, 0x63, 0x61, 0x62, 0x30, 0x63, 0x64, 0x31, 0x33, 0x36, 0x31, 0x38, 0x36, 0x36, 0x34, 0x35, 0x62, 0x65, 0x64, 0x35, 0x33, 0x64, 0x37, 0x35, 0x61, 0x35, 0x32, 0x33, 0x38, 0x63, 0x39, 0x30, 0x38, 0x36, 0x39, 0x61, 0x35, 0x37, 0x35, 0x63, 0x64, 0x61, 0x62, 0x33, 0x37, 0x62, 0x32, 0x61, 0x62, 0x31, 0x61, 0x30, 0x64, 0x37, 0x37, 0x32, 0x35, 0x39, 0x61, 0x63, 0x36, 0x39, 0x33, 0x34, 0x62, 0x35, 0x61, 0x38, 0x66, 0x37, 0x64, 0x61, 0x65, 0x31, 0x30, 0x30, 0x36, 0x37, 0x35, 0x62, 0x64, 0x32, 0x34, 0x65, 0x64, 0x32, 0x34, 0x64, 0x37, 0x37, 0x39, 0x61, 0x65, 0x62, 0x39, 0x38, 0x64, 0x61, 0x66, 0x31, 0x64, 0x61, 0x61, 0x64, 0x62, 0x33, 0x34, 0x66, 0x31, 0x30, 0x62, 0x62, 0x35, 0x65, 0x63, 0x32, 0x32, 0x61, 0x36, 0x36, 0x65, 0x34, 0x33, 0x32, 0x37, 0x31, 0x33, 0x63, 0x39, 0x62, 0x33, 0x36, 0x37, 0x65, 0x63, 0x64, 0x39, 0x31, 0x32, 0x39, 0x38, 0x63, 0x62, 0x62, 0x62, 0x63, 0x61, 0x34, 0x65, 0x32, 0x37, 0x66, 0x30, 0x33, 0x65, 0x33, 0x33, 0x32, 0x64, 0x39, 0x33, 0x66, 0x37, 0x32, 0x31, 0x65, 0x30, 0x38, 0x37, 0x38, 0x65, 0x66, 0x61, 0x39, 0x35, 0x30, 0x35, 0x62, 0x37, 0x61, 0x32, 0x36, 0x36, 0x30, 0x62, 0x36, 0x34, 0x33, 0x37, 0x30, 0x64, 0x33, 0x37, 0x62, 0x62, 0x37, 0x64, 0x30, 0x66, 0x64, 0x63, 0x34, 0x34, 0x34, 0x35, 0x38, 0x30, 0x36, 0x30, 0x38, 0x66, 0x61, 0x36, 0x34, 0x62, 0x61, 0x61, 0x65, 0x39, 0x37, 0x38, 0x31, 0x61, 0x65, 0x30, 0x31, 0x38, 0x62, 0x30, 0x35, 0x36, 0x39, 0x61, 0x64, 0x33, 0x61, 0x32, 0x33, 0x38, 0x61, 0x35, 0x35, 0x39, 0x36, 0x36, 0x62, 0x37, 0x32, 0x62, 0x36, 0x61, 0x63, 0x66, 0x66, 0x38, 0x30, 0x33, 0x62, 0x36, 0x39, 0x63, 0x31, 0x35, 0x66, 0x62, 0x61, 0x30, 0x38, 0x63, 0x65, 0x34, 0x32, 0x35, 0x38, 0x36, 0x34, 0x61, 0x39, 0x64, 0x38, 0x34, 0x34, 0x64, 0x63, 0x62, 0x35, 0x36, 0x32, 0x39, 0x39, 0x39, 0x39, 0x35, 0x36, 0x65, 0x61, 0x61, 0x30, 0x35, 0x39, 0x65, 0x34, 0x63, 0x62, 0x39, 0x38, 0x64, 0x33, 0x36, 0x32, 0x37, 0x32, 0x64, 0x64, 0x62, 0x33, 0x34, 0x30, 0x63, 0x34, 0x30, 0x35, 0x63, 0x36, 0x32, 0x30, 0x36, 0x36, 0x32, 0x38, 0x62, 0x61, 0x66, 0x65, 0x38, 0x63, 0x33, 0x34, 0x61, 0x36, 0x37, 0x63, 0x31, 0x36, 0x31, 0x66, 0x34, 0x63, 0x38, 0x64, 0x34, 0x36, 0x34, 0x35, 0x39, 0x63, 0x36, 0x31, 0x30, 0x62, 0x30, 0x38, 0x62, 0x61, 0x31, 0x62, 0x65, 0x62, 0x63, 0x32, 0x36, 0x34, 0x65, 0x65, 0x36, 0x37, 0x32, 0x61, 0x39, 0x65, 0x36, 0x35, 0x62, 0x33, 0x64, 0x63, 0x35, 0x36, 0x36, 0x38, 0x39, 0x39, 0x37, 0x32, 0x37, 0x64, 0x31, 0x38, 0x33, 0x38, 0x30, 0x34, 0x66, 0x65, 0x30, 0x32, 0x32, 0x32, 0x34, 0x30, 0x30, 0x39, 0x61, 0x39, 0x62, 0x31, 0x37, 0x30, 0x38, 0x65, 0x33, 0x36, 0x34, 0x63, 0x38, 0x65, 0x66, 0x36, 0x36, 0x37, 0x36, 0x37, 0x63, 0x37, 0x61, 0x63, 0x66, 0x38, 0x30, 0x34, 0x39, 0x66, 0x64, 0x63, 0x36, 0x64, 0x32, 0x30, 0x62, 0x61, 0x32, 0x34, 0x63, 0x32, 0x31, 0x39, 0x65, 0x36, 0x39, 0x62, 0x34, 0x39, 0x35, 0x38, 0x61, 0x32, 0x65, 0x30, 0x37, 0x30, 0x36, 0x31, 0x32, 0x38, 0x39, 0x37, 0x37, 0x66, 0x62, 0x31, 0x61, 0x61, 0x64, 0x39, 0x61, 0x35, 0x64, 0x64, 0x65, 0x65, 0x38, 0x38, 0x66, 0x38, 0x64, 0x37, 0x63, 0x66, 0x33, 0x65, 0x38, 0x39, 0x30, 0x31, 0x31, 0x38, 0x32, 0x36, 0x33, 0x64, 0x39, 0x32, 0x65, 0x36, 0x36, 0x39, 0x61, 0x34, 0x34, 0x30, 0x34, 0x33, 0x62, 0x33, 0x30, 0x37, 0x33, 0x34, 0x66, 0x35, 0x37, 0x36, 0x38, 0x30, 0x35, 0x30, 0x64, 0x34, 0x30, 0x61, 0x63, 0x30, 0x39, 0x63, 0x62, 0x65, 0x38, 0x64, 0x39, 0x35, 0x63, 0x64, 0x39, 0x34, 0x33, 0x36, 0x36, 0x31, 0x39, 0x66, 0x35, 0x65, 0x66, 0x34, 0x31, 0x38, 0x35, 0x32, 0x31, 0x38, 0x35, 0x36, 0x34, 0x37, 0x30, 0x39, 0x63, 0x66, 0x39, 0x32, 0x63, 0x66, 0x37, 0x38, 0x66, 0x37, 0x66, 0x38, 0x61, 0x36, 0x66, 0x32, 0x62, 0x32, 0x39, 0x32, 0x63, 0x30, 0x65, 0x64, 0x30, 0x38, 0x62, 0x65, 0x65, 0x31, 0x63, 0x31, 0x66, 0x31, 0x66, 0x38, 0x30, 0x33, 0x37, 0x64, 0x32, 0x32, 0x32, 0x63, 0x37, 0x36, 0x64, 0x65, 0x31, 0x62, 0x38, 0x62, 0x35, 0x65, 0x37, 0x32, 0x31, 0x64, 0x62, 0x36, 0x30, 0x30, 0x35, 0x33, 0x38, 0x30, 0x31, 0x64, 0x64, 0x31, 0x65, 0x39, 0x64, 0x35, 0x38, 0x30, 0x38, 0x63, 0x38, 0x34, 0x64, 0x38, 0x32, 0x30, 0x37, 0x33, 0x64, 0x36, 0x34, 0x35, 0x38, 0x38, 0x61, 0x64, 0x30, 0x38, 0x32, 0x66, 0x66, 0x32, 0x62, 0x32, 0x30, 0x62, 0x64, 0x33, 0x32, 0x66, 0x30, 0x35, 0x65, 0x34, 0x65, 0x30, 0x34, 0x30, 0x34, 0x32, 0x30, 0x33, 0x38, 0x33, 0x36, 0x33, 0x37, 0x37, 0x62, 0x38, 0x64, 0x33, 0x62, 0x38, 0x30, 0x63, 0x62, 0x35, 0x37, 0x62, 0x65, 0x32, 0x37, 0x38, 0x39, 0x38, 0x38, 0x33, 0x39, 0x64, 0x34, 0x36, 0x37, 0x33, 0x61, 0x30, 0x62, 0x36, 0x35, 0x63, 0x37, 0x62, 0x38, 0x61, 0x63, 0x38, 0x66, 0x66, 0x64, 0x31, 0x36, 0x63, 0x31, 0x63, 0x64, 0x61, 0x33, 0x35, 0x38, 0x63, 0x39, 0x62, 0x30, 0x61, 0x30, 0x38, 0x64, 0x39, 0x34, 0x66, 0x39, 0x61, 0x30, 0x64, 0x64, 0x31, 0x64, 0x38, 0x66, 0x65, 0x35, 0x63, 0x62, 0x39, 0x61, 0x66, 0x35, 0x61, 0x31, 0x34, 0x36, 0x38, 0x66, 0x33, 0x38, 0x66, 0x31, 0x30, 0x35, 0x31, 0x38, 0x62, 0x32, 0x31, 0x30, 0x32, 0x36, 0x65, 0x35, 0x30, 0x61, 0x36, 0x63, 0x65, 0x61, 0x37, 0x66, 0x61, 0x66, 0x63, 0x37, 0x36, 0x39, 0x39, 0x37, 0x35, 0x34, 0x35, 0x37, 0x32, 0x65, 0x38, 0x64, 0x66, 0x31, 0x39, 0x39, 0x30, 0x65, 0x64, 0x65, 0x35, 0x33, 0x66, 0x30, 0x63, 0x36, 0x66, 0x37, 0x61, 0x66, 0x30, 0x38, 0x65, 0x39, 0x39, 0x32, 0x34, 0x30, 0x38, 0x37, 0x34, 0x62, 0x66, 0x31, 0x35, 0x33, 0x33, 0x62, 0x64, 0x33, 0x66, 0x35, 0x39, 0x37, 0x35, 0x38, 0x38, 0x38, 0x34, 0x33, 0x64, 0x61, 0x33, 0x30, 0x65, 0x33, 0x66, 0x33, 0x37, 0x30, 0x39, 0x34, 0x63, 0x65, 0x35, 0x36, 0x32, 0x63, 0x62, 0x61, 0x34, 0x32, 0x65, 0x30, 0x65, 0x64, 0x66, 0x30, 0x35, 0x38, 0x36, 0x30, 0x30, 0x38, 0x39, 0x63, 0x30, 0x39, 0x38, 0x36, 0x30, 0x61, 0x38, 0x65, 0x38, 0x66, 0x66, 0x64, 0x35, 0x34, 0x63, 0x61, 0x35, 0x38, 0x37, 0x66, 0x61, 0x61, 0x34, 0x31, 0x66, 0x30, 0x31, 0x63, 0x31, 0x36, 0x33, 0x64, 0x36, 0x35, 0x62, 0x66, 0x39, 0x32, 0x31, 0x33, 0x39, 0x61, 0x35, 0x32, 0x39, 0x37, 0x35, 0x32, 0x61, 0x33, 0x35, 0x30, 0x65, 0x31, 0x36, 0x30, 0x31, 0x35, 0x63, 0x35, 0x61, 0x37, 0x32, 0x38, 0x62, 0x64, 0x38, 0x31, 0x34, 0x64, 0x34, 0x32, 0x64, 0x39, 0x33, 0x37, 0x39, 0x65, 0x34, 0x38, 0x64, 0x35, 0x32, 0x65, 0x30, 0x39, 0x32, 0x39, 0x34, 0x66, 0x36, 0x33, 0x36, 0x39, 0x33, 0x33, 0x36, 0x63, 0x62, 0x62, 0x33, 0x32, 0x66, 0x37, 0x32, 0x31, 0x65, 0x31, 0x61, 0x65, 0x39, 0x32, 0x30, 0x65, 0x30, 0x39, 0x36, 0x31, 0x37, 0x31, 0x66, 0x32, 0x35, 0x62, 0x62, 0x66, 0x61, 0x31, 0x66, 0x35, 0x36, 0x38, 0x64, 0x63, 0x61, 0x66, 0x39, 0x31, 0x39, 0x39, 0x61, 0x32, 0x31, 0x63, 0x35, 0x66, 0x63, 0x31, 0x36, 0x30, 0x39, 0x63, 0x35, 0x33, 0x36, 0x66, 0x35, 0x30, 0x38, 0x30, 0x64, 0x62, 0x61, 0x66, 0x62, 0x38, 0x37, 0x37, 0x32, 0x35, 0x30, 0x65, 0x34, 0x37, 0x39, 0x34, 0x66, 0x61, 0x31, 0x39, 0x64, 0x61, 0x39, 0x35, 0x30, 0x63, 0x39, 0x37, 0x39, 0x30, 0x65, 0x31, 0x30, 0x31, 0x62, 0x33, 0x61, 0x65, 0x36, 0x39, 0x62, 0x39, 0x32, 0x30, 0x34, 0x34, 0x30, 0x32, 0x34, 0x36, 0x32, 0x32, 0x66, 0x32, 0x65, 0x32, 0x64, 0x30, 0x66, 0x30, 0x62, 0x38, 0x34, 0x65, 0x66, 0x63, 0x63, 0x31, 0x32, 0x32, 0x62, 0x33, 0x37, 0x36, 0x30, 0x66, 0x33, 0x62, 0x37, 0x37, 0x38, 0x32, 0x32, 0x38, 0x63, 0x36, 0x36, 0x65, 0x61, 0x37, 0x62, 0x32, 0x62, 0x65, 0x66, 0x63, 0x35, 0x31, 0x38, 0x34, 0x62, 0x39, 0x39, 0x34, 0x33, 0x63, 0x31, 0x34, 0x30, 0x34, 0x37, 0x33, 0x65, 0x64, 0x34, 0x30, 0x61, 0x65, 0x33, 0x65, 0x64, 0x61, 0x37, 0x64, 0x30, 0x34, 0x37, 0x31, 0x31, 0x61, 0x66, 0x32, 0x35, 0x31, 0x33, 0x31, 0x33, 0x36, 0x33, 0x62, 0x38, 0x62, 0x35, 0x35, 0x39, 0x66, 0x39, 0x66, 0x36, 0x33, 0x35, 0x31, 0x64, 0x30, 0x33, 0x35, 0x39, 0x31, 0x37, 0x38, 0x38, 0x35, 0x33, 0x32, 0x62, 0x36, 0x61, 0x34, 0x32, 0x66, 0x61, 0x34, 0x65, 0x36, 0x34, 0x36, 0x37, 0x37, 0x62, 0x63, 0x38, 0x38, 0x35, 0x37, 0x33, 0x61, 0x30, 0x33, 0x33, 0x66, 0x35, 0x39, 0x63, 0x34, 0x61, 0x36, 0x33, 0x36, 0x66, 0x37, 0x32, 0x32, 0x37, 0x61, 0x37, 0x33, 0x33, 0x32, 0x36, 0x36, 0x31, 0x38, 0x36, 0x39, 0x65, 0x37, 0x37, 0x62, 0x37, 0x63, 0x36, 0x61, 0x37, 0x39, 0x65, 0x64, 0x33, 0x31, 0x31, 0x66, 0x33, 0x64, 0x39, 0x66, 0x33, 0x66, 0x38, 0x33, 0x65, 0x65, 0x31, 0x65, 0x65, 0x66, 0x32, 0x61, 0x39, 0x64, 0x65, 0x34, 0x63, 0x35, 0x37, 0x32, 0x34, 0x66, 0x63, 0x36, 0x36, 0x33, 0x33, 0x64, 0x61, 0x33, 0x32, 0x66, 0x66, 0x39, 0x36, 0x37, 0x33, 0x65, 0x62, 0x61, 0x37, 0x62, 0x61, 0x32, 0x35, 0x62, 0x34, 0x36, 0x36, 0x30, 0x38, 0x31, 0x34, 0x62, 0x31, 0x30, 0x30, 0x65, 0x63, 0x38, 0x38, 0x61, 0x32, 0x64, 0x62, 0x34, 0x38, 0x38, 0x34, 0x35, 0x39, 0x35, 0x62, 0x39, 0x35, 0x61, 0x38, 0x66, 0x32, 0x33, 0x65, 0x65, 0x35, 0x63, 0x38, 0x64, 0x61, 0x32, 0x61, 0x65, 0x34, 0x62, 0x65, 0x37, 0x32, 0x33, 0x65, 0x32, 0x62, 0x62, 0x65, 0x34, 0x33, 0x64, 0x30, 0x62, 0x66, 0x36, 0x39, 0x31, 0x64, 0x32, 0x62, 0x34, 0x36, 0x30, 0x64, 0x39, 0x65, 0x66, 0x39, 0x65, 0x38, 0x31, 0x36, 0x33, 0x38, 0x30, 0x32, 0x32, 0x37, 0x38, 0x62, 0x62, 0x36, 0x62, 0x30, 0x33, 0x33, 0x62, 0x35, 0x36, 0x31, 0x64, 0x31, 0x66, 0x35, 0x35, 0x63, 0x34, 0x35, 0x62, 0x31, 0x33, 0x37, 0x66, 0x61, 0x31, 0x39, 0x37, 0x35, 0x63, 0x61, 0x62, 0x39, 0x66, 0x38, 0x65, 0x64, 0x65, 0x65, 0x34, 0x65, 0x37, 0x61, 0x64, 0x31, 0x66, 0x38, 0x65, 0x35, 0x31, 0x37, 0x38, 0x30, 0x38, 0x65, 0x31, 0x32, 0x61, 0x34, 0x39, 0x66, 0x66, 0x62, 0x31, 0x33, 0x37, 0x34, 0x65, 0x62, 0x66, 0x37, 0x35, 0x63, 0x39, 0x38, 0x30, 0x65, 0x61, 0x66, 0x35, 0x66, 0x34, 0x32, 0x65, 0x61, 0x31, 0x34, 0x61, 0x33, 0x37, 0x32, 0x66, 0x64, 0x62, 0x66, 0x36, 0x32, 0x39, 0x31, 0x35, 0x64, 0x65, 0x62, 0x35, 0x66, 0x61, 0x62, 0x39, 0x61, 0x36, 0x62, 0x36, 0x64, 0x38, 0x66, 0x37, 0x30, 0x66, 0x30, 0x39, 0x62, 0x61, 0x39, 0x35, 0x33, 0x33, 0x37, 0x39, 0x39, 0x63, 0x38, 0x65, 0x62, 0x34, 0x66, 0x66, 0x34, 0x31, 0x61, 0x64, 0x34, 0x64, 0x38, 0x65, 0x36, 0x63, 0x36, 0x31, 0x61, 0x38, 0x32, 0x33, 0x30, 0x37, 0x32, 0x36, 0x38, 0x64, 0x36, 0x32, 0x31, 0x32, 0x35, 0x31, 0x37, 0x65, 0x31, 0x36, 0x38, 0x39, 0x66, 0x31, 0x65, 0x35, 0x64, 0x34, 0x39, 0x34, 0x30, 0x37, 0x64, 0x39, 0x34, 0x38, 0x64, 0x31, 0x61, 0x61, 0x37, 0x31, 0x62, 0x33, 0x65, 0x35, 0x35, 0x61, 0x63, 0x36, 0x33, 0x33, 0x64, 0x30, 0x65, 0x65, 0x65, 0x30, 0x32, 0x39, 0x32, 0x66, 0x36, 0x36, 0x34, 0x36, 0x63, 0x63, 0x63, 0x32, 0x65, 0x35, 0x36, 0x64, 0x34, 0x38, 0x30, 0x35, 0x65, 0x61, 0x31, 0x36, 0x31, 0x35, 0x62, 0x31, 0x63, 0x31, 0x37, 0x61, 0x36, 0x31, 0x33, 0x30, 0x37, 0x64, 0x36, 0x31, 0x31, 0x30, 0x30, 0x34, 0x62, 0x39, 0x33, 0x34, 0x30, 0x64, 0x33, 0x65, 0x31, 0x37, 0x63, 0x38, 0x36, 0x65, 0x66, 0x33, 0x31, 0x35, 0x66, 0x65, 0x37, 0x62, 0x38, 0x30, 0x34, 0x35, 0x36, 0x33, 0x65, 0x64, 0x31, 0x37, 0x32, 0x64, 0x33, 0x33, 0x64, 0x37, 0x64, 0x31, 0x62, 0x33, 0x62, 0x64, 0x30, 0x64, 0x61, 0x64, 0x33, 0x38, 0x66, 0x66, 0x34, 0x36, 0x34, 0x38, 0x65, 0x33, 0x63, 0x37, 0x61, 0x35, 0x37, 0x31, 0x34, 0x39, 0x39, 0x32, 0x37, 0x31, 0x31, 0x30, 0x36, 0x39, 0x66, 0x63, 0x66, 0x34, 0x62, 0x30, 0x39, 0x64, 0x33, 0x36, 0x30, 0x64, 0x63, 0x62, 0x61, 0x31, 0x34, 0x62, 0x39, 0x33, 0x64, 0x37, 0x32, 0x38, 0x32, 0x34, 0x66, 0x61, 0x39, 0x63, 0x65, 0x30, 0x35, 0x66, 0x31, 0x63, 0x63, 0x32, 0x38, 0x34, 0x62, 0x62, 0x36, 0x32, 0x38, 0x63, 0x37, 0x63, 0x61, 0x62, 0x36, 0x34, 0x64, 0x62, 0x38, 0x39, 0x36, 0x37, 0x37, 0x32, 0x38, 0x61, 0x65, 0x61, 0x33, 0x38, 0x38, 0x64, 0x37, 0x64, 0x35, 0x62, 0x30, 0x34, 0x33, 0x38, 0x66, 0x63, 0x63, 0x30, 0x64, 0x38, 0x37, 0x61, 0x35, 0x37, 0x32, 0x31, 0x31, 0x63, 0x66, 0x63, 0x36, 0x30, 0x62, 0x38, 0x35, 0x63, 0x37, 0x37, 0x62, 0x64, 0x66, 0x34, 0x63, 0x62, 0x33, 0x65, 0x39, 0x63, 0x64, 0x37, 0x63, 0x37, 0x61, 0x34, 0x63, 0x61, 0x31, 0x36, 0x39, 0x33, 0x30, 0x35, 0x38, 0x34, 0x32, 0x31, 0x63, 0x30, 0x33, 0x34, 0x64, 0x37, 0x36, 0x63, 0x31, 0x38, 0x38, 0x65, 0x39, 0x66, 0x65, 0x31, 0x30, 0x66, 0x38, 0x33, 0x66, 0x34, 0x37, 0x65, 0x38, 0x32, 0x38, 0x39, 0x34, 0x66, 0x31, 0x34, 0x34, 0x36, 0x39, 0x38, 0x34, 0x38, 0x37, 0x33, 0x62, 0x62, 0x31, 0x35, 0x32, 0x32, 0x62, 0x63, 0x63, 0x62, 0x64, 0x62, 0x31, 0x65, 0x64, 0x32, 0x31, 0x31, 0x31, 0x35, 0x38, 0x35, 0x62, 0x37, 0x62, 0x32, 0x32, 0x64, 0x36, 0x35, 0x38, 0x65, 0x64, 0x31, 0x38, 0x65, 0x32, 0x37, 0x32, 0x62, 0x66, 0x33, 0x34, 0x30, 0x64, 0x37, 0x32, 0x66, 0x62, 0x39, 0x34, 0x36, 0x35, 0x35, 0x39, 0x31, 0x36, 0x38, 0x32, 0x62, 0x63, 0x61, 0x61, 0x37, 0x31, 0x62, 0x34, 0x63, 0x30, 0x36, 0x31, 0x38, 0x66, 0x39, 0x32, 0x62, 0x30, 0x39, 0x30, 0x34, 0x31, 0x66, 0x66, 0x37, 0x36, 0x30, 0x39, 0x66, 0x34, 0x63, 0x33, 0x65, 0x36, 0x64, 0x30, 0x37, 0x32, 0x35, 0x63, 0x39, 0x62, 0x61, 0x63, 0x61, 0x64, 0x36, 0x65, 0x35, 0x39, 0x37, 0x32, 0x31, 0x31, 0x30, 0x36, 0x35, 0x33, 0x39, 0x37, 0x32, 0x34, 0x64, 0x30, 0x32, 0x66, 0x63, 0x39, 0x66, 0x62, 0x65, 0x33, 0x32, 0x35, 0x66, 0x64, 0x30, 0x33, 0x36, 0x31, 0x64, 0x39, 0x63, 0x63, 0x62, 0x30, 0x31, 0x34, 0x30, 0x63, 0x39, 0x35, 0x35, 0x38, 0x39, 0x66, 0x64, 0x62, 0x32, 0x39, 0x61, 0x35, 0x64, 0x63, 0x31, 0x63, 0x66, 0x32, 0x31, 0x63, 0x64, 0x65, 0x31, 0x30, 0x37, 0x31, 0x38, 0x66, 0x35, 0x64, 0x64, 0x63, 0x36, 0x62, 0x33, 0x32, 0x64, 0x37, 0x33, 0x64, 0x39, 0x37, 0x61, 0x66, 0x62, 0x63, 0x36, 0x36, 0x63, 0x65, 0x62, 0x61, 0x65, 0x36, 0x35, 0x32, 0x62, 0x35, 0x34, 0x33, 0x38, 0x61, 0x31, 0x39, 0x32, 0x33, 0x39, 0x64, 0x65, 0x38, 0x39, 0x37, 0x38, 0x30, 0x64, 0x61, 0x35, 0x64, 0x30, 0x66, 0x36, 0x39, 0x34, 0x36, 0x63, 0x33, 0x63, 0x33, 0x37, 0x32, 0x61, 0x35, 0x39, 0x30, 0x61, 0x66, 0x61, 0x36, 0x66, 0x62, 0x31, 0x66, 0x30, 0x63, 0x64, 0x38, 0x32, 0x39, 0x30, 0x34, 0x66, 0x32, 0x38, 0x36, 0x38, 0x63, 0x62, 0x65, 0x65, 0x35, 0x62, 0x35, 0x61, 0x63, 0x36, 0x66, 0x32, 0x62, 0x32, 0x62, 0x36, 0x65, 0x66, 0x30, 0x39, 0x64, 0x65, 0x38, 0x63, 0x64, 0x39, 0x63, 0x61, 0x39, 0x66, 0x36, 0x33, 0x65, 0x35, 0x30, 0x61, 0x65, 0x30, 0x64, 0x30, 0x63, 0x36, 0x62, 0x31, 0x61, 0x32, 0x31, 0x61, 0x31, 0x30, 0x37, 0x37, 0x64, 0x61, 0x36, 0x38, 0x31, 0x36, 0x62, 0x37, 0x38, 0x31, 0x31, 0x35, 0x65, 0x34, 0x64, 0x65, 0x38, 0x32, 0x65, 0x63, 0x38, 0x36, 0x64, 0x36, 0x33, 0x38, 0x33, 0x37, 0x66, 0x33, 0x37, 0x31, 0x65, 0x34, 0x62, 0x61, 0x35, 0x33, 0x33, 0x64, 0x64, 0x32, 0x38, 0x64, 0x62, 0x38, 0x34, 0x61, 0x38, 0x37, 0x32, 0x37, 0x61, 0x34, 0x39, 0x63, 0x61, 0x63, 0x63, 0x30, 0x61, 0x63, 0x31, 0x30, 0x33, 0x63, 0x62, 0x39, 0x38, 0x37, 0x36, 0x39, 0x63, 0x39, 0x37, 0x33, 0x39, 0x32, 0x39, 0x32, 0x62, 0x64, 0x36, 0x35, 0x31, 0x65, 0x30, 0x30, 0x30, 0x65, 0x38, 0x31, 0x38, 0x66, 0x30, 0x37, 0x39, 0x62, 0x63, 0x30, 0x34, 0x34, 0x38, 0x34, 0x64, 0x64, 0x31, 0x32, 0x34, 0x66, 0x34, 0x31, 0x64, 0x35, 0x34, 0x37, 0x30, 0x66, 0x63, 0x64, 0x38, 0x66, 0x64, 0x34, 0x66, 0x35, 0x34, 0x65, 0x35, 0x64, 0x32, 0x66, 0x37, 0x30, 0x34, 0x37, 0x39, 0x34, 0x38, 0x62, 0x65, 0x64, 0x62, 0x37, 0x64, 0x66, 0x31, 0x34, 0x61, 0x33, 0x62, 0x32, 0x31, 0x30, 0x66, 0x64, 0x65, 0x39, 0x33, 0x65, 0x32, 0x39, 0x65, 0x64, 0x30, 0x35, 0x64, 0x31, 0x39, 0x63, 0x34, 0x37, 0x32, 0x34, 0x36, 0x37, 0x30, 0x30, 0x35, 0x61, 0x65, 0x35, 0x36, 0x31, 0x36, 0x31, 0x35, 0x64, 0x34, 0x66, 0x39, 0x62, 0x30, 0x35, 0x30, 0x33, 0x61, 0x64, 0x33, 0x30, 0x32, 0x33, 0x62, 0x62, 0x34, 0x63, 0x31, 0x32, 0x38, 0x63, 0x35, 0x31, 0x33, 0x61, 0x36, 0x38, 0x63, 0x65, 0x36, 0x61, 0x61, 0x30, 0x61, 0x33, 0x30, 0x63, 0x63, 0x35, 0x63, 0x62, 0x63, 0x31, 0x64, 0x38, 0x66, 0x39, 0x35, 0x36, 0x62, 0x35, 0x39, 0x34, 0x32, 0x35, 0x30, 0x65, 0x35, 0x31, 0x34, 0x31, 0x61, 0x31, 0x64, 0x37, 0x33, 0x33, 0x30, 0x30, 0x62, 0x65, 0x63, 0x38, 0x30, 0x61, 0x34, 0x33, 0x62, 0x35, 0x39, 0x35, 0x62, 0x64, 0x62, 0x32, 0x62, 0x63, 0x66, 0x37, 0x63, 0x61, 0x37, 0x62, 0x62, 0x64, 0x31, 0x36, 0x36, 0x63, 0x62, 0x30, 0x34, 0x35, 0x38, 0x30, 0x34, 0x63, 0x36, 0x34, 0x62, 0x36, 0x31, 0x32, 0x34, 0x63, 0x39, 0x37, 0x32, 0x66, 0x33, 0x35, 0x38, 0x66, 0x35, 0x65, 0x63, 0x33, 0x38, 0x63, 0x34, 0x63, 0x66, 0x64, 0x31, 0x31, 0x65, 0x31, 0x32, 0x61, 0x65, 0x36, 0x62, 0x34, 0x34, 0x31, 0x33, 0x32, 0x62, 0x66, 0x62, 0x32, 0x38, 0x35, 0x34, 0x66, 0x64, 0x35, 0x30, 0x66, 0x66, 0x32, 0x61, 0x66, 0x35, 0x39, 0x62, 0x33, 0x38, 0x63, 0x31, 0x37, 0x62, 0x64, 0x38, 0x65, 0x62, 0x66, 0x61, 0x36, 0x36, 0x37, 0x32, 0x31, 0x37, 0x64, 0x34, 0x65, 0x39, 0x38, 0x62, 0x66, 0x38, 0x39, 0x31, 0x38, 0x31, 0x33, 0x37, 0x30, 0x63, 0x63, 0x65, 0x37, 0x35, 0x33, 0x30, 0x30, 0x63, 0x32, 0x39, 0x30, 0x37, 0x36, 0x37, 0x62, 0x62, 0x33, 0x62, 0x62, 0x65, 0x65, 0x33, 0x37, 0x64, 0x66, 0x38, 0x31, 0x33, 0x37, 0x62, 0x38, 0x66, 0x31, 0x31, 0x35, 0x36, 0x66, 0x62, 0x61, 0x36, 0x38, 0x35, 0x63, 0x65, 0x37, 0x32, 0x30, 0x64, 0x36, 0x31, 0x31, 0x66, 0x32, 0x34, 0x61, 0x38, 0x62, 0x30, 0x31, 0x38, 0x65, 0x38, 0x34, 0x38, 0x30, 0x39, 0x34, 0x39, 0x33, 0x36, 0x66, 0x35, 0x62, 0x31, 0x35, 0x64, 0x64, 0x38, 0x31, 0x38, 0x32, 0x35, 0x66, 0x64, 0x65, 0x64, 0x32, 0x64, 0x37, 0x64, 0x38, 0x62, 0x31, 0x31, 0x61, 0x62, 0x63, 0x35, 0x30, 0x38, 0x61, 0x32, 0x36, 0x65, 0x64, 0x63, 0x66, 0x38, 0x37, 0x32, 0x32, 0x39, 0x33, 0x64, 0x33, 0x61, 0x33, 0x36, 0x35, 0x32, 0x65, 0x65, 0x64, 0x39, 0x61, 0x34, 0x63, 0x35, 0x33, 0x32, 0x32, 0x33, 0x32, 0x39, 0x65, 0x66, 0x65, 0x66, 0x61, 0x64, 0x30, 0x66, 0x39, 0x62, 0x66, 0x34, 0x31, 0x63, 0x63, 0x37, 0x31, 0x66, 0x30, 0x31, 0x63, 0x37, 0x32, 0x30, 0x31, 0x30, 0x63, 0x66, 0x36, 0x37, 0x61, 0x66, 0x38, 0x61, 0x30, 0x39, 0x32, 0x63, 0x37, 0x32, 0x64, 0x62, 0x39, 0x31, 0x38, 0x63, 0x32, 0x63, 0x62, 0x66, 0x31, 0x37, 0x66, 0x31, 0x34, 0x64, 0x64, 0x35, 0x39, 0x35, 0x36, 0x38, 0x64, 0x33, 0x64, 0x38, 0x35, 0x64, 0x38, 0x34, 0x33, 0x35, 0x65, 0x37, 0x33, 0x62, 0x62, 0x30, 0x34, 0x31, 0x30, 0x38, 0x34, 0x63, 0x36, 0x30, 0x37, 0x65, 0x65, 0x64, 0x38, 0x34, 0x34, 0x38, 0x39, 0x64, 0x65, 0x63, 0x39, 0x35, 0x64, 0x35, 0x36, 0x33, 0x31, 0x66, 0x35, 0x35, 0x32, 0x32, 0x34, 0x38, 0x62, 0x36, 0x66, 0x33, 0x30, 0x65, 0x36, 0x39, 0x62, 0x61, 0x32, 0x65, 0x65, 0x34, 0x37, 0x39, 0x30, 0x39, 0x61, 0x38, 0x63, 0x36, 0x65, 0x61, 0x62, 0x34, 0x37, 0x35, 0x34, 0x61, 0x61, 0x38, 0x62, 0x66, 0x36, 0x35, 0x30, 0x34, 0x39, 0x34, 0x38, 0x33, 0x31, 0x37, 0x36, 0x38, 0x63, 0x39, 0x62, 0x61, 0x38, 0x33, 0x37, 0x61, 0x36, 0x36, 0x65, 0x35, 0x30, 0x30, 0x62, 0x39, 0x32, 0x38, 0x32, 0x30, 0x61, 0x39, 0x35, 0x65, 0x33, 0x65, 0x39, 0x31, 0x34, 0x65, 0x66, 0x36, 0x34, 0x39, 0x61, 0x65, 0x31, 0x66, 0x35, 0x65, 0x65, 0x65, 0x38, 0x39, 0x36, 0x62, 0x32, 0x38, 0x38, 0x33, 0x36, 0x63, 0x38, 0x38, 0x36, 0x34, 0x33, 0x63, 0x39, 0x61, 0x63, 0x64, 0x33, 0x31, 0x39, 0x61, 0x36, 0x32, 0x38, 0x30, 0x64, 0x36, 0x37, 0x32, 0x63, 0x36, 0x61, 0x32, 0x35, 0x36, 0x36, 0x39, 0x30, 0x39, 0x66, 0x34, 0x64, 0x31, 0x66, 0x61, 0x35, 0x37, 0x38, 0x33, 0x65, 0x61, 0x33, 0x39, 0x32, 0x65, 0x62, 0x61, 0x63, 0x33, 0x30, 0x64, 0x61, 0x65, 0x33, 0x34, 0x66, 0x38, 0x36, 0x63, 0x66, 0x34, 0x38, 0x61, 0x32, 0x32, 0x38, 0x39, 0x39, 0x33, 0x34, 0x66, 0x64, 0x39, 0x35, 0x33, 0x36, 0x35, 0x31, 0x36, 0x31, 0x39, 0x37, 0x32, 0x34, 0x35, 0x32, 0x30, 0x62, 0x64, 0x63, 0x37, 0x34, 0x39, 0x31, 0x61, 0x37, 0x30, 0x30, 0x32, 0x66, 0x37, 0x64, 0x30, 0x36, 0x32, 0x37, 0x31, 0x34, 0x38, 0x34, 0x38, 0x33, 0x34, 0x64, 0x39, 0x39, 0x37, 0x63, 0x32, 0x30, 0x37, 0x38, 0x38, 0x35, 0x39, 0x39, 0x34, 0x63, 0x37, 0x62, 0x32, 0x66, 0x39, 0x34, 0x64, 0x62, 0x33, 0x36, 0x37, 0x36, 0x64, 0x61, 0x36, 0x39, 0x62, 0x37, 0x32, 0x38, 0x35, 0x39, 0x36, 0x36, 0x65, 0x65, 0x37, 0x37, 0x62, 0x35, 0x35, 0x34, 0x65, 0x65, 0x38, 0x35, 0x63, 0x37, 0x64, 0x36, 0x39, 0x37, 0x33, 0x39, 0x66, 0x38, 0x32, 0x64, 0x33, 0x37, 0x33, 0x61, 0x62, 0x31, 0x38, 0x65, 0x33, 0x63, 0x37, 0x39, 0x36, 0x63, 0x64, 0x31, 0x32, 0x35, 0x64, 0x32, 0x35, 0x66, 0x39, 0x31, 0x65, 0x66, 0x62, 0x38, 0x39, 0x37, 0x65, 0x34, 0x35, 0x35, 0x32, 0x36, 0x35, 0x63, 0x64, 0x32, 0x33, 0x63, 0x63, 0x65, 0x37, 0x64, 0x35, 0x37, 0x61, 0x31, 0x39, 0x34, 0x37, 0x34, 0x62, 0x39, 0x62, 0x66, 0x36, 0x31, 0x36, 0x31, 0x30, 0x30, 0x31, 0x34, 0x39, 0x62, 0x31, 0x61, 0x62, 0x64, 0x65, 0x39, 0x39, 0x39, 0x61, 0x62, 0x63, 0x37, 0x33, 0x61, 0x64, 0x35, 0x31, 0x64, 0x36, 0x37, 0x64, 0x36, 0x32, 0x65, 0x63, 0x34, 0x65, 0x63, 0x38, 0x37, 0x32, 0x33, 0x37, 0x38, 0x38, 0x61, 0x30, 0x61, 0x38, 0x62, 0x62, 0x63, 0x63, 0x39, 0x63, 0x65, 0x32, 0x65, 0x65, 0x65, 0x62, 0x31, 0x39, 0x65, 0x38, 0x38, 0x64, 0x64, 0x63, 0x63, 0x66, 0x66, 0x35, 0x34, 0x30, 0x63, 0x37, 0x64, 0x37, 0x36, 0x66, 0x64, 0x64, 0x65, 0x66, 0x65, 0x65, 0x33, 0x39, 0x36, 0x37, 0x36, 0x30, 0x66, 0x66, 0x61, 0x36, 0x63, 0x62, 0x62, 0x30, 0x38, 0x64, 0x35, 0x65, 0x65, 0x33, 0x32, 0x34, 0x37, 0x66, 0x38, 0x30, 0x66, 0x38, 0x37, 0x32, 0x30, 0x63, 0x66, 0x39, 0x30, 0x34, 0x35, 0x62, 0x62, 0x61, 0x36, 0x36, 0x30, 0x36, 0x31, 0x31, 0x34, 0x38, 0x33, 0x38, 0x32, 0x34, 0x34, 0x32, 0x39, 0x63, 0x36, 0x63, 0x61, 0x31, 0x34, 0x34, 0x30, 0x36, 0x31, 0x61, 0x30, 0x66, 0x63, 0x30, 0x63, 0x62, 0x63, 0x64, 0x66, 0x66, 0x33, 0x39, 0x64, 0x30, 0x37, 0x32, 0x33, 0x63, 0x38, 0x33, 0x37, 0x31, 0x36, 0x39, 0x31, 0x63, 0x63, 0x62, 0x36, 0x30, 0x31, 0x38, 0x63, 0x65, 0x36, 0x35, 0x39, 0x61, 0x31, 0x30, 0x62, 0x64, 0x39, 0x65, 0x63, 0x36, 0x35, 0x30, 0x66, 0x33, 0x63, 0x64, 0x65, 0x36, 0x35, 0x61, 0x34, 0x64, 0x63, 0x33, 0x38, 0x32, 0x33, 0x30, 0x65, 0x35, 0x65, 0x36, 0x65, 0x39, 0x37, 0x66, 0x36, 0x30, 0x30, 0x61, 0x64, 0x37, 0x37, 0x32, 0x38, 0x38, 0x35, 0x62, 0x35, 0x66, 0x31, 0x66, 0x65, 0x66, 0x37, 0x64, 0x38, 0x61, 0x38, 0x38, 0x64, 0x30, 0x33, 0x61, 0x34, 0x63, 0x30, 0x39, 0x33, 0x39, 0x31, 0x38, 0x39, 0x35, 0x62, 0x37, 0x34, 0x34, 0x34, 0x31, 0x35, 0x33, 0x38, 0x32, 0x39, 0x63, 0x30, 0x34, 0x38, 0x35, 0x33, 0x65, 0x35, 0x35, 0x62, 0x33, 0x31, 0x62, 0x62, 0x66, 0x34, 0x33, 0x32, 0x35, 0x38, 0x62, 0x35, 0x66, 0x36, 0x38, 0x35, 0x35, 0x37, 0x30, 0x37, 0x38, 0x63, 0x31, 0x61, 0x31, 0x61, 0x63, 0x36, 0x64, 0x63, 0x63, 0x32, 0x39, 0x64, 0x33, 0x33, 0x37, 0x36, 0x66, 0x31, 0x61, 0x39, 0x63, 0x66, 0x34, 0x35, 0x34, 0x39, 0x34, 0x32, 0x63, 0x63, 0x61, 0x63, 0x36, 0x39, 0x30, 0x63, 0x66, 0x38, 0x31, 0x32, 0x31, 0x62, 0x32, 0x61, 0x63, 0x65, 0x36, 0x66, 0x62, 0x66, 0x34, 0x63, 0x34, 0x37, 0x32, 0x34, 0x35, 0x38, 0x65, 0x36, 0x38, 0x36, 0x39, 0x61, 0x39, 0x64, 0x36, 0x61, 0x34, 0x36, 0x32, 0x30, 0x65, 0x63, 0x36, 0x35, 0x39, 0x32, 0x63, 0x62, 0x31, 0x34, 0x66, 0x63, 0x62, 0x65, 0x37, 0x33, 0x66, 0x32, 0x32, 0x65, 0x36, 0x35, 0x62, 0x30, 0x61, 0x66, 0x63, 0x65, 0x34, 0x66, 0x65, 0x64, 0x62, 0x64, 0x35, 0x63, 0x32, 0x38, 0x31, 0x33, 0x33, 0x37, 0x64, 0x39, 0x30, 0x37, 0x32, 0x63, 0x66, 0x61, 0x32, 0x31, 0x31, 0x65, 0x34, 0x36, 0x39, 0x63, 0x61, 0x35, 0x30, 0x64, 0x34, 0x30, 0x62, 0x64, 0x36, 0x30, 0x66, 0x30, 0x35, 0x64, 0x31, 0x36, 0x38, 0x31, 0x61, 0x66, 0x36, 0x31, 0x64, 0x38, 0x65, 0x30, 0x37, 0x64, 0x33, 0x66, 0x62, 0x31, 0x63, 0x34, 0x38, 0x33, 0x39, 0x65, 0x36, 0x66, 0x64, 0x61, 0x62, 0x33, 0x31, 0x30, 0x62, 0x63, 0x61, 0x64, 0x36, 0x30, 0x33, 0x36, 0x63, 0x39, 0x30, 0x64, 0x34, 0x64, 0x30, 0x62, 0x66, 0x31, 0x62, 0x65, 0x35, 0x65, 0x38, 0x32, 0x32, 0x64, 0x33, 0x63, 0x34, 0x32, 0x39, 0x62, 0x35, 0x37, 0x63, 0x37, 0x33, 0x38, 0x33, 0x31, 0x65, 0x66, 0x61, 0x36, 0x39, 0x63, 0x36, 0x32, 0x65, 0x37, 0x33, 0x33, 0x63, 0x39, 0x64, 0x39, 0x32, 0x35, 0x36, 0x37, 0x33, 0x65, 0x36, 0x35, 0x36, 0x38, 0x37, 0x39, 0x34, 0x35, 0x39, 0x61, 0x31, 0x66, 0x64, 0x32, 0x37, 0x38, 0x62, 0x39, 0x33, 0x64, 0x38, 0x66, 0x32, 0x36, 0x33, 0x37, 0x36, 0x33, 0x34, 0x65, 0x37, 0x65, 0x30, 0x30, 0x30, 0x61, 0x66, 0x38, 0x64, 0x31, 0x65, 0x66, 0x36, 0x34, 0x63, 0x32, 0x31, 0x33, 0x65, 0x61, 0x33, 0x37, 0x36, 0x65, 0x62, 0x65, 0x65, 0x64, 0x32, 0x63, 0x38, 0x35, 0x38, 0x64, 0x34, 0x30, 0x39, 0x61, 0x36, 0x31, 0x65, 0x37, 0x32, 0x61, 0x64, 0x39, 0x30, 0x65, 0x34, 0x39, 0x64, 0x36, 0x31, 0x36, 0x30, 0x62, 0x34, 0x34, 0x32, 0x34, 0x34, 0x64, 0x61, 0x32, 0x64, 0x30, 0x66, 0x62, 0x64, 0x62, 0x39, 0x35, 0x37, 0x38, 0x63, 0x35, 0x66, 0x36, 0x62, 0x63, 0x39, 0x62, 0x64, 0x38, 0x39, 0x31, 0x63, 0x37, 0x61, 0x38, 0x64, 0x32, 0x61, 0x35, 0x36, 0x66, 0x61, 0x33, 0x64, 0x31, 0x32, 0x64, 0x30, 0x39, 0x30, 0x33, 0x63, 0x30, 0x64, 0x38, 0x33, 0x39, 0x62, 0x63, 0x34, 0x32, 0x66, 0x32, 0x64, 0x31, 0x61, 0x37, 0x65, 0x31, 0x34, 0x62, 0x39, 0x63, 0x32, 0x62, 0x37, 0x31, 0x61, 0x38, 0x34, 0x34, 0x66, 0x30, 0x65, 0x64, 0x33, 0x65, 0x32, 0x38, 0x33, 0x39, 0x31, 0x30, 0x39, 0x63, 0x30, 0x66, 0x37, 0x35, 0x38, 0x39, 0x39, 0x30, 0x32, 0x63, 0x33, 0x39, 0x30, 0x63, 0x32, 0x32, 0x31, 0x34, 0x61, 0x36, 0x61, 0x34, 0x66, 0x63, 0x65, 0x33, 0x61, 0x32, 0x64, 0x63, 0x36, 0x31, 0x39, 0x37, 0x35, 0x65, 0x37, 0x36, 0x39, 0x37, 0x35, 0x30, 0x64, 0x38, 0x30, 0x35, 0x39, 0x64, 0x33, 0x39, 0x34, 0x31, 0x38, 0x33, 0x38, 0x32, 0x34, 0x33, 0x37, 0x30, 0x62, 0x36, 0x31, 0x30, 0x64, 0x62, 0x32, 0x35, 0x63, 0x64, 0x32, 0x61, 0x35, 0x66, 0x64, 0x34, 0x63, 0x34, 0x62, 0x63, 0x32, 0x39, 0x35, 0x37, 0x32, 0x32, 0x66, 0x63, 0x64, 0x33, 0x64, 0x62, 0x62, 0x37, 0x36, 0x37, 0x64, 0x33, 0x62, 0x66, 0x62, 0x65, 0x36, 0x34, 0x38, 0x36, 0x65, 0x33, 0x31, 0x39, 0x37, 0x36, 0x38, 0x34, 0x38, 0x33, 0x64, 0x36, 0x62, 0x64, 0x32, 0x33, 0x66, 0x64, 0x38, 0x35, 0x39, 0x63, 0x39, 0x38, 0x38, 0x33, 0x37, 0x66, 0x63, 0x36, 0x31, 0x30, 0x36, 0x61, 0x35, 0x31, 0x32, 0x61, 0x65, 0x65, 0x31, 0x35, 0x35, 0x39, 0x66, 0x66, 0x31, 0x31, 0x36, 0x36, 0x34, 0x33, 0x32, 0x66, 0x61, 0x38, 0x35, 0x39, 0x32, 0x34, 0x33, 0x63, 0x62, 0x32, 0x39, 0x35, 0x33, 0x36, 0x37, 0x35, 0x61, 0x32, 0x34, 0x39, 0x31, 0x33, 0x63, 0x32, 0x66, 0x63, 0x61, 0x64, 0x39, 0x33, 0x65, 0x37, 0x61, 0x36, 0x37, 0x30, 0x32, 0x30, 0x61, 0x35, 0x62, 0x39, 0x61, 0x30, 0x37, 0x66, 0x39, 0x39, 0x32, 0x66, 0x30, 0x37, 0x32, 0x37, 0x35, 0x38, 0x37, 0x66, 0x33, 0x63, 0x31, 0x62, 0x33, 0x36, 0x66, 0x31, 0x34, 0x62, 0x31, 0x61, 0x31, 0x62, 0x32, 0x31, 0x37, 0x66, 0x34, 0x38, 0x31, 0x64, 0x66, 0x32, 0x35, 0x30, 0x64, 0x38, 0x35, 0x62, 0x31, 0x65, 0x39, 0x66, 0x66, 0x32, 0x31, 0x62, 0x62, 0x63, 0x62, 0x66, 0x62, 0x36, 0x32, 0x38, 0x65, 0x34, 0x35, 0x30, 0x61, 0x36, 0x63, 0x33, 0x64, 0x39, 0x34, 0x36, 0x62, 0x63, 0x35, 0x33, 0x31, 0x37, 0x66, 0x39, 0x30, 0x36, 0x64, 0x35, 0x32, 0x35, 0x32, 0x38, 0x38, 0x32, 0x30, 0x62, 0x61, 0x30, 0x64, 0x39, 0x39, 0x64, 0x64, 0x66, 0x30, 0x36, 0x38, 0x61, 0x39, 0x34, 0x30, 0x35, 0x39, 0x31, 0x36, 0x61, 0x31, 0x30, 0x36, 0x33, 0x33, 0x64, 0x37, 0x36, 0x32, 0x31, 0x31, 0x65, 0x39, 0x39, 0x34, 0x62, 0x34, 0x39, 0x61, 0x31, 0x61, 0x39, 0x31, 0x37, 0x32, 0x37, 0x35, 0x31, 0x30, 0x37, 0x35, 0x30, 0x35, 0x39, 0x33, 0x33, 0x36, 0x65, 0x37, 0x37, 0x64, 0x63, 0x37, 0x35, 0x38, 0x61, 0x32, 0x64, 0x36, 0x37, 0x35, 0x65, 0x30, 0x64, 0x31, 0x33, 0x39, 0x64, 0x32, 0x66, 0x30, 0x38, 0x38, 0x32, 0x39, 0x63, 0x38, 0x61, 0x33, 0x31, 0x62, 0x38, 0x34, 0x32, 0x62, 0x33, 0x62, 0x61, 0x35, 0x35, 0x36, 0x63, 0x62, 0x36, 0x64, 0x64, 0x39, 0x33, 0x30, 0x34, 0x66, 0x39, 0x39, 0x38, 0x62, 0x37, 0x34, 0x39, 0x63, 0x66, 0x35, 0x37, 0x65, 0x31, 0x32, 0x66, 0x31, 0x37, 0x66, 0x63, 0x36, 0x34, 0x66, 0x36, 0x39, 0x65, 0x62, 0x66, 0x32, 0x38, 0x61, 0x66, 0x36, 0x38, 0x63, 0x33, 0x39, 0x65, 0x34, 0x62, 0x37, 0x62, 0x31, 0x33, 0x34, 0x38, 0x63, 0x64, 0x36, 0x35, 0x38, 0x34, 0x32, 0x30, 0x62, 0x35, 0x65, 0x33, 0x62, 0x34, 0x34, 0x37, 0x32, 0x34, 0x61, 0x30, 0x64, 0x65, 0x37, 0x64, 0x64, 0x37, 0x30, 0x32, 0x35, 0x31, 0x37, 0x64, 0x64, 0x37, 0x35, 0x38, 0x66, 0x33, 0x63, 0x33, 0x31, 0x33, 0x32, 0x36, 0x64, 0x63, 0x33, 0x65, 0x33, 0x35, 0x65, 0x64, 0x65, 0x66, 0x65, 0x65, 0x35, 0x39, 0x35, 0x30, 0x32, 0x63, 0x64, 0x65, 0x31, 0x64, 0x34, 0x65, 0x64, 0x30, 0x65, 0x30, 0x63, 0x39, 0x61, 0x62, 0x34, 0x37, 0x33, 0x37, 0x32, 0x31, 0x65, 0x31, 0x61, 0x32, 0x35, 0x64, 0x61, 0x66, 0x39, 0x38, 0x30, 0x63, 0x39, 0x32, 0x63, 0x32, 0x64, 0x30, 0x32, 0x66, 0x32, 0x65, 0x39, 0x36, 0x61, 0x66, 0x30, 0x35, 0x30, 0x36, 0x66, 0x62, 0x62, 0x66, 0x64, 0x38, 0x39, 0x38, 0x66, 0x32, 0x36, 0x61, 0x64, 0x30, 0x34, 0x36, 0x39, 0x37, 0x37, 0x34, 0x30, 0x38, 0x30, 0x63, 0x31, 0x36, 0x66, 0x30, 0x30, 0x39, 0x38, 0x37, 0x32, 0x61, 0x30, 0x34, 0x32, 0x61, 0x31, 0x62, 0x33, 0x39, 0x30, 0x34, 0x35, 0x65, 0x62, 0x33, 0x66, 0x35, 0x38, 0x37, 0x66, 0x31, 0x32, 0x66, 0x66, 0x36, 0x62, 0x31, 0x35, 0x38, 0x61, 0x34, 0x34, 0x66, 0x34, 0x66, 0x36, 0x36, 0x63, 0x32, 0x66, 0x30, 0x63, 0x38, 0x30, 0x64, 0x32, 0x37, 0x32, 0x39, 0x39, 0x34, 0x30, 0x36, 0x66, 0x34, 0x62, 0x37, 0x37, 0x33, 0x36, 0x38, 0x31, 0x37, 0x32, 0x64, 0x31, 0x31, 0x39, 0x66, 0x37, 0x64, 0x66, 0x30, 0x38, 0x32, 0x33, 0x36, 0x33, 0x63, 0x64, 0x39, 0x66, 0x32, 0x39, 0x38, 0x30, 0x37, 0x32, 0x37, 0x35, 0x37, 0x66, 0x65, 0x61, 0x37, 0x66, 0x37, 0x32, 0x31, 0x37, 0x64, 0x36, 0x30, 0x63, 0x39, 0x62, 0x61, 0x33, 0x37, 0x65, 0x31, 0x32, 0x36, 0x63, 0x37, 0x31, 0x65, 0x30, 0x63, 0x33, 0x38, 0x66, 0x65, 0x36, 0x63, 0x34, 0x37, 0x32, 0x65, 0x63, 0x36, 0x33, 0x30, 0x33, 0x32, 0x38, 0x32, 0x64, 0x35, 0x30, 0x64, 0x39, 0x37, 0x62, 0x32, 0x63, 0x39, 0x63, 0x66, 0x34, 0x64, 0x35, 0x30, 0x36, 0x34, 0x31, 0x61, 0x34, 0x34, 0x31, 0x38, 0x31, 0x65, 0x38, 0x36, 0x63, 0x33, 0x63, 0x34, 0x62, 0x35, 0x39, 0x32, 0x37, 0x62, 0x64, 0x63, 0x65, 0x37, 0x34, 0x38, 0x30, 0x64, 0x38, 0x64, 0x33, 0x30, 0x30, 0x61, 0x62, 0x37, 0x32, 0x38, 0x64, 0x32, 0x61, 0x61, 0x61, 0x36, 0x62, 0x61, 0x66, 0x37, 0x30, 0x32, 0x33, 0x37, 0x35, 0x35, 0x30, 0x63, 0x61, 0x36, 0x62, 0x61, 0x62, 0x31, 0x62, 0x33, 0x38, 0x36, 0x38, 0x31, 0x39, 0x37, 0x65, 0x38, 0x30, 0x35, 0x37, 0x31, 0x36, 0x64, 0x36, 0x64, 0x37, 0x32, 0x33, 0x38, 0x37, 0x33, 0x65, 0x64, 0x38, 0x65, 0x61, 0x32, 0x66, 0x66, 0x36, 0x65, 0x34, 0x30, 0x31, 0x37, 0x32, 0x66, 0x32, 0x32, 0x64, 0x64, 0x34, 0x39, 0x61, 0x62, 0x62, 0x39, 0x30, 0x36, 0x30, 0x38, 0x38, 0x31, 0x32, 0x63, 0x34, 0x35, 0x62, 0x36, 0x64, 0x38, 0x64, 0x63, 0x39, 0x33, 0x63, 0x63, 0x62, 0x39, 0x37, 0x38, 0x65, 0x61, 0x37, 0x35, 0x66, 0x34, 0x64, 0x30, 0x33, 0x39, 0x36, 0x37, 0x37, 0x38, 0x37, 0x33, 0x61, 0x35, 0x64, 0x63, 0x34, 0x32, 0x31, 0x38, 0x63, 0x31, 0x31, 0x31, 0x35, 0x31, 0x30, 0x62, 0x65, 0x31, 0x38, 0x33, 0x39, 0x37, 0x32, 0x61, 0x34, 0x64, 0x65, 0x31, 0x63, 0x62, 0x37, 0x61, 0x65, 0x65, 0x31, 0x35, 0x32, 0x63, 0x35, 0x35, 0x36, 0x66, 0x66, 0x30, 0x34, 0x38, 0x66, 0x35, 0x62, 0x37, 0x63, 0x33, 0x32, 0x65, 0x66, 0x63, 0x33, 0x33, 0x63, 0x61, 0x35, 0x64, 0x64, 0x34, 0x38, 0x32, 0x33, 0x32, 0x62, 0x36, 0x61, 0x66, 0x62, 0x34, 0x30, 0x32, 0x34, 0x62, 0x37, 0x61, 0x30, 0x38, 0x66, 0x38, 0x61, 0x38, 0x66, 0x30, 0x39, 0x64, 0x37, 0x31, 0x34, 0x34, 0x65, 0x64, 0x65, 0x36, 0x64, 0x63, 0x63, 0x39, 0x61, 0x33, 0x64, 0x65, 0x62, 0x63, 0x61, 0x63, 0x64, 0x65, 0x65, 0x62, 0x61, 0x37, 0x66, 0x38, 0x37, 0x32, 0x39, 0x34, 0x35, 0x34, 0x33, 0x63, 0x36, 0x30, 0x34, 0x61, 0x64, 0x32, 0x66, 0x66, 0x66, 0x66, 0x35, 0x39, 0x30, 0x37, 0x32, 0x38, 0x34, 0x30, 0x64, 0x31, 0x66, 0x36, 0x33, 0x39, 0x33, 0x39, 0x62, 0x33, 0x37, 0x32, 0x36, 0x36, 0x36, 0x65, 0x38, 0x66, 0x33, 0x62, 0x62, 0x63, 0x37, 0x66, 0x35, 0x61, 0x36, 0x38, 0x34, 0x63, 0x65, 0x61, 0x31, 0x39, 0x65, 0x66, 0x37, 0x65, 0x35, 0x65, 0x65, 0x38, 0x66, 0x65, 0x61, 0x38, 0x63, 0x39, 0x39, 0x31, 0x33, 0x61, 0x39, 0x64, 0x35, 0x39, 0x34, 0x31, 0x32, 0x36, 0x65, 0x66, 0x37, 0x61, 0x65, 0x63, 0x39, 0x31, 0x33, 0x30, 0x32, 0x37, 0x31, 0x65, 0x63, 0x64, 0x31, 0x62, 0x33, 0x37, 0x34, 0x32, 0x31, 0x66, 0x38, 0x66, 0x31, 0x37, 0x63, 0x37, 0x39, 0x31, 0x38, 0x33, 0x30, 0x33, 0x31, 0x33, 0x30, 0x66, 0x66, 0x61, 0x66, 0x66, 0x35, 0x31, 0x35, 0x35, 0x31, 0x65, 0x64, 0x38, 0x37, 0x33, 0x63, 0x61, 0x32, 0x35, 0x35, 0x36, 0x39, 0x30, 0x64, 0x37, 0x32, 0x38, 0x39, 0x34, 0x32, 0x65, 0x64, 0x38, 0x65, 0x34, 0x31, 0x63, 0x64, 0x63, 0x62, 0x37, 0x65, 0x63, 0x65, 0x64, 0x36, 0x36, 0x36, 0x37, 0x34, 0x37, 0x33, 0x66, 0x63, 0x32, 0x62, 0x35, 0x37, 0x30, 0x61, 0x62, 0x66, 0x33, 0x38, 0x66, 0x31, 0x37, 0x66, 0x30, 0x63, 0x64, 0x36, 0x66, 0x66, 0x63, 0x65, 0x39, 0x35, 0x35, 0x35, 0x64, 0x65, 0x36, 0x34, 0x34, 0x66, 0x65, 0x62, 0x37, 0x32, 0x38, 0x30, 0x64, 0x66, 0x62, 0x63, 0x35, 0x33, 0x30, 0x66, 0x65, 0x31, 0x34, 0x63, 0x39, 0x34, 0x36, 0x63, 0x34, 0x33, 0x63, 0x31, 0x66, 0x36, 0x65, 0x37, 0x62, 0x35, 0x36, 0x31, 0x65, 0x31, 0x37, 0x32, 0x66, 0x36, 0x36, 0x32, 0x64, 0x64, 0x36, 0x32, 0x35, 0x35, 0x39, 0x64, 0x66, 0x33, 0x31, 0x62, 0x32, 0x35, 0x61, 0x64, 0x64, 0x65, 0x61, 0x65, 0x35, 0x39, 0x30, 0x38, 0x30, 0x32, 0x39, 0x66, 0x37, 0x38, 0x33, 0x65, 0x30, 0x64, 0x62, 0x35, 0x63, 0x37, 0x39, 0x61, 0x63, 0x62, 0x35, 0x39, 0x65, 0x34, 0x66, 0x39, 0x65, 0x36, 0x61, 0x36, 0x30, 0x32, 0x65, 0x37, 0x65, 0x35, 0x38, 0x63, 0x36, 0x36, 0x36, 0x66, 0x30, 0x34, 0x39, 0x34, 0x37, 0x31, 0x30, 0x36, 0x37, 0x32, 0x66, 0x65, 0x63, 0x37, 0x36, 0x35, 0x33, 0x31, 0x39, 0x36, 0x33, 0x66, 0x62, 0x38, 0x30, 0x36, 0x61, 0x35, 0x33, 0x61, 0x33, 0x34, 0x63, 0x34, 0x36, 0x62, 0x64, 0x39, 0x63, 0x34, 0x31, 0x36, 0x32, 0x66, 0x36, 0x39, 0x34, 0x34, 0x39, 0x31, 0x34, 0x38, 0x36, 0x35, 0x66, 0x63, 0x63, 0x64, 0x31, 0x62, 0x31, 0x64, 0x31, 0x33, 0x31, 0x37, 0x39, 0x62, 0x64, 0x65, 0x36, 0x66, 0x63, 0x39, 0x64, 0x65, 0x30, 0x35, 0x63, 0x63, 0x30, 0x32, 0x30, 0x65, 0x62, 0x62, 0x34, 0x32, 0x37, 0x32, 0x38, 0x63, 0x64, 0x66, 0x63, 0x65, 0x34, 0x35, 0x38, 0x34, 0x64, 0x61, 0x64, 0x33, 0x35, 0x63, 0x39, 0x30, 0x31, 0x37, 0x32, 0x33, 0x64, 0x32, 0x63, 0x64, 0x65, 0x34, 0x39, 0x63, 0x39, 0x35, 0x33, 0x38, 0x66, 0x66, 0x61, 0x31, 0x35, 0x66, 0x65, 0x62, 0x61, 0x38, 0x39, 0x63, 0x62, 0x35, 0x32, 0x65, 0x34, 0x64, 0x36, 0x36, 0x33, 0x66, 0x31, 0x65, 0x66, 0x61, 0x34, 0x36, 0x37, 0x32, 0x63, 0x32, 0x39, 0x37, 0x34, 0x33, 0x34, 0x61, 0x39, 0x30, 0x39, 0x30, 0x37, 0x64, 0x35, 0x64, 0x66, 0x32, 0x33, 0x64, 0x33, 0x65, 0x66, 0x39, 0x33, 0x61, 0x32, 0x63, 0x36, 0x65, 0x34, 0x32, 0x34, 0x37, 0x39, 0x37, 0x36, 0x63, 0x36, 0x33, 0x35, 0x66, 0x39, 0x36, 0x64, 0x62, 0x36, 0x31, 0x37, 0x35, 0x65, 0x33, 0x30, 0x32, 0x33, 0x63, 0x37, 0x66, 0x30, 0x32, 0x34, 0x66, 0x37, 0x32, 0x63, 0x35, 0x66, 0x32, 0x30, 0x36, 0x39, 0x38, 0x33, 0x64, 0x32, 0x32, 0x35, 0x62, 0x64, 0x62, 0x39, 0x33, 0x63, 0x66, 0x39, 0x39, 0x35, 0x34, 0x31, 0x61, 0x66, 0x61, 0x65, 0x38, 0x31, 0x65, 0x31, 0x38, 0x63, 0x34, 0x37, 0x36, 0x65, 0x34, 0x64, 0x35, 0x61, 0x66, 0x62, 0x39, 0x62, 0x32, 0x33, 0x64, 0x65, 0x61, 0x62, 0x33, 0x65, 0x31, 0x61, 0x61, 0x65, 0x64, 0x33, 0x31, 0x37, 0x32, 0x66, 0x63, 0x30, 0x61, 0x66, 0x62, 0x66, 0x61, 0x61, 0x64, 0x61, 0x62, 0x66, 0x61, 0x37, 0x63, 0x61, 0x38, 0x63, 0x61, 0x62, 0x30, 0x38, 0x38, 0x32, 0x30, 0x64, 0x39, 0x61, 0x66, 0x36, 0x66, 0x66, 0x34, 0x31, 0x61, 0x37, 0x37, 0x37, 0x39, 0x36, 0x63, 0x61, 0x35, 0x64, 0x38, 0x30, 0x63, 0x35, 0x62, 0x36, 0x64, 0x62, 0x62, 0x38, 0x63, 0x65, 0x65, 0x66, 0x37, 0x37, 0x66, 0x37, 0x32, 0x39, 0x32, 0x33, 0x65, 0x30, 0x66, 0x63, 0x31, 0x38, 0x35, 0x37, 0x64, 0x66, 0x61, 0x36, 0x32, 0x63, 0x63, 0x62, 0x65, 0x32, 0x35, 0x64, 0x65, 0x35, 0x64, 0x30, 0x62, 0x62, 0x31, 0x32, 0x34, 0x37, 0x33, 0x34, 0x65, 0x39, 0x61, 0x35, 0x31, 0x32, 0x61, 0x62, 0x62, 0x37, 0x61, 0x37, 0x30, 0x66, 0x31, 0x33, 0x38, 0x63, 0x64, 0x35, 0x34, 0x63, 0x63, 0x63, 0x31, 0x65, 0x35, 0x37, 0x32, 0x35, 0x36, 0x65, 0x35, 0x62, 0x37, 0x61, 0x38, 0x36, 0x64, 0x33, 0x37, 0x34, 0x37, 0x34, 0x30, 0x32, 0x39, 0x62, 0x38, 0x38, 0x35, 0x61, 0x38, 0x62, 0x37, 0x38, 0x36, 0x64, 0x37, 0x39, 0x30, 0x38, 0x36, 0x31, 0x64, 0x38, 0x35, 0x36, 0x33, 0x33, 0x34, 0x32, 0x66, 0x34, 0x33, 0x61, 0x32, 0x32, 0x33, 0x36, 0x31, 0x33, 0x63, 0x33, 0x33, 0x61, 0x65, 0x64, 0x38, 0x63, 0x64, 0x37, 0x32, 0x65, 0x31, 0x36, 0x33, 0x37, 0x63, 0x64, 0x61, 0x61, 0x63, 0x38, 0x33, 0x31, 0x35, 0x36, 0x62, 0x37, 0x30, 0x34, 0x30, 0x66, 0x62, 0x38, 0x61, 0x62, 0x36, 0x62, 0x31, 0x64, 0x39, 0x62, 0x63, 0x61, 0x36, 0x61, 0x38, 0x61, 0x66, 0x64, 0x34, 0x30, 0x37, 0x64, 0x37, 0x33, 0x65, 0x39, 0x30, 0x30, 0x35, 0x64, 0x66, 0x66, 0x34, 0x61, 0x36, 0x64, 0x63, 0x33, 0x34, 0x62, 0x38, 0x31, 0x30, 0x34, 0x64, 0x35, 0x35, 0x36, 0x64, 0x39, 0x65, 0x38, 0x36, 0x64, 0x38, 0x38, 0x35, 0x63, 0x62, 0x33, 0x63, 0x65, 0x66, 0x64, 0x35, 0x65, 0x33, 0x64, 0x38, 0x30, 0x65, 0x34, 0x38, 0x38, 0x38, 0x31, 0x30, 0x39, 0x32, 0x34, 0x36, 0x64, 0x35, 0x35, 0x37, 0x34, 0x65, 0x66, 0x31, 0x66, 0x63, 0x33, 0x39, 0x65, 0x30, 0x31, 0x33, 0x33, 0x38, 0x32, 0x31, 0x65, 0x65, 0x31, 0x64, 0x37, 0x32, 0x64, 0x32, 0x66, 0x64, 0x35, 0x34, 0x34, 0x39, 0x32, 0x61, 0x37, 0x63, 0x36, 0x34, 0x34, 0x38, 0x35, 0x35, 0x64, 0x38, 0x37, 0x33, 0x30, 0x61, 0x61, 0x66, 0x63, 0x64, 0x36, 0x64, 0x61, 0x64, 0x65, 0x63, 0x66, 0x64, 0x61, 0x63, 0x36, 0x34, 0x62, 0x35, 0x66, 0x36, 0x63, 0x64, 0x65, 0x34, 0x30, 0x30, 0x30, 0x33, 0x63, 0x64, 0x63, 0x61, 0x62, 0x38, 0x39, 0x62, 0x36, 0x37, 0x37, 0x32, 0x38, 0x38, 0x35, 0x32, 0x33, 0x30, 0x39, 0x31, 0x31, 0x36, 0x30, 0x35, 0x61, 0x38, 0x31, 0x66, 0x62, 0x38, 0x38, 0x32, 0x31, 0x65, 0x37, 0x37, 0x66, 0x63, 0x33, 0x35, 0x36, 0x34, 0x33, 0x39, 0x61, 0x36, 0x39, 0x34, 0x62, 0x36, 0x35, 0x63, 0x61, 0x63, 0x33, 0x65, 0x61, 0x31, 0x32, 0x32, 0x35, 0x64, 0x37, 0x38, 0x30, 0x32, 0x66, 0x64, 0x32, 0x39, 0x39, 0x63, 0x64, 0x33, 0x36, 0x30, 0x38, 0x31, 0x36, 0x37, 0x33, 0x65, 0x32, 0x37, 0x39, 0x39, 0x30, 0x64, 0x38, 0x62, 0x33, 0x64, 0x66, 0x39, 0x39, 0x66, 0x63, 0x31, 0x39, 0x38, 0x37, 0x32, 0x64, 0x33, 0x65, 0x39, 0x62, 0x37, 0x33, 0x37, 0x30, 0x30, 0x33, 0x62, 0x36, 0x37, 0x36, 0x35, 0x66, 0x66, 0x37, 0x31, 0x31, 0x31, 0x30, 0x31, 0x38, 0x66, 0x61, 0x63, 0x38, 0x66, 0x66, 0x32, 0x38, 0x62, 0x34, 0x32, 0x30, 0x61, 0x32, 0x34, 0x37, 0x38, 0x37, 0x35, 0x35, 0x30, 0x35, 0x64, 0x62, 0x32, 0x39, 0x32, 0x39, 0x35, 0x63, 0x34, 0x32, 0x62, 0x66, 0x63, 0x65, 0x61, 0x35, 0x39, 0x63, 0x33, 0x32, 0x64, 0x61, 0x37, 0x32, 0x64, 0x61, 0x35, 0x34, 0x30, 0x61, 0x61, 0x66, 0x30, 0x64, 0x32, 0x32, 0x34, 0x38, 0x33, 0x34, 0x30, 0x38, 0x33, 0x64, 0x30, 0x39, 0x37, 0x62, 0x37, 0x32, 0x31, 0x39, 0x37, 0x37, 0x32, 0x31, 0x38, 0x36, 0x66, 0x31, 0x35, 0x34, 0x33, 0x64, 0x39, 0x34, 0x64, 0x36, 0x64, 0x38, 0x37, 0x66, 0x35, 0x62, 0x64, 0x34, 0x32, 0x39, 0x37, 0x61, 0x39, 0x66, 0x39, 0x35, 0x61, 0x64, 0x63, 0x66, 0x39, 0x31, 0x32, 0x34, 0x33, 0x30, 0x39, 0x61, 0x64, 0x37, 0x64, 0x39, 0x38, 0x38, 0x37, 0x61, 0x61, 0x34, 0x34, 0x33, 0x37, 0x62, 0x35, 0x35, 0x32, 0x64, 0x32, 0x31, 0x37, 0x37, 0x32, 0x30, 0x64, 0x39, 0x36, 0x66, 0x31, 0x66, 0x39, 0x34, 0x35, 0x36, 0x65, 0x35, 0x62, 0x31, 0x63, 0x33, 0x32, 0x63, 0x64, 0x62, 0x63, 0x34, 0x33, 0x33, 0x66, 0x31, 0x39, 0x39, 0x32, 0x62, 0x32, 0x66, 0x31, 0x36, 0x62, 0x30, 0x30, 0x38, 0x63, 0x61, 0x37, 0x38, 0x65, 0x39, 0x39, 0x38, 0x63, 0x36, 0x31, 0x64, 0x31, 0x66, 0x38, 0x35, 0x38, 0x36, 0x30, 0x30, 0x65, 0x63, 0x63, 0x37, 0x32, 0x30, 0x30, 0x35, 0x37, 0x32, 0x65, 0x38, 0x32, 0x34, 0x66, 0x37, 0x65, 0x39, 0x33, 0x33, 0x62, 0x32, 0x62, 0x63, 0x39, 0x64, 0x65, 0x63, 0x64, 0x37, 0x64, 0x65, 0x33, 0x34, 0x65, 0x39, 0x39, 0x31, 0x39, 0x61, 0x65, 0x66, 0x63, 0x34, 0x66, 0x37, 0x39, 0x39, 0x31, 0x66, 0x37, 0x31, 0x64, 0x38, 0x33, 0x30, 0x39, 0x61, 0x66, 0x65, 0x61, 0x61, 0x33, 0x32, 0x35, 0x36, 0x62, 0x37, 0x32, 0x38, 0x30, 0x63, 0x62, 0x65, 0x65, 0x63, 0x33, 0x64, 0x37, 0x31, 0x35, 0x63, 0x37, 0x38, 0x65, 0x39, 0x35, 0x38, 0x37, 0x63, 0x38, 0x61, 0x64, 0x61, 0x38, 0x35, 0x33, 0x37, 0x37, 0x35, 0x39, 0x65, 0x34, 0x32, 0x30, 0x66, 0x62, 0x33, 0x37, 0x32, 0x32, 0x37, 0x39, 0x37, 0x39, 0x37, 0x30, 0x61, 0x36, 0x38, 0x30, 0x66, 0x62, 0x39, 0x64, 0x30, 0x30, 0x31, 0x31, 0x38, 0x61, 0x35, 0x62, 0x35, 0x66, 0x32, 0x31, 0x63, 0x62, 0x37, 0x33, 0x30, 0x65, 0x61, 0x36, 0x62, 0x65, 0x61, 0x33, 0x61, 0x30, 0x64, 0x38, 0x38, 0x64, 0x63, 0x39, 0x35, 0x66, 0x31, 0x38, 0x37, 0x61, 0x34, 0x36, 0x65, 0x63, 0x31, 0x35, 0x66, 0x66, 0x30, 0x39, 0x64, 0x66, 0x62, 0x64, 0x62, 0x63, 0x63, 0x34, 0x63, 0x37, 0x32, 0x33, 0x32, 0x32, 0x61, 0x36, 0x62, 0x31, 0x30, 0x61, 0x32, 0x33, 0x34, 0x37, 0x37, 0x61, 0x39, 0x62, 0x38, 0x63, 0x62, 0x61, 0x66, 0x36, 0x38, 0x35, 0x37, 0x36, 0x37, 0x62, 0x64, 0x39, 0x66, 0x32, 0x34, 0x64, 0x32, 0x37, 0x35, 0x38, 0x34, 0x64, 0x33, 0x61, 0x30, 0x62, 0x37, 0x66, 0x36, 0x62, 0x62, 0x31, 0x35, 0x33, 0x37, 0x30, 0x30, 0x31, 0x34, 0x32, 0x36, 0x34, 0x33, 0x34, 0x36, 0x30, 0x65, 0x32, 0x64, 0x36, 0x31, 0x34, 0x37, 0x31, 0x61, 0x34, 0x36, 0x35, 0x31, 0x66, 0x61, 0x61, 0x33, 0x37, 0x63, 0x66, 0x31, 0x34, 0x39, 0x36, 0x61, 0x64, 0x32, 0x61, 0x35, 0x62, 0x65, 0x31, 0x66, 0x38, 0x64, 0x39, 0x62, 0x30, 0x31, 0x65, 0x62, 0x63, 0x66, 0x35, 0x32, 0x62, 0x34, 0x39, 0x36, 0x37, 0x65, 0x64, 0x35, 0x39, 0x31, 0x64, 0x32, 0x34, 0x64, 0x30, 0x30, 0x32, 0x34, 0x32, 0x39, 0x34, 0x65, 0x63, 0x32, 0x33, 0x35, 0x35, 0x34, 0x36, 0x37, 0x32, 0x35, 0x62, 0x62, 0x34, 0x34, 0x32, 0x64, 0x31, 0x66, 0x30, 0x38, 0x31, 0x61, 0x65, 0x37, 0x34, 0x33, 0x37, 0x63, 0x39, 0x35, 0x66, 0x32, 0x37, 0x61, 0x38, 0x65, 0x66, 0x63, 0x33, 0x37, 0x36, 0x66, 0x38, 0x64, 0x33, 0x35, 0x65, 0x33, 0x64, 0x34, 0x62, 0x39, 0x63, 0x34, 0x35, 0x35, 0x38, 0x37, 0x61, 0x38, 0x37, 0x31, 0x34, 0x65, 0x37, 0x37, 0x32, 0x62, 0x33, 0x62, 0x64, 0x30, 0x66, 0x37, 0x62, 0x62, 0x33, 0x30, 0x32, 0x32, 0x33, 0x32, 0x30, 0x63, 0x36, 0x31, 0x61, 0x62, 0x33, 0x37, 0x35, 0x31, 0x65, 0x64, 0x31, 0x39, 0x39, 0x62, 0x66, 0x38, 0x34, 0x30, 0x33, 0x35, 0x61, 0x32, 0x62, 0x66, 0x30, 0x30, 0x32, 0x31, 0x31, 0x64, 0x34, 0x64, 0x39, 0x63, 0x36, 0x32, 0x34, 0x33, 0x37, 0x65, 0x63, 0x34, 0x31, 0x33, 0x61, 0x62, 0x34, 0x65, 0x39, 0x64, 0x30, 0x37, 0x32, 0x36, 0x39, 0x36, 0x34, 0x65, 0x38, 0x62, 0x33, 0x64, 0x38, 0x66, 0x32, 0x65, 0x39, 0x31, 0x32, 0x34, 0x30, 0x36, 0x66, 0x65, 0x62, 0x62, 0x35, 0x35, 0x62, 0x63, 0x30, 0x65, 0x31, 0x37, 0x37, 0x36, 0x39, 0x34, 0x30, 0x65, 0x61, 0x62, 0x31, 0x37, 0x61, 0x64, 0x38, 0x35, 0x38, 0x64, 0x61, 0x39, 0x38, 0x35, 0x66, 0x32, 0x62, 0x61, 0x39, 0x34, 0x34, 0x39, 0x32, 0x65, 0x65, 0x34, 0x64, 0x34, 0x31, 0x38, 0x35, 0x35, 0x62, 0x65, 0x39, 0x61, 0x30, 0x33, 0x31, 0x39, 0x63, 0x39, 0x64, 0x35, 0x66, 0x64, 0x32, 0x30, 0x32, 0x63, 0x66, 0x61, 0x35, 0x64, 0x38, 0x33, 0x30, 0x36, 0x62, 0x36, 0x39, 0x39, 0x39, 0x61, 0x38, 0x37, 0x30, 0x66, 0x30, 0x62, 0x64, 0x62, 0x34, 0x65, 0x32, 0x36, 0x39, 0x34, 0x65, 0x33, 0x64, 0x35, 0x36, 0x32, 0x62, 0x62, 0x33, 0x32, 0x32, 0x35, 0x64, 0x33, 0x61, 0x36, 0x30, 0x33, 0x33, 0x62, 0x34, 0x37, 0x36, 0x62, 0x38, 0x39, 0x34, 0x66, 0x35, 0x65, 0x64, 0x38, 0x63, 0x37, 0x36, 0x32, 0x63, 0x38, 0x66, 0x33, 0x37, 0x36, 0x36, 0x32, 0x35, 0x38, 0x34, 0x36, 0x34, 0x39, 0x32, 0x33, 0x39, 0x35, 0x61, 0x38, 0x34, 0x36, 0x34, 0x65, 0x62, 0x34, 0x65, 0x66, 0x33, 0x66, 0x36, 0x34, 0x65, 0x61, 0x30, 0x61, 0x33, 0x30, 0x64, 0x37, 0x32, 0x39, 0x61, 0x34, 0x66, 0x31, 0x32, 0x39, 0x61, 0x35, 0x33, 0x38, 0x38, 0x33, 0x35, 0x66, 0x65, 0x36, 0x31, 0x33, 0x33, 0x66, 0x31, 0x35, 0x32, 0x61, 0x33, 0x33, 0x64, 0x35, 0x39, 0x62, 0x39, 0x30, 0x36, 0x32, 0x64, 0x36, 0x64, 0x39, 0x34, 0x63, 0x31, 0x63, 0x65, 0x63, 0x63, 0x63, 0x38, 0x30, 0x66, 0x33, 0x33, 0x34, 0x66, 0x37, 0x34, 0x62, 0x33, 0x37, 0x33, 0x33, 0x32, 0x37, 0x32, 0x30, 0x36, 0x61, 0x62, 0x36, 0x33, 0x35, 0x39, 0x64, 0x61, 0x33, 0x32, 0x65, 0x66, 0x66, 0x61, 0x39, 0x32, 0x32, 0x33, 0x39, 0x66, 0x38, 0x64, 0x65, 0x34, 0x37, 0x36, 0x30, 0x34, 0x35, 0x62, 0x34, 0x30, 0x66, 0x35, 0x34, 0x37, 0x32, 0x35, 0x34, 0x38, 0x34, 0x64, 0x36, 0x62, 0x31, 0x33, 0x33, 0x66, 0x36, 0x30, 0x30, 0x34, 0x33, 0x61, 0x34, 0x62, 0x35, 0x30, 0x35, 0x31, 0x37, 0x32, 0x39, 0x34, 0x33, 0x61, 0x65, 0x33, 0x34, 0x31, 0x35, 0x33, 0x34, 0x35, 0x35, 0x32, 0x62, 0x61, 0x38, 0x66, 0x65, 0x62, 0x63, 0x38, 0x61, 0x39, 0x35, 0x64, 0x66, 0x31, 0x32, 0x35, 0x36, 0x64, 0x38, 0x35, 0x36, 0x34, 0x30, 0x62, 0x38, 0x61, 0x30, 0x38, 0x33, 0x36, 0x66, 0x66, 0x39, 0x32, 0x66, 0x33, 0x32, 0x66, 0x39, 0x62, 0x33, 0x63, 0x38, 0x32, 0x35, 0x63, 0x31, 0x39, 0x37, 0x32, 0x31, 0x34, 0x33, 0x61, 0x37, 0x65, 0x65, 0x35, 0x31, 0x31, 0x31, 0x31, 0x64, 0x38, 0x37, 0x37, 0x34, 0x31, 0x61, 0x33, 0x62, 0x35, 0x39, 0x36, 0x63, 0x66, 0x65, 0x38, 0x37, 0x66, 0x31, 0x30, 0x63, 0x30, 0x65, 0x31, 0x62, 0x62, 0x66, 0x37, 0x66, 0x39, 0x61, 0x62, 0x63, 0x36, 0x34, 0x31, 0x61, 0x64, 0x35, 0x30, 0x36, 0x66, 0x62, 0x66, 0x66, 0x63, 0x61, 0x36, 0x34, 0x34, 0x37, 0x32, 0x66, 0x38, 0x62, 0x63, 0x64, 0x34, 0x64, 0x65, 0x38, 0x66, 0x37, 0x32, 0x61, 0x35, 0x38, 0x66, 0x31, 0x35, 0x30, 0x37, 0x33, 0x63, 0x33, 0x36, 0x35, 0x36, 0x31, 0x64, 0x30, 0x35, 0x61, 0x62, 0x64, 0x64, 0x65, 0x32, 0x62, 0x39, 0x34, 0x33, 0x65, 0x33, 0x34, 0x34, 0x64, 0x36, 0x37, 0x35, 0x61, 0x66, 0x65, 0x61, 0x31, 0x38, 0x38, 0x62, 0x37, 0x61, 0x33, 0x61, 0x30, 0x30, 0x37, 0x32, 0x30, 0x37, 0x36, 0x37, 0x30, 0x65, 0x37, 0x38, 0x33, 0x31, 0x34, 0x63, 0x62, 0x39, 0x33, 0x63, 0x32, 0x37, 0x64, 0x38, 0x38, 0x64, 0x61, 0x33, 0x62, 0x35, 0x35, 0x64, 0x30, 0x63, 0x36, 0x39, 0x32, 0x39, 0x31, 0x66, 0x62, 0x61, 0x61, 0x38, 0x38, 0x30, 0x32, 0x63, 0x30, 0x36, 0x37, 0x32, 0x66, 0x63, 0x36, 0x34, 0x64, 0x30, 0x33, 0x37, 0x65, 0x64, 0x66, 0x36, 0x62, 0x34, 0x36, 0x32, 0x64, 0x30, 0x37, 0x34, 0x38, 0x64, 0x61, 0x39, 0x38, 0x34, 0x36, 0x32, 0x62, 0x32, 0x36, 0x62, 0x66, 0x38, 0x36, 0x36, 0x61, 0x61, 0x66, 0x62, 0x37, 0x31, 0x61, 0x61, 0x66, 0x66, 0x36, 0x38, 0x38, 0x31, 0x64, 0x39, 0x30, 0x37, 0x39, 0x34, 0x63, 0x31, 0x65, 0x61, 0x33, 0x33, 0x33, 0x35, 0x33, 0x39, 0x63, 0x66, 0x37, 0x61, 0x30, 0x61, 0x62, 0x39, 0x65, 0x30, 0x64, 0x37, 0x37, 0x32, 0x61, 0x32, 0x62, 0x38, 0x63, 0x32, 0x31, 0x36, 0x65, 0x35, 0x39, 0x36, 0x39, 0x32, 0x30, 0x65, 0x65, 0x63, 0x39, 0x32, 0x36, 0x39, 0x61, 0x39, 0x33, 0x31, 0x30, 0x39, 0x62, 0x32, 0x34, 0x65, 0x31, 0x30, 0x34, 0x61, 0x36, 0x34, 0x35, 0x35, 0x66, 0x66, 0x63, 0x65, 0x65, 0x63, 0x30, 0x62, 0x63, 0x31, 0x65, 0x34, 0x37, 0x34, 0x34, 0x39, 0x65, 0x35, 0x35, 0x35, 0x34, 0x37, 0x30, 0x38, 0x66, 0x35, 0x34, 0x34, 0x35, 0x61, 0x63, 0x63, 0x65, 0x31, 0x66, 0x36, 0x64, 0x35, 0x36, 0x65, 0x66, 0x66, 0x39, 0x39, 0x63, 0x32, 0x64, 0x38, 0x33, 0x30, 0x63, 0x62, 0x31, 0x37, 0x30, 0x62, 0x66, 0x37, 0x39, 0x64, 0x30, 0x31, 0x32, 0x65, 0x63, 0x63, 0x36, 0x35, 0x63, 0x38, 0x63, 0x33, 0x33, 0x38, 0x31, 0x62, 0x63, 0x36, 0x30, 0x33, 0x34, 0x62, 0x65, 0x38, 0x65, 0x38, 0x37, 0x32, 0x64, 0x30, 0x36, 0x35, 0x66, 0x36, 0x38, 0x36, 0x30, 0x36, 0x37, 0x61, 0x33, 0x64, 0x31, 0x35, 0x34, 0x61, 0x66, 0x39, 0x66, 0x32, 0x32, 0x62, 0x30, 0x65, 0x33, 0x34, 0x64, 0x32, 0x37, 0x31, 0x30, 0x35, 0x65, 0x34, 0x37, 0x62, 0x66, 0x32, 0x61, 0x32, 0x65, 0x38, 0x65, 0x64, 0x30, 0x37, 0x33, 0x62, 0x36, 0x34, 0x35, 0x30, 0x35, 0x31, 0x37, 0x36, 0x31, 0x30, 0x37, 0x63, 0x37, 0x32, 0x37, 0x61, 0x65, 0x62, 0x31, 0x61, 0x62, 0x64, 0x32, 0x32, 0x37, 0x32, 0x38, 0x35, 0x38, 0x61, 0x63, 0x63, 0x34, 0x37, 0x62, 0x62, 0x35, 0x35, 0x33, 0x35, 0x64, 0x35, 0x35, 0x39, 0x62, 0x31, 0x34, 0x62, 0x39, 0x31, 0x64, 0x38, 0x34, 0x35, 0x39, 0x32, 0x61, 0x63, 0x31, 0x33, 0x37, 0x39, 0x37, 0x63, 0x38, 0x33, 0x34, 0x30, 0x63, 0x32, 0x32, 0x30, 0x35, 0x32, 0x66, 0x63, 0x31, 0x39, 0x38, 0x36, 0x38, 0x38, 0x30, 0x36, 0x31, 0x33, 0x36, 0x34, 0x62, 0x35, 0x37, 0x31, 0x65, 0x32, 0x61, 0x37, 0x35, 0x33, 0x66, 0x66, 0x35, 0x32, 0x30, 0x66, 0x31, 0x63, 0x65, 0x30, 0x66, 0x66, 0x61, 0x39, 0x32, 0x36, 0x32, 0x34, 0x31, 0x31, 0x62, 0x65, 0x34, 0x61, 0x32, 0x32, 0x61, 0x39, 0x65, 0x61, 0x63, 0x65, 0x34, 0x61, 0x35, 0x35, 0x62, 0x35, 0x30, 0x62, 0x62, 0x62, 0x31, 0x61, 0x32, 0x34, 0x36, 0x66, 0x35, 0x31, 0x64, 0x33, 0x63, 0x61, 0x35, 0x61, 0x62, 0x35, 0x32, 0x65, 0x63, 0x65, 0x34, 0x62, 0x62, 0x65, 0x32, 0x30, 0x30, 0x33, 0x61, 0x33, 0x34, 0x65, 0x32, 0x30, 0x63, 0x61, 0x39, 0x61, 0x32, 0x64, 0x63, 0x37, 0x63, 0x66, 0x31, 0x65, 0x37, 0x32, 0x38, 0x39, 0x33, 0x32, 0x62, 0x61, 0x36, 0x32, 0x61, 0x61, 0x39, 0x62, 0x34, 0x61, 0x30, 0x33, 0x37, 0x32, 0x32, 0x35, 0x34, 0x33, 0x36, 0x35, 0x61, 0x64, 0x61, 0x39, 0x36, 0x37, 0x63, 0x39, 0x63, 0x38, 0x32, 0x63, 0x62, 0x38, 0x31, 0x39, 0x31, 0x31, 0x37, 0x62, 0x35, 0x34, 0x35, 0x65, 0x62, 0x30, 0x30, 0x39, 0x30, 0x62, 0x66, 0x35, 0x62, 0x65, 0x65, 0x33, 0x64, 0x65, 0x63, 0x34, 0x31, 0x35, 0x31, 0x35, 0x36, 0x37, 0x34, 0x37, 0x39, 0x36, 0x34, 0x36, 0x34, 0x63, 0x65, 0x34, 0x37, 0x32, 0x63, 0x31, 0x62, 0x30, 0x65, 0x35, 0x62, 0x30, 0x34, 0x31, 0x38, 0x36, 0x63, 0x63, 0x33, 0x63, 0x61, 0x30, 0x31, 0x37, 0x31, 0x35, 0x65, 0x35, 0x36, 0x37, 0x61, 0x61, 0x66, 0x66, 0x35, 0x63, 0x37, 0x32, 0x38, 0x34, 0x38, 0x61, 0x66, 0x30, 0x61, 0x61, 0x34, 0x34, 0x31, 0x62, 0x61, 0x65, 0x32, 0x61, 0x30, 0x65, 0x62, 0x31, 0x36, 0x30, 0x33, 0x31, 0x35, 0x64, 0x38, 0x65, 0x37, 0x32, 0x65, 0x34, 0x62, 0x33, 0x66, 0x39, 0x34, 0x39, 0x65, 0x36, 0x34, 0x30, 0x34, 0x38, 0x65, 0x30, 0x30, 0x31, 0x62, 0x34, 0x62, 0x64, 0x61, 0x32, 0x66, 0x32, 0x62, 0x35, 0x65, 0x36, 0x62, 0x62, 0x65, 0x34, 0x34, 0x62, 0x35, 0x34, 0x65, 0x38, 0x30, 0x35, 0x39, 0x33, 0x32, 0x39, 0x63, 0x61, 0x62, 0x31, 0x34, 0x30, 0x33, 0x37, 0x65, 0x39, 0x64, 0x31, 0x30, 0x66, 0x37, 0x39, 0x37, 0x32, 0x31, 0x63, 0x31, 0x61, 0x31, 0x62, 0x33, 0x36, 0x33, 0x64, 0x62, 0x61, 0x65, 0x30, 0x36, 0x63, 0x63, 0x38, 0x33, 0x31, 0x31, 0x61, 0x36, 0x38, 0x66, 0x63, 0x32, 0x64, 0x38, 0x32, 0x65, 0x31, 0x36, 0x38, 0x39, 0x32, 0x35, 0x34, 0x31, 0x38, 0x31, 0x35, 0x65, 0x38, 0x30, 0x61, 0x30, 0x66, 0x38, 0x36, 0x34, 0x61, 0x31, 0x35, 0x30, 0x64, 0x64, 0x65, 0x38, 0x32, 0x63, 0x64, 0x37, 0x32, 0x32, 0x31, 0x66, 0x30, 0x37, 0x34, 0x66, 0x33, 0x34, 0x32, 0x66, 0x30, 0x63, 0x32, 0x62, 0x63, 0x35, 0x35, 0x36, 0x63, 0x31, 0x34, 0x35, 0x37, 0x65, 0x39, 0x32, 0x37, 0x31, 0x65, 0x31, 0x33, 0x32, 0x36, 0x33, 0x66, 0x37, 0x62, 0x31, 0x65, 0x38, 0x64, 0x65, 0x32, 0x39, 0x39, 0x38, 0x65, 0x34, 0x35, 0x36, 0x31, 0x63, 0x34, 0x34, 0x65, 0x39, 0x30, 0x63, 0x36, 0x36, 0x33, 0x36, 0x30, 0x61, 0x36, 0x32, 0x62, 0x37, 0x66, 0x37, 0x35, 0x37, 0x36, 0x64, 0x35, 0x31, 0x64, 0x39, 0x35, 0x30, 0x61, 0x36, 0x31, 0x66, 0x37, 0x66, 0x65, 0x32, 0x34, 0x30, 0x64, 0x34, 0x34, 0x36, 0x64, 0x65, 0x31, 0x36, 0x35, 0x65, 0x62, 0x38, 0x61, 0x64, 0x64, 0x34, 0x61, 0x64, 0x36, 0x66, 0x38, 0x35, 0x38, 0x31, 0x32, 0x32, 0x65, 0x62, 0x66, 0x32, 0x62, 0x31, 0x34, 0x35, 0x61, 0x37, 0x32, 0x32, 0x33, 0x32, 0x35, 0x62, 0x61, 0x30, 0x39, 0x32, 0x32, 0x33, 0x34, 0x66, 0x66, 0x31, 0x61, 0x63, 0x33, 0x62, 0x64, 0x38, 0x65, 0x64, 0x33, 0x61, 0x39, 0x39, 0x35, 0x31, 0x31, 0x61, 0x36, 0x66, 0x64, 0x30, 0x31, 0x39, 0x30, 0x66, 0x37, 0x36, 0x35, 0x33, 0x36, 0x31, 0x34, 0x65, 0x36, 0x37, 0x63, 0x36, 0x35, 0x30, 0x61, 0x39, 0x63, 0x39, 0x64, 0x33, 0x32, 0x33, 0x32, 0x30, 0x62, 0x65, 0x32, 0x35, 0x30, 0x34, 0x61, 0x65, 0x64, 0x32, 0x62, 0x64, 0x32, 0x37, 0x64, 0x36, 0x61, 0x34, 0x37, 0x38, 0x65, 0x38, 0x31, 0x34, 0x33, 0x34, 0x39, 0x37, 0x38, 0x37, 0x39, 0x66, 0x38, 0x62, 0x39, 0x38, 0x32, 0x65, 0x34, 0x65, 0x39, 0x65, 0x63, 0x34, 0x30, 0x63, 0x61, 0x31, 0x39, 0x33, 0x62, 0x33, 0x32, 0x30, 0x65, 0x38, 0x61, 0x31, 0x33, 0x31, 0x36, 0x37, 0x62, 0x32, 0x33, 0x32, 0x38, 0x38, 0x65, 0x35, 0x32, 0x31, 0x30, 0x35, 0x66, 0x37, 0x37, 0x36, 0x61, 0x31, 0x66, 0x38, 0x64, 0x64, 0x61, 0x65, 0x39, 0x66, 0x63, 0x34, 0x34, 0x63, 0x64, 0x30, 0x33, 0x33, 0x63, 0x36, 0x65, 0x63, 0x35, 0x37, 0x64, 0x33, 0x61, 0x38, 0x38, 0x37, 0x30, 0x35, 0x30, 0x38, 0x31, 0x62, 0x64, 0x66, 0x35, 0x39, 0x62, 0x30, 0x38, 0x61, 0x66, 0x36, 0x33, 0x66, 0x35, 0x37, 0x32, 0x38, 0x35, 0x62, 0x34, 0x65, 0x63, 0x37, 0x61, 0x34, 0x35, 0x31, 0x61, 0x37, 0x65, 0x39, 0x61, 0x38, 0x65, 0x31, 0x36, 0x64, 0x33, 0x38, 0x62, 0x64, 0x30, 0x65, 0x33, 0x62, 0x64, 0x62, 0x36, 0x65, 0x36, 0x30, 0x36, 0x63, 0x34, 0x66, 0x65, 0x30, 0x38, 0x37, 0x34, 0x39, 0x62, 0x32, 0x32, 0x34, 0x62, 0x35, 0x36, 0x36, 0x63, 0x31, 0x32, 0x33, 0x32, 0x38, 0x65, 0x65, 0x62, 0x37, 0x32, 0x61, 0x31, 0x33, 0x37, 0x63, 0x31, 0x30, 0x64, 0x34, 0x61, 0x38, 0x33, 0x30, 0x36, 0x39, 0x39, 0x39, 0x31, 0x64, 0x37, 0x30, 0x39, 0x38, 0x66, 0x32, 0x62, 0x34, 0x30, 0x64, 0x63, 0x61, 0x36, 0x36, 0x62, 0x35, 0x66, 0x35, 0x64, 0x32, 0x34, 0x34, 0x63, 0x39, 0x63, 0x37, 0x66, 0x61, 0x66, 0x32, 0x61, 0x35, 0x31, 0x66, 0x61, 0x39, 0x64, 0x33, 0x36, 0x30, 0x39, 0x61, 0x65, 0x37, 0x32, 0x37, 0x38, 0x36, 0x64, 0x62, 0x32, 0x33, 0x61, 0x63, 0x36, 0x32, 0x39, 0x62, 0x31, 0x63, 0x37, 0x62, 0x64, 0x61, 0x64, 0x61, 0x39, 0x36, 0x32, 0x30, 0x38, 0x30, 0x32, 0x39, 0x64, 0x36, 0x66, 0x32, 0x34, 0x37, 0x31, 0x37, 0x32, 0x35, 0x64, 0x61, 0x32, 0x33, 0x66, 0x38, 0x34, 0x35, 0x39, 0x39, 0x63, 0x63, 0x32, 0x66, 0x36, 0x33, 0x39, 0x37, 0x30, 0x30, 0x39, 0x66, 0x31, 0x33, 0x31, 0x63, 0x33, 0x64, 0x66, 0x65, 0x33, 0x64, 0x39, 0x61, 0x62, 0x65, 0x31, 0x31, 0x32, 0x35, 0x31, 0x66, 0x63, 0x34, 0x33, 0x36, 0x37, 0x31, 0x32, 0x33, 0x61, 0x38, 0x61, 0x64, 0x36, 0x63, 0x32, 0x30, 0x36, 0x31, 0x66, 0x64, 0x30, 0x32, 0x35, 0x32, 0x32, 0x64, 0x39, 0x62, 0x65, 0x35, 0x38, 0x38, 0x34, 0x35, 0x62, 0x35, 0x34, 0x32, 0x36, 0x61, 0x33, 0x38, 0x66, 0x36, 0x30, 0x30, 0x38, 0x30, 0x33, 0x62, 0x39, 0x66, 0x64, 0x38, 0x63, 0x35, 0x64, 0x31, 0x35, 0x37, 0x30, 0x63, 0x63, 0x61, 0x38, 0x39, 0x31, 0x31, 0x39, 0x39, 0x64, 0x31, 0x61, 0x38, 0x31, 0x30, 0x31, 0x37, 0x38, 0x65, 0x31, 0x31, 0x39, 0x39, 0x34, 0x62, 0x39, 0x35, 0x64, 0x31, 0x38, 0x32, 0x63, 0x65, 0x35, 0x62, 0x35, 0x33, 0x38, 0x64, 0x36, 0x66, 0x33, 0x37, 0x36, 0x65, 0x36, 0x31, 0x36, 0x37, 0x32, 0x35, 0x31, 0x31, 0x34, 0x35, 0x33, 0x63, 0x61, 0x65, 0x65, 0x63, 0x32, 0x36, 0x36, 0x37, 0x38, 0x36, 0x66, 0x39, 0x35, 0x39, 0x31, 0x34, 0x61, 0x65, 0x37, 0x62, 0x37, 0x66, 0x63, 0x63, 0x36, 0x66, 0x32, 0x35, 0x38, 0x38, 0x39, 0x38, 0x65, 0x34, 0x32, 0x34, 0x34, 0x34, 0x62, 0x38, 0x30, 0x63, 0x65, 0x32, 0x62, 0x33, 0x66, 0x39, 0x36, 0x30, 0x66, 0x62, 0x65, 0x33, 0x37, 0x37, 0x32, 0x30, 0x35, 0x34, 0x30, 0x65, 0x61, 0x39, 0x66, 0x31, 0x34, 0x66, 0x62, 0x31, 0x37, 0x37, 0x34, 0x33, 0x63, 0x33, 0x66, 0x64, 0x62, 0x61, 0x39, 0x61, 0x61, 0x30, 0x30, 0x34, 0x30, 0x39, 0x61, 0x36, 0x64, 0x32, 0x34, 0x33, 0x34, 0x34, 0x61, 0x65, 0x38, 0x32, 0x38, 0x38, 0x35, 0x66, 0x37, 0x66, 0x62, 0x30, 0x35, 0x65, 0x35, 0x32, 0x31, 0x38, 0x35, 0x35, 0x36, 0x63, 0x37, 0x36, 0x65, 0x31, 0x63, 0x33, 0x39, 0x33, 0x34, 0x35, 0x63, 0x35, 0x66, 0x65, 0x38, 0x61, 0x66, 0x32, 0x65, 0x33, 0x62, 0x38, 0x62, 0x31, 0x37, 0x65, 0x61, 0x30, 0x35, 0x39, 0x39, 0x62, 0x63, 0x61, 0x64, 0x32, 0x33, 0x64, 0x31, 0x34, 0x38, 0x39, 0x64, 0x37, 0x66, 0x32, 0x30, 0x32, 0x61, 0x33, 0x34, 0x33, 0x65, 0x35, 0x30, 0x37, 0x38, 0x30, 0x64, 0x61, 0x65, 0x36, 0x65, 0x37, 0x61, 0x31, 0x63, 0x36, 0x35, 0x35, 0x33, 0x35, 0x37, 0x34, 0x34, 0x39, 0x31, 0x63, 0x39, 0x39, 0x64, 0x39, 0x36, 0x63, 0x37, 0x63, 0x65, 0x30, 0x66, 0x65, 0x31, 0x62, 0x66, 0x32, 0x38, 0x61, 0x66, 0x38, 0x38, 0x31, 0x38, 0x39, 0x33, 0x61, 0x64, 0x65, 0x30, 0x34, 0x34, 0x30, 0x37, 0x31, 0x62, 0x66, 0x61, 0x63, 0x31, 0x65, 0x63, 0x36, 0x65, 0x39, 0x63, 0x33, 0x33, 0x38, 0x63, 0x31, 0x61, 0x31, 0x61, 0x61, 0x63, 0x62, 0x36, 0x65, 0x30, 0x38, 0x39, 0x35, 0x30, 0x30, 0x65, 0x65, 0x35, 0x34, 0x31, 0x66, 0x33, 0x31, 0x64, 0x39, 0x38, 0x34, 0x61, 0x64, 0x30, 0x64, 0x66, 0x38, 0x62, 0x33, 0x38, 0x38, 0x63, 0x36, 0x66, 0x33, 0x31, 0x62, 0x39, 0x33, 0x35, 0x30, 0x34, 0x33, 0x65, 0x37, 0x31, 0x35, 0x62, 0x30, 0x34, 0x35, 0x34, 0x62, 0x36, 0x33, 0x64, 0x33, 0x66, 0x62, 0x34, 0x37, 0x32, 0x65, 0x62, 0x39, 0x66, 0x66, 0x66, 0x30, 0x38, 0x33, 0x66, 0x37, 0x34, 0x39, 0x64, 0x38, 0x36, 0x36, 0x63, 0x64, 0x35, 0x31, 0x36, 0x33, 0x65, 0x38, 0x62, 0x35, 0x63, 0x38, 0x39, 0x35, 0x63, 0x61, 0x62, 0x63, 0x30, 0x64, 0x33, 0x33, 0x64, 0x61, 0x32, 0x63, 0x64, 0x62, 0x66, 0x37, 0x32, 0x30, 0x64, 0x64, 0x37, 0x38, 0x36, 0x31, 0x36, 0x66, 0x61, 0x62, 0x62, 0x64, 0x30, 0x37, 0x32, 0x66, 0x34, 0x62, 0x61, 0x35, 0x33, 0x62, 0x39, 0x65, 0x33, 0x65, 0x36, 0x34, 0x65, 0x34, 0x33, 0x65, 0x66, 0x63, 0x35, 0x39, 0x32, 0x35, 0x35, 0x38, 0x61, 0x66, 0x37, 0x39, 0x39, 0x38, 0x38, 0x37, 0x31, 0x35, 0x36, 0x39, 0x61, 0x32, 0x32, 0x30, 0x65, 0x62, 0x39, 0x30, 0x61, 0x33, 0x35, 0x36, 0x64, 0x61, 0x63, 0x31, 0x35, 0x35, 0x61, 0x36, 0x35, 0x35, 0x39, 0x65, 0x64, 0x32, 0x30, 0x34, 0x35, 0x38, 0x64, 0x32, 0x61, 0x65, 0x39, 0x38, 0x31, 0x35, 0x38, 0x36, 0x31, 0x63, 0x35, 0x32, 0x37, 0x38, 0x30, 0x38, 0x35, 0x39, 0x62, 0x37, 0x65, 0x39, 0x38, 0x34, 0x66, 0x39, 0x63, 0x33, 0x64, 0x30, 0x64, 0x62, 0x66, 0x65, 0x36, 0x66, 0x32, 0x66, 0x32, 0x66, 0x37, 0x61, 0x33, 0x63, 0x39, 0x64, 0x31, 0x65, 0x61, 0x37, 0x38, 0x64, 0x32, 0x36, 0x38, 0x30, 0x34, 0x37, 0x32, 0x39, 0x32, 0x64, 0x39, 0x37, 0x38, 0x34, 0x32, 0x35, 0x32, 0x31, 0x39, 0x32, 0x37, 0x61, 0x65, 0x63, 0x30, 0x62, 0x61, 0x34, 0x39, 0x65, 0x36, 0x39, 0x63, 0x66, 0x35, 0x34, 0x35, 0x37, 0x33, 0x64, 0x35, 0x31, 0x63, 0x64, 0x39, 0x66, 0x39, 0x66, 0x66, 0x35, 0x39, 0x38, 0x38, 0x33, 0x36, 0x38, 0x35, 0x66, 0x65, 0x61, 0x34, 0x63, 0x34, 0x30, 0x34, 0x35, 0x39, 0x33, 0x33, 0x36, 0x61, 0x62, 0x39, 0x35, 0x30, 0x32, 0x32, 0x35, 0x66, 0x64, 0x37, 0x63, 0x61, 0x61, 0x62, 0x65, 0x62, 0x34, 0x65, 0x34, 0x34, 0x32, 0x62, 0x65, 0x32, 0x38, 0x38, 0x31, 0x32, 0x32, 0x64, 0x65, 0x33, 0x33, 0x64, 0x35, 0x30, 0x38, 0x34, 0x36, 0x64, 0x35, 0x66, 0x62, 0x35, 0x37, 0x62, 0x36, 0x39, 0x37, 0x65, 0x34, 0x61, 0x33, 0x35, 0x35, 0x36, 0x33, 0x66, 0x36, 0x62, 0x33, 0x63, 0x32, 0x30, 0x63, 0x39, 0x36, 0x31, 0x37, 0x36, 0x38, 0x38, 0x38, 0x30, 0x32, 0x36, 0x38, 0x37, 0x65, 0x35, 0x30, 0x38, 0x64, 0x61, 0x36, 0x65, 0x31, 0x34, 0x33, 0x66, 0x65, 0x66, 0x38, 0x37, 0x36, 0x33, 0x66, 0x38, 0x63, 0x38, 0x32, 0x65, 0x66, 0x33, 0x33, 0x61, 0x31, 0x31, 0x30, 0x36, 0x61, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x64, 0x36, 0x30, 0x39, 0x65, 0x36, 0x62, 0x32, 0x37, 0x30, 0x31, 0x61, 0x61, 0x39, 0x63, 0x65, 0x33, 0x39, 0x33, 0x66, 0x64, 0x65, 0x38, 0x34, 0x37, 0x34, 0x32, 0x62, 0x65, 0x66, 0x63, 0x30, 0x64, 0x31, 0x38, 0x66, 0x39, 0x31, 0x62, 0x32, 0x35, 0x65, 0x32, 0x63, 0x36, 0x37, 0x62, 0x62, 0x33, 0x36, 0x33, 0x34, 0x65, 0x38, 0x35, 0x30, 0x64, 0x61, 0x31, 0x30, 0x33, 0x66, 0x35, 0x34, 0x64, 0x37, 0x66, 0x65, 0x62, 0x39, 0x38, 0x37, 0x32, 0x30, 0x30, 0x39, 0x64, 0x64, 0x64, 0x32, 0x35, 0x30, 0x35, 0x30, 0x31, 0x65, 0x33, 0x38, 0x34, 0x31, 0x35, 0x39, 0x64, 0x64, 0x39, 0x63, 0x62, 0x37, 0x31, 0x65, 0x39, 0x34, 0x35, 0x61, 0x62, 0x33, 0x30, 0x62, 0x35, 0x65, 0x34, 0x35, 0x62, 0x39, 0x62, 0x38, 0x35, 0x31, 0x31, 0x66, 0x62, 0x36, 0x30, 0x33, 0x31, 0x30, 0x62, 0x65, 0x38, 0x34, 0x63, 0x36, 0x39, 0x62, 0x31, 0x31, 0x39, 0x37, 0x32, 0x61, 0x64, 0x63, 0x64, 0x33, 0x32, 0x64, 0x32, 0x31, 0x37, 0x39, 0x38, 0x30, 0x39, 0x62, 0x65, 0x33, 0x66, 0x64, 0x65, 0x35, 0x38, 0x66, 0x64, 0x66, 0x31, 0x37, 0x39, 0x39, 0x30, 0x39, 0x37, 0x62, 0x34, 0x38, 0x33, 0x65, 0x33, 0x34, 0x38, 0x34, 0x35, 0x35, 0x63, 0x31, 0x61, 0x61, 0x30, 0x64, 0x64, 0x63, 0x36, 0x38, 0x61, 0x31, 0x66, 0x31, 0x38, 0x64, 0x63, 0x32, 0x39, 0x32, 0x36, 0x65, 0x35, 0x66, 0x39, 0x34, 0x64, 0x33, 0x31, 0x38, 0x61, 0x64, 0x66, 0x62, 0x64, 0x65, 0x31, 0x38, 0x31, 0x32, 0x30, 0x30, 0x34, 0x32, 0x33, 0x66, 0x35, 0x64, 0x33, 0x33, 0x66, 0x61, 0x39, 0x33, 0x31, 0x35, 0x64, 0x62, 0x63, 0x30, 0x30, 0x32, 0x61, 0x36, 0x34, 0x33, 0x37, 0x39, 0x30, 0x33, 0x61, 0x30, 0x37, 0x66, 0x35, 0x65, 0x65, 0x37, 0x37, 0x65, 0x32, 0x64, 0x65, 0x35, 0x31, 0x65, 0x31, 0x38, 0x35, 0x30, 0x32, 0x61, 0x34, 0x36, 0x64, 0x62, 0x39, 0x66, 0x35, 0x62, 0x31, 0x35, 0x64, 0x30, 0x38, 0x38, 0x30, 0x63, 0x62, 0x38, 0x66, 0x66, 0x35, 0x39, 0x31, 0x39, 0x62, 0x65, 0x64, 0x64, 0x66, 0x36, 0x63, 0x34, 0x38, 0x32, 0x30, 0x32, 0x33, 0x37, 0x30, 0x30, 0x31, 0x66, 0x39, 0x34, 0x34, 0x64, 0x36, 0x66, 0x66, 0x61, 0x37, 0x32, 0x63, 0x39, 0x62, 0x37, 0x32, 0x63, 0x65, 0x30, 0x66, 0x35, 0x30, 0x31, 0x38, 0x36, 0x63, 0x64, 0x39, 0x31, 0x35, 0x36, 0x30, 0x65, 0x36, 0x31, 0x39, 0x37, 0x39, 0x35, 0x34, 0x38, 0x64, 0x65, 0x66, 0x33, 0x38, 0x33, 0x39, 0x36, 0x66, 0x31, 0x66, 0x63, 0x33, 0x64, 0x33, 0x65, 0x38, 0x33, 0x64, 0x36, 0x39, 0x64, 0x63, 0x63, 0x62, 0x61, 0x34, 0x65, 0x39, 0x66, 0x39, 0x37, 0x66, 0x65, 0x37, 0x31, 0x30, 0x37, 0x32, 0x32, 0x34, 0x35, 0x62, 0x33, 0x30, 0x39, 0x64, 0x32, 0x62, 0x32, 0x64, 0x31, 0x66, 0x31, 0x32, 0x64, 0x63, 0x33, 0x35, 0x62, 0x31, 0x63, 0x33, 0x31, 0x37, 0x63, 0x36, 0x31, 0x66, 0x31, 0x34, 0x66, 0x38, 0x66, 0x63, 0x61, 0x32, 0x37, 0x66, 0x35, 0x62, 0x32, 0x33, 0x66, 0x31, 0x34, 0x32, 0x61, 0x37, 0x37, 0x64, 0x38, 0x34, 0x37, 0x64, 0x62, 0x62, 0x64, 0x39, 0x65, 0x64, 0x33, 0x62, 0x37, 0x65, 0x31, 0x36, 0x65, 0x33, 0x30, 0x36, 0x31, 0x33, 0x35, 0x38, 0x66, 0x62, 0x66, 0x38, 0x39, 0x32, 0x34, 0x61, 0x61, 0x64, 0x36, 0x32, 0x30, 0x38, 0x38, 0x63, 0x64, 0x61, 0x63, 0x61, 0x39, 0x32, 0x34, 0x65, 0x35, 0x34, 0x31, 0x63, 0x32, 0x32, 0x62, 0x65, 0x37, 0x66, 0x38, 0x62, 0x33, 0x31, 0x35, 0x64, 0x63, 0x63, 0x61, 0x33, 0x33, 0x66, 0x65, 0x38, 0x39, 0x62, 0x37, 0x32, 0x30, 0x64, 0x39, 0x36, 0x62, 0x66, 0x64, 0x34, 0x61, 0x36, 0x35, 0x64, 0x66, 0x35, 0x39, 0x39, 0x63, 0x31, 0x65, 0x38, 0x32, 0x34, 0x33, 0x36, 0x32, 0x36, 0x35, 0x36, 0x36, 0x33, 0x64, 0x62, 0x36, 0x36, 0x31, 0x33, 0x65, 0x36, 0x61, 0x33, 0x39, 0x38, 0x30, 0x34, 0x31, 0x37, 0x39, 0x35, 0x31, 0x35, 0x34, 0x37, 0x31, 0x65, 0x35, 0x66, 0x31, 0x34, 0x35, 0x39, 0x30, 0x39, 0x35, 0x37, 0x33, 0x66, 0x39, 0x30, 0x34, 0x63, 0x37, 0x34, 0x37, 0x63, 0x34, 0x32, 0x33, 0x65, 0x30, 0x63, 0x31, 0x31, 0x36, 0x66, 0x66, 0x31, 0x61, 0x30, 0x64, 0x31, 0x61, 0x34, 0x62, 0x37, 0x35, 0x62, 0x64, 0x64, 0x63, 0x63, 0x61, 0x39, 0x32, 0x38, 0x32, 0x64, 0x32, 0x34, 0x35, 0x64, 0x32, 0x32, 0x30, 0x39, 0x35, 0x62, 0x61, 0x62, 0x65, 0x30, 0x30, 0x34, 0x64, 0x66, 0x66, 0x65, 0x36, 0x66, 0x35, 0x62, 0x62, 0x30, 0x35, 0x34, 0x63, 0x39, 0x37, 0x32, 0x62, 0x61, 0x32, 0x61, 0x38, 0x36, 0x31, 0x61, 0x36, 0x34, 0x37, 0x30, 0x32, 0x39, 0x38, 0x63, 0x32, 0x31, 0x64, 0x38, 0x62, 0x30, 0x38, 0x61, 0x35, 0x37, 0x31, 0x61, 0x61, 0x37, 0x65, 0x32, 0x66, 0x30, 0x66, 0x61, 0x66, 0x61, 0x62, 0x65, 0x38, 0x39, 0x64, 0x64, 0x32, 0x39, 0x34, 0x39, 0x39, 0x66, 0x31, 0x62, 0x37, 0x32, 0x62, 0x35, 0x35, 0x66, 0x37, 0x65, 0x31, 0x62, 0x37, 0x66, 0x62, 0x63, 0x33, 0x33, 0x63, 0x64, 0x31, 0x62, 0x63, 0x38, 0x62, 0x38, 0x34, 0x63, 0x35, 0x36, 0x37, 0x65, 0x64, 0x36, 0x36, 0x38, 0x63, 0x33, 0x31, 0x34, 0x63, 0x39, 0x61, 0x37, 0x63, 0x30, 0x38, 0x31, 0x31, 0x61, 0x36, 0x36, 0x33, 0x33, 0x61, 0x32, 0x66, 0x66, 0x66, 0x39, 0x39, 0x39, 0x66, 0x34, 0x35, 0x38, 0x37, 0x32, 0x30, 0x36, 0x66, 0x35, 0x34, 0x32, 0x65, 0x63, 0x35, 0x62, 0x66, 0x38, 0x66, 0x32, 0x65, 0x34, 0x37, 0x65, 0x32, 0x34, 0x31, 0x33, 0x65, 0x36, 0x38, 0x38, 0x37, 0x66, 0x32, 0x63, 0x36, 0x64, 0x36, 0x33, 0x31, 0x30, 0x36, 0x39, 0x39, 0x31, 0x31, 0x32, 0x66, 0x66, 0x35, 0x31, 0x62, 0x65, 0x65, 0x63, 0x39, 0x66, 0x63, 0x64, 0x38, 0x61, 0x37, 0x30, 0x39, 0x38, 0x61, 0x37, 0x37, 0x32, 0x66, 0x36, 0x32, 0x37, 0x62, 0x31, 0x65, 0x30, 0x36, 0x62, 0x34, 0x38, 0x30, 0x66, 0x38, 0x33, 0x63, 0x66, 0x65, 0x64, 0x35, 0x32, 0x65, 0x30, 0x35, 0x33, 0x31, 0x35, 0x62, 0x34, 0x33, 0x39, 0x32, 0x35, 0x64, 0x61, 0x38, 0x36, 0x38, 0x34, 0x30, 0x38, 0x35, 0x64, 0x34, 0x30, 0x39, 0x66, 0x31, 0x37, 0x39, 0x64, 0x66, 0x61, 0x66, 0x31, 0x33, 0x30, 0x35, 0x39, 0x33, 0x38, 0x37, 0x32, 0x62, 0x36, 0x61, 0x35, 0x32, 0x62, 0x62, 0x31, 0x39, 0x35, 0x39, 0x32, 0x31, 0x37, 0x32, 0x30, 0x66, 0x37, 0x31, 0x66, 0x38, 0x31, 0x34, 0x31, 0x61, 0x32, 0x37, 0x36, 0x62, 0x33, 0x36, 0x61, 0x65, 0x65, 0x33, 0x62, 0x63, 0x61, 0x62, 0x38, 0x65, 0x62, 0x37, 0x39, 0x32, 0x36, 0x36, 0x30, 0x31, 0x61, 0x38, 0x38, 0x35, 0x37, 0x65, 0x37, 0x34, 0x64, 0x31, 0x62, 0x66, 0x32, 0x37, 0x32, 0x30, 0x35, 0x32, 0x36, 0x37, 0x31, 0x66, 0x36, 0x37, 0x66, 0x62, 0x35, 0x62, 0x63, 0x37, 0x31, 0x33, 0x64, 0x36, 0x64, 0x31, 0x61, 0x63, 0x32, 0x63, 0x66, 0x33, 0x64, 0x39, 0x31, 0x34, 0x38, 0x66, 0x38, 0x64, 0x62, 0x37, 0x62, 0x32, 0x36, 0x36, 0x34, 0x36, 0x34, 0x62, 0x64, 0x35, 0x33, 0x35, 0x32, 0x39, 0x65, 0x37, 0x32, 0x64, 0x30, 0x34, 0x39, 0x63, 0x61, 0x66, 0x66, 0x34, 0x36, 0x39, 0x32, 0x61, 0x63, 0x65, 0x66, 0x39, 0x63, 0x38, 0x33, 0x32, 0x35, 0x38, 0x32, 0x33, 0x39, 0x32, 0x64, 0x34, 0x38, 0x36, 0x63, 0x35, 0x36, 0x34, 0x38, 0x63, 0x35, 0x62, 0x30, 0x33, 0x66, 0x31, 0x36, 0x32, 0x65, 0x38, 0x64, 0x33, 0x37, 0x64, 0x63, 0x37, 0x36, 0x65, 0x36, 0x61, 0x30, 0x37, 0x31, 0x36, 0x63, 0x33, 0x33, 0x63, 0x66, 0x38, 0x33, 0x31, 0x34, 0x33, 0x33, 0x37, 0x32, 0x64, 0x31, 0x61, 0x65, 0x37, 0x63, 0x30, 0x61, 0x34, 0x64, 0x31, 0x66, 0x35, 0x63, 0x32, 0x62, 0x36, 0x32, 0x33, 0x36, 0x65, 0x64, 0x64, 0x65, 0x63, 0x64, 0x30, 0x35, 0x34, 0x31, 0x31, 0x66, 0x39, 0x30, 0x36, 0x36, 0x65, 0x38, 0x39, 0x31, 0x33, 0x32, 0x62, 0x62, 0x31, 0x31, 0x62, 0x66, 0x65, 0x32, 0x32, 0x66, 0x30, 0x39, 0x34, 0x38, 0x66, 0x62, 0x65, 0x33, 0x32, 0x61, 0x37, 0x32, 0x63, 0x62, 0x38, 0x37, 0x64, 0x38, 0x32, 0x61, 0x35, 0x31, 0x31, 0x36, 0x34, 0x64, 0x31, 0x39, 0x64, 0x61, 0x61, 0x31, 0x38, 0x63, 0x37, 0x66, 0x36, 0x34, 0x38, 0x65, 0x62, 0x38, 0x33, 0x63, 0x39, 0x37, 0x66, 0x35, 0x64, 0x35, 0x39, 0x37, 0x35, 0x62, 0x31, 0x63, 0x64, 0x66, 0x37, 0x64, 0x31, 0x36, 0x64, 0x65, 0x39, 0x32, 0x33, 0x33, 0x62, 0x36, 0x30, 0x38, 0x30, 0x63, 0x37, 0x32, 0x36, 0x39, 0x35, 0x33, 0x37, 0x39, 0x31, 0x35, 0x37, 0x66, 0x32, 0x33, 0x64, 0x37, 0x61, 0x35, 0x35, 0x62, 0x34, 0x38, 0x39, 0x66, 0x63, 0x61, 0x64, 0x32, 0x33, 0x61, 0x31, 0x63, 0x31, 0x35, 0x31, 0x38, 0x64, 0x32, 0x65, 0x36, 0x33, 0x35, 0x37, 0x61, 0x61, 0x36, 0x37, 0x32, 0x62, 0x65, 0x34, 0x38, 0x37, 0x37, 0x63, 0x31, 0x33, 0x66, 0x62, 0x32, 0x33, 0x62, 0x39, 0x30, 0x30, 0x62, 0x35, 0x33, 0x33, 0x32, 0x37, 0x34, 0x37, 0x34, 0x62, 0x65, 0x36, 0x64, 0x32, 0x61, 0x36, 0x37, 0x37, 0x66, 0x38, 0x64, 0x31, 0x34, 0x61, 0x34, 0x62, 0x61, 0x61, 0x63, 0x36, 0x63, 0x34, 0x37, 0x65, 0x65, 0x63, 0x64, 0x39, 0x63, 0x37, 0x33, 0x37, 0x33, 0x63, 0x66, 0x66, 0x63, 0x63, 0x31, 0x33, 0x32, 0x33, 0x35, 0x34, 0x37, 0x61, 0x31, 0x61, 0x37, 0x39, 0x39, 0x33, 0x61, 0x37, 0x32, 0x63, 0x65, 0x31, 0x30, 0x35, 0x64, 0x65, 0x62, 0x62, 0x30, 0x62, 0x61, 0x39, 0x37, 0x36, 0x31, 0x66, 0x66, 0x38, 0x65, 0x36, 0x38, 0x33, 0x32, 0x39, 0x39, 0x36, 0x35, 0x64, 0x66, 0x32, 0x37, 0x34, 0x33, 0x36, 0x33, 0x35, 0x34, 0x37, 0x63, 0x63, 0x35, 0x61, 0x39, 0x38, 0x64, 0x31, 0x39, 0x37, 0x31, 0x62, 0x33, 0x38, 0x38, 0x39, 0x36, 0x61, 0x65, 0x34, 0x62, 0x37, 0x39, 0x37, 0x32, 0x36, 0x39, 0x66, 0x66, 0x61, 0x35, 0x39, 0x39, 0x38, 0x65, 0x66, 0x66, 0x35, 0x33, 0x63, 0x33, 0x35, 0x63, 0x62, 0x64, 0x61, 0x64, 0x33, 0x33, 0x37, 0x64, 0x64, 0x32, 0x39, 0x38, 0x64, 0x32, 0x63, 0x38, 0x36, 0x39, 0x37, 0x30, 0x39, 0x66, 0x35, 0x38, 0x35, 0x30, 0x37, 0x61, 0x34, 0x66, 0x66, 0x35, 0x63, 0x35, 0x33, 0x63, 0x34, 0x62, 0x34, 0x62, 0x31, 0x30, 0x66, 0x64, 0x36, 0x61, 0x37, 0x64, 0x62, 0x34, 0x39, 0x31, 0x61, 0x39, 0x39, 0x63, 0x61, 0x61, 0x61, 0x38, 0x66, 0x64, 0x32, 0x34, 0x38, 0x63, 0x66, 0x62, 0x39, 0x38, 0x30, 0x62, 0x37, 0x38, 0x36, 0x31, 0x64, 0x64, 0x64, 0x64, 0x36, 0x61, 0x64, 0x35, 0x62, 0x66, 0x66, 0x34, 0x39, 0x32, 0x65, 0x36, 0x39, 0x62, 0x32, 0x63, 0x36, 0x34, 0x63, 0x39, 0x31, 0x63, 0x62, 0x35, 0x35, 0x35, 0x63, 0x65, 0x37, 0x32, 0x35, 0x62, 0x66, 0x64, 0x61, 0x63, 0x30, 0x62, 0x31, 0x64, 0x66, 0x38, 0x31, 0x32, 0x61, 0x38, 0x33, 0x65, 0x65, 0x32, 0x34, 0x66, 0x38, 0x61, 0x62, 0x64, 0x61, 0x32, 0x30, 0x34, 0x33, 0x62, 0x63, 0x32, 0x39, 0x65, 0x37, 0x36, 0x37, 0x63, 0x62, 0x34, 0x39, 0x30, 0x33, 0x31, 0x62, 0x31, 0x61, 0x30, 0x66, 0x65, 0x38, 0x65, 0x63, 0x61, 0x66, 0x32, 0x35, 0x35, 0x39, 0x64, 0x37, 0x32, 0x37, 0x37, 0x35, 0x61, 0x33, 0x33, 0x35, 0x36, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x32, 0x32, 0x61, 0x65, 0x38, 0x36, 0x34, 0x62, 0x62, 0x31, 0x36, 0x64, 0x33, 0x31, 0x30, 0x65, 0x32, 0x39, 0x33, 0x61, 0x33, 0x61, 0x62, 0x35, 0x36, 0x61, 0x66, 0x35, 0x61, 0x38, 0x36, 0x65, 0x62, 0x33, 0x30, 0x36, 0x66, 0x66, 0x36, 0x62, 0x34, 0x35, 0x39, 0x64, 0x65, 0x36, 0x32, 0x62, 0x37, 0x32, 0x62, 0x64, 0x37, 0x35, 0x65, 0x65, 0x64, 0x35, 0x34, 0x36, 0x36, 0x36, 0x33, 0x65, 0x37, 0x31, 0x36, 0x33, 0x34, 0x36, 0x30, 0x32, 0x63, 0x62, 0x65, 0x62, 0x34, 0x33, 0x39, 0x33, 0x33, 0x36, 0x32, 0x30, 0x64, 0x65, 0x33, 0x33, 0x30, 0x66, 0x35, 0x66, 0x64, 0x64, 0x64, 0x63, 0x66, 0x37, 0x64, 0x32, 0x61, 0x35, 0x34, 0x64, 0x66, 0x31, 0x35, 0x61, 0x63, 0x64, 0x38, 0x39, 0x37, 0x32, 0x65, 0x34, 0x30, 0x62, 0x64, 0x65, 0x38, 0x65, 0x35, 0x33, 0x63, 0x35, 0x62, 0x61, 0x33, 0x66, 0x63, 0x63, 0x35, 0x34, 0x62, 0x64, 0x37, 0x30, 0x63, 0x35, 0x37, 0x33, 0x35, 0x64, 0x39, 0x65, 0x65, 0x34, 0x37, 0x39, 0x64, 0x63, 0x38, 0x30, 0x64, 0x61, 0x33, 0x36, 0x36, 0x64, 0x33, 0x38, 0x35, 0x38, 0x30, 0x64, 0x62, 0x31, 0x66, 0x62, 0x33, 0x65, 0x31, 0x61, 0x61, 0x30, 0x37, 0x32, 0x65, 0x32, 0x34, 0x30, 0x62, 0x66, 0x33, 0x34, 0x37, 0x35, 0x36, 0x36, 0x34, 0x61, 0x62, 0x34, 0x66, 0x63, 0x33, 0x31, 0x34, 0x30, 0x34, 0x66, 0x66, 0x37, 0x64, 0x32, 0x37, 0x39, 0x33, 0x37, 0x61, 0x35, 0x39, 0x61, 0x63, 0x34, 0x39, 0x61, 0x36, 0x32, 0x39, 0x30, 0x32, 0x38, 0x35, 0x33, 0x63, 0x63, 0x34, 0x63, 0x36, 0x30, 0x31, 0x33, 0x31, 0x61, 0x33, 0x38, 0x36, 0x63, 0x30, 0x36, 0x32, 0x65, 0x65, 0x36, 0x61, 0x35, 0x64, 0x65, 0x33, 0x32, 0x35, 0x65, 0x32, 0x64, 0x35, 0x61, 0x31, 0x66, 0x63, 0x34, 0x38, 0x61, 0x31, 0x35, 0x62, 0x64, 0x64, 0x63, 0x38, 0x61, 0x63, 0x65, 0x31, 0x62, 0x66, 0x35, 0x33, 0x33, 0x30, 0x36, 0x30, 0x61, 0x39, 0x61, 0x39, 0x34, 0x34, 0x37, 0x32, 0x39, 0x62, 0x33, 0x35, 0x38, 0x32, 0x62, 0x33, 0x38, 0x32, 0x65, 0x32, 0x63, 0x37, 0x32, 0x35, 0x34, 0x38, 0x38, 0x61, 0x35, 0x36, 0x30, 0x35, 0x63, 0x63, 0x65, 0x32, 0x37, 0x36, 0x37, 0x64, 0x64, 0x66, 0x33, 0x39, 0x32, 0x33, 0x37, 0x63, 0x38, 0x31, 0x33, 0x38, 0x36, 0x36, 0x66, 0x34, 0x61, 0x62, 0x30, 0x32, 0x30, 0x39, 0x63, 0x62, 0x65, 0x34, 0x66, 0x31, 0x33, 0x39, 0x38, 0x32, 0x64, 0x66, 0x33, 0x64, 0x66, 0x61, 0x36, 0x37, 0x64, 0x35, 0x35, 0x31, 0x32, 0x37, 0x32, 0x33, 0x36, 0x30, 0x66, 0x31, 0x64, 0x66, 0x30, 0x65, 0x32, 0x32, 0x37, 0x63, 0x33, 0x30, 0x63, 0x31, 0x39, 0x66, 0x64, 0x30, 0x32, 0x33, 0x32, 0x64, 0x36, 0x38, 0x35, 0x62, 0x31, 0x64, 0x33, 0x64, 0x66, 0x65, 0x32, 0x65, 0x62, 0x63, 0x62, 0x33, 0x33, 0x33, 0x31, 0x64, 0x31, 0x37, 0x33, 0x61, 0x31, 0x38, 0x65, 0x66, 0x33, 0x30, 0x31, 0x62, 0x38, 0x33, 0x63, 0x31, 0x30, 0x34, 0x65, 0x62, 0x34, 0x34, 0x64, 0x34, 0x66, 0x66, 0x31, 0x64, 0x33, 0x39, 0x65, 0x65, 0x35, 0x61, 0x34, 0x61, 0x64, 0x35, 0x38, 0x30, 0x36, 0x35, 0x32, 0x62, 0x37, 0x30, 0x30, 0x66, 0x65, 0x32, 0x34, 0x36, 0x30, 0x31, 0x35, 0x61, 0x31, 0x39, 0x32, 0x39, 0x66, 0x31, 0x63, 0x38, 0x66, 0x33, 0x61, 0x36, 0x32, 0x38, 0x34, 0x64, 0x39, 0x66, 0x39, 0x30, 0x35, 0x63, 0x38, 0x34, 0x63, 0x37, 0x32, 0x65, 0x30, 0x37, 0x36, 0x32, 0x65, 0x62, 0x38, 0x63, 0x36, 0x37, 0x31, 0x65, 0x62, 0x64, 0x35, 0x30, 0x62, 0x39, 0x31, 0x35, 0x39, 0x63, 0x36, 0x66, 0x31, 0x36, 0x34, 0x35, 0x33, 0x37, 0x37, 0x33, 0x66, 0x31, 0x31, 0x65, 0x63, 0x65, 0x64, 0x35, 0x38, 0x30, 0x30, 0x36, 0x63, 0x35, 0x38, 0x63, 0x31, 0x63, 0x36, 0x64, 0x34, 0x33, 0x37, 0x35, 0x63, 0x31, 0x38, 0x35, 0x62, 0x31, 0x39, 0x37, 0x33, 0x37, 0x32, 0x35, 0x65, 0x34, 0x63, 0x64, 0x37, 0x61, 0x38, 0x38, 0x30, 0x34, 0x64, 0x66, 0x31, 0x34, 0x38, 0x31, 0x61, 0x66, 0x39, 0x36, 0x30, 0x66, 0x35, 0x31, 0x33, 0x31, 0x38, 0x38, 0x61, 0x37, 0x61, 0x37, 0x34, 0x34, 0x64, 0x64, 0x66, 0x33, 0x36, 0x33, 0x62, 0x63, 0x31, 0x63, 0x36, 0x64, 0x32, 0x34, 0x63, 0x36, 0x35, 0x37, 0x34, 0x36, 0x63, 0x33, 0x35, 0x37, 0x32, 0x33, 0x32, 0x35, 0x62, 0x61, 0x35, 0x34, 0x39, 0x32, 0x64, 0x31, 0x39, 0x35, 0x35, 0x35, 0x32, 0x34, 0x63, 0x64, 0x32, 0x66, 0x37, 0x35, 0x62, 0x33, 0x62, 0x61, 0x61, 0x35, 0x35, 0x35, 0x37, 0x65, 0x31, 0x30, 0x63, 0x63, 0x31, 0x30, 0x38, 0x33, 0x39, 0x66, 0x30, 0x65, 0x36, 0x38, 0x30, 0x31, 0x37, 0x39, 0x63, 0x61, 0x35, 0x66, 0x66, 0x33, 0x65, 0x64, 0x63, 0x63, 0x39, 0x37, 0x32, 0x31, 0x65, 0x65, 0x63, 0x38, 0x33, 0x30, 0x62, 0x33, 0x34, 0x38, 0x36, 0x38, 0x31, 0x66, 0x37, 0x64, 0x37, 0x39, 0x62, 0x33, 0x37, 0x35, 0x66, 0x37, 0x63, 0x35, 0x63, 0x31, 0x30, 0x33, 0x65, 0x64, 0x62, 0x64, 0x31, 0x62, 0x32, 0x39, 0x39, 0x34, 0x31, 0x64, 0x37, 0x63, 0x32, 0x66, 0x39, 0x36, 0x39, 0x35, 0x38, 0x31, 0x63, 0x61, 0x64, 0x39, 0x66, 0x65, 0x35, 0x38, 0x30, 0x37, 0x32, 0x64, 0x65, 0x62, 0x30, 0x63, 0x36, 0x34, 0x39, 0x64, 0x32, 0x31, 0x37, 0x37, 0x61, 0x30, 0x39, 0x35, 0x34, 0x65, 0x37, 0x63, 0x36, 0x37, 0x37, 0x66, 0x34, 0x63, 0x39, 0x64, 0x66, 0x37, 0x33, 0x62, 0x38, 0x64, 0x64, 0x65, 0x66, 0x62, 0x30, 0x32, 0x65, 0x39, 0x35, 0x33, 0x31, 0x33, 0x64, 0x35, 0x61, 0x30, 0x64, 0x62, 0x61, 0x65, 0x65, 0x61, 0x31, 0x32, 0x64, 0x64, 0x38, 0x32, 0x32, 0x37, 0x66, 0x39, 0x62, 0x38, 0x34, 0x36, 0x32, 0x36, 0x34, 0x33, 0x64, 0x30, 0x64, 0x66, 0x33, 0x61, 0x34, 0x62, 0x38, 0x37, 0x38, 0x32, 0x62, 0x66, 0x33, 0x35, 0x65, 0x65, 0x36, 0x66, 0x33, 0x61, 0x64, 0x35, 0x36, 0x32, 0x39, 0x32, 0x64, 0x32, 0x34, 0x35, 0x63, 0x36, 0x66, 0x33, 0x39, 0x62, 0x31, 0x36, 0x63, 0x30, 0x31, 0x32, 0x38, 0x36, 0x33, 0x36, 0x34, 0x38, 0x35, 0x30, 0x30, 0x36, 0x37, 0x39, 0x37, 0x61, 0x39, 0x36, 0x66, 0x34, 0x37, 0x38, 0x30, 0x32, 0x65, 0x63, 0x65, 0x30, 0x36, 0x37, 0x30, 0x30, 0x65, 0x66, 0x65, 0x64, 0x31, 0x35, 0x38, 0x63, 0x34, 0x34, 0x34, 0x36, 0x39, 0x36, 0x65, 0x32, 0x66, 0x65, 0x37, 0x38, 0x31, 0x65, 0x64, 0x65, 0x32, 0x33, 0x62, 0x32, 0x34, 0x66, 0x34, 0x31, 0x32, 0x63, 0x35, 0x63, 0x36, 0x36, 0x62, 0x64, 0x62, 0x30, 0x35, 0x63, 0x39, 0x65, 0x30, 0x66, 0x32, 0x31, 0x35, 0x37, 0x63, 0x62, 0x63, 0x63, 0x36, 0x39, 0x31, 0x39, 0x34, 0x36, 0x39, 0x33, 0x35, 0x66, 0x63, 0x32, 0x32, 0x30, 0x61, 0x30, 0x39, 0x66, 0x38, 0x38, 0x31, 0x32, 0x65, 0x30, 0x34, 0x30, 0x63, 0x38, 0x62, 0x39, 0x31, 0x39, 0x39, 0x66, 0x30, 0x37, 0x34, 0x34, 0x63, 0x38, 0x36, 0x33, 0x31, 0x63, 0x30, 0x30, 0x37, 0x38, 0x39, 0x37, 0x32, 0x34, 0x37, 0x39, 0x65, 0x32, 0x65, 0x36, 0x34, 0x66, 0x33, 0x38, 0x31, 0x30, 0x62, 0x36, 0x66, 0x35, 0x64, 0x32, 0x33, 0x64, 0x39, 0x34, 0x39, 0x61, 0x30, 0x36, 0x38, 0x66, 0x38, 0x34, 0x37, 0x31, 0x33, 0x33, 0x66, 0x64, 0x63, 0x36, 0x63, 0x30, 0x61, 0x36, 0x37, 0x63, 0x37, 0x66, 0x66, 0x65, 0x37, 0x63, 0x63, 0x38, 0x62, 0x65, 0x65, 0x64, 0x64, 0x35, 0x33, 0x66, 0x64, 0x34, 0x33, 0x61, 0x61, 0x64, 0x35, 0x65, 0x38, 0x32, 0x38, 0x36, 0x39, 0x65, 0x34, 0x61, 0x34, 0x32, 0x31, 0x37, 0x39, 0x30, 0x65, 0x36, 0x62, 0x65, 0x32, 0x66, 0x31, 0x30, 0x37, 0x39, 0x34, 0x36, 0x62, 0x36, 0x35, 0x37, 0x34, 0x36, 0x36, 0x39, 0x36, 0x63, 0x34, 0x62, 0x61, 0x34, 0x66, 0x32, 0x62, 0x38, 0x39, 0x36, 0x31, 0x62, 0x30, 0x63, 0x65, 0x61, 0x31, 0x61, 0x65, 0x32, 0x66, 0x36, 0x32, 0x36, 0x34, 0x30, 0x35, 0x32, 0x63, 0x63, 0x30, 0x65, 0x31, 0x33, 0x33, 0x31, 0x31, 0x36, 0x34, 0x36, 0x37, 0x30, 0x39, 0x61, 0x35, 0x64, 0x62, 0x39, 0x61, 0x38, 0x38, 0x65, 0x36, 0x62, 0x34, 0x34, 0x66, 0x63, 0x63, 0x38, 0x37, 0x62, 0x64, 0x32, 0x64, 0x61, 0x32, 0x66, 0x61, 0x32, 0x66, 0x39, 0x64, 0x65, 0x38, 0x33, 0x37, 0x38, 0x39, 0x61, 0x63, 0x35, 0x31, 0x31, 0x63, 0x37, 0x32, 0x33, 0x35, 0x63, 0x38, 0x38, 0x66, 0x36, 0x64, 0x36, 0x38, 0x63, 0x35, 0x62, 0x34, 0x63, 0x64, 0x37, 0x64, 0x30, 0x33, 0x65, 0x37, 0x65, 0x64, 0x62, 0x66, 0x61, 0x65, 0x38, 0x37, 0x39, 0x30, 0x33, 0x31, 0x61, 0x30, 0x35, 0x34, 0x31, 0x38, 0x63, 0x61, 0x62, 0x62, 0x34, 0x30, 0x64, 0x65, 0x35, 0x34, 0x31, 0x35, 0x64, 0x61, 0x39, 0x39, 0x63, 0x61, 0x31, 0x34, 0x35, 0x39, 0x36, 0x34, 0x37, 0x35, 0x33, 0x63, 0x34, 0x65, 0x38, 0x62, 0x38, 0x66, 0x35, 0x32, 0x63, 0x38, 0x64, 0x65, 0x63, 0x36, 0x31, 0x66, 0x65, 0x62, 0x30, 0x32, 0x66, 0x37, 0x62, 0x62, 0x39, 0x36, 0x36, 0x33, 0x66, 0x33, 0x36, 0x64, 0x37, 0x65, 0x62, 0x61, 0x38, 0x64, 0x66, 0x65, 0x34, 0x62, 0x36, 0x38, 0x35, 0x37, 0x38, 0x39, 0x63, 0x33, 0x36, 0x39, 0x64, 0x62, 0x37, 0x38, 0x36, 0x62, 0x37, 0x32, 0x36, 0x66, 0x61, 0x38, 0x35, 0x39, 0x61, 0x63, 0x31, 0x30, 0x32, 0x33, 0x37, 0x38, 0x30, 0x63, 0x30, 0x64, 0x38, 0x61, 0x65, 0x32, 0x35, 0x32, 0x37, 0x34, 0x30, 0x32, 0x64, 0x39, 0x32, 0x61, 0x39, 0x62, 0x32, 0x62, 0x64, 0x33, 0x64, 0x35, 0x64, 0x65, 0x38, 0x64, 0x37, 0x61, 0x63, 0x37, 0x62, 0x61, 0x34, 0x61, 0x66, 0x35, 0x34, 0x38, 0x64, 0x33, 0x63, 0x37, 0x34, 0x39, 0x37, 0x32, 0x30, 0x36, 0x30, 0x35, 0x34, 0x65, 0x38, 0x34, 0x63, 0x38, 0x32, 0x33, 0x31, 0x39, 0x37, 0x36, 0x62, 0x31, 0x30, 0x32, 0x63, 0x39, 0x65, 0x65, 0x39, 0x35, 0x31, 0x33, 0x63, 0x38, 0x35, 0x33, 0x34, 0x63, 0x33, 0x34, 0x36, 0x66, 0x66, 0x66, 0x65, 0x62, 0x30, 0x34, 0x62, 0x33, 0x61, 0x32, 0x32, 0x32, 0x36, 0x35, 0x62, 0x31, 0x32, 0x34, 0x64, 0x36, 0x34, 0x38, 0x32, 0x66, 0x35, 0x36, 0x64, 0x65, 0x61, 0x36, 0x33, 0x66, 0x31, 0x36, 0x35, 0x33, 0x30, 0x31, 0x38, 0x31, 0x36, 0x63, 0x37, 0x31, 0x37, 0x39, 0x37, 0x31, 0x64, 0x63, 0x38, 0x31, 0x30, 0x65, 0x66, 0x35, 0x30, 0x30, 0x37, 0x61, 0x32, 0x35, 0x65, 0x63, 0x34, 0x31, 0x64, 0x66, 0x30, 0x33, 0x34, 0x61, 0x36, 0x66, 0x64, 0x66, 0x31, 0x65, 0x35, 0x39, 0x37, 0x65, 0x66, 0x32, 0x34, 0x30, 0x63, 0x61, 0x31, 0x33, 0x62, 0x65, 0x33, 0x37, 0x63, 0x38, 0x30, 0x37, 0x61, 0x63, 0x32, 0x62, 0x35, 0x64, 0x34, 0x38, 0x64, 0x33, 0x32, 0x63, 0x61, 0x61, 0x66, 0x64, 0x63, 0x33, 0x37, 0x30, 0x31, 0x62, 0x38, 0x61, 0x39, 0x64, 0x66, 0x31, 0x38, 0x66, 0x61, 0x65, 0x32, 0x65, 0x35, 0x31, 0x38, 0x63, 0x66, 0x35, 0x31, 0x64, 0x62, 0x32, 0x33, 0x33, 0x63, 0x32, 0x37, 0x64, 0x65, 0x61, 0x33, 0x37, 0x37, 0x32, 0x32, 0x38, 0x31, 0x35, 0x36, 0x63, 0x61, 0x33, 0x38, 0x65, 0x66, 0x32, 0x36, 0x31, 0x64, 0x36, 0x35, 0x39, 0x34, 0x62, 0x37, 0x61, 0x37, 0x34, 0x64, 0x36, 0x39, 0x39, 0x30, 0x39, 0x65, 0x64, 0x64, 0x63, 0x63, 0x64, 0x32, 0x62, 0x34, 0x64, 0x62, 0x61, 0x65, 0x38, 0x61, 0x30, 0x35, 0x64, 0x35, 0x63, 0x34, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x36, 0x33, 0x65, 0x38, 0x32, 0x31, 0x39, 0x35, 0x64, 0x38, 0x35, 0x62, 0x39, 0x62, 0x64, 0x62, 0x33, 0x32, 0x33, 0x36, 0x66, 0x65, 0x38, 0x36, 0x64, 0x62, 0x31, 0x30, 0x32, 0x32, 0x37, 0x66, 0x38, 0x34, 0x32, 0x65, 0x33, 0x35, 0x35, 0x32, 0x32, 0x66, 0x35, 0x65, 0x61, 0x32, 0x32, 0x62, 0x63, 0x61, 0x32, 0x32, 0x36, 0x39, 0x64, 0x63, 0x62, 0x34, 0x63, 0x63, 0x61, 0x39, 0x39, 0x33, 0x32, 0x61, 0x64, 0x31, 0x66, 0x37, 0x32, 0x30, 0x38, 0x35, 0x63, 0x31, 0x62, 0x66, 0x39, 0x32, 0x66, 0x64, 0x39, 0x30, 0x63, 0x63, 0x36, 0x66, 0x39, 0x32, 0x37, 0x32, 0x30, 0x39, 0x39, 0x65, 0x34, 0x35, 0x61, 0x64, 0x61, 0x66, 0x38, 0x36, 0x39, 0x34, 0x39, 0x38, 0x36, 0x66, 0x32, 0x39, 0x65, 0x64, 0x32, 0x31, 0x37, 0x61, 0x31, 0x37, 0x63, 0x61, 0x30, 0x33, 0x31, 0x66, 0x37, 0x38, 0x61, 0x34, 0x39, 0x64, 0x32, 0x37, 0x32, 0x35, 0x39, 0x31, 0x31, 0x64, 0x38, 0x63, 0x32, 0x61, 0x37, 0x63, 0x36, 0x32, 0x64, 0x32, 0x34, 0x34, 0x38, 0x65, 0x66, 0x32, 0x32, 0x63, 0x63, 0x64, 0x38, 0x33, 0x36, 0x38, 0x62, 0x35, 0x33, 0x63, 0x62, 0x39, 0x36, 0x65, 0x37, 0x66, 0x65, 0x62, 0x66, 0x61, 0x66, 0x30, 0x38, 0x63, 0x65, 0x66, 0x39, 0x34, 0x65, 0x66, 0x30, 0x36, 0x64, 0x38, 0x31, 0x37, 0x36, 0x66, 0x35, 0x37, 0x32, 0x35, 0x38, 0x62, 0x31, 0x39, 0x62, 0x64, 0x62, 0x32, 0x64, 0x64, 0x61, 0x63, 0x35, 0x64, 0x34, 0x37, 0x62, 0x63, 0x33, 0x37, 0x66, 0x64, 0x65, 0x35, 0x66, 0x66, 0x39, 0x35, 0x35, 0x31, 0x39, 0x64, 0x38, 0x31, 0x32, 0x38, 0x61, 0x36, 0x30, 0x35, 0x38, 0x33, 0x34, 0x63, 0x65, 0x61, 0x38, 0x30, 0x33, 0x35, 0x66, 0x37, 0x66, 0x30, 0x63, 0x30, 0x31, 0x36, 0x34, 0x32, 0x35, 0x37, 0x32, 0x61, 0x30, 0x63, 0x34, 0x36, 0x30, 0x35, 0x31, 0x63, 0x36, 0x31, 0x38, 0x30, 0x65, 0x62, 0x63, 0x61, 0x31, 0x32, 0x36, 0x38, 0x37, 0x62, 0x64, 0x62, 0x66, 0x32, 0x34, 0x39, 0x38, 0x35, 0x30, 0x34, 0x39, 0x63, 0x31, 0x33, 0x64, 0x39, 0x64, 0x63, 0x62, 0x62, 0x34, 0x36, 0x31, 0x65, 0x37, 0x39, 0x35, 0x61, 0x30, 0x61, 0x63, 0x64, 0x39, 0x66, 0x36, 0x33, 0x35, 0x38, 0x35, 0x35, 0x63, 0x66, 0x38, 0x36, 0x63, 0x38, 0x36, 0x61, 0x35, 0x61, 0x38, 0x36, 0x65, 0x62, 0x30, 0x65, 0x35, 0x37, 0x30, 0x36, 0x33, 0x31, 0x31, 0x63, 0x33, 0x35, 0x30, 0x37, 0x39, 0x33, 0x38, 0x62, 0x38, 0x32, 0x39, 0x63, 0x61, 0x32, 0x65, 0x35, 0x32, 0x62, 0x36, 0x38, 0x33, 0x36, 0x32, 0x39, 0x34, 0x65, 0x62, 0x34, 0x33, 0x37, 0x37, 0x31, 0x34, 0x37, 0x39, 0x31, 0x32, 0x39, 0x65, 0x37, 0x32, 0x38, 0x32, 0x34, 0x30, 0x61, 0x64, 0x63, 0x30, 0x38, 0x62, 0x64, 0x30, 0x38, 0x30, 0x35, 0x33, 0x64, 0x32, 0x31, 0x38, 0x36, 0x61, 0x36, 0x66, 0x36, 0x38, 0x63, 0x31, 0x65, 0x61, 0x62, 0x37, 0x30, 0x65, 0x32, 0x66, 0x38, 0x30, 0x37, 0x30, 0x63, 0x64, 0x37, 0x37, 0x35, 0x38, 0x64, 0x38, 0x62, 0x65, 0x39, 0x31, 0x36, 0x34, 0x30, 0x32, 0x63, 0x61, 0x36, 0x32, 0x64, 0x66, 0x37, 0x32, 0x35, 0x35, 0x63, 0x65, 0x30, 0x39, 0x34, 0x32, 0x33, 0x65, 0x37, 0x65, 0x34, 0x34, 0x63, 0x32, 0x66, 0x31, 0x61, 0x36, 0x36, 0x37, 0x37, 0x33, 0x62, 0x39, 0x66, 0x62, 0x37, 0x34, 0x39, 0x65, 0x64, 0x66, 0x39, 0x66, 0x65, 0x61, 0x39, 0x36, 0x30, 0x65, 0x33, 0x35, 0x35, 0x65, 0x64, 0x63, 0x31, 0x65, 0x30, 0x66, 0x31, 0x38, 0x62, 0x66, 0x65, 0x32, 0x32, 0x65, 0x66, 0x31, 0x37, 0x32, 0x62, 0x66, 0x37, 0x61, 0x38, 0x63, 0x37, 0x64, 0x32, 0x63, 0x39, 0x66, 0x36, 0x31, 0x63, 0x61, 0x34, 0x61, 0x65, 0x34, 0x39, 0x30, 0x64, 0x30, 0x39, 0x36, 0x62, 0x37, 0x31, 0x36, 0x37, 0x61, 0x37, 0x65, 0x38, 0x30, 0x39, 0x34, 0x66, 0x36, 0x34, 0x66, 0x36, 0x62, 0x65, 0x39, 0x39, 0x39, 0x35, 0x65, 0x36, 0x31, 0x38, 0x66, 0x33, 0x31, 0x65, 0x34, 0x62, 0x66, 0x36, 0x66, 0x37, 0x32, 0x33, 0x31, 0x34, 0x62, 0x39, 0x65, 0x34, 0x35, 0x32, 0x32, 0x34, 0x34, 0x65, 0x38, 0x35, 0x35, 0x39, 0x35, 0x38, 0x39, 0x66, 0x39, 0x64, 0x34, 0x63, 0x65, 0x34, 0x32, 0x66, 0x31, 0x38, 0x66, 0x61, 0x64, 0x34, 0x31, 0x62, 0x39, 0x30, 0x33, 0x34, 0x35, 0x31, 0x31, 0x35, 0x63, 0x33, 0x31, 0x31, 0x37, 0x38, 0x31, 0x32, 0x35, 0x35, 0x33, 0x61, 0x37, 0x61, 0x33, 0x63, 0x39, 0x34, 0x61, 0x34, 0x63, 0x37, 0x33, 0x32, 0x65, 0x66, 0x32, 0x32, 0x35, 0x63, 0x65, 0x63, 0x63, 0x61, 0x35, 0x64, 0x39, 0x63, 0x36, 0x62, 0x62, 0x34, 0x32, 0x31, 0x64, 0x66, 0x36, 0x30, 0x35, 0x38, 0x37, 0x38, 0x39, 0x63, 0x38, 0x63, 0x65, 0x65, 0x39, 0x33, 0x35, 0x34, 0x61, 0x36, 0x64, 0x33, 0x33, 0x35, 0x34, 0x64, 0x63, 0x62, 0x64, 0x36, 0x65, 0x36, 0x37, 0x63, 0x63, 0x39, 0x31, 0x32, 0x61, 0x36, 0x38, 0x35, 0x30, 0x30, 0x63, 0x65, 0x32, 0x30, 0x63, 0x39, 0x64, 0x32, 0x39, 0x36, 0x65, 0x36, 0x32, 0x36, 0x33, 0x37, 0x61, 0x61, 0x39, 0x63, 0x63, 0x39, 0x61, 0x61, 0x32, 0x66, 0x61, 0x37, 0x31, 0x38, 0x35, 0x63, 0x31, 0x61, 0x65, 0x62, 0x62, 0x33, 0x35, 0x63, 0x61, 0x39, 0x61, 0x62, 0x63, 0x64, 0x66, 0x39, 0x36, 0x38, 0x64, 0x32, 0x62, 0x32, 0x61, 0x63, 0x34, 0x35, 0x66, 0x61, 0x30, 0x31, 0x36, 0x39, 0x39, 0x30, 0x63, 0x63, 0x31, 0x35, 0x66, 0x37, 0x63, 0x39, 0x34, 0x61, 0x30, 0x66, 0x31, 0x61, 0x35, 0x63, 0x34, 0x38, 0x38, 0x61, 0x31, 0x64, 0x30, 0x38, 0x61, 0x64, 0x37, 0x38, 0x65, 0x62, 0x66, 0x62, 0x66, 0x36, 0x35, 0x32, 0x38, 0x32, 0x36, 0x36, 0x65, 0x30, 0x65, 0x35, 0x63, 0x65, 0x62, 0x36, 0x32, 0x63, 0x62, 0x61, 0x32, 0x39, 0x62, 0x37, 0x32, 0x65, 0x33, 0x34, 0x65, 0x34, 0x61, 0x65, 0x36, 0x62, 0x37, 0x61, 0x39, 0x62, 0x35, 0x36, 0x36, 0x63, 0x36, 0x64, 0x32, 0x61, 0x33, 0x37, 0x34, 0x36, 0x30, 0x36, 0x61, 0x38, 0x65, 0x38, 0x39, 0x30, 0x65, 0x37, 0x66, 0x61, 0x62, 0x30, 0x61, 0x35, 0x64, 0x39, 0x39, 0x34, 0x66, 0x33, 0x61, 0x37, 0x39, 0x36, 0x63, 0x38, 0x35, 0x62, 0x64, 0x66, 0x38, 0x64, 0x36, 0x34, 0x62, 0x34, 0x62, 0x38, 0x39, 0x61, 0x32, 0x31, 0x35, 0x31, 0x31, 0x61, 0x36, 0x64, 0x37, 0x65, 0x36, 0x30, 0x37, 0x66, 0x64, 0x31, 0x61, 0x65, 0x65, 0x30, 0x30, 0x37, 0x65, 0x64, 0x38, 0x31, 0x39, 0x63, 0x37, 0x31, 0x30, 0x33, 0x33, 0x35, 0x39, 0x34, 0x39, 0x65, 0x35, 0x39, 0x30, 0x62, 0x37, 0x35, 0x65, 0x39, 0x64, 0x33, 0x36, 0x63, 0x34, 0x38, 0x61, 0x61, 0x32, 0x37, 0x33, 0x38, 0x37, 0x37, 0x32, 0x34, 0x35, 0x32, 0x33, 0x33, 0x61, 0x34, 0x34, 0x35, 0x61, 0x34, 0x64, 0x38, 0x61, 0x31, 0x30, 0x39, 0x33, 0x33, 0x38, 0x32, 0x39, 0x30, 0x61, 0x62, 0x64, 0x33, 0x63, 0x38, 0x64, 0x32, 0x66, 0x65, 0x32, 0x34, 0x31, 0x31, 0x64, 0x32, 0x36, 0x38, 0x35, 0x31, 0x38, 0x30, 0x32, 0x33, 0x33, 0x37, 0x36, 0x33, 0x32, 0x30, 0x61, 0x32, 0x39, 0x63, 0x36, 0x31, 0x38, 0x32, 0x37, 0x37, 0x32, 0x31, 0x36, 0x66, 0x61, 0x32, 0x38, 0x61, 0x36, 0x37, 0x64, 0x61, 0x34, 0x35, 0x64, 0x62, 0x39, 0x39, 0x65, 0x33, 0x64, 0x33, 0x38, 0x31, 0x63, 0x66, 0x61, 0x32, 0x30, 0x38, 0x66, 0x37, 0x63, 0x37, 0x30, 0x33, 0x39, 0x39, 0x37, 0x35, 0x34, 0x31, 0x61, 0x61, 0x65, 0x31, 0x39, 0x65, 0x35, 0x66, 0x37, 0x62, 0x62, 0x64, 0x34, 0x32, 0x38, 0x33, 0x31, 0x38, 0x37, 0x32, 0x38, 0x37, 0x32, 0x31, 0x39, 0x66, 0x63, 0x35, 0x32, 0x32, 0x65, 0x33, 0x63, 0x31, 0x32, 0x35, 0x30, 0x34, 0x37, 0x63, 0x64, 0x35, 0x64, 0x62, 0x30, 0x39, 0x62, 0x30, 0x61, 0x37, 0x62, 0x30, 0x36, 0x32, 0x36, 0x39, 0x39, 0x63, 0x64, 0x32, 0x63, 0x31, 0x34, 0x34, 0x63, 0x61, 0x36, 0x64, 0x34, 0x33, 0x30, 0x37, 0x33, 0x36, 0x66, 0x32, 0x65, 0x31, 0x34, 0x32, 0x63, 0x64, 0x63, 0x65, 0x62, 0x32, 0x32, 0x33, 0x65, 0x39, 0x64, 0x31, 0x35, 0x34, 0x66, 0x65, 0x37, 0x33, 0x30, 0x64, 0x61, 0x39, 0x39, 0x65, 0x31, 0x34, 0x35, 0x61, 0x30, 0x66, 0x37, 0x62, 0x64, 0x38, 0x30, 0x38, 0x30, 0x37, 0x31, 0x63, 0x34, 0x65, 0x31, 0x64, 0x36, 0x66, 0x63, 0x31, 0x34, 0x35, 0x34, 0x37, 0x62, 0x34, 0x36, 0x37, 0x30, 0x32, 0x34, 0x32, 0x31, 0x31, 0x35, 0x64, 0x31, 0x36, 0x39, 0x64, 0x34, 0x37, 0x32, 0x63, 0x63, 0x61, 0x61, 0x33, 0x39, 0x37, 0x33, 0x63, 0x65, 0x30, 0x61, 0x62, 0x38, 0x38, 0x36, 0x63, 0x32, 0x37, 0x61, 0x35, 0x31, 0x35, 0x35, 0x37, 0x35, 0x35, 0x61, 0x36, 0x65, 0x64, 0x66, 0x30, 0x37, 0x61, 0x61, 0x38, 0x37, 0x30, 0x39, 0x61, 0x39, 0x37, 0x34, 0x65, 0x62, 0x66, 0x34, 0x37, 0x62, 0x37, 0x38, 0x63, 0x38, 0x37, 0x61, 0x36, 0x37, 0x36, 0x38, 0x65, 0x33, 0x31, 0x65, 0x38, 0x33, 0x33, 0x33, 0x65, 0x36, 0x36, 0x38, 0x63, 0x37, 0x61, 0x66, 0x66, 0x62, 0x35, 0x64, 0x30, 0x63, 0x61, 0x64, 0x30, 0x64, 0x61, 0x62, 0x32, 0x66, 0x39, 0x35, 0x34, 0x32, 0x36, 0x31, 0x32, 0x65, 0x35, 0x63, 0x61, 0x65, 0x32, 0x63, 0x37, 0x32, 0x63, 0x35, 0x35, 0x63, 0x30, 0x64, 0x31, 0x66, 0x31, 0x30, 0x31, 0x30, 0x32, 0x63, 0x37, 0x63, 0x36, 0x36, 0x36, 0x66, 0x32, 0x63, 0x33, 0x37, 0x39, 0x66, 0x64, 0x35, 0x65, 0x63, 0x31, 0x62, 0x39, 0x30, 0x39, 0x63, 0x66, 0x35, 0x32, 0x32, 0x62, 0x62, 0x34, 0x37, 0x62, 0x61, 0x64, 0x38, 0x64, 0x65, 0x33, 0x37, 0x64, 0x62, 0x66, 0x66, 0x66, 0x64, 0x36, 0x39, 0x31, 0x30, 0x31, 0x66, 0x65, 0x34, 0x62, 0x39, 0x61, 0x33, 0x37, 0x35, 0x30, 0x64, 0x61, 0x32, 0x62, 0x39, 0x65, 0x63, 0x31, 0x35, 0x32, 0x37, 0x37, 0x32, 0x32, 0x30, 0x36, 0x38, 0x65, 0x62, 0x63, 0x37, 0x32, 0x38, 0x33, 0x37, 0x38, 0x37, 0x62, 0x31, 0x65, 0x64, 0x36, 0x34, 0x61, 0x62, 0x33, 0x39, 0x38, 0x64, 0x38, 0x30, 0x34, 0x39, 0x31, 0x35, 0x33, 0x31, 0x63, 0x33, 0x31, 0x63, 0x35, 0x37, 0x30, 0x32, 0x36, 0x36, 0x33, 0x37, 0x30, 0x35, 0x39, 0x66, 0x33, 0x31, 0x64, 0x38, 0x39, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x35, 0x37, 0x32, 0x31, 0x65, 0x37, 0x66, 0x65, 0x66, 0x33, 0x34, 0x64, 0x63, 0x38, 0x32, 0x30, 0x39, 0x33, 0x64, 0x39, 0x30, 0x33, 0x63, 0x36, 0x34, 0x62, 0x34, 0x30, 0x64, 0x32, 0x30, 0x63, 0x65, 0x32, 0x39, 0x35, 0x31, 0x65, 0x30, 0x62, 0x38, 0x34, 0x62, 0x65, 0x65, 0x35, 0x66, 0x32, 0x31, 0x62, 0x34, 0x35, 0x32, 0x36, 0x66, 0x31, 0x65, 0x65, 0x64, 0x36, 0x33, 0x35, 0x33, 0x39, 0x61, 0x30, 0x62, 0x65, 0x36, 0x32, 0x64, 0x35, 0x66, 0x31, 0x66, 0x61, 0x65, 0x64, 0x35, 0x38, 0x37, 0x64, 0x36, 0x64, 0x37, 0x66, 0x36, 0x66, 0x31, 0x36, 0x30, 0x63, 0x61, 0x38, 0x34, 0x66, 0x39, 0x38, 0x61, 0x39, 0x34, 0x35, 0x64, 0x33, 0x30, 0x35, 0x32, 0x61, 0x63, 0x35, 0x38, 0x65, 0x39, 0x62, 0x37, 0x61, 0x31, 0x33, 0x36, 0x64, 0x31, 0x37, 0x61, 0x65, 0x33, 0x32, 0x33, 0x37, 0x33, 0x33, 0x62, 0x30, 0x31, 0x37, 0x61, 0x36, 0x35, 0x64, 0x31, 0x64, 0x31, 0x62, 0x66, 0x66, 0x30, 0x38, 0x61, 0x35, 0x34, 0x34, 0x34, 0x64, 0x32, 0x36, 0x33, 0x61, 0x37, 0x32, 0x34, 0x31, 0x61, 0x32, 0x63, 0x30, 0x64, 0x65, 0x32, 0x39, 0x39, 0x63, 0x61, 0x64, 0x65, 0x63, 0x33, 0x61, 0x38, 0x39, 0x35, 0x64, 0x66, 0x37, 0x65, 0x64, 0x33, 0x63, 0x34, 0x38, 0x66, 0x39, 0x38, 0x30, 0x63, 0x36, 0x65, 0x31, 0x38, 0x33, 0x35, 0x35, 0x34, 0x62, 0x64, 0x62, 0x30, 0x62, 0x34, 0x32, 0x36, 0x39, 0x34, 0x33, 0x33, 0x39, 0x64, 0x37, 0x35, 0x30, 0x33, 0x65, 0x30, 0x38, 0x65, 0x31, 0x34, 0x36, 0x33, 0x30, 0x31, 0x61, 0x35, 0x35, 0x37, 0x32, 0x66, 0x64, 0x35, 0x65, 0x34, 0x64, 0x65, 0x35, 0x38, 0x30, 0x32, 0x64, 0x39, 0x65, 0x34, 0x36, 0x61, 0x39, 0x36, 0x35, 0x34, 0x38, 0x38, 0x37, 0x32, 0x38, 0x31, 0x38, 0x30, 0x39, 0x61, 0x61, 0x66, 0x33, 0x62, 0x35, 0x37, 0x38, 0x37, 0x35, 0x64, 0x63, 0x65, 0x32, 0x63, 0x30, 0x66, 0x61, 0x30, 0x62, 0x38, 0x39, 0x35, 0x30, 0x64, 0x36, 0x66, 0x32, 0x38, 0x61, 0x35, 0x36, 0x39, 0x63, 0x36, 0x37, 0x64, 0x38, 0x35, 0x64, 0x31, 0x39, 0x32, 0x63, 0x39, 0x34, 0x62, 0x66, 0x38, 0x62, 0x37, 0x32, 0x33, 0x39, 0x65, 0x63, 0x31, 0x37, 0x32, 0x64, 0x35, 0x34, 0x37, 0x64, 0x66, 0x66, 0x38, 0x36, 0x35, 0x38, 0x64, 0x33, 0x65, 0x34, 0x66, 0x32, 0x33, 0x37, 0x66, 0x39, 0x30, 0x36, 0x33, 0x39, 0x37, 0x63, 0x35, 0x34, 0x31, 0x39, 0x64, 0x66, 0x34, 0x30, 0x66, 0x32, 0x61, 0x33, 0x30, 0x36, 0x37, 0x63, 0x39, 0x61, 0x36, 0x37, 0x66, 0x64, 0x39, 0x33, 0x33, 0x36, 0x35, 0x61, 0x38, 0x62, 0x32, 0x30, 0x64, 0x63, 0x33, 0x37, 0x32, 0x30, 0x61, 0x32, 0x61, 0x33, 0x38, 0x36, 0x34, 0x36, 0x61, 0x35, 0x66, 0x62, 0x61, 0x37, 0x34, 0x35, 0x32, 0x62, 0x32, 0x32, 0x66, 0x36, 0x65, 0x32, 0x39, 0x66, 0x38, 0x64, 0x37, 0x61, 0x38, 0x31, 0x31, 0x36, 0x65, 0x62, 0x34, 0x38, 0x66, 0x61, 0x35, 0x38, 0x64, 0x36, 0x35, 0x38, 0x37, 0x39, 0x34, 0x33, 0x38, 0x37, 0x66, 0x36, 0x35, 0x31, 0x35, 0x31, 0x36, 0x37, 0x38, 0x32, 0x31, 0x64, 0x36, 0x38, 0x62, 0x31, 0x62, 0x62, 0x30, 0x36, 0x30, 0x32, 0x63, 0x30, 0x31, 0x61, 0x31, 0x33, 0x36, 0x31, 0x64, 0x62, 0x36, 0x66, 0x35, 0x36, 0x39, 0x38, 0x37, 0x65, 0x66, 0x37, 0x39, 0x38, 0x32, 0x36, 0x32, 0x65, 0x37, 0x35, 0x33, 0x39, 0x65, 0x30, 0x66, 0x31, 0x62, 0x66, 0x66, 0x65, 0x38, 0x61, 0x64, 0x63, 0x35, 0x63, 0x31, 0x30, 0x64, 0x32, 0x36, 0x65, 0x36, 0x37, 0x32, 0x31, 0x37, 0x33, 0x61, 0x33, 0x32, 0x38, 0x30, 0x63, 0x32, 0x63, 0x62, 0x66, 0x61, 0x30, 0x33, 0x38, 0x36, 0x39, 0x64, 0x32, 0x34, 0x39, 0x37, 0x36, 0x37, 0x39, 0x64, 0x66, 0x34, 0x37, 0x61, 0x33, 0x64, 0x39, 0x33, 0x30, 0x35, 0x32, 0x34, 0x61, 0x33, 0x33, 0x37, 0x38, 0x37, 0x63, 0x65, 0x34, 0x62, 0x36, 0x30, 0x62, 0x65, 0x39, 0x34, 0x63, 0x66, 0x36, 0x35, 0x37, 0x36, 0x37, 0x32, 0x66, 0x66, 0x31, 0x39, 0x61, 0x32, 0x61, 0x63, 0x64, 0x66, 0x34, 0x32, 0x62, 0x31, 0x66, 0x64, 0x64, 0x35, 0x65, 0x61, 0x65, 0x62, 0x36, 0x64, 0x62, 0x66, 0x37, 0x64, 0x65, 0x37, 0x35, 0x38, 0x37, 0x66, 0x37, 0x63, 0x64, 0x63, 0x34, 0x35, 0x65, 0x64, 0x38, 0x62, 0x64, 0x33, 0x30, 0x37, 0x39, 0x31, 0x35, 0x31, 0x66, 0x38, 0x30, 0x63, 0x30, 0x37, 0x33, 0x65, 0x35, 0x65, 0x37, 0x32, 0x66, 0x37, 0x35, 0x63, 0x66, 0x64, 0x36, 0x34, 0x66, 0x61, 0x32, 0x62, 0x32, 0x61, 0x66, 0x34, 0x63, 0x65, 0x38, 0x36, 0x61, 0x33, 0x65, 0x37, 0x34, 0x66, 0x39, 0x31, 0x62, 0x31, 0x66, 0x31, 0x36, 0x31, 0x66, 0x64, 0x64, 0x63, 0x36, 0x34, 0x30, 0x64, 0x38, 0x30, 0x66, 0x30, 0x31, 0x63, 0x63, 0x39, 0x39, 0x34, 0x63, 0x39, 0x37, 0x39, 0x61, 0x64, 0x62, 0x61, 0x63, 0x30, 0x37, 0x32, 0x31, 0x31, 0x31, 0x61, 0x35, 0x32, 0x37, 0x33, 0x35, 0x39, 0x39, 0x39, 0x61, 0x63, 0x34, 0x37, 0x63, 0x62, 0x35, 0x66, 0x66, 0x37, 0x39, 0x63, 0x63, 0x32, 0x38, 0x36, 0x66, 0x61, 0x61, 0x63, 0x37, 0x34, 0x61, 0x66, 0x32, 0x64, 0x32, 0x36, 0x64, 0x63, 0x31, 0x38, 0x35, 0x66, 0x31, 0x66, 0x30, 0x63, 0x64, 0x32, 0x62, 0x36, 0x30, 0x61, 0x39, 0x37, 0x65, 0x66, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x38, 0x64, 0x63, 0x37, 0x61, 0x38, 0x66, 0x61, 0x38, 0x32, 0x34, 0x31, 0x36, 0x63, 0x36, 0x65, 0x39, 0x38, 0x36, 0x66, 0x31, 0x66, 0x36, 0x37, 0x30, 0x61, 0x37, 0x66, 0x62, 0x35, 0x31, 0x64, 0x63, 0x35, 0x33, 0x34, 0x31, 0x62, 0x37, 0x63, 0x64, 0x36, 0x61, 0x62, 0x32, 0x39, 0x30, 0x36, 0x35, 0x33, 0x32, 0x30, 0x35, 0x32, 0x38, 0x63, 0x34, 0x62, 0x33, 0x35, 0x37, 0x32, 0x66, 0x62, 0x62, 0x30, 0x30, 0x36, 0x34, 0x39, 0x65, 0x63, 0x36, 0x33, 0x61, 0x37, 0x65, 0x35, 0x63, 0x31, 0x37, 0x34, 0x39, 0x64, 0x31, 0x37, 0x36, 0x35, 0x65, 0x30, 0x30, 0x39, 0x37, 0x34, 0x64, 0x65, 0x33, 0x35, 0x31, 0x39, 0x31, 0x62, 0x37, 0x30, 0x30, 0x30, 0x64, 0x35, 0x30, 0x30, 0x33, 0x32, 0x64, 0x30, 0x38, 0x66, 0x64, 0x33, 0x35, 0x33, 0x34, 0x65, 0x66, 0x62, 0x31, 0x36, 0x34, 0x36, 0x63, 0x39, 0x61, 0x36, 0x63, 0x30, 0x65, 0x34, 0x39, 0x31, 0x30, 0x38, 0x36, 0x65, 0x36, 0x35, 0x34, 0x65, 0x39, 0x35, 0x34, 0x65, 0x37, 0x35, 0x62, 0x34, 0x63, 0x66, 0x63, 0x63, 0x61, 0x63, 0x37, 0x64, 0x63, 0x62, 0x38, 0x63, 0x66, 0x34, 0x38, 0x38, 0x30, 0x33, 0x34, 0x36, 0x33, 0x65, 0x33, 0x34, 0x39, 0x63, 0x38, 0x35, 0x39, 0x32, 0x35, 0x32, 0x30, 0x61, 0x34, 0x35, 0x34, 0x37, 0x64, 0x34, 0x61, 0x35, 0x64, 0x35, 0x36, 0x30, 0x39, 0x37, 0x33, 0x39, 0x35, 0x35, 0x32, 0x37, 0x66, 0x63, 0x61, 0x36, 0x63, 0x64, 0x65, 0x61, 0x31, 0x33, 0x61, 0x31, 0x34, 0x62, 0x66, 0x65, 0x62, 0x66, 0x64, 0x31, 0x66, 0x31, 0x66, 0x32, 0x36, 0x39, 0x63, 0x33, 0x32, 0x37, 0x32, 0x65, 0x65, 0x37, 0x66, 0x62, 0x33, 0x31, 0x39, 0x32, 0x37, 0x33, 0x61, 0x38, 0x36, 0x38, 0x34, 0x37, 0x31, 0x63, 0x62, 0x66, 0x37, 0x38, 0x31, 0x38, 0x30, 0x66, 0x34, 0x63, 0x65, 0x63, 0x36, 0x30, 0x31, 0x61, 0x65, 0x39, 0x31, 0x65, 0x33, 0x62, 0x30, 0x61, 0x32, 0x36, 0x30, 0x66, 0x62, 0x63, 0x65, 0x65, 0x66, 0x34, 0x38, 0x32, 0x35, 0x36, 0x66, 0x64, 0x66, 0x33, 0x33, 0x37, 0x62, 0x62, 0x63, 0x32, 0x33, 0x34, 0x63, 0x64, 0x61, 0x32, 0x63, 0x35, 0x33, 0x35, 0x37, 0x32, 0x66, 0x31, 0x62, 0x62, 0x61, 0x38, 0x34, 0x61, 0x38, 0x62, 0x34, 0x30, 0x37, 0x65, 0x35, 0x33, 0x33, 0x39, 0x37, 0x65, 0x35, 0x31, 0x38, 0x39, 0x31, 0x39, 0x36, 0x31, 0x61, 0x33, 0x32, 0x33, 0x38, 0x38, 0x64, 0x36, 0x33, 0x38, 0x30, 0x65, 0x33, 0x36, 0x30, 0x38, 0x30, 0x65, 0x62, 0x64, 0x62, 0x65, 0x65, 0x64, 0x30, 0x35, 0x63, 0x34, 0x66, 0x62, 0x34, 0x61, 0x38, 0x63, 0x34, 0x62, 0x34, 0x61, 0x66, 0x65, 0x65, 0x61, 0x31, 0x35, 0x37, 0x36, 0x34, 0x36, 0x66, 0x34, 0x63, 0x30, 0x30, 0x39, 0x37, 0x34, 0x64, 0x36, 0x37, 0x32, 0x66, 0x35, 0x65, 0x32, 0x62, 0x39, 0x39, 0x38, 0x33, 0x38, 0x65, 0x65, 0x65, 0x38, 0x32, 0x39, 0x34, 0x32, 0x31, 0x33, 0x31, 0x34, 0x66, 0x34, 0x36, 0x35, 0x37, 0x36, 0x63, 0x32, 0x65, 0x62, 0x65, 0x33, 0x66, 0x65, 0x64, 0x32, 0x37, 0x32, 0x36, 0x32, 0x31, 0x36, 0x37, 0x32, 0x65, 0x35, 0x61, 0x30, 0x62, 0x34, 0x37, 0x61, 0x64, 0x30, 0x38, 0x65, 0x64, 0x32, 0x37, 0x63, 0x38, 0x37, 0x36, 0x35, 0x39, 0x30, 0x38, 0x33, 0x36, 0x38, 0x36, 0x30, 0x34, 0x35, 0x62, 0x37, 0x66, 0x34, 0x38, 0x65, 0x32, 0x38, 0x62, 0x62, 0x32, 0x35, 0x37, 0x36, 0x63, 0x38, 0x30, 0x63, 0x30, 0x62, 0x35, 0x31, 0x38, 0x39, 0x35, 0x61, 0x37, 0x32, 0x65, 0x35, 0x32, 0x39, 0x66, 0x33, 0x30, 0x64, 0x36, 0x64, 0x65, 0x34, 0x36, 0x34, 0x36, 0x38, 0x30, 0x64, 0x64, 0x63, 0x62, 0x66, 0x32, 0x36, 0x33, 0x62, 0x36, 0x32, 0x32, 0x66, 0x61, 0x31, 0x36, 0x37, 0x32, 0x32, 0x61, 0x63, 0x35, 0x64, 0x63, 0x64, 0x38, 0x63, 0x37, 0x34, 0x37, 0x64, 0x37, 0x30, 0x64, 0x38, 0x32, 0x65, 0x39, 0x37, 0x33, 0x34, 0x63, 0x38, 0x36, 0x33, 0x37, 0x32, 0x33, 0x37, 0x65, 0x37, 0x66, 0x64, 0x63, 0x61, 0x62, 0x66, 0x61, 0x32, 0x64, 0x38, 0x31, 0x31, 0x35, 0x30, 0x33, 0x32, 0x37, 0x30, 0x36, 0x34, 0x64, 0x33, 0x61, 0x30, 0x33, 0x36, 0x66, 0x31, 0x35, 0x36, 0x66, 0x37, 0x63, 0x62, 0x66, 0x66, 0x33, 0x61, 0x65, 0x34, 0x34, 0x36, 0x33, 0x31, 0x37, 0x61, 0x37, 0x31, 0x31, 0x66, 0x33, 0x39, 0x37, 0x30, 0x32, 0x33, 0x65, 0x39, 0x37, 0x32, 0x63, 0x37, 0x32, 0x33, 0x33, 0x30, 0x61, 0x63, 0x63, 0x36, 0x65, 0x61, 0x33, 0x31, 0x32, 0x30, 0x66, 0x62, 0x30, 0x36, 0x64, 0x31, 0x36, 0x37, 0x65, 0x37, 0x65, 0x65, 0x39, 0x66, 0x30, 0x30, 0x65, 0x38, 0x65, 0x30, 0x36, 0x65, 0x37, 0x35, 0x65, 0x33, 0x64, 0x62, 0x64, 0x33, 0x30, 0x65, 0x35, 0x35, 0x30, 0x30, 0x38, 0x36, 0x64, 0x62, 0x66, 0x66, 0x39, 0x61, 0x61, 0x66, 0x37, 0x32, 0x62, 0x64, 0x32, 0x64, 0x34, 0x62, 0x38, 0x61, 0x30, 0x66, 0x37, 0x61, 0x30, 0x65, 0x38, 0x38, 0x35, 0x34, 0x32, 0x66, 0x37, 0x35, 0x39, 0x37, 0x64, 0x31, 0x37, 0x38, 0x34, 0x38, 0x31, 0x35, 0x37, 0x33, 0x66, 0x32, 0x31, 0x33, 0x35, 0x66, 0x37, 0x37, 0x65, 0x66, 0x63, 0x62, 0x66, 0x31, 0x32, 0x64, 0x61, 0x35, 0x38, 0x64, 0x63, 0x31, 0x34, 0x31, 0x61, 0x33, 0x66, 0x34, 0x37, 0x32, 0x34, 0x35, 0x62, 0x62, 0x32, 0x36, 0x62, 0x31, 0x33, 0x36, 0x31, 0x35, 0x63, 0x31, 0x33, 0x62, 0x64, 0x36, 0x65, 0x38, 0x61, 0x63, 0x33, 0x61, 0x37, 0x36, 0x34, 0x35, 0x32, 0x65, 0x31, 0x63, 0x34, 0x65, 0x37, 0x62, 0x65, 0x36, 0x37, 0x36, 0x64, 0x61, 0x61, 0x33, 0x63, 0x34, 0x34, 0x62, 0x66, 0x36, 0x64, 0x35, 0x66, 0x32, 0x66, 0x63, 0x32, 0x34, 0x32, 0x62, 0x32, 0x39, 0x33, 0x30, 0x65, 0x33, 0x36, 0x30, 0x35, 0x63, 0x63, 0x62, 0x64, 0x37, 0x36, 0x32, 0x63, 0x34, 0x65, 0x63, 0x31, 0x65, 0x37, 0x66, 0x61, 0x63, 0x63, 0x31, 0x31, 0x66, 0x64, 0x35, 0x33, 0x35, 0x36, 0x61, 0x62, 0x34, 0x33, 0x36, 0x61, 0x64, 0x62, 0x64, 0x65, 0x36, 0x31, 0x65, 0x33, 0x31, 0x62, 0x37, 0x37, 0x36, 0x38, 0x39, 0x66, 0x64, 0x65, 0x31, 0x31, 0x61, 0x39, 0x33, 0x36, 0x66, 0x32, 0x32, 0x31, 0x33, 0x64, 0x63, 0x35, 0x33, 0x64, 0x34, 0x39, 0x38, 0x38, 0x31, 0x39, 0x63, 0x30, 0x30, 0x66, 0x65, 0x38, 0x33, 0x66, 0x63, 0x35, 0x61, 0x64, 0x33, 0x61, 0x62, 0x34, 0x32, 0x61, 0x64, 0x66, 0x38, 0x37, 0x33, 0x35, 0x66, 0x66, 0x32, 0x36, 0x64, 0x37, 0x64, 0x38, 0x65, 0x61, 0x65, 0x36, 0x37, 0x32, 0x38, 0x62, 0x31, 0x39, 0x66, 0x35, 0x65, 0x61, 0x34, 0x32, 0x33, 0x37, 0x32, 0x30, 0x32, 0x30, 0x31, 0x35, 0x35, 0x36, 0x38, 0x66, 0x37, 0x39, 0x30, 0x38, 0x30, 0x31, 0x65, 0x32, 0x39, 0x63, 0x62, 0x62, 0x32, 0x38, 0x61, 0x61, 0x64, 0x38, 0x31, 0x30, 0x36, 0x66, 0x35, 0x31, 0x62, 0x64, 0x61, 0x66, 0x39, 0x34, 0x32, 0x32, 0x64, 0x61, 0x34, 0x37, 0x63, 0x36, 0x65, 0x62, 0x61, 0x36, 0x66, 0x64, 0x38, 0x32, 0x65, 0x61, 0x32, 0x36, 0x66, 0x32, 0x30, 0x37, 0x32, 0x32, 0x39, 0x65, 0x65, 0x31, 0x66, 0x62, 0x63, 0x30, 0x33, 0x63, 0x65, 0x36, 0x33, 0x39, 0x62, 0x31, 0x33, 0x34, 0x32, 0x61, 0x64, 0x62, 0x39, 0x31, 0x66, 0x65, 0x63, 0x39, 0x35, 0x35, 0x35, 0x64, 0x64, 0x65, 0x64, 0x66, 0x31, 0x64, 0x64, 0x65, 0x31, 0x65, 0x65, 0x66, 0x30, 0x37, 0x30, 0x32, 0x32, 0x36, 0x62, 0x65, 0x32, 0x38, 0x36, 0x31, 0x31, 0x35, 0x39, 0x37, 0x35, 0x31, 0x37, 0x34, 0x63, 0x30, 0x66, 0x66, 0x30, 0x35, 0x38, 0x64, 0x62, 0x37, 0x32, 0x32, 0x32, 0x33, 0x32, 0x62, 0x30, 0x30, 0x39, 0x39, 0x31, 0x33, 0x33, 0x33, 0x34, 0x36, 0x34, 0x30, 0x36, 0x61, 0x34, 0x65, 0x32, 0x63, 0x65, 0x39, 0x63, 0x62, 0x33, 0x31, 0x31, 0x63, 0x36, 0x35, 0x34, 0x36, 0x31, 0x61, 0x38, 0x39, 0x32, 0x34, 0x35, 0x38, 0x38, 0x65, 0x39, 0x34, 0x62, 0x66, 0x39, 0x37, 0x30, 0x34, 0x39, 0x62, 0x38, 0x65, 0x36, 0x64, 0x33, 0x36, 0x63, 0x63, 0x37, 0x61, 0x35, 0x36, 0x38, 0x37, 0x30, 0x34, 0x30, 0x32, 0x38, 0x32, 0x37, 0x35, 0x31, 0x30, 0x31, 0x62, 0x66, 0x65, 0x65, 0x33, 0x30, 0x39, 0x64, 0x63, 0x33, 0x64, 0x37, 0x38, 0x62, 0x30, 0x65, 0x34, 0x63, 0x66, 0x33, 0x31, 0x30, 0x62, 0x63, 0x66, 0x37, 0x61, 0x31, 0x31, 0x35, 0x64, 0x66, 0x33, 0x62, 0x34, 0x34, 0x34, 0x39, 0x64, 0x66, 0x36, 0x31, 0x36, 0x61, 0x62, 0x66, 0x61, 0x63, 0x37, 0x34, 0x32, 0x62, 0x63, 0x31, 0x30, 0x39, 0x66, 0x65, 0x37, 0x36, 0x65, 0x66, 0x65, 0x63, 0x63, 0x39, 0x65, 0x31, 0x39, 0x61, 0x37, 0x32, 0x39, 0x33, 0x39, 0x35, 0x31, 0x62, 0x33, 0x64, 0x37, 0x39, 0x38, 0x36, 0x34, 0x32, 0x63, 0x62, 0x35, 0x33, 0x61, 0x38, 0x32, 0x37, 0x62, 0x35, 0x30, 0x62, 0x37, 0x32, 0x34, 0x30, 0x63, 0x36, 0x36, 0x62, 0x64, 0x37, 0x31, 0x66, 0x64, 0x62, 0x34, 0x38, 0x38, 0x64, 0x66, 0x30, 0x62, 0x33, 0x64, 0x36, 0x37, 0x38, 0x61, 0x30, 0x61, 0x33, 0x62, 0x36, 0x62, 0x30, 0x38, 0x33, 0x39, 0x32, 0x62, 0x32, 0x62, 0x35, 0x62, 0x37, 0x61, 0x30, 0x31, 0x33, 0x36, 0x37, 0x62, 0x64, 0x39, 0x63, 0x64, 0x63, 0x38, 0x62, 0x33, 0x32, 0x63, 0x35, 0x30, 0x37, 0x34, 0x36, 0x63, 0x32, 0x65, 0x34, 0x35, 0x64, 0x37, 0x35, 0x65, 0x35, 0x66, 0x61, 0x64, 0x64, 0x33, 0x65, 0x63, 0x37, 0x35, 0x62, 0x64, 0x37, 0x32, 0x37, 0x66, 0x31, 0x63, 0x33, 0x62, 0x35, 0x38, 0x62, 0x35, 0x33, 0x31, 0x31, 0x38, 0x62, 0x36, 0x61, 0x37, 0x62, 0x37, 0x39, 0x30, 0x37, 0x33, 0x33, 0x34, 0x65, 0x35, 0x65, 0x31, 0x61, 0x32, 0x62, 0x32, 0x34, 0x64, 0x32, 0x62, 0x35, 0x37, 0x32, 0x32, 0x35, 0x33, 0x37, 0x38, 0x31, 0x62, 0x36, 0x62, 0x39, 0x33, 0x34, 0x32, 0x36, 0x34, 0x61, 0x35, 0x63, 0x34, 0x39, 0x32, 0x35, 0x63, 0x36, 0x30, 0x31, 0x34, 0x33, 0x63, 0x66, 0x36, 0x62, 0x32, 0x37, 0x32, 0x64, 0x34, 0x64, 0x65, 0x34, 0x32, 0x38, 0x32, 0x64, 0x62, 0x61, 0x36, 0x66, 0x30, 0x64, 0x31, 0x35, 0x38, 0x31, 0x62, 0x32, 0x62, 0x63, 0x39, 0x34, 0x38, 0x61, 0x37, 0x32, 0x66, 0x34, 0x63, 0x65, 0x66, 0x34, 0x32, 0x32, 0x34, 0x66, 0x36, 0x32, 0x65, 0x61, 0x33, 0x32, 0x65, 0x36, 0x37, 0x64, 0x63, 0x63, 0x31, 0x37, 0x31, 0x33, 0x30, 0x64, 0x66, 0x62, 0x38, 0x34, 0x38, 0x30, 0x37, 0x36, 0x64, 0x37, 0x35, 0x32, 0x38, 0x37, 0x33, 0x39, 0x64, 0x35, 0x32, 0x35, 0x31, 0x61, 0x66, 0x37, 0x37, 0x36, 0x65, 0x37, 0x33, 0x61, 0x36, 0x65, 0x38, 0x36, 0x32, 0x33, 0x37, 0x35, 0x35, 0x61, 0x38, 0x35, 0x39, 0x31, 0x66, 0x30, 0x65, 0x31, 0x38, 0x37, 0x32, 0x37, 0x38, 0x61, 0x32, 0x37, 0x63, 0x31, 0x30, 0x34, 0x32, 0x37, 0x66, 0x34, 0x30, 0x30, 0x63, 0x36, 0x62, 0x62, 0x65, 0x65, 0x62, 0x64, 0x38, 0x61, 0x39, 0x64, 0x31, 0x63, 0x62, 0x64, 0x31, 0x33, 0x32, 0x62, 0x31, 0x35, 0x66, 0x62, 0x63, 0x61, 0x39, 0x35, 0x33, 0x64, 0x39, 0x30, 0x30, 0x31, 0x64, 0x36, 0x38, 0x39, 0x39, 0x39, 0x63, 0x64, 0x38, 0x62, 0x37, 0x34, 0x63, 0x62, 0x64, 0x37, 0x64, 0x39, 0x31, 0x31, 0x66, 0x64, 0x38, 0x64, 0x63, 0x38, 0x63, 0x64, 0x66, 0x38, 0x33, 0x64, 0x30, 0x63, 0x64, 0x66, 0x65, 0x35, 0x62, 0x37, 0x62, 0x31, 0x65, 0x64, 0x38, 0x39, 0x63, 0x63, 0x34, 0x33, 0x35, 0x63, 0x37, 0x33, 0x65, 0x65, 0x61, 0x62, 0x33, 0x38, 0x61, 0x32, 0x37, 0x32, 0x64, 0x39, 0x30, 0x66, 0x37, 0x64, 0x65, 0x34, 0x35, 0x33, 0x34, 0x66, 0x66, 0x63, 0x62, 0x35, 0x30, 0x37, 0x33, 0x38, 0x32, 0x62, 0x31, 0x35, 0x62, 0x31, 0x38, 0x36, 0x31, 0x62, 0x32, 0x38, 0x30, 0x31, 0x61, 0x63, 0x31, 0x34, 0x63, 0x31, 0x32, 0x37, 0x39, 0x35, 0x64, 0x30, 0x36, 0x63, 0x63, 0x31, 0x34, 0x38, 0x66, 0x33, 0x66, 0x31, 0x35, 0x37, 0x36, 0x33, 0x63, 0x38, 0x37, 0x32, 0x34, 0x64, 0x32, 0x62, 0x33, 0x65, 0x66, 0x66, 0x33, 0x61, 0x63, 0x34, 0x62, 0x31, 0x39, 0x32, 0x61, 0x39, 0x64, 0x34, 0x65, 0x34, 0x62, 0x30, 0x66, 0x37, 0x30, 0x30, 0x64, 0x33, 0x38, 0x66, 0x37, 0x39, 0x31, 0x66, 0x65, 0x30, 0x66, 0x62, 0x65, 0x32, 0x34, 0x32, 0x63, 0x31, 0x30, 0x31, 0x39, 0x37, 0x63, 0x62, 0x35, 0x62, 0x63, 0x33, 0x32, 0x36, 0x31, 0x35, 0x66, 0x35, 0x34, 0x33, 0x64, 0x31, 0x33, 0x66, 0x34, 0x38, 0x64, 0x61, 0x63, 0x62, 0x38, 0x61, 0x65, 0x31, 0x65, 0x64, 0x33, 0x38, 0x39, 0x31, 0x66, 0x35, 0x36, 0x39, 0x37, 0x30, 0x33, 0x39, 0x66, 0x38, 0x32, 0x30, 0x64, 0x35, 0x32, 0x31, 0x61, 0x63, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x33, 0x37, 0x33, 0x64, 0x31, 0x38, 0x64, 0x33, 0x63, 0x62, 0x33, 0x37, 0x36, 0x38, 0x61, 0x39, 0x61, 0x37, 0x32, 0x34, 0x65, 0x63, 0x38, 0x36, 0x36, 0x36, 0x66, 0x64, 0x63, 0x66, 0x36, 0x31, 0x31, 0x34, 0x39, 0x37, 0x61, 0x39, 0x30, 0x39, 0x35, 0x33, 0x37, 0x35, 0x35, 0x39, 0x36, 0x61, 0x66, 0x32, 0x31, 0x65, 0x39, 0x64, 0x30, 0x35, 0x37, 0x63, 0x31, 0x63, 0x37, 0x34, 0x32, 0x36, 0x36, 0x63, 0x39, 0x36, 0x31, 0x61, 0x32, 0x66, 0x30, 0x37, 0x30, 0x33, 0x62, 0x38, 0x61, 0x33, 0x64, 0x36, 0x33, 0x38, 0x65, 0x64, 0x66, 0x64, 0x65, 0x39, 0x37, 0x31, 0x65, 0x37, 0x31, 0x38, 0x30, 0x35, 0x37, 0x31, 0x30, 0x38, 0x66, 0x61, 0x35, 0x33, 0x39, 0x37, 0x65, 0x35, 0x64, 0x34, 0x33, 0x39, 0x65, 0x66, 0x33, 0x33, 0x34, 0x32, 0x35, 0x34, 0x31, 0x38, 0x66, 0x35, 0x61, 0x38, 0x36, 0x64, 0x32, 0x61, 0x61, 0x34, 0x64, 0x32, 0x61, 0x63, 0x38, 0x37, 0x34, 0x66, 0x31, 0x39, 0x34, 0x37, 0x32, 0x39, 0x31, 0x37, 0x66, 0x30, 0x34, 0x31, 0x65, 0x63, 0x35, 0x33, 0x65, 0x39, 0x63, 0x38, 0x30, 0x64, 0x65, 0x31, 0x39, 0x61, 0x65, 0x63, 0x39, 0x30, 0x31, 0x34, 0x63, 0x61, 0x66, 0x63, 0x61, 0x63, 0x65, 0x36, 0x66, 0x33, 0x61, 0x37, 0x39, 0x31, 0x30, 0x32, 0x33, 0x33, 0x38, 0x37, 0x31, 0x61, 0x64, 0x39, 0x31, 0x32, 0x63, 0x64, 0x38, 0x34, 0x66, 0x35, 0x39, 0x64, 0x61, 0x33, 0x62, 0x32, 0x37, 0x37, 0x66, 0x66, 0x33, 0x36, 0x32, 0x34, 0x65, 0x64, 0x39, 0x61, 0x35, 0x34, 0x64, 0x66, 0x38, 0x30, 0x34, 0x32, 0x61, 0x30, 0x33, 0x33, 0x35, 0x36, 0x35, 0x63, 0x34, 0x33, 0x65, 0x64, 0x33, 0x37, 0x65, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x64, 0x37, 0x32, 0x33, 0x33, 0x32, 0x31, 0x31, 0x63, 0x64, 0x62, 0x63, 0x32, 0x33, 0x34, 0x33, 0x63, 0x35, 0x39, 0x38, 0x37, 0x32, 0x31, 0x64, 0x36, 0x38, 0x36, 0x64, 0x30, 0x33, 0x62, 0x31, 0x35, 0x33, 0x32, 0x65, 0x35, 0x62, 0x65, 0x31, 0x61, 0x61, 0x37, 0x30, 0x34, 0x38, 0x33, 0x33, 0x36, 0x38, 0x31, 0x63, 0x63, 0x30, 0x30, 0x33, 0x66, 0x38, 0x38, 0x35, 0x33, 0x30, 0x30, 0x38, 0x32, 0x37, 0x31, 0x63, 0x35, 0x38, 0x66, 0x37, 0x39, 0x61, 0x61, 0x61, 0x33, 0x36, 0x38, 0x65, 0x31, 0x63, 0x63, 0x35, 0x31, 0x64, 0x36, 0x62, 0x38, 0x64, 0x35, 0x66, 0x63, 0x66, 0x36, 0x64, 0x32, 0x36, 0x35, 0x63, 0x30, 0x62, 0x63, 0x31, 0x32, 0x61, 0x37, 0x63, 0x38, 0x37, 0x33, 0x36, 0x64, 0x62, 0x35, 0x32, 0x32, 0x33, 0x33, 0x35, 0x36, 0x39, 0x30, 0x38, 0x65, 0x64, 0x61, 0x37, 0x31, 0x30, 0x61, 0x36, 0x61, 0x66, 0x64, 0x61, 0x39, 0x66, 0x36, 0x32, 0x62, 0x31, 0x32, 0x34, 0x32, 0x61, 0x35, 0x32, 0x37, 0x32, 0x62, 0x65, 0x37, 0x38, 0x39, 0x30, 0x61, 0x39, 0x64, 0x65, 0x32, 0x61, 0x33, 0x64, 0x35, 0x65, 0x38, 0x35, 0x39, 0x61, 0x39, 0x34, 0x35, 0x63, 0x36, 0x30, 0x32, 0x34, 0x38, 0x36, 0x36, 0x37, 0x61, 0x30, 0x37, 0x30, 0x33, 0x38, 0x65, 0x39, 0x66, 0x38, 0x62, 0x35, 0x61, 0x35, 0x33, 0x63, 0x33, 0x64, 0x66, 0x66, 0x34, 0x36, 0x38, 0x64, 0x35, 0x38, 0x32, 0x31, 0x30, 0x38, 0x37, 0x32, 0x35, 0x35, 0x36, 0x35, 0x36, 0x36, 0x35, 0x64, 0x33, 0x39, 0x35, 0x32, 0x30, 0x33, 0x62, 0x39, 0x32, 0x61, 0x63, 0x65, 0x32, 0x30, 0x37, 0x37, 0x38, 0x34, 0x63, 0x35, 0x33, 0x39, 0x33, 0x34, 0x62, 0x30, 0x66, 0x39, 0x66, 0x32, 0x37, 0x38, 0x62, 0x66, 0x66, 0x37, 0x37, 0x31, 0x63, 0x61, 0x36, 0x64, 0x34, 0x32, 0x30, 0x37, 0x38, 0x37, 0x66, 0x64, 0x30, 0x33, 0x37, 0x62, 0x37, 0x32, 0x32, 0x39, 0x62, 0x34, 0x33, 0x64, 0x39, 0x61, 0x65, 0x63, 0x61, 0x66, 0x61, 0x32, 0x37, 0x37, 0x30, 0x66, 0x31, 0x30, 0x34, 0x63, 0x37, 0x37, 0x61, 0x36, 0x63, 0x33, 0x38, 0x39, 0x39, 0x36, 0x39, 0x33, 0x63, 0x33, 0x37, 0x36, 0x63, 0x38, 0x32, 0x64, 0x37, 0x30, 0x34, 0x66, 0x38, 0x64, 0x33, 0x31, 0x39, 0x32, 0x35, 0x33, 0x38, 0x39, 0x66, 0x32, 0x30, 0x63, 0x33, 0x33, 0x30, 0x34, 0x66, 0x66, 0x37, 0x36, 0x64, 0x65, 0x35, 0x34, 0x32, 0x32, 0x35, 0x63, 0x32, 0x64, 0x36, 0x63, 0x34, 0x38, 0x32, 0x36, 0x32, 0x34, 0x39, 0x61, 0x36, 0x31, 0x37, 0x65, 0x38, 0x63, 0x64, 0x31, 0x32, 0x32, 0x37, 0x35, 0x62, 0x64, 0x62, 0x62, 0x63, 0x33, 0x38, 0x63, 0x30, 0x65, 0x64, 0x39, 0x37, 0x63, 0x31, 0x66, 0x35, 0x35, 0x31, 0x32, 0x62, 0x33, 0x34, 0x64, 0x63, 0x61, 0x30, 0x39, 0x32, 0x64, 0x37, 0x34, 0x63, 0x35, 0x32, 0x63, 0x36, 0x65, 0x62, 0x64, 0x31, 0x32, 0x38, 0x38, 0x37, 0x34, 0x65, 0x32, 0x62, 0x64, 0x65, 0x34, 0x36, 0x30, 0x34, 0x36, 0x32, 0x30, 0x61, 0x30, 0x31, 0x30, 0x36, 0x62, 0x38, 0x37, 0x39, 0x33, 0x32, 0x62, 0x65, 0x66, 0x33, 0x30, 0x65, 0x35, 0x66, 0x37, 0x30, 0x63, 0x35, 0x62, 0x61, 0x66, 0x66, 0x38, 0x32, 0x32, 0x39, 0x64, 0x33, 0x37, 0x64, 0x37, 0x37, 0x61, 0x31, 0x37, 0x33, 0x61, 0x61, 0x61, 0x30, 0x35, 0x36, 0x33, 0x32, 0x34, 0x66, 0x61, 0x65, 0x61, 0x32, 0x34, 0x62, 0x63, 0x31, 0x65, 0x38, 0x63, 0x34, 0x64, 0x39, 0x35, 0x66, 0x37, 0x64, 0x37, 0x61, 0x63, 0x63, 0x39, 0x34, 0x38, 0x39, 0x31, 0x66, 0x39, 0x34, 0x35, 0x33, 0x66, 0x32, 0x31, 0x62, 0x38, 0x38, 0x31, 0x33, 0x64, 0x37, 0x38, 0x38, 0x62, 0x37, 0x32, 0x30, 0x65, 0x65, 0x36, 0x30, 0x63, 0x33, 0x33, 0x35, 0x64, 0x36, 0x31, 0x38, 0x37, 0x35, 0x62, 0x34, 0x65, 0x34, 0x37, 0x38, 0x34, 0x38, 0x32, 0x37, 0x39, 0x36, 0x65, 0x38, 0x64, 0x61, 0x65, 0x65, 0x36, 0x62, 0x39, 0x31, 0x64, 0x36, 0x65, 0x39, 0x65, 0x32, 0x66, 0x61, 0x66, 0x32, 0x63, 0x37, 0x38, 0x38, 0x66, 0x65, 0x36, 0x61, 0x38, 0x66, 0x37, 0x36, 0x62, 0x35, 0x66, 0x37, 0x32, 0x61, 0x31, 0x34, 0x61, 0x33, 0x39, 0x30, 0x38, 0x37, 0x37, 0x62, 0x61, 0x30, 0x32, 0x33, 0x39, 0x65, 0x33, 0x66, 0x36, 0x30, 0x39, 0x36, 0x35, 0x63, 0x39, 0x35, 0x35, 0x39, 0x65, 0x64, 0x39, 0x35, 0x66, 0x66, 0x30, 0x36, 0x36, 0x38, 0x30, 0x39, 0x35, 0x66, 0x30, 0x62, 0x39, 0x36, 0x66, 0x61, 0x31, 0x32, 0x39, 0x37, 0x32, 0x62, 0x39, 0x38, 0x31, 0x39, 0x34, 0x65, 0x65, 0x37, 0x32, 0x31, 0x31, 0x32, 0x36, 0x33, 0x61, 0x37, 0x36, 0x36, 0x63, 0x64, 0x30, 0x62, 0x33, 0x38, 0x38, 0x33, 0x62, 0x32, 0x34, 0x33, 0x36, 0x31, 0x31, 0x31, 0x63, 0x63, 0x31, 0x62, 0x30, 0x31, 0x62, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x61, 0x34, 0x62, 0x65, 0x36, 0x36, 0x30, 0x65, 0x39, 0x32, 0x38, 0x30, 0x34, 0x65, 0x66, 0x34, 0x61, 0x36, 0x62, 0x32, 0x35, 0x65, 0x30, 0x34, 0x37, 0x32, 0x33, 0x66, 0x64, 0x33, 0x61, 0x37, 0x63, 0x35, 0x61, 0x35, 0x30, 0x32, 0x65, 0x35, 0x34, 0x38, 0x64, 0x37, 0x66, 0x35, 0x37, 0x63, 0x62, 0x37, 0x36, 0x37, 0x38, 0x37, 0x38, 0x37, 0x30, 0x62, 0x37, 0x66, 0x35, 0x63, 0x30, 0x32, 0x64, 0x36, 0x36, 0x65, 0x66, 0x65, 0x65, 0x35, 0x31, 0x38, 0x32, 0x64, 0x61, 0x33, 0x63, 0x38, 0x30, 0x30, 0x35, 0x61, 0x63, 0x33, 0x32, 0x30, 0x32, 0x36, 0x32, 0x31, 0x63, 0x37, 0x34, 0x34, 0x66, 0x37, 0x34, 0x63, 0x38, 0x35, 0x32, 0x32, 0x63, 0x36, 0x31, 0x38, 0x66, 0x34, 0x65, 0x62, 0x63, 0x32, 0x32, 0x31, 0x36, 0x63, 0x31, 0x64, 0x30, 0x39, 0x31, 0x35, 0x61, 0x62, 0x30, 0x36, 0x63, 0x34, 0x34, 0x64, 0x64, 0x34, 0x32, 0x30, 0x34, 0x35, 0x35, 0x63, 0x63, 0x38, 0x39, 0x65, 0x35, 0x31, 0x37, 0x64, 0x33, 0x37, 0x64, 0x66, 0x35, 0x30, 0x62, 0x38, 0x38, 0x62, 0x63, 0x33, 0x64, 0x61, 0x36, 0x31, 0x30, 0x34, 0x32, 0x63, 0x38, 0x64, 0x63, 0x38, 0x61, 0x33, 0x30, 0x65, 0x38, 0x39, 0x37, 0x31, 0x33, 0x66, 0x63, 0x64, 0x66, 0x61, 0x35, 0x64, 0x63, 0x33, 0x30, 0x62, 0x38, 0x37, 0x35, 0x35, 0x64, 0x64, 0x35, 0x66, 0x66, 0x66, 0x65, 0x61, 0x62, 0x37, 0x63, 0x38, 0x33, 0x66, 0x33, 0x64, 0x64, 0x33, 0x64, 0x35, 0x37, 0x32, 0x38, 0x61, 0x35, 0x33, 0x64, 0x39, 0x61, 0x32, 0x35, 0x38, 0x36, 0x37, 0x38, 0x39, 0x35, 0x37, 0x30, 0x64, 0x31, 0x65, 0x65, 0x63, 0x31, 0x34, 0x64, 0x64, 0x36, 0x65, 0x35, 0x65, 0x37, 0x32, 0x66, 0x37, 0x36, 0x66, 0x62, 0x64, 0x33, 0x33, 0x64, 0x65, 0x65, 0x66, 0x32, 0x37, 0x62, 0x61, 0x39, 0x37, 0x37, 0x36, 0x33, 0x32, 0x37, 0x37, 0x64, 0x38, 0x64, 0x65, 0x30, 0x30, 0x37, 0x32, 0x36, 0x64, 0x31, 0x33, 0x65, 0x61, 0x32, 0x38, 0x61, 0x64, 0x36, 0x34, 0x61, 0x30, 0x35, 0x30, 0x30, 0x62, 0x30, 0x65, 0x64, 0x64, 0x61, 0x36, 0x65, 0x31, 0x39, 0x66, 0x31, 0x36, 0x64, 0x38, 0x33, 0x31, 0x36, 0x39, 0x32, 0x64, 0x38, 0x62, 0x61, 0x64, 0x32, 0x62, 0x62, 0x64, 0x36, 0x30, 0x37, 0x37, 0x34, 0x38, 0x39, 0x61, 0x31, 0x35, 0x65, 0x33, 0x30, 0x39, 0x65, 0x63, 0x35, 0x33, 0x63, 0x66, 0x39, 0x32, 0x35, 0x31, 0x62, 0x64, 0x61, 0x66, 0x61, 0x62, 0x66, 0x39, 0x39, 0x31, 0x61, 0x63, 0x35, 0x63, 0x65, 0x37, 0x30, 0x35, 0x39, 0x31, 0x31, 0x36, 0x61, 0x37, 0x38, 0x38, 0x35, 0x35, 0x30, 0x31, 0x35, 0x65, 0x34, 0x34, 0x31, 0x33, 0x64, 0x61, 0x31, 0x65, 0x37, 0x64, 0x37, 0x36, 0x36, 0x37, 0x61, 0x30, 0x31, 0x37, 0x64, 0x39, 0x62, 0x61, 0x31, 0x63, 0x37, 0x32, 0x65, 0x65, 0x36, 0x61, 0x36, 0x30, 0x64, 0x39, 0x31, 0x61, 0x61, 0x36, 0x64, 0x32, 0x33, 0x39, 0x62, 0x32, 0x64, 0x63, 0x31, 0x30, 0x38, 0x36, 0x61, 0x65, 0x66, 0x61, 0x33, 0x34, 0x34, 0x62, 0x33, 0x37, 0x35, 0x35, 0x66, 0x63, 0x36, 0x62, 0x30, 0x31, 0x38, 0x61, 0x32, 0x30, 0x62, 0x61, 0x31, 0x62, 0x35, 0x36, 0x64, 0x31, 0x34, 0x34, 0x63, 0x32, 0x35, 0x36, 0x36, 0x63, 0x37, 0x32, 0x31, 0x66, 0x33, 0x66, 0x64, 0x64, 0x32, 0x36, 0x38, 0x36, 0x62, 0x35, 0x35, 0x39, 0x32, 0x31, 0x63, 0x61, 0x37, 0x35, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x62, 0x31, 0x63, 0x63, 0x62, 0x63, 0x38, 0x33, 0x31, 0x34, 0x31, 0x64, 0x35, 0x61, 0x65, 0x64, 0x65, 0x33, 0x62, 0x64, 0x39, 0x37, 0x33, 0x63, 0x66, 0x38, 0x33, 0x35, 0x32, 0x31, 0x61, 0x63, 0x37, 0x32, 0x63, 0x33, 0x32, 0x65, 0x62, 0x39, 0x65, 0x32, 0x35, 0x63, 0x37, 0x38, 0x35, 0x36, 0x37, 0x61, 0x30, 0x62, 0x30, 0x63, 0x33, 0x61, 0x30, 0x34, 0x34, 0x38, 0x37, 0x64, 0x31, 0x32, 0x30, 0x61, 0x66, 0x36, 0x34, 0x38, 0x64, 0x31, 0x61, 0x39, 0x63, 0x31, 0x36, 0x62, 0x38, 0x30, 0x31, 0x37, 0x65, 0x63, 0x61, 0x64, 0x36, 0x36, 0x63, 0x37, 0x31, 0x32, 0x31, 0x66, 0x31, 0x38, 0x35, 0x65, 0x65, 0x63, 0x37, 0x32, 0x33, 0x35, 0x63, 0x32, 0x38, 0x39, 0x36, 0x63, 0x35, 0x30, 0x65, 0x66, 0x36, 0x64, 0x38, 0x34, 0x64, 0x62, 0x66, 0x32, 0x30, 0x61, 0x36, 0x64, 0x62, 0x64, 0x35, 0x65, 0x31, 0x62, 0x65, 0x36, 0x35, 0x36, 0x38, 0x35, 0x62, 0x30, 0x38, 0x32, 0x39, 0x65, 0x63, 0x32, 0x34, 0x34, 0x34, 0x37, 0x65, 0x65, 0x39, 0x62, 0x30, 0x66, 0x39, 0x31, 0x64, 0x64, 0x36, 0x34, 0x39, 0x38, 0x32, 0x35, 0x30, 0x38, 0x33, 0x36, 0x30, 0x32, 0x63, 0x31, 0x66, 0x39, 0x62, 0x33, 0x38, 0x36, 0x37, 0x31, 0x32, 0x33, 0x30, 0x61, 0x63, 0x38, 0x33, 0x65, 0x63, 0x61, 0x39, 0x64, 0x35, 0x65, 0x34, 0x62, 0x33, 0x33, 0x39, 0x65, 0x39, 0x38, 0x32, 0x65, 0x39, 0x30, 0x35, 0x30, 0x30, 0x63, 0x64, 0x34, 0x62, 0x61, 0x32, 0x33, 0x61, 0x36, 0x34, 0x33, 0x35, 0x65, 0x32, 0x63, 0x62, 0x39, 0x37, 0x32, 0x32, 0x32, 0x63, 0x31, 0x61, 0x34, 0x63, 0x38, 0x32, 0x62, 0x32, 0x36, 0x37, 0x35, 0x31, 0x63, 0x30, 0x36, 0x33, 0x36, 0x32, 0x61, 0x32, 0x39, 0x61, 0x31, 0x36, 0x62, 0x62, 0x34, 0x33, 0x63, 0x31, 0x39, 0x62, 0x31, 0x31, 0x64, 0x36, 0x62, 0x64, 0x65, 0x38, 0x64, 0x32, 0x33, 0x63, 0x61, 0x34, 0x30, 0x65, 0x64, 0x66, 0x36, 0x35, 0x32, 0x33, 0x38, 0x64, 0x35, 0x36, 0x34, 0x37, 0x32, 0x63, 0x65, 0x65, 0x66, 0x33, 0x31, 0x39, 0x34, 0x37, 0x30, 0x66, 0x39, 0x66, 0x62, 0x63, 0x35, 0x35, 0x30, 0x61, 0x38, 0x65, 0x33, 0x32, 0x36, 0x37, 0x62, 0x30, 0x31, 0x63, 0x34, 0x66, 0x61, 0x65, 0x31, 0x62, 0x31, 0x61, 0x35, 0x66, 0x39, 0x35, 0x34, 0x36, 0x66, 0x34, 0x34, 0x37, 0x66, 0x66, 0x35, 0x37, 0x65, 0x61, 0x32, 0x34, 0x64, 0x36, 0x39, 0x33, 0x32, 0x62, 0x33, 0x37, 0x32, 0x32, 0x30, 0x62, 0x65, 0x66, 0x36, 0x36, 0x63, 0x31, 0x63, 0x32, 0x63, 0x30, 0x65, 0x30, 0x64, 0x31, 0x39, 0x66, 0x34, 0x64, 0x66, 0x39, 0x39, 0x37, 0x65, 0x39, 0x61, 0x38, 0x32, 0x35, 0x62, 0x32, 0x30, 0x63, 0x31, 0x34, 0x63, 0x37, 0x33, 0x35, 0x62, 0x33, 0x33, 0x63, 0x33, 0x62, 0x30, 0x38, 0x65, 0x62, 0x30, 0x30, 0x64, 0x65, 0x66, 0x31, 0x62, 0x32, 0x36, 0x33, 0x33, 0x37, 0x32, 0x37, 0x31, 0x37, 0x38, 0x32, 0x62, 0x64, 0x62, 0x63, 0x34, 0x61, 0x63, 0x65, 0x66, 0x33, 0x32, 0x37, 0x64, 0x36, 0x35, 0x64, 0x64, 0x66, 0x63, 0x39, 0x61, 0x65, 0x66, 0x32, 0x38, 0x38, 0x61, 0x61, 0x64, 0x35, 0x31, 0x37, 0x64, 0x34, 0x63, 0x35, 0x62, 0x32, 0x34, 0x34, 0x61, 0x37, 0x64, 0x66, 0x65, 0x32, 0x31, 0x30, 0x30, 0x66, 0x38, 0x39, 0x62, 0x34, 0x64, 0x35, 0x63, 0x37, 0x32, 0x37, 0x34, 0x38, 0x36, 0x64, 0x64, 0x64, 0x38, 0x32, 0x39, 0x66, 0x66, 0x61, 0x62, 0x34, 0x38, 0x37, 0x33, 0x34, 0x39, 0x62, 0x62, 0x38, 0x62, 0x63, 0x34, 0x37, 0x62, 0x36, 0x62, 0x30, 0x39, 0x37, 0x64, 0x64, 0x32, 0x31, 0x39, 0x33, 0x65, 0x37, 0x36, 0x32, 0x66, 0x65, 0x65, 0x64, 0x32, 0x36, 0x64, 0x31, 0x32, 0x38, 0x37, 0x62, 0x31, 0x37, 0x39, 0x33, 0x34, 0x38, 0x37, 0x37, 0x32, 0x35, 0x33, 0x65, 0x32, 0x65, 0x34, 0x39, 0x35, 0x38, 0x35, 0x34, 0x33, 0x32, 0x36, 0x33, 0x31, 0x30, 0x65, 0x62, 0x64, 0x36, 0x66, 0x39, 0x38, 0x64, 0x31, 0x32, 0x36, 0x34, 0x64, 0x36, 0x65, 0x61, 0x65, 0x38, 0x38, 0x39, 0x33, 0x35, 0x65, 0x32, 0x39, 0x36, 0x36, 0x61, 0x61, 0x39, 0x65, 0x39, 0x64, 0x32, 0x34, 0x38, 0x36, 0x37, 0x64, 0x33, 0x35, 0x62, 0x38, 0x61, 0x61, 0x33, 0x38, 0x39, 0x31, 0x31, 0x62, 0x35, 0x66, 0x36, 0x66, 0x63, 0x66, 0x65, 0x63, 0x62, 0x34, 0x39, 0x63, 0x33, 0x61, 0x33, 0x62, 0x31, 0x64, 0x30, 0x32, 0x35, 0x36, 0x61, 0x61, 0x34, 0x66, 0x36, 0x34, 0x64, 0x38, 0x33, 0x34, 0x61, 0x33, 0x31, 0x38, 0x63, 0x38, 0x37, 0x65, 0x31, 0x66, 0x36, 0x63, 0x32, 0x65, 0x33, 0x37, 0x36, 0x39, 0x36, 0x62, 0x36, 0x64, 0x34, 0x66, 0x61, 0x30, 0x37, 0x32, 0x62, 0x38, 0x31, 0x61, 0x36, 0x34, 0x63, 0x33, 0x35, 0x38, 0x32, 0x34, 0x63, 0x62, 0x63, 0x35, 0x62, 0x61, 0x39, 0x38, 0x33, 0x65, 0x34, 0x38, 0x35, 0x30, 0x61, 0x62, 0x33, 0x61, 0x64, 0x61, 0x64, 0x65, 0x66, 0x39, 0x37, 0x62, 0x33, 0x64, 0x63, 0x38, 0x64, 0x38, 0x34, 0x33, 0x64, 0x35, 0x38, 0x64, 0x61, 0x33, 0x31, 0x63, 0x36, 0x36, 0x36, 0x65, 0x35, 0x37, 0x63, 0x64, 0x37, 0x32, 0x66, 0x64, 0x36, 0x35, 0x36, 0x31, 0x39, 0x62, 0x39, 0x37, 0x64, 0x35, 0x38, 0x38, 0x31, 0x64, 0x38, 0x31, 0x37, 0x33, 0x36, 0x30, 0x61, 0x33, 0x39, 0x39, 0x35, 0x64, 0x65, 0x36, 0x31, 0x31, 0x37, 0x36, 0x30, 0x65, 0x39, 0x64, 0x66, 0x33, 0x30, 0x62, 0x39, 0x61, 0x37, 0x66, 0x36, 0x62, 0x61, 0x66, 0x37, 0x34, 0x32, 0x32, 0x63, 0x64, 0x30, 0x64, 0x66, 0x66, 0x63, 0x30, 0x37, 0x32, 0x35, 0x62, 0x66, 0x65, 0x65, 0x65, 0x35, 0x31, 0x34, 0x62, 0x36, 0x37, 0x33, 0x36, 0x39, 0x66, 0x30, 0x63, 0x36, 0x66, 0x66, 0x37, 0x35, 0x61, 0x36, 0x61, 0x31, 0x37, 0x39, 0x39, 0x39, 0x39, 0x30, 0x35, 0x33, 0x63, 0x35, 0x63, 0x39, 0x61, 0x32, 0x33, 0x66, 0x65, 0x32, 0x37, 0x62, 0x65, 0x37, 0x30, 0x62, 0x65, 0x34, 0x30, 0x63, 0x64, 0x32, 0x66, 0x62, 0x39, 0x37, 0x30, 0x37, 0x32, 0x33, 0x62, 0x62, 0x39, 0x35, 0x65, 0x62, 0x36, 0x37, 0x64, 0x31, 0x35, 0x61, 0x62, 0x36, 0x64, 0x30, 0x34, 0x31, 0x64, 0x36, 0x39, 0x30, 0x36, 0x38, 0x39, 0x34, 0x37, 0x61, 0x63, 0x33, 0x65, 0x36, 0x34, 0x34, 0x65, 0x66, 0x35, 0x63, 0x65, 0x31, 0x31, 0x61, 0x33, 0x64, 0x64, 0x32, 0x32, 0x37, 0x37, 0x37, 0x33, 0x38, 0x37, 0x62, 0x30, 0x36, 0x38, 0x61, 0x34, 0x39, 0x33, 0x31, 0x32, 0x65, 0x62, 0x65, 0x62, 0x31, 0x30, 0x31, 0x63, 0x38, 0x30, 0x62, 0x30, 0x31, 0x39, 0x37, 0x30, 0x33, 0x62, 0x39, 0x66, 0x66, 0x63, 0x30, 0x32, 0x64, 0x62, 0x61, 0x61, 0x39, 0x36, 0x35, 0x63, 0x36, 0x63, 0x31, 0x35, 0x64, 0x32, 0x61, 0x32, 0x36, 0x34, 0x35, 0x32, 0x34, 0x62, 0x66, 0x61, 0x33, 0x35, 0x36, 0x36, 0x32, 0x65, 0x39, 0x39, 0x62, 0x32, 0x36, 0x66, 0x65, 0x61, 0x34, 0x35, 0x31, 0x38, 0x36, 0x35, 0x37, 0x37, 0x64, 0x64, 0x39, 0x64, 0x30, 0x61, 0x32, 0x33, 0x35, 0x31, 0x34, 0x34, 0x35, 0x62, 0x37, 0x39, 0x30, 0x61, 0x65, 0x33, 0x30, 0x30, 0x66, 0x64, 0x39, 0x64, 0x62, 0x35, 0x63, 0x62, 0x61, 0x31, 0x66, 0x31, 0x66, 0x62, 0x32, 0x62, 0x62, 0x63, 0x65, 0x34, 0x37, 0x30, 0x66, 0x61, 0x31, 0x62, 0x31, 0x61, 0x37, 0x65, 0x39, 0x64, 0x64, 0x38, 0x37, 0x32, 0x66, 0x38, 0x39, 0x34, 0x36, 0x38, 0x65, 0x30, 0x30, 0x66, 0x62, 0x33, 0x30, 0x37, 0x39, 0x33, 0x66, 0x31, 0x39, 0x63, 0x34, 0x39, 0x63, 0x63, 0x65, 0x35, 0x36, 0x38, 0x65, 0x66, 0x64, 0x65, 0x32, 0x31, 0x31, 0x32, 0x66, 0x61, 0x31, 0x64, 0x38, 0x33, 0x64, 0x63, 0x35, 0x39, 0x31, 0x36, 0x61, 0x66, 0x33, 0x37, 0x33, 0x61, 0x62, 0x65, 0x64, 0x64, 0x31, 0x63, 0x39, 0x33, 0x32, 0x39, 0x37, 0x62, 0x33, 0x34, 0x65, 0x63, 0x35, 0x66, 0x37, 0x33, 0x35, 0x62, 0x34, 0x38, 0x35, 0x65, 0x64, 0x34, 0x38, 0x38, 0x38, 0x65, 0x30, 0x39, 0x33, 0x31, 0x39, 0x61, 0x37, 0x33, 0x65, 0x65, 0x66, 0x38, 0x36, 0x61, 0x36, 0x38, 0x37, 0x35, 0x34, 0x30, 0x64, 0x33, 0x32, 0x34, 0x34, 0x36, 0x35, 0x66, 0x39, 0x65, 0x61, 0x33, 0x38, 0x31, 0x35, 0x65, 0x39, 0x62, 0x33, 0x62, 0x37, 0x32, 0x30, 0x64, 0x62, 0x63, 0x39, 0x61, 0x30, 0x62, 0x61, 0x30, 0x37, 0x32, 0x61, 0x37, 0x35, 0x63, 0x34, 0x34, 0x37, 0x65, 0x31, 0x36, 0x32, 0x33, 0x32, 0x33, 0x36, 0x61, 0x38, 0x62, 0x39, 0x38, 0x32, 0x33, 0x62, 0x62, 0x38, 0x39, 0x65, 0x32, 0x63, 0x38, 0x32, 0x64, 0x30, 0x65, 0x61, 0x36, 0x62, 0x36, 0x38, 0x30, 0x39, 0x33, 0x38, 0x34, 0x33, 0x32, 0x39, 0x61, 0x65, 0x30, 0x37, 0x32, 0x37, 0x31, 0x63, 0x66, 0x35, 0x62, 0x36, 0x64, 0x34, 0x62, 0x65, 0x35, 0x38, 0x61, 0x63, 0x62, 0x33, 0x38, 0x35, 0x37, 0x64, 0x62, 0x34, 0x66, 0x34, 0x63, 0x66, 0x61, 0x36, 0x36, 0x33, 0x66, 0x36, 0x66, 0x37, 0x33, 0x36, 0x64, 0x34, 0x33, 0x39, 0x36, 0x32, 0x63, 0x62, 0x62, 0x37, 0x32, 0x33, 0x30, 0x65, 0x62, 0x30, 0x61, 0x39, 0x38, 0x33, 0x62, 0x38, 0x37, 0x34, 0x38, 0x30, 0x64, 0x30, 0x30, 0x32, 0x36, 0x37, 0x63, 0x35, 0x30, 0x38, 0x35, 0x34, 0x30, 0x34, 0x32, 0x39, 0x66, 0x31, 0x64, 0x62, 0x61, 0x63, 0x38, 0x62, 0x62, 0x36, 0x66, 0x30, 0x65, 0x35, 0x63, 0x31, 0x61, 0x30, 0x36, 0x61, 0x62, 0x33, 0x33, 0x38, 0x63, 0x30, 0x63, 0x38, 0x61, 0x36, 0x65, 0x38, 0x32, 0x30, 0x30, 0x35, 0x32, 0x30, 0x65, 0x61, 0x36, 0x34, 0x37, 0x62, 0x32, 0x38, 0x63, 0x34, 0x35, 0x62, 0x35, 0x37, 0x37, 0x36, 0x34, 0x36, 0x31, 0x31, 0x62, 0x35, 0x37, 0x65, 0x32, 0x31, 0x34, 0x33, 0x61, 0x61, 0x64, 0x33, 0x63, 0x32, 0x65, 0x66, 0x66, 0x61, 0x32, 0x31, 0x33, 0x39, 0x36, 0x33, 0x62, 0x37, 0x66, 0x37, 0x66, 0x62, 0x33, 0x38, 0x35, 0x61, 0x39, 0x66, 0x66, 0x30, 0x30, 0x35, 0x61, 0x35, 0x37, 0x38, 0x66, 0x65, 0x33, 0x36, 0x63, 0x38, 0x62, 0x33, 0x37, 0x34, 0x66, 0x31, 0x36, 0x37, 0x31, 0x38, 0x62, 0x64, 0x66, 0x66, 0x36, 0x34, 0x63, 0x35, 0x36, 0x63, 0x64, 0x36, 0x37, 0x63, 0x30, 0x39, 0x32, 0x62, 0x65, 0x37, 0x66, 0x35, 0x37, 0x34, 0x38, 0x66, 0x39, 0x34, 0x65, 0x62, 0x32, 0x31, 0x37, 0x30, 0x65, 0x66, 0x39, 0x61, 0x62, 0x34, 0x34, 0x39, 0x35, 0x64, 0x35, 0x34, 0x35, 0x37, 0x38, 0x35, 0x62, 0x35, 0x62, 0x62, 0x37, 0x37, 0x65, 0x35, 0x32, 0x37, 0x32, 0x32, 0x30, 0x34, 0x38, 0x62, 0x38, 0x38, 0x38, 0x66, 0x66, 0x33, 0x38, 0x32, 0x33, 0x62, 0x32, 0x61, 0x33, 0x38, 0x62, 0x66, 0x39, 0x62, 0x33, 0x35, 0x32, 0x32, 0x38, 0x37, 0x35, 0x66, 0x63, 0x31, 0x36, 0x34, 0x38, 0x33, 0x63, 0x66, 0x31, 0x65, 0x37, 0x38, 0x37, 0x37, 0x65, 0x38, 0x32, 0x37, 0x65, 0x30, 0x39, 0x34, 0x30, 0x34, 0x37, 0x63, 0x30, 0x39, 0x31, 0x37, 0x32, 0x66, 0x66, 0x39, 0x62, 0x63, 0x64, 0x63, 0x31, 0x36, 0x31, 0x63, 0x33, 0x62, 0x34, 0x66, 0x63, 0x33, 0x35, 0x64, 0x37, 0x65, 0x36, 0x37, 0x63, 0x66, 0x39, 0x35, 0x33, 0x31, 0x64, 0x30, 0x66, 0x65, 0x64, 0x39, 0x62, 0x63, 0x35, 0x30, 0x66, 0x30, 0x39, 0x31, 0x34, 0x66, 0x66, 0x36, 0x30, 0x30, 0x32, 0x38, 0x33, 0x31, 0x39, 0x34, 0x37, 0x31, 0x35, 0x65, 0x62, 0x36, 0x62, 0x34, 0x63, 0x35, 0x66, 0x31, 0x65, 0x63, 0x65, 0x61, 0x39, 0x62, 0x66, 0x63, 0x63, 0x36, 0x31, 0x62, 0x37, 0x33, 0x34, 0x34, 0x38, 0x33, 0x32, 0x31, 0x35, 0x30, 0x65, 0x36, 0x63, 0x66, 0x63, 0x31, 0x63, 0x39, 0x63, 0x30, 0x39, 0x35, 0x34, 0x32, 0x34, 0x65, 0x32, 0x33, 0x64, 0x65, 0x39, 0x32, 0x66, 0x31, 0x62, 0x61, 0x37, 0x65, 0x31, 0x63, 0x63, 0x30, 0x33, 0x62, 0x33, 0x66, 0x36, 0x37, 0x32, 0x61, 0x30, 0x36, 0x64, 0x33, 0x64, 0x30, 0x37, 0x62, 0x64, 0x34, 0x65, 0x31, 0x38, 0x34, 0x66, 0x35, 0x32, 0x32, 0x30, 0x36, 0x32, 0x33, 0x37, 0x34, 0x30, 0x30, 0x65, 0x66, 0x65, 0x38, 0x36, 0x62, 0x36, 0x62, 0x36, 0x33, 0x35, 0x65, 0x64, 0x34, 0x30, 0x63, 0x34, 0x63, 0x66, 0x38, 0x30, 0x61, 0x65, 0x30, 0x33, 0x62, 0x35, 0x32, 0x30, 0x64, 0x63, 0x66, 0x66, 0x31, 0x32, 0x37, 0x32, 0x64, 0x39, 0x33, 0x38, 0x65, 0x38, 0x66, 0x30, 0x63, 0x34, 0x62, 0x33, 0x36, 0x35, 0x38, 0x62, 0x39, 0x32, 0x37, 0x35, 0x61, 0x63, 0x34, 0x37, 0x61, 0x61, 0x35, 0x64, 0x32, 0x35, 0x65, 0x37, 0x31, 0x66, 0x33, 0x38, 0x33, 0x39, 0x66, 0x39, 0x32, 0x64, 0x64, 0x62, 0x66, 0x31, 0x31, 0x30, 0x62, 0x38, 0x38, 0x61, 0x33, 0x65, 0x62, 0x35, 0x34, 0x39, 0x38, 0x30, 0x63, 0x66, 0x37, 0x32, 0x62, 0x66, 0x32, 0x62, 0x34, 0x39, 0x30, 0x32, 0x62, 0x31, 0x66, 0x34, 0x33, 0x36, 0x35, 0x66, 0x63, 0x62, 0x66, 0x37, 0x33, 0x35, 0x64, 0x39, 0x32, 0x30, 0x61, 0x37, 0x36, 0x64, 0x33, 0x64, 0x37, 0x61, 0x62, 0x63, 0x65, 0x33, 0x37, 0x36, 0x39, 0x39, 0x64, 0x36, 0x32, 0x34, 0x39, 0x35, 0x63, 0x34, 0x30, 0x35, 0x63, 0x38, 0x62, 0x37, 0x66, 0x65, 0x32, 0x33, 0x63, 0x66, 0x35, 0x65, 0x30, 0x39, 0x37, 0x37, 0x63, 0x34, 0x37, 0x64, 0x34, 0x36, 0x32, 0x64, 0x63, 0x34, 0x36, 0x30, 0x64, 0x39, 0x31, 0x38, 0x33, 0x34, 0x62, 0x34, 0x61, 0x30, 0x66, 0x39, 0x32, 0x33, 0x33, 0x32, 0x32, 0x39, 0x39, 0x33, 0x39, 0x63, 0x36, 0x66, 0x36, 0x62, 0x66, 0x31, 0x38, 0x61, 0x39, 0x38, 0x66, 0x63, 0x63, 0x35, 0x33, 0x35, 0x66, 0x36, 0x64, 0x32, 0x38, 0x33, 0x34, 0x31, 0x35, 0x65, 0x33, 0x38, 0x36, 0x64, 0x30, 0x37, 0x66, 0x62, 0x37, 0x33, 0x33, 0x38, 0x37, 0x62, 0x62, 0x66, 0x63, 0x30, 0x62, 0x65, 0x65, 0x37, 0x36, 0x33, 0x61, 0x37, 0x33, 0x32, 0x63, 0x32, 0x38, 0x61, 0x61, 0x64, 0x38, 0x32, 0x31, 0x62, 0x64, 0x32, 0x38, 0x65, 0x38, 0x38, 0x36, 0x65, 0x65, 0x31, 0x66, 0x61, 0x61, 0x36, 0x33, 0x30, 0x31, 0x61, 0x35, 0x37, 0x38, 0x63, 0x63, 0x65, 0x30, 0x31, 0x61, 0x63, 0x31, 0x63, 0x38, 0x34, 0x34, 0x38, 0x34, 0x66, 0x31, 0x36, 0x61, 0x38, 0x66, 0x33, 0x30, 0x66, 0x62, 0x35, 0x39, 0x62, 0x37, 0x62, 0x38, 0x32, 0x30, 0x63, 0x37, 0x64, 0x65, 0x32, 0x33, 0x62, 0x33, 0x33, 0x61, 0x33, 0x66, 0x34, 0x37, 0x38, 0x38, 0x36, 0x38, 0x35, 0x31, 0x64, 0x61, 0x64, 0x31, 0x34, 0x35, 0x62, 0x61, 0x63, 0x32, 0x64, 0x38, 0x30, 0x38, 0x32, 0x37, 0x32, 0x62, 0x66, 0x62, 0x34, 0x33, 0x35, 0x61, 0x33, 0x35, 0x37, 0x38, 0x31, 0x35, 0x63, 0x64, 0x64, 0x65, 0x31, 0x36, 0x63, 0x31, 0x32, 0x63, 0x34, 0x66, 0x39, 0x62, 0x62, 0x66, 0x64, 0x30, 0x38, 0x30, 0x62, 0x66, 0x39, 0x65, 0x37, 0x31, 0x32, 0x64, 0x64, 0x35, 0x34, 0x62, 0x64, 0x62, 0x66, 0x30, 0x62, 0x37, 0x36, 0x64, 0x64, 0x66, 0x31, 0x33, 0x33, 0x31, 0x39, 0x36, 0x33, 0x37, 0x32, 0x64, 0x31, 0x39, 0x36, 0x32, 0x32, 0x31, 0x66, 0x32, 0x64, 0x36, 0x38, 0x38, 0x34, 0x30, 0x66, 0x30, 0x39, 0x30, 0x34, 0x34, 0x64, 0x32, 0x62, 0x33, 0x64, 0x64, 0x38, 0x63, 0x34, 0x35, 0x30, 0x65, 0x30, 0x35, 0x34, 0x35, 0x66, 0x39, 0x63, 0x38, 0x30, 0x61, 0x39, 0x61, 0x37, 0x35, 0x61, 0x31, 0x39, 0x37, 0x65, 0x38, 0x61, 0x66, 0x64, 0x30, 0x62, 0x61, 0x33, 0x63, 0x33, 0x36, 0x33, 0x65, 0x35, 0x65, 0x64, 0x61, 0x37, 0x37, 0x30, 0x39, 0x63, 0x65, 0x62, 0x39, 0x34, 0x33, 0x34, 0x34, 0x31, 0x64, 0x37, 0x63, 0x38, 0x37, 0x31, 0x61, 0x31, 0x61, 0x36, 0x31, 0x66, 0x32, 0x65, 0x31, 0x34, 0x30, 0x61, 0x62, 0x62, 0x39, 0x31, 0x66, 0x30, 0x34, 0x39, 0x35, 0x31, 0x33, 0x39, 0x39, 0x36, 0x34, 0x35, 0x37, 0x61, 0x61, 0x32, 0x63, 0x62, 0x31, 0x33, 0x32, 0x63, 0x36, 0x64, 0x61, 0x36, 0x35, 0x32, 0x30, 0x65, 0x64, 0x32, 0x32, 0x35, 0x38, 0x31, 0x61, 0x30, 0x34, 0x39, 0x30, 0x30, 0x34, 0x33, 0x61, 0x34, 0x33, 0x39, 0x35, 0x33, 0x63, 0x39, 0x61, 0x65, 0x64, 0x32, 0x39, 0x65, 0x65, 0x66, 0x66, 0x35, 0x36, 0x37, 0x34, 0x34, 0x37, 0x66, 0x65, 0x33, 0x39, 0x31, 0x63, 0x61, 0x61, 0x38, 0x33, 0x38, 0x33, 0x32, 0x38, 0x35, 0x30, 0x64, 0x30, 0x30, 0x34, 0x62, 0x38, 0x32, 0x30, 0x62, 0x30, 0x38, 0x37, 0x63, 0x62, 0x31, 0x36, 0x64, 0x33, 0x64, 0x38, 0x36, 0x31, 0x33, 0x36, 0x61, 0x38, 0x64, 0x33, 0x39, 0x31, 0x32, 0x63, 0x31, 0x64, 0x33, 0x38, 0x61, 0x36, 0x34, 0x37, 0x61, 0x34, 0x34, 0x65, 0x39, 0x34, 0x33, 0x63, 0x66, 0x32, 0x30, 0x38, 0x38, 0x36, 0x37, 0x39, 0x31, 0x39, 0x35, 0x30, 0x36, 0x65, 0x30, 0x38, 0x65, 0x34, 0x38, 0x37, 0x32, 0x32, 0x65, 0x63, 0x62, 0x33, 0x39, 0x39, 0x64, 0x34, 0x63, 0x66, 0x34, 0x61, 0x34, 0x32, 0x33, 0x65, 0x63, 0x37, 0x61, 0x32, 0x38, 0x37, 0x62, 0x32, 0x36, 0x37, 0x65, 0x36, 0x32, 0x39, 0x30, 0x32, 0x35, 0x37, 0x63, 0x64, 0x30, 0x37, 0x39, 0x36, 0x37, 0x36, 0x31, 0x36, 0x65, 0x34, 0x33, 0x35, 0x30, 0x35, 0x64, 0x62, 0x35, 0x38, 0x35, 0x61, 0x65, 0x34, 0x63, 0x39, 0x35, 0x37, 0x32, 0x34, 0x31, 0x30, 0x36, 0x63, 0x31, 0x65, 0x65, 0x32, 0x63, 0x32, 0x34, 0x30, 0x66, 0x63, 0x35, 0x31, 0x36, 0x30, 0x35, 0x30, 0x65, 0x63, 0x31, 0x31, 0x36, 0x62, 0x63, 0x33, 0x37, 0x35, 0x31, 0x61, 0x65, 0x39, 0x65, 0x64, 0x34, 0x63, 0x63, 0x65, 0x34, 0x34, 0x32, 0x64, 0x30, 0x34, 0x61, 0x63, 0x62, 0x66, 0x39, 0x36, 0x31, 0x37, 0x66, 0x31, 0x39, 0x36, 0x63, 0x33, 0x66, 0x33, 0x39, 0x38, 0x38, 0x32, 0x65, 0x32, 0x30, 0x34, 0x62, 0x30, 0x37, 0x36, 0x61, 0x31, 0x33, 0x64, 0x38, 0x61, 0x39, 0x36, 0x62, 0x33, 0x34, 0x38, 0x36, 0x31, 0x33, 0x34, 0x63, 0x34, 0x31, 0x63, 0x35, 0x66, 0x38, 0x63, 0x39, 0x36, 0x61, 0x37, 0x65, 0x64, 0x39, 0x35, 0x32, 0x32, 0x35, 0x38, 0x31, 0x66, 0x34, 0x30, 0x38, 0x64, 0x37, 0x63, 0x34, 0x35, 0x66, 0x61, 0x36, 0x61, 0x32, 0x31, 0x38, 0x39, 0x63, 0x61, 0x38, 0x66, 0x63, 0x61, 0x37, 0x62, 0x31, 0x39, 0x38, 0x34, 0x39, 0x61, 0x64, 0x37, 0x33, 0x35, 0x34, 0x36, 0x34, 0x66, 0x37, 0x37, 0x32, 0x63, 0x61, 0x62, 0x64, 0x35, 0x39, 0x65, 0x32, 0x37, 0x63, 0x64, 0x31, 0x65, 0x64, 0x62, 0x62, 0x37, 0x35, 0x37, 0x39, 0x64, 0x65, 0x66, 0x39, 0x36, 0x38, 0x33, 0x33, 0x66, 0x30, 0x63, 0x39, 0x37, 0x61, 0x31, 0x31, 0x37, 0x32, 0x30, 0x64, 0x35, 0x35, 0x37, 0x30, 0x32, 0x65, 0x37, 0x61, 0x34, 0x65, 0x64, 0x39, 0x38, 0x37, 0x64, 0x38, 0x62, 0x62, 0x65, 0x65, 0x64, 0x31, 0x36, 0x34, 0x63, 0x34, 0x61, 0x62, 0x35, 0x36, 0x64, 0x39, 0x35, 0x30, 0x35, 0x34, 0x34, 0x35, 0x37, 0x32, 0x30, 0x35, 0x37, 0x30, 0x38, 0x64, 0x38, 0x64, 0x35, 0x32, 0x63, 0x38, 0x32, 0x66, 0x31, 0x32, 0x30, 0x66, 0x35, 0x31, 0x37, 0x32, 0x37, 0x35, 0x33, 0x38, 0x33, 0x61, 0x39, 0x39, 0x62, 0x35, 0x63, 0x65, 0x37, 0x35, 0x30, 0x34, 0x66, 0x30, 0x65, 0x33, 0x66, 0x66, 0x33, 0x62, 0x30, 0x31, 0x62, 0x61, 0x65, 0x63, 0x65, 0x32, 0x36, 0x38, 0x37, 0x30, 0x63, 0x38, 0x34, 0x35, 0x31, 0x66, 0x38, 0x61, 0x36, 0x33, 0x65, 0x39, 0x66, 0x31, 0x32, 0x35, 0x64, 0x64, 0x33, 0x62, 0x32, 0x66, 0x39, 0x64, 0x64, 0x37, 0x36, 0x36, 0x35, 0x30, 0x35, 0x35, 0x38, 0x33, 0x61, 0x34, 0x36, 0x34, 0x65, 0x34, 0x63, 0x36, 0x38, 0x39, 0x65, 0x65, 0x33, 0x30, 0x66, 0x30, 0x63, 0x39, 0x38, 0x64, 0x66, 0x39, 0x66, 0x62, 0x62, 0x38, 0x36, 0x39, 0x31, 0x35, 0x36, 0x36, 0x64, 0x66, 0x36, 0x38, 0x36, 0x64, 0x32, 0x66, 0x61, 0x36, 0x36, 0x35, 0x63, 0x65, 0x32, 0x63, 0x63, 0x64, 0x35, 0x38, 0x66, 0x32, 0x39, 0x35, 0x35, 0x39, 0x65, 0x63, 0x30, 0x37, 0x35, 0x35, 0x38, 0x34, 0x64, 0x30, 0x35, 0x35, 0x35, 0x64, 0x36, 0x37, 0x61, 0x33, 0x65, 0x32, 0x64, 0x34, 0x37, 0x30, 0x31, 0x39, 0x66, 0x30, 0x38, 0x34, 0x61, 0x30, 0x36, 0x32, 0x38, 0x38, 0x34, 0x61, 0x64, 0x63, 0x31, 0x65, 0x37, 0x35, 0x61, 0x30, 0x35, 0x65, 0x38, 0x61, 0x64, 0x31, 0x62, 0x63, 0x31, 0x37, 0x37, 0x30, 0x38, 0x66, 0x30, 0x30, 0x37, 0x32, 0x66, 0x33, 0x34, 0x39, 0x33, 0x31, 0x39, 0x39, 0x31, 0x63, 0x31, 0x65, 0x63, 0x31, 0x36, 0x62, 0x35, 0x61, 0x31, 0x38, 0x61, 0x33, 0x39, 0x31, 0x33, 0x31, 0x33, 0x38, 0x65, 0x39, 0x64, 0x61, 0x35, 0x37, 0x32, 0x39, 0x63, 0x33, 0x63, 0x36, 0x33, 0x39, 0x66, 0x37, 0x64, 0x66, 0x65, 0x33, 0x66, 0x63, 0x39, 0x35, 0x33, 0x64, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x36, 0x38, 0x37, 0x32, 0x63, 0x63, 0x39, 0x65, 0x36, 0x37, 0x34, 0x64, 0x35, 0x33, 0x39, 0x62, 0x62, 0x61, 0x30, 0x31, 0x36, 0x38, 0x39, 0x39, 0x35, 0x36, 0x66, 0x32, 0x65, 0x65, 0x62, 0x63, 0x35, 0x63, 0x37, 0x63, 0x63, 0x64, 0x33, 0x65, 0x66, 0x39, 0x37, 0x61, 0x62, 0x37, 0x34, 0x65, 0x32, 0x65, 0x33, 0x65, 0x38, 0x61, 0x33, 0x37, 0x37, 0x64, 0x33, 0x39, 0x64, 0x37, 0x64, 0x30, 0x34, 0x36, 0x35, 0x61, 0x39, 0x62, 0x64, 0x36, 0x34, 0x66, 0x61, 0x37, 0x63, 0x32, 0x31, 0x38, 0x63, 0x64, 0x35, 0x66, 0x61, 0x31, 0x31, 0x37, 0x32, 0x63, 0x32, 0x30, 0x36, 0x35, 0x38, 0x35, 0x34, 0x61, 0x62, 0x37, 0x34, 0x35, 0x31, 0x33, 0x33, 0x33, 0x32, 0x33, 0x35, 0x64, 0x34, 0x63, 0x32, 0x36, 0x32, 0x35, 0x66, 0x64, 0x65, 0x63, 0x38, 0x34, 0x32, 0x63, 0x64, 0x37, 0x61, 0x66, 0x31, 0x37, 0x36, 0x32, 0x64, 0x64, 0x61, 0x62, 0x61, 0x30, 0x39, 0x38, 0x30, 0x32, 0x36, 0x39, 0x38, 0x34, 0x37, 0x36, 0x34, 0x38, 0x33, 0x37, 0x32, 0x35, 0x61, 0x33, 0x35, 0x61, 0x61, 0x32, 0x66, 0x34, 0x39, 0x63, 0x63, 0x33, 0x35, 0x33, 0x39, 0x30, 0x32, 0x35, 0x34, 0x64, 0x65, 0x64, 0x61, 0x32, 0x39, 0x65, 0x34, 0x65, 0x32, 0x32, 0x38, 0x36, 0x35, 0x34, 0x39, 0x32, 0x61, 0x31, 0x39, 0x32, 0x37, 0x32, 0x61, 0x34, 0x36, 0x35, 0x65, 0x38, 0x34, 0x65, 0x37, 0x34, 0x66, 0x38, 0x32, 0x30, 0x35, 0x66, 0x31, 0x32, 0x35, 0x64, 0x32, 0x63, 0x65, 0x34, 0x30, 0x33, 0x38, 0x30, 0x34, 0x37, 0x39, 0x38, 0x39, 0x31, 0x66, 0x31, 0x32, 0x61, 0x65, 0x39, 0x61, 0x65, 0x32, 0x63, 0x36, 0x65, 0x31, 0x35, 0x31, 0x39, 0x30, 0x65, 0x36, 0x33, 0x61, 0x33, 0x30, 0x30, 0x63, 0x31, 0x30, 0x63, 0x34, 0x33, 0x32, 0x35, 0x34, 0x66, 0x62, 0x65, 0x61, 0x30, 0x38, 0x31, 0x36, 0x33, 0x33, 0x65, 0x35, 0x30, 0x31, 0x36, 0x34, 0x33, 0x64, 0x33, 0x32, 0x61, 0x33, 0x38, 0x30, 0x38, 0x63, 0x33, 0x65, 0x32, 0x38, 0x35, 0x30, 0x37, 0x62, 0x61, 0x30, 0x37, 0x32, 0x31, 0x64, 0x63, 0x33, 0x61, 0x63, 0x38, 0x30, 0x65, 0x65, 0x32, 0x37, 0x31, 0x39, 0x32, 0x66, 0x30, 0x62, 0x63, 0x35, 0x34, 0x37, 0x32, 0x31, 0x30, 0x32, 0x39, 0x64, 0x39, 0x64, 0x30, 0x66, 0x61, 0x63, 0x32, 0x33, 0x38, 0x37, 0x66, 0x36, 0x36, 0x66, 0x32, 0x62, 0x62, 0x36, 0x39, 0x39, 0x30, 0x38, 0x34, 0x63, 0x36, 0x36, 0x31, 0x66, 0x36, 0x64, 0x62, 0x62, 0x66, 0x64, 0x31, 0x63, 0x33, 0x61, 0x65, 0x62, 0x66, 0x37, 0x30, 0x33, 0x31, 0x66, 0x39, 0x62, 0x36, 0x64, 0x36, 0x31, 0x35, 0x32, 0x61, 0x61, 0x64, 0x30, 0x33, 0x63, 0x33, 0x38, 0x66, 0x36, 0x66, 0x66, 0x38, 0x35, 0x30, 0x33, 0x65, 0x63, 0x62, 0x39, 0x39, 0x61, 0x31, 0x36, 0x35, 0x64, 0x30, 0x64, 0x38, 0x31, 0x30, 0x65, 0x39, 0x38, 0x39, 0x61, 0x65, 0x38, 0x62, 0x62, 0x38, 0x30, 0x37, 0x65, 0x64, 0x32, 0x37, 0x30, 0x36, 0x32, 0x33, 0x63, 0x37, 0x30, 0x35, 0x62, 0x66, 0x34, 0x62, 0x65, 0x64, 0x35, 0x32, 0x34, 0x32, 0x66, 0x38, 0x37, 0x32, 0x66, 0x63, 0x64, 0x39, 0x30, 0x62, 0x63, 0x65, 0x37, 0x61, 0x35, 0x32, 0x31, 0x37, 0x36, 0x30, 0x61, 0x37, 0x36, 0x64, 0x36, 0x66, 0x64, 0x66, 0x33, 0x65, 0x31, 0x65, 0x64, 0x35, 0x62, 0x62, 0x33, 0x62, 0x66, 0x38, 0x38, 0x36, 0x61, 0x35, 0x30, 0x66, 0x38, 0x37, 0x30, 0x33, 0x37, 0x36, 0x64, 0x36, 0x39, 0x35, 0x33, 0x31, 0x64, 0x64, 0x63, 0x38, 0x64, 0x62, 0x31, 0x38, 0x22, 0x5d, 0x7d, 0x2c, 0x22, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x34, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x4f, 0x62, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x72, 0x61, 0x67, 0x75, 0x65, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x34, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x39, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x65, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x20, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x34, 0x38, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x20, 0x66, 0x6c, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x31, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x35, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x34, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x66, 0x61, 0x35, 0x64, 0x64, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x32, 0x37, 0x32, 0x30, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x61, 0x64, 0x32, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x32, 0x35, 0x36, 0x66, 0x39, 0x39, 0x66, 0x62, 0x38, 0x39, 0x39, 0x63, 0x32, 0x64, 0x65, 0x30, 0x61, 0x65, 0x61, 0x63, 0x30, 0x63, 0x35, 0x61, 0x61, 0x36, 0x61, 0x61, 0x64, 0x36, 0x39, 0x64, 0x65, 0x31, 0x38, 0x38, 0x62, 0x36, 0x61, 0x30, 0x66, 0x34, 0x61, 0x63, 0x32, 0x39, 0x66, 0x32, 0x64, 0x30, 0x37, 0x35, 0x61, 0x35, 0x33, 0x61, 0x61, 0x33, 0x65, 0x64, 0x30, 0x65, 0x34, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x38, 0x30, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x30, 0x31, 0x61, 0x30, 0x38, 0x34, 0x30, 0x36, 0x35, 0x30, 0x61, 0x61, 0x38, 0x66, 0x37, 0x34, 0x64, 0x32, 0x62, 0x30, 0x37, 0x66, 0x34, 0x30, 0x30, 0x36, 0x37, 0x64, 0x63, 0x33, 0x33, 0x62, 0x37, 0x31, 0x35, 0x30, 0x37, 0x38, 0x64, 0x37, 0x33, 0x34, 0x32, 0x32, 0x66, 0x30, 0x31, 0x64, 0x61, 0x31, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x31, 0x31, 0x65, 0x30, 0x32, 0x62, 0x62, 0x64, 0x66, 0x64, 0x61, 0x39, 0x61, 0x30, 0x34, 0x62, 0x32, 0x32, 0x36, 0x30, 0x66, 0x36, 0x30, 0x32, 0x32, 0x62, 0x66, 0x35, 0x33, 0x65, 0x61, 0x64, 0x62, 0x33, 0x33, 0x37, 0x62, 0x33, 0x65, 0x35, 0x39, 0x35, 0x31, 0x34, 0x39, 0x33, 0x36, 0x66, 0x37, 0x33, 0x31, 0x37, 0x64, 0x38, 0x37, 0x32, 0x64, 0x65, 0x66, 0x62, 0x38, 0x39, 0x31, 0x61, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x37, 0x39, 0x62, 0x64, 0x63, 0x61, 0x39, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x35, 0x32, 0x31, 0x64, 0x35, 0x32, 0x38, 0x61, 0x64, 0x30, 0x63, 0x37, 0x36, 0x30, 0x33, 0x35, 0x34, 0x61, 0x34, 0x66, 0x30, 0x34, 0x39, 0x36, 0x37, 0x37, 0x36, 0x63, 0x66, 0x31, 0x34, 0x61, 0x39, 0x32, 0x66, 0x65, 0x31, 0x66, 0x62, 0x35, 0x64, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x63, 0x65, 0x61, 0x31, 0x61, 0x34, 0x38, 0x39, 0x63, 0x37, 0x63, 0x38, 0x33, 0x31, 0x30, 0x31, 0x61, 0x30, 0x61, 0x38, 0x36, 0x63, 0x31, 0x66, 0x64, 0x38, 0x63, 0x32, 0x65, 0x37, 0x34, 0x38, 0x32, 0x30, 0x36, 0x38, 0x36, 0x39, 0x33, 0x37, 0x66, 0x35, 0x63, 0x31, 0x62, 0x66, 0x65, 0x38, 0x33, 0x36, 0x65, 0x32, 0x66, 0x62, 0x36, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66, 0x63, 0x62, 0x65, 0x62, 0x64, 0x63, 0x34, 0x61, 0x62, 0x34, 0x33, 0x35, 0x37, 0x66, 0x32, 0x64, 0x62, 0x62, 0x63, 0x36, 0x31, 0x61, 0x30, 0x35, 0x63, 0x33, 0x62, 0x32, 0x62, 0x34, 0x34, 0x66, 0x66, 0x38, 0x32, 0x35, 0x32, 0x66, 0x37, 0x38, 0x64, 0x37, 0x30, 0x61, 0x65, 0x62, 0x33, 0x33, 0x66, 0x38, 0x62, 0x61, 0x30, 0x39, 0x62, 0x65, 0x61, 0x65, 0x61, 0x64, 0x61, 0x64, 0x31, 0x62, 0x33, 0x37, 0x36, 0x61, 0x35, 0x37, 0x64, 0x33, 0x34, 0x66, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x63, 0x34, 0x61, 0x31, 0x38, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x32, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x36, 0x32, 0x63, 0x33, 0x36, 0x30, 0x66, 0x64, 0x64, 0x38, 0x38, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x39, 0x64, 0x34, 0x36, 0x33, 0x65, 0x36, 0x64, 0x36, 0x34, 0x62, 0x32, 0x65, 0x65, 0x33, 0x32, 0x30, 0x61, 0x63, 0x36, 0x61, 0x30, 0x38, 0x38, 0x38, 0x35, 0x64, 0x66, 0x36, 0x30, 0x38, 0x33, 0x36, 0x34, 0x34, 0x61, 0x30, 0x36, 0x33, 0x65, 0x37, 0x30, 0x31, 0x61, 0x30, 0x33, 0x37, 0x61, 0x37, 0x32, 0x38, 0x61, 0x65, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x66, 0x66, 0x61, 0x37, 0x30, 0x32, 0x61, 0x32, 0x63, 0x61, 0x36, 0x32, 0x30, 0x64, 0x62, 0x38, 0x39, 0x63, 0x61, 0x66, 0x33, 0x65, 0x34, 0x36, 0x61, 0x62, 0x37, 0x66, 0x32, 0x35, 0x66, 0x37, 0x36, 0x34, 0x36, 0x66, 0x63, 0x39, 0x35, 0x31, 0x35, 0x31, 0x30, 0x39, 0x39, 0x31, 0x62, 0x61, 0x64, 0x63, 0x61, 0x30, 0x36, 0x35, 0x64, 0x38, 0x34, 0x36, 0x66, 0x30, 0x34, 0x36, 0x33, 0x35, 0x37, 0x61, 0x66, 0x33, 0x39, 0x62, 0x62, 0x37, 0x33, 0x39, 0x62, 0x31, 0x36, 0x31, 0x32, 0x33, 0x33, 0x66, 0x63, 0x65, 0x37, 0x33, 0x64, 0x64, 0x66, 0x65, 0x30, 0x62, 0x62, 0x38, 0x37, 0x66, 0x32, 0x64, 0x32, 0x38, 0x65, 0x66, 0x36, 0x30, 0x64, 0x66, 0x65, 0x36, 0x64, 0x62, 0x62, 0x30, 0x31, 0x32, 0x38, 0x64, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x36, 0x61, 0x39, 0x36, 0x30, 0x38, 0x36, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x66, 0x31, 0x37, 0x36, 0x36, 0x38, 0x66, 0x33, 0x35, 0x66, 0x37, 0x34, 0x31, 0x38, 0x65, 0x66, 0x38, 0x37, 0x39, 0x38, 0x30, 0x37, 0x39, 0x31, 0x36, 0x37, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x37, 0x32, 0x65, 0x63, 0x64, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x32, 0x36, 0x31, 0x33, 0x37, 0x63, 0x66, 0x34, 0x35, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x32, 0x34, 0x37, 0x38, 0x36, 0x61, 0x62, 0x33, 0x34, 0x38, 0x33, 0x63, 0x32, 0x66, 0x39, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x33, 0x66, 0x35, 0x31, 0x30, 0x32, 0x64, 0x61, 0x62, 0x65, 0x30, 0x61, 0x32, 0x37, 0x62, 0x31, 0x37, 0x34, 0x36, 0x30, 0x39, 0x38, 0x64, 0x31, 0x64, 0x63, 0x31, 0x37, 0x61, 0x35, 0x64, 0x33, 0x66, 0x62, 0x64, 0x34, 0x37, 0x38, 0x37, 0x35, 0x39, 0x66, 0x65, 0x61, 0x39, 0x32, 0x38, 0x37, 0x65, 0x34, 0x65, 0x34, 0x31, 0x39, 0x62, 0x33, 0x63, 0x33, 0x63, 0x65, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x31, 0x61, 0x63, 0x64, 0x62, 0x32, 0x63, 0x34, 0x64, 0x33, 0x64, 0x66, 0x33, 0x66, 0x31, 0x62, 0x38, 0x64, 0x33, 0x62, 0x66, 0x64, 0x33, 0x33, 0x34, 0x32, 0x31, 0x36, 0x36, 0x30, 0x64, 0x66, 0x33, 0x35, 0x38, 0x64, 0x38, 0x34, 0x64, 0x37, 0x38, 0x64, 0x31, 0x36, 0x63, 0x34, 0x36, 0x30, 0x33, 0x35, 0x35, 0x31, 0x39, 0x33, 0x35, 0x66, 0x34, 0x62, 0x36, 0x37, 0x36, 0x34, 0x33, 0x33, 0x37, 0x33, 0x65, 0x37, 0x65, 0x62, 0x36, 0x33, 0x64, 0x63, 0x62, 0x31, 0x36, 0x65, 0x63, 0x33, 0x35, 0x39, 0x62, 0x65, 0x30, 0x65, 0x63, 0x34, 0x31, 0x66, 0x65, 0x65, 0x33, 0x33, 0x62, 0x30, 0x33, 0x61, 0x31, 0x36, 0x65, 0x38, 0x30, 0x37, 0x34, 0x35, 0x66, 0x32, 0x33, 0x37, 0x34, 0x66, 0x66, 0x31, 0x64, 0x33, 0x63, 0x33, 0x35, 0x32, 0x35, 0x30, 0x38, 0x61, 0x63, 0x35, 0x64, 0x38, 0x35, 0x37, 0x63, 0x36, 0x34, 0x37, 0x36, 0x64, 0x33, 0x63, 0x33, 0x62, 0x63, 0x66, 0x37, 0x65, 0x36, 0x63, 0x61, 0x33, 0x37, 0x34, 0x32, 0x37, 0x63, 0x39, 0x32, 0x30, 0x39, 0x66, 0x31, 0x37, 0x62, 0x65, 0x33, 0x61, 0x66, 0x35, 0x32, 0x36, 0x34, 0x63, 0x30, 0x65, 0x32, 0x31, 0x33, 0x32, 0x62, 0x33, 0x64, 0x64, 0x31, 0x31, 0x35, 0x36, 0x63, 0x32, 0x38, 0x62, 0x34, 0x65, 0x39, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x63, 0x38, 0x35, 0x61, 0x36, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x63, 0x32, 0x31, 0x35, 0x66, 0x36, 0x61, 0x31, 0x32, 0x38, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x31, 0x65, 0x65, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x36, 0x34, 0x32, 0x34, 0x34, 0x30, 0x34, 0x33, 0x61, 0x35, 0x66, 0x36, 0x33, 0x39, 0x61, 0x61, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x32, 0x30, 0x34, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x63, 0x38, 0x35, 0x31, 0x66, 0x32, 0x39, 0x63, 0x37, 0x63, 0x31, 0x38, 0x33, 0x62, 0x65, 0x32, 0x35, 0x33, 0x65, 0x61, 0x31, 0x35, 0x31, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x31, 0x64, 0x62, 0x37, 0x30, 0x63, 0x34, 0x38, 0x35, 0x62, 0x36, 0x32, 0x36, 0x34, 0x36, 0x39, 0x32, 0x66, 0x32, 0x36, 0x62, 0x38, 0x61, 0x65, 0x61, 0x61, 0x62, 0x35, 0x62, 0x30, 0x63, 0x33, 0x38, 0x34, 0x31, 0x38, 0x30, 0x64, 0x66, 0x38, 0x65, 0x32, 0x31, 0x38, 0x34, 0x61, 0x32, 0x31, 0x61, 0x38, 0x30, 0x38, 0x61, 0x33, 0x65, 0x63, 0x38, 0x65, 0x38, 0x36, 0x63, 0x61, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x35, 0x36, 0x31, 0x37, 0x33, 0x31, 0x37, 0x38, 0x35, 0x62, 0x34, 0x38, 0x63, 0x66, 0x31, 0x38, 0x38, 0x36, 0x34, 0x31, 0x32, 0x32, 0x33, 0x34, 0x35, 0x33, 0x31, 0x65, 0x34, 0x39, 0x34, 0x30, 0x30, 0x36, 0x34, 0x35, 0x38, 0x34, 0x34, 0x36, 0x33, 0x65, 0x39, 0x36, 0x61, 0x63, 0x36, 0x33, 0x61, 0x31, 0x61, 0x31, 0x35, 0x34, 0x33, 0x32, 0x30, 0x32, 0x32, 0x37, 0x65, 0x33, 0x33, 0x33, 0x66, 0x62, 0x35, 0x31, 0x61, 0x64, 0x64, 0x63, 0x34, 0x61, 0x38, 0x39, 0x62, 0x37, 0x65, 0x30, 0x64, 0x33, 0x66, 0x38, 0x36, 0x32, 0x64, 0x37, 0x63, 0x31, 0x66, 0x64, 0x34, 0x65, 0x61, 0x30, 0x33, 0x62, 0x64, 0x38, 0x65, 0x62, 0x33, 0x64, 0x38, 0x38, 0x30, 0x36, 0x66, 0x31, 0x65, 0x37, 0x64, 0x61, 0x66, 0x35, 0x39, 0x31, 0x63, 0x62, 0x62, 0x62, 0x62, 0x39, 0x32, 0x62, 0x30, 0x62, 0x65, 0x62, 0x37, 0x34, 0x64, 0x31, 0x33, 0x63, 0x30, 0x31, 0x36, 0x31, 0x37, 0x66, 0x32, 0x32, 0x63, 0x35, 0x30, 0x32, 0x36, 0x62, 0x34, 0x66, 0x39, 0x66, 0x39, 0x66, 0x32, 0x39, 0x34, 0x61, 0x38, 0x61, 0x37, 0x63, 0x33, 0x32, 0x64, 0x62, 0x38, 0x39, 0x35, 0x64, 0x65, 0x33, 0x62, 0x30, 0x31, 0x62, 0x65, 0x65, 0x30, 0x31, 0x33, 0x32, 0x63, 0x39, 0x32, 0x30, 0x39, 0x65, 0x31, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x36, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x64, 0x61, 0x65, 0x65, 0x64, 0x37, 0x33, 0x34, 0x64, 0x61, 0x31, 0x31, 0x34, 0x34, 0x37, 0x30, 0x64, 0x61, 0x35, 0x35, 0x39, 0x62, 0x64, 0x34, 0x62, 0x34, 0x63, 0x37, 0x32, 0x35, 0x39, 0x65, 0x31, 0x66, 0x37, 0x39, 0x35, 0x32, 0x35, 0x35, 0x35, 0x32, 0x34, 0x31, 0x64, 0x63, 0x62, 0x63, 0x39, 0x30, 0x63, 0x66, 0x31, 0x39, 0x34, 0x61, 0x32, 0x65, 0x66, 0x36, 0x37, 0x36, 0x66, 0x63, 0x36, 0x30, 0x30, 0x35, 0x66, 0x33, 0x36, 0x37, 0x32, 0x66, 0x61, 0x64, 0x61, 0x32, 0x61, 0x33, 0x36, 0x34, 0x35, 0x65, 0x64, 0x62, 0x32, 0x39, 0x37, 0x61, 0x37, 0x35, 0x35, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x30, 0x61, 0x37, 0x34, 0x31, 0x61, 0x34, 0x36, 0x32, 0x37, 0x38, 0x30, 0x31, 0x34, 0x64, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x38, 0x30, 0x63, 0x35, 0x66, 0x32, 0x65, 0x31, 0x65, 0x62, 0x32, 0x33, 0x39, 0x33, 0x39, 0x63, 0x66, 0x33, 0x36, 0x30, 0x30, 0x66, 0x36, 0x31, 0x38, 0x37, 0x32, 0x65, 0x33, 0x65, 0x39, 0x39, 0x36, 0x34, 0x64, 0x30, 0x61, 0x63, 0x61, 0x66, 0x62, 0x34, 0x34, 0x30, 0x36, 0x33, 0x34, 0x65, 0x35, 0x33, 0x30, 0x64, 0x36, 0x31, 0x33, 0x39, 0x61, 0x31, 0x39, 0x33, 0x62, 0x38, 0x38, 0x39, 0x63, 0x35, 0x36, 0x61, 0x30, 0x63, 0x30, 0x37, 0x64, 0x37, 0x33, 0x37, 0x37, 0x32, 0x39, 0x64, 0x62, 0x65, 0x30, 0x36, 0x32, 0x36, 0x37, 0x30, 0x36, 0x66, 0x63, 0x39, 0x66, 0x32, 0x35, 0x66, 0x22, 0x5d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x37, 0x32, 0x32, 0x36, 0x36, 0x32, 0x31, 0x35, 0x34, 0x65, 0x36, 0x64, 0x37, 0x36, 0x62, 0x32, 0x62, 0x32, 0x62, 0x39, 0x32, 0x65, 0x37, 0x30, 0x63, 0x30, 0x63, 0x61, 0x63, 0x33, 0x63, 0x63, 0x66, 0x35, 0x33, 0x34, 0x66, 0x39, 0x62, 0x37, 0x34, 0x65, 0x62, 0x35, 0x62, 0x38, 0x39, 0x38, 0x31, 0x39, 0x65, 0x63, 0x35, 0x30, 0x39, 0x30, 0x38, 0x33, 0x64, 0x30, 0x30, 0x61, 0x35, 0x30, 0x33, 0x61, 0x65, 0x35, 0x63, 0x31, 0x39, 0x38, 0x64, 0x31, 0x37, 0x36, 0x33, 0x34, 0x65, 0x37, 0x39, 0x30, 0x35, 0x39, 0x63, 0x32, 0x63, 0x64, 0x37, 0x33, 0x35, 0x34, 0x39, 0x31, 0x35, 0x35, 0x33, 0x64, 0x32, 0x32, 0x63, 0x34, 0x65, 0x30, 0x39, 0x64, 0x31, 0x64, 0x39, 0x66, 0x65, 0x61, 0x33, 0x65, 0x63, 0x66, 0x32, 0x31, 0x34, 0x35, 0x36, 0x35, 0x64, 0x66, 0x32, 0x32, 0x38, 0x34, 0x37, 0x32, 0x36, 0x37, 0x64, 0x64, 0x64, 0x37, 0x63, 0x34, 0x37, 0x30, 0x33, 0x30, 0x66, 0x38, 0x36, 0x36, 0x37, 0x62, 0x36, 0x31, 0x61, 0x39, 0x38, 0x36, 0x30, 0x62, 0x30, 0x38, 0x35, 0x63, 0x30, 0x36, 0x30, 0x63, 0x30, 0x37, 0x65, 0x62, 0x32, 0x31, 0x35, 0x61, 0x34, 0x64, 0x65, 0x39, 0x39, 0x31, 0x61, 0x38, 0x66, 0x65, 0x64, 0x30, 0x63, 0x61, 0x65, 0x33, 0x38, 0x32, 0x31, 0x66, 0x30, 0x65, 0x65, 0x38, 0x64, 0x65, 0x36, 0x34, 0x64, 0x32, 0x35, 0x64, 0x32, 0x64, 0x65, 0x34, 0x61, 0x37, 0x31, 0x30, 0x65, 0x61, 0x39, 0x66, 0x64, 0x38, 0x39, 0x66, 0x38, 0x66, 0x34, 0x36, 0x36, 0x36, 0x66, 0x63, 0x63, 0x37, 0x34, 0x35, 0x31, 0x65, 0x36, 0x64, 0x36, 0x39, 0x61, 0x30, 0x32, 0x30, 0x39, 0x38, 0x62, 0x62, 0x65, 0x35, 0x64, 0x35, 0x62, 0x38, 0x37, 0x63, 0x36, 0x30, 0x37, 0x32, 0x30, 0x66, 0x36, 0x64, 0x62, 0x37, 0x35, 0x62, 0x63, 0x62, 0x61, 0x64, 0x34, 0x39, 0x66, 0x63, 0x31, 0x31, 0x35, 0x31, 0x32, 0x39, 0x33, 0x30, 0x64, 0x39, 0x64, 0x39, 0x37, 0x62, 0x65, 0x66, 0x33, 0x66, 0x32, 0x62, 0x34, 0x62, 0x66, 0x36, 0x63, 0x38, 0x66, 0x63, 0x62, 0x63, 0x34, 0x31, 0x34, 0x62, 0x66, 0x36, 0x31, 0x63, 0x39, 0x38, 0x64, 0x36, 0x62, 0x66, 0x66, 0x32, 0x33, 0x62, 0x61, 0x36, 0x61, 0x62, 0x31, 0x64, 0x37, 0x36, 0x65, 0x30, 0x34, 0x34, 0x39, 0x30, 0x38, 0x31, 0x33, 0x35, 0x65, 0x36, 0x63, 0x38, 0x37, 0x32, 0x30, 0x64, 0x33, 0x64, 0x38, 0x63, 0x61, 0x31, 0x38, 0x62, 0x65, 0x31, 0x65, 0x30, 0x31, 0x33, 0x63, 0x32, 0x37, 0x35, 0x62, 0x61, 0x39, 0x66, 0x32, 0x61, 0x35, 0x64, 0x37, 0x65, 0x65, 0x66, 0x35, 0x63, 0x32, 0x62, 0x35, 0x66, 0x33, 0x38, 0x36, 0x38, 0x64, 0x66, 0x34, 0x37, 0x30, 0x62, 0x34, 0x65, 0x37, 0x38, 0x34, 0x38, 0x66, 0x37, 0x39, 0x64, 0x39, 0x38, 0x63, 0x66, 0x64, 0x37, 0x33, 0x38, 0x31, 0x63, 0x38, 0x65, 0x33, 0x38, 0x65, 0x39, 0x64, 0x64, 0x62, 0x64, 0x66, 0x32, 0x31, 0x33, 0x61, 0x66, 0x38, 0x64, 0x33, 0x65, 0x61, 0x63, 0x62, 0x64, 0x64, 0x31, 0x62, 0x37, 0x64, 0x30, 0x66, 0x65, 0x61, 0x35, 0x37, 0x32, 0x34, 0x66, 0x61, 0x35, 0x61, 0x65, 0x65, 0x35, 0x66, 0x35, 0x62, 0x38, 0x31, 0x39, 0x66, 0x33, 0x35, 0x66, 0x38, 0x66, 0x64, 0x61, 0x66, 0x66, 0x62, 0x64, 0x64, 0x63, 0x32, 0x61, 0x32, 0x62, 0x62, 0x32, 0x66, 0x64, 0x32, 0x31, 0x66, 0x30, 0x37, 0x66, 0x32, 0x34, 0x66, 0x62, 0x65, 0x31, 0x31, 0x66, 0x39, 0x38, 0x65, 0x62, 0x63, 0x64, 0x62, 0x66, 0x36, 0x65, 0x33, 0x32, 0x37, 0x32, 0x35, 0x37, 0x33, 0x38, 0x39, 0x66, 0x62, 0x30, 0x62, 0x63, 0x62, 0x34, 0x33, 0x31, 0x30, 0x38, 0x30, 0x39, 0x32, 0x39, 0x34, 0x35, 0x33, 0x31, 0x32, 0x64, 0x37, 0x36, 0x37, 0x64, 0x34, 0x34, 0x38, 0x35, 0x33, 0x35, 0x38, 0x66, 0x64, 0x35, 0x34, 0x33, 0x32, 0x31, 0x35, 0x38, 0x30, 0x37, 0x64, 0x62, 0x35, 0x65, 0x35, 0x65, 0x33, 0x63, 0x62, 0x33, 0x37, 0x34, 0x31, 0x63, 0x37, 0x32, 0x32, 0x66, 0x32, 0x35, 0x38, 0x31, 0x64, 0x31, 0x35, 0x65, 0x63, 0x38, 0x64, 0x36, 0x65, 0x65, 0x61, 0x37, 0x63, 0x30, 0x65, 0x37, 0x64, 0x62, 0x32, 0x61, 0x62, 0x36, 0x66, 0x39, 0x62, 0x35, 0x61, 0x37, 0x37, 0x34, 0x62, 0x65, 0x38, 0x33, 0x34, 0x31, 0x64, 0x33, 0x32, 0x61, 0x33, 0x37, 0x33, 0x39, 0x64, 0x31, 0x30, 0x33, 0x39, 0x32, 0x39, 0x63, 0x65, 0x30, 0x35, 0x34, 0x37, 0x32, 0x30, 0x38, 0x62, 0x33, 0x32, 0x34, 0x62, 0x37, 0x62, 0x32, 0x39, 0x61, 0x38, 0x35, 0x35, 0x35, 0x32, 0x64, 0x32, 0x66, 0x63, 0x39, 0x30, 0x62, 0x34, 0x30, 0x66, 0x39, 0x65, 0x35, 0x31, 0x30, 0x36, 0x38, 0x30, 0x61, 0x63, 0x65, 0x31, 0x34, 0x34, 0x37, 0x37, 0x32, 0x30, 0x63, 0x39, 0x38, 0x30, 0x30, 0x32, 0x66, 0x37, 0x65, 0x66, 0x37, 0x62, 0x37, 0x66, 0x65, 0x30, 0x39, 0x33, 0x30, 0x38, 0x66, 0x66, 0x33, 0x61, 0x38, 0x66, 0x37, 0x35, 0x30, 0x33, 0x36, 0x63, 0x34, 0x38, 0x61, 0x66, 0x62, 0x62, 0x30, 0x39, 0x64, 0x61, 0x66, 0x34, 0x32, 0x66, 0x31, 0x66, 0x33, 0x36, 0x66, 0x34, 0x37, 0x37, 0x65, 0x36, 0x34, 0x36, 0x30, 0x36, 0x63, 0x33, 0x33, 0x32, 0x32, 0x66, 0x39, 0x38, 0x37, 0x66, 0x62, 0x30, 0x35, 0x36, 0x30, 0x33, 0x62, 0x63, 0x36, 0x32, 0x64, 0x32, 0x31, 0x37, 0x31, 0x64, 0x65, 0x30, 0x66, 0x63, 0x66, 0x65, 0x33, 0x30, 0x39, 0x30, 0x63, 0x33, 0x32, 0x32, 0x33, 0x34, 0x61, 0x37, 0x31, 0x32, 0x64, 0x37, 0x66, 0x32, 0x34, 0x38, 0x33, 0x38, 0x30, 0x36, 0x66, 0x31, 0x39, 0x32, 0x37, 0x37, 0x31, 0x63, 0x64, 0x30, 0x65, 0x32, 0x61, 0x62, 0x31, 0x34, 0x37, 0x32, 0x65, 0x66, 0x64, 0x66, 0x34, 0x32, 0x38, 0x66, 0x35, 0x66, 0x61, 0x37, 0x32, 0x63, 0x32, 0x63, 0x35, 0x61, 0x35, 0x63, 0x61, 0x37, 0x33, 0x65, 0x33, 0x66, 0x30, 0x39, 0x35, 0x61, 0x64, 0x37, 0x36, 0x33, 0x30, 0x35, 0x34, 0x65, 0x64, 0x32, 0x61, 0x34, 0x61, 0x38, 0x66, 0x61, 0x36, 0x61, 0x30, 0x35, 0x62, 0x66, 0x33, 0x62, 0x30, 0x32, 0x39, 0x36, 0x34, 0x36, 0x63, 0x35, 0x66, 0x38, 0x62, 0x36, 0x31, 0x30, 0x33, 0x33, 0x65, 0x64, 0x38, 0x35, 0x31, 0x37, 0x32, 0x37, 0x65, 0x37, 0x61, 0x61, 0x34, 0x64, 0x31, 0x32, 0x30, 0x66, 0x39, 0x38, 0x31, 0x37, 0x61, 0x62, 0x32, 0x34, 0x32, 0x30, 0x61, 0x37, 0x63, 0x62, 0x64, 0x65, 0x66, 0x62, 0x36, 0x37, 0x64, 0x36, 0x64, 0x31, 0x36, 0x36, 0x36, 0x63, 0x63, 0x30, 0x30, 0x61, 0x31, 0x61, 0x33, 0x37, 0x62, 0x35, 0x36, 0x34, 0x63, 0x65, 0x61, 0x63, 0x64, 0x31, 0x34, 0x63, 0x33, 0x37, 0x63, 0x37, 0x32, 0x65, 0x30, 0x61, 0x65, 0x30, 0x36, 0x66, 0x61, 0x31, 0x61, 0x30, 0x39, 0x62, 0x66, 0x36, 0x33, 0x30, 0x37, 0x65, 0x32, 0x32, 0x36, 0x64, 0x32, 0x39, 0x39, 0x34, 0x32, 0x64, 0x62, 0x31, 0x65, 0x66, 0x33, 0x31, 0x63, 0x36, 0x35, 0x64, 0x65, 0x36, 0x61, 0x34, 0x39, 0x39, 0x32, 0x32, 0x66, 0x38, 0x66, 0x34, 0x38, 0x36, 0x30, 0x65, 0x63, 0x32, 0x64, 0x38, 0x61, 0x37, 0x31, 0x37, 0x32, 0x36, 0x66, 0x37, 0x34, 0x63, 0x63, 0x32, 0x39, 0x34, 0x39, 0x36, 0x61, 0x38, 0x35, 0x61, 0x37, 0x37, 0x35, 0x62, 0x62, 0x32, 0x39, 0x31, 0x30, 0x33, 0x66, 0x37, 0x35, 0x32, 0x34, 0x37, 0x62, 0x32, 0x62, 0x33, 0x34, 0x37, 0x31, 0x38, 0x61, 0x38, 0x39, 0x30, 0x31, 0x30, 0x64, 0x64, 0x39, 0x33, 0x37, 0x31, 0x35, 0x35, 0x37, 0x63, 0x31, 0x65, 0x64, 0x34, 0x36, 0x36, 0x37, 0x37, 0x32, 0x30, 0x38, 0x37, 0x62, 0x66, 0x65, 0x33, 0x31, 0x34, 0x38, 0x64, 0x31, 0x37, 0x66, 0x38, 0x32, 0x37, 0x39, 0x64, 0x65, 0x31, 0x66, 0x65, 0x38, 0x33, 0x38, 0x37, 0x31, 0x30, 0x34, 0x64, 0x30, 0x65, 0x32, 0x35, 0x62, 0x62, 0x33, 0x36, 0x65, 0x30, 0x31, 0x38, 0x37, 0x62, 0x32, 0x65, 0x31, 0x64, 0x34, 0x64, 0x66, 0x39, 0x64, 0x66, 0x33, 0x65, 0x66, 0x63, 0x35, 0x32, 0x64, 0x37, 0x32, 0x66, 0x38, 0x39, 0x36, 0x65, 0x35, 0x61, 0x61, 0x65, 0x34, 0x65, 0x35, 0x33, 0x37, 0x31, 0x62, 0x64, 0x65, 0x34, 0x35, 0x37, 0x31, 0x34, 0x32, 0x31, 0x62, 0x64, 0x64, 0x31, 0x65, 0x34, 0x37, 0x62, 0x31, 0x65, 0x63, 0x65, 0x32, 0x61, 0x38, 0x66, 0x61, 0x64, 0x62, 0x66, 0x32, 0x37, 0x66, 0x32, 0x37, 0x62, 0x38, 0x37, 0x64, 0x31, 0x36, 0x38, 0x39, 0x66, 0x34, 0x34, 0x35, 0x33, 0x64, 0x38, 0x37, 0x64, 0x34, 0x62, 0x64, 0x63, 0x31, 0x66, 0x34, 0x31, 0x31, 0x62, 0x66, 0x61, 0x31, 0x33, 0x37, 0x38, 0x39, 0x34, 0x37, 0x38, 0x66, 0x34, 0x62, 0x32, 0x66, 0x36, 0x32, 0x30, 0x33, 0x61, 0x66, 0x31, 0x39, 0x63, 0x37, 0x63, 0x32, 0x34, 0x30, 0x36, 0x33, 0x65, 0x33, 0x64, 0x32, 0x36, 0x36, 0x33, 0x64, 0x63, 0x37, 0x61, 0x33, 0x63, 0x39, 0x37, 0x64, 0x31, 0x32, 0x35, 0x35, 0x38, 0x36, 0x32, 0x65, 0x63, 0x35, 0x31, 0x32, 0x31, 0x65, 0x34, 0x63, 0x63, 0x37, 0x33, 0x33, 0x65, 0x37, 0x65, 0x36, 0x39, 0x32, 0x39, 0x38, 0x34, 0x37, 0x66, 0x33, 0x32, 0x33, 0x35, 0x33, 0x61, 0x34, 0x62, 0x63, 0x66, 0x36, 0x38, 0x39, 0x37, 0x66, 0x31, 0x66, 0x66, 0x35, 0x32, 0x64, 0x63, 0x63, 0x36, 0x36, 0x64, 0x38, 0x63, 0x39, 0x39, 0x32, 0x33, 0x66, 0x30, 0x64, 0x35, 0x32, 0x35, 0x61, 0x32, 0x32, 0x36, 0x39, 0x39, 0x65, 0x62, 0x62, 0x65, 0x62, 0x63, 0x63, 0x38, 0x30, 0x66, 0x62, 0x31, 0x66, 0x31, 0x35, 0x38, 0x62, 0x65, 0x62, 0x38, 0x63, 0x36, 0x31, 0x35, 0x31, 0x31, 0x36, 0x39, 0x38, 0x65, 0x65, 0x39, 0x66, 0x65, 0x39, 0x62, 0x34, 0x30, 0x61, 0x32, 0x64, 0x64, 0x65, 0x61, 0x37, 0x34, 0x36, 0x63, 0x37, 0x61, 0x39, 0x32, 0x31, 0x65, 0x38, 0x35, 0x33, 0x32, 0x32, 0x38, 0x31, 0x62, 0x34, 0x36, 0x62, 0x66, 0x34, 0x65, 0x66, 0x37, 0x31, 0x38, 0x33, 0x35, 0x39, 0x37, 0x65, 0x32, 0x30, 0x38, 0x61, 0x66, 0x66, 0x31, 0x37, 0x38, 0x34, 0x64, 0x37, 0x39, 0x34, 0x33, 0x36, 0x63, 0x63, 0x36, 0x39, 0x65, 0x66, 0x35, 0x62, 0x64, 0x64, 0x63, 0x30, 0x64, 0x62, 0x32, 0x39, 0x66, 0x65, 0x32, 0x64, 0x61, 0x38, 0x34, 0x62, 0x63, 0x65, 0x37, 0x32, 0x63, 0x37, 0x38, 0x62, 0x32, 0x33, 0x64, 0x63, 0x39, 0x34, 0x63, 0x31, 0x65, 0x37, 0x36, 0x35, 0x39, 0x38, 0x64, 0x63, 0x64, 0x36, 0x63, 0x65, 0x38, 0x63, 0x32, 0x34, 0x63, 0x30, 0x62, 0x64, 0x37, 0x32, 0x63, 0x62, 0x35, 0x38, 0x31, 0x36, 0x30, 0x35, 0x63, 0x34, 0x64, 0x38, 0x61, 0x34, 0x65, 0x37, 0x31, 0x31, 0x65, 0x66, 0x62, 0x39, 0x35, 0x37, 0x39, 0x35, 0x32, 0x66, 0x37, 0x32, 0x36, 0x36, 0x66, 0x39, 0x66, 0x61, 0x61, 0x61, 0x64, 0x31, 0x65, 0x30, 0x32, 0x35, 0x38, 0x34, 0x36, 0x32, 0x65, 0x62, 0x36, 0x38, 0x64, 0x65, 0x36, 0x38, 0x31, 0x30, 0x33, 0x32, 0x64, 0x33, 0x64, 0x63, 0x63, 0x33, 0x30, 0x34, 0x37, 0x62, 0x62, 0x66, 0x31, 0x63, 0x37, 0x66, 0x31, 0x66, 0x33, 0x33, 0x33, 0x37, 0x62, 0x62, 0x36, 0x37, 0x64, 0x39, 0x35, 0x36, 0x33, 0x61, 0x37, 0x32, 0x31, 0x32, 0x61, 0x34, 0x32, 0x61, 0x39, 0x30, 0x64, 0x63, 0x39, 0x33, 0x36, 0x34, 0x37, 0x62, 0x36, 0x33, 0x36, 0x35, 0x34, 0x30, 0x63, 0x37, 0x37, 0x34, 0x61, 0x36, 0x38, 0x30, 0x65, 0x38, 0x61, 0x65, 0x38, 0x39, 0x35, 0x38, 0x66, 0x33, 0x38, 0x36, 0x64, 0x34, 0x36, 0x33, 0x39, 0x66, 0x61, 0x39, 0x64, 0x36, 0x31, 0x65, 0x30, 0x32, 0x66, 0x61, 0x35, 0x32, 0x39, 0x33, 0x35, 0x34, 0x30, 0x66, 0x36, 0x66, 0x37, 0x33, 0x33, 0x64, 0x65, 0x34, 0x39, 0x36, 0x61, 0x30, 0x35, 0x34, 0x38, 0x65, 0x61, 0x65, 0x63, 0x33, 0x64, 0x35, 0x31, 0x30, 0x65, 0x65, 0x36, 0x65, 0x31, 0x61, 0x65, 0x32, 0x38, 0x32, 0x32, 0x64, 0x33, 0x34, 0x38, 0x37, 0x39, 0x33, 0x36, 0x39, 0x33, 0x65, 0x31, 0x64, 0x63, 0x33, 0x38, 0x64, 0x64, 0x33, 0x65, 0x36, 0x39, 0x33, 0x39, 0x34, 0x37, 0x32, 0x30, 0x61, 0x64, 0x62, 0x61, 0x35, 0x35, 0x62, 0x36, 0x37, 0x39, 0x32, 0x66, 0x61, 0x64, 0x34, 0x37, 0x38, 0x31, 0x37, 0x61, 0x39, 0x62, 0x61, 0x30, 0x38, 0x38, 0x31, 0x35, 0x37, 0x32, 0x62, 0x34, 0x65, 0x63, 0x62, 0x31, 0x61, 0x39, 0x31, 0x63, 0x63, 0x37, 0x66, 0x65, 0x64, 0x33, 0x65, 0x32, 0x64, 0x66, 0x63, 0x35, 0x31, 0x35, 0x36, 0x39, 0x34, 0x31, 0x39, 0x37, 0x37, 0x37, 0x32, 0x37, 0x30, 0x34, 0x33, 0x37, 0x39, 0x38, 0x38, 0x62, 0x62, 0x37, 0x34, 0x65, 0x35, 0x65, 0x65, 0x62, 0x38, 0x38, 0x38, 0x64, 0x35, 0x38, 0x35, 0x30, 0x66, 0x39, 0x64, 0x65, 0x34, 0x33, 0x32, 0x65, 0x62, 0x63, 0x36, 0x61, 0x32, 0x30, 0x31, 0x35, 0x34, 0x36, 0x33, 0x32, 0x35, 0x64, 0x66, 0x36, 0x38, 0x66, 0x31, 0x30, 0x30, 0x34, 0x39, 0x64, 0x35, 0x34, 0x63, 0x39, 0x36, 0x37, 0x32, 0x62, 0x33, 0x66, 0x35, 0x32, 0x37, 0x31, 0x65, 0x62, 0x35, 0x63, 0x62, 0x33, 0x37, 0x61, 0x39, 0x39, 0x35, 0x64, 0x39, 0x66, 0x66, 0x30, 0x34, 0x31, 0x36, 0x32, 0x61, 0x35, 0x33, 0x32, 0x30, 0x61, 0x34, 0x38, 0x30, 0x63, 0x34, 0x35, 0x37, 0x34, 0x30, 0x39, 0x62, 0x32, 0x38, 0x61, 0x36, 0x36, 0x33, 0x65, 0x64, 0x37, 0x31, 0x62, 0x32, 0x62, 0x34, 0x30, 0x61, 0x64, 0x32, 0x32, 0x62, 0x35, 0x34, 0x31, 0x62, 0x35, 0x66, 0x66, 0x64, 0x64, 0x63, 0x36, 0x32, 0x64, 0x30, 0x38, 0x62, 0x38, 0x64, 0x34, 0x63, 0x38, 0x64, 0x61, 0x36, 0x32, 0x64, 0x32, 0x31, 0x66, 0x61, 0x34, 0x32, 0x39, 0x61, 0x36, 0x64, 0x36, 0x35, 0x38, 0x62, 0x33, 0x35, 0x34, 0x33, 0x32, 0x61, 0x37, 0x33, 0x36, 0x35, 0x31, 0x61, 0x64, 0x39, 0x66, 0x39, 0x63, 0x32, 0x31, 0x32, 0x31, 0x65, 0x37, 0x32, 0x65, 0x31, 0x37, 0x32, 0x64, 0x63, 0x62, 0x35, 0x31, 0x61, 0x65, 0x36, 0x65, 0x65, 0x34, 0x66, 0x32, 0x62, 0x62, 0x62, 0x35, 0x30, 0x63, 0x35, 0x31, 0x61, 0x39, 0x37, 0x63, 0x65, 0x37, 0x63, 0x37, 0x34, 0x32, 0x66, 0x61, 0x64, 0x37, 0x38, 0x36, 0x65, 0x34, 0x36, 0x35, 0x64, 0x65, 0x34, 0x32, 0x63, 0x66, 0x35, 0x36, 0x39, 0x66, 0x35, 0x34, 0x33, 0x63, 0x34, 0x63, 0x63, 0x32, 0x61, 0x33, 0x37, 0x39, 0x34, 0x32, 0x62, 0x66, 0x33, 0x34, 0x35, 0x35, 0x61, 0x33, 0x31, 0x66, 0x63, 0x65, 0x63, 0x61, 0x61, 0x36, 0x63, 0x31, 0x65, 0x32, 0x37, 0x31, 0x38, 0x64, 0x30, 0x30, 0x34, 0x37, 0x38, 0x38, 0x37, 0x31, 0x64, 0x63, 0x39, 0x64, 0x30, 0x64, 0x64, 0x62, 0x36, 0x65, 0x39, 0x38, 0x34, 0x37, 0x30, 0x31, 0x31, 0x39, 0x36, 0x66, 0x34, 0x39, 0x61, 0x63, 0x39, 0x37, 0x32, 0x61, 0x33, 0x66, 0x64, 0x64, 0x35, 0x30, 0x65, 0x36, 0x33, 0x31, 0x65, 0x38, 0x32, 0x38, 0x63, 0x38, 0x32, 0x33, 0x61, 0x33, 0x35, 0x34, 0x36, 0x31, 0x39, 0x38, 0x65, 0x66, 0x65, 0x35, 0x66, 0x38, 0x63, 0x61, 0x33, 0x31, 0x32, 0x65, 0x33, 0x31, 0x66, 0x62, 0x32, 0x61, 0x36, 0x62, 0x61, 0x66, 0x31, 0x34, 0x38, 0x63, 0x61, 0x62, 0x64, 0x35, 0x39, 0x35, 0x61, 0x62, 0x38, 0x37, 0x32, 0x30, 0x36, 0x35, 0x37, 0x66, 0x38, 0x64, 0x64, 0x39, 0x39, 0x62, 0x37, 0x39, 0x32, 0x39, 0x37, 0x36, 0x65, 0x36, 0x65, 0x30, 0x38, 0x37, 0x62, 0x37, 0x31, 0x31, 0x39, 0x37, 0x37, 0x65, 0x66, 0x31, 0x37, 0x65, 0x66, 0x64, 0x34, 0x65, 0x30, 0x64, 0x32, 0x38, 0x64, 0x39, 0x63, 0x65, 0x65, 0x34, 0x38, 0x65, 0x63, 0x31, 0x31, 0x33, 0x63, 0x35, 0x30, 0x39, 0x32, 0x35, 0x36, 0x37, 0x32, 0x34, 0x38, 0x62, 0x32, 0x35, 0x62, 0x63, 0x66, 0x64, 0x35, 0x62, 0x62, 0x61, 0x64, 0x61, 0x38, 0x31, 0x33, 0x36, 0x34, 0x32, 0x33, 0x32, 0x33, 0x61, 0x37, 0x66, 0x64, 0x37, 0x61, 0x37, 0x36, 0x33, 0x35, 0x36, 0x63, 0x64, 0x65, 0x38, 0x64, 0x61, 0x62, 0x62, 0x62, 0x65, 0x61, 0x34, 0x34, 0x63, 0x64, 0x65, 0x36, 0x63, 0x65, 0x31, 0x66, 0x63, 0x63, 0x31, 0x65, 0x36, 0x36, 0x37, 0x32, 0x38, 0x30, 0x65, 0x35, 0x39, 0x33, 0x32, 0x66, 0x30, 0x63, 0x64, 0x30, 0x38, 0x62, 0x33, 0x64, 0x32, 0x33, 0x39, 0x39, 0x61, 0x35, 0x37, 0x34, 0x36, 0x32, 0x39, 0x65, 0x31, 0x65, 0x62, 0x61, 0x39, 0x38, 0x62, 0x30, 0x61, 0x30, 0x64, 0x62, 0x34, 0x36, 0x37, 0x61, 0x36, 0x36, 0x34, 0x39, 0x39, 0x34, 0x35, 0x66, 0x38, 0x65, 0x32, 0x37, 0x31, 0x63, 0x66, 0x65, 0x66, 0x31, 0x32, 0x32, 0x33, 0x30, 0x30, 0x36, 0x62, 0x61, 0x66, 0x66, 0x38, 0x35, 0x31, 0x31, 0x62, 0x35, 0x35, 0x34, 0x62, 0x39, 0x63, 0x31, 0x31, 0x38, 0x31, 0x64, 0x37, 0x34, 0x63, 0x34, 0x39, 0x39, 0x65, 0x33, 0x35, 0x31, 0x36, 0x63, 0x30, 0x33, 0x31, 0x30, 0x33, 0x63, 0x62, 0x36, 0x63, 0x63, 0x62, 0x31, 0x65, 0x35, 0x34, 0x39, 0x65, 0x39, 0x65, 0x35, 0x37, 0x62, 0x65, 0x38, 0x30, 0x66, 0x37, 0x32, 0x65, 0x33, 0x39, 0x32, 0x35, 0x30, 0x38, 0x62, 0x63, 0x36, 0x32, 0x34, 0x64, 0x39, 0x61, 0x66, 0x34, 0x37, 0x64, 0x32, 0x64, 0x61, 0x32, 0x62, 0x61, 0x38, 0x39, 0x38, 0x66, 0x63, 0x33, 0x32, 0x36, 0x30, 0x38, 0x61, 0x34, 0x64, 0x66, 0x31, 0x61, 0x35, 0x61, 0x63, 0x34, 0x39, 0x35, 0x34, 0x64, 0x38, 0x31, 0x39, 0x65, 0x31, 0x37, 0x62, 0x61, 0x39, 0x33, 0x38, 0x61, 0x35, 0x37, 0x32, 0x33, 0x37, 0x63, 0x36, 0x39, 0x39, 0x61, 0x62, 0x62, 0x64, 0x65, 0x38, 0x30, 0x65, 0x34, 0x61, 0x37, 0x33, 0x61, 0x61, 0x34, 0x32, 0x61, 0x34, 0x63, 0x61, 0x38, 0x35, 0x35, 0x63, 0x38, 0x31, 0x30, 0x38, 0x64, 0x34, 0x36, 0x35, 0x38, 0x62, 0x30, 0x32, 0x39, 0x33, 0x66, 0x30, 0x39, 0x61, 0x39, 0x34, 0x66, 0x65, 0x31, 0x39, 0x32, 0x61, 0x35, 0x63, 0x30, 0x34, 0x30, 0x34, 0x37, 0x32, 0x62, 0x35, 0x36, 0x64, 0x66, 0x65, 0x65, 0x62, 0x31, 0x38, 0x63, 0x33, 0x35, 0x36, 0x33, 0x63, 0x38, 0x36, 0x66, 0x33, 0x32, 0x35, 0x62, 0x38, 0x33, 0x30, 0x35, 0x65, 0x39, 0x61, 0x62, 0x38, 0x34, 0x62, 0x32, 0x37, 0x36, 0x38, 0x31, 0x31, 0x61, 0x66, 0x36, 0x65, 0x30, 0x37, 0x62, 0x63, 0x31, 0x35, 0x61, 0x61, 0x33, 0x65, 0x64, 0x33, 0x65, 0x34, 0x37, 0x38, 0x31, 0x39, 0x33, 0x31, 0x34, 0x35, 0x32, 0x32, 0x35, 0x38, 0x64, 0x33, 0x38, 0x37, 0x65, 0x32, 0x38, 0x34, 0x61, 0x34, 0x64, 0x64, 0x32, 0x33, 0x62, 0x37, 0x38, 0x38, 0x34, 0x62, 0x38, 0x65, 0x39, 0x66, 0x30, 0x61, 0x33, 0x61, 0x65, 0x34, 0x31, 0x37, 0x37, 0x39, 0x61, 0x32, 0x30, 0x62, 0x31, 0x38, 0x36, 0x30, 0x37, 0x64, 0x36, 0x39, 0x32, 0x32, 0x38, 0x33, 0x61, 0x34, 0x31, 0x33, 0x62, 0x63, 0x34, 0x33, 0x33, 0x38, 0x61, 0x64, 0x39, 0x33, 0x31, 0x32, 0x34, 0x39, 0x39, 0x66, 0x63, 0x66, 0x38, 0x62, 0x31, 0x37, 0x61, 0x36, 0x66, 0x32, 0x38, 0x65, 0x61, 0x62, 0x38, 0x64, 0x64, 0x63, 0x33, 0x31, 0x35, 0x31, 0x61, 0x65, 0x38, 0x39, 0x38, 0x30, 0x35, 0x34, 0x30, 0x30, 0x61, 0x31, 0x30, 0x39, 0x36, 0x31, 0x36, 0x34, 0x30, 0x36, 0x33, 0x36, 0x35, 0x33, 0x32, 0x36, 0x37, 0x66, 0x37, 0x32, 0x34, 0x63, 0x38, 0x62, 0x37, 0x31, 0x32, 0x34, 0x35, 0x32, 0x63, 0x62, 0x65, 0x39, 0x39, 0x39, 0x33, 0x38, 0x36, 0x63, 0x34, 0x35, 0x65, 0x35, 0x34, 0x64, 0x39, 0x34, 0x39, 0x31, 0x36, 0x65, 0x30, 0x61, 0x38, 0x30, 0x31, 0x37, 0x65, 0x30, 0x64, 0x61, 0x64, 0x62, 0x32, 0x31, 0x61, 0x64, 0x32, 0x37, 0x63, 0x38, 0x30, 0x35, 0x39, 0x32, 0x31, 0x34, 0x64, 0x39, 0x37, 0x64, 0x33, 0x32, 0x63, 0x37, 0x36, 0x66, 0x63, 0x34, 0x37, 0x64, 0x62, 0x62, 0x64, 0x66, 0x35, 0x32, 0x38, 0x37, 0x34, 0x35, 0x61, 0x65, 0x39, 0x65, 0x35, 0x35, 0x63, 0x63, 0x35, 0x64, 0x61, 0x35, 0x66, 0x66, 0x30, 0x66, 0x39, 0x61, 0x65, 0x62, 0x34, 0x36, 0x64, 0x31, 0x62, 0x37, 0x39, 0x36, 0x35, 0x34, 0x36, 0x30, 0x30, 0x66, 0x61, 0x33, 0x63, 0x37, 0x64, 0x66, 0x34, 0x39, 0x61, 0x63, 0x37, 0x32, 0x33, 0x63, 0x30, 0x66, 0x63, 0x34, 0x35, 0x37, 0x34, 0x34, 0x30, 0x38, 0x36, 0x32, 0x62, 0x34, 0x63, 0x36, 0x31, 0x33, 0x38, 0x64, 0x35, 0x37, 0x37, 0x66, 0x62, 0x38, 0x64, 0x37, 0x34, 0x61, 0x64, 0x61, 0x37, 0x32, 0x38, 0x62, 0x65, 0x33, 0x63, 0x35, 0x34, 0x33, 0x38, 0x66, 0x35, 0x63, 0x32, 0x63, 0x31, 0x64, 0x61, 0x38, 0x35, 0x33, 0x33, 0x30, 0x35, 0x65, 0x66, 0x65, 0x37, 0x32, 0x61, 0x39, 0x31, 0x37, 0x63, 0x34, 0x64, 0x66, 0x64, 0x38, 0x39, 0x37, 0x33, 0x35, 0x65, 0x38, 0x66, 0x61, 0x35, 0x63, 0x30, 0x37, 0x63, 0x39, 0x63, 0x63, 0x34, 0x34, 0x35, 0x32, 0x62, 0x36, 0x38, 0x34, 0x34, 0x34, 0x36, 0x33, 0x61, 0x31, 0x38, 0x37, 0x38, 0x31, 0x62, 0x64, 0x39, 0x61, 0x63, 0x63, 0x64, 0x64, 0x61, 0x37, 0x34, 0x62, 0x31, 0x65, 0x39, 0x35, 0x38, 0x65, 0x31, 0x63, 0x61, 0x37, 0x64, 0x65, 0x39, 0x66, 0x34, 0x39, 0x63, 0x39, 0x30, 0x30, 0x30, 0x37, 0x39, 0x61, 0x62, 0x36, 0x31, 0x30, 0x38, 0x36, 0x37, 0x30, 0x63, 0x63, 0x35, 0x35, 0x31, 0x39, 0x62, 0x36, 0x37, 0x34, 0x34, 0x61, 0x64, 0x32, 0x64, 0x31, 0x30, 0x35, 0x66, 0x36, 0x62, 0x30, 0x64, 0x34, 0x65, 0x63, 0x35, 0x62, 0x35, 0x65, 0x65, 0x38, 0x38, 0x63, 0x65, 0x65, 0x39, 0x62, 0x34, 0x65, 0x33, 0x31, 0x34, 0x38, 0x64, 0x61, 0x31, 0x64, 0x62, 0x63, 0x39, 0x63, 0x38, 0x31, 0x33, 0x61, 0x64, 0x39, 0x36, 0x65, 0x39, 0x31, 0x31, 0x66, 0x61, 0x61, 0x64, 0x33, 0x34, 0x39, 0x31, 0x35, 0x31, 0x64, 0x36, 0x38, 0x34, 0x33, 0x39, 0x35, 0x34, 0x64, 0x38, 0x39, 0x35, 0x37, 0x32, 0x63, 0x31, 0x37, 0x66, 0x36, 0x33, 0x62, 0x38, 0x33, 0x63, 0x64, 0x32, 0x64, 0x65, 0x66, 0x37, 0x32, 0x32, 0x38, 0x35, 0x39, 0x39, 0x38, 0x30, 0x61, 0x34, 0x33, 0x63, 0x62, 0x31, 0x31, 0x32, 0x34, 0x38, 0x30, 0x61, 0x37, 0x30, 0x61, 0x66, 0x32, 0x31, 0x31, 0x36, 0x31, 0x37, 0x64, 0x38, 0x65, 0x33, 0x34, 0x36, 0x65, 0x39, 0x36, 0x31, 0x61, 0x62, 0x66, 0x32, 0x66, 0x35, 0x64, 0x66, 0x36, 0x35, 0x31, 0x33, 0x36, 0x64, 0x61, 0x31, 0x36, 0x31, 0x39, 0x65, 0x30, 0x66, 0x30, 0x37, 0x32, 0x34, 0x37, 0x62, 0x31, 0x61, 0x38, 0x35, 0x38, 0x39, 0x66, 0x30, 0x30, 0x65, 0x39, 0x64, 0x65, 0x65, 0x66, 0x36, 0x31, 0x39, 0x37, 0x30, 0x61, 0x32, 0x33, 0x65, 0x64, 0x64, 0x36, 0x62, 0x39, 0x36, 0x62, 0x33, 0x33, 0x30, 0x65, 0x35, 0x34, 0x63, 0x39, 0x38, 0x65, 0x30, 0x64, 0x66, 0x30, 0x65, 0x36, 0x30, 0x32, 0x37, 0x32, 0x34, 0x64, 0x30, 0x30, 0x33, 0x36, 0x38, 0x63, 0x37, 0x32, 0x39, 0x66, 0x30, 0x39, 0x61, 0x32, 0x31, 0x64, 0x31, 0x62, 0x35, 0x32, 0x39, 0x33, 0x32, 0x32, 0x37, 0x36, 0x62, 0x31, 0x61, 0x66, 0x66, 0x34, 0x65, 0x36, 0x33, 0x64, 0x30, 0x30, 0x61, 0x63, 0x62, 0x33, 0x61, 0x33, 0x34, 0x31, 0x66, 0x31, 0x36, 0x39, 0x39, 0x39, 0x64, 0x35, 0x61, 0x30, 0x31, 0x33, 0x63, 0x32, 0x34, 0x35, 0x34, 0x66, 0x39, 0x35, 0x63, 0x65, 0x64, 0x33, 0x30, 0x66, 0x30, 0x64, 0x32, 0x32, 0x66, 0x36, 0x63, 0x38, 0x38, 0x66, 0x36, 0x37, 0x32, 0x66, 0x66, 0x63, 0x33, 0x65, 0x36, 0x31, 0x64, 0x35, 0x32, 0x32, 0x33, 0x64, 0x61, 0x33, 0x39, 0x32, 0x36, 0x36, 0x66, 0x36, 0x32, 0x65, 0x62, 0x61, 0x65, 0x35, 0x64, 0x64, 0x37, 0x35, 0x61, 0x34, 0x38, 0x39, 0x65, 0x66, 0x65, 0x62, 0x36, 0x64, 0x66, 0x30, 0x38, 0x36, 0x32, 0x64, 0x31, 0x31, 0x37, 0x32, 0x63, 0x64, 0x64, 0x66, 0x30, 0x65, 0x33, 0x36, 0x35, 0x66, 0x37, 0x35, 0x63, 0x31, 0x38, 0x64, 0x62, 0x63, 0x38, 0x34, 0x38, 0x66, 0x36, 0x37, 0x34, 0x36, 0x61, 0x33, 0x63, 0x63, 0x61, 0x65, 0x31, 0x36, 0x38, 0x34, 0x37, 0x35, 0x32, 0x61, 0x32, 0x31, 0x37, 0x34, 0x30, 0x39, 0x62, 0x38, 0x62, 0x35, 0x37, 0x61, 0x39, 0x31, 0x61, 0x61, 0x30, 0x35, 0x65, 0x65, 0x61, 0x32, 0x37, 0x32, 0x66, 0x38, 0x63, 0x39, 0x36, 0x61, 0x30, 0x39, 0x35, 0x39, 0x34, 0x39, 0x35, 0x36, 0x63, 0x33, 0x65, 0x35, 0x64, 0x39, 0x31, 0x37, 0x63, 0x64, 0x36, 0x31, 0x35, 0x36, 0x63, 0x30, 0x39, 0x36, 0x63, 0x32, 0x36, 0x64, 0x62, 0x64, 0x39, 0x33, 0x66, 0x39, 0x61, 0x34, 0x66, 0x61, 0x35, 0x63, 0x38, 0x61, 0x34, 0x31, 0x31, 0x30, 0x39, 0x32, 0x63, 0x30, 0x63, 0x31, 0x63, 0x36, 0x33, 0x62, 0x65, 0x39, 0x34, 0x30, 0x33, 0x66, 0x31, 0x39, 0x64, 0x36, 0x63, 0x36, 0x61, 0x39, 0x61, 0x30, 0x35, 0x32, 0x66, 0x63, 0x34, 0x61, 0x36, 0x61, 0x63, 0x66, 0x34, 0x36, 0x63, 0x39, 0x66, 0x64, 0x61, 0x61, 0x66, 0x38, 0x61, 0x36, 0x36, 0x32, 0x35, 0x39, 0x31, 0x66, 0x37, 0x35, 0x34, 0x63, 0x33, 0x30, 0x39, 0x63, 0x32, 0x64, 0x35, 0x66, 0x36, 0x32, 0x37, 0x35, 0x65, 0x39, 0x32, 0x66, 0x36, 0x34, 0x62, 0x36, 0x66, 0x38, 0x31, 0x36, 0x34, 0x39, 0x66, 0x62, 0x66, 0x35, 0x65, 0x38, 0x66, 0x30, 0x35, 0x63, 0x37, 0x65, 0x37, 0x32, 0x38, 0x34, 0x32, 0x65, 0x61, 0x36, 0x32, 0x61, 0x63, 0x63, 0x39, 0x62, 0x38, 0x61, 0x62, 0x38, 0x63, 0x38, 0x32, 0x65, 0x34, 0x39, 0x62, 0x38, 0x65, 0x39, 0x36, 0x61, 0x66, 0x32, 0x32, 0x31, 0x39, 0x62, 0x32, 0x62, 0x39, 0x32, 0x37, 0x32, 0x32, 0x63, 0x64, 0x35, 0x61, 0x36, 0x32, 0x38, 0x61, 0x62, 0x31, 0x34, 0x66, 0x37, 0x34, 0x38, 0x33, 0x66, 0x38, 0x66, 0x35, 0x36, 0x32, 0x36, 0x31, 0x61, 0x61, 0x63, 0x31, 0x37, 0x65, 0x37, 0x62, 0x38, 0x62, 0x64, 0x31, 0x30, 0x31, 0x36, 0x61, 0x34, 0x61, 0x39, 0x36, 0x31, 0x36, 0x30, 0x37, 0x35, 0x38, 0x32, 0x39, 0x63, 0x32, 0x30, 0x65, 0x62, 0x35, 0x34, 0x30, 0x36, 0x37, 0x32, 0x63, 0x61, 0x38, 0x64, 0x38, 0x32, 0x39, 0x34, 0x37, 0x30, 0x63, 0x30, 0x30, 0x35, 0x30, 0x64, 0x38, 0x66, 0x30, 0x38, 0x34, 0x31, 0x37, 0x63, 0x64, 0x66, 0x34, 0x65, 0x62, 0x34, 0x31, 0x37, 0x65, 0x61, 0x30, 0x63, 0x35, 0x38, 0x36, 0x34, 0x65, 0x39, 0x65, 0x37, 0x63, 0x62, 0x38, 0x63, 0x61, 0x63, 0x61, 0x38, 0x38, 0x38, 0x33, 0x32, 0x63, 0x62, 0x32, 0x34, 0x35, 0x66, 0x37, 0x32, 0x36, 0x64, 0x36, 0x30, 0x61, 0x34, 0x36, 0x30, 0x30, 0x34, 0x66, 0x34, 0x62, 0x66, 0x37, 0x31, 0x66, 0x31, 0x30, 0x37, 0x33, 0x33, 0x30, 0x64, 0x36, 0x33, 0x34, 0x62, 0x38, 0x36, 0x64, 0x39, 0x66, 0x61, 0x38, 0x39, 0x30, 0x35, 0x31, 0x35, 0x37, 0x33, 0x65, 0x64, 0x39, 0x34, 0x37, 0x65, 0x37, 0x65, 0x30, 0x39, 0x35, 0x64, 0x38, 0x63, 0x66, 0x64, 0x36, 0x37, 0x37, 0x64, 0x37, 0x32, 0x33, 0x39, 0x36, 0x39, 0x31, 0x32, 0x61, 0x61, 0x31, 0x32, 0x62, 0x39, 0x66, 0x62, 0x38, 0x64, 0x64, 0x37, 0x64, 0x34, 0x66, 0x32, 0x31, 0x64, 0x63, 0x30, 0x62, 0x62, 0x32, 0x38, 0x66, 0x32, 0x64, 0x31, 0x65, 0x32, 0x39, 0x30, 0x34, 0x37, 0x36, 0x37, 0x38, 0x37, 0x66, 0x36, 0x33, 0x66, 0x61, 0x33, 0x65, 0x34, 0x65, 0x65, 0x64, 0x32, 0x34, 0x36, 0x39, 0x63, 0x66, 0x37, 0x37, 0x32, 0x63, 0x66, 0x61, 0x37, 0x34, 0x35, 0x31, 0x66, 0x64, 0x66, 0x31, 0x39, 0x36, 0x37, 0x34, 0x61, 0x30, 0x31, 0x30, 0x30, 0x64, 0x36, 0x30, 0x66, 0x66, 0x63, 0x35, 0x33, 0x35, 0x63, 0x64, 0x61, 0x38, 0x36, 0x63, 0x32, 0x34, 0x38, 0x64, 0x65, 0x31, 0x66, 0x31, 0x37, 0x63, 0x36, 0x30, 0x63, 0x64, 0x65, 0x31, 0x30, 0x34, 0x62, 0x39, 0x37, 0x34, 0x31, 0x30, 0x35, 0x65, 0x63, 0x36, 0x65, 0x64, 0x63, 0x39, 0x62, 0x37, 0x65, 0x34, 0x30, 0x38, 0x32, 0x32, 0x61, 0x39, 0x36, 0x62, 0x33, 0x63, 0x37, 0x65, 0x36, 0x30, 0x31, 0x38, 0x65, 0x36, 0x30, 0x64, 0x62, 0x32, 0x34, 0x39, 0x33, 0x64, 0x33, 0x65, 0x35, 0x33, 0x61, 0x61, 0x30, 0x63, 0x62, 0x39, 0x63, 0x61, 0x39, 0x65, 0x33, 0x35, 0x39, 0x39, 0x34, 0x30, 0x36, 0x34, 0x34, 0x33, 0x34, 0x37, 0x61, 0x65, 0x32, 0x33, 0x66, 0x65, 0x35, 0x33, 0x63, 0x39, 0x38, 0x30, 0x36, 0x32, 0x65, 0x37, 0x34, 0x63, 0x62, 0x39, 0x39, 0x31, 0x61, 0x64, 0x37, 0x65, 0x30, 0x33, 0x33, 0x34, 0x32, 0x36, 0x31, 0x34, 0x66, 0x38, 0x36, 0x39, 0x36, 0x62, 0x62, 0x66, 0x63, 0x30, 0x39, 0x37, 0x62, 0x31, 0x62, 0x61, 0x37, 0x36, 0x38, 0x65, 0x30, 0x34, 0x34, 0x34, 0x39, 0x64, 0x63, 0x62, 0x33, 0x32, 0x39, 0x38, 0x64, 0x37, 0x32, 0x65, 0x35, 0x30, 0x61, 0x30, 0x37, 0x33, 0x33, 0x61, 0x36, 0x34, 0x34, 0x61, 0x36, 0x63, 0x30, 0x36, 0x64, 0x30, 0x36, 0x65, 0x38, 0x32, 0x37, 0x34, 0x64, 0x39, 0x30, 0x65, 0x33, 0x64, 0x39, 0x39, 0x39, 0x34, 0x65, 0x64, 0x37, 0x62, 0x39, 0x32, 0x38, 0x61, 0x65, 0x37, 0x63, 0x37, 0x65, 0x66, 0x61, 0x64, 0x31, 0x34, 0x35, 0x65, 0x32, 0x33, 0x30, 0x36, 0x65, 0x62, 0x66, 0x33, 0x61, 0x32, 0x66, 0x32, 0x35, 0x38, 0x32, 0x32, 0x33, 0x61, 0x66, 0x65, 0x38, 0x66, 0x31, 0x64, 0x34, 0x32, 0x31, 0x39, 0x62, 0x66, 0x33, 0x37, 0x64, 0x61, 0x33, 0x36, 0x37, 0x30, 0x30, 0x32, 0x36, 0x32, 0x36, 0x34, 0x64, 0x34, 0x64, 0x63, 0x31, 0x64, 0x32, 0x39, 0x32, 0x38, 0x63, 0x31, 0x62, 0x37, 0x38, 0x36, 0x35, 0x62, 0x66, 0x39, 0x39, 0x62, 0x30, 0x33, 0x36, 0x64, 0x65, 0x37, 0x32, 0x38, 0x39, 0x32, 0x38, 0x36, 0x65, 0x63, 0x36, 0x61, 0x62, 0x64, 0x31, 0x32, 0x33, 0x35, 0x61, 0x64, 0x61, 0x37, 0x63, 0x34, 0x65, 0x66, 0x62, 0x33, 0x34, 0x39, 0x64, 0x32, 0x31, 0x66, 0x37, 0x39, 0x63, 0x61, 0x30, 0x35, 0x36, 0x32, 0x63, 0x65, 0x33, 0x65, 0x39, 0x33, 0x31, 0x65, 0x62, 0x35, 0x30, 0x64, 0x34, 0x31, 0x31, 0x36, 0x61, 0x34, 0x61, 0x66, 0x37, 0x62, 0x66, 0x37, 0x32, 0x62, 0x63, 0x66, 0x32, 0x66, 0x33, 0x39, 0x30, 0x33, 0x34, 0x31, 0x34, 0x31, 0x32, 0x63, 0x37, 0x37, 0x63, 0x62, 0x64, 0x65, 0x62, 0x61, 0x32, 0x36, 0x63, 0x61, 0x62, 0x61, 0x62, 0x35, 0x30, 0x64, 0x30, 0x35, 0x37, 0x36, 0x61, 0x30, 0x30, 0x62, 0x33, 0x31, 0x33, 0x66, 0x65, 0x63, 0x34, 0x32, 0x34, 0x62, 0x61, 0x30, 0x33, 0x64, 0x34, 0x64, 0x65, 0x31, 0x39, 0x61, 0x33, 0x37, 0x32, 0x33, 0x32, 0x36, 0x62, 0x31, 0x37, 0x31, 0x65, 0x32, 0x35, 0x31, 0x37, 0x30, 0x30, 0x61, 0x37, 0x32, 0x31, 0x32, 0x31, 0x64, 0x37, 0x66, 0x61, 0x30, 0x30, 0x30, 0x39, 0x65, 0x34, 0x65, 0x38, 0x63, 0x39, 0x34, 0x65, 0x31, 0x38, 0x36, 0x61, 0x37, 0x62, 0x65, 0x33, 0x36, 0x35, 0x62, 0x61, 0x31, 0x35, 0x36, 0x38, 0x64, 0x39, 0x39, 0x33, 0x61, 0x63, 0x31, 0x36, 0x62, 0x39, 0x37, 0x32, 0x30, 0x37, 0x36, 0x34, 0x38, 0x30, 0x36, 0x31, 0x39, 0x37, 0x62, 0x32, 0x65, 0x65, 0x61, 0x63, 0x32, 0x64, 0x37, 0x35, 0x36, 0x35, 0x37, 0x38, 0x33, 0x62, 0x39, 0x33, 0x38, 0x61, 0x36, 0x66, 0x62, 0x61, 0x62, 0x61, 0x35, 0x37, 0x63, 0x62, 0x36, 0x30, 0x30, 0x36, 0x32, 0x62, 0x35, 0x33, 0x63, 0x31, 0x65, 0x38, 0x63, 0x65, 0x32, 0x32, 0x36, 0x39, 0x38, 0x33, 0x61, 0x39, 0x37, 0x32, 0x64, 0x65, 0x65, 0x61, 0x39, 0x33, 0x63, 0x65, 0x64, 0x37, 0x62, 0x38, 0x38, 0x63, 0x32, 0x65, 0x38, 0x37, 0x39, 0x32, 0x30, 0x61, 0x30, 0x31, 0x35, 0x36, 0x63, 0x31, 0x62, 0x39, 0x34, 0x61, 0x34, 0x62, 0x65, 0x63, 0x30, 0x65, 0x34, 0x37, 0x66, 0x63, 0x66, 0x62, 0x33, 0x30, 0x65, 0x31, 0x39, 0x37, 0x32, 0x66, 0x30, 0x34, 0x37, 0x62, 0x35, 0x36, 0x32, 0x35, 0x32, 0x62, 0x36, 0x39, 0x64, 0x66, 0x32, 0x32, 0x66, 0x31, 0x32, 0x31, 0x37, 0x35, 0x38, 0x61, 0x34, 0x39, 0x62, 0x30, 0x38, 0x64, 0x38, 0x65, 0x35, 0x31, 0x34, 0x37, 0x61, 0x37, 0x36, 0x31, 0x31, 0x34, 0x33, 0x65, 0x36, 0x65, 0x63, 0x35, 0x65, 0x32, 0x61, 0x34, 0x33, 0x32, 0x32, 0x66, 0x39, 0x66, 0x65, 0x64, 0x61, 0x34, 0x64, 0x65, 0x65, 0x35, 0x39, 0x62, 0x32, 0x36, 0x38, 0x63, 0x34, 0x38, 0x37, 0x32, 0x35, 0x35, 0x30, 0x61, 0x37, 0x36, 0x63, 0x35, 0x62, 0x63, 0x30, 0x63, 0x30, 0x37, 0x32, 0x33, 0x32, 0x61, 0x37, 0x37, 0x63, 0x37, 0x64, 0x30, 0x34, 0x63, 0x34, 0x37, 0x62, 0x33, 0x30, 0x65, 0x66, 0x36, 0x39, 0x36, 0x35, 0x38, 0x34, 0x30, 0x37, 0x35, 0x36, 0x65, 0x30, 0x30, 0x37, 0x63, 0x63, 0x38, 0x37, 0x32, 0x66, 0x37, 0x31, 0x65, 0x39, 0x66, 0x61, 0x66, 0x31, 0x39, 0x34, 0x61, 0x36, 0x32, 0x62, 0x36, 0x39, 0x37, 0x38, 0x37, 0x65, 0x30, 0x31, 0x37, 0x37, 0x36, 0x32, 0x66, 0x64, 0x34, 0x66, 0x39, 0x31, 0x34, 0x38, 0x66, 0x37, 0x61, 0x34, 0x33, 0x62, 0x39, 0x64, 0x35, 0x30, 0x64, 0x38, 0x61, 0x62, 0x65, 0x34, 0x32, 0x39, 0x30, 0x66, 0x62, 0x39, 0x38, 0x36, 0x38, 0x36, 0x34, 0x63, 0x63, 0x66, 0x32, 0x34, 0x66, 0x39, 0x66, 0x35, 0x32, 0x66, 0x38, 0x34, 0x38, 0x33, 0x63, 0x38, 0x37, 0x65, 0x35, 0x65, 0x34, 0x65, 0x34, 0x35, 0x63, 0x34, 0x65, 0x39, 0x33, 0x35, 0x66, 0x34, 0x66, 0x33, 0x33, 0x37, 0x62, 0x37, 0x64, 0x38, 0x38, 0x62, 0x61, 0x61, 0x33, 0x38, 0x62, 0x39, 0x30, 0x33, 0x39, 0x66, 0x64, 0x66, 0x30, 0x33, 0x63, 0x65, 0x34, 0x30, 0x61, 0x39, 0x66, 0x66, 0x64, 0x63, 0x36, 0x65, 0x31, 0x31, 0x31, 0x66, 0x65, 0x36, 0x39, 0x32, 0x66, 0x33, 0x38, 0x63, 0x36, 0x35, 0x30, 0x37, 0x35, 0x32, 0x30, 0x31, 0x39, 0x64, 0x62, 0x32, 0x38, 0x33, 0x36, 0x36, 0x38, 0x35, 0x36, 0x30, 0x66, 0x64, 0x33, 0x31, 0x33, 0x34, 0x39, 0x63, 0x35, 0x38, 0x34, 0x39, 0x31, 0x38, 0x33, 0x66, 0x30, 0x64, 0x39, 0x31, 0x64, 0x65, 0x30, 0x64, 0x32, 0x62, 0x38, 0x38, 0x39, 0x33, 0x31, 0x65, 0x64, 0x33, 0x39, 0x33, 0x61, 0x33, 0x31, 0x37, 0x32, 0x36, 0x32, 0x34, 0x36, 0x34, 0x39, 0x39, 0x33, 0x37, 0x66, 0x62, 0x31, 0x61, 0x66, 0x62, 0x30, 0x34, 0x61, 0x39, 0x32, 0x66, 0x66, 0x32, 0x63, 0x34, 0x34, 0x36, 0x39, 0x30, 0x34, 0x31, 0x36, 0x37, 0x39, 0x30, 0x35, 0x37, 0x37, 0x36, 0x32, 0x64, 0x64, 0x64, 0x31, 0x35, 0x61, 0x34, 0x63, 0x38, 0x61, 0x34, 0x35, 0x30, 0x31, 0x62, 0x36, 0x31, 0x31, 0x36, 0x63, 0x39, 0x61, 0x37, 0x32, 0x61, 0x32, 0x32, 0x36, 0x30, 0x62, 0x32, 0x65, 0x38, 0x35, 0x38, 0x38, 0x39, 0x34, 0x38, 0x66, 0x61, 0x65, 0x36, 0x39, 0x31, 0x33, 0x30, 0x33, 0x63, 0x35, 0x61, 0x37, 0x30, 0x34, 0x31, 0x30, 0x32, 0x37, 0x63, 0x65, 0x34, 0x61, 0x35, 0x38, 0x32, 0x37, 0x63, 0x33, 0x39, 0x65, 0x64, 0x63, 0x36, 0x61, 0x38, 0x37, 0x31, 0x34, 0x34, 0x33, 0x34, 0x62, 0x35, 0x33, 0x37, 0x64, 0x37, 0x32, 0x34, 0x38, 0x38, 0x34, 0x66, 0x62, 0x62, 0x39, 0x61, 0x33, 0x39, 0x62, 0x66, 0x62, 0x66, 0x38, 0x38, 0x37, 0x65, 0x39, 0x34, 0x35, 0x31, 0x35, 0x37, 0x63, 0x61, 0x32, 0x65, 0x65, 0x39, 0x39, 0x30, 0x66, 0x64, 0x65, 0x64, 0x36, 0x38, 0x65, 0x33, 0x30, 0x36, 0x30, 0x34, 0x61, 0x66, 0x39, 0x39, 0x34, 0x32, 0x66, 0x38, 0x65, 0x33, 0x39, 0x31, 0x39, 0x35, 0x63, 0x35, 0x39, 0x37, 0x32, 0x61, 0x35, 0x33, 0x32, 0x33, 0x33, 0x33, 0x65, 0x66, 0x34, 0x64, 0x35, 0x65, 0x61, 0x63, 0x62, 0x63, 0x39, 0x62, 0x65, 0x38, 0x35, 0x33, 0x34, 0x32, 0x37, 0x33, 0x38, 0x35, 0x34, 0x35, 0x30, 0x33, 0x61, 0x30, 0x65, 0x62, 0x39, 0x34, 0x65, 0x62, 0x36, 0x30, 0x30, 0x37, 0x64, 0x34, 0x66, 0x37, 0x65, 0x66, 0x33, 0x38, 0x36, 0x63, 0x36, 0x61, 0x61, 0x33, 0x37, 0x61, 0x38, 0x36, 0x36, 0x65, 0x31, 0x63, 0x31, 0x32, 0x63, 0x30, 0x66, 0x33, 0x34, 0x66, 0x35, 0x64, 0x62, 0x32, 0x61, 0x39, 0x32, 0x62, 0x31, 0x65, 0x33, 0x61, 0x64, 0x34, 0x36, 0x37, 0x63, 0x37, 0x65, 0x31, 0x66, 0x37, 0x35, 0x62, 0x64, 0x61, 0x64, 0x33, 0x36, 0x65, 0x30, 0x35, 0x34, 0x37, 0x34, 0x65, 0x31, 0x35, 0x38, 0x31, 0x36, 0x62, 0x64, 0x31, 0x64, 0x66, 0x34, 0x65, 0x63, 0x38, 0x35, 0x32, 0x35, 0x39, 0x32, 0x36, 0x32, 0x64, 0x33, 0x66, 0x66, 0x37, 0x61, 0x35, 0x31, 0x38, 0x34, 0x66, 0x38, 0x30, 0x31, 0x32, 0x32, 0x62, 0x31, 0x33, 0x64, 0x65, 0x32, 0x30, 0x38, 0x65, 0x38, 0x37, 0x62, 0x64, 0x39, 0x62, 0x32, 0x63, 0x36, 0x30, 0x37, 0x65, 0x36, 0x65, 0x66, 0x61, 0x65, 0x38, 0x36, 0x34, 0x35, 0x36, 0x39, 0x61, 0x32, 0x64, 0x38, 0x62, 0x34, 0x36, 0x34, 0x66, 0x63, 0x30, 0x34, 0x37, 0x33, 0x64, 0x65, 0x61, 0x36, 0x35, 0x33, 0x35, 0x31, 0x66, 0x34, 0x65, 0x33, 0x64, 0x35, 0x32, 0x61, 0x34, 0x39, 0x37, 0x34, 0x35, 0x32, 0x63, 0x37, 0x39, 0x37, 0x34, 0x30, 0x63, 0x34, 0x35, 0x38, 0x34, 0x35, 0x30, 0x39, 0x31, 0x34, 0x65, 0x64, 0x61, 0x36, 0x38, 0x39, 0x34, 0x37, 0x34, 0x33, 0x36, 0x37, 0x32, 0x31, 0x37, 0x64, 0x31, 0x38, 0x64, 0x36, 0x32, 0x30, 0x34, 0x32, 0x65, 0x36, 0x33, 0x34, 0x38, 0x37, 0x63, 0x64, 0x61, 0x62, 0x37, 0x30, 0x65, 0x65, 0x66, 0x35, 0x31, 0x32, 0x66, 0x36, 0x36, 0x38, 0x31, 0x61, 0x32, 0x61, 0x65, 0x66, 0x34, 0x64, 0x32, 0x33, 0x35, 0x39, 0x37, 0x38, 0x33, 0x39, 0x33, 0x36, 0x63, 0x61, 0x65, 0x32, 0x61, 0x35, 0x63, 0x33, 0x64, 0x66, 0x38, 0x34, 0x33, 0x63, 0x39, 0x33, 0x63, 0x37, 0x66, 0x33, 0x35, 0x66, 0x37, 0x32, 0x30, 0x38, 0x62, 0x33, 0x38, 0x36, 0x62, 0x39, 0x38, 0x32, 0x32, 0x66, 0x37, 0x39, 0x64, 0x32, 0x31, 0x31, 0x35, 0x34, 0x61, 0x31, 0x65, 0x64, 0x66, 0x32, 0x35, 0x36, 0x38, 0x62, 0x34, 0x62, 0x33, 0x35, 0x35, 0x65, 0x64, 0x37, 0x64, 0x61, 0x33, 0x63, 0x66, 0x37, 0x65, 0x35, 0x65, 0x37, 0x39, 0x35, 0x34, 0x63, 0x61, 0x37, 0x35, 0x38, 0x32, 0x32, 0x31, 0x37, 0x61, 0x32, 0x37, 0x32, 0x38, 0x62, 0x63, 0x31, 0x63, 0x34, 0x32, 0x37, 0x36, 0x31, 0x30, 0x61, 0x33, 0x38, 0x33, 0x31, 0x64, 0x36, 0x37, 0x62, 0x39, 0x33, 0x31, 0x66, 0x32, 0x39, 0x36, 0x62, 0x33, 0x63, 0x33, 0x30, 0x62, 0x33, 0x37, 0x32, 0x64, 0x31, 0x39, 0x66, 0x63, 0x62, 0x34, 0x64, 0x36, 0x30, 0x62, 0x33, 0x63, 0x30, 0x62, 0x38, 0x62, 0x66, 0x65, 0x30, 0x66, 0x36, 0x36, 0x37, 0x35, 0x30, 0x33, 0x64, 0x63, 0x37, 0x63, 0x64, 0x37, 0x30, 0x64, 0x34, 0x31, 0x64, 0x66, 0x36, 0x32, 0x39, 0x66, 0x66, 0x31, 0x33, 0x39, 0x64, 0x30, 0x66, 0x36, 0x36, 0x39, 0x35, 0x32, 0x39, 0x30, 0x31, 0x66, 0x34, 0x32, 0x37, 0x39, 0x35, 0x63, 0x34, 0x62, 0x61, 0x62, 0x63, 0x36, 0x38, 0x66, 0x36, 0x35, 0x33, 0x65, 0x64, 0x30, 0x38, 0x30, 0x62, 0x63, 0x38, 0x39, 0x35, 0x66, 0x35, 0x36, 0x66, 0x34, 0x30, 0x35, 0x33, 0x61, 0x65, 0x63, 0x62, 0x39, 0x37, 0x66, 0x36, 0x36, 0x30, 0x33, 0x39, 0x32, 0x36, 0x61, 0x32, 0x61, 0x65, 0x32, 0x38, 0x35, 0x64, 0x66, 0x38, 0x63, 0x66, 0x32, 0x30, 0x63, 0x35, 0x37, 0x65, 0x33, 0x34, 0x65, 0x35, 0x36, 0x39, 0x36, 0x35, 0x65, 0x61, 0x61, 0x64, 0x64, 0x34, 0x66, 0x37, 0x62, 0x64, 0x31, 0x62, 0x32, 0x30, 0x33, 0x30, 0x38, 0x66, 0x38, 0x30, 0x37, 0x32, 0x35, 0x30, 0x38, 0x33, 0x39, 0x30, 0x37, 0x32, 0x34, 0x63, 0x61, 0x65, 0x35, 0x36, 0x31, 0x31, 0x66, 0x30, 0x35, 0x37, 0x34, 0x64, 0x31, 0x65, 0x38, 0x33, 0x63, 0x30, 0x64, 0x62, 0x64, 0x66, 0x62, 0x63, 0x36, 0x31, 0x61, 0x62, 0x30, 0x36, 0x66, 0x64, 0x63, 0x63, 0x30, 0x65, 0x36, 0x35, 0x62, 0x65, 0x33, 0x32, 0x62, 0x66, 0x32, 0x37, 0x32, 0x65, 0x61, 0x64, 0x38, 0x36, 0x37, 0x32, 0x35, 0x34, 0x35, 0x61, 0x38, 0x31, 0x34, 0x35, 0x62, 0x62, 0x31, 0x31, 0x37, 0x39, 0x35, 0x31, 0x31, 0x63, 0x38, 0x38, 0x32, 0x32, 0x63, 0x36, 0x33, 0x66, 0x66, 0x31, 0x65, 0x37, 0x62, 0x66, 0x62, 0x62, 0x33, 0x62, 0x38, 0x35, 0x32, 0x37, 0x63, 0x34, 0x38, 0x62, 0x61, 0x35, 0x62, 0x65, 0x32, 0x38, 0x33, 0x30, 0x37, 0x38, 0x65, 0x62, 0x66, 0x63, 0x61, 0x61, 0x32, 0x66, 0x37, 0x32, 0x65, 0x61, 0x66, 0x30, 0x61, 0x33, 0x36, 0x32, 0x66, 0x66, 0x37, 0x34, 0x37, 0x65, 0x32, 0x32, 0x36, 0x63, 0x34, 0x66, 0x32, 0x32, 0x38, 0x32, 0x38, 0x31, 0x66, 0x65, 0x35, 0x65, 0x33, 0x36, 0x30, 0x36, 0x65, 0x62, 0x38, 0x32, 0x36, 0x66, 0x34, 0x31, 0x36, 0x31, 0x38, 0x32, 0x38, 0x65, 0x65, 0x31, 0x61, 0x35, 0x30, 0x31, 0x64, 0x34, 0x38, 0x63, 0x36, 0x61, 0x33, 0x36, 0x32, 0x37, 0x34, 0x39, 0x62, 0x61, 0x34, 0x33, 0x30, 0x32, 0x62, 0x38, 0x39, 0x34, 0x31, 0x64, 0x38, 0x31, 0x62, 0x65, 0x37, 0x35, 0x31, 0x66, 0x32, 0x33, 0x63, 0x64, 0x32, 0x37, 0x62, 0x30, 0x34, 0x30, 0x63, 0x32, 0x64, 0x38, 0x39, 0x30, 0x63, 0x39, 0x61, 0x36, 0x61, 0x32, 0x30, 0x34, 0x37, 0x62, 0x33, 0x61, 0x31, 0x66, 0x37, 0x61, 0x33, 0x33, 0x66, 0x63, 0x65, 0x36, 0x31, 0x32, 0x37, 0x32, 0x35, 0x65, 0x37, 0x64, 0x38, 0x33, 0x31, 0x39, 0x64, 0x65, 0x63, 0x63, 0x35, 0x34, 0x35, 0x38, 0x30, 0x33, 0x61, 0x34, 0x32, 0x30, 0x30, 0x39, 0x39, 0x61, 0x64, 0x35, 0x61, 0x37, 0x63, 0x61, 0x35, 0x32, 0x62, 0x34, 0x31, 0x62, 0x30, 0x66, 0x35, 0x31, 0x65, 0x35, 0x38, 0x38, 0x64, 0x33, 0x35, 0x38, 0x33, 0x65, 0x37, 0x31, 0x32, 0x34, 0x34, 0x64, 0x37, 0x35, 0x30, 0x32, 0x37, 0x32, 0x33, 0x37, 0x31, 0x30, 0x37, 0x37, 0x31, 0x33, 0x64, 0x64, 0x61, 0x30, 0x38, 0x30, 0x33, 0x30, 0x35, 0x35, 0x33, 0x31, 0x34, 0x63, 0x31, 0x66, 0x61, 0x65, 0x38, 0x66, 0x63, 0x64, 0x38, 0x39, 0x39, 0x33, 0x36, 0x33, 0x32, 0x61, 0x37, 0x65, 0x64, 0x39, 0x31, 0x62, 0x62, 0x30, 0x66, 0x64, 0x63, 0x63, 0x37, 0x39, 0x31, 0x63, 0x66, 0x62, 0x33, 0x64, 0x37, 0x32, 0x30, 0x33, 0x37, 0x32, 0x64, 0x32, 0x66, 0x35, 0x30, 0x36, 0x39, 0x38, 0x36, 0x39, 0x38, 0x39, 0x30, 0x35, 0x31, 0x61, 0x36, 0x64, 0x33, 0x32, 0x37, 0x37, 0x37, 0x63, 0x32, 0x64, 0x31, 0x61, 0x61, 0x30, 0x32, 0x35, 0x32, 0x34, 0x36, 0x37, 0x38, 0x38, 0x66, 0x33, 0x30, 0x66, 0x35, 0x34, 0x63, 0x31, 0x34, 0x34, 0x63, 0x30, 0x35, 0x33, 0x35, 0x39, 0x38, 0x39, 0x33, 0x33, 0x33, 0x64, 0x35, 0x37, 0x37, 0x32, 0x33, 0x66, 0x39, 0x66, 0x66, 0x35, 0x34, 0x61, 0x36, 0x39, 0x31, 0x64, 0x30, 0x34, 0x33, 0x66, 0x32, 0x63, 0x32, 0x64, 0x38, 0x34, 0x61, 0x65, 0x39, 0x35, 0x32, 0x37, 0x32, 0x38, 0x30, 0x37, 0x38, 0x36, 0x30, 0x64, 0x36, 0x63, 0x35, 0x37, 0x36, 0x61, 0x30, 0x63, 0x36, 0x64, 0x66, 0x64, 0x39, 0x30, 0x63, 0x34, 0x62, 0x61, 0x65, 0x36, 0x62, 0x36, 0x35, 0x30, 0x33, 0x32, 0x37, 0x32, 0x32, 0x35, 0x30, 0x37, 0x38, 0x61, 0x63, 0x32, 0x62, 0x64, 0x39, 0x36, 0x64, 0x63, 0x35, 0x64, 0x36, 0x34, 0x36, 0x61, 0x38, 0x37, 0x33, 0x61, 0x36, 0x64, 0x37, 0x35, 0x34, 0x33, 0x63, 0x32, 0x65, 0x31, 0x32, 0x36, 0x35, 0x62, 0x37, 0x31, 0x66, 0x39, 0x39, 0x64, 0x33, 0x63, 0x39, 0x66, 0x31, 0x65, 0x32, 0x61, 0x30, 0x36, 0x61, 0x33, 0x30, 0x35, 0x39, 0x63, 0x30, 0x36, 0x37, 0x32, 0x37, 0x63, 0x30, 0x66, 0x35, 0x31, 0x39, 0x36, 0x34, 0x31, 0x39, 0x61, 0x66, 0x63, 0x31, 0x39, 0x61, 0x34, 0x35, 0x35, 0x62, 0x63, 0x33, 0x61, 0x64, 0x62, 0x34, 0x61, 0x65, 0x32, 0x33, 0x65, 0x36, 0x39, 0x65, 0x61, 0x30, 0x30, 0x37, 0x33, 0x65, 0x37, 0x63, 0x36, 0x30, 0x30, 0x66, 0x63, 0x35, 0x64, 0x66, 0x64, 0x37, 0x30, 0x35, 0x30, 0x62, 0x62, 0x61, 0x62, 0x38, 0x38, 0x35, 0x30, 0x62, 0x61, 0x33, 0x35, 0x62, 0x32, 0x35, 0x64, 0x65, 0x36, 0x64, 0x62, 0x62, 0x64, 0x38, 0x66, 0x37, 0x66, 0x37, 0x62, 0x33, 0x39, 0x35, 0x61, 0x63, 0x62, 0x36, 0x62, 0x36, 0x64, 0x34, 0x36, 0x30, 0x65, 0x37, 0x62, 0x37, 0x38, 0x38, 0x33, 0x65, 0x39, 0x33, 0x35, 0x30, 0x38, 0x63, 0x34, 0x32, 0x64, 0x37, 0x66, 0x32, 0x61, 0x66, 0x61, 0x34, 0x63, 0x38, 0x66, 0x39, 0x61, 0x32, 0x36, 0x66, 0x37, 0x36, 0x39, 0x66, 0x31, 0x61, 0x30, 0x64, 0x33, 0x31, 0x66, 0x65, 0x38, 0x38, 0x38, 0x63, 0x61, 0x37, 0x63, 0x61, 0x32, 0x37, 0x37, 0x31, 0x65, 0x31, 0x63, 0x31, 0x32, 0x38, 0x37, 0x33, 0x31, 0x34, 0x64, 0x32, 0x38, 0x33, 0x33, 0x65, 0x62, 0x64, 0x35, 0x33, 0x37, 0x32, 0x36, 0x61, 0x66, 0x38, 0x35, 0x36, 0x65, 0x34, 0x36, 0x35, 0x38, 0x61, 0x30, 0x62, 0x62, 0x36, 0x65, 0x64, 0x35, 0x35, 0x63, 0x34, 0x31, 0x61, 0x63, 0x30, 0x34, 0x62, 0x34, 0x33, 0x34, 0x61, 0x33, 0x65, 0x36, 0x37, 0x33, 0x36, 0x63, 0x64, 0x39, 0x32, 0x36, 0x31, 0x33, 0x30, 0x30, 0x62, 0x39, 0x33, 0x31, 0x35, 0x61, 0x64, 0x33, 0x36, 0x34, 0x63, 0x34, 0x36, 0x37, 0x32, 0x33, 0x38, 0x34, 0x38, 0x37, 0x62, 0x61, 0x30, 0x31, 0x30, 0x38, 0x61, 0x63, 0x65, 0x65, 0x64, 0x64, 0x31, 0x63, 0x38, 0x38, 0x31, 0x34, 0x66, 0x37, 0x66, 0x61, 0x39, 0x65, 0x31, 0x34, 0x62, 0x38, 0x32, 0x32, 0x34, 0x33, 0x31, 0x36, 0x34, 0x65, 0x38, 0x34, 0x37, 0x36, 0x30, 0x38, 0x38, 0x37, 0x61, 0x32, 0x34, 0x31, 0x39, 0x65, 0x31, 0x35, 0x35, 0x39, 0x31, 0x32, 0x33, 0x65, 0x39, 0x64, 0x35, 0x66, 0x39, 0x34, 0x31, 0x62, 0x64, 0x34, 0x31, 0x63, 0x38, 0x38, 0x33, 0x33, 0x63, 0x61, 0x37, 0x32, 0x33, 0x39, 0x30, 0x64, 0x33, 0x33, 0x61, 0x32, 0x37, 0x64, 0x34, 0x35, 0x62, 0x36, 0x65, 0x37, 0x33, 0x61, 0x62, 0x34, 0x65, 0x65, 0x30, 0x32, 0x66, 0x32, 0x33, 0x62, 0x33, 0x62, 0x30, 0x31, 0x65, 0x65, 0x30, 0x66, 0x39, 0x34, 0x62, 0x34, 0x61, 0x39, 0x38, 0x33, 0x30, 0x34, 0x36, 0x37, 0x31, 0x66, 0x31, 0x61, 0x61, 0x62, 0x34, 0x32, 0x33, 0x66, 0x65, 0x65, 0x63, 0x64, 0x32, 0x38, 0x37, 0x39, 0x66, 0x62, 0x36, 0x31, 0x39, 0x36, 0x35, 0x30, 0x33, 0x62, 0x36, 0x65, 0x62, 0x34, 0x39, 0x39, 0x66, 0x32, 0x30, 0x31, 0x34, 0x34, 0x63, 0x35, 0x36, 0x38, 0x33, 0x36, 0x63, 0x33, 0x63, 0x65, 0x66, 0x37, 0x38, 0x38, 0x64, 0x30, 0x61, 0x65, 0x35, 0x33, 0x30, 0x65, 0x38, 0x61, 0x65, 0x61, 0x63, 0x61, 0x66, 0x39, 0x63, 0x30, 0x31, 0x61, 0x65, 0x34, 0x30, 0x31, 0x37, 0x32, 0x32, 0x39, 0x37, 0x63, 0x35, 0x66, 0x34, 0x36, 0x66, 0x37, 0x30, 0x62, 0x30, 0x38, 0x35, 0x34, 0x31, 0x37, 0x62, 0x62, 0x31, 0x63, 0x34, 0x32, 0x31, 0x37, 0x65, 0x66, 0x36, 0x62, 0x30, 0x66, 0x33, 0x34, 0x30, 0x30, 0x62, 0x34, 0x39, 0x39, 0x34, 0x65, 0x35, 0x37, 0x63, 0x65, 0x66, 0x37, 0x31, 0x31, 0x36, 0x66, 0x65, 0x65, 0x61, 0x63, 0x33, 0x37, 0x63, 0x39, 0x32, 0x39, 0x33, 0x39, 0x32, 0x61, 0x62, 0x36, 0x62, 0x62, 0x39, 0x35, 0x66, 0x66, 0x65, 0x39, 0x32, 0x66, 0x36, 0x34, 0x33, 0x66, 0x36, 0x34, 0x65, 0x63, 0x37, 0x65, 0x30, 0x33, 0x36, 0x61, 0x66, 0x32, 0x36, 0x35, 0x36, 0x66, 0x38, 0x34, 0x37, 0x32, 0x37, 0x63, 0x63, 0x33, 0x30, 0x38, 0x33, 0x35, 0x34, 0x30, 0x39, 0x31, 0x63, 0x31, 0x63, 0x64, 0x37, 0x65, 0x61, 0x66, 0x34, 0x64, 0x66, 0x31, 0x37, 0x32, 0x34, 0x34, 0x62, 0x31, 0x61, 0x30, 0x34, 0x35, 0x31, 0x34, 0x64, 0x34, 0x66, 0x38, 0x65, 0x31, 0x36, 0x32, 0x39, 0x38, 0x38, 0x31, 0x63, 0x38, 0x34, 0x63, 0x62, 0x36, 0x66, 0x35, 0x62, 0x65, 0x31, 0x38, 0x32, 0x62, 0x34, 0x30, 0x62, 0x34, 0x39, 0x38, 0x63, 0x33, 0x66, 0x61, 0x61, 0x35, 0x35, 0x62, 0x32, 0x38, 0x61, 0x37, 0x38, 0x36, 0x34, 0x33, 0x36, 0x39, 0x32, 0x39, 0x37, 0x32, 0x38, 0x64, 0x61, 0x35, 0x32, 0x38, 0x65, 0x36, 0x30, 0x31, 0x35, 0x30, 0x30, 0x33, 0x34, 0x65, 0x31, 0x34, 0x36, 0x36, 0x62, 0x36, 0x30, 0x61, 0x37, 0x65, 0x62, 0x63, 0x66, 0x33, 0x37, 0x39, 0x35, 0x38, 0x34, 0x35, 0x35, 0x65, 0x62, 0x30, 0x39, 0x36, 0x38, 0x36, 0x39, 0x36, 0x35, 0x63, 0x38, 0x31, 0x62, 0x35, 0x38, 0x35, 0x62, 0x64, 0x63, 0x61, 0x61, 0x61, 0x64, 0x63, 0x37, 0x32, 0x35, 0x61, 0x63, 0x65, 0x31, 0x39, 0x31, 0x64, 0x65, 0x64, 0x61, 0x33, 0x62, 0x30, 0x64, 0x30, 0x66, 0x62, 0x33, 0x65, 0x36, 0x33, 0x36, 0x33, 0x66, 0x32, 0x38, 0x62, 0x36, 0x32, 0x36, 0x63, 0x31, 0x34, 0x65, 0x34, 0x35, 0x39, 0x31, 0x38, 0x62, 0x63, 0x33, 0x31, 0x34, 0x36, 0x38, 0x34, 0x36, 0x38, 0x32, 0x62, 0x36, 0x38, 0x63, 0x35, 0x31, 0x66, 0x64, 0x64, 0x31, 0x32, 0x37, 0x32, 0x33, 0x35, 0x63, 0x31, 0x64, 0x66, 0x61, 0x61, 0x30, 0x32, 0x31, 0x64, 0x64, 0x39, 0x36, 0x32, 0x35, 0x63, 0x65, 0x38, 0x34, 0x61, 0x64, 0x33, 0x64, 0x63, 0x33, 0x61, 0x63, 0x62, 0x37, 0x39, 0x37, 0x38, 0x66, 0x35, 0x37, 0x38, 0x32, 0x35, 0x61, 0x36, 0x66, 0x61, 0x61, 0x65, 0x39, 0x65, 0x37, 0x30, 0x34, 0x62, 0x39, 0x61, 0x62, 0x35, 0x31, 0x37, 0x37, 0x32, 0x64, 0x61, 0x36, 0x31, 0x31, 0x39, 0x65, 0x31, 0x38, 0x34, 0x61, 0x65, 0x31, 0x62, 0x63, 0x39, 0x39, 0x65, 0x65, 0x32, 0x39, 0x62, 0x66, 0x61, 0x64, 0x66, 0x38, 0x61, 0x62, 0x63, 0x38, 0x33, 0x61, 0x62, 0x36, 0x38, 0x30, 0x35, 0x34, 0x38, 0x38, 0x65, 0x38, 0x39, 0x63, 0x65, 0x32, 0x32, 0x61, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, 0x63, 0x31, 0x64, 0x39, 0x64, 0x65, 0x66, 0x30, 0x35, 0x37, 0x34, 0x36, 0x32, 0x64, 0x61, 0x33, 0x34, 0x63, 0x65, 0x66, 0x64, 0x38, 0x66, 0x66, 0x39, 0x36, 0x61, 0x62, 0x37, 0x36, 0x37, 0x64, 0x66, 0x62, 0x37, 0x64, 0x32, 0x64, 0x66, 0x33, 0x62, 0x39, 0x64, 0x32, 0x66, 0x31, 0x33, 0x37, 0x66, 0x63, 0x34, 0x30, 0x30, 0x33, 0x33, 0x38, 0x66, 0x65, 0x38, 0x38, 0x61, 0x36, 0x63, 0x31, 0x38, 0x66, 0x38, 0x35, 0x37, 0x37, 0x35, 0x30, 0x37, 0x66, 0x31, 0x31, 0x38, 0x38, 0x64, 0x63, 0x64, 0x35, 0x62, 0x63, 0x39, 0x37, 0x35, 0x66, 0x30, 0x34, 0x31, 0x32, 0x33, 0x39, 0x36, 0x62, 0x31, 0x62, 0x64, 0x35, 0x63, 0x31, 0x31, 0x66, 0x36, 0x66, 0x36, 0x30, 0x36, 0x35, 0x65, 0x30, 0x35, 0x38, 0x61, 0x66, 0x34, 0x35, 0x39, 0x38, 0x33, 0x35, 0x66, 0x66, 0x39, 0x34, 0x32, 0x61, 0x65, 0x34, 0x66, 0x38, 0x30, 0x61, 0x65, 0x34, 0x63, 0x31, 0x31, 0x37, 0x32, 0x33, 0x39, 0x38, 0x32, 0x38, 0x62, 0x39, 0x38, 0x62, 0x33, 0x62, 0x33, 0x34, 0x64, 0x30, 0x39, 0x32, 0x63, 0x63, 0x38, 0x63, 0x64, 0x35, 0x33, 0x61, 0x37, 0x66, 0x37, 0x65, 0x38, 0x30, 0x34, 0x64, 0x32, 0x65, 0x33, 0x33, 0x37, 0x63, 0x39, 0x66, 0x64, 0x38, 0x35, 0x37, 0x32, 0x32, 0x38, 0x65, 0x35, 0x32, 0x63, 0x36, 0x33, 0x37, 0x30, 0x65, 0x65, 0x64, 0x37, 0x36, 0x36, 0x37, 0x32, 0x39, 0x35, 0x35, 0x33, 0x66, 0x64, 0x39, 0x64, 0x63, 0x64, 0x62, 0x36, 0x34, 0x33, 0x61, 0x30, 0x31, 0x32, 0x37, 0x61, 0x65, 0x31, 0x63, 0x66, 0x63, 0x61, 0x38, 0x66, 0x65, 0x38, 0x62, 0x33, 0x38, 0x31, 0x31, 0x33, 0x38, 0x30, 0x62, 0x33, 0x33, 0x32, 0x37, 0x63, 0x33, 0x31, 0x32, 0x38, 0x64, 0x62, 0x34, 0x62, 0x36, 0x36, 0x39, 0x35, 0x61, 0x36, 0x62, 0x34, 0x61, 0x35, 0x37, 0x32, 0x61, 0x66, 0x35, 0x37, 0x63, 0x65, 0x33, 0x65, 0x35, 0x65, 0x39, 0x61, 0x66, 0x31, 0x35, 0x36, 0x66, 0x33, 0x63, 0x33, 0x38, 0x34, 0x62, 0x65, 0x63, 0x61, 0x62, 0x62, 0x35, 0x38, 0x37, 0x31, 0x37, 0x38, 0x34, 0x39, 0x66, 0x34, 0x39, 0x33, 0x61, 0x63, 0x61, 0x30, 0x32, 0x37, 0x62, 0x36, 0x66, 0x36, 0x39, 0x64, 0x36, 0x30, 0x36, 0x32, 0x63, 0x63, 0x64, 0x62, 0x33, 0x61, 0x32, 0x66, 0x62, 0x38, 0x32, 0x33, 0x30, 0x37, 0x37, 0x30, 0x62, 0x32, 0x32, 0x39, 0x62, 0x30, 0x61, 0x64, 0x37, 0x30, 0x39, 0x38, 0x32, 0x37, 0x33, 0x35, 0x32, 0x31, 0x36, 0x37, 0x35, 0x36, 0x35, 0x34, 0x64, 0x63, 0x37, 0x37, 0x33, 0x66, 0x66, 0x39, 0x30, 0x36, 0x34, 0x36, 0x33, 0x65, 0x31, 0x66, 0x33, 0x61, 0x64, 0x34, 0x39, 0x62, 0x63, 0x62, 0x36, 0x61, 0x34, 0x31, 0x38, 0x66, 0x34, 0x64, 0x35, 0x66, 0x61, 0x63, 0x35, 0x39, 0x33, 0x37, 0x37, 0x66, 0x63, 0x62, 0x38, 0x30, 0x34, 0x65, 0x33, 0x39, 0x36, 0x31, 0x34, 0x37, 0x35, 0x62, 0x33, 0x38, 0x61, 0x32, 0x35, 0x65, 0x33, 0x37, 0x36, 0x33, 0x63, 0x36, 0x39, 0x39, 0x65, 0x62, 0x34, 0x30, 0x66, 0x33, 0x33, 0x61, 0x65, 0x65, 0x30, 0x32, 0x31, 0x65, 0x34, 0x31, 0x64, 0x34, 0x34, 0x33, 0x66, 0x31, 0x30, 0x31, 0x37, 0x32, 0x35, 0x36, 0x63, 0x62, 0x38, 0x35, 0x31, 0x63, 0x61, 0x36, 0x31, 0x62, 0x31, 0x33, 0x37, 0x30, 0x32, 0x33, 0x39, 0x66, 0x34, 0x62, 0x30, 0x33, 0x61, 0x33, 0x34, 0x63, 0x61, 0x34, 0x66, 0x33, 0x37, 0x63, 0x37, 0x34, 0x66, 0x36, 0x66, 0x36, 0x63, 0x32, 0x32, 0x35, 0x31, 0x32, 0x64, 0x65, 0x62, 0x65, 0x66, 0x31, 0x62, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x61, 0x64, 0x37, 0x32, 0x66, 0x38, 0x61, 0x66, 0x65, 0x35, 0x65, 0x31, 0x35, 0x62, 0x34, 0x33, 0x36, 0x38, 0x35, 0x62, 0x31, 0x32, 0x38, 0x64, 0x33, 0x35, 0x37, 0x32, 0x61, 0x37, 0x32, 0x61, 0x34, 0x66, 0x63, 0x33, 0x33, 0x64, 0x33, 0x32, 0x61, 0x65, 0x64, 0x61, 0x36, 0x30, 0x38, 0x33, 0x66, 0x32, 0x36, 0x35, 0x33, 0x63, 0x37, 0x39, 0x32, 0x39, 0x64, 0x64, 0x34, 0x39, 0x62, 0x35, 0x62, 0x35, 0x32, 0x63, 0x39, 0x61, 0x36, 0x38, 0x36, 0x63, 0x30, 0x64, 0x39, 0x38, 0x31, 0x63, 0x64, 0x37, 0x61, 0x64, 0x35, 0x30, 0x31, 0x66, 0x31, 0x33, 0x37, 0x63, 0x62, 0x36, 0x36, 0x61, 0x66, 0x30, 0x34, 0x62, 0x64, 0x30, 0x35, 0x31, 0x38, 0x38, 0x64, 0x39, 0x33, 0x37, 0x63, 0x34, 0x64, 0x36, 0x66, 0x63, 0x30, 0x34, 0x34, 0x34, 0x65, 0x31, 0x31, 0x39, 0x61, 0x35, 0x30, 0x66, 0x30, 0x37, 0x37, 0x32, 0x31, 0x61, 0x32, 0x39, 0x37, 0x64, 0x64, 0x39, 0x65, 0x62, 0x31, 0x39, 0x37, 0x33, 0x64, 0x35, 0x33, 0x30, 0x66, 0x39, 0x62, 0x33, 0x38, 0x37, 0x31, 0x35, 0x35, 0x35, 0x35, 0x64, 0x39, 0x31, 0x63, 0x31, 0x65, 0x65, 0x63, 0x36, 0x32, 0x32, 0x35, 0x63, 0x36, 0x34, 0x62, 0x31, 0x66, 0x39, 0x30, 0x39, 0x33, 0x63, 0x39, 0x30, 0x33, 0x61, 0x30, 0x62, 0x61, 0x32, 0x62, 0x39, 0x37, 0x32, 0x33, 0x62, 0x36, 0x34, 0x34, 0x63, 0x65, 0x33, 0x64, 0x35, 0x35, 0x31, 0x61, 0x36, 0x66, 0x66, 0x35, 0x66, 0x39, 0x33, 0x32, 0x31, 0x62, 0x61, 0x31, 0x39, 0x39, 0x62, 0x33, 0x61, 0x61, 0x65, 0x31, 0x66, 0x61, 0x37, 0x36, 0x64, 0x34, 0x37, 0x38, 0x30, 0x32, 0x34, 0x33, 0x30, 0x38, 0x64, 0x64, 0x64, 0x38, 0x66, 0x31, 0x33, 0x63, 0x38, 0x65, 0x31, 0x37, 0x37, 0x62, 0x64, 0x37, 0x32, 0x35, 0x65, 0x66, 0x63, 0x65, 0x35, 0x32, 0x66, 0x65, 0x39, 0x37, 0x64, 0x63, 0x35, 0x36, 0x37, 0x35, 0x63, 0x37, 0x62, 0x36, 0x39, 0x31, 0x36, 0x65, 0x38, 0x35, 0x38, 0x39, 0x64, 0x35, 0x65, 0x34, 0x65, 0x63, 0x33, 0x33, 0x32, 0x38, 0x39, 0x33, 0x65, 0x35, 0x31, 0x38, 0x32, 0x61, 0x35, 0x33, 0x39, 0x30, 0x39, 0x39, 0x63, 0x39, 0x34, 0x30, 0x31, 0x62, 0x37, 0x65, 0x62, 0x37, 0x32, 0x34, 0x65, 0x61, 0x37, 0x37, 0x63, 0x38, 0x32, 0x33, 0x65, 0x39, 0x32, 0x34, 0x36, 0x35, 0x64, 0x65, 0x34, 0x36, 0x64, 0x38, 0x35, 0x30, 0x36, 0x63, 0x34, 0x37, 0x65, 0x62, 0x61, 0x30, 0x38, 0x35, 0x35, 0x62, 0x64, 0x32, 0x30, 0x66, 0x34, 0x34, 0x62, 0x30, 0x34, 0x38, 0x31, 0x63, 0x34, 0x65, 0x35, 0x61, 0x61, 0x63, 0x34, 0x64, 0x66, 0x66, 0x65, 0x61, 0x61, 0x39, 0x65, 0x37, 0x32, 0x63, 0x32, 0x33, 0x36, 0x62, 0x39, 0x30, 0x32, 0x31, 0x61, 0x34, 0x66, 0x33, 0x65, 0x34, 0x30, 0x64, 0x38, 0x37, 0x64, 0x37, 0x34, 0x35, 0x38, 0x62, 0x65, 0x33, 0x37, 0x32, 0x30, 0x30, 0x62, 0x39, 0x64, 0x35, 0x33, 0x66, 0x66, 0x66, 0x34, 0x31, 0x31, 0x34, 0x36, 0x34, 0x63, 0x33, 0x63, 0x61, 0x38, 0x33, 0x36, 0x66, 0x65, 0x32, 0x38, 0x65, 0x32, 0x32, 0x38, 0x63, 0x63, 0x31, 0x62, 0x61, 0x37, 0x37, 0x39, 0x66, 0x31, 0x33, 0x38, 0x39, 0x66, 0x32, 0x65, 0x37, 0x31, 0x30, 0x35, 0x34, 0x32, 0x32, 0x37, 0x62, 0x66, 0x62, 0x66, 0x64, 0x62, 0x34, 0x33, 0x62, 0x36, 0x30, 0x39, 0x65, 0x30, 0x39, 0x37, 0x31, 0x35, 0x33, 0x61, 0x62, 0x39, 0x65, 0x36, 0x32, 0x36, 0x31, 0x34, 0x36, 0x38, 0x34, 0x30, 0x36, 0x62, 0x33, 0x34, 0x63, 0x37, 0x39, 0x36, 0x38, 0x38, 0x37, 0x32, 0x36, 0x61, 0x34, 0x61, 0x61, 0x61, 0x39, 0x64, 0x37, 0x36, 0x38, 0x64, 0x64, 0x35, 0x39, 0x30, 0x38, 0x66, 0x37, 0x36, 0x32, 0x37, 0x39, 0x32, 0x63, 0x38, 0x33, 0x33, 0x64, 0x39, 0x35, 0x64, 0x38, 0x65, 0x31, 0x39, 0x34, 0x62, 0x32, 0x66, 0x61, 0x64, 0x37, 0x35, 0x36, 0x61, 0x65, 0x65, 0x35, 0x63, 0x33, 0x37, 0x64, 0x65, 0x35, 0x66, 0x34, 0x65, 0x32, 0x65, 0x64, 0x34, 0x34, 0x31, 0x37, 0x30, 0x64, 0x31, 0x66, 0x38, 0x30, 0x30, 0x38, 0x30, 0x61, 0x35, 0x36, 0x32, 0x65, 0x37, 0x61, 0x31, 0x30, 0x37, 0x66, 0x30, 0x66, 0x66, 0x37, 0x34, 0x31, 0x37, 0x30, 0x37, 0x65, 0x66, 0x64, 0x63, 0x64, 0x63, 0x66, 0x63, 0x31, 0x31, 0x36, 0x66, 0x35, 0x64, 0x36, 0x32, 0x33, 0x61, 0x61, 0x63, 0x64, 0x33, 0x31, 0x34, 0x62, 0x39, 0x31, 0x34, 0x33, 0x38, 0x63, 0x61, 0x37, 0x32, 0x66, 0x34, 0x36, 0x61, 0x34, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x32, 0x37, 0x65, 0x65, 0x66, 0x66, 0x38, 0x35, 0x35, 0x64, 0x36, 0x35, 0x33, 0x31, 0x63, 0x38, 0x62, 0x64, 0x33, 0x33, 0x63, 0x61, 0x66, 0x62, 0x65, 0x37, 0x34, 0x33, 0x31, 0x37, 0x37, 0x38, 0x62, 0x37, 0x33, 0x31, 0x34, 0x35, 0x31, 0x39, 0x61, 0x33, 0x30, 0x37, 0x31, 0x32, 0x39, 0x30, 0x31, 0x65, 0x30, 0x30, 0x32, 0x33, 0x62, 0x32, 0x34, 0x61, 0x61, 0x39, 0x39, 0x32, 0x66, 0x64, 0x64, 0x30, 0x34, 0x64, 0x35, 0x33, 0x37, 0x63, 0x62, 0x30, 0x64, 0x31, 0x30, 0x30, 0x37, 0x36, 0x31, 0x61, 0x30, 0x39, 0x39, 0x37, 0x37, 0x62, 0x33, 0x37, 0x34, 0x32, 0x30, 0x39, 0x64, 0x37, 0x38, 0x65, 0x65, 0x34, 0x61, 0x37, 0x31, 0x36, 0x37, 0x66, 0x38, 0x66, 0x33, 0x36, 0x63, 0x30, 0x63, 0x63, 0x64, 0x37, 0x32, 0x38, 0x32, 0x66, 0x63, 0x39, 0x36, 0x33, 0x31, 0x37, 0x66, 0x39, 0x61, 0x31, 0x61, 0x65, 0x30, 0x39, 0x39, 0x39, 0x61, 0x37, 0x31, 0x62, 0x30, 0x32, 0x39, 0x31, 0x62, 0x34, 0x66, 0x62, 0x33, 0x63, 0x64, 0x39, 0x62, 0x64, 0x35, 0x66, 0x36, 0x65, 0x64, 0x36, 0x65, 0x37, 0x38, 0x64, 0x32, 0x35, 0x66, 0x33, 0x35, 0x33, 0x32, 0x33, 0x39, 0x34, 0x63, 0x64, 0x31, 0x36, 0x37, 0x31, 0x33, 0x35, 0x37, 0x33, 0x32, 0x62, 0x32, 0x34, 0x31, 0x35, 0x37, 0x64, 0x30, 0x61, 0x63, 0x31, 0x66, 0x63, 0x33, 0x33, 0x35, 0x37, 0x36, 0x61, 0x64, 0x31, 0x38, 0x32, 0x33, 0x61, 0x65, 0x31, 0x64, 0x31, 0x39, 0x34, 0x61, 0x32, 0x30, 0x34, 0x64, 0x65, 0x64, 0x33, 0x34, 0x64, 0x66, 0x65, 0x34, 0x36, 0x39, 0x66, 0x66, 0x65, 0x62, 0x65, 0x37, 0x64, 0x63, 0x39, 0x39, 0x30, 0x62, 0x37, 0x32, 0x34, 0x38, 0x32, 0x65, 0x39, 0x62, 0x65, 0x37, 0x33, 0x35, 0x31, 0x37, 0x31, 0x37, 0x35, 0x39, 0x32, 0x66, 0x65, 0x32, 0x66, 0x32, 0x62, 0x65, 0x63, 0x35, 0x65, 0x63, 0x64, 0x63, 0x39, 0x31, 0x31, 0x32, 0x39, 0x39, 0x32, 0x37, 0x62, 0x32, 0x32, 0x31, 0x61, 0x64, 0x32, 0x34, 0x30, 0x31, 0x31, 0x63, 0x36, 0x64, 0x31, 0x31, 0x62, 0x66, 0x33, 0x61, 0x33, 0x35, 0x66, 0x33, 0x37, 0x32, 0x37, 0x66, 0x39, 0x33, 0x34, 0x33, 0x37, 0x32, 0x36, 0x31, 0x30, 0x31, 0x38, 0x34, 0x31, 0x61, 0x31, 0x38, 0x39, 0x37, 0x61, 0x65, 0x63, 0x38, 0x32, 0x64, 0x33, 0x63, 0x64, 0x33, 0x62, 0x30, 0x38, 0x63, 0x62, 0x39, 0x35, 0x66, 0x66, 0x37, 0x34, 0x31, 0x31, 0x35, 0x62, 0x32, 0x30, 0x32, 0x62, 0x30, 0x33, 0x36, 0x33, 0x37, 0x33, 0x61, 0x37, 0x32, 0x34, 0x31, 0x36, 0x62, 0x37, 0x32, 0x63, 0x31, 0x36, 0x65, 0x34, 0x66, 0x66, 0x64, 0x62, 0x36, 0x31, 0x32, 0x61, 0x36, 0x35, 0x39, 0x63, 0x65, 0x61, 0x66, 0x30, 0x30, 0x63, 0x34, 0x37, 0x37, 0x30, 0x37, 0x38, 0x62, 0x65, 0x39, 0x63, 0x62, 0x34, 0x61, 0x37, 0x34, 0x34, 0x62, 0x34, 0x35, 0x32, 0x33, 0x30, 0x62, 0x38, 0x65, 0x38, 0x32, 0x36, 0x39, 0x64, 0x32, 0x33, 0x63, 0x32, 0x32, 0x37, 0x36, 0x65, 0x66, 0x34, 0x38, 0x38, 0x38, 0x32, 0x35, 0x66, 0x65, 0x30, 0x34, 0x39, 0x35, 0x34, 0x64, 0x38, 0x35, 0x66, 0x65, 0x63, 0x65, 0x65, 0x32, 0x39, 0x64, 0x37, 0x32, 0x65, 0x64, 0x37, 0x31, 0x37, 0x34, 0x66, 0x38, 0x33, 0x36, 0x39, 0x62, 0x37, 0x63, 0x37, 0x61, 0x39, 0x32, 0x63, 0x64, 0x30, 0x61, 0x31, 0x31, 0x34, 0x36, 0x62, 0x38, 0x62, 0x30, 0x31, 0x62, 0x32, 0x39, 0x32, 0x61, 0x61, 0x34, 0x34, 0x35, 0x35, 0x36, 0x64, 0x33, 0x66, 0x34, 0x66, 0x30, 0x65, 0x62, 0x63, 0x64, 0x37, 0x63, 0x35, 0x35, 0x31, 0x64, 0x65, 0x32, 0x31, 0x34, 0x36, 0x32, 0x63, 0x33, 0x37, 0x65, 0x32, 0x66, 0x62, 0x32, 0x34, 0x38, 0x61, 0x35, 0x39, 0x34, 0x34, 0x66, 0x65, 0x65, 0x33, 0x62, 0x37, 0x33, 0x30, 0x62, 0x34, 0x62, 0x61, 0x64, 0x37, 0x63, 0x39, 0x38, 0x61, 0x30, 0x39, 0x35, 0x63, 0x36, 0x37, 0x32, 0x36, 0x62, 0x30, 0x35, 0x33, 0x63, 0x35, 0x35, 0x61, 0x35, 0x35, 0x39, 0x33, 0x39, 0x65, 0x30, 0x38, 0x33, 0x33, 0x38, 0x30, 0x32, 0x35, 0x63, 0x66, 0x62, 0x34, 0x31, 0x64, 0x32, 0x33, 0x39, 0x37, 0x63, 0x39, 0x31, 0x39, 0x61, 0x61, 0x39, 0x63, 0x61, 0x32, 0x34, 0x65, 0x39, 0x39, 0x61, 0x61, 0x64, 0x37, 0x65, 0x32, 0x36, 0x32, 0x65, 0x30, 0x34, 0x66, 0x33, 0x30, 0x37, 0x37, 0x32, 0x30, 0x63, 0x61, 0x30, 0x37, 0x66, 0x66, 0x31, 0x32, 0x31, 0x36, 0x61, 0x64, 0x66, 0x65, 0x39, 0x37, 0x36, 0x38, 0x63, 0x39, 0x35, 0x65, 0x61, 0x32, 0x66, 0x33, 0x31, 0x32, 0x36, 0x38, 0x62, 0x31, 0x35, 0x65, 0x35, 0x35, 0x34, 0x39, 0x36, 0x38, 0x65, 0x30, 0x64, 0x65, 0x37, 0x36, 0x39, 0x38, 0x64, 0x39, 0x32, 0x30, 0x65, 0x36, 0x62, 0x33, 0x63, 0x38, 0x38, 0x35, 0x61, 0x37, 0x32, 0x38, 0x39, 0x64, 0x66, 0x33, 0x63, 0x30, 0x36, 0x30, 0x35, 0x30, 0x31, 0x64, 0x31, 0x34, 0x38, 0x32, 0x32, 0x65, 0x62, 0x61, 0x39, 0x36, 0x33, 0x64, 0x62, 0x32, 0x36, 0x31, 0x62, 0x37, 0x61, 0x63, 0x39, 0x30, 0x62, 0x63, 0x30, 0x34, 0x62, 0x31, 0x31, 0x35, 0x33, 0x30, 0x36, 0x39, 0x35, 0x38, 0x30, 0x39, 0x36, 0x33, 0x61, 0x63, 0x62, 0x30, 0x61, 0x37, 0x65, 0x61, 0x61, 0x33, 0x35, 0x30, 0x32, 0x33, 0x62, 0x63, 0x37, 0x31, 0x30, 0x64, 0x35, 0x63, 0x66, 0x34, 0x62, 0x35, 0x37, 0x39, 0x35, 0x66, 0x36, 0x37, 0x33, 0x35, 0x66, 0x61, 0x30, 0x63, 0x38, 0x66, 0x65, 0x37, 0x62, 0x35, 0x62, 0x38, 0x63, 0x38, 0x32, 0x61, 0x39, 0x62, 0x32, 0x35, 0x62, 0x39, 0x39, 0x30, 0x32, 0x62, 0x32, 0x62, 0x65, 0x61, 0x65, 0x37, 0x34, 0x39, 0x63, 0x33, 0x30, 0x35, 0x61, 0x33, 0x66, 0x37, 0x33, 0x35, 0x30, 0x61, 0x38, 0x35, 0x64, 0x33, 0x39, 0x31, 0x33, 0x64, 0x35, 0x30, 0x63, 0x66, 0x32, 0x37, 0x37, 0x65, 0x33, 0x61, 0x30, 0x63, 0x62, 0x32, 0x62, 0x34, 0x63, 0x39, 0x37, 0x61, 0x62, 0x65, 0x37, 0x66, 0x36, 0x62, 0x37, 0x35, 0x31, 0x63, 0x37, 0x61, 0x35, 0x34, 0x31, 0x65, 0x32, 0x30, 0x61, 0x65, 0x38, 0x62, 0x39, 0x35, 0x63, 0x31, 0x31, 0x32, 0x66, 0x37, 0x32, 0x61, 0x35, 0x37, 0x61, 0x61, 0x32, 0x61, 0x37, 0x39, 0x33, 0x64, 0x39, 0x36, 0x62, 0x37, 0x33, 0x34, 0x34, 0x66, 0x63, 0x66, 0x61, 0x38, 0x66, 0x32, 0x61, 0x65, 0x37, 0x64, 0x63, 0x61, 0x33, 0x63, 0x37, 0x37, 0x62, 0x30, 0x30, 0x30, 0x32, 0x34, 0x38, 0x39, 0x62, 0x32, 0x62, 0x63, 0x39, 0x39, 0x38, 0x36, 0x62, 0x30, 0x38, 0x63, 0x39, 0x33, 0x62, 0x66, 0x31, 0x33, 0x66, 0x37, 0x32, 0x66, 0x62, 0x63, 0x63, 0x64, 0x36, 0x35, 0x39, 0x30, 0x35, 0x36, 0x61, 0x30, 0x37, 0x38, 0x64, 0x61, 0x35, 0x31, 0x66, 0x61, 0x64, 0x32, 0x62, 0x33, 0x65, 0x39, 0x33, 0x37, 0x34, 0x66, 0x65, 0x31, 0x66, 0x62, 0x66, 0x62, 0x35, 0x66, 0x61, 0x32, 0x63, 0x31, 0x62, 0x35, 0x64, 0x39, 0x32, 0x39, 0x65, 0x38, 0x30, 0x36, 0x66, 0x66, 0x31, 0x39, 0x63, 0x32, 0x33, 0x66, 0x66, 0x33, 0x30, 0x61, 0x33, 0x34, 0x63, 0x31, 0x37, 0x66, 0x62, 0x34, 0x32, 0x66, 0x65, 0x32, 0x63, 0x39, 0x37, 0x35, 0x38, 0x62, 0x30, 0x62, 0x36, 0x62, 0x39, 0x61, 0x64, 0x31, 0x31, 0x62, 0x36, 0x33, 0x63, 0x37, 0x30, 0x61, 0x39, 0x30, 0x36, 0x33, 0x35, 0x37, 0x62, 0x39, 0x35, 0x34, 0x35, 0x36, 0x38, 0x65, 0x31, 0x66, 0x36, 0x37, 0x61, 0x38, 0x36, 0x31, 0x38, 0x30, 0x63, 0x38, 0x62, 0x37, 0x32, 0x37, 0x61, 0x36, 0x64, 0x36, 0x31, 0x35, 0x33, 0x61, 0x61, 0x35, 0x34, 0x34, 0x65, 0x31, 0x66, 0x38, 0x38, 0x32, 0x35, 0x66, 0x36, 0x37, 0x64, 0x38, 0x64, 0x33, 0x65, 0x33, 0x34, 0x61, 0x35, 0x62, 0x32, 0x64, 0x65, 0x34, 0x38, 0x38, 0x31, 0x62, 0x62, 0x38, 0x66, 0x61, 0x36, 0x31, 0x32, 0x30, 0x64, 0x33, 0x38, 0x31, 0x37, 0x65, 0x61, 0x62, 0x62, 0x66, 0x38, 0x64, 0x64, 0x37, 0x32, 0x30, 0x30, 0x31, 0x32, 0x64, 0x38, 0x32, 0x39, 0x37, 0x35, 0x66, 0x33, 0x33, 0x34, 0x33, 0x62, 0x62, 0x32, 0x32, 0x31, 0x34, 0x63, 0x31, 0x33, 0x38, 0x62, 0x65, 0x62, 0x39, 0x31, 0x32, 0x62, 0x61, 0x38, 0x63, 0x38, 0x32, 0x33, 0x62, 0x39, 0x34, 0x35, 0x65, 0x38, 0x39, 0x62, 0x38, 0x37, 0x63, 0x33, 0x37, 0x37, 0x37, 0x66, 0x33, 0x30, 0x30, 0x65, 0x61, 0x34, 0x30, 0x31, 0x37, 0x32, 0x62, 0x32, 0x66, 0x35, 0x63, 0x36, 0x65, 0x39, 0x32, 0x64, 0x31, 0x66, 0x30, 0x38, 0x34, 0x65, 0x34, 0x38, 0x35, 0x66, 0x64, 0x37, 0x33, 0x31, 0x30, 0x34, 0x30, 0x38, 0x61, 0x37, 0x64, 0x64, 0x61, 0x63, 0x31, 0x31, 0x35, 0x32, 0x65, 0x31, 0x61, 0x65, 0x37, 0x61, 0x32, 0x61, 0x31, 0x38, 0x34, 0x32, 0x31, 0x32, 0x31, 0x64, 0x62, 0x36, 0x35, 0x64, 0x66, 0x65, 0x38, 0x66, 0x37, 0x32, 0x30, 0x35, 0x66, 0x35, 0x62, 0x63, 0x33, 0x34, 0x36, 0x61, 0x33, 0x35, 0x64, 0x33, 0x66, 0x38, 0x66, 0x65, 0x62, 0x31, 0x66, 0x31, 0x32, 0x62, 0x66, 0x36, 0x33, 0x37, 0x37, 0x33, 0x34, 0x31, 0x37, 0x34, 0x37, 0x39, 0x66, 0x38, 0x64, 0x37, 0x37, 0x62, 0x39, 0x31, 0x62, 0x35, 0x64, 0x30, 0x38, 0x63, 0x61, 0x33, 0x33, 0x63, 0x35, 0x66, 0x63, 0x34, 0x34, 0x38, 0x37, 0x32, 0x36, 0x61, 0x39, 0x65, 0x38, 0x37, 0x34, 0x61, 0x31, 0x38, 0x61, 0x63, 0x61, 0x30, 0x31, 0x33, 0x38, 0x34, 0x34, 0x36, 0x38, 0x37, 0x38, 0x38, 0x64, 0x31, 0x63, 0x37, 0x36, 0x61, 0x33, 0x37, 0x35, 0x39, 0x36, 0x30, 0x37, 0x30, 0x37, 0x65, 0x32, 0x37, 0x61, 0x39, 0x36, 0x66, 0x34, 0x31, 0x34, 0x64, 0x35, 0x36, 0x65, 0x37, 0x35, 0x64, 0x33, 0x30, 0x31, 0x36, 0x30, 0x39, 0x63, 0x31, 0x37, 0x32, 0x63, 0x66, 0x37, 0x33, 0x66, 0x38, 0x36, 0x37, 0x34, 0x62, 0x34, 0x34, 0x66, 0x63, 0x31, 0x39, 0x38, 0x38, 0x39, 0x64, 0x30, 0x32, 0x37, 0x36, 0x34, 0x37, 0x32, 0x37, 0x62, 0x33, 0x66, 0x30, 0x30, 0x62, 0x37, 0x32, 0x62, 0x31, 0x39, 0x63, 0x66, 0x62, 0x30, 0x31, 0x31, 0x38, 0x32, 0x31, 0x39, 0x38, 0x35, 0x62, 0x66, 0x35, 0x62, 0x36, 0x63, 0x34, 0x30, 0x34, 0x61, 0x38, 0x37, 0x32, 0x33, 0x38, 0x62, 0x36, 0x62, 0x34, 0x66, 0x35, 0x62, 0x35, 0x61, 0x65, 0x65, 0x63, 0x30, 0x33, 0x31, 0x61, 0x66, 0x30, 0x34, 0x33, 0x65, 0x30, 0x61, 0x64, 0x32, 0x34, 0x31, 0x62, 0x37, 0x35, 0x66, 0x32, 0x32, 0x31, 0x37, 0x64, 0x33, 0x39, 0x65, 0x33, 0x38, 0x38, 0x63, 0x38, 0x31, 0x39, 0x34, 0x63, 0x38, 0x31, 0x65, 0x31, 0x38, 0x36, 0x35, 0x37, 0x30, 0x37, 0x62, 0x31, 0x36, 0x36, 0x65, 0x38, 0x64, 0x33, 0x33, 0x30, 0x35, 0x64, 0x64, 0x61, 0x61, 0x62, 0x61, 0x35, 0x32, 0x32, 0x39, 0x38, 0x34, 0x63, 0x32, 0x66, 0x31, 0x36, 0x61, 0x64, 0x63, 0x39, 0x37, 0x61, 0x30, 0x65, 0x35, 0x62, 0x30, 0x33, 0x38, 0x30, 0x33, 0x37, 0x34, 0x38, 0x66, 0x34, 0x34, 0x30, 0x37, 0x63, 0x36, 0x64, 0x34, 0x34, 0x35, 0x38, 0x64, 0x33, 0x65, 0x66, 0x34, 0x64, 0x34, 0x33, 0x32, 0x34, 0x66, 0x65, 0x32, 0x34, 0x64, 0x66, 0x32, 0x61, 0x62, 0x34, 0x39, 0x37, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, 0x65, 0x30, 0x39, 0x35, 0x30, 0x63, 0x36, 0x64, 0x39, 0x64, 0x31, 0x35, 0x62, 0x63, 0x39, 0x65, 0x36, 0x32, 0x34, 0x34, 0x65, 0x36, 0x31, 0x31, 0x34, 0x62, 0x37, 0x31, 0x36, 0x34, 0x64, 0x39, 0x66, 0x39, 0x37, 0x38, 0x35, 0x65, 0x65, 0x37, 0x30, 0x30, 0x33, 0x31, 0x37, 0x32, 0x62, 0x33, 0x38, 0x31, 0x32, 0x38, 0x34, 0x61, 0x39, 0x61, 0x30, 0x34, 0x37, 0x65, 0x37, 0x38, 0x66, 0x66, 0x34, 0x66, 0x32, 0x34, 0x37, 0x30, 0x30, 0x61, 0x39, 0x36, 0x63, 0x62, 0x63, 0x32, 0x30, 0x34, 0x63, 0x34, 0x66, 0x64, 0x32, 0x35, 0x35, 0x31, 0x64, 0x62, 0x33, 0x30, 0x35, 0x33, 0x65, 0x33, 0x39, 0x65, 0x64, 0x39, 0x62, 0x34, 0x30, 0x61, 0x65, 0x35, 0x66, 0x37, 0x37, 0x32, 0x31, 0x39, 0x34, 0x32, 0x64, 0x63, 0x61, 0x39, 0x65, 0x36, 0x39, 0x64, 0x61, 0x33, 0x31, 0x65, 0x65, 0x37, 0x62, 0x35, 0x32, 0x35, 0x30, 0x31, 0x30, 0x66, 0x31, 0x62, 0x30, 0x35, 0x65, 0x35, 0x37, 0x34, 0x66, 0x61, 0x32, 0x62, 0x64, 0x30, 0x61, 0x63, 0x63, 0x63, 0x34, 0x39, 0x63, 0x33, 0x33, 0x32, 0x66, 0x65, 0x66, 0x38, 0x35, 0x63, 0x34, 0x61, 0x36, 0x32, 0x62, 0x39, 0x33, 0x34, 0x63, 0x32, 0x33, 0x62, 0x65, 0x34, 0x33, 0x64, 0x63, 0x35, 0x64, 0x35, 0x37, 0x64, 0x37, 0x36, 0x31, 0x36, 0x64, 0x33, 0x31, 0x35, 0x62, 0x38, 0x38, 0x37, 0x32, 0x66, 0x61, 0x32, 0x35, 0x63, 0x35, 0x36, 0x35, 0x62, 0x34, 0x32, 0x64, 0x61, 0x38, 0x61, 0x61, 0x63, 0x38, 0x34, 0x34, 0x31, 0x39, 0x66, 0x38, 0x39, 0x64, 0x38, 0x39, 0x31, 0x34, 0x30, 0x39, 0x39, 0x62, 0x63, 0x37, 0x32, 0x31, 0x65, 0x38, 0x61, 0x61, 0x36, 0x37, 0x66, 0x61, 0x39, 0x32, 0x32, 0x35, 0x37, 0x30, 0x63, 0x38, 0x65, 0x62, 0x62, 0x63, 0x66, 0x33, 0x32, 0x30, 0x36, 0x32, 0x64, 0x62, 0x31, 0x31, 0x65, 0x32, 0x35, 0x36, 0x34, 0x30, 0x32, 0x34, 0x37, 0x30, 0x37, 0x64, 0x63, 0x66, 0x66, 0x35, 0x66, 0x39, 0x66, 0x31, 0x63, 0x34, 0x34, 0x32, 0x66, 0x37, 0x66, 0x34, 0x30, 0x36, 0x32, 0x37, 0x32, 0x39, 0x65, 0x35, 0x61, 0x32, 0x31, 0x35, 0x34, 0x64, 0x31, 0x39, 0x30, 0x64, 0x39, 0x38, 0x62, 0x66, 0x33, 0x30, 0x65, 0x36, 0x30, 0x63, 0x39, 0x37, 0x31, 0x36, 0x39, 0x30, 0x35, 0x64, 0x61, 0x33, 0x63, 0x36, 0x63, 0x64, 0x35, 0x32, 0x36, 0x62, 0x34, 0x34, 0x64, 0x38, 0x34, 0x32, 0x34, 0x65, 0x31, 0x37, 0x65, 0x32, 0x36, 0x62, 0x32, 0x30, 0x38, 0x34, 0x33, 0x37, 0x30, 0x34, 0x61, 0x38, 0x62, 0x38, 0x37, 0x35, 0x37, 0x31, 0x33, 0x30, 0x66, 0x31, 0x38, 0x63, 0x38, 0x39, 0x66, 0x35, 0x33, 0x33, 0x31, 0x31, 0x38, 0x61, 0x34, 0x38, 0x39, 0x34, 0x66, 0x30, 0x61, 0x64, 0x32, 0x64, 0x66, 0x30, 0x39, 0x63, 0x35, 0x62, 0x64, 0x35, 0x66, 0x38, 0x66, 0x39, 0x66, 0x36, 0x39, 0x31, 0x33, 0x61, 0x35, 0x65, 0x36, 0x37, 0x64, 0x32, 0x62, 0x32, 0x65, 0x66, 0x32, 0x31, 0x35, 0x35, 0x37, 0x36, 0x64, 0x63, 0x33, 0x32, 0x32, 0x32, 0x37, 0x36, 0x31, 0x38, 0x31, 0x33, 0x36, 0x65, 0x36, 0x38, 0x30, 0x63, 0x31, 0x30, 0x38, 0x38, 0x63, 0x35, 0x66, 0x31, 0x34, 0x63, 0x66, 0x66, 0x35, 0x63, 0x62, 0x63, 0x37, 0x31, 0x37, 0x61, 0x39, 0x36, 0x33, 0x66, 0x63, 0x33, 0x38, 0x37, 0x64, 0x38, 0x62, 0x62, 0x31, 0x39, 0x65, 0x30, 0x31, 0x65, 0x37, 0x66, 0x64, 0x37, 0x32, 0x35, 0x36, 0x64, 0x30, 0x36, 0x39, 0x35, 0x39, 0x39, 0x35, 0x63, 0x61, 0x35, 0x34, 0x33, 0x36, 0x33, 0x33, 0x32, 0x38, 0x31, 0x39, 0x34, 0x61, 0x35, 0x66, 0x31, 0x36, 0x35, 0x30, 0x66, 0x61, 0x31, 0x33, 0x62, 0x35, 0x39, 0x34, 0x65, 0x63, 0x65, 0x36, 0x39, 0x61, 0x31, 0x33, 0x33, 0x66, 0x61, 0x35, 0x34, 0x35, 0x62, 0x64, 0x61, 0x66, 0x63, 0x32, 0x36, 0x66, 0x39, 0x33, 0x37, 0x32, 0x35, 0x61, 0x38, 0x37, 0x63, 0x63, 0x66, 0x32, 0x66, 0x36, 0x30, 0x30, 0x37, 0x32, 0x61, 0x38, 0x31, 0x33, 0x35, 0x62, 0x39, 0x34, 0x66, 0x35, 0x30, 0x62, 0x64, 0x64, 0x36, 0x62, 0x66, 0x35, 0x32, 0x35, 0x62, 0x32, 0x65, 0x35, 0x38, 0x34, 0x66, 0x32, 0x39, 0x32, 0x33, 0x62, 0x38, 0x65, 0x65, 0x38, 0x63, 0x32, 0x62, 0x35, 0x38, 0x33, 0x32, 0x38, 0x36, 0x64, 0x39, 0x39, 0x32, 0x38, 0x31, 0x31, 0x35, 0x65, 0x39, 0x31, 0x65, 0x30, 0x62, 0x62, 0x63, 0x30, 0x39, 0x37, 0x65, 0x35, 0x63, 0x31, 0x35, 0x38, 0x35, 0x33, 0x65, 0x33, 0x39, 0x66, 0x31, 0x62, 0x30, 0x37, 0x61, 0x35, 0x37, 0x30, 0x39, 0x64, 0x62, 0x38, 0x64, 0x36, 0x37, 0x65, 0x31, 0x39, 0x64, 0x37, 0x65, 0x62, 0x65, 0x38, 0x36, 0x66, 0x65, 0x62, 0x37, 0x34, 0x66, 0x64, 0x61, 0x62, 0x63, 0x63, 0x36, 0x35, 0x66, 0x30, 0x61, 0x62, 0x64, 0x61, 0x63, 0x30, 0x63, 0x31, 0x38, 0x62, 0x66, 0x38, 0x36, 0x35, 0x38, 0x35, 0x31, 0x36, 0x33, 0x39, 0x39, 0x35, 0x30, 0x36, 0x38, 0x30, 0x61, 0x34, 0x34, 0x61, 0x32, 0x64, 0x62, 0x61, 0x66, 0x63, 0x33, 0x62, 0x38, 0x32, 0x65, 0x35, 0x64, 0x39, 0x30, 0x31, 0x35, 0x31, 0x38, 0x37, 0x33, 0x34, 0x64, 0x38, 0x31, 0x30, 0x36, 0x33, 0x63, 0x36, 0x37, 0x32, 0x38, 0x34, 0x34, 0x32, 0x30, 0x38, 0x39, 0x31, 0x35, 0x30, 0x61, 0x65, 0x65, 0x65, 0x62, 0x36, 0x65, 0x31, 0x66, 0x64, 0x65, 0x36, 0x36, 0x39, 0x36, 0x36, 0x34, 0x35, 0x36, 0x35, 0x37, 0x30, 0x62, 0x66, 0x65, 0x61, 0x33, 0x30, 0x31, 0x63, 0x66, 0x39, 0x66, 0x32, 0x33, 0x31, 0x64, 0x34, 0x64, 0x39, 0x64, 0x38, 0x35, 0x61, 0x37, 0x66, 0x35, 0x30, 0x61, 0x39, 0x36, 0x34, 0x37, 0x32, 0x34, 0x38, 0x62, 0x32, 0x36, 0x64, 0x39, 0x33, 0x30, 0x64, 0x63, 0x36, 0x37, 0x62, 0x62, 0x33, 0x30, 0x31, 0x61, 0x34, 0x65, 0x65, 0x31, 0x35, 0x64, 0x62, 0x33, 0x63, 0x37, 0x33, 0x62, 0x63, 0x63, 0x63, 0x37, 0x63, 0x33, 0x34, 0x33, 0x30, 0x66, 0x35, 0x35, 0x38, 0x37, 0x62, 0x63, 0x66, 0x35, 0x35, 0x34, 0x34, 0x61, 0x37, 0x64, 0x33, 0x64, 0x63, 0x31, 0x36, 0x39, 0x39, 0x34, 0x61, 0x64, 0x38, 0x38, 0x61, 0x64, 0x61, 0x32, 0x65, 0x31, 0x66, 0x38, 0x36, 0x63, 0x30, 0x38, 0x63, 0x64, 0x31, 0x33, 0x61, 0x61, 0x39, 0x62, 0x66, 0x35, 0x39, 0x37, 0x34, 0x30, 0x63, 0x33, 0x64, 0x35, 0x33, 0x62, 0x35, 0x36, 0x37, 0x32, 0x39, 0x31, 0x33, 0x37, 0x65, 0x61, 0x66, 0x32, 0x37, 0x34, 0x65, 0x33, 0x62, 0x32, 0x31, 0x31, 0x63, 0x62, 0x65, 0x30, 0x39, 0x65, 0x66, 0x37, 0x32, 0x63, 0x37, 0x30, 0x64, 0x32, 0x65, 0x39, 0x37, 0x35, 0x61, 0x37, 0x39, 0x62, 0x64, 0x63, 0x37, 0x61, 0x63, 0x33, 0x33, 0x62, 0x36, 0x35, 0x64, 0x39, 0x31, 0x33, 0x61, 0x66, 0x30, 0x62, 0x61, 0x64, 0x37, 0x35, 0x39, 0x30, 0x39, 0x37, 0x64, 0x63, 0x36, 0x38, 0x39, 0x35, 0x30, 0x39, 0x61, 0x36, 0x65, 0x63, 0x33, 0x65, 0x61, 0x65, 0x37, 0x64, 0x65, 0x38, 0x37, 0x64, 0x36, 0x37, 0x32, 0x30, 0x34, 0x38, 0x34, 0x66, 0x37, 0x64, 0x33, 0x64, 0x66, 0x66, 0x36, 0x36, 0x37, 0x31, 0x63, 0x34, 0x63, 0x33, 0x34, 0x66, 0x38, 0x63, 0x31, 0x35, 0x34, 0x34, 0x36, 0x37, 0x63, 0x36, 0x61, 0x62, 0x38, 0x32, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x63, 0x61, 0x38, 0x33, 0x35, 0x35, 0x30, 0x37, 0x66, 0x39, 0x63, 0x30, 0x31, 0x62, 0x32, 0x39, 0x63, 0x36, 0x32, 0x34, 0x66, 0x34, 0x39, 0x38, 0x61, 0x32, 0x61, 0x31, 0x61, 0x34, 0x32, 0x32, 0x30, 0x31, 0x32, 0x38, 0x66, 0x39, 0x66, 0x62, 0x39, 0x34, 0x65, 0x30, 0x61, 0x62, 0x61, 0x36, 0x36, 0x33, 0x61, 0x65, 0x38, 0x31, 0x66, 0x38, 0x35, 0x33, 0x38, 0x64, 0x62, 0x38, 0x38, 0x62, 0x39, 0x36, 0x33, 0x37, 0x61, 0x35, 0x30, 0x37, 0x64, 0x37, 0x65, 0x31, 0x36, 0x30, 0x65, 0x63, 0x30, 0x37, 0x65, 0x30, 0x65, 0x30, 0x64, 0x65, 0x35, 0x38, 0x38, 0x36, 0x39, 0x32, 0x38, 0x31, 0x66, 0x63, 0x32, 0x35, 0x65, 0x36, 0x64, 0x35, 0x32, 0x33, 0x62, 0x63, 0x30, 0x39, 0x35, 0x38, 0x36, 0x38, 0x66, 0x33, 0x65, 0x38, 0x36, 0x39, 0x30, 0x32, 0x30, 0x39, 0x35, 0x64, 0x61, 0x63, 0x62, 0x65, 0x36, 0x32, 0x64, 0x61, 0x37, 0x32, 0x63, 0x35, 0x63, 0x66, 0x63, 0x61, 0x38, 0x61, 0x34, 0x36, 0x33, 0x34, 0x30, 0x36, 0x37, 0x65, 0x37, 0x66, 0x64, 0x38, 0x63, 0x39, 0x33, 0x32, 0x66, 0x64, 0x36, 0x35, 0x63, 0x61, 0x64, 0x33, 0x32, 0x36, 0x66, 0x35, 0x30, 0x35, 0x34, 0x61, 0x35, 0x63, 0x61, 0x31, 0x39, 0x65, 0x36, 0x35, 0x38, 0x63, 0x66, 0x31, 0x36, 0x65, 0x38, 0x64, 0x33, 0x38, 0x39, 0x64, 0x32, 0x62, 0x36, 0x37, 0x64, 0x30, 0x65, 0x64, 0x38, 0x39, 0x61, 0x39, 0x35, 0x39, 0x64, 0x33, 0x30, 0x37, 0x32, 0x37, 0x63, 0x38, 0x30, 0x34, 0x38, 0x34, 0x34, 0x63, 0x62, 0x30, 0x66, 0x37, 0x30, 0x39, 0x31, 0x64, 0x31, 0x38, 0x66, 0x35, 0x61, 0x37, 0x32, 0x37, 0x63, 0x66, 0x63, 0x35, 0x38, 0x32, 0x30, 0x37, 0x65, 0x33, 0x31, 0x35, 0x36, 0x61, 0x30, 0x65, 0x64, 0x62, 0x33, 0x64, 0x37, 0x39, 0x33, 0x34, 0x66, 0x64, 0x31, 0x62, 0x30, 0x34, 0x30, 0x61, 0x33, 0x65, 0x37, 0x34, 0x30, 0x37, 0x32, 0x35, 0x34, 0x35, 0x62, 0x37, 0x37, 0x64, 0x62, 0x66, 0x33, 0x34, 0x33, 0x30, 0x65, 0x65, 0x38, 0x38, 0x33, 0x61, 0x37, 0x31, 0x33, 0x39, 0x31, 0x37, 0x63, 0x38, 0x32, 0x61, 0x37, 0x32, 0x31, 0x37, 0x37, 0x33, 0x39, 0x33, 0x35, 0x61, 0x65, 0x33, 0x65, 0x34, 0x31, 0x36, 0x37, 0x62, 0x32, 0x37, 0x32, 0x63, 0x31, 0x63, 0x36, 0x62, 0x32, 0x61, 0x39, 0x31, 0x31, 0x65, 0x38, 0x37, 0x32, 0x65, 0x39, 0x35, 0x38, 0x30, 0x34, 0x65, 0x33, 0x65, 0x65, 0x36, 0x36, 0x37, 0x63, 0x36, 0x33, 0x63, 0x31, 0x63, 0x64, 0x34, 0x34, 0x62, 0x37, 0x62, 0x65, 0x33, 0x37, 0x31, 0x65, 0x62, 0x35, 0x32, 0x30, 0x36, 0x35, 0x35, 0x38, 0x66, 0x39, 0x32, 0x65, 0x65, 0x64, 0x63, 0x36, 0x33, 0x36, 0x32, 0x65, 0x37, 0x39, 0x33, 0x64, 0x35, 0x64, 0x36, 0x31, 0x36, 0x34, 0x64, 0x37, 0x34, 0x35, 0x66, 0x65, 0x31, 0x65, 0x36, 0x34, 0x34, 0x37, 0x61, 0x33, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, 0x39, 0x63, 0x34, 0x36, 0x64, 0x62, 0x32, 0x35, 0x38, 0x36, 0x35, 0x37, 0x30, 0x37, 0x62, 0x61, 0x31, 0x33, 0x37, 0x63, 0x35, 0x37, 0x64, 0x32, 0x61, 0x61, 0x34, 0x30, 0x39, 0x33, 0x31, 0x64, 0x61, 0x35, 0x37, 0x64, 0x36, 0x30, 0x33, 0x66, 0x35, 0x62, 0x32, 0x36, 0x38, 0x31, 0x37, 0x32, 0x38, 0x65, 0x64, 0x32, 0x39, 0x63, 0x39, 0x65, 0x33, 0x33, 0x66, 0x61, 0x30, 0x61, 0x32, 0x30, 0x63, 0x32, 0x63, 0x37, 0x37, 0x33, 0x38, 0x39, 0x37, 0x34, 0x66, 0x34, 0x30, 0x31, 0x30, 0x32, 0x36, 0x32, 0x62, 0x32, 0x39, 0x64, 0x64, 0x38, 0x30, 0x61, 0x31, 0x36, 0x64, 0x38, 0x39, 0x63, 0x35, 0x62, 0x36, 0x66, 0x36, 0x34, 0x37, 0x62, 0x63, 0x37, 0x34, 0x30, 0x66, 0x34, 0x34, 0x39, 0x32, 0x35, 0x62, 0x65, 0x33, 0x33, 0x64, 0x30, 0x66, 0x65, 0x32, 0x37, 0x34, 0x35, 0x66, 0x31, 0x66, 0x38, 0x35, 0x31, 0x64, 0x33, 0x33, 0x33, 0x35, 0x34, 0x32, 0x35, 0x32, 0x66, 0x36, 0x37, 0x38, 0x63, 0x34, 0x38, 0x61, 0x31, 0x32, 0x35, 0x61, 0x64, 0x36, 0x64, 0x66, 0x65, 0x36, 0x65, 0x34, 0x31, 0x35, 0x34, 0x38, 0x38, 0x63, 0x36, 0x63, 0x66, 0x35, 0x65, 0x35, 0x34, 0x37, 0x32, 0x61, 0x38, 0x65, 0x64, 0x64, 0x61, 0x62, 0x66, 0x33, 0x37, 0x64, 0x62, 0x34, 0x66, 0x33, 0x30, 0x38, 0x33, 0x37, 0x36, 0x36, 0x66, 0x65, 0x33, 0x31, 0x30, 0x37, 0x32, 0x63, 0x36, 0x38, 0x38, 0x36, 0x37, 0x31, 0x32, 0x32, 0x30, 0x38, 0x36, 0x64, 0x30, 0x35, 0x66, 0x35, 0x66, 0x34, 0x61, 0x37, 0x63, 0x61, 0x31, 0x38, 0x31, 0x36, 0x32, 0x30, 0x64, 0x65, 0x64, 0x35, 0x62, 0x32, 0x30, 0x39, 0x30, 0x37, 0x63, 0x62, 0x36, 0x36, 0x37, 0x35, 0x65, 0x33, 0x39, 0x32, 0x33, 0x65, 0x39, 0x62, 0x63, 0x39, 0x33, 0x30, 0x63, 0x64, 0x64, 0x62, 0x63, 0x33, 0x38, 0x61, 0x33, 0x35, 0x66, 0x31, 0x65, 0x35, 0x63, 0x34, 0x35, 0x66, 0x64, 0x64, 0x64, 0x37, 0x35, 0x34, 0x34, 0x37, 0x64, 0x36, 0x38, 0x38, 0x37, 0x32, 0x34, 0x32, 0x62, 0x30, 0x63, 0x36, 0x39, 0x65, 0x64, 0x37, 0x32, 0x65, 0x32, 0x66, 0x35, 0x64, 0x35, 0x37, 0x62, 0x66, 0x39, 0x37, 0x66, 0x35, 0x65, 0x63, 0x62, 0x39, 0x34, 0x65, 0x66, 0x32, 0x61, 0x39, 0x39, 0x38, 0x37, 0x30, 0x39, 0x36, 0x33, 0x64, 0x37, 0x66, 0x32, 0x65, 0x64, 0x33, 0x64, 0x35, 0x63, 0x36, 0x38, 0x32, 0x63, 0x64, 0x64, 0x62, 0x32, 0x65, 0x31, 0x32, 0x30, 0x37, 0x35, 0x32, 0x30, 0x30, 0x62, 0x37, 0x36, 0x32, 0x30, 0x37, 0x32, 0x30, 0x33, 0x31, 0x65, 0x61, 0x66, 0x61, 0x65, 0x33, 0x33, 0x62, 0x34, 0x30, 0x62, 0x38, 0x38, 0x66, 0x62, 0x38, 0x37, 0x31, 0x64, 0x32, 0x66, 0x62, 0x30, 0x63, 0x39, 0x35, 0x39, 0x39, 0x65, 0x61, 0x35, 0x39, 0x38, 0x62, 0x65, 0x62, 0x34, 0x62, 0x65, 0x34, 0x32, 0x36, 0x38, 0x39, 0x39, 0x31, 0x63, 0x34, 0x37, 0x32, 0x31, 0x38, 0x34, 0x38, 0x38, 0x31, 0x33, 0x33, 0x65, 0x37, 0x32, 0x39, 0x39, 0x65, 0x65, 0x34, 0x66, 0x34, 0x33, 0x66, 0x66, 0x62, 0x37, 0x66, 0x33, 0x63, 0x31, 0x34, 0x34, 0x63, 0x38, 0x62, 0x30, 0x39, 0x38, 0x34, 0x64, 0x66, 0x62, 0x37, 0x34, 0x34, 0x34, 0x38, 0x36, 0x39, 0x36, 0x61, 0x63, 0x37, 0x32, 0x66, 0x33, 0x37, 0x62, 0x36, 0x37, 0x38, 0x61, 0x65, 0x66, 0x31, 0x30, 0x32, 0x38, 0x34, 0x35, 0x63, 0x32, 0x37, 0x62, 0x39, 0x35, 0x31, 0x63, 0x30, 0x65, 0x63, 0x30, 0x33, 0x31, 0x66, 0x32, 0x35, 0x63, 0x31, 0x39, 0x32, 0x31, 0x37, 0x36, 0x62, 0x39, 0x32, 0x36, 0x32, 0x61, 0x32, 0x63, 0x38, 0x31, 0x62, 0x62, 0x35, 0x61, 0x64, 0x66, 0x62, 0x66, 0x35, 0x32, 0x63, 0x34, 0x36, 0x31, 0x37, 0x36, 0x37, 0x65, 0x38, 0x61, 0x36, 0x33, 0x64, 0x38, 0x30, 0x61, 0x38, 0x30, 0x62, 0x30, 0x64, 0x35, 0x31, 0x34, 0x39, 0x31, 0x35, 0x32, 0x31, 0x32, 0x31, 0x34, 0x62, 0x38, 0x34, 0x35, 0x63, 0x61, 0x33, 0x33, 0x33, 0x30, 0x35, 0x39, 0x66, 0x31, 0x37, 0x34, 0x64, 0x61, 0x65, 0x62, 0x39, 0x38, 0x37, 0x39, 0x39, 0x35, 0x32, 0x33, 0x34, 0x34, 0x64, 0x66, 0x66, 0x38, 0x65, 0x65, 0x62, 0x37, 0x63, 0x33, 0x35, 0x62, 0x33, 0x61, 0x31, 0x64, 0x34, 0x64, 0x34, 0x32, 0x36, 0x66, 0x62, 0x62, 0x63, 0x38, 0x62, 0x37, 0x37, 0x32, 0x61, 0x31, 0x66, 0x66, 0x30, 0x39, 0x31, 0x35, 0x37, 0x37, 0x66, 0x30, 0x33, 0x31, 0x34, 0x31, 0x33, 0x63, 0x62, 0x32, 0x66, 0x31, 0x39, 0x65, 0x39, 0x36, 0x64, 0x30, 0x34, 0x64, 0x64, 0x34, 0x62, 0x35, 0x33, 0x62, 0x65, 0x61, 0x37, 0x35, 0x37, 0x32, 0x33, 0x31, 0x30, 0x35, 0x37, 0x34, 0x36, 0x32, 0x34, 0x38, 0x65, 0x66, 0x36, 0x66, 0x39, 0x31, 0x64, 0x38, 0x30, 0x66, 0x34, 0x66, 0x32, 0x30, 0x30, 0x39, 0x65, 0x63, 0x33, 0x37, 0x30, 0x64, 0x65, 0x62, 0x61, 0x64, 0x31, 0x66, 0x64, 0x32, 0x66, 0x36, 0x34, 0x36, 0x63, 0x64, 0x35, 0x64, 0x66, 0x62, 0x30, 0x63, 0x32, 0x63, 0x31, 0x36, 0x32, 0x63, 0x61, 0x38, 0x61, 0x39, 0x32, 0x35, 0x33, 0x35, 0x62, 0x33, 0x35, 0x62, 0x63, 0x35, 0x32, 0x36, 0x31, 0x36, 0x31, 0x64, 0x33, 0x36, 0x34, 0x33, 0x35, 0x36, 0x31, 0x66, 0x65, 0x33, 0x61, 0x62, 0x64, 0x39, 0x35, 0x31, 0x61, 0x34, 0x66, 0x30, 0x30, 0x66, 0x61, 0x38, 0x61, 0x62, 0x62, 0x31, 0x39, 0x63, 0x65, 0x37, 0x63, 0x38, 0x64, 0x39, 0x37, 0x33, 0x33, 0x62, 0x32, 0x36, 0x32, 0x39, 0x66, 0x62, 0x39, 0x66, 0x66, 0x38, 0x63, 0x37, 0x66, 0x35, 0x63, 0x63, 0x36, 0x30, 0x33, 0x37, 0x63, 0x37, 0x30, 0x63, 0x32, 0x32, 0x38, 0x64, 0x63, 0x36, 0x32, 0x35, 0x36, 0x30, 0x36, 0x31, 0x30, 0x34, 0x65, 0x30, 0x31, 0x66, 0x39, 0x33, 0x63, 0x38, 0x31, 0x65, 0x39, 0x62, 0x63, 0x64, 0x63, 0x30, 0x37, 0x65, 0x32, 0x33, 0x37, 0x38, 0x61, 0x38, 0x64, 0x37, 0x39, 0x62, 0x62, 0x62, 0x61, 0x33, 0x35, 0x65, 0x37, 0x61, 0x35, 0x66, 0x61, 0x64, 0x34, 0x37, 0x32, 0x37, 0x39, 0x39, 0x33, 0x32, 0x63, 0x61, 0x30, 0x33, 0x65, 0x30, 0x30, 0x34, 0x37, 0x32, 0x64, 0x33, 0x36, 0x65, 0x36, 0x36, 0x66, 0x35, 0x35, 0x34, 0x39, 0x31, 0x63, 0x38, 0x36, 0x30, 0x62, 0x33, 0x61, 0x32, 0x62, 0x30, 0x61, 0x63, 0x33, 0x62, 0x38, 0x38, 0x36, 0x33, 0x64, 0x64, 0x34, 0x35, 0x33, 0x65, 0x32, 0x66, 0x36, 0x32, 0x65, 0x62, 0x61, 0x62, 0x37, 0x32, 0x38, 0x38, 0x66, 0x39, 0x65, 0x61, 0x33, 0x39, 0x35, 0x65, 0x37, 0x63, 0x31, 0x36, 0x35, 0x62, 0x37, 0x32, 0x31, 0x33, 0x39, 0x63, 0x39, 0x62, 0x35, 0x63, 0x35, 0x64, 0x61, 0x31, 0x66, 0x66, 0x39, 0x66, 0x33, 0x32, 0x30, 0x34, 0x62, 0x62, 0x30, 0x35, 0x61, 0x39, 0x64, 0x66, 0x30, 0x36, 0x39, 0x66, 0x66, 0x31, 0x32, 0x61, 0x39, 0x39, 0x30, 0x38, 0x62, 0x37, 0x35, 0x32, 0x64, 0x33, 0x64, 0x65, 0x33, 0x38, 0x63, 0x31, 0x37, 0x63, 0x38, 0x36, 0x35, 0x37, 0x39, 0x30, 0x63, 0x65, 0x36, 0x64, 0x61, 0x34, 0x33, 0x63, 0x65, 0x30, 0x31, 0x62, 0x65, 0x62, 0x35, 0x36, 0x35, 0x61, 0x62, 0x33, 0x64, 0x31, 0x38, 0x63, 0x36, 0x32, 0x32, 0x30, 0x64, 0x32, 0x63, 0x34, 0x33, 0x33, 0x35, 0x35, 0x32, 0x66, 0x34, 0x33, 0x31, 0x65, 0x35, 0x33, 0x36, 0x31, 0x35, 0x38, 0x66, 0x34, 0x62, 0x63, 0x33, 0x38, 0x63, 0x63, 0x34, 0x64, 0x36, 0x64, 0x63, 0x61, 0x31, 0x38, 0x64, 0x31, 0x37, 0x32, 0x63, 0x31, 0x34, 0x37, 0x35, 0x64, 0x62, 0x36, 0x64, 0x64, 0x31, 0x36, 0x62, 0x61, 0x37, 0x38, 0x38, 0x33, 0x37, 0x33, 0x62, 0x62, 0x30, 0x31, 0x39, 0x33, 0x30, 0x39, 0x34, 0x32, 0x30, 0x38, 0x62, 0x66, 0x35, 0x64, 0x65, 0x34, 0x64, 0x61, 0x37, 0x36, 0x64, 0x36, 0x38, 0x30, 0x32, 0x36, 0x34, 0x34, 0x38, 0x66, 0x65, 0x31, 0x36, 0x32, 0x35, 0x33, 0x32, 0x35, 0x63, 0x61, 0x37, 0x32, 0x64, 0x35, 0x31, 0x31, 0x61, 0x65, 0x64, 0x32, 0x66, 0x30, 0x63, 0x35, 0x63, 0x35, 0x38, 0x39, 0x31, 0x38, 0x63, 0x63, 0x30, 0x32, 0x30, 0x37, 0x31, 0x30, 0x36, 0x38, 0x35, 0x38, 0x61, 0x38, 0x30, 0x34, 0x64, 0x65, 0x31, 0x34, 0x32, 0x65, 0x63, 0x61, 0x39, 0x38, 0x38, 0x33, 0x35, 0x30, 0x34, 0x34, 0x34, 0x39, 0x63, 0x39, 0x35, 0x30, 0x34, 0x37, 0x39, 0x65, 0x37, 0x66, 0x37, 0x32, 0x35, 0x39, 0x30, 0x33, 0x61, 0x61, 0x61, 0x35, 0x35, 0x63, 0x35, 0x66, 0x63, 0x33, 0x63, 0x65, 0x30, 0x65, 0x37, 0x37, 0x65, 0x39, 0x62, 0x65, 0x34, 0x33, 0x64, 0x65, 0x31, 0x36, 0x66, 0x36, 0x33, 0x36, 0x65, 0x39, 0x65, 0x33, 0x33, 0x35, 0x32, 0x61, 0x61, 0x39, 0x63, 0x30, 0x66, 0x33, 0x66, 0x33, 0x63, 0x66, 0x65, 0x63, 0x61, 0x66, 0x39, 0x35, 0x62, 0x31, 0x35, 0x39, 0x37, 0x32, 0x34, 0x66, 0x61, 0x65, 0x63, 0x66, 0x66, 0x39, 0x36, 0x62, 0x35, 0x37, 0x35, 0x31, 0x34, 0x33, 0x61, 0x62, 0x32, 0x63, 0x34, 0x32, 0x34, 0x38, 0x39, 0x66, 0x33, 0x63, 0x33, 0x34, 0x64, 0x61, 0x66, 0x32, 0x31, 0x35, 0x62, 0x38, 0x35, 0x64, 0x36, 0x34, 0x66, 0x38, 0x62, 0x63, 0x34, 0x31, 0x66, 0x66, 0x34, 0x64, 0x64, 0x66, 0x30, 0x36, 0x35, 0x63, 0x36, 0x30, 0x35, 0x38, 0x37, 0x32, 0x65, 0x64, 0x65, 0x32, 0x34, 0x62, 0x65, 0x37, 0x31, 0x36, 0x62, 0x66, 0x35, 0x38, 0x38, 0x66, 0x61, 0x32, 0x62, 0x38, 0x63, 0x30, 0x34, 0x31, 0x36, 0x32, 0x62, 0x61, 0x65, 0x64, 0x61, 0x35, 0x65, 0x32, 0x64, 0x32, 0x30, 0x34, 0x65, 0x66, 0x64, 0x35, 0x62, 0x38, 0x33, 0x38, 0x38, 0x34, 0x32, 0x35, 0x30, 0x37, 0x62, 0x37, 0x62, 0x30, 0x36, 0x66, 0x36, 0x38, 0x65, 0x34, 0x37, 0x32, 0x31, 0x65, 0x61, 0x66, 0x33, 0x34, 0x62, 0x65, 0x37, 0x62, 0x31, 0x66, 0x36, 0x35, 0x37, 0x63, 0x65, 0x65, 0x62, 0x64, 0x39, 0x38, 0x31, 0x36, 0x32, 0x32, 0x64, 0x66, 0x38, 0x34, 0x64, 0x35, 0x33, 0x36, 0x65, 0x61, 0x36, 0x66, 0x34, 0x38, 0x33, 0x38, 0x62, 0x33, 0x36, 0x34, 0x33, 0x62, 0x34, 0x30, 0x33, 0x30, 0x34, 0x36, 0x36, 0x34, 0x36, 0x37, 0x33, 0x65, 0x63, 0x36, 0x34, 0x66, 0x62, 0x39, 0x31, 0x37, 0x34, 0x66, 0x33, 0x38, 0x35, 0x34, 0x37, 0x64, 0x32, 0x34, 0x38, 0x31, 0x65, 0x33, 0x65, 0x38, 0x35, 0x31, 0x66, 0x39, 0x62, 0x33, 0x63, 0x65, 0x64, 0x66, 0x37, 0x31, 0x33, 0x31, 0x30, 0x61, 0x39, 0x38, 0x33, 0x32, 0x64, 0x31, 0x63, 0x61, 0x64, 0x62, 0x39, 0x63, 0x36, 0x33, 0x63, 0x62, 0x38, 0x63, 0x38, 0x31, 0x35, 0x31, 0x36, 0x65, 0x65, 0x65, 0x37, 0x32, 0x66, 0x64, 0x61, 0x30, 0x30, 0x62, 0x37, 0x62, 0x64, 0x61, 0x33, 0x35, 0x33, 0x30, 0x31, 0x38, 0x34, 0x34, 0x63, 0x30, 0x63, 0x30, 0x32, 0x36, 0x61, 0x31, 0x36, 0x36, 0x65, 0x66, 0x38, 0x37, 0x31, 0x36, 0x36, 0x30, 0x38, 0x65, 0x35, 0x37, 0x62, 0x64, 0x30, 0x34, 0x30, 0x31, 0x33, 0x65, 0x37, 0x61, 0x38, 0x61, 0x61, 0x39, 0x33, 0x62, 0x32, 0x33, 0x63, 0x37, 0x30, 0x32, 0x37, 0x32, 0x62, 0x66, 0x32, 0x63, 0x31, 0x34, 0x35, 0x64, 0x36, 0x36, 0x38, 0x35, 0x31, 0x64, 0x32, 0x35, 0x37, 0x38, 0x33, 0x61, 0x65, 0x32, 0x36, 0x64, 0x61, 0x32, 0x32, 0x66, 0x65, 0x39, 0x61, 0x37, 0x35, 0x36, 0x64, 0x37, 0x39, 0x61, 0x63, 0x34, 0x32, 0x63, 0x38, 0x32, 0x66, 0x62, 0x30, 0x64, 0x66, 0x30, 0x65, 0x31, 0x35, 0x30, 0x63, 0x31, 0x66, 0x39, 0x65, 0x65, 0x38, 0x64, 0x37, 0x32, 0x62, 0x32, 0x31, 0x39, 0x30, 0x34, 0x36, 0x63, 0x34, 0x36, 0x32, 0x62, 0x31, 0x61, 0x62, 0x65, 0x38, 0x61, 0x32, 0x61, 0x63, 0x31, 0x37, 0x37, 0x33, 0x65, 0x66, 0x65, 0x31, 0x31, 0x33, 0x34, 0x62, 0x36, 0x63, 0x36, 0x63, 0x62, 0x61, 0x36, 0x33, 0x37, 0x61, 0x36, 0x63, 0x66, 0x65, 0x35, 0x33, 0x35, 0x39, 0x63, 0x35, 0x64, 0x38, 0x35, 0x33, 0x37, 0x37, 0x37, 0x64, 0x31, 0x33, 0x39, 0x61, 0x36, 0x36, 0x32, 0x61, 0x34, 0x63, 0x31, 0x39, 0x64, 0x30, 0x31, 0x34, 0x64, 0x35, 0x31, 0x35, 0x66, 0x30, 0x30, 0x64, 0x30, 0x32, 0x34, 0x36, 0x30, 0x39, 0x62, 0x61, 0x35, 0x34, 0x62, 0x31, 0x65, 0x31, 0x65, 0x63, 0x38, 0x34, 0x35, 0x63, 0x62, 0x34, 0x31, 0x34, 0x38, 0x32, 0x34, 0x64, 0x66, 0x64, 0x33, 0x61, 0x65, 0x65, 0x31, 0x33, 0x38, 0x31, 0x65, 0x61, 0x63, 0x36, 0x35, 0x63, 0x62, 0x65, 0x64, 0x37, 0x64, 0x30, 0x37, 0x36, 0x38, 0x66, 0x39, 0x34, 0x65, 0x31, 0x30, 0x32, 0x34, 0x37, 0x39, 0x36, 0x33, 0x39, 0x37, 0x66, 0x32, 0x66, 0x65, 0x63, 0x30, 0x30, 0x30, 0x65, 0x31, 0x38, 0x64, 0x65, 0x61, 0x62, 0x61, 0x34, 0x32, 0x65, 0x37, 0x65, 0x32, 0x37, 0x66, 0x36, 0x32, 0x66, 0x64, 0x63, 0x30, 0x32, 0x31, 0x33, 0x66, 0x63, 0x62, 0x31, 0x35, 0x37, 0x32, 0x30, 0x32, 0x31, 0x34, 0x61, 0x35, 0x31, 0x61, 0x31, 0x61, 0x65, 0x30, 0x65, 0x33, 0x61, 0x61, 0x30, 0x65, 0x66, 0x35, 0x64, 0x37, 0x32, 0x33, 0x62, 0x30, 0x31, 0x64, 0x36, 0x33, 0x62, 0x38, 0x63, 0x65, 0x61, 0x32, 0x33, 0x32, 0x34, 0x35, 0x34, 0x39, 0x62, 0x31, 0x63, 0x66, 0x31, 0x35, 0x33, 0x33, 0x36, 0x64, 0x33, 0x33, 0x31, 0x61, 0x39, 0x63, 0x66, 0x62, 0x32, 0x63, 0x37, 0x32, 0x37, 0x35, 0x30, 0x34, 0x39, 0x34, 0x37, 0x64, 0x62, 0x35, 0x61, 0x61, 0x61, 0x31, 0x61, 0x66, 0x35, 0x32, 0x61, 0x36, 0x66, 0x61, 0x31, 0x32, 0x32, 0x35, 0x62, 0x39, 0x65, 0x32, 0x30, 0x33, 0x31, 0x62, 0x34, 0x38, 0x66, 0x65, 0x35, 0x32, 0x36, 0x37, 0x61, 0x34, 0x34, 0x30, 0x37, 0x64, 0x30, 0x37, 0x38, 0x37, 0x34, 0x62, 0x35, 0x62, 0x31, 0x34, 0x37, 0x31, 0x35, 0x30, 0x34, 0x64, 0x34, 0x39, 0x35, 0x66, 0x35, 0x31, 0x64, 0x36, 0x65, 0x65, 0x36, 0x63, 0x38, 0x37, 0x36, 0x32, 0x34, 0x36, 0x37, 0x32, 0x66, 0x38, 0x66, 0x66, 0x38, 0x64, 0x31, 0x30, 0x66, 0x64, 0x63, 0x32, 0x30, 0x66, 0x66, 0x35, 0x33, 0x38, 0x62, 0x35, 0x31, 0x38, 0x66, 0x65, 0x65, 0x36, 0x32, 0x38, 0x36, 0x65, 0x34, 0x36, 0x30, 0x64, 0x66, 0x65, 0x38, 0x36, 0x31, 0x65, 0x65, 0x62, 0x37, 0x32, 0x64, 0x33, 0x31, 0x66, 0x61, 0x64, 0x33, 0x65, 0x64, 0x61, 0x65, 0x33, 0x62, 0x62, 0x66, 0x66, 0x64, 0x37, 0x32, 0x33, 0x31, 0x35, 0x33, 0x39, 0x33, 0x35, 0x62, 0x30, 0x35, 0x34, 0x61, 0x37, 0x30, 0x39, 0x66, 0x33, 0x63, 0x64, 0x34, 0x38, 0x66, 0x39, 0x34, 0x30, 0x30, 0x64, 0x37, 0x63, 0x61, 0x39, 0x34, 0x35, 0x38, 0x62, 0x65, 0x62, 0x36, 0x37, 0x61, 0x63, 0x64, 0x35, 0x34, 0x34, 0x34, 0x30, 0x36, 0x66, 0x66, 0x61, 0x65, 0x31, 0x38, 0x37, 0x64, 0x65, 0x34, 0x65, 0x31, 0x37, 0x34, 0x38, 0x30, 0x39, 0x39, 0x34, 0x63, 0x39, 0x37, 0x37, 0x37, 0x35, 0x61, 0x32, 0x66, 0x66, 0x31, 0x33, 0x37, 0x38, 0x33, 0x34, 0x32, 0x38, 0x32, 0x61, 0x32, 0x35, 0x30, 0x31, 0x30, 0x34, 0x32, 0x35, 0x34, 0x30, 0x37, 0x36, 0x62, 0x63, 0x66, 0x35, 0x30, 0x32, 0x30, 0x38, 0x34, 0x63, 0x33, 0x35, 0x63, 0x32, 0x34, 0x62, 0x32, 0x32, 0x33, 0x66, 0x36, 0x39, 0x62, 0x32, 0x64, 0x35, 0x31, 0x30, 0x38, 0x32, 0x39, 0x63, 0x38, 0x35, 0x32, 0x61, 0x30, 0x39, 0x66, 0x61, 0x63, 0x63, 0x32, 0x37, 0x64, 0x61, 0x35, 0x63, 0x62, 0x34, 0x37, 0x66, 0x61, 0x30, 0x32, 0x37, 0x65, 0x62, 0x32, 0x66, 0x33, 0x35, 0x38, 0x62, 0x36, 0x36, 0x65, 0x33, 0x38, 0x39, 0x30, 0x38, 0x35, 0x64, 0x66, 0x31, 0x38, 0x31, 0x66, 0x66, 0x64, 0x64, 0x34, 0x61, 0x39, 0x35, 0x37, 0x33, 0x38, 0x32, 0x65, 0x62, 0x63, 0x65, 0x34, 0x61, 0x31, 0x30, 0x63, 0x32, 0x61, 0x32, 0x66, 0x32, 0x37, 0x32, 0x61, 0x61, 0x62, 0x37, 0x66, 0x34, 0x35, 0x31, 0x61, 0x64, 0x38, 0x39, 0x65, 0x39, 0x66, 0x62, 0x31, 0x32, 0x61, 0x38, 0x38, 0x32, 0x33, 0x32, 0x36, 0x37, 0x64, 0x36, 0x65, 0x62, 0x36, 0x32, 0x36, 0x36, 0x32, 0x63, 0x61, 0x66, 0x35, 0x39, 0x34, 0x61, 0x62, 0x33, 0x61, 0x62, 0x31, 0x39, 0x36, 0x63, 0x37, 0x64, 0x36, 0x63, 0x38, 0x63, 0x37, 0x35, 0x37, 0x34, 0x39, 0x31, 0x62, 0x34, 0x31, 0x66, 0x32, 0x37, 0x38, 0x36, 0x31, 0x39, 0x63, 0x33, 0x66, 0x61, 0x30, 0x62, 0x62, 0x33, 0x62, 0x61, 0x64, 0x64, 0x39, 0x31, 0x66, 0x35, 0x38, 0x62, 0x65, 0x33, 0x36, 0x61, 0x32, 0x65, 0x66, 0x65, 0x66, 0x33, 0x64, 0x61, 0x64, 0x30, 0x35, 0x33, 0x31, 0x37, 0x64, 0x63, 0x30, 0x31, 0x38, 0x35, 0x32, 0x62, 0x30, 0x34, 0x32, 0x30, 0x39, 0x64, 0x34, 0x34, 0x32, 0x30, 0x62, 0x35, 0x63, 0x32, 0x61, 0x36, 0x31, 0x36, 0x31, 0x62, 0x39, 0x34, 0x61, 0x39, 0x65, 0x65, 0x35, 0x65, 0x36, 0x66, 0x35, 0x35, 0x63, 0x61, 0x66, 0x63, 0x37, 0x39, 0x36, 0x36, 0x30, 0x35, 0x37, 0x32, 0x65, 0x30, 0x32, 0x66, 0x32, 0x64, 0x34, 0x31, 0x33, 0x35, 0x38, 0x30, 0x30, 0x34, 0x63, 0x37, 0x35, 0x66, 0x35, 0x36, 0x34, 0x34, 0x38, 0x62, 0x64, 0x37, 0x30, 0x31, 0x36, 0x63, 0x38, 0x37, 0x61, 0x35, 0x39, 0x30, 0x64, 0x32, 0x62, 0x65, 0x65, 0x33, 0x38, 0x62, 0x32, 0x63, 0x66, 0x34, 0x64, 0x37, 0x63, 0x33, 0x30, 0x32, 0x63, 0x32, 0x63, 0x39, 0x34, 0x33, 0x30, 0x39, 0x37, 0x32, 0x61, 0x62, 0x30, 0x33, 0x64, 0x30, 0x37, 0x61, 0x38, 0x30, 0x39, 0x38, 0x62, 0x31, 0x36, 0x63, 0x30, 0x34, 0x36, 0x64, 0x30, 0x34, 0x63, 0x31, 0x34, 0x63, 0x63, 0x38, 0x30, 0x65, 0x35, 0x62, 0x35, 0x39, 0x65, 0x31, 0x36, 0x66, 0x66, 0x64, 0x38, 0x37, 0x30, 0x61, 0x35, 0x35, 0x32, 0x37, 0x37, 0x61, 0x30, 0x37, 0x34, 0x38, 0x34, 0x30, 0x61, 0x61, 0x32, 0x38, 0x63, 0x39, 0x37, 0x32, 0x37, 0x66, 0x36, 0x65, 0x37, 0x37, 0x39, 0x39, 0x37, 0x66, 0x32, 0x36, 0x31, 0x37, 0x30, 0x30, 0x35, 0x36, 0x31, 0x36, 0x64, 0x37, 0x39, 0x63, 0x32, 0x64, 0x64, 0x30, 0x33, 0x65, 0x37, 0x30, 0x31, 0x39, 0x30, 0x37, 0x38, 0x39, 0x31, 0x37, 0x64, 0x35, 0x65, 0x30, 0x65, 0x35, 0x64, 0x32, 0x65, 0x36, 0x33, 0x38, 0x65, 0x61, 0x33, 0x64, 0x32, 0x31, 0x34, 0x61, 0x33, 0x39, 0x31, 0x36, 0x37, 0x30, 0x63, 0x34, 0x35, 0x31, 0x32, 0x38, 0x31, 0x38, 0x61, 0x34, 0x63, 0x62, 0x38, 0x30, 0x34, 0x30, 0x64, 0x66, 0x63, 0x32, 0x35, 0x66, 0x64, 0x30, 0x32, 0x36, 0x34, 0x66, 0x61, 0x63, 0x36, 0x61, 0x62, 0x65, 0x64, 0x32, 0x66, 0x31, 0x33, 0x31, 0x63, 0x63, 0x65, 0x65, 0x30, 0x61, 0x64, 0x37, 0x66, 0x38, 0x63, 0x61, 0x61, 0x32, 0x36, 0x39, 0x35, 0x37, 0x64, 0x36, 0x34, 0x39, 0x38, 0x61, 0x33, 0x66, 0x32, 0x33, 0x30, 0x31, 0x35, 0x65, 0x66, 0x34, 0x64, 0x61, 0x31, 0x39, 0x65, 0x39, 0x31, 0x35, 0x64, 0x63, 0x65, 0x36, 0x65, 0x34, 0x30, 0x66, 0x30, 0x64, 0x65, 0x35, 0x62, 0x65, 0x31, 0x30, 0x31, 0x38, 0x35, 0x37, 0x61, 0x38, 0x34, 0x33, 0x64, 0x36, 0x64, 0x36, 0x30, 0x64, 0x63, 0x64, 0x32, 0x61, 0x31, 0x32, 0x65, 0x31, 0x64, 0x61, 0x64, 0x36, 0x35, 0x39, 0x63, 0x34, 0x61, 0x63, 0x33, 0x61, 0x65, 0x34, 0x39, 0x34, 0x65, 0x33, 0x38, 0x32, 0x61, 0x37, 0x33, 0x62, 0x32, 0x62, 0x33, 0x63, 0x38, 0x63, 0x65, 0x63, 0x35, 0x38, 0x65, 0x30, 0x66, 0x33, 0x35, 0x66, 0x37, 0x36, 0x38, 0x35, 0x32, 0x31, 0x65, 0x65, 0x38, 0x39, 0x65, 0x65, 0x33, 0x39, 0x66, 0x31, 0x35, 0x35, 0x66, 0x66, 0x64, 0x37, 0x34, 0x63, 0x65, 0x62, 0x35, 0x30, 0x32, 0x36, 0x32, 0x62, 0x63, 0x38, 0x36, 0x64, 0x66, 0x63, 0x33, 0x62, 0x30, 0x30, 0x65, 0x33, 0x62, 0x66, 0x63, 0x62, 0x63, 0x61, 0x33, 0x32, 0x36, 0x39, 0x34, 0x64, 0x32, 0x30, 0x65, 0x31, 0x66, 0x34, 0x31, 0x36, 0x37, 0x39, 0x35, 0x39, 0x32, 0x30, 0x36, 0x65, 0x31, 0x32, 0x38, 0x36, 0x34, 0x39, 0x32, 0x31, 0x63, 0x37, 0x36, 0x66, 0x38, 0x61, 0x64, 0x37, 0x66, 0x34, 0x36, 0x32, 0x37, 0x32, 0x33, 0x39, 0x37, 0x34, 0x32, 0x38, 0x62, 0x66, 0x38, 0x34, 0x62, 0x65, 0x62, 0x38, 0x62, 0x38, 0x36, 0x65, 0x34, 0x34, 0x31, 0x37, 0x30, 0x38, 0x36, 0x66, 0x61, 0x32, 0x39, 0x30, 0x35, 0x61, 0x37, 0x34, 0x34, 0x62, 0x63, 0x66, 0x63, 0x39, 0x64, 0x39, 0x64, 0x33, 0x32, 0x61, 0x33, 0x63, 0x39, 0x62, 0x39, 0x65, 0x62, 0x39, 0x32, 0x64, 0x61, 0x63, 0x39, 0x63, 0x66, 0x62, 0x32, 0x38, 0x33, 0x61, 0x63, 0x34, 0x39, 0x66, 0x34, 0x64, 0x63, 0x31, 0x37, 0x32, 0x65, 0x38, 0x63, 0x31, 0x62, 0x30, 0x35, 0x63, 0x36, 0x35, 0x39, 0x37, 0x64, 0x62, 0x65, 0x36, 0x61, 0x66, 0x64, 0x39, 0x32, 0x36, 0x30, 0x64, 0x36, 0x33, 0x33, 0x31, 0x37, 0x31, 0x34, 0x33, 0x64, 0x39, 0x36, 0x32, 0x65, 0x35, 0x36, 0x30, 0x32, 0x33, 0x65, 0x33, 0x34, 0x33, 0x36, 0x37, 0x31, 0x62, 0x37, 0x32, 0x35, 0x66, 0x32, 0x38, 0x61, 0x33, 0x61, 0x32, 0x61, 0x32, 0x64, 0x34, 0x38, 0x32, 0x62, 0x34, 0x30, 0x61, 0x39, 0x31, 0x39, 0x62, 0x38, 0x32, 0x37, 0x31, 0x34, 0x34, 0x33, 0x61, 0x36, 0x30, 0x38, 0x39, 0x64, 0x32, 0x38, 0x37, 0x33, 0x32, 0x62, 0x39, 0x39, 0x39, 0x65, 0x33, 0x35, 0x39, 0x65, 0x62, 0x64, 0x66, 0x62, 0x30, 0x32, 0x30, 0x32, 0x34, 0x30, 0x36, 0x31, 0x65, 0x31, 0x63, 0x33, 0x33, 0x66, 0x33, 0x38, 0x33, 0x61, 0x38, 0x66, 0x62, 0x66, 0x34, 0x62, 0x66, 0x63, 0x30, 0x38, 0x33, 0x38, 0x38, 0x35, 0x38, 0x31, 0x32, 0x63, 0x34, 0x37, 0x36, 0x31, 0x63, 0x65, 0x64, 0x38, 0x38, 0x34, 0x38, 0x39, 0x34, 0x36, 0x35, 0x37, 0x39, 0x32, 0x36, 0x35, 0x31, 0x62, 0x30, 0x66, 0x65, 0x65, 0x39, 0x65, 0x32, 0x30, 0x38, 0x64, 0x30, 0x65, 0x30, 0x34, 0x31, 0x37, 0x32, 0x61, 0x62, 0x64, 0x37, 0x32, 0x38, 0x61, 0x35, 0x62, 0x39, 0x64, 0x34, 0x63, 0x37, 0x35, 0x63, 0x32, 0x32, 0x31, 0x61, 0x64, 0x34, 0x61, 0x65, 0x61, 0x38, 0x37, 0x39, 0x32, 0x33, 0x38, 0x34, 0x66, 0x36, 0x61, 0x36, 0x31, 0x38, 0x34, 0x63, 0x31, 0x30, 0x32, 0x37, 0x61, 0x62, 0x33, 0x30, 0x65, 0x36, 0x62, 0x39, 0x34, 0x33, 0x32, 0x32, 0x37, 0x35, 0x31, 0x61, 0x64, 0x66, 0x37, 0x32, 0x34, 0x39, 0x33, 0x30, 0x61, 0x61, 0x37, 0x37, 0x63, 0x38, 0x66, 0x63, 0x63, 0x66, 0x64, 0x37, 0x66, 0x32, 0x37, 0x64, 0x35, 0x64, 0x66, 0x61, 0x38, 0x62, 0x62, 0x32, 0x61, 0x66, 0x61, 0x31, 0x30, 0x30, 0x64, 0x30, 0x30, 0x38, 0x38, 0x36, 0x34, 0x61, 0x64, 0x66, 0x30, 0x38, 0x37, 0x31, 0x36, 0x35, 0x63, 0x34, 0x30, 0x66, 0x37, 0x34, 0x38, 0x30, 0x36, 0x31, 0x34, 0x31, 0x37, 0x32, 0x33, 0x30, 0x34, 0x36, 0x38, 0x36, 0x65, 0x36, 0x39, 0x34, 0x37, 0x39, 0x36, 0x36, 0x36, 0x39, 0x61, 0x34, 0x66, 0x38, 0x61, 0x31, 0x31, 0x39, 0x35, 0x62, 0x39, 0x36, 0x61, 0x37, 0x61, 0x35, 0x35, 0x35, 0x38, 0x33, 0x63, 0x38, 0x37, 0x63, 0x39, 0x37, 0x62, 0x62, 0x64, 0x66, 0x64, 0x33, 0x66, 0x33, 0x38, 0x36, 0x37, 0x39, 0x62, 0x66, 0x31, 0x34, 0x33, 0x30, 0x62, 0x38, 0x37, 0x32, 0x34, 0x61, 0x37, 0x66, 0x32, 0x39, 0x66, 0x63, 0x32, 0x33, 0x62, 0x33, 0x36, 0x66, 0x62, 0x38, 0x61, 0x63, 0x34, 0x64, 0x63, 0x34, 0x32, 0x31, 0x62, 0x62, 0x38, 0x34, 0x38, 0x62, 0x64, 0x61, 0x62, 0x31, 0x38, 0x32, 0x33, 0x64, 0x34, 0x30, 0x30, 0x33, 0x61, 0x33, 0x39, 0x37, 0x33, 0x64, 0x34, 0x65, 0x63, 0x61, 0x65, 0x38, 0x38, 0x39, 0x34, 0x63, 0x64, 0x65, 0x62, 0x36, 0x37, 0x32, 0x32, 0x32, 0x65, 0x37, 0x30, 0x65, 0x33, 0x36, 0x61, 0x33, 0x64, 0x35, 0x61, 0x62, 0x39, 0x62, 0x65, 0x32, 0x39, 0x32, 0x62, 0x38, 0x63, 0x37, 0x38, 0x38, 0x37, 0x38, 0x63, 0x66, 0x32, 0x62, 0x36, 0x31, 0x32, 0x31, 0x30, 0x37, 0x32, 0x34, 0x64, 0x35, 0x63, 0x63, 0x31, 0x61, 0x32, 0x64, 0x38, 0x34, 0x36, 0x36, 0x65, 0x36, 0x35, 0x32, 0x36, 0x62, 0x37, 0x65, 0x33, 0x32, 0x35, 0x38, 0x33, 0x34, 0x36, 0x33, 0x35, 0x64, 0x36, 0x65, 0x66, 0x31, 0x31, 0x61, 0x32, 0x34, 0x33, 0x63, 0x31, 0x61, 0x66, 0x30, 0x32, 0x35, 0x31, 0x36, 0x34, 0x65, 0x61, 0x31, 0x30, 0x34, 0x30, 0x35, 0x31, 0x61, 0x66, 0x66, 0x30, 0x38, 0x66, 0x64, 0x37, 0x31, 0x33, 0x63, 0x31, 0x66, 0x64, 0x33, 0x38, 0x63, 0x33, 0x63, 0x30, 0x37, 0x64, 0x35, 0x63, 0x38, 0x65, 0x36, 0x62, 0x62, 0x31, 0x36, 0x31, 0x38, 0x63, 0x37, 0x36, 0x33, 0x38, 0x64, 0x37, 0x61, 0x35, 0x38, 0x34, 0x31, 0x32, 0x66, 0x61, 0x65, 0x35, 0x39, 0x64, 0x62, 0x36, 0x65, 0x65, 0x39, 0x64, 0x61, 0x63, 0x36, 0x66, 0x66, 0x37, 0x30, 0x66, 0x39, 0x30, 0x62, 0x33, 0x61, 0x65, 0x36, 0x62, 0x35, 0x33, 0x32, 0x32, 0x31, 0x35, 0x33, 0x36, 0x36, 0x33, 0x61, 0x62, 0x35, 0x62, 0x37, 0x32, 0x34, 0x62, 0x37, 0x37, 0x32, 0x37, 0x65, 0x36, 0x63, 0x37, 0x39, 0x63, 0x64, 0x39, 0x63, 0x64, 0x65, 0x62, 0x33, 0x65, 0x30, 0x34, 0x37, 0x63, 0x33, 0x35, 0x62, 0x64, 0x33, 0x64, 0x62, 0x38, 0x30, 0x35, 0x39, 0x34, 0x35, 0x36, 0x37, 0x30, 0x35, 0x30, 0x64, 0x35, 0x65, 0x30, 0x39, 0x37, 0x34, 0x64, 0x66, 0x37, 0x64, 0x66, 0x30, 0x34, 0x61, 0x31, 0x65, 0x34, 0x37, 0x34, 0x63, 0x31, 0x37, 0x61, 0x33, 0x35, 0x65, 0x38, 0x62, 0x61, 0x32, 0x37, 0x30, 0x38, 0x64, 0x37, 0x35, 0x37, 0x39, 0x62, 0x61, 0x65, 0x39, 0x35, 0x39, 0x66, 0x30, 0x63, 0x30, 0x61, 0x64, 0x35, 0x63, 0x32, 0x35, 0x35, 0x31, 0x33, 0x32, 0x62, 0x30, 0x63, 0x64, 0x36, 0x37, 0x30, 0x31, 0x61, 0x65, 0x30, 0x34, 0x35, 0x33, 0x63, 0x30, 0x39, 0x37, 0x62, 0x65, 0x61, 0x38, 0x37, 0x64, 0x34, 0x64, 0x66, 0x62, 0x33, 0x31, 0x30, 0x65, 0x63, 0x65, 0x30, 0x39, 0x63, 0x30, 0x38, 0x36, 0x65, 0x32, 0x62, 0x31, 0x61, 0x33, 0x37, 0x35, 0x61, 0x37, 0x39, 0x66, 0x36, 0x66, 0x31, 0x38, 0x31, 0x66, 0x31, 0x36, 0x61, 0x32, 0x63, 0x33, 0x35, 0x37, 0x34, 0x32, 0x65, 0x30, 0x39, 0x65, 0x64, 0x64, 0x37, 0x62, 0x30, 0x30, 0x33, 0x32, 0x39, 0x38, 0x65, 0x34, 0x62, 0x38, 0x30, 0x35, 0x64, 0x39, 0x38, 0x33, 0x61, 0x30, 0x37, 0x32, 0x35, 0x65, 0x38, 0x32, 0x35, 0x62, 0x33, 0x36, 0x64, 0x30, 0x32, 0x37, 0x63, 0x36, 0x61, 0x63, 0x30, 0x61, 0x61, 0x65, 0x30, 0x37, 0x39, 0x36, 0x32, 0x64, 0x63, 0x32, 0x30, 0x63, 0x39, 0x62, 0x33, 0x39, 0x39, 0x38, 0x39, 0x62, 0x66, 0x61, 0x62, 0x30, 0x35, 0x34, 0x66, 0x61, 0x62, 0x31, 0x37, 0x31, 0x33, 0x39, 0x64, 0x30, 0x35, 0x63, 0x65, 0x31, 0x34, 0x65, 0x33, 0x33, 0x36, 0x33, 0x63, 0x32, 0x30, 0x33, 0x36, 0x37, 0x38, 0x38, 0x33, 0x36, 0x32, 0x36, 0x32, 0x33, 0x31, 0x66, 0x37, 0x65, 0x36, 0x30, 0x32, 0x64, 0x35, 0x63, 0x37, 0x62, 0x66, 0x38, 0x61, 0x66, 0x62, 0x65, 0x30, 0x37, 0x61, 0x30, 0x62, 0x38, 0x63, 0x39, 0x30, 0x38, 0x35, 0x34, 0x65, 0x36, 0x66, 0x36, 0x65, 0x63, 0x33, 0x64, 0x38, 0x61, 0x66, 0x65, 0x61, 0x36, 0x31, 0x36, 0x33, 0x34, 0x30, 0x32, 0x36, 0x37, 0x65, 0x33, 0x62, 0x37, 0x35, 0x37, 0x64, 0x30, 0x66, 0x61, 0x63, 0x64, 0x34, 0x62, 0x37, 0x30, 0x31, 0x33, 0x31, 0x32, 0x33, 0x33, 0x32, 0x33, 0x32, 0x65, 0x39, 0x31, 0x61, 0x37, 0x34, 0x61, 0x38, 0x66, 0x39, 0x33, 0x35, 0x33, 0x39, 0x62, 0x63, 0x37, 0x64, 0x62, 0x64, 0x36, 0x36, 0x65, 0x65, 0x34, 0x39, 0x62, 0x64, 0x32, 0x63, 0x38, 0x35, 0x39, 0x34, 0x36, 0x36, 0x36, 0x31, 0x62, 0x33, 0x61, 0x31, 0x62, 0x36, 0x62, 0x31, 0x62, 0x32, 0x32, 0x32, 0x39, 0x65, 0x32, 0x32, 0x33, 0x64, 0x35, 0x39, 0x65, 0x63, 0x37, 0x65, 0x62, 0x37, 0x34, 0x32, 0x65, 0x39, 0x63, 0x36, 0x38, 0x61, 0x62, 0x61, 0x64, 0x39, 0x37, 0x61, 0x37, 0x63, 0x31, 0x62, 0x39, 0x36, 0x38, 0x65, 0x37, 0x65, 0x37, 0x62, 0x35, 0x35, 0x35, 0x64, 0x64, 0x34, 0x32, 0x62, 0x35, 0x36, 0x63, 0x38, 0x66, 0x66, 0x39, 0x64, 0x37, 0x38, 0x30, 0x33, 0x65, 0x66, 0x37, 0x37, 0x62, 0x31, 0x33, 0x36, 0x38, 0x65, 0x37, 0x39, 0x38, 0x61, 0x39, 0x38, 0x34, 0x62, 0x61, 0x62, 0x64, 0x31, 0x62, 0x62, 0x65, 0x34, 0x38, 0x38, 0x33, 0x36, 0x36, 0x66, 0x35, 0x61, 0x38, 0x62, 0x63, 0x31, 0x63, 0x65, 0x61, 0x30, 0x62, 0x36, 0x38, 0x37, 0x62, 0x38, 0x34, 0x66, 0x65, 0x66, 0x37, 0x37, 0x32, 0x32, 0x34, 0x64, 0x61, 0x62, 0x66, 0x34, 0x66, 0x61, 0x66, 0x61, 0x39, 0x39, 0x66, 0x61, 0x30, 0x61, 0x35, 0x33, 0x62, 0x39, 0x35, 0x65, 0x35, 0x62, 0x63, 0x35, 0x64, 0x38, 0x30, 0x34, 0x66, 0x63, 0x38, 0x30, 0x62, 0x32, 0x33, 0x37, 0x62, 0x31, 0x62, 0x39, 0x34, 0x31, 0x61, 0x37, 0x30, 0x39, 0x32, 0x31, 0x66, 0x61, 0x65, 0x37, 0x36, 0x61, 0x34, 0x65, 0x31, 0x30, 0x65, 0x36, 0x34, 0x36, 0x38, 0x66, 0x65, 0x66, 0x39, 0x65, 0x30, 0x34, 0x65, 0x34, 0x36, 0x63, 0x61, 0x31, 0x36, 0x63, 0x30, 0x30, 0x30, 0x38, 0x37, 0x61, 0x61, 0x33, 0x35, 0x36, 0x61, 0x61, 0x39, 0x30, 0x63, 0x62, 0x30, 0x64, 0x61, 0x62, 0x34, 0x62, 0x63, 0x37, 0x63, 0x63, 0x64, 0x64, 0x65, 0x62, 0x31, 0x61, 0x66, 0x37, 0x37, 0x34, 0x34, 0x64, 0x34, 0x36, 0x31, 0x61, 0x38, 0x62, 0x36, 0x37, 0x32, 0x65, 0x65, 0x33, 0x33, 0x32, 0x31, 0x61, 0x37, 0x31, 0x66, 0x36, 0x32, 0x62, 0x66, 0x65, 0x33, 0x63, 0x64, 0x64, 0x32, 0x31, 0x64, 0x33, 0x32, 0x66, 0x31, 0x38, 0x35, 0x62, 0x61, 0x35, 0x63, 0x32, 0x37, 0x30, 0x31, 0x66, 0x39, 0x65, 0x66, 0x62, 0x33, 0x32, 0x66, 0x32, 0x38, 0x30, 0x36, 0x33, 0x63, 0x34, 0x32, 0x39, 0x32, 0x35, 0x37, 0x35, 0x31, 0x65, 0x61, 0x38, 0x66, 0x33, 0x66, 0x33, 0x64, 0x36, 0x61, 0x34, 0x34, 0x36, 0x39, 0x66, 0x39, 0x34, 0x65, 0x30, 0x30, 0x34, 0x63, 0x66, 0x32, 0x62, 0x32, 0x31, 0x37, 0x33, 0x38, 0x62, 0x62, 0x32, 0x30, 0x36, 0x66, 0x34, 0x31, 0x30, 0x35, 0x32, 0x39, 0x61, 0x38, 0x34, 0x36, 0x64, 0x36, 0x37, 0x36, 0x35, 0x61, 0x64, 0x66, 0x34, 0x61, 0x32, 0x32, 0x61, 0x39, 0x31, 0x37, 0x39, 0x37, 0x37, 0x34, 0x65, 0x32, 0x34, 0x35, 0x65, 0x32, 0x34, 0x32, 0x64, 0x31, 0x33, 0x63, 0x32, 0x62, 0x65, 0x32, 0x37, 0x63, 0x36, 0x33, 0x31, 0x34, 0x31, 0x30, 0x61, 0x31, 0x36, 0x65, 0x37, 0x35, 0x34, 0x61, 0x63, 0x31, 0x38, 0x36, 0x39, 0x39, 0x62, 0x36, 0x66, 0x63, 0x38, 0x35, 0x33, 0x30, 0x63, 0x65, 0x37, 0x32, 0x39, 0x36, 0x37, 0x62, 0x62, 0x31, 0x34, 0x33, 0x32, 0x37, 0x61, 0x62, 0x32, 0x38, 0x36, 0x33, 0x37, 0x32, 0x62, 0x36, 0x35, 0x64, 0x37, 0x34, 0x30, 0x63, 0x65, 0x38, 0x64, 0x32, 0x35, 0x64, 0x35, 0x66, 0x64, 0x64, 0x32, 0x63, 0x34, 0x30, 0x33, 0x30, 0x63, 0x65, 0x37, 0x64, 0x32, 0x30, 0x64, 0x36, 0x37, 0x64, 0x39, 0x34, 0x35, 0x66, 0x62, 0x38, 0x35, 0x35, 0x38, 0x31, 0x34, 0x39, 0x65, 0x63, 0x65, 0x37, 0x35, 0x30, 0x30, 0x36, 0x32, 0x37, 0x34, 0x65, 0x35, 0x61, 0x64, 0x66, 0x37, 0x32, 0x64, 0x30, 0x37, 0x38, 0x35, 0x32, 0x32, 0x65, 0x38, 0x31, 0x61, 0x32, 0x36, 0x32, 0x33, 0x61, 0x61, 0x61, 0x63, 0x64, 0x34, 0x35, 0x61, 0x35, 0x65, 0x63, 0x65, 0x64, 0x37, 0x35, 0x36, 0x65, 0x61, 0x36, 0x63, 0x30, 0x61, 0x65, 0x66, 0x31, 0x36, 0x33, 0x38, 0x37, 0x31, 0x65, 0x35, 0x31, 0x34, 0x36, 0x38, 0x36, 0x61, 0x62, 0x37, 0x34, 0x32, 0x63, 0x30, 0x30, 0x30, 0x64, 0x37, 0x32, 0x36, 0x65, 0x62, 0x32, 0x64, 0x64, 0x36, 0x61, 0x31, 0x32, 0x37, 0x61, 0x33, 0x66, 0x35, 0x61, 0x61, 0x66, 0x61, 0x38, 0x65, 0x30, 0x63, 0x65, 0x36, 0x65, 0x64, 0x34, 0x39, 0x64, 0x33, 0x61, 0x61, 0x39, 0x36, 0x35, 0x32, 0x36, 0x65, 0x61, 0x61, 0x66, 0x36, 0x31, 0x39, 0x66, 0x39, 0x34, 0x30, 0x38, 0x32, 0x34, 0x61, 0x33, 0x34, 0x31, 0x63, 0x35, 0x63, 0x34, 0x34, 0x35, 0x30, 0x37, 0x32, 0x66, 0x63, 0x33, 0x34, 0x35, 0x63, 0x61, 0x37, 0x31, 0x66, 0x37, 0x37, 0x61, 0x32, 0x66, 0x65, 0x33, 0x31, 0x33, 0x65, 0x31, 0x31, 0x66, 0x32, 0x38, 0x31, 0x34, 0x31, 0x39, 0x31, 0x33, 0x36, 0x62, 0x37, 0x36, 0x34, 0x66, 0x61, 0x35, 0x31, 0x33, 0x30, 0x38, 0x32, 0x35, 0x62, 0x32, 0x63, 0x35, 0x31, 0x30, 0x39, 0x64, 0x66, 0x65, 0x33, 0x66, 0x65, 0x33, 0x38, 0x39, 0x31, 0x61, 0x37, 0x31, 0x61, 0x31, 0x38, 0x31, 0x61, 0x37, 0x61, 0x30, 0x35, 0x65, 0x61, 0x31, 0x63, 0x64, 0x36, 0x63, 0x30, 0x39, 0x38, 0x65, 0x64, 0x62, 0x61, 0x34, 0x64, 0x31, 0x62, 0x30, 0x34, 0x39, 0x66, 0x64, 0x35, 0x36, 0x32, 0x36, 0x65, 0x64, 0x64, 0x62, 0x33, 0x35, 0x66, 0x30, 0x64, 0x38, 0x32, 0x31, 0x34, 0x34, 0x32, 0x34, 0x64, 0x39, 0x65, 0x64, 0x36, 0x63, 0x30, 0x66, 0x37, 0x32, 0x30, 0x32, 0x65, 0x63, 0x33, 0x32, 0x35, 0x31, 0x39, 0x61, 0x34, 0x39, 0x63, 0x39, 0x63, 0x62, 0x34, 0x33, 0x35, 0x66, 0x37, 0x61, 0x38, 0x30, 0x39, 0x38, 0x36, 0x62, 0x36, 0x35, 0x34, 0x36, 0x39, 0x66, 0x38, 0x62, 0x35, 0x62, 0x38, 0x63, 0x32, 0x63, 0x62, 0x32, 0x31, 0x64, 0x30, 0x30, 0x62, 0x61, 0x34, 0x39, 0x39, 0x64, 0x65, 0x36, 0x31, 0x36, 0x30, 0x62, 0x33, 0x64, 0x31, 0x66, 0x66, 0x35, 0x63, 0x34, 0x62, 0x39, 0x34, 0x64, 0x64, 0x39, 0x31, 0x37, 0x64, 0x61, 0x38, 0x38, 0x66, 0x65, 0x66, 0x32, 0x61, 0x31, 0x31, 0x34, 0x39, 0x32, 0x64, 0x61, 0x38, 0x63, 0x39, 0x65, 0x63, 0x31, 0x30, 0x32, 0x30, 0x64, 0x65, 0x62, 0x62, 0x34, 0x62, 0x37, 0x34, 0x66, 0x30, 0x66, 0x66, 0x39, 0x32, 0x30, 0x66, 0x36, 0x32, 0x66, 0x39, 0x39, 0x37, 0x30, 0x35, 0x66, 0x37, 0x32, 0x36, 0x63, 0x36, 0x62, 0x37, 0x34, 0x62, 0x39, 0x37, 0x62, 0x36, 0x31, 0x37, 0x64, 0x65, 0x36, 0x39, 0x64, 0x34, 0x33, 0x33, 0x30, 0x65, 0x37, 0x32, 0x66, 0x33, 0x38, 0x35, 0x39, 0x66, 0x30, 0x32, 0x35, 0x30, 0x62, 0x38, 0x31, 0x63, 0x36, 0x64, 0x66, 0x62, 0x34, 0x35, 0x65, 0x65, 0x63, 0x37, 0x33, 0x37, 0x37, 0x36, 0x39, 0x63, 0x63, 0x32, 0x61, 0x66, 0x38, 0x38, 0x39, 0x35, 0x36, 0x64, 0x31, 0x32, 0x30, 0x35, 0x35, 0x32, 0x33, 0x61, 0x39, 0x35, 0x34, 0x63, 0x63, 0x66, 0x66, 0x31, 0x30, 0x65, 0x35, 0x63, 0x36, 0x34, 0x35, 0x35, 0x63, 0x33, 0x61, 0x63, 0x35, 0x33, 0x64, 0x61, 0x31, 0x39, 0x65, 0x32, 0x65, 0x65, 0x35, 0x65, 0x61, 0x30, 0x35, 0x34, 0x31, 0x38, 0x62, 0x34, 0x61, 0x61, 0x61, 0x39, 0x64, 0x38, 0x37, 0x30, 0x31, 0x34, 0x62, 0x39, 0x65, 0x37, 0x32, 0x33, 0x30, 0x37, 0x34, 0x63, 0x33, 0x30, 0x65, 0x35, 0x64, 0x63, 0x33, 0x32, 0x36, 0x39, 0x37, 0x37, 0x66, 0x33, 0x33, 0x35, 0x31, 0x63, 0x38, 0x38, 0x64, 0x64, 0x33, 0x64, 0x35, 0x63, 0x39, 0x33, 0x30, 0x62, 0x64, 0x62, 0x39, 0x63, 0x63, 0x35, 0x39, 0x32, 0x61, 0x30, 0x38, 0x62, 0x63, 0x33, 0x32, 0x36, 0x37, 0x64, 0x32, 0x35, 0x35, 0x64, 0x62, 0x61, 0x31, 0x38, 0x31, 0x37, 0x32, 0x38, 0x30, 0x39, 0x63, 0x39, 0x36, 0x62, 0x38, 0x33, 0x62, 0x38, 0x38, 0x66, 0x65, 0x65, 0x62, 0x38, 0x36, 0x36, 0x31, 0x39, 0x61, 0x62, 0x64, 0x31, 0x35, 0x66, 0x62, 0x65, 0x34, 0x66, 0x33, 0x33, 0x64, 0x38, 0x62, 0x63, 0x63, 0x36, 0x38, 0x62, 0x30, 0x61, 0x65, 0x34, 0x31, 0x39, 0x37, 0x37, 0x35, 0x31, 0x33, 0x31, 0x35, 0x31, 0x64, 0x36, 0x32, 0x33, 0x37, 0x62, 0x31, 0x37, 0x32, 0x30, 0x32, 0x33, 0x30, 0x35, 0x30, 0x37, 0x61, 0x61, 0x35, 0x39, 0x65, 0x34, 0x35, 0x33, 0x35, 0x63, 0x61, 0x31, 0x63, 0x34, 0x33, 0x33, 0x64, 0x63, 0x61, 0x33, 0x37, 0x64, 0x37, 0x61, 0x66, 0x66, 0x34, 0x33, 0x30, 0x65, 0x35, 0x34, 0x35, 0x36, 0x35, 0x39, 0x61, 0x35, 0x65, 0x64, 0x34, 0x35, 0x38, 0x66, 0x33, 0x33, 0x65, 0x66, 0x63, 0x38, 0x66, 0x38, 0x65, 0x34, 0x63, 0x33, 0x34, 0x32, 0x66, 0x66, 0x38, 0x65, 0x30, 0x65, 0x38, 0x64, 0x64, 0x38, 0x63, 0x66, 0x31, 0x39, 0x35, 0x30, 0x33, 0x64, 0x37, 0x31, 0x32, 0x37, 0x63, 0x61, 0x31, 0x63, 0x30, 0x31, 0x31, 0x32, 0x33, 0x31, 0x66, 0x65, 0x39, 0x39, 0x34, 0x35, 0x63, 0x38, 0x36, 0x63, 0x65, 0x37, 0x30, 0x32, 0x34, 0x36, 0x33, 0x66, 0x31, 0x35, 0x36, 0x34, 0x31, 0x66, 0x30, 0x36, 0x36, 0x65, 0x32, 0x36, 0x64, 0x31, 0x30, 0x65, 0x37, 0x34, 0x31, 0x37, 0x33, 0x66, 0x39, 0x64, 0x33, 0x37, 0x34, 0x65, 0x39, 0x66, 0x32, 0x30, 0x64, 0x32, 0x36, 0x38, 0x32, 0x31, 0x31, 0x34, 0x38, 0x37, 0x31, 0x31, 0x33, 0x35, 0x36, 0x38, 0x31, 0x37, 0x30, 0x37, 0x37, 0x32, 0x32, 0x30, 0x35, 0x64, 0x32, 0x65, 0x65, 0x39, 0x65, 0x61, 0x61, 0x65, 0x38, 0x38, 0x36, 0x37, 0x31, 0x61, 0x35, 0x32, 0x39, 0x37, 0x32, 0x34, 0x31, 0x31, 0x64, 0x35, 0x39, 0x31, 0x30, 0x63, 0x37, 0x65, 0x32, 0x62, 0x61, 0x34, 0x66, 0x35, 0x36, 0x38, 0x39, 0x64, 0x39, 0x64, 0x63, 0x37, 0x36, 0x61, 0x34, 0x33, 0x63, 0x33, 0x33, 0x62, 0x64, 0x33, 0x65, 0x35, 0x34, 0x32, 0x64, 0x38, 0x63, 0x37, 0x32, 0x64, 0x62, 0x30, 0x38, 0x62, 0x33, 0x62, 0x31, 0x36, 0x65, 0x32, 0x63, 0x62, 0x61, 0x30, 0x30, 0x39, 0x65, 0x37, 0x32, 0x31, 0x32, 0x63, 0x38, 0x30, 0x30, 0x62, 0x30, 0x32, 0x39, 0x32, 0x66, 0x35, 0x32, 0x36, 0x62, 0x36, 0x31, 0x65, 0x64, 0x33, 0x35, 0x30, 0x62, 0x63, 0x64, 0x35, 0x33, 0x31, 0x63, 0x35, 0x61, 0x36, 0x31, 0x63, 0x64, 0x64, 0x34, 0x36, 0x32, 0x34, 0x30, 0x35, 0x61, 0x35, 0x34, 0x33, 0x38, 0x61, 0x32, 0x31, 0x34, 0x39, 0x38, 0x36, 0x32, 0x39, 0x38, 0x35, 0x38, 0x32, 0x34, 0x37, 0x32, 0x37, 0x33, 0x31, 0x61, 0x64, 0x39, 0x38, 0x32, 0x66, 0x39, 0x63, 0x38, 0x65, 0x61, 0x31, 0x65, 0x30, 0x38, 0x39, 0x61, 0x62, 0x33, 0x33, 0x64, 0x37, 0x61, 0x31, 0x30, 0x35, 0x65, 0x38, 0x32, 0x34, 0x31, 0x33, 0x39, 0x32, 0x36, 0x31, 0x66, 0x63, 0x34, 0x30, 0x34, 0x36, 0x38, 0x38, 0x37, 0x30, 0x61, 0x37, 0x61, 0x36, 0x61, 0x35, 0x62, 0x39, 0x31, 0x30, 0x66, 0x32, 0x63, 0x32, 0x39, 0x66, 0x65, 0x61, 0x35, 0x31, 0x33, 0x64, 0x37, 0x33, 0x39, 0x36, 0x36, 0x65, 0x33, 0x62, 0x38, 0x65, 0x61, 0x33, 0x30, 0x36, 0x32, 0x61, 0x66, 0x37, 0x33, 0x66, 0x36, 0x31, 0x31, 0x39, 0x39, 0x32, 0x36, 0x36, 0x66, 0x36, 0x36, 0x38, 0x33, 0x65, 0x30, 0x64, 0x37, 0x63, 0x39, 0x39, 0x39, 0x38, 0x31, 0x61, 0x31, 0x35, 0x30, 0x62, 0x32, 0x30, 0x35, 0x64, 0x32, 0x30, 0x66, 0x37, 0x32, 0x32, 0x33, 0x63, 0x31, 0x39, 0x34, 0x62, 0x66, 0x65, 0x39, 0x30, 0x37, 0x31, 0x34, 0x63, 0x66, 0x35, 0x32, 0x39, 0x62, 0x64, 0x32, 0x38, 0x66, 0x38, 0x30, 0x38, 0x36, 0x64, 0x33, 0x38, 0x37, 0x62, 0x66, 0x61, 0x63, 0x32, 0x62, 0x65, 0x61, 0x30, 0x33, 0x63, 0x66, 0x36, 0x32, 0x35, 0x65, 0x66, 0x66, 0x35, 0x31, 0x32, 0x39, 0x31, 0x38, 0x33, 0x34, 0x34, 0x33, 0x37, 0x35, 0x32, 0x62, 0x34, 0x62, 0x38, 0x32, 0x33, 0x66, 0x30, 0x33, 0x66, 0x64, 0x31, 0x31, 0x38, 0x38, 0x66, 0x63, 0x35, 0x65, 0x39, 0x32, 0x62, 0x62, 0x32, 0x62, 0x66, 0x32, 0x66, 0x61, 0x31, 0x35, 0x33, 0x61, 0x35, 0x61, 0x65, 0x39, 0x35, 0x63, 0x64, 0x64, 0x63, 0x64, 0x34, 0x32, 0x32, 0x64, 0x36, 0x30, 0x30, 0x38, 0x64, 0x35, 0x32, 0x34, 0x33, 0x37, 0x36, 0x32, 0x30, 0x30, 0x37, 0x62, 0x30, 0x37, 0x37, 0x38, 0x39, 0x37, 0x61, 0x32, 0x37, 0x65, 0x32, 0x64, 0x30, 0x38, 0x33, 0x34, 0x63, 0x30, 0x61, 0x34, 0x36, 0x65, 0x64, 0x30, 0x62, 0x35, 0x64, 0x30, 0x39, 0x30, 0x62, 0x35, 0x31, 0x37, 0x34, 0x37, 0x36, 0x39, 0x36, 0x65, 0x33, 0x30, 0x39, 0x31, 0x31, 0x66, 0x64, 0x38, 0x38, 0x34, 0x35, 0x33, 0x65, 0x62, 0x30, 0x30, 0x32, 0x65, 0x31, 0x63, 0x30, 0x63, 0x38, 0x39, 0x32, 0x62, 0x62, 0x30, 0x61, 0x30, 0x65, 0x31, 0x39, 0x38, 0x36, 0x34, 0x62, 0x37, 0x65, 0x36, 0x30, 0x34, 0x65, 0x61, 0x30, 0x33, 0x35, 0x37, 0x38, 0x62, 0x35, 0x34, 0x32, 0x30, 0x62, 0x39, 0x33, 0x37, 0x63, 0x66, 0x64, 0x65, 0x31, 0x62, 0x34, 0x31, 0x66, 0x62, 0x66, 0x63, 0x65, 0x34, 0x65, 0x64, 0x34, 0x30, 0x66, 0x35, 0x31, 0x64, 0x34, 0x38, 0x31, 0x61, 0x34, 0x36, 0x38, 0x65, 0x37, 0x32, 0x33, 0x38, 0x30, 0x37, 0x37, 0x36, 0x33, 0x37, 0x65, 0x30, 0x31, 0x30, 0x64, 0x34, 0x63, 0x34, 0x61, 0x62, 0x31, 0x32, 0x32, 0x61, 0x35, 0x62, 0x32, 0x64, 0x35, 0x37, 0x33, 0x36, 0x63, 0x39, 0x64, 0x62, 0x62, 0x66, 0x32, 0x38, 0x37, 0x64, 0x64, 0x65, 0x32, 0x37, 0x34, 0x32, 0x31, 0x36, 0x64, 0x33, 0x31, 0x31, 0x66, 0x32, 0x34, 0x35, 0x38, 0x36, 0x30, 0x39, 0x33, 0x35, 0x37, 0x32, 0x66, 0x61, 0x62, 0x66, 0x61, 0x34, 0x66, 0x30, 0x31, 0x39, 0x61, 0x65, 0x34, 0x63, 0x32, 0x64, 0x37, 0x64, 0x62, 0x36, 0x30, 0x37, 0x34, 0x34, 0x64, 0x34, 0x39, 0x64, 0x65, 0x61, 0x66, 0x35, 0x66, 0x33, 0x32, 0x30, 0x64, 0x31, 0x61, 0x62, 0x61, 0x64, 0x64, 0x66, 0x30, 0x65, 0x31, 0x31, 0x62, 0x32, 0x64, 0x31, 0x37, 0x32, 0x37, 0x33, 0x38, 0x35, 0x31, 0x39, 0x38, 0x65, 0x37, 0x30, 0x66, 0x63, 0x65, 0x36, 0x65, 0x36, 0x61, 0x39, 0x63, 0x37, 0x66, 0x66, 0x32, 0x39, 0x63, 0x65, 0x65, 0x30, 0x37, 0x65, 0x33, 0x39, 0x63, 0x64, 0x31, 0x65, 0x66, 0x64, 0x32, 0x30, 0x65, 0x66, 0x65, 0x66, 0x38, 0x36, 0x36, 0x65, 0x38, 0x30, 0x36, 0x34, 0x65, 0x37, 0x34, 0x35, 0x39, 0x38, 0x34, 0x31, 0x33, 0x33, 0x65, 0x33, 0x39, 0x65, 0x32, 0x36, 0x61, 0x37, 0x31, 0x63, 0x30, 0x62, 0x38, 0x65, 0x62, 0x33, 0x65, 0x61, 0x32, 0x31, 0x61, 0x38, 0x39, 0x63, 0x32, 0x34, 0x34, 0x30, 0x63, 0x63, 0x66, 0x62, 0x34, 0x34, 0x64, 0x65, 0x38, 0x64, 0x64, 0x37, 0x34, 0x38, 0x39, 0x36, 0x32, 0x62, 0x30, 0x65, 0x62, 0x64, 0x33, 0x63, 0x39, 0x34, 0x32, 0x65, 0x38, 0x32, 0x66, 0x36, 0x35, 0x65, 0x30, 0x35, 0x66, 0x30, 0x37, 0x36, 0x39, 0x30, 0x32, 0x65, 0x37, 0x35, 0x37, 0x32, 0x38, 0x30, 0x39, 0x65, 0x38, 0x38, 0x66, 0x62, 0x31, 0x61, 0x61, 0x62, 0x63, 0x35, 0x66, 0x64, 0x33, 0x39, 0x61, 0x66, 0x64, 0x34, 0x32, 0x37, 0x33, 0x37, 0x39, 0x62, 0x66, 0x31, 0x33, 0x32, 0x64, 0x61, 0x38, 0x62, 0x38, 0x38, 0x37, 0x63, 0x38, 0x62, 0x35, 0x33, 0x38, 0x37, 0x30, 0x63, 0x36, 0x64, 0x34, 0x32, 0x66, 0x33, 0x32, 0x36, 0x66, 0x33, 0x37, 0x65, 0x35, 0x34, 0x33, 0x65, 0x61, 0x38, 0x36, 0x61, 0x32, 0x31, 0x62, 0x39, 0x62, 0x38, 0x61, 0x36, 0x65, 0x61, 0x65, 0x35, 0x62, 0x61, 0x31, 0x64, 0x30, 0x65, 0x64, 0x37, 0x66, 0x34, 0x31, 0x36, 0x66, 0x37, 0x30, 0x65, 0x61, 0x66, 0x33, 0x32, 0x38, 0x62, 0x30, 0x31, 0x36, 0x36, 0x62, 0x30, 0x33, 0x63, 0x62, 0x61, 0x64, 0x30, 0x66, 0x63, 0x30, 0x31, 0x61, 0x37, 0x35, 0x31, 0x62, 0x64, 0x30, 0x61, 0x37, 0x32, 0x39, 0x66, 0x31, 0x65, 0x33, 0x39, 0x39, 0x34, 0x37, 0x39, 0x35, 0x62, 0x62, 0x64, 0x30, 0x65, 0x32, 0x35, 0x31, 0x36, 0x30, 0x36, 0x61, 0x35, 0x37, 0x61, 0x65, 0x65, 0x61, 0x37, 0x61, 0x39, 0x39, 0x64, 0x65, 0x35, 0x66, 0x30, 0x38, 0x62, 0x62, 0x63, 0x30, 0x39, 0x61, 0x34, 0x38, 0x36, 0x37, 0x36, 0x37, 0x65, 0x32, 0x38, 0x36, 0x35, 0x38, 0x30, 0x39, 0x31, 0x64, 0x34, 0x36, 0x38, 0x37, 0x61, 0x34, 0x35, 0x66, 0x35, 0x64, 0x33, 0x31, 0x63, 0x36, 0x32, 0x61, 0x33, 0x34, 0x30, 0x65, 0x39, 0x32, 0x66, 0x32, 0x38, 0x39, 0x66, 0x35, 0x39, 0x65, 0x66, 0x38, 0x61, 0x31, 0x36, 0x66, 0x38, 0x34, 0x62, 0x61, 0x35, 0x65, 0x39, 0x34, 0x66, 0x32, 0x62, 0x66, 0x31, 0x32, 0x39, 0x38, 0x31, 0x62, 0x63, 0x31, 0x63, 0x36, 0x63, 0x62, 0x38, 0x38, 0x33, 0x61, 0x66, 0x37, 0x32, 0x38, 0x33, 0x64, 0x39, 0x65, 0x32, 0x35, 0x65, 0x33, 0x31, 0x30, 0x38, 0x39, 0x62, 0x35, 0x31, 0x61, 0x66, 0x33, 0x39, 0x62, 0x38, 0x35, 0x66, 0x31, 0x65, 0x33, 0x63, 0x31, 0x30, 0x64, 0x38, 0x64, 0x65, 0x63, 0x65, 0x30, 0x34, 0x62, 0x37, 0x64, 0x66, 0x38, 0x30, 0x32, 0x31, 0x64, 0x30, 0x30, 0x39, 0x64, 0x64, 0x34, 0x37, 0x34, 0x38, 0x33, 0x39, 0x32, 0x38, 0x66, 0x30, 0x37, 0x32, 0x36, 0x30, 0x61, 0x63, 0x62, 0x63, 0x33, 0x35, 0x39, 0x64, 0x63, 0x38, 0x61, 0x62, 0x65, 0x35, 0x34, 0x36, 0x39, 0x39, 0x64, 0x38, 0x65, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x38, 0x65, 0x31, 0x36, 0x34, 0x61, 0x65, 0x39, 0x36, 0x38, 0x35, 0x65, 0x31, 0x34, 0x31, 0x61, 0x35, 0x36, 0x37, 0x65, 0x33, 0x63, 0x30, 0x38, 0x64, 0x61, 0x61, 0x30, 0x32, 0x62, 0x37, 0x37, 0x32, 0x31, 0x35, 0x64, 0x37, 0x63, 0x38, 0x65, 0x61, 0x66, 0x31, 0x32, 0x61, 0x37, 0x39, 0x31, 0x64, 0x35, 0x61, 0x66, 0x35, 0x61, 0x33, 0x63, 0x63, 0x37, 0x39, 0x64, 0x65, 0x38, 0x62, 0x33, 0x65, 0x34, 0x30, 0x65, 0x37, 0x33, 0x34, 0x38, 0x66, 0x31, 0x66, 0x33, 0x35, 0x62, 0x37, 0x63, 0x38, 0x34, 0x39, 0x38, 0x63, 0x61, 0x66, 0x64, 0x32, 0x64, 0x31, 0x33, 0x32, 0x30, 0x62, 0x37, 0x32, 0x30, 0x64, 0x38, 0x34, 0x65, 0x36, 0x66, 0x33, 0x38, 0x61, 0x62, 0x62, 0x38, 0x32, 0x34, 0x38, 0x63, 0x35, 0x37, 0x35, 0x35, 0x61, 0x39, 0x32, 0x32, 0x64, 0x34, 0x34, 0x32, 0x33, 0x65, 0x62, 0x36, 0x33, 0x39, 0x33, 0x30, 0x33, 0x36, 0x32, 0x34, 0x61, 0x36, 0x65, 0x62, 0x63, 0x39, 0x33, 0x64, 0x32, 0x61, 0x65, 0x37, 0x37, 0x31, 0x30, 0x63, 0x38, 0x65, 0x31, 0x61, 0x64, 0x35, 0x62, 0x66, 0x31, 0x65, 0x31, 0x66, 0x63, 0x35, 0x35, 0x63, 0x35, 0x34, 0x33, 0x61, 0x32, 0x61, 0x36, 0x30, 0x31, 0x36, 0x63, 0x32, 0x66, 0x34, 0x63, 0x39, 0x65, 0x34, 0x34, 0x61, 0x63, 0x31, 0x61, 0x31, 0x31, 0x37, 0x31, 0x30, 0x62, 0x61, 0x32, 0x61, 0x39, 0x62, 0x30, 0x63, 0x34, 0x31, 0x65, 0x64, 0x66, 0x35, 0x33, 0x61, 0x64, 0x62, 0x33, 0x33, 0x63, 0x30, 0x38, 0x61, 0x65, 0x37, 0x32, 0x39, 0x38, 0x39, 0x31, 0x61, 0x63, 0x34, 0x34, 0x38, 0x33, 0x61, 0x65, 0x36, 0x34, 0x38, 0x39, 0x34, 0x32, 0x62, 0x31, 0x34, 0x62, 0x38, 0x35, 0x31, 0x36, 0x64, 0x38, 0x30, 0x39, 0x36, 0x38, 0x34, 0x31, 0x31, 0x30, 0x36, 0x38, 0x61, 0x33, 0x66, 0x62, 0x36, 0x39, 0x38, 0x30, 0x38, 0x62, 0x65, 0x37, 0x64, 0x32, 0x38, 0x38, 0x39, 0x64, 0x61, 0x32, 0x61, 0x39, 0x36, 0x33, 0x33, 0x62, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x36, 0x66, 0x35, 0x66, 0x38, 0x66, 0x33, 0x35, 0x64, 0x63, 0x38, 0x62, 0x34, 0x34, 0x61, 0x37, 0x33, 0x39, 0x63, 0x30, 0x36, 0x35, 0x62, 0x35, 0x64, 0x33, 0x32, 0x64, 0x37, 0x65, 0x64, 0x37, 0x38, 0x66, 0x33, 0x63, 0x37, 0x35, 0x62, 0x36, 0x62, 0x35, 0x39, 0x31, 0x34, 0x38, 0x38, 0x38, 0x61, 0x36, 0x65, 0x36, 0x62, 0x38, 0x39, 0x39, 0x37, 0x32, 0x62, 0x61, 0x63, 0x61, 0x34, 0x63, 0x34, 0x62, 0x30, 0x34, 0x66, 0x34, 0x38, 0x66, 0x39, 0x64, 0x63, 0x34, 0x32, 0x66, 0x35, 0x33, 0x39, 0x64, 0x36, 0x39, 0x34, 0x62, 0x63, 0x37, 0x32, 0x66, 0x65, 0x36, 0x61, 0x64, 0x66, 0x34, 0x62, 0x38, 0x35, 0x35, 0x62, 0x34, 0x63, 0x63, 0x39, 0x30, 0x65, 0x39, 0x32, 0x32, 0x64, 0x33, 0x39, 0x36, 0x37, 0x65, 0x31, 0x37, 0x39, 0x39, 0x37, 0x32, 0x33, 0x30, 0x63, 0x65, 0x34, 0x32, 0x61, 0x63, 0x37, 0x32, 0x39, 0x38, 0x39, 0x63, 0x32, 0x65, 0x35, 0x37, 0x35, 0x63, 0x64, 0x35, 0x62, 0x36, 0x39, 0x63, 0x31, 0x62, 0x63, 0x39, 0x35, 0x34, 0x31, 0x36, 0x31, 0x37, 0x39, 0x36, 0x34, 0x61, 0x39, 0x31, 0x39, 0x65, 0x38, 0x30, 0x61, 0x32, 0x61, 0x63, 0x33, 0x66, 0x33, 0x35, 0x33, 0x66, 0x31, 0x35, 0x34, 0x31, 0x32, 0x35, 0x37, 0x32, 0x32, 0x35, 0x38, 0x36, 0x30, 0x32, 0x33, 0x31, 0x61, 0x36, 0x35, 0x36, 0x64, 0x37, 0x31, 0x34, 0x30, 0x38, 0x31, 0x38, 0x34, 0x66, 0x65, 0x61, 0x38, 0x31, 0x65, 0x30, 0x31, 0x37, 0x62, 0x34, 0x63, 0x33, 0x38, 0x30, 0x62, 0x64, 0x39, 0x31, 0x39, 0x37, 0x63, 0x34, 0x33, 0x66, 0x66, 0x32, 0x30, 0x31, 0x31, 0x66, 0x39, 0x36, 0x36, 0x64, 0x38, 0x33, 0x63, 0x35, 0x66, 0x30, 0x37, 0x32, 0x62, 0x33, 0x30, 0x39, 0x31, 0x39, 0x38, 0x38, 0x61, 0x38, 0x65, 0x30, 0x38, 0x37, 0x61, 0x36, 0x30, 0x34, 0x63, 0x30, 0x38, 0x33, 0x37, 0x61, 0x33, 0x32, 0x61, 0x30, 0x33, 0x62, 0x63, 0x36, 0x64, 0x30, 0x30, 0x35, 0x30, 0x65, 0x35, 0x32, 0x31, 0x63, 0x63, 0x61, 0x31, 0x62, 0x33, 0x63, 0x61, 0x66, 0x63, 0x62, 0x39, 0x30, 0x37, 0x33, 0x31, 0x64, 0x61, 0x62, 0x34, 0x31, 0x37, 0x32, 0x32, 0x38, 0x63, 0x35, 0x64, 0x66, 0x39, 0x37, 0x36, 0x30, 0x37, 0x37, 0x37, 0x65, 0x64, 0x62, 0x66, 0x62, 0x32, 0x30, 0x65, 0x31, 0x33, 0x34, 0x33, 0x30, 0x31, 0x65, 0x36, 0x65, 0x39, 0x39, 0x36, 0x35, 0x66, 0x62, 0x32, 0x38, 0x39, 0x63, 0x32, 0x61, 0x38, 0x35, 0x61, 0x32, 0x35, 0x35, 0x35, 0x32, 0x62, 0x32, 0x65, 0x63, 0x63, 0x30, 0x65, 0x30, 0x61, 0x31, 0x37, 0x30, 0x37, 0x32, 0x37, 0x31, 0x65, 0x36, 0x31, 0x39, 0x32, 0x30, 0x36, 0x35, 0x30, 0x64, 0x31, 0x61, 0x30, 0x64, 0x62, 0x66, 0x37, 0x38, 0x34, 0x31, 0x33, 0x36, 0x33, 0x65, 0x36, 0x37, 0x32, 0x39, 0x32, 0x63, 0x66, 0x32, 0x64, 0x66, 0x65, 0x61, 0x30, 0x36, 0x65, 0x65, 0x36, 0x66, 0x65, 0x66, 0x63, 0x33, 0x38, 0x61, 0x61, 0x35, 0x33, 0x61, 0x66, 0x63, 0x39, 0x36, 0x64, 0x35, 0x65, 0x61, 0x37, 0x32, 0x66, 0x64, 0x33, 0x30, 0x35, 0x31, 0x34, 0x35, 0x39, 0x31, 0x65, 0x66, 0x62, 0x34, 0x35, 0x39, 0x39, 0x31, 0x30, 0x30, 0x30, 0x65, 0x30, 0x66, 0x39, 0x34, 0x36, 0x35, 0x61, 0x33, 0x30, 0x66, 0x62, 0x39, 0x30, 0x65, 0x63, 0x36, 0x38, 0x62, 0x39, 0x38, 0x30, 0x32, 0x36, 0x62, 0x30, 0x32, 0x35, 0x32, 0x61, 0x65, 0x65, 0x31, 0x61, 0x64, 0x63, 0x33, 0x63, 0x63, 0x64, 0x37, 0x37, 0x32, 0x37, 0x33, 0x34, 0x61, 0x61, 0x33, 0x66, 0x35, 0x36, 0x36, 0x62, 0x62, 0x33, 0x63, 0x61, 0x32, 0x33, 0x35, 0x36, 0x33, 0x34, 0x64, 0x63, 0x32, 0x35, 0x63, 0x65, 0x37, 0x38, 0x65, 0x32, 0x64, 0x31, 0x31, 0x39, 0x66, 0x66, 0x64, 0x36, 0x64, 0x34, 0x34, 0x34, 0x33, 0x34, 0x36, 0x34, 0x31, 0x65, 0x36, 0x62, 0x61, 0x63, 0x39, 0x31, 0x37, 0x30, 0x65, 0x39, 0x37, 0x33, 0x39, 0x37, 0x32, 0x30, 0x37, 0x63, 0x36, 0x37, 0x63, 0x35, 0x37, 0x37, 0x61, 0x36, 0x61, 0x35, 0x36, 0x64, 0x66, 0x30, 0x37, 0x33, 0x37, 0x62, 0x36, 0x64, 0x39, 0x61, 0x35, 0x32, 0x34, 0x65, 0x30, 0x32, 0x30, 0x63, 0x31, 0x35, 0x61, 0x36, 0x39, 0x34, 0x33, 0x64, 0x61, 0x31, 0x39, 0x32, 0x64, 0x66, 0x65, 0x33, 0x32, 0x39, 0x33, 0x32, 0x61, 0x62, 0x32, 0x36, 0x66, 0x33, 0x66, 0x61, 0x62, 0x34, 0x64, 0x38, 0x64, 0x34, 0x37, 0x63, 0x64, 0x63, 0x30, 0x63, 0x31, 0x65, 0x31, 0x66, 0x66, 0x63, 0x62, 0x32, 0x32, 0x62, 0x33, 0x34, 0x38, 0x61, 0x63, 0x35, 0x66, 0x33, 0x31, 0x35, 0x36, 0x64, 0x34, 0x66, 0x36, 0x64, 0x63, 0x36, 0x65, 0x66, 0x38, 0x63, 0x30, 0x66, 0x33, 0x34, 0x39, 0x65, 0x38, 0x33, 0x34, 0x65, 0x64, 0x39, 0x61, 0x30, 0x61, 0x39, 0x61, 0x63, 0x34, 0x34, 0x66, 0x32, 0x63, 0x31, 0x63, 0x35, 0x31, 0x61, 0x63, 0x39, 0x38, 0x66, 0x64, 0x64, 0x37, 0x31, 0x38, 0x65, 0x63, 0x37, 0x39, 0x65, 0x63, 0x36, 0x36, 0x31, 0x37, 0x32, 0x66, 0x64, 0x66, 0x32, 0x65, 0x36, 0x37, 0x65, 0x62, 0x64, 0x36, 0x63, 0x35, 0x30, 0x35, 0x61, 0x63, 0x35, 0x35, 0x64, 0x33, 0x37, 0x38, 0x65, 0x34, 0x32, 0x31, 0x39, 0x39, 0x32, 0x35, 0x37, 0x32, 0x35, 0x63, 0x38, 0x38, 0x37, 0x32, 0x64, 0x66, 0x61, 0x63, 0x66, 0x31, 0x34, 0x39, 0x63, 0x33, 0x34, 0x33, 0x35, 0x61, 0x37, 0x31, 0x39, 0x39, 0x62, 0x36, 0x61, 0x36, 0x32, 0x62, 0x64, 0x63, 0x64, 0x33, 0x31, 0x36, 0x64, 0x61, 0x38, 0x63, 0x34, 0x36, 0x37, 0x65, 0x34, 0x65, 0x30, 0x65, 0x33, 0x31, 0x36, 0x37, 0x35, 0x37, 0x37, 0x33, 0x38, 0x38, 0x64, 0x63, 0x38, 0x31, 0x39, 0x39, 0x63, 0x36, 0x31, 0x35, 0x37, 0x32, 0x61, 0x65, 0x34, 0x66, 0x30, 0x31, 0x64, 0x38, 0x63, 0x32, 0x66, 0x38, 0x61, 0x39, 0x38, 0x37, 0x34, 0x30, 0x64, 0x34, 0x34, 0x64, 0x33, 0x61, 0x35, 0x38, 0x34, 0x63, 0x38, 0x63, 0x61, 0x34, 0x35, 0x39, 0x31, 0x65, 0x66, 0x64, 0x39, 0x30, 0x35, 0x32, 0x37, 0x35, 0x65, 0x30, 0x65, 0x65, 0x32, 0x62, 0x39, 0x62, 0x39, 0x38, 0x65, 0x36, 0x31, 0x63, 0x66, 0x34, 0x66, 0x39, 0x36, 0x64, 0x33, 0x64, 0x61, 0x33, 0x65, 0x37, 0x63, 0x38, 0x61, 0x36, 0x33, 0x36, 0x38, 0x37, 0x62, 0x62, 0x34, 0x63, 0x31, 0x65, 0x64, 0x66, 0x36, 0x33, 0x36, 0x64, 0x66, 0x32, 0x33, 0x65, 0x39, 0x31, 0x66, 0x63, 0x37, 0x31, 0x63, 0x33, 0x63, 0x65, 0x37, 0x61, 0x32, 0x66, 0x65, 0x33, 0x38, 0x34, 0x31, 0x36, 0x62, 0x62, 0x33, 0x31, 0x61, 0x39, 0x37, 0x34, 0x34, 0x65, 0x33, 0x39, 0x35, 0x33, 0x63, 0x63, 0x37, 0x66, 0x61, 0x63, 0x36, 0x63, 0x39, 0x31, 0x31, 0x39, 0x39, 0x37, 0x39, 0x38, 0x39, 0x30, 0x36, 0x62, 0x62, 0x35, 0x62, 0x35, 0x36, 0x64, 0x63, 0x63, 0x33, 0x36, 0x64, 0x37, 0x34, 0x34, 0x37, 0x32, 0x32, 0x35, 0x37, 0x61, 0x66, 0x63, 0x30, 0x65, 0x34, 0x31, 0x63, 0x63, 0x63, 0x65, 0x32, 0x64, 0x63, 0x63, 0x64, 0x35, 0x64, 0x61, 0x31, 0x36, 0x62, 0x61, 0x30, 0x34, 0x37, 0x34, 0x61, 0x34, 0x35, 0x33, 0x66, 0x65, 0x30, 0x37, 0x36, 0x61, 0x31, 0x36, 0x65, 0x35, 0x61, 0x66, 0x61, 0x36, 0x61, 0x65, 0x65, 0x39, 0x61, 0x35, 0x66, 0x34, 0x34, 0x37, 0x62, 0x66, 0x63, 0x34, 0x36, 0x36, 0x62, 0x65, 0x30, 0x31, 0x31, 0x32, 0x37, 0x61, 0x34, 0x61, 0x65, 0x30, 0x31, 0x66, 0x31, 0x30, 0x33, 0x39, 0x33, 0x34, 0x39, 0x61, 0x35, 0x64, 0x33, 0x33, 0x37, 0x32, 0x33, 0x30, 0x34, 0x35, 0x35, 0x33, 0x39, 0x61, 0x38, 0x37, 0x63, 0x37, 0x38, 0x39, 0x38, 0x64, 0x33, 0x66, 0x35, 0x63, 0x63, 0x31, 0x35, 0x62, 0x61, 0x38, 0x66, 0x33, 0x38, 0x63, 0x37, 0x35, 0x61, 0x39, 0x34, 0x39, 0x30, 0x31, 0x30, 0x61, 0x32, 0x61, 0x37, 0x65, 0x65, 0x30, 0x65, 0x33, 0x30, 0x65, 0x61, 0x63, 0x33, 0x38, 0x38, 0x32, 0x66, 0x30, 0x36, 0x37, 0x33, 0x63, 0x37, 0x32, 0x61, 0x62, 0x66, 0x66, 0x32, 0x34, 0x37, 0x39, 0x66, 0x36, 0x30, 0x30, 0x38, 0x36, 0x39, 0x65, 0x39, 0x38, 0x64, 0x36, 0x37, 0x63, 0x64, 0x66, 0x34, 0x37, 0x64, 0x37, 0x36, 0x65, 0x30, 0x37, 0x33, 0x35, 0x62, 0x38, 0x64, 0x34, 0x31, 0x66, 0x63, 0x30, 0x33, 0x38, 0x39, 0x39, 0x39, 0x62, 0x39, 0x33, 0x64, 0x35, 0x37, 0x34, 0x31, 0x61, 0x34, 0x36, 0x65, 0x33, 0x36, 0x62, 0x37, 0x32, 0x34, 0x65, 0x61, 0x64, 0x63, 0x62, 0x35, 0x36, 0x39, 0x62, 0x63, 0x64, 0x35, 0x63, 0x34, 0x62, 0x64, 0x64, 0x35, 0x30, 0x63, 0x61, 0x38, 0x64, 0x62, 0x36, 0x37, 0x39, 0x30, 0x35, 0x38, 0x33, 0x33, 0x31, 0x37, 0x66, 0x36, 0x62, 0x33, 0x36, 0x66, 0x33, 0x65, 0x36, 0x37, 0x61, 0x35, 0x38, 0x33, 0x38, 0x37, 0x31, 0x38, 0x33, 0x32, 0x35, 0x64, 0x63, 0x38, 0x35, 0x38, 0x34, 0x37, 0x32, 0x33, 0x66, 0x37, 0x64, 0x32, 0x62, 0x35, 0x65, 0x66, 0x30, 0x61, 0x31, 0x32, 0x61, 0x36, 0x36, 0x65, 0x63, 0x31, 0x31, 0x64, 0x33, 0x61, 0x32, 0x62, 0x63, 0x39, 0x63, 0x39, 0x33, 0x38, 0x33, 0x66, 0x33, 0x34, 0x66, 0x63, 0x30, 0x61, 0x37, 0x65, 0x61, 0x33, 0x36, 0x30, 0x63, 0x35, 0x32, 0x30, 0x37, 0x65, 0x36, 0x32, 0x62, 0x34, 0x33, 0x39, 0x39, 0x37, 0x66, 0x34, 0x34, 0x36, 0x64, 0x66, 0x66, 0x31, 0x31, 0x39, 0x33, 0x34, 0x35, 0x35, 0x34, 0x62, 0x35, 0x32, 0x33, 0x64, 0x65, 0x35, 0x36, 0x32, 0x61, 0x61, 0x33, 0x66, 0x62, 0x32, 0x37, 0x35, 0x31, 0x65, 0x37, 0x30, 0x32, 0x34, 0x38, 0x63, 0x65, 0x31, 0x36, 0x63, 0x38, 0x35, 0x63, 0x33, 0x31, 0x61, 0x36, 0x31, 0x32, 0x39, 0x32, 0x63, 0x30, 0x38, 0x66, 0x34, 0x32, 0x34, 0x63, 0x34, 0x63, 0x35, 0x38, 0x37, 0x32, 0x62, 0x34, 0x31, 0x32, 0x33, 0x31, 0x61, 0x39, 0x34, 0x32, 0x64, 0x38, 0x38, 0x39, 0x38, 0x39, 0x64, 0x36, 0x36, 0x66, 0x65, 0x62, 0x33, 0x63, 0x31, 0x30, 0x37, 0x30, 0x63, 0x33, 0x62, 0x62, 0x30, 0x30, 0x30, 0x35, 0x62, 0x34, 0x65, 0x35, 0x30, 0x39, 0x35, 0x64, 0x36, 0x32, 0x36, 0x39, 0x34, 0x33, 0x38, 0x64, 0x32, 0x34, 0x61, 0x35, 0x37, 0x32, 0x33, 0x64, 0x66, 0x65, 0x37, 0x32, 0x65, 0x31, 0x65, 0x32, 0x66, 0x62, 0x66, 0x37, 0x64, 0x64, 0x30, 0x30, 0x61, 0x35, 0x38, 0x39, 0x62, 0x65, 0x30, 0x34, 0x34, 0x31, 0x34, 0x63, 0x62, 0x32, 0x62, 0x36, 0x30, 0x66, 0x36, 0x64, 0x34, 0x31, 0x61, 0x32, 0x32, 0x38, 0x61, 0x65, 0x61, 0x39, 0x35, 0x31, 0x31, 0x65, 0x63, 0x32, 0x36, 0x31, 0x65, 0x61, 0x35, 0x34, 0x34, 0x61, 0x34, 0x65, 0x35, 0x61, 0x61, 0x31, 0x34, 0x63, 0x36, 0x30, 0x39, 0x66, 0x32, 0x63, 0x61, 0x35, 0x35, 0x35, 0x31, 0x37, 0x36, 0x31, 0x63, 0x31, 0x65, 0x65, 0x34, 0x66, 0x65, 0x34, 0x62, 0x63, 0x65, 0x65, 0x61, 0x32, 0x31, 0x61, 0x37, 0x65, 0x32, 0x32, 0x36, 0x33, 0x34, 0x39, 0x64, 0x37, 0x34, 0x65, 0x66, 0x66, 0x38, 0x63, 0x34, 0x32, 0x30, 0x64, 0x31, 0x64, 0x65, 0x38, 0x61, 0x37, 0x39, 0x63, 0x34, 0x31, 0x38, 0x65, 0x35, 0x62, 0x33, 0x36, 0x39, 0x32, 0x66, 0x39, 0x34, 0x38, 0x30, 0x35, 0x38, 0x64, 0x32, 0x64, 0x30, 0x63, 0x61, 0x65, 0x63, 0x32, 0x32, 0x30, 0x63, 0x64, 0x35, 0x30, 0x30, 0x32, 0x34, 0x34, 0x65, 0x32, 0x35, 0x39, 0x64, 0x39, 0x39, 0x39, 0x33, 0x65, 0x33, 0x62, 0x30, 0x35, 0x33, 0x66, 0x61, 0x39, 0x64, 0x37, 0x32, 0x35, 0x38, 0x62, 0x66, 0x33, 0x39, 0x36, 0x39, 0x39, 0x32, 0x38, 0x37, 0x32, 0x66, 0x37, 0x31, 0x36, 0x31, 0x31, 0x33, 0x61, 0x62, 0x32, 0x61, 0x35, 0x64, 0x62, 0x66, 0x36, 0x63, 0x37, 0x36, 0x30, 0x38, 0x65, 0x37, 0x31, 0x36, 0x63, 0x31, 0x64, 0x32, 0x66, 0x33, 0x35, 0x64, 0x35, 0x64, 0x37, 0x64, 0x65, 0x32, 0x34, 0x62, 0x66, 0x66, 0x33, 0x65, 0x39, 0x34, 0x32, 0x30, 0x63, 0x30, 0x39, 0x35, 0x33, 0x37, 0x30, 0x66, 0x33, 0x38, 0x34, 0x63, 0x38, 0x37, 0x32, 0x31, 0x36, 0x37, 0x36, 0x61, 0x38, 0x66, 0x32, 0x35, 0x32, 0x64, 0x32, 0x30, 0x32, 0x39, 0x34, 0x65, 0x31, 0x61, 0x64, 0x34, 0x36, 0x38, 0x63, 0x36, 0x31, 0x33, 0x36, 0x62, 0x39, 0x63, 0x62, 0x38, 0x37, 0x32, 0x66, 0x65, 0x39, 0x38, 0x66, 0x38, 0x35, 0x38, 0x38, 0x65, 0x39, 0x64, 0x65, 0x34, 0x37, 0x36, 0x38, 0x34, 0x35, 0x39, 0x39, 0x37, 0x66, 0x61, 0x32, 0x32, 0x33, 0x36, 0x61, 0x36, 0x62, 0x65, 0x61, 0x66, 0x66, 0x62, 0x39, 0x38, 0x33, 0x62, 0x34, 0x64, 0x63, 0x61, 0x31, 0x62, 0x32, 0x61, 0x39, 0x32, 0x38, 0x66, 0x34, 0x34, 0x63, 0x33, 0x35, 0x34, 0x62, 0x63, 0x30, 0x31, 0x65, 0x36, 0x35, 0x63, 0x64, 0x31, 0x61, 0x33, 0x34, 0x62, 0x34, 0x66, 0x35, 0x38, 0x66, 0x34, 0x30, 0x30, 0x61, 0x34, 0x30, 0x37, 0x38, 0x36, 0x32, 0x33, 0x33, 0x38, 0x62, 0x35, 0x66, 0x64, 0x33, 0x66, 0x62, 0x31, 0x35, 0x38, 0x35, 0x66, 0x39, 0x36, 0x34, 0x38, 0x62, 0x66, 0x39, 0x66, 0x34, 0x30, 0x34, 0x30, 0x61, 0x33, 0x62, 0x36, 0x63, 0x37, 0x33, 0x32, 0x31, 0x32, 0x38, 0x39, 0x36, 0x61, 0x37, 0x34, 0x38, 0x62, 0x35, 0x38, 0x35, 0x38, 0x39, 0x64, 0x65, 0x31, 0x61, 0x35, 0x39, 0x34, 0x36, 0x31, 0x33, 0x66, 0x65, 0x36, 0x38, 0x35, 0x32, 0x62, 0x39, 0x32, 0x62, 0x63, 0x61, 0x31, 0x65, 0x65, 0x64, 0x62, 0x66, 0x64, 0x32, 0x39, 0x65, 0x34, 0x66, 0x64, 0x39, 0x66, 0x64, 0x66, 0x66, 0x65, 0x38, 0x39, 0x30, 0x66, 0x66, 0x64, 0x61, 0x37, 0x63, 0x61, 0x34, 0x37, 0x31, 0x62, 0x65, 0x35, 0x64, 0x30, 0x65, 0x30, 0x37, 0x34, 0x39, 0x33, 0x64, 0x66, 0x39, 0x65, 0x32, 0x34, 0x31, 0x65, 0x62, 0x36, 0x38, 0x37, 0x32, 0x33, 0x61, 0x39, 0x65, 0x37, 0x32, 0x37, 0x32, 0x38, 0x32, 0x37, 0x35, 0x37, 0x66, 0x64, 0x65, 0x36, 0x63, 0x39, 0x66, 0x61, 0x66, 0x66, 0x62, 0x61, 0x63, 0x33, 0x37, 0x35, 0x66, 0x65, 0x62, 0x61, 0x35, 0x31, 0x31, 0x64, 0x62, 0x31, 0x38, 0x34, 0x38, 0x62, 0x63, 0x38, 0x32, 0x34, 0x62, 0x33, 0x33, 0x33, 0x34, 0x32, 0x34, 0x31, 0x38, 0x39, 0x64, 0x37, 0x39, 0x62, 0x35, 0x64, 0x62, 0x30, 0x63, 0x62, 0x61, 0x35, 0x36, 0x66, 0x38, 0x64, 0x38, 0x35, 0x63, 0x37, 0x32, 0x61, 0x31, 0x35, 0x34, 0x65, 0x39, 0x30, 0x35, 0x37, 0x39, 0x64, 0x62, 0x37, 0x65, 0x36, 0x33, 0x31, 0x35, 0x31, 0x34, 0x33, 0x61, 0x34, 0x66, 0x66, 0x30, 0x39, 0x61, 0x61, 0x30, 0x34, 0x31, 0x38, 0x32, 0x32, 0x37, 0x65, 0x66, 0x30, 0x66, 0x33, 0x38, 0x33, 0x37, 0x35, 0x66, 0x62, 0x63, 0x66, 0x65, 0x32, 0x38, 0x64, 0x30, 0x33, 0x65, 0x38, 0x61, 0x64, 0x37, 0x30, 0x31, 0x39, 0x38, 0x62, 0x65, 0x64, 0x35, 0x63, 0x33, 0x64, 0x30, 0x32, 0x34, 0x61, 0x38, 0x63, 0x38, 0x66, 0x31, 0x32, 0x31, 0x64, 0x36, 0x36, 0x34, 0x33, 0x31, 0x61, 0x65, 0x32, 0x65, 0x35, 0x34, 0x34, 0x64, 0x35, 0x30, 0x62, 0x62, 0x64, 0x64, 0x33, 0x30, 0x31, 0x32, 0x35, 0x34, 0x31, 0x64, 0x62, 0x37, 0x30, 0x33, 0x39, 0x39, 0x31, 0x35, 0x32, 0x31, 0x33, 0x33, 0x65, 0x62, 0x66, 0x62, 0x30, 0x32, 0x38, 0x33, 0x37, 0x37, 0x31, 0x61, 0x64, 0x61, 0x33, 0x32, 0x63, 0x66, 0x62, 0x30, 0x30, 0x34, 0x30, 0x31, 0x33, 0x32, 0x34, 0x61, 0x65, 0x37, 0x35, 0x30, 0x35, 0x30, 0x39, 0x35, 0x64, 0x64, 0x33, 0x33, 0x39, 0x31, 0x35, 0x32, 0x33, 0x30, 0x65, 0x62, 0x34, 0x62, 0x64, 0x39, 0x65, 0x61, 0x39, 0x36, 0x64, 0x36, 0x39, 0x63, 0x37, 0x32, 0x38, 0x38, 0x30, 0x65, 0x32, 0x38, 0x64, 0x61, 0x62, 0x65, 0x35, 0x32, 0x30, 0x38, 0x63, 0x65, 0x36, 0x38, 0x35, 0x62, 0x38, 0x32, 0x61, 0x62, 0x36, 0x63, 0x65, 0x30, 0x65, 0x30, 0x31, 0x37, 0x30, 0x65, 0x32, 0x35, 0x65, 0x32, 0x64, 0x61, 0x39, 0x37, 0x66, 0x66, 0x32, 0x61, 0x34, 0x39, 0x66, 0x36, 0x61, 0x61, 0x33, 0x37, 0x66, 0x36, 0x65, 0x65, 0x30, 0x64, 0x39, 0x35, 0x33, 0x37, 0x62, 0x63, 0x32, 0x66, 0x38, 0x35, 0x38, 0x65, 0x61, 0x65, 0x61, 0x61, 0x31, 0x61, 0x63, 0x66, 0x34, 0x62, 0x66, 0x62, 0x36, 0x61, 0x38, 0x64, 0x64, 0x66, 0x30, 0x38, 0x39, 0x34, 0x33, 0x63, 0x66, 0x37, 0x36, 0x33, 0x36, 0x63, 0x65, 0x61, 0x39, 0x35, 0x64, 0x31, 0x33, 0x31, 0x65, 0x30, 0x39, 0x65, 0x37, 0x31, 0x35, 0x37, 0x39, 0x64, 0x30, 0x37, 0x63, 0x31, 0x38, 0x39, 0x37, 0x32, 0x34, 0x65, 0x65, 0x66, 0x36, 0x32, 0x66, 0x39, 0x63, 0x39, 0x34, 0x63, 0x62, 0x62, 0x66, 0x63, 0x34, 0x37, 0x36, 0x36, 0x34, 0x30, 0x33, 0x64, 0x33, 0x62, 0x35, 0x66, 0x64, 0x66, 0x62, 0x30, 0x37, 0x61, 0x63, 0x30, 0x39, 0x36, 0x39, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, 0x38, 0x30, 0x36, 0x63, 0x31, 0x63, 0x65, 0x64, 0x61, 0x33, 0x61, 0x34, 0x65, 0x39, 0x39, 0x65, 0x63, 0x37, 0x32, 0x65, 0x62, 0x34, 0x33, 0x64, 0x32, 0x65, 0x36, 0x39, 0x62, 0x61, 0x62, 0x64, 0x66, 0x33, 0x31, 0x31, 0x37, 0x36, 0x30, 0x62, 0x37, 0x37, 0x35, 0x34, 0x37, 0x33, 0x35, 0x39, 0x38, 0x62, 0x34, 0x35, 0x65, 0x37, 0x64, 0x64, 0x36, 0x32, 0x33, 0x64, 0x62, 0x65, 0x65, 0x31, 0x37, 0x64, 0x64, 0x63, 0x30, 0x62, 0x61, 0x39, 0x39, 0x61, 0x33, 0x32, 0x62, 0x65, 0x37, 0x32, 0x63, 0x37, 0x32, 0x35, 0x34, 0x30, 0x36, 0x30, 0x31, 0x37, 0x34, 0x30, 0x34, 0x34, 0x62, 0x39, 0x65, 0x39, 0x34, 0x33, 0x32, 0x38, 0x33, 0x31, 0x33, 0x33, 0x65, 0x33, 0x32, 0x36, 0x65, 0x64, 0x61, 0x34, 0x62, 0x30, 0x36, 0x36, 0x30, 0x30, 0x61, 0x36, 0x39, 0x32, 0x66, 0x38, 0x61, 0x34, 0x64, 0x62, 0x36, 0x37, 0x66, 0x62, 0x33, 0x66, 0x35, 0x36, 0x30, 0x65, 0x65, 0x31, 0x65, 0x66, 0x35, 0x37, 0x32, 0x65, 0x65, 0x39, 0x37, 0x65, 0x31, 0x35, 0x30, 0x32, 0x34, 0x36, 0x34, 0x30, 0x63, 0x36, 0x36, 0x33, 0x37, 0x30, 0x39, 0x37, 0x30, 0x65, 0x39, 0x39, 0x39, 0x62, 0x62, 0x65, 0x30, 0x39, 0x65, 0x32, 0x63, 0x33, 0x64, 0x35, 0x63, 0x31, 0x35, 0x34, 0x32, 0x34, 0x35, 0x62, 0x65, 0x34, 0x66, 0x61, 0x36, 0x30, 0x32, 0x33, 0x61, 0x33, 0x63, 0x62, 0x32, 0x35, 0x36, 0x31, 0x30, 0x37, 0x32, 0x62, 0x39, 0x36, 0x37, 0x39, 0x37, 0x65, 0x65, 0x31, 0x30, 0x36, 0x65, 0x64, 0x39, 0x39, 0x62, 0x64, 0x64, 0x34, 0x65, 0x61, 0x30, 0x66, 0x36, 0x66, 0x37, 0x64, 0x35, 0x35, 0x31, 0x30, 0x36, 0x66, 0x64, 0x36, 0x61, 0x64, 0x31, 0x35, 0x36, 0x30, 0x35, 0x63, 0x33, 0x35, 0x65, 0x31, 0x36, 0x35, 0x64, 0x31, 0x63, 0x65, 0x30, 0x38, 0x33, 0x38, 0x30, 0x35, 0x36, 0x65, 0x37, 0x34, 0x61, 0x36, 0x36, 0x61, 0x30, 0x32, 0x38, 0x30, 0x61, 0x62, 0x66, 0x31, 0x38, 0x36, 0x65, 0x65, 0x65, 0x62, 0x31, 0x31, 0x34, 0x38, 0x64, 0x38, 0x33, 0x66, 0x35, 0x63, 0x38, 0x61, 0x31, 0x37, 0x38, 0x62, 0x39, 0x35, 0x32, 0x33, 0x37, 0x35, 0x34, 0x35, 0x30, 0x35, 0x61, 0x33, 0x35, 0x30, 0x38, 0x32, 0x63, 0x62, 0x37, 0x30, 0x63, 0x39, 0x35, 0x65, 0x39, 0x32, 0x64, 0x34, 0x62, 0x30, 0x39, 0x30, 0x37, 0x65, 0x38, 0x39, 0x62, 0x65, 0x32, 0x33, 0x64, 0x65, 0x66, 0x31, 0x37, 0x64, 0x36, 0x30, 0x38, 0x62, 0x30, 0x65, 0x62, 0x65, 0x64, 0x66, 0x38, 0x39, 0x64, 0x66, 0x37, 0x62, 0x66, 0x31, 0x33, 0x34, 0x64, 0x62, 0x32, 0x61, 0x38, 0x38, 0x32, 0x63, 0x63, 0x33, 0x32, 0x37, 0x33, 0x35, 0x33, 0x66, 0x33, 0x33, 0x64, 0x66, 0x30, 0x33, 0x31, 0x30, 0x31, 0x30, 0x33, 0x37, 0x32, 0x31, 0x33, 0x39, 0x66, 0x39, 0x33, 0x33, 0x35, 0x39, 0x31, 0x34, 0x65, 0x61, 0x61, 0x35, 0x34, 0x38, 0x62, 0x36, 0x33, 0x63, 0x63, 0x39, 0x63, 0x65, 0x63, 0x64, 0x33, 0x64, 0x31, 0x65, 0x65, 0x61, 0x38, 0x38, 0x66, 0x39, 0x65, 0x62, 0x31, 0x64, 0x31, 0x64, 0x66, 0x62, 0x65, 0x32, 0x38, 0x30, 0x32, 0x35, 0x62, 0x34, 0x31, 0x61, 0x39, 0x32, 0x35, 0x35, 0x34, 0x37, 0x30, 0x31, 0x39, 0x39, 0x32, 0x66, 0x36, 0x61, 0x63, 0x61, 0x39, 0x65, 0x65, 0x36, 0x64, 0x33, 0x66, 0x62, 0x33, 0x39, 0x38, 0x65, 0x62, 0x33, 0x36, 0x64, 0x39, 0x35, 0x36, 0x33, 0x36, 0x66, 0x63, 0x37, 0x32, 0x62, 0x65, 0x30, 0x39, 0x35, 0x64, 0x37, 0x33, 0x31, 0x66, 0x66, 0x32, 0x66, 0x30, 0x64, 0x37, 0x61, 0x35, 0x33, 0x63, 0x35, 0x62, 0x62, 0x65, 0x31, 0x39, 0x30, 0x66, 0x64, 0x64, 0x37, 0x32, 0x36, 0x39, 0x32, 0x30, 0x33, 0x31, 0x61, 0x35, 0x31, 0x34, 0x37, 0x66, 0x36, 0x31, 0x62, 0x38, 0x65, 0x31, 0x62, 0x31, 0x37, 0x31, 0x37, 0x32, 0x30, 0x37, 0x35, 0x35, 0x39, 0x65, 0x66, 0x33, 0x39, 0x37, 0x61, 0x63, 0x34, 0x65, 0x32, 0x39, 0x30, 0x31, 0x66, 0x33, 0x30, 0x62, 0x62, 0x62, 0x38, 0x64, 0x37, 0x36, 0x66, 0x33, 0x34, 0x31, 0x66, 0x32, 0x36, 0x33, 0x66, 0x62, 0x37, 0x32, 0x62, 0x31, 0x38, 0x31, 0x34, 0x35, 0x32, 0x64, 0x62, 0x36, 0x61, 0x37, 0x66, 0x65, 0x65, 0x64, 0x61, 0x61, 0x35, 0x33, 0x64, 0x30, 0x64, 0x62, 0x33, 0x35, 0x39, 0x36, 0x66, 0x62, 0x63, 0x62, 0x38, 0x64, 0x63, 0x36, 0x30, 0x30, 0x64, 0x32, 0x35, 0x38, 0x31, 0x64, 0x36, 0x64, 0x33, 0x64, 0x33, 0x37, 0x38, 0x33, 0x32, 0x39, 0x36, 0x63, 0x31, 0x34, 0x61, 0x63, 0x66, 0x65, 0x37, 0x32, 0x66, 0x33, 0x34, 0x30, 0x61, 0x36, 0x64, 0x62, 0x35, 0x31, 0x64, 0x31, 0x38, 0x63, 0x34, 0x36, 0x38, 0x65, 0x62, 0x39, 0x37, 0x63, 0x65, 0x64, 0x31, 0x37, 0x37, 0x39, 0x35, 0x38, 0x62, 0x37, 0x31, 0x34, 0x33, 0x62, 0x38, 0x63, 0x61, 0x36, 0x35, 0x32, 0x39, 0x31, 0x37, 0x30, 0x37, 0x33, 0x65, 0x64, 0x35, 0x64, 0x33, 0x30, 0x61, 0x36, 0x34, 0x62, 0x61, 0x32, 0x66, 0x31, 0x33, 0x30, 0x64, 0x30, 0x63, 0x62, 0x30, 0x36, 0x61, 0x36, 0x32, 0x39, 0x39, 0x38, 0x64, 0x38, 0x62, 0x30, 0x31, 0x35, 0x38, 0x36, 0x32, 0x66, 0x36, 0x30, 0x36, 0x34, 0x61, 0x61, 0x63, 0x61, 0x30, 0x36, 0x32, 0x63, 0x63, 0x33, 0x62, 0x38, 0x34, 0x63, 0x62, 0x62, 0x31, 0x65, 0x31, 0x62, 0x34, 0x39, 0x39, 0x35, 0x30, 0x30, 0x64, 0x36, 0x31, 0x33, 0x38, 0x63, 0x34, 0x63, 0x63, 0x34, 0x32, 0x61, 0x37, 0x35, 0x35, 0x31, 0x35, 0x33, 0x34, 0x66, 0x37, 0x34, 0x63, 0x61, 0x62, 0x65, 0x33, 0x62, 0x36, 0x38, 0x66, 0x65, 0x61, 0x32, 0x63, 0x62, 0x64, 0x63, 0x36, 0x30, 0x33, 0x35, 0x63, 0x64, 0x36, 0x37, 0x31, 0x65, 0x34, 0x37, 0x35, 0x38, 0x30, 0x33, 0x61, 0x38, 0x38, 0x61, 0x34, 0x32, 0x63, 0x36, 0x39, 0x39, 0x31, 0x62, 0x61, 0x32, 0x37, 0x61, 0x63, 0x33, 0x30, 0x65, 0x37, 0x32, 0x63, 0x37, 0x34, 0x38, 0x32, 0x62, 0x30, 0x30, 0x33, 0x66, 0x65, 0x62, 0x65, 0x38, 0x62, 0x65, 0x36, 0x64, 0x62, 0x30, 0x66, 0x65, 0x30, 0x39, 0x36, 0x34, 0x61, 0x39, 0x34, 0x39, 0x61, 0x31, 0x38, 0x36, 0x33, 0x39, 0x63, 0x30, 0x64, 0x64, 0x33, 0x30, 0x62, 0x30, 0x30, 0x36, 0x31, 0x62, 0x35, 0x64, 0x66, 0x64, 0x37, 0x62, 0x63, 0x36, 0x62, 0x32, 0x63, 0x65, 0x33, 0x34, 0x37, 0x32, 0x36, 0x37, 0x34, 0x38, 0x39, 0x38, 0x31, 0x61, 0x33, 0x30, 0x35, 0x30, 0x30, 0x36, 0x30, 0x33, 0x64, 0x63, 0x30, 0x34, 0x62, 0x32, 0x63, 0x61, 0x36, 0x34, 0x66, 0x61, 0x39, 0x31, 0x65, 0x66, 0x34, 0x66, 0x64, 0x66, 0x65, 0x61, 0x31, 0x37, 0x30, 0x61, 0x66, 0x66, 0x34, 0x38, 0x35, 0x30, 0x37, 0x65, 0x63, 0x39, 0x64, 0x36, 0x33, 0x63, 0x61, 0x38, 0x31, 0x31, 0x61, 0x34, 0x35, 0x63, 0x34, 0x64, 0x32, 0x30, 0x31, 0x33, 0x61, 0x66, 0x32, 0x63, 0x63, 0x32, 0x61, 0x64, 0x62, 0x30, 0x66, 0x63, 0x37, 0x64, 0x32, 0x33, 0x34, 0x64, 0x33, 0x62, 0x63, 0x34, 0x38, 0x62, 0x64, 0x37, 0x62, 0x34, 0x62, 0x38, 0x32, 0x33, 0x34, 0x30, 0x31, 0x62, 0x36, 0x32, 0x64, 0x62, 0x35, 0x31, 0x62, 0x36, 0x64, 0x34, 0x30, 0x31, 0x65, 0x37, 0x34, 0x32, 0x37, 0x31, 0x31, 0x64, 0x37, 0x32, 0x66, 0x31, 0x31, 0x32, 0x32, 0x34, 0x66, 0x32, 0x61, 0x30, 0x65, 0x37, 0x34, 0x36, 0x38, 0x66, 0x61, 0x61, 0x66, 0x62, 0x63, 0x64, 0x31, 0x61, 0x31, 0x30, 0x33, 0x30, 0x31, 0x65, 0x63, 0x37, 0x65, 0x36, 0x38, 0x37, 0x38, 0x35, 0x32, 0x36, 0x35, 0x65, 0x64, 0x36, 0x65, 0x39, 0x32, 0x38, 0x64, 0x64, 0x65, 0x36, 0x38, 0x61, 0x64, 0x30, 0x35, 0x65, 0x36, 0x65, 0x36, 0x31, 0x37, 0x32, 0x31, 0x34, 0x65, 0x30, 0x39, 0x30, 0x37, 0x64, 0x38, 0x35, 0x34, 0x61, 0x39, 0x32, 0x66, 0x62, 0x34, 0x37, 0x36, 0x34, 0x39, 0x33, 0x65, 0x35, 0x61, 0x65, 0x37, 0x35, 0x37, 0x30, 0x36, 0x32, 0x38, 0x34, 0x66, 0x65, 0x37, 0x39, 0x33, 0x63, 0x37, 0x62, 0x39, 0x61, 0x62, 0x63, 0x62, 0x64, 0x31, 0x36, 0x62, 0x34, 0x64, 0x61, 0x61, 0x38, 0x63, 0x30, 0x61, 0x36, 0x38, 0x33, 0x36, 0x39, 0x62, 0x65, 0x36, 0x62, 0x31, 0x64, 0x61, 0x38, 0x61, 0x38, 0x63, 0x34, 0x62, 0x33, 0x34, 0x33, 0x64, 0x35, 0x61, 0x63, 0x63, 0x37, 0x31, 0x31, 0x36, 0x62, 0x34, 0x35, 0x36, 0x61, 0x65, 0x61, 0x63, 0x35, 0x66, 0x33, 0x35, 0x62, 0x32, 0x63, 0x62, 0x66, 0x39, 0x65, 0x33, 0x34, 0x37, 0x37, 0x66, 0x36, 0x63, 0x61, 0x62, 0x39, 0x63, 0x33, 0x62, 0x36, 0x62, 0x66, 0x34, 0x39, 0x37, 0x32, 0x38, 0x61, 0x63, 0x37, 0x36, 0x37, 0x32, 0x35, 0x66, 0x65, 0x33, 0x39, 0x32, 0x64, 0x63, 0x61, 0x31, 0x36, 0x34, 0x37, 0x39, 0x37, 0x62, 0x31, 0x37, 0x36, 0x35, 0x33, 0x31, 0x64, 0x35, 0x62, 0x38, 0x38, 0x39, 0x38, 0x33, 0x38, 0x65, 0x33, 0x32, 0x63, 0x34, 0x39, 0x64, 0x33, 0x62, 0x31, 0x63, 0x65, 0x66, 0x64, 0x34, 0x65, 0x38, 0x34, 0x39, 0x34, 0x66, 0x31, 0x35, 0x38, 0x37, 0x32, 0x32, 0x39, 0x38, 0x61, 0x64, 0x61, 0x37, 0x66, 0x61, 0x35, 0x66, 0x63, 0x66, 0x35, 0x34, 0x37, 0x39, 0x38, 0x38, 0x62, 0x38, 0x65, 0x36, 0x64, 0x36, 0x33, 0x35, 0x31, 0x38, 0x32, 0x30, 0x62, 0x37, 0x62, 0x33, 0x39, 0x30, 0x66, 0x63, 0x30, 0x65, 0x64, 0x31, 0x62, 0x37, 0x63, 0x61, 0x61, 0x66, 0x63, 0x66, 0x63, 0x37, 0x64, 0x33, 0x34, 0x32, 0x64, 0x31, 0x64, 0x66, 0x35, 0x37, 0x32, 0x37, 0x61, 0x65, 0x35, 0x35, 0x62, 0x31, 0x39, 0x34, 0x64, 0x36, 0x61, 0x31, 0x33, 0x30, 0x31, 0x36, 0x32, 0x32, 0x37, 0x39, 0x64, 0x64, 0x63, 0x65, 0x39, 0x62, 0x65, 0x66, 0x64, 0x30, 0x64, 0x63, 0x31, 0x39, 0x32, 0x61, 0x35, 0x31, 0x63, 0x35, 0x38, 0x64, 0x63, 0x37, 0x33, 0x61, 0x38, 0x33, 0x32, 0x38, 0x38, 0x65, 0x37, 0x35, 0x38, 0x65, 0x35, 0x37, 0x33, 0x62, 0x30, 0x37, 0x32, 0x33, 0x66, 0x39, 0x31, 0x33, 0x38, 0x39, 0x30, 0x35, 0x61, 0x32, 0x65, 0x62, 0x34, 0x34, 0x63, 0x36, 0x62, 0x39, 0x39, 0x33, 0x33, 0x33, 0x35, 0x34, 0x39, 0x33, 0x34, 0x31, 0x36, 0x37, 0x64, 0x39, 0x61, 0x63, 0x36, 0x39, 0x33, 0x62, 0x65, 0x35, 0x61, 0x30, 0x62, 0x33, 0x64, 0x66, 0x30, 0x64, 0x34, 0x38, 0x62, 0x64, 0x34, 0x35, 0x30, 0x33, 0x30, 0x65, 0x32, 0x34, 0x63, 0x37, 0x32, 0x30, 0x62, 0x34, 0x35, 0x61, 0x31, 0x61, 0x32, 0x61, 0x63, 0x39, 0x36, 0x34, 0x66, 0x65, 0x38, 0x31, 0x39, 0x39, 0x31, 0x37, 0x66, 0x66, 0x61, 0x37, 0x30, 0x34, 0x33, 0x37, 0x66, 0x37, 0x31, 0x30, 0x64, 0x36, 0x62, 0x64, 0x36, 0x39, 0x64, 0x62, 0x64, 0x38, 0x64, 0x39, 0x30, 0x64, 0x61, 0x35, 0x64, 0x66, 0x35, 0x66, 0x31, 0x62, 0x30, 0x30, 0x66, 0x35, 0x33, 0x31, 0x30, 0x37, 0x32, 0x34, 0x62, 0x31, 0x37, 0x64, 0x62, 0x34, 0x33, 0x33, 0x64, 0x33, 0x62, 0x39, 0x61, 0x65, 0x31, 0x31, 0x33, 0x64, 0x34, 0x65, 0x33, 0x31, 0x39, 0x35, 0x31, 0x34, 0x63, 0x64, 0x62, 0x32, 0x35, 0x32, 0x39, 0x38, 0x65, 0x30, 0x33, 0x32, 0x66, 0x32, 0x38, 0x38, 0x62, 0x66, 0x35, 0x38, 0x32, 0x66, 0x36, 0x62, 0x37, 0x39, 0x64, 0x63, 0x62, 0x36, 0x38, 0x66, 0x35, 0x64, 0x33, 0x34, 0x62, 0x65, 0x39, 0x31, 0x37, 0x38, 0x61, 0x36, 0x36, 0x31, 0x37, 0x64, 0x64, 0x35, 0x34, 0x38, 0x32, 0x33, 0x39, 0x63, 0x35, 0x34, 0x66, 0x30, 0x34, 0x34, 0x35, 0x30, 0x63, 0x31, 0x62, 0x37, 0x63, 0x64, 0x37, 0x34, 0x66, 0x66, 0x39, 0x37, 0x61, 0x32, 0x65, 0x38, 0x38, 0x61, 0x66, 0x63, 0x39, 0x62, 0x32, 0x66, 0x65, 0x34, 0x63, 0x36, 0x62, 0x32, 0x65, 0x64, 0x36, 0x30, 0x61, 0x34, 0x33, 0x64, 0x63, 0x39, 0x38, 0x32, 0x62, 0x31, 0x31, 0x30, 0x38, 0x38, 0x62, 0x36, 0x30, 0x62, 0x30, 0x30, 0x36, 0x38, 0x65, 0x34, 0x62, 0x31, 0x66, 0x61, 0x30, 0x62, 0x61, 0x30, 0x38, 0x36, 0x61, 0x65, 0x37, 0x65, 0x63, 0x37, 0x62, 0x66, 0x38, 0x63, 0x33, 0x61, 0x64, 0x33, 0x36, 0x30, 0x36, 0x31, 0x37, 0x38, 0x61, 0x39, 0x32, 0x32, 0x34, 0x35, 0x62, 0x34, 0x38, 0x66, 0x61, 0x37, 0x32, 0x32, 0x65, 0x38, 0x31, 0x35, 0x38, 0x63, 0x66, 0x31, 0x36, 0x39, 0x65, 0x65, 0x39, 0x34, 0x62, 0x31, 0x65, 0x39, 0x33, 0x39, 0x63, 0x32, 0x63, 0x64, 0x34, 0x37, 0x31, 0x34, 0x62, 0x38, 0x36, 0x35, 0x36, 0x32, 0x31, 0x34, 0x61, 0x61, 0x37, 0x66, 0x65, 0x32, 0x39, 0x35, 0x62, 0x31, 0x66, 0x30, 0x64, 0x62, 0x37, 0x66, 0x30, 0x31, 0x61, 0x35, 0x66, 0x65, 0x66, 0x36, 0x35, 0x30, 0x33, 0x66, 0x33, 0x33, 0x34, 0x36, 0x36, 0x37, 0x30, 0x36, 0x66, 0x39, 0x61, 0x35, 0x34, 0x64, 0x32, 0x30, 0x35, 0x31, 0x30, 0x36, 0x32, 0x61, 0x63, 0x61, 0x31, 0x36, 0x37, 0x30, 0x36, 0x35, 0x32, 0x63, 0x62, 0x34, 0x38, 0x66, 0x63, 0x61, 0x32, 0x64, 0x66, 0x32, 0x38, 0x33, 0x65, 0x65, 0x62, 0x36, 0x30, 0x31, 0x31, 0x36, 0x38, 0x34, 0x33, 0x61, 0x38, 0x66, 0x37, 0x33, 0x36, 0x37, 0x32, 0x30, 0x30, 0x33, 0x36, 0x39, 0x61, 0x30, 0x30, 0x66, 0x32, 0x64, 0x37, 0x38, 0x30, 0x31, 0x37, 0x61, 0x31, 0x63, 0x32, 0x61, 0x33, 0x63, 0x61, 0x39, 0x34, 0x36, 0x36, 0x36, 0x63, 0x32, 0x65, 0x37, 0x35, 0x33, 0x30, 0x61, 0x32, 0x36, 0x30, 0x35, 0x38, 0x38, 0x36, 0x37, 0x63, 0x37, 0x32, 0x35, 0x30, 0x39, 0x38, 0x64, 0x63, 0x34, 0x30, 0x64, 0x64, 0x36, 0x66, 0x32, 0x30, 0x31, 0x65, 0x39, 0x34, 0x63, 0x33, 0x61, 0x61, 0x66, 0x64, 0x61, 0x61, 0x65, 0x31, 0x30, 0x33, 0x30, 0x32, 0x65, 0x66, 0x62, 0x37, 0x64, 0x37, 0x61, 0x30, 0x63, 0x31, 0x31, 0x36, 0x31, 0x37, 0x63, 0x65, 0x34, 0x32, 0x64, 0x34, 0x64, 0x36, 0x65, 0x39, 0x65, 0x33, 0x65, 0x36, 0x39, 0x31, 0x31, 0x65, 0x61, 0x33, 0x63, 0x35, 0x66, 0x62, 0x34, 0x33, 0x31, 0x31, 0x62, 0x61, 0x35, 0x66, 0x31, 0x66, 0x65, 0x34, 0x66, 0x65, 0x63, 0x39, 0x64, 0x63, 0x39, 0x33, 0x33, 0x33, 0x34, 0x31, 0x36, 0x35, 0x35, 0x64, 0x63, 0x38, 0x61, 0x66, 0x61, 0x32, 0x36, 0x39, 0x35, 0x63, 0x38, 0x38, 0x38, 0x64, 0x61, 0x61, 0x66, 0x62, 0x36, 0x34, 0x63, 0x30, 0x32, 0x62, 0x38, 0x64, 0x31, 0x36, 0x61, 0x33, 0x64, 0x38, 0x66, 0x31, 0x66, 0x31, 0x37, 0x34, 0x33, 0x65, 0x30, 0x30, 0x66, 0x31, 0x34, 0x30, 0x39, 0x32, 0x63, 0x62, 0x36, 0x35, 0x30, 0x38, 0x30, 0x30, 0x64, 0x63, 0x64, 0x30, 0x37, 0x35, 0x63, 0x37, 0x61, 0x31, 0x65, 0x36, 0x61, 0x36, 0x39, 0x31, 0x30, 0x66, 0x30, 0x39, 0x62, 0x34, 0x32, 0x36, 0x39, 0x39, 0x31, 0x63, 0x31, 0x64, 0x36, 0x61, 0x61, 0x31, 0x35, 0x65, 0x33, 0x30, 0x39, 0x64, 0x36, 0x39, 0x37, 0x62, 0x34, 0x36, 0x64, 0x37, 0x35, 0x32, 0x30, 0x34, 0x37, 0x32, 0x36, 0x34, 0x65, 0x38, 0x35, 0x34, 0x66, 0x39, 0x62, 0x39, 0x32, 0x65, 0x32, 0x64, 0x33, 0x34, 0x63, 0x63, 0x63, 0x30, 0x64, 0x30, 0x31, 0x39, 0x64, 0x38, 0x64, 0x62, 0x36, 0x30, 0x62, 0x62, 0x34, 0x39, 0x37, 0x64, 0x33, 0x62, 0x37, 0x34, 0x39, 0x63, 0x39, 0x31, 0x35, 0x32, 0x34, 0x62, 0x64, 0x62, 0x35, 0x64, 0x66, 0x66, 0x38, 0x34, 0x62, 0x36, 0x31, 0x37, 0x37, 0x32, 0x37, 0x32, 0x35, 0x30, 0x62, 0x35, 0x31, 0x38, 0x34, 0x30, 0x33, 0x30, 0x38, 0x34, 0x35, 0x35, 0x63, 0x63, 0x65, 0x64, 0x62, 0x32, 0x33, 0x31, 0x33, 0x62, 0x31, 0x36, 0x35, 0x30, 0x61, 0x61, 0x61, 0x34, 0x31, 0x35, 0x66, 0x66, 0x61, 0x32, 0x65, 0x63, 0x32, 0x37, 0x63, 0x31, 0x32, 0x30, 0x31, 0x30, 0x64, 0x32, 0x34, 0x35, 0x30, 0x38, 0x64, 0x31, 0x35, 0x36, 0x66, 0x36, 0x61, 0x64, 0x37, 0x32, 0x30, 0x62, 0x64, 0x61, 0x65, 0x35, 0x32, 0x66, 0x34, 0x38, 0x39, 0x33, 0x61, 0x64, 0x36, 0x37, 0x33, 0x31, 0x61, 0x64, 0x35, 0x64, 0x64, 0x31, 0x65, 0x39, 0x33, 0x36, 0x35, 0x36, 0x35, 0x32, 0x65, 0x66, 0x61, 0x31, 0x34, 0x38, 0x62, 0x63, 0x32, 0x31, 0x32, 0x62, 0x65, 0x30, 0x35, 0x33, 0x31, 0x65, 0x66, 0x33, 0x35, 0x65, 0x32, 0x34, 0x36, 0x66, 0x38, 0x32, 0x35, 0x38, 0x37, 0x32, 0x32, 0x35, 0x37, 0x32, 0x64, 0x38, 0x30, 0x31, 0x36, 0x35, 0x63, 0x34, 0x62, 0x31, 0x65, 0x35, 0x66, 0x30, 0x32, 0x35, 0x36, 0x33, 0x61, 0x33, 0x34, 0x34, 0x65, 0x30, 0x35, 0x38, 0x32, 0x39, 0x31, 0x64, 0x31, 0x65, 0x35, 0x37, 0x64, 0x35, 0x34, 0x64, 0x65, 0x33, 0x65, 0x64, 0x61, 0x66, 0x32, 0x63, 0x31, 0x64, 0x61, 0x34, 0x66, 0x32, 0x62, 0x37, 0x30, 0x32, 0x64, 0x35, 0x37, 0x32, 0x37, 0x34, 0x31, 0x64, 0x33, 0x61, 0x35, 0x66, 0x39, 0x38, 0x32, 0x66, 0x35, 0x33, 0x38, 0x66, 0x62, 0x61, 0x31, 0x30, 0x62, 0x66, 0x30, 0x62, 0x62, 0x63, 0x61, 0x64, 0x37, 0x63, 0x62, 0x32, 0x38, 0x33, 0x65, 0x65, 0x63, 0x36, 0x33, 0x37, 0x35, 0x63, 0x63, 0x35, 0x61, 0x31, 0x34, 0x32, 0x62, 0x39, 0x30, 0x33, 0x33, 0x62, 0x31, 0x37, 0x62, 0x39, 0x38, 0x37, 0x61, 0x63, 0x37, 0x32, 0x61, 0x37, 0x31, 0x62, 0x31, 0x33, 0x62, 0x32, 0x31, 0x61, 0x32, 0x37, 0x66, 0x65, 0x33, 0x34, 0x33, 0x63, 0x37, 0x32, 0x34, 0x39, 0x33, 0x33, 0x39, 0x64, 0x38, 0x32, 0x65, 0x63, 0x64, 0x32, 0x37, 0x30, 0x64, 0x62, 0x63, 0x37, 0x65, 0x62, 0x61, 0x62, 0x30, 0x36, 0x34, 0x38, 0x66, 0x62, 0x30, 0x38, 0x39, 0x34, 0x35, 0x61, 0x33, 0x31, 0x32, 0x66, 0x36, 0x33, 0x62, 0x30, 0x37, 0x32, 0x61, 0x63, 0x33, 0x64, 0x31, 0x36, 0x65, 0x35, 0x62, 0x37, 0x30, 0x35, 0x38, 0x34, 0x33, 0x33, 0x62, 0x36, 0x32, 0x34, 0x35, 0x31, 0x30, 0x38, 0x37, 0x33, 0x65, 0x39, 0x30, 0x32, 0x30, 0x35, 0x38, 0x33, 0x39, 0x32, 0x35, 0x65, 0x36, 0x36, 0x36, 0x35, 0x36, 0x65, 0x61, 0x34, 0x66, 0x36, 0x32, 0x36, 0x34, 0x62, 0x36, 0x66, 0x36, 0x61, 0x36, 0x65, 0x31, 0x32, 0x39, 0x34, 0x30, 0x35, 0x38, 0x34, 0x31, 0x64, 0x62, 0x61, 0x63, 0x62, 0x33, 0x36, 0x65, 0x39, 0x61, 0x33, 0x65, 0x61, 0x39, 0x39, 0x37, 0x39, 0x32, 0x31, 0x33, 0x37, 0x66, 0x62, 0x61, 0x65, 0x30, 0x32, 0x62, 0x38, 0x66, 0x63, 0x64, 0x35, 0x35, 0x66, 0x63, 0x37, 0x62, 0x66, 0x33, 0x62, 0x31, 0x62, 0x65, 0x65, 0x38, 0x33, 0x37, 0x35, 0x64, 0x34, 0x63, 0x63, 0x34, 0x63, 0x65, 0x32, 0x65, 0x64, 0x37, 0x32, 0x66, 0x63, 0x66, 0x66, 0x38, 0x37, 0x66, 0x39, 0x30, 0x33, 0x37, 0x37, 0x30, 0x65, 0x35, 0x33, 0x62, 0x35, 0x30, 0x37, 0x33, 0x65, 0x62, 0x35, 0x36, 0x63, 0x30, 0x65, 0x31, 0x61, 0x33, 0x64, 0x64, 0x32, 0x38, 0x39, 0x62, 0x32, 0x38, 0x38, 0x31, 0x63, 0x63, 0x30, 0x65, 0x30, 0x63, 0x39, 0x65, 0x66, 0x37, 0x33, 0x63, 0x61, 0x36, 0x62, 0x30, 0x32, 0x35, 0x61, 0x37, 0x38, 0x35, 0x35, 0x36, 0x31, 0x63, 0x62, 0x34, 0x30, 0x64, 0x34, 0x32, 0x30, 0x31, 0x38, 0x36, 0x34, 0x37, 0x65, 0x35, 0x37, 0x33, 0x66, 0x65, 0x35, 0x30, 0x36, 0x33, 0x62, 0x31, 0x61, 0x36, 0x33, 0x31, 0x31, 0x36, 0x36, 0x65, 0x65, 0x66, 0x34, 0x34, 0x33, 0x39, 0x33, 0x62, 0x31, 0x66, 0x66, 0x38, 0x37, 0x66, 0x35, 0x65, 0x61, 0x35, 0x62, 0x32, 0x35, 0x30, 0x35, 0x61, 0x65, 0x65, 0x37, 0x37, 0x32, 0x36, 0x63, 0x33, 0x61, 0x64, 0x38, 0x65, 0x30, 0x37, 0x35, 0x31, 0x63, 0x65, 0x62, 0x31, 0x63, 0x31, 0x31, 0x30, 0x32, 0x61, 0x38, 0x32, 0x39, 0x66, 0x65, 0x31, 0x38, 0x33, 0x37, 0x36, 0x66, 0x65, 0x31, 0x35, 0x39, 0x39, 0x63, 0x39, 0x33, 0x36, 0x61, 0x35, 0x38, 0x65, 0x64, 0x39, 0x33, 0x39, 0x63, 0x61, 0x37, 0x66, 0x63, 0x30, 0x63, 0x62, 0x39, 0x66, 0x34, 0x36, 0x37, 0x35, 0x38, 0x35, 0x65, 0x35, 0x39, 0x34, 0x61, 0x33, 0x30, 0x32, 0x32, 0x62, 0x33, 0x34, 0x31, 0x66, 0x63, 0x32, 0x31, 0x37, 0x61, 0x66, 0x37, 0x32, 0x66, 0x38, 0x63, 0x62, 0x30, 0x62, 0x65, 0x36, 0x63, 0x64, 0x61, 0x64, 0x39, 0x38, 0x33, 0x65, 0x39, 0x39, 0x36, 0x30, 0x38, 0x30, 0x36, 0x33, 0x36, 0x30, 0x30, 0x38, 0x37, 0x63, 0x64, 0x32, 0x36, 0x30, 0x36, 0x39, 0x66, 0x64, 0x34, 0x30, 0x64, 0x62, 0x36, 0x37, 0x64, 0x36, 0x30, 0x62, 0x35, 0x65, 0x32, 0x34, 0x38, 0x33, 0x65, 0x30, 0x61, 0x39, 0x63, 0x34, 0x37, 0x39, 0x66, 0x33, 0x30, 0x30, 0x31, 0x65, 0x66, 0x61, 0x39, 0x33, 0x63, 0x38, 0x37, 0x62, 0x37, 0x61, 0x66, 0x61, 0x32, 0x36, 0x65, 0x63, 0x32, 0x39, 0x33, 0x37, 0x35, 0x38, 0x30, 0x32, 0x39, 0x63, 0x37, 0x39, 0x32, 0x33, 0x39, 0x63, 0x39, 0x61, 0x36, 0x34, 0x61, 0x34, 0x38, 0x64, 0x33, 0x66, 0x65, 0x36, 0x30, 0x64, 0x36, 0x65, 0x61, 0x64, 0x39, 0x34, 0x33, 0x38, 0x39, 0x63, 0x61, 0x32, 0x32, 0x35, 0x35, 0x64, 0x65, 0x64, 0x35, 0x35, 0x38, 0x30, 0x37, 0x34, 0x32, 0x63, 0x61, 0x61, 0x35, 0x36, 0x36, 0x61, 0x32, 0x39, 0x63, 0x62, 0x61, 0x30, 0x30, 0x36, 0x39, 0x37, 0x65, 0x62, 0x66, 0x64, 0x31, 0x66, 0x37, 0x36, 0x64, 0x32, 0x34, 0x37, 0x32, 0x63, 0x64, 0x65, 0x30, 0x37, 0x38, 0x38, 0x61, 0x38, 0x38, 0x31, 0x38, 0x38, 0x38, 0x30, 0x37, 0x30, 0x63, 0x34, 0x30, 0x38, 0x65, 0x36, 0x31, 0x33, 0x64, 0x35, 0x36, 0x34, 0x36, 0x36, 0x33, 0x32, 0x63, 0x30, 0x34, 0x32, 0x32, 0x62, 0x61, 0x38, 0x62, 0x36, 0x39, 0x34, 0x33, 0x63, 0x30, 0x34, 0x32, 0x63, 0x31, 0x65, 0x38, 0x30, 0x31, 0x65, 0x31, 0x38, 0x61, 0x39, 0x39, 0x35, 0x33, 0x34, 0x32, 0x33, 0x38, 0x30, 0x66, 0x30, 0x63, 0x31, 0x38, 0x36, 0x33, 0x39, 0x66, 0x61, 0x36, 0x30, 0x33, 0x66, 0x61, 0x64, 0x39, 0x38, 0x62, 0x30, 0x63, 0x31, 0x30, 0x34, 0x36, 0x38, 0x38, 0x31, 0x66, 0x36, 0x65, 0x34, 0x32, 0x30, 0x31, 0x39, 0x30, 0x63, 0x61, 0x37, 0x38, 0x39, 0x36, 0x65, 0x32, 0x38, 0x37, 0x34, 0x63, 0x37, 0x32, 0x37, 0x65, 0x63, 0x35, 0x37, 0x30, 0x30, 0x33, 0x35, 0x62, 0x64, 0x61, 0x37, 0x31, 0x63, 0x64, 0x30, 0x65, 0x34, 0x61, 0x38, 0x65, 0x39, 0x63, 0x63, 0x33, 0x61, 0x65, 0x63, 0x63, 0x36, 0x35, 0x39, 0x65, 0x64, 0x66, 0x30, 0x33, 0x61, 0x34, 0x37, 0x34, 0x32, 0x33, 0x33, 0x64, 0x38, 0x61, 0x39, 0x62, 0x63, 0x64, 0x63, 0x65, 0x39, 0x32, 0x30, 0x65, 0x32, 0x62, 0x63, 0x65, 0x65, 0x64, 0x61, 0x31, 0x34, 0x62, 0x35, 0x61, 0x37, 0x32, 0x63, 0x32, 0x66, 0x31, 0x62, 0x34, 0x36, 0x35, 0x63, 0x34, 0x62, 0x32, 0x62, 0x61, 0x65, 0x38, 0x39, 0x31, 0x61, 0x62, 0x31, 0x31, 0x36, 0x30, 0x31, 0x64, 0x31, 0x35, 0x38, 0x66, 0x31, 0x65, 0x63, 0x61, 0x35, 0x61, 0x62, 0x63, 0x65, 0x30, 0x30, 0x65, 0x61, 0x38, 0x62, 0x33, 0x66, 0x31, 0x35, 0x33, 0x62, 0x38, 0x66, 0x66, 0x65, 0x30, 0x30, 0x35, 0x33, 0x32, 0x62, 0x63, 0x37, 0x32, 0x63, 0x65, 0x34, 0x35, 0x62, 0x30, 0x63, 0x31, 0x31, 0x38, 0x62, 0x62, 0x64, 0x66, 0x61, 0x32, 0x34, 0x63, 0x31, 0x39, 0x61, 0x38, 0x63, 0x33, 0x61, 0x31, 0x33, 0x34, 0x34, 0x32, 0x37, 0x36, 0x38, 0x65, 0x33, 0x61, 0x39, 0x35, 0x34, 0x30, 0x64, 0x36, 0x39, 0x35, 0x30, 0x65, 0x34, 0x30, 0x31, 0x39, 0x61, 0x38, 0x33, 0x33, 0x32, 0x62, 0x65, 0x65, 0x36, 0x61, 0x33, 0x31, 0x37, 0x32, 0x35, 0x31, 0x36, 0x37, 0x30, 0x66, 0x66, 0x61, 0x62, 0x39, 0x37, 0x38, 0x61, 0x66, 0x65, 0x34, 0x36, 0x36, 0x64, 0x31, 0x32, 0x35, 0x33, 0x33, 0x65, 0x62, 0x31, 0x62, 0x32, 0x65, 0x62, 0x61, 0x66, 0x36, 0x35, 0x61, 0x39, 0x35, 0x33, 0x30, 0x31, 0x34, 0x36, 0x31, 0x66, 0x65, 0x39, 0x36, 0x39, 0x66, 0x64, 0x66, 0x36, 0x66, 0x30, 0x63, 0x39, 0x66, 0x38, 0x62, 0x65, 0x35, 0x37, 0x32, 0x62, 0x33, 0x37, 0x37, 0x66, 0x37, 0x36, 0x32, 0x37, 0x66, 0x63, 0x61, 0x39, 0x37, 0x61, 0x62, 0x39, 0x63, 0x35, 0x66, 0x34, 0x37, 0x34, 0x31, 0x30, 0x62, 0x34, 0x39, 0x32, 0x33, 0x35, 0x30, 0x34, 0x31, 0x33, 0x33, 0x61, 0x36, 0x36, 0x36, 0x30, 0x65, 0x34, 0x33, 0x31, 0x36, 0x66, 0x63, 0x32, 0x63, 0x36, 0x63, 0x35, 0x39, 0x31, 0x66, 0x31, 0x36, 0x35, 0x36, 0x36, 0x36, 0x34, 0x63, 0x65, 0x33, 0x33, 0x62, 0x31, 0x62, 0x37, 0x39, 0x33, 0x30, 0x34, 0x62, 0x39, 0x65, 0x37, 0x66, 0x35, 0x36, 0x65, 0x30, 0x64, 0x35, 0x63, 0x35, 0x63, 0x65, 0x32, 0x30, 0x38, 0x30, 0x65, 0x35, 0x37, 0x61, 0x34, 0x64, 0x33, 0x32, 0x39, 0x30, 0x64, 0x63, 0x34, 0x33, 0x35, 0x36, 0x39, 0x38, 0x63, 0x31, 0x66, 0x62, 0x66, 0x62, 0x33, 0x39, 0x63, 0x62, 0x65, 0x32, 0x64, 0x62, 0x34, 0x64, 0x38, 0x62, 0x30, 0x66, 0x34, 0x62, 0x38, 0x31, 0x34, 0x65, 0x32, 0x36, 0x35, 0x35, 0x30, 0x36, 0x35, 0x33, 0x31, 0x65, 0x65, 0x30, 0x38, 0x33, 0x30, 0x36, 0x38, 0x39, 0x31, 0x33, 0x39, 0x62, 0x31, 0x33, 0x65, 0x30, 0x30, 0x33, 0x63, 0x35, 0x61, 0x36, 0x39, 0x31, 0x65, 0x35, 0x34, 0x64, 0x30, 0x65, 0x64, 0x64, 0x36, 0x36, 0x37, 0x63, 0x38, 0x66, 0x63, 0x63, 0x64, 0x33, 0x31, 0x64, 0x33, 0x35, 0x31, 0x31, 0x32, 0x62, 0x37, 0x63, 0x62, 0x31, 0x30, 0x62, 0x64, 0x61, 0x66, 0x65, 0x31, 0x63, 0x35, 0x31, 0x32, 0x64, 0x38, 0x62, 0x37, 0x61, 0x35, 0x31, 0x33, 0x34, 0x63, 0x36, 0x65, 0x31, 0x31, 0x31, 0x33, 0x37, 0x31, 0x30, 0x66, 0x35, 0x36, 0x61, 0x36, 0x66, 0x31, 0x36, 0x39, 0x35, 0x33, 0x64, 0x64, 0x34, 0x30, 0x39, 0x31, 0x33, 0x66, 0x32, 0x63, 0x30, 0x37, 0x32, 0x65, 0x34, 0x61, 0x38, 0x30, 0x63, 0x61, 0x39, 0x33, 0x38, 0x64, 0x34, 0x32, 0x35, 0x61, 0x33, 0x63, 0x64, 0x65, 0x37, 0x62, 0x39, 0x61, 0x61, 0x33, 0x30, 0x37, 0x30, 0x36, 0x34, 0x65, 0x33, 0x38, 0x33, 0x37, 0x34, 0x34, 0x61, 0x35, 0x34, 0x38, 0x33, 0x30, 0x32, 0x31, 0x36, 0x65, 0x38, 0x37, 0x32, 0x36, 0x34, 0x61, 0x64, 0x62, 0x62, 0x38, 0x39, 0x34, 0x66, 0x65, 0x30, 0x35, 0x38, 0x66, 0x36, 0x65, 0x31, 0x30, 0x65, 0x66, 0x39, 0x34, 0x30, 0x63, 0x38, 0x65, 0x35, 0x39, 0x39, 0x39, 0x34, 0x36, 0x30, 0x35, 0x33, 0x62, 0x32, 0x39, 0x65, 0x66, 0x37, 0x35, 0x34, 0x33, 0x65, 0x63, 0x61, 0x36, 0x33, 0x32, 0x33, 0x35, 0x31, 0x33, 0x61, 0x38, 0x31, 0x35, 0x61, 0x38, 0x33, 0x61, 0x38, 0x33, 0x63, 0x61, 0x35, 0x37, 0x30, 0x33, 0x37, 0x63, 0x61, 0x31, 0x33, 0x30, 0x36, 0x34, 0x37, 0x61, 0x65, 0x62, 0x65, 0x64, 0x35, 0x32, 0x39, 0x64, 0x33, 0x38, 0x30, 0x66, 0x64, 0x61, 0x61, 0x65, 0x65, 0x61, 0x30, 0x36, 0x65, 0x31, 0x31, 0x30, 0x38, 0x38, 0x34, 0x36, 0x64, 0x33, 0x39, 0x35, 0x33, 0x39, 0x36, 0x37, 0x34, 0x65, 0x33, 0x36, 0x36, 0x31, 0x39, 0x65, 0x31, 0x33, 0x32, 0x61, 0x63, 0x66, 0x36, 0x61, 0x34, 0x66, 0x35, 0x31, 0x64, 0x37, 0x35, 0x37, 0x32, 0x32, 0x62, 0x31, 0x39, 0x33, 0x32, 0x32, 0x31, 0x61, 0x64, 0x64, 0x39, 0x30, 0x31, 0x36, 0x35, 0x65, 0x31, 0x61, 0x61, 0x33, 0x33, 0x32, 0x62, 0x65, 0x38, 0x30, 0x30, 0x64, 0x61, 0x38, 0x31, 0x62, 0x65, 0x37, 0x32, 0x31, 0x38, 0x64, 0x63, 0x35, 0x61, 0x36, 0x39, 0x38, 0x63, 0x65, 0x62, 0x64, 0x39, 0x33, 0x30, 0x30, 0x63, 0x33, 0x65, 0x35, 0x63, 0x66, 0x38, 0x39, 0x64, 0x35, 0x33, 0x65, 0x64, 0x31, 0x61, 0x34, 0x35, 0x65, 0x65, 0x30, 0x38, 0x37, 0x61, 0x65, 0x61, 0x33, 0x63, 0x31, 0x33, 0x39, 0x64, 0x30, 0x64, 0x39, 0x39, 0x36, 0x61, 0x37, 0x39, 0x31, 0x63, 0x38, 0x32, 0x31, 0x62, 0x36, 0x33, 0x62, 0x39, 0x62, 0x31, 0x37, 0x65, 0x61, 0x37, 0x31, 0x30, 0x37, 0x31, 0x66, 0x33, 0x65, 0x36, 0x33, 0x32, 0x66, 0x35, 0x65, 0x35, 0x62, 0x64, 0x39, 0x62, 0x37, 0x32, 0x32, 0x61, 0x61, 0x35, 0x63, 0x66, 0x30, 0x38, 0x35, 0x35, 0x35, 0x35, 0x65, 0x34, 0x32, 0x31, 0x64, 0x34, 0x34, 0x38, 0x38, 0x39, 0x61, 0x63, 0x35, 0x65, 0x63, 0x31, 0x66, 0x38, 0x35, 0x34, 0x30, 0x63, 0x61, 0x64, 0x64, 0x64, 0x32, 0x36, 0x31, 0x38, 0x65, 0x66, 0x37, 0x62, 0x66, 0x66, 0x38, 0x62, 0x37, 0x35, 0x38, 0x64, 0x37, 0x65, 0x34, 0x38, 0x38, 0x31, 0x36, 0x65, 0x35, 0x37, 0x61, 0x64, 0x62, 0x63, 0x31, 0x31, 0x65, 0x65, 0x33, 0x33, 0x35, 0x63, 0x39, 0x30, 0x38, 0x32, 0x31, 0x30, 0x62, 0x36, 0x33, 0x34, 0x64, 0x37, 0x34, 0x38, 0x32, 0x64, 0x32, 0x34, 0x39, 0x35, 0x37, 0x33, 0x33, 0x66, 0x65, 0x39, 0x62, 0x62, 0x33, 0x62, 0x38, 0x39, 0x63, 0x65, 0x65, 0x61, 0x38, 0x30, 0x31, 0x30, 0x63, 0x35, 0x65, 0x35, 0x33, 0x32, 0x31, 0x34, 0x37, 0x30, 0x35, 0x62, 0x36, 0x30, 0x64, 0x31, 0x38, 0x32, 0x37, 0x61, 0x31, 0x30, 0x36, 0x63, 0x30, 0x66, 0x34, 0x38, 0x33, 0x37, 0x38, 0x32, 0x64, 0x39, 0x37, 0x64, 0x37, 0x65, 0x64, 0x35, 0x32, 0x35, 0x38, 0x37, 0x65, 0x36, 0x31, 0x31, 0x37, 0x62, 0x30, 0x64, 0x62, 0x61, 0x32, 0x61, 0x66, 0x37, 0x66, 0x65, 0x38, 0x64, 0x36, 0x64, 0x62, 0x38, 0x63, 0x35, 0x36, 0x34, 0x30, 0x36, 0x34, 0x63, 0x31, 0x61, 0x32, 0x38, 0x38, 0x32, 0x30, 0x65, 0x61, 0x63, 0x62, 0x66, 0x34, 0x66, 0x33, 0x30, 0x64, 0x65, 0x63, 0x37, 0x39, 0x33, 0x35, 0x37, 0x37, 0x65, 0x65, 0x66, 0x33, 0x66, 0x39, 0x30, 0x36, 0x38, 0x34, 0x38, 0x39, 0x30, 0x34, 0x64, 0x36, 0x37, 0x37, 0x34, 0x66, 0x35, 0x63, 0x37, 0x63, 0x39, 0x35, 0x35, 0x30, 0x39, 0x35, 0x31, 0x65, 0x39, 0x65, 0x36, 0x30, 0x62, 0x37, 0x65, 0x35, 0x64, 0x38, 0x32, 0x30, 0x33, 0x39, 0x34, 0x37, 0x39, 0x35, 0x32, 0x35, 0x37, 0x66, 0x65, 0x61, 0x36, 0x34, 0x61, 0x39, 0x32, 0x63, 0x62, 0x37, 0x39, 0x64, 0x32, 0x36, 0x36, 0x33, 0x37, 0x36, 0x62, 0x36, 0x65, 0x66, 0x31, 0x63, 0x36, 0x30, 0x30, 0x63, 0x34, 0x32, 0x35, 0x61, 0x35, 0x37, 0x35, 0x30, 0x36, 0x66, 0x33, 0x39, 0x61, 0x39, 0x31, 0x36, 0x35, 0x38, 0x38, 0x64, 0x33, 0x33, 0x31, 0x35, 0x63, 0x63, 0x32, 0x61, 0x38, 0x65, 0x36, 0x35, 0x61, 0x36, 0x65, 0x65, 0x33, 0x39, 0x35, 0x32, 0x62, 0x31, 0x35, 0x66, 0x31, 0x33, 0x39, 0x61, 0x38, 0x65, 0x39, 0x30, 0x66, 0x33, 0x65, 0x65, 0x35, 0x34, 0x63, 0x63, 0x39, 0x66, 0x62, 0x38, 0x35, 0x61, 0x66, 0x37, 0x31, 0x36, 0x63, 0x65, 0x34, 0x66, 0x34, 0x30, 0x30, 0x61, 0x61, 0x36, 0x61, 0x66, 0x33, 0x33, 0x63, 0x35, 0x32, 0x35, 0x66, 0x62, 0x30, 0x66, 0x35, 0x35, 0x65, 0x64, 0x34, 0x34, 0x64, 0x64, 0x31, 0x34, 0x62, 0x31, 0x33, 0x65, 0x31, 0x63, 0x38, 0x61, 0x30, 0x35, 0x37, 0x35, 0x63, 0x39, 0x34, 0x37, 0x30, 0x39, 0x32, 0x35, 0x30, 0x30, 0x62, 0x62, 0x34, 0x30, 0x62, 0x35, 0x34, 0x65, 0x34, 0x35, 0x61, 0x64, 0x39, 0x39, 0x61, 0x31, 0x61, 0x38, 0x33, 0x62, 0x61, 0x34, 0x64, 0x34, 0x66, 0x33, 0x64, 0x65, 0x63, 0x30, 0x65, 0x62, 0x61, 0x61, 0x37, 0x38, 0x30, 0x38, 0x33, 0x37, 0x62, 0x30, 0x32, 0x35, 0x66, 0x39, 0x64, 0x62, 0x30, 0x63, 0x39, 0x63, 0x39, 0x31, 0x36, 0x31, 0x30, 0x31, 0x62, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x39, 0x31, 0x36, 0x61, 0x36, 0x65, 0x36, 0x31, 0x34, 0x35, 0x38, 0x35, 0x35, 0x39, 0x39, 0x61, 0x61, 0x32, 0x34, 0x61, 0x33, 0x30, 0x62, 0x38, 0x36, 0x61, 0x61, 0x32, 0x37, 0x34, 0x35, 0x36, 0x32, 0x35, 0x34, 0x64, 0x31, 0x39, 0x32, 0x38, 0x66, 0x36, 0x33, 0x38, 0x31, 0x33, 0x64, 0x32, 0x63, 0x39, 0x62, 0x63, 0x39, 0x36, 0x65, 0x37, 0x63, 0x37, 0x34, 0x37, 0x66, 0x65, 0x39, 0x61, 0x61, 0x34, 0x35, 0x35, 0x35, 0x65, 0x37, 0x34, 0x31, 0x37, 0x66, 0x31, 0x64, 0x34, 0x31, 0x64, 0x31, 0x38, 0x38, 0x38, 0x34, 0x66, 0x34, 0x61, 0x30, 0x36, 0x33, 0x33, 0x37, 0x33, 0x62, 0x36, 0x65, 0x33, 0x34, 0x65, 0x61, 0x61, 0x38, 0x30, 0x35, 0x34, 0x33, 0x31, 0x66, 0x61, 0x33, 0x31, 0x35, 0x61, 0x31, 0x30, 0x61, 0x64, 0x64, 0x36, 0x62, 0x33, 0x34, 0x63, 0x35, 0x61, 0x66, 0x64, 0x34, 0x63, 0x35, 0x62, 0x36, 0x66, 0x38, 0x35, 0x34, 0x35, 0x34, 0x64, 0x33, 0x36, 0x61, 0x62, 0x65, 0x34, 0x31, 0x30, 0x65, 0x65, 0x65, 0x34, 0x32, 0x66, 0x39, 0x66, 0x36, 0x32, 0x38, 0x65, 0x61, 0x31, 0x36, 0x34, 0x62, 0x61, 0x36, 0x33, 0x36, 0x65, 0x30, 0x65, 0x62, 0x62, 0x37, 0x65, 0x64, 0x37, 0x63, 0x65, 0x37, 0x38, 0x38, 0x66, 0x30, 0x65, 0x38, 0x64, 0x37, 0x61, 0x61, 0x34, 0x30, 0x36, 0x66, 0x65, 0x63, 0x34, 0x33, 0x63, 0x39, 0x35, 0x30, 0x39, 0x61, 0x65, 0x30, 0x65, 0x34, 0x65, 0x61, 0x31, 0x36, 0x61, 0x34, 0x39, 0x37, 0x32, 0x62, 0x64, 0x32, 0x37, 0x63, 0x35, 0x65, 0x37, 0x65, 0x63, 0x61, 0x36, 0x35, 0x61, 0x36, 0x36, 0x37, 0x33, 0x35, 0x64, 0x37, 0x38, 0x32, 0x61, 0x33, 0x35, 0x38, 0x33, 0x34, 0x63, 0x65, 0x38, 0x65, 0x34, 0x31, 0x31, 0x34, 0x64, 0x61, 0x31, 0x64, 0x34, 0x37, 0x61, 0x62, 0x61, 0x64, 0x31, 0x61, 0x61, 0x35, 0x66, 0x32, 0x35, 0x36, 0x32, 0x30, 0x62, 0x37, 0x65, 0x64, 0x36, 0x37, 0x32, 0x61, 0x37, 0x36, 0x31, 0x37, 0x35, 0x32, 0x61, 0x37, 0x64, 0x35, 0x34, 0x37, 0x65, 0x61, 0x33, 0x36, 0x65, 0x38, 0x39, 0x36, 0x65, 0x32, 0x65, 0x64, 0x35, 0x64, 0x33, 0x34, 0x61, 0x39, 0x32, 0x39, 0x33, 0x37, 0x31, 0x31, 0x39, 0x65, 0x62, 0x32, 0x62, 0x32, 0x30, 0x35, 0x39, 0x63, 0x64, 0x38, 0x36, 0x38, 0x36, 0x32, 0x61, 0x39, 0x32, 0x62, 0x64, 0x35, 0x62, 0x63, 0x34, 0x34, 0x38, 0x39, 0x64, 0x39, 0x31, 0x62, 0x66, 0x32, 0x65, 0x36, 0x30, 0x32, 0x38, 0x39, 0x36, 0x62, 0x62, 0x31, 0x31, 0x61, 0x64, 0x34, 0x36, 0x61, 0x39, 0x38, 0x37, 0x31, 0x35, 0x63, 0x34, 0x65, 0x36, 0x34, 0x34, 0x38, 0x64, 0x33, 0x36, 0x33, 0x34, 0x37, 0x32, 0x62, 0x35, 0x63, 0x33, 0x34, 0x34, 0x38, 0x66, 0x64, 0x66, 0x33, 0x39, 0x33, 0x32, 0x35, 0x34, 0x31, 0x32, 0x34, 0x64, 0x37, 0x32, 0x35, 0x38, 0x35, 0x64, 0x37, 0x30, 0x35, 0x64, 0x31, 0x63, 0x33, 0x33, 0x37, 0x39, 0x31, 0x33, 0x33, 0x66, 0x39, 0x66, 0x36, 0x32, 0x66, 0x66, 0x65, 0x32, 0x30, 0x39, 0x35, 0x65, 0x30, 0x64, 0x39, 0x37, 0x37, 0x66, 0x65, 0x63, 0x62, 0x63, 0x33, 0x36, 0x37, 0x33, 0x32, 0x30, 0x38, 0x65, 0x62, 0x30, 0x36, 0x31, 0x65, 0x33, 0x66, 0x61, 0x31, 0x32, 0x66, 0x62, 0x32, 0x30, 0x35, 0x38, 0x33, 0x32, 0x33, 0x31, 0x33, 0x62, 0x62, 0x38, 0x35, 0x30, 0x33, 0x65, 0x30, 0x63, 0x62, 0x63, 0x64, 0x64, 0x34, 0x35, 0x30, 0x38, 0x31, 0x66, 0x37, 0x35, 0x37, 0x33, 0x38, 0x32, 0x30, 0x34, 0x62, 0x36, 0x35, 0x35, 0x31, 0x61, 0x30, 0x37, 0x61, 0x61, 0x32, 0x66, 0x38, 0x36, 0x64, 0x63, 0x34, 0x39, 0x62, 0x66, 0x36, 0x33, 0x38, 0x61, 0x39, 0x39, 0x65, 0x38, 0x33, 0x33, 0x34, 0x61, 0x62, 0x33, 0x62, 0x66, 0x65, 0x35, 0x64, 0x64, 0x35, 0x34, 0x65, 0x39, 0x65, 0x34, 0x30, 0x38, 0x66, 0x62, 0x36, 0x33, 0x33, 0x63, 0x35, 0x35, 0x33, 0x37, 0x32, 0x64, 0x36, 0x31, 0x38, 0x32, 0x32, 0x34, 0x35, 0x31, 0x39, 0x38, 0x62, 0x30, 0x35, 0x34, 0x31, 0x39, 0x36, 0x62, 0x61, 0x32, 0x61, 0x64, 0x32, 0x38, 0x66, 0x62, 0x35, 0x35, 0x32, 0x38, 0x64, 0x62, 0x31, 0x61, 0x30, 0x38, 0x36, 0x35, 0x61, 0x62, 0x31, 0x66, 0x36, 0x39, 0x38, 0x34, 0x65, 0x35, 0x64, 0x62, 0x34, 0x61, 0x30, 0x63, 0x34, 0x32, 0x31, 0x64, 0x66, 0x35, 0x39, 0x66, 0x66, 0x34, 0x63, 0x36, 0x62, 0x65, 0x36, 0x66, 0x37, 0x39, 0x32, 0x61, 0x31, 0x31, 0x35, 0x63, 0x61, 0x30, 0x64, 0x32, 0x32, 0x31, 0x62, 0x63, 0x66, 0x33, 0x66, 0x32, 0x37, 0x61, 0x34, 0x32, 0x65, 0x35, 0x32, 0x64, 0x34, 0x33, 0x65, 0x66, 0x63, 0x62, 0x64, 0x31, 0x32, 0x38, 0x32, 0x37, 0x65, 0x35, 0x31, 0x39, 0x66, 0x34, 0x39, 0x61, 0x33, 0x37, 0x36, 0x66, 0x34, 0x66, 0x66, 0x63, 0x64, 0x35, 0x39, 0x63, 0x66, 0x61, 0x63, 0x38, 0x30, 0x62, 0x64, 0x31, 0x35, 0x65, 0x31, 0x34, 0x37, 0x62, 0x32, 0x66, 0x39, 0x63, 0x39, 0x64, 0x33, 0x64, 0x63, 0x38, 0x34, 0x64, 0x39, 0x66, 0x38, 0x31, 0x36, 0x62, 0x35, 0x39, 0x66, 0x61, 0x37, 0x65, 0x64, 0x36, 0x65, 0x36, 0x65, 0x34, 0x63, 0x61, 0x64, 0x30, 0x35, 0x31, 0x65, 0x33, 0x34, 0x38, 0x64, 0x66, 0x37, 0x33, 0x31, 0x37, 0x37, 0x62, 0x64, 0x62, 0x36, 0x34, 0x61, 0x33, 0x36, 0x38, 0x65, 0x33, 0x64, 0x37, 0x36, 0x36, 0x39, 0x66, 0x39, 0x64, 0x61, 0x37, 0x32, 0x64, 0x37, 0x65, 0x64, 0x35, 0x61, 0x34, 0x34, 0x35, 0x66, 0x38, 0x35, 0x31, 0x34, 0x39, 0x33, 0x62, 0x37, 0x32, 0x31, 0x34, 0x62, 0x61, 0x64, 0x38, 0x36, 0x35, 0x30, 0x64, 0x31, 0x65, 0x33, 0x34, 0x31, 0x66, 0x33, 0x39, 0x35, 0x35, 0x36, 0x63, 0x35, 0x36, 0x36, 0x31, 0x65, 0x33, 0x31, 0x34, 0x34, 0x65, 0x30, 0x61, 0x33, 0x34, 0x61, 0x63, 0x36, 0x64, 0x35, 0x37, 0x37, 0x33, 0x39, 0x66, 0x30, 0x37, 0x35, 0x65, 0x64, 0x66, 0x62, 0x31, 0x61, 0x66, 0x30, 0x30, 0x37, 0x32, 0x61, 0x66, 0x36, 0x36, 0x65, 0x37, 0x36, 0x62, 0x62, 0x62, 0x64, 0x33, 0x62, 0x32, 0x66, 0x35, 0x39, 0x31, 0x39, 0x32, 0x64, 0x37, 0x31, 0x37, 0x36, 0x33, 0x36, 0x34, 0x62, 0x65, 0x65, 0x63, 0x31, 0x64, 0x37, 0x30, 0x61, 0x37, 0x39, 0x65, 0x39, 0x37, 0x34, 0x63, 0x31, 0x61, 0x36, 0x65, 0x61, 0x33, 0x34, 0x66, 0x34, 0x38, 0x36, 0x30, 0x61, 0x63, 0x34, 0x30, 0x33, 0x31, 0x31, 0x32, 0x63, 0x31, 0x65, 0x64, 0x36, 0x61, 0x65, 0x61, 0x61, 0x63, 0x39, 0x66, 0x30, 0x35, 0x65, 0x62, 0x66, 0x33, 0x31, 0x33, 0x38, 0x64, 0x33, 0x34, 0x61, 0x65, 0x64, 0x31, 0x30, 0x39, 0x34, 0x65, 0x66, 0x66, 0x30, 0x34, 0x62, 0x35, 0x34, 0x39, 0x61, 0x30, 0x34, 0x38, 0x66, 0x36, 0x32, 0x66, 0x32, 0x66, 0x39, 0x36, 0x37, 0x33, 0x38, 0x36, 0x63, 0x39, 0x62, 0x39, 0x36, 0x66, 0x35, 0x62, 0x65, 0x62, 0x66, 0x39, 0x32, 0x38, 0x32, 0x35, 0x37, 0x37, 0x63, 0x31, 0x31, 0x61, 0x35, 0x35, 0x31, 0x64, 0x61, 0x33, 0x61, 0x34, 0x38, 0x33, 0x33, 0x39, 0x34, 0x33, 0x33, 0x34, 0x30, 0x37, 0x62, 0x62, 0x62, 0x33, 0x66, 0x35, 0x64, 0x66, 0x34, 0x66, 0x34, 0x61, 0x38, 0x61, 0x33, 0x33, 0x32, 0x35, 0x33, 0x66, 0x35, 0x64, 0x33, 0x32, 0x35, 0x63, 0x33, 0x66, 0x30, 0x34, 0x30, 0x31, 0x63, 0x39, 0x30, 0x61, 0x61, 0x62, 0x61, 0x38, 0x63, 0x64, 0x30, 0x65, 0x61, 0x35, 0x66, 0x38, 0x37, 0x33, 0x36, 0x62, 0x61, 0x36, 0x38, 0x30, 0x66, 0x31, 0x64, 0x33, 0x33, 0x63, 0x66, 0x64, 0x64, 0x38, 0x61, 0x32, 0x61, 0x61, 0x33, 0x30, 0x35, 0x61, 0x63, 0x62, 0x38, 0x33, 0x31, 0x65, 0x33, 0x31, 0x35, 0x63, 0x33, 0x36, 0x31, 0x61, 0x38, 0x36, 0x66, 0x62, 0x66, 0x33, 0x37, 0x32, 0x62, 0x34, 0x65, 0x32, 0x62, 0x38, 0x39, 0x39, 0x37, 0x31, 0x36, 0x31, 0x33, 0x66, 0x31, 0x62, 0x63, 0x32, 0x35, 0x30, 0x37, 0x34, 0x65, 0x33, 0x39, 0x62, 0x34, 0x64, 0x31, 0x66, 0x33, 0x61, 0x30, 0x61, 0x62, 0x66, 0x65, 0x32, 0x61, 0x63, 0x62, 0x31, 0x33, 0x33, 0x30, 0x39, 0x66, 0x33, 0x34, 0x35, 0x63, 0x36, 0x61, 0x62, 0x36, 0x38, 0x35, 0x62, 0x37, 0x36, 0x35, 0x33, 0x37, 0x32, 0x31, 0x65, 0x38, 0x33, 0x35, 0x39, 0x64, 0x31, 0x65, 0x32, 0x62, 0x61, 0x66, 0x34, 0x61, 0x65, 0x31, 0x34, 0x38, 0x31, 0x33, 0x62, 0x34, 0x65, 0x33, 0x61, 0x32, 0x32, 0x37, 0x61, 0x35, 0x66, 0x34, 0x61, 0x33, 0x64, 0x65, 0x66, 0x36, 0x66, 0x65, 0x37, 0x63, 0x61, 0x36, 0x35, 0x66, 0x32, 0x61, 0x65, 0x65, 0x66, 0x31, 0x30, 0x61, 0x63, 0x65, 0x61, 0x66, 0x62, 0x64, 0x39, 0x37, 0x32, 0x65, 0x30, 0x30, 0x30, 0x35, 0x61, 0x34, 0x35, 0x31, 0x61, 0x37, 0x63, 0x33, 0x30, 0x35, 0x32, 0x65, 0x30, 0x38, 0x61, 0x30, 0x34, 0x63, 0x36, 0x64, 0x30, 0x35, 0x31, 0x34, 0x66, 0x33, 0x65, 0x37, 0x65, 0x35, 0x34, 0x65, 0x30, 0x36, 0x30, 0x66, 0x66, 0x62, 0x64, 0x39, 0x39, 0x36, 0x34, 0x32, 0x66, 0x65, 0x30, 0x66, 0x64, 0x37, 0x65, 0x37, 0x61, 0x32, 0x35, 0x39, 0x35, 0x37, 0x32, 0x63, 0x32, 0x62, 0x36, 0x66, 0x34, 0x30, 0x35, 0x39, 0x36, 0x31, 0x30, 0x35, 0x63, 0x36, 0x34, 0x66, 0x37, 0x33, 0x35, 0x35, 0x62, 0x31, 0x39, 0x31, 0x33, 0x62, 0x63, 0x33, 0x37, 0x64, 0x38, 0x37, 0x34, 0x35, 0x64, 0x61, 0x66, 0x34, 0x65, 0x36, 0x38, 0x64, 0x34, 0x32, 0x61, 0x61, 0x66, 0x61, 0x38, 0x37, 0x35, 0x66, 0x36, 0x64, 0x30, 0x65, 0x63, 0x63, 0x35, 0x38, 0x38, 0x32, 0x62, 0x61, 0x39, 0x36, 0x35, 0x30, 0x39, 0x39, 0x31, 0x36, 0x32, 0x66, 0x62, 0x34, 0x32, 0x34, 0x33, 0x30, 0x34, 0x62, 0x37, 0x39, 0x34, 0x32, 0x64, 0x61, 0x38, 0x37, 0x30, 0x64, 0x31, 0x33, 0x30, 0x61, 0x34, 0x62, 0x39, 0x37, 0x62, 0x36, 0x63, 0x30, 0x64, 0x63, 0x33, 0x66, 0x63, 0x32, 0x30, 0x62, 0x37, 0x39, 0x32, 0x61, 0x34, 0x39, 0x33, 0x36, 0x38, 0x37, 0x32, 0x63, 0x64, 0x36, 0x62, 0x31, 0x36, 0x31, 0x34, 0x66, 0x33, 0x37, 0x35, 0x65, 0x31, 0x63, 0x32, 0x39, 0x62, 0x31, 0x34, 0x32, 0x39, 0x61, 0x64, 0x32, 0x31, 0x39, 0x33, 0x65, 0x66, 0x35, 0x38, 0x62, 0x34, 0x61, 0x38, 0x35, 0x61, 0x30, 0x35, 0x37, 0x66, 0x34, 0x35, 0x37, 0x38, 0x64, 0x34, 0x61, 0x36, 0x39, 0x35, 0x39, 0x66, 0x32, 0x62, 0x31, 0x34, 0x63, 0x37, 0x34, 0x64, 0x38, 0x66, 0x32, 0x35, 0x33, 0x65, 0x63, 0x37, 0x30, 0x36, 0x35, 0x61, 0x32, 0x66, 0x38, 0x65, 0x32, 0x31, 0x65, 0x66, 0x63, 0x32, 0x66, 0x66, 0x66, 0x63, 0x63, 0x63, 0x38, 0x37, 0x62, 0x30, 0x30, 0x65, 0x61, 0x61, 0x33, 0x38, 0x33, 0x65, 0x34, 0x31, 0x31, 0x66, 0x36, 0x39, 0x30, 0x31, 0x66, 0x61, 0x38, 0x32, 0x37, 0x38, 0x64, 0x62, 0x36, 0x66, 0x61, 0x36, 0x61, 0x30, 0x65, 0x31, 0x61, 0x65, 0x36, 0x61, 0x30, 0x61, 0x33, 0x39, 0x32, 0x65, 0x38, 0x34, 0x30, 0x62, 0x63, 0x63, 0x34, 0x39, 0x33, 0x33, 0x64, 0x63, 0x35, 0x62, 0x36, 0x39, 0x33, 0x32, 0x34, 0x32, 0x65, 0x31, 0x33, 0x30, 0x38, 0x39, 0x39, 0x39, 0x32, 0x64, 0x31, 0x36, 0x63, 0x34, 0x39, 0x34, 0x62, 0x64, 0x65, 0x30, 0x33, 0x36, 0x33, 0x61, 0x39, 0x33, 0x35, 0x66, 0x38, 0x64, 0x61, 0x32, 0x32, 0x62, 0x37, 0x65, 0x65, 0x39, 0x37, 0x32, 0x35, 0x36, 0x31, 0x66, 0x63, 0x35, 0x30, 0x63, 0x66, 0x66, 0x37, 0x64, 0x65, 0x31, 0x61, 0x36, 0x38, 0x33, 0x63, 0x31, 0x63, 0x63, 0x62, 0x61, 0x39, 0x30, 0x64, 0x39, 0x36, 0x66, 0x38, 0x36, 0x61, 0x61, 0x63, 0x37, 0x36, 0x34, 0x36, 0x36, 0x65, 0x30, 0x63, 0x62, 0x30, 0x35, 0x35, 0x38, 0x33, 0x33, 0x31, 0x66, 0x32, 0x32, 0x34, 0x64, 0x39, 0x39, 0x31, 0x34, 0x30, 0x35, 0x37, 0x32, 0x32, 0x35, 0x31, 0x32, 0x66, 0x32, 0x66, 0x66, 0x38, 0x66, 0x39, 0x66, 0x34, 0x36, 0x30, 0x64, 0x65, 0x37, 0x64, 0x65, 0x35, 0x33, 0x61, 0x62, 0x64, 0x31, 0x36, 0x34, 0x65, 0x38, 0x62, 0x64, 0x38, 0x38, 0x36, 0x64, 0x61, 0x35, 0x37, 0x64, 0x35, 0x62, 0x63, 0x36, 0x32, 0x36, 0x33, 0x32, 0x38, 0x61, 0x36, 0x35, 0x61, 0x32, 0x34, 0x62, 0x34, 0x39, 0x32, 0x37, 0x37, 0x61, 0x33, 0x33, 0x30, 0x38, 0x35, 0x61, 0x30, 0x62, 0x65, 0x65, 0x30, 0x39, 0x36, 0x39, 0x35, 0x65, 0x34, 0x61, 0x35, 0x31, 0x33, 0x63, 0x65, 0x38, 0x39, 0x39, 0x64, 0x31, 0x62, 0x66, 0x39, 0x32, 0x36, 0x33, 0x34, 0x64, 0x62, 0x36, 0x64, 0x31, 0x32, 0x61, 0x34, 0x61, 0x31, 0x37, 0x32, 0x33, 0x30, 0x66, 0x66, 0x30, 0x35, 0x36, 0x62, 0x37, 0x61, 0x36, 0x36, 0x66, 0x33, 0x34, 0x31, 0x66, 0x33, 0x63, 0x61, 0x36, 0x38, 0x37, 0x30, 0x65, 0x33, 0x37, 0x34, 0x35, 0x62, 0x34, 0x38, 0x32, 0x30, 0x35, 0x30, 0x37, 0x37, 0x35, 0x33, 0x37, 0x66, 0x36, 0x64, 0x32, 0x34, 0x61, 0x37, 0x35, 0x33, 0x32, 0x38, 0x30, 0x33, 0x36, 0x64, 0x64, 0x30, 0x61, 0x37, 0x38, 0x33, 0x66, 0x32, 0x66, 0x32, 0x37, 0x63, 0x34, 0x30, 0x37, 0x37, 0x64, 0x66, 0x64, 0x64, 0x35, 0x63, 0x33, 0x62, 0x61, 0x32, 0x33, 0x36, 0x37, 0x37, 0x33, 0x63, 0x32, 0x32, 0x31, 0x66, 0x37, 0x61, 0x39, 0x63, 0x61, 0x34, 0x66, 0x66, 0x38, 0x37, 0x37, 0x32, 0x35, 0x36, 0x36, 0x64, 0x66, 0x64, 0x38, 0x37, 0x31, 0x62, 0x61, 0x38, 0x35, 0x36, 0x39, 0x33, 0x37, 0x36, 0x64, 0x31, 0x33, 0x36, 0x65, 0x61, 0x32, 0x34, 0x34, 0x66, 0x65, 0x65, 0x30, 0x63, 0x35, 0x30, 0x63, 0x36, 0x64, 0x30, 0x31, 0x31, 0x34, 0x32, 0x66, 0x64, 0x32, 0x30, 0x36, 0x65, 0x61, 0x33, 0x63, 0x66, 0x64, 0x36, 0x33, 0x65, 0x62, 0x32, 0x62, 0x34, 0x30, 0x36, 0x35, 0x37, 0x65, 0x37, 0x30, 0x32, 0x31, 0x32, 0x32, 0x35, 0x66, 0x38, 0x64, 0x30, 0x32, 0x30, 0x36, 0x39, 0x37, 0x61, 0x61, 0x62, 0x39, 0x35, 0x61, 0x33, 0x63, 0x32, 0x31, 0x37, 0x38, 0x39, 0x63, 0x61, 0x65, 0x64, 0x38, 0x37, 0x37, 0x33, 0x38, 0x61, 0x38, 0x35, 0x65, 0x35, 0x36, 0x30, 0x62, 0x65, 0x37, 0x35, 0x62, 0x66, 0x32, 0x62, 0x66, 0x36, 0x35, 0x61, 0x63, 0x33, 0x64, 0x37, 0x66, 0x33, 0x34, 0x33, 0x32, 0x31, 0x35, 0x62, 0x31, 0x66, 0x30, 0x30, 0x65, 0x63, 0x64, 0x36, 0x65, 0x63, 0x65, 0x38, 0x33, 0x39, 0x64, 0x30, 0x30, 0x39, 0x63, 0x35, 0x61, 0x63, 0x65, 0x31, 0x35, 0x63, 0x61, 0x30, 0x33, 0x33, 0x61, 0x61, 0x62, 0x63, 0x35, 0x37, 0x32, 0x61, 0x65, 0x34, 0x35, 0x63, 0x38, 0x63, 0x32, 0x63, 0x30, 0x31, 0x63, 0x30, 0x33, 0x31, 0x65, 0x37, 0x61, 0x30, 0x66, 0x65, 0x35, 0x65, 0x38, 0x65, 0x38, 0x65, 0x36, 0x32, 0x30, 0x66, 0x37, 0x34, 0x35, 0x63, 0x38, 0x39, 0x38, 0x32, 0x30, 0x37, 0x64, 0x63, 0x35, 0x66, 0x33, 0x30, 0x37, 0x33, 0x30, 0x34, 0x63, 0x61, 0x35, 0x62, 0x39, 0x32, 0x31, 0x34, 0x31, 0x35, 0x30, 0x37, 0x32, 0x35, 0x33, 0x64, 0x33, 0x61, 0x34, 0x63, 0x31, 0x63, 0x36, 0x62, 0x36, 0x32, 0x66, 0x33, 0x62, 0x36, 0x35, 0x31, 0x65, 0x30, 0x61, 0x61, 0x35, 0x63, 0x61, 0x31, 0x64, 0x39, 0x39, 0x32, 0x39, 0x34, 0x62, 0x34, 0x30, 0x65, 0x33, 0x37, 0x37, 0x63, 0x65, 0x36, 0x38, 0x37, 0x61, 0x64, 0x37, 0x63, 0x34, 0x31, 0x36, 0x39, 0x65, 0x32, 0x63, 0x66, 0x64, 0x30, 0x38, 0x34, 0x36, 0x35, 0x38, 0x35, 0x61, 0x31, 0x34, 0x61, 0x62, 0x36, 0x61, 0x34, 0x35, 0x31, 0x37, 0x30, 0x33, 0x32, 0x36, 0x38, 0x66, 0x61, 0x37, 0x39, 0x34, 0x33, 0x32, 0x35, 0x64, 0x30, 0x30, 0x31, 0x65, 0x63, 0x37, 0x38, 0x30, 0x34, 0x61, 0x64, 0x63, 0x39, 0x33, 0x65, 0x66, 0x31, 0x62, 0x65, 0x31, 0x34, 0x34, 0x36, 0x66, 0x35, 0x30, 0x62, 0x63, 0x39, 0x65, 0x61, 0x61, 0x64, 0x37, 0x61, 0x62, 0x37, 0x32, 0x34, 0x31, 0x66, 0x36, 0x35, 0x63, 0x66, 0x36, 0x61, 0x30, 0x34, 0x32, 0x39, 0x33, 0x35, 0x32, 0x32, 0x31, 0x62, 0x36, 0x61, 0x38, 0x32, 0x66, 0x61, 0x37, 0x36, 0x35, 0x30, 0x30, 0x61, 0x37, 0x63, 0x38, 0x32, 0x37, 0x32, 0x39, 0x30, 0x36, 0x34, 0x61, 0x63, 0x32, 0x36, 0x39, 0x65, 0x63, 0x31, 0x35, 0x62, 0x37, 0x36, 0x30, 0x31, 0x34, 0x66, 0x64, 0x35, 0x35, 0x63, 0x37, 0x37, 0x32, 0x31, 0x61, 0x33, 0x66, 0x39, 0x62, 0x34, 0x38, 0x61, 0x63, 0x66, 0x61, 0x62, 0x62, 0x39, 0x62, 0x36, 0x35, 0x65, 0x38, 0x39, 0x61, 0x62, 0x34, 0x64, 0x33, 0x35, 0x38, 0x66, 0x31, 0x33, 0x36, 0x37, 0x64, 0x36, 0x39, 0x62, 0x62, 0x30, 0x35, 0x31, 0x64, 0x62, 0x35, 0x64, 0x34, 0x36, 0x32, 0x33, 0x36, 0x39, 0x35, 0x64, 0x34, 0x34, 0x34, 0x62, 0x65, 0x32, 0x38, 0x33, 0x38, 0x33, 0x37, 0x30, 0x61, 0x30, 0x30, 0x39, 0x33, 0x32, 0x64, 0x39, 0x66, 0x65, 0x38, 0x36, 0x35, 0x33, 0x64, 0x62, 0x31, 0x32, 0x62, 0x62, 0x35, 0x30, 0x61, 0x38, 0x61, 0x35, 0x35, 0x39, 0x37, 0x35, 0x62, 0x64, 0x36, 0x39, 0x64, 0x64, 0x39, 0x61, 0x37, 0x31, 0x34, 0x65, 0x35, 0x39, 0x31, 0x63, 0x66, 0x38, 0x30, 0x34, 0x34, 0x33, 0x32, 0x65, 0x61, 0x38, 0x37, 0x62, 0x30, 0x36, 0x61, 0x32, 0x36, 0x35, 0x64, 0x34, 0x62, 0x66, 0x34, 0x62, 0x33, 0x32, 0x37, 0x32, 0x63, 0x38, 0x34, 0x34, 0x32, 0x63, 0x30, 0x32, 0x38, 0x65, 0x39, 0x63, 0x64, 0x33, 0x38, 0x34, 0x32, 0x35, 0x39, 0x61, 0x37, 0x33, 0x37, 0x37, 0x37, 0x65, 0x63, 0x61, 0x34, 0x62, 0x39, 0x33, 0x37, 0x66, 0x63, 0x37, 0x36, 0x39, 0x34, 0x30, 0x39, 0x64, 0x62, 0x39, 0x32, 0x32, 0x31, 0x36, 0x35, 0x34, 0x62, 0x37, 0x32, 0x39, 0x64, 0x32, 0x30, 0x36, 0x36, 0x33, 0x62, 0x37, 0x35, 0x31, 0x37, 0x36, 0x37, 0x37, 0x63, 0x33, 0x31, 0x34, 0x65, 0x39, 0x30, 0x34, 0x35, 0x65, 0x37, 0x38, 0x65, 0x37, 0x32, 0x66, 0x63, 0x66, 0x36, 0x39, 0x39, 0x38, 0x63, 0x30, 0x38, 0x32, 0x36, 0x37, 0x36, 0x39, 0x32, 0x65, 0x38, 0x30, 0x34, 0x63, 0x65, 0x63, 0x64, 0x31, 0x31, 0x37, 0x61, 0x38, 0x66, 0x31, 0x63, 0x37, 0x32, 0x37, 0x62, 0x62, 0x61, 0x63, 0x63, 0x38, 0x62, 0x39, 0x39, 0x38, 0x38, 0x30, 0x35, 0x32, 0x30, 0x37, 0x30, 0x30, 0x62, 0x30, 0x63, 0x36, 0x37, 0x34, 0x34, 0x62, 0x32, 0x34, 0x34, 0x65, 0x30, 0x63, 0x39, 0x62, 0x32, 0x61, 0x31, 0x63, 0x39, 0x62, 0x38, 0x33, 0x30, 0x30, 0x63, 0x35, 0x39, 0x66, 0x65, 0x61, 0x37, 0x35, 0x37, 0x61, 0x39, 0x66, 0x31, 0x37, 0x38, 0x31, 0x66, 0x35, 0x36, 0x66, 0x66, 0x39, 0x33, 0x65, 0x31, 0x64, 0x31, 0x32, 0x63, 0x39, 0x38, 0x65, 0x34, 0x62, 0x36, 0x34, 0x64, 0x37, 0x36, 0x37, 0x37, 0x66, 0x65, 0x62, 0x65, 0x61, 0x32, 0x34, 0x64, 0x66, 0x34, 0x35, 0x31, 0x37, 0x65, 0x35, 0x62, 0x34, 0x38, 0x63, 0x33, 0x61, 0x30, 0x37, 0x35, 0x34, 0x64, 0x39, 0x37, 0x37, 0x30, 0x63, 0x39, 0x62, 0x62, 0x61, 0x33, 0x66, 0x61, 0x32, 0x39, 0x37, 0x32, 0x35, 0x32, 0x35, 0x37, 0x35, 0x38, 0x38, 0x35, 0x39, 0x62, 0x61, 0x30, 0x38, 0x62, 0x36, 0x35, 0x35, 0x32, 0x64, 0x62, 0x30, 0x33, 0x38, 0x63, 0x37, 0x35, 0x62, 0x66, 0x62, 0x32, 0x65, 0x31, 0x37, 0x30, 0x61, 0x32, 0x34, 0x34, 0x62, 0x39, 0x62, 0x38, 0x38, 0x66, 0x37, 0x33, 0x64, 0x63, 0x66, 0x38, 0x33, 0x64, 0x65, 0x37, 0x36, 0x66, 0x32, 0x65, 0x33, 0x38, 0x64, 0x65, 0x32, 0x30, 0x34, 0x39, 0x39, 0x30, 0x64, 0x36, 0x61, 0x61, 0x33, 0x38, 0x31, 0x63, 0x65, 0x37, 0x64, 0x65, 0x34, 0x33, 0x35, 0x35, 0x31, 0x35, 0x61, 0x37, 0x39, 0x62, 0x66, 0x34, 0x39, 0x35, 0x30, 0x34, 0x36, 0x66, 0x39, 0x32, 0x63, 0x64, 0x62, 0x32, 0x63, 0x66, 0x63, 0x31, 0x63, 0x64, 0x62, 0x34, 0x36, 0x61, 0x61, 0x36, 0x36, 0x65, 0x37, 0x30, 0x32, 0x64, 0x65, 0x65, 0x66, 0x36, 0x35, 0x35, 0x36, 0x35, 0x66, 0x36, 0x64, 0x39, 0x30, 0x30, 0x30, 0x39, 0x39, 0x31, 0x33, 0x37, 0x63, 0x62, 0x39, 0x34, 0x32, 0x38, 0x36, 0x39, 0x64, 0x35, 0x37, 0x37, 0x61, 0x38, 0x34, 0x36, 0x34, 0x32, 0x30, 0x38, 0x37, 0x34, 0x65, 0x64, 0x39, 0x33, 0x31, 0x61, 0x63, 0x30, 0x36, 0x36, 0x66, 0x34, 0x66, 0x38, 0x31, 0x62, 0x64, 0x34, 0x36, 0x32, 0x33, 0x30, 0x63, 0x32, 0x65, 0x36, 0x37, 0x32, 0x39, 0x31, 0x64, 0x38, 0x61, 0x38, 0x36, 0x37, 0x38, 0x39, 0x32, 0x31, 0x39, 0x34, 0x34, 0x37, 0x37, 0x34, 0x61, 0x34, 0x34, 0x30, 0x36, 0x39, 0x63, 0x32, 0x36, 0x32, 0x38, 0x34, 0x35, 0x36, 0x62, 0x36, 0x30, 0x39, 0x31, 0x65, 0x65, 0x33, 0x32, 0x39, 0x32, 0x30, 0x65, 0x63, 0x39, 0x66, 0x62, 0x33, 0x62, 0x66, 0x30, 0x37, 0x30, 0x38, 0x66, 0x31, 0x39, 0x36, 0x37, 0x66, 0x34, 0x33, 0x65, 0x32, 0x63, 0x66, 0x32, 0x63, 0x63, 0x64, 0x30, 0x62, 0x37, 0x35, 0x35, 0x31, 0x34, 0x32, 0x66, 0x66, 0x36, 0x35, 0x39, 0x66, 0x64, 0x37, 0x37, 0x30, 0x35, 0x30, 0x64, 0x34, 0x37, 0x37, 0x62, 0x62, 0x33, 0x62, 0x34, 0x30, 0x36, 0x39, 0x35, 0x32, 0x63, 0x34, 0x36, 0x37, 0x35, 0x35, 0x37, 0x65, 0x39, 0x34, 0x32, 0x61, 0x32, 0x34, 0x33, 0x63, 0x66, 0x36, 0x66, 0x66, 0x37, 0x32, 0x36, 0x62, 0x37, 0x34, 0x66, 0x63, 0x39, 0x33, 0x39, 0x63, 0x39, 0x30, 0x31, 0x62, 0x33, 0x66, 0x39, 0x32, 0x64, 0x31, 0x38, 0x31, 0x39, 0x64, 0x61, 0x37, 0x61, 0x33, 0x39, 0x37, 0x30, 0x62, 0x64, 0x61, 0x39, 0x39, 0x36, 0x62, 0x66, 0x61, 0x62, 0x66, 0x38, 0x33, 0x33, 0x34, 0x37, 0x33, 0x35, 0x38, 0x31, 0x38, 0x36, 0x37, 0x35, 0x37, 0x32, 0x31, 0x66, 0x33, 0x65, 0x66, 0x37, 0x32, 0x63, 0x65, 0x38, 0x33, 0x35, 0x35, 0x35, 0x37, 0x34, 0x33, 0x61, 0x62, 0x39, 0x37, 0x63, 0x35, 0x33, 0x61, 0x62, 0x36, 0x33, 0x32, 0x36, 0x34, 0x64, 0x36, 0x34, 0x65, 0x64, 0x37, 0x32, 0x32, 0x32, 0x37, 0x30, 0x30, 0x37, 0x34, 0x62, 0x61, 0x65, 0x34, 0x33, 0x62, 0x34, 0x30, 0x31, 0x64, 0x30, 0x35, 0x61, 0x34, 0x65, 0x39, 0x62, 0x34, 0x66, 0x66, 0x65, 0x30, 0x39, 0x35, 0x33, 0x35, 0x65, 0x36, 0x62, 0x63, 0x33, 0x30, 0x65, 0x62, 0x62, 0x38, 0x63, 0x33, 0x37, 0x34, 0x39, 0x36, 0x36, 0x66, 0x64, 0x62, 0x36, 0x32, 0x30, 0x31, 0x32, 0x61, 0x32, 0x66, 0x66, 0x37, 0x39, 0x30, 0x37, 0x38, 0x36, 0x35, 0x38, 0x66, 0x61, 0x64, 0x39, 0x30, 0x66, 0x31, 0x65, 0x32, 0x63, 0x62, 0x36, 0x63, 0x33, 0x63, 0x35, 0x36, 0x33, 0x63, 0x33, 0x62, 0x34, 0x32, 0x62, 0x62, 0x37, 0x32, 0x66, 0x63, 0x36, 0x39, 0x30, 0x32, 0x34, 0x65, 0x66, 0x35, 0x34, 0x34, 0x33, 0x39, 0x65, 0x62, 0x63, 0x33, 0x34, 0x36, 0x63, 0x33, 0x39, 0x36, 0x38, 0x34, 0x30, 0x30, 0x32, 0x33, 0x30, 0x35, 0x32, 0x34, 0x39, 0x63, 0x38, 0x63, 0x61, 0x31, 0x33, 0x38, 0x38, 0x34, 0x33, 0x32, 0x66, 0x32, 0x39, 0x39, 0x35, 0x35, 0x62, 0x34, 0x37, 0x39, 0x36, 0x32, 0x36, 0x36, 0x62, 0x66, 0x31, 0x65, 0x34, 0x63, 0x38, 0x39, 0x61, 0x63, 0x32, 0x66, 0x36, 0x34, 0x65, 0x66, 0x30, 0x33, 0x38, 0x37, 0x39, 0x34, 0x31, 0x65, 0x37, 0x34, 0x32, 0x32, 0x32, 0x33, 0x37, 0x37, 0x38, 0x33, 0x66, 0x65, 0x36, 0x38, 0x64, 0x37, 0x38, 0x62, 0x65, 0x39, 0x62, 0x37, 0x34, 0x34, 0x30, 0x36, 0x37, 0x36, 0x66, 0x31, 0x34, 0x36, 0x37, 0x62, 0x35, 0x61, 0x36, 0x66, 0x64, 0x65, 0x31, 0x61, 0x35, 0x39, 0x64, 0x63, 0x64, 0x31, 0x31, 0x62, 0x38, 0x30, 0x32, 0x36, 0x39, 0x35, 0x37, 0x33, 0x39, 0x61, 0x36, 0x35, 0x36, 0x30, 0x33, 0x39, 0x38, 0x36, 0x32, 0x35, 0x38, 0x66, 0x66, 0x34, 0x39, 0x38, 0x30, 0x63, 0x31, 0x34, 0x37, 0x31, 0x31, 0x30, 0x36, 0x32, 0x31, 0x64, 0x61, 0x33, 0x66, 0x32, 0x31, 0x30, 0x64, 0x34, 0x65, 0x64, 0x66, 0x31, 0x36, 0x30, 0x39, 0x62, 0x62, 0x61, 0x37, 0x32, 0x33, 0x34, 0x34, 0x31, 0x39, 0x30, 0x34, 0x62, 0x62, 0x34, 0x37, 0x63, 0x61, 0x37, 0x39, 0x65, 0x32, 0x32, 0x39, 0x31, 0x61, 0x64, 0x37, 0x33, 0x64, 0x30, 0x37, 0x65, 0x62, 0x63, 0x39, 0x34, 0x63, 0x64, 0x64, 0x37, 0x31, 0x64, 0x35, 0x65, 0x66, 0x33, 0x62, 0x30, 0x39, 0x62, 0x34, 0x34, 0x61, 0x62, 0x36, 0x62, 0x62, 0x32, 0x35, 0x30, 0x30, 0x63, 0x33, 0x36, 0x35, 0x61, 0x37, 0x32, 0x38, 0x30, 0x30, 0x36, 0x38, 0x39, 0x34, 0x39, 0x66, 0x37, 0x32, 0x63, 0x61, 0x35, 0x65, 0x39, 0x64, 0x36, 0x39, 0x64, 0x31, 0x64, 0x35, 0x64, 0x35, 0x32, 0x33, 0x65, 0x32, 0x33, 0x65, 0x30, 0x63, 0x61, 0x37, 0x35, 0x38, 0x61, 0x37, 0x37, 0x39, 0x62, 0x37, 0x30, 0x36, 0x32, 0x64, 0x66, 0x62, 0x38, 0x63, 0x65, 0x38, 0x64, 0x32, 0x65, 0x37, 0x39, 0x30, 0x33, 0x62, 0x39, 0x37, 0x32, 0x39, 0x38, 0x36, 0x63, 0x32, 0x66, 0x30, 0x30, 0x38, 0x61, 0x34, 0x37, 0x62, 0x66, 0x33, 0x61, 0x38, 0x38, 0x32, 0x39, 0x36, 0x35, 0x65, 0x63, 0x35, 0x64, 0x38, 0x39, 0x62, 0x63, 0x32, 0x64, 0x66, 0x38, 0x66, 0x35, 0x31, 0x36, 0x33, 0x35, 0x34, 0x34, 0x34, 0x37, 0x35, 0x38, 0x35, 0x37, 0x65, 0x36, 0x37, 0x34, 0x38, 0x32, 0x35, 0x36, 0x30, 0x35, 0x62, 0x31, 0x33, 0x66, 0x37, 0x32, 0x37, 0x34, 0x33, 0x32, 0x61, 0x65, 0x34, 0x37, 0x30, 0x65, 0x63, 0x30, 0x63, 0x34, 0x31, 0x37, 0x33, 0x63, 0x34, 0x66, 0x33, 0x36, 0x63, 0x38, 0x63, 0x33, 0x62, 0x35, 0x63, 0x34, 0x36, 0x38, 0x32, 0x39, 0x38, 0x34, 0x32, 0x65, 0x39, 0x62, 0x61, 0x35, 0x64, 0x38, 0x62, 0x66, 0x36, 0x66, 0x33, 0x34, 0x64, 0x63, 0x34, 0x30, 0x37, 0x33, 0x35, 0x39, 0x66, 0x33, 0x36, 0x33, 0x37, 0x32, 0x31, 0x36, 0x39, 0x34, 0x65, 0x33, 0x33, 0x33, 0x64, 0x33, 0x65, 0x62, 0x39, 0x61, 0x32, 0x34, 0x61, 0x62, 0x32, 0x31, 0x38, 0x36, 0x32, 0x34, 0x62, 0x35, 0x38, 0x32, 0x66, 0x33, 0x34, 0x32, 0x38, 0x39, 0x38, 0x37, 0x30, 0x32, 0x32, 0x64, 0x66, 0x63, 0x65, 0x37, 0x30, 0x61, 0x36, 0x62, 0x34, 0x62, 0x31, 0x36, 0x39, 0x39, 0x31, 0x35, 0x34, 0x36, 0x33, 0x61, 0x30, 0x35, 0x37, 0x32, 0x32, 0x36, 0x37, 0x64, 0x62, 0x34, 0x30, 0x35, 0x39, 0x34, 0x39, 0x36, 0x36, 0x63, 0x39, 0x36, 0x64, 0x34, 0x62, 0x61, 0x31, 0x34, 0x65, 0x62, 0x38, 0x63, 0x37, 0x65, 0x31, 0x38, 0x61, 0x32, 0x34, 0x62, 0x37, 0x38, 0x65, 0x36, 0x62, 0x30, 0x34, 0x64, 0x62, 0x62, 0x36, 0x35, 0x38, 0x37, 0x34, 0x61, 0x34, 0x65, 0x33, 0x31, 0x35, 0x65, 0x30, 0x30, 0x34, 0x37, 0x30, 0x35, 0x37, 0x32, 0x61, 0x35, 0x35, 0x36, 0x66, 0x32, 0x39, 0x31, 0x62, 0x37, 0x65, 0x35, 0x34, 0x39, 0x35, 0x66, 0x39, 0x31, 0x33, 0x30, 0x32, 0x32, 0x32, 0x31, 0x38, 0x35, 0x61, 0x63, 0x39, 0x32, 0x61, 0x66, 0x66, 0x32, 0x35, 0x64, 0x63, 0x36, 0x35, 0x30, 0x39, 0x31, 0x61, 0x37, 0x39, 0x61, 0x65, 0x66, 0x35, 0x33, 0x37, 0x65, 0x39, 0x35, 0x37, 0x37, 0x33, 0x33, 0x63, 0x33, 0x39, 0x61, 0x37, 0x32, 0x36, 0x39, 0x39, 0x31, 0x38, 0x31, 0x66, 0x61, 0x62, 0x34, 0x34, 0x35, 0x32, 0x65, 0x65, 0x34, 0x31, 0x39, 0x61, 0x61, 0x64, 0x66, 0x64, 0x39, 0x62, 0x34, 0x61, 0x39, 0x33, 0x39, 0x39, 0x37, 0x30, 0x64, 0x30, 0x66, 0x35, 0x39, 0x38, 0x35, 0x66, 0x37, 0x65, 0x66, 0x37, 0x63, 0x65, 0x61, 0x36, 0x65, 0x66, 0x63, 0x34, 0x65, 0x63, 0x64, 0x34, 0x32, 0x36, 0x35, 0x66, 0x39, 0x37, 0x32, 0x35, 0x31, 0x32, 0x64, 0x66, 0x38, 0x30, 0x35, 0x31, 0x36, 0x39, 0x38, 0x65, 0x63, 0x63, 0x36, 0x39, 0x33, 0x36, 0x33, 0x62, 0x63, 0x63, 0x31, 0x64, 0x31, 0x61, 0x37, 0x65, 0x37, 0x37, 0x61, 0x39, 0x64, 0x62, 0x36, 0x32, 0x66, 0x36, 0x62, 0x66, 0x33, 0x36, 0x35, 0x64, 0x63, 0x32, 0x36, 0x65, 0x65, 0x34, 0x30, 0x63, 0x63, 0x39, 0x39, 0x64, 0x64, 0x38, 0x30, 0x39, 0x31, 0x37, 0x32, 0x39, 0x38, 0x34, 0x36, 0x38, 0x37, 0x34, 0x31, 0x35, 0x37, 0x61, 0x36, 0x61, 0x61, 0x61, 0x62, 0x61, 0x65, 0x66, 0x63, 0x63, 0x34, 0x33, 0x62, 0x65, 0x65, 0x36, 0x66, 0x66, 0x66, 0x30, 0x39, 0x37, 0x33, 0x34, 0x65, 0x32, 0x34, 0x34, 0x37, 0x39, 0x31, 0x36, 0x35, 0x61, 0x31, 0x64, 0x61, 0x61, 0x65, 0x66, 0x36, 0x30, 0x33, 0x62, 0x64, 0x65, 0x34, 0x63, 0x64, 0x35, 0x35, 0x37, 0x32, 0x66, 0x33, 0x61, 0x31, 0x37, 0x39, 0x31, 0x34, 0x66, 0x33, 0x63, 0x66, 0x63, 0x32, 0x35, 0x33, 0x61, 0x31, 0x34, 0x35, 0x37, 0x31, 0x63, 0x66, 0x32, 0x37, 0x61, 0x38, 0x38, 0x33, 0x38, 0x37, 0x34, 0x64, 0x30, 0x30, 0x31, 0x63, 0x37, 0x30, 0x36, 0x31, 0x31, 0x35, 0x32, 0x35, 0x36, 0x33, 0x31, 0x61, 0x64, 0x66, 0x30, 0x61, 0x66, 0x64, 0x64, 0x63, 0x38, 0x31, 0x33, 0x36, 0x33, 0x65, 0x32, 0x32, 0x39, 0x32, 0x31, 0x36, 0x61, 0x36, 0x38, 0x35, 0x65, 0x62, 0x39, 0x33, 0x36, 0x63, 0x31, 0x38, 0x32, 0x64, 0x64, 0x34, 0x62, 0x32, 0x30, 0x63, 0x61, 0x32, 0x66, 0x33, 0x36, 0x31, 0x64, 0x31, 0x32, 0x61, 0x34, 0x36, 0x36, 0x31, 0x36, 0x33, 0x35, 0x64, 0x31, 0x33, 0x30, 0x35, 0x61, 0x35, 0x35, 0x65, 0x38, 0x34, 0x30, 0x38, 0x37, 0x37, 0x66, 0x63, 0x64, 0x31, 0x35, 0x38, 0x62, 0x64, 0x37, 0x62, 0x32, 0x62, 0x36, 0x62, 0x66, 0x37, 0x38, 0x36, 0x32, 0x36, 0x66, 0x65, 0x39, 0x62, 0x33, 0x64, 0x65, 0x61, 0x34, 0x32, 0x62, 0x61, 0x34, 0x36, 0x34, 0x66, 0x61, 0x38, 0x66, 0x34, 0x61, 0x34, 0x33, 0x37, 0x31, 0x35, 0x63, 0x35, 0x31, 0x32, 0x61, 0x32, 0x65, 0x33, 0x39, 0x66, 0x37, 0x32, 0x64, 0x63, 0x64, 0x36, 0x39, 0x63, 0x31, 0x66, 0x35, 0x63, 0x37, 0x32, 0x30, 0x30, 0x66, 0x32, 0x62, 0x62, 0x65, 0x36, 0x37, 0x39, 0x32, 0x38, 0x64, 0x64, 0x33, 0x39, 0x33, 0x32, 0x62, 0x64, 0x66, 0x65, 0x61, 0x64, 0x61, 0x33, 0x35, 0x66, 0x64, 0x37, 0x62, 0x62, 0x62, 0x38, 0x30, 0x66, 0x65, 0x34, 0x31, 0x66, 0x63, 0x62, 0x61, 0x39, 0x62, 0x30, 0x37, 0x34, 0x33, 0x38, 0x33, 0x64, 0x34, 0x63, 0x30, 0x39, 0x38, 0x39, 0x63, 0x39, 0x37, 0x63, 0x37, 0x32, 0x63, 0x32, 0x61, 0x37, 0x65, 0x35, 0x64, 0x33, 0x37, 0x38, 0x30, 0x35, 0x62, 0x61, 0x39, 0x63, 0x33, 0x32, 0x36, 0x66, 0x64, 0x37, 0x61, 0x30, 0x33, 0x33, 0x65, 0x37, 0x34, 0x34, 0x31, 0x30, 0x30, 0x63, 0x39, 0x39, 0x30, 0x35, 0x62, 0x33, 0x36, 0x34, 0x66, 0x66, 0x38, 0x61, 0x38, 0x36, 0x66, 0x31, 0x65, 0x61, 0x31, 0x66, 0x37, 0x65, 0x37, 0x63, 0x34, 0x32, 0x66, 0x37, 0x37, 0x32, 0x62, 0x32, 0x66, 0x61, 0x35, 0x61, 0x31, 0x31, 0x30, 0x32, 0x33, 0x35, 0x39, 0x64, 0x65, 0x33, 0x32, 0x64, 0x62, 0x32, 0x30, 0x33, 0x31, 0x66, 0x39, 0x31, 0x34, 0x38, 0x63, 0x63, 0x37, 0x66, 0x63, 0x33, 0x32, 0x66, 0x64, 0x31, 0x39, 0x61, 0x64, 0x61, 0x30, 0x30, 0x34, 0x62, 0x66, 0x30, 0x31, 0x31, 0x36, 0x63, 0x36, 0x36, 0x35, 0x65, 0x33, 0x61, 0x62, 0x31, 0x31, 0x31, 0x35, 0x64, 0x31, 0x61, 0x36, 0x35, 0x30, 0x36, 0x33, 0x64, 0x66, 0x33, 0x39, 0x36, 0x62, 0x31, 0x64, 0x37, 0x37, 0x65, 0x32, 0x31, 0x62, 0x36, 0x65, 0x37, 0x32, 0x31, 0x62, 0x66, 0x65, 0x34, 0x63, 0x36, 0x65, 0x65, 0x39, 0x36, 0x37, 0x39, 0x61, 0x36, 0x31, 0x62, 0x35, 0x32, 0x32, 0x63, 0x38, 0x30, 0x64, 0x36, 0x37, 0x39, 0x35, 0x35, 0x64, 0x61, 0x64, 0x65, 0x34, 0x62, 0x64, 0x37, 0x37, 0x32, 0x35, 0x62, 0x64, 0x63, 0x65, 0x36, 0x39, 0x62, 0x38, 0x64, 0x32, 0x34, 0x37, 0x35, 0x38, 0x62, 0x33, 0x61, 0x39, 0x62, 0x34, 0x63, 0x39, 0x32, 0x30, 0x31, 0x64, 0x61, 0x64, 0x31, 0x39, 0x36, 0x62, 0x35, 0x37, 0x32, 0x39, 0x36, 0x61, 0x62, 0x62, 0x32, 0x39, 0x63, 0x66, 0x61, 0x61, 0x66, 0x33, 0x34, 0x34, 0x38, 0x35, 0x66, 0x61, 0x31, 0x63, 0x31, 0x32, 0x62, 0x37, 0x39, 0x36, 0x39, 0x38, 0x35, 0x30, 0x38, 0x31, 0x33, 0x65, 0x61, 0x31, 0x39, 0x64, 0x31, 0x34, 0x61, 0x65, 0x31, 0x63, 0x63, 0x61, 0x36, 0x66, 0x38, 0x39, 0x34, 0x63, 0x38, 0x33, 0x38, 0x64, 0x33, 0x30, 0x33, 0x38, 0x36, 0x38, 0x30, 0x66, 0x66, 0x37, 0x38, 0x66, 0x32, 0x39, 0x38, 0x36, 0x62, 0x36, 0x62, 0x31, 0x37, 0x32, 0x30, 0x36, 0x66, 0x33, 0x39, 0x61, 0x35, 0x35, 0x32, 0x64, 0x31, 0x37, 0x32, 0x39, 0x32, 0x63, 0x34, 0x30, 0x62, 0x61, 0x38, 0x37, 0x39, 0x65, 0x35, 0x31, 0x31, 0x64, 0x62, 0x65, 0x34, 0x36, 0x36, 0x62, 0x34, 0x39, 0x32, 0x30, 0x30, 0x38, 0x33, 0x62, 0x35, 0x64, 0x64, 0x33, 0x65, 0x63, 0x65, 0x65, 0x39, 0x36, 0x37, 0x38, 0x37, 0x38, 0x62, 0x65, 0x39, 0x33, 0x30, 0x38, 0x37, 0x31, 0x31, 0x33, 0x39, 0x39, 0x33, 0x37, 0x36, 0x36, 0x33, 0x66, 0x36, 0x31, 0x61, 0x36, 0x65, 0x34, 0x64, 0x39, 0x38, 0x33, 0x31, 0x66, 0x65, 0x62, 0x30, 0x35, 0x36, 0x35, 0x36, 0x39, 0x32, 0x66, 0x63, 0x39, 0x64, 0x64, 0x38, 0x62, 0x35, 0x61, 0x62, 0x61, 0x66, 0x33, 0x64, 0x62, 0x32, 0x30, 0x64, 0x36, 0x62, 0x66, 0x30, 0x38, 0x37, 0x63, 0x38, 0x64, 0x64, 0x38, 0x65, 0x35, 0x38, 0x62, 0x30, 0x35, 0x34, 0x30, 0x39, 0x34, 0x63, 0x31, 0x33, 0x37, 0x61, 0x30, 0x30, 0x34, 0x66, 0x66, 0x64, 0x62, 0x65, 0x66, 0x32, 0x31, 0x38, 0x39, 0x34, 0x37, 0x63, 0x63, 0x63, 0x65, 0x35, 0x61, 0x63, 0x31, 0x30, 0x36, 0x38, 0x31, 0x30, 0x61, 0x35, 0x30, 0x30, 0x38, 0x64, 0x37, 0x36, 0x32, 0x38, 0x34, 0x62, 0x35, 0x39, 0x64, 0x64, 0x37, 0x32, 0x39, 0x65, 0x37, 0x34, 0x36, 0x30, 0x65, 0x37, 0x35, 0x39, 0x62, 0x31, 0x39, 0x36, 0x33, 0x37, 0x32, 0x33, 0x37, 0x32, 0x32, 0x66, 0x66, 0x31, 0x62, 0x34, 0x37, 0x65, 0x32, 0x38, 0x38, 0x64, 0x39, 0x63, 0x36, 0x37, 0x35, 0x33, 0x31, 0x65, 0x35, 0x65, 0x39, 0x64, 0x39, 0x63, 0x65, 0x30, 0x65, 0x64, 0x61, 0x39, 0x38, 0x32, 0x30, 0x62, 0x36, 0x31, 0x32, 0x32, 0x66, 0x62, 0x30, 0x39, 0x39, 0x34, 0x38, 0x38, 0x32, 0x36, 0x34, 0x31, 0x30, 0x63, 0x66, 0x61, 0x30, 0x64, 0x32, 0x32, 0x65, 0x33, 0x37, 0x32, 0x39, 0x62, 0x37, 0x30, 0x30, 0x62, 0x34, 0x64, 0x62, 0x33, 0x66, 0x36, 0x64, 0x61, 0x33, 0x63, 0x39, 0x39, 0x34, 0x64, 0x65, 0x35, 0x37, 0x33, 0x33, 0x31, 0x35, 0x61, 0x34, 0x35, 0x66, 0x30, 0x32, 0x38, 0x35, 0x65, 0x63, 0x66, 0x65, 0x31, 0x36, 0x34, 0x64, 0x38, 0x34, 0x34, 0x32, 0x38, 0x32, 0x31, 0x61, 0x62, 0x64, 0x33, 0x63, 0x61, 0x31, 0x32, 0x34, 0x37, 0x31, 0x64, 0x37, 0x32, 0x63, 0x61, 0x33, 0x65, 0x38, 0x30, 0x35, 0x38, 0x33, 0x33, 0x33, 0x66, 0x62, 0x37, 0x30, 0x62, 0x65, 0x32, 0x39, 0x34, 0x38, 0x66, 0x61, 0x65, 0x39, 0x62, 0x65, 0x66, 0x62, 0x63, 0x63, 0x63, 0x61, 0x62, 0x34, 0x61, 0x64, 0x33, 0x65, 0x32, 0x66, 0x62, 0x33, 0x62, 0x39, 0x39, 0x66, 0x63, 0x38, 0x33, 0x32, 0x61, 0x61, 0x62, 0x63, 0x65, 0x39, 0x61, 0x36, 0x37, 0x65, 0x66, 0x37, 0x32, 0x65, 0x61, 0x38, 0x39, 0x32, 0x38, 0x37, 0x33, 0x61, 0x36, 0x37, 0x35, 0x37, 0x66, 0x65, 0x33, 0x37, 0x65, 0x37, 0x34, 0x65, 0x36, 0x34, 0x66, 0x39, 0x31, 0x65, 0x34, 0x63, 0x30, 0x66, 0x31, 0x31, 0x37, 0x32, 0x31, 0x66, 0x38, 0x62, 0x32, 0x39, 0x35, 0x66, 0x35, 0x65, 0x65, 0x30, 0x62, 0x34, 0x34, 0x65, 0x66, 0x30, 0x62, 0x34, 0x37, 0x62, 0x65, 0x65, 0x36, 0x36, 0x31, 0x34, 0x31, 0x35, 0x33, 0x61, 0x64, 0x33, 0x39, 0x63, 0x39, 0x64, 0x33, 0x38, 0x61, 0x31, 0x64, 0x66, 0x32, 0x61, 0x66, 0x32, 0x66, 0x62, 0x35, 0x31, 0x62, 0x37, 0x38, 0x33, 0x37, 0x37, 0x35, 0x37, 0x65, 0x61, 0x64, 0x37, 0x62, 0x62, 0x32, 0x62, 0x39, 0x64, 0x64, 0x66, 0x39, 0x35, 0x39, 0x66, 0x63, 0x38, 0x66, 0x62, 0x61, 0x36, 0x65, 0x30, 0x37, 0x66, 0x38, 0x61, 0x30, 0x62, 0x66, 0x37, 0x32, 0x34, 0x61, 0x35, 0x32, 0x65, 0x33, 0x63, 0x63, 0x36, 0x66, 0x34, 0x33, 0x36, 0x36, 0x36, 0x35, 0x32, 0x66, 0x30, 0x65, 0x63, 0x31, 0x63, 0x33, 0x37, 0x35, 0x33, 0x31, 0x30, 0x38, 0x61, 0x65, 0x36, 0x61, 0x63, 0x66, 0x39, 0x63, 0x37, 0x66, 0x65, 0x63, 0x64, 0x62, 0x34, 0x34, 0x31, 0x65, 0x33, 0x62, 0x30, 0x31, 0x65, 0x61, 0x33, 0x37, 0x36, 0x65, 0x64, 0x32, 0x64, 0x63, 0x36, 0x62, 0x62, 0x37, 0x30, 0x37, 0x66, 0x38, 0x35, 0x65, 0x61, 0x30, 0x34, 0x39, 0x38, 0x36, 0x66, 0x63, 0x39, 0x30, 0x64, 0x65, 0x61, 0x34, 0x64, 0x35, 0x37, 0x64, 0x33, 0x64, 0x61, 0x31, 0x64, 0x37, 0x64, 0x31, 0x35, 0x39, 0x34, 0x33, 0x39, 0x63, 0x34, 0x33, 0x64, 0x62, 0x63, 0x65, 0x65, 0x33, 0x38, 0x33, 0x63, 0x36, 0x64, 0x39, 0x39, 0x32, 0x30, 0x36, 0x63, 0x35, 0x37, 0x32, 0x35, 0x65, 0x35, 0x34, 0x31, 0x35, 0x64, 0x35, 0x34, 0x38, 0x33, 0x33, 0x32, 0x32, 0x32, 0x36, 0x34, 0x37, 0x32, 0x37, 0x34, 0x31, 0x30, 0x35, 0x36, 0x64, 0x62, 0x61, 0x37, 0x36, 0x39, 0x61, 0x38, 0x36, 0x35, 0x65, 0x62, 0x39, 0x35, 0x38, 0x32, 0x32, 0x61, 0x32, 0x34, 0x63, 0x37, 0x39, 0x65, 0x33, 0x36, 0x66, 0x33, 0x33, 0x65, 0x39, 0x32, 0x34, 0x34, 0x30, 0x36, 0x62, 0x39, 0x36, 0x37, 0x32, 0x30, 0x65, 0x32, 0x62, 0x34, 0x36, 0x39, 0x65, 0x62, 0x35, 0x35, 0x36, 0x66, 0x32, 0x38, 0x36, 0x32, 0x39, 0x62, 0x30, 0x66, 0x30, 0x33, 0x63, 0x37, 0x65, 0x65, 0x61, 0x35, 0x65, 0x30, 0x33, 0x32, 0x39, 0x36, 0x31, 0x35, 0x39, 0x65, 0x36, 0x66, 0x30, 0x37, 0x33, 0x30, 0x62, 0x65, 0x31, 0x62, 0x66, 0x35, 0x33, 0x34, 0x34, 0x34, 0x38, 0x65, 0x37, 0x31, 0x65, 0x36, 0x64, 0x37, 0x32, 0x63, 0x65, 0x30, 0x36, 0x61, 0x36, 0x66, 0x30, 0x66, 0x33, 0x30, 0x62, 0x32, 0x37, 0x39, 0x33, 0x31, 0x38, 0x61, 0x33, 0x65, 0x64, 0x63, 0x38, 0x30, 0x65, 0x35, 0x39, 0x34, 0x37, 0x31, 0x33, 0x66, 0x65, 0x62, 0x35, 0x30, 0x34, 0x31, 0x32, 0x37, 0x39, 0x32, 0x30, 0x65, 0x66, 0x39, 0x64, 0x65, 0x36, 0x34, 0x31, 0x32, 0x37, 0x61, 0x38, 0x61, 0x32, 0x36, 0x32, 0x33, 0x32, 0x37, 0x31, 0x62, 0x30, 0x62, 0x33, 0x66, 0x34, 0x62, 0x31, 0x63, 0x66, 0x32, 0x30, 0x61, 0x37, 0x39, 0x65, 0x36, 0x32, 0x30, 0x66, 0x64, 0x38, 0x32, 0x64, 0x61, 0x37, 0x31, 0x36, 0x66, 0x34, 0x64, 0x65, 0x36, 0x62, 0x65, 0x34, 0x36, 0x66, 0x37, 0x36, 0x61, 0x34, 0x64, 0x64, 0x35, 0x39, 0x32, 0x62, 0x31, 0x38, 0x62, 0x64, 0x65, 0x38, 0x36, 0x33, 0x31, 0x34, 0x32, 0x38, 0x66, 0x35, 0x37, 0x32, 0x64, 0x30, 0x61, 0x35, 0x39, 0x38, 0x62, 0x33, 0x65, 0x31, 0x36, 0x38, 0x32, 0x30, 0x38, 0x61, 0x64, 0x62, 0x39, 0x34, 0x62, 0x66, 0x35, 0x31, 0x35, 0x39, 0x33, 0x63, 0x39, 0x39, 0x30, 0x32, 0x64, 0x34, 0x33, 0x63, 0x62, 0x62, 0x66, 0x35, 0x66, 0x31, 0x37, 0x39, 0x66, 0x30, 0x64, 0x30, 0x62, 0x33, 0x64, 0x66, 0x64, 0x62, 0x65, 0x32, 0x32, 0x30, 0x38, 0x30, 0x37, 0x62, 0x30, 0x38, 0x32, 0x31, 0x34, 0x31, 0x39, 0x30, 0x32, 0x62, 0x32, 0x63, 0x33, 0x39, 0x39, 0x62, 0x39, 0x35, 0x31, 0x37, 0x32, 0x62, 0x62, 0x63, 0x63, 0x62, 0x36, 0x65, 0x63, 0x66, 0x64, 0x65, 0x35, 0x61, 0x38, 0x36, 0x65, 0x30, 0x31, 0x65, 0x36, 0x66, 0x31, 0x65, 0x65, 0x64, 0x32, 0x37, 0x32, 0x63, 0x37, 0x35, 0x62, 0x36, 0x37, 0x35, 0x66, 0x38, 0x31, 0x30, 0x62, 0x38, 0x38, 0x62, 0x37, 0x32, 0x66, 0x35, 0x36, 0x66, 0x34, 0x64, 0x61, 0x64, 0x64, 0x38, 0x64, 0x39, 0x30, 0x30, 0x66, 0x62, 0x63, 0x33, 0x32, 0x32, 0x66, 0x36, 0x30, 0x33, 0x61, 0x63, 0x31, 0x65, 0x64, 0x35, 0x32, 0x63, 0x63, 0x62, 0x38, 0x32, 0x34, 0x61, 0x65, 0x39, 0x36, 0x33, 0x33, 0x38, 0x63, 0x61, 0x64, 0x65, 0x66, 0x34, 0x61, 0x36, 0x63, 0x66, 0x39, 0x38, 0x30, 0x62, 0x62, 0x63, 0x62, 0x63, 0x30, 0x35, 0x39, 0x36, 0x37, 0x35, 0x61, 0x65, 0x31, 0x66, 0x31, 0x65, 0x63, 0x33, 0x61, 0x38, 0x36, 0x39, 0x30, 0x38, 0x31, 0x62, 0x34, 0x64, 0x30, 0x64, 0x32, 0x31, 0x64, 0x65, 0x66, 0x39, 0x63, 0x64, 0x31, 0x62, 0x30, 0x66, 0x37, 0x64, 0x32, 0x32, 0x66, 0x39, 0x30, 0x31, 0x61, 0x31, 0x62, 0x64, 0x34, 0x66, 0x61, 0x62, 0x63, 0x38, 0x35, 0x61, 0x37, 0x30, 0x62, 0x39, 0x34, 0x62, 0x37, 0x32, 0x32, 0x39, 0x63, 0x63, 0x64, 0x31, 0x37, 0x66, 0x62, 0x66, 0x38, 0x34, 0x66, 0x38, 0x35, 0x38, 0x63, 0x36, 0x39, 0x33, 0x37, 0x39, 0x63, 0x32, 0x37, 0x30, 0x64, 0x66, 0x37, 0x64, 0x64, 0x34, 0x65, 0x62, 0x63, 0x34, 0x39, 0x65, 0x32, 0x39, 0x39, 0x30, 0x39, 0x62, 0x61, 0x62, 0x39, 0x37, 0x65, 0x62, 0x62, 0x65, 0x35, 0x32, 0x64, 0x34, 0x32, 0x61, 0x30, 0x64, 0x32, 0x66, 0x30, 0x37, 0x30, 0x33, 0x31, 0x39, 0x63, 0x39, 0x32, 0x35, 0x33, 0x30, 0x66, 0x33, 0x32, 0x36, 0x35, 0x34, 0x35, 0x38, 0x63, 0x65, 0x33, 0x39, 0x39, 0x61, 0x62, 0x65, 0x65, 0x63, 0x35, 0x65, 0x31, 0x39, 0x34, 0x31, 0x38, 0x33, 0x34, 0x66, 0x34, 0x33, 0x38, 0x36, 0x37, 0x38, 0x34, 0x38, 0x38, 0x37, 0x62, 0x65, 0x32, 0x62, 0x33, 0x35, 0x30, 0x35, 0x35, 0x62, 0x39, 0x34, 0x39, 0x64, 0x37, 0x32, 0x30, 0x38, 0x61, 0x32, 0x38, 0x37, 0x31, 0x65, 0x63, 0x30, 0x66, 0x33, 0x31, 0x31, 0x37, 0x37, 0x62, 0x63, 0x34, 0x63, 0x32, 0x35, 0x35, 0x64, 0x32, 0x35, 0x62, 0x31, 0x61, 0x32, 0x33, 0x30, 0x33, 0x64, 0x30, 0x31, 0x30, 0x35, 0x35, 0x66, 0x38, 0x37, 0x38, 0x35, 0x66, 0x63, 0x65, 0x61, 0x31, 0x32, 0x30, 0x39, 0x61, 0x33, 0x30, 0x34, 0x36, 0x61, 0x66, 0x35, 0x63, 0x35, 0x37, 0x32, 0x35, 0x66, 0x63, 0x66, 0x32, 0x65, 0x36, 0x34, 0x36, 0x32, 0x64, 0x61, 0x37, 0x63, 0x64, 0x66, 0x38, 0x33, 0x34, 0x32, 0x37, 0x62, 0x62, 0x34, 0x35, 0x65, 0x61, 0x39, 0x39, 0x34, 0x65, 0x63, 0x35, 0x35, 0x62, 0x35, 0x33, 0x61, 0x64, 0x30, 0x32, 0x34, 0x37, 0x32, 0x33, 0x38, 0x37, 0x61, 0x39, 0x39, 0x62, 0x63, 0x38, 0x35, 0x30, 0x30, 0x62, 0x35, 0x31, 0x62, 0x37, 0x32, 0x37, 0x32, 0x35, 0x66, 0x38, 0x35, 0x37, 0x36, 0x33, 0x37, 0x33, 0x66, 0x39, 0x32, 0x61, 0x61, 0x38, 0x31, 0x34, 0x37, 0x32, 0x66, 0x39, 0x31, 0x35, 0x62, 0x61, 0x38, 0x39, 0x64, 0x37, 0x35, 0x33, 0x31, 0x62, 0x32, 0x30, 0x32, 0x38, 0x38, 0x39, 0x62, 0x62, 0x61, 0x62, 0x35, 0x37, 0x62, 0x62, 0x63, 0x36, 0x35, 0x35, 0x65, 0x33, 0x61, 0x64, 0x39, 0x63, 0x30, 0x33, 0x35, 0x30, 0x65, 0x33, 0x61, 0x30, 0x37, 0x35, 0x64, 0x65, 0x31, 0x34, 0x63, 0x37, 0x64, 0x36, 0x62, 0x36, 0x37, 0x31, 0x30, 0x32, 0x34, 0x37, 0x32, 0x33, 0x61, 0x31, 0x31, 0x35, 0x39, 0x63, 0x65, 0x35, 0x63, 0x39, 0x36, 0x32, 0x62, 0x66, 0x64, 0x66, 0x66, 0x66, 0x65, 0x63, 0x35, 0x38, 0x31, 0x33, 0x36, 0x61, 0x36, 0x38, 0x61, 0x30, 0x37, 0x30, 0x39, 0x38, 0x35, 0x66, 0x38, 0x37, 0x64, 0x63, 0x32, 0x30, 0x39, 0x62, 0x34, 0x37, 0x35, 0x35, 0x66, 0x64, 0x66, 0x65, 0x66, 0x30, 0x36, 0x64, 0x37, 0x36, 0x35, 0x34, 0x36, 0x36, 0x38, 0x36, 0x64, 0x37, 0x62, 0x38, 0x39, 0x64, 0x38, 0x35, 0x63, 0x35, 0x66, 0x65, 0x31, 0x39, 0x33, 0x36, 0x63, 0x35, 0x37, 0x65, 0x35, 0x34, 0x62, 0x64, 0x64, 0x32, 0x37, 0x32, 0x66, 0x37, 0x61, 0x34, 0x32, 0x39, 0x38, 0x31, 0x65, 0x38, 0x30, 0x32, 0x65, 0x37, 0x32, 0x37, 0x33, 0x36, 0x38, 0x66, 0x65, 0x62, 0x34, 0x31, 0x30, 0x35, 0x31, 0x65, 0x34, 0x38, 0x37, 0x39, 0x30, 0x65, 0x30, 0x66, 0x33, 0x64, 0x61, 0x35, 0x35, 0x30, 0x30, 0x61, 0x34, 0x31, 0x33, 0x38, 0x33, 0x39, 0x32, 0x63, 0x35, 0x61, 0x63, 0x64, 0x32, 0x66, 0x63, 0x30, 0x65, 0x63, 0x33, 0x63, 0x37, 0x33, 0x62, 0x66, 0x61, 0x61, 0x36, 0x66, 0x36, 0x66, 0x32, 0x39, 0x32, 0x37, 0x32, 0x33, 0x30, 0x61, 0x63, 0x34, 0x38, 0x65, 0x37, 0x66, 0x33, 0x64, 0x38, 0x37, 0x37, 0x33, 0x63, 0x61, 0x33, 0x33, 0x38, 0x62, 0x66, 0x38, 0x61, 0x39, 0x63, 0x30, 0x64, 0x39, 0x39, 0x37, 0x62, 0x31, 0x30, 0x37, 0x31, 0x61, 0x33, 0x65, 0x62, 0x61, 0x32, 0x33, 0x64, 0x35, 0x62, 0x62, 0x30, 0x39, 0x32, 0x66, 0x63, 0x38, 0x66, 0x61, 0x32, 0x33, 0x36, 0x38, 0x64, 0x33, 0x32, 0x37, 0x32, 0x65, 0x31, 0x62, 0x65, 0x30, 0x65, 0x38, 0x38, 0x36, 0x64, 0x31, 0x62, 0x33, 0x63, 0x39, 0x35, 0x65, 0x63, 0x61, 0x65, 0x62, 0x34, 0x34, 0x62, 0x62, 0x31, 0x61, 0x36, 0x61, 0x66, 0x65, 0x39, 0x34, 0x36, 0x34, 0x61, 0x38, 0x30, 0x35, 0x63, 0x30, 0x64, 0x63, 0x38, 0x61, 0x63, 0x30, 0x61, 0x35, 0x66, 0x61, 0x31, 0x37, 0x30, 0x66, 0x30, 0x39, 0x64, 0x66, 0x61, 0x32, 0x31, 0x35, 0x34, 0x62, 0x38, 0x30, 0x62, 0x30, 0x37, 0x30, 0x39, 0x33, 0x30, 0x31, 0x36, 0x63, 0x65, 0x34, 0x30, 0x37, 0x38, 0x35, 0x30, 0x39, 0x32, 0x61, 0x33, 0x36, 0x65, 0x65, 0x36, 0x65, 0x65, 0x37, 0x34, 0x38, 0x36, 0x32, 0x63, 0x32, 0x32, 0x37, 0x66, 0x61, 0x66, 0x33, 0x66, 0x38, 0x35, 0x66, 0x30, 0x66, 0x62, 0x63, 0x61, 0x34, 0x63, 0x61, 0x64, 0x37, 0x34, 0x31, 0x34, 0x62, 0x61, 0x30, 0x34, 0x66, 0x30, 0x33, 0x63, 0x31, 0x36, 0x62, 0x36, 0x33, 0x32, 0x35, 0x62, 0x34, 0x38, 0x34, 0x32, 0x65, 0x33, 0x30, 0x38, 0x63, 0x35, 0x62, 0x31, 0x62, 0x31, 0x38, 0x38, 0x35, 0x32, 0x66, 0x65, 0x38, 0x39, 0x36, 0x34, 0x38, 0x30, 0x34, 0x37, 0x35, 0x38, 0x61, 0x39, 0x34, 0x35, 0x64, 0x61, 0x66, 0x37, 0x63, 0x37, 0x65, 0x38, 0x35, 0x34, 0x35, 0x61, 0x65, 0x32, 0x39, 0x63, 0x37, 0x32, 0x64, 0x31, 0x62, 0x36, 0x64, 0x30, 0x31, 0x35, 0x62, 0x38, 0x65, 0x66, 0x33, 0x38, 0x64, 0x39, 0x62, 0x64, 0x38, 0x38, 0x66, 0x61, 0x34, 0x33, 0x37, 0x32, 0x35, 0x65, 0x31, 0x39, 0x66, 0x30, 0x36, 0x39, 0x36, 0x30, 0x65, 0x32, 0x37, 0x61, 0x31, 0x38, 0x35, 0x33, 0x31, 0x61, 0x64, 0x30, 0x32, 0x38, 0x61, 0x36, 0x33, 0x62, 0x38, 0x39, 0x36, 0x65, 0x62, 0x62, 0x64, 0x61, 0x32, 0x30, 0x66, 0x63, 0x39, 0x61, 0x30, 0x36, 0x61, 0x33, 0x61, 0x61, 0x34, 0x33, 0x61, 0x30, 0x61, 0x63, 0x32, 0x62, 0x30, 0x31, 0x38, 0x65, 0x37, 0x33, 0x39, 0x35, 0x65, 0x35, 0x36, 0x30, 0x38, 0x62, 0x38, 0x38, 0x63, 0x66, 0x65, 0x33, 0x35, 0x37, 0x66, 0x63, 0x61, 0x37, 0x34, 0x36, 0x38, 0x33, 0x38, 0x35, 0x31, 0x33, 0x31, 0x32, 0x30, 0x61, 0x64, 0x63, 0x30, 0x33, 0x64, 0x32, 0x36, 0x33, 0x62, 0x64, 0x37, 0x64, 0x63, 0x65, 0x66, 0x39, 0x34, 0x31, 0x62, 0x33, 0x66, 0x64, 0x38, 0x61, 0x61, 0x37, 0x66, 0x37, 0x35, 0x37, 0x61, 0x61, 0x37, 0x39, 0x39, 0x63, 0x35, 0x35, 0x61, 0x64, 0x35, 0x66, 0x64, 0x33, 0x31, 0x63, 0x31, 0x63, 0x33, 0x64, 0x39, 0x37, 0x35, 0x31, 0x36, 0x66, 0x62, 0x65, 0x65, 0x30, 0x64, 0x64, 0x66, 0x39, 0x63, 0x64, 0x30, 0x33, 0x34, 0x35, 0x31, 0x31, 0x36, 0x32, 0x37, 0x34, 0x34, 0x62, 0x64, 0x31, 0x38, 0x62, 0x36, 0x66, 0x31, 0x35, 0x35, 0x63, 0x39, 0x31, 0x32, 0x38, 0x36, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x33, 0x61, 0x66, 0x39, 0x36, 0x36, 0x30, 0x30, 0x64, 0x30, 0x36, 0x32, 0x30, 0x63, 0x63, 0x64, 0x39, 0x35, 0x31, 0x64, 0x39, 0x65, 0x62, 0x31, 0x30, 0x36, 0x33, 0x32, 0x64, 0x38, 0x32, 0x31, 0x65, 0x61, 0x61, 0x37, 0x32, 0x66, 0x34, 0x39, 0x61, 0x36, 0x38, 0x61, 0x38, 0x37, 0x38, 0x66, 0x33, 0x63, 0x39, 0x34, 0x39, 0x39, 0x37, 0x36, 0x62, 0x30, 0x30, 0x64, 0x65, 0x61, 0x33, 0x65, 0x38, 0x62, 0x32, 0x30, 0x39, 0x31, 0x37, 0x61, 0x36, 0x62, 0x32, 0x65, 0x38, 0x35, 0x36, 0x65, 0x65, 0x65, 0x34, 0x61, 0x65, 0x30, 0x66, 0x30, 0x66, 0x35, 0x37, 0x61, 0x62, 0x33, 0x31, 0x31, 0x32, 0x63, 0x62, 0x35, 0x30, 0x37, 0x36, 0x31, 0x63, 0x31, 0x62, 0x61, 0x37, 0x64, 0x35, 0x36, 0x61, 0x62, 0x33, 0x63, 0x32, 0x64, 0x65, 0x64, 0x66, 0x39, 0x63, 0x39, 0x34, 0x31, 0x39, 0x37, 0x35, 0x61, 0x61, 0x62, 0x37, 0x65, 0x63, 0x61, 0x65, 0x61, 0x64, 0x38, 0x39, 0x64, 0x63, 0x62, 0x64, 0x39, 0x30, 0x37, 0x66, 0x34, 0x31, 0x32, 0x62, 0x35, 0x66, 0x64, 0x62, 0x30, 0x61, 0x37, 0x66, 0x39, 0x61, 0x37, 0x32, 0x39, 0x66, 0x30, 0x65, 0x31, 0x37, 0x35, 0x63, 0x32, 0x39, 0x33, 0x38, 0x34, 0x35, 0x61, 0x31, 0x64, 0x36, 0x33, 0x66, 0x34, 0x30, 0x34, 0x38, 0x34, 0x34, 0x30, 0x66, 0x31, 0x31, 0x33, 0x33, 0x33, 0x36, 0x38, 0x38, 0x35, 0x30, 0x62, 0x61, 0x64, 0x35, 0x65, 0x31, 0x36, 0x30, 0x62, 0x34, 0x61, 0x38, 0x32, 0x37, 0x66, 0x64, 0x61, 0x32, 0x63, 0x32, 0x39, 0x38, 0x66, 0x32, 0x30, 0x34, 0x63, 0x32, 0x37, 0x62, 0x32, 0x39, 0x30, 0x65, 0x32, 0x38, 0x34, 0x61, 0x66, 0x38, 0x38, 0x33, 0x37, 0x63, 0x63, 0x36, 0x36, 0x63, 0x37, 0x39, 0x34, 0x64, 0x62, 0x32, 0x32, 0x31, 0x66, 0x61, 0x39, 0x62, 0x34, 0x65, 0x35, 0x39, 0x61, 0x32, 0x38, 0x63, 0x62, 0x66, 0x39, 0x32, 0x30, 0x32, 0x64, 0x37, 0x30, 0x34, 0x62, 0x63, 0x63, 0x64, 0x62, 0x66, 0x32, 0x32, 0x31, 0x66, 0x34, 0x63, 0x35, 0x66, 0x65, 0x66, 0x65, 0x38, 0x66, 0x30, 0x65, 0x30, 0x63, 0x34, 0x36, 0x32, 0x39, 0x32, 0x36, 0x61, 0x30, 0x34, 0x30, 0x30, 0x37, 0x38, 0x39, 0x34, 0x34, 0x39, 0x65, 0x34, 0x32, 0x35, 0x61, 0x31, 0x66, 0x32, 0x31, 0x64, 0x37, 0x31, 0x38, 0x30, 0x61, 0x34, 0x38, 0x37, 0x63, 0x38, 0x62, 0x30, 0x31, 0x63, 0x38, 0x32, 0x64, 0x64, 0x62, 0x36, 0x36, 0x30, 0x61, 0x34, 0x33, 0x35, 0x39, 0x64, 0x35, 0x64, 0x66, 0x63, 0x39, 0x66, 0x35, 0x33, 0x66, 0x63, 0x64, 0x36, 0x62, 0x65, 0x34, 0x36, 0x32, 0x63, 0x38, 0x62, 0x32, 0x39, 0x38, 0x39, 0x36, 0x38, 0x36, 0x34, 0x33, 0x62, 0x39, 0x34, 0x34, 0x30, 0x37, 0x32, 0x61, 0x38, 0x65, 0x65, 0x32, 0x39, 0x39, 0x66, 0x62, 0x39, 0x65, 0x63, 0x36, 0x66, 0x37, 0x66, 0x64, 0x36, 0x31, 0x35, 0x38, 0x30, 0x36, 0x65, 0x36, 0x65, 0x39, 0x35, 0x30, 0x35, 0x66, 0x30, 0x65, 0x36, 0x66, 0x36, 0x36, 0x65, 0x31, 0x39, 0x65, 0x38, 0x65, 0x30, 0x30, 0x36, 0x34, 0x66, 0x38, 0x33, 0x36, 0x30, 0x39, 0x36, 0x64, 0x38, 0x32, 0x61, 0x61, 0x62, 0x33, 0x62, 0x66, 0x35, 0x37, 0x62, 0x63, 0x61, 0x33, 0x35, 0x35, 0x35, 0x66, 0x30, 0x34, 0x39, 0x30, 0x37, 0x66, 0x63, 0x63, 0x31, 0x64, 0x65, 0x35, 0x39, 0x37, 0x31, 0x35, 0x37, 0x38, 0x32, 0x37, 0x31, 0x31, 0x32, 0x66, 0x61, 0x33, 0x61, 0x65, 0x36, 0x63, 0x63, 0x33, 0x61, 0x30, 0x61, 0x62, 0x31, 0x65, 0x37, 0x64, 0x64, 0x64, 0x38, 0x32, 0x33, 0x35, 0x66, 0x33, 0x38, 0x39, 0x32, 0x34, 0x39, 0x36, 0x61, 0x35, 0x39, 0x36, 0x61, 0x61, 0x31, 0x62, 0x39, 0x38, 0x38, 0x32, 0x36, 0x61, 0x64, 0x39, 0x31, 0x62, 0x33, 0x34, 0x35, 0x34, 0x35, 0x39, 0x64, 0x37, 0x30, 0x66, 0x39, 0x35, 0x39, 0x66, 0x62, 0x61, 0x33, 0x64, 0x65, 0x33, 0x63, 0x65, 0x32, 0x39, 0x61, 0x65, 0x31, 0x38, 0x37, 0x61, 0x37, 0x30, 0x31, 0x36, 0x62, 0x39, 0x32, 0x63, 0x38, 0x66, 0x33, 0x61, 0x36, 0x66, 0x62, 0x65, 0x32, 0x65, 0x36, 0x32, 0x39, 0x35, 0x66, 0x36, 0x33, 0x34, 0x63, 0x39, 0x31, 0x65, 0x62, 0x36, 0x39, 0x61, 0x63, 0x36, 0x38, 0x31, 0x61, 0x32, 0x34, 0x37, 0x32, 0x66, 0x34, 0x34, 0x63, 0x62, 0x33, 0x34, 0x30, 0x64, 0x33, 0x38, 0x63, 0x32, 0x30, 0x31, 0x66, 0x66, 0x30, 0x33, 0x62, 0x39, 0x36, 0x64, 0x33, 0x66, 0x34, 0x33, 0x63, 0x65, 0x30, 0x63, 0x36, 0x31, 0x65, 0x37, 0x35, 0x65, 0x39, 0x35, 0x30, 0x33, 0x32, 0x63, 0x32, 0x63, 0x31, 0x30, 0x39, 0x34, 0x63, 0x31, 0x36, 0x39, 0x66, 0x30, 0x30, 0x65, 0x35, 0x30, 0x63, 0x36, 0x61, 0x36, 0x62, 0x34, 0x32, 0x31, 0x61, 0x35, 0x36, 0x31, 0x32, 0x30, 0x65, 0x36, 0x38, 0x37, 0x33, 0x30, 0x32, 0x62, 0x38, 0x32, 0x38, 0x33, 0x39, 0x36, 0x66, 0x61, 0x66, 0x39, 0x63, 0x63, 0x38, 0x36, 0x38, 0x66, 0x33, 0x30, 0x32, 0x37, 0x65, 0x39, 0x32, 0x66, 0x33, 0x34, 0x34, 0x38, 0x35, 0x37, 0x34, 0x31, 0x38, 0x39, 0x33, 0x34, 0x38, 0x39, 0x30, 0x39, 0x61, 0x36, 0x62, 0x34, 0x61, 0x37, 0x32, 0x33, 0x61, 0x31, 0x30, 0x63, 0x34, 0x39, 0x63, 0x65, 0x36, 0x34, 0x65, 0x63, 0x64, 0x36, 0x36, 0x30, 0x63, 0x62, 0x62, 0x64, 0x62, 0x35, 0x34, 0x64, 0x37, 0x36, 0x61, 0x35, 0x35, 0x35, 0x31, 0x39, 0x63, 0x65, 0x37, 0x36, 0x32, 0x32, 0x34, 0x33, 0x66, 0x36, 0x32, 0x36, 0x64, 0x65, 0x31, 0x64, 0x33, 0x39, 0x30, 0x62, 0x31, 0x38, 0x62, 0x35, 0x61, 0x30, 0x61, 0x65, 0x32, 0x37, 0x32, 0x65, 0x38, 0x36, 0x32, 0x65, 0x62, 0x39, 0x62, 0x65, 0x33, 0x65, 0x31, 0x65, 0x62, 0x31, 0x36, 0x31, 0x66, 0x33, 0x64, 0x38, 0x34, 0x63, 0x36, 0x66, 0x62, 0x30, 0x66, 0x36, 0x34, 0x31, 0x66, 0x39, 0x35, 0x64, 0x31, 0x62, 0x61, 0x38, 0x36, 0x36, 0x38, 0x62, 0x63, 0x37, 0x38, 0x33, 0x39, 0x34, 0x32, 0x36, 0x32, 0x64, 0x30, 0x30, 0x36, 0x62, 0x63, 0x31, 0x62, 0x32, 0x35, 0x37, 0x32, 0x39, 0x31, 0x62, 0x65, 0x30, 0x36, 0x36, 0x39, 0x61, 0x62, 0x61, 0x34, 0x39, 0x37, 0x65, 0x63, 0x65, 0x35, 0x64, 0x61, 0x62, 0x37, 0x34, 0x39, 0x66, 0x36, 0x38, 0x62, 0x36, 0x34, 0x32, 0x63, 0x38, 0x33, 0x64, 0x31, 0x65, 0x64, 0x37, 0x36, 0x35, 0x64, 0x35, 0x65, 0x34, 0x35, 0x33, 0x38, 0x35, 0x66, 0x64, 0x62, 0x38, 0x65, 0x66, 0x66, 0x65, 0x64, 0x38, 0x34, 0x37, 0x35, 0x37, 0x32, 0x35, 0x31, 0x65, 0x65, 0x65, 0x61, 0x35, 0x65, 0x61, 0x63, 0x38, 0x36, 0x34, 0x38, 0x66, 0x64, 0x38, 0x61, 0x39, 0x37, 0x64, 0x32, 0x61, 0x39, 0x64, 0x39, 0x61, 0x36, 0x33, 0x63, 0x36, 0x61, 0x36, 0x62, 0x63, 0x37, 0x30, 0x38, 0x62, 0x36, 0x35, 0x61, 0x33, 0x39, 0x30, 0x64, 0x62, 0x65, 0x62, 0x32, 0x61, 0x33, 0x33, 0x63, 0x63, 0x34, 0x31, 0x37, 0x37, 0x39, 0x66, 0x37, 0x32, 0x31, 0x61, 0x66, 0x32, 0x33, 0x36, 0x33, 0x34, 0x62, 0x39, 0x31, 0x62, 0x38, 0x39, 0x66, 0x61, 0x61, 0x34, 0x39, 0x38, 0x35, 0x33, 0x63, 0x66, 0x33, 0x32, 0x61, 0x31, 0x62, 0x65, 0x62, 0x61, 0x30, 0x30, 0x37, 0x38, 0x38, 0x32, 0x31, 0x33, 0x36, 0x31, 0x63, 0x38, 0x63, 0x32, 0x63, 0x39, 0x63, 0x34, 0x64, 0x33, 0x30, 0x35, 0x63, 0x64, 0x64, 0x62, 0x39, 0x31, 0x61, 0x66, 0x66, 0x36, 0x37, 0x65, 0x38, 0x66, 0x31, 0x32, 0x30, 0x64, 0x34, 0x32, 0x35, 0x38, 0x37, 0x33, 0x33, 0x64, 0x39, 0x35, 0x65, 0x65, 0x66, 0x66, 0x62, 0x37, 0x37, 0x38, 0x32, 0x30, 0x38, 0x65, 0x61, 0x30, 0x38, 0x66, 0x34, 0x63, 0x39, 0x62, 0x30, 0x38, 0x39, 0x33, 0x65, 0x64, 0x31, 0x31, 0x36, 0x36, 0x64, 0x36, 0x61, 0x34, 0x64, 0x61, 0x65, 0x61, 0x35, 0x36, 0x31, 0x61, 0x32, 0x38, 0x34, 0x37, 0x32, 0x31, 0x32, 0x37, 0x36, 0x33, 0x35, 0x61, 0x38, 0x61, 0x66, 0x63, 0x66, 0x32, 0x38, 0x30, 0x33, 0x37, 0x64, 0x63, 0x61, 0x31, 0x36, 0x32, 0x33, 0x35, 0x33, 0x63, 0x34, 0x64, 0x33, 0x32, 0x35, 0x63, 0x32, 0x32, 0x66, 0x34, 0x64, 0x63, 0x63, 0x33, 0x30, 0x62, 0x32, 0x38, 0x61, 0x65, 0x39, 0x30, 0x65, 0x38, 0x34, 0x64, 0x38, 0x38, 0x34, 0x64, 0x31, 0x38, 0x31, 0x37, 0x64, 0x37, 0x32, 0x32, 0x34, 0x63, 0x30, 0x65, 0x65, 0x30, 0x35, 0x62, 0x63, 0x36, 0x33, 0x38, 0x64, 0x35, 0x34, 0x62, 0x30, 0x35, 0x61, 0x33, 0x30, 0x32, 0x34, 0x65, 0x36, 0x32, 0x34, 0x34, 0x61, 0x36, 0x62, 0x35, 0x66, 0x39, 0x34, 0x65, 0x37, 0x37, 0x38, 0x33, 0x66, 0x31, 0x31, 0x30, 0x34, 0x65, 0x33, 0x32, 0x61, 0x38, 0x34, 0x35, 0x61, 0x34, 0x33, 0x64, 0x66, 0x34, 0x66, 0x37, 0x66, 0x33, 0x32, 0x64, 0x32, 0x63, 0x66, 0x61, 0x37, 0x31, 0x36, 0x64, 0x31, 0x63, 0x63, 0x34, 0x62, 0x66, 0x37, 0x32, 0x36, 0x63, 0x64, 0x66, 0x38, 0x30, 0x63, 0x36, 0x65, 0x30, 0x65, 0x31, 0x36, 0x34, 0x64, 0x64, 0x32, 0x64, 0x65, 0x32, 0x30, 0x32, 0x63, 0x62, 0x62, 0x35, 0x32, 0x37, 0x37, 0x36, 0x32, 0x64, 0x36, 0x64, 0x63, 0x66, 0x36, 0x64, 0x32, 0x63, 0x30, 0x66, 0x66, 0x37, 0x32, 0x32, 0x65, 0x62, 0x32, 0x30, 0x31, 0x65, 0x38, 0x33, 0x61, 0x34, 0x39, 0x66, 0x63, 0x36, 0x38, 0x65, 0x32, 0x38, 0x33, 0x62, 0x62, 0x37, 0x36, 0x63, 0x36, 0x64, 0x35, 0x63, 0x34, 0x33, 0x39, 0x30, 0x33, 0x64, 0x31, 0x62, 0x38, 0x61, 0x37, 0x38, 0x66, 0x63, 0x31, 0x37, 0x66, 0x65, 0x36, 0x65, 0x62, 0x37, 0x36, 0x36, 0x31, 0x31, 0x39, 0x65, 0x37, 0x32, 0x32, 0x37, 0x36, 0x32, 0x36, 0x33, 0x36, 0x34, 0x31, 0x30, 0x39, 0x32, 0x38, 0x65, 0x30, 0x37, 0x63, 0x64, 0x65, 0x33, 0x63, 0x36, 0x30, 0x66, 0x31, 0x37, 0x63, 0x36, 0x38, 0x32, 0x39, 0x61, 0x65, 0x34, 0x33, 0x35, 0x31, 0x38, 0x34, 0x65, 0x38, 0x66, 0x33, 0x34, 0x63, 0x38, 0x61, 0x63, 0x34, 0x31, 0x34, 0x31, 0x36, 0x33, 0x66, 0x62, 0x61, 0x30, 0x35, 0x64, 0x63, 0x66, 0x30, 0x62, 0x66, 0x66, 0x61, 0x64, 0x35, 0x36, 0x39, 0x31, 0x35, 0x39, 0x30, 0x31, 0x32, 0x38, 0x66, 0x62, 0x63, 0x63, 0x33, 0x61, 0x30, 0x30, 0x66, 0x37, 0x61, 0x31, 0x38, 0x33, 0x62, 0x35, 0x65, 0x30, 0x33, 0x31, 0x65, 0x30, 0x39, 0x33, 0x62, 0x36, 0x62, 0x33, 0x37, 0x35, 0x37, 0x31, 0x61, 0x31, 0x64, 0x65, 0x63, 0x62, 0x36, 0x38, 0x61, 0x65, 0x33, 0x33, 0x34, 0x63, 0x32, 0x64, 0x36, 0x35, 0x64, 0x61, 0x61, 0x38, 0x35, 0x30, 0x62, 0x61, 0x32, 0x39, 0x36, 0x31, 0x31, 0x30, 0x66, 0x37, 0x66, 0x37, 0x37, 0x34, 0x64, 0x36, 0x32, 0x30, 0x65, 0x62, 0x65, 0x39, 0x32, 0x34, 0x38, 0x65, 0x65, 0x39, 0x30, 0x62, 0x33, 0x62, 0x32, 0x33, 0x33, 0x32, 0x34, 0x35, 0x39, 0x64, 0x63, 0x38, 0x30, 0x62, 0x64, 0x38, 0x66, 0x32, 0x64, 0x63, 0x61, 0x32, 0x38, 0x36, 0x32, 0x62, 0x35, 0x33, 0x34, 0x34, 0x66, 0x64, 0x38, 0x36, 0x33, 0x61, 0x39, 0x33, 0x31, 0x63, 0x30, 0x62, 0x63, 0x38, 0x64, 0x36, 0x64, 0x34, 0x63, 0x32, 0x64, 0x33, 0x32, 0x64, 0x31, 0x39, 0x33, 0x62, 0x39, 0x31, 0x38, 0x63, 0x37, 0x66, 0x32, 0x34, 0x37, 0x62, 0x33, 0x37, 0x36, 0x34, 0x32, 0x63, 0x38, 0x32, 0x30, 0x61, 0x35, 0x30, 0x35, 0x62, 0x62, 0x64, 0x61, 0x65, 0x36, 0x33, 0x66, 0x34, 0x63, 0x64, 0x31, 0x33, 0x31, 0x35, 0x65, 0x36, 0x65, 0x64, 0x64, 0x35, 0x30, 0x37, 0x61, 0x37, 0x34, 0x36, 0x62, 0x39, 0x31, 0x64, 0x31, 0x34, 0x34, 0x33, 0x30, 0x65, 0x34, 0x61, 0x30, 0x61, 0x33, 0x63, 0x31, 0x36, 0x37, 0x61, 0x62, 0x62, 0x37, 0x65, 0x62, 0x64, 0x37, 0x31, 0x66, 0x33, 0x61, 0x30, 0x31, 0x35, 0x36, 0x30, 0x32, 0x62, 0x32, 0x37, 0x63, 0x33, 0x62, 0x65, 0x35, 0x31, 0x65, 0x66, 0x62, 0x38, 0x63, 0x66, 0x39, 0x33, 0x62, 0x65, 0x30, 0x66, 0x38, 0x37, 0x61, 0x38, 0x33, 0x62, 0x65, 0x34, 0x30, 0x65, 0x62, 0x38, 0x36, 0x31, 0x64, 0x35, 0x61, 0x33, 0x37, 0x31, 0x38, 0x35, 0x63, 0x34, 0x35, 0x64, 0x39, 0x37, 0x65, 0x34, 0x61, 0x30, 0x39, 0x64, 0x37, 0x30, 0x33, 0x64, 0x30, 0x32, 0x65, 0x33, 0x30, 0x33, 0x34, 0x31, 0x64, 0x39, 0x37, 0x35, 0x66, 0x31, 0x30, 0x31, 0x33, 0x38, 0x32, 0x65, 0x30, 0x37, 0x32, 0x37, 0x66, 0x39, 0x63, 0x30, 0x65, 0x66, 0x38, 0x37, 0x34, 0x62, 0x34, 0x31, 0x65, 0x32, 0x64, 0x35, 0x38, 0x61, 0x35, 0x32, 0x33, 0x38, 0x61, 0x33, 0x36, 0x62, 0x30, 0x64, 0x33, 0x37, 0x66, 0x36, 0x33, 0x62, 0x66, 0x66, 0x66, 0x36, 0x33, 0x61, 0x62, 0x63, 0x62, 0x66, 0x34, 0x65, 0x63, 0x65, 0x65, 0x38, 0x65, 0x37, 0x66, 0x65, 0x33, 0x30, 0x31, 0x39, 0x65, 0x62, 0x38, 0x34, 0x30, 0x31, 0x63, 0x61, 0x35, 0x63, 0x64, 0x64, 0x66, 0x38, 0x63, 0x38, 0x65, 0x30, 0x39, 0x64, 0x38, 0x39, 0x38, 0x32, 0x30, 0x39, 0x61, 0x33, 0x39, 0x64, 0x38, 0x65, 0x36, 0x31, 0x61, 0x33, 0x30, 0x39, 0x39, 0x33, 0x39, 0x36, 0x33, 0x30, 0x31, 0x36, 0x39, 0x62, 0x33, 0x32, 0x64, 0x63, 0x31, 0x34, 0x65, 0x34, 0x61, 0x36, 0x66, 0x36, 0x61, 0x35, 0x65, 0x32, 0x30, 0x64, 0x63, 0x37, 0x32, 0x62, 0x63, 0x65, 0x37, 0x31, 0x62, 0x62, 0x62, 0x30, 0x61, 0x39, 0x62, 0x35, 0x32, 0x30, 0x31, 0x30, 0x36, 0x66, 0x38, 0x38, 0x61, 0x64, 0x35, 0x38, 0x36, 0x33, 0x39, 0x39, 0x66, 0x33, 0x39, 0x34, 0x30, 0x30, 0x65, 0x65, 0x36, 0x65, 0x36, 0x30, 0x38, 0x64, 0x32, 0x31, 0x35, 0x35, 0x36, 0x32, 0x63, 0x34, 0x38, 0x37, 0x65, 0x37, 0x30, 0x38, 0x61, 0x31, 0x62, 0x30, 0x61, 0x34, 0x31, 0x64, 0x61, 0x39, 0x33, 0x33, 0x39, 0x34, 0x31, 0x64, 0x33, 0x31, 0x64, 0x62, 0x65, 0x37, 0x30, 0x64, 0x36, 0x33, 0x39, 0x33, 0x65, 0x64, 0x39, 0x30, 0x34, 0x30, 0x39, 0x36, 0x34, 0x66, 0x66, 0x38, 0x64, 0x39, 0x34, 0x33, 0x65, 0x63, 0x30, 0x64, 0x66, 0x36, 0x61, 0x35, 0x32, 0x34, 0x64, 0x37, 0x37, 0x31, 0x66, 0x37, 0x63, 0x38, 0x64, 0x34, 0x37, 0x31, 0x61, 0x36, 0x61, 0x37, 0x32, 0x64, 0x34, 0x62, 0x32, 0x39, 0x66, 0x63, 0x62, 0x65, 0x31, 0x66, 0x66, 0x31, 0x30, 0x37, 0x30, 0x62, 0x32, 0x38, 0x35, 0x66, 0x32, 0x31, 0x34, 0x65, 0x34, 0x37, 0x37, 0x66, 0x32, 0x63, 0x35, 0x38, 0x30, 0x37, 0x32, 0x35, 0x31, 0x36, 0x61, 0x33, 0x61, 0x30, 0x62, 0x66, 0x36, 0x30, 0x61, 0x32, 0x66, 0x62, 0x34, 0x65, 0x61, 0x66, 0x37, 0x39, 0x65, 0x62, 0x30, 0x36, 0x65, 0x37, 0x32, 0x32, 0x64, 0x63, 0x31, 0x64, 0x34, 0x33, 0x65, 0x63, 0x62, 0x38, 0x32, 0x37, 0x31, 0x65, 0x39, 0x31, 0x64, 0x37, 0x36, 0x66, 0x66, 0x66, 0x37, 0x34, 0x35, 0x62, 0x39, 0x36, 0x34, 0x30, 0x34, 0x63, 0x33, 0x62, 0x65, 0x61, 0x31, 0x37, 0x36, 0x64, 0x30, 0x62, 0x34, 0x33, 0x38, 0x37, 0x30, 0x66, 0x65, 0x33, 0x35, 0x30, 0x62, 0x32, 0x32, 0x65, 0x32, 0x62, 0x31, 0x37, 0x39, 0x37, 0x32, 0x66, 0x38, 0x64, 0x63, 0x35, 0x61, 0x37, 0x36, 0x33, 0x30, 0x35, 0x64, 0x36, 0x36, 0x35, 0x30, 0x38, 0x38, 0x30, 0x39, 0x33, 0x33, 0x36, 0x64, 0x34, 0x31, 0x35, 0x33, 0x31, 0x32, 0x64, 0x65, 0x61, 0x35, 0x30, 0x32, 0x37, 0x39, 0x31, 0x66, 0x33, 0x36, 0x37, 0x62, 0x64, 0x37, 0x64, 0x64, 0x63, 0x64, 0x30, 0x65, 0x61, 0x38, 0x39, 0x31, 0x30, 0x64, 0x33, 0x63, 0x37, 0x66, 0x36, 0x63, 0x66, 0x32, 0x62, 0x34, 0x63, 0x35, 0x33, 0x61, 0x38, 0x35, 0x30, 0x61, 0x61, 0x31, 0x34, 0x32, 0x66, 0x39, 0x66, 0x62, 0x66, 0x32, 0x32, 0x61, 0x37, 0x39, 0x62, 0x65, 0x34, 0x33, 0x66, 0x62, 0x30, 0x61, 0x62, 0x30, 0x31, 0x34, 0x61, 0x38, 0x64, 0x36, 0x62, 0x61, 0x37, 0x30, 0x30, 0x35, 0x65, 0x39, 0x35, 0x39, 0x61, 0x38, 0x31, 0x65, 0x31, 0x66, 0x30, 0x32, 0x62, 0x66, 0x37, 0x32, 0x36, 0x64, 0x66, 0x63, 0x37, 0x66, 0x62, 0x38, 0x35, 0x64, 0x34, 0x33, 0x34, 0x34, 0x38, 0x34, 0x30, 0x35, 0x61, 0x32, 0x34, 0x33, 0x32, 0x61, 0x63, 0x64, 0x63, 0x34, 0x32, 0x65, 0x34, 0x31, 0x36, 0x61, 0x36, 0x35, 0x61, 0x33, 0x35, 0x63, 0x38, 0x61, 0x31, 0x36, 0x63, 0x35, 0x36, 0x66, 0x62, 0x31, 0x30, 0x37, 0x65, 0x63, 0x32, 0x36, 0x30, 0x34, 0x38, 0x37, 0x33, 0x61, 0x33, 0x66, 0x33, 0x61, 0x32, 0x38, 0x32, 0x39, 0x35, 0x61, 0x65, 0x66, 0x38, 0x37, 0x33, 0x66, 0x62, 0x65, 0x32, 0x34, 0x63, 0x38, 0x30, 0x65, 0x37, 0x39, 0x63, 0x33, 0x38, 0x32, 0x31, 0x31, 0x38, 0x31, 0x34, 0x32, 0x34, 0x35, 0x66, 0x32, 0x35, 0x62, 0x30, 0x61, 0x34, 0x62, 0x34, 0x37, 0x66, 0x39, 0x31, 0x62, 0x33, 0x35, 0x63, 0x35, 0x64, 0x63, 0x34, 0x30, 0x61, 0x61, 0x65, 0x61, 0x37, 0x32, 0x38, 0x39, 0x61, 0x35, 0x33, 0x61, 0x62, 0x33, 0x64, 0x33, 0x35, 0x66, 0x66, 0x61, 0x33, 0x66, 0x35, 0x35, 0x64, 0x66, 0x64, 0x37, 0x30, 0x61, 0x38, 0x32, 0x30, 0x33, 0x61, 0x31, 0x31, 0x38, 0x35, 0x37, 0x62, 0x65, 0x66, 0x34, 0x32, 0x34, 0x30, 0x39, 0x34, 0x39, 0x35, 0x32, 0x64, 0x32, 0x36, 0x66, 0x64, 0x33, 0x36, 0x34, 0x33, 0x34, 0x36, 0x33, 0x38, 0x38, 0x64, 0x61, 0x33, 0x30, 0x37, 0x31, 0x34, 0x35, 0x37, 0x65, 0x61, 0x65, 0x30, 0x63, 0x64, 0x66, 0x39, 0x37, 0x37, 0x66, 0x37, 0x39, 0x62, 0x35, 0x62, 0x62, 0x66, 0x39, 0x63, 0x63, 0x33, 0x64, 0x30, 0x64, 0x62, 0x36, 0x33, 0x66, 0x36, 0x63, 0x35, 0x30, 0x39, 0x64, 0x39, 0x30, 0x61, 0x38, 0x31, 0x62, 0x39, 0x34, 0x66, 0x31, 0x61, 0x36, 0x37, 0x66, 0x66, 0x31, 0x64, 0x39, 0x64, 0x39, 0x38, 0x35, 0x37, 0x32, 0x32, 0x37, 0x39, 0x32, 0x35, 0x32, 0x62, 0x38, 0x30, 0x31, 0x62, 0x61, 0x39, 0x38, 0x32, 0x39, 0x65, 0x38, 0x30, 0x65, 0x33, 0x61, 0x61, 0x38, 0x65, 0x64, 0x32, 0x62, 0x62, 0x64, 0x62, 0x33, 0x61, 0x39, 0x66, 0x32, 0x39, 0x35, 0x64, 0x64, 0x39, 0x37, 0x39, 0x39, 0x38, 0x63, 0x34, 0x63, 0x33, 0x64, 0x61, 0x39, 0x36, 0x62, 0x39, 0x61, 0x35, 0x33, 0x37, 0x63, 0x37, 0x31, 0x37, 0x32, 0x66, 0x38, 0x34, 0x61, 0x31, 0x64, 0x31, 0x38, 0x35, 0x32, 0x61, 0x32, 0x30, 0x35, 0x38, 0x62, 0x38, 0x66, 0x30, 0x31, 0x62, 0x64, 0x35, 0x61, 0x31, 0x35, 0x66, 0x63, 0x36, 0x64, 0x33, 0x33, 0x62, 0x38, 0x63, 0x36, 0x65, 0x64, 0x65, 0x30, 0x65, 0x33, 0x33, 0x31, 0x38, 0x30, 0x63, 0x64, 0x31, 0x36, 0x64, 0x64, 0x31, 0x37, 0x31, 0x31, 0x30, 0x31, 0x31, 0x64, 0x38, 0x66, 0x34, 0x64, 0x31, 0x34, 0x31, 0x62, 0x36, 0x35, 0x36, 0x64, 0x63, 0x32, 0x37, 0x39, 0x64, 0x63, 0x39, 0x64, 0x63, 0x38, 0x38, 0x61, 0x39, 0x39, 0x31, 0x62, 0x64, 0x33, 0x30, 0x37, 0x38, 0x39, 0x35, 0x64, 0x63, 0x38, 0x35, 0x36, 0x33, 0x32, 0x38, 0x39, 0x35, 0x33, 0x38, 0x32, 0x30, 0x63, 0x34, 0x64, 0x36, 0x33, 0x61, 0x30, 0x63, 0x39, 0x33, 0x63, 0x61, 0x38, 0x65, 0x62, 0x65, 0x31, 0x37, 0x32, 0x33, 0x65, 0x66, 0x37, 0x32, 0x33, 0x34, 0x35, 0x36, 0x31, 0x37, 0x32, 0x63, 0x61, 0x63, 0x35, 0x35, 0x65, 0x31, 0x34, 0x37, 0x33, 0x39, 0x31, 0x61, 0x66, 0x31, 0x39, 0x62, 0x32, 0x61, 0x36, 0x30, 0x31, 0x61, 0x61, 0x64, 0x38, 0x36, 0x64, 0x62, 0x33, 0x34, 0x37, 0x38, 0x32, 0x64, 0x34, 0x36, 0x30, 0x35, 0x34, 0x62, 0x61, 0x63, 0x35, 0x39, 0x31, 0x61, 0x64, 0x39, 0x37, 0x36, 0x32, 0x31, 0x65, 0x38, 0x33, 0x62, 0x38, 0x34, 0x37, 0x32, 0x64, 0x64, 0x39, 0x37, 0x35, 0x65, 0x34, 0x30, 0x30, 0x38, 0x31, 0x30, 0x32, 0x37, 0x65, 0x37, 0x66, 0x38, 0x33, 0x62, 0x64, 0x39, 0x38, 0x65, 0x38, 0x64, 0x30, 0x63, 0x30, 0x31, 0x37, 0x65, 0x30, 0x33, 0x61, 0x33, 0x62, 0x39, 0x66, 0x38, 0x31, 0x38, 0x65, 0x37, 0x34, 0x33, 0x34, 0x65, 0x66, 0x35, 0x35, 0x31, 0x33, 0x35, 0x61, 0x65, 0x37, 0x31, 0x34, 0x37, 0x37, 0x61, 0x31, 0x61, 0x63, 0x37, 0x38, 0x61, 0x39, 0x31, 0x66, 0x38, 0x35, 0x31, 0x30, 0x37, 0x31, 0x62, 0x61, 0x61, 0x63, 0x62, 0x31, 0x37, 0x35, 0x62, 0x38, 0x32, 0x65, 0x32, 0x32, 0x33, 0x39, 0x63, 0x32, 0x35, 0x61, 0x37, 0x39, 0x64, 0x61, 0x36, 0x32, 0x35, 0x65, 0x34, 0x61, 0x37, 0x36, 0x66, 0x30, 0x34, 0x32, 0x32, 0x35, 0x61, 0x65, 0x37, 0x32, 0x33, 0x39, 0x39, 0x31, 0x66, 0x37, 0x38, 0x64, 0x36, 0x37, 0x39, 0x66, 0x65, 0x34, 0x35, 0x33, 0x31, 0x38, 0x64, 0x65, 0x38, 0x64, 0x33, 0x32, 0x32, 0x37, 0x66, 0x33, 0x36, 0x65, 0x35, 0x35, 0x33, 0x65, 0x39, 0x32, 0x38, 0x66, 0x61, 0x36, 0x61, 0x65, 0x36, 0x61, 0x38, 0x39, 0x37, 0x64, 0x66, 0x38, 0x34, 0x65, 0x33, 0x31, 0x30, 0x62, 0x36, 0x39, 0x33, 0x66, 0x62, 0x63, 0x30, 0x30, 0x33, 0x39, 0x36, 0x38, 0x37, 0x61, 0x62, 0x63, 0x38, 0x65, 0x31, 0x66, 0x34, 0x36, 0x64, 0x33, 0x35, 0x64, 0x64, 0x35, 0x39, 0x33, 0x37, 0x61, 0x33, 0x31, 0x37, 0x63, 0x34, 0x33, 0x34, 0x61, 0x62, 0x65, 0x63, 0x31, 0x32, 0x36, 0x33, 0x35, 0x32, 0x30, 0x38, 0x39, 0x62, 0x39, 0x31, 0x36, 0x63, 0x64, 0x36, 0x34, 0x65, 0x64, 0x38, 0x64, 0x39, 0x39, 0x37, 0x32, 0x38, 0x63, 0x37, 0x32, 0x35, 0x32, 0x66, 0x34, 0x34, 0x63, 0x38, 0x62, 0x62, 0x30, 0x36, 0x32, 0x65, 0x34, 0x32, 0x32, 0x63, 0x38, 0x62, 0x30, 0x30, 0x64, 0x31, 0x35, 0x63, 0x31, 0x30, 0x32, 0x33, 0x30, 0x37, 0x39, 0x65, 0x30, 0x62, 0x62, 0x62, 0x36, 0x65, 0x38, 0x37, 0x35, 0x36, 0x31, 0x65, 0x30, 0x66, 0x34, 0x61, 0x66, 0x38, 0x33, 0x62, 0x66, 0x62, 0x66, 0x36, 0x30, 0x31, 0x33, 0x33, 0x38, 0x33, 0x30, 0x31, 0x34, 0x62, 0x66, 0x36, 0x30, 0x38, 0x62, 0x62, 0x66, 0x65, 0x33, 0x66, 0x37, 0x34, 0x30, 0x62, 0x38, 0x33, 0x39, 0x30, 0x64, 0x63, 0x62, 0x36, 0x32, 0x64, 0x65, 0x62, 0x61, 0x31, 0x33, 0x34, 0x64, 0x37, 0x33, 0x31, 0x37, 0x33, 0x65, 0x33, 0x35, 0x37, 0x38, 0x38, 0x34, 0x38, 0x64, 0x61, 0x62, 0x63, 0x35, 0x66, 0x66, 0x63, 0x64, 0x63, 0x36, 0x30, 0x30, 0x32, 0x31, 0x37, 0x32, 0x64, 0x39, 0x35, 0x64, 0x33, 0x65, 0x65, 0x34, 0x35, 0x32, 0x62, 0x31, 0x31, 0x61, 0x66, 0x33, 0x66, 0x65, 0x30, 0x65, 0x37, 0x38, 0x62, 0x35, 0x32, 0x64, 0x38, 0x32, 0x31, 0x35, 0x30, 0x65, 0x38, 0x34, 0x30, 0x34, 0x33, 0x37, 0x36, 0x34, 0x35, 0x32, 0x39, 0x62, 0x61, 0x32, 0x66, 0x61, 0x30, 0x33, 0x61, 0x30, 0x65, 0x39, 0x33, 0x64, 0x30, 0x38, 0x32, 0x33, 0x35, 0x62, 0x37, 0x32, 0x66, 0x30, 0x33, 0x38, 0x35, 0x37, 0x63, 0x33, 0x61, 0x39, 0x65, 0x62, 0x32, 0x32, 0x32, 0x36, 0x37, 0x66, 0x66, 0x63, 0x63, 0x36, 0x63, 0x63, 0x61, 0x34, 0x39, 0x66, 0x34, 0x39, 0x64, 0x34, 0x36, 0x32, 0x34, 0x33, 0x65, 0x36, 0x61, 0x31, 0x35, 0x35, 0x35, 0x36, 0x31, 0x66, 0x34, 0x30, 0x38, 0x62, 0x61, 0x36, 0x66, 0x32, 0x31, 0x34, 0x62, 0x65, 0x32, 0x66, 0x35, 0x35, 0x37, 0x32, 0x62, 0x65, 0x62, 0x31, 0x37, 0x64, 0x36, 0x38, 0x62, 0x32, 0x30, 0x65, 0x30, 0x66, 0x38, 0x64, 0x63, 0x32, 0x64, 0x61, 0x31, 0x39, 0x61, 0x35, 0x61, 0x38, 0x35, 0x32, 0x36, 0x30, 0x38, 0x37, 0x39, 0x37, 0x30, 0x61, 0x31, 0x34, 0x37, 0x39, 0x39, 0x39, 0x65, 0x39, 0x39, 0x64, 0x62, 0x63, 0x33, 0x34, 0x36, 0x38, 0x31, 0x66, 0x30, 0x61, 0x64, 0x61, 0x38, 0x63, 0x64, 0x34, 0x37, 0x32, 0x38, 0x65, 0x32, 0x36, 0x39, 0x39, 0x65, 0x39, 0x36, 0x34, 0x30, 0x38, 0x38, 0x62, 0x31, 0x36, 0x62, 0x38, 0x33, 0x37, 0x61, 0x37, 0x38, 0x62, 0x32, 0x39, 0x31, 0x33, 0x31, 0x64, 0x64, 0x66, 0x39, 0x30, 0x31, 0x37, 0x61, 0x34, 0x32, 0x62, 0x63, 0x32, 0x34, 0x30, 0x37, 0x37, 0x62, 0x61, 0x62, 0x66, 0x39, 0x39, 0x38, 0x34, 0x63, 0x30, 0x33, 0x61, 0x66, 0x30, 0x36, 0x32, 0x37, 0x32, 0x31, 0x39, 0x38, 0x38, 0x31, 0x32, 0x62, 0x32, 0x62, 0x61, 0x36, 0x65, 0x34, 0x65, 0x66, 0x63, 0x64, 0x61, 0x61, 0x35, 0x35, 0x37, 0x63, 0x33, 0x30, 0x35, 0x38, 0x65, 0x64, 0x64, 0x33, 0x65, 0x65, 0x30, 0x34, 0x31, 0x62, 0x62, 0x62, 0x37, 0x66, 0x32, 0x31, 0x34, 0x31, 0x61, 0x65, 0x30, 0x35, 0x66, 0x37, 0x33, 0x31, 0x30, 0x35, 0x62, 0x30, 0x35, 0x34, 0x36, 0x62, 0x33, 0x37, 0x32, 0x63, 0x36, 0x32, 0x31, 0x33, 0x61, 0x39, 0x66, 0x61, 0x35, 0x39, 0x33, 0x63, 0x66, 0x39, 0x62, 0x65, 0x61, 0x32, 0x37, 0x30, 0x36, 0x64, 0x30, 0x39, 0x32, 0x38, 0x32, 0x34, 0x64, 0x63, 0x64, 0x65, 0x61, 0x63, 0x31, 0x31, 0x66, 0x39, 0x64, 0x32, 0x33, 0x63, 0x33, 0x62, 0x34, 0x65, 0x35, 0x34, 0x32, 0x32, 0x65, 0x35, 0x36, 0x37, 0x39, 0x66, 0x66, 0x35, 0x63, 0x32, 0x30, 0x37, 0x32, 0x66, 0x66, 0x63, 0x37, 0x66, 0x64, 0x64, 0x63, 0x66, 0x32, 0x66, 0x63, 0x61, 0x65, 0x65, 0x66, 0x64, 0x32, 0x66, 0x30, 0x37, 0x33, 0x38, 0x30, 0x32, 0x39, 0x30, 0x34, 0x33, 0x37, 0x31, 0x38, 0x63, 0x30, 0x39, 0x38, 0x65, 0x62, 0x64, 0x31, 0x61, 0x61, 0x66, 0x39, 0x37, 0x32, 0x37, 0x62, 0x32, 0x31, 0x63, 0x35, 0x65, 0x33, 0x38, 0x37, 0x38, 0x34, 0x66, 0x37, 0x64, 0x32, 0x35, 0x63, 0x36, 0x64, 0x33, 0x33, 0x66, 0x64, 0x37, 0x64, 0x39, 0x36, 0x36, 0x63, 0x36, 0x39, 0x30, 0x36, 0x32, 0x30, 0x63, 0x66, 0x36, 0x37, 0x36, 0x65, 0x35, 0x37, 0x62, 0x64, 0x32, 0x65, 0x65, 0x33, 0x37, 0x66, 0x66, 0x64, 0x66, 0x62, 0x39, 0x62, 0x66, 0x33, 0x39, 0x31, 0x61, 0x36, 0x31, 0x36, 0x64, 0x37, 0x35, 0x35, 0x61, 0x36, 0x62, 0x64, 0x65, 0x61, 0x39, 0x32, 0x30, 0x37, 0x37, 0x32, 0x39, 0x39, 0x37, 0x64, 0x31, 0x63, 0x38, 0x37, 0x39, 0x62, 0x63, 0x36, 0x31, 0x31, 0x38, 0x39, 0x38, 0x65, 0x35, 0x32, 0x30, 0x37, 0x62, 0x37, 0x30, 0x65, 0x66, 0x37, 0x64, 0x32, 0x32, 0x62, 0x31, 0x35, 0x31, 0x63, 0x65, 0x35, 0x61, 0x33, 0x37, 0x39, 0x66, 0x31, 0x33, 0x66, 0x65, 0x34, 0x39, 0x37, 0x38, 0x38, 0x65, 0x35, 0x34, 0x38, 0x30, 0x33, 0x36, 0x37, 0x66, 0x61, 0x33, 0x61, 0x66, 0x35, 0x64, 0x64, 0x33, 0x39, 0x31, 0x65, 0x35, 0x30, 0x63, 0x63, 0x36, 0x39, 0x38, 0x33, 0x65, 0x63, 0x61, 0x34, 0x35, 0x63, 0x31, 0x31, 0x62, 0x30, 0x33, 0x30, 0x61, 0x36, 0x65, 0x34, 0x66, 0x30, 0x33, 0x64, 0x31, 0x34, 0x31, 0x37, 0x66, 0x30, 0x64, 0x35, 0x35, 0x31, 0x61, 0x64, 0x64, 0x64, 0x65, 0x61, 0x36, 0x33, 0x64, 0x36, 0x31, 0x62, 0x66, 0x39, 0x31, 0x32, 0x37, 0x32, 0x35, 0x61, 0x37, 0x64, 0x33, 0x35, 0x37, 0x31, 0x39, 0x62, 0x66, 0x37, 0x62, 0x30, 0x65, 0x64, 0x61, 0x61, 0x66, 0x39, 0x32, 0x65, 0x38, 0x30, 0x65, 0x36, 0x35, 0x65, 0x30, 0x33, 0x35, 0x61, 0x65, 0x35, 0x30, 0x66, 0x31, 0x64, 0x37, 0x61, 0x37, 0x63, 0x32, 0x38, 0x35, 0x34, 0x31, 0x61, 0x64, 0x30, 0x61, 0x31, 0x62, 0x37, 0x66, 0x34, 0x61, 0x39, 0x62, 0x36, 0x34, 0x62, 0x37, 0x32, 0x34, 0x63, 0x61, 0x33, 0x32, 0x33, 0x65, 0x39, 0x31, 0x64, 0x34, 0x65, 0x62, 0x36, 0x37, 0x33, 0x63, 0x36, 0x31, 0x37, 0x63, 0x33, 0x33, 0x39, 0x31, 0x38, 0x36, 0x31, 0x61, 0x65, 0x62, 0x35, 0x66, 0x36, 0x33, 0x30, 0x33, 0x65, 0x65, 0x38, 0x36, 0x62, 0x64, 0x32, 0x62, 0x34, 0x32, 0x34, 0x37, 0x39, 0x64, 0x64, 0x65, 0x31, 0x36, 0x61, 0x31, 0x63, 0x34, 0x37, 0x64, 0x66, 0x37, 0x32, 0x39, 0x65, 0x62, 0x34, 0x62, 0x32, 0x32, 0x62, 0x30, 0x38, 0x37, 0x63, 0x66, 0x61, 0x61, 0x31, 0x62, 0x62, 0x33, 0x31, 0x30, 0x62, 0x38, 0x63, 0x36, 0x38, 0x31, 0x64, 0x36, 0x39, 0x38, 0x34, 0x35, 0x65, 0x66, 0x63, 0x35, 0x30, 0x65, 0x30, 0x36, 0x36, 0x65, 0x35, 0x65, 0x39, 0x38, 0x65, 0x65, 0x32, 0x36, 0x34, 0x35, 0x64, 0x32, 0x36, 0x64, 0x37, 0x32, 0x62, 0x32, 0x39, 0x37, 0x32, 0x64, 0x62, 0x31, 0x39, 0x38, 0x31, 0x64, 0x31, 0x37, 0x62, 0x36, 0x65, 0x38, 0x66, 0x65, 0x62, 0x66, 0x35, 0x38, 0x66, 0x63, 0x34, 0x37, 0x31, 0x64, 0x34, 0x36, 0x34, 0x36, 0x32, 0x30, 0x36, 0x33, 0x38, 0x36, 0x34, 0x65, 0x63, 0x61, 0x39, 0x36, 0x36, 0x36, 0x63, 0x66, 0x31, 0x32, 0x36, 0x63, 0x66, 0x61, 0x33, 0x61, 0x63, 0x33, 0x63, 0x30, 0x39, 0x31, 0x63, 0x33, 0x65, 0x35, 0x65, 0x65, 0x62, 0x38, 0x31, 0x39, 0x39, 0x34, 0x35, 0x38, 0x66, 0x33, 0x30, 0x33, 0x38, 0x35, 0x32, 0x61, 0x61, 0x66, 0x66, 0x66, 0x65, 0x63, 0x39, 0x35, 0x62, 0x31, 0x66, 0x62, 0x64, 0x33, 0x64, 0x35, 0x62, 0x63, 0x63, 0x31, 0x62, 0x33, 0x36, 0x33, 0x32, 0x66, 0x64, 0x30, 0x35, 0x66, 0x33, 0x66, 0x64, 0x38, 0x64, 0x62, 0x63, 0x63, 0x34, 0x34, 0x61, 0x35, 0x36, 0x36, 0x63, 0x31, 0x34, 0x32, 0x38, 0x35, 0x61, 0x66, 0x33, 0x64, 0x66, 0x64, 0x65, 0x38, 0x35, 0x36, 0x30, 0x34, 0x30, 0x34, 0x64, 0x34, 0x31, 0x37, 0x38, 0x64, 0x30, 0x61, 0x64, 0x63, 0x35, 0x64, 0x63, 0x31, 0x35, 0x37, 0x36, 0x63, 0x36, 0x34, 0x31, 0x31, 0x61, 0x32, 0x33, 0x66, 0x35, 0x38, 0x35, 0x65, 0x33, 0x63, 0x33, 0x39, 0x66, 0x35, 0x36, 0x33, 0x61, 0x37, 0x36, 0x33, 0x36, 0x30, 0x30, 0x30, 0x66, 0x63, 0x34, 0x30, 0x35, 0x32, 0x38, 0x37, 0x38, 0x64, 0x62, 0x35, 0x36, 0x32, 0x64, 0x66, 0x31, 0x34, 0x35, 0x63, 0x39, 0x64, 0x32, 0x66, 0x34, 0x31, 0x31, 0x36, 0x38, 0x65, 0x32, 0x31, 0x65, 0x64, 0x35, 0x35, 0x39, 0x31, 0x66, 0x62, 0x64, 0x32, 0x64, 0x64, 0x61, 0x64, 0x64, 0x34, 0x33, 0x33, 0x37, 0x33, 0x37, 0x36, 0x66, 0x63, 0x34, 0x36, 0x64, 0x66, 0x64, 0x38, 0x33, 0x32, 0x37, 0x61, 0x37, 0x62, 0x36, 0x34, 0x63, 0x30, 0x63, 0x64, 0x30, 0x37, 0x39, 0x35, 0x38, 0x38, 0x33, 0x62, 0x62, 0x37, 0x33, 0x39, 0x61, 0x35, 0x39, 0x64, 0x32, 0x61, 0x66, 0x65, 0x61, 0x34, 0x66, 0x66, 0x31, 0x64, 0x31, 0x38, 0x39, 0x32, 0x34, 0x32, 0x31, 0x36, 0x34, 0x64, 0x32, 0x35, 0x63, 0x66, 0x62, 0x64, 0x61, 0x63, 0x61, 0x38, 0x37, 0x38, 0x61, 0x36, 0x37, 0x62, 0x35, 0x37, 0x32, 0x30, 0x39, 0x30, 0x61, 0x37, 0x36, 0x30, 0x61, 0x62, 0x30, 0x63, 0x66, 0x66, 0x37, 0x61, 0x64, 0x66, 0x62, 0x31, 0x64, 0x32, 0x39, 0x33, 0x30, 0x32, 0x37, 0x62, 0x31, 0x35, 0x33, 0x39, 0x64, 0x38, 0x39, 0x31, 0x36, 0x38, 0x31, 0x36, 0x32, 0x34, 0x62, 0x38, 0x62, 0x32, 0x64, 0x38, 0x65, 0x62, 0x36, 0x61, 0x30, 0x30, 0x33, 0x64, 0x38, 0x64, 0x62, 0x61, 0x36, 0x62, 0x64, 0x32, 0x35, 0x62, 0x34, 0x38, 0x63, 0x65, 0x35, 0x33, 0x66, 0x31, 0x31, 0x34, 0x36, 0x30, 0x32, 0x33, 0x35, 0x37, 0x61, 0x33, 0x36, 0x36, 0x66, 0x65, 0x31, 0x39, 0x31, 0x30, 0x32, 0x62, 0x62, 0x63, 0x62, 0x32, 0x38, 0x66, 0x66, 0x62, 0x61, 0x37, 0x61, 0x38, 0x35, 0x64, 0x65, 0x36, 0x30, 0x38, 0x37, 0x38, 0x30, 0x38, 0x37, 0x30, 0x31, 0x62, 0x66, 0x32, 0x61, 0x33, 0x31, 0x30, 0x65, 0x32, 0x65, 0x32, 0x61, 0x34, 0x36, 0x30, 0x64, 0x36, 0x31, 0x38, 0x38, 0x39, 0x36, 0x63, 0x64, 0x61, 0x37, 0x37, 0x37, 0x66, 0x62, 0x30, 0x36, 0x37, 0x65, 0x38, 0x63, 0x37, 0x33, 0x33, 0x65, 0x38, 0x64, 0x39, 0x66, 0x66, 0x31, 0x66, 0x38, 0x38, 0x38, 0x61, 0x30, 0x35, 0x33, 0x34, 0x64, 0x66, 0x33, 0x63, 0x62, 0x31, 0x36, 0x31, 0x34, 0x37, 0x35, 0x31, 0x38, 0x38, 0x30, 0x36, 0x32, 0x37, 0x32, 0x32, 0x66, 0x63, 0x62, 0x37, 0x65, 0x31, 0x66, 0x64, 0x32, 0x37, 0x66, 0x30, 0x34, 0x31, 0x65, 0x65, 0x61, 0x64, 0x33, 0x32, 0x39, 0x39, 0x65, 0x38, 0x62, 0x30, 0x62, 0x30, 0x66, 0x64, 0x62, 0x33, 0x66, 0x63, 0x65, 0x61, 0x63, 0x65, 0x33, 0x38, 0x31, 0x31, 0x66, 0x32, 0x34, 0x63, 0x39, 0x61, 0x62, 0x36, 0x61, 0x37, 0x66, 0x33, 0x63, 0x39, 0x64, 0x38, 0x39, 0x64, 0x39, 0x30, 0x64, 0x61, 0x65, 0x63, 0x36, 0x39, 0x34, 0x34, 0x39, 0x32, 0x63, 0x62, 0x33, 0x66, 0x35, 0x61, 0x61, 0x66, 0x62, 0x64, 0x37, 0x30, 0x61, 0x35, 0x62, 0x64, 0x38, 0x64, 0x31, 0x36, 0x32, 0x32, 0x62, 0x33, 0x33, 0x38, 0x66, 0x32, 0x30, 0x33, 0x34, 0x39, 0x66, 0x63, 0x62, 0x62, 0x37, 0x61, 0x34, 0x30, 0x63, 0x32, 0x38, 0x34, 0x66, 0x65, 0x65, 0x65, 0x34, 0x66, 0x65, 0x62, 0x32, 0x37, 0x32, 0x63, 0x62, 0x61, 0x61, 0x66, 0x64, 0x37, 0x63, 0x32, 0x65, 0x38, 0x63, 0x63, 0x61, 0x65, 0x65, 0x30, 0x65, 0x35, 0x65, 0x36, 0x64, 0x65, 0x63, 0x31, 0x63, 0x32, 0x62, 0x35, 0x35, 0x63, 0x30, 0x66, 0x34, 0x39, 0x63, 0x37, 0x32, 0x64, 0x62, 0x33, 0x37, 0x30, 0x65, 0x37, 0x61, 0x61, 0x32, 0x38, 0x39, 0x61, 0x30, 0x31, 0x38, 0x34, 0x34, 0x33, 0x35, 0x34, 0x35, 0x38, 0x61, 0x37, 0x32, 0x65, 0x34, 0x66, 0x31, 0x30, 0x33, 0x32, 0x65, 0x30, 0x66, 0x38, 0x61, 0x63, 0x32, 0x34, 0x37, 0x30, 0x37, 0x35, 0x63, 0x62, 0x34, 0x34, 0x65, 0x30, 0x63, 0x31, 0x37, 0x64, 0x36, 0x34, 0x30, 0x65, 0x64, 0x32, 0x62, 0x36, 0x61, 0x36, 0x31, 0x32, 0x63, 0x31, 0x36, 0x63, 0x33, 0x39, 0x65, 0x65, 0x35, 0x66, 0x62, 0x31, 0x35, 0x39, 0x66, 0x31, 0x62, 0x66, 0x35, 0x66, 0x63, 0x37, 0x32, 0x32, 0x36, 0x33, 0x62, 0x30, 0x30, 0x66, 0x62, 0x37, 0x63, 0x38, 0x39, 0x35, 0x38, 0x35, 0x32, 0x34, 0x65, 0x34, 0x65, 0x61, 0x63, 0x61, 0x64, 0x38, 0x38, 0x30, 0x36, 0x63, 0x66, 0x37, 0x61, 0x30, 0x39, 0x64, 0x39, 0x61, 0x65, 0x38, 0x36, 0x38, 0x62, 0x36, 0x31, 0x62, 0x61, 0x39, 0x35, 0x38, 0x36, 0x39, 0x35, 0x35, 0x37, 0x62, 0x37, 0x66, 0x34, 0x38, 0x61, 0x61, 0x38, 0x30, 0x66, 0x37, 0x65, 0x63, 0x37, 0x64, 0x37, 0x32, 0x64, 0x31, 0x38, 0x34, 0x62, 0x61, 0x36, 0x61, 0x38, 0x63, 0x32, 0x66, 0x33, 0x37, 0x38, 0x65, 0x33, 0x31, 0x65, 0x62, 0x65, 0x32, 0x35, 0x39, 0x39, 0x65, 0x61, 0x37, 0x30, 0x37, 0x37, 0x36, 0x39, 0x63, 0x32, 0x65, 0x63, 0x39, 0x64, 0x38, 0x34, 0x36, 0x32, 0x39, 0x61, 0x36, 0x64, 0x61, 0x39, 0x63, 0x31, 0x30, 0x34, 0x36, 0x63, 0x30, 0x31, 0x32, 0x34, 0x35, 0x34, 0x34, 0x33, 0x36, 0x36, 0x37, 0x39, 0x61, 0x38, 0x38, 0x38, 0x65, 0x62, 0x32, 0x34, 0x63, 0x61, 0x64, 0x38, 0x30, 0x36, 0x62, 0x37, 0x32, 0x30, 0x66, 0x30, 0x31, 0x32, 0x65, 0x31, 0x37, 0x33, 0x35, 0x37, 0x31, 0x30, 0x66, 0x66, 0x34, 0x38, 0x63, 0x35, 0x63, 0x31, 0x33, 0x31, 0x65, 0x32, 0x31, 0x62, 0x32, 0x64, 0x65, 0x63, 0x63, 0x36, 0x62, 0x65, 0x32, 0x37, 0x61, 0x63, 0x30, 0x61, 0x31, 0x37, 0x65, 0x30, 0x31, 0x30, 0x35, 0x38, 0x36, 0x34, 0x30, 0x37, 0x65, 0x66, 0x65, 0x31, 0x32, 0x30, 0x62, 0x37, 0x65, 0x62, 0x64, 0x36, 0x36, 0x63, 0x62, 0x65, 0x34, 0x38, 0x36, 0x61, 0x30, 0x66, 0x66, 0x61, 0x35, 0x30, 0x36, 0x66, 0x62, 0x31, 0x35, 0x31, 0x35, 0x30, 0x63, 0x34, 0x37, 0x34, 0x62, 0x63, 0x62, 0x63, 0x64, 0x34, 0x63, 0x31, 0x37, 0x32, 0x39, 0x34, 0x32, 0x62, 0x62, 0x36, 0x34, 0x33, 0x66, 0x36, 0x30, 0x34, 0x33, 0x34, 0x62, 0x38, 0x30, 0x61, 0x33, 0x66, 0x36, 0x65, 0x34, 0x66, 0x66, 0x39, 0x30, 0x30, 0x61, 0x63, 0x34, 0x34, 0x61, 0x30, 0x62, 0x31, 0x31, 0x66, 0x35, 0x36, 0x34, 0x37, 0x65, 0x38, 0x64, 0x39, 0x35, 0x36, 0x32, 0x38, 0x63, 0x35, 0x39, 0x30, 0x36, 0x38, 0x63, 0x66, 0x38, 0x66, 0x66, 0x66, 0x35, 0x32, 0x34, 0x31, 0x38, 0x33, 0x66, 0x31, 0x35, 0x65, 0x62, 0x39, 0x39, 0x38, 0x31, 0x30, 0x65, 0x36, 0x64, 0x64, 0x33, 0x65, 0x36, 0x66, 0x31, 0x33, 0x64, 0x62, 0x61, 0x32, 0x31, 0x33, 0x63, 0x62, 0x32, 0x37, 0x30, 0x33, 0x62, 0x37, 0x66, 0x30, 0x31, 0x33, 0x31, 0x62, 0x65, 0x66, 0x37, 0x63, 0x66, 0x37, 0x35, 0x31, 0x36, 0x34, 0x63, 0x35, 0x39, 0x65, 0x63, 0x65, 0x62, 0x31, 0x32, 0x37, 0x37, 0x35, 0x33, 0x32, 0x32, 0x32, 0x37, 0x31, 0x36, 0x39, 0x31, 0x31, 0x34, 0x35, 0x35, 0x39, 0x61, 0x30, 0x33, 0x31, 0x62, 0x35, 0x37, 0x61, 0x64, 0x62, 0x61, 0x37, 0x38, 0x38, 0x61, 0x64, 0x66, 0x32, 0x31, 0x33, 0x39, 0x64, 0x35, 0x63, 0x33, 0x33, 0x31, 0x30, 0x32, 0x64, 0x33, 0x36, 0x38, 0x33, 0x31, 0x63, 0x36, 0x35, 0x31, 0x30, 0x61, 0x37, 0x37, 0x65, 0x35, 0x63, 0x37, 0x32, 0x66, 0x35, 0x64, 0x36, 0x66, 0x30, 0x32, 0x63, 0x38, 0x62, 0x36, 0x30, 0x30, 0x65, 0x63, 0x38, 0x36, 0x36, 0x62, 0x61, 0x31, 0x61, 0x35, 0x37, 0x63, 0x35, 0x30, 0x39, 0x32, 0x33, 0x35, 0x63, 0x31, 0x37, 0x37, 0x62, 0x39, 0x66, 0x64, 0x39, 0x31, 0x66, 0x37, 0x61, 0x31, 0x34, 0x37, 0x65, 0x33, 0x63, 0x34, 0x35, 0x31, 0x33, 0x33, 0x31, 0x62, 0x31, 0x63, 0x32, 0x63, 0x32, 0x37, 0x32, 0x34, 0x66, 0x32, 0x36, 0x32, 0x66, 0x39, 0x33, 0x37, 0x39, 0x30, 0x64, 0x62, 0x35, 0x38, 0x30, 0x33, 0x30, 0x33, 0x66, 0x39, 0x63, 0x63, 0x30, 0x37, 0x62, 0x63, 0x64, 0x31, 0x36, 0x38, 0x35, 0x37, 0x64, 0x62, 0x32, 0x32, 0x31, 0x32, 0x31, 0x32, 0x62, 0x32, 0x66, 0x63, 0x35, 0x33, 0x30, 0x31, 0x64, 0x66, 0x35, 0x64, 0x30, 0x61, 0x61, 0x33, 0x33, 0x38, 0x64, 0x37, 0x62, 0x37, 0x32, 0x66, 0x64, 0x31, 0x63, 0x38, 0x66, 0x37, 0x35, 0x33, 0x65, 0x66, 0x63, 0x38, 0x64, 0x61, 0x35, 0x64, 0x35, 0x61, 0x32, 0x61, 0x66, 0x66, 0x32, 0x30, 0x34, 0x32, 0x64, 0x39, 0x31, 0x38, 0x35, 0x64, 0x65, 0x38, 0x30, 0x39, 0x39, 0x61, 0x35, 0x31, 0x65, 0x62, 0x31, 0x62, 0x61, 0x32, 0x61, 0x37, 0x38, 0x30, 0x62, 0x32, 0x65, 0x30, 0x34, 0x64, 0x66, 0x65, 0x61, 0x66, 0x62, 0x33, 0x32, 0x64, 0x65, 0x62, 0x36, 0x36, 0x65, 0x39, 0x63, 0x35, 0x66, 0x38, 0x31, 0x62, 0x39, 0x39, 0x38, 0x30, 0x33, 0x39, 0x66, 0x64, 0x38, 0x31, 0x35, 0x65, 0x32, 0x34, 0x36, 0x32, 0x31, 0x37, 0x35, 0x39, 0x37, 0x36, 0x66, 0x66, 0x64, 0x35, 0x39, 0x61, 0x38, 0x61, 0x61, 0x39, 0x32, 0x30, 0x30, 0x62, 0x66, 0x31, 0x64, 0x30, 0x38, 0x37, 0x38, 0x66, 0x61, 0x37, 0x66, 0x39, 0x65, 0x33, 0x65, 0x38, 0x65, 0x63, 0x31, 0x62, 0x62, 0x36, 0x64, 0x37, 0x66, 0x35, 0x37, 0x38, 0x36, 0x36, 0x34, 0x34, 0x64, 0x62, 0x37, 0x33, 0x31, 0x30, 0x34, 0x61, 0x66, 0x32, 0x39, 0x36, 0x63, 0x35, 0x37, 0x39, 0x35, 0x32, 0x30, 0x31, 0x61, 0x33, 0x30, 0x37, 0x31, 0x33, 0x34, 0x30, 0x30, 0x34, 0x61, 0x39, 0x30, 0x62, 0x34, 0x34, 0x62, 0x66, 0x62, 0x61, 0x66, 0x62, 0x64, 0x31, 0x32, 0x32, 0x38, 0x66, 0x39, 0x32, 0x65, 0x39, 0x62, 0x33, 0x36, 0x36, 0x62, 0x39, 0x38, 0x66, 0x64, 0x66, 0x64, 0x61, 0x31, 0x31, 0x38, 0x33, 0x62, 0x61, 0x37, 0x63, 0x66, 0x65, 0x33, 0x30, 0x30, 0x64, 0x61, 0x65, 0x61, 0x38, 0x61, 0x38, 0x35, 0x38, 0x33, 0x35, 0x32, 0x66, 0x61, 0x35, 0x35, 0x35, 0x39, 0x30, 0x36, 0x39, 0x64, 0x30, 0x31, 0x32, 0x39, 0x65, 0x38, 0x39, 0x36, 0x64, 0x65, 0x37, 0x32, 0x38, 0x32, 0x66, 0x31, 0x65, 0x64, 0x30, 0x39, 0x30, 0x62, 0x66, 0x31, 0x61, 0x38, 0x61, 0x62, 0x37, 0x35, 0x66, 0x32, 0x66, 0x34, 0x30, 0x38, 0x32, 0x65, 0x37, 0x63, 0x63, 0x33, 0x63, 0x37, 0x34, 0x33, 0x36, 0x30, 0x32, 0x64, 0x31, 0x38, 0x33, 0x32, 0x33, 0x66, 0x33, 0x35, 0x36, 0x33, 0x64, 0x66, 0x31, 0x38, 0x38, 0x36, 0x62, 0x66, 0x37, 0x66, 0x61, 0x62, 0x61, 0x61, 0x32, 0x37, 0x33, 0x63, 0x36, 0x38, 0x36, 0x65, 0x32, 0x63, 0x38, 0x65, 0x65, 0x37, 0x37, 0x65, 0x37, 0x61, 0x33, 0x63, 0x63, 0x64, 0x63, 0x31, 0x62, 0x61, 0x65, 0x36, 0x65, 0x66, 0x33, 0x37, 0x36, 0x66, 0x37, 0x34, 0x31, 0x32, 0x35, 0x64, 0x64, 0x63, 0x30, 0x30, 0x31, 0x65, 0x30, 0x61, 0x64, 0x35, 0x35, 0x36, 0x35, 0x39, 0x62, 0x36, 0x36, 0x34, 0x30, 0x35, 0x39, 0x61, 0x36, 0x35, 0x37, 0x32, 0x39, 0x35, 0x35, 0x38, 0x61, 0x31, 0x38, 0x35, 0x33, 0x62, 0x63, 0x30, 0x39, 0x64, 0x32, 0x30, 0x30, 0x65, 0x66, 0x34, 0x31, 0x63, 0x63, 0x39, 0x30, 0x38, 0x36, 0x61, 0x62, 0x38, 0x37, 0x63, 0x30, 0x32, 0x30, 0x30, 0x38, 0x36, 0x39, 0x35, 0x63, 0x34, 0x33, 0x63, 0x39, 0x37, 0x32, 0x64, 0x36, 0x38, 0x62, 0x65, 0x33, 0x38, 0x35, 0x64, 0x32, 0x34, 0x37, 0x64, 0x35, 0x66, 0x37, 0x32, 0x65, 0x34, 0x37, 0x37, 0x38, 0x35, 0x61, 0x32, 0x35, 0x33, 0x31, 0x34, 0x65, 0x34, 0x36, 0x62, 0x38, 0x61, 0x38, 0x64, 0x31, 0x35, 0x39, 0x35, 0x65, 0x62, 0x61, 0x34, 0x32, 0x36, 0x37, 0x66, 0x39, 0x30, 0x65, 0x31, 0x36, 0x62, 0x39, 0x37, 0x64, 0x39, 0x64, 0x32, 0x39, 0x32, 0x30, 0x30, 0x35, 0x34, 0x34, 0x32, 0x63, 0x61, 0x64, 0x65, 0x32, 0x39, 0x64, 0x38, 0x63, 0x37, 0x35, 0x64, 0x33, 0x34, 0x64, 0x39, 0x33, 0x65, 0x31, 0x31, 0x33, 0x38, 0x32, 0x38, 0x30, 0x64, 0x34, 0x34, 0x33, 0x36, 0x31, 0x37, 0x30, 0x39, 0x32, 0x34, 0x33, 0x32, 0x62, 0x64, 0x30, 0x36, 0x30, 0x36, 0x32, 0x38, 0x63, 0x30, 0x65, 0x36, 0x37, 0x34, 0x36, 0x34, 0x66, 0x35, 0x39, 0x64, 0x35, 0x63, 0x38, 0x37, 0x35, 0x34, 0x34, 0x66, 0x35, 0x31, 0x65, 0x37, 0x36, 0x30, 0x66, 0x30, 0x30, 0x62, 0x31, 0x30, 0x30, 0x64, 0x66, 0x33, 0x63, 0x61, 0x31, 0x66, 0x66, 0x32, 0x62, 0x38, 0x38, 0x38, 0x37, 0x38, 0x34, 0x31, 0x36, 0x65, 0x65, 0x32, 0x31, 0x64, 0x39, 0x38, 0x31, 0x64, 0x33, 0x37, 0x36, 0x33, 0x35, 0x31, 0x61, 0x66, 0x39, 0x62, 0x62, 0x30, 0x35, 0x36, 0x33, 0x33, 0x63, 0x65, 0x33, 0x63, 0x36, 0x66, 0x36, 0x34, 0x64, 0x37, 0x61, 0x63, 0x64, 0x61, 0x32, 0x30, 0x34, 0x31, 0x63, 0x65, 0x35, 0x36, 0x34, 0x61, 0x63, 0x31, 0x64, 0x66, 0x32, 0x61, 0x30, 0x63, 0x63, 0x61, 0x31, 0x36, 0x65, 0x65, 0x39, 0x63, 0x32, 0x36, 0x36, 0x34, 0x64, 0x33, 0x31, 0x33, 0x34, 0x30, 0x35, 0x30, 0x62, 0x36, 0x39, 0x32, 0x63, 0x37, 0x66, 0x38, 0x63, 0x35, 0x37, 0x31, 0x32, 0x66, 0x62, 0x30, 0x34, 0x62, 0x37, 0x30, 0x64, 0x39, 0x65, 0x36, 0x61, 0x37, 0x31, 0x66, 0x32, 0x30, 0x63, 0x38, 0x31, 0x31, 0x33, 0x30, 0x64, 0x65, 0x37, 0x36, 0x33, 0x36, 0x39, 0x62, 0x37, 0x39, 0x65, 0x30, 0x64, 0x39, 0x38, 0x63, 0x65, 0x66, 0x35, 0x31, 0x39, 0x37, 0x63, 0x35, 0x34, 0x65, 0x33, 0x32, 0x39, 0x65, 0x62, 0x31, 0x63, 0x33, 0x34, 0x36, 0x65, 0x31, 0x62, 0x63, 0x63, 0x61, 0x32, 0x38, 0x31, 0x34, 0x36, 0x30, 0x61, 0x33, 0x34, 0x36, 0x39, 0x65, 0x35, 0x63, 0x37, 0x32, 0x38, 0x38, 0x34, 0x62, 0x64, 0x63, 0x65, 0x66, 0x63, 0x38, 0x65, 0x31, 0x36, 0x62, 0x34, 0x63, 0x38, 0x61, 0x30, 0x61, 0x39, 0x37, 0x62, 0x36, 0x65, 0x65, 0x61, 0x31, 0x65, 0x39, 0x37, 0x37, 0x36, 0x65, 0x36, 0x32, 0x30, 0x38, 0x33, 0x65, 0x34, 0x62, 0x35, 0x36, 0x35, 0x32, 0x33, 0x65, 0x36, 0x61, 0x61, 0x30, 0x36, 0x39, 0x66, 0x33, 0x66, 0x39, 0x37, 0x38, 0x61, 0x33, 0x37, 0x32, 0x64, 0x66, 0x32, 0x30, 0x65, 0x36, 0x66, 0x33, 0x65, 0x61, 0x62, 0x31, 0x37, 0x33, 0x37, 0x65, 0x61, 0x36, 0x34, 0x37, 0x38, 0x35, 0x35, 0x62, 0x37, 0x39, 0x30, 0x37, 0x36, 0x65, 0x37, 0x38, 0x34, 0x65, 0x33, 0x39, 0x34, 0x36, 0x63, 0x39, 0x34, 0x39, 0x33, 0x62, 0x65, 0x38, 0x63, 0x38, 0x35, 0x63, 0x64, 0x36, 0x66, 0x65, 0x32, 0x65, 0x36, 0x34, 0x61, 0x32, 0x35, 0x30, 0x37, 0x32, 0x30, 0x32, 0x35, 0x36, 0x66, 0x32, 0x39, 0x35, 0x65, 0x38, 0x61, 0x65, 0x65, 0x36, 0x31, 0x38, 0x30, 0x35, 0x62, 0x34, 0x33, 0x62, 0x35, 0x34, 0x37, 0x63, 0x30, 0x66, 0x31, 0x34, 0x38, 0x30, 0x34, 0x65, 0x30, 0x61, 0x61, 0x31, 0x31, 0x61, 0x64, 0x37, 0x38, 0x32, 0x35, 0x34, 0x64, 0x34, 0x32, 0x62, 0x63, 0x35, 0x34, 0x64, 0x38, 0x65, 0x31, 0x61, 0x39, 0x32, 0x65, 0x39, 0x37, 0x32, 0x32, 0x62, 0x62, 0x33, 0x62, 0x30, 0x38, 0x32, 0x32, 0x63, 0x66, 0x33, 0x31, 0x36, 0x35, 0x33, 0x32, 0x39, 0x65, 0x33, 0x34, 0x64, 0x36, 0x30, 0x64, 0x39, 0x61, 0x63, 0x32, 0x61, 0x66, 0x32, 0x34, 0x39, 0x30, 0x63, 0x62, 0x65, 0x34, 0x33, 0x36, 0x37, 0x64, 0x36, 0x31, 0x39, 0x66, 0x34, 0x34, 0x61, 0x65, 0x62, 0x65, 0x36, 0x34, 0x65, 0x32, 0x62, 0x63, 0x35, 0x32, 0x38, 0x33, 0x31, 0x61, 0x35, 0x32, 0x64, 0x62, 0x32, 0x38, 0x64, 0x35, 0x32, 0x39, 0x33, 0x32, 0x31, 0x33, 0x31, 0x62, 0x36, 0x61, 0x62, 0x63, 0x35, 0x63, 0x38, 0x37, 0x31, 0x34, 0x63, 0x65, 0x30, 0x63, 0x37, 0x64, 0x31, 0x31, 0x33, 0x37, 0x61, 0x34, 0x39, 0x34, 0x38, 0x35, 0x32, 0x66, 0x61, 0x66, 0x65, 0x33, 0x66, 0x34, 0x35, 0x38, 0x66, 0x34, 0x63, 0x37, 0x34, 0x39, 0x39, 0x32, 0x34, 0x35, 0x64, 0x36, 0x32, 0x31, 0x33, 0x35, 0x64, 0x62, 0x38, 0x32, 0x39, 0x61, 0x36, 0x35, 0x33, 0x65, 0x36, 0x64, 0x61, 0x65, 0x39, 0x38, 0x32, 0x33, 0x33, 0x31, 0x31, 0x64, 0x33, 0x38, 0x32, 0x65, 0x62, 0x61, 0x62, 0x64, 0x61, 0x31, 0x64, 0x66, 0x66, 0x35, 0x63, 0x66, 0x35, 0x39, 0x34, 0x38, 0x62, 0x63, 0x39, 0x36, 0x30, 0x33, 0x36, 0x30, 0x64, 0x62, 0x37, 0x61, 0x37, 0x38, 0x37, 0x32, 0x34, 0x38, 0x64, 0x65, 0x33, 0x64, 0x32, 0x63, 0x61, 0x32, 0x36, 0x61, 0x36, 0x37, 0x64, 0x66, 0x61, 0x30, 0x36, 0x32, 0x62, 0x39, 0x33, 0x64, 0x34, 0x33, 0x37, 0x63, 0x32, 0x66, 0x35, 0x66, 0x61, 0x37, 0x31, 0x63, 0x36, 0x38, 0x38, 0x61, 0x35, 0x31, 0x33, 0x37, 0x35, 0x62, 0x32, 0x37, 0x32, 0x33, 0x37, 0x33, 0x30, 0x38, 0x31, 0x38, 0x30, 0x64, 0x39, 0x38, 0x37, 0x66, 0x33, 0x37, 0x32, 0x61, 0x31, 0x39, 0x38, 0x39, 0x36, 0x65, 0x36, 0x64, 0x62, 0x65, 0x33, 0x39, 0x31, 0x32, 0x34, 0x35, 0x35, 0x31, 0x31, 0x34, 0x64, 0x64, 0x31, 0x30, 0x38, 0x34, 0x33, 0x35, 0x31, 0x39, 0x37, 0x63, 0x33, 0x37, 0x38, 0x32, 0x33, 0x37, 0x62, 0x33, 0x36, 0x61, 0x35, 0x61, 0x30, 0x61, 0x36, 0x31, 0x37, 0x35, 0x62, 0x62, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x38, 0x61, 0x64, 0x37, 0x32, 0x66, 0x34, 0x61, 0x39, 0x35, 0x31, 0x30, 0x65, 0x37, 0x33, 0x35, 0x62, 0x65, 0x64, 0x35, 0x63, 0x65, 0x31, 0x33, 0x32, 0x30, 0x65, 0x36, 0x62, 0x37, 0x30, 0x35, 0x61, 0x62, 0x35, 0x64, 0x39, 0x33, 0x30, 0x36, 0x65, 0x63, 0x64, 0x39, 0x61, 0x39, 0x33, 0x35, 0x65, 0x36, 0x32, 0x64, 0x61, 0x64, 0x37, 0x36, 0x39, 0x39, 0x31, 0x30, 0x62, 0x32, 0x61, 0x37, 0x34, 0x61, 0x34, 0x37, 0x32, 0x30, 0x64, 0x32, 0x62, 0x39, 0x64, 0x61, 0x37, 0x61, 0x63, 0x65, 0x34, 0x66, 0x38, 0x66, 0x64, 0x31, 0x38, 0x38, 0x63, 0x37, 0x30, 0x33, 0x32, 0x63, 0x36, 0x66, 0x32, 0x62, 0x39, 0x66, 0x31, 0x62, 0x35, 0x30, 0x63, 0x33, 0x61, 0x36, 0x39, 0x37, 0x65, 0x63, 0x36, 0x31, 0x39, 0x32, 0x66, 0x62, 0x65, 0x39, 0x38, 0x37, 0x31, 0x36, 0x35, 0x36, 0x39, 0x37, 0x34, 0x38, 0x61, 0x36, 0x62, 0x66, 0x33, 0x65, 0x39, 0x31, 0x34, 0x37, 0x32, 0x32, 0x66, 0x35, 0x38, 0x64, 0x64, 0x64, 0x66, 0x64, 0x34, 0x61, 0x38, 0x32, 0x30, 0x64, 0x31, 0x32, 0x66, 0x61, 0x39, 0x65, 0x66, 0x38, 0x35, 0x65, 0x64, 0x62, 0x31, 0x38, 0x64, 0x30, 0x37, 0x34, 0x31, 0x36, 0x33, 0x66, 0x33, 0x34, 0x32, 0x66, 0x39, 0x35, 0x62, 0x36, 0x66, 0x62, 0x38, 0x30, 0x36, 0x62, 0x35, 0x38, 0x38, 0x37, 0x32, 0x62, 0x36, 0x35, 0x64, 0x36, 0x37, 0x32, 0x31, 0x34, 0x38, 0x38, 0x39, 0x32, 0x38, 0x34, 0x38, 0x30, 0x36, 0x34, 0x31, 0x31, 0x63, 0x64, 0x33, 0x34, 0x66, 0x62, 0x31, 0x31, 0x64, 0x31, 0x64, 0x63, 0x30, 0x39, 0x39, 0x31, 0x61, 0x66, 0x63, 0x34, 0x36, 0x62, 0x35, 0x66, 0x35, 0x33, 0x30, 0x37, 0x36, 0x36, 0x36, 0x66, 0x33, 0x35, 0x34, 0x33, 0x32, 0x37, 0x37, 0x34, 0x30, 0x37, 0x32, 0x65, 0x64, 0x66, 0x35, 0x36, 0x34, 0x32, 0x31, 0x62, 0x31, 0x34, 0x61, 0x30, 0x31, 0x35, 0x35, 0x34, 0x30, 0x33, 0x66, 0x64, 0x61, 0x38, 0x39, 0x62, 0x36, 0x64, 0x32, 0x66, 0x64, 0x39, 0x30, 0x33, 0x32, 0x36, 0x38, 0x64, 0x65, 0x63, 0x32, 0x32, 0x39, 0x30, 0x34, 0x62, 0x32, 0x66, 0x38, 0x64, 0x61, 0x62, 0x36, 0x38, 0x30, 0x32, 0x62, 0x61, 0x62, 0x30, 0x35, 0x38, 0x38, 0x37, 0x32, 0x35, 0x64, 0x63, 0x33, 0x65, 0x63, 0x32, 0x34, 0x38, 0x64, 0x39, 0x37, 0x65, 0x36, 0x32, 0x37, 0x37, 0x64, 0x38, 0x64, 0x36, 0x39, 0x38, 0x39, 0x65, 0x63, 0x31, 0x32, 0x30, 0x34, 0x37, 0x32, 0x33, 0x35, 0x30, 0x30, 0x63, 0x34, 0x32, 0x34, 0x30, 0x66, 0x36, 0x33, 0x62, 0x61, 0x34, 0x35, 0x66, 0x32, 0x35, 0x38, 0x63, 0x39, 0x35, 0x63, 0x62, 0x32, 0x33, 0x36, 0x62, 0x39, 0x37, 0x32, 0x36, 0x38, 0x63, 0x35, 0x61, 0x61, 0x63, 0x39, 0x35, 0x32, 0x34, 0x34, 0x37, 0x39, 0x35, 0x39, 0x32, 0x30, 0x39, 0x66, 0x34, 0x30, 0x61, 0x66, 0x66, 0x36, 0x38, 0x62, 0x31, 0x34, 0x63, 0x31, 0x35, 0x32, 0x65, 0x33, 0x34, 0x66, 0x66, 0x66, 0x66, 0x63, 0x36, 0x63, 0x32, 0x35, 0x66, 0x39, 0x39, 0x64, 0x61, 0x35, 0x37, 0x39, 0x30, 0x31, 0x31, 0x39, 0x31, 0x62, 0x66, 0x39, 0x35, 0x61, 0x37, 0x34, 0x62, 0x62, 0x62, 0x30, 0x36, 0x37, 0x66, 0x62, 0x33, 0x35, 0x36, 0x66, 0x66, 0x65, 0x66, 0x63, 0x62, 0x66, 0x37, 0x64, 0x32, 0x37, 0x62, 0x66, 0x65, 0x64, 0x64, 0x39, 0x38, 0x33, 0x61, 0x61, 0x63, 0x36, 0x37, 0x39, 0x30, 0x37, 0x32, 0x36, 0x66, 0x39, 0x61, 0x35, 0x62, 0x64, 0x36, 0x63, 0x63, 0x62, 0x34, 0x39, 0x35, 0x63, 0x62, 0x34, 0x32, 0x66, 0x38, 0x36, 0x37, 0x32, 0x32, 0x30, 0x36, 0x37, 0x61, 0x32, 0x37, 0x34, 0x34, 0x63, 0x35, 0x35, 0x36, 0x31, 0x30, 0x32, 0x64, 0x39, 0x38, 0x38, 0x33, 0x38, 0x37, 0x33, 0x34, 0x37, 0x34, 0x32, 0x39, 0x33, 0x35, 0x65, 0x64, 0x35, 0x35, 0x62, 0x38, 0x66, 0x64, 0x30, 0x33, 0x61, 0x30, 0x34, 0x38, 0x35, 0x64, 0x30, 0x32, 0x62, 0x32, 0x39, 0x33, 0x32, 0x32, 0x37, 0x62, 0x38, 0x66, 0x63, 0x34, 0x36, 0x37, 0x32, 0x61, 0x39, 0x61, 0x32, 0x37, 0x31, 0x30, 0x62, 0x36, 0x39, 0x39, 0x34, 0x39, 0x33, 0x66, 0x35, 0x36, 0x36, 0x64, 0x38, 0x35, 0x66, 0x31, 0x36, 0x61, 0x34, 0x65, 0x65, 0x38, 0x36, 0x35, 0x34, 0x63, 0x62, 0x36, 0x32, 0x36, 0x63, 0x33, 0x38, 0x36, 0x66, 0x66, 0x31, 0x38, 0x35, 0x63, 0x61, 0x30, 0x30, 0x65, 0x35, 0x31, 0x63, 0x64, 0x38, 0x65, 0x39, 0x38, 0x35, 0x66, 0x33, 0x36, 0x33, 0x61, 0x65, 0x63, 0x33, 0x64, 0x63, 0x61, 0x33, 0x39, 0x32, 0x65, 0x36, 0x62, 0x62, 0x34, 0x31, 0x31, 0x36, 0x37, 0x34, 0x32, 0x66, 0x62, 0x37, 0x62, 0x31, 0x61, 0x33, 0x66, 0x61, 0x37, 0x37, 0x36, 0x33, 0x61, 0x33, 0x65, 0x65, 0x61, 0x65, 0x66, 0x63, 0x66, 0x36, 0x36, 0x31, 0x32, 0x62, 0x35, 0x33, 0x64, 0x30, 0x39, 0x65, 0x64, 0x66, 0x63, 0x39, 0x38, 0x34, 0x35, 0x35, 0x37, 0x32, 0x31, 0x64, 0x38, 0x30, 0x33, 0x34, 0x39, 0x38, 0x65, 0x33, 0x32, 0x34, 0x33, 0x38, 0x34, 0x33, 0x66, 0x62, 0x62, 0x38, 0x37, 0x63, 0x36, 0x32, 0x36, 0x34, 0x32, 0x35, 0x31, 0x39, 0x37, 0x34, 0x35, 0x66, 0x33, 0x36, 0x38, 0x38, 0x66, 0x31, 0x65, 0x31, 0x38, 0x32, 0x31, 0x63, 0x65, 0x64, 0x66, 0x32, 0x62, 0x35, 0x38, 0x39, 0x61, 0x63, 0x32, 0x61, 0x35, 0x64, 0x32, 0x65, 0x36, 0x38, 0x36, 0x36, 0x65, 0x33, 0x32, 0x64, 0x65, 0x37, 0x33, 0x31, 0x35, 0x38, 0x32, 0x65, 0x63, 0x65, 0x66, 0x35, 0x66, 0x32, 0x63, 0x61, 0x38, 0x33, 0x33, 0x34, 0x35, 0x65, 0x34, 0x65, 0x36, 0x38, 0x34, 0x34, 0x37, 0x66, 0x65, 0x64, 0x66, 0x32, 0x35, 0x33, 0x63, 0x31, 0x37, 0x35, 0x39, 0x65, 0x37, 0x30, 0x61, 0x66, 0x34, 0x35, 0x36, 0x66, 0x35, 0x64, 0x61, 0x63, 0x62, 0x36, 0x37, 0x32, 0x62, 0x66, 0x37, 0x61, 0x66, 0x33, 0x36, 0x39, 0x30, 0x36, 0x31, 0x66, 0x36, 0x35, 0x64, 0x62, 0x64, 0x66, 0x35, 0x35, 0x30, 0x64, 0x36, 0x66, 0x34, 0x31, 0x65, 0x30, 0x63, 0x33, 0x32, 0x65, 0x32, 0x63, 0x36, 0x61, 0x34, 0x36, 0x36, 0x62, 0x62, 0x36, 0x32, 0x64, 0x61, 0x61, 0x37, 0x64, 0x61, 0x62, 0x66, 0x36, 0x35, 0x38, 0x31, 0x35, 0x30, 0x35, 0x63, 0x33, 0x61, 0x63, 0x37, 0x32, 0x34, 0x39, 0x36, 0x38, 0x30, 0x65, 0x31, 0x64, 0x34, 0x64, 0x37, 0x38, 0x64, 0x65, 0x34, 0x63, 0x35, 0x32, 0x37, 0x62, 0x35, 0x31, 0x30, 0x65, 0x38, 0x30, 0x35, 0x33, 0x63, 0x34, 0x33, 0x63, 0x34, 0x62, 0x39, 0x39, 0x31, 0x63, 0x37, 0x37, 0x36, 0x64, 0x38, 0x38, 0x30, 0x66, 0x64, 0x31, 0x38, 0x33, 0x33, 0x64, 0x66, 0x38, 0x38, 0x33, 0x65, 0x30, 0x35, 0x63, 0x62, 0x33, 0x37, 0x32, 0x63, 0x37, 0x65, 0x36, 0x31, 0x61, 0x66, 0x32, 0x32, 0x36, 0x32, 0x61, 0x31, 0x34, 0x30, 0x33, 0x63, 0x63, 0x38, 0x65, 0x65, 0x38, 0x37, 0x30, 0x38, 0x32, 0x31, 0x38, 0x66, 0x32, 0x32, 0x32, 0x31, 0x39, 0x65, 0x39, 0x39, 0x36, 0x63, 0x34, 0x63, 0x62, 0x32, 0x33, 0x37, 0x65, 0x32, 0x61, 0x33, 0x61, 0x33, 0x31, 0x65, 0x31, 0x33, 0x62, 0x39, 0x64, 0x39, 0x32, 0x66, 0x38, 0x37, 0x32, 0x64, 0x32, 0x33, 0x30, 0x62, 0x39, 0x30, 0x31, 0x64, 0x62, 0x34, 0x35, 0x32, 0x31, 0x39, 0x38, 0x32, 0x65, 0x63, 0x38, 0x39, 0x32, 0x61, 0x33, 0x31, 0x30, 0x37, 0x35, 0x37, 0x32, 0x36, 0x36, 0x36, 0x34, 0x62, 0x37, 0x64, 0x38, 0x39, 0x34, 0x33, 0x31, 0x30, 0x31, 0x34, 0x66, 0x32, 0x39, 0x64, 0x63, 0x39, 0x36, 0x64, 0x62, 0x66, 0x66, 0x61, 0x62, 0x31, 0x36, 0x63, 0x36, 0x37, 0x32, 0x31, 0x35, 0x65, 0x61, 0x39, 0x66, 0x66, 0x64, 0x31, 0x37, 0x31, 0x35, 0x34, 0x35, 0x36, 0x38, 0x33, 0x39, 0x34, 0x33, 0x36, 0x31, 0x34, 0x38, 0x61, 0x61, 0x31, 0x62, 0x35, 0x31, 0x36, 0x36, 0x61, 0x32, 0x63, 0x65, 0x37, 0x64, 0x35, 0x61, 0x35, 0x33, 0x38, 0x39, 0x64, 0x33, 0x30, 0x32, 0x37, 0x63, 0x30, 0x37, 0x31, 0x61, 0x63, 0x39, 0x62, 0x33, 0x35, 0x35, 0x31, 0x34, 0x37, 0x32, 0x31, 0x34, 0x65, 0x64, 0x30, 0x36, 0x61, 0x65, 0x31, 0x64, 0x35, 0x37, 0x62, 0x35, 0x38, 0x38, 0x34, 0x33, 0x33, 0x30, 0x33, 0x64, 0x65, 0x37, 0x35, 0x30, 0x65, 0x31, 0x66, 0x38, 0x33, 0x31, 0x64, 0x30, 0x30, 0x36, 0x62, 0x30, 0x37, 0x62, 0x39, 0x65, 0x65, 0x39, 0x36, 0x31, 0x34, 0x37, 0x62, 0x62, 0x65, 0x35, 0x39, 0x64, 0x35, 0x36, 0x63, 0x34, 0x64, 0x38, 0x31, 0x38, 0x37, 0x32, 0x34, 0x36, 0x37, 0x36, 0x31, 0x65, 0x39, 0x39, 0x39, 0x63, 0x61, 0x36, 0x31, 0x65, 0x36, 0x35, 0x35, 0x38, 0x30, 0x37, 0x61, 0x36, 0x39, 0x39, 0x30, 0x39, 0x39, 0x39, 0x30, 0x36, 0x36, 0x61, 0x32, 0x31, 0x36, 0x35, 0x66, 0x35, 0x32, 0x36, 0x35, 0x61, 0x62, 0x64, 0x39, 0x62, 0x64, 0x65, 0x38, 0x61, 0x38, 0x61, 0x37, 0x31, 0x39, 0x66, 0x64, 0x30, 0x32, 0x66, 0x33, 0x63, 0x37, 0x32, 0x35, 0x32, 0x63, 0x32, 0x34, 0x35, 0x33, 0x39, 0x65, 0x37, 0x61, 0x39, 0x33, 0x34, 0x61, 0x39, 0x32, 0x37, 0x30, 0x34, 0x35, 0x66, 0x33, 0x63, 0x64, 0x37, 0x30, 0x38, 0x33, 0x37, 0x65, 0x32, 0x65, 0x38, 0x36, 0x65, 0x62, 0x63, 0x65, 0x63, 0x37, 0x62, 0x65, 0x39, 0x35, 0x39, 0x66, 0x65, 0x66, 0x30, 0x36, 0x61, 0x30, 0x66, 0x33, 0x32, 0x37, 0x39, 0x66, 0x35, 0x65, 0x66, 0x30, 0x65, 0x30, 0x33, 0x63, 0x62, 0x65, 0x33, 0x36, 0x37, 0x30, 0x37, 0x63, 0x63, 0x33, 0x36, 0x37, 0x39, 0x66, 0x64, 0x66, 0x63, 0x30, 0x32, 0x34, 0x63, 0x30, 0x32, 0x65, 0x65, 0x32, 0x31, 0x30, 0x61, 0x34, 0x30, 0x33, 0x39, 0x61, 0x39, 0x35, 0x32, 0x37, 0x31, 0x34, 0x63, 0x39, 0x32, 0x37, 0x35, 0x61, 0x64, 0x65, 0x31, 0x37, 0x36, 0x61, 0x62, 0x39, 0x31, 0x64, 0x61, 0x34, 0x64, 0x37, 0x32, 0x64, 0x34, 0x32, 0x38, 0x37, 0x31, 0x38, 0x35, 0x32, 0x61, 0x31, 0x30, 0x33, 0x34, 0x64, 0x36, 0x37, 0x66, 0x63, 0x37, 0x61, 0x64, 0x36, 0x38, 0x65, 0x65, 0x33, 0x63, 0x37, 0x30, 0x39, 0x35, 0x63, 0x61, 0x37, 0x32, 0x63, 0x63, 0x30, 0x64, 0x61, 0x32, 0x31, 0x37, 0x62, 0x65, 0x64, 0x35, 0x33, 0x33, 0x30, 0x36, 0x39, 0x36, 0x35, 0x63, 0x66, 0x62, 0x31, 0x66, 0x61, 0x39, 0x33, 0x31, 0x30, 0x61, 0x39, 0x38, 0x39, 0x61, 0x34, 0x37, 0x32, 0x30, 0x66, 0x64, 0x37, 0x39, 0x33, 0x34, 0x62, 0x65, 0x37, 0x39, 0x39, 0x39, 0x30, 0x32, 0x30, 0x64, 0x34, 0x31, 0x62, 0x32, 0x31, 0x33, 0x65, 0x32, 0x66, 0x31, 0x32, 0x35, 0x63, 0x62, 0x36, 0x39, 0x64, 0x64, 0x32, 0x38, 0x30, 0x36, 0x34, 0x65, 0x61, 0x34, 0x61, 0x31, 0x64, 0x30, 0x66, 0x63, 0x39, 0x62, 0x36, 0x32, 0x34, 0x62, 0x35, 0x37, 0x61, 0x32, 0x31, 0x36, 0x34, 0x31, 0x66, 0x37, 0x64, 0x36, 0x34, 0x33, 0x62, 0x32, 0x33, 0x39, 0x30, 0x65, 0x37, 0x33, 0x34, 0x38, 0x36, 0x66, 0x63, 0x64, 0x61, 0x31, 0x63, 0x36, 0x61, 0x64, 0x63, 0x30, 0x66, 0x33, 0x38, 0x37, 0x64, 0x37, 0x34, 0x62, 0x33, 0x63, 0x35, 0x63, 0x38, 0x30, 0x33, 0x32, 0x33, 0x64, 0x37, 0x66, 0x31, 0x31, 0x36, 0x66, 0x32, 0x66, 0x37, 0x32, 0x61, 0x61, 0x37, 0x36, 0x65, 0x66, 0x65, 0x63, 0x31, 0x65, 0x31, 0x32, 0x31, 0x36, 0x37, 0x32, 0x34, 0x39, 0x38, 0x34, 0x30, 0x65, 0x35, 0x61, 0x39, 0x38, 0x38, 0x35, 0x32, 0x31, 0x66, 0x61, 0x37, 0x33, 0x33, 0x66, 0x34, 0x35, 0x62, 0x39, 0x66, 0x31, 0x66, 0x30, 0x32, 0x39, 0x37, 0x33, 0x36, 0x66, 0x31, 0x33, 0x35, 0x30, 0x37, 0x63, 0x33, 0x34, 0x64, 0x31, 0x39, 0x32, 0x37, 0x32, 0x32, 0x31, 0x63, 0x63, 0x39, 0x36, 0x33, 0x30, 0x32, 0x37, 0x37, 0x39, 0x61, 0x33, 0x63, 0x33, 0x63, 0x37, 0x32, 0x36, 0x62, 0x37, 0x36, 0x39, 0x31, 0x36, 0x32, 0x35, 0x62, 0x65, 0x32, 0x66, 0x35, 0x66, 0x63, 0x35, 0x38, 0x63, 0x31, 0x38, 0x33, 0x34, 0x63, 0x37, 0x32, 0x36, 0x39, 0x35, 0x62, 0x39, 0x66, 0x37, 0x65, 0x38, 0x39, 0x38, 0x38, 0x33, 0x65, 0x39, 0x64, 0x36, 0x37, 0x32, 0x32, 0x31, 0x64, 0x62, 0x64, 0x33, 0x35, 0x39, 0x31, 0x30, 0x38, 0x64, 0x30, 0x66, 0x32, 0x37, 0x31, 0x37, 0x61, 0x30, 0x62, 0x63, 0x36, 0x66, 0x38, 0x35, 0x63, 0x31, 0x37, 0x30, 0x32, 0x30, 0x32, 0x35, 0x66, 0x32, 0x63, 0x34, 0x34, 0x35, 0x30, 0x37, 0x31, 0x36, 0x62, 0x62, 0x62, 0x37, 0x63, 0x64, 0x36, 0x34, 0x66, 0x63, 0x31, 0x32, 0x33, 0x62, 0x30, 0x32, 0x65, 0x36, 0x34, 0x31, 0x34, 0x34, 0x33, 0x64, 0x34, 0x38, 0x38, 0x35, 0x65, 0x38, 0x34, 0x61, 0x36, 0x33, 0x35, 0x66, 0x61, 0x61, 0x65, 0x30, 0x63, 0x33, 0x30, 0x34, 0x31, 0x36, 0x35, 0x63, 0x33, 0x32, 0x32, 0x36, 0x38, 0x63, 0x61, 0x39, 0x31, 0x64, 0x31, 0x30, 0x61, 0x34, 0x39, 0x66, 0x34, 0x36, 0x65, 0x65, 0x64, 0x63, 0x38, 0x30, 0x37, 0x63, 0x34, 0x35, 0x64, 0x66, 0x66, 0x65, 0x64, 0x62, 0x37, 0x32, 0x39, 0x39, 0x31, 0x35, 0x30, 0x35, 0x36, 0x63, 0x66, 0x64, 0x30, 0x63, 0x37, 0x32, 0x35, 0x37, 0x62, 0x35, 0x33, 0x31, 0x64, 0x38, 0x62, 0x63, 0x38, 0x33, 0x65, 0x37, 0x62, 0x33, 0x32, 0x30, 0x38, 0x31, 0x35, 0x62, 0x37, 0x62, 0x61, 0x35, 0x36, 0x33, 0x33, 0x64, 0x32, 0x37, 0x31, 0x38, 0x31, 0x66, 0x31, 0x65, 0x61, 0x34, 0x66, 0x36, 0x62, 0x64, 0x33, 0x32, 0x31, 0x62, 0x37, 0x32, 0x36, 0x34, 0x63, 0x61, 0x61, 0x31, 0x31, 0x31, 0x30, 0x33, 0x32, 0x31, 0x36, 0x33, 0x32, 0x64, 0x34, 0x38, 0x64, 0x64, 0x61, 0x62, 0x35, 0x66, 0x37, 0x31, 0x36, 0x64, 0x38, 0x34, 0x38, 0x36, 0x65, 0x34, 0x64, 0x61, 0x34, 0x38, 0x32, 0x35, 0x37, 0x66, 0x63, 0x33, 0x37, 0x62, 0x34, 0x62, 0x38, 0x38, 0x35, 0x36, 0x38, 0x61, 0x36, 0x32, 0x34, 0x31, 0x64, 0x38, 0x36, 0x64, 0x34, 0x36, 0x64, 0x34, 0x35, 0x63, 0x31, 0x39, 0x65, 0x30, 0x33, 0x32, 0x36, 0x34, 0x37, 0x65, 0x37, 0x36, 0x66, 0x33, 0x30, 0x62, 0x36, 0x32, 0x34, 0x34, 0x32, 0x33, 0x35, 0x37, 0x61, 0x34, 0x62, 0x30, 0x35, 0x63, 0x39, 0x31, 0x36, 0x31, 0x66, 0x36, 0x61, 0x38, 0x35, 0x39, 0x31, 0x64, 0x36, 0x65, 0x34, 0x61, 0x37, 0x34, 0x65, 0x34, 0x66, 0x37, 0x66, 0x31, 0x37, 0x62, 0x39, 0x35, 0x36, 0x38, 0x34, 0x39, 0x36, 0x30, 0x66, 0x37, 0x64, 0x61, 0x62, 0x65, 0x63, 0x39, 0x64, 0x37, 0x62, 0x62, 0x33, 0x65, 0x65, 0x62, 0x37, 0x31, 0x66, 0x32, 0x66, 0x66, 0x39, 0x36, 0x64, 0x30, 0x35, 0x32, 0x30, 0x34, 0x63, 0x35, 0x62, 0x38, 0x38, 0x64, 0x39, 0x62, 0x30, 0x64, 0x39, 0x64, 0x32, 0x63, 0x65, 0x65, 0x65, 0x36, 0x31, 0x61, 0x30, 0x36, 0x31, 0x31, 0x38, 0x34, 0x36, 0x36, 0x32, 0x35, 0x31, 0x36, 0x39, 0x31, 0x32, 0x32, 0x38, 0x32, 0x63, 0x36, 0x35, 0x30, 0x65, 0x38, 0x63, 0x33, 0x35, 0x37, 0x32, 0x33, 0x61, 0x61, 0x34, 0x64, 0x38, 0x39, 0x61, 0x30, 0x62, 0x34, 0x34, 0x64, 0x34, 0x30, 0x36, 0x33, 0x62, 0x66, 0x66, 0x64, 0x64, 0x62, 0x35, 0x30, 0x65, 0x38, 0x37, 0x64, 0x31, 0x39, 0x36, 0x36, 0x66, 0x63, 0x30, 0x35, 0x61, 0x65, 0x36, 0x37, 0x39, 0x63, 0x33, 0x34, 0x30, 0x39, 0x64, 0x38, 0x32, 0x37, 0x39, 0x63, 0x64, 0x39, 0x34, 0x31, 0x31, 0x33, 0x36, 0x34, 0x66, 0x38, 0x62, 0x63, 0x33, 0x33, 0x31, 0x33, 0x63, 0x63, 0x66, 0x34, 0x30, 0x62, 0x38, 0x32, 0x33, 0x31, 0x63, 0x64, 0x32, 0x39, 0x30, 0x66, 0x62, 0x61, 0x37, 0x63, 0x38, 0x38, 0x33, 0x34, 0x32, 0x66, 0x39, 0x34, 0x35, 0x66, 0x37, 0x37, 0x63, 0x66, 0x30, 0x31, 0x35, 0x31, 0x37, 0x32, 0x36, 0x34, 0x34, 0x31, 0x63, 0x35, 0x38, 0x66, 0x64, 0x38, 0x31, 0x30, 0x35, 0x63, 0x62, 0x38, 0x61, 0x64, 0x39, 0x37, 0x36, 0x31, 0x64, 0x61, 0x38, 0x61, 0x35, 0x33, 0x61, 0x66, 0x35, 0x61, 0x63, 0x32, 0x37, 0x62, 0x65, 0x38, 0x38, 0x39, 0x33, 0x36, 0x63, 0x62, 0x65, 0x65, 0x31, 0x65, 0x32, 0x66, 0x65, 0x33, 0x66, 0x38, 0x31, 0x35, 0x30, 0x34, 0x35, 0x35, 0x35, 0x36, 0x36, 0x61, 0x61, 0x36, 0x65, 0x36, 0x61, 0x62, 0x37, 0x62, 0x31, 0x63, 0x35, 0x36, 0x38, 0x66, 0x36, 0x38, 0x36, 0x63, 0x65, 0x30, 0x62, 0x61, 0x62, 0x62, 0x66, 0x63, 0x35, 0x34, 0x65, 0x34, 0x39, 0x66, 0x65, 0x64, 0x38, 0x37, 0x36, 0x36, 0x63, 0x34, 0x65, 0x30, 0x66, 0x62, 0x61, 0x37, 0x64, 0x37, 0x39, 0x38, 0x33, 0x31, 0x39, 0x32, 0x31, 0x61, 0x62, 0x30, 0x62, 0x30, 0x33, 0x62, 0x37, 0x32, 0x32, 0x34, 0x63, 0x66, 0x35, 0x30, 0x39, 0x62, 0x61, 0x61, 0x61, 0x39, 0x64, 0x37, 0x38, 0x30, 0x63, 0x63, 0x61, 0x31, 0x61, 0x62, 0x36, 0x38, 0x65, 0x39, 0x31, 0x33, 0x31, 0x32, 0x66, 0x63, 0x64, 0x32, 0x66, 0x36, 0x61, 0x66, 0x37, 0x37, 0x38, 0x65, 0x64, 0x39, 0x30, 0x34, 0x30, 0x64, 0x36, 0x65, 0x65, 0x31, 0x34, 0x34, 0x34, 0x36, 0x33, 0x62, 0x38, 0x39, 0x39, 0x61, 0x36, 0x33, 0x33, 0x32, 0x37, 0x63, 0x33, 0x66, 0x64, 0x34, 0x64, 0x35, 0x37, 0x37, 0x64, 0x37, 0x37, 0x31, 0x35, 0x36, 0x31, 0x66, 0x31, 0x39, 0x35, 0x62, 0x31, 0x32, 0x30, 0x66, 0x34, 0x65, 0x62, 0x34, 0x34, 0x33, 0x34, 0x64, 0x61, 0x39, 0x64, 0x34, 0x35, 0x38, 0x38, 0x37, 0x39, 0x37, 0x33, 0x36, 0x66, 0x35, 0x66, 0x64, 0x63, 0x61, 0x34, 0x30, 0x35, 0x33, 0x38, 0x63, 0x30, 0x32, 0x31, 0x34, 0x31, 0x31, 0x35, 0x39, 0x34, 0x37, 0x61, 0x30, 0x39, 0x63, 0x63, 0x32, 0x62, 0x30, 0x30, 0x35, 0x30, 0x31, 0x38, 0x34, 0x31, 0x61, 0x35, 0x37, 0x36, 0x61, 0x63, 0x38, 0x34, 0x65, 0x35, 0x65, 0x62, 0x37, 0x31, 0x63, 0x33, 0x37, 0x39, 0x33, 0x65, 0x63, 0x30, 0x66, 0x37, 0x63, 0x39, 0x64, 0x39, 0x35, 0x61, 0x36, 0x36, 0x32, 0x37, 0x64, 0x35, 0x61, 0x31, 0x35, 0x39, 0x33, 0x37, 0x32, 0x35, 0x38, 0x38, 0x61, 0x65, 0x36, 0x63, 0x34, 0x36, 0x63, 0x35, 0x38, 0x31, 0x35, 0x32, 0x32, 0x32, 0x30, 0x66, 0x36, 0x65, 0x30, 0x62, 0x34, 0x62, 0x36, 0x65, 0x61, 0x30, 0x30, 0x39, 0x38, 0x30, 0x64, 0x33, 0x34, 0x31, 0x33, 0x32, 0x65, 0x37, 0x36, 0x38, 0x65, 0x32, 0x62, 0x35, 0x61, 0x63, 0x33, 0x30, 0x36, 0x64, 0x62, 0x63, 0x34, 0x33, 0x37, 0x63, 0x33, 0x35, 0x35, 0x37, 0x32, 0x30, 0x38, 0x33, 0x39, 0x64, 0x32, 0x66, 0x64, 0x62, 0x34, 0x39, 0x61, 0x38, 0x32, 0x38, 0x65, 0x31, 0x64, 0x65, 0x66, 0x37, 0x30, 0x64, 0x64, 0x34, 0x32, 0x34, 0x36, 0x61, 0x38, 0x65, 0x62, 0x36, 0x35, 0x66, 0x39, 0x32, 0x32, 0x37, 0x66, 0x34, 0x30, 0x34, 0x33, 0x35, 0x38, 0x66, 0x65, 0x30, 0x61, 0x62, 0x65, 0x30, 0x65, 0x66, 0x66, 0x65, 0x37, 0x63, 0x64, 0x61, 0x38, 0x36, 0x33, 0x35, 0x63, 0x39, 0x31, 0x39, 0x66, 0x33, 0x66, 0x34, 0x34, 0x37, 0x36, 0x62, 0x30, 0x63, 0x36, 0x31, 0x62, 0x65, 0x35, 0x30, 0x65, 0x65, 0x61, 0x38, 0x63, 0x32, 0x65, 0x38, 0x62, 0x37, 0x63, 0x33, 0x30, 0x64, 0x34, 0x64, 0x62, 0x65, 0x63, 0x63, 0x33, 0x30, 0x36, 0x38, 0x37, 0x64, 0x66, 0x39, 0x33, 0x65, 0x65, 0x30, 0x38, 0x36, 0x34, 0x32, 0x66, 0x30, 0x64, 0x36, 0x30, 0x37, 0x32, 0x30, 0x37, 0x37, 0x32, 0x35, 0x65, 0x30, 0x64, 0x35, 0x39, 0x62, 0x63, 0x33, 0x62, 0x66, 0x66, 0x64, 0x63, 0x38, 0x62, 0x64, 0x37, 0x31, 0x35, 0x30, 0x34, 0x37, 0x61, 0x64, 0x64, 0x31, 0x65, 0x65, 0x64, 0x65, 0x61, 0x61, 0x63, 0x66, 0x63, 0x37, 0x39, 0x37, 0x30, 0x37, 0x62, 0x61, 0x38, 0x33, 0x64, 0x38, 0x33, 0x32, 0x36, 0x37, 0x38, 0x33, 0x64, 0x39, 0x33, 0x33, 0x62, 0x37, 0x32, 0x33, 0x30, 0x33, 0x36, 0x34, 0x32, 0x61, 0x33, 0x61, 0x66, 0x35, 0x32, 0x63, 0x64, 0x66, 0x37, 0x61, 0x35, 0x37, 0x34, 0x64, 0x61, 0x63, 0x31, 0x33, 0x66, 0x30, 0x37, 0x39, 0x34, 0x39, 0x61, 0x36, 0x34, 0x35, 0x36, 0x63, 0x62, 0x66, 0x62, 0x66, 0x62, 0x63, 0x34, 0x64, 0x62, 0x39, 0x65, 0x34, 0x66, 0x33, 0x39, 0x66, 0x30, 0x62, 0x39, 0x39, 0x31, 0x33, 0x64, 0x37, 0x66, 0x36, 0x63, 0x66, 0x35, 0x65, 0x64, 0x36, 0x33, 0x33, 0x61, 0x36, 0x66, 0x62, 0x36, 0x30, 0x63, 0x31, 0x64, 0x31, 0x34, 0x37, 0x37, 0x35, 0x31, 0x30, 0x31, 0x32, 0x33, 0x32, 0x61, 0x36, 0x66, 0x36, 0x31, 0x30, 0x35, 0x37, 0x64, 0x65, 0x39, 0x30, 0x35, 0x66, 0x37, 0x32, 0x35, 0x63, 0x66, 0x37, 0x64, 0x66, 0x32, 0x36, 0x36, 0x35, 0x62, 0x35, 0x33, 0x30, 0x31, 0x32, 0x63, 0x36, 0x31, 0x37, 0x32, 0x65, 0x66, 0x35, 0x30, 0x37, 0x61, 0x36, 0x65, 0x39, 0x63, 0x62, 0x32, 0x31, 0x39, 0x34, 0x37, 0x64, 0x34, 0x38, 0x61, 0x39, 0x30, 0x38, 0x35, 0x36, 0x38, 0x62, 0x35, 0x36, 0x66, 0x31, 0x30, 0x61, 0x62, 0x64, 0x32, 0x37, 0x65, 0x61, 0x66, 0x31, 0x66, 0x66, 0x38, 0x34, 0x36, 0x65, 0x62, 0x37, 0x61, 0x64, 0x30, 0x35, 0x66, 0x38, 0x35, 0x33, 0x66, 0x38, 0x66, 0x39, 0x65, 0x35, 0x39, 0x65, 0x38, 0x32, 0x62, 0x38, 0x36, 0x35, 0x65, 0x36, 0x32, 0x64, 0x33, 0x35, 0x30, 0x62, 0x30, 0x32, 0x66, 0x62, 0x66, 0x66, 0x66, 0x35, 0x32, 0x64, 0x63, 0x38, 0x36, 0x37, 0x39, 0x65, 0x38, 0x35, 0x36, 0x65, 0x66, 0x65, 0x38, 0x66, 0x32, 0x39, 0x31, 0x66, 0x65, 0x38, 0x37, 0x34, 0x38, 0x35, 0x32, 0x61, 0x35, 0x64, 0x39, 0x37, 0x31, 0x37, 0x63, 0x39, 0x65, 0x66, 0x63, 0x30, 0x31, 0x61, 0x62, 0x31, 0x37, 0x65, 0x61, 0x38, 0x65, 0x62, 0x35, 0x64, 0x31, 0x30, 0x65, 0x38, 0x39, 0x38, 0x37, 0x38, 0x31, 0x33, 0x62, 0x62, 0x34, 0x38, 0x63, 0x64, 0x63, 0x64, 0x38, 0x61, 0x61, 0x31, 0x65, 0x31, 0x63, 0x61, 0x34, 0x34, 0x61, 0x64, 0x36, 0x30, 0x35, 0x39, 0x34, 0x30, 0x39, 0x62, 0x30, 0x31, 0x35, 0x36, 0x63, 0x36, 0x36, 0x62, 0x34, 0x32, 0x35, 0x61, 0x62, 0x30, 0x66, 0x31, 0x34, 0x31, 0x63, 0x30, 0x35, 0x30, 0x61, 0x38, 0x63, 0x32, 0x34, 0x63, 0x31, 0x39, 0x66, 0x35, 0x62, 0x61, 0x39, 0x38, 0x66, 0x39, 0x30, 0x61, 0x32, 0x32, 0x61, 0x39, 0x36, 0x61, 0x61, 0x32, 0x36, 0x36, 0x63, 0x37, 0x34, 0x61, 0x32, 0x36, 0x61, 0x35, 0x35, 0x65, 0x66, 0x32, 0x66, 0x35, 0x31, 0x33, 0x36, 0x65, 0x35, 0x38, 0x35, 0x37, 0x33, 0x36, 0x37, 0x31, 0x65, 0x37, 0x32, 0x62, 0x65, 0x38, 0x34, 0x31, 0x34, 0x65, 0x61, 0x33, 0x32, 0x39, 0x65, 0x62, 0x37, 0x31, 0x64, 0x38, 0x35, 0x34, 0x34, 0x61, 0x66, 0x30, 0x34, 0x34, 0x63, 0x31, 0x63, 0x38, 0x39, 0x66, 0x65, 0x38, 0x64, 0x32, 0x38, 0x37, 0x38, 0x35, 0x38, 0x38, 0x32, 0x35, 0x31, 0x34, 0x33, 0x33, 0x64, 0x65, 0x39, 0x39, 0x66, 0x32, 0x38, 0x32, 0x31, 0x33, 0x35, 0x39, 0x66, 0x38, 0x30, 0x36, 0x65, 0x37, 0x62, 0x36, 0x38, 0x34, 0x35, 0x34, 0x61, 0x34, 0x65, 0x61, 0x66, 0x36, 0x63, 0x61, 0x32, 0x32, 0x37, 0x30, 0x36, 0x39, 0x66, 0x61, 0x38, 0x38, 0x33, 0x30, 0x37, 0x65, 0x35, 0x61, 0x37, 0x61, 0x31, 0x33, 0x30, 0x64, 0x65, 0x66, 0x62, 0x31, 0x62, 0x31, 0x38, 0x31, 0x37, 0x65, 0x66, 0x36, 0x39, 0x36, 0x33, 0x38, 0x62, 0x33, 0x63, 0x36, 0x61, 0x62, 0x33, 0x34, 0x63, 0x34, 0x37, 0x63, 0x34, 0x37, 0x61, 0x30, 0x36, 0x30, 0x38, 0x37, 0x32, 0x33, 0x37, 0x37, 0x62, 0x66, 0x39, 0x34, 0x65, 0x37, 0x65, 0x39, 0x34, 0x61, 0x63, 0x62, 0x64, 0x35, 0x37, 0x61, 0x31, 0x32, 0x34, 0x37, 0x31, 0x32, 0x31, 0x37, 0x37, 0x61, 0x36, 0x30, 0x36, 0x30, 0x63, 0x35, 0x31, 0x62, 0x30, 0x35, 0x62, 0x64, 0x65, 0x31, 0x34, 0x34, 0x33, 0x34, 0x63, 0x30, 0x61, 0x37, 0x65, 0x36, 0x36, 0x38, 0x38, 0x37, 0x30, 0x34, 0x65, 0x36, 0x33, 0x63, 0x63, 0x36, 0x61, 0x38, 0x37, 0x31, 0x34, 0x65, 0x36, 0x31, 0x32, 0x37, 0x62, 0x37, 0x30, 0x33, 0x32, 0x61, 0x38, 0x65, 0x34, 0x64, 0x64, 0x65, 0x63, 0x38, 0x34, 0x61, 0x38, 0x63, 0x62, 0x61, 0x66, 0x64, 0x62, 0x66, 0x36, 0x31, 0x30, 0x30, 0x32, 0x33, 0x65, 0x32, 0x33, 0x32, 0x34, 0x65, 0x61, 0x35, 0x30, 0x34, 0x63, 0x37, 0x32, 0x39, 0x35, 0x32, 0x32, 0x37, 0x66, 0x36, 0x62, 0x33, 0x39, 0x30, 0x61, 0x31, 0x65, 0x34, 0x36, 0x30, 0x61, 0x36, 0x39, 0x61, 0x66, 0x37, 0x63, 0x61, 0x32, 0x36, 0x33, 0x31, 0x64, 0x64, 0x33, 0x63, 0x32, 0x61, 0x64, 0x33, 0x38, 0x32, 0x31, 0x34, 0x31, 0x39, 0x34, 0x63, 0x32, 0x31, 0x30, 0x65, 0x65, 0x64, 0x39, 0x32, 0x38, 0x66, 0x61, 0x65, 0x63, 0x30, 0x63, 0x64, 0x33, 0x31, 0x65, 0x34, 0x33, 0x62, 0x32, 0x35, 0x32, 0x66, 0x32, 0x35, 0x34, 0x63, 0x62, 0x30, 0x35, 0x38, 0x34, 0x37, 0x64, 0x61, 0x61, 0x66, 0x36, 0x36, 0x63, 0x65, 0x33, 0x38, 0x61, 0x61, 0x35, 0x32, 0x34, 0x62, 0x61, 0x61, 0x36, 0x31, 0x33, 0x30, 0x34, 0x32, 0x37, 0x33, 0x34, 0x64, 0x31, 0x30, 0x65, 0x37, 0x62, 0x62, 0x31, 0x33, 0x61, 0x33, 0x34, 0x62, 0x64, 0x61, 0x31, 0x38, 0x34, 0x31, 0x63, 0x39, 0x37, 0x64, 0x30, 0x35, 0x62, 0x30, 0x66, 0x63, 0x38, 0x61, 0x32, 0x34, 0x39, 0x37, 0x64, 0x35, 0x61, 0x62, 0x63, 0x62, 0x32, 0x38, 0x65, 0x38, 0x33, 0x64, 0x31, 0x62, 0x63, 0x30, 0x37, 0x34, 0x63, 0x66, 0x62, 0x34, 0x33, 0x34, 0x66, 0x37, 0x61, 0x33, 0x37, 0x62, 0x64, 0x66, 0x62, 0x39, 0x61, 0x64, 0x34, 0x30, 0x33, 0x32, 0x61, 0x31, 0x64, 0x34, 0x38, 0x33, 0x63, 0x32, 0x65, 0x38, 0x31, 0x31, 0x32, 0x32, 0x39, 0x32, 0x63, 0x66, 0x30, 0x33, 0x30, 0x66, 0x32, 0x31, 0x35, 0x38, 0x62, 0x32, 0x64, 0x36, 0x31, 0x35, 0x32, 0x39, 0x37, 0x63, 0x63, 0x39, 0x38, 0x66, 0x38, 0x38, 0x30, 0x36, 0x65, 0x62, 0x64, 0x64, 0x34, 0x36, 0x63, 0x65, 0x32, 0x63, 0x65, 0x65, 0x65, 0x31, 0x39, 0x39, 0x34, 0x37, 0x61, 0x34, 0x62, 0x31, 0x34, 0x37, 0x62, 0x32, 0x62, 0x32, 0x30, 0x36, 0x36, 0x62, 0x33, 0x62, 0x34, 0x37, 0x66, 0x38, 0x65, 0x36, 0x33, 0x66, 0x61, 0x62, 0x64, 0x38, 0x63, 0x37, 0x33, 0x31, 0x39, 0x33, 0x66, 0x63, 0x37, 0x37, 0x65, 0x30, 0x62, 0x30, 0x65, 0x39, 0x66, 0x31, 0x64, 0x31, 0x34, 0x65, 0x38, 0x30, 0x37, 0x65, 0x32, 0x64, 0x33, 0x63, 0x38, 0x39, 0x64, 0x35, 0x61, 0x64, 0x61, 0x30, 0x36, 0x31, 0x30, 0x64, 0x64, 0x63, 0x32, 0x31, 0x36, 0x31, 0x61, 0x36, 0x33, 0x66, 0x37, 0x64, 0x63, 0x62, 0x35, 0x62, 0x64, 0x38, 0x33, 0x61, 0x33, 0x39, 0x36, 0x61, 0x65, 0x64, 0x63, 0x36, 0x34, 0x64, 0x38, 0x62, 0x65, 0x33, 0x34, 0x37, 0x35, 0x66, 0x63, 0x34, 0x31, 0x34, 0x37, 0x32, 0x35, 0x31, 0x31, 0x66, 0x39, 0x66, 0x32, 0x33, 0x34, 0x65, 0x61, 0x30, 0x62, 0x64, 0x66, 0x62, 0x62, 0x31, 0x63, 0x31, 0x35, 0x34, 0x65, 0x37, 0x32, 0x37, 0x36, 0x63, 0x62, 0x61, 0x36, 0x32, 0x37, 0x64, 0x39, 0x33, 0x33, 0x37, 0x65, 0x34, 0x35, 0x62, 0x63, 0x66, 0x34, 0x35, 0x33, 0x64, 0x37, 0x37, 0x31, 0x36, 0x37, 0x34, 0x36, 0x31, 0x61, 0x37, 0x34, 0x33, 0x30, 0x62, 0x61, 0x38, 0x64, 0x63, 0x31, 0x66, 0x36, 0x38, 0x30, 0x61, 0x39, 0x65, 0x38, 0x34, 0x33, 0x37, 0x37, 0x62, 0x62, 0x64, 0x38, 0x32, 0x37, 0x38, 0x33, 0x31, 0x63, 0x35, 0x37, 0x66, 0x35, 0x65, 0x63, 0x62, 0x65, 0x61, 0x61, 0x31, 0x33, 0x39, 0x31, 0x37, 0x31, 0x38, 0x32, 0x66, 0x30, 0x39, 0x66, 0x65, 0x38, 0x33, 0x63, 0x36, 0x34, 0x66, 0x34, 0x66, 0x33, 0x61, 0x38, 0x34, 0x61, 0x62, 0x38, 0x36, 0x38, 0x36, 0x37, 0x35, 0x32, 0x63, 0x33, 0x63, 0x61, 0x65, 0x31, 0x39, 0x30, 0x66, 0x38, 0x66, 0x30, 0x65, 0x66, 0x36, 0x34, 0x32, 0x33, 0x30, 0x65, 0x39, 0x32, 0x32, 0x31, 0x35, 0x62, 0x39, 0x61, 0x65, 0x38, 0x35, 0x32, 0x37, 0x30, 0x34, 0x35, 0x65, 0x33, 0x32, 0x39, 0x66, 0x38, 0x39, 0x63, 0x64, 0x37, 0x32, 0x37, 0x36, 0x36, 0x30, 0x36, 0x65, 0x66, 0x33, 0x30, 0x33, 0x35, 0x65, 0x61, 0x61, 0x61, 0x66, 0x30, 0x31, 0x34, 0x31, 0x32, 0x66, 0x35, 0x32, 0x65, 0x38, 0x35, 0x36, 0x39, 0x37, 0x61, 0x31, 0x31, 0x31, 0x34, 0x36, 0x32, 0x33, 0x36, 0x32, 0x34, 0x34, 0x38, 0x32, 0x39, 0x31, 0x63, 0x66, 0x38, 0x37, 0x30, 0x31, 0x63, 0x61, 0x61, 0x65, 0x35, 0x32, 0x36, 0x39, 0x33, 0x61, 0x66, 0x35, 0x35, 0x31, 0x31, 0x33, 0x39, 0x61, 0x39, 0x61, 0x38, 0x33, 0x31, 0x36, 0x30, 0x31, 0x33, 0x34, 0x30, 0x65, 0x35, 0x32, 0x30, 0x32, 0x65, 0x30, 0x35, 0x31, 0x35, 0x30, 0x62, 0x30, 0x39, 0x64, 0x35, 0x63, 0x33, 0x37, 0x32, 0x30, 0x32, 0x39, 0x35, 0x32, 0x61, 0x61, 0x36, 0x35, 0x36, 0x36, 0x39, 0x37, 0x63, 0x65, 0x32, 0x62, 0x37, 0x32, 0x66, 0x30, 0x37, 0x36, 0x32, 0x35, 0x38, 0x36, 0x31, 0x63, 0x65, 0x37, 0x61, 0x33, 0x30, 0x30, 0x32, 0x39, 0x38, 0x36, 0x32, 0x32, 0x64, 0x66, 0x32, 0x39, 0x61, 0x63, 0x38, 0x64, 0x66, 0x64, 0x66, 0x38, 0x33, 0x65, 0x37, 0x31, 0x61, 0x38, 0x62, 0x63, 0x66, 0x32, 0x34, 0x31, 0x65, 0x64, 0x61, 0x32, 0x39, 0x32, 0x64, 0x66, 0x35, 0x65, 0x38, 0x61, 0x64, 0x66, 0x63, 0x62, 0x66, 0x37, 0x63, 0x61, 0x35, 0x34, 0x63, 0x63, 0x66, 0x32, 0x64, 0x34, 0x62, 0x62, 0x36, 0x37, 0x30, 0x63, 0x63, 0x30, 0x39, 0x63, 0x63, 0x61, 0x62, 0x35, 0x66, 0x39, 0x38, 0x34, 0x65, 0x36, 0x31, 0x34, 0x32, 0x36, 0x34, 0x66, 0x61, 0x64, 0x62, 0x64, 0x31, 0x30, 0x30, 0x37, 0x32, 0x66, 0x61, 0x32, 0x37, 0x66, 0x64, 0x62, 0x30, 0x39, 0x32, 0x65, 0x39, 0x38, 0x39, 0x38, 0x37, 0x65, 0x33, 0x38, 0x38, 0x31, 0x31, 0x30, 0x62, 0x35, 0x33, 0x61, 0x63, 0x36, 0x66, 0x35, 0x33, 0x38, 0x66, 0x38, 0x61, 0x63, 0x34, 0x63, 0x65, 0x65, 0x32, 0x31, 0x33, 0x39, 0x31, 0x37, 0x32, 0x35, 0x33, 0x62, 0x65, 0x62, 0x64, 0x36, 0x61, 0x66, 0x32, 0x37, 0x32, 0x36, 0x37, 0x37, 0x32, 0x63, 0x38, 0x32, 0x35, 0x63, 0x62, 0x66, 0x33, 0x36, 0x33, 0x35, 0x31, 0x31, 0x34, 0x65, 0x33, 0x61, 0x38, 0x65, 0x35, 0x39, 0x31, 0x66, 0x35, 0x61, 0x30, 0x65, 0x31, 0x64, 0x30, 0x32, 0x63, 0x65, 0x38, 0x62, 0x61, 0x62, 0x62, 0x33, 0x64, 0x33, 0x33, 0x33, 0x37, 0x62, 0x30, 0x37, 0x32, 0x33, 0x64, 0x31, 0x63, 0x31, 0x62, 0x64, 0x65, 0x37, 0x39, 0x62, 0x63, 0x33, 0x30, 0x35, 0x66, 0x30, 0x65, 0x33, 0x61, 0x35, 0x30, 0x63, 0x31, 0x33, 0x37, 0x62, 0x65, 0x61, 0x38, 0x66, 0x33, 0x66, 0x64, 0x37, 0x61, 0x36, 0x63, 0x31, 0x37, 0x65, 0x64, 0x61, 0x32, 0x38, 0x37, 0x65, 0x31, 0x65, 0x30, 0x34, 0x65, 0x34, 0x33, 0x30, 0x35, 0x30, 0x30, 0x38, 0x35, 0x63, 0x32, 0x62, 0x30, 0x61, 0x35, 0x36, 0x38, 0x34, 0x61, 0x38, 0x32, 0x38, 0x32, 0x66, 0x64, 0x37, 0x61, 0x37, 0x32, 0x66, 0x62, 0x39, 0x30, 0x66, 0x63, 0x39, 0x37, 0x35, 0x33, 0x35, 0x34, 0x37, 0x38, 0x62, 0x39, 0x30, 0x37, 0x33, 0x63, 0x65, 0x66, 0x38, 0x62, 0x65, 0x64, 0x38, 0x34, 0x34, 0x39, 0x64, 0x32, 0x66, 0x61, 0x31, 0x38, 0x30, 0x33, 0x36, 0x64, 0x34, 0x62, 0x31, 0x66, 0x39, 0x63, 0x36, 0x65, 0x34, 0x31, 0x63, 0x39, 0x62, 0x64, 0x34, 0x39, 0x63, 0x65, 0x66, 0x31, 0x31, 0x65, 0x37, 0x32, 0x64, 0x30, 0x66, 0x33, 0x33, 0x35, 0x65, 0x61, 0x63, 0x64, 0x37, 0x36, 0x32, 0x33, 0x34, 0x37, 0x64, 0x32, 0x38, 0x35, 0x38, 0x37, 0x35, 0x30, 0x39, 0x31, 0x34, 0x35, 0x31, 0x31, 0x39, 0x32, 0x33, 0x32, 0x39, 0x65, 0x66, 0x35, 0x38, 0x36, 0x64, 0x33, 0x39, 0x38, 0x62, 0x35, 0x62, 0x33, 0x62, 0x30, 0x34, 0x35, 0x61, 0x35, 0x64, 0x38, 0x65, 0x62, 0x39, 0x37, 0x36, 0x30, 0x37, 0x32, 0x38, 0x38, 0x62, 0x39, 0x64, 0x61, 0x36, 0x62, 0x62, 0x64, 0x32, 0x62, 0x30, 0x36, 0x62, 0x37, 0x61, 0x38, 0x39, 0x38, 0x61, 0x39, 0x36, 0x39, 0x34, 0x38, 0x64, 0x30, 0x34, 0x38, 0x36, 0x31, 0x31, 0x66, 0x66, 0x30, 0x35, 0x38, 0x61, 0x62, 0x62, 0x62, 0x37, 0x62, 0x38, 0x32, 0x30, 0x62, 0x37, 0x36, 0x65, 0x65, 0x38, 0x31, 0x65, 0x34, 0x61, 0x62, 0x38, 0x35, 0x36, 0x65, 0x37, 0x32, 0x62, 0x62, 0x63, 0x63, 0x31, 0x61, 0x64, 0x61, 0x61, 0x39, 0x66, 0x38, 0x36, 0x32, 0x63, 0x34, 0x62, 0x62, 0x61, 0x63, 0x30, 0x65, 0x37, 0x61, 0x31, 0x37, 0x36, 0x61, 0x34, 0x37, 0x65, 0x64, 0x39, 0x36, 0x37, 0x64, 0x63, 0x37, 0x33, 0x33, 0x65, 0x32, 0x64, 0x62, 0x37, 0x34, 0x33, 0x37, 0x66, 0x36, 0x66, 0x35, 0x61, 0x35, 0x63, 0x62, 0x62, 0x30, 0x34, 0x37, 0x30, 0x37, 0x37, 0x32, 0x62, 0x66, 0x36, 0x63, 0x36, 0x31, 0x31, 0x32, 0x30, 0x39, 0x61, 0x34, 0x30, 0x61, 0x39, 0x32, 0x65, 0x64, 0x30, 0x65, 0x30, 0x38, 0x36, 0x36, 0x32, 0x34, 0x64, 0x66, 0x64, 0x32, 0x66, 0x31, 0x36, 0x36, 0x36, 0x64, 0x35, 0x34, 0x39, 0x36, 0x35, 0x61, 0x64, 0x30, 0x62, 0x36, 0x31, 0x61, 0x61, 0x64, 0x36, 0x31, 0x34, 0x32, 0x62, 0x32, 0x34, 0x36, 0x38, 0x65, 0x33, 0x65, 0x34, 0x66, 0x32, 0x30, 0x61, 0x30, 0x37, 0x34, 0x66, 0x36, 0x34, 0x31, 0x35, 0x33, 0x38, 0x64, 0x37, 0x34, 0x62, 0x64, 0x35, 0x61, 0x34, 0x65, 0x63, 0x66, 0x61, 0x66, 0x66, 0x64, 0x33, 0x66, 0x63, 0x65, 0x37, 0x64, 0x66, 0x34, 0x33, 0x38, 0x62, 0x66, 0x62, 0x37, 0x39, 0x37, 0x62, 0x62, 0x39, 0x34, 0x65, 0x32, 0x35, 0x61, 0x30, 0x32, 0x39, 0x66, 0x33, 0x39, 0x39, 0x62, 0x30, 0x36, 0x37, 0x32, 0x37, 0x36, 0x30, 0x30, 0x65, 0x63, 0x32, 0x33, 0x36, 0x32, 0x63, 0x32, 0x66, 0x38, 0x65, 0x31, 0x64, 0x35, 0x64, 0x35, 0x63, 0x31, 0x66, 0x30, 0x63, 0x37, 0x34, 0x61, 0x61, 0x63, 0x38, 0x62, 0x64, 0x34, 0x36, 0x61, 0x31, 0x33, 0x38, 0x63, 0x64, 0x34, 0x64, 0x66, 0x32, 0x31, 0x37, 0x34, 0x33, 0x63, 0x37, 0x39, 0x63, 0x63, 0x36, 0x34, 0x63, 0x37, 0x64, 0x65, 0x32, 0x64, 0x37, 0x32, 0x65, 0x38, 0x64, 0x34, 0x62, 0x35, 0x38, 0x30, 0x62, 0x31, 0x33, 0x36, 0x37, 0x63, 0x33, 0x64, 0x37, 0x35, 0x39, 0x63, 0x31, 0x32, 0x33, 0x64, 0x61, 0x61, 0x39, 0x63, 0x61, 0x66, 0x37, 0x37, 0x65, 0x32, 0x64, 0x38, 0x66, 0x31, 0x63, 0x66, 0x39, 0x64, 0x63, 0x62, 0x32, 0x35, 0x30, 0x66, 0x36, 0x65, 0x34, 0x61, 0x66, 0x31, 0x36, 0x35, 0x32, 0x62, 0x36, 0x65, 0x35, 0x65, 0x33, 0x36, 0x33, 0x39, 0x36, 0x64, 0x33, 0x64, 0x35, 0x64, 0x62, 0x30, 0x31, 0x66, 0x35, 0x66, 0x34, 0x37, 0x36, 0x63, 0x31, 0x33, 0x31, 0x38, 0x64, 0x37, 0x61, 0x39, 0x37, 0x65, 0x35, 0x62, 0x35, 0x39, 0x31, 0x65, 0x34, 0x63, 0x64, 0x37, 0x30, 0x39, 0x63, 0x62, 0x34, 0x31, 0x32, 0x65, 0x31, 0x33, 0x66, 0x32, 0x34, 0x31, 0x64, 0x33, 0x35, 0x33, 0x61, 0x37, 0x39, 0x35, 0x61, 0x61, 0x31, 0x66, 0x37, 0x33, 0x38, 0x39, 0x33, 0x64, 0x35, 0x33, 0x64, 0x39, 0x66, 0x37, 0x61, 0x64, 0x35, 0x33, 0x38, 0x35, 0x34, 0x34, 0x30, 0x32, 0x31, 0x62, 0x35, 0x37, 0x31, 0x38, 0x39, 0x65, 0x33, 0x33, 0x30, 0x30, 0x32, 0x64, 0x30, 0x65, 0x63, 0x35, 0x34, 0x64, 0x33, 0x37, 0x66, 0x35, 0x37, 0x63, 0x37, 0x31, 0x36, 0x65, 0x64, 0x38, 0x33, 0x64, 0x34, 0x63, 0x64, 0x35, 0x33, 0x31, 0x37, 0x32, 0x39, 0x33, 0x32, 0x35, 0x37, 0x35, 0x31, 0x37, 0x37, 0x39, 0x39, 0x61, 0x64, 0x31, 0x35, 0x32, 0x62, 0x34, 0x32, 0x64, 0x61, 0x34, 0x32, 0x38, 0x61, 0x36, 0x64, 0x62, 0x62, 0x65, 0x65, 0x35, 0x61, 0x33, 0x34, 0x34, 0x34, 0x32, 0x33, 0x33, 0x30, 0x31, 0x34, 0x33, 0x66, 0x63, 0x38, 0x38, 0x37, 0x63, 0x30, 0x32, 0x62, 0x30, 0x65, 0x39, 0x39, 0x37, 0x39, 0x30, 0x31, 0x63, 0x37, 0x32, 0x32, 0x39, 0x63, 0x38, 0x39, 0x32, 0x66, 0x39, 0x36, 0x30, 0x64, 0x37, 0x64, 0x34, 0x61, 0x31, 0x37, 0x36, 0x34, 0x61, 0x62, 0x65, 0x61, 0x37, 0x39, 0x32, 0x37, 0x62, 0x66, 0x37, 0x32, 0x61, 0x38, 0x30, 0x38, 0x63, 0x33, 0x37, 0x37, 0x34, 0x64, 0x32, 0x36, 0x33, 0x62, 0x64, 0x36, 0x37, 0x36, 0x36, 0x34, 0x65, 0x39, 0x62, 0x31, 0x33, 0x39, 0x39, 0x30, 0x32, 0x39, 0x38, 0x37, 0x32, 0x32, 0x37, 0x33, 0x34, 0x33, 0x62, 0x61, 0x36, 0x36, 0x31, 0x31, 0x66, 0x63, 0x63, 0x63, 0x38, 0x32, 0x31, 0x32, 0x38, 0x31, 0x32, 0x37, 0x63, 0x39, 0x31, 0x36, 0x38, 0x39, 0x65, 0x39, 0x35, 0x33, 0x65, 0x65, 0x36, 0x62, 0x65, 0x31, 0x36, 0x32, 0x39, 0x37, 0x33, 0x37, 0x64, 0x61, 0x35, 0x66, 0x31, 0x64, 0x64, 0x61, 0x62, 0x64, 0x64, 0x34, 0x34, 0x38, 0x64, 0x63, 0x66, 0x37, 0x32, 0x36, 0x34, 0x63, 0x31, 0x38, 0x65, 0x62, 0x39, 0x35, 0x64, 0x37, 0x31, 0x31, 0x64, 0x34, 0x64, 0x34, 0x66, 0x37, 0x31, 0x62, 0x36, 0x64, 0x61, 0x65, 0x62, 0x37, 0x36, 0x35, 0x65, 0x63, 0x63, 0x65, 0x39, 0x63, 0x36, 0x30, 0x62, 0x61, 0x32, 0x38, 0x62, 0x32, 0x39, 0x66, 0x34, 0x34, 0x66, 0x37, 0x34, 0x65, 0x36, 0x30, 0x30, 0x65, 0x63, 0x31, 0x64, 0x35, 0x32, 0x30, 0x39, 0x32, 0x35, 0x39, 0x38, 0x64, 0x34, 0x33, 0x64, 0x32, 0x37, 0x32, 0x34, 0x64, 0x30, 0x34, 0x61, 0x32, 0x32, 0x31, 0x63, 0x37, 0x63, 0x61, 0x30, 0x31, 0x35, 0x39, 0x31, 0x30, 0x34, 0x33, 0x38, 0x33, 0x64, 0x61, 0x32, 0x64, 0x65, 0x37, 0x34, 0x36, 0x61, 0x37, 0x30, 0x30, 0x36, 0x30, 0x32, 0x33, 0x62, 0x35, 0x33, 0x37, 0x32, 0x36, 0x30, 0x34, 0x39, 0x30, 0x66, 0x62, 0x30, 0x63, 0x36, 0x37, 0x32, 0x63, 0x30, 0x36, 0x66, 0x38, 0x37, 0x32, 0x31, 0x39, 0x32, 0x65, 0x62, 0x34, 0x65, 0x64, 0x31, 0x38, 0x63, 0x62, 0x39, 0x33, 0x30, 0x32, 0x35, 0x62, 0x39, 0x61, 0x31, 0x31, 0x66, 0x63, 0x32, 0x33, 0x64, 0x39, 0x30, 0x37, 0x66, 0x37, 0x63, 0x61, 0x66, 0x62, 0x39, 0x61, 0x37, 0x65, 0x65, 0x62, 0x39, 0x63, 0x31, 0x32, 0x31, 0x35, 0x62, 0x37, 0x36, 0x37, 0x66, 0x65, 0x62, 0x33, 0x33, 0x64, 0x62, 0x66, 0x32, 0x33, 0x32, 0x37, 0x38, 0x62, 0x39, 0x61, 0x61, 0x61, 0x30, 0x30, 0x32, 0x35, 0x30, 0x37, 0x32, 0x31, 0x35, 0x31, 0x62, 0x63, 0x63, 0x63, 0x31, 0x62, 0x38, 0x34, 0x66, 0x36, 0x61, 0x34, 0x32, 0x35, 0x34, 0x38, 0x31, 0x38, 0x62, 0x38, 0x34, 0x35, 0x35, 0x37, 0x30, 0x39, 0x38, 0x31, 0x31, 0x64, 0x38, 0x39, 0x61, 0x63, 0x35, 0x66, 0x62, 0x34, 0x65, 0x35, 0x32, 0x32, 0x63, 0x64, 0x63, 0x30, 0x65, 0x34, 0x37, 0x64, 0x31, 0x31, 0x64, 0x35, 0x37, 0x35, 0x63, 0x66, 0x33, 0x38, 0x37, 0x35, 0x65, 0x65, 0x36, 0x65, 0x30, 0x61, 0x31, 0x64, 0x38, 0x33, 0x37, 0x39, 0x31, 0x35, 0x33, 0x38, 0x30, 0x65, 0x62, 0x66, 0x31, 0x62, 0x37, 0x62, 0x38, 0x62, 0x61, 0x34, 0x38, 0x64, 0x66, 0x36, 0x66, 0x64, 0x61, 0x63, 0x35, 0x38, 0x64, 0x39, 0x37, 0x37, 0x32, 0x63, 0x32, 0x38, 0x66, 0x64, 0x36, 0x33, 0x31, 0x39, 0x33, 0x65, 0x34, 0x64, 0x62, 0x35, 0x65, 0x30, 0x62, 0x37, 0x31, 0x33, 0x36, 0x35, 0x31, 0x32, 0x38, 0x37, 0x37, 0x31, 0x33, 0x37, 0x66, 0x38, 0x33, 0x30, 0x35, 0x31, 0x61, 0x31, 0x66, 0x38, 0x66, 0x33, 0x65, 0x39, 0x61, 0x65, 0x30, 0x37, 0x33, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x65, 0x63, 0x63, 0x32, 0x37, 0x32, 0x34, 0x63, 0x65, 0x61, 0x62, 0x33, 0x33, 0x38, 0x37, 0x63, 0x66, 0x61, 0x65, 0x62, 0x39, 0x34, 0x33, 0x37, 0x65, 0x34, 0x36, 0x31, 0x36, 0x33, 0x31, 0x63, 0x37, 0x61, 0x65, 0x63, 0x32, 0x35, 0x38, 0x33, 0x64, 0x39, 0x30, 0x63, 0x36, 0x33, 0x65, 0x30, 0x62, 0x35, 0x62, 0x33, 0x33, 0x35, 0x33, 0x31, 0x65, 0x30, 0x65, 0x33, 0x32, 0x66, 0x33, 0x39, 0x38, 0x36, 0x35, 0x36, 0x37, 0x30, 0x62, 0x36, 0x33, 0x65, 0x30, 0x61, 0x36, 0x37, 0x30, 0x63, 0x33, 0x34, 0x61, 0x31, 0x64, 0x63, 0x64, 0x63, 0x63, 0x30, 0x35, 0x32, 0x38, 0x38, 0x36, 0x62, 0x34, 0x39, 0x34, 0x66, 0x63, 0x65, 0x63, 0x35, 0x30, 0x39, 0x33, 0x31, 0x63, 0x63, 0x34, 0x33, 0x33, 0x30, 0x34, 0x39, 0x64, 0x32, 0x64, 0x32, 0x38, 0x32, 0x63, 0x36, 0x34, 0x65, 0x31, 0x39, 0x35, 0x39, 0x32, 0x31, 0x37, 0x32, 0x38, 0x64, 0x65, 0x66, 0x37, 0x65, 0x36, 0x30, 0x62, 0x31, 0x62, 0x62, 0x33, 0x38, 0x33, 0x31, 0x32, 0x66, 0x63, 0x63, 0x30, 0x66, 0x61, 0x38, 0x35, 0x65, 0x31, 0x62, 0x39, 0x65, 0x35, 0x30, 0x65, 0x64, 0x65, 0x31, 0x34, 0x34, 0x34, 0x37, 0x31, 0x33, 0x31, 0x38, 0x38, 0x65, 0x38, 0x34, 0x30, 0x64, 0x37, 0x32, 0x65, 0x66, 0x31, 0x31, 0x30, 0x64, 0x62, 0x37, 0x62, 0x36, 0x37, 0x32, 0x37, 0x63, 0x38, 0x61, 0x37, 0x38, 0x33, 0x36, 0x31, 0x31, 0x33, 0x38, 0x35, 0x63, 0x32, 0x63, 0x66, 0x64, 0x36, 0x35, 0x63, 0x34, 0x37, 0x36, 0x39, 0x38, 0x31, 0x38, 0x61, 0x64, 0x38, 0x37, 0x37, 0x61, 0x35, 0x30, 0x63, 0x37, 0x35, 0x66, 0x30, 0x36, 0x65, 0x62, 0x33, 0x66, 0x37, 0x61, 0x37, 0x62, 0x34, 0x34, 0x34, 0x61, 0x30, 0x34, 0x66, 0x39, 0x34, 0x36, 0x31, 0x37, 0x37, 0x32, 0x31, 0x34, 0x64, 0x36, 0x65, 0x62, 0x39, 0x30, 0x32, 0x36, 0x65, 0x33, 0x66, 0x33, 0x32, 0x36, 0x31, 0x35, 0x34, 0x35, 0x31, 0x34, 0x31, 0x34, 0x35, 0x63, 0x31, 0x65, 0x37, 0x65, 0x64, 0x34, 0x65, 0x64, 0x33, 0x31, 0x63, 0x65, 0x33, 0x65, 0x64, 0x39, 0x62, 0x32, 0x66, 0x64, 0x65, 0x39, 0x62, 0x37, 0x63, 0x38, 0x36, 0x37, 0x35, 0x31, 0x39, 0x36, 0x66, 0x39, 0x30, 0x65, 0x37, 0x32, 0x65, 0x62, 0x34, 0x35, 0x33, 0x61, 0x37, 0x36, 0x34, 0x64, 0x30, 0x31, 0x39, 0x37, 0x37, 0x63, 0x36, 0x30, 0x32, 0x64, 0x34, 0x64, 0x30, 0x64, 0x64, 0x33, 0x39, 0x37, 0x30, 0x32, 0x31, 0x34, 0x62, 0x35, 0x39, 0x62, 0x34, 0x38, 0x66, 0x34, 0x62, 0x64, 0x31, 0x38, 0x30, 0x35, 0x37, 0x64, 0x38, 0x36, 0x37, 0x30, 0x36, 0x35, 0x62, 0x33, 0x39, 0x64, 0x61, 0x31, 0x39, 0x32, 0x37, 0x32, 0x35, 0x61, 0x37, 0x61, 0x63, 0x61, 0x30, 0x31, 0x30, 0x66, 0x63, 0x63, 0x65, 0x34, 0x63, 0x32, 0x37, 0x62, 0x34, 0x62, 0x66, 0x39, 0x33, 0x31, 0x61, 0x37, 0x65, 0x64, 0x30, 0x30, 0x30, 0x39, 0x33, 0x30, 0x61, 0x30, 0x63, 0x35, 0x37, 0x61, 0x33, 0x61, 0x62, 0x66, 0x36, 0x35, 0x36, 0x38, 0x37, 0x30, 0x30, 0x35, 0x64, 0x38, 0x36, 0x36, 0x32, 0x30, 0x65, 0x34, 0x30, 0x63, 0x37, 0x32, 0x37, 0x31, 0x36, 0x62, 0x32, 0x66, 0x63, 0x35, 0x34, 0x64, 0x33, 0x36, 0x37, 0x35, 0x31, 0x34, 0x64, 0x66, 0x39, 0x66, 0x38, 0x38, 0x31, 0x35, 0x39, 0x64, 0x63, 0x64, 0x33, 0x30, 0x32, 0x64, 0x32, 0x62, 0x34, 0x31, 0x32, 0x32, 0x38, 0x65, 0x63, 0x30, 0x66, 0x37, 0x31, 0x61, 0x64, 0x36, 0x35, 0x39, 0x61, 0x62, 0x35, 0x36, 0x63, 0x36, 0x35, 0x64, 0x31, 0x66, 0x36, 0x39, 0x37, 0x32, 0x33, 0x33, 0x31, 0x38, 0x61, 0x31, 0x63, 0x39, 0x64, 0x66, 0x30, 0x65, 0x32, 0x37, 0x65, 0x38, 0x62, 0x36, 0x34, 0x39, 0x66, 0x64, 0x35, 0x62, 0x63, 0x37, 0x37, 0x30, 0x31, 0x65, 0x39, 0x34, 0x66, 0x35, 0x34, 0x34, 0x33, 0x38, 0x35, 0x32, 0x38, 0x65, 0x35, 0x36, 0x63, 0x65, 0x64, 0x65, 0x65, 0x66, 0x32, 0x34, 0x37, 0x31, 0x66, 0x31, 0x63, 0x31, 0x62, 0x35, 0x66, 0x31, 0x30, 0x61, 0x35, 0x34, 0x30, 0x61, 0x32, 0x62, 0x38, 0x34, 0x30, 0x30, 0x37, 0x31, 0x35, 0x30, 0x66, 0x30, 0x31, 0x37, 0x38, 0x38, 0x63, 0x61, 0x37, 0x38, 0x65, 0x63, 0x62, 0x64, 0x39, 0x62, 0x64, 0x64, 0x62, 0x64, 0x38, 0x32, 0x31, 0x34, 0x35, 0x31, 0x39, 0x37, 0x62, 0x36, 0x32, 0x63, 0x30, 0x31, 0x30, 0x31, 0x39, 0x38, 0x39, 0x38, 0x31, 0x64, 0x65, 0x32, 0x66, 0x31, 0x30, 0x30, 0x37, 0x32, 0x35, 0x61, 0x65, 0x62, 0x34, 0x38, 0x30, 0x65, 0x36, 0x65, 0x30, 0x61, 0x36, 0x61, 0x38, 0x36, 0x33, 0x66, 0x30, 0x65, 0x34, 0x39, 0x35, 0x38, 0x39, 0x36, 0x61, 0x33, 0x32, 0x32, 0x30, 0x66, 0x34, 0x66, 0x62, 0x35, 0x62, 0x30, 0x65, 0x34, 0x64, 0x65, 0x39, 0x38, 0x36, 0x31, 0x63, 0x64, 0x64, 0x39, 0x33, 0x37, 0x38, 0x36, 0x39, 0x32, 0x30, 0x63, 0x39, 0x65, 0x32, 0x35, 0x33, 0x32, 0x38, 0x38, 0x35, 0x33, 0x37, 0x37, 0x37, 0x30, 0x34, 0x37, 0x66, 0x38, 0x62, 0x31, 0x37, 0x64, 0x62, 0x39, 0x32, 0x65, 0x34, 0x33, 0x32, 0x39, 0x34, 0x31, 0x65, 0x66, 0x63, 0x35, 0x35, 0x38, 0x31, 0x38, 0x66, 0x35, 0x34, 0x32, 0x62, 0x35, 0x39, 0x37, 0x34, 0x64, 0x31, 0x63, 0x65, 0x64, 0x32, 0x37, 0x62, 0x36, 0x39, 0x65, 0x30, 0x63, 0x34, 0x30, 0x61, 0x66, 0x35, 0x35, 0x37, 0x32, 0x38, 0x63, 0x31, 0x66, 0x32, 0x30, 0x61, 0x37, 0x39, 0x38, 0x66, 0x65, 0x32, 0x66, 0x30, 0x37, 0x32, 0x36, 0x36, 0x39, 0x65, 0x39, 0x30, 0x64, 0x34, 0x38, 0x62, 0x39, 0x36, 0x30, 0x31, 0x66, 0x35, 0x37, 0x38, 0x34, 0x33, 0x34, 0x30, 0x64, 0x33, 0x64, 0x38, 0x38, 0x61, 0x61, 0x62, 0x64, 0x30, 0x35, 0x36, 0x38, 0x63, 0x65, 0x34, 0x34, 0x39, 0x37, 0x37, 0x65, 0x61, 0x61, 0x34, 0x66, 0x33, 0x31, 0x33, 0x38, 0x31, 0x65, 0x65, 0x30, 0x39, 0x63, 0x65, 0x33, 0x65, 0x62, 0x66, 0x65, 0x32, 0x32, 0x36, 0x65, 0x37, 0x30, 0x30, 0x39, 0x62, 0x65, 0x31, 0x39, 0x39, 0x30, 0x35, 0x64, 0x61, 0x32, 0x63, 0x34, 0x32, 0x66, 0x61, 0x66, 0x66, 0x38, 0x62, 0x33, 0x63, 0x34, 0x33, 0x38, 0x64, 0x37, 0x39, 0x32, 0x61, 0x34, 0x38, 0x37, 0x63, 0x30, 0x36, 0x39, 0x38, 0x31, 0x37, 0x32, 0x39, 0x66, 0x65, 0x61, 0x63, 0x38, 0x38, 0x30, 0x39, 0x63, 0x31, 0x65, 0x30, 0x34, 0x62, 0x38, 0x32, 0x64, 0x64, 0x65, 0x36, 0x38, 0x38, 0x36, 0x39, 0x62, 0x35, 0x33, 0x65, 0x63, 0x35, 0x32, 0x63, 0x31, 0x30, 0x30, 0x31, 0x39, 0x66, 0x32, 0x31, 0x32, 0x37, 0x63, 0x33, 0x35, 0x33, 0x33, 0x62, 0x38, 0x61, 0x39, 0x38, 0x37, 0x37, 0x35, 0x65, 0x62, 0x63, 0x32, 0x65, 0x62, 0x37, 0x32, 0x64, 0x38, 0x65, 0x38, 0x32, 0x64, 0x65, 0x36, 0x65, 0x35, 0x62, 0x33, 0x63, 0x32, 0x39, 0x36, 0x33, 0x32, 0x33, 0x31, 0x38, 0x34, 0x36, 0x39, 0x61, 0x38, 0x39, 0x62, 0x64, 0x35, 0x39, 0x66, 0x38, 0x37, 0x31, 0x63, 0x31, 0x36, 0x34, 0x66, 0x30, 0x39, 0x66, 0x39, 0x33, 0x36, 0x66, 0x39, 0x31, 0x35, 0x32, 0x38, 0x30, 0x39, 0x37, 0x63, 0x39, 0x30, 0x32, 0x61, 0x62, 0x34, 0x34, 0x38, 0x64, 0x66, 0x39, 0x32, 0x36, 0x62, 0x30, 0x66, 0x35, 0x62, 0x65, 0x36, 0x35, 0x61, 0x35, 0x36, 0x31, 0x35, 0x32, 0x62, 0x33, 0x38, 0x65, 0x66, 0x33, 0x61, 0x63, 0x36, 0x66, 0x31, 0x33, 0x64, 0x35, 0x62, 0x62, 0x65, 0x39, 0x39, 0x61, 0x38, 0x64, 0x35, 0x30, 0x38, 0x39, 0x38, 0x37, 0x61, 0x62, 0x38, 0x39, 0x39, 0x36, 0x35, 0x31, 0x39, 0x32, 0x37, 0x32, 0x63, 0x30, 0x32, 0x32, 0x66, 0x63, 0x33, 0x30, 0x62, 0x30, 0x35, 0x64, 0x63, 0x31, 0x32, 0x38, 0x62, 0x30, 0x64, 0x37, 0x38, 0x62, 0x34, 0x38, 0x36, 0x31, 0x35, 0x65, 0x64, 0x64, 0x30, 0x35, 0x64, 0x66, 0x63, 0x35, 0x39, 0x39, 0x66, 0x35, 0x37, 0x35, 0x38, 0x30, 0x36, 0x33, 0x39, 0x35, 0x63, 0x38, 0x66, 0x66, 0x34, 0x39, 0x62, 0x66, 0x37, 0x66, 0x35, 0x35, 0x66, 0x63, 0x39, 0x63, 0x36, 0x39, 0x32, 0x37, 0x32, 0x33, 0x35, 0x64, 0x37, 0x61, 0x34, 0x34, 0x37, 0x35, 0x30, 0x34, 0x61, 0x38, 0x30, 0x30, 0x35, 0x38, 0x62, 0x33, 0x35, 0x30, 0x64, 0x66, 0x37, 0x30, 0x61, 0x38, 0x66, 0x35, 0x63, 0x31, 0x31, 0x62, 0x32, 0x39, 0x30, 0x66, 0x36, 0x36, 0x30, 0x30, 0x38, 0x33, 0x33, 0x30, 0x62, 0x36, 0x39, 0x30, 0x37, 0x35, 0x38, 0x36, 0x39, 0x61, 0x37, 0x34, 0x38, 0x38, 0x64, 0x31, 0x66, 0x30, 0x30, 0x32, 0x63, 0x39, 0x64, 0x65, 0x65, 0x37, 0x30, 0x32, 0x35, 0x31, 0x30, 0x33, 0x37, 0x61, 0x61, 0x38, 0x39, 0x39, 0x62, 0x33, 0x36, 0x63, 0x64, 0x66, 0x38, 0x39, 0x62, 0x66, 0x61, 0x39, 0x32, 0x35, 0x34, 0x39, 0x31, 0x36, 0x39, 0x61, 0x39, 0x33, 0x62, 0x31, 0x62, 0x65, 0x32, 0x64, 0x61, 0x35, 0x30, 0x62, 0x31, 0x30, 0x39, 0x36, 0x31, 0x66, 0x32, 0x65, 0x65, 0x62, 0x39, 0x37, 0x32, 0x62, 0x31, 0x33, 0x38, 0x64, 0x39, 0x66, 0x66, 0x32, 0x36, 0x61, 0x31, 0x30, 0x66, 0x64, 0x32, 0x61, 0x32, 0x66, 0x66, 0x64, 0x61, 0x34, 0x61, 0x33, 0x61, 0x62, 0x33, 0x34, 0x63, 0x35, 0x35, 0x36, 0x33, 0x33, 0x65, 0x35, 0x32, 0x34, 0x33, 0x62, 0x66, 0x35, 0x61, 0x66, 0x30, 0x31, 0x32, 0x37, 0x64, 0x34, 0x35, 0x66, 0x61, 0x38, 0x34, 0x35, 0x39, 0x61, 0x61, 0x31, 0x62, 0x37, 0x32, 0x33, 0x31, 0x64, 0x66, 0x32, 0x32, 0x31, 0x30, 0x35, 0x61, 0x65, 0x33, 0x64, 0x35, 0x37, 0x38, 0x31, 0x34, 0x33, 0x37, 0x32, 0x30, 0x36, 0x39, 0x66, 0x36, 0x61, 0x30, 0x38, 0x30, 0x32, 0x31, 0x38, 0x65, 0x31, 0x66, 0x35, 0x62, 0x62, 0x39, 0x35, 0x33, 0x30, 0x32, 0x38, 0x36, 0x33, 0x31, 0x37, 0x38, 0x32, 0x65, 0x63, 0x35, 0x34, 0x65, 0x34, 0x38, 0x66, 0x37, 0x37, 0x34, 0x37, 0x32, 0x37, 0x61, 0x64, 0x63, 0x62, 0x38, 0x34, 0x31, 0x37, 0x38, 0x65, 0x39, 0x62, 0x34, 0x65, 0x31, 0x31, 0x34, 0x64, 0x34, 0x64, 0x37, 0x32, 0x35, 0x62, 0x62, 0x38, 0x62, 0x63, 0x64, 0x61, 0x37, 0x31, 0x35, 0x32, 0x64, 0x30, 0x34, 0x64, 0x31, 0x66, 0x39, 0x33, 0x63, 0x38, 0x36, 0x31, 0x37, 0x39, 0x31, 0x34, 0x33, 0x61, 0x34, 0x63, 0x32, 0x32, 0x65, 0x39, 0x65, 0x32, 0x61, 0x37, 0x32, 0x30, 0x36, 0x66, 0x32, 0x66, 0x30, 0x35, 0x66, 0x35, 0x34, 0x61, 0x31, 0x65, 0x62, 0x36, 0x34, 0x66, 0x31, 0x36, 0x38, 0x32, 0x32, 0x35, 0x31, 0x65, 0x39, 0x63, 0x63, 0x64, 0x34, 0x30, 0x38, 0x37, 0x66, 0x64, 0x30, 0x38, 0x66, 0x63, 0x32, 0x39, 0x31, 0x38, 0x34, 0x36, 0x32, 0x34, 0x36, 0x39, 0x61, 0x33, 0x30, 0x63, 0x36, 0x33, 0x31, 0x33, 0x36, 0x36, 0x30, 0x34, 0x39, 0x37, 0x32, 0x37, 0x35, 0x39, 0x32, 0x63, 0x34, 0x39, 0x34, 0x65, 0x35, 0x62, 0x63, 0x64, 0x62, 0x32, 0x31, 0x32, 0x34, 0x35, 0x63, 0x64, 0x64, 0x66, 0x37, 0x64, 0x65, 0x39, 0x62, 0x30, 0x61, 0x30, 0x62, 0x32, 0x66, 0x61, 0x37, 0x34, 0x35, 0x31, 0x30, 0x38, 0x30, 0x65, 0x37, 0x64, 0x65, 0x39, 0x37, 0x32, 0x34, 0x61, 0x34, 0x64, 0x65, 0x64, 0x36, 0x37, 0x37, 0x30, 0x37, 0x38, 0x62, 0x37, 0x32, 0x39, 0x36, 0x33, 0x30, 0x39, 0x63, 0x35, 0x34, 0x35, 0x39, 0x30, 0x31, 0x65, 0x66, 0x64, 0x33, 0x64, 0x38, 0x37, 0x38, 0x66, 0x33, 0x35, 0x33, 0x33, 0x66, 0x38, 0x37, 0x31, 0x33, 0x38, 0x36, 0x39, 0x39, 0x36, 0x30, 0x62, 0x31, 0x34, 0x30, 0x61, 0x32, 0x66, 0x65, 0x62, 0x61, 0x31, 0x61, 0x65, 0x35, 0x65, 0x39, 0x64, 0x30, 0x64, 0x62, 0x35, 0x33, 0x37, 0x38, 0x35, 0x33, 0x37, 0x32, 0x30, 0x39, 0x63, 0x63, 0x31, 0x37, 0x35, 0x31, 0x36, 0x66, 0x61, 0x32, 0x62, 0x38, 0x38, 0x31, 0x61, 0x66, 0x63, 0x39, 0x36, 0x30, 0x62, 0x61, 0x37, 0x39, 0x63, 0x66, 0x30, 0x64, 0x32, 0x31, 0x63, 0x35, 0x39, 0x31, 0x62, 0x65, 0x39, 0x63, 0x65, 0x33, 0x66, 0x63, 0x62, 0x34, 0x33, 0x63, 0x34, 0x32, 0x39, 0x63, 0x39, 0x39, 0x61, 0x33, 0x35, 0x30, 0x36, 0x38, 0x64, 0x62, 0x37, 0x32, 0x62, 0x32, 0x35, 0x31, 0x32, 0x35, 0x32, 0x62, 0x30, 0x62, 0x33, 0x37, 0x37, 0x31, 0x34, 0x34, 0x38, 0x32, 0x32, 0x65, 0x37, 0x62, 0x34, 0x33, 0x62, 0x63, 0x39, 0x39, 0x66, 0x34, 0x34, 0x63, 0x36, 0x63, 0x61, 0x64, 0x64, 0x35, 0x30, 0x31, 0x65, 0x64, 0x61, 0x39, 0x62, 0x37, 0x64, 0x65, 0x31, 0x62, 0x39, 0x33, 0x61, 0x37, 0x32, 0x63, 0x63, 0x36, 0x62, 0x36, 0x38, 0x32, 0x37, 0x32, 0x39, 0x62, 0x36, 0x36, 0x36, 0x65, 0x38, 0x66, 0x38, 0x31, 0x37, 0x63, 0x66, 0x31, 0x36, 0x62, 0x64, 0x30, 0x32, 0x33, 0x37, 0x31, 0x39, 0x64, 0x34, 0x32, 0x63, 0x65, 0x33, 0x38, 0x37, 0x33, 0x38, 0x30, 0x61, 0x63, 0x38, 0x37, 0x64, 0x32, 0x33, 0x36, 0x32, 0x63, 0x34, 0x66, 0x33, 0x33, 0x30, 0x65, 0x34, 0x33, 0x39, 0x33, 0x64, 0x34, 0x65, 0x38, 0x61, 0x63, 0x65, 0x33, 0x37, 0x32, 0x64, 0x39, 0x33, 0x66, 0x30, 0x66, 0x36, 0x66, 0x33, 0x61, 0x36, 0x30, 0x62, 0x32, 0x30, 0x34, 0x38, 0x34, 0x34, 0x31, 0x36, 0x30, 0x62, 0x33, 0x33, 0x61, 0x61, 0x30, 0x36, 0x34, 0x35, 0x35, 0x31, 0x32, 0x30, 0x33, 0x64, 0x31, 0x37, 0x64, 0x35, 0x32, 0x65, 0x62, 0x37, 0x35, 0x39, 0x36, 0x37, 0x36, 0x62, 0x36, 0x36, 0x62, 0x34, 0x63, 0x39, 0x61, 0x63, 0x35, 0x61, 0x32, 0x37, 0x32, 0x66, 0x66, 0x64, 0x37, 0x62, 0x61, 0x38, 0x37, 0x61, 0x34, 0x39, 0x32, 0x39, 0x33, 0x30, 0x39, 0x34, 0x62, 0x37, 0x30, 0x36, 0x63, 0x37, 0x37, 0x62, 0x31, 0x33, 0x37, 0x66, 0x62, 0x62, 0x33, 0x39, 0x62, 0x64, 0x65, 0x35, 0x66, 0x35, 0x31, 0x35, 0x31, 0x33, 0x64, 0x38, 0x66, 0x65, 0x39, 0x38, 0x32, 0x36, 0x37, 0x62, 0x39, 0x36, 0x61, 0x66, 0x66, 0x38, 0x64, 0x30, 0x31, 0x31, 0x31, 0x32, 0x33, 0x66, 0x37, 0x32, 0x62, 0x37, 0x38, 0x37, 0x31, 0x37, 0x34, 0x33, 0x66, 0x36, 0x39, 0x30, 0x65, 0x62, 0x61, 0x64, 0x37, 0x35, 0x64, 0x36, 0x36, 0x38, 0x61, 0x38, 0x30, 0x66, 0x38, 0x61, 0x38, 0x39, 0x30, 0x33, 0x62, 0x39, 0x65, 0x63, 0x65, 0x39, 0x65, 0x61, 0x61, 0x37, 0x66, 0x33, 0x66, 0x35, 0x31, 0x62, 0x34, 0x66, 0x35, 0x33, 0x63, 0x36, 0x65, 0x35, 0x30, 0x35, 0x65, 0x33, 0x61, 0x34, 0x61, 0x32, 0x39, 0x65, 0x61, 0x36, 0x66, 0x39, 0x35, 0x39, 0x61, 0x39, 0x30, 0x65, 0x38, 0x64, 0x32, 0x62, 0x33, 0x35, 0x35, 0x32, 0x35, 0x36, 0x32, 0x37, 0x64, 0x37, 0x35, 0x30, 0x36, 0x36, 0x62, 0x62, 0x35, 0x63, 0x62, 0x38, 0x30, 0x34, 0x32, 0x37, 0x33, 0x65, 0x32, 0x66, 0x31, 0x31, 0x63, 0x39, 0x62, 0x33, 0x39, 0x36, 0x65, 0x39, 0x37, 0x39, 0x65, 0x35, 0x33, 0x63, 0x62, 0x33, 0x61, 0x31, 0x65, 0x63, 0x62, 0x64, 0x66, 0x34, 0x38, 0x62, 0x61, 0x63, 0x39, 0x36, 0x37, 0x64, 0x35, 0x62, 0x64, 0x31, 0x33, 0x63, 0x38, 0x66, 0x35, 0x31, 0x39, 0x66, 0x30, 0x66, 0x61, 0x37, 0x31, 0x62, 0x66, 0x35, 0x32, 0x39, 0x32, 0x31, 0x32, 0x35, 0x36, 0x61, 0x61, 0x65, 0x30, 0x39, 0x66, 0x65, 0x62, 0x35, 0x30, 0x66, 0x36, 0x36, 0x64, 0x64, 0x37, 0x37, 0x32, 0x62, 0x62, 0x31, 0x34, 0x37, 0x38, 0x34, 0x34, 0x66, 0x31, 0x38, 0x37, 0x61, 0x63, 0x62, 0x61, 0x37, 0x35, 0x30, 0x30, 0x62, 0x64, 0x35, 0x33, 0x33, 0x34, 0x30, 0x63, 0x63, 0x33, 0x37, 0x32, 0x34, 0x38, 0x65, 0x39, 0x38, 0x62, 0x39, 0x35, 0x66, 0x66, 0x66, 0x35, 0x61, 0x30, 0x34, 0x66, 0x31, 0x37, 0x39, 0x37, 0x61, 0x39, 0x66, 0x32, 0x61, 0x32, 0x35, 0x33, 0x37, 0x30, 0x37, 0x32, 0x62, 0x62, 0x32, 0x32, 0x30, 0x36, 0x39, 0x35, 0x66, 0x34, 0x66, 0x66, 0x38, 0x64, 0x35, 0x38, 0x61, 0x66, 0x62, 0x37, 0x34, 0x36, 0x37, 0x39, 0x36, 0x30, 0x65, 0x38, 0x63, 0x64, 0x39, 0x61, 0x36, 0x62, 0x32, 0x65, 0x38, 0x63, 0x31, 0x36, 0x34, 0x65, 0x36, 0x32, 0x34, 0x31, 0x32, 0x39, 0x63, 0x65, 0x35, 0x37, 0x34, 0x66, 0x34, 0x32, 0x64, 0x32, 0x38, 0x33, 0x63, 0x30, 0x37, 0x32, 0x38, 0x31, 0x33, 0x64, 0x32, 0x38, 0x34, 0x66, 0x65, 0x65, 0x36, 0x36, 0x65, 0x64, 0x39, 0x39, 0x36, 0x37, 0x65, 0x63, 0x30, 0x36, 0x64, 0x32, 0x36, 0x36, 0x64, 0x32, 0x34, 0x38, 0x36, 0x31, 0x34, 0x31, 0x36, 0x31, 0x31, 0x32, 0x34, 0x39, 0x31, 0x62, 0x65, 0x35, 0x30, 0x32, 0x30, 0x37, 0x64, 0x31, 0x34, 0x34, 0x64, 0x37, 0x65, 0x63, 0x36, 0x37, 0x65, 0x63, 0x66, 0x64, 0x37, 0x32, 0x38, 0x64, 0x62, 0x34, 0x63, 0x31, 0x38, 0x64, 0x38, 0x35, 0x32, 0x39, 0x32, 0x63, 0x36, 0x63, 0x62, 0x31, 0x62, 0x64, 0x33, 0x63, 0x37, 0x37, 0x61, 0x33, 0x39, 0x62, 0x35, 0x63, 0x38, 0x31, 0x65, 0x32, 0x66, 0x62, 0x63, 0x32, 0x65, 0x35, 0x33, 0x34, 0x66, 0x34, 0x33, 0x63, 0x63, 0x61, 0x64, 0x32, 0x33, 0x39, 0x36, 0x62, 0x39, 0x31, 0x30, 0x39, 0x33, 0x36, 0x35, 0x39, 0x37, 0x32, 0x61, 0x39, 0x38, 0x30, 0x37, 0x63, 0x37, 0x38, 0x61, 0x30, 0x32, 0x31, 0x33, 0x65, 0x62, 0x63, 0x30, 0x38, 0x35, 0x30, 0x38, 0x31, 0x65, 0x63, 0x33, 0x35, 0x38, 0x36, 0x35, 0x32, 0x61, 0x34, 0x66, 0x66, 0x65, 0x30, 0x65, 0x36, 0x66, 0x39, 0x32, 0x63, 0x64, 0x30, 0x33, 0x34, 0x32, 0x39, 0x61, 0x39, 0x31, 0x32, 0x37, 0x66, 0x63, 0x63, 0x38, 0x63, 0x32, 0x66, 0x63, 0x34, 0x37, 0x32, 0x38, 0x33, 0x31, 0x37, 0x31, 0x32, 0x32, 0x65, 0x63, 0x33, 0x30, 0x64, 0x35, 0x39, 0x37, 0x37, 0x61, 0x39, 0x38, 0x39, 0x62, 0x39, 0x33, 0x62, 0x63, 0x61, 0x64, 0x65, 0x35, 0x36, 0x66, 0x39, 0x62, 0x62, 0x38, 0x66, 0x66, 0x33, 0x39, 0x30, 0x30, 0x63, 0x62, 0x64, 0x31, 0x66, 0x62, 0x32, 0x30, 0x61, 0x30, 0x39, 0x66, 0x33, 0x64, 0x32, 0x32, 0x30, 0x39, 0x65, 0x33, 0x35, 0x33, 0x63, 0x30, 0x66, 0x66, 0x61, 0x33, 0x33, 0x35, 0x30, 0x36, 0x34, 0x64, 0x38, 0x36, 0x36, 0x66, 0x66, 0x63, 0x32, 0x33, 0x65, 0x35, 0x64, 0x37, 0x65, 0x36, 0x39, 0x36, 0x62, 0x63, 0x64, 0x63, 0x33, 0x34, 0x66, 0x64, 0x37, 0x37, 0x36, 0x30, 0x37, 0x64, 0x34, 0x32, 0x62, 0x33, 0x66, 0x39, 0x33, 0x62, 0x37, 0x31, 0x34, 0x66, 0x63, 0x37, 0x38, 0x38, 0x32, 0x65, 0x65, 0x37, 0x37, 0x36, 0x66, 0x37, 0x33, 0x36, 0x66, 0x64, 0x63, 0x38, 0x62, 0x36, 0x36, 0x62, 0x65, 0x30, 0x33, 0x33, 0x33, 0x31, 0x62, 0x61, 0x34, 0x61, 0x38, 0x37, 0x32, 0x62, 0x63, 0x64, 0x66, 0x63, 0x66, 0x66, 0x30, 0x61, 0x30, 0x63, 0x63, 0x35, 0x33, 0x38, 0x32, 0x32, 0x66, 0x34, 0x39, 0x37, 0x64, 0x64, 0x33, 0x35, 0x30, 0x39, 0x65, 0x33, 0x38, 0x61, 0x33, 0x64, 0x33, 0x34, 0x30, 0x66, 0x33, 0x37, 0x32, 0x38, 0x35, 0x32, 0x30, 0x36, 0x65, 0x66, 0x32, 0x64, 0x38, 0x64, 0x65, 0x39, 0x65, 0x64, 0x32, 0x36, 0x64, 0x32, 0x65, 0x37, 0x65, 0x38, 0x31, 0x38, 0x37, 0x36, 0x36, 0x62, 0x64, 0x64, 0x30, 0x31, 0x37, 0x36, 0x66, 0x36, 0x32, 0x61, 0x61, 0x63, 0x39, 0x62, 0x66, 0x32, 0x66, 0x38, 0x30, 0x32, 0x39, 0x33, 0x39, 0x34, 0x32, 0x35, 0x65, 0x64, 0x37, 0x37, 0x37, 0x35, 0x63, 0x37, 0x32, 0x66, 0x30, 0x31, 0x39, 0x37, 0x63, 0x39, 0x37, 0x35, 0x32, 0x66, 0x38, 0x62, 0x63, 0x36, 0x36, 0x32, 0x30, 0x61, 0x38, 0x35, 0x38, 0x30, 0x31, 0x63, 0x38, 0x39, 0x35, 0x65, 0x33, 0x33, 0x30, 0x34, 0x34, 0x30, 0x38, 0x66, 0x38, 0x37, 0x61, 0x32, 0x62, 0x61, 0x34, 0x33, 0x65, 0x66, 0x31, 0x34, 0x35, 0x31, 0x33, 0x61, 0x33, 0x62, 0x39, 0x38, 0x66, 0x31, 0x61, 0x64, 0x62, 0x34, 0x63, 0x63, 0x64, 0x62, 0x34, 0x63, 0x31, 0x30, 0x32, 0x31, 0x66, 0x35, 0x65, 0x32, 0x63, 0x34, 0x36, 0x63, 0x33, 0x64, 0x35, 0x33, 0x62, 0x33, 0x32, 0x65, 0x33, 0x65, 0x34, 0x34, 0x66, 0x61, 0x32, 0x37, 0x32, 0x39, 0x33, 0x66, 0x38, 0x38, 0x35, 0x64, 0x36, 0x63, 0x65, 0x61, 0x65, 0x39, 0x38, 0x62, 0x39, 0x39, 0x33, 0x62, 0x65, 0x30, 0x35, 0x39, 0x36, 0x38, 0x64, 0x65, 0x39, 0x37, 0x32, 0x64, 0x30, 0x65, 0x64, 0x63, 0x61, 0x65, 0x64, 0x65, 0x64, 0x65, 0x62, 0x31, 0x62, 0x35, 0x37, 0x62, 0x63, 0x64, 0x66, 0x30, 0x66, 0x64, 0x31, 0x66, 0x31, 0x61, 0x32, 0x30, 0x36, 0x37, 0x39, 0x66, 0x66, 0x65, 0x36, 0x36, 0x38, 0x61, 0x37, 0x64, 0x62, 0x31, 0x31, 0x31, 0x30, 0x36, 0x32, 0x35, 0x34, 0x30, 0x62, 0x33, 0x30, 0x36, 0x65, 0x38, 0x34, 0x65, 0x63, 0x30, 0x66, 0x36, 0x35, 0x65, 0x35, 0x34, 0x63, 0x37, 0x63, 0x36, 0x34, 0x39, 0x61, 0x34, 0x63, 0x37, 0x31, 0x36, 0x62, 0x36, 0x62, 0x39, 0x65, 0x35, 0x32, 0x32, 0x31, 0x30, 0x37, 0x66, 0x33, 0x37, 0x31, 0x38, 0x35, 0x31, 0x37, 0x37, 0x64, 0x36, 0x34, 0x62, 0x38, 0x61, 0x35, 0x62, 0x62, 0x31, 0x37, 0x32, 0x65, 0x36, 0x62, 0x38, 0x61, 0x30, 0x36, 0x61, 0x33, 0x37, 0x37, 0x39, 0x64, 0x31, 0x38, 0x37, 0x32, 0x33, 0x33, 0x62, 0x38, 0x33, 0x36, 0x39, 0x61, 0x32, 0x61, 0x36, 0x31, 0x30, 0x32, 0x62, 0x31, 0x34, 0x33, 0x38, 0x33, 0x30, 0x35, 0x39, 0x32, 0x32, 0x66, 0x39, 0x63, 0x34, 0x38, 0x38, 0x38, 0x61, 0x38, 0x35, 0x62, 0x37, 0x65, 0x64, 0x37, 0x39, 0x37, 0x39, 0x34, 0x64, 0x38, 0x39, 0x65, 0x36, 0x30, 0x30, 0x63, 0x34, 0x65, 0x36, 0x32, 0x64, 0x36, 0x34, 0x64, 0x65, 0x62, 0x30, 0x63, 0x38, 0x64, 0x36, 0x61, 0x34, 0x36, 0x37, 0x64, 0x62, 0x31, 0x61, 0x61, 0x30, 0x64, 0x64, 0x33, 0x34, 0x30, 0x35, 0x38, 0x34, 0x31, 0x64, 0x36, 0x39, 0x38, 0x30, 0x64, 0x62, 0x63, 0x39, 0x38, 0x65, 0x61, 0x33, 0x33, 0x61, 0x65, 0x38, 0x65, 0x66, 0x32, 0x64, 0x31, 0x35, 0x65, 0x34, 0x35, 0x31, 0x33, 0x65, 0x37, 0x33, 0x30, 0x63, 0x31, 0x66, 0x61, 0x63, 0x63, 0x62, 0x38, 0x37, 0x32, 0x31, 0x30, 0x62, 0x33, 0x62, 0x65, 0x34, 0x36, 0x33, 0x62, 0x31, 0x62, 0x30, 0x37, 0x61, 0x36, 0x65, 0x61, 0x32, 0x62, 0x38, 0x38, 0x66, 0x37, 0x64, 0x65, 0x31, 0x30, 0x37, 0x35, 0x33, 0x32, 0x66, 0x38, 0x61, 0x34, 0x62, 0x33, 0x62, 0x36, 0x65, 0x63, 0x64, 0x31, 0x31, 0x62, 0x30, 0x33, 0x61, 0x39, 0x33, 0x35, 0x63, 0x35, 0x63, 0x34, 0x31, 0x30, 0x61, 0x35, 0x38, 0x64, 0x37, 0x32, 0x31, 0x34, 0x62, 0x38, 0x63, 0x33, 0x33, 0x31, 0x65, 0x61, 0x37, 0x62, 0x35, 0x34, 0x36, 0x38, 0x34, 0x61, 0x38, 0x30, 0x30, 0x61, 0x39, 0x33, 0x34, 0x37, 0x37, 0x32, 0x65, 0x63, 0x34, 0x35, 0x62, 0x65, 0x35, 0x66, 0x62, 0x37, 0x32, 0x36, 0x63, 0x30, 0x39, 0x34, 0x63, 0x38, 0x35, 0x35, 0x33, 0x36, 0x66, 0x37, 0x63, 0x31, 0x35, 0x63, 0x66, 0x33, 0x30, 0x34, 0x32, 0x65, 0x31, 0x32, 0x61, 0x33, 0x37, 0x31, 0x39, 0x63, 0x62, 0x32, 0x35, 0x37, 0x36, 0x37, 0x66, 0x37, 0x36, 0x63, 0x61, 0x34, 0x65, 0x61, 0x37, 0x64, 0x35, 0x63, 0x37, 0x64, 0x62, 0x39, 0x63, 0x34, 0x32, 0x37, 0x30, 0x33, 0x36, 0x65, 0x36, 0x38, 0x34, 0x38, 0x30, 0x35, 0x35, 0x34, 0x35, 0x39, 0x62, 0x35, 0x36, 0x66, 0x61, 0x36, 0x65, 0x66, 0x30, 0x32, 0x31, 0x64, 0x65, 0x37, 0x38, 0x62, 0x35, 0x31, 0x38, 0x62, 0x36, 0x38, 0x63, 0x36, 0x33, 0x34, 0x63, 0x61, 0x30, 0x37, 0x36, 0x39, 0x37, 0x39, 0x39, 0x61, 0x39, 0x64, 0x63, 0x66, 0x33, 0x66, 0x33, 0x32, 0x37, 0x64, 0x34, 0x33, 0x35, 0x36, 0x39, 0x35, 0x32, 0x33, 0x64, 0x66, 0x66, 0x32, 0x33, 0x30, 0x30, 0x31, 0x62, 0x33, 0x36, 0x32, 0x32, 0x39, 0x37, 0x31, 0x36, 0x61, 0x37, 0x36, 0x37, 0x38, 0x62, 0x30, 0x38, 0x30, 0x37, 0x32, 0x64, 0x35, 0x31, 0x34, 0x37, 0x33, 0x65, 0x66, 0x35, 0x61, 0x33, 0x63, 0x30, 0x36, 0x34, 0x36, 0x64, 0x34, 0x37, 0x33, 0x62, 0x32, 0x38, 0x64, 0x34, 0x62, 0x38, 0x31, 0x62, 0x62, 0x39, 0x34, 0x36, 0x66, 0x32, 0x63, 0x61, 0x38, 0x66, 0x38, 0x65, 0x31, 0x65, 0x61, 0x33, 0x35, 0x33, 0x37, 0x39, 0x33, 0x65, 0x62, 0x35, 0x39, 0x36, 0x39, 0x30, 0x64, 0x31, 0x36, 0x39, 0x35, 0x37, 0x32, 0x61, 0x30, 0x63, 0x30, 0x31, 0x32, 0x63, 0x65, 0x64, 0x31, 0x39, 0x63, 0x64, 0x34, 0x62, 0x63, 0x61, 0x32, 0x36, 0x65, 0x32, 0x34, 0x31, 0x66, 0x34, 0x61, 0x31, 0x61, 0x34, 0x63, 0x30, 0x39, 0x37, 0x66, 0x61, 0x39, 0x61, 0x31, 0x36, 0x65, 0x35, 0x30, 0x33, 0x38, 0x35, 0x31, 0x63, 0x39, 0x30, 0x34, 0x37, 0x31, 0x62, 0x36, 0x34, 0x64, 0x34, 0x39, 0x64, 0x37, 0x37, 0x34, 0x37, 0x32, 0x32, 0x37, 0x30, 0x37, 0x39, 0x33, 0x64, 0x31, 0x31, 0x38, 0x38, 0x61, 0x31, 0x62, 0x65, 0x33, 0x31, 0x36, 0x62, 0x61, 0x65, 0x65, 0x64, 0x35, 0x64, 0x34, 0x31, 0x32, 0x66, 0x38, 0x36, 0x66, 0x39, 0x32, 0x35, 0x61, 0x38, 0x32, 0x34, 0x38, 0x65, 0x33, 0x35, 0x34, 0x30, 0x63, 0x35, 0x32, 0x37, 0x61, 0x39, 0x36, 0x31, 0x39, 0x65, 0x30, 0x36, 0x30, 0x36, 0x31, 0x65, 0x62, 0x33, 0x65, 0x63, 0x62, 0x36, 0x33, 0x33, 0x34, 0x33, 0x65, 0x62, 0x37, 0x66, 0x36, 0x62, 0x32, 0x38, 0x61, 0x34, 0x31, 0x30, 0x39, 0x31, 0x65, 0x36, 0x31, 0x37, 0x38, 0x32, 0x32, 0x30, 0x65, 0x64, 0x32, 0x66, 0x39, 0x38, 0x31, 0x62, 0x36, 0x35, 0x30, 0x39, 0x64, 0x62, 0x63, 0x65, 0x35, 0x38, 0x61, 0x61, 0x66, 0x36, 0x62, 0x61, 0x36, 0x64, 0x36, 0x31, 0x35, 0x39, 0x62, 0x33, 0x31, 0x37, 0x32, 0x34, 0x63, 0x38, 0x35, 0x65, 0x32, 0x37, 0x34, 0x30, 0x61, 0x35, 0x36, 0x33, 0x65, 0x39, 0x38, 0x30, 0x63, 0x36, 0x35, 0x37, 0x65, 0x34, 0x36, 0x62, 0x63, 0x37, 0x36, 0x62, 0x39, 0x38, 0x32, 0x66, 0x37, 0x33, 0x65, 0x39, 0x64, 0x38, 0x64, 0x64, 0x32, 0x63, 0x35, 0x66, 0x33, 0x34, 0x62, 0x63, 0x38, 0x35, 0x31, 0x38, 0x32, 0x39, 0x63, 0x38, 0x63, 0x62, 0x62, 0x33, 0x33, 0x37, 0x32, 0x37, 0x30, 0x36, 0x62, 0x33, 0x37, 0x63, 0x31, 0x34, 0x35, 0x32, 0x36, 0x63, 0x66, 0x34, 0x33, 0x30, 0x30, 0x34, 0x38, 0x32, 0x62, 0x33, 0x61, 0x61, 0x66, 0x38, 0x62, 0x63, 0x36, 0x31, 0x33, 0x63, 0x33, 0x62, 0x62, 0x65, 0x38, 0x30, 0x35, 0x32, 0x38, 0x35, 0x65, 0x39, 0x35, 0x32, 0x32, 0x39, 0x35, 0x65, 0x34, 0x66, 0x63, 0x31, 0x34, 0x33, 0x61, 0x38, 0x30, 0x32, 0x38, 0x37, 0x32, 0x39, 0x34, 0x33, 0x66, 0x66, 0x32, 0x61, 0x30, 0x38, 0x39, 0x66, 0x30, 0x35, 0x33, 0x30, 0x31, 0x34, 0x64, 0x62, 0x66, 0x62, 0x30, 0x36, 0x35, 0x36, 0x33, 0x36, 0x30, 0x31, 0x35, 0x37, 0x62, 0x37, 0x34, 0x34, 0x34, 0x66, 0x36, 0x62, 0x37, 0x37, 0x38, 0x31, 0x35, 0x37, 0x30, 0x38, 0x32, 0x37, 0x36, 0x63, 0x31, 0x61, 0x33, 0x36, 0x35, 0x65, 0x36, 0x39, 0x65, 0x62, 0x61, 0x30, 0x33, 0x61, 0x39, 0x31, 0x37, 0x61, 0x33, 0x35, 0x66, 0x65, 0x31, 0x65, 0x38, 0x35, 0x63, 0x32, 0x34, 0x64, 0x31, 0x62, 0x31, 0x36, 0x63, 0x32, 0x61, 0x61, 0x61, 0x35, 0x32, 0x32, 0x38, 0x38, 0x31, 0x30, 0x37, 0x32, 0x38, 0x36, 0x38, 0x35, 0x32, 0x38, 0x36, 0x33, 0x31, 0x30, 0x39, 0x64, 0x33, 0x34, 0x61, 0x62, 0x61, 0x62, 0x33, 0x65, 0x36, 0x34, 0x62, 0x30, 0x34, 0x37, 0x63, 0x34, 0x66, 0x31, 0x34, 0x64, 0x30, 0x35, 0x32, 0x31, 0x63, 0x30, 0x64, 0x38, 0x37, 0x64, 0x37, 0x35, 0x64, 0x34, 0x30, 0x64, 0x35, 0x38, 0x62, 0x31, 0x30, 0x38, 0x36, 0x37, 0x61, 0x31, 0x35, 0x36, 0x30, 0x36, 0x30, 0x63, 0x31, 0x34, 0x62, 0x39, 0x32, 0x39, 0x39, 0x63, 0x36, 0x37, 0x32, 0x61, 0x33, 0x39, 0x31, 0x38, 0x37, 0x31, 0x31, 0x36, 0x33, 0x31, 0x32, 0x61, 0x65, 0x30, 0x32, 0x30, 0x31, 0x39, 0x63, 0x62, 0x35, 0x38, 0x30, 0x32, 0x37, 0x34, 0x64, 0x35, 0x34, 0x64, 0x66, 0x36, 0x32, 0x38, 0x38, 0x63, 0x33, 0x34, 0x63, 0x65, 0x33, 0x38, 0x33, 0x35, 0x30, 0x66, 0x61, 0x35, 0x62, 0x64, 0x65, 0x31, 0x30, 0x39, 0x62, 0x62, 0x33, 0x63, 0x32, 0x31, 0x33, 0x34, 0x34, 0x31, 0x65, 0x31, 0x35, 0x61, 0x64, 0x34, 0x61, 0x62, 0x36, 0x61, 0x61, 0x37, 0x33, 0x36, 0x34, 0x34, 0x35, 0x61, 0x61, 0x33, 0x33, 0x37, 0x65, 0x65, 0x61, 0x64, 0x66, 0x34, 0x62, 0x31, 0x65, 0x39, 0x64, 0x64, 0x65, 0x33, 0x30, 0x38, 0x37, 0x62, 0x33, 0x37, 0x62, 0x65, 0x36, 0x32, 0x35, 0x37, 0x35, 0x38, 0x32, 0x62, 0x61, 0x62, 0x65, 0x33, 0x33, 0x66, 0x66, 0x65, 0x31, 0x62, 0x31, 0x66, 0x66, 0x66, 0x36, 0x63, 0x63, 0x61, 0x30, 0x35, 0x63, 0x66, 0x31, 0x66, 0x39, 0x61, 0x65, 0x37, 0x32, 0x62, 0x32, 0x61, 0x37, 0x38, 0x32, 0x39, 0x39, 0x38, 0x35, 0x31, 0x34, 0x37, 0x36, 0x36, 0x39, 0x37, 0x66, 0x34, 0x66, 0x35, 0x36, 0x66, 0x65, 0x34, 0x65, 0x33, 0x36, 0x64, 0x61, 0x38, 0x36, 0x38, 0x35, 0x37, 0x38, 0x33, 0x64, 0x63, 0x39, 0x35, 0x34, 0x63, 0x39, 0x66, 0x30, 0x30, 0x31, 0x61, 0x35, 0x36, 0x66, 0x37, 0x31, 0x36, 0x39, 0x32, 0x35, 0x64, 0x65, 0x66, 0x31, 0x32, 0x64, 0x66, 0x34, 0x31, 0x39, 0x33, 0x35, 0x32, 0x34, 0x38, 0x63, 0x37, 0x32, 0x62, 0x33, 0x35, 0x36, 0x61, 0x30, 0x66, 0x30, 0x35, 0x63, 0x32, 0x38, 0x66, 0x38, 0x39, 0x63, 0x36, 0x31, 0x61, 0x34, 0x61, 0x36, 0x36, 0x39, 0x39, 0x35, 0x64, 0x30, 0x34, 0x62, 0x31, 0x30, 0x30, 0x31, 0x63, 0x37, 0x61, 0x34, 0x38, 0x63, 0x30, 0x61, 0x33, 0x65, 0x33, 0x32, 0x35, 0x38, 0x61, 0x37, 0x36, 0x64, 0x36, 0x33, 0x65, 0x31, 0x33, 0x61, 0x35, 0x63, 0x65, 0x35, 0x32, 0x32, 0x38, 0x37, 0x30, 0x61, 0x66, 0x34, 0x31, 0x63, 0x37, 0x32, 0x64, 0x37, 0x62, 0x61, 0x34, 0x63, 0x36, 0x33, 0x39, 0x65, 0x35, 0x38, 0x32, 0x31, 0x64, 0x35, 0x65, 0x32, 0x30, 0x37, 0x37, 0x39, 0x32, 0x30, 0x32, 0x65, 0x34, 0x30, 0x35, 0x31, 0x61, 0x62, 0x30, 0x38, 0x62, 0x35, 0x35, 0x63, 0x33, 0x31, 0x37, 0x32, 0x65, 0x66, 0x37, 0x62, 0x37, 0x64, 0x37, 0x33, 0x61, 0x39, 0x30, 0x35, 0x33, 0x62, 0x34, 0x39, 0x34, 0x65, 0x63, 0x65, 0x64, 0x34, 0x32, 0x64, 0x65, 0x37, 0x37, 0x61, 0x65, 0x36, 0x63, 0x61, 0x31, 0x65, 0x35, 0x38, 0x31, 0x66, 0x38, 0x66, 0x33, 0x64, 0x37, 0x61, 0x35, 0x32, 0x39, 0x30, 0x32, 0x32, 0x33, 0x39, 0x30, 0x38, 0x32, 0x31, 0x37, 0x33, 0x63, 0x39, 0x32, 0x33, 0x36, 0x63, 0x63, 0x35, 0x36, 0x36, 0x34, 0x36, 0x39, 0x32, 0x33, 0x64, 0x35, 0x35, 0x38, 0x65, 0x37, 0x33, 0x66, 0x37, 0x61, 0x64, 0x65, 0x38, 0x32, 0x35, 0x31, 0x36, 0x64, 0x39, 0x30, 0x62, 0x65, 0x36, 0x63, 0x61, 0x65, 0x36, 0x39, 0x62, 0x32, 0x37, 0x36, 0x37, 0x36, 0x64, 0x33, 0x63, 0x39, 0x33, 0x35, 0x62, 0x64, 0x38, 0x35, 0x30, 0x61, 0x31, 0x33, 0x36, 0x33, 0x32, 0x61, 0x61, 0x37, 0x32, 0x61, 0x33, 0x62, 0x36, 0x32, 0x31, 0x63, 0x35, 0x31, 0x31, 0x31, 0x63, 0x65, 0x63, 0x38, 0x39, 0x37, 0x66, 0x37, 0x61, 0x36, 0x66, 0x66, 0x63, 0x62, 0x37, 0x64, 0x64, 0x65, 0x30, 0x34, 0x62, 0x64, 0x31, 0x33, 0x32, 0x39, 0x62, 0x33, 0x61, 0x31, 0x32, 0x37, 0x31, 0x36, 0x37, 0x33, 0x37, 0x38, 0x63, 0x32, 0x62, 0x38, 0x30, 0x62, 0x30, 0x38, 0x33, 0x30, 0x63, 0x35, 0x61, 0x37, 0x32, 0x66, 0x39, 0x35, 0x39, 0x32, 0x36, 0x35, 0x32, 0x63, 0x63, 0x38, 0x32, 0x36, 0x61, 0x36, 0x62, 0x37, 0x30, 0x39, 0x37, 0x39, 0x38, 0x61, 0x36, 0x63, 0x32, 0x63, 0x65, 0x33, 0x66, 0x32, 0x38, 0x38, 0x64, 0x30, 0x37, 0x64, 0x65, 0x36, 0x63, 0x38, 0x65, 0x63, 0x38, 0x31, 0x33, 0x66, 0x36, 0x35, 0x37, 0x63, 0x62, 0x61, 0x66, 0x39, 0x33, 0x33, 0x63, 0x31, 0x61, 0x33, 0x62, 0x37, 0x32, 0x34, 0x38, 0x36, 0x37, 0x39, 0x65, 0x32, 0x64, 0x36, 0x63, 0x39, 0x61, 0x64, 0x35, 0x62, 0x38, 0x62, 0x34, 0x62, 0x62, 0x39, 0x61, 0x38, 0x35, 0x31, 0x36, 0x38, 0x35, 0x35, 0x33, 0x30, 0x37, 0x38, 0x62, 0x63, 0x62, 0x34, 0x62, 0x37, 0x65, 0x62, 0x30, 0x62, 0x61, 0x38, 0x61, 0x37, 0x63, 0x34, 0x61, 0x36, 0x31, 0x37, 0x65, 0x66, 0x36, 0x63, 0x39, 0x66, 0x37, 0x34, 0x30, 0x37, 0x32, 0x62, 0x37, 0x64, 0x62, 0x61, 0x62, 0x30, 0x63, 0x62, 0x62, 0x36, 0x36, 0x36, 0x38, 0x65, 0x36, 0x32, 0x30, 0x34, 0x38, 0x66, 0x64, 0x36, 0x66, 0x38, 0x33, 0x61, 0x64, 0x38, 0x37, 0x66, 0x61, 0x38, 0x30, 0x33, 0x61, 0x38, 0x64, 0x38, 0x39, 0x33, 0x35, 0x62, 0x33, 0x63, 0x61, 0x33, 0x32, 0x33, 0x66, 0x39, 0x61, 0x37, 0x61, 0x64, 0x33, 0x32, 0x39, 0x39, 0x35, 0x66, 0x33, 0x36, 0x30, 0x62, 0x30, 0x65, 0x32, 0x36, 0x39, 0x32, 0x30, 0x37, 0x65, 0x33, 0x31, 0x32, 0x34, 0x36, 0x35, 0x33, 0x63, 0x34, 0x63, 0x61, 0x36, 0x34, 0x30, 0x30, 0x63, 0x39, 0x39, 0x33, 0x64, 0x34, 0x34, 0x32, 0x30, 0x36, 0x32, 0x32, 0x65, 0x63, 0x63, 0x62, 0x65, 0x63, 0x34, 0x31, 0x36, 0x65, 0x31, 0x35, 0x38, 0x62, 0x33, 0x35, 0x31, 0x32, 0x32, 0x35, 0x35, 0x66, 0x65, 0x61, 0x34, 0x37, 0x32, 0x35, 0x33, 0x61, 0x38, 0x66, 0x63, 0x35, 0x36, 0x66, 0x37, 0x64, 0x62, 0x65, 0x64, 0x64, 0x37, 0x33, 0x31, 0x61, 0x33, 0x62, 0x32, 0x39, 0x65, 0x30, 0x36, 0x66, 0x64, 0x33, 0x30, 0x37, 0x61, 0x36, 0x36, 0x62, 0x65, 0x65, 0x34, 0x62, 0x64, 0x65, 0x39, 0x61, 0x35, 0x31, 0x64, 0x31, 0x30, 0x64, 0x34, 0x34, 0x33, 0x36, 0x66, 0x37, 0x34, 0x30, 0x34, 0x61, 0x61, 0x35, 0x38, 0x34, 0x37, 0x35, 0x36, 0x38, 0x35, 0x61, 0x39, 0x34, 0x36, 0x34, 0x30, 0x61, 0x31, 0x31, 0x30, 0x63, 0x35, 0x34, 0x37, 0x34, 0x33, 0x39, 0x64, 0x30, 0x63, 0x65, 0x37, 0x61, 0x66, 0x65, 0x64, 0x37, 0x64, 0x33, 0x66, 0x34, 0x33, 0x34, 0x62, 0x66, 0x66, 0x39, 0x61, 0x38, 0x37, 0x65, 0x65, 0x66, 0x35, 0x39, 0x64, 0x31, 0x32, 0x39, 0x37, 0x31, 0x31, 0x37, 0x62, 0x39, 0x64, 0x33, 0x33, 0x37, 0x32, 0x33, 0x36, 0x37, 0x30, 0x66, 0x38, 0x36, 0x66, 0x66, 0x39, 0x64, 0x35, 0x30, 0x38, 0x38, 0x39, 0x37, 0x61, 0x38, 0x39, 0x63, 0x36, 0x63, 0x38, 0x36, 0x31, 0x31, 0x38, 0x34, 0x66, 0x33, 0x65, 0x62, 0x66, 0x38, 0x65, 0x61, 0x31, 0x36, 0x33, 0x35, 0x38, 0x31, 0x61, 0x65, 0x37, 0x34, 0x36, 0x35, 0x62, 0x65, 0x32, 0x38, 0x61, 0x65, 0x39, 0x31, 0x37, 0x36, 0x61, 0x35, 0x65, 0x34, 0x65, 0x63, 0x34, 0x61, 0x34, 0x32, 0x36, 0x64, 0x36, 0x34, 0x34, 0x61, 0x33, 0x38, 0x62, 0x39, 0x39, 0x35, 0x62, 0x33, 0x63, 0x39, 0x36, 0x61, 0x63, 0x64, 0x63, 0x61, 0x34, 0x63, 0x37, 0x64, 0x39, 0x61, 0x36, 0x33, 0x38, 0x37, 0x65, 0x64, 0x64, 0x34, 0x64, 0x66, 0x34, 0x63, 0x32, 0x35, 0x31, 0x66, 0x61, 0x63, 0x38, 0x35, 0x31, 0x30, 0x32, 0x66, 0x36, 0x32, 0x61, 0x31, 0x64, 0x37, 0x32, 0x35, 0x31, 0x31, 0x64, 0x64, 0x31, 0x35, 0x38, 0x32, 0x65, 0x66, 0x30, 0x61, 0x30, 0x39, 0x35, 0x64, 0x62, 0x32, 0x34, 0x39, 0x31, 0x37, 0x36, 0x31, 0x65, 0x32, 0x64, 0x31, 0x62, 0x31, 0x35, 0x32, 0x65, 0x62, 0x66, 0x38, 0x63, 0x63, 0x61, 0x62, 0x34, 0x34, 0x32, 0x66, 0x34, 0x38, 0x39, 0x36, 0x31, 0x36, 0x35, 0x61, 0x34, 0x63, 0x65, 0x63, 0x32, 0x63, 0x61, 0x64, 0x61, 0x37, 0x32, 0x62, 0x61, 0x64, 0x64, 0x33, 0x38, 0x32, 0x34, 0x65, 0x39, 0x38, 0x35, 0x31, 0x61, 0x36, 0x31, 0x63, 0x39, 0x34, 0x62, 0x31, 0x35, 0x33, 0x61, 0x34, 0x65, 0x37, 0x36, 0x64, 0x38, 0x33, 0x35, 0x31, 0x66, 0x31, 0x66, 0x65, 0x39, 0x30, 0x36, 0x38, 0x30, 0x30, 0x34, 0x33, 0x63, 0x37, 0x35, 0x32, 0x62, 0x62, 0x66, 0x32, 0x31, 0x35, 0x33, 0x34, 0x39, 0x35, 0x63, 0x33, 0x31, 0x37, 0x32, 0x63, 0x63, 0x64, 0x64, 0x65, 0x31, 0x36, 0x33, 0x31, 0x30, 0x65, 0x62, 0x66, 0x66, 0x64, 0x37, 0x62, 0x32, 0x33, 0x37, 0x62, 0x62, 0x35, 0x39, 0x66, 0x63, 0x37, 0x37, 0x39, 0x64, 0x61, 0x65, 0x65, 0x39, 0x37, 0x62, 0x33, 0x65, 0x32, 0x30, 0x35, 0x34, 0x30, 0x31, 0x33, 0x33, 0x61, 0x34, 0x61, 0x61, 0x37, 0x33, 0x38, 0x34, 0x65, 0x33, 0x36, 0x31, 0x38, 0x62, 0x36, 0x65, 0x34, 0x39, 0x31, 0x32, 0x65, 0x36, 0x36, 0x33, 0x65, 0x36, 0x38, 0x30, 0x35, 0x65, 0x35, 0x38, 0x33, 0x36, 0x34, 0x65, 0x31, 0x66, 0x33, 0x61, 0x34, 0x32, 0x30, 0x65, 0x32, 0x36, 0x34, 0x30, 0x66, 0x32, 0x39, 0x37, 0x63, 0x65, 0x33, 0x38, 0x38, 0x38, 0x31, 0x35, 0x66, 0x30, 0x36, 0x66, 0x30, 0x65, 0x61, 0x61, 0x33, 0x65, 0x37, 0x65, 0x64, 0x62, 0x35, 0x62, 0x36, 0x66, 0x33, 0x63, 0x37, 0x32, 0x38, 0x30, 0x33, 0x62, 0x38, 0x66, 0x39, 0x37, 0x64, 0x34, 0x32, 0x36, 0x61, 0x30, 0x39, 0x61, 0x35, 0x37, 0x36, 0x32, 0x62, 0x62, 0x36, 0x34, 0x62, 0x32, 0x31, 0x66, 0x34, 0x35, 0x34, 0x30, 0x63, 0x66, 0x63, 0x32, 0x36, 0x31, 0x33, 0x66, 0x38, 0x37, 0x35, 0x30, 0x38, 0x30, 0x62, 0x63, 0x66, 0x31, 0x31, 0x33, 0x65, 0x31, 0x39, 0x33, 0x62, 0x32, 0x33, 0x33, 0x39, 0x30, 0x37, 0x32, 0x31, 0x36, 0x36, 0x62, 0x38, 0x38, 0x32, 0x35, 0x30, 0x62, 0x38, 0x36, 0x36, 0x65, 0x64, 0x66, 0x36, 0x33, 0x32, 0x62, 0x65, 0x64, 0x37, 0x35, 0x64, 0x37, 0x65, 0x33, 0x65, 0x34, 0x63, 0x30, 0x63, 0x33, 0x32, 0x37, 0x36, 0x38, 0x66, 0x62, 0x64, 0x36, 0x36, 0x34, 0x36, 0x65, 0x32, 0x62, 0x62, 0x61, 0x31, 0x64, 0x31, 0x66, 0x31, 0x38, 0x39, 0x32, 0x33, 0x35, 0x38, 0x36, 0x37, 0x32, 0x37, 0x66, 0x61, 0x35, 0x66, 0x32, 0x39, 0x34, 0x30, 0x35, 0x61, 0x65, 0x66, 0x39, 0x65, 0x36, 0x61, 0x31, 0x38, 0x34, 0x31, 0x36, 0x61, 0x31, 0x37, 0x64, 0x34, 0x63, 0x33, 0x61, 0x36, 0x66, 0x64, 0x35, 0x62, 0x63, 0x39, 0x65, 0x65, 0x31, 0x39, 0x61, 0x34, 0x61, 0x32, 0x32, 0x30, 0x66, 0x36, 0x63, 0x38, 0x38, 0x30, 0x33, 0x65, 0x65, 0x39, 0x33, 0x39, 0x30, 0x31, 0x66, 0x32, 0x32, 0x64, 0x35, 0x65, 0x36, 0x66, 0x61, 0x33, 0x37, 0x38, 0x64, 0x30, 0x32, 0x63, 0x38, 0x61, 0x61, 0x61, 0x34, 0x62, 0x37, 0x35, 0x62, 0x33, 0x33, 0x33, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x62, 0x65, 0x63, 0x36, 0x37, 0x30, 0x36, 0x62, 0x64, 0x61, 0x35, 0x37, 0x39, 0x35, 0x65, 0x34, 0x33, 0x35, 0x30, 0x35, 0x33, 0x33, 0x39, 0x33, 0x32, 0x36, 0x65, 0x37, 0x65, 0x62, 0x36, 0x33, 0x66, 0x63, 0x38, 0x33, 0x33, 0x35, 0x34, 0x30, 0x63, 0x37, 0x35, 0x63, 0x32, 0x36, 0x30, 0x36, 0x64, 0x34, 0x37, 0x36, 0x38, 0x62, 0x62, 0x64, 0x34, 0x38, 0x30, 0x62, 0x33, 0x66, 0x31, 0x39, 0x37, 0x31, 0x31, 0x35, 0x39, 0x65, 0x31, 0x31, 0x31, 0x34, 0x63, 0x61, 0x62, 0x65, 0x36, 0x33, 0x32, 0x61, 0x31, 0x38, 0x33, 0x64, 0x36, 0x36, 0x63, 0x35, 0x36, 0x32, 0x36, 0x66, 0x31, 0x30, 0x33, 0x36, 0x36, 0x37, 0x39, 0x32, 0x39, 0x62, 0x30, 0x35, 0x35, 0x62, 0x39, 0x33, 0x32, 0x30, 0x39, 0x32, 0x34, 0x65, 0x37, 0x34, 0x38, 0x63, 0x64, 0x64, 0x39, 0x37, 0x62, 0x39, 0x63, 0x32, 0x31, 0x64, 0x35, 0x61, 0x37, 0x65, 0x63, 0x62, 0x38, 0x32, 0x63, 0x61, 0x63, 0x38, 0x64, 0x62, 0x63, 0x61, 0x65, 0x62, 0x66, 0x35, 0x32, 0x31, 0x36, 0x38, 0x31, 0x38, 0x30, 0x33, 0x64, 0x37, 0x32, 0x35, 0x39, 0x33, 0x36, 0x38, 0x61, 0x30, 0x30, 0x34, 0x66, 0x30, 0x35, 0x33, 0x61, 0x39, 0x65, 0x61, 0x33, 0x38, 0x30, 0x62, 0x34, 0x31, 0x32, 0x64, 0x63, 0x31, 0x61, 0x63, 0x62, 0x32, 0x34, 0x63, 0x63, 0x64, 0x64, 0x39, 0x64, 0x36, 0x63, 0x37, 0x64, 0x61, 0x65, 0x32, 0x30, 0x37, 0x31, 0x65, 0x62, 0x35, 0x39, 0x64, 0x30, 0x30, 0x35, 0x35, 0x35, 0x61, 0x66, 0x35, 0x32, 0x37, 0x32, 0x32, 0x30, 0x64, 0x32, 0x61, 0x66, 0x64, 0x63, 0x31, 0x61, 0x30, 0x34, 0x63, 0x35, 0x38, 0x63, 0x33, 0x31, 0x31, 0x31, 0x33, 0x32, 0x64, 0x63, 0x36, 0x63, 0x32, 0x66, 0x61, 0x39, 0x33, 0x61, 0x38, 0x39, 0x63, 0x38, 0x36, 0x38, 0x37, 0x63, 0x62, 0x37, 0x36, 0x63, 0x30, 0x64, 0x35, 0x33, 0x65, 0x35, 0x36, 0x35, 0x39, 0x61, 0x66, 0x65, 0x62, 0x32, 0x64, 0x66, 0x33, 0x63, 0x33, 0x39, 0x63, 0x33, 0x61, 0x37, 0x39, 0x35, 0x37, 0x38, 0x63, 0x39, 0x33, 0x64, 0x35, 0x30, 0x62, 0x37, 0x35, 0x35, 0x39, 0x36, 0x37, 0x62, 0x38, 0x37, 0x39, 0x65, 0x31, 0x65, 0x63, 0x31, 0x39, 0x66, 0x34, 0x66, 0x66, 0x38, 0x36, 0x64, 0x31, 0x63, 0x34, 0x33, 0x38, 0x65, 0x64, 0x64, 0x33, 0x62, 0x37, 0x38, 0x30, 0x65, 0x31, 0x65, 0x39, 0x62, 0x34, 0x66, 0x30, 0x31, 0x37, 0x63, 0x30, 0x32, 0x33, 0x65, 0x30, 0x31, 0x31, 0x63, 0x32, 0x30, 0x39, 0x35, 0x31, 0x31, 0x64, 0x66, 0x36, 0x30, 0x31, 0x62, 0x37, 0x64, 0x33, 0x37, 0x39, 0x62, 0x37, 0x34, 0x64, 0x38, 0x31, 0x39, 0x64, 0x35, 0x32, 0x36, 0x34, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x61, 0x30, 0x39, 0x65, 0x61, 0x38, 0x62, 0x62, 0x66, 0x36, 0x62, 0x64, 0x38, 0x62, 0x39, 0x32, 0x63, 0x31, 0x63, 0x33, 0x65, 0x37, 0x32, 0x37, 0x30, 0x36, 0x65, 0x33, 0x35, 0x37, 0x32, 0x64, 0x65, 0x32, 0x64, 0x64, 0x64, 0x31, 0x38, 0x33, 0x66, 0x33, 0x33, 0x61, 0x38, 0x32, 0x39, 0x39, 0x63, 0x31, 0x64, 0x65, 0x37, 0x32, 0x62, 0x66, 0x32, 0x37, 0x36, 0x39, 0x66, 0x61, 0x39, 0x61, 0x39, 0x38, 0x33, 0x36, 0x61, 0x39, 0x31, 0x33, 0x35, 0x35, 0x34, 0x30, 0x37, 0x32, 0x36, 0x33, 0x33, 0x62, 0x31, 0x61, 0x31, 0x37, 0x32, 0x62, 0x34, 0x38, 0x64, 0x66, 0x62, 0x36, 0x31, 0x64, 0x37, 0x30, 0x34, 0x31, 0x39, 0x62, 0x30, 0x37, 0x35, 0x31, 0x37, 0x63, 0x62, 0x36, 0x64, 0x38, 0x66, 0x33, 0x63, 0x37, 0x66, 0x34, 0x32, 0x65, 0x32, 0x66, 0x38, 0x30, 0x38, 0x64, 0x65, 0x36, 0x31, 0x61, 0x36, 0x64, 0x62, 0x31, 0x34, 0x38, 0x36, 0x63, 0x63, 0x38, 0x38, 0x30, 0x30, 0x30, 0x62, 0x31, 0x61, 0x32, 0x37, 0x30, 0x64, 0x39, 0x38, 0x30, 0x37, 0x36, 0x34, 0x34, 0x38, 0x37, 0x36, 0x61, 0x35, 0x33, 0x64, 0x39, 0x63, 0x62, 0x66, 0x35, 0x35, 0x38, 0x63, 0x66, 0x38, 0x61, 0x64, 0x61, 0x33, 0x37, 0x37, 0x62, 0x61, 0x65, 0x31, 0x36, 0x62, 0x38, 0x31, 0x31, 0x33, 0x38, 0x61, 0x65, 0x31, 0x33, 0x34, 0x34, 0x36, 0x34, 0x32, 0x65, 0x38, 0x37, 0x38, 0x30, 0x31, 0x63, 0x33, 0x33, 0x33, 0x62, 0x38, 0x30, 0x32, 0x65, 0x61, 0x30, 0x35, 0x65, 0x63, 0x32, 0x66, 0x39, 0x63, 0x36, 0x61, 0x61, 0x64, 0x36, 0x62, 0x30, 0x63, 0x32, 0x39, 0x66, 0x61, 0x31, 0x31, 0x30, 0x31, 0x38, 0x34, 0x31, 0x64, 0x38, 0x61, 0x36, 0x38, 0x36, 0x37, 0x32, 0x65, 0x39, 0x65, 0x34, 0x37, 0x36, 0x33, 0x32, 0x36, 0x35, 0x31, 0x64, 0x34, 0x37, 0x39, 0x62, 0x64, 0x65, 0x30, 0x33, 0x33, 0x65, 0x35, 0x34, 0x39, 0x33, 0x36, 0x30, 0x62, 0x39, 0x36, 0x38, 0x34, 0x33, 0x36, 0x33, 0x36, 0x32, 0x35, 0x30, 0x33, 0x62, 0x64, 0x30, 0x34, 0x36, 0x38, 0x34, 0x35, 0x38, 0x64, 0x34, 0x35, 0x34, 0x38, 0x33, 0x38, 0x38, 0x65, 0x66, 0x35, 0x31, 0x35, 0x65, 0x31, 0x64, 0x36, 0x32, 0x38, 0x34, 0x36, 0x61, 0x35, 0x31, 0x66, 0x38, 0x36, 0x61, 0x63, 0x35, 0x33, 0x32, 0x62, 0x36, 0x34, 0x39, 0x61, 0x61, 0x33, 0x35, 0x37, 0x32, 0x61, 0x30, 0x38, 0x64, 0x64, 0x66, 0x39, 0x31, 0x30, 0x36, 0x61, 0x31, 0x61, 0x62, 0x34, 0x65, 0x64, 0x66, 0x65, 0x33, 0x62, 0x34, 0x33, 0x62, 0x66, 0x32, 0x66, 0x37, 0x64, 0x38, 0x64, 0x31, 0x66, 0x34, 0x32, 0x65, 0x37, 0x33, 0x36, 0x37, 0x31, 0x64, 0x32, 0x66, 0x65, 0x32, 0x33, 0x32, 0x39, 0x33, 0x64, 0x34, 0x38, 0x63, 0x65, 0x32, 0x30, 0x63, 0x62, 0x36, 0x63, 0x36, 0x36, 0x33, 0x66, 0x61, 0x34, 0x37, 0x63, 0x32, 0x38, 0x31, 0x65, 0x62, 0x62, 0x37, 0x62, 0x63, 0x31, 0x39, 0x39, 0x39, 0x33, 0x39, 0x62, 0x33, 0x65, 0x61, 0x64, 0x66, 0x33, 0x38, 0x63, 0x64, 0x31, 0x62, 0x38, 0x38, 0x64, 0x34, 0x61, 0x62, 0x31, 0x61, 0x63, 0x65, 0x31, 0x33, 0x66, 0x33, 0x31, 0x34, 0x65, 0x37, 0x64, 0x65, 0x65, 0x34, 0x62, 0x65, 0x38, 0x36, 0x32, 0x65, 0x30, 0x37, 0x32, 0x32, 0x33, 0x38, 0x33, 0x30, 0x31, 0x62, 0x64, 0x33, 0x66, 0x66, 0x65, 0x63, 0x31, 0x63, 0x64, 0x64, 0x64, 0x65, 0x63, 0x36, 0x63, 0x61, 0x66, 0x31, 0x62, 0x31, 0x36, 0x35, 0x66, 0x32, 0x63, 0x36, 0x64, 0x35, 0x66, 0x65, 0x32, 0x35, 0x37, 0x64, 0x63, 0x32, 0x61, 0x66, 0x61, 0x32, 0x36, 0x32, 0x33, 0x37, 0x36, 0x63, 0x31, 0x63, 0x33, 0x39, 0x62, 0x38, 0x65, 0x35, 0x66, 0x32, 0x62, 0x62, 0x39, 0x37, 0x63, 0x36, 0x65, 0x30, 0x33, 0x30, 0x64, 0x66, 0x31, 0x63, 0x34, 0x35, 0x38, 0x64, 0x63, 0x37, 0x61, 0x64, 0x65, 0x64, 0x31, 0x32, 0x33, 0x63, 0x30, 0x31, 0x34, 0x33, 0x61, 0x64, 0x63, 0x62, 0x65, 0x36, 0x65, 0x36, 0x34, 0x62, 0x62, 0x61, 0x62, 0x32, 0x30, 0x36, 0x36, 0x39, 0x63, 0x37, 0x64, 0x38, 0x62, 0x39, 0x64, 0x62, 0x66, 0x39, 0x33, 0x30, 0x31, 0x36, 0x63, 0x61, 0x31, 0x36, 0x35, 0x36, 0x36, 0x65, 0x62, 0x34, 0x66, 0x65, 0x66, 0x39, 0x38, 0x31, 0x30, 0x31, 0x66, 0x64, 0x31, 0x36, 0x35, 0x37, 0x36, 0x32, 0x35, 0x35, 0x63, 0x34, 0x31, 0x32, 0x34, 0x34, 0x63, 0x66, 0x30, 0x38, 0x30, 0x36, 0x33, 0x33, 0x38, 0x31, 0x61, 0x66, 0x33, 0x32, 0x61, 0x37, 0x66, 0x66, 0x34, 0x63, 0x62, 0x36, 0x33, 0x63, 0x66, 0x34, 0x65, 0x32, 0x37, 0x37, 0x32, 0x65, 0x39, 0x64, 0x36, 0x33, 0x30, 0x61, 0x33, 0x65, 0x66, 0x39, 0x33, 0x63, 0x35, 0x37, 0x38, 0x38, 0x38, 0x36, 0x35, 0x34, 0x38, 0x65, 0x38, 0x30, 0x30, 0x35, 0x33, 0x39, 0x34, 0x36, 0x38, 0x32, 0x36, 0x31, 0x38, 0x36, 0x61, 0x32, 0x35, 0x32, 0x63, 0x61, 0x63, 0x63, 0x31, 0x31, 0x61, 0x63, 0x61, 0x66, 0x65, 0x32, 0x36, 0x38, 0x35, 0x66, 0x34, 0x63, 0x63, 0x62, 0x63, 0x37, 0x32, 0x61, 0x31, 0x33, 0x33, 0x33, 0x39, 0x31, 0x62, 0x61, 0x36, 0x34, 0x61, 0x61, 0x35, 0x32, 0x37, 0x32, 0x34, 0x36, 0x38, 0x36, 0x64, 0x32, 0x64, 0x32, 0x65, 0x33, 0x31, 0x39, 0x32, 0x36, 0x38, 0x63, 0x38, 0x66, 0x35, 0x64, 0x66, 0x31, 0x31, 0x63, 0x32, 0x35, 0x61, 0x36, 0x33, 0x34, 0x36, 0x61, 0x32, 0x65, 0x34, 0x30, 0x65, 0x61, 0x38, 0x39, 0x31, 0x63, 0x38, 0x31, 0x66, 0x33, 0x33, 0x37, 0x36, 0x63, 0x31, 0x31, 0x32, 0x66, 0x39, 0x33, 0x33, 0x62, 0x37, 0x39, 0x66, 0x35, 0x61, 0x38, 0x31, 0x66, 0x30, 0x31, 0x63, 0x39, 0x37, 0x37, 0x32, 0x39, 0x62, 0x62, 0x64, 0x30, 0x35, 0x61, 0x30, 0x64, 0x36, 0x63, 0x33, 0x31, 0x35, 0x65, 0x37, 0x33, 0x65, 0x38, 0x66, 0x31, 0x61, 0x33, 0x36, 0x65, 0x61, 0x64, 0x37, 0x37, 0x63, 0x63, 0x35, 0x33, 0x66, 0x33, 0x36, 0x33, 0x33, 0x63, 0x32, 0x38, 0x61, 0x39, 0x61, 0x66, 0x31, 0x35, 0x35, 0x63, 0x63, 0x34, 0x66, 0x35, 0x64, 0x34, 0x64, 0x31, 0x32, 0x61, 0x62, 0x63, 0x63, 0x31, 0x31, 0x32, 0x30, 0x66, 0x35, 0x35, 0x38, 0x39, 0x64, 0x39, 0x39, 0x66, 0x66, 0x62, 0x61, 0x33, 0x30, 0x63, 0x65, 0x63, 0x34, 0x31, 0x37, 0x34, 0x64, 0x35, 0x66, 0x65, 0x64, 0x38, 0x36, 0x38, 0x32, 0x39, 0x39, 0x62, 0x38, 0x37, 0x32, 0x38, 0x39, 0x39, 0x33, 0x32, 0x35, 0x66, 0x38, 0x34, 0x64, 0x66, 0x30, 0x64, 0x63, 0x61, 0x66, 0x64, 0x65, 0x36, 0x39, 0x34, 0x65, 0x33, 0x62, 0x31, 0x36, 0x62, 0x31, 0x30, 0x33, 0x66, 0x32, 0x35, 0x65, 0x31, 0x61, 0x33, 0x36, 0x61, 0x66, 0x65, 0x32, 0x66, 0x37, 0x39, 0x33, 0x63, 0x33, 0x65, 0x35, 0x30, 0x30, 0x30, 0x66, 0x33, 0x63, 0x36, 0x38, 0x39, 0x63, 0x36, 0x66, 0x37, 0x32, 0x64, 0x37, 0x38, 0x65, 0x66, 0x66, 0x35, 0x35, 0x32, 0x65, 0x35, 0x64, 0x63, 0x61, 0x33, 0x63, 0x62, 0x36, 0x62, 0x63, 0x32, 0x31, 0x38, 0x64, 0x33, 0x66, 0x32, 0x66, 0x65, 0x32, 0x66, 0x33, 0x63, 0x37, 0x65, 0x66, 0x31, 0x31, 0x37, 0x61, 0x62, 0x31, 0x30, 0x66, 0x36, 0x39, 0x61, 0x36, 0x35, 0x35, 0x64, 0x39, 0x35, 0x31, 0x66, 0x34, 0x64, 0x35, 0x63, 0x35, 0x62, 0x36, 0x35, 0x61, 0x30, 0x64, 0x32, 0x32, 0x35, 0x62, 0x61, 0x32, 0x37, 0x33, 0x32, 0x36, 0x63, 0x66, 0x30, 0x30, 0x32, 0x35, 0x32, 0x66, 0x66, 0x66, 0x66, 0x31, 0x39, 0x63, 0x30, 0x65, 0x31, 0x33, 0x66, 0x36, 0x30, 0x64, 0x62, 0x34, 0x34, 0x37, 0x66, 0x34, 0x33, 0x63, 0x35, 0x37, 0x65, 0x34, 0x30, 0x38, 0x62, 0x61, 0x33, 0x30, 0x66, 0x32, 0x65, 0x64, 0x38, 0x64, 0x63, 0x65, 0x35, 0x62, 0x37, 0x32, 0x30, 0x66, 0x39, 0x65, 0x33, 0x31, 0x38, 0x34, 0x61, 0x30, 0x35, 0x33, 0x62, 0x38, 0x34, 0x31, 0x66, 0x32, 0x33, 0x66, 0x65, 0x37, 0x34, 0x62, 0x30, 0x31, 0x35, 0x66, 0x30, 0x39, 0x30, 0x36, 0x63, 0x36, 0x34, 0x31, 0x66, 0x37, 0x32, 0x38, 0x34, 0x39, 0x36, 0x35, 0x66, 0x66, 0x66, 0x34, 0x36, 0x64, 0x63, 0x36, 0x64, 0x61, 0x32, 0x33, 0x63, 0x66, 0x33, 0x61, 0x65, 0x31, 0x33, 0x31, 0x66, 0x33, 0x39, 0x63, 0x34, 0x30, 0x36, 0x64, 0x66, 0x64, 0x65, 0x62, 0x36, 0x39, 0x30, 0x64, 0x32, 0x30, 0x37, 0x64, 0x66, 0x33, 0x61, 0x38, 0x32, 0x64, 0x36, 0x38, 0x66, 0x36, 0x37, 0x33, 0x65, 0x65, 0x66, 0x35, 0x61, 0x65, 0x64, 0x62, 0x32, 0x35, 0x35, 0x36, 0x33, 0x62, 0x63, 0x66, 0x62, 0x32, 0x31, 0x32, 0x62, 0x66, 0x31, 0x36, 0x64, 0x39, 0x65, 0x33, 0x30, 0x66, 0x30, 0x36, 0x63, 0x66, 0x37, 0x33, 0x63, 0x37, 0x62, 0x33, 0x39, 0x32, 0x30, 0x36, 0x38, 0x63, 0x39, 0x65, 0x33, 0x33, 0x35, 0x65, 0x63, 0x35, 0x31, 0x65, 0x36, 0x66, 0x63, 0x30, 0x65, 0x61, 0x34, 0x63, 0x34, 0x61, 0x31, 0x63, 0x61, 0x66, 0x61, 0x61, 0x63, 0x62, 0x38, 0x61, 0x38, 0x66, 0x64, 0x32, 0x32, 0x62, 0x30, 0x63, 0x32, 0x64, 0x64, 0x33, 0x64, 0x30, 0x32, 0x65, 0x33, 0x30, 0x37, 0x32, 0x32, 0x64, 0x34, 0x37, 0x63, 0x38, 0x30, 0x65, 0x30, 0x30, 0x66, 0x32, 0x62, 0x34, 0x32, 0x37, 0x31, 0x61, 0x30, 0x32, 0x64, 0x37, 0x63, 0x63, 0x64, 0x35, 0x31, 0x64, 0x37, 0x30, 0x38, 0x32, 0x34, 0x39, 0x33, 0x61, 0x37, 0x64, 0x66, 0x61, 0x65, 0x32, 0x31, 0x62, 0x36, 0x37, 0x63, 0x63, 0x31, 0x39, 0x37, 0x31, 0x64, 0x66, 0x39, 0x30, 0x33, 0x39, 0x36, 0x39, 0x65, 0x36, 0x37, 0x32, 0x63, 0x63, 0x34, 0x32, 0x37, 0x66, 0x35, 0x61, 0x66, 0x64, 0x38, 0x64, 0x63, 0x66, 0x34, 0x62, 0x32, 0x33, 0x32, 0x65, 0x32, 0x32, 0x33, 0x62, 0x33, 0x32, 0x35, 0x30, 0x37, 0x34, 0x64, 0x36, 0x63, 0x37, 0x36, 0x63, 0x32, 0x63, 0x34, 0x32, 0x36, 0x32, 0x66, 0x39, 0x38, 0x33, 0x33, 0x38, 0x33, 0x31, 0x65, 0x65, 0x39, 0x30, 0x62, 0x33, 0x34, 0x37, 0x36, 0x35, 0x63, 0x37, 0x35, 0x35, 0x31, 0x38, 0x32, 0x61, 0x33, 0x64, 0x35, 0x63, 0x61, 0x62, 0x39, 0x61, 0x61, 0x64, 0x34, 0x61, 0x35, 0x61, 0x39, 0x64, 0x35, 0x62, 0x32, 0x38, 0x65, 0x39, 0x32, 0x62, 0x64, 0x32, 0x65, 0x35, 0x31, 0x35, 0x34, 0x64, 0x35, 0x35, 0x30, 0x36, 0x61, 0x37, 0x34, 0x64, 0x31, 0x37, 0x61, 0x32, 0x65, 0x63, 0x33, 0x31, 0x64, 0x64, 0x35, 0x62, 0x33, 0x35, 0x33, 0x38, 0x61, 0x32, 0x32, 0x66, 0x36, 0x66, 0x36, 0x36, 0x65, 0x66, 0x63, 0x31, 0x35, 0x37, 0x33, 0x37, 0x35, 0x30, 0x38, 0x64, 0x30, 0x39, 0x37, 0x62, 0x62, 0x38, 0x33, 0x36, 0x61, 0x62, 0x63, 0x31, 0x63, 0x35, 0x39, 0x38, 0x62, 0x61, 0x33, 0x62, 0x35, 0x61, 0x32, 0x36, 0x66, 0x33, 0x34, 0x30, 0x36, 0x64, 0x61, 0x62, 0x34, 0x32, 0x62, 0x61, 0x39, 0x33, 0x38, 0x30, 0x66, 0x65, 0x62, 0x35, 0x30, 0x66, 0x33, 0x61, 0x31, 0x37, 0x64, 0x38, 0x63, 0x61, 0x32, 0x38, 0x66, 0x61, 0x34, 0x63, 0x65, 0x33, 0x31, 0x37, 0x36, 0x34, 0x32, 0x65, 0x36, 0x31, 0x37, 0x36, 0x63, 0x34, 0x36, 0x36, 0x38, 0x34, 0x32, 0x63, 0x31, 0x33, 0x34, 0x30, 0x33, 0x36, 0x64, 0x31, 0x35, 0x65, 0x30, 0x36, 0x32, 0x61, 0x37, 0x65, 0x31, 0x34, 0x64, 0x36, 0x66, 0x34, 0x32, 0x39, 0x33, 0x66, 0x31, 0x62, 0x32, 0x34, 0x37, 0x32, 0x64, 0x61, 0x64, 0x34, 0x38, 0x63, 0x37, 0x63, 0x30, 0x39, 0x64, 0x35, 0x63, 0x61, 0x33, 0x32, 0x32, 0x30, 0x61, 0x33, 0x30, 0x35, 0x61, 0x66, 0x31, 0x39, 0x33, 0x31, 0x64, 0x32, 0x31, 0x36, 0x66, 0x64, 0x66, 0x36, 0x39, 0x34, 0x39, 0x35, 0x63, 0x32, 0x38, 0x62, 0x33, 0x34, 0x32, 0x30, 0x38, 0x65, 0x38, 0x34, 0x39, 0x37, 0x35, 0x33, 0x66, 0x34, 0x31, 0x61, 0x34, 0x61, 0x37, 0x32, 0x66, 0x66, 0x34, 0x38, 0x33, 0x30, 0x31, 0x35, 0x36, 0x33, 0x36, 0x37, 0x37, 0x38, 0x66, 0x31, 0x35, 0x39, 0x30, 0x34, 0x32, 0x32, 0x62, 0x37, 0x38, 0x33, 0x34, 0x39, 0x37, 0x35, 0x33, 0x39, 0x66, 0x36, 0x31, 0x39, 0x65, 0x33, 0x37, 0x62, 0x62, 0x33, 0x35, 0x62, 0x38, 0x61, 0x66, 0x39, 0x35, 0x61, 0x36, 0x64, 0x31, 0x31, 0x35, 0x31, 0x62, 0x31, 0x35, 0x35, 0x37, 0x64, 0x37, 0x32, 0x30, 0x64, 0x30, 0x31, 0x65, 0x65, 0x36, 0x39, 0x30, 0x33, 0x34, 0x37, 0x64, 0x39, 0x30, 0x32, 0x62, 0x31, 0x35, 0x63, 0x32, 0x34, 0x33, 0x33, 0x37, 0x63, 0x64, 0x30, 0x37, 0x33, 0x36, 0x32, 0x66, 0x63, 0x39, 0x31, 0x37, 0x35, 0x66, 0x63, 0x30, 0x65, 0x38, 0x61, 0x66, 0x37, 0x64, 0x38, 0x64, 0x33, 0x35, 0x39, 0x35, 0x30, 0x37, 0x66, 0x32, 0x33, 0x39, 0x36, 0x35, 0x36, 0x30, 0x36, 0x33, 0x35, 0x33, 0x37, 0x62, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x38, 0x33, 0x32, 0x64, 0x61, 0x61, 0x63, 0x66, 0x39, 0x66, 0x35, 0x32, 0x32, 0x32, 0x33, 0x34, 0x31, 0x31, 0x62, 0x37, 0x63, 0x35, 0x63, 0x64, 0x38, 0x35, 0x65, 0x30, 0x34, 0x30, 0x65, 0x31, 0x39, 0x38, 0x33, 0x63, 0x31, 0x63, 0x32, 0x30, 0x35, 0x30, 0x36, 0x62, 0x34, 0x38, 0x61, 0x65, 0x38, 0x32, 0x37, 0x32, 0x34, 0x63, 0x36, 0x63, 0x66, 0x33, 0x32, 0x39, 0x64, 0x62, 0x39, 0x38, 0x33, 0x63, 0x32, 0x31, 0x35, 0x63, 0x30, 0x35, 0x35, 0x61, 0x30, 0x64, 0x37, 0x39, 0x36, 0x38, 0x35, 0x64, 0x37, 0x38, 0x32, 0x35, 0x65, 0x31, 0x63, 0x65, 0x65, 0x37, 0x61, 0x31, 0x34, 0x30, 0x30, 0x32, 0x62, 0x35, 0x37, 0x62, 0x65, 0x38, 0x31, 0x39, 0x62, 0x65, 0x32, 0x30, 0x38, 0x33, 0x31, 0x36, 0x37, 0x32, 0x32, 0x31, 0x35, 0x39, 0x39, 0x37, 0x33, 0x31, 0x63, 0x65, 0x31, 0x34, 0x38, 0x34, 0x33, 0x37, 0x38, 0x61, 0x30, 0x38, 0x30, 0x30, 0x35, 0x34, 0x62, 0x39, 0x37, 0x34, 0x34, 0x61, 0x38, 0x65, 0x63, 0x66, 0x39, 0x65, 0x31, 0x36, 0x61, 0x35, 0x36, 0x63, 0x38, 0x30, 0x33, 0x62, 0x37, 0x36, 0x64, 0x30, 0x66, 0x31, 0x64, 0x39, 0x64, 0x63, 0x36, 0x65, 0x30, 0x33, 0x39, 0x61, 0x36, 0x30, 0x63, 0x30, 0x37, 0x64, 0x62, 0x65, 0x33, 0x31, 0x61, 0x34, 0x37, 0x36, 0x31, 0x65, 0x33, 0x33, 0x65, 0x38, 0x61, 0x34, 0x31, 0x62, 0x34, 0x65, 0x65, 0x30, 0x36, 0x37, 0x37, 0x35, 0x33, 0x36, 0x63, 0x63, 0x35, 0x66, 0x63, 0x38, 0x63, 0x36, 0x66, 0x66, 0x61, 0x62, 0x62, 0x63, 0x66, 0x35, 0x38, 0x65, 0x37, 0x30, 0x37, 0x36, 0x61, 0x64, 0x38, 0x32, 0x66, 0x32, 0x63, 0x33, 0x34, 0x31, 0x32, 0x33, 0x62, 0x34, 0x32, 0x38, 0x62, 0x64, 0x62, 0x32, 0x66, 0x34, 0x31, 0x36, 0x65, 0x32, 0x37, 0x38, 0x64, 0x39, 0x35, 0x34, 0x37, 0x34, 0x64, 0x61, 0x63, 0x35, 0x30, 0x34, 0x39, 0x62, 0x63, 0x33, 0x35, 0x38, 0x36, 0x31, 0x34, 0x66, 0x30, 0x35, 0x33, 0x36, 0x35, 0x64, 0x36, 0x30, 0x35, 0x31, 0x36, 0x32, 0x66, 0x33, 0x37, 0x31, 0x61, 0x36, 0x63, 0x62, 0x39, 0x39, 0x37, 0x32, 0x65, 0x66, 0x66, 0x65, 0x31, 0x31, 0x30, 0x34, 0x62, 0x32, 0x65, 0x38, 0x37, 0x33, 0x35, 0x32, 0x61, 0x66, 0x38, 0x61, 0x34, 0x31, 0x38, 0x30, 0x35, 0x65, 0x30, 0x61, 0x32, 0x32, 0x37, 0x63, 0x35, 0x35, 0x36, 0x63, 0x64, 0x63, 0x32, 0x38, 0x33, 0x38, 0x64, 0x33, 0x31, 0x38, 0x37, 0x35, 0x37, 0x34, 0x64, 0x37, 0x38, 0x62, 0x63, 0x66, 0x36, 0x65, 0x30, 0x33, 0x66, 0x63, 0x37, 0x32, 0x39, 0x62, 0x66, 0x63, 0x30, 0x61, 0x38, 0x30, 0x30, 0x64, 0x65, 0x37, 0x62, 0x39, 0x31, 0x35, 0x64, 0x61, 0x65, 0x37, 0x61, 0x39, 0x66, 0x33, 0x64, 0x33, 0x35, 0x39, 0x35, 0x33, 0x36, 0x65, 0x36, 0x33, 0x31, 0x37, 0x32, 0x39, 0x66, 0x32, 0x65, 0x39, 0x34, 0x35, 0x34, 0x61, 0x33, 0x35, 0x37, 0x37, 0x38, 0x61, 0x31, 0x34, 0x31, 0x64, 0x38, 0x36, 0x36, 0x36, 0x31, 0x34, 0x34, 0x33, 0x66, 0x35, 0x62, 0x33, 0x62, 0x66, 0x34, 0x66, 0x34, 0x30, 0x32, 0x62, 0x36, 0x62, 0x64, 0x30, 0x38, 0x32, 0x66, 0x63, 0x38, 0x33, 0x66, 0x38, 0x39, 0x37, 0x39, 0x33, 0x38, 0x61, 0x32, 0x36, 0x39, 0x37, 0x39, 0x35, 0x63, 0x38, 0x30, 0x64, 0x34, 0x62, 0x66, 0x65, 0x33, 0x34, 0x32, 0x62, 0x34, 0x36, 0x62, 0x65, 0x64, 0x61, 0x66, 0x65, 0x33, 0x36, 0x31, 0x62, 0x65, 0x61, 0x37, 0x32, 0x35, 0x65, 0x39, 0x39, 0x63, 0x38, 0x66, 0x32, 0x66, 0x61, 0x31, 0x64, 0x30, 0x30, 0x63, 0x38, 0x61, 0x34, 0x65, 0x30, 0x34, 0x61, 0x33, 0x38, 0x65, 0x64, 0x61, 0x64, 0x39, 0x65, 0x61, 0x62, 0x36, 0x32, 0x36, 0x37, 0x64, 0x65, 0x34, 0x35, 0x39, 0x66, 0x64, 0x38, 0x36, 0x33, 0x35, 0x63, 0x65, 0x32, 0x30, 0x35, 0x62, 0x63, 0x39, 0x32, 0x62, 0x32, 0x65, 0x34, 0x38, 0x38, 0x30, 0x33, 0x37, 0x64, 0x32, 0x33, 0x35, 0x35, 0x39, 0x63, 0x30, 0x30, 0x37, 0x63, 0x63, 0x37, 0x35, 0x62, 0x65, 0x34, 0x35, 0x65, 0x38, 0x63, 0x64, 0x61, 0x62, 0x32, 0x63, 0x38, 0x61, 0x37, 0x64, 0x32, 0x36, 0x31, 0x61, 0x33, 0x65, 0x64, 0x33, 0x32, 0x64, 0x62, 0x62, 0x34, 0x37, 0x62, 0x64, 0x30, 0x35, 0x32, 0x34, 0x36, 0x36, 0x34, 0x35, 0x32, 0x64, 0x36, 0x30, 0x64, 0x31, 0x63, 0x37, 0x32, 0x62, 0x38, 0x36, 0x33, 0x37, 0x39, 0x61, 0x33, 0x66, 0x65, 0x36, 0x32, 0x30, 0x35, 0x31, 0x33, 0x38, 0x38, 0x35, 0x36, 0x37, 0x62, 0x33, 0x33, 0x39, 0x63, 0x66, 0x66, 0x34, 0x35, 0x35, 0x61, 0x32, 0x37, 0x36, 0x65, 0x37, 0x64, 0x36, 0x65, 0x65, 0x35, 0x30, 0x37, 0x35, 0x61, 0x66, 0x36, 0x34, 0x62, 0x66, 0x35, 0x32, 0x37, 0x34, 0x36, 0x39, 0x61, 0x36, 0x31, 0x36, 0x30, 0x34, 0x39, 0x37, 0x38, 0x36, 0x30, 0x37, 0x30, 0x65, 0x65, 0x66, 0x33, 0x36, 0x36, 0x66, 0x37, 0x33, 0x39, 0x65, 0x34, 0x37, 0x38, 0x37, 0x61, 0x63, 0x35, 0x32, 0x34, 0x32, 0x39, 0x64, 0x65, 0x61, 0x35, 0x33, 0x61, 0x32, 0x31, 0x35, 0x33, 0x36, 0x32, 0x62, 0x30, 0x66, 0x66, 0x61, 0x37, 0x32, 0x63, 0x39, 0x34, 0x30, 0x39, 0x33, 0x64, 0x66, 0x37, 0x66, 0x37, 0x35, 0x31, 0x61, 0x34, 0x30, 0x30, 0x30, 0x64, 0x33, 0x64, 0x66, 0x38, 0x31, 0x65, 0x61, 0x34, 0x31, 0x31, 0x34, 0x61, 0x65, 0x36, 0x34, 0x66, 0x39, 0x33, 0x30, 0x31, 0x31, 0x61, 0x31, 0x32, 0x66, 0x35, 0x32, 0x66, 0x38, 0x61, 0x38, 0x37, 0x36, 0x62, 0x64, 0x34, 0x33, 0x63, 0x65, 0x64, 0x64, 0x62, 0x63, 0x36, 0x33, 0x30, 0x34, 0x63, 0x64, 0x35, 0x64, 0x35, 0x64, 0x39, 0x61, 0x39, 0x33, 0x36, 0x30, 0x64, 0x34, 0x38, 0x64, 0x31, 0x37, 0x66, 0x62, 0x65, 0x38, 0x66, 0x63, 0x38, 0x31, 0x34, 0x62, 0x39, 0x37, 0x65, 0x61, 0x31, 0x64, 0x64, 0x62, 0x62, 0x62, 0x34, 0x30, 0x34, 0x30, 0x62, 0x62, 0x61, 0x66, 0x64, 0x34, 0x38, 0x36, 0x38, 0x35, 0x32, 0x37, 0x36, 0x30, 0x62, 0x64, 0x31, 0x35, 0x63, 0x32, 0x38, 0x35, 0x32, 0x30, 0x36, 0x32, 0x37, 0x36, 0x63, 0x36, 0x66, 0x30, 0x37, 0x36, 0x34, 0x37, 0x32, 0x39, 0x63, 0x65, 0x38, 0x38, 0x36, 0x39, 0x64, 0x32, 0x34, 0x30, 0x33, 0x63, 0x31, 0x38, 0x38, 0x62, 0x34, 0x64, 0x34, 0x32, 0x31, 0x37, 0x34, 0x61, 0x34, 0x65, 0x31, 0x30, 0x36, 0x31, 0x62, 0x62, 0x64, 0x31, 0x30, 0x62, 0x64, 0x61, 0x61, 0x30, 0x37, 0x30, 0x38, 0x32, 0x65, 0x65, 0x36, 0x34, 0x66, 0x66, 0x66, 0x30, 0x63, 0x35, 0x66, 0x64, 0x63, 0x65, 0x64, 0x64, 0x66, 0x37, 0x32, 0x30, 0x31, 0x37, 0x63, 0x34, 0x31, 0x62, 0x64, 0x66, 0x63, 0x64, 0x34, 0x66, 0x36, 0x32, 0x34, 0x39, 0x66, 0x65, 0x63, 0x39, 0x33, 0x62, 0x36, 0x35, 0x63, 0x61, 0x37, 0x63, 0x31, 0x36, 0x64, 0x66, 0x35, 0x61, 0x65, 0x37, 0x34, 0x62, 0x37, 0x38, 0x35, 0x37, 0x30, 0x32, 0x62, 0x31, 0x66, 0x63, 0x65, 0x64, 0x30, 0x38, 0x62, 0x36, 0x32, 0x37, 0x35, 0x63, 0x32, 0x64, 0x33, 0x37, 0x32, 0x30, 0x66, 0x31, 0x38, 0x36, 0x39, 0x62, 0x64, 0x33, 0x31, 0x37, 0x36, 0x30, 0x63, 0x65, 0x31, 0x30, 0x37, 0x30, 0x62, 0x63, 0x61, 0x64, 0x62, 0x61, 0x30, 0x64, 0x36, 0x33, 0x65, 0x37, 0x38, 0x34, 0x64, 0x38, 0x33, 0x39, 0x32, 0x62, 0x35, 0x30, 0x64, 0x35, 0x38, 0x66, 0x65, 0x31, 0x36, 0x32, 0x33, 0x66, 0x62, 0x31, 0x66, 0x31, 0x31, 0x36, 0x38, 0x61, 0x35, 0x31, 0x31, 0x30, 0x39, 0x66, 0x64, 0x64, 0x61, 0x34, 0x66, 0x36, 0x34, 0x66, 0x65, 0x38, 0x37, 0x35, 0x66, 0x31, 0x61, 0x65, 0x37, 0x35, 0x65, 0x33, 0x63, 0x63, 0x38, 0x34, 0x37, 0x66, 0x33, 0x38, 0x63, 0x35, 0x36, 0x35, 0x30, 0x64, 0x37, 0x35, 0x31, 0x62, 0x65, 0x31, 0x37, 0x63, 0x34, 0x64, 0x37, 0x64, 0x64, 0x66, 0x38, 0x31, 0x64, 0x66, 0x61, 0x36, 0x34, 0x39, 0x30, 0x39, 0x63, 0x39, 0x65, 0x30, 0x38, 0x61, 0x63, 0x65, 0x34, 0x33, 0x38, 0x61, 0x63, 0x61, 0x65, 0x33, 0x30, 0x37, 0x37, 0x61, 0x61, 0x34, 0x32, 0x64, 0x31, 0x37, 0x62, 0x62, 0x37, 0x31, 0x66, 0x31, 0x35, 0x38, 0x35, 0x37, 0x39, 0x65, 0x66, 0x64, 0x30, 0x63, 0x66, 0x39, 0x35, 0x66, 0x39, 0x66, 0x37, 0x64, 0x62, 0x37, 0x39, 0x65, 0x33, 0x63, 0x37, 0x33, 0x64, 0x63, 0x64, 0x38, 0x35, 0x65, 0x32, 0x37, 0x30, 0x32, 0x33, 0x63, 0x39, 0x66, 0x31, 0x31, 0x61, 0x34, 0x34, 0x65, 0x35, 0x64, 0x39, 0x64, 0x31, 0x37, 0x66, 0x32, 0x33, 0x62, 0x37, 0x64, 0x62, 0x32, 0x34, 0x65, 0x35, 0x31, 0x63, 0x65, 0x61, 0x39, 0x64, 0x65, 0x35, 0x32, 0x61, 0x35, 0x37, 0x31, 0x64, 0x63, 0x30, 0x39, 0x37, 0x64, 0x31, 0x64, 0x36, 0x31, 0x31, 0x62, 0x63, 0x65, 0x34, 0x31, 0x61, 0x39, 0x34, 0x65, 0x36, 0x36, 0x36, 0x37, 0x32, 0x30, 0x35, 0x34, 0x62, 0x30, 0x30, 0x62, 0x37, 0x36, 0x62, 0x64, 0x64, 0x39, 0x66, 0x37, 0x39, 0x34, 0x37, 0x34, 0x39, 0x64, 0x65, 0x35, 0x64, 0x36, 0x32, 0x33, 0x34, 0x62, 0x64, 0x39, 0x39, 0x35, 0x38, 0x30, 0x30, 0x32, 0x32, 0x32, 0x61, 0x65, 0x62, 0x66, 0x38, 0x32, 0x37, 0x32, 0x62, 0x36, 0x30, 0x38, 0x34, 0x37, 0x62, 0x64, 0x34, 0x31, 0x39, 0x30, 0x62, 0x63, 0x38, 0x35, 0x32, 0x63, 0x31, 0x32, 0x61, 0x33, 0x65, 0x65, 0x63, 0x37, 0x39, 0x63, 0x63, 0x65, 0x39, 0x63, 0x31, 0x65, 0x35, 0x64, 0x63, 0x63, 0x36, 0x31, 0x61, 0x63, 0x32, 0x62, 0x33, 0x62, 0x36, 0x31, 0x30, 0x32, 0x61, 0x61, 0x61, 0x32, 0x36, 0x31, 0x62, 0x64, 0x35, 0x63, 0x38, 0x34, 0x31, 0x35, 0x32, 0x62, 0x62, 0x62, 0x31, 0x33, 0x32, 0x65, 0x61, 0x32, 0x65, 0x36, 0x34, 0x66, 0x63, 0x35, 0x36, 0x34, 0x36, 0x32, 0x32, 0x66, 0x37, 0x37, 0x39, 0x32, 0x31, 0x38, 0x33, 0x62, 0x34, 0x66, 0x65, 0x31, 0x31, 0x34, 0x35, 0x38, 0x34, 0x38, 0x38, 0x31, 0x35, 0x31, 0x64, 0x65, 0x66, 0x35, 0x62, 0x30, 0x38, 0x37, 0x64, 0x38, 0x32, 0x34, 0x66, 0x33, 0x36, 0x38, 0x61, 0x31, 0x38, 0x38, 0x30, 0x32, 0x65, 0x65, 0x36, 0x32, 0x32, 0x33, 0x61, 0x32, 0x62, 0x64, 0x61, 0x37, 0x36, 0x35, 0x39, 0x36, 0x37, 0x35, 0x39, 0x34, 0x32, 0x33, 0x65, 0x32, 0x30, 0x37, 0x39, 0x37, 0x65, 0x30, 0x63, 0x35, 0x64, 0x32, 0x34, 0x34, 0x32, 0x63, 0x64, 0x63, 0x65, 0x31, 0x37, 0x35, 0x37, 0x32, 0x35, 0x63, 0x66, 0x64, 0x33, 0x33, 0x36, 0x33, 0x38, 0x33, 0x36, 0x66, 0x38, 0x65, 0x32, 0x32, 0x37, 0x31, 0x64, 0x36, 0x62, 0x33, 0x64, 0x30, 0x63, 0x34, 0x36, 0x32, 0x32, 0x63, 0x34, 0x37, 0x32, 0x36, 0x63, 0x34, 0x32, 0x64, 0x63, 0x33, 0x39, 0x66, 0x31, 0x35, 0x36, 0x35, 0x35, 0x37, 0x37, 0x62, 0x66, 0x39, 0x39, 0x62, 0x38, 0x65, 0x64, 0x39, 0x66, 0x38, 0x61, 0x32, 0x36, 0x39, 0x64, 0x36, 0x63, 0x32, 0x33, 0x65, 0x31, 0x62, 0x31, 0x37, 0x34, 0x62, 0x62, 0x35, 0x37, 0x36, 0x38, 0x37, 0x39, 0x35, 0x30, 0x34, 0x39, 0x64, 0x31, 0x31, 0x65, 0x39, 0x30, 0x31, 0x64, 0x37, 0x32, 0x66, 0x34, 0x36, 0x61, 0x39, 0x30, 0x66, 0x31, 0x66, 0x61, 0x61, 0x34, 0x66, 0x64, 0x64, 0x31, 0x61, 0x63, 0x39, 0x32, 0x32, 0x39, 0x61, 0x36, 0x66, 0x63, 0x36, 0x32, 0x61, 0x38, 0x34, 0x36, 0x63, 0x62, 0x34, 0x30, 0x37, 0x61, 0x31, 0x37, 0x33, 0x63, 0x36, 0x34, 0x33, 0x30, 0x33, 0x37, 0x66, 0x37, 0x35, 0x37, 0x37, 0x36, 0x66, 0x38, 0x63, 0x63, 0x35, 0x34, 0x65, 0x32, 0x34, 0x65, 0x30, 0x37, 0x39, 0x37, 0x32, 0x38, 0x33, 0x30, 0x39, 0x63, 0x62, 0x63, 0x65, 0x63, 0x36, 0x61, 0x32, 0x63, 0x32, 0x63, 0x39, 0x34, 0x62, 0x63, 0x32, 0x64, 0x62, 0x36, 0x66, 0x31, 0x62, 0x35, 0x38, 0x61, 0x38, 0x33, 0x65, 0x38, 0x65, 0x32, 0x65, 0x61, 0x66, 0x39, 0x38, 0x36, 0x61, 0x33, 0x62, 0x32, 0x31, 0x63, 0x36, 0x63, 0x61, 0x31, 0x34, 0x33, 0x34, 0x38, 0x64, 0x66, 0x33, 0x31, 0x64, 0x31, 0x66, 0x34, 0x37, 0x39, 0x31, 0x31, 0x30, 0x39, 0x30, 0x66, 0x39, 0x61, 0x35, 0x63, 0x61, 0x64, 0x36, 0x38, 0x37, 0x66, 0x31, 0x61, 0x66, 0x64, 0x30, 0x33, 0x30, 0x30, 0x61, 0x64, 0x39, 0x32, 0x37, 0x62, 0x38, 0x39, 0x37, 0x39, 0x39, 0x64, 0x30, 0x65, 0x32, 0x62, 0x35, 0x66, 0x36, 0x32, 0x31, 0x65, 0x63, 0x64, 0x37, 0x34, 0x62, 0x66, 0x35, 0x64, 0x39, 0x36, 0x34, 0x35, 0x37, 0x37, 0x31, 0x64, 0x61, 0x38, 0x65, 0x62, 0x34, 0x32, 0x61, 0x36, 0x34, 0x36, 0x32, 0x39, 0x31, 0x34, 0x62, 0x32, 0x65, 0x32, 0x37, 0x39, 0x32, 0x65, 0x63, 0x63, 0x30, 0x33, 0x35, 0x38, 0x66, 0x37, 0x62, 0x64, 0x31, 0x64, 0x63, 0x34, 0x63, 0x39, 0x63, 0x31, 0x32, 0x66, 0x62, 0x31, 0x65, 0x63, 0x38, 0x37, 0x64, 0x35, 0x62, 0x38, 0x33, 0x34, 0x65, 0x33, 0x30, 0x34, 0x37, 0x32, 0x65, 0x37, 0x33, 0x36, 0x34, 0x37, 0x30, 0x62, 0x33, 0x63, 0x32, 0x37, 0x35, 0x33, 0x66, 0x39, 0x66, 0x37, 0x33, 0x62, 0x64, 0x32, 0x62, 0x34, 0x62, 0x62, 0x64, 0x32, 0x34, 0x30, 0x36, 0x66, 0x61, 0x66, 0x31, 0x39, 0x61, 0x65, 0x63, 0x62, 0x30, 0x34, 0x37, 0x34, 0x38, 0x36, 0x39, 0x65, 0x63, 0x30, 0x39, 0x36, 0x36, 0x61, 0x34, 0x61, 0x66, 0x66, 0x63, 0x31, 0x33, 0x35, 0x37, 0x32, 0x65, 0x39, 0x39, 0x64, 0x63, 0x30, 0x31, 0x39, 0x61, 0x31, 0x37, 0x66, 0x38, 0x39, 0x63, 0x62, 0x35, 0x38, 0x35, 0x33, 0x66, 0x39, 0x32, 0x66, 0x61, 0x65, 0x30, 0x61, 0x63, 0x30, 0x34, 0x31, 0x38, 0x32, 0x39, 0x64, 0x62, 0x31, 0x62, 0x66, 0x66, 0x31, 0x39, 0x30, 0x31, 0x61, 0x65, 0x31, 0x39, 0x34, 0x39, 0x35, 0x33, 0x32, 0x64, 0x37, 0x32, 0x34, 0x37, 0x63, 0x33, 0x61, 0x35, 0x61, 0x32, 0x39, 0x63, 0x36, 0x61, 0x63, 0x38, 0x33, 0x30, 0x37, 0x38, 0x30, 0x35, 0x66, 0x35, 0x35, 0x66, 0x36, 0x36, 0x66, 0x65, 0x62, 0x66, 0x32, 0x38, 0x32, 0x31, 0x30, 0x66, 0x32, 0x66, 0x36, 0x31, 0x39, 0x36, 0x30, 0x36, 0x33, 0x66, 0x38, 0x65, 0x37, 0x64, 0x33, 0x32, 0x66, 0x63, 0x62, 0x65, 0x34, 0x61, 0x32, 0x33, 0x61, 0x61, 0x62, 0x36, 0x36, 0x30, 0x34, 0x33, 0x66, 0x35, 0x31, 0x33, 0x37, 0x64, 0x39, 0x31, 0x38, 0x34, 0x34, 0x63, 0x37, 0x35, 0x34, 0x38, 0x61, 0x36, 0x39, 0x63, 0x35, 0x32, 0x33, 0x64, 0x62, 0x32, 0x39, 0x63, 0x37, 0x36, 0x66, 0x34, 0x30, 0x61, 0x36, 0x65, 0x35, 0x65, 0x61, 0x37, 0x31, 0x61, 0x37, 0x61, 0x32, 0x36, 0x61, 0x37, 0x31, 0x38, 0x35, 0x63, 0x62, 0x64, 0x36, 0x30, 0x36, 0x37, 0x30, 0x30, 0x30, 0x31, 0x63, 0x34, 0x36, 0x30, 0x61, 0x65, 0x61, 0x64, 0x32, 0x37, 0x65, 0x34, 0x61, 0x31, 0x31, 0x66, 0x30, 0x64, 0x65, 0x37, 0x34, 0x62, 0x36, 0x36, 0x35, 0x32, 0x65, 0x63, 0x30, 0x63, 0x63, 0x62, 0x30, 0x37, 0x39, 0x63, 0x34, 0x35, 0x39, 0x63, 0x35, 0x33, 0x61, 0x64, 0x37, 0x31, 0x64, 0x36, 0x66, 0x37, 0x61, 0x34, 0x66, 0x65, 0x37, 0x38, 0x36, 0x66, 0x37, 0x64, 0x39, 0x39, 0x39, 0x31, 0x31, 0x62, 0x35, 0x37, 0x32, 0x64, 0x64, 0x37, 0x62, 0x63, 0x37, 0x34, 0x32, 0x39, 0x34, 0x36, 0x32, 0x63, 0x61, 0x30, 0x31, 0x63, 0x66, 0x61, 0x35, 0x62, 0x33, 0x33, 0x31, 0x66, 0x61, 0x34, 0x61, 0x66, 0x37, 0x65, 0x36, 0x61, 0x64, 0x37, 0x38, 0x37, 0x34, 0x36, 0x33, 0x64, 0x35, 0x66, 0x64, 0x66, 0x35, 0x34, 0x30, 0x36, 0x35, 0x35, 0x35, 0x64, 0x30, 0x66, 0x34, 0x33, 0x32, 0x31, 0x66, 0x37, 0x30, 0x32, 0x30, 0x64, 0x39, 0x38, 0x34, 0x37, 0x65, 0x31, 0x64, 0x39, 0x61, 0x34, 0x66, 0x61, 0x61, 0x31, 0x32, 0x65, 0x62, 0x33, 0x32, 0x63, 0x30, 0x38, 0x32, 0x39, 0x37, 0x36, 0x36, 0x38, 0x30, 0x35, 0x36, 0x63, 0x64, 0x32, 0x30, 0x61, 0x66, 0x34, 0x32, 0x34, 0x63, 0x36, 0x64, 0x61, 0x65, 0x30, 0x62, 0x30, 0x37, 0x62, 0x30, 0x65, 0x34, 0x62, 0x63, 0x32, 0x34, 0x65, 0x31, 0x33, 0x33, 0x34, 0x63, 0x62, 0x66, 0x66, 0x64, 0x33, 0x66, 0x31, 0x31, 0x64, 0x39, 0x34, 0x38, 0x65, 0x66, 0x32, 0x37, 0x63, 0x61, 0x33, 0x33, 0x63, 0x61, 0x64, 0x62, 0x33, 0x32, 0x38, 0x30, 0x63, 0x38, 0x33, 0x36, 0x34, 0x33, 0x39, 0x32, 0x33, 0x39, 0x34, 0x36, 0x35, 0x32, 0x61, 0x33, 0x37, 0x38, 0x33, 0x37, 0x31, 0x63, 0x33, 0x64, 0x31, 0x32, 0x39, 0x35, 0x35, 0x39, 0x66, 0x37, 0x62, 0x30, 0x34, 0x31, 0x61, 0x66, 0x37, 0x30, 0x62, 0x37, 0x63, 0x63, 0x33, 0x30, 0x61, 0x61, 0x32, 0x31, 0x61, 0x65, 0x63, 0x30, 0x64, 0x36, 0x63, 0x65, 0x38, 0x62, 0x63, 0x63, 0x39, 0x35, 0x35, 0x66, 0x38, 0x38, 0x38, 0x37, 0x61, 0x39, 0x35, 0x32, 0x66, 0x36, 0x39, 0x38, 0x30, 0x36, 0x32, 0x32, 0x64, 0x34, 0x35, 0x39, 0x35, 0x66, 0x30, 0x63, 0x35, 0x61, 0x35, 0x35, 0x65, 0x31, 0x35, 0x39, 0x37, 0x32, 0x33, 0x62, 0x34, 0x64, 0x36, 0x35, 0x35, 0x39, 0x62, 0x66, 0x36, 0x66, 0x39, 0x38, 0x31, 0x34, 0x31, 0x37, 0x34, 0x31, 0x61, 0x38, 0x64, 0x37, 0x30, 0x37, 0x31, 0x38, 0x35, 0x65, 0x61, 0x34, 0x31, 0x36, 0x66, 0x62, 0x36, 0x62, 0x63, 0x63, 0x30, 0x34, 0x61, 0x30, 0x35, 0x64, 0x30, 0x61, 0x31, 0x38, 0x34, 0x37, 0x63, 0x66, 0x37, 0x38, 0x64, 0x30, 0x35, 0x36, 0x31, 0x38, 0x33, 0x62, 0x34, 0x32, 0x38, 0x34, 0x34, 0x33, 0x64, 0x66, 0x36, 0x61, 0x31, 0x62, 0x35, 0x33, 0x39, 0x62, 0x62, 0x39, 0x62, 0x31, 0x65, 0x61, 0x66, 0x30, 0x65, 0x61, 0x32, 0x61, 0x36, 0x64, 0x61, 0x64, 0x35, 0x61, 0x34, 0x33, 0x36, 0x31, 0x65, 0x34, 0x66, 0x64, 0x30, 0x32, 0x34, 0x33, 0x30, 0x31, 0x37, 0x30, 0x33, 0x61, 0x64, 0x33, 0x39, 0x39, 0x66, 0x38, 0x66, 0x35, 0x32, 0x32, 0x37, 0x32, 0x34, 0x38, 0x66, 0x38, 0x38, 0x38, 0x38, 0x32, 0x38, 0x64, 0x30, 0x66, 0x39, 0x31, 0x37, 0x35, 0x32, 0x39, 0x38, 0x63, 0x66, 0x61, 0x32, 0x62, 0x32, 0x36, 0x35, 0x63, 0x36, 0x39, 0x63, 0x62, 0x37, 0x62, 0x38, 0x30, 0x39, 0x64, 0x34, 0x30, 0x32, 0x61, 0x62, 0x31, 0x31, 0x66, 0x33, 0x65, 0x64, 0x36, 0x32, 0x31, 0x32, 0x63, 0x32, 0x34, 0x66, 0x63, 0x63, 0x64, 0x32, 0x35, 0x37, 0x32, 0x63, 0x38, 0x65, 0x34, 0x31, 0x34, 0x61, 0x38, 0x39, 0x39, 0x33, 0x64, 0x61, 0x34, 0x33, 0x35, 0x63, 0x36, 0x34, 0x31, 0x63, 0x63, 0x38, 0x30, 0x32, 0x37, 0x64, 0x32, 0x66, 0x39, 0x37, 0x38, 0x36, 0x33, 0x35, 0x33, 0x66, 0x31, 0x35, 0x39, 0x38, 0x32, 0x64, 0x66, 0x64, 0x36, 0x63, 0x62, 0x63, 0x39, 0x38, 0x66, 0x64, 0x31, 0x38, 0x30, 0x37, 0x36, 0x38, 0x38, 0x35, 0x39, 0x37, 0x32, 0x66, 0x36, 0x37, 0x63, 0x37, 0x65, 0x33, 0x65, 0x63, 0x32, 0x38, 0x66, 0x64, 0x64, 0x32, 0x33, 0x32, 0x63, 0x30, 0x62, 0x33, 0x34, 0x61, 0x65, 0x31, 0x30, 0x63, 0x65, 0x31, 0x32, 0x36, 0x34, 0x35, 0x33, 0x61, 0x32, 0x39, 0x66, 0x34, 0x64, 0x36, 0x66, 0x39, 0x37, 0x36, 0x39, 0x36, 0x61, 0x61, 0x31, 0x63, 0x36, 0x39, 0x34, 0x35, 0x66, 0x64, 0x34, 0x34, 0x33, 0x62, 0x63, 0x37, 0x32, 0x64, 0x38, 0x34, 0x38, 0x36, 0x32, 0x39, 0x31, 0x37, 0x33, 0x33, 0x65, 0x30, 0x30, 0x33, 0x64, 0x33, 0x35, 0x38, 0x38, 0x34, 0x31, 0x61, 0x65, 0x37, 0x34, 0x31, 0x65, 0x66, 0x61, 0x61, 0x62, 0x30, 0x34, 0x35, 0x66, 0x32, 0x65, 0x37, 0x62, 0x31, 0x63, 0x32, 0x32, 0x37, 0x38, 0x39, 0x62, 0x34, 0x30, 0x61, 0x33, 0x63, 0x66, 0x30, 0x63, 0x39, 0x38, 0x39, 0x62, 0x38, 0x63, 0x37, 0x32, 0x66, 0x65, 0x62, 0x36, 0x34, 0x35, 0x62, 0x35, 0x38, 0x36, 0x31, 0x61, 0x62, 0x39, 0x63, 0x64, 0x33, 0x33, 0x63, 0x36, 0x66, 0x63, 0x66, 0x37, 0x30, 0x66, 0x66, 0x30, 0x35, 0x35, 0x30, 0x39, 0x62, 0x30, 0x64, 0x34, 0x34, 0x66, 0x63, 0x62, 0x36, 0x38, 0x62, 0x63, 0x64, 0x64, 0x63, 0x37, 0x61, 0x63, 0x30, 0x38, 0x39, 0x35, 0x61, 0x34, 0x63, 0x64, 0x35, 0x65, 0x31, 0x32, 0x37, 0x32, 0x38, 0x36, 0x65, 0x35, 0x38, 0x36, 0x66, 0x61, 0x32, 0x35, 0x39, 0x39, 0x36, 0x39, 0x34, 0x63, 0x31, 0x33, 0x66, 0x30, 0x32, 0x63, 0x35, 0x30, 0x64, 0x63, 0x33, 0x32, 0x35, 0x39, 0x61, 0x36, 0x32, 0x62, 0x33, 0x61, 0x35, 0x32, 0x35, 0x39, 0x32, 0x62, 0x39, 0x34, 0x32, 0x66, 0x63, 0x30, 0x37, 0x61, 0x33, 0x61, 0x63, 0x33, 0x31, 0x38, 0x31, 0x38, 0x32, 0x39, 0x32, 0x36, 0x37, 0x32, 0x32, 0x39, 0x34, 0x33, 0x36, 0x34, 0x66, 0x33, 0x39, 0x38, 0x39, 0x35, 0x38, 0x63, 0x36, 0x62, 0x33, 0x31, 0x33, 0x63, 0x37, 0x36, 0x39, 0x31, 0x37, 0x36, 0x63, 0x34, 0x34, 0x66, 0x65, 0x61, 0x39, 0x63, 0x34, 0x32, 0x65, 0x39, 0x38, 0x32, 0x30, 0x33, 0x35, 0x34, 0x34, 0x32, 0x66, 0x65, 0x35, 0x30, 0x63, 0x61, 0x34, 0x37, 0x39, 0x30, 0x33, 0x38, 0x61, 0x31, 0x62, 0x62, 0x35, 0x33, 0x62, 0x32, 0x64, 0x61, 0x62, 0x31, 0x31, 0x64, 0x66, 0x31, 0x32, 0x30, 0x62, 0x35, 0x39, 0x61, 0x62, 0x32, 0x33, 0x66, 0x35, 0x61, 0x32, 0x30, 0x65, 0x33, 0x66, 0x39, 0x30, 0x63, 0x62, 0x30, 0x31, 0x35, 0x35, 0x33, 0x61, 0x39, 0x32, 0x61, 0x62, 0x65, 0x39, 0x34, 0x37, 0x64, 0x61, 0x31, 0x31, 0x39, 0x30, 0x65, 0x66, 0x32, 0x62, 0x31, 0x30, 0x34, 0x36, 0x32, 0x30, 0x34, 0x30, 0x32, 0x39, 0x37, 0x39, 0x39, 0x66, 0x31, 0x36, 0x32, 0x63, 0x39, 0x65, 0x39, 0x62, 0x32, 0x38, 0x39, 0x35, 0x37, 0x36, 0x34, 0x34, 0x38, 0x39, 0x37, 0x36, 0x30, 0x35, 0x64, 0x38, 0x62, 0x37, 0x33, 0x62, 0x37, 0x65, 0x66, 0x66, 0x37, 0x33, 0x62, 0x62, 0x62, 0x38, 0x37, 0x35, 0x32, 0x38, 0x39, 0x63, 0x37, 0x64, 0x39, 0x64, 0x34, 0x62, 0x38, 0x64, 0x31, 0x62, 0x31, 0x38, 0x35, 0x36, 0x65, 0x33, 0x30, 0x65, 0x30, 0x65, 0x31, 0x62, 0x31, 0x64, 0x34, 0x62, 0x30, 0x37, 0x30, 0x30, 0x32, 0x35, 0x66, 0x37, 0x63, 0x65, 0x39, 0x63, 0x61, 0x62, 0x63, 0x36, 0x31, 0x33, 0x63, 0x36, 0x62, 0x34, 0x39, 0x66, 0x64, 0x34, 0x34, 0x66, 0x31, 0x36, 0x66, 0x36, 0x31, 0x32, 0x30, 0x65, 0x37, 0x31, 0x64, 0x66, 0x34, 0x33, 0x33, 0x64, 0x30, 0x30, 0x36, 0x34, 0x64, 0x33, 0x35, 0x37, 0x32, 0x62, 0x32, 0x34, 0x61, 0x32, 0x64, 0x30, 0x32, 0x30, 0x61, 0x34, 0x65, 0x39, 0x32, 0x64, 0x35, 0x65, 0x62, 0x37, 0x37, 0x34, 0x36, 0x31, 0x63, 0x62, 0x38, 0x32, 0x39, 0x61, 0x33, 0x61, 0x62, 0x63, 0x33, 0x65, 0x35, 0x38, 0x66, 0x35, 0x33, 0x63, 0x33, 0x36, 0x64, 0x61, 0x32, 0x37, 0x33, 0x35, 0x39, 0x37, 0x62, 0x39, 0x36, 0x37, 0x30, 0x62, 0x66, 0x34, 0x31, 0x33, 0x31, 0x37, 0x32, 0x65, 0x62, 0x38, 0x30, 0x62, 0x63, 0x64, 0x63, 0x31, 0x31, 0x31, 0x31, 0x62, 0x37, 0x64, 0x35, 0x36, 0x37, 0x35, 0x31, 0x66, 0x32, 0x35, 0x63, 0x66, 0x35, 0x31, 0x36, 0x34, 0x66, 0x66, 0x62, 0x36, 0x35, 0x62, 0x63, 0x38, 0x61, 0x38, 0x61, 0x61, 0x34, 0x32, 0x31, 0x31, 0x61, 0x39, 0x38, 0x63, 0x38, 0x32, 0x31, 0x39, 0x39, 0x63, 0x34, 0x38, 0x36, 0x37, 0x33, 0x34, 0x66, 0x32, 0x36, 0x33, 0x32, 0x64, 0x65, 0x66, 0x61, 0x65, 0x39, 0x38, 0x34, 0x30, 0x66, 0x33, 0x38, 0x66, 0x66, 0x64, 0x39, 0x64, 0x64, 0x64, 0x61, 0x30, 0x36, 0x30, 0x35, 0x62, 0x34, 0x32, 0x63, 0x31, 0x34, 0x64, 0x33, 0x38, 0x30, 0x37, 0x65, 0x64, 0x39, 0x64, 0x64, 0x34, 0x62, 0x37, 0x36, 0x34, 0x63, 0x64, 0x66, 0x65, 0x61, 0x38, 0x37, 0x65, 0x37, 0x30, 0x32, 0x34, 0x39, 0x33, 0x39, 0x37, 0x32, 0x37, 0x66, 0x33, 0x34, 0x61, 0x36, 0x61, 0x65, 0x30, 0x64, 0x37, 0x38, 0x34, 0x62, 0x35, 0x63, 0x39, 0x62, 0x32, 0x66, 0x62, 0x39, 0x32, 0x62, 0x37, 0x36, 0x64, 0x63, 0x39, 0x35, 0x63, 0x36, 0x30, 0x63, 0x34, 0x33, 0x38, 0x39, 0x34, 0x64, 0x38, 0x30, 0x65, 0x38, 0x37, 0x36, 0x37, 0x39, 0x31, 0x62, 0x31, 0x66, 0x39, 0x61, 0x61, 0x37, 0x30, 0x62, 0x62, 0x30, 0x63, 0x30, 0x37, 0x32, 0x35, 0x35, 0x37, 0x65, 0x34, 0x31, 0x64, 0x37, 0x62, 0x38, 0x37, 0x38, 0x65, 0x64, 0x62, 0x63, 0x64, 0x38, 0x64, 0x34, 0x66, 0x66, 0x62, 0x38, 0x37, 0x33, 0x34, 0x37, 0x65, 0x36, 0x64, 0x33, 0x65, 0x33, 0x30, 0x61, 0x34, 0x63, 0x32, 0x66, 0x38, 0x66, 0x33, 0x62, 0x66, 0x64, 0x62, 0x34, 0x61, 0x36, 0x35, 0x36, 0x33, 0x61, 0x62, 0x36, 0x32, 0x66, 0x32, 0x33, 0x38, 0x61, 0x37, 0x32, 0x36, 0x66, 0x62, 0x64, 0x66, 0x32, 0x39, 0x37, 0x33, 0x63, 0x66, 0x38, 0x61, 0x38, 0x33, 0x37, 0x37, 0x35, 0x30, 0x30, 0x64, 0x62, 0x33, 0x30, 0x65, 0x33, 0x37, 0x36, 0x33, 0x39, 0x34, 0x31, 0x37, 0x30, 0x37, 0x31, 0x65, 0x37, 0x34, 0x34, 0x37, 0x36, 0x65, 0x64, 0x38, 0x32, 0x38, 0x39, 0x34, 0x62, 0x38, 0x37, 0x65, 0x33, 0x30, 0x64, 0x66, 0x33, 0x39, 0x38, 0x39, 0x33, 0x36, 0x38, 0x30, 0x34, 0x64, 0x62, 0x33, 0x38, 0x30, 0x31, 0x39, 0x37, 0x35, 0x64, 0x37, 0x30, 0x63, 0x36, 0x32, 0x32, 0x35, 0x62, 0x31, 0x33, 0x37, 0x37, 0x34, 0x63, 0x62, 0x63, 0x31, 0x65, 0x32, 0x36, 0x35, 0x64, 0x33, 0x39, 0x61, 0x32, 0x33, 0x62, 0x64, 0x64, 0x33, 0x39, 0x38, 0x36, 0x36, 0x63, 0x64, 0x31, 0x61, 0x34, 0x63, 0x39, 0x39, 0x61, 0x34, 0x32, 0x35, 0x31, 0x63, 0x32, 0x34, 0x36, 0x66, 0x36, 0x38, 0x66, 0x64, 0x31, 0x30, 0x61, 0x30, 0x30, 0x35, 0x65, 0x63, 0x30, 0x66, 0x36, 0x61, 0x35, 0x34, 0x64, 0x32, 0x33, 0x36, 0x61, 0x65, 0x35, 0x39, 0x32, 0x66, 0x66, 0x32, 0x64, 0x36, 0x33, 0x30, 0x61, 0x63, 0x30, 0x61, 0x34, 0x38, 0x31, 0x63, 0x36, 0x33, 0x39, 0x62, 0x38, 0x35, 0x33, 0x62, 0x34, 0x38, 0x38, 0x37, 0x36, 0x34, 0x64, 0x31, 0x30, 0x34, 0x37, 0x34, 0x62, 0x64, 0x37, 0x35, 0x33, 0x66, 0x33, 0x33, 0x65, 0x62, 0x66, 0x30, 0x35, 0x35, 0x65, 0x38, 0x35, 0x36, 0x62, 0x34, 0x36, 0x63, 0x37, 0x63, 0x37, 0x32, 0x30, 0x31, 0x65, 0x64, 0x31, 0x30, 0x37, 0x34, 0x30, 0x39, 0x34, 0x31, 0x37, 0x62, 0x64, 0x34, 0x63, 0x32, 0x63, 0x64, 0x39, 0x63, 0x37, 0x34, 0x39, 0x33, 0x63, 0x65, 0x36, 0x32, 0x34, 0x34, 0x34, 0x65, 0x61, 0x38, 0x66, 0x37, 0x32, 0x34, 0x63, 0x66, 0x35, 0x36, 0x31, 0x34, 0x64, 0x37, 0x36, 0x32, 0x35, 0x36, 0x36, 0x35, 0x36, 0x38, 0x65, 0x63, 0x65, 0x33, 0x39, 0x65, 0x30, 0x33, 0x33, 0x38, 0x35, 0x64, 0x37, 0x30, 0x34, 0x36, 0x33, 0x39, 0x30, 0x62, 0x33, 0x38, 0x65, 0x31, 0x39, 0x65, 0x32, 0x37, 0x62, 0x32, 0x33, 0x63, 0x62, 0x35, 0x64, 0x38, 0x38, 0x38, 0x38, 0x62, 0x35, 0x62, 0x61, 0x63, 0x32, 0x37, 0x32, 0x31, 0x61, 0x66, 0x61, 0x32, 0x37, 0x33, 0x38, 0x62, 0x66, 0x38, 0x36, 0x65, 0x65, 0x37, 0x31, 0x32, 0x62, 0x66, 0x63, 0x65, 0x36, 0x65, 0x34, 0x38, 0x31, 0x63, 0x34, 0x39, 0x61, 0x63, 0x62, 0x32, 0x39, 0x63, 0x35, 0x30, 0x65, 0x62, 0x33, 0x64, 0x61, 0x38, 0x31, 0x66, 0x37, 0x61, 0x64, 0x33, 0x38, 0x39, 0x61, 0x31, 0x61, 0x30, 0x37, 0x65, 0x36, 0x38, 0x66, 0x63, 0x38, 0x37, 0x32, 0x37, 0x62, 0x61, 0x64, 0x38, 0x35, 0x35, 0x32, 0x65, 0x30, 0x32, 0x32, 0x62, 0x34, 0x61, 0x36, 0x34, 0x35, 0x63, 0x64, 0x34, 0x37, 0x32, 0x35, 0x64, 0x66, 0x35, 0x66, 0x32, 0x37, 0x64, 0x36, 0x33, 0x33, 0x31, 0x66, 0x32, 0x35, 0x36, 0x62, 0x39, 0x33, 0x32, 0x30, 0x38, 0x39, 0x33, 0x33, 0x61, 0x66, 0x65, 0x63, 0x37, 0x34, 0x39, 0x31, 0x31, 0x63, 0x61, 0x31, 0x61, 0x33, 0x37, 0x32, 0x61, 0x38, 0x64, 0x64, 0x63, 0x36, 0x36, 0x38, 0x65, 0x37, 0x35, 0x36, 0x63, 0x64, 0x62, 0x30, 0x32, 0x36, 0x39, 0x31, 0x37, 0x61, 0x36, 0x62, 0x36, 0x36, 0x37, 0x32, 0x30, 0x39, 0x36, 0x66, 0x33, 0x61, 0x35, 0x61, 0x63, 0x35, 0x66, 0x63, 0x34, 0x62, 0x62, 0x39, 0x34, 0x37, 0x30, 0x31, 0x38, 0x33, 0x64, 0x38, 0x63, 0x33, 0x66, 0x66, 0x34, 0x30, 0x66, 0x34, 0x31, 0x31, 0x35, 0x35, 0x63, 0x38, 0x62, 0x64, 0x66, 0x31, 0x64, 0x31, 0x39, 0x35, 0x31, 0x61, 0x36, 0x36, 0x30, 0x35, 0x32, 0x65, 0x65, 0x37, 0x38, 0x35, 0x33, 0x61, 0x63, 0x65, 0x37, 0x61, 0x63, 0x63, 0x62, 0x61, 0x37, 0x39, 0x31, 0x38, 0x33, 0x39, 0x32, 0x32, 0x63, 0x33, 0x63, 0x33, 0x64, 0x64, 0x38, 0x30, 0x39, 0x65, 0x65, 0x64, 0x34, 0x65, 0x34, 0x34, 0x38, 0x35, 0x36, 0x61, 0x65, 0x62, 0x37, 0x32, 0x65, 0x65, 0x66, 0x62, 0x39, 0x62, 0x65, 0x64, 0x65, 0x37, 0x33, 0x66, 0x37, 0x34, 0x37, 0x65, 0x35, 0x61, 0x62, 0x34, 0x65, 0x61, 0x30, 0x37, 0x30, 0x33, 0x63, 0x62, 0x62, 0x34, 0x36, 0x39, 0x37, 0x37, 0x62, 0x66, 0x62, 0x32, 0x65, 0x37, 0x63, 0x38, 0x39, 0x36, 0x66, 0x39, 0x62, 0x31, 0x36, 0x31, 0x34, 0x61, 0x37, 0x62, 0x66, 0x35, 0x36, 0x39, 0x61, 0x62, 0x64, 0x65, 0x31, 0x33, 0x38, 0x32, 0x64, 0x33, 0x30, 0x39, 0x34, 0x36, 0x34, 0x30, 0x65, 0x34, 0x39, 0x64, 0x31, 0x37, 0x33, 0x31, 0x35, 0x32, 0x38, 0x33, 0x62, 0x31, 0x37, 0x37, 0x61, 0x38, 0x62, 0x31, 0x35, 0x35, 0x34, 0x61, 0x66, 0x35, 0x31, 0x39, 0x39, 0x64, 0x37, 0x34, 0x63, 0x64, 0x63, 0x64, 0x35, 0x32, 0x31, 0x35, 0x35, 0x66, 0x63, 0x30, 0x35, 0x61, 0x63, 0x63, 0x35, 0x33, 0x35, 0x61, 0x37, 0x32, 0x34, 0x32, 0x33, 0x35, 0x30, 0x38, 0x36, 0x31, 0x32, 0x37, 0x33, 0x31, 0x32, 0x37, 0x33, 0x35, 0x37, 0x63, 0x35, 0x32, 0x65, 0x34, 0x62, 0x62, 0x33, 0x38, 0x31, 0x37, 0x38, 0x32, 0x63, 0x64, 0x36, 0x65, 0x38, 0x32, 0x39, 0x34, 0x35, 0x31, 0x31, 0x35, 0x34, 0x63, 0x33, 0x33, 0x63, 0x65, 0x35, 0x39, 0x31, 0x31, 0x65, 0x32, 0x62, 0x63, 0x36, 0x62, 0x65, 0x30, 0x30, 0x64, 0x37, 0x32, 0x66, 0x63, 0x34, 0x38, 0x37, 0x35, 0x39, 0x34, 0x33, 0x64, 0x65, 0x66, 0x39, 0x30, 0x35, 0x64, 0x32, 0x31, 0x34, 0x32, 0x65, 0x32, 0x37, 0x36, 0x37, 0x37, 0x36, 0x64, 0x34, 0x39, 0x62, 0x35, 0x64, 0x38, 0x35, 0x36, 0x36, 0x35, 0x30, 0x38, 0x61, 0x66, 0x37, 0x38, 0x34, 0x39, 0x34, 0x64, 0x31, 0x61, 0x34, 0x37, 0x36, 0x36, 0x32, 0x66, 0x39, 0x33, 0x39, 0x34, 0x39, 0x65, 0x34, 0x32, 0x36, 0x30, 0x36, 0x64, 0x31, 0x64, 0x33, 0x31, 0x30, 0x34, 0x31, 0x62, 0x65, 0x38, 0x31, 0x61, 0x38, 0x66, 0x35, 0x32, 0x64, 0x61, 0x34, 0x37, 0x36, 0x64, 0x32, 0x33, 0x38, 0x31, 0x30, 0x33, 0x33, 0x65, 0x31, 0x66, 0x38, 0x35, 0x36, 0x61, 0x32, 0x33, 0x63, 0x62, 0x63, 0x32, 0x32, 0x62, 0x36, 0x39, 0x37, 0x35, 0x64, 0x30, 0x61, 0x38, 0x39, 0x30, 0x36, 0x61, 0x64, 0x36, 0x37, 0x32, 0x64, 0x64, 0x32, 0x37, 0x33, 0x31, 0x36, 0x37, 0x65, 0x62, 0x31, 0x30, 0x31, 0x33, 0x33, 0x34, 0x61, 0x31, 0x63, 0x63, 0x34, 0x37, 0x61, 0x62, 0x39, 0x33, 0x63, 0x38, 0x62, 0x37, 0x64, 0x62, 0x31, 0x37, 0x34, 0x37, 0x39, 0x66, 0x35, 0x30, 0x39, 0x61, 0x65, 0x34, 0x63, 0x63, 0x65, 0x34, 0x65, 0x61, 0x34, 0x35, 0x30, 0x63, 0x36, 0x33, 0x61, 0x31, 0x65, 0x65, 0x33, 0x62, 0x37, 0x32, 0x38, 0x34, 0x36, 0x32, 0x39, 0x65, 0x38, 0x37, 0x37, 0x35, 0x61, 0x66, 0x64, 0x32, 0x62, 0x32, 0x64, 0x62, 0x63, 0x36, 0x38, 0x62, 0x64, 0x36, 0x31, 0x36, 0x37, 0x66, 0x33, 0x33, 0x65, 0x32, 0x37, 0x37, 0x35, 0x30, 0x39, 0x31, 0x63, 0x30, 0x36, 0x35, 0x38, 0x62, 0x61, 0x38, 0x33, 0x32, 0x32, 0x30, 0x36, 0x37, 0x66, 0x61, 0x64, 0x38, 0x66, 0x62, 0x61, 0x63, 0x35, 0x32, 0x37, 0x32, 0x62, 0x66, 0x65, 0x61, 0x37, 0x35, 0x61, 0x64, 0x38, 0x32, 0x31, 0x38, 0x61, 0x65, 0x63, 0x65, 0x35, 0x30, 0x32, 0x35, 0x33, 0x35, 0x34, 0x66, 0x65, 0x39, 0x66, 0x37, 0x32, 0x63, 0x38, 0x32, 0x33, 0x34, 0x61, 0x65, 0x31, 0x31, 0x36, 0x33, 0x39, 0x37, 0x63, 0x65, 0x30, 0x38, 0x30, 0x63, 0x32, 0x38, 0x31, 0x64, 0x33, 0x38, 0x37, 0x62, 0x32, 0x38, 0x38, 0x61, 0x63, 0x33, 0x37, 0x32, 0x64, 0x62, 0x31, 0x30, 0x33, 0x63, 0x64, 0x66, 0x66, 0x31, 0x36, 0x64, 0x61, 0x32, 0x33, 0x66, 0x61, 0x31, 0x35, 0x61, 0x32, 0x66, 0x31, 0x64, 0x37, 0x33, 0x37, 0x64, 0x32, 0x63, 0x39, 0x65, 0x34, 0x32, 0x39, 0x66, 0x32, 0x36, 0x36, 0x31, 0x65, 0x64, 0x35, 0x34, 0x61, 0x34, 0x66, 0x65, 0x64, 0x32, 0x31, 0x31, 0x66, 0x34, 0x30, 0x64, 0x37, 0x35, 0x34, 0x63, 0x64, 0x32, 0x37, 0x32, 0x34, 0x39, 0x65, 0x37, 0x39, 0x35, 0x30, 0x66, 0x62, 0x64, 0x33, 0x63, 0x33, 0x34, 0x61, 0x61, 0x34, 0x30, 0x64, 0x32, 0x34, 0x63, 0x30, 0x62, 0x39, 0x62, 0x66, 0x35, 0x34, 0x33, 0x35, 0x35, 0x32, 0x34, 0x37, 0x32, 0x30, 0x63, 0x38, 0x63, 0x34, 0x32, 0x33, 0x35, 0x37, 0x36, 0x37, 0x32, 0x34, 0x33, 0x64, 0x35, 0x33, 0x38, 0x31, 0x62, 0x38, 0x63, 0x37, 0x36, 0x37, 0x38, 0x37, 0x32, 0x32, 0x39, 0x35, 0x65, 0x31, 0x66, 0x34, 0x38, 0x35, 0x66, 0x36, 0x39, 0x31, 0x37, 0x34, 0x64, 0x64, 0x66, 0x31, 0x66, 0x38, 0x31, 0x62, 0x38, 0x32, 0x38, 0x33, 0x30, 0x38, 0x31, 0x36, 0x30, 0x37, 0x64, 0x36, 0x34, 0x63, 0x37, 0x35, 0x62, 0x61, 0x33, 0x63, 0x35, 0x61, 0x61, 0x65, 0x63, 0x35, 0x32, 0x32, 0x30, 0x36, 0x61, 0x37, 0x36, 0x34, 0x64, 0x65, 0x32, 0x34, 0x65, 0x37, 0x32, 0x66, 0x61, 0x31, 0x32, 0x30, 0x33, 0x63, 0x65, 0x38, 0x62, 0x39, 0x62, 0x32, 0x37, 0x31, 0x36, 0x32, 0x33, 0x63, 0x33, 0x34, 0x32, 0x61, 0x63, 0x65, 0x63, 0x36, 0x64, 0x65, 0x35, 0x63, 0x36, 0x36, 0x63, 0x39, 0x36, 0x35, 0x65, 0x38, 0x66, 0x39, 0x66, 0x36, 0x66, 0x31, 0x36, 0x31, 0x31, 0x61, 0x62, 0x36, 0x30, 0x38, 0x63, 0x64, 0x63, 0x63, 0x61, 0x34, 0x65, 0x61, 0x34, 0x35, 0x31, 0x31, 0x32, 0x32, 0x66, 0x34, 0x34, 0x35, 0x63, 0x39, 0x39, 0x66, 0x63, 0x63, 0x65, 0x34, 0x31, 0x65, 0x65, 0x64, 0x61, 0x38, 0x66, 0x38, 0x32, 0x35, 0x63, 0x65, 0x38, 0x39, 0x35, 0x37, 0x39, 0x39, 0x66, 0x65, 0x37, 0x30, 0x37, 0x35, 0x63, 0x65, 0x37, 0x38, 0x36, 0x37, 0x30, 0x63, 0x65, 0x31, 0x31, 0x61, 0x64, 0x36, 0x39, 0x62, 0x61, 0x39, 0x38, 0x66, 0x66, 0x32, 0x30, 0x37, 0x32, 0x39, 0x62, 0x34, 0x36, 0x31, 0x33, 0x38, 0x38, 0x34, 0x63, 0x61, 0x64, 0x36, 0x64, 0x36, 0x38, 0x65, 0x34, 0x63, 0x30, 0x38, 0x31, 0x32, 0x34, 0x31, 0x66, 0x35, 0x64, 0x37, 0x63, 0x65, 0x33, 0x63, 0x66, 0x33, 0x66, 0x32, 0x39, 0x61, 0x65, 0x34, 0x33, 0x64, 0x31, 0x30, 0x39, 0x35, 0x66, 0x38, 0x65, 0x39, 0x64, 0x32, 0x61, 0x63, 0x66, 0x62, 0x65, 0x61, 0x64, 0x31, 0x37, 0x35, 0x33, 0x63, 0x35, 0x66, 0x65, 0x34, 0x62, 0x37, 0x34, 0x39, 0x30, 0x30, 0x61, 0x38, 0x63, 0x37, 0x37, 0x62, 0x61, 0x39, 0x34, 0x64, 0x38, 0x32, 0x33, 0x62, 0x65, 0x33, 0x33, 0x38, 0x64, 0x31, 0x38, 0x32, 0x34, 0x63, 0x30, 0x62, 0x32, 0x36, 0x39, 0x34, 0x35, 0x33, 0x62, 0x39, 0x39, 0x61, 0x36, 0x35, 0x31, 0x39, 0x35, 0x32, 0x63, 0x62, 0x62, 0x31, 0x64, 0x64, 0x33, 0x38, 0x62, 0x37, 0x32, 0x63, 0x30, 0x39, 0x33, 0x64, 0x65, 0x38, 0x30, 0x32, 0x65, 0x32, 0x66, 0x66, 0x33, 0x35, 0x31, 0x66, 0x35, 0x64, 0x63, 0x66, 0x62, 0x62, 0x36, 0x63, 0x32, 0x31, 0x38, 0x37, 0x36, 0x31, 0x65, 0x36, 0x33, 0x34, 0x63, 0x62, 0x66, 0x33, 0x33, 0x39, 0x38, 0x33, 0x33, 0x37, 0x33, 0x39, 0x39, 0x61, 0x66, 0x35, 0x37, 0x64, 0x36, 0x62, 0x62, 0x65, 0x63, 0x64, 0x61, 0x36, 0x36, 0x31, 0x62, 0x31, 0x39, 0x61, 0x35, 0x66, 0x32, 0x30, 0x33, 0x63, 0x35, 0x35, 0x39, 0x61, 0x33, 0x61, 0x35, 0x30, 0x39, 0x37, 0x37, 0x31, 0x62, 0x39, 0x36, 0x64, 0x35, 0x35, 0x38, 0x35, 0x33, 0x63, 0x34, 0x65, 0x62, 0x30, 0x38, 0x64, 0x34, 0x39, 0x32, 0x65, 0x61, 0x34, 0x32, 0x62, 0x63, 0x33, 0x65, 0x64, 0x36, 0x64, 0x66, 0x62, 0x36, 0x63, 0x30, 0x39, 0x37, 0x65, 0x63, 0x35, 0x33, 0x30, 0x62, 0x66, 0x36, 0x36, 0x34, 0x38, 0x39, 0x38, 0x62, 0x35, 0x62, 0x33, 0x32, 0x63, 0x66, 0x38, 0x65, 0x32, 0x31, 0x33, 0x38, 0x64, 0x64, 0x36, 0x64, 0x62, 0x61, 0x64, 0x66, 0x65, 0x64, 0x38, 0x32, 0x61, 0x61, 0x36, 0x35, 0x61, 0x30, 0x61, 0x62, 0x64, 0x30, 0x33, 0x65, 0x39, 0x62, 0x32, 0x33, 0x63, 0x37, 0x36, 0x62, 0x34, 0x65, 0x62, 0x62, 0x61, 0x33, 0x33, 0x39, 0x62, 0x64, 0x37, 0x32, 0x39, 0x37, 0x30, 0x65, 0x30, 0x64, 0x30, 0x63, 0x65, 0x62, 0x37, 0x31, 0x66, 0x32, 0x63, 0x35, 0x32, 0x39, 0x65, 0x64, 0x39, 0x31, 0x64, 0x35, 0x30, 0x36, 0x37, 0x64, 0x33, 0x62, 0x39, 0x66, 0x63, 0x30, 0x65, 0x37, 0x38, 0x65, 0x62, 0x64, 0x39, 0x31, 0x64, 0x31, 0x61, 0x63, 0x36, 0x30, 0x65, 0x30, 0x30, 0x63, 0x36, 0x33, 0x61, 0x34, 0x31, 0x32, 0x61, 0x38, 0x65, 0x35, 0x37, 0x32, 0x39, 0x62, 0x38, 0x38, 0x34, 0x36, 0x63, 0x39, 0x33, 0x36, 0x37, 0x31, 0x38, 0x65, 0x33, 0x39, 0x30, 0x36, 0x66, 0x33, 0x34, 0x35, 0x64, 0x35, 0x63, 0x33, 0x66, 0x31, 0x61, 0x65, 0x61, 0x38, 0x39, 0x66, 0x63, 0x34, 0x66, 0x34, 0x62, 0x61, 0x62, 0x35, 0x32, 0x39, 0x37, 0x65, 0x38, 0x38, 0x34, 0x62, 0x65, 0x32, 0x30, 0x65, 0x61, 0x33, 0x61, 0x61, 0x63, 0x38, 0x33, 0x66, 0x37, 0x32, 0x36, 0x39, 0x61, 0x35, 0x62, 0x66, 0x37, 0x34, 0x34, 0x63, 0x36, 0x62, 0x38, 0x30, 0x35, 0x63, 0x32, 0x61, 0x61, 0x35, 0x61, 0x35, 0x32, 0x38, 0x37, 0x61, 0x66, 0x39, 0x30, 0x30, 0x63, 0x63, 0x61, 0x36, 0x34, 0x35, 0x35, 0x39, 0x36, 0x33, 0x37, 0x37, 0x65, 0x32, 0x61, 0x39, 0x61, 0x66, 0x66, 0x33, 0x33, 0x63, 0x36, 0x32, 0x31, 0x62, 0x33, 0x34, 0x38, 0x34, 0x36, 0x37, 0x37, 0x31, 0x61, 0x30, 0x36, 0x34, 0x30, 0x34, 0x31, 0x64, 0x30, 0x65, 0x34, 0x35, 0x35, 0x65, 0x38, 0x65, 0x34, 0x66, 0x37, 0x65, 0x31, 0x34, 0x63, 0x35, 0x61, 0x36, 0x37, 0x31, 0x66, 0x39, 0x64, 0x32, 0x39, 0x33, 0x37, 0x61, 0x31, 0x38, 0x62, 0x31, 0x65, 0x65, 0x65, 0x62, 0x36, 0x35, 0x36, 0x63, 0x35, 0x33, 0x65, 0x66, 0x32, 0x66, 0x31, 0x36, 0x34, 0x63, 0x30, 0x66, 0x32, 0x61, 0x37, 0x32, 0x31, 0x32, 0x65, 0x37, 0x63, 0x66, 0x37, 0x65, 0x35, 0x31, 0x62, 0x32, 0x64, 0x36, 0x38, 0x31, 0x36, 0x66, 0x35, 0x65, 0x62, 0x61, 0x63, 0x30, 0x38, 0x64, 0x32, 0x65, 0x38, 0x64, 0x36, 0x38, 0x31, 0x66, 0x63, 0x62, 0x62, 0x63, 0x33, 0x37, 0x32, 0x61, 0x32, 0x30, 0x65, 0x31, 0x36, 0x39, 0x64, 0x35, 0x34, 0x64, 0x35, 0x31, 0x37, 0x39, 0x36, 0x61, 0x61, 0x37, 0x39, 0x63, 0x31, 0x32, 0x39, 0x64, 0x33, 0x38, 0x39, 0x34, 0x34, 0x63, 0x66, 0x33, 0x34, 0x38, 0x39, 0x66, 0x66, 0x33, 0x35, 0x32, 0x31, 0x37, 0x39, 0x64, 0x33, 0x39, 0x62, 0x37, 0x31, 0x33, 0x65, 0x32, 0x63, 0x32, 0x32, 0x31, 0x62, 0x61, 0x66, 0x31, 0x34, 0x66, 0x65, 0x30, 0x63, 0x35, 0x62, 0x61, 0x66, 0x37, 0x38, 0x35, 0x65, 0x63, 0x31, 0x30, 0x62, 0x63, 0x35, 0x35, 0x30, 0x33, 0x66, 0x31, 0x35, 0x32, 0x34, 0x32, 0x38, 0x65, 0x64, 0x33, 0x65, 0x36, 0x63, 0x33, 0x65, 0x37, 0x66, 0x66, 0x62, 0x62, 0x63, 0x38, 0x63, 0x62, 0x38, 0x38, 0x33, 0x62, 0x33, 0x31, 0x30, 0x31, 0x65, 0x36, 0x66, 0x30, 0x36, 0x36, 0x34, 0x30, 0x38, 0x39, 0x31, 0x34, 0x30, 0x36, 0x65, 0x63, 0x66, 0x66, 0x33, 0x39, 0x61, 0x38, 0x65, 0x30, 0x30, 0x34, 0x37, 0x63, 0x31, 0x34, 0x32, 0x34, 0x33, 0x61, 0x37, 0x32, 0x39, 0x61, 0x34, 0x65, 0x39, 0x63, 0x66, 0x33, 0x31, 0x37, 0x64, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x63, 0x38, 0x64, 0x66, 0x30, 0x31, 0x65, 0x63, 0x31, 0x66, 0x64, 0x37, 0x64, 0x66, 0x35, 0x38, 0x36, 0x39, 0x30, 0x32, 0x32, 0x35, 0x31, 0x36, 0x65, 0x63, 0x30, 0x64, 0x35, 0x34, 0x32, 0x31, 0x37, 0x65, 0x66, 0x64, 0x39, 0x31, 0x35, 0x61, 0x39, 0x66, 0x38, 0x64, 0x30, 0x37, 0x32, 0x61, 0x35, 0x66, 0x31, 0x65, 0x38, 0x61, 0x30, 0x39, 0x33, 0x64, 0x33, 0x30, 0x31, 0x30, 0x62, 0x38, 0x65, 0x62, 0x36, 0x38, 0x64, 0x64, 0x36, 0x62, 0x37, 0x33, 0x35, 0x33, 0x30, 0x66, 0x65, 0x62, 0x31, 0x33, 0x32, 0x63, 0x37, 0x34, 0x65, 0x34, 0x38, 0x33, 0x31, 0x34, 0x66, 0x65, 0x33, 0x34, 0x35, 0x39, 0x37, 0x62, 0x63, 0x65, 0x30, 0x61, 0x31, 0x31, 0x34, 0x38, 0x34, 0x34, 0x38, 0x63, 0x65, 0x32, 0x64, 0x66, 0x36, 0x30, 0x32, 0x32, 0x66, 0x32, 0x33, 0x37, 0x38, 0x66, 0x37, 0x61, 0x62, 0x62, 0x64, 0x61, 0x65, 0x33, 0x39, 0x63, 0x65, 0x61, 0x66, 0x65, 0x63, 0x36, 0x36, 0x32, 0x31, 0x36, 0x38, 0x63, 0x37, 0x31, 0x32, 0x63, 0x66, 0x62, 0x66, 0x31, 0x32, 0x63, 0x30, 0x32, 0x30, 0x64, 0x64, 0x33, 0x31, 0x61, 0x32, 0x39, 0x65, 0x31, 0x34, 0x30, 0x65, 0x33, 0x30, 0x39, 0x64, 0x61, 0x34, 0x65, 0x39, 0x61, 0x66, 0x38, 0x35, 0x30, 0x34, 0x35, 0x37, 0x33, 0x30, 0x66, 0x63, 0x30, 0x36, 0x33, 0x64, 0x39, 0x62, 0x62, 0x66, 0x35, 0x30, 0x32, 0x66, 0x36, 0x35, 0x32, 0x34, 0x34, 0x66, 0x30, 0x66, 0x32, 0x33, 0x63, 0x66, 0x63, 0x65, 0x36, 0x62, 0x33, 0x36, 0x64, 0x61, 0x31, 0x38, 0x33, 0x39, 0x37, 0x34, 0x64, 0x39, 0x66, 0x36, 0x65, 0x31, 0x35, 0x61, 0x63, 0x63, 0x38, 0x36, 0x36, 0x34, 0x39, 0x36, 0x31, 0x65, 0x32, 0x65, 0x34, 0x37, 0x35, 0x36, 0x63, 0x34, 0x33, 0x35, 0x33, 0x39, 0x39, 0x32, 0x34, 0x39, 0x32, 0x63, 0x38, 0x33, 0x64, 0x62, 0x35, 0x34, 0x62, 0x32, 0x38, 0x39, 0x31, 0x31, 0x34, 0x33, 0x31, 0x63, 0x39, 0x37, 0x33, 0x30, 0x61, 0x62, 0x33, 0x35, 0x39, 0x62, 0x63, 0x33, 0x32, 0x64, 0x37, 0x32, 0x62, 0x36, 0x37, 0x32, 0x32, 0x34, 0x33, 0x36, 0x34, 0x31, 0x66, 0x65, 0x33, 0x37, 0x38, 0x65, 0x33, 0x35, 0x64, 0x37, 0x31, 0x34, 0x32, 0x38, 0x36, 0x66, 0x33, 0x36, 0x64, 0x31, 0x62, 0x65, 0x31, 0x64, 0x65, 0x39, 0x63, 0x39, 0x61, 0x62, 0x35, 0x63, 0x33, 0x61, 0x32, 0x36, 0x31, 0x65, 0x38, 0x31, 0x37, 0x66, 0x33, 0x66, 0x61, 0x66, 0x34, 0x31, 0x39, 0x66, 0x31, 0x34, 0x66, 0x61, 0x39, 0x33, 0x31, 0x66, 0x34, 0x65, 0x66, 0x30, 0x38, 0x32, 0x30, 0x30, 0x62, 0x33, 0x63, 0x33, 0x61, 0x32, 0x35, 0x62, 0x63, 0x30, 0x66, 0x65, 0x30, 0x36, 0x37, 0x35, 0x30, 0x66, 0x62, 0x61, 0x61, 0x31, 0x64, 0x34, 0x61, 0x38, 0x62, 0x64, 0x66, 0x66, 0x36, 0x34, 0x61, 0x31, 0x30, 0x61, 0x38, 0x32, 0x36, 0x66, 0x31, 0x36, 0x36, 0x65, 0x35, 0x65, 0x35, 0x61, 0x33, 0x61, 0x64, 0x31, 0x32, 0x65, 0x37, 0x32, 0x66, 0x38, 0x30, 0x38, 0x66, 0x34, 0x37, 0x30, 0x36, 0x66, 0x62, 0x36, 0x61, 0x31, 0x37, 0x38, 0x66, 0x66, 0x34, 0x62, 0x33, 0x61, 0x30, 0x37, 0x30, 0x62, 0x63, 0x63, 0x32, 0x65, 0x64, 0x30, 0x66, 0x64, 0x63, 0x37, 0x65, 0x64, 0x36, 0x66, 0x39, 0x62, 0x39, 0x61, 0x64, 0x34, 0x37, 0x38, 0x32, 0x63, 0x35, 0x61, 0x37, 0x35, 0x61, 0x65, 0x63, 0x63, 0x62, 0x30, 0x63, 0x35, 0x37, 0x32, 0x37, 0x36, 0x62, 0x38, 0x38, 0x64, 0x32, 0x65, 0x61, 0x35, 0x35, 0x36, 0x32, 0x61, 0x39, 0x34, 0x38, 0x64, 0x64, 0x36, 0x61, 0x64, 0x65, 0x35, 0x63, 0x30, 0x32, 0x35, 0x31, 0x30, 0x63, 0x33, 0x36, 0x65, 0x30, 0x37, 0x32, 0x66, 0x62, 0x63, 0x39, 0x64, 0x38, 0x37, 0x65, 0x63, 0x63, 0x63, 0x39, 0x63, 0x36, 0x39, 0x33, 0x61, 0x32, 0x65, 0x34, 0x36, 0x35, 0x61, 0x31, 0x63, 0x37, 0x32, 0x64, 0x62, 0x36, 0x61, 0x65, 0x37, 0x37, 0x32, 0x39, 0x33, 0x66, 0x31, 0x31, 0x36, 0x39, 0x36, 0x36, 0x36, 0x34, 0x37, 0x64, 0x38, 0x65, 0x65, 0x31, 0x34, 0x61, 0x61, 0x30, 0x61, 0x65, 0x63, 0x33, 0x66, 0x36, 0x65, 0x37, 0x30, 0x37, 0x32, 0x37, 0x30, 0x37, 0x33, 0x35, 0x34, 0x30, 0x65, 0x33, 0x30, 0x64, 0x61, 0x62, 0x36, 0x39, 0x62, 0x61, 0x66, 0x36, 0x61, 0x39, 0x35, 0x37, 0x32, 0x65, 0x31, 0x62, 0x64, 0x36, 0x65, 0x36, 0x37, 0x61, 0x66, 0x66, 0x35, 0x35, 0x34, 0x61, 0x30, 0x34, 0x65, 0x30, 0x65, 0x66, 0x30, 0x32, 0x66, 0x61, 0x38, 0x31, 0x62, 0x66, 0x37, 0x30, 0x31, 0x35, 0x36, 0x39, 0x35, 0x36, 0x39, 0x64, 0x32, 0x37, 0x35, 0x65, 0x39, 0x38, 0x37, 0x66, 0x63, 0x33, 0x37, 0x62, 0x35, 0x30, 0x33, 0x61, 0x31, 0x33, 0x33, 0x39, 0x37, 0x35, 0x63, 0x32, 0x63, 0x37, 0x61, 0x35, 0x37, 0x63, 0x31, 0x63, 0x63, 0x39, 0x63, 0x34, 0x31, 0x33, 0x36, 0x33, 0x32, 0x30, 0x65, 0x63, 0x63, 0x65, 0x34, 0x39, 0x34, 0x37, 0x33, 0x66, 0x64, 0x31, 0x34, 0x33, 0x65, 0x64, 0x61, 0x35, 0x34, 0x38, 0x31, 0x30, 0x66, 0x37, 0x38, 0x61, 0x30, 0x38, 0x66, 0x39, 0x30, 0x36, 0x61, 0x32, 0x37, 0x36, 0x35, 0x32, 0x33, 0x64, 0x64, 0x33, 0x30, 0x63, 0x37, 0x37, 0x30, 0x66, 0x63, 0x61, 0x62, 0x63, 0x66, 0x38, 0x64, 0x33, 0x37, 0x32, 0x63, 0x35, 0x62, 0x35, 0x62, 0x30, 0x63, 0x66, 0x61, 0x61, 0x33, 0x38, 0x31, 0x32, 0x64, 0x35, 0x64, 0x62, 0x32, 0x31, 0x36, 0x61, 0x30, 0x35, 0x33, 0x38, 0x61, 0x64, 0x37, 0x63, 0x38, 0x34, 0x32, 0x63, 0x63, 0x36, 0x39, 0x31, 0x32, 0x63, 0x63, 0x30, 0x34, 0x62, 0x66, 0x33, 0x36, 0x62, 0x30, 0x37, 0x66, 0x34, 0x39, 0x34, 0x35, 0x61, 0x38, 0x33, 0x65, 0x35, 0x65, 0x66, 0x39, 0x39, 0x37, 0x30, 0x66, 0x63, 0x32, 0x65, 0x35, 0x39, 0x38, 0x65, 0x66, 0x32, 0x35, 0x61, 0x38, 0x66, 0x63, 0x65, 0x61, 0x32, 0x35, 0x31, 0x65, 0x61, 0x30, 0x37, 0x63, 0x31, 0x63, 0x36, 0x61, 0x39, 0x31, 0x31, 0x65, 0x63, 0x66, 0x31, 0x61, 0x64, 0x36, 0x32, 0x35, 0x35, 0x65, 0x31, 0x65, 0x38, 0x37, 0x61, 0x34, 0x30, 0x39, 0x31, 0x30, 0x39, 0x66, 0x61, 0x61, 0x35, 0x39, 0x36, 0x35, 0x63, 0x39, 0x66, 0x32, 0x64, 0x61, 0x32, 0x33, 0x32, 0x64, 0x38, 0x34, 0x62, 0x33, 0x63, 0x33, 0x33, 0x62, 0x65, 0x63, 0x32, 0x35, 0x35, 0x38, 0x66, 0x38, 0x61, 0x31, 0x63, 0x64, 0x30, 0x62, 0x38, 0x61, 0x37, 0x36, 0x62, 0x32, 0x66, 0x64, 0x61, 0x62, 0x30, 0x62, 0x30, 0x39, 0x30, 0x64, 0x32, 0x65, 0x34, 0x32, 0x31, 0x36, 0x62, 0x66, 0x65, 0x34, 0x39, 0x37, 0x34, 0x34, 0x32, 0x33, 0x65, 0x62, 0x31, 0x65, 0x62, 0x34, 0x30, 0x35, 0x39, 0x63, 0x32, 0x35, 0x63, 0x62, 0x66, 0x65, 0x36, 0x62, 0x61, 0x66, 0x32, 0x37, 0x30, 0x30, 0x30, 0x36, 0x64, 0x32, 0x31, 0x65, 0x63, 0x34, 0x31, 0x31, 0x33, 0x31, 0x39, 0x61, 0x37, 0x61, 0x30, 0x62, 0x31, 0x37, 0x64, 0x38, 0x39, 0x61, 0x33, 0x32, 0x39, 0x62, 0x36, 0x32, 0x65, 0x31, 0x62, 0x36, 0x63, 0x62, 0x36, 0x33, 0x38, 0x63, 0x35, 0x34, 0x36, 0x35, 0x38, 0x31, 0x65, 0x39, 0x65, 0x33, 0x62, 0x64, 0x62, 0x35, 0x33, 0x35, 0x64, 0x63, 0x31, 0x35, 0x62, 0x34, 0x31, 0x66, 0x39, 0x35, 0x36, 0x37, 0x61, 0x36, 0x34, 0x38, 0x34, 0x30, 0x31, 0x38, 0x37, 0x37, 0x62, 0x37, 0x62, 0x37, 0x32, 0x32, 0x35, 0x63, 0x39, 0x32, 0x31, 0x35, 0x31, 0x31, 0x32, 0x33, 0x63, 0x61, 0x31, 0x39, 0x65, 0x32, 0x63, 0x30, 0x66, 0x65, 0x34, 0x66, 0x34, 0x63, 0x65, 0x34, 0x63, 0x31, 0x63, 0x62, 0x32, 0x35, 0x31, 0x38, 0x31, 0x34, 0x66, 0x31, 0x33, 0x30, 0x64, 0x34, 0x32, 0x63, 0x32, 0x37, 0x34, 0x33, 0x61, 0x36, 0x66, 0x62, 0x32, 0x66, 0x31, 0x35, 0x64, 0x63, 0x32, 0x65, 0x30, 0x36, 0x62, 0x65, 0x38, 0x64, 0x63, 0x30, 0x64, 0x37, 0x63, 0x66, 0x32, 0x61, 0x30, 0x61, 0x65, 0x38, 0x64, 0x33, 0x30, 0x64, 0x38, 0x39, 0x32, 0x32, 0x36, 0x36, 0x30, 0x33, 0x38, 0x34, 0x30, 0x66, 0x62, 0x34, 0x66, 0x30, 0x38, 0x30, 0x33, 0x62, 0x64, 0x61, 0x38, 0x38, 0x61, 0x36, 0x36, 0x39, 0x35, 0x37, 0x33, 0x37, 0x64, 0x36, 0x62, 0x35, 0x34, 0x31, 0x31, 0x38, 0x31, 0x37, 0x38, 0x63, 0x30, 0x38, 0x62, 0x66, 0x37, 0x62, 0x38, 0x30, 0x34, 0x31, 0x37, 0x32, 0x66, 0x35, 0x35, 0x38, 0x34, 0x31, 0x61, 0x33, 0x63, 0x35, 0x33, 0x32, 0x36, 0x37, 0x66, 0x30, 0x34, 0x65, 0x36, 0x34, 0x65, 0x33, 0x63, 0x36, 0x33, 0x61, 0x39, 0x61, 0x35, 0x35, 0x38, 0x31, 0x39, 0x32, 0x62, 0x34, 0x64, 0x63, 0x33, 0x62, 0x32, 0x33, 0x38, 0x39, 0x64, 0x31, 0x30, 0x33, 0x33, 0x37, 0x34, 0x64, 0x34, 0x31, 0x66, 0x30, 0x31, 0x39, 0x34, 0x31, 0x36, 0x38, 0x32, 0x66, 0x38, 0x38, 0x66, 0x62, 0x64, 0x38, 0x30, 0x33, 0x30, 0x32, 0x30, 0x33, 0x61, 0x37, 0x37, 0x38, 0x32, 0x38, 0x64, 0x31, 0x38, 0x38, 0x62, 0x65, 0x63, 0x36, 0x32, 0x32, 0x65, 0x65, 0x65, 0x38, 0x66, 0x36, 0x31, 0x65, 0x30, 0x63, 0x31, 0x63, 0x31, 0x30, 0x66, 0x38, 0x36, 0x32, 0x30, 0x31, 0x37, 0x39, 0x63, 0x61, 0x35, 0x35, 0x66, 0x38, 0x34, 0x63, 0x39, 0x34, 0x30, 0x36, 0x37, 0x32, 0x65, 0x30, 0x61, 0x34, 0x31, 0x65, 0x37, 0x62, 0x38, 0x62, 0x30, 0x66, 0x61, 0x31, 0x66, 0x36, 0x64, 0x33, 0x35, 0x64, 0x34, 0x30, 0x35, 0x62, 0x35, 0x63, 0x39, 0x32, 0x33, 0x64, 0x35, 0x37, 0x64, 0x37, 0x34, 0x37, 0x61, 0x39, 0x66, 0x34, 0x39, 0x34, 0x66, 0x64, 0x30, 0x36, 0x34, 0x34, 0x34, 0x37, 0x30, 0x61, 0x31, 0x62, 0x38, 0x66, 0x62, 0x64, 0x65, 0x31, 0x30, 0x32, 0x37, 0x32, 0x61, 0x61, 0x39, 0x66, 0x65, 0x61, 0x33, 0x61, 0x65, 0x33, 0x35, 0x62, 0x39, 0x65, 0x31, 0x38, 0x37, 0x65, 0x36, 0x36, 0x35, 0x33, 0x31, 0x36, 0x37, 0x33, 0x37, 0x61, 0x38, 0x35, 0x34, 0x61, 0x61, 0x35, 0x33, 0x37, 0x33, 0x35, 0x64, 0x35, 0x62, 0x31, 0x39, 0x66, 0x32, 0x32, 0x30, 0x30, 0x37, 0x36, 0x36, 0x33, 0x34, 0x62, 0x30, 0x33, 0x64, 0x37, 0x61, 0x35, 0x38, 0x62, 0x37, 0x32, 0x30, 0x31, 0x32, 0x32, 0x31, 0x35, 0x35, 0x36, 0x38, 0x63, 0x63, 0x36, 0x64, 0x64, 0x65, 0x63, 0x66, 0x35, 0x62, 0x39, 0x34, 0x63, 0x30, 0x30, 0x63, 0x37, 0x37, 0x38, 0x38, 0x66, 0x65, 0x61, 0x37, 0x35, 0x62, 0x31, 0x38, 0x65, 0x65, 0x32, 0x39, 0x62, 0x37, 0x66, 0x66, 0x34, 0x63, 0x35, 0x33, 0x38, 0x36, 0x33, 0x38, 0x61, 0x35, 0x38, 0x30, 0x33, 0x32, 0x37, 0x64, 0x63, 0x31, 0x62, 0x36, 0x63, 0x37, 0x62, 0x39, 0x36, 0x35, 0x66, 0x63, 0x34, 0x66, 0x33, 0x66, 0x30, 0x35, 0x33, 0x65, 0x35, 0x64, 0x65, 0x62, 0x38, 0x34, 0x33, 0x64, 0x36, 0x30, 0x33, 0x39, 0x33, 0x38, 0x63, 0x37, 0x33, 0x30, 0x36, 0x39, 0x63, 0x61, 0x36, 0x65, 0x36, 0x36, 0x34, 0x64, 0x30, 0x30, 0x61, 0x66, 0x65, 0x36, 0x32, 0x66, 0x33, 0x38, 0x32, 0x63, 0x38, 0x35, 0x31, 0x36, 0x66, 0x37, 0x32, 0x65, 0x34, 0x30, 0x32, 0x36, 0x66, 0x37, 0x31, 0x32, 0x66, 0x65, 0x34, 0x39, 0x30, 0x61, 0x64, 0x37, 0x64, 0x61, 0x62, 0x38, 0x32, 0x34, 0x39, 0x32, 0x30, 0x30, 0x38, 0x61, 0x36, 0x37, 0x36, 0x66, 0x34, 0x64, 0x30, 0x36, 0x35, 0x65, 0x65, 0x37, 0x36, 0x30, 0x34, 0x35, 0x39, 0x34, 0x66, 0x31, 0x64, 0x61, 0x31, 0x62, 0x66, 0x61, 0x66, 0x63, 0x32, 0x62, 0x36, 0x30, 0x30, 0x32, 0x33, 0x66, 0x61, 0x31, 0x64, 0x62, 0x32, 0x37, 0x63, 0x36, 0x36, 0x31, 0x35, 0x37, 0x36, 0x65, 0x33, 0x32, 0x30, 0x64, 0x64, 0x65, 0x32, 0x34, 0x61, 0x32, 0x66, 0x36, 0x64, 0x31, 0x33, 0x64, 0x34, 0x35, 0x39, 0x30, 0x63, 0x33, 0x65, 0x35, 0x33, 0x37, 0x38, 0x34, 0x36, 0x36, 0x33, 0x64, 0x37, 0x35, 0x30, 0x37, 0x64, 0x63, 0x32, 0x39, 0x32, 0x30, 0x35, 0x31, 0x33, 0x35, 0x38, 0x35, 0x64, 0x62, 0x64, 0x39, 0x32, 0x37, 0x37, 0x37, 0x33, 0x34, 0x30, 0x36, 0x37, 0x33, 0x34, 0x34, 0x34, 0x65, 0x32, 0x66, 0x65, 0x66, 0x36, 0x64, 0x35, 0x61, 0x32, 0x62, 0x64, 0x62, 0x63, 0x32, 0x66, 0x38, 0x30, 0x30, 0x35, 0x35, 0x35, 0x37, 0x65, 0x63, 0x30, 0x35, 0x65, 0x38, 0x34, 0x33, 0x38, 0x35, 0x31, 0x66, 0x38, 0x34, 0x39, 0x62, 0x32, 0x35, 0x33, 0x63, 0x66, 0x63, 0x32, 0x33, 0x66, 0x66, 0x34, 0x61, 0x32, 0x33, 0x65, 0x61, 0x65, 0x63, 0x38, 0x36, 0x64, 0x34, 0x33, 0x38, 0x66, 0x31, 0x35, 0x64, 0x34, 0x66, 0x62, 0x38, 0x34, 0x63, 0x66, 0x37, 0x35, 0x39, 0x36, 0x32, 0x39, 0x34, 0x62, 0x35, 0x37, 0x65, 0x39, 0x65, 0x61, 0x36, 0x33, 0x38, 0x36, 0x64, 0x30, 0x63, 0x66, 0x38, 0x39, 0x66, 0x32, 0x65, 0x65, 0x39, 0x36, 0x65, 0x37, 0x39, 0x62, 0x39, 0x34, 0x37, 0x32, 0x36, 0x35, 0x36, 0x37, 0x66, 0x31, 0x36, 0x31, 0x39, 0x39, 0x63, 0x36, 0x36, 0x35, 0x39, 0x33, 0x31, 0x31, 0x30, 0x35, 0x38, 0x62, 0x62, 0x37, 0x36, 0x30, 0x65, 0x64, 0x64, 0x62, 0x61, 0x66, 0x38, 0x34, 0x64, 0x34, 0x32, 0x62, 0x66, 0x34, 0x35, 0x38, 0x64, 0x37, 0x66, 0x39, 0x61, 0x32, 0x61, 0x66, 0x38, 0x31, 0x62, 0x32, 0x62, 0x30, 0x38, 0x35, 0x66, 0x39, 0x66, 0x62, 0x37, 0x32, 0x34, 0x35, 0x66, 0x37, 0x38, 0x63, 0x65, 0x62, 0x33, 0x65, 0x33, 0x32, 0x64, 0x37, 0x62, 0x30, 0x34, 0x36, 0x39, 0x34, 0x38, 0x39, 0x31, 0x36, 0x63, 0x38, 0x34, 0x64, 0x65, 0x38, 0x62, 0x63, 0x31, 0x62, 0x61, 0x62, 0x32, 0x62, 0x39, 0x36, 0x65, 0x37, 0x64, 0x33, 0x66, 0x62, 0x65, 0x62, 0x31, 0x31, 0x61, 0x66, 0x30, 0x35, 0x64, 0x30, 0x37, 0x65, 0x63, 0x38, 0x39, 0x63, 0x37, 0x32, 0x33, 0x33, 0x64, 0x61, 0x63, 0x31, 0x33, 0x66, 0x61, 0x32, 0x30, 0x63, 0x36, 0x32, 0x66, 0x62, 0x65, 0x39, 0x30, 0x33, 0x31, 0x61, 0x35, 0x31, 0x66, 0x34, 0x35, 0x63, 0x62, 0x31, 0x63, 0x38, 0x35, 0x37, 0x34, 0x37, 0x64, 0x38, 0x38, 0x64, 0x37, 0x65, 0x63, 0x64, 0x37, 0x32, 0x38, 0x34, 0x32, 0x35, 0x37, 0x34, 0x36, 0x36, 0x32, 0x36, 0x38, 0x38, 0x36, 0x33, 0x63, 0x38, 0x31, 0x30, 0x36, 0x35, 0x35, 0x33, 0x34, 0x38, 0x30, 0x61, 0x64, 0x63, 0x31, 0x39, 0x31, 0x39, 0x61, 0x38, 0x39, 0x35, 0x30, 0x62, 0x39, 0x32, 0x35, 0x30, 0x36, 0x66, 0x62, 0x63, 0x64, 0x33, 0x62, 0x62, 0x38, 0x32, 0x32, 0x30, 0x32, 0x64, 0x63, 0x33, 0x61, 0x39, 0x31, 0x61, 0x38, 0x63, 0x37, 0x34, 0x63, 0x64, 0x37, 0x30, 0x64, 0x37, 0x38, 0x63, 0x64, 0x33, 0x33, 0x38, 0x66, 0x31, 0x34, 0x61, 0x34, 0x64, 0x36, 0x30, 0x38, 0x34, 0x61, 0x33, 0x35, 0x34, 0x36, 0x32, 0x34, 0x64, 0x33, 0x38, 0x32, 0x36, 0x31, 0x38, 0x65, 0x61, 0x33, 0x34, 0x37, 0x64, 0x38, 0x31, 0x64, 0x36, 0x65, 0x64, 0x63, 0x34, 0x61, 0x31, 0x32, 0x66, 0x36, 0x35, 0x63, 0x37, 0x64, 0x30, 0x34, 0x39, 0x63, 0x32, 0x36, 0x61, 0x31, 0x61, 0x65, 0x36, 0x33, 0x62, 0x36, 0x32, 0x62, 0x30, 0x63, 0x66, 0x32, 0x66, 0x37, 0x64, 0x66, 0x63, 0x32, 0x61, 0x30, 0x31, 0x36, 0x65, 0x36, 0x34, 0x66, 0x61, 0x31, 0x65, 0x33, 0x34, 0x61, 0x36, 0x36, 0x37, 0x33, 0x38, 0x37, 0x37, 0x63, 0x35, 0x37, 0x38, 0x36, 0x39, 0x37, 0x65, 0x32, 0x38, 0x61, 0x35, 0x37, 0x34, 0x30, 0x37, 0x36, 0x66, 0x31, 0x33, 0x66, 0x35, 0x61, 0x35, 0x37, 0x37, 0x32, 0x65, 0x37, 0x34, 0x64, 0x64, 0x64, 0x64, 0x65, 0x32, 0x36, 0x33, 0x66, 0x33, 0x39, 0x35, 0x38, 0x39, 0x65, 0x37, 0x62, 0x64, 0x65, 0x63, 0x31, 0x35, 0x36, 0x66, 0x39, 0x31, 0x35, 0x31, 0x62, 0x30, 0x39, 0x65, 0x66, 0x31, 0x63, 0x34, 0x31, 0x33, 0x63, 0x31, 0x64, 0x34, 0x39, 0x62, 0x35, 0x30, 0x64, 0x31, 0x64, 0x34, 0x63, 0x62, 0x63, 0x32, 0x62, 0x30, 0x61, 0x39, 0x32, 0x63, 0x35, 0x61, 0x64, 0x66, 0x33, 0x39, 0x32, 0x66, 0x61, 0x65, 0x37, 0x32, 0x33, 0x64, 0x37, 0x64, 0x38, 0x34, 0x65, 0x37, 0x64, 0x63, 0x34, 0x34, 0x30, 0x36, 0x30, 0x36, 0x31, 0x65, 0x32, 0x66, 0x64, 0x39, 0x62, 0x65, 0x30, 0x34, 0x33, 0x66, 0x37, 0x61, 0x65, 0x62, 0x37, 0x33, 0x33, 0x62, 0x63, 0x61, 0x34, 0x39, 0x61, 0x62, 0x35, 0x34, 0x32, 0x30, 0x61, 0x39, 0x38, 0x34, 0x30, 0x34, 0x62, 0x35, 0x34, 0x37, 0x66, 0x61, 0x36, 0x36, 0x37, 0x36, 0x34, 0x61, 0x34, 0x34, 0x38, 0x31, 0x63, 0x66, 0x63, 0x36, 0x63, 0x30, 0x30, 0x33, 0x31, 0x39, 0x31, 0x63, 0x35, 0x38, 0x32, 0x38, 0x61, 0x61, 0x65, 0x32, 0x36, 0x36, 0x61, 0x64, 0x33, 0x34, 0x36, 0x38, 0x31, 0x63, 0x66, 0x34, 0x39, 0x31, 0x66, 0x65, 0x63, 0x64, 0x37, 0x63, 0x37, 0x38, 0x64, 0x33, 0x30, 0x39, 0x65, 0x63, 0x37, 0x35, 0x37, 0x62, 0x39, 0x32, 0x30, 0x36, 0x65, 0x63, 0x37, 0x32, 0x31, 0x31, 0x37, 0x39, 0x34, 0x31, 0x36, 0x35, 0x36, 0x36, 0x65, 0x61, 0x65, 0x62, 0x33, 0x66, 0x31, 0x61, 0x37, 0x30, 0x64, 0x30, 0x34, 0x36, 0x32, 0x66, 0x35, 0x64, 0x34, 0x35, 0x63, 0x31, 0x30, 0x62, 0x32, 0x36, 0x33, 0x66, 0x65, 0x62, 0x33, 0x61, 0x37, 0x36, 0x39, 0x32, 0x64, 0x61, 0x36, 0x63, 0x64, 0x33, 0x64, 0x37, 0x37, 0x37, 0x37, 0x34, 0x34, 0x63, 0x65, 0x31, 0x33, 0x61, 0x65, 0x30, 0x62, 0x30, 0x62, 0x32, 0x31, 0x64, 0x66, 0x66, 0x34, 0x38, 0x63, 0x33, 0x65, 0x33, 0x33, 0x30, 0x31, 0x62, 0x63, 0x66, 0x61, 0x39, 0x30, 0x36, 0x36, 0x36, 0x61, 0x66, 0x31, 0x65, 0x62, 0x36, 0x62, 0x32, 0x63, 0x65, 0x35, 0x35, 0x38, 0x65, 0x61, 0x61, 0x36, 0x39, 0x39, 0x33, 0x30, 0x61, 0x39, 0x36, 0x33, 0x64, 0x66, 0x61, 0x30, 0x37, 0x64, 0x62, 0x34, 0x38, 0x34, 0x30, 0x31, 0x35, 0x39, 0x35, 0x34, 0x65, 0x33, 0x35, 0x33, 0x38, 0x32, 0x61, 0x66, 0x34, 0x39, 0x61, 0x32, 0x66, 0x63, 0x31, 0x35, 0x61, 0x36, 0x61, 0x38, 0x34, 0x31, 0x63, 0x33, 0x30, 0x36, 0x63, 0x66, 0x36, 0x34, 0x65, 0x38, 0x33, 0x37, 0x63, 0x32, 0x38, 0x32, 0x63, 0x36, 0x62, 0x36, 0x39, 0x39, 0x63, 0x63, 0x63, 0x66, 0x38, 0x37, 0x35, 0x31, 0x65, 0x35, 0x38, 0x66, 0x65, 0x32, 0x61, 0x31, 0x32, 0x62, 0x66, 0x38, 0x64, 0x38, 0x63, 0x64, 0x35, 0x33, 0x32, 0x61, 0x31, 0x36, 0x64, 0x61, 0x36, 0x38, 0x36, 0x64, 0x34, 0x62, 0x61, 0x63, 0x30, 0x63, 0x36, 0x65, 0x64, 0x31, 0x63, 0x32, 0x64, 0x34, 0x66, 0x37, 0x62, 0x37, 0x66, 0x30, 0x39, 0x30, 0x35, 0x35, 0x63, 0x31, 0x64, 0x30, 0x32, 0x31, 0x39, 0x36, 0x66, 0x63, 0x38, 0x61, 0x34, 0x35, 0x62, 0x35, 0x63, 0x37, 0x32, 0x32, 0x31, 0x31, 0x63, 0x34, 0x37, 0x30, 0x66, 0x64, 0x34, 0x61, 0x38, 0x32, 0x36, 0x64, 0x63, 0x66, 0x35, 0x39, 0x35, 0x65, 0x61, 0x66, 0x34, 0x66, 0x64, 0x62, 0x32, 0x61, 0x62, 0x65, 0x35, 0x34, 0x38, 0x64, 0x36, 0x34, 0x66, 0x32, 0x34, 0x63, 0x39, 0x66, 0x38, 0x36, 0x64, 0x30, 0x30, 0x31, 0x38, 0x66, 0x64, 0x32, 0x64, 0x34, 0x31, 0x64, 0x64, 0x63, 0x62, 0x62, 0x30, 0x35, 0x30, 0x31, 0x63, 0x65, 0x38, 0x64, 0x31, 0x37, 0x38, 0x31, 0x35, 0x66, 0x63, 0x39, 0x39, 0x65, 0x64, 0x32, 0x39, 0x61, 0x64, 0x63, 0x36, 0x39, 0x38, 0x33, 0x65, 0x61, 0x35, 0x66, 0x32, 0x39, 0x61, 0x39, 0x39, 0x34, 0x39, 0x32, 0x64, 0x32, 0x63, 0x63, 0x33, 0x66, 0x34, 0x32, 0x31, 0x65, 0x62, 0x34, 0x62, 0x36, 0x39, 0x39, 0x39, 0x39, 0x34, 0x38, 0x34, 0x64, 0x35, 0x31, 0x66, 0x35, 0x37, 0x61, 0x31, 0x63, 0x34, 0x34, 0x32, 0x66, 0x65, 0x32, 0x66, 0x31, 0x63, 0x36, 0x62, 0x32, 0x61, 0x64, 0x38, 0x32, 0x30, 0x39, 0x38, 0x64, 0x38, 0x37, 0x34, 0x39, 0x35, 0x61, 0x62, 0x65, 0x33, 0x38, 0x38, 0x65, 0x39, 0x65, 0x35, 0x38, 0x66, 0x62, 0x35, 0x37, 0x64, 0x37, 0x66, 0x37, 0x37, 0x38, 0x65, 0x61, 0x38, 0x36, 0x31, 0x30, 0x63, 0x34, 0x39, 0x34, 0x36, 0x66, 0x64, 0x35, 0x38, 0x37, 0x66, 0x63, 0x36, 0x61, 0x36, 0x36, 0x61, 0x64, 0x62, 0x38, 0x37, 0x36, 0x34, 0x64, 0x66, 0x65, 0x39, 0x61, 0x34, 0x39, 0x37, 0x62, 0x35, 0x65, 0x33, 0x34, 0x64, 0x36, 0x62, 0x63, 0x33, 0x32, 0x64, 0x61, 0x38, 0x66, 0x39, 0x36, 0x38, 0x30, 0x30, 0x64, 0x37, 0x35, 0x62, 0x33, 0x66, 0x63, 0x61, 0x38, 0x37, 0x63, 0x37, 0x36, 0x32, 0x34, 0x62, 0x64, 0x35, 0x64, 0x30, 0x37, 0x32, 0x63, 0x33, 0x63, 0x66, 0x64, 0x34, 0x64, 0x62, 0x66, 0x35, 0x65, 0x62, 0x64, 0x38, 0x37, 0x35, 0x64, 0x62, 0x63, 0x35, 0x38, 0x31, 0x36, 0x38, 0x63, 0x35, 0x61, 0x30, 0x38, 0x30, 0x31, 0x66, 0x61, 0x30, 0x36, 0x39, 0x31, 0x62, 0x39, 0x32, 0x35, 0x61, 0x66, 0x36, 0x62, 0x33, 0x30, 0x34, 0x37, 0x35, 0x64, 0x36, 0x34, 0x61, 0x32, 0x39, 0x62, 0x38, 0x66, 0x62, 0x65, 0x64, 0x37, 0x32, 0x61, 0x62, 0x65, 0x64, 0x31, 0x38, 0x31, 0x30, 0x36, 0x66, 0x38, 0x65, 0x64, 0x38, 0x32, 0x64, 0x30, 0x38, 0x66, 0x33, 0x63, 0x30, 0x39, 0x30, 0x63, 0x30, 0x35, 0x63, 0x36, 0x62, 0x34, 0x39, 0x32, 0x65, 0x32, 0x38, 0x63, 0x32, 0x61, 0x37, 0x36, 0x34, 0x31, 0x65, 0x36, 0x61, 0x32, 0x64, 0x33, 0x39, 0x39, 0x37, 0x64, 0x66, 0x34, 0x65, 0x65, 0x37, 0x65, 0x64, 0x34, 0x31, 0x33, 0x35, 0x66, 0x62, 0x33, 0x37, 0x36, 0x39, 0x33, 0x34, 0x63, 0x33, 0x33, 0x62, 0x35, 0x62, 0x33, 0x30, 0x39, 0x31, 0x36, 0x63, 0x38, 0x66, 0x64, 0x37, 0x38, 0x35, 0x64, 0x33, 0x62, 0x39, 0x63, 0x63, 0x64, 0x37, 0x61, 0x34, 0x65, 0x35, 0x35, 0x32, 0x33, 0x38, 0x34, 0x33, 0x62, 0x37, 0x32, 0x61, 0x63, 0x61, 0x61, 0x62, 0x35, 0x65, 0x63, 0x61, 0x37, 0x30, 0x61, 0x62, 0x62, 0x35, 0x37, 0x32, 0x31, 0x63, 0x34, 0x31, 0x65, 0x65, 0x66, 0x36, 0x38, 0x65, 0x35, 0x38, 0x62, 0x66, 0x36, 0x62, 0x36, 0x39, 0x62, 0x31, 0x64, 0x32, 0x37, 0x35, 0x61, 0x36, 0x34, 0x34, 0x32, 0x34, 0x39, 0x34, 0x64, 0x39, 0x38, 0x62, 0x39, 0x63, 0x64, 0x31, 0x39, 0x35, 0x66, 0x31, 0x62, 0x62, 0x63, 0x32, 0x65, 0x62, 0x61, 0x37, 0x30, 0x64, 0x65, 0x61, 0x30, 0x35, 0x61, 0x37, 0x65, 0x35, 0x30, 0x37, 0x34, 0x35, 0x38, 0x36, 0x31, 0x61, 0x66, 0x33, 0x32, 0x32, 0x33, 0x66, 0x32, 0x32, 0x30, 0x39, 0x31, 0x65, 0x33, 0x31, 0x64, 0x30, 0x32, 0x37, 0x34, 0x34, 0x37, 0x64, 0x32, 0x65, 0x64, 0x32, 0x34, 0x32, 0x32, 0x61, 0x33, 0x30, 0x64, 0x63, 0x62, 0x37, 0x31, 0x61, 0x38, 0x36, 0x34, 0x63, 0x66, 0x61, 0x31, 0x36, 0x31, 0x37, 0x30, 0x37, 0x62, 0x30, 0x39, 0x31, 0x64, 0x37, 0x37, 0x32, 0x31, 0x36, 0x37, 0x34, 0x35, 0x32, 0x63, 0x38, 0x66, 0x37, 0x36, 0x31, 0x38, 0x39, 0x39, 0x32, 0x35, 0x62, 0x65, 0x62, 0x32, 0x32, 0x66, 0x30, 0x66, 0x37, 0x64, 0x62, 0x38, 0x37, 0x32, 0x38, 0x61, 0x34, 0x35, 0x36, 0x63, 0x34, 0x33, 0x31, 0x39, 0x63, 0x31, 0x66, 0x30, 0x65, 0x31, 0x66, 0x37, 0x66, 0x63, 0x35, 0x31, 0x34, 0x37, 0x34, 0x66, 0x33, 0x66, 0x38, 0x64, 0x38, 0x30, 0x37, 0x33, 0x33, 0x39, 0x35, 0x37, 0x32, 0x64, 0x30, 0x66, 0x35, 0x33, 0x34, 0x37, 0x37, 0x66, 0x35, 0x61, 0x62, 0x33, 0x33, 0x33, 0x37, 0x30, 0x31, 0x38, 0x30, 0x30, 0x61, 0x35, 0x36, 0x31, 0x63, 0x32, 0x61, 0x39, 0x65, 0x31, 0x65, 0x66, 0x34, 0x36, 0x30, 0x36, 0x38, 0x66, 0x63, 0x61, 0x30, 0x63, 0x35, 0x64, 0x34, 0x30, 0x30, 0x31, 0x30, 0x62, 0x66, 0x63, 0x39, 0x64, 0x30, 0x37, 0x32, 0x39, 0x66, 0x31, 0x39, 0x32, 0x35, 0x35, 0x34, 0x66, 0x39, 0x65, 0x37, 0x62, 0x61, 0x31, 0x61, 0x30, 0x37, 0x64, 0x30, 0x35, 0x62, 0x34, 0x39, 0x38, 0x62, 0x37, 0x64, 0x62, 0x65, 0x66, 0x36, 0x34, 0x35, 0x33, 0x63, 0x36, 0x63, 0x65, 0x37, 0x65, 0x65, 0x66, 0x61, 0x63, 0x61, 0x38, 0x36, 0x63, 0x63, 0x30, 0x63, 0x65, 0x30, 0x61, 0x38, 0x61, 0x31, 0x31, 0x65, 0x62, 0x35, 0x34, 0x30, 0x38, 0x61, 0x61, 0x34, 0x65, 0x61, 0x30, 0x38, 0x38, 0x30, 0x34, 0x65, 0x62, 0x36, 0x38, 0x66, 0x61, 0x37, 0x36, 0x30, 0x36, 0x31, 0x35, 0x66, 0x65, 0x66, 0x64, 0x66, 0x37, 0x31, 0x38, 0x37, 0x35, 0x30, 0x62, 0x65, 0x65, 0x62, 0x36, 0x38, 0x61, 0x32, 0x35, 0x33, 0x35, 0x31, 0x37, 0x35, 0x66, 0x37, 0x32, 0x30, 0x63, 0x66, 0x64, 0x34, 0x36, 0x66, 0x35, 0x35, 0x34, 0x39, 0x32, 0x32, 0x31, 0x39, 0x35, 0x65, 0x33, 0x63, 0x34, 0x33, 0x35, 0x35, 0x32, 0x39, 0x61, 0x61, 0x38, 0x62, 0x39, 0x37, 0x30, 0x34, 0x37, 0x38, 0x65, 0x36, 0x33, 0x35, 0x63, 0x62, 0x33, 0x65, 0x38, 0x37, 0x35, 0x31, 0x66, 0x62, 0x30, 0x33, 0x37, 0x66, 0x30, 0x33, 0x39, 0x64, 0x63, 0x32, 0x35, 0x33, 0x61, 0x35, 0x62, 0x37, 0x66, 0x64, 0x32, 0x62, 0x32, 0x33, 0x38, 0x39, 0x63, 0x31, 0x35, 0x61, 0x35, 0x38, 0x38, 0x63, 0x32, 0x62, 0x61, 0x36, 0x30, 0x35, 0x30, 0x34, 0x38, 0x34, 0x30, 0x64, 0x36, 0x36, 0x38, 0x31, 0x61, 0x39, 0x32, 0x35, 0x62, 0x38, 0x37, 0x35, 0x34, 0x63, 0x33, 0x35, 0x66, 0x62, 0x62, 0x37, 0x62, 0x30, 0x36, 0x38, 0x32, 0x34, 0x61, 0x63, 0x66, 0x36, 0x61, 0x64, 0x38, 0x64, 0x30, 0x32, 0x66, 0x63, 0x65, 0x31, 0x37, 0x61, 0x34, 0x32, 0x34, 0x61, 0x37, 0x32, 0x64, 0x38, 0x31, 0x62, 0x35, 0x30, 0x61, 0x33, 0x62, 0x37, 0x30, 0x65, 0x36, 0x37, 0x65, 0x30, 0x63, 0x63, 0x31, 0x63, 0x30, 0x34, 0x31, 0x30, 0x62, 0x38, 0x30, 0x33, 0x66, 0x36, 0x35, 0x35, 0x64, 0x62, 0x62, 0x33, 0x63, 0x34, 0x64, 0x65, 0x37, 0x65, 0x63, 0x39, 0x36, 0x62, 0x66, 0x35, 0x37, 0x62, 0x63, 0x33, 0x35, 0x35, 0x31, 0x63, 0x65, 0x63, 0x61, 0x39, 0x30, 0x30, 0x32, 0x32, 0x32, 0x65, 0x35, 0x63, 0x34, 0x32, 0x65, 0x66, 0x35, 0x62, 0x37, 0x33, 0x33, 0x35, 0x38, 0x34, 0x30, 0x30, 0x62, 0x66, 0x31, 0x66, 0x35, 0x33, 0x36, 0x37, 0x31, 0x32, 0x66, 0x30, 0x36, 0x33, 0x61, 0x31, 0x38, 0x39, 0x34, 0x31, 0x31, 0x32, 0x39, 0x38, 0x30, 0x34, 0x35, 0x36, 0x61, 0x62, 0x33, 0x63, 0x31, 0x63, 0x65, 0x39, 0x62, 0x62, 0x37, 0x35, 0x34, 0x61, 0x62, 0x61, 0x37, 0x32, 0x63, 0x62, 0x64, 0x34, 0x35, 0x32, 0x32, 0x63, 0x34, 0x36, 0x35, 0x30, 0x37, 0x32, 0x38, 0x31, 0x34, 0x34, 0x38, 0x65, 0x65, 0x38, 0x62, 0x37, 0x37, 0x30, 0x32, 0x63, 0x66, 0x32, 0x61, 0x37, 0x38, 0x31, 0x32, 0x32, 0x65, 0x32, 0x36, 0x63, 0x61, 0x34, 0x63, 0x30, 0x31, 0x33, 0x65, 0x66, 0x66, 0x61, 0x66, 0x36, 0x66, 0x32, 0x32, 0x35, 0x33, 0x37, 0x34, 0x38, 0x64, 0x37, 0x32, 0x66, 0x37, 0x30, 0x65, 0x61, 0x63, 0x66, 0x39, 0x63, 0x35, 0x30, 0x37, 0x36, 0x66, 0x39, 0x65, 0x34, 0x65, 0x31, 0x63, 0x36, 0x38, 0x37, 0x62, 0x38, 0x35, 0x33, 0x65, 0x36, 0x61, 0x39, 0x33, 0x61, 0x61, 0x33, 0x36, 0x31, 0x62, 0x32, 0x63, 0x65, 0x62, 0x34, 0x39, 0x32, 0x39, 0x38, 0x30, 0x35, 0x30, 0x64, 0x65, 0x34, 0x32, 0x37, 0x61, 0x66, 0x38, 0x66, 0x34, 0x32, 0x35, 0x37, 0x37, 0x32, 0x61, 0x61, 0x36, 0x39, 0x35, 0x37, 0x64, 0x30, 0x39, 0x64, 0x63, 0x36, 0x64, 0x36, 0x63, 0x34, 0x36, 0x31, 0x35, 0x34, 0x62, 0x30, 0x66, 0x65, 0x33, 0x35, 0x31, 0x65, 0x33, 0x64, 0x61, 0x61, 0x34, 0x31, 0x30, 0x34, 0x34, 0x36, 0x30, 0x64, 0x34, 0x31, 0x39, 0x39, 0x31, 0x66, 0x63, 0x35, 0x66, 0x64, 0x38, 0x37, 0x64, 0x66, 0x32, 0x34, 0x35, 0x36, 0x64, 0x36, 0x65, 0x38, 0x37, 0x32, 0x39, 0x36, 0x64, 0x61, 0x36, 0x32, 0x30, 0x38, 0x36, 0x62, 0x65, 0x34, 0x66, 0x37, 0x33, 0x39, 0x37, 0x31, 0x35, 0x63, 0x63, 0x64, 0x34, 0x35, 0x61, 0x32, 0x30, 0x35, 0x36, 0x30, 0x35, 0x33, 0x65, 0x66, 0x32, 0x38, 0x38, 0x31, 0x63, 0x34, 0x63, 0x35, 0x33, 0x34, 0x34, 0x66, 0x32, 0x63, 0x30, 0x35, 0x63, 0x34, 0x62, 0x38, 0x63, 0x38, 0x36, 0x64, 0x66, 0x32, 0x65, 0x30, 0x37, 0x32, 0x66, 0x62, 0x33, 0x38, 0x35, 0x65, 0x61, 0x36, 0x62, 0x37, 0x66, 0x36, 0x61, 0x32, 0x64, 0x65, 0x36, 0x35, 0x63, 0x66, 0x38, 0x61, 0x33, 0x33, 0x64, 0x37, 0x37, 0x37, 0x39, 0x62, 0x38, 0x30, 0x66, 0x62, 0x64, 0x61, 0x38, 0x62, 0x39, 0x32, 0x65, 0x38, 0x33, 0x37, 0x34, 0x65, 0x61, 0x35, 0x37, 0x37, 0x35, 0x38, 0x32, 0x39, 0x61, 0x36, 0x35, 0x64, 0x30, 0x63, 0x30, 0x61, 0x37, 0x32, 0x35, 0x35, 0x37, 0x31, 0x62, 0x36, 0x32, 0x37, 0x32, 0x63, 0x61, 0x35, 0x66, 0x32, 0x31, 0x35, 0x63, 0x38, 0x33, 0x65, 0x34, 0x37, 0x65, 0x65, 0x63, 0x36, 0x36, 0x31, 0x32, 0x39, 0x61, 0x33, 0x62, 0x37, 0x61, 0x64, 0x36, 0x37, 0x65, 0x66, 0x31, 0x35, 0x65, 0x30, 0x61, 0x33, 0x30, 0x61, 0x38, 0x62, 0x39, 0x37, 0x62, 0x61, 0x62, 0x33, 0x63, 0x61, 0x61, 0x35, 0x63, 0x38, 0x30, 0x31, 0x37, 0x33, 0x32, 0x65, 0x63, 0x33, 0x32, 0x66, 0x62, 0x66, 0x31, 0x62, 0x37, 0x32, 0x61, 0x65, 0x62, 0x34, 0x61, 0x34, 0x64, 0x31, 0x65, 0x63, 0x38, 0x65, 0x64, 0x63, 0x34, 0x33, 0x63, 0x61, 0x30, 0x31, 0x34, 0x66, 0x65, 0x38, 0x65, 0x65, 0x35, 0x65, 0x30, 0x33, 0x37, 0x37, 0x64, 0x33, 0x36, 0x36, 0x66, 0x37, 0x65, 0x31, 0x30, 0x32, 0x34, 0x39, 0x32, 0x32, 0x39, 0x61, 0x35, 0x64, 0x38, 0x33, 0x30, 0x35, 0x33, 0x61, 0x34, 0x64, 0x36, 0x30, 0x38, 0x33, 0x34, 0x65, 0x31, 0x35, 0x62, 0x61, 0x38, 0x37, 0x62, 0x62, 0x37, 0x65, 0x65, 0x32, 0x36, 0x64, 0x36, 0x34, 0x39, 0x65, 0x38, 0x36, 0x37, 0x39, 0x62, 0x30, 0x30, 0x61, 0x31, 0x33, 0x38, 0x37, 0x30, 0x34, 0x63, 0x32, 0x38, 0x34, 0x34, 0x32, 0x30, 0x32, 0x33, 0x65, 0x31, 0x31, 0x34, 0x38, 0x62, 0x66, 0x37, 0x32, 0x64, 0x38, 0x63, 0x35, 0x32, 0x64, 0x65, 0x34, 0x32, 0x66, 0x33, 0x32, 0x30, 0x62, 0x33, 0x34, 0x31, 0x63, 0x33, 0x37, 0x37, 0x61, 0x31, 0x33, 0x39, 0x66, 0x37, 0x62, 0x31, 0x63, 0x32, 0x36, 0x62, 0x62, 0x39, 0x32, 0x32, 0x33, 0x36, 0x61, 0x64, 0x61, 0x32, 0x65, 0x65, 0x65, 0x62, 0x36, 0x31, 0x32, 0x65, 0x35, 0x64, 0x66, 0x30, 0x64, 0x35, 0x36, 0x31, 0x38, 0x34, 0x33, 0x34, 0x30, 0x32, 0x37, 0x38, 0x33, 0x35, 0x66, 0x33, 0x36, 0x34, 0x61, 0x64, 0x33, 0x39, 0x33, 0x31, 0x66, 0x36, 0x39, 0x39, 0x61, 0x34, 0x38, 0x35, 0x31, 0x65, 0x36, 0x65, 0x31, 0x39, 0x33, 0x36, 0x62, 0x34, 0x65, 0x31, 0x65, 0x35, 0x65, 0x35, 0x66, 0x32, 0x37, 0x65, 0x30, 0x63, 0x30, 0x30, 0x64, 0x30, 0x36, 0x64, 0x39, 0x32, 0x65, 0x64, 0x34, 0x34, 0x30, 0x63, 0x39, 0x63, 0x36, 0x31, 0x30, 0x38, 0x65, 0x65, 0x37, 0x39, 0x31, 0x30, 0x33, 0x34, 0x35, 0x66, 0x39, 0x37, 0x65, 0x31, 0x62, 0x35, 0x63, 0x63, 0x36, 0x33, 0x36, 0x34, 0x38, 0x62, 0x33, 0x34, 0x31, 0x36, 0x36, 0x36, 0x34, 0x62, 0x62, 0x37, 0x65, 0x30, 0x61, 0x36, 0x39, 0x32, 0x30, 0x64, 0x33, 0x30, 0x63, 0x35, 0x35, 0x65, 0x64, 0x35, 0x35, 0x35, 0x63, 0x65, 0x32, 0x33, 0x39, 0x62, 0x65, 0x61, 0x65, 0x34, 0x31, 0x66, 0x37, 0x36, 0x66, 0x63, 0x32, 0x31, 0x66, 0x36, 0x30, 0x39, 0x64, 0x37, 0x38, 0x35, 0x38, 0x33, 0x62, 0x31, 0x33, 0x31, 0x37, 0x38, 0x38, 0x65, 0x64, 0x63, 0x36, 0x61, 0x34, 0x65, 0x61, 0x34, 0x35, 0x62, 0x31, 0x62, 0x38, 0x30, 0x34, 0x39, 0x64, 0x64, 0x37, 0x32, 0x36, 0x31, 0x34, 0x62, 0x37, 0x63, 0x36, 0x63, 0x31, 0x37, 0x62, 0x34, 0x64, 0x33, 0x35, 0x37, 0x39, 0x37, 0x32, 0x62, 0x35, 0x32, 0x66, 0x32, 0x63, 0x61, 0x31, 0x33, 0x65, 0x32, 0x36, 0x32, 0x61, 0x66, 0x31, 0x61, 0x64, 0x36, 0x66, 0x38, 0x62, 0x65, 0x61, 0x33, 0x33, 0x37, 0x65, 0x37, 0x64, 0x34, 0x61, 0x32, 0x33, 0x64, 0x33, 0x30, 0x61, 0x30, 0x34, 0x64, 0x33, 0x65, 0x36, 0x66, 0x63, 0x34, 0x31, 0x37, 0x36, 0x62, 0x64, 0x39, 0x64, 0x33, 0x61, 0x64, 0x66, 0x66, 0x32, 0x61, 0x61, 0x33, 0x31, 0x32, 0x39, 0x33, 0x38, 0x32, 0x39, 0x38, 0x62, 0x61, 0x61, 0x62, 0x61, 0x34, 0x31, 0x37, 0x30, 0x36, 0x66, 0x62, 0x36, 0x65, 0x61, 0x31, 0x66, 0x64, 0x32, 0x61, 0x66, 0x64, 0x37, 0x36, 0x64, 0x39, 0x32, 0x64, 0x31, 0x39, 0x38, 0x35, 0x38, 0x30, 0x61, 0x61, 0x38, 0x61, 0x63, 0x63, 0x65, 0x34, 0x62, 0x34, 0x30, 0x39, 0x62, 0x39, 0x65, 0x65, 0x35, 0x66, 0x62, 0x66, 0x30, 0x37, 0x32, 0x31, 0x34, 0x61, 0x62, 0x65, 0x33, 0x34, 0x31, 0x39, 0x35, 0x64, 0x33, 0x33, 0x35, 0x63, 0x31, 0x36, 0x61, 0x65, 0x33, 0x65, 0x31, 0x63, 0x36, 0x64, 0x34, 0x32, 0x38, 0x66, 0x34, 0x35, 0x31, 0x66, 0x65, 0x34, 0x32, 0x65, 0x32, 0x62, 0x65, 0x63, 0x66, 0x31, 0x31, 0x31, 0x65, 0x30, 0x35, 0x31, 0x31, 0x35, 0x63, 0x32, 0x35, 0x63, 0x34, 0x65, 0x34, 0x62, 0x33, 0x64, 0x39, 0x37, 0x32, 0x38, 0x64, 0x65, 0x36, 0x62, 0x35, 0x63, 0x34, 0x66, 0x62, 0x38, 0x30, 0x63, 0x66, 0x64, 0x61, 0x66, 0x66, 0x32, 0x33, 0x66, 0x36, 0x61, 0x30, 0x37, 0x63, 0x35, 0x30, 0x30, 0x34, 0x30, 0x62, 0x34, 0x34, 0x33, 0x65, 0x64, 0x62, 0x35, 0x65, 0x30, 0x64, 0x38, 0x61, 0x36, 0x64, 0x64, 0x39, 0x35, 0x62, 0x61, 0x65, 0x30, 0x32, 0x61, 0x36, 0x65, 0x31, 0x35, 0x66, 0x36, 0x33, 0x35, 0x65, 0x35, 0x34, 0x39, 0x65, 0x38, 0x61, 0x38, 0x38, 0x31, 0x32, 0x66, 0x34, 0x37, 0x61, 0x61, 0x33, 0x31, 0x37, 0x33, 0x66, 0x31, 0x33, 0x65, 0x32, 0x36, 0x66, 0x61, 0x30, 0x36, 0x35, 0x37, 0x32, 0x61, 0x32, 0x32, 0x62, 0x33, 0x62, 0x35, 0x30, 0x66, 0x64, 0x62, 0x32, 0x37, 0x63, 0x30, 0x38, 0x63, 0x34, 0x31, 0x39, 0x61, 0x32, 0x33, 0x37, 0x64, 0x35, 0x38, 0x62, 0x61, 0x66, 0x37, 0x32, 0x37, 0x37, 0x64, 0x30, 0x38, 0x39, 0x62, 0x65, 0x33, 0x63, 0x33, 0x63, 0x37, 0x34, 0x36, 0x30, 0x39, 0x65, 0x65, 0x62, 0x35, 0x65, 0x38, 0x64, 0x37, 0x35, 0x34, 0x61, 0x64, 0x65, 0x37, 0x64, 0x34, 0x62, 0x32, 0x33, 0x66, 0x30, 0x36, 0x62, 0x30, 0x33, 0x39, 0x33, 0x32, 0x39, 0x31, 0x31, 0x39, 0x62, 0x65, 0x64, 0x37, 0x61, 0x66, 0x64, 0x37, 0x39, 0x32, 0x33, 0x31, 0x34, 0x34, 0x37, 0x63, 0x62, 0x36, 0x39, 0x32, 0x66, 0x35, 0x33, 0x36, 0x34, 0x32, 0x38, 0x35, 0x34, 0x61, 0x63, 0x66, 0x62, 0x66, 0x35, 0x62, 0x65, 0x38, 0x65, 0x38, 0x31, 0x35, 0x37, 0x37, 0x33, 0x37, 0x31, 0x32, 0x39, 0x32, 0x35, 0x33, 0x62, 0x35, 0x64, 0x32, 0x30, 0x66, 0x39, 0x33, 0x62, 0x34, 0x35, 0x64, 0x61, 0x39, 0x62, 0x36, 0x64, 0x61, 0x66, 0x62, 0x63, 0x63, 0x38, 0x30, 0x66, 0x32, 0x39, 0x36, 0x31, 0x37, 0x34, 0x33, 0x63, 0x61, 0x31, 0x61, 0x61, 0x35, 0x36, 0x34, 0x37, 0x34, 0x39, 0x61, 0x32, 0x31, 0x35, 0x32, 0x39, 0x34, 0x66, 0x66, 0x35, 0x33, 0x66, 0x35, 0x35, 0x61, 0x36, 0x37, 0x36, 0x39, 0x64, 0x61, 0x36, 0x33, 0x35, 0x35, 0x35, 0x37, 0x31, 0x62, 0x37, 0x35, 0x63, 0x61, 0x39, 0x65, 0x62, 0x31, 0x66, 0x35, 0x37, 0x64, 0x61, 0x33, 0x65, 0x30, 0x38, 0x35, 0x30, 0x32, 0x37, 0x66, 0x64, 0x61, 0x64, 0x62, 0x61, 0x37, 0x31, 0x61, 0x35, 0x37, 0x61, 0x33, 0x31, 0x32, 0x66, 0x64, 0x39, 0x38, 0x33, 0x37, 0x37, 0x32, 0x65, 0x30, 0x37, 0x62, 0x38, 0x63, 0x63, 0x37, 0x34, 0x35, 0x61, 0x34, 0x39, 0x30, 0x37, 0x33, 0x63, 0x37, 0x61, 0x64, 0x39, 0x62, 0x30, 0x61, 0x63, 0x30, 0x30, 0x31, 0x34, 0x61, 0x66, 0x37, 0x31, 0x63, 0x34, 0x39, 0x30, 0x36, 0x31, 0x66, 0x61, 0x38, 0x36, 0x38, 0x39, 0x32, 0x63, 0x31, 0x32, 0x34, 0x34, 0x34, 0x62, 0x31, 0x31, 0x39, 0x62, 0x31, 0x61, 0x32, 0x64, 0x30, 0x33, 0x35, 0x30, 0x37, 0x61, 0x65, 0x64, 0x36, 0x34, 0x32, 0x62, 0x61, 0x62, 0x66, 0x33, 0x37, 0x65, 0x35, 0x61, 0x63, 0x39, 0x65, 0x62, 0x32, 0x38, 0x64, 0x66, 0x62, 0x66, 0x32, 0x32, 0x64, 0x36, 0x35, 0x30, 0x65, 0x38, 0x38, 0x35, 0x37, 0x32, 0x30, 0x35, 0x37, 0x32, 0x32, 0x65, 0x35, 0x33, 0x30, 0x39, 0x32, 0x64, 0x35, 0x35, 0x36, 0x61, 0x63, 0x62, 0x63, 0x62, 0x37, 0x65, 0x65, 0x63, 0x33, 0x63, 0x31, 0x37, 0x32, 0x65, 0x39, 0x65, 0x34, 0x61, 0x39, 0x38, 0x35, 0x64, 0x30, 0x65, 0x34, 0x35, 0x65, 0x63, 0x65, 0x36, 0x63, 0x33, 0x38, 0x62, 0x63, 0x61, 0x30, 0x32, 0x31, 0x38, 0x30, 0x35, 0x66, 0x34, 0x35, 0x65, 0x31, 0x35, 0x35, 0x38, 0x35, 0x36, 0x63, 0x36, 0x39, 0x30, 0x61, 0x64, 0x37, 0x62, 0x36, 0x32, 0x30, 0x62, 0x65, 0x37, 0x38, 0x66, 0x39, 0x35, 0x39, 0x36, 0x34, 0x37, 0x63, 0x36, 0x62, 0x38, 0x63, 0x36, 0x34, 0x30, 0x37, 0x39, 0x34, 0x63, 0x62, 0x39, 0x61, 0x32, 0x32, 0x63, 0x32, 0x35, 0x61, 0x38, 0x61, 0x62, 0x65, 0x35, 0x34, 0x35, 0x61, 0x31, 0x33, 0x38, 0x36, 0x36, 0x66, 0x36, 0x33, 0x31, 0x31, 0x33, 0x62, 0x34, 0x63, 0x66, 0x61, 0x61, 0x63, 0x65, 0x66, 0x35, 0x30, 0x65, 0x32, 0x34, 0x39, 0x39, 0x37, 0x33, 0x35, 0x33, 0x38, 0x64, 0x39, 0x66, 0x33, 0x34, 0x32, 0x63, 0x65, 0x39, 0x38, 0x62, 0x36, 0x36, 0x63, 0x31, 0x63, 0x30, 0x64, 0x36, 0x65, 0x63, 0x32, 0x36, 0x62, 0x34, 0x66, 0x61, 0x37, 0x66, 0x61, 0x36, 0x38, 0x34, 0x31, 0x38, 0x35, 0x30, 0x39, 0x36, 0x35, 0x31, 0x30, 0x65, 0x39, 0x64, 0x62, 0x31, 0x31, 0x39, 0x30, 0x62, 0x36, 0x36, 0x33, 0x63, 0x39, 0x36, 0x66, 0x63, 0x35, 0x62, 0x66, 0x34, 0x64, 0x31, 0x64, 0x34, 0x63, 0x30, 0x34, 0x34, 0x38, 0x37, 0x32, 0x39, 0x61, 0x64, 0x66, 0x65, 0x61, 0x36, 0x38, 0x31, 0x37, 0x39, 0x63, 0x34, 0x66, 0x64, 0x36, 0x65, 0x36, 0x35, 0x64, 0x66, 0x35, 0x38, 0x30, 0x34, 0x33, 0x34, 0x34, 0x61, 0x37, 0x32, 0x39, 0x36, 0x39, 0x63, 0x35, 0x33, 0x36, 0x62, 0x34, 0x36, 0x65, 0x38, 0x31, 0x35, 0x32, 0x61, 0x36, 0x37, 0x39, 0x38, 0x65, 0x61, 0x32, 0x63, 0x36, 0x65, 0x66, 0x35, 0x36, 0x66, 0x39, 0x34, 0x66, 0x31, 0x38, 0x30, 0x34, 0x64, 0x38, 0x35, 0x64, 0x39, 0x66, 0x66, 0x34, 0x66, 0x37, 0x66, 0x31, 0x38, 0x36, 0x30, 0x61, 0x30, 0x32, 0x31, 0x61, 0x65, 0x31, 0x31, 0x65, 0x65, 0x30, 0x35, 0x31, 0x33, 0x34, 0x32, 0x30, 0x30, 0x65, 0x33, 0x66, 0x33, 0x34, 0x31, 0x30, 0x65, 0x37, 0x63, 0x66, 0x38, 0x30, 0x34, 0x32, 0x36, 0x30, 0x66, 0x31, 0x35, 0x31, 0x30, 0x39, 0x36, 0x34, 0x39, 0x62, 0x33, 0x37, 0x36, 0x33, 0x36, 0x38, 0x65, 0x37, 0x32, 0x35, 0x30, 0x31, 0x36, 0x34, 0x66, 0x61, 0x36, 0x39, 0x37, 0x65, 0x36, 0x30, 0x31, 0x66, 0x38, 0x39, 0x37, 0x61, 0x64, 0x37, 0x32, 0x66, 0x64, 0x39, 0x64, 0x37, 0x37, 0x65, 0x64, 0x63, 0x65, 0x32, 0x61, 0x64, 0x33, 0x36, 0x63, 0x35, 0x64, 0x30, 0x36, 0x31, 0x38, 0x33, 0x37, 0x65, 0x62, 0x39, 0x35, 0x38, 0x66, 0x65, 0x33, 0x62, 0x62, 0x61, 0x35, 0x62, 0x61, 0x36, 0x37, 0x37, 0x64, 0x63, 0x66, 0x35, 0x33, 0x65, 0x62, 0x35, 0x63, 0x32, 0x62, 0x32, 0x66, 0x36, 0x39, 0x33, 0x31, 0x37, 0x33, 0x62, 0x66, 0x37, 0x32, 0x61, 0x62, 0x63, 0x66, 0x62, 0x34, 0x32, 0x38, 0x38, 0x33, 0x39, 0x64, 0x34, 0x33, 0x64, 0x34, 0x65, 0x34, 0x63, 0x30, 0x38, 0x31, 0x35, 0x64, 0x32, 0x37, 0x65, 0x64, 0x63, 0x38, 0x64, 0x37, 0x37, 0x66, 0x36, 0x36, 0x31, 0x37, 0x30, 0x66, 0x32, 0x37, 0x38, 0x30, 0x30, 0x63, 0x37, 0x65, 0x38, 0x66, 0x39, 0x38, 0x35, 0x61, 0x62, 0x37, 0x66, 0x33, 0x34, 0x36, 0x38, 0x35, 0x37, 0x32, 0x64, 0x30, 0x64, 0x30, 0x31, 0x63, 0x66, 0x30, 0x37, 0x37, 0x66, 0x39, 0x32, 0x61, 0x34, 0x32, 0x39, 0x34, 0x63, 0x30, 0x39, 0x39, 0x62, 0x36, 0x30, 0x33, 0x62, 0x36, 0x33, 0x63, 0x63, 0x33, 0x61, 0x62, 0x62, 0x65, 0x61, 0x31, 0x38, 0x63, 0x63, 0x35, 0x66, 0x37, 0x34, 0x35, 0x36, 0x66, 0x34, 0x66, 0x63, 0x65, 0x37, 0x31, 0x34, 0x38, 0x38, 0x35, 0x36, 0x39, 0x62, 0x39, 0x32, 0x35, 0x38, 0x35, 0x64, 0x32, 0x32, 0x31, 0x35, 0x32, 0x61, 0x64, 0x32, 0x32, 0x31, 0x30, 0x30, 0x37, 0x63, 0x66, 0x32, 0x33, 0x35, 0x36, 0x32, 0x32, 0x39, 0x65, 0x33, 0x39, 0x33, 0x61, 0x38, 0x33, 0x31, 0x35, 0x30, 0x61, 0x63, 0x66, 0x39, 0x30, 0x64, 0x32, 0x36, 0x65, 0x33, 0x35, 0x66, 0x33, 0x37, 0x35, 0x30, 0x61, 0x32, 0x66, 0x35, 0x31, 0x31, 0x39, 0x31, 0x61, 0x65, 0x33, 0x30, 0x66, 0x34, 0x34, 0x32, 0x35, 0x34, 0x66, 0x64, 0x63, 0x64, 0x61, 0x34, 0x65, 0x32, 0x63, 0x65, 0x31, 0x38, 0x32, 0x39, 0x61, 0x61, 0x63, 0x61, 0x63, 0x30, 0x37, 0x36, 0x61, 0x34, 0x66, 0x62, 0x32, 0x36, 0x33, 0x33, 0x39, 0x35, 0x31, 0x65, 0x65, 0x31, 0x31, 0x61, 0x62, 0x33, 0x32, 0x62, 0x33, 0x66, 0x39, 0x61, 0x38, 0x30, 0x39, 0x38, 0x37, 0x31, 0x61, 0x35, 0x35, 0x38, 0x32, 0x37, 0x32, 0x38, 0x62, 0x63, 0x64, 0x31, 0x35, 0x30, 0x35, 0x34, 0x65, 0x39, 0x62, 0x32, 0x34, 0x33, 0x30, 0x33, 0x37, 0x39, 0x30, 0x37, 0x34, 0x38, 0x30, 0x66, 0x30, 0x65, 0x63, 0x63, 0x34, 0x64, 0x63, 0x34, 0x31, 0x37, 0x65, 0x64, 0x36, 0x31, 0x64, 0x63, 0x32, 0x34, 0x30, 0x62, 0x65, 0x63, 0x66, 0x61, 0x35, 0x63, 0x31, 0x38, 0x38, 0x65, 0x34, 0x66, 0x31, 0x31, 0x39, 0x65, 0x34, 0x34, 0x36, 0x39, 0x63, 0x39, 0x61, 0x38, 0x31, 0x38, 0x38, 0x38, 0x62, 0x33, 0x36, 0x38, 0x65, 0x38, 0x30, 0x61, 0x30, 0x34, 0x63, 0x35, 0x33, 0x31, 0x34, 0x33, 0x39, 0x39, 0x61, 0x38, 0x39, 0x38, 0x38, 0x31, 0x36, 0x30, 0x66, 0x31, 0x66, 0x34, 0x30, 0x30, 0x63, 0x36, 0x34, 0x65, 0x63, 0x63, 0x63, 0x30, 0x61, 0x33, 0x34, 0x33, 0x65, 0x64, 0x37, 0x33, 0x37, 0x39, 0x33, 0x38, 0x37, 0x30, 0x31, 0x36, 0x32, 0x32, 0x62, 0x65, 0x63, 0x36, 0x34, 0x39, 0x65, 0x35, 0x36, 0x38, 0x39, 0x36, 0x31, 0x63, 0x61, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x62, 0x38, 0x37, 0x64, 0x31, 0x30, 0x31, 0x31, 0x37, 0x61, 0x61, 0x39, 0x37, 0x65, 0x61, 0x63, 0x63, 0x63, 0x39, 0x34, 0x65, 0x66, 0x33, 0x61, 0x37, 0x39, 0x37, 0x39, 0x33, 0x38, 0x30, 0x64, 0x63, 0x61, 0x61, 0x31, 0x32, 0x30, 0x35, 0x36, 0x39, 0x63, 0x61, 0x30, 0x36, 0x39, 0x37, 0x35, 0x64, 0x61, 0x35, 0x31, 0x35, 0x33, 0x36, 0x62, 0x31, 0x38, 0x31, 0x64, 0x63, 0x33, 0x35, 0x63, 0x62, 0x36, 0x38, 0x63, 0x33, 0x30, 0x63, 0x30, 0x39, 0x30, 0x66, 0x37, 0x65, 0x66, 0x32, 0x30, 0x37, 0x38, 0x63, 0x32, 0x66, 0x65, 0x30, 0x32, 0x31, 0x32, 0x65, 0x61, 0x37, 0x32, 0x30, 0x61, 0x32, 0x31, 0x62, 0x30, 0x30, 0x61, 0x37, 0x32, 0x34, 0x61, 0x31, 0x32, 0x39, 0x36, 0x32, 0x65, 0x63, 0x30, 0x62, 0x39, 0x62, 0x34, 0x34, 0x35, 0x34, 0x65, 0x37, 0x38, 0x64, 0x38, 0x61, 0x37, 0x65, 0x63, 0x33, 0x32, 0x38, 0x65, 0x61, 0x61, 0x63, 0x38, 0x39, 0x31, 0x35, 0x36, 0x38, 0x32, 0x61, 0x39, 0x35, 0x63, 0x38, 0x36, 0x32, 0x61, 0x63, 0x34, 0x64, 0x37, 0x30, 0x65, 0x34, 0x34, 0x65, 0x64, 0x63, 0x30, 0x66, 0x61, 0x37, 0x32, 0x65, 0x34, 0x36, 0x33, 0x33, 0x35, 0x64, 0x34, 0x61, 0x31, 0x30, 0x62, 0x38, 0x32, 0x34, 0x65, 0x65, 0x38, 0x63, 0x32, 0x61, 0x30, 0x62, 0x35, 0x63, 0x30, 0x33, 0x37, 0x65, 0x63, 0x64, 0x39, 0x61, 0x36, 0x32, 0x30, 0x30, 0x30, 0x32, 0x39, 0x38, 0x62, 0x65, 0x65, 0x38, 0x64, 0x65, 0x62, 0x65, 0x35, 0x39, 0x62, 0x30, 0x65, 0x32, 0x61, 0x65, 0x33, 0x32, 0x38, 0x32, 0x33, 0x37, 0x32, 0x65, 0x31, 0x63, 0x37, 0x36, 0x34, 0x65, 0x62, 0x38, 0x38, 0x34, 0x65, 0x65, 0x61, 0x61, 0x38, 0x36, 0x66, 0x33, 0x32, 0x31, 0x32, 0x66, 0x36, 0x38, 0x32, 0x30, 0x37, 0x62, 0x62, 0x31, 0x30, 0x31, 0x33, 0x62, 0x63, 0x37, 0x37, 0x34, 0x61, 0x61, 0x38, 0x38, 0x32, 0x30, 0x39, 0x39, 0x33, 0x30, 0x65, 0x35, 0x33, 0x33, 0x38, 0x30, 0x38, 0x63, 0x39, 0x35, 0x61, 0x62, 0x30, 0x37, 0x32, 0x36, 0x34, 0x65, 0x62, 0x39, 0x30, 0x30, 0x66, 0x37, 0x33, 0x33, 0x63, 0x35, 0x37, 0x36, 0x66, 0x37, 0x36, 0x30, 0x32, 0x39, 0x64, 0x63, 0x63, 0x35, 0x31, 0x38, 0x62, 0x62, 0x37, 0x38, 0x65, 0x30, 0x65, 0x64, 0x31, 0x64, 0x32, 0x33, 0x39, 0x35, 0x32, 0x37, 0x63, 0x32, 0x32, 0x36, 0x34, 0x35, 0x33, 0x36, 0x32, 0x37, 0x64, 0x66, 0x39, 0x37, 0x36, 0x39, 0x38, 0x66, 0x39, 0x37, 0x32, 0x37, 0x63, 0x64, 0x30, 0x38, 0x61, 0x61, 0x38, 0x33, 0x33, 0x34, 0x35, 0x63, 0x63, 0x65, 0x39, 0x62, 0x30, 0x62, 0x38, 0x35, 0x34, 0x30, 0x61, 0x31, 0x65, 0x33, 0x36, 0x32, 0x62, 0x62, 0x34, 0x63, 0x38, 0x62, 0x33, 0x31, 0x61, 0x65, 0x62, 0x32, 0x35, 0x38, 0x38, 0x37, 0x65, 0x64, 0x38, 0x66, 0x62, 0x37, 0x66, 0x66, 0x32, 0x32, 0x61, 0x66, 0x39, 0x32, 0x65, 0x34, 0x39, 0x37, 0x32, 0x33, 0x35, 0x62, 0x35, 0x35, 0x38, 0x37, 0x31, 0x30, 0x32, 0x63, 0x61, 0x36, 0x39, 0x34, 0x30, 0x34, 0x61, 0x33, 0x36, 0x32, 0x33, 0x61, 0x63, 0x37, 0x63, 0x65, 0x38, 0x35, 0x61, 0x38, 0x30, 0x32, 0x66, 0x62, 0x61, 0x63, 0x38, 0x66, 0x61, 0x33, 0x64, 0x61, 0x39, 0x32, 0x62, 0x65, 0x62, 0x63, 0x39, 0x66, 0x33, 0x66, 0x33, 0x30, 0x34, 0x66, 0x63, 0x63, 0x66, 0x66, 0x33, 0x37, 0x32, 0x66, 0x66, 0x64, 0x34, 0x30, 0x37, 0x34, 0x34, 0x31, 0x30, 0x62, 0x65, 0x66, 0x37, 0x30, 0x39, 0x31, 0x66, 0x35, 0x31, 0x65, 0x63, 0x30, 0x61, 0x38, 0x66, 0x61, 0x65, 0x65, 0x32, 0x66, 0x35, 0x38, 0x37, 0x61, 0x33, 0x30, 0x38, 0x30, 0x33, 0x34, 0x62, 0x36, 0x39, 0x30, 0x37, 0x39, 0x64, 0x66, 0x63, 0x31, 0x32, 0x62, 0x38, 0x38, 0x33, 0x63, 0x36, 0x33, 0x66, 0x37, 0x65, 0x37, 0x32, 0x38, 0x38, 0x32, 0x35, 0x30, 0x38, 0x30, 0x32, 0x65, 0x33, 0x64, 0x64, 0x39, 0x66, 0x65, 0x61, 0x65, 0x66, 0x63, 0x35, 0x35, 0x66, 0x66, 0x34, 0x62, 0x33, 0x37, 0x65, 0x61, 0x66, 0x64, 0x30, 0x62, 0x66, 0x64, 0x38, 0x35, 0x39, 0x31, 0x62, 0x63, 0x65, 0x62, 0x62, 0x66, 0x30, 0x31, 0x30, 0x30, 0x65, 0x63, 0x61, 0x39, 0x34, 0x31, 0x64, 0x39, 0x61, 0x37, 0x34, 0x66, 0x38, 0x30, 0x30, 0x37, 0x66, 0x62, 0x32, 0x66, 0x64, 0x34, 0x37, 0x32, 0x33, 0x30, 0x39, 0x65, 0x62, 0x34, 0x38, 0x38, 0x63, 0x34, 0x64, 0x37, 0x63, 0x34, 0x65, 0x62, 0x65, 0x62, 0x35, 0x65, 0x64, 0x63, 0x35, 0x63, 0x66, 0x32, 0x66, 0x32, 0x34, 0x66, 0x37, 0x61, 0x34, 0x35, 0x31, 0x33, 0x66, 0x38, 0x37, 0x63, 0x39, 0x65, 0x32, 0x31, 0x32, 0x30, 0x66, 0x35, 0x34, 0x62, 0x62, 0x31, 0x31, 0x33, 0x38, 0x30, 0x35, 0x61, 0x63, 0x38, 0x65, 0x32, 0x33, 0x63, 0x36, 0x39, 0x35, 0x61, 0x39, 0x33, 0x64, 0x30, 0x38, 0x39, 0x32, 0x66, 0x63, 0x61, 0x39, 0x38, 0x66, 0x62, 0x36, 0x35, 0x37, 0x35, 0x39, 0x61, 0x30, 0x31, 0x64, 0x66, 0x31, 0x64, 0x62, 0x36, 0x66, 0x62, 0x37, 0x66, 0x35, 0x33, 0x65, 0x35, 0x37, 0x34, 0x63, 0x61, 0x66, 0x61, 0x38, 0x62, 0x31, 0x62, 0x31, 0x32, 0x65, 0x37, 0x32, 0x61, 0x33, 0x35, 0x61, 0x30, 0x65, 0x36, 0x37, 0x66, 0x37, 0x35, 0x62, 0x64, 0x61, 0x34, 0x34, 0x30, 0x34, 0x34, 0x35, 0x30, 0x34, 0x65, 0x34, 0x31, 0x63, 0x30, 0x66, 0x36, 0x66, 0x36, 0x63, 0x62, 0x37, 0x37, 0x61, 0x30, 0x33, 0x66, 0x64, 0x31, 0x32, 0x37, 0x36, 0x31, 0x61, 0x37, 0x64, 0x35, 0x34, 0x34, 0x34, 0x31, 0x63, 0x33, 0x30, 0x39, 0x66, 0x39, 0x33, 0x39, 0x32, 0x37, 0x32, 0x31, 0x32, 0x63, 0x61, 0x34, 0x35, 0x65, 0x35, 0x34, 0x62, 0x37, 0x37, 0x36, 0x39, 0x61, 0x37, 0x39, 0x34, 0x36, 0x61, 0x61, 0x33, 0x34, 0x63, 0x64, 0x66, 0x38, 0x31, 0x39, 0x61, 0x31, 0x62, 0x66, 0x64, 0x37, 0x35, 0x33, 0x30, 0x61, 0x62, 0x64, 0x63, 0x36, 0x36, 0x32, 0x33, 0x34, 0x30, 0x31, 0x39, 0x35, 0x61, 0x38, 0x36, 0x31, 0x38, 0x31, 0x33, 0x62, 0x31, 0x66, 0x37, 0x30, 0x66, 0x62, 0x30, 0x66, 0x63, 0x31, 0x35, 0x39, 0x37, 0x62, 0x35, 0x33, 0x61, 0x39, 0x64, 0x61, 0x33, 0x61, 0x38, 0x61, 0x64, 0x64, 0x63, 0x66, 0x32, 0x33, 0x31, 0x66, 0x61, 0x62, 0x33, 0x39, 0x39, 0x32, 0x34, 0x30, 0x62, 0x63, 0x33, 0x37, 0x37, 0x30, 0x37, 0x65, 0x34, 0x31, 0x35, 0x32, 0x65, 0x34, 0x30, 0x33, 0x30, 0x35, 0x62, 0x34, 0x64, 0x36, 0x30, 0x35, 0x38, 0x65, 0x65, 0x37, 0x32, 0x38, 0x61, 0x64, 0x35, 0x34, 0x36, 0x30, 0x39, 0x39, 0x65, 0x37, 0x30, 0x64, 0x64, 0x36, 0x38, 0x66, 0x66, 0x30, 0x61, 0x32, 0x30, 0x31, 0x36, 0x61, 0x35, 0x37, 0x32, 0x36, 0x62, 0x37, 0x33, 0x30, 0x34, 0x30, 0x31, 0x31, 0x63, 0x37, 0x37, 0x30, 0x38, 0x65, 0x31, 0x63, 0x65, 0x34, 0x30, 0x62, 0x31, 0x63, 0x65, 0x38, 0x63, 0x64, 0x31, 0x35, 0x32, 0x62, 0x66, 0x33, 0x63, 0x37, 0x32, 0x66, 0x39, 0x34, 0x30, 0x65, 0x36, 0x62, 0x38, 0x35, 0x62, 0x32, 0x39, 0x37, 0x31, 0x65, 0x63, 0x64, 0x66, 0x63, 0x62, 0x62, 0x61, 0x34, 0x38, 0x35, 0x37, 0x35, 0x39, 0x64, 0x66, 0x66, 0x36, 0x61, 0x62, 0x35, 0x31, 0x62, 0x61, 0x35, 0x33, 0x34, 0x31, 0x66, 0x64, 0x36, 0x38, 0x34, 0x65, 0x63, 0x36, 0x62, 0x62, 0x38, 0x64, 0x65, 0x66, 0x66, 0x61, 0x62, 0x37, 0x34, 0x32, 0x30, 0x39, 0x37, 0x35, 0x36, 0x30, 0x63, 0x37, 0x66, 0x61, 0x62, 0x36, 0x63, 0x35, 0x37, 0x64, 0x34, 0x32, 0x66, 0x36, 0x36, 0x30, 0x32, 0x37, 0x66, 0x63, 0x30, 0x33, 0x31, 0x30, 0x36, 0x32, 0x63, 0x61, 0x33, 0x38, 0x38, 0x64, 0x36, 0x35, 0x33, 0x65, 0x34, 0x33, 0x33, 0x35, 0x65, 0x63, 0x34, 0x62, 0x64, 0x63, 0x64, 0x65, 0x33, 0x32, 0x32, 0x63, 0x66, 0x34, 0x66, 0x37, 0x34, 0x38, 0x36, 0x32, 0x30, 0x36, 0x33, 0x31, 0x61, 0x64, 0x37, 0x64, 0x65, 0x62, 0x30, 0x34, 0x32, 0x36, 0x62, 0x38, 0x36, 0x38, 0x61, 0x30, 0x39, 0x39, 0x61, 0x38, 0x61, 0x35, 0x37, 0x63, 0x33, 0x65, 0x32, 0x34, 0x39, 0x32, 0x35, 0x35, 0x30, 0x36, 0x66, 0x64, 0x63, 0x62, 0x36, 0x30, 0x36, 0x35, 0x61, 0x35, 0x34, 0x63, 0x63, 0x33, 0x31, 0x66, 0x38, 0x35, 0x36, 0x63, 0x34, 0x61, 0x65, 0x38, 0x37, 0x32, 0x61, 0x30, 0x65, 0x65, 0x34, 0x32, 0x30, 0x61, 0x63, 0x64, 0x32, 0x65, 0x37, 0x61, 0x38, 0x35, 0x62, 0x66, 0x63, 0x65, 0x34, 0x39, 0x36, 0x37, 0x32, 0x34, 0x62, 0x31, 0x64, 0x63, 0x61, 0x31, 0x39, 0x66, 0x35, 0x64, 0x32, 0x63, 0x37, 0x36, 0x32, 0x33, 0x62, 0x62, 0x63, 0x31, 0x32, 0x30, 0x65, 0x34, 0x32, 0x35, 0x37, 0x34, 0x35, 0x64, 0x33, 0x65, 0x37, 0x35, 0x61, 0x61, 0x37, 0x32, 0x36, 0x36, 0x36, 0x62, 0x61, 0x63, 0x38, 0x32, 0x37, 0x36, 0x38, 0x35, 0x38, 0x38, 0x64, 0x61, 0x35, 0x64, 0x38, 0x62, 0x65, 0x65, 0x37, 0x38, 0x38, 0x65, 0x37, 0x63, 0x66, 0x65, 0x35, 0x38, 0x64, 0x36, 0x64, 0x30, 0x35, 0x64, 0x35, 0x39, 0x36, 0x37, 0x66, 0x34, 0x63, 0x35, 0x33, 0x65, 0x35, 0x62, 0x35, 0x36, 0x37, 0x31, 0x63, 0x33, 0x32, 0x31, 0x31, 0x32, 0x66, 0x66, 0x37, 0x32, 0x66, 0x31, 0x36, 0x39, 0x63, 0x37, 0x32, 0x66, 0x30, 0x35, 0x31, 0x63, 0x38, 0x61, 0x34, 0x31, 0x64, 0x34, 0x38, 0x36, 0x36, 0x31, 0x35, 0x34, 0x61, 0x31, 0x35, 0x37, 0x37, 0x33, 0x62, 0x39, 0x62, 0x32, 0x62, 0x65, 0x38, 0x35, 0x33, 0x65, 0x35, 0x37, 0x39, 0x34, 0x31, 0x65, 0x33, 0x37, 0x63, 0x36, 0x63, 0x35, 0x64, 0x38, 0x31, 0x37, 0x66, 0x32, 0x65, 0x31, 0x38, 0x64, 0x34, 0x38, 0x66, 0x36, 0x37, 0x31, 0x34, 0x65, 0x35, 0x38, 0x66, 0x38, 0x37, 0x64, 0x65, 0x31, 0x39, 0x62, 0x35, 0x33, 0x36, 0x39, 0x63, 0x66, 0x35, 0x64, 0x32, 0x39, 0x66, 0x32, 0x31, 0x63, 0x39, 0x35, 0x36, 0x66, 0x66, 0x36, 0x37, 0x61, 0x65, 0x63, 0x61, 0x65, 0x65, 0x35, 0x35, 0x32, 0x63, 0x39, 0x63, 0x65, 0x39, 0x38, 0x36, 0x65, 0x33, 0x65, 0x65, 0x38, 0x35, 0x31, 0x30, 0x39, 0x33, 0x65, 0x62, 0x61, 0x32, 0x33, 0x34, 0x39, 0x64, 0x62, 0x34, 0x35, 0x36, 0x63, 0x35, 0x34, 0x65, 0x62, 0x36, 0x35, 0x62, 0x65, 0x62, 0x33, 0x65, 0x63, 0x63, 0x31, 0x64, 0x33, 0x33, 0x33, 0x39, 0x37, 0x30, 0x64, 0x36, 0x62, 0x35, 0x62, 0x63, 0x61, 0x65, 0x38, 0x34, 0x61, 0x38, 0x39, 0x35, 0x31, 0x39, 0x61, 0x64, 0x64, 0x35, 0x36, 0x65, 0x36, 0x37, 0x35, 0x35, 0x64, 0x37, 0x61, 0x33, 0x32, 0x30, 0x30, 0x64, 0x61, 0x64, 0x33, 0x37, 0x30, 0x35, 0x65, 0x36, 0x38, 0x65, 0x36, 0x37, 0x32, 0x38, 0x36, 0x62, 0x37, 0x61, 0x37, 0x63, 0x65, 0x62, 0x66, 0x30, 0x36, 0x62, 0x32, 0x38, 0x31, 0x65, 0x34, 0x31, 0x66, 0x61, 0x66, 0x62, 0x37, 0x34, 0x31, 0x31, 0x32, 0x66, 0x33, 0x38, 0x39, 0x37, 0x37, 0x36, 0x66, 0x61, 0x34, 0x61, 0x37, 0x39, 0x32, 0x30, 0x66, 0x61, 0x31, 0x37, 0x32, 0x39, 0x61, 0x37, 0x34, 0x34, 0x65, 0x64, 0x64, 0x31, 0x37, 0x39, 0x63, 0x39, 0x66, 0x30, 0x64, 0x33, 0x30, 0x65, 0x64, 0x34, 0x36, 0x31, 0x31, 0x30, 0x35, 0x30, 0x66, 0x37, 0x37, 0x30, 0x35, 0x35, 0x65, 0x66, 0x32, 0x32, 0x33, 0x62, 0x33, 0x63, 0x34, 0x35, 0x39, 0x65, 0x36, 0x62, 0x36, 0x31, 0x65, 0x34, 0x64, 0x39, 0x38, 0x34, 0x62, 0x37, 0x35, 0x37, 0x61, 0x37, 0x62, 0x36, 0x64, 0x63, 0x64, 0x38, 0x31, 0x66, 0x36, 0x34, 0x39, 0x31, 0x36, 0x36, 0x61, 0x34, 0x63, 0x32, 0x30, 0x37, 0x32, 0x36, 0x65, 0x30, 0x39, 0x61, 0x62, 0x34, 0x65, 0x61, 0x31, 0x32, 0x39, 0x35, 0x32, 0x65, 0x34, 0x31, 0x32, 0x32, 0x35, 0x37, 0x38, 0x30, 0x66, 0x35, 0x61, 0x61, 0x31, 0x66, 0x31, 0x62, 0x35, 0x32, 0x32, 0x66, 0x37, 0x35, 0x31, 0x37, 0x36, 0x61, 0x32, 0x35, 0x35, 0x30, 0x36, 0x34, 0x30, 0x31, 0x65, 0x63, 0x38, 0x61, 0x38, 0x63, 0x33, 0x37, 0x36, 0x38, 0x36, 0x31, 0x65, 0x37, 0x32, 0x30, 0x30, 0x33, 0x35, 0x62, 0x38, 0x35, 0x39, 0x64, 0x31, 0x32, 0x39, 0x36, 0x38, 0x61, 0x36, 0x39, 0x61, 0x34, 0x34, 0x66, 0x32, 0x32, 0x63, 0x36, 0x30, 0x62, 0x63, 0x34, 0x34, 0x30, 0x63, 0x61, 0x63, 0x63, 0x35, 0x39, 0x38, 0x36, 0x30, 0x66, 0x35, 0x61, 0x64, 0x37, 0x32, 0x66, 0x36, 0x63, 0x39, 0x65, 0x36, 0x64, 0x33, 0x32, 0x34, 0x39, 0x63, 0x30, 0x30, 0x31, 0x64, 0x63, 0x38, 0x31, 0x64, 0x31, 0x32, 0x34, 0x61, 0x63, 0x66, 0x64, 0x63, 0x62, 0x31, 0x35, 0x30, 0x64, 0x31, 0x37, 0x30, 0x61, 0x61, 0x62, 0x37, 0x33, 0x35, 0x32, 0x64, 0x33, 0x61, 0x36, 0x33, 0x32, 0x31, 0x32, 0x30, 0x63, 0x62, 0x33, 0x63, 0x34, 0x64, 0x61, 0x39, 0x64, 0x39, 0x37, 0x32, 0x62, 0x61, 0x37, 0x66, 0x37, 0x35, 0x33, 0x35, 0x30, 0x64, 0x37, 0x63, 0x33, 0x61, 0x66, 0x36, 0x39, 0x33, 0x65, 0x66, 0x32, 0x39, 0x34, 0x34, 0x35, 0x31, 0x32, 0x35, 0x35, 0x33, 0x35, 0x39, 0x36, 0x34, 0x30, 0x30, 0x66, 0x61, 0x62, 0x36, 0x66, 0x62, 0x61, 0x36, 0x32, 0x64, 0x35, 0x36, 0x37, 0x37, 0x65, 0x37, 0x37, 0x35, 0x32, 0x61, 0x63, 0x34, 0x63, 0x65, 0x34, 0x39, 0x37, 0x32, 0x36, 0x62, 0x61, 0x34, 0x64, 0x39, 0x66, 0x34, 0x32, 0x33, 0x39, 0x38, 0x30, 0x36, 0x64, 0x64, 0x63, 0x32, 0x62, 0x66, 0x62, 0x31, 0x64, 0x33, 0x32, 0x35, 0x62, 0x36, 0x64, 0x62, 0x32, 0x61, 0x63, 0x62, 0x62, 0x39, 0x30, 0x62, 0x61, 0x35, 0x39, 0x38, 0x64, 0x37, 0x61, 0x31, 0x64, 0x34, 0x65, 0x30, 0x62, 0x38, 0x30, 0x36, 0x39, 0x31, 0x63, 0x35, 0x65, 0x66, 0x31, 0x36, 0x37, 0x31, 0x32, 0x38, 0x36, 0x66, 0x64, 0x34, 0x62, 0x34, 0x66, 0x32, 0x34, 0x61, 0x36, 0x62, 0x30, 0x66, 0x39, 0x35, 0x61, 0x33, 0x63, 0x64, 0x63, 0x63, 0x62, 0x35, 0x64, 0x65, 0x61, 0x31, 0x64, 0x36, 0x61, 0x33, 0x62, 0x62, 0x63, 0x62, 0x62, 0x62, 0x64, 0x37, 0x37, 0x34, 0x39, 0x35, 0x63, 0x62, 0x62, 0x34, 0x63, 0x31, 0x35, 0x32, 0x63, 0x64, 0x65, 0x37, 0x64, 0x38, 0x63, 0x33, 0x37, 0x32, 0x35, 0x30, 0x37, 0x37, 0x38, 0x33, 0x31, 0x36, 0x34, 0x38, 0x31, 0x33, 0x34, 0x32, 0x33, 0x64, 0x36, 0x36, 0x64, 0x35, 0x61, 0x38, 0x38, 0x32, 0x66, 0x32, 0x65, 0x32, 0x31, 0x39, 0x34, 0x35, 0x30, 0x32, 0x31, 0x37, 0x39, 0x65, 0x61, 0x36, 0x61, 0x66, 0x38, 0x66, 0x38, 0x39, 0x62, 0x37, 0x64, 0x66, 0x33, 0x32, 0x36, 0x35, 0x34, 0x39, 0x34, 0x33, 0x37, 0x65, 0x33, 0x63, 0x33, 0x63, 0x61, 0x36, 0x66, 0x37, 0x30, 0x38, 0x65, 0x32, 0x34, 0x35, 0x32, 0x39, 0x39, 0x37, 0x62, 0x65, 0x31, 0x62, 0x39, 0x62, 0x61, 0x37, 0x38, 0x35, 0x65, 0x39, 0x38, 0x37, 0x63, 0x34, 0x30, 0x34, 0x62, 0x63, 0x66, 0x64, 0x64, 0x36, 0x39, 0x39, 0x65, 0x39, 0x36, 0x65, 0x39, 0x38, 0x62, 0x37, 0x64, 0x35, 0x61, 0x63, 0x61, 0x35, 0x33, 0x34, 0x37, 0x66, 0x65, 0x65, 0x39, 0x65, 0x37, 0x32, 0x37, 0x64, 0x37, 0x35, 0x63, 0x37, 0x31, 0x32, 0x61, 0x63, 0x34, 0x61, 0x61, 0x61, 0x61, 0x33, 0x33, 0x30, 0x36, 0x31, 0x63, 0x35, 0x63, 0x61, 0x66, 0x39, 0x63, 0x32, 0x61, 0x35, 0x63, 0x33, 0x31, 0x62, 0x65, 0x37, 0x30, 0x35, 0x66, 0x33, 0x39, 0x37, 0x61, 0x32, 0x39, 0x38, 0x33, 0x35, 0x33, 0x39, 0x30, 0x39, 0x66, 0x61, 0x39, 0x62, 0x62, 0x61, 0x38, 0x32, 0x64, 0x62, 0x37, 0x32, 0x32, 0x37, 0x65, 0x63, 0x61, 0x30, 0x33, 0x37, 0x34, 0x65, 0x62, 0x30, 0x30, 0x62, 0x62, 0x37, 0x64, 0x39, 0x35, 0x38, 0x36, 0x32, 0x34, 0x39, 0x30, 0x39, 0x33, 0x33, 0x33, 0x38, 0x31, 0x39, 0x66, 0x33, 0x63, 0x37, 0x66, 0x39, 0x33, 0x66, 0x32, 0x35, 0x34, 0x36, 0x64, 0x66, 0x61, 0x32, 0x34, 0x38, 0x36, 0x37, 0x33, 0x33, 0x35, 0x37, 0x35, 0x34, 0x31, 0x35, 0x66, 0x37, 0x37, 0x32, 0x36, 0x33, 0x38, 0x61, 0x65, 0x30, 0x30, 0x31, 0x30, 0x30, 0x65, 0x39, 0x39, 0x36, 0x63, 0x37, 0x39, 0x36, 0x66, 0x39, 0x61, 0x62, 0x36, 0x61, 0x62, 0x34, 0x62, 0x35, 0x62, 0x35, 0x36, 0x38, 0x30, 0x63, 0x31, 0x37, 0x34, 0x64, 0x36, 0x61, 0x35, 0x35, 0x35, 0x33, 0x39, 0x62, 0x35, 0x34, 0x31, 0x32, 0x31, 0x63, 0x66, 0x30, 0x39, 0x38, 0x64, 0x32, 0x38, 0x36, 0x64, 0x63, 0x32, 0x64, 0x65, 0x34, 0x66, 0x63, 0x39, 0x30, 0x38, 0x37, 0x35, 0x39, 0x34, 0x36, 0x38, 0x39, 0x63, 0x64, 0x30, 0x30, 0x37, 0x30, 0x65, 0x62, 0x36, 0x65, 0x39, 0x34, 0x63, 0x34, 0x61, 0x63, 0x30, 0x63, 0x34, 0x63, 0x30, 0x32, 0x34, 0x35, 0x65, 0x64, 0x33, 0x39, 0x65, 0x61, 0x39, 0x35, 0x39, 0x31, 0x31, 0x66, 0x32, 0x63, 0x33, 0x37, 0x38, 0x65, 0x66, 0x30, 0x39, 0x31, 0x64, 0x36, 0x35, 0x64, 0x35, 0x35, 0x33, 0x65, 0x39, 0x65, 0x30, 0x32, 0x32, 0x61, 0x66, 0x30, 0x30, 0x39, 0x62, 0x66, 0x36, 0x66, 0x63, 0x33, 0x37, 0x37, 0x66, 0x61, 0x34, 0x39, 0x64, 0x36, 0x33, 0x39, 0x32, 0x66, 0x35, 0x33, 0x66, 0x37, 0x65, 0x36, 0x33, 0x38, 0x33, 0x30, 0x63, 0x37, 0x64, 0x62, 0x63, 0x61, 0x35, 0x33, 0x37, 0x34, 0x65, 0x36, 0x32, 0x34, 0x38, 0x33, 0x36, 0x64, 0x65, 0x63, 0x37, 0x32, 0x34, 0x66, 0x36, 0x64, 0x37, 0x37, 0x63, 0x64, 0x34, 0x33, 0x66, 0x61, 0x66, 0x32, 0x34, 0x36, 0x38, 0x33, 0x34, 0x62, 0x39, 0x31, 0x64, 0x37, 0x36, 0x31, 0x36, 0x33, 0x64, 0x38, 0x36, 0x31, 0x39, 0x32, 0x65, 0x38, 0x30, 0x31, 0x30, 0x63, 0x63, 0x32, 0x31, 0x63, 0x66, 0x65, 0x35, 0x35, 0x38, 0x65, 0x36, 0x39, 0x66, 0x35, 0x62, 0x31, 0x62, 0x64, 0x30, 0x34, 0x63, 0x66, 0x37, 0x32, 0x66, 0x38, 0x36, 0x39, 0x35, 0x32, 0x34, 0x39, 0x61, 0x63, 0x37, 0x63, 0x32, 0x36, 0x65, 0x62, 0x62, 0x34, 0x39, 0x33, 0x63, 0x37, 0x37, 0x64, 0x66, 0x30, 0x62, 0x38, 0x61, 0x31, 0x64, 0x32, 0x39, 0x35, 0x61, 0x35, 0x30, 0x33, 0x61, 0x39, 0x63, 0x30, 0x34, 0x32, 0x33, 0x37, 0x66, 0x31, 0x32, 0x36, 0x66, 0x32, 0x32, 0x63, 0x31, 0x66, 0x64, 0x39, 0x32, 0x31, 0x35, 0x34, 0x37, 0x32, 0x33, 0x38, 0x38, 0x38, 0x31, 0x35, 0x64, 0x39, 0x65, 0x65, 0x33, 0x35, 0x30, 0x62, 0x34, 0x66, 0x30, 0x65, 0x34, 0x39, 0x39, 0x36, 0x65, 0x30, 0x30, 0x34, 0x65, 0x30, 0x36, 0x61, 0x34, 0x37, 0x34, 0x61, 0x65, 0x33, 0x34, 0x38, 0x34, 0x31, 0x35, 0x64, 0x37, 0x64, 0x63, 0x35, 0x62, 0x36, 0x61, 0x39, 0x37, 0x62, 0x61, 0x65, 0x36, 0x38, 0x36, 0x64, 0x32, 0x33, 0x37, 0x66, 0x34, 0x31, 0x33, 0x34, 0x63, 0x39, 0x65, 0x36, 0x32, 0x62, 0x35, 0x65, 0x66, 0x34, 0x31, 0x30, 0x64, 0x33, 0x65, 0x38, 0x66, 0x36, 0x34, 0x34, 0x32, 0x32, 0x64, 0x32, 0x66, 0x35, 0x31, 0x64, 0x39, 0x66, 0x30, 0x65, 0x66, 0x38, 0x33, 0x32, 0x62, 0x34, 0x64, 0x33, 0x63, 0x31, 0x39, 0x38, 0x62, 0x63, 0x35, 0x37, 0x39, 0x31, 0x34, 0x32, 0x34, 0x63, 0x61, 0x30, 0x32, 0x34, 0x38, 0x62, 0x37, 0x32, 0x35, 0x35, 0x61, 0x62, 0x37, 0x61, 0x35, 0x39, 0x61, 0x62, 0x65, 0x66, 0x36, 0x33, 0x38, 0x34, 0x37, 0x63, 0x30, 0x37, 0x36, 0x39, 0x62, 0x37, 0x38, 0x39, 0x30, 0x39, 0x38, 0x37, 0x30, 0x33, 0x33, 0x34, 0x66, 0x36, 0x38, 0x61, 0x37, 0x36, 0x32, 0x66, 0x33, 0x66, 0x38, 0x65, 0x36, 0x64, 0x34, 0x31, 0x37, 0x30, 0x32, 0x38, 0x64, 0x63, 0x38, 0x34, 0x34, 0x35, 0x35, 0x39, 0x35, 0x39, 0x36, 0x30, 0x63, 0x32, 0x39, 0x32, 0x66, 0x35, 0x65, 0x65, 0x61, 0x30, 0x64, 0x39, 0x63, 0x36, 0x35, 0x32, 0x64, 0x36, 0x31, 0x66, 0x33, 0x38, 0x62, 0x62, 0x33, 0x33, 0x36, 0x34, 0x65, 0x39, 0x37, 0x32, 0x63, 0x33, 0x64, 0x39, 0x34, 0x36, 0x64, 0x66, 0x61, 0x31, 0x30, 0x30, 0x65, 0x38, 0x66, 0x35, 0x39, 0x63, 0x64, 0x66, 0x39, 0x38, 0x33, 0x32, 0x33, 0x61, 0x30, 0x64, 0x31, 0x39, 0x33, 0x30, 0x31, 0x62, 0x36, 0x37, 0x39, 0x66, 0x64, 0x32, 0x30, 0x39, 0x36, 0x64, 0x35, 0x35, 0x37, 0x37, 0x61, 0x36, 0x32, 0x36, 0x62, 0x31, 0x36, 0x37, 0x36, 0x36, 0x38, 0x66, 0x62, 0x38, 0x36, 0x33, 0x32, 0x61, 0x62, 0x37, 0x30, 0x39, 0x35, 0x37, 0x34, 0x61, 0x38, 0x62, 0x39, 0x38, 0x31, 0x35, 0x31, 0x64, 0x30, 0x35, 0x35, 0x64, 0x36, 0x36, 0x36, 0x35, 0x31, 0x66, 0x31, 0x30, 0x32, 0x33, 0x39, 0x36, 0x34, 0x39, 0x37, 0x35, 0x37, 0x37, 0x37, 0x33, 0x63, 0x64, 0x32, 0x62, 0x34, 0x34, 0x32, 0x33, 0x37, 0x33, 0x38, 0x65, 0x63, 0x36, 0x39, 0x32, 0x39, 0x33, 0x32, 0x36, 0x65, 0x34, 0x35, 0x31, 0x65, 0x34, 0x64, 0x62, 0x39, 0x32, 0x34, 0x38, 0x35, 0x66, 0x64, 0x38, 0x36, 0x65, 0x66, 0x63, 0x61, 0x32, 0x64, 0x35, 0x61, 0x32, 0x66, 0x64, 0x65, 0x39, 0x31, 0x62, 0x37, 0x39, 0x33, 0x64, 0x61, 0x33, 0x32, 0x34, 0x32, 0x30, 0x30, 0x32, 0x34, 0x34, 0x62, 0x37, 0x62, 0x35, 0x34, 0x34, 0x66, 0x61, 0x31, 0x36, 0x35, 0x39, 0x64, 0x33, 0x39, 0x36, 0x39, 0x62, 0x31, 0x30, 0x63, 0x66, 0x38, 0x30, 0x39, 0x38, 0x38, 0x65, 0x33, 0x36, 0x35, 0x38, 0x34, 0x64, 0x35, 0x31, 0x34, 0x37, 0x32, 0x37, 0x64, 0x65, 0x32, 0x34, 0x34, 0x32, 0x30, 0x32, 0x37, 0x32, 0x33, 0x31, 0x66, 0x30, 0x65, 0x36, 0x65, 0x35, 0x39, 0x31, 0x33, 0x66, 0x32, 0x37, 0x32, 0x33, 0x38, 0x35, 0x38, 0x36, 0x34, 0x62, 0x34, 0x35, 0x66, 0x64, 0x34, 0x37, 0x62, 0x31, 0x64, 0x32, 0x64, 0x64, 0x33, 0x30, 0x63, 0x37, 0x64, 0x30, 0x35, 0x30, 0x62, 0x62, 0x62, 0x64, 0x39, 0x31, 0x65, 0x33, 0x35, 0x32, 0x36, 0x63, 0x62, 0x64, 0x38, 0x36, 0x66, 0x31, 0x61, 0x64, 0x37, 0x32, 0x61, 0x39, 0x38, 0x36, 0x37, 0x62, 0x64, 0x61, 0x31, 0x61, 0x63, 0x63, 0x33, 0x62, 0x31, 0x33, 0x34, 0x38, 0x32, 0x62, 0x33, 0x64, 0x36, 0x37, 0x65, 0x61, 0x33, 0x31, 0x61, 0x31, 0x62, 0x32, 0x39, 0x31, 0x37, 0x35, 0x35, 0x35, 0x31, 0x33, 0x33, 0x62, 0x31, 0x61, 0x37, 0x65, 0x37, 0x33, 0x63, 0x34, 0x30, 0x62, 0x64, 0x39, 0x39, 0x35, 0x66, 0x38, 0x38, 0x65, 0x38, 0x39, 0x37, 0x32, 0x31, 0x37, 0x30, 0x33, 0x64, 0x64, 0x34, 0x31, 0x30, 0x61, 0x64, 0x33, 0x61, 0x63, 0x65, 0x66, 0x32, 0x63, 0x37, 0x63, 0x32, 0x35, 0x36, 0x31, 0x63, 0x31, 0x64, 0x65, 0x61, 0x61, 0x65, 0x34, 0x34, 0x31, 0x38, 0x39, 0x32, 0x32, 0x66, 0x63, 0x34, 0x61, 0x36, 0x34, 0x61, 0x31, 0x38, 0x65, 0x30, 0x32, 0x32, 0x38, 0x33, 0x62, 0x38, 0x33, 0x38, 0x32, 0x38, 0x30, 0x61, 0x65, 0x34, 0x31, 0x35, 0x62, 0x36, 0x30, 0x36, 0x36, 0x64, 0x35, 0x35, 0x63, 0x34, 0x34, 0x62, 0x39, 0x39, 0x36, 0x30, 0x39, 0x62, 0x62, 0x63, 0x37, 0x33, 0x38, 0x39, 0x34, 0x30, 0x39, 0x65, 0x34, 0x33, 0x32, 0x63, 0x36, 0x32, 0x65, 0x63, 0x30, 0x36, 0x32, 0x34, 0x32, 0x61, 0x30, 0x61, 0x61, 0x31, 0x66, 0x62, 0x36, 0x65, 0x37, 0x34, 0x30, 0x36, 0x36, 0x66, 0x66, 0x63, 0x38, 0x32, 0x36, 0x37, 0x32, 0x36, 0x37, 0x66, 0x66, 0x30, 0x66, 0x64, 0x36, 0x64, 0x31, 0x35, 0x62, 0x35, 0x66, 0x36, 0x32, 0x37, 0x31, 0x38, 0x32, 0x34, 0x62, 0x61, 0x36, 0x64, 0x61, 0x66, 0x35, 0x34, 0x34, 0x30, 0x31, 0x64, 0x34, 0x66, 0x62, 0x36, 0x65, 0x34, 0x38, 0x36, 0x62, 0x37, 0x62, 0x37, 0x64, 0x34, 0x38, 0x38, 0x39, 0x39, 0x37, 0x33, 0x30, 0x39, 0x34, 0x63, 0x35, 0x31, 0x63, 0x61, 0x38, 0x34, 0x61, 0x63, 0x37, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x61, 0x39, 0x35, 0x33, 0x66, 0x34, 0x62, 0x34, 0x36, 0x39, 0x62, 0x63, 0x38, 0x65, 0x33, 0x62, 0x37, 0x35, 0x64, 0x33, 0x66, 0x61, 0x61, 0x65, 0x63, 0x66, 0x38, 0x32, 0x65, 0x37, 0x62, 0x30, 0x38, 0x32, 0x61, 0x66, 0x30, 0x65, 0x36, 0x36, 0x32, 0x31, 0x31, 0x32, 0x35, 0x30, 0x30, 0x61, 0x38, 0x35, 0x63, 0x37, 0x34, 0x36, 0x37, 0x32, 0x35, 0x35, 0x39, 0x32, 0x38, 0x37, 0x32, 0x62, 0x31, 0x35, 0x66, 0x34, 0x62, 0x35, 0x35, 0x63, 0x39, 0x37, 0x35, 0x34, 0x39, 0x38, 0x32, 0x39, 0x32, 0x64, 0x65, 0x31, 0x30, 0x32, 0x37, 0x38, 0x61, 0x35, 0x30, 0x65, 0x65, 0x39, 0x30, 0x65, 0x38, 0x31, 0x38, 0x34, 0x34, 0x34, 0x34, 0x64, 0x32, 0x37, 0x35, 0x31, 0x37, 0x30, 0x37, 0x33, 0x64, 0x61, 0x61, 0x39, 0x61, 0x34, 0x37, 0x32, 0x34, 0x30, 0x39, 0x30, 0x39, 0x34, 0x61, 0x62, 0x37, 0x66, 0x34, 0x34, 0x38, 0x31, 0x34, 0x32, 0x62, 0x64, 0x37, 0x63, 0x63, 0x39, 0x63, 0x39, 0x35, 0x33, 0x64, 0x31, 0x30, 0x66, 0x66, 0x66, 0x61, 0x39, 0x32, 0x63, 0x62, 0x35, 0x66, 0x61, 0x35, 0x31, 0x38, 0x36, 0x62, 0x33, 0x30, 0x37, 0x30, 0x32, 0x39, 0x64, 0x35, 0x65, 0x61, 0x65, 0x36, 0x65, 0x37, 0x35, 0x63, 0x63, 0x35, 0x64, 0x36, 0x33, 0x61, 0x35, 0x32, 0x64, 0x32, 0x30, 0x64, 0x37, 0x37, 0x39, 0x35, 0x33, 0x37, 0x66, 0x34, 0x39, 0x65, 0x37, 0x38, 0x36, 0x37, 0x38, 0x33, 0x35, 0x39, 0x66, 0x61, 0x35, 0x62, 0x39, 0x64, 0x38, 0x35, 0x30, 0x34, 0x33, 0x33, 0x30, 0x35, 0x38, 0x30, 0x32, 0x30, 0x31, 0x33, 0x30, 0x65, 0x63, 0x65, 0x36, 0x34, 0x65, 0x35, 0x34, 0x62, 0x65, 0x30, 0x30, 0x36, 0x63, 0x34, 0x61, 0x38, 0x66, 0x66, 0x65, 0x35, 0x37, 0x32, 0x33, 0x64, 0x33, 0x32, 0x36, 0x38, 0x33, 0x31, 0x63, 0x39, 0x34, 0x31, 0x35, 0x30, 0x64, 0x39, 0x33, 0x30, 0x39, 0x37, 0x63, 0x63, 0x33, 0x32, 0x33, 0x34, 0x65, 0x35, 0x33, 0x38, 0x37, 0x37, 0x61, 0x61, 0x65, 0x35, 0x38, 0x39, 0x39, 0x62, 0x64, 0x36, 0x35, 0x64, 0x36, 0x34, 0x38, 0x63, 0x61, 0x31, 0x31, 0x33, 0x62, 0x37, 0x37, 0x34, 0x36, 0x63, 0x62, 0x61, 0x31, 0x64, 0x61, 0x38, 0x34, 0x34, 0x30, 0x34, 0x32, 0x61, 0x64, 0x63, 0x64, 0x35, 0x33, 0x39, 0x37, 0x33, 0x32, 0x66, 0x38, 0x61, 0x66, 0x66, 0x65, 0x33, 0x38, 0x32, 0x66, 0x62, 0x65, 0x38, 0x32, 0x63, 0x65, 0x39, 0x37, 0x30, 0x32, 0x63, 0x66, 0x62, 0x37, 0x32, 0x63, 0x63, 0x61, 0x35, 0x35, 0x34, 0x31, 0x36, 0x61, 0x31, 0x33, 0x36, 0x62, 0x30, 0x36, 0x36, 0x38, 0x30, 0x64, 0x62, 0x64, 0x31, 0x61, 0x66, 0x36, 0x62, 0x33, 0x33, 0x35, 0x39, 0x36, 0x65, 0x32, 0x36, 0x66, 0x65, 0x65, 0x30, 0x32, 0x31, 0x36, 0x64, 0x64, 0x64, 0x33, 0x34, 0x63, 0x34, 0x37, 0x33, 0x39, 0x30, 0x61, 0x37, 0x61, 0x38, 0x30, 0x34, 0x30, 0x63, 0x65, 0x66, 0x39, 0x30, 0x30, 0x66, 0x65, 0x62, 0x66, 0x66, 0x37, 0x64, 0x39, 0x32, 0x39, 0x38, 0x62, 0x32, 0x62, 0x37, 0x32, 0x33, 0x33, 0x33, 0x33, 0x65, 0x39, 0x36, 0x34, 0x39, 0x32, 0x36, 0x32, 0x64, 0x35, 0x33, 0x61, 0x34, 0x61, 0x34, 0x37, 0x31, 0x39, 0x66, 0x64, 0x35, 0x38, 0x63, 0x62, 0x36, 0x38, 0x65, 0x36, 0x32, 0x36, 0x34, 0x33, 0x37, 0x31, 0x37, 0x63, 0x61, 0x32, 0x66, 0x31, 0x61, 0x31, 0x65, 0x36, 0x34, 0x38, 0x31, 0x38, 0x30, 0x37, 0x65, 0x30, 0x66, 0x35, 0x32, 0x65, 0x38, 0x34, 0x31, 0x37, 0x63, 0x39, 0x61, 0x38, 0x65, 0x37, 0x37, 0x30, 0x39, 0x66, 0x61, 0x64, 0x32, 0x36, 0x62, 0x33, 0x32, 0x36, 0x62, 0x38, 0x37, 0x33, 0x61, 0x33, 0x39, 0x61, 0x32, 0x34, 0x61, 0x65, 0x36, 0x66, 0x30, 0x34, 0x35, 0x30, 0x64, 0x38, 0x65, 0x33, 0x63, 0x39, 0x66, 0x62, 0x36, 0x39, 0x61, 0x30, 0x34, 0x37, 0x31, 0x31, 0x37, 0x31, 0x63, 0x38, 0x37, 0x66, 0x66, 0x65, 0x33, 0x65, 0x37, 0x32, 0x36, 0x66, 0x30, 0x63, 0x61, 0x38, 0x35, 0x36, 0x63, 0x39, 0x39, 0x31, 0x66, 0x39, 0x33, 0x65, 0x62, 0x63, 0x34, 0x30, 0x39, 0x35, 0x38, 0x65, 0x34, 0x31, 0x66, 0x30, 0x36, 0x34, 0x66, 0x65, 0x32, 0x36, 0x36, 0x62, 0x36, 0x62, 0x63, 0x30, 0x33, 0x31, 0x39, 0x30, 0x34, 0x31, 0x32, 0x61, 0x65, 0x33, 0x65, 0x39, 0x35, 0x62, 0x65, 0x66, 0x38, 0x30, 0x38, 0x33, 0x33, 0x31, 0x37, 0x32, 0x37, 0x30, 0x35, 0x65, 0x31, 0x62, 0x36, 0x61, 0x34, 0x65, 0x36, 0x66, 0x34, 0x38, 0x32, 0x34, 0x36, 0x61, 0x34, 0x37, 0x66, 0x61, 0x34, 0x32, 0x37, 0x65, 0x64, 0x34, 0x39, 0x32, 0x36, 0x38, 0x32, 0x34, 0x63, 0x35, 0x35, 0x62, 0x37, 0x65, 0x36, 0x61, 0x64, 0x32, 0x38, 0x37, 0x61, 0x35, 0x37, 0x37, 0x35, 0x64, 0x34, 0x34, 0x33, 0x39, 0x33, 0x64, 0x34, 0x37, 0x35, 0x33, 0x37, 0x32, 0x33, 0x37, 0x33, 0x39, 0x35, 0x66, 0x61, 0x37, 0x37, 0x61, 0x34, 0x31, 0x39, 0x30, 0x31, 0x39, 0x37, 0x37, 0x64, 0x30, 0x61, 0x34, 0x38, 0x30, 0x32, 0x37, 0x64, 0x65, 0x39, 0x36, 0x34, 0x35, 0x63, 0x39, 0x36, 0x39, 0x66, 0x62, 0x63, 0x32, 0x31, 0x34, 0x34, 0x38, 0x32, 0x39, 0x64, 0x61, 0x38, 0x62, 0x64, 0x38, 0x36, 0x38, 0x64, 0x39, 0x32, 0x38, 0x30, 0x38, 0x62, 0x34, 0x37, 0x32, 0x64, 0x61, 0x39, 0x32, 0x34, 0x62, 0x37, 0x35, 0x37, 0x63, 0x38, 0x36, 0x65, 0x61, 0x39, 0x36, 0x64, 0x36, 0x39, 0x63, 0x31, 0x37, 0x63, 0x32, 0x30, 0x62, 0x64, 0x38, 0x35, 0x65, 0x63, 0x36, 0x63, 0x65, 0x33, 0x34, 0x36, 0x35, 0x32, 0x31, 0x38, 0x39, 0x64, 0x34, 0x31, 0x36, 0x30, 0x34, 0x66, 0x39, 0x33, 0x39, 0x38, 0x64, 0x63, 0x35, 0x35, 0x35, 0x63, 0x65, 0x37, 0x62, 0x37, 0x32, 0x35, 0x64, 0x65, 0x66, 0x33, 0x37, 0x33, 0x65, 0x39, 0x62, 0x61, 0x33, 0x61, 0x62, 0x62, 0x62, 0x63, 0x38, 0x66, 0x36, 0x61, 0x36, 0x33, 0x33, 0x37, 0x62, 0x64, 0x32, 0x37, 0x33, 0x33, 0x30, 0x39, 0x32, 0x30, 0x36, 0x39, 0x37, 0x33, 0x39, 0x37, 0x39, 0x64, 0x63, 0x64, 0x38, 0x65, 0x37, 0x36, 0x35, 0x65, 0x30, 0x31, 0x37, 0x31, 0x34, 0x33, 0x32, 0x66, 0x33, 0x32, 0x33, 0x30, 0x35, 0x62, 0x33, 0x61, 0x31, 0x62, 0x30, 0x30, 0x30, 0x66, 0x32, 0x64, 0x63, 0x38, 0x39, 0x39, 0x62, 0x32, 0x39, 0x61, 0x33, 0x61, 0x32, 0x31, 0x39, 0x35, 0x64, 0x64, 0x33, 0x61, 0x38, 0x61, 0x64, 0x65, 0x39, 0x65, 0x33, 0x62, 0x39, 0x36, 0x32, 0x30, 0x31, 0x30, 0x64, 0x31, 0x32, 0x34, 0x30, 0x39, 0x62, 0x65, 0x61, 0x34, 0x31, 0x31, 0x31, 0x63, 0x35, 0x38, 0x63, 0x33, 0x33, 0x37, 0x32, 0x31, 0x66, 0x65, 0x66, 0x33, 0x34, 0x62, 0x63, 0x34, 0x30, 0x30, 0x37, 0x61, 0x34, 0x64, 0x38, 0x33, 0x34, 0x30, 0x62, 0x65, 0x31, 0x63, 0x31, 0x35, 0x31, 0x64, 0x30, 0x61, 0x30, 0x35, 0x66, 0x65, 0x37, 0x38, 0x63, 0x31, 0x63, 0x66, 0x38, 0x38, 0x34, 0x62, 0x61, 0x61, 0x65, 0x38, 0x64, 0x32, 0x39, 0x34, 0x35, 0x32, 0x65, 0x32, 0x64, 0x64, 0x36, 0x35, 0x31, 0x62, 0x36, 0x32, 0x31, 0x35, 0x32, 0x31, 0x61, 0x35, 0x61, 0x62, 0x34, 0x63, 0x66, 0x63, 0x34, 0x65, 0x35, 0x36, 0x35, 0x33, 0x64, 0x36, 0x63, 0x65, 0x38, 0x37, 0x30, 0x39, 0x31, 0x66, 0x65, 0x35, 0x65, 0x30, 0x32, 0x34, 0x32, 0x39, 0x32, 0x37, 0x35, 0x62, 0x34, 0x35, 0x38, 0x63, 0x37, 0x36, 0x37, 0x30, 0x34, 0x39, 0x30, 0x62, 0x66, 0x31, 0x61, 0x62, 0x64, 0x65, 0x30, 0x65, 0x62, 0x64, 0x30, 0x35, 0x39, 0x38, 0x33, 0x62, 0x63, 0x31, 0x64, 0x65, 0x31, 0x66, 0x30, 0x31, 0x65, 0x34, 0x36, 0x66, 0x65, 0x62, 0x34, 0x38, 0x39, 0x32, 0x62, 0x61, 0x30, 0x31, 0x36, 0x63, 0x33, 0x63, 0x61, 0x38, 0x64, 0x37, 0x32, 0x66, 0x38, 0x33, 0x33, 0x61, 0x37, 0x62, 0x31, 0x61, 0x39, 0x35, 0x66, 0x38, 0x35, 0x61, 0x30, 0x34, 0x32, 0x66, 0x33, 0x39, 0x63, 0x32, 0x39, 0x36, 0x66, 0x36, 0x65, 0x37, 0x32, 0x61, 0x34, 0x62, 0x30, 0x32, 0x32, 0x37, 0x30, 0x61, 0x34, 0x37, 0x30, 0x36, 0x37, 0x35, 0x38, 0x32, 0x64, 0x30, 0x34, 0x65, 0x36, 0x32, 0x61, 0x31, 0x34, 0x33, 0x63, 0x30, 0x35, 0x62, 0x38, 0x63, 0x30, 0x37, 0x30, 0x65, 0x31, 0x31, 0x32, 0x38, 0x35, 0x63, 0x38, 0x37, 0x30, 0x61, 0x32, 0x35, 0x30, 0x61, 0x32, 0x64, 0x38, 0x35, 0x62, 0x36, 0x65, 0x34, 0x63, 0x37, 0x35, 0x37, 0x32, 0x37, 0x31, 0x36, 0x64, 0x39, 0x62, 0x33, 0x61, 0x66, 0x34, 0x34, 0x65, 0x66, 0x34, 0x64, 0x39, 0x37, 0x65, 0x31, 0x33, 0x64, 0x32, 0x37, 0x36, 0x65, 0x30, 0x65, 0x62, 0x33, 0x33, 0x65, 0x65, 0x66, 0x30, 0x37, 0x66, 0x36, 0x30, 0x32, 0x65, 0x33, 0x33, 0x35, 0x32, 0x66, 0x30, 0x62, 0x36, 0x30, 0x31, 0x39, 0x35, 0x35, 0x64, 0x35, 0x61, 0x37, 0x62, 0x36, 0x63, 0x61, 0x64, 0x37, 0x32, 0x32, 0x66, 0x36, 0x32, 0x64, 0x65, 0x38, 0x61, 0x34, 0x39, 0x32, 0x66, 0x30, 0x38, 0x65, 0x34, 0x35, 0x37, 0x36, 0x38, 0x64, 0x35, 0x65, 0x35, 0x31, 0x30, 0x36, 0x66, 0x37, 0x38, 0x61, 0x66, 0x64, 0x39, 0x32, 0x31, 0x64, 0x65, 0x66, 0x38, 0x61, 0x32, 0x39, 0x62, 0x34, 0x34, 0x30, 0x66, 0x66, 0x64, 0x35, 0x33, 0x62, 0x63, 0x31, 0x34, 0x32, 0x31, 0x31, 0x62, 0x33, 0x30, 0x35, 0x32, 0x62, 0x64, 0x65, 0x33, 0x33, 0x36, 0x63, 0x65, 0x37, 0x38, 0x64, 0x38, 0x33, 0x63, 0x38, 0x37, 0x35, 0x64, 0x31, 0x63, 0x31, 0x31, 0x37, 0x36, 0x39, 0x36, 0x64, 0x32, 0x32, 0x39, 0x37, 0x65, 0x65, 0x31, 0x33, 0x39, 0x38, 0x32, 0x65, 0x39, 0x33, 0x35, 0x64, 0x39, 0x33, 0x66, 0x33, 0x31, 0x39, 0x33, 0x37, 0x39, 0x66, 0x31, 0x32, 0x38, 0x31, 0x30, 0x30, 0x37, 0x61, 0x31, 0x37, 0x32, 0x33, 0x36, 0x33, 0x65, 0x33, 0x64, 0x33, 0x33, 0x31, 0x66, 0x39, 0x61, 0x32, 0x39, 0x39, 0x35, 0x64, 0x36, 0x66, 0x39, 0x30, 0x35, 0x38, 0x31, 0x65, 0x39, 0x33, 0x36, 0x32, 0x39, 0x33, 0x32, 0x31, 0x33, 0x65, 0x38, 0x30, 0x37, 0x35, 0x37, 0x37, 0x39, 0x39, 0x36, 0x34, 0x32, 0x61, 0x37, 0x65, 0x39, 0x61, 0x32, 0x65, 0x36, 0x30, 0x64, 0x66, 0x30, 0x31, 0x34, 0x66, 0x37, 0x37, 0x32, 0x30, 0x32, 0x39, 0x61, 0x39, 0x31, 0x61, 0x37, 0x61, 0x39, 0x61, 0x38, 0x62, 0x33, 0x61, 0x66, 0x34, 0x38, 0x63, 0x35, 0x39, 0x33, 0x39, 0x61, 0x35, 0x35, 0x32, 0x61, 0x66, 0x35, 0x66, 0x35, 0x65, 0x61, 0x37, 0x31, 0x61, 0x37, 0x32, 0x39, 0x62, 0x35, 0x35, 0x36, 0x65, 0x64, 0x62, 0x36, 0x37, 0x63, 0x63, 0x32, 0x33, 0x36, 0x31, 0x31, 0x31, 0x30, 0x35, 0x64, 0x61, 0x37, 0x30, 0x30, 0x31, 0x37, 0x39, 0x33, 0x37, 0x63, 0x35, 0x62, 0x36, 0x63, 0x65, 0x38, 0x33, 0x39, 0x64, 0x63, 0x36, 0x63, 0x63, 0x66, 0x38, 0x34, 0x36, 0x33, 0x66, 0x36, 0x37, 0x63, 0x33, 0x66, 0x66, 0x63, 0x34, 0x34, 0x65, 0x30, 0x64, 0x38, 0x31, 0x34, 0x33, 0x62, 0x38, 0x38, 0x34, 0x37, 0x32, 0x32, 0x30, 0x30, 0x33, 0x34, 0x62, 0x37, 0x63, 0x35, 0x32, 0x61, 0x32, 0x34, 0x33, 0x61, 0x37, 0x32, 0x39, 0x34, 0x61, 0x34, 0x37, 0x66, 0x39, 0x31, 0x39, 0x37, 0x64, 0x64, 0x31, 0x62, 0x65, 0x61, 0x36, 0x64, 0x30, 0x62, 0x32, 0x66, 0x61, 0x63, 0x32, 0x36, 0x30, 0x62, 0x31, 0x61, 0x38, 0x33, 0x62, 0x34, 0x62, 0x66, 0x33, 0x35, 0x31, 0x33, 0x30, 0x62, 0x37, 0x33, 0x39, 0x31, 0x61, 0x62, 0x35, 0x36, 0x37, 0x30, 0x32, 0x65, 0x63, 0x34, 0x61, 0x61, 0x39, 0x31, 0x39, 0x31, 0x37, 0x32, 0x66, 0x32, 0x30, 0x33, 0x65, 0x61, 0x31, 0x32, 0x66, 0x38, 0x64, 0x38, 0x62, 0x66, 0x66, 0x35, 0x63, 0x66, 0x63, 0x39, 0x64, 0x66, 0x37, 0x31, 0x32, 0x34, 0x63, 0x30, 0x64, 0x31, 0x30, 0x34, 0x33, 0x35, 0x62, 0x34, 0x36, 0x32, 0x62, 0x62, 0x31, 0x66, 0x66, 0x30, 0x62, 0x35, 0x63, 0x39, 0x35, 0x33, 0x65, 0x65, 0x61, 0x38, 0x32, 0x61, 0x31, 0x64, 0x33, 0x66, 0x30, 0x63, 0x34, 0x33, 0x66, 0x33, 0x33, 0x35, 0x39, 0x34, 0x37, 0x66, 0x65, 0x66, 0x37, 0x66, 0x63, 0x63, 0x64, 0x65, 0x66, 0x65, 0x30, 0x38, 0x32, 0x39, 0x63, 0x30, 0x31, 0x33, 0x31, 0x39, 0x34, 0x38, 0x31, 0x36, 0x61, 0x31, 0x61, 0x64, 0x61, 0x34, 0x31, 0x32, 0x31, 0x37, 0x34, 0x38, 0x32, 0x64, 0x31, 0x64, 0x31, 0x38, 0x35, 0x36, 0x31, 0x38, 0x38, 0x38, 0x66, 0x66, 0x37, 0x63, 0x33, 0x63, 0x31, 0x35, 0x62, 0x32, 0x37, 0x65, 0x31, 0x32, 0x33, 0x66, 0x37, 0x64, 0x32, 0x62, 0x34, 0x34, 0x63, 0x66, 0x37, 0x39, 0x65, 0x33, 0x34, 0x61, 0x62, 0x30, 0x62, 0x63, 0x32, 0x34, 0x30, 0x66, 0x38, 0x64, 0x62, 0x38, 0x64, 0x64, 0x39, 0x63, 0x31, 0x66, 0x31, 0x35, 0x33, 0x61, 0x64, 0x36, 0x30, 0x61, 0x37, 0x66, 0x30, 0x39, 0x33, 0x64, 0x35, 0x31, 0x61, 0x32, 0x61, 0x31, 0x66, 0x37, 0x31, 0x30, 0x33, 0x37, 0x32, 0x31, 0x64, 0x37, 0x34, 0x33, 0x61, 0x34, 0x32, 0x30, 0x33, 0x30, 0x34, 0x65, 0x35, 0x66, 0x39, 0x64, 0x30, 0x33, 0x36, 0x63, 0x66, 0x64, 0x66, 0x37, 0x39, 0x65, 0x34, 0x38, 0x30, 0x31, 0x35, 0x37, 0x63, 0x62, 0x61, 0x63, 0x34, 0x34, 0x61, 0x30, 0x32, 0x61, 0x30, 0x31, 0x64, 0x34, 0x61, 0x63, 0x61, 0x36, 0x38, 0x38, 0x37, 0x30, 0x61, 0x35, 0x32, 0x39, 0x37, 0x32, 0x31, 0x38, 0x65, 0x62, 0x33, 0x63, 0x38, 0x35, 0x32, 0x33, 0x31, 0x35, 0x39, 0x33, 0x62, 0x33, 0x63, 0x64, 0x64, 0x37, 0x32, 0x62, 0x33, 0x31, 0x35, 0x38, 0x35, 0x62, 0x65, 0x33, 0x36, 0x39, 0x63, 0x66, 0x65, 0x32, 0x37, 0x62, 0x32, 0x33, 0x61, 0x31, 0x64, 0x30, 0x64, 0x38, 0x35, 0x36, 0x65, 0x32, 0x32, 0x30, 0x30, 0x36, 0x31, 0x39, 0x31, 0x31, 0x64, 0x33, 0x38, 0x61, 0x35, 0x38, 0x35, 0x31, 0x61, 0x34, 0x65, 0x35, 0x31, 0x38, 0x33, 0x39, 0x61, 0x62, 0x39, 0x64, 0x32, 0x30, 0x63, 0x64, 0x39, 0x35, 0x33, 0x34, 0x35, 0x33, 0x66, 0x36, 0x31, 0x30, 0x31, 0x39, 0x64, 0x33, 0x34, 0x30, 0x64, 0x63, 0x33, 0x33, 0x66, 0x31, 0x34, 0x30, 0x33, 0x39, 0x39, 0x64, 0x34, 0x34, 0x31, 0x64, 0x64, 0x62, 0x38, 0x31, 0x62, 0x33, 0x65, 0x37, 0x37, 0x30, 0x31, 0x35, 0x37, 0x32, 0x39, 0x61, 0x65, 0x33, 0x38, 0x65, 0x34, 0x34, 0x33, 0x36, 0x31, 0x35, 0x33, 0x38, 0x64, 0x36, 0x35, 0x32, 0x65, 0x38, 0x38, 0x35, 0x62, 0x35, 0x38, 0x65, 0x39, 0x65, 0x31, 0x66, 0x39, 0x30, 0x61, 0x34, 0x64, 0x31, 0x34, 0x36, 0x39, 0x36, 0x38, 0x32, 0x36, 0x37, 0x66, 0x30, 0x35, 0x34, 0x30, 0x66, 0x66, 0x38, 0x36, 0x66, 0x64, 0x39, 0x65, 0x33, 0x36, 0x66, 0x30, 0x61, 0x37, 0x32, 0x37, 0x35, 0x32, 0x66, 0x34, 0x64, 0x66, 0x39, 0x33, 0x61, 0x39, 0x31, 0x37, 0x33, 0x36, 0x36, 0x32, 0x36, 0x30, 0x62, 0x31, 0x32, 0x32, 0x66, 0x37, 0x37, 0x64, 0x39, 0x65, 0x31, 0x30, 0x65, 0x38, 0x30, 0x35, 0x38, 0x63, 0x32, 0x38, 0x31, 0x61, 0x65, 0x63, 0x36, 0x62, 0x34, 0x30, 0x31, 0x32, 0x65, 0x36, 0x63, 0x32, 0x30, 0x36, 0x35, 0x62, 0x62, 0x65, 0x36, 0x33, 0x35, 0x37, 0x32, 0x30, 0x31, 0x38, 0x31, 0x35, 0x37, 0x39, 0x62, 0x34, 0x30, 0x31, 0x34, 0x30, 0x62, 0x65, 0x30, 0x30, 0x36, 0x32, 0x62, 0x62, 0x63, 0x66, 0x32, 0x38, 0x33, 0x33, 0x33, 0x65, 0x62, 0x35, 0x35, 0x36, 0x63, 0x38, 0x36, 0x33, 0x35, 0x38, 0x30, 0x38, 0x64, 0x63, 0x62, 0x35, 0x61, 0x34, 0x34, 0x65, 0x66, 0x31, 0x34, 0x31, 0x39, 0x64, 0x38, 0x34, 0x32, 0x39, 0x36, 0x38, 0x37, 0x34, 0x63, 0x63, 0x65, 0x37, 0x62, 0x33, 0x64, 0x32, 0x31, 0x33, 0x62, 0x37, 0x35, 0x33, 0x65, 0x34, 0x35, 0x64, 0x31, 0x37, 0x62, 0x37, 0x36, 0x66, 0x64, 0x66, 0x38, 0x65, 0x64, 0x37, 0x62, 0x66, 0x39, 0x31, 0x38, 0x37, 0x32, 0x36, 0x34, 0x31, 0x32, 0x38, 0x64, 0x64, 0x61, 0x62, 0x62, 0x37, 0x37, 0x33, 0x30, 0x39, 0x62, 0x34, 0x31, 0x64, 0x30, 0x36, 0x62, 0x33, 0x35, 0x30, 0x36, 0x37, 0x32, 0x65, 0x39, 0x33, 0x38, 0x30, 0x33, 0x35, 0x35, 0x61, 0x62, 0x34, 0x34, 0x65, 0x38, 0x64, 0x36, 0x31, 0x37, 0x63, 0x35, 0x39, 0x39, 0x32, 0x32, 0x30, 0x32, 0x66, 0x35, 0x32, 0x34, 0x30, 0x33, 0x31, 0x62, 0x34, 0x62, 0x63, 0x66, 0x32, 0x32, 0x63, 0x39, 0x36, 0x62, 0x36, 0x64, 0x62, 0x65, 0x33, 0x38, 0x38, 0x36, 0x66, 0x36, 0x62, 0x35, 0x63, 0x66, 0x31, 0x35, 0x63, 0x66, 0x32, 0x33, 0x36, 0x63, 0x36, 0x64, 0x65, 0x30, 0x61, 0x65, 0x63, 0x61, 0x30, 0x34, 0x61, 0x64, 0x64, 0x36, 0x62, 0x37, 0x30, 0x62, 0x38, 0x31, 0x62, 0x30, 0x32, 0x35, 0x36, 0x39, 0x61, 0x39, 0x38, 0x61, 0x63, 0x33, 0x65, 0x64, 0x32, 0x63, 0x36, 0x66, 0x66, 0x62, 0x36, 0x63, 0x35, 0x38, 0x33, 0x37, 0x31, 0x64, 0x61, 0x65, 0x65, 0x31, 0x64, 0x62, 0x31, 0x65, 0x30, 0x36, 0x34, 0x39, 0x36, 0x62, 0x32, 0x62, 0x35, 0x37, 0x34, 0x36, 0x30, 0x63, 0x65, 0x65, 0x36, 0x63, 0x30, 0x62, 0x35, 0x35, 0x32, 0x36, 0x62, 0x37, 0x64, 0x34, 0x38, 0x65, 0x32, 0x37, 0x63, 0x33, 0x63, 0x66, 0x37, 0x66, 0x65, 0x30, 0x32, 0x66, 0x61, 0x61, 0x66, 0x62, 0x64, 0x39, 0x39, 0x65, 0x63, 0x36, 0x36, 0x36, 0x30, 0x37, 0x64, 0x38, 0x65, 0x62, 0x39, 0x62, 0x64, 0x36, 0x39, 0x65, 0x63, 0x65, 0x34, 0x31, 0x35, 0x35, 0x62, 0x39, 0x36, 0x64, 0x36, 0x66, 0x36, 0x63, 0x66, 0x37, 0x34, 0x30, 0x63, 0x30, 0x33, 0x35, 0x33, 0x64, 0x33, 0x38, 0x66, 0x65, 0x35, 0x64, 0x63, 0x37, 0x65, 0x61, 0x34, 0x65, 0x62, 0x37, 0x34, 0x66, 0x39, 0x63, 0x63, 0x32, 0x65, 0x35, 0x39, 0x34, 0x38, 0x32, 0x65, 0x35, 0x63, 0x33, 0x39, 0x61, 0x39, 0x61, 0x61, 0x63, 0x64, 0x36, 0x61, 0x38, 0x38, 0x39, 0x33, 0x64, 0x66, 0x37, 0x30, 0x38, 0x38, 0x33, 0x39, 0x32, 0x38, 0x38, 0x61, 0x36, 0x34, 0x33, 0x65, 0x66, 0x30, 0x65, 0x64, 0x31, 0x37, 0x62, 0x35, 0x32, 0x33, 0x33, 0x30, 0x38, 0x38, 0x30, 0x66, 0x38, 0x65, 0x37, 0x63, 0x66, 0x30, 0x37, 0x34, 0x34, 0x61, 0x63, 0x64, 0x39, 0x32, 0x35, 0x34, 0x65, 0x61, 0x63, 0x62, 0x64, 0x36, 0x34, 0x34, 0x65, 0x34, 0x63, 0x31, 0x63, 0x32, 0x33, 0x37, 0x32, 0x34, 0x33, 0x37, 0x61, 0x64, 0x34, 0x36, 0x36, 0x33, 0x31, 0x66, 0x31, 0x65, 0x35, 0x66, 0x32, 0x34, 0x64, 0x34, 0x30, 0x30, 0x64, 0x64, 0x64, 0x62, 0x36, 0x66, 0x30, 0x34, 0x32, 0x30, 0x34, 0x66, 0x36, 0x61, 0x32, 0x37, 0x33, 0x64, 0x31, 0x30, 0x33, 0x61, 0x39, 0x38, 0x30, 0x33, 0x32, 0x62, 0x34, 0x30, 0x62, 0x35, 0x38, 0x66, 0x66, 0x63, 0x37, 0x61, 0x37, 0x65, 0x38, 0x33, 0x61, 0x63, 0x39, 0x36, 0x30, 0x64, 0x32, 0x65, 0x64, 0x34, 0x38, 0x39, 0x32, 0x31, 0x32, 0x63, 0x61, 0x61, 0x64, 0x36, 0x37, 0x34, 0x66, 0x66, 0x38, 0x63, 0x65, 0x65, 0x63, 0x63, 0x37, 0x34, 0x63, 0x35, 0x38, 0x64, 0x62, 0x35, 0x66, 0x35, 0x62, 0x37, 0x35, 0x63, 0x33, 0x30, 0x38, 0x65, 0x38, 0x32, 0x39, 0x66, 0x31, 0x38, 0x34, 0x63, 0x34, 0x30, 0x39, 0x65, 0x64, 0x31, 0x38, 0x36, 0x35, 0x65, 0x33, 0x66, 0x39, 0x36, 0x34, 0x63, 0x31, 0x62, 0x30, 0x36, 0x62, 0x62, 0x38, 0x38, 0x39, 0x63, 0x64, 0x66, 0x36, 0x31, 0x38, 0x33, 0x63, 0x32, 0x33, 0x61, 0x64, 0x35, 0x35, 0x33, 0x35, 0x61, 0x32, 0x33, 0x32, 0x39, 0x63, 0x34, 0x37, 0x35, 0x32, 0x62, 0x31, 0x36, 0x37, 0x32, 0x31, 0x63, 0x31, 0x61, 0x39, 0x39, 0x33, 0x35, 0x65, 0x62, 0x32, 0x62, 0x39, 0x64, 0x66, 0x32, 0x39, 0x61, 0x37, 0x37, 0x34, 0x31, 0x66, 0x61, 0x64, 0x38, 0x31, 0x39, 0x62, 0x66, 0x61, 0x31, 0x32, 0x64, 0x32, 0x65, 0x65, 0x33, 0x62, 0x39, 0x39, 0x35, 0x34, 0x36, 0x31, 0x39, 0x39, 0x37, 0x62, 0x64, 0x66, 0x66, 0x39, 0x32, 0x38, 0x36, 0x64, 0x34, 0x33, 0x30, 0x65, 0x33, 0x39, 0x38, 0x35, 0x63, 0x32, 0x63, 0x30, 0x32, 0x63, 0x35, 0x35, 0x61, 0x63, 0x36, 0x36, 0x33, 0x32, 0x35, 0x35, 0x61, 0x34, 0x35, 0x64, 0x61, 0x63, 0x38, 0x33, 0x64, 0x63, 0x65, 0x63, 0x37, 0x38, 0x31, 0x37, 0x35, 0x30, 0x32, 0x32, 0x39, 0x64, 0x63, 0x66, 0x39, 0x34, 0x63, 0x31, 0x64, 0x38, 0x66, 0x39, 0x61, 0x39, 0x30, 0x62, 0x61, 0x66, 0x65, 0x63, 0x62, 0x64, 0x65, 0x30, 0x33, 0x61, 0x34, 0x64, 0x30, 0x66, 0x61, 0x36, 0x63, 0x38, 0x32, 0x33, 0x31, 0x35, 0x30, 0x36, 0x36, 0x62, 0x37, 0x32, 0x63, 0x33, 0x31, 0x33, 0x33, 0x64, 0x38, 0x30, 0x37, 0x34, 0x34, 0x37, 0x39, 0x38, 0x36, 0x65, 0x66, 0x37, 0x66, 0x34, 0x34, 0x63, 0x32, 0x66, 0x64, 0x35, 0x62, 0x63, 0x62, 0x37, 0x65, 0x34, 0x64, 0x36, 0x66, 0x32, 0x66, 0x33, 0x65, 0x38, 0x32, 0x31, 0x66, 0x32, 0x61, 0x32, 0x62, 0x34, 0x62, 0x33, 0x31, 0x30, 0x66, 0x34, 0x61, 0x64, 0x31, 0x38, 0x34, 0x65, 0x34, 0x30, 0x35, 0x30, 0x37, 0x66, 0x64, 0x38, 0x35, 0x33, 0x33, 0x34, 0x31, 0x36, 0x65, 0x65, 0x65, 0x36, 0x61, 0x66, 0x64, 0x39, 0x35, 0x61, 0x37, 0x35, 0x34, 0x32, 0x62, 0x63, 0x34, 0x62, 0x66, 0x39, 0x30, 0x65, 0x61, 0x35, 0x65, 0x37, 0x36, 0x37, 0x36, 0x39, 0x64, 0x65, 0x66, 0x30, 0x36, 0x63, 0x66, 0x31, 0x33, 0x30, 0x33, 0x65, 0x62, 0x37, 0x32, 0x62, 0x63, 0x63, 0x37, 0x32, 0x61, 0x37, 0x33, 0x63, 0x31, 0x32, 0x33, 0x31, 0x61, 0x62, 0x31, 0x31, 0x66, 0x61, 0x31, 0x36, 0x38, 0x65, 0x62, 0x30, 0x65, 0x39, 0x35, 0x64, 0x31, 0x32, 0x38, 0x34, 0x36, 0x64, 0x61, 0x61, 0x61, 0x35, 0x39, 0x31, 0x33, 0x61, 0x63, 0x65, 0x34, 0x39, 0x65, 0x36, 0x37, 0x30, 0x66, 0x64, 0x38, 0x32, 0x61, 0x36, 0x61, 0x38, 0x31, 0x35, 0x34, 0x30, 0x32, 0x33, 0x39, 0x62, 0x38, 0x63, 0x33, 0x64, 0x37, 0x32, 0x33, 0x65, 0x61, 0x66, 0x37, 0x34, 0x63, 0x37, 0x32, 0x61, 0x32, 0x61, 0x62, 0x32, 0x65, 0x65, 0x33, 0x34, 0x64, 0x66, 0x34, 0x35, 0x65, 0x33, 0x66, 0x62, 0x34, 0x35, 0x37, 0x32, 0x63, 0x34, 0x30, 0x36, 0x64, 0x62, 0x32, 0x64, 0x39, 0x37, 0x32, 0x36, 0x31, 0x33, 0x35, 0x37, 0x62, 0x35, 0x31, 0x34, 0x35, 0x30, 0x39, 0x66, 0x64, 0x30, 0x34, 0x65, 0x36, 0x39, 0x33, 0x32, 0x36, 0x34, 0x33, 0x65, 0x36, 0x64, 0x30, 0x36, 0x34, 0x63, 0x61, 0x37, 0x32, 0x65, 0x37, 0x66, 0x66, 0x62, 0x36, 0x62, 0x31, 0x36, 0x30, 0x36, 0x63, 0x62, 0x35, 0x62, 0x34, 0x30, 0x61, 0x66, 0x36, 0x36, 0x31, 0x62, 0x38, 0x66, 0x33, 0x32, 0x64, 0x37, 0x30, 0x36, 0x36, 0x65, 0x36, 0x38, 0x30, 0x39, 0x62, 0x34, 0x33, 0x62, 0x37, 0x63, 0x64, 0x61, 0x61, 0x64, 0x32, 0x37, 0x32, 0x62, 0x37, 0x32, 0x36, 0x62, 0x33, 0x37, 0x31, 0x34, 0x65, 0x35, 0x32, 0x37, 0x35, 0x35, 0x62, 0x34, 0x61, 0x64, 0x34, 0x30, 0x32, 0x37, 0x30, 0x30, 0x38, 0x30, 0x61, 0x35, 0x37, 0x65, 0x65, 0x35, 0x38, 0x34, 0x39, 0x64, 0x32, 0x33, 0x64, 0x62, 0x38, 0x37, 0x61, 0x63, 0x32, 0x33, 0x39, 0x65, 0x37, 0x39, 0x66, 0x61, 0x37, 0x35, 0x31, 0x30, 0x39, 0x30, 0x63, 0x62, 0x32, 0x31, 0x61, 0x65, 0x31, 0x61, 0x38, 0x31, 0x30, 0x65, 0x65, 0x37, 0x33, 0x31, 0x38, 0x30, 0x61, 0x33, 0x34, 0x63, 0x63, 0x33, 0x37, 0x36, 0x61, 0x30, 0x30, 0x62, 0x61, 0x31, 0x63, 0x32, 0x31, 0x39, 0x31, 0x35, 0x37, 0x38, 0x38, 0x36, 0x61, 0x36, 0x32, 0x66, 0x64, 0x32, 0x32, 0x31, 0x36, 0x30, 0x61, 0x38, 0x62, 0x32, 0x65, 0x30, 0x61, 0x39, 0x37, 0x37, 0x64, 0x64, 0x34, 0x35, 0x35, 0x37, 0x39, 0x34, 0x36, 0x33, 0x61, 0x34, 0x65, 0x64, 0x33, 0x64, 0x31, 0x34, 0x39, 0x36, 0x66, 0x39, 0x38, 0x63, 0x66, 0x61, 0x31, 0x63, 0x35, 0x34, 0x33, 0x39, 0x61, 0x38, 0x35, 0x66, 0x65, 0x61, 0x31, 0x66, 0x65, 0x61, 0x65, 0x31, 0x30, 0x61, 0x36, 0x30, 0x31, 0x62, 0x31, 0x31, 0x33, 0x31, 0x63, 0x38, 0x30, 0x38, 0x65, 0x31, 0x30, 0x38, 0x38, 0x39, 0x32, 0x65, 0x35, 0x66, 0x38, 0x35, 0x64, 0x31, 0x37, 0x32, 0x39, 0x31, 0x39, 0x38, 0x63, 0x62, 0x31, 0x63, 0x39, 0x39, 0x35, 0x32, 0x39, 0x36, 0x35, 0x34, 0x37, 0x33, 0x62, 0x66, 0x37, 0x33, 0x33, 0x65, 0x37, 0x35, 0x34, 0x62, 0x61, 0x36, 0x30, 0x35, 0x30, 0x35, 0x61, 0x65, 0x35, 0x38, 0x33, 0x33, 0x39, 0x39, 0x33, 0x65, 0x39, 0x36, 0x30, 0x31, 0x32, 0x63, 0x66, 0x39, 0x62, 0x31, 0x39, 0x35, 0x32, 0x39, 0x33, 0x31, 0x30, 0x36, 0x37, 0x32, 0x35, 0x66, 0x38, 0x64, 0x39, 0x61, 0x34, 0x39, 0x33, 0x34, 0x64, 0x38, 0x62, 0x37, 0x64, 0x34, 0x33, 0x33, 0x34, 0x35, 0x61, 0x36, 0x37, 0x37, 0x65, 0x36, 0x36, 0x32, 0x32, 0x35, 0x39, 0x33, 0x66, 0x65, 0x36, 0x30, 0x66, 0x33, 0x61, 0x32, 0x32, 0x32, 0x36, 0x66, 0x64, 0x31, 0x61, 0x37, 0x30, 0x32, 0x63, 0x37, 0x62, 0x39, 0x36, 0x35, 0x30, 0x35, 0x61, 0x35, 0x66, 0x33, 0x32, 0x30, 0x63, 0x31, 0x31, 0x34, 0x62, 0x35, 0x61, 0x65, 0x33, 0x33, 0x38, 0x38, 0x39, 0x61, 0x33, 0x64, 0x62, 0x38, 0x38, 0x36, 0x61, 0x34, 0x65, 0x31, 0x37, 0x65, 0x36, 0x39, 0x30, 0x65, 0x34, 0x31, 0x33, 0x62, 0x33, 0x66, 0x33, 0x32, 0x66, 0x31, 0x39, 0x63, 0x31, 0x34, 0x61, 0x65, 0x62, 0x33, 0x33, 0x61, 0x65, 0x36, 0x37, 0x38, 0x35, 0x32, 0x62, 0x63, 0x38, 0x39, 0x35, 0x38, 0x32, 0x33, 0x31, 0x36, 0x38, 0x38, 0x31, 0x35, 0x63, 0x34, 0x36, 0x36, 0x30, 0x33, 0x35, 0x32, 0x61, 0x31, 0x37, 0x37, 0x34, 0x61, 0x38, 0x66, 0x35, 0x33, 0x37, 0x38, 0x63, 0x38, 0x62, 0x36, 0x64, 0x36, 0x63, 0x33, 0x66, 0x65, 0x38, 0x39, 0x66, 0x37, 0x36, 0x64, 0x66, 0x63, 0x63, 0x64, 0x37, 0x38, 0x34, 0x35, 0x35, 0x37, 0x66, 0x36, 0x34, 0x35, 0x64, 0x65, 0x63, 0x65, 0x31, 0x39, 0x34, 0x36, 0x31, 0x36, 0x38, 0x61, 0x66, 0x39, 0x66, 0x65, 0x64, 0x31, 0x35, 0x61, 0x33, 0x30, 0x31, 0x61, 0x32, 0x62, 0x31, 0x63, 0x34, 0x63, 0x39, 0x62, 0x37, 0x66, 0x33, 0x30, 0x39, 0x30, 0x32, 0x31, 0x35, 0x66, 0x35, 0x66, 0x64, 0x39, 0x38, 0x65, 0x65, 0x33, 0x35, 0x66, 0x63, 0x32, 0x63, 0x36, 0x33, 0x65, 0x32, 0x64, 0x61, 0x36, 0x39, 0x64, 0x34, 0x63, 0x36, 0x33, 0x62, 0x62, 0x37, 0x32, 0x32, 0x36, 0x61, 0x36, 0x34, 0x36, 0x30, 0x36, 0x32, 0x61, 0x62, 0x39, 0x34, 0x65, 0x66, 0x63, 0x38, 0x34, 0x35, 0x32, 0x37, 0x39, 0x31, 0x65, 0x62, 0x65, 0x63, 0x61, 0x31, 0x39, 0x30, 0x63, 0x66, 0x61, 0x65, 0x39, 0x35, 0x36, 0x33, 0x35, 0x30, 0x32, 0x66, 0x38, 0x39, 0x37, 0x34, 0x66, 0x30, 0x31, 0x35, 0x65, 0x61, 0x35, 0x34, 0x32, 0x30, 0x32, 0x37, 0x63, 0x65, 0x62, 0x37, 0x32, 0x35, 0x36, 0x65, 0x32, 0x37, 0x33, 0x62, 0x32, 0x63, 0x61, 0x65, 0x66, 0x61, 0x62, 0x36, 0x63, 0x30, 0x33, 0x38, 0x38, 0x66, 0x33, 0x39, 0x66, 0x37, 0x65, 0x62, 0x65, 0x63, 0x64, 0x38, 0x37, 0x35, 0x34, 0x36, 0x38, 0x31, 0x64, 0x37, 0x65, 0x30, 0x37, 0x62, 0x31, 0x36, 0x38, 0x66, 0x37, 0x36, 0x65, 0x33, 0x61, 0x65, 0x38, 0x32, 0x64, 0x34, 0x39, 0x34, 0x37, 0x38, 0x32, 0x37, 0x32, 0x37, 0x61, 0x37, 0x62, 0x62, 0x31, 0x35, 0x35, 0x32, 0x38, 0x33, 0x64, 0x31, 0x64, 0x63, 0x66, 0x61, 0x38, 0x36, 0x31, 0x37, 0x37, 0x33, 0x61, 0x62, 0x33, 0x32, 0x61, 0x31, 0x37, 0x65, 0x39, 0x39, 0x61, 0x32, 0x35, 0x35, 0x66, 0x30, 0x39, 0x33, 0x34, 0x64, 0x66, 0x36, 0x63, 0x64, 0x30, 0x36, 0x34, 0x37, 0x66, 0x39, 0x33, 0x37, 0x64, 0x64, 0x64, 0x32, 0x32, 0x38, 0x35, 0x37, 0x32, 0x63, 0x32, 0x30, 0x39, 0x63, 0x39, 0x63, 0x36, 0x30, 0x66, 0x30, 0x34, 0x61, 0x35, 0x36, 0x62, 0x61, 0x39, 0x31, 0x39, 0x66, 0x62, 0x35, 0x36, 0x63, 0x33, 0x38, 0x64, 0x37, 0x31, 0x64, 0x38, 0x35, 0x65, 0x38, 0x61, 0x32, 0x38, 0x66, 0x34, 0x65, 0x61, 0x39, 0x32, 0x36, 0x35, 0x61, 0x39, 0x36, 0x62, 0x38, 0x33, 0x39, 0x63, 0x34, 0x66, 0x32, 0x33, 0x32, 0x31, 0x39, 0x35, 0x37, 0x32, 0x62, 0x65, 0x64, 0x65, 0x31, 0x62, 0x63, 0x64, 0x31, 0x62, 0x35, 0x30, 0x38, 0x61, 0x66, 0x62, 0x37, 0x30, 0x38, 0x36, 0x30, 0x66, 0x66, 0x32, 0x61, 0x31, 0x32, 0x64, 0x61, 0x38, 0x61, 0x35, 0x31, 0x65, 0x66, 0x39, 0x37, 0x64, 0x65, 0x30, 0x63, 0x37, 0x35, 0x39, 0x64, 0x30, 0x34, 0x61, 0x65, 0x30, 0x30, 0x34, 0x32, 0x39, 0x33, 0x38, 0x62, 0x32, 0x35, 0x35, 0x31, 0x39, 0x37, 0x32, 0x37, 0x38, 0x66, 0x66, 0x37, 0x31, 0x38, 0x35, 0x35, 0x33, 0x32, 0x65, 0x63, 0x63, 0x31, 0x34, 0x36, 0x30, 0x38, 0x37, 0x33, 0x65, 0x32, 0x33, 0x39, 0x38, 0x63, 0x36, 0x63, 0x62, 0x66, 0x63, 0x38, 0x36, 0x61, 0x34, 0x64, 0x34, 0x35, 0x36, 0x63, 0x39, 0x35, 0x36, 0x61, 0x66, 0x66, 0x34, 0x39, 0x61, 0x32, 0x30, 0x33, 0x61, 0x38, 0x63, 0x32, 0x30, 0x62, 0x35, 0x34, 0x65, 0x35, 0x36, 0x34, 0x65, 0x62, 0x34, 0x65, 0x32, 0x65, 0x66, 0x35, 0x33, 0x33, 0x64, 0x36, 0x35, 0x30, 0x31, 0x32, 0x66, 0x30, 0x38, 0x63, 0x39, 0x36, 0x66, 0x34, 0x35, 0x30, 0x39, 0x31, 0x65, 0x37, 0x31, 0x66, 0x63, 0x35, 0x65, 0x38, 0x33, 0x33, 0x31, 0x66, 0x31, 0x39, 0x33, 0x62, 0x37, 0x32, 0x63, 0x35, 0x30, 0x37, 0x39, 0x37, 0x65, 0x66, 0x34, 0x31, 0x32, 0x36, 0x36, 0x34, 0x38, 0x37, 0x32, 0x37, 0x64, 0x39, 0x63, 0x31, 0x36, 0x32, 0x64, 0x66, 0x34, 0x34, 0x35, 0x66, 0x65, 0x38, 0x31, 0x65, 0x35, 0x33, 0x37, 0x66, 0x30, 0x63, 0x37, 0x35, 0x62, 0x39, 0x33, 0x36, 0x65, 0x33, 0x63, 0x39, 0x64, 0x65, 0x32, 0x38, 0x66, 0x32, 0x65, 0x61, 0x35, 0x38, 0x30, 0x38, 0x33, 0x62, 0x34, 0x62, 0x63, 0x63, 0x61, 0x35, 0x34, 0x34, 0x38, 0x31, 0x32, 0x39, 0x30, 0x32, 0x30, 0x37, 0x32, 0x32, 0x34, 0x36, 0x36, 0x37, 0x31, 0x66, 0x33, 0x32, 0x31, 0x65, 0x36, 0x62, 0x38, 0x35, 0x33, 0x36, 0x34, 0x39, 0x35, 0x39, 0x30, 0x35, 0x66, 0x65, 0x63, 0x31, 0x38, 0x37, 0x39, 0x65, 0x39, 0x64, 0x61, 0x30, 0x32, 0x37, 0x63, 0x39, 0x62, 0x66, 0x31, 0x32, 0x64, 0x65, 0x32, 0x31, 0x63, 0x38, 0x61, 0x62, 0x36, 0x37, 0x62, 0x30, 0x32, 0x65, 0x65, 0x63, 0x33, 0x61, 0x62, 0x37, 0x32, 0x38, 0x30, 0x32, 0x32, 0x35, 0x37, 0x64, 0x31, 0x64, 0x37, 0x38, 0x30, 0x37, 0x35, 0x30, 0x39, 0x64, 0x62, 0x34, 0x38, 0x66, 0x65, 0x36, 0x30, 0x61, 0x36, 0x37, 0x30, 0x65, 0x36, 0x38, 0x39, 0x63, 0x33, 0x36, 0x33, 0x34, 0x63, 0x37, 0x34, 0x32, 0x36, 0x64, 0x62, 0x37, 0x39, 0x34, 0x37, 0x63, 0x66, 0x63, 0x63, 0x33, 0x37, 0x62, 0x65, 0x39, 0x35, 0x62, 0x31, 0x34, 0x32, 0x32, 0x39, 0x39, 0x32, 0x31, 0x66, 0x33, 0x34, 0x32, 0x35, 0x64, 0x35, 0x66, 0x38, 0x31, 0x32, 0x33, 0x33, 0x37, 0x32, 0x62, 0x39, 0x66, 0x35, 0x34, 0x31, 0x38, 0x30, 0x32, 0x39, 0x64, 0x30, 0x34, 0x38, 0x33, 0x32, 0x61, 0x66, 0x39, 0x37, 0x35, 0x36, 0x32, 0x35, 0x38, 0x38, 0x33, 0x63, 0x37, 0x39, 0x30, 0x31, 0x38, 0x64, 0x37, 0x37, 0x62, 0x63, 0x63, 0x35, 0x33, 0x30, 0x39, 0x36, 0x37, 0x32, 0x65, 0x62, 0x64, 0x33, 0x64, 0x30, 0x30, 0x64, 0x38, 0x35, 0x31, 0x62, 0x61, 0x63, 0x32, 0x35, 0x37, 0x66, 0x66, 0x34, 0x65, 0x32, 0x65, 0x66, 0x34, 0x37, 0x37, 0x62, 0x35, 0x34, 0x32, 0x30, 0x33, 0x30, 0x64, 0x34, 0x62, 0x32, 0x61, 0x35, 0x32, 0x36, 0x35, 0x63, 0x65, 0x61, 0x30, 0x63, 0x63, 0x39, 0x34, 0x63, 0x34, 0x34, 0x63, 0x64, 0x63, 0x65, 0x62, 0x30, 0x36, 0x65, 0x33, 0x33, 0x35, 0x64, 0x38, 0x66, 0x32, 0x66, 0x37, 0x64, 0x63, 0x35, 0x30, 0x34, 0x61, 0x35, 0x65, 0x32, 0x30, 0x31, 0x62, 0x61, 0x63, 0x63, 0x37, 0x35, 0x38, 0x39, 0x61, 0x34, 0x62, 0x39, 0x39, 0x31, 0x37, 0x31, 0x36, 0x64, 0x35, 0x65, 0x39, 0x63, 0x35, 0x35, 0x63, 0x63, 0x63, 0x66, 0x38, 0x61, 0x30, 0x32, 0x31, 0x65, 0x33, 0x30, 0x38, 0x63, 0x64, 0x32, 0x64, 0x36, 0x34, 0x63, 0x37, 0x32, 0x66, 0x66, 0x34, 0x65, 0x38, 0x61, 0x66, 0x61, 0x34, 0x65, 0x32, 0x61, 0x38, 0x63, 0x37, 0x35, 0x33, 0x64, 0x65, 0x32, 0x64, 0x62, 0x61, 0x63, 0x66, 0x39, 0x61, 0x30, 0x63, 0x30, 0x38, 0x62, 0x36, 0x64, 0x64, 0x35, 0x66, 0x66, 0x32, 0x64, 0x35, 0x37, 0x64, 0x65, 0x64, 0x35, 0x35, 0x64, 0x62, 0x35, 0x33, 0x35, 0x36, 0x30, 0x66, 0x62, 0x61, 0x61, 0x66, 0x65, 0x62, 0x35, 0x37, 0x32, 0x37, 0x38, 0x64, 0x30, 0x33, 0x36, 0x63, 0x62, 0x65, 0x35, 0x38, 0x61, 0x32, 0x65, 0x61, 0x31, 0x37, 0x62, 0x33, 0x36, 0x33, 0x65, 0x33, 0x32, 0x64, 0x33, 0x39, 0x32, 0x64, 0x33, 0x62, 0x38, 0x30, 0x38, 0x38, 0x35, 0x39, 0x63, 0x30, 0x66, 0x62, 0x35, 0x30, 0x62, 0x39, 0x61, 0x61, 0x38, 0x30, 0x35, 0x30, 0x35, 0x37, 0x38, 0x35, 0x39, 0x63, 0x39, 0x64, 0x36, 0x61, 0x61, 0x37, 0x32, 0x61, 0x30, 0x38, 0x66, 0x66, 0x38, 0x61, 0x31, 0x31, 0x31, 0x30, 0x35, 0x34, 0x38, 0x33, 0x62, 0x32, 0x30, 0x65, 0x64, 0x66, 0x61, 0x30, 0x30, 0x36, 0x65, 0x61, 0x38, 0x35, 0x61, 0x39, 0x64, 0x35, 0x37, 0x36, 0x34, 0x36, 0x61, 0x62, 0x64, 0x66, 0x31, 0x65, 0x63, 0x38, 0x65, 0x66, 0x62, 0x35, 0x63, 0x65, 0x61, 0x31, 0x36, 0x37, 0x36, 0x63, 0x62, 0x39, 0x32, 0x37, 0x65, 0x32, 0x37, 0x33, 0x37, 0x38, 0x35, 0x37, 0x39, 0x66, 0x66, 0x36, 0x35, 0x38, 0x37, 0x38, 0x65, 0x35, 0x34, 0x34, 0x63, 0x62, 0x33, 0x34, 0x31, 0x34, 0x66, 0x30, 0x32, 0x64, 0x61, 0x62, 0x38, 0x61, 0x32, 0x64, 0x65, 0x66, 0x31, 0x32, 0x33, 0x61, 0x33, 0x62, 0x33, 0x33, 0x61, 0x64, 0x62, 0x62, 0x37, 0x64, 0x37, 0x39, 0x32, 0x65, 0x63, 0x39, 0x30, 0x62, 0x39, 0x63, 0x66, 0x35, 0x61, 0x30, 0x32, 0x62, 0x38, 0x37, 0x30, 0x39, 0x63, 0x61, 0x38, 0x32, 0x38, 0x63, 0x38, 0x32, 0x63, 0x38, 0x61, 0x35, 0x32, 0x31, 0x32, 0x64, 0x63, 0x36, 0x35, 0x32, 0x35, 0x37, 0x61, 0x63, 0x31, 0x37, 0x65, 0x63, 0x37, 0x64, 0x38, 0x62, 0x33, 0x61, 0x34, 0x37, 0x39, 0x34, 0x64, 0x36, 0x62, 0x30, 0x34, 0x31, 0x62, 0x31, 0x39, 0x65, 0x33, 0x31, 0x32, 0x66, 0x33, 0x36, 0x32, 0x39, 0x38, 0x36, 0x35, 0x34, 0x32, 0x39, 0x39, 0x34, 0x39, 0x32, 0x63, 0x39, 0x35, 0x61, 0x31, 0x31, 0x65, 0x30, 0x65, 0x31, 0x63, 0x63, 0x66, 0x64, 0x39, 0x37, 0x38, 0x32, 0x38, 0x30, 0x63, 0x37, 0x66, 0x35, 0x30, 0x31, 0x37, 0x37, 0x66, 0x63, 0x35, 0x64, 0x38, 0x61, 0x66, 0x34, 0x62, 0x34, 0x65, 0x36, 0x61, 0x37, 0x34, 0x34, 0x31, 0x66, 0x34, 0x38, 0x35, 0x66, 0x31, 0x39, 0x38, 0x35, 0x32, 0x37, 0x32, 0x65, 0x36, 0x34, 0x32, 0x31, 0x30, 0x36, 0x30, 0x66, 0x39, 0x66, 0x35, 0x32, 0x30, 0x66, 0x32, 0x35, 0x39, 0x63, 0x37, 0x37, 0x36, 0x63, 0x63, 0x30, 0x39, 0x35, 0x30, 0x31, 0x64, 0x66, 0x34, 0x64, 0x38, 0x34, 0x37, 0x39, 0x34, 0x38, 0x38, 0x35, 0x66, 0x65, 0x37, 0x62, 0x64, 0x64, 0x36, 0x64, 0x39, 0x63, 0x31, 0x34, 0x63, 0x65, 0x66, 0x62, 0x35, 0x63, 0x38, 0x39, 0x34, 0x31, 0x64, 0x36, 0x62, 0x37, 0x31, 0x34, 0x37, 0x34, 0x33, 0x62, 0x62, 0x30, 0x38, 0x63, 0x30, 0x62, 0x32, 0x33, 0x66, 0x31, 0x39, 0x37, 0x64, 0x34, 0x37, 0x39, 0x65, 0x39, 0x61, 0x61, 0x31, 0x62, 0x66, 0x31, 0x39, 0x30, 0x65, 0x36, 0x64, 0x62, 0x64, 0x61, 0x62, 0x35, 0x30, 0x64, 0x30, 0x64, 0x32, 0x61, 0x64, 0x32, 0x36, 0x39, 0x39, 0x33, 0x36, 0x35, 0x37, 0x35, 0x32, 0x36, 0x32, 0x35, 0x64, 0x34, 0x33, 0x39, 0x62, 0x31, 0x65, 0x30, 0x33, 0x38, 0x65, 0x63, 0x31, 0x65, 0x38, 0x30, 0x30, 0x63, 0x62, 0x32, 0x64, 0x36, 0x62, 0x36, 0x64, 0x36, 0x65, 0x34, 0x32, 0x65, 0x33, 0x35, 0x33, 0x31, 0x36, 0x64, 0x65, 0x31, 0x65, 0x32, 0x63, 0x38, 0x63, 0x66, 0x33, 0x39, 0x66, 0x36, 0x35, 0x38, 0x36, 0x64, 0x38, 0x65, 0x38, 0x61, 0x62, 0x38, 0x64, 0x30, 0x63, 0x38, 0x37, 0x37, 0x32, 0x64, 0x31, 0x30, 0x39, 0x30, 0x34, 0x36, 0x63, 0x32, 0x33, 0x66, 0x62, 0x31, 0x32, 0x65, 0x37, 0x61, 0x37, 0x30, 0x37, 0x36, 0x64, 0x61, 0x39, 0x61, 0x62, 0x63, 0x32, 0x62, 0x64, 0x32, 0x39, 0x30, 0x64, 0x64, 0x30, 0x38, 0x39, 0x33, 0x61, 0x35, 0x34, 0x34, 0x34, 0x65, 0x35, 0x34, 0x32, 0x35, 0x64, 0x37, 0x32, 0x36, 0x64, 0x37, 0x35, 0x34, 0x34, 0x66, 0x63, 0x37, 0x63, 0x32, 0x33, 0x36, 0x35, 0x36, 0x65, 0x35, 0x30, 0x65, 0x30, 0x33, 0x33, 0x32, 0x65, 0x35, 0x61, 0x38, 0x34, 0x34, 0x39, 0x37, 0x39, 0x66, 0x64, 0x66, 0x37, 0x37, 0x64, 0x34, 0x65, 0x64, 0x37, 0x31, 0x33, 0x37, 0x61, 0x61, 0x35, 0x65, 0x34, 0x30, 0x35, 0x34, 0x31, 0x34, 0x35, 0x31, 0x37, 0x34, 0x36, 0x31, 0x36, 0x33, 0x61, 0x32, 0x30, 0x33, 0x62, 0x61, 0x31, 0x34, 0x38, 0x32, 0x65, 0x35, 0x63, 0x31, 0x31, 0x32, 0x66, 0x63, 0x63, 0x62, 0x61, 0x65, 0x63, 0x32, 0x35, 0x38, 0x38, 0x63, 0x31, 0x64, 0x35, 0x31, 0x33, 0x39, 0x64, 0x38, 0x65, 0x34, 0x62, 0x61, 0x35, 0x33, 0x63, 0x38, 0x33, 0x61, 0x38, 0x62, 0x30, 0x31, 0x36, 0x31, 0x38, 0x32, 0x63, 0x38, 0x33, 0x33, 0x39, 0x34, 0x38, 0x62, 0x35, 0x63, 0x35, 0x37, 0x37, 0x65, 0x66, 0x34, 0x32, 0x36, 0x36, 0x32, 0x30, 0x36, 0x31, 0x35, 0x31, 0x30, 0x38, 0x34, 0x63, 0x62, 0x62, 0x62, 0x37, 0x63, 0x32, 0x36, 0x61, 0x34, 0x32, 0x38, 0x62, 0x32, 0x62, 0x32, 0x38, 0x61, 0x34, 0x30, 0x34, 0x62, 0x66, 0x39, 0x65, 0x66, 0x65, 0x30, 0x64, 0x66, 0x62, 0x31, 0x32, 0x66, 0x35, 0x30, 0x38, 0x37, 0x64, 0x61, 0x32, 0x33, 0x32, 0x65, 0x30, 0x35, 0x61, 0x33, 0x34, 0x61, 0x31, 0x38, 0x38, 0x35, 0x31, 0x61, 0x39, 0x37, 0x32, 0x36, 0x33, 0x37, 0x62, 0x37, 0x35, 0x36, 0x31, 0x33, 0x30, 0x36, 0x35, 0x63, 0x38, 0x32, 0x62, 0x30, 0x35, 0x31, 0x61, 0x35, 0x34, 0x62, 0x31, 0x37, 0x33, 0x61, 0x35, 0x36, 0x61, 0x34, 0x36, 0x66, 0x33, 0x66, 0x35, 0x65, 0x65, 0x32, 0x39, 0x39, 0x66, 0x39, 0x33, 0x31, 0x32, 0x39, 0x34, 0x64, 0x39, 0x36, 0x33, 0x31, 0x38, 0x37, 0x65, 0x62, 0x61, 0x65, 0x64, 0x38, 0x62, 0x37, 0x32, 0x65, 0x38, 0x61, 0x32, 0x32, 0x65, 0x33, 0x33, 0x35, 0x37, 0x30, 0x38, 0x37, 0x30, 0x66, 0x61, 0x30, 0x36, 0x61, 0x33, 0x33, 0x62, 0x36, 0x64, 0x35, 0x37, 0x30, 0x38, 0x32, 0x39, 0x62, 0x38, 0x30, 0x62, 0x31, 0x62, 0x31, 0x61, 0x39, 0x30, 0x62, 0x37, 0x37, 0x61, 0x39, 0x39, 0x61, 0x61, 0x31, 0x61, 0x38, 0x33, 0x61, 0x66, 0x39, 0x31, 0x64, 0x39, 0x33, 0x38, 0x66, 0x33, 0x37, 0x32, 0x30, 0x31, 0x37, 0x63, 0x63, 0x31, 0x62, 0x35, 0x62, 0x36, 0x63, 0x38, 0x31, 0x66, 0x64, 0x65, 0x30, 0x38, 0x66, 0x34, 0x64, 0x36, 0x62, 0x64, 0x35, 0x34, 0x32, 0x33, 0x66, 0x66, 0x64, 0x32, 0x39, 0x38, 0x63, 0x64, 0x36, 0x66, 0x34, 0x62, 0x31, 0x31, 0x33, 0x37, 0x37, 0x65, 0x61, 0x32, 0x31, 0x36, 0x63, 0x38, 0x30, 0x32, 0x38, 0x34, 0x39, 0x64, 0x36, 0x64, 0x34, 0x30, 0x34, 0x36, 0x61, 0x30, 0x35, 0x63, 0x39, 0x66, 0x37, 0x62, 0x34, 0x33, 0x66, 0x62, 0x66, 0x34, 0x62, 0x30, 0x37, 0x39, 0x64, 0x64, 0x36, 0x36, 0x33, 0x39, 0x36, 0x33, 0x64, 0x38, 0x39, 0x65, 0x38, 0x64, 0x32, 0x63, 0x31, 0x66, 0x64, 0x38, 0x36, 0x63, 0x34, 0x31, 0x63, 0x36, 0x34, 0x36, 0x32, 0x37, 0x37, 0x33, 0x35, 0x64, 0x32, 0x34, 0x61, 0x61, 0x63, 0x37, 0x63, 0x39, 0x39, 0x63, 0x37, 0x32, 0x39, 0x61, 0x35, 0x39, 0x33, 0x34, 0x66, 0x35, 0x30, 0x34, 0x33, 0x30, 0x34, 0x66, 0x37, 0x64, 0x65, 0x39, 0x61, 0x39, 0x30, 0x36, 0x64, 0x63, 0x39, 0x35, 0x39, 0x38, 0x33, 0x62, 0x62, 0x64, 0x38, 0x31, 0x33, 0x32, 0x34, 0x33, 0x66, 0x36, 0x65, 0x39, 0x38, 0x65, 0x38, 0x65, 0x38, 0x35, 0x61, 0x33, 0x66, 0x38, 0x38, 0x30, 0x64, 0x61, 0x34, 0x61, 0x35, 0x37, 0x61, 0x32, 0x37, 0x32, 0x35, 0x30, 0x38, 0x35, 0x32, 0x38, 0x31, 0x37, 0x36, 0x63, 0x34, 0x62, 0x62, 0x32, 0x39, 0x66, 0x62, 0x66, 0x63, 0x36, 0x66, 0x65, 0x64, 0x39, 0x39, 0x65, 0x66, 0x39, 0x33, 0x35, 0x31, 0x32, 0x32, 0x65, 0x37, 0x30, 0x32, 0x33, 0x32, 0x35, 0x32, 0x31, 0x37, 0x38, 0x62, 0x63, 0x63, 0x35, 0x34, 0x30, 0x62, 0x36, 0x30, 0x32, 0x30, 0x35, 0x32, 0x32, 0x62, 0x65, 0x36, 0x65, 0x37, 0x32, 0x37, 0x66, 0x65, 0x30, 0x64, 0x31, 0x39, 0x37, 0x61, 0x30, 0x61, 0x32, 0x38, 0x61, 0x36, 0x64, 0x35, 0x63, 0x31, 0x30, 0x61, 0x66, 0x33, 0x63, 0x62, 0x33, 0x64, 0x66, 0x38, 0x35, 0x62, 0x34, 0x39, 0x64, 0x32, 0x33, 0x33, 0x39, 0x37, 0x63, 0x32, 0x32, 0x35, 0x32, 0x31, 0x39, 0x61, 0x36, 0x33, 0x36, 0x32, 0x37, 0x62, 0x35, 0x64, 0x34, 0x66, 0x31, 0x61, 0x64, 0x66, 0x63, 0x30, 0x34, 0x65, 0x38, 0x30, 0x37, 0x33, 0x63, 0x64, 0x36, 0x30, 0x62, 0x66, 0x62, 0x30, 0x39, 0x31, 0x32, 0x35, 0x62, 0x62, 0x37, 0x39, 0x34, 0x33, 0x64, 0x33, 0x61, 0x36, 0x36, 0x37, 0x31, 0x37, 0x32, 0x62, 0x62, 0x33, 0x33, 0x34, 0x35, 0x61, 0x36, 0x63, 0x32, 0x65, 0x62, 0x39, 0x32, 0x32, 0x35, 0x32, 0x34, 0x36, 0x61, 0x30, 0x39, 0x38, 0x37, 0x32, 0x66, 0x30, 0x37, 0x30, 0x34, 0x35, 0x31, 0x39, 0x61, 0x62, 0x61, 0x32, 0x62, 0x33, 0x34, 0x32, 0x34, 0x62, 0x39, 0x33, 0x66, 0x35, 0x33, 0x66, 0x62, 0x62, 0x34, 0x39, 0x38, 0x65, 0x66, 0x32, 0x31, 0x63, 0x62, 0x37, 0x36, 0x34, 0x33, 0x33, 0x34, 0x31, 0x32, 0x35, 0x32, 0x35, 0x61, 0x65, 0x31, 0x34, 0x30, 0x38, 0x64, 0x63, 0x35, 0x30, 0x35, 0x33, 0x39, 0x64, 0x66, 0x36, 0x65, 0x38, 0x30, 0x38, 0x63, 0x38, 0x65, 0x37, 0x32, 0x61, 0x36, 0x66, 0x38, 0x39, 0x61, 0x34, 0x64, 0x37, 0x30, 0x64, 0x31, 0x35, 0x66, 0x31, 0x62, 0x34, 0x34, 0x66, 0x62, 0x31, 0x37, 0x31, 0x30, 0x62, 0x36, 0x36, 0x64, 0x36, 0x38, 0x33, 0x63, 0x63, 0x34, 0x35, 0x38, 0x37, 0x37, 0x34, 0x31, 0x62, 0x30, 0x38, 0x32, 0x36, 0x61, 0x33, 0x31, 0x33, 0x63, 0x36, 0x61, 0x31, 0x31, 0x34, 0x37, 0x34, 0x63, 0x38, 0x66, 0x65, 0x38, 0x30, 0x30, 0x32, 0x33, 0x37, 0x66, 0x36, 0x35, 0x64, 0x34, 0x35, 0x65, 0x38, 0x31, 0x61, 0x39, 0x63, 0x66, 0x33, 0x30, 0x62, 0x31, 0x31, 0x34, 0x38, 0x38, 0x30, 0x61, 0x39, 0x62, 0x31, 0x35, 0x66, 0x31, 0x66, 0x63, 0x34, 0x33, 0x62, 0x63, 0x65, 0x39, 0x30, 0x34, 0x63, 0x62, 0x35, 0x62, 0x38, 0x39, 0x34, 0x62, 0x63, 0x39, 0x39, 0x64, 0x39, 0x62, 0x63, 0x64, 0x61, 0x31, 0x64, 0x35, 0x37, 0x32, 0x30, 0x37, 0x30, 0x65, 0x39, 0x65, 0x37, 0x61, 0x33, 0x32, 0x35, 0x32, 0x30, 0x38, 0x34, 0x30, 0x37, 0x36, 0x66, 0x36, 0x64, 0x39, 0x38, 0x62, 0x35, 0x31, 0x38, 0x65, 0x33, 0x39, 0x61, 0x34, 0x63, 0x65, 0x39, 0x38, 0x34, 0x34, 0x36, 0x61, 0x38, 0x65, 0x30, 0x33, 0x31, 0x39, 0x62, 0x35, 0x66, 0x33, 0x34, 0x64, 0x30, 0x38, 0x63, 0x38, 0x32, 0x34, 0x66, 0x62, 0x30, 0x33, 0x33, 0x32, 0x62, 0x34, 0x37, 0x34, 0x35, 0x32, 0x33, 0x33, 0x62, 0x30, 0x63, 0x30, 0x66, 0x33, 0x63, 0x34, 0x31, 0x37, 0x65, 0x30, 0x39, 0x36, 0x33, 0x66, 0x63, 0x33, 0x33, 0x30, 0x37, 0x39, 0x34, 0x33, 0x35, 0x64, 0x31, 0x34, 0x36, 0x34, 0x32, 0x31, 0x39, 0x62, 0x34, 0x63, 0x38, 0x61, 0x32, 0x31, 0x34, 0x62, 0x31, 0x30, 0x34, 0x32, 0x39, 0x37, 0x61, 0x63, 0x35, 0x65, 0x32, 0x37, 0x33, 0x64, 0x66, 0x62, 0x38, 0x61, 0x30, 0x35, 0x31, 0x62, 0x38, 0x63, 0x65, 0x35, 0x63, 0x37, 0x38, 0x39, 0x30, 0x33, 0x65, 0x66, 0x64, 0x35, 0x63, 0x39, 0x62, 0x32, 0x36, 0x66, 0x61, 0x63, 0x34, 0x62, 0x64, 0x30, 0x33, 0x64, 0x37, 0x32, 0x36, 0x65, 0x35, 0x31, 0x32, 0x65, 0x32, 0x30, 0x30, 0x32, 0x66, 0x66, 0x64, 0x62, 0x65, 0x63, 0x61, 0x38, 0x33, 0x66, 0x39, 0x32, 0x32, 0x64, 0x37, 0x32, 0x34, 0x64, 0x61, 0x63, 0x39, 0x33, 0x32, 0x39, 0x65, 0x31, 0x33, 0x30, 0x30, 0x66, 0x37, 0x30, 0x61, 0x39, 0x62, 0x63, 0x66, 0x62, 0x64, 0x35, 0x33, 0x64, 0x66, 0x66, 0x34, 0x32, 0x39, 0x64, 0x64, 0x34, 0x31, 0x31, 0x37, 0x66, 0x61, 0x38, 0x37, 0x64, 0x38, 0x35, 0x33, 0x30, 0x37, 0x34, 0x31, 0x63, 0x34, 0x64, 0x66, 0x39, 0x38, 0x35, 0x39, 0x38, 0x36, 0x62, 0x61, 0x35, 0x37, 0x32, 0x61, 0x66, 0x64, 0x65, 0x33, 0x32, 0x36, 0x32, 0x39, 0x36, 0x34, 0x39, 0x64, 0x33, 0x30, 0x36, 0x65, 0x31, 0x63, 0x62, 0x61, 0x66, 0x35, 0x39, 0x34, 0x66, 0x31, 0x63, 0x38, 0x32, 0x65, 0x33, 0x32, 0x39, 0x66, 0x38, 0x32, 0x34, 0x35, 0x31, 0x37, 0x38, 0x32, 0x37, 0x66, 0x30, 0x64, 0x37, 0x34, 0x62, 0x35, 0x30, 0x64, 0x65, 0x34, 0x32, 0x37, 0x66, 0x34, 0x66, 0x65, 0x30, 0x37, 0x32, 0x32, 0x37, 0x65, 0x34, 0x38, 0x62, 0x33, 0x61, 0x63, 0x36, 0x34, 0x61, 0x37, 0x38, 0x63, 0x32, 0x33, 0x37, 0x64, 0x31, 0x30, 0x34, 0x33, 0x32, 0x65, 0x65, 0x38, 0x32, 0x66, 0x34, 0x38, 0x35, 0x34, 0x62, 0x30, 0x35, 0x62, 0x38, 0x38, 0x63, 0x65, 0x65, 0x62, 0x61, 0x30, 0x35, 0x38, 0x37, 0x33, 0x65, 0x38, 0x66, 0x63, 0x65, 0x62, 0x63, 0x31, 0x34, 0x30, 0x36, 0x61, 0x36, 0x37, 0x32, 0x65, 0x37, 0x36, 0x37, 0x30, 0x37, 0x39, 0x34, 0x63, 0x34, 0x66, 0x38, 0x34, 0x33, 0x31, 0x34, 0x36, 0x62, 0x36, 0x36, 0x38, 0x61, 0x63, 0x64, 0x66, 0x63, 0x39, 0x34, 0x30, 0x63, 0x32, 0x63, 0x66, 0x62, 0x36, 0x31, 0x37, 0x65, 0x61, 0x65, 0x65, 0x31, 0x66, 0x32, 0x34, 0x30, 0x38, 0x66, 0x35, 0x30, 0x63, 0x30, 0x31, 0x66, 0x61, 0x62, 0x32, 0x38, 0x38, 0x36, 0x39, 0x31, 0x33, 0x39, 0x32, 0x33, 0x32, 0x65, 0x65, 0x37, 0x32, 0x64, 0x66, 0x32, 0x61, 0x33, 0x38, 0x37, 0x34, 0x30, 0x36, 0x38, 0x63, 0x32, 0x62, 0x61, 0x65, 0x33, 0x64, 0x64, 0x32, 0x63, 0x36, 0x39, 0x34, 0x39, 0x63, 0x64, 0x63, 0x34, 0x34, 0x31, 0x37, 0x36, 0x32, 0x33, 0x31, 0x37, 0x30, 0x64, 0x35, 0x34, 0x63, 0x62, 0x63, 0x61, 0x32, 0x33, 0x61, 0x37, 0x63, 0x36, 0x35, 0x35, 0x33, 0x36, 0x34, 0x64, 0x31, 0x32, 0x61, 0x65, 0x32, 0x63, 0x64, 0x64, 0x33, 0x66, 0x37, 0x62, 0x38, 0x66, 0x30, 0x62, 0x62, 0x63, 0x37, 0x39, 0x36, 0x64, 0x37, 0x32, 0x34, 0x36, 0x38, 0x37, 0x34, 0x65, 0x30, 0x63, 0x65, 0x37, 0x31, 0x34, 0x38, 0x61, 0x62, 0x35, 0x64, 0x66, 0x66, 0x34, 0x36, 0x66, 0x64, 0x64, 0x63, 0x38, 0x64, 0x63, 0x37, 0x65, 0x30, 0x32, 0x65, 0x36, 0x63, 0x39, 0x36, 0x61, 0x37, 0x32, 0x66, 0x33, 0x30, 0x31, 0x34, 0x33, 0x66, 0x37, 0x66, 0x34, 0x34, 0x65, 0x32, 0x39, 0x65, 0x38, 0x39, 0x38, 0x36, 0x64, 0x63, 0x38, 0x61, 0x30, 0x35, 0x62, 0x37, 0x30, 0x65, 0x61, 0x35, 0x31, 0x66, 0x32, 0x30, 0x35, 0x62, 0x35, 0x62, 0x66, 0x36, 0x35, 0x31, 0x64, 0x65, 0x31, 0x33, 0x38, 0x36, 0x39, 0x31, 0x33, 0x64, 0x34, 0x39, 0x39, 0x37, 0x62, 0x66, 0x66, 0x39, 0x33, 0x31, 0x31, 0x32, 0x31, 0x61, 0x31, 0x35, 0x36, 0x33, 0x61, 0x34, 0x36, 0x65, 0x37, 0x66, 0x34, 0x33, 0x39, 0x33, 0x39, 0x30, 0x61, 0x35, 0x34, 0x66, 0x64, 0x32, 0x66, 0x39, 0x31, 0x62, 0x33, 0x37, 0x38, 0x64, 0x62, 0x30, 0x64, 0x39, 0x31, 0x37, 0x35, 0x31, 0x32, 0x65, 0x39, 0x64, 0x65, 0x61, 0x63, 0x34, 0x61, 0x66, 0x37, 0x32, 0x37, 0x64, 0x31, 0x37, 0x32, 0x64, 0x32, 0x32, 0x30, 0x37, 0x32, 0x32, 0x64, 0x61, 0x61, 0x36, 0x35, 0x65, 0x66, 0x61, 0x66, 0x63, 0x65, 0x34, 0x38, 0x63, 0x32, 0x38, 0x63, 0x66, 0x34, 0x38, 0x34, 0x39, 0x32, 0x35, 0x66, 0x31, 0x65, 0x39, 0x65, 0x30, 0x62, 0x65, 0x34, 0x63, 0x38, 0x61, 0x37, 0x33, 0x39, 0x62, 0x32, 0x31, 0x32, 0x34, 0x66, 0x30, 0x36, 0x30, 0x64, 0x66, 0x66, 0x39, 0x66, 0x31, 0x64, 0x35, 0x65, 0x33, 0x34, 0x61, 0x37, 0x32, 0x36, 0x35, 0x35, 0x66, 0x33, 0x36, 0x35, 0x63, 0x66, 0x30, 0x30, 0x39, 0x64, 0x62, 0x62, 0x66, 0x61, 0x63, 0x66, 0x30, 0x64, 0x35, 0x36, 0x35, 0x63, 0x61, 0x35, 0x38, 0x30, 0x34, 0x62, 0x37, 0x35, 0x30, 0x38, 0x38, 0x30, 0x66, 0x38, 0x30, 0x38, 0x38, 0x66, 0x34, 0x65, 0x63, 0x30, 0x37, 0x34, 0x63, 0x63, 0x63, 0x62, 0x30, 0x36, 0x30, 0x33, 0x37, 0x61, 0x37, 0x62, 0x62, 0x64, 0x37, 0x32, 0x38, 0x65, 0x30, 0x65, 0x34, 0x30, 0x32, 0x63, 0x62, 0x38, 0x35, 0x37, 0x35, 0x31, 0x37, 0x38, 0x31, 0x35, 0x62, 0x36, 0x63, 0x33, 0x31, 0x63, 0x63, 0x66, 0x30, 0x39, 0x37, 0x33, 0x31, 0x39, 0x39, 0x37, 0x39, 0x31, 0x66, 0x62, 0x31, 0x61, 0x66, 0x65, 0x39, 0x36, 0x65, 0x37, 0x34, 0x35, 0x39, 0x37, 0x63, 0x61, 0x35, 0x30, 0x64, 0x35, 0x35, 0x33, 0x35, 0x39, 0x33, 0x30, 0x32, 0x35, 0x38, 0x62, 0x38, 0x65, 0x66, 0x30, 0x66, 0x33, 0x30, 0x65, 0x63, 0x61, 0x32, 0x36, 0x34, 0x62, 0x61, 0x65, 0x37, 0x64, 0x39, 0x30, 0x38, 0x65, 0x33, 0x66, 0x32, 0x35, 0x38, 0x37, 0x34, 0x31, 0x61, 0x39, 0x66, 0x34, 0x65, 0x31, 0x31, 0x63, 0x62, 0x30, 0x62, 0x36, 0x35, 0x36, 0x32, 0x66, 0x33, 0x30, 0x64, 0x34, 0x61, 0x31, 0x39, 0x61, 0x37, 0x64, 0x35, 0x64, 0x32, 0x34, 0x37, 0x32, 0x39, 0x66, 0x34, 0x39, 0x32, 0x38, 0x37, 0x35, 0x33, 0x36, 0x35, 0x31, 0x39, 0x37, 0x30, 0x31, 0x33, 0x35, 0x66, 0x38, 0x33, 0x65, 0x65, 0x34, 0x39, 0x62, 0x65, 0x66, 0x62, 0x62, 0x39, 0x35, 0x30, 0x64, 0x38, 0x39, 0x64, 0x61, 0x31, 0x38, 0x38, 0x33, 0x34, 0x62, 0x61, 0x36, 0x35, 0x62, 0x33, 0x38, 0x30, 0x37, 0x37, 0x32, 0x33, 0x65, 0x64, 0x65, 0x64, 0x32, 0x34, 0x34, 0x37, 0x32, 0x36, 0x35, 0x31, 0x37, 0x61, 0x62, 0x39, 0x37, 0x31, 0x36, 0x61, 0x66, 0x30, 0x63, 0x34, 0x31, 0x33, 0x65, 0x34, 0x30, 0x38, 0x33, 0x64, 0x61, 0x35, 0x65, 0x31, 0x38, 0x39, 0x63, 0x66, 0x35, 0x39, 0x66, 0x62, 0x64, 0x66, 0x32, 0x64, 0x30, 0x32, 0x63, 0x39, 0x65, 0x62, 0x66, 0x61, 0x61, 0x30, 0x39, 0x61, 0x66, 0x30, 0x32, 0x62, 0x32, 0x39, 0x37, 0x62, 0x65, 0x64, 0x34, 0x37, 0x32, 0x36, 0x63, 0x65, 0x61, 0x63, 0x64, 0x61, 0x32, 0x33, 0x63, 0x62, 0x33, 0x31, 0x65, 0x63, 0x62, 0x31, 0x35, 0x34, 0x37, 0x65, 0x65, 0x66, 0x38, 0x64, 0x38, 0x34, 0x33, 0x30, 0x63, 0x33, 0x62, 0x37, 0x39, 0x64, 0x66, 0x33, 0x31, 0x34, 0x31, 0x62, 0x34, 0x34, 0x64, 0x66, 0x39, 0x35, 0x32, 0x31, 0x61, 0x66, 0x38, 0x36, 0x61, 0x36, 0x64, 0x62, 0x66, 0x65, 0x31, 0x36, 0x32, 0x31, 0x35, 0x32, 0x64, 0x39, 0x36, 0x61, 0x33, 0x37, 0x35, 0x34, 0x38, 0x61, 0x65, 0x38, 0x31, 0x62, 0x61, 0x33, 0x39, 0x32, 0x35, 0x64, 0x39, 0x39, 0x36, 0x63, 0x64, 0x61, 0x61, 0x39, 0x35, 0x36, 0x66, 0x37, 0x64, 0x66, 0x39, 0x38, 0x31, 0x37, 0x32, 0x39, 0x35, 0x64, 0x33, 0x38, 0x32, 0x61, 0x65, 0x62, 0x38, 0x64, 0x36, 0x34, 0x38, 0x35, 0x31, 0x61, 0x64, 0x61, 0x66, 0x36, 0x31, 0x37, 0x32, 0x66, 0x31, 0x62, 0x30, 0x65, 0x62, 0x61, 0x33, 0x64, 0x30, 0x65, 0x66, 0x62, 0x64, 0x33, 0x32, 0x63, 0x33, 0x61, 0x63, 0x63, 0x36, 0x30, 0x64, 0x63, 0x34, 0x64, 0x39, 0x65, 0x34, 0x30, 0x35, 0x39, 0x31, 0x33, 0x37, 0x37, 0x30, 0x35, 0x35, 0x36, 0x65, 0x65, 0x36, 0x33, 0x31, 0x61, 0x39, 0x32, 0x36, 0x64, 0x31, 0x34, 0x38, 0x35, 0x31, 0x65, 0x39, 0x34, 0x35, 0x34, 0x35, 0x36, 0x34, 0x63, 0x62, 0x36, 0x35, 0x37, 0x66, 0x66, 0x62, 0x37, 0x33, 0x36, 0x64, 0x31, 0x32, 0x33, 0x33, 0x66, 0x30, 0x64, 0x33, 0x61, 0x64, 0x37, 0x31, 0x38, 0x37, 0x32, 0x33, 0x34, 0x61, 0x30, 0x65, 0x65, 0x38, 0x34, 0x66, 0x33, 0x31, 0x34, 0x33, 0x35, 0x64, 0x65, 0x61, 0x37, 0x62, 0x32, 0x37, 0x33, 0x37, 0x37, 0x65, 0x31, 0x37, 0x63, 0x33, 0x65, 0x39, 0x35, 0x34, 0x36, 0x36, 0x37, 0x32, 0x33, 0x65, 0x66, 0x32, 0x65, 0x35, 0x32, 0x61, 0x34, 0x37, 0x61, 0x31, 0x35, 0x35, 0x32, 0x36, 0x33, 0x34, 0x36, 0x63, 0x33, 0x65, 0x33, 0x35, 0x35, 0x33, 0x61, 0x31, 0x37, 0x65, 0x62, 0x63, 0x37, 0x33, 0x63, 0x64, 0x66, 0x33, 0x31, 0x31, 0x64, 0x63, 0x35, 0x63, 0x66, 0x31, 0x38, 0x34, 0x33, 0x38, 0x30, 0x31, 0x30, 0x31, 0x61, 0x38, 0x62, 0x65, 0x64, 0x36, 0x62, 0x61, 0x37, 0x32, 0x34, 0x39, 0x64, 0x65, 0x37, 0x62, 0x38, 0x35, 0x33, 0x35, 0x37, 0x61, 0x31, 0x34, 0x61, 0x38, 0x31, 0x61, 0x38, 0x30, 0x65, 0x39, 0x31, 0x37, 0x66, 0x38, 0x34, 0x33, 0x30, 0x64, 0x33, 0x62, 0x65, 0x61, 0x30, 0x38, 0x65, 0x38, 0x62, 0x30, 0x39, 0x37, 0x35, 0x39, 0x31, 0x65, 0x62, 0x65, 0x65, 0x30, 0x63, 0x66, 0x34, 0x37, 0x32, 0x38, 0x33, 0x38, 0x63, 0x35, 0x61, 0x39, 0x35, 0x34, 0x62, 0x31, 0x61, 0x35, 0x36, 0x66, 0x30, 0x33, 0x61, 0x66, 0x34, 0x63, 0x38, 0x66, 0x39, 0x30, 0x32, 0x35, 0x33, 0x39, 0x61, 0x38, 0x31, 0x61, 0x36, 0x39, 0x65, 0x62, 0x61, 0x34, 0x61, 0x32, 0x66, 0x37, 0x31, 0x62, 0x62, 0x66, 0x35, 0x66, 0x64, 0x37, 0x35, 0x66, 0x34, 0x64, 0x62, 0x39, 0x38, 0x34, 0x31, 0x36, 0x36, 0x36, 0x39, 0x61, 0x39, 0x36, 0x63, 0x36, 0x38, 0x65, 0x37, 0x32, 0x30, 0x65, 0x62, 0x32, 0x32, 0x30, 0x36, 0x33, 0x33, 0x36, 0x34, 0x34, 0x37, 0x38, 0x36, 0x30, 0x39, 0x36, 0x36, 0x64, 0x34, 0x66, 0x34, 0x64, 0x65, 0x65, 0x66, 0x33, 0x37, 0x33, 0x37, 0x61, 0x33, 0x33, 0x31, 0x36, 0x32, 0x31, 0x37, 0x33, 0x63, 0x64, 0x39, 0x31, 0x39, 0x64, 0x64, 0x38, 0x32, 0x62, 0x31, 0x32, 0x31, 0x61, 0x32, 0x31, 0x66, 0x35, 0x62, 0x33, 0x63, 0x30, 0x34, 0x66, 0x64, 0x38, 0x63, 0x31, 0x31, 0x30, 0x30, 0x66, 0x34, 0x37, 0x38, 0x31, 0x65, 0x63, 0x32, 0x66, 0x62, 0x33, 0x34, 0x61, 0x66, 0x61, 0x66, 0x37, 0x38, 0x65, 0x62, 0x61, 0x62, 0x63, 0x36, 0x62, 0x33, 0x64, 0x65, 0x31, 0x38, 0x36, 0x31, 0x64, 0x62, 0x36, 0x39, 0x34, 0x62, 0x38, 0x34, 0x38, 0x38, 0x65, 0x61, 0x39, 0x64, 0x38, 0x64, 0x39, 0x61, 0x37, 0x64, 0x34, 0x32, 0x33, 0x37, 0x32, 0x62, 0x32, 0x31, 0x34, 0x61, 0x62, 0x35, 0x36, 0x31, 0x37, 0x65, 0x39, 0x37, 0x64, 0x31, 0x31, 0x63, 0x33, 0x30, 0x37, 0x39, 0x61, 0x36, 0x35, 0x35, 0x64, 0x32, 0x35, 0x61, 0x62, 0x64, 0x32, 0x30, 0x65, 0x33, 0x38, 0x33, 0x39, 0x36, 0x36, 0x61, 0x64, 0x62, 0x31, 0x31, 0x33, 0x32, 0x36, 0x63, 0x31, 0x62, 0x63, 0x61, 0x61, 0x63, 0x31, 0x66, 0x35, 0x38, 0x30, 0x61, 0x36, 0x37, 0x32, 0x34, 0x36, 0x30, 0x38, 0x62, 0x64, 0x64, 0x63, 0x66, 0x37, 0x32, 0x64, 0x36, 0x34, 0x38, 0x37, 0x65, 0x33, 0x64, 0x64, 0x62, 0x34, 0x39, 0x31, 0x63, 0x62, 0x39, 0x39, 0x61, 0x37, 0x62, 0x64, 0x37, 0x33, 0x34, 0x65, 0x38, 0x33, 0x35, 0x62, 0x65, 0x33, 0x33, 0x39, 0x63, 0x33, 0x61, 0x39, 0x64, 0x62, 0x35, 0x36, 0x63, 0x31, 0x39, 0x66, 0x31, 0x36, 0x32, 0x37, 0x35, 0x62, 0x36, 0x63, 0x33, 0x61, 0x38, 0x32, 0x38, 0x37, 0x64, 0x61, 0x37, 0x38, 0x66, 0x39, 0x65, 0x30, 0x37, 0x30, 0x33, 0x31, 0x35, 0x30, 0x62, 0x38, 0x61, 0x31, 0x39, 0x34, 0x64, 0x31, 0x32, 0x39, 0x31, 0x35, 0x36, 0x38, 0x37, 0x61, 0x38, 0x63, 0x62, 0x64, 0x35, 0x32, 0x33, 0x66, 0x66, 0x39, 0x30, 0x66, 0x39, 0x62, 0x30, 0x34, 0x61, 0x30, 0x31, 0x31, 0x35, 0x64, 0x36, 0x62, 0x34, 0x35, 0x37, 0x32, 0x32, 0x36, 0x30, 0x34, 0x64, 0x38, 0x36, 0x37, 0x63, 0x61, 0x63, 0x35, 0x62, 0x65, 0x32, 0x35, 0x35, 0x34, 0x63, 0x62, 0x38, 0x61, 0x38, 0x32, 0x39, 0x33, 0x65, 0x37, 0x65, 0x34, 0x62, 0x38, 0x36, 0x66, 0x38, 0x62, 0x30, 0x38, 0x36, 0x38, 0x39, 0x39, 0x33, 0x61, 0x37, 0x37, 0x64, 0x34, 0x66, 0x63, 0x35, 0x62, 0x31, 0x62, 0x38, 0x38, 0x62, 0x32, 0x34, 0x61, 0x38, 0x35, 0x37, 0x32, 0x38, 0x39, 0x34, 0x30, 0x30, 0x30, 0x33, 0x61, 0x30, 0x31, 0x33, 0x64, 0x30, 0x61, 0x65, 0x39, 0x36, 0x65, 0x61, 0x37, 0x32, 0x66, 0x66, 0x30, 0x34, 0x34, 0x32, 0x37, 0x62, 0x31, 0x64, 0x32, 0x61, 0x64, 0x30, 0x36, 0x30, 0x33, 0x31, 0x36, 0x30, 0x61, 0x31, 0x32, 0x33, 0x39, 0x34, 0x62, 0x31, 0x38, 0x64, 0x62, 0x65, 0x31, 0x30, 0x33, 0x35, 0x63, 0x30, 0x34, 0x31, 0x36, 0x37, 0x32, 0x61, 0x30, 0x30, 0x32, 0x64, 0x36, 0x31, 0x36, 0x30, 0x65, 0x66, 0x35, 0x30, 0x62, 0x65, 0x31, 0x63, 0x30, 0x34, 0x64, 0x34, 0x37, 0x31, 0x65, 0x36, 0x63, 0x39, 0x65, 0x36, 0x61, 0x64, 0x35, 0x36, 0x66, 0x36, 0x39, 0x30, 0x63, 0x34, 0x63, 0x65, 0x34, 0x32, 0x39, 0x64, 0x36, 0x35, 0x31, 0x63, 0x36, 0x32, 0x65, 0x62, 0x30, 0x39, 0x36, 0x66, 0x36, 0x63, 0x61, 0x38, 0x65, 0x33, 0x64, 0x37, 0x38, 0x65, 0x66, 0x36, 0x34, 0x64, 0x30, 0x62, 0x62, 0x31, 0x66, 0x33, 0x36, 0x64, 0x66, 0x62, 0x61, 0x39, 0x63, 0x39, 0x30, 0x38, 0x32, 0x34, 0x32, 0x33, 0x63, 0x38, 0x30, 0x65, 0x33, 0x35, 0x39, 0x39, 0x38, 0x63, 0x37, 0x63, 0x61, 0x38, 0x64, 0x38, 0x34, 0x61, 0x65, 0x62, 0x39, 0x64, 0x31, 0x39, 0x36, 0x62, 0x65, 0x32, 0x37, 0x65, 0x33, 0x63, 0x64, 0x35, 0x37, 0x37, 0x32, 0x37, 0x34, 0x62, 0x37, 0x33, 0x64, 0x39, 0x64, 0x62, 0x62, 0x65, 0x35, 0x32, 0x66, 0x31, 0x31, 0x30, 0x35, 0x62, 0x64, 0x64, 0x30, 0x61, 0x36, 0x66, 0x38, 0x32, 0x34, 0x33, 0x61, 0x38, 0x65, 0x63, 0x35, 0x33, 0x64, 0x61, 0x36, 0x35, 0x38, 0x35, 0x63, 0x63, 0x31, 0x39, 0x35, 0x38, 0x64, 0x34, 0x64, 0x30, 0x66, 0x35, 0x30, 0x62, 0x34, 0x61, 0x37, 0x65, 0x63, 0x36, 0x39, 0x32, 0x38, 0x37, 0x32, 0x31, 0x33, 0x35, 0x61, 0x32, 0x65, 0x39, 0x61, 0x63, 0x62, 0x63, 0x61, 0x36, 0x32, 0x66, 0x66, 0x39, 0x34, 0x33, 0x66, 0x65, 0x64, 0x35, 0x65, 0x32, 0x37, 0x33, 0x34, 0x63, 0x64, 0x30, 0x66, 0x37, 0x62, 0x35, 0x63, 0x39, 0x38, 0x34, 0x30, 0x36, 0x38, 0x64, 0x38, 0x63, 0x37, 0x30, 0x38, 0x39, 0x64, 0x66, 0x34, 0x36, 0x61, 0x32, 0x38, 0x63, 0x63, 0x66, 0x33, 0x37, 0x32, 0x66, 0x33, 0x61, 0x31, 0x37, 0x38, 0x66, 0x34, 0x62, 0x64, 0x62, 0x63, 0x65, 0x35, 0x38, 0x31, 0x33, 0x36, 0x37, 0x35, 0x37, 0x66, 0x35, 0x30, 0x62, 0x33, 0x64, 0x30, 0x64, 0x38, 0x36, 0x65, 0x37, 0x65, 0x63, 0x65, 0x30, 0x63, 0x65, 0x37, 0x64, 0x65, 0x61, 0x39, 0x30, 0x33, 0x62, 0x61, 0x66, 0x31, 0x34, 0x63, 0x38, 0x63, 0x34, 0x37, 0x33, 0x37, 0x65, 0x63, 0x35, 0x30, 0x37, 0x32, 0x31, 0x34, 0x39, 0x34, 0x64, 0x38, 0x36, 0x38, 0x33, 0x36, 0x35, 0x30, 0x33, 0x62, 0x36, 0x38, 0x36, 0x63, 0x66, 0x31, 0x35, 0x32, 0x62, 0x36, 0x33, 0x61, 0x35, 0x31, 0x36, 0x30, 0x62, 0x37, 0x32, 0x33, 0x63, 0x66, 0x35, 0x32, 0x33, 0x30, 0x38, 0x34, 0x61, 0x65, 0x32, 0x37, 0x37, 0x30, 0x38, 0x37, 0x62, 0x33, 0x36, 0x66, 0x34, 0x30, 0x36, 0x37, 0x37, 0x39, 0x32, 0x32, 0x37, 0x32, 0x31, 0x38, 0x65, 0x38, 0x39, 0x34, 0x38, 0x39, 0x32, 0x37, 0x64, 0x35, 0x61, 0x30, 0x34, 0x36, 0x30, 0x39, 0x66, 0x38, 0x32, 0x62, 0x35, 0x34, 0x38, 0x63, 0x30, 0x35, 0x36, 0x33, 0x33, 0x39, 0x63, 0x66, 0x65, 0x35, 0x32, 0x33, 0x35, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x30, 0x64, 0x65, 0x34, 0x30, 0x34, 0x63, 0x63, 0x64, 0x32, 0x65, 0x36, 0x62, 0x63, 0x65, 0x38, 0x61, 0x37, 0x32, 0x36, 0x37, 0x66, 0x64, 0x31, 0x35, 0x38, 0x62, 0x63, 0x63, 0x39, 0x33, 0x39, 0x62, 0x34, 0x30, 0x32, 0x34, 0x66, 0x35, 0x65, 0x33, 0x61, 0x31, 0x63, 0x36, 0x63, 0x30, 0x63, 0x36, 0x30, 0x36, 0x36, 0x62, 0x31, 0x32, 0x36, 0x36, 0x64, 0x64, 0x65, 0x37, 0x36, 0x38, 0x61, 0x33, 0x61, 0x64, 0x64, 0x32, 0x31, 0x36, 0x33, 0x63, 0x64, 0x32, 0x65, 0x36, 0x62, 0x65, 0x64, 0x33, 0x33, 0x32, 0x39, 0x36, 0x34, 0x34, 0x32, 0x63, 0x37, 0x63, 0x37, 0x34, 0x64, 0x65, 0x62, 0x61, 0x36, 0x34, 0x39, 0x34, 0x31, 0x61, 0x36, 0x62, 0x33, 0x64, 0x35, 0x61, 0x61, 0x64, 0x32, 0x66, 0x36, 0x36, 0x65, 0x39, 0x64, 0x37, 0x38, 0x65, 0x34, 0x61, 0x39, 0x63, 0x63, 0x65, 0x63, 0x64, 0x38, 0x30, 0x64, 0x34, 0x64, 0x62, 0x33, 0x35, 0x61, 0x39, 0x39, 0x37, 0x38, 0x34, 0x61, 0x38, 0x37, 0x32, 0x62, 0x30, 0x37, 0x61, 0x33, 0x30, 0x35, 0x65, 0x36, 0x34, 0x63, 0x63, 0x37, 0x61, 0x64, 0x34, 0x39, 0x64, 0x37, 0x62, 0x36, 0x30, 0x66, 0x64, 0x65, 0x62, 0x62, 0x39, 0x62, 0x35, 0x65, 0x30, 0x63, 0x37, 0x64, 0x64, 0x38, 0x30, 0x66, 0x34, 0x65, 0x36, 0x38, 0x65, 0x31, 0x35, 0x39, 0x36, 0x34, 0x62, 0x39, 0x39, 0x38, 0x61, 0x65, 0x65, 0x32, 0x33, 0x33, 0x35, 0x62, 0x65, 0x32, 0x34, 0x62, 0x38, 0x34, 0x61, 0x33, 0x36, 0x35, 0x38, 0x33, 0x62, 0x65, 0x30, 0x33, 0x64, 0x38, 0x61, 0x63, 0x61, 0x65, 0x32, 0x63, 0x35, 0x34, 0x36, 0x66, 0x37, 0x31, 0x32, 0x32, 0x61, 0x30, 0x38, 0x39, 0x36, 0x34, 0x31, 0x65, 0x32, 0x64, 0x33, 0x63, 0x31, 0x31, 0x30, 0x34, 0x62, 0x38, 0x35, 0x39, 0x32, 0x38, 0x36, 0x30, 0x64, 0x65, 0x61, 0x34, 0x33, 0x33, 0x36, 0x62, 0x37, 0x37, 0x32, 0x32, 0x62, 0x64, 0x64, 0x38, 0x32, 0x33, 0x34, 0x32, 0x36, 0x38, 0x33, 0x32, 0x36, 0x61, 0x34, 0x35, 0x34, 0x63, 0x39, 0x61, 0x65, 0x62, 0x66, 0x36, 0x31, 0x38, 0x62, 0x65, 0x64, 0x66, 0x66, 0x39, 0x35, 0x61, 0x34, 0x36, 0x66, 0x36, 0x64, 0x34, 0x30, 0x62, 0x65, 0x31, 0x36, 0x63, 0x32, 0x61, 0x37, 0x34, 0x39, 0x38, 0x32, 0x32, 0x61, 0x35, 0x33, 0x36, 0x34, 0x33, 0x38, 0x37, 0x32, 0x38, 0x64, 0x66, 0x30, 0x30, 0x64, 0x31, 0x30, 0x33, 0x33, 0x32, 0x31, 0x32, 0x33, 0x38, 0x65, 0x62, 0x63, 0x30, 0x30, 0x35, 0x34, 0x32, 0x30, 0x32, 0x61, 0x30, 0x30, 0x33, 0x32, 0x31, 0x36, 0x65, 0x64, 0x66, 0x65, 0x31, 0x34, 0x35, 0x34, 0x63, 0x30, 0x35, 0x39, 0x66, 0x61, 0x62, 0x61, 0x36, 0x31, 0x39, 0x66, 0x65, 0x63, 0x63, 0x32, 0x61, 0x65, 0x64, 0x63, 0x65, 0x66, 0x37, 0x32, 0x37, 0x63, 0x35, 0x30, 0x32, 0x32, 0x32, 0x66, 0x35, 0x33, 0x31, 0x65, 0x61, 0x34, 0x33, 0x37, 0x63, 0x35, 0x30, 0x32, 0x35, 0x65, 0x35, 0x32, 0x36, 0x63, 0x35, 0x64, 0x36, 0x61, 0x30, 0x33, 0x35, 0x36, 0x64, 0x62, 0x62, 0x32, 0x38, 0x36, 0x65, 0x34, 0x39, 0x32, 0x33, 0x61, 0x32, 0x66, 0x39, 0x38, 0x66, 0x31, 0x39, 0x39, 0x31, 0x39, 0x37, 0x35, 0x38, 0x62, 0x64, 0x65, 0x32, 0x33, 0x37, 0x39, 0x35, 0x64, 0x38, 0x33, 0x32, 0x32, 0x39, 0x39, 0x30, 0x64, 0x35, 0x63, 0x65, 0x32, 0x31, 0x37, 0x66, 0x34, 0x39, 0x64, 0x66, 0x62, 0x61, 0x36, 0x39, 0x64, 0x31, 0x32, 0x34, 0x36, 0x33, 0x33, 0x38, 0x65, 0x66, 0x65, 0x64, 0x62, 0x65, 0x30, 0x62, 0x31, 0x63, 0x62, 0x66, 0x31, 0x34, 0x64, 0x35, 0x30, 0x64, 0x62, 0x62, 0x35, 0x35, 0x61, 0x35, 0x64, 0x63, 0x34, 0x34, 0x62, 0x66, 0x34, 0x66, 0x62, 0x33, 0x36, 0x31, 0x34, 0x36, 0x39, 0x30, 0x66, 0x30, 0x64, 0x31, 0x37, 0x34, 0x65, 0x34, 0x33, 0x65, 0x64, 0x37, 0x33, 0x34, 0x63, 0x66, 0x31, 0x65, 0x66, 0x63, 0x61, 0x33, 0x65, 0x32, 0x34, 0x35, 0x63, 0x62, 0x34, 0x31, 0x37, 0x64, 0x36, 0x31, 0x34, 0x35, 0x35, 0x34, 0x34, 0x37, 0x34, 0x37, 0x36, 0x34, 0x33, 0x38, 0x61, 0x36, 0x33, 0x64, 0x66, 0x34, 0x63, 0x36, 0x37, 0x39, 0x33, 0x30, 0x35, 0x32, 0x30, 0x63, 0x32, 0x39, 0x33, 0x66, 0x37, 0x31, 0x63, 0x33, 0x38, 0x31, 0x31, 0x66, 0x66, 0x66, 0x30, 0x66, 0x39, 0x30, 0x37, 0x32, 0x63, 0x35, 0x31, 0x36, 0x38, 0x35, 0x39, 0x30, 0x35, 0x64, 0x38, 0x37, 0x64, 0x38, 0x32, 0x33, 0x37, 0x63, 0x39, 0x64, 0x34, 0x33, 0x31, 0x31, 0x61, 0x61, 0x33, 0x61, 0x61, 0x33, 0x37, 0x39, 0x61, 0x37, 0x32, 0x32, 0x61, 0x65, 0x34, 0x64, 0x61, 0x31, 0x33, 0x32, 0x62, 0x39, 0x35, 0x38, 0x39, 0x31, 0x62, 0x31, 0x65, 0x34, 0x66, 0x34, 0x37, 0x65, 0x36, 0x62, 0x36, 0x31, 0x35, 0x38, 0x63, 0x62, 0x36, 0x32, 0x61, 0x35, 0x38, 0x62, 0x66, 0x30, 0x31, 0x36, 0x63, 0x39, 0x37, 0x63, 0x61, 0x30, 0x66, 0x37, 0x37, 0x30, 0x30, 0x61, 0x66, 0x30, 0x61, 0x61, 0x30, 0x66, 0x36, 0x63, 0x37, 0x37, 0x32, 0x39, 0x62, 0x30, 0x37, 0x34, 0x63, 0x33, 0x36, 0x37, 0x36, 0x62, 0x62, 0x63, 0x37, 0x35, 0x66, 0x63, 0x37, 0x31, 0x62, 0x64, 0x35, 0x32, 0x64, 0x61, 0x37, 0x36, 0x62, 0x31, 0x61, 0x63, 0x30, 0x38, 0x33, 0x34, 0x33, 0x65, 0x66, 0x31, 0x30, 0x66, 0x30, 0x30, 0x31, 0x33, 0x64, 0x64, 0x30, 0x35, 0x35, 0x35, 0x31, 0x65, 0x63, 0x30, 0x64, 0x32, 0x33, 0x32, 0x63, 0x35, 0x30, 0x37, 0x32, 0x62, 0x63, 0x30, 0x37, 0x36, 0x33, 0x31, 0x37, 0x38, 0x63, 0x35, 0x32, 0x34, 0x37, 0x66, 0x65, 0x31, 0x61, 0x61, 0x36, 0x33, 0x64, 0x37, 0x36, 0x34, 0x31, 0x61, 0x31, 0x34, 0x34, 0x33, 0x64, 0x64, 0x30, 0x64, 0x34, 0x66, 0x32, 0x38, 0x61, 0x62, 0x62, 0x64, 0x62, 0x31, 0x34, 0x34, 0x35, 0x36, 0x32, 0x38, 0x66, 0x37, 0x39, 0x31, 0x65, 0x34, 0x33, 0x37, 0x37, 0x32, 0x63, 0x37, 0x32, 0x63, 0x31, 0x30, 0x64, 0x31, 0x35, 0x33, 0x62, 0x36, 0x63, 0x31, 0x62, 0x38, 0x37, 0x32, 0x64, 0x30, 0x37, 0x34, 0x39, 0x37, 0x62, 0x35, 0x31, 0x64, 0x65, 0x30, 0x64, 0x31, 0x63, 0x37, 0x34, 0x35, 0x35, 0x34, 0x33, 0x38, 0x66, 0x61, 0x37, 0x37, 0x63, 0x32, 0x35, 0x34, 0x38, 0x62, 0x35, 0x30, 0x66, 0x31, 0x32, 0x62, 0x37, 0x61, 0x39, 0x62, 0x33, 0x33, 0x39, 0x38, 0x35, 0x35, 0x64, 0x37, 0x63, 0x35, 0x35, 0x63, 0x61, 0x36, 0x39, 0x33, 0x30, 0x34, 0x33, 0x34, 0x65, 0x37, 0x31, 0x35, 0x31, 0x30, 0x62, 0x36, 0x65, 0x33, 0x66, 0x31, 0x37, 0x39, 0x63, 0x62, 0x64, 0x30, 0x36, 0x34, 0x66, 0x65, 0x38, 0x34, 0x34, 0x33, 0x63, 0x65, 0x35, 0x62, 0x62, 0x32, 0x64, 0x31, 0x37, 0x37, 0x33, 0x36, 0x35, 0x39, 0x39, 0x35, 0x64, 0x38, 0x39, 0x61, 0x31, 0x32, 0x61, 0x37, 0x32, 0x33, 0x38, 0x38, 0x62, 0x37, 0x64, 0x33, 0x64, 0x65, 0x65, 0x32, 0x37, 0x66, 0x33, 0x33, 0x63, 0x66, 0x65, 0x34, 0x36, 0x31, 0x37, 0x35, 0x38, 0x32, 0x66, 0x64, 0x63, 0x64, 0x64, 0x34, 0x62, 0x32, 0x65, 0x66, 0x39, 0x64, 0x35, 0x35, 0x38, 0x61, 0x36, 0x31, 0x64, 0x36, 0x35, 0x61, 0x65, 0x34, 0x35, 0x62, 0x35, 0x34, 0x33, 0x66, 0x37, 0x63, 0x36, 0x32, 0x61, 0x65, 0x34, 0x34, 0x64, 0x34, 0x30, 0x61, 0x30, 0x66, 0x62, 0x36, 0x35, 0x32, 0x63, 0x34, 0x39, 0x66, 0x33, 0x63, 0x35, 0x62, 0x66, 0x63, 0x65, 0x32, 0x39, 0x38, 0x34, 0x61, 0x62, 0x33, 0x38, 0x32, 0x30, 0x64, 0x36, 0x34, 0x31, 0x38, 0x37, 0x35, 0x39, 0x31, 0x64, 0x32, 0x66, 0x37, 0x37, 0x62, 0x30, 0x36, 0x65, 0x36, 0x31, 0x64, 0x30, 0x37, 0x31, 0x36, 0x63, 0x65, 0x66, 0x65, 0x61, 0x31, 0x65, 0x37, 0x32, 0x61, 0x30, 0x30, 0x38, 0x64, 0x31, 0x39, 0x33, 0x36, 0x61, 0x37, 0x61, 0x36, 0x63, 0x64, 0x35, 0x37, 0x63, 0x30, 0x66, 0x39, 0x39, 0x61, 0x64, 0x39, 0x32, 0x38, 0x35, 0x38, 0x39, 0x30, 0x30, 0x33, 0x30, 0x36, 0x65, 0x39, 0x39, 0x63, 0x34, 0x63, 0x38, 0x66, 0x31, 0x31, 0x39, 0x33, 0x37, 0x64, 0x34, 0x35, 0x30, 0x63, 0x38, 0x38, 0x36, 0x31, 0x62, 0x62, 0x66, 0x61, 0x64, 0x37, 0x32, 0x64, 0x64, 0x32, 0x61, 0x32, 0x66, 0x64, 0x64, 0x36, 0x38, 0x39, 0x30, 0x66, 0x31, 0x30, 0x38, 0x38, 0x30, 0x35, 0x30, 0x64, 0x33, 0x34, 0x33, 0x38, 0x31, 0x39, 0x39, 0x39, 0x62, 0x38, 0x38, 0x36, 0x66, 0x64, 0x36, 0x66, 0x30, 0x31, 0x64, 0x66, 0x65, 0x64, 0x34, 0x66, 0x33, 0x33, 0x31, 0x65, 0x34, 0x31, 0x30, 0x64, 0x64, 0x38, 0x34, 0x35, 0x63, 0x66, 0x38, 0x61, 0x36, 0x37, 0x32, 0x39, 0x37, 0x31, 0x33, 0x34, 0x36, 0x62, 0x36, 0x39, 0x37, 0x36, 0x66, 0x64, 0x66, 0x65, 0x33, 0x36, 0x62, 0x62, 0x35, 0x65, 0x35, 0x65, 0x39, 0x32, 0x36, 0x36, 0x33, 0x64, 0x39, 0x31, 0x62, 0x35, 0x61, 0x35, 0x61, 0x35, 0x37, 0x64, 0x32, 0x36, 0x39, 0x65, 0x61, 0x66, 0x30, 0x61, 0x64, 0x38, 0x36, 0x62, 0x35, 0x63, 0x66, 0x66, 0x65, 0x62, 0x30, 0x30, 0x31, 0x38, 0x38, 0x30, 0x64, 0x30, 0x38, 0x65, 0x65, 0x38, 0x33, 0x38, 0x36, 0x36, 0x66, 0x65, 0x36, 0x35, 0x31, 0x35, 0x35, 0x34, 0x66, 0x38, 0x64, 0x65, 0x33, 0x38, 0x39, 0x64, 0x37, 0x62, 0x66, 0x66, 0x34, 0x64, 0x64, 0x62, 0x64, 0x37, 0x36, 0x66, 0x63, 0x35, 0x36, 0x31, 0x34, 0x38, 0x39, 0x32, 0x31, 0x36, 0x32, 0x32, 0x33, 0x61, 0x64, 0x35, 0x33, 0x36, 0x64, 0x38, 0x32, 0x65, 0x37, 0x63, 0x61, 0x32, 0x65, 0x31, 0x38, 0x32, 0x36, 0x31, 0x65, 0x62, 0x36, 0x35, 0x39, 0x30, 0x31, 0x33, 0x36, 0x30, 0x32, 0x62, 0x63, 0x34, 0x64, 0x65, 0x34, 0x33, 0x30, 0x34, 0x38, 0x37, 0x65, 0x63, 0x66, 0x39, 0x64, 0x37, 0x37, 0x37, 0x62, 0x64, 0x61, 0x66, 0x32, 0x33, 0x65, 0x65, 0x64, 0x33, 0x64, 0x36, 0x33, 0x34, 0x30, 0x35, 0x62, 0x35, 0x66, 0x34, 0x38, 0x37, 0x35, 0x66, 0x39, 0x36, 0x61, 0x31, 0x64, 0x32, 0x65, 0x31, 0x38, 0x31, 0x31, 0x31, 0x31, 0x33, 0x31, 0x35, 0x62, 0x33, 0x65, 0x30, 0x31, 0x32, 0x36, 0x39, 0x33, 0x66, 0x37, 0x35, 0x37, 0x32, 0x64, 0x35, 0x62, 0x32, 0x35, 0x61, 0x36, 0x65, 0x35, 0x65, 0x63, 0x38, 0x61, 0x66, 0x64, 0x62, 0x63, 0x61, 0x30, 0x32, 0x32, 0x30, 0x35, 0x61, 0x31, 0x64, 0x31, 0x35, 0x37, 0x31, 0x61, 0x66, 0x62, 0x37, 0x61, 0x32, 0x66, 0x37, 0x32, 0x66, 0x61, 0x32, 0x34, 0x62, 0x64, 0x65, 0x39, 0x36, 0x31, 0x36, 0x33, 0x36, 0x35, 0x30, 0x36, 0x39, 0x62, 0x32, 0x33, 0x30, 0x61, 0x37, 0x34, 0x34, 0x30, 0x30, 0x39, 0x32, 0x36, 0x39, 0x63, 0x64, 0x65, 0x31, 0x64, 0x35, 0x63, 0x38, 0x66, 0x36, 0x30, 0x64, 0x30, 0x31, 0x62, 0x36, 0x34, 0x63, 0x37, 0x65, 0x62, 0x31, 0x64, 0x31, 0x31, 0x63, 0x34, 0x36, 0x38, 0x66, 0x30, 0x36, 0x35, 0x63, 0x62, 0x37, 0x30, 0x64, 0x30, 0x37, 0x32, 0x31, 0x33, 0x36, 0x61, 0x64, 0x35, 0x33, 0x34, 0x62, 0x63, 0x31, 0x32, 0x33, 0x66, 0x30, 0x36, 0x39, 0x39, 0x63, 0x33, 0x64, 0x37, 0x64, 0x39, 0x36, 0x63, 0x32, 0x31, 0x38, 0x31, 0x31, 0x32, 0x38, 0x30, 0x62, 0x31, 0x34, 0x64, 0x30, 0x63, 0x36, 0x32, 0x38, 0x63, 0x32, 0x30, 0x64, 0x32, 0x65, 0x38, 0x34, 0x31, 0x34, 0x66, 0x37, 0x32, 0x64, 0x64, 0x65, 0x38, 0x33, 0x39, 0x64, 0x36, 0x66, 0x31, 0x36, 0x61, 0x63, 0x36, 0x66, 0x38, 0x34, 0x62, 0x66, 0x31, 0x61, 0x37, 0x30, 0x32, 0x61, 0x36, 0x63, 0x61, 0x36, 0x66, 0x31, 0x36, 0x35, 0x64, 0x35, 0x31, 0x61, 0x66, 0x64, 0x36, 0x63, 0x36, 0x33, 0x61, 0x62, 0x39, 0x33, 0x34, 0x39, 0x34, 0x37, 0x38, 0x65, 0x63, 0x35, 0x61, 0x34, 0x36, 0x39, 0x61, 0x62, 0x66, 0x37, 0x32, 0x31, 0x66, 0x38, 0x39, 0x62, 0x32, 0x38, 0x64, 0x34, 0x65, 0x32, 0x33, 0x38, 0x35, 0x38, 0x31, 0x65, 0x63, 0x33, 0x61, 0x35, 0x36, 0x66, 0x66, 0x31, 0x34, 0x32, 0x36, 0x39, 0x38, 0x66, 0x36, 0x64, 0x30, 0x64, 0x63, 0x63, 0x37, 0x38, 0x39, 0x36, 0x61, 0x37, 0x37, 0x38, 0x39, 0x37, 0x35, 0x31, 0x63, 0x30, 0x39, 0x37, 0x37, 0x63, 0x30, 0x32, 0x61, 0x31, 0x32, 0x64, 0x62, 0x37, 0x32, 0x32, 0x37, 0x32, 0x35, 0x35, 0x30, 0x35, 0x39, 0x37, 0x35, 0x64, 0x36, 0x65, 0x64, 0x32, 0x63, 0x63, 0x34, 0x61, 0x36, 0x35, 0x32, 0x65, 0x33, 0x39, 0x65, 0x38, 0x62, 0x33, 0x63, 0x61, 0x34, 0x63, 0x63, 0x63, 0x33, 0x64, 0x36, 0x35, 0x65, 0x36, 0x30, 0x35, 0x35, 0x63, 0x32, 0x64, 0x33, 0x32, 0x62, 0x34, 0x31, 0x38, 0x65, 0x65, 0x64, 0x66, 0x61, 0x61, 0x31, 0x37, 0x61, 0x37, 0x32, 0x30, 0x38, 0x32, 0x36, 0x38, 0x30, 0x35, 0x30, 0x33, 0x63, 0x65, 0x38, 0x38, 0x38, 0x38, 0x37, 0x36, 0x65, 0x31, 0x62, 0x64, 0x37, 0x33, 0x63, 0x32, 0x37, 0x34, 0x32, 0x39, 0x63, 0x35, 0x35, 0x61, 0x38, 0x61, 0x37, 0x31, 0x35, 0x62, 0x33, 0x64, 0x36, 0x65, 0x65, 0x33, 0x39, 0x65, 0x64, 0x66, 0x65, 0x65, 0x39, 0x39, 0x38, 0x35, 0x34, 0x63, 0x36, 0x34, 0x34, 0x64, 0x61, 0x33, 0x35, 0x32, 0x62, 0x61, 0x39, 0x34, 0x66, 0x61, 0x65, 0x62, 0x66, 0x61, 0x66, 0x65, 0x33, 0x34, 0x31, 0x32, 0x32, 0x33, 0x36, 0x64, 0x62, 0x63, 0x62, 0x31, 0x65, 0x30, 0x61, 0x66, 0x65, 0x63, 0x34, 0x37, 0x38, 0x30, 0x34, 0x37, 0x66, 0x33, 0x35, 0x63, 0x65, 0x35, 0x30, 0x64, 0x61, 0x36, 0x66, 0x35, 0x63, 0x36, 0x64, 0x37, 0x39, 0x34, 0x66, 0x33, 0x36, 0x63, 0x38, 0x36, 0x66, 0x37, 0x32, 0x39, 0x38, 0x35, 0x35, 0x34, 0x63, 0x31, 0x62, 0x63, 0x35, 0x66, 0x38, 0x37, 0x64, 0x62, 0x31, 0x62, 0x36, 0x63, 0x38, 0x65, 0x64, 0x30, 0x64, 0x65, 0x31, 0x34, 0x65, 0x35, 0x64, 0x64, 0x61, 0x37, 0x63, 0x32, 0x30, 0x30, 0x62, 0x65, 0x66, 0x33, 0x34, 0x35, 0x31, 0x33, 0x65, 0x66, 0x37, 0x37, 0x64, 0x37, 0x39, 0x34, 0x31, 0x34, 0x32, 0x63, 0x34, 0x32, 0x34, 0x32, 0x37, 0x37, 0x32, 0x61, 0x31, 0x34, 0x39, 0x66, 0x39, 0x66, 0x33, 0x34, 0x62, 0x62, 0x61, 0x62, 0x35, 0x65, 0x39, 0x39, 0x38, 0x30, 0x63, 0x33, 0x32, 0x64, 0x34, 0x65, 0x63, 0x38, 0x64, 0x38, 0x65, 0x32, 0x66, 0x30, 0x66, 0x32, 0x32, 0x30, 0x61, 0x33, 0x30, 0x30, 0x64, 0x64, 0x63, 0x31, 0x34, 0x63, 0x65, 0x35, 0x30, 0x61, 0x64, 0x33, 0x33, 0x35, 0x63, 0x38, 0x63, 0x66, 0x35, 0x32, 0x36, 0x35, 0x37, 0x38, 0x61, 0x38, 0x39, 0x30, 0x38, 0x37, 0x62, 0x37, 0x34, 0x62, 0x39, 0x32, 0x31, 0x65, 0x63, 0x62, 0x38, 0x34, 0x63, 0x63, 0x35, 0x63, 0x31, 0x36, 0x63, 0x30, 0x33, 0x35, 0x64, 0x66, 0x62, 0x30, 0x38, 0x34, 0x66, 0x64, 0x33, 0x64, 0x66, 0x34, 0x34, 0x64, 0x62, 0x30, 0x65, 0x64, 0x37, 0x35, 0x34, 0x32, 0x35, 0x31, 0x30, 0x66, 0x38, 0x62, 0x35, 0x36, 0x66, 0x66, 0x39, 0x37, 0x32, 0x38, 0x34, 0x30, 0x38, 0x31, 0x37, 0x38, 0x30, 0x36, 0x37, 0x62, 0x63, 0x37, 0x31, 0x37, 0x61, 0x31, 0x35, 0x37, 0x37, 0x64, 0x61, 0x39, 0x36, 0x31, 0x63, 0x36, 0x66, 0x36, 0x35, 0x38, 0x39, 0x34, 0x33, 0x32, 0x34, 0x31, 0x61, 0x36, 0x39, 0x63, 0x38, 0x32, 0x39, 0x39, 0x62, 0x64, 0x39, 0x38, 0x65, 0x30, 0x38, 0x37, 0x38, 0x33, 0x31, 0x62, 0x36, 0x34, 0x63, 0x61, 0x37, 0x37, 0x32, 0x32, 0x35, 0x64, 0x36, 0x37, 0x62, 0x30, 0x39, 0x61, 0x64, 0x61, 0x34, 0x33, 0x33, 0x37, 0x62, 0x65, 0x35, 0x38, 0x39, 0x31, 0x33, 0x62, 0x63, 0x33, 0x35, 0x31, 0x32, 0x63, 0x35, 0x33, 0x37, 0x64, 0x66, 0x37, 0x32, 0x65, 0x31, 0x66, 0x35, 0x31, 0x34, 0x31, 0x63, 0x34, 0x39, 0x34, 0x33, 0x65, 0x32, 0x62, 0x34, 0x66, 0x63, 0x61, 0x64, 0x32, 0x66, 0x36, 0x31, 0x62, 0x30, 0x37, 0x32, 0x31, 0x66, 0x35, 0x38, 0x65, 0x61, 0x36, 0x32, 0x32, 0x39, 0x62, 0x37, 0x64, 0x31, 0x64, 0x66, 0x39, 0x32, 0x62, 0x65, 0x35, 0x35, 0x36, 0x36, 0x38, 0x62, 0x66, 0x65, 0x33, 0x39, 0x63, 0x65, 0x36, 0x62, 0x31, 0x62, 0x32, 0x36, 0x33, 0x36, 0x65, 0x66, 0x64, 0x63, 0x33, 0x34, 0x30, 0x32, 0x33, 0x32, 0x39, 0x33, 0x32, 0x62, 0x36, 0x38, 0x61, 0x39, 0x61, 0x39, 0x38, 0x63, 0x37, 0x32, 0x62, 0x38, 0x30, 0x33, 0x66, 0x66, 0x35, 0x32, 0x32, 0x33, 0x36, 0x30, 0x39, 0x31, 0x33, 0x64, 0x63, 0x61, 0x36, 0x32, 0x33, 0x39, 0x39, 0x39, 0x64, 0x38, 0x36, 0x30, 0x31, 0x37, 0x31, 0x66, 0x62, 0x33, 0x65, 0x65, 0x34, 0x35, 0x39, 0x34, 0x32, 0x62, 0x32, 0x36, 0x61, 0x34, 0x62, 0x36, 0x61, 0x36, 0x36, 0x33, 0x36, 0x34, 0x66, 0x61, 0x33, 0x35, 0x37, 0x31, 0x65, 0x61, 0x37, 0x32, 0x32, 0x37, 0x38, 0x39, 0x66, 0x31, 0x36, 0x38, 0x37, 0x35, 0x32, 0x37, 0x39, 0x31, 0x35, 0x30, 0x63, 0x32, 0x64, 0x63, 0x33, 0x30, 0x66, 0x65, 0x38, 0x34, 0x64, 0x65, 0x39, 0x34, 0x65, 0x34, 0x32, 0x38, 0x63, 0x34, 0x64, 0x37, 0x64, 0x62, 0x61, 0x36, 0x62, 0x61, 0x39, 0x63, 0x31, 0x66, 0x66, 0x37, 0x61, 0x62, 0x37, 0x62, 0x38, 0x61, 0x33, 0x30, 0x30, 0x66, 0x35, 0x34, 0x31, 0x37, 0x32, 0x66, 0x32, 0x38, 0x33, 0x30, 0x37, 0x35, 0x62, 0x33, 0x66, 0x38, 0x34, 0x61, 0x36, 0x33, 0x32, 0x30, 0x30, 0x61, 0x37, 0x31, 0x36, 0x38, 0x64, 0x35, 0x37, 0x64, 0x33, 0x61, 0x39, 0x34, 0x35, 0x38, 0x66, 0x65, 0x30, 0x36, 0x35, 0x33, 0x38, 0x35, 0x63, 0x66, 0x63, 0x30, 0x61, 0x30, 0x62, 0x33, 0x61, 0x39, 0x64, 0x36, 0x65, 0x37, 0x66, 0x37, 0x65, 0x38, 0x33, 0x62, 0x37, 0x32, 0x38, 0x66, 0x63, 0x36, 0x64, 0x61, 0x36, 0x63, 0x62, 0x66, 0x36, 0x32, 0x66, 0x34, 0x33, 0x65, 0x37, 0x30, 0x30, 0x65, 0x35, 0x38, 0x36, 0x35, 0x62, 0x37, 0x65, 0x66, 0x34, 0x32, 0x30, 0x30, 0x39, 0x63, 0x39, 0x66, 0x65, 0x34, 0x34, 0x64, 0x66, 0x36, 0x32, 0x33, 0x34, 0x31, 0x34, 0x37, 0x35, 0x37, 0x64, 0x34, 0x38, 0x35, 0x32, 0x65, 0x35, 0x64, 0x31, 0x61, 0x61, 0x34, 0x37, 0x32, 0x37, 0x66, 0x37, 0x37, 0x36, 0x36, 0x62, 0x32, 0x36, 0x31, 0x37, 0x35, 0x65, 0x33, 0x31, 0x30, 0x32, 0x39, 0x30, 0x35, 0x33, 0x39, 0x36, 0x64, 0x36, 0x62, 0x30, 0x63, 0x35, 0x65, 0x30, 0x66, 0x31, 0x34, 0x62, 0x31, 0x35, 0x33, 0x35, 0x38, 0x34, 0x30, 0x65, 0x61, 0x63, 0x33, 0x61, 0x63, 0x66, 0x31, 0x36, 0x66, 0x39, 0x63, 0x37, 0x62, 0x65, 0x32, 0x63, 0x31, 0x63, 0x31, 0x32, 0x30, 0x65, 0x30, 0x39, 0x33, 0x33, 0x33, 0x32, 0x33, 0x63, 0x65, 0x36, 0x65, 0x39, 0x63, 0x63, 0x64, 0x30, 0x64, 0x36, 0x66, 0x66, 0x63, 0x32, 0x33, 0x63, 0x30, 0x37, 0x30, 0x37, 0x30, 0x34, 0x66, 0x38, 0x39, 0x65, 0x37, 0x37, 0x61, 0x36, 0x63, 0x61, 0x37, 0x35, 0x33, 0x65, 0x39, 0x37, 0x37, 0x32, 0x39, 0x63, 0x65, 0x65, 0x31, 0x35, 0x33, 0x32, 0x31, 0x35, 0x61, 0x65, 0x62, 0x37, 0x32, 0x66, 0x35, 0x36, 0x37, 0x32, 0x62, 0x37, 0x38, 0x32, 0x31, 0x35, 0x33, 0x39, 0x63, 0x33, 0x38, 0x33, 0x33, 0x39, 0x62, 0x34, 0x61, 0x34, 0x66, 0x62, 0x65, 0x66, 0x39, 0x66, 0x33, 0x32, 0x30, 0x63, 0x64, 0x39, 0x36, 0x64, 0x39, 0x33, 0x34, 0x66, 0x64, 0x64, 0x31, 0x61, 0x63, 0x33, 0x33, 0x38, 0x33, 0x38, 0x64, 0x35, 0x61, 0x63, 0x37, 0x36, 0x64, 0x61, 0x30, 0x35, 0x37, 0x33, 0x37, 0x33, 0x34, 0x37, 0x31, 0x64, 0x62, 0x34, 0x39, 0x31, 0x37, 0x32, 0x39, 0x65, 0x34, 0x66, 0x64, 0x37, 0x62, 0x38, 0x39, 0x37, 0x36, 0x34, 0x36, 0x38, 0x66, 0x35, 0x35, 0x30, 0x62, 0x30, 0x62, 0x37, 0x37, 0x39, 0x31, 0x63, 0x30, 0x35, 0x38, 0x65, 0x34, 0x37, 0x34, 0x35, 0x66, 0x33, 0x64, 0x39, 0x64, 0x61, 0x33, 0x64, 0x36, 0x66, 0x37, 0x31, 0x34, 0x65, 0x39, 0x31, 0x66, 0x37, 0x32, 0x35, 0x30, 0x63, 0x66, 0x61, 0x66, 0x35, 0x32, 0x39, 0x34, 0x61, 0x63, 0x63, 0x66, 0x37, 0x33, 0x37, 0x63, 0x62, 0x33, 0x65, 0x34, 0x36, 0x65, 0x64, 0x32, 0x61, 0x33, 0x32, 0x64, 0x30, 0x61, 0x66, 0x66, 0x34, 0x66, 0x62, 0x32, 0x35, 0x31, 0x62, 0x61, 0x33, 0x31, 0x36, 0x61, 0x33, 0x30, 0x65, 0x32, 0x63, 0x65, 0x36, 0x61, 0x62, 0x38, 0x30, 0x39, 0x37, 0x66, 0x31, 0x39, 0x37, 0x32, 0x31, 0x63, 0x39, 0x35, 0x62, 0x35, 0x37, 0x30, 0x37, 0x62, 0x64, 0x32, 0x36, 0x37, 0x33, 0x64, 0x30, 0x32, 0x62, 0x30, 0x31, 0x38, 0x34, 0x31, 0x66, 0x33, 0x36, 0x32, 0x34, 0x61, 0x33, 0x39, 0x34, 0x33, 0x32, 0x61, 0x66, 0x33, 0x62, 0x38, 0x33, 0x30, 0x31, 0x66, 0x37, 0x37, 0x35, 0x36, 0x65, 0x37, 0x35, 0x63, 0x36, 0x32, 0x64, 0x66, 0x63, 0x32, 0x33, 0x38, 0x32, 0x61, 0x32, 0x63, 0x33, 0x31, 0x39, 0x31, 0x35, 0x61, 0x33, 0x63, 0x30, 0x39, 0x64, 0x65, 0x34, 0x31, 0x35, 0x34, 0x63, 0x64, 0x61, 0x32, 0x61, 0x62, 0x32, 0x36, 0x65, 0x31, 0x34, 0x31, 0x39, 0x62, 0x37, 0x66, 0x39, 0x33, 0x36, 0x33, 0x61, 0x39, 0x38, 0x66, 0x64, 0x36, 0x37, 0x36, 0x34, 0x61, 0x30, 0x38, 0x33, 0x36, 0x66, 0x39, 0x61, 0x64, 0x39, 0x36, 0x64, 0x66, 0x61, 0x36, 0x39, 0x32, 0x37, 0x32, 0x62, 0x32, 0x35, 0x37, 0x34, 0x65, 0x66, 0x34, 0x31, 0x64, 0x31, 0x39, 0x33, 0x35, 0x31, 0x63, 0x35, 0x37, 0x32, 0x35, 0x31, 0x36, 0x35, 0x62, 0x37, 0x30, 0x64, 0x36, 0x64, 0x37, 0x64, 0x66, 0x63, 0x63, 0x32, 0x38, 0x38, 0x32, 0x39, 0x39, 0x33, 0x31, 0x34, 0x33, 0x66, 0x36, 0x61, 0x31, 0x34, 0x66, 0x30, 0x65, 0x34, 0x36, 0x30, 0x36, 0x30, 0x36, 0x35, 0x61, 0x33, 0x32, 0x33, 0x34, 0x39, 0x32, 0x33, 0x61, 0x33, 0x65, 0x37, 0x36, 0x34, 0x34, 0x33, 0x37, 0x36, 0x38, 0x62, 0x65, 0x37, 0x38, 0x63, 0x39, 0x39, 0x35, 0x37, 0x65, 0x31, 0x63, 0x66, 0x37, 0x65, 0x62, 0x63, 0x38, 0x64, 0x37, 0x36, 0x38, 0x31, 0x62, 0x35, 0x64, 0x37, 0x37, 0x34, 0x33, 0x62, 0x33, 0x34, 0x38, 0x34, 0x33, 0x32, 0x64, 0x61, 0x62, 0x34, 0x61, 0x33, 0x37, 0x63, 0x36, 0x36, 0x34, 0x37, 0x32, 0x63, 0x38, 0x61, 0x65, 0x65, 0x64, 0x66, 0x37, 0x37, 0x37, 0x63, 0x36, 0x62, 0x33, 0x31, 0x63, 0x61, 0x36, 0x66, 0x64, 0x65, 0x39, 0x32, 0x39, 0x63, 0x36, 0x34, 0x35, 0x61, 0x65, 0x30, 0x64, 0x33, 0x37, 0x30, 0x34, 0x36, 0x39, 0x31, 0x62, 0x33, 0x64, 0x65, 0x34, 0x39, 0x34, 0x63, 0x61, 0x33, 0x65, 0x38, 0x34, 0x35, 0x39, 0x31, 0x33, 0x37, 0x30, 0x31, 0x61, 0x37, 0x36, 0x37, 0x32, 0x35, 0x34, 0x32, 0x30, 0x30, 0x66, 0x33, 0x66, 0x65, 0x66, 0x38, 0x38, 0x31, 0x37, 0x30, 0x61, 0x38, 0x35, 0x31, 0x31, 0x66, 0x62, 0x36, 0x64, 0x36, 0x39, 0x31, 0x61, 0x34, 0x64, 0x37, 0x30, 0x37, 0x33, 0x61, 0x32, 0x65, 0x65, 0x37, 0x35, 0x33, 0x64, 0x36, 0x61, 0x66, 0x62, 0x33, 0x64, 0x63, 0x66, 0x33, 0x65, 0x31, 0x62, 0x63, 0x64, 0x35, 0x36, 0x37, 0x39, 0x61, 0x63, 0x30, 0x31, 0x61, 0x38, 0x61, 0x63, 0x64, 0x39, 0x61, 0x30, 0x63, 0x39, 0x62, 0x63, 0x61, 0x38, 0x37, 0x32, 0x30, 0x34, 0x62, 0x63, 0x37, 0x32, 0x66, 0x33, 0x39, 0x38, 0x64, 0x36, 0x66, 0x37, 0x61, 0x30, 0x61, 0x33, 0x62, 0x66, 0x39, 0x33, 0x38, 0x64, 0x63, 0x33, 0x33, 0x63, 0x34, 0x31, 0x33, 0x66, 0x33, 0x33, 0x63, 0x64, 0x37, 0x30, 0x39, 0x39, 0x38, 0x38, 0x61, 0x65, 0x65, 0x65, 0x33, 0x36, 0x39, 0x64, 0x37, 0x61, 0x32, 0x38, 0x32, 0x30, 0x63, 0x31, 0x34, 0x66, 0x30, 0x63, 0x38, 0x37, 0x37, 0x37, 0x37, 0x62, 0x38, 0x64, 0x35, 0x32, 0x63, 0x61, 0x33, 0x34, 0x38, 0x35, 0x66, 0x61, 0x38, 0x65, 0x35, 0x63, 0x32, 0x35, 0x63, 0x39, 0x62, 0x61, 0x30, 0x39, 0x64, 0x37, 0x62, 0x34, 0x33, 0x31, 0x38, 0x34, 0x66, 0x61, 0x38, 0x63, 0x61, 0x65, 0x33, 0x31, 0x31, 0x34, 0x37, 0x32, 0x39, 0x64, 0x39, 0x31, 0x37, 0x62, 0x66, 0x30, 0x30, 0x33, 0x63, 0x38, 0x34, 0x66, 0x33, 0x62, 0x31, 0x61, 0x35, 0x66, 0x31, 0x34, 0x36, 0x66, 0x31, 0x30, 0x37, 0x30, 0x64, 0x36, 0x66, 0x31, 0x34, 0x36, 0x30, 0x62, 0x66, 0x64, 0x66, 0x31, 0x65, 0x31, 0x65, 0x62, 0x30, 0x38, 0x34, 0x32, 0x31, 0x35, 0x64, 0x32, 0x36, 0x38, 0x61, 0x35, 0x61, 0x62, 0x35, 0x66, 0x30, 0x32, 0x37, 0x32, 0x37, 0x38, 0x66, 0x66, 0x65, 0x63, 0x33, 0x38, 0x65, 0x35, 0x65, 0x37, 0x31, 0x61, 0x34, 0x35, 0x38, 0x35, 0x30, 0x65, 0x35, 0x35, 0x33, 0x64, 0x61, 0x32, 0x30, 0x37, 0x36, 0x64, 0x31, 0x61, 0x30, 0x66, 0x39, 0x66, 0x31, 0x39, 0x34, 0x38, 0x33, 0x62, 0x34, 0x39, 0x30, 0x64, 0x33, 0x65, 0x64, 0x61, 0x38, 0x30, 0x33, 0x64, 0x61, 0x61, 0x36, 0x30, 0x30, 0x33, 0x39, 0x34, 0x37, 0x32, 0x62, 0x31, 0x62, 0x37, 0x38, 0x61, 0x64, 0x65, 0x32, 0x65, 0x65, 0x64, 0x66, 0x37, 0x30, 0x38, 0x38, 0x36, 0x35, 0x34, 0x61, 0x65, 0x37, 0x33, 0x32, 0x62, 0x61, 0x39, 0x35, 0x38, 0x64, 0x66, 0x66, 0x30, 0x36, 0x38, 0x31, 0x62, 0x30, 0x34, 0x36, 0x61, 0x38, 0x36, 0x36, 0x35, 0x32, 0x65, 0x30, 0x30, 0x31, 0x30, 0x30, 0x62, 0x64, 0x61, 0x31, 0x63, 0x64, 0x37, 0x62, 0x30, 0x30, 0x38, 0x62, 0x35, 0x61, 0x65, 0x36, 0x66, 0x34, 0x39, 0x33, 0x35, 0x62, 0x36, 0x37, 0x39, 0x37, 0x64, 0x38, 0x37, 0x30, 0x63, 0x35, 0x30, 0x37, 0x38, 0x39, 0x32, 0x39, 0x37, 0x31, 0x31, 0x34, 0x65, 0x36, 0x62, 0x38, 0x35, 0x33, 0x37, 0x36, 0x30, 0x66, 0x36, 0x33, 0x36, 0x30, 0x33, 0x31, 0x31, 0x33, 0x64, 0x33, 0x61, 0x37, 0x31, 0x61, 0x62, 0x62, 0x39, 0x66, 0x38, 0x34, 0x37, 0x37, 0x32, 0x32, 0x39, 0x37, 0x31, 0x35, 0x66, 0x34, 0x39, 0x66, 0x37, 0x62, 0x35, 0x62, 0x34, 0x37, 0x31, 0x61, 0x38, 0x62, 0x66, 0x32, 0x65, 0x66, 0x32, 0x37, 0x61, 0x65, 0x62, 0x35, 0x32, 0x61, 0x37, 0x35, 0x32, 0x64, 0x34, 0x31, 0x31, 0x33, 0x38, 0x37, 0x39, 0x30, 0x37, 0x35, 0x37, 0x34, 0x36, 0x33, 0x31, 0x61, 0x38, 0x33, 0x31, 0x36, 0x33, 0x35, 0x63, 0x62, 0x32, 0x39, 0x66, 0x37, 0x32, 0x36, 0x33, 0x64, 0x37, 0x63, 0x37, 0x66, 0x30, 0x61, 0x33, 0x63, 0x33, 0x31, 0x64, 0x66, 0x33, 0x38, 0x33, 0x33, 0x35, 0x66, 0x38, 0x34, 0x33, 0x35, 0x65, 0x30, 0x36, 0x35, 0x62, 0x62, 0x63, 0x34, 0x63, 0x63, 0x62, 0x32, 0x38, 0x32, 0x31, 0x64, 0x35, 0x31, 0x33, 0x33, 0x30, 0x37, 0x36, 0x33, 0x38, 0x63, 0x30, 0x32, 0x32, 0x63, 0x38, 0x66, 0x32, 0x36, 0x62, 0x34, 0x30, 0x36, 0x64, 0x33, 0x64, 0x37, 0x34, 0x32, 0x61, 0x30, 0x38, 0x31, 0x66, 0x35, 0x30, 0x37, 0x35, 0x33, 0x30, 0x30, 0x61, 0x31, 0x39, 0x37, 0x36, 0x66, 0x62, 0x31, 0x63, 0x66, 0x63, 0x63, 0x34, 0x65, 0x61, 0x38, 0x61, 0x66, 0x31, 0x35, 0x37, 0x30, 0x65, 0x66, 0x33, 0x39, 0x63, 0x30, 0x63, 0x37, 0x66, 0x62, 0x39, 0x38, 0x35, 0x66, 0x39, 0x64, 0x65, 0x64, 0x32, 0x64, 0x37, 0x66, 0x32, 0x37, 0x32, 0x33, 0x34, 0x34, 0x36, 0x61, 0x66, 0x38, 0x63, 0x66, 0x62, 0x63, 0x36, 0x61, 0x32, 0x63, 0x32, 0x61, 0x31, 0x32, 0x35, 0x32, 0x37, 0x31, 0x30, 0x35, 0x33, 0x32, 0x38, 0x33, 0x38, 0x66, 0x37, 0x30, 0x62, 0x36, 0x37, 0x61, 0x35, 0x62, 0x33, 0x35, 0x34, 0x34, 0x33, 0x61, 0x37, 0x38, 0x39, 0x31, 0x62, 0x30, 0x32, 0x62, 0x34, 0x31, 0x35, 0x39, 0x63, 0x36, 0x39, 0x65, 0x32, 0x37, 0x32, 0x61, 0x64, 0x34, 0x66, 0x35, 0x34, 0x39, 0x32, 0x37, 0x38, 0x66, 0x61, 0x31, 0x63, 0x65, 0x35, 0x62, 0x39, 0x33, 0x30, 0x39, 0x33, 0x65, 0x64, 0x39, 0x37, 0x33, 0x36, 0x39, 0x33, 0x65, 0x33, 0x31, 0x35, 0x66, 0x63, 0x36, 0x34, 0x63, 0x62, 0x66, 0x62, 0x66, 0x66, 0x66, 0x35, 0x66, 0x66, 0x65, 0x32, 0x32, 0x66, 0x36, 0x31, 0x37, 0x37, 0x33, 0x33, 0x65, 0x35, 0x66, 0x65, 0x36, 0x66, 0x32, 0x30, 0x30, 0x65, 0x37, 0x34, 0x63, 0x61, 0x30, 0x37, 0x35, 0x39, 0x62, 0x64, 0x31, 0x38, 0x32, 0x38, 0x63, 0x66, 0x32, 0x34, 0x31, 0x35, 0x66, 0x38, 0x65, 0x34, 0x34, 0x64, 0x64, 0x65, 0x62, 0x61, 0x33, 0x30, 0x32, 0x66, 0x39, 0x35, 0x32, 0x35, 0x65, 0x66, 0x34, 0x32, 0x37, 0x65, 0x65, 0x64, 0x66, 0x64, 0x36, 0x61, 0x30, 0x39, 0x66, 0x39, 0x36, 0x32, 0x61, 0x32, 0x35, 0x37, 0x37, 0x66, 0x32, 0x38, 0x64, 0x36, 0x37, 0x32, 0x61, 0x34, 0x62, 0x34, 0x64, 0x34, 0x32, 0x31, 0x62, 0x32, 0x66, 0x63, 0x37, 0x64, 0x65, 0x33, 0x36, 0x61, 0x37, 0x66, 0x32, 0x64, 0x63, 0x61, 0x37, 0x37, 0x63, 0x35, 0x62, 0x32, 0x64, 0x39, 0x65, 0x32, 0x39, 0x66, 0x37, 0x31, 0x66, 0x62, 0x66, 0x30, 0x32, 0x32, 0x64, 0x38, 0x32, 0x62, 0x36, 0x64, 0x30, 0x65, 0x61, 0x63, 0x33, 0x33, 0x61, 0x63, 0x33, 0x30, 0x32, 0x34, 0x35, 0x64, 0x37, 0x65, 0x63, 0x32, 0x31, 0x38, 0x62, 0x63, 0x34, 0x32, 0x32, 0x30, 0x30, 0x31, 0x31, 0x32, 0x65, 0x30, 0x62, 0x38, 0x37, 0x39, 0x34, 0x39, 0x39, 0x35, 0x37, 0x33, 0x64, 0x31, 0x32, 0x64, 0x34, 0x65, 0x30, 0x35, 0x61, 0x66, 0x38, 0x61, 0x39, 0x39, 0x35, 0x39, 0x61, 0x33, 0x32, 0x62, 0x65, 0x30, 0x38, 0x31, 0x37, 0x66, 0x37, 0x32, 0x61, 0x62, 0x33, 0x64, 0x35, 0x66, 0x39, 0x38, 0x36, 0x61, 0x31, 0x39, 0x33, 0x37, 0x33, 0x62, 0x30, 0x35, 0x63, 0x65, 0x31, 0x39, 0x32, 0x35, 0x33, 0x65, 0x62, 0x35, 0x61, 0x65, 0x65, 0x63, 0x34, 0x37, 0x33, 0x62, 0x39, 0x32, 0x34, 0x31, 0x62, 0x32, 0x61, 0x36, 0x36, 0x32, 0x61, 0x31, 0x34, 0x62, 0x39, 0x63, 0x35, 0x39, 0x66, 0x38, 0x61, 0x66, 0x30, 0x30, 0x37, 0x61, 0x35, 0x62, 0x37, 0x33, 0x31, 0x33, 0x37, 0x39, 0x33, 0x61, 0x37, 0x33, 0x35, 0x37, 0x33, 0x34, 0x62, 0x30, 0x38, 0x33, 0x30, 0x65, 0x65, 0x31, 0x31, 0x36, 0x61, 0x33, 0x32, 0x37, 0x62, 0x62, 0x34, 0x62, 0x65, 0x34, 0x32, 0x31, 0x36, 0x39, 0x61, 0x64, 0x36, 0x36, 0x62, 0x65, 0x39, 0x66, 0x35, 0x64, 0x37, 0x37, 0x39, 0x32, 0x34, 0x63, 0x65, 0x64, 0x33, 0x35, 0x62, 0x65, 0x31, 0x36, 0x37, 0x32, 0x31, 0x65, 0x35, 0x31, 0x32, 0x34, 0x65, 0x62, 0x65, 0x66, 0x66, 0x66, 0x35, 0x66, 0x39, 0x34, 0x62, 0x32, 0x37, 0x38, 0x36, 0x64, 0x31, 0x65, 0x63, 0x37, 0x38, 0x32, 0x32, 0x65, 0x31, 0x39, 0x65, 0x38, 0x31, 0x36, 0x34, 0x35, 0x30, 0x64, 0x61, 0x35, 0x33, 0x63, 0x62, 0x37, 0x30, 0x34, 0x62, 0x38, 0x39, 0x66, 0x61, 0x37, 0x33, 0x37, 0x30, 0x35, 0x63, 0x33, 0x32, 0x31, 0x35, 0x35, 0x31, 0x37, 0x36, 0x31, 0x33, 0x37, 0x65, 0x36, 0x35, 0x39, 0x30, 0x36, 0x64, 0x33, 0x36, 0x31, 0x61, 0x38, 0x61, 0x64, 0x30, 0x34, 0x39, 0x65, 0x33, 0x34, 0x39, 0x36, 0x63, 0x64, 0x39, 0x64, 0x63, 0x66, 0x39, 0x35, 0x63, 0x38, 0x39, 0x61, 0x62, 0x34, 0x61, 0x62, 0x38, 0x30, 0x66, 0x31, 0x62, 0x61, 0x32, 0x34, 0x37, 0x31, 0x31, 0x61, 0x63, 0x34, 0x31, 0x35, 0x62, 0x66, 0x37, 0x32, 0x34, 0x62, 0x37, 0x33, 0x33, 0x33, 0x31, 0x36, 0x33, 0x31, 0x36, 0x63, 0x63, 0x30, 0x30, 0x30, 0x39, 0x63, 0x38, 0x62, 0x38, 0x33, 0x37, 0x38, 0x64, 0x62, 0x37, 0x30, 0x30, 0x65, 0x31, 0x35, 0x37, 0x30, 0x30, 0x37, 0x34, 0x30, 0x36, 0x38, 0x37, 0x31, 0x62, 0x34, 0x30, 0x66, 0x65, 0x64, 0x37, 0x31, 0x36, 0x34, 0x31, 0x62, 0x38, 0x65, 0x34, 0x65, 0x33, 0x64, 0x63, 0x32, 0x37, 0x32, 0x39, 0x35, 0x35, 0x32, 0x37, 0x30, 0x36, 0x64, 0x39, 0x61, 0x61, 0x34, 0x30, 0x35, 0x65, 0x65, 0x34, 0x66, 0x32, 0x37, 0x65, 0x66, 0x31, 0x30, 0x63, 0x30, 0x30, 0x66, 0x35, 0x34, 0x63, 0x63, 0x66, 0x62, 0x34, 0x65, 0x33, 0x61, 0x30, 0x36, 0x66, 0x63, 0x37, 0x31, 0x66, 0x39, 0x30, 0x32, 0x34, 0x34, 0x35, 0x38, 0x37, 0x65, 0x66, 0x61, 0x36, 0x63, 0x37, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x31, 0x34, 0x31, 0x30, 0x63, 0x39, 0x62, 0x62, 0x34, 0x61, 0x65, 0x38, 0x38, 0x36, 0x39, 0x65, 0x35, 0x37, 0x64, 0x31, 0x33, 0x39, 0x65, 0x30, 0x35, 0x32, 0x30, 0x32, 0x36, 0x64, 0x66, 0x36, 0x66, 0x33, 0x66, 0x33, 0x34, 0x61, 0x35, 0x35, 0x32, 0x38, 0x32, 0x37, 0x39, 0x66, 0x62, 0x35, 0x39, 0x62, 0x39, 0x63, 0x33, 0x31, 0x39, 0x38, 0x32, 0x66, 0x64, 0x37, 0x33, 0x37, 0x32, 0x30, 0x33, 0x61, 0x63, 0x37, 0x34, 0x32, 0x61, 0x36, 0x31, 0x64, 0x34, 0x36, 0x33, 0x38, 0x31, 0x39, 0x64, 0x65, 0x64, 0x62, 0x63, 0x35, 0x36, 0x62, 0x36, 0x62, 0x63, 0x33, 0x64, 0x36, 0x35, 0x63, 0x34, 0x35, 0x37, 0x31, 0x65, 0x38, 0x36, 0x61, 0x61, 0x35, 0x64, 0x37, 0x35, 0x37, 0x63, 0x33, 0x37, 0x34, 0x61, 0x33, 0x39, 0x39, 0x66, 0x33, 0x61, 0x38, 0x30, 0x33, 0x30, 0x35, 0x63, 0x63, 0x63, 0x31, 0x31, 0x32, 0x62, 0x62, 0x34, 0x64, 0x30, 0x31, 0x66, 0x39, 0x31, 0x35, 0x37, 0x37, 0x30, 0x62, 0x39, 0x61, 0x35, 0x36, 0x66, 0x39, 0x63, 0x65, 0x38, 0x38, 0x33, 0x63, 0x62, 0x33, 0x64, 0x34, 0x38, 0x64, 0x30, 0x38, 0x35, 0x65, 0x31, 0x64, 0x62, 0x36, 0x61, 0x37, 0x34, 0x66, 0x62, 0x36, 0x66, 0x63, 0x32, 0x33, 0x30, 0x64, 0x64, 0x32, 0x32, 0x33, 0x65, 0x37, 0x32, 0x36, 0x31, 0x35, 0x63, 0x66, 0x66, 0x37, 0x63, 0x33, 0x32, 0x63, 0x32, 0x63, 0x37, 0x30, 0x33, 0x61, 0x64, 0x61, 0x66, 0x64, 0x35, 0x39, 0x63, 0x63, 0x61, 0x32, 0x37, 0x31, 0x61, 0x66, 0x61, 0x35, 0x36, 0x34, 0x33, 0x38, 0x63, 0x62, 0x37, 0x31, 0x30, 0x64, 0x31, 0x39, 0x38, 0x63, 0x61, 0x35, 0x38, 0x37, 0x33, 0x38, 0x61, 0x33, 0x34, 0x36, 0x61, 0x39, 0x36, 0x66, 0x31, 0x37, 0x32, 0x32, 0x66, 0x33, 0x32, 0x65, 0x33, 0x36, 0x33, 0x61, 0x37, 0x65, 0x34, 0x31, 0x62, 0x32, 0x32, 0x38, 0x35, 0x34, 0x32, 0x34, 0x66, 0x37, 0x31, 0x37, 0x39, 0x36, 0x38, 0x31, 0x31, 0x36, 0x64, 0x36, 0x65, 0x38, 0x38, 0x31, 0x34, 0x34, 0x35, 0x32, 0x30, 0x39, 0x34, 0x39, 0x38, 0x62, 0x31, 0x39, 0x64, 0x62, 0x39, 0x62, 0x39, 0x36, 0x30, 0x63, 0x32, 0x37, 0x34, 0x64, 0x36, 0x30, 0x62, 0x38, 0x64, 0x34, 0x65, 0x33, 0x61, 0x61, 0x36, 0x34, 0x63, 0x65, 0x63, 0x38, 0x30, 0x30, 0x32, 0x33, 0x61, 0x64, 0x66, 0x35, 0x35, 0x32, 0x34, 0x66, 0x62, 0x63, 0x62, 0x66, 0x33, 0x35, 0x61, 0x62, 0x36, 0x34, 0x38, 0x36, 0x31, 0x34, 0x38, 0x64, 0x61, 0x66, 0x66, 0x65, 0x64, 0x66, 0x65, 0x62, 0x36, 0x36, 0x64, 0x30, 0x35, 0x35, 0x62, 0x30, 0x64, 0x34, 0x34, 0x35, 0x34, 0x31, 0x35, 0x35, 0x36, 0x64, 0x62, 0x38, 0x39, 0x62, 0x37, 0x35, 0x36, 0x39, 0x61, 0x34, 0x31, 0x61, 0x63, 0x63, 0x36, 0x65, 0x30, 0x62, 0x38, 0x30, 0x35, 0x63, 0x31, 0x35, 0x61, 0x61, 0x34, 0x34, 0x64, 0x64, 0x65, 0x61, 0x37, 0x65, 0x31, 0x39, 0x65, 0x62, 0x30, 0x65, 0x65, 0x62, 0x63, 0x65, 0x35, 0x39, 0x64, 0x61, 0x39, 0x65, 0x38, 0x36, 0x65, 0x62, 0x31, 0x31, 0x61, 0x65, 0x34, 0x37, 0x32, 0x62, 0x34, 0x66, 0x35, 0x39, 0x32, 0x64, 0x64, 0x30, 0x32, 0x37, 0x65, 0x63, 0x34, 0x35, 0x31, 0x64, 0x34, 0x61, 0x37, 0x32, 0x62, 0x34, 0x35, 0x32, 0x36, 0x61, 0x35, 0x31, 0x36, 0x38, 0x31, 0x33, 0x63, 0x35, 0x39, 0x64, 0x64, 0x37, 0x61, 0x61, 0x38, 0x37, 0x33, 0x39, 0x36, 0x38, 0x31, 0x64, 0x34, 0x63, 0x37, 0x39, 0x31, 0x64, 0x37, 0x32, 0x35, 0x39, 0x36, 0x35, 0x30, 0x37, 0x32, 0x66, 0x64, 0x32, 0x32, 0x35, 0x36, 0x31, 0x36, 0x61, 0x39, 0x61, 0x30, 0x66, 0x33, 0x63, 0x30, 0x65, 0x31, 0x39, 0x35, 0x36, 0x38, 0x38, 0x30, 0x33, 0x36, 0x32, 0x64, 0x62, 0x66, 0x34, 0x33, 0x64, 0x39, 0x32, 0x62, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x34, 0x31, 0x37, 0x61, 0x33, 0x37, 0x35, 0x37, 0x66, 0x66, 0x61, 0x66, 0x64, 0x61, 0x32, 0x65, 0x65, 0x30, 0x61, 0x35, 0x37, 0x32, 0x39, 0x66, 0x65, 0x62, 0x35, 0x63, 0x65, 0x33, 0x63, 0x35, 0x61, 0x33, 0x63, 0x62, 0x31, 0x38, 0x36, 0x62, 0x31, 0x35, 0x35, 0x38, 0x35, 0x33, 0x31, 0x32, 0x63, 0x34, 0x30, 0x63, 0x65, 0x65, 0x37, 0x62, 0x36, 0x63, 0x31, 0x66, 0x61, 0x34, 0x32, 0x32, 0x65, 0x32, 0x62, 0x66, 0x62, 0x37, 0x34, 0x30, 0x38, 0x38, 0x30, 0x36, 0x32, 0x37, 0x30, 0x35, 0x38, 0x32, 0x35, 0x34, 0x37, 0x32, 0x62, 0x31, 0x66, 0x30, 0x61, 0x62, 0x33, 0x33, 0x65, 0x37, 0x66, 0x30, 0x63, 0x32, 0x35, 0x65, 0x66, 0x65, 0x30, 0x64, 0x61, 0x66, 0x36, 0x34, 0x39, 0x38, 0x61, 0x64, 0x64, 0x63, 0x65, 0x36, 0x66, 0x30, 0x66, 0x30, 0x63, 0x61, 0x36, 0x37, 0x31, 0x61, 0x33, 0x31, 0x66, 0x32, 0x66, 0x39, 0x39, 0x36, 0x36, 0x37, 0x32, 0x65, 0x64, 0x31, 0x61, 0x36, 0x33, 0x62, 0x37, 0x64, 0x37, 0x32, 0x32, 0x38, 0x32, 0x66, 0x30, 0x31, 0x65, 0x38, 0x65, 0x39, 0x38, 0x39, 0x39, 0x35, 0x35, 0x31, 0x39, 0x34, 0x32, 0x61, 0x62, 0x30, 0x30, 0x35, 0x64, 0x35, 0x30, 0x32, 0x64, 0x39, 0x33, 0x66, 0x37, 0x64, 0x62, 0x34, 0x31, 0x32, 0x37, 0x65, 0x66, 0x65, 0x38, 0x64, 0x39, 0x63, 0x39, 0x65, 0x64, 0x35, 0x61, 0x39, 0x61, 0x38, 0x38, 0x33, 0x32, 0x37, 0x39, 0x36, 0x62, 0x34, 0x37, 0x32, 0x36, 0x39, 0x38, 0x38, 0x31, 0x66, 0x34, 0x37, 0x35, 0x38, 0x63, 0x33, 0x34, 0x32, 0x32, 0x32, 0x64, 0x32, 0x64, 0x38, 0x63, 0x38, 0x64, 0x65, 0x30, 0x39, 0x34, 0x38, 0x61, 0x32, 0x34, 0x63, 0x38, 0x61, 0x65, 0x38, 0x64, 0x61, 0x66, 0x31, 0x31, 0x64, 0x33, 0x66, 0x35, 0x66, 0x38, 0x61, 0x30, 0x65, 0x37, 0x37, 0x65, 0x66, 0x66, 0x66, 0x61, 0x32, 0x63, 0x64, 0x64, 0x65, 0x37, 0x32, 0x65, 0x34, 0x65, 0x34, 0x65, 0x33, 0x63, 0x37, 0x35, 0x63, 0x36, 0x30, 0x33, 0x34, 0x61, 0x63, 0x64, 0x64, 0x61, 0x61, 0x63, 0x61, 0x34, 0x34, 0x37, 0x63, 0x62, 0x34, 0x66, 0x31, 0x39, 0x63, 0x31, 0x64, 0x61, 0x32, 0x36, 0x62, 0x37, 0x36, 0x32, 0x63, 0x64, 0x63, 0x36, 0x34, 0x38, 0x39, 0x37, 0x39, 0x30, 0x61, 0x31, 0x33, 0x36, 0x30, 0x63, 0x63, 0x32, 0x33, 0x63, 0x61, 0x35, 0x38, 0x38, 0x64, 0x62, 0x64, 0x64, 0x66, 0x31, 0x34, 0x35, 0x38, 0x37, 0x37, 0x31, 0x63, 0x65, 0x35, 0x32, 0x30, 0x62, 0x64, 0x32, 0x37, 0x39, 0x32, 0x38, 0x33, 0x32, 0x62, 0x39, 0x36, 0x62, 0x64, 0x38, 0x36, 0x33, 0x35, 0x36, 0x37, 0x39, 0x64, 0x66, 0x38, 0x38, 0x31, 0x37, 0x65, 0x39, 0x64, 0x66, 0x37, 0x31, 0x39, 0x37, 0x36, 0x36, 0x32, 0x30, 0x33, 0x65, 0x66, 0x36, 0x33, 0x37, 0x32, 0x35, 0x38, 0x65, 0x62, 0x30, 0x34, 0x37, 0x35, 0x62, 0x39, 0x33, 0x61, 0x34, 0x35, 0x32, 0x63, 0x30, 0x37, 0x62, 0x38, 0x36, 0x65, 0x66, 0x37, 0x37, 0x61, 0x63, 0x36, 0x36, 0x31, 0x62, 0x32, 0x36, 0x62, 0x64, 0x34, 0x33, 0x39, 0x32, 0x64, 0x65, 0x36, 0x31, 0x61, 0x36, 0x33, 0x37, 0x66, 0x39, 0x37, 0x38, 0x32, 0x64, 0x35, 0x65, 0x63, 0x64, 0x33, 0x39, 0x30, 0x39, 0x31, 0x37, 0x32, 0x30, 0x35, 0x35, 0x34, 0x62, 0x66, 0x30, 0x38, 0x33, 0x30, 0x34, 0x32, 0x31, 0x64, 0x39, 0x38, 0x31, 0x63, 0x32, 0x66, 0x63, 0x38, 0x62, 0x38, 0x63, 0x61, 0x34, 0x33, 0x34, 0x33, 0x36, 0x31, 0x33, 0x39, 0x39, 0x31, 0x34, 0x63, 0x66, 0x32, 0x34, 0x31, 0x35, 0x34, 0x63, 0x32, 0x65, 0x32, 0x66, 0x36, 0x34, 0x39, 0x61, 0x65, 0x61, 0x66, 0x38, 0x66, 0x30, 0x64, 0x30, 0x63, 0x37, 0x32, 0x31, 0x62, 0x34, 0x64, 0x64, 0x66, 0x63, 0x36, 0x34, 0x64, 0x61, 0x64, 0x36, 0x30, 0x37, 0x30, 0x36, 0x61, 0x62, 0x31, 0x30, 0x32, 0x64, 0x35, 0x30, 0x31, 0x66, 0x35, 0x63, 0x33, 0x35, 0x33, 0x32, 0x35, 0x63, 0x39, 0x38, 0x34, 0x37, 0x35, 0x34, 0x65, 0x30, 0x65, 0x61, 0x38, 0x32, 0x35, 0x33, 0x62, 0x33, 0x66, 0x39, 0x39, 0x66, 0x35, 0x32, 0x66, 0x62, 0x65, 0x37, 0x66, 0x37, 0x32, 0x34, 0x37, 0x66, 0x37, 0x30, 0x38, 0x65, 0x66, 0x63, 0x31, 0x36, 0x64, 0x32, 0x33, 0x65, 0x62, 0x65, 0x65, 0x39, 0x64, 0x30, 0x36, 0x63, 0x35, 0x35, 0x62, 0x61, 0x64, 0x33, 0x64, 0x32, 0x36, 0x37, 0x39, 0x31, 0x35, 0x36, 0x66, 0x31, 0x38, 0x31, 0x63, 0x33, 0x33, 0x39, 0x37, 0x34, 0x61, 0x39, 0x32, 0x64, 0x63, 0x62, 0x34, 0x61, 0x62, 0x34, 0x38, 0x63, 0x62, 0x35, 0x65, 0x37, 0x32, 0x65, 0x35, 0x31, 0x39, 0x35, 0x32, 0x65, 0x30, 0x61, 0x32, 0x37, 0x30, 0x63, 0x36, 0x65, 0x36, 0x32, 0x39, 0x38, 0x37, 0x64, 0x36, 0x35, 0x35, 0x34, 0x38, 0x35, 0x31, 0x66, 0x34, 0x33, 0x37, 0x35, 0x66, 0x33, 0x62, 0x62, 0x39, 0x31, 0x32, 0x62, 0x30, 0x30, 0x62, 0x37, 0x36, 0x65, 0x36, 0x30, 0x30, 0x39, 0x31, 0x64, 0x63, 0x39, 0x35, 0x33, 0x35, 0x61, 0x30, 0x30, 0x61, 0x32, 0x62, 0x62, 0x32, 0x63, 0x63, 0x64, 0x31, 0x65, 0x30, 0x36, 0x37, 0x34, 0x61, 0x36, 0x33, 0x32, 0x36, 0x36, 0x36, 0x30, 0x66, 0x39, 0x33, 0x30, 0x32, 0x64, 0x39, 0x62, 0x61, 0x35, 0x36, 0x32, 0x38, 0x62, 0x35, 0x30, 0x66, 0x35, 0x63, 0x36, 0x38, 0x34, 0x31, 0x66, 0x30, 0x33, 0x30, 0x38, 0x36, 0x61, 0x63, 0x62, 0x35, 0x64, 0x38, 0x66, 0x62, 0x63, 0x38, 0x61, 0x39, 0x62, 0x39, 0x37, 0x32, 0x63, 0x39, 0x62, 0x64, 0x30, 0x34, 0x39, 0x65, 0x66, 0x32, 0x36, 0x38, 0x35, 0x31, 0x34, 0x39, 0x30, 0x61, 0x64, 0x64, 0x31, 0x32, 0x64, 0x30, 0x66, 0x65, 0x39, 0x31, 0x33, 0x37, 0x64, 0x33, 0x36, 0x62, 0x64, 0x63, 0x35, 0x63, 0x66, 0x33, 0x36, 0x36, 0x64, 0x30, 0x39, 0x33, 0x36, 0x30, 0x31, 0x31, 0x33, 0x30, 0x34, 0x36, 0x63, 0x38, 0x63, 0x35, 0x62, 0x35, 0x31, 0x32, 0x36, 0x37, 0x63, 0x61, 0x62, 0x61, 0x33, 0x61, 0x62, 0x64, 0x31, 0x61, 0x33, 0x66, 0x30, 0x35, 0x65, 0x65, 0x64, 0x31, 0x34, 0x30, 0x38, 0x31, 0x35, 0x63, 0x30, 0x36, 0x64, 0x30, 0x37, 0x62, 0x33, 0x36, 0x34, 0x37, 0x34, 0x36, 0x37, 0x36, 0x37, 0x35, 0x61, 0x64, 0x36, 0x65, 0x35, 0x39, 0x39, 0x65, 0x34, 0x63, 0x36, 0x62, 0x38, 0x63, 0x38, 0x35, 0x35, 0x63, 0x62, 0x38, 0x33, 0x37, 0x33, 0x66, 0x64, 0x39, 0x63, 0x33, 0x32, 0x61, 0x35, 0x61, 0x34, 0x31, 0x38, 0x38, 0x38, 0x62, 0x32, 0x64, 0x31, 0x66, 0x34, 0x32, 0x63, 0x61, 0x38, 0x63, 0x34, 0x66, 0x62, 0x37, 0x65, 0x31, 0x32, 0x39, 0x39, 0x63, 0x33, 0x64, 0x62, 0x63, 0x35, 0x66, 0x66, 0x31, 0x32, 0x65, 0x32, 0x33, 0x66, 0x30, 0x30, 0x66, 0x39, 0x30, 0x66, 0x66, 0x63, 0x35, 0x63, 0x66, 0x35, 0x65, 0x63, 0x62, 0x37, 0x32, 0x65, 0x63, 0x33, 0x36, 0x33, 0x66, 0x35, 0x30, 0x39, 0x66, 0x31, 0x37, 0x62, 0x30, 0x66, 0x32, 0x33, 0x37, 0x34, 0x36, 0x66, 0x65, 0x38, 0x66, 0x31, 0x63, 0x66, 0x39, 0x35, 0x65, 0x33, 0x30, 0x34, 0x39, 0x63, 0x61, 0x39, 0x31, 0x37, 0x64, 0x31, 0x34, 0x38, 0x63, 0x38, 0x65, 0x36, 0x65, 0x35, 0x64, 0x35, 0x66, 0x38, 0x31, 0x63, 0x35, 0x38, 0x63, 0x63, 0x36, 0x61, 0x34, 0x37, 0x32, 0x35, 0x30, 0x32, 0x63, 0x65, 0x61, 0x30, 0x31, 0x64, 0x63, 0x34, 0x61, 0x36, 0x61, 0x31, 0x66, 0x37, 0x34, 0x33, 0x36, 0x63, 0x65, 0x35, 0x63, 0x31, 0x35, 0x34, 0x39, 0x61, 0x32, 0x38, 0x61, 0x39, 0x66, 0x31, 0x66, 0x32, 0x30, 0x65, 0x33, 0x62, 0x31, 0x38, 0x32, 0x66, 0x64, 0x64, 0x34, 0x65, 0x63, 0x39, 0x39, 0x35, 0x36, 0x34, 0x36, 0x65, 0x64, 0x61, 0x36, 0x38, 0x62, 0x37, 0x32, 0x62, 0x61, 0x31, 0x35, 0x31, 0x30, 0x66, 0x34, 0x39, 0x39, 0x31, 0x62, 0x36, 0x32, 0x66, 0x35, 0x33, 0x61, 0x31, 0x36, 0x66, 0x62, 0x37, 0x37, 0x63, 0x61, 0x65, 0x30, 0x66, 0x31, 0x64, 0x33, 0x32, 0x64, 0x38, 0x38, 0x39, 0x39, 0x30, 0x31, 0x33, 0x31, 0x66, 0x34, 0x64, 0x36, 0x66, 0x65, 0x64, 0x30, 0x65, 0x64, 0x35, 0x31, 0x31, 0x30, 0x38, 0x62, 0x31, 0x65, 0x35, 0x30, 0x36, 0x64, 0x39, 0x32, 0x37, 0x33, 0x30, 0x63, 0x61, 0x33, 0x62, 0x30, 0x39, 0x36, 0x63, 0x35, 0x30, 0x66, 0x63, 0x30, 0x39, 0x33, 0x31, 0x36, 0x36, 0x30, 0x35, 0x66, 0x34, 0x35, 0x36, 0x64, 0x63, 0x65, 0x36, 0x39, 0x36, 0x39, 0x30, 0x34, 0x62, 0x66, 0x37, 0x66, 0x30, 0x38, 0x31, 0x36, 0x38, 0x36, 0x64, 0x66, 0x66, 0x62, 0x36, 0x30, 0x31, 0x61, 0x32, 0x34, 0x39, 0x61, 0x36, 0x38, 0x31, 0x64, 0x34, 0x35, 0x62, 0x33, 0x33, 0x37, 0x35, 0x35, 0x39, 0x35, 0x62, 0x33, 0x64, 0x37, 0x63, 0x36, 0x66, 0x63, 0x35, 0x35, 0x63, 0x30, 0x38, 0x65, 0x32, 0x39, 0x66, 0x30, 0x66, 0x31, 0x32, 0x37, 0x34, 0x66, 0x62, 0x38, 0x38, 0x35, 0x32, 0x39, 0x62, 0x31, 0x39, 0x64, 0x31, 0x66, 0x62, 0x32, 0x62, 0x30, 0x36, 0x37, 0x64, 0x62, 0x37, 0x39, 0x37, 0x62, 0x36, 0x32, 0x37, 0x31, 0x37, 0x32, 0x32, 0x35, 0x62, 0x64, 0x66, 0x62, 0x64, 0x66, 0x64, 0x30, 0x32, 0x36, 0x66, 0x34, 0x63, 0x30, 0x36, 0x30, 0x33, 0x64, 0x35, 0x38, 0x64, 0x36, 0x37, 0x65, 0x32, 0x35, 0x63, 0x66, 0x36, 0x64, 0x63, 0x33, 0x61, 0x65, 0x38, 0x37, 0x34, 0x31, 0x36, 0x35, 0x34, 0x32, 0x63, 0x32, 0x66, 0x33, 0x39, 0x34, 0x36, 0x30, 0x65, 0x39, 0x31, 0x38, 0x36, 0x61, 0x33, 0x33, 0x31, 0x38, 0x37, 0x32, 0x33, 0x32, 0x38, 0x32, 0x63, 0x65, 0x35, 0x61, 0x33, 0x30, 0x30, 0x37, 0x65, 0x37, 0x35, 0x66, 0x38, 0x38, 0x62, 0x66, 0x64, 0x34, 0x64, 0x36, 0x32, 0x31, 0x61, 0x63, 0x64, 0x37, 0x38, 0x32, 0x66, 0x38, 0x65, 0x38, 0x39, 0x31, 0x66, 0x36, 0x34, 0x32, 0x65, 0x37, 0x32, 0x39, 0x61, 0x63, 0x30, 0x37, 0x63, 0x36, 0x39, 0x66, 0x32, 0x61, 0x39, 0x30, 0x38, 0x32, 0x33, 0x36, 0x37, 0x32, 0x61, 0x33, 0x64, 0x62, 0x38, 0x31, 0x34, 0x36, 0x65, 0x39, 0x32, 0x65, 0x39, 0x66, 0x39, 0x37, 0x65, 0x64, 0x34, 0x30, 0x64, 0x63, 0x34, 0x30, 0x32, 0x39, 0x64, 0x34, 0x35, 0x66, 0x65, 0x34, 0x34, 0x30, 0x64, 0x34, 0x63, 0x36, 0x39, 0x37, 0x61, 0x37, 0x30, 0x37, 0x38, 0x65, 0x64, 0x61, 0x66, 0x31, 0x34, 0x36, 0x39, 0x37, 0x38, 0x38, 0x63, 0x36, 0x62, 0x31, 0x37, 0x35, 0x34, 0x66, 0x32, 0x34, 0x39, 0x34, 0x63, 0x35, 0x34, 0x34, 0x38, 0x64, 0x66, 0x66, 0x62, 0x39, 0x31, 0x33, 0x64, 0x37, 0x30, 0x31, 0x37, 0x30, 0x63, 0x61, 0x38, 0x31, 0x66, 0x36, 0x31, 0x66, 0x66, 0x63, 0x38, 0x61, 0x32, 0x35, 0x35, 0x66, 0x38, 0x66, 0x63, 0x61, 0x33, 0x62, 0x38, 0x35, 0x64, 0x63, 0x36, 0x31, 0x63, 0x33, 0x61, 0x30, 0x64, 0x62, 0x35, 0x30, 0x64, 0x64, 0x62, 0x66, 0x37, 0x32, 0x34, 0x31, 0x62, 0x38, 0x33, 0x32, 0x63, 0x32, 0x36, 0x34, 0x61, 0x61, 0x30, 0x65, 0x62, 0x31, 0x37, 0x63, 0x61, 0x63, 0x65, 0x30, 0x65, 0x64, 0x64, 0x34, 0x63, 0x39, 0x64, 0x61, 0x32, 0x32, 0x35, 0x31, 0x36, 0x66, 0x36, 0x31, 0x31, 0x33, 0x31, 0x35, 0x32, 0x32, 0x31, 0x32, 0x61, 0x35, 0x61, 0x66, 0x36, 0x64, 0x37, 0x39, 0x35, 0x64, 0x62, 0x35, 0x37, 0x36, 0x61, 0x37, 0x32, 0x39, 0x64, 0x32, 0x37, 0x64, 0x30, 0x63, 0x33, 0x37, 0x39, 0x36, 0x35, 0x34, 0x64, 0x66, 0x64, 0x38, 0x61, 0x37, 0x35, 0x30, 0x39, 0x37, 0x63, 0x36, 0x37, 0x39, 0x66, 0x31, 0x65, 0x63, 0x62, 0x63, 0x32, 0x36, 0x31, 0x38, 0x31, 0x36, 0x34, 0x36, 0x34, 0x63, 0x32, 0x62, 0x31, 0x37, 0x32, 0x38, 0x39, 0x34, 0x66, 0x34, 0x39, 0x37, 0x38, 0x61, 0x61, 0x65, 0x30, 0x36, 0x34, 0x36, 0x33, 0x37, 0x38, 0x39, 0x37, 0x37, 0x64, 0x62, 0x34, 0x36, 0x37, 0x62, 0x30, 0x30, 0x35, 0x35, 0x37, 0x37, 0x39, 0x61, 0x63, 0x30, 0x30, 0x63, 0x38, 0x33, 0x36, 0x38, 0x65, 0x64, 0x66, 0x61, 0x34, 0x32, 0x61, 0x30, 0x31, 0x39, 0x63, 0x66, 0x39, 0x34, 0x35, 0x66, 0x30, 0x62, 0x33, 0x64, 0x31, 0x38, 0x65, 0x36, 0x32, 0x31, 0x64, 0x36, 0x36, 0x39, 0x32, 0x30, 0x63, 0x66, 0x32, 0x30, 0x37, 0x32, 0x32, 0x30, 0x62, 0x39, 0x64, 0x35, 0x39, 0x35, 0x39, 0x66, 0x35, 0x63, 0x39, 0x64, 0x37, 0x33, 0x30, 0x33, 0x61, 0x36, 0x64, 0x30, 0x37, 0x66, 0x65, 0x64, 0x35, 0x66, 0x62, 0x62, 0x39, 0x34, 0x30, 0x32, 0x65, 0x63, 0x34, 0x63, 0x36, 0x31, 0x32, 0x38, 0x64, 0x36, 0x63, 0x61, 0x33, 0x36, 0x30, 0x31, 0x39, 0x63, 0x38, 0x38, 0x66, 0x35, 0x33, 0x39, 0x36, 0x61, 0x66, 0x32, 0x37, 0x32, 0x66, 0x63, 0x34, 0x38, 0x32, 0x64, 0x63, 0x34, 0x36, 0x32, 0x37, 0x36, 0x66, 0x38, 0x65, 0x63, 0x64, 0x30, 0x35, 0x61, 0x62, 0x32, 0x39, 0x35, 0x35, 0x36, 0x32, 0x30, 0x35, 0x31, 0x34, 0x36, 0x64, 0x31, 0x62, 0x38, 0x39, 0x38, 0x33, 0x65, 0x38, 0x62, 0x64, 0x64, 0x36, 0x33, 0x62, 0x37, 0x31, 0x64, 0x31, 0x62, 0x62, 0x36, 0x64, 0x31, 0x62, 0x31, 0x32, 0x65, 0x61, 0x64, 0x35, 0x32, 0x64, 0x62, 0x63, 0x32, 0x36, 0x39, 0x64, 0x30, 0x31, 0x31, 0x64, 0x61, 0x35, 0x63, 0x33, 0x62, 0x30, 0x34, 0x66, 0x64, 0x38, 0x65, 0x38, 0x37, 0x39, 0x32, 0x62, 0x39, 0x65, 0x62, 0x38, 0x30, 0x31, 0x39, 0x62, 0x65, 0x31, 0x64, 0x34, 0x36, 0x30, 0x63, 0x32, 0x64, 0x31, 0x61, 0x65, 0x32, 0x37, 0x39, 0x31, 0x39, 0x39, 0x31, 0x37, 0x62, 0x33, 0x31, 0x31, 0x62, 0x38, 0x64, 0x37, 0x32, 0x32, 0x64, 0x63, 0x37, 0x30, 0x63, 0x39, 0x33, 0x61, 0x30, 0x62, 0x62, 0x65, 0x62, 0x38, 0x33, 0x39, 0x37, 0x36, 0x33, 0x38, 0x37, 0x61, 0x31, 0x35, 0x37, 0x30, 0x64, 0x61, 0x33, 0x63, 0x32, 0x37, 0x66, 0x33, 0x34, 0x36, 0x35, 0x62, 0x65, 0x35, 0x34, 0x64, 0x64, 0x33, 0x33, 0x35, 0x32, 0x36, 0x63, 0x64, 0x63, 0x63, 0x32, 0x66, 0x31, 0x31, 0x65, 0x61, 0x37, 0x36, 0x66, 0x37, 0x32, 0x37, 0x62, 0x62, 0x37, 0x65, 0x62, 0x66, 0x38, 0x38, 0x64, 0x63, 0x64, 0x37, 0x65, 0x38, 0x30, 0x38, 0x36, 0x38, 0x63, 0x30, 0x65, 0x30, 0x66, 0x32, 0x65, 0x65, 0x61, 0x65, 0x32, 0x65, 0x37, 0x38, 0x36, 0x34, 0x35, 0x62, 0x32, 0x32, 0x35, 0x38, 0x65, 0x37, 0x38, 0x30, 0x62, 0x31, 0x30, 0x33, 0x62, 0x61, 0x36, 0x64, 0x65, 0x39, 0x65, 0x31, 0x39, 0x38, 0x36, 0x34, 0x31, 0x37, 0x32, 0x65, 0x38, 0x34, 0x30, 0x65, 0x66, 0x34, 0x30, 0x30, 0x65, 0x66, 0x61, 0x39, 0x31, 0x33, 0x37, 0x35, 0x32, 0x61, 0x65, 0x34, 0x65, 0x37, 0x62, 0x64, 0x64, 0x36, 0x33, 0x64, 0x64, 0x34, 0x64, 0x61, 0x61, 0x30, 0x66, 0x61, 0x63, 0x33, 0x62, 0x36, 0x64, 0x63, 0x30, 0x32, 0x37, 0x35, 0x36, 0x34, 0x39, 0x31, 0x62, 0x33, 0x37, 0x65, 0x61, 0x34, 0x66, 0x38, 0x65, 0x31, 0x38, 0x31, 0x61, 0x38, 0x31, 0x64, 0x34, 0x62, 0x62, 0x39, 0x38, 0x33, 0x38, 0x30, 0x39, 0x32, 0x61, 0x34, 0x33, 0x30, 0x38, 0x30, 0x38, 0x32, 0x66, 0x35, 0x39, 0x61, 0x31, 0x37, 0x62, 0x36, 0x39, 0x32, 0x35, 0x63, 0x66, 0x34, 0x38, 0x37, 0x31, 0x63, 0x63, 0x63, 0x39, 0x39, 0x32, 0x38, 0x31, 0x32, 0x64, 0x39, 0x66, 0x31, 0x31, 0x33, 0x39, 0x64, 0x39, 0x62, 0x62, 0x32, 0x65, 0x33, 0x31, 0x37, 0x32, 0x31, 0x38, 0x30, 0x36, 0x32, 0x64, 0x30, 0x63, 0x65, 0x66, 0x62, 0x63, 0x33, 0x36, 0x62, 0x35, 0x65, 0x39, 0x32, 0x63, 0x36, 0x30, 0x64, 0x35, 0x64, 0x37, 0x37, 0x34, 0x36, 0x32, 0x37, 0x39, 0x35, 0x33, 0x66, 0x63, 0x36, 0x39, 0x66, 0x65, 0x35, 0x63, 0x33, 0x64, 0x61, 0x35, 0x37, 0x62, 0x64, 0x32, 0x36, 0x63, 0x62, 0x30, 0x35, 0x39, 0x37, 0x63, 0x32, 0x66, 0x38, 0x35, 0x31, 0x36, 0x66, 0x66, 0x35, 0x30, 0x39, 0x61, 0x65, 0x33, 0x34, 0x34, 0x37, 0x66, 0x63, 0x62, 0x65, 0x66, 0x31, 0x64, 0x30, 0x61, 0x30, 0x34, 0x34, 0x34, 0x63, 0x63, 0x34, 0x62, 0x38, 0x32, 0x62, 0x64, 0x66, 0x39, 0x35, 0x34, 0x32, 0x35, 0x39, 0x63, 0x66, 0x64, 0x33, 0x34, 0x34, 0x37, 0x32, 0x38, 0x37, 0x38, 0x33, 0x66, 0x65, 0x37, 0x62, 0x34, 0x35, 0x66, 0x65, 0x33, 0x32, 0x37, 0x37, 0x32, 0x61, 0x36, 0x34, 0x34, 0x37, 0x64, 0x37, 0x34, 0x63, 0x66, 0x34, 0x33, 0x37, 0x31, 0x62, 0x34, 0x61, 0x34, 0x65, 0x36, 0x39, 0x36, 0x30, 0x30, 0x30, 0x32, 0x35, 0x36, 0x35, 0x39, 0x39, 0x31, 0x30, 0x31, 0x62, 0x31, 0x38, 0x32, 0x39, 0x38, 0x62, 0x35, 0x32, 0x64, 0x33, 0x62, 0x65, 0x36, 0x32, 0x62, 0x38, 0x63, 0x31, 0x36, 0x33, 0x36, 0x35, 0x32, 0x61, 0x39, 0x63, 0x36, 0x33, 0x63, 0x32, 0x39, 0x38, 0x39, 0x65, 0x36, 0x32, 0x34, 0x36, 0x39, 0x64, 0x62, 0x62, 0x65, 0x36, 0x34, 0x66, 0x66, 0x34, 0x39, 0x32, 0x30, 0x38, 0x38, 0x62, 0x64, 0x66, 0x37, 0x61, 0x64, 0x32, 0x61, 0x65, 0x31, 0x38, 0x62, 0x63, 0x35, 0x33, 0x30, 0x30, 0x33, 0x61, 0x39, 0x31, 0x37, 0x35, 0x31, 0x66, 0x32, 0x66, 0x64, 0x33, 0x35, 0x31, 0x35, 0x38, 0x64, 0x61, 0x32, 0x31, 0x64, 0x32, 0x35, 0x36, 0x37, 0x34, 0x31, 0x30, 0x31, 0x65, 0x30, 0x65, 0x30, 0x64, 0x30, 0x32, 0x36, 0x38, 0x39, 0x33, 0x34, 0x39, 0x64, 0x31, 0x65, 0x32, 0x63, 0x62, 0x37, 0x32, 0x34, 0x62, 0x35, 0x32, 0x35, 0x38, 0x62, 0x62, 0x34, 0x63, 0x65, 0x38, 0x33, 0x30, 0x64, 0x62, 0x39, 0x66, 0x39, 0x32, 0x39, 0x36, 0x39, 0x62, 0x62, 0x64, 0x66, 0x37, 0x36, 0x64, 0x62, 0x36, 0x35, 0x65, 0x61, 0x31, 0x63, 0x31, 0x66, 0x63, 0x35, 0x31, 0x38, 0x38, 0x32, 0x35, 0x62, 0x33, 0x62, 0x31, 0x31, 0x65, 0x38, 0x35, 0x37, 0x39, 0x61, 0x31, 0x64, 0x31, 0x33, 0x33, 0x30, 0x33, 0x34, 0x61, 0x61, 0x31, 0x32, 0x65, 0x33, 0x32, 0x39, 0x37, 0x39, 0x63, 0x63, 0x34, 0x31, 0x61, 0x62, 0x38, 0x64, 0x38, 0x63, 0x62, 0x61, 0x66, 0x34, 0x63, 0x32, 0x39, 0x39, 0x65, 0x64, 0x64, 0x35, 0x33, 0x35, 0x34, 0x34, 0x32, 0x65, 0x66, 0x31, 0x34, 0x32, 0x62, 0x32, 0x38, 0x32, 0x66, 0x65, 0x32, 0x36, 0x31, 0x37, 0x30, 0x31, 0x35, 0x32, 0x30, 0x37, 0x62, 0x34, 0x34, 0x66, 0x64, 0x35, 0x31, 0x65, 0x66, 0x37, 0x63, 0x38, 0x31, 0x31, 0x36, 0x65, 0x36, 0x63, 0x64, 0x39, 0x39, 0x66, 0x64, 0x33, 0x66, 0x61, 0x64, 0x35, 0x33, 0x64, 0x35, 0x35, 0x65, 0x37, 0x63, 0x33, 0x66, 0x32, 0x66, 0x66, 0x33, 0x64, 0x66, 0x37, 0x33, 0x34, 0x64, 0x62, 0x32, 0x37, 0x31, 0x31, 0x37, 0x30, 0x65, 0x63, 0x31, 0x65, 0x66, 0x66, 0x31, 0x35, 0x36, 0x31, 0x32, 0x64, 0x62, 0x31, 0x38, 0x35, 0x61, 0x34, 0x61, 0x63, 0x32, 0x65, 0x38, 0x65, 0x63, 0x30, 0x30, 0x61, 0x63, 0x64, 0x30, 0x61, 0x32, 0x38, 0x33, 0x34, 0x38, 0x36, 0x30, 0x38, 0x61, 0x61, 0x34, 0x61, 0x66, 0x30, 0x62, 0x33, 0x39, 0x66, 0x30, 0x33, 0x63, 0x35, 0x31, 0x61, 0x62, 0x32, 0x63, 0x36, 0x65, 0x35, 0x30, 0x31, 0x66, 0x37, 0x63, 0x32, 0x39, 0x31, 0x30, 0x39, 0x36, 0x63, 0x61, 0x32, 0x33, 0x30, 0x62, 0x64, 0x63, 0x66, 0x34, 0x32, 0x62, 0x39, 0x66, 0x65, 0x62, 0x33, 0x61, 0x65, 0x64, 0x35, 0x61, 0x34, 0x62, 0x64, 0x65, 0x35, 0x32, 0x38, 0x32, 0x30, 0x61, 0x31, 0x38, 0x36, 0x66, 0x32, 0x30, 0x37, 0x31, 0x36, 0x36, 0x36, 0x33, 0x35, 0x30, 0x31, 0x38, 0x61, 0x33, 0x36, 0x64, 0x37, 0x36, 0x30, 0x35, 0x66, 0x37, 0x37, 0x35, 0x33, 0x32, 0x66, 0x36, 0x61, 0x62, 0x61, 0x64, 0x36, 0x65, 0x61, 0x30, 0x64, 0x32, 0x34, 0x30, 0x35, 0x63, 0x32, 0x39, 0x34, 0x62, 0x39, 0x33, 0x36, 0x32, 0x37, 0x33, 0x64, 0x37, 0x36, 0x32, 0x33, 0x61, 0x36, 0x37, 0x36, 0x61, 0x34, 0x38, 0x39, 0x38, 0x33, 0x61, 0x32, 0x36, 0x61, 0x63, 0x39, 0x32, 0x65, 0x66, 0x38, 0x62, 0x35, 0x38, 0x39, 0x30, 0x39, 0x35, 0x64, 0x64, 0x38, 0x32, 0x64, 0x30, 0x38, 0x38, 0x35, 0x64, 0x35, 0x33, 0x65, 0x31, 0x35, 0x34, 0x65, 0x37, 0x34, 0x65, 0x30, 0x61, 0x62, 0x64, 0x30, 0x30, 0x66, 0x64, 0x33, 0x37, 0x63, 0x36, 0x64, 0x63, 0x61, 0x38, 0x64, 0x35, 0x38, 0x30, 0x39, 0x61, 0x35, 0x33, 0x38, 0x38, 0x30, 0x33, 0x64, 0x34, 0x36, 0x66, 0x64, 0x65, 0x65, 0x64, 0x61, 0x61, 0x32, 0x62, 0x39, 0x62, 0x36, 0x39, 0x30, 0x35, 0x65, 0x64, 0x66, 0x32, 0x62, 0x34, 0x64, 0x61, 0x65, 0x37, 0x63, 0x33, 0x36, 0x32, 0x33, 0x36, 0x39, 0x32, 0x65, 0x30, 0x66, 0x61, 0x64, 0x64, 0x30, 0x39, 0x30, 0x35, 0x39, 0x33, 0x36, 0x35, 0x37, 0x62, 0x38, 0x34, 0x37, 0x34, 0x62, 0x38, 0x39, 0x61, 0x36, 0x33, 0x30, 0x61, 0x30, 0x37, 0x32, 0x30, 0x63, 0x63, 0x36, 0x63, 0x31, 0x30, 0x39, 0x39, 0x62, 0x66, 0x38, 0x32, 0x37, 0x38, 0x36, 0x66, 0x62, 0x61, 0x33, 0x36, 0x39, 0x33, 0x61, 0x33, 0x63, 0x65, 0x31, 0x39, 0x66, 0x33, 0x38, 0x64, 0x30, 0x34, 0x35, 0x65, 0x38, 0x61, 0x66, 0x30, 0x62, 0x63, 0x36, 0x30, 0x61, 0x32, 0x66, 0x33, 0x66, 0x63, 0x38, 0x36, 0x39, 0x65, 0x66, 0x37, 0x31, 0x35, 0x33, 0x62, 0x30, 0x37, 0x32, 0x39, 0x39, 0x39, 0x34, 0x37, 0x34, 0x65, 0x37, 0x31, 0x64, 0x62, 0x37, 0x62, 0x39, 0x32, 0x32, 0x62, 0x37, 0x37, 0x32, 0x63, 0x66, 0x62, 0x66, 0x36, 0x61, 0x66, 0x62, 0x32, 0x35, 0x63, 0x38, 0x63, 0x31, 0x31, 0x38, 0x33, 0x66, 0x33, 0x37, 0x34, 0x34, 0x37, 0x64, 0x62, 0x34, 0x37, 0x39, 0x38, 0x30, 0x37, 0x38, 0x34, 0x36, 0x62, 0x61, 0x38, 0x34, 0x34, 0x62, 0x37, 0x30, 0x36, 0x64, 0x35, 0x34, 0x65, 0x39, 0x31, 0x33, 0x61, 0x37, 0x38, 0x38, 0x61, 0x34, 0x66, 0x32, 0x30, 0x36, 0x32, 0x65, 0x30, 0x62, 0x30, 0x35, 0x35, 0x37, 0x39, 0x62, 0x37, 0x66, 0x35, 0x36, 0x64, 0x39, 0x33, 0x32, 0x61, 0x35, 0x34, 0x32, 0x64, 0x34, 0x38, 0x31, 0x39, 0x64, 0x33, 0x37, 0x34, 0x32, 0x37, 0x64, 0x39, 0x35, 0x66, 0x62, 0x32, 0x65, 0x66, 0x30, 0x37, 0x38, 0x66, 0x34, 0x37, 0x32, 0x30, 0x63, 0x39, 0x33, 0x33, 0x39, 0x38, 0x38, 0x62, 0x31, 0x33, 0x66, 0x39, 0x30, 0x65, 0x65, 0x65, 0x64, 0x65, 0x30, 0x63, 0x37, 0x65, 0x38, 0x61, 0x37, 0x32, 0x39, 0x64, 0x31, 0x33, 0x64, 0x64, 0x62, 0x35, 0x61, 0x64, 0x39, 0x62, 0x63, 0x35, 0x65, 0x31, 0x32, 0x39, 0x31, 0x36, 0x31, 0x37, 0x37, 0x38, 0x38, 0x65, 0x66, 0x31, 0x30, 0x62, 0x61, 0x37, 0x33, 0x32, 0x65, 0x37, 0x32, 0x30, 0x36, 0x61, 0x64, 0x32, 0x37, 0x30, 0x36, 0x62, 0x36, 0x64, 0x62, 0x32, 0x61, 0x37, 0x32, 0x63, 0x61, 0x37, 0x30, 0x64, 0x61, 0x65, 0x61, 0x62, 0x61, 0x35, 0x33, 0x37, 0x33, 0x65, 0x63, 0x63, 0x66, 0x65, 0x65, 0x61, 0x32, 0x31, 0x38, 0x63, 0x66, 0x35, 0x31, 0x30, 0x64, 0x34, 0x32, 0x62, 0x31, 0x38, 0x38, 0x37, 0x34, 0x64, 0x66, 0x63, 0x32, 0x66, 0x35, 0x34, 0x66, 0x30, 0x37, 0x66, 0x62, 0x66, 0x35, 0x33, 0x30, 0x64, 0x38, 0x39, 0x30, 0x38, 0x38, 0x64, 0x63, 0x33, 0x62, 0x31, 0x38, 0x66, 0x30, 0x38, 0x38, 0x36, 0x30, 0x39, 0x64, 0x33, 0x38, 0x34, 0x61, 0x31, 0x31, 0x31, 0x63, 0x33, 0x62, 0x34, 0x34, 0x64, 0x64, 0x64, 0x61, 0x62, 0x35, 0x62, 0x66, 0x36, 0x30, 0x33, 0x66, 0x38, 0x61, 0x38, 0x66, 0x37, 0x33, 0x30, 0x39, 0x30, 0x31, 0x34, 0x64, 0x34, 0x36, 0x34, 0x34, 0x61, 0x62, 0x33, 0x30, 0x38, 0x38, 0x36, 0x65, 0x38, 0x66, 0x39, 0x66, 0x35, 0x66, 0x30, 0x38, 0x36, 0x35, 0x63, 0x34, 0x63, 0x65, 0x66, 0x39, 0x61, 0x66, 0x61, 0x36, 0x37, 0x61, 0x66, 0x33, 0x36, 0x30, 0x35, 0x30, 0x33, 0x38, 0x66, 0x62, 0x61, 0x31, 0x31, 0x63, 0x39, 0x35, 0x39, 0x30, 0x38, 0x39, 0x37, 0x31, 0x39, 0x36, 0x63, 0x39, 0x36, 0x65, 0x31, 0x33, 0x37, 0x32, 0x66, 0x30, 0x31, 0x65, 0x33, 0x34, 0x39, 0x64, 0x37, 0x38, 0x65, 0x61, 0x30, 0x62, 0x64, 0x33, 0x35, 0x64, 0x37, 0x62, 0x36, 0x61, 0x35, 0x37, 0x61, 0x30, 0x66, 0x37, 0x66, 0x39, 0x35, 0x34, 0x38, 0x37, 0x31, 0x38, 0x36, 0x39, 0x63, 0x33, 0x37, 0x62, 0x63, 0x35, 0x39, 0x32, 0x36, 0x37, 0x35, 0x30, 0x61, 0x61, 0x64, 0x38, 0x37, 0x37, 0x34, 0x38, 0x62, 0x38, 0x61, 0x61, 0x36, 0x31, 0x62, 0x38, 0x66, 0x39, 0x36, 0x64, 0x61, 0x37, 0x63, 0x38, 0x33, 0x65, 0x63, 0x33, 0x62, 0x36, 0x37, 0x36, 0x38, 0x64, 0x65, 0x37, 0x35, 0x39, 0x32, 0x30, 0x65, 0x62, 0x38, 0x35, 0x38, 0x32, 0x33, 0x38, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x34, 0x31, 0x66, 0x61, 0x37, 0x65, 0x37, 0x39, 0x31, 0x30, 0x61, 0x32, 0x36, 0x38, 0x31, 0x64, 0x61, 0x63, 0x35, 0x31, 0x64, 0x62, 0x31, 0x36, 0x39, 0x33, 0x34, 0x64, 0x36, 0x38, 0x31, 0x61, 0x61, 0x34, 0x33, 0x63, 0x31, 0x32, 0x33, 0x39, 0x34, 0x32, 0x36, 0x64, 0x33, 0x35, 0x32, 0x66, 0x30, 0x62, 0x36, 0x36, 0x39, 0x34, 0x66, 0x62, 0x37, 0x61, 0x33, 0x37, 0x30, 0x64, 0x65, 0x64, 0x62, 0x66, 0x36, 0x33, 0x62, 0x37, 0x61, 0x64, 0x65, 0x31, 0x30, 0x35, 0x32, 0x34, 0x33, 0x64, 0x39, 0x35, 0x33, 0x35, 0x63, 0x38, 0x35, 0x34, 0x35, 0x39, 0x63, 0x34, 0x39, 0x34, 0x65, 0x65, 0x61, 0x37, 0x39, 0x34, 0x65, 0x62, 0x31, 0x63, 0x33, 0x39, 0x39, 0x65, 0x36, 0x62, 0x37, 0x39, 0x35, 0x63, 0x37, 0x61, 0x35, 0x65, 0x37, 0x63, 0x62, 0x65, 0x35, 0x37, 0x38, 0x33, 0x65, 0x61, 0x37, 0x33, 0x32, 0x35, 0x62, 0x62, 0x39, 0x61, 0x35, 0x65, 0x32, 0x65, 0x35, 0x33, 0x37, 0x37, 0x33, 0x39, 0x65, 0x35, 0x35, 0x38, 0x37, 0x32, 0x66, 0x64, 0x33, 0x35, 0x31, 0x31, 0x30, 0x37, 0x31, 0x63, 0x37, 0x39, 0x66, 0x30, 0x38, 0x62, 0x37, 0x66, 0x64, 0x64, 0x33, 0x61, 0x66, 0x37, 0x39, 0x33, 0x66, 0x32, 0x65, 0x38, 0x66, 0x36, 0x37, 0x30, 0x39, 0x31, 0x33, 0x32, 0x62, 0x39, 0x38, 0x63, 0x39, 0x32, 0x62, 0x30, 0x30, 0x62, 0x65, 0x62, 0x39, 0x37, 0x38, 0x38, 0x64, 0x32, 0x39, 0x31, 0x64, 0x39, 0x65, 0x36, 0x37, 0x32, 0x33, 0x38, 0x65, 0x30, 0x65, 0x63, 0x61, 0x63, 0x63, 0x36, 0x30, 0x33, 0x63, 0x63, 0x61, 0x36, 0x38, 0x62, 0x37, 0x63, 0x36, 0x32, 0x37, 0x32, 0x63, 0x36, 0x65, 0x39, 0x33, 0x66, 0x38, 0x64, 0x61, 0x30, 0x63, 0x63, 0x30, 0x61, 0x33, 0x62, 0x64, 0x66, 0x30, 0x65, 0x34, 0x66, 0x61, 0x34, 0x63, 0x35, 0x38, 0x36, 0x36, 0x31, 0x65, 0x64, 0x32, 0x32, 0x65, 0x61, 0x32, 0x30, 0x37, 0x32, 0x30, 0x37, 0x35, 0x31, 0x62, 0x32, 0x34, 0x37, 0x63, 0x65, 0x38, 0x37, 0x35, 0x66, 0x62, 0x37, 0x34, 0x63, 0x64, 0x65, 0x61, 0x33, 0x65, 0x30, 0x64, 0x62, 0x35, 0x65, 0x66, 0x33, 0x36, 0x33, 0x38, 0x36, 0x39, 0x66, 0x61, 0x66, 0x36, 0x37, 0x63, 0x35, 0x64, 0x31, 0x36, 0x30, 0x31, 0x62, 0x61, 0x62, 0x38, 0x35, 0x65, 0x38, 0x65, 0x38, 0x61, 0x34, 0x66, 0x37, 0x65, 0x38, 0x37, 0x32, 0x66, 0x33, 0x64, 0x62, 0x34, 0x32, 0x35, 0x61, 0x66, 0x63, 0x31, 0x66, 0x37, 0x66, 0x32, 0x30, 0x65, 0x63, 0x62, 0x39, 0x61, 0x35, 0x36, 0x38, 0x35, 0x38, 0x61, 0x39, 0x61, 0x31, 0x64, 0x33, 0x34, 0x30, 0x31, 0x33, 0x62, 0x32, 0x65, 0x39, 0x61, 0x34, 0x35, 0x37, 0x30, 0x33, 0x37, 0x39, 0x37, 0x32, 0x61, 0x32, 0x61, 0x61, 0x63, 0x62, 0x61, 0x35, 0x36, 0x66, 0x35, 0x62, 0x33, 0x35, 0x61, 0x39, 0x37, 0x62, 0x61, 0x66, 0x66, 0x65, 0x36, 0x65, 0x35, 0x63, 0x34, 0x37, 0x62, 0x64, 0x66, 0x64, 0x33, 0x36, 0x37, 0x31, 0x65, 0x65, 0x30, 0x31, 0x32, 0x34, 0x35, 0x30, 0x33, 0x63, 0x31, 0x30, 0x35, 0x35, 0x36, 0x61, 0x30, 0x61, 0x31, 0x30, 0x37, 0x36, 0x62, 0x30, 0x36, 0x63, 0x63, 0x65, 0x34, 0x30, 0x61, 0x30, 0x30, 0x62, 0x35, 0x38, 0x35, 0x33, 0x31, 0x32, 0x37, 0x32, 0x30, 0x64, 0x64, 0x66, 0x35, 0x61, 0x33, 0x35, 0x64, 0x32, 0x66, 0x64, 0x30, 0x34, 0x65, 0x66, 0x31, 0x31, 0x37, 0x31, 0x36, 0x38, 0x33, 0x32, 0x39, 0x37, 0x31, 0x61, 0x65, 0x31, 0x64, 0x36, 0x34, 0x65, 0x30, 0x37, 0x34, 0x37, 0x61, 0x35, 0x65, 0x61, 0x31, 0x62, 0x65, 0x61, 0x39, 0x66, 0x36, 0x64, 0x30, 0x36, 0x31, 0x37, 0x65, 0x34, 0x66, 0x35, 0x64, 0x63, 0x39, 0x61, 0x33, 0x39, 0x31, 0x61, 0x34, 0x61, 0x37, 0x66, 0x35, 0x37, 0x66, 0x64, 0x35, 0x38, 0x31, 0x37, 0x61, 0x37, 0x38, 0x32, 0x63, 0x62, 0x35, 0x66, 0x66, 0x64, 0x30, 0x35, 0x61, 0x61, 0x39, 0x39, 0x63, 0x63, 0x65, 0x37, 0x65, 0x39, 0x61, 0x35, 0x63, 0x61, 0x30, 0x38, 0x64, 0x33, 0x34, 0x65, 0x33, 0x37, 0x31, 0x32, 0x33, 0x36, 0x65, 0x30, 0x37, 0x34, 0x33, 0x35, 0x31, 0x37, 0x64, 0x39, 0x37, 0x32, 0x31, 0x62, 0x36, 0x64, 0x66, 0x35, 0x30, 0x63, 0x66, 0x66, 0x66, 0x36, 0x65, 0x66, 0x34, 0x32, 0x34, 0x63, 0x30, 0x61, 0x63, 0x37, 0x33, 0x34, 0x62, 0x36, 0x36, 0x66, 0x33, 0x64, 0x66, 0x64, 0x66, 0x37, 0x35, 0x39, 0x33, 0x31, 0x38, 0x35, 0x38, 0x66, 0x38, 0x37, 0x33, 0x63, 0x37, 0x62, 0x31, 0x62, 0x39, 0x62, 0x65, 0x62, 0x37, 0x61, 0x30, 0x35, 0x36, 0x66, 0x35, 0x38, 0x37, 0x32, 0x39, 0x61, 0x38, 0x31, 0x31, 0x36, 0x61, 0x38, 0x37, 0x66, 0x65, 0x66, 0x33, 0x65, 0x63, 0x62, 0x66, 0x34, 0x62, 0x37, 0x35, 0x32, 0x31, 0x64, 0x36, 0x66, 0x66, 0x63, 0x38, 0x61, 0x61, 0x63, 0x37, 0x38, 0x62, 0x65, 0x33, 0x63, 0x64, 0x62, 0x35, 0x34, 0x30, 0x35, 0x39, 0x66, 0x35, 0x36, 0x66, 0x37, 0x64, 0x34, 0x30, 0x31, 0x64, 0x32, 0x64, 0x39, 0x64, 0x65, 0x63, 0x64, 0x37, 0x32, 0x35, 0x30, 0x66, 0x64, 0x62, 0x35, 0x31, 0x62, 0x35, 0x34, 0x37, 0x66, 0x35, 0x32, 0x30, 0x32, 0x33, 0x66, 0x33, 0x30, 0x64, 0x32, 0x64, 0x65, 0x39, 0x30, 0x34, 0x63, 0x39, 0x62, 0x64, 0x33, 0x36, 0x63, 0x64, 0x32, 0x65, 0x64, 0x62, 0x38, 0x63, 0x34, 0x36, 0x62, 0x30, 0x65, 0x64, 0x62, 0x65, 0x64, 0x36, 0x30, 0x63, 0x65, 0x39, 0x65, 0x35, 0x30, 0x34, 0x35, 0x65, 0x35, 0x30, 0x33, 0x62, 0x63, 0x64, 0x32, 0x64, 0x30, 0x38, 0x65, 0x61, 0x61, 0x38, 0x38, 0x65, 0x61, 0x39, 0x35, 0x30, 0x62, 0x62, 0x34, 0x38, 0x35, 0x34, 0x33, 0x62, 0x31, 0x62, 0x65, 0x63, 0x66, 0x65, 0x39, 0x38, 0x30, 0x62, 0x32, 0x39, 0x38, 0x63, 0x31, 0x36, 0x32, 0x39, 0x34, 0x39, 0x65, 0x36, 0x37, 0x39, 0x63, 0x64, 0x36, 0x36, 0x63, 0x30, 0x37, 0x65, 0x37, 0x39, 0x39, 0x39, 0x62, 0x37, 0x32, 0x65, 0x30, 0x64, 0x33, 0x63, 0x66, 0x39, 0x34, 0x33, 0x65, 0x34, 0x37, 0x35, 0x36, 0x63, 0x34, 0x66, 0x39, 0x32, 0x63, 0x35, 0x62, 0x62, 0x65, 0x35, 0x64, 0x38, 0x37, 0x62, 0x35, 0x65, 0x35, 0x63, 0x39, 0x36, 0x65, 0x33, 0x33, 0x38, 0x66, 0x35, 0x32, 0x63, 0x34, 0x61, 0x39, 0x31, 0x30, 0x35, 0x64, 0x64, 0x66, 0x63, 0x64, 0x39, 0x30, 0x61, 0x33, 0x66, 0x31, 0x32, 0x38, 0x37, 0x32, 0x63, 0x31, 0x64, 0x36, 0x62, 0x35, 0x30, 0x66, 0x64, 0x36, 0x33, 0x32, 0x64, 0x30, 0x64, 0x64, 0x66, 0x61, 0x61, 0x66, 0x30, 0x35, 0x63, 0x35, 0x36, 0x63, 0x39, 0x61, 0x64, 0x65, 0x38, 0x35, 0x66, 0x38, 0x64, 0x61, 0x39, 0x64, 0x62, 0x31, 0x37, 0x31, 0x66, 0x66, 0x63, 0x63, 0x34, 0x34, 0x61, 0x32, 0x34, 0x63, 0x34, 0x33, 0x32, 0x30, 0x65, 0x39, 0x32, 0x38, 0x35, 0x63, 0x36, 0x66, 0x62, 0x38, 0x31, 0x63, 0x66, 0x61, 0x39, 0x32, 0x61, 0x30, 0x62, 0x66, 0x63, 0x30, 0x61, 0x31, 0x32, 0x64, 0x32, 0x31, 0x66, 0x33, 0x30, 0x63, 0x35, 0x38, 0x38, 0x61, 0x66, 0x38, 0x62, 0x39, 0x66, 0x32, 0x62, 0x32, 0x32, 0x64, 0x62, 0x35, 0x66, 0x65, 0x63, 0x32, 0x37, 0x34, 0x66, 0x33, 0x62, 0x38, 0x32, 0x61, 0x38, 0x62, 0x61, 0x31, 0x61, 0x32, 0x61, 0x36, 0x36, 0x38, 0x37, 0x32, 0x38, 0x39, 0x33, 0x37, 0x31, 0x38, 0x30, 0x39, 0x35, 0x37, 0x37, 0x64, 0x30, 0x61, 0x31, 0x30, 0x34, 0x66, 0x63, 0x33, 0x62, 0x66, 0x31, 0x66, 0x65, 0x31, 0x33, 0x32, 0x61, 0x65, 0x38, 0x62, 0x64, 0x30, 0x37, 0x38, 0x35, 0x32, 0x37, 0x30, 0x31, 0x34, 0x35, 0x34, 0x30, 0x61, 0x35, 0x30, 0x61, 0x63, 0x65, 0x36, 0x31, 0x30, 0x34, 0x36, 0x37, 0x35, 0x63, 0x62, 0x32, 0x65, 0x36, 0x31, 0x65, 0x38, 0x64, 0x32, 0x39, 0x32, 0x65, 0x66, 0x66, 0x65, 0x65, 0x30, 0x38, 0x64, 0x32, 0x63, 0x39, 0x37, 0x66, 0x31, 0x34, 0x34, 0x61, 0x34, 0x37, 0x35, 0x39, 0x61, 0x64, 0x62, 0x39, 0x63, 0x61, 0x65, 0x34, 0x39, 0x31, 0x61, 0x33, 0x36, 0x39, 0x36, 0x30, 0x65, 0x38, 0x32, 0x63, 0x65, 0x32, 0x36, 0x30, 0x34, 0x66, 0x33, 0x31, 0x32, 0x62, 0x64, 0x65, 0x36, 0x38, 0x36, 0x37, 0x32, 0x61, 0x32, 0x61, 0x61, 0x63, 0x63, 0x35, 0x39, 0x39, 0x36, 0x38, 0x31, 0x64, 0x33, 0x38, 0x33, 0x33, 0x38, 0x37, 0x38, 0x66, 0x38, 0x37, 0x39, 0x66, 0x64, 0x66, 0x62, 0x66, 0x63, 0x34, 0x62, 0x37, 0x30, 0x37, 0x34, 0x37, 0x37, 0x30, 0x31, 0x66, 0x37, 0x33, 0x38, 0x61, 0x33, 0x38, 0x37, 0x32, 0x37, 0x33, 0x63, 0x65, 0x39, 0x31, 0x32, 0x39, 0x66, 0x63, 0x32, 0x64, 0x65, 0x31, 0x61, 0x39, 0x66, 0x32, 0x64, 0x38, 0x64, 0x39, 0x31, 0x64, 0x34, 0x34, 0x61, 0x65, 0x61, 0x38, 0x38, 0x35, 0x33, 0x64, 0x34, 0x62, 0x35, 0x38, 0x64, 0x31, 0x65, 0x33, 0x34, 0x63, 0x35, 0x34, 0x32, 0x36, 0x32, 0x63, 0x34, 0x66, 0x65, 0x38, 0x34, 0x61, 0x37, 0x33, 0x34, 0x36, 0x39, 0x62, 0x33, 0x63, 0x33, 0x35, 0x36, 0x30, 0x33, 0x38, 0x35, 0x35, 0x64, 0x30, 0x38, 0x64, 0x38, 0x34, 0x32, 0x37, 0x39, 0x32, 0x39, 0x64, 0x38, 0x64, 0x30, 0x63, 0x38, 0x30, 0x36, 0x62, 0x32, 0x38, 0x66, 0x38, 0x37, 0x61, 0x39, 0x33, 0x38, 0x62, 0x62, 0x39, 0x62, 0x62, 0x32, 0x36, 0x34, 0x34, 0x32, 0x61, 0x37, 0x63, 0x61, 0x63, 0x35, 0x66, 0x35, 0x61, 0x63, 0x35, 0x66, 0x32, 0x65, 0x64, 0x61, 0x37, 0x63, 0x38, 0x38, 0x38, 0x30, 0x33, 0x39, 0x34, 0x36, 0x35, 0x38, 0x38, 0x38, 0x37, 0x32, 0x31, 0x34, 0x64, 0x39, 0x39, 0x38, 0x35, 0x39, 0x35, 0x63, 0x65, 0x61, 0x61, 0x65, 0x37, 0x32, 0x30, 0x64, 0x64, 0x35, 0x36, 0x33, 0x31, 0x32, 0x65, 0x65, 0x64, 0x36, 0x31, 0x34, 0x65, 0x63, 0x32, 0x30, 0x36, 0x66, 0x34, 0x30, 0x38, 0x66, 0x65, 0x33, 0x64, 0x64, 0x65, 0x61, 0x39, 0x65, 0x65, 0x31, 0x64, 0x63, 0x37, 0x33, 0x37, 0x36, 0x63, 0x63, 0x37, 0x39, 0x38, 0x36, 0x35, 0x35, 0x64, 0x36, 0x35, 0x37, 0x33, 0x37, 0x30, 0x62, 0x34, 0x66, 0x65, 0x38, 0x37, 0x35, 0x31, 0x39, 0x30, 0x31, 0x62, 0x30, 0x39, 0x36, 0x36, 0x36, 0x31, 0x66, 0x63, 0x33, 0x31, 0x64, 0x64, 0x35, 0x38, 0x37, 0x33, 0x31, 0x37, 0x61, 0x36, 0x33, 0x31, 0x36, 0x32, 0x35, 0x32, 0x36, 0x34, 0x36, 0x38, 0x31, 0x37, 0x34, 0x30, 0x37, 0x65, 0x30, 0x61, 0x34, 0x63, 0x66, 0x65, 0x39, 0x32, 0x35, 0x39, 0x66, 0x30, 0x64, 0x34, 0x62, 0x34, 0x62, 0x66, 0x64, 0x35, 0x62, 0x30, 0x66, 0x64, 0x36, 0x31, 0x35, 0x33, 0x32, 0x61, 0x65, 0x31, 0x66, 0x32, 0x30, 0x36, 0x30, 0x38, 0x32, 0x62, 0x39, 0x63, 0x31, 0x66, 0x37, 0x38, 0x39, 0x66, 0x36, 0x65, 0x64, 0x38, 0x33, 0x61, 0x33, 0x62, 0x39, 0x65, 0x63, 0x33, 0x63, 0x37, 0x32, 0x34, 0x63, 0x64, 0x36, 0x35, 0x37, 0x39, 0x31, 0x37, 0x32, 0x32, 0x33, 0x34, 0x61, 0x64, 0x39, 0x35, 0x35, 0x61, 0x39, 0x35, 0x39, 0x30, 0x61, 0x35, 0x38, 0x39, 0x65, 0x62, 0x36, 0x63, 0x35, 0x37, 0x35, 0x34, 0x65, 0x66, 0x30, 0x34, 0x62, 0x34, 0x39, 0x35, 0x32, 0x63, 0x65, 0x38, 0x61, 0x61, 0x37, 0x30, 0x37, 0x34, 0x38, 0x32, 0x37, 0x31, 0x63, 0x37, 0x31, 0x38, 0x34, 0x35, 0x65, 0x64, 0x36, 0x65, 0x34, 0x35, 0x33, 0x66, 0x66, 0x35, 0x64, 0x33, 0x65, 0x62, 0x33, 0x62, 0x62, 0x65, 0x35, 0x32, 0x66, 0x38, 0x36, 0x37, 0x33, 0x62, 0x62, 0x37, 0x32, 0x31, 0x35, 0x39, 0x32, 0x65, 0x34, 0x63, 0x35, 0x66, 0x39, 0x38, 0x63, 0x35, 0x39, 0x39, 0x38, 0x31, 0x39, 0x34, 0x32, 0x38, 0x31, 0x35, 0x63, 0x64, 0x63, 0x38, 0x39, 0x36, 0x31, 0x64, 0x66, 0x33, 0x64, 0x37, 0x38, 0x37, 0x34, 0x33, 0x30, 0x66, 0x31, 0x31, 0x39, 0x37, 0x32, 0x33, 0x38, 0x62, 0x33, 0x38, 0x66, 0x30, 0x32, 0x33, 0x33, 0x37, 0x32, 0x65, 0x37, 0x64, 0x66, 0x61, 0x66, 0x31, 0x35, 0x39, 0x37, 0x35, 0x66, 0x61, 0x38, 0x61, 0x34, 0x63, 0x34, 0x61, 0x31, 0x35, 0x61, 0x37, 0x62, 0x30, 0x65, 0x65, 0x36, 0x34, 0x36, 0x35, 0x33, 0x62, 0x61, 0x37, 0x61, 0x35, 0x64, 0x61, 0x63, 0x33, 0x62, 0x34, 0x30, 0x63, 0x33, 0x64, 0x33, 0x61, 0x64, 0x37, 0x32, 0x32, 0x63, 0x65, 0x39, 0x62, 0x62, 0x61, 0x63, 0x39, 0x39, 0x30, 0x66, 0x31, 0x34, 0x32, 0x30, 0x35, 0x33, 0x62, 0x36, 0x37, 0x63, 0x32, 0x39, 0x30, 0x64, 0x33, 0x65, 0x65, 0x64, 0x35, 0x35, 0x66, 0x61, 0x31, 0x33, 0x38, 0x36, 0x66, 0x33, 0x64, 0x33, 0x31, 0x63, 0x64, 0x66, 0x36, 0x66, 0x35, 0x31, 0x35, 0x38, 0x31, 0x65, 0x66, 0x39, 0x34, 0x32, 0x61, 0x31, 0x38, 0x38, 0x35, 0x34, 0x66, 0x66, 0x38, 0x64, 0x35, 0x35, 0x35, 0x31, 0x38, 0x37, 0x39, 0x61, 0x34, 0x61, 0x35, 0x62, 0x38, 0x66, 0x32, 0x31, 0x66, 0x62, 0x63, 0x35, 0x61, 0x33, 0x32, 0x32, 0x64, 0x32, 0x31, 0x35, 0x36, 0x34, 0x65, 0x63, 0x64, 0x62, 0x36, 0x62, 0x66, 0x37, 0x30, 0x62, 0x39, 0x30, 0x30, 0x33, 0x35, 0x33, 0x38, 0x37, 0x30, 0x38, 0x34, 0x65, 0x36, 0x35, 0x39, 0x61, 0x34, 0x36, 0x32, 0x32, 0x38, 0x38, 0x64, 0x35, 0x36, 0x62, 0x31, 0x36, 0x31, 0x37, 0x33, 0x34, 0x35, 0x37, 0x35, 0x36, 0x65, 0x30, 0x37, 0x33, 0x39, 0x39, 0x66, 0x34, 0x66, 0x65, 0x33, 0x31, 0x61, 0x63, 0x39, 0x65, 0x35, 0x36, 0x30, 0x34, 0x64, 0x63, 0x62, 0x33, 0x62, 0x33, 0x66, 0x37, 0x30, 0x34, 0x37, 0x34, 0x35, 0x33, 0x36, 0x31, 0x34, 0x36, 0x65, 0x65, 0x39, 0x35, 0x39, 0x61, 0x35, 0x62, 0x36, 0x35, 0x66, 0x38, 0x30, 0x36, 0x63, 0x34, 0x30, 0x32, 0x64, 0x34, 0x33, 0x64, 0x35, 0x66, 0x35, 0x32, 0x64, 0x34, 0x62, 0x63, 0x33, 0x65, 0x38, 0x30, 0x61, 0x38, 0x34, 0x65, 0x36, 0x30, 0x61, 0x30, 0x64, 0x38, 0x34, 0x63, 0x30, 0x64, 0x65, 0x62, 0x65, 0x34, 0x61, 0x34, 0x30, 0x39, 0x66, 0x35, 0x66, 0x65, 0x34, 0x34, 0x35, 0x33, 0x31, 0x35, 0x31, 0x61, 0x30, 0x63, 0x32, 0x62, 0x31, 0x30, 0x35, 0x66, 0x34, 0x35, 0x65, 0x33, 0x65, 0x63, 0x36, 0x32, 0x31, 0x39, 0x62, 0x30, 0x63, 0x65, 0x38, 0x36, 0x30, 0x36, 0x34, 0x33, 0x61, 0x37, 0x33, 0x33, 0x33, 0x37, 0x65, 0x62, 0x64, 0x38, 0x32, 0x37, 0x35, 0x65, 0x38, 0x64, 0x39, 0x66, 0x63, 0x66, 0x35, 0x37, 0x62, 0x34, 0x36, 0x30, 0x37, 0x63, 0x36, 0x61, 0x34, 0x38, 0x33, 0x39, 0x39, 0x34, 0x61, 0x62, 0x33, 0x32, 0x33, 0x62, 0x63, 0x64, 0x30, 0x65, 0x39, 0x39, 0x37, 0x30, 0x64, 0x39, 0x38, 0x39, 0x31, 0x39, 0x64, 0x65, 0x32, 0x38, 0x61, 0x35, 0x63, 0x64, 0x65, 0x33, 0x39, 0x30, 0x33, 0x31, 0x31, 0x61, 0x63, 0x61, 0x38, 0x31, 0x32, 0x39, 0x38, 0x64, 0x64, 0x63, 0x35, 0x39, 0x35, 0x35, 0x32, 0x31, 0x37, 0x34, 0x38, 0x30, 0x64, 0x66, 0x37, 0x65, 0x37, 0x63, 0x35, 0x34, 0x33, 0x30, 0x38, 0x33, 0x37, 0x32, 0x36, 0x33, 0x30, 0x39, 0x34, 0x34, 0x36, 0x37, 0x63, 0x61, 0x32, 0x63, 0x30, 0x63, 0x62, 0x63, 0x63, 0x37, 0x65, 0x39, 0x65, 0x37, 0x36, 0x36, 0x36, 0x32, 0x33, 0x39, 0x66, 0x30, 0x63, 0x66, 0x35, 0x35, 0x36, 0x34, 0x66, 0x37, 0x30, 0x35, 0x64, 0x32, 0x65, 0x61, 0x38, 0x65, 0x64, 0x61, 0x35, 0x30, 0x39, 0x62, 0x37, 0x37, 0x36, 0x35, 0x38, 0x37, 0x61, 0x36, 0x66, 0x33, 0x34, 0x30, 0x66, 0x37, 0x30, 0x34, 0x66, 0x65, 0x34, 0x33, 0x39, 0x61, 0x63, 0x65, 0x61, 0x63, 0x37, 0x62, 0x62, 0x61, 0x65, 0x39, 0x34, 0x38, 0x30, 0x36, 0x31, 0x34, 0x31, 0x31, 0x65, 0x61, 0x62, 0x31, 0x31, 0x32, 0x33, 0x30, 0x36, 0x33, 0x39, 0x39, 0x35, 0x37, 0x34, 0x37, 0x39, 0x38, 0x65, 0x61, 0x65, 0x38, 0x61, 0x31, 0x39, 0x63, 0x31, 0x35, 0x37, 0x66, 0x61, 0x37, 0x32, 0x37, 0x35, 0x39, 0x30, 0x39, 0x66, 0x61, 0x30, 0x62, 0x38, 0x61, 0x66, 0x36, 0x61, 0x30, 0x30, 0x66, 0x61, 0x32, 0x39, 0x34, 0x34, 0x36, 0x35, 0x31, 0x65, 0x34, 0x35, 0x66, 0x66, 0x36, 0x62, 0x35, 0x36, 0x66, 0x62, 0x62, 0x61, 0x64, 0x35, 0x65, 0x32, 0x37, 0x65, 0x36, 0x32, 0x65, 0x31, 0x30, 0x65, 0x30, 0x39, 0x65, 0x33, 0x36, 0x38, 0x36, 0x35, 0x30, 0x66, 0x36, 0x35, 0x64, 0x39, 0x39, 0x37, 0x32, 0x33, 0x61, 0x34, 0x64, 0x34, 0x33, 0x65, 0x63, 0x37, 0x34, 0x36, 0x33, 0x30, 0x30, 0x62, 0x64, 0x65, 0x39, 0x34, 0x65, 0x30, 0x61, 0x35, 0x62, 0x30, 0x31, 0x61, 0x32, 0x30, 0x64, 0x64, 0x38, 0x63, 0x64, 0x37, 0x38, 0x66, 0x36, 0x31, 0x66, 0x61, 0x39, 0x65, 0x65, 0x63, 0x32, 0x37, 0x61, 0x63, 0x30, 0x63, 0x36, 0x62, 0x30, 0x30, 0x31, 0x35, 0x35, 0x39, 0x35, 0x65, 0x61, 0x33, 0x31, 0x66, 0x38, 0x36, 0x33, 0x30, 0x66, 0x65, 0x32, 0x36, 0x31, 0x35, 0x34, 0x61, 0x39, 0x66, 0x65, 0x36, 0x31, 0x35, 0x63, 0x35, 0x39, 0x35, 0x32, 0x35, 0x33, 0x38, 0x35, 0x65, 0x31, 0x38, 0x62, 0x65, 0x33, 0x32, 0x30, 0x32, 0x66, 0x66, 0x66, 0x63, 0x33, 0x36, 0x37, 0x62, 0x65, 0x64, 0x35, 0x39, 0x34, 0x36, 0x33, 0x39, 0x63, 0x39, 0x62, 0x63, 0x64, 0x31, 0x38, 0x63, 0x36, 0x32, 0x35, 0x64, 0x34, 0x33, 0x34, 0x65, 0x34, 0x61, 0x63, 0x30, 0x34, 0x61, 0x38, 0x37, 0x34, 0x32, 0x62, 0x63, 0x39, 0x34, 0x65, 0x61, 0x37, 0x37, 0x30, 0x65, 0x38, 0x32, 0x64, 0x62, 0x63, 0x36, 0x36, 0x39, 0x64, 0x32, 0x34, 0x65, 0x39, 0x32, 0x36, 0x33, 0x64, 0x63, 0x63, 0x31, 0x30, 0x38, 0x35, 0x66, 0x62, 0x65, 0x61, 0x61, 0x39, 0x39, 0x61, 0x66, 0x64, 0x61, 0x39, 0x30, 0x64, 0x37, 0x32, 0x32, 0x66, 0x63, 0x31, 0x30, 0x32, 0x37, 0x35, 0x64, 0x30, 0x35, 0x32, 0x34, 0x31, 0x39, 0x38, 0x34, 0x34, 0x36, 0x63, 0x37, 0x66, 0x37, 0x32, 0x35, 0x30, 0x36, 0x63, 0x34, 0x66, 0x65, 0x37, 0x66, 0x39, 0x38, 0x39, 0x61, 0x64, 0x33, 0x35, 0x31, 0x66, 0x39, 0x37, 0x35, 0x62, 0x63, 0x35, 0x37, 0x32, 0x63, 0x35, 0x35, 0x38, 0x32, 0x66, 0x65, 0x38, 0x66, 0x34, 0x66, 0x36, 0x34, 0x37, 0x31, 0x33, 0x66, 0x38, 0x33, 0x66, 0x36, 0x35, 0x36, 0x64, 0x37, 0x34, 0x35, 0x62, 0x62, 0x61, 0x63, 0x65, 0x32, 0x66, 0x32, 0x35, 0x65, 0x64, 0x36, 0x35, 0x32, 0x39, 0x61, 0x35, 0x63, 0x38, 0x34, 0x38, 0x66, 0x33, 0x39, 0x38, 0x33, 0x36, 0x64, 0x66, 0x33, 0x35, 0x33, 0x31, 0x66, 0x31, 0x64, 0x36, 0x32, 0x38, 0x31, 0x39, 0x66, 0x39, 0x64, 0x37, 0x36, 0x39, 0x38, 0x32, 0x30, 0x36, 0x65, 0x31, 0x38, 0x38, 0x30, 0x31, 0x32, 0x37, 0x31, 0x39, 0x64, 0x62, 0x65, 0x35, 0x31, 0x33, 0x31, 0x66, 0x35, 0x30, 0x33, 0x63, 0x31, 0x62, 0x38, 0x64, 0x37, 0x62, 0x39, 0x34, 0x37, 0x32, 0x36, 0x35, 0x38, 0x65, 0x62, 0x62, 0x36, 0x38, 0x30, 0x66, 0x62, 0x36, 0x64, 0x32, 0x66, 0x63, 0x32, 0x66, 0x31, 0x65, 0x61, 0x39, 0x64, 0x35, 0x33, 0x33, 0x31, 0x65, 0x33, 0x35, 0x37, 0x32, 0x33, 0x39, 0x37, 0x64, 0x37, 0x63, 0x30, 0x30, 0x33, 0x34, 0x32, 0x63, 0x66, 0x32, 0x30, 0x65, 0x64, 0x33, 0x32, 0x64, 0x33, 0x63, 0x39, 0x63, 0x34, 0x65, 0x31, 0x62, 0x32, 0x30, 0x35, 0x64, 0x64, 0x33, 0x31, 0x61, 0x35, 0x64, 0x61, 0x62, 0x38, 0x36, 0x64, 0x37, 0x33, 0x61, 0x32, 0x61, 0x35, 0x39, 0x36, 0x37, 0x64, 0x33, 0x65, 0x61, 0x63, 0x61, 0x37, 0x31, 0x66, 0x39, 0x37, 0x32, 0x64, 0x64, 0x31, 0x33, 0x32, 0x34, 0x39, 0x35, 0x37, 0x36, 0x30, 0x37, 0x32, 0x65, 0x64, 0x66, 0x36, 0x38, 0x36, 0x36, 0x31, 0x34, 0x65, 0x34, 0x34, 0x61, 0x32, 0x37, 0x62, 0x37, 0x65, 0x35, 0x63, 0x39, 0x30, 0x30, 0x64, 0x33, 0x61, 0x61, 0x62, 0x37, 0x30, 0x33, 0x37, 0x39, 0x39, 0x65, 0x65, 0x66, 0x38, 0x34, 0x37, 0x61, 0x35, 0x65, 0x65, 0x61, 0x63, 0x33, 0x61, 0x63, 0x37, 0x32, 0x31, 0x62, 0x62, 0x61, 0x35, 0x34, 0x33, 0x62, 0x38, 0x61, 0x34, 0x32, 0x63, 0x37, 0x66, 0x36, 0x64, 0x62, 0x32, 0x30, 0x66, 0x64, 0x31, 0x65, 0x35, 0x32, 0x33, 0x34, 0x37, 0x34, 0x38, 0x39, 0x34, 0x38, 0x63, 0x32, 0x63, 0x37, 0x63, 0x66, 0x32, 0x30, 0x33, 0x62, 0x34, 0x36, 0x34, 0x61, 0x35, 0x30, 0x35, 0x35, 0x37, 0x37, 0x32, 0x65, 0x39, 0x34, 0x36, 0x63, 0x62, 0x63, 0x34, 0x62, 0x38, 0x33, 0x62, 0x64, 0x66, 0x35, 0x61, 0x64, 0x32, 0x32, 0x37, 0x65, 0x35, 0x31, 0x36, 0x62, 0x34, 0x66, 0x65, 0x38, 0x62, 0x32, 0x65, 0x61, 0x31, 0x30, 0x31, 0x37, 0x66, 0x31, 0x31, 0x62, 0x34, 0x33, 0x64, 0x65, 0x64, 0x35, 0x30, 0x33, 0x35, 0x32, 0x33, 0x63, 0x34, 0x30, 0x37, 0x62, 0x35, 0x32, 0x31, 0x66, 0x63, 0x36, 0x38, 0x65, 0x35, 0x36, 0x32, 0x36, 0x65, 0x37, 0x37, 0x32, 0x34, 0x36, 0x34, 0x38, 0x35, 0x33, 0x66, 0x63, 0x34, 0x39, 0x39, 0x64, 0x30, 0x66, 0x36, 0x37, 0x36, 0x35, 0x66, 0x38, 0x62, 0x63, 0x32, 0x62, 0x64, 0x64, 0x34, 0x35, 0x35, 0x62, 0x38, 0x66, 0x65, 0x33, 0x37, 0x33, 0x61, 0x35, 0x33, 0x61, 0x38, 0x62, 0x65, 0x38, 0x39, 0x65, 0x34, 0x32, 0x38, 0x62, 0x30, 0x65, 0x30, 0x66, 0x64, 0x64, 0x30, 0x36, 0x39, 0x32, 0x66, 0x61, 0x37, 0x32, 0x31, 0x62, 0x31, 0x39, 0x61, 0x65, 0x64, 0x35, 0x63, 0x64, 0x37, 0x38, 0x35, 0x33, 0x63, 0x35, 0x38, 0x63, 0x30, 0x64, 0x66, 0x38, 0x38, 0x31, 0x63, 0x38, 0x38, 0x63, 0x30, 0x36, 0x61, 0x66, 0x62, 0x34, 0x32, 0x39, 0x39, 0x33, 0x38, 0x38, 0x62, 0x31, 0x66, 0x62, 0x38, 0x38, 0x36, 0x61, 0x39, 0x63, 0x31, 0x62, 0x37, 0x38, 0x31, 0x35, 0x37, 0x36, 0x64, 0x65, 0x35, 0x35, 0x34, 0x34, 0x62, 0x62, 0x65, 0x34, 0x37, 0x62, 0x64, 0x62, 0x33, 0x34, 0x33, 0x65, 0x65, 0x37, 0x36, 0x37, 0x37, 0x66, 0x38, 0x34, 0x39, 0x37, 0x37, 0x65, 0x62, 0x37, 0x65, 0x31, 0x39, 0x37, 0x38, 0x36, 0x66, 0x34, 0x38, 0x33, 0x61, 0x61, 0x33, 0x61, 0x63, 0x65, 0x62, 0x34, 0x66, 0x35, 0x33, 0x39, 0x35, 0x31, 0x37, 0x62, 0x36, 0x61, 0x31, 0x37, 0x33, 0x34, 0x31, 0x65, 0x64, 0x34, 0x37, 0x32, 0x33, 0x30, 0x61, 0x34, 0x31, 0x30, 0x64, 0x64, 0x66, 0x64, 0x37, 0x39, 0x37, 0x62, 0x36, 0x33, 0x38, 0x38, 0x31, 0x65, 0x61, 0x33, 0x66, 0x35, 0x64, 0x38, 0x65, 0x66, 0x38, 0x62, 0x32, 0x35, 0x35, 0x66, 0x37, 0x31, 0x64, 0x64, 0x33, 0x64, 0x36, 0x36, 0x37, 0x65, 0x65, 0x37, 0x37, 0x64, 0x34, 0x61, 0x33, 0x63, 0x61, 0x38, 0x37, 0x39, 0x35, 0x30, 0x36, 0x33, 0x63, 0x35, 0x37, 0x32, 0x65, 0x32, 0x39, 0x61, 0x39, 0x32, 0x38, 0x66, 0x33, 0x65, 0x63, 0x33, 0x32, 0x31, 0x61, 0x38, 0x33, 0x39, 0x63, 0x35, 0x38, 0x31, 0x66, 0x61, 0x36, 0x36, 0x63, 0x35, 0x38, 0x65, 0x61, 0x61, 0x65, 0x63, 0x32, 0x31, 0x30, 0x32, 0x64, 0x61, 0x62, 0x33, 0x64, 0x66, 0x32, 0x32, 0x36, 0x35, 0x36, 0x31, 0x37, 0x65, 0x31, 0x30, 0x38, 0x38, 0x31, 0x33, 0x35, 0x36, 0x65, 0x61, 0x37, 0x32, 0x32, 0x63, 0x30, 0x34, 0x62, 0x31, 0x65, 0x30, 0x64, 0x36, 0x36, 0x33, 0x39, 0x37, 0x39, 0x62, 0x33, 0x64, 0x36, 0x64, 0x32, 0x30, 0x39, 0x34, 0x63, 0x66, 0x65, 0x37, 0x61, 0x32, 0x38, 0x34, 0x65, 0x65, 0x31, 0x36, 0x30, 0x63, 0x37, 0x64, 0x61, 0x32, 0x30, 0x35, 0x37, 0x64, 0x66, 0x63, 0x35, 0x63, 0x34, 0x33, 0x65, 0x30, 0x34, 0x33, 0x38, 0x66, 0x31, 0x39, 0x63, 0x30, 0x37, 0x32, 0x61, 0x35, 0x35, 0x66, 0x66, 0x31, 0x63, 0x37, 0x35, 0x38, 0x61, 0x36, 0x64, 0x36, 0x33, 0x39, 0x32, 0x65, 0x61, 0x35, 0x38, 0x64, 0x34, 0x35, 0x36, 0x31, 0x35, 0x66, 0x38, 0x63, 0x37, 0x61, 0x64, 0x66, 0x66, 0x63, 0x61, 0x62, 0x64, 0x66, 0x33, 0x30, 0x35, 0x65, 0x38, 0x65, 0x36, 0x33, 0x62, 0x63, 0x63, 0x64, 0x35, 0x61, 0x33, 0x35, 0x64, 0x66, 0x37, 0x61, 0x31, 0x39, 0x32, 0x63, 0x37, 0x33, 0x61, 0x32, 0x34, 0x65, 0x33, 0x63, 0x31, 0x34, 0x64, 0x39, 0x66, 0x39, 0x33, 0x65, 0x63, 0x32, 0x65, 0x61, 0x32, 0x31, 0x63, 0x63, 0x64, 0x64, 0x33, 0x65, 0x32, 0x66, 0x38, 0x66, 0x33, 0x33, 0x33, 0x30, 0x33, 0x64, 0x33, 0x36, 0x62, 0x37, 0x39, 0x63, 0x64, 0x66, 0x36, 0x39, 0x63, 0x61, 0x61, 0x34, 0x61, 0x63, 0x39, 0x64, 0x32, 0x63, 0x37, 0x31, 0x64, 0x63, 0x35, 0x38, 0x39, 0x37, 0x32, 0x66, 0x39, 0x63, 0x37, 0x66, 0x61, 0x37, 0x34, 0x37, 0x64, 0x33, 0x34, 0x33, 0x33, 0x37, 0x63, 0x39, 0x35, 0x65, 0x34, 0x39, 0x31, 0x63, 0x35, 0x37, 0x31, 0x64, 0x38, 0x36, 0x63, 0x64, 0x61, 0x64, 0x39, 0x34, 0x39, 0x35, 0x38, 0x61, 0x39, 0x61, 0x37, 0x31, 0x30, 0x36, 0x31, 0x32, 0x63, 0x33, 0x64, 0x35, 0x61, 0x63, 0x33, 0x65, 0x64, 0x35, 0x37, 0x37, 0x37, 0x32, 0x34, 0x38, 0x38, 0x37, 0x61, 0x66, 0x32, 0x39, 0x64, 0x61, 0x39, 0x35, 0x36, 0x31, 0x35, 0x39, 0x31, 0x30, 0x64, 0x64, 0x35, 0x30, 0x66, 0x36, 0x64, 0x63, 0x64, 0x30, 0x66, 0x61, 0x32, 0x34, 0x62, 0x38, 0x33, 0x38, 0x35, 0x31, 0x37, 0x62, 0x37, 0x65, 0x34, 0x37, 0x65, 0x32, 0x65, 0x61, 0x31, 0x35, 0x33, 0x35, 0x62, 0x33, 0x31, 0x34, 0x64, 0x36, 0x63, 0x31, 0x38, 0x66, 0x37, 0x32, 0x65, 0x65, 0x65, 0x64, 0x35, 0x65, 0x66, 0x38, 0x35, 0x61, 0x34, 0x38, 0x33, 0x39, 0x30, 0x63, 0x39, 0x37, 0x64, 0x36, 0x31, 0x32, 0x30, 0x32, 0x34, 0x64, 0x61, 0x38, 0x61, 0x38, 0x32, 0x61, 0x62, 0x30, 0x37, 0x38, 0x63, 0x62, 0x39, 0x33, 0x39, 0x64, 0x65, 0x62, 0x33, 0x33, 0x63, 0x31, 0x32, 0x64, 0x30, 0x32, 0x64, 0x66, 0x31, 0x31, 0x34, 0x33, 0x62, 0x35, 0x62, 0x63, 0x36, 0x35, 0x63, 0x63, 0x63, 0x39, 0x61, 0x65, 0x39, 0x61, 0x36, 0x62, 0x62, 0x35, 0x62, 0x39, 0x33, 0x33, 0x61, 0x62, 0x61, 0x38, 0x34, 0x30, 0x33, 0x38, 0x38, 0x36, 0x63, 0x63, 0x66, 0x36, 0x63, 0x65, 0x32, 0x63, 0x39, 0x39, 0x30, 0x32, 0x36, 0x31, 0x66, 0x62, 0x34, 0x33, 0x30, 0x34, 0x37, 0x62, 0x30, 0x61, 0x66, 0x37, 0x63, 0x65, 0x32, 0x30, 0x63, 0x63, 0x36, 0x65, 0x38, 0x65, 0x34, 0x37, 0x38, 0x33, 0x37, 0x36, 0x65, 0x31, 0x62, 0x33, 0x39, 0x66, 0x66, 0x66, 0x66, 0x30, 0x61, 0x63, 0x36, 0x63, 0x32, 0x32, 0x35, 0x38, 0x65, 0x39, 0x62, 0x38, 0x37, 0x34, 0x66, 0x33, 0x30, 0x35, 0x34, 0x63, 0x30, 0x63, 0x30, 0x64, 0x37, 0x31, 0x62, 0x32, 0x61, 0x32, 0x63, 0x38, 0x65, 0x39, 0x32, 0x36, 0x34, 0x30, 0x36, 0x33, 0x35, 0x34, 0x64, 0x63, 0x37, 0x63, 0x38, 0x36, 0x32, 0x33, 0x30, 0x35, 0x66, 0x63, 0x36, 0x33, 0x62, 0x36, 0x35, 0x33, 0x36, 0x38, 0x63, 0x35, 0x64, 0x61, 0x31, 0x65, 0x65, 0x62, 0x31, 0x38, 0x65, 0x31, 0x38, 0x30, 0x30, 0x33, 0x65, 0x37, 0x31, 0x65, 0x35, 0x36, 0x37, 0x66, 0x33, 0x61, 0x34, 0x39, 0x66, 0x62, 0x62, 0x38, 0x63, 0x62, 0x38, 0x35, 0x36, 0x39, 0x37, 0x65, 0x61, 0x39, 0x64, 0x64, 0x33, 0x30, 0x63, 0x35, 0x35, 0x34, 0x35, 0x32, 0x61, 0x62, 0x35, 0x38, 0x30, 0x34, 0x34, 0x37, 0x34, 0x30, 0x34, 0x31, 0x65, 0x32, 0x64, 0x34, 0x34, 0x64, 0x33, 0x64, 0x32, 0x65, 0x36, 0x66, 0x37, 0x37, 0x37, 0x31, 0x34, 0x63, 0x65, 0x38, 0x36, 0x33, 0x37, 0x31, 0x32, 0x32, 0x33, 0x30, 0x66, 0x65, 0x36, 0x32, 0x36, 0x34, 0x30, 0x30, 0x61, 0x65, 0x34, 0x33, 0x32, 0x38, 0x66, 0x31, 0x66, 0x61, 0x31, 0x37, 0x61, 0x37, 0x35, 0x34, 0x65, 0x64, 0x62, 0x63, 0x64, 0x32, 0x62, 0x34, 0x65, 0x33, 0x38, 0x31, 0x33, 0x39, 0x38, 0x33, 0x33, 0x30, 0x39, 0x34, 0x62, 0x61, 0x66, 0x64, 0x62, 0x62, 0x64, 0x35, 0x38, 0x30, 0x32, 0x38, 0x38, 0x64, 0x65, 0x31, 0x62, 0x37, 0x31, 0x63, 0x39, 0x62, 0x30, 0x39, 0x31, 0x65, 0x63, 0x66, 0x34, 0x66, 0x63, 0x34, 0x30, 0x64, 0x34, 0x38, 0x37, 0x65, 0x38, 0x35, 0x64, 0x38, 0x37, 0x32, 0x30, 0x31, 0x35, 0x66, 0x38, 0x66, 0x33, 0x30, 0x38, 0x63, 0x34, 0x65, 0x33, 0x38, 0x33, 0x64, 0x39, 0x63, 0x65, 0x35, 0x37, 0x39, 0x38, 0x30, 0x63, 0x33, 0x31, 0x33, 0x36, 0x33, 0x63, 0x61, 0x37, 0x30, 0x65, 0x35, 0x63, 0x63, 0x39, 0x30, 0x37, 0x31, 0x33, 0x63, 0x36, 0x63, 0x66, 0x62, 0x39, 0x36, 0x39, 0x33, 0x61, 0x36, 0x61, 0x62, 0x37, 0x65, 0x64, 0x35, 0x30, 0x31, 0x37, 0x32, 0x38, 0x63, 0x36, 0x64, 0x33, 0x64, 0x64, 0x36, 0x36, 0x36, 0x66, 0x64, 0x30, 0x65, 0x63, 0x61, 0x38, 0x38, 0x30, 0x31, 0x63, 0x38, 0x66, 0x65, 0x64, 0x61, 0x61, 0x37, 0x64, 0x39, 0x33, 0x63, 0x63, 0x64, 0x32, 0x66, 0x36, 0x36, 0x30, 0x30, 0x65, 0x31, 0x65, 0x37, 0x37, 0x63, 0x37, 0x65, 0x33, 0x38, 0x39, 0x62, 0x38, 0x39, 0x37, 0x66, 0x35, 0x34, 0x63, 0x63, 0x30, 0x37, 0x37, 0x32, 0x33, 0x66, 0x61, 0x37, 0x65, 0x65, 0x63, 0x63, 0x39, 0x65, 0x32, 0x31, 0x63, 0x61, 0x36, 0x31, 0x62, 0x36, 0x37, 0x64, 0x30, 0x36, 0x34, 0x39, 0x37, 0x32, 0x62, 0x62, 0x31, 0x39, 0x64, 0x37, 0x66, 0x63, 0x64, 0x37, 0x30, 0x33, 0x61, 0x32, 0x32, 0x34, 0x37, 0x61, 0x64, 0x62, 0x39, 0x32, 0x63, 0x31, 0x37, 0x35, 0x36, 0x37, 0x65, 0x32, 0x39, 0x37, 0x62, 0x33, 0x38, 0x35, 0x37, 0x32, 0x30, 0x35, 0x62, 0x34, 0x62, 0x33, 0x66, 0x38, 0x64, 0x34, 0x36, 0x37, 0x65, 0x32, 0x66, 0x62, 0x33, 0x61, 0x31, 0x65, 0x38, 0x30, 0x32, 0x63, 0x66, 0x62, 0x30, 0x37, 0x37, 0x61, 0x38, 0x35, 0x35, 0x35, 0x65, 0x31, 0x35, 0x37, 0x30, 0x61, 0x61, 0x36, 0x66, 0x31, 0x62, 0x34, 0x62, 0x61, 0x34, 0x37, 0x32, 0x66, 0x39, 0x39, 0x34, 0x64, 0x38, 0x34, 0x65, 0x33, 0x32, 0x32, 0x32, 0x34, 0x31, 0x34, 0x37, 0x35, 0x66, 0x31, 0x37, 0x38, 0x66, 0x33, 0x39, 0x31, 0x34, 0x61, 0x31, 0x64, 0x61, 0x63, 0x31, 0x37, 0x30, 0x34, 0x34, 0x31, 0x31, 0x65, 0x30, 0x63, 0x65, 0x31, 0x61, 0x34, 0x35, 0x34, 0x35, 0x33, 0x39, 0x39, 0x31, 0x35, 0x34, 0x39, 0x32, 0x38, 0x32, 0x36, 0x63, 0x33, 0x63, 0x30, 0x66, 0x34, 0x32, 0x34, 0x34, 0x39, 0x63, 0x30, 0x64, 0x62, 0x37, 0x38, 0x33, 0x63, 0x36, 0x32, 0x61, 0x38, 0x35, 0x65, 0x36, 0x63, 0x30, 0x66, 0x65, 0x37, 0x36, 0x36, 0x66, 0x31, 0x30, 0x64, 0x32, 0x35, 0x34, 0x31, 0x66, 0x34, 0x38, 0x38, 0x36, 0x62, 0x36, 0x35, 0x36, 0x35, 0x36, 0x64, 0x38, 0x61, 0x33, 0x32, 0x65, 0x39, 0x32, 0x37, 0x37, 0x38, 0x33, 0x38, 0x39, 0x36, 0x35, 0x37, 0x37, 0x62, 0x61, 0x34, 0x31, 0x65, 0x30, 0x33, 0x34, 0x36, 0x34, 0x64, 0x35, 0x61, 0x34, 0x35, 0x64, 0x33, 0x38, 0x39, 0x36, 0x64, 0x65, 0x31, 0x38, 0x34, 0x64, 0x33, 0x34, 0x65, 0x61, 0x33, 0x39, 0x35, 0x38, 0x33, 0x61, 0x31, 0x62, 0x36, 0x37, 0x62, 0x65, 0x33, 0x30, 0x33, 0x38, 0x62, 0x33, 0x38, 0x63, 0x34, 0x32, 0x65, 0x61, 0x61, 0x33, 0x62, 0x66, 0x37, 0x37, 0x64, 0x34, 0x30, 0x66, 0x33, 0x62, 0x32, 0x31, 0x32, 0x37, 0x37, 0x36, 0x35, 0x31, 0x36, 0x37, 0x32, 0x30, 0x33, 0x39, 0x35, 0x36, 0x61, 0x30, 0x36, 0x32, 0x39, 0x31, 0x36, 0x33, 0x38, 0x61, 0x30, 0x34, 0x33, 0x37, 0x39, 0x61, 0x32, 0x37, 0x32, 0x63, 0x34, 0x37, 0x36, 0x66, 0x35, 0x37, 0x34, 0x61, 0x39, 0x61, 0x64, 0x30, 0x61, 0x32, 0x39, 0x61, 0x66, 0x35, 0x31, 0x38, 0x65, 0x31, 0x36, 0x35, 0x36, 0x36, 0x36, 0x33, 0x38, 0x31, 0x64, 0x63, 0x35, 0x30, 0x33, 0x30, 0x32, 0x32, 0x38, 0x31, 0x38, 0x30, 0x66, 0x38, 0x36, 0x30, 0x38, 0x32, 0x61, 0x36, 0x30, 0x63, 0x33, 0x38, 0x61, 0x65, 0x61, 0x34, 0x61, 0x35, 0x30, 0x36, 0x33, 0x38, 0x34, 0x64, 0x62, 0x33, 0x34, 0x33, 0x35, 0x33, 0x33, 0x66, 0x32, 0x66, 0x30, 0x31, 0x35, 0x66, 0x31, 0x33, 0x34, 0x37, 0x32, 0x35, 0x63, 0x64, 0x36, 0x66, 0x62, 0x38, 0x37, 0x38, 0x62, 0x32, 0x33, 0x66, 0x38, 0x66, 0x38, 0x30, 0x35, 0x66, 0x37, 0x65, 0x36, 0x36, 0x62, 0x36, 0x61, 0x35, 0x36, 0x33, 0x62, 0x35, 0x32, 0x38, 0x64, 0x61, 0x36, 0x66, 0x31, 0x33, 0x63, 0x62, 0x63, 0x35, 0x32, 0x30, 0x33, 0x32, 0x63, 0x64, 0x33, 0x30, 0x63, 0x62, 0x32, 0x62, 0x65, 0x34, 0x66, 0x37, 0x37, 0x65, 0x61, 0x62, 0x35, 0x63, 0x65, 0x35, 0x39, 0x30, 0x33, 0x66, 0x36, 0x34, 0x33, 0x34, 0x39, 0x66, 0x61, 0x32, 0x33, 0x37, 0x32, 0x39, 0x35, 0x63, 0x64, 0x34, 0x33, 0x66, 0x64, 0x62, 0x37, 0x35, 0x63, 0x66, 0x37, 0x63, 0x36, 0x63, 0x30, 0x38, 0x37, 0x61, 0x66, 0x31, 0x62, 0x66, 0x31, 0x30, 0x30, 0x39, 0x39, 0x33, 0x31, 0x33, 0x36, 0x33, 0x62, 0x37, 0x66, 0x36, 0x65, 0x34, 0x34, 0x36, 0x33, 0x37, 0x37, 0x35, 0x33, 0x64, 0x62, 0x36, 0x31, 0x64, 0x61, 0x66, 0x36, 0x66, 0x65, 0x32, 0x64, 0x38, 0x61, 0x34, 0x65, 0x38, 0x39, 0x35, 0x62, 0x33, 0x33, 0x31, 0x31, 0x33, 0x61, 0x34, 0x37, 0x65, 0x36, 0x63, 0x37, 0x32, 0x64, 0x33, 0x33, 0x61, 0x39, 0x30, 0x39, 0x31, 0x64, 0x65, 0x35, 0x38, 0x64, 0x35, 0x37, 0x61, 0x65, 0x66, 0x66, 0x33, 0x65, 0x32, 0x65, 0x66, 0x39, 0x61, 0x39, 0x65, 0x61, 0x65, 0x38, 0x31, 0x65, 0x61, 0x39, 0x64, 0x38, 0x62, 0x32, 0x63, 0x31, 0x37, 0x61, 0x35, 0x37, 0x31, 0x66, 0x34, 0x62, 0x31, 0x30, 0x35, 0x37, 0x39, 0x37, 0x63, 0x30, 0x61, 0x33, 0x35, 0x32, 0x39, 0x36, 0x31, 0x34, 0x31, 0x35, 0x61, 0x39, 0x61, 0x61, 0x34, 0x35, 0x37, 0x37, 0x36, 0x31, 0x63, 0x38, 0x66, 0x61, 0x39, 0x30, 0x39, 0x37, 0x66, 0x33, 0x37, 0x34, 0x37, 0x65, 0x39, 0x32, 0x35, 0x39, 0x65, 0x33, 0x39, 0x38, 0x63, 0x63, 0x34, 0x61, 0x31, 0x65, 0x31, 0x62, 0x66, 0x32, 0x37, 0x32, 0x63, 0x33, 0x61, 0x66, 0x38, 0x66, 0x39, 0x63, 0x36, 0x37, 0x65, 0x34, 0x39, 0x34, 0x33, 0x62, 0x36, 0x36, 0x64, 0x64, 0x64, 0x32, 0x36, 0x63, 0x32, 0x35, 0x62, 0x34, 0x30, 0x61, 0x38, 0x30, 0x66, 0x30, 0x63, 0x34, 0x38, 0x34, 0x62, 0x64, 0x31, 0x37, 0x32, 0x34, 0x39, 0x34, 0x37, 0x37, 0x34, 0x31, 0x61, 0x64, 0x61, 0x39, 0x36, 0x61, 0x38, 0x36, 0x63, 0x63, 0x31, 0x66, 0x37, 0x32, 0x30, 0x66, 0x62, 0x38, 0x34, 0x34, 0x37, 0x39, 0x65, 0x38, 0x32, 0x33, 0x66, 0x65, 0x30, 0x61, 0x31, 0x62, 0x34, 0x65, 0x66, 0x31, 0x30, 0x30, 0x33, 0x33, 0x30, 0x66, 0x34, 0x35, 0x34, 0x37, 0x62, 0x35, 0x61, 0x35, 0x33, 0x61, 0x39, 0x64, 0x38, 0x34, 0x34, 0x34, 0x39, 0x61, 0x39, 0x63, 0x36, 0x31, 0x65, 0x63, 0x32, 0x35, 0x65, 0x63, 0x32, 0x61, 0x61, 0x34, 0x63, 0x61, 0x37, 0x32, 0x32, 0x31, 0x39, 0x37, 0x32, 0x62, 0x31, 0x32, 0x33, 0x65, 0x65, 0x32, 0x39, 0x39, 0x39, 0x31, 0x32, 0x31, 0x33, 0x37, 0x38, 0x66, 0x31, 0x63, 0x39, 0x32, 0x61, 0x35, 0x62, 0x33, 0x64, 0x62, 0x61, 0x66, 0x36, 0x61, 0x61, 0x66, 0x64, 0x35, 0x34, 0x39, 0x66, 0x32, 0x32, 0x65, 0x33, 0x65, 0x37, 0x66, 0x39, 0x65, 0x62, 0x61, 0x61, 0x62, 0x63, 0x66, 0x62, 0x37, 0x37, 0x66, 0x37, 0x32, 0x64, 0x35, 0x32, 0x32, 0x31, 0x64, 0x64, 0x32, 0x61, 0x32, 0x37, 0x39, 0x38, 0x63, 0x62, 0x36, 0x30, 0x62, 0x66, 0x37, 0x37, 0x37, 0x32, 0x65, 0x34, 0x31, 0x62, 0x35, 0x33, 0x31, 0x30, 0x64, 0x35, 0x31, 0x32, 0x36, 0x61, 0x32, 0x35, 0x30, 0x33, 0x30, 0x32, 0x32, 0x36, 0x63, 0x30, 0x34, 0x66, 0x36, 0x39, 0x65, 0x36, 0x35, 0x38, 0x39, 0x34, 0x37, 0x37, 0x37, 0x30, 0x39, 0x37, 0x32, 0x37, 0x31, 0x64, 0x34, 0x33, 0x65, 0x32, 0x64, 0x64, 0x31, 0x38, 0x61, 0x63, 0x31, 0x63, 0x34, 0x38, 0x64, 0x62, 0x39, 0x30, 0x66, 0x34, 0x65, 0x38, 0x34, 0x34, 0x66, 0x32, 0x31, 0x61, 0x64, 0x31, 0x37, 0x62, 0x65, 0x36, 0x36, 0x62, 0x39, 0x37, 0x65, 0x38, 0x61, 0x33, 0x39, 0x35, 0x66, 0x33, 0x38, 0x61, 0x31, 0x30, 0x30, 0x62, 0x61, 0x32, 0x66, 0x61, 0x66, 0x33, 0x35, 0x33, 0x66, 0x62, 0x35, 0x35, 0x61, 0x64, 0x36, 0x30, 0x63, 0x36, 0x62, 0x65, 0x33, 0x34, 0x34, 0x62, 0x30, 0x61, 0x62, 0x61, 0x38, 0x63, 0x33, 0x36, 0x39, 0x61, 0x62, 0x64, 0x62, 0x34, 0x64, 0x39, 0x61, 0x34, 0x63, 0x62, 0x37, 0x63, 0x65, 0x64, 0x66, 0x38, 0x33, 0x30, 0x36, 0x32, 0x33, 0x61, 0x32, 0x37, 0x39, 0x39, 0x62, 0x63, 0x66, 0x64, 0x61, 0x32, 0x34, 0x33, 0x35, 0x32, 0x35, 0x36, 0x66, 0x37, 0x66, 0x38, 0x66, 0x39, 0x36, 0x63, 0x33, 0x34, 0x62, 0x66, 0x66, 0x32, 0x38, 0x39, 0x31, 0x34, 0x39, 0x34, 0x37, 0x66, 0x39, 0x65, 0x65, 0x39, 0x61, 0x37, 0x39, 0x39, 0x62, 0x37, 0x38, 0x32, 0x34, 0x31, 0x32, 0x38, 0x32, 0x66, 0x32, 0x61, 0x66, 0x33, 0x61, 0x64, 0x31, 0x64, 0x32, 0x37, 0x33, 0x66, 0x65, 0x31, 0x65, 0x35, 0x63, 0x39, 0x37, 0x64, 0x31, 0x65, 0x34, 0x37, 0x32, 0x32, 0x62, 0x35, 0x36, 0x37, 0x65, 0x64, 0x31, 0x34, 0x32, 0x66, 0x33, 0x36, 0x37, 0x31, 0x33, 0x63, 0x33, 0x31, 0x32, 0x31, 0x30, 0x37, 0x39, 0x61, 0x66, 0x30, 0x66, 0x66, 0x38, 0x36, 0x38, 0x63, 0x32, 0x32, 0x66, 0x61, 0x33, 0x37, 0x65, 0x31, 0x37, 0x37, 0x64, 0x30, 0x30, 0x35, 0x64, 0x64, 0x31, 0x62, 0x36, 0x61, 0x63, 0x35, 0x36, 0x64, 0x63, 0x62, 0x39, 0x66, 0x33, 0x37, 0x32, 0x61, 0x32, 0x63, 0x62, 0x66, 0x32, 0x39, 0x35, 0x36, 0x64, 0x31, 0x37, 0x66, 0x37, 0x32, 0x32, 0x65, 0x61, 0x39, 0x30, 0x34, 0x30, 0x38, 0x35, 0x34, 0x61, 0x62, 0x39, 0x37, 0x31, 0x32, 0x33, 0x62, 0x63, 0x39, 0x32, 0x39, 0x31, 0x64, 0x31, 0x65, 0x65, 0x61, 0x64, 0x63, 0x64, 0x37, 0x61, 0x33, 0x32, 0x61, 0x37, 0x32, 0x63, 0x33, 0x63, 0x37, 0x39, 0x38, 0x38, 0x63, 0x64, 0x37, 0x32, 0x39, 0x62, 0x63, 0x31, 0x38, 0x35, 0x32, 0x31, 0x30, 0x62, 0x32, 0x36, 0x36, 0x35, 0x38, 0x61, 0x37, 0x65, 0x37, 0x31, 0x36, 0x39, 0x34, 0x35, 0x38, 0x64, 0x66, 0x64, 0x33, 0x66, 0x34, 0x66, 0x31, 0x64, 0x35, 0x35, 0x66, 0x33, 0x31, 0x35, 0x38, 0x64, 0x66, 0x38, 0x37, 0x34, 0x35, 0x36, 0x39, 0x33, 0x36, 0x38, 0x35, 0x66, 0x39, 0x31, 0x32, 0x61, 0x39, 0x63, 0x31, 0x63, 0x32, 0x66, 0x66, 0x34, 0x61, 0x38, 0x39, 0x64, 0x63, 0x39, 0x62, 0x35, 0x33, 0x63, 0x34, 0x66, 0x34, 0x32, 0x38, 0x66, 0x64, 0x31, 0x36, 0x66, 0x62, 0x65, 0x38, 0x62, 0x63, 0x63, 0x34, 0x32, 0x62, 0x38, 0x38, 0x66, 0x36, 0x31, 0x34, 0x30, 0x63, 0x32, 0x38, 0x36, 0x32, 0x64, 0x66, 0x63, 0x62, 0x63, 0x32, 0x35, 0x32, 0x63, 0x35, 0x30, 0x64, 0x62, 0x39, 0x38, 0x61, 0x35, 0x65, 0x38, 0x37, 0x32, 0x65, 0x36, 0x66, 0x39, 0x31, 0x36, 0x30, 0x62, 0x31, 0x38, 0x39, 0x65, 0x38, 0x36, 0x66, 0x34, 0x36, 0x64, 0x63, 0x64, 0x36, 0x63, 0x32, 0x34, 0x37, 0x63, 0x31, 0x64, 0x35, 0x31, 0x35, 0x33, 0x62, 0x35, 0x65, 0x39, 0x31, 0x61, 0x63, 0x39, 0x30, 0x34, 0x38, 0x37, 0x37, 0x64, 0x65, 0x63, 0x32, 0x30, 0x37, 0x35, 0x37, 0x37, 0x64, 0x66, 0x32, 0x38, 0x31, 0x62, 0x61, 0x30, 0x31, 0x63, 0x35, 0x34, 0x66, 0x37, 0x63, 0x66, 0x34, 0x35, 0x65, 0x34, 0x62, 0x32, 0x32, 0x34, 0x63, 0x38, 0x63, 0x30, 0x64, 0x32, 0x63, 0x62, 0x63, 0x64, 0x65, 0x33, 0x65, 0x31, 0x66, 0x62, 0x37, 0x62, 0x32, 0x33, 0x65, 0x38, 0x39, 0x61, 0x35, 0x33, 0x62, 0x63, 0x31, 0x61, 0x64, 0x34, 0x66, 0x37, 0x66, 0x32, 0x32, 0x35, 0x65, 0x62, 0x30, 0x32, 0x35, 0x31, 0x65, 0x65, 0x65, 0x31, 0x32, 0x63, 0x63, 0x30, 0x31, 0x64, 0x65, 0x31, 0x35, 0x31, 0x61, 0x62, 0x32, 0x31, 0x62, 0x62, 0x30, 0x33, 0x62, 0x66, 0x34, 0x35, 0x30, 0x66, 0x66, 0x30, 0x31, 0x62, 0x38, 0x62, 0x33, 0x63, 0x32, 0x32, 0x34, 0x30, 0x33, 0x61, 0x37, 0x36, 0x30, 0x64, 0x31, 0x66, 0x31, 0x39, 0x32, 0x61, 0x32, 0x33, 0x31, 0x61, 0x31, 0x31, 0x39, 0x38, 0x62, 0x36, 0x31, 0x30, 0x31, 0x35, 0x35, 0x36, 0x36, 0x38, 0x61, 0x62, 0x37, 0x33, 0x31, 0x37, 0x62, 0x34, 0x63, 0x34, 0x34, 0x37, 0x39, 0x31, 0x30, 0x31, 0x33, 0x63, 0x62, 0x38, 0x32, 0x37, 0x64, 0x63, 0x35, 0x35, 0x34, 0x39, 0x65, 0x33, 0x37, 0x33, 0x35, 0x63, 0x64, 0x33, 0x65, 0x32, 0x62, 0x65, 0x63, 0x37, 0x64, 0x32, 0x66, 0x65, 0x39, 0x61, 0x35, 0x65, 0x66, 0x61, 0x34, 0x34, 0x34, 0x35, 0x61, 0x32, 0x64, 0x64, 0x36, 0x66, 0x32, 0x61, 0x35, 0x61, 0x63, 0x38, 0x63, 0x32, 0x35, 0x66, 0x34, 0x32, 0x37, 0x65, 0x36, 0x34, 0x32, 0x36, 0x32, 0x34, 0x39, 0x61, 0x65, 0x37, 0x33, 0x37, 0x34, 0x31, 0x32, 0x35, 0x65, 0x37, 0x34, 0x38, 0x37, 0x33, 0x38, 0x36, 0x31, 0x35, 0x35, 0x30, 0x39, 0x35, 0x34, 0x61, 0x38, 0x33, 0x38, 0x36, 0x38, 0x37, 0x61, 0x35, 0x32, 0x63, 0x61, 0x34, 0x34, 0x37, 0x37, 0x32, 0x34, 0x65, 0x37, 0x32, 0x62, 0x65, 0x62, 0x34, 0x66, 0x37, 0x33, 0x35, 0x37, 0x66, 0x34, 0x35, 0x35, 0x66, 0x61, 0x32, 0x62, 0x35, 0x32, 0x31, 0x61, 0x63, 0x32, 0x37, 0x32, 0x33, 0x30, 0x38, 0x35, 0x36, 0x32, 0x34, 0x38, 0x39, 0x63, 0x37, 0x64, 0x32, 0x63, 0x30, 0x65, 0x33, 0x62, 0x61, 0x32, 0x36, 0x36, 0x32, 0x64, 0x34, 0x36, 0x38, 0x61, 0x66, 0x30, 0x61, 0x64, 0x36, 0x61, 0x39, 0x31, 0x33, 0x37, 0x32, 0x31, 0x39, 0x63, 0x61, 0x33, 0x33, 0x30, 0x35, 0x31, 0x31, 0x62, 0x30, 0x35, 0x34, 0x30, 0x65, 0x33, 0x63, 0x33, 0x64, 0x30, 0x31, 0x64, 0x39, 0x65, 0x32, 0x30, 0x36, 0x34, 0x39, 0x33, 0x34, 0x66, 0x35, 0x66, 0x32, 0x35, 0x33, 0x30, 0x34, 0x36, 0x61, 0x32, 0x63, 0x63, 0x37, 0x62, 0x31, 0x63, 0x65, 0x37, 0x66, 0x38, 0x36, 0x63, 0x37, 0x32, 0x37, 0x66, 0x62, 0x35, 0x63, 0x35, 0x65, 0x38, 0x38, 0x32, 0x39, 0x63, 0x64, 0x30, 0x36, 0x63, 0x63, 0x39, 0x33, 0x37, 0x63, 0x34, 0x33, 0x63, 0x33, 0x37, 0x31, 0x36, 0x37, 0x32, 0x34, 0x33, 0x34, 0x65, 0x30, 0x66, 0x33, 0x35, 0x33, 0x65, 0x30, 0x62, 0x63, 0x36, 0x38, 0x38, 0x66, 0x65, 0x33, 0x61, 0x35, 0x63, 0x32, 0x39, 0x38, 0x65, 0x66, 0x36, 0x39, 0x30, 0x35, 0x36, 0x36, 0x30, 0x31, 0x31, 0x39, 0x37, 0x39, 0x37, 0x32, 0x37, 0x31, 0x64, 0x61, 0x36, 0x63, 0x66, 0x65, 0x39, 0x30, 0x62, 0x66, 0x66, 0x64, 0x38, 0x64, 0x32, 0x37, 0x37, 0x30, 0x33, 0x63, 0x33, 0x39, 0x61, 0x38, 0x35, 0x37, 0x31, 0x38, 0x63, 0x34, 0x39, 0x62, 0x65, 0x30, 0x33, 0x31, 0x31, 0x65, 0x37, 0x38, 0x39, 0x61, 0x32, 0x30, 0x32, 0x62, 0x61, 0x64, 0x63, 0x32, 0x32, 0x39, 0x31, 0x39, 0x37, 0x34, 0x65, 0x33, 0x33, 0x62, 0x30, 0x32, 0x38, 0x64, 0x35, 0x33, 0x39, 0x65, 0x63, 0x64, 0x36, 0x63, 0x34, 0x33, 0x34, 0x37, 0x63, 0x62, 0x38, 0x37, 0x62, 0x39, 0x36, 0x38, 0x64, 0x33, 0x33, 0x33, 0x36, 0x35, 0x37, 0x32, 0x39, 0x66, 0x63, 0x32, 0x39, 0x64, 0x39, 0x36, 0x61, 0x32, 0x66, 0x61, 0x38, 0x39, 0x32, 0x65, 0x63, 0x33, 0x38, 0x34, 0x31, 0x33, 0x38, 0x32, 0x64, 0x38, 0x31, 0x37, 0x30, 0x36, 0x35, 0x63, 0x35, 0x38, 0x34, 0x38, 0x37, 0x33, 0x64, 0x64, 0x35, 0x36, 0x62, 0x62, 0x65, 0x66, 0x33, 0x62, 0x62, 0x32, 0x66, 0x61, 0x61, 0x36, 0x33, 0x32, 0x63, 0x34, 0x62, 0x35, 0x33, 0x31, 0x32, 0x37, 0x61, 0x36, 0x30, 0x65, 0x66, 0x32, 0x31, 0x33, 0x61, 0x65, 0x34, 0x65, 0x35, 0x61, 0x65, 0x34, 0x62, 0x36, 0x35, 0x61, 0x63, 0x33, 0x64, 0x66, 0x31, 0x36, 0x33, 0x30, 0x35, 0x34, 0x36, 0x38, 0x35, 0x65, 0x36, 0x33, 0x65, 0x65, 0x63, 0x36, 0x34, 0x64, 0x33, 0x30, 0x36, 0x32, 0x65, 0x38, 0x37, 0x66, 0x39, 0x61, 0x35, 0x62, 0x38, 0x30, 0x31, 0x33, 0x33, 0x31, 0x38, 0x39, 0x36, 0x61, 0x61, 0x36, 0x62, 0x30, 0x35, 0x34, 0x61, 0x39, 0x66, 0x33, 0x66, 0x37, 0x30, 0x63, 0x38, 0x65, 0x61, 0x30, 0x31, 0x34, 0x30, 0x32, 0x34, 0x34, 0x36, 0x39, 0x61, 0x64, 0x35, 0x39, 0x63, 0x39, 0x37, 0x32, 0x33, 0x36, 0x30, 0x37, 0x30, 0x34, 0x34, 0x39, 0x36, 0x35, 0x64, 0x32, 0x65, 0x33, 0x66, 0x37, 0x33, 0x33, 0x66, 0x38, 0x64, 0x61, 0x66, 0x37, 0x37, 0x39, 0x66, 0x31, 0x33, 0x34, 0x61, 0x30, 0x66, 0x38, 0x37, 0x34, 0x39, 0x36, 0x36, 0x65, 0x32, 0x34, 0x39, 0x36, 0x39, 0x36, 0x61, 0x38, 0x36, 0x39, 0x39, 0x38, 0x37, 0x64, 0x33, 0x62, 0x65, 0x32, 0x31, 0x63, 0x34, 0x33, 0x37, 0x32, 0x32, 0x63, 0x38, 0x37, 0x38, 0x36, 0x63, 0x35, 0x36, 0x65, 0x65, 0x61, 0x31, 0x66, 0x64, 0x66, 0x33, 0x36, 0x61, 0x63, 0x35, 0x33, 0x65, 0x63, 0x35, 0x62, 0x32, 0x37, 0x36, 0x64, 0x63, 0x33, 0x63, 0x37, 0x66, 0x38, 0x35, 0x65, 0x39, 0x61, 0x66, 0x37, 0x34, 0x37, 0x61, 0x63, 0x62, 0x62, 0x34, 0x30, 0x38, 0x64, 0x37, 0x33, 0x37, 0x35, 0x61, 0x33, 0x30, 0x32, 0x62, 0x33, 0x34, 0x33, 0x66, 0x32, 0x34, 0x65, 0x66, 0x36, 0x30, 0x63, 0x66, 0x37, 0x31, 0x61, 0x38, 0x33, 0x30, 0x65, 0x38, 0x33, 0x38, 0x37, 0x64, 0x33, 0x32, 0x34, 0x36, 0x66, 0x61, 0x33, 0x61, 0x37, 0x34, 0x32, 0x38, 0x38, 0x33, 0x61, 0x31, 0x64, 0x39, 0x62, 0x39, 0x66, 0x36, 0x65, 0x34, 0x38, 0x64, 0x66, 0x66, 0x65, 0x36, 0x31, 0x38, 0x64, 0x33, 0x63, 0x63, 0x38, 0x32, 0x31, 0x36, 0x39, 0x32, 0x39, 0x62, 0x31, 0x63, 0x35, 0x32, 0x61, 0x33, 0x32, 0x65, 0x31, 0x30, 0x39, 0x33, 0x33, 0x33, 0x63, 0x30, 0x37, 0x66, 0x64, 0x61, 0x31, 0x36, 0x64, 0x31, 0x31, 0x36, 0x39, 0x63, 0x61, 0x38, 0x64, 0x65, 0x38, 0x66, 0x31, 0x36, 0x37, 0x33, 0x66, 0x65, 0x38, 0x64, 0x64, 0x31, 0x36, 0x31, 0x32, 0x63, 0x65, 0x63, 0x37, 0x31, 0x61, 0x34, 0x64, 0x30, 0x35, 0x31, 0x30, 0x66, 0x35, 0x36, 0x33, 0x32, 0x36, 0x64, 0x32, 0x64, 0x65, 0x65, 0x62, 0x62, 0x31, 0x38, 0x65, 0x61, 0x64, 0x32, 0x36, 0x37, 0x31, 0x32, 0x66, 0x39, 0x37, 0x35, 0x66, 0x65, 0x62, 0x64, 0x32, 0x33, 0x61, 0x34, 0x35, 0x36, 0x39, 0x30, 0x35, 0x66, 0x30, 0x39, 0x62, 0x39, 0x31, 0x37, 0x62, 0x66, 0x37, 0x38, 0x34, 0x31, 0x61, 0x64, 0x37, 0x32, 0x61, 0x63, 0x30, 0x66, 0x33, 0x36, 0x61, 0x66, 0x33, 0x30, 0x66, 0x66, 0x31, 0x66, 0x62, 0x31, 0x65, 0x30, 0x63, 0x62, 0x61, 0x62, 0x65, 0x30, 0x31, 0x38, 0x61, 0x33, 0x33, 0x34, 0x36, 0x62, 0x34, 0x36, 0x35, 0x31, 0x33, 0x39, 0x30, 0x30, 0x30, 0x32, 0x31, 0x32, 0x33, 0x30, 0x62, 0x37, 0x37, 0x38, 0x33, 0x62, 0x36, 0x65, 0x33, 0x37, 0x65, 0x31, 0x65, 0x64, 0x63, 0x63, 0x35, 0x35, 0x65, 0x32, 0x30, 0x37, 0x38, 0x32, 0x30, 0x65, 0x38, 0x34, 0x33, 0x38, 0x31, 0x33, 0x62, 0x37, 0x66, 0x30, 0x62, 0x64, 0x35, 0x31, 0x65, 0x35, 0x31, 0x33, 0x35, 0x39, 0x37, 0x39, 0x39, 0x35, 0x66, 0x30, 0x33, 0x62, 0x34, 0x35, 0x38, 0x38, 0x34, 0x38, 0x38, 0x36, 0x66, 0x65, 0x36, 0x30, 0x66, 0x61, 0x38, 0x65, 0x63, 0x39, 0x32, 0x34, 0x65, 0x38, 0x31, 0x34, 0x34, 0x64, 0x64, 0x36, 0x61, 0x36, 0x30, 0x63, 0x34, 0x37, 0x36, 0x66, 0x66, 0x30, 0x63, 0x30, 0x61, 0x30, 0x39, 0x37, 0x38, 0x31, 0x37, 0x38, 0x33, 0x61, 0x62, 0x35, 0x65, 0x35, 0x32, 0x32, 0x32, 0x38, 0x33, 0x30, 0x37, 0x37, 0x63, 0x63, 0x35, 0x38, 0x39, 0x38, 0x31, 0x64, 0x35, 0x33, 0x31, 0x35, 0x66, 0x33, 0x64, 0x33, 0x66, 0x35, 0x33, 0x38, 0x64, 0x35, 0x32, 0x31, 0x32, 0x39, 0x36, 0x61, 0x35, 0x35, 0x64, 0x36, 0x65, 0x32, 0x32, 0x61, 0x38, 0x63, 0x63, 0x37, 0x32, 0x64, 0x34, 0x33, 0x37, 0x65, 0x31, 0x61, 0x39, 0x66, 0x35, 0x66, 0x64, 0x31, 0x62, 0x66, 0x30, 0x35, 0x34, 0x33, 0x31, 0x33, 0x62, 0x65, 0x65, 0x35, 0x32, 0x34, 0x63, 0x32, 0x62, 0x34, 0x36, 0x65, 0x38, 0x38, 0x34, 0x66, 0x64, 0x39, 0x64, 0x62, 0x37, 0x37, 0x66, 0x64, 0x63, 0x30, 0x30, 0x34, 0x61, 0x36, 0x38, 0x30, 0x39, 0x32, 0x33, 0x34, 0x34, 0x62, 0x34, 0x32, 0x35, 0x33, 0x31, 0x64, 0x63, 0x65, 0x36, 0x64, 0x32, 0x63, 0x62, 0x38, 0x65, 0x33, 0x36, 0x64, 0x37, 0x36, 0x30, 0x63, 0x38, 0x39, 0x34, 0x32, 0x65, 0x62, 0x65, 0x61, 0x34, 0x66, 0x39, 0x30, 0x32, 0x63, 0x64, 0x61, 0x31, 0x30, 0x37, 0x39, 0x62, 0x65, 0x63, 0x34, 0x38, 0x66, 0x61, 0x36, 0x35, 0x62, 0x33, 0x61, 0x66, 0x62, 0x30, 0x31, 0x39, 0x61, 0x35, 0x66, 0x30, 0x34, 0x37, 0x37, 0x35, 0x35, 0x64, 0x33, 0x61, 0x33, 0x30, 0x61, 0x38, 0x30, 0x38, 0x61, 0x34, 0x61, 0x66, 0x31, 0x37, 0x33, 0x65, 0x65, 0x65, 0x61, 0x65, 0x38, 0x63, 0x34, 0x62, 0x34, 0x63, 0x30, 0x35, 0x38, 0x34, 0x38, 0x64, 0x64, 0x63, 0x30, 0x33, 0x37, 0x33, 0x63, 0x36, 0x30, 0x35, 0x63, 0x38, 0x37, 0x37, 0x37, 0x65, 0x61, 0x38, 0x36, 0x63, 0x34, 0x64, 0x62, 0x34, 0x65, 0x32, 0x63, 0x36, 0x36, 0x31, 0x37, 0x32, 0x35, 0x39, 0x62, 0x66, 0x61, 0x30, 0x65, 0x31, 0x65, 0x34, 0x33, 0x36, 0x32, 0x39, 0x31, 0x66, 0x30, 0x33, 0x38, 0x38, 0x61, 0x66, 0x31, 0x63, 0x35, 0x64, 0x66, 0x35, 0x31, 0x62, 0x35, 0x38, 0x35, 0x64, 0x63, 0x62, 0x39, 0x61, 0x64, 0x61, 0x36, 0x33, 0x62, 0x37, 0x37, 0x39, 0x39, 0x30, 0x35, 0x65, 0x63, 0x36, 0x38, 0x35, 0x34, 0x63, 0x63, 0x33, 0x37, 0x62, 0x37, 0x63, 0x37, 0x32, 0x38, 0x35, 0x66, 0x63, 0x66, 0x66, 0x65, 0x66, 0x34, 0x35, 0x39, 0x63, 0x61, 0x61, 0x65, 0x61, 0x65, 0x38, 0x31, 0x62, 0x35, 0x36, 0x32, 0x66, 0x39, 0x63, 0x65, 0x38, 0x39, 0x34, 0x38, 0x32, 0x37, 0x39, 0x64, 0x34, 0x31, 0x66, 0x63, 0x64, 0x37, 0x39, 0x35, 0x34, 0x31, 0x61, 0x61, 0x37, 0x61, 0x65, 0x37, 0x64, 0x62, 0x66, 0x35, 0x31, 0x38, 0x31, 0x30, 0x63, 0x38, 0x64, 0x37, 0x32, 0x30, 0x65, 0x33, 0x62, 0x31, 0x64, 0x64, 0x31, 0x31, 0x39, 0x32, 0x30, 0x62, 0x32, 0x36, 0x39, 0x62, 0x30, 0x63, 0x61, 0x66, 0x33, 0x35, 0x36, 0x66, 0x39, 0x61, 0x30, 0x32, 0x30, 0x65, 0x30, 0x37, 0x65, 0x38, 0x63, 0x63, 0x35, 0x66, 0x34, 0x36, 0x62, 0x65, 0x66, 0x66, 0x30, 0x64, 0x35, 0x62, 0x65, 0x35, 0x62, 0x33, 0x62, 0x35, 0x38, 0x32, 0x61, 0x35, 0x33, 0x37, 0x37, 0x37, 0x32, 0x61, 0x34, 0x61, 0x34, 0x30, 0x39, 0x38, 0x35, 0x31, 0x34, 0x61, 0x65, 0x32, 0x33, 0x65, 0x66, 0x66, 0x39, 0x65, 0x31, 0x33, 0x32, 0x39, 0x31, 0x63, 0x64, 0x37, 0x33, 0x30, 0x34, 0x37, 0x64, 0x62, 0x39, 0x65, 0x33, 0x34, 0x30, 0x36, 0x65, 0x62, 0x65, 0x30, 0x34, 0x64, 0x37, 0x37, 0x61, 0x64, 0x33, 0x66, 0x33, 0x62, 0x32, 0x64, 0x31, 0x35, 0x38, 0x32, 0x35, 0x33, 0x37, 0x34, 0x31, 0x65, 0x65, 0x34, 0x38, 0x33, 0x30, 0x38, 0x64, 0x65, 0x31, 0x34, 0x62, 0x36, 0x64, 0x34, 0x39, 0x33, 0x36, 0x62, 0x36, 0x66, 0x30, 0x62, 0x32, 0x34, 0x62, 0x30, 0x65, 0x37, 0x63, 0x33, 0x36, 0x62, 0x34, 0x37, 0x30, 0x63, 0x63, 0x32, 0x66, 0x61, 0x63, 0x63, 0x65, 0x61, 0x37, 0x64, 0x34, 0x38, 0x30, 0x35, 0x33, 0x61, 0x33, 0x35, 0x33, 0x33, 0x34, 0x36, 0x33, 0x34, 0x38, 0x37, 0x32, 0x34, 0x31, 0x32, 0x65, 0x30, 0x36, 0x37, 0x32, 0x30, 0x66, 0x37, 0x36, 0x64, 0x38, 0x36, 0x33, 0x32, 0x34, 0x62, 0x64, 0x63, 0x30, 0x66, 0x37, 0x65, 0x66, 0x31, 0x32, 0x34, 0x36, 0x34, 0x37, 0x37, 0x64, 0x36, 0x31, 0x63, 0x65, 0x31, 0x34, 0x34, 0x39, 0x66, 0x61, 0x38, 0x32, 0x31, 0x66, 0x33, 0x39, 0x61, 0x38, 0x36, 0x65, 0x33, 0x61, 0x30, 0x30, 0x36, 0x66, 0x35, 0x61, 0x37, 0x32, 0x65, 0x64, 0x34, 0x33, 0x32, 0x30, 0x62, 0x30, 0x66, 0x31, 0x65, 0x63, 0x65, 0x35, 0x64, 0x30, 0x34, 0x34, 0x34, 0x66, 0x65, 0x61, 0x63, 0x62, 0x64, 0x30, 0x36, 0x64, 0x65, 0x35, 0x35, 0x64, 0x32, 0x33, 0x65, 0x65, 0x39, 0x36, 0x33, 0x36, 0x64, 0x35, 0x37, 0x37, 0x34, 0x61, 0x62, 0x32, 0x62, 0x61, 0x63, 0x66, 0x32, 0x39, 0x35, 0x37, 0x35, 0x32, 0x62, 0x37, 0x39, 0x34, 0x33, 0x38, 0x38, 0x34, 0x62, 0x35, 0x33, 0x31, 0x35, 0x39, 0x39, 0x37, 0x32, 0x30, 0x65, 0x33, 0x66, 0x32, 0x65, 0x66, 0x39, 0x39, 0x39, 0x31, 0x39, 0x61, 0x34, 0x34, 0x62, 0x31, 0x33, 0x62, 0x62, 0x33, 0x38, 0x63, 0x32, 0x37, 0x37, 0x37, 0x37, 0x31, 0x64, 0x62, 0x37, 0x35, 0x35, 0x38, 0x32, 0x66, 0x61, 0x66, 0x65, 0x36, 0x36, 0x39, 0x31, 0x61, 0x66, 0x32, 0x31, 0x32, 0x36, 0x38, 0x37, 0x32, 0x65, 0x32, 0x34, 0x63, 0x62, 0x39, 0x38, 0x65, 0x30, 0x65, 0x33, 0x62, 0x62, 0x32, 0x36, 0x33, 0x32, 0x61, 0x39, 0x63, 0x31, 0x32, 0x36, 0x65, 0x37, 0x64, 0x38, 0x34, 0x65, 0x66, 0x30, 0x66, 0x66, 0x62, 0x35, 0x33, 0x30, 0x63, 0x64, 0x30, 0x39, 0x63, 0x36, 0x65, 0x65, 0x62, 0x34, 0x31, 0x39, 0x32, 0x65, 0x61, 0x65, 0x61, 0x39, 0x61, 0x37, 0x37, 0x37, 0x65, 0x65, 0x65, 0x34, 0x37, 0x36, 0x65, 0x65, 0x36, 0x66, 0x32, 0x62, 0x63, 0x63, 0x64, 0x63, 0x39, 0x39, 0x65, 0x31, 0x39, 0x64, 0x64, 0x34, 0x62, 0x31, 0x38, 0x30, 0x66, 0x32, 0x38, 0x61, 0x39, 0x38, 0x36, 0x38, 0x34, 0x65, 0x34, 0x35, 0x35, 0x61, 0x30, 0x63, 0x38, 0x31, 0x62, 0x31, 0x31, 0x31, 0x33, 0x63, 0x65, 0x35, 0x36, 0x30, 0x65, 0x62, 0x38, 0x33, 0x62, 0x30, 0x32, 0x62, 0x62, 0x33, 0x30, 0x33, 0x30, 0x37, 0x39, 0x34, 0x63, 0x33, 0x32, 0x36, 0x61, 0x63, 0x61, 0x65, 0x30, 0x65, 0x62, 0x65, 0x31, 0x35, 0x35, 0x38, 0x37, 0x61, 0x64, 0x63, 0x61, 0x66, 0x61, 0x34, 0x64, 0x36, 0x65, 0x64, 0x32, 0x37, 0x34, 0x37, 0x38, 0x35, 0x33, 0x30, 0x61, 0x37, 0x65, 0x62, 0x66, 0x30, 0x33, 0x64, 0x30, 0x35, 0x39, 0x34, 0x37, 0x63, 0x35, 0x33, 0x30, 0x39, 0x65, 0x39, 0x65, 0x32, 0x36, 0x36, 0x63, 0x31, 0x39, 0x34, 0x33, 0x63, 0x33, 0x30, 0x33, 0x37, 0x38, 0x30, 0x39, 0x35, 0x35, 0x30, 0x35, 0x30, 0x39, 0x30, 0x32, 0x61, 0x39, 0x38, 0x33, 0x33, 0x31, 0x30, 0x36, 0x36, 0x63, 0x61, 0x31, 0x36, 0x37, 0x36, 0x64, 0x65, 0x61, 0x66, 0x34, 0x33, 0x36, 0x64, 0x38, 0x61, 0x65, 0x30, 0x61, 0x62, 0x36, 0x63, 0x64, 0x63, 0x66, 0x38, 0x62, 0x34, 0x38, 0x38, 0x32, 0x61, 0x39, 0x37, 0x32, 0x35, 0x63, 0x38, 0x62, 0x33, 0x34, 0x62, 0x33, 0x37, 0x64, 0x62, 0x63, 0x30, 0x36, 0x32, 0x63, 0x66, 0x63, 0x35, 0x38, 0x30, 0x30, 0x30, 0x37, 0x65, 0x65, 0x64, 0x35, 0x39, 0x37, 0x39, 0x33, 0x66, 0x30, 0x31, 0x31, 0x61, 0x66, 0x30, 0x38, 0x37, 0x30, 0x39, 0x33, 0x39, 0x35, 0x61, 0x35, 0x61, 0x39, 0x62, 0x66, 0x34, 0x31, 0x61, 0x38, 0x62, 0x61, 0x63, 0x36, 0x36, 0x38, 0x31, 0x39, 0x39, 0x36, 0x31, 0x61, 0x36, 0x37, 0x39, 0x30, 0x64, 0x31, 0x30, 0x37, 0x36, 0x61, 0x63, 0x30, 0x63, 0x37, 0x61, 0x37, 0x36, 0x66, 0x66, 0x39, 0x35, 0x62, 0x62, 0x33, 0x66, 0x39, 0x31, 0x34, 0x62, 0x33, 0x34, 0x31, 0x64, 0x62, 0x30, 0x63, 0x61, 0x30, 0x62, 0x35, 0x32, 0x66, 0x38, 0x32, 0x34, 0x63, 0x31, 0x32, 0x63, 0x64, 0x65, 0x31, 0x65, 0x65, 0x33, 0x66, 0x31, 0x36, 0x37, 0x32, 0x37, 0x62, 0x65, 0x34, 0x37, 0x62, 0x62, 0x39, 0x62, 0x39, 0x30, 0x66, 0x61, 0x65, 0x37, 0x65, 0x35, 0x34, 0x36, 0x33, 0x66, 0x33, 0x61, 0x65, 0x66, 0x39, 0x61, 0x33, 0x32, 0x39, 0x61, 0x34, 0x35, 0x32, 0x39, 0x36, 0x33, 0x37, 0x66, 0x61, 0x63, 0x62, 0x37, 0x62, 0x30, 0x33, 0x37, 0x63, 0x36, 0x65, 0x33, 0x31, 0x32, 0x37, 0x35, 0x63, 0x35, 0x37, 0x64, 0x65, 0x32, 0x30, 0x37, 0x32, 0x62, 0x31, 0x39, 0x64, 0x33, 0x37, 0x64, 0x35, 0x64, 0x33, 0x35, 0x33, 0x33, 0x35, 0x36, 0x62, 0x32, 0x33, 0x37, 0x37, 0x32, 0x35, 0x34, 0x62, 0x61, 0x33, 0x65, 0x32, 0x33, 0x38, 0x62, 0x65, 0x35, 0x36, 0x62, 0x30, 0x38, 0x30, 0x36, 0x64, 0x62, 0x32, 0x66, 0x61, 0x31, 0x65, 0x30, 0x31, 0x63, 0x33, 0x64, 0x62, 0x62, 0x63, 0x64, 0x32, 0x66, 0x33, 0x33, 0x36, 0x30, 0x30, 0x37, 0x32, 0x31, 0x36, 0x61, 0x36, 0x31, 0x65, 0x30, 0x37, 0x35, 0x34, 0x65, 0x34, 0x64, 0x63, 0x61, 0x30, 0x64, 0x34, 0x31, 0x61, 0x36, 0x66, 0x36, 0x39, 0x39, 0x38, 0x38, 0x36, 0x37, 0x39, 0x63, 0x32, 0x63, 0x31, 0x35, 0x39, 0x63, 0x63, 0x38, 0x64, 0x31, 0x30, 0x32, 0x33, 0x31, 0x66, 0x33, 0x35, 0x64, 0x33, 0x65, 0x31, 0x33, 0x37, 0x62, 0x35, 0x64, 0x63, 0x62, 0x64, 0x38, 0x61, 0x37, 0x32, 0x61, 0x31, 0x62, 0x30, 0x39, 0x38, 0x39, 0x63, 0x34, 0x32, 0x39, 0x33, 0x61, 0x30, 0x30, 0x37, 0x33, 0x36, 0x38, 0x39, 0x30, 0x65, 0x39, 0x61, 0x30, 0x62, 0x37, 0x34, 0x38, 0x62, 0x65, 0x38, 0x38, 0x36, 0x38, 0x62, 0x34, 0x30, 0x63, 0x31, 0x65, 0x36, 0x39, 0x39, 0x36, 0x34, 0x61, 0x63, 0x65, 0x35, 0x30, 0x61, 0x37, 0x32, 0x63, 0x31, 0x32, 0x61, 0x64, 0x63, 0x61, 0x30, 0x37, 0x32, 0x39, 0x38, 0x34, 0x32, 0x66, 0x63, 0x35, 0x64, 0x62, 0x37, 0x63, 0x62, 0x65, 0x31, 0x34, 0x64, 0x64, 0x34, 0x39, 0x35, 0x62, 0x35, 0x66, 0x65, 0x39, 0x62, 0x39, 0x31, 0x37, 0x31, 0x37, 0x35, 0x32, 0x66, 0x34, 0x37, 0x61, 0x62, 0x64, 0x66, 0x35, 0x35, 0x66, 0x64, 0x30, 0x32, 0x66, 0x62, 0x63, 0x33, 0x63, 0x35, 0x36, 0x65, 0x35, 0x61, 0x31, 0x66, 0x38, 0x37, 0x30, 0x35, 0x37, 0x32, 0x30, 0x32, 0x61, 0x63, 0x65, 0x30, 0x34, 0x65, 0x37, 0x63, 0x33, 0x63, 0x34, 0x39, 0x62, 0x33, 0x61, 0x37, 0x37, 0x61, 0x63, 0x62, 0x36, 0x65, 0x61, 0x36, 0x34, 0x63, 0x64, 0x66, 0x64, 0x31, 0x62, 0x31, 0x34, 0x36, 0x62, 0x30, 0x65, 0x33, 0x33, 0x39, 0x36, 0x37, 0x62, 0x36, 0x31, 0x30, 0x36, 0x65, 0x64, 0x31, 0x61, 0x32, 0x35, 0x64, 0x31, 0x31, 0x37, 0x32, 0x30, 0x37, 0x37, 0x32, 0x34, 0x36, 0x32, 0x61, 0x38, 0x36, 0x62, 0x61, 0x36, 0x65, 0x35, 0x31, 0x32, 0x34, 0x65, 0x61, 0x64, 0x38, 0x31, 0x66, 0x33, 0x66, 0x39, 0x66, 0x33, 0x62, 0x61, 0x34, 0x63, 0x31, 0x30, 0x61, 0x66, 0x34, 0x66, 0x61, 0x64, 0x34, 0x30, 0x62, 0x36, 0x32, 0x37, 0x39, 0x39, 0x64, 0x65, 0x61, 0x61, 0x34, 0x38, 0x34, 0x62, 0x62, 0x37, 0x31, 0x34, 0x31, 0x63, 0x35, 0x32, 0x31, 0x36, 0x62, 0x38, 0x62, 0x62, 0x64, 0x63, 0x39, 0x36, 0x36, 0x64, 0x31, 0x63, 0x35, 0x61, 0x63, 0x61, 0x32, 0x35, 0x63, 0x64, 0x63, 0x66, 0x64, 0x64, 0x32, 0x64, 0x32, 0x36, 0x65, 0x37, 0x37, 0x33, 0x34, 0x62, 0x65, 0x61, 0x31, 0x64, 0x32, 0x34, 0x39, 0x63, 0x66, 0x62, 0x35, 0x36, 0x61, 0x65, 0x39, 0x63, 0x38, 0x38, 0x32, 0x33, 0x36, 0x36, 0x64, 0x64, 0x31, 0x33, 0x33, 0x61, 0x66, 0x37, 0x32, 0x31, 0x31, 0x64, 0x66, 0x37, 0x33, 0x38, 0x39, 0x36, 0x31, 0x64, 0x65, 0x34, 0x63, 0x64, 0x36, 0x39, 0x64, 0x62, 0x64, 0x31, 0x61, 0x38, 0x66, 0x34, 0x35, 0x39, 0x64, 0x36, 0x61, 0x62, 0x63, 0x65, 0x62, 0x66, 0x34, 0x31, 0x64, 0x32, 0x33, 0x61, 0x34, 0x32, 0x32, 0x36, 0x65, 0x65, 0x61, 0x34, 0x37, 0x31, 0x35, 0x30, 0x37, 0x34, 0x66, 0x64, 0x62, 0x35, 0x35, 0x35, 0x37, 0x37, 0x32, 0x62, 0x31, 0x35, 0x66, 0x62, 0x32, 0x34, 0x61, 0x38, 0x64, 0x31, 0x34, 0x34, 0x36, 0x62, 0x30, 0x38, 0x33, 0x32, 0x61, 0x34, 0x33, 0x33, 0x32, 0x37, 0x61, 0x32, 0x36, 0x30, 0x34, 0x35, 0x64, 0x34, 0x65, 0x39, 0x35, 0x38, 0x30, 0x35, 0x61, 0x61, 0x33, 0x38, 0x64, 0x37, 0x34, 0x35, 0x62, 0x30, 0x65, 0x61, 0x35, 0x31, 0x39, 0x63, 0x34, 0x36, 0x36, 0x35, 0x36, 0x35, 0x31, 0x30, 0x66, 0x31, 0x62, 0x32, 0x32, 0x37, 0x39, 0x63, 0x30, 0x31, 0x36, 0x63, 0x63, 0x38, 0x66, 0x61, 0x66, 0x30, 0x38, 0x65, 0x38, 0x34, 0x62, 0x65, 0x64, 0x38, 0x64, 0x64, 0x30, 0x66, 0x36, 0x63, 0x31, 0x36, 0x32, 0x33, 0x65, 0x35, 0x33, 0x66, 0x39, 0x66, 0x64, 0x32, 0x38, 0x34, 0x33, 0x39, 0x31, 0x65, 0x38, 0x34, 0x64, 0x65, 0x38, 0x65, 0x31, 0x34, 0x62, 0x64, 0x31, 0x62, 0x66, 0x33, 0x65, 0x30, 0x66, 0x34, 0x39, 0x30, 0x35, 0x34, 0x37, 0x66, 0x61, 0x34, 0x36, 0x31, 0x63, 0x65, 0x33, 0x34, 0x30, 0x61, 0x36, 0x66, 0x34, 0x31, 0x30, 0x33, 0x62, 0x31, 0x66, 0x36, 0x61, 0x39, 0x32, 0x30, 0x64, 0x35, 0x64, 0x34, 0x35, 0x62, 0x30, 0x63, 0x66, 0x37, 0x37, 0x63, 0x31, 0x64, 0x63, 0x64, 0x36, 0x65, 0x65, 0x63, 0x63, 0x62, 0x35, 0x66, 0x31, 0x31, 0x35, 0x32, 0x61, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x35, 0x30, 0x63, 0x31, 0x62, 0x65, 0x62, 0x36, 0x39, 0x32, 0x65, 0x32, 0x62, 0x63, 0x34, 0x30, 0x35, 0x37, 0x38, 0x37, 0x66, 0x37, 0x31, 0x31, 0x66, 0x31, 0x61, 0x34, 0x39, 0x61, 0x38, 0x34, 0x66, 0x34, 0x31, 0x32, 0x32, 0x61, 0x61, 0x66, 0x38, 0x36, 0x61, 0x62, 0x38, 0x35, 0x64, 0x39, 0x35, 0x37, 0x39, 0x62, 0x33, 0x63, 0x65, 0x35, 0x35, 0x64, 0x37, 0x32, 0x30, 0x63, 0x33, 0x63, 0x37, 0x64, 0x39, 0x39, 0x66, 0x63, 0x63, 0x61, 0x35, 0x33, 0x31, 0x64, 0x39, 0x62, 0x65, 0x31, 0x37, 0x33, 0x32, 0x64, 0x34, 0x62, 0x62, 0x65, 0x34, 0x30, 0x31, 0x31, 0x34, 0x36, 0x63, 0x64, 0x32, 0x39, 0x35, 0x62, 0x64, 0x35, 0x64, 0x33, 0x65, 0x32, 0x35, 0x63, 0x66, 0x31, 0x32, 0x35, 0x64, 0x62, 0x31, 0x34, 0x32, 0x39, 0x38, 0x30, 0x36, 0x63, 0x37, 0x32, 0x61, 0x64, 0x65, 0x31, 0x34, 0x30, 0x63, 0x32, 0x66, 0x64, 0x36, 0x33, 0x61, 0x38, 0x38, 0x61, 0x38, 0x38, 0x37, 0x64, 0x35, 0x39, 0x34, 0x36, 0x33, 0x62, 0x35, 0x30, 0x37, 0x32, 0x33, 0x63, 0x61, 0x66, 0x66, 0x66, 0x33, 0x64, 0x37, 0x35, 0x65, 0x30, 0x30, 0x35, 0x38, 0x64, 0x35, 0x37, 0x38, 0x30, 0x65, 0x30, 0x64, 0x32, 0x39, 0x30, 0x32, 0x37, 0x35, 0x61, 0x39, 0x65, 0x37, 0x30, 0x31, 0x38, 0x38, 0x62, 0x65, 0x33, 0x32, 0x32, 0x33, 0x37, 0x39, 0x34, 0x64, 0x63, 0x66, 0x34, 0x35, 0x35, 0x36, 0x64, 0x30, 0x33, 0x39, 0x66, 0x66, 0x32, 0x32, 0x34, 0x37, 0x38, 0x30, 0x32, 0x61, 0x34, 0x62, 0x35, 0x62, 0x66, 0x39, 0x35, 0x30, 0x62, 0x35, 0x35, 0x62, 0x37, 0x31, 0x32, 0x32, 0x64, 0x33, 0x34, 0x35, 0x39, 0x33, 0x35, 0x31, 0x32, 0x33, 0x39, 0x33, 0x32, 0x32, 0x61, 0x36, 0x39, 0x65, 0x38, 0x33, 0x62, 0x34, 0x33, 0x61, 0x32, 0x63, 0x65, 0x32, 0x34, 0x34, 0x62, 0x34, 0x37, 0x64, 0x39, 0x36, 0x32, 0x31, 0x34, 0x63, 0x38, 0x39, 0x37, 0x66, 0x62, 0x30, 0x63, 0x32, 0x32, 0x65, 0x33, 0x30, 0x30, 0x30, 0x30, 0x66, 0x62, 0x61, 0x37, 0x39, 0x35, 0x64, 0x66, 0x35, 0x30, 0x63, 0x31, 0x63, 0x36, 0x30, 0x31, 0x61, 0x32, 0x64, 0x34, 0x36, 0x36, 0x37, 0x32, 0x33, 0x34, 0x65, 0x64, 0x34, 0x39, 0x65, 0x65, 0x36, 0x31, 0x36, 0x38, 0x34, 0x61, 0x32, 0x34, 0x34, 0x38, 0x66, 0x34, 0x37, 0x65, 0x65, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x35, 0x61, 0x36, 0x32, 0x31, 0x66, 0x37, 0x30, 0x62, 0x31, 0x30, 0x33, 0x34, 0x36, 0x62, 0x64, 0x65, 0x65, 0x34, 0x31, 0x34, 0x30, 0x33, 0x63, 0x33, 0x63, 0x38, 0x31, 0x37, 0x62, 0x35, 0x35, 0x62, 0x30, 0x38, 0x36, 0x65, 0x63, 0x34, 0x61, 0x62, 0x31, 0x64, 0x61, 0x39, 0x31, 0x63, 0x38, 0x30, 0x65, 0x62, 0x36, 0x31, 0x39, 0x37, 0x37, 0x30, 0x35, 0x63, 0x37, 0x65, 0x62, 0x31, 0x63, 0x32, 0x38, 0x65, 0x63, 0x30, 0x37, 0x66, 0x38, 0x32, 0x61, 0x34, 0x32, 0x65, 0x64, 0x61, 0x39, 0x30, 0x39, 0x33, 0x33, 0x33, 0x31, 0x62, 0x63, 0x34, 0x31, 0x33, 0x66, 0x65, 0x66, 0x36, 0x39, 0x35, 0x37, 0x32, 0x30, 0x30, 0x32, 0x64, 0x63, 0x62, 0x34, 0x35, 0x38, 0x65, 0x62, 0x33, 0x39, 0x34, 0x65, 0x64, 0x38, 0x37, 0x34, 0x64, 0x35, 0x36, 0x31, 0x65, 0x61, 0x39, 0x33, 0x31, 0x31, 0x33, 0x39, 0x34, 0x64, 0x63, 0x61, 0x37, 0x64, 0x31, 0x34, 0x35, 0x30, 0x64, 0x30, 0x36, 0x39, 0x30, 0x35, 0x37, 0x62, 0x33, 0x32, 0x66, 0x32, 0x31, 0x65, 0x64, 0x66, 0x38, 0x30, 0x62, 0x65, 0x66, 0x36, 0x32, 0x35, 0x31, 0x61, 0x39, 0x31, 0x32, 0x33, 0x61, 0x34, 0x33, 0x66, 0x62, 0x63, 0x37, 0x36, 0x66, 0x63, 0x61, 0x62, 0x37, 0x31, 0x34, 0x32, 0x65, 0x63, 0x33, 0x36, 0x62, 0x35, 0x30, 0x30, 0x36, 0x61, 0x35, 0x35, 0x33, 0x31, 0x61, 0x31, 0x36, 0x35, 0x38, 0x61, 0x38, 0x32, 0x32, 0x66, 0x35, 0x34, 0x66, 0x30, 0x33, 0x31, 0x34, 0x32, 0x62, 0x36, 0x35, 0x61, 0x63, 0x62, 0x37, 0x33, 0x65, 0x38, 0x65, 0x65, 0x31, 0x62, 0x30, 0x36, 0x61, 0x62, 0x34, 0x37, 0x32, 0x36, 0x32, 0x38, 0x66, 0x31, 0x64, 0x63, 0x36, 0x33, 0x35, 0x36, 0x32, 0x31, 0x63, 0x33, 0x66, 0x31, 0x35, 0x39, 0x35, 0x31, 0x62, 0x37, 0x38, 0x62, 0x61, 0x64, 0x30, 0x31, 0x31, 0x39, 0x32, 0x62, 0x32, 0x31, 0x30, 0x65, 0x37, 0x36, 0x64, 0x30, 0x32, 0x38, 0x32, 0x62, 0x65, 0x62, 0x33, 0x33, 0x35, 0x36, 0x65, 0x38, 0x34, 0x30, 0x63, 0x65, 0x65, 0x32, 0x30, 0x61, 0x34, 0x64, 0x63, 0x35, 0x63, 0x35, 0x66, 0x65, 0x37, 0x63, 0x61, 0x66, 0x62, 0x32, 0x34, 0x64, 0x62, 0x31, 0x63, 0x64, 0x33, 0x39, 0x63, 0x65, 0x35, 0x62, 0x34, 0x65, 0x65, 0x31, 0x63, 0x65, 0x30, 0x33, 0x32, 0x36, 0x36, 0x31, 0x37, 0x32, 0x38, 0x31, 0x31, 0x66, 0x31, 0x33, 0x37, 0x31, 0x32, 0x30, 0x33, 0x33, 0x31, 0x35, 0x61, 0x30, 0x63, 0x34, 0x31, 0x34, 0x65, 0x66, 0x38, 0x63, 0x31, 0x35, 0x38, 0x37, 0x62, 0x66, 0x31, 0x36, 0x35, 0x65, 0x66, 0x32, 0x36, 0x62, 0x65, 0x30, 0x65, 0x62, 0x36, 0x34, 0x66, 0x37, 0x62, 0x37, 0x34, 0x35, 0x30, 0x30, 0x66, 0x65, 0x39, 0x61, 0x33, 0x38, 0x36, 0x65, 0x30, 0x63, 0x61, 0x35, 0x36, 0x31, 0x63, 0x64, 0x61, 0x63, 0x61, 0x64, 0x62, 0x61, 0x39, 0x34, 0x64, 0x35, 0x61, 0x32, 0x30, 0x66, 0x32, 0x32, 0x33, 0x64, 0x33, 0x64, 0x62, 0x30, 0x31, 0x64, 0x34, 0x37, 0x62, 0x39, 0x65, 0x35, 0x39, 0x31, 0x64, 0x31, 0x65, 0x62, 0x37, 0x32, 0x64, 0x35, 0x34, 0x31, 0x39, 0x39, 0x31, 0x39, 0x30, 0x34, 0x32, 0x32, 0x35, 0x65, 0x34, 0x34, 0x30, 0x34, 0x64, 0x33, 0x35, 0x35, 0x30, 0x37, 0x66, 0x39, 0x38, 0x35, 0x38, 0x66, 0x65, 0x37, 0x36, 0x63, 0x34, 0x37, 0x32, 0x37, 0x65, 0x61, 0x35, 0x32, 0x35, 0x65, 0x36, 0x37, 0x61, 0x37, 0x34, 0x31, 0x63, 0x38, 0x64, 0x30, 0x36, 0x34, 0x32, 0x62, 0x30, 0x66, 0x62, 0x37, 0x66, 0x64, 0x61, 0x30, 0x34, 0x30, 0x39, 0x32, 0x62, 0x38, 0x65, 0x31, 0x64, 0x38, 0x61, 0x64, 0x30, 0x37, 0x64, 0x35, 0x34, 0x32, 0x32, 0x37, 0x38, 0x38, 0x37, 0x38, 0x31, 0x37, 0x32, 0x31, 0x39, 0x38, 0x63, 0x36, 0x64, 0x30, 0x33, 0x64, 0x63, 0x34, 0x36, 0x64, 0x32, 0x37, 0x32, 0x39, 0x66, 0x33, 0x61, 0x33, 0x62, 0x35, 0x65, 0x39, 0x61, 0x64, 0x66, 0x32, 0x35, 0x65, 0x38, 0x32, 0x65, 0x33, 0x32, 0x61, 0x63, 0x32, 0x39, 0x65, 0x61, 0x32, 0x61, 0x31, 0x31, 0x62, 0x39, 0x36, 0x39, 0x38, 0x30, 0x62, 0x31, 0x36, 0x32, 0x34, 0x61, 0x61, 0x37, 0x31, 0x36, 0x32, 0x37, 0x31, 0x38, 0x61, 0x63, 0x36, 0x37, 0x37, 0x32, 0x39, 0x35, 0x30, 0x39, 0x37, 0x66, 0x38, 0x38, 0x36, 0x31, 0x63, 0x62, 0x66, 0x36, 0x66, 0x30, 0x35, 0x35, 0x35, 0x62, 0x36, 0x63, 0x39, 0x32, 0x32, 0x30, 0x34, 0x36, 0x32, 0x64, 0x30, 0x32, 0x33, 0x64, 0x34, 0x65, 0x36, 0x66, 0x63, 0x34, 0x66, 0x33, 0x62, 0x31, 0x31, 0x37, 0x30, 0x33, 0x31, 0x37, 0x37, 0x66, 0x39, 0x30, 0x34, 0x61, 0x62, 0x63, 0x35, 0x66, 0x37, 0x66, 0x37, 0x32, 0x66, 0x39, 0x65, 0x61, 0x33, 0x37, 0x39, 0x33, 0x34, 0x31, 0x38, 0x31, 0x36, 0x34, 0x30, 0x65, 0x36, 0x63, 0x39, 0x66, 0x66, 0x36, 0x65, 0x65, 0x38, 0x64, 0x33, 0x32, 0x35, 0x35, 0x38, 0x39, 0x39, 0x39, 0x38, 0x61, 0x36, 0x36, 0x66, 0x62, 0x30, 0x64, 0x32, 0x30, 0x33, 0x38, 0x62, 0x35, 0x63, 0x38, 0x36, 0x33, 0x63, 0x38, 0x63, 0x66, 0x31, 0x64, 0x39, 0x39, 0x30, 0x61, 0x31, 0x30, 0x64, 0x34, 0x63, 0x37, 0x39, 0x36, 0x32, 0x66, 0x38, 0x61, 0x35, 0x30, 0x33, 0x31, 0x35, 0x65, 0x34, 0x63, 0x61, 0x64, 0x64, 0x33, 0x30, 0x65, 0x66, 0x36, 0x39, 0x34, 0x38, 0x30, 0x63, 0x30, 0x66, 0x38, 0x33, 0x65, 0x32, 0x39, 0x61, 0x32, 0x32, 0x30, 0x33, 0x32, 0x31, 0x61, 0x35, 0x32, 0x31, 0x37, 0x31, 0x64, 0x38, 0x31, 0x37, 0x38, 0x30, 0x61, 0x35, 0x65, 0x31, 0x63, 0x34, 0x39, 0x65, 0x64, 0x62, 0x39, 0x31, 0x33, 0x32, 0x65, 0x66, 0x66, 0x35, 0x38, 0x35, 0x34, 0x64, 0x37, 0x31, 0x31, 0x38, 0x38, 0x64, 0x62, 0x36, 0x33, 0x33, 0x35, 0x37, 0x65, 0x32, 0x34, 0x63, 0x37, 0x63, 0x63, 0x65, 0x62, 0x31, 0x64, 0x36, 0x61, 0x30, 0x33, 0x32, 0x62, 0x61, 0x30, 0x63, 0x32, 0x37, 0x37, 0x32, 0x38, 0x33, 0x35, 0x63, 0x64, 0x31, 0x65, 0x32, 0x30, 0x31, 0x39, 0x35, 0x33, 0x66, 0x36, 0x38, 0x38, 0x33, 0x64, 0x31, 0x36, 0x64, 0x37, 0x63, 0x34, 0x66, 0x37, 0x33, 0x61, 0x39, 0x36, 0x32, 0x36, 0x66, 0x62, 0x64, 0x62, 0x66, 0x64, 0x39, 0x62, 0x34, 0x64, 0x63, 0x62, 0x38, 0x35, 0x38, 0x64, 0x38, 0x66, 0x32, 0x38, 0x34, 0x63, 0x39, 0x61, 0x61, 0x39, 0x33, 0x39, 0x34, 0x35, 0x34, 0x31, 0x66, 0x66, 0x35, 0x65, 0x63, 0x61, 0x62, 0x39, 0x62, 0x64, 0x37, 0x32, 0x66, 0x34, 0x65, 0x33, 0x39, 0x64, 0x32, 0x30, 0x39, 0x39, 0x30, 0x34, 0x61, 0x65, 0x39, 0x65, 0x36, 0x35, 0x37, 0x61, 0x33, 0x64, 0x62, 0x31, 0x37, 0x62, 0x37, 0x63, 0x38, 0x33, 0x34, 0x38, 0x34, 0x39, 0x34, 0x31, 0x33, 0x63, 0x39, 0x38, 0x66, 0x66, 0x39, 0x37, 0x61, 0x61, 0x39, 0x31, 0x36, 0x38, 0x65, 0x35, 0x32, 0x64, 0x61, 0x65, 0x66, 0x33, 0x39, 0x64, 0x62, 0x64, 0x36, 0x30, 0x39, 0x64, 0x34, 0x65, 0x38, 0x37, 0x35, 0x62, 0x63, 0x64, 0x38, 0x66, 0x38, 0x35, 0x61, 0x62, 0x35, 0x32, 0x38, 0x61, 0x63, 0x36, 0x32, 0x33, 0x32, 0x32, 0x38, 0x35, 0x65, 0x33, 0x33, 0x62, 0x38, 0x39, 0x36, 0x36, 0x65, 0x33, 0x34, 0x64, 0x66, 0x61, 0x38, 0x65, 0x34, 0x64, 0x61, 0x33, 0x36, 0x33, 0x30, 0x34, 0x32, 0x64, 0x62, 0x38, 0x39, 0x33, 0x66, 0x36, 0x61, 0x35, 0x37, 0x32, 0x35, 0x62, 0x61, 0x61, 0x39, 0x38, 0x32, 0x35, 0x38, 0x64, 0x39, 0x38, 0x38, 0x38, 0x62, 0x34, 0x30, 0x30, 0x61, 0x37, 0x32, 0x62, 0x39, 0x61, 0x65, 0x37, 0x33, 0x62, 0x34, 0x65, 0x31, 0x30, 0x66, 0x63, 0x65, 0x34, 0x37, 0x63, 0x39, 0x39, 0x30, 0x62, 0x63, 0x64, 0x62, 0x61, 0x36, 0x35, 0x38, 0x37, 0x39, 0x38, 0x30, 0x32, 0x64, 0x35, 0x64, 0x34, 0x33, 0x66, 0x63, 0x37, 0x36, 0x32, 0x38, 0x36, 0x31, 0x32, 0x62, 0x37, 0x63, 0x34, 0x38, 0x37, 0x63, 0x62, 0x64, 0x31, 0x39, 0x35, 0x36, 0x39, 0x65, 0x65, 0x37, 0x33, 0x38, 0x39, 0x37, 0x34, 0x35, 0x35, 0x35, 0x61, 0x63, 0x33, 0x65, 0x66, 0x31, 0x64, 0x63, 0x63, 0x63, 0x61, 0x34, 0x65, 0x64, 0x63, 0x61, 0x35, 0x36, 0x31, 0x35, 0x62, 0x39, 0x38, 0x35, 0x32, 0x34, 0x65, 0x63, 0x34, 0x39, 0x31, 0x33, 0x64, 0x37, 0x32, 0x36, 0x63, 0x64, 0x32, 0x62, 0x34, 0x32, 0x63, 0x64, 0x30, 0x37, 0x39, 0x34, 0x65, 0x61, 0x63, 0x66, 0x31, 0x38, 0x35, 0x64, 0x64, 0x38, 0x37, 0x36, 0x66, 0x64, 0x33, 0x63, 0x64, 0x64, 0x37, 0x31, 0x62, 0x62, 0x34, 0x65, 0x37, 0x37, 0x65, 0x31, 0x34, 0x36, 0x32, 0x65, 0x32, 0x61, 0x62, 0x33, 0x31, 0x30, 0x66, 0x36, 0x39, 0x36, 0x31, 0x37, 0x34, 0x62, 0x61, 0x36, 0x66, 0x37, 0x32, 0x36, 0x33, 0x32, 0x64, 0x30, 0x34, 0x36, 0x31, 0x36, 0x35, 0x31, 0x63, 0x32, 0x30, 0x66, 0x63, 0x30, 0x34, 0x64, 0x32, 0x62, 0x34, 0x66, 0x33, 0x35, 0x64, 0x35, 0x33, 0x65, 0x31, 0x36, 0x38, 0x36, 0x37, 0x38, 0x32, 0x30, 0x65, 0x64, 0x34, 0x35, 0x38, 0x63, 0x31, 0x35, 0x66, 0x35, 0x36, 0x36, 0x63, 0x63, 0x38, 0x61, 0x30, 0x33, 0x65, 0x39, 0x39, 0x37, 0x31, 0x66, 0x61, 0x35, 0x65, 0x64, 0x37, 0x62, 0x30, 0x35, 0x61, 0x64, 0x33, 0x61, 0x66, 0x38, 0x66, 0x36, 0x39, 0x64, 0x30, 0x66, 0x33, 0x66, 0x38, 0x39, 0x36, 0x65, 0x35, 0x35, 0x35, 0x65, 0x38, 0x61, 0x33, 0x61, 0x33, 0x37, 0x36, 0x64, 0x39, 0x36, 0x37, 0x32, 0x66, 0x66, 0x66, 0x36, 0x38, 0x65, 0x32, 0x35, 0x35, 0x35, 0x64, 0x39, 0x33, 0x63, 0x35, 0x33, 0x35, 0x31, 0x30, 0x36, 0x64, 0x38, 0x66, 0x37, 0x32, 0x33, 0x66, 0x34, 0x64, 0x37, 0x35, 0x32, 0x30, 0x34, 0x34, 0x62, 0x33, 0x36, 0x64, 0x36, 0x38, 0x39, 0x66, 0x62, 0x38, 0x66, 0x39, 0x39, 0x37, 0x30, 0x39, 0x65, 0x39, 0x37, 0x39, 0x62, 0x35, 0x64, 0x64, 0x61, 0x62, 0x35, 0x33, 0x63, 0x64, 0x62, 0x39, 0x36, 0x34, 0x36, 0x31, 0x30, 0x30, 0x64, 0x37, 0x31, 0x37, 0x65, 0x31, 0x39, 0x63, 0x39, 0x30, 0x63, 0x32, 0x31, 0x33, 0x37, 0x32, 0x66, 0x39, 0x66, 0x35, 0x33, 0x63, 0x34, 0x64, 0x63, 0x64, 0x37, 0x61, 0x64, 0x66, 0x36, 0x33, 0x39, 0x39, 0x38, 0x30, 0x35, 0x37, 0x32, 0x37, 0x34, 0x61, 0x32, 0x37, 0x31, 0x31, 0x39, 0x65, 0x30, 0x31, 0x38, 0x63, 0x32, 0x32, 0x38, 0x38, 0x61, 0x37, 0x34, 0x38, 0x63, 0x33, 0x65, 0x65, 0x38, 0x61, 0x66, 0x36, 0x38, 0x32, 0x65, 0x36, 0x63, 0x39, 0x38, 0x38, 0x36, 0x31, 0x31, 0x38, 0x61, 0x62, 0x65, 0x62, 0x31, 0x36, 0x64, 0x32, 0x33, 0x30, 0x61, 0x34, 0x32, 0x65, 0x30, 0x61, 0x30, 0x31, 0x33, 0x38, 0x34, 0x63, 0x37, 0x64, 0x66, 0x61, 0x63, 0x63, 0x66, 0x64, 0x65, 0x34, 0x64, 0x30, 0x34, 0x65, 0x33, 0x36, 0x37, 0x64, 0x64, 0x37, 0x65, 0x34, 0x39, 0x64, 0x33, 0x61, 0x61, 0x37, 0x66, 0x63, 0x38, 0x32, 0x36, 0x32, 0x31, 0x64, 0x38, 0x63, 0x66, 0x62, 0x37, 0x32, 0x30, 0x39, 0x31, 0x35, 0x30, 0x66, 0x65, 0x35, 0x38, 0x61, 0x61, 0x37, 0x30, 0x64, 0x61, 0x34, 0x30, 0x36, 0x38, 0x65, 0x63, 0x32, 0x35, 0x34, 0x35, 0x63, 0x35, 0x33, 0x64, 0x39, 0x38, 0x64, 0x30, 0x61, 0x65, 0x62, 0x39, 0x38, 0x33, 0x38, 0x64, 0x39, 0x32, 0x66, 0x30, 0x31, 0x38, 0x35, 0x38, 0x35, 0x66, 0x36, 0x34, 0x30, 0x34, 0x37, 0x36, 0x36, 0x64, 0x30, 0x65, 0x61, 0x30, 0x65, 0x34, 0x62, 0x64, 0x64, 0x32, 0x34, 0x65, 0x65, 0x32, 0x35, 0x64, 0x61, 0x34, 0x36, 0x39, 0x61, 0x63, 0x66, 0x31, 0x32, 0x31, 0x38, 0x61, 0x62, 0x64, 0x30, 0x34, 0x62, 0x34, 0x39, 0x36, 0x66, 0x32, 0x64, 0x35, 0x65, 0x38, 0x65, 0x61, 0x66, 0x30, 0x32, 0x61, 0x39, 0x32, 0x30, 0x31, 0x64, 0x61, 0x61, 0x61, 0x33, 0x35, 0x30, 0x39, 0x61, 0x32, 0x62, 0x30, 0x66, 0x66, 0x33, 0x37, 0x32, 0x66, 0x63, 0x33, 0x35, 0x38, 0x61, 0x31, 0x61, 0x66, 0x34, 0x30, 0x37, 0x39, 0x63, 0x34, 0x63, 0x66, 0x30, 0x34, 0x63, 0x36, 0x31, 0x37, 0x32, 0x61, 0x63, 0x32, 0x64, 0x39, 0x66, 0x39, 0x63, 0x65, 0x38, 0x64, 0x32, 0x36, 0x34, 0x35, 0x31, 0x36, 0x63, 0x62, 0x38, 0x65, 0x35, 0x65, 0x66, 0x61, 0x38, 0x61, 0x38, 0x64, 0x31, 0x38, 0x34, 0x38, 0x31, 0x65, 0x62, 0x66, 0x33, 0x30, 0x31, 0x61, 0x65, 0x62, 0x63, 0x37, 0x64, 0x65, 0x38, 0x31, 0x61, 0x61, 0x35, 0x32, 0x64, 0x64, 0x33, 0x61, 0x66, 0x31, 0x31, 0x65, 0x36, 0x38, 0x33, 0x38, 0x37, 0x30, 0x35, 0x35, 0x66, 0x33, 0x34, 0x65, 0x30, 0x30, 0x35, 0x38, 0x61, 0x34, 0x66, 0x61, 0x34, 0x63, 0x32, 0x65, 0x62, 0x33, 0x35, 0x66, 0x37, 0x65, 0x34, 0x34, 0x31, 0x36, 0x63, 0x30, 0x33, 0x64, 0x34, 0x32, 0x61, 0x30, 0x61, 0x63, 0x39, 0x64, 0x66, 0x32, 0x64, 0x66, 0x36, 0x38, 0x35, 0x38, 0x34, 0x32, 0x66, 0x62, 0x39, 0x65, 0x37, 0x38, 0x62, 0x36, 0x62, 0x65, 0x39, 0x33, 0x39, 0x66, 0x32, 0x62, 0x65, 0x38, 0x34, 0x36, 0x39, 0x64, 0x32, 0x38, 0x65, 0x31, 0x32, 0x38, 0x62, 0x63, 0x37, 0x61, 0x32, 0x39, 0x61, 0x63, 0x39, 0x39, 0x31, 0x33, 0x30, 0x36, 0x34, 0x31, 0x36, 0x33, 0x62, 0x35, 0x66, 0x37, 0x32, 0x30, 0x30, 0x33, 0x32, 0x32, 0x39, 0x66, 0x33, 0x62, 0x36, 0x36, 0x34, 0x33, 0x62, 0x63, 0x35, 0x61, 0x65, 0x30, 0x33, 0x36, 0x63, 0x34, 0x34, 0x33, 0x32, 0x37, 0x33, 0x39, 0x61, 0x36, 0x65, 0x61, 0x63, 0x37, 0x32, 0x36, 0x64, 0x64, 0x32, 0x65, 0x33, 0x30, 0x36, 0x30, 0x61, 0x37, 0x37, 0x32, 0x32, 0x62, 0x35, 0x33, 0x65, 0x65, 0x37, 0x63, 0x34, 0x33, 0x34, 0x35, 0x66, 0x35, 0x35, 0x39, 0x33, 0x32, 0x32, 0x38, 0x63, 0x31, 0x63, 0x65, 0x31, 0x63, 0x63, 0x65, 0x32, 0x32, 0x38, 0x32, 0x30, 0x38, 0x33, 0x63, 0x62, 0x38, 0x64, 0x64, 0x39, 0x34, 0x36, 0x34, 0x37, 0x62, 0x38, 0x33, 0x33, 0x38, 0x65, 0x61, 0x66, 0x63, 0x63, 0x36, 0x34, 0x65, 0x30, 0x65, 0x32, 0x62, 0x62, 0x36, 0x35, 0x39, 0x31, 0x66, 0x66, 0x65, 0x64, 0x66, 0x31, 0x36, 0x62, 0x65, 0x62, 0x32, 0x65, 0x39, 0x63, 0x34, 0x65, 0x61, 0x38, 0x64, 0x65, 0x38, 0x61, 0x62, 0x39, 0x65, 0x39, 0x34, 0x39, 0x31, 0x66, 0x38, 0x37, 0x39, 0x64, 0x30, 0x36, 0x33, 0x31, 0x63, 0x39, 0x33, 0x33, 0x32, 0x38, 0x66, 0x65, 0x64, 0x32, 0x31, 0x36, 0x66, 0x38, 0x63, 0x66, 0x32, 0x34, 0x62, 0x66, 0x32, 0x39, 0x36, 0x31, 0x64, 0x35, 0x39, 0x36, 0x32, 0x61, 0x63, 0x62, 0x61, 0x34, 0x65, 0x39, 0x37, 0x32, 0x65, 0x65, 0x33, 0x31, 0x33, 0x32, 0x30, 0x65, 0x34, 0x63, 0x64, 0x32, 0x64, 0x63, 0x63, 0x66, 0x31, 0x32, 0x30, 0x34, 0x36, 0x35, 0x63, 0x33, 0x36, 0x35, 0x62, 0x65, 0x32, 0x66, 0x32, 0x34, 0x39, 0x31, 0x37, 0x37, 0x66, 0x30, 0x62, 0x35, 0x63, 0x37, 0x62, 0x38, 0x39, 0x63, 0x32, 0x33, 0x35, 0x34, 0x36, 0x31, 0x34, 0x35, 0x33, 0x66, 0x66, 0x61, 0x37, 0x64, 0x35, 0x37, 0x37, 0x32, 0x37, 0x36, 0x66, 0x39, 0x62, 0x30, 0x35, 0x30, 0x66, 0x34, 0x66, 0x65, 0x63, 0x39, 0x32, 0x35, 0x32, 0x63, 0x64, 0x31, 0x66, 0x65, 0x30, 0x66, 0x37, 0x33, 0x38, 0x63, 0x61, 0x35, 0x63, 0x65, 0x37, 0x36, 0x32, 0x30, 0x38, 0x65, 0x34, 0x34, 0x39, 0x39, 0x62, 0x37, 0x61, 0x61, 0x32, 0x31, 0x36, 0x66, 0x35, 0x36, 0x62, 0x37, 0x36, 0x61, 0x65, 0x35, 0x38, 0x37, 0x36, 0x36, 0x37, 0x32, 0x34, 0x35, 0x63, 0x31, 0x38, 0x65, 0x39, 0x61, 0x37, 0x31, 0x63, 0x64, 0x65, 0x31, 0x62, 0x62, 0x34, 0x31, 0x35, 0x32, 0x63, 0x62, 0x64, 0x32, 0x32, 0x61, 0x39, 0x66, 0x62, 0x35, 0x61, 0x65, 0x61, 0x34, 0x38, 0x30, 0x66, 0x65, 0x65, 0x62, 0x31, 0x38, 0x35, 0x66, 0x38, 0x62, 0x34, 0x62, 0x38, 0x66, 0x32, 0x66, 0x37, 0x61, 0x37, 0x38, 0x63, 0x61, 0x65, 0x36, 0x38, 0x33, 0x37, 0x32, 0x33, 0x37, 0x37, 0x37, 0x32, 0x63, 0x35, 0x31, 0x61, 0x39, 0x30, 0x63, 0x61, 0x34, 0x34, 0x66, 0x61, 0x36, 0x30, 0x65, 0x62, 0x64, 0x61, 0x37, 0x39, 0x63, 0x39, 0x36, 0x62, 0x31, 0x35, 0x32, 0x33, 0x31, 0x36, 0x31, 0x32, 0x63, 0x30, 0x33, 0x63, 0x34, 0x64, 0x34, 0x65, 0x62, 0x66, 0x64, 0x65, 0x34, 0x61, 0x63, 0x39, 0x35, 0x62, 0x64, 0x65, 0x31, 0x62, 0x31, 0x64, 0x37, 0x37, 0x32, 0x62, 0x61, 0x36, 0x63, 0x30, 0x35, 0x64, 0x30, 0x30, 0x66, 0x38, 0x61, 0x30, 0x38, 0x30, 0x32, 0x31, 0x61, 0x62, 0x66, 0x62, 0x32, 0x30, 0x35, 0x31, 0x34, 0x63, 0x39, 0x64, 0x37, 0x36, 0x61, 0x38, 0x63, 0x38, 0x30, 0x34, 0x66, 0x35, 0x66, 0x64, 0x36, 0x37, 0x37, 0x66, 0x37, 0x32, 0x32, 0x38, 0x32, 0x63, 0x37, 0x33, 0x34, 0x34, 0x36, 0x31, 0x61, 0x34, 0x31, 0x37, 0x39, 0x30, 0x36, 0x31, 0x65, 0x30, 0x61, 0x33, 0x62, 0x37, 0x66, 0x30, 0x39, 0x34, 0x39, 0x65, 0x63, 0x64, 0x38, 0x38, 0x34, 0x31, 0x33, 0x36, 0x33, 0x39, 0x37, 0x31, 0x39, 0x61, 0x65, 0x39, 0x62, 0x36, 0x33, 0x30, 0x64, 0x31, 0x33, 0x35, 0x36, 0x34, 0x36, 0x62, 0x37, 0x35, 0x37, 0x36, 0x64, 0x61, 0x31, 0x30, 0x31, 0x64, 0x36, 0x61, 0x39, 0x36, 0x35, 0x65, 0x35, 0x66, 0x30, 0x34, 0x33, 0x35, 0x38, 0x39, 0x34, 0x32, 0x37, 0x64, 0x64, 0x32, 0x65, 0x35, 0x30, 0x37, 0x66, 0x64, 0x39, 0x36, 0x36, 0x38, 0x35, 0x64, 0x30, 0x66, 0x62, 0x33, 0x36, 0x63, 0x64, 0x35, 0x64, 0x32, 0x63, 0x35, 0x62, 0x61, 0x62, 0x34, 0x33, 0x38, 0x64, 0x33, 0x34, 0x66, 0x36, 0x31, 0x38, 0x66, 0x37, 0x36, 0x61, 0x61, 0x33, 0x30, 0x65, 0x38, 0x34, 0x30, 0x37, 0x65, 0x64, 0x63, 0x66, 0x65, 0x31, 0x32, 0x64, 0x34, 0x66, 0x33, 0x65, 0x65, 0x34, 0x64, 0x64, 0x39, 0x34, 0x39, 0x35, 0x63, 0x61, 0x36, 0x61, 0x38, 0x33, 0x32, 0x64, 0x31, 0x61, 0x36, 0x65, 0x30, 0x31, 0x65, 0x62, 0x37, 0x66, 0x32, 0x64, 0x34, 0x36, 0x38, 0x33, 0x66, 0x34, 0x32, 0x65, 0x61, 0x34, 0x61, 0x65, 0x65, 0x38, 0x32, 0x64, 0x30, 0x64, 0x32, 0x64, 0x37, 0x34, 0x63, 0x63, 0x34, 0x64, 0x66, 0x62, 0x64, 0x34, 0x32, 0x36, 0x64, 0x63, 0x65, 0x32, 0x35, 0x38, 0x65, 0x36, 0x62, 0x30, 0x61, 0x38, 0x32, 0x34, 0x32, 0x34, 0x62, 0x32, 0x61, 0x33, 0x36, 0x32, 0x36, 0x35, 0x62, 0x62, 0x39, 0x30, 0x38, 0x32, 0x34, 0x65, 0x32, 0x33, 0x61, 0x36, 0x62, 0x30, 0x37, 0x64, 0x33, 0x32, 0x65, 0x36, 0x37, 0x32, 0x66, 0x31, 0x32, 0x61, 0x33, 0x33, 0x30, 0x39, 0x36, 0x61, 0x38, 0x64, 0x33, 0x65, 0x34, 0x65, 0x37, 0x32, 0x34, 0x33, 0x31, 0x39, 0x37, 0x66, 0x35, 0x62, 0x64, 0x32, 0x61, 0x33, 0x36, 0x33, 0x36, 0x36, 0x62, 0x61, 0x33, 0x61, 0x62, 0x34, 0x30, 0x66, 0x31, 0x35, 0x38, 0x37, 0x36, 0x31, 0x30, 0x66, 0x34, 0x34, 0x31, 0x36, 0x30, 0x36, 0x35, 0x62, 0x33, 0x35, 0x33, 0x32, 0x35, 0x33, 0x39, 0x65, 0x30, 0x65, 0x64, 0x66, 0x33, 0x35, 0x66, 0x37, 0x33, 0x64, 0x35, 0x31, 0x63, 0x65, 0x34, 0x63, 0x36, 0x39, 0x39, 0x30, 0x39, 0x65, 0x63, 0x66, 0x31, 0x35, 0x39, 0x37, 0x39, 0x30, 0x30, 0x37, 0x36, 0x66, 0x31, 0x39, 0x31, 0x38, 0x39, 0x66, 0x66, 0x34, 0x32, 0x32, 0x33, 0x63, 0x34, 0x62, 0x33, 0x30, 0x34, 0x62, 0x63, 0x31, 0x32, 0x32, 0x33, 0x61, 0x39, 0x34, 0x64, 0x64, 0x61, 0x34, 0x61, 0x64, 0x61, 0x33, 0x36, 0x33, 0x35, 0x34, 0x34, 0x31, 0x66, 0x30, 0x65, 0x65, 0x37, 0x32, 0x37, 0x61, 0x63, 0x66, 0x30, 0x39, 0x62, 0x31, 0x32, 0x34, 0x38, 0x35, 0x64, 0x33, 0x38, 0x38, 0x38, 0x62, 0x64, 0x37, 0x37, 0x64, 0x61, 0x38, 0x32, 0x39, 0x37, 0x39, 0x66, 0x62, 0x64, 0x39, 0x36, 0x61, 0x64, 0x62, 0x62, 0x32, 0x66, 0x37, 0x37, 0x39, 0x30, 0x38, 0x65, 0x32, 0x31, 0x33, 0x63, 0x62, 0x66, 0x64, 0x34, 0x38, 0x38, 0x63, 0x65, 0x61, 0x38, 0x39, 0x65, 0x65, 0x37, 0x32, 0x38, 0x65, 0x37, 0x65, 0x65, 0x35, 0x39, 0x33, 0x30, 0x30, 0x31, 0x31, 0x31, 0x61, 0x36, 0x32, 0x66, 0x38, 0x35, 0x38, 0x30, 0x32, 0x39, 0x34, 0x32, 0x38, 0x33, 0x62, 0x35, 0x32, 0x32, 0x31, 0x38, 0x39, 0x61, 0x64, 0x30, 0x39, 0x30, 0x63, 0x30, 0x36, 0x37, 0x62, 0x62, 0x62, 0x30, 0x66, 0x66, 0x65, 0x63, 0x66, 0x38, 0x31, 0x63, 0x61, 0x65, 0x34, 0x33, 0x35, 0x31, 0x38, 0x30, 0x39, 0x62, 0x36, 0x35, 0x61, 0x66, 0x38, 0x61, 0x32, 0x66, 0x34, 0x30, 0x32, 0x33, 0x31, 0x33, 0x66, 0x65, 0x36, 0x34, 0x39, 0x61, 0x30, 0x36, 0x62, 0x30, 0x61, 0x61, 0x66, 0x30, 0x64, 0x38, 0x66, 0x38, 0x36, 0x37, 0x38, 0x30, 0x32, 0x62, 0x33, 0x63, 0x66, 0x38, 0x30, 0x32, 0x36, 0x36, 0x38, 0x30, 0x39, 0x63, 0x38, 0x65, 0x61, 0x64, 0x35, 0x61, 0x34, 0x66, 0x62, 0x30, 0x64, 0x31, 0x34, 0x30, 0x62, 0x36, 0x36, 0x62, 0x64, 0x31, 0x65, 0x65, 0x37, 0x33, 0x38, 0x36, 0x64, 0x36, 0x38, 0x32, 0x39, 0x38, 0x34, 0x65, 0x39, 0x34, 0x34, 0x33, 0x33, 0x63, 0x38, 0x31, 0x66, 0x61, 0x32, 0x34, 0x34, 0x61, 0x33, 0x38, 0x32, 0x39, 0x61, 0x33, 0x35, 0x62, 0x61, 0x34, 0x37, 0x38, 0x39, 0x33, 0x66, 0x64, 0x33, 0x36, 0x32, 0x36, 0x37, 0x63, 0x62, 0x63, 0x39, 0x64, 0x63, 0x37, 0x32, 0x66, 0x32, 0x65, 0x34, 0x35, 0x32, 0x31, 0x62, 0x30, 0x61, 0x32, 0x36, 0x61, 0x65, 0x30, 0x37, 0x64, 0x32, 0x30, 0x33, 0x33, 0x34, 0x61, 0x39, 0x64, 0x61, 0x38, 0x66, 0x62, 0x39, 0x38, 0x32, 0x33, 0x39, 0x37, 0x38, 0x32, 0x64, 0x30, 0x38, 0x33, 0x36, 0x32, 0x65, 0x30, 0x30, 0x36, 0x36, 0x31, 0x36, 0x66, 0x62, 0x63, 0x37, 0x63, 0x38, 0x36, 0x33, 0x38, 0x61, 0x39, 0x35, 0x37, 0x32, 0x64, 0x38, 0x31, 0x62, 0x37, 0x38, 0x64, 0x39, 0x62, 0x34, 0x35, 0x36, 0x30, 0x66, 0x39, 0x63, 0x66, 0x39, 0x32, 0x63, 0x64, 0x62, 0x31, 0x61, 0x35, 0x34, 0x37, 0x62, 0x65, 0x35, 0x61, 0x33, 0x64, 0x38, 0x39, 0x37, 0x31, 0x64, 0x32, 0x62, 0x38, 0x37, 0x39, 0x38, 0x30, 0x64, 0x35, 0x39, 0x35, 0x66, 0x30, 0x65, 0x37, 0x35, 0x65, 0x62, 0x30, 0x39, 0x32, 0x62, 0x34, 0x37, 0x32, 0x65, 0x62, 0x36, 0x35, 0x62, 0x38, 0x66, 0x66, 0x30, 0x62, 0x32, 0x63, 0x64, 0x62, 0x35, 0x39, 0x34, 0x64, 0x66, 0x65, 0x34, 0x37, 0x63, 0x38, 0x32, 0x31, 0x30, 0x35, 0x63, 0x36, 0x34, 0x33, 0x61, 0x61, 0x63, 0x30, 0x63, 0x63, 0x38, 0x34, 0x65, 0x34, 0x62, 0x34, 0x66, 0x63, 0x36, 0x61, 0x35, 0x36, 0x37, 0x62, 0x36, 0x65, 0x61, 0x62, 0x62, 0x62, 0x62, 0x63, 0x34, 0x61, 0x32, 0x34, 0x61, 0x65, 0x62, 0x36, 0x37, 0x33, 0x34, 0x33, 0x37, 0x61, 0x32, 0x39, 0x64, 0x34, 0x34, 0x65, 0x30, 0x61, 0x64, 0x66, 0x39, 0x66, 0x38, 0x62, 0x38, 0x33, 0x38, 0x61, 0x62, 0x62, 0x38, 0x31, 0x36, 0x32, 0x30, 0x31, 0x33, 0x38, 0x33, 0x31, 0x30, 0x62, 0x66, 0x66, 0x32, 0x34, 0x32, 0x34, 0x31, 0x65, 0x63, 0x62, 0x30, 0x34, 0x66, 0x39, 0x38, 0x38, 0x63, 0x33, 0x38, 0x34, 0x65, 0x33, 0x33, 0x34, 0x30, 0x38, 0x61, 0x39, 0x33, 0x37, 0x62, 0x39, 0x65, 0x63, 0x39, 0x65, 0x33, 0x34, 0x32, 0x61, 0x33, 0x62, 0x38, 0x63, 0x65, 0x39, 0x66, 0x32, 0x34, 0x38, 0x39, 0x66, 0x37, 0x36, 0x33, 0x38, 0x33, 0x31, 0x39, 0x34, 0x31, 0x36, 0x35, 0x61, 0x37, 0x37, 0x65, 0x64, 0x66, 0x39, 0x37, 0x66, 0x61, 0x64, 0x30, 0x38, 0x34, 0x34, 0x62, 0x33, 0x37, 0x31, 0x38, 0x32, 0x38, 0x37, 0x32, 0x36, 0x62, 0x33, 0x63, 0x35, 0x36, 0x63, 0x65, 0x65, 0x39, 0x61, 0x65, 0x38, 0x37, 0x30, 0x64, 0x36, 0x33, 0x63, 0x37, 0x35, 0x38, 0x35, 0x65, 0x65, 0x32, 0x65, 0x31, 0x37, 0x38, 0x37, 0x65, 0x38, 0x38, 0x61, 0x62, 0x34, 0x30, 0x33, 0x61, 0x66, 0x32, 0x34, 0x65, 0x32, 0x39, 0x30, 0x35, 0x32, 0x61, 0x32, 0x31, 0x66, 0x33, 0x34, 0x66, 0x65, 0x39, 0x35, 0x32, 0x61, 0x35, 0x33, 0x65, 0x65, 0x38, 0x65, 0x31, 0x37, 0x61, 0x30, 0x64, 0x35, 0x35, 0x39, 0x30, 0x34, 0x36, 0x33, 0x37, 0x66, 0x31, 0x61, 0x38, 0x34, 0x38, 0x64, 0x64, 0x30, 0x66, 0x37, 0x30, 0x39, 0x63, 0x61, 0x61, 0x61, 0x66, 0x62, 0x66, 0x39, 0x33, 0x34, 0x35, 0x31, 0x33, 0x38, 0x63, 0x64, 0x38, 0x64, 0x61, 0x66, 0x30, 0x35, 0x39, 0x64, 0x39, 0x35, 0x30, 0x64, 0x31, 0x66, 0x33, 0x37, 0x34, 0x37, 0x32, 0x35, 0x37, 0x35, 0x66, 0x65, 0x30, 0x62, 0x34, 0x62, 0x33, 0x30, 0x62, 0x30, 0x31, 0x63, 0x38, 0x62, 0x63, 0x38, 0x37, 0x31, 0x36, 0x32, 0x63, 0x65, 0x30, 0x62, 0x62, 0x61, 0x66, 0x37, 0x32, 0x37, 0x38, 0x31, 0x63, 0x64, 0x65, 0x38, 0x65, 0x30, 0x38, 0x35, 0x62, 0x64, 0x32, 0x38, 0x33, 0x35, 0x66, 0x66, 0x30, 0x39, 0x64, 0x64, 0x36, 0x36, 0x37, 0x65, 0x30, 0x65, 0x66, 0x37, 0x32, 0x33, 0x66, 0x61, 0x65, 0x65, 0x31, 0x65, 0x30, 0x62, 0x66, 0x36, 0x33, 0x36, 0x61, 0x65, 0x32, 0x30, 0x64, 0x37, 0x37, 0x63, 0x65, 0x34, 0x32, 0x61, 0x31, 0x39, 0x33, 0x61, 0x63, 0x39, 0x64, 0x37, 0x66, 0x39, 0x62, 0x33, 0x33, 0x31, 0x36, 0x32, 0x34, 0x61, 0x61, 0x35, 0x64, 0x34, 0x32, 0x66, 0x63, 0x37, 0x36, 0x37, 0x62, 0x62, 0x33, 0x33, 0x38, 0x64, 0x36, 0x63, 0x36, 0x37, 0x32, 0x62, 0x37, 0x30, 0x35, 0x65, 0x32, 0x33, 0x30, 0x30, 0x66, 0x65, 0x65, 0x39, 0x32, 0x62, 0x33, 0x63, 0x64, 0x63, 0x31, 0x66, 0x33, 0x31, 0x61, 0x64, 0x39, 0x66, 0x35, 0x31, 0x35, 0x38, 0x61, 0x38, 0x64, 0x38, 0x30, 0x38, 0x33, 0x65, 0x35, 0x33, 0x63, 0x65, 0x65, 0x31, 0x36, 0x39, 0x33, 0x36, 0x31, 0x38, 0x32, 0x33, 0x34, 0x65, 0x63, 0x61, 0x66, 0x33, 0x63, 0x34, 0x61, 0x36, 0x31, 0x36, 0x34, 0x37, 0x64, 0x65, 0x65, 0x61, 0x39, 0x31, 0x64, 0x31, 0x38, 0x37, 0x34, 0x30, 0x31, 0x37, 0x33, 0x30, 0x39, 0x30, 0x63, 0x30, 0x65, 0x33, 0x35, 0x37, 0x34, 0x35, 0x34, 0x33, 0x36, 0x65, 0x39, 0x30, 0x66, 0x32, 0x63, 0x36, 0x31, 0x64, 0x35, 0x33, 0x31, 0x36, 0x38, 0x35, 0x66, 0x61, 0x64, 0x66, 0x38, 0x36, 0x32, 0x35, 0x31, 0x63, 0x63, 0x32, 0x35, 0x32, 0x61, 0x37, 0x32, 0x33, 0x37, 0x30, 0x37, 0x62, 0x66, 0x30, 0x33, 0x37, 0x64, 0x61, 0x62, 0x62, 0x61, 0x32, 0x39, 0x64, 0x63, 0x35, 0x64, 0x36, 0x30, 0x34, 0x62, 0x31, 0x65, 0x37, 0x30, 0x34, 0x63, 0x38, 0x37, 0x38, 0x63, 0x61, 0x36, 0x39, 0x37, 0x30, 0x65, 0x64, 0x38, 0x30, 0x66, 0x31, 0x31, 0x34, 0x31, 0x66, 0x65, 0x33, 0x35, 0x64, 0x65, 0x66, 0x35, 0x62, 0x30, 0x32, 0x63, 0x62, 0x66, 0x34, 0x38, 0x33, 0x39, 0x35, 0x34, 0x66, 0x35, 0x65, 0x36, 0x33, 0x38, 0x62, 0x63, 0x39, 0x38, 0x38, 0x61, 0x63, 0x31, 0x63, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x64, 0x62, 0x38, 0x30, 0x63, 0x63, 0x35, 0x37, 0x35, 0x33, 0x35, 0x36, 0x39, 0x35, 0x65, 0x34, 0x34, 0x38, 0x38, 0x61, 0x37, 0x62, 0x64, 0x33, 0x66, 0x37, 0x33, 0x66, 0x38, 0x31, 0x35, 0x66, 0x34, 0x38, 0x35, 0x62, 0x38, 0x32, 0x64, 0x35, 0x38, 0x31, 0x30, 0x39, 0x39, 0x31, 0x30, 0x32, 0x32, 0x36, 0x62, 0x33, 0x38, 0x38, 0x35, 0x32, 0x38, 0x65, 0x39, 0x61, 0x39, 0x38, 0x30, 0x34, 0x65, 0x31, 0x66, 0x64, 0x33, 0x33, 0x32, 0x35, 0x61, 0x36, 0x32, 0x39, 0x35, 0x36, 0x33, 0x37, 0x36, 0x30, 0x64, 0x35, 0x32, 0x63, 0x38, 0x35, 0x36, 0x37, 0x35, 0x63, 0x38, 0x66, 0x31, 0x63, 0x39, 0x34, 0x32, 0x36, 0x65, 0x31, 0x31, 0x30, 0x32, 0x37, 0x65, 0x64, 0x36, 0x37, 0x37, 0x66, 0x66, 0x36, 0x35, 0x65, 0x65, 0x36, 0x34, 0x33, 0x66, 0x39, 0x30, 0x63, 0x61, 0x37, 0x35, 0x33, 0x38, 0x35, 0x36, 0x30, 0x38, 0x31, 0x33, 0x61, 0x66, 0x66, 0x33, 0x34, 0x62, 0x32, 0x36, 0x64, 0x39, 0x30, 0x33, 0x36, 0x63, 0x33, 0x63, 0x32, 0x39, 0x39, 0x32, 0x35, 0x38, 0x32, 0x31, 0x34, 0x63, 0x30, 0x66, 0x64, 0x39, 0x32, 0x64, 0x63, 0x34, 0x37, 0x30, 0x62, 0x39, 0x31, 0x31, 0x36, 0x66, 0x30, 0x32, 0x31, 0x66, 0x32, 0x63, 0x36, 0x38, 0x61, 0x61, 0x66, 0x65, 0x36, 0x38, 0x64, 0x39, 0x63, 0x32, 0x37, 0x66, 0x34, 0x37, 0x61, 0x66, 0x33, 0x36, 0x34, 0x62, 0x61, 0x38, 0x34, 0x64, 0x64, 0x64, 0x65, 0x63, 0x61, 0x64, 0x37, 0x37, 0x35, 0x36, 0x32, 0x63, 0x62, 0x66, 0x32, 0x62, 0x35, 0x30, 0x32, 0x62, 0x36, 0x34, 0x36, 0x62, 0x65, 0x38, 0x66, 0x66, 0x33, 0x35, 0x35, 0x35, 0x61, 0x36, 0x33, 0x63, 0x34, 0x32, 0x37, 0x30, 0x32, 0x31, 0x66, 0x62, 0x66, 0x35, 0x61, 0x36, 0x35, 0x66, 0x32, 0x32, 0x63, 0x32, 0x63, 0x66, 0x35, 0x64, 0x35, 0x62, 0x61, 0x32, 0x66, 0x66, 0x33, 0x37, 0x30, 0x36, 0x37, 0x37, 0x33, 0x38, 0x63, 0x38, 0x34, 0x61, 0x39, 0x36, 0x37, 0x36, 0x31, 0x63, 0x38, 0x62, 0x34, 0x34, 0x61, 0x65, 0x32, 0x39, 0x63, 0x62, 0x34, 0x62, 0x65, 0x62, 0x38, 0x63, 0x65, 0x30, 0x62, 0x37, 0x63, 0x31, 0x65, 0x35, 0x37, 0x35, 0x65, 0x33, 0x33, 0x36, 0x64, 0x62, 0x36, 0x39, 0x65, 0x65, 0x61, 0x37, 0x31, 0x38, 0x39, 0x37, 0x64, 0x35, 0x36, 0x36, 0x36, 0x37, 0x37, 0x38, 0x61, 0x36, 0x66, 0x63, 0x38, 0x62, 0x65, 0x65, 0x34, 0x34, 0x39, 0x30, 0x65, 0x30, 0x30, 0x38, 0x36, 0x38, 0x34, 0x32, 0x35, 0x37, 0x31, 0x33, 0x32, 0x35, 0x32, 0x65, 0x33, 0x65, 0x32, 0x35, 0x64, 0x31, 0x39, 0x64, 0x38, 0x66, 0x64, 0x62, 0x61, 0x66, 0x32, 0x39, 0x65, 0x38, 0x36, 0x32, 0x37, 0x63, 0x39, 0x61, 0x64, 0x35, 0x31, 0x61, 0x61, 0x30, 0x31, 0x31, 0x33, 0x66, 0x31, 0x39, 0x30, 0x61, 0x62, 0x30, 0x36, 0x62, 0x31, 0x32, 0x37, 0x39, 0x36, 0x33, 0x37, 0x30, 0x32, 0x33, 0x32, 0x37, 0x30, 0x66, 0x35, 0x35, 0x34, 0x39, 0x64, 0x61, 0x37, 0x37, 0x34, 0x61, 0x35, 0x39, 0x36, 0x38, 0x35, 0x37, 0x62, 0x61, 0x39, 0x37, 0x39, 0x39, 0x35, 0x65, 0x39, 0x31, 0x33, 0x32, 0x63, 0x65, 0x38, 0x31, 0x33, 0x63, 0x31, 0x31, 0x38, 0x65, 0x65, 0x63, 0x62, 0x38, 0x63, 0x36, 0x66, 0x66, 0x34, 0x65, 0x33, 0x65, 0x32, 0x61, 0x66, 0x65, 0x33, 0x34, 0x65, 0x62, 0x35, 0x63, 0x37, 0x32, 0x37, 0x62, 0x39, 0x39, 0x32, 0x31, 0x38, 0x63, 0x38, 0x33, 0x30, 0x61, 0x37, 0x61, 0x64, 0x38, 0x62, 0x30, 0x39, 0x61, 0x34, 0x64, 0x32, 0x38, 0x62, 0x61, 0x36, 0x31, 0x65, 0x63, 0x36, 0x31, 0x61, 0x61, 0x62, 0x36, 0x38, 0x32, 0x36, 0x66, 0x36, 0x36, 0x62, 0x66, 0x30, 0x37, 0x64, 0x66, 0x64, 0x36, 0x31, 0x31, 0x66, 0x38, 0x35, 0x36, 0x63, 0x63, 0x31, 0x36, 0x35, 0x64, 0x37, 0x32, 0x30, 0x63, 0x61, 0x30, 0x64, 0x35, 0x32, 0x64, 0x63, 0x62, 0x35, 0x36, 0x62, 0x63, 0x64, 0x37, 0x62, 0x34, 0x62, 0x63, 0x30, 0x34, 0x38, 0x61, 0x30, 0x31, 0x63, 0x35, 0x32, 0x35, 0x35, 0x33, 0x64, 0x31, 0x37, 0x61, 0x65, 0x66, 0x66, 0x35, 0x35, 0x66, 0x30, 0x35, 0x30, 0x61, 0x35, 0x35, 0x33, 0x33, 0x65, 0x37, 0x62, 0x30, 0x39, 0x62, 0x62, 0x38, 0x38, 0x61, 0x33, 0x65, 0x37, 0x32, 0x31, 0x33, 0x64, 0x36, 0x30, 0x62, 0x62, 0x66, 0x32, 0x63, 0x32, 0x39, 0x61, 0x30, 0x39, 0x62, 0x35, 0x61, 0x35, 0x35, 0x36, 0x63, 0x31, 0x36, 0x65, 0x34, 0x30, 0x37, 0x65, 0x62, 0x30, 0x37, 0x66, 0x33, 0x33, 0x31, 0x30, 0x31, 0x62, 0x32, 0x39, 0x65, 0x34, 0x34, 0x65, 0x63, 0x36, 0x38, 0x62, 0x33, 0x61, 0x62, 0x65, 0x36, 0x65, 0x31, 0x63, 0x62, 0x63, 0x66, 0x31, 0x38, 0x32, 0x37, 0x31, 0x37, 0x34, 0x34, 0x35, 0x36, 0x38, 0x32, 0x38, 0x34, 0x64, 0x65, 0x34, 0x30, 0x34, 0x30, 0x37, 0x34, 0x33, 0x34, 0x31, 0x35, 0x37, 0x33, 0x62, 0x35, 0x66, 0x37, 0x61, 0x34, 0x63, 0x33, 0x65, 0x34, 0x30, 0x65, 0x36, 0x31, 0x39, 0x65, 0x61, 0x33, 0x37, 0x64, 0x36, 0x39, 0x38, 0x36, 0x63, 0x32, 0x34, 0x66, 0x64, 0x66, 0x63, 0x34, 0x37, 0x63, 0x37, 0x33, 0x34, 0x32, 0x32, 0x36, 0x30, 0x31, 0x64, 0x33, 0x33, 0x65, 0x64, 0x34, 0x32, 0x36, 0x36, 0x36, 0x35, 0x31, 0x33, 0x31, 0x38, 0x64, 0x61, 0x35, 0x35, 0x31, 0x34, 0x39, 0x65, 0x31, 0x66, 0x65, 0x38, 0x36, 0x30, 0x66, 0x66, 0x31, 0x32, 0x64, 0x66, 0x39, 0x30, 0x30, 0x64, 0x30, 0x65, 0x30, 0x39, 0x64, 0x37, 0x66, 0x39, 0x38, 0x38, 0x32, 0x36, 0x33, 0x36, 0x33, 0x35, 0x33, 0x37, 0x31, 0x33, 0x39, 0x32, 0x38, 0x61, 0x62, 0x32, 0x63, 0x33, 0x61, 0x36, 0x33, 0x34, 0x62, 0x35, 0x66, 0x63, 0x65, 0x66, 0x65, 0x65, 0x32, 0x63, 0x33, 0x39, 0x34, 0x38, 0x38, 0x36, 0x32, 0x66, 0x34, 0x37, 0x65, 0x39, 0x64, 0x66, 0x38, 0x37, 0x63, 0x39, 0x38, 0x61, 0x65, 0x31, 0x64, 0x30, 0x63, 0x38, 0x30, 0x64, 0x64, 0x39, 0x65, 0x33, 0x39, 0x30, 0x39, 0x35, 0x34, 0x66, 0x37, 0x39, 0x64, 0x39, 0x61, 0x31, 0x39, 0x37, 0x36, 0x30, 0x35, 0x36, 0x39, 0x37, 0x66, 0x39, 0x36, 0x65, 0x64, 0x37, 0x38, 0x63, 0x35, 0x33, 0x63, 0x37, 0x61, 0x66, 0x66, 0x30, 0x31, 0x30, 0x37, 0x62, 0x31, 0x63, 0x32, 0x33, 0x31, 0x62, 0x62, 0x30, 0x65, 0x33, 0x62, 0x37, 0x33, 0x36, 0x66, 0x30, 0x38, 0x61, 0x39, 0x35, 0x63, 0x32, 0x35, 0x35, 0x36, 0x31, 0x65, 0x30, 0x39, 0x37, 0x34, 0x33, 0x30, 0x34, 0x31, 0x37, 0x32, 0x37, 0x61, 0x36, 0x33, 0x36, 0x64, 0x35, 0x38, 0x36, 0x65, 0x62, 0x34, 0x35, 0x63, 0x38, 0x64, 0x62, 0x38, 0x39, 0x64, 0x64, 0x37, 0x31, 0x66, 0x38, 0x33, 0x38, 0x37, 0x39, 0x34, 0x34, 0x38, 0x66, 0x63, 0x64, 0x39, 0x34, 0x36, 0x61, 0x61, 0x39, 0x65, 0x62, 0x31, 0x34, 0x31, 0x34, 0x36, 0x66, 0x36, 0x35, 0x62, 0x30, 0x36, 0x64, 0x37, 0x65, 0x64, 0x32, 0x61, 0x66, 0x64, 0x37, 0x32, 0x62, 0x61, 0x66, 0x32, 0x34, 0x64, 0x37, 0x37, 0x36, 0x35, 0x30, 0x65, 0x32, 0x32, 0x63, 0x63, 0x66, 0x61, 0x64, 0x64, 0x36, 0x39, 0x35, 0x61, 0x66, 0x36, 0x62, 0x37, 0x62, 0x63, 0x61, 0x39, 0x33, 0x63, 0x65, 0x64, 0x36, 0x30, 0x31, 0x63, 0x33, 0x37, 0x32, 0x38, 0x64, 0x39, 0x65, 0x31, 0x32, 0x65, 0x38, 0x64, 0x37, 0x35, 0x31, 0x31, 0x35, 0x66, 0x61, 0x34, 0x35, 0x62, 0x37, 0x32, 0x36, 0x30, 0x37, 0x36, 0x35, 0x65, 0x34, 0x36, 0x39, 0x65, 0x38, 0x39, 0x39, 0x33, 0x38, 0x38, 0x35, 0x66, 0x66, 0x30, 0x32, 0x30, 0x31, 0x65, 0x30, 0x30, 0x31, 0x63, 0x31, 0x64, 0x66, 0x61, 0x65, 0x34, 0x36, 0x33, 0x30, 0x36, 0x38, 0x63, 0x38, 0x31, 0x37, 0x32, 0x34, 0x62, 0x38, 0x37, 0x65, 0x63, 0x39, 0x62, 0x63, 0x37, 0x34, 0x31, 0x66, 0x62, 0x62, 0x65, 0x66, 0x34, 0x36, 0x37, 0x66, 0x34, 0x35, 0x62, 0x31, 0x62, 0x61, 0x34, 0x33, 0x35, 0x32, 0x31, 0x65, 0x63, 0x31, 0x32, 0x32, 0x64, 0x30, 0x66, 0x37, 0x63, 0x32, 0x65, 0x66, 0x66, 0x62, 0x39, 0x32, 0x61, 0x66, 0x34, 0x36, 0x37, 0x37, 0x65, 0x65, 0x30, 0x37, 0x62, 0x31, 0x61, 0x63, 0x65, 0x38, 0x61, 0x38, 0x61, 0x31, 0x37, 0x34, 0x65, 0x61, 0x61, 0x64, 0x37, 0x62, 0x39, 0x66, 0x38, 0x65, 0x63, 0x37, 0x32, 0x38, 0x61, 0x35, 0x35, 0x66, 0x32, 0x36, 0x37, 0x31, 0x33, 0x36, 0x30, 0x38, 0x34, 0x35, 0x38, 0x33, 0x34, 0x64, 0x64, 0x63, 0x61, 0x37, 0x65, 0x64, 0x38, 0x61, 0x30, 0x32, 0x30, 0x34, 0x39, 0x33, 0x66, 0x31, 0x37, 0x65, 0x34, 0x66, 0x31, 0x37, 0x32, 0x35, 0x35, 0x65, 0x30, 0x66, 0x64, 0x37, 0x30, 0x63, 0x39, 0x64, 0x36, 0x34, 0x35, 0x65, 0x66, 0x30, 0x63, 0x63, 0x30, 0x34, 0x30, 0x30, 0x36, 0x65, 0x33, 0x30, 0x38, 0x61, 0x37, 0x36, 0x30, 0x66, 0x30, 0x34, 0x36, 0x62, 0x62, 0x61, 0x31, 0x30, 0x37, 0x34, 0x35, 0x62, 0x33, 0x62, 0x32, 0x34, 0x39, 0x31, 0x38, 0x34, 0x35, 0x62, 0x62, 0x64, 0x62, 0x31, 0x38, 0x62, 0x36, 0x31, 0x34, 0x37, 0x62, 0x30, 0x38, 0x37, 0x39, 0x64, 0x35, 0x65, 0x39, 0x31, 0x34, 0x38, 0x32, 0x30, 0x32, 0x39, 0x31, 0x36, 0x30, 0x31, 0x65, 0x37, 0x35, 0x39, 0x34, 0x63, 0x31, 0x34, 0x65, 0x34, 0x30, 0x62, 0x61, 0x33, 0x33, 0x61, 0x32, 0x30, 0x64, 0x63, 0x35, 0x64, 0x63, 0x32, 0x39, 0x61, 0x31, 0x33, 0x36, 0x32, 0x32, 0x62, 0x31, 0x31, 0x33, 0x35, 0x39, 0x31, 0x33, 0x31, 0x36, 0x66, 0x36, 0x35, 0x39, 0x64, 0x36, 0x30, 0x64, 0x31, 0x62, 0x38, 0x30, 0x63, 0x30, 0x34, 0x63, 0x35, 0x36, 0x37, 0x64, 0x64, 0x33, 0x37, 0x32, 0x37, 0x32, 0x65, 0x38, 0x36, 0x30, 0x34, 0x33, 0x34, 0x35, 0x37, 0x64, 0x35, 0x61, 0x35, 0x62, 0x62, 0x34, 0x33, 0x38, 0x65, 0x64, 0x35, 0x32, 0x65, 0x62, 0x65, 0x39, 0x37, 0x35, 0x63, 0x61, 0x31, 0x34, 0x37, 0x39, 0x64, 0x61, 0x37, 0x37, 0x65, 0x62, 0x63, 0x66, 0x33, 0x35, 0x66, 0x61, 0x33, 0x66, 0x65, 0x62, 0x31, 0x39, 0x39, 0x34, 0x62, 0x65, 0x38, 0x63, 0x31, 0x30, 0x37, 0x32, 0x30, 0x34, 0x62, 0x34, 0x66, 0x30, 0x30, 0x62, 0x36, 0x32, 0x65, 0x65, 0x63, 0x33, 0x32, 0x65, 0x63, 0x61, 0x65, 0x30, 0x64, 0x35, 0x39, 0x38, 0x33, 0x35, 0x65, 0x39, 0x36, 0x38, 0x62, 0x36, 0x62, 0x34, 0x65, 0x63, 0x30, 0x30, 0x39, 0x66, 0x35, 0x35, 0x38, 0x64, 0x37, 0x34, 0x64, 0x64, 0x39, 0x33, 0x37, 0x65, 0x30, 0x33, 0x30, 0x38, 0x62, 0x31, 0x33, 0x62, 0x31, 0x36, 0x37, 0x32, 0x33, 0x33, 0x30, 0x37, 0x34, 0x39, 0x66, 0x33, 0x38, 0x38, 0x39, 0x33, 0x35, 0x34, 0x64, 0x62, 0x38, 0x64, 0x61, 0x31, 0x38, 0x64, 0x36, 0x33, 0x35, 0x30, 0x62, 0x61, 0x39, 0x32, 0x31, 0x61, 0x65, 0x66, 0x62, 0x34, 0x65, 0x35, 0x63, 0x37, 0x35, 0x32, 0x39, 0x33, 0x66, 0x30, 0x30, 0x66, 0x61, 0x66, 0x64, 0x66, 0x64, 0x34, 0x35, 0x35, 0x66, 0x30, 0x64, 0x32, 0x30, 0x62, 0x37, 0x32, 0x62, 0x65, 0x36, 0x31, 0x30, 0x61, 0x32, 0x36, 0x65, 0x65, 0x63, 0x64, 0x31, 0x35, 0x36, 0x36, 0x36, 0x34, 0x32, 0x62, 0x64, 0x65, 0x63, 0x33, 0x37, 0x62, 0x32, 0x64, 0x39, 0x66, 0x38, 0x65, 0x37, 0x63, 0x37, 0x66, 0x64, 0x64, 0x34, 0x37, 0x34, 0x30, 0x66, 0x37, 0x33, 0x35, 0x30, 0x32, 0x39, 0x35, 0x63, 0x33, 0x63, 0x32, 0x30, 0x37, 0x66, 0x35, 0x36, 0x39, 0x63, 0x30, 0x30, 0x38, 0x34, 0x37, 0x30, 0x61, 0x31, 0x38, 0x31, 0x33, 0x61, 0x33, 0x32, 0x31, 0x65, 0x38, 0x35, 0x30, 0x39, 0x63, 0x33, 0x61, 0x30, 0x39, 0x37, 0x36, 0x30, 0x30, 0x61, 0x37, 0x63, 0x32, 0x38, 0x66, 0x63, 0x35, 0x61, 0x64, 0x62, 0x63, 0x32, 0x62, 0x31, 0x63, 0x64, 0x32, 0x62, 0x33, 0x64, 0x66, 0x34, 0x61, 0x38, 0x66, 0x65, 0x64, 0x35, 0x37, 0x33, 0x33, 0x63, 0x31, 0x38, 0x30, 0x33, 0x34, 0x62, 0x38, 0x38, 0x32, 0x36, 0x31, 0x39, 0x31, 0x38, 0x35, 0x32, 0x34, 0x32, 0x35, 0x34, 0x34, 0x65, 0x31, 0x36, 0x32, 0x63, 0x63, 0x37, 0x65, 0x64, 0x65, 0x61, 0x30, 0x62, 0x61, 0x34, 0x34, 0x38, 0x65, 0x39, 0x35, 0x36, 0x38, 0x31, 0x65, 0x38, 0x33, 0x38, 0x37, 0x38, 0x61, 0x37, 0x38, 0x61, 0x38, 0x64, 0x66, 0x66, 0x39, 0x61, 0x37, 0x35, 0x35, 0x65, 0x32, 0x66, 0x66, 0x37, 0x32, 0x36, 0x62, 0x63, 0x33, 0x34, 0x33, 0x39, 0x33, 0x30, 0x34, 0x66, 0x31, 0x31, 0x66, 0x39, 0x64, 0x63, 0x34, 0x32, 0x34, 0x63, 0x31, 0x62, 0x38, 0x66, 0x30, 0x30, 0x66, 0x37, 0x65, 0x31, 0x32, 0x33, 0x31, 0x64, 0x33, 0x65, 0x30, 0x65, 0x65, 0x39, 0x61, 0x63, 0x33, 0x65, 0x64, 0x32, 0x61, 0x35, 0x65, 0x37, 0x38, 0x36, 0x36, 0x37, 0x31, 0x32, 0x63, 0x34, 0x62, 0x34, 0x64, 0x34, 0x61, 0x64, 0x66, 0x63, 0x39, 0x30, 0x66, 0x37, 0x63, 0x34, 0x31, 0x31, 0x34, 0x32, 0x36, 0x30, 0x33, 0x63, 0x36, 0x63, 0x30, 0x30, 0x36, 0x63, 0x34, 0x65, 0x37, 0x36, 0x63, 0x33, 0x38, 0x32, 0x62, 0x65, 0x38, 0x63, 0x30, 0x62, 0x30, 0x36, 0x64, 0x65, 0x64, 0x30, 0x66, 0x30, 0x32, 0x39, 0x33, 0x66, 0x30, 0x62, 0x39, 0x62, 0x33, 0x34, 0x36, 0x62, 0x32, 0x34, 0x34, 0x30, 0x31, 0x31, 0x37, 0x37, 0x38, 0x38, 0x38, 0x34, 0x64, 0x63, 0x34, 0x66, 0x62, 0x63, 0x33, 0x61, 0x34, 0x32, 0x62, 0x30, 0x38, 0x62, 0x64, 0x37, 0x63, 0x38, 0x64, 0x61, 0x62, 0x37, 0x65, 0x33, 0x31, 0x30, 0x39, 0x35, 0x35, 0x36, 0x39, 0x36, 0x61, 0x37, 0x34, 0x61, 0x30, 0x31, 0x65, 0x66, 0x37, 0x31, 0x33, 0x36, 0x30, 0x63, 0x37, 0x31, 0x66, 0x32, 0x35, 0x39, 0x33, 0x61, 0x38, 0x37, 0x37, 0x37, 0x32, 0x39, 0x36, 0x30, 0x64, 0x63, 0x37, 0x39, 0x61, 0x66, 0x32, 0x66, 0x34, 0x36, 0x35, 0x65, 0x38, 0x32, 0x61, 0x33, 0x39, 0x33, 0x37, 0x39, 0x38, 0x61, 0x34, 0x34, 0x65, 0x62, 0x39, 0x63, 0x39, 0x66, 0x35, 0x64, 0x66, 0x63, 0x32, 0x65, 0x61, 0x31, 0x31, 0x32, 0x66, 0x33, 0x34, 0x38, 0x63, 0x61, 0x38, 0x39, 0x35, 0x38, 0x64, 0x34, 0x61, 0x37, 0x32, 0x35, 0x38, 0x66, 0x65, 0x37, 0x32, 0x38, 0x64, 0x37, 0x38, 0x63, 0x31, 0x39, 0x64, 0x61, 0x36, 0x39, 0x35, 0x37, 0x66, 0x63, 0x37, 0x35, 0x64, 0x64, 0x61, 0x61, 0x31, 0x61, 0x63, 0x63, 0x64, 0x34, 0x33, 0x64, 0x39, 0x39, 0x35, 0x64, 0x65, 0x65, 0x36, 0x39, 0x63, 0x33, 0x63, 0x62, 0x61, 0x39, 0x63, 0x38, 0x64, 0x30, 0x33, 0x63, 0x35, 0x39, 0x31, 0x36, 0x64, 0x64, 0x38, 0x35, 0x63, 0x30, 0x64, 0x35, 0x37, 0x37, 0x32, 0x35, 0x31, 0x37, 0x31, 0x34, 0x66, 0x66, 0x65, 0x32, 0x38, 0x35, 0x61, 0x36, 0x34, 0x63, 0x37, 0x36, 0x38, 0x31, 0x64, 0x65, 0x61, 0x62, 0x37, 0x34, 0x66, 0x62, 0x37, 0x31, 0x64, 0x63, 0x34, 0x37, 0x33, 0x39, 0x39, 0x32, 0x35, 0x39, 0x32, 0x65, 0x37, 0x64, 0x39, 0x36, 0x38, 0x30, 0x62, 0x63, 0x36, 0x35, 0x32, 0x32, 0x61, 0x36, 0x30, 0x30, 0x31, 0x36, 0x38, 0x63, 0x37, 0x37, 0x32, 0x65, 0x36, 0x39, 0x62, 0x30, 0x32, 0x34, 0x34, 0x64, 0x66, 0x65, 0x65, 0x39, 0x65, 0x38, 0x38, 0x37, 0x35, 0x64, 0x30, 0x32, 0x66, 0x33, 0x35, 0x36, 0x31, 0x36, 0x65, 0x36, 0x39, 0x62, 0x62, 0x65, 0x30, 0x30, 0x30, 0x31, 0x36, 0x64, 0x36, 0x30, 0x63, 0x38, 0x64, 0x36, 0x39, 0x66, 0x62, 0x32, 0x37, 0x32, 0x61, 0x64, 0x61, 0x63, 0x61, 0x31, 0x37, 0x61, 0x38, 0x61, 0x64, 0x37, 0x32, 0x31, 0x39, 0x31, 0x65, 0x33, 0x64, 0x62, 0x64, 0x62, 0x37, 0x31, 0x62, 0x33, 0x66, 0x37, 0x35, 0x63, 0x37, 0x63, 0x35, 0x30, 0x36, 0x66, 0x30, 0x64, 0x30, 0x61, 0x38, 0x62, 0x65, 0x30, 0x65, 0x39, 0x37, 0x30, 0x35, 0x30, 0x35, 0x32, 0x36, 0x30, 0x61, 0x63, 0x32, 0x35, 0x38, 0x65, 0x66, 0x31, 0x38, 0x64, 0x30, 0x66, 0x38, 0x38, 0x31, 0x33, 0x37, 0x32, 0x37, 0x34, 0x64, 0x32, 0x36, 0x35, 0x36, 0x65, 0x33, 0x36, 0x39, 0x33, 0x63, 0x32, 0x35, 0x64, 0x30, 0x32, 0x64, 0x62, 0x32, 0x64, 0x36, 0x64, 0x61, 0x65, 0x36, 0x33, 0x32, 0x34, 0x64, 0x62, 0x35, 0x32, 0x33, 0x37, 0x33, 0x32, 0x36, 0x31, 0x62, 0x62, 0x66, 0x31, 0x38, 0x66, 0x61, 0x35, 0x66, 0x62, 0x65, 0x39, 0x31, 0x37, 0x64, 0x39, 0x64, 0x39, 0x65, 0x66, 0x37, 0x34, 0x65, 0x34, 0x36, 0x39, 0x31, 0x30, 0x62, 0x61, 0x34, 0x37, 0x35, 0x64, 0x65, 0x34, 0x34, 0x36, 0x35, 0x34, 0x64, 0x64, 0x64, 0x32, 0x37, 0x66, 0x33, 0x30, 0x30, 0x63, 0x39, 0x63, 0x62, 0x61, 0x35, 0x65, 0x35, 0x36, 0x38, 0x38, 0x37, 0x32, 0x35, 0x62, 0x32, 0x34, 0x33, 0x65, 0x39, 0x39, 0x39, 0x63, 0x62, 0x39, 0x63, 0x66, 0x65, 0x62, 0x65, 0x38, 0x31, 0x64, 0x34, 0x34, 0x39, 0x64, 0x64, 0x31, 0x65, 0x38, 0x61, 0x31, 0x66, 0x63, 0x62, 0x64, 0x32, 0x61, 0x37, 0x61, 0x64, 0x32, 0x63, 0x36, 0x30, 0x35, 0x62, 0x31, 0x31, 0x38, 0x37, 0x64, 0x30, 0x30, 0x35, 0x65, 0x34, 0x63, 0x65, 0x64, 0x65, 0x35, 0x37, 0x65, 0x30, 0x65, 0x62, 0x37, 0x32, 0x64, 0x31, 0x65, 0x39, 0x30, 0x36, 0x35, 0x63, 0x65, 0x36, 0x34, 0x38, 0x33, 0x34, 0x30, 0x63, 0x31, 0x39, 0x64, 0x66, 0x63, 0x35, 0x33, 0x61, 0x31, 0x38, 0x34, 0x61, 0x65, 0x66, 0x35, 0x33, 0x63, 0x65, 0x64, 0x64, 0x61, 0x33, 0x31, 0x61, 0x31, 0x66, 0x36, 0x35, 0x31, 0x65, 0x34, 0x38, 0x37, 0x35, 0x65, 0x66, 0x36, 0x33, 0x39, 0x35, 0x37, 0x64, 0x61, 0x35, 0x34, 0x39, 0x62, 0x66, 0x64, 0x33, 0x36, 0x39, 0x37, 0x33, 0x32, 0x66, 0x39, 0x66, 0x33, 0x61, 0x34, 0x39, 0x32, 0x35, 0x32, 0x30, 0x31, 0x35, 0x32, 0x63, 0x37, 0x61, 0x38, 0x37, 0x36, 0x65, 0x30, 0x66, 0x38, 0x64, 0x61, 0x66, 0x61, 0x37, 0x66, 0x63, 0x34, 0x35, 0x30, 0x64, 0x39, 0x32, 0x33, 0x37, 0x37, 0x31, 0x39, 0x36, 0x65, 0x38, 0x37, 0x37, 0x39, 0x31, 0x36, 0x35, 0x38, 0x64, 0x64, 0x62, 0x61, 0x65, 0x66, 0x33, 0x62, 0x61, 0x37, 0x37, 0x34, 0x34, 0x31, 0x30, 0x63, 0x32, 0x35, 0x65, 0x61, 0x62, 0x36, 0x62, 0x32, 0x32, 0x34, 0x37, 0x37, 0x38, 0x65, 0x30, 0x37, 0x32, 0x66, 0x66, 0x65, 0x33, 0x37, 0x39, 0x37, 0x62, 0x37, 0x61, 0x62, 0x34, 0x31, 0x64, 0x66, 0x37, 0x35, 0x65, 0x38, 0x37, 0x64, 0x31, 0x38, 0x36, 0x37, 0x64, 0x34, 0x30, 0x35, 0x66, 0x34, 0x65, 0x37, 0x62, 0x65, 0x61, 0x30, 0x33, 0x31, 0x61, 0x65, 0x61, 0x30, 0x39, 0x36, 0x63, 0x66, 0x36, 0x32, 0x32, 0x30, 0x32, 0x63, 0x35, 0x30, 0x62, 0x62, 0x62, 0x32, 0x61, 0x39, 0x34, 0x35, 0x64, 0x66, 0x39, 0x38, 0x30, 0x32, 0x32, 0x63, 0x34, 0x34, 0x34, 0x35, 0x32, 0x66, 0x36, 0x32, 0x39, 0x64, 0x35, 0x30, 0x38, 0x66, 0x34, 0x33, 0x36, 0x32, 0x34, 0x36, 0x34, 0x32, 0x61, 0x35, 0x34, 0x33, 0x39, 0x66, 0x31, 0x35, 0x33, 0x37, 0x38, 0x30, 0x37, 0x31, 0x38, 0x38, 0x31, 0x32, 0x65, 0x63, 0x39, 0x62, 0x35, 0x62, 0x30, 0x64, 0x31, 0x30, 0x32, 0x38, 0x37, 0x61, 0x64, 0x37, 0x32, 0x63, 0x37, 0x34, 0x61, 0x36, 0x33, 0x65, 0x39, 0x63, 0x61, 0x35, 0x61, 0x39, 0x34, 0x34, 0x61, 0x63, 0x36, 0x61, 0x35, 0x33, 0x32, 0x66, 0x65, 0x61, 0x34, 0x32, 0x37, 0x66, 0x32, 0x32, 0x65, 0x31, 0x63, 0x38, 0x37, 0x32, 0x33, 0x38, 0x34, 0x61, 0x35, 0x32, 0x62, 0x38, 0x30, 0x37, 0x33, 0x35, 0x33, 0x32, 0x39, 0x64, 0x39, 0x32, 0x66, 0x63, 0x65, 0x66, 0x32, 0x33, 0x64, 0x37, 0x32, 0x65, 0x63, 0x31, 0x64, 0x39, 0x63, 0x36, 0x37, 0x64, 0x37, 0x66, 0x64, 0x34, 0x35, 0x61, 0x37, 0x39, 0x30, 0x34, 0x31, 0x39, 0x38, 0x37, 0x64, 0x37, 0x66, 0x35, 0x35, 0x34, 0x34, 0x39, 0x33, 0x37, 0x32, 0x35, 0x39, 0x63, 0x33, 0x35, 0x30, 0x62, 0x36, 0x64, 0x39, 0x31, 0x35, 0x62, 0x36, 0x61, 0x38, 0x37, 0x30, 0x33, 0x31, 0x33, 0x38, 0x31, 0x30, 0x38, 0x39, 0x36, 0x33, 0x37, 0x32, 0x32, 0x34, 0x34, 0x30, 0x32, 0x31, 0x32, 0x35, 0x61, 0x35, 0x65, 0x39, 0x65, 0x64, 0x32, 0x61, 0x66, 0x33, 0x35, 0x35, 0x32, 0x38, 0x62, 0x30, 0x35, 0x36, 0x64, 0x34, 0x36, 0x33, 0x33, 0x38, 0x63, 0x66, 0x36, 0x35, 0x38, 0x36, 0x38, 0x65, 0x66, 0x33, 0x36, 0x31, 0x31, 0x63, 0x63, 0x64, 0x34, 0x66, 0x33, 0x65, 0x66, 0x64, 0x38, 0x39, 0x36, 0x63, 0x38, 0x39, 0x32, 0x36, 0x31, 0x36, 0x32, 0x65, 0x31, 0x64, 0x33, 0x61, 0x62, 0x61, 0x39, 0x62, 0x66, 0x31, 0x35, 0x33, 0x39, 0x66, 0x64, 0x38, 0x33, 0x34, 0x38, 0x31, 0x37, 0x65, 0x36, 0x62, 0x34, 0x64, 0x39, 0x39, 0x36, 0x37, 0x33, 0x38, 0x65, 0x65, 0x61, 0x39, 0x38, 0x63, 0x65, 0x64, 0x32, 0x39, 0x33, 0x63, 0x63, 0x62, 0x64, 0x62, 0x34, 0x32, 0x31, 0x31, 0x66, 0x30, 0x30, 0x39, 0x39, 0x31, 0x31, 0x64, 0x31, 0x64, 0x30, 0x36, 0x62, 0x32, 0x38, 0x34, 0x36, 0x34, 0x61, 0x33, 0x66, 0x37, 0x35, 0x63, 0x35, 0x36, 0x39, 0x30, 0x38, 0x33, 0x31, 0x36, 0x63, 0x32, 0x30, 0x66, 0x37, 0x61, 0x66, 0x30, 0x39, 0x32, 0x66, 0x33, 0x34, 0x62, 0x39, 0x66, 0x65, 0x34, 0x35, 0x32, 0x62, 0x66, 0x62, 0x62, 0x30, 0x37, 0x32, 0x30, 0x35, 0x65, 0x34, 0x61, 0x30, 0x35, 0x38, 0x61, 0x37, 0x65, 0x32, 0x35, 0x34, 0x62, 0x35, 0x63, 0x39, 0x34, 0x36, 0x64, 0x35, 0x38, 0x66, 0x35, 0x35, 0x39, 0x35, 0x63, 0x39, 0x32, 0x66, 0x30, 0x36, 0x37, 0x32, 0x63, 0x34, 0x32, 0x34, 0x65, 0x34, 0x62, 0x61, 0x33, 0x30, 0x63, 0x33, 0x62, 0x35, 0x30, 0x66, 0x63, 0x32, 0x31, 0x35, 0x35, 0x30, 0x61, 0x37, 0x64, 0x65, 0x37, 0x31, 0x35, 0x33, 0x36, 0x62, 0x64, 0x62, 0x62, 0x39, 0x33, 0x31, 0x34, 0x33, 0x62, 0x37, 0x32, 0x61, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x62, 0x61, 0x38, 0x65, 0x39, 0x39, 0x64, 0x36, 0x31, 0x66, 0x64, 0x30, 0x61, 0x34, 0x32, 0x64, 0x35, 0x33, 0x30, 0x36, 0x36, 0x64, 0x39, 0x38, 0x35, 0x30, 0x36, 0x31, 0x37, 0x61, 0x35, 0x31, 0x66, 0x62, 0x36, 0x62, 0x65, 0x66, 0x33, 0x36, 0x33, 0x33, 0x32, 0x37, 0x33, 0x63, 0x64, 0x39, 0x32, 0x30, 0x33, 0x63, 0x34, 0x61, 0x65, 0x37, 0x31, 0x61, 0x34, 0x35, 0x38, 0x61, 0x36, 0x62, 0x65, 0x62, 0x35, 0x61, 0x62, 0x66, 0x32, 0x35, 0x36, 0x32, 0x38, 0x62, 0x64, 0x30, 0x32, 0x36, 0x34, 0x33, 0x33, 0x38, 0x39, 0x30, 0x61, 0x64, 0x31, 0x62, 0x32, 0x38, 0x65, 0x61, 0x65, 0x62, 0x39, 0x31, 0x34, 0x62, 0x39, 0x34, 0x33, 0x65, 0x64, 0x62, 0x36, 0x36, 0x30, 0x32, 0x33, 0x66, 0x61, 0x66, 0x36, 0x65, 0x35, 0x33, 0x31, 0x36, 0x38, 0x32, 0x33, 0x65, 0x33, 0x64, 0x66, 0x35, 0x64, 0x61, 0x65, 0x66, 0x62, 0x65, 0x37, 0x62, 0x65, 0x64, 0x34, 0x33, 0x34, 0x64, 0x65, 0x35, 0x30, 0x65, 0x30, 0x39, 0x31, 0x35, 0x62, 0x39, 0x66, 0x34, 0x65, 0x34, 0x34, 0x31, 0x63, 0x33, 0x36, 0x34, 0x66, 0x65, 0x38, 0x63, 0x34, 0x64, 0x35, 0x34, 0x39, 0x63, 0x33, 0x61, 0x66, 0x62, 0x66, 0x63, 0x36, 0x35, 0x34, 0x38, 0x39, 0x37, 0x32, 0x64, 0x65, 0x64, 0x32, 0x39, 0x34, 0x32, 0x38, 0x37, 0x37, 0x36, 0x66, 0x30, 0x62, 0x62, 0x62, 0x65, 0x62, 0x31, 0x31, 0x32, 0x64, 0x62, 0x33, 0x61, 0x30, 0x31, 0x61, 0x36, 0x63, 0x63, 0x65, 0x32, 0x63, 0x65, 0x31, 0x62, 0x38, 0x62, 0x30, 0x62, 0x36, 0x38, 0x38, 0x64, 0x39, 0x63, 0x32, 0x39, 0x64, 0x33, 0x39, 0x61, 0x32, 0x61, 0x62, 0x30, 0x63, 0x33, 0x63, 0x38, 0x61, 0x32, 0x36, 0x33, 0x38, 0x66, 0x66, 0x34, 0x30, 0x36, 0x35, 0x64, 0x38, 0x66, 0x66, 0x64, 0x39, 0x38, 0x35, 0x32, 0x36, 0x30, 0x30, 0x32, 0x32, 0x31, 0x64, 0x34, 0x33, 0x30, 0x39, 0x30, 0x37, 0x37, 0x34, 0x34, 0x37, 0x30, 0x30, 0x39, 0x35, 0x61, 0x38, 0x35, 0x64, 0x64, 0x34, 0x61, 0x31, 0x33, 0x37, 0x37, 0x37, 0x36, 0x39, 0x65, 0x66, 0x62, 0x31, 0x31, 0x33, 0x65, 0x65, 0x63, 0x65, 0x30, 0x32, 0x61, 0x30, 0x38, 0x37, 0x39, 0x31, 0x64, 0x32, 0x37, 0x65, 0x35, 0x33, 0x37, 0x34, 0x34, 0x36, 0x65, 0x66, 0x64, 0x33, 0x30, 0x62, 0x35, 0x32, 0x65, 0x39, 0x64, 0x35, 0x36, 0x31, 0x64, 0x32, 0x65, 0x64, 0x62, 0x66, 0x31, 0x35, 0x32, 0x39, 0x37, 0x62, 0x62, 0x63, 0x66, 0x30, 0x65, 0x34, 0x62, 0x61, 0x32, 0x33, 0x38, 0x30, 0x63, 0x63, 0x30, 0x61, 0x61, 0x31, 0x64, 0x61, 0x37, 0x32, 0x32, 0x62, 0x65, 0x30, 0x65, 0x39, 0x66, 0x37, 0x35, 0x32, 0x62, 0x35, 0x35, 0x38, 0x37, 0x64, 0x39, 0x61, 0x32, 0x65, 0x65, 0x62, 0x38, 0x34, 0x36, 0x62, 0x64, 0x62, 0x32, 0x64, 0x65, 0x36, 0x34, 0x37, 0x34, 0x64, 0x65, 0x62, 0x62, 0x62, 0x63, 0x65, 0x32, 0x66, 0x35, 0x31, 0x66, 0x61, 0x39, 0x61, 0x37, 0x65, 0x35, 0x62, 0x64, 0x62, 0x34, 0x37, 0x33, 0x37, 0x35, 0x66, 0x37, 0x32, 0x37, 0x32, 0x65, 0x33, 0x39, 0x30, 0x65, 0x65, 0x62, 0x30, 0x30, 0x31, 0x34, 0x35, 0x61, 0x33, 0x37, 0x31, 0x39, 0x31, 0x34, 0x35, 0x61, 0x30, 0x34, 0x32, 0x35, 0x36, 0x66, 0x33, 0x65, 0x33, 0x30, 0x38, 0x65, 0x64, 0x63, 0x65, 0x33, 0x65, 0x36, 0x34, 0x37, 0x38, 0x62, 0x65, 0x30, 0x65, 0x37, 0x61, 0x34, 0x32, 0x36, 0x64, 0x33, 0x39, 0x38, 0x33, 0x62, 0x38, 0x64, 0x31, 0x37, 0x32, 0x34, 0x65, 0x32, 0x32, 0x31, 0x65, 0x33, 0x35, 0x35, 0x61, 0x38, 0x30, 0x30, 0x30, 0x61, 0x36, 0x32, 0x31, 0x66, 0x63, 0x32, 0x64, 0x37, 0x63, 0x62, 0x61, 0x38, 0x33, 0x66, 0x35, 0x39, 0x30, 0x36, 0x38, 0x64, 0x30, 0x64, 0x64, 0x38, 0x38, 0x37, 0x38, 0x36, 0x32, 0x63, 0x30, 0x30, 0x62, 0x35, 0x64, 0x31, 0x38, 0x65, 0x62, 0x38, 0x61, 0x63, 0x38, 0x61, 0x33, 0x35, 0x37, 0x37, 0x32, 0x66, 0x31, 0x31, 0x61, 0x66, 0x64, 0x33, 0x34, 0x39, 0x38, 0x65, 0x39, 0x31, 0x32, 0x63, 0x38, 0x31, 0x33, 0x34, 0x31, 0x39, 0x61, 0x35, 0x35, 0x61, 0x38, 0x35, 0x38, 0x39, 0x66, 0x34, 0x31, 0x32, 0x64, 0x37, 0x66, 0x62, 0x61, 0x30, 0x39, 0x35, 0x33, 0x33, 0x35, 0x64, 0x34, 0x65, 0x37, 0x34, 0x35, 0x36, 0x62, 0x34, 0x61, 0x38, 0x38, 0x38, 0x35, 0x62, 0x38, 0x38, 0x62, 0x37, 0x32, 0x66, 0x36, 0x64, 0x61, 0x39, 0x64, 0x64, 0x63, 0x37, 0x32, 0x31, 0x65, 0x32, 0x36, 0x39, 0x38, 0x31, 0x37, 0x33, 0x36, 0x34, 0x35, 0x34, 0x65, 0x30, 0x37, 0x32, 0x34, 0x65, 0x38, 0x66, 0x30, 0x38, 0x39, 0x65, 0x61, 0x36, 0x65, 0x61, 0x31, 0x33, 0x63, 0x64, 0x36, 0x61, 0x61, 0x39, 0x30, 0x64, 0x61, 0x34, 0x34, 0x33, 0x39, 0x64, 0x32, 0x66, 0x32, 0x62, 0x37, 0x39, 0x33, 0x36, 0x63, 0x38, 0x62, 0x39, 0x30, 0x66, 0x30, 0x61, 0x62, 0x31, 0x64, 0x62, 0x33, 0x33, 0x66, 0x62, 0x64, 0x66, 0x34, 0x66, 0x38, 0x33, 0x35, 0x64, 0x30, 0x32, 0x64, 0x33, 0x66, 0x35, 0x36, 0x32, 0x37, 0x64, 0x66, 0x61, 0x65, 0x62, 0x63, 0x37, 0x38, 0x62, 0x35, 0x31, 0x65, 0x38, 0x34, 0x38, 0x63, 0x64, 0x34, 0x30, 0x62, 0x64, 0x65, 0x38, 0x39, 0x61, 0x31, 0x31, 0x37, 0x31, 0x30, 0x37, 0x32, 0x31, 0x63, 0x36, 0x61, 0x34, 0x34, 0x31, 0x33, 0x65, 0x34, 0x65, 0x64, 0x38, 0x33, 0x30, 0x39, 0x39, 0x33, 0x36, 0x33, 0x30, 0x61, 0x66, 0x66, 0x37, 0x62, 0x35, 0x36, 0x37, 0x61, 0x39, 0x36, 0x64, 0x63, 0x32, 0x63, 0x30, 0x32, 0x36, 0x30, 0x63, 0x33, 0x32, 0x65, 0x31, 0x62, 0x35, 0x61, 0x34, 0x37, 0x65, 0x61, 0x61, 0x32, 0x33, 0x62, 0x31, 0x35, 0x33, 0x33, 0x62, 0x33, 0x37, 0x32, 0x32, 0x34, 0x61, 0x34, 0x62, 0x31, 0x39, 0x38, 0x32, 0x64, 0x61, 0x39, 0x34, 0x36, 0x33, 0x63, 0x61, 0x34, 0x64, 0x37, 0x37, 0x39, 0x30, 0x65, 0x63, 0x64, 0x38, 0x35, 0x32, 0x62, 0x33, 0x38, 0x35, 0x34, 0x64, 0x38, 0x35, 0x39, 0x35, 0x63, 0x65, 0x32, 0x63, 0x36, 0x36, 0x36, 0x30, 0x39, 0x39, 0x34, 0x32, 0x31, 0x32, 0x35, 0x36, 0x37, 0x30, 0x38, 0x39, 0x64, 0x35, 0x39, 0x37, 0x32, 0x63, 0x38, 0x65, 0x37, 0x31, 0x38, 0x61, 0x33, 0x63, 0x64, 0x63, 0x36, 0x37, 0x34, 0x30, 0x35, 0x61, 0x62, 0x36, 0x32, 0x39, 0x64, 0x32, 0x32, 0x61, 0x65, 0x62, 0x63, 0x34, 0x34, 0x65, 0x34, 0x30, 0x66, 0x62, 0x61, 0x65, 0x61, 0x30, 0x38, 0x33, 0x35, 0x65, 0x38, 0x30, 0x39, 0x66, 0x39, 0x32, 0x34, 0x36, 0x30, 0x34, 0x65, 0x37, 0x63, 0x61, 0x39, 0x63, 0x63, 0x32, 0x62, 0x37, 0x32, 0x35, 0x34, 0x38, 0x31, 0x38, 0x65, 0x39, 0x65, 0x61, 0x35, 0x62, 0x64, 0x66, 0x30, 0x39, 0x65, 0x35, 0x61, 0x39, 0x32, 0x39, 0x36, 0x30, 0x65, 0x34, 0x35, 0x37, 0x37, 0x39, 0x65, 0x64, 0x33, 0x36, 0x30, 0x65, 0x64, 0x35, 0x66, 0x61, 0x30, 0x33, 0x31, 0x66, 0x64, 0x65, 0x65, 0x63, 0x35, 0x36, 0x66, 0x38, 0x38, 0x66, 0x37, 0x35, 0x63, 0x62, 0x35, 0x36, 0x35, 0x36, 0x31, 0x36, 0x36, 0x34, 0x62, 0x64, 0x61, 0x30, 0x61, 0x65, 0x35, 0x63, 0x61, 0x33, 0x65, 0x35, 0x61, 0x37, 0x34, 0x63, 0x38, 0x30, 0x61, 0x64, 0x38, 0x32, 0x33, 0x39, 0x63, 0x63, 0x63, 0x35, 0x65, 0x37, 0x31, 0x64, 0x32, 0x37, 0x66, 0x35, 0x35, 0x31, 0x65, 0x62, 0x31, 0x30, 0x62, 0x62, 0x39, 0x64, 0x64, 0x64, 0x38, 0x33, 0x38, 0x30, 0x35, 0x32, 0x66, 0x38, 0x64, 0x33, 0x32, 0x63, 0x66, 0x35, 0x37, 0x32, 0x30, 0x39, 0x62, 0x61, 0x63, 0x34, 0x62, 0x36, 0x38, 0x33, 0x36, 0x64, 0x63, 0x35, 0x61, 0x61, 0x63, 0x34, 0x63, 0x62, 0x62, 0x61, 0x38, 0x37, 0x63, 0x38, 0x38, 0x66, 0x37, 0x38, 0x66, 0x36, 0x61, 0x32, 0x34, 0x32, 0x36, 0x30, 0x66, 0x37, 0x37, 0x61, 0x32, 0x31, 0x61, 0x33, 0x34, 0x38, 0x65, 0x33, 0x63, 0x34, 0x35, 0x32, 0x64, 0x38, 0x35, 0x66, 0x66, 0x65, 0x39, 0x37, 0x32, 0x35, 0x38, 0x30, 0x34, 0x63, 0x31, 0x62, 0x63, 0x38, 0x33, 0x35, 0x65, 0x34, 0x37, 0x36, 0x38, 0x61, 0x35, 0x34, 0x36, 0x30, 0x63, 0x65, 0x66, 0x63, 0x39, 0x62, 0x64, 0x65, 0x35, 0x36, 0x35, 0x66, 0x37, 0x66, 0x61, 0x61, 0x38, 0x31, 0x39, 0x61, 0x38, 0x61, 0x64, 0x34, 0x38, 0x63, 0x39, 0x36, 0x32, 0x65, 0x61, 0x37, 0x39, 0x61, 0x38, 0x38, 0x35, 0x62, 0x35, 0x35, 0x61, 0x37, 0x32, 0x34, 0x61, 0x32, 0x31, 0x36, 0x61, 0x32, 0x65, 0x64, 0x30, 0x34, 0x64, 0x61, 0x33, 0x63, 0x38, 0x30, 0x35, 0x63, 0x62, 0x36, 0x30, 0x37, 0x64, 0x39, 0x33, 0x33, 0x62, 0x66, 0x33, 0x36, 0x33, 0x34, 0x39, 0x63, 0x39, 0x65, 0x62, 0x62, 0x32, 0x35, 0x64, 0x36, 0x61, 0x39, 0x34, 0x39, 0x64, 0x34, 0x31, 0x66, 0x38, 0x31, 0x63, 0x33, 0x31, 0x61, 0x37, 0x61, 0x66, 0x32, 0x38, 0x37, 0x32, 0x32, 0x61, 0x61, 0x61, 0x35, 0x64, 0x66, 0x61, 0x61, 0x33, 0x61, 0x61, 0x35, 0x63, 0x66, 0x64, 0x66, 0x61, 0x61, 0x30, 0x63, 0x33, 0x37, 0x38, 0x62, 0x33, 0x62, 0x38, 0x64, 0x62, 0x64, 0x32, 0x64, 0x37, 0x62, 0x63, 0x62, 0x65, 0x36, 0x30, 0x33, 0x62, 0x32, 0x66, 0x31, 0x32, 0x32, 0x65, 0x31, 0x37, 0x38, 0x39, 0x37, 0x61, 0x35, 0x65, 0x34, 0x64, 0x35, 0x61, 0x32, 0x34, 0x37, 0x32, 0x36, 0x61, 0x62, 0x36, 0x63, 0x62, 0x32, 0x63, 0x36, 0x65, 0x37, 0x37, 0x35, 0x30, 0x39, 0x61, 0x32, 0x36, 0x65, 0x32, 0x66, 0x38, 0x38, 0x31, 0x38, 0x32, 0x63, 0x33, 0x63, 0x62, 0x31, 0x64, 0x65, 0x66, 0x66, 0x32, 0x39, 0x62, 0x66, 0x33, 0x34, 0x32, 0x37, 0x38, 0x36, 0x38, 0x34, 0x39, 0x30, 0x34, 0x64, 0x34, 0x35, 0x32, 0x66, 0x62, 0x30, 0x35, 0x34, 0x33, 0x39, 0x33, 0x37, 0x32, 0x65, 0x30, 0x66, 0x62, 0x34, 0x62, 0x35, 0x32, 0x62, 0x62, 0x64, 0x65, 0x35, 0x31, 0x30, 0x37, 0x32, 0x39, 0x31, 0x31, 0x39, 0x62, 0x62, 0x35, 0x33, 0x31, 0x39, 0x63, 0x37, 0x35, 0x34, 0x61, 0x63, 0x64, 0x66, 0x32, 0x34, 0x62, 0x64, 0x35, 0x62, 0x32, 0x38, 0x38, 0x31, 0x31, 0x39, 0x39, 0x39, 0x64, 0x39, 0x63, 0x62, 0x31, 0x38, 0x38, 0x34, 0x66, 0x63, 0x31, 0x66, 0x36, 0x37, 0x32, 0x35, 0x62, 0x30, 0x63, 0x35, 0x37, 0x38, 0x38, 0x39, 0x33, 0x33, 0x35, 0x34, 0x64, 0x32, 0x61, 0x63, 0x62, 0x38, 0x32, 0x36, 0x31, 0x61, 0x32, 0x32, 0x66, 0x39, 0x64, 0x35, 0x62, 0x66, 0x62, 0x32, 0x33, 0x64, 0x64, 0x33, 0x64, 0x64, 0x32, 0x66, 0x32, 0x61, 0x33, 0x31, 0x30, 0x39, 0x36, 0x64, 0x31, 0x30, 0x66, 0x63, 0x61, 0x37, 0x31, 0x62, 0x33, 0x30, 0x37, 0x61, 0x30, 0x33, 0x64, 0x36, 0x36, 0x35, 0x61, 0x35, 0x37, 0x66, 0x38, 0x36, 0x35, 0x64, 0x32, 0x31, 0x62, 0x38, 0x37, 0x65, 0x64, 0x66, 0x36, 0x66, 0x37, 0x64, 0x61, 0x64, 0x64, 0x32, 0x62, 0x39, 0x38, 0x39, 0x31, 0x38, 0x35, 0x31, 0x34, 0x65, 0x33, 0x31, 0x64, 0x32, 0x31, 0x63, 0x63, 0x62, 0x30, 0x66, 0x36, 0x34, 0x39, 0x64, 0x64, 0x62, 0x34, 0x37, 0x36, 0x35, 0x61, 0x35, 0x38, 0x31, 0x61, 0x30, 0x64, 0x63, 0x38, 0x38, 0x66, 0x36, 0x38, 0x65, 0x61, 0x31, 0x30, 0x34, 0x61, 0x30, 0x31, 0x34, 0x38, 0x31, 0x39, 0x37, 0x30, 0x63, 0x36, 0x63, 0x32, 0x64, 0x38, 0x32, 0x39, 0x30, 0x62, 0x63, 0x62, 0x63, 0x64, 0x65, 0x31, 0x64, 0x35, 0x39, 0x63, 0x38, 0x36, 0x34, 0x32, 0x35, 0x37, 0x35, 0x64, 0x62, 0x30, 0x61, 0x61, 0x38, 0x38, 0x32, 0x65, 0x31, 0x66, 0x65, 0x65, 0x37, 0x33, 0x37, 0x32, 0x30, 0x36, 0x65, 0x32, 0x65, 0x32, 0x38, 0x63, 0x66, 0x65, 0x36, 0x30, 0x35, 0x61, 0x61, 0x38, 0x39, 0x38, 0x34, 0x36, 0x33, 0x39, 0x32, 0x39, 0x36, 0x36, 0x36, 0x63, 0x66, 0x62, 0x63, 0x31, 0x65, 0x65, 0x32, 0x65, 0x30, 0x34, 0x61, 0x37, 0x63, 0x35, 0x62, 0x31, 0x30, 0x66, 0x64, 0x64, 0x33, 0x37, 0x65, 0x64, 0x38, 0x33, 0x64, 0x33, 0x63, 0x38, 0x30, 0x31, 0x65, 0x32, 0x37, 0x32, 0x38, 0x32, 0x61, 0x30, 0x36, 0x36, 0x35, 0x31, 0x37, 0x63, 0x30, 0x37, 0x62, 0x66, 0x32, 0x65, 0x62, 0x30, 0x34, 0x61, 0x38, 0x32, 0x30, 0x65, 0x39, 0x30, 0x35, 0x64, 0x39, 0x62, 0x66, 0x38, 0x36, 0x31, 0x64, 0x36, 0x62, 0x32, 0x65, 0x31, 0x38, 0x31, 0x31, 0x37, 0x35, 0x65, 0x64, 0x35, 0x38, 0x66, 0x36, 0x36, 0x31, 0x35, 0x64, 0x32, 0x37, 0x33, 0x35, 0x61, 0x32, 0x30, 0x37, 0x32, 0x66, 0x65, 0x33, 0x62, 0x62, 0x61, 0x38, 0x35, 0x65, 0x63, 0x38, 0x38, 0x31, 0x39, 0x62, 0x66, 0x31, 0x33, 0x62, 0x61, 0x32, 0x66, 0x38, 0x63, 0x36, 0x34, 0x30, 0x33, 0x38, 0x33, 0x31, 0x39, 0x34, 0x64, 0x62, 0x37, 0x61, 0x36, 0x63, 0x35, 0x31, 0x66, 0x39, 0x35, 0x39, 0x63, 0x39, 0x37, 0x38, 0x34, 0x31, 0x38, 0x62, 0x36, 0x39, 0x63, 0x31, 0x62, 0x65, 0x63, 0x35, 0x62, 0x33, 0x65, 0x35, 0x35, 0x64, 0x66, 0x37, 0x39, 0x37, 0x39, 0x65, 0x39, 0x65, 0x62, 0x30, 0x34, 0x33, 0x31, 0x61, 0x34, 0x65, 0x61, 0x65, 0x32, 0x65, 0x66, 0x38, 0x30, 0x64, 0x37, 0x39, 0x34, 0x64, 0x39, 0x63, 0x65, 0x38, 0x37, 0x39, 0x65, 0x64, 0x31, 0x38, 0x39, 0x62, 0x63, 0x65, 0x63, 0x39, 0x31, 0x33, 0x33, 0x36, 0x61, 0x66, 0x63, 0x61, 0x32, 0x34, 0x39, 0x34, 0x36, 0x62, 0x64, 0x37, 0x32, 0x32, 0x65, 0x36, 0x62, 0x64, 0x35, 0x39, 0x32, 0x38, 0x61, 0x65, 0x37, 0x64, 0x30, 0x66, 0x63, 0x34, 0x62, 0x65, 0x63, 0x33, 0x31, 0x61, 0x62, 0x36, 0x39, 0x37, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x63, 0x36, 0x39, 0x32, 0x33, 0x63, 0x62, 0x62, 0x64, 0x37, 0x62, 0x65, 0x63, 0x35, 0x37, 0x31, 0x38, 0x36, 0x31, 0x61, 0x32, 0x35, 0x64, 0x61, 0x35, 0x31, 0x33, 0x37, 0x39, 0x36, 0x31, 0x31, 0x36, 0x34, 0x30, 0x31, 0x30, 0x31, 0x34, 0x39, 0x33, 0x63, 0x35, 0x31, 0x38, 0x36, 0x39, 0x32, 0x66, 0x30, 0x30, 0x64, 0x35, 0x34, 0x39, 0x35, 0x64, 0x39, 0x31, 0x65, 0x32, 0x63, 0x30, 0x37, 0x34, 0x33, 0x37, 0x34, 0x36, 0x33, 0x62, 0x35, 0x37, 0x37, 0x63, 0x30, 0x35, 0x32, 0x62, 0x37, 0x34, 0x37, 0x61, 0x37, 0x37, 0x33, 0x34, 0x39, 0x37, 0x33, 0x32, 0x64, 0x38, 0x37, 0x32, 0x36, 0x39, 0x35, 0x64, 0x39, 0x33, 0x30, 0x38, 0x38, 0x63, 0x38, 0x64, 0x38, 0x65, 0x61, 0x35, 0x61, 0x63, 0x39, 0x38, 0x31, 0x62, 0x30, 0x62, 0x35, 0x64, 0x66, 0x30, 0x63, 0x31, 0x33, 0x30, 0x39, 0x66, 0x30, 0x62, 0x62, 0x66, 0x62, 0x62, 0x33, 0x61, 0x39, 0x61, 0x30, 0x39, 0x35, 0x34, 0x36, 0x35, 0x35, 0x35, 0x30, 0x62, 0x37, 0x65, 0x37, 0x36, 0x34, 0x63, 0x32, 0x34, 0x36, 0x34, 0x63, 0x34, 0x64, 0x38, 0x39, 0x34, 0x64, 0x33, 0x61, 0x65, 0x38, 0x66, 0x65, 0x30, 0x37, 0x35, 0x64, 0x33, 0x63, 0x37, 0x64, 0x63, 0x33, 0x32, 0x66, 0x62, 0x34, 0x34, 0x34, 0x63, 0x61, 0x66, 0x33, 0x36, 0x30, 0x63, 0x61, 0x38, 0x33, 0x37, 0x30, 0x32, 0x35, 0x66, 0x63, 0x65, 0x66, 0x65, 0x34, 0x63, 0x30, 0x62, 0x30, 0x63, 0x30, 0x62, 0x63, 0x36, 0x38, 0x63, 0x65, 0x35, 0x33, 0x35, 0x30, 0x61, 0x33, 0x37, 0x33, 0x37, 0x32, 0x32, 0x30, 0x64, 0x64, 0x38, 0x65, 0x64, 0x30, 0x62, 0x64, 0x33, 0x30, 0x62, 0x36, 0x62, 0x61, 0x64, 0x33, 0x30, 0x35, 0x36, 0x64, 0x66, 0x66, 0x39, 0x64, 0x61, 0x38, 0x34, 0x34, 0x35, 0x36, 0x64, 0x34, 0x32, 0x63, 0x37, 0x64, 0x36, 0x31, 0x33, 0x32, 0x65, 0x37, 0x31, 0x61, 0x64, 0x64, 0x65, 0x63, 0x35, 0x33, 0x31, 0x32, 0x62, 0x37, 0x32, 0x33, 0x36, 0x32, 0x34, 0x32, 0x33, 0x62, 0x33, 0x31, 0x38, 0x63, 0x36, 0x66, 0x33, 0x31, 0x39, 0x37, 0x66, 0x62, 0x61, 0x62, 0x36, 0x61, 0x34, 0x37, 0x36, 0x30, 0x66, 0x66, 0x34, 0x38, 0x33, 0x36, 0x38, 0x62, 0x66, 0x66, 0x32, 0x36, 0x38, 0x38, 0x66, 0x33, 0x36, 0x36, 0x38, 0x37, 0x62, 0x31, 0x64, 0x37, 0x39, 0x61, 0x30, 0x62, 0x33, 0x35, 0x35, 0x65, 0x33, 0x36, 0x33, 0x37, 0x32, 0x63, 0x34, 0x35, 0x34, 0x65, 0x63, 0x32, 0x37, 0x64, 0x65, 0x66, 0x31, 0x65, 0x35, 0x66, 0x35, 0x34, 0x35, 0x64, 0x35, 0x63, 0x61, 0x63, 0x35, 0x30, 0x37, 0x36, 0x38, 0x63, 0x38, 0x61, 0x30, 0x65, 0x35, 0x36, 0x65, 0x65, 0x62, 0x39, 0x30, 0x65, 0x64, 0x33, 0x31, 0x39, 0x33, 0x33, 0x32, 0x62, 0x33, 0x39, 0x37, 0x31, 0x66, 0x66, 0x64, 0x32, 0x62, 0x36, 0x33, 0x65, 0x30, 0x37, 0x32, 0x32, 0x37, 0x33, 0x64, 0x39, 0x35, 0x34, 0x63, 0x65, 0x30, 0x33, 0x64, 0x38, 0x66, 0x30, 0x61, 0x30, 0x33, 0x36, 0x65, 0x32, 0x31, 0x61, 0x36, 0x63, 0x33, 0x62, 0x34, 0x34, 0x31, 0x37, 0x65, 0x31, 0x66, 0x62, 0x35, 0x66, 0x63, 0x64, 0x34, 0x61, 0x66, 0x37, 0x38, 0x32, 0x66, 0x33, 0x36, 0x39, 0x35, 0x33, 0x38, 0x66, 0x38, 0x65, 0x37, 0x65, 0x32, 0x39, 0x34, 0x36, 0x66, 0x37, 0x32, 0x62, 0x64, 0x30, 0x35, 0x63, 0x37, 0x36, 0x62, 0x64, 0x66, 0x66, 0x30, 0x34, 0x64, 0x63, 0x62, 0x30, 0x66, 0x63, 0x36, 0x31, 0x34, 0x30, 0x39, 0x31, 0x61, 0x30, 0x66, 0x62, 0x32, 0x33, 0x37, 0x38, 0x32, 0x39, 0x66, 0x61, 0x39, 0x33, 0x65, 0x64, 0x37, 0x31, 0x63, 0x66, 0x63, 0x36, 0x34, 0x36, 0x66, 0x32, 0x35, 0x35, 0x30, 0x37, 0x64, 0x62, 0x66, 0x32, 0x30, 0x37, 0x66, 0x36, 0x66, 0x37, 0x62, 0x36, 0x66, 0x61, 0x35, 0x33, 0x38, 0x61, 0x65, 0x62, 0x37, 0x37, 0x33, 0x61, 0x37, 0x61, 0x63, 0x62, 0x65, 0x31, 0x61, 0x37, 0x37, 0x64, 0x63, 0x63, 0x66, 0x32, 0x65, 0x62, 0x65, 0x30, 0x63, 0x39, 0x64, 0x32, 0x66, 0x31, 0x31, 0x38, 0x30, 0x31, 0x32, 0x61, 0x31, 0x36, 0x33, 0x31, 0x66, 0x61, 0x31, 0x35, 0x34, 0x64, 0x30, 0x65, 0x31, 0x63, 0x34, 0x63, 0x36, 0x37, 0x32, 0x39, 0x35, 0x35, 0x62, 0x62, 0x64, 0x39, 0x37, 0x65, 0x31, 0x65, 0x34, 0x30, 0x36, 0x33, 0x31, 0x39, 0x64, 0x65, 0x35, 0x35, 0x31, 0x64, 0x37, 0x31, 0x38, 0x63, 0x38, 0x61, 0x36, 0x61, 0x33, 0x32, 0x65, 0x37, 0x66, 0x31, 0x34, 0x66, 0x39, 0x35, 0x64, 0x63, 0x31, 0x62, 0x31, 0x37, 0x63, 0x36, 0x37, 0x65, 0x62, 0x39, 0x61, 0x32, 0x65, 0x30, 0x31, 0x61, 0x65, 0x66, 0x34, 0x35, 0x64, 0x63, 0x30, 0x37, 0x30, 0x37, 0x65, 0x39, 0x36, 0x36, 0x62, 0x31, 0x32, 0x39, 0x36, 0x39, 0x62, 0x35, 0x35, 0x32, 0x39, 0x34, 0x61, 0x32, 0x63, 0x62, 0x66, 0x62, 0x35, 0x36, 0x36, 0x36, 0x66, 0x62, 0x61, 0x39, 0x31, 0x63, 0x33, 0x39, 0x32, 0x36, 0x38, 0x31, 0x37, 0x39, 0x32, 0x37, 0x61, 0x36, 0x31, 0x63, 0x34, 0x65, 0x65, 0x37, 0x36, 0x39, 0x63, 0x34, 0x33, 0x39, 0x36, 0x37, 0x32, 0x63, 0x65, 0x63, 0x62, 0x33, 0x63, 0x66, 0x34, 0x62, 0x66, 0x35, 0x65, 0x65, 0x63, 0x63, 0x35, 0x62, 0x61, 0x64, 0x66, 0x33, 0x31, 0x63, 0x32, 0x39, 0x62, 0x63, 0x34, 0x30, 0x33, 0x34, 0x34, 0x64, 0x34, 0x61, 0x63, 0x32, 0x36, 0x31, 0x35, 0x38, 0x38, 0x32, 0x31, 0x33, 0x65, 0x30, 0x37, 0x36, 0x37, 0x61, 0x31, 0x61, 0x36, 0x30, 0x35, 0x33, 0x63, 0x38, 0x38, 0x33, 0x38, 0x37, 0x32, 0x34, 0x63, 0x38, 0x61, 0x38, 0x65, 0x63, 0x65, 0x66, 0x37, 0x36, 0x37, 0x64, 0x39, 0x33, 0x33, 0x30, 0x61, 0x35, 0x37, 0x35, 0x33, 0x30, 0x61, 0x63, 0x62, 0x38, 0x63, 0x39, 0x66, 0x64, 0x31, 0x65, 0x36, 0x66, 0x35, 0x62, 0x33, 0x63, 0x62, 0x61, 0x61, 0x39, 0x30, 0x30, 0x38, 0x39, 0x61, 0x66, 0x62, 0x34, 0x35, 0x35, 0x32, 0x30, 0x63, 0x32, 0x32, 0x32, 0x34, 0x32, 0x36, 0x32, 0x39, 0x38, 0x38, 0x63, 0x33, 0x34, 0x32, 0x37, 0x35, 0x61, 0x35, 0x36, 0x37, 0x38, 0x33, 0x65, 0x31, 0x63, 0x62, 0x63, 0x34, 0x32, 0x30, 0x37, 0x39, 0x62, 0x30, 0x37, 0x61, 0x62, 0x66, 0x34, 0x31, 0x34, 0x65, 0x35, 0x39, 0x32, 0x31, 0x39, 0x33, 0x36, 0x38, 0x36, 0x34, 0x33, 0x66, 0x31, 0x63, 0x32, 0x62, 0x64, 0x36, 0x61, 0x64, 0x39, 0x37, 0x34, 0x36, 0x33, 0x62, 0x31, 0x38, 0x33, 0x39, 0x62, 0x31, 0x66, 0x65, 0x62, 0x63, 0x35, 0x37, 0x38, 0x34, 0x35, 0x39, 0x62, 0x61, 0x35, 0x35, 0x61, 0x30, 0x31, 0x66, 0x39, 0x31, 0x34, 0x30, 0x36, 0x38, 0x32, 0x66, 0x61, 0x35, 0x35, 0x65, 0x30, 0x61, 0x61, 0x66, 0x35, 0x66, 0x32, 0x38, 0x61, 0x34, 0x37, 0x65, 0x36, 0x38, 0x33, 0x32, 0x63, 0x63, 0x61, 0x62, 0x31, 0x31, 0x38, 0x36, 0x39, 0x64, 0x35, 0x66, 0x34, 0x36, 0x33, 0x65, 0x34, 0x32, 0x35, 0x30, 0x38, 0x66, 0x65, 0x66, 0x39, 0x32, 0x33, 0x30, 0x64, 0x30, 0x63, 0x64, 0x63, 0x32, 0x66, 0x32, 0x65, 0x34, 0x63, 0x38, 0x64, 0x30, 0x30, 0x61, 0x30, 0x35, 0x62, 0x37, 0x62, 0x34, 0x31, 0x35, 0x37, 0x66, 0x65, 0x30, 0x37, 0x36, 0x65, 0x61, 0x65, 0x65, 0x31, 0x66, 0x61, 0x61, 0x34, 0x30, 0x34, 0x39, 0x66, 0x64, 0x64, 0x39, 0x32, 0x64, 0x61, 0x35, 0x37, 0x32, 0x65, 0x32, 0x34, 0x34, 0x32, 0x36, 0x33, 0x32, 0x64, 0x37, 0x63, 0x36, 0x36, 0x31, 0x39, 0x38, 0x39, 0x31, 0x61, 0x38, 0x31, 0x61, 0x64, 0x31, 0x36, 0x38, 0x39, 0x65, 0x65, 0x33, 0x35, 0x34, 0x65, 0x34, 0x62, 0x38, 0x65, 0x38, 0x64, 0x31, 0x37, 0x66, 0x32, 0x32, 0x64, 0x36, 0x62, 0x32, 0x37, 0x34, 0x62, 0x39, 0x35, 0x30, 0x64, 0x34, 0x36, 0x36, 0x64, 0x37, 0x33, 0x66, 0x32, 0x34, 0x31, 0x35, 0x65, 0x33, 0x31, 0x64, 0x65, 0x64, 0x33, 0x35, 0x31, 0x32, 0x65, 0x33, 0x31, 0x35, 0x64, 0x30, 0x33, 0x65, 0x61, 0x66, 0x34, 0x39, 0x62, 0x37, 0x61, 0x30, 0x35, 0x62, 0x31, 0x33, 0x35, 0x66, 0x63, 0x65, 0x61, 0x39, 0x32, 0x65, 0x65, 0x39, 0x33, 0x63, 0x66, 0x66, 0x62, 0x32, 0x34, 0x66, 0x37, 0x38, 0x30, 0x33, 0x34, 0x65, 0x66, 0x37, 0x31, 0x35, 0x64, 0x65, 0x33, 0x38, 0x36, 0x39, 0x30, 0x38, 0x39, 0x65, 0x62, 0x37, 0x62, 0x32, 0x65, 0x32, 0x34, 0x36, 0x36, 0x33, 0x66, 0x31, 0x62, 0x36, 0x64, 0x63, 0x61, 0x33, 0x30, 0x61, 0x38, 0x62, 0x63, 0x61, 0x39, 0x35, 0x35, 0x64, 0x39, 0x30, 0x62, 0x35, 0x63, 0x31, 0x35, 0x39, 0x64, 0x34, 0x33, 0x32, 0x37, 0x38, 0x39, 0x36, 0x64, 0x30, 0x32, 0x37, 0x32, 0x33, 0x36, 0x31, 0x38, 0x64, 0x30, 0x35, 0x37, 0x32, 0x39, 0x65, 0x39, 0x38, 0x64, 0x34, 0x64, 0x37, 0x62, 0x37, 0x30, 0x34, 0x30, 0x36, 0x34, 0x61, 0x30, 0x61, 0x31, 0x62, 0x64, 0x65, 0x64, 0x61, 0x66, 0x39, 0x65, 0x66, 0x31, 0x30, 0x37, 0x33, 0x35, 0x33, 0x63, 0x62, 0x64, 0x35, 0x62, 0x32, 0x36, 0x33, 0x32, 0x31, 0x31, 0x36, 0x66, 0x38, 0x33, 0x34, 0x63, 0x34, 0x64, 0x64, 0x30, 0x64, 0x34, 0x36, 0x36, 0x30, 0x37, 0x36, 0x37, 0x32, 0x30, 0x66, 0x65, 0x34, 0x32, 0x63, 0x30, 0x62, 0x30, 0x35, 0x64, 0x36, 0x30, 0x35, 0x63, 0x61, 0x37, 0x61, 0x35, 0x30, 0x37, 0x61, 0x37, 0x62, 0x63, 0x66, 0x64, 0x32, 0x38, 0x32, 0x63, 0x35, 0x39, 0x62, 0x34, 0x38, 0x61, 0x65, 0x34, 0x35, 0x66, 0x39, 0x35, 0x64, 0x33, 0x62, 0x34, 0x34, 0x37, 0x62, 0x32, 0x65, 0x38, 0x36, 0x33, 0x61, 0x32, 0x33, 0x37, 0x33, 0x35, 0x38, 0x37, 0x32, 0x62, 0x66, 0x31, 0x37, 0x35, 0x34, 0x36, 0x39, 0x62, 0x31, 0x62, 0x33, 0x65, 0x34, 0x38, 0x35, 0x33, 0x30, 0x32, 0x63, 0x38, 0x63, 0x62, 0x36, 0x32, 0x66, 0x35, 0x66, 0x32, 0x64, 0x39, 0x33, 0x63, 0x32, 0x38, 0x34, 0x31, 0x65, 0x62, 0x38, 0x63, 0x34, 0x30, 0x32, 0x65, 0x34, 0x66, 0x33, 0x39, 0x36, 0x31, 0x64, 0x32, 0x63, 0x30, 0x36, 0x64, 0x63, 0x31, 0x31, 0x31, 0x62, 0x37, 0x32, 0x31, 0x34, 0x63, 0x61, 0x36, 0x39, 0x35, 0x61, 0x65, 0x31, 0x65, 0x65, 0x38, 0x66, 0x66, 0x32, 0x34, 0x61, 0x32, 0x66, 0x32, 0x36, 0x64, 0x64, 0x35, 0x38, 0x62, 0x36, 0x65, 0x65, 0x37, 0x37, 0x35, 0x35, 0x36, 0x37, 0x63, 0x34, 0x35, 0x34, 0x64, 0x62, 0x65, 0x61, 0x37, 0x39, 0x34, 0x33, 0x64, 0x64, 0x32, 0x37, 0x65, 0x62, 0x62, 0x34, 0x35, 0x37, 0x31, 0x61, 0x33, 0x37, 0x36, 0x33, 0x38, 0x31, 0x61, 0x64, 0x35, 0x35, 0x34, 0x66, 0x65, 0x32, 0x37, 0x35, 0x61, 0x37, 0x63, 0x33, 0x63, 0x65, 0x38, 0x38, 0x34, 0x38, 0x65, 0x62, 0x39, 0x62, 0x38, 0x35, 0x63, 0x33, 0x33, 0x33, 0x36, 0x35, 0x30, 0x64, 0x31, 0x32, 0x34, 0x61, 0x66, 0x34, 0x34, 0x32, 0x38, 0x33, 0x30, 0x39, 0x66, 0x30, 0x66, 0x62, 0x31, 0x35, 0x38, 0x62, 0x64, 0x39, 0x66, 0x37, 0x37, 0x37, 0x37, 0x32, 0x35, 0x36, 0x33, 0x38, 0x39, 0x32, 0x65, 0x65, 0x62, 0x36, 0x35, 0x31, 0x36, 0x66, 0x32, 0x35, 0x64, 0x39, 0x64, 0x31, 0x65, 0x36, 0x35, 0x35, 0x64, 0x63, 0x37, 0x33, 0x35, 0x35, 0x39, 0x37, 0x61, 0x32, 0x36, 0x66, 0x32, 0x64, 0x66, 0x35, 0x66, 0x63, 0x36, 0x39, 0x36, 0x61, 0x35, 0x32, 0x62, 0x38, 0x30, 0x34, 0x65, 0x30, 0x39, 0x62, 0x35, 0x64, 0x39, 0x30, 0x34, 0x62, 0x37, 0x32, 0x34, 0x61, 0x63, 0x35, 0x65, 0x35, 0x64, 0x36, 0x65, 0x66, 0x33, 0x37, 0x63, 0x36, 0x65, 0x65, 0x62, 0x63, 0x35, 0x33, 0x61, 0x38, 0x35, 0x34, 0x37, 0x33, 0x32, 0x31, 0x39, 0x64, 0x34, 0x31, 0x34, 0x31, 0x38, 0x61, 0x34, 0x38, 0x31, 0x31, 0x64, 0x66, 0x38, 0x61, 0x34, 0x33, 0x33, 0x36, 0x30, 0x31, 0x37, 0x31, 0x35, 0x61, 0x39, 0x62, 0x66, 0x35, 0x66, 0x36, 0x35, 0x64, 0x37, 0x32, 0x31, 0x62, 0x34, 0x38, 0x36, 0x66, 0x36, 0x37, 0x33, 0x31, 0x35, 0x32, 0x65, 0x35, 0x64, 0x39, 0x65, 0x66, 0x32, 0x30, 0x31, 0x37, 0x34, 0x39, 0x36, 0x35, 0x33, 0x32, 0x62, 0x63, 0x31, 0x36, 0x61, 0x33, 0x65, 0x35, 0x66, 0x65, 0x66, 0x65, 0x61, 0x64, 0x31, 0x36, 0x32, 0x38, 0x62, 0x66, 0x35, 0x62, 0x62, 0x31, 0x32, 0x37, 0x39, 0x62, 0x33, 0x36, 0x39, 0x37, 0x32, 0x61, 0x35, 0x34, 0x64, 0x31, 0x66, 0x32, 0x31, 0x62, 0x38, 0x62, 0x31, 0x32, 0x35, 0x35, 0x34, 0x32, 0x33, 0x38, 0x33, 0x30, 0x33, 0x31, 0x31, 0x35, 0x64, 0x34, 0x34, 0x66, 0x62, 0x33, 0x36, 0x64, 0x32, 0x37, 0x33, 0x31, 0x31, 0x65, 0x34, 0x33, 0x66, 0x33, 0x30, 0x65, 0x36, 0x62, 0x63, 0x33, 0x39, 0x64, 0x38, 0x63, 0x30, 0x63, 0x62, 0x33, 0x66, 0x61, 0x31, 0x30, 0x65, 0x65, 0x35, 0x62, 0x37, 0x32, 0x39, 0x36, 0x32, 0x30, 0x38, 0x34, 0x33, 0x63, 0x34, 0x34, 0x38, 0x38, 0x39, 0x39, 0x61, 0x30, 0x38, 0x39, 0x38, 0x39, 0x61, 0x35, 0x61, 0x38, 0x30, 0x38, 0x38, 0x32, 0x61, 0x38, 0x35, 0x61, 0x37, 0x65, 0x36, 0x39, 0x66, 0x39, 0x33, 0x34, 0x65, 0x66, 0x62, 0x32, 0x62, 0x39, 0x37, 0x65, 0x32, 0x36, 0x39, 0x32, 0x32, 0x61, 0x34, 0x65, 0x35, 0x31, 0x65, 0x37, 0x32, 0x66, 0x37, 0x32, 0x39, 0x63, 0x36, 0x38, 0x65, 0x32, 0x61, 0x65, 0x61, 0x36, 0x38, 0x36, 0x37, 0x34, 0x38, 0x38, 0x32, 0x39, 0x65, 0x34, 0x65, 0x62, 0x32, 0x61, 0x32, 0x37, 0x37, 0x63, 0x63, 0x39, 0x34, 0x36, 0x61, 0x31, 0x36, 0x31, 0x62, 0x34, 0x38, 0x63, 0x32, 0x61, 0x34, 0x64, 0x61, 0x30, 0x62, 0x31, 0x64, 0x34, 0x63, 0x35, 0x30, 0x30, 0x36, 0x35, 0x32, 0x32, 0x32, 0x61, 0x66, 0x63, 0x32, 0x37, 0x61, 0x63, 0x30, 0x30, 0x34, 0x37, 0x63, 0x64, 0x31, 0x31, 0x39, 0x32, 0x66, 0x65, 0x37, 0x66, 0x36, 0x30, 0x36, 0x32, 0x30, 0x64, 0x31, 0x30, 0x30, 0x61, 0x36, 0x37, 0x66, 0x31, 0x32, 0x35, 0x33, 0x38, 0x37, 0x32, 0x30, 0x37, 0x64, 0x38, 0x63, 0x34, 0x33, 0x35, 0x31, 0x36, 0x32, 0x33, 0x31, 0x36, 0x31, 0x66, 0x63, 0x63, 0x38, 0x66, 0x34, 0x61, 0x66, 0x63, 0x34, 0x35, 0x37, 0x32, 0x35, 0x61, 0x36, 0x66, 0x32, 0x30, 0x33, 0x38, 0x66, 0x65, 0x66, 0x31, 0x63, 0x35, 0x63, 0x65, 0x38, 0x39, 0x66, 0x65, 0x34, 0x63, 0x61, 0x35, 0x39, 0x61, 0x31, 0x39, 0x33, 0x65, 0x32, 0x30, 0x62, 0x64, 0x63, 0x39, 0x35, 0x61, 0x61, 0x38, 0x65, 0x38, 0x37, 0x33, 0x62, 0x30, 0x66, 0x32, 0x39, 0x34, 0x37, 0x35, 0x38, 0x65, 0x65, 0x61, 0x62, 0x33, 0x30, 0x32, 0x31, 0x35, 0x36, 0x62, 0x61, 0x32, 0x39, 0x34, 0x63, 0x38, 0x61, 0x38, 0x66, 0x66, 0x65, 0x66, 0x34, 0x63, 0x35, 0x30, 0x33, 0x34, 0x64, 0x66, 0x63, 0x64, 0x38, 0x31, 0x34, 0x66, 0x66, 0x37, 0x30, 0x36, 0x61, 0x39, 0x35, 0x62, 0x65, 0x38, 0x65, 0x31, 0x63, 0x64, 0x31, 0x61, 0x32, 0x62, 0x37, 0x64, 0x30, 0x66, 0x37, 0x35, 0x32, 0x32, 0x62, 0x62, 0x37, 0x62, 0x61, 0x36, 0x33, 0x39, 0x66, 0x39, 0x37, 0x32, 0x30, 0x30, 0x32, 0x36, 0x38, 0x33, 0x33, 0x38, 0x34, 0x63, 0x33, 0x62, 0x31, 0x36, 0x64, 0x32, 0x62, 0x39, 0x31, 0x39, 0x66, 0x38, 0x63, 0x66, 0x36, 0x36, 0x64, 0x34, 0x38, 0x37, 0x63, 0x33, 0x34, 0x65, 0x39, 0x63, 0x38, 0x35, 0x32, 0x35, 0x66, 0x39, 0x31, 0x30, 0x35, 0x65, 0x61, 0x66, 0x31, 0x38, 0x63, 0x30, 0x37, 0x66, 0x30, 0x35, 0x31, 0x33, 0x64, 0x35, 0x35, 0x30, 0x35, 0x64, 0x64, 0x61, 0x35, 0x32, 0x31, 0x66, 0x36, 0x61, 0x62, 0x34, 0x66, 0x36, 0x62, 0x62, 0x38, 0x64, 0x61, 0x30, 0x33, 0x61, 0x34, 0x38, 0x35, 0x37, 0x39, 0x35, 0x30, 0x65, 0x34, 0x33, 0x30, 0x33, 0x33, 0x31, 0x39, 0x35, 0x63, 0x38, 0x63, 0x38, 0x32, 0x63, 0x30, 0x34, 0x66, 0x39, 0x61, 0x37, 0x63, 0x61, 0x33, 0x38, 0x34, 0x36, 0x37, 0x34, 0x35, 0x63, 0x61, 0x36, 0x64, 0x65, 0x37, 0x32, 0x39, 0x62, 0x66, 0x31, 0x32, 0x34, 0x66, 0x39, 0x35, 0x32, 0x36, 0x35, 0x33, 0x63, 0x63, 0x36, 0x34, 0x31, 0x36, 0x61, 0x65, 0x66, 0x31, 0x34, 0x37, 0x37, 0x61, 0x32, 0x32, 0x31, 0x33, 0x38, 0x38, 0x39, 0x34, 0x33, 0x62, 0x64, 0x38, 0x32, 0x37, 0x30, 0x66, 0x39, 0x65, 0x30, 0x33, 0x35, 0x39, 0x66, 0x33, 0x32, 0x61, 0x66, 0x39, 0x30, 0x37, 0x64, 0x65, 0x61, 0x33, 0x63, 0x37, 0x32, 0x31, 0x31, 0x30, 0x36, 0x64, 0x35, 0x39, 0x33, 0x30, 0x36, 0x39, 0x65, 0x64, 0x30, 0x37, 0x34, 0x66, 0x35, 0x66, 0x61, 0x30, 0x31, 0x32, 0x35, 0x36, 0x63, 0x38, 0x35, 0x64, 0x61, 0x39, 0x30, 0x38, 0x33, 0x31, 0x63, 0x34, 0x38, 0x37, 0x61, 0x61, 0x63, 0x31, 0x66, 0x39, 0x34, 0x35, 0x61, 0x66, 0x62, 0x36, 0x32, 0x34, 0x65, 0x32, 0x36, 0x39, 0x30, 0x39, 0x36, 0x31, 0x35, 0x36, 0x38, 0x38, 0x30, 0x33, 0x65, 0x32, 0x34, 0x31, 0x38, 0x35, 0x64, 0x61, 0x33, 0x32, 0x38, 0x64, 0x63, 0x65, 0x63, 0x37, 0x35, 0x34, 0x33, 0x34, 0x32, 0x34, 0x39, 0x65, 0x34, 0x35, 0x32, 0x39, 0x30, 0x31, 0x30, 0x30, 0x31, 0x34, 0x62, 0x64, 0x65, 0x62, 0x38, 0x35, 0x65, 0x30, 0x61, 0x61, 0x65, 0x66, 0x33, 0x34, 0x37, 0x30, 0x64, 0x35, 0x65, 0x63, 0x34, 0x30, 0x39, 0x66, 0x36, 0x37, 0x32, 0x36, 0x30, 0x31, 0x61, 0x38, 0x39, 0x33, 0x34, 0x66, 0x39, 0x35, 0x32, 0x34, 0x30, 0x33, 0x30, 0x65, 0x31, 0x35, 0x63, 0x33, 0x63, 0x63, 0x35, 0x39, 0x38, 0x33, 0x62, 0x36, 0x32, 0x65, 0x66, 0x32, 0x31, 0x35, 0x62, 0x65, 0x33, 0x64, 0x35, 0x34, 0x30, 0x32, 0x39, 0x65, 0x31, 0x61, 0x32, 0x65, 0x39, 0x66, 0x35, 0x32, 0x30, 0x62, 0x35, 0x34, 0x32, 0x38, 0x37, 0x39, 0x37, 0x35, 0x36, 0x61, 0x33, 0x66, 0x64, 0x37, 0x61, 0x30, 0x37, 0x65, 0x63, 0x31, 0x63, 0x31, 0x36, 0x66, 0x64, 0x35, 0x36, 0x30, 0x37, 0x64, 0x39, 0x64, 0x31, 0x32, 0x33, 0x65, 0x62, 0x31, 0x35, 0x32, 0x35, 0x32, 0x61, 0x35, 0x39, 0x65, 0x34, 0x33, 0x35, 0x66, 0x66, 0x33, 0x32, 0x37, 0x35, 0x37, 0x37, 0x34, 0x36, 0x37, 0x39, 0x66, 0x66, 0x63, 0x63, 0x32, 0x65, 0x37, 0x31, 0x37, 0x32, 0x37, 0x32, 0x39, 0x64, 0x31, 0x33, 0x61, 0x35, 0x38, 0x31, 0x66, 0x33, 0x37, 0x61, 0x35, 0x39, 0x39, 0x33, 0x38, 0x35, 0x35, 0x61, 0x65, 0x65, 0x38, 0x37, 0x37, 0x38, 0x31, 0x61, 0x32, 0x33, 0x35, 0x61, 0x30, 0x38, 0x30, 0x37, 0x62, 0x31, 0x39, 0x33, 0x64, 0x66, 0x32, 0x39, 0x37, 0x36, 0x39, 0x30, 0x64, 0x37, 0x38, 0x32, 0x30, 0x63, 0x39, 0x63, 0x37, 0x66, 0x34, 0x34, 0x35, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x37, 0x65, 0x32, 0x30, 0x66, 0x64, 0x31, 0x61, 0x31, 0x33, 0x65, 0x63, 0x65, 0x31, 0x61, 0x37, 0x37, 0x38, 0x61, 0x37, 0x34, 0x66, 0x66, 0x30, 0x34, 0x62, 0x61, 0x63, 0x37, 0x61, 0x38, 0x34, 0x37, 0x36, 0x33, 0x33, 0x66, 0x61, 0x37, 0x36, 0x65, 0x61, 0x66, 0x30, 0x63, 0x65, 0x64, 0x66, 0x33, 0x65, 0x39, 0x39, 0x34, 0x66, 0x64, 0x33, 0x33, 0x63, 0x35, 0x32, 0x32, 0x35, 0x30, 0x65, 0x36, 0x39, 0x63, 0x35, 0x63, 0x37, 0x64, 0x35, 0x30, 0x33, 0x62, 0x39, 0x33, 0x62, 0x62, 0x62, 0x33, 0x65, 0x62, 0x65, 0x38, 0x33, 0x66, 0x32, 0x36, 0x33, 0x35, 0x64, 0x30, 0x32, 0x38, 0x64, 0x31, 0x34, 0x34, 0x37, 0x63, 0x61, 0x32, 0x33, 0x37, 0x61, 0x36, 0x34, 0x62, 0x62, 0x65, 0x64, 0x63, 0x31, 0x32, 0x31, 0x66, 0x30, 0x66, 0x37, 0x39, 0x39, 0x31, 0x37, 0x32, 0x31, 0x31, 0x63, 0x35, 0x38, 0x30, 0x39, 0x64, 0x31, 0x36, 0x64, 0x33, 0x65, 0x66, 0x61, 0x63, 0x39, 0x66, 0x35, 0x63, 0x61, 0x63, 0x39, 0x34, 0x30, 0x38, 0x36, 0x66, 0x66, 0x37, 0x31, 0x36, 0x34, 0x66, 0x31, 0x35, 0x37, 0x39, 0x63, 0x63, 0x66, 0x39, 0x64, 0x38, 0x37, 0x38, 0x30, 0x62, 0x36, 0x33, 0x35, 0x39, 0x38, 0x64, 0x37, 0x33, 0x38, 0x39, 0x35, 0x36, 0x61, 0x62, 0x37, 0x32, 0x36, 0x63, 0x35, 0x38, 0x62, 0x33, 0x62, 0x33, 0x65, 0x31, 0x30, 0x31, 0x64, 0x61, 0x32, 0x39, 0x64, 0x62, 0x38, 0x35, 0x64, 0x33, 0x62, 0x65, 0x39, 0x31, 0x61, 0x30, 0x39, 0x64, 0x61, 0x36, 0x63, 0x61, 0x36, 0x62, 0x36, 0x61, 0x32, 0x33, 0x39, 0x35, 0x64, 0x32, 0x64, 0x62, 0x64, 0x30, 0x37, 0x65, 0x30, 0x39, 0x33, 0x65, 0x64, 0x63, 0x38, 0x34, 0x38, 0x31, 0x33, 0x35, 0x37, 0x32, 0x62, 0x36, 0x36, 0x63, 0x63, 0x38, 0x61, 0x30, 0x63, 0x33, 0x66, 0x32, 0x65, 0x31, 0x33, 0x32, 0x65, 0x32, 0x61, 0x34, 0x65, 0x65, 0x36, 0x34, 0x61, 0x37, 0x66, 0x31, 0x39, 0x66, 0x33, 0x64, 0x38, 0x30, 0x34, 0x64, 0x36, 0x63, 0x35, 0x36, 0x62, 0x65, 0x33, 0x66, 0x66, 0x37, 0x62, 0x36, 0x32, 0x38, 0x30, 0x62, 0x38, 0x34, 0x65, 0x35, 0x61, 0x32, 0x30, 0x62, 0x33, 0x33, 0x35, 0x34, 0x39, 0x39, 0x37, 0x35, 0x37, 0x63, 0x30, 0x38, 0x65, 0x32, 0x39, 0x31, 0x32, 0x62, 0x66, 0x63, 0x38, 0x32, 0x65, 0x38, 0x66, 0x36, 0x30, 0x35, 0x64, 0x35, 0x66, 0x33, 0x31, 0x64, 0x33, 0x30, 0x39, 0x66, 0x61, 0x61, 0x37, 0x64, 0x35, 0x62, 0x37, 0x31, 0x64, 0x63, 0x33, 0x32, 0x33, 0x63, 0x61, 0x30, 0x33, 0x30, 0x62, 0x61, 0x38, 0x65, 0x64, 0x38, 0x32, 0x61, 0x66, 0x32, 0x34, 0x36, 0x61, 0x61, 0x66, 0x38, 0x39, 0x61, 0x61, 0x62, 0x34, 0x62, 0x61, 0x34, 0x37, 0x62, 0x37, 0x34, 0x38, 0x33, 0x37, 0x31, 0x37, 0x31, 0x62, 0x37, 0x31, 0x64, 0x61, 0x32, 0x30, 0x39, 0x37, 0x63, 0x32, 0x64, 0x63, 0x61, 0x34, 0x33, 0x62, 0x38, 0x31, 0x39, 0x33, 0x62, 0x33, 0x61, 0x36, 0x31, 0x61, 0x31, 0x64, 0x37, 0x64, 0x30, 0x36, 0x33, 0x62, 0x30, 0x66, 0x31, 0x39, 0x63, 0x37, 0x32, 0x37, 0x33, 0x65, 0x32, 0x30, 0x35, 0x61, 0x66, 0x64, 0x38, 0x34, 0x63, 0x66, 0x64, 0x39, 0x30, 0x62, 0x61, 0x30, 0x39, 0x32, 0x61, 0x66, 0x37, 0x39, 0x36, 0x33, 0x65, 0x66, 0x37, 0x38, 0x65, 0x63, 0x64, 0x33, 0x63, 0x30, 0x36, 0x62, 0x61, 0x61, 0x66, 0x31, 0x38, 0x32, 0x33, 0x33, 0x64, 0x63, 0x64, 0x64, 0x35, 0x31, 0x39, 0x33, 0x39, 0x32, 0x62, 0x38, 0x38, 0x31, 0x33, 0x35, 0x66, 0x61, 0x34, 0x61, 0x36, 0x32, 0x39, 0x30, 0x38, 0x38, 0x38, 0x30, 0x36, 0x30, 0x39, 0x33, 0x36, 0x30, 0x35, 0x30, 0x36, 0x32, 0x38, 0x61, 0x32, 0x35, 0x66, 0x64, 0x36, 0x35, 0x38, 0x65, 0x65, 0x63, 0x65, 0x62, 0x34, 0x66, 0x35, 0x64, 0x39, 0x63, 0x32, 0x63, 0x35, 0x32, 0x32, 0x38, 0x34, 0x32, 0x61, 0x32, 0x38, 0x66, 0x61, 0x61, 0x39, 0x63, 0x62, 0x66, 0x33, 0x61, 0x63, 0x37, 0x32, 0x66, 0x30, 0x65, 0x34, 0x35, 0x34, 0x31, 0x32, 0x30, 0x31, 0x66, 0x34, 0x32, 0x32, 0x31, 0x66, 0x61, 0x66, 0x31, 0x36, 0x62, 0x66, 0x64, 0x37, 0x63, 0x63, 0x64, 0x32, 0x32, 0x32, 0x66, 0x62, 0x30, 0x31, 0x37, 0x63, 0x64, 0x65, 0x33, 0x32, 0x31, 0x36, 0x62, 0x36, 0x33, 0x66, 0x62, 0x35, 0x32, 0x31, 0x65, 0x37, 0x39, 0x61, 0x33, 0x37, 0x38, 0x64, 0x39, 0x31, 0x65, 0x31, 0x35, 0x35, 0x61, 0x32, 0x32, 0x61, 0x37, 0x37, 0x35, 0x30, 0x65, 0x61, 0x66, 0x61, 0x63, 0x61, 0x64, 0x36, 0x66, 0x31, 0x34, 0x66, 0x35, 0x34, 0x36, 0x35, 0x30, 0x31, 0x36, 0x32, 0x38, 0x64, 0x34, 0x30, 0x31, 0x64, 0x38, 0x66, 0x36, 0x64, 0x35, 0x38, 0x32, 0x33, 0x63, 0x61, 0x63, 0x39, 0x65, 0x37, 0x61, 0x37, 0x66, 0x30, 0x61, 0x66, 0x66, 0x62, 0x61, 0x62, 0x32, 0x33, 0x31, 0x65, 0x37, 0x32, 0x36, 0x65, 0x62, 0x39, 0x34, 0x66, 0x61, 0x65, 0x63, 0x31, 0x37, 0x64, 0x32, 0x35, 0x30, 0x33, 0x30, 0x64, 0x33, 0x30, 0x34, 0x61, 0x31, 0x64, 0x61, 0x39, 0x65, 0x34, 0x33, 0x64, 0x30, 0x30, 0x35, 0x36, 0x63, 0x36, 0x62, 0x62, 0x33, 0x34, 0x66, 0x34, 0x35, 0x31, 0x63, 0x31, 0x64, 0x66, 0x35, 0x35, 0x34, 0x36, 0x63, 0x39, 0x33, 0x35, 0x33, 0x36, 0x61, 0x31, 0x64, 0x34, 0x37, 0x32, 0x66, 0x61, 0x64, 0x62, 0x62, 0x39, 0x36, 0x33, 0x30, 0x33, 0x34, 0x32, 0x37, 0x33, 0x32, 0x66, 0x61, 0x65, 0x31, 0x62, 0x32, 0x37, 0x63, 0x62, 0x32, 0x66, 0x61, 0x34, 0x31, 0x34, 0x37, 0x32, 0x61, 0x34, 0x38, 0x38, 0x36, 0x63, 0x66, 0x37, 0x65, 0x36, 0x38, 0x35, 0x62, 0x35, 0x65, 0x37, 0x61, 0x34, 0x37, 0x38, 0x34, 0x35, 0x66, 0x33, 0x61, 0x36, 0x64, 0x37, 0x62, 0x34, 0x33, 0x62, 0x61, 0x62, 0x64, 0x62, 0x30, 0x66, 0x37, 0x62, 0x61, 0x65, 0x61, 0x39, 0x38, 0x39, 0x66, 0x31, 0x36, 0x39, 0x65, 0x66, 0x31, 0x63, 0x33, 0x32, 0x62, 0x34, 0x62, 0x33, 0x32, 0x62, 0x36, 0x35, 0x38, 0x63, 0x63, 0x61, 0x63, 0x32, 0x32, 0x37, 0x33, 0x35, 0x38, 0x61, 0x37, 0x65, 0x36, 0x38, 0x35, 0x33, 0x61, 0x61, 0x36, 0x64, 0x63, 0x38, 0x34, 0x38, 0x66, 0x38, 0x31, 0x33, 0x37, 0x32, 0x37, 0x37, 0x37, 0x30, 0x35, 0x39, 0x65, 0x64, 0x65, 0x63, 0x34, 0x61, 0x37, 0x39, 0x35, 0x34, 0x65, 0x39, 0x61, 0x31, 0x33, 0x65, 0x33, 0x61, 0x66, 0x37, 0x34, 0x31, 0x39, 0x65, 0x35, 0x63, 0x30, 0x62, 0x38, 0x61, 0x62, 0x62, 0x61, 0x61, 0x64, 0x33, 0x32, 0x33, 0x33, 0x66, 0x63, 0x61, 0x32, 0x35, 0x35, 0x64, 0x38, 0x38, 0x62, 0x34, 0x39, 0x61, 0x30, 0x65, 0x66, 0x64, 0x37, 0x32, 0x61, 0x31, 0x39, 0x32, 0x35, 0x35, 0x34, 0x62, 0x31, 0x65, 0x61, 0x61, 0x33, 0x63, 0x30, 0x36, 0x63, 0x32, 0x35, 0x38, 0x37, 0x36, 0x32, 0x63, 0x65, 0x31, 0x31, 0x36, 0x31, 0x30, 0x66, 0x32, 0x33, 0x61, 0x35, 0x39, 0x64, 0x35, 0x65, 0x64, 0x34, 0x38, 0x65, 0x31, 0x39, 0x39, 0x38, 0x38, 0x64, 0x66, 0x63, 0x61, 0x37, 0x35, 0x37, 0x65, 0x34, 0x38, 0x37, 0x39, 0x32, 0x36, 0x35, 0x39, 0x38, 0x30, 0x63, 0x62, 0x31, 0x64, 0x63, 0x35, 0x62, 0x30, 0x30, 0x34, 0x39, 0x30, 0x61, 0x61, 0x30, 0x61, 0x35, 0x62, 0x32, 0x33, 0x61, 0x37, 0x36, 0x37, 0x38, 0x31, 0x63, 0x62, 0x63, 0x65, 0x34, 0x62, 0x33, 0x30, 0x37, 0x33, 0x34, 0x62, 0x35, 0x65, 0x31, 0x66, 0x66, 0x64, 0x66, 0x39, 0x30, 0x35, 0x36, 0x39, 0x32, 0x36, 0x36, 0x61, 0x65, 0x35, 0x63, 0x31, 0x32, 0x38, 0x37, 0x32, 0x62, 0x39, 0x63, 0x32, 0x66, 0x63, 0x35, 0x30, 0x39, 0x33, 0x38, 0x63, 0x63, 0x65, 0x37, 0x31, 0x65, 0x38, 0x39, 0x64, 0x37, 0x66, 0x61, 0x30, 0x32, 0x38, 0x61, 0x31, 0x35, 0x30, 0x33, 0x34, 0x31, 0x38, 0x31, 0x64, 0x34, 0x37, 0x66, 0x65, 0x36, 0x66, 0x36, 0x65, 0x65, 0x32, 0x65, 0x33, 0x31, 0x33, 0x63, 0x33, 0x64, 0x31, 0x38, 0x38, 0x31, 0x38, 0x34, 0x36, 0x65, 0x33, 0x31, 0x62, 0x32, 0x37, 0x37, 0x65, 0x37, 0x37, 0x35, 0x36, 0x32, 0x64, 0x65, 0x31, 0x33, 0x66, 0x65, 0x37, 0x37, 0x33, 0x33, 0x61, 0x32, 0x38, 0x63, 0x66, 0x37, 0x30, 0x63, 0x61, 0x32, 0x64, 0x30, 0x38, 0x32, 0x32, 0x31, 0x31, 0x34, 0x31, 0x64, 0x37, 0x62, 0x37, 0x37, 0x33, 0x32, 0x61, 0x31, 0x65, 0x36, 0x36, 0x31, 0x33, 0x35, 0x38, 0x64, 0x65, 0x37, 0x33, 0x33, 0x35, 0x39, 0x66, 0x37, 0x32, 0x30, 0x62, 0x62, 0x33, 0x30, 0x37, 0x32, 0x37, 0x36, 0x62, 0x31, 0x36, 0x38, 0x63, 0x33, 0x33, 0x35, 0x30, 0x31, 0x33, 0x37, 0x35, 0x39, 0x33, 0x34, 0x63, 0x63, 0x63, 0x35, 0x31, 0x34, 0x30, 0x64, 0x35, 0x65, 0x38, 0x33, 0x63, 0x65, 0x61, 0x66, 0x35, 0x37, 0x30, 0x62, 0x35, 0x35, 0x36, 0x65, 0x66, 0x38, 0x34, 0x34, 0x61, 0x65, 0x36, 0x63, 0x63, 0x34, 0x31, 0x37, 0x62, 0x37, 0x32, 0x34, 0x65, 0x36, 0x66, 0x66, 0x65, 0x65, 0x30, 0x30, 0x33, 0x35, 0x66, 0x33, 0x34, 0x38, 0x37, 0x38, 0x30, 0x30, 0x31, 0x30, 0x37, 0x33, 0x34, 0x36, 0x63, 0x30, 0x36, 0x39, 0x64, 0x31, 0x31, 0x39, 0x35, 0x31, 0x31, 0x61, 0x62, 0x31, 0x61, 0x30, 0x33, 0x63, 0x31, 0x66, 0x38, 0x64, 0x62, 0x32, 0x65, 0x65, 0x37, 0x33, 0x36, 0x66, 0x61, 0x62, 0x65, 0x64, 0x34, 0x63, 0x39, 0x37, 0x32, 0x37, 0x66, 0x38, 0x38, 0x39, 0x32, 0x37, 0x64, 0x34, 0x35, 0x66, 0x35, 0x36, 0x66, 0x37, 0x62, 0x65, 0x35, 0x30, 0x38, 0x38, 0x32, 0x34, 0x30, 0x66, 0x65, 0x38, 0x61, 0x30, 0x65, 0x63, 0x62, 0x32, 0x31, 0x66, 0x61, 0x30, 0x33, 0x66, 0x33, 0x31, 0x33, 0x66, 0x38, 0x64, 0x65, 0x30, 0x64, 0x62, 0x35, 0x65, 0x32, 0x33, 0x34, 0x39, 0x66, 0x31, 0x34, 0x36, 0x64, 0x66, 0x32, 0x37, 0x32, 0x39, 0x62, 0x38, 0x39, 0x36, 0x33, 0x61, 0x37, 0x38, 0x30, 0x37, 0x38, 0x33, 0x31, 0x31, 0x33, 0x65, 0x61, 0x31, 0x33, 0x66, 0x36, 0x33, 0x32, 0x63, 0x65, 0x62, 0x61, 0x65, 0x39, 0x66, 0x36, 0x62, 0x35, 0x66, 0x33, 0x65, 0x66, 0x65, 0x38, 0x33, 0x62, 0x62, 0x35, 0x62, 0x31, 0x39, 0x38, 0x30, 0x37, 0x35, 0x66, 0x61, 0x31, 0x64, 0x37, 0x62, 0x61, 0x62, 0x39, 0x32, 0x30, 0x35, 0x63, 0x35, 0x36, 0x33, 0x36, 0x37, 0x33, 0x32, 0x37, 0x32, 0x64, 0x63, 0x35, 0x63, 0x31, 0x35, 0x36, 0x66, 0x35, 0x61, 0x61, 0x34, 0x35, 0x61, 0x31, 0x36, 0x64, 0x64, 0x37, 0x36, 0x39, 0x32, 0x66, 0x32, 0x30, 0x30, 0x37, 0x30, 0x35, 0x30, 0x35, 0x62, 0x39, 0x32, 0x39, 0x35, 0x39, 0x39, 0x35, 0x36, 0x36, 0x31, 0x33, 0x33, 0x66, 0x39, 0x35, 0x33, 0x33, 0x35, 0x33, 0x65, 0x66, 0x37, 0x32, 0x66, 0x64, 0x61, 0x37, 0x38, 0x34, 0x36, 0x33, 0x37, 0x38, 0x39, 0x65, 0x35, 0x32, 0x32, 0x62, 0x65, 0x34, 0x33, 0x66, 0x62, 0x30, 0x38, 0x37, 0x64, 0x61, 0x37, 0x63, 0x66, 0x63, 0x39, 0x64, 0x37, 0x31, 0x34, 0x62, 0x30, 0x37, 0x63, 0x33, 0x66, 0x38, 0x39, 0x65, 0x63, 0x39, 0x36, 0x33, 0x61, 0x64, 0x38, 0x33, 0x62, 0x65, 0x64, 0x63, 0x62, 0x32, 0x37, 0x36, 0x65, 0x38, 0x35, 0x32, 0x62, 0x62, 0x33, 0x35, 0x35, 0x64, 0x63, 0x37, 0x39, 0x37, 0x61, 0x35, 0x36, 0x30, 0x31, 0x61, 0x39, 0x35, 0x62, 0x64, 0x32, 0x35, 0x37, 0x66, 0x63, 0x62, 0x32, 0x65, 0x66, 0x38, 0x65, 0x65, 0x34, 0x36, 0x61, 0x31, 0x33, 0x34, 0x33, 0x34, 0x32, 0x33, 0x64, 0x33, 0x61, 0x34, 0x37, 0x36, 0x63, 0x63, 0x37, 0x34, 0x34, 0x36, 0x30, 0x37, 0x34, 0x64, 0x65, 0x36, 0x66, 0x30, 0x37, 0x32, 0x33, 0x66, 0x34, 0x38, 0x30, 0x30, 0x38, 0x62, 0x65, 0x30, 0x34, 0x63, 0x65, 0x62, 0x37, 0x64, 0x62, 0x61, 0x31, 0x32, 0x37, 0x38, 0x37, 0x63, 0x64, 0x62, 0x38, 0x34, 0x65, 0x64, 0x62, 0x37, 0x30, 0x36, 0x61, 0x32, 0x30, 0x34, 0x62, 0x31, 0x37, 0x30, 0x62, 0x37, 0x38, 0x35, 0x36, 0x32, 0x35, 0x30, 0x63, 0x34, 0x62, 0x38, 0x31, 0x62, 0x33, 0x66, 0x37, 0x61, 0x65, 0x66, 0x37, 0x32, 0x38, 0x31, 0x30, 0x33, 0x35, 0x39, 0x33, 0x62, 0x66, 0x34, 0x62, 0x33, 0x37, 0x62, 0x35, 0x61, 0x37, 0x33, 0x64, 0x38, 0x39, 0x39, 0x31, 0x30, 0x32, 0x39, 0x36, 0x39, 0x39, 0x66, 0x61, 0x37, 0x63, 0x36, 0x66, 0x30, 0x63, 0x30, 0x30, 0x38, 0x38, 0x30, 0x38, 0x38, 0x30, 0x61, 0x36, 0x31, 0x63, 0x63, 0x38, 0x61, 0x62, 0x34, 0x66, 0x36, 0x31, 0x34, 0x66, 0x35, 0x64, 0x33, 0x36, 0x39, 0x61, 0x31, 0x63, 0x37, 0x36, 0x66, 0x62, 0x33, 0x38, 0x30, 0x31, 0x33, 0x63, 0x33, 0x64, 0x66, 0x65, 0x31, 0x30, 0x65, 0x35, 0x31, 0x64, 0x33, 0x34, 0x38, 0x30, 0x35, 0x35, 0x64, 0x33, 0x64, 0x36, 0x30, 0x32, 0x32, 0x32, 0x30, 0x61, 0x37, 0x65, 0x38, 0x61, 0x64, 0x33, 0x35, 0x30, 0x34, 0x33, 0x31, 0x65, 0x63, 0x32, 0x61, 0x35, 0x65, 0x36, 0x66, 0x62, 0x62, 0x62, 0x36, 0x37, 0x32, 0x38, 0x36, 0x33, 0x36, 0x64, 0x34, 0x38, 0x37, 0x32, 0x66, 0x36, 0x33, 0x35, 0x36, 0x34, 0x36, 0x33, 0x30, 0x38, 0x38, 0x35, 0x31, 0x32, 0x33, 0x33, 0x30, 0x38, 0x35, 0x64, 0x32, 0x64, 0x36, 0x65, 0x63, 0x32, 0x39, 0x34, 0x65, 0x33, 0x61, 0x31, 0x39, 0x37, 0x31, 0x38, 0x35, 0x35, 0x64, 0x31, 0x61, 0x31, 0x33, 0x62, 0x61, 0x33, 0x63, 0x63, 0x31, 0x34, 0x66, 0x61, 0x62, 0x37, 0x32, 0x64, 0x33, 0x65, 0x39, 0x30, 0x65, 0x36, 0x37, 0x37, 0x36, 0x39, 0x39, 0x35, 0x32, 0x38, 0x32, 0x34, 0x32, 0x62, 0x32, 0x63, 0x34, 0x34, 0x38, 0x30, 0x37, 0x34, 0x35, 0x36, 0x64, 0x37, 0x61, 0x35, 0x61, 0x30, 0x66, 0x32, 0x37, 0x33, 0x65, 0x62, 0x34, 0x61, 0x35, 0x30, 0x36, 0x63, 0x62, 0x34, 0x66, 0x65, 0x66, 0x33, 0x63, 0x32, 0x61, 0x36, 0x34, 0x62, 0x33, 0x35, 0x36, 0x37, 0x32, 0x32, 0x35, 0x63, 0x64, 0x30, 0x34, 0x31, 0x61, 0x63, 0x65, 0x31, 0x32, 0x38, 0x39, 0x64, 0x36, 0x62, 0x31, 0x64, 0x65, 0x65, 0x32, 0x65, 0x34, 0x62, 0x63, 0x31, 0x65, 0x64, 0x62, 0x61, 0x36, 0x39, 0x61, 0x65, 0x63, 0x32, 0x66, 0x38, 0x37, 0x65, 0x30, 0x34, 0x65, 0x32, 0x61, 0x61, 0x35, 0x66, 0x37, 0x31, 0x33, 0x31, 0x66, 0x39, 0x39, 0x31, 0x63, 0x32, 0x61, 0x33, 0x34, 0x37, 0x32, 0x66, 0x39, 0x61, 0x66, 0x36, 0x62, 0x66, 0x31, 0x66, 0x31, 0x37, 0x66, 0x65, 0x34, 0x31, 0x32, 0x36, 0x30, 0x64, 0x38, 0x66, 0x66, 0x33, 0x33, 0x63, 0x38, 0x33, 0x63, 0x31, 0x30, 0x30, 0x64, 0x31, 0x35, 0x66, 0x34, 0x39, 0x32, 0x31, 0x36, 0x34, 0x30, 0x66, 0x62, 0x30, 0x62, 0x30, 0x36, 0x37, 0x63, 0x65, 0x38, 0x31, 0x64, 0x62, 0x36, 0x32, 0x34, 0x36, 0x35, 0x36, 0x33, 0x35, 0x64, 0x39, 0x30, 0x36, 0x61, 0x61, 0x65, 0x65, 0x36, 0x31, 0x39, 0x64, 0x37, 0x30, 0x65, 0x31, 0x64, 0x63, 0x62, 0x61, 0x62, 0x62, 0x39, 0x31, 0x38, 0x33, 0x35, 0x38, 0x31, 0x32, 0x35, 0x32, 0x36, 0x39, 0x35, 0x30, 0x38, 0x62, 0x36, 0x30, 0x35, 0x64, 0x37, 0x39, 0x30, 0x38, 0x30, 0x63, 0x32, 0x66, 0x34, 0x32, 0x62, 0x35, 0x30, 0x65, 0x35, 0x36, 0x63, 0x32, 0x31, 0x31, 0x64, 0x37, 0x32, 0x37, 0x34, 0x64, 0x32, 0x61, 0x38, 0x36, 0x36, 0x65, 0x39, 0x62, 0x35, 0x65, 0x31, 0x65, 0x35, 0x62, 0x38, 0x61, 0x63, 0x38, 0x32, 0x31, 0x38, 0x63, 0x62, 0x36, 0x32, 0x33, 0x31, 0x33, 0x39, 0x66, 0x36, 0x64, 0x35, 0x30, 0x30, 0x37, 0x66, 0x63, 0x35, 0x38, 0x31, 0x66, 0x35, 0x35, 0x39, 0x32, 0x30, 0x36, 0x32, 0x31, 0x34, 0x33, 0x39, 0x38, 0x32, 0x66, 0x32, 0x36, 0x34, 0x37, 0x32, 0x33, 0x30, 0x63, 0x34, 0x61, 0x30, 0x30, 0x35, 0x30, 0x33, 0x63, 0x35, 0x30, 0x65, 0x35, 0x64, 0x63, 0x63, 0x61, 0x63, 0x37, 0x39, 0x33, 0x39, 0x36, 0x64, 0x61, 0x64, 0x66, 0x61, 0x63, 0x30, 0x31, 0x39, 0x36, 0x32, 0x38, 0x64, 0x65, 0x66, 0x36, 0x61, 0x61, 0x35, 0x32, 0x65, 0x36, 0x34, 0x62, 0x62, 0x34, 0x62, 0x33, 0x39, 0x63, 0x38, 0x36, 0x65, 0x30, 0x34, 0x61, 0x39, 0x34, 0x31, 0x30, 0x37, 0x62, 0x66, 0x65, 0x36, 0x34, 0x30, 0x31, 0x63, 0x61, 0x31, 0x31, 0x31, 0x31, 0x34, 0x33, 0x64, 0x64, 0x38, 0x66, 0x62, 0x35, 0x34, 0x38, 0x65, 0x31, 0x64, 0x66, 0x64, 0x64, 0x31, 0x37, 0x37, 0x34, 0x38, 0x32, 0x66, 0x31, 0x64, 0x64, 0x37, 0x61, 0x63, 0x35, 0x32, 0x35, 0x33, 0x65, 0x34, 0x35, 0x63, 0x32, 0x61, 0x39, 0x31, 0x37, 0x39, 0x36, 0x36, 0x65, 0x32, 0x37, 0x32, 0x64, 0x65, 0x62, 0x38, 0x34, 0x63, 0x33, 0x36, 0x61, 0x36, 0x63, 0x36, 0x63, 0x62, 0x31, 0x39, 0x34, 0x32, 0x32, 0x39, 0x63, 0x66, 0x30, 0x65, 0x32, 0x65, 0x33, 0x64, 0x63, 0x33, 0x65, 0x64, 0x64, 0x36, 0x64, 0x32, 0x36, 0x38, 0x31, 0x36, 0x30, 0x66, 0x63, 0x62, 0x34, 0x63, 0x39, 0x32, 0x37, 0x61, 0x33, 0x37, 0x30, 0x32, 0x61, 0x65, 0x32, 0x62, 0x38, 0x32, 0x37, 0x34, 0x37, 0x30, 0x39, 0x62, 0x38, 0x62, 0x39, 0x35, 0x65, 0x66, 0x37, 0x61, 0x66, 0x39, 0x30, 0x66, 0x37, 0x65, 0x62, 0x65, 0x31, 0x36, 0x30, 0x38, 0x62, 0x33, 0x39, 0x65, 0x61, 0x61, 0x61, 0x66, 0x31, 0x62, 0x63, 0x65, 0x30, 0x65, 0x63, 0x35, 0x37, 0x32, 0x30, 0x35, 0x63, 0x62, 0x61, 0x35, 0x32, 0x30, 0x32, 0x63, 0x33, 0x33, 0x63, 0x38, 0x39, 0x64, 0x64, 0x61, 0x65, 0x34, 0x34, 0x62, 0x34, 0x36, 0x65, 0x32, 0x31, 0x39, 0x37, 0x62, 0x33, 0x66, 0x63, 0x66, 0x33, 0x35, 0x33, 0x38, 0x33, 0x65, 0x30, 0x66, 0x37, 0x30, 0x36, 0x32, 0x38, 0x64, 0x37, 0x32, 0x66, 0x65, 0x66, 0x34, 0x34, 0x31, 0x61, 0x34, 0x31, 0x33, 0x35, 0x36, 0x38, 0x31, 0x38, 0x65, 0x31, 0x30, 0x36, 0x38, 0x63, 0x39, 0x66, 0x65, 0x61, 0x62, 0x38, 0x63, 0x65, 0x31, 0x38, 0x32, 0x35, 0x64, 0x33, 0x61, 0x37, 0x32, 0x34, 0x64, 0x36, 0x66, 0x37, 0x39, 0x38, 0x31, 0x63, 0x66, 0x62, 0x37, 0x30, 0x37, 0x61, 0x33, 0x62, 0x34, 0x66, 0x63, 0x66, 0x39, 0x66, 0x61, 0x31, 0x31, 0x66, 0x31, 0x33, 0x34, 0x65, 0x66, 0x63, 0x31, 0x34, 0x62, 0x32, 0x36, 0x62, 0x64, 0x37, 0x63, 0x31, 0x34, 0x31, 0x38, 0x35, 0x39, 0x63, 0x64, 0x61, 0x31, 0x39, 0x32, 0x30, 0x36, 0x31, 0x62, 0x64, 0x63, 0x63, 0x39, 0x37, 0x32, 0x36, 0x62, 0x64, 0x61, 0x64, 0x36, 0x61, 0x30, 0x33, 0x30, 0x62, 0x34, 0x36, 0x61, 0x63, 0x38, 0x34, 0x34, 0x30, 0x31, 0x37, 0x64, 0x36, 0x33, 0x34, 0x34, 0x66, 0x30, 0x31, 0x37, 0x34, 0x63, 0x35, 0x36, 0x63, 0x61, 0x38, 0x35, 0x39, 0x30, 0x64, 0x37, 0x37, 0x63, 0x30, 0x34, 0x65, 0x30, 0x37, 0x30, 0x37, 0x37, 0x30, 0x63, 0x30, 0x61, 0x62, 0x62, 0x38, 0x32, 0x64, 0x36, 0x37, 0x32, 0x65, 0x36, 0x39, 0x30, 0x64, 0x32, 0x34, 0x65, 0x31, 0x30, 0x63, 0x63, 0x36, 0x32, 0x38, 0x31, 0x64, 0x66, 0x34, 0x38, 0x66, 0x63, 0x32, 0x39, 0x37, 0x61, 0x35, 0x66, 0x35, 0x36, 0x39, 0x65, 0x39, 0x62, 0x66, 0x37, 0x35, 0x65, 0x35, 0x38, 0x33, 0x66, 0x39, 0x30, 0x61, 0x62, 0x39, 0x32, 0x35, 0x37, 0x38, 0x32, 0x34, 0x65, 0x31, 0x34, 0x30, 0x66, 0x63, 0x63, 0x34, 0x62, 0x37, 0x32, 0x35, 0x38, 0x61, 0x66, 0x62, 0x31, 0x66, 0x31, 0x30, 0x37, 0x36, 0x38, 0x31, 0x62, 0x37, 0x61, 0x31, 0x61, 0x38, 0x32, 0x34, 0x36, 0x35, 0x34, 0x38, 0x39, 0x34, 0x64, 0x36, 0x65, 0x30, 0x37, 0x64, 0x61, 0x31, 0x38, 0x62, 0x30, 0x30, 0x65, 0x65, 0x39, 0x33, 0x65, 0x66, 0x35, 0x34, 0x35, 0x61, 0x33, 0x62, 0x38, 0x62, 0x62, 0x66, 0x37, 0x37, 0x37, 0x66, 0x65, 0x64, 0x32, 0x35, 0x34, 0x65, 0x38, 0x37, 0x38, 0x38, 0x37, 0x61, 0x62, 0x34, 0x63, 0x35, 0x31, 0x34, 0x63, 0x62, 0x36, 0x61, 0x36, 0x37, 0x61, 0x33, 0x62, 0x30, 0x62, 0x33, 0x31, 0x36, 0x30, 0x39, 0x62, 0x36, 0x38, 0x65, 0x61, 0x64, 0x38, 0x31, 0x39, 0x31, 0x32, 0x64, 0x35, 0x39, 0x65, 0x34, 0x62, 0x34, 0x38, 0x34, 0x37, 0x62, 0x30, 0x39, 0x39, 0x30, 0x61, 0x35, 0x32, 0x33, 0x66, 0x64, 0x31, 0x37, 0x32, 0x39, 0x35, 0x34, 0x34, 0x62, 0x32, 0x32, 0x36, 0x66, 0x34, 0x63, 0x33, 0x65, 0x66, 0x61, 0x37, 0x61, 0x64, 0x61, 0x37, 0x30, 0x64, 0x30, 0x65, 0x64, 0x64, 0x34, 0x62, 0x34, 0x66, 0x31, 0x34, 0x33, 0x32, 0x62, 0x30, 0x61, 0x32, 0x63, 0x65, 0x39, 0x37, 0x36, 0x36, 0x36, 0x63, 0x39, 0x64, 0x32, 0x62, 0x33, 0x62, 0x61, 0x33, 0x32, 0x64, 0x39, 0x33, 0x35, 0x35, 0x66, 0x39, 0x36, 0x64, 0x64, 0x30, 0x65, 0x38, 0x61, 0x35, 0x39, 0x36, 0x31, 0x35, 0x30, 0x39, 0x32, 0x33, 0x63, 0x63, 0x36, 0x37, 0x30, 0x64, 0x37, 0x32, 0x39, 0x64, 0x66, 0x33, 0x35, 0x65, 0x33, 0x62, 0x66, 0x66, 0x39, 0x64, 0x64, 0x30, 0x31, 0x38, 0x32, 0x33, 0x39, 0x39, 0x37, 0x66, 0x65, 0x37, 0x34, 0x35, 0x66, 0x32, 0x65, 0x61, 0x64, 0x30, 0x37, 0x63, 0x38, 0x35, 0x61, 0x62, 0x31, 0x33, 0x37, 0x32, 0x32, 0x38, 0x64, 0x37, 0x32, 0x33, 0x61, 0x34, 0x63, 0x38, 0x33, 0x30, 0x64, 0x33, 0x34, 0x65, 0x39, 0x63, 0x64, 0x34, 0x64, 0x65, 0x32, 0x64, 0x63, 0x33, 0x64, 0x65, 0x65, 0x61, 0x38, 0x31, 0x38, 0x30, 0x37, 0x63, 0x36, 0x34, 0x61, 0x35, 0x34, 0x32, 0x65, 0x34, 0x35, 0x36, 0x61, 0x33, 0x66, 0x34, 0x62, 0x31, 0x32, 0x66, 0x35, 0x31, 0x38, 0x30, 0x32, 0x36, 0x30, 0x34, 0x37, 0x32, 0x33, 0x61, 0x33, 0x66, 0x33, 0x30, 0x64, 0x37, 0x30, 0x66, 0x32, 0x65, 0x35, 0x66, 0x35, 0x34, 0x37, 0x64, 0x63, 0x32, 0x32, 0x36, 0x33, 0x66, 0x32, 0x64, 0x66, 0x39, 0x32, 0x35, 0x61, 0x35, 0x61, 0x36, 0x36, 0x39, 0x39, 0x65, 0x31, 0x61, 0x66, 0x66, 0x31, 0x34, 0x33, 0x64, 0x32, 0x61, 0x37, 0x62, 0x32, 0x39, 0x64, 0x31, 0x62, 0x64, 0x35, 0x39, 0x66, 0x37, 0x31, 0x32, 0x34, 0x36, 0x36, 0x66, 0x34, 0x35, 0x37, 0x39, 0x38, 0x61, 0x34, 0x35, 0x37, 0x61, 0x34, 0x65, 0x30, 0x37, 0x64, 0x35, 0x38, 0x38, 0x39, 0x32, 0x61, 0x62, 0x32, 0x62, 0x35, 0x33, 0x39, 0x31, 0x36, 0x65, 0x38, 0x66, 0x39, 0x35, 0x31, 0x66, 0x65, 0x37, 0x34, 0x36, 0x66, 0x32, 0x31, 0x64, 0x66, 0x66, 0x38, 0x30, 0x31, 0x35, 0x66, 0x62, 0x66, 0x31, 0x61, 0x65, 0x63, 0x32, 0x39, 0x62, 0x37, 0x32, 0x36, 0x32, 0x39, 0x34, 0x34, 0x65, 0x32, 0x66, 0x61, 0x35, 0x39, 0x32, 0x32, 0x37, 0x62, 0x30, 0x66, 0x36, 0x36, 0x36, 0x39, 0x62, 0x32, 0x65, 0x39, 0x30, 0x32, 0x64, 0x61, 0x66, 0x34, 0x65, 0x32, 0x33, 0x37, 0x65, 0x31, 0x65, 0x30, 0x34, 0x66, 0x66, 0x32, 0x31, 0x31, 0x35, 0x32, 0x31, 0x62, 0x65, 0x63, 0x63, 0x39, 0x61, 0x66, 0x35, 0x61, 0x36, 0x30, 0x37, 0x37, 0x64, 0x37, 0x32, 0x63, 0x39, 0x31, 0x32, 0x61, 0x64, 0x64, 0x30, 0x66, 0x62, 0x39, 0x61, 0x35, 0x34, 0x63, 0x38, 0x64, 0x36, 0x32, 0x65, 0x61, 0x61, 0x38, 0x61, 0x62, 0x36, 0x39, 0x39, 0x37, 0x38, 0x31, 0x36, 0x32, 0x39, 0x64, 0x35, 0x32, 0x35, 0x33, 0x61, 0x31, 0x62, 0x39, 0x32, 0x65, 0x66, 0x65, 0x38, 0x32, 0x34, 0x30, 0x62, 0x61, 0x36, 0x36, 0x34, 0x63, 0x30, 0x65, 0x34, 0x63, 0x63, 0x37, 0x32, 0x64, 0x61, 0x38, 0x36, 0x30, 0x33, 0x62, 0x31, 0x64, 0x32, 0x65, 0x62, 0x30, 0x32, 0x62, 0x36, 0x31, 0x35, 0x36, 0x64, 0x64, 0x32, 0x30, 0x39, 0x38, 0x36, 0x37, 0x63, 0x66, 0x64, 0x39, 0x38, 0x35, 0x65, 0x64, 0x62, 0x30, 0x61, 0x33, 0x35, 0x61, 0x33, 0x62, 0x63, 0x39, 0x34, 0x38, 0x39, 0x31, 0x61, 0x38, 0x32, 0x33, 0x33, 0x61, 0x62, 0x35, 0x65, 0x61, 0x61, 0x32, 0x63, 0x33, 0x30, 0x38, 0x39, 0x39, 0x31, 0x32, 0x35, 0x38, 0x31, 0x37, 0x34, 0x38, 0x66, 0x37, 0x39, 0x62, 0x63, 0x39, 0x65, 0x65, 0x38, 0x65, 0x30, 0x37, 0x61, 0x63, 0x35, 0x30, 0x39, 0x31, 0x31, 0x34, 0x34, 0x32, 0x39, 0x65, 0x63, 0x66, 0x36, 0x62, 0x36, 0x39, 0x31, 0x31, 0x37, 0x37, 0x31, 0x38, 0x36, 0x31, 0x32, 0x39, 0x39, 0x63, 0x62, 0x33, 0x63, 0x31, 0x64, 0x39, 0x31, 0x65, 0x34, 0x37, 0x32, 0x63, 0x63, 0x32, 0x33, 0x32, 0x63, 0x63, 0x37, 0x61, 0x34, 0x31, 0x36, 0x62, 0x30, 0x66, 0x33, 0x33, 0x65, 0x37, 0x62, 0x34, 0x65, 0x39, 0x38, 0x38, 0x61, 0x33, 0x35, 0x30, 0x31, 0x65, 0x61, 0x61, 0x62, 0x34, 0x31, 0x64, 0x33, 0x63, 0x63, 0x61, 0x38, 0x38, 0x36, 0x62, 0x31, 0x33, 0x36, 0x38, 0x36, 0x65, 0x31, 0x31, 0x31, 0x39, 0x30, 0x63, 0x39, 0x62, 0x35, 0x37, 0x38, 0x37, 0x32, 0x32, 0x33, 0x62, 0x62, 0x35, 0x65, 0x37, 0x66, 0x33, 0x36, 0x39, 0x38, 0x37, 0x35, 0x37, 0x30, 0x63, 0x38, 0x61, 0x62, 0x37, 0x66, 0x32, 0x65, 0x38, 0x66, 0x37, 0x31, 0x32, 0x31, 0x35, 0x31, 0x34, 0x30, 0x38, 0x66, 0x38, 0x66, 0x63, 0x66, 0x64, 0x61, 0x61, 0x39, 0x34, 0x31, 0x62, 0x63, 0x66, 0x32, 0x34, 0x35, 0x63, 0x61, 0x31, 0x39, 0x61, 0x36, 0x61, 0x61, 0x38, 0x32, 0x37, 0x32, 0x65, 0x31, 0x62, 0x64, 0x66, 0x65, 0x62, 0x62, 0x33, 0x64, 0x62, 0x33, 0x66, 0x38, 0x34, 0x36, 0x63, 0x37, 0x63, 0x62, 0x65, 0x65, 0x61, 0x37, 0x34, 0x31, 0x33, 0x35, 0x66, 0x33, 0x64, 0x37, 0x33, 0x64, 0x39, 0x62, 0x35, 0x39, 0x38, 0x33, 0x38, 0x36, 0x65, 0x38, 0x31, 0x66, 0x38, 0x30, 0x31, 0x34, 0x34, 0x31, 0x66, 0x35, 0x36, 0x33, 0x63, 0x32, 0x62, 0x65, 0x37, 0x65, 0x37, 0x32, 0x64, 0x33, 0x64, 0x34, 0x34, 0x63, 0x30, 0x35, 0x61, 0x31, 0x38, 0x66, 0x36, 0x33, 0x66, 0x63, 0x37, 0x66, 0x34, 0x65, 0x35, 0x38, 0x35, 0x37, 0x38, 0x38, 0x30, 0x64, 0x36, 0x63, 0x31, 0x34, 0x34, 0x38, 0x33, 0x64, 0x30, 0x32, 0x61, 0x35, 0x63, 0x35, 0x64, 0x62, 0x63, 0x66, 0x61, 0x31, 0x66, 0x33, 0x35, 0x61, 0x39, 0x65, 0x62, 0x61, 0x38, 0x30, 0x65, 0x37, 0x65, 0x66, 0x34, 0x62, 0x33, 0x39, 0x32, 0x35, 0x62, 0x64, 0x65, 0x63, 0x39, 0x31, 0x62, 0x63, 0x35, 0x35, 0x32, 0x37, 0x34, 0x30, 0x35, 0x38, 0x33, 0x33, 0x62, 0x66, 0x62, 0x36, 0x62, 0x33, 0x33, 0x36, 0x62, 0x34, 0x34, 0x38, 0x63, 0x64, 0x36, 0x33, 0x37, 0x63, 0x32, 0x66, 0x62, 0x38, 0x39, 0x63, 0x36, 0x38, 0x65, 0x32, 0x35, 0x39, 0x34, 0x30, 0x35, 0x38, 0x61, 0x61, 0x63, 0x33, 0x65, 0x35, 0x37, 0x32, 0x39, 0x36, 0x38, 0x30, 0x30, 0x61, 0x66, 0x65, 0x31, 0x65, 0x64, 0x32, 0x39, 0x64, 0x61, 0x65, 0x63, 0x37, 0x35, 0x64, 0x61, 0x64, 0x61, 0x63, 0x65, 0x64, 0x64, 0x37, 0x65, 0x36, 0x37, 0x36, 0x36, 0x30, 0x64, 0x30, 0x61, 0x65, 0x66, 0x39, 0x61, 0x62, 0x36, 0x63, 0x35, 0x36, 0x31, 0x36, 0x32, 0x33, 0x30, 0x33, 0x39, 0x64, 0x30, 0x65, 0x33, 0x33, 0x61, 0x36, 0x39, 0x32, 0x37, 0x32, 0x65, 0x34, 0x38, 0x32, 0x66, 0x36, 0x38, 0x61, 0x32, 0x32, 0x36, 0x33, 0x37, 0x32, 0x37, 0x66, 0x61, 0x66, 0x63, 0x64, 0x63, 0x30, 0x33, 0x34, 0x66, 0x62, 0x38, 0x66, 0x64, 0x66, 0x61, 0x38, 0x38, 0x36, 0x36, 0x62, 0x61, 0x36, 0x31, 0x33, 0x61, 0x61, 0x61, 0x39, 0x66, 0x31, 0x34, 0x35, 0x35, 0x64, 0x30, 0x34, 0x34, 0x36, 0x64, 0x31, 0x33, 0x38, 0x32, 0x61, 0x61, 0x30, 0x37, 0x32, 0x39, 0x39, 0x62, 0x64, 0x34, 0x39, 0x34, 0x37, 0x37, 0x33, 0x37, 0x66, 0x30, 0x64, 0x31, 0x61, 0x66, 0x38, 0x32, 0x64, 0x38, 0x35, 0x66, 0x37, 0x61, 0x61, 0x33, 0x32, 0x62, 0x64, 0x62, 0x39, 0x39, 0x37, 0x62, 0x36, 0x37, 0x39, 0x37, 0x35, 0x64, 0x66, 0x38, 0x35, 0x32, 0x30, 0x36, 0x31, 0x62, 0x61, 0x33, 0x30, 0x39, 0x61, 0x33, 0x34, 0x62, 0x36, 0x37, 0x65, 0x64, 0x39, 0x37, 0x32, 0x32, 0x34, 0x31, 0x31, 0x31, 0x30, 0x38, 0x34, 0x33, 0x65, 0x62, 0x37, 0x62, 0x31, 0x37, 0x32, 0x37, 0x31, 0x38, 0x34, 0x34, 0x39, 0x62, 0x65, 0x33, 0x65, 0x64, 0x32, 0x30, 0x62, 0x33, 0x30, 0x66, 0x35, 0x30, 0x63, 0x33, 0x30, 0x63, 0x34, 0x63, 0x30, 0x35, 0x39, 0x36, 0x33, 0x38, 0x30, 0x32, 0x32, 0x65, 0x36, 0x30, 0x32, 0x61, 0x32, 0x31, 0x66, 0x32, 0x38, 0x36, 0x33, 0x33, 0x65, 0x30, 0x65, 0x61, 0x63, 0x31, 0x39, 0x65, 0x31, 0x62, 0x36, 0x39, 0x33, 0x64, 0x34, 0x37, 0x63, 0x30, 0x64, 0x62, 0x33, 0x66, 0x36, 0x62, 0x61, 0x63, 0x30, 0x39, 0x61, 0x65, 0x66, 0x63, 0x62, 0x32, 0x65, 0x32, 0x34, 0x64, 0x62, 0x62, 0x31, 0x61, 0x63, 0x61, 0x65, 0x63, 0x32, 0x31, 0x36, 0x35, 0x32, 0x63, 0x37, 0x66, 0x31, 0x66, 0x32, 0x31, 0x63, 0x61, 0x35, 0x63, 0x31, 0x37, 0x32, 0x32, 0x63, 0x62, 0x64, 0x66, 0x37, 0x36, 0x64, 0x31, 0x33, 0x32, 0x39, 0x61, 0x37, 0x37, 0x34, 0x65, 0x32, 0x38, 0x64, 0x61, 0x39, 0x65, 0x32, 0x36, 0x36, 0x66, 0x36, 0x30, 0x64, 0x62, 0x66, 0x63, 0x35, 0x32, 0x62, 0x30, 0x64, 0x32, 0x64, 0x32, 0x38, 0x62, 0x64, 0x38, 0x35, 0x39, 0x34, 0x37, 0x66, 0x33, 0x33, 0x34, 0x61, 0x32, 0x37, 0x35, 0x61, 0x34, 0x33, 0x33, 0x36, 0x37, 0x32, 0x63, 0x61, 0x36, 0x66, 0x61, 0x65, 0x66, 0x31, 0x30, 0x35, 0x31, 0x37, 0x31, 0x65, 0x31, 0x31, 0x30, 0x64, 0x65, 0x30, 0x64, 0x62, 0x64, 0x65, 0x30, 0x66, 0x61, 0x39, 0x63, 0x33, 0x66, 0x34, 0x66, 0x62, 0x33, 0x36, 0x37, 0x61, 0x66, 0x32, 0x32, 0x33, 0x64, 0x37, 0x37, 0x66, 0x62, 0x31, 0x36, 0x66, 0x31, 0x66, 0x38, 0x32, 0x37, 0x34, 0x65, 0x38, 0x36, 0x30, 0x33, 0x36, 0x37, 0x32, 0x32, 0x34, 0x65, 0x34, 0x30, 0x31, 0x31, 0x37, 0x33, 0x37, 0x61, 0x31, 0x37, 0x36, 0x65, 0x66, 0x64, 0x36, 0x64, 0x62, 0x39, 0x35, 0x35, 0x34, 0x66, 0x62, 0x64, 0x64, 0x38, 0x64, 0x61, 0x64, 0x63, 0x64, 0x36, 0x63, 0x38, 0x37, 0x37, 0x63, 0x61, 0x62, 0x30, 0x35, 0x33, 0x35, 0x37, 0x62, 0x39, 0x64, 0x64, 0x36, 0x63, 0x38, 0x62, 0x61, 0x32, 0x33, 0x64, 0x36, 0x35, 0x63, 0x36, 0x66, 0x38, 0x33, 0x62, 0x61, 0x61, 0x32, 0x34, 0x63, 0x31, 0x32, 0x39, 0x65, 0x39, 0x62, 0x63, 0x35, 0x36, 0x39, 0x36, 0x34, 0x63, 0x65, 0x30, 0x62, 0x64, 0x35, 0x39, 0x61, 0x61, 0x63, 0x38, 0x34, 0x38, 0x62, 0x36, 0x35, 0x66, 0x37, 0x30, 0x38, 0x64, 0x35, 0x63, 0x61, 0x35, 0x62, 0x63, 0x34, 0x37, 0x61, 0x36, 0x34, 0x35, 0x61, 0x33, 0x39, 0x61, 0x61, 0x35, 0x39, 0x38, 0x39, 0x32, 0x65, 0x30, 0x36, 0x66, 0x61, 0x32, 0x66, 0x61, 0x39, 0x66, 0x31, 0x34, 0x37, 0x64, 0x37, 0x64, 0x32, 0x34, 0x63, 0x62, 0x63, 0x36, 0x62, 0x30, 0x39, 0x37, 0x30, 0x63, 0x37, 0x31, 0x32, 0x32, 0x32, 0x61, 0x33, 0x36, 0x34, 0x38, 0x31, 0x63, 0x39, 0x34, 0x35, 0x34, 0x39, 0x62, 0x30, 0x31, 0x30, 0x65, 0x64, 0x30, 0x31, 0x33, 0x33, 0x61, 0x37, 0x63, 0x31, 0x65, 0x39, 0x31, 0x65, 0x37, 0x32, 0x34, 0x32, 0x38, 0x62, 0x30, 0x63, 0x37, 0x36, 0x31, 0x63, 0x33, 0x61, 0x64, 0x35, 0x62, 0x36, 0x31, 0x33, 0x37, 0x35, 0x34, 0x33, 0x62, 0x62, 0x38, 0x66, 0x31, 0x33, 0x66, 0x65, 0x33, 0x31, 0x61, 0x36, 0x66, 0x33, 0x64, 0x62, 0x63, 0x33, 0x66, 0x37, 0x64, 0x39, 0x63, 0x39, 0x30, 0x35, 0x39, 0x37, 0x61, 0x63, 0x34, 0x30, 0x36, 0x64, 0x65, 0x61, 0x61, 0x31, 0x30, 0x35, 0x37, 0x32, 0x62, 0x63, 0x33, 0x39, 0x36, 0x34, 0x30, 0x65, 0x37, 0x32, 0x34, 0x36, 0x36, 0x63, 0x66, 0x63, 0x30, 0x63, 0x63, 0x61, 0x38, 0x34, 0x39, 0x66, 0x32, 0x39, 0x62, 0x61, 0x30, 0x65, 0x39, 0x37, 0x31, 0x35, 0x38, 0x37, 0x38, 0x39, 0x38, 0x62, 0x35, 0x63, 0x34, 0x65, 0x37, 0x64, 0x39, 0x31, 0x65, 0x35, 0x38, 0x35, 0x35, 0x64, 0x61, 0x31, 0x63, 0x63, 0x65, 0x64, 0x63, 0x35, 0x37, 0x32, 0x63, 0x66, 0x66, 0x31, 0x64, 0x34, 0x37, 0x32, 0x33, 0x35, 0x36, 0x35, 0x64, 0x31, 0x62, 0x39, 0x63, 0x63, 0x65, 0x34, 0x32, 0x34, 0x34, 0x32, 0x34, 0x63, 0x64, 0x62, 0x37, 0x62, 0x30, 0x32, 0x31, 0x63, 0x65, 0x38, 0x63, 0x36, 0x64, 0x63, 0x62, 0x39, 0x33, 0x31, 0x63, 0x36, 0x64, 0x33, 0x63, 0x62, 0x63, 0x33, 0x65, 0x34, 0x38, 0x37, 0x31, 0x32, 0x30, 0x37, 0x39, 0x37, 0x31, 0x61, 0x64, 0x62, 0x36, 0x63, 0x39, 0x33, 0x62, 0x61, 0x39, 0x30, 0x31, 0x35, 0x61, 0x65, 0x36, 0x36, 0x30, 0x31, 0x65, 0x31, 0x65, 0x33, 0x30, 0x34, 0x30, 0x37, 0x30, 0x33, 0x61, 0x35, 0x66, 0x33, 0x38, 0x30, 0x66, 0x35, 0x37, 0x30, 0x39, 0x31, 0x64, 0x35, 0x35, 0x62, 0x38, 0x33, 0x37, 0x38, 0x38, 0x38, 0x34, 0x63, 0x65, 0x62, 0x38, 0x36, 0x33, 0x35, 0x31, 0x35, 0x32, 0x39, 0x32, 0x61, 0x64, 0x31, 0x35, 0x61, 0x61, 0x36, 0x31, 0x39, 0x36, 0x37, 0x33, 0x30, 0x35, 0x36, 0x65, 0x36, 0x31, 0x39, 0x37, 0x30, 0x66, 0x39, 0x37, 0x32, 0x34, 0x31, 0x33, 0x39, 0x33, 0x65, 0x33, 0x39, 0x62, 0x31, 0x62, 0x38, 0x63, 0x64, 0x65, 0x33, 0x36, 0x61, 0x66, 0x34, 0x37, 0x36, 0x34, 0x32, 0x64, 0x62, 0x65, 0x30, 0x35, 0x31, 0x33, 0x62, 0x37, 0x36, 0x62, 0x62, 0x62, 0x30, 0x31, 0x39, 0x63, 0x37, 0x32, 0x39, 0x39, 0x64, 0x61, 0x66, 0x30, 0x64, 0x36, 0x66, 0x65, 0x31, 0x62, 0x31, 0x34, 0x62, 0x63, 0x39, 0x65, 0x31, 0x66, 0x61, 0x36, 0x66, 0x62, 0x64, 0x36, 0x39, 0x33, 0x63, 0x38, 0x36, 0x37, 0x65, 0x63, 0x30, 0x66, 0x38, 0x39, 0x65, 0x62, 0x31, 0x66, 0x37, 0x36, 0x34, 0x38, 0x66, 0x35, 0x65, 0x39, 0x61, 0x39, 0x61, 0x30, 0x33, 0x32, 0x63, 0x65, 0x33, 0x31, 0x65, 0x35, 0x31, 0x62, 0x37, 0x64, 0x38, 0x33, 0x32, 0x65, 0x34, 0x61, 0x37, 0x39, 0x61, 0x61, 0x62, 0x65, 0x63, 0x61, 0x30, 0x39, 0x32, 0x38, 0x36, 0x35, 0x63, 0x32, 0x36, 0x66, 0x62, 0x31, 0x38, 0x61, 0x38, 0x35, 0x62, 0x61, 0x66, 0x61, 0x63, 0x37, 0x32, 0x34, 0x35, 0x31, 0x39, 0x61, 0x33, 0x33, 0x30, 0x32, 0x30, 0x33, 0x66, 0x38, 0x36, 0x63, 0x38, 0x35, 0x38, 0x36, 0x65, 0x33, 0x66, 0x35, 0x37, 0x35, 0x65, 0x32, 0x36, 0x39, 0x38, 0x32, 0x37, 0x63, 0x65, 0x65, 0x31, 0x34, 0x33, 0x31, 0x39, 0x63, 0x31, 0x38, 0x35, 0x64, 0x32, 0x30, 0x36, 0x66, 0x37, 0x63, 0x62, 0x39, 0x38, 0x32, 0x62, 0x63, 0x66, 0x63, 0x30, 0x63, 0x33, 0x30, 0x63, 0x61, 0x33, 0x37, 0x39, 0x31, 0x39, 0x39, 0x32, 0x66, 0x64, 0x35, 0x64, 0x36, 0x66, 0x37, 0x30, 0x38, 0x65, 0x38, 0x34, 0x36, 0x34, 0x64, 0x33, 0x64, 0x61, 0x31, 0x33, 0x34, 0x63, 0x65, 0x65, 0x38, 0x33, 0x62, 0x39, 0x64, 0x31, 0x34, 0x34, 0x66, 0x34, 0x32, 0x65, 0x66, 0x61, 0x37, 0x37, 0x65, 0x64, 0x39, 0x38, 0x32, 0x62, 0x61, 0x66, 0x64, 0x36, 0x37, 0x62, 0x37, 0x38, 0x39, 0x66, 0x37, 0x36, 0x36, 0x32, 0x31, 0x65, 0x34, 0x62, 0x37, 0x35, 0x34, 0x34, 0x63, 0x66, 0x65, 0x34, 0x33, 0x38, 0x38, 0x38, 0x37, 0x32, 0x66, 0x61, 0x30, 0x33, 0x33, 0x37, 0x65, 0x64, 0x34, 0x34, 0x63, 0x39, 0x62, 0x34, 0x31, 0x38, 0x35, 0x39, 0x32, 0x32, 0x37, 0x65, 0x33, 0x63, 0x38, 0x66, 0x36, 0x39, 0x63, 0x64, 0x63, 0x63, 0x37, 0x39, 0x33, 0x35, 0x61, 0x63, 0x32, 0x39, 0x39, 0x38, 0x66, 0x66, 0x38, 0x65, 0x36, 0x37, 0x30, 0x38, 0x64, 0x65, 0x36, 0x32, 0x37, 0x30, 0x64, 0x31, 0x66, 0x37, 0x33, 0x61, 0x37, 0x32, 0x30, 0x30, 0x38, 0x31, 0x63, 0x64, 0x64, 0x36, 0x30, 0x65, 0x64, 0x66, 0x65, 0x36, 0x66, 0x66, 0x32, 0x30, 0x65, 0x38, 0x30, 0x30, 0x32, 0x37, 0x32, 0x62, 0x39, 0x36, 0x35, 0x39, 0x64, 0x36, 0x39, 0x38, 0x30, 0x63, 0x37, 0x35, 0x61, 0x37, 0x33, 0x39, 0x63, 0x34, 0x35, 0x34, 0x32, 0x37, 0x33, 0x62, 0x64, 0x38, 0x65, 0x36, 0x62, 0x65, 0x38, 0x33, 0x36, 0x62, 0x33, 0x62, 0x37, 0x32, 0x65, 0x35, 0x31, 0x61, 0x36, 0x34, 0x64, 0x32, 0x62, 0x38, 0x34, 0x61, 0x33, 0x62, 0x64, 0x33, 0x39, 0x64, 0x34, 0x62, 0x63, 0x63, 0x62, 0x30, 0x38, 0x61, 0x62, 0x65, 0x33, 0x37, 0x66, 0x37, 0x66, 0x38, 0x38, 0x35, 0x36, 0x36, 0x33, 0x30, 0x64, 0x65, 0x36, 0x61, 0x30, 0x64, 0x30, 0x37, 0x30, 0x32, 0x37, 0x64, 0x62, 0x38, 0x62, 0x33, 0x35, 0x64, 0x64, 0x65, 0x63, 0x66, 0x32, 0x31, 0x63, 0x65, 0x38, 0x39, 0x39, 0x64, 0x38, 0x34, 0x66, 0x39, 0x62, 0x36, 0x39, 0x35, 0x65, 0x34, 0x33, 0x36, 0x63, 0x34, 0x63, 0x33, 0x37, 0x35, 0x33, 0x65, 0x33, 0x35, 0x35, 0x32, 0x61, 0x32, 0x35, 0x65, 0x37, 0x66, 0x39, 0x37, 0x37, 0x64, 0x39, 0x66, 0x66, 0x38, 0x64, 0x30, 0x34, 0x62, 0x64, 0x33, 0x39, 0x37, 0x66, 0x63, 0x35, 0x31, 0x30, 0x61, 0x64, 0x61, 0x65, 0x33, 0x37, 0x32, 0x34, 0x31, 0x65, 0x33, 0x61, 0x61, 0x33, 0x37, 0x66, 0x38, 0x31, 0x36, 0x61, 0x34, 0x36, 0x30, 0x37, 0x65, 0x34, 0x31, 0x62, 0x34, 0x65, 0x33, 0x38, 0x63, 0x30, 0x61, 0x38, 0x33, 0x64, 0x37, 0x62, 0x32, 0x64, 0x61, 0x35, 0x36, 0x32, 0x34, 0x35, 0x32, 0x32, 0x32, 0x30, 0x31, 0x32, 0x62, 0x34, 0x63, 0x33, 0x39, 0x66, 0x36, 0x39, 0x33, 0x35, 0x66, 0x33, 0x39, 0x34, 0x64, 0x33, 0x33, 0x64, 0x61, 0x34, 0x30, 0x65, 0x34, 0x36, 0x66, 0x61, 0x35, 0x34, 0x38, 0x38, 0x37, 0x64, 0x65, 0x37, 0x36, 0x30, 0x32, 0x39, 0x66, 0x64, 0x39, 0x39, 0x34, 0x61, 0x34, 0x66, 0x31, 0x64, 0x32, 0x66, 0x36, 0x35, 0x64, 0x35, 0x61, 0x34, 0x61, 0x32, 0x64, 0x63, 0x63, 0x66, 0x64, 0x32, 0x39, 0x33, 0x62, 0x38, 0x66, 0x31, 0x65, 0x35, 0x32, 0x31, 0x35, 0x35, 0x39, 0x62, 0x31, 0x37, 0x32, 0x38, 0x37, 0x61, 0x66, 0x66, 0x32, 0x30, 0x63, 0x33, 0x39, 0x61, 0x66, 0x34, 0x66, 0x32, 0x64, 0x30, 0x37, 0x39, 0x61, 0x35, 0x30, 0x32, 0x36, 0x33, 0x63, 0x61, 0x30, 0x63, 0x33, 0x39, 0x32, 0x39, 0x30, 0x34, 0x35, 0x65, 0x63, 0x37, 0x64, 0x39, 0x30, 0x37, 0x64, 0x39, 0x39, 0x32, 0x39, 0x30, 0x39, 0x32, 0x31, 0x61, 0x31, 0x39, 0x64, 0x30, 0x32, 0x66, 0x30, 0x32, 0x38, 0x32, 0x66, 0x63, 0x32, 0x35, 0x61, 0x31, 0x64, 0x63, 0x62, 0x65, 0x32, 0x64, 0x33, 0x33, 0x36, 0x30, 0x38, 0x63, 0x31, 0x31, 0x39, 0x36, 0x61, 0x35, 0x33, 0x36, 0x61, 0x64, 0x30, 0x39, 0x31, 0x33, 0x39, 0x30, 0x38, 0x65, 0x36, 0x62, 0x33, 0x38, 0x61, 0x65, 0x33, 0x61, 0x66, 0x34, 0x62, 0x35, 0x39, 0x30, 0x37, 0x62, 0x30, 0x34, 0x32, 0x32, 0x62, 0x65, 0x35, 0x65, 0x35, 0x35, 0x64, 0x37, 0x32, 0x61, 0x30, 0x63, 0x62, 0x30, 0x61, 0x66, 0x34, 0x34, 0x30, 0x63, 0x61, 0x36, 0x34, 0x32, 0x39, 0x66, 0x37, 0x32, 0x65, 0x38, 0x39, 0x62, 0x63, 0x30, 0x65, 0x61, 0x32, 0x37, 0x35, 0x30, 0x62, 0x38, 0x35, 0x63, 0x39, 0x62, 0x39, 0x37, 0x30, 0x31, 0x65, 0x63, 0x34, 0x65, 0x34, 0x33, 0x31, 0x33, 0x36, 0x64, 0x37, 0x33, 0x64, 0x31, 0x38, 0x64, 0x62, 0x38, 0x38, 0x32, 0x36, 0x35, 0x63, 0x31, 0x30, 0x65, 0x39, 0x62, 0x32, 0x32, 0x61, 0x34, 0x34, 0x39, 0x38, 0x65, 0x65, 0x39, 0x34, 0x37, 0x36, 0x33, 0x36, 0x63, 0x30, 0x61, 0x39, 0x38, 0x63, 0x33, 0x36, 0x63, 0x64, 0x31, 0x66, 0x37, 0x38, 0x62, 0x39, 0x63, 0x66, 0x37, 0x36, 0x61, 0x33, 0x62, 0x62, 0x36, 0x32, 0x65, 0x32, 0x66, 0x64, 0x63, 0x66, 0x31, 0x64, 0x36, 0x33, 0x36, 0x65, 0x65, 0x30, 0x62, 0x36, 0x36, 0x34, 0x66, 0x63, 0x35, 0x35, 0x65, 0x66, 0x38, 0x30, 0x38, 0x62, 0x30, 0x64, 0x32, 0x39, 0x62, 0x65, 0x31, 0x65, 0x36, 0x39, 0x36, 0x63, 0x64, 0x35, 0x33, 0x31, 0x66, 0x31, 0x33, 0x39, 0x66, 0x37, 0x61, 0x33, 0x30, 0x63, 0x32, 0x66, 0x64, 0x66, 0x65, 0x39, 0x61, 0x35, 0x65, 0x64, 0x65, 0x61, 0x64, 0x37, 0x30, 0x36, 0x33, 0x64, 0x66, 0x31, 0x37, 0x34, 0x37, 0x63, 0x62, 0x62, 0x30, 0x35, 0x32, 0x62, 0x38, 0x31, 0x32, 0x30, 0x66, 0x35, 0x35, 0x62, 0x64, 0x38, 0x39, 0x65, 0x36, 0x39, 0x32, 0x64, 0x66, 0x61, 0x66, 0x61, 0x30, 0x33, 0x39, 0x32, 0x33, 0x32, 0x64, 0x32, 0x62, 0x65, 0x38, 0x30, 0x61, 0x32, 0x64, 0x34, 0x37, 0x32, 0x32, 0x37, 0x38, 0x34, 0x33, 0x36, 0x63, 0x37, 0x30, 0x32, 0x35, 0x63, 0x31, 0x64, 0x39, 0x39, 0x39, 0x38, 0x61, 0x61, 0x31, 0x61, 0x37, 0x32, 0x34, 0x32, 0x30, 0x65, 0x37, 0x35, 0x65, 0x33, 0x32, 0x61, 0x37, 0x31, 0x39, 0x61, 0x33, 0x34, 0x30, 0x39, 0x61, 0x33, 0x34, 0x37, 0x34, 0x65, 0x36, 0x33, 0x30, 0x31, 0x32, 0x62, 0x63, 0x63, 0x66, 0x66, 0x34, 0x65, 0x31, 0x31, 0x36, 0x66, 0x61, 0x64, 0x35, 0x33, 0x33, 0x64, 0x39, 0x31, 0x35, 0x38, 0x30, 0x66, 0x63, 0x31, 0x66, 0x36, 0x32, 0x65, 0x37, 0x39, 0x39, 0x63, 0x32, 0x63, 0x34, 0x36, 0x32, 0x38, 0x32, 0x66, 0x35, 0x33, 0x62, 0x62, 0x65, 0x66, 0x34, 0x36, 0x30, 0x38, 0x30, 0x63, 0x33, 0x36, 0x37, 0x36, 0x32, 0x66, 0x36, 0x65, 0x61, 0x64, 0x38, 0x65, 0x61, 0x39, 0x64, 0x66, 0x39, 0x34, 0x30, 0x33, 0x61, 0x66, 0x66, 0x66, 0x35, 0x36, 0x30, 0x61, 0x64, 0x62, 0x37, 0x64, 0x61, 0x66, 0x38, 0x39, 0x37, 0x66, 0x33, 0x38, 0x32, 0x66, 0x63, 0x61, 0x37, 0x32, 0x31, 0x30, 0x37, 0x61, 0x62, 0x33, 0x61, 0x32, 0x64, 0x63, 0x62, 0x38, 0x33, 0x39, 0x32, 0x39, 0x34, 0x38, 0x33, 0x63, 0x36, 0x62, 0x63, 0x38, 0x38, 0x31, 0x35, 0x38, 0x66, 0x63, 0x36, 0x65, 0x64, 0x64, 0x39, 0x66, 0x62, 0x31, 0x39, 0x38, 0x37, 0x64, 0x30, 0x39, 0x36, 0x37, 0x31, 0x34, 0x39, 0x65, 0x30, 0x66, 0x32, 0x38, 0x64, 0x64, 0x33, 0x39, 0x38, 0x35, 0x63, 0x30, 0x37, 0x32, 0x61, 0x63, 0x63, 0x65, 0x39, 0x37, 0x32, 0x37, 0x30, 0x32, 0x66, 0x33, 0x30, 0x61, 0x36, 0x33, 0x31, 0x62, 0x32, 0x39, 0x36, 0x38, 0x61, 0x33, 0x32, 0x32, 0x62, 0x38, 0x64, 0x33, 0x62, 0x65, 0x62, 0x65, 0x64, 0x31, 0x34, 0x62, 0x64, 0x36, 0x30, 0x65, 0x63, 0x31, 0x63, 0x35, 0x30, 0x35, 0x65, 0x32, 0x33, 0x38, 0x39, 0x39, 0x37, 0x39, 0x30, 0x37, 0x38, 0x38, 0x61, 0x61, 0x37, 0x32, 0x31, 0x34, 0x62, 0x35, 0x30, 0x30, 0x63, 0x36, 0x35, 0x39, 0x34, 0x32, 0x34, 0x66, 0x38, 0x37, 0x35, 0x37, 0x34, 0x39, 0x37, 0x38, 0x65, 0x37, 0x32, 0x62, 0x62, 0x61, 0x30, 0x38, 0x66, 0x38, 0x65, 0x32, 0x62, 0x66, 0x37, 0x61, 0x31, 0x37, 0x37, 0x37, 0x61, 0x66, 0x38, 0x36, 0x63, 0x32, 0x35, 0x31, 0x65, 0x36, 0x38, 0x35, 0x32, 0x63, 0x33, 0x30, 0x30, 0x31, 0x64, 0x33, 0x37, 0x32, 0x35, 0x31, 0x38, 0x31, 0x37, 0x33, 0x32, 0x35, 0x66, 0x64, 0x38, 0x37, 0x63, 0x38, 0x32, 0x38, 0x31, 0x30, 0x36, 0x34, 0x66, 0x61, 0x61, 0x35, 0x31, 0x37, 0x30, 0x32, 0x39, 0x64, 0x33, 0x36, 0x33, 0x66, 0x38, 0x62, 0x31, 0x63, 0x33, 0x63, 0x61, 0x65, 0x65, 0x65, 0x64, 0x62, 0x63, 0x36, 0x63, 0x35, 0x36, 0x62, 0x36, 0x33, 0x63, 0x39, 0x33, 0x31, 0x38, 0x62, 0x31, 0x34, 0x33, 0x37, 0x32, 0x33, 0x65, 0x63, 0x35, 0x63, 0x39, 0x35, 0x30, 0x33, 0x61, 0x66, 0x32, 0x66, 0x30, 0x32, 0x32, 0x66, 0x31, 0x61, 0x38, 0x66, 0x64, 0x37, 0x32, 0x39, 0x66, 0x33, 0x65, 0x39, 0x66, 0x35, 0x34, 0x33, 0x33, 0x39, 0x33, 0x34, 0x31, 0x35, 0x37, 0x36, 0x62, 0x36, 0x37, 0x61, 0x31, 0x61, 0x38, 0x31, 0x66, 0x31, 0x30, 0x62, 0x36, 0x37, 0x63, 0x36, 0x33, 0x63, 0x61, 0x61, 0x32, 0x64, 0x31, 0x62, 0x32, 0x61, 0x65, 0x32, 0x66, 0x36, 0x33, 0x34, 0x30, 0x34, 0x32, 0x31, 0x61, 0x37, 0x31, 0x62, 0x36, 0x31, 0x38, 0x63, 0x36, 0x30, 0x65, 0x36, 0x65, 0x65, 0x65, 0x37, 0x33, 0x65, 0x65, 0x30, 0x34, 0x34, 0x66, 0x63, 0x65, 0x36, 0x34, 0x63, 0x33, 0x33, 0x35, 0x37, 0x31, 0x34, 0x65, 0x32, 0x63, 0x39, 0x62, 0x32, 0x34, 0x33, 0x39, 0x31, 0x65, 0x64, 0x38, 0x31, 0x36, 0x38, 0x38, 0x61, 0x64, 0x63, 0x34, 0x63, 0x64, 0x62, 0x32, 0x65, 0x65, 0x32, 0x62, 0x33, 0x62, 0x35, 0x37, 0x33, 0x38, 0x64, 0x36, 0x32, 0x31, 0x36, 0x38, 0x34, 0x35, 0x38, 0x66, 0x63, 0x63, 0x39, 0x33, 0x61, 0x30, 0x39, 0x33, 0x36, 0x65, 0x62, 0x61, 0x35, 0x62, 0x64, 0x30, 0x64, 0x31, 0x65, 0x63, 0x63, 0x37, 0x64, 0x63, 0x63, 0x39, 0x34, 0x64, 0x39, 0x33, 0x65, 0x30, 0x39, 0x31, 0x35, 0x36, 0x62, 0x33, 0x61, 0x33, 0x39, 0x61, 0x62, 0x38, 0x65, 0x64, 0x65, 0x39, 0x37, 0x37, 0x66, 0x63, 0x66, 0x61, 0x32, 0x32, 0x39, 0x65, 0x39, 0x65, 0x63, 0x37, 0x66, 0x36, 0x36, 0x66, 0x38, 0x30, 0x32, 0x38, 0x36, 0x35, 0x32, 0x30, 0x39, 0x31, 0x34, 0x36, 0x30, 0x31, 0x63, 0x64, 0x31, 0x39, 0x66, 0x36, 0x32, 0x65, 0x33, 0x37, 0x61, 0x62, 0x35, 0x33, 0x65, 0x64, 0x66, 0x32, 0x38, 0x65, 0x64, 0x62, 0x34, 0x65, 0x35, 0x65, 0x62, 0x38, 0x64, 0x63, 0x62, 0x30, 0x34, 0x65, 0x35, 0x31, 0x66, 0x37, 0x66, 0x38, 0x62, 0x65, 0x64, 0x33, 0x34, 0x65, 0x61, 0x38, 0x36, 0x62, 0x30, 0x62, 0x34, 0x66, 0x36, 0x39, 0x31, 0x64, 0x62, 0x33, 0x38, 0x35, 0x64, 0x38, 0x39, 0x32, 0x65, 0x64, 0x38, 0x61, 0x39, 0x35, 0x63, 0x61, 0x33, 0x39, 0x63, 0x31, 0x64, 0x65, 0x37, 0x37, 0x32, 0x32, 0x35, 0x61, 0x65, 0x34, 0x33, 0x37, 0x62, 0x32, 0x36, 0x62, 0x37, 0x63, 0x31, 0x34, 0x36, 0x35, 0x33, 0x66, 0x35, 0x33, 0x65, 0x63, 0x31, 0x37, 0x64, 0x64, 0x30, 0x30, 0x36, 0x64, 0x36, 0x36, 0x39, 0x63, 0x39, 0x34, 0x38, 0x35, 0x62, 0x64, 0x30, 0x35, 0x33, 0x66, 0x61, 0x66, 0x66, 0x66, 0x65, 0x36, 0x32, 0x30, 0x35, 0x35, 0x32, 0x61, 0x62, 0x32, 0x30, 0x37, 0x30, 0x37, 0x32, 0x62, 0x39, 0x38, 0x37, 0x33, 0x66, 0x62, 0x62, 0x38, 0x32, 0x65, 0x33, 0x36, 0x61, 0x32, 0x65, 0x64, 0x30, 0x30, 0x62, 0x62, 0x33, 0x65, 0x35, 0x38, 0x65, 0x64, 0x62, 0x37, 0x64, 0x30, 0x63, 0x37, 0x38, 0x31, 0x34, 0x34, 0x64, 0x64, 0x61, 0x39, 0x36, 0x35, 0x37, 0x35, 0x63, 0x31, 0x63, 0x61, 0x39, 0x39, 0x62, 0x38, 0x39, 0x31, 0x61, 0x66, 0x38, 0x63, 0x66, 0x36, 0x61, 0x31, 0x65, 0x32, 0x33, 0x39, 0x66, 0x64, 0x35, 0x34, 0x35, 0x39, 0x63, 0x62, 0x35, 0x66, 0x31, 0x39, 0x62, 0x66, 0x61, 0x61, 0x33, 0x66, 0x65, 0x65, 0x64, 0x36, 0x30, 0x63, 0x64, 0x32, 0x61, 0x65, 0x33, 0x62, 0x64, 0x62, 0x62, 0x63, 0x35, 0x35, 0x62, 0x31, 0x65, 0x64, 0x30, 0x31, 0x66, 0x36, 0x32, 0x35, 0x39, 0x31, 0x61, 0x64, 0x33, 0x31, 0x63, 0x32, 0x38, 0x66, 0x39, 0x39, 0x64, 0x37, 0x32, 0x61, 0x63, 0x66, 0x31, 0x63, 0x33, 0x31, 0x33, 0x63, 0x38, 0x61, 0x31, 0x31, 0x39, 0x31, 0x38, 0x39, 0x64, 0x30, 0x37, 0x35, 0x31, 0x33, 0x65, 0x38, 0x65, 0x38, 0x38, 0x65, 0x32, 0x64, 0x64, 0x30, 0x35, 0x34, 0x33, 0x30, 0x63, 0x31, 0x39, 0x37, 0x38, 0x65, 0x65, 0x61, 0x35, 0x62, 0x62, 0x63, 0x64, 0x36, 0x35, 0x37, 0x32, 0x32, 0x61, 0x38, 0x61, 0x61, 0x32, 0x30, 0x32, 0x37, 0x32, 0x35, 0x34, 0x64, 0x36, 0x31, 0x61, 0x38, 0x39, 0x64, 0x62, 0x30, 0x66, 0x66, 0x33, 0x37, 0x35, 0x36, 0x36, 0x66, 0x37, 0x61, 0x31, 0x37, 0x65, 0x66, 0x30, 0x38, 0x39, 0x31, 0x34, 0x65, 0x61, 0x36, 0x62, 0x62, 0x36, 0x36, 0x34, 0x34, 0x36, 0x37, 0x62, 0x31, 0x36, 0x36, 0x61, 0x35, 0x36, 0x34, 0x35, 0x36, 0x63, 0x35, 0x34, 0x32, 0x30, 0x34, 0x61, 0x65, 0x66, 0x34, 0x62, 0x37, 0x32, 0x62, 0x33, 0x37, 0x39, 0x34, 0x37, 0x37, 0x33, 0x37, 0x35, 0x34, 0x30, 0x34, 0x65, 0x39, 0x32, 0x65, 0x62, 0x36, 0x62, 0x37, 0x66, 0x61, 0x31, 0x31, 0x32, 0x66, 0x39, 0x64, 0x36, 0x31, 0x30, 0x66, 0x61, 0x39, 0x61, 0x65, 0x35, 0x35, 0x64, 0x38, 0x33, 0x65, 0x64, 0x63, 0x66, 0x38, 0x39, 0x64, 0x38, 0x30, 0x35, 0x66, 0x65, 0x30, 0x35, 0x32, 0x39, 0x35, 0x64, 0x30, 0x32, 0x30, 0x30, 0x64, 0x38, 0x62, 0x36, 0x66, 0x61, 0x66, 0x32, 0x32, 0x35, 0x66, 0x66, 0x61, 0x62, 0x35, 0x63, 0x66, 0x35, 0x34, 0x34, 0x37, 0x63, 0x39, 0x61, 0x32, 0x34, 0x62, 0x61, 0x66, 0x33, 0x33, 0x32, 0x37, 0x66, 0x36, 0x33, 0x34, 0x37, 0x62, 0x34, 0x66, 0x37, 0x37, 0x38, 0x62, 0x63, 0x32, 0x38, 0x66, 0x38, 0x62, 0x32, 0x61, 0x37, 0x66, 0x37, 0x36, 0x33, 0x34, 0x31, 0x39, 0x31, 0x35, 0x66, 0x62, 0x37, 0x33, 0x65, 0x36, 0x38, 0x61, 0x63, 0x35, 0x63, 0x66, 0x63, 0x63, 0x65, 0x63, 0x30, 0x63, 0x65, 0x31, 0x30, 0x66, 0x64, 0x65, 0x38, 0x34, 0x34, 0x65, 0x30, 0x34, 0x38, 0x33, 0x66, 0x33, 0x37, 0x61, 0x33, 0x63, 0x66, 0x65, 0x38, 0x31, 0x35, 0x35, 0x30, 0x36, 0x63, 0x33, 0x33, 0x66, 0x65, 0x34, 0x34, 0x63, 0x66, 0x61, 0x65, 0x63, 0x31, 0x62, 0x34, 0x30, 0x64, 0x37, 0x32, 0x33, 0x39, 0x38, 0x65, 0x39, 0x62, 0x35, 0x30, 0x31, 0x64, 0x35, 0x31, 0x62, 0x30, 0x61, 0x65, 0x37, 0x63, 0x64, 0x63, 0x30, 0x65, 0x63, 0x61, 0x35, 0x30, 0x37, 0x34, 0x64, 0x38, 0x37, 0x37, 0x39, 0x35, 0x61, 0x30, 0x33, 0x30, 0x61, 0x37, 0x35, 0x33, 0x37, 0x62, 0x62, 0x32, 0x30, 0x65, 0x36, 0x34, 0x61, 0x62, 0x66, 0x62, 0x31, 0x38, 0x33, 0x36, 0x37, 0x35, 0x31, 0x39, 0x37, 0x32, 0x65, 0x66, 0x35, 0x36, 0x34, 0x32, 0x39, 0x30, 0x38, 0x63, 0x33, 0x66, 0x63, 0x65, 0x35, 0x66, 0x37, 0x32, 0x30, 0x39, 0x33, 0x35, 0x39, 0x61, 0x33, 0x37, 0x63, 0x30, 0x39, 0x33, 0x65, 0x64, 0x65, 0x63, 0x31, 0x62, 0x62, 0x63, 0x31, 0x61, 0x38, 0x63, 0x39, 0x34, 0x32, 0x62, 0x35, 0x34, 0x63, 0x38, 0x66, 0x37, 0x39, 0x36, 0x63, 0x37, 0x30, 0x62, 0x66, 0x39, 0x64, 0x39, 0x37, 0x32, 0x39, 0x30, 0x61, 0x63, 0x35, 0x34, 0x32, 0x33, 0x39, 0x66, 0x62, 0x33, 0x39, 0x65, 0x32, 0x34, 0x66, 0x39, 0x63, 0x65, 0x32, 0x66, 0x30, 0x64, 0x31, 0x32, 0x64, 0x39, 0x66, 0x36, 0x66, 0x61, 0x38, 0x37, 0x66, 0x64, 0x63, 0x64, 0x35, 0x66, 0x31, 0x62, 0x66, 0x31, 0x36, 0x35, 0x32, 0x62, 0x63, 0x31, 0x31, 0x63, 0x30, 0x63, 0x64, 0x62, 0x61, 0x62, 0x33, 0x30, 0x36, 0x39, 0x35, 0x35, 0x33, 0x38, 0x64, 0x37, 0x31, 0x66, 0x64, 0x37, 0x38, 0x34, 0x66, 0x39, 0x30, 0x65, 0x36, 0x30, 0x66, 0x39, 0x61, 0x39, 0x30, 0x65, 0x66, 0x37, 0x63, 0x64, 0x30, 0x32, 0x61, 0x37, 0x61, 0x37, 0x36, 0x32, 0x30, 0x33, 0x38, 0x32, 0x32, 0x37, 0x37, 0x31, 0x63, 0x61, 0x34, 0x61, 0x30, 0x38, 0x37, 0x64, 0x36, 0x62, 0x63, 0x38, 0x31, 0x38, 0x39, 0x37, 0x65, 0x37, 0x30, 0x32, 0x37, 0x32, 0x64, 0x39, 0x36, 0x64, 0x33, 0x64, 0x64, 0x38, 0x30, 0x30, 0x36, 0x65, 0x63, 0x66, 0x33, 0x36, 0x63, 0x65, 0x33, 0x66, 0x65, 0x32, 0x35, 0x35, 0x63, 0x33, 0x39, 0x62, 0x36, 0x30, 0x66, 0x37, 0x36, 0x64, 0x31, 0x33, 0x33, 0x31, 0x36, 0x66, 0x61, 0x37, 0x64, 0x62, 0x62, 0x33, 0x33, 0x61, 0x33, 0x65, 0x39, 0x39, 0x33, 0x33, 0x39, 0x35, 0x39, 0x34, 0x33, 0x35, 0x38, 0x63, 0x37, 0x32, 0x66, 0x33, 0x65, 0x31, 0x34, 0x35, 0x61, 0x31, 0x34, 0x64, 0x37, 0x66, 0x30, 0x35, 0x61, 0x35, 0x36, 0x65, 0x31, 0x34, 0x32, 0x33, 0x30, 0x64, 0x37, 0x37, 0x36, 0x31, 0x38, 0x33, 0x33, 0x35, 0x62, 0x33, 0x32, 0x34, 0x36, 0x66, 0x38, 0x39, 0x66, 0x35, 0x38, 0x63, 0x33, 0x65, 0x39, 0x30, 0x64, 0x33, 0x39, 0x64, 0x62, 0x65, 0x64, 0x63, 0x66, 0x65, 0x34, 0x39, 0x32, 0x36, 0x37, 0x32, 0x65, 0x65, 0x31, 0x32, 0x31, 0x34, 0x38, 0x61, 0x30, 0x39, 0x65, 0x61, 0x63, 0x39, 0x61, 0x63, 0x33, 0x61, 0x61, 0x66, 0x36, 0x37, 0x30, 0x65, 0x32, 0x63, 0x36, 0x37, 0x36, 0x34, 0x35, 0x37, 0x31, 0x32, 0x37, 0x32, 0x34, 0x35, 0x35, 0x30, 0x61, 0x64, 0x65, 0x37, 0x37, 0x64, 0x62, 0x39, 0x61, 0x32, 0x30, 0x39, 0x34, 0x62, 0x61, 0x38, 0x64, 0x30, 0x61, 0x65, 0x62, 0x30, 0x37, 0x32, 0x61, 0x32, 0x38, 0x61, 0x35, 0x38, 0x61, 0x38, 0x35, 0x34, 0x30, 0x39, 0x65, 0x32, 0x66, 0x36, 0x62, 0x39, 0x63, 0x37, 0x38, 0x33, 0x35, 0x37, 0x65, 0x33, 0x32, 0x64, 0x39, 0x62, 0x33, 0x33, 0x33, 0x34, 0x37, 0x39, 0x31, 0x35, 0x63, 0x65, 0x33, 0x30, 0x39, 0x34, 0x63, 0x63, 0x35, 0x30, 0x37, 0x30, 0x39, 0x61, 0x66, 0x39, 0x32, 0x65, 0x65, 0x37, 0x32, 0x38, 0x38, 0x38, 0x37, 0x32, 0x66, 0x65, 0x39, 0x32, 0x66, 0x62, 0x63, 0x63, 0x62, 0x35, 0x37, 0x31, 0x66, 0x34, 0x36, 0x32, 0x36, 0x33, 0x63, 0x66, 0x61, 0x61, 0x36, 0x65, 0x64, 0x37, 0x65, 0x33, 0x37, 0x65, 0x33, 0x34, 0x66, 0x37, 0x38, 0x34, 0x36, 0x34, 0x36, 0x36, 0x39, 0x62, 0x31, 0x36, 0x66, 0x37, 0x63, 0x61, 0x37, 0x33, 0x66, 0x39, 0x39, 0x36, 0x33, 0x31, 0x33, 0x32, 0x66, 0x34, 0x33, 0x38, 0x32, 0x61, 0x38, 0x61, 0x63, 0x34, 0x35, 0x64, 0x30, 0x32, 0x63, 0x31, 0x37, 0x66, 0x37, 0x33, 0x34, 0x62, 0x34, 0x64, 0x65, 0x64, 0x61, 0x66, 0x36, 0x61, 0x35, 0x33, 0x35, 0x66, 0x64, 0x34, 0x62, 0x34, 0x39, 0x38, 0x30, 0x31, 0x61, 0x35, 0x61, 0x34, 0x61, 0x37, 0x65, 0x35, 0x38, 0x30, 0x64, 0x30, 0x36, 0x61, 0x64, 0x33, 0x63, 0x61, 0x63, 0x37, 0x64, 0x36, 0x32, 0x62, 0x30, 0x35, 0x34, 0x30, 0x61, 0x34, 0x64, 0x62, 0x37, 0x32, 0x66, 0x32, 0x32, 0x63, 0x37, 0x33, 0x62, 0x34, 0x62, 0x35, 0x38, 0x61, 0x34, 0x61, 0x36, 0x61, 0x31, 0x30, 0x32, 0x61, 0x34, 0x66, 0x63, 0x39, 0x37, 0x38, 0x34, 0x64, 0x39, 0x39, 0x62, 0x31, 0x32, 0x33, 0x31, 0x62, 0x35, 0x31, 0x64, 0x39, 0x63, 0x31, 0x62, 0x65, 0x38, 0x38, 0x30, 0x62, 0x39, 0x39, 0x34, 0x31, 0x34, 0x32, 0x66, 0x65, 0x37, 0x32, 0x35, 0x31, 0x32, 0x32, 0x38, 0x63, 0x63, 0x32, 0x30, 0x31, 0x30, 0x32, 0x62, 0x38, 0x61, 0x35, 0x34, 0x63, 0x63, 0x39, 0x65, 0x31, 0x61, 0x65, 0x33, 0x33, 0x65, 0x38, 0x64, 0x32, 0x31, 0x64, 0x36, 0x35, 0x35, 0x35, 0x63, 0x64, 0x35, 0x62, 0x35, 0x61, 0x62, 0x39, 0x36, 0x30, 0x63, 0x37, 0x33, 0x34, 0x36, 0x65, 0x62, 0x33, 0x33, 0x61, 0x65, 0x37, 0x36, 0x38, 0x63, 0x30, 0x37, 0x32, 0x39, 0x34, 0x32, 0x37, 0x36, 0x36, 0x36, 0x61, 0x33, 0x36, 0x34, 0x34, 0x63, 0x35, 0x30, 0x32, 0x38, 0x31, 0x31, 0x32, 0x62, 0x30, 0x66, 0x32, 0x64, 0x30, 0x66, 0x63, 0x66, 0x65, 0x34, 0x31, 0x38, 0x35, 0x66, 0x63, 0x66, 0x38, 0x37, 0x33, 0x64, 0x66, 0x64, 0x65, 0x33, 0x61, 0x61, 0x33, 0x61, 0x39, 0x62, 0x36, 0x34, 0x63, 0x62, 0x33, 0x36, 0x64, 0x32, 0x37, 0x64, 0x66, 0x37, 0x32, 0x62, 0x30, 0x32, 0x37, 0x61, 0x62, 0x37, 0x34, 0x34, 0x65, 0x62, 0x31, 0x34, 0x38, 0x66, 0x61, 0x32, 0x34, 0x63, 0x66, 0x62, 0x64, 0x36, 0x62, 0x63, 0x34, 0x33, 0x62, 0x38, 0x62, 0x30, 0x38, 0x66, 0x65, 0x61, 0x66, 0x32, 0x38, 0x39, 0x32, 0x31, 0x34, 0x36, 0x30, 0x33, 0x66, 0x38, 0x35, 0x65, 0x30, 0x36, 0x61, 0x30, 0x66, 0x33, 0x61, 0x65, 0x61, 0x65, 0x39, 0x32, 0x33, 0x37, 0x32, 0x35, 0x31, 0x39, 0x63, 0x37, 0x38, 0x32, 0x37, 0x34, 0x65, 0x62, 0x33, 0x39, 0x33, 0x63, 0x36, 0x39, 0x34, 0x65, 0x32, 0x32, 0x32, 0x39, 0x34, 0x32, 0x63, 0x34, 0x38, 0x32, 0x31, 0x38, 0x32, 0x63, 0x31, 0x39, 0x65, 0x32, 0x35, 0x37, 0x66, 0x62, 0x30, 0x62, 0x61, 0x32, 0x39, 0x34, 0x30, 0x62, 0x38, 0x37, 0x30, 0x34, 0x31, 0x64, 0x36, 0x34, 0x64, 0x30, 0x65, 0x65, 0x63, 0x34, 0x65, 0x30, 0x34, 0x64, 0x63, 0x33, 0x33, 0x32, 0x34, 0x36, 0x65, 0x62, 0x36, 0x61, 0x65, 0x33, 0x61, 0x36, 0x32, 0x61, 0x66, 0x61, 0x38, 0x66, 0x62, 0x62, 0x32, 0x32, 0x66, 0x32, 0x65, 0x61, 0x34, 0x65, 0x37, 0x33, 0x34, 0x36, 0x31, 0x36, 0x63, 0x62, 0x35, 0x62, 0x62, 0x63, 0x66, 0x64, 0x33, 0x62, 0x38, 0x31, 0x37, 0x61, 0x31, 0x37, 0x32, 0x63, 0x62, 0x34, 0x30, 0x31, 0x63, 0x37, 0x32, 0x61, 0x38, 0x63, 0x33, 0x64, 0x39, 0x33, 0x65, 0x31, 0x61, 0x31, 0x35, 0x65, 0x66, 0x64, 0x38, 0x61, 0x36, 0x62, 0x36, 0x39, 0x30, 0x33, 0x36, 0x32, 0x36, 0x62, 0x34, 0x62, 0x33, 0x65, 0x61, 0x65, 0x32, 0x64, 0x64, 0x61, 0x66, 0x63, 0x36, 0x34, 0x32, 0x35, 0x63, 0x63, 0x31, 0x64, 0x31, 0x34, 0x62, 0x64, 0x34, 0x31, 0x65, 0x33, 0x30, 0x65, 0x65, 0x63, 0x64, 0x37, 0x36, 0x37, 0x32, 0x30, 0x38, 0x36, 0x61, 0x37, 0x66, 0x38, 0x62, 0x66, 0x39, 0x35, 0x64, 0x63, 0x39, 0x64, 0x34, 0x63, 0x39, 0x37, 0x30, 0x65, 0x62, 0x36, 0x62, 0x31, 0x66, 0x32, 0x30, 0x66, 0x66, 0x36, 0x34, 0x30, 0x32, 0x37, 0x34, 0x33, 0x35, 0x63, 0x63, 0x31, 0x39, 0x66, 0x33, 0x61, 0x30, 0x37, 0x36, 0x34, 0x65, 0x39, 0x35, 0x38, 0x63, 0x34, 0x63, 0x34, 0x34, 0x65, 0x36, 0x63, 0x64, 0x34, 0x66, 0x61, 0x36, 0x37, 0x30, 0x32, 0x36, 0x66, 0x62, 0x39, 0x33, 0x37, 0x62, 0x66, 0x30, 0x62, 0x32, 0x63, 0x61, 0x32, 0x33, 0x39, 0x37, 0x37, 0x32, 0x65, 0x63, 0x35, 0x32, 0x33, 0x35, 0x65, 0x63, 0x63, 0x36, 0x38, 0x39, 0x31, 0x65, 0x30, 0x39, 0x33, 0x61, 0x31, 0x31, 0x36, 0x37, 0x33, 0x36, 0x35, 0x38, 0x38, 0x30, 0x37, 0x33, 0x61, 0x62, 0x38, 0x62, 0x31, 0x32, 0x63, 0x33, 0x37, 0x32, 0x37, 0x30, 0x36, 0x37, 0x66, 0x32, 0x36, 0x66, 0x61, 0x36, 0x33, 0x64, 0x39, 0x63, 0x30, 0x33, 0x64, 0x63, 0x38, 0x36, 0x32, 0x63, 0x30, 0x61, 0x65, 0x65, 0x66, 0x37, 0x36, 0x62, 0x64, 0x66, 0x32, 0x61, 0x61, 0x31, 0x39, 0x36, 0x64, 0x30, 0x35, 0x64, 0x61, 0x37, 0x35, 0x62, 0x36, 0x37, 0x62, 0x34, 0x66, 0x62, 0x61, 0x62, 0x37, 0x64, 0x34, 0x38, 0x35, 0x35, 0x66, 0x39, 0x37, 0x32, 0x62, 0x66, 0x39, 0x63, 0x38, 0x33, 0x33, 0x62, 0x31, 0x64, 0x30, 0x38, 0x61, 0x63, 0x63, 0x62, 0x61, 0x34, 0x65, 0x62, 0x33, 0x63, 0x30, 0x38, 0x36, 0x33, 0x38, 0x30, 0x34, 0x63, 0x31, 0x62, 0x33, 0x38, 0x63, 0x34, 0x32, 0x33, 0x61, 0x66, 0x35, 0x35, 0x31, 0x62, 0x66, 0x35, 0x66, 0x32, 0x39, 0x37, 0x37, 0x32, 0x30, 0x34, 0x32, 0x31, 0x35, 0x65, 0x61, 0x36, 0x36, 0x30, 0x35, 0x36, 0x37, 0x61, 0x34, 0x35, 0x66, 0x62, 0x30, 0x35, 0x61, 0x37, 0x66, 0x38, 0x36, 0x32, 0x39, 0x38, 0x65, 0x61, 0x30, 0x35, 0x32, 0x64, 0x65, 0x37, 0x36, 0x62, 0x36, 0x34, 0x65, 0x32, 0x31, 0x66, 0x65, 0x30, 0x34, 0x66, 0x61, 0x61, 0x30, 0x30, 0x31, 0x35, 0x61, 0x39, 0x30, 0x35, 0x63, 0x37, 0x31, 0x35, 0x35, 0x31, 0x35, 0x34, 0x37, 0x33, 0x31, 0x62, 0x32, 0x66, 0x62, 0x34, 0x37, 0x32, 0x30, 0x30, 0x38, 0x36, 0x37, 0x31, 0x65, 0x31, 0x34, 0x65, 0x61, 0x65, 0x34, 0x37, 0x63, 0x32, 0x31, 0x62, 0x31, 0x36, 0x65, 0x35, 0x62, 0x34, 0x30, 0x66, 0x39, 0x31, 0x66, 0x31, 0x37, 0x30, 0x34, 0x62, 0x66, 0x66, 0x38, 0x30, 0x38, 0x38, 0x66, 0x36, 0x32, 0x62, 0x35, 0x62, 0x63, 0x61, 0x32, 0x32, 0x62, 0x30, 0x33, 0x30, 0x62, 0x62, 0x31, 0x66, 0x61, 0x62, 0x36, 0x31, 0x37, 0x32, 0x37, 0x62, 0x38, 0x61, 0x39, 0x61, 0x37, 0x38, 0x35, 0x36, 0x36, 0x64, 0x38, 0x31, 0x38, 0x38, 0x31, 0x32, 0x37, 0x31, 0x37, 0x66, 0x66, 0x31, 0x32, 0x33, 0x62, 0x65, 0x39, 0x63, 0x34, 0x64, 0x64, 0x36, 0x39, 0x33, 0x66, 0x66, 0x61, 0x31, 0x61, 0x36, 0x66, 0x30, 0x35, 0x36, 0x65, 0x32, 0x36, 0x61, 0x62, 0x32, 0x37, 0x31, 0x61, 0x66, 0x39, 0x61, 0x38, 0x65, 0x62, 0x65, 0x37, 0x32, 0x64, 0x61, 0x63, 0x62, 0x38, 0x65, 0x30, 0x39, 0x35, 0x63, 0x64, 0x66, 0x65, 0x32, 0x61, 0x35, 0x62, 0x31, 0x66, 0x63, 0x31, 0x34, 0x65, 0x62, 0x30, 0x31, 0x39, 0x33, 0x35, 0x63, 0x37, 0x32, 0x61, 0x62, 0x37, 0x61, 0x37, 0x64, 0x30, 0x65, 0x65, 0x66, 0x32, 0x32, 0x36, 0x36, 0x37, 0x65, 0x34, 0x33, 0x34, 0x34, 0x62, 0x31, 0x31, 0x62, 0x34, 0x36, 0x61, 0x61, 0x33, 0x64, 0x37, 0x32, 0x31, 0x66, 0x34, 0x65, 0x36, 0x66, 0x35, 0x39, 0x61, 0x63, 0x39, 0x39, 0x62, 0x30, 0x33, 0x37, 0x39, 0x39, 0x62, 0x35, 0x63, 0x31, 0x61, 0x39, 0x65, 0x31, 0x36, 0x34, 0x64, 0x32, 0x34, 0x64, 0x32, 0x32, 0x36, 0x66, 0x30, 0x33, 0x34, 0x32, 0x38, 0x64, 0x39, 0x39, 0x63, 0x34, 0x33, 0x63, 0x34, 0x65, 0x34, 0x64, 0x32, 0x37, 0x37, 0x39, 0x34, 0x36, 0x61, 0x34, 0x63, 0x35, 0x31, 0x35, 0x64, 0x31, 0x36, 0x30, 0x61, 0x30, 0x32, 0x32, 0x65, 0x64, 0x36, 0x36, 0x62, 0x63, 0x64, 0x37, 0x39, 0x32, 0x38, 0x34, 0x64, 0x35, 0x62, 0x62, 0x30, 0x36, 0x66, 0x62, 0x36, 0x35, 0x66, 0x32, 0x65, 0x32, 0x62, 0x32, 0x64, 0x66, 0x31, 0x31, 0x61, 0x66, 0x37, 0x65, 0x62, 0x62, 0x37, 0x37, 0x65, 0x38, 0x32, 0x65, 0x37, 0x32, 0x36, 0x66, 0x63, 0x36, 0x34, 0x30, 0x35, 0x33, 0x34, 0x32, 0x35, 0x30, 0x66, 0x62, 0x33, 0x37, 0x62, 0x63, 0x61, 0x31, 0x62, 0x30, 0x64, 0x65, 0x36, 0x34, 0x30, 0x31, 0x63, 0x38, 0x39, 0x31, 0x39, 0x65, 0x64, 0x34, 0x35, 0x33, 0x36, 0x34, 0x64, 0x66, 0x64, 0x30, 0x61, 0x37, 0x31, 0x32, 0x66, 0x61, 0x66, 0x64, 0x61, 0x65, 0x36, 0x35, 0x38, 0x36, 0x36, 0x66, 0x66, 0x37, 0x33, 0x37, 0x64, 0x36, 0x63, 0x30, 0x36, 0x61, 0x65, 0x39, 0x36, 0x39, 0x34, 0x32, 0x31, 0x63, 0x30, 0x30, 0x38, 0x36, 0x61, 0x34, 0x31, 0x61, 0x34, 0x35, 0x39, 0x63, 0x34, 0x35, 0x66, 0x64, 0x36, 0x37, 0x34, 0x30, 0x36, 0x65, 0x30, 0x34, 0x36, 0x66, 0x65, 0x36, 0x33, 0x65, 0x66, 0x66, 0x63, 0x65, 0x33, 0x64, 0x36, 0x62, 0x36, 0x30, 0x35, 0x39, 0x30, 0x38, 0x38, 0x64, 0x31, 0x38, 0x65, 0x37, 0x61, 0x36, 0x32, 0x36, 0x65, 0x63, 0x33, 0x39, 0x37, 0x32, 0x64, 0x63, 0x64, 0x62, 0x35, 0x35, 0x62, 0x64, 0x39, 0x31, 0x36, 0x63, 0x62, 0x66, 0x63, 0x63, 0x66, 0x34, 0x38, 0x37, 0x33, 0x32, 0x38, 0x65, 0x36, 0x61, 0x62, 0x62, 0x37, 0x32, 0x34, 0x63, 0x64, 0x33, 0x36, 0x39, 0x61, 0x65, 0x34, 0x30, 0x39, 0x61, 0x64, 0x64, 0x62, 0x39, 0x38, 0x62, 0x32, 0x38, 0x61, 0x31, 0x37, 0x38, 0x36, 0x62, 0x63, 0x37, 0x37, 0x65, 0x39, 0x37, 0x31, 0x37, 0x30, 0x38, 0x63, 0x37, 0x39, 0x38, 0x36, 0x63, 0x63, 0x35, 0x66, 0x61, 0x66, 0x63, 0x37, 0x30, 0x39, 0x30, 0x39, 0x37, 0x32, 0x64, 0x30, 0x37, 0x30, 0x62, 0x64, 0x66, 0x62, 0x34, 0x62, 0x65, 0x33, 0x66, 0x31, 0x36, 0x30, 0x66, 0x65, 0x62, 0x65, 0x32, 0x36, 0x37, 0x66, 0x37, 0x63, 0x38, 0x34, 0x37, 0x36, 0x38, 0x31, 0x63, 0x39, 0x63, 0x66, 0x61, 0x30, 0x37, 0x30, 0x65, 0x37, 0x32, 0x36, 0x38, 0x61, 0x39, 0x65, 0x38, 0x39, 0x31, 0x34, 0x61, 0x38, 0x38, 0x38, 0x31, 0x35, 0x38, 0x66, 0x33, 0x35, 0x39, 0x39, 0x65, 0x34, 0x33, 0x30, 0x64, 0x61, 0x65, 0x65, 0x37, 0x30, 0x34, 0x64, 0x66, 0x62, 0x65, 0x36, 0x61, 0x65, 0x30, 0x30, 0x61, 0x33, 0x62, 0x31, 0x34, 0x35, 0x30, 0x62, 0x39, 0x32, 0x64, 0x61, 0x38, 0x62, 0x34, 0x31, 0x38, 0x65, 0x30, 0x39, 0x35, 0x31, 0x35, 0x66, 0x61, 0x65, 0x37, 0x35, 0x30, 0x32, 0x64, 0x33, 0x36, 0x34, 0x62, 0x64, 0x66, 0x33, 0x34, 0x33, 0x38, 0x39, 0x30, 0x36, 0x32, 0x38, 0x36, 0x38, 0x36, 0x64, 0x30, 0x62, 0x63, 0x64, 0x64, 0x31, 0x37, 0x63, 0x65, 0x35, 0x37, 0x37, 0x64, 0x64, 0x62, 0x61, 0x33, 0x63, 0x39, 0x31, 0x39, 0x38, 0x34, 0x66, 0x31, 0x65, 0x37, 0x62, 0x64, 0x39, 0x38, 0x64, 0x34, 0x65, 0x66, 0x37, 0x32, 0x39, 0x36, 0x36, 0x34, 0x37, 0x31, 0x32, 0x38, 0x30, 0x64, 0x39, 0x66, 0x37, 0x37, 0x64, 0x36, 0x36, 0x35, 0x38, 0x36, 0x32, 0x37, 0x30, 0x33, 0x30, 0x37, 0x38, 0x32, 0x36, 0x38, 0x34, 0x65, 0x32, 0x37, 0x66, 0x38, 0x36, 0x66, 0x62, 0x31, 0x36, 0x62, 0x30, 0x63, 0x63, 0x65, 0x34, 0x36, 0x31, 0x31, 0x61, 0x34, 0x35, 0x36, 0x37, 0x65, 0x34, 0x33, 0x30, 0x39, 0x35, 0x62, 0x34, 0x31, 0x36, 0x37, 0x33, 0x65, 0x30, 0x64, 0x30, 0x35, 0x62, 0x64, 0x62, 0x62, 0x66, 0x33, 0x33, 0x62, 0x62, 0x33, 0x35, 0x61, 0x31, 0x65, 0x37, 0x34, 0x32, 0x64, 0x65, 0x66, 0x65, 0x31, 0x39, 0x33, 0x32, 0x66, 0x65, 0x65, 0x64, 0x61, 0x31, 0x30, 0x34, 0x32, 0x66, 0x61, 0x34, 0x62, 0x64, 0x36, 0x30, 0x38, 0x36, 0x64, 0x32, 0x62, 0x62, 0x34, 0x34, 0x37, 0x36, 0x37, 0x33, 0x65, 0x33, 0x64, 0x32, 0x31, 0x33, 0x34, 0x66, 0x61, 0x33, 0x32, 0x38, 0x65, 0x65, 0x35, 0x30, 0x36, 0x30, 0x38, 0x64, 0x35, 0x34, 0x33, 0x39, 0x66, 0x36, 0x35, 0x37, 0x66, 0x66, 0x30, 0x34, 0x35, 0x63, 0x39, 0x33, 0x64, 0x33, 0x30, 0x34, 0x37, 0x34, 0x61, 0x36, 0x31, 0x66, 0x33, 0x64, 0x34, 0x32, 0x32, 0x61, 0x36, 0x38, 0x34, 0x61, 0x37, 0x31, 0x64, 0x34, 0x61, 0x31, 0x65, 0x66, 0x30, 0x37, 0x32, 0x37, 0x62, 0x32, 0x34, 0x32, 0x31, 0x33, 0x61, 0x35, 0x66, 0x31, 0x38, 0x31, 0x64, 0x37, 0x35, 0x64, 0x63, 0x65, 0x32, 0x62, 0x31, 0x30, 0x33, 0x32, 0x30, 0x38, 0x66, 0x37, 0x63, 0x62, 0x36, 0x61, 0x37, 0x64, 0x62, 0x66, 0x33, 0x38, 0x62, 0x37, 0x64, 0x61, 0x65, 0x63, 0x65, 0x63, 0x35, 0x33, 0x34, 0x64, 0x31, 0x39, 0x35, 0x62, 0x34, 0x38, 0x34, 0x66, 0x35, 0x65, 0x36, 0x31, 0x38, 0x34, 0x37, 0x63, 0x61, 0x62, 0x64, 0x62, 0x39, 0x63, 0x36, 0x61, 0x32, 0x65, 0x33, 0x31, 0x32, 0x37, 0x64, 0x38, 0x64, 0x31, 0x65, 0x30, 0x31, 0x64, 0x30, 0x30, 0x62, 0x34, 0x32, 0x65, 0x31, 0x30, 0x66, 0x34, 0x32, 0x32, 0x34, 0x32, 0x64, 0x38, 0x66, 0x65, 0x64, 0x62, 0x33, 0x65, 0x38, 0x30, 0x61, 0x61, 0x64, 0x33, 0x64, 0x36, 0x35, 0x32, 0x39, 0x34, 0x38, 0x36, 0x39, 0x34, 0x32, 0x36, 0x37, 0x34, 0x36, 0x38, 0x62, 0x30, 0x64, 0x39, 0x65, 0x38, 0x35, 0x36, 0x31, 0x38, 0x36, 0x32, 0x63, 0x63, 0x33, 0x33, 0x35, 0x65, 0x37, 0x37, 0x38, 0x38, 0x38, 0x35, 0x64, 0x36, 0x35, 0x31, 0x37, 0x31, 0x36, 0x64, 0x65, 0x32, 0x64, 0x39, 0x34, 0x33, 0x36, 0x63, 0x38, 0x33, 0x65, 0x36, 0x36, 0x64, 0x33, 0x31, 0x39, 0x64, 0x30, 0x38, 0x62, 0x66, 0x63, 0x35, 0x30, 0x30, 0x31, 0x39, 0x32, 0x31, 0x36, 0x39, 0x61, 0x34, 0x37, 0x66, 0x38, 0x32, 0x61, 0x30, 0x31, 0x34, 0x35, 0x37, 0x32, 0x36, 0x30, 0x66, 0x62, 0x31, 0x38, 0x37, 0x35, 0x38, 0x65, 0x61, 0x63, 0x61, 0x63, 0x63, 0x64, 0x62, 0x35, 0x62, 0x61, 0x37, 0x35, 0x63, 0x33, 0x35, 0x34, 0x34, 0x31, 0x63, 0x62, 0x64, 0x35, 0x39, 0x39, 0x30, 0x62, 0x64, 0x64, 0x63, 0x33, 0x63, 0x61, 0x39, 0x32, 0x35, 0x36, 0x33, 0x63, 0x37, 0x63, 0x34, 0x36, 0x31, 0x63, 0x32, 0x65, 0x66, 0x63, 0x33, 0x37, 0x39, 0x61, 0x37, 0x39, 0x34, 0x35, 0x35, 0x34, 0x32, 0x30, 0x62, 0x34, 0x38, 0x32, 0x61, 0x39, 0x62, 0x36, 0x61, 0x61, 0x33, 0x35, 0x35, 0x66, 0x32, 0x35, 0x30, 0x31, 0x31, 0x34, 0x65, 0x66, 0x32, 0x33, 0x61, 0x63, 0x65, 0x38, 0x62, 0x32, 0x61, 0x33, 0x61, 0x66, 0x62, 0x66, 0x61, 0x35, 0x37, 0x32, 0x31, 0x30, 0x31, 0x35, 0x37, 0x64, 0x64, 0x38, 0x36, 0x66, 0x33, 0x32, 0x65, 0x64, 0x37, 0x32, 0x31, 0x30, 0x66, 0x32, 0x37, 0x35, 0x33, 0x64, 0x37, 0x65, 0x63, 0x30, 0x63, 0x37, 0x31, 0x30, 0x30, 0x39, 0x39, 0x31, 0x64, 0x61, 0x32, 0x37, 0x33, 0x34, 0x33, 0x66, 0x31, 0x62, 0x38, 0x36, 0x63, 0x33, 0x32, 0x34, 0x32, 0x36, 0x33, 0x33, 0x30, 0x66, 0x64, 0x62, 0x39, 0x63, 0x34, 0x31, 0x33, 0x31, 0x65, 0x66, 0x33, 0x63, 0x31, 0x39, 0x31, 0x35, 0x63, 0x65, 0x63, 0x39, 0x33, 0x32, 0x39, 0x66, 0x30, 0x63, 0x63, 0x35, 0x63, 0x62, 0x39, 0x31, 0x33, 0x32, 0x64, 0x30, 0x32, 0x64, 0x63, 0x32, 0x62, 0x32, 0x34, 0x31, 0x63, 0x62, 0x35, 0x63, 0x34, 0x36, 0x64, 0x39, 0x37, 0x34, 0x63, 0x63, 0x34, 0x34, 0x35, 0x32, 0x66, 0x35, 0x61, 0x32, 0x61, 0x36, 0x63, 0x32, 0x31, 0x32, 0x65, 0x31, 0x64, 0x66, 0x39, 0x37, 0x30, 0x33, 0x65, 0x63, 0x63, 0x33, 0x34, 0x33, 0x38, 0x37, 0x32, 0x36, 0x65, 0x36, 0x37, 0x62, 0x36, 0x39, 0x32, 0x62, 0x38, 0x36, 0x33, 0x63, 0x63, 0x66, 0x36, 0x62, 0x39, 0x66, 0x61, 0x62, 0x65, 0x62, 0x62, 0x31, 0x30, 0x64, 0x62, 0x61, 0x63, 0x34, 0x31, 0x33, 0x30, 0x35, 0x64, 0x64, 0x64, 0x66, 0x30, 0x30, 0x34, 0x33, 0x34, 0x35, 0x37, 0x32, 0x66, 0x34, 0x61, 0x66, 0x36, 0x64, 0x35, 0x66, 0x63, 0x30, 0x37, 0x30, 0x36, 0x66, 0x37, 0x33, 0x38, 0x34, 0x39, 0x66, 0x31, 0x36, 0x61, 0x61, 0x62, 0x66, 0x66, 0x63, 0x38, 0x63, 0x33, 0x64, 0x32, 0x61, 0x39, 0x34, 0x30, 0x33, 0x36, 0x65, 0x39, 0x65, 0x64, 0x38, 0x38, 0x63, 0x38, 0x64, 0x61, 0x30, 0x66, 0x33, 0x36, 0x37, 0x62, 0x64, 0x61, 0x32, 0x31, 0x33, 0x31, 0x66, 0x37, 0x32, 0x36, 0x35, 0x32, 0x64, 0x64, 0x62, 0x33, 0x65, 0x37, 0x31, 0x66, 0x63, 0x39, 0x61, 0x64, 0x37, 0x65, 0x61, 0x61, 0x66, 0x65, 0x64, 0x61, 0x30, 0x66, 0x39, 0x63, 0x37, 0x33, 0x37, 0x33, 0x36, 0x66, 0x61, 0x63, 0x63, 0x31, 0x39, 0x30, 0x61, 0x31, 0x66, 0x63, 0x39, 0x62, 0x34, 0x30, 0x65, 0x61, 0x39, 0x65, 0x33, 0x33, 0x65, 0x33, 0x30, 0x33, 0x38, 0x39, 0x64, 0x63, 0x33, 0x37, 0x32, 0x33, 0x32, 0x31, 0x32, 0x37, 0x30, 0x38, 0x64, 0x37, 0x34, 0x36, 0x33, 0x64, 0x30, 0x63, 0x34, 0x34, 0x31, 0x66, 0x65, 0x37, 0x63, 0x31, 0x31, 0x31, 0x64, 0x33, 0x37, 0x30, 0x32, 0x36, 0x34, 0x62, 0x66, 0x37, 0x33, 0x62, 0x37, 0x61, 0x65, 0x37, 0x30, 0x34, 0x39, 0x37, 0x39, 0x31, 0x31, 0x34, 0x31, 0x65, 0x61, 0x32, 0x32, 0x65, 0x33, 0x38, 0x39, 0x34, 0x38, 0x37, 0x32, 0x37, 0x32, 0x33, 0x39, 0x64, 0x37, 0x64, 0x36, 0x63, 0x64, 0x30, 0x34, 0x35, 0x36, 0x62, 0x66, 0x63, 0x63, 0x32, 0x31, 0x33, 0x32, 0x34, 0x61, 0x65, 0x33, 0x33, 0x38, 0x30, 0x66, 0x31, 0x37, 0x35, 0x36, 0x34, 0x31, 0x38, 0x63, 0x37, 0x34, 0x30, 0x63, 0x66, 0x34, 0x35, 0x62, 0x30, 0x61, 0x64, 0x33, 0x66, 0x35, 0x61, 0x33, 0x38, 0x66, 0x33, 0x63, 0x62, 0x61, 0x31, 0x34, 0x34, 0x64, 0x37, 0x32, 0x32, 0x65, 0x33, 0x35, 0x62, 0x63, 0x39, 0x61, 0x32, 0x39, 0x64, 0x38, 0x62, 0x30, 0x30, 0x63, 0x35, 0x64, 0x63, 0x39, 0x64, 0x34, 0x35, 0x65, 0x37, 0x30, 0x66, 0x38, 0x38, 0x64, 0x33, 0x65, 0x33, 0x61, 0x33, 0x37, 0x32, 0x30, 0x39, 0x63, 0x32, 0x62, 0x36, 0x37, 0x66, 0x64, 0x38, 0x62, 0x35, 0x62, 0x39, 0x33, 0x64, 0x30, 0x66, 0x37, 0x63, 0x61, 0x31, 0x34, 0x33, 0x62, 0x34, 0x39, 0x64, 0x33, 0x33, 0x62, 0x31, 0x65, 0x32, 0x33, 0x36, 0x34, 0x35, 0x39, 0x34, 0x37, 0x32, 0x32, 0x30, 0x31, 0x30, 0x35, 0x64, 0x33, 0x33, 0x65, 0x38, 0x64, 0x64, 0x30, 0x38, 0x39, 0x65, 0x39, 0x65, 0x35, 0x65, 0x31, 0x36, 0x61, 0x36, 0x35, 0x37, 0x62, 0x37, 0x33, 0x65, 0x66, 0x38, 0x34, 0x32, 0x62, 0x36, 0x39, 0x37, 0x30, 0x62, 0x33, 0x64, 0x61, 0x30, 0x32, 0x33, 0x63, 0x32, 0x63, 0x62, 0x35, 0x30, 0x35, 0x65, 0x65, 0x38, 0x31, 0x35, 0x35, 0x61, 0x61, 0x30, 0x63, 0x61, 0x65, 0x66, 0x65, 0x30, 0x33, 0x61, 0x64, 0x38, 0x66, 0x33, 0x36, 0x31, 0x30, 0x36, 0x65, 0x31, 0x62, 0x66, 0x36, 0x35, 0x37, 0x63, 0x34, 0x31, 0x35, 0x31, 0x39, 0x38, 0x62, 0x37, 0x34, 0x39, 0x33, 0x39, 0x61, 0x38, 0x65, 0x34, 0x38, 0x39, 0x32, 0x63, 0x61, 0x64, 0x61, 0x32, 0x61, 0x37, 0x32, 0x32, 0x36, 0x61, 0x62, 0x64, 0x65, 0x34, 0x39, 0x36, 0x62, 0x65, 0x66, 0x64, 0x32, 0x37, 0x35, 0x34, 0x64, 0x36, 0x36, 0x65, 0x34, 0x65, 0x34, 0x32, 0x31, 0x33, 0x63, 0x34, 0x62, 0x32, 0x64, 0x39, 0x65, 0x35, 0x34, 0x62, 0x64, 0x38, 0x35, 0x30, 0x36, 0x34, 0x62, 0x38, 0x32, 0x38, 0x62, 0x61, 0x37, 0x64, 0x66, 0x32, 0x36, 0x63, 0x35, 0x38, 0x35, 0x64, 0x37, 0x33, 0x39, 0x31, 0x66, 0x66, 0x31, 0x38, 0x65, 0x33, 0x61, 0x66, 0x35, 0x31, 0x36, 0x30, 0x31, 0x64, 0x61, 0x64, 0x62, 0x33, 0x64, 0x30, 0x30, 0x37, 0x32, 0x30, 0x33, 0x36, 0x64, 0x32, 0x36, 0x63, 0x61, 0x31, 0x31, 0x32, 0x37, 0x36, 0x66, 0x33, 0x65, 0x65, 0x62, 0x30, 0x65, 0x66, 0x66, 0x30, 0x34, 0x63, 0x62, 0x38, 0x62, 0x61, 0x35, 0x64, 0x62, 0x63, 0x34, 0x31, 0x38, 0x33, 0x32, 0x31, 0x39, 0x37, 0x32, 0x64, 0x36, 0x35, 0x32, 0x30, 0x61, 0x38, 0x30, 0x64, 0x66, 0x61, 0x37, 0x63, 0x38, 0x35, 0x36, 0x36, 0x39, 0x39, 0x30, 0x31, 0x30, 0x66, 0x36, 0x35, 0x66, 0x39, 0x37, 0x30, 0x61, 0x39, 0x32, 0x35, 0x38, 0x66, 0x66, 0x62, 0x30, 0x62, 0x30, 0x30, 0x61, 0x34, 0x39, 0x37, 0x33, 0x66, 0x66, 0x36, 0x39, 0x33, 0x66, 0x64, 0x65, 0x32, 0x33, 0x30, 0x30, 0x61, 0x37, 0x32, 0x31, 0x37, 0x30, 0x66, 0x33, 0x63, 0x37, 0x36, 0x39, 0x33, 0x61, 0x39, 0x30, 0x62, 0x38, 0x32, 0x39, 0x34, 0x62, 0x34, 0x34, 0x35, 0x62, 0x39, 0x32, 0x63, 0x39, 0x31, 0x65, 0x65, 0x38, 0x37, 0x61, 0x35, 0x65, 0x39, 0x62, 0x35, 0x37, 0x31, 0x38, 0x39, 0x39, 0x36, 0x63, 0x31, 0x64, 0x64, 0x38, 0x61, 0x64, 0x62, 0x63, 0x33, 0x30, 0x33, 0x33, 0x37, 0x61, 0x61, 0x61, 0x32, 0x61, 0x38, 0x32, 0x34, 0x31, 0x65, 0x38, 0x63, 0x31, 0x35, 0x39, 0x62, 0x34, 0x65, 0x35, 0x62, 0x38, 0x66, 0x34, 0x62, 0x65, 0x62, 0x32, 0x33, 0x33, 0x38, 0x62, 0x33, 0x62, 0x64, 0x61, 0x31, 0x35, 0x37, 0x36, 0x39, 0x30, 0x35, 0x66, 0x38, 0x66, 0x65, 0x37, 0x62, 0x30, 0x39, 0x65, 0x38, 0x31, 0x61, 0x65, 0x38, 0x65, 0x37, 0x63, 0x30, 0x62, 0x32, 0x66, 0x39, 0x30, 0x62, 0x66, 0x61, 0x31, 0x63, 0x64, 0x37, 0x32, 0x33, 0x32, 0x34, 0x61, 0x65, 0x63, 0x33, 0x32, 0x64, 0x62, 0x66, 0x62, 0x62, 0x30, 0x31, 0x32, 0x39, 0x32, 0x61, 0x63, 0x66, 0x61, 0x37, 0x36, 0x30, 0x66, 0x34, 0x37, 0x63, 0x62, 0x66, 0x37, 0x64, 0x38, 0x30, 0x30, 0x38, 0x39, 0x38, 0x34, 0x31, 0x66, 0x64, 0x37, 0x32, 0x36, 0x38, 0x62, 0x34, 0x36, 0x31, 0x36, 0x34, 0x65, 0x66, 0x31, 0x63, 0x62, 0x37, 0x37, 0x32, 0x39, 0x37, 0x32, 0x35, 0x64, 0x66, 0x34, 0x30, 0x39, 0x39, 0x35, 0x39, 0x37, 0x33, 0x32, 0x64, 0x39, 0x31, 0x31, 0x66, 0x34, 0x64, 0x33, 0x61, 0x37, 0x63, 0x34, 0x65, 0x66, 0x64, 0x37, 0x64, 0x32, 0x38, 0x35, 0x30, 0x36, 0x37, 0x63, 0x35, 0x37, 0x64, 0x33, 0x30, 0x63, 0x36, 0x63, 0x62, 0x63, 0x39, 0x38, 0x66, 0x34, 0x64, 0x64, 0x64, 0x32, 0x36, 0x64, 0x37, 0x30, 0x64, 0x31, 0x66, 0x64, 0x37, 0x32, 0x61, 0x36, 0x66, 0x65, 0x61, 0x64, 0x62, 0x38, 0x30, 0x31, 0x35, 0x39, 0x66, 0x32, 0x38, 0x65, 0x65, 0x61, 0x62, 0x61, 0x65, 0x64, 0x37, 0x32, 0x35, 0x30, 0x32, 0x39, 0x30, 0x32, 0x39, 0x66, 0x34, 0x33, 0x38, 0x38, 0x61, 0x31, 0x61, 0x33, 0x65, 0x30, 0x66, 0x37, 0x35, 0x61, 0x35, 0x62, 0x65, 0x32, 0x35, 0x33, 0x64, 0x35, 0x32, 0x34, 0x63, 0x34, 0x35, 0x37, 0x32, 0x34, 0x37, 0x32, 0x33, 0x65, 0x32, 0x35, 0x64, 0x33, 0x66, 0x62, 0x36, 0x35, 0x32, 0x38, 0x36, 0x63, 0x39, 0x66, 0x36, 0x64, 0x34, 0x33, 0x66, 0x36, 0x61, 0x64, 0x62, 0x36, 0x66, 0x66, 0x65, 0x32, 0x36, 0x36, 0x36, 0x65, 0x66, 0x31, 0x36, 0x38, 0x37, 0x64, 0x39, 0x62, 0x39, 0x63, 0x30, 0x66, 0x31, 0x64, 0x66, 0x33, 0x36, 0x62, 0x63, 0x62, 0x32, 0x35, 0x66, 0x32, 0x38, 0x35, 0x39, 0x30, 0x37, 0x32, 0x61, 0x66, 0x31, 0x63, 0x36, 0x38, 0x61, 0x63, 0x32, 0x63, 0x38, 0x36, 0x37, 0x66, 0x33, 0x66, 0x33, 0x65, 0x63, 0x32, 0x64, 0x33, 0x36, 0x62, 0x32, 0x36, 0x66, 0x65, 0x35, 0x32, 0x39, 0x30, 0x64, 0x36, 0x38, 0x39, 0x30, 0x61, 0x65, 0x38, 0x62, 0x32, 0x33, 0x34, 0x30, 0x65, 0x63, 0x37, 0x33, 0x63, 0x30, 0x31, 0x39, 0x34, 0x34, 0x35, 0x61, 0x64, 0x63, 0x61, 0x35, 0x63, 0x37, 0x32, 0x61, 0x65, 0x31, 0x64, 0x39, 0x31, 0x38, 0x63, 0x37, 0x32, 0x36, 0x36, 0x30, 0x33, 0x63, 0x30, 0x34, 0x61, 0x32, 0x32, 0x66, 0x39, 0x31, 0x39, 0x39, 0x61, 0x35, 0x39, 0x31, 0x39, 0x64, 0x36, 0x34, 0x66, 0x61, 0x38, 0x36, 0x37, 0x35, 0x37, 0x39, 0x35, 0x39, 0x32, 0x62, 0x66, 0x64, 0x34, 0x62, 0x37, 0x37, 0x30, 0x33, 0x35, 0x31, 0x32, 0x32, 0x61, 0x39, 0x63, 0x65, 0x31, 0x37, 0x32, 0x34, 0x64, 0x31, 0x36, 0x34, 0x65, 0x62, 0x38, 0x35, 0x37, 0x35, 0x61, 0x38, 0x66, 0x65, 0x63, 0x61, 0x36, 0x36, 0x38, 0x65, 0x38, 0x38, 0x31, 0x36, 0x61, 0x30, 0x32, 0x31, 0x65, 0x39, 0x31, 0x37, 0x38, 0x39, 0x37, 0x36, 0x37, 0x66, 0x63, 0x38, 0x34, 0x61, 0x63, 0x33, 0x33, 0x64, 0x33, 0x34, 0x30, 0x64, 0x32, 0x35, 0x66, 0x66, 0x30, 0x66, 0x62, 0x38, 0x31, 0x61, 0x65, 0x31, 0x33, 0x64, 0x35, 0x34, 0x38, 0x37, 0x61, 0x65, 0x31, 0x35, 0x38, 0x64, 0x34, 0x65, 0x62, 0x32, 0x38, 0x35, 0x32, 0x66, 0x30, 0x30, 0x36, 0x34, 0x32, 0x34, 0x66, 0x31, 0x65, 0x38, 0x35, 0x33, 0x32, 0x39, 0x65, 0x66, 0x65, 0x38, 0x38, 0x32, 0x33, 0x63, 0x65, 0x64, 0x64, 0x30, 0x63, 0x35, 0x35, 0x62, 0x34, 0x62, 0x34, 0x32, 0x37, 0x62, 0x61, 0x36, 0x30, 0x33, 0x66, 0x64, 0x37, 0x34, 0x30, 0x35, 0x62, 0x34, 0x36, 0x34, 0x35, 0x38, 0x63, 0x30, 0x63, 0x32, 0x61, 0x32, 0x38, 0x65, 0x34, 0x39, 0x63, 0x64, 0x33, 0x32, 0x30, 0x35, 0x61, 0x38, 0x34, 0x38, 0x31, 0x36, 0x61, 0x37, 0x33, 0x63, 0x31, 0x61, 0x65, 0x31, 0x30, 0x36, 0x66, 0x65, 0x39, 0x63, 0x39, 0x34, 0x66, 0x66, 0x30, 0x61, 0x36, 0x36, 0x39, 0x30, 0x32, 0x30, 0x65, 0x34, 0x61, 0x38, 0x34, 0x30, 0x35, 0x32, 0x36, 0x33, 0x63, 0x64, 0x38, 0x33, 0x38, 0x65, 0x61, 0x33, 0x64, 0x61, 0x38, 0x64, 0x31, 0x66, 0x35, 0x30, 0x38, 0x31, 0x35, 0x31, 0x39, 0x37, 0x37, 0x62, 0x65, 0x63, 0x37, 0x66, 0x65, 0x62, 0x39, 0x33, 0x39, 0x65, 0x32, 0x66, 0x61, 0x38, 0x34, 0x61, 0x65, 0x64, 0x64, 0x34, 0x30, 0x66, 0x65, 0x34, 0x35, 0x65, 0x36, 0x32, 0x32, 0x63, 0x64, 0x63, 0x32, 0x30, 0x34, 0x39, 0x33, 0x35, 0x34, 0x39, 0x30, 0x64, 0x35, 0x62, 0x32, 0x39, 0x30, 0x30, 0x32, 0x33, 0x32, 0x39, 0x35, 0x37, 0x61, 0x39, 0x34, 0x33, 0x37, 0x36, 0x33, 0x36, 0x32, 0x31, 0x64, 0x31, 0x30, 0x65, 0x35, 0x62, 0x66, 0x38, 0x35, 0x30, 0x37, 0x30, 0x32, 0x30, 0x31, 0x38, 0x61, 0x32, 0x37, 0x61, 0x33, 0x37, 0x31, 0x34, 0x66, 0x31, 0x65, 0x66, 0x66, 0x66, 0x39, 0x31, 0x37, 0x30, 0x36, 0x33, 0x34, 0x37, 0x32, 0x39, 0x32, 0x37, 0x65, 0x38, 0x38, 0x35, 0x66, 0x30, 0x30, 0x31, 0x31, 0x62, 0x64, 0x39, 0x30, 0x38, 0x35, 0x39, 0x63, 0x62, 0x63, 0x62, 0x31, 0x35, 0x33, 0x61, 0x66, 0x34, 0x65, 0x33, 0x61, 0x38, 0x34, 0x32, 0x39, 0x36, 0x35, 0x65, 0x63, 0x61, 0x36, 0x37, 0x66, 0x33, 0x35, 0x34, 0x35, 0x35, 0x64, 0x35, 0x63, 0x33, 0x37, 0x63, 0x39, 0x63, 0x63, 0x34, 0x39, 0x66, 0x30, 0x37, 0x32, 0x32, 0x33, 0x35, 0x65, 0x32, 0x37, 0x33, 0x30, 0x32, 0x30, 0x31, 0x35, 0x36, 0x63, 0x63, 0x66, 0x63, 0x65, 0x31, 0x65, 0x39, 0x34, 0x36, 0x34, 0x36, 0x64, 0x31, 0x62, 0x34, 0x32, 0x30, 0x66, 0x63, 0x33, 0x36, 0x30, 0x63, 0x36, 0x32, 0x31, 0x61, 0x33, 0x37, 0x37, 0x39, 0x36, 0x37, 0x30, 0x37, 0x61, 0x30, 0x38, 0x32, 0x32, 0x62, 0x63, 0x62, 0x32, 0x63, 0x38, 0x35, 0x64, 0x32, 0x63, 0x36, 0x62, 0x31, 0x64, 0x65, 0x32, 0x34, 0x30, 0x34, 0x36, 0x34, 0x32, 0x31, 0x34, 0x61, 0x33, 0x33, 0x63, 0x34, 0x31, 0x32, 0x35, 0x33, 0x62, 0x32, 0x35, 0x61, 0x36, 0x63, 0x36, 0x30, 0x34, 0x63, 0x32, 0x65, 0x33, 0x33, 0x65, 0x34, 0x38, 0x64, 0x63, 0x39, 0x63, 0x30, 0x63, 0x66, 0x33, 0x30, 0x30, 0x32, 0x61, 0x34, 0x63, 0x38, 0x35, 0x33, 0x64, 0x38, 0x33, 0x65, 0x34, 0x37, 0x32, 0x38, 0x34, 0x64, 0x64, 0x34, 0x63, 0x61, 0x37, 0x36, 0x61, 0x32, 0x38, 0x64, 0x31, 0x62, 0x39, 0x61, 0x63, 0x30, 0x36, 0x66, 0x61, 0x61, 0x66, 0x38, 0x33, 0x35, 0x31, 0x34, 0x39, 0x35, 0x38, 0x36, 0x37, 0x62, 0x36, 0x34, 0x66, 0x32, 0x39, 0x65, 0x35, 0x36, 0x34, 0x31, 0x33, 0x62, 0x34, 0x31, 0x38, 0x66, 0x34, 0x32, 0x32, 0x63, 0x30, 0x66, 0x33, 0x64, 0x33, 0x37, 0x30, 0x37, 0x32, 0x32, 0x62, 0x33, 0x31, 0x34, 0x32, 0x62, 0x37, 0x38, 0x62, 0x65, 0x31, 0x63, 0x62, 0x37, 0x33, 0x66, 0x66, 0x33, 0x66, 0x32, 0x36, 0x38, 0x30, 0x32, 0x34, 0x30, 0x61, 0x61, 0x62, 0x34, 0x38, 0x30, 0x64, 0x65, 0x39, 0x39, 0x32, 0x61, 0x62, 0x34, 0x38, 0x30, 0x36, 0x39, 0x39, 0x63, 0x64, 0x35, 0x34, 0x37, 0x39, 0x33, 0x35, 0x64, 0x31, 0x35, 0x38, 0x38, 0x37, 0x32, 0x65, 0x33, 0x30, 0x64, 0x62, 0x38, 0x33, 0x65, 0x35, 0x33, 0x36, 0x63, 0x66, 0x63, 0x64, 0x34, 0x66, 0x30, 0x38, 0x34, 0x62, 0x37, 0x39, 0x30, 0x38, 0x30, 0x65, 0x65, 0x62, 0x35, 0x30, 0x65, 0x32, 0x64, 0x31, 0x35, 0x34, 0x37, 0x30, 0x61, 0x37, 0x37, 0x65, 0x30, 0x36, 0x63, 0x31, 0x65, 0x32, 0x64, 0x37, 0x38, 0x64, 0x32, 0x37, 0x61, 0x64, 0x65, 0x36, 0x36, 0x35, 0x61, 0x63, 0x61, 0x39, 0x37, 0x32, 0x32, 0x63, 0x65, 0x37, 0x37, 0x38, 0x35, 0x63, 0x32, 0x30, 0x62, 0x37, 0x37, 0x65, 0x37, 0x39, 0x37, 0x34, 0x31, 0x33, 0x66, 0x62, 0x65, 0x32, 0x31, 0x33, 0x37, 0x31, 0x37, 0x38, 0x62, 0x63, 0x66, 0x31, 0x33, 0x66, 0x38, 0x63, 0x39, 0x66, 0x35, 0x39, 0x64, 0x38, 0x61, 0x39, 0x30, 0x33, 0x34, 0x36, 0x31, 0x64, 0x64, 0x62, 0x31, 0x36, 0x66, 0x37, 0x37, 0x39, 0x33, 0x34, 0x37, 0x32, 0x61, 0x37, 0x34, 0x65, 0x30, 0x39, 0x39, 0x33, 0x63, 0x31, 0x65, 0x61, 0x31, 0x65, 0x62, 0x32, 0x63, 0x34, 0x62, 0x34, 0x64, 0x66, 0x32, 0x30, 0x36, 0x39, 0x63, 0x63, 0x32, 0x66, 0x31, 0x31, 0x30, 0x37, 0x37, 0x35, 0x30, 0x66, 0x31, 0x38, 0x63, 0x35, 0x63, 0x34, 0x61, 0x35, 0x61, 0x31, 0x64, 0x36, 0x35, 0x63, 0x64, 0x33, 0x31, 0x35, 0x61, 0x63, 0x64, 0x35, 0x36, 0x38, 0x37, 0x32, 0x30, 0x34, 0x39, 0x61, 0x30, 0x35, 0x66, 0x62, 0x62, 0x35, 0x39, 0x32, 0x62, 0x30, 0x34, 0x62, 0x63, 0x66, 0x30, 0x35, 0x32, 0x38, 0x36, 0x34, 0x66, 0x34, 0x61, 0x38, 0x39, 0x36, 0x61, 0x30, 0x31, 0x33, 0x37, 0x32, 0x36, 0x32, 0x62, 0x39, 0x65, 0x35, 0x66, 0x34, 0x31, 0x36, 0x31, 0x32, 0x32, 0x39, 0x38, 0x64, 0x32, 0x35, 0x66, 0x31, 0x32, 0x32, 0x31, 0x63, 0x63, 0x62, 0x37, 0x32, 0x39, 0x30, 0x35, 0x32, 0x34, 0x34, 0x37, 0x38, 0x65, 0x62, 0x64, 0x35, 0x61, 0x64, 0x38, 0x62, 0x37, 0x31, 0x30, 0x37, 0x31, 0x64, 0x63, 0x38, 0x30, 0x36, 0x36, 0x36, 0x62, 0x31, 0x33, 0x63, 0x37, 0x39, 0x36, 0x35, 0x66, 0x30, 0x31, 0x31, 0x39, 0x61, 0x33, 0x63, 0x38, 0x34, 0x33, 0x36, 0x62, 0x62, 0x63, 0x31, 0x31, 0x66, 0x66, 0x37, 0x38, 0x62, 0x34, 0x35, 0x64, 0x61, 0x34, 0x30, 0x36, 0x61, 0x37, 0x31, 0x39, 0x35, 0x61, 0x37, 0x39, 0x34, 0x64, 0x38, 0x37, 0x34, 0x30, 0x34, 0x62, 0x33, 0x61, 0x65, 0x35, 0x35, 0x65, 0x66, 0x64, 0x39, 0x35, 0x32, 0x36, 0x35, 0x66, 0x63, 0x64, 0x66, 0x33, 0x38, 0x35, 0x37, 0x63, 0x35, 0x37, 0x61, 0x38, 0x30, 0x31, 0x30, 0x39, 0x31, 0x65, 0x64, 0x33, 0x38, 0x62, 0x34, 0x63, 0x65, 0x62, 0x64, 0x30, 0x34, 0x66, 0x32, 0x33, 0x66, 0x61, 0x35, 0x30, 0x31, 0x34, 0x39, 0x34, 0x66, 0x31, 0x38, 0x66, 0x35, 0x34, 0x39, 0x61, 0x33, 0x36, 0x37, 0x64, 0x34, 0x36, 0x35, 0x61, 0x62, 0x65, 0x63, 0x36, 0x39, 0x64, 0x39, 0x63, 0x65, 0x34, 0x62, 0x61, 0x34, 0x35, 0x61, 0x38, 0x64, 0x33, 0x39, 0x62, 0x61, 0x64, 0x35, 0x39, 0x31, 0x66, 0x35, 0x66, 0x30, 0x36, 0x35, 0x66, 0x63, 0x34, 0x61, 0x36, 0x32, 0x36, 0x61, 0x37, 0x32, 0x37, 0x66, 0x66, 0x62, 0x63, 0x61, 0x30, 0x66, 0x65, 0x61, 0x66, 0x66, 0x38, 0x61, 0x65, 0x37, 0x32, 0x61, 0x38, 0x38, 0x62, 0x33, 0x30, 0x66, 0x32, 0x31, 0x32, 0x66, 0x61, 0x36, 0x38, 0x38, 0x65, 0x31, 0x39, 0x39, 0x63, 0x65, 0x65, 0x63, 0x66, 0x64, 0x62, 0x66, 0x36, 0x64, 0x64, 0x37, 0x63, 0x64, 0x65, 0x30, 0x30, 0x37, 0x37, 0x64, 0x30, 0x66, 0x39, 0x35, 0x35, 0x65, 0x37, 0x32, 0x62, 0x61, 0x63, 0x66, 0x32, 0x61, 0x37, 0x64, 0x62, 0x39, 0x66, 0x62, 0x39, 0x35, 0x62, 0x37, 0x62, 0x61, 0x37, 0x33, 0x32, 0x33, 0x65, 0x31, 0x32, 0x65, 0x65, 0x65, 0x36, 0x33, 0x34, 0x63, 0x38, 0x37, 0x64, 0x64, 0x30, 0x39, 0x33, 0x62, 0x32, 0x61, 0x64, 0x64, 0x39, 0x35, 0x65, 0x65, 0x66, 0x62, 0x30, 0x64, 0x65, 0x65, 0x34, 0x65, 0x39, 0x37, 0x36, 0x32, 0x38, 0x34, 0x37, 0x32, 0x30, 0x32, 0x63, 0x30, 0x31, 0x39, 0x35, 0x63, 0x65, 0x65, 0x30, 0x66, 0x35, 0x33, 0x31, 0x38, 0x65, 0x38, 0x65, 0x38, 0x33, 0x62, 0x37, 0x34, 0x32, 0x34, 0x62, 0x37, 0x32, 0x30, 0x61, 0x62, 0x63, 0x37, 0x64, 0x61, 0x38, 0x39, 0x64, 0x62, 0x37, 0x39, 0x63, 0x36, 0x63, 0x34, 0x37, 0x61, 0x38, 0x34, 0x37, 0x65, 0x64, 0x38, 0x36, 0x37, 0x36, 0x38, 0x31, 0x38, 0x34, 0x63, 0x37, 0x32, 0x37, 0x30, 0x33, 0x62, 0x34, 0x36, 0x32, 0x62, 0x34, 0x31, 0x64, 0x63, 0x63, 0x35, 0x31, 0x39, 0x33, 0x38, 0x35, 0x36, 0x64, 0x34, 0x32, 0x36, 0x62, 0x61, 0x30, 0x32, 0x33, 0x31, 0x61, 0x34, 0x30, 0x37, 0x65, 0x39, 0x38, 0x61, 0x36, 0x31, 0x37, 0x34, 0x33, 0x35, 0x32, 0x61, 0x39, 0x61, 0x33, 0x61, 0x65, 0x30, 0x34, 0x34, 0x64, 0x32, 0x66, 0x36, 0x35, 0x65, 0x30, 0x38, 0x32, 0x61, 0x35, 0x64, 0x30, 0x31, 0x37, 0x37, 0x35, 0x66, 0x64, 0x30, 0x62, 0x38, 0x33, 0x34, 0x62, 0x34, 0x66, 0x66, 0x61, 0x62, 0x35, 0x34, 0x61, 0x64, 0x66, 0x65, 0x61, 0x32, 0x64, 0x65, 0x62, 0x35, 0x62, 0x30, 0x31, 0x32, 0x30, 0x63, 0x65, 0x31, 0x36, 0x38, 0x32, 0x31, 0x39, 0x30, 0x32, 0x62, 0x32, 0x37, 0x37, 0x61, 0x33, 0x33, 0x37, 0x32, 0x64, 0x35, 0x30, 0x62, 0x33, 0x66, 0x37, 0x32, 0x32, 0x36, 0x64, 0x31, 0x32, 0x32, 0x64, 0x33, 0x31, 0x61, 0x39, 0x63, 0x33, 0x35, 0x33, 0x61, 0x65, 0x64, 0x62, 0x64, 0x33, 0x34, 0x37, 0x34, 0x35, 0x36, 0x33, 0x32, 0x33, 0x65, 0x39, 0x62, 0x62, 0x33, 0x33, 0x32, 0x38, 0x30, 0x32, 0x62, 0x39, 0x66, 0x33, 0x36, 0x35, 0x31, 0x33, 0x32, 0x34, 0x64, 0x62, 0x38, 0x35, 0x35, 0x33, 0x33, 0x64, 0x38, 0x62, 0x62, 0x66, 0x38, 0x37, 0x32, 0x38, 0x32, 0x37, 0x30, 0x39, 0x35, 0x30, 0x38, 0x61, 0x31, 0x31, 0x64, 0x31, 0x30, 0x63, 0x35, 0x30, 0x31, 0x31, 0x61, 0x37, 0x63, 0x32, 0x64, 0x33, 0x66, 0x31, 0x35, 0x66, 0x36, 0x37, 0x61, 0x62, 0x36, 0x34, 0x37, 0x32, 0x66, 0x66, 0x37, 0x65, 0x62, 0x32, 0x35, 0x32, 0x38, 0x34, 0x33, 0x37, 0x36, 0x31, 0x64, 0x31, 0x37, 0x34, 0x61, 0x61, 0x32, 0x31, 0x65, 0x34, 0x32, 0x37, 0x32, 0x39, 0x65, 0x35, 0x35, 0x36, 0x30, 0x64, 0x61, 0x64, 0x64, 0x66, 0x64, 0x34, 0x66, 0x37, 0x61, 0x61, 0x31, 0x62, 0x65, 0x38, 0x65, 0x39, 0x33, 0x61, 0x62, 0x32, 0x63, 0x30, 0x30, 0x37, 0x38, 0x61, 0x38, 0x37, 0x38, 0x33, 0x63, 0x33, 0x35, 0x63, 0x37, 0x35, 0x62, 0x37, 0x63, 0x38, 0x65, 0x66, 0x37, 0x35, 0x66, 0x38, 0x31, 0x65, 0x37, 0x36, 0x38, 0x65, 0x31, 0x31, 0x31, 0x37, 0x32, 0x62, 0x36, 0x61, 0x34, 0x38, 0x62, 0x63, 0x30, 0x62, 0x30, 0x65, 0x36, 0x65, 0x61, 0x39, 0x65, 0x36, 0x63, 0x65, 0x35, 0x62, 0x37, 0x34, 0x61, 0x37, 0x33, 0x31, 0x36, 0x64, 0x31, 0x34, 0x64, 0x30, 0x34, 0x37, 0x39, 0x32, 0x62, 0x37, 0x33, 0x32, 0x38, 0x62, 0x38, 0x61, 0x31, 0x30, 0x39, 0x38, 0x37, 0x61, 0x63, 0x38, 0x62, 0x30, 0x35, 0x62, 0x35, 0x31, 0x32, 0x37, 0x65, 0x37, 0x32, 0x34, 0x32, 0x39, 0x38, 0x30, 0x61, 0x37, 0x34, 0x38, 0x39, 0x32, 0x36, 0x39, 0x64, 0x62, 0x64, 0x66, 0x38, 0x36, 0x36, 0x35, 0x32, 0x31, 0x37, 0x33, 0x38, 0x62, 0x34, 0x31, 0x32, 0x39, 0x65, 0x30, 0x33, 0x61, 0x35, 0x35, 0x34, 0x36, 0x32, 0x31, 0x65, 0x39, 0x39, 0x37, 0x64, 0x61, 0x63, 0x31, 0x30, 0x38, 0x65, 0x37, 0x64, 0x37, 0x31, 0x36, 0x35, 0x63, 0x38, 0x65, 0x38, 0x33, 0x34, 0x64, 0x35, 0x66, 0x30, 0x31, 0x30, 0x39, 0x34, 0x38, 0x35, 0x62, 0x63, 0x38, 0x64, 0x31, 0x34, 0x39, 0x35, 0x61, 0x64, 0x65, 0x33, 0x66, 0x31, 0x32, 0x33, 0x39, 0x64, 0x33, 0x66, 0x32, 0x34, 0x65, 0x37, 0x35, 0x37, 0x32, 0x30, 0x31, 0x63, 0x39, 0x61, 0x63, 0x64, 0x36, 0x39, 0x33, 0x66, 0x33, 0x37, 0x66, 0x36, 0x37, 0x36, 0x37, 0x33, 0x30, 0x35, 0x32, 0x39, 0x39, 0x62, 0x37, 0x32, 0x33, 0x61, 0x35, 0x31, 0x35, 0x37, 0x65, 0x61, 0x65, 0x39, 0x37, 0x63, 0x37, 0x35, 0x37, 0x31, 0x65, 0x36, 0x61, 0x34, 0x33, 0x62, 0x39, 0x34, 0x62, 0x62, 0x32, 0x30, 0x31, 0x64, 0x30, 0x37, 0x63, 0x63, 0x35, 0x62, 0x64, 0x61, 0x35, 0x62, 0x62, 0x32, 0x61, 0x63, 0x61, 0x61, 0x34, 0x66, 0x32, 0x30, 0x38, 0x61, 0x30, 0x61, 0x39, 0x33, 0x66, 0x39, 0x63, 0x64, 0x34, 0x64, 0x36, 0x64, 0x38, 0x31, 0x39, 0x39, 0x62, 0x31, 0x30, 0x30, 0x62, 0x30, 0x32, 0x66, 0x64, 0x64, 0x65, 0x64, 0x38, 0x62, 0x33, 0x36, 0x35, 0x34, 0x30, 0x35, 0x35, 0x30, 0x66, 0x62, 0x38, 0x64, 0x61, 0x65, 0x33, 0x65, 0x65, 0x31, 0x64, 0x37, 0x34, 0x33, 0x64, 0x63, 0x61, 0x63, 0x34, 0x33, 0x34, 0x39, 0x34, 0x61, 0x36, 0x64, 0x30, 0x61, 0x62, 0x66, 0x30, 0x66, 0x66, 0x39, 0x38, 0x35, 0x37, 0x32, 0x63, 0x37, 0x66, 0x37, 0x34, 0x34, 0x35, 0x66, 0x34, 0x65, 0x31, 0x62, 0x65, 0x62, 0x30, 0x34, 0x38, 0x37, 0x33, 0x30, 0x61, 0x35, 0x33, 0x37, 0x32, 0x63, 0x34, 0x65, 0x65, 0x39, 0x31, 0x37, 0x66, 0x63, 0x37, 0x31, 0x30, 0x36, 0x65, 0x35, 0x30, 0x34, 0x62, 0x30, 0x32, 0x61, 0x65, 0x65, 0x34, 0x34, 0x65, 0x30, 0x61, 0x35, 0x35, 0x61, 0x35, 0x35, 0x35, 0x30, 0x63, 0x30, 0x37, 0x32, 0x64, 0x36, 0x36, 0x36, 0x30, 0x37, 0x61, 0x35, 0x66, 0x61, 0x65, 0x66, 0x66, 0x62, 0x30, 0x34, 0x35, 0x30, 0x31, 0x32, 0x39, 0x66, 0x32, 0x31, 0x33, 0x36, 0x63, 0x66, 0x31, 0x64, 0x32, 0x35, 0x36, 0x61, 0x31, 0x61, 0x35, 0x33, 0x38, 0x37, 0x31, 0x32, 0x37, 0x37, 0x35, 0x36, 0x39, 0x35, 0x34, 0x65, 0x63, 0x37, 0x66, 0x33, 0x30, 0x35, 0x61, 0x34, 0x65, 0x65, 0x34, 0x35, 0x37, 0x32, 0x32, 0x34, 0x37, 0x37, 0x62, 0x37, 0x62, 0x62, 0x39, 0x30, 0x65, 0x39, 0x65, 0x38, 0x63, 0x38, 0x36, 0x38, 0x39, 0x30, 0x33, 0x34, 0x62, 0x31, 0x35, 0x66, 0x37, 0x34, 0x32, 0x65, 0x33, 0x34, 0x37, 0x64, 0x64, 0x66, 0x32, 0x63, 0x35, 0x64, 0x62, 0x31, 0x62, 0x33, 0x35, 0x32, 0x30, 0x39, 0x38, 0x33, 0x63, 0x33, 0x62, 0x31, 0x30, 0x36, 0x31, 0x39, 0x35, 0x30, 0x31, 0x30, 0x34, 0x36, 0x33, 0x64, 0x35, 0x33, 0x32, 0x34, 0x35, 0x64, 0x62, 0x37, 0x39, 0x65, 0x38, 0x34, 0x39, 0x65, 0x61, 0x65, 0x65, 0x37, 0x30, 0x63, 0x31, 0x32, 0x38, 0x39, 0x61, 0x61, 0x37, 0x31, 0x30, 0x35, 0x62, 0x35, 0x63, 0x39, 0x63, 0x32, 0x32, 0x33, 0x63, 0x66, 0x35, 0x31, 0x61, 0x30, 0x35, 0x35, 0x31, 0x39, 0x37, 0x66, 0x61, 0x38, 0x38, 0x64, 0x66, 0x36, 0x61, 0x61, 0x66, 0x30, 0x37, 0x32, 0x65, 0x61, 0x30, 0x33, 0x66, 0x35, 0x37, 0x35, 0x33, 0x39, 0x34, 0x65, 0x36, 0x34, 0x61, 0x32, 0x64, 0x65, 0x61, 0x30, 0x31, 0x30, 0x38, 0x36, 0x64, 0x35, 0x36, 0x30, 0x34, 0x66, 0x36, 0x36, 0x66, 0x31, 0x34, 0x32, 0x38, 0x66, 0x36, 0x65, 0x62, 0x32, 0x63, 0x36, 0x31, 0x30, 0x63, 0x39, 0x32, 0x66, 0x63, 0x63, 0x66, 0x63, 0x65, 0x37, 0x61, 0x66, 0x35, 0x38, 0x35, 0x65, 0x37, 0x32, 0x64, 0x32, 0x66, 0x32, 0x63, 0x66, 0x33, 0x65, 0x33, 0x32, 0x66, 0x66, 0x39, 0x34, 0x39, 0x38, 0x37, 0x62, 0x35, 0x65, 0x39, 0x31, 0x36, 0x65, 0x30, 0x31, 0x63, 0x62, 0x30, 0x34, 0x66, 0x37, 0x63, 0x31, 0x30, 0x36, 0x37, 0x64, 0x39, 0x39, 0x32, 0x62, 0x36, 0x31, 0x66, 0x65, 0x63, 0x61, 0x65, 0x31, 0x31, 0x66, 0x36, 0x65, 0x37, 0x33, 0x33, 0x61, 0x32, 0x39, 0x33, 0x30, 0x37, 0x32, 0x64, 0x31, 0x62, 0x64, 0x66, 0x34, 0x37, 0x34, 0x39, 0x30, 0x62, 0x65, 0x66, 0x64, 0x63, 0x33, 0x33, 0x64, 0x65, 0x39, 0x64, 0x32, 0x31, 0x65, 0x34, 0x64, 0x38, 0x39, 0x35, 0x63, 0x30, 0x62, 0x39, 0x30, 0x35, 0x37, 0x36, 0x36, 0x61, 0x37, 0x65, 0x37, 0x35, 0x63, 0x31, 0x37, 0x63, 0x36, 0x38, 0x32, 0x63, 0x61, 0x64, 0x66, 0x35, 0x32, 0x66, 0x39, 0x31, 0x32, 0x34, 0x34, 0x37, 0x32, 0x32, 0x36, 0x39, 0x30, 0x61, 0x32, 0x65, 0x33, 0x33, 0x35, 0x65, 0x62, 0x62, 0x61, 0x34, 0x62, 0x62, 0x36, 0x35, 0x64, 0x30, 0x37, 0x30, 0x39, 0x33, 0x35, 0x64, 0x62, 0x65, 0x61, 0x36, 0x62, 0x33, 0x36, 0x31, 0x31, 0x35, 0x66, 0x65, 0x30, 0x31, 0x34, 0x62, 0x65, 0x64, 0x34, 0x66, 0x39, 0x31, 0x39, 0x61, 0x66, 0x34, 0x33, 0x66, 0x39, 0x61, 0x64, 0x63, 0x36, 0x37, 0x63, 0x36, 0x36, 0x36, 0x38, 0x30, 0x65, 0x30, 0x66, 0x31, 0x64, 0x33, 0x36, 0x63, 0x61, 0x38, 0x31, 0x64, 0x34, 0x64, 0x33, 0x66, 0x34, 0x62, 0x65, 0x35, 0x62, 0x66, 0x64, 0x34, 0x66, 0x63, 0x35, 0x38, 0x66, 0x39, 0x33, 0x35, 0x61, 0x34, 0x36, 0x32, 0x32, 0x32, 0x64, 0x38, 0x32, 0x65, 0x32, 0x36, 0x38, 0x61, 0x62, 0x63, 0x36, 0x63, 0x66, 0x33, 0x64, 0x34, 0x31, 0x66, 0x31, 0x35, 0x31, 0x37, 0x32, 0x38, 0x35, 0x38, 0x64, 0x62, 0x61, 0x62, 0x61, 0x62, 0x34, 0x62, 0x34, 0x33, 0x33, 0x30, 0x33, 0x30, 0x33, 0x30, 0x36, 0x35, 0x64, 0x33, 0x64, 0x35, 0x39, 0x38, 0x64, 0x65, 0x61, 0x35, 0x32, 0x32, 0x34, 0x33, 0x61, 0x39, 0x61, 0x37, 0x39, 0x32, 0x30, 0x66, 0x66, 0x33, 0x63, 0x36, 0x63, 0x33, 0x63, 0x65, 0x32, 0x34, 0x36, 0x61, 0x37, 0x30, 0x39, 0x39, 0x37, 0x64, 0x33, 0x31, 0x30, 0x39, 0x35, 0x38, 0x32, 0x33, 0x65, 0x37, 0x34, 0x35, 0x62, 0x63, 0x35, 0x61, 0x62, 0x39, 0x64, 0x38, 0x62, 0x39, 0x30, 0x36, 0x36, 0x35, 0x38, 0x38, 0x35, 0x36, 0x37, 0x66, 0x39, 0x38, 0x38, 0x62, 0x31, 0x37, 0x63, 0x34, 0x66, 0x33, 0x39, 0x30, 0x35, 0x32, 0x62, 0x39, 0x36, 0x32, 0x36, 0x64, 0x39, 0x33, 0x63, 0x62, 0x39, 0x39, 0x39, 0x39, 0x31, 0x36, 0x62, 0x62, 0x31, 0x33, 0x37, 0x65, 0x34, 0x37, 0x65, 0x32, 0x34, 0x66, 0x34, 0x65, 0x32, 0x63, 0x30, 0x62, 0x31, 0x66, 0x61, 0x31, 0x33, 0x31, 0x63, 0x35, 0x64, 0x65, 0x33, 0x30, 0x66, 0x33, 0x33, 0x61, 0x66, 0x37, 0x30, 0x32, 0x35, 0x61, 0x34, 0x36, 0x37, 0x61, 0x34, 0x30, 0x30, 0x32, 0x30, 0x36, 0x38, 0x62, 0x62, 0x35, 0x30, 0x30, 0x66, 0x33, 0x65, 0x63, 0x63, 0x31, 0x33, 0x37, 0x61, 0x37, 0x65, 0x37, 0x32, 0x37, 0x65, 0x38, 0x61, 0x36, 0x30, 0x30, 0x30, 0x31, 0x64, 0x39, 0x34, 0x38, 0x39, 0x66, 0x39, 0x63, 0x65, 0x31, 0x38, 0x30, 0x63, 0x34, 0x64, 0x39, 0x62, 0x33, 0x63, 0x64, 0x63, 0x30, 0x62, 0x39, 0x66, 0x30, 0x34, 0x32, 0x31, 0x34, 0x30, 0x31, 0x62, 0x61, 0x65, 0x64, 0x64, 0x65, 0x39, 0x32, 0x30, 0x66, 0x64, 0x39, 0x37, 0x63, 0x39, 0x61, 0x34, 0x61, 0x36, 0x65, 0x37, 0x32, 0x63, 0x34, 0x30, 0x36, 0x66, 0x31, 0x36, 0x35, 0x63, 0x32, 0x31, 0x36, 0x37, 0x65, 0x64, 0x37, 0x39, 0x61, 0x39, 0x31, 0x64, 0x36, 0x64, 0x66, 0x66, 0x33, 0x62, 0x38, 0x39, 0x35, 0x36, 0x33, 0x37, 0x63, 0x34, 0x63, 0x30, 0x35, 0x35, 0x34, 0x32, 0x38, 0x64, 0x38, 0x31, 0x61, 0x63, 0x35, 0x35, 0x66, 0x36, 0x32, 0x65, 0x35, 0x64, 0x33, 0x32, 0x65, 0x33, 0x64, 0x32, 0x34, 0x37, 0x36, 0x39, 0x64, 0x32, 0x33, 0x38, 0x62, 0x65, 0x38, 0x64, 0x36, 0x63, 0x63, 0x34, 0x34, 0x34, 0x39, 0x37, 0x30, 0x32, 0x34, 0x34, 0x37, 0x37, 0x33, 0x38, 0x31, 0x61, 0x63, 0x65, 0x64, 0x35, 0x36, 0x31, 0x61, 0x35, 0x63, 0x34, 0x38, 0x34, 0x37, 0x63, 0x31, 0x37, 0x38, 0x61, 0x65, 0x62, 0x37, 0x66, 0x66, 0x32, 0x61, 0x62, 0x32, 0x38, 0x33, 0x65, 0x66, 0x30, 0x65, 0x63, 0x31, 0x62, 0x33, 0x62, 0x31, 0x65, 0x65, 0x37, 0x32, 0x37, 0x63, 0x62, 0x65, 0x30, 0x36, 0x64, 0x38, 0x36, 0x30, 0x62, 0x63, 0x35, 0x31, 0x39, 0x61, 0x39, 0x38, 0x39, 0x65, 0x31, 0x62, 0x36, 0x66, 0x34, 0x65, 0x62, 0x32, 0x65, 0x37, 0x66, 0x32, 0x63, 0x66, 0x33, 0x38, 0x33, 0x37, 0x62, 0x65, 0x31, 0x36, 0x31, 0x39, 0x39, 0x39, 0x61, 0x33, 0x31, 0x32, 0x36, 0x38, 0x38, 0x33, 0x38, 0x61, 0x32, 0x37, 0x32, 0x37, 0x65, 0x39, 0x36, 0x65, 0x37, 0x65, 0x65, 0x66, 0x36, 0x30, 0x38, 0x65, 0x33, 0x36, 0x35, 0x39, 0x32, 0x39, 0x35, 0x30, 0x31, 0x35, 0x39, 0x35, 0x33, 0x35, 0x65, 0x30, 0x34, 0x38, 0x35, 0x37, 0x66, 0x33, 0x61, 0x63, 0x62, 0x35, 0x61, 0x37, 0x64, 0x37, 0x64, 0x36, 0x36, 0x38, 0x35, 0x66, 0x66, 0x61, 0x61, 0x62, 0x32, 0x64, 0x32, 0x36, 0x64, 0x64, 0x31, 0x31, 0x39, 0x37, 0x32, 0x62, 0x33, 0x39, 0x65, 0x35, 0x61, 0x63, 0x65, 0x38, 0x32, 0x64, 0x30, 0x63, 0x61, 0x37, 0x63, 0x36, 0x32, 0x65, 0x39, 0x30, 0x32, 0x65, 0x30, 0x39, 0x61, 0x33, 0x39, 0x35, 0x62, 0x62, 0x32, 0x65, 0x63, 0x39, 0x61, 0x31, 0x35, 0x33, 0x62, 0x34, 0x35, 0x33, 0x34, 0x33, 0x65, 0x37, 0x39, 0x37, 0x36, 0x36, 0x36, 0x31, 0x66, 0x32, 0x66, 0x61, 0x64, 0x63, 0x63, 0x33, 0x63, 0x37, 0x32, 0x33, 0x36, 0x65, 0x38, 0x62, 0x30, 0x33, 0x30, 0x35, 0x63, 0x64, 0x37, 0x35, 0x38, 0x30, 0x36, 0x38, 0x34, 0x30, 0x31, 0x37, 0x36, 0x62, 0x34, 0x36, 0x62, 0x35, 0x38, 0x66, 0x61, 0x35, 0x37, 0x63, 0x61, 0x63, 0x31, 0x32, 0x39, 0x66, 0x62, 0x39, 0x62, 0x32, 0x66, 0x34, 0x36, 0x64, 0x63, 0x63, 0x38, 0x66, 0x34, 0x37, 0x34, 0x31, 0x31, 0x62, 0x64, 0x36, 0x34, 0x65, 0x38, 0x37, 0x32, 0x65, 0x34, 0x38, 0x37, 0x37, 0x31, 0x35, 0x37, 0x66, 0x65, 0x35, 0x30, 0x39, 0x61, 0x38, 0x37, 0x61, 0x31, 0x30, 0x35, 0x38, 0x66, 0x63, 0x35, 0x39, 0x34, 0x32, 0x61, 0x62, 0x34, 0x64, 0x39, 0x35, 0x61, 0x33, 0x64, 0x32, 0x33, 0x35, 0x39, 0x62, 0x64, 0x30, 0x38, 0x37, 0x38, 0x31, 0x39, 0x61, 0x31, 0x38, 0x65, 0x38, 0x31, 0x30, 0x65, 0x31, 0x62, 0x34, 0x61, 0x32, 0x37, 0x31, 0x38, 0x61, 0x39, 0x33, 0x33, 0x66, 0x62, 0x36, 0x31, 0x33, 0x64, 0x36, 0x66, 0x66, 0x63, 0x64, 0x64, 0x38, 0x65, 0x65, 0x32, 0x36, 0x35, 0x38, 0x33, 0x35, 0x34, 0x61, 0x38, 0x39, 0x66, 0x62, 0x65, 0x37, 0x65, 0x62, 0x35, 0x30, 0x30, 0x32, 0x65, 0x31, 0x66, 0x37, 0x34, 0x39, 0x39, 0x63, 0x64, 0x36, 0x63, 0x37, 0x35, 0x65, 0x35, 0x39, 0x65, 0x64, 0x66, 0x39, 0x61, 0x31, 0x39, 0x37, 0x32, 0x32, 0x34, 0x38, 0x35, 0x32, 0x32, 0x63, 0x61, 0x37, 0x65, 0x34, 0x64, 0x61, 0x30, 0x35, 0x31, 0x39, 0x35, 0x61, 0x66, 0x35, 0x32, 0x32, 0x39, 0x39, 0x31, 0x64, 0x63, 0x62, 0x61, 0x62, 0x39, 0x34, 0x62, 0x65, 0x63, 0x35, 0x31, 0x30, 0x33, 0x35, 0x32, 0x39, 0x35, 0x65, 0x30, 0x63, 0x63, 0x32, 0x36, 0x38, 0x38, 0x30, 0x66, 0x61, 0x31, 0x61, 0x64, 0x31, 0x33, 0x38, 0x38, 0x37, 0x32, 0x63, 0x33, 0x36, 0x38, 0x37, 0x63, 0x66, 0x33, 0x34, 0x33, 0x63, 0x38, 0x31, 0x33, 0x34, 0x66, 0x30, 0x32, 0x37, 0x63, 0x65, 0x62, 0x36, 0x64, 0x30, 0x37, 0x63, 0x63, 0x63, 0x65, 0x65, 0x32, 0x62, 0x61, 0x38, 0x64, 0x37, 0x35, 0x63, 0x63, 0x35, 0x32, 0x39, 0x64, 0x33, 0x64, 0x65, 0x31, 0x36, 0x35, 0x65, 0x32, 0x32, 0x30, 0x61, 0x66, 0x31, 0x65, 0x65, 0x65, 0x35, 0x35, 0x35, 0x37, 0x63, 0x65, 0x61, 0x64, 0x36, 0x34, 0x31, 0x66, 0x35, 0x39, 0x64, 0x34, 0x38, 0x34, 0x30, 0x65, 0x39, 0x30, 0x35, 0x31, 0x31, 0x34, 0x61, 0x33, 0x33, 0x33, 0x36, 0x35, 0x31, 0x34, 0x34, 0x39, 0x34, 0x34, 0x31, 0x63, 0x62, 0x65, 0x34, 0x62, 0x31, 0x33, 0x37, 0x62, 0x35, 0x64, 0x38, 0x64, 0x33, 0x36, 0x62, 0x34, 0x34, 0x34, 0x31, 0x62, 0x63, 0x39, 0x31, 0x34, 0x61, 0x32, 0x34, 0x38, 0x64, 0x32, 0x62, 0x33, 0x62, 0x35, 0x39, 0x34, 0x38, 0x31, 0x34, 0x34, 0x63, 0x30, 0x32, 0x62, 0x36, 0x39, 0x31, 0x39, 0x35, 0x38, 0x30, 0x63, 0x32, 0x62, 0x37, 0x32, 0x38, 0x33, 0x36, 0x63, 0x64, 0x37, 0x31, 0x36, 0x62, 0x31, 0x63, 0x35, 0x39, 0x61, 0x66, 0x64, 0x30, 0x66, 0x38, 0x39, 0x38, 0x31, 0x33, 0x32, 0x31, 0x38, 0x34, 0x33, 0x37, 0x36, 0x39, 0x33, 0x33, 0x65, 0x36, 0x39, 0x36, 0x35, 0x66, 0x34, 0x64, 0x37, 0x33, 0x36, 0x32, 0x39, 0x34, 0x30, 0x66, 0x31, 0x36, 0x66, 0x37, 0x62, 0x31, 0x37, 0x36, 0x64, 0x34, 0x31, 0x34, 0x36, 0x31, 0x36, 0x35, 0x63, 0x35, 0x36, 0x35, 0x65, 0x30, 0x37, 0x30, 0x34, 0x39, 0x31, 0x31, 0x32, 0x36, 0x34, 0x34, 0x30, 0x39, 0x39, 0x61, 0x32, 0x39, 0x63, 0x65, 0x62, 0x30, 0x35, 0x65, 0x32, 0x39, 0x36, 0x33, 0x33, 0x37, 0x32, 0x33, 0x34, 0x38, 0x32, 0x39, 0x31, 0x37, 0x34, 0x37, 0x38, 0x34, 0x37, 0x35, 0x36, 0x63, 0x39, 0x33, 0x66, 0x63, 0x31, 0x61, 0x64, 0x37, 0x33, 0x66, 0x66, 0x33, 0x36, 0x61, 0x37, 0x34, 0x32, 0x31, 0x65, 0x61, 0x30, 0x33, 0x38, 0x61, 0x66, 0x61, 0x66, 0x38, 0x38, 0x63, 0x66, 0x37, 0x38, 0x36, 0x63, 0x35, 0x36, 0x37, 0x33, 0x64, 0x31, 0x35, 0x61, 0x32, 0x63, 0x62, 0x37, 0x36, 0x33, 0x63, 0x38, 0x37, 0x65, 0x33, 0x62, 0x37, 0x33, 0x65, 0x65, 0x39, 0x65, 0x66, 0x65, 0x61, 0x37, 0x38, 0x64, 0x61, 0x61, 0x37, 0x63, 0x30, 0x30, 0x64, 0x61, 0x31, 0x32, 0x34, 0x61, 0x32, 0x33, 0x33, 0x39, 0x36, 0x30, 0x32, 0x65, 0x34, 0x61, 0x32, 0x33, 0x39, 0x64, 0x64, 0x62, 0x30, 0x33, 0x62, 0x30, 0x34, 0x66, 0x65, 0x30, 0x61, 0x66, 0x61, 0x61, 0x38, 0x39, 0x61, 0x63, 0x35, 0x66, 0x36, 0x32, 0x33, 0x37, 0x66, 0x36, 0x66, 0x31, 0x31, 0x62, 0x39, 0x64, 0x37, 0x62, 0x65, 0x35, 0x35, 0x61, 0x65, 0x38, 0x63, 0x39, 0x31, 0x63, 0x32, 0x65, 0x30, 0x33, 0x32, 0x30, 0x36, 0x37, 0x39, 0x37, 0x30, 0x31, 0x32, 0x65, 0x38, 0x31, 0x34, 0x38, 0x33, 0x66, 0x30, 0x39, 0x66, 0x33, 0x64, 0x32, 0x62, 0x39, 0x38, 0x36, 0x62, 0x34, 0x35, 0x66, 0x35, 0x61, 0x66, 0x62, 0x37, 0x32, 0x31, 0x64, 0x37, 0x33, 0x36, 0x30, 0x62, 0x31, 0x37, 0x34, 0x39, 0x37, 0x33, 0x66, 0x39, 0x63, 0x30, 0x33, 0x32, 0x38, 0x33, 0x33, 0x61, 0x39, 0x34, 0x36, 0x39, 0x38, 0x65, 0x64, 0x62, 0x34, 0x37, 0x36, 0x66, 0x37, 0x65, 0x61, 0x65, 0x36, 0x35, 0x39, 0x37, 0x34, 0x61, 0x63, 0x35, 0x30, 0x31, 0x34, 0x34, 0x33, 0x36, 0x31, 0x61, 0x32, 0x31, 0x34, 0x30, 0x39, 0x65, 0x61, 0x37, 0x32, 0x35, 0x39, 0x32, 0x37, 0x30, 0x35, 0x65, 0x32, 0x35, 0x61, 0x35, 0x37, 0x35, 0x63, 0x30, 0x64, 0x31, 0x35, 0x30, 0x35, 0x61, 0x36, 0x34, 0x62, 0x63, 0x37, 0x64, 0x32, 0x39, 0x35, 0x38, 0x34, 0x33, 0x64, 0x63, 0x64, 0x35, 0x34, 0x39, 0x36, 0x30, 0x62, 0x66, 0x65, 0x66, 0x61, 0x66, 0x30, 0x36, 0x31, 0x33, 0x65, 0x33, 0x30, 0x65, 0x63, 0x37, 0x34, 0x39, 0x65, 0x37, 0x30, 0x37, 0x32, 0x39, 0x37, 0x64, 0x33, 0x38, 0x62, 0x35, 0x63, 0x63, 0x39, 0x30, 0x35, 0x65, 0x62, 0x38, 0x61, 0x63, 0x65, 0x64, 0x33, 0x62, 0x64, 0x33, 0x62, 0x30, 0x30, 0x36, 0x37, 0x66, 0x30, 0x39, 0x62, 0x39, 0x65, 0x34, 0x34, 0x38, 0x32, 0x63, 0x66, 0x64, 0x34, 0x65, 0x63, 0x37, 0x38, 0x32, 0x62, 0x37, 0x38, 0x30, 0x65, 0x36, 0x30, 0x61, 0x35, 0x30, 0x39, 0x66, 0x30, 0x65, 0x37, 0x34, 0x61, 0x61, 0x64, 0x34, 0x61, 0x36, 0x30, 0x30, 0x35, 0x65, 0x61, 0x31, 0x31, 0x64, 0x31, 0x31, 0x34, 0x62, 0x64, 0x64, 0x61, 0x33, 0x65, 0x39, 0x65, 0x65, 0x39, 0x39, 0x36, 0x31, 0x39, 0x37, 0x66, 0x31, 0x32, 0x63, 0x65, 0x30, 0x31, 0x34, 0x64, 0x30, 0x63, 0x66, 0x34, 0x37, 0x33, 0x61, 0x34, 0x31, 0x35, 0x65, 0x34, 0x66, 0x30, 0x61, 0x66, 0x62, 0x65, 0x62, 0x31, 0x32, 0x37, 0x37, 0x32, 0x36, 0x31, 0x31, 0x38, 0x65, 0x62, 0x66, 0x66, 0x32, 0x63, 0x61, 0x66, 0x30, 0x34, 0x32, 0x33, 0x61, 0x30, 0x32, 0x65, 0x38, 0x30, 0x65, 0x61, 0x32, 0x61, 0x32, 0x36, 0x31, 0x63, 0x32, 0x61, 0x37, 0x33, 0x61, 0x66, 0x32, 0x65, 0x61, 0x65, 0x39, 0x39, 0x66, 0x66, 0x61, 0x39, 0x66, 0x34, 0x65, 0x63, 0x63, 0x36, 0x37, 0x31, 0x30, 0x62, 0x61, 0x38, 0x39, 0x62, 0x34, 0x39, 0x35, 0x36, 0x33, 0x31, 0x38, 0x62, 0x66, 0x34, 0x64, 0x39, 0x62, 0x65, 0x64, 0x61, 0x37, 0x34, 0x34, 0x64, 0x35, 0x30, 0x31, 0x35, 0x64, 0x62, 0x65, 0x62, 0x61, 0x61, 0x62, 0x62, 0x61, 0x31, 0x66, 0x66, 0x31, 0x64, 0x30, 0x63, 0x62, 0x63, 0x66, 0x64, 0x39, 0x65, 0x64, 0x31, 0x38, 0x33, 0x36, 0x33, 0x32, 0x34, 0x63, 0x62, 0x64, 0x62, 0x63, 0x37, 0x33, 0x35, 0x32, 0x62, 0x34, 0x34, 0x32, 0x39, 0x33, 0x33, 0x35, 0x66, 0x61, 0x32, 0x61, 0x36, 0x32, 0x30, 0x32, 0x39, 0x64, 0x38, 0x37, 0x62, 0x34, 0x31, 0x34, 0x63, 0x38, 0x30, 0x33, 0x39, 0x34, 0x61, 0x37, 0x35, 0x61, 0x64, 0x31, 0x39, 0x61, 0x39, 0x31, 0x34, 0x34, 0x65, 0x38, 0x35, 0x37, 0x65, 0x39, 0x65, 0x64, 0x35, 0x35, 0x33, 0x62, 0x34, 0x66, 0x64, 0x31, 0x32, 0x36, 0x34, 0x31, 0x31, 0x64, 0x66, 0x33, 0x64, 0x31, 0x34, 0x63, 0x34, 0x63, 0x39, 0x64, 0x32, 0x38, 0x33, 0x34, 0x33, 0x66, 0x34, 0x36, 0x63, 0x34, 0x39, 0x64, 0x31, 0x32, 0x37, 0x38, 0x64, 0x33, 0x31, 0x64, 0x66, 0x36, 0x63, 0x30, 0x39, 0x66, 0x38, 0x38, 0x63, 0x39, 0x62, 0x35, 0x36, 0x61, 0x32, 0x38, 0x37, 0x62, 0x62, 0x31, 0x61, 0x38, 0x66, 0x62, 0x62, 0x37, 0x64, 0x39, 0x36, 0x61, 0x62, 0x62, 0x62, 0x36, 0x37, 0x35, 0x61, 0x37, 0x32, 0x37, 0x63, 0x39, 0x31, 0x31, 0x30, 0x36, 0x39, 0x66, 0x64, 0x33, 0x37, 0x30, 0x37, 0x63, 0x64, 0x35, 0x63, 0x62, 0x66, 0x35, 0x35, 0x32, 0x38, 0x33, 0x63, 0x64, 0x65, 0x32, 0x38, 0x35, 0x31, 0x64, 0x35, 0x32, 0x65, 0x64, 0x66, 0x38, 0x61, 0x30, 0x34, 0x38, 0x36, 0x38, 0x35, 0x36, 0x36, 0x66, 0x37, 0x33, 0x38, 0x38, 0x31, 0x33, 0x33, 0x66, 0x35, 0x39, 0x35, 0x30, 0x36, 0x37, 0x32, 0x62, 0x65, 0x37, 0x62, 0x39, 0x38, 0x35, 0x64, 0x66, 0x63, 0x33, 0x63, 0x30, 0x39, 0x38, 0x31, 0x63, 0x37, 0x37, 0x36, 0x39, 0x30, 0x36, 0x37, 0x31, 0x35, 0x32, 0x62, 0x39, 0x63, 0x62, 0x63, 0x31, 0x35, 0x66, 0x32, 0x33, 0x66, 0x37, 0x34, 0x66, 0x38, 0x64, 0x61, 0x32, 0x64, 0x66, 0x39, 0x31, 0x30, 0x35, 0x63, 0x62, 0x64, 0x36, 0x61, 0x30, 0x31, 0x33, 0x32, 0x63, 0x64, 0x30, 0x62, 0x63, 0x39, 0x31, 0x39, 0x64, 0x63, 0x30, 0x64, 0x64, 0x38, 0x34, 0x38, 0x38, 0x39, 0x31, 0x35, 0x65, 0x35, 0x32, 0x66, 0x37, 0x36, 0x65, 0x36, 0x39, 0x62, 0x31, 0x31, 0x39, 0x62, 0x34, 0x37, 0x30, 0x39, 0x39, 0x65, 0x39, 0x30, 0x37, 0x37, 0x62, 0x37, 0x30, 0x66, 0x35, 0x65, 0x63, 0x35, 0x31, 0x62, 0x32, 0x66, 0x66, 0x34, 0x66, 0x62, 0x33, 0x62, 0x66, 0x39, 0x39, 0x32, 0x37, 0x32, 0x63, 0x37, 0x38, 0x66, 0x37, 0x36, 0x63, 0x33, 0x62, 0x64, 0x65, 0x38, 0x36, 0x31, 0x35, 0x34, 0x31, 0x61, 0x30, 0x34, 0x61, 0x34, 0x38, 0x32, 0x35, 0x39, 0x33, 0x62, 0x34, 0x30, 0x30, 0x63, 0x30, 0x62, 0x63, 0x38, 0x36, 0x31, 0x61, 0x34, 0x30, 0x62, 0x34, 0x35, 0x37, 0x63, 0x64, 0x61, 0x63, 0x62, 0x32, 0x30, 0x65, 0x34, 0x66, 0x39, 0x61, 0x62, 0x31, 0x31, 0x61, 0x66, 0x37, 0x32, 0x38, 0x62, 0x35, 0x39, 0x38, 0x33, 0x66, 0x33, 0x64, 0x37, 0x62, 0x64, 0x36, 0x66, 0x66, 0x66, 0x61, 0x30, 0x62, 0x66, 0x32, 0x31, 0x38, 0x66, 0x38, 0x33, 0x35, 0x34, 0x63, 0x64, 0x39, 0x36, 0x30, 0x63, 0x35, 0x63, 0x30, 0x32, 0x62, 0x34, 0x38, 0x66, 0x65, 0x35, 0x38, 0x30, 0x64, 0x38, 0x62, 0x33, 0x36, 0x62, 0x38, 0x38, 0x63, 0x38, 0x63, 0x30, 0x37, 0x31, 0x66, 0x39, 0x31, 0x34, 0x38, 0x64, 0x30, 0x37, 0x33, 0x65, 0x33, 0x66, 0x61, 0x34, 0x62, 0x30, 0x61, 0x37, 0x65, 0x66, 0x66, 0x39, 0x38, 0x39, 0x38, 0x37, 0x34, 0x34, 0x61, 0x33, 0x31, 0x65, 0x62, 0x63, 0x37, 0x34, 0x64, 0x32, 0x39, 0x38, 0x35, 0x35, 0x63, 0x39, 0x32, 0x64, 0x62, 0x38, 0x39, 0x32, 0x64, 0x31, 0x31, 0x33, 0x64, 0x36, 0x65, 0x35, 0x33, 0x33, 0x65, 0x35, 0x30, 0x33, 0x34, 0x65, 0x37, 0x32, 0x62, 0x36, 0x61, 0x31, 0x39, 0x65, 0x37, 0x62, 0x36, 0x64, 0x30, 0x62, 0x63, 0x61, 0x37, 0x30, 0x37, 0x66, 0x65, 0x31, 0x65, 0x62, 0x65, 0x65, 0x66, 0x32, 0x31, 0x36, 0x61, 0x61, 0x37, 0x31, 0x34, 0x37, 0x33, 0x33, 0x30, 0x63, 0x33, 0x35, 0x32, 0x37, 0x65, 0x63, 0x65, 0x34, 0x65, 0x62, 0x30, 0x31, 0x35, 0x66, 0x39, 0x36, 0x35, 0x62, 0x36, 0x31, 0x62, 0x39, 0x33, 0x62, 0x37, 0x32, 0x35, 0x34, 0x64, 0x65, 0x31, 0x66, 0x31, 0x61, 0x61, 0x31, 0x61, 0x35, 0x61, 0x36, 0x38, 0x37, 0x61, 0x31, 0x31, 0x37, 0x30, 0x65, 0x35, 0x39, 0x62, 0x61, 0x36, 0x36, 0x38, 0x30, 0x33, 0x35, 0x38, 0x65, 0x32, 0x32, 0x31, 0x65, 0x31, 0x36, 0x65, 0x38, 0x31, 0x30, 0x31, 0x33, 0x61, 0x34, 0x63, 0x62, 0x66, 0x65, 0x32, 0x31, 0x34, 0x30, 0x64, 0x30, 0x34, 0x62, 0x39, 0x32, 0x30, 0x32, 0x31, 0x64, 0x37, 0x39, 0x35, 0x30, 0x35, 0x32, 0x66, 0x33, 0x35, 0x33, 0x31, 0x65, 0x66, 0x65, 0x32, 0x66, 0x30, 0x30, 0x30, 0x34, 0x38, 0x62, 0x38, 0x65, 0x62, 0x66, 0x63, 0x61, 0x36, 0x39, 0x39, 0x37, 0x36, 0x66, 0x66, 0x38, 0x35, 0x33, 0x37, 0x30, 0x30, 0x62, 0x34, 0x63, 0x64, 0x35, 0x66, 0x37, 0x63, 0x64, 0x36, 0x65, 0x32, 0x33, 0x63, 0x36, 0x39, 0x38, 0x62, 0x33, 0x37, 0x32, 0x34, 0x39, 0x34, 0x62, 0x34, 0x33, 0x36, 0x62, 0x36, 0x65, 0x38, 0x37, 0x30, 0x33, 0x64, 0x61, 0x35, 0x36, 0x39, 0x62, 0x65, 0x33, 0x31, 0x31, 0x39, 0x31, 0x36, 0x63, 0x66, 0x65, 0x34, 0x64, 0x35, 0x31, 0x35, 0x30, 0x32, 0x64, 0x63, 0x32, 0x63, 0x39, 0x34, 0x39, 0x65, 0x35, 0x30, 0x65, 0x65, 0x39, 0x63, 0x64, 0x33, 0x31, 0x64, 0x65, 0x35, 0x66, 0x64, 0x37, 0x65, 0x33, 0x37, 0x32, 0x63, 0x64, 0x39, 0x33, 0x36, 0x39, 0x65, 0x32, 0x36, 0x61, 0x35, 0x37, 0x62, 0x33, 0x39, 0x32, 0x65, 0x33, 0x66, 0x31, 0x32, 0x33, 0x37, 0x37, 0x38, 0x31, 0x65, 0x35, 0x35, 0x31, 0x66, 0x35, 0x37, 0x34, 0x64, 0x66, 0x31, 0x35, 0x63, 0x33, 0x35, 0x31, 0x63, 0x30, 0x61, 0x30, 0x61, 0x66, 0x34, 0x32, 0x32, 0x38, 0x36, 0x38, 0x37, 0x37, 0x61, 0x35, 0x38, 0x64, 0x33, 0x39, 0x37, 0x32, 0x36, 0x35, 0x66, 0x66, 0x35, 0x31, 0x65, 0x31, 0x63, 0x63, 0x32, 0x62, 0x34, 0x63, 0x64, 0x61, 0x39, 0x39, 0x65, 0x32, 0x30, 0x31, 0x34, 0x64, 0x65, 0x35, 0x63, 0x62, 0x34, 0x64, 0x62, 0x66, 0x66, 0x61, 0x32, 0x31, 0x63, 0x39, 0x64, 0x35, 0x34, 0x39, 0x61, 0x38, 0x63, 0x61, 0x31, 0x32, 0x62, 0x34, 0x39, 0x34, 0x63, 0x65, 0x65, 0x61, 0x33, 0x63, 0x62, 0x30, 0x38, 0x38, 0x35, 0x36, 0x39, 0x65, 0x61, 0x35, 0x63, 0x32, 0x34, 0x33, 0x64, 0x33, 0x64, 0x31, 0x32, 0x32, 0x31, 0x66, 0x39, 0x61, 0x32, 0x66, 0x65, 0x65, 0x65, 0x38, 0x39, 0x33, 0x34, 0x31, 0x63, 0x64, 0x64, 0x65, 0x65, 0x64, 0x63, 0x38, 0x35, 0x66, 0x34, 0x38, 0x63, 0x63, 0x31, 0x31, 0x38, 0x36, 0x31, 0x32, 0x31, 0x63, 0x32, 0x64, 0x66, 0x66, 0x62, 0x66, 0x33, 0x33, 0x35, 0x64, 0x36, 0x64, 0x37, 0x32, 0x31, 0x34, 0x35, 0x31, 0x31, 0x31, 0x65, 0x35, 0x31, 0x32, 0x38, 0x63, 0x30, 0x66, 0x30, 0x66, 0x30, 0x66, 0x39, 0x64, 0x31, 0x33, 0x32, 0x34, 0x30, 0x34, 0x31, 0x34, 0x66, 0x66, 0x34, 0x63, 0x63, 0x61, 0x66, 0x66, 0x61, 0x37, 0x32, 0x64, 0x33, 0x32, 0x37, 0x30, 0x32, 0x35, 0x38, 0x64, 0x34, 0x39, 0x66, 0x32, 0x38, 0x36, 0x36, 0x35, 0x34, 0x33, 0x62, 0x33, 0x31, 0x62, 0x37, 0x32, 0x35, 0x62, 0x31, 0x64, 0x32, 0x39, 0x63, 0x32, 0x34, 0x63, 0x37, 0x61, 0x35, 0x64, 0x64, 0x32, 0x64, 0x34, 0x37, 0x64, 0x31, 0x30, 0x63, 0x35, 0x65, 0x66, 0x31, 0x35, 0x64, 0x37, 0x38, 0x65, 0x39, 0x64, 0x34, 0x30, 0x39, 0x32, 0x39, 0x37, 0x33, 0x62, 0x66, 0x36, 0x63, 0x38, 0x35, 0x30, 0x35, 0x63, 0x61, 0x66, 0x63, 0x32, 0x61, 0x64, 0x31, 0x63, 0x66, 0x31, 0x61, 0x37, 0x33, 0x62, 0x61, 0x31, 0x34, 0x65, 0x66, 0x62, 0x61, 0x30, 0x66, 0x31, 0x63, 0x33, 0x65, 0x65, 0x65, 0x35, 0x66, 0x36, 0x31, 0x30, 0x32, 0x33, 0x38, 0x34, 0x63, 0x33, 0x65, 0x33, 0x35, 0x34, 0x38, 0x66, 0x33, 0x38, 0x64, 0x64, 0x33, 0x33, 0x35, 0x30, 0x65, 0x30, 0x36, 0x37, 0x63, 0x34, 0x37, 0x61, 0x33, 0x32, 0x61, 0x34, 0x66, 0x37, 0x64, 0x66, 0x35, 0x39, 0x35, 0x35, 0x31, 0x36, 0x37, 0x32, 0x32, 0x34, 0x30, 0x65, 0x31, 0x38, 0x66, 0x30, 0x32, 0x61, 0x63, 0x65, 0x65, 0x31, 0x61, 0x33, 0x63, 0x34, 0x62, 0x62, 0x39, 0x35, 0x34, 0x64, 0x38, 0x38, 0x62, 0x39, 0x32, 0x39, 0x66, 0x32, 0x36, 0x38, 0x36, 0x33, 0x65, 0x65, 0x38, 0x34, 0x65, 0x35, 0x32, 0x63, 0x35, 0x65, 0x36, 0x38, 0x32, 0x35, 0x31, 0x39, 0x38, 0x64, 0x35, 0x31, 0x66, 0x31, 0x35, 0x65, 0x66, 0x64, 0x37, 0x32, 0x34, 0x62, 0x34, 0x32, 0x36, 0x38, 0x61, 0x33, 0x30, 0x61, 0x65, 0x35, 0x39, 0x65, 0x31, 0x39, 0x38, 0x63, 0x36, 0x39, 0x30, 0x36, 0x64, 0x65, 0x37, 0x62, 0x62, 0x32, 0x30, 0x34, 0x35, 0x38, 0x31, 0x33, 0x30, 0x34, 0x36, 0x64, 0x33, 0x66, 0x37, 0x64, 0x64, 0x64, 0x32, 0x36, 0x37, 0x33, 0x66, 0x65, 0x30, 0x32, 0x66, 0x33, 0x66, 0x33, 0x38, 0x30, 0x32, 0x33, 0x61, 0x32, 0x37, 0x32, 0x36, 0x34, 0x38, 0x33, 0x65, 0x65, 0x31, 0x37, 0x62, 0x30, 0x61, 0x39, 0x31, 0x32, 0x31, 0x64, 0x34, 0x39, 0x33, 0x38, 0x31, 0x37, 0x37, 0x62, 0x64, 0x66, 0x31, 0x66, 0x65, 0x66, 0x34, 0x62, 0x62, 0x61, 0x38, 0x38, 0x38, 0x63, 0x31, 0x39, 0x63, 0x33, 0x31, 0x36, 0x63, 0x30, 0x31, 0x30, 0x65, 0x33, 0x37, 0x32, 0x33, 0x61, 0x36, 0x33, 0x64, 0x30, 0x32, 0x62, 0x38, 0x64, 0x37, 0x32, 0x38, 0x32, 0x66, 0x63, 0x64, 0x35, 0x32, 0x39, 0x30, 0x61, 0x65, 0x34, 0x65, 0x31, 0x30, 0x34, 0x66, 0x63, 0x66, 0x36, 0x36, 0x34, 0x36, 0x38, 0x36, 0x36, 0x61, 0x38, 0x31, 0x64, 0x63, 0x64, 0x35, 0x31, 0x65, 0x38, 0x36, 0x65, 0x63, 0x37, 0x39, 0x62, 0x62, 0x62, 0x35, 0x34, 0x31, 0x36, 0x66, 0x33, 0x62, 0x32, 0x32, 0x34, 0x63, 0x63, 0x35, 0x65, 0x62, 0x35, 0x38, 0x64, 0x35, 0x66, 0x61, 0x65, 0x34, 0x30, 0x63, 0x65, 0x36, 0x38, 0x34, 0x61, 0x37, 0x33, 0x32, 0x38, 0x62, 0x63, 0x30, 0x37, 0x38, 0x35, 0x35, 0x31, 0x62, 0x32, 0x62, 0x32, 0x30, 0x30, 0x37, 0x61, 0x64, 0x65, 0x38, 0x31, 0x62, 0x31, 0x39, 0x39, 0x65, 0x65, 0x35, 0x35, 0x37, 0x33, 0x61, 0x38, 0x35, 0x34, 0x35, 0x37, 0x37, 0x65, 0x32, 0x63, 0x31, 0x61, 0x38, 0x62, 0x31, 0x38, 0x65, 0x38, 0x37, 0x32, 0x61, 0x35, 0x63, 0x32, 0x31, 0x34, 0x39, 0x31, 0x37, 0x62, 0x62, 0x64, 0x35, 0x38, 0x35, 0x63, 0x61, 0x35, 0x35, 0x66, 0x38, 0x36, 0x30, 0x38, 0x65, 0x38, 0x66, 0x32, 0x62, 0x66, 0x62, 0x64, 0x37, 0x63, 0x37, 0x61, 0x64, 0x63, 0x66, 0x33, 0x33, 0x34, 0x35, 0x64, 0x35, 0x33, 0x63, 0x65, 0x30, 0x66, 0x37, 0x30, 0x38, 0x38, 0x37, 0x30, 0x65, 0x39, 0x36, 0x38, 0x66, 0x64, 0x37, 0x32, 0x62, 0x37, 0x34, 0x63, 0x63, 0x65, 0x31, 0x34, 0x38, 0x61, 0x33, 0x61, 0x39, 0x36, 0x30, 0x30, 0x37, 0x31, 0x39, 0x30, 0x62, 0x62, 0x38, 0x61, 0x30, 0x38, 0x39, 0x33, 0x30, 0x34, 0x65, 0x33, 0x64, 0x35, 0x37, 0x36, 0x62, 0x35, 0x38, 0x32, 0x61, 0x31, 0x30, 0x34, 0x39, 0x64, 0x65, 0x37, 0x66, 0x33, 0x32, 0x38, 0x39, 0x34, 0x37, 0x32, 0x61, 0x64, 0x35, 0x32, 0x62, 0x34, 0x35, 0x66, 0x39, 0x34, 0x39, 0x32, 0x62, 0x35, 0x32, 0x61, 0x63, 0x64, 0x63, 0x32, 0x62, 0x63, 0x62, 0x33, 0x63, 0x32, 0x33, 0x35, 0x61, 0x31, 0x35, 0x62, 0x31, 0x65, 0x61, 0x64, 0x66, 0x37, 0x36, 0x38, 0x36, 0x35, 0x33, 0x37, 0x32, 0x34, 0x39, 0x31, 0x38, 0x36, 0x31, 0x61, 0x38, 0x62, 0x37, 0x65, 0x36, 0x31, 0x32, 0x37, 0x65, 0x33, 0x63, 0x31, 0x32, 0x32, 0x35, 0x31, 0x35, 0x35, 0x37, 0x32, 0x61, 0x31, 0x31, 0x38, 0x30, 0x34, 0x64, 0x65, 0x36, 0x63, 0x62, 0x33, 0x35, 0x63, 0x66, 0x65, 0x65, 0x32, 0x63, 0x61, 0x61, 0x62, 0x32, 0x62, 0x30, 0x62, 0x37, 0x36, 0x65, 0x63, 0x66, 0x35, 0x32, 0x30, 0x38, 0x63, 0x66, 0x64, 0x64, 0x65, 0x36, 0x39, 0x34, 0x36, 0x65, 0x30, 0x65, 0x34, 0x38, 0x62, 0x37, 0x34, 0x66, 0x61, 0x38, 0x65, 0x35, 0x61, 0x35, 0x66, 0x31, 0x35, 0x32, 0x35, 0x33, 0x63, 0x31, 0x37, 0x61, 0x32, 0x33, 0x62, 0x39, 0x30, 0x32, 0x34, 0x35, 0x30, 0x37, 0x66, 0x32, 0x30, 0x66, 0x36, 0x64, 0x36, 0x32, 0x38, 0x63, 0x62, 0x61, 0x35, 0x31, 0x63, 0x35, 0x64, 0x62, 0x35, 0x31, 0x64, 0x63, 0x63, 0x31, 0x61, 0x35, 0x66, 0x31, 0x62, 0x30, 0x31, 0x32, 0x63, 0x65, 0x37, 0x32, 0x63, 0x31, 0x66, 0x30, 0x62, 0x33, 0x66, 0x39, 0x30, 0x30, 0x32, 0x37, 0x32, 0x63, 0x65, 0x35, 0x66, 0x63, 0x38, 0x38, 0x66, 0x38, 0x61, 0x35, 0x34, 0x37, 0x35, 0x37, 0x39, 0x36, 0x61, 0x38, 0x34, 0x66, 0x61, 0x66, 0x34, 0x64, 0x39, 0x32, 0x62, 0x30, 0x61, 0x64, 0x38, 0x62, 0x31, 0x36, 0x64, 0x34, 0x36, 0x62, 0x36, 0x39, 0x38, 0x35, 0x37, 0x37, 0x33, 0x63, 0x36, 0x33, 0x30, 0x36, 0x62, 0x37, 0x32, 0x32, 0x61, 0x62, 0x35, 0x37, 0x31, 0x61, 0x39, 0x37, 0x32, 0x63, 0x62, 0x33, 0x33, 0x36, 0x61, 0x30, 0x31, 0x61, 0x62, 0x61, 0x38, 0x61, 0x36, 0x38, 0x64, 0x39, 0x65, 0x61, 0x32, 0x37, 0x63, 0x32, 0x31, 0x61, 0x33, 0x61, 0x63, 0x39, 0x66, 0x61, 0x66, 0x62, 0x65, 0x66, 0x63, 0x63, 0x62, 0x36, 0x37, 0x38, 0x34, 0x36, 0x33, 0x33, 0x62, 0x65, 0x65, 0x31, 0x38, 0x61, 0x61, 0x63, 0x34, 0x38, 0x36, 0x34, 0x30, 0x66, 0x66, 0x62, 0x64, 0x34, 0x31, 0x62, 0x61, 0x39, 0x30, 0x65, 0x34, 0x39, 0x30, 0x35, 0x63, 0x39, 0x61, 0x61, 0x30, 0x37, 0x38, 0x32, 0x35, 0x37, 0x66, 0x64, 0x63, 0x61, 0x37, 0x39, 0x33, 0x65, 0x33, 0x62, 0x65, 0x38, 0x31, 0x32, 0x30, 0x39, 0x37, 0x31, 0x35, 0x31, 0x31, 0x32, 0x37, 0x65, 0x30, 0x65, 0x64, 0x36, 0x31, 0x33, 0x66, 0x61, 0x35, 0x30, 0x63, 0x61, 0x64, 0x34, 0x66, 0x39, 0x62, 0x32, 0x31, 0x35, 0x35, 0x64, 0x61, 0x34, 0x64, 0x36, 0x64, 0x35, 0x35, 0x34, 0x62, 0x38, 0x30, 0x36, 0x36, 0x35, 0x35, 0x61, 0x31, 0x35, 0x37, 0x66, 0x66, 0x65, 0x39, 0x62, 0x31, 0x38, 0x37, 0x35, 0x37, 0x36, 0x32, 0x33, 0x61, 0x31, 0x64, 0x38, 0x63, 0x65, 0x38, 0x36, 0x64, 0x61, 0x37, 0x36, 0x36, 0x30, 0x35, 0x30, 0x39, 0x39, 0x32, 0x36, 0x33, 0x66, 0x61, 0x37, 0x63, 0x31, 0x33, 0x65, 0x36, 0x37, 0x32, 0x65, 0x61, 0x37, 0x34, 0x63, 0x32, 0x65, 0x34, 0x61, 0x61, 0x63, 0x32, 0x37, 0x31, 0x35, 0x34, 0x30, 0x33, 0x62, 0x64, 0x34, 0x64, 0x37, 0x34, 0x35, 0x39, 0x30, 0x33, 0x38, 0x30, 0x66, 0x39, 0x38, 0x64, 0x37, 0x35, 0x31, 0x64, 0x31, 0x39, 0x65, 0x31, 0x37, 0x36, 0x64, 0x61, 0x39, 0x36, 0x33, 0x38, 0x32, 0x36, 0x62, 0x37, 0x61, 0x35, 0x35, 0x30, 0x31, 0x30, 0x32, 0x36, 0x37, 0x32, 0x32, 0x36, 0x34, 0x38, 0x30, 0x39, 0x37, 0x64, 0x62, 0x64, 0x65, 0x66, 0x65, 0x65, 0x39, 0x30, 0x62, 0x61, 0x30, 0x61, 0x39, 0x36, 0x34, 0x39, 0x64, 0x32, 0x30, 0x36, 0x32, 0x65, 0x33, 0x33, 0x36, 0x61, 0x38, 0x33, 0x61, 0x34, 0x34, 0x62, 0x31, 0x32, 0x64, 0x62, 0x62, 0x30, 0x38, 0x32, 0x30, 0x66, 0x39, 0x34, 0x34, 0x64, 0x32, 0x36, 0x34, 0x36, 0x63, 0x32, 0x61, 0x37, 0x36, 0x64, 0x33, 0x66, 0x63, 0x39, 0x31, 0x35, 0x63, 0x61, 0x62, 0x36, 0x65, 0x35, 0x66, 0x63, 0x35, 0x62, 0x66, 0x35, 0x37, 0x65, 0x65, 0x39, 0x39, 0x37, 0x33, 0x31, 0x33, 0x65, 0x63, 0x39, 0x64, 0x38, 0x31, 0x34, 0x63, 0x64, 0x31, 0x61, 0x31, 0x37, 0x39, 0x66, 0x37, 0x39, 0x35, 0x64, 0x34, 0x39, 0x64, 0x31, 0x65, 0x61, 0x66, 0x30, 0x30, 0x37, 0x30, 0x63, 0x63, 0x33, 0x32, 0x37, 0x30, 0x63, 0x61, 0x66, 0x39, 0x66, 0x35, 0x66, 0x33, 0x32, 0x64, 0x30, 0x63, 0x37, 0x36, 0x31, 0x30, 0x38, 0x36, 0x39, 0x36, 0x30, 0x35, 0x31, 0x61, 0x63, 0x65, 0x33, 0x39, 0x37, 0x37, 0x61, 0x30, 0x32, 0x30, 0x37, 0x34, 0x37, 0x31, 0x32, 0x66, 0x64, 0x32, 0x30, 0x33, 0x32, 0x37, 0x39, 0x34, 0x64, 0x34, 0x30, 0x34, 0x34, 0x66, 0x34, 0x39, 0x34, 0x66, 0x38, 0x65, 0x39, 0x64, 0x32, 0x35, 0x65, 0x39, 0x36, 0x65, 0x66, 0x39, 0x63, 0x39, 0x38, 0x33, 0x32, 0x30, 0x34, 0x62, 0x66, 0x39, 0x38, 0x35, 0x31, 0x38, 0x38, 0x61, 0x63, 0x61, 0x65, 0x36, 0x64, 0x30, 0x66, 0x61, 0x32, 0x32, 0x61, 0x62, 0x36, 0x33, 0x38, 0x66, 0x61, 0x63, 0x35, 0x65, 0x34, 0x36, 0x63, 0x65, 0x65, 0x31, 0x30, 0x30, 0x61, 0x36, 0x65, 0x65, 0x63, 0x36, 0x35, 0x63, 0x64, 0x34, 0x37, 0x35, 0x32, 0x30, 0x61, 0x64, 0x32, 0x31, 0x37, 0x33, 0x32, 0x63, 0x39, 0x62, 0x66, 0x34, 0x35, 0x35, 0x32, 0x34, 0x36, 0x32, 0x66, 0x64, 0x61, 0x32, 0x38, 0x33, 0x34, 0x36, 0x64, 0x64, 0x34, 0x33, 0x38, 0x35, 0x30, 0x34, 0x36, 0x37, 0x38, 0x65, 0x62, 0x66, 0x66, 0x64, 0x31, 0x35, 0x30, 0x37, 0x31, 0x31, 0x66, 0x64, 0x65, 0x31, 0x35, 0x62, 0x61, 0x35, 0x37, 0x31, 0x33, 0x33, 0x39, 0x31, 0x63, 0x37, 0x32, 0x37, 0x66, 0x32, 0x65, 0x34, 0x63, 0x38, 0x35, 0x65, 0x64, 0x63, 0x36, 0x65, 0x37, 0x39, 0x35, 0x66, 0x66, 0x35, 0x32, 0x39, 0x39, 0x34, 0x37, 0x34, 0x61, 0x62, 0x33, 0x35, 0x64, 0x33, 0x33, 0x66, 0x36, 0x64, 0x63, 0x34, 0x30, 0x34, 0x37, 0x39, 0x63, 0x64, 0x34, 0x31, 0x63, 0x36, 0x37, 0x38, 0x63, 0x65, 0x31, 0x37, 0x39, 0x61, 0x62, 0x63, 0x39, 0x32, 0x34, 0x37, 0x63, 0x33, 0x62, 0x30, 0x39, 0x39, 0x33, 0x32, 0x61, 0x65, 0x34, 0x38, 0x32, 0x61, 0x34, 0x38, 0x38, 0x34, 0x30, 0x61, 0x30, 0x61, 0x62, 0x62, 0x30, 0x61, 0x31, 0x62, 0x39, 0x34, 0x66, 0x63, 0x65, 0x36, 0x62, 0x36, 0x64, 0x35, 0x34, 0x35, 0x34, 0x61, 0x31, 0x63, 0x64, 0x64, 0x32, 0x62, 0x33, 0x66, 0x65, 0x30, 0x32, 0x64, 0x63, 0x62, 0x36, 0x35, 0x36, 0x61, 0x63, 0x38, 0x65, 0x61, 0x62, 0x35, 0x34, 0x37, 0x33, 0x63, 0x62, 0x33, 0x31, 0x35, 0x64, 0x62, 0x64, 0x63, 0x61, 0x38, 0x62, 0x65, 0x62, 0x66, 0x61, 0x34, 0x32, 0x61, 0x65, 0x35, 0x31, 0x32, 0x39, 0x63, 0x36, 0x65, 0x62, 0x66, 0x35, 0x30, 0x30, 0x61, 0x33, 0x37, 0x62, 0x63, 0x65, 0x65, 0x65, 0x31, 0x66, 0x31, 0x66, 0x64, 0x37, 0x37, 0x31, 0x31, 0x63, 0x38, 0x30, 0x63, 0x61, 0x36, 0x36, 0x36, 0x37, 0x36, 0x37, 0x35, 0x30, 0x63, 0x63, 0x32, 0x36, 0x34, 0x39, 0x31, 0x31, 0x61, 0x34, 0x66, 0x36, 0x35, 0x36, 0x65, 0x38, 0x66, 0x34, 0x38, 0x30, 0x61, 0x65, 0x33, 0x31, 0x62, 0x65, 0x61, 0x66, 0x62, 0x34, 0x34, 0x38, 0x32, 0x64, 0x65, 0x65, 0x38, 0x64, 0x63, 0x35, 0x39, 0x31, 0x39, 0x30, 0x63, 0x31, 0x35, 0x34, 0x62, 0x39, 0x63, 0x64, 0x38, 0x39, 0x34, 0x34, 0x63, 0x32, 0x32, 0x39, 0x31, 0x34, 0x32, 0x39, 0x64, 0x38, 0x62, 0x37, 0x65, 0x32, 0x32, 0x36, 0x65, 0x39, 0x34, 0x64, 0x66, 0x39, 0x31, 0x64, 0x61, 0x32, 0x35, 0x62, 0x38, 0x63, 0x37, 0x34, 0x37, 0x34, 0x36, 0x33, 0x35, 0x31, 0x35, 0x65, 0x31, 0x34, 0x30, 0x33, 0x31, 0x33, 0x62, 0x39, 0x38, 0x64, 0x31, 0x31, 0x61, 0x39, 0x35, 0x33, 0x39, 0x65, 0x61, 0x62, 0x35, 0x32, 0x37, 0x33, 0x38, 0x64, 0x30, 0x38, 0x31, 0x31, 0x31, 0x61, 0x33, 0x66, 0x31, 0x38, 0x31, 0x32, 0x37, 0x38, 0x62, 0x36, 0x37, 0x66, 0x33, 0x37, 0x30, 0x61, 0x64, 0x61, 0x62, 0x63, 0x35, 0x38, 0x36, 0x32, 0x30, 0x39, 0x61, 0x37, 0x37, 0x30, 0x64, 0x32, 0x32, 0x64, 0x62, 0x61, 0x61, 0x38, 0x35, 0x32, 0x31, 0x34, 0x36, 0x33, 0x33, 0x34, 0x39, 0x39, 0x36, 0x61, 0x39, 0x63, 0x36, 0x37, 0x36, 0x35, 0x66, 0x35, 0x33, 0x35, 0x36, 0x31, 0x37, 0x32, 0x63, 0x34, 0x37, 0x32, 0x37, 0x37, 0x31, 0x33, 0x33, 0x66, 0x66, 0x37, 0x37, 0x61, 0x36, 0x34, 0x31, 0x31, 0x30, 0x35, 0x32, 0x38, 0x38, 0x64, 0x31, 0x32, 0x33, 0x33, 0x62, 0x38, 0x33, 0x35, 0x66, 0x31, 0x33, 0x64, 0x34, 0x32, 0x38, 0x64, 0x34, 0x38, 0x37, 0x65, 0x65, 0x32, 0x33, 0x34, 0x30, 0x34, 0x31, 0x33, 0x39, 0x61, 0x33, 0x30, 0x62, 0x64, 0x34, 0x31, 0x32, 0x32, 0x34, 0x35, 0x37, 0x31, 0x62, 0x61, 0x35, 0x37, 0x36, 0x64, 0x38, 0x34, 0x63, 0x37, 0x39, 0x62, 0x37, 0x62, 0x62, 0x66, 0x38, 0x31, 0x30, 0x39, 0x36, 0x39, 0x64, 0x64, 0x33, 0x62, 0x63, 0x36, 0x61, 0x30, 0x66, 0x62, 0x32, 0x64, 0x31, 0x62, 0x65, 0x34, 0x62, 0x33, 0x33, 0x39, 0x64, 0x33, 0x65, 0x37, 0x34, 0x65, 0x35, 0x34, 0x61, 0x37, 0x36, 0x66, 0x39, 0x34, 0x38, 0x62, 0x62, 0x65, 0x35, 0x30, 0x63, 0x32, 0x36, 0x34, 0x63, 0x61, 0x61, 0x66, 0x63, 0x35, 0x66, 0x31, 0x36, 0x61, 0x34, 0x37, 0x64, 0x63, 0x31, 0x36, 0x34, 0x35, 0x32, 0x62, 0x34, 0x61, 0x33, 0x63, 0x39, 0x35, 0x63, 0x36, 0x63, 0x36, 0x65, 0x37, 0x32, 0x64, 0x65, 0x62, 0x65, 0x61, 0x63, 0x33, 0x35, 0x33, 0x63, 0x37, 0x31, 0x62, 0x64, 0x63, 0x33, 0x36, 0x31, 0x36, 0x37, 0x32, 0x37, 0x37, 0x63, 0x30, 0x34, 0x38, 0x36, 0x34, 0x36, 0x65, 0x66, 0x35, 0x65, 0x62, 0x33, 0x31, 0x32, 0x64, 0x62, 0x39, 0x62, 0x32, 0x32, 0x64, 0x66, 0x63, 0x66, 0x35, 0x38, 0x64, 0x38, 0x62, 0x38, 0x34, 0x33, 0x61, 0x62, 0x65, 0x37, 0x37, 0x34, 0x37, 0x37, 0x31, 0x39, 0x39, 0x34, 0x35, 0x31, 0x63, 0x33, 0x37, 0x62, 0x31, 0x33, 0x32, 0x38, 0x62, 0x34, 0x65, 0x66, 0x61, 0x35, 0x66, 0x36, 0x66, 0x65, 0x65, 0x35, 0x36, 0x61, 0x31, 0x64, 0x31, 0x64, 0x66, 0x61, 0x30, 0x65, 0x39, 0x65, 0x36, 0x35, 0x35, 0x32, 0x35, 0x38, 0x63, 0x36, 0x61, 0x64, 0x37, 0x62, 0x66, 0x62, 0x30, 0x39, 0x39, 0x30, 0x36, 0x66, 0x34, 0x62, 0x66, 0x36, 0x62, 0x39, 0x63, 0x62, 0x35, 0x63, 0x38, 0x36, 0x65, 0x31, 0x32, 0x35, 0x31, 0x31, 0x35, 0x65, 0x39, 0x30, 0x33, 0x37, 0x30, 0x61, 0x35, 0x37, 0x63, 0x65, 0x30, 0x37, 0x32, 0x62, 0x34, 0x38, 0x35, 0x36, 0x35, 0x37, 0x65, 0x64, 0x35, 0x38, 0x37, 0x36, 0x30, 0x36, 0x66, 0x30, 0x66, 0x30, 0x30, 0x33, 0x65, 0x63, 0x36, 0x62, 0x62, 0x37, 0x37, 0x66, 0x31, 0x31, 0x38, 0x31, 0x36, 0x37, 0x64, 0x65, 0x64, 0x33, 0x34, 0x31, 0x61, 0x36, 0x34, 0x31, 0x62, 0x36, 0x31, 0x31, 0x35, 0x36, 0x31, 0x66, 0x34, 0x30, 0x61, 0x33, 0x34, 0x63, 0x64, 0x37, 0x31, 0x37, 0x32, 0x61, 0x66, 0x64, 0x62, 0x64, 0x62, 0x35, 0x32, 0x65, 0x65, 0x39, 0x31, 0x39, 0x64, 0x61, 0x33, 0x38, 0x30, 0x33, 0x38, 0x31, 0x39, 0x30, 0x36, 0x31, 0x32, 0x64, 0x35, 0x32, 0x62, 0x37, 0x39, 0x62, 0x65, 0x32, 0x37, 0x30, 0x30, 0x34, 0x66, 0x62, 0x64, 0x34, 0x32, 0x33, 0x34, 0x61, 0x66, 0x33, 0x36, 0x32, 0x63, 0x32, 0x65, 0x36, 0x33, 0x37, 0x32, 0x31, 0x31, 0x33, 0x66, 0x32, 0x33, 0x34, 0x66, 0x38, 0x31, 0x38, 0x31, 0x66, 0x63, 0x30, 0x65, 0x36, 0x64, 0x62, 0x30, 0x39, 0x33, 0x38, 0x32, 0x32, 0x65, 0x65, 0x64, 0x66, 0x31, 0x33, 0x62, 0x66, 0x32, 0x34, 0x66, 0x65, 0x35, 0x62, 0x39, 0x65, 0x34, 0x64, 0x34, 0x61, 0x34, 0x33, 0x61, 0x63, 0x36, 0x61, 0x35, 0x65, 0x63, 0x38, 0x66, 0x30, 0x33, 0x65, 0x61, 0x32, 0x31, 0x34, 0x38, 0x32, 0x61, 0x63, 0x62, 0x37, 0x32, 0x30, 0x65, 0x65, 0x30, 0x32, 0x38, 0x34, 0x30, 0x37, 0x31, 0x66, 0x39, 0x38, 0x62, 0x36, 0x34, 0x37, 0x66, 0x65, 0x36, 0x66, 0x31, 0x63, 0x32, 0x35, 0x35, 0x38, 0x32, 0x66, 0x30, 0x34, 0x37, 0x63, 0x37, 0x62, 0x34, 0x64, 0x61, 0x64, 0x35, 0x39, 0x30, 0x35, 0x31, 0x61, 0x61, 0x37, 0x63, 0x37, 0x63, 0x65, 0x66, 0x35, 0x65, 0x32, 0x66, 0x37, 0x65, 0x63, 0x62, 0x62, 0x64, 0x36, 0x39, 0x31, 0x62, 0x34, 0x34, 0x61, 0x32, 0x61, 0x38, 0x63, 0x62, 0x33, 0x36, 0x66, 0x63, 0x61, 0x62, 0x31, 0x64, 0x66, 0x39, 0x63, 0x39, 0x30, 0x34, 0x37, 0x61, 0x32, 0x38, 0x64, 0x32, 0x37, 0x37, 0x38, 0x34, 0x31, 0x66, 0x35, 0x63, 0x36, 0x34, 0x62, 0x34, 0x32, 0x37, 0x37, 0x37, 0x36, 0x34, 0x36, 0x38, 0x63, 0x30, 0x30, 0x32, 0x38, 0x38, 0x37, 0x37, 0x37, 0x31, 0x30, 0x34, 0x37, 0x32, 0x64, 0x65, 0x36, 0x64, 0x32, 0x35, 0x32, 0x30, 0x65, 0x30, 0x35, 0x33, 0x31, 0x62, 0x64, 0x32, 0x33, 0x39, 0x34, 0x62, 0x35, 0x61, 0x31, 0x32, 0x31, 0x39, 0x31, 0x31, 0x37, 0x34, 0x30, 0x61, 0x33, 0x63, 0x33, 0x32, 0x38, 0x33, 0x38, 0x39, 0x33, 0x62, 0x36, 0x31, 0x39, 0x65, 0x37, 0x64, 0x64, 0x34, 0x31, 0x63, 0x31, 0x39, 0x31, 0x64, 0x64, 0x30, 0x64, 0x38, 0x65, 0x64, 0x37, 0x32, 0x37, 0x61, 0x64, 0x36, 0x61, 0x34, 0x32, 0x34, 0x36, 0x37, 0x31, 0x37, 0x38, 0x31, 0x37, 0x66, 0x65, 0x36, 0x33, 0x33, 0x33, 0x34, 0x35, 0x36, 0x62, 0x65, 0x36, 0x63, 0x30, 0x66, 0x66, 0x30, 0x38, 0x35, 0x32, 0x63, 0x36, 0x32, 0x33, 0x62, 0x34, 0x33, 0x66, 0x32, 0x63, 0x64, 0x66, 0x62, 0x61, 0x36, 0x64, 0x33, 0x66, 0x64, 0x66, 0x66, 0x62, 0x61, 0x39, 0x31, 0x33, 0x38, 0x31, 0x63, 0x34, 0x38, 0x62, 0x34, 0x31, 0x37, 0x39, 0x37, 0x32, 0x35, 0x30, 0x37, 0x34, 0x33, 0x64, 0x62, 0x62, 0x39, 0x33, 0x66, 0x65, 0x62, 0x38, 0x62, 0x64, 0x31, 0x38, 0x62, 0x64, 0x64, 0x30, 0x62, 0x30, 0x31, 0x36, 0x63, 0x33, 0x34, 0x62, 0x62, 0x34, 0x39, 0x35, 0x33, 0x35, 0x36, 0x64, 0x61, 0x32, 0x66, 0x63, 0x31, 0x33, 0x36, 0x31, 0x30, 0x62, 0x66, 0x37, 0x66, 0x35, 0x61, 0x37, 0x32, 0x37, 0x30, 0x63, 0x33, 0x66, 0x66, 0x66, 0x33, 0x61, 0x64, 0x62, 0x33, 0x37, 0x33, 0x66, 0x39, 0x36, 0x33, 0x31, 0x31, 0x39, 0x62, 0x33, 0x62, 0x30, 0x31, 0x64, 0x65, 0x62, 0x30, 0x38, 0x66, 0x35, 0x32, 0x62, 0x66, 0x30, 0x63, 0x36, 0x66, 0x36, 0x36, 0x64, 0x38, 0x31, 0x38, 0x66, 0x35, 0x32, 0x66, 0x36, 0x66, 0x66, 0x32, 0x62, 0x61, 0x63, 0x32, 0x37, 0x62, 0x62, 0x30, 0x32, 0x36, 0x65, 0x38, 0x34, 0x66, 0x33, 0x38, 0x61, 0x34, 0x34, 0x31, 0x37, 0x33, 0x64, 0x64, 0x34, 0x38, 0x36, 0x66, 0x34, 0x31, 0x65, 0x66, 0x31, 0x32, 0x34, 0x33, 0x38, 0x34, 0x63, 0x36, 0x35, 0x64, 0x65, 0x32, 0x35, 0x65, 0x30, 0x63, 0x31, 0x35, 0x32, 0x32, 0x33, 0x62, 0x34, 0x33, 0x65, 0x65, 0x31, 0x34, 0x64, 0x34, 0x62, 0x34, 0x63, 0x61, 0x62, 0x62, 0x61, 0x39, 0x36, 0x34, 0x37, 0x32, 0x33, 0x39, 0x64, 0x35, 0x38, 0x34, 0x38, 0x36, 0x32, 0x33, 0x65, 0x36, 0x61, 0x36, 0x65, 0x38, 0x31, 0x62, 0x32, 0x31, 0x30, 0x39, 0x39, 0x32, 0x38, 0x32, 0x38, 0x31, 0x33, 0x63, 0x63, 0x35, 0x63, 0x30, 0x35, 0x37, 0x65, 0x37, 0x33, 0x66, 0x31, 0x64, 0x39, 0x38, 0x39, 0x38, 0x37, 0x33, 0x65, 0x39, 0x38, 0x32, 0x64, 0x61, 0x66, 0x37, 0x34, 0x35, 0x34, 0x65, 0x36, 0x37, 0x37, 0x32, 0x37, 0x30, 0x34, 0x34, 0x63, 0x32, 0x38, 0x37, 0x37, 0x32, 0x35, 0x38, 0x32, 0x34, 0x38, 0x61, 0x38, 0x31, 0x62, 0x38, 0x61, 0x62, 0x64, 0x34, 0x31, 0x30, 0x31, 0x39, 0x64, 0x30, 0x30, 0x39, 0x32, 0x63, 0x37, 0x39, 0x33, 0x63, 0x31, 0x31, 0x65, 0x33, 0x66, 0x39, 0x65, 0x62, 0x33, 0x36, 0x64, 0x64, 0x63, 0x63, 0x35, 0x61, 0x64, 0x39, 0x31, 0x63, 0x35, 0x32, 0x32, 0x66, 0x36, 0x64, 0x31, 0x33, 0x36, 0x35, 0x66, 0x35, 0x61, 0x63, 0x39, 0x31, 0x34, 0x64, 0x31, 0x65, 0x36, 0x63, 0x63, 0x33, 0x31, 0x64, 0x63, 0x37, 0x64, 0x31, 0x38, 0x64, 0x32, 0x36, 0x66, 0x64, 0x30, 0x66, 0x38, 0x31, 0x31, 0x33, 0x63, 0x65, 0x61, 0x66, 0x31, 0x63, 0x38, 0x65, 0x37, 0x35, 0x66, 0x31, 0x35, 0x32, 0x35, 0x66, 0x33, 0x66, 0x66, 0x61, 0x65, 0x35, 0x63, 0x32, 0x36, 0x31, 0x32, 0x66, 0x63, 0x33, 0x64, 0x30, 0x62, 0x36, 0x61, 0x62, 0x31, 0x30, 0x36, 0x63, 0x36, 0x61, 0x38, 0x37, 0x65, 0x31, 0x30, 0x32, 0x36, 0x30, 0x61, 0x65, 0x35, 0x39, 0x66, 0x37, 0x39, 0x36, 0x38, 0x38, 0x65, 0x64, 0x33, 0x39, 0x37, 0x31, 0x64, 0x62, 0x33, 0x35, 0x39, 0x31, 0x36, 0x36, 0x66, 0x30, 0x65, 0x64, 0x61, 0x35, 0x31, 0x35, 0x39, 0x36, 0x64, 0x34, 0x64, 0x66, 0x63, 0x37, 0x35, 0x39, 0x31, 0x34, 0x32, 0x31, 0x64, 0x63, 0x61, 0x33, 0x65, 0x37, 0x66, 0x65, 0x34, 0x35, 0x32, 0x34, 0x62, 0x64, 0x35, 0x31, 0x64, 0x61, 0x32, 0x30, 0x34, 0x66, 0x30, 0x61, 0x62, 0x66, 0x35, 0x61, 0x33, 0x61, 0x33, 0x39, 0x36, 0x66, 0x65, 0x34, 0x31, 0x63, 0x62, 0x36, 0x34, 0x30, 0x30, 0x30, 0x35, 0x37, 0x65, 0x63, 0x31, 0x61, 0x63, 0x38, 0x61, 0x31, 0x61, 0x30, 0x32, 0x61, 0x35, 0x36, 0x32, 0x30, 0x35, 0x65, 0x65, 0x37, 0x33, 0x61, 0x63, 0x62, 0x39, 0x32, 0x36, 0x66, 0x34, 0x65, 0x30, 0x62, 0x30, 0x38, 0x36, 0x34, 0x64, 0x33, 0x36, 0x64, 0x63, 0x62, 0x38, 0x62, 0x38, 0x35, 0x39, 0x31, 0x30, 0x34, 0x63, 0x36, 0x65, 0x35, 0x32, 0x35, 0x35, 0x31, 0x62, 0x32, 0x39, 0x35, 0x37, 0x63, 0x31, 0x33, 0x36, 0x37, 0x61, 0x61, 0x63, 0x63, 0x62, 0x65, 0x34, 0x39, 0x31, 0x66, 0x39, 0x65, 0x62, 0x31, 0x38, 0x36, 0x61, 0x35, 0x65, 0x34, 0x32, 0x62, 0x66, 0x38, 0x61, 0x64, 0x65, 0x63, 0x33, 0x66, 0x66, 0x30, 0x34, 0x65, 0x65, 0x65, 0x34, 0x37, 0x37, 0x65, 0x34, 0x33, 0x66, 0x31, 0x66, 0x37, 0x62, 0x62, 0x39, 0x65, 0x64, 0x36, 0x63, 0x34, 0x38, 0x30, 0x35, 0x33, 0x63, 0x32, 0x36, 0x66, 0x62, 0x34, 0x39, 0x35, 0x38, 0x64, 0x38, 0x35, 0x38, 0x31, 0x37, 0x32, 0x35, 0x62, 0x36, 0x63, 0x65, 0x65, 0x62, 0x33, 0x65, 0x32, 0x65, 0x34, 0x63, 0x62, 0x35, 0x36, 0x34, 0x34, 0x63, 0x31, 0x30, 0x63, 0x32, 0x38, 0x35, 0x34, 0x39, 0x65, 0x66, 0x61, 0x62, 0x62, 0x30, 0x34, 0x35, 0x35, 0x65, 0x38, 0x62, 0x32, 0x30, 0x37, 0x63, 0x35, 0x35, 0x34, 0x37, 0x61, 0x39, 0x61, 0x34, 0x63, 0x32, 0x31, 0x33, 0x62, 0x30, 0x36, 0x31, 0x66, 0x64, 0x39, 0x37, 0x32, 0x37, 0x61, 0x32, 0x36, 0x38, 0x34, 0x66, 0x64, 0x30, 0x62, 0x65, 0x66, 0x39, 0x33, 0x37, 0x64, 0x38, 0x30, 0x36, 0x34, 0x64, 0x66, 0x35, 0x63, 0x36, 0x31, 0x36, 0x62, 0x30, 0x64, 0x32, 0x39, 0x36, 0x30, 0x30, 0x66, 0x33, 0x32, 0x37, 0x39, 0x66, 0x66, 0x62, 0x32, 0x31, 0x65, 0x32, 0x36, 0x32, 0x66, 0x38, 0x36, 0x34, 0x38, 0x32, 0x34, 0x63, 0x38, 0x34, 0x65, 0x66, 0x39, 0x30, 0x36, 0x61, 0x32, 0x64, 0x62, 0x64, 0x62, 0x30, 0x32, 0x37, 0x39, 0x31, 0x33, 0x66, 0x61, 0x37, 0x33, 0x39, 0x65, 0x32, 0x35, 0x30, 0x61, 0x39, 0x30, 0x37, 0x31, 0x32, 0x34, 0x33, 0x33, 0x33, 0x30, 0x66, 0x36, 0x39, 0x61, 0x61, 0x32, 0x64, 0x32, 0x30, 0x65, 0x37, 0x31, 0x38, 0x39, 0x39, 0x64, 0x35, 0x39, 0x66, 0x64, 0x37, 0x66, 0x38, 0x32, 0x34, 0x30, 0x62, 0x35, 0x64, 0x61, 0x37, 0x32, 0x63, 0x62, 0x30, 0x30, 0x32, 0x30, 0x31, 0x35, 0x63, 0x66, 0x63, 0x37, 0x36, 0x65, 0x36, 0x62, 0x64, 0x33, 0x32, 0x36, 0x65, 0x38, 0x33, 0x39, 0x39, 0x66, 0x31, 0x38, 0x35, 0x63, 0x36, 0x33, 0x39, 0x32, 0x63, 0x37, 0x31, 0x37, 0x65, 0x32, 0x36, 0x38, 0x36, 0x34, 0x64, 0x66, 0x35, 0x37, 0x66, 0x35, 0x66, 0x30, 0x62, 0x35, 0x39, 0x30, 0x64, 0x66, 0x31, 0x37, 0x32, 0x36, 0x37, 0x32, 0x62, 0x38, 0x33, 0x38, 0x34, 0x62, 0x37, 0x66, 0x36, 0x63, 0x32, 0x66, 0x31, 0x36, 0x39, 0x35, 0x65, 0x31, 0x30, 0x64, 0x31, 0x63, 0x66, 0x66, 0x30, 0x61, 0x61, 0x61, 0x63, 0x30, 0x32, 0x65, 0x63, 0x37, 0x37, 0x66, 0x37, 0x62, 0x66, 0x30, 0x66, 0x33, 0x30, 0x65, 0x38, 0x30, 0x37, 0x65, 0x36, 0x30, 0x37, 0x34, 0x62, 0x39, 0x31, 0x39, 0x32, 0x65, 0x32, 0x66, 0x66, 0x65, 0x37, 0x32, 0x34, 0x63, 0x34, 0x38, 0x64, 0x61, 0x64, 0x33, 0x36, 0x64, 0x63, 0x62, 0x33, 0x34, 0x32, 0x32, 0x32, 0x32, 0x61, 0x64, 0x34, 0x31, 0x34, 0x30, 0x62, 0x62, 0x34, 0x65, 0x36, 0x36, 0x34, 0x30, 0x62, 0x36, 0x39, 0x35, 0x31, 0x33, 0x62, 0x30, 0x31, 0x37, 0x37, 0x31, 0x31, 0x65, 0x66, 0x61, 0x31, 0x32, 0x32, 0x38, 0x35, 0x66, 0x34, 0x61, 0x65, 0x39, 0x35, 0x35, 0x61, 0x31, 0x33, 0x65, 0x39, 0x39, 0x63, 0x36, 0x30, 0x35, 0x35, 0x62, 0x30, 0x65, 0x62, 0x34, 0x34, 0x34, 0x63, 0x37, 0x64, 0x62, 0x36, 0x32, 0x66, 0x61, 0x38, 0x61, 0x35, 0x36, 0x30, 0x39, 0x37, 0x30, 0x31, 0x38, 0x61, 0x66, 0x30, 0x38, 0x66, 0x61, 0x61, 0x31, 0x35, 0x38, 0x31, 0x62, 0x39, 0x64, 0x63, 0x32, 0x31, 0x32, 0x34, 0x33, 0x37, 0x62, 0x38, 0x39, 0x34, 0x63, 0x35, 0x36, 0x62, 0x38, 0x30, 0x38, 0x36, 0x30, 0x63, 0x61, 0x39, 0x36, 0x37, 0x65, 0x61, 0x34, 0x62, 0x64, 0x63, 0x33, 0x30, 0x61, 0x35, 0x38, 0x62, 0x34, 0x37, 0x65, 0x65, 0x35, 0x30, 0x36, 0x38, 0x37, 0x39, 0x36, 0x37, 0x61, 0x32, 0x61, 0x33, 0x63, 0x34, 0x66, 0x31, 0x62, 0x30, 0x31, 0x32, 0x64, 0x38, 0x39, 0x36, 0x66, 0x63, 0x33, 0x37, 0x36, 0x61, 0x33, 0x30, 0x36, 0x32, 0x34, 0x37, 0x62, 0x61, 0x36, 0x37, 0x32, 0x32, 0x64, 0x30, 0x31, 0x62, 0x63, 0x61, 0x39, 0x63, 0x32, 0x39, 0x30, 0x39, 0x35, 0x62, 0x36, 0x63, 0x37, 0x64, 0x36, 0x38, 0x64, 0x39, 0x65, 0x30, 0x62, 0x33, 0x63, 0x62, 0x33, 0x37, 0x38, 0x31, 0x34, 0x32, 0x62, 0x30, 0x39, 0x33, 0x38, 0x39, 0x36, 0x30, 0x61, 0x37, 0x65, 0x62, 0x32, 0x38, 0x66, 0x64, 0x37, 0x39, 0x65, 0x63, 0x31, 0x62, 0x32, 0x39, 0x61, 0x32, 0x38, 0x37, 0x32, 0x66, 0x63, 0x32, 0x62, 0x32, 0x33, 0x36, 0x38, 0x31, 0x36, 0x63, 0x36, 0x39, 0x61, 0x66, 0x65, 0x63, 0x34, 0x66, 0x66, 0x32, 0x32, 0x62, 0x38, 0x62, 0x38, 0x64, 0x32, 0x64, 0x39, 0x36, 0x39, 0x66, 0x30, 0x62, 0x38, 0x32, 0x62, 0x30, 0x61, 0x66, 0x32, 0x64, 0x35, 0x39, 0x39, 0x63, 0x65, 0x30, 0x65, 0x39, 0x32, 0x61, 0x37, 0x33, 0x62, 0x61, 0x65, 0x65, 0x63, 0x65, 0x35, 0x37, 0x32, 0x38, 0x32, 0x38, 0x66, 0x62, 0x32, 0x35, 0x37, 0x65, 0x35, 0x38, 0x61, 0x63, 0x32, 0x36, 0x34, 0x39, 0x62, 0x30, 0x35, 0x31, 0x65, 0x36, 0x65, 0x35, 0x33, 0x39, 0x64, 0x65, 0x33, 0x36, 0x37, 0x36, 0x66, 0x35, 0x37, 0x34, 0x35, 0x61, 0x37, 0x63, 0x38, 0x37, 0x61, 0x32, 0x38, 0x61, 0x33, 0x30, 0x37, 0x64, 0x65, 0x63, 0x32, 0x34, 0x33, 0x31, 0x37, 0x39, 0x63, 0x39, 0x35, 0x36, 0x35, 0x30, 0x37, 0x64, 0x32, 0x37, 0x34, 0x61, 0x62, 0x39, 0x31, 0x61, 0x61, 0x62, 0x31, 0x38, 0x33, 0x33, 0x31, 0x31, 0x38, 0x65, 0x32, 0x62, 0x34, 0x31, 0x39, 0x33, 0x35, 0x38, 0x33, 0x32, 0x39, 0x63, 0x32, 0x66, 0x61, 0x37, 0x62, 0x63, 0x66, 0x37, 0x36, 0x36, 0x61, 0x38, 0x34, 0x34, 0x38, 0x66, 0x65, 0x66, 0x31, 0x35, 0x32, 0x36, 0x39, 0x62, 0x31, 0x31, 0x37, 0x35, 0x30, 0x37, 0x32, 0x62, 0x30, 0x38, 0x32, 0x35, 0x33, 0x38, 0x37, 0x37, 0x65, 0x38, 0x64, 0x33, 0x62, 0x65, 0x35, 0x38, 0x66, 0x37, 0x39, 0x39, 0x31, 0x33, 0x39, 0x39, 0x37, 0x64, 0x30, 0x37, 0x65, 0x35, 0x64, 0x38, 0x38, 0x65, 0x65, 0x64, 0x37, 0x34, 0x35, 0x35, 0x65, 0x61, 0x33, 0x31, 0x32, 0x37, 0x30, 0x36, 0x64, 0x30, 0x32, 0x35, 0x39, 0x65, 0x63, 0x34, 0x33, 0x66, 0x62, 0x35, 0x33, 0x37, 0x32, 0x64, 0x31, 0x35, 0x36, 0x39, 0x38, 0x64, 0x65, 0x66, 0x37, 0x31, 0x65, 0x65, 0x63, 0x38, 0x66, 0x38, 0x62, 0x32, 0x31, 0x31, 0x34, 0x62, 0x39, 0x36, 0x37, 0x61, 0x30, 0x63, 0x33, 0x35, 0x33, 0x32, 0x31, 0x61, 0x32, 0x30, 0x34, 0x64, 0x65, 0x65, 0x35, 0x63, 0x66, 0x30, 0x64, 0x66, 0x64, 0x61, 0x63, 0x38, 0x63, 0x38, 0x66, 0x61, 0x32, 0x30, 0x32, 0x32, 0x39, 0x38, 0x65, 0x33, 0x61, 0x64, 0x33, 0x37, 0x62, 0x66, 0x64, 0x62, 0x31, 0x63, 0x32, 0x34, 0x65, 0x38, 0x64, 0x30, 0x32, 0x38, 0x32, 0x63, 0x32, 0x38, 0x32, 0x65, 0x34, 0x37, 0x33, 0x38, 0x61, 0x33, 0x61, 0x33, 0x37, 0x65, 0x31, 0x61, 0x38, 0x35, 0x32, 0x32, 0x31, 0x64, 0x36, 0x34, 0x66, 0x31, 0x62, 0x39, 0x63, 0x38, 0x63, 0x35, 0x37, 0x66, 0x64, 0x30, 0x30, 0x36, 0x37, 0x33, 0x35, 0x37, 0x65, 0x37, 0x32, 0x63, 0x65, 0x30, 0x31, 0x37, 0x39, 0x32, 0x39, 0x64, 0x36, 0x63, 0x30, 0x63, 0x38, 0x64, 0x31, 0x36, 0x63, 0x65, 0x36, 0x64, 0x63, 0x64, 0x33, 0x65, 0x66, 0x38, 0x66, 0x61, 0x31, 0x30, 0x38, 0x32, 0x32, 0x61, 0x32, 0x33, 0x33, 0x30, 0x61, 0x33, 0x32, 0x35, 0x36, 0x61, 0x38, 0x31, 0x36, 0x66, 0x39, 0x37, 0x30, 0x61, 0x65, 0x34, 0x62, 0x63, 0x65, 0x34, 0x36, 0x61, 0x65, 0x37, 0x32, 0x65, 0x35, 0x32, 0x33, 0x31, 0x64, 0x37, 0x30, 0x33, 0x36, 0x39, 0x64, 0x63, 0x36, 0x36, 0x33, 0x32, 0x66, 0x37, 0x31, 0x37, 0x35, 0x36, 0x33, 0x33, 0x32, 0x37, 0x61, 0x33, 0x36, 0x65, 0x31, 0x61, 0x39, 0x38, 0x63, 0x35, 0x38, 0x33, 0x35, 0x31, 0x62, 0x37, 0x34, 0x65, 0x36, 0x33, 0x33, 0x63, 0x39, 0x65, 0x31, 0x30, 0x66, 0x33, 0x32, 0x37, 0x39, 0x30, 0x64, 0x31, 0x37, 0x37, 0x32, 0x65, 0x33, 0x66, 0x66, 0x35, 0x38, 0x65, 0x31, 0x34, 0x31, 0x34, 0x65, 0x65, 0x34, 0x35, 0x62, 0x35, 0x66, 0x36, 0x61, 0x38, 0x37, 0x61, 0x35, 0x39, 0x35, 0x34, 0x34, 0x65, 0x38, 0x36, 0x37, 0x66, 0x36, 0x34, 0x64, 0x62, 0x66, 0x30, 0x34, 0x39, 0x31, 0x65, 0x38, 0x61, 0x33, 0x36, 0x63, 0x30, 0x37, 0x31, 0x64, 0x36, 0x61, 0x61, 0x32, 0x35, 0x39, 0x32, 0x32, 0x64, 0x34, 0x37, 0x32, 0x36, 0x31, 0x37, 0x31, 0x35, 0x37, 0x65, 0x31, 0x61, 0x33, 0x38, 0x37, 0x31, 0x64, 0x37, 0x63, 0x39, 0x35, 0x62, 0x32, 0x65, 0x38, 0x64, 0x31, 0x30, 0x38, 0x38, 0x34, 0x30, 0x30, 0x39, 0x66, 0x39, 0x65, 0x37, 0x30, 0x37, 0x62, 0x31, 0x38, 0x64, 0x61, 0x65, 0x65, 0x65, 0x32, 0x66, 0x33, 0x62, 0x63, 0x61, 0x36, 0x66, 0x33, 0x36, 0x66, 0x32, 0x36, 0x34, 0x35, 0x35, 0x64, 0x37, 0x32, 0x65, 0x66, 0x34, 0x34, 0x62, 0x62, 0x37, 0x36, 0x39, 0x39, 0x63, 0x30, 0x30, 0x66, 0x38, 0x37, 0x39, 0x37, 0x62, 0x64, 0x30, 0x35, 0x33, 0x36, 0x63, 0x63, 0x39, 0x32, 0x34, 0x64, 0x61, 0x63, 0x36, 0x65, 0x65, 0x66, 0x38, 0x38, 0x38, 0x63, 0x37, 0x36, 0x61, 0x64, 0x36, 0x37, 0x32, 0x61, 0x37, 0x31, 0x66, 0x33, 0x33, 0x64, 0x66, 0x36, 0x62, 0x33, 0x63, 0x63, 0x31, 0x66, 0x37, 0x32, 0x31, 0x38, 0x38, 0x63, 0x35, 0x63, 0x36, 0x37, 0x34, 0x31, 0x64, 0x35, 0x38, 0x36, 0x32, 0x39, 0x34, 0x33, 0x32, 0x62, 0x38, 0x35, 0x61, 0x38, 0x64, 0x63, 0x30, 0x38, 0x39, 0x36, 0x62, 0x66, 0x63, 0x61, 0x31, 0x64, 0x32, 0x31, 0x32, 0x32, 0x33, 0x33, 0x32, 0x63, 0x34, 0x33, 0x35, 0x35, 0x62, 0x61, 0x30, 0x37, 0x32, 0x37, 0x39, 0x61, 0x32, 0x30, 0x38, 0x31, 0x36, 0x34, 0x37, 0x32, 0x38, 0x64, 0x38, 0x62, 0x63, 0x31, 0x39, 0x35, 0x31, 0x34, 0x34, 0x66, 0x61, 0x34, 0x38, 0x63, 0x35, 0x66, 0x39, 0x33, 0x37, 0x31, 0x36, 0x61, 0x63, 0x62, 0x62, 0x34, 0x65, 0x38, 0x39, 0x61, 0x31, 0x61, 0x32, 0x38, 0x64, 0x65, 0x62, 0x30, 0x66, 0x39, 0x39, 0x66, 0x61, 0x32, 0x32, 0x39, 0x35, 0x32, 0x30, 0x66, 0x31, 0x36, 0x32, 0x36, 0x30, 0x38, 0x32, 0x65, 0x36, 0x34, 0x31, 0x64, 0x31, 0x65, 0x34, 0x61, 0x31, 0x32, 0x63, 0x30, 0x66, 0x36, 0x61, 0x38, 0x66, 0x35, 0x63, 0x32, 0x64, 0x66, 0x33, 0x30, 0x35, 0x39, 0x65, 0x36, 0x36, 0x36, 0x33, 0x38, 0x31, 0x63, 0x65, 0x30, 0x35, 0x62, 0x61, 0x37, 0x31, 0x31, 0x66, 0x62, 0x64, 0x66, 0x36, 0x65, 0x64, 0x62, 0x61, 0x31, 0x66, 0x32, 0x35, 0x65, 0x37, 0x64, 0x35, 0x63, 0x64, 0x36, 0x62, 0x30, 0x35, 0x33, 0x37, 0x32, 0x35, 0x33, 0x30, 0x39, 0x35, 0x37, 0x38, 0x36, 0x38, 0x63, 0x37, 0x37, 0x39, 0x34, 0x39, 0x65, 0x38, 0x31, 0x38, 0x62, 0x34, 0x35, 0x32, 0x63, 0x38, 0x65, 0x35, 0x64, 0x37, 0x37, 0x64, 0x66, 0x32, 0x63, 0x37, 0x63, 0x66, 0x38, 0x32, 0x66, 0x39, 0x30, 0x66, 0x32, 0x33, 0x31, 0x32, 0x38, 0x62, 0x64, 0x34, 0x37, 0x33, 0x66, 0x32, 0x64, 0x63, 0x37, 0x65, 0x32, 0x64, 0x30, 0x37, 0x32, 0x66, 0x66, 0x30, 0x34, 0x30, 0x39, 0x65, 0x32, 0x35, 0x35, 0x30, 0x62, 0x33, 0x61, 0x36, 0x39, 0x30, 0x35, 0x38, 0x32, 0x33, 0x65, 0x31, 0x62, 0x63, 0x63, 0x36, 0x66, 0x61, 0x39, 0x30, 0x63, 0x65, 0x63, 0x39, 0x64, 0x61, 0x34, 0x35, 0x66, 0x32, 0x39, 0x30, 0x36, 0x34, 0x33, 0x39, 0x32, 0x61, 0x38, 0x34, 0x64, 0x39, 0x62, 0x38, 0x36, 0x64, 0x62, 0x66, 0x39, 0x63, 0x39, 0x34, 0x63, 0x61, 0x65, 0x63, 0x32, 0x61, 0x36, 0x39, 0x33, 0x65, 0x31, 0x66, 0x66, 0x31, 0x35, 0x65, 0x33, 0x62, 0x37, 0x66, 0x36, 0x38, 0x38, 0x63, 0x65, 0x34, 0x37, 0x30, 0x66, 0x35, 0x63, 0x35, 0x33, 0x62, 0x30, 0x32, 0x62, 0x34, 0x36, 0x30, 0x30, 0x35, 0x39, 0x62, 0x35, 0x31, 0x39, 0x32, 0x64, 0x34, 0x63, 0x39, 0x39, 0x65, 0x65, 0x31, 0x66, 0x65, 0x61, 0x62, 0x64, 0x33, 0x61, 0x34, 0x31, 0x32, 0x39, 0x39, 0x33, 0x30, 0x64, 0x65, 0x32, 0x61, 0x61, 0x39, 0x37, 0x38, 0x35, 0x39, 0x39, 0x31, 0x39, 0x66, 0x37, 0x36, 0x35, 0x34, 0x32, 0x65, 0x31, 0x34, 0x65, 0x31, 0x66, 0x36, 0x39, 0x63, 0x31, 0x61, 0x38, 0x35, 0x31, 0x64, 0x33, 0x34, 0x32, 0x32, 0x65, 0x61, 0x35, 0x65, 0x66, 0x65, 0x63, 0x37, 0x31, 0x38, 0x31, 0x64, 0x65, 0x36, 0x31, 0x35, 0x31, 0x31, 0x63, 0x37, 0x32, 0x30, 0x31, 0x64, 0x39, 0x35, 0x37, 0x62, 0x30, 0x31, 0x65, 0x63, 0x32, 0x38, 0x36, 0x66, 0x35, 0x62, 0x31, 0x37, 0x34, 0x36, 0x65, 0x30, 0x34, 0x66, 0x63, 0x66, 0x66, 0x31, 0x39, 0x64, 0x34, 0x39, 0x39, 0x36, 0x64, 0x30, 0x35, 0x34, 0x61, 0x66, 0x34, 0x39, 0x62, 0x34, 0x64, 0x36, 0x64, 0x33, 0x37, 0x32, 0x38, 0x38, 0x62, 0x65, 0x62, 0x37, 0x61, 0x65, 0x64, 0x31, 0x39, 0x35, 0x36, 0x37, 0x35, 0x39, 0x34, 0x63, 0x31, 0x38, 0x31, 0x66, 0x31, 0x64, 0x39, 0x34, 0x62, 0x38, 0x61, 0x62, 0x34, 0x30, 0x65, 0x33, 0x32, 0x63, 0x30, 0x39, 0x32, 0x30, 0x65, 0x34, 0x61, 0x35, 0x32, 0x30, 0x64, 0x35, 0x32, 0x32, 0x63, 0x61, 0x31, 0x33, 0x31, 0x31, 0x61, 0x64, 0x62, 0x61, 0x33, 0x31, 0x39, 0x63, 0x30, 0x36, 0x33, 0x32, 0x66, 0x31, 0x32, 0x65, 0x63, 0x37, 0x32, 0x31, 0x38, 0x35, 0x32, 0x34, 0x65, 0x39, 0x64, 0x38, 0x64, 0x62, 0x35, 0x33, 0x36, 0x33, 0x37, 0x36, 0x62, 0x32, 0x38, 0x63, 0x64, 0x33, 0x30, 0x39, 0x61, 0x61, 0x34, 0x61, 0x33, 0x33, 0x37, 0x37, 0x63, 0x65, 0x61, 0x62, 0x33, 0x39, 0x31, 0x33, 0x33, 0x30, 0x30, 0x34, 0x30, 0x61, 0x63, 0x36, 0x64, 0x30, 0x34, 0x36, 0x32, 0x37, 0x34, 0x36, 0x63, 0x33, 0x38, 0x33, 0x35, 0x38, 0x66, 0x36, 0x63, 0x66, 0x30, 0x36, 0x61, 0x30, 0x35, 0x30, 0x65, 0x36, 0x33, 0x63, 0x38, 0x39, 0x35, 0x32, 0x39, 0x37, 0x34, 0x64, 0x34, 0x63, 0x65, 0x66, 0x36, 0x30, 0x38, 0x63, 0x39, 0x35, 0x36, 0x63, 0x39, 0x30, 0x63, 0x35, 0x37, 0x35, 0x39, 0x35, 0x62, 0x30, 0x33, 0x65, 0x64, 0x38, 0x32, 0x31, 0x38, 0x62, 0x34, 0x36, 0x63, 0x32, 0x35, 0x30, 0x34, 0x31, 0x35, 0x37, 0x34, 0x66, 0x63, 0x35, 0x66, 0x34, 0x30, 0x66, 0x30, 0x61, 0x36, 0x64, 0x63, 0x33, 0x30, 0x37, 0x33, 0x32, 0x30, 0x36, 0x66, 0x36, 0x30, 0x33, 0x61, 0x61, 0x66, 0x38, 0x38, 0x32, 0x63, 0x64, 0x33, 0x31, 0x33, 0x63, 0x64, 0x30, 0x39, 0x61, 0x32, 0x35, 0x61, 0x66, 0x34, 0x35, 0x66, 0x64, 0x65, 0x39, 0x30, 0x63, 0x35, 0x65, 0x35, 0x62, 0x36, 0x39, 0x39, 0x30, 0x65, 0x66, 0x31, 0x37, 0x34, 0x37, 0x32, 0x37, 0x32, 0x32, 0x39, 0x34, 0x32, 0x63, 0x62, 0x61, 0x35, 0x33, 0x62, 0x30, 0x61, 0x66, 0x30, 0x34, 0x31, 0x65, 0x37, 0x65, 0x35, 0x34, 0x35, 0x30, 0x35, 0x36, 0x37, 0x37, 0x31, 0x61, 0x63, 0x65, 0x31, 0x32, 0x31, 0x39, 0x62, 0x30, 0x34, 0x61, 0x36, 0x64, 0x34, 0x39, 0x62, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x39, 0x36, 0x36, 0x34, 0x35, 0x63, 0x64, 0x36, 0x35, 0x65, 0x62, 0x38, 0x37, 0x32, 0x32, 0x32, 0x64, 0x64, 0x37, 0x30, 0x61, 0x37, 0x30, 0x38, 0x31, 0x30, 0x65, 0x62, 0x32, 0x35, 0x63, 0x30, 0x62, 0x38, 0x66, 0x65, 0x33, 0x64, 0x31, 0x61, 0x33, 0x34, 0x36, 0x65, 0x32, 0x37, 0x38, 0x35, 0x63, 0x65, 0x32, 0x61, 0x31, 0x63, 0x33, 0x38, 0x66, 0x31, 0x38, 0x34, 0x37, 0x64, 0x34, 0x32, 0x61, 0x64, 0x33, 0x63, 0x39, 0x65, 0x30, 0x64, 0x38, 0x65, 0x38, 0x36, 0x37, 0x32, 0x32, 0x31, 0x30, 0x39, 0x39, 0x38, 0x61, 0x64, 0x31, 0x62, 0x35, 0x38, 0x36, 0x37, 0x66, 0x63, 0x31, 0x39, 0x36, 0x32, 0x30, 0x63, 0x39, 0x31, 0x61, 0x38, 0x36, 0x30, 0x62, 0x63, 0x32, 0x30, 0x34, 0x36, 0x61, 0x37, 0x33, 0x61, 0x37, 0x36, 0x36, 0x63, 0x30, 0x61, 0x64, 0x35, 0x63, 0x61, 0x32, 0x35, 0x38, 0x36, 0x63, 0x32, 0x39, 0x35, 0x39, 0x64, 0x30, 0x64, 0x36, 0x36, 0x33, 0x37, 0x38, 0x61, 0x35, 0x36, 0x31, 0x64, 0x63, 0x39, 0x66, 0x35, 0x65, 0x37, 0x61, 0x64, 0x33, 0x37, 0x30, 0x33, 0x35, 0x65, 0x34, 0x30, 0x31, 0x35, 0x37, 0x33, 0x30, 0x32, 0x64, 0x61, 0x30, 0x34, 0x63, 0x64, 0x35, 0x36, 0x61, 0x30, 0x66, 0x37, 0x33, 0x37, 0x33, 0x65, 0x64, 0x66, 0x65, 0x35, 0x39, 0x30, 0x61, 0x33, 0x34, 0x33, 0x31, 0x37, 0x63, 0x32, 0x62, 0x35, 0x66, 0x66, 0x36, 0x61, 0x63, 0x30, 0x38, 0x38, 0x65, 0x37, 0x30, 0x32, 0x63, 0x64, 0x39, 0x35, 0x61, 0x65, 0x63, 0x32, 0x36, 0x36, 0x64, 0x61, 0x34, 0x35, 0x39, 0x64, 0x31, 0x63, 0x31, 0x38, 0x38, 0x66, 0x34, 0x37, 0x31, 0x36, 0x38, 0x35, 0x39, 0x65, 0x62, 0x37, 0x65, 0x61, 0x30, 0x30, 0x33, 0x62, 0x35, 0x34, 0x33, 0x33, 0x61, 0x37, 0x31, 0x66, 0x65, 0x61, 0x31, 0x31, 0x38, 0x33, 0x31, 0x65, 0x37, 0x32, 0x32, 0x65, 0x38, 0x33, 0x65, 0x33, 0x35, 0x31, 0x61, 0x31, 0x37, 0x39, 0x31, 0x62, 0x61, 0x39, 0x37, 0x63, 0x63, 0x32, 0x65, 0x62, 0x66, 0x31, 0x36, 0x35, 0x33, 0x30, 0x30, 0x61, 0x39, 0x36, 0x33, 0x32, 0x61, 0x61, 0x66, 0x62, 0x33, 0x35, 0x35, 0x33, 0x38, 0x39, 0x63, 0x39, 0x63, 0x30, 0x31, 0x31, 0x64, 0x30, 0x31, 0x62, 0x38, 0x31, 0x66, 0x37, 0x63, 0x31, 0x36, 0x61, 0x37, 0x32, 0x34, 0x37, 0x36, 0x34, 0x39, 0x37, 0x66, 0x32, 0x62, 0x30, 0x39, 0x34, 0x66, 0x34, 0x38, 0x31, 0x66, 0x35, 0x66, 0x36, 0x66, 0x33, 0x39, 0x33, 0x64, 0x36, 0x31, 0x62, 0x39, 0x39, 0x64, 0x36, 0x30, 0x64, 0x33, 0x63, 0x64, 0x36, 0x64, 0x30, 0x63, 0x66, 0x34, 0x62, 0x32, 0x34, 0x64, 0x66, 0x34, 0x64, 0x37, 0x31, 0x35, 0x37, 0x37, 0x37, 0x39, 0x62, 0x61, 0x35, 0x62, 0x61, 0x37, 0x32, 0x34, 0x36, 0x38, 0x39, 0x35, 0x35, 0x66, 0x36, 0x65, 0x37, 0x36, 0x64, 0x31, 0x35, 0x64, 0x34, 0x32, 0x39, 0x64, 0x31, 0x37, 0x36, 0x64, 0x63, 0x38, 0x62, 0x65, 0x34, 0x33, 0x31, 0x66, 0x33, 0x37, 0x31, 0x62, 0x66, 0x62, 0x39, 0x39, 0x34, 0x34, 0x66, 0x39, 0x33, 0x31, 0x31, 0x64, 0x64, 0x65, 0x35, 0x35, 0x61, 0x33, 0x64, 0x32, 0x35, 0x37, 0x38, 0x66, 0x65, 0x66, 0x62, 0x37, 0x32, 0x61, 0x34, 0x61, 0x32, 0x32, 0x33, 0x34, 0x32, 0x30, 0x33, 0x62, 0x31, 0x35, 0x35, 0x37, 0x64, 0x37, 0x37, 0x61, 0x39, 0x31, 0x39, 0x31, 0x30, 0x31, 0x36, 0x66, 0x34, 0x34, 0x32, 0x61, 0x31, 0x61, 0x61, 0x37, 0x39, 0x37, 0x37, 0x36, 0x65, 0x32, 0x36, 0x61, 0x62, 0x32, 0x35, 0x32, 0x64, 0x34, 0x31, 0x34, 0x66, 0x30, 0x35, 0x36, 0x31, 0x38, 0x34, 0x36, 0x65, 0x61, 0x34, 0x33, 0x34, 0x33, 0x62, 0x33, 0x65, 0x63, 0x66, 0x38, 0x35, 0x63, 0x62, 0x37, 0x31, 0x64, 0x30, 0x62, 0x34, 0x31, 0x34, 0x65, 0x62, 0x65, 0x39, 0x63, 0x62, 0x39, 0x64, 0x36, 0x64, 0x32, 0x34, 0x35, 0x30, 0x31, 0x64, 0x36, 0x30, 0x35, 0x33, 0x36, 0x64, 0x39, 0x34, 0x34, 0x66, 0x61, 0x36, 0x31, 0x34, 0x38, 0x33, 0x61, 0x31, 0x62, 0x61, 0x65, 0x39, 0x32, 0x65, 0x39, 0x64, 0x33, 0x32, 0x37, 0x32, 0x30, 0x37, 0x34, 0x39, 0x35, 0x31, 0x62, 0x34, 0x34, 0x39, 0x33, 0x36, 0x64, 0x66, 0x65, 0x38, 0x33, 0x31, 0x30, 0x32, 0x39, 0x36, 0x33, 0x62, 0x30, 0x62, 0x34, 0x61, 0x31, 0x63, 0x32, 0x30, 0x66, 0x65, 0x33, 0x61, 0x63, 0x33, 0x30, 0x33, 0x34, 0x65, 0x39, 0x63, 0x63, 0x37, 0x65, 0x32, 0x63, 0x32, 0x62, 0x61, 0x62, 0x61, 0x32, 0x39, 0x34, 0x38, 0x30, 0x66, 0x31, 0x30, 0x36, 0x34, 0x35, 0x31, 0x65, 0x63, 0x64, 0x34, 0x38, 0x33, 0x65, 0x35, 0x34, 0x38, 0x66, 0x31, 0x61, 0x38, 0x36, 0x62, 0x33, 0x66, 0x35, 0x37, 0x61, 0x34, 0x33, 0x31, 0x63, 0x62, 0x64, 0x30, 0x62, 0x38, 0x36, 0x31, 0x30, 0x34, 0x63, 0x65, 0x64, 0x30, 0x37, 0x35, 0x37, 0x61, 0x34, 0x65, 0x38, 0x38, 0x64, 0x36, 0x36, 0x37, 0x62, 0x34, 0x34, 0x31, 0x61, 0x37, 0x36, 0x35, 0x31, 0x36, 0x37, 0x32, 0x34, 0x64, 0x31, 0x39, 0x38, 0x62, 0x61, 0x37, 0x62, 0x37, 0x63, 0x64, 0x37, 0x36, 0x30, 0x33, 0x66, 0x37, 0x66, 0x33, 0x32, 0x61, 0x30, 0x65, 0x32, 0x63, 0x66, 0x62, 0x65, 0x65, 0x35, 0x35, 0x61, 0x65, 0x30, 0x37, 0x38, 0x33, 0x35, 0x37, 0x31, 0x31, 0x64, 0x64, 0x35, 0x37, 0x35, 0x34, 0x31, 0x30, 0x61, 0x64, 0x65, 0x38, 0x61, 0x38, 0x64, 0x33, 0x30, 0x35, 0x31, 0x36, 0x37, 0x32, 0x38, 0x37, 0x62, 0x31, 0x37, 0x33, 0x64, 0x35, 0x39, 0x34, 0x65, 0x62, 0x33, 0x65, 0x36, 0x38, 0x63, 0x32, 0x35, 0x61, 0x34, 0x64, 0x34, 0x65, 0x30, 0x36, 0x33, 0x39, 0x30, 0x34, 0x61, 0x33, 0x61, 0x31, 0x64, 0x32, 0x34, 0x65, 0x32, 0x61, 0x32, 0x64, 0x38, 0x39, 0x35, 0x38, 0x36, 0x66, 0x39, 0x36, 0x61, 0x33, 0x33, 0x33, 0x37, 0x39, 0x32, 0x33, 0x34, 0x61, 0x62, 0x37, 0x37, 0x32, 0x63, 0x33, 0x65, 0x34, 0x39, 0x39, 0x31, 0x63, 0x30, 0x34, 0x31, 0x34, 0x32, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x38, 0x65, 0x34, 0x36, 0x30, 0x32, 0x61, 0x32, 0x37, 0x33, 0x31, 0x34, 0x38, 0x61, 0x39, 0x31, 0x36, 0x32, 0x65, 0x62, 0x35, 0x36, 0x62, 0x64, 0x33, 0x36, 0x64, 0x63, 0x35, 0x38, 0x32, 0x61, 0x61, 0x65, 0x36, 0x65, 0x61, 0x64, 0x64, 0x32, 0x37, 0x32, 0x35, 0x37, 0x32, 0x61, 0x38, 0x61, 0x64, 0x37, 0x64, 0x38, 0x66, 0x39, 0x64, 0x34, 0x62, 0x35, 0x65, 0x36, 0x30, 0x33, 0x63, 0x35, 0x30, 0x34, 0x34, 0x65, 0x38, 0x63, 0x39, 0x37, 0x66, 0x35, 0x31, 0x37, 0x32, 0x63, 0x30, 0x38, 0x64, 0x61, 0x66, 0x37, 0x65, 0x34, 0x65, 0x30, 0x63, 0x39, 0x35, 0x62, 0x33, 0x38, 0x61, 0x38, 0x31, 0x31, 0x38, 0x66, 0x31, 0x30, 0x65, 0x32, 0x32, 0x37, 0x34, 0x36, 0x32, 0x64, 0x31, 0x30, 0x36, 0x31, 0x61, 0x64, 0x63, 0x30, 0x33, 0x35, 0x35, 0x30, 0x34, 0x34, 0x63, 0x32, 0x31, 0x34, 0x32, 0x66, 0x61, 0x66, 0x63, 0x66, 0x66, 0x31, 0x34, 0x62, 0x64, 0x36, 0x33, 0x32, 0x62, 0x39, 0x66, 0x61, 0x39, 0x37, 0x32, 0x36, 0x65, 0x37, 0x31, 0x31, 0x66, 0x33, 0x62, 0x33, 0x61, 0x35, 0x32, 0x65, 0x32, 0x65, 0x61, 0x65, 0x32, 0x32, 0x35, 0x61, 0x32, 0x33, 0x36, 0x63, 0x64, 0x32, 0x63, 0x64, 0x32, 0x37, 0x36, 0x36, 0x34, 0x34, 0x63, 0x33, 0x64, 0x31, 0x33, 0x38, 0x37, 0x32, 0x33, 0x39, 0x65, 0x34, 0x39, 0x65, 0x30, 0x34, 0x62, 0x62, 0x30, 0x36, 0x35, 0x64, 0x30, 0x37, 0x64, 0x35, 0x31, 0x64, 0x62, 0x38, 0x33, 0x33, 0x31, 0x32, 0x32, 0x33, 0x63, 0x66, 0x37, 0x61, 0x35, 0x61, 0x66, 0x38, 0x64, 0x38, 0x36, 0x37, 0x63, 0x31, 0x32, 0x34, 0x62, 0x63, 0x32, 0x63, 0x31, 0x36, 0x33, 0x35, 0x64, 0x63, 0x33, 0x37, 0x30, 0x35, 0x63, 0x65, 0x62, 0x31, 0x66, 0x61, 0x66, 0x61, 0x33, 0x63, 0x62, 0x31, 0x34, 0x36, 0x36, 0x61, 0x30, 0x64, 0x33, 0x34, 0x34, 0x30, 0x38, 0x66, 0x64, 0x36, 0x30, 0x64, 0x32, 0x62, 0x36, 0x39, 0x66, 0x38, 0x65, 0x62, 0x63, 0x33, 0x62, 0x38, 0x32, 0x35, 0x64, 0x36, 0x62, 0x64, 0x66, 0x36, 0x61, 0x37, 0x32, 0x37, 0x64, 0x30, 0x63, 0x66, 0x38, 0x36, 0x38, 0x34, 0x37, 0x37, 0x35, 0x38, 0x34, 0x33, 0x36, 0x34, 0x63, 0x31, 0x34, 0x36, 0x39, 0x30, 0x61, 0x30, 0x30, 0x63, 0x32, 0x65, 0x32, 0x37, 0x39, 0x33, 0x61, 0x38, 0x31, 0x64, 0x33, 0x37, 0x33, 0x34, 0x35, 0x31, 0x34, 0x36, 0x31, 0x61, 0x34, 0x30, 0x35, 0x34, 0x38, 0x35, 0x37, 0x30, 0x31, 0x35, 0x36, 0x62, 0x32, 0x39, 0x39, 0x32, 0x64, 0x34, 0x31, 0x65, 0x65, 0x36, 0x63, 0x38, 0x66, 0x36, 0x64, 0x35, 0x65, 0x32, 0x63, 0x33, 0x38, 0x33, 0x65, 0x37, 0x64, 0x34, 0x65, 0x63, 0x62, 0x35, 0x34, 0x62, 0x65, 0x65, 0x38, 0x64, 0x65, 0x37, 0x32, 0x61, 0x33, 0x63, 0x66, 0x63, 0x32, 0x66, 0x63, 0x61, 0x63, 0x38, 0x35, 0x62, 0x65, 0x36, 0x62, 0x30, 0x30, 0x34, 0x37, 0x30, 0x62, 0x38, 0x38, 0x34, 0x31, 0x36, 0x32, 0x37, 0x32, 0x32, 0x37, 0x33, 0x31, 0x66, 0x30, 0x39, 0x36, 0x33, 0x37, 0x36, 0x66, 0x62, 0x65, 0x31, 0x31, 0x39, 0x39, 0x64, 0x38, 0x36, 0x65, 0x37, 0x63, 0x66, 0x31, 0x66, 0x33, 0x35, 0x31, 0x35, 0x36, 0x36, 0x62, 0x64, 0x37, 0x33, 0x64, 0x37, 0x38, 0x66, 0x66, 0x62, 0x30, 0x37, 0x32, 0x35, 0x38, 0x36, 0x63, 0x65, 0x62, 0x66, 0x66, 0x36, 0x63, 0x33, 0x31, 0x63, 0x38, 0x63, 0x33, 0x37, 0x32, 0x61, 0x35, 0x31, 0x61, 0x63, 0x36, 0x30, 0x37, 0x36, 0x32, 0x37, 0x64, 0x31, 0x33, 0x35, 0x31, 0x66, 0x32, 0x32, 0x63, 0x61, 0x39, 0x38, 0x39, 0x33, 0x32, 0x32, 0x64, 0x33, 0x65, 0x36, 0x31, 0x31, 0x39, 0x30, 0x35, 0x30, 0x36, 0x34, 0x39, 0x35, 0x66, 0x64, 0x63, 0x63, 0x39, 0x35, 0x38, 0x66, 0x36, 0x39, 0x37, 0x36, 0x34, 0x65, 0x66, 0x64, 0x32, 0x61, 0x31, 0x66, 0x37, 0x34, 0x65, 0x61, 0x65, 0x61, 0x35, 0x62, 0x38, 0x36, 0x39, 0x61, 0x34, 0x66, 0x65, 0x30, 0x62, 0x34, 0x34, 0x66, 0x36, 0x63, 0x36, 0x37, 0x63, 0x32, 0x61, 0x62, 0x35, 0x64, 0x38, 0x64, 0x63, 0x65, 0x61, 0x65, 0x65, 0x65, 0x30, 0x31, 0x35, 0x65, 0x64, 0x62, 0x31, 0x30, 0x31, 0x38, 0x38, 0x31, 0x31, 0x65, 0x66, 0x62, 0x65, 0x38, 0x61, 0x37, 0x33, 0x35, 0x66, 0x37, 0x33, 0x31, 0x35, 0x34, 0x37, 0x38, 0x33, 0x35, 0x32, 0x30, 0x65, 0x61, 0x33, 0x37, 0x35, 0x39, 0x61, 0x36, 0x61, 0x63, 0x62, 0x36, 0x36, 0x37, 0x31, 0x31, 0x31, 0x31, 0x63, 0x39, 0x35, 0x36, 0x65, 0x37, 0x35, 0x63, 0x31, 0x35, 0x63, 0x39, 0x34, 0x66, 0x31, 0x38, 0x37, 0x33, 0x30, 0x36, 0x65, 0x65, 0x62, 0x30, 0x39, 0x61, 0x38, 0x63, 0x33, 0x34, 0x34, 0x66, 0x64, 0x31, 0x37, 0x62, 0x32, 0x62, 0x62, 0x37, 0x32, 0x62, 0x38, 0x64, 0x63, 0x31, 0x35, 0x37, 0x35, 0x62, 0x34, 0x35, 0x65, 0x37, 0x30, 0x32, 0x32, 0x63, 0x63, 0x34, 0x34, 0x34, 0x36, 0x39, 0x39, 0x65, 0x36, 0x63, 0x38, 0x64, 0x33, 0x36, 0x63, 0x30, 0x32, 0x30, 0x31, 0x37, 0x63, 0x36, 0x32, 0x37, 0x38, 0x36, 0x32, 0x31, 0x36, 0x36, 0x63, 0x61, 0x34, 0x62, 0x35, 0x34, 0x36, 0x34, 0x37, 0x36, 0x65, 0x62, 0x39, 0x63, 0x38, 0x37, 0x32, 0x65, 0x38, 0x36, 0x62, 0x62, 0x64, 0x61, 0x37, 0x39, 0x62, 0x33, 0x66, 0x61, 0x31, 0x62, 0x39, 0x65, 0x32, 0x39, 0x32, 0x31, 0x66, 0x61, 0x38, 0x34, 0x35, 0x31, 0x66, 0x32, 0x62, 0x32, 0x32, 0x62, 0x37, 0x61, 0x36, 0x30, 0x30, 0x66, 0x38, 0x39, 0x65, 0x30, 0x35, 0x30, 0x37, 0x62, 0x33, 0x30, 0x31, 0x30, 0x66, 0x38, 0x65, 0x31, 0x39, 0x37, 0x32, 0x30, 0x61, 0x61, 0x37, 0x37, 0x32, 0x36, 0x37, 0x32, 0x62, 0x34, 0x34, 0x64, 0x63, 0x37, 0x38, 0x64, 0x63, 0x63, 0x35, 0x63, 0x37, 0x37, 0x35, 0x31, 0x30, 0x37, 0x62, 0x38, 0x33, 0x31, 0x65, 0x39, 0x39, 0x38, 0x38, 0x33, 0x33, 0x36, 0x64, 0x61, 0x33, 0x64, 0x35, 0x32, 0x32, 0x31, 0x34, 0x38, 0x39, 0x66, 0x34, 0x35, 0x34, 0x33, 0x32, 0x35, 0x39, 0x30, 0x62, 0x32, 0x31, 0x64, 0x35, 0x31, 0x31, 0x39, 0x63, 0x35, 0x63, 0x32, 0x37, 0x61, 0x37, 0x62, 0x30, 0x35, 0x31, 0x37, 0x31, 0x36, 0x39, 0x64, 0x62, 0x37, 0x34, 0x37, 0x61, 0x64, 0x34, 0x30, 0x38, 0x30, 0x63, 0x66, 0x31, 0x34, 0x34, 0x65, 0x34, 0x30, 0x31, 0x36, 0x65, 0x62, 0x31, 0x37, 0x30, 0x32, 0x39, 0x63, 0x61, 0x37, 0x38, 0x36, 0x31, 0x64, 0x39, 0x65, 0x65, 0x33, 0x61, 0x61, 0x65, 0x35, 0x39, 0x33, 0x66, 0x63, 0x62, 0x32, 0x65, 0x37, 0x32, 0x36, 0x34, 0x39, 0x37, 0x39, 0x63, 0x33, 0x33, 0x35, 0x32, 0x39, 0x62, 0x36, 0x36, 0x34, 0x37, 0x35, 0x66, 0x34, 0x33, 0x63, 0x30, 0x65, 0x36, 0x35, 0x30, 0x35, 0x37, 0x32, 0x66, 0x35, 0x33, 0x66, 0x30, 0x35, 0x65, 0x35, 0x63, 0x66, 0x66, 0x31, 0x65, 0x64, 0x30, 0x34, 0x63, 0x65, 0x31, 0x38, 0x66, 0x32, 0x33, 0x61, 0x36, 0x62, 0x61, 0x32, 0x64, 0x30, 0x31, 0x62, 0x34, 0x37, 0x32, 0x62, 0x66, 0x64, 0x33, 0x37, 0x65, 0x65, 0x39, 0x32, 0x36, 0x61, 0x63, 0x32, 0x64, 0x33, 0x37, 0x38, 0x34, 0x61, 0x64, 0x33, 0x37, 0x37, 0x62, 0x36, 0x38, 0x63, 0x33, 0x33, 0x62, 0x65, 0x39, 0x30, 0x61, 0x32, 0x31, 0x63, 0x34, 0x64, 0x37, 0x31, 0x30, 0x31, 0x38, 0x66, 0x64, 0x37, 0x36, 0x62, 0x62, 0x37, 0x39, 0x32, 0x66, 0x33, 0x30, 0x65, 0x31, 0x37, 0x39, 0x39, 0x34, 0x37, 0x32, 0x64, 0x34, 0x33, 0x63, 0x65, 0x62, 0x66, 0x39, 0x37, 0x62, 0x64, 0x38, 0x32, 0x32, 0x65, 0x34, 0x37, 0x35, 0x36, 0x66, 0x34, 0x63, 0x65, 0x34, 0x65, 0x35, 0x65, 0x61, 0x33, 0x36, 0x65, 0x38, 0x36, 0x62, 0x66, 0x66, 0x38, 0x33, 0x37, 0x31, 0x37, 0x37, 0x39, 0x66, 0x65, 0x39, 0x64, 0x64, 0x37, 0x63, 0x38, 0x65, 0x30, 0x35, 0x36, 0x61, 0x38, 0x33, 0x39, 0x31, 0x37, 0x31, 0x37, 0x32, 0x62, 0x32, 0x39, 0x66, 0x65, 0x32, 0x63, 0x36, 0x34, 0x39, 0x30, 0x62, 0x35, 0x39, 0x39, 0x33, 0x31, 0x36, 0x30, 0x64, 0x63, 0x37, 0x64, 0x33, 0x65, 0x34, 0x33, 0x31, 0x38, 0x65, 0x39, 0x33, 0x38, 0x33, 0x65, 0x35, 0x31, 0x63, 0x37, 0x39, 0x31, 0x64, 0x36, 0x37, 0x33, 0x31, 0x31, 0x66, 0x30, 0x33, 0x31, 0x66, 0x30, 0x63, 0x37, 0x33, 0x30, 0x35, 0x35, 0x36, 0x30, 0x33, 0x35, 0x61, 0x65, 0x64, 0x33, 0x37, 0x31, 0x65, 0x36, 0x39, 0x34, 0x34, 0x38, 0x36, 0x39, 0x33, 0x39, 0x31, 0x32, 0x66, 0x31, 0x33, 0x34, 0x36, 0x34, 0x31, 0x33, 0x38, 0x66, 0x31, 0x63, 0x34, 0x65, 0x63, 0x31, 0x35, 0x30, 0x32, 0x62, 0x32, 0x30, 0x31, 0x62, 0x63, 0x64, 0x32, 0x31, 0x37, 0x30, 0x62, 0x37, 0x64, 0x61, 0x35, 0x33, 0x61, 0x31, 0x33, 0x64, 0x65, 0x61, 0x30, 0x31, 0x39, 0x36, 0x62, 0x66, 0x66, 0x31, 0x63, 0x38, 0x36, 0x39, 0x64, 0x38, 0x31, 0x38, 0x66, 0x64, 0x35, 0x34, 0x39, 0x35, 0x62, 0x66, 0x63, 0x36, 0x34, 0x30, 0x33, 0x61, 0x34, 0x33, 0x64, 0x32, 0x65, 0x37, 0x35, 0x39, 0x39, 0x63, 0x65, 0x61, 0x37, 0x61, 0x38, 0x35, 0x64, 0x36, 0x66, 0x32, 0x35, 0x32, 0x33, 0x61, 0x64, 0x61, 0x38, 0x36, 0x30, 0x39, 0x30, 0x36, 0x62, 0x65, 0x31, 0x31, 0x61, 0x37, 0x32, 0x39, 0x31, 0x33, 0x64, 0x36, 0x34, 0x39, 0x35, 0x64, 0x63, 0x34, 0x37, 0x62, 0x33, 0x63, 0x36, 0x37, 0x31, 0x65, 0x64, 0x63, 0x66, 0x66, 0x30, 0x63, 0x34, 0x36, 0x64, 0x35, 0x63, 0x64, 0x62, 0x63, 0x37, 0x37, 0x37, 0x66, 0x66, 0x63, 0x63, 0x39, 0x37, 0x63, 0x31, 0x39, 0x37, 0x38, 0x62, 0x61, 0x35, 0x65, 0x39, 0x66, 0x34, 0x66, 0x64, 0x66, 0x33, 0x33, 0x36, 0x36, 0x63, 0x34, 0x39, 0x36, 0x30, 0x33, 0x36, 0x36, 0x66, 0x66, 0x63, 0x63, 0x34, 0x63, 0x63, 0x32, 0x33, 0x37, 0x31, 0x33, 0x32, 0x34, 0x35, 0x62, 0x61, 0x63, 0x33, 0x61, 0x66, 0x30, 0x39, 0x31, 0x36, 0x38, 0x63, 0x30, 0x61, 0x62, 0x63, 0x37, 0x35, 0x61, 0x37, 0x65, 0x30, 0x34, 0x61, 0x36, 0x31, 0x65, 0x37, 0x39, 0x33, 0x35, 0x39, 0x31, 0x64, 0x39, 0x37, 0x34, 0x66, 0x63, 0x66, 0x31, 0x30, 0x32, 0x35, 0x36, 0x37, 0x31, 0x64, 0x39, 0x62, 0x36, 0x31, 0x61, 0x39, 0x64, 0x36, 0x30, 0x62, 0x37, 0x30, 0x66, 0x38, 0x37, 0x35, 0x38, 0x66, 0x38, 0x66, 0x39, 0x37, 0x32, 0x34, 0x32, 0x38, 0x31, 0x65, 0x35, 0x33, 0x61, 0x64, 0x39, 0x62, 0x30, 0x31, 0x39, 0x38, 0x36, 0x64, 0x33, 0x66, 0x34, 0x61, 0x61, 0x37, 0x36, 0x38, 0x65, 0x66, 0x38, 0x37, 0x64, 0x38, 0x37, 0x31, 0x66, 0x38, 0x35, 0x34, 0x65, 0x39, 0x32, 0x64, 0x38, 0x38, 0x61, 0x64, 0x36, 0x65, 0x62, 0x61, 0x39, 0x34, 0x33, 0x34, 0x62, 0x63, 0x37, 0x39, 0x30, 0x31, 0x39, 0x64, 0x31, 0x65, 0x64, 0x34, 0x35, 0x32, 0x30, 0x61, 0x64, 0x66, 0x39, 0x62, 0x36, 0x37, 0x30, 0x37, 0x35, 0x33, 0x30, 0x33, 0x31, 0x66, 0x30, 0x66, 0x61, 0x39, 0x65, 0x64, 0x64, 0x63, 0x63, 0x33, 0x36, 0x65, 0x63, 0x62, 0x37, 0x63, 0x37, 0x32, 0x65, 0x34, 0x39, 0x65, 0x34, 0x31, 0x34, 0x38, 0x35, 0x62, 0x64, 0x36, 0x31, 0x63, 0x31, 0x31, 0x33, 0x33, 0x33, 0x61, 0x31, 0x64, 0x33, 0x33, 0x30, 0x31, 0x33, 0x32, 0x35, 0x30, 0x66, 0x33, 0x63, 0x61, 0x66, 0x37, 0x36, 0x64, 0x61, 0x38, 0x62, 0x32, 0x62, 0x36, 0x37, 0x64, 0x34, 0x36, 0x63, 0x37, 0x34, 0x37, 0x64, 0x32, 0x36, 0x61, 0x30, 0x64, 0x66, 0x37, 0x35, 0x61, 0x35, 0x33, 0x61, 0x63, 0x35, 0x33, 0x64, 0x35, 0x38, 0x66, 0x31, 0x61, 0x39, 0x31, 0x62, 0x31, 0x65, 0x37, 0x37, 0x63, 0x35, 0x36, 0x38, 0x63, 0x61, 0x65, 0x63, 0x35, 0x33, 0x62, 0x38, 0x38, 0x61, 0x63, 0x33, 0x62, 0x66, 0x33, 0x39, 0x36, 0x36, 0x30, 0x61, 0x63, 0x38, 0x39, 0x64, 0x65, 0x36, 0x63, 0x65, 0x34, 0x66, 0x66, 0x66, 0x37, 0x64, 0x33, 0x39, 0x33, 0x62, 0x36, 0x61, 0x61, 0x37, 0x32, 0x34, 0x32, 0x34, 0x32, 0x34, 0x32, 0x61, 0x62, 0x63, 0x63, 0x34, 0x30, 0x62, 0x35, 0x33, 0x30, 0x38, 0x37, 0x35, 0x33, 0x66, 0x66, 0x64, 0x63, 0x36, 0x35, 0x31, 0x31, 0x65, 0x65, 0x35, 0x31, 0x61, 0x62, 0x65, 0x37, 0x64, 0x31, 0x65, 0x35, 0x33, 0x62, 0x35, 0x65, 0x39, 0x39, 0x63, 0x64, 0x37, 0x39, 0x62, 0x61, 0x33, 0x37, 0x36, 0x37, 0x62, 0x33, 0x35, 0x66, 0x38, 0x31, 0x37, 0x32, 0x61, 0x33, 0x36, 0x39, 0x38, 0x35, 0x38, 0x37, 0x65, 0x65, 0x33, 0x35, 0x62, 0x63, 0x66, 0x65, 0x37, 0x31, 0x31, 0x33, 0x31, 0x63, 0x36, 0x32, 0x62, 0x33, 0x31, 0x63, 0x33, 0x37, 0x33, 0x61, 0x61, 0x65, 0x34, 0x61, 0x37, 0x61, 0x35, 0x39, 0x30, 0x34, 0x65, 0x66, 0x34, 0x31, 0x35, 0x62, 0x63, 0x32, 0x66, 0x65, 0x63, 0x31, 0x39, 0x61, 0x65, 0x38, 0x61, 0x64, 0x35, 0x30, 0x37, 0x32, 0x36, 0x32, 0x35, 0x37, 0x30, 0x61, 0x61, 0x64, 0x36, 0x39, 0x65, 0x39, 0x38, 0x39, 0x30, 0x37, 0x33, 0x62, 0x33, 0x33, 0x31, 0x63, 0x36, 0x62, 0x31, 0x33, 0x30, 0x39, 0x64, 0x66, 0x32, 0x31, 0x33, 0x37, 0x35, 0x34, 0x62, 0x61, 0x31, 0x38, 0x37, 0x32, 0x64, 0x65, 0x36, 0x61, 0x36, 0x32, 0x64, 0x33, 0x63, 0x62, 0x32, 0x32, 0x36, 0x32, 0x61, 0x38, 0x34, 0x35, 0x39, 0x63, 0x37, 0x32, 0x38, 0x30, 0x62, 0x31, 0x37, 0x34, 0x66, 0x39, 0x35, 0x35, 0x36, 0x37, 0x61, 0x38, 0x62, 0x30, 0x36, 0x63, 0x35, 0x39, 0x33, 0x36, 0x39, 0x63, 0x39, 0x37, 0x62, 0x62, 0x31, 0x37, 0x32, 0x62, 0x37, 0x31, 0x34, 0x34, 0x38, 0x37, 0x38, 0x61, 0x63, 0x63, 0x30, 0x30, 0x39, 0x35, 0x38, 0x38, 0x34, 0x66, 0x63, 0x66, 0x30, 0x30, 0x63, 0x30, 0x37, 0x65, 0x38, 0x31, 0x31, 0x32, 0x34, 0x39, 0x65, 0x61, 0x38, 0x37, 0x62, 0x63, 0x63, 0x34, 0x31, 0x64, 0x62, 0x33, 0x65, 0x37, 0x34, 0x34, 0x37, 0x34, 0x32, 0x32, 0x37, 0x36, 0x39, 0x31, 0x65, 0x39, 0x30, 0x65, 0x63, 0x31, 0x65, 0x38, 0x36, 0x35, 0x30, 0x31, 0x65, 0x34, 0x61, 0x64, 0x65, 0x61, 0x66, 0x62, 0x34, 0x33, 0x66, 0x35, 0x31, 0x65, 0x35, 0x37, 0x31, 0x33, 0x65, 0x61, 0x66, 0x31, 0x39, 0x34, 0x37, 0x30, 0x37, 0x32, 0x34, 0x33, 0x30, 0x63, 0x61, 0x64, 0x62, 0x30, 0x66, 0x36, 0x62, 0x61, 0x64, 0x30, 0x66, 0x61, 0x32, 0x39, 0x65, 0x38, 0x35, 0x32, 0x63, 0x30, 0x39, 0x38, 0x64, 0x30, 0x34, 0x32, 0x61, 0x63, 0x61, 0x64, 0x63, 0x37, 0x30, 0x62, 0x62, 0x32, 0x34, 0x31, 0x34, 0x37, 0x34, 0x32, 0x33, 0x36, 0x65, 0x66, 0x34, 0x31, 0x66, 0x34, 0x31, 0x33, 0x31, 0x31, 0x36, 0x30, 0x32, 0x31, 0x37, 0x32, 0x64, 0x33, 0x31, 0x65, 0x65, 0x33, 0x32, 0x39, 0x37, 0x34, 0x31, 0x66, 0x32, 0x33, 0x33, 0x32, 0x37, 0x37, 0x62, 0x62, 0x64, 0x63, 0x34, 0x39, 0x61, 0x63, 0x34, 0x32, 0x34, 0x30, 0x34, 0x30, 0x32, 0x35, 0x38, 0x62, 0x38, 0x65, 0x38, 0x32, 0x64, 0x63, 0x66, 0x64, 0x63, 0x37, 0x65, 0x63, 0x38, 0x64, 0x61, 0x61, 0x37, 0x39, 0x39, 0x63, 0x38, 0x61, 0x61, 0x65, 0x38, 0x34, 0x37, 0x32, 0x33, 0x32, 0x62, 0x64, 0x66, 0x34, 0x63, 0x35, 0x34, 0x65, 0x61, 0x64, 0x31, 0x63, 0x61, 0x62, 0x35, 0x33, 0x38, 0x31, 0x30, 0x65, 0x62, 0x64, 0x35, 0x63, 0x63, 0x37, 0x65, 0x61, 0x32, 0x61, 0x32, 0x65, 0x37, 0x64, 0x66, 0x66, 0x38, 0x34, 0x37, 0x64, 0x65, 0x35, 0x61, 0x31, 0x36, 0x62, 0x36, 0x33, 0x66, 0x35, 0x62, 0x34, 0x66, 0x36, 0x62, 0x37, 0x34, 0x61, 0x64, 0x32, 0x30, 0x62, 0x61, 0x61, 0x30, 0x63, 0x64, 0x61, 0x65, 0x32, 0x35, 0x64, 0x63, 0x63, 0x31, 0x33, 0x63, 0x30, 0x61, 0x35, 0x37, 0x33, 0x61, 0x30, 0x31, 0x62, 0x62, 0x33, 0x66, 0x63, 0x32, 0x34, 0x64, 0x31, 0x38, 0x62, 0x35, 0x65, 0x36, 0x63, 0x34, 0x30, 0x64, 0x66, 0x36, 0x38, 0x30, 0x63, 0x65, 0x64, 0x31, 0x64, 0x64, 0x30, 0x39, 0x37, 0x34, 0x33, 0x34, 0x62, 0x63, 0x32, 0x64, 0x36, 0x31, 0x36, 0x35, 0x66, 0x65, 0x32, 0x38, 0x38, 0x62, 0x30, 0x65, 0x39, 0x63, 0x61, 0x32, 0x61, 0x35, 0x39, 0x62, 0x65, 0x66, 0x64, 0x39, 0x31, 0x30, 0x39, 0x64, 0x34, 0x38, 0x32, 0x38, 0x34, 0x37, 0x63, 0x39, 0x39, 0x62, 0x65, 0x33, 0x66, 0x39, 0x38, 0x63, 0x31, 0x34, 0x36, 0x38, 0x65, 0x32, 0x64, 0x34, 0x66, 0x37, 0x62, 0x30, 0x37, 0x34, 0x31, 0x61, 0x62, 0x32, 0x64, 0x39, 0x66, 0x35, 0x63, 0x66, 0x30, 0x38, 0x34, 0x34, 0x30, 0x37, 0x36, 0x35, 0x34, 0x63, 0x63, 0x39, 0x37, 0x35, 0x64, 0x35, 0x35, 0x32, 0x64, 0x39, 0x61, 0x38, 0x33, 0x62, 0x66, 0x38, 0x66, 0x33, 0x31, 0x62, 0x64, 0x61, 0x65, 0x61, 0x31, 0x63, 0x33, 0x36, 0x64, 0x39, 0x31, 0x33, 0x38, 0x38, 0x36, 0x35, 0x39, 0x35, 0x62, 0x36, 0x31, 0x32, 0x30, 0x37, 0x62, 0x61, 0x31, 0x35, 0x62, 0x32, 0x30, 0x34, 0x62, 0x32, 0x31, 0x30, 0x64, 0x36, 0x33, 0x33, 0x65, 0x63, 0x34, 0x36, 0x61, 0x31, 0x61, 0x36, 0x64, 0x39, 0x31, 0x61, 0x34, 0x37, 0x62, 0x62, 0x34, 0x63, 0x36, 0x32, 0x64, 0x63, 0x36, 0x39, 0x38, 0x30, 0x38, 0x63, 0x31, 0x62, 0x34, 0x39, 0x64, 0x64, 0x38, 0x65, 0x32, 0x36, 0x61, 0x61, 0x31, 0x37, 0x32, 0x64, 0x30, 0x65, 0x38, 0x64, 0x35, 0x32, 0x30, 0x65, 0x30, 0x38, 0x34, 0x37, 0x32, 0x63, 0x62, 0x39, 0x39, 0x66, 0x66, 0x37, 0x61, 0x63, 0x36, 0x31, 0x31, 0x31, 0x66, 0x34, 0x62, 0x62, 0x37, 0x61, 0x31, 0x66, 0x62, 0x37, 0x61, 0x33, 0x33, 0x62, 0x35, 0x61, 0x33, 0x66, 0x62, 0x36, 0x33, 0x35, 0x38, 0x39, 0x37, 0x32, 0x37, 0x36, 0x65, 0x34, 0x39, 0x62, 0x32, 0x66, 0x30, 0x66, 0x35, 0x37, 0x61, 0x39, 0x35, 0x61, 0x39, 0x31, 0x37, 0x66, 0x37, 0x62, 0x32, 0x37, 0x32, 0x64, 0x65, 0x37, 0x66, 0x32, 0x39, 0x36, 0x39, 0x30, 0x32, 0x35, 0x61, 0x62, 0x63, 0x65, 0x39, 0x36, 0x39, 0x61, 0x66, 0x34, 0x61, 0x65, 0x39, 0x66, 0x34, 0x37, 0x35, 0x32, 0x66, 0x31, 0x62, 0x63, 0x38, 0x36, 0x35, 0x33, 0x62, 0x30, 0x61, 0x66, 0x31, 0x35, 0x38, 0x63, 0x31, 0x38, 0x64, 0x39, 0x35, 0x62, 0x33, 0x32, 0x37, 0x39, 0x66, 0x31, 0x35, 0x38, 0x66, 0x35, 0x31, 0x37, 0x32, 0x34, 0x62, 0x33, 0x61, 0x37, 0x36, 0x36, 0x30, 0x63, 0x39, 0x63, 0x38, 0x34, 0x63, 0x62, 0x38, 0x64, 0x66, 0x65, 0x34, 0x31, 0x66, 0x64, 0x31, 0x64, 0x36, 0x32, 0x63, 0x37, 0x64, 0x30, 0x66, 0x35, 0x66, 0x36, 0x33, 0x63, 0x35, 0x62, 0x64, 0x32, 0x64, 0x35, 0x66, 0x30, 0x66, 0x33, 0x30, 0x61, 0x36, 0x39, 0x38, 0x37, 0x36, 0x39, 0x38, 0x66, 0x39, 0x35, 0x61, 0x36, 0x64, 0x37, 0x32, 0x31, 0x66, 0x36, 0x35, 0x64, 0x62, 0x35, 0x34, 0x66, 0x32, 0x62, 0x34, 0x32, 0x61, 0x34, 0x66, 0x64, 0x61, 0x66, 0x62, 0x66, 0x33, 0x39, 0x66, 0x33, 0x35, 0x37, 0x34, 0x33, 0x62, 0x37, 0x65, 0x65, 0x38, 0x34, 0x35, 0x66, 0x30, 0x32, 0x65, 0x39, 0x64, 0x34, 0x63, 0x33, 0x30, 0x32, 0x66, 0x62, 0x61, 0x30, 0x35, 0x37, 0x38, 0x38, 0x64, 0x30, 0x66, 0x65, 0x39, 0x37, 0x66, 0x37, 0x32, 0x62, 0x37, 0x34, 0x65, 0x39, 0x64, 0x36, 0x36, 0x64, 0x35, 0x38, 0x62, 0x35, 0x61, 0x33, 0x38, 0x35, 0x38, 0x66, 0x30, 0x39, 0x62, 0x63, 0x61, 0x66, 0x33, 0x32, 0x31, 0x62, 0x32, 0x61, 0x32, 0x64, 0x63, 0x33, 0x64, 0x35, 0x63, 0x34, 0x63, 0x62, 0x61, 0x65, 0x30, 0x66, 0x33, 0x33, 0x35, 0x61, 0x39, 0x65, 0x39, 0x34, 0x31, 0x62, 0x32, 0x63, 0x37, 0x62, 0x39, 0x38, 0x33, 0x37, 0x32, 0x36, 0x37, 0x37, 0x61, 0x34, 0x35, 0x39, 0x37, 0x34, 0x66, 0x36, 0x35, 0x37, 0x39, 0x35, 0x65, 0x34, 0x63, 0x30, 0x65, 0x30, 0x33, 0x32, 0x30, 0x38, 0x38, 0x35, 0x37, 0x63, 0x37, 0x35, 0x66, 0x30, 0x38, 0x31, 0x66, 0x35, 0x36, 0x33, 0x66, 0x35, 0x30, 0x37, 0x34, 0x61, 0x35, 0x62, 0x64, 0x31, 0x63, 0x35, 0x65, 0x65, 0x31, 0x32, 0x30, 0x30, 0x31, 0x36, 0x37, 0x62, 0x38, 0x37, 0x32, 0x35, 0x63, 0x39, 0x39, 0x38, 0x34, 0x63, 0x64, 0x31, 0x61, 0x64, 0x34, 0x34, 0x32, 0x63, 0x33, 0x32, 0x64, 0x39, 0x66, 0x66, 0x34, 0x66, 0x66, 0x62, 0x34, 0x66, 0x65, 0x65, 0x34, 0x37, 0x64, 0x64, 0x61, 0x32, 0x33, 0x39, 0x34, 0x61, 0x37, 0x61, 0x37, 0x36, 0x34, 0x63, 0x30, 0x31, 0x38, 0x38, 0x62, 0x65, 0x39, 0x62, 0x32, 0x62, 0x32, 0x65, 0x34, 0x38, 0x30, 0x30, 0x64, 0x36, 0x35, 0x38, 0x65, 0x34, 0x39, 0x31, 0x36, 0x36, 0x37, 0x34, 0x36, 0x31, 0x61, 0x33, 0x31, 0x62, 0x36, 0x63, 0x37, 0x39, 0x37, 0x39, 0x61, 0x38, 0x64, 0x62, 0x37, 0x65, 0x38, 0x37, 0x61, 0x65, 0x63, 0x38, 0x35, 0x35, 0x32, 0x61, 0x34, 0x30, 0x62, 0x36, 0x66, 0x38, 0x37, 0x36, 0x61, 0x35, 0x32, 0x39, 0x33, 0x33, 0x62, 0x61, 0x34, 0x33, 0x62, 0x37, 0x35, 0x61, 0x31, 0x63, 0x39, 0x34, 0x61, 0x31, 0x30, 0x62, 0x30, 0x66, 0x61, 0x32, 0x33, 0x37, 0x36, 0x37, 0x66, 0x30, 0x34, 0x61, 0x38, 0x61, 0x65, 0x32, 0x34, 0x64, 0x38, 0x39, 0x61, 0x35, 0x36, 0x63, 0x36, 0x63, 0x33, 0x32, 0x66, 0x32, 0x65, 0x35, 0x30, 0x32, 0x64, 0x63, 0x30, 0x32, 0x35, 0x32, 0x30, 0x36, 0x64, 0x35, 0x38, 0x36, 0x37, 0x34, 0x66, 0x39, 0x65, 0x64, 0x39, 0x34, 0x30, 0x35, 0x30, 0x36, 0x31, 0x37, 0x32, 0x63, 0x38, 0x65, 0x37, 0x38, 0x61, 0x39, 0x33, 0x38, 0x35, 0x64, 0x37, 0x38, 0x66, 0x36, 0x61, 0x61, 0x34, 0x65, 0x62, 0x31, 0x39, 0x32, 0x61, 0x64, 0x63, 0x66, 0x34, 0x39, 0x37, 0x63, 0x39, 0x62, 0x38, 0x37, 0x39, 0x30, 0x31, 0x39, 0x64, 0x34, 0x30, 0x65, 0x64, 0x63, 0x32, 0x62, 0x61, 0x65, 0x66, 0x35, 0x65, 0x62, 0x30, 0x31, 0x62, 0x61, 0x66, 0x31, 0x31, 0x32, 0x31, 0x37, 0x32, 0x64, 0x32, 0x61, 0x32, 0x38, 0x63, 0x33, 0x62, 0x62, 0x66, 0x39, 0x39, 0x32, 0x65, 0x34, 0x30, 0x64, 0x34, 0x66, 0x30, 0x39, 0x65, 0x66, 0x33, 0x32, 0x65, 0x34, 0x37, 0x64, 0x37, 0x31, 0x62, 0x35, 0x34, 0x32, 0x36, 0x62, 0x64, 0x62, 0x32, 0x36, 0x37, 0x33, 0x31, 0x32, 0x62, 0x31, 0x34, 0x31, 0x65, 0x34, 0x35, 0x30, 0x32, 0x32, 0x32, 0x34, 0x36, 0x31, 0x65, 0x35, 0x39, 0x37, 0x32, 0x36, 0x36, 0x31, 0x34, 0x61, 0x38, 0x34, 0x33, 0x36, 0x63, 0x63, 0x35, 0x62, 0x63, 0x37, 0x63, 0x30, 0x38, 0x35, 0x64, 0x36, 0x38, 0x39, 0x64, 0x35, 0x64, 0x32, 0x33, 0x62, 0x33, 0x37, 0x31, 0x37, 0x33, 0x32, 0x61, 0x34, 0x38, 0x37, 0x35, 0x38, 0x39, 0x38, 0x36, 0x32, 0x38, 0x63, 0x39, 0x61, 0x63, 0x66, 0x33, 0x33, 0x39, 0x62, 0x34, 0x34, 0x64, 0x38, 0x37, 0x31, 0x32, 0x37, 0x32, 0x34, 0x38, 0x65, 0x33, 0x30, 0x37, 0x37, 0x32, 0x35, 0x64, 0x33, 0x34, 0x36, 0x35, 0x62, 0x63, 0x62, 0x37, 0x36, 0x31, 0x36, 0x35, 0x35, 0x31, 0x65, 0x37, 0x62, 0x61, 0x65, 0x66, 0x32, 0x66, 0x34, 0x33, 0x62, 0x30, 0x36, 0x61, 0x66, 0x62, 0x63, 0x61, 0x33, 0x32, 0x64, 0x66, 0x37, 0x38, 0x37, 0x63, 0x38, 0x30, 0x37, 0x38, 0x32, 0x66, 0x62, 0x63, 0x37, 0x36, 0x38, 0x62, 0x31, 0x35, 0x65, 0x61, 0x36, 0x62, 0x39, 0x38, 0x35, 0x38, 0x61, 0x63, 0x32, 0x65, 0x38, 0x36, 0x38, 0x63, 0x35, 0x65, 0x34, 0x63, 0x65, 0x38, 0x33, 0x32, 0x66, 0x62, 0x36, 0x30, 0x36, 0x37, 0x62, 0x35, 0x66, 0x31, 0x64, 0x64, 0x38, 0x37, 0x34, 0x38, 0x30, 0x61, 0x63, 0x35, 0x63, 0x65, 0x66, 0x61, 0x64, 0x30, 0x61, 0x64, 0x34, 0x62, 0x65, 0x62, 0x36, 0x36, 0x65, 0x37, 0x63, 0x62, 0x31, 0x34, 0x64, 0x35, 0x37, 0x37, 0x65, 0x39, 0x62, 0x63, 0x34, 0x64, 0x63, 0x64, 0x31, 0x38, 0x31, 0x39, 0x35, 0x31, 0x37, 0x63, 0x61, 0x61, 0x36, 0x38, 0x32, 0x61, 0x66, 0x35, 0x37, 0x35, 0x33, 0x39, 0x32, 0x66, 0x64, 0x30, 0x38, 0x65, 0x32, 0x30, 0x35, 0x30, 0x31, 0x31, 0x36, 0x63, 0x66, 0x61, 0x37, 0x61, 0x64, 0x39, 0x35, 0x61, 0x31, 0x36, 0x32, 0x62, 0x33, 0x38, 0x32, 0x35, 0x35, 0x63, 0x61, 0x65, 0x33, 0x39, 0x66, 0x31, 0x34, 0x32, 0x63, 0x30, 0x33, 0x65, 0x32, 0x61, 0x65, 0x33, 0x62, 0x64, 0x65, 0x63, 0x38, 0x34, 0x30, 0x61, 0x63, 0x34, 0x61, 0x62, 0x62, 0x63, 0x38, 0x63, 0x63, 0x39, 0x32, 0x32, 0x62, 0x61, 0x62, 0x63, 0x33, 0x65, 0x65, 0x65, 0x31, 0x61, 0x38, 0x63, 0x62, 0x34, 0x38, 0x37, 0x38, 0x61, 0x61, 0x31, 0x31, 0x31, 0x61, 0x36, 0x34, 0x35, 0x37, 0x32, 0x39, 0x35, 0x62, 0x64, 0x35, 0x36, 0x66, 0x33, 0x65, 0x35, 0x37, 0x37, 0x30, 0x31, 0x64, 0x33, 0x33, 0x66, 0x31, 0x36, 0x34, 0x34, 0x31, 0x36, 0x64, 0x61, 0x30, 0x65, 0x65, 0x38, 0x39, 0x37, 0x35, 0x33, 0x30, 0x66, 0x32, 0x30, 0x37, 0x63, 0x32, 0x66, 0x63, 0x35, 0x65, 0x38, 0x39, 0x31, 0x31, 0x32, 0x37, 0x35, 0x62, 0x66, 0x31, 0x35, 0x38, 0x34, 0x34, 0x38, 0x62, 0x35, 0x30, 0x36, 0x65, 0x34, 0x64, 0x35, 0x37, 0x64, 0x62, 0x32, 0x38, 0x38, 0x35, 0x62, 0x38, 0x62, 0x34, 0x34, 0x37, 0x34, 0x64, 0x39, 0x35, 0x37, 0x37, 0x35, 0x66, 0x65, 0x33, 0x66, 0x65, 0x33, 0x32, 0x66, 0x61, 0x64, 0x62, 0x65, 0x32, 0x39, 0x64, 0x35, 0x62, 0x31, 0x34, 0x37, 0x33, 0x32, 0x34, 0x37, 0x34, 0x34, 0x31, 0x61, 0x62, 0x32, 0x63, 0x32, 0x64, 0x35, 0x66, 0x33, 0x32, 0x37, 0x30, 0x63, 0x30, 0x34, 0x65, 0x31, 0x62, 0x31, 0x61, 0x66, 0x32, 0x36, 0x35, 0x64, 0x34, 0x65, 0x61, 0x35, 0x38, 0x33, 0x63, 0x64, 0x39, 0x31, 0x33, 0x37, 0x30, 0x35, 0x30, 0x61, 0x62, 0x30, 0x38, 0x63, 0x36, 0x64, 0x37, 0x63, 0x66, 0x65, 0x63, 0x35, 0x61, 0x61, 0x31, 0x33, 0x66, 0x35, 0x31, 0x34, 0x64, 0x64, 0x38, 0x30, 0x31, 0x37, 0x31, 0x65, 0x32, 0x61, 0x34, 0x38, 0x62, 0x64, 0x37, 0x32, 0x30, 0x34, 0x33, 0x36, 0x30, 0x33, 0x37, 0x30, 0x37, 0x33, 0x61, 0x37, 0x39, 0x33, 0x66, 0x31, 0x64, 0x36, 0x65, 0x36, 0x31, 0x36, 0x37, 0x38, 0x35, 0x33, 0x32, 0x32, 0x39, 0x36, 0x64, 0x37, 0x36, 0x61, 0x65, 0x33, 0x62, 0x32, 0x62, 0x35, 0x62, 0x33, 0x30, 0x66, 0x63, 0x31, 0x33, 0x63, 0x30, 0x31, 0x61, 0x31, 0x66, 0x37, 0x33, 0x30, 0x65, 0x65, 0x36, 0x63, 0x61, 0x35, 0x31, 0x37, 0x64, 0x37, 0x35, 0x63, 0x31, 0x64, 0x66, 0x66, 0x33, 0x63, 0x32, 0x65, 0x34, 0x38, 0x63, 0x61, 0x65, 0x35, 0x62, 0x38, 0x38, 0x63, 0x33, 0x32, 0x35, 0x34, 0x61, 0x66, 0x62, 0x37, 0x31, 0x64, 0x30, 0x39, 0x31, 0x65, 0x32, 0x62, 0x32, 0x36, 0x38, 0x30, 0x37, 0x39, 0x31, 0x64, 0x35, 0x65, 0x36, 0x64, 0x66, 0x61, 0x33, 0x32, 0x37, 0x30, 0x37, 0x31, 0x33, 0x32, 0x39, 0x30, 0x37, 0x32, 0x33, 0x33, 0x33, 0x33, 0x66, 0x35, 0x65, 0x33, 0x37, 0x33, 0x64, 0x31, 0x34, 0x35, 0x32, 0x62, 0x34, 0x34, 0x61, 0x33, 0x37, 0x36, 0x33, 0x35, 0x32, 0x39, 0x38, 0x39, 0x30, 0x35, 0x32, 0x31, 0x34, 0x63, 0x61, 0x61, 0x39, 0x63, 0x66, 0x38, 0x30, 0x39, 0x38, 0x33, 0x34, 0x66, 0x63, 0x36, 0x65, 0x36, 0x39, 0x61, 0x31, 0x31, 0x39, 0x37, 0x33, 0x34, 0x35, 0x65, 0x64, 0x32, 0x37, 0x32, 0x35, 0x33, 0x32, 0x30, 0x34, 0x34, 0x32, 0x65, 0x37, 0x37, 0x39, 0x61, 0x30, 0x38, 0x33, 0x61, 0x33, 0x30, 0x31, 0x30, 0x61, 0x63, 0x65, 0x37, 0x62, 0x36, 0x61, 0x35, 0x30, 0x33, 0x38, 0x61, 0x64, 0x66, 0x31, 0x35, 0x63, 0x30, 0x31, 0x64, 0x35, 0x66, 0x31, 0x35, 0x37, 0x38, 0x65, 0x61, 0x33, 0x31, 0x37, 0x39, 0x38, 0x32, 0x63, 0x33, 0x61, 0x61, 0x35, 0x65, 0x39, 0x36, 0x30, 0x62, 0x64, 0x38, 0x32, 0x65, 0x61, 0x34, 0x39, 0x30, 0x36, 0x32, 0x38, 0x63, 0x34, 0x35, 0x61, 0x36, 0x63, 0x34, 0x38, 0x33, 0x66, 0x31, 0x64, 0x32, 0x64, 0x39, 0x35, 0x37, 0x61, 0x39, 0x36, 0x62, 0x63, 0x36, 0x39, 0x33, 0x36, 0x66, 0x39, 0x35, 0x61, 0x39, 0x38, 0x31, 0x35, 0x36, 0x39, 0x65, 0x65, 0x35, 0x35, 0x37, 0x36, 0x39, 0x66, 0x63, 0x34, 0x62, 0x33, 0x37, 0x61, 0x33, 0x37, 0x32, 0x30, 0x62, 0x31, 0x63, 0x35, 0x65, 0x30, 0x32, 0x34, 0x63, 0x33, 0x36, 0x35, 0x37, 0x66, 0x33, 0x31, 0x63, 0x63, 0x66, 0x31, 0x30, 0x37, 0x63, 0x66, 0x35, 0x65, 0x37, 0x62, 0x35, 0x65, 0x66, 0x34, 0x35, 0x38, 0x61, 0x30, 0x39, 0x37, 0x38, 0x65, 0x34, 0x36, 0x39, 0x63, 0x37, 0x30, 0x33, 0x33, 0x35, 0x38, 0x32, 0x64, 0x65, 0x65, 0x31, 0x30, 0x34, 0x63, 0x34, 0x37, 0x62, 0x37, 0x32, 0x34, 0x63, 0x38, 0x65, 0x63, 0x32, 0x36, 0x34, 0x63, 0x35, 0x65, 0x36, 0x39, 0x34, 0x30, 0x38, 0x38, 0x64, 0x66, 0x37, 0x38, 0x35, 0x34, 0x64, 0x33, 0x38, 0x34, 0x33, 0x64, 0x33, 0x61, 0x30, 0x31, 0x36, 0x32, 0x64, 0x39, 0x38, 0x66, 0x65, 0x61, 0x33, 0x63, 0x37, 0x36, 0x61, 0x63, 0x66, 0x37, 0x36, 0x36, 0x38, 0x62, 0x39, 0x62, 0x66, 0x34, 0x65, 0x62, 0x39, 0x38, 0x66, 0x31, 0x39, 0x32, 0x30, 0x31, 0x35, 0x30, 0x61, 0x38, 0x35, 0x35, 0x33, 0x61, 0x66, 0x31, 0x62, 0x34, 0x35, 0x32, 0x33, 0x38, 0x33, 0x34, 0x61, 0x32, 0x62, 0x65, 0x35, 0x62, 0x37, 0x62, 0x35, 0x31, 0x62, 0x61, 0x63, 0x62, 0x38, 0x30, 0x30, 0x62, 0x33, 0x65, 0x64, 0x62, 0x64, 0x66, 0x62, 0x35, 0x38, 0x35, 0x66, 0x64, 0x30, 0x61, 0x64, 0x63, 0x35, 0x37, 0x35, 0x61, 0x62, 0x66, 0x38, 0x37, 0x32, 0x38, 0x33, 0x33, 0x63, 0x35, 0x38, 0x65, 0x32, 0x36, 0x36, 0x63, 0x35, 0x39, 0x66, 0x34, 0x61, 0x37, 0x61, 0x62, 0x35, 0x34, 0x66, 0x38, 0x36, 0x32, 0x64, 0x65, 0x39, 0x31, 0x33, 0x39, 0x38, 0x36, 0x66, 0x36, 0x35, 0x63, 0x38, 0x34, 0x36, 0x61, 0x66, 0x34, 0x66, 0x33, 0x66, 0x37, 0x63, 0x39, 0x39, 0x62, 0x35, 0x33, 0x63, 0x32, 0x32, 0x64, 0x61, 0x65, 0x38, 0x65, 0x31, 0x32, 0x35, 0x35, 0x37, 0x30, 0x30, 0x62, 0x62, 0x34, 0x33, 0x62, 0x39, 0x33, 0x33, 0x61, 0x38, 0x32, 0x30, 0x32, 0x35, 0x61, 0x31, 0x64, 0x35, 0x33, 0x65, 0x64, 0x30, 0x37, 0x61, 0x39, 0x39, 0x32, 0x32, 0x38, 0x36, 0x63, 0x33, 0x39, 0x63, 0x34, 0x32, 0x39, 0x64, 0x33, 0x37, 0x64, 0x64, 0x30, 0x30, 0x30, 0x66, 0x37, 0x65, 0x65, 0x66, 0x31, 0x63, 0x38, 0x36, 0x64, 0x35, 0x65, 0x37, 0x37, 0x32, 0x32, 0x31, 0x38, 0x39, 0x37, 0x39, 0x62, 0x66, 0x31, 0x36, 0x33, 0x39, 0x39, 0x64, 0x34, 0x61, 0x32, 0x61, 0x63, 0x35, 0x30, 0x62, 0x66, 0x65, 0x32, 0x33, 0x34, 0x35, 0x34, 0x35, 0x64, 0x30, 0x37, 0x64, 0x30, 0x62, 0x65, 0x32, 0x33, 0x39, 0x30, 0x65, 0x37, 0x39, 0x62, 0x39, 0x62, 0x39, 0x65, 0x38, 0x64, 0x33, 0x31, 0x35, 0x66, 0x33, 0x33, 0x30, 0x64, 0x61, 0x34, 0x63, 0x37, 0x32, 0x34, 0x38, 0x31, 0x64, 0x62, 0x63, 0x66, 0x63, 0x39, 0x66, 0x35, 0x66, 0x34, 0x36, 0x35, 0x34, 0x32, 0x61, 0x34, 0x35, 0x61, 0x35, 0x65, 0x32, 0x38, 0x31, 0x65, 0x64, 0x36, 0x37, 0x30, 0x37, 0x30, 0x39, 0x36, 0x63, 0x39, 0x33, 0x39, 0x63, 0x65, 0x35, 0x62, 0x66, 0x34, 0x35, 0x33, 0x39, 0x37, 0x34, 0x30, 0x61, 0x37, 0x64, 0x66, 0x30, 0x33, 0x39, 0x39, 0x32, 0x36, 0x38, 0x37, 0x32, 0x64, 0x37, 0x38, 0x36, 0x37, 0x34, 0x31, 0x36, 0x37, 0x39, 0x33, 0x64, 0x31, 0x30, 0x61, 0x62, 0x31, 0x65, 0x61, 0x31, 0x36, 0x31, 0x61, 0x33, 0x63, 0x38, 0x31, 0x39, 0x37, 0x39, 0x38, 0x66, 0x30, 0x32, 0x63, 0x34, 0x65, 0x34, 0x61, 0x34, 0x39, 0x37, 0x66, 0x33, 0x34, 0x38, 0x64, 0x38, 0x31, 0x61, 0x33, 0x34, 0x38, 0x34, 0x36, 0x32, 0x35, 0x66, 0x34, 0x33, 0x34, 0x36, 0x37, 0x32, 0x63, 0x30, 0x30, 0x61, 0x37, 0x32, 0x35, 0x39, 0x37, 0x32, 0x31, 0x35, 0x63, 0x35, 0x30, 0x30, 0x33, 0x39, 0x61, 0x62, 0x33, 0x36, 0x31, 0x30, 0x32, 0x36, 0x62, 0x39, 0x37, 0x62, 0x38, 0x38, 0x61, 0x66, 0x61, 0x39, 0x39, 0x32, 0x35, 0x34, 0x38, 0x37, 0x35, 0x37, 0x36, 0x62, 0x30, 0x34, 0x37, 0x62, 0x63, 0x66, 0x37, 0x32, 0x31, 0x36, 0x63, 0x32, 0x39, 0x33, 0x35, 0x38, 0x37, 0x32, 0x62, 0x65, 0x39, 0x61, 0x38, 0x62, 0x64, 0x33, 0x33, 0x62, 0x30, 0x62, 0x36, 0x34, 0x36, 0x65, 0x66, 0x65, 0x31, 0x38, 0x36, 0x35, 0x39, 0x38, 0x35, 0x62, 0x39, 0x64, 0x63, 0x31, 0x32, 0x62, 0x66, 0x63, 0x30, 0x64, 0x62, 0x30, 0x63, 0x34, 0x33, 0x62, 0x36, 0x33, 0x61, 0x32, 0x61, 0x35, 0x66, 0x30, 0x64, 0x66, 0x37, 0x62, 0x33, 0x37, 0x66, 0x33, 0x31, 0x64, 0x35, 0x36, 0x37, 0x32, 0x36, 0x62, 0x34, 0x65, 0x31, 0x32, 0x35, 0x61, 0x31, 0x66, 0x62, 0x38, 0x34, 0x38, 0x38, 0x37, 0x31, 0x39, 0x35, 0x65, 0x62, 0x34, 0x35, 0x39, 0x31, 0x61, 0x33, 0x62, 0x38, 0x38, 0x64, 0x33, 0x38, 0x32, 0x32, 0x30, 0x37, 0x32, 0x32, 0x39, 0x33, 0x39, 0x39, 0x36, 0x31, 0x30, 0x32, 0x35, 0x31, 0x34, 0x66, 0x33, 0x31, 0x35, 0x62, 0x36, 0x64, 0x31, 0x64, 0x65, 0x64, 0x38, 0x32, 0x35, 0x66, 0x37, 0x66, 0x30, 0x36, 0x66, 0x39, 0x34, 0x32, 0x31, 0x39, 0x37, 0x38, 0x64, 0x35, 0x39, 0x38, 0x31, 0x66, 0x61, 0x66, 0x34, 0x66, 0x35, 0x66, 0x34, 0x64, 0x35, 0x32, 0x34, 0x38, 0x38, 0x64, 0x32, 0x31, 0x66, 0x66, 0x63, 0x66, 0x66, 0x36, 0x62, 0x31, 0x34, 0x62, 0x30, 0x34, 0x38, 0x37, 0x30, 0x36, 0x34, 0x32, 0x62, 0x62, 0x66, 0x35, 0x30, 0x65, 0x63, 0x63, 0x66, 0x35, 0x66, 0x64, 0x38, 0x32, 0x34, 0x61, 0x36, 0x34, 0x38, 0x30, 0x32, 0x37, 0x32, 0x35, 0x31, 0x66, 0x39, 0x34, 0x62, 0x63, 0x36, 0x62, 0x32, 0x30, 0x64, 0x33, 0x39, 0x36, 0x66, 0x35, 0x30, 0x39, 0x32, 0x63, 0x34, 0x34, 0x66, 0x32, 0x32, 0x63, 0x34, 0x31, 0x62, 0x66, 0x30, 0x38, 0x31, 0x63, 0x39, 0x62, 0x38, 0x62, 0x32, 0x35, 0x33, 0x61, 0x37, 0x65, 0x33, 0x39, 0x61, 0x37, 0x39, 0x37, 0x32, 0x64, 0x62, 0x36, 0x61, 0x62, 0x61, 0x37, 0x62, 0x66, 0x65, 0x35, 0x66, 0x61, 0x61, 0x31, 0x34, 0x33, 0x31, 0x31, 0x61, 0x30, 0x30, 0x33, 0x64, 0x65, 0x64, 0x32, 0x37, 0x65, 0x36, 0x61, 0x35, 0x30, 0x31, 0x63, 0x39, 0x39, 0x62, 0x37, 0x66, 0x31, 0x33, 0x37, 0x63, 0x33, 0x36, 0x34, 0x35, 0x36, 0x32, 0x65, 0x34, 0x64, 0x35, 0x62, 0x34, 0x65, 0x34, 0x30, 0x39, 0x30, 0x64, 0x37, 0x32, 0x39, 0x30, 0x61, 0x39, 0x34, 0x66, 0x34, 0x61, 0x66, 0x62, 0x33, 0x35, 0x35, 0x39, 0x39, 0x39, 0x37, 0x65, 0x34, 0x36, 0x37, 0x36, 0x63, 0x32, 0x31, 0x34, 0x66, 0x34, 0x37, 0x63, 0x34, 0x32, 0x63, 0x65, 0x63, 0x38, 0x66, 0x31, 0x65, 0x64, 0x35, 0x33, 0x39, 0x38, 0x31, 0x37, 0x62, 0x30, 0x37, 0x36, 0x39, 0x33, 0x34, 0x63, 0x63, 0x30, 0x35, 0x30, 0x30, 0x33, 0x37, 0x63, 0x37, 0x32, 0x39, 0x34, 0x30, 0x33, 0x34, 0x34, 0x33, 0x35, 0x61, 0x61, 0x34, 0x37, 0x36, 0x37, 0x38, 0x66, 0x66, 0x66, 0x39, 0x66, 0x31, 0x35, 0x36, 0x36, 0x37, 0x35, 0x61, 0x38, 0x34, 0x35, 0x65, 0x66, 0x33, 0x62, 0x62, 0x35, 0x30, 0x65, 0x35, 0x63, 0x66, 0x36, 0x33, 0x39, 0x34, 0x36, 0x64, 0x36, 0x62, 0x30, 0x65, 0x35, 0x33, 0x63, 0x30, 0x39, 0x63, 0x61, 0x63, 0x65, 0x30, 0x30, 0x37, 0x32, 0x31, 0x34, 0x64, 0x66, 0x63, 0x66, 0x30, 0x65, 0x66, 0x30, 0x36, 0x32, 0x35, 0x65, 0x31, 0x61, 0x66, 0x34, 0x33, 0x39, 0x32, 0x36, 0x37, 0x35, 0x32, 0x62, 0x37, 0x37, 0x32, 0x30, 0x32, 0x37, 0x39, 0x37, 0x34, 0x39, 0x37, 0x34, 0x38, 0x66, 0x33, 0x36, 0x65, 0x38, 0x34, 0x30, 0x39, 0x61, 0x62, 0x63, 0x37, 0x32, 0x39, 0x62, 0x64, 0x31, 0x61, 0x31, 0x62, 0x39, 0x61, 0x65, 0x30, 0x36, 0x64, 0x61, 0x65, 0x63, 0x39, 0x65, 0x61, 0x35, 0x36, 0x34, 0x65, 0x34, 0x65, 0x64, 0x33, 0x30, 0x31, 0x61, 0x37, 0x37, 0x65, 0x64, 0x37, 0x63, 0x33, 0x33, 0x39, 0x31, 0x31, 0x65, 0x63, 0x30, 0x34, 0x34, 0x64, 0x38, 0x32, 0x65, 0x39, 0x63, 0x34, 0x32, 0x39, 0x36, 0x63, 0x63, 0x31, 0x37, 0x33, 0x63, 0x30, 0x66, 0x30, 0x31, 0x32, 0x39, 0x38, 0x35, 0x30, 0x36, 0x63, 0x39, 0x37, 0x32, 0x65, 0x63, 0x63, 0x37, 0x39, 0x30, 0x65, 0x62, 0x30, 0x61, 0x36, 0x33, 0x66, 0x61, 0x62, 0x61, 0x37, 0x34, 0x61, 0x64, 0x62, 0x31, 0x66, 0x37, 0x37, 0x66, 0x61, 0x36, 0x34, 0x30, 0x36, 0x38, 0x65, 0x62, 0x61, 0x62, 0x38, 0x65, 0x33, 0x63, 0x39, 0x38, 0x34, 0x30, 0x62, 0x65, 0x37, 0x34, 0x32, 0x37, 0x34, 0x33, 0x37, 0x34, 0x61, 0x66, 0x30, 0x32, 0x35, 0x30, 0x66, 0x33, 0x37, 0x32, 0x38, 0x64, 0x63, 0x64, 0x34, 0x66, 0x33, 0x35, 0x30, 0x62, 0x35, 0x37, 0x31, 0x33, 0x30, 0x36, 0x32, 0x37, 0x38, 0x63, 0x37, 0x66, 0x62, 0x65, 0x63, 0x63, 0x39, 0x35, 0x63, 0x36, 0x61, 0x39, 0x38, 0x64, 0x37, 0x61, 0x31, 0x36, 0x66, 0x61, 0x65, 0x65, 0x38, 0x35, 0x39, 0x38, 0x38, 0x30, 0x31, 0x64, 0x31, 0x30, 0x31, 0x62, 0x66, 0x30, 0x63, 0x65, 0x39, 0x30, 0x34, 0x37, 0x31, 0x63, 0x31, 0x31, 0x33, 0x65, 0x31, 0x32, 0x32, 0x32, 0x33, 0x36, 0x30, 0x34, 0x65, 0x34, 0x63, 0x64, 0x30, 0x64, 0x33, 0x32, 0x34, 0x64, 0x37, 0x39, 0x36, 0x65, 0x61, 0x35, 0x63, 0x35, 0x32, 0x61, 0x38, 0x37, 0x31, 0x38, 0x34, 0x64, 0x61, 0x34, 0x61, 0x61, 0x61, 0x34, 0x39, 0x30, 0x63, 0x35, 0x66, 0x65, 0x30, 0x38, 0x61, 0x30, 0x30, 0x64, 0x62, 0x66, 0x63, 0x66, 0x66, 0x33, 0x30, 0x32, 0x66, 0x30, 0x63, 0x34, 0x61, 0x39, 0x34, 0x66, 0x66, 0x39, 0x34, 0x66, 0x39, 0x38, 0x65, 0x65, 0x33, 0x62, 0x30, 0x64, 0x61, 0x34, 0x32, 0x35, 0x62, 0x31, 0x33, 0x36, 0x66, 0x62, 0x65, 0x65, 0x38, 0x30, 0x34, 0x30, 0x63, 0x62, 0x63, 0x30, 0x36, 0x37, 0x30, 0x61, 0x36, 0x66, 0x34, 0x32, 0x31, 0x35, 0x30, 0x34, 0x62, 0x32, 0x32, 0x30, 0x35, 0x63, 0x66, 0x66, 0x36, 0x64, 0x34, 0x37, 0x39, 0x37, 0x31, 0x32, 0x34, 0x64, 0x33, 0x33, 0x36, 0x30, 0x33, 0x37, 0x37, 0x30, 0x61, 0x32, 0x64, 0x31, 0x64, 0x39, 0x65, 0x37, 0x39, 0x63, 0x66, 0x65, 0x39, 0x30, 0x66, 0x66, 0x34, 0x33, 0x64, 0x66, 0x39, 0x38, 0x63, 0x62, 0x34, 0x33, 0x65, 0x30, 0x61, 0x64, 0x30, 0x38, 0x35, 0x38, 0x65, 0x31, 0x62, 0x33, 0x39, 0x63, 0x32, 0x62, 0x64, 0x31, 0x37, 0x31, 0x33, 0x64, 0x37, 0x32, 0x31, 0x62, 0x32, 0x32, 0x32, 0x32, 0x66, 0x37, 0x31, 0x61, 0x39, 0x31, 0x65, 0x32, 0x36, 0x63, 0x30, 0x63, 0x37, 0x32, 0x32, 0x61, 0x62, 0x61, 0x39, 0x30, 0x61, 0x32, 0x32, 0x65, 0x64, 0x35, 0x65, 0x66, 0x66, 0x33, 0x33, 0x36, 0x30, 0x31, 0x38, 0x37, 0x34, 0x64, 0x37, 0x62, 0x65, 0x36, 0x30, 0x63, 0x63, 0x36, 0x62, 0x64, 0x66, 0x35, 0x62, 0x39, 0x38, 0x65, 0x30, 0x34, 0x35, 0x62, 0x32, 0x37, 0x34, 0x34, 0x39, 0x36, 0x64, 0x39, 0x35, 0x35, 0x61, 0x66, 0x33, 0x64, 0x62, 0x39, 0x31, 0x39, 0x36, 0x30, 0x31, 0x31, 0x66, 0x65, 0x30, 0x62, 0x63, 0x37, 0x33, 0x64, 0x37, 0x61, 0x64, 0x30, 0x37, 0x37, 0x61, 0x34, 0x33, 0x33, 0x36, 0x38, 0x64, 0x39, 0x32, 0x65, 0x31, 0x66, 0x32, 0x30, 0x65, 0x37, 0x65, 0x32, 0x33, 0x61, 0x34, 0x66, 0x36, 0x30, 0x65, 0x62, 0x35, 0x63, 0x63, 0x37, 0x66, 0x34, 0x32, 0x66, 0x62, 0x31, 0x32, 0x36, 0x62, 0x36, 0x35, 0x39, 0x65, 0x31, 0x34, 0x31, 0x65, 0x63, 0x65, 0x35, 0x63, 0x32, 0x62, 0x63, 0x33, 0x63, 0x39, 0x38, 0x34, 0x66, 0x32, 0x37, 0x37, 0x37, 0x63, 0x38, 0x63, 0x63, 0x66, 0x37, 0x61, 0x63, 0x35, 0x35, 0x63, 0x66, 0x65, 0x38, 0x35, 0x62, 0x65, 0x64, 0x31, 0x39, 0x64, 0x31, 0x35, 0x63, 0x30, 0x34, 0x35, 0x38, 0x32, 0x31, 0x32, 0x62, 0x33, 0x30, 0x34, 0x31, 0x37, 0x61, 0x37, 0x34, 0x62, 0x66, 0x65, 0x31, 0x39, 0x39, 0x34, 0x39, 0x62, 0x63, 0x63, 0x33, 0x66, 0x66, 0x32, 0x62, 0x66, 0x37, 0x30, 0x62, 0x64, 0x30, 0x63, 0x66, 0x62, 0x32, 0x62, 0x39, 0x32, 0x64, 0x66, 0x38, 0x38, 0x62, 0x36, 0x32, 0x37, 0x63, 0x30, 0x38, 0x36, 0x64, 0x38, 0x31, 0x34, 0x65, 0x63, 0x65, 0x34, 0x61, 0x37, 0x32, 0x63, 0x34, 0x37, 0x62, 0x30, 0x34, 0x31, 0x62, 0x62, 0x63, 0x30, 0x37, 0x34, 0x30, 0x61, 0x32, 0x35, 0x35, 0x64, 0x39, 0x38, 0x34, 0x65, 0x37, 0x32, 0x39, 0x63, 0x62, 0x36, 0x64, 0x62, 0x31, 0x35, 0x35, 0x31, 0x63, 0x62, 0x65, 0x66, 0x65, 0x64, 0x37, 0x62, 0x33, 0x31, 0x65, 0x32, 0x66, 0x64, 0x35, 0x61, 0x36, 0x37, 0x33, 0x34, 0x30, 0x31, 0x62, 0x63, 0x32, 0x34, 0x65, 0x35, 0x33, 0x65, 0x35, 0x39, 0x34, 0x33, 0x33, 0x62, 0x63, 0x64, 0x64, 0x62, 0x34, 0x66, 0x64, 0x36, 0x36, 0x39, 0x66, 0x30, 0x35, 0x36, 0x64, 0x34, 0x33, 0x37, 0x64, 0x31, 0x63, 0x33, 0x61, 0x32, 0x36, 0x34, 0x34, 0x63, 0x37, 0x35, 0x64, 0x33, 0x66, 0x63, 0x37, 0x62, 0x66, 0x65, 0x31, 0x35, 0x31, 0x31, 0x63, 0x34, 0x33, 0x63, 0x66, 0x39, 0x62, 0x35, 0x63, 0x36, 0x62, 0x35, 0x64, 0x34, 0x35, 0x34, 0x66, 0x63, 0x37, 0x66, 0x36, 0x65, 0x63, 0x33, 0x38, 0x35, 0x32, 0x64, 0x63, 0x34, 0x63, 0x32, 0x66, 0x33, 0x38, 0x62, 0x37, 0x34, 0x32, 0x66, 0x39, 0x34, 0x35, 0x39, 0x38, 0x63, 0x39, 0x32, 0x36, 0x37, 0x62, 0x38, 0x64, 0x35, 0x32, 0x34, 0x33, 0x34, 0x66, 0x33, 0x34, 0x64, 0x38, 0x38, 0x64, 0x36, 0x36, 0x33, 0x39, 0x62, 0x36, 0x66, 0x38, 0x35, 0x38, 0x34, 0x63, 0x35, 0x63, 0x34, 0x66, 0x33, 0x63, 0x63, 0x30, 0x30, 0x61, 0x30, 0x31, 0x66, 0x63, 0x63, 0x62, 0x33, 0x31, 0x65, 0x66, 0x65, 0x30, 0x39, 0x31, 0x33, 0x34, 0x62, 0x62, 0x32, 0x65, 0x63, 0x66, 0x32, 0x30, 0x61, 0x65, 0x36, 0x64, 0x33, 0x35, 0x61, 0x35, 0x63, 0x30, 0x39, 0x62, 0x62, 0x30, 0x37, 0x36, 0x65, 0x61, 0x37, 0x38, 0x63, 0x31, 0x38, 0x30, 0x32, 0x34, 0x33, 0x34, 0x62, 0x62, 0x37, 0x32, 0x63, 0x65, 0x37, 0x61, 0x37, 0x65, 0x65, 0x30, 0x61, 0x66, 0x66, 0x34, 0x64, 0x35, 0x38, 0x62, 0x34, 0x34, 0x39, 0x34, 0x64, 0x39, 0x32, 0x37, 0x33, 0x36, 0x31, 0x34, 0x66, 0x65, 0x30, 0x35, 0x34, 0x61, 0x66, 0x35, 0x63, 0x62, 0x62, 0x33, 0x65, 0x64, 0x63, 0x64, 0x63, 0x65, 0x31, 0x30, 0x63, 0x33, 0x64, 0x66, 0x34, 0x30, 0x32, 0x32, 0x30, 0x39, 0x66, 0x64, 0x30, 0x66, 0x34, 0x32, 0x33, 0x36, 0x34, 0x61, 0x32, 0x61, 0x63, 0x65, 0x66, 0x39, 0x61, 0x62, 0x36, 0x33, 0x33, 0x63, 0x65, 0x34, 0x62, 0x65, 0x66, 0x63, 0x36, 0x66, 0x63, 0x65, 0x31, 0x35, 0x32, 0x34, 0x34, 0x33, 0x65, 0x33, 0x36, 0x63, 0x39, 0x32, 0x66, 0x38, 0x35, 0x33, 0x64, 0x62, 0x35, 0x35, 0x38, 0x33, 0x66, 0x39, 0x61, 0x32, 0x37, 0x33, 0x64, 0x65, 0x39, 0x37, 0x36, 0x38, 0x35, 0x61, 0x37, 0x32, 0x35, 0x31, 0x62, 0x39, 0x34, 0x62, 0x37, 0x63, 0x33, 0x61, 0x36, 0x34, 0x37, 0x36, 0x61, 0x31, 0x61, 0x30, 0x36, 0x33, 0x65, 0x38, 0x30, 0x31, 0x64, 0x33, 0x34, 0x64, 0x66, 0x37, 0x66, 0x34, 0x33, 0x38, 0x32, 0x33, 0x31, 0x35, 0x30, 0x63, 0x64, 0x32, 0x63, 0x34, 0x33, 0x33, 0x38, 0x30, 0x33, 0x62, 0x38, 0x63, 0x31, 0x30, 0x34, 0x64, 0x38, 0x38, 0x36, 0x39, 0x30, 0x61, 0x37, 0x32, 0x31, 0x35, 0x39, 0x61, 0x32, 0x63, 0x64, 0x30, 0x37, 0x63, 0x62, 0x63, 0x39, 0x33, 0x35, 0x66, 0x30, 0x61, 0x63, 0x36, 0x63, 0x33, 0x64, 0x33, 0x32, 0x31, 0x33, 0x62, 0x66, 0x65, 0x39, 0x31, 0x39, 0x38, 0x31, 0x38, 0x30, 0x38, 0x63, 0x32, 0x63, 0x39, 0x32, 0x32, 0x34, 0x30, 0x62, 0x66, 0x66, 0x34, 0x30, 0x32, 0x32, 0x31, 0x35, 0x38, 0x37, 0x62, 0x31, 0x63, 0x66, 0x34, 0x37, 0x32, 0x66, 0x38, 0x35, 0x65, 0x33, 0x32, 0x63, 0x65, 0x36, 0x64, 0x30, 0x39, 0x33, 0x31, 0x31, 0x37, 0x36, 0x37, 0x32, 0x65, 0x34, 0x66, 0x63, 0x34, 0x31, 0x64, 0x66, 0x61, 0x64, 0x36, 0x65, 0x37, 0x39, 0x65, 0x34, 0x31, 0x33, 0x64, 0x33, 0x66, 0x30, 0x37, 0x38, 0x30, 0x34, 0x37, 0x38, 0x64, 0x66, 0x63, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35, 0x64, 0x39, 0x33, 0x65, 0x39, 0x63, 0x37, 0x32, 0x66, 0x37, 0x36, 0x34, 0x34, 0x37, 0x66, 0x36, 0x62, 0x63, 0x33, 0x32, 0x33, 0x66, 0x66, 0x66, 0x62, 0x61, 0x61, 0x37, 0x39, 0x38, 0x33, 0x65, 0x63, 0x63, 0x30, 0x37, 0x61, 0x36, 0x65, 0x36, 0x31, 0x34, 0x63, 0x30, 0x61, 0x31, 0x62, 0x31, 0x38, 0x30, 0x65, 0x65, 0x34, 0x31, 0x64, 0x66, 0x63, 0x62, 0x35, 0x65, 0x63, 0x31, 0x66, 0x62, 0x63, 0x65, 0x32, 0x63, 0x65, 0x34, 0x30, 0x62, 0x61, 0x65, 0x39, 0x36, 0x38, 0x33, 0x30, 0x30, 0x35, 0x36, 0x31, 0x61, 0x31, 0x66, 0x31, 0x33, 0x66, 0x62, 0x35, 0x65, 0x63, 0x64, 0x35, 0x31, 0x62, 0x39, 0x61, 0x62, 0x33, 0x30, 0x66, 0x37, 0x64, 0x65, 0x34, 0x35, 0x65, 0x64, 0x35, 0x36, 0x31, 0x65, 0x37, 0x38, 0x66, 0x32, 0x61, 0x32, 0x30, 0x66, 0x31, 0x65, 0x31, 0x35, 0x34, 0x33, 0x65, 0x37, 0x32, 0x66, 0x32, 0x35, 0x37, 0x32, 0x33, 0x64, 0x65, 0x38, 0x37, 0x62, 0x33, 0x64, 0x33, 0x39, 0x34, 0x38, 0x30, 0x63, 0x35, 0x35, 0x39, 0x30, 0x65, 0x62, 0x66, 0x37, 0x66, 0x61, 0x32, 0x31, 0x66, 0x34, 0x39, 0x34, 0x39, 0x31, 0x35, 0x37, 0x36, 0x36, 0x37, 0x32, 0x36, 0x37, 0x34, 0x38, 0x33, 0x33, 0x33, 0x35, 0x31, 0x32, 0x63, 0x61, 0x35, 0x33, 0x32, 0x64, 0x64, 0x38, 0x39, 0x61, 0x31, 0x35, 0x66, 0x62, 0x30, 0x39, 0x66, 0x36, 0x32, 0x64, 0x36, 0x32, 0x34, 0x65, 0x39, 0x35, 0x65, 0x61, 0x65, 0x33, 0x37, 0x32, 0x30, 0x36, 0x35, 0x36, 0x61, 0x37, 0x39, 0x65, 0x62, 0x38, 0x31, 0x34, 0x61, 0x63, 0x39, 0x36, 0x62, 0x62, 0x62, 0x37, 0x39, 0x63, 0x33, 0x39, 0x30, 0x39, 0x32, 0x35, 0x31, 0x32, 0x30, 0x35, 0x64, 0x34, 0x32, 0x37, 0x35, 0x34, 0x32, 0x62, 0x30, 0x64, 0x33, 0x66, 0x39, 0x62, 0x31, 0x61, 0x65, 0x33, 0x39, 0x64, 0x37, 0x31, 0x31, 0x63, 0x31, 0x32, 0x34, 0x33, 0x34, 0x31, 0x32, 0x62, 0x64, 0x34, 0x39, 0x34, 0x38, 0x64, 0x62, 0x65, 0x32, 0x36, 0x34, 0x63, 0x66, 0x64, 0x62, 0x62, 0x66, 0x65, 0x30, 0x66, 0x63, 0x30, 0x33, 0x62, 0x37, 0x32, 0x35, 0x35, 0x38, 0x32, 0x66, 0x65, 0x64, 0x34, 0x36, 0x32, 0x62, 0x33, 0x38, 0x36, 0x63, 0x65, 0x61, 0x63, 0x38, 0x64, 0x37, 0x32, 0x39, 0x62, 0x65, 0x34, 0x65, 0x62, 0x62, 0x38, 0x66, 0x39, 0x32, 0x63, 0x37, 0x64, 0x34, 0x66, 0x39, 0x34, 0x32, 0x37, 0x39, 0x66, 0x38, 0x66, 0x34, 0x36, 0x65, 0x32, 0x66, 0x63, 0x30, 0x61, 0x31, 0x63, 0x37, 0x36, 0x37, 0x31, 0x32, 0x62, 0x66, 0x62, 0x39, 0x65, 0x63, 0x34, 0x65, 0x64, 0x61, 0x37, 0x38, 0x39, 0x31, 0x62, 0x36, 0x62, 0x65, 0x63, 0x32, 0x35, 0x30, 0x64, 0x37, 0x32, 0x30, 0x34, 0x64, 0x63, 0x33, 0x32, 0x66, 0x61, 0x34, 0x33, 0x30, 0x31, 0x32, 0x32, 0x31, 0x39, 0x37, 0x34, 0x30, 0x66, 0x61, 0x61, 0x37, 0x31, 0x39, 0x38, 0x37, 0x62, 0x30, 0x65, 0x33, 0x39, 0x31, 0x33, 0x34, 0x36, 0x66, 0x63, 0x36, 0x33, 0x37, 0x37, 0x63, 0x64, 0x31, 0x63, 0x65, 0x35, 0x64, 0x65, 0x38, 0x65, 0x38, 0x34, 0x33, 0x64, 0x65, 0x62, 0x34, 0x61, 0x30, 0x64, 0x35, 0x64, 0x36, 0x30, 0x30, 0x65, 0x62, 0x31, 0x36, 0x34, 0x63, 0x32, 0x34, 0x66, 0x64, 0x36, 0x36, 0x33, 0x39, 0x61, 0x31, 0x36, 0x36, 0x35, 0x31, 0x34, 0x35, 0x62, 0x61, 0x33, 0x61, 0x33, 0x31, 0x64, 0x35, 0x33, 0x31, 0x63, 0x30, 0x35, 0x61, 0x63, 0x31, 0x65, 0x65, 0x65, 0x61, 0x63, 0x64, 0x65, 0x62, 0x66, 0x62, 0x39, 0x63, 0x37, 0x63, 0x35, 0x38, 0x61, 0x33, 0x61, 0x66, 0x63, 0x32, 0x62, 0x37, 0x33, 0x36, 0x65, 0x35, 0x34, 0x62, 0x61, 0x35, 0x32, 0x30, 0x34, 0x64, 0x37, 0x66, 0x38, 0x64, 0x39, 0x34, 0x36, 0x64, 0x62, 0x33, 0x61, 0x64, 0x38, 0x39, 0x62, 0x63, 0x63, 0x38, 0x62, 0x30, 0x65, 0x34, 0x63, 0x30, 0x30, 0x66, 0x38, 0x30, 0x33, 0x37, 0x63, 0x63, 0x34, 0x62, 0x39, 0x37, 0x37, 0x63, 0x30, 0x30, 0x66, 0x39, 0x34, 0x62, 0x32, 0x62, 0x36, 0x30, 0x63, 0x37, 0x32, 0x33, 0x36, 0x31, 0x38, 0x66, 0x33, 0x66, 0x31, 0x63, 0x33, 0x33, 0x63, 0x31, 0x32, 0x31, 0x62, 0x32, 0x38, 0x35, 0x32, 0x30, 0x66, 0x65, 0x35, 0x66, 0x61, 0x62, 0x37, 0x66, 0x62, 0x63, 0x65, 0x65, 0x61, 0x33, 0x38, 0x65, 0x37, 0x61, 0x38, 0x63, 0x33, 0x34, 0x33, 0x32, 0x39, 0x35, 0x38, 0x63, 0x38, 0x61, 0x33, 0x31, 0x31, 0x61, 0x61, 0x38, 0x39, 0x30, 0x31, 0x35, 0x30, 0x36, 0x37, 0x35, 0x32, 0x65, 0x37, 0x61, 0x31, 0x62, 0x61, 0x64, 0x31, 0x37, 0x63, 0x35, 0x37, 0x37, 0x61, 0x65, 0x38, 0x35, 0x39, 0x31, 0x65, 0x62, 0x32, 0x36, 0x63, 0x33, 0x33, 0x62, 0x65, 0x61, 0x37, 0x37, 0x38, 0x61, 0x65, 0x63, 0x36, 0x35, 0x31, 0x36, 0x37, 0x33, 0x33, 0x34, 0x62, 0x66, 0x64, 0x30, 0x38, 0x39, 0x31, 0x39, 0x30, 0x36, 0x36, 0x34, 0x36, 0x62, 0x61, 0x66, 0x32, 0x37, 0x32, 0x35, 0x66, 0x30, 0x33, 0x62, 0x38, 0x33, 0x63, 0x33, 0x65, 0x31, 0x66, 0x31, 0x39, 0x66, 0x34, 0x37, 0x66, 0x39, 0x36, 0x62, 0x37, 0x62, 0x39, 0x63, 0x34, 0x35, 0x39, 0x66, 0x61, 0x37, 0x30, 0x36, 0x38, 0x37, 0x34, 0x33, 0x34, 0x65, 0x31, 0x39, 0x39, 0x64, 0x32, 0x31, 0x33, 0x39, 0x36, 0x38, 0x30, 0x38, 0x36, 0x64, 0x34, 0x64, 0x39, 0x64, 0x34, 0x31, 0x34, 0x39, 0x30, 0x30, 0x39, 0x32, 0x37, 0x31, 0x33, 0x38, 0x62, 0x31, 0x61, 0x32, 0x61, 0x66, 0x33, 0x36, 0x65, 0x33, 0x38, 0x37, 0x33, 0x31, 0x35, 0x37, 0x63, 0x63, 0x65, 0x31, 0x63, 0x62, 0x63, 0x65, 0x61, 0x31, 0x66, 0x30, 0x61, 0x66, 0x63, 0x38, 0x65, 0x30, 0x37, 0x36, 0x39, 0x31, 0x66, 0x37, 0x31, 0x64, 0x61, 0x64, 0x35, 0x33, 0x66, 0x36, 0x36, 0x30, 0x64, 0x37, 0x63, 0x65, 0x65, 0x38, 0x31, 0x37, 0x32, 0x31, 0x36, 0x37, 0x33, 0x34, 0x38, 0x61, 0x31, 0x31, 0x62, 0x36, 0x62, 0x37, 0x31, 0x61, 0x39, 0x62, 0x62, 0x32, 0x38, 0x31, 0x37, 0x30, 0x32, 0x35, 0x32, 0x36, 0x63, 0x66, 0x38, 0x32, 0x66, 0x64, 0x65, 0x37, 0x30, 0x34, 0x31, 0x62, 0x62, 0x65, 0x31, 0x30, 0x38, 0x63, 0x39, 0x33, 0x34, 0x63, 0x32, 0x35, 0x63, 0x64, 0x32, 0x33, 0x37, 0x63, 0x35, 0x64, 0x39, 0x64, 0x33, 0x31, 0x31, 0x61, 0x36, 0x63, 0x35, 0x34, 0x61, 0x32, 0x34, 0x66, 0x34, 0x61, 0x36, 0x35, 0x39, 0x65, 0x30, 0x64, 0x63, 0x66, 0x30, 0x65, 0x32, 0x39, 0x39, 0x35, 0x38, 0x31, 0x64, 0x32, 0x33, 0x62, 0x63, 0x62, 0x37, 0x32, 0x37, 0x32, 0x37, 0x34, 0x64, 0x34, 0x62, 0x65, 0x31, 0x39, 0x64, 0x66, 0x30, 0x64, 0x63, 0x63, 0x35, 0x33, 0x36, 0x62, 0x30, 0x39, 0x37, 0x64, 0x39, 0x32, 0x35, 0x32, 0x31, 0x35, 0x36, 0x35, 0x62, 0x36, 0x62, 0x34, 0x30, 0x64, 0x62, 0x36, 0x62, 0x63, 0x38, 0x37, 0x37, 0x65, 0x38, 0x36, 0x64, 0x65, 0x38, 0x37, 0x39, 0x61, 0x66, 0x36, 0x31, 0x34, 0x65, 0x65, 0x65, 0x30, 0x64, 0x63, 0x62, 0x66, 0x65, 0x34, 0x35, 0x30, 0x39, 0x61, 0x39, 0x35, 0x33, 0x36, 0x36, 0x63, 0x38, 0x62, 0x30, 0x66, 0x33, 0x32, 0x36, 0x34, 0x34, 0x36, 0x37, 0x63, 0x64, 0x37, 0x32, 0x65, 0x62, 0x64, 0x38, 0x31, 0x33, 0x63, 0x61, 0x31, 0x64, 0x39, 0x34, 0x30, 0x31, 0x65, 0x36, 0x63, 0x37, 0x63, 0x63, 0x35, 0x32, 0x61, 0x34, 0x36, 0x38, 0x31, 0x30, 0x62, 0x61, 0x62, 0x65, 0x34, 0x62, 0x37, 0x64, 0x34, 0x61, 0x30, 0x65, 0x61, 0x61, 0x35, 0x61, 0x66, 0x35, 0x30, 0x33, 0x36, 0x33, 0x33, 0x62, 0x66, 0x37, 0x33, 0x33, 0x33, 0x31, 0x61, 0x31, 0x65, 0x35, 0x37, 0x32, 0x30, 0x30, 0x65, 0x64, 0x38, 0x35, 0x61, 0x34, 0x33, 0x33, 0x39, 0x61, 0x66, 0x62, 0x64, 0x34, 0x34, 0x62, 0x64, 0x39, 0x31, 0x63, 0x61, 0x63, 0x30, 0x31, 0x66, 0x32, 0x32, 0x65, 0x36, 0x33, 0x62, 0x38, 0x37, 0x33, 0x65, 0x33, 0x36, 0x33, 0x31, 0x33, 0x33, 0x37, 0x35, 0x62, 0x37, 0x32, 0x62, 0x32, 0x38, 0x39, 0x37, 0x39, 0x31, 0x32, 0x31, 0x32, 0x37, 0x61, 0x31, 0x62, 0x35, 0x63, 0x33, 0x33, 0x65, 0x61, 0x38, 0x36, 0x36, 0x61, 0x65, 0x38, 0x64, 0x36, 0x31, 0x65, 0x66, 0x30, 0x36, 0x35, 0x33, 0x65, 0x34, 0x37, 0x36, 0x37, 0x33, 0x66, 0x31, 0x35, 0x64, 0x62, 0x32, 0x36, 0x38, 0x38, 0x38, 0x32, 0x65, 0x30, 0x63, 0x65, 0x33, 0x65, 0x63, 0x36, 0x65, 0x36, 0x63, 0x65, 0x37, 0x64, 0x30, 0x64, 0x61, 0x36, 0x65, 0x31, 0x61, 0x39, 0x62, 0x39, 0x31, 0x37, 0x32, 0x35, 0x65, 0x32, 0x31, 0x35, 0x38, 0x32, 0x64, 0x36, 0x61, 0x30, 0x39, 0x32, 0x64, 0x38, 0x33, 0x63, 0x33, 0x65, 0x38, 0x34, 0x31, 0x62, 0x37, 0x38, 0x61, 0x30, 0x62, 0x66, 0x36, 0x33, 0x39, 0x66, 0x63, 0x38, 0x33, 0x64, 0x33, 0x61, 0x61, 0x30, 0x38, 0x31, 0x38, 0x33, 0x35, 0x63, 0x39, 0x36, 0x35, 0x31, 0x39, 0x65, 0x39, 0x64, 0x65, 0x62, 0x36, 0x63, 0x64, 0x31, 0x31, 0x62, 0x37, 0x32, 0x36, 0x63, 0x33, 0x63, 0x63, 0x32, 0x39, 0x61, 0x31, 0x32, 0x66, 0x37, 0x66, 0x62, 0x37, 0x32, 0x36, 0x35, 0x65, 0x33, 0x30, 0x66, 0x62, 0x65, 0x33, 0x65, 0x39, 0x36, 0x33, 0x64, 0x35, 0x63, 0x35, 0x33, 0x61, 0x30, 0x34, 0x38, 0x61, 0x33, 0x38, 0x35, 0x66, 0x30, 0x62, 0x64, 0x37, 0x30, 0x32, 0x62, 0x35, 0x65, 0x66, 0x35, 0x31, 0x66, 0x31, 0x66, 0x35, 0x39, 0x66, 0x34, 0x37, 0x32, 0x36, 0x30, 0x63, 0x32, 0x66, 0x63, 0x39, 0x38, 0x37, 0x31, 0x66, 0x36, 0x36, 0x38, 0x34, 0x38, 0x65, 0x36, 0x63, 0x32, 0x61, 0x38, 0x32, 0x32, 0x31, 0x31, 0x33, 0x34, 0x66, 0x64, 0x63, 0x38, 0x66, 0x62, 0x33, 0x39, 0x62, 0x66, 0x65, 0x64, 0x39, 0x34, 0x61, 0x31, 0x31, 0x62, 0x61, 0x34, 0x36, 0x34, 0x35, 0x66, 0x65, 0x61, 0x62, 0x30, 0x64, 0x61, 0x35, 0x33, 0x61, 0x35, 0x37, 0x32, 0x64, 0x66, 0x33, 0x61, 0x35, 0x63, 0x33, 0x62, 0x39, 0x35, 0x66, 0x37, 0x61, 0x37, 0x65, 0x63, 0x33, 0x30, 0x61, 0x34, 0x33, 0x30, 0x33, 0x34, 0x37, 0x34, 0x63, 0x32, 0x31, 0x64, 0x63, 0x66, 0x31, 0x31, 0x32, 0x34, 0x39, 0x62, 0x36, 0x65, 0x62, 0x30, 0x36, 0x38, 0x32, 0x66, 0x62, 0x34, 0x39, 0x32, 0x35, 0x39, 0x32, 0x64, 0x31, 0x36, 0x65, 0x62, 0x35, 0x36, 0x31, 0x61, 0x37, 0x32, 0x36, 0x35, 0x34, 0x37, 0x64, 0x66, 0x65, 0x61, 0x38, 0x36, 0x36, 0x39, 0x35, 0x63, 0x66, 0x35, 0x33, 0x61, 0x37, 0x65, 0x35, 0x35, 0x63, 0x35, 0x38, 0x32, 0x61, 0x31, 0x31, 0x61, 0x32, 0x64, 0x64, 0x37, 0x34, 0x33, 0x35, 0x30, 0x66, 0x32, 0x65, 0x66, 0x33, 0x34, 0x65, 0x38, 0x38, 0x66, 0x33, 0x39, 0x65, 0x35, 0x35, 0x64, 0x34, 0x33, 0x32, 0x31, 0x66, 0x30, 0x38, 0x38, 0x33, 0x31, 0x37, 0x66, 0x35, 0x36, 0x63, 0x66, 0x35, 0x63, 0x38, 0x37, 0x65, 0x65, 0x61, 0x63, 0x33, 0x64, 0x65, 0x34, 0x39, 0x38, 0x30, 0x36, 0x30, 0x32, 0x65, 0x36, 0x39, 0x64, 0x64, 0x33, 0x62, 0x62, 0x35, 0x35, 0x63, 0x64, 0x37, 0x31, 0x64, 0x35, 0x66, 0x35, 0x37, 0x34, 0x61, 0x36, 0x38, 0x31, 0x62, 0x63, 0x30, 0x39, 0x39, 0x64, 0x36, 0x62, 0x31, 0x63, 0x39, 0x33, 0x39, 0x32, 0x37, 0x32, 0x35, 0x33, 0x37, 0x37, 0x31, 0x30, 0x39, 0x35, 0x36, 0x66, 0x65, 0x65, 0x32, 0x34, 0x61, 0x61, 0x34, 0x62, 0x33, 0x33, 0x62, 0x62, 0x39, 0x38, 0x65, 0x31, 0x32, 0x65, 0x65, 0x66, 0x65, 0x63, 0x30, 0x61, 0x64, 0x61, 0x39, 0x31, 0x37, 0x66, 0x62, 0x65, 0x35, 0x33, 0x32, 0x32, 0x64, 0x64, 0x30, 0x38, 0x35, 0x65, 0x63, 0x32, 0x64, 0x33, 0x62, 0x39, 0x61, 0x37, 0x37, 0x39, 0x37, 0x32, 0x63, 0x30, 0x65, 0x33, 0x63, 0x37, 0x35, 0x39, 0x38, 0x66, 0x33, 0x34, 0x36, 0x63, 0x61, 0x34, 0x65, 0x39, 0x64, 0x31, 0x37, 0x33, 0x34, 0x34, 0x30, 0x61, 0x65, 0x31, 0x62, 0x33, 0x36, 0x63, 0x30, 0x31, 0x66, 0x32, 0x31, 0x32, 0x63, 0x66, 0x38, 0x38, 0x35, 0x32, 0x30, 0x66, 0x66, 0x35, 0x33, 0x63, 0x66, 0x66, 0x65, 0x38, 0x63, 0x34, 0x35, 0x66, 0x65, 0x62, 0x37, 0x39, 0x37, 0x32, 0x61, 0x63, 0x33, 0x33, 0x64, 0x34, 0x62, 0x30, 0x62, 0x66, 0x31, 0x35, 0x37, 0x39, 0x62, 0x63, 0x36, 0x66, 0x38, 0x37, 0x34, 0x65, 0x35, 0x63, 0x38, 0x37, 0x36, 0x36, 0x38, 0x31, 0x34, 0x63, 0x39, 0x33, 0x35, 0x39, 0x66, 0x31, 0x37, 0x37, 0x30, 0x36, 0x62, 0x62, 0x36, 0x66, 0x33, 0x62, 0x38, 0x62, 0x66, 0x65, 0x62, 0x36, 0x36, 0x65, 0x64, 0x66, 0x34, 0x66, 0x63, 0x31, 0x37, 0x32, 0x61, 0x63, 0x32, 0x65, 0x35, 0x35, 0x33, 0x38, 0x32, 0x66, 0x36, 0x64, 0x61, 0x32, 0x65, 0x33, 0x31, 0x39, 0x65, 0x38, 0x31, 0x34, 0x37, 0x39, 0x62, 0x34, 0x37, 0x36, 0x34, 0x32, 0x36, 0x66, 0x66, 0x34, 0x30, 0x33, 0x63, 0x30, 0x31, 0x65, 0x63, 0x64, 0x64, 0x35, 0x36, 0x35, 0x65, 0x64, 0x63, 0x63, 0x31, 0x33, 0x65, 0x34, 0x39, 0x65, 0x32, 0x34, 0x32, 0x38, 0x62, 0x65, 0x37, 0x32, 0x64, 0x64, 0x64, 0x35, 0x65, 0x66, 0x62, 0x66, 0x32, 0x64, 0x37, 0x66, 0x66, 0x38, 0x33, 0x34, 0x36, 0x65, 0x39, 0x62, 0x63, 0x64, 0x34, 0x64, 0x35, 0x62, 0x39, 0x31, 0x61, 0x65, 0x38, 0x65, 0x38, 0x38, 0x36, 0x30, 0x37, 0x61, 0x63, 0x34, 0x62, 0x36, 0x62, 0x66, 0x35, 0x62, 0x38, 0x63, 0x31, 0x39, 0x31, 0x38, 0x63, 0x64, 0x30, 0x66, 0x33, 0x31, 0x34, 0x64, 0x61, 0x64, 0x33, 0x64, 0x61, 0x66, 0x37, 0x37, 0x64, 0x32, 0x31, 0x39, 0x36, 0x63, 0x39, 0x32, 0x61, 0x32, 0x36, 0x62, 0x30, 0x30, 0x65, 0x39, 0x62, 0x36, 0x31, 0x36, 0x64, 0x61, 0x36, 0x63, 0x30, 0x34, 0x64, 0x34, 0x39, 0x61, 0x31, 0x36, 0x30, 0x61, 0x37, 0x37, 0x36, 0x64, 0x63, 0x63, 0x33, 0x30, 0x64, 0x36, 0x34, 0x32, 0x62, 0x34, 0x63, 0x39, 0x37, 0x33, 0x66, 0x30, 0x39, 0x32, 0x65, 0x32, 0x37, 0x32, 0x30, 0x32, 0x39, 0x30, 0x61, 0x66, 0x39, 0x34, 0x66, 0x61, 0x35, 0x65, 0x35, 0x39, 0x31, 0x39, 0x66, 0x36, 0x61, 0x63, 0x63, 0x61, 0x36, 0x36, 0x32, 0x32, 0x33, 0x63, 0x34, 0x30, 0x31, 0x36, 0x33, 0x63, 0x33, 0x35, 0x66, 0x66, 0x37, 0x62, 0x64, 0x34, 0x38, 0x32, 0x36, 0x38, 0x36, 0x30, 0x33, 0x66, 0x66, 0x31, 0x30, 0x64, 0x34, 0x32, 0x33, 0x33, 0x37, 0x66, 0x32, 0x36, 0x36, 0x30, 0x35, 0x66, 0x32, 0x62, 0x63, 0x32, 0x64, 0x30, 0x38, 0x36, 0x36, 0x65, 0x62, 0x32, 0x37, 0x65, 0x65, 0x65, 0x30, 0x61, 0x37, 0x37, 0x61, 0x32, 0x61, 0x36, 0x31, 0x37, 0x38, 0x63, 0x63, 0x39, 0x31, 0x34, 0x65, 0x37, 0x37, 0x66, 0x35, 0x63, 0x34, 0x31, 0x65, 0x65, 0x31, 0x36, 0x39, 0x32, 0x62, 0x39, 0x31, 0x35, 0x62, 0x39, 0x62, 0x61, 0x39, 0x34, 0x30, 0x37, 0x65, 0x66, 0x36, 0x65, 0x39, 0x61, 0x31, 0x32, 0x63, 0x62, 0x39, 0x35, 0x34, 0x39, 0x35, 0x33, 0x35, 0x38, 0x61, 0x33, 0x38, 0x33, 0x65, 0x35, 0x38, 0x39, 0x31, 0x32, 0x35, 0x61, 0x34, 0x62, 0x36, 0x61, 0x39, 0x36, 0x63, 0x62, 0x63, 0x34, 0x31, 0x34, 0x63, 0x61, 0x63, 0x63, 0x64, 0x35, 0x39, 0x66, 0x38, 0x36, 0x65, 0x39, 0x65, 0x36, 0x39, 0x61, 0x65, 0x38, 0x62, 0x37, 0x33, 0x30, 0x34, 0x37, 0x31, 0x61, 0x34, 0x32, 0x65, 0x34, 0x34, 0x61, 0x36, 0x33, 0x36, 0x31, 0x64, 0x64, 0x62, 0x30, 0x32, 0x33, 0x32, 0x66, 0x31, 0x36, 0x62, 0x36, 0x62, 0x65, 0x63, 0x61, 0x33, 0x30, 0x38, 0x37, 0x63, 0x36, 0x36, 0x30, 0x31, 0x31, 0x36, 0x64, 0x37, 0x32, 0x65, 0x37, 0x64, 0x39, 0x35, 0x61, 0x39, 0x31, 0x63, 0x36, 0x36, 0x37, 0x36, 0x64, 0x63, 0x63, 0x39, 0x65, 0x65, 0x34, 0x66, 0x38, 0x37, 0x32, 0x66, 0x39, 0x62, 0x31, 0x63, 0x33, 0x34, 0x34, 0x65, 0x30, 0x62, 0x34, 0x39, 0x33, 0x37, 0x35, 0x31, 0x39, 0x65, 0x63, 0x35, 0x36, 0x61, 0x30, 0x37, 0x64, 0x35, 0x38, 0x38, 0x39, 0x37, 0x37, 0x34, 0x39, 0x66, 0x38, 0x66, 0x32, 0x66, 0x32, 0x35, 0x33, 0x39, 0x33, 0x31, 0x65, 0x33, 0x31, 0x30, 0x39, 0x36, 0x38, 0x39, 0x64, 0x31, 0x34, 0x62, 0x65, 0x61, 0x66, 0x61, 0x37, 0x31, 0x64, 0x30, 0x66, 0x61, 0x34, 0x64, 0x33, 0x38, 0x64, 0x37, 0x62, 0x34, 0x35, 0x34, 0x34, 0x33, 0x61, 0x32, 0x33, 0x38, 0x61, 0x34, 0x38, 0x35, 0x64, 0x34, 0x63, 0x65, 0x61, 0x62, 0x37, 0x33, 0x35, 0x38, 0x35, 0x34, 0x33, 0x36, 0x36, 0x33, 0x62, 0x35, 0x39, 0x30, 0x65, 0x32, 0x36, 0x64, 0x34, 0x30, 0x63, 0x39, 0x32, 0x63, 0x33, 0x34, 0x32, 0x63, 0x38, 0x61, 0x39, 0x37, 0x64, 0x31, 0x39, 0x36, 0x32, 0x63, 0x62, 0x36, 0x64, 0x62, 0x61, 0x30, 0x34, 0x31, 0x31, 0x64, 0x32, 0x62, 0x35, 0x38, 0x36, 0x63, 0x33, 0x30, 0x31, 0x31, 0x34, 0x64, 0x61, 0x62, 0x61, 0x36, 0x65, 0x66, 0x33, 0x39, 0x35, 0x63, 0x64, 0x61, 0x66, 0x66, 0x33, 0x66, 0x38, 0x65, 0x61, 0x34, 0x38, 0x35, 0x30, 0x63, 0x66, 0x63, 0x65, 0x32, 0x30, 0x35, 0x30, 0x66, 0x34, 0x39, 0x37, 0x32, 0x62, 0x34, 0x33, 0x64, 0x31, 0x62, 0x65, 0x38, 0x65, 0x33, 0x39, 0x65, 0x37, 0x35, 0x39, 0x30, 0x36, 0x35, 0x30, 0x32, 0x34, 0x61, 0x35, 0x64, 0x32, 0x63, 0x37, 0x38, 0x62, 0x61, 0x63, 0x61, 0x33, 0x66, 0x35, 0x31, 0x62, 0x64, 0x62, 0x35, 0x66, 0x63, 0x39, 0x35, 0x36, 0x37, 0x35, 0x38, 0x65, 0x64, 0x36, 0x31, 0x37, 0x63, 0x37, 0x34, 0x35, 0x37, 0x63, 0x33, 0x32, 0x64, 0x33, 0x62, 0x38, 0x37, 0x30, 0x30, 0x32, 0x35, 0x37, 0x64, 0x63, 0x61, 0x30, 0x33, 0x38, 0x65, 0x61, 0x65, 0x38, 0x31, 0x30, 0x64, 0x39, 0x35, 0x62, 0x34, 0x34, 0x61, 0x64, 0x38, 0x32, 0x66, 0x63, 0x36, 0x37, 0x33, 0x62, 0x38, 0x37, 0x63, 0x38, 0x65, 0x33, 0x33, 0x66, 0x35, 0x35, 0x34, 0x30, 0x63, 0x64, 0x63, 0x61, 0x31, 0x31, 0x64, 0x33, 0x36, 0x66, 0x62, 0x39, 0x36, 0x30, 0x39, 0x31, 0x36, 0x39, 0x37, 0x32, 0x39, 0x34, 0x39, 0x35, 0x36, 0x32, 0x39, 0x65, 0x39, 0x35, 0x36, 0x62, 0x37, 0x35, 0x64, 0x61, 0x62, 0x31, 0x32, 0x62, 0x30, 0x36, 0x31, 0x36, 0x30, 0x66, 0x64, 0x33, 0x65, 0x33, 0x64, 0x39, 0x39, 0x34, 0x39, 0x62, 0x31, 0x65, 0x37, 0x33, 0x32, 0x39, 0x30, 0x62, 0x66, 0x31, 0x35, 0x36, 0x38, 0x33, 0x66, 0x32, 0x64, 0x35, 0x32, 0x37, 0x30, 0x63, 0x39, 0x62, 0x66, 0x33, 0x37, 0x32, 0x39, 0x34, 0x39, 0x38, 0x36, 0x34, 0x39, 0x36, 0x39, 0x64, 0x35, 0x30, 0x38, 0x38, 0x33, 0x32, 0x61, 0x32, 0x64, 0x65, 0x32, 0x32, 0x64, 0x32, 0x39, 0x66, 0x64, 0x66, 0x39, 0x37, 0x36, 0x35, 0x31, 0x65, 0x32, 0x31, 0x65, 0x32, 0x63, 0x33, 0x32, 0x39, 0x31, 0x38, 0x65, 0x37, 0x65, 0x63, 0x63, 0x39, 0x62, 0x34, 0x30, 0x33, 0x36, 0x64, 0x34, 0x31, 0x66, 0x32, 0x33, 0x33, 0x34, 0x37, 0x34, 0x35, 0x64, 0x34, 0x32, 0x31, 0x39, 0x63, 0x61, 0x37, 0x31, 0x37, 0x62, 0x38, 0x64, 0x63, 0x32, 0x34, 0x39, 0x64, 0x33, 0x61, 0x39, 0x63, 0x65, 0x61, 0x63, 0x35, 0x39, 0x62, 0x35, 0x30, 0x30, 0x38, 0x65, 0x63, 0x36, 0x32, 0x37, 0x36, 0x30, 0x66, 0x35, 0x31, 0x38, 0x34, 0x34, 0x36, 0x31, 0x65, 0x61, 0x65, 0x66, 0x65, 0x31, 0x33, 0x61, 0x34, 0x63, 0x35, 0x66, 0x61, 0x37, 0x32, 0x31, 0x38, 0x39, 0x30, 0x39, 0x33, 0x33, 0x32, 0x38, 0x32, 0x37, 0x39, 0x36, 0x31, 0x37, 0x34, 0x34, 0x31, 0x36, 0x62, 0x37, 0x61, 0x34, 0x34, 0x30, 0x64, 0x37, 0x34, 0x65, 0x61, 0x39, 0x33, 0x65, 0x31, 0x33, 0x36, 0x61, 0x64, 0x30, 0x32, 0x36, 0x36, 0x31, 0x30, 0x64, 0x63, 0x63, 0x65, 0x38, 0x62, 0x31, 0x65, 0x64, 0x31, 0x37, 0x37, 0x30, 0x38, 0x63, 0x64, 0x39, 0x31, 0x35, 0x64, 0x31, 0x37, 0x61, 0x36, 0x62, 0x61, 0x35, 0x64, 0x63, 0x39, 0x63, 0x32, 0x64, 0x62, 0x62, 0x38, 0x38, 0x30, 0x35, 0x37, 0x37, 0x34, 0x39, 0x65, 0x66, 0x63, 0x39, 0x64, 0x66, 0x65, 0x39, 0x33, 0x32, 0x63, 0x39, 0x33, 0x30, 0x30, 0x32, 0x63, 0x39, 0x35, 0x31, 0x33, 0x64, 0x31, 0x61, 0x38, 0x63, 0x33, 0x39, 0x61, 0x33, 0x35, 0x39, 0x64, 0x65, 0x65, 0x38, 0x32, 0x39, 0x63, 0x37, 0x32, 0x33, 0x35, 0x31, 0x37, 0x33, 0x63, 0x30, 0x34, 0x65, 0x30, 0x62, 0x66, 0x31, 0x63, 0x36, 0x31, 0x35, 0x63, 0x38, 0x34, 0x61, 0x37, 0x65, 0x36, 0x64, 0x30, 0x34, 0x32, 0x65, 0x35, 0x66, 0x62, 0x33, 0x37, 0x37, 0x30, 0x30, 0x36, 0x34, 0x30, 0x38, 0x33, 0x62, 0x38, 0x36, 0x32, 0x65, 0x39, 0x65, 0x39, 0x35, 0x34, 0x37, 0x62, 0x32, 0x35, 0x37, 0x65, 0x37, 0x35, 0x66, 0x33, 0x30, 0x62, 0x33, 0x64, 0x65, 0x33, 0x32, 0x64, 0x30, 0x62, 0x65, 0x35, 0x64, 0x30, 0x38, 0x61, 0x65, 0x66, 0x63, 0x61, 0x31, 0x37, 0x33, 0x33, 0x64, 0x36, 0x39, 0x35, 0x65, 0x38, 0x32, 0x66, 0x33, 0x64, 0x35, 0x63, 0x32, 0x32, 0x30, 0x32, 0x38, 0x61, 0x64, 0x33, 0x66, 0x32, 0x64, 0x30, 0x33, 0x66, 0x61, 0x39, 0x64, 0x61, 0x62, 0x64, 0x32, 0x36, 0x61, 0x62, 0x62, 0x66, 0x61, 0x35, 0x37, 0x32, 0x38, 0x36, 0x61, 0x35, 0x61, 0x33, 0x33, 0x38, 0x35, 0x39, 0x66, 0x66, 0x39, 0x30, 0x62, 0x64, 0x64, 0x31, 0x37, 0x30, 0x61, 0x30, 0x38, 0x39, 0x63, 0x31, 0x30, 0x37, 0x31, 0x61, 0x61, 0x35, 0x66, 0x64, 0x35, 0x30, 0x38, 0x36, 0x32, 0x61, 0x63, 0x31, 0x35, 0x65, 0x36, 0x38, 0x65, 0x39, 0x34, 0x37, 0x63, 0x61, 0x37, 0x32, 0x36, 0x37, 0x35, 0x38, 0x62, 0x32, 0x63, 0x64, 0x37, 0x32, 0x63, 0x64, 0x37, 0x64, 0x35, 0x32, 0x33, 0x34, 0x64, 0x35, 0x34, 0x64, 0x63, 0x33, 0x32, 0x35, 0x36, 0x61, 0x62, 0x63, 0x64, 0x66, 0x31, 0x30, 0x64, 0x64, 0x62, 0x62, 0x39, 0x65, 0x39, 0x36, 0x65, 0x34, 0x63, 0x64, 0x30, 0x33, 0x37, 0x39, 0x37, 0x36, 0x35, 0x34, 0x66, 0x64, 0x32, 0x35, 0x61, 0x32, 0x32, 0x35, 0x30, 0x32, 0x34, 0x39, 0x37, 0x32, 0x35, 0x39, 0x64, 0x30, 0x37, 0x32, 0x37, 0x61, 0x32, 0x63, 0x35, 0x65, 0x39, 0x66, 0x34, 0x35, 0x38, 0x32, 0x38, 0x35, 0x61, 0x64, 0x65, 0x31, 0x36, 0x36, 0x65, 0x35, 0x35, 0x33, 0x30, 0x62, 0x64, 0x65, 0x31, 0x34, 0x30, 0x31, 0x63, 0x65, 0x62, 0x64, 0x37, 0x66, 0x66, 0x35, 0x64, 0x62, 0x39, 0x33, 0x37, 0x32, 0x33, 0x36, 0x38, 0x34, 0x61, 0x64, 0x36, 0x34, 0x37, 0x31, 0x63, 0x30, 0x31, 0x32, 0x64, 0x66, 0x37, 0x32, 0x38, 0x62, 0x34, 0x64, 0x64, 0x62, 0x32, 0x34, 0x62, 0x66, 0x31, 0x35, 0x31, 0x63, 0x62, 0x37, 0x64, 0x31, 0x62, 0x62, 0x39, 0x31, 0x30, 0x63, 0x61, 0x30, 0x35, 0x62, 0x63, 0x66, 0x32, 0x39, 0x31, 0x39, 0x38, 0x35, 0x31, 0x39, 0x39, 0x64, 0x39, 0x32, 0x39, 0x63, 0x61, 0x63, 0x32, 0x63, 0x62, 0x37, 0x37, 0x38, 0x65, 0x38, 0x65, 0x62, 0x65, 0x38, 0x30, 0x31, 0x34, 0x65, 0x37, 0x32, 0x32, 0x36, 0x34, 0x65, 0x34, 0x63, 0x31, 0x64, 0x39, 0x66, 0x66, 0x35, 0x31, 0x31, 0x35, 0x33, 0x65, 0x30, 0x37, 0x63, 0x37, 0x65, 0x32, 0x32, 0x38, 0x61, 0x32, 0x32, 0x61, 0x38, 0x32, 0x31, 0x62, 0x63, 0x39, 0x66, 0x32, 0x37, 0x31, 0x35, 0x39, 0x61, 0x34, 0x64, 0x37, 0x34, 0x64, 0x61, 0x36, 0x65, 0x32, 0x35, 0x39, 0x65, 0x61, 0x33, 0x66, 0x62, 0x66, 0x39, 0x37, 0x37, 0x37, 0x32, 0x62, 0x36, 0x37, 0x32, 0x63, 0x61, 0x32, 0x30, 0x35, 0x63, 0x36, 0x33, 0x63, 0x36, 0x39, 0x33, 0x37, 0x61, 0x30, 0x39, 0x39, 0x32, 0x37, 0x66, 0x35, 0x32, 0x36, 0x37, 0x38, 0x65, 0x35, 0x36, 0x65, 0x34, 0x61, 0x36, 0x66, 0x62, 0x37, 0x61, 0x65, 0x64, 0x32, 0x63, 0x36, 0x31, 0x30, 0x37, 0x34, 0x38, 0x32, 0x35, 0x62, 0x36, 0x65, 0x39, 0x61, 0x30, 0x63, 0x32, 0x39, 0x62, 0x34, 0x38, 0x63, 0x38, 0x32, 0x62, 0x64, 0x31, 0x66, 0x33, 0x63, 0x65, 0x38, 0x66, 0x38, 0x66, 0x61, 0x37, 0x39, 0x33, 0x37, 0x61, 0x65, 0x61, 0x65, 0x32, 0x63, 0x34, 0x61, 0x65, 0x37, 0x65, 0x61, 0x66, 0x62, 0x65, 0x33, 0x63, 0x32, 0x34, 0x64, 0x34, 0x32, 0x35, 0x33, 0x35, 0x35, 0x62, 0x30, 0x37, 0x31, 0x61, 0x63, 0x36, 0x31, 0x66, 0x37, 0x61, 0x63, 0x66, 0x31, 0x37, 0x62, 0x36, 0x37, 0x32, 0x34, 0x33, 0x34, 0x61, 0x39, 0x39, 0x30, 0x34, 0x66, 0x30, 0x33, 0x31, 0x34, 0x31, 0x39, 0x34, 0x38, 0x61, 0x39, 0x30, 0x33, 0x61, 0x32, 0x66, 0x62, 0x66, 0x39, 0x33, 0x65, 0x65, 0x33, 0x66, 0x63, 0x32, 0x33, 0x66, 0x63, 0x61, 0x33, 0x36, 0x31, 0x34, 0x31, 0x33, 0x63, 0x37, 0x63, 0x65, 0x64, 0x66, 0x64, 0x32, 0x38, 0x32, 0x32, 0x36, 0x64, 0x30, 0x32, 0x62, 0x34, 0x38, 0x36, 0x33, 0x63, 0x63, 0x37, 0x30, 0x30, 0x35, 0x36, 0x66, 0x35, 0x35, 0x63, 0x61, 0x30, 0x30, 0x62, 0x38, 0x61, 0x37, 0x65, 0x63, 0x39, 0x35, 0x66, 0x31, 0x36, 0x65, 0x32, 0x65, 0x34, 0x37, 0x62, 0x31, 0x39, 0x30, 0x64, 0x65, 0x64, 0x62, 0x38, 0x33, 0x61, 0x35, 0x31, 0x31, 0x36, 0x64, 0x32, 0x38, 0x62, 0x33, 0x62, 0x37, 0x35, 0x35, 0x39, 0x38, 0x39, 0x35, 0x34, 0x30, 0x38, 0x36, 0x36, 0x39, 0x30, 0x61, 0x33, 0x62, 0x37, 0x33, 0x61, 0x35, 0x39, 0x36, 0x35, 0x36, 0x33, 0x61, 0x37, 0x39, 0x36, 0x36, 0x38, 0x61, 0x37, 0x36, 0x34, 0x34, 0x35, 0x33, 0x65, 0x62, 0x38, 0x61, 0x64, 0x61, 0x64, 0x37, 0x37, 0x32, 0x61, 0x39, 0x38, 0x61, 0x30, 0x65, 0x65, 0x62, 0x39, 0x37, 0x39, 0x32, 0x38, 0x66, 0x31, 0x37, 0x64, 0x39, 0x35, 0x38, 0x63, 0x61, 0x35, 0x31, 0x31, 0x61, 0x37, 0x32, 0x33, 0x35, 0x62, 0x35, 0x30, 0x65, 0x33, 0x36, 0x63, 0x39, 0x31, 0x38, 0x65, 0x33, 0x33, 0x34, 0x34, 0x37, 0x33, 0x32, 0x63, 0x38, 0x65, 0x39, 0x39, 0x61, 0x39, 0x38, 0x36, 0x65, 0x64, 0x31, 0x36, 0x63, 0x36, 0x36, 0x39, 0x33, 0x30, 0x35, 0x30, 0x62, 0x61, 0x32, 0x30, 0x63, 0x38, 0x37, 0x31, 0x33, 0x36, 0x31, 0x66, 0x30, 0x31, 0x65, 0x66, 0x64, 0x36, 0x63, 0x63, 0x37, 0x31, 0x33, 0x32, 0x37, 0x39, 0x30, 0x30, 0x36, 0x35, 0x66, 0x62, 0x32, 0x37, 0x31, 0x63, 0x39, 0x36, 0x63, 0x39, 0x37, 0x31, 0x65, 0x65, 0x33, 0x65, 0x63, 0x66, 0x64, 0x39, 0x61, 0x36, 0x62, 0x37, 0x61, 0x31, 0x30, 0x33, 0x33, 0x39, 0x39, 0x64, 0x62, 0x32, 0x61, 0x39, 0x64, 0x32, 0x34, 0x31, 0x33, 0x37, 0x37, 0x30, 0x37, 0x62, 0x63, 0x66, 0x63, 0x32, 0x64, 0x30, 0x62, 0x30, 0x37, 0x37, 0x32, 0x37, 0x64, 0x61, 0x38, 0x38, 0x34, 0x66, 0x64, 0x35, 0x30, 0x31, 0x38, 0x31, 0x30, 0x64, 0x37, 0x31, 0x38, 0x65, 0x61, 0x35, 0x66, 0x31, 0x34, 0x34, 0x30, 0x34, 0x31, 0x30, 0x62, 0x32, 0x32, 0x32, 0x62, 0x33, 0x33, 0x62, 0x39, 0x35, 0x39, 0x65, 0x32, 0x35, 0x66, 0x33, 0x64, 0x39, 0x39, 0x65, 0x30, 0x38, 0x33, 0x34, 0x33, 0x33, 0x65, 0x33, 0x38, 0x31, 0x36, 0x30, 0x35, 0x37, 0x32, 0x63, 0x39, 0x35, 0x63, 0x35, 0x31, 0x30, 0x34, 0x39, 0x30, 0x61, 0x35, 0x62, 0x31, 0x38, 0x38, 0x62, 0x39, 0x32, 0x65, 0x38, 0x66, 0x61, 0x30, 0x39, 0x33, 0x31, 0x64, 0x62, 0x35, 0x36, 0x33, 0x36, 0x37, 0x62, 0x32, 0x63, 0x66, 0x37, 0x34, 0x32, 0x31, 0x37, 0x36, 0x30, 0x62, 0x30, 0x65, 0x61, 0x34, 0x63, 0x30, 0x63, 0x62, 0x31, 0x39, 0x36, 0x61, 0x30, 0x38, 0x61, 0x35, 0x37, 0x32, 0x61, 0x65, 0x33, 0x61, 0x32, 0x36, 0x33, 0x36, 0x37, 0x33, 0x62, 0x34, 0x66, 0x64, 0x65, 0x62, 0x30, 0x64, 0x31, 0x61, 0x31, 0x62, 0x66, 0x64, 0x37, 0x61, 0x66, 0x38, 0x63, 0x66, 0x31, 0x36, 0x33, 0x64, 0x30, 0x36, 0x35, 0x65, 0x31, 0x65, 0x33, 0x39, 0x31, 0x37, 0x31, 0x38, 0x39, 0x66, 0x62, 0x39, 0x66, 0x64, 0x30, 0x36, 0x63, 0x32, 0x63, 0x65, 0x33, 0x38, 0x32, 0x66, 0x36, 0x61, 0x62, 0x63, 0x62, 0x38, 0x30, 0x66, 0x36, 0x35, 0x33, 0x38, 0x35, 0x66, 0x38, 0x33, 0x32, 0x35, 0x63, 0x32, 0x30, 0x31, 0x34, 0x66, 0x61, 0x66, 0x35, 0x30, 0x64, 0x35, 0x36, 0x30, 0x30, 0x35, 0x37, 0x34, 0x62, 0x63, 0x30, 0x39, 0x31, 0x36, 0x61, 0x37, 0x61, 0x65, 0x31, 0x37, 0x30, 0x65, 0x36, 0x64, 0x61, 0x35, 0x66, 0x34, 0x39, 0x32, 0x34, 0x62, 0x66, 0x33, 0x34, 0x62, 0x30, 0x39, 0x37, 0x37, 0x35, 0x31, 0x62, 0x37, 0x31, 0x61, 0x37, 0x34, 0x37, 0x33, 0x30, 0x65, 0x30, 0x33, 0x33, 0x36, 0x31, 0x37, 0x34, 0x64, 0x34, 0x35, 0x36, 0x30, 0x36, 0x36, 0x63, 0x31, 0x62, 0x66, 0x33, 0x33, 0x64, 0x31, 0x32, 0x36, 0x30, 0x39, 0x38, 0x34, 0x30, 0x34, 0x37, 0x37, 0x61, 0x30, 0x38, 0x63, 0x62, 0x34, 0x61, 0x63, 0x66, 0x38, 0x64, 0x64, 0x35, 0x66, 0x36, 0x36, 0x37, 0x32, 0x31, 0x61, 0x36, 0x66, 0x31, 0x39, 0x34, 0x38, 0x62, 0x62, 0x30, 0x33, 0x31, 0x37, 0x64, 0x65, 0x32, 0x66, 0x66, 0x33, 0x31, 0x30, 0x37, 0x64, 0x65, 0x63, 0x62, 0x39, 0x30, 0x36, 0x36, 0x64, 0x61, 0x39, 0x39, 0x39, 0x65, 0x30, 0x34, 0x35, 0x34, 0x62, 0x37, 0x33, 0x30, 0x63, 0x35, 0x32, 0x35, 0x62, 0x35, 0x37, 0x66, 0x62, 0x64, 0x33, 0x64, 0x34, 0x64, 0x32, 0x66, 0x66, 0x30, 0x61, 0x39, 0x37, 0x36, 0x32, 0x30, 0x32, 0x66, 0x36, 0x33, 0x37, 0x37, 0x30, 0x63, 0x36, 0x66, 0x37, 0x61, 0x34, 0x34, 0x66, 0x33, 0x33, 0x34, 0x63, 0x65, 0x39, 0x31, 0x30, 0x31, 0x35, 0x33, 0x35, 0x30, 0x61, 0x65, 0x35, 0x66, 0x65, 0x66, 0x62, 0x34, 0x32, 0x62, 0x39, 0x33, 0x66, 0x32, 0x31, 0x39, 0x66, 0x64, 0x39, 0x65, 0x38, 0x36, 0x33, 0x36, 0x36, 0x65, 0x62, 0x39, 0x65, 0x31, 0x30, 0x63, 0x35, 0x63, 0x32, 0x30, 0x30, 0x35, 0x38, 0x33, 0x64, 0x38, 0x62, 0x62, 0x36, 0x31, 0x36, 0x63, 0x38, 0x33, 0x34, 0x31, 0x35, 0x65, 0x39, 0x64, 0x66, 0x63, 0x38, 0x37, 0x36, 0x64, 0x38, 0x36, 0x64, 0x66, 0x30, 0x30, 0x32, 0x35, 0x39, 0x32, 0x33, 0x66, 0x31, 0x39, 0x66, 0x35, 0x33, 0x61, 0x35, 0x66, 0x36, 0x36, 0x64, 0x61, 0x66, 0x61, 0x39, 0x62, 0x66, 0x61, 0x64, 0x37, 0x32, 0x62, 0x36, 0x35, 0x34, 0x32, 0x32, 0x65, 0x64, 0x64, 0x32, 0x61, 0x30, 0x32, 0x61, 0x36, 0x39, 0x62, 0x32, 0x39, 0x36, 0x66, 0x38, 0x61, 0x33, 0x62, 0x62, 0x36, 0x34, 0x38, 0x30, 0x35, 0x33, 0x63, 0x37, 0x64, 0x61, 0x38, 0x35, 0x32, 0x30, 0x36, 0x34, 0x35, 0x33, 0x65, 0x38, 0x39, 0x39, 0x61, 0x33, 0x38, 0x62, 0x64, 0x36, 0x65, 0x31, 0x34, 0x65, 0x34, 0x39, 0x66, 0x30, 0x31, 0x33, 0x32, 0x62, 0x61, 0x32, 0x66, 0x35, 0x61, 0x35, 0x34, 0x33, 0x35, 0x32, 0x36, 0x36, 0x61, 0x38, 0x63, 0x66, 0x62, 0x35, 0x63, 0x33, 0x33, 0x38, 0x63, 0x31, 0x39, 0x32, 0x65, 0x33, 0x63, 0x37, 0x65, 0x61, 0x63, 0x35, 0x31, 0x34, 0x33, 0x63, 0x62, 0x31, 0x64, 0x38, 0x33, 0x38, 0x65, 0x63, 0x61, 0x66, 0x33, 0x62, 0x35, 0x62, 0x35, 0x65, 0x65, 0x35, 0x62, 0x34, 0x39, 0x31, 0x35, 0x30, 0x63, 0x30, 0x61, 0x32, 0x32, 0x35, 0x31, 0x65, 0x35, 0x30, 0x35, 0x31, 0x35, 0x34, 0x32, 0x32, 0x33, 0x32, 0x66, 0x65, 0x37, 0x66, 0x36, 0x61, 0x30, 0x62, 0x30, 0x36, 0x36, 0x32, 0x35, 0x34, 0x66, 0x38, 0x61, 0x66, 0x31, 0x39, 0x30, 0x31, 0x30, 0x30, 0x34, 0x63, 0x30, 0x62, 0x38, 0x64, 0x39, 0x33, 0x34, 0x31, 0x39, 0x65, 0x34, 0x64, 0x35, 0x62, 0x34, 0x38, 0x30, 0x61, 0x30, 0x63, 0x37, 0x36, 0x65, 0x30, 0x62, 0x63, 0x65, 0x37, 0x30, 0x33, 0x31, 0x63, 0x64, 0x63, 0x32, 0x33, 0x66, 0x63, 0x62, 0x35, 0x66, 0x34, 0x63, 0x33, 0x36, 0x31, 0x66, 0x65, 0x31, 0x63, 0x37, 0x62, 0x64, 0x35, 0x31, 0x38, 0x63, 0x35, 0x63, 0x62, 0x33, 0x33, 0x32, 0x64, 0x38, 0x62, 0x30, 0x63, 0x34, 0x33, 0x37, 0x37, 0x65, 0x30, 0x63, 0x33, 0x63, 0x66, 0x39, 0x31, 0x34, 0x62, 0x37, 0x32, 0x36, 0x61, 0x36, 0x62, 0x62, 0x37, 0x63, 0x39, 0x37, 0x66, 0x36, 0x65, 0x32, 0x61, 0x36, 0x33, 0x38, 0x36, 0x36, 0x61, 0x65, 0x38, 0x39, 0x38, 0x36, 0x37, 0x61, 0x61, 0x31, 0x31, 0x63, 0x37, 0x39, 0x61, 0x39, 0x63, 0x35, 0x34, 0x35, 0x36, 0x62, 0x34, 0x61, 0x37, 0x31, 0x61, 0x66, 0x33, 0x39, 0x66, 0x39, 0x63, 0x61, 0x39, 0x36, 0x32, 0x33, 0x34, 0x65, 0x64, 0x30, 0x66, 0x37, 0x32, 0x61, 0x33, 0x64, 0x66, 0x34, 0x33, 0x38, 0x30, 0x64, 0x31, 0x66, 0x39, 0x36, 0x36, 0x38, 0x36, 0x39, 0x38, 0x65, 0x65, 0x37, 0x31, 0x33, 0x66, 0x66, 0x36, 0x66, 0x39, 0x62, 0x63, 0x36, 0x62, 0x62, 0x38, 0x66, 0x62, 0x34, 0x61, 0x64, 0x64, 0x36, 0x35, 0x32, 0x62, 0x35, 0x37, 0x65, 0x33, 0x34, 0x62, 0x61, 0x64, 0x62, 0x66, 0x31, 0x33, 0x65, 0x30, 0x63, 0x39, 0x35, 0x38, 0x36, 0x38, 0x64, 0x66, 0x63, 0x33, 0x36, 0x37, 0x61, 0x33, 0x61, 0x66, 0x63, 0x31, 0x39, 0x63, 0x64, 0x36, 0x30, 0x33, 0x30, 0x38, 0x39, 0x62, 0x34, 0x32, 0x35, 0x64, 0x37, 0x66, 0x63, 0x63, 0x37, 0x36, 0x64, 0x65, 0x64, 0x66, 0x66, 0x32, 0x65, 0x66, 0x61, 0x39, 0x39, 0x30, 0x65, 0x31, 0x38, 0x62, 0x63, 0x34, 0x64, 0x64, 0x65, 0x63, 0x64, 0x39, 0x30, 0x64, 0x31, 0x32, 0x65, 0x62, 0x37, 0x32, 0x66, 0x35, 0x33, 0x39, 0x38, 0x33, 0x37, 0x36, 0x35, 0x65, 0x33, 0x33, 0x64, 0x39, 0x36, 0x38, 0x64, 0x34, 0x32, 0x64, 0x37, 0x35, 0x35, 0x30, 0x39, 0x32, 0x62, 0x30, 0x35, 0x64, 0x33, 0x63, 0x30, 0x61, 0x62, 0x34, 0x36, 0x36, 0x66, 0x31, 0x62, 0x35, 0x38, 0x38, 0x39, 0x37, 0x33, 0x33, 0x61, 0x33, 0x32, 0x34, 0x30, 0x63, 0x36, 0x61, 0x38, 0x65, 0x34, 0x36, 0x38, 0x62, 0x33, 0x39, 0x31, 0x32, 0x35, 0x31, 0x64, 0x37, 0x30, 0x64, 0x32, 0x66, 0x38, 0x62, 0x64, 0x35, 0x36, 0x64, 0x35, 0x63, 0x32, 0x64, 0x65, 0x33, 0x66, 0x31, 0x37, 0x36, 0x33, 0x61, 0x61, 0x34, 0x62, 0x39, 0x65, 0x63, 0x35, 0x36, 0x63, 0x65, 0x30, 0x34, 0x61, 0x33, 0x63, 0x61, 0x34, 0x32, 0x66, 0x39, 0x36, 0x63, 0x36, 0x64, 0x30, 0x35, 0x31, 0x35, 0x66, 0x62, 0x65, 0x65, 0x35, 0x34, 0x35, 0x33, 0x36, 0x31, 0x36, 0x35, 0x38, 0x38, 0x30, 0x34, 0x39, 0x65, 0x38, 0x65, 0x63, 0x35, 0x65, 0x61, 0x63, 0x34, 0x34, 0x66, 0x38, 0x30, 0x30, 0x31, 0x36, 0x36, 0x37, 0x37, 0x37, 0x62, 0x64, 0x64, 0x66, 0x33, 0x33, 0x37, 0x34, 0x34, 0x64, 0x31, 0x62, 0x61, 0x66, 0x36, 0x61, 0x39, 0x34, 0x33, 0x36, 0x38, 0x62, 0x35, 0x64, 0x62, 0x35, 0x34, 0x37, 0x64, 0x63, 0x37, 0x66, 0x66, 0x31, 0x33, 0x34, 0x66, 0x38, 0x30, 0x36, 0x36, 0x34, 0x63, 0x30, 0x64, 0x30, 0x30, 0x35, 0x63, 0x37, 0x33, 0x32, 0x61, 0x30, 0x63, 0x66, 0x35, 0x34, 0x39, 0x39, 0x35, 0x63, 0x39, 0x35, 0x37, 0x34, 0x61, 0x63, 0x34, 0x62, 0x34, 0x61, 0x65, 0x65, 0x31, 0x33, 0x31, 0x33, 0x32, 0x62, 0x64, 0x33, 0x61, 0x30, 0x36, 0x31, 0x36, 0x61, 0x39, 0x34, 0x62, 0x35, 0x31, 0x64, 0x34, 0x39, 0x61, 0x32, 0x31, 0x35, 0x33, 0x66, 0x61, 0x36, 0x35, 0x36, 0x64, 0x61, 0x39, 0x39, 0x37, 0x35, 0x35, 0x66, 0x65, 0x35, 0x35, 0x66, 0x35, 0x66, 0x31, 0x63, 0x32, 0x34, 0x64, 0x64, 0x31, 0x34, 0x65, 0x66, 0x65, 0x62, 0x32, 0x30, 0x61, 0x61, 0x66, 0x33, 0x61, 0x64, 0x62, 0x37, 0x33, 0x39, 0x36, 0x33, 0x37, 0x30, 0x33, 0x31, 0x64, 0x30, 0x33, 0x32, 0x63, 0x65, 0x32, 0x30, 0x33, 0x63, 0x30, 0x36, 0x36, 0x30, 0x64, 0x37, 0x64, 0x36, 0x64, 0x66, 0x39, 0x37, 0x62, 0x38, 0x35, 0x63, 0x31, 0x35, 0x64, 0x64, 0x64, 0x32, 0x32, 0x38, 0x61, 0x66, 0x32, 0x30, 0x35, 0x38, 0x66, 0x35, 0x35, 0x30, 0x38, 0x38, 0x63, 0x32, 0x33, 0x66, 0x34, 0x32, 0x33, 0x62, 0x66, 0x30, 0x32, 0x39, 0x36, 0x61, 0x30, 0x39, 0x39, 0x64, 0x61, 0x62, 0x63, 0x31, 0x39, 0x66, 0x62, 0x35, 0x31, 0x66, 0x30, 0x37, 0x32, 0x32, 0x34, 0x35, 0x36, 0x32, 0x36, 0x30, 0x34, 0x35, 0x30, 0x38, 0x36, 0x31, 0x62, 0x62, 0x32, 0x38, 0x31, 0x65, 0x66, 0x62, 0x32, 0x30, 0x34, 0x32, 0x30, 0x33, 0x39, 0x63, 0x63, 0x36, 0x39, 0x32, 0x34, 0x32, 0x61, 0x65, 0x63, 0x37, 0x65, 0x64, 0x66, 0x64, 0x32, 0x35, 0x38, 0x37, 0x35, 0x63, 0x37, 0x66, 0x61, 0x35, 0x37, 0x61, 0x37, 0x64, 0x37, 0x33, 0x33, 0x31, 0x65, 0x34, 0x66, 0x33, 0x66, 0x39, 0x38, 0x64, 0x61, 0x61, 0x63, 0x37, 0x32, 0x65, 0x36, 0x63, 0x64, 0x35, 0x35, 0x32, 0x62, 0x37, 0x37, 0x39, 0x64, 0x63, 0x31, 0x33, 0x37, 0x34, 0x65, 0x61, 0x37, 0x39, 0x39, 0x31, 0x32, 0x39, 0x66, 0x62, 0x61, 0x34, 0x32, 0x65, 0x35, 0x61, 0x62, 0x66, 0x31, 0x31, 0x62, 0x35, 0x31, 0x65, 0x61, 0x66, 0x34, 0x33, 0x31, 0x64, 0x61, 0x39, 0x66, 0x39, 0x31, 0x31, 0x31, 0x36, 0x30, 0x30, 0x65, 0x38, 0x35, 0x35, 0x65, 0x37, 0x30, 0x33, 0x66, 0x37, 0x34, 0x30, 0x39, 0x64, 0x31, 0x39, 0x38, 0x66, 0x39, 0x31, 0x33, 0x35, 0x62, 0x30, 0x33, 0x63, 0x38, 0x65, 0x34, 0x30, 0x62, 0x39, 0x63, 0x61, 0x64, 0x39, 0x33, 0x64, 0x65, 0x64, 0x61, 0x38, 0x31, 0x65, 0x32, 0x36, 0x33, 0x65, 0x35, 0x38, 0x61, 0x34, 0x39, 0x63, 0x35, 0x38, 0x34, 0x34, 0x31, 0x37, 0x32, 0x38, 0x61, 0x36, 0x31, 0x38, 0x65, 0x31, 0x31, 0x37, 0x33, 0x34, 0x65, 0x62, 0x37, 0x31, 0x38, 0x33, 0x38, 0x38, 0x33, 0x61, 0x66, 0x36, 0x61, 0x63, 0x39, 0x31, 0x37, 0x65, 0x31, 0x31, 0x33, 0x65, 0x35, 0x63, 0x36, 0x35, 0x31, 0x31, 0x35, 0x64, 0x65, 0x65, 0x62, 0x63, 0x37, 0x66, 0x66, 0x33, 0x30, 0x35, 0x64, 0x36, 0x31, 0x62, 0x32, 0x37, 0x63, 0x35, 0x35, 0x31, 0x36, 0x36, 0x32, 0x66, 0x32, 0x37, 0x63, 0x38, 0x34, 0x62, 0x34, 0x64, 0x65, 0x64, 0x64, 0x63, 0x35, 0x65, 0x34, 0x30, 0x39, 0x35, 0x62, 0x33, 0x64, 0x31, 0x30, 0x65, 0x64, 0x35, 0x33, 0x31, 0x35, 0x31, 0x30, 0x35, 0x31, 0x66, 0x31, 0x61, 0x38, 0x32, 0x38, 0x39, 0x63, 0x62, 0x64, 0x66, 0x31, 0x66, 0x66, 0x64, 0x37, 0x39, 0x34, 0x32, 0x65, 0x35, 0x35, 0x61, 0x35, 0x66, 0x32, 0x33, 0x62, 0x37, 0x32, 0x66, 0x33, 0x61, 0x66, 0x61, 0x33, 0x66, 0x64, 0x39, 0x37, 0x30, 0x36, 0x66, 0x38, 0x64, 0x39, 0x30, 0x39, 0x30, 0x39, 0x36, 0x63, 0x64, 0x62, 0x33, 0x35, 0x31, 0x39, 0x31, 0x35, 0x37, 0x64, 0x32, 0x34, 0x39, 0x32, 0x66, 0x32, 0x61, 0x36, 0x37, 0x61, 0x34, 0x35, 0x65, 0x31, 0x39, 0x35, 0x62, 0x31, 0x37, 0x30, 0x39, 0x66, 0x36, 0x35, 0x31, 0x62, 0x37, 0x38, 0x63, 0x66, 0x37, 0x32, 0x66, 0x63, 0x61, 0x34, 0x62, 0x34, 0x31, 0x65, 0x36, 0x61, 0x31, 0x31, 0x38, 0x38, 0x36, 0x66, 0x34, 0x37, 0x39, 0x39, 0x39, 0x39, 0x61, 0x33, 0x37, 0x66, 0x33, 0x64, 0x38, 0x32, 0x37, 0x36, 0x39, 0x31, 0x30, 0x32, 0x66, 0x34, 0x36, 0x65, 0x34, 0x65, 0x39, 0x64, 0x64, 0x61, 0x30, 0x39, 0x33, 0x33, 0x39, 0x31, 0x34, 0x35, 0x61, 0x32, 0x30, 0x30, 0x36, 0x64, 0x34, 0x30, 0x37, 0x32, 0x61, 0x39, 0x64, 0x65, 0x36, 0x33, 0x62, 0x31, 0x30, 0x63, 0x36, 0x64, 0x64, 0x35, 0x64, 0x34, 0x30, 0x34, 0x37, 0x62, 0x38, 0x63, 0x65, 0x61, 0x62, 0x36, 0x62, 0x64, 0x62, 0x36, 0x63, 0x35, 0x62, 0x37, 0x39, 0x66, 0x35, 0x30, 0x35, 0x32, 0x65, 0x35, 0x62, 0x38, 0x38, 0x33, 0x36, 0x63, 0x31, 0x63, 0x35, 0x35, 0x62, 0x38, 0x34, 0x39, 0x33, 0x66, 0x63, 0x38, 0x37, 0x35, 0x37, 0x32, 0x62, 0x66, 0x61, 0x38, 0x61, 0x36, 0x64, 0x38, 0x66, 0x37, 0x32, 0x31, 0x36, 0x35, 0x36, 0x31, 0x64, 0x63, 0x38, 0x64, 0x30, 0x35, 0x65, 0x31, 0x31, 0x37, 0x37, 0x65, 0x35, 0x36, 0x63, 0x65, 0x38, 0x32, 0x36, 0x35, 0x66, 0x34, 0x35, 0x62, 0x63, 0x64, 0x31, 0x62, 0x35, 0x33, 0x39, 0x32, 0x61, 0x65, 0x34, 0x63, 0x33, 0x65, 0x34, 0x61, 0x66, 0x35, 0x39, 0x30, 0x61, 0x62, 0x33, 0x36, 0x32, 0x38, 0x33, 0x38, 0x66, 0x61, 0x34, 0x34, 0x65, 0x34, 0x62, 0x63, 0x64, 0x32, 0x33, 0x37, 0x35, 0x30, 0x34, 0x35, 0x37, 0x34, 0x64, 0x63, 0x63, 0x36, 0x61, 0x35, 0x33, 0x34, 0x35, 0x31, 0x36, 0x64, 0x31, 0x36, 0x37, 0x66, 0x34, 0x32, 0x34, 0x62, 0x33, 0x63, 0x63, 0x37, 0x61, 0x66, 0x38, 0x31, 0x36, 0x35, 0x61, 0x33, 0x64, 0x37, 0x31, 0x38, 0x63, 0x31, 0x31, 0x39, 0x37, 0x32, 0x62, 0x37, 0x35, 0x66, 0x35, 0x36, 0x31, 0x63, 0x31, 0x31, 0x66, 0x64, 0x31, 0x38, 0x37, 0x31, 0x33, 0x33, 0x64, 0x62, 0x34, 0x63, 0x39, 0x64, 0x64, 0x34, 0x63, 0x36, 0x66, 0x62, 0x33, 0x36, 0x35, 0x61, 0x31, 0x38, 0x31, 0x39, 0x35, 0x31, 0x63, 0x31, 0x30, 0x63, 0x34, 0x30, 0x39, 0x38, 0x61, 0x63, 0x63, 0x33, 0x38, 0x38, 0x37, 0x33, 0x63, 0x39, 0x37, 0x64, 0x37, 0x39, 0x31, 0x35, 0x65, 0x35, 0x33, 0x66, 0x33, 0x32, 0x66, 0x37, 0x32, 0x36, 0x31, 0x61, 0x65, 0x63, 0x63, 0x31, 0x38, 0x66, 0x30, 0x66, 0x66, 0x32, 0x30, 0x64, 0x61, 0x35, 0x33, 0x63, 0x32, 0x61, 0x64, 0x39, 0x38, 0x36, 0x35, 0x66, 0x64, 0x35, 0x30, 0x61, 0x36, 0x37, 0x37, 0x62, 0x65, 0x32, 0x31, 0x64, 0x32, 0x30, 0x62, 0x62, 0x39, 0x30, 0x61, 0x65, 0x62, 0x64, 0x30, 0x32, 0x61, 0x34, 0x37, 0x32, 0x30, 0x32, 0x65, 0x35, 0x63, 0x37, 0x34, 0x36, 0x62, 0x37, 0x37, 0x61, 0x62, 0x63, 0x36, 0x37, 0x64, 0x36, 0x36, 0x37, 0x33, 0x62, 0x35, 0x32, 0x35, 0x37, 0x62, 0x66, 0x37, 0x66, 0x34, 0x39, 0x64, 0x38, 0x37, 0x35, 0x65, 0x61, 0x39, 0x39, 0x39, 0x62, 0x34, 0x34, 0x64, 0x36, 0x64, 0x65, 0x37, 0x37, 0x31, 0x66, 0x33, 0x63, 0x62, 0x39, 0x63, 0x39, 0x36, 0x38, 0x37, 0x33, 0x37, 0x32, 0x38, 0x63, 0x36, 0x32, 0x65, 0x32, 0x64, 0x66, 0x35, 0x30, 0x64, 0x38, 0x39, 0x65, 0x66, 0x66, 0x31, 0x65, 0x32, 0x63, 0x36, 0x37, 0x61, 0x39, 0x65, 0x35, 0x33, 0x39, 0x66, 0x66, 0x31, 0x38, 0x31, 0x61, 0x37, 0x64, 0x64, 0x63, 0x30, 0x66, 0x66, 0x63, 0x66, 0x32, 0x62, 0x37, 0x66, 0x34, 0x36, 0x31, 0x30, 0x32, 0x35, 0x31, 0x61, 0x63, 0x63, 0x38, 0x63, 0x66, 0x35, 0x61, 0x37, 0x32, 0x66, 0x38, 0x61, 0x32, 0x37, 0x35, 0x31, 0x31, 0x30, 0x64, 0x63, 0x38, 0x32, 0x66, 0x39, 0x62, 0x66, 0x31, 0x31, 0x39, 0x30, 0x36, 0x30, 0x32, 0x37, 0x30, 0x36, 0x64, 0x63, 0x61, 0x33, 0x33, 0x30, 0x32, 0x33, 0x64, 0x30, 0x62, 0x33, 0x33, 0x31, 0x39, 0x37, 0x33, 0x39, 0x31, 0x64, 0x37, 0x37, 0x61, 0x33, 0x32, 0x30, 0x65, 0x66, 0x39, 0x32, 0x34, 0x34, 0x35, 0x35, 0x31, 0x37, 0x32, 0x35, 0x64, 0x35, 0x38, 0x36, 0x33, 0x31, 0x38, 0x61, 0x38, 0x39, 0x31, 0x65, 0x65, 0x63, 0x37, 0x31, 0x33, 0x66, 0x34, 0x36, 0x30, 0x66, 0x32, 0x30, 0x66, 0x66, 0x35, 0x35, 0x30, 0x38, 0x39, 0x37, 0x61, 0x65, 0x33, 0x66, 0x63, 0x37, 0x34, 0x65, 0x32, 0x33, 0x37, 0x62, 0x61, 0x35, 0x34, 0x62, 0x39, 0x39, 0x35, 0x37, 0x64, 0x33, 0x36, 0x30, 0x35, 0x30, 0x30, 0x39, 0x64, 0x37, 0x32, 0x36, 0x38, 0x33, 0x61, 0x66, 0x64, 0x32, 0x64, 0x62, 0x38, 0x64, 0x61, 0x30, 0x64, 0x39, 0x64, 0x33, 0x37, 0x65, 0x39, 0x32, 0x35, 0x32, 0x36, 0x33, 0x32, 0x64, 0x32, 0x63, 0x32, 0x66, 0x35, 0x32, 0x65, 0x30, 0x62, 0x62, 0x35, 0x30, 0x38, 0x34, 0x36, 0x30, 0x34, 0x66, 0x64, 0x65, 0x62, 0x34, 0x38, 0x34, 0x34, 0x30, 0x35, 0x63, 0x65, 0x32, 0x66, 0x33, 0x34, 0x62, 0x39, 0x31, 0x63, 0x38, 0x62, 0x38, 0x33, 0x62, 0x66, 0x63, 0x61, 0x33, 0x64, 0x30, 0x33, 0x65, 0x33, 0x30, 0x35, 0x36, 0x61, 0x33, 0x31, 0x36, 0x37, 0x62, 0x63, 0x39, 0x33, 0x66, 0x65, 0x61, 0x64, 0x62, 0x34, 0x34, 0x36, 0x33, 0x35, 0x34, 0x33, 0x35, 0x61, 0x64, 0x39, 0x35, 0x39, 0x64, 0x38, 0x37, 0x38, 0x34, 0x63, 0x34, 0x33, 0x35, 0x32, 0x65, 0x31, 0x66, 0x38, 0x64, 0x32, 0x35, 0x38, 0x36, 0x38, 0x65, 0x34, 0x65, 0x63, 0x63, 0x63, 0x37, 0x31, 0x36, 0x64, 0x62, 0x64, 0x38, 0x33, 0x37, 0x37, 0x63, 0x65, 0x62, 0x39, 0x33, 0x39, 0x39, 0x33, 0x33, 0x61, 0x34, 0x33, 0x65, 0x35, 0x30, 0x66, 0x35, 0x33, 0x33, 0x63, 0x38, 0x63, 0x30, 0x62, 0x64, 0x64, 0x64, 0x33, 0x39, 0x35, 0x39, 0x61, 0x38, 0x65, 0x31, 0x36, 0x32, 0x31, 0x36, 0x33, 0x65, 0x61, 0x33, 0x62, 0x32, 0x63, 0x32, 0x66, 0x37, 0x35, 0x35, 0x31, 0x61, 0x39, 0x33, 0x39, 0x32, 0x30, 0x61, 0x65, 0x62, 0x36, 0x35, 0x65, 0x33, 0x35, 0x35, 0x35, 0x62, 0x64, 0x33, 0x35, 0x65, 0x34, 0x39, 0x37, 0x37, 0x63, 0x62, 0x30, 0x36, 0x33, 0x35, 0x63, 0x62, 0x66, 0x61, 0x33, 0x65, 0x37, 0x61, 0x64, 0x61, 0x65, 0x34, 0x37, 0x61, 0x64, 0x31, 0x36, 0x66, 0x61, 0x61, 0x38, 0x62, 0x37, 0x61, 0x61, 0x38, 0x65, 0x37, 0x32, 0x35, 0x30, 0x65, 0x36, 0x65, 0x63, 0x63, 0x34, 0x37, 0x62, 0x62, 0x31, 0x35, 0x61, 0x31, 0x30, 0x38, 0x62, 0x30, 0x61, 0x66, 0x63, 0x65, 0x66, 0x31, 0x63, 0x32, 0x34, 0x36, 0x32, 0x32, 0x62, 0x63, 0x65, 0x66, 0x61, 0x39, 0x33, 0x39, 0x62, 0x62, 0x30, 0x32, 0x63, 0x30, 0x35, 0x65, 0x30, 0x61, 0x66, 0x36, 0x66, 0x36, 0x30, 0x35, 0x35, 0x63, 0x38, 0x35, 0x30, 0x35, 0x62, 0x37, 0x32, 0x62, 0x35, 0x39, 0x39, 0x37, 0x33, 0x36, 0x30, 0x62, 0x32, 0x35, 0x33, 0x32, 0x39, 0x38, 0x65, 0x63, 0x33, 0x63, 0x39, 0x33, 0x31, 0x31, 0x33, 0x63, 0x30, 0x31, 0x64, 0x65, 0x38, 0x65, 0x33, 0x33, 0x33, 0x36, 0x61, 0x39, 0x39, 0x39, 0x34, 0x34, 0x38, 0x66, 0x30, 0x66, 0x33, 0x35, 0x33, 0x38, 0x32, 0x64, 0x64, 0x66, 0x38, 0x30, 0x63, 0x39, 0x65, 0x61, 0x34, 0x65, 0x33, 0x35, 0x61, 0x31, 0x63, 0x31, 0x63, 0x64, 0x30, 0x33, 0x62, 0x62, 0x37, 0x61, 0x30, 0x31, 0x30, 0x33, 0x65, 0x65, 0x37, 0x33, 0x30, 0x34, 0x61, 0x63, 0x31, 0x62, 0x34, 0x66, 0x38, 0x65, 0x36, 0x33, 0x66, 0x62, 0x61, 0x39, 0x37, 0x66, 0x66, 0x31, 0x66, 0x30, 0x39, 0x61, 0x65, 0x37, 0x31, 0x36, 0x32, 0x64, 0x35, 0x36, 0x32, 0x39, 0x66, 0x63, 0x38, 0x30, 0x34, 0x33, 0x34, 0x38, 0x34, 0x37, 0x32, 0x65, 0x61, 0x64, 0x37, 0x39, 0x39, 0x61, 0x39, 0x38, 0x32, 0x32, 0x62, 0x63, 0x34, 0x32, 0x64, 0x31, 0x31, 0x65, 0x38, 0x65, 0x66, 0x34, 0x63, 0x35, 0x34, 0x32, 0x36, 0x31, 0x61, 0x31, 0x63, 0x35, 0x33, 0x66, 0x62, 0x36, 0x62, 0x34, 0x63, 0x32, 0x64, 0x37, 0x34, 0x62, 0x61, 0x32, 0x65, 0x62, 0x64, 0x37, 0x38, 0x37, 0x31, 0x37, 0x63, 0x66, 0x62, 0x32, 0x34, 0x64, 0x33, 0x37, 0x32, 0x66, 0x64, 0x36, 0x36, 0x33, 0x33, 0x63, 0x65, 0x35, 0x62, 0x62, 0x66, 0x62, 0x63, 0x33, 0x61, 0x30, 0x36, 0x33, 0x35, 0x64, 0x66, 0x31, 0x38, 0x63, 0x39, 0x39, 0x33, 0x32, 0x62, 0x32, 0x33, 0x30, 0x63, 0x63, 0x35, 0x34, 0x37, 0x64, 0x30, 0x64, 0x61, 0x39, 0x30, 0x30, 0x34, 0x65, 0x63, 0x32, 0x63, 0x65, 0x32, 0x36, 0x63, 0x30, 0x36, 0x65, 0x66, 0x39, 0x35, 0x63, 0x36, 0x32, 0x38, 0x30, 0x36, 0x37, 0x63, 0x64, 0x30, 0x30, 0x38, 0x32, 0x61, 0x30, 0x36, 0x66, 0x37, 0x63, 0x65, 0x66, 0x34, 0x65, 0x65, 0x64, 0x39, 0x39, 0x37, 0x30, 0x63, 0x32, 0x64, 0x38, 0x63, 0x37, 0x63, 0x63, 0x36, 0x30, 0x61, 0x62, 0x34, 0x66, 0x62, 0x35, 0x64, 0x36, 0x65, 0x63, 0x37, 0x62, 0x62, 0x30, 0x38, 0x61, 0x64, 0x65, 0x36, 0x63, 0x62, 0x66, 0x35, 0x63, 0x65, 0x61, 0x62, 0x34, 0x36, 0x39, 0x37, 0x66, 0x37, 0x35, 0x64, 0x62, 0x30, 0x61, 0x62, 0x35, 0x38, 0x64, 0x36, 0x35, 0x38, 0x35, 0x62, 0x38, 0x65, 0x35, 0x37, 0x33, 0x32, 0x39, 0x36, 0x33, 0x64, 0x35, 0x38, 0x63, 0x33, 0x37, 0x62, 0x36, 0x39, 0x30, 0x34, 0x62, 0x66, 0x37, 0x64, 0x33, 0x63, 0x64, 0x35, 0x37, 0x32, 0x31, 0x35, 0x37, 0x32, 0x35, 0x31, 0x31, 0x31, 0x66, 0x62, 0x64, 0x32, 0x33, 0x31, 0x32, 0x30, 0x32, 0x31, 0x34, 0x61, 0x63, 0x38, 0x33, 0x63, 0x33, 0x63, 0x38, 0x31, 0x30, 0x63, 0x39, 0x66, 0x33, 0x64, 0x34, 0x61, 0x39, 0x61, 0x31, 0x65, 0x34, 0x33, 0x32, 0x38, 0x36, 0x66, 0x66, 0x62, 0x33, 0x38, 0x33, 0x35, 0x39, 0x37, 0x32, 0x62, 0x62, 0x36, 0x66, 0x62, 0x30, 0x35, 0x32, 0x31, 0x63, 0x31, 0x30, 0x37, 0x61, 0x36, 0x61, 0x36, 0x37, 0x36, 0x39, 0x36, 0x66, 0x30, 0x34, 0x34, 0x39, 0x30, 0x39, 0x35, 0x66, 0x35, 0x30, 0x34, 0x66, 0x66, 0x31, 0x63, 0x37, 0x35, 0x64, 0x30, 0x36, 0x36, 0x39, 0x30, 0x35, 0x32, 0x63, 0x36, 0x61, 0x34, 0x35, 0x65, 0x64, 0x32, 0x63, 0x36, 0x37, 0x64, 0x31, 0x63, 0x35, 0x39, 0x61, 0x37, 0x39, 0x32, 0x65, 0x64, 0x32, 0x62, 0x39, 0x62, 0x64, 0x66, 0x61, 0x30, 0x39, 0x64, 0x36, 0x66, 0x62, 0x66, 0x38, 0x35, 0x36, 0x37, 0x37, 0x32, 0x39, 0x36, 0x30, 0x36, 0x33, 0x33, 0x66, 0x66, 0x66, 0x39, 0x33, 0x39, 0x39, 0x63, 0x30, 0x66, 0x38, 0x36, 0x62, 0x30, 0x32, 0x65, 0x31, 0x36, 0x30, 0x32, 0x35, 0x62, 0x37, 0x31, 0x37, 0x36, 0x61, 0x63, 0x37, 0x34, 0x35, 0x31, 0x62, 0x33, 0x65, 0x62, 0x66, 0x33, 0x38, 0x34, 0x37, 0x39, 0x32, 0x65, 0x39, 0x38, 0x65, 0x39, 0x36, 0x36, 0x36, 0x30, 0x61, 0x39, 0x64, 0x38, 0x37, 0x32, 0x62, 0x34, 0x63, 0x61, 0x35, 0x61, 0x63, 0x61, 0x35, 0x34, 0x36, 0x38, 0x31, 0x64, 0x36, 0x63, 0x34, 0x37, 0x66, 0x31, 0x64, 0x62, 0x32, 0x31, 0x38, 0x61, 0x35, 0x38, 0x38, 0x33, 0x34, 0x31, 0x64, 0x66, 0x37, 0x37, 0x39, 0x66, 0x63, 0x32, 0x30, 0x32, 0x66, 0x38, 0x61, 0x39, 0x37, 0x32, 0x36, 0x61, 0x35, 0x36, 0x37, 0x64, 0x30, 0x65, 0x61, 0x31, 0x61, 0x37, 0x62, 0x32, 0x33, 0x61, 0x66, 0x37, 0x64, 0x31, 0x34, 0x62, 0x61, 0x65, 0x39, 0x30, 0x65, 0x38, 0x36, 0x64, 0x35, 0x63, 0x32, 0x37, 0x39, 0x38, 0x65, 0x37, 0x65, 0x30, 0x32, 0x30, 0x37, 0x63, 0x36, 0x61, 0x36, 0x33, 0x64, 0x39, 0x39, 0x65, 0x30, 0x66, 0x36, 0x39, 0x38, 0x65, 0x31, 0x39, 0x65, 0x38, 0x66, 0x64, 0x32, 0x66, 0x38, 0x37, 0x36, 0x62, 0x35, 0x35, 0x30, 0x35, 0x63, 0x33, 0x66, 0x62, 0x37, 0x32, 0x65, 0x64, 0x34, 0x62, 0x34, 0x39, 0x65, 0x33, 0x32, 0x33, 0x62, 0x32, 0x36, 0x66, 0x34, 0x63, 0x64, 0x34, 0x62, 0x34, 0x32, 0x30, 0x38, 0x30, 0x66, 0x35, 0x31, 0x33, 0x65, 0x65, 0x62, 0x62, 0x65, 0x62, 0x32, 0x66, 0x62, 0x38, 0x65, 0x33, 0x39, 0x63, 0x33, 0x31, 0x65, 0x61, 0x33, 0x34, 0x37, 0x33, 0x30, 0x38, 0x37, 0x33, 0x39, 0x38, 0x39, 0x63, 0x34, 0x36, 0x31, 0x32, 0x30, 0x30, 0x66, 0x39, 0x39, 0x64, 0x31, 0x66, 0x64, 0x33, 0x64, 0x63, 0x34, 0x30, 0x63, 0x61, 0x63, 0x62, 0x36, 0x65, 0x34, 0x38, 0x61, 0x35, 0x32, 0x33, 0x61, 0x35, 0x33, 0x64, 0x30, 0x63, 0x36, 0x38, 0x30, 0x36, 0x61, 0x62, 0x36, 0x36, 0x34, 0x32, 0x33, 0x64, 0x61, 0x39, 0x33, 0x64, 0x65, 0x32, 0x33, 0x65, 0x35, 0x30, 0x33, 0x66, 0x34, 0x65, 0x39, 0x34, 0x64, 0x32, 0x34, 0x34, 0x32, 0x33, 0x66, 0x38, 0x30, 0x31, 0x65, 0x37, 0x38, 0x38, 0x39, 0x38, 0x37, 0x61, 0x39, 0x65, 0x63, 0x34, 0x35, 0x39, 0x38, 0x37, 0x61, 0x63, 0x33, 0x63, 0x61, 0x30, 0x36, 0x39, 0x35, 0x64, 0x64, 0x35, 0x33, 0x35, 0x33, 0x37, 0x35, 0x63, 0x32, 0x38, 0x30, 0x32, 0x35, 0x38, 0x39, 0x31, 0x32, 0x38, 0x36, 0x65, 0x35, 0x61, 0x61, 0x66, 0x38, 0x30, 0x63, 0x39, 0x39, 0x35, 0x65, 0x65, 0x32, 0x65, 0x61, 0x30, 0x63, 0x64, 0x38, 0x31, 0x64, 0x31, 0x33, 0x63, 0x32, 0x38, 0x32, 0x62, 0x38, 0x61, 0x32, 0x39, 0x62, 0x36, 0x61, 0x63, 0x64, 0x31, 0x31, 0x65, 0x36, 0x61, 0x65, 0x62, 0x66, 0x32, 0x33, 0x31, 0x31, 0x33, 0x35, 0x63, 0x65, 0x30, 0x36, 0x37, 0x33, 0x35, 0x33, 0x36, 0x65, 0x34, 0x38, 0x64, 0x61, 0x65, 0x33, 0x37, 0x39, 0x32, 0x38, 0x34, 0x33, 0x39, 0x61, 0x62, 0x37, 0x32, 0x62, 0x31, 0x30, 0x65, 0x36, 0x30, 0x62, 0x34, 0x37, 0x30, 0x63, 0x66, 0x38, 0x64, 0x36, 0x36, 0x64, 0x63, 0x64, 0x39, 0x64, 0x33, 0x34, 0x32, 0x32, 0x61, 0x64, 0x34, 0x37, 0x64, 0x30, 0x63, 0x39, 0x35, 0x66, 0x36, 0x61, 0x32, 0x35, 0x66, 0x31, 0x37, 0x65, 0x34, 0x39, 0x36, 0x33, 0x33, 0x64, 0x63, 0x62, 0x30, 0x61, 0x35, 0x32, 0x61, 0x32, 0x30, 0x39, 0x65, 0x66, 0x32, 0x34, 0x38, 0x32, 0x65, 0x65, 0x32, 0x34, 0x36, 0x37, 0x63, 0x63, 0x62, 0x62, 0x63, 0x38, 0x61, 0x39, 0x37, 0x65, 0x36, 0x36, 0x35, 0x62, 0x30, 0x61, 0x64, 0x37, 0x61, 0x32, 0x39, 0x61, 0x38, 0x31, 0x31, 0x66, 0x31, 0x62, 0x64, 0x34, 0x64, 0x63, 0x37, 0x36, 0x61, 0x66, 0x36, 0x36, 0x32, 0x65, 0x63, 0x63, 0x36, 0x64, 0x38, 0x32, 0x34, 0x61, 0x33, 0x39, 0x64, 0x35, 0x38, 0x62, 0x35, 0x30, 0x66, 0x33, 0x61, 0x35, 0x34, 0x65, 0x32, 0x39, 0x64, 0x31, 0x34, 0x34, 0x61, 0x31, 0x64, 0x34, 0x37, 0x62, 0x66, 0x34, 0x65, 0x38, 0x38, 0x61, 0x36, 0x37, 0x32, 0x61, 0x66, 0x30, 0x37, 0x33, 0x35, 0x39, 0x36, 0x62, 0x66, 0x30, 0x36, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x65, 0x35, 0x35, 0x62, 0x35, 0x30, 0x34, 0x33, 0x30, 0x37, 0x62, 0x34, 0x38, 0x66, 0x61, 0x37, 0x64, 0x35, 0x37, 0x32, 0x64, 0x32, 0x64, 0x62, 0x32, 0x35, 0x63, 0x33, 0x39, 0x35, 0x35, 0x34, 0x65, 0x38, 0x33, 0x33, 0x36, 0x36, 0x62, 0x37, 0x34, 0x35, 0x65, 0x34, 0x61, 0x30, 0x65, 0x32, 0x35, 0x64, 0x32, 0x34, 0x66, 0x39, 0x35, 0x61, 0x36, 0x33, 0x37, 0x33, 0x31, 0x38, 0x30, 0x34, 0x36, 0x34, 0x37, 0x66, 0x65, 0x63, 0x32, 0x36, 0x64, 0x36, 0x62, 0x39, 0x30, 0x34, 0x37, 0x65, 0x36, 0x37, 0x37, 0x32, 0x63, 0x37, 0x36, 0x63, 0x30, 0x31, 0x62, 0x32, 0x38, 0x37, 0x63, 0x32, 0x62, 0x63, 0x39, 0x38, 0x61, 0x39, 0x64, 0x65, 0x30, 0x61, 0x66, 0x35, 0x61, 0x64, 0x30, 0x35, 0x36, 0x34, 0x64, 0x66, 0x36, 0x62, 0x37, 0x64, 0x32, 0x31, 0x63, 0x34, 0x33, 0x31, 0x34, 0x36, 0x34, 0x38, 0x38, 0x38, 0x38, 0x34, 0x39, 0x65, 0x36, 0x34, 0x35, 0x62, 0x39, 0x31, 0x36, 0x64, 0x61, 0x39, 0x37, 0x32, 0x64, 0x61, 0x34, 0x63, 0x65, 0x32, 0x34, 0x61, 0x66, 0x33, 0x38, 0x36, 0x64, 0x64, 0x63, 0x66, 0x39, 0x38, 0x31, 0x31, 0x65, 0x64, 0x63, 0x30, 0x39, 0x65, 0x61, 0x64, 0x66, 0x62, 0x31, 0x36, 0x37, 0x31, 0x33, 0x63, 0x61, 0x31, 0x36, 0x63, 0x63, 0x66, 0x39, 0x35, 0x63, 0x64, 0x61, 0x34, 0x66, 0x63, 0x35, 0x36, 0x32, 0x30, 0x36, 0x65, 0x38, 0x34, 0x39, 0x30, 0x36, 0x66, 0x31, 0x61, 0x61, 0x63, 0x33, 0x30, 0x62, 0x33, 0x31, 0x37, 0x31, 0x36, 0x62, 0x66, 0x30, 0x33, 0x35, 0x61, 0x64, 0x35, 0x36, 0x34, 0x62, 0x39, 0x64, 0x66, 0x63, 0x35, 0x62, 0x62, 0x65, 0x39, 0x62, 0x66, 0x63, 0x38, 0x35, 0x30, 0x39, 0x35, 0x35, 0x35, 0x34, 0x64, 0x32, 0x38, 0x38, 0x35, 0x32, 0x31, 0x34, 0x39, 0x66, 0x37, 0x31, 0x32, 0x31, 0x33, 0x35, 0x64, 0x30, 0x33, 0x36, 0x64, 0x37, 0x32, 0x38, 0x32, 0x32, 0x30, 0x36, 0x64, 0x34, 0x38, 0x31, 0x39, 0x66, 0x38, 0x39, 0x37, 0x30, 0x31, 0x61, 0x37, 0x63, 0x65, 0x34, 0x31, 0x61, 0x61, 0x33, 0x64, 0x64, 0x34, 0x33, 0x34, 0x64, 0x31, 0x39, 0x38, 0x34, 0x39, 0x34, 0x34, 0x30, 0x39, 0x33, 0x31, 0x31, 0x66, 0x34, 0x66, 0x30, 0x35, 0x34, 0x33, 0x31, 0x61, 0x62, 0x32, 0x31, 0x32, 0x34, 0x65, 0x37, 0x38, 0x39, 0x64, 0x31, 0x35, 0x61, 0x61, 0x37, 0x61, 0x35, 0x61, 0x39, 0x33, 0x64, 0x38, 0x39, 0x37, 0x33, 0x64, 0x62, 0x61, 0x64, 0x32, 0x39, 0x65, 0x65, 0x64, 0x39, 0x30, 0x33, 0x62, 0x65, 0x61, 0x32, 0x39, 0x62, 0x61, 0x32, 0x33, 0x33, 0x63, 0x32, 0x30, 0x36, 0x34, 0x31, 0x64, 0x61, 0x34, 0x32, 0x37, 0x66, 0x32, 0x33, 0x31, 0x63, 0x30, 0x62, 0x66, 0x31, 0x32, 0x63, 0x31, 0x61, 0x63, 0x34, 0x32, 0x35, 0x34, 0x64, 0x63, 0x31, 0x61, 0x39, 0x64, 0x34, 0x64, 0x39, 0x61, 0x32, 0x63, 0x66, 0x32, 0x32, 0x38, 0x36, 0x35, 0x33, 0x62, 0x64, 0x33, 0x38, 0x36, 0x66, 0x39, 0x64, 0x63, 0x30, 0x63, 0x32, 0x38, 0x33, 0x66, 0x30, 0x34, 0x61, 0x34, 0x65, 0x39, 0x31, 0x65, 0x65, 0x33, 0x61, 0x32, 0x64, 0x36, 0x63, 0x30, 0x33, 0x61, 0x61, 0x62, 0x35, 0x30, 0x63, 0x30, 0x61, 0x62, 0x66, 0x39, 0x36, 0x34, 0x37, 0x64, 0x30, 0x37, 0x32, 0x31, 0x62, 0x34, 0x37, 0x31, 0x38, 0x64, 0x35, 0x34, 0x64, 0x62, 0x34, 0x33, 0x33, 0x32, 0x34, 0x61, 0x39, 0x34, 0x34, 0x38, 0x31, 0x32, 0x62, 0x39, 0x36, 0x62, 0x36, 0x66, 0x38, 0x34, 0x34, 0x61, 0x39, 0x61, 0x36, 0x35, 0x36, 0x66, 0x64, 0x33, 0x64, 0x39, 0x63, 0x34, 0x61, 0x63, 0x63, 0x38, 0x66, 0x30, 0x66, 0x32, 0x31, 0x64, 0x38, 0x36, 0x37, 0x32, 0x34, 0x31, 0x61, 0x65, 0x38, 0x62, 0x63, 0x65, 0x37, 0x30, 0x66, 0x63, 0x39, 0x38, 0x66, 0x64, 0x31, 0x66, 0x35, 0x37, 0x37, 0x64, 0x37, 0x62, 0x64, 0x37, 0x64, 0x61, 0x32, 0x66, 0x33, 0x30, 0x39, 0x65, 0x64, 0x37, 0x63, 0x34, 0x35, 0x66, 0x36, 0x65, 0x62, 0x38, 0x38, 0x39, 0x66, 0x31, 0x61, 0x36, 0x38, 0x62, 0x66, 0x32, 0x35, 0x66, 0x33, 0x63, 0x65, 0x31, 0x64, 0x31, 0x33, 0x38, 0x37, 0x31, 0x65, 0x62, 0x33, 0x66, 0x33, 0x31, 0x62, 0x61, 0x39, 0x37, 0x37, 0x66, 0x32, 0x30, 0x63, 0x63, 0x37, 0x31, 0x39, 0x36, 0x63, 0x66, 0x34, 0x66, 0x64, 0x32, 0x65, 0x32, 0x62, 0x62, 0x30, 0x35, 0x35, 0x66, 0x39, 0x61, 0x37, 0x37, 0x39, 0x65, 0x30, 0x30, 0x33, 0x34, 0x65, 0x64, 0x35, 0x36, 0x35, 0x39, 0x32, 0x36, 0x30, 0x31, 0x62, 0x37, 0x65, 0x39, 0x31, 0x35, 0x31, 0x30, 0x37, 0x30, 0x32, 0x65, 0x33, 0x30, 0x35, 0x38, 0x37, 0x36, 0x37, 0x62, 0x39, 0x35, 0x64, 0x65, 0x62, 0x65, 0x64, 0x33, 0x35, 0x39, 0x31, 0x37, 0x61, 0x33, 0x33, 0x34, 0x64, 0x61, 0x62, 0x32, 0x65, 0x31, 0x34, 0x66, 0x66, 0x39, 0x62, 0x30, 0x61, 0x38, 0x33, 0x34, 0x64, 0x61, 0x66, 0x32, 0x62, 0x63, 0x32, 0x64, 0x35, 0x61, 0x32, 0x37, 0x66, 0x35, 0x31, 0x64, 0x33, 0x32, 0x37, 0x32, 0x66, 0x38, 0x36, 0x64, 0x37, 0x63, 0x63, 0x37, 0x30, 0x30, 0x31, 0x61, 0x63, 0x65, 0x64, 0x37, 0x35, 0x35, 0x66, 0x30, 0x37, 0x30, 0x39, 0x30, 0x61, 0x66, 0x37, 0x37, 0x36, 0x35, 0x65, 0x62, 0x32, 0x62, 0x37, 0x37, 0x65, 0x36, 0x36, 0x62, 0x35, 0x62, 0x63, 0x39, 0x35, 0x62, 0x33, 0x36, 0x61, 0x61, 0x30, 0x32, 0x38, 0x37, 0x38, 0x64, 0x38, 0x31, 0x35, 0x36, 0x63, 0x33, 0x32, 0x38, 0x39, 0x35, 0x66, 0x63, 0x66, 0x64, 0x66, 0x62, 0x61, 0x66, 0x39, 0x63, 0x36, 0x39, 0x65, 0x35, 0x34, 0x30, 0x39, 0x65, 0x34, 0x38, 0x38, 0x38, 0x34, 0x64, 0x36, 0x37, 0x37, 0x34, 0x66, 0x33, 0x32, 0x34, 0x38, 0x39, 0x62, 0x39, 0x62, 0x62, 0x64, 0x61, 0x36, 0x35, 0x66, 0x35, 0x38, 0x31, 0x65, 0x33, 0x36, 0x30, 0x31, 0x62, 0x63, 0x65, 0x35, 0x63, 0x39, 0x35, 0x30, 0x61, 0x37, 0x32, 0x37, 0x66, 0x32, 0x37, 0x36, 0x62, 0x33, 0x35, 0x36, 0x38, 0x32, 0x31, 0x66, 0x62, 0x61, 0x38, 0x63, 0x34, 0x31, 0x65, 0x63, 0x62, 0x35, 0x33, 0x36, 0x62, 0x33, 0x36, 0x62, 0x32, 0x65, 0x36, 0x33, 0x32, 0x66, 0x62, 0x62, 0x34, 0x65, 0x39, 0x39, 0x38, 0x64, 0x30, 0x31, 0x64, 0x35, 0x63, 0x31, 0x30, 0x39, 0x61, 0x31, 0x61, 0x64, 0x31, 0x64, 0x37, 0x37, 0x39, 0x32, 0x36, 0x37, 0x32, 0x63, 0x66, 0x37, 0x33, 0x31, 0x63, 0x62, 0x64, 0x61, 0x35, 0x66, 0x31, 0x33, 0x61, 0x33, 0x30, 0x66, 0x39, 0x31, 0x33, 0x65, 0x34, 0x65, 0x32, 0x64, 0x62, 0x64, 0x61, 0x35, 0x32, 0x34, 0x35, 0x64, 0x32, 0x31, 0x66, 0x30, 0x39, 0x38, 0x37, 0x38, 0x32, 0x32, 0x32, 0x61, 0x62, 0x31, 0x62, 0x63, 0x33, 0x37, 0x65, 0x66, 0x61, 0x33, 0x37, 0x33, 0x38, 0x66, 0x36, 0x35, 0x32, 0x34, 0x37, 0x31, 0x37, 0x39, 0x37, 0x65, 0x33, 0x33, 0x33, 0x65, 0x36, 0x66, 0x35, 0x33, 0x36, 0x35, 0x31, 0x65, 0x36, 0x36, 0x32, 0x33, 0x62, 0x66, 0x38, 0x62, 0x61, 0x36, 0x31, 0x61, 0x61, 0x30, 0x33, 0x66, 0x65, 0x31, 0x39, 0x30, 0x66, 0x61, 0x39, 0x36, 0x64, 0x35, 0x64, 0x31, 0x32, 0x39, 0x30, 0x38, 0x35, 0x34, 0x64, 0x64, 0x63, 0x36, 0x30, 0x62, 0x36, 0x65, 0x64, 0x33, 0x38, 0x37, 0x32, 0x31, 0x65, 0x31, 0x38, 0x34, 0x66, 0x30, 0x66, 0x62, 0x62, 0x65, 0x62, 0x63, 0x63, 0x35, 0x62, 0x66, 0x35, 0x30, 0x38, 0x37, 0x31, 0x65, 0x35, 0x61, 0x64, 0x38, 0x32, 0x36, 0x65, 0x65, 0x39, 0x66, 0x35, 0x61, 0x31, 0x39, 0x38, 0x66, 0x30, 0x37, 0x31, 0x61, 0x35, 0x37, 0x64, 0x66, 0x65, 0x32, 0x31, 0x66, 0x62, 0x38, 0x65, 0x62, 0x61, 0x32, 0x30, 0x38, 0x33, 0x65, 0x37, 0x31, 0x63, 0x39, 0x63, 0x34, 0x39, 0x64, 0x39, 0x64, 0x34, 0x65, 0x30, 0x62, 0x63, 0x61, 0x32, 0x36, 0x38, 0x38, 0x32, 0x65, 0x64, 0x33, 0x63, 0x32, 0x62, 0x32, 0x62, 0x37, 0x35, 0x37, 0x36, 0x39, 0x36, 0x63, 0x30, 0x37, 0x61, 0x31, 0x36, 0x62, 0x37, 0x33, 0x34, 0x32, 0x62, 0x64, 0x38, 0x62, 0x33, 0x62, 0x31, 0x31, 0x65, 0x31, 0x30, 0x64, 0x33, 0x33, 0x39, 0x65, 0x63, 0x65, 0x38, 0x32, 0x33, 0x36, 0x37, 0x63, 0x37, 0x31, 0x61, 0x30, 0x66, 0x63, 0x32, 0x35, 0x35, 0x64, 0x65, 0x65, 0x37, 0x36, 0x34, 0x61, 0x35, 0x34, 0x35, 0x37, 0x63, 0x64, 0x35, 0x33, 0x34, 0x64, 0x34, 0x33, 0x30, 0x39, 0x30, 0x63, 0x38, 0x37, 0x37, 0x35, 0x30, 0x65, 0x61, 0x64, 0x33, 0x34, 0x32, 0x31, 0x31, 0x64, 0x32, 0x64, 0x34, 0x37, 0x66, 0x63, 0x38, 0x34, 0x64, 0x63, 0x32, 0x63, 0x66, 0x37, 0x32, 0x30, 0x37, 0x63, 0x66, 0x66, 0x63, 0x37, 0x37, 0x62, 0x30, 0x65, 0x38, 0x39, 0x30, 0x38, 0x30, 0x33, 0x65, 0x31, 0x63, 0x64, 0x32, 0x36, 0x62, 0x66, 0x32, 0x30, 0x61, 0x30, 0x66, 0x32, 0x64, 0x32, 0x32, 0x61, 0x63, 0x65, 0x66, 0x37, 0x36, 0x34, 0x36, 0x62, 0x35, 0x66, 0x39, 0x62, 0x66, 0x30, 0x39, 0x30, 0x63, 0x34, 0x62, 0x64, 0x36, 0x64, 0x31, 0x35, 0x64, 0x36, 0x63, 0x37, 0x32, 0x64, 0x61, 0x31, 0x34, 0x39, 0x33, 0x38, 0x62, 0x36, 0x61, 0x37, 0x62, 0x36, 0x33, 0x38, 0x31, 0x38, 0x66, 0x32, 0x61, 0x31, 0x37, 0x33, 0x65, 0x36, 0x37, 0x39, 0x61, 0x35, 0x36, 0x32, 0x34, 0x64, 0x35, 0x36, 0x35, 0x38, 0x38, 0x65, 0x36, 0x61, 0x62, 0x35, 0x65, 0x36, 0x30, 0x38, 0x65, 0x39, 0x63, 0x39, 0x33, 0x31, 0x63, 0x66, 0x33, 0x36, 0x33, 0x34, 0x33, 0x66, 0x32, 0x36, 0x61, 0x63, 0x30, 0x36, 0x63, 0x34, 0x63, 0x36, 0x61, 0x38, 0x64, 0x31, 0x38, 0x30, 0x33, 0x39, 0x63, 0x36, 0x39, 0x63, 0x32, 0x30, 0x64, 0x34, 0x61, 0x63, 0x37, 0x32, 0x65, 0x34, 0x38, 0x38, 0x31, 0x35, 0x31, 0x32, 0x65, 0x61, 0x31, 0x61, 0x66, 0x61, 0x62, 0x39, 0x64, 0x33, 0x36, 0x30, 0x31, 0x62, 0x36, 0x36, 0x63, 0x35, 0x63, 0x31, 0x34, 0x31, 0x31, 0x36, 0x66, 0x34, 0x30, 0x31, 0x37, 0x34, 0x39, 0x64, 0x66, 0x37, 0x37, 0x61, 0x39, 0x35, 0x35, 0x31, 0x63, 0x37, 0x30, 0x62, 0x34, 0x62, 0x64, 0x39, 0x64, 0x65, 0x33, 0x38, 0x62, 0x37, 0x35, 0x31, 0x30, 0x33, 0x30, 0x65, 0x62, 0x37, 0x65, 0x62, 0x61, 0x63, 0x65, 0x30, 0x31, 0x61, 0x33, 0x30, 0x34, 0x64, 0x66, 0x39, 0x32, 0x65, 0x37, 0x38, 0x33, 0x39, 0x37, 0x65, 0x32, 0x63, 0x61, 0x63, 0x63, 0x34, 0x33, 0x36, 0x38, 0x66, 0x35, 0x62, 0x32, 0x62, 0x66, 0x33, 0x38, 0x32, 0x37, 0x61, 0x35, 0x36, 0x39, 0x62, 0x33, 0x65, 0x66, 0x30, 0x37, 0x63, 0x35, 0x66, 0x66, 0x65, 0x31, 0x33, 0x39, 0x36, 0x64, 0x37, 0x65, 0x39, 0x66, 0x62, 0x64, 0x63, 0x61, 0x30, 0x62, 0x38, 0x34, 0x31, 0x35, 0x37, 0x30, 0x64, 0x33, 0x30, 0x32, 0x63, 0x30, 0x35, 0x63, 0x31, 0x34, 0x32, 0x62, 0x64, 0x31, 0x66, 0x63, 0x37, 0x32, 0x63, 0x37, 0x35, 0x39, 0x66, 0x63, 0x64, 0x64, 0x64, 0x37, 0x36, 0x37, 0x63, 0x32, 0x36, 0x33, 0x61, 0x61, 0x37, 0x39, 0x33, 0x38, 0x34, 0x61, 0x37, 0x63, 0x65, 0x36, 0x36, 0x34, 0x63, 0x33, 0x63, 0x33, 0x31, 0x39, 0x34, 0x32, 0x66, 0x66, 0x39, 0x36, 0x34, 0x35, 0x39, 0x33, 0x37, 0x64, 0x35, 0x34, 0x65, 0x63, 0x38, 0x65, 0x37, 0x65, 0x66, 0x62, 0x36, 0x31, 0x34, 0x31, 0x30, 0x63, 0x37, 0x39, 0x66, 0x37, 0x65, 0x62, 0x36, 0x34, 0x30, 0x61, 0x62, 0x36, 0x37, 0x66, 0x39, 0x62, 0x33, 0x33, 0x37, 0x35, 0x35, 0x65, 0x36, 0x61, 0x66, 0x35, 0x65, 0x36, 0x66, 0x38, 0x64, 0x32, 0x39, 0x30, 0x30, 0x66, 0x65, 0x30, 0x38, 0x63, 0x31, 0x36, 0x64, 0x38, 0x38, 0x35, 0x66, 0x31, 0x36, 0x32, 0x64, 0x61, 0x62, 0x61, 0x36, 0x30, 0x39, 0x38, 0x34, 0x32, 0x65, 0x39, 0x34, 0x37, 0x37, 0x36, 0x63, 0x30, 0x38, 0x32, 0x32, 0x65, 0x35, 0x30, 0x33, 0x35, 0x31, 0x34, 0x35, 0x66, 0x62, 0x30, 0x30, 0x32, 0x36, 0x64, 0x64, 0x62, 0x37, 0x61, 0x31, 0x35, 0x30, 0x38, 0x32, 0x63, 0x35, 0x66, 0x64, 0x66, 0x63, 0x65, 0x65, 0x31, 0x39, 0x64, 0x32, 0x34, 0x62, 0x62, 0x32, 0x32, 0x30, 0x37, 0x30, 0x34, 0x61, 0x35, 0x64, 0x64, 0x31, 0x33, 0x36, 0x61, 0x65, 0x61, 0x37, 0x32, 0x33, 0x37, 0x65, 0x33, 0x66, 0x63, 0x64, 0x63, 0x37, 0x33, 0x63, 0x30, 0x30, 0x63, 0x65, 0x61, 0x65, 0x62, 0x37, 0x65, 0x31, 0x33, 0x33, 0x37, 0x35, 0x30, 0x33, 0x33, 0x66, 0x36, 0x33, 0x62, 0x38, 0x63, 0x32, 0x38, 0x62, 0x61, 0x66, 0x34, 0x36, 0x33, 0x64, 0x32, 0x65, 0x38, 0x65, 0x35, 0x34, 0x65, 0x38, 0x30, 0x39, 0x65, 0x64, 0x37, 0x62, 0x32, 0x34, 0x61, 0x64, 0x32, 0x37, 0x32, 0x38, 0x61, 0x34, 0x38, 0x36, 0x64, 0x34, 0x36, 0x30, 0x31, 0x64, 0x32, 0x63, 0x30, 0x34, 0x34, 0x64, 0x34, 0x31, 0x38, 0x38, 0x66, 0x62, 0x61, 0x38, 0x63, 0x66, 0x32, 0x63, 0x61, 0x31, 0x63, 0x32, 0x31, 0x62, 0x33, 0x33, 0x32, 0x38, 0x39, 0x65, 0x63, 0x30, 0x37, 0x37, 0x30, 0x65, 0x30, 0x66, 0x34, 0x66, 0x63, 0x65, 0x32, 0x35, 0x61, 0x66, 0x30, 0x66, 0x35, 0x66, 0x62, 0x37, 0x32, 0x36, 0x36, 0x39, 0x61, 0x35, 0x35, 0x63, 0x37, 0x37, 0x36, 0x36, 0x38, 0x62, 0x63, 0x30, 0x33, 0x61, 0x31, 0x36, 0x62, 0x38, 0x30, 0x63, 0x37, 0x31, 0x38, 0x63, 0x35, 0x66, 0x62, 0x38, 0x66, 0x64, 0x61, 0x61, 0x35, 0x39, 0x62, 0x38, 0x61, 0x64, 0x65, 0x61, 0x63, 0x65, 0x33, 0x61, 0x37, 0x32, 0x63, 0x65, 0x61, 0x39, 0x30, 0x35, 0x61, 0x65, 0x61, 0x30, 0x39, 0x39, 0x63, 0x36, 0x32, 0x33, 0x62, 0x36, 0x30, 0x37, 0x34, 0x33, 0x35, 0x62, 0x35, 0x63, 0x63, 0x33, 0x36, 0x34, 0x63, 0x35, 0x63, 0x63, 0x63, 0x65, 0x37, 0x35, 0x64, 0x36, 0x36, 0x37, 0x65, 0x61, 0x30, 0x34, 0x62, 0x64, 0x63, 0x34, 0x61, 0x34, 0x61, 0x64, 0x63, 0x33, 0x35, 0x61, 0x63, 0x62, 0x31, 0x38, 0x65, 0x64, 0x30, 0x39, 0x39, 0x63, 0x61, 0x38, 0x34, 0x38, 0x63, 0x30, 0x63, 0x36, 0x37, 0x37, 0x32, 0x61, 0x34, 0x66, 0x66, 0x35, 0x39, 0x36, 0x64, 0x34, 0x33, 0x32, 0x30, 0x61, 0x35, 0x30, 0x61, 0x35, 0x34, 0x35, 0x62, 0x36, 0x64, 0x65, 0x39, 0x33, 0x65, 0x66, 0x62, 0x64, 0x38, 0x36, 0x64, 0x66, 0x36, 0x38, 0x33, 0x30, 0x65, 0x30, 0x36, 0x66, 0x61, 0x63, 0x34, 0x37, 0x61, 0x63, 0x39, 0x35, 0x35, 0x35, 0x35, 0x64, 0x65, 0x61, 0x61, 0x34, 0x64, 0x32, 0x61, 0x33, 0x36, 0x37, 0x32, 0x34, 0x36, 0x35, 0x61, 0x36, 0x63, 0x64, 0x65, 0x38, 0x62, 0x64, 0x63, 0x65, 0x62, 0x64, 0x39, 0x36, 0x32, 0x31, 0x64, 0x36, 0x36, 0x64, 0x33, 0x39, 0x61, 0x65, 0x63, 0x65, 0x62, 0x30, 0x33, 0x32, 0x61, 0x61, 0x65, 0x37, 0x39, 0x30, 0x30, 0x65, 0x66, 0x32, 0x35, 0x36, 0x63, 0x35, 0x66, 0x64, 0x63, 0x64, 0x63, 0x32, 0x66, 0x34, 0x37, 0x64, 0x62, 0x31, 0x32, 0x61, 0x30, 0x37, 0x32, 0x32, 0x37, 0x30, 0x65, 0x39, 0x66, 0x65, 0x31, 0x33, 0x37, 0x36, 0x38, 0x30, 0x64, 0x33, 0x30, 0x31, 0x36, 0x62, 0x65, 0x33, 0x65, 0x61, 0x35, 0x30, 0x35, 0x33, 0x32, 0x37, 0x63, 0x31, 0x65, 0x31, 0x62, 0x64, 0x30, 0x39, 0x34, 0x31, 0x34, 0x32, 0x35, 0x62, 0x65, 0x61, 0x31, 0x62, 0x66, 0x31, 0x63, 0x35, 0x63, 0x66, 0x37, 0x32, 0x36, 0x34, 0x38, 0x38, 0x37, 0x30, 0x61, 0x37, 0x32, 0x64, 0x32, 0x31, 0x33, 0x64, 0x39, 0x39, 0x63, 0x65, 0x31, 0x34, 0x36, 0x31, 0x63, 0x31, 0x64, 0x62, 0x35, 0x39, 0x61, 0x32, 0x35, 0x33, 0x65, 0x65, 0x38, 0x62, 0x36, 0x39, 0x32, 0x30, 0x35, 0x36, 0x30, 0x65, 0x61, 0x39, 0x62, 0x37, 0x65, 0x61, 0x35, 0x61, 0x62, 0x31, 0x36, 0x37, 0x30, 0x30, 0x37, 0x38, 0x63, 0x62, 0x61, 0x32, 0x62, 0x37, 0x35, 0x63, 0x35, 0x34, 0x64, 0x33, 0x30, 0x39, 0x62, 0x34, 0x31, 0x61, 0x38, 0x35, 0x30, 0x61, 0x65, 0x34, 0x39, 0x32, 0x66, 0x66, 0x33, 0x63, 0x39, 0x35, 0x63, 0x32, 0x37, 0x35, 0x38, 0x34, 0x37, 0x34, 0x64, 0x35, 0x64, 0x39, 0x61, 0x35, 0x34, 0x65, 0x30, 0x35, 0x39, 0x38, 0x37, 0x66, 0x65, 0x62, 0x65, 0x33, 0x31, 0x31, 0x31, 0x38, 0x36, 0x33, 0x37, 0x65, 0x65, 0x38, 0x65, 0x66, 0x35, 0x66, 0x31, 0x64, 0x39, 0x37, 0x32, 0x36, 0x33, 0x36, 0x63, 0x65, 0x63, 0x62, 0x65, 0x63, 0x66, 0x39, 0x63, 0x34, 0x38, 0x66, 0x66, 0x39, 0x39, 0x34, 0x37, 0x33, 0x66, 0x62, 0x38, 0x37, 0x37, 0x33, 0x63, 0x31, 0x36, 0x32, 0x63, 0x32, 0x61, 0x32, 0x39, 0x30, 0x37, 0x64, 0x62, 0x62, 0x62, 0x35, 0x63, 0x62, 0x34, 0x35, 0x39, 0x38, 0x37, 0x38, 0x65, 0x63, 0x38, 0x31, 0x65, 0x32, 0x33, 0x36, 0x37, 0x33, 0x36, 0x37, 0x32, 0x64, 0x66, 0x34, 0x66, 0x66, 0x35, 0x38, 0x37, 0x34, 0x31, 0x61, 0x64, 0x35, 0x35, 0x38, 0x33, 0x32, 0x63, 0x35, 0x61, 0x34, 0x37, 0x37, 0x33, 0x35, 0x66, 0x34, 0x35, 0x62, 0x61, 0x38, 0x38, 0x63, 0x37, 0x65, 0x39, 0x34, 0x64, 0x39, 0x61, 0x61, 0x36, 0x37, 0x35, 0x62, 0x34, 0x63, 0x37, 0x34, 0x31, 0x32, 0x38, 0x31, 0x39, 0x38, 0x37, 0x38, 0x37, 0x33, 0x30, 0x62, 0x62, 0x34, 0x33, 0x31, 0x31, 0x32, 0x36, 0x36, 0x39, 0x34, 0x33, 0x39, 0x63, 0x39, 0x37, 0x34, 0x63, 0x30, 0x37, 0x35, 0x61, 0x61, 0x36, 0x32, 0x38, 0x31, 0x33, 0x63, 0x32, 0x39, 0x65, 0x66, 0x64, 0x63, 0x39, 0x62, 0x64, 0x61, 0x30, 0x63, 0x37, 0x33, 0x33, 0x32, 0x39, 0x62, 0x61, 0x31, 0x63, 0x32, 0x37, 0x31, 0x30, 0x32, 0x35, 0x39, 0x32, 0x30, 0x63, 0x36, 0x31, 0x31, 0x30, 0x35, 0x38, 0x37, 0x32, 0x65, 0x38, 0x63, 0x64, 0x65, 0x33, 0x37, 0x31, 0x38, 0x64, 0x64, 0x30, 0x62, 0x37, 0x61, 0x37, 0x38, 0x62, 0x62, 0x35, 0x31, 0x37, 0x37, 0x33, 0x63, 0x36, 0x37, 0x61, 0x66, 0x37, 0x34, 0x65, 0x30, 0x61, 0x33, 0x30, 0x34, 0x32, 0x35, 0x32, 0x38, 0x65, 0x63, 0x35, 0x30, 0x34, 0x34, 0x32, 0x35, 0x38, 0x37, 0x30, 0x30, 0x62, 0x64, 0x34, 0x39, 0x30, 0x36, 0x31, 0x64, 0x33, 0x32, 0x63, 0x32, 0x63, 0x62, 0x61, 0x30, 0x61, 0x66, 0x31, 0x62, 0x37, 0x37, 0x37, 0x31, 0x37, 0x38, 0x31, 0x65, 0x61, 0x35, 0x35, 0x30, 0x30, 0x37, 0x35, 0x37, 0x31, 0x36, 0x37, 0x34, 0x31, 0x38, 0x31, 0x35, 0x66, 0x36, 0x37, 0x65, 0x64, 0x30, 0x65, 0x62, 0x64, 0x34, 0x35, 0x33, 0x32, 0x61, 0x65, 0x33, 0x36, 0x36, 0x32, 0x33, 0x66, 0x32, 0x36, 0x31, 0x33, 0x61, 0x64, 0x36, 0x30, 0x37, 0x32, 0x30, 0x31, 0x64, 0x36, 0x65, 0x38, 0x31, 0x35, 0x35, 0x66, 0x30, 0x66, 0x38, 0x34, 0x34, 0x33, 0x32, 0x66, 0x35, 0x66, 0x63, 0x34, 0x38, 0x31, 0x31, 0x65, 0x39, 0x38, 0x63, 0x61, 0x62, 0x36, 0x30, 0x33, 0x63, 0x34, 0x30, 0x62, 0x63, 0x65, 0x62, 0x36, 0x30, 0x39, 0x31, 0x61, 0x62, 0x64, 0x66, 0x65, 0x36, 0x62, 0x38, 0x63, 0x33, 0x31, 0x33, 0x66, 0x38, 0x65, 0x63, 0x38, 0x35, 0x66, 0x61, 0x31, 0x36, 0x62, 0x65, 0x36, 0x36, 0x61, 0x63, 0x39, 0x37, 0x31, 0x37, 0x37, 0x63, 0x37, 0x33, 0x34, 0x64, 0x35, 0x65, 0x37, 0x65, 0x30, 0x38, 0x66, 0x66, 0x33, 0x66, 0x35, 0x34, 0x61, 0x39, 0x37, 0x30, 0x61, 0x34, 0x39, 0x35, 0x30, 0x35, 0x64, 0x36, 0x36, 0x38, 0x39, 0x36, 0x33, 0x32, 0x62, 0x65, 0x66, 0x36, 0x65, 0x39, 0x32, 0x61, 0x32, 0x31, 0x34, 0x39, 0x61, 0x30, 0x65, 0x65, 0x63, 0x32, 0x38, 0x34, 0x30, 0x30, 0x65, 0x37, 0x39, 0x64, 0x65, 0x33, 0x33, 0x31, 0x39, 0x33, 0x64, 0x32, 0x61, 0x39, 0x62, 0x65, 0x31, 0x37, 0x33, 0x36, 0x65, 0x39, 0x30, 0x34, 0x39, 0x35, 0x31, 0x37, 0x39, 0x30, 0x38, 0x35, 0x30, 0x36, 0x33, 0x35, 0x34, 0x39, 0x32, 0x36, 0x30, 0x39, 0x62, 0x39, 0x33, 0x36, 0x66, 0x30, 0x37, 0x36, 0x30, 0x63, 0x36, 0x61, 0x62, 0x37, 0x32, 0x39, 0x33, 0x61, 0x66, 0x39, 0x38, 0x62, 0x65, 0x35, 0x37, 0x34, 0x39, 0x34, 0x36, 0x61, 0x35, 0x61, 0x31, 0x32, 0x38, 0x35, 0x35, 0x61, 0x30, 0x31, 0x38, 0x31, 0x36, 0x61, 0x39, 0x30, 0x66, 0x31, 0x36, 0x32, 0x32, 0x30, 0x30, 0x65, 0x38, 0x30, 0x63, 0x34, 0x34, 0x65, 0x64, 0x65, 0x36, 0x34, 0x34, 0x33, 0x64, 0x62, 0x33, 0x33, 0x63, 0x34, 0x61, 0x33, 0x66, 0x66, 0x64, 0x37, 0x32, 0x62, 0x63, 0x61, 0x37, 0x61, 0x34, 0x63, 0x39, 0x38, 0x35, 0x33, 0x31, 0x37, 0x38, 0x37, 0x30, 0x65, 0x32, 0x32, 0x61, 0x35, 0x65, 0x33, 0x64, 0x34, 0x62, 0x39, 0x65, 0x32, 0x39, 0x39, 0x37, 0x65, 0x30, 0x38, 0x33, 0x30, 0x31, 0x34, 0x34, 0x36, 0x61, 0x39, 0x33, 0x34, 0x64, 0x35, 0x39, 0x62, 0x61, 0x61, 0x63, 0x62, 0x61, 0x32, 0x33, 0x61, 0x66, 0x34, 0x34, 0x66, 0x34, 0x37, 0x32, 0x62, 0x34, 0x32, 0x37, 0x37, 0x34, 0x65, 0x39, 0x61, 0x61, 0x32, 0x63, 0x32, 0x33, 0x61, 0x61, 0x62, 0x63, 0x39, 0x36, 0x64, 0x63, 0x36, 0x62, 0x39, 0x63, 0x32, 0x38, 0x39, 0x39, 0x36, 0x38, 0x37, 0x34, 0x64, 0x36, 0x65, 0x39, 0x34, 0x32, 0x62, 0x30, 0x38, 0x66, 0x62, 0x33, 0x32, 0x36, 0x33, 0x61, 0x32, 0x61, 0x32, 0x32, 0x33, 0x61, 0x36, 0x31, 0x66, 0x30, 0x36, 0x33, 0x37, 0x32, 0x30, 0x34, 0x64, 0x61, 0x38, 0x34, 0x32, 0x66, 0x63, 0x31, 0x36, 0x33, 0x62, 0x36, 0x39, 0x65, 0x63, 0x30, 0x36, 0x33, 0x63, 0x35, 0x64, 0x30, 0x37, 0x33, 0x39, 0x30, 0x34, 0x36, 0x31, 0x63, 0x38, 0x30, 0x64, 0x30, 0x63, 0x35, 0x35, 0x63, 0x32, 0x66, 0x63, 0x34, 0x35, 0x33, 0x63, 0x61, 0x35, 0x65, 0x65, 0x37, 0x34, 0x32, 0x35, 0x33, 0x65, 0x66, 0x32, 0x36, 0x63, 0x63, 0x37, 0x32, 0x66, 0x37, 0x64, 0x33, 0x39, 0x65, 0x66, 0x32, 0x66, 0x64, 0x38, 0x37, 0x31, 0x61, 0x65, 0x64, 0x30, 0x39, 0x38, 0x35, 0x39, 0x63, 0x36, 0x66, 0x62, 0x65, 0x61, 0x38, 0x36, 0x64, 0x37, 0x63, 0x61, 0x65, 0x36, 0x35, 0x36, 0x64, 0x35, 0x34, 0x39, 0x65, 0x31, 0x33, 0x62, 0x65, 0x64, 0x38, 0x30, 0x32, 0x62, 0x39, 0x62, 0x32, 0x35, 0x32, 0x62, 0x32, 0x65, 0x62, 0x36, 0x66, 0x30, 0x61, 0x32, 0x34, 0x38, 0x38, 0x64, 0x30, 0x33, 0x66, 0x62, 0x63, 0x37, 0x39, 0x35, 0x36, 0x61, 0x61, 0x37, 0x30, 0x36, 0x32, 0x66, 0x37, 0x37, 0x30, 0x63, 0x36, 0x39, 0x39, 0x39, 0x37, 0x31, 0x61, 0x39, 0x39, 0x31, 0x30, 0x37, 0x63, 0x39, 0x66, 0x36, 0x64, 0x62, 0x61, 0x38, 0x37, 0x61, 0x65, 0x33, 0x33, 0x34, 0x64, 0x32, 0x62, 0x66, 0x31, 0x36, 0x61, 0x30, 0x35, 0x37, 0x30, 0x33, 0x35, 0x34, 0x37, 0x35, 0x64, 0x32, 0x38, 0x36, 0x36, 0x30, 0x36, 0x37, 0x31, 0x36, 0x32, 0x30, 0x62, 0x38, 0x32, 0x66, 0x39, 0x32, 0x31, 0x62, 0x61, 0x32, 0x37, 0x33, 0x66, 0x39, 0x37, 0x33, 0x64, 0x34, 0x35, 0x63, 0x61, 0x37, 0x35, 0x37, 0x30, 0x37, 0x38, 0x36, 0x37, 0x36, 0x33, 0x30, 0x64, 0x61, 0x39, 0x34, 0x39, 0x31, 0x64, 0x30, 0x62, 0x30, 0x61, 0x39, 0x65, 0x33, 0x61, 0x31, 0x39, 0x35, 0x39, 0x34, 0x33, 0x32, 0x64, 0x34, 0x34, 0x37, 0x34, 0x32, 0x36, 0x35, 0x30, 0x36, 0x35, 0x63, 0x65, 0x34, 0x35, 0x34, 0x64, 0x34, 0x64, 0x39, 0x66, 0x32, 0x38, 0x35, 0x62, 0x64, 0x64, 0x31, 0x32, 0x64, 0x39, 0x38, 0x63, 0x32, 0x35, 0x38, 0x62, 0x62, 0x31, 0x37, 0x61, 0x33, 0x37, 0x35, 0x34, 0x65, 0x30, 0x32, 0x38, 0x62, 0x38, 0x30, 0x61, 0x34, 0x32, 0x37, 0x36, 0x37, 0x32, 0x32, 0x62, 0x34, 0x35, 0x65, 0x34, 0x35, 0x36, 0x35, 0x34, 0x66, 0x32, 0x31, 0x64, 0x64, 0x36, 0x38, 0x34, 0x37, 0x39, 0x37, 0x36, 0x64, 0x39, 0x62, 0x34, 0x63, 0x39, 0x66, 0x64, 0x62, 0x35, 0x38, 0x39, 0x63, 0x33, 0x34, 0x66, 0x38, 0x33, 0x34, 0x32, 0x36, 0x61, 0x31, 0x35, 0x39, 0x32, 0x32, 0x30, 0x31, 0x33, 0x63, 0x66, 0x61, 0x63, 0x32, 0x34, 0x64, 0x37, 0x65, 0x39, 0x37, 0x32, 0x65, 0x31, 0x62, 0x38, 0x37, 0x38, 0x39, 0x35, 0x66, 0x66, 0x63, 0x61, 0x64, 0x63, 0x37, 0x36, 0x36, 0x64, 0x36, 0x36, 0x65, 0x34, 0x64, 0x39, 0x33, 0x39, 0x39, 0x61, 0x66, 0x31, 0x37, 0x36, 0x61, 0x37, 0x34, 0x37, 0x63, 0x37, 0x65, 0x32, 0x31, 0x36, 0x66, 0x63, 0x34, 0x36, 0x31, 0x31, 0x32, 0x62, 0x38, 0x31, 0x35, 0x30, 0x34, 0x38, 0x37, 0x34, 0x66, 0x63, 0x30, 0x38, 0x36, 0x66, 0x33, 0x64, 0x32, 0x63, 0x35, 0x36, 0x36, 0x37, 0x37, 0x62, 0x30, 0x65, 0x30, 0x62, 0x63, 0x64, 0x38, 0x37, 0x63, 0x35, 0x34, 0x65, 0x31, 0x65, 0x64, 0x32, 0x30, 0x61, 0x33, 0x64, 0x64, 0x39, 0x39, 0x39, 0x64, 0x30, 0x38, 0x62, 0x63, 0x39, 0x31, 0x61, 0x36, 0x63, 0x34, 0x34, 0x65, 0x38, 0x34, 0x66, 0x31, 0x30, 0x32, 0x35, 0x34, 0x30, 0x36, 0x61, 0x33, 0x30, 0x32, 0x64, 0x37, 0x32, 0x34, 0x62, 0x65, 0x66, 0x61, 0x63, 0x38, 0x35, 0x62, 0x34, 0x33, 0x65, 0x35, 0x31, 0x35, 0x36, 0x30, 0x36, 0x66, 0x66, 0x36, 0x65, 0x35, 0x32, 0x63, 0x33, 0x36, 0x62, 0x39, 0x34, 0x64, 0x33, 0x35, 0x32, 0x62, 0x37, 0x64, 0x65, 0x34, 0x35, 0x65, 0x66, 0x32, 0x33, 0x64, 0x64, 0x62, 0x65, 0x30, 0x37, 0x63, 0x35, 0x64, 0x34, 0x31, 0x64, 0x62, 0x32, 0x64, 0x37, 0x39, 0x33, 0x36, 0x33, 0x34, 0x64, 0x39, 0x62, 0x38, 0x36, 0x30, 0x37, 0x36, 0x31, 0x65, 0x30, 0x30, 0x34, 0x35, 0x39, 0x64, 0x39, 0x36, 0x63, 0x62, 0x37, 0x30, 0x62, 0x39, 0x39, 0x38, 0x31, 0x33, 0x36, 0x38, 0x31, 0x37, 0x31, 0x30, 0x37, 0x32, 0x65, 0x39, 0x34, 0x35, 0x64, 0x64, 0x66, 0x31, 0x32, 0x35, 0x35, 0x31, 0x66, 0x34, 0x35, 0x66, 0x63, 0x61, 0x35, 0x34, 0x65, 0x65, 0x39, 0x63, 0x62, 0x37, 0x32, 0x65, 0x62, 0x36, 0x65, 0x35, 0x34, 0x30, 0x65, 0x62, 0x39, 0x30, 0x66, 0x34, 0x65, 0x30, 0x38, 0x32, 0x32, 0x31, 0x61, 0x35, 0x31, 0x64, 0x61, 0x31, 0x37, 0x35, 0x32, 0x38, 0x33, 0x34, 0x39, 0x38, 0x66, 0x38, 0x65, 0x64, 0x33, 0x37, 0x34, 0x34, 0x31, 0x39, 0x62, 0x39, 0x30, 0x35, 0x32, 0x33, 0x38, 0x62, 0x34, 0x39, 0x65, 0x34, 0x65, 0x30, 0x64, 0x39, 0x34, 0x36, 0x65, 0x37, 0x32, 0x61, 0x64, 0x33, 0x31, 0x65, 0x65, 0x35, 0x34, 0x62, 0x34, 0x63, 0x39, 0x30, 0x36, 0x39, 0x61, 0x63, 0x65, 0x61, 0x35, 0x66, 0x66, 0x63, 0x39, 0x39, 0x30, 0x38, 0x35, 0x31, 0x65, 0x34, 0x30, 0x31, 0x35, 0x30, 0x66, 0x34, 0x36, 0x66, 0x34, 0x37, 0x39, 0x33, 0x39, 0x32, 0x34, 0x65, 0x37, 0x37, 0x61, 0x30, 0x63, 0x62, 0x35, 0x38, 0x62, 0x34, 0x66, 0x64, 0x62, 0x36, 0x39, 0x35, 0x30, 0x62, 0x62, 0x33, 0x37, 0x37, 0x34, 0x32, 0x64, 0x65, 0x33, 0x32, 0x63, 0x33, 0x65, 0x32, 0x34, 0x30, 0x31, 0x34, 0x36, 0x37, 0x65, 0x32, 0x39, 0x35, 0x31, 0x33, 0x61, 0x32, 0x65, 0x61, 0x31, 0x37, 0x34, 0x31, 0x63, 0x64, 0x31, 0x31, 0x32, 0x38, 0x64, 0x34, 0x31, 0x64, 0x33, 0x61, 0x38, 0x31, 0x35, 0x31, 0x32, 0x38, 0x65, 0x34, 0x61, 0x65, 0x30, 0x62, 0x33, 0x30, 0x65, 0x37, 0x32, 0x36, 0x32, 0x36, 0x36, 0x38, 0x61, 0x39, 0x36, 0x66, 0x65, 0x32, 0x37, 0x35, 0x36, 0x65, 0x65, 0x36, 0x32, 0x39, 0x33, 0x34, 0x33, 0x36, 0x36, 0x39, 0x30, 0x64, 0x32, 0x63, 0x39, 0x64, 0x38, 0x37, 0x64, 0x65, 0x63, 0x61, 0x30, 0x62, 0x36, 0x36, 0x61, 0x65, 0x64, 0x62, 0x30, 0x38, 0x33, 0x33, 0x38, 0x38, 0x66, 0x39, 0x31, 0x35, 0x39, 0x37, 0x35, 0x31, 0x61, 0x31, 0x61, 0x37, 0x32, 0x63, 0x34, 0x37, 0x34, 0x38, 0x63, 0x31, 0x34, 0x35, 0x30, 0x65, 0x38, 0x65, 0x33, 0x32, 0x65, 0x66, 0x33, 0x38, 0x32, 0x66, 0x30, 0x34, 0x33, 0x33, 0x61, 0x36, 0x30, 0x37, 0x63, 0x31, 0x65, 0x33, 0x64, 0x36, 0x39, 0x63, 0x35, 0x34, 0x32, 0x64, 0x37, 0x37, 0x31, 0x61, 0x63, 0x64, 0x63, 0x37, 0x34, 0x34, 0x65, 0x39, 0x32, 0x64, 0x35, 0x64, 0x39, 0x34, 0x38, 0x34, 0x66, 0x30, 0x31, 0x63, 0x62, 0x64, 0x66, 0x31, 0x61, 0x37, 0x62, 0x38, 0x32, 0x34, 0x38, 0x66, 0x34, 0x36, 0x34, 0x33, 0x62, 0x65, 0x37, 0x63, 0x38, 0x32, 0x61, 0x62, 0x63, 0x65, 0x34, 0x35, 0x31, 0x36, 0x35, 0x38, 0x39, 0x39, 0x64, 0x37, 0x30, 0x66, 0x32, 0x37, 0x37, 0x62, 0x30, 0x38, 0x34, 0x35, 0x39, 0x61, 0x37, 0x38, 0x34, 0x32, 0x30, 0x38, 0x33, 0x61, 0x38, 0x63, 0x32, 0x38, 0x34, 0x37, 0x32, 0x39, 0x65, 0x65, 0x37, 0x38, 0x33, 0x33, 0x38, 0x39, 0x33, 0x31, 0x39, 0x64, 0x62, 0x61, 0x65, 0x37, 0x36, 0x38, 0x30, 0x36, 0x66, 0x63, 0x62, 0x36, 0x64, 0x62, 0x65, 0x36, 0x39, 0x62, 0x36, 0x31, 0x38, 0x30, 0x39, 0x62, 0x35, 0x36, 0x33, 0x66, 0x36, 0x30, 0x65, 0x64, 0x66, 0x35, 0x64, 0x62, 0x64, 0x31, 0x66, 0x38, 0x33, 0x65, 0x30, 0x35, 0x39, 0x61, 0x62, 0x33, 0x64, 0x34, 0x32, 0x66, 0x33, 0x66, 0x37, 0x34, 0x37, 0x32, 0x36, 0x38, 0x34, 0x31, 0x61, 0x62, 0x65, 0x30, 0x35, 0x35, 0x39, 0x32, 0x36, 0x66, 0x34, 0x38, 0x33, 0x64, 0x37, 0x63, 0x36, 0x63, 0x65, 0x39, 0x30, 0x31, 0x65, 0x66, 0x36, 0x37, 0x32, 0x38, 0x33, 0x39, 0x66, 0x32, 0x30, 0x65, 0x36, 0x62, 0x63, 0x35, 0x35, 0x33, 0x64, 0x66, 0x30, 0x65, 0x64, 0x37, 0x39, 0x63, 0x30, 0x64, 0x30, 0x37, 0x32, 0x62, 0x66, 0x38, 0x31, 0x30, 0x32, 0x35, 0x61, 0x64, 0x35, 0x66, 0x66, 0x61, 0x35, 0x33, 0x37, 0x63, 0x36, 0x33, 0x36, 0x33, 0x64, 0x62, 0x30, 0x34, 0x61, 0x31, 0x30, 0x36, 0x64, 0x66, 0x61, 0x30, 0x31, 0x61, 0x34, 0x62, 0x30, 0x39, 0x35, 0x31, 0x62, 0x32, 0x39, 0x36, 0x62, 0x35, 0x63, 0x65, 0x61, 0x63, 0x61, 0x66, 0x31, 0x30, 0x33, 0x34, 0x65, 0x33, 0x32, 0x33, 0x65, 0x30, 0x30, 0x64, 0x35, 0x33, 0x64, 0x35, 0x38, 0x30, 0x32, 0x64, 0x33, 0x32, 0x36, 0x31, 0x30, 0x32, 0x66, 0x39, 0x35, 0x66, 0x35, 0x33, 0x62, 0x34, 0x32, 0x35, 0x37, 0x34, 0x33, 0x36, 0x63, 0x35, 0x61, 0x37, 0x36, 0x61, 0x61, 0x63, 0x61, 0x61, 0x34, 0x65, 0x66, 0x37, 0x30, 0x38, 0x36, 0x34, 0x35, 0x65, 0x32, 0x38, 0x32, 0x31, 0x39, 0x31, 0x63, 0x39, 0x66, 0x66, 0x30, 0x33, 0x39, 0x33, 0x39, 0x36, 0x65, 0x39, 0x33, 0x30, 0x65, 0x62, 0x65, 0x61, 0x36, 0x30, 0x33, 0x36, 0x62, 0x33, 0x63, 0x64, 0x64, 0x34, 0x62, 0x38, 0x62, 0x37, 0x30, 0x62, 0x39, 0x38, 0x64, 0x32, 0x64, 0x39, 0x65, 0x35, 0x31, 0x35, 0x38, 0x36, 0x64, 0x63, 0x61, 0x38, 0x66, 0x66, 0x34, 0x31, 0x62, 0x34, 0x61, 0x65, 0x32, 0x31, 0x34, 0x63, 0x61, 0x63, 0x37, 0x62, 0x66, 0x37, 0x63, 0x61, 0x64, 0x37, 0x32, 0x33, 0x32, 0x61, 0x32, 0x38, 0x61, 0x36, 0x30, 0x37, 0x37, 0x63, 0x66, 0x39, 0x62, 0x33, 0x37, 0x32, 0x31, 0x37, 0x65, 0x39, 0x34, 0x33, 0x62, 0x34, 0x66, 0x30, 0x32, 0x66, 0x35, 0x64, 0x64, 0x63, 0x37, 0x66, 0x38, 0x39, 0x31, 0x30, 0x36, 0x63, 0x63, 0x64, 0x38, 0x33, 0x34, 0x64, 0x39, 0x66, 0x39, 0x66, 0x64, 0x34, 0x36, 0x30, 0x34, 0x63, 0x33, 0x39, 0x64, 0x39, 0x34, 0x37, 0x32, 0x62, 0x31, 0x64, 0x66, 0x63, 0x32, 0x30, 0x37, 0x33, 0x35, 0x66, 0x62, 0x39, 0x38, 0x37, 0x62, 0x62, 0x64, 0x66, 0x38, 0x61, 0x33, 0x35, 0x39, 0x63, 0x31, 0x63, 0x36, 0x34, 0x63, 0x36, 0x64, 0x66, 0x33, 0x65, 0x66, 0x66, 0x62, 0x33, 0x63, 0x66, 0x33, 0x64, 0x36, 0x35, 0x38, 0x33, 0x66, 0x39, 0x66, 0x65, 0x62, 0x30, 0x62, 0x66, 0x37, 0x64, 0x62, 0x64, 0x30, 0x33, 0x39, 0x37, 0x32, 0x63, 0x64, 0x64, 0x34, 0x62, 0x37, 0x65, 0x30, 0x37, 0x36, 0x36, 0x36, 0x30, 0x65, 0x62, 0x61, 0x65, 0x61, 0x36, 0x30, 0x38, 0x65, 0x64, 0x63, 0x36, 0x37, 0x33, 0x36, 0x38, 0x30, 0x31, 0x35, 0x33, 0x64, 0x36, 0x31, 0x63, 0x35, 0x39, 0x36, 0x33, 0x64, 0x30, 0x37, 0x38, 0x66, 0x37, 0x61, 0x32, 0x30, 0x65, 0x37, 0x30, 0x36, 0x63, 0x39, 0x38, 0x34, 0x36, 0x35, 0x62, 0x32, 0x37, 0x32, 0x63, 0x37, 0x37, 0x31, 0x62, 0x61, 0x30, 0x37, 0x64, 0x39, 0x32, 0x32, 0x31, 0x39, 0x37, 0x66, 0x62, 0x38, 0x35, 0x36, 0x34, 0x31, 0x35, 0x30, 0x39, 0x66, 0x36, 0x65, 0x36, 0x65, 0x39, 0x66, 0x30, 0x63, 0x64, 0x66, 0x32, 0x35, 0x31, 0x31, 0x35, 0x65, 0x38, 0x63, 0x39, 0x66, 0x62, 0x36, 0x38, 0x32, 0x61, 0x33, 0x39, 0x37, 0x61, 0x62, 0x38, 0x30, 0x32, 0x31, 0x34, 0x33, 0x34, 0x38, 0x63, 0x39, 0x39, 0x62, 0x63, 0x32, 0x35, 0x34, 0x38, 0x66, 0x33, 0x32, 0x31, 0x62, 0x32, 0x35, 0x62, 0x30, 0x63, 0x62, 0x34, 0x37, 0x62, 0x37, 0x62, 0x30, 0x65, 0x31, 0x61, 0x37, 0x35, 0x66, 0x65, 0x65, 0x31, 0x66, 0x39, 0x37, 0x33, 0x64, 0x61, 0x35, 0x61, 0x39, 0x30, 0x30, 0x64, 0x31, 0x35, 0x64, 0x66, 0x39, 0x36, 0x37, 0x64, 0x30, 0x62, 0x63, 0x33, 0x34, 0x63, 0x39, 0x37, 0x32, 0x33, 0x31, 0x38, 0x37, 0x35, 0x65, 0x30, 0x39, 0x62, 0x30, 0x65, 0x64, 0x36, 0x34, 0x30, 0x31, 0x36, 0x63, 0x35, 0x63, 0x65, 0x39, 0x64, 0x37, 0x37, 0x64, 0x30, 0x63, 0x62, 0x63, 0x37, 0x39, 0x31, 0x35, 0x63, 0x35, 0x38, 0x31, 0x37, 0x39, 0x38, 0x37, 0x39, 0x33, 0x38, 0x38, 0x32, 0x37, 0x34, 0x36, 0x35, 0x61, 0x34, 0x64, 0x65, 0x66, 0x38, 0x30, 0x31, 0x63, 0x33, 0x61, 0x33, 0x62, 0x62, 0x62, 0x30, 0x62, 0x63, 0x66, 0x62, 0x65, 0x33, 0x38, 0x35, 0x64, 0x62, 0x61, 0x61, 0x64, 0x33, 0x64, 0x39, 0x30, 0x35, 0x34, 0x31, 0x39, 0x38, 0x39, 0x31, 0x33, 0x65, 0x39, 0x34, 0x35, 0x38, 0x38, 0x33, 0x61, 0x39, 0x61, 0x35, 0x37, 0x37, 0x63, 0x35, 0x66, 0x31, 0x63, 0x64, 0x65, 0x65, 0x33, 0x38, 0x34, 0x39, 0x32, 0x34, 0x37, 0x63, 0x39, 0x61, 0x36, 0x64, 0x34, 0x36, 0x36, 0x37, 0x62, 0x34, 0x63, 0x35, 0x36, 0x33, 0x33, 0x34, 0x30, 0x61, 0x62, 0x36, 0x62, 0x63, 0x34, 0x39, 0x64, 0x31, 0x30, 0x31, 0x33, 0x61, 0x66, 0x31, 0x32, 0x32, 0x34, 0x66, 0x38, 0x39, 0x30, 0x62, 0x65, 0x63, 0x31, 0x36, 0x30, 0x65, 0x32, 0x37, 0x39, 0x37, 0x37, 0x61, 0x32, 0x30, 0x33, 0x32, 0x61, 0x33, 0x62, 0x35, 0x30, 0x34, 0x35, 0x65, 0x33, 0x65, 0x31, 0x66, 0x63, 0x37, 0x32, 0x32, 0x63, 0x65, 0x32, 0x66, 0x38, 0x63, 0x64, 0x61, 0x35, 0x61, 0x64, 0x65, 0x62, 0x31, 0x32, 0x30, 0x38, 0x61, 0x66, 0x65, 0x39, 0x61, 0x66, 0x36, 0x39, 0x34, 0x37, 0x37, 0x31, 0x61, 0x35, 0x39, 0x65, 0x66, 0x37, 0x38, 0x61, 0x66, 0x63, 0x32, 0x65, 0x61, 0x30, 0x62, 0x63, 0x63, 0x61, 0x62, 0x35, 0x36, 0x32, 0x34, 0x61, 0x34, 0x33, 0x31, 0x62, 0x32, 0x34, 0x39, 0x36, 0x37, 0x32, 0x30, 0x63, 0x34, 0x36, 0x64, 0x38, 0x30, 0x31, 0x39, 0x33, 0x35, 0x62, 0x63, 0x37, 0x30, 0x31, 0x33, 0x39, 0x65, 0x34, 0x34, 0x64, 0x32, 0x65, 0x66, 0x64, 0x63, 0x38, 0x34, 0x36, 0x35, 0x66, 0x39, 0x35, 0x65, 0x32, 0x33, 0x36, 0x39, 0x35, 0x36, 0x31, 0x37, 0x66, 0x32, 0x35, 0x36, 0x64, 0x62, 0x38, 0x66, 0x33, 0x38, 0x36, 0x35, 0x37, 0x65, 0x36, 0x35, 0x65, 0x66, 0x33, 0x37, 0x32, 0x37, 0x66, 0x33, 0x33, 0x64, 0x38, 0x36, 0x33, 0x35, 0x35, 0x31, 0x37, 0x65, 0x31, 0x66, 0x36, 0x34, 0x33, 0x39, 0x33, 0x63, 0x34, 0x34, 0x36, 0x33, 0x37, 0x65, 0x37, 0x61, 0x62, 0x62, 0x63, 0x62, 0x33, 0x39, 0x34, 0x37, 0x39, 0x34, 0x38, 0x37, 0x38, 0x64, 0x65, 0x64, 0x62, 0x33, 0x63, 0x31, 0x62, 0x61, 0x66, 0x61, 0x66, 0x37, 0x32, 0x62, 0x64, 0x61, 0x36, 0x35, 0x34, 0x37, 0x32, 0x33, 0x32, 0x39, 0x38, 0x39, 0x64, 0x36, 0x38, 0x35, 0x37, 0x61, 0x64, 0x32, 0x65, 0x39, 0x33, 0x31, 0x64, 0x35, 0x31, 0x34, 0x35, 0x64, 0x37, 0x32, 0x64, 0x65, 0x30, 0x35, 0x65, 0x64, 0x37, 0x65, 0x34, 0x39, 0x30, 0x62, 0x36, 0x66, 0x63, 0x30, 0x66, 0x62, 0x65, 0x65, 0x33, 0x36, 0x31, 0x35, 0x35, 0x34, 0x32, 0x36, 0x33, 0x34, 0x63, 0x64, 0x30, 0x61, 0x63, 0x63, 0x65, 0x35, 0x30, 0x31, 0x62, 0x39, 0x65, 0x39, 0x61, 0x36, 0x35, 0x35, 0x38, 0x61, 0x66, 0x30, 0x30, 0x31, 0x64, 0x34, 0x64, 0x34, 0x34, 0x65, 0x38, 0x66, 0x31, 0x35, 0x65, 0x33, 0x33, 0x63, 0x38, 0x62, 0x62, 0x35, 0x31, 0x33, 0x39, 0x32, 0x63, 0x62, 0x30, 0x32, 0x64, 0x34, 0x33, 0x36, 0x38, 0x30, 0x30, 0x32, 0x32, 0x36, 0x65, 0x33, 0x65, 0x63, 0x36, 0x31, 0x66, 0x38, 0x31, 0x66, 0x61, 0x37, 0x32, 0x64, 0x65, 0x30, 0x63, 0x35, 0x31, 0x34, 0x30, 0x35, 0x33, 0x34, 0x39, 0x35, 0x31, 0x32, 0x39, 0x36, 0x35, 0x31, 0x31, 0x65, 0x65, 0x37, 0x64, 0x34, 0x33, 0x33, 0x32, 0x63, 0x61, 0x39, 0x35, 0x65, 0x37, 0x62, 0x62, 0x61, 0x30, 0x63, 0x64, 0x36, 0x63, 0x30, 0x66, 0x38, 0x66, 0x61, 0x62, 0x30, 0x31, 0x61, 0x30, 0x61, 0x32, 0x32, 0x37, 0x39, 0x38, 0x35, 0x62, 0x38, 0x63, 0x37, 0x32, 0x64, 0x66, 0x30, 0x65, 0x31, 0x36, 0x62, 0x35, 0x30, 0x64, 0x62, 0x61, 0x38, 0x37, 0x32, 0x66, 0x39, 0x37, 0x31, 0x62, 0x31, 0x30, 0x61, 0x33, 0x61, 0x37, 0x38, 0x31, 0x39, 0x62, 0x62, 0x32, 0x61, 0x34, 0x30, 0x35, 0x61, 0x61, 0x39, 0x62, 0x64, 0x65, 0x31, 0x36, 0x31, 0x38, 0x35, 0x35, 0x39, 0x31, 0x62, 0x34, 0x34, 0x63, 0x38, 0x35, 0x34, 0x66, 0x63, 0x64, 0x34, 0x31, 0x37, 0x32, 0x36, 0x36, 0x62, 0x64, 0x63, 0x30, 0x37, 0x37, 0x34, 0x39, 0x35, 0x64, 0x38, 0x32, 0x35, 0x34, 0x35, 0x39, 0x62, 0x36, 0x64, 0x35, 0x65, 0x30, 0x38, 0x64, 0x33, 0x31, 0x38, 0x33, 0x64, 0x38, 0x35, 0x64, 0x63, 0x34, 0x31, 0x66, 0x35, 0x38, 0x33, 0x37, 0x31, 0x63, 0x61, 0x37, 0x36, 0x63, 0x33, 0x38, 0x35, 0x34, 0x34, 0x63, 0x38, 0x31, 0x63, 0x39, 0x39, 0x35, 0x66, 0x30, 0x32, 0x66, 0x32, 0x32, 0x39, 0x63, 0x30, 0x61, 0x66, 0x64, 0x62, 0x62, 0x64, 0x32, 0x65, 0x63, 0x62, 0x32, 0x66, 0x66, 0x66, 0x32, 0x62, 0x35, 0x62, 0x38, 0x31, 0x64, 0x66, 0x32, 0x31, 0x39, 0x64, 0x32, 0x37, 0x33, 0x33, 0x31, 0x30, 0x64, 0x66, 0x66, 0x34, 0x37, 0x31, 0x33, 0x63, 0x63, 0x62, 0x66, 0x62, 0x34, 0x30, 0x63, 0x66, 0x32, 0x33, 0x34, 0x62, 0x31, 0x35, 0x38, 0x37, 0x61, 0x36, 0x38, 0x30, 0x65, 0x33, 0x62, 0x34, 0x36, 0x61, 0x36, 0x61, 0x64, 0x34, 0x64, 0x30, 0x64, 0x64, 0x38, 0x32, 0x37, 0x34, 0x30, 0x35, 0x34, 0x65, 0x38, 0x36, 0x33, 0x37, 0x63, 0x33, 0x31, 0x63, 0x65, 0x66, 0x30, 0x35, 0x39, 0x31, 0x38, 0x61, 0x32, 0x37, 0x65, 0x32, 0x62, 0x31, 0x62, 0x36, 0x37, 0x63, 0x32, 0x34, 0x37, 0x37, 0x37, 0x36, 0x37, 0x36, 0x61, 0x37, 0x31, 0x34, 0x35, 0x36, 0x61, 0x65, 0x39, 0x33, 0x66, 0x37, 0x66, 0x62, 0x39, 0x38, 0x32, 0x63, 0x36, 0x32, 0x62, 0x39, 0x65, 0x32, 0x63, 0x32, 0x65, 0x63, 0x63, 0x35, 0x34, 0x36, 0x33, 0x34, 0x64, 0x35, 0x65, 0x38, 0x64, 0x34, 0x37, 0x64, 0x63, 0x37, 0x31, 0x32, 0x36, 0x65, 0x64, 0x65, 0x36, 0x65, 0x66, 0x61, 0x65, 0x66, 0x30, 0x37, 0x32, 0x38, 0x37, 0x65, 0x37, 0x61, 0x64, 0x34, 0x30, 0x33, 0x31, 0x32, 0x37, 0x35, 0x34, 0x33, 0x39, 0x34, 0x34, 0x64, 0x66, 0x36, 0x36, 0x65, 0x34, 0x64, 0x39, 0x34, 0x32, 0x62, 0x62, 0x64, 0x37, 0x62, 0x65, 0x62, 0x34, 0x62, 0x34, 0x63, 0x31, 0x30, 0x30, 0x66, 0x35, 0x37, 0x38, 0x64, 0x32, 0x36, 0x65, 0x34, 0x66, 0x30, 0x33, 0x63, 0x64, 0x61, 0x32, 0x65, 0x61, 0x35, 0x32, 0x62, 0x66, 0x35, 0x33, 0x35, 0x33, 0x64, 0x63, 0x39, 0x37, 0x64, 0x33, 0x35, 0x61, 0x63, 0x62, 0x61, 0x33, 0x32, 0x63, 0x35, 0x62, 0x33, 0x38, 0x66, 0x36, 0x38, 0x34, 0x62, 0x34, 0x63, 0x62, 0x37, 0x63, 0x34, 0x33, 0x66, 0x36, 0x30, 0x62, 0x34, 0x33, 0x37, 0x34, 0x37, 0x35, 0x63, 0x37, 0x65, 0x39, 0x66, 0x63, 0x63, 0x65, 0x37, 0x31, 0x30, 0x35, 0x62, 0x37, 0x38, 0x39, 0x34, 0x37, 0x32, 0x36, 0x62, 0x33, 0x37, 0x34, 0x62, 0x62, 0x36, 0x61, 0x65, 0x31, 0x37, 0x32, 0x63, 0x36, 0x62, 0x30, 0x39, 0x62, 0x35, 0x38, 0x61, 0x35, 0x38, 0x61, 0x65, 0x62, 0x32, 0x66, 0x64, 0x38, 0x35, 0x32, 0x39, 0x35, 0x62, 0x62, 0x63, 0x63, 0x32, 0x36, 0x33, 0x31, 0x33, 0x32, 0x66, 0x39, 0x61, 0x38, 0x63, 0x34, 0x36, 0x61, 0x37, 0x64, 0x36, 0x39, 0x37, 0x66, 0x36, 0x64, 0x35, 0x37, 0x65, 0x35, 0x61, 0x31, 0x38, 0x63, 0x31, 0x36, 0x62, 0x62, 0x64, 0x65, 0x35, 0x38, 0x63, 0x64, 0x64, 0x31, 0x63, 0x65, 0x34, 0x64, 0x64, 0x61, 0x30, 0x32, 0x31, 0x65, 0x62, 0x31, 0x37, 0x34, 0x34, 0x37, 0x63, 0x39, 0x66, 0x66, 0x61, 0x65, 0x38, 0x35, 0x37, 0x64, 0x34, 0x30, 0x64, 0x38, 0x37, 0x66, 0x33, 0x34, 0x37, 0x34, 0x36, 0x38, 0x65, 0x31, 0x64, 0x66, 0x61, 0x63, 0x63, 0x32, 0x37, 0x39, 0x39, 0x62, 0x33, 0x61, 0x36, 0x39, 0x63, 0x32, 0x61, 0x30, 0x31, 0x33, 0x32, 0x39, 0x62, 0x34, 0x32, 0x33, 0x62, 0x39, 0x62, 0x38, 0x65, 0x65, 0x38, 0x63, 0x32, 0x61, 0x30, 0x37, 0x39, 0x61, 0x62, 0x64, 0x61, 0x30, 0x64, 0x36, 0x66, 0x30, 0x62, 0x63, 0x62, 0x65, 0x36, 0x39, 0x61, 0x34, 0x34, 0x61, 0x30, 0x33, 0x31, 0x39, 0x35, 0x66, 0x62, 0x31, 0x35, 0x30, 0x33, 0x61, 0x37, 0x33, 0x64, 0x32, 0x31, 0x30, 0x61, 0x39, 0x66, 0x38, 0x30, 0x37, 0x36, 0x39, 0x36, 0x38, 0x34, 0x38, 0x34, 0x65, 0x61, 0x66, 0x38, 0x37, 0x66, 0x62, 0x61, 0x34, 0x30, 0x33, 0x61, 0x39, 0x35, 0x36, 0x36, 0x30, 0x39, 0x65, 0x63, 0x33, 0x61, 0x38, 0x36, 0x63, 0x33, 0x66, 0x37, 0x62, 0x36, 0x33, 0x64, 0x66, 0x32, 0x33, 0x38, 0x65, 0x32, 0x33, 0x39, 0x36, 0x35, 0x38, 0x36, 0x66, 0x31, 0x30, 0x66, 0x32, 0x36, 0x30, 0x66, 0x63, 0x61, 0x39, 0x62, 0x61, 0x35, 0x61, 0x37, 0x33, 0x34, 0x32, 0x37, 0x32, 0x63, 0x64, 0x35, 0x34, 0x34, 0x34, 0x62, 0x64, 0x62, 0x61, 0x61, 0x35, 0x35, 0x63, 0x38, 0x38, 0x38, 0x35, 0x38, 0x63, 0x30, 0x65, 0x34, 0x37, 0x33, 0x30, 0x36, 0x32, 0x39, 0x37, 0x36, 0x66, 0x66, 0x61, 0x61, 0x65, 0x32, 0x33, 0x65, 0x62, 0x63, 0x31, 0x34, 0x64, 0x32, 0x39, 0x37, 0x32, 0x39, 0x33, 0x33, 0x32, 0x35, 0x33, 0x38, 0x31, 0x37, 0x32, 0x65, 0x39, 0x34, 0x36, 0x32, 0x39, 0x66, 0x39, 0x61, 0x36, 0x38, 0x37, 0x39, 0x63, 0x31, 0x31, 0x37, 0x61, 0x62, 0x33, 0x33, 0x63, 0x30, 0x34, 0x65, 0x38, 0x31, 0x39, 0x61, 0x34, 0x33, 0x39, 0x35, 0x65, 0x63, 0x37, 0x30, 0x63, 0x37, 0x36, 0x36, 0x30, 0x32, 0x62, 0x64, 0x36, 0x62, 0x63, 0x33, 0x36, 0x63, 0x39, 0x66, 0x39, 0x65, 0x31, 0x65, 0x33, 0x63, 0x38, 0x30, 0x65, 0x37, 0x32, 0x62, 0x39, 0x61, 0x65, 0x62, 0x66, 0x39, 0x37, 0x33, 0x32, 0x66, 0x63, 0x33, 0x62, 0x63, 0x64, 0x30, 0x32, 0x35, 0x64, 0x35, 0x39, 0x36, 0x30, 0x30, 0x36, 0x37, 0x39, 0x36, 0x62, 0x37, 0x31, 0x32, 0x30, 0x37, 0x37, 0x37, 0x38, 0x35, 0x65, 0x37, 0x64, 0x30, 0x65, 0x38, 0x37, 0x62, 0x37, 0x33, 0x37, 0x66, 0x30, 0x61, 0x33, 0x65, 0x35, 0x63, 0x34, 0x33, 0x38, 0x30, 0x65, 0x33, 0x61, 0x65, 0x62, 0x36, 0x37, 0x65, 0x36, 0x36, 0x34, 0x65, 0x65, 0x63, 0x65, 0x64, 0x35, 0x62, 0x33, 0x30, 0x33, 0x39, 0x66, 0x36, 0x33, 0x31, 0x62, 0x38, 0x30, 0x39, 0x39, 0x33, 0x32, 0x33, 0x35, 0x33, 0x39, 0x66, 0x35, 0x63, 0x39, 0x63, 0x38, 0x36, 0x34, 0x61, 0x32, 0x62, 0x34, 0x66, 0x38, 0x31, 0x30, 0x32, 0x63, 0x32, 0x62, 0x64, 0x33, 0x38, 0x65, 0x66, 0x39, 0x64, 0x33, 0x37, 0x32, 0x31, 0x36, 0x64, 0x31, 0x36, 0x36, 0x32, 0x64, 0x30, 0x34, 0x33, 0x66, 0x35, 0x39, 0x66, 0x30, 0x32, 0x35, 0x64, 0x39, 0x33, 0x37, 0x39, 0x64, 0x36, 0x63, 0x34, 0x32, 0x30, 0x66, 0x32, 0x37, 0x39, 0x34, 0x35, 0x37, 0x39, 0x66, 0x63, 0x61, 0x62, 0x30, 0x30, 0x33, 0x61, 0x62, 0x66, 0x38, 0x33, 0x61, 0x32, 0x31, 0x36, 0x61, 0x65, 0x64, 0x65, 0x33, 0x37, 0x65, 0x64, 0x34, 0x37, 0x32, 0x64, 0x65, 0x39, 0x31, 0x37, 0x34, 0x38, 0x33, 0x64, 0x37, 0x64, 0x63, 0x62, 0x31, 0x66, 0x64, 0x36, 0x37, 0x31, 0x38, 0x34, 0x63, 0x36, 0x30, 0x32, 0x61, 0x65, 0x63, 0x32, 0x38, 0x32, 0x32, 0x64, 0x37, 0x32, 0x37, 0x65, 0x63, 0x64, 0x62, 0x65, 0x39, 0x39, 0x36, 0x64, 0x62, 0x66, 0x66, 0x66, 0x36, 0x37, 0x34, 0x61, 0x62, 0x30, 0x61, 0x63, 0x65, 0x33, 0x39, 0x31, 0x62, 0x31, 0x37, 0x62, 0x65, 0x36, 0x66, 0x64, 0x31, 0x38, 0x32, 0x37, 0x39, 0x39, 0x63, 0x38, 0x36, 0x66, 0x31, 0x38, 0x31, 0x32, 0x66, 0x63, 0x66, 0x35, 0x39, 0x31, 0x63, 0x37, 0x30, 0x33, 0x66, 0x63, 0x65, 0x30, 0x33, 0x36, 0x30, 0x61, 0x35, 0x65, 0x62, 0x34, 0x64, 0x37, 0x35, 0x38, 0x32, 0x64, 0x31, 0x33, 0x32, 0x32, 0x63, 0x33, 0x38, 0x62, 0x32, 0x32, 0x32, 0x66, 0x63, 0x61, 0x35, 0x37, 0x32, 0x39, 0x32, 0x37, 0x66, 0x36, 0x62, 0x35, 0x63, 0x64, 0x63, 0x38, 0x36, 0x31, 0x36, 0x39, 0x36, 0x34, 0x32, 0x66, 0x63, 0x37, 0x33, 0x61, 0x30, 0x32, 0x37, 0x33, 0x66, 0x32, 0x61, 0x35, 0x32, 0x64, 0x30, 0x61, 0x62, 0x63, 0x35, 0x30, 0x37, 0x64, 0x62, 0x37, 0x35, 0x35, 0x30, 0x37, 0x66, 0x64, 0x61, 0x34, 0x63, 0x37, 0x38, 0x37, 0x35, 0x37, 0x38, 0x39, 0x39, 0x64, 0x36, 0x31, 0x35, 0x64, 0x63, 0x37, 0x33, 0x64, 0x65, 0x34, 0x61, 0x64, 0x31, 0x31, 0x31, 0x65, 0x39, 0x63, 0x64, 0x64, 0x66, 0x37, 0x37, 0x61, 0x65, 0x37, 0x64, 0x63, 0x62, 0x34, 0x61, 0x66, 0x36, 0x64, 0x34, 0x63, 0x32, 0x37, 0x62, 0x66, 0x38, 0x37, 0x62, 0x38, 0x34, 0x36, 0x31, 0x66, 0x63, 0x38, 0x61, 0x34, 0x38, 0x35, 0x34, 0x31, 0x37, 0x62, 0x64, 0x63, 0x38, 0x36, 0x64, 0x62, 0x65, 0x37, 0x32, 0x31, 0x37, 0x31, 0x38, 0x35, 0x34, 0x31, 0x62, 0x63, 0x61, 0x63, 0x36, 0x61, 0x32, 0x34, 0x65, 0x65, 0x32, 0x35, 0x34, 0x30, 0x66, 0x34, 0x66, 0x62, 0x39, 0x65, 0x38, 0x32, 0x62, 0x66, 0x62, 0x63, 0x34, 0x32, 0x62, 0x35, 0x65, 0x32, 0x61, 0x35, 0x63, 0x37, 0x36, 0x31, 0x39, 0x66, 0x34, 0x64, 0x30, 0x39, 0x35, 0x31, 0x63, 0x36, 0x36, 0x37, 0x63, 0x64, 0x31, 0x33, 0x31, 0x34, 0x30, 0x62, 0x35, 0x39, 0x39, 0x34, 0x38, 0x37, 0x63, 0x62, 0x61, 0x31, 0x34, 0x36, 0x35, 0x31, 0x30, 0x36, 0x61, 0x31, 0x30, 0x63, 0x30, 0x61, 0x38, 0x35, 0x30, 0x65, 0x35, 0x63, 0x35, 0x65, 0x66, 0x34, 0x66, 0x66, 0x30, 0x64, 0x36, 0x62, 0x31, 0x66, 0x33, 0x31, 0x38, 0x34, 0x37, 0x63, 0x64, 0x36, 0x62, 0x37, 0x35, 0x61, 0x62, 0x62, 0x33, 0x34, 0x30, 0x38, 0x63, 0x61, 0x37, 0x37, 0x32, 0x34, 0x33, 0x38, 0x34, 0x32, 0x35, 0x61, 0x62, 0x38, 0x32, 0x33, 0x66, 0x32, 0x36, 0x31, 0x39, 0x66, 0x32, 0x33, 0x66, 0x31, 0x65, 0x30, 0x36, 0x30, 0x38, 0x66, 0x62, 0x64, 0x35, 0x30, 0x39, 0x61, 0x66, 0x62, 0x38, 0x37, 0x33, 0x61, 0x65, 0x30, 0x37, 0x61, 0x62, 0x33, 0x34, 0x65, 0x36, 0x62, 0x34, 0x62, 0x66, 0x66, 0x35, 0x37, 0x39, 0x66, 0x37, 0x62, 0x37, 0x33, 0x34, 0x31, 0x38, 0x36, 0x39, 0x32, 0x61, 0x65, 0x63, 0x64, 0x34, 0x66, 0x39, 0x36, 0x64, 0x61, 0x61, 0x34, 0x34, 0x32, 0x65, 0x39, 0x31, 0x30, 0x37, 0x63, 0x62, 0x66, 0x30, 0x33, 0x66, 0x35, 0x36, 0x35, 0x35, 0x65, 0x33, 0x38, 0x30, 0x62, 0x33, 0x63, 0x39, 0x64, 0x35, 0x38, 0x61, 0x66, 0x65, 0x66, 0x65, 0x61, 0x39, 0x38, 0x34, 0x63, 0x30, 0x34, 0x61, 0x64, 0x66, 0x34, 0x31, 0x38, 0x33, 0x35, 0x64, 0x33, 0x63, 0x31, 0x31, 0x62, 0x34, 0x61, 0x38, 0x30, 0x34, 0x36, 0x61, 0x39, 0x66, 0x64, 0x64, 0x64, 0x39, 0x34, 0x61, 0x33, 0x32, 0x32, 0x35, 0x37, 0x37, 0x63, 0x62, 0x33, 0x35, 0x39, 0x36, 0x30, 0x31, 0x65, 0x64, 0x33, 0x32, 0x39, 0x66, 0x65, 0x65, 0x32, 0x66, 0x38, 0x61, 0x37, 0x62, 0x34, 0x33, 0x63, 0x61, 0x38, 0x66, 0x63, 0x65, 0x35, 0x32, 0x34, 0x66, 0x66, 0x63, 0x34, 0x32, 0x33, 0x30, 0x61, 0x66, 0x31, 0x63, 0x31, 0x66, 0x65, 0x35, 0x34, 0x64, 0x35, 0x35, 0x62, 0x62, 0x61, 0x39, 0x34, 0x33, 0x63, 0x61, 0x34, 0x66, 0x35, 0x65, 0x32, 0x64, 0x37, 0x62, 0x62, 0x37, 0x35, 0x65, 0x34, 0x36, 0x66, 0x36, 0x34, 0x62, 0x34, 0x37, 0x30, 0x61, 0x31, 0x32, 0x63, 0x33, 0x61, 0x36, 0x30, 0x62, 0x32, 0x63, 0x35, 0x65, 0x36, 0x65, 0x32, 0x62, 0x33, 0x61, 0x32, 0x34, 0x64, 0x32, 0x63, 0x34, 0x36, 0x66, 0x30, 0x35, 0x65, 0x31, 0x36, 0x31, 0x34, 0x37, 0x39, 0x33, 0x61, 0x30, 0x38, 0x63, 0x65, 0x34, 0x64, 0x30, 0x35, 0x35, 0x34, 0x38, 0x33, 0x63, 0x31, 0x65, 0x32, 0x31, 0x37, 0x38, 0x62, 0x31, 0x62, 0x34, 0x61, 0x64, 0x31, 0x61, 0x33, 0x62, 0x34, 0x39, 0x63, 0x38, 0x65, 0x37, 0x63, 0x31, 0x34, 0x31, 0x61, 0x32, 0x32, 0x31, 0x32, 0x63, 0x37, 0x32, 0x65, 0x38, 0x32, 0x33, 0x36, 0x35, 0x36, 0x32, 0x62, 0x66, 0x63, 0x35, 0x33, 0x65, 0x38, 0x62, 0x62, 0x30, 0x64, 0x39, 0x34, 0x35, 0x65, 0x64, 0x35, 0x30, 0x35, 0x64, 0x39, 0x64, 0x34, 0x30, 0x64, 0x33, 0x62, 0x39, 0x30, 0x32, 0x61, 0x35, 0x33, 0x63, 0x66, 0x31, 0x37, 0x62, 0x33, 0x65, 0x30, 0x36, 0x38, 0x37, 0x61, 0x36, 0x34, 0x37, 0x62, 0x30, 0x31, 0x35, 0x63, 0x30, 0x37, 0x32, 0x33, 0x63, 0x36, 0x36, 0x62, 0x32, 0x30, 0x63, 0x33, 0x32, 0x37, 0x32, 0x36, 0x66, 0x33, 0x37, 0x31, 0x62, 0x38, 0x39, 0x31, 0x36, 0x38, 0x34, 0x63, 0x62, 0x39, 0x62, 0x30, 0x61, 0x39, 0x35, 0x37, 0x36, 0x31, 0x35, 0x31, 0x61, 0x35, 0x66, 0x35, 0x62, 0x39, 0x31, 0x62, 0x34, 0x38, 0x62, 0x33, 0x62, 0x66, 0x36, 0x61, 0x63, 0x32, 0x38, 0x38, 0x63, 0x63, 0x66, 0x65, 0x33, 0x37, 0x32, 0x65, 0x39, 0x37, 0x38, 0x63, 0x35, 0x62, 0x33, 0x33, 0x63, 0x35, 0x35, 0x65, 0x32, 0x63, 0x65, 0x35, 0x38, 0x32, 0x65, 0x65, 0x62, 0x36, 0x63, 0x35, 0x36, 0x36, 0x61, 0x35, 0x62, 0x30, 0x36, 0x63, 0x63, 0x35, 0x37, 0x63, 0x62, 0x30, 0x61, 0x38, 0x65, 0x33, 0x62, 0x66, 0x38, 0x62, 0x31, 0x39, 0x65, 0x33, 0x31, 0x39, 0x34, 0x33, 0x36, 0x36, 0x63, 0x31, 0x38, 0x61, 0x62, 0x37, 0x32, 0x63, 0x35, 0x32, 0x37, 0x35, 0x33, 0x33, 0x66, 0x37, 0x36, 0x33, 0x37, 0x35, 0x66, 0x32, 0x63, 0x36, 0x66, 0x32, 0x39, 0x66, 0x61, 0x64, 0x35, 0x31, 0x38, 0x37, 0x62, 0x31, 0x62, 0x65, 0x33, 0x62, 0x65, 0x39, 0x32, 0x36, 0x61, 0x32, 0x39, 0x39, 0x63, 0x62, 0x36, 0x34, 0x65, 0x37, 0x31, 0x63, 0x39, 0x62, 0x62, 0x61, 0x30, 0x39, 0x34, 0x62, 0x31, 0x61, 0x61, 0x66, 0x64, 0x32, 0x37, 0x64, 0x63, 0x62, 0x33, 0x34, 0x64, 0x34, 0x30, 0x33, 0x36, 0x62, 0x63, 0x32, 0x62, 0x30, 0x34, 0x33, 0x39, 0x61, 0x37, 0x36, 0x66, 0x63, 0x66, 0x61, 0x33, 0x39, 0x36, 0x32, 0x62, 0x35, 0x37, 0x64, 0x39, 0x32, 0x63, 0x34, 0x33, 0x66, 0x34, 0x32, 0x32, 0x33, 0x39, 0x34, 0x65, 0x63, 0x62, 0x38, 0x34, 0x31, 0x63, 0x63, 0x64, 0x38, 0x61, 0x62, 0x32, 0x31, 0x65, 0x37, 0x33, 0x31, 0x34, 0x39, 0x63, 0x35, 0x36, 0x34, 0x63, 0x34, 0x64, 0x39, 0x33, 0x34, 0x35, 0x33, 0x62, 0x61, 0x37, 0x35, 0x62, 0x36, 0x66, 0x34, 0x33, 0x66, 0x62, 0x35, 0x64, 0x33, 0x63, 0x64, 0x61, 0x63, 0x37, 0x33, 0x65, 0x61, 0x35, 0x31, 0x31, 0x37, 0x32, 0x35, 0x33, 0x33, 0x36, 0x34, 0x37, 0x32, 0x65, 0x61, 0x63, 0x33, 0x66, 0x32, 0x38, 0x64, 0x64, 0x37, 0x38, 0x33, 0x36, 0x38, 0x30, 0x37, 0x32, 0x34, 0x32, 0x35, 0x39, 0x32, 0x33, 0x38, 0x38, 0x38, 0x38, 0x37, 0x65, 0x61, 0x63, 0x32, 0x37, 0x33, 0x33, 0x32, 0x31, 0x61, 0x38, 0x66, 0x33, 0x66, 0x66, 0x32, 0x34, 0x34, 0x36, 0x37, 0x34, 0x62, 0x39, 0x39, 0x64, 0x66, 0x65, 0x32, 0x39, 0x34, 0x65, 0x39, 0x62, 0x61, 0x63, 0x65, 0x36, 0x37, 0x34, 0x32, 0x32, 0x66, 0x62, 0x34, 0x36, 0x64, 0x37, 0x61, 0x31, 0x62, 0x61, 0x37, 0x32, 0x33, 0x31, 0x64, 0x66, 0x32, 0x30, 0x30, 0x66, 0x39, 0x63, 0x33, 0x30, 0x62, 0x65, 0x36, 0x36, 0x64, 0x65, 0x39, 0x61, 0x63, 0x65, 0x34, 0x63, 0x66, 0x36, 0x32, 0x31, 0x35, 0x34, 0x62, 0x32, 0x32, 0x38, 0x65, 0x38, 0x66, 0x32, 0x33, 0x64, 0x33, 0x66, 0x38, 0x36, 0x33, 0x33, 0x31, 0x39, 0x30, 0x35, 0x63, 0x64, 0x37, 0x31, 0x33, 0x36, 0x62, 0x35, 0x34, 0x66, 0x63, 0x37, 0x37, 0x32, 0x61, 0x30, 0x38, 0x64, 0x31, 0x61, 0x35, 0x38, 0x31, 0x39, 0x38, 0x39, 0x62, 0x37, 0x30, 0x32, 0x62, 0x65, 0x66, 0x39, 0x66, 0x61, 0x63, 0x64, 0x35, 0x66, 0x30, 0x31, 0x33, 0x62, 0x61, 0x37, 0x37, 0x64, 0x32, 0x66, 0x65, 0x39, 0x64, 0x35, 0x39, 0x33, 0x30, 0x32, 0x66, 0x36, 0x33, 0x33, 0x64, 0x34, 0x39, 0x37, 0x38, 0x36, 0x32, 0x64, 0x31, 0x61, 0x64, 0x66, 0x62, 0x39, 0x34, 0x39, 0x63, 0x30, 0x39, 0x35, 0x37, 0x66, 0x64, 0x34, 0x38, 0x63, 0x38, 0x65, 0x37, 0x65, 0x30, 0x32, 0x62, 0x65, 0x61, 0x63, 0x61, 0x63, 0x38, 0x62, 0x37, 0x61, 0x30, 0x36, 0x30, 0x62, 0x34, 0x37, 0x36, 0x38, 0x39, 0x35, 0x36, 0x38, 0x63, 0x35, 0x63, 0x36, 0x64, 0x39, 0x31, 0x36, 0x63, 0x30, 0x64, 0x63, 0x64, 0x62, 0x38, 0x64, 0x61, 0x61, 0x35, 0x66, 0x66, 0x38, 0x64, 0x34, 0x31, 0x31, 0x31, 0x34, 0x38, 0x33, 0x31, 0x30, 0x37, 0x32, 0x30, 0x37, 0x37, 0x64, 0x32, 0x65, 0x35, 0x30, 0x36, 0x32, 0x32, 0x36, 0x32, 0x66, 0x39, 0x36, 0x63, 0x38, 0x32, 0x32, 0x32, 0x30, 0x35, 0x37, 0x38, 0x65, 0x63, 0x30, 0x38, 0x32, 0x31, 0x32, 0x37, 0x38, 0x65, 0x30, 0x30, 0x30, 0x34, 0x36, 0x34, 0x34, 0x37, 0x61, 0x33, 0x38, 0x66, 0x63, 0x39, 0x32, 0x61, 0x30, 0x66, 0x61, 0x37, 0x32, 0x38, 0x30, 0x64, 0x39, 0x65, 0x63, 0x37, 0x66, 0x37, 0x64, 0x66, 0x37, 0x63, 0x31, 0x61, 0x34, 0x36, 0x36, 0x32, 0x31, 0x34, 0x37, 0x63, 0x38, 0x65, 0x33, 0x31, 0x62, 0x39, 0x64, 0x32, 0x63, 0x38, 0x65, 0x61, 0x35, 0x36, 0x30, 0x35, 0x61, 0x65, 0x38, 0x34, 0x61, 0x37, 0x33, 0x39, 0x36, 0x34, 0x33, 0x38, 0x63, 0x30, 0x33, 0x30, 0x61, 0x65, 0x63, 0x37, 0x39, 0x30, 0x66, 0x37, 0x32, 0x37, 0x63, 0x64, 0x36, 0x36, 0x64, 0x32, 0x34, 0x36, 0x61, 0x31, 0x31, 0x39, 0x32, 0x62, 0x33, 0x34, 0x31, 0x33, 0x34, 0x63, 0x38, 0x39, 0x31, 0x63, 0x39, 0x66, 0x62, 0x63, 0x63, 0x66, 0x34, 0x33, 0x66, 0x61, 0x37, 0x61, 0x33, 0x65, 0x62, 0x37, 0x36, 0x63, 0x32, 0x61, 0x39, 0x34, 0x37, 0x65, 0x37, 0x33, 0x65, 0x66, 0x38, 0x37, 0x38, 0x62, 0x62, 0x65, 0x30, 0x65, 0x64, 0x33, 0x65, 0x32, 0x39, 0x65, 0x61, 0x37, 0x62, 0x62, 0x36, 0x62, 0x31, 0x30, 0x38, 0x31, 0x33, 0x35, 0x31, 0x66, 0x34, 0x30, 0x63, 0x33, 0x31, 0x63, 0x39, 0x63, 0x33, 0x63, 0x34, 0x35, 0x66, 0x65, 0x36, 0x65, 0x61, 0x39, 0x63, 0x39, 0x66, 0x38, 0x65, 0x39, 0x36, 0x32, 0x64, 0x33, 0x32, 0x32, 0x36, 0x61, 0x34, 0x31, 0x31, 0x33, 0x36, 0x39, 0x36, 0x35, 0x30, 0x39, 0x35, 0x33, 0x61, 0x37, 0x32, 0x39, 0x36, 0x64, 0x38, 0x31, 0x39, 0x38, 0x38, 0x66, 0x34, 0x65, 0x30, 0x65, 0x62, 0x31, 0x65, 0x61, 0x62, 0x30, 0x32, 0x38, 0x37, 0x64, 0x64, 0x62, 0x36, 0x31, 0x34, 0x63, 0x61, 0x66, 0x36, 0x32, 0x33, 0x61, 0x37, 0x34, 0x63, 0x39, 0x31, 0x37, 0x64, 0x37, 0x35, 0x36, 0x30, 0x39, 0x30, 0x30, 0x39, 0x33, 0x35, 0x65, 0x64, 0x34, 0x30, 0x33, 0x37, 0x36, 0x32, 0x30, 0x35, 0x31, 0x39, 0x37, 0x35, 0x64, 0x35, 0x30, 0x33, 0x62, 0x32, 0x34, 0x61, 0x30, 0x63, 0x38, 0x39, 0x35, 0x38, 0x34, 0x61, 0x34, 0x35, 0x36, 0x64, 0x39, 0x66, 0x63, 0x33, 0x66, 0x39, 0x30, 0x66, 0x65, 0x63, 0x66, 0x66, 0x38, 0x63, 0x32, 0x62, 0x39, 0x39, 0x33, 0x66, 0x66, 0x35, 0x36, 0x64, 0x35, 0x33, 0x66, 0x32, 0x65, 0x31, 0x32, 0x34, 0x33, 0x34, 0x36, 0x66, 0x34, 0x34, 0x61, 0x63, 0x34, 0x34, 0x39, 0x37, 0x38, 0x62, 0x38, 0x61, 0x65, 0x39, 0x34, 0x61, 0x61, 0x34, 0x32, 0x61, 0x37, 0x61, 0x63, 0x62, 0x39, 0x62, 0x66, 0x30, 0x61, 0x33, 0x63, 0x65, 0x39, 0x65, 0x33, 0x39, 0x32, 0x30, 0x37, 0x61, 0x63, 0x63, 0x65, 0x61, 0x31, 0x39, 0x62, 0x61, 0x62, 0x39, 0x30, 0x32, 0x65, 0x64, 0x39, 0x61, 0x62, 0x34, 0x63, 0x36, 0x64, 0x33, 0x61, 0x61, 0x62, 0x36, 0x63, 0x30, 0x37, 0x32, 0x38, 0x64, 0x62, 0x33, 0x62, 0x31, 0x30, 0x35, 0x30, 0x31, 0x39, 0x32, 0x33, 0x39, 0x61, 0x64, 0x35, 0x33, 0x39, 0x35, 0x65, 0x33, 0x32, 0x35, 0x66, 0x33, 0x63, 0x37, 0x37, 0x33, 0x36, 0x37, 0x63, 0x34, 0x35, 0x62, 0x33, 0x37, 0x30, 0x33, 0x63, 0x38, 0x38, 0x38, 0x63, 0x34, 0x64, 0x32, 0x64, 0x39, 0x36, 0x35, 0x32, 0x64, 0x62, 0x39, 0x63, 0x34, 0x33, 0x31, 0x62, 0x61, 0x37, 0x32, 0x39, 0x39, 0x61, 0x38, 0x31, 0x30, 0x61, 0x38, 0x39, 0x37, 0x37, 0x34, 0x39, 0x39, 0x30, 0x30, 0x31, 0x66, 0x65, 0x33, 0x63, 0x66, 0x33, 0x37, 0x65, 0x36, 0x30, 0x32, 0x65, 0x64, 0x39, 0x33, 0x38, 0x65, 0x62, 0x35, 0x30, 0x34, 0x32, 0x63, 0x38, 0x66, 0x64, 0x33, 0x37, 0x64, 0x66, 0x31, 0x32, 0x64, 0x61, 0x31, 0x31, 0x38, 0x32, 0x65, 0x64, 0x31, 0x65, 0x61, 0x30, 0x31, 0x32, 0x65, 0x39, 0x63, 0x30, 0x38, 0x36, 0x34, 0x61, 0x34, 0x66, 0x36, 0x63, 0x31, 0x61, 0x30, 0x64, 0x35, 0x31, 0x32, 0x65, 0x32, 0x63, 0x65, 0x33, 0x39, 0x34, 0x37, 0x66, 0x62, 0x61, 0x36, 0x34, 0x34, 0x30, 0x32, 0x30, 0x39, 0x36, 0x38, 0x64, 0x38, 0x34, 0x38, 0x33, 0x62, 0x64, 0x62, 0x35, 0x64, 0x38, 0x32, 0x38, 0x61, 0x35, 0x38, 0x61, 0x61, 0x36, 0x39, 0x62, 0x35, 0x64, 0x61, 0x31, 0x30, 0x65, 0x38, 0x35, 0x61, 0x66, 0x34, 0x30, 0x34, 0x39, 0x62, 0x34, 0x34, 0x32, 0x34, 0x61, 0x37, 0x36, 0x39, 0x63, 0x37, 0x30, 0x30, 0x36, 0x65, 0x31, 0x33, 0x30, 0x36, 0x37, 0x61, 0x34, 0x65, 0x64, 0x34, 0x39, 0x32, 0x66, 0x36, 0x32, 0x35, 0x65, 0x61, 0x61, 0x61, 0x62, 0x61, 0x65, 0x38, 0x63, 0x38, 0x33, 0x34, 0x62, 0x37, 0x65, 0x38, 0x62, 0x61, 0x66, 0x31, 0x66, 0x64, 0x33, 0x62, 0x64, 0x62, 0x38, 0x65, 0x38, 0x63, 0x32, 0x62, 0x65, 0x35, 0x61, 0x37, 0x31, 0x65, 0x66, 0x33, 0x36, 0x65, 0x39, 0x62, 0x64, 0x35, 0x63, 0x33, 0x65, 0x63, 0x63, 0x34, 0x36, 0x65, 0x62, 0x33, 0x31, 0x63, 0x61, 0x34, 0x31, 0x37, 0x39, 0x32, 0x30, 0x31, 0x65, 0x62, 0x65, 0x34, 0x61, 0x66, 0x38, 0x63, 0x33, 0x33, 0x62, 0x32, 0x39, 0x39, 0x38, 0x33, 0x31, 0x64, 0x32, 0x33, 0x35, 0x64, 0x61, 0x38, 0x31, 0x62, 0x30, 0x63, 0x62, 0x61, 0x61, 0x61, 0x64, 0x30, 0x64, 0x61, 0x63, 0x37, 0x33, 0x35, 0x30, 0x30, 0x65, 0x62, 0x38, 0x62, 0x34, 0x62, 0x30, 0x63, 0x34, 0x61, 0x63, 0x38, 0x34, 0x62, 0x39, 0x30, 0x62, 0x63, 0x35, 0x63, 0x61, 0x64, 0x64, 0x66, 0x64, 0x37, 0x32, 0x38, 0x31, 0x30, 0x61, 0x65, 0x36, 0x36, 0x39, 0x32, 0x63, 0x61, 0x38, 0x37, 0x62, 0x30, 0x37, 0x32, 0x63, 0x65, 0x39, 0x64, 0x62, 0x33, 0x32, 0x38, 0x66, 0x66, 0x62, 0x64, 0x66, 0x30, 0x37, 0x34, 0x64, 0x34, 0x63, 0x62, 0x61, 0x36, 0x62, 0x38, 0x35, 0x33, 0x37, 0x64, 0x33, 0x35, 0x35, 0x36, 0x61, 0x31, 0x32, 0x64, 0x35, 0x33, 0x34, 0x34, 0x64, 0x61, 0x66, 0x61, 0x61, 0x64, 0x30, 0x33, 0x62, 0x34, 0x34, 0x32, 0x35, 0x34, 0x37, 0x35, 0x31, 0x61, 0x64, 0x63, 0x31, 0x36, 0x31, 0x30, 0x64, 0x65, 0x37, 0x31, 0x66, 0x35, 0x66, 0x33, 0x35, 0x38, 0x66, 0x34, 0x66, 0x33, 0x37, 0x30, 0x34, 0x30, 0x62, 0x66, 0x63, 0x36, 0x34, 0x30, 0x30, 0x66, 0x63, 0x63, 0x61, 0x64, 0x34, 0x64, 0x61, 0x39, 0x36, 0x36, 0x36, 0x35, 0x34, 0x32, 0x37, 0x66, 0x65, 0x66, 0x64, 0x34, 0x31, 0x63, 0x33, 0x36, 0x61, 0x64, 0x64, 0x64, 0x31, 0x61, 0x63, 0x66, 0x30, 0x36, 0x32, 0x36, 0x33, 0x34, 0x32, 0x39, 0x31, 0x30, 0x64, 0x38, 0x35, 0x31, 0x65, 0x66, 0x32, 0x62, 0x62, 0x61, 0x38, 0x62, 0x32, 0x38, 0x31, 0x39, 0x62, 0x30, 0x30, 0x32, 0x35, 0x65, 0x38, 0x36, 0x38, 0x30, 0x33, 0x34, 0x32, 0x30, 0x31, 0x36, 0x36, 0x30, 0x34, 0x34, 0x38, 0x64, 0x64, 0x61, 0x65, 0x33, 0x65, 0x35, 0x63, 0x36, 0x65, 0x31, 0x61, 0x64, 0x34, 0x62, 0x37, 0x35, 0x63, 0x64, 0x64, 0x61, 0x34, 0x32, 0x31, 0x32, 0x30, 0x32, 0x62, 0x61, 0x39, 0x31, 0x33, 0x64, 0x36, 0x39, 0x30, 0x36, 0x30, 0x63, 0x65, 0x33, 0x34, 0x63, 0x35, 0x37, 0x35, 0x65, 0x63, 0x36, 0x65, 0x62, 0x62, 0x34, 0x31, 0x64, 0x30, 0x33, 0x64, 0x66, 0x30, 0x38, 0x61, 0x35, 0x63, 0x62, 0x63, 0x30, 0x63, 0x38, 0x38, 0x30, 0x33, 0x34, 0x62, 0x36, 0x61, 0x33, 0x66, 0x65, 0x37, 0x34, 0x62, 0x38, 0x34, 0x30, 0x37, 0x32, 0x39, 0x35, 0x66, 0x33, 0x34, 0x65, 0x66, 0x64, 0x35, 0x30, 0x66, 0x39, 0x63, 0x32, 0x38, 0x39, 0x65, 0x64, 0x39, 0x33, 0x36, 0x65, 0x64, 0x32, 0x30, 0x32, 0x63, 0x30, 0x37, 0x32, 0x36, 0x66, 0x30, 0x65, 0x63, 0x62, 0x31, 0x35, 0x37, 0x66, 0x34, 0x61, 0x31, 0x30, 0x30, 0x32, 0x65, 0x30, 0x30, 0x35, 0x34, 0x62, 0x36, 0x37, 0x31, 0x65, 0x31, 0x34, 0x32, 0x35, 0x39, 0x39, 0x32, 0x34, 0x65, 0x61, 0x30, 0x37, 0x36, 0x66, 0x32, 0x36, 0x35, 0x32, 0x66, 0x36, 0x66, 0x37, 0x35, 0x64, 0x30, 0x34, 0x39, 0x63, 0x63, 0x35, 0x30, 0x38, 0x34, 0x66, 0x64, 0x34, 0x65, 0x39, 0x34, 0x31, 0x36, 0x32, 0x65, 0x33, 0x62, 0x39, 0x31, 0x63, 0x35, 0x64, 0x62, 0x32, 0x30, 0x30, 0x66, 0x39, 0x38, 0x66, 0x66, 0x65, 0x36, 0x39, 0x31, 0x61, 0x61, 0x30, 0x39, 0x36, 0x34, 0x34, 0x30, 0x61, 0x63, 0x63, 0x38, 0x31, 0x39, 0x62, 0x30, 0x33, 0x66, 0x62, 0x66, 0x63, 0x35, 0x37, 0x30, 0x30, 0x30, 0x63, 0x39, 0x33, 0x37, 0x36, 0x37, 0x61, 0x66, 0x36, 0x34, 0x62, 0x38, 0x32, 0x34, 0x61, 0x36, 0x61, 0x39, 0x35, 0x39, 0x36, 0x39, 0x31, 0x66, 0x62, 0x63, 0x38, 0x38, 0x30, 0x34, 0x31, 0x38, 0x38, 0x31, 0x32, 0x36, 0x61, 0x66, 0x64, 0x37, 0x61, 0x66, 0x37, 0x61, 0x39, 0x30, 0x34, 0x38, 0x34, 0x33, 0x33, 0x32, 0x39, 0x34, 0x34, 0x65, 0x31, 0x65, 0x33, 0x37, 0x36, 0x34, 0x37, 0x37, 0x35, 0x61, 0x63, 0x62, 0x39, 0x32, 0x30, 0x37, 0x31, 0x33, 0x39, 0x61, 0x62, 0x37, 0x31, 0x38, 0x30, 0x62, 0x64, 0x36, 0x37, 0x36, 0x34, 0x32, 0x32, 0x36, 0x66, 0x63, 0x39, 0x36, 0x32, 0x64, 0x35, 0x65, 0x61, 0x66, 0x31, 0x36, 0x61, 0x61, 0x33, 0x61, 0x65, 0x34, 0x36, 0x33, 0x30, 0x37, 0x32, 0x61, 0x38, 0x31, 0x37, 0x64, 0x66, 0x35, 0x64, 0x62, 0x64, 0x39, 0x33, 0x36, 0x39, 0x61, 0x36, 0x39, 0x37, 0x36, 0x35, 0x35, 0x30, 0x37, 0x64, 0x37, 0x39, 0x39, 0x39, 0x36, 0x61, 0x66, 0x64, 0x61, 0x63, 0x38, 0x37, 0x63, 0x37, 0x34, 0x63, 0x66, 0x30, 0x65, 0x31, 0x32, 0x62, 0x61, 0x37, 0x33, 0x63, 0x33, 0x34, 0x62, 0x66, 0x64, 0x38, 0x38, 0x66, 0x34, 0x34, 0x30, 0x61, 0x33, 0x35, 0x31, 0x30, 0x66, 0x36, 0x66, 0x65, 0x63, 0x63, 0x34, 0x66, 0x39, 0x65, 0x31, 0x62, 0x62, 0x64, 0x32, 0x38, 0x64, 0x31, 0x34, 0x35, 0x39, 0x31, 0x65, 0x61, 0x30, 0x37, 0x66, 0x38, 0x33, 0x34, 0x34, 0x37, 0x66, 0x62, 0x33, 0x31, 0x34, 0x31, 0x37, 0x61, 0x38, 0x63, 0x36, 0x63, 0x35, 0x38, 0x35, 0x61, 0x33, 0x33, 0x39, 0x65, 0x33, 0x61, 0x62, 0x34, 0x32, 0x33, 0x35, 0x35, 0x33, 0x61, 0x63, 0x64, 0x34, 0x63, 0x66, 0x31, 0x38, 0x38, 0x31, 0x39, 0x65, 0x61, 0x31, 0x38, 0x66, 0x38, 0x65, 0x38, 0x39, 0x34, 0x63, 0x65, 0x33, 0x31, 0x39, 0x39, 0x30, 0x32, 0x32, 0x38, 0x35, 0x30, 0x32, 0x33, 0x63, 0x37, 0x33, 0x36, 0x37, 0x61, 0x63, 0x66, 0x32, 0x33, 0x65, 0x32, 0x64, 0x30, 0x65, 0x32, 0x36, 0x66, 0x30, 0x35, 0x36, 0x39, 0x64, 0x66, 0x30, 0x64, 0x37, 0x32, 0x34, 0x38, 0x65, 0x61, 0x63, 0x34, 0x64, 0x37, 0x38, 0x30, 0x30, 0x64, 0x39, 0x36, 0x39, 0x35, 0x30, 0x39, 0x31, 0x66, 0x36, 0x33, 0x36, 0x34, 0x37, 0x39, 0x37, 0x66, 0x36, 0x63, 0x33, 0x63, 0x30, 0x64, 0x32, 0x38, 0x37, 0x38, 0x38, 0x39, 0x61, 0x37, 0x35, 0x66, 0x36, 0x32, 0x61, 0x35, 0x33, 0x30, 0x61, 0x36, 0x30, 0x66, 0x38, 0x64, 0x38, 0x64, 0x65, 0x38, 0x63, 0x31, 0x37, 0x32, 0x38, 0x38, 0x30, 0x61, 0x33, 0x32, 0x39, 0x61, 0x65, 0x62, 0x64, 0x61, 0x66, 0x62, 0x63, 0x34, 0x36, 0x61, 0x61, 0x38, 0x32, 0x35, 0x38, 0x39, 0x61, 0x38, 0x35, 0x62, 0x66, 0x30, 0x61, 0x38, 0x32, 0x34, 0x33, 0x34, 0x65, 0x39, 0x62, 0x35, 0x31, 0x34, 0x32, 0x30, 0x34, 0x36, 0x36, 0x64, 0x30, 0x35, 0x36, 0x36, 0x32, 0x66, 0x32, 0x61, 0x64, 0x34, 0x35, 0x65, 0x34, 0x66, 0x37, 0x32, 0x36, 0x34, 0x30, 0x37, 0x36, 0x33, 0x38, 0x32, 0x32, 0x32, 0x32, 0x64, 0x36, 0x37, 0x63, 0x35, 0x36, 0x30, 0x65, 0x39, 0x33, 0x66, 0x38, 0x36, 0x66, 0x30, 0x62, 0x63, 0x64, 0x62, 0x31, 0x33, 0x35, 0x38, 0x35, 0x33, 0x31, 0x31, 0x34, 0x39, 0x65, 0x65, 0x61, 0x66, 0x34, 0x64, 0x32, 0x39, 0x31, 0x65, 0x65, 0x32, 0x38, 0x36, 0x64, 0x66, 0x37, 0x34, 0x65, 0x39, 0x39, 0x31, 0x34, 0x32, 0x31, 0x64, 0x65, 0x35, 0x64, 0x61, 0x37, 0x33, 0x30, 0x33, 0x39, 0x36, 0x65, 0x35, 0x65, 0x36, 0x30, 0x34, 0x66, 0x34, 0x32, 0x30, 0x32, 0x33, 0x31, 0x32, 0x37, 0x32, 0x30, 0x62, 0x30, 0x38, 0x30, 0x61, 0x63, 0x64, 0x39, 0x30, 0x31, 0x66, 0x62, 0x64, 0x65, 0x66, 0x38, 0x63, 0x64, 0x34, 0x36, 0x33, 0x64, 0x33, 0x37, 0x30, 0x36, 0x31, 0x35, 0x39, 0x65, 0x31, 0x66, 0x62, 0x37, 0x32, 0x39, 0x34, 0x62, 0x33, 0x36, 0x63, 0x37, 0x64, 0x31, 0x39, 0x33, 0x37, 0x35, 0x38, 0x34, 0x38, 0x61, 0x32, 0x37, 0x37, 0x36, 0x38, 0x37, 0x36, 0x62, 0x64, 0x62, 0x32, 0x31, 0x64, 0x34, 0x33, 0x33, 0x62, 0x64, 0x32, 0x33, 0x34, 0x64, 0x30, 0x31, 0x39, 0x61, 0x39, 0x62, 0x64, 0x64, 0x39, 0x37, 0x38, 0x36, 0x39, 0x31, 0x35, 0x34, 0x31, 0x62, 0x38, 0x39, 0x62, 0x62, 0x38, 0x30, 0x65, 0x64, 0x64, 0x38, 0x39, 0x65, 0x64, 0x32, 0x66, 0x33, 0x30, 0x38, 0x35, 0x36, 0x39, 0x32, 0x31, 0x66, 0x31, 0x38, 0x30, 0x37, 0x66, 0x63, 0x38, 0x62, 0x30, 0x61, 0x33, 0x63, 0x30, 0x36, 0x65, 0x62, 0x66, 0x65, 0x31, 0x38, 0x37, 0x31, 0x66, 0x38, 0x63, 0x39, 0x35, 0x38, 0x64, 0x39, 0x65, 0x36, 0x32, 0x36, 0x62, 0x33, 0x62, 0x37, 0x39, 0x37, 0x64, 0x33, 0x64, 0x38, 0x61, 0x37, 0x32, 0x37, 0x39, 0x65, 0x61, 0x39, 0x64, 0x31, 0x39, 0x61, 0x39, 0x36, 0x62, 0x36, 0x39, 0x30, 0x63, 0x33, 0x61, 0x66, 0x35, 0x33, 0x31, 0x65, 0x62, 0x35, 0x64, 0x64, 0x36, 0x35, 0x33, 0x38, 0x31, 0x31, 0x36, 0x63, 0x38, 0x64, 0x31, 0x31, 0x64, 0x39, 0x36, 0x62, 0x64, 0x64, 0x36, 0x65, 0x64, 0x66, 0x66, 0x31, 0x35, 0x33, 0x38, 0x61, 0x38, 0x66, 0x64, 0x61, 0x65, 0x62, 0x34, 0x36, 0x63, 0x64, 0x63, 0x63, 0x31, 0x62, 0x62, 0x33, 0x63, 0x39, 0x66, 0x61, 0x38, 0x62, 0x64, 0x30, 0x34, 0x39, 0x38, 0x64, 0x37, 0x34, 0x63, 0x66, 0x34, 0x31, 0x38, 0x64, 0x31, 0x62, 0x35, 0x30, 0x38, 0x36, 0x30, 0x33, 0x35, 0x39, 0x36, 0x31, 0x39, 0x66, 0x33, 0x31, 0x30, 0x66, 0x33, 0x38, 0x62, 0x61, 0x61, 0x63, 0x35, 0x66, 0x66, 0x30, 0x65, 0x62, 0x64, 0x65, 0x36, 0x62, 0x31, 0x37, 0x32, 0x37, 0x64, 0x35, 0x33, 0x65, 0x32, 0x32, 0x31, 0x61, 0x64, 0x38, 0x31, 0x33, 0x63, 0x62, 0x65, 0x37, 0x64, 0x62, 0x35, 0x62, 0x36, 0x34, 0x36, 0x37, 0x37, 0x35, 0x37, 0x36, 0x66, 0x64, 0x62, 0x37, 0x34, 0x64, 0x38, 0x37, 0x38, 0x62, 0x36, 0x61, 0x33, 0x34, 0x65, 0x61, 0x61, 0x36, 0x35, 0x37, 0x37, 0x63, 0x31, 0x65, 0x61, 0x38, 0x36, 0x66, 0x36, 0x37, 0x39, 0x61, 0x64, 0x37, 0x32, 0x37, 0x63, 0x32, 0x65, 0x66, 0x64, 0x33, 0x62, 0x64, 0x32, 0x35, 0x65, 0x37, 0x38, 0x30, 0x64, 0x34, 0x35, 0x66, 0x37, 0x61, 0x61, 0x33, 0x63, 0x34, 0x34, 0x37, 0x62, 0x34, 0x39, 0x66, 0x38, 0x62, 0x36, 0x35, 0x65, 0x37, 0x37, 0x61, 0x35, 0x31, 0x37, 0x34, 0x65, 0x37, 0x38, 0x38, 0x63, 0x33, 0x36, 0x34, 0x32, 0x33, 0x39, 0x30, 0x62, 0x32, 0x65, 0x32, 0x35, 0x64, 0x64, 0x37, 0x32, 0x38, 0x34, 0x30, 0x33, 0x39, 0x63, 0x37, 0x66, 0x65, 0x63, 0x63, 0x62, 0x31, 0x32, 0x31, 0x39, 0x37, 0x66, 0x37, 0x61, 0x62, 0x62, 0x61, 0x66, 0x31, 0x61, 0x39, 0x62, 0x64, 0x35, 0x33, 0x33, 0x33, 0x38, 0x35, 0x62, 0x66, 0x37, 0x62, 0x35, 0x33, 0x37, 0x64, 0x61, 0x62, 0x31, 0x63, 0x37, 0x62, 0x64, 0x61, 0x36, 0x64, 0x66, 0x38, 0x39, 0x33, 0x35, 0x30, 0x32, 0x39, 0x39, 0x37, 0x32, 0x36, 0x61, 0x62, 0x65, 0x33, 0x61, 0x61, 0x63, 0x61, 0x64, 0x38, 0x63, 0x62, 0x62, 0x62, 0x37, 0x63, 0x31, 0x34, 0x39, 0x61, 0x66, 0x63, 0x37, 0x61, 0x37, 0x36, 0x37, 0x30, 0x33, 0x32, 0x63, 0x30, 0x36, 0x63, 0x35, 0x32, 0x38, 0x34, 0x64, 0x32, 0x35, 0x61, 0x30, 0x62, 0x30, 0x34, 0x66, 0x63, 0x38, 0x39, 0x65, 0x32, 0x36, 0x30, 0x30, 0x32, 0x63, 0x30, 0x31, 0x65, 0x62, 0x37, 0x32, 0x34, 0x32, 0x63, 0x63, 0x65, 0x66, 0x61, 0x62, 0x32, 0x61, 0x38, 0x66, 0x64, 0x37, 0x33, 0x36, 0x38, 0x63, 0x66, 0x37, 0x65, 0x31, 0x33, 0x38, 0x38, 0x33, 0x34, 0x38, 0x31, 0x39, 0x64, 0x35, 0x30, 0x30, 0x61, 0x33, 0x65, 0x38, 0x32, 0x39, 0x61, 0x37, 0x31, 0x35, 0x31, 0x37, 0x35, 0x64, 0x31, 0x62, 0x66, 0x30, 0x34, 0x37, 0x62, 0x38, 0x35, 0x30, 0x35, 0x61, 0x64, 0x31, 0x31, 0x34, 0x62, 0x61, 0x34, 0x32, 0x38, 0x62, 0x66, 0x34, 0x65, 0x62, 0x61, 0x63, 0x30, 0x31, 0x66, 0x62, 0x30, 0x30, 0x66, 0x30, 0x31, 0x33, 0x34, 0x61, 0x30, 0x66, 0x65, 0x39, 0x62, 0x31, 0x65, 0x37, 0x32, 0x38, 0x39, 0x65, 0x37, 0x35, 0x32, 0x63, 0x63, 0x61, 0x66, 0x31, 0x37, 0x64, 0x33, 0x64, 0x33, 0x32, 0x62, 0x65, 0x63, 0x61, 0x37, 0x31, 0x35, 0x65, 0x64, 0x38, 0x61, 0x31, 0x37, 0x32, 0x64, 0x32, 0x32, 0x33, 0x33, 0x62, 0x63, 0x34, 0x61, 0x61, 0x36, 0x61, 0x34, 0x37, 0x30, 0x65, 0x39, 0x30, 0x30, 0x62, 0x37, 0x30, 0x33, 0x63, 0x33, 0x31, 0x37, 0x32, 0x35, 0x66, 0x62, 0x62, 0x61, 0x61, 0x31, 0x32, 0x39, 0x62, 0x37, 0x61, 0x37, 0x37, 0x37, 0x34, 0x38, 0x63, 0x62, 0x35, 0x66, 0x37, 0x38, 0x66, 0x37, 0x38, 0x66, 0x66, 0x39, 0x61, 0x38, 0x38, 0x62, 0x64, 0x37, 0x32, 0x31, 0x36, 0x30, 0x66, 0x33, 0x35, 0x33, 0x38, 0x33, 0x31, 0x30, 0x37, 0x33, 0x39, 0x36, 0x39, 0x61, 0x37, 0x62, 0x36, 0x34, 0x31, 0x63, 0x32, 0x64, 0x36, 0x35, 0x37, 0x61, 0x61, 0x33, 0x31, 0x62, 0x65, 0x31, 0x35, 0x39, 0x66, 0x61, 0x66, 0x30, 0x31, 0x30, 0x31, 0x33, 0x66, 0x32, 0x36, 0x64, 0x37, 0x32, 0x63, 0x32, 0x65, 0x64, 0x61, 0x63, 0x65, 0x33, 0x66, 0x31, 0x39, 0x36, 0x35, 0x66, 0x65, 0x64, 0x33, 0x31, 0x35, 0x65, 0x33, 0x65, 0x37, 0x63, 0x37, 0x63, 0x61, 0x66, 0x62, 0x30, 0x62, 0x38, 0x65, 0x37, 0x39, 0x33, 0x66, 0x34, 0x38, 0x38, 0x32, 0x35, 0x36, 0x64, 0x37, 0x39, 0x39, 0x33, 0x32, 0x35, 0x37, 0x34, 0x34, 0x65, 0x35, 0x30, 0x38, 0x61, 0x35, 0x64, 0x38, 0x30, 0x61, 0x30, 0x32, 0x30, 0x31, 0x66, 0x64, 0x36, 0x30, 0x36, 0x62, 0x65, 0x39, 0x31, 0x62, 0x31, 0x61, 0x31, 0x35, 0x38, 0x32, 0x34, 0x65, 0x35, 0x31, 0x65, 0x38, 0x34, 0x36, 0x37, 0x39, 0x31, 0x63, 0x39, 0x33, 0x61, 0x39, 0x38, 0x36, 0x38, 0x32, 0x65, 0x37, 0x34, 0x35, 0x61, 0x61, 0x62, 0x64, 0x66, 0x64, 0x61, 0x37, 0x30, 0x66, 0x66, 0x66, 0x62, 0x30, 0x35, 0x34, 0x65, 0x62, 0x63, 0x64, 0x35, 0x37, 0x33, 0x65, 0x36, 0x34, 0x65, 0x30, 0x63, 0x35, 0x31, 0x65, 0x37, 0x32, 0x31, 0x36, 0x37, 0x38, 0x65, 0x36, 0x39, 0x39, 0x33, 0x36, 0x65, 0x39, 0x39, 0x31, 0x63, 0x31, 0x62, 0x63, 0x37, 0x31, 0x62, 0x64, 0x66, 0x37, 0x35, 0x31, 0x39, 0x36, 0x65, 0x31, 0x38, 0x31, 0x30, 0x38, 0x37, 0x30, 0x65, 0x65, 0x63, 0x31, 0x37, 0x39, 0x30, 0x35, 0x30, 0x61, 0x33, 0x30, 0x63, 0x62, 0x63, 0x63, 0x30, 0x64, 0x63, 0x33, 0x35, 0x34, 0x39, 0x30, 0x37, 0x35, 0x37, 0x32, 0x33, 0x30, 0x66, 0x36, 0x66, 0x39, 0x65, 0x62, 0x33, 0x62, 0x30, 0x64, 0x65, 0x62, 0x63, 0x63, 0x63, 0x32, 0x37, 0x65, 0x31, 0x31, 0x37, 0x63, 0x30, 0x37, 0x30, 0x63, 0x34, 0x66, 0x62, 0x30, 0x31, 0x61, 0x37, 0x30, 0x39, 0x36, 0x62, 0x61, 0x65, 0x62, 0x33, 0x61, 0x35, 0x36, 0x64, 0x36, 0x66, 0x34, 0x31, 0x34, 0x30, 0x64, 0x39, 0x37, 0x61, 0x37, 0x32, 0x66, 0x32, 0x62, 0x32, 0x64, 0x36, 0x32, 0x34, 0x66, 0x64, 0x65, 0x66, 0x39, 0x32, 0x63, 0x38, 0x31, 0x61, 0x30, 0x36, 0x33, 0x63, 0x61, 0x39, 0x34, 0x38, 0x30, 0x63, 0x62, 0x37, 0x61, 0x31, 0x63, 0x65, 0x61, 0x61, 0x37, 0x65, 0x61, 0x66, 0x38, 0x61, 0x35, 0x37, 0x35, 0x30, 0x37, 0x66, 0x35, 0x33, 0x62, 0x32, 0x35, 0x63, 0x65, 0x38, 0x35, 0x31, 0x36, 0x37, 0x32, 0x31, 0x33, 0x66, 0x38, 0x37, 0x66, 0x31, 0x61, 0x62, 0x62, 0x34, 0x61, 0x36, 0x37, 0x31, 0x66, 0x35, 0x64, 0x36, 0x38, 0x61, 0x63, 0x62, 0x63, 0x39, 0x39, 0x64, 0x66, 0x39, 0x62, 0x37, 0x35, 0x30, 0x62, 0x34, 0x63, 0x30, 0x61, 0x35, 0x30, 0x32, 0x35, 0x61, 0x38, 0x30, 0x35, 0x39, 0x63, 0x32, 0x36, 0x31, 0x37, 0x62, 0x36, 0x32, 0x61, 0x35, 0x64, 0x65, 0x66, 0x61, 0x63, 0x65, 0x37, 0x64, 0x37, 0x61, 0x36, 0x61, 0x38, 0x37, 0x32, 0x31, 0x34, 0x62, 0x31, 0x35, 0x30, 0x62, 0x39, 0x65, 0x34, 0x38, 0x63, 0x62, 0x65, 0x61, 0x32, 0x33, 0x31, 0x62, 0x64, 0x39, 0x63, 0x38, 0x30, 0x30, 0x66, 0x62, 0x39, 0x36, 0x66, 0x33, 0x62, 0x63, 0x36, 0x30, 0x33, 0x36, 0x62, 0x30, 0x33, 0x33, 0x38, 0x38, 0x33, 0x65, 0x62, 0x39, 0x65, 0x34, 0x31, 0x63, 0x30, 0x30, 0x37, 0x37, 0x35, 0x62, 0x63, 0x31, 0x61, 0x35, 0x39, 0x37, 0x32, 0x31, 0x35, 0x64, 0x62, 0x38, 0x39, 0x35, 0x62, 0x64, 0x35, 0x31, 0x30, 0x31, 0x32, 0x33, 0x38, 0x65, 0x38, 0x36, 0x36, 0x66, 0x32, 0x33, 0x36, 0x33, 0x64, 0x36, 0x31, 0x61, 0x30, 0x65, 0x32, 0x66, 0x37, 0x39, 0x39, 0x63, 0x36, 0x35, 0x66, 0x62, 0x33, 0x63, 0x38, 0x38, 0x39, 0x61, 0x63, 0x63, 0x65, 0x31, 0x39, 0x35, 0x39, 0x31, 0x32, 0x31, 0x34, 0x35, 0x33, 0x65, 0x36, 0x36, 0x38, 0x65, 0x39, 0x33, 0x63, 0x62, 0x61, 0x63, 0x37, 0x31, 0x38, 0x32, 0x39, 0x32, 0x34, 0x34, 0x61, 0x64, 0x64, 0x31, 0x66, 0x34, 0x36, 0x64, 0x33, 0x65, 0x65, 0x33, 0x66, 0x33, 0x39, 0x35, 0x34, 0x39, 0x64, 0x65, 0x64, 0x36, 0x32, 0x62, 0x61, 0x64, 0x37, 0x61, 0x31, 0x30, 0x37, 0x38, 0x39, 0x62, 0x66, 0x30, 0x37, 0x33, 0x36, 0x34, 0x35, 0x64, 0x35, 0x31, 0x30, 0x38, 0x38, 0x37, 0x32, 0x39, 0x30, 0x62, 0x38, 0x33, 0x37, 0x39, 0x30, 0x65, 0x36, 0x62, 0x63, 0x34, 0x36, 0x66, 0x35, 0x38, 0x33, 0x32, 0x64, 0x63, 0x34, 0x39, 0x64, 0x65, 0x39, 0x30, 0x61, 0x62, 0x31, 0x66, 0x31, 0x39, 0x64, 0x31, 0x62, 0x62, 0x31, 0x33, 0x66, 0x65, 0x64, 0x38, 0x64, 0x35, 0x38, 0x32, 0x65, 0x35, 0x62, 0x66, 0x62, 0x35, 0x31, 0x34, 0x33, 0x30, 0x31, 0x39, 0x37, 0x64, 0x65, 0x37, 0x32, 0x65, 0x64, 0x37, 0x31, 0x33, 0x33, 0x62, 0x37, 0x61, 0x35, 0x61, 0x64, 0x65, 0x62, 0x35, 0x36, 0x31, 0x63, 0x66, 0x34, 0x62, 0x39, 0x61, 0x32, 0x37, 0x62, 0x66, 0x30, 0x32, 0x38, 0x36, 0x33, 0x35, 0x64, 0x37, 0x35, 0x36, 0x39, 0x62, 0x61, 0x35, 0x32, 0x36, 0x36, 0x36, 0x32, 0x38, 0x66, 0x39, 0x62, 0x66, 0x63, 0x62, 0x37, 0x62, 0x32, 0x35, 0x33, 0x65, 0x62, 0x37, 0x35, 0x37, 0x32, 0x37, 0x33, 0x34, 0x62, 0x31, 0x37, 0x64, 0x30, 0x64, 0x34, 0x63, 0x62, 0x63, 0x36, 0x33, 0x65, 0x34, 0x32, 0x63, 0x36, 0x38, 0x38, 0x35, 0x33, 0x63, 0x66, 0x64, 0x38, 0x64, 0x32, 0x35, 0x62, 0x30, 0x36, 0x36, 0x39, 0x36, 0x31, 0x35, 0x38, 0x30, 0x32, 0x66, 0x32, 0x64, 0x39, 0x32, 0x66, 0x38, 0x63, 0x33, 0x35, 0x61, 0x39, 0x33, 0x65, 0x62, 0x32, 0x66, 0x66, 0x39, 0x36, 0x37, 0x32, 0x36, 0x37, 0x61, 0x65, 0x36, 0x35, 0x66, 0x32, 0x62, 0x65, 0x35, 0x38, 0x62, 0x65, 0x39, 0x32, 0x39, 0x64, 0x65, 0x38, 0x64, 0x63, 0x62, 0x66, 0x33, 0x61, 0x65, 0x37, 0x36, 0x33, 0x39, 0x30, 0x37, 0x36, 0x38, 0x66, 0x61, 0x35, 0x39, 0x63, 0x63, 0x32, 0x61, 0x35, 0x38, 0x38, 0x34, 0x64, 0x62, 0x30, 0x31, 0x61, 0x35, 0x38, 0x65, 0x34, 0x33, 0x35, 0x65, 0x65, 0x39, 0x63, 0x37, 0x32, 0x65, 0x31, 0x39, 0x33, 0x33, 0x61, 0x33, 0x62, 0x38, 0x30, 0x35, 0x30, 0x35, 0x32, 0x66, 0x63, 0x62, 0x32, 0x37, 0x63, 0x63, 0x63, 0x31, 0x64, 0x30, 0x64, 0x33, 0x65, 0x37, 0x38, 0x38, 0x61, 0x35, 0x30, 0x34, 0x39, 0x37, 0x39, 0x37, 0x35, 0x39, 0x34, 0x37, 0x32, 0x66, 0x62, 0x63, 0x64, 0x61, 0x35, 0x35, 0x34, 0x65, 0x62, 0x39, 0x31, 0x34, 0x35, 0x35, 0x65, 0x34, 0x37, 0x33, 0x66, 0x30, 0x30, 0x66, 0x39, 0x35, 0x32, 0x36, 0x35, 0x63, 0x34, 0x39, 0x30, 0x38, 0x35, 0x35, 0x35, 0x61, 0x38, 0x65, 0x38, 0x39, 0x32, 0x61, 0x66, 0x30, 0x66, 0x33, 0x31, 0x63, 0x65, 0x32, 0x61, 0x39, 0x30, 0x65, 0x36, 0x31, 0x63, 0x63, 0x39, 0x36, 0x62, 0x36, 0x37, 0x34, 0x31, 0x64, 0x39, 0x33, 0x36, 0x64, 0x65, 0x62, 0x35, 0x36, 0x39, 0x66, 0x66, 0x39, 0x38, 0x62, 0x30, 0x35, 0x39, 0x34, 0x37, 0x32, 0x39, 0x61, 0x33, 0x61, 0x32, 0x62, 0x36, 0x36, 0x35, 0x39, 0x33, 0x31, 0x61, 0x33, 0x39, 0x61, 0x63, 0x65, 0x32, 0x61, 0x30, 0x64, 0x61, 0x63, 0x32, 0x34, 0x62, 0x66, 0x65, 0x63, 0x61, 0x36, 0x30, 0x65, 0x31, 0x63, 0x65, 0x64, 0x35, 0x32, 0x65, 0x31, 0x32, 0x64, 0x30, 0x34, 0x37, 0x33, 0x39, 0x32, 0x37, 0x66, 0x61, 0x61, 0x32, 0x64, 0x31, 0x30, 0x32, 0x31, 0x66, 0x64, 0x31, 0x38, 0x30, 0x63, 0x38, 0x36, 0x39, 0x30, 0x38, 0x63, 0x30, 0x63, 0x35, 0x64, 0x32, 0x38, 0x65, 0x39, 0x64, 0x38, 0x61, 0x38, 0x65, 0x64, 0x34, 0x65, 0x31, 0x32, 0x33, 0x34, 0x31, 0x63, 0x36, 0x31, 0x64, 0x66, 0x62, 0x65, 0x35, 0x32, 0x35, 0x65, 0x61, 0x36, 0x32, 0x33, 0x39, 0x32, 0x30, 0x64, 0x38, 0x38, 0x64, 0x34, 0x64, 0x38, 0x30, 0x62, 0x31, 0x65, 0x61, 0x37, 0x32, 0x38, 0x63, 0x35, 0x34, 0x30, 0x62, 0x38, 0x36, 0x66, 0x37, 0x34, 0x34, 0x39, 0x33, 0x31, 0x64, 0x39, 0x32, 0x61, 0x38, 0x35, 0x35, 0x38, 0x32, 0x31, 0x35, 0x64, 0x33, 0x37, 0x32, 0x34, 0x39, 0x36, 0x65, 0x30, 0x38, 0x34, 0x36, 0x63, 0x65, 0x63, 0x30, 0x36, 0x63, 0x34, 0x31, 0x30, 0x65, 0x38, 0x36, 0x62, 0x64, 0x65, 0x62, 0x63, 0x62, 0x39, 0x38, 0x38, 0x31, 0x64, 0x30, 0x32, 0x61, 0x63, 0x63, 0x32, 0x34, 0x38, 0x30, 0x33, 0x32, 0x37, 0x32, 0x66, 0x64, 0x33, 0x62, 0x64, 0x65, 0x32, 0x37, 0x34, 0x37, 0x30, 0x34, 0x66, 0x62, 0x62, 0x65, 0x66, 0x39, 0x35, 0x64, 0x39, 0x31, 0x32, 0x31, 0x61, 0x37, 0x66, 0x33, 0x33, 0x32, 0x61, 0x65, 0x64, 0x64, 0x32, 0x30, 0x64, 0x39, 0x35, 0x61, 0x31, 0x37, 0x62, 0x36, 0x35, 0x65, 0x61, 0x31, 0x65, 0x32, 0x32, 0x35, 0x37, 0x32, 0x63, 0x32, 0x64, 0x62, 0x38, 0x63, 0x33, 0x34, 0x37, 0x62, 0x37, 0x62, 0x34, 0x31, 0x37, 0x35, 0x37, 0x66, 0x65, 0x65, 0x64, 0x30, 0x64, 0x36, 0x36, 0x31, 0x32, 0x63, 0x38, 0x39, 0x66, 0x38, 0x38, 0x34, 0x39, 0x63, 0x33, 0x33, 0x34, 0x64, 0x39, 0x35, 0x61, 0x39, 0x36, 0x64, 0x32, 0x66, 0x33, 0x63, 0x63, 0x63, 0x66, 0x31, 0x63, 0x31, 0x63, 0x63, 0x66, 0x38, 0x35, 0x61, 0x32, 0x63, 0x65, 0x32, 0x31, 0x37, 0x33, 0x35, 0x65, 0x32, 0x33, 0x34, 0x62, 0x30, 0x64, 0x37, 0x64, 0x30, 0x63, 0x35, 0x64, 0x37, 0x33, 0x61, 0x36, 0x38, 0x36, 0x31, 0x39, 0x33, 0x38, 0x39, 0x33, 0x39, 0x38, 0x64, 0x65, 0x35, 0x62, 0x36, 0x38, 0x61, 0x65, 0x63, 0x38, 0x35, 0x65, 0x32, 0x35, 0x63, 0x38, 0x34, 0x63, 0x35, 0x39, 0x34, 0x33, 0x63, 0x37, 0x31, 0x39, 0x65, 0x30, 0x37, 0x37, 0x32, 0x30, 0x38, 0x37, 0x64, 0x66, 0x65, 0x38, 0x66, 0x39, 0x35, 0x37, 0x38, 0x61, 0x62, 0x64, 0x34, 0x39, 0x63, 0x61, 0x61, 0x63, 0x34, 0x36, 0x63, 0x33, 0x66, 0x30, 0x36, 0x34, 0x36, 0x33, 0x35, 0x65, 0x36, 0x33, 0x39, 0x38, 0x32, 0x38, 0x66, 0x36, 0x35, 0x38, 0x34, 0x64, 0x61, 0x65, 0x66, 0x39, 0x37, 0x66, 0x65, 0x34, 0x32, 0x32, 0x39, 0x33, 0x32, 0x32, 0x32, 0x36, 0x35, 0x37, 0x32, 0x62, 0x61, 0x62, 0x34, 0x34, 0x39, 0x32, 0x30, 0x66, 0x31, 0x37, 0x37, 0x35, 0x35, 0x38, 0x31, 0x66, 0x33, 0x61, 0x34, 0x66, 0x62, 0x37, 0x38, 0x61, 0x61, 0x33, 0x36, 0x32, 0x39, 0x31, 0x38, 0x66, 0x32, 0x35, 0x36, 0x65, 0x63, 0x61, 0x36, 0x61, 0x35, 0x38, 0x63, 0x61, 0x35, 0x62, 0x30, 0x36, 0x65, 0x66, 0x32, 0x31, 0x63, 0x30, 0x32, 0x39, 0x39, 0x63, 0x39, 0x66, 0x32, 0x35, 0x38, 0x64, 0x33, 0x34, 0x38, 0x32, 0x61, 0x34, 0x36, 0x30, 0x64, 0x31, 0x38, 0x31, 0x37, 0x37, 0x65, 0x31, 0x35, 0x32, 0x38, 0x31, 0x36, 0x35, 0x64, 0x37, 0x63, 0x35, 0x37, 0x37, 0x65, 0x39, 0x30, 0x37, 0x38, 0x39, 0x62, 0x35, 0x61, 0x30, 0x37, 0x61, 0x66, 0x34, 0x65, 0x61, 0x64, 0x63, 0x64, 0x66, 0x37, 0x37, 0x36, 0x65, 0x61, 0x33, 0x34, 0x65, 0x38, 0x37, 0x63, 0x66, 0x39, 0x30, 0x38, 0x32, 0x30, 0x64, 0x32, 0x31, 0x37, 0x62, 0x31, 0x36, 0x61, 0x65, 0x63, 0x38, 0x37, 0x63, 0x38, 0x39, 0x63, 0x32, 0x34, 0x39, 0x38, 0x38, 0x64, 0x34, 0x31, 0x33, 0x35, 0x35, 0x33, 0x33, 0x35, 0x30, 0x31, 0x37, 0x35, 0x38, 0x30, 0x38, 0x66, 0x38, 0x30, 0x39, 0x36, 0x62, 0x65, 0x31, 0x64, 0x35, 0x31, 0x39, 0x61, 0x33, 0x62, 0x38, 0x64, 0x32, 0x38, 0x39, 0x30, 0x38, 0x34, 0x37, 0x32, 0x38, 0x61, 0x62, 0x37, 0x62, 0x64, 0x64, 0x30, 0x36, 0x33, 0x66, 0x63, 0x37, 0x61, 0x33, 0x34, 0x38, 0x35, 0x62, 0x35, 0x31, 0x34, 0x33, 0x36, 0x65, 0x38, 0x37, 0x31, 0x66, 0x65, 0x30, 0x37, 0x61, 0x35, 0x62, 0x64, 0x36, 0x63, 0x62, 0x66, 0x37, 0x61, 0x61, 0x33, 0x39, 0x64, 0x31, 0x39, 0x66, 0x33, 0x61, 0x65, 0x31, 0x35, 0x61, 0x36, 0x33, 0x61, 0x32, 0x65, 0x64, 0x66, 0x37, 0x32, 0x34, 0x38, 0x39, 0x62, 0x36, 0x33, 0x37, 0x37, 0x64, 0x30, 0x63, 0x37, 0x64, 0x30, 0x63, 0x32, 0x61, 0x63, 0x61, 0x33, 0x61, 0x37, 0x32, 0x39, 0x64, 0x38, 0x61, 0x31, 0x63, 0x30, 0x66, 0x30, 0x35, 0x37, 0x35, 0x62, 0x65, 0x32, 0x38, 0x35, 0x37, 0x39, 0x39, 0x66, 0x61, 0x39, 0x37, 0x64, 0x65, 0x30, 0x63, 0x34, 0x38, 0x35, 0x38, 0x63, 0x61, 0x37, 0x64, 0x38, 0x33, 0x35, 0x37, 0x32, 0x39, 0x31, 0x39, 0x32, 0x63, 0x61, 0x36, 0x61, 0x39, 0x37, 0x34, 0x32, 0x36, 0x37, 0x36, 0x34, 0x62, 0x34, 0x35, 0x38, 0x35, 0x38, 0x39, 0x37, 0x35, 0x62, 0x66, 0x34, 0x38, 0x34, 0x66, 0x63, 0x33, 0x63, 0x66, 0x37, 0x64, 0x62, 0x37, 0x32, 0x31, 0x38, 0x62, 0x65, 0x65, 0x30, 0x30, 0x31, 0x63, 0x62, 0x61, 0x36, 0x64, 0x34, 0x66, 0x64, 0x64, 0x63, 0x61, 0x32, 0x66, 0x39, 0x35, 0x62, 0x36, 0x39, 0x32, 0x66, 0x39, 0x35, 0x66, 0x32, 0x61, 0x36, 0x34, 0x64, 0x35, 0x66, 0x65, 0x37, 0x39, 0x65, 0x38, 0x30, 0x32, 0x62, 0x39, 0x61, 0x39, 0x38, 0x62, 0x31, 0x39, 0x61, 0x39, 0x63, 0x65, 0x65, 0x36, 0x64, 0x61, 0x38, 0x30, 0x32, 0x38, 0x37, 0x63, 0x36, 0x31, 0x66, 0x36, 0x66, 0x34, 0x61, 0x31, 0x37, 0x35, 0x34, 0x66, 0x34, 0x30, 0x38, 0x62, 0x63, 0x36, 0x39, 0x31, 0x61, 0x63, 0x30, 0x38, 0x34, 0x39, 0x33, 0x31, 0x63, 0x34, 0x63, 0x61, 0x63, 0x31, 0x62, 0x33, 0x37, 0x61, 0x35, 0x66, 0x62, 0x66, 0x61, 0x63, 0x66, 0x36, 0x35, 0x32, 0x38, 0x31, 0x38, 0x36, 0x39, 0x37, 0x35, 0x39, 0x35, 0x33, 0x35, 0x62, 0x63, 0x31, 0x33, 0x38, 0x65, 0x36, 0x37, 0x38, 0x61, 0x64, 0x33, 0x35, 0x63, 0x36, 0x62, 0x36, 0x34, 0x39, 0x61, 0x32, 0x36, 0x31, 0x33, 0x33, 0x33, 0x35, 0x66, 0x64, 0x36, 0x62, 0x63, 0x65, 0x32, 0x61, 0x63, 0x38, 0x30, 0x37, 0x34, 0x30, 0x34, 0x33, 0x30, 0x32, 0x34, 0x35, 0x39, 0x39, 0x62, 0x64, 0x63, 0x34, 0x33, 0x38, 0x64, 0x36, 0x66, 0x31, 0x32, 0x66, 0x66, 0x37, 0x63, 0x35, 0x61, 0x32, 0x39, 0x66, 0x30, 0x63, 0x35, 0x63, 0x36, 0x36, 0x64, 0x66, 0x34, 0x31, 0x39, 0x65, 0x64, 0x64, 0x34, 0x38, 0x30, 0x62, 0x38, 0x31, 0x64, 0x63, 0x35, 0x39, 0x64, 0x38, 0x35, 0x38, 0x61, 0x38, 0x65, 0x65, 0x30, 0x66, 0x35, 0x37, 0x63, 0x65, 0x36, 0x31, 0x37, 0x62, 0x63, 0x63, 0x65, 0x30, 0x64, 0x61, 0x38, 0x31, 0x64, 0x38, 0x31, 0x34, 0x66, 0x31, 0x31, 0x66, 0x30, 0x63, 0x63, 0x30, 0x35, 0x65, 0x39, 0x38, 0x63, 0x30, 0x66, 0x35, 0x39, 0x39, 0x61, 0x35, 0x36, 0x31, 0x37, 0x63, 0x61, 0x35, 0x39, 0x63, 0x35, 0x37, 0x32, 0x62, 0x34, 0x62, 0x38, 0x34, 0x36, 0x38, 0x31, 0x35, 0x37, 0x35, 0x33, 0x38, 0x33, 0x66, 0x31, 0x39, 0x61, 0x32, 0x34, 0x63, 0x39, 0x61, 0x61, 0x64, 0x30, 0x35, 0x31, 0x38, 0x30, 0x66, 0x30, 0x61, 0x35, 0x64, 0x61, 0x38, 0x61, 0x38, 0x32, 0x64, 0x39, 0x64, 0x39, 0x35, 0x66, 0x38, 0x36, 0x31, 0x64, 0x33, 0x30, 0x63, 0x65, 0x39, 0x61, 0x34, 0x64, 0x37, 0x64, 0x38, 0x61, 0x37, 0x31, 0x36, 0x31, 0x33, 0x66, 0x37, 0x35, 0x37, 0x30, 0x36, 0x63, 0x33, 0x61, 0x39, 0x36, 0x38, 0x35, 0x65, 0x32, 0x39, 0x31, 0x61, 0x30, 0x39, 0x62, 0x35, 0x63, 0x63, 0x64, 0x34, 0x34, 0x31, 0x66, 0x61, 0x62, 0x32, 0x64, 0x36, 0x36, 0x36, 0x64, 0x39, 0x64, 0x38, 0x62, 0x34, 0x63, 0x34, 0x64, 0x61, 0x30, 0x66, 0x65, 0x62, 0x64, 0x31, 0x33, 0x62, 0x37, 0x62, 0x65, 0x35, 0x62, 0x37, 0x32, 0x32, 0x64, 0x36, 0x63, 0x65, 0x66, 0x61, 0x64, 0x39, 0x37, 0x37, 0x39, 0x66, 0x62, 0x31, 0x65, 0x39, 0x61, 0x63, 0x62, 0x62, 0x63, 0x34, 0x61, 0x33, 0x34, 0x37, 0x62, 0x33, 0x63, 0x37, 0x30, 0x32, 0x65, 0x30, 0x38, 0x66, 0x36, 0x66, 0x35, 0x35, 0x34, 0x34, 0x37, 0x66, 0x63, 0x32, 0x34, 0x61, 0x66, 0x38, 0x64, 0x61, 0x34, 0x39, 0x66, 0x35, 0x66, 0x63, 0x62, 0x65, 0x34, 0x37, 0x32, 0x66, 0x37, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x33, 0x66, 0x30, 0x33, 0x30, 0x30, 0x35, 0x61, 0x39, 0x61, 0x32, 0x31, 0x62, 0x34, 0x64, 0x66, 0x38, 0x63, 0x32, 0x62, 0x39, 0x33, 0x39, 0x64, 0x63, 0x66, 0x30, 0x35, 0x61, 0x35, 0x30, 0x30, 0x31, 0x35, 0x62, 0x64, 0x37, 0x61, 0x33, 0x66, 0x31, 0x30, 0x63, 0x65, 0x34, 0x38, 0x32, 0x61, 0x63, 0x33, 0x62, 0x33, 0x32, 0x34, 0x37, 0x32, 0x62, 0x39, 0x37, 0x30, 0x61, 0x62, 0x64, 0x63, 0x34, 0x31, 0x33, 0x30, 0x30, 0x63, 0x37, 0x31, 0x62, 0x30, 0x34, 0x30, 0x62, 0x37, 0x39, 0x65, 0x65, 0x33, 0x61, 0x33, 0x30, 0x62, 0x38, 0x63, 0x61, 0x37, 0x35, 0x31, 0x39, 0x33, 0x36, 0x38, 0x37, 0x61, 0x37, 0x36, 0x63, 0x64, 0x66, 0x62, 0x34, 0x66, 0x63, 0x34, 0x39, 0x32, 0x31, 0x38, 0x63, 0x61, 0x37, 0x32, 0x66, 0x64, 0x37, 0x32, 0x34, 0x64, 0x65, 0x65, 0x31, 0x35, 0x61, 0x61, 0x39, 0x61, 0x32, 0x34, 0x62, 0x63, 0x37, 0x38, 0x61, 0x64, 0x37, 0x61, 0x39, 0x37, 0x31, 0x39, 0x33, 0x33, 0x63, 0x65, 0x38, 0x37, 0x66, 0x33, 0x37, 0x33, 0x35, 0x30, 0x35, 0x31, 0x62, 0x64, 0x31, 0x30, 0x33, 0x33, 0x30, 0x34, 0x35, 0x32, 0x64, 0x62, 0x37, 0x38, 0x34, 0x66, 0x38, 0x33, 0x66, 0x66, 0x37, 0x30, 0x62, 0x66, 0x31, 0x30, 0x33, 0x61, 0x30, 0x62, 0x64, 0x36, 0x65, 0x36, 0x33, 0x36, 0x35, 0x39, 0x64, 0x32, 0x31, 0x30, 0x63, 0x33, 0x37, 0x30, 0x39, 0x35, 0x35, 0x61, 0x35, 0x34, 0x63, 0x34, 0x61, 0x63, 0x64, 0x33, 0x30, 0x31, 0x37, 0x66, 0x63, 0x39, 0x38, 0x62, 0x30, 0x64, 0x33, 0x61, 0x65, 0x38, 0x63, 0x35, 0x36, 0x62, 0x33, 0x30, 0x32, 0x36, 0x37, 0x31, 0x39, 0x38, 0x66, 0x36, 0x37, 0x39, 0x37, 0x32, 0x36, 0x33, 0x65, 0x61, 0x36, 0x36, 0x32, 0x34, 0x63, 0x66, 0x61, 0x30, 0x31, 0x35, 0x63, 0x34, 0x66, 0x39, 0x64, 0x32, 0x38, 0x65, 0x35, 0x30, 0x33, 0x32, 0x37, 0x34, 0x36, 0x64, 0x39, 0x33, 0x38, 0x33, 0x33, 0x36, 0x30, 0x63, 0x63, 0x35, 0x30, 0x39, 0x33, 0x38, 0x31, 0x64, 0x64, 0x63, 0x64, 0x61, 0x38, 0x62, 0x34, 0x36, 0x32, 0x36, 0x37, 0x31, 0x64, 0x33, 0x36, 0x39, 0x34, 0x38, 0x30, 0x65, 0x35, 0x32, 0x39, 0x62, 0x38, 0x65, 0x66, 0x34, 0x66, 0x36, 0x65, 0x39, 0x34, 0x63, 0x66, 0x65, 0x31, 0x61, 0x30, 0x34, 0x38, 0x36, 0x64, 0x34, 0x61, 0x65, 0x33, 0x61, 0x38, 0x38, 0x37, 0x31, 0x32, 0x65, 0x39, 0x33, 0x38, 0x35, 0x64, 0x37, 0x65, 0x38, 0x35, 0x38, 0x30, 0x38, 0x39, 0x36, 0x33, 0x35, 0x31, 0x33, 0x37, 0x33, 0x30, 0x39, 0x66, 0x62, 0x37, 0x62, 0x37, 0x32, 0x36, 0x65, 0x35, 0x31, 0x66, 0x31, 0x38, 0x30, 0x61, 0x62, 0x30, 0x39, 0x38, 0x63, 0x37, 0x63, 0x32, 0x62, 0x62, 0x32, 0x66, 0x36, 0x37, 0x36, 0x61, 0x66, 0x36, 0x63, 0x32, 0x63, 0x62, 0x66, 0x34, 0x30, 0x31, 0x37, 0x36, 0x30, 0x64, 0x34, 0x35, 0x32, 0x66, 0x38, 0x66, 0x65, 0x63, 0x30, 0x65, 0x33, 0x30, 0x64, 0x38, 0x39, 0x30, 0x63, 0x37, 0x63, 0x65, 0x64, 0x33, 0x32, 0x30, 0x36, 0x64, 0x37, 0x30, 0x66, 0x66, 0x63, 0x65, 0x38, 0x61, 0x30, 0x35, 0x36, 0x30, 0x30, 0x61, 0x31, 0x66, 0x35, 0x30, 0x66, 0x64, 0x61, 0x33, 0x35, 0x61, 0x64, 0x33, 0x34, 0x30, 0x30, 0x66, 0x38, 0x31, 0x35, 0x34, 0x65, 0x34, 0x65, 0x65, 0x64, 0x62, 0x61, 0x61, 0x33, 0x63, 0x30, 0x38, 0x62, 0x63, 0x64, 0x65, 0x64, 0x63, 0x32, 0x34, 0x30, 0x64, 0x32, 0x63, 0x36, 0x37, 0x36, 0x37, 0x32, 0x30, 0x34, 0x30, 0x30, 0x63, 0x64, 0x66, 0x64, 0x65, 0x64, 0x35, 0x34, 0x61, 0x38, 0x35, 0x63, 0x30, 0x61, 0x61, 0x63, 0x38, 0x66, 0x63, 0x30, 0x38, 0x36, 0x31, 0x31, 0x38, 0x33, 0x32, 0x30, 0x39, 0x30, 0x38, 0x34, 0x66, 0x37, 0x33, 0x33, 0x62, 0x61, 0x66, 0x62, 0x35, 0x63, 0x35, 0x64, 0x65, 0x37, 0x35, 0x62, 0x36, 0x64, 0x30, 0x30, 0x32, 0x64, 0x37, 0x39, 0x61, 0x35, 0x37, 0x32, 0x63, 0x33, 0x63, 0x61, 0x62, 0x65, 0x35, 0x61, 0x38, 0x38, 0x37, 0x38, 0x35, 0x62, 0x62, 0x34, 0x34, 0x66, 0x39, 0x34, 0x64, 0x61, 0x61, 0x61, 0x30, 0x37, 0x34, 0x35, 0x37, 0x62, 0x31, 0x34, 0x63, 0x34, 0x34, 0x63, 0x31, 0x38, 0x65, 0x33, 0x34, 0x31, 0x33, 0x32, 0x64, 0x66, 0x35, 0x37, 0x32, 0x61, 0x38, 0x39, 0x38, 0x63, 0x30, 0x36, 0x38, 0x32, 0x61, 0x31, 0x37, 0x33, 0x37, 0x32, 0x64, 0x63, 0x32, 0x62, 0x65, 0x36, 0x36, 0x34, 0x62, 0x66, 0x64, 0x62, 0x30, 0x66, 0x31, 0x39, 0x61, 0x30, 0x39, 0x30, 0x61, 0x39, 0x31, 0x31, 0x31, 0x34, 0x61, 0x62, 0x64, 0x39, 0x62, 0x38, 0x39, 0x35, 0x66, 0x66, 0x31, 0x64, 0x33, 0x36, 0x65, 0x37, 0x62, 0x37, 0x30, 0x61, 0x31, 0x37, 0x31, 0x37, 0x62, 0x32, 0x30, 0x61, 0x30, 0x39, 0x63, 0x64, 0x66, 0x35, 0x38, 0x32, 0x37, 0x32, 0x38, 0x33, 0x36, 0x32, 0x64, 0x64, 0x63, 0x61, 0x66, 0x64, 0x37, 0x30, 0x33, 0x66, 0x36, 0x36, 0x35, 0x33, 0x62, 0x35, 0x37, 0x37, 0x35, 0x35, 0x61, 0x64, 0x35, 0x62, 0x36, 0x39, 0x38, 0x35, 0x64, 0x64, 0x35, 0x36, 0x33, 0x39, 0x65, 0x62, 0x34, 0x36, 0x63, 0x39, 0x34, 0x37, 0x63, 0x39, 0x31, 0x35, 0x31, 0x64, 0x35, 0x65, 0x39, 0x37, 0x61, 0x61, 0x62, 0x31, 0x63, 0x66, 0x37, 0x32, 0x30, 0x61, 0x66, 0x32, 0x66, 0x63, 0x31, 0x34, 0x64, 0x39, 0x64, 0x37, 0x36, 0x34, 0x61, 0x64, 0x65, 0x61, 0x65, 0x35, 0x38, 0x66, 0x35, 0x63, 0x30, 0x38, 0x30, 0x36, 0x35, 0x66, 0x32, 0x31, 0x64, 0x64, 0x34, 0x63, 0x64, 0x34, 0x65, 0x36, 0x65, 0x34, 0x39, 0x64, 0x33, 0x38, 0x33, 0x31, 0x34, 0x32, 0x36, 0x61, 0x39, 0x33, 0x38, 0x66, 0x61, 0x32, 0x32, 0x33, 0x31, 0x66, 0x34, 0x64, 0x30, 0x30, 0x62, 0x35, 0x37, 0x36, 0x35, 0x35, 0x61, 0x35, 0x36, 0x36, 0x39, 0x64, 0x30, 0x38, 0x39, 0x37, 0x63, 0x65, 0x63, 0x39, 0x35, 0x64, 0x66, 0x30, 0x65, 0x38, 0x61, 0x61, 0x36, 0x61, 0x62, 0x36, 0x35, 0x62, 0x66, 0x63, 0x37, 0x38, 0x65, 0x37, 0x66, 0x34, 0x39, 0x31, 0x35, 0x37, 0x62, 0x33, 0x34, 0x32, 0x62, 0x63, 0x32, 0x61, 0x34, 0x62, 0x61, 0x37, 0x38, 0x66, 0x37, 0x32, 0x66, 0x31, 0x63, 0x34, 0x66, 0x31, 0x33, 0x39, 0x34, 0x35, 0x63, 0x62, 0x63, 0x63, 0x65, 0x39, 0x36, 0x32, 0x39, 0x38, 0x39, 0x64, 0x30, 0x66, 0x31, 0x62, 0x33, 0x64, 0x30, 0x66, 0x32, 0x65, 0x31, 0x62, 0x34, 0x66, 0x34, 0x63, 0x63, 0x36, 0x65, 0x30, 0x37, 0x31, 0x39, 0x37, 0x35, 0x38, 0x31, 0x34, 0x66, 0x34, 0x62, 0x35, 0x61, 0x39, 0x38, 0x38, 0x64, 0x37, 0x30, 0x37, 0x37, 0x32, 0x32, 0x33, 0x61, 0x39, 0x36, 0x64, 0x61, 0x38, 0x61, 0x32, 0x62, 0x63, 0x32, 0x30, 0x62, 0x36, 0x30, 0x37, 0x33, 0x37, 0x35, 0x30, 0x66, 0x36, 0x34, 0x32, 0x39, 0x37, 0x31, 0x31, 0x63, 0x35, 0x30, 0x66, 0x35, 0x39, 0x62, 0x34, 0x61, 0x66, 0x33, 0x36, 0x65, 0x64, 0x36, 0x30, 0x30, 0x66, 0x32, 0x63, 0x63, 0x39, 0x31, 0x30, 0x33, 0x63, 0x31, 0x36, 0x64, 0x37, 0x38, 0x39, 0x30, 0x39, 0x66, 0x65, 0x64, 0x39, 0x35, 0x32, 0x33, 0x34, 0x63, 0x61, 0x38, 0x64, 0x31, 0x38, 0x38, 0x61, 0x31, 0x62, 0x61, 0x34, 0x61, 0x37, 0x30, 0x32, 0x33, 0x33, 0x38, 0x62, 0x32, 0x61, 0x35, 0x32, 0x65, 0x34, 0x35, 0x34, 0x38, 0x61, 0x64, 0x35, 0x36, 0x34, 0x35, 0x61, 0x66, 0x61, 0x32, 0x39, 0x30, 0x61, 0x36, 0x30, 0x34, 0x35, 0x32, 0x38, 0x64, 0x31, 0x30, 0x62, 0x65, 0x38, 0x37, 0x32, 0x65, 0x35, 0x35, 0x31, 0x36, 0x37, 0x37, 0x61, 0x30, 0x62, 0x37, 0x32, 0x63, 0x32, 0x31, 0x33, 0x37, 0x32, 0x66, 0x63, 0x39, 0x39, 0x33, 0x33, 0x30, 0x65, 0x33, 0x31, 0x30, 0x66, 0x34, 0x30, 0x39, 0x30, 0x64, 0x63, 0x37, 0x65, 0x30, 0x39, 0x32, 0x65, 0x37, 0x30, 0x37, 0x38, 0x35, 0x36, 0x64, 0x62, 0x34, 0x34, 0x37, 0x33, 0x30, 0x37, 0x33, 0x33, 0x32, 0x35, 0x37, 0x32, 0x37, 0x32, 0x39, 0x31, 0x33, 0x64, 0x66, 0x65, 0x66, 0x66, 0x62, 0x36, 0x39, 0x38, 0x65, 0x31, 0x35, 0x34, 0x62, 0x33, 0x32, 0x62, 0x61, 0x38, 0x38, 0x66, 0x62, 0x39, 0x34, 0x62, 0x35, 0x65, 0x30, 0x65, 0x64, 0x66, 0x63, 0x35, 0x65, 0x66, 0x61, 0x33, 0x35, 0x31, 0x31, 0x37, 0x37, 0x38, 0x61, 0x61, 0x33, 0x63, 0x62, 0x35, 0x39, 0x61, 0x34, 0x36, 0x39, 0x61, 0x36, 0x63, 0x37, 0x63, 0x37, 0x32, 0x37, 0x63, 0x36, 0x64, 0x33, 0x30, 0x33, 0x64, 0x37, 0x33, 0x63, 0x36, 0x61, 0x36, 0x64, 0x30, 0x64, 0x63, 0x39, 0x31, 0x62, 0x30, 0x61, 0x32, 0x39, 0x36, 0x33, 0x39, 0x64, 0x61, 0x30, 0x37, 0x61, 0x62, 0x36, 0x61, 0x32, 0x39, 0x65, 0x31, 0x30, 0x64, 0x34, 0x62, 0x66, 0x39, 0x65, 0x63, 0x66, 0x33, 0x32, 0x66, 0x37, 0x36, 0x34, 0x34, 0x65, 0x36, 0x66, 0x64, 0x65, 0x33, 0x37, 0x32, 0x33, 0x30, 0x33, 0x30, 0x34, 0x61, 0x62, 0x32, 0x61, 0x32, 0x32, 0x39, 0x63, 0x35, 0x32, 0x33, 0x34, 0x64, 0x36, 0x33, 0x39, 0x32, 0x62, 0x39, 0x61, 0x34, 0x64, 0x62, 0x32, 0x61, 0x61, 0x65, 0x33, 0x34, 0x64, 0x66, 0x62, 0x64, 0x62, 0x65, 0x64, 0x35, 0x63, 0x39, 0x62, 0x38, 0x39, 0x61, 0x61, 0x63, 0x34, 0x61, 0x35, 0x64, 0x66, 0x35, 0x37, 0x38, 0x30, 0x35, 0x34, 0x38, 0x37, 0x32, 0x35, 0x35, 0x63, 0x38, 0x62, 0x33, 0x30, 0x62, 0x62, 0x31, 0x66, 0x62, 0x65, 0x65, 0x37, 0x64, 0x63, 0x30, 0x61, 0x62, 0x34, 0x35, 0x39, 0x62, 0x32, 0x36, 0x30, 0x38, 0x62, 0x65, 0x34, 0x38, 0x64, 0x38, 0x33, 0x32, 0x62, 0x34, 0x33, 0x32, 0x33, 0x64, 0x31, 0x37, 0x66, 0x62, 0x30, 0x66, 0x34, 0x65, 0x64, 0x64, 0x65, 0x61, 0x63, 0x38, 0x61, 0x63, 0x61, 0x62, 0x62, 0x63, 0x33, 0x30, 0x32, 0x34, 0x66, 0x64, 0x36, 0x37, 0x33, 0x31, 0x62, 0x38, 0x66, 0x66, 0x65, 0x32, 0x36, 0x31, 0x39, 0x66, 0x32, 0x35, 0x38, 0x30, 0x31, 0x32, 0x61, 0x65, 0x37, 0x33, 0x66, 0x61, 0x36, 0x62, 0x32, 0x30, 0x32, 0x64, 0x65, 0x66, 0x33, 0x35, 0x34, 0x36, 0x32, 0x30, 0x37, 0x62, 0x63, 0x62, 0x62, 0x65, 0x37, 0x61, 0x36, 0x63, 0x34, 0x33, 0x35, 0x38, 0x39, 0x33, 0x36, 0x36, 0x35, 0x37, 0x30, 0x65, 0x61, 0x31, 0x62, 0x38, 0x37, 0x38, 0x36, 0x30, 0x64, 0x65, 0x36, 0x30, 0x34, 0x35, 0x35, 0x35, 0x64, 0x31, 0x33, 0x61, 0x36, 0x61, 0x63, 0x39, 0x63, 0x34, 0x65, 0x33, 0x34, 0x62, 0x38, 0x32, 0x39, 0x37, 0x30, 0x30, 0x36, 0x30, 0x35, 0x37, 0x33, 0x39, 0x33, 0x30, 0x63, 0x36, 0x38, 0x39, 0x36, 0x34, 0x30, 0x33, 0x36, 0x36, 0x38, 0x61, 0x61, 0x64, 0x30, 0x31, 0x37, 0x32, 0x31, 0x66, 0x64, 0x64, 0x30, 0x62, 0x39, 0x38, 0x65, 0x33, 0x66, 0x62, 0x64, 0x66, 0x65, 0x39, 0x63, 0x65, 0x63, 0x33, 0x61, 0x32, 0x62, 0x64, 0x62, 0x30, 0x63, 0x33, 0x64, 0x63, 0x34, 0x61, 0x65, 0x35, 0x32, 0x35, 0x39, 0x35, 0x32, 0x62, 0x36, 0x37, 0x33, 0x34, 0x39, 0x35, 0x37, 0x30, 0x66, 0x65, 0x37, 0x38, 0x39, 0x38, 0x35, 0x35, 0x38, 0x64, 0x31, 0x31, 0x65, 0x64, 0x37, 0x32, 0x63, 0x31, 0x34, 0x34, 0x31, 0x65, 0x38, 0x35, 0x64, 0x35, 0x39, 0x34, 0x63, 0x35, 0x35, 0x32, 0x37, 0x38, 0x38, 0x33, 0x64, 0x36, 0x37, 0x35, 0x30, 0x32, 0x38, 0x32, 0x32, 0x32, 0x63, 0x33, 0x63, 0x64, 0x36, 0x63, 0x35, 0x31, 0x62, 0x35, 0x34, 0x32, 0x36, 0x33, 0x36, 0x35, 0x65, 0x34, 0x62, 0x38, 0x30, 0x61, 0x36, 0x38, 0x34, 0x66, 0x64, 0x64, 0x64, 0x30, 0x65, 0x38, 0x37, 0x32, 0x31, 0x62, 0x65, 0x34, 0x31, 0x62, 0x35, 0x61, 0x30, 0x64, 0x61, 0x64, 0x38, 0x30, 0x30, 0x36, 0x33, 0x61, 0x64, 0x36, 0x66, 0x33, 0x34, 0x63, 0x34, 0x64, 0x33, 0x34, 0x31, 0x36, 0x66, 0x66, 0x62, 0x30, 0x63, 0x63, 0x31, 0x33, 0x62, 0x38, 0x62, 0x64, 0x30, 0x34, 0x35, 0x65, 0x39, 0x39, 0x66, 0x35, 0x37, 0x37, 0x37, 0x32, 0x35, 0x38, 0x61, 0x35, 0x30, 0x37, 0x38, 0x31, 0x33, 0x32, 0x62, 0x64, 0x64, 0x36, 0x32, 0x31, 0x38, 0x30, 0x62, 0x37, 0x30, 0x62, 0x38, 0x64, 0x33, 0x63, 0x36, 0x34, 0x30, 0x37, 0x35, 0x36, 0x65, 0x39, 0x32, 0x33, 0x64, 0x38, 0x33, 0x38, 0x61, 0x37, 0x34, 0x31, 0x65, 0x30, 0x64, 0x66, 0x39, 0x61, 0x66, 0x66, 0x63, 0x38, 0x35, 0x62, 0x39, 0x38, 0x34, 0x61, 0x62, 0x38, 0x38, 0x65, 0x33, 0x39, 0x62, 0x65, 0x30, 0x65, 0x64, 0x66, 0x32, 0x66, 0x35, 0x33, 0x62, 0x30, 0x64, 0x61, 0x31, 0x65, 0x36, 0x33, 0x32, 0x61, 0x32, 0x66, 0x64, 0x62, 0x38, 0x38, 0x30, 0x64, 0x38, 0x64, 0x33, 0x34, 0x37, 0x62, 0x39, 0x64, 0x61, 0x34, 0x63, 0x33, 0x33, 0x36, 0x64, 0x32, 0x32, 0x35, 0x61, 0x63, 0x66, 0x39, 0x37, 0x33, 0x65, 0x31, 0x66, 0x61, 0x62, 0x35, 0x37, 0x64, 0x66, 0x38, 0x64, 0x61, 0x38, 0x62, 0x65, 0x61, 0x66, 0x63, 0x37, 0x32, 0x31, 0x32, 0x39, 0x61, 0x64, 0x64, 0x38, 0x30, 0x61, 0x37, 0x32, 0x30, 0x35, 0x39, 0x38, 0x35, 0x66, 0x31, 0x32, 0x30, 0x63, 0x31, 0x63, 0x34, 0x66, 0x31, 0x65, 0x66, 0x34, 0x61, 0x38, 0x63, 0x62, 0x34, 0x64, 0x39, 0x66, 0x39, 0x35, 0x61, 0x61, 0x37, 0x65, 0x63, 0x36, 0x36, 0x36, 0x66, 0x61, 0x62, 0x64, 0x39, 0x31, 0x34, 0x36, 0x32, 0x61, 0x37, 0x39, 0x30, 0x32, 0x36, 0x32, 0x62, 0x65, 0x33, 0x36, 0x36, 0x33, 0x65, 0x34, 0x32, 0x32, 0x37, 0x33, 0x31, 0x33, 0x34, 0x37, 0x65, 0x62, 0x35, 0x38, 0x63, 0x32, 0x66, 0x32, 0x39, 0x66, 0x35, 0x64, 0x61, 0x64, 0x33, 0x63, 0x32, 0x31, 0x65, 0x30, 0x62, 0x39, 0x65, 0x32, 0x64, 0x33, 0x61, 0x31, 0x32, 0x64, 0x39, 0x33, 0x63, 0x62, 0x32, 0x61, 0x35, 0x30, 0x64, 0x31, 0x39, 0x66, 0x32, 0x37, 0x35, 0x35, 0x62, 0x30, 0x31, 0x65, 0x33, 0x64, 0x38, 0x31, 0x38, 0x66, 0x33, 0x34, 0x37, 0x33, 0x64, 0x63, 0x64, 0x33, 0x38, 0x66, 0x34, 0x30, 0x34, 0x64, 0x37, 0x30, 0x62, 0x38, 0x37, 0x35, 0x33, 0x34, 0x33, 0x65, 0x33, 0x38, 0x32, 0x66, 0x65, 0x31, 0x32, 0x30, 0x38, 0x36, 0x31, 0x39, 0x65, 0x65, 0x32, 0x63, 0x37, 0x36, 0x37, 0x61, 0x62, 0x39, 0x37, 0x63, 0x33, 0x34, 0x63, 0x39, 0x34, 0x63, 0x62, 0x37, 0x32, 0x62, 0x32, 0x66, 0x33, 0x39, 0x30, 0x61, 0x66, 0x62, 0x39, 0x61, 0x39, 0x38, 0x64, 0x38, 0x35, 0x63, 0x61, 0x39, 0x64, 0x33, 0x30, 0x64, 0x30, 0x35, 0x62, 0x30, 0x30, 0x36, 0x65, 0x39, 0x62, 0x63, 0x39, 0x30, 0x64, 0x63, 0x34, 0x33, 0x34, 0x65, 0x34, 0x30, 0x63, 0x61, 0x35, 0x66, 0x38, 0x35, 0x35, 0x38, 0x31, 0x34, 0x65, 0x35, 0x38, 0x39, 0x39, 0x62, 0x35, 0x30, 0x38, 0x32, 0x30, 0x66, 0x37, 0x38, 0x62, 0x31, 0x36, 0x61, 0x64, 0x61, 0x38, 0x33, 0x62, 0x36, 0x61, 0x38, 0x66, 0x31, 0x66, 0x38, 0x30, 0x30, 0x35, 0x38, 0x62, 0x36, 0x64, 0x35, 0x65, 0x33, 0x37, 0x64, 0x64, 0x64, 0x33, 0x61, 0x34, 0x62, 0x66, 0x65, 0x39, 0x39, 0x65, 0x33, 0x37, 0x38, 0x36, 0x66, 0x63, 0x32, 0x37, 0x34, 0x32, 0x63, 0x32, 0x34, 0x37, 0x34, 0x32, 0x37, 0x33, 0x35, 0x34, 0x32, 0x35, 0x33, 0x34, 0x65, 0x30, 0x66, 0x63, 0x35, 0x34, 0x65, 0x30, 0x62, 0x62, 0x36, 0x33, 0x61, 0x63, 0x30, 0x39, 0x61, 0x30, 0x33, 0x39, 0x36, 0x34, 0x35, 0x35, 0x66, 0x64, 0x62, 0x35, 0x65, 0x35, 0x32, 0x36, 0x39, 0x32, 0x32, 0x63, 0x66, 0x34, 0x31, 0x36, 0x33, 0x35, 0x31, 0x34, 0x64, 0x33, 0x61, 0x31, 0x37, 0x38, 0x65, 0x65, 0x62, 0x65, 0x65, 0x31, 0x37, 0x33, 0x34, 0x39, 0x37, 0x32, 0x39, 0x32, 0x31, 0x66, 0x30, 0x39, 0x32, 0x62, 0x35, 0x39, 0x32, 0x33, 0x35, 0x37, 0x30, 0x32, 0x31, 0x63, 0x38, 0x38, 0x34, 0x34, 0x32, 0x31, 0x30, 0x37, 0x66, 0x61, 0x31, 0x39, 0x64, 0x35, 0x63, 0x63, 0x31, 0x35, 0x62, 0x36, 0x31, 0x64, 0x34, 0x37, 0x33, 0x66, 0x32, 0x39, 0x63, 0x33, 0x38, 0x33, 0x32, 0x61, 0x34, 0x39, 0x64, 0x35, 0x32, 0x62, 0x65, 0x62, 0x66, 0x61, 0x37, 0x32, 0x34, 0x35, 0x33, 0x35, 0x33, 0x61, 0x35, 0x66, 0x35, 0x38, 0x64, 0x37, 0x37, 0x62, 0x61, 0x31, 0x38, 0x62, 0x37, 0x37, 0x37, 0x32, 0x34, 0x66, 0x30, 0x32, 0x66, 0x30, 0x37, 0x36, 0x65, 0x35, 0x63, 0x63, 0x64, 0x33, 0x63, 0x63, 0x38, 0x61, 0x39, 0x61, 0x64, 0x66, 0x64, 0x62, 0x30, 0x62, 0x32, 0x30, 0x64, 0x66, 0x34, 0x34, 0x62, 0x61, 0x38, 0x31, 0x36, 0x35, 0x61, 0x61, 0x37, 0x32, 0x35, 0x63, 0x36, 0x37, 0x30, 0x37, 0x64, 0x34, 0x38, 0x32, 0x31, 0x38, 0x33, 0x38, 0x65, 0x66, 0x35, 0x30, 0x38, 0x34, 0x39, 0x36, 0x32, 0x35, 0x62, 0x65, 0x34, 0x31, 0x34, 0x62, 0x30, 0x62, 0x31, 0x31, 0x35, 0x64, 0x64, 0x65, 0x61, 0x37, 0x36, 0x62, 0x30, 0x66, 0x62, 0x32, 0x66, 0x36, 0x34, 0x30, 0x65, 0x30, 0x35, 0x35, 0x66, 0x61, 0x61, 0x64, 0x35, 0x37, 0x30, 0x36, 0x34, 0x65, 0x65, 0x33, 0x32, 0x37, 0x32, 0x37, 0x61, 0x63, 0x61, 0x65, 0x66, 0x65, 0x33, 0x39, 0x38, 0x36, 0x64, 0x61, 0x65, 0x30, 0x31, 0x61, 0x33, 0x66, 0x64, 0x35, 0x63, 0x31, 0x36, 0x66, 0x30, 0x61, 0x33, 0x30, 0x38, 0x32, 0x35, 0x34, 0x32, 0x37, 0x32, 0x32, 0x61, 0x37, 0x37, 0x65, 0x37, 0x33, 0x34, 0x66, 0x37, 0x65, 0x30, 0x33, 0x39, 0x62, 0x63, 0x34, 0x38, 0x36, 0x37, 0x30, 0x37, 0x32, 0x39, 0x37, 0x31, 0x31, 0x64, 0x32, 0x34, 0x38, 0x61, 0x35, 0x38, 0x37, 0x61, 0x35, 0x30, 0x38, 0x63, 0x63, 0x36, 0x35, 0x36, 0x35, 0x62, 0x31, 0x37, 0x30, 0x37, 0x63, 0x39, 0x37, 0x65, 0x62, 0x33, 0x62, 0x38, 0x65, 0x63, 0x65, 0x62, 0x63, 0x63, 0x33, 0x63, 0x66, 0x33, 0x35, 0x30, 0x30, 0x61, 0x33, 0x66, 0x32, 0x32, 0x62, 0x65, 0x37, 0x34, 0x36, 0x30, 0x33, 0x63, 0x38, 0x37, 0x32, 0x34, 0x32, 0x61, 0x38, 0x65, 0x36, 0x38, 0x61, 0x64, 0x35, 0x65, 0x36, 0x63, 0x62, 0x33, 0x31, 0x61, 0x66, 0x39, 0x30, 0x32, 0x39, 0x65, 0x36, 0x31, 0x66, 0x36, 0x35, 0x38, 0x30, 0x65, 0x63, 0x38, 0x33, 0x65, 0x63, 0x34, 0x32, 0x36, 0x35, 0x32, 0x31, 0x63, 0x65, 0x63, 0x35, 0x37, 0x62, 0x36, 0x66, 0x36, 0x64, 0x33, 0x32, 0x34, 0x31, 0x35, 0x35, 0x61, 0x38, 0x62, 0x65, 0x31, 0x35, 0x66, 0x35, 0x31, 0x30, 0x39, 0x65, 0x64, 0x36, 0x34, 0x63, 0x36, 0x65, 0x30, 0x66, 0x34, 0x35, 0x62, 0x61, 0x30, 0x36, 0x35, 0x33, 0x37, 0x30, 0x61, 0x30, 0x64, 0x31, 0x31, 0x36, 0x38, 0x37, 0x65, 0x32, 0x36, 0x31, 0x64, 0x30, 0x34, 0x34, 0x61, 0x65, 0x31, 0x34, 0x61, 0x35, 0x65, 0x38, 0x66, 0x37, 0x34, 0x65, 0x62, 0x64, 0x63, 0x37, 0x62, 0x65, 0x38, 0x37, 0x39, 0x64, 0x37, 0x32, 0x34, 0x37, 0x38, 0x62, 0x61, 0x64, 0x38, 0x62, 0x64, 0x65, 0x34, 0x38, 0x38, 0x64, 0x61, 0x35, 0x37, 0x35, 0x38, 0x33, 0x61, 0x38, 0x34, 0x34, 0x34, 0x30, 0x64, 0x30, 0x38, 0x33, 0x37, 0x38, 0x66, 0x32, 0x39, 0x62, 0x30, 0x62, 0x35, 0x39, 0x36, 0x37, 0x32, 0x39, 0x63, 0x34, 0x34, 0x33, 0x35, 0x65, 0x66, 0x32, 0x65, 0x61, 0x66, 0x64, 0x34, 0x37, 0x64, 0x66, 0x65, 0x33, 0x34, 0x37, 0x62, 0x61, 0x32, 0x32, 0x64, 0x35, 0x65, 0x30, 0x34, 0x64, 0x38, 0x63, 0x38, 0x61, 0x33, 0x31, 0x61, 0x65, 0x64, 0x37, 0x38, 0x38, 0x33, 0x30, 0x37, 0x36, 0x65, 0x31, 0x36, 0x38, 0x63, 0x63, 0x63, 0x32, 0x38, 0x64, 0x30, 0x36, 0x33, 0x36, 0x61, 0x38, 0x66, 0x66, 0x65, 0x63, 0x66, 0x39, 0x63, 0x34, 0x30, 0x38, 0x38, 0x35, 0x61, 0x37, 0x32, 0x30, 0x33, 0x37, 0x39, 0x32, 0x37, 0x32, 0x34, 0x36, 0x34, 0x39, 0x31, 0x66, 0x30, 0x38, 0x36, 0x62, 0x31, 0x33, 0x38, 0x63, 0x63, 0x62, 0x30, 0x34, 0x66, 0x30, 0x31, 0x63, 0x37, 0x30, 0x39, 0x35, 0x64, 0x34, 0x66, 0x34, 0x39, 0x66, 0x36, 0x31, 0x61, 0x33, 0x65, 0x62, 0x39, 0x64, 0x33, 0x39, 0x31, 0x63, 0x35, 0x66, 0x61, 0x61, 0x33, 0x30, 0x34, 0x33, 0x39, 0x32, 0x63, 0x35, 0x62, 0x36, 0x34, 0x30, 0x31, 0x33, 0x37, 0x32, 0x62, 0x66, 0x61, 0x38, 0x61, 0x32, 0x34, 0x66, 0x63, 0x36, 0x61, 0x30, 0x38, 0x39, 0x61, 0x38, 0x62, 0x61, 0x66, 0x39, 0x30, 0x38, 0x39, 0x35, 0x31, 0x61, 0x62, 0x39, 0x63, 0x33, 0x36, 0x35, 0x65, 0x33, 0x63, 0x61, 0x61, 0x64, 0x38, 0x30, 0x66, 0x35, 0x61, 0x35, 0x62, 0x65, 0x30, 0x63, 0x62, 0x64, 0x62, 0x38, 0x38, 0x34, 0x66, 0x31, 0x34, 0x64, 0x36, 0x38, 0x37, 0x37, 0x37, 0x32, 0x32, 0x62, 0x36, 0x31, 0x31, 0x62, 0x38, 0x37, 0x33, 0x38, 0x39, 0x33, 0x33, 0x34, 0x61, 0x66, 0x38, 0x61, 0x31, 0x34, 0x37, 0x36, 0x66, 0x32, 0x63, 0x61, 0x62, 0x37, 0x62, 0x32, 0x35, 0x65, 0x39, 0x63, 0x61, 0x32, 0x32, 0x34, 0x32, 0x62, 0x62, 0x31, 0x31, 0x33, 0x64, 0x37, 0x37, 0x64, 0x38, 0x32, 0x62, 0x63, 0x64, 0x36, 0x30, 0x34, 0x32, 0x30, 0x31, 0x63, 0x34, 0x37, 0x32, 0x34, 0x35, 0x32, 0x66, 0x39, 0x31, 0x34, 0x38, 0x36, 0x36, 0x33, 0x66, 0x66, 0x62, 0x33, 0x34, 0x61, 0x38, 0x65, 0x61, 0x64, 0x31, 0x33, 0x63, 0x64, 0x61, 0x39, 0x38, 0x65, 0x61, 0x38, 0x32, 0x31, 0x35, 0x35, 0x37, 0x36, 0x38, 0x36, 0x31, 0x38, 0x35, 0x34, 0x35, 0x30, 0x64, 0x63, 0x62, 0x37, 0x39, 0x36, 0x39, 0x38, 0x37, 0x66, 0x36, 0x31, 0x31, 0x30, 0x63, 0x64, 0x62, 0x38, 0x37, 0x32, 0x66, 0x61, 0x61, 0x36, 0x31, 0x37, 0x32, 0x61, 0x62, 0x34, 0x30, 0x31, 0x63, 0x35, 0x31, 0x65, 0x33, 0x66, 0x66, 0x35, 0x62, 0x62, 0x34, 0x36, 0x35, 0x38, 0x31, 0x35, 0x33, 0x34, 0x39, 0x36, 0x36, 0x64, 0x34, 0x33, 0x65, 0x30, 0x37, 0x37, 0x33, 0x33, 0x66, 0x34, 0x37, 0x63, 0x63, 0x39, 0x34, 0x35, 0x66, 0x30, 0x61, 0x63, 0x38, 0x36, 0x63, 0x35, 0x33, 0x36, 0x63, 0x30, 0x36, 0x32, 0x66, 0x62, 0x37, 0x62, 0x63, 0x61, 0x37, 0x66, 0x38, 0x36, 0x37, 0x37, 0x33, 0x39, 0x65, 0x32, 0x31, 0x63, 0x65, 0x64, 0x62, 0x38, 0x66, 0x35, 0x61, 0x32, 0x65, 0x37, 0x30, 0x38, 0x31, 0x34, 0x33, 0x63, 0x34, 0x65, 0x62, 0x38, 0x65, 0x64, 0x38, 0x61, 0x32, 0x65, 0x30, 0x34, 0x31, 0x39, 0x36, 0x65, 0x31, 0x62, 0x38, 0x66, 0x65, 0x62, 0x34, 0x35, 0x30, 0x36, 0x39, 0x37, 0x35, 0x65, 0x62, 0x38, 0x32, 0x30, 0x35, 0x65, 0x66, 0x36, 0x33, 0x35, 0x65, 0x38, 0x66, 0x61, 0x61, 0x66, 0x62, 0x64, 0x35, 0x63, 0x65, 0x66, 0x38, 0x33, 0x30, 0x62, 0x66, 0x66, 0x66, 0x38, 0x30, 0x63, 0x61, 0x34, 0x33, 0x63, 0x63, 0x38, 0x34, 0x36, 0x37, 0x33, 0x30, 0x64, 0x33, 0x35, 0x65, 0x33, 0x35, 0x61, 0x64, 0x32, 0x61, 0x39, 0x31, 0x34, 0x65, 0x35, 0x37, 0x32, 0x65, 0x31, 0x37, 0x32, 0x63, 0x37, 0x33, 0x39, 0x65, 0x31, 0x38, 0x31, 0x61, 0x62, 0x39, 0x63, 0x36, 0x61, 0x62, 0x65, 0x63, 0x35, 0x31, 0x63, 0x30, 0x33, 0x33, 0x66, 0x37, 0x62, 0x64, 0x62, 0x62, 0x37, 0x63, 0x63, 0x37, 0x63, 0x63, 0x30, 0x30, 0x30, 0x39, 0x63, 0x33, 0x35, 0x33, 0x39, 0x66, 0x65, 0x35, 0x34, 0x34, 0x32, 0x36, 0x30, 0x65, 0x65, 0x64, 0x39, 0x39, 0x32, 0x31, 0x39, 0x30, 0x33, 0x37, 0x32, 0x63, 0x37, 0x37, 0x32, 0x65, 0x63, 0x33, 0x64, 0x65, 0x63, 0x30, 0x31, 0x65, 0x65, 0x37, 0x31, 0x38, 0x34, 0x34, 0x34, 0x30, 0x37, 0x35, 0x30, 0x32, 0x65, 0x38, 0x30, 0x66, 0x63, 0x39, 0x33, 0x37, 0x35, 0x39, 0x64, 0x36, 0x64, 0x39, 0x37, 0x66, 0x35, 0x33, 0x65, 0x63, 0x64, 0x31, 0x32, 0x31, 0x30, 0x38, 0x38, 0x31, 0x39, 0x38, 0x38, 0x36, 0x65, 0x36, 0x30, 0x61, 0x39, 0x37, 0x32, 0x32, 0x36, 0x37, 0x65, 0x64, 0x61, 0x61, 0x31, 0x33, 0x30, 0x39, 0x64, 0x31, 0x64, 0x33, 0x38, 0x62, 0x33, 0x38, 0x39, 0x31, 0x30, 0x66, 0x31, 0x35, 0x62, 0x31, 0x63, 0x35, 0x65, 0x33, 0x38, 0x37, 0x35, 0x62, 0x38, 0x30, 0x65, 0x65, 0x33, 0x32, 0x32, 0x64, 0x37, 0x39, 0x63, 0x35, 0x66, 0x61, 0x34, 0x34, 0x34, 0x35, 0x39, 0x30, 0x31, 0x32, 0x66, 0x39, 0x31, 0x38, 0x31, 0x37, 0x32, 0x32, 0x63, 0x34, 0x62, 0x66, 0x66, 0x30, 0x37, 0x64, 0x61, 0x35, 0x33, 0x66, 0x39, 0x66, 0x37, 0x37, 0x65, 0x35, 0x30, 0x31, 0x35, 0x34, 0x65, 0x36, 0x34, 0x61, 0x63, 0x31, 0x64, 0x31, 0x39, 0x39, 0x65, 0x66, 0x66, 0x38, 0x64, 0x62, 0x34, 0x64, 0x38, 0x64, 0x30, 0x66, 0x39, 0x35, 0x30, 0x65, 0x30, 0x34, 0x33, 0x63, 0x36, 0x35, 0x66, 0x63, 0x63, 0x37, 0x62, 0x31, 0x35, 0x37, 0x32, 0x38, 0x66, 0x65, 0x38, 0x61, 0x64, 0x36, 0x64, 0x32, 0x30, 0x61, 0x30, 0x64, 0x61, 0x62, 0x64, 0x33, 0x37, 0x39, 0x38, 0x65, 0x64, 0x63, 0x65, 0x31, 0x61, 0x30, 0x36, 0x36, 0x30, 0x38, 0x31, 0x31, 0x33, 0x33, 0x63, 0x66, 0x65, 0x64, 0x35, 0x37, 0x38, 0x33, 0x37, 0x38, 0x36, 0x36, 0x64, 0x63, 0x33, 0x39, 0x31, 0x36, 0x63, 0x33, 0x63, 0x32, 0x38, 0x35, 0x36, 0x61, 0x37, 0x37, 0x32, 0x31, 0x65, 0x34, 0x35, 0x63, 0x32, 0x37, 0x35, 0x35, 0x32, 0x32, 0x32, 0x30, 0x32, 0x64, 0x34, 0x34, 0x36, 0x66, 0x32, 0x39, 0x62, 0x34, 0x35, 0x66, 0x37, 0x34, 0x32, 0x33, 0x61, 0x65, 0x65, 0x32, 0x31, 0x34, 0x63, 0x31, 0x34, 0x66, 0x36, 0x30, 0x66, 0x30, 0x63, 0x38, 0x62, 0x66, 0x65, 0x64, 0x65, 0x30, 0x62, 0x66, 0x32, 0x34, 0x35, 0x35, 0x31, 0x61, 0x35, 0x38, 0x33, 0x37, 0x32, 0x65, 0x36, 0x33, 0x39, 0x34, 0x30, 0x31, 0x63, 0x36, 0x64, 0x66, 0x34, 0x36, 0x37, 0x39, 0x64, 0x32, 0x31, 0x66, 0x63, 0x61, 0x35, 0x32, 0x65, 0x65, 0x66, 0x32, 0x34, 0x65, 0x30, 0x64, 0x64, 0x66, 0x33, 0x38, 0x30, 0x36, 0x34, 0x32, 0x66, 0x31, 0x63, 0x63, 0x33, 0x36, 0x35, 0x36, 0x66, 0x31, 0x31, 0x30, 0x65, 0x37, 0x38, 0x37, 0x61, 0x32, 0x36, 0x65, 0x64, 0x35, 0x36, 0x33, 0x36, 0x61, 0x34, 0x65, 0x30, 0x66, 0x61, 0x35, 0x32, 0x35, 0x39, 0x37, 0x33, 0x31, 0x35, 0x36, 0x32, 0x31, 0x61, 0x33, 0x63, 0x32, 0x35, 0x33, 0x39, 0x64, 0x33, 0x37, 0x62, 0x32, 0x62, 0x36, 0x38, 0x62, 0x39, 0x63, 0x31, 0x34, 0x36, 0x65, 0x35, 0x32, 0x39, 0x35, 0x63, 0x36, 0x30, 0x64, 0x61, 0x30, 0x33, 0x64, 0x37, 0x61, 0x30, 0x62, 0x31, 0x66, 0x32, 0x34, 0x33, 0x37, 0x32, 0x36, 0x61, 0x64, 0x32, 0x36, 0x37, 0x33, 0x30, 0x61, 0x30, 0x35, 0x38, 0x66, 0x38, 0x37, 0x63, 0x32, 0x65, 0x39, 0x62, 0x39, 0x33, 0x64, 0x31, 0x62, 0x33, 0x37, 0x32, 0x38, 0x63, 0x64, 0x32, 0x31, 0x31, 0x37, 0x65, 0x64, 0x38, 0x66, 0x35, 0x63, 0x61, 0x63, 0x33, 0x66, 0x63, 0x66, 0x64, 0x33, 0x31, 0x64, 0x65, 0x61, 0x33, 0x66, 0x38, 0x34, 0x36, 0x33, 0x65, 0x66, 0x64, 0x66, 0x37, 0x37, 0x32, 0x39, 0x32, 0x34, 0x34, 0x62, 0x36, 0x39, 0x31, 0x63, 0x37, 0x63, 0x63, 0x38, 0x64, 0x31, 0x65, 0x39, 0x33, 0x34, 0x39, 0x37, 0x61, 0x35, 0x63, 0x30, 0x37, 0x66, 0x39, 0x30, 0x62, 0x64, 0x62, 0x33, 0x36, 0x65, 0x39, 0x39, 0x37, 0x63, 0x31, 0x36, 0x63, 0x62, 0x30, 0x38, 0x33, 0x35, 0x31, 0x37, 0x61, 0x64, 0x31, 0x30, 0x65, 0x66, 0x32, 0x37, 0x32, 0x63, 0x61, 0x61, 0x39, 0x31, 0x31, 0x35, 0x37, 0x31, 0x31, 0x34, 0x35, 0x38, 0x33, 0x64, 0x33, 0x30, 0x35, 0x35, 0x38, 0x62, 0x66, 0x62, 0x66, 0x39, 0x66, 0x64, 0x35, 0x66, 0x32, 0x63, 0x35, 0x62, 0x35, 0x62, 0x63, 0x30, 0x33, 0x33, 0x61, 0x30, 0x66, 0x64, 0x36, 0x66, 0x66, 0x37, 0x35, 0x32, 0x63, 0x38, 0x32, 0x32, 0x63, 0x62, 0x66, 0x39, 0x32, 0x39, 0x64, 0x31, 0x65, 0x35, 0x62, 0x39, 0x62, 0x66, 0x33, 0x36, 0x36, 0x32, 0x39, 0x38, 0x30, 0x64, 0x61, 0x32, 0x61, 0x35, 0x63, 0x34, 0x62, 0x38, 0x30, 0x66, 0x32, 0x64, 0x62, 0x62, 0x39, 0x39, 0x39, 0x35, 0x31, 0x34, 0x64, 0x30, 0x33, 0x65, 0x36, 0x33, 0x63, 0x39, 0x39, 0x32, 0x35, 0x33, 0x38, 0x63, 0x34, 0x32, 0x64, 0x61, 0x36, 0x33, 0x31, 0x63, 0x32, 0x36, 0x63, 0x39, 0x36, 0x36, 0x65, 0x39, 0x38, 0x66, 0x37, 0x33, 0x37, 0x32, 0x61, 0x37, 0x32, 0x37, 0x62, 0x31, 0x66, 0x65, 0x37, 0x31, 0x30, 0x34, 0x65, 0x35, 0x39, 0x35, 0x36, 0x62, 0x64, 0x36, 0x35, 0x33, 0x62, 0x36, 0x61, 0x34, 0x31, 0x35, 0x32, 0x38, 0x39, 0x35, 0x63, 0x35, 0x62, 0x34, 0x36, 0x61, 0x65, 0x66, 0x38, 0x66, 0x61, 0x66, 0x37, 0x34, 0x30, 0x36, 0x63, 0x65, 0x64, 0x64, 0x65, 0x63, 0x65, 0x65, 0x61, 0x37, 0x38, 0x36, 0x38, 0x30, 0x36, 0x63, 0x65, 0x30, 0x35, 0x35, 0x33, 0x30, 0x66, 0x62, 0x66, 0x63, 0x62, 0x30, 0x66, 0x31, 0x38, 0x66, 0x32, 0x65, 0x39, 0x38, 0x38, 0x39, 0x37, 0x66, 0x64, 0x36, 0x32, 0x30, 0x30, 0x65, 0x38, 0x31, 0x39, 0x66, 0x38, 0x36, 0x35, 0x65, 0x39, 0x31, 0x30, 0x63, 0x31, 0x31, 0x66, 0x37, 0x66, 0x36, 0x62, 0x66, 0x39, 0x33, 0x36, 0x62, 0x39, 0x36, 0x62, 0x30, 0x64, 0x37, 0x66, 0x31, 0x37, 0x31, 0x39, 0x37, 0x32, 0x66, 0x65, 0x32, 0x33, 0x64, 0x34, 0x39, 0x35, 0x31, 0x64, 0x66, 0x30, 0x64, 0x31, 0x39, 0x36, 0x38, 0x39, 0x34, 0x30, 0x65, 0x39, 0x38, 0x38, 0x65, 0x66, 0x34, 0x63, 0x35, 0x31, 0x64, 0x38, 0x36, 0x30, 0x38, 0x66, 0x66, 0x35, 0x39, 0x63, 0x30, 0x37, 0x33, 0x36, 0x32, 0x61, 0x63, 0x31, 0x64, 0x38, 0x32, 0x65, 0x35, 0x38, 0x36, 0x64, 0x62, 0x61, 0x65, 0x38, 0x38, 0x31, 0x37, 0x32, 0x37, 0x32, 0x39, 0x30, 0x31, 0x61, 0x35, 0x61, 0x63, 0x62, 0x39, 0x30, 0x36, 0x61, 0x38, 0x32, 0x37, 0x65, 0x61, 0x35, 0x66, 0x32, 0x30, 0x35, 0x30, 0x37, 0x38, 0x63, 0x37, 0x35, 0x34, 0x62, 0x35, 0x63, 0x39, 0x63, 0x36, 0x62, 0x30, 0x63, 0x35, 0x64, 0x39, 0x33, 0x66, 0x62, 0x38, 0x66, 0x61, 0x37, 0x65, 0x30, 0x31, 0x66, 0x36, 0x39, 0x64, 0x33, 0x66, 0x63, 0x66, 0x39, 0x36, 0x32, 0x37, 0x64, 0x64, 0x33, 0x65, 0x32, 0x65, 0x34, 0x34, 0x35, 0x64, 0x62, 0x33, 0x32, 0x65, 0x66, 0x35, 0x62, 0x62, 0x35, 0x64, 0x62, 0x64, 0x36, 0x30, 0x37, 0x38, 0x32, 0x31, 0x62, 0x32, 0x66, 0x38, 0x36, 0x36, 0x65, 0x35, 0x33, 0x62, 0x38, 0x63, 0x31, 0x31, 0x39, 0x63, 0x62, 0x35, 0x30, 0x39, 0x37, 0x33, 0x38, 0x37, 0x37, 0x32, 0x39, 0x32, 0x36, 0x37, 0x66, 0x32, 0x34, 0x32, 0x32, 0x66, 0x32, 0x62, 0x66, 0x38, 0x63, 0x35, 0x39, 0x32, 0x32, 0x39, 0x31, 0x63, 0x37, 0x65, 0x38, 0x37, 0x31, 0x33, 0x35, 0x64, 0x39, 0x65, 0x34, 0x31, 0x63, 0x32, 0x35, 0x61, 0x30, 0x63, 0x30, 0x31, 0x39, 0x36, 0x64, 0x35, 0x31, 0x37, 0x65, 0x34, 0x66, 0x31, 0x37, 0x31, 0x62, 0x32, 0x35, 0x62, 0x62, 0x63, 0x36, 0x62, 0x61, 0x32, 0x36, 0x66, 0x38, 0x39, 0x33, 0x32, 0x38, 0x37, 0x32, 0x34, 0x61, 0x62, 0x63, 0x32, 0x65, 0x37, 0x61, 0x39, 0x63, 0x30, 0x39, 0x31, 0x31, 0x37, 0x30, 0x62, 0x31, 0x66, 0x30, 0x61, 0x62, 0x39, 0x61, 0x33, 0x30, 0x35, 0x66, 0x31, 0x63, 0x32, 0x63, 0x38, 0x35, 0x36, 0x62, 0x66, 0x65, 0x64, 0x37, 0x65, 0x66, 0x31, 0x64, 0x63, 0x36, 0x38, 0x34, 0x66, 0x35, 0x37, 0x64, 0x65, 0x34, 0x61, 0x63, 0x34, 0x66, 0x34, 0x33, 0x34, 0x34, 0x37, 0x32, 0x62, 0x64, 0x64, 0x37, 0x34, 0x35, 0x35, 0x32, 0x35, 0x62, 0x64, 0x65, 0x62, 0x62, 0x30, 0x66, 0x37, 0x66, 0x62, 0x65, 0x63, 0x62, 0x66, 0x63, 0x61, 0x61, 0x37, 0x30, 0x38, 0x33, 0x65, 0x32, 0x38, 0x36, 0x31, 0x35, 0x61, 0x33, 0x36, 0x61, 0x33, 0x66, 0x33, 0x31, 0x31, 0x34, 0x38, 0x63, 0x63, 0x64, 0x31, 0x63, 0x64, 0x61, 0x33, 0x31, 0x36, 0x36, 0x35, 0x63, 0x64, 0x34, 0x37, 0x32, 0x38, 0x62, 0x66, 0x35, 0x33, 0x37, 0x36, 0x33, 0x38, 0x37, 0x37, 0x32, 0x66, 0x64, 0x38, 0x66, 0x36, 0x65, 0x38, 0x65, 0x64, 0x66, 0x32, 0x66, 0x64, 0x63, 0x32, 0x30, 0x63, 0x36, 0x63, 0x33, 0x63, 0x30, 0x32, 0x63, 0x61, 0x66, 0x31, 0x36, 0x36, 0x63, 0x30, 0x65, 0x36, 0x32, 0x66, 0x61, 0x35, 0x36, 0x31, 0x62, 0x34, 0x35, 0x30, 0x36, 0x37, 0x33, 0x37, 0x36, 0x39, 0x32, 0x34, 0x36, 0x37, 0x31, 0x63, 0x62, 0x61, 0x32, 0x35, 0x35, 0x36, 0x34, 0x32, 0x63, 0x63, 0x30, 0x36, 0x31, 0x33, 0x31, 0x64, 0x34, 0x30, 0x33, 0x30, 0x39, 0x35, 0x35, 0x33, 0x36, 0x31, 0x62, 0x38, 0x39, 0x65, 0x62, 0x64, 0x64, 0x63, 0x62, 0x62, 0x31, 0x64, 0x34, 0x32, 0x35, 0x30, 0x62, 0x35, 0x61, 0x35, 0x63, 0x35, 0x31, 0x61, 0x37, 0x32, 0x63, 0x63, 0x64, 0x31, 0x33, 0x39, 0x33, 0x37, 0x32, 0x33, 0x64, 0x34, 0x65, 0x63, 0x33, 0x32, 0x62, 0x38, 0x38, 0x31, 0x34, 0x34, 0x31, 0x62, 0x66, 0x66, 0x33, 0x66, 0x64, 0x39, 0x37, 0x35, 0x65, 0x62, 0x35, 0x32, 0x65, 0x36, 0x31, 0x65, 0x37, 0x37, 0x64, 0x37, 0x63, 0x65, 0x38, 0x34, 0x31, 0x63, 0x30, 0x30, 0x34, 0x39, 0x65, 0x66, 0x37, 0x30, 0x33, 0x63, 0x39, 0x64, 0x63, 0x63, 0x32, 0x61, 0x38, 0x32, 0x37, 0x64, 0x39, 0x37, 0x32, 0x35, 0x33, 0x32, 0x62, 0x61, 0x36, 0x36, 0x64, 0x36, 0x34, 0x39, 0x31, 0x39, 0x37, 0x37, 0x39, 0x36, 0x31, 0x33, 0x65, 0x39, 0x38, 0x37, 0x39, 0x63, 0x38, 0x32, 0x37, 0x35, 0x63, 0x62, 0x36, 0x66, 0x62, 0x65, 0x66, 0x32, 0x39, 0x66, 0x31, 0x62, 0x39, 0x30, 0x65, 0x35, 0x39, 0x66, 0x63, 0x32, 0x37, 0x38, 0x35, 0x62, 0x63, 0x63, 0x66, 0x38, 0x37, 0x65, 0x62, 0x62, 0x38, 0x37, 0x32, 0x35, 0x66, 0x62, 0x61, 0x65, 0x33, 0x61, 0x66, 0x34, 0x66, 0x33, 0x62, 0x36, 0x30, 0x64, 0x63, 0x32, 0x33, 0x32, 0x62, 0x31, 0x32, 0x32, 0x65, 0x62, 0x32, 0x32, 0x66, 0x37, 0x66, 0x63, 0x31, 0x65, 0x32, 0x64, 0x38, 0x34, 0x31, 0x61, 0x34, 0x65, 0x39, 0x38, 0x38, 0x66, 0x39, 0x34, 0x37, 0x31, 0x31, 0x37, 0x66, 0x66, 0x31, 0x66, 0x37, 0x36, 0x36, 0x36, 0x31, 0x37, 0x64, 0x37, 0x32, 0x33, 0x32, 0x64, 0x65, 0x32, 0x33, 0x33, 0x62, 0x37, 0x36, 0x34, 0x37, 0x38, 0x30, 0x37, 0x30, 0x65, 0x33, 0x34, 0x34, 0x62, 0x66, 0x30, 0x30, 0x38, 0x66, 0x34, 0x36, 0x61, 0x33, 0x63, 0x37, 0x33, 0x33, 0x63, 0x35, 0x34, 0x63, 0x33, 0x62, 0x31, 0x32, 0x66, 0x30, 0x36, 0x31, 0x33, 0x30, 0x64, 0x31, 0x38, 0x34, 0x62, 0x61, 0x38, 0x39, 0x34, 0x65, 0x39, 0x37, 0x66, 0x32, 0x36, 0x64, 0x65, 0x61, 0x62, 0x31, 0x32, 0x33, 0x64, 0x34, 0x32, 0x62, 0x62, 0x62, 0x36, 0x34, 0x33, 0x30, 0x66, 0x65, 0x30, 0x61, 0x31, 0x31, 0x35, 0x30, 0x31, 0x30, 0x64, 0x36, 0x61, 0x39, 0x34, 0x66, 0x62, 0x65, 0x39, 0x39, 0x64, 0x39, 0x35, 0x64, 0x62, 0x32, 0x32, 0x36, 0x33, 0x66, 0x63, 0x39, 0x66, 0x34, 0x32, 0x66, 0x32, 0x32, 0x62, 0x35, 0x32, 0x33, 0x36, 0x34, 0x34, 0x36, 0x37, 0x32, 0x39, 0x66, 0x63, 0x37, 0x37, 0x66, 0x30, 0x32, 0x64, 0x39, 0x31, 0x65, 0x30, 0x38, 0x35, 0x30, 0x32, 0x35, 0x31, 0x64, 0x35, 0x39, 0x66, 0x63, 0x32, 0x30, 0x34, 0x38, 0x35, 0x32, 0x65, 0x66, 0x64, 0x32, 0x36, 0x34, 0x63, 0x61, 0x30, 0x65, 0x30, 0x64, 0x62, 0x63, 0x66, 0x30, 0x61, 0x62, 0x62, 0x36, 0x39, 0x32, 0x32, 0x63, 0x61, 0x31, 0x62, 0x38, 0x32, 0x62, 0x63, 0x32, 0x37, 0x32, 0x34, 0x34, 0x39, 0x31, 0x35, 0x61, 0x65, 0x62, 0x33, 0x64, 0x64, 0x35, 0x65, 0x62, 0x61, 0x36, 0x35, 0x36, 0x64, 0x63, 0x66, 0x35, 0x34, 0x36, 0x38, 0x32, 0x64, 0x37, 0x65, 0x63, 0x32, 0x65, 0x61, 0x63, 0x34, 0x64, 0x31, 0x32, 0x32, 0x63, 0x65, 0x33, 0x32, 0x62, 0x62, 0x32, 0x36, 0x33, 0x30, 0x31, 0x34, 0x35, 0x65, 0x35, 0x39, 0x61, 0x31, 0x34, 0x35, 0x37, 0x66, 0x33, 0x35, 0x38, 0x37, 0x37, 0x66, 0x63, 0x39, 0x62, 0x32, 0x33, 0x37, 0x34, 0x34, 0x31, 0x39, 0x31, 0x35, 0x32, 0x66, 0x37, 0x30, 0x64, 0x35, 0x35, 0x39, 0x61, 0x35, 0x66, 0x39, 0x31, 0x39, 0x66, 0x38, 0x62, 0x61, 0x35, 0x38, 0x66, 0x38, 0x65, 0x34, 0x35, 0x39, 0x65, 0x33, 0x38, 0x31, 0x34, 0x65, 0x65, 0x64, 0x64, 0x39, 0x30, 0x30, 0x32, 0x38, 0x65, 0x36, 0x31, 0x35, 0x66, 0x36, 0x38, 0x32, 0x61, 0x30, 0x35, 0x39, 0x32, 0x36, 0x36, 0x63, 0x62, 0x39, 0x30, 0x66, 0x34, 0x39, 0x34, 0x37, 0x33, 0x62, 0x31, 0x39, 0x35, 0x37, 0x34, 0x30, 0x33, 0x64, 0x35, 0x63, 0x34, 0x62, 0x36, 0x35, 0x36, 0x36, 0x33, 0x30, 0x32, 0x31, 0x34, 0x31, 0x32, 0x65, 0x61, 0x34, 0x36, 0x65, 0x31, 0x64, 0x31, 0x61, 0x64, 0x61, 0x30, 0x36, 0x30, 0x62, 0x62, 0x66, 0x64, 0x30, 0x39, 0x62, 0x66, 0x37, 0x32, 0x34, 0x62, 0x32, 0x33, 0x35, 0x30, 0x65, 0x35, 0x33, 0x63, 0x66, 0x32, 0x64, 0x64, 0x31, 0x32, 0x62, 0x63, 0x61, 0x34, 0x33, 0x61, 0x64, 0x62, 0x33, 0x65, 0x37, 0x39, 0x38, 0x36, 0x38, 0x31, 0x37, 0x38, 0x64, 0x30, 0x35, 0x37, 0x32, 0x31, 0x64, 0x32, 0x37, 0x32, 0x35, 0x62, 0x62, 0x63, 0x38, 0x65, 0x30, 0x35, 0x33, 0x33, 0x39, 0x63, 0x33, 0x31, 0x33, 0x38, 0x30, 0x33, 0x37, 0x32, 0x38, 0x34, 0x30, 0x61, 0x63, 0x38, 0x66, 0x31, 0x63, 0x64, 0x39, 0x64, 0x34, 0x34, 0x34, 0x36, 0x64, 0x38, 0x34, 0x31, 0x36, 0x64, 0x35, 0x39, 0x65, 0x30, 0x66, 0x66, 0x63, 0x64, 0x39, 0x38, 0x62, 0x65, 0x65, 0x38, 0x38, 0x63, 0x63, 0x37, 0x39, 0x30, 0x39, 0x37, 0x32, 0x39, 0x34, 0x62, 0x34, 0x38, 0x37, 0x37, 0x32, 0x62, 0x34, 0x62, 0x36, 0x61, 0x65, 0x61, 0x32, 0x33, 0x36, 0x62, 0x33, 0x38, 0x62, 0x36, 0x61, 0x62, 0x62, 0x61, 0x39, 0x39, 0x38, 0x33, 0x37, 0x38, 0x34, 0x37, 0x61, 0x39, 0x62, 0x63, 0x39, 0x64, 0x62, 0x35, 0x65, 0x34, 0x65, 0x66, 0x34, 0x33, 0x39, 0x63, 0x38, 0x61, 0x30, 0x61, 0x31, 0x63, 0x36, 0x32, 0x36, 0x37, 0x66, 0x33, 0x39, 0x32, 0x39, 0x33, 0x37, 0x39, 0x64, 0x37, 0x62, 0x37, 0x31, 0x64, 0x39, 0x33, 0x39, 0x64, 0x63, 0x61, 0x37, 0x32, 0x39, 0x61, 0x35, 0x65, 0x35, 0x34, 0x32, 0x33, 0x33, 0x37, 0x32, 0x31, 0x63, 0x36, 0x63, 0x39, 0x61, 0x37, 0x30, 0x35, 0x37, 0x65, 0x30, 0x30, 0x66, 0x33, 0x39, 0x31, 0x61, 0x33, 0x65, 0x30, 0x65, 0x38, 0x34, 0x36, 0x32, 0x36, 0x65, 0x35, 0x30, 0x37, 0x39, 0x38, 0x37, 0x32, 0x66, 0x33, 0x35, 0x37, 0x31, 0x62, 0x38, 0x37, 0x38, 0x39, 0x65, 0x33, 0x34, 0x61, 0x66, 0x31, 0x37, 0x32, 0x32, 0x39, 0x34, 0x34, 0x32, 0x36, 0x30, 0x62, 0x36, 0x63, 0x64, 0x65, 0x35, 0x34, 0x34, 0x37, 0x31, 0x31, 0x35, 0x62, 0x63, 0x66, 0x32, 0x34, 0x66, 0x66, 0x36, 0x30, 0x61, 0x37, 0x36, 0x37, 0x37, 0x33, 0x30, 0x33, 0x30, 0x34, 0x38, 0x33, 0x32, 0x36, 0x62, 0x64, 0x34, 0x63, 0x61, 0x39, 0x33, 0x61, 0x30, 0x64, 0x37, 0x38, 0x31, 0x39, 0x38, 0x65, 0x65, 0x62, 0x36, 0x31, 0x37, 0x32, 0x32, 0x36, 0x36, 0x66, 0x61, 0x66, 0x63, 0x32, 0x39, 0x65, 0x66, 0x37, 0x66, 0x34, 0x36, 0x32, 0x66, 0x66, 0x37, 0x64, 0x35, 0x33, 0x61, 0x32, 0x34, 0x66, 0x61, 0x61, 0x31, 0x31, 0x61, 0x32, 0x33, 0x31, 0x64, 0x37, 0x32, 0x33, 0x64, 0x38, 0x66, 0x36, 0x37, 0x62, 0x61, 0x39, 0x38, 0x38, 0x62, 0x31, 0x64, 0x37, 0x35, 0x39, 0x35, 0x33, 0x62, 0x39, 0x35, 0x38, 0x37, 0x38, 0x37, 0x32, 0x37, 0x30, 0x32, 0x35, 0x35, 0x61, 0x32, 0x62, 0x33, 0x63, 0x62, 0x35, 0x30, 0x61, 0x36, 0x31, 0x37, 0x34, 0x64, 0x66, 0x32, 0x65, 0x37, 0x66, 0x38, 0x31, 0x34, 0x38, 0x30, 0x66, 0x33, 0x37, 0x64, 0x61, 0x65, 0x64, 0x30, 0x31, 0x64, 0x39, 0x66, 0x39, 0x31, 0x38, 0x35, 0x32, 0x62, 0x63, 0x65, 0x64, 0x65, 0x38, 0x61, 0x34, 0x30, 0x31, 0x39, 0x62, 0x39, 0x63, 0x32, 0x38, 0x37, 0x32, 0x64, 0x30, 0x38, 0x36, 0x39, 0x31, 0x35, 0x32, 0x32, 0x31, 0x66, 0x63, 0x37, 0x62, 0x39, 0x65, 0x33, 0x61, 0x35, 0x39, 0x31, 0x62, 0x30, 0x32, 0x39, 0x31, 0x64, 0x38, 0x37, 0x36, 0x31, 0x36, 0x33, 0x61, 0x39, 0x31, 0x36, 0x30, 0x33, 0x30, 0x35, 0x66, 0x61, 0x61, 0x64, 0x38, 0x32, 0x38, 0x63, 0x32, 0x33, 0x36, 0x63, 0x66, 0x64, 0x39, 0x30, 0x65, 0x31, 0x37, 0x66, 0x33, 0x36, 0x32, 0x31, 0x31, 0x63, 0x34, 0x33, 0x33, 0x36, 0x38, 0x38, 0x38, 0x34, 0x32, 0x30, 0x37, 0x66, 0x39, 0x37, 0x66, 0x65, 0x33, 0x33, 0x63, 0x62, 0x62, 0x66, 0x65, 0x61, 0x32, 0x66, 0x37, 0x35, 0x37, 0x38, 0x63, 0x38, 0x37, 0x35, 0x38, 0x39, 0x39, 0x35, 0x31, 0x65, 0x37, 0x62, 0x62, 0x39, 0x63, 0x62, 0x33, 0x31, 0x36, 0x37, 0x32, 0x31, 0x62, 0x61, 0x37, 0x35, 0x33, 0x31, 0x36, 0x35, 0x33, 0x64, 0x35, 0x34, 0x62, 0x33, 0x62, 0x38, 0x64, 0x35, 0x65, 0x62, 0x63, 0x39, 0x35, 0x61, 0x35, 0x65, 0x37, 0x30, 0x66, 0x34, 0x31, 0x61, 0x31, 0x31, 0x32, 0x39, 0x64, 0x31, 0x30, 0x38, 0x34, 0x30, 0x30, 0x32, 0x66, 0x33, 0x38, 0x35, 0x63, 0x63, 0x32, 0x34, 0x65, 0x35, 0x63, 0x62, 0x38, 0x62, 0x63, 0x62, 0x65, 0x61, 0x31, 0x33, 0x62, 0x34, 0x36, 0x62, 0x38, 0x65, 0x31, 0x33, 0x32, 0x35, 0x63, 0x61, 0x37, 0x32, 0x32, 0x62, 0x31, 0x32, 0x37, 0x39, 0x36, 0x64, 0x35, 0x61, 0x64, 0x38, 0x36, 0x61, 0x33, 0x61, 0x34, 0x33, 0x38, 0x34, 0x31, 0x35, 0x61, 0x32, 0x39, 0x36, 0x34, 0x63, 0x32, 0x33, 0x39, 0x66, 0x34, 0x33, 0x34, 0x38, 0x34, 0x38, 0x32, 0x39, 0x37, 0x37, 0x33, 0x63, 0x31, 0x39, 0x36, 0x32, 0x31, 0x32, 0x33, 0x66, 0x62, 0x37, 0x32, 0x35, 0x37, 0x37, 0x32, 0x35, 0x31, 0x37, 0x64, 0x64, 0x61, 0x65, 0x63, 0x32, 0x30, 0x36, 0x39, 0x36, 0x37, 0x61, 0x63, 0x64, 0x32, 0x63, 0x32, 0x35, 0x34, 0x38, 0x31, 0x31, 0x30, 0x63, 0x35, 0x39, 0x64, 0x64, 0x65, 0x62, 0x64, 0x62, 0x63, 0x32, 0x32, 0x30, 0x61, 0x62, 0x32, 0x36, 0x65, 0x33, 0x66, 0x34, 0x64, 0x36, 0x66, 0x34, 0x32, 0x30, 0x62, 0x65, 0x61, 0x30, 0x33, 0x37, 0x64, 0x65, 0x31, 0x32, 0x36, 0x36, 0x61, 0x66, 0x31, 0x64, 0x61, 0x34, 0x62, 0x35, 0x32, 0x64, 0x61, 0x30, 0x65, 0x30, 0x66, 0x38, 0x38, 0x35, 0x37, 0x66, 0x32, 0x33, 0x39, 0x32, 0x32, 0x31, 0x66, 0x33, 0x35, 0x65, 0x33, 0x34, 0x31, 0x61, 0x39, 0x62, 0x63, 0x62, 0x31, 0x34, 0x31, 0x65, 0x37, 0x63, 0x35, 0x33, 0x37, 0x35, 0x30, 0x31, 0x65, 0x33, 0x63, 0x36, 0x39, 0x33, 0x61, 0x31, 0x31, 0x30, 0x65, 0x31, 0x30, 0x34, 0x31, 0x64, 0x32, 0x38, 0x37, 0x61, 0x64, 0x32, 0x66, 0x64, 0x32, 0x32, 0x66, 0x65, 0x35, 0x63, 0x37, 0x31, 0x65, 0x38, 0x62, 0x30, 0x33, 0x33, 0x31, 0x32, 0x32, 0x66, 0x31, 0x30, 0x38, 0x39, 0x30, 0x62, 0x38, 0x62, 0x62, 0x34, 0x63, 0x37, 0x62, 0x33, 0x33, 0x34, 0x35, 0x62, 0x62, 0x39, 0x31, 0x35, 0x65, 0x35, 0x31, 0x66, 0x66, 0x62, 0x36, 0x66, 0x32, 0x65, 0x38, 0x35, 0x36, 0x30, 0x61, 0x62, 0x30, 0x62, 0x31, 0x65, 0x66, 0x30, 0x61, 0x35, 0x35, 0x32, 0x31, 0x35, 0x38, 0x66, 0x65, 0x62, 0x33, 0x39, 0x33, 0x37, 0x30, 0x34, 0x39, 0x61, 0x65, 0x36, 0x63, 0x61, 0x64, 0x34, 0x34, 0x38, 0x36, 0x64, 0x32, 0x64, 0x32, 0x63, 0x61, 0x32, 0x66, 0x31, 0x64, 0x30, 0x31, 0x30, 0x61, 0x62, 0x32, 0x66, 0x38, 0x39, 0x63, 0x65, 0x65, 0x32, 0x38, 0x62, 0x35, 0x30, 0x66, 0x34, 0x35, 0x65, 0x34, 0x33, 0x38, 0x35, 0x35, 0x33, 0x66, 0x33, 0x66, 0x63, 0x33, 0x62, 0x30, 0x39, 0x37, 0x37, 0x30, 0x30, 0x64, 0x63, 0x37, 0x34, 0x39, 0x37, 0x38, 0x31, 0x61, 0x37, 0x30, 0x32, 0x31, 0x32, 0x64, 0x66, 0x65, 0x66, 0x36, 0x38, 0x36, 0x65, 0x34, 0x38, 0x39, 0x63, 0x37, 0x66, 0x65, 0x66, 0x62, 0x38, 0x34, 0x31, 0x34, 0x64, 0x62, 0x33, 0x32, 0x63, 0x37, 0x37, 0x32, 0x64, 0x32, 0x37, 0x33, 0x39, 0x34, 0x30, 0x62, 0x36, 0x34, 0x61, 0x65, 0x61, 0x38, 0x32, 0x37, 0x63, 0x63, 0x65, 0x33, 0x32, 0x36, 0x30, 0x33, 0x61, 0x66, 0x33, 0x30, 0x65, 0x35, 0x38, 0x31, 0x63, 0x34, 0x35, 0x31, 0x33, 0x64, 0x30, 0x35, 0x61, 0x65, 0x33, 0x38, 0x34, 0x34, 0x33, 0x62, 0x63, 0x64, 0x32, 0x38, 0x39, 0x63, 0x64, 0x39, 0x35, 0x34, 0x32, 0x33, 0x34, 0x30, 0x37, 0x32, 0x62, 0x65, 0x30, 0x32, 0x66, 0x31, 0x31, 0x38, 0x34, 0x64, 0x64, 0x31, 0x36, 0x62, 0x38, 0x37, 0x31, 0x66, 0x30, 0x33, 0x31, 0x30, 0x35, 0x33, 0x31, 0x32, 0x33, 0x65, 0x62, 0x64, 0x39, 0x34, 0x36, 0x35, 0x61, 0x65, 0x64, 0x32, 0x61, 0x31, 0x35, 0x61, 0x36, 0x65, 0x30, 0x63, 0x30, 0x33, 0x39, 0x38, 0x36, 0x64, 0x31, 0x32, 0x65, 0x65, 0x35, 0x37, 0x33, 0x30, 0x30, 0x38, 0x30, 0x31, 0x37, 0x39, 0x32, 0x31, 0x35, 0x31, 0x32, 0x62, 0x30, 0x32, 0x33, 0x63, 0x37, 0x66, 0x30, 0x66, 0x63, 0x32, 0x36, 0x36, 0x62, 0x66, 0x36, 0x34, 0x33, 0x39, 0x37, 0x30, 0x38, 0x39, 0x33, 0x63, 0x33, 0x39, 0x65, 0x34, 0x31, 0x31, 0x61, 0x35, 0x30, 0x65, 0x62, 0x66, 0x30, 0x36, 0x33, 0x63, 0x39, 0x35, 0x35, 0x63, 0x36, 0x39, 0x33, 0x38, 0x36, 0x66, 0x37, 0x32, 0x38, 0x63, 0x37, 0x32, 0x33, 0x30, 0x36, 0x65, 0x33, 0x30, 0x32, 0x37, 0x37, 0x30, 0x37, 0x32, 0x34, 0x36, 0x65, 0x66, 0x36, 0x63, 0x66, 0x62, 0x65, 0x32, 0x38, 0x33, 0x66, 0x37, 0x38, 0x36, 0x31, 0x37, 0x38, 0x36, 0x66, 0x35, 0x38, 0x61, 0x39, 0x61, 0x34, 0x39, 0x34, 0x61, 0x61, 0x65, 0x66, 0x63, 0x61, 0x36, 0x61, 0x30, 0x34, 0x64, 0x31, 0x61, 0x30, 0x66, 0x39, 0x66, 0x31, 0x39, 0x63, 0x30, 0x37, 0x32, 0x37, 0x62, 0x37, 0x31, 0x38, 0x61, 0x39, 0x32, 0x61, 0x37, 0x33, 0x65, 0x38, 0x33, 0x31, 0x34, 0x35, 0x37, 0x35, 0x64, 0x37, 0x36, 0x30, 0x61, 0x64, 0x32, 0x65, 0x30, 0x38, 0x39, 0x31, 0x65, 0x39, 0x38, 0x32, 0x31, 0x36, 0x37, 0x32, 0x35, 0x64, 0x33, 0x34, 0x31, 0x62, 0x63, 0x63, 0x66, 0x65, 0x32, 0x33, 0x33, 0x30, 0x65, 0x37, 0x61, 0x30, 0x32, 0x35, 0x32, 0x62, 0x31, 0x30, 0x30, 0x64, 0x37, 0x37, 0x64, 0x38, 0x63, 0x34, 0x66, 0x36, 0x37, 0x35, 0x35, 0x33, 0x39, 0x31, 0x61, 0x65, 0x35, 0x66, 0x64, 0x66, 0x66, 0x63, 0x36, 0x65, 0x65, 0x34, 0x37, 0x37, 0x35, 0x37, 0x32, 0x37, 0x31, 0x64, 0x66, 0x30, 0x33, 0x36, 0x64, 0x39, 0x65, 0x62, 0x37, 0x33, 0x62, 0x35, 0x37, 0x64, 0x62, 0x66, 0x34, 0x31, 0x30, 0x31, 0x30, 0x33, 0x63, 0x38, 0x32, 0x30, 0x37, 0x37, 0x32, 0x39, 0x39, 0x31, 0x63, 0x34, 0x64, 0x34, 0x33, 0x63, 0x39, 0x34, 0x31, 0x30, 0x37, 0x63, 0x30, 0x36, 0x39, 0x37, 0x33, 0x65, 0x33, 0x32, 0x30, 0x36, 0x30, 0x64, 0x62, 0x65, 0x39, 0x30, 0x36, 0x39, 0x39, 0x63, 0x36, 0x36, 0x61, 0x63, 0x65, 0x64, 0x31, 0x64, 0x66, 0x37, 0x65, 0x39, 0x33, 0x33, 0x61, 0x37, 0x35, 0x36, 0x39, 0x31, 0x66, 0x61, 0x61, 0x62, 0x36, 0x39, 0x36, 0x37, 0x32, 0x33, 0x38, 0x31, 0x34, 0x65, 0x61, 0x66, 0x63, 0x65, 0x34, 0x37, 0x39, 0x36, 0x64, 0x35, 0x39, 0x39, 0x36, 0x38, 0x31, 0x36, 0x62, 0x34, 0x32, 0x37, 0x65, 0x66, 0x66, 0x37, 0x37, 0x39, 0x61, 0x66, 0x61, 0x36, 0x38, 0x36, 0x64, 0x62, 0x30, 0x34, 0x62, 0x63, 0x33, 0x31, 0x34, 0x36, 0x62, 0x31, 0x31, 0x62, 0x65, 0x62, 0x32, 0x33, 0x30, 0x36, 0x63, 0x34, 0x38, 0x66, 0x65, 0x30, 0x63, 0x63, 0x32, 0x39, 0x34, 0x33, 0x39, 0x66, 0x38, 0x63, 0x63, 0x38, 0x32, 0x30, 0x34, 0x66, 0x63, 0x31, 0x39, 0x33, 0x35, 0x34, 0x32, 0x35, 0x30, 0x31, 0x66, 0x66, 0x63, 0x64, 0x34, 0x64, 0x30, 0x31, 0x30, 0x33, 0x36, 0x62, 0x66, 0x34, 0x65, 0x31, 0x63, 0x35, 0x34, 0x63, 0x39, 0x63, 0x66, 0x34, 0x35, 0x31, 0x34, 0x33, 0x64, 0x62, 0x66, 0x34, 0x62, 0x35, 0x64, 0x35, 0x33, 0x37, 0x32, 0x35, 0x64, 0x38, 0x61, 0x66, 0x37, 0x32, 0x37, 0x62, 0x64, 0x35, 0x32, 0x36, 0x36, 0x33, 0x61, 0x63, 0x32, 0x31, 0x63, 0x31, 0x36, 0x61, 0x33, 0x63, 0x61, 0x63, 0x66, 0x30, 0x61, 0x66, 0x63, 0x63, 0x37, 0x64, 0x31, 0x30, 0x36, 0x37, 0x31, 0x62, 0x36, 0x63, 0x38, 0x63, 0x30, 0x66, 0x31, 0x35, 0x63, 0x30, 0x63, 0x32, 0x35, 0x33, 0x37, 0x64, 0x37, 0x31, 0x34, 0x30, 0x31, 0x37, 0x32, 0x35, 0x33, 0x66, 0x34, 0x39, 0x37, 0x65, 0x34, 0x32, 0x65, 0x65, 0x33, 0x65, 0x62, 0x35, 0x39, 0x39, 0x64, 0x63, 0x36, 0x36, 0x33, 0x36, 0x31, 0x37, 0x63, 0x37, 0x66, 0x39, 0x62, 0x37, 0x36, 0x65, 0x38, 0x61, 0x39, 0x38, 0x65, 0x61, 0x39, 0x35, 0x37, 0x30, 0x32, 0x39, 0x39, 0x63, 0x62, 0x34, 0x33, 0x35, 0x66, 0x34, 0x31, 0x35, 0x30, 0x32, 0x33, 0x35, 0x37, 0x31, 0x61, 0x37, 0x32, 0x37, 0x65, 0x63, 0x66, 0x61, 0x64, 0x35, 0x33, 0x33, 0x37, 0x39, 0x34, 0x39, 0x66, 0x34, 0x65, 0x34, 0x31, 0x31, 0x63, 0x39, 0x38, 0x38, 0x65, 0x33, 0x33, 0x37, 0x33, 0x32, 0x30, 0x65, 0x34, 0x39, 0x34, 0x39, 0x31, 0x62, 0x64, 0x37, 0x34, 0x35, 0x30, 0x30, 0x61, 0x34, 0x32, 0x63, 0x63, 0x38, 0x65, 0x65, 0x32, 0x31, 0x39, 0x35, 0x39, 0x39, 0x36, 0x32, 0x34, 0x63, 0x62, 0x33, 0x35, 0x66, 0x63, 0x30, 0x64, 0x36, 0x32, 0x37, 0x38, 0x64, 0x63, 0x35, 0x31, 0x61, 0x37, 0x38, 0x39, 0x63, 0x30, 0x37, 0x33, 0x61, 0x33, 0x66, 0x66, 0x62, 0x31, 0x66, 0x36, 0x65, 0x63, 0x64, 0x61, 0x65, 0x62, 0x63, 0x61, 0x38, 0x32, 0x61, 0x66, 0x34, 0x38, 0x36, 0x66, 0x66, 0x37, 0x39, 0x32, 0x65, 0x61, 0x30, 0x37, 0x61, 0x37, 0x66, 0x66, 0x35, 0x30, 0x61, 0x63, 0x64, 0x34, 0x37, 0x32, 0x63, 0x30, 0x62, 0x39, 0x34, 0x66, 0x30, 0x63, 0x37, 0x32, 0x36, 0x65, 0x35, 0x38, 0x33, 0x32, 0x30, 0x34, 0x32, 0x62, 0x61, 0x61, 0x32, 0x63, 0x37, 0x61, 0x30, 0x65, 0x63, 0x37, 0x30, 0x37, 0x65, 0x62, 0x63, 0x38, 0x64, 0x34, 0x66, 0x62, 0x37, 0x66, 0x31, 0x66, 0x30, 0x62, 0x64, 0x63, 0x66, 0x64, 0x30, 0x64, 0x38, 0x38, 0x63, 0x62, 0x34, 0x61, 0x63, 0x32, 0x31, 0x35, 0x35, 0x39, 0x65, 0x33, 0x34, 0x30, 0x32, 0x33, 0x31, 0x36, 0x33, 0x39, 0x66, 0x37, 0x32, 0x61, 0x32, 0x30, 0x62, 0x33, 0x65, 0x38, 0x31, 0x35, 0x39, 0x61, 0x64, 0x30, 0x36, 0x66, 0x32, 0x62, 0x31, 0x30, 0x33, 0x35, 0x32, 0x34, 0x38, 0x34, 0x30, 0x35, 0x33, 0x62, 0x35, 0x65, 0x35, 0x64, 0x33, 0x61, 0x64, 0x33, 0x32, 0x31, 0x33, 0x39, 0x33, 0x63, 0x39, 0x33, 0x39, 0x32, 0x66, 0x61, 0x37, 0x32, 0x35, 0x39, 0x37, 0x35, 0x31, 0x65, 0x62, 0x38, 0x30, 0x37, 0x38, 0x61, 0x62, 0x30, 0x38, 0x34, 0x39, 0x62, 0x36, 0x31, 0x32, 0x37, 0x30, 0x63, 0x62, 0x35, 0x65, 0x63, 0x64, 0x64, 0x35, 0x36, 0x31, 0x64, 0x30, 0x64, 0x62, 0x33, 0x38, 0x36, 0x64, 0x31, 0x33, 0x36, 0x32, 0x39, 0x38, 0x31, 0x35, 0x31, 0x36, 0x63, 0x61, 0x62, 0x38, 0x33, 0x30, 0x35, 0x66, 0x66, 0x35, 0x38, 0x32, 0x65, 0x65, 0x33, 0x39, 0x61, 0x36, 0x64, 0x32, 0x32, 0x64, 0x62, 0x65, 0x35, 0x63, 0x30, 0x66, 0x61, 0x65, 0x30, 0x63, 0x34, 0x34, 0x62, 0x66, 0x33, 0x66, 0x32, 0x30, 0x34, 0x38, 0x33, 0x30, 0x37, 0x63, 0x31, 0x37, 0x62, 0x64, 0x31, 0x34, 0x39, 0x66, 0x63, 0x65, 0x65, 0x66, 0x33, 0x34, 0x30, 0x62, 0x33, 0x37, 0x37, 0x65, 0x37, 0x62, 0x65, 0x34, 0x64, 0x38, 0x38, 0x63, 0x33, 0x30, 0x61, 0x66, 0x64, 0x32, 0x33, 0x64, 0x31, 0x64, 0x39, 0x35, 0x66, 0x35, 0x34, 0x37, 0x34, 0x63, 0x39, 0x66, 0x31, 0x61, 0x66, 0x62, 0x65, 0x66, 0x66, 0x31, 0x64, 0x30, 0x61, 0x63, 0x36, 0x38, 0x62, 0x35, 0x39, 0x36, 0x61, 0x39, 0x35, 0x63, 0x63, 0x35, 0x34, 0x35, 0x65, 0x38, 0x39, 0x35, 0x62, 0x32, 0x38, 0x36, 0x31, 0x30, 0x66, 0x36, 0x33, 0x63, 0x62, 0x34, 0x36, 0x31, 0x62, 0x37, 0x32, 0x62, 0x63, 0x33, 0x38, 0x37, 0x63, 0x62, 0x30, 0x65, 0x35, 0x39, 0x32, 0x31, 0x32, 0x35, 0x63, 0x38, 0x35, 0x36, 0x62, 0x66, 0x35, 0x32, 0x35, 0x62, 0x34, 0x39, 0x62, 0x33, 0x36, 0x37, 0x66, 0x61, 0x38, 0x63, 0x30, 0x66, 0x39, 0x61, 0x62, 0x31, 0x35, 0x30, 0x65, 0x64, 0x61, 0x32, 0x39, 0x36, 0x33, 0x62, 0x39, 0x63, 0x64, 0x64, 0x34, 0x63, 0x62, 0x33, 0x32, 0x62, 0x65, 0x37, 0x32, 0x62, 0x39, 0x30, 0x36, 0x66, 0x39, 0x62, 0x36, 0x30, 0x39, 0x62, 0x61, 0x33, 0x65, 0x30, 0x37, 0x36, 0x32, 0x35, 0x64, 0x66, 0x37, 0x32, 0x61, 0x30, 0x36, 0x64, 0x30, 0x32, 0x65, 0x33, 0x36, 0x38, 0x30, 0x35, 0x66, 0x37, 0x30, 0x35, 0x39, 0x63, 0x63, 0x31, 0x36, 0x37, 0x39, 0x63, 0x31, 0x37, 0x38, 0x39, 0x35, 0x34, 0x35, 0x66, 0x38, 0x39, 0x33, 0x64, 0x61, 0x30, 0x36, 0x37, 0x32, 0x38, 0x61, 0x66, 0x33, 0x31, 0x31, 0x35, 0x66, 0x34, 0x61, 0x32, 0x61, 0x62, 0x36, 0x61, 0x39, 0x33, 0x38, 0x31, 0x34, 0x34, 0x30, 0x65, 0x64, 0x33, 0x39, 0x35, 0x62, 0x30, 0x61, 0x64, 0x37, 0x61, 0x30, 0x34, 0x66, 0x38, 0x37, 0x34, 0x61, 0x38, 0x34, 0x31, 0x33, 0x30, 0x32, 0x30, 0x66, 0x30, 0x33, 0x61, 0x63, 0x66, 0x34, 0x62, 0x62, 0x39, 0x38, 0x34, 0x37, 0x36, 0x63, 0x37, 0x32, 0x30, 0x37, 0x66, 0x35, 0x64, 0x32, 0x36, 0x37, 0x63, 0x63, 0x62, 0x66, 0x64, 0x33, 0x35, 0x62, 0x30, 0x39, 0x36, 0x31, 0x64, 0x36, 0x35, 0x35, 0x65, 0x63, 0x36, 0x34, 0x64, 0x64, 0x62, 0x34, 0x66, 0x37, 0x63, 0x33, 0x31, 0x64, 0x37, 0x61, 0x31, 0x38, 0x62, 0x61, 0x38, 0x66, 0x66, 0x61, 0x34, 0x62, 0x31, 0x31, 0x62, 0x38, 0x63, 0x33, 0x32, 0x39, 0x31, 0x34, 0x38, 0x64, 0x33, 0x61, 0x30, 0x31, 0x39, 0x37, 0x33, 0x35, 0x34, 0x39, 0x32, 0x62, 0x39, 0x38, 0x62, 0x39, 0x34, 0x65, 0x61, 0x62, 0x39, 0x32, 0x36, 0x34, 0x39, 0x32, 0x63, 0x30, 0x35, 0x30, 0x31, 0x38, 0x63, 0x63, 0x36, 0x37, 0x65, 0x38, 0x39, 0x39, 0x36, 0x65, 0x35, 0x33, 0x38, 0x62, 0x32, 0x63, 0x66, 0x36, 0x66, 0x38, 0x32, 0x64, 0x64, 0x37, 0x61, 0x64, 0x33, 0x30, 0x66, 0x63, 0x39, 0x37, 0x34, 0x64, 0x61, 0x33, 0x35, 0x36, 0x36, 0x34, 0x36, 0x35, 0x63, 0x39, 0x63, 0x31, 0x62, 0x61, 0x37, 0x33, 0x31, 0x36, 0x61, 0x61, 0x64, 0x36, 0x39, 0x66, 0x37, 0x34, 0x62, 0x30, 0x61, 0x65, 0x61, 0x35, 0x36, 0x65, 0x36, 0x30, 0x35, 0x65, 0x61, 0x32, 0x66, 0x61, 0x33, 0x61, 0x31, 0x36, 0x37, 0x38, 0x65, 0x32, 0x65, 0x35, 0x39, 0x62, 0x61, 0x39, 0x39, 0x37, 0x66, 0x63, 0x35, 0x64, 0x30, 0x37, 0x63, 0x33, 0x65, 0x31, 0x31, 0x35, 0x61, 0x31, 0x37, 0x36, 0x35, 0x64, 0x38, 0x30, 0x30, 0x63, 0x66, 0x31, 0x61, 0x39, 0x35, 0x33, 0x66, 0x30, 0x38, 0x38, 0x64, 0x36, 0x64, 0x62, 0x33, 0x30, 0x31, 0x63, 0x37, 0x38, 0x65, 0x61, 0x64, 0x37, 0x31, 0x34, 0x33, 0x34, 0x65, 0x61, 0x33, 0x62, 0x37, 0x64, 0x65, 0x61, 0x34, 0x61, 0x34, 0x37, 0x34, 0x36, 0x62, 0x62, 0x63, 0x30, 0x37, 0x32, 0x30, 0x36, 0x61, 0x33, 0x30, 0x36, 0x35, 0x61, 0x63, 0x61, 0x35, 0x66, 0x33, 0x64, 0x31, 0x66, 0x61, 0x64, 0x65, 0x64, 0x64, 0x64, 0x31, 0x65, 0x37, 0x65, 0x31, 0x63, 0x37, 0x37, 0x62, 0x38, 0x38, 0x63, 0x62, 0x30, 0x31, 0x32, 0x34, 0x66, 0x61, 0x66, 0x62, 0x64, 0x33, 0x32, 0x66, 0x32, 0x35, 0x35, 0x36, 0x32, 0x62, 0x32, 0x66, 0x61, 0x39, 0x35, 0x61, 0x34, 0x39, 0x35, 0x35, 0x31, 0x38, 0x35, 0x38, 0x39, 0x64, 0x64, 0x64, 0x34, 0x65, 0x30, 0x34, 0x34, 0x65, 0x37, 0x39, 0x63, 0x63, 0x38, 0x64, 0x38, 0x64, 0x34, 0x61, 0x63, 0x37, 0x66, 0x34, 0x30, 0x66, 0x33, 0x30, 0x65, 0x34, 0x36, 0x35, 0x62, 0x32, 0x35, 0x34, 0x35, 0x36, 0x33, 0x34, 0x61, 0x31, 0x64, 0x62, 0x36, 0x30, 0x64, 0x37, 0x39, 0x61, 0x31, 0x62, 0x32, 0x66, 0x34, 0x37, 0x62, 0x61, 0x33, 0x37, 0x32, 0x32, 0x63, 0x66, 0x31, 0x63, 0x30, 0x34, 0x64, 0x63, 0x64, 0x32, 0x38, 0x61, 0x64, 0x35, 0x37, 0x30, 0x64, 0x37, 0x31, 0x65, 0x30, 0x31, 0x62, 0x35, 0x37, 0x38, 0x30, 0x30, 0x35, 0x39, 0x38, 0x34, 0x31, 0x64, 0x37, 0x36, 0x62, 0x62, 0x66, 0x36, 0x38, 0x37, 0x65, 0x35, 0x35, 0x31, 0x35, 0x37, 0x39, 0x34, 0x63, 0x34, 0x64, 0x35, 0x32, 0x66, 0x33, 0x65, 0x65, 0x32, 0x32, 0x31, 0x39, 0x65, 0x33, 0x39, 0x37, 0x38, 0x63, 0x39, 0x38, 0x65, 0x31, 0x31, 0x30, 0x33, 0x66, 0x31, 0x35, 0x63, 0x65, 0x33, 0x36, 0x63, 0x34, 0x36, 0x65, 0x34, 0x61, 0x36, 0x33, 0x66, 0x66, 0x61, 0x62, 0x39, 0x61, 0x61, 0x66, 0x34, 0x30, 0x38, 0x65, 0x66, 0x30, 0x30, 0x66, 0x66, 0x64, 0x36, 0x39, 0x39, 0x33, 0x32, 0x62, 0x64, 0x62, 0x35, 0x32, 0x38, 0x33, 0x65, 0x63, 0x39, 0x33, 0x30, 0x33, 0x63, 0x62, 0x38, 0x31, 0x30, 0x64, 0x32, 0x37, 0x35, 0x65, 0x65, 0x62, 0x38, 0x61, 0x63, 0x34, 0x64, 0x61, 0x34, 0x36, 0x65, 0x39, 0x39, 0x32, 0x30, 0x62, 0x61, 0x31, 0x39, 0x38, 0x34, 0x36, 0x30, 0x36, 0x37, 0x36, 0x62, 0x62, 0x34, 0x64, 0x65, 0x32, 0x61, 0x33, 0x61, 0x61, 0x39, 0x39, 0x37, 0x64, 0x34, 0x64, 0x36, 0x64, 0x65, 0x33, 0x38, 0x35, 0x34, 0x62, 0x38, 0x39, 0x37, 0x32, 0x38, 0x62, 0x64, 0x36, 0x35, 0x65, 0x61, 0x65, 0x37, 0x31, 0x37, 0x36, 0x38, 0x39, 0x66, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x34, 0x35, 0x35, 0x35, 0x62, 0x62, 0x30, 0x32, 0x30, 0x32, 0x35, 0x63, 0x35, 0x36, 0x31, 0x33, 0x64, 0x39, 0x33, 0x32, 0x30, 0x33, 0x34, 0x32, 0x37, 0x65, 0x66, 0x36, 0x35, 0x33, 0x31, 0x30, 0x30, 0x34, 0x61, 0x32, 0x62, 0x37, 0x32, 0x33, 0x64, 0x31, 0x63, 0x38, 0x33, 0x65, 0x65, 0x31, 0x65, 0x62, 0x37, 0x32, 0x35, 0x32, 0x34, 0x61, 0x31, 0x39, 0x30, 0x30, 0x36, 0x38, 0x61, 0x36, 0x32, 0x31, 0x64, 0x63, 0x35, 0x64, 0x33, 0x34, 0x62, 0x33, 0x62, 0x61, 0x38, 0x36, 0x63, 0x35, 0x61, 0x36, 0x64, 0x31, 0x62, 0x66, 0x61, 0x38, 0x61, 0x61, 0x62, 0x65, 0x63, 0x37, 0x36, 0x61, 0x32, 0x32, 0x35, 0x37, 0x64, 0x62, 0x34, 0x66, 0x37, 0x33, 0x62, 0x30, 0x65, 0x62, 0x36, 0x65, 0x37, 0x31, 0x31, 0x39, 0x31, 0x62, 0x64, 0x32, 0x32, 0x37, 0x31, 0x34, 0x31, 0x66, 0x64, 0x36, 0x31, 0x66, 0x30, 0x66, 0x35, 0x35, 0x61, 0x62, 0x65, 0x32, 0x61, 0x37, 0x37, 0x65, 0x32, 0x30, 0x30, 0x65, 0x66, 0x63, 0x35, 0x37, 0x36, 0x61, 0x61, 0x38, 0x36, 0x63, 0x61, 0x62, 0x34, 0x39, 0x34, 0x34, 0x35, 0x36, 0x30, 0x64, 0x62, 0x66, 0x30, 0x37, 0x32, 0x39, 0x34, 0x34, 0x32, 0x35, 0x33, 0x62, 0x35, 0x32, 0x31, 0x30, 0x64, 0x66, 0x34, 0x36, 0x32, 0x35, 0x36, 0x32, 0x32, 0x37, 0x31, 0x39, 0x31, 0x65, 0x36, 0x61, 0x31, 0x35, 0x31, 0x35, 0x35, 0x30, 0x37, 0x33, 0x31, 0x64, 0x63, 0x39, 0x34, 0x36, 0x64, 0x39, 0x36, 0x37, 0x62, 0x64, 0x34, 0x31, 0x34, 0x35, 0x38, 0x37, 0x34, 0x38, 0x63, 0x61, 0x61, 0x61, 0x65, 0x64, 0x32, 0x37, 0x32, 0x66, 0x37, 0x61, 0x61, 0x39, 0x65, 0x36, 0x38, 0x35, 0x34, 0x65, 0x62, 0x65, 0x35, 0x39, 0x38, 0x62, 0x38, 0x32, 0x39, 0x61, 0x65, 0x33, 0x65, 0x63, 0x34, 0x31, 0x39, 0x37, 0x66, 0x30, 0x31, 0x64, 0x36, 0x30, 0x36, 0x61, 0x33, 0x62, 0x61, 0x34, 0x61, 0x64, 0x37, 0x62, 0x61, 0x63, 0x63, 0x34, 0x64, 0x38, 0x37, 0x36, 0x30, 0x38, 0x32, 0x66, 0x65, 0x64, 0x64, 0x61, 0x66, 0x35, 0x30, 0x61, 0x33, 0x33, 0x36, 0x38, 0x33, 0x33, 0x66, 0x38, 0x36, 0x34, 0x65, 0x65, 0x32, 0x30, 0x61, 0x33, 0x35, 0x64, 0x64, 0x35, 0x31, 0x37, 0x32, 0x64, 0x38, 0x34, 0x32, 0x64, 0x39, 0x66, 0x38, 0x33, 0x30, 0x63, 0x66, 0x35, 0x37, 0x64, 0x62, 0x39, 0x32, 0x38, 0x30, 0x36, 0x65, 0x38, 0x62, 0x31, 0x36, 0x63, 0x61, 0x34, 0x62, 0x35, 0x37, 0x61, 0x37, 0x35, 0x35, 0x30, 0x30, 0x30, 0x62, 0x30, 0x31, 0x32, 0x32, 0x35, 0x31, 0x34, 0x36, 0x64, 0x34, 0x63, 0x37, 0x33, 0x66, 0x36, 0x65, 0x38, 0x65, 0x64, 0x65, 0x61, 0x38, 0x36, 0x38, 0x38, 0x38, 0x63, 0x64, 0x65, 0x37, 0x38, 0x30, 0x32, 0x38, 0x36, 0x38, 0x39, 0x33, 0x31, 0x65, 0x66, 0x62, 0x33, 0x38, 0x39, 0x39, 0x61, 0x37, 0x35, 0x66, 0x62, 0x37, 0x34, 0x64, 0x33, 0x61, 0x33, 0x62, 0x38, 0x62, 0x37, 0x36, 0x37, 0x32, 0x62, 0x36, 0x64, 0x61, 0x38, 0x36, 0x34, 0x62, 0x66, 0x61, 0x39, 0x38, 0x30, 0x36, 0x64, 0x64, 0x32, 0x35, 0x32, 0x31, 0x33, 0x30, 0x39, 0x64, 0x33, 0x39, 0x63, 0x62, 0x34, 0x38, 0x35, 0x38, 0x36, 0x31, 0x37, 0x34, 0x33, 0x66, 0x63, 0x31, 0x62, 0x66, 0x62, 0x32, 0x38, 0x66, 0x38, 0x62, 0x37, 0x63, 0x37, 0x37, 0x65, 0x35, 0x38, 0x38, 0x63, 0x38, 0x38, 0x66, 0x34, 0x62, 0x35, 0x63, 0x35, 0x39, 0x63, 0x30, 0x33, 0x66, 0x65, 0x61, 0x35, 0x64, 0x36, 0x62, 0x34, 0x64, 0x35, 0x32, 0x65, 0x39, 0x33, 0x62, 0x35, 0x39, 0x65, 0x63, 0x63, 0x35, 0x38, 0x36, 0x61, 0x30, 0x33, 0x32, 0x63, 0x33, 0x37, 0x34, 0x35, 0x30, 0x30, 0x66, 0x38, 0x32, 0x31, 0x31, 0x31, 0x35, 0x62, 0x64, 0x32, 0x37, 0x39, 0x66, 0x35, 0x61, 0x31, 0x37, 0x62, 0x31, 0x35, 0x32, 0x66, 0x36, 0x30, 0x33, 0x30, 0x39, 0x39, 0x36, 0x37, 0x34, 0x34, 0x36, 0x32, 0x31, 0x39, 0x31, 0x64, 0x38, 0x38, 0x33, 0x38, 0x64, 0x32, 0x61, 0x39, 0x37, 0x34, 0x39, 0x65, 0x61, 0x32, 0x36, 0x62, 0x65, 0x35, 0x65, 0x66, 0x64, 0x61, 0x65, 0x38, 0x66, 0x65, 0x38, 0x65, 0x32, 0x35, 0x33, 0x31, 0x38, 0x38, 0x30, 0x30, 0x34, 0x35, 0x65, 0x61, 0x31, 0x63, 0x61, 0x34, 0x64, 0x31, 0x39, 0x33, 0x64, 0x37, 0x32, 0x35, 0x39, 0x34, 0x32, 0x64, 0x30, 0x35, 0x37, 0x34, 0x64, 0x62, 0x61, 0x65, 0x36, 0x31, 0x30, 0x31, 0x30, 0x39, 0x32, 0x38, 0x62, 0x33, 0x64, 0x34, 0x63, 0x34, 0x36, 0x35, 0x32, 0x39, 0x61, 0x31, 0x39, 0x33, 0x30, 0x32, 0x36, 0x65, 0x65, 0x37, 0x61, 0x62, 0x39, 0x32, 0x63, 0x66, 0x35, 0x36, 0x36, 0x31, 0x38, 0x36, 0x61, 0x63, 0x64, 0x31, 0x66, 0x34, 0x32, 0x61, 0x66, 0x37, 0x32, 0x32, 0x65, 0x37, 0x62, 0x30, 0x34, 0x39, 0x37, 0x31, 0x33, 0x63, 0x36, 0x35, 0x37, 0x32, 0x66, 0x38, 0x37, 0x61, 0x30, 0x63, 0x36, 0x66, 0x61, 0x65, 0x36, 0x32, 0x34, 0x37, 0x34, 0x38, 0x35, 0x61, 0x31, 0x64, 0x31, 0x36, 0x38, 0x65, 0x30, 0x61, 0x64, 0x36, 0x66, 0x32, 0x65, 0x32, 0x36, 0x34, 0x65, 0x65, 0x31, 0x38, 0x38, 0x65, 0x38, 0x37, 0x30, 0x38, 0x36, 0x66, 0x30, 0x32, 0x65, 0x66, 0x61, 0x38, 0x38, 0x31, 0x64, 0x37, 0x31, 0x62, 0x31, 0x35, 0x39, 0x64, 0x37, 0x66, 0x31, 0x37, 0x37, 0x35, 0x30, 0x65, 0x39, 0x64, 0x32, 0x31, 0x39, 0x36, 0x64, 0x31, 0x31, 0x32, 0x32, 0x39, 0x37, 0x37, 0x39, 0x65, 0x63, 0x36, 0x65, 0x36, 0x33, 0x61, 0x36, 0x31, 0x63, 0x34, 0x64, 0x39, 0x34, 0x32, 0x38, 0x33, 0x63, 0x31, 0x30, 0x34, 0x65, 0x36, 0x61, 0x39, 0x30, 0x35, 0x65, 0x39, 0x31, 0x66, 0x65, 0x66, 0x30, 0x63, 0x64, 0x35, 0x62, 0x61, 0x36, 0x34, 0x64, 0x37, 0x36, 0x61, 0x39, 0x39, 0x33, 0x34, 0x36, 0x31, 0x34, 0x38, 0x38, 0x62, 0x62, 0x36, 0x31, 0x33, 0x32, 0x63, 0x39, 0x64, 0x33, 0x63, 0x30, 0x64, 0x66, 0x64, 0x38, 0x61, 0x65, 0x33, 0x62, 0x35, 0x35, 0x37, 0x33, 0x37, 0x30, 0x33, 0x32, 0x39, 0x30, 0x62, 0x37, 0x38, 0x32, 0x65, 0x39, 0x31, 0x35, 0x63, 0x61, 0x32, 0x33, 0x38, 0x31, 0x66, 0x66, 0x65, 0x64, 0x32, 0x35, 0x61, 0x64, 0x62, 0x37, 0x35, 0x35, 0x61, 0x32, 0x64, 0x65, 0x65, 0x61, 0x34, 0x64, 0x66, 0x30, 0x39, 0x35, 0x38, 0x36, 0x35, 0x62, 0x31, 0x63, 0x33, 0x34, 0x36, 0x39, 0x39, 0x32, 0x30, 0x31, 0x39, 0x37, 0x32, 0x61, 0x63, 0x35, 0x32, 0x36, 0x36, 0x63, 0x33, 0x63, 0x33, 0x38, 0x34, 0x64, 0x35, 0x61, 0x37, 0x32, 0x63, 0x66, 0x62, 0x30, 0x66, 0x62, 0x34, 0x32, 0x37, 0x31, 0x61, 0x34, 0x35, 0x65, 0x30, 0x31, 0x64, 0x31, 0x30, 0x64, 0x63, 0x66, 0x37, 0x37, 0x65, 0x32, 0x65, 0x30, 0x31, 0x35, 0x61, 0x65, 0x65, 0x63, 0x35, 0x30, 0x38, 0x34, 0x39, 0x66, 0x37, 0x66, 0x65, 0x63, 0x66, 0x33, 0x61, 0x66, 0x39, 0x64, 0x63, 0x35, 0x37, 0x64, 0x37, 0x66, 0x63, 0x37, 0x64, 0x66, 0x33, 0x30, 0x32, 0x66, 0x34, 0x39, 0x35, 0x35, 0x62, 0x38, 0x63, 0x32, 0x33, 0x30, 0x61, 0x39, 0x61, 0x39, 0x38, 0x63, 0x31, 0x62, 0x38, 0x38, 0x32, 0x31, 0x65, 0x66, 0x65, 0x62, 0x65, 0x38, 0x66, 0x37, 0x63, 0x32, 0x66, 0x32, 0x35, 0x32, 0x65, 0x35, 0x32, 0x38, 0x38, 0x39, 0x39, 0x39, 0x36, 0x66, 0x37, 0x38, 0x38, 0x64, 0x30, 0x30, 0x62, 0x66, 0x65, 0x34, 0x64, 0x64, 0x62, 0x31, 0x62, 0x39, 0x33, 0x31, 0x61, 0x66, 0x32, 0x35, 0x61, 0x65, 0x30, 0x62, 0x61, 0x36, 0x35, 0x36, 0x35, 0x34, 0x64, 0x64, 0x33, 0x33, 0x65, 0x33, 0x32, 0x36, 0x35, 0x34, 0x32, 0x63, 0x61, 0x63, 0x39, 0x62, 0x34, 0x36, 0x31, 0x33, 0x35, 0x31, 0x31, 0x62, 0x62, 0x36, 0x30, 0x30, 0x32, 0x66, 0x63, 0x34, 0x37, 0x31, 0x64, 0x64, 0x35, 0x37, 0x30, 0x38, 0x35, 0x66, 0x36, 0x37, 0x38, 0x65, 0x34, 0x37, 0x33, 0x34, 0x32, 0x61, 0x31, 0x36, 0x64, 0x37, 0x64, 0x36, 0x35, 0x30, 0x65, 0x62, 0x32, 0x36, 0x30, 0x63, 0x36, 0x37, 0x33, 0x61, 0x34, 0x31, 0x65, 0x35, 0x34, 0x32, 0x39, 0x31, 0x65, 0x66, 0x30, 0x62, 0x36, 0x61, 0x65, 0x32, 0x34, 0x33, 0x34, 0x30, 0x61, 0x36, 0x38, 0x39, 0x37, 0x63, 0x37, 0x64, 0x37, 0x30, 0x66, 0x39, 0x65, 0x66, 0x61, 0x65, 0x37, 0x30, 0x35, 0x66, 0x36, 0x61, 0x37, 0x32, 0x61, 0x30, 0x63, 0x35, 0x63, 0x36, 0x32, 0x61, 0x66, 0x35, 0x62, 0x62, 0x33, 0x31, 0x32, 0x61, 0x39, 0x38, 0x38, 0x64, 0x35, 0x35, 0x30, 0x39, 0x61, 0x36, 0x34, 0x62, 0x64, 0x64, 0x34, 0x64, 0x64, 0x63, 0x39, 0x34, 0x33, 0x66, 0x38, 0x32, 0x35, 0x32, 0x34, 0x37, 0x61, 0x38, 0x31, 0x32, 0x36, 0x30, 0x31, 0x64, 0x64, 0x66, 0x32, 0x63, 0x63, 0x33, 0x33, 0x37, 0x64, 0x62, 0x37, 0x32, 0x65, 0x36, 0x66, 0x35, 0x35, 0x37, 0x39, 0x64, 0x35, 0x32, 0x31, 0x31, 0x34, 0x64, 0x61, 0x64, 0x34, 0x37, 0x33, 0x64, 0x61, 0x33, 0x36, 0x34, 0x61, 0x32, 0x64, 0x31, 0x38, 0x35, 0x34, 0x66, 0x31, 0x34, 0x34, 0x66, 0x34, 0x66, 0x65, 0x61, 0x38, 0x65, 0x34, 0x35, 0x63, 0x37, 0x33, 0x38, 0x62, 0x66, 0x30, 0x65, 0x39, 0x30, 0x31, 0x65, 0x63, 0x65, 0x31, 0x31, 0x66, 0x30, 0x37, 0x32, 0x39, 0x34, 0x39, 0x39, 0x39, 0x62, 0x32, 0x30, 0x39, 0x38, 0x34, 0x36, 0x31, 0x33, 0x32, 0x30, 0x64, 0x34, 0x33, 0x61, 0x34, 0x35, 0x35, 0x66, 0x39, 0x38, 0x66, 0x37, 0x66, 0x64, 0x62, 0x35, 0x30, 0x61, 0x38, 0x37, 0x37, 0x64, 0x66, 0x65, 0x62, 0x33, 0x37, 0x36, 0x35, 0x33, 0x35, 0x65, 0x65, 0x33, 0x38, 0x35, 0x35, 0x63, 0x64, 0x32, 0x34, 0x38, 0x62, 0x62, 0x63, 0x64, 0x37, 0x31, 0x34, 0x61, 0x30, 0x65, 0x33, 0x30, 0x63, 0x31, 0x33, 0x63, 0x34, 0x30, 0x63, 0x39, 0x64, 0x31, 0x61, 0x39, 0x33, 0x32, 0x33, 0x64, 0x62, 0x36, 0x64, 0x63, 0x33, 0x30, 0x37, 0x31, 0x36, 0x32, 0x65, 0x61, 0x62, 0x61, 0x66, 0x39, 0x39, 0x36, 0x37, 0x37, 0x35, 0x34, 0x62, 0x32, 0x38, 0x30, 0x61, 0x33, 0x31, 0x65, 0x33, 0x33, 0x63, 0x39, 0x35, 0x64, 0x65, 0x36, 0x30, 0x33, 0x37, 0x32, 0x38, 0x30, 0x61, 0x63, 0x36, 0x32, 0x30, 0x66, 0x37, 0x33, 0x31, 0x30, 0x32, 0x32, 0x65, 0x30, 0x64, 0x39, 0x62, 0x37, 0x62, 0x33, 0x61, 0x66, 0x34, 0x64, 0x63, 0x38, 0x62, 0x37, 0x64, 0x36, 0x37, 0x34, 0x66, 0x64, 0x62, 0x37, 0x65, 0x65, 0x65, 0x62, 0x37, 0x61, 0x33, 0x61, 0x33, 0x36, 0x64, 0x30, 0x63, 0x65, 0x39, 0x66, 0x62, 0x66, 0x35, 0x61, 0x39, 0x61, 0x34, 0x32, 0x36, 0x64, 0x64, 0x64, 0x36, 0x31, 0x34, 0x64, 0x33, 0x66, 0x36, 0x62, 0x65, 0x65, 0x31, 0x63, 0x64, 0x34, 0x35, 0x31, 0x38, 0x36, 0x37, 0x32, 0x63, 0x64, 0x37, 0x63, 0x30, 0x31, 0x66, 0x37, 0x30, 0x38, 0x64, 0x61, 0x37, 0x35, 0x66, 0x64, 0x66, 0x35, 0x36, 0x64, 0x35, 0x34, 0x66, 0x31, 0x61, 0x36, 0x37, 0x30, 0x39, 0x63, 0x35, 0x32, 0x39, 0x38, 0x66, 0x31, 0x32, 0x38, 0x61, 0x32, 0x37, 0x32, 0x61, 0x65, 0x31, 0x39, 0x30, 0x65, 0x30, 0x62, 0x30, 0x36, 0x34, 0x34, 0x65, 0x30, 0x34, 0x31, 0x30, 0x36, 0x35, 0x34, 0x64, 0x34, 0x39, 0x65, 0x31, 0x62, 0x34, 0x66, 0x62, 0x65, 0x36, 0x63, 0x32, 0x34, 0x36, 0x30, 0x63, 0x31, 0x32, 0x62, 0x35, 0x61, 0x31, 0x65, 0x66, 0x39, 0x63, 0x65, 0x63, 0x37, 0x33, 0x30, 0x32, 0x31, 0x31, 0x38, 0x37, 0x31, 0x61, 0x34, 0x64, 0x35, 0x37, 0x32, 0x30, 0x63, 0x62, 0x38, 0x65, 0x39, 0x63, 0x37, 0x32, 0x62, 0x39, 0x31, 0x30, 0x39, 0x36, 0x63, 0x65, 0x65, 0x39, 0x36, 0x38, 0x35, 0x62, 0x63, 0x64, 0x30, 0x63, 0x33, 0x34, 0x62, 0x34, 0x63, 0x39, 0x65, 0x32, 0x36, 0x39, 0x35, 0x64, 0x63, 0x64, 0x64, 0x63, 0x39, 0x32, 0x35, 0x65, 0x30, 0x38, 0x37, 0x63, 0x64, 0x34, 0x34, 0x36, 0x33, 0x37, 0x31, 0x61, 0x65, 0x63, 0x30, 0x35, 0x36, 0x66, 0x63, 0x61, 0x39, 0x36, 0x33, 0x65, 0x66, 0x35, 0x32, 0x61, 0x34, 0x36, 0x30, 0x34, 0x37, 0x36, 0x63, 0x34, 0x32, 0x32, 0x66, 0x36, 0x34, 0x38, 0x61, 0x31, 0x39, 0x65, 0x62, 0x39, 0x37, 0x36, 0x35, 0x33, 0x39, 0x31, 0x62, 0x38, 0x39, 0x34, 0x36, 0x65, 0x65, 0x39, 0x63, 0x33, 0x34, 0x37, 0x34, 0x38, 0x36, 0x37, 0x34, 0x35, 0x64, 0x38, 0x63, 0x30, 0x37, 0x61, 0x37, 0x37, 0x32, 0x30, 0x39, 0x34, 0x33, 0x33, 0x63, 0x61, 0x34, 0x32, 0x36, 0x30, 0x35, 0x65, 0x33, 0x39, 0x36, 0x35, 0x39, 0x38, 0x65, 0x33, 0x63, 0x37, 0x66, 0x35, 0x62, 0x31, 0x37, 0x33, 0x61, 0x30, 0x38, 0x35, 0x32, 0x66, 0x32, 0x36, 0x62, 0x33, 0x62, 0x65, 0x62, 0x64, 0x65, 0x31, 0x36, 0x65, 0x38, 0x32, 0x34, 0x34, 0x39, 0x39, 0x33, 0x34, 0x37, 0x33, 0x38, 0x61, 0x32, 0x63, 0x37, 0x37, 0x32, 0x66, 0x30, 0x30, 0x33, 0x33, 0x31, 0x38, 0x31, 0x37, 0x37, 0x66, 0x65, 0x38, 0x32, 0x32, 0x64, 0x31, 0x65, 0x62, 0x30, 0x32, 0x32, 0x62, 0x65, 0x31, 0x37, 0x38, 0x61, 0x30, 0x65, 0x61, 0x37, 0x30, 0x64, 0x63, 0x33, 0x33, 0x36, 0x31, 0x35, 0x31, 0x63, 0x31, 0x62, 0x30, 0x38, 0x38, 0x35, 0x62, 0x62, 0x39, 0x66, 0x32, 0x61, 0x32, 0x39, 0x30, 0x30, 0x39, 0x66, 0x65, 0x30, 0x37, 0x32, 0x38, 0x64, 0x31, 0x36, 0x37, 0x64, 0x37, 0x35, 0x32, 0x64, 0x64, 0x35, 0x36, 0x38, 0x39, 0x32, 0x34, 0x30, 0x38, 0x63, 0x65, 0x37, 0x65, 0x32, 0x65, 0x39, 0x65, 0x64, 0x38, 0x64, 0x66, 0x32, 0x62, 0x37, 0x64, 0x38, 0x65, 0x37, 0x30, 0x66, 0x64, 0x65, 0x34, 0x30, 0x33, 0x62, 0x33, 0x37, 0x35, 0x64, 0x30, 0x64, 0x38, 0x34, 0x63, 0x66, 0x64, 0x62, 0x66, 0x34, 0x64, 0x33, 0x33, 0x39, 0x36, 0x35, 0x64, 0x34, 0x37, 0x39, 0x62, 0x65, 0x30, 0x62, 0x30, 0x66, 0x39, 0x31, 0x34, 0x39, 0x66, 0x38, 0x64, 0x64, 0x64, 0x64, 0x62, 0x64, 0x36, 0x36, 0x37, 0x38, 0x63, 0x37, 0x62, 0x30, 0x30, 0x36, 0x38, 0x64, 0x30, 0x32, 0x63, 0x65, 0x30, 0x37, 0x33, 0x34, 0x36, 0x31, 0x65, 0x39, 0x61, 0x35, 0x39, 0x39, 0x39, 0x30, 0x36, 0x62, 0x66, 0x30, 0x37, 0x63, 0x66, 0x66, 0x32, 0x38, 0x34, 0x32, 0x66, 0x30, 0x64, 0x39, 0x64, 0x32, 0x39, 0x31, 0x62, 0x37, 0x34, 0x38, 0x61, 0x34, 0x37, 0x66, 0x62, 0x33, 0x38, 0x33, 0x63, 0x35, 0x33, 0x31, 0x37, 0x35, 0x39, 0x65, 0x36, 0x35, 0x66, 0x39, 0x32, 0x33, 0x64, 0x33, 0x64, 0x35, 0x62, 0x31, 0x33, 0x30, 0x33, 0x66, 0x32, 0x36, 0x34, 0x62, 0x34, 0x35, 0x61, 0x64, 0x36, 0x31, 0x39, 0x63, 0x31, 0x33, 0x36, 0x37, 0x37, 0x32, 0x38, 0x37, 0x37, 0x38, 0x31, 0x61, 0x34, 0x35, 0x62, 0x64, 0x61, 0x37, 0x33, 0x34, 0x32, 0x63, 0x63, 0x34, 0x38, 0x31, 0x33, 0x36, 0x62, 0x63, 0x66, 0x33, 0x36, 0x36, 0x35, 0x64, 0x38, 0x63, 0x62, 0x64, 0x38, 0x31, 0x38, 0x30, 0x35, 0x30, 0x64, 0x35, 0x65, 0x34, 0x32, 0x61, 0x31, 0x63, 0x32, 0x31, 0x30, 0x63, 0x32, 0x61, 0x65, 0x39, 0x30, 0x30, 0x64, 0x64, 0x39, 0x35, 0x37, 0x32, 0x35, 0x64, 0x61, 0x61, 0x61, 0x30, 0x62, 0x32, 0x33, 0x38, 0x38, 0x65, 0x66, 0x63, 0x65, 0x64, 0x61, 0x35, 0x33, 0x61, 0x39, 0x37, 0x64, 0x64, 0x32, 0x39, 0x63, 0x63, 0x32, 0x32, 0x62, 0x36, 0x30, 0x33, 0x34, 0x31, 0x39, 0x62, 0x36, 0x61, 0x30, 0x64, 0x31, 0x31, 0x37, 0x39, 0x65, 0x34, 0x64, 0x36, 0x31, 0x65, 0x39, 0x37, 0x62, 0x62, 0x39, 0x61, 0x31, 0x36, 0x65, 0x61, 0x37, 0x32, 0x65, 0x64, 0x65, 0x61, 0x38, 0x38, 0x62, 0x30, 0x61, 0x35, 0x39, 0x65, 0x32, 0x66, 0x35, 0x39, 0x38, 0x62, 0x32, 0x38, 0x33, 0x36, 0x39, 0x32, 0x37, 0x30, 0x64, 0x30, 0x34, 0x39, 0x31, 0x38, 0x64, 0x39, 0x30, 0x62, 0x33, 0x61, 0x61, 0x66, 0x62, 0x38, 0x31, 0x31, 0x35, 0x61, 0x35, 0x33, 0x35, 0x62, 0x33, 0x30, 0x32, 0x38, 0x39, 0x39, 0x36, 0x61, 0x65, 0x64, 0x35, 0x66, 0x33, 0x37, 0x34, 0x61, 0x38, 0x30, 0x65, 0x65, 0x65, 0x36, 0x33, 0x37, 0x32, 0x36, 0x65, 0x65, 0x66, 0x62, 0x64, 0x39, 0x37, 0x30, 0x63, 0x31, 0x62, 0x66, 0x30, 0x38, 0x65, 0x37, 0x33, 0x32, 0x34, 0x36, 0x63, 0x61, 0x30, 0x35, 0x39, 0x65, 0x30, 0x32, 0x61, 0x38, 0x38, 0x35, 0x30, 0x65, 0x66, 0x65, 0x64, 0x63, 0x34, 0x37, 0x36, 0x34, 0x64, 0x31, 0x33, 0x31, 0x66, 0x64, 0x33, 0x38, 0x37, 0x32, 0x65, 0x31, 0x34, 0x31, 0x36, 0x62, 0x35, 0x34, 0x35, 0x30, 0x65, 0x64, 0x30, 0x66, 0x32, 0x34, 0x36, 0x31, 0x61, 0x65, 0x35, 0x63, 0x34, 0x66, 0x65, 0x66, 0x36, 0x36, 0x65, 0x31, 0x66, 0x62, 0x63, 0x30, 0x36, 0x39, 0x63, 0x35, 0x35, 0x36, 0x37, 0x66, 0x35, 0x32, 0x63, 0x37, 0x65, 0x35, 0x36, 0x37, 0x64, 0x65, 0x66, 0x61, 0x34, 0x30, 0x33, 0x65, 0x33, 0x65, 0x30, 0x62, 0x37, 0x32, 0x32, 0x62, 0x33, 0x33, 0x64, 0x34, 0x63, 0x62, 0x31, 0x65, 0x35, 0x39, 0x38, 0x35, 0x30, 0x61, 0x63, 0x39, 0x35, 0x65, 0x33, 0x30, 0x65, 0x35, 0x34, 0x62, 0x62, 0x35, 0x36, 0x31, 0x34, 0x33, 0x37, 0x32, 0x36, 0x30, 0x31, 0x34, 0x36, 0x34, 0x61, 0x62, 0x63, 0x39, 0x61, 0x36, 0x61, 0x65, 0x64, 0x65, 0x30, 0x31, 0x33, 0x36, 0x63, 0x64, 0x38, 0x35, 0x62, 0x37, 0x35, 0x32, 0x37, 0x32, 0x63, 0x31, 0x37, 0x31, 0x37, 0x65, 0x63, 0x61, 0x65, 0x61, 0x35, 0x32, 0x30, 0x37, 0x31, 0x35, 0x66, 0x30, 0x62, 0x35, 0x61, 0x32, 0x37, 0x35, 0x31, 0x31, 0x65, 0x36, 0x36, 0x65, 0x32, 0x34, 0x62, 0x62, 0x34, 0x37, 0x61, 0x62, 0x35, 0x63, 0x31, 0x63, 0x30, 0x61, 0x30, 0x64, 0x66, 0x33, 0x30, 0x30, 0x32, 0x63, 0x32, 0x37, 0x38, 0x36, 0x38, 0x35, 0x63, 0x38, 0x30, 0x62, 0x34, 0x38, 0x65, 0x35, 0x39, 0x66, 0x39, 0x34, 0x64, 0x33, 0x30, 0x66, 0x35, 0x30, 0x38, 0x65, 0x64, 0x33, 0x65, 0x64, 0x62, 0x65, 0x66, 0x31, 0x31, 0x38, 0x32, 0x30, 0x62, 0x61, 0x32, 0x35, 0x33, 0x65, 0x30, 0x33, 0x64, 0x62, 0x32, 0x37, 0x62, 0x66, 0x65, 0x63, 0x63, 0x35, 0x65, 0x38, 0x65, 0x32, 0x36, 0x64, 0x31, 0x61, 0x32, 0x64, 0x37, 0x64, 0x32, 0x31, 0x63, 0x37, 0x37, 0x33, 0x37, 0x32, 0x38, 0x34, 0x39, 0x32, 0x36, 0x64, 0x39, 0x37, 0x62, 0x65, 0x31, 0x64, 0x37, 0x30, 0x62, 0x36, 0x62, 0x61, 0x39, 0x38, 0x64, 0x38, 0x30, 0x39, 0x61, 0x65, 0x31, 0x64, 0x65, 0x61, 0x30, 0x31, 0x36, 0x34, 0x64, 0x35, 0x35, 0x64, 0x30, 0x33, 0x62, 0x65, 0x38, 0x37, 0x66, 0x32, 0x38, 0x62, 0x33, 0x35, 0x35, 0x30, 0x32, 0x37, 0x38, 0x34, 0x35, 0x61, 0x36, 0x30, 0x31, 0x30, 0x37, 0x32, 0x33, 0x62, 0x64, 0x31, 0x64, 0x35, 0x35, 0x63, 0x65, 0x39, 0x66, 0x34, 0x34, 0x38, 0x61, 0x63, 0x61, 0x64, 0x39, 0x61, 0x31, 0x31, 0x62, 0x31, 0x36, 0x39, 0x30, 0x37, 0x34, 0x65, 0x64, 0x38, 0x39, 0x31, 0x34, 0x64, 0x61, 0x66, 0x66, 0x61, 0x64, 0x36, 0x37, 0x39, 0x34, 0x39, 0x32, 0x32, 0x31, 0x36, 0x63, 0x32, 0x64, 0x32, 0x35, 0x38, 0x36, 0x39, 0x31, 0x37, 0x38, 0x31, 0x37, 0x32, 0x34, 0x64, 0x34, 0x32, 0x31, 0x62, 0x61, 0x63, 0x39, 0x64, 0x32, 0x37, 0x30, 0x63, 0x61, 0x39, 0x62, 0x31, 0x66, 0x36, 0x62, 0x62, 0x63, 0x63, 0x30, 0x39, 0x30, 0x34, 0x66, 0x32, 0x65, 0x32, 0x31, 0x66, 0x39, 0x64, 0x64, 0x31, 0x65, 0x65, 0x39, 0x35, 0x61, 0x64, 0x39, 0x34, 0x64, 0x66, 0x62, 0x61, 0x62, 0x32, 0x62, 0x34, 0x65, 0x36, 0x33, 0x65, 0x35, 0x33, 0x62, 0x61, 0x33, 0x30, 0x65, 0x66, 0x38, 0x64, 0x35, 0x31, 0x32, 0x39, 0x38, 0x30, 0x62, 0x36, 0x34, 0x65, 0x35, 0x65, 0x62, 0x36, 0x34, 0x35, 0x64, 0x31, 0x34, 0x37, 0x62, 0x35, 0x35, 0x38, 0x61, 0x38, 0x36, 0x66, 0x30, 0x35, 0x62, 0x64, 0x33, 0x36, 0x64, 0x62, 0x61, 0x61, 0x66, 0x36, 0x36, 0x35, 0x33, 0x33, 0x39, 0x36, 0x30, 0x62, 0x36, 0x38, 0x33, 0x62, 0x64, 0x39, 0x62, 0x38, 0x32, 0x33, 0x36, 0x32, 0x32, 0x66, 0x33, 0x61, 0x36, 0x35, 0x61, 0x63, 0x36, 0x64, 0x36, 0x62, 0x37, 0x64, 0x33, 0x38, 0x39, 0x62, 0x37, 0x38, 0x65, 0x38, 0x31, 0x61, 0x32, 0x64, 0x62, 0x32, 0x36, 0x35, 0x37, 0x37, 0x33, 0x32, 0x30, 0x66, 0x33, 0x37, 0x65, 0x37, 0x35, 0x39, 0x62, 0x35, 0x64, 0x33, 0x65, 0x34, 0x36, 0x34, 0x37, 0x31, 0x39, 0x61, 0x30, 0x66, 0x33, 0x39, 0x30, 0x38, 0x31, 0x33, 0x31, 0x38, 0x30, 0x63, 0x38, 0x36, 0x63, 0x65, 0x65, 0x66, 0x38, 0x33, 0x31, 0x30, 0x64, 0x66, 0x36, 0x39, 0x66, 0x30, 0x65, 0x63, 0x64, 0x38, 0x36, 0x65, 0x36, 0x31, 0x63, 0x32, 0x64, 0x65, 0x64, 0x61, 0x38, 0x33, 0x62, 0x30, 0x30, 0x36, 0x34, 0x33, 0x62, 0x66, 0x38, 0x38, 0x30, 0x35, 0x32, 0x31, 0x38, 0x37, 0x30, 0x31, 0x63, 0x35, 0x35, 0x39, 0x66, 0x66, 0x35, 0x39, 0x62, 0x38, 0x37, 0x31, 0x35, 0x64, 0x64, 0x39, 0x33, 0x35, 0x31, 0x64, 0x30, 0x30, 0x30, 0x66, 0x33, 0x35, 0x32, 0x62, 0x33, 0x39, 0x33, 0x66, 0x65, 0x34, 0x33, 0x62, 0x35, 0x37, 0x38, 0x39, 0x61, 0x34, 0x35, 0x62, 0x62, 0x30, 0x36, 0x63, 0x31, 0x63, 0x66, 0x36, 0x64, 0x66, 0x65, 0x34, 0x62, 0x33, 0x62, 0x37, 0x32, 0x32, 0x66, 0x32, 0x39, 0x62, 0x64, 0x64, 0x63, 0x32, 0x63, 0x61, 0x39, 0x32, 0x36, 0x62, 0x30, 0x33, 0x37, 0x38, 0x30, 0x37, 0x33, 0x37, 0x62, 0x33, 0x30, 0x63, 0x65, 0x61, 0x30, 0x32, 0x36, 0x62, 0x38, 0x30, 0x32, 0x38, 0x38, 0x64, 0x36, 0x33, 0x61, 0x63, 0x34, 0x32, 0x39, 0x30, 0x37, 0x39, 0x34, 0x30, 0x38, 0x33, 0x62, 0x63, 0x32, 0x61, 0x64, 0x63, 0x38, 0x35, 0x35, 0x36, 0x32, 0x65, 0x64, 0x35, 0x37, 0x64, 0x66, 0x62, 0x65, 0x36, 0x61, 0x30, 0x38, 0x62, 0x37, 0x32, 0x35, 0x37, 0x66, 0x63, 0x37, 0x61, 0x61, 0x37, 0x30, 0x31, 0x38, 0x35, 0x32, 0x35, 0x63, 0x37, 0x31, 0x65, 0x30, 0x36, 0x65, 0x38, 0x39, 0x35, 0x65, 0x36, 0x35, 0x33, 0x66, 0x37, 0x31, 0x38, 0x32, 0x61, 0x62, 0x65, 0x38, 0x63, 0x63, 0x64, 0x39, 0x38, 0x36, 0x38, 0x33, 0x33, 0x30, 0x66, 0x34, 0x33, 0x33, 0x36, 0x32, 0x39, 0x33, 0x39, 0x64, 0x30, 0x32, 0x65, 0x66, 0x33, 0x32, 0x34, 0x31, 0x37, 0x36, 0x38, 0x63, 0x62, 0x62, 0x31, 0x39, 0x33, 0x66, 0x35, 0x39, 0x62, 0x65, 0x32, 0x62, 0x64, 0x35, 0x35, 0x64, 0x65, 0x62, 0x32, 0x66, 0x37, 0x36, 0x61, 0x34, 0x62, 0x64, 0x37, 0x66, 0x39, 0x33, 0x33, 0x38, 0x66, 0x34, 0x64, 0x32, 0x36, 0x62, 0x66, 0x65, 0x30, 0x63, 0x38, 0x37, 0x63, 0x65, 0x66, 0x34, 0x63, 0x36, 0x65, 0x30, 0x32, 0x31, 0x31, 0x33, 0x33, 0x36, 0x33, 0x63, 0x63, 0x34, 0x63, 0x37, 0x64, 0x34, 0x34, 0x61, 0x65, 0x63, 0x39, 0x66, 0x39, 0x61, 0x34, 0x61, 0x64, 0x30, 0x66, 0x37, 0x34, 0x38, 0x64, 0x62, 0x38, 0x36, 0x61, 0x39, 0x33, 0x66, 0x63, 0x30, 0x34, 0x33, 0x65, 0x39, 0x65, 0x61, 0x38, 0x37, 0x65, 0x34, 0x32, 0x66, 0x33, 0x62, 0x64, 0x61, 0x61, 0x61, 0x65, 0x31, 0x32, 0x30, 0x36, 0x36, 0x64, 0x38, 0x61, 0x61, 0x62, 0x37, 0x32, 0x31, 0x66, 0x39, 0x37, 0x33, 0x63, 0x66, 0x37, 0x63, 0x38, 0x33, 0x31, 0x62, 0x63, 0x64, 0x34, 0x32, 0x30, 0x32, 0x33, 0x61, 0x35, 0x36, 0x65, 0x64, 0x38, 0x61, 0x62, 0x63, 0x61, 0x32, 0x64, 0x63, 0x65, 0x63, 0x63, 0x66, 0x65, 0x66, 0x65, 0x62, 0x35, 0x30, 0x32, 0x66, 0x62, 0x30, 0x34, 0x39, 0x66, 0x62, 0x65, 0x31, 0x35, 0x63, 0x38, 0x31, 0x36, 0x66, 0x65, 0x35, 0x63, 0x37, 0x32, 0x36, 0x31, 0x36, 0x39, 0x63, 0x66, 0x37, 0x30, 0x63, 0x38, 0x30, 0x66, 0x34, 0x36, 0x37, 0x37, 0x36, 0x64, 0x38, 0x36, 0x36, 0x30, 0x30, 0x65, 0x34, 0x61, 0x61, 0x66, 0x31, 0x65, 0x62, 0x34, 0x38, 0x64, 0x38, 0x32, 0x37, 0x35, 0x37, 0x38, 0x38, 0x35, 0x64, 0x32, 0x30, 0x66, 0x66, 0x64, 0x36, 0x66, 0x64, 0x64, 0x34, 0x36, 0x38, 0x30, 0x38, 0x66, 0x37, 0x36, 0x64, 0x65, 0x34, 0x66, 0x39, 0x38, 0x35, 0x33, 0x38, 0x32, 0x61, 0x64, 0x65, 0x64, 0x65, 0x64, 0x37, 0x36, 0x38, 0x66, 0x34, 0x62, 0x64, 0x64, 0x30, 0x37, 0x33, 0x30, 0x34, 0x64, 0x33, 0x34, 0x36, 0x31, 0x62, 0x62, 0x39, 0x66, 0x66, 0x39, 0x64, 0x39, 0x62, 0x34, 0x32, 0x63, 0x62, 0x63, 0x61, 0x30, 0x63, 0x64, 0x63, 0x61, 0x36, 0x64, 0x61, 0x63, 0x65, 0x34, 0x61, 0x63, 0x34, 0x37, 0x35, 0x63, 0x30, 0x33, 0x37, 0x39, 0x34, 0x37, 0x30, 0x61, 0x39, 0x63, 0x65, 0x35, 0x39, 0x62, 0x39, 0x30, 0x32, 0x30, 0x66, 0x31, 0x31, 0x30, 0x33, 0x39, 0x38, 0x39, 0x63, 0x61, 0x33, 0x34, 0x32, 0x35, 0x39, 0x62, 0x66, 0x37, 0x32, 0x64, 0x63, 0x36, 0x34, 0x38, 0x65, 0x64, 0x64, 0x66, 0x30, 0x31, 0x65, 0x32, 0x32, 0x63, 0x66, 0x63, 0x63, 0x30, 0x30, 0x30, 0x62, 0x31, 0x64, 0x35, 0x61, 0x36, 0x32, 0x32, 0x38, 0x63, 0x62, 0x61, 0x35, 0x31, 0x35, 0x31, 0x39, 0x65, 0x64, 0x63, 0x32, 0x62, 0x31, 0x64, 0x37, 0x65, 0x30, 0x35, 0x30, 0x35, 0x39, 0x61, 0x39, 0x37, 0x38, 0x37, 0x31, 0x31, 0x39, 0x65, 0x61, 0x66, 0x34, 0x30, 0x63, 0x39, 0x37, 0x64, 0x37, 0x34, 0x61, 0x62, 0x37, 0x64, 0x36, 0x30, 0x66, 0x61, 0x36, 0x33, 0x64, 0x37, 0x35, 0x62, 0x39, 0x66, 0x34, 0x63, 0x38, 0x64, 0x30, 0x62, 0x61, 0x36, 0x66, 0x62, 0x38, 0x31, 0x35, 0x32, 0x63, 0x38, 0x30, 0x62, 0x36, 0x39, 0x38, 0x33, 0x38, 0x32, 0x61, 0x32, 0x39, 0x30, 0x30, 0x37, 0x63, 0x66, 0x31, 0x63, 0x30, 0x65, 0x37, 0x35, 0x65, 0x66, 0x62, 0x37, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x38, 0x37, 0x39, 0x61, 0x39, 0x32, 0x30, 0x62, 0x33, 0x66, 0x31, 0x32, 0x38, 0x34, 0x63, 0x64, 0x39, 0x63, 0x33, 0x39, 0x32, 0x66, 0x39, 0x39, 0x33, 0x32, 0x62, 0x36, 0x38, 0x62, 0x62, 0x39, 0x65, 0x33, 0x66, 0x32, 0x61, 0x37, 0x31, 0x36, 0x32, 0x35, 0x64, 0x30, 0x33, 0x39, 0x34, 0x33, 0x66, 0x64, 0x63, 0x38, 0x63, 0x32, 0x37, 0x38, 0x36, 0x39, 0x39, 0x65, 0x63, 0x32, 0x63, 0x34, 0x62, 0x61, 0x63, 0x30, 0x33, 0x66, 0x64, 0x32, 0x64, 0x64, 0x64, 0x62, 0x62, 0x62, 0x38, 0x61, 0x61, 0x36, 0x31, 0x62, 0x37, 0x32, 0x35, 0x39, 0x35, 0x38, 0x64, 0x39, 0x66, 0x35, 0x37, 0x66, 0x61, 0x36, 0x34, 0x32, 0x37, 0x30, 0x31, 0x39, 0x37, 0x63, 0x35, 0x36, 0x35, 0x33, 0x66, 0x34, 0x37, 0x34, 0x32, 0x38, 0x66, 0x64, 0x35, 0x32, 0x36, 0x35, 0x36, 0x33, 0x32, 0x33, 0x35, 0x36, 0x36, 0x37, 0x35, 0x36, 0x65, 0x31, 0x37, 0x32, 0x39, 0x36, 0x30, 0x66, 0x37, 0x62, 0x32, 0x61, 0x63, 0x64, 0x61, 0x38, 0x37, 0x32, 0x34, 0x30, 0x37, 0x33, 0x31, 0x64, 0x66, 0x34, 0x37, 0x31, 0x66, 0x61, 0x31, 0x35, 0x62, 0x38, 0x33, 0x62, 0x38, 0x39, 0x34, 0x66, 0x38, 0x62, 0x38, 0x38, 0x61, 0x62, 0x38, 0x64, 0x62, 0x66, 0x63, 0x30, 0x64, 0x30, 0x39, 0x66, 0x34, 0x62, 0x30, 0x35, 0x63, 0x36, 0x65, 0x35, 0x65, 0x33, 0x37, 0x37, 0x66, 0x36, 0x35, 0x62, 0x61, 0x34, 0x39, 0x30, 0x33, 0x62, 0x63, 0x30, 0x37, 0x32, 0x38, 0x34, 0x33, 0x33, 0x37, 0x35, 0x66, 0x39, 0x33, 0x63, 0x33, 0x35, 0x65, 0x63, 0x39, 0x38, 0x61, 0x38, 0x63, 0x37, 0x63, 0x38, 0x61, 0x39, 0x30, 0x31, 0x65, 0x36, 0x32, 0x65, 0x39, 0x62, 0x62, 0x30, 0x38, 0x61, 0x32, 0x33, 0x37, 0x34, 0x32, 0x38, 0x30, 0x37, 0x30, 0x39, 0x31, 0x39, 0x64, 0x30, 0x38, 0x39, 0x39, 0x63, 0x62, 0x62, 0x61, 0x35, 0x63, 0x66, 0x34, 0x35, 0x35, 0x63, 0x34, 0x66, 0x66, 0x33, 0x61, 0x33, 0x39, 0x66, 0x65, 0x38, 0x64, 0x34, 0x38, 0x62, 0x62, 0x36, 0x34, 0x32, 0x32, 0x31, 0x66, 0x38, 0x31, 0x30, 0x37, 0x61, 0x34, 0x32, 0x65, 0x34, 0x32, 0x35, 0x30, 0x63, 0x36, 0x35, 0x30, 0x65, 0x33, 0x61, 0x61, 0x37, 0x66, 0x37, 0x36, 0x64, 0x30, 0x61, 0x37, 0x30, 0x36, 0x64, 0x34, 0x30, 0x36, 0x61, 0x39, 0x64, 0x65, 0x34, 0x31, 0x35, 0x37, 0x32, 0x37, 0x66, 0x61, 0x66, 0x30, 0x35, 0x35, 0x33, 0x39, 0x64, 0x37, 0x66, 0x37, 0x62, 0x61, 0x38, 0x36, 0x30, 0x65, 0x30, 0x62, 0x39, 0x32, 0x39, 0x62, 0x37, 0x35, 0x32, 0x39, 0x37, 0x33, 0x63, 0x32, 0x39, 0x30, 0x35, 0x33, 0x38, 0x38, 0x38, 0x31, 0x39, 0x33, 0x66, 0x62, 0x64, 0x38, 0x32, 0x39, 0x62, 0x66, 0x31, 0x36, 0x35, 0x63, 0x37, 0x35, 0x33, 0x34, 0x33, 0x35, 0x63, 0x37, 0x32, 0x34, 0x36, 0x61, 0x65, 0x38, 0x35, 0x38, 0x35, 0x62, 0x36, 0x64, 0x61, 0x36, 0x63, 0x34, 0x33, 0x33, 0x34, 0x66, 0x33, 0x38, 0x36, 0x30, 0x38, 0x64, 0x34, 0x31, 0x63, 0x61, 0x38, 0x36, 0x35, 0x34, 0x61, 0x66, 0x65, 0x63, 0x65, 0x31, 0x31, 0x63, 0x61, 0x66, 0x39, 0x64, 0x64, 0x30, 0x36, 0x33, 0x66, 0x63, 0x37, 0x33, 0x31, 0x39, 0x65, 0x61, 0x35, 0x64, 0x34, 0x37, 0x63, 0x37, 0x32, 0x31, 0x35, 0x64, 0x31, 0x65, 0x34, 0x64, 0x62, 0x34, 0x39, 0x64, 0x37, 0x62, 0x66, 0x64, 0x64, 0x39, 0x33, 0x37, 0x32, 0x35, 0x64, 0x64, 0x64, 0x30, 0x38, 0x39, 0x63, 0x39, 0x37, 0x61, 0x61, 0x62, 0x34, 0x66, 0x36, 0x39, 0x30, 0x64, 0x64, 0x61, 0x34, 0x66, 0x65, 0x36, 0x36, 0x36, 0x66, 0x64, 0x65, 0x38, 0x62, 0x65, 0x64, 0x33, 0x37, 0x30, 0x30, 0x35, 0x36, 0x63, 0x35, 0x37, 0x32, 0x38, 0x35, 0x39, 0x31, 0x37, 0x61, 0x66, 0x37, 0x39, 0x63, 0x61, 0x61, 0x39, 0x39, 0x38, 0x30, 0x32, 0x31, 0x66, 0x39, 0x33, 0x66, 0x62, 0x34, 0x66, 0x63, 0x33, 0x38, 0x35, 0x39, 0x38, 0x33, 0x31, 0x37, 0x37, 0x66, 0x62, 0x31, 0x33, 0x32, 0x39, 0x32, 0x62, 0x39, 0x37, 0x61, 0x32, 0x36, 0x33, 0x65, 0x62, 0x31, 0x30, 0x38, 0x62, 0x39, 0x64, 0x30, 0x34, 0x39, 0x33, 0x61, 0x32, 0x35, 0x32, 0x37, 0x31, 0x65, 0x35, 0x31, 0x38, 0x33, 0x61, 0x38, 0x31, 0x61, 0x65, 0x32, 0x35, 0x32, 0x39, 0x37, 0x61, 0x32, 0x36, 0x37, 0x63, 0x64, 0x34, 0x32, 0x36, 0x39, 0x32, 0x38, 0x37, 0x35, 0x34, 0x61, 0x32, 0x66, 0x36, 0x39, 0x64, 0x32, 0x64, 0x61, 0x38, 0x61, 0x33, 0x36, 0x62, 0x65, 0x66, 0x38, 0x34, 0x32, 0x37, 0x37, 0x33, 0x62, 0x39, 0x37, 0x38, 0x62, 0x39, 0x39, 0x32, 0x36, 0x30, 0x66, 0x34, 0x62, 0x38, 0x64, 0x38, 0x30, 0x31, 0x38, 0x34, 0x38, 0x34, 0x65, 0x39, 0x35, 0x62, 0x36, 0x33, 0x38, 0x32, 0x35, 0x37, 0x39, 0x39, 0x65, 0x34, 0x31, 0x36, 0x61, 0x65, 0x38, 0x37, 0x32, 0x31, 0x37, 0x65, 0x30, 0x38, 0x66, 0x64, 0x66, 0x32, 0x39, 0x36, 0x61, 0x66, 0x66, 0x39, 0x36, 0x62, 0x61, 0x30, 0x64, 0x65, 0x39, 0x65, 0x63, 0x63, 0x62, 0x36, 0x66, 0x37, 0x32, 0x65, 0x34, 0x61, 0x62, 0x63, 0x63, 0x64, 0x30, 0x39, 0x33, 0x35, 0x39, 0x35, 0x36, 0x39, 0x34, 0x66, 0x37, 0x30, 0x30, 0x30, 0x65, 0x32, 0x62, 0x35, 0x31, 0x37, 0x62, 0x31, 0x35, 0x37, 0x66, 0x33, 0x61, 0x30, 0x64, 0x34, 0x64, 0x39, 0x38, 0x63, 0x66, 0x61, 0x38, 0x34, 0x31, 0x36, 0x36, 0x39, 0x35, 0x37, 0x63, 0x64, 0x65, 0x33, 0x30, 0x39, 0x65, 0x62, 0x61, 0x66, 0x38, 0x37, 0x32, 0x36, 0x36, 0x61, 0x66, 0x61, 0x63, 0x30, 0x35, 0x30, 0x65, 0x64, 0x34, 0x39, 0x30, 0x64, 0x31, 0x34, 0x31, 0x33, 0x37, 0x39, 0x61, 0x31, 0x63, 0x32, 0x63, 0x30, 0x62, 0x65, 0x63, 0x36, 0x31, 0x34, 0x35, 0x31, 0x62, 0x37, 0x39, 0x39, 0x65, 0x63, 0x66, 0x38, 0x37, 0x35, 0x64, 0x37, 0x34, 0x39, 0x64, 0x30, 0x66, 0x61, 0x35, 0x66, 0x35, 0x62, 0x61, 0x31, 0x37, 0x38, 0x38, 0x37, 0x32, 0x61, 0x31, 0x37, 0x39, 0x66, 0x66, 0x37, 0x37, 0x36, 0x33, 0x31, 0x35, 0x36, 0x61, 0x66, 0x35, 0x33, 0x31, 0x30, 0x35, 0x33, 0x37, 0x39, 0x35, 0x37, 0x30, 0x32, 0x61, 0x63, 0x32, 0x64, 0x34, 0x62, 0x30, 0x31, 0x65, 0x66, 0x35, 0x61, 0x65, 0x37, 0x39, 0x39, 0x30, 0x63, 0x65, 0x31, 0x35, 0x37, 0x64, 0x31, 0x33, 0x32, 0x61, 0x37, 0x38, 0x65, 0x33, 0x37, 0x37, 0x65, 0x39, 0x31, 0x38, 0x37, 0x30, 0x35, 0x39, 0x64, 0x35, 0x62, 0x30, 0x64, 0x35, 0x38, 0x64, 0x33, 0x37, 0x38, 0x39, 0x61, 0x61, 0x31, 0x30, 0x36, 0x37, 0x62, 0x63, 0x66, 0x37, 0x34, 0x37, 0x34, 0x33, 0x30, 0x37, 0x35, 0x63, 0x31, 0x62, 0x34, 0x37, 0x62, 0x63, 0x34, 0x37, 0x62, 0x39, 0x38, 0x31, 0x66, 0x35, 0x64, 0x38, 0x63, 0x35, 0x38, 0x30, 0x34, 0x37, 0x63, 0x39, 0x38, 0x34, 0x62, 0x39, 0x30, 0x62, 0x33, 0x32, 0x63, 0x37, 0x61, 0x63, 0x32, 0x35, 0x65, 0x65, 0x34, 0x34, 0x35, 0x66, 0x62, 0x36, 0x63, 0x62, 0x64, 0x63, 0x38, 0x38, 0x33, 0x30, 0x31, 0x37, 0x38, 0x65, 0x39, 0x36, 0x32, 0x64, 0x31, 0x32, 0x64, 0x33, 0x35, 0x32, 0x34, 0x64, 0x33, 0x39, 0x38, 0x65, 0x66, 0x34, 0x37, 0x38, 0x30, 0x61, 0x39, 0x66, 0x37, 0x35, 0x39, 0x34, 0x34, 0x30, 0x36, 0x33, 0x35, 0x62, 0x35, 0x37, 0x65, 0x36, 0x65, 0x39, 0x35, 0x63, 0x36, 0x36, 0x33, 0x66, 0x39, 0x35, 0x38, 0x35, 0x65, 0x64, 0x31, 0x61, 0x65, 0x33, 0x37, 0x39, 0x39, 0x38, 0x65, 0x61, 0x30, 0x65, 0x63, 0x30, 0x66, 0x63, 0x34, 0x61, 0x31, 0x37, 0x30, 0x38, 0x36, 0x34, 0x31, 0x64, 0x63, 0x65, 0x37, 0x30, 0x39, 0x38, 0x64, 0x63, 0x37, 0x61, 0x31, 0x64, 0x34, 0x32, 0x31, 0x39, 0x36, 0x61, 0x63, 0x37, 0x37, 0x32, 0x37, 0x64, 0x30, 0x32, 0x64, 0x38, 0x36, 0x62, 0x33, 0x66, 0x38, 0x31, 0x32, 0x37, 0x33, 0x34, 0x39, 0x64, 0x33, 0x66, 0x63, 0x34, 0x37, 0x30, 0x64, 0x37, 0x38, 0x32, 0x62, 0x66, 0x66, 0x62, 0x36, 0x32, 0x64, 0x31, 0x66, 0x30, 0x65, 0x34, 0x32, 0x36, 0x62, 0x31, 0x31, 0x64, 0x38, 0x31, 0x30, 0x38, 0x35, 0x35, 0x61, 0x66, 0x31, 0x34, 0x37, 0x39, 0x61, 0x31, 0x65, 0x31, 0x30, 0x34, 0x64, 0x64, 0x65, 0x33, 0x62, 0x63, 0x63, 0x33, 0x38, 0x63, 0x31, 0x30, 0x63, 0x61, 0x39, 0x33, 0x37, 0x37, 0x66, 0x34, 0x34, 0x35, 0x34, 0x33, 0x65, 0x38, 0x64, 0x66, 0x32, 0x63, 0x61, 0x66, 0x66, 0x30, 0x63, 0x35, 0x39, 0x38, 0x30, 0x30, 0x38, 0x33, 0x61, 0x38, 0x33, 0x61, 0x39, 0x34, 0x39, 0x39, 0x64, 0x35, 0x65, 0x66, 0x36, 0x63, 0x38, 0x39, 0x66, 0x64, 0x33, 0x35, 0x30, 0x37, 0x31, 0x35, 0x33, 0x39, 0x37, 0x62, 0x31, 0x35, 0x37, 0x62, 0x66, 0x63, 0x33, 0x36, 0x62, 0x38, 0x33, 0x65, 0x30, 0x31, 0x34, 0x35, 0x35, 0x37, 0x39, 0x34, 0x65, 0x33, 0x34, 0x30, 0x31, 0x61, 0x37, 0x61, 0x38, 0x39, 0x35, 0x63, 0x66, 0x65, 0x63, 0x66, 0x33, 0x35, 0x31, 0x32, 0x64, 0x37, 0x37, 0x64, 0x33, 0x66, 0x38, 0x65, 0x35, 0x31, 0x37, 0x38, 0x63, 0x31, 0x64, 0x38, 0x37, 0x32, 0x33, 0x31, 0x31, 0x32, 0x64, 0x35, 0x62, 0x63, 0x30, 0x66, 0x35, 0x31, 0x36, 0x64, 0x33, 0x37, 0x31, 0x64, 0x62, 0x36, 0x34, 0x37, 0x64, 0x62, 0x38, 0x32, 0x65, 0x32, 0x63, 0x30, 0x64, 0x32, 0x35, 0x66, 0x36, 0x36, 0x31, 0x66, 0x65, 0x32, 0x31, 0x63, 0x61, 0x31, 0x37, 0x65, 0x62, 0x34, 0x34, 0x32, 0x63, 0x63, 0x36, 0x35, 0x37, 0x31, 0x39, 0x66, 0x65, 0x31, 0x62, 0x62, 0x31, 0x61, 0x61, 0x61, 0x30, 0x30, 0x38, 0x61, 0x63, 0x38, 0x66, 0x36, 0x31, 0x37, 0x37, 0x37, 0x65, 0x62, 0x62, 0x31, 0x66, 0x38, 0x61, 0x34, 0x34, 0x31, 0x61, 0x36, 0x62, 0x32, 0x31, 0x37, 0x62, 0x63, 0x30, 0x62, 0x62, 0x63, 0x65, 0x34, 0x31, 0x39, 0x66, 0x62, 0x39, 0x66, 0x34, 0x64, 0x65, 0x34, 0x36, 0x65, 0x37, 0x34, 0x62, 0x39, 0x65, 0x31, 0x30, 0x64, 0x33, 0x62, 0x64, 0x35, 0x30, 0x65, 0x64, 0x33, 0x35, 0x62, 0x64, 0x65, 0x33, 0x66, 0x36, 0x31, 0x30, 0x62, 0x38, 0x61, 0x37, 0x30, 0x38, 0x39, 0x36, 0x33, 0x63, 0x61, 0x39, 0x32, 0x34, 0x31, 0x62, 0x37, 0x30, 0x32, 0x66, 0x32, 0x36, 0x35, 0x30, 0x30, 0x36, 0x61, 0x37, 0x37, 0x61, 0x30, 0x34, 0x31, 0x32, 0x30, 0x64, 0x31, 0x34, 0x66, 0x32, 0x64, 0x36, 0x38, 0x64, 0x37, 0x36, 0x66, 0x34, 0x66, 0x65, 0x30, 0x37, 0x32, 0x30, 0x64, 0x35, 0x36, 0x37, 0x36, 0x64, 0x36, 0x64, 0x61, 0x64, 0x33, 0x39, 0x64, 0x38, 0x33, 0x33, 0x36, 0x63, 0x34, 0x35, 0x30, 0x65, 0x30, 0x34, 0x63, 0x31, 0x65, 0x65, 0x38, 0x37, 0x31, 0x37, 0x62, 0x37, 0x66, 0x33, 0x39, 0x30, 0x37, 0x63, 0x30, 0x62, 0x62, 0x35, 0x38, 0x64, 0x34, 0x61, 0x36, 0x66, 0x38, 0x34, 0x62, 0x64, 0x37, 0x39, 0x35, 0x39, 0x37, 0x61, 0x39, 0x37, 0x32, 0x32, 0x66, 0x63, 0x64, 0x33, 0x63, 0x31, 0x37, 0x66, 0x36, 0x31, 0x33, 0x32, 0x62, 0x34, 0x64, 0x39, 0x36, 0x64, 0x65, 0x65, 0x34, 0x32, 0x34, 0x65, 0x31, 0x64, 0x61, 0x61, 0x32, 0x33, 0x30, 0x65, 0x63, 0x65, 0x37, 0x34, 0x62, 0x61, 0x65, 0x34, 0x36, 0x36, 0x39, 0x37, 0x30, 0x62, 0x30, 0x35, 0x35, 0x64, 0x39, 0x36, 0x64, 0x66, 0x34, 0x39, 0x62, 0x37, 0x37, 0x35, 0x32, 0x37, 0x32, 0x62, 0x32, 0x63, 0x32, 0x62, 0x62, 0x39, 0x66, 0x33, 0x36, 0x63, 0x34, 0x34, 0x38, 0x34, 0x39, 0x35, 0x35, 0x34, 0x66, 0x31, 0x38, 0x39, 0x32, 0x32, 0x64, 0x37, 0x65, 0x33, 0x32, 0x33, 0x38, 0x37, 0x64, 0x63, 0x32, 0x39, 0x65, 0x39, 0x32, 0x39, 0x61, 0x31, 0x61, 0x62, 0x37, 0x62, 0x30, 0x34, 0x62, 0x38, 0x61, 0x61, 0x36, 0x35, 0x38, 0x35, 0x35, 0x31, 0x63, 0x37, 0x32, 0x37, 0x32, 0x38, 0x33, 0x32, 0x65, 0x64, 0x31, 0x34, 0x36, 0x35, 0x66, 0x61, 0x61, 0x39, 0x37, 0x34, 0x66, 0x61, 0x34, 0x37, 0x66, 0x65, 0x65, 0x34, 0x36, 0x34, 0x61, 0x36, 0x34, 0x33, 0x39, 0x63, 0x31, 0x63, 0x33, 0x38, 0x39, 0x36, 0x66, 0x36, 0x33, 0x65, 0x39, 0x38, 0x66, 0x66, 0x61, 0x38, 0x39, 0x66, 0x64, 0x30, 0x33, 0x31, 0x38, 0x34, 0x38, 0x33, 0x36, 0x35, 0x34, 0x38, 0x31, 0x37, 0x32, 0x31, 0x62, 0x32, 0x63, 0x35, 0x34, 0x36, 0x63, 0x35, 0x65, 0x30, 0x39, 0x30, 0x36, 0x66, 0x32, 0x34, 0x31, 0x30, 0x31, 0x66, 0x36, 0x33, 0x39, 0x63, 0x36, 0x34, 0x39, 0x61, 0x38, 0x38, 0x64, 0x65, 0x34, 0x30, 0x64, 0x62, 0x64, 0x30, 0x64, 0x61, 0x33, 0x61, 0x33, 0x65, 0x33, 0x61, 0x36, 0x35, 0x65, 0x34, 0x39, 0x62, 0x63, 0x65, 0x32, 0x38, 0x31, 0x62, 0x30, 0x35, 0x31, 0x35, 0x33, 0x39, 0x36, 0x31, 0x61, 0x66, 0x66, 0x34, 0x31, 0x33, 0x63, 0x62, 0x66, 0x64, 0x32, 0x38, 0x66, 0x63, 0x65, 0x39, 0x63, 0x61, 0x34, 0x31, 0x30, 0x66, 0x31, 0x34, 0x33, 0x39, 0x65, 0x35, 0x64, 0x36, 0x61, 0x64, 0x31, 0x34, 0x31, 0x30, 0x33, 0x38, 0x66, 0x36, 0x64, 0x34, 0x63, 0x31, 0x35, 0x63, 0x39, 0x61, 0x39, 0x61, 0x34, 0x62, 0x61, 0x61, 0x61, 0x38, 0x65, 0x30, 0x39, 0x37, 0x32, 0x35, 0x30, 0x32, 0x64, 0x38, 0x33, 0x64, 0x64, 0x39, 0x32, 0x31, 0x62, 0x33, 0x61, 0x36, 0x64, 0x33, 0x62, 0x38, 0x34, 0x39, 0x37, 0x39, 0x65, 0x33, 0x61, 0x36, 0x61, 0x61, 0x38, 0x66, 0x64, 0x32, 0x30, 0x35, 0x38, 0x38, 0x37, 0x63, 0x37, 0x35, 0x37, 0x30, 0x64, 0x31, 0x38, 0x65, 0x65, 0x36, 0x38, 0x30, 0x32, 0x65, 0x62, 0x34, 0x35, 0x32, 0x37, 0x30, 0x39, 0x66, 0x34, 0x31, 0x63, 0x65, 0x37, 0x39, 0x38, 0x61, 0x37, 0x31, 0x32, 0x36, 0x35, 0x65, 0x62, 0x61, 0x35, 0x38, 0x31, 0x37, 0x66, 0x39, 0x38, 0x33, 0x63, 0x61, 0x30, 0x62, 0x34, 0x35, 0x35, 0x36, 0x64, 0x31, 0x34, 0x34, 0x35, 0x65, 0x64, 0x35, 0x63, 0x61, 0x35, 0x62, 0x61, 0x34, 0x37, 0x32, 0x32, 0x39, 0x36, 0x65, 0x66, 0x31, 0x34, 0x63, 0x62, 0x35, 0x38, 0x66, 0x65, 0x39, 0x64, 0x30, 0x37, 0x32, 0x32, 0x66, 0x62, 0x65, 0x36, 0x37, 0x35, 0x31, 0x39, 0x66, 0x36, 0x31, 0x65, 0x64, 0x66, 0x31, 0x39, 0x30, 0x33, 0x35, 0x30, 0x61, 0x62, 0x66, 0x31, 0x38, 0x34, 0x61, 0x31, 0x35, 0x63, 0x66, 0x31, 0x31, 0x66, 0x31, 0x35, 0x36, 0x31, 0x65, 0x38, 0x36, 0x38, 0x39, 0x64, 0x35, 0x30, 0x33, 0x66, 0x31, 0x63, 0x35, 0x66, 0x39, 0x65, 0x33, 0x66, 0x30, 0x62, 0x63, 0x31, 0x30, 0x39, 0x37, 0x32, 0x65, 0x63, 0x64, 0x61, 0x61, 0x66, 0x32, 0x65, 0x39, 0x30, 0x35, 0x37, 0x62, 0x32, 0x66, 0x30, 0x66, 0x38, 0x62, 0x36, 0x65, 0x36, 0x31, 0x64, 0x35, 0x61, 0x61, 0x34, 0x30, 0x30, 0x39, 0x35, 0x64, 0x38, 0x66, 0x63, 0x30, 0x63, 0x62, 0x36, 0x30, 0x65, 0x66, 0x31, 0x33, 0x63, 0x61, 0x33, 0x61, 0x61, 0x65, 0x65, 0x66, 0x38, 0x34, 0x34, 0x66, 0x32, 0x32, 0x38, 0x64, 0x35, 0x34, 0x61, 0x62, 0x31, 0x34, 0x33, 0x30, 0x34, 0x36, 0x61, 0x64, 0x35, 0x39, 0x66, 0x36, 0x61, 0x36, 0x36, 0x66, 0x61, 0x36, 0x61, 0x35, 0x66, 0x61, 0x35, 0x37, 0x35, 0x30, 0x39, 0x61, 0x34, 0x61, 0x30, 0x35, 0x65, 0x37, 0x62, 0x34, 0x39, 0x32, 0x38, 0x64, 0x38, 0x34, 0x35, 0x30, 0x37, 0x61, 0x65, 0x36, 0x65, 0x63, 0x63, 0x32, 0x37, 0x64, 0x36, 0x66, 0x62, 0x36, 0x65, 0x62, 0x64, 0x34, 0x36, 0x33, 0x32, 0x64, 0x33, 0x35, 0x66, 0x66, 0x35, 0x61, 0x37, 0x65, 0x66, 0x34, 0x33, 0x64, 0x35, 0x33, 0x61, 0x64, 0x37, 0x30, 0x39, 0x36, 0x64, 0x61, 0x38, 0x64, 0x63, 0x31, 0x64, 0x61, 0x39, 0x36, 0x62, 0x64, 0x64, 0x39, 0x34, 0x65, 0x30, 0x35, 0x36, 0x35, 0x37, 0x37, 0x64, 0x31, 0x33, 0x31, 0x61, 0x38, 0x32, 0x35, 0x30, 0x35, 0x35, 0x61, 0x62, 0x66, 0x36, 0x34, 0x65, 0x37, 0x32, 0x34, 0x30, 0x34, 0x31, 0x65, 0x62, 0x62, 0x63, 0x33, 0x34, 0x61, 0x38, 0x34, 0x65, 0x38, 0x33, 0x34, 0x35, 0x35, 0x38, 0x30, 0x66, 0x37, 0x30, 0x30, 0x35, 0x37, 0x64, 0x31, 0x37, 0x37, 0x34, 0x37, 0x63, 0x30, 0x65, 0x62, 0x66, 0x34, 0x32, 0x30, 0x35, 0x66, 0x37, 0x36, 0x33, 0x36, 0x37, 0x61, 0x33, 0x32, 0x36, 0x33, 0x64, 0x65, 0x32, 0x64, 0x65, 0x36, 0x30, 0x34, 0x63, 0x36, 0x31, 0x61, 0x36, 0x35, 0x39, 0x63, 0x37, 0x32, 0x36, 0x36, 0x32, 0x32, 0x31, 0x31, 0x63, 0x66, 0x66, 0x63, 0x35, 0x61, 0x30, 0x62, 0x66, 0x63, 0x36, 0x39, 0x33, 0x66, 0x35, 0x33, 0x32, 0x32, 0x34, 0x36, 0x36, 0x66, 0x33, 0x64, 0x66, 0x61, 0x61, 0x64, 0x66, 0x32, 0x66, 0x30, 0x39, 0x36, 0x35, 0x30, 0x62, 0x31, 0x61, 0x37, 0x37, 0x37, 0x30, 0x35, 0x65, 0x30, 0x38, 0x33, 0x61, 0x37, 0x32, 0x66, 0x64, 0x65, 0x34, 0x31, 0x35, 0x63, 0x33, 0x36, 0x38, 0x39, 0x62, 0x33, 0x65, 0x63, 0x38, 0x32, 0x61, 0x66, 0x61, 0x31, 0x64, 0x37, 0x35, 0x37, 0x32, 0x32, 0x32, 0x65, 0x38, 0x36, 0x32, 0x37, 0x61, 0x30, 0x37, 0x37, 0x64, 0x30, 0x37, 0x30, 0x62, 0x39, 0x62, 0x33, 0x64, 0x62, 0x38, 0x36, 0x34, 0x37, 0x37, 0x35, 0x39, 0x62, 0x62, 0x62, 0x32, 0x39, 0x31, 0x38, 0x62, 0x31, 0x36, 0x30, 0x63, 0x39, 0x65, 0x30, 0x35, 0x38, 0x62, 0x62, 0x35, 0x37, 0x38, 0x36, 0x33, 0x62, 0x62, 0x36, 0x64, 0x65, 0x62, 0x62, 0x31, 0x63, 0x61, 0x32, 0x36, 0x30, 0x64, 0x63, 0x63, 0x32, 0x32, 0x62, 0x66, 0x38, 0x32, 0x32, 0x62, 0x37, 0x64, 0x64, 0x37, 0x30, 0x38, 0x61, 0x61, 0x31, 0x33, 0x66, 0x61, 0x37, 0x30, 0x36, 0x33, 0x35, 0x35, 0x30, 0x31, 0x66, 0x37, 0x37, 0x35, 0x30, 0x63, 0x30, 0x66, 0x63, 0x32, 0x63, 0x66, 0x36, 0x31, 0x38, 0x62, 0x34, 0x66, 0x65, 0x37, 0x61, 0x66, 0x65, 0x36, 0x34, 0x65, 0x64, 0x65, 0x35, 0x35, 0x31, 0x63, 0x37, 0x64, 0x63, 0x30, 0x64, 0x37, 0x34, 0x62, 0x39, 0x63, 0x31, 0x61, 0x33, 0x34, 0x62, 0x30, 0x65, 0x35, 0x61, 0x30, 0x36, 0x62, 0x65, 0x63, 0x34, 0x39, 0x33, 0x35, 0x62, 0x39, 0x61, 0x31, 0x35, 0x62, 0x32, 0x35, 0x37, 0x32, 0x33, 0x64, 0x35, 0x66, 0x37, 0x62, 0x36, 0x38, 0x31, 0x33, 0x33, 0x37, 0x63, 0x63, 0x31, 0x35, 0x38, 0x37, 0x33, 0x37, 0x32, 0x34, 0x35, 0x34, 0x30, 0x64, 0x35, 0x32, 0x32, 0x34, 0x34, 0x66, 0x34, 0x31, 0x64, 0x63, 0x61, 0x64, 0x36, 0x37, 0x36, 0x35, 0x39, 0x32, 0x34, 0x39, 0x33, 0x63, 0x66, 0x32, 0x39, 0x32, 0x36, 0x34, 0x37, 0x34, 0x35, 0x35, 0x34, 0x36, 0x36, 0x61, 0x35, 0x64, 0x65, 0x31, 0x64, 0x39, 0x30, 0x66, 0x34, 0x30, 0x61, 0x66, 0x64, 0x32, 0x61, 0x35, 0x38, 0x33, 0x64, 0x64, 0x38, 0x34, 0x31, 0x66, 0x30, 0x33, 0x39, 0x35, 0x35, 0x32, 0x64, 0x31, 0x63, 0x36, 0x35, 0x66, 0x37, 0x34, 0x37, 0x33, 0x66, 0x30, 0x34, 0x66, 0x33, 0x65, 0x35, 0x39, 0x34, 0x39, 0x31, 0x62, 0x32, 0x35, 0x33, 0x34, 0x32, 0x38, 0x30, 0x38, 0x39, 0x31, 0x31, 0x38, 0x37, 0x32, 0x66, 0x39, 0x66, 0x63, 0x30, 0x61, 0x61, 0x64, 0x36, 0x32, 0x36, 0x63, 0x35, 0x33, 0x35, 0x36, 0x39, 0x63, 0x34, 0x65, 0x66, 0x63, 0x39, 0x33, 0x65, 0x38, 0x38, 0x61, 0x30, 0x63, 0x61, 0x34, 0x65, 0x64, 0x61, 0x39, 0x63, 0x65, 0x34, 0x38, 0x38, 0x37, 0x65, 0x39, 0x33, 0x33, 0x34, 0x65, 0x62, 0x64, 0x36, 0x35, 0x65, 0x32, 0x34, 0x33, 0x31, 0x37, 0x63, 0x66, 0x61, 0x37, 0x37, 0x32, 0x32, 0x35, 0x66, 0x63, 0x30, 0x65, 0x37, 0x30, 0x33, 0x38, 0x62, 0x63, 0x30, 0x36, 0x64, 0x33, 0x62, 0x62, 0x66, 0x62, 0x31, 0x66, 0x34, 0x63, 0x62, 0x36, 0x37, 0x30, 0x63, 0x33, 0x64, 0x65, 0x37, 0x64, 0x35, 0x37, 0x63, 0x36, 0x32, 0x35, 0x37, 0x38, 0x62, 0x64, 0x64, 0x38, 0x65, 0x35, 0x36, 0x65, 0x66, 0x63, 0x65, 0x38, 0x38, 0x61, 0x65, 0x33, 0x62, 0x39, 0x30, 0x38, 0x37, 0x32, 0x62, 0x30, 0x63, 0x30, 0x32, 0x63, 0x65, 0x34, 0x61, 0x30, 0x39, 0x31, 0x34, 0x65, 0x33, 0x66, 0x39, 0x33, 0x38, 0x36, 0x64, 0x38, 0x36, 0x38, 0x37, 0x34, 0x66, 0x61, 0x39, 0x66, 0x30, 0x62, 0x61, 0x31, 0x30, 0x31, 0x62, 0x63, 0x62, 0x39, 0x32, 0x35, 0x36, 0x30, 0x35, 0x61, 0x63, 0x62, 0x31, 0x63, 0x32, 0x32, 0x30, 0x31, 0x31, 0x64, 0x36, 0x30, 0x32, 0x35, 0x61, 0x63, 0x37, 0x32, 0x38, 0x38, 0x35, 0x64, 0x61, 0x34, 0x64, 0x33, 0x31, 0x37, 0x31, 0x32, 0x35, 0x33, 0x30, 0x34, 0x33, 0x33, 0x63, 0x64, 0x36, 0x66, 0x38, 0x38, 0x63, 0x36, 0x39, 0x62, 0x35, 0x32, 0x38, 0x34, 0x66, 0x34, 0x64, 0x36, 0x66, 0x35, 0x39, 0x63, 0x39, 0x33, 0x36, 0x61, 0x38, 0x63, 0x62, 0x66, 0x65, 0x62, 0x35, 0x35, 0x61, 0x35, 0x64, 0x32, 0x66, 0x64, 0x37, 0x33, 0x62, 0x38, 0x31, 0x37, 0x61, 0x66, 0x37, 0x36, 0x62, 0x32, 0x32, 0x62, 0x63, 0x35, 0x30, 0x65, 0x62, 0x61, 0x36, 0x66, 0x30, 0x35, 0x65, 0x34, 0x64, 0x63, 0x38, 0x34, 0x36, 0x39, 0x66, 0x32, 0x34, 0x61, 0x65, 0x37, 0x38, 0x30, 0x33, 0x30, 0x30, 0x37, 0x31, 0x36, 0x61, 0x39, 0x36, 0x33, 0x62, 0x66, 0x66, 0x63, 0x63, 0x31, 0x36, 0x62, 0x34, 0x34, 0x65, 0x63, 0x30, 0x30, 0x31, 0x64, 0x34, 0x34, 0x37, 0x32, 0x30, 0x32, 0x31, 0x36, 0x36, 0x63, 0x33, 0x63, 0x61, 0x63, 0x32, 0x34, 0x30, 0x39, 0x35, 0x61, 0x66, 0x39, 0x31, 0x61, 0x62, 0x30, 0x63, 0x61, 0x65, 0x62, 0x64, 0x65, 0x39, 0x37, 0x63, 0x61, 0x62, 0x65, 0x31, 0x30, 0x33, 0x63, 0x66, 0x32, 0x30, 0x36, 0x64, 0x31, 0x34, 0x65, 0x63, 0x64, 0x63, 0x32, 0x31, 0x30, 0x34, 0x61, 0x35, 0x31, 0x39, 0x64, 0x66, 0x65, 0x62, 0x32, 0x32, 0x31, 0x38, 0x31, 0x33, 0x33, 0x30, 0x35, 0x33, 0x39, 0x63, 0x66, 0x31, 0x37, 0x33, 0x30, 0x31, 0x66, 0x35, 0x34, 0x66, 0x66, 0x65, 0x62, 0x37, 0x61, 0x34, 0x32, 0x30, 0x65, 0x36, 0x61, 0x66, 0x66, 0x62, 0x65, 0x66, 0x38, 0x31, 0x37, 0x66, 0x61, 0x30, 0x31, 0x37, 0x64, 0x32, 0x30, 0x63, 0x62, 0x30, 0x63, 0x66, 0x33, 0x35, 0x62, 0x66, 0x39, 0x30, 0x66, 0x61, 0x66, 0x36, 0x39, 0x34, 0x61, 0x35, 0x34, 0x37, 0x31, 0x33, 0x31, 0x64, 0x36, 0x66, 0x39, 0x65, 0x36, 0x34, 0x34, 0x63, 0x32, 0x37, 0x35, 0x62, 0x66, 0x30, 0x61, 0x62, 0x63, 0x33, 0x35, 0x37, 0x34, 0x61, 0x33, 0x32, 0x38, 0x34, 0x35, 0x35, 0x35, 0x38, 0x61, 0x62, 0x62, 0x33, 0x63, 0x38, 0x39, 0x65, 0x61, 0x34, 0x35, 0x66, 0x64, 0x64, 0x65, 0x64, 0x30, 0x38, 0x61, 0x62, 0x32, 0x33, 0x62, 0x37, 0x36, 0x37, 0x32, 0x35, 0x62, 0x61, 0x30, 0x64, 0x33, 0x36, 0x65, 0x62, 0x35, 0x62, 0x38, 0x61, 0x65, 0x32, 0x61, 0x33, 0x61, 0x62, 0x30, 0x63, 0x63, 0x30, 0x61, 0x30, 0x37, 0x61, 0x63, 0x34, 0x63, 0x32, 0x63, 0x63, 0x64, 0x37, 0x34, 0x37, 0x37, 0x39, 0x37, 0x39, 0x38, 0x62, 0x31, 0x39, 0x30, 0x36, 0x31, 0x66, 0x61, 0x35, 0x31, 0x31, 0x38, 0x30, 0x65, 0x66, 0x34, 0x34, 0x65, 0x66, 0x34, 0x37, 0x32, 0x34, 0x39, 0x32, 0x61, 0x36, 0x37, 0x39, 0x31, 0x63, 0x62, 0x37, 0x36, 0x32, 0x30, 0x65, 0x38, 0x30, 0x61, 0x64, 0x65, 0x34, 0x62, 0x36, 0x64, 0x31, 0x30, 0x35, 0x30, 0x33, 0x66, 0x38, 0x37, 0x62, 0x61, 0x32, 0x36, 0x34, 0x32, 0x62, 0x30, 0x63, 0x65, 0x35, 0x62, 0x64, 0x34, 0x35, 0x33, 0x61, 0x34, 0x35, 0x62, 0x35, 0x38, 0x36, 0x64, 0x39, 0x35, 0x30, 0x36, 0x63, 0x33, 0x37, 0x32, 0x37, 0x35, 0x32, 0x39, 0x66, 0x65, 0x35, 0x31, 0x34, 0x30, 0x32, 0x38, 0x62, 0x33, 0x30, 0x61, 0x62, 0x32, 0x65, 0x35, 0x65, 0x31, 0x37, 0x65, 0x32, 0x64, 0x34, 0x61, 0x65, 0x63, 0x30, 0x65, 0x33, 0x33, 0x64, 0x38, 0x30, 0x30, 0x39, 0x63, 0x37, 0x34, 0x39, 0x39, 0x35, 0x66, 0x66, 0x66, 0x38, 0x62, 0x61, 0x66, 0x35, 0x34, 0x30, 0x31, 0x33, 0x38, 0x38, 0x38, 0x31, 0x66, 0x37, 0x32, 0x64, 0x33, 0x37, 0x66, 0x62, 0x63, 0x66, 0x35, 0x36, 0x31, 0x31, 0x66, 0x63, 0x30, 0x33, 0x38, 0x39, 0x66, 0x63, 0x65, 0x31, 0x31, 0x65, 0x31, 0x62, 0x63, 0x64, 0x33, 0x66, 0x31, 0x38, 0x38, 0x35, 0x66, 0x66, 0x35, 0x32, 0x38, 0x30, 0x61, 0x31, 0x31, 0x35, 0x30, 0x38, 0x65, 0x34, 0x66, 0x61, 0x34, 0x37, 0x61, 0x39, 0x39, 0x33, 0x64, 0x33, 0x37, 0x30, 0x36, 0x30, 0x36, 0x37, 0x32, 0x36, 0x34, 0x63, 0x61, 0x33, 0x34, 0x38, 0x32, 0x62, 0x30, 0x32, 0x63, 0x38, 0x36, 0x39, 0x32, 0x63, 0x66, 0x39, 0x38, 0x61, 0x63, 0x63, 0x38, 0x38, 0x32, 0x31, 0x30, 0x35, 0x31, 0x36, 0x37, 0x37, 0x61, 0x36, 0x36, 0x38, 0x38, 0x31, 0x38, 0x64, 0x35, 0x62, 0x65, 0x37, 0x61, 0x32, 0x38, 0x38, 0x38, 0x64, 0x64, 0x37, 0x31, 0x39, 0x36, 0x36, 0x33, 0x30, 0x61, 0x30, 0x39, 0x35, 0x64, 0x33, 0x30, 0x64, 0x65, 0x33, 0x32, 0x34, 0x33, 0x39, 0x30, 0x65, 0x35, 0x35, 0x34, 0x61, 0x31, 0x64, 0x62, 0x35, 0x31, 0x34, 0x31, 0x32, 0x33, 0x35, 0x65, 0x35, 0x35, 0x62, 0x62, 0x66, 0x62, 0x35, 0x37, 0x35, 0x31, 0x66, 0x64, 0x64, 0x66, 0x37, 0x30, 0x61, 0x38, 0x66, 0x61, 0x65, 0x32, 0x33, 0x64, 0x37, 0x35, 0x38, 0x31, 0x31, 0x37, 0x66, 0x37, 0x31, 0x61, 0x33, 0x35, 0x37, 0x32, 0x38, 0x37, 0x37, 0x34, 0x63, 0x64, 0x32, 0x36, 0x30, 0x39, 0x33, 0x39, 0x32, 0x37, 0x31, 0x39, 0x39, 0x64, 0x63, 0x63, 0x39, 0x61, 0x65, 0x32, 0x65, 0x35, 0x63, 0x61, 0x31, 0x32, 0x64, 0x63, 0x61, 0x39, 0x36, 0x64, 0x38, 0x31, 0x37, 0x36, 0x34, 0x61, 0x64, 0x33, 0x66, 0x33, 0x63, 0x63, 0x37, 0x34, 0x39, 0x33, 0x32, 0x33, 0x39, 0x65, 0x64, 0x39, 0x32, 0x37, 0x61, 0x65, 0x37, 0x32, 0x66, 0x35, 0x31, 0x35, 0x61, 0x33, 0x66, 0x63, 0x30, 0x39, 0x33, 0x38, 0x63, 0x63, 0x33, 0x63, 0x32, 0x36, 0x38, 0x32, 0x31, 0x33, 0x33, 0x65, 0x35, 0x38, 0x61, 0x61, 0x65, 0x33, 0x61, 0x62, 0x33, 0x38, 0x66, 0x30, 0x62, 0x64, 0x62, 0x35, 0x30, 0x66, 0x39, 0x65, 0x62, 0x32, 0x64, 0x37, 0x36, 0x30, 0x35, 0x64, 0x33, 0x30, 0x34, 0x37, 0x37, 0x36, 0x66, 0x35, 0x33, 0x65, 0x37, 0x32, 0x63, 0x35, 0x66, 0x33, 0x61, 0x64, 0x36, 0x33, 0x63, 0x32, 0x37, 0x64, 0x33, 0x38, 0x61, 0x63, 0x63, 0x30, 0x33, 0x63, 0x34, 0x35, 0x32, 0x31, 0x34, 0x31, 0x61, 0x63, 0x63, 0x33, 0x36, 0x33, 0x63, 0x31, 0x37, 0x63, 0x66, 0x65, 0x37, 0x32, 0x39, 0x30, 0x64, 0x61, 0x39, 0x66, 0x63, 0x33, 0x62, 0x61, 0x62, 0x61, 0x36, 0x32, 0x62, 0x32, 0x63, 0x66, 0x33, 0x30, 0x31, 0x64, 0x36, 0x64, 0x63, 0x66, 0x63, 0x34, 0x36, 0x32, 0x36, 0x30, 0x31, 0x34, 0x61, 0x65, 0x38, 0x66, 0x35, 0x65, 0x33, 0x30, 0x36, 0x39, 0x34, 0x66, 0x36, 0x30, 0x34, 0x34, 0x31, 0x32, 0x66, 0x61, 0x65, 0x62, 0x61, 0x36, 0x38, 0x35, 0x66, 0x31, 0x39, 0x61, 0x34, 0x34, 0x62, 0x37, 0x64, 0x62, 0x34, 0x63, 0x30, 0x33, 0x36, 0x63, 0x33, 0x63, 0x36, 0x63, 0x30, 0x35, 0x34, 0x30, 0x62, 0x65, 0x37, 0x32, 0x30, 0x30, 0x61, 0x30, 0x32, 0x63, 0x65, 0x30, 0x64, 0x33, 0x34, 0x31, 0x35, 0x34, 0x66, 0x62, 0x31, 0x61, 0x35, 0x61, 0x65, 0x38, 0x39, 0x30, 0x62, 0x32, 0x62, 0x63, 0x32, 0x64, 0x35, 0x62, 0x36, 0x63, 0x64, 0x64, 0x62, 0x61, 0x63, 0x66, 0x61, 0x34, 0x37, 0x61, 0x34, 0x38, 0x39, 0x38, 0x63, 0x33, 0x35, 0x62, 0x62, 0x31, 0x39, 0x32, 0x30, 0x62, 0x63, 0x35, 0x37, 0x62, 0x37, 0x32, 0x65, 0x65, 0x65, 0x33, 0x32, 0x63, 0x34, 0x38, 0x65, 0x36, 0x38, 0x36, 0x37, 0x33, 0x66, 0x61, 0x35, 0x34, 0x64, 0x39, 0x33, 0x63, 0x35, 0x64, 0x32, 0x32, 0x62, 0x62, 0x38, 0x35, 0x61, 0x31, 0x61, 0x34, 0x65, 0x39, 0x35, 0x37, 0x36, 0x30, 0x31, 0x62, 0x38, 0x65, 0x63, 0x64, 0x64, 0x33, 0x35, 0x62, 0x30, 0x34, 0x32, 0x37, 0x64, 0x32, 0x33, 0x31, 0x31, 0x37, 0x30, 0x36, 0x30, 0x33, 0x39, 0x64, 0x39, 0x31, 0x30, 0x33, 0x34, 0x34, 0x35, 0x36, 0x31, 0x62, 0x36, 0x31, 0x35, 0x34, 0x30, 0x36, 0x65, 0x37, 0x63, 0x37, 0x39, 0x30, 0x64, 0x34, 0x66, 0x35, 0x30, 0x65, 0x33, 0x37, 0x64, 0x39, 0x35, 0x63, 0x30, 0x65, 0x31, 0x35, 0x66, 0x63, 0x65, 0x35, 0x65, 0x34, 0x38, 0x34, 0x38, 0x36, 0x31, 0x31, 0x31, 0x34, 0x66, 0x61, 0x38, 0x38, 0x61, 0x62, 0x63, 0x36, 0x32, 0x65, 0x34, 0x34, 0x36, 0x63, 0x66, 0x62, 0x36, 0x64, 0x36, 0x38, 0x32, 0x61, 0x36, 0x62, 0x61, 0x32, 0x33, 0x36, 0x65, 0x33, 0x30, 0x39, 0x37, 0x32, 0x66, 0x33, 0x61, 0x61, 0x38, 0x63, 0x37, 0x36, 0x64, 0x33, 0x39, 0x64, 0x61, 0x33, 0x31, 0x65, 0x64, 0x36, 0x61, 0x32, 0x34, 0x61, 0x36, 0x30, 0x64, 0x33, 0x32, 0x34, 0x34, 0x65, 0x33, 0x64, 0x33, 0x34, 0x37, 0x36, 0x32, 0x32, 0x34, 0x35, 0x38, 0x30, 0x63, 0x39, 0x66, 0x61, 0x38, 0x36, 0x66, 0x37, 0x61, 0x39, 0x61, 0x64, 0x63, 0x32, 0x66, 0x32, 0x33, 0x37, 0x37, 0x38, 0x35, 0x66, 0x66, 0x65, 0x36, 0x35, 0x36, 0x61, 0x37, 0x34, 0x61, 0x37, 0x39, 0x31, 0x62, 0x34, 0x35, 0x63, 0x34, 0x38, 0x36, 0x64, 0x38, 0x33, 0x33, 0x36, 0x39, 0x35, 0x64, 0x36, 0x38, 0x65, 0x62, 0x34, 0x35, 0x64, 0x64, 0x38, 0x30, 0x61, 0x37, 0x32, 0x35, 0x34, 0x62, 0x32, 0x32, 0x39, 0x39, 0x36, 0x61, 0x65, 0x65, 0x38, 0x62, 0x63, 0x31, 0x64, 0x36, 0x63, 0x64, 0x65, 0x31, 0x35, 0x31, 0x34, 0x32, 0x64, 0x39, 0x32, 0x35, 0x62, 0x33, 0x63, 0x61, 0x31, 0x61, 0x33, 0x36, 0x64, 0x38, 0x66, 0x34, 0x38, 0x30, 0x33, 0x34, 0x35, 0x30, 0x35, 0x66, 0x38, 0x65, 0x61, 0x38, 0x38, 0x63, 0x33, 0x38, 0x39, 0x36, 0x33, 0x65, 0x62, 0x37, 0x32, 0x64, 0x65, 0x62, 0x65, 0x61, 0x65, 0x30, 0x66, 0x37, 0x36, 0x34, 0x34, 0x30, 0x34, 0x34, 0x34, 0x38, 0x34, 0x62, 0x37, 0x31, 0x38, 0x37, 0x65, 0x33, 0x38, 0x64, 0x63, 0x30, 0x33, 0x36, 0x36, 0x64, 0x31, 0x35, 0x64, 0x31, 0x62, 0x61, 0x64, 0x66, 0x63, 0x61, 0x61, 0x37, 0x35, 0x66, 0x65, 0x62, 0x65, 0x36, 0x36, 0x30, 0x33, 0x36, 0x32, 0x30, 0x64, 0x62, 0x36, 0x34, 0x38, 0x37, 0x32, 0x36, 0x31, 0x33, 0x37, 0x35, 0x64, 0x65, 0x39, 0x30, 0x30, 0x30, 0x39, 0x35, 0x31, 0x36, 0x33, 0x32, 0x66, 0x65, 0x36, 0x32, 0x65, 0x35, 0x32, 0x66, 0x65, 0x65, 0x34, 0x38, 0x32, 0x31, 0x35, 0x66, 0x39, 0x36, 0x30, 0x31, 0x32, 0x38, 0x64, 0x62, 0x36, 0x62, 0x37, 0x66, 0x63, 0x61, 0x61, 0x36, 0x63, 0x30, 0x36, 0x65, 0x34, 0x62, 0x30, 0x38, 0x30, 0x64, 0x32, 0x65, 0x63, 0x37, 0x32, 0x64, 0x31, 0x65, 0x62, 0x34, 0x65, 0x36, 0x39, 0x64, 0x30, 0x31, 0x32, 0x66, 0x30, 0x66, 0x65, 0x62, 0x38, 0x35, 0x38, 0x64, 0x63, 0x37, 0x32, 0x61, 0x39, 0x63, 0x61, 0x30, 0x63, 0x32, 0x30, 0x38, 0x39, 0x37, 0x33, 0x63, 0x36, 0x35, 0x35, 0x63, 0x36, 0x33, 0x63, 0x37, 0x63, 0x63, 0x65, 0x39, 0x66, 0x39, 0x37, 0x30, 0x31, 0x32, 0x63, 0x34, 0x61, 0x30, 0x63, 0x30, 0x61, 0x37, 0x32, 0x30, 0x35, 0x33, 0x36, 0x37, 0x37, 0x37, 0x39, 0x65, 0x39, 0x35, 0x39, 0x33, 0x30, 0x35, 0x61, 0x36, 0x35, 0x33, 0x32, 0x36, 0x32, 0x64, 0x35, 0x64, 0x33, 0x37, 0x35, 0x61, 0x37, 0x62, 0x31, 0x33, 0x32, 0x32, 0x36, 0x66, 0x30, 0x62, 0x32, 0x32, 0x64, 0x66, 0x38, 0x64, 0x61, 0x35, 0x63, 0x63, 0x30, 0x30, 0x37, 0x39, 0x35, 0x61, 0x34, 0x30, 0x61, 0x30, 0x31, 0x63, 0x66, 0x37, 0x32, 0x66, 0x37, 0x64, 0x31, 0x36, 0x33, 0x32, 0x62, 0x65, 0x31, 0x61, 0x35, 0x65, 0x65, 0x31, 0x30, 0x31, 0x62, 0x37, 0x65, 0x37, 0x65, 0x64, 0x37, 0x61, 0x62, 0x64, 0x32, 0x32, 0x36, 0x35, 0x35, 0x63, 0x38, 0x64, 0x30, 0x30, 0x62, 0x34, 0x39, 0x34, 0x35, 0x37, 0x63, 0x36, 0x65, 0x31, 0x38, 0x64, 0x33, 0x30, 0x66, 0x34, 0x34, 0x32, 0x35, 0x65, 0x66, 0x61, 0x37, 0x65, 0x39, 0x37, 0x32, 0x35, 0x61, 0x36, 0x62, 0x66, 0x34, 0x62, 0x65, 0x63, 0x66, 0x30, 0x65, 0x34, 0x66, 0x62, 0x34, 0x35, 0x38, 0x30, 0x66, 0x61, 0x37, 0x66, 0x33, 0x33, 0x62, 0x62, 0x36, 0x33, 0x64, 0x37, 0x35, 0x31, 0x33, 0x62, 0x61, 0x37, 0x63, 0x65, 0x30, 0x31, 0x33, 0x63, 0x36, 0x66, 0x38, 0x37, 0x37, 0x33, 0x34, 0x35, 0x39, 0x65, 0x31, 0x36, 0x34, 0x62, 0x39, 0x38, 0x64, 0x30, 0x34, 0x36, 0x33, 0x63, 0x65, 0x31, 0x38, 0x63, 0x31, 0x36, 0x38, 0x65, 0x31, 0x33, 0x38, 0x31, 0x64, 0x38, 0x61, 0x37, 0x35, 0x64, 0x64, 0x66, 0x34, 0x62, 0x37, 0x38, 0x64, 0x36, 0x63, 0x66, 0x33, 0x33, 0x34, 0x63, 0x36, 0x32, 0x30, 0x62, 0x36, 0x31, 0x62, 0x65, 0x33, 0x35, 0x33, 0x64, 0x63, 0x64, 0x32, 0x33, 0x33, 0x34, 0x33, 0x61, 0x30, 0x33, 0x63, 0x66, 0x35, 0x30, 0x37, 0x35, 0x30, 0x37, 0x32, 0x30, 0x62, 0x61, 0x37, 0x37, 0x63, 0x33, 0x38, 0x30, 0x65, 0x63, 0x34, 0x63, 0x39, 0x64, 0x31, 0x65, 0x39, 0x39, 0x66, 0x38, 0x30, 0x36, 0x34, 0x32, 0x63, 0x32, 0x34, 0x34, 0x66, 0x37, 0x35, 0x62, 0x62, 0x32, 0x38, 0x65, 0x39, 0x66, 0x31, 0x32, 0x65, 0x30, 0x62, 0x31, 0x35, 0x34, 0x61, 0x63, 0x61, 0x30, 0x63, 0x38, 0x30, 0x34, 0x31, 0x31, 0x39, 0x38, 0x64, 0x38, 0x37, 0x33, 0x62, 0x36, 0x62, 0x37, 0x35, 0x39, 0x63, 0x64, 0x33, 0x66, 0x30, 0x62, 0x30, 0x30, 0x64, 0x31, 0x34, 0x64, 0x65, 0x35, 0x36, 0x33, 0x33, 0x64, 0x65, 0x66, 0x31, 0x36, 0x64, 0x61, 0x32, 0x35, 0x64, 0x30, 0x39, 0x65, 0x62, 0x32, 0x35, 0x62, 0x64, 0x31, 0x61, 0x62, 0x37, 0x39, 0x66, 0x38, 0x61, 0x64, 0x61, 0x32, 0x62, 0x39, 0x62, 0x65, 0x34, 0x66, 0x33, 0x65, 0x30, 0x66, 0x62, 0x37, 0x32, 0x61, 0x31, 0x62, 0x37, 0x63, 0x32, 0x33, 0x62, 0x37, 0x38, 0x30, 0x30, 0x30, 0x66, 0x33, 0x33, 0x30, 0x31, 0x64, 0x39, 0x31, 0x62, 0x35, 0x64, 0x65, 0x66, 0x39, 0x36, 0x39, 0x65, 0x38, 0x34, 0x39, 0x39, 0x36, 0x33, 0x62, 0x66, 0x39, 0x38, 0x38, 0x38, 0x63, 0x35, 0x36, 0x61, 0x35, 0x30, 0x66, 0x35, 0x66, 0x34, 0x64, 0x66, 0x36, 0x32, 0x62, 0x63, 0x37, 0x33, 0x63, 0x63, 0x37, 0x32, 0x33, 0x65, 0x36, 0x32, 0x35, 0x34, 0x63, 0x39, 0x30, 0x33, 0x30, 0x32, 0x64, 0x31, 0x37, 0x66, 0x34, 0x65, 0x38, 0x62, 0x66, 0x38, 0x61, 0x66, 0x64, 0x65, 0x37, 0x30, 0x36, 0x39, 0x38, 0x65, 0x61, 0x37, 0x35, 0x34, 0x34, 0x39, 0x62, 0x62, 0x36, 0x65, 0x65, 0x36, 0x65, 0x33, 0x34, 0x38, 0x38, 0x39, 0x38, 0x32, 0x64, 0x32, 0x31, 0x39, 0x64, 0x36, 0x39, 0x37, 0x34, 0x61, 0x36, 0x36, 0x36, 0x63, 0x65, 0x37, 0x37, 0x64, 0x61, 0x66, 0x63, 0x62, 0x37, 0x61, 0x31, 0x61, 0x65, 0x30, 0x61, 0x35, 0x30, 0x62, 0x62, 0x61, 0x34, 0x36, 0x65, 0x30, 0x39, 0x64, 0x65, 0x33, 0x37, 0x63, 0x39, 0x66, 0x30, 0x30, 0x62, 0x63, 0x65, 0x32, 0x34, 0x38, 0x33, 0x35, 0x65, 0x39, 0x32, 0x61, 0x30, 0x32, 0x36, 0x61, 0x39, 0x61, 0x34, 0x36, 0x63, 0x64, 0x65, 0x65, 0x32, 0x63, 0x37, 0x32, 0x34, 0x65, 0x62, 0x61, 0x39, 0x37, 0x33, 0x63, 0x34, 0x30, 0x37, 0x61, 0x65, 0x39, 0x62, 0x34, 0x62, 0x39, 0x61, 0x61, 0x61, 0x30, 0x63, 0x39, 0x65, 0x63, 0x62, 0x37, 0x64, 0x39, 0x66, 0x65, 0x36, 0x39, 0x34, 0x62, 0x31, 0x33, 0x39, 0x39, 0x64, 0x34, 0x38, 0x65, 0x33, 0x39, 0x37, 0x37, 0x38, 0x31, 0x64, 0x63, 0x38, 0x62, 0x30, 0x36, 0x64, 0x36, 0x62, 0x37, 0x38, 0x31, 0x37, 0x32, 0x35, 0x32, 0x32, 0x66, 0x33, 0x64, 0x30, 0x30, 0x65, 0x34, 0x61, 0x33, 0x61, 0x33, 0x33, 0x62, 0x65, 0x31, 0x31, 0x63, 0x36, 0x37, 0x34, 0x36, 0x64, 0x65, 0x32, 0x33, 0x63, 0x37, 0x63, 0x66, 0x37, 0x65, 0x35, 0x63, 0x38, 0x62, 0x63, 0x66, 0x34, 0x33, 0x38, 0x31, 0x64, 0x35, 0x61, 0x63, 0x38, 0x66, 0x66, 0x32, 0x36, 0x34, 0x33, 0x65, 0x65, 0x63, 0x61, 0x36, 0x34, 0x38, 0x37, 0x32, 0x38, 0x31, 0x64, 0x38, 0x37, 0x36, 0x62, 0x36, 0x31, 0x63, 0x30, 0x31, 0x66, 0x33, 0x31, 0x34, 0x63, 0x33, 0x37, 0x35, 0x61, 0x66, 0x38, 0x37, 0x62, 0x38, 0x33, 0x65, 0x36, 0x64, 0x62, 0x35, 0x34, 0x61, 0x63, 0x36, 0x65, 0x37, 0x64, 0x37, 0x64, 0x65, 0x64, 0x35, 0x30, 0x34, 0x61, 0x66, 0x38, 0x64, 0x65, 0x62, 0x66, 0x36, 0x32, 0x62, 0x66, 0x35, 0x37, 0x35, 0x66, 0x37, 0x36, 0x35, 0x31, 0x31, 0x65, 0x31, 0x33, 0x33, 0x37, 0x37, 0x30, 0x30, 0x39, 0x61, 0x36, 0x63, 0x63, 0x61, 0x36, 0x61, 0x36, 0x34, 0x32, 0x62, 0x62, 0x64, 0x61, 0x30, 0x39, 0x36, 0x66, 0x31, 0x63, 0x65, 0x34, 0x63, 0x64, 0x61, 0x35, 0x31, 0x31, 0x37, 0x33, 0x36, 0x31, 0x34, 0x32, 0x36, 0x62, 0x31, 0x33, 0x61, 0x37, 0x37, 0x63, 0x37, 0x34, 0x35, 0x30, 0x32, 0x37, 0x61, 0x37, 0x38, 0x32, 0x30, 0x32, 0x61, 0x37, 0x37, 0x64, 0x61, 0x66, 0x36, 0x35, 0x63, 0x66, 0x38, 0x32, 0x63, 0x62, 0x62, 0x31, 0x39, 0x33, 0x38, 0x62, 0x30, 0x64, 0x32, 0x61, 0x62, 0x64, 0x64, 0x62, 0x64, 0x39, 0x64, 0x63, 0x32, 0x64, 0x62, 0x36, 0x64, 0x63, 0x31, 0x33, 0x33, 0x63, 0x34, 0x62, 0x39, 0x63, 0x39, 0x36, 0x36, 0x64, 0x61, 0x31, 0x65, 0x31, 0x30, 0x33, 0x63, 0x62, 0x31, 0x30, 0x31, 0x32, 0x33, 0x36, 0x63, 0x62, 0x30, 0x61, 0x30, 0x38, 0x36, 0x61, 0x64, 0x34, 0x39, 0x39, 0x66, 0x30, 0x65, 0x63, 0x61, 0x39, 0x61, 0x39, 0x34, 0x34, 0x61, 0x63, 0x65, 0x63, 0x64, 0x38, 0x64, 0x62, 0x62, 0x36, 0x32, 0x30, 0x65, 0x34, 0x63, 0x62, 0x35, 0x33, 0x37, 0x39, 0x62, 0x63, 0x32, 0x33, 0x37, 0x36, 0x31, 0x63, 0x36, 0x37, 0x32, 0x39, 0x33, 0x31, 0x39, 0x33, 0x65, 0x30, 0x32, 0x37, 0x32, 0x30, 0x37, 0x34, 0x34, 0x63, 0x62, 0x61, 0x62, 0x31, 0x62, 0x66, 0x65, 0x62, 0x39, 0x31, 0x64, 0x65, 0x30, 0x34, 0x34, 0x63, 0x38, 0x32, 0x39, 0x31, 0x32, 0x30, 0x34, 0x35, 0x65, 0x66, 0x65, 0x39, 0x32, 0x66, 0x33, 0x38, 0x35, 0x38, 0x35, 0x31, 0x35, 0x63, 0x37, 0x34, 0x64, 0x37, 0x63, 0x31, 0x64, 0x66, 0x30, 0x38, 0x66, 0x34, 0x35, 0x37, 0x65, 0x39, 0x64, 0x34, 0x63, 0x37, 0x32, 0x62, 0x34, 0x30, 0x39, 0x36, 0x39, 0x62, 0x32, 0x33, 0x31, 0x63, 0x36, 0x32, 0x64, 0x34, 0x66, 0x31, 0x61, 0x37, 0x62, 0x61, 0x39, 0x37, 0x61, 0x66, 0x31, 0x36, 0x30, 0x65, 0x33, 0x65, 0x39, 0x63, 0x61, 0x64, 0x37, 0x37, 0x32, 0x66, 0x39, 0x66, 0x31, 0x32, 0x39, 0x37, 0x61, 0x65, 0x31, 0x35, 0x65, 0x32, 0x33, 0x38, 0x38, 0x66, 0x35, 0x35, 0x39, 0x63, 0x64, 0x64, 0x39, 0x32, 0x36, 0x66, 0x62, 0x32, 0x36, 0x31, 0x34, 0x39, 0x61, 0x30, 0x35, 0x34, 0x36, 0x62, 0x33, 0x35, 0x35, 0x35, 0x66, 0x39, 0x65, 0x33, 0x31, 0x64, 0x31, 0x37, 0x34, 0x31, 0x38, 0x34, 0x66, 0x65, 0x34, 0x37, 0x65, 0x36, 0x30, 0x61, 0x35, 0x64, 0x31, 0x65, 0x39, 0x61, 0x64, 0x63, 0x39, 0x65, 0x38, 0x31, 0x61, 0x62, 0x33, 0x39, 0x31, 0x30, 0x63, 0x32, 0x63, 0x64, 0x37, 0x62, 0x38, 0x37, 0x32, 0x37, 0x33, 0x33, 0x30, 0x66, 0x39, 0x34, 0x61, 0x64, 0x39, 0x39, 0x35, 0x38, 0x33, 0x64, 0x30, 0x36, 0x65, 0x36, 0x33, 0x66, 0x30, 0x64, 0x37, 0x65, 0x39, 0x61, 0x32, 0x63, 0x62, 0x35, 0x62, 0x39, 0x62, 0x37, 0x64, 0x31, 0x34, 0x32, 0x30, 0x39, 0x35, 0x30, 0x62, 0x37, 0x38, 0x32, 0x31, 0x36, 0x32, 0x33, 0x30, 0x39, 0x39, 0x32, 0x65, 0x39, 0x64, 0x32, 0x36, 0x31, 0x34, 0x37, 0x32, 0x65, 0x66, 0x35, 0x63, 0x37, 0x33, 0x61, 0x38, 0x63, 0x36, 0x31, 0x38, 0x32, 0x32, 0x63, 0x38, 0x37, 0x61, 0x35, 0x39, 0x64, 0x37, 0x38, 0x62, 0x36, 0x66, 0x31, 0x64, 0x66, 0x36, 0x38, 0x39, 0x39, 0x66, 0x64, 0x63, 0x39, 0x35, 0x39, 0x33, 0x33, 0x61, 0x39, 0x34, 0x62, 0x35, 0x65, 0x64, 0x35, 0x66, 0x65, 0x64, 0x64, 0x33, 0x61, 0x34, 0x35, 0x61, 0x33, 0x33, 0x65, 0x33, 0x37, 0x32, 0x66, 0x37, 0x65, 0x65, 0x66, 0x66, 0x62, 0x31, 0x30, 0x61, 0x30, 0x37, 0x37, 0x66, 0x32, 0x34, 0x66, 0x32, 0x39, 0x66, 0x31, 0x36, 0x64, 0x36, 0x65, 0x32, 0x61, 0x37, 0x65, 0x61, 0x66, 0x64, 0x38, 0x36, 0x35, 0x36, 0x31, 0x38, 0x65, 0x31, 0x30, 0x34, 0x66, 0x33, 0x66, 0x61, 0x33, 0x31, 0x30, 0x63, 0x39, 0x38, 0x30, 0x39, 0x36, 0x39, 0x34, 0x36, 0x34, 0x66, 0x38, 0x61, 0x36, 0x36, 0x31, 0x30, 0x63, 0x37, 0x64, 0x65, 0x39, 0x66, 0x37, 0x63, 0x35, 0x34, 0x64, 0x61, 0x31, 0x30, 0x66, 0x39, 0x33, 0x39, 0x66, 0x64, 0x39, 0x65, 0x65, 0x62, 0x66, 0x62, 0x61, 0x36, 0x62, 0x36, 0x35, 0x37, 0x38, 0x35, 0x33, 0x31, 0x62, 0x33, 0x36, 0x35, 0x34, 0x66, 0x38, 0x36, 0x36, 0x39, 0x30, 0x30, 0x35, 0x35, 0x35, 0x34, 0x38, 0x62, 0x65, 0x65, 0x62, 0x66, 0x65, 0x37, 0x37, 0x32, 0x31, 0x66, 0x39, 0x35, 0x31, 0x63, 0x62, 0x33, 0x33, 0x35, 0x62, 0x66, 0x34, 0x39, 0x36, 0x62, 0x34, 0x33, 0x37, 0x64, 0x64, 0x66, 0x65, 0x33, 0x62, 0x61, 0x31, 0x66, 0x65, 0x64, 0x63, 0x39, 0x35, 0x64, 0x64, 0x61, 0x39, 0x30, 0x63, 0x39, 0x62, 0x32, 0x38, 0x38, 0x35, 0x62, 0x32, 0x32, 0x62, 0x66, 0x61, 0x65, 0x66, 0x36, 0x30, 0x65, 0x30, 0x38, 0x62, 0x31, 0x30, 0x63, 0x37, 0x32, 0x65, 0x65, 0x37, 0x65, 0x31, 0x37, 0x39, 0x64, 0x38, 0x62, 0x66, 0x31, 0x37, 0x37, 0x37, 0x36, 0x33, 0x37, 0x65, 0x61, 0x66, 0x30, 0x66, 0x62, 0x31, 0x62, 0x64, 0x62, 0x34, 0x36, 0x32, 0x39, 0x31, 0x39, 0x63, 0x63, 0x37, 0x32, 0x32, 0x31, 0x36, 0x35, 0x36, 0x64, 0x34, 0x34, 0x63, 0x38, 0x61, 0x65, 0x36, 0x39, 0x36, 0x33, 0x37, 0x38, 0x65, 0x66, 0x31, 0x35, 0x63, 0x66, 0x37, 0x32, 0x33, 0x37, 0x61, 0x30, 0x32, 0x30, 0x31, 0x62, 0x35, 0x38, 0x35, 0x62, 0x31, 0x39, 0x34, 0x33, 0x63, 0x63, 0x65, 0x31, 0x61, 0x64, 0x30, 0x34, 0x65, 0x34, 0x39, 0x39, 0x31, 0x66, 0x38, 0x33, 0x32, 0x66, 0x65, 0x37, 0x62, 0x63, 0x32, 0x63, 0x35, 0x63, 0x61, 0x36, 0x66, 0x30, 0x66, 0x65, 0x30, 0x61, 0x62, 0x35, 0x38, 0x31, 0x33, 0x65, 0x66, 0x39, 0x39, 0x62, 0x37, 0x66, 0x37, 0x32, 0x32, 0x37, 0x36, 0x31, 0x66, 0x34, 0x61, 0x34, 0x39, 0x37, 0x39, 0x64, 0x31, 0x64, 0x37, 0x37, 0x38, 0x64, 0x36, 0x36, 0x63, 0x31, 0x64, 0x65, 0x30, 0x37, 0x35, 0x61, 0x33, 0x66, 0x61, 0x36, 0x61, 0x33, 0x64, 0x65, 0x37, 0x37, 0x31, 0x62, 0x37, 0x31, 0x34, 0x65, 0x36, 0x66, 0x39, 0x66, 0x62, 0x38, 0x64, 0x64, 0x38, 0x36, 0x32, 0x65, 0x34, 0x65, 0x36, 0x38, 0x64, 0x36, 0x37, 0x32, 0x63, 0x64, 0x38, 0x64, 0x37, 0x35, 0x65, 0x37, 0x61, 0x33, 0x65, 0x34, 0x31, 0x39, 0x65, 0x37, 0x63, 0x64, 0x30, 0x63, 0x36, 0x62, 0x34, 0x38, 0x39, 0x33, 0x62, 0x39, 0x33, 0x39, 0x66, 0x65, 0x62, 0x35, 0x64, 0x34, 0x38, 0x66, 0x39, 0x35, 0x66, 0x38, 0x65, 0x36, 0x39, 0x65, 0x62, 0x30, 0x61, 0x35, 0x63, 0x62, 0x34, 0x62, 0x33, 0x38, 0x63, 0x65, 0x61, 0x64, 0x35, 0x62, 0x32, 0x61, 0x35, 0x39, 0x63, 0x63, 0x30, 0x62, 0x64, 0x39, 0x62, 0x62, 0x64, 0x39, 0x33, 0x65, 0x66, 0x31, 0x66, 0x36, 0x30, 0x62, 0x64, 0x65, 0x36, 0x31, 0x63, 0x33, 0x61, 0x37, 0x35, 0x36, 0x35, 0x64, 0x37, 0x32, 0x37, 0x66, 0x33, 0x34, 0x63, 0x30, 0x66, 0x62, 0x63, 0x62, 0x61, 0x63, 0x63, 0x61, 0x37, 0x32, 0x39, 0x38, 0x36, 0x38, 0x30, 0x39, 0x30, 0x30, 0x38, 0x62, 0x37, 0x39, 0x35, 0x31, 0x31, 0x36, 0x31, 0x37, 0x35, 0x63, 0x63, 0x39, 0x35, 0x66, 0x65, 0x34, 0x38, 0x33, 0x63, 0x38, 0x62, 0x33, 0x39, 0x64, 0x65, 0x37, 0x36, 0x33, 0x61, 0x36, 0x36, 0x65, 0x65, 0x35, 0x31, 0x37, 0x64, 0x31, 0x35, 0x35, 0x66, 0x61, 0x61, 0x64, 0x32, 0x61, 0x61, 0x36, 0x31, 0x32, 0x39, 0x62, 0x66, 0x39, 0x65, 0x32, 0x61, 0x61, 0x37, 0x61, 0x39, 0x34, 0x35, 0x36, 0x65, 0x32, 0x37, 0x32, 0x39, 0x39, 0x33, 0x36, 0x61, 0x30, 0x37, 0x65, 0x35, 0x32, 0x63, 0x35, 0x33, 0x61, 0x37, 0x61, 0x33, 0x36, 0x38, 0x38, 0x61, 0x61, 0x37, 0x62, 0x61, 0x64, 0x31, 0x39, 0x34, 0x34, 0x65, 0x34, 0x31, 0x62, 0x61, 0x32, 0x33, 0x64, 0x61, 0x33, 0x32, 0x65, 0x36, 0x64, 0x36, 0x38, 0x30, 0x33, 0x37, 0x64, 0x37, 0x35, 0x63, 0x66, 0x38, 0x30, 0x61, 0x34, 0x35, 0x31, 0x32, 0x34, 0x37, 0x32, 0x38, 0x63, 0x66, 0x65, 0x35, 0x65, 0x38, 0x37, 0x31, 0x36, 0x32, 0x30, 0x30, 0x63, 0x61, 0x62, 0x66, 0x62, 0x33, 0x63, 0x36, 0x37, 0x39, 0x34, 0x35, 0x62, 0x33, 0x32, 0x65, 0x36, 0x61, 0x62, 0x38, 0x30, 0x32, 0x65, 0x61, 0x35, 0x32, 0x31, 0x33, 0x65, 0x66, 0x38, 0x63, 0x38, 0x64, 0x32, 0x39, 0x37, 0x36, 0x33, 0x64, 0x65, 0x35, 0x39, 0x66, 0x32, 0x37, 0x63, 0x64, 0x65, 0x32, 0x35, 0x33, 0x33, 0x39, 0x36, 0x65, 0x62, 0x38, 0x35, 0x38, 0x33, 0x34, 0x63, 0x30, 0x61, 0x63, 0x36, 0x64, 0x37, 0x62, 0x37, 0x32, 0x39, 0x66, 0x35, 0x31, 0x65, 0x39, 0x66, 0x62, 0x35, 0x66, 0x61, 0x30, 0x37, 0x33, 0x31, 0x36, 0x37, 0x30, 0x66, 0x38, 0x33, 0x66, 0x37, 0x31, 0x64, 0x36, 0x39, 0x38, 0x38, 0x39, 0x33, 0x37, 0x66, 0x61, 0x31, 0x30, 0x39, 0x34, 0x30, 0x66, 0x32, 0x37, 0x32, 0x66, 0x32, 0x37, 0x62, 0x61, 0x33, 0x35, 0x34, 0x30, 0x36, 0x64, 0x34, 0x30, 0x31, 0x30, 0x33, 0x34, 0x37, 0x33, 0x39, 0x37, 0x37, 0x63, 0x34, 0x34, 0x64, 0x63, 0x61, 0x61, 0x63, 0x33, 0x32, 0x33, 0x61, 0x66, 0x37, 0x31, 0x32, 0x39, 0x66, 0x33, 0x64, 0x65, 0x63, 0x66, 0x33, 0x32, 0x63, 0x39, 0x65, 0x35, 0x36, 0x61, 0x32, 0x34, 0x37, 0x36, 0x36, 0x35, 0x38, 0x30, 0x63, 0x30, 0x38, 0x62, 0x36, 0x64, 0x65, 0x37, 0x39, 0x36, 0x37, 0x65, 0x62, 0x64, 0x65, 0x31, 0x62, 0x32, 0x64, 0x39, 0x61, 0x65, 0x63, 0x32, 0x64, 0x32, 0x66, 0x31, 0x63, 0x61, 0x32, 0x37, 0x39, 0x34, 0x39, 0x66, 0x38, 0x39, 0x64, 0x33, 0x39, 0x62, 0x31, 0x33, 0x64, 0x63, 0x64, 0x66, 0x30, 0x34, 0x33, 0x37, 0x64, 0x63, 0x64, 0x33, 0x31, 0x33, 0x66, 0x65, 0x37, 0x62, 0x64, 0x34, 0x36, 0x36, 0x33, 0x62, 0x34, 0x62, 0x38, 0x38, 0x61, 0x38, 0x32, 0x33, 0x33, 0x34, 0x65, 0x64, 0x32, 0x37, 0x39, 0x64, 0x37, 0x61, 0x64, 0x35, 0x65, 0x64, 0x38, 0x39, 0x61, 0x32, 0x62, 0x62, 0x39, 0x33, 0x35, 0x34, 0x63, 0x30, 0x32, 0x66, 0x33, 0x35, 0x32, 0x34, 0x66, 0x35, 0x66, 0x39, 0x30, 0x64, 0x37, 0x63, 0x66, 0x65, 0x37, 0x61, 0x61, 0x65, 0x35, 0x36, 0x39, 0x65, 0x31, 0x64, 0x36, 0x36, 0x31, 0x61, 0x63, 0x64, 0x63, 0x64, 0x37, 0x34, 0x66, 0x64, 0x63, 0x37, 0x34, 0x39, 0x38, 0x33, 0x31, 0x65, 0x36, 0x62, 0x30, 0x38, 0x39, 0x66, 0x31, 0x35, 0x30, 0x32, 0x34, 0x36, 0x35, 0x64, 0x39, 0x32, 0x32, 0x38, 0x62, 0x31, 0x39, 0x35, 0x61, 0x64, 0x30, 0x32, 0x38, 0x31, 0x36, 0x33, 0x31, 0x30, 0x64, 0x62, 0x34, 0x66, 0x61, 0x66, 0x65, 0x64, 0x34, 0x66, 0x32, 0x66, 0x33, 0x37, 0x32, 0x31, 0x37, 0x30, 0x36, 0x63, 0x65, 0x32, 0x31, 0x66, 0x36, 0x31, 0x34, 0x33, 0x37, 0x39, 0x61, 0x32, 0x33, 0x36, 0x32, 0x30, 0x32, 0x37, 0x64, 0x61, 0x32, 0x35, 0x32, 0x38, 0x66, 0x30, 0x63, 0x36, 0x32, 0x37, 0x34, 0x38, 0x33, 0x37, 0x31, 0x38, 0x39, 0x62, 0x63, 0x64, 0x32, 0x36, 0x31, 0x35, 0x38, 0x34, 0x64, 0x36, 0x63, 0x30, 0x33, 0x66, 0x63, 0x34, 0x39, 0x36, 0x63, 0x36, 0x61, 0x38, 0x65, 0x30, 0x64, 0x32, 0x64, 0x32, 0x37, 0x37, 0x37, 0x34, 0x38, 0x36, 0x35, 0x35, 0x30, 0x34, 0x39, 0x36, 0x61, 0x31, 0x64, 0x31, 0x35, 0x34, 0x37, 0x63, 0x63, 0x37, 0x62, 0x63, 0x36, 0x30, 0x30, 0x31, 0x65, 0x32, 0x34, 0x63, 0x33, 0x34, 0x36, 0x30, 0x34, 0x31, 0x33, 0x33, 0x31, 0x63, 0x38, 0x39, 0x39, 0x65, 0x32, 0x39, 0x32, 0x31, 0x34, 0x66, 0x38, 0x38, 0x38, 0x37, 0x32, 0x66, 0x33, 0x61, 0x34, 0x32, 0x30, 0x66, 0x34, 0x30, 0x64, 0x31, 0x33, 0x66, 0x32, 0x31, 0x64, 0x37, 0x31, 0x66, 0x61, 0x33, 0x39, 0x32, 0x36, 0x64, 0x31, 0x39, 0x62, 0x31, 0x34, 0x38, 0x37, 0x30, 0x35, 0x32, 0x34, 0x61, 0x66, 0x65, 0x64, 0x34, 0x33, 0x38, 0x31, 0x62, 0x63, 0x66, 0x36, 0x37, 0x61, 0x64, 0x30, 0x34, 0x38, 0x65, 0x34, 0x30, 0x32, 0x38, 0x61, 0x34, 0x62, 0x37, 0x32, 0x32, 0x36, 0x64, 0x30, 0x65, 0x38, 0x33, 0x33, 0x65, 0x62, 0x64, 0x38, 0x38, 0x34, 0x64, 0x34, 0x31, 0x30, 0x63, 0x31, 0x38, 0x61, 0x31, 0x31, 0x31, 0x31, 0x64, 0x37, 0x32, 0x39, 0x33, 0x33, 0x66, 0x65, 0x33, 0x33, 0x61, 0x36, 0x32, 0x38, 0x63, 0x31, 0x61, 0x65, 0x62, 0x66, 0x33, 0x64, 0x35, 0x39, 0x33, 0x63, 0x62, 0x62, 0x63, 0x61, 0x37, 0x31, 0x30, 0x38, 0x64, 0x33, 0x33, 0x64, 0x32, 0x61, 0x62, 0x35, 0x64, 0x31, 0x61, 0x64, 0x37, 0x31, 0x38, 0x64, 0x63, 0x63, 0x62, 0x39, 0x32, 0x35, 0x32, 0x38, 0x63, 0x61, 0x32, 0x34, 0x30, 0x62, 0x66, 0x38, 0x36, 0x62, 0x35, 0x62, 0x30, 0x66, 0x30, 0x39, 0x34, 0x66, 0x61, 0x35, 0x63, 0x39, 0x35, 0x36, 0x33, 0x35, 0x36, 0x62, 0x34, 0x64, 0x35, 0x36, 0x62, 0x36, 0x66, 0x38, 0x64, 0x64, 0x34, 0x65, 0x63, 0x37, 0x34, 0x37, 0x66, 0x66, 0x38, 0x35, 0x38, 0x34, 0x31, 0x63, 0x62, 0x62, 0x62, 0x30, 0x38, 0x30, 0x35, 0x34, 0x37, 0x64, 0x62, 0x39, 0x32, 0x66, 0x61, 0x66, 0x31, 0x61, 0x64, 0x62, 0x64, 0x62, 0x30, 0x39, 0x30, 0x37, 0x66, 0x61, 0x36, 0x35, 0x63, 0x32, 0x65, 0x37, 0x63, 0x36, 0x63, 0x33, 0x30, 0x62, 0x35, 0x37, 0x63, 0x39, 0x61, 0x62, 0x38, 0x66, 0x37, 0x62, 0x30, 0x39, 0x36, 0x37, 0x37, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x38, 0x37, 0x62, 0x31, 0x37, 0x63, 0x36, 0x63, 0x61, 0x65, 0x62, 0x66, 0x32, 0x35, 0x66, 0x32, 0x37, 0x62, 0x35, 0x38, 0x65, 0x64, 0x31, 0x39, 0x66, 0x38, 0x38, 0x31, 0x38, 0x65, 0x39, 0x39, 0x39, 0x36, 0x35, 0x61, 0x64, 0x66, 0x63, 0x39, 0x37, 0x35, 0x66, 0x62, 0x30, 0x66, 0x61, 0x31, 0x34, 0x63, 0x31, 0x35, 0x38, 0x33, 0x61, 0x36, 0x34, 0x33, 0x63, 0x35, 0x61, 0x64, 0x65, 0x61, 0x32, 0x30, 0x64, 0x66, 0x30, 0x33, 0x66, 0x30, 0x36, 0x66, 0x37, 0x34, 0x31, 0x65, 0x37, 0x66, 0x31, 0x39, 0x66, 0x30, 0x38, 0x64, 0x63, 0x66, 0x37, 0x38, 0x31, 0x31, 0x62, 0x31, 0x31, 0x66, 0x38, 0x62, 0x66, 0x61, 0x39, 0x34, 0x37, 0x63, 0x63, 0x63, 0x34, 0x66, 0x64, 0x30, 0x63, 0x33, 0x39, 0x38, 0x37, 0x63, 0x65, 0x34, 0x63, 0x65, 0x37, 0x32, 0x63, 0x35, 0x32, 0x36, 0x36, 0x30, 0x34, 0x61, 0x30, 0x64, 0x65, 0x66, 0x65, 0x34, 0x65, 0x30, 0x62, 0x61, 0x34, 0x65, 0x61, 0x61, 0x35, 0x37, 0x63, 0x35, 0x62, 0x36, 0x65, 0x65, 0x30, 0x62, 0x39, 0x61, 0x38, 0x38, 0x39, 0x62, 0x61, 0x36, 0x36, 0x32, 0x36, 0x35, 0x64, 0x32, 0x30, 0x63, 0x65, 0x34, 0x61, 0x62, 0x65, 0x39, 0x30, 0x36, 0x32, 0x64, 0x31, 0x61, 0x36, 0x35, 0x37, 0x32, 0x36, 0x62, 0x65, 0x34, 0x63, 0x37, 0x62, 0x36, 0x33, 0x31, 0x31, 0x39, 0x36, 0x61, 0x32, 0x64, 0x62, 0x33, 0x34, 0x33, 0x62, 0x63, 0x31, 0x34, 0x62, 0x38, 0x64, 0x33, 0x33, 0x36, 0x34, 0x30, 0x35, 0x34, 0x62, 0x39, 0x33, 0x32, 0x38, 0x31, 0x62, 0x63, 0x61, 0x38, 0x62, 0x64, 0x33, 0x63, 0x33, 0x64, 0x64, 0x32, 0x39, 0x62, 0x31, 0x61, 0x38, 0x64, 0x62, 0x39, 0x62, 0x31, 0x30, 0x36, 0x34, 0x62, 0x61, 0x35, 0x37, 0x61, 0x61, 0x63, 0x35, 0x36, 0x35, 0x35, 0x30, 0x62, 0x38, 0x31, 0x62, 0x30, 0x31, 0x35, 0x65, 0x32, 0x30, 0x63, 0x65, 0x66, 0x61, 0x63, 0x35, 0x34, 0x35, 0x62, 0x39, 0x32, 0x66, 0x33, 0x65, 0x34, 0x37, 0x33, 0x65, 0x37, 0x35, 0x37, 0x31, 0x61, 0x37, 0x33, 0x35, 0x36, 0x33, 0x30, 0x39, 0x62, 0x62, 0x37, 0x35, 0x66, 0x63, 0x32, 0x39, 0x37, 0x34, 0x66, 0x36, 0x32, 0x62, 0x66, 0x37, 0x39, 0x65, 0x35, 0x31, 0x36, 0x39, 0x66, 0x63, 0x64, 0x38, 0x32, 0x61, 0x65, 0x63, 0x32, 0x35, 0x66, 0x65, 0x38, 0x36, 0x32, 0x30, 0x33, 0x35, 0x65, 0x32, 0x34, 0x34, 0x64, 0x62, 0x63, 0x37, 0x34, 0x66, 0x33, 0x33, 0x30, 0x34, 0x30, 0x38, 0x64, 0x39, 0x34, 0x37, 0x31, 0x61, 0x34, 0x61, 0x65, 0x61, 0x38, 0x62, 0x36, 0x33, 0x33, 0x33, 0x39, 0x37, 0x32, 0x66, 0x34, 0x39, 0x64, 0x66, 0x35, 0x34, 0x63, 0x32, 0x31, 0x30, 0x38, 0x39, 0x35, 0x31, 0x62, 0x37, 0x36, 0x31, 0x66, 0x63, 0x38, 0x66, 0x38, 0x31, 0x62, 0x64, 0x36, 0x61, 0x31, 0x38, 0x63, 0x36, 0x65, 0x30, 0x37, 0x36, 0x65, 0x31, 0x61, 0x34, 0x35, 0x64, 0x39, 0x34, 0x34, 0x36, 0x63, 0x38, 0x65, 0x65, 0x39, 0x61, 0x33, 0x37, 0x33, 0x36, 0x37, 0x65, 0x34, 0x64, 0x65, 0x37, 0x32, 0x65, 0x66, 0x37, 0x30, 0x65, 0x31, 0x32, 0x61, 0x65, 0x39, 0x32, 0x32, 0x62, 0x65, 0x61, 0x34, 0x64, 0x33, 0x34, 0x36, 0x34, 0x65, 0x35, 0x62, 0x34, 0x36, 0x34, 0x62, 0x39, 0x33, 0x32, 0x36, 0x65, 0x66, 0x66, 0x35, 0x33, 0x30, 0x33, 0x31, 0x36, 0x66, 0x30, 0x64, 0x31, 0x32, 0x37, 0x33, 0x30, 0x33, 0x36, 0x31, 0x65, 0x32, 0x37, 0x35, 0x39, 0x38, 0x32, 0x39, 0x35, 0x34, 0x33, 0x39, 0x39, 0x65, 0x33, 0x61, 0x62, 0x32, 0x65, 0x31, 0x33, 0x66, 0x32, 0x31, 0x31, 0x61, 0x65, 0x65, 0x66, 0x64, 0x30, 0x34, 0x33, 0x37, 0x39, 0x62, 0x36, 0x38, 0x64, 0x33, 0x38, 0x30, 0x36, 0x66, 0x61, 0x64, 0x36, 0x32, 0x66, 0x63, 0x35, 0x32, 0x37, 0x65, 0x62, 0x61, 0x31, 0x66, 0x66, 0x36, 0x35, 0x32, 0x37, 0x63, 0x37, 0x34, 0x65, 0x34, 0x66, 0x64, 0x31, 0x38, 0x64, 0x62, 0x34, 0x65, 0x30, 0x30, 0x64, 0x62, 0x65, 0x63, 0x32, 0x35, 0x34, 0x38, 0x66, 0x37, 0x63, 0x62, 0x34, 0x64, 0x37, 0x33, 0x36, 0x65, 0x39, 0x38, 0x62, 0x37, 0x36, 0x64, 0x34, 0x38, 0x63, 0x32, 0x63, 0x39, 0x63, 0x63, 0x33, 0x32, 0x35, 0x64, 0x66, 0x35, 0x35, 0x62, 0x38, 0x64, 0x63, 0x39, 0x39, 0x36, 0x38, 0x65, 0x34, 0x37, 0x36, 0x66, 0x30, 0x38, 0x30, 0x66, 0x33, 0x36, 0x32, 0x65, 0x37, 0x32, 0x38, 0x38, 0x36, 0x65, 0x64, 0x61, 0x66, 0x36, 0x30, 0x36, 0x64, 0x32, 0x31, 0x63, 0x34, 0x35, 0x38, 0x37, 0x63, 0x36, 0x39, 0x62, 0x61, 0x31, 0x31, 0x64, 0x62, 0x37, 0x37, 0x30, 0x64, 0x39, 0x31, 0x32, 0x37, 0x61, 0x38, 0x66, 0x30, 0x33, 0x30, 0x32, 0x65, 0x36, 0x66, 0x39, 0x35, 0x63, 0x39, 0x64, 0x39, 0x37, 0x39, 0x32, 0x32, 0x64, 0x62, 0x64, 0x34, 0x33, 0x33, 0x37, 0x37, 0x32, 0x34, 0x39, 0x65, 0x64, 0x65, 0x36, 0x38, 0x32, 0x62, 0x66, 0x38, 0x66, 0x31, 0x65, 0x33, 0x38, 0x64, 0x64, 0x32, 0x66, 0x31, 0x65, 0x62, 0x33, 0x35, 0x64, 0x61, 0x61, 0x32, 0x39, 0x63, 0x65, 0x65, 0x64, 0x65, 0x63, 0x65, 0x63, 0x37, 0x32, 0x64, 0x33, 0x61, 0x33, 0x63, 0x62, 0x34, 0x65, 0x36, 0x35, 0x31, 0x63, 0x36, 0x39, 0x30, 0x39, 0x30, 0x34, 0x38, 0x32, 0x30, 0x38, 0x35, 0x32, 0x35, 0x32, 0x63, 0x32, 0x34, 0x30, 0x35, 0x30, 0x30, 0x64, 0x65, 0x63, 0x33, 0x31, 0x65, 0x62, 0x36, 0x32, 0x37, 0x65, 0x64, 0x61, 0x64, 0x65, 0x65, 0x30, 0x37, 0x36, 0x61, 0x65, 0x64, 0x33, 0x63, 0x62, 0x35, 0x30, 0x61, 0x31, 0x33, 0x35, 0x62, 0x37, 0x64, 0x32, 0x32, 0x61, 0x38, 0x62, 0x35, 0x38, 0x63, 0x64, 0x34, 0x33, 0x66, 0x31, 0x61, 0x63, 0x39, 0x39, 0x61, 0x36, 0x37, 0x32, 0x62, 0x39, 0x38, 0x62, 0x38, 0x33, 0x34, 0x63, 0x61, 0x64, 0x36, 0x30, 0x35, 0x31, 0x64, 0x61, 0x66, 0x64, 0x31, 0x63, 0x38, 0x66, 0x66, 0x62, 0x32, 0x30, 0x30, 0x33, 0x36, 0x33, 0x36, 0x64, 0x32, 0x31, 0x65, 0x38, 0x64, 0x63, 0x36, 0x34, 0x62, 0x35, 0x30, 0x63, 0x63, 0x32, 0x65, 0x61, 0x37, 0x61, 0x37, 0x36, 0x30, 0x34, 0x31, 0x63, 0x30, 0x66, 0x65, 0x62, 0x35, 0x35, 0x37, 0x32, 0x39, 0x34, 0x62, 0x66, 0x32, 0x30, 0x34, 0x32, 0x65, 0x39, 0x30, 0x39, 0x38, 0x35, 0x35, 0x62, 0x34, 0x66, 0x37, 0x34, 0x37, 0x35, 0x30, 0x62, 0x63, 0x63, 0x39, 0x38, 0x63, 0x33, 0x62, 0x63, 0x63, 0x63, 0x62, 0x32, 0x33, 0x32, 0x63, 0x64, 0x63, 0x31, 0x36, 0x64, 0x34, 0x38, 0x31, 0x36, 0x64, 0x38, 0x32, 0x32, 0x31, 0x37, 0x66, 0x35, 0x36, 0x31, 0x32, 0x33, 0x39, 0x64, 0x30, 0x65, 0x62, 0x65, 0x62, 0x65, 0x33, 0x65, 0x32, 0x37, 0x38, 0x66, 0x63, 0x39, 0x31, 0x38, 0x36, 0x36, 0x30, 0x64, 0x61, 0x31, 0x35, 0x37, 0x34, 0x35, 0x62, 0x63, 0x30, 0x34, 0x63, 0x35, 0x61, 0x63, 0x33, 0x35, 0x34, 0x36, 0x38, 0x38, 0x64, 0x33, 0x36, 0x33, 0x35, 0x63, 0x32, 0x64, 0x64, 0x37, 0x34, 0x33, 0x31, 0x31, 0x37, 0x38, 0x39, 0x63, 0x64, 0x62, 0x32, 0x35, 0x39, 0x38, 0x34, 0x62, 0x63, 0x39, 0x65, 0x39, 0x39, 0x61, 0x35, 0x37, 0x65, 0x35, 0x39, 0x30, 0x63, 0x35, 0x35, 0x35, 0x66, 0x62, 0x62, 0x63, 0x35, 0x36, 0x61, 0x63, 0x66, 0x35, 0x32, 0x30, 0x32, 0x64, 0x39, 0x61, 0x63, 0x63, 0x34, 0x32, 0x62, 0x34, 0x65, 0x63, 0x61, 0x39, 0x64, 0x65, 0x35, 0x33, 0x32, 0x38, 0x39, 0x61, 0x39, 0x35, 0x35, 0x39, 0x66, 0x38, 0x35, 0x35, 0x37, 0x31, 0x62, 0x35, 0x33, 0x64, 0x30, 0x62, 0x63, 0x65, 0x37, 0x66, 0x30, 0x64, 0x61, 0x36, 0x33, 0x32, 0x36, 0x39, 0x61, 0x35, 0x61, 0x64, 0x65, 0x39, 0x31, 0x66, 0x62, 0x63, 0x39, 0x36, 0x35, 0x66, 0x39, 0x37, 0x64, 0x35, 0x65, 0x64, 0x63, 0x65, 0x65, 0x30, 0x38, 0x35, 0x32, 0x35, 0x31, 0x62, 0x65, 0x61, 0x61, 0x33, 0x30, 0x31, 0x66, 0x33, 0x64, 0x61, 0x30, 0x37, 0x62, 0x32, 0x63, 0x63, 0x30, 0x37, 0x30, 0x65, 0x37, 0x61, 0x30, 0x33, 0x64, 0x36, 0x66, 0x62, 0x33, 0x39, 0x30, 0x33, 0x62, 0x33, 0x36, 0x64, 0x34, 0x64, 0x65, 0x37, 0x32, 0x30, 0x64, 0x66, 0x37, 0x65, 0x62, 0x35, 0x37, 0x30, 0x62, 0x36, 0x30, 0x33, 0x30, 0x30, 0x38, 0x32, 0x61, 0x64, 0x36, 0x38, 0x61, 0x34, 0x34, 0x37, 0x33, 0x61, 0x35, 0x66, 0x64, 0x33, 0x38, 0x62, 0x65, 0x39, 0x32, 0x31, 0x35, 0x35, 0x33, 0x33, 0x37, 0x32, 0x37, 0x30, 0x34, 0x30, 0x62, 0x32, 0x63, 0x30, 0x62, 0x36, 0x34, 0x34, 0x61, 0x61, 0x30, 0x39, 0x63, 0x62, 0x64, 0x35, 0x66, 0x31, 0x66, 0x65, 0x37, 0x35, 0x31, 0x63, 0x63, 0x39, 0x38, 0x35, 0x32, 0x61, 0x64, 0x34, 0x63, 0x36, 0x36, 0x37, 0x64, 0x32, 0x36, 0x34, 0x34, 0x65, 0x35, 0x33, 0x61, 0x37, 0x39, 0x35, 0x33, 0x66, 0x34, 0x30, 0x35, 0x32, 0x62, 0x37, 0x66, 0x65, 0x37, 0x32, 0x35, 0x38, 0x35, 0x65, 0x31, 0x62, 0x62, 0x30, 0x31, 0x63, 0x66, 0x34, 0x31, 0x32, 0x32, 0x31, 0x64, 0x39, 0x36, 0x34, 0x38, 0x64, 0x62, 0x35, 0x65, 0x38, 0x31, 0x66, 0x65, 0x65, 0x38, 0x38, 0x36, 0x64, 0x38, 0x38, 0x30, 0x65, 0x32, 0x36, 0x37, 0x62, 0x35, 0x35, 0x64, 0x36, 0x36, 0x30, 0x65, 0x66, 0x65, 0x36, 0x35, 0x63, 0x36, 0x66, 0x66, 0x30, 0x62, 0x62, 0x32, 0x31, 0x30, 0x64, 0x32, 0x61, 0x66, 0x38, 0x32, 0x37, 0x38, 0x64, 0x34, 0x33, 0x63, 0x65, 0x36, 0x33, 0x65, 0x63, 0x34, 0x66, 0x65, 0x38, 0x32, 0x38, 0x64, 0x30, 0x65, 0x63, 0x62, 0x65, 0x64, 0x61, 0x34, 0x38, 0x63, 0x32, 0x35, 0x32, 0x33, 0x33, 0x35, 0x36, 0x34, 0x39, 0x61, 0x32, 0x61, 0x33, 0x34, 0x39, 0x35, 0x65, 0x38, 0x39, 0x63, 0x39, 0x66, 0x61, 0x30, 0x31, 0x37, 0x63, 0x66, 0x31, 0x37, 0x32, 0x33, 0x31, 0x66, 0x38, 0x38, 0x34, 0x35, 0x62, 0x32, 0x65, 0x30, 0x62, 0x34, 0x35, 0x31, 0x30, 0x66, 0x37, 0x63, 0x36, 0x30, 0x38, 0x64, 0x61, 0x32, 0x65, 0x34, 0x38, 0x33, 0x31, 0x38, 0x36, 0x62, 0x32, 0x34, 0x33, 0x37, 0x34, 0x62, 0x38, 0x65, 0x64, 0x35, 0x31, 0x64, 0x33, 0x31, 0x63, 0x35, 0x39, 0x65, 0x39, 0x39, 0x33, 0x62, 0x31, 0x62, 0x61, 0x36, 0x61, 0x37, 0x31, 0x37, 0x32, 0x65, 0x39, 0x34, 0x34, 0x36, 0x30, 0x38, 0x30, 0x62, 0x36, 0x39, 0x39, 0x63, 0x38, 0x66, 0x64, 0x61, 0x61, 0x35, 0x62, 0x35, 0x37, 0x32, 0x32, 0x33, 0x64, 0x64, 0x65, 0x62, 0x65, 0x63, 0x37, 0x63, 0x38, 0x30, 0x36, 0x64, 0x66, 0x66, 0x61, 0x39, 0x62, 0x30, 0x30, 0x37, 0x34, 0x63, 0x62, 0x65, 0x37, 0x65, 0x66, 0x64, 0x38, 0x33, 0x31, 0x62, 0x64, 0x31, 0x64, 0x64, 0x62, 0x30, 0x66, 0x66, 0x30, 0x61, 0x63, 0x66, 0x31, 0x61, 0x37, 0x63, 0x61, 0x65, 0x64, 0x64, 0x39, 0x65, 0x63, 0x36, 0x38, 0x63, 0x65, 0x66, 0x30, 0x38, 0x39, 0x35, 0x39, 0x33, 0x39, 0x65, 0x63, 0x34, 0x30, 0x39, 0x33, 0x63, 0x35, 0x33, 0x37, 0x35, 0x32, 0x62, 0x32, 0x33, 0x64, 0x65, 0x62, 0x64, 0x31, 0x63, 0x32, 0x37, 0x61, 0x34, 0x38, 0x36, 0x31, 0x34, 0x30, 0x66, 0x34, 0x35, 0x63, 0x37, 0x32, 0x30, 0x37, 0x38, 0x64, 0x35, 0x61, 0x31, 0x61, 0x63, 0x30, 0x30, 0x39, 0x36, 0x63, 0x66, 0x38, 0x30, 0x65, 0x33, 0x33, 0x38, 0x39, 0x33, 0x64, 0x39, 0x33, 0x31, 0x37, 0x33, 0x61, 0x33, 0x31, 0x34, 0x31, 0x30, 0x64, 0x61, 0x65, 0x33, 0x30, 0x39, 0x62, 0x61, 0x62, 0x38, 0x64, 0x38, 0x39, 0x65, 0x65, 0x62, 0x32, 0x36, 0x39, 0x64, 0x33, 0x31, 0x36, 0x64, 0x33, 0x30, 0x64, 0x37, 0x30, 0x64, 0x35, 0x37, 0x37, 0x61, 0x31, 0x36, 0x63, 0x31, 0x66, 0x33, 0x34, 0x61, 0x35, 0x65, 0x36, 0x65, 0x32, 0x34, 0x37, 0x64, 0x39, 0x37, 0x33, 0x36, 0x61, 0x30, 0x36, 0x62, 0x34, 0x36, 0x65, 0x61, 0x37, 0x66, 0x38, 0x39, 0x66, 0x36, 0x39, 0x32, 0x61, 0x62, 0x33, 0x65, 0x38, 0x64, 0x35, 0x38, 0x31, 0x65, 0x37, 0x62, 0x31, 0x61, 0x30, 0x30, 0x31, 0x37, 0x64, 0x64, 0x34, 0x36, 0x35, 0x32, 0x38, 0x39, 0x66, 0x36, 0x35, 0x33, 0x65, 0x61, 0x39, 0x33, 0x30, 0x36, 0x36, 0x36, 0x61, 0x34, 0x39, 0x30, 0x38, 0x33, 0x38, 0x30, 0x62, 0x39, 0x37, 0x62, 0x31, 0x64, 0x38, 0x39, 0x30, 0x37, 0x62, 0x64, 0x39, 0x36, 0x31, 0x30, 0x35, 0x30, 0x65, 0x39, 0x63, 0x31, 0x32, 0x64, 0x62, 0x37, 0x62, 0x64, 0x38, 0x39, 0x64, 0x63, 0x66, 0x65, 0x38, 0x32, 0x35, 0x33, 0x34, 0x33, 0x30, 0x38, 0x32, 0x66, 0x38, 0x38, 0x38, 0x37, 0x31, 0x31, 0x64, 0x36, 0x63, 0x65, 0x38, 0x32, 0x62, 0x33, 0x38, 0x64, 0x62, 0x36, 0x36, 0x64, 0x39, 0x63, 0x31, 0x64, 0x37, 0x62, 0x35, 0x32, 0x63, 0x39, 0x66, 0x66, 0x61, 0x35, 0x35, 0x63, 0x64, 0x31, 0x65, 0x35, 0x63, 0x32, 0x33, 0x61, 0x38, 0x66, 0x61, 0x39, 0x32, 0x63, 0x61, 0x61, 0x32, 0x66, 0x63, 0x33, 0x33, 0x31, 0x39, 0x31, 0x34, 0x36, 0x38, 0x66, 0x66, 0x33, 0x37, 0x37, 0x33, 0x66, 0x35, 0x65, 0x35, 0x36, 0x33, 0x38, 0x33, 0x62, 0x39, 0x36, 0x66, 0x65, 0x61, 0x35, 0x39, 0x33, 0x66, 0x35, 0x63, 0x35, 0x37, 0x31, 0x62, 0x65, 0x32, 0x66, 0x65, 0x63, 0x34, 0x33, 0x39, 0x31, 0x62, 0x36, 0x34, 0x34, 0x66, 0x33, 0x33, 0x34, 0x37, 0x36, 0x38, 0x37, 0x66, 0x62, 0x63, 0x37, 0x63, 0x31, 0x33, 0x37, 0x36, 0x30, 0x32, 0x36, 0x38, 0x65, 0x66, 0x63, 0x63, 0x61, 0x39, 0x62, 0x35, 0x33, 0x64, 0x65, 0x38, 0x61, 0x34, 0x66, 0x65, 0x63, 0x37, 0x63, 0x37, 0x31, 0x38, 0x61, 0x66, 0x38, 0x37, 0x38, 0x37, 0x39, 0x38, 0x32, 0x32, 0x38, 0x36, 0x36, 0x63, 0x65, 0x30, 0x63, 0x32, 0x35, 0x39, 0x36, 0x36, 0x65, 0x35, 0x33, 0x35, 0x63, 0x63, 0x61, 0x36, 0x65, 0x63, 0x35, 0x37, 0x32, 0x34, 0x30, 0x30, 0x36, 0x31, 0x35, 0x35, 0x34, 0x62, 0x35, 0x63, 0x64, 0x62, 0x30, 0x34, 0x61, 0x64, 0x37, 0x36, 0x37, 0x33, 0x32, 0x36, 0x39, 0x61, 0x63, 0x64, 0x30, 0x38, 0x32, 0x65, 0x33, 0x63, 0x62, 0x34, 0x32, 0x66, 0x35, 0x65, 0x62, 0x34, 0x32, 0x33, 0x61, 0x66, 0x32, 0x32, 0x39, 0x32, 0x38, 0x38, 0x39, 0x64, 0x65, 0x66, 0x38, 0x63, 0x61, 0x39, 0x30, 0x65, 0x65, 0x35, 0x31, 0x65, 0x65, 0x62, 0x37, 0x32, 0x34, 0x37, 0x61, 0x32, 0x35, 0x33, 0x63, 0x62, 0x65, 0x64, 0x38, 0x31, 0x61, 0x32, 0x30, 0x61, 0x31, 0x32, 0x38, 0x38, 0x32, 0x66, 0x33, 0x31, 0x61, 0x30, 0x31, 0x62, 0x31, 0x61, 0x38, 0x31, 0x34, 0x65, 0x32, 0x35, 0x62, 0x63, 0x64, 0x65, 0x31, 0x66, 0x35, 0x30, 0x39, 0x64, 0x65, 0x38, 0x38, 0x37, 0x66, 0x35, 0x35, 0x37, 0x37, 0x36, 0x32, 0x31, 0x63, 0x63, 0x61, 0x35, 0x37, 0x32, 0x38, 0x62, 0x66, 0x34, 0x32, 0x37, 0x33, 0x37, 0x34, 0x36, 0x35, 0x32, 0x38, 0x61, 0x61, 0x33, 0x32, 0x65, 0x34, 0x37, 0x31, 0x37, 0x31, 0x66, 0x38, 0x34, 0x64, 0x37, 0x37, 0x34, 0x64, 0x66, 0x32, 0x61, 0x65, 0x31, 0x61, 0x39, 0x38, 0x31, 0x66, 0x32, 0x31, 0x35, 0x35, 0x63, 0x61, 0x36, 0x32, 0x34, 0x61, 0x33, 0x63, 0x66, 0x30, 0x61, 0x35, 0x30, 0x39, 0x31, 0x33, 0x66, 0x30, 0x35, 0x36, 0x62, 0x37, 0x63, 0x62, 0x32, 0x66, 0x32, 0x61, 0x33, 0x38, 0x32, 0x65, 0x32, 0x34, 0x31, 0x33, 0x39, 0x38, 0x35, 0x37, 0x34, 0x64, 0x65, 0x62, 0x35, 0x64, 0x61, 0x30, 0x38, 0x33, 0x39, 0x39, 0x35, 0x61, 0x30, 0x63, 0x30, 0x61, 0x34, 0x34, 0x66, 0x39, 0x30, 0x62, 0x32, 0x65, 0x65, 0x34, 0x65, 0x61, 0x32, 0x35, 0x65, 0x31, 0x37, 0x65, 0x35, 0x30, 0x30, 0x66, 0x38, 0x33, 0x64, 0x33, 0x37, 0x34, 0x33, 0x61, 0x61, 0x30, 0x37, 0x38, 0x31, 0x36, 0x34, 0x63, 0x38, 0x65, 0x37, 0x66, 0x64, 0x66, 0x37, 0x39, 0x34, 0x37, 0x34, 0x35, 0x31, 0x37, 0x39, 0x38, 0x31, 0x39, 0x31, 0x32, 0x39, 0x33, 0x37, 0x39, 0x36, 0x66, 0x37, 0x37, 0x61, 0x66, 0x65, 0x61, 0x65, 0x62, 0x66, 0x66, 0x62, 0x65, 0x65, 0x61, 0x65, 0x61, 0x64, 0x39, 0x63, 0x38, 0x31, 0x64, 0x30, 0x33, 0x64, 0x33, 0x37, 0x65, 0x39, 0x31, 0x65, 0x37, 0x32, 0x35, 0x33, 0x34, 0x37, 0x34, 0x31, 0x31, 0x34, 0x36, 0x64, 0x34, 0x62, 0x66, 0x38, 0x62, 0x65, 0x37, 0x36, 0x39, 0x64, 0x66, 0x32, 0x31, 0x34, 0x32, 0x61, 0x61, 0x37, 0x39, 0x39, 0x37, 0x35, 0x37, 0x33, 0x61, 0x62, 0x64, 0x36, 0x37, 0x64, 0x33, 0x37, 0x66, 0x37, 0x37, 0x63, 0x62, 0x33, 0x61, 0x39, 0x33, 0x35, 0x33, 0x30, 0x32, 0x31, 0x35, 0x34, 0x61, 0x39, 0x31, 0x39, 0x38, 0x62, 0x63, 0x32, 0x65, 0x66, 0x64, 0x39, 0x32, 0x33, 0x35, 0x38, 0x32, 0x66, 0x30, 0x37, 0x65, 0x31, 0x63, 0x39, 0x63, 0x36, 0x33, 0x34, 0x63, 0x31, 0x31, 0x62, 0x36, 0x61, 0x36, 0x30, 0x31, 0x66, 0x37, 0x35, 0x66, 0x34, 0x63, 0x62, 0x39, 0x61, 0x35, 0x30, 0x64, 0x35, 0x64, 0x66, 0x37, 0x36, 0x37, 0x61, 0x38, 0x34, 0x66, 0x39, 0x34, 0x34, 0x65, 0x33, 0x63, 0x32, 0x31, 0x66, 0x32, 0x31, 0x66, 0x35, 0x32, 0x33, 0x34, 0x61, 0x63, 0x35, 0x33, 0x63, 0x66, 0x36, 0x61, 0x31, 0x34, 0x63, 0x66, 0x65, 0x61, 0x63, 0x37, 0x65, 0x34, 0x36, 0x62, 0x31, 0x64, 0x61, 0x64, 0x63, 0x65, 0x30, 0x33, 0x34, 0x65, 0x62, 0x65, 0x63, 0x36, 0x36, 0x37, 0x39, 0x65, 0x30, 0x36, 0x33, 0x34, 0x66, 0x35, 0x32, 0x61, 0x33, 0x66, 0x35, 0x35, 0x63, 0x32, 0x64, 0x35, 0x37, 0x37, 0x65, 0x30, 0x35, 0x30, 0x61, 0x38, 0x37, 0x33, 0x35, 0x64, 0x31, 0x36, 0x39, 0x32, 0x31, 0x33, 0x65, 0x33, 0x34, 0x36, 0x38, 0x63, 0x62, 0x65, 0x63, 0x37, 0x36, 0x65, 0x65, 0x32, 0x61, 0x34, 0x33, 0x35, 0x39, 0x30, 0x30, 0x63, 0x36, 0x32, 0x33, 0x32, 0x36, 0x33, 0x31, 0x35, 0x39, 0x38, 0x64, 0x38, 0x64, 0x39, 0x61, 0x34, 0x34, 0x31, 0x64, 0x33, 0x62, 0x32, 0x35, 0x34, 0x32, 0x66, 0x61, 0x65, 0x63, 0x65, 0x39, 0x36, 0x64, 0x63, 0x63, 0x65, 0x35, 0x64, 0x30, 0x61, 0x32, 0x63, 0x63, 0x62, 0x30, 0x33, 0x34, 0x32, 0x32, 0x66, 0x61, 0x32, 0x63, 0x35, 0x61, 0x66, 0x34, 0x61, 0x37, 0x66, 0x36, 0x37, 0x61, 0x30, 0x35, 0x30, 0x66, 0x33, 0x66, 0x63, 0x62, 0x39, 0x61, 0x31, 0x64, 0x37, 0x34, 0x38, 0x38, 0x64, 0x38, 0x65, 0x32, 0x36, 0x31, 0x32, 0x64, 0x33, 0x34, 0x38, 0x38, 0x35, 0x36, 0x61, 0x61, 0x30, 0x65, 0x33, 0x63, 0x65, 0x62, 0x30, 0x36, 0x62, 0x64, 0x34, 0x64, 0x33, 0x35, 0x61, 0x66, 0x37, 0x39, 0x38, 0x65, 0x62, 0x36, 0x39, 0x31, 0x31, 0x36, 0x33, 0x37, 0x66, 0x32, 0x37, 0x39, 0x66, 0x66, 0x30, 0x65, 0x32, 0x30, 0x37, 0x35, 0x38, 0x62, 0x62, 0x65, 0x34, 0x63, 0x63, 0x65, 0x33, 0x66, 0x34, 0x66, 0x37, 0x32, 0x34, 0x64, 0x62, 0x35, 0x39, 0x63, 0x39, 0x33, 0x37, 0x66, 0x64, 0x65, 0x62, 0x30, 0x37, 0x31, 0x39, 0x34, 0x38, 0x36, 0x63, 0x39, 0x33, 0x38, 0x65, 0x64, 0x36, 0x35, 0x31, 0x31, 0x63, 0x34, 0x37, 0x32, 0x64, 0x32, 0x37, 0x64, 0x35, 0x33, 0x62, 0x32, 0x37, 0x66, 0x36, 0x63, 0x64, 0x33, 0x30, 0x63, 0x36, 0x36, 0x66, 0x35, 0x66, 0x33, 0x38, 0x36, 0x66, 0x61, 0x34, 0x66, 0x37, 0x32, 0x35, 0x35, 0x39, 0x39, 0x30, 0x61, 0x65, 0x63, 0x61, 0x34, 0x39, 0x38, 0x65, 0x64, 0x33, 0x31, 0x66, 0x32, 0x31, 0x66, 0x38, 0x33, 0x34, 0x34, 0x32, 0x66, 0x30, 0x37, 0x36, 0x31, 0x37, 0x61, 0x36, 0x37, 0x61, 0x61, 0x34, 0x64, 0x38, 0x32, 0x32, 0x30, 0x65, 0x35, 0x34, 0x64, 0x35, 0x30, 0x35, 0x63, 0x35, 0x38, 0x64, 0x39, 0x66, 0x61, 0x30, 0x30, 0x30, 0x36, 0x64, 0x31, 0x37, 0x32, 0x65, 0x36, 0x36, 0x61, 0x30, 0x30, 0x37, 0x33, 0x33, 0x38, 0x62, 0x37, 0x65, 0x36, 0x36, 0x38, 0x63, 0x39, 0x62, 0x37, 0x38, 0x61, 0x34, 0x30, 0x64, 0x34, 0x61, 0x63, 0x38, 0x63, 0x31, 0x38, 0x35, 0x64, 0x34, 0x62, 0x63, 0x61, 0x62, 0x31, 0x39, 0x33, 0x33, 0x63, 0x39, 0x61, 0x66, 0x34, 0x31, 0x65, 0x34, 0x31, 0x35, 0x62, 0x34, 0x37, 0x32, 0x34, 0x33, 0x63, 0x61, 0x62, 0x37, 0x32, 0x34, 0x31, 0x34, 0x63, 0x66, 0x30, 0x30, 0x31, 0x62, 0x62, 0x65, 0x33, 0x64, 0x36, 0x33, 0x37, 0x36, 0x31, 0x62, 0x37, 0x65, 0x37, 0x36, 0x32, 0x36, 0x64, 0x37, 0x35, 0x38, 0x66, 0x32, 0x37, 0x64, 0x64, 0x65, 0x32, 0x61, 0x63, 0x61, 0x66, 0x63, 0x31, 0x36, 0x66, 0x64, 0x35, 0x30, 0x36, 0x36, 0x38, 0x39, 0x66, 0x64, 0x34, 0x64, 0x36, 0x66, 0x63, 0x34, 0x34, 0x31, 0x34, 0x37, 0x32, 0x37, 0x32, 0x65, 0x62, 0x30, 0x30, 0x65, 0x39, 0x31, 0x65, 0x32, 0x37, 0x31, 0x66, 0x63, 0x38, 0x34, 0x62, 0x37, 0x39, 0x36, 0x37, 0x32, 0x36, 0x66, 0x65, 0x37, 0x62, 0x62, 0x38, 0x63, 0x63, 0x39, 0x35, 0x34, 0x63, 0x32, 0x34, 0x64, 0x61, 0x35, 0x36, 0x62, 0x65, 0x32, 0x32, 0x64, 0x65, 0x38, 0x32, 0x66, 0x61, 0x33, 0x61, 0x30, 0x65, 0x38, 0x36, 0x33, 0x32, 0x64, 0x35, 0x37, 0x32, 0x34, 0x65, 0x61, 0x33, 0x64, 0x30, 0x30, 0x64, 0x33, 0x38, 0x61, 0x37, 0x62, 0x61, 0x34, 0x39, 0x34, 0x37, 0x30, 0x66, 0x37, 0x38, 0x38, 0x63, 0x39, 0x62, 0x39, 0x63, 0x34, 0x61, 0x36, 0x34, 0x64, 0x65, 0x33, 0x33, 0x31, 0x36, 0x34, 0x39, 0x34, 0x38, 0x64, 0x36, 0x33, 0x37, 0x36, 0x65, 0x66, 0x31, 0x39, 0x65, 0x36, 0x66, 0x64, 0x61, 0x65, 0x63, 0x62, 0x65, 0x34, 0x62, 0x36, 0x39, 0x38, 0x64, 0x36, 0x36, 0x61, 0x30, 0x30, 0x35, 0x65, 0x31, 0x31, 0x61, 0x61, 0x34, 0x31, 0x64, 0x39, 0x63, 0x33, 0x33, 0x63, 0x62, 0x39, 0x34, 0x35, 0x62, 0x39, 0x65, 0x34, 0x35, 0x61, 0x38, 0x34, 0x62, 0x66, 0x36, 0x65, 0x30, 0x33, 0x64, 0x62, 0x35, 0x62, 0x66, 0x61, 0x61, 0x37, 0x61, 0x31, 0x33, 0x66, 0x61, 0x62, 0x34, 0x36, 0x66, 0x61, 0x63, 0x35, 0x32, 0x62, 0x33, 0x30, 0x32, 0x35, 0x35, 0x32, 0x38, 0x36, 0x36, 0x62, 0x36, 0x66, 0x63, 0x64, 0x38, 0x39, 0x31, 0x32, 0x32, 0x38, 0x35, 0x38, 0x35, 0x30, 0x30, 0x62, 0x30, 0x34, 0x66, 0x33, 0x35, 0x34, 0x64, 0x35, 0x63, 0x65, 0x35, 0x32, 0x32, 0x35, 0x35, 0x37, 0x35, 0x62, 0x30, 0x32, 0x35, 0x33, 0x33, 0x39, 0x34, 0x32, 0x39, 0x38, 0x64, 0x35, 0x31, 0x36, 0x32, 0x31, 0x64, 0x63, 0x66, 0x63, 0x37, 0x37, 0x32, 0x66, 0x64, 0x30, 0x34, 0x66, 0x30, 0x37, 0x38, 0x39, 0x37, 0x35, 0x33, 0x35, 0x64, 0x39, 0x38, 0x62, 0x61, 0x35, 0x65, 0x32, 0x62, 0x63, 0x34, 0x64, 0x64, 0x61, 0x35, 0x66, 0x35, 0x30, 0x32, 0x34, 0x34, 0x33, 0x35, 0x35, 0x66, 0x61, 0x32, 0x39, 0x36, 0x30, 0x64, 0x33, 0x63, 0x30, 0x66, 0x30, 0x64, 0x62, 0x36, 0x63, 0x33, 0x35, 0x33, 0x33, 0x66, 0x30, 0x66, 0x62, 0x63, 0x37, 0x32, 0x38, 0x66, 0x35, 0x66, 0x37, 0x31, 0x38, 0x65, 0x63, 0x38, 0x39, 0x35, 0x33, 0x39, 0x64, 0x64, 0x31, 0x36, 0x64, 0x39, 0x32, 0x31, 0x38, 0x37, 0x35, 0x31, 0x64, 0x35, 0x38, 0x32, 0x36, 0x65, 0x38, 0x36, 0x38, 0x38, 0x30, 0x64, 0x61, 0x66, 0x34, 0x34, 0x62, 0x30, 0x31, 0x36, 0x62, 0x33, 0x31, 0x64, 0x37, 0x63, 0x36, 0x31, 0x37, 0x33, 0x34, 0x37, 0x39, 0x62, 0x37, 0x36, 0x37, 0x32, 0x31, 0x35, 0x61, 0x39, 0x33, 0x36, 0x33, 0x30, 0x31, 0x62, 0x65, 0x65, 0x32, 0x34, 0x64, 0x62, 0x39, 0x30, 0x61, 0x65, 0x61, 0x61, 0x32, 0x63, 0x37, 0x63, 0x38, 0x34, 0x34, 0x30, 0x64, 0x38, 0x61, 0x65, 0x33, 0x39, 0x34, 0x65, 0x32, 0x66, 0x39, 0x66, 0x63, 0x30, 0x64, 0x33, 0x30, 0x65, 0x38, 0x39, 0x62, 0x31, 0x32, 0x66, 0x36, 0x63, 0x64, 0x34, 0x38, 0x32, 0x65, 0x32, 0x37, 0x32, 0x34, 0x39, 0x36, 0x63, 0x61, 0x34, 0x38, 0x64, 0x62, 0x62, 0x61, 0x39, 0x34, 0x65, 0x30, 0x31, 0x30, 0x64, 0x35, 0x35, 0x30, 0x39, 0x63, 0x66, 0x30, 0x38, 0x66, 0x62, 0x34, 0x36, 0x31, 0x64, 0x38, 0x33, 0x33, 0x34, 0x62, 0x65, 0x32, 0x34, 0x36, 0x35, 0x39, 0x39, 0x62, 0x62, 0x66, 0x33, 0x39, 0x34, 0x35, 0x66, 0x33, 0x62, 0x38, 0x65, 0x37, 0x36, 0x63, 0x63, 0x66, 0x64, 0x36, 0x38, 0x39, 0x36, 0x63, 0x61, 0x39, 0x32, 0x37, 0x31, 0x31, 0x64, 0x61, 0x31, 0x34, 0x35, 0x64, 0x31, 0x62, 0x63, 0x37, 0x66, 0x61, 0x62, 0x38, 0x63, 0x62, 0x62, 0x34, 0x33, 0x66, 0x36, 0x38, 0x39, 0x34, 0x63, 0x34, 0x34, 0x62, 0x31, 0x37, 0x64, 0x31, 0x39, 0x30, 0x39, 0x38, 0x39, 0x33, 0x34, 0x31, 0x36, 0x36, 0x65, 0x35, 0x30, 0x64, 0x65, 0x61, 0x62, 0x66, 0x65, 0x62, 0x66, 0x37, 0x32, 0x32, 0x61, 0x64, 0x64, 0x37, 0x38, 0x34, 0x32, 0x32, 0x32, 0x32, 0x36, 0x63, 0x37, 0x39, 0x61, 0x31, 0x62, 0x34, 0x34, 0x63, 0x39, 0x33, 0x34, 0x66, 0x34, 0x30, 0x38, 0x36, 0x66, 0x39, 0x30, 0x35, 0x33, 0x32, 0x65, 0x39, 0x65, 0x64, 0x64, 0x30, 0x39, 0x38, 0x61, 0x63, 0x37, 0x63, 0x34, 0x62, 0x32, 0x39, 0x66, 0x33, 0x33, 0x66, 0x35, 0x37, 0x33, 0x31, 0x64, 0x39, 0x37, 0x37, 0x32, 0x39, 0x66, 0x63, 0x65, 0x31, 0x61, 0x31, 0x32, 0x33, 0x32, 0x61, 0x39, 0x66, 0x30, 0x61, 0x63, 0x36, 0x36, 0x30, 0x62, 0x32, 0x34, 0x37, 0x30, 0x36, 0x38, 0x31, 0x30, 0x66, 0x37, 0x32, 0x65, 0x38, 0x61, 0x32, 0x35, 0x65, 0x61, 0x30, 0x39, 0x62, 0x33, 0x30, 0x65, 0x30, 0x63, 0x61, 0x62, 0x62, 0x34, 0x33, 0x34, 0x38, 0x65, 0x30, 0x32, 0x35, 0x36, 0x35, 0x37, 0x34, 0x31, 0x37, 0x32, 0x34, 0x65, 0x35, 0x64, 0x63, 0x63, 0x35, 0x36, 0x66, 0x65, 0x66, 0x36, 0x62, 0x63, 0x66, 0x32, 0x39, 0x61, 0x64, 0x61, 0x34, 0x35, 0x38, 0x64, 0x66, 0x35, 0x39, 0x37, 0x36, 0x32, 0x33, 0x35, 0x32, 0x33, 0x30, 0x32, 0x37, 0x34, 0x30, 0x33, 0x36, 0x30, 0x33, 0x34, 0x34, 0x39, 0x66, 0x38, 0x61, 0x32, 0x34, 0x36, 0x33, 0x33, 0x33, 0x30, 0x66, 0x30, 0x65, 0x62, 0x38, 0x62, 0x32, 0x32, 0x30, 0x30, 0x35, 0x37, 0x33, 0x30, 0x36, 0x34, 0x31, 0x63, 0x61, 0x64, 0x32, 0x30, 0x30, 0x31, 0x34, 0x36, 0x63, 0x33, 0x33, 0x65, 0x62, 0x64, 0x37, 0x65, 0x61, 0x31, 0x62, 0x62, 0x35, 0x32, 0x35, 0x34, 0x33, 0x36, 0x30, 0x36, 0x37, 0x35, 0x62, 0x62, 0x63, 0x32, 0x65, 0x64, 0x63, 0x30, 0x31, 0x61, 0x65, 0x39, 0x37, 0x37, 0x65, 0x65, 0x31, 0x34, 0x31, 0x64, 0x31, 0x34, 0x30, 0x32, 0x37, 0x66, 0x34, 0x31, 0x64, 0x34, 0x39, 0x61, 0x62, 0x64, 0x63, 0x62, 0x39, 0x39, 0x33, 0x62, 0x63, 0x66, 0x31, 0x35, 0x65, 0x66, 0x62, 0x38, 0x34, 0x37, 0x61, 0x33, 0x36, 0x38, 0x64, 0x36, 0x36, 0x30, 0x39, 0x32, 0x34, 0x61, 0x37, 0x30, 0x66, 0x64, 0x34, 0x37, 0x37, 0x37, 0x33, 0x39, 0x37, 0x61, 0x32, 0x31, 0x62, 0x38, 0x38, 0x32, 0x33, 0x61, 0x32, 0x32, 0x65, 0x31, 0x31, 0x64, 0x61, 0x37, 0x39, 0x34, 0x30, 0x61, 0x61, 0x64, 0x36, 0x35, 0x37, 0x63, 0x39, 0x36, 0x39, 0x64, 0x35, 0x35, 0x65, 0x62, 0x30, 0x64, 0x61, 0x64, 0x36, 0x63, 0x35, 0x35, 0x62, 0x39, 0x33, 0x66, 0x35, 0x38, 0x38, 0x61, 0x64, 0x62, 0x63, 0x34, 0x35, 0x30, 0x65, 0x37, 0x37, 0x39, 0x31, 0x37, 0x38, 0x38, 0x37, 0x34, 0x66, 0x37, 0x63, 0x36, 0x31, 0x62, 0x39, 0x32, 0x35, 0x39, 0x37, 0x32, 0x32, 0x32, 0x65, 0x34, 0x66, 0x31, 0x34, 0x61, 0x31, 0x34, 0x31, 0x37, 0x39, 0x62, 0x62, 0x30, 0x35, 0x31, 0x30, 0x35, 0x35, 0x34, 0x62, 0x63, 0x64, 0x38, 0x36, 0x61, 0x62, 0x33, 0x39, 0x39, 0x35, 0x36, 0x38, 0x61, 0x39, 0x30, 0x61, 0x65, 0x65, 0x62, 0x62, 0x36, 0x31, 0x63, 0x64, 0x39, 0x39, 0x64, 0x30, 0x65, 0x36, 0x36, 0x32, 0x37, 0x34, 0x31, 0x37, 0x63, 0x38, 0x33, 0x34, 0x33, 0x35, 0x37, 0x30, 0x64, 0x32, 0x30, 0x66, 0x65, 0x65, 0x32, 0x65, 0x35, 0x37, 0x31, 0x38, 0x64, 0x66, 0x34, 0x36, 0x30, 0x63, 0x65, 0x61, 0x37, 0x37, 0x34, 0x64, 0x35, 0x39, 0x38, 0x37, 0x62, 0x37, 0x34, 0x65, 0x31, 0x65, 0x38, 0x31, 0x31, 0x31, 0x62, 0x35, 0x65, 0x39, 0x34, 0x34, 0x66, 0x32, 0x61, 0x33, 0x66, 0x35, 0x38, 0x33, 0x62, 0x65, 0x39, 0x37, 0x61, 0x30, 0x39, 0x30, 0x64, 0x32, 0x36, 0x39, 0x33, 0x34, 0x35, 0x34, 0x35, 0x33, 0x66, 0x34, 0x39, 0x61, 0x39, 0x30, 0x39, 0x65, 0x62, 0x64, 0x31, 0x32, 0x33, 0x34, 0x35, 0x30, 0x61, 0x39, 0x63, 0x66, 0x31, 0x36, 0x34, 0x38, 0x37, 0x32, 0x34, 0x38, 0x64, 0x38, 0x65, 0x66, 0x61, 0x61, 0x35, 0x32, 0x30, 0x34, 0x33, 0x33, 0x63, 0x37, 0x61, 0x35, 0x36, 0x37, 0x34, 0x36, 0x63, 0x62, 0x38, 0x66, 0x61, 0x37, 0x32, 0x35, 0x39, 0x34, 0x63, 0x36, 0x63, 0x34, 0x66, 0x34, 0x34, 0x34, 0x31, 0x31, 0x35, 0x32, 0x35, 0x35, 0x62, 0x33, 0x61, 0x61, 0x39, 0x64, 0x34, 0x31, 0x66, 0x38, 0x65, 0x61, 0x39, 0x37, 0x34, 0x63, 0x37, 0x31, 0x34, 0x36, 0x33, 0x34, 0x38, 0x38, 0x34, 0x61, 0x61, 0x66, 0x38, 0x32, 0x39, 0x62, 0x61, 0x34, 0x30, 0x33, 0x38, 0x63, 0x38, 0x65, 0x64, 0x32, 0x66, 0x33, 0x64, 0x37, 0x32, 0x34, 0x62, 0x37, 0x32, 0x35, 0x31, 0x66, 0x65, 0x37, 0x62, 0x38, 0x65, 0x36, 0x31, 0x30, 0x30, 0x33, 0x34, 0x64, 0x37, 0x65, 0x66, 0x61, 0x34, 0x32, 0x31, 0x66, 0x65, 0x30, 0x64, 0x36, 0x33, 0x61, 0x63, 0x66, 0x66, 0x32, 0x61, 0x33, 0x31, 0x31, 0x38, 0x35, 0x63, 0x37, 0x39, 0x65, 0x30, 0x36, 0x34, 0x65, 0x37, 0x65, 0x38, 0x35, 0x64, 0x37, 0x39, 0x39, 0x34, 0x34, 0x33, 0x37, 0x32, 0x39, 0x37, 0x36, 0x39, 0x30, 0x31, 0x66, 0x64, 0x61, 0x36, 0x39, 0x61, 0x61, 0x34, 0x34, 0x63, 0x63, 0x61, 0x37, 0x36, 0x66, 0x35, 0x65, 0x64, 0x30, 0x35, 0x33, 0x34, 0x62, 0x31, 0x34, 0x62, 0x31, 0x37, 0x39, 0x35, 0x32, 0x63, 0x36, 0x37, 0x35, 0x32, 0x35, 0x65, 0x64, 0x39, 0x64, 0x66, 0x39, 0x62, 0x61, 0x34, 0x62, 0x32, 0x30, 0x30, 0x61, 0x64, 0x63, 0x38, 0x31, 0x39, 0x32, 0x65, 0x39, 0x35, 0x63, 0x65, 0x32, 0x62, 0x33, 0x63, 0x63, 0x30, 0x38, 0x33, 0x35, 0x33, 0x33, 0x66, 0x38, 0x31, 0x65, 0x62, 0x33, 0x64, 0x61, 0x35, 0x64, 0x31, 0x37, 0x37, 0x31, 0x31, 0x66, 0x61, 0x33, 0x63, 0x65, 0x63, 0x38, 0x35, 0x63, 0x34, 0x34, 0x66, 0x64, 0x65, 0x65, 0x35, 0x33, 0x37, 0x35, 0x64, 0x65, 0x64, 0x62, 0x34, 0x62, 0x61, 0x32, 0x66, 0x61, 0x66, 0x37, 0x35, 0x34, 0x33, 0x61, 0x63, 0x38, 0x63, 0x61, 0x38, 0x33, 0x62, 0x61, 0x62, 0x39, 0x65, 0x39, 0x33, 0x62, 0x31, 0x30, 0x36, 0x38, 0x32, 0x31, 0x37, 0x34, 0x32, 0x36, 0x36, 0x34, 0x61, 0x34, 0x31, 0x37, 0x66, 0x35, 0x31, 0x65, 0x62, 0x37, 0x35, 0x34, 0x39, 0x37, 0x39, 0x65, 0x63, 0x35, 0x63, 0x65, 0x37, 0x30, 0x61, 0x35, 0x30, 0x63, 0x36, 0x62, 0x39, 0x63, 0x38, 0x62, 0x38, 0x30, 0x31, 0x37, 0x32, 0x62, 0x32, 0x34, 0x39, 0x33, 0x32, 0x36, 0x32, 0x30, 0x36, 0x35, 0x36, 0x66, 0x65, 0x61, 0x38, 0x37, 0x63, 0x61, 0x33, 0x33, 0x31, 0x63, 0x62, 0x35, 0x38, 0x34, 0x31, 0x66, 0x34, 0x33, 0x63, 0x31, 0x62, 0x35, 0x36, 0x38, 0x66, 0x61, 0x64, 0x63, 0x61, 0x37, 0x30, 0x38, 0x64, 0x66, 0x33, 0x32, 0x62, 0x34, 0x30, 0x34, 0x37, 0x66, 0x65, 0x36, 0x63, 0x31, 0x62, 0x64, 0x39, 0x37, 0x32, 0x63, 0x61, 0x63, 0x38, 0x62, 0x36, 0x63, 0x61, 0x63, 0x64, 0x66, 0x34, 0x64, 0x34, 0x39, 0x33, 0x38, 0x33, 0x39, 0x61, 0x65, 0x39, 0x63, 0x38, 0x65, 0x37, 0x39, 0x66, 0x63, 0x32, 0x33, 0x64, 0x66, 0x65, 0x36, 0x33, 0x65, 0x65, 0x66, 0x39, 0x33, 0x38, 0x37, 0x32, 0x65, 0x65, 0x33, 0x66, 0x34, 0x32, 0x31, 0x39, 0x36, 0x37, 0x61, 0x32, 0x64, 0x33, 0x37, 0x32, 0x66, 0x63, 0x37, 0x30, 0x38, 0x65, 0x61, 0x33, 0x61, 0x36, 0x37, 0x35, 0x30, 0x66, 0x62, 0x32, 0x34, 0x66, 0x38, 0x30, 0x61, 0x36, 0x62, 0x66, 0x35, 0x63, 0x30, 0x37, 0x61, 0x36, 0x37, 0x38, 0x37, 0x35, 0x37, 0x61, 0x61, 0x31, 0x35, 0x66, 0x66, 0x34, 0x38, 0x61, 0x64, 0x61, 0x65, 0x63, 0x31, 0x64, 0x32, 0x38, 0x37, 0x32, 0x37, 0x30, 0x63, 0x33, 0x65, 0x63, 0x30, 0x66, 0x61, 0x37, 0x33, 0x61, 0x33, 0x32, 0x62, 0x61, 0x30, 0x65, 0x36, 0x66, 0x36, 0x34, 0x33, 0x33, 0x37, 0x36, 0x64, 0x38, 0x66, 0x63, 0x33, 0x62, 0x32, 0x31, 0x31, 0x34, 0x62, 0x33, 0x64, 0x62, 0x33, 0x61, 0x30, 0x64, 0x37, 0x64, 0x63, 0x30, 0x62, 0x66, 0x32, 0x35, 0x66, 0x63, 0x37, 0x62, 0x64, 0x34, 0x62, 0x34, 0x31, 0x62, 0x39, 0x39, 0x65, 0x35, 0x34, 0x66, 0x36, 0x63, 0x31, 0x32, 0x63, 0x66, 0x37, 0x62, 0x33, 0x35, 0x39, 0x37, 0x39, 0x61, 0x35, 0x63, 0x34, 0x61, 0x62, 0x65, 0x30, 0x33, 0x38, 0x62, 0x39, 0x62, 0x65, 0x65, 0x32, 0x64, 0x33, 0x35, 0x64, 0x34, 0x36, 0x39, 0x32, 0x32, 0x37, 0x39, 0x38, 0x32, 0x65, 0x37, 0x33, 0x66, 0x30, 0x37, 0x34, 0x64, 0x66, 0x62, 0x38, 0x65, 0x38, 0x35, 0x61, 0x38, 0x39, 0x64, 0x35, 0x66, 0x66, 0x31, 0x64, 0x37, 0x32, 0x36, 0x36, 0x30, 0x39, 0x36, 0x32, 0x63, 0x33, 0x61, 0x36, 0x63, 0x61, 0x32, 0x35, 0x32, 0x61, 0x63, 0x63, 0x36, 0x32, 0x37, 0x32, 0x30, 0x38, 0x37, 0x66, 0x64, 0x64, 0x35, 0x37, 0x61, 0x63, 0x33, 0x65, 0x37, 0x33, 0x32, 0x38, 0x38, 0x33, 0x32, 0x63, 0x31, 0x36, 0x62, 0x63, 0x37, 0x35, 0x31, 0x36, 0x37, 0x32, 0x34, 0x66, 0x33, 0x36, 0x61, 0x62, 0x61, 0x37, 0x61, 0x30, 0x61, 0x36, 0x61, 0x30, 0x64, 0x62, 0x38, 0x37, 0x32, 0x61, 0x38, 0x65, 0x39, 0x37, 0x38, 0x62, 0x37, 0x66, 0x33, 0x64, 0x34, 0x64, 0x38, 0x37, 0x65, 0x30, 0x37, 0x66, 0x37, 0x36, 0x33, 0x63, 0x32, 0x32, 0x39, 0x36, 0x31, 0x63, 0x38, 0x35, 0x64, 0x65, 0x38, 0x61, 0x35, 0x35, 0x36, 0x63, 0x38, 0x63, 0x66, 0x62, 0x36, 0x37, 0x30, 0x66, 0x65, 0x39, 0x35, 0x36, 0x39, 0x63, 0x30, 0x32, 0x31, 0x65, 0x32, 0x36, 0x38, 0x32, 0x64, 0x33, 0x61, 0x31, 0x32, 0x62, 0x39, 0x33, 0x61, 0x31, 0x34, 0x37, 0x63, 0x30, 0x37, 0x34, 0x61, 0x61, 0x64, 0x30, 0x37, 0x30, 0x65, 0x32, 0x33, 0x34, 0x65, 0x31, 0x62, 0x34, 0x61, 0x63, 0x34, 0x30, 0x63, 0x64, 0x39, 0x36, 0x61, 0x35, 0x62, 0x62, 0x37, 0x36, 0x65, 0x64, 0x66, 0x64, 0x34, 0x63, 0x62, 0x62, 0x38, 0x61, 0x66, 0x65, 0x66, 0x38, 0x66, 0x61, 0x34, 0x36, 0x36, 0x64, 0x33, 0x36, 0x31, 0x32, 0x62, 0x36, 0x65, 0x30, 0x37, 0x64, 0x65, 0x30, 0x65, 0x32, 0x61, 0x65, 0x36, 0x34, 0x30, 0x64, 0x61, 0x32, 0x64, 0x61, 0x32, 0x35, 0x61, 0x62, 0x32, 0x37, 0x33, 0x64, 0x30, 0x64, 0x33, 0x38, 0x65, 0x62, 0x39, 0x34, 0x30, 0x31, 0x65, 0x35, 0x34, 0x31, 0x34, 0x34, 0x65, 0x31, 0x64, 0x62, 0x65, 0x39, 0x64, 0x36, 0x31, 0x66, 0x33, 0x34, 0x30, 0x37, 0x64, 0x31, 0x35, 0x32, 0x39, 0x63, 0x35, 0x30, 0x63, 0x37, 0x30, 0x39, 0x30, 0x34, 0x38, 0x39, 0x33, 0x32, 0x36, 0x63, 0x32, 0x31, 0x31, 0x38, 0x39, 0x38, 0x32, 0x30, 0x30, 0x66, 0x34, 0x65, 0x64, 0x62, 0x39, 0x61, 0x61, 0x35, 0x30, 0x66, 0x37, 0x32, 0x62, 0x39, 0x32, 0x36, 0x37, 0x38, 0x61, 0x66, 0x63, 0x62, 0x38, 0x32, 0x31, 0x30, 0x38, 0x62, 0x65, 0x65, 0x33, 0x66, 0x35, 0x31, 0x63, 0x64, 0x31, 0x37, 0x32, 0x36, 0x63, 0x34, 0x62, 0x37, 0x34, 0x64, 0x38, 0x66, 0x63, 0x37, 0x65, 0x38, 0x32, 0x64, 0x36, 0x61, 0x66, 0x36, 0x35, 0x65, 0x30, 0x33, 0x37, 0x65, 0x62, 0x34, 0x39, 0x34, 0x35, 0x65, 0x37, 0x35, 0x30, 0x31, 0x30, 0x34, 0x39, 0x64, 0x39, 0x63, 0x35, 0x63, 0x35, 0x66, 0x31, 0x32, 0x64, 0x33, 0x36, 0x65, 0x39, 0x33, 0x64, 0x36, 0x63, 0x31, 0x66, 0x34, 0x39, 0x31, 0x39, 0x37, 0x32, 0x65, 0x30, 0x35, 0x33, 0x38, 0x32, 0x32, 0x64, 0x33, 0x36, 0x66, 0x64, 0x34, 0x63, 0x33, 0x63, 0x31, 0x39, 0x38, 0x39, 0x62, 0x39, 0x30, 0x34, 0x66, 0x31, 0x30, 0x66, 0x66, 0x65, 0x33, 0x38, 0x31, 0x34, 0x30, 0x61, 0x65, 0x33, 0x64, 0x39, 0x63, 0x39, 0x30, 0x33, 0x37, 0x62, 0x63, 0x37, 0x65, 0x39, 0x31, 0x66, 0x62, 0x63, 0x33, 0x34, 0x66, 0x65, 0x39, 0x32, 0x65, 0x37, 0x37, 0x32, 0x66, 0x63, 0x33, 0x61, 0x31, 0x66, 0x37, 0x39, 0x35, 0x30, 0x34, 0x61, 0x31, 0x36, 0x34, 0x34, 0x38, 0x36, 0x63, 0x63, 0x66, 0x34, 0x62, 0x32, 0x64, 0x37, 0x61, 0x65, 0x61, 0x66, 0x63, 0x62, 0x39, 0x61, 0x65, 0x36, 0x66, 0x33, 0x62, 0x32, 0x66, 0x37, 0x31, 0x66, 0x62, 0x63, 0x63, 0x36, 0x38, 0x35, 0x38, 0x61, 0x38, 0x39, 0x61, 0x39, 0x39, 0x65, 0x36, 0x30, 0x30, 0x65, 0x37, 0x32, 0x34, 0x61, 0x30, 0x32, 0x62, 0x37, 0x66, 0x66, 0x34, 0x38, 0x30, 0x38, 0x33, 0x39, 0x63, 0x65, 0x30, 0x33, 0x32, 0x39, 0x34, 0x66, 0x31, 0x35, 0x61, 0x32, 0x64, 0x31, 0x35, 0x35, 0x33, 0x33, 0x30, 0x33, 0x36, 0x65, 0x33, 0x63, 0x34, 0x62, 0x32, 0x31, 0x62, 0x38, 0x61, 0x65, 0x31, 0x30, 0x37, 0x63, 0x36, 0x63, 0x64, 0x38, 0x32, 0x37, 0x34, 0x64, 0x34, 0x32, 0x39, 0x32, 0x37, 0x32, 0x65, 0x62, 0x38, 0x30, 0x63, 0x64, 0x37, 0x34, 0x66, 0x30, 0x63, 0x39, 0x64, 0x35, 0x35, 0x37, 0x65, 0x64, 0x65, 0x32, 0x38, 0x36, 0x63, 0x61, 0x61, 0x34, 0x31, 0x61, 0x35, 0x38, 0x39, 0x62, 0x62, 0x33, 0x66, 0x31, 0x61, 0x36, 0x65, 0x36, 0x34, 0x31, 0x38, 0x62, 0x32, 0x39, 0x36, 0x63, 0x30, 0x32, 0x35, 0x33, 0x61, 0x64, 0x63, 0x32, 0x62, 0x31, 0x34, 0x33, 0x66, 0x63, 0x37, 0x32, 0x38, 0x30, 0x37, 0x38, 0x63, 0x62, 0x65, 0x37, 0x61, 0x33, 0x62, 0x30, 0x35, 0x32, 0x36, 0x61, 0x65, 0x36, 0x36, 0x31, 0x30, 0x63, 0x65, 0x64, 0x36, 0x61, 0x65, 0x66, 0x64, 0x62, 0x65, 0x66, 0x34, 0x34, 0x66, 0x33, 0x64, 0x37, 0x65, 0x31, 0x30, 0x33, 0x30, 0x63, 0x62, 0x35, 0x38, 0x66, 0x37, 0x32, 0x64, 0x37, 0x36, 0x35, 0x35, 0x64, 0x35, 0x32, 0x63, 0x38, 0x38, 0x63, 0x37, 0x32, 0x37, 0x30, 0x35, 0x61, 0x34, 0x34, 0x61, 0x63, 0x66, 0x64, 0x31, 0x64, 0x66, 0x62, 0x34, 0x65, 0x36, 0x38, 0x30, 0x64, 0x38, 0x35, 0x32, 0x65, 0x63, 0x36, 0x61, 0x61, 0x38, 0x36, 0x35, 0x37, 0x61, 0x63, 0x65, 0x32, 0x38, 0x30, 0x36, 0x31, 0x34, 0x63, 0x34, 0x37, 0x65, 0x30, 0x66, 0x38, 0x64, 0x36, 0x66, 0x39, 0x66, 0x37, 0x61, 0x36, 0x65, 0x39, 0x34, 0x38, 0x35, 0x37, 0x37, 0x32, 0x32, 0x33, 0x38, 0x37, 0x61, 0x35, 0x66, 0x31, 0x32, 0x63, 0x31, 0x30, 0x63, 0x32, 0x34, 0x65, 0x35, 0x62, 0x64, 0x32, 0x65, 0x63, 0x63, 0x62, 0x33, 0x62, 0x65, 0x37, 0x66, 0x64, 0x34, 0x39, 0x65, 0x38, 0x32, 0x64, 0x38, 0x35, 0x31, 0x30, 0x39, 0x34, 0x66, 0x33, 0x63, 0x35, 0x32, 0x30, 0x35, 0x37, 0x31, 0x38, 0x62, 0x63, 0x61, 0x63, 0x34, 0x34, 0x33, 0x33, 0x38, 0x34, 0x34, 0x35, 0x36, 0x62, 0x32, 0x32, 0x62, 0x34, 0x64, 0x38, 0x38, 0x37, 0x30, 0x31, 0x37, 0x36, 0x33, 0x65, 0x37, 0x62, 0x34, 0x30, 0x63, 0x64, 0x65, 0x64, 0x31, 0x61, 0x62, 0x33, 0x33, 0x37, 0x37, 0x66, 0x66, 0x61, 0x38, 0x62, 0x65, 0x39, 0x66, 0x39, 0x39, 0x63, 0x33, 0x32, 0x39, 0x64, 0x38, 0x61, 0x62, 0x66, 0x36, 0x31, 0x38, 0x38, 0x33, 0x30, 0x34, 0x33, 0x66, 0x30, 0x38, 0x38, 0x35, 0x35, 0x62, 0x34, 0x63, 0x63, 0x63, 0x66, 0x30, 0x39, 0x65, 0x33, 0x35, 0x30, 0x39, 0x61, 0x65, 0x61, 0x64, 0x34, 0x36, 0x64, 0x63, 0x37, 0x66, 0x65, 0x61, 0x61, 0x65, 0x61, 0x66, 0x33, 0x39, 0x33, 0x37, 0x64, 0x65, 0x31, 0x61, 0x36, 0x66, 0x66, 0x34, 0x63, 0x30, 0x35, 0x34, 0x30, 0x64, 0x65, 0x63, 0x39, 0x30, 0x64, 0x66, 0x31, 0x63, 0x35, 0x37, 0x37, 0x34, 0x37, 0x37, 0x36, 0x37, 0x32, 0x65, 0x65, 0x38, 0x33, 0x62, 0x30, 0x30, 0x37, 0x30, 0x63, 0x37, 0x31, 0x37, 0x63, 0x34, 0x65, 0x31, 0x62, 0x38, 0x31, 0x35, 0x35, 0x30, 0x62, 0x38, 0x66, 0x63, 0x62, 0x35, 0x37, 0x65, 0x37, 0x61, 0x33, 0x39, 0x61, 0x62, 0x35, 0x65, 0x33, 0x63, 0x39, 0x38, 0x31, 0x32, 0x62, 0x34, 0x66, 0x34, 0x32, 0x62, 0x63, 0x37, 0x33, 0x31, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x66, 0x37, 0x32, 0x31, 0x37, 0x65, 0x37, 0x32, 0x33, 0x33, 0x30, 0x61, 0x37, 0x63, 0x63, 0x37, 0x36, 0x66, 0x33, 0x30, 0x63, 0x62, 0x62, 0x65, 0x33, 0x66, 0x31, 0x62, 0x61, 0x39, 0x35, 0x30, 0x66, 0x39, 0x65, 0x36, 0x65, 0x61, 0x31, 0x36, 0x38, 0x64, 0x39, 0x36, 0x61, 0x34, 0x34, 0x32, 0x35, 0x37, 0x62, 0x39, 0x38, 0x62, 0x66, 0x38, 0x62, 0x62, 0x31, 0x36, 0x65, 0x63, 0x37, 0x34, 0x37, 0x37, 0x32, 0x32, 0x35, 0x30, 0x33, 0x37, 0x36, 0x65, 0x39, 0x38, 0x36, 0x33, 0x65, 0x38, 0x38, 0x66, 0x37, 0x63, 0x34, 0x37, 0x31, 0x39, 0x62, 0x65, 0x63, 0x66, 0x39, 0x36, 0x64, 0x61, 0x32, 0x61, 0x66, 0x64, 0x62, 0x37, 0x63, 0x35, 0x37, 0x34, 0x35, 0x30, 0x38, 0x36, 0x66, 0x35, 0x66, 0x65, 0x39, 0x62, 0x37, 0x39, 0x38, 0x39, 0x65, 0x36, 0x35, 0x63, 0x34, 0x30, 0x35, 0x37, 0x65, 0x37, 0x32, 0x39, 0x31, 0x37, 0x31, 0x36, 0x34, 0x39, 0x34, 0x34, 0x31, 0x31, 0x38, 0x65, 0x34, 0x38, 0x36, 0x31, 0x65, 0x63, 0x37, 0x34, 0x64, 0x33, 0x65, 0x32, 0x32, 0x30, 0x63, 0x65, 0x31, 0x38, 0x66, 0x37, 0x65, 0x35, 0x31, 0x65, 0x36, 0x37, 0x34, 0x37, 0x39, 0x64, 0x62, 0x34, 0x32, 0x30, 0x64, 0x39, 0x61, 0x62, 0x39, 0x36, 0x62, 0x31, 0x30, 0x37, 0x32, 0x38, 0x38, 0x32, 0x65, 0x37, 0x31, 0x65, 0x65, 0x35, 0x33, 0x37, 0x63, 0x65, 0x66, 0x31, 0x37, 0x31, 0x63, 0x37, 0x36, 0x32, 0x35, 0x30, 0x61, 0x38, 0x31, 0x65, 0x62, 0x63, 0x35, 0x39, 0x39, 0x32, 0x64, 0x32, 0x35, 0x38, 0x66, 0x63, 0x31, 0x39, 0x34, 0x35, 0x39, 0x65, 0x63, 0x32, 0x65, 0x66, 0x39, 0x38, 0x34, 0x38, 0x30, 0x39, 0x35, 0x35, 0x36, 0x65, 0x31, 0x34, 0x31, 0x62, 0x32, 0x33, 0x63, 0x62, 0x32, 0x34, 0x34, 0x61, 0x64, 0x63, 0x31, 0x64, 0x61, 0x39, 0x62, 0x62, 0x65, 0x62, 0x31, 0x37, 0x34, 0x64, 0x63, 0x61, 0x34, 0x62, 0x66, 0x61, 0x37, 0x32, 0x31, 0x33, 0x37, 0x37, 0x39, 0x34, 0x35, 0x30, 0x63, 0x64, 0x37, 0x65, 0x62, 0x61, 0x35, 0x63, 0x64, 0x66, 0x62, 0x34, 0x31, 0x33, 0x34, 0x32, 0x62, 0x65, 0x39, 0x66, 0x36, 0x33, 0x30, 0x62, 0x34, 0x35, 0x39, 0x36, 0x63, 0x65, 0x66, 0x33, 0x65, 0x66, 0x38, 0x32, 0x32, 0x64, 0x66, 0x39, 0x33, 0x61, 0x30, 0x64, 0x62, 0x39, 0x61, 0x31, 0x31, 0x64, 0x37, 0x35, 0x33, 0x63, 0x63, 0x64, 0x38, 0x37, 0x63, 0x38, 0x65, 0x65, 0x33, 0x32, 0x39, 0x30, 0x30, 0x31, 0x63, 0x39, 0x65, 0x63, 0x38, 0x63, 0x66, 0x39, 0x37, 0x65, 0x35, 0x66, 0x61, 0x39, 0x65, 0x37, 0x61, 0x37, 0x36, 0x64, 0x65, 0x33, 0x34, 0x34, 0x32, 0x66, 0x35, 0x30, 0x33, 0x32, 0x30, 0x61, 0x61, 0x31, 0x38, 0x39, 0x36, 0x66, 0x61, 0x65, 0x62, 0x64, 0x66, 0x65, 0x34, 0x35, 0x32, 0x66, 0x31, 0x65, 0x62, 0x61, 0x30, 0x61, 0x61, 0x33, 0x65, 0x35, 0x64, 0x61, 0x62, 0x63, 0x66, 0x66, 0x35, 0x32, 0x36, 0x38, 0x38, 0x61, 0x32, 0x31, 0x39, 0x35, 0x33, 0x39, 0x64, 0x62, 0x34, 0x39, 0x63, 0x33, 0x61, 0x64, 0x63, 0x65, 0x30, 0x35, 0x39, 0x64, 0x34, 0x37, 0x32, 0x36, 0x66, 0x64, 0x39, 0x66, 0x33, 0x31, 0x63, 0x32, 0x36, 0x64, 0x30, 0x66, 0x32, 0x37, 0x66, 0x36, 0x62, 0x38, 0x34, 0x30, 0x38, 0x64, 0x61, 0x30, 0x64, 0x38, 0x63, 0x32, 0x31, 0x33, 0x31, 0x37, 0x63, 0x64, 0x31, 0x33, 0x62, 0x30, 0x32, 0x35, 0x35, 0x34, 0x64, 0x30, 0x61, 0x39, 0x38, 0x30, 0x30, 0x66, 0x39, 0x62, 0x36, 0x37, 0x33, 0x37, 0x61, 0x61, 0x32, 0x63, 0x32, 0x37, 0x32, 0x63, 0x64, 0x61, 0x34, 0x66, 0x66, 0x66, 0x32, 0x39, 0x36, 0x38, 0x61, 0x30, 0x38, 0x35, 0x30, 0x66, 0x30, 0x66, 0x62, 0x65, 0x66, 0x39, 0x39, 0x62, 0x66, 0x36, 0x65, 0x65, 0x39, 0x64, 0x38, 0x63, 0x34, 0x65, 0x39, 0x66, 0x38, 0x36, 0x61, 0x31, 0x36, 0x30, 0x63, 0x63, 0x34, 0x38, 0x64, 0x35, 0x66, 0x66, 0x39, 0x33, 0x61, 0x39, 0x61, 0x64, 0x38, 0x32, 0x39, 0x61, 0x36, 0x36, 0x32, 0x34, 0x35, 0x66, 0x38, 0x66, 0x62, 0x33, 0x39, 0x63, 0x33, 0x34, 0x61, 0x33, 0x63, 0x61, 0x36, 0x33, 0x36, 0x31, 0x30, 0x35, 0x62, 0x35, 0x33, 0x61, 0x38, 0x35, 0x33, 0x65, 0x63, 0x32, 0x37, 0x35, 0x31, 0x36, 0x34, 0x64, 0x35, 0x36, 0x61, 0x30, 0x39, 0x62, 0x62, 0x30, 0x36, 0x65, 0x36, 0x66, 0x34, 0x32, 0x37, 0x61, 0x34, 0x35, 0x34, 0x33, 0x37, 0x64, 0x62, 0x64, 0x30, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x66, 0x37, 0x35, 0x63, 0x63, 0x30, 0x34, 0x31, 0x39, 0x62, 0x65, 0x38, 0x63, 0x61, 0x61, 0x33, 0x34, 0x35, 0x65, 0x38, 0x62, 0x33, 0x36, 0x39, 0x62, 0x36, 0x39, 0x65, 0x64, 0x61, 0x39, 0x61, 0x65, 0x61, 0x32, 0x62, 0x61, 0x37, 0x64, 0x39, 0x35, 0x32, 0x63, 0x39, 0x31, 0x64, 0x34, 0x61, 0x36, 0x39, 0x37, 0x61, 0x30, 0x66, 0x62, 0x32, 0x64, 0x65, 0x64, 0x35, 0x37, 0x65, 0x63, 0x64, 0x39, 0x33, 0x62, 0x61, 0x36, 0x37, 0x30, 0x38, 0x65, 0x62, 0x33, 0x36, 0x63, 0x36, 0x36, 0x33, 0x33, 0x37, 0x34, 0x39, 0x66, 0x38, 0x63, 0x64, 0x63, 0x66, 0x65, 0x38, 0x34, 0x62, 0x65, 0x35, 0x33, 0x38, 0x66, 0x38, 0x61, 0x38, 0x35, 0x66, 0x39, 0x32, 0x65, 0x65, 0x65, 0x62, 0x65, 0x32, 0x38, 0x61, 0x30, 0x30, 0x33, 0x63, 0x36, 0x35, 0x32, 0x64, 0x36, 0x64, 0x35, 0x30, 0x65, 0x33, 0x62, 0x35, 0x32, 0x32, 0x62, 0x39, 0x35, 0x34, 0x32, 0x31, 0x33, 0x64, 0x35, 0x30, 0x65, 0x30, 0x65, 0x37, 0x65, 0x35, 0x66, 0x33, 0x61, 0x63, 0x35, 0x35, 0x63, 0x64, 0x33, 0x38, 0x61, 0x39, 0x33, 0x33, 0x38, 0x64, 0x34, 0x30, 0x38, 0x37, 0x34, 0x63, 0x63, 0x31, 0x30, 0x66, 0x62, 0x64, 0x34, 0x65, 0x63, 0x38, 0x63, 0x64, 0x37, 0x37, 0x32, 0x66, 0x32, 0x66, 0x62, 0x63, 0x30, 0x35, 0x37, 0x39, 0x37, 0x38, 0x36, 0x36, 0x62, 0x65, 0x65, 0x37, 0x39, 0x66, 0x65, 0x31, 0x62, 0x38, 0x37, 0x37, 0x33, 0x64, 0x34, 0x34, 0x30, 0x65, 0x35, 0x62, 0x35, 0x36, 0x32, 0x34, 0x66, 0x36, 0x32, 0x35, 0x63, 0x32, 0x38, 0x30, 0x66, 0x66, 0x33, 0x34, 0x63, 0x35, 0x39, 0x34, 0x61, 0x38, 0x64, 0x38, 0x64, 0x35, 0x32, 0x61, 0x32, 0x30, 0x31, 0x35, 0x31, 0x62, 0x63, 0x33, 0x34, 0x32, 0x63, 0x38, 0x39, 0x64, 0x62, 0x63, 0x62, 0x62, 0x61, 0x34, 0x34, 0x36, 0x33, 0x31, 0x30, 0x61, 0x65, 0x37, 0x61, 0x62, 0x39, 0x63, 0x62, 0x38, 0x62, 0x66, 0x34, 0x36, 0x62, 0x34, 0x63, 0x64, 0x35, 0x34, 0x37, 0x61, 0x63, 0x36, 0x63, 0x65, 0x34, 0x30, 0x65, 0x35, 0x65, 0x61, 0x34, 0x64, 0x33, 0x31, 0x36, 0x37, 0x31, 0x38, 0x36, 0x37, 0x32, 0x65, 0x63, 0x65, 0x31, 0x36, 0x62, 0x35, 0x66, 0x33, 0x34, 0x38, 0x63, 0x65, 0x65, 0x32, 0x65, 0x61, 0x61, 0x39, 0x35, 0x33, 0x66, 0x34, 0x33, 0x65, 0x38, 0x38, 0x33, 0x36, 0x62, 0x63, 0x38, 0x63, 0x34, 0x35, 0x64, 0x36, 0x66, 0x33, 0x39, 0x62, 0x36, 0x36, 0x64, 0x37, 0x62, 0x36, 0x62, 0x65, 0x65, 0x66, 0x30, 0x37, 0x33, 0x66, 0x63, 0x35, 0x31, 0x30, 0x36, 0x32, 0x66, 0x35, 0x30, 0x66, 0x66, 0x63, 0x34, 0x64, 0x61, 0x62, 0x39, 0x65, 0x35, 0x39, 0x35, 0x33, 0x31, 0x32, 0x38, 0x34, 0x38, 0x63, 0x62, 0x66, 0x39, 0x30, 0x63, 0x35, 0x35, 0x39, 0x62, 0x30, 0x62, 0x35, 0x63, 0x31, 0x30, 0x65, 0x38, 0x31, 0x37, 0x33, 0x61, 0x65, 0x64, 0x66, 0x31, 0x66, 0x31, 0x65, 0x30, 0x35, 0x63, 0x34, 0x64, 0x36, 0x30, 0x38, 0x32, 0x31, 0x36, 0x65, 0x64, 0x62, 0x65, 0x37, 0x32, 0x63, 0x31, 0x38, 0x31, 0x33, 0x36, 0x34, 0x30, 0x36, 0x61, 0x31, 0x33, 0x35, 0x63, 0x37, 0x62, 0x64, 0x61, 0x66, 0x64, 0x64, 0x37, 0x65, 0x36, 0x65, 0x36, 0x32, 0x34, 0x32, 0x31, 0x61, 0x61, 0x39, 0x39, 0x62, 0x61, 0x39, 0x37, 0x62, 0x37, 0x62, 0x30, 0x31, 0x34, 0x63, 0x36, 0x39, 0x31, 0x34, 0x65, 0x61, 0x33, 0x38, 0x33, 0x32, 0x36, 0x36, 0x32, 0x38, 0x30, 0x38, 0x64, 0x35, 0x37, 0x30, 0x62, 0x65, 0x62, 0x65, 0x30, 0x38, 0x36, 0x30, 0x36, 0x38, 0x32, 0x63, 0x37, 0x35, 0x61, 0x62, 0x62, 0x33, 0x34, 0x35, 0x39, 0x65, 0x62, 0x35, 0x61, 0x61, 0x38, 0x34, 0x39, 0x31, 0x64, 0x30, 0x64, 0x32, 0x38, 0x66, 0x64, 0x63, 0x38, 0x61, 0x34, 0x64, 0x35, 0x36, 0x62, 0x61, 0x32, 0x63, 0x39, 0x66, 0x38, 0x65, 0x33, 0x35, 0x32, 0x33, 0x36, 0x64, 0x65, 0x34, 0x31, 0x32, 0x36, 0x31, 0x37, 0x39, 0x32, 0x66, 0x38, 0x65, 0x64, 0x33, 0x39, 0x30, 0x34, 0x62, 0x32, 0x65, 0x37, 0x64, 0x39, 0x37, 0x37, 0x33, 0x31, 0x63, 0x30, 0x64, 0x30, 0x32, 0x31, 0x30, 0x37, 0x63, 0x31, 0x64, 0x36, 0x62, 0x32, 0x30, 0x31, 0x30, 0x39, 0x31, 0x38, 0x65, 0x39, 0x36, 0x61, 0x61, 0x37, 0x64, 0x32, 0x64, 0x34, 0x37, 0x39, 0x36, 0x39, 0x34, 0x66, 0x66, 0x32, 0x33, 0x66, 0x31, 0x37, 0x66, 0x32, 0x39, 0x34, 0x39, 0x34, 0x30, 0x66, 0x62, 0x66, 0x32, 0x31, 0x66, 0x30, 0x34, 0x66, 0x31, 0x36, 0x36, 0x35, 0x63, 0x66, 0x61, 0x36, 0x66, 0x37, 0x65, 0x33, 0x61, 0x62, 0x36, 0x34, 0x62, 0x30, 0x34, 0x31, 0x33, 0x35, 0x32, 0x35, 0x61, 0x66, 0x62, 0x65, 0x62, 0x66, 0x34, 0x38, 0x36, 0x65, 0x65, 0x38, 0x63, 0x65, 0x35, 0x64, 0x30, 0x63, 0x65, 0x33, 0x64, 0x33, 0x31, 0x39, 0x63, 0x61, 0x38, 0x36, 0x63, 0x39, 0x36, 0x65, 0x66, 0x65, 0x38, 0x36, 0x39, 0x62, 0x30, 0x31, 0x61, 0x31, 0x62, 0x61, 0x63, 0x61, 0x66, 0x36, 0x64, 0x33, 0x30, 0x32, 0x63, 0x64, 0x36, 0x66, 0x63, 0x32, 0x62, 0x63, 0x30, 0x34, 0x35, 0x30, 0x33, 0x64, 0x61, 0x31, 0x34, 0x63, 0x62, 0x61, 0x64, 0x33, 0x30, 0x38, 0x62, 0x38, 0x63, 0x61, 0x61, 0x63, 0x39, 0x62, 0x66, 0x39, 0x31, 0x33, 0x64, 0x63, 0x30, 0x39, 0x35, 0x66, 0x63, 0x65, 0x65, 0x34, 0x65, 0x30, 0x30, 0x63, 0x32, 0x62, 0x62, 0x34, 0x66, 0x66, 0x36, 0x66, 0x63, 0x33, 0x38, 0x61, 0x66, 0x63, 0x62, 0x30, 0x37, 0x38, 0x66, 0x34, 0x37, 0x34, 0x36, 0x36, 0x36, 0x63, 0x63, 0x32, 0x32, 0x30, 0x34, 0x37, 0x39, 0x33, 0x35, 0x31, 0x65, 0x39, 0x66, 0x65, 0x39, 0x34, 0x39, 0x66, 0x31, 0x35, 0x33, 0x61, 0x37, 0x32, 0x39, 0x34, 0x30, 0x31, 0x66, 0x37, 0x62, 0x39, 0x62, 0x32, 0x33, 0x66, 0x31, 0x31, 0x38, 0x30, 0x36, 0x30, 0x33, 0x37, 0x64, 0x39, 0x39, 0x64, 0x64, 0x66, 0x65, 0x32, 0x66, 0x34, 0x63, 0x62, 0x63, 0x38, 0x33, 0x35, 0x39, 0x33, 0x36, 0x34, 0x39, 0x65, 0x39, 0x33, 0x32, 0x61, 0x31, 0x63, 0x37, 0x63, 0x65, 0x65, 0x65, 0x35, 0x38, 0x34, 0x63, 0x64, 0x37, 0x61, 0x37, 0x30, 0x37, 0x32, 0x62, 0x35, 0x65, 0x37, 0x63, 0x62, 0x65, 0x39, 0x30, 0x65, 0x61, 0x35, 0x38, 0x36, 0x36, 0x36, 0x33, 0x38, 0x63, 0x63, 0x31, 0x61, 0x61, 0x38, 0x35, 0x61, 0x65, 0x37, 0x63, 0x64, 0x34, 0x35, 0x31, 0x65, 0x33, 0x37, 0x65, 0x37, 0x35, 0x31, 0x66, 0x66, 0x35, 0x30, 0x30, 0x65, 0x35, 0x38, 0x39, 0x33, 0x36, 0x32, 0x39, 0x65, 0x32, 0x37, 0x32, 0x36, 0x35, 0x37, 0x38, 0x65, 0x37, 0x32, 0x37, 0x65, 0x32, 0x63, 0x64, 0x34, 0x34, 0x31, 0x36, 0x37, 0x37, 0x65, 0x35, 0x61, 0x61, 0x30, 0x30, 0x33, 0x33, 0x38, 0x36, 0x37, 0x35, 0x39, 0x39, 0x34, 0x61, 0x39, 0x63, 0x36, 0x34, 0x38, 0x38, 0x31, 0x62, 0x39, 0x64, 0x61, 0x34, 0x65, 0x38, 0x61, 0x33, 0x31, 0x64, 0x36, 0x38, 0x65, 0x63, 0x61, 0x64, 0x39, 0x35, 0x63, 0x61, 0x38, 0x32, 0x33, 0x33, 0x66, 0x33, 0x33, 0x37, 0x32, 0x37, 0x61, 0x35, 0x30, 0x38, 0x35, 0x34, 0x39, 0x63, 0x32, 0x64, 0x36, 0x38, 0x37, 0x61, 0x33, 0x38, 0x63, 0x35, 0x30, 0x66, 0x66, 0x39, 0x66, 0x36, 0x33, 0x39, 0x64, 0x32, 0x30, 0x35, 0x37, 0x61, 0x63, 0x61, 0x63, 0x38, 0x64, 0x38, 0x65, 0x39, 0x35, 0x61, 0x32, 0x66, 0x31, 0x61, 0x36, 0x62, 0x37, 0x36, 0x37, 0x65, 0x63, 0x34, 0x31, 0x63, 0x32, 0x63, 0x37, 0x36, 0x36, 0x32, 0x39, 0x33, 0x61, 0x31, 0x65, 0x33, 0x62, 0x30, 0x64, 0x30, 0x32, 0x37, 0x37, 0x33, 0x61, 0x62, 0x32, 0x32, 0x38, 0x39, 0x32, 0x61, 0x38, 0x61, 0x30, 0x39, 0x32, 0x34, 0x32, 0x30, 0x39, 0x62, 0x34, 0x31, 0x32, 0x64, 0x31, 0x35, 0x39, 0x34, 0x35, 0x33, 0x36, 0x62, 0x33, 0x61, 0x37, 0x36, 0x39, 0x66, 0x38, 0x38, 0x38, 0x66, 0x39, 0x35, 0x39, 0x35, 0x34, 0x33, 0x30, 0x39, 0x65, 0x36, 0x65, 0x33, 0x35, 0x35, 0x61, 0x38, 0x32, 0x30, 0x38, 0x34, 0x39, 0x39, 0x30, 0x61, 0x32, 0x36, 0x36, 0x37, 0x30, 0x63, 0x38, 0x31, 0x35, 0x64, 0x64, 0x34, 0x62, 0x34, 0x32, 0x39, 0x66, 0x33, 0x31, 0x34, 0x66, 0x30, 0x66, 0x63, 0x61, 0x64, 0x66, 0x63, 0x33, 0x62, 0x33, 0x64, 0x65, 0x65, 0x33, 0x35, 0x61, 0x31, 0x61, 0x30, 0x64, 0x31, 0x31, 0x36, 0x35, 0x64, 0x65, 0x38, 0x31, 0x30, 0x39, 0x64, 0x63, 0x62, 0x34, 0x37, 0x64, 0x66, 0x64, 0x39, 0x63, 0x37, 0x35, 0x63, 0x61, 0x33, 0x62, 0x33, 0x62, 0x37, 0x35, 0x66, 0x64, 0x61, 0x61, 0x62, 0x61, 0x37, 0x34, 0x36, 0x37, 0x39, 0x30, 0x65, 0x65, 0x31, 0x62, 0x63, 0x38, 0x63, 0x65, 0x30, 0x31, 0x64, 0x39, 0x32, 0x37, 0x36, 0x63, 0x61, 0x37, 0x30, 0x66, 0x39, 0x33, 0x36, 0x63, 0x62, 0x35, 0x62, 0x33, 0x62, 0x62, 0x30, 0x39, 0x34, 0x33, 0x32, 0x63, 0x66, 0x62, 0x32, 0x35, 0x62, 0x30, 0x66, 0x33, 0x34, 0x38, 0x30, 0x62, 0x32, 0x32, 0x39, 0x65, 0x30, 0x61, 0x31, 0x36, 0x64, 0x66, 0x32, 0x33, 0x63, 0x31, 0x61, 0x35, 0x62, 0x32, 0x37, 0x37, 0x38, 0x65, 0x36, 0x64, 0x38, 0x63, 0x64, 0x65, 0x39, 0x36, 0x38, 0x63, 0x36, 0x31, 0x61, 0x37, 0x62, 0x63, 0x32, 0x36, 0x33, 0x34, 0x66, 0x35, 0x64, 0x61, 0x37, 0x32, 0x66, 0x62, 0x34, 0x64, 0x30, 0x34, 0x65, 0x39, 0x66, 0x66, 0x63, 0x66, 0x66, 0x36, 0x63, 0x33, 0x33, 0x37, 0x37, 0x36, 0x64, 0x38, 0x63, 0x32, 0x38, 0x38, 0x34, 0x38, 0x38, 0x65, 0x32, 0x39, 0x37, 0x61, 0x64, 0x61, 0x64, 0x38, 0x36, 0x30, 0x31, 0x66, 0x62, 0x39, 0x31, 0x36, 0x39, 0x35, 0x33, 0x63, 0x32, 0x66, 0x34, 0x32, 0x63, 0x38, 0x38, 0x66, 0x31, 0x32, 0x38, 0x61, 0x37, 0x32, 0x37, 0x66, 0x62, 0x36, 0x37, 0x61, 0x33, 0x61, 0x33, 0x61, 0x32, 0x64, 0x33, 0x38, 0x33, 0x32, 0x39, 0x35, 0x34, 0x38, 0x62, 0x38, 0x32, 0x35, 0x38, 0x65, 0x38, 0x37, 0x61, 0x39, 0x33, 0x37, 0x33, 0x63, 0x34, 0x66, 0x63, 0x38, 0x66, 0x30, 0x36, 0x62, 0x38, 0x37, 0x30, 0x35, 0x38, 0x65, 0x37, 0x62, 0x35, 0x35, 0x36, 0x39, 0x37, 0x37, 0x32, 0x31, 0x64, 0x62, 0x32, 0x61, 0x37, 0x32, 0x39, 0x32, 0x61, 0x37, 0x34, 0x33, 0x35, 0x36, 0x33, 0x32, 0x33, 0x32, 0x65, 0x65, 0x61, 0x32, 0x65, 0x36, 0x35, 0x66, 0x33, 0x63, 0x34, 0x34, 0x63, 0x30, 0x31, 0x35, 0x39, 0x31, 0x33, 0x66, 0x32, 0x35, 0x36, 0x34, 0x61, 0x36, 0x35, 0x39, 0x39, 0x61, 0x35, 0x66, 0x34, 0x34, 0x65, 0x35, 0x39, 0x66, 0x63, 0x30, 0x36, 0x36, 0x38, 0x62, 0x35, 0x38, 0x38, 0x35, 0x37, 0x35, 0x37, 0x32, 0x64, 0x35, 0x36, 0x37, 0x39, 0x65, 0x33, 0x38, 0x37, 0x63, 0x36, 0x35, 0x34, 0x31, 0x34, 0x65, 0x62, 0x31, 0x32, 0x33, 0x61, 0x33, 0x30, 0x35, 0x63, 0x30, 0x34, 0x64, 0x37, 0x33, 0x37, 0x64, 0x30, 0x34, 0x34, 0x36, 0x30, 0x30, 0x37, 0x66, 0x33, 0x39, 0x32, 0x32, 0x64, 0x33, 0x34, 0x63, 0x39, 0x62, 0x36, 0x37, 0x30, 0x32, 0x33, 0x62, 0x61, 0x65, 0x34, 0x37, 0x35, 0x63, 0x37, 0x32, 0x66, 0x36, 0x39, 0x30, 0x62, 0x31, 0x65, 0x36, 0x34, 0x30, 0x64, 0x34, 0x61, 0x30, 0x61, 0x38, 0x34, 0x64, 0x30, 0x38, 0x31, 0x34, 0x63, 0x32, 0x66, 0x65, 0x31, 0x36, 0x65, 0x32, 0x35, 0x35, 0x33, 0x32, 0x37, 0x37, 0x34, 0x30, 0x65, 0x66, 0x32, 0x38, 0x39, 0x39, 0x66, 0x63, 0x64, 0x31, 0x37, 0x66, 0x34, 0x33, 0x37, 0x30, 0x65, 0x36, 0x33, 0x38, 0x34, 0x31, 0x33, 0x30, 0x37, 0x32, 0x66, 0x62, 0x62, 0x31, 0x39, 0x30, 0x30, 0x66, 0x36, 0x65, 0x34, 0x62, 0x30, 0x34, 0x62, 0x66, 0x31, 0x33, 0x35, 0x64, 0x37, 0x62, 0x31, 0x65, 0x65, 0x34, 0x62, 0x64, 0x30, 0x33, 0x32, 0x36, 0x34, 0x31, 0x64, 0x30, 0x35, 0x35, 0x33, 0x37, 0x65, 0x31, 0x33, 0x62, 0x31, 0x62, 0x32, 0x61, 0x33, 0x39, 0x37, 0x36, 0x34, 0x30, 0x31, 0x32, 0x30, 0x34, 0x61, 0x66, 0x38, 0x35, 0x37, 0x32, 0x35, 0x63, 0x38, 0x33, 0x35, 0x65, 0x36, 0x35, 0x33, 0x34, 0x34, 0x65, 0x37, 0x34, 0x35, 0x30, 0x35, 0x31, 0x38, 0x35, 0x37, 0x32, 0x35, 0x62, 0x31, 0x32, 0x35, 0x62, 0x34, 0x33, 0x32, 0x65, 0x32, 0x35, 0x33, 0x62, 0x63, 0x65, 0x62, 0x64, 0x65, 0x32, 0x31, 0x37, 0x32, 0x37, 0x62, 0x63, 0x31, 0x62, 0x35, 0x33, 0x34, 0x62, 0x61, 0x62, 0x38, 0x65, 0x33, 0x64, 0x61, 0x62, 0x34, 0x61, 0x33, 0x64, 0x32, 0x64, 0x39, 0x31, 0x38, 0x33, 0x64, 0x38, 0x61, 0x34, 0x61, 0x36, 0x35, 0x30, 0x30, 0x65, 0x64, 0x32, 0x36, 0x30, 0x39, 0x37, 0x35, 0x33, 0x63, 0x32, 0x37, 0x37, 0x38, 0x65, 0x31, 0x39, 0x61, 0x62, 0x66, 0x32, 0x31, 0x63, 0x34, 0x65, 0x37, 0x37, 0x66, 0x30, 0x31, 0x36, 0x61, 0x30, 0x36, 0x31, 0x38, 0x63, 0x65, 0x34, 0x64, 0x34, 0x38, 0x33, 0x33, 0x32, 0x30, 0x61, 0x38, 0x33, 0x39, 0x65, 0x65, 0x38, 0x39, 0x35, 0x32, 0x30, 0x65, 0x36, 0x63, 0x37, 0x38, 0x32, 0x32, 0x32, 0x39, 0x62, 0x61, 0x34, 0x64, 0x61, 0x30, 0x66, 0x64, 0x64, 0x30, 0x30, 0x31, 0x32, 0x32, 0x33, 0x38, 0x35, 0x66, 0x35, 0x35, 0x65, 0x39, 0x34, 0x64, 0x32, 0x37, 0x65, 0x33, 0x61, 0x35, 0x65, 0x35, 0x34, 0x33, 0x30, 0x65, 0x36, 0x39, 0x66, 0x65, 0x35, 0x65, 0x33, 0x32, 0x39, 0x33, 0x31, 0x36, 0x39, 0x34, 0x33, 0x35, 0x66, 0x30, 0x62, 0x64, 0x61, 0x38, 0x66, 0x65, 0x34, 0x63, 0x34, 0x34, 0x35, 0x65, 0x31, 0x31, 0x65, 0x32, 0x62, 0x33, 0x32, 0x37, 0x33, 0x62, 0x32, 0x34, 0x63, 0x64, 0x31, 0x35, 0x61, 0x31, 0x32, 0x64, 0x64, 0x36, 0x37, 0x30, 0x36, 0x64, 0x61, 0x63, 0x63, 0x64, 0x30, 0x30, 0x39, 0x33, 0x31, 0x33, 0x33, 0x63, 0x33, 0x30, 0x36, 0x37, 0x32, 0x34, 0x31, 0x64, 0x32, 0x31, 0x35, 0x32, 0x37, 0x37, 0x31, 0x30, 0x35, 0x36, 0x63, 0x30, 0x31, 0x66, 0x66, 0x38, 0x37, 0x35, 0x30, 0x37, 0x65, 0x33, 0x64, 0x61, 0x39, 0x37, 0x34, 0x32, 0x37, 0x32, 0x33, 0x32, 0x33, 0x36, 0x61, 0x34, 0x33, 0x34, 0x61, 0x64, 0x39, 0x31, 0x65, 0x35, 0x38, 0x34, 0x61, 0x66, 0x63, 0x30, 0x32, 0x37, 0x39, 0x65, 0x38, 0x37, 0x36, 0x37, 0x35, 0x32, 0x31, 0x31, 0x30, 0x34, 0x31, 0x31, 0x64, 0x64, 0x39, 0x65, 0x61, 0x32, 0x32, 0x37, 0x36, 0x61, 0x31, 0x30, 0x32, 0x31, 0x37, 0x61, 0x32, 0x66, 0x39, 0x30, 0x31, 0x66, 0x63, 0x62, 0x36, 0x66, 0x66, 0x66, 0x66, 0x62, 0x39, 0x66, 0x32, 0x31, 0x30, 0x38, 0x64, 0x39, 0x65, 0x30, 0x63, 0x62, 0x33, 0x38, 0x64, 0x36, 0x66, 0x64, 0x65, 0x37, 0x61, 0x34, 0x32, 0x35, 0x31, 0x61, 0x36, 0x37, 0x32, 0x66, 0x38, 0x62, 0x63, 0x64, 0x33, 0x32, 0x36, 0x64, 0x34, 0x34, 0x64, 0x39, 0x36, 0x35, 0x64, 0x38, 0x33, 0x64, 0x32, 0x65, 0x33, 0x62, 0x34, 0x62, 0x62, 0x34, 0x36, 0x32, 0x30, 0x66, 0x35, 0x61, 0x35, 0x39, 0x64, 0x64, 0x30, 0x62, 0x64, 0x34, 0x30, 0x30, 0x34, 0x38, 0x31, 0x31, 0x66, 0x36, 0x62, 0x30, 0x38, 0x34, 0x33, 0x35, 0x36, 0x61, 0x65, 0x38, 0x63, 0x39, 0x38, 0x37, 0x32, 0x39, 0x63, 0x39, 0x30, 0x66, 0x30, 0x61, 0x34, 0x39, 0x34, 0x32, 0x30, 0x63, 0x62, 0x38, 0x31, 0x35, 0x66, 0x61, 0x38, 0x36, 0x62, 0x31, 0x36, 0x65, 0x37, 0x31, 0x38, 0x33, 0x61, 0x32, 0x31, 0x36, 0x32, 0x31, 0x38, 0x64, 0x61, 0x64, 0x39, 0x38, 0x30, 0x63, 0x35, 0x63, 0x61, 0x65, 0x62, 0x63, 0x33, 0x31, 0x65, 0x65, 0x38, 0x33, 0x64, 0x32, 0x39, 0x32, 0x38, 0x33, 0x66, 0x37, 0x32, 0x62, 0x30, 0x65, 0x35, 0x30, 0x65, 0x64, 0x39, 0x66, 0x65, 0x39, 0x35, 0x32, 0x61, 0x33, 0x65, 0x31, 0x66, 0x36, 0x38, 0x31, 0x34, 0x30, 0x61, 0x35, 0x39, 0x36, 0x36, 0x39, 0x39, 0x30, 0x37, 0x64, 0x64, 0x38, 0x65, 0x37, 0x38, 0x62, 0x66, 0x38, 0x35, 0x39, 0x61, 0x39, 0x65, 0x37, 0x65, 0x30, 0x34, 0x61, 0x36, 0x61, 0x30, 0x38, 0x37, 0x63, 0x39, 0x34, 0x38, 0x35, 0x31, 0x37, 0x32, 0x61, 0x36, 0x34, 0x32, 0x38, 0x63, 0x36, 0x37, 0x30, 0x33, 0x38, 0x62, 0x36, 0x33, 0x61, 0x37, 0x66, 0x39, 0x37, 0x39, 0x63, 0x64, 0x36, 0x35, 0x31, 0x31, 0x37, 0x65, 0x32, 0x37, 0x37, 0x35, 0x35, 0x30, 0x30, 0x66, 0x34, 0x64, 0x32, 0x39, 0x30, 0x39, 0x61, 0x34, 0x35, 0x38, 0x36, 0x30, 0x33, 0x30, 0x64, 0x35, 0x66, 0x61, 0x63, 0x30, 0x38, 0x37, 0x62, 0x63, 0x30, 0x32, 0x37, 0x32, 0x63, 0x63, 0x65, 0x64, 0x64, 0x35, 0x30, 0x63, 0x35, 0x64, 0x37, 0x34, 0x65, 0x62, 0x64, 0x32, 0x36, 0x37, 0x61, 0x62, 0x64, 0x30, 0x63, 0x66, 0x38, 0x34, 0x61, 0x31, 0x62, 0x63, 0x37, 0x32, 0x64, 0x33, 0x65, 0x66, 0x30, 0x32, 0x33, 0x62, 0x33, 0x31, 0x30, 0x64, 0x38, 0x34, 0x36, 0x64, 0x37, 0x34, 0x63, 0x38, 0x38, 0x32, 0x32, 0x30, 0x35, 0x34, 0x35, 0x64, 0x38, 0x34, 0x37, 0x32, 0x33, 0x65, 0x35, 0x39, 0x38, 0x63, 0x64, 0x35, 0x35, 0x30, 0x62, 0x32, 0x30, 0x61, 0x39, 0x65, 0x32, 0x36, 0x64, 0x30, 0x32, 0x33, 0x35, 0x33, 0x64, 0x33, 0x35, 0x66, 0x63, 0x66, 0x32, 0x37, 0x36, 0x32, 0x63, 0x63, 0x61, 0x61, 0x37, 0x63, 0x30, 0x38, 0x31, 0x61, 0x37, 0x64, 0x31, 0x37, 0x64, 0x35, 0x66, 0x63, 0x37, 0x32, 0x36, 0x32, 0x61, 0x37, 0x61, 0x32, 0x39, 0x65, 0x37, 0x31, 0x63, 0x64, 0x64, 0x35, 0x34, 0x35, 0x34, 0x35, 0x34, 0x31, 0x31, 0x31, 0x30, 0x62, 0x37, 0x37, 0x32, 0x34, 0x33, 0x34, 0x36, 0x64, 0x61, 0x33, 0x63, 0x31, 0x39, 0x38, 0x35, 0x30, 0x39, 0x61, 0x61, 0x38, 0x38, 0x62, 0x30, 0x33, 0x64, 0x62, 0x31, 0x64, 0x33, 0x30, 0x33, 0x31, 0x63, 0x35, 0x31, 0x61, 0x61, 0x30, 0x32, 0x31, 0x32, 0x37, 0x63, 0x34, 0x36, 0x32, 0x36, 0x39, 0x30, 0x62, 0x35, 0x30, 0x35, 0x37, 0x37, 0x30, 0x30, 0x35, 0x38, 0x63, 0x64, 0x38, 0x62, 0x38, 0x39, 0x64, 0x35, 0x34, 0x61, 0x39, 0x65, 0x34, 0x61, 0x31, 0x31, 0x33, 0x38, 0x37, 0x33, 0x63, 0x31, 0x32, 0x31, 0x63, 0x36, 0x66, 0x63, 0x31, 0x35, 0x65, 0x66, 0x35, 0x61, 0x31, 0x37, 0x33, 0x35, 0x30, 0x32, 0x39, 0x62, 0x66, 0x65, 0x31, 0x32, 0x35, 0x66, 0x62, 0x37, 0x33, 0x36, 0x30, 0x37, 0x32, 0x63, 0x30, 0x37, 0x38, 0x61, 0x62, 0x64, 0x37, 0x31, 0x32, 0x62, 0x36, 0x37, 0x30, 0x30, 0x61, 0x31, 0x36, 0x66, 0x36, 0x36, 0x61, 0x62, 0x61, 0x32, 0x63, 0x62, 0x62, 0x36, 0x37, 0x65, 0x65, 0x37, 0x31, 0x31, 0x32, 0x38, 0x31, 0x63, 0x66, 0x33, 0x35, 0x38, 0x32, 0x31, 0x31, 0x38, 0x30, 0x63, 0x63, 0x33, 0x35, 0x61, 0x32, 0x31, 0x64, 0x37, 0x64, 0x33, 0x66, 0x37, 0x33, 0x37, 0x32, 0x39, 0x32, 0x61, 0x62, 0x62, 0x64, 0x39, 0x33, 0x64, 0x64, 0x38, 0x35, 0x62, 0x64, 0x61, 0x64, 0x34, 0x31, 0x64, 0x64, 0x35, 0x37, 0x34, 0x33, 0x33, 0x30, 0x37, 0x63, 0x35, 0x36, 0x61, 0x32, 0x65, 0x64, 0x37, 0x37, 0x64, 0x32, 0x66, 0x62, 0x66, 0x35, 0x38, 0x61, 0x35, 0x64, 0x63, 0x32, 0x62, 0x66, 0x65, 0x66, 0x37, 0x32, 0x31, 0x35, 0x39, 0x61, 0x31, 0x31, 0x62, 0x34, 0x37, 0x32, 0x36, 0x37, 0x63, 0x63, 0x37, 0x31, 0x34, 0x37, 0x65, 0x63, 0x30, 0x37, 0x39, 0x30, 0x38, 0x30, 0x62, 0x61, 0x39, 0x62, 0x66, 0x30, 0x32, 0x39, 0x31, 0x63, 0x65, 0x39, 0x36, 0x65, 0x37, 0x30, 0x36, 0x62, 0x31, 0x36, 0x32, 0x38, 0x65, 0x35, 0x34, 0x63, 0x65, 0x66, 0x38, 0x37, 0x62, 0x32, 0x62, 0x39, 0x34, 0x34, 0x62, 0x36, 0x37, 0x32, 0x63, 0x32, 0x63, 0x33, 0x65, 0x31, 0x37, 0x32, 0x34, 0x31, 0x38, 0x61, 0x62, 0x32, 0x62, 0x31, 0x35, 0x30, 0x66, 0x38, 0x35, 0x32, 0x39, 0x35, 0x30, 0x31, 0x33, 0x36, 0x35, 0x39, 0x36, 0x65, 0x32, 0x61, 0x37, 0x36, 0x37, 0x35, 0x37, 0x36, 0x66, 0x32, 0x61, 0x33, 0x63, 0x38, 0x32, 0x62, 0x35, 0x66, 0x62, 0x33, 0x66, 0x37, 0x64, 0x61, 0x61, 0x36, 0x30, 0x32, 0x39, 0x66, 0x37, 0x30, 0x63, 0x36, 0x61, 0x31, 0x64, 0x66, 0x37, 0x32, 0x30, 0x33, 0x30, 0x36, 0x37, 0x63, 0x62, 0x38, 0x33, 0x36, 0x38, 0x34, 0x37, 0x63, 0x31, 0x30, 0x32, 0x61, 0x37, 0x36, 0x64, 0x63, 0x66, 0x66, 0x33, 0x64, 0x33, 0x30, 0x66, 0x39, 0x63, 0x39, 0x33, 0x65, 0x64, 0x35, 0x35, 0x63, 0x34, 0x31, 0x32, 0x36, 0x30, 0x30, 0x34, 0x65, 0x36, 0x65, 0x62, 0x30, 0x36, 0x64, 0x38, 0x32, 0x34, 0x30, 0x38, 0x35, 0x32, 0x65, 0x35, 0x63, 0x31, 0x61, 0x33, 0x36, 0x33, 0x32, 0x33, 0x64, 0x32, 0x65, 0x66, 0x64, 0x65, 0x39, 0x30, 0x63, 0x34, 0x34, 0x38, 0x38, 0x66, 0x36, 0x65, 0x64, 0x62, 0x66, 0x65, 0x30, 0x63, 0x31, 0x35, 0x66, 0x39, 0x66, 0x30, 0x65, 0x62, 0x38, 0x36, 0x35, 0x62, 0x63, 0x38, 0x63, 0x34, 0x36, 0x36, 0x62, 0x34, 0x36, 0x38, 0x34, 0x66, 0x65, 0x33, 0x61, 0x64, 0x64, 0x37, 0x63, 0x38, 0x62, 0x33, 0x39, 0x36, 0x66, 0x61, 0x63, 0x39, 0x39, 0x62, 0x35, 0x33, 0x38, 0x39, 0x37, 0x62, 0x64, 0x35, 0x37, 0x35, 0x38, 0x34, 0x39, 0x30, 0x32, 0x64, 0x63, 0x34, 0x36, 0x65, 0x30, 0x66, 0x33, 0x30, 0x36, 0x35, 0x65, 0x35, 0x36, 0x39, 0x35, 0x36, 0x33, 0x37, 0x37, 0x35, 0x64, 0x62, 0x61, 0x35, 0x35, 0x37, 0x32, 0x37, 0x63, 0x61, 0x38, 0x31, 0x33, 0x34, 0x66, 0x34, 0x63, 0x36, 0x39, 0x62, 0x38, 0x37, 0x32, 0x34, 0x39, 0x35, 0x65, 0x32, 0x35, 0x65, 0x36, 0x32, 0x64, 0x35, 0x64, 0x37, 0x39, 0x39, 0x35, 0x66, 0x36, 0x63, 0x39, 0x66, 0x37, 0x61, 0x65, 0x33, 0x30, 0x35, 0x34, 0x39, 0x38, 0x63, 0x36, 0x32, 0x66, 0x31, 0x31, 0x38, 0x33, 0x39, 0x34, 0x36, 0x62, 0x39, 0x66, 0x62, 0x37, 0x34, 0x31, 0x30, 0x65, 0x65, 0x61, 0x39, 0x38, 0x35, 0x38, 0x31, 0x30, 0x62, 0x65, 0x38, 0x30, 0x37, 0x32, 0x39, 0x39, 0x62, 0x35, 0x36, 0x64, 0x39, 0x31, 0x34, 0x63, 0x33, 0x30, 0x63, 0x32, 0x62, 0x32, 0x35, 0x66, 0x33, 0x37, 0x66, 0x61, 0x38, 0x31, 0x39, 0x35, 0x30, 0x62, 0x64, 0x66, 0x66, 0x39, 0x61, 0x32, 0x34, 0x30, 0x66, 0x36, 0x30, 0x30, 0x39, 0x36, 0x36, 0x66, 0x64, 0x61, 0x36, 0x32, 0x33, 0x33, 0x37, 0x65, 0x39, 0x64, 0x32, 0x33, 0x31, 0x32, 0x61, 0x64, 0x39, 0x63, 0x34, 0x66, 0x34, 0x31, 0x65, 0x65, 0x34, 0x62, 0x30, 0x32, 0x37, 0x34, 0x63, 0x30, 0x63, 0x36, 0x31, 0x33, 0x37, 0x33, 0x34, 0x33, 0x33, 0x33, 0x32, 0x61, 0x66, 0x37, 0x31, 0x30, 0x36, 0x32, 0x62, 0x65, 0x37, 0x32, 0x33, 0x38, 0x33, 0x36, 0x33, 0x37, 0x35, 0x34, 0x39, 0x65, 0x35, 0x62, 0x64, 0x34, 0x61, 0x32, 0x35, 0x35, 0x36, 0x66, 0x65, 0x33, 0x30, 0x62, 0x64, 0x37, 0x38, 0x39, 0x37, 0x32, 0x65, 0x31, 0x37, 0x30, 0x31, 0x37, 0x37, 0x64, 0x66, 0x35, 0x38, 0x35, 0x64, 0x36, 0x38, 0x37, 0x31, 0x64, 0x63, 0x63, 0x39, 0x63, 0x35, 0x66, 0x65, 0x39, 0x38, 0x63, 0x39, 0x32, 0x30, 0x33, 0x37, 0x66, 0x61, 0x34, 0x38, 0x62, 0x66, 0x39, 0x30, 0x30, 0x39, 0x35, 0x30, 0x61, 0x63, 0x39, 0x33, 0x34, 0x38, 0x62, 0x66, 0x36, 0x63, 0x33, 0x30, 0x36, 0x35, 0x62, 0x61, 0x38, 0x37, 0x32, 0x37, 0x62, 0x64, 0x64, 0x35, 0x30, 0x62, 0x61, 0x30, 0x36, 0x34, 0x33, 0x39, 0x65, 0x32, 0x61, 0x33, 0x35, 0x62, 0x35, 0x64, 0x62, 0x66, 0x66, 0x30, 0x61, 0x33, 0x33, 0x62, 0x39, 0x37, 0x38, 0x61, 0x61, 0x65, 0x30, 0x35, 0x31, 0x38, 0x32, 0x36, 0x39, 0x66, 0x64, 0x66, 0x61, 0x63, 0x30, 0x39, 0x34, 0x39, 0x32, 0x38, 0x66, 0x61, 0x34, 0x37, 0x38, 0x30, 0x31, 0x30, 0x33, 0x36, 0x35, 0x65, 0x66, 0x37, 0x63, 0x65, 0x34, 0x39, 0x64, 0x36, 0x32, 0x39, 0x31, 0x39, 0x35, 0x66, 0x61, 0x61, 0x36, 0x34, 0x65, 0x62, 0x36, 0x34, 0x65, 0x61, 0x38, 0x32, 0x36, 0x38, 0x36, 0x61, 0x34, 0x30, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x31, 0x65, 0x64, 0x36, 0x30, 0x38, 0x31, 0x38, 0x36, 0x34, 0x34, 0x66, 0x32, 0x61, 0x64, 0x39, 0x30, 0x63, 0x66, 0x32, 0x31, 0x65, 0x37, 0x32, 0x61, 0x37, 0x38, 0x32, 0x31, 0x63, 0x63, 0x35, 0x63, 0x39, 0x66, 0x36, 0x32, 0x38, 0x33, 0x63, 0x36, 0x61, 0x37, 0x65, 0x61, 0x37, 0x37, 0x35, 0x31, 0x39, 0x61, 0x39, 0x63, 0x62, 0x62, 0x39, 0x66, 0x36, 0x39, 0x34, 0x63, 0x65, 0x36, 0x32, 0x33, 0x63, 0x63, 0x61, 0x35, 0x35, 0x65, 0x37, 0x64, 0x33, 0x31, 0x66, 0x61, 0x38, 0x37, 0x62, 0x62, 0x64, 0x31, 0x63, 0x31, 0x33, 0x37, 0x32, 0x34, 0x66, 0x61, 0x36, 0x35, 0x36, 0x38, 0x38, 0x31, 0x64, 0x65, 0x61, 0x62, 0x64, 0x62, 0x64, 0x38, 0x66, 0x30, 0x63, 0x65, 0x38, 0x62, 0x64, 0x64, 0x34, 0x37, 0x38, 0x36, 0x64, 0x30, 0x34, 0x38, 0x61, 0x37, 0x31, 0x32, 0x34, 0x39, 0x36, 0x30, 0x30, 0x32, 0x35, 0x36, 0x63, 0x37, 0x64, 0x31, 0x63, 0x30, 0x38, 0x62, 0x39, 0x34, 0x33, 0x61, 0x34, 0x65, 0x61, 0x38, 0x64, 0x37, 0x32, 0x65, 0x37, 0x38, 0x33, 0x31, 0x39, 0x38, 0x32, 0x65, 0x36, 0x64, 0x65, 0x34, 0x38, 0x30, 0x64, 0x37, 0x65, 0x38, 0x34, 0x37, 0x63, 0x35, 0x37, 0x37, 0x64, 0x31, 0x63, 0x61, 0x39, 0x34, 0x63, 0x61, 0x66, 0x35, 0x38, 0x33, 0x63, 0x32, 0x37, 0x64, 0x64, 0x65, 0x62, 0x38, 0x36, 0x32, 0x64, 0x39, 0x61, 0x64, 0x31, 0x36, 0x32, 0x36, 0x35, 0x65, 0x38, 0x35, 0x66, 0x38, 0x32, 0x34, 0x63, 0x35, 0x33, 0x66, 0x36, 0x34, 0x38, 0x38, 0x33, 0x62, 0x35, 0x61, 0x31, 0x38, 0x39, 0x63, 0x37, 0x63, 0x33, 0x61, 0x30, 0x37, 0x66, 0x33, 0x35, 0x66, 0x30, 0x64, 0x36, 0x35, 0x31, 0x31, 0x65, 0x37, 0x33, 0x66, 0x64, 0x38, 0x61, 0x64, 0x63, 0x34, 0x64, 0x36, 0x36, 0x31, 0x63, 0x66, 0x36, 0x31, 0x34, 0x36, 0x34, 0x33, 0x30, 0x38, 0x36, 0x66, 0x33, 0x64, 0x36, 0x37, 0x30, 0x37, 0x32, 0x63, 0x66, 0x33, 0x64, 0x63, 0x34, 0x31, 0x32, 0x30, 0x34, 0x37, 0x32, 0x34, 0x61, 0x35, 0x38, 0x64, 0x30, 0x30, 0x35, 0x35, 0x36, 0x37, 0x39, 0x32, 0x65, 0x33, 0x66, 0x38, 0x63, 0x61, 0x35, 0x30, 0x35, 0x36, 0x33, 0x30, 0x61, 0x63, 0x31, 0x30, 0x30, 0x37, 0x65, 0x62, 0x37, 0x37, 0x64, 0x38, 0x32, 0x37, 0x39, 0x32, 0x30, 0x37, 0x33, 0x30, 0x30, 0x64, 0x37, 0x62, 0x39, 0x37, 0x32, 0x33, 0x30, 0x32, 0x31, 0x36, 0x33, 0x34, 0x66, 0x63, 0x36, 0x31, 0x63, 0x35, 0x31, 0x35, 0x34, 0x65, 0x34, 0x33, 0x62, 0x39, 0x31, 0x35, 0x31, 0x34, 0x64, 0x30, 0x61, 0x32, 0x38, 0x34, 0x39, 0x36, 0x31, 0x64, 0x30, 0x62, 0x65, 0x62, 0x31, 0x37, 0x35, 0x62, 0x32, 0x35, 0x32, 0x37, 0x38, 0x61, 0x61, 0x30, 0x31, 0x37, 0x30, 0x34, 0x34, 0x37, 0x64, 0x38, 0x39, 0x65, 0x61, 0x37, 0x32, 0x36, 0x31, 0x33, 0x36, 0x61, 0x36, 0x33, 0x62, 0x61, 0x62, 0x36, 0x36, 0x61, 0x38, 0x62, 0x36, 0x38, 0x38, 0x36, 0x64, 0x66, 0x38, 0x30, 0x30, 0x64, 0x37, 0x38, 0x39, 0x35, 0x64, 0x62, 0x39, 0x35, 0x34, 0x30, 0x64, 0x35, 0x62, 0x62, 0x36, 0x35, 0x33, 0x31, 0x61, 0x39, 0x38, 0x33, 0x33, 0x65, 0x37, 0x30, 0x39, 0x62, 0x30, 0x64, 0x34, 0x33, 0x38, 0x38, 0x34, 0x33, 0x37, 0x34, 0x37, 0x65, 0x39, 0x37, 0x37, 0x64, 0x35, 0x65, 0x32, 0x63, 0x61, 0x31, 0x39, 0x63, 0x38, 0x33, 0x33, 0x64, 0x33, 0x61, 0x36, 0x63, 0x63, 0x35, 0x36, 0x66, 0x66, 0x66, 0x31, 0x33, 0x33, 0x35, 0x63, 0x34, 0x62, 0x36, 0x37, 0x63, 0x66, 0x36, 0x65, 0x38, 0x61, 0x65, 0x32, 0x36, 0x62, 0x30, 0x30, 0x61, 0x33, 0x36, 0x37, 0x31, 0x64, 0x39, 0x33, 0x39, 0x35, 0x37, 0x66, 0x30, 0x36, 0x37, 0x32, 0x35, 0x34, 0x32, 0x65, 0x62, 0x62, 0x63, 0x62, 0x33, 0x36, 0x62, 0x35, 0x63, 0x33, 0x31, 0x36, 0x63, 0x64, 0x37, 0x36, 0x63, 0x33, 0x32, 0x31, 0x38, 0x63, 0x39, 0x62, 0x39, 0x63, 0x33, 0x66, 0x66, 0x34, 0x36, 0x38, 0x39, 0x65, 0x38, 0x61, 0x37, 0x35, 0x33, 0x39, 0x36, 0x66, 0x38, 0x64, 0x34, 0x30, 0x31, 0x36, 0x38, 0x36, 0x63, 0x32, 0x31, 0x33, 0x32, 0x65, 0x64, 0x30, 0x37, 0x32, 0x66, 0x64, 0x32, 0x39, 0x33, 0x31, 0x30, 0x32, 0x63, 0x37, 0x65, 0x62, 0x39, 0x61, 0x62, 0x63, 0x65, 0x64, 0x33, 0x31, 0x65, 0x33, 0x31, 0x35, 0x64, 0x32, 0x65, 0x34, 0x31, 0x35, 0x63, 0x39, 0x31, 0x66, 0x32, 0x64, 0x31, 0x65, 0x31, 0x31, 0x66, 0x38, 0x37, 0x33, 0x31, 0x30, 0x34, 0x36, 0x64, 0x63, 0x39, 0x63, 0x32, 0x62, 0x35, 0x37, 0x35, 0x35, 0x35, 0x32, 0x34, 0x36, 0x37, 0x32, 0x65, 0x35, 0x63, 0x34, 0x35, 0x34, 0x32, 0x36, 0x38, 0x63, 0x63, 0x65, 0x65, 0x30, 0x35, 0x35, 0x62, 0x34, 0x34, 0x63, 0x63, 0x64, 0x35, 0x39, 0x32, 0x33, 0x35, 0x65, 0x37, 0x37, 0x33, 0x30, 0x61, 0x39, 0x39, 0x32, 0x66, 0x33, 0x63, 0x63, 0x30, 0x63, 0x33, 0x39, 0x33, 0x39, 0x37, 0x63, 0x36, 0x64, 0x62, 0x31, 0x63, 0x34, 0x65, 0x38, 0x37, 0x38, 0x32, 0x62, 0x37, 0x65, 0x37, 0x32, 0x30, 0x66, 0x39, 0x37, 0x63, 0x33, 0x37, 0x38, 0x33, 0x62, 0x39, 0x39, 0x31, 0x63, 0x62, 0x38, 0x31, 0x37, 0x32, 0x34, 0x37, 0x39, 0x63, 0x38, 0x33, 0x33, 0x65, 0x39, 0x38, 0x38, 0x36, 0x62, 0x31, 0x35, 0x35, 0x37, 0x36, 0x66, 0x64, 0x64, 0x37, 0x38, 0x64, 0x31, 0x62, 0x36, 0x34, 0x31, 0x38, 0x38, 0x38, 0x32, 0x62, 0x33, 0x33, 0x33, 0x64, 0x33, 0x63, 0x39, 0x64, 0x39, 0x37, 0x32, 0x39, 0x39, 0x34, 0x38, 0x66, 0x32, 0x31, 0x32, 0x65, 0x37, 0x62, 0x65, 0x39, 0x38, 0x65, 0x37, 0x31, 0x30, 0x62, 0x37, 0x36, 0x35, 0x39, 0x66, 0x63, 0x65, 0x31, 0x30, 0x30, 0x30, 0x63, 0x35, 0x38, 0x30, 0x31, 0x63, 0x30, 0x32, 0x62, 0x38, 0x33, 0x65, 0x32, 0x32, 0x32, 0x32, 0x33, 0x61, 0x36, 0x35, 0x30, 0x35, 0x62, 0x37, 0x62, 0x34, 0x64, 0x66, 0x64, 0x39, 0x62, 0x36, 0x37, 0x32, 0x65, 0x38, 0x63, 0x61, 0x64, 0x62, 0x32, 0x33, 0x64, 0x32, 0x37, 0x34, 0x36, 0x31, 0x30, 0x30, 0x34, 0x35, 0x61, 0x30, 0x30, 0x62, 0x63, 0x38, 0x32, 0x38, 0x30, 0x36, 0x33, 0x62, 0x37, 0x36, 0x63, 0x33, 0x33, 0x64, 0x31, 0x31, 0x62, 0x33, 0x61, 0x65, 0x62, 0x34, 0x38, 0x38, 0x30, 0x63, 0x34, 0x38, 0x34, 0x64, 0x64, 0x61, 0x32, 0x35, 0x64, 0x32, 0x65, 0x63, 0x38, 0x37, 0x36, 0x65, 0x30, 0x64, 0x36, 0x37, 0x33, 0x31, 0x31, 0x65, 0x63, 0x37, 0x36, 0x65, 0x38, 0x30, 0x34, 0x39, 0x62, 0x36, 0x36, 0x65, 0x35, 0x36, 0x36, 0x62, 0x66, 0x39, 0x30, 0x61, 0x31, 0x39, 0x32, 0x37, 0x39, 0x33, 0x61, 0x36, 0x66, 0x39, 0x36, 0x39, 0x35, 0x65, 0x34, 0x35, 0x37, 0x39, 0x62, 0x36, 0x33, 0x36, 0x32, 0x37, 0x62, 0x34, 0x65, 0x35, 0x66, 0x62, 0x39, 0x34, 0x64, 0x37, 0x34, 0x65, 0x64, 0x63, 0x61, 0x32, 0x34, 0x34, 0x66, 0x63, 0x37, 0x36, 0x65, 0x38, 0x34, 0x65, 0x61, 0x30, 0x65, 0x39, 0x38, 0x39, 0x38, 0x64, 0x36, 0x64, 0x35, 0x39, 0x36, 0x39, 0x30, 0x65, 0x34, 0x31, 0x30, 0x35, 0x37, 0x37, 0x30, 0x63, 0x38, 0x36, 0x30, 0x37, 0x61, 0x63, 0x39, 0x36, 0x36, 0x34, 0x65, 0x62, 0x34, 0x39, 0x33, 0x66, 0x64, 0x34, 0x37, 0x35, 0x63, 0x31, 0x35, 0x37, 0x37, 0x32, 0x32, 0x35, 0x33, 0x62, 0x61, 0x62, 0x38, 0x65, 0x39, 0x32, 0x30, 0x66, 0x66, 0x61, 0x38, 0x31, 0x37, 0x36, 0x37, 0x31, 0x31, 0x37, 0x39, 0x37, 0x39, 0x39, 0x62, 0x36, 0x36, 0x37, 0x65, 0x63, 0x34, 0x37, 0x31, 0x36, 0x36, 0x32, 0x39, 0x65, 0x66, 0x61, 0x36, 0x37, 0x37, 0x34, 0x32, 0x62, 0x32, 0x32, 0x64, 0x66, 0x39, 0x32, 0x64, 0x63, 0x36, 0x35, 0x32, 0x38, 0x32, 0x64, 0x36, 0x65, 0x64, 0x37, 0x62, 0x32, 0x37, 0x34, 0x33, 0x63, 0x30, 0x34, 0x34, 0x62, 0x37, 0x31, 0x37, 0x64, 0x30, 0x62, 0x30, 0x66, 0x64, 0x63, 0x30, 0x36, 0x32, 0x35, 0x62, 0x33, 0x37, 0x31, 0x39, 0x31, 0x38, 0x38, 0x63, 0x36, 0x32, 0x66, 0x61, 0x39, 0x37, 0x62, 0x65, 0x30, 0x34, 0x37, 0x32, 0x32, 0x34, 0x38, 0x64, 0x31, 0x32, 0x65, 0x30, 0x33, 0x39, 0x64, 0x32, 0x61, 0x34, 0x63, 0x37, 0x32, 0x39, 0x35, 0x38, 0x35, 0x30, 0x39, 0x35, 0x63, 0x34, 0x32, 0x34, 0x32, 0x32, 0x63, 0x39, 0x33, 0x33, 0x66, 0x61, 0x64, 0x38, 0x38, 0x38, 0x39, 0x38, 0x62, 0x38, 0x36, 0x37, 0x33, 0x61, 0x65, 0x66, 0x66, 0x61, 0x64, 0x66, 0x30, 0x36, 0x63, 0x65, 0x33, 0x63, 0x34, 0x34, 0x37, 0x35, 0x35, 0x34, 0x36, 0x33, 0x66, 0x35, 0x38, 0x66, 0x61, 0x31, 0x38, 0x31, 0x34, 0x39, 0x62, 0x37, 0x32, 0x38, 0x35, 0x31, 0x32, 0x62, 0x35, 0x32, 0x64, 0x33, 0x31, 0x37, 0x37, 0x34, 0x34, 0x61, 0x37, 0x61, 0x32, 0x34, 0x32, 0x39, 0x65, 0x36, 0x33, 0x63, 0x61, 0x66, 0x38, 0x36, 0x34, 0x64, 0x31, 0x38, 0x32, 0x30, 0x63, 0x34, 0x66, 0x63, 0x33, 0x37, 0x66, 0x32, 0x38, 0x32, 0x66, 0x30, 0x64, 0x63, 0x39, 0x39, 0x63, 0x38, 0x31, 0x32, 0x38, 0x61, 0x63, 0x36, 0x66, 0x31, 0x66, 0x37, 0x32, 0x39, 0x64, 0x35, 0x32, 0x39, 0x66, 0x66, 0x39, 0x30, 0x32, 0x62, 0x30, 0x31, 0x34, 0x65, 0x61, 0x39, 0x63, 0x38, 0x65, 0x66, 0x39, 0x66, 0x63, 0x66, 0x35, 0x66, 0x31, 0x39, 0x66, 0x37, 0x31, 0x66, 0x62, 0x63, 0x64, 0x38, 0x35, 0x61, 0x35, 0x64, 0x63, 0x38, 0x35, 0x62, 0x64, 0x35, 0x36, 0x63, 0x38, 0x62, 0x37, 0x38, 0x63, 0x30, 0x64, 0x30, 0x36, 0x35, 0x65, 0x38, 0x38, 0x33, 0x38, 0x37, 0x32, 0x35, 0x62, 0x62, 0x61, 0x36, 0x64, 0x39, 0x30, 0x65, 0x36, 0x35, 0x61, 0x64, 0x31, 0x35, 0x31, 0x63, 0x38, 0x37, 0x32, 0x35, 0x37, 0x34, 0x32, 0x65, 0x61, 0x35, 0x61, 0x62, 0x63, 0x63, 0x36, 0x34, 0x35, 0x61, 0x36, 0x36, 0x65, 0x32, 0x39, 0x34, 0x62, 0x32, 0x64, 0x30, 0x33, 0x30, 0x39, 0x65, 0x65, 0x31, 0x30, 0x33, 0x30, 0x34, 0x39, 0x39, 0x39, 0x65, 0x37, 0x35, 0x33, 0x64, 0x37, 0x37, 0x38, 0x34, 0x31, 0x32, 0x37, 0x34, 0x34, 0x31, 0x33, 0x65, 0x38, 0x37, 0x39, 0x35, 0x38, 0x31, 0x37, 0x62, 0x66, 0x64, 0x66, 0x38, 0x31, 0x66, 0x66, 0x61, 0x31, 0x64, 0x35, 0x35, 0x32, 0x31, 0x62, 0x64, 0x65, 0x63, 0x38, 0x39, 0x32, 0x30, 0x32, 0x35, 0x31, 0x30, 0x38, 0x33, 0x35, 0x62, 0x32, 0x64, 0x39, 0x38, 0x63, 0x37, 0x37, 0x61, 0x31, 0x31, 0x33, 0x30, 0x32, 0x33, 0x36, 0x62, 0x35, 0x62, 0x35, 0x65, 0x33, 0x32, 0x39, 0x34, 0x63, 0x62, 0x64, 0x64, 0x34, 0x34, 0x65, 0x34, 0x62, 0x30, 0x35, 0x30, 0x39, 0x31, 0x36, 0x66, 0x61, 0x38, 0x38, 0x35, 0x35, 0x33, 0x37, 0x38, 0x34, 0x33, 0x30, 0x63, 0x37, 0x32, 0x61, 0x62, 0x62, 0x65, 0x66, 0x65, 0x33, 0x32, 0x66, 0x65, 0x32, 0x36, 0x62, 0x39, 0x36, 0x30, 0x34, 0x32, 0x33, 0x65, 0x61, 0x37, 0x32, 0x65, 0x32, 0x39, 0x34, 0x61, 0x33, 0x63, 0x62, 0x37, 0x62, 0x34, 0x39, 0x30, 0x35, 0x36, 0x36, 0x32, 0x39, 0x39, 0x66, 0x66, 0x65, 0x66, 0x34, 0x34, 0x31, 0x31, 0x63, 0x31, 0x31, 0x64, 0x38, 0x33, 0x61, 0x66, 0x39, 0x61, 0x34, 0x39, 0x37, 0x65, 0x33, 0x39, 0x63, 0x36, 0x66, 0x38, 0x63, 0x61, 0x61, 0x66, 0x62, 0x65, 0x61, 0x64, 0x34, 0x62, 0x34, 0x65, 0x32, 0x64, 0x35, 0x37, 0x32, 0x65, 0x65, 0x61, 0x39, 0x64, 0x33, 0x32, 0x32, 0x38, 0x33, 0x35, 0x37, 0x64, 0x33, 0x61, 0x66, 0x35, 0x35, 0x33, 0x38, 0x65, 0x31, 0x34, 0x35, 0x39, 0x66, 0x64, 0x66, 0x33, 0x31, 0x37, 0x33, 0x62, 0x62, 0x36, 0x37, 0x38, 0x62, 0x34, 0x33, 0x37, 0x31, 0x38, 0x64, 0x39, 0x32, 0x33, 0x32, 0x39, 0x30, 0x30, 0x36, 0x31, 0x37, 0x37, 0x62, 0x62, 0x34, 0x64, 0x64, 0x63, 0x32, 0x37, 0x32, 0x37, 0x37, 0x38, 0x36, 0x65, 0x38, 0x35, 0x33, 0x62, 0x37, 0x62, 0x33, 0x35, 0x33, 0x65, 0x36, 0x30, 0x31, 0x34, 0x32, 0x31, 0x37, 0x63, 0x65, 0x65, 0x31, 0x33, 0x36, 0x63, 0x62, 0x66, 0x39, 0x62, 0x66, 0x61, 0x66, 0x35, 0x38, 0x39, 0x61, 0x61, 0x62, 0x37, 0x37, 0x64, 0x64, 0x32, 0x61, 0x32, 0x32, 0x30, 0x36, 0x39, 0x38, 0x66, 0x31, 0x37, 0x63, 0x39, 0x32, 0x39, 0x65, 0x37, 0x32, 0x37, 0x61, 0x32, 0x64, 0x66, 0x64, 0x66, 0x66, 0x31, 0x33, 0x65, 0x33, 0x32, 0x36, 0x32, 0x32, 0x39, 0x62, 0x66, 0x61, 0x37, 0x36, 0x65, 0x30, 0x31, 0x38, 0x66, 0x35, 0x62, 0x36, 0x37, 0x36, 0x39, 0x30, 0x31, 0x38, 0x61, 0x63, 0x31, 0x38, 0x65, 0x39, 0x62, 0x33, 0x65, 0x66, 0x65, 0x34, 0x31, 0x31, 0x30, 0x37, 0x35, 0x30, 0x37, 0x33, 0x35, 0x66, 0x35, 0x61, 0x34, 0x64, 0x32, 0x37, 0x64, 0x34, 0x34, 0x32, 0x63, 0x61, 0x62, 0x35, 0x31, 0x34, 0x61, 0x36, 0x65, 0x30, 0x61, 0x34, 0x65, 0x33, 0x61, 0x36, 0x61, 0x36, 0x63, 0x38, 0x61, 0x62, 0x32, 0x66, 0x37, 0x64, 0x61, 0x64, 0x61, 0x63, 0x35, 0x61, 0x33, 0x37, 0x32, 0x38, 0x62, 0x64, 0x37, 0x35, 0x38, 0x32, 0x61, 0x35, 0x39, 0x32, 0x61, 0x66, 0x38, 0x63, 0x32, 0x31, 0x36, 0x36, 0x63, 0x31, 0x30, 0x36, 0x37, 0x32, 0x37, 0x39, 0x37, 0x66, 0x31, 0x38, 0x64, 0x39, 0x36, 0x39, 0x63, 0x34, 0x65, 0x34, 0x34, 0x30, 0x65, 0x32, 0x64, 0x39, 0x32, 0x34, 0x61, 0x30, 0x65, 0x38, 0x65, 0x64, 0x64, 0x36, 0x34, 0x39, 0x63, 0x39, 0x30, 0x39, 0x34, 0x30, 0x62, 0x37, 0x35, 0x64, 0x61, 0x35, 0x36, 0x66, 0x34, 0x36, 0x30, 0x31, 0x62, 0x32, 0x30, 0x33, 0x38, 0x33, 0x34, 0x34, 0x66, 0x61, 0x63, 0x39, 0x30, 0x30, 0x65, 0x63, 0x32, 0x39, 0x32, 0x36, 0x34, 0x64, 0x66, 0x38, 0x39, 0x34, 0x64, 0x64, 0x30, 0x33, 0x35, 0x38, 0x65, 0x63, 0x39, 0x64, 0x63, 0x62, 0x38, 0x65, 0x33, 0x33, 0x65, 0x30, 0x37, 0x30, 0x32, 0x37, 0x66, 0x62, 0x30, 0x64, 0x63, 0x30, 0x62, 0x30, 0x61, 0x62, 0x34, 0x61, 0x65, 0x64, 0x65, 0x36, 0x35, 0x65, 0x66, 0x32, 0x66, 0x62, 0x37, 0x31, 0x36, 0x38, 0x64, 0x62, 0x34, 0x30, 0x65, 0x33, 0x32, 0x63, 0x62, 0x38, 0x39, 0x36, 0x39, 0x62, 0x30, 0x37, 0x33, 0x64, 0x38, 0x62, 0x34, 0x39, 0x35, 0x65, 0x34, 0x33, 0x30, 0x36, 0x32, 0x66, 0x37, 0x61, 0x38, 0x34, 0x65, 0x36, 0x35, 0x66, 0x36, 0x39, 0x39, 0x63, 0x35, 0x37, 0x37, 0x31, 0x39, 0x61, 0x66, 0x66, 0x34, 0x34, 0x31, 0x34, 0x38, 0x32, 0x35, 0x64, 0x63, 0x65, 0x63, 0x31, 0x65, 0x65, 0x37, 0x65, 0x37, 0x32, 0x38, 0x31, 0x61, 0x31, 0x35, 0x38, 0x66, 0x36, 0x31, 0x65, 0x63, 0x37, 0x36, 0x65, 0x39, 0x30, 0x64, 0x30, 0x63, 0x31, 0x36, 0x30, 0x38, 0x33, 0x65, 0x39, 0x62, 0x35, 0x62, 0x32, 0x34, 0x38, 0x36, 0x30, 0x37, 0x38, 0x62, 0x37, 0x37, 0x34, 0x66, 0x36, 0x64, 0x30, 0x62, 0x35, 0x66, 0x31, 0x64, 0x61, 0x63, 0x32, 0x30, 0x64, 0x64, 0x64, 0x33, 0x66, 0x63, 0x66, 0x31, 0x39, 0x30, 0x64, 0x63, 0x66, 0x33, 0x35, 0x66, 0x65, 0x66, 0x63, 0x30, 0x63, 0x39, 0x62, 0x36, 0x66, 0x30, 0x37, 0x30, 0x35, 0x66, 0x65, 0x32, 0x64, 0x62, 0x61, 0x36, 0x31, 0x33, 0x32, 0x35, 0x36, 0x65, 0x36, 0x35, 0x38, 0x30, 0x39, 0x62, 0x61, 0x61, 0x66, 0x62, 0x37, 0x38, 0x36, 0x63, 0x65, 0x65, 0x34, 0x64, 0x31, 0x35, 0x64, 0x61, 0x38, 0x31, 0x32, 0x62, 0x35, 0x66, 0x34, 0x65, 0x61, 0x30, 0x66, 0x63, 0x66, 0x65, 0x62, 0x34, 0x38, 0x32, 0x39, 0x38, 0x62, 0x35, 0x30, 0x63, 0x31, 0x61, 0x39, 0x61, 0x34, 0x30, 0x66, 0x63, 0x38, 0x65, 0x34, 0x39, 0x35, 0x38, 0x33, 0x63, 0x63, 0x61, 0x36, 0x61, 0x35, 0x37, 0x33, 0x62, 0x61, 0x34, 0x36, 0x31, 0x30, 0x61, 0x65, 0x66, 0x37, 0x37, 0x36, 0x35, 0x66, 0x65, 0x63, 0x35, 0x63, 0x38, 0x35, 0x61, 0x32, 0x32, 0x38, 0x62, 0x61, 0x32, 0x63, 0x34, 0x62, 0x37, 0x65, 0x31, 0x33, 0x31, 0x30, 0x31, 0x36, 0x31, 0x36, 0x33, 0x65, 0x38, 0x31, 0x61, 0x36, 0x36, 0x36, 0x61, 0x35, 0x33, 0x34, 0x37, 0x32, 0x39, 0x63, 0x37, 0x33, 0x31, 0x62, 0x62, 0x39, 0x62, 0x62, 0x62, 0x61, 0x31, 0x64, 0x38, 0x38, 0x34, 0x62, 0x61, 0x31, 0x31, 0x34, 0x66, 0x37, 0x64, 0x35, 0x35, 0x62, 0x37, 0x35, 0x39, 0x61, 0x30, 0x35, 0x62, 0x65, 0x37, 0x32, 0x62, 0x39, 0x66, 0x39, 0x64, 0x39, 0x39, 0x62, 0x66, 0x33, 0x64, 0x36, 0x62, 0x39, 0x38, 0x64, 0x63, 0x37, 0x30, 0x32, 0x62, 0x39, 0x63, 0x61, 0x32, 0x39, 0x33, 0x37, 0x30, 0x32, 0x31, 0x32, 0x61, 0x36, 0x30, 0x66, 0x32, 0x31, 0x38, 0x30, 0x37, 0x30, 0x35, 0x38, 0x33, 0x37, 0x30, 0x39, 0x30, 0x32, 0x64, 0x64, 0x62, 0x63, 0x36, 0x61, 0x37, 0x33, 0x62, 0x39, 0x32, 0x38, 0x34, 0x63, 0x34, 0x66, 0x64, 0x66, 0x33, 0x35, 0x65, 0x38, 0x64, 0x64, 0x31, 0x37, 0x37, 0x33, 0x35, 0x35, 0x30, 0x31, 0x33, 0x65, 0x35, 0x34, 0x64, 0x32, 0x30, 0x37, 0x31, 0x36, 0x39, 0x34, 0x61, 0x38, 0x38, 0x61, 0x62, 0x64, 0x31, 0x61, 0x65, 0x37, 0x39, 0x65, 0x62, 0x38, 0x38, 0x36, 0x39, 0x38, 0x30, 0x61, 0x37, 0x62, 0x62, 0x30, 0x31, 0x39, 0x33, 0x65, 0x37, 0x65, 0x34, 0x33, 0x33, 0x35, 0x32, 0x38, 0x36, 0x62, 0x32, 0x34, 0x38, 0x66, 0x32, 0x62, 0x66, 0x32, 0x34, 0x37, 0x61, 0x64, 0x31, 0x62, 0x33, 0x31, 0x30, 0x65, 0x37, 0x62, 0x30, 0x35, 0x65, 0x39, 0x66, 0x36, 0x62, 0x66, 0x61, 0x63, 0x61, 0x66, 0x35, 0x62, 0x39, 0x32, 0x65, 0x33, 0x37, 0x65, 0x35, 0x36, 0x64, 0x36, 0x31, 0x33, 0x62, 0x64, 0x34, 0x35, 0x30, 0x63, 0x30, 0x36, 0x35, 0x63, 0x37, 0x32, 0x34, 0x61, 0x36, 0x66, 0x64, 0x37, 0x61, 0x61, 0x63, 0x61, 0x66, 0x37, 0x35, 0x36, 0x31, 0x65, 0x38, 0x30, 0x62, 0x61, 0x31, 0x30, 0x30, 0x63, 0x36, 0x66, 0x34, 0x30, 0x61, 0x31, 0x33, 0x30, 0x39, 0x36, 0x66, 0x62, 0x62, 0x34, 0x37, 0x30, 0x35, 0x33, 0x63, 0x62, 0x64, 0x31, 0x37, 0x38, 0x37, 0x34, 0x39, 0x37, 0x64, 0x66, 0x32, 0x31, 0x33, 0x61, 0x66, 0x38, 0x36, 0x38, 0x63, 0x66, 0x37, 0x32, 0x30, 0x32, 0x34, 0x34, 0x63, 0x61, 0x33, 0x61, 0x37, 0x33, 0x63, 0x34, 0x64, 0x39, 0x65, 0x37, 0x66, 0x39, 0x30, 0x31, 0x62, 0x37, 0x37, 0x37, 0x31, 0x33, 0x66, 0x62, 0x63, 0x39, 0x38, 0x33, 0x34, 0x63, 0x63, 0x38, 0x64, 0x65, 0x65, 0x30, 0x31, 0x33, 0x32, 0x32, 0x63, 0x35, 0x36, 0x66, 0x33, 0x61, 0x32, 0x33, 0x37, 0x61, 0x62, 0x37, 0x34, 0x64, 0x34, 0x33, 0x31, 0x64, 0x37, 0x32, 0x65, 0x62, 0x32, 0x35, 0x31, 0x37, 0x37, 0x34, 0x31, 0x36, 0x63, 0x38, 0x61, 0x65, 0x35, 0x37, 0x35, 0x35, 0x32, 0x31, 0x34, 0x33, 0x32, 0x63, 0x61, 0x39, 0x38, 0x33, 0x39, 0x31, 0x39, 0x66, 0x61, 0x33, 0x35, 0x34, 0x33, 0x62, 0x30, 0x32, 0x39, 0x62, 0x66, 0x38, 0x30, 0x34, 0x32, 0x66, 0x62, 0x35, 0x37, 0x35, 0x34, 0x30, 0x36, 0x62, 0x31, 0x63, 0x38, 0x34, 0x61, 0x30, 0x37, 0x32, 0x30, 0x66, 0x64, 0x65, 0x64, 0x32, 0x30, 0x63, 0x31, 0x38, 0x35, 0x39, 0x64, 0x30, 0x31, 0x34, 0x62, 0x32, 0x37, 0x66, 0x39, 0x31, 0x33, 0x30, 0x35, 0x61, 0x38, 0x30, 0x35, 0x32, 0x63, 0x63, 0x37, 0x33, 0x34, 0x33, 0x65, 0x34, 0x37, 0x36, 0x36, 0x65, 0x65, 0x30, 0x32, 0x37, 0x61, 0x66, 0x36, 0x61, 0x36, 0x30, 0x61, 0x32, 0x34, 0x66, 0x34, 0x62, 0x32, 0x30, 0x33, 0x36, 0x33, 0x36, 0x62, 0x62, 0x36, 0x66, 0x37, 0x30, 0x63, 0x34, 0x34, 0x30, 0x62, 0x31, 0x61, 0x66, 0x30, 0x31, 0x35, 0x33, 0x36, 0x33, 0x36, 0x66, 0x66, 0x32, 0x36, 0x30, 0x38, 0x64, 0x31, 0x65, 0x31, 0x33, 0x31, 0x65, 0x32, 0x39, 0x64, 0x34, 0x35, 0x61, 0x65, 0x64, 0x30, 0x34, 0x62, 0x38, 0x35, 0x34, 0x37, 0x37, 0x34, 0x39, 0x64, 0x36, 0x32, 0x38, 0x62, 0x36, 0x65, 0x33, 0x32, 0x37, 0x30, 0x65, 0x63, 0x62, 0x37, 0x35, 0x61, 0x37, 0x61, 0x63, 0x62, 0x33, 0x36, 0x62, 0x31, 0x31, 0x39, 0x61, 0x64, 0x30, 0x37, 0x38, 0x32, 0x31, 0x65, 0x37, 0x66, 0x62, 0x35, 0x36, 0x35, 0x63, 0x30, 0x63, 0x65, 0x66, 0x37, 0x39, 0x33, 0x33, 0x62, 0x36, 0x31, 0x39, 0x65, 0x64, 0x30, 0x34, 0x62, 0x61, 0x34, 0x36, 0x65, 0x62, 0x34, 0x36, 0x33, 0x34, 0x63, 0x32, 0x34, 0x64, 0x61, 0x32, 0x37, 0x32, 0x64, 0x63, 0x35, 0x39, 0x36, 0x31, 0x37, 0x65, 0x33, 0x65, 0x33, 0x37, 0x32, 0x33, 0x66, 0x37, 0x34, 0x31, 0x39, 0x34, 0x35, 0x37, 0x31, 0x39, 0x37, 0x39, 0x35, 0x33, 0x31, 0x31, 0x37, 0x30, 0x37, 0x37, 0x66, 0x61, 0x36, 0x63, 0x39, 0x39, 0x65, 0x66, 0x33, 0x33, 0x34, 0x65, 0x31, 0x64, 0x33, 0x33, 0x32, 0x35, 0x66, 0x38, 0x37, 0x66, 0x35, 0x35, 0x39, 0x35, 0x32, 0x61, 0x37, 0x32, 0x66, 0x31, 0x31, 0x36, 0x65, 0x63, 0x36, 0x34, 0x31, 0x61, 0x37, 0x31, 0x39, 0x63, 0x35, 0x37, 0x32, 0x64, 0x61, 0x61, 0x32, 0x62, 0x34, 0x66, 0x38, 0x32, 0x63, 0x36, 0x63, 0x65, 0x36, 0x39, 0x38, 0x39, 0x31, 0x37, 0x30, 0x63, 0x62, 0x61, 0x62, 0x63, 0x39, 0x66, 0x66, 0x38, 0x36, 0x35, 0x32, 0x39, 0x35, 0x64, 0x35, 0x33, 0x32, 0x64, 0x64, 0x32, 0x61, 0x63, 0x38, 0x65, 0x37, 0x31, 0x39, 0x39, 0x39, 0x32, 0x64, 0x66, 0x65, 0x34, 0x35, 0x39, 0x37, 0x32, 0x33, 0x33, 0x37, 0x33, 0x36, 0x30, 0x62, 0x35, 0x31, 0x37, 0x38, 0x36, 0x37, 0x33, 0x35, 0x34, 0x32, 0x30, 0x32, 0x61, 0x61, 0x62, 0x32, 0x35, 0x34, 0x65, 0x65, 0x35, 0x33, 0x34, 0x61, 0x35, 0x36, 0x31, 0x35, 0x65, 0x39, 0x38, 0x39, 0x38, 0x31, 0x37, 0x32, 0x63, 0x39, 0x34, 0x33, 0x34, 0x39, 0x31, 0x37, 0x32, 0x63, 0x32, 0x39, 0x31, 0x34, 0x32, 0x66, 0x36, 0x31, 0x64, 0x39, 0x33, 0x33, 0x31, 0x65, 0x66, 0x64, 0x30, 0x31, 0x63, 0x36, 0x35, 0x39, 0x32, 0x66, 0x31, 0x64, 0x33, 0x38, 0x35, 0x33, 0x34, 0x37, 0x39, 0x34, 0x66, 0x66, 0x30, 0x33, 0x64, 0x64, 0x61, 0x35, 0x66, 0x64, 0x34, 0x32, 0x62, 0x63, 0x34, 0x39, 0x61, 0x33, 0x61, 0x65, 0x33, 0x38, 0x34, 0x31, 0x36, 0x64, 0x65, 0x37, 0x32, 0x38, 0x39, 0x37, 0x31, 0x31, 0x36, 0x61, 0x38, 0x63, 0x39, 0x39, 0x31, 0x61, 0x62, 0x65, 0x35, 0x33, 0x31, 0x61, 0x33, 0x34, 0x38, 0x39, 0x61, 0x61, 0x66, 0x64, 0x39, 0x39, 0x30, 0x63, 0x30, 0x37, 0x32, 0x34, 0x39, 0x35, 0x30, 0x39, 0x36, 0x36, 0x64, 0x36, 0x39, 0x66, 0x39, 0x34, 0x38, 0x61, 0x39, 0x63, 0x65, 0x65, 0x33, 0x63, 0x35, 0x39, 0x37, 0x37, 0x32, 0x61, 0x38, 0x37, 0x32, 0x32, 0x32, 0x39, 0x32, 0x35, 0x32, 0x62, 0x66, 0x64, 0x36, 0x30, 0x31, 0x31, 0x37, 0x62, 0x34, 0x64, 0x37, 0x64, 0x31, 0x31, 0x64, 0x36, 0x37, 0x30, 0x64, 0x62, 0x35, 0x37, 0x61, 0x63, 0x39, 0x61, 0x35, 0x32, 0x61, 0x31, 0x36, 0x63, 0x32, 0x35, 0x34, 0x33, 0x64, 0x33, 0x63, 0x36, 0x64, 0x34, 0x63, 0x64, 0x33, 0x34, 0x31, 0x65, 0x33, 0x30, 0x39, 0x64, 0x63, 0x62, 0x33, 0x37, 0x32, 0x30, 0x34, 0x63, 0x63, 0x32, 0x38, 0x65, 0x34, 0x65, 0x32, 0x66, 0x34, 0x66, 0x32, 0x30, 0x37, 0x31, 0x64, 0x39, 0x63, 0x31, 0x61, 0x36, 0x61, 0x66, 0x37, 0x34, 0x64, 0x38, 0x38, 0x36, 0x63, 0x38, 0x63, 0x37, 0x39, 0x37, 0x37, 0x39, 0x35, 0x61, 0x64, 0x38, 0x63, 0x64, 0x31, 0x62, 0x33, 0x35, 0x35, 0x61, 0x30, 0x33, 0x33, 0x36, 0x65, 0x61, 0x34, 0x32, 0x38, 0x32, 0x62, 0x37, 0x32, 0x64, 0x61, 0x31, 0x66, 0x37, 0x35, 0x32, 0x64, 0x30, 0x62, 0x63, 0x65, 0x32, 0x36, 0x33, 0x31, 0x64, 0x62, 0x62, 0x30, 0x62, 0x39, 0x64, 0x61, 0x63, 0x66, 0x64, 0x66, 0x63, 0x65, 0x36, 0x62, 0x66, 0x31, 0x30, 0x62, 0x34, 0x38, 0x34, 0x34, 0x63, 0x39, 0x36, 0x35, 0x65, 0x37, 0x39, 0x33, 0x30, 0x61, 0x63, 0x39, 0x31, 0x34, 0x38, 0x35, 0x65, 0x38, 0x31, 0x30, 0x61, 0x63, 0x37, 0x32, 0x66, 0x65, 0x64, 0x66, 0x34, 0x65, 0x38, 0x33, 0x37, 0x63, 0x35, 0x64, 0x62, 0x63, 0x36, 0x64, 0x63, 0x38, 0x65, 0x36, 0x31, 0x66, 0x64, 0x63, 0x30, 0x32, 0x34, 0x30, 0x35, 0x61, 0x64, 0x35, 0x30, 0x30, 0x63, 0x33, 0x38, 0x64, 0x65, 0x30, 0x61, 0x33, 0x62, 0x30, 0x64, 0x39, 0x39, 0x64, 0x39, 0x62, 0x39, 0x30, 0x34, 0x33, 0x61, 0x64, 0x64, 0x64, 0x35, 0x39, 0x61, 0x37, 0x37, 0x32, 0x64, 0x34, 0x63, 0x38, 0x39, 0x65, 0x66, 0x34, 0x38, 0x66, 0x61, 0x62, 0x38, 0x62, 0x66, 0x38, 0x65, 0x34, 0x37, 0x66, 0x30, 0x31, 0x30, 0x32, 0x64, 0x30, 0x61, 0x63, 0x38, 0x64, 0x65, 0x32, 0x65, 0x37, 0x63, 0x66, 0x65, 0x65, 0x33, 0x37, 0x32, 0x34, 0x62, 0x32, 0x30, 0x39, 0x35, 0x39, 0x35, 0x38, 0x66, 0x64, 0x64, 0x35, 0x37, 0x30, 0x31, 0x30, 0x37, 0x61, 0x31, 0x38, 0x37, 0x32, 0x39, 0x61, 0x38, 0x64, 0x35, 0x62, 0x64, 0x32, 0x37, 0x35, 0x39, 0x32, 0x64, 0x63, 0x36, 0x39, 0x32, 0x39, 0x32, 0x65, 0x37, 0x33, 0x39, 0x30, 0x35, 0x35, 0x31, 0x34, 0x62, 0x32, 0x64, 0x32, 0x32, 0x32, 0x34, 0x33, 0x31, 0x31, 0x35, 0x39, 0x63, 0x32, 0x37, 0x63, 0x66, 0x30, 0x64, 0x30, 0x31, 0x64, 0x35, 0x63, 0x33, 0x38, 0x63, 0x31, 0x30, 0x36, 0x34, 0x61, 0x33, 0x62, 0x37, 0x32, 0x36, 0x37, 0x61, 0x31, 0x31, 0x63, 0x64, 0x61, 0x66, 0x31, 0x32, 0x66, 0x32, 0x63, 0x33, 0x35, 0x35, 0x64, 0x39, 0x63, 0x37, 0x62, 0x64, 0x64, 0x61, 0x31, 0x31, 0x65, 0x31, 0x39, 0x39, 0x37, 0x38, 0x61, 0x64, 0x35, 0x32, 0x64, 0x30, 0x37, 0x32, 0x32, 0x63, 0x61, 0x34, 0x34, 0x61, 0x39, 0x35, 0x66, 0x37, 0x32, 0x63, 0x62, 0x32, 0x37, 0x64, 0x35, 0x65, 0x34, 0x32, 0x61, 0x37, 0x32, 0x38, 0x63, 0x31, 0x64, 0x64, 0x61, 0x34, 0x39, 0x31, 0x33, 0x35, 0x30, 0x38, 0x36, 0x66, 0x35, 0x31, 0x31, 0x35, 0x36, 0x35, 0x37, 0x31, 0x64, 0x32, 0x38, 0x66, 0x62, 0x61, 0x35, 0x65, 0x33, 0x63, 0x35, 0x65, 0x37, 0x30, 0x39, 0x36, 0x64, 0x62, 0x34, 0x64, 0x66, 0x31, 0x30, 0x37, 0x64, 0x31, 0x64, 0x36, 0x37, 0x37, 0x33, 0x61, 0x38, 0x39, 0x61, 0x35, 0x61, 0x61, 0x33, 0x37, 0x32, 0x37, 0x38, 0x62, 0x66, 0x63, 0x31, 0x63, 0x33, 0x37, 0x34, 0x30, 0x61, 0x31, 0x30, 0x61, 0x31, 0x62, 0x66, 0x31, 0x61, 0x36, 0x63, 0x38, 0x34, 0x64, 0x66, 0x37, 0x34, 0x34, 0x35, 0x62, 0x37, 0x63, 0x36, 0x35, 0x65, 0x39, 0x33, 0x62, 0x34, 0x31, 0x61, 0x31, 0x35, 0x39, 0x32, 0x66, 0x64, 0x30, 0x35, 0x61, 0x62, 0x65, 0x62, 0x38, 0x33, 0x32, 0x61, 0x62, 0x63, 0x39, 0x34, 0x37, 0x32, 0x63, 0x36, 0x66, 0x38, 0x61, 0x34, 0x37, 0x38, 0x65, 0x32, 0x63, 0x36, 0x36, 0x63, 0x66, 0x30, 0x65, 0x64, 0x32, 0x39, 0x31, 0x38, 0x30, 0x37, 0x66, 0x30, 0x65, 0x38, 0x33, 0x62, 0x66, 0x65, 0x31, 0x62, 0x32, 0x64, 0x61, 0x66, 0x66, 0x35, 0x34, 0x31, 0x65, 0x63, 0x62, 0x65, 0x63, 0x62, 0x38, 0x66, 0x39, 0x39, 0x32, 0x36, 0x38, 0x39, 0x62, 0x61, 0x63, 0x36, 0x33, 0x32, 0x37, 0x32, 0x37, 0x38, 0x62, 0x31, 0x35, 0x38, 0x64, 0x65, 0x32, 0x35, 0x33, 0x32, 0x34, 0x32, 0x30, 0x37, 0x65, 0x34, 0x37, 0x37, 0x35, 0x62, 0x61, 0x37, 0x61, 0x34, 0x61, 0x65, 0x36, 0x34, 0x61, 0x38, 0x37, 0x31, 0x64, 0x62, 0x31, 0x63, 0x34, 0x36, 0x61, 0x38, 0x38, 0x37, 0x66, 0x37, 0x39, 0x66, 0x65, 0x34, 0x62, 0x36, 0x39, 0x36, 0x33, 0x34, 0x32, 0x39, 0x32, 0x63, 0x31, 0x35, 0x37, 0x32, 0x38, 0x62, 0x30, 0x66, 0x37, 0x35, 0x62, 0x62, 0x61, 0x63, 0x33, 0x33, 0x64, 0x65, 0x37, 0x35, 0x31, 0x65, 0x65, 0x32, 0x35, 0x63, 0x65, 0x37, 0x64, 0x34, 0x38, 0x30, 0x30, 0x63, 0x30, 0x35, 0x31, 0x36, 0x62, 0x63, 0x65, 0x33, 0x37, 0x34, 0x61, 0x61, 0x34, 0x65, 0x65, 0x63, 0x33, 0x64, 0x62, 0x38, 0x39, 0x65, 0x30, 0x65, 0x31, 0x63, 0x38, 0x64, 0x65, 0x64, 0x64, 0x30, 0x32, 0x61, 0x34, 0x31, 0x34, 0x66, 0x35, 0x35, 0x34, 0x30, 0x61, 0x36, 0x66, 0x66, 0x39, 0x34, 0x39, 0x36, 0x39, 0x34, 0x62, 0x32, 0x36, 0x62, 0x39, 0x35, 0x65, 0x34, 0x38, 0x33, 0x66, 0x66, 0x31, 0x37, 0x64, 0x63, 0x33, 0x62, 0x39, 0x62, 0x36, 0x36, 0x37, 0x32, 0x33, 0x64, 0x31, 0x37, 0x32, 0x31, 0x36, 0x37, 0x35, 0x63, 0x62, 0x37, 0x32, 0x65, 0x35, 0x61, 0x31, 0x65, 0x64, 0x39, 0x37, 0x32, 0x37, 0x39, 0x37, 0x30, 0x30, 0x36, 0x39, 0x34, 0x34, 0x65, 0x65, 0x32, 0x37, 0x66, 0x33, 0x62, 0x39, 0x37, 0x65, 0x37, 0x66, 0x34, 0x66, 0x35, 0x36, 0x37, 0x34, 0x66, 0x66, 0x61, 0x66, 0x37, 0x39, 0x36, 0x34, 0x35, 0x65, 0x32, 0x61, 0x65, 0x66, 0x34, 0x36, 0x31, 0x61, 0x37, 0x30, 0x62, 0x36, 0x64, 0x63, 0x63, 0x30, 0x65, 0x33, 0x34, 0x65, 0x65, 0x63, 0x66, 0x36, 0x34, 0x37, 0x32, 0x36, 0x62, 0x38, 0x32, 0x65, 0x34, 0x32, 0x35, 0x30, 0x64, 0x61, 0x32, 0x64, 0x61, 0x36, 0x65, 0x32, 0x64, 0x36, 0x38, 0x36, 0x66, 0x39, 0x62, 0x61, 0x36, 0x38, 0x37, 0x62, 0x66, 0x32, 0x63, 0x31, 0x63, 0x62, 0x34, 0x31, 0x34, 0x66, 0x35, 0x63, 0x38, 0x62, 0x39, 0x33, 0x33, 0x33, 0x64, 0x31, 0x61, 0x34, 0x34, 0x38, 0x37, 0x34, 0x34, 0x31, 0x63, 0x38, 0x38, 0x66, 0x61, 0x33, 0x65, 0x30, 0x62, 0x64, 0x30, 0x65, 0x35, 0x63, 0x62, 0x30, 0x65, 0x31, 0x39, 0x39, 0x64, 0x30, 0x66, 0x62, 0x39, 0x61, 0x39, 0x33, 0x64, 0x62, 0x32, 0x38, 0x30, 0x33, 0x36, 0x31, 0x30, 0x66, 0x33, 0x35, 0x64, 0x39, 0x65, 0x32, 0x37, 0x65, 0x36, 0x61, 0x39, 0x32, 0x65, 0x39, 0x37, 0x34, 0x37, 0x36, 0x38, 0x37, 0x64, 0x62, 0x35, 0x33, 0x39, 0x31, 0x33, 0x33, 0x34, 0x33, 0x30, 0x37, 0x32, 0x32, 0x65, 0x38, 0x39, 0x61, 0x62, 0x31, 0x31, 0x64, 0x61, 0x39, 0x63, 0x36, 0x30, 0x65, 0x38, 0x63, 0x31, 0x64, 0x63, 0x63, 0x61, 0x32, 0x32, 0x31, 0x66, 0x61, 0x32, 0x37, 0x38, 0x36, 0x39, 0x64, 0x30, 0x33, 0x38, 0x33, 0x64, 0x66, 0x65, 0x62, 0x61, 0x61, 0x34, 0x38, 0x34, 0x64, 0x39, 0x39, 0x39, 0x34, 0x61, 0x63, 0x66, 0x37, 0x39, 0x35, 0x38, 0x35, 0x37, 0x66, 0x65, 0x34, 0x65, 0x38, 0x61, 0x35, 0x30, 0x64, 0x66, 0x62, 0x30, 0x62, 0x34, 0x63, 0x33, 0x39, 0x33, 0x62, 0x63, 0x61, 0x38, 0x35, 0x64, 0x30, 0x64, 0x37, 0x39, 0x32, 0x64, 0x31, 0x64, 0x37, 0x63, 0x38, 0x61, 0x37, 0x37, 0x34, 0x64, 0x30, 0x61, 0x66, 0x38, 0x39, 0x63, 0x63, 0x36, 0x39, 0x33, 0x31, 0x35, 0x33, 0x34, 0x38, 0x66, 0x64, 0x30, 0x61, 0x32, 0x66, 0x33, 0x64, 0x63, 0x30, 0x65, 0x30, 0x32, 0x32, 0x33, 0x34, 0x33, 0x38, 0x36, 0x38, 0x38, 0x65, 0x30, 0x63, 0x33, 0x66, 0x37, 0x64, 0x37, 0x32, 0x34, 0x37, 0x35, 0x31, 0x31, 0x37, 0x33, 0x61, 0x66, 0x35, 0x39, 0x31, 0x32, 0x63, 0x34, 0x30, 0x32, 0x61, 0x63, 0x37, 0x37, 0x63, 0x61, 0x38, 0x31, 0x66, 0x61, 0x61, 0x65, 0x61, 0x62, 0x36, 0x66, 0x34, 0x34, 0x31, 0x66, 0x31, 0x37, 0x61, 0x33, 0x63, 0x37, 0x37, 0x62, 0x37, 0x32, 0x66, 0x31, 0x61, 0x34, 0x36, 0x66, 0x66, 0x39, 0x35, 0x31, 0x39, 0x32, 0x65, 0x62, 0x62, 0x36, 0x62, 0x62, 0x30, 0x30, 0x65, 0x33, 0x33, 0x35, 0x30, 0x39, 0x62, 0x32, 0x30, 0x31, 0x61, 0x38, 0x32, 0x37, 0x62, 0x36, 0x38, 0x33, 0x34, 0x32, 0x31, 0x31, 0x61, 0x62, 0x61, 0x32, 0x37, 0x65, 0x30, 0x38, 0x34, 0x32, 0x35, 0x66, 0x37, 0x32, 0x63, 0x33, 0x66, 0x64, 0x64, 0x65, 0x37, 0x32, 0x34, 0x62, 0x63, 0x32, 0x36, 0x38, 0x66, 0x62, 0x65, 0x30, 0x31, 0x39, 0x63, 0x34, 0x30, 0x34, 0x63, 0x36, 0x36, 0x31, 0x31, 0x35, 0x36, 0x39, 0x66, 0x62, 0x65, 0x32, 0x30, 0x33, 0x63, 0x31, 0x31, 0x30, 0x65, 0x39, 0x38, 0x63, 0x39, 0x66, 0x36, 0x32, 0x33, 0x64, 0x36, 0x39, 0x35, 0x31, 0x32, 0x37, 0x32, 0x64, 0x61, 0x64, 0x64, 0x64, 0x66, 0x65, 0x34, 0x33, 0x35, 0x37, 0x37, 0x32, 0x64, 0x30, 0x35, 0x37, 0x34, 0x61, 0x66, 0x35, 0x61, 0x31, 0x61, 0x65, 0x30, 0x65, 0x31, 0x64, 0x61, 0x35, 0x64, 0x62, 0x37, 0x33, 0x63, 0x34, 0x38, 0x31, 0x36, 0x61, 0x32, 0x38, 0x61, 0x63, 0x36, 0x64, 0x30, 0x63, 0x32, 0x33, 0x33, 0x64, 0x39, 0x39, 0x66, 0x34, 0x36, 0x30, 0x35, 0x33, 0x64, 0x39, 0x37, 0x65, 0x32, 0x61, 0x34, 0x62, 0x31, 0x63, 0x33, 0x65, 0x37, 0x36, 0x37, 0x32, 0x39, 0x66, 0x37, 0x36, 0x39, 0x34, 0x65, 0x37, 0x66, 0x63, 0x65, 0x39, 0x32, 0x33, 0x34, 0x35, 0x33, 0x61, 0x34, 0x64, 0x38, 0x62, 0x66, 0x63, 0x62, 0x61, 0x32, 0x63, 0x36, 0x30, 0x64, 0x31, 0x37, 0x39, 0x63, 0x35, 0x62, 0x38, 0x64, 0x65, 0x30, 0x31, 0x65, 0x61, 0x34, 0x63, 0x65, 0x31, 0x66, 0x31, 0x33, 0x36, 0x37, 0x34, 0x34, 0x62, 0x61, 0x30, 0x39, 0x36, 0x62, 0x35, 0x37, 0x32, 0x36, 0x31, 0x30, 0x36, 0x36, 0x66, 0x36, 0x64, 0x62, 0x33, 0x63, 0x61, 0x34, 0x31, 0x66, 0x62, 0x32, 0x34, 0x38, 0x38, 0x32, 0x36, 0x62, 0x64, 0x39, 0x33, 0x30, 0x32, 0x31, 0x30, 0x65, 0x38, 0x61, 0x34, 0x61, 0x31, 0x63, 0x61, 0x62, 0x36, 0x35, 0x36, 0x63, 0x39, 0x66, 0x37, 0x31, 0x65, 0x38, 0x32, 0x66, 0x65, 0x62, 0x34, 0x34, 0x31, 0x37, 0x65, 0x30, 0x34, 0x34, 0x63, 0x37, 0x32, 0x37, 0x30, 0x36, 0x36, 0x64, 0x61, 0x64, 0x32, 0x38, 0x66, 0x34, 0x36, 0x63, 0x32, 0x62, 0x38, 0x32, 0x30, 0x31, 0x64, 0x37, 0x62, 0x32, 0x32, 0x37, 0x61, 0x61, 0x33, 0x34, 0x64, 0x36, 0x36, 0x34, 0x39, 0x33, 0x38, 0x31, 0x65, 0x61, 0x61, 0x34, 0x37, 0x36, 0x39, 0x66, 0x38, 0x66, 0x30, 0x30, 0x35, 0x39, 0x66, 0x35, 0x37, 0x33, 0x39, 0x39, 0x31, 0x33, 0x65, 0x63, 0x62, 0x35, 0x62, 0x39, 0x32, 0x38, 0x34, 0x31, 0x65, 0x65, 0x61, 0x34, 0x37, 0x36, 0x39, 0x37, 0x65, 0x31, 0x66, 0x34, 0x63, 0x33, 0x39, 0x34, 0x33, 0x64, 0x39, 0x66, 0x61, 0x64, 0x30, 0x34, 0x32, 0x37, 0x66, 0x38, 0x31, 0x64, 0x63, 0x35, 0x37, 0x36, 0x63, 0x66, 0x39, 0x31, 0x38, 0x39, 0x35, 0x39, 0x65, 0x33, 0x31, 0x65, 0x63, 0x30, 0x32, 0x37, 0x64, 0x31, 0x65, 0x61, 0x63, 0x34, 0x62, 0x37, 0x32, 0x37, 0x34, 0x65, 0x66, 0x66, 0x38, 0x31, 0x39, 0x61, 0x31, 0x38, 0x36, 0x65, 0x33, 0x39, 0x62, 0x64, 0x65, 0x39, 0x63, 0x31, 0x34, 0x38, 0x39, 0x66, 0x62, 0x30, 0x33, 0x36, 0x66, 0x66, 0x63, 0x66, 0x36, 0x61, 0x34, 0x32, 0x39, 0x63, 0x64, 0x66, 0x66, 0x30, 0x66, 0x35, 0x37, 0x34, 0x65, 0x62, 0x64, 0x32, 0x38, 0x30, 0x38, 0x64, 0x63, 0x38, 0x38, 0x33, 0x39, 0x65, 0x35, 0x37, 0x32, 0x36, 0x65, 0x38, 0x31, 0x63, 0x61, 0x32, 0x66, 0x38, 0x39, 0x32, 0x32, 0x66, 0x35, 0x64, 0x35, 0x39, 0x36, 0x64, 0x64, 0x39, 0x31, 0x62, 0x37, 0x66, 0x32, 0x31, 0x39, 0x62, 0x39, 0x66, 0x35, 0x64, 0x34, 0x66, 0x64, 0x31, 0x34, 0x37, 0x30, 0x30, 0x32, 0x37, 0x33, 0x35, 0x62, 0x64, 0x65, 0x30, 0x39, 0x33, 0x35, 0x35, 0x35, 0x31, 0x63, 0x39, 0x33, 0x34, 0x66, 0x30, 0x33, 0x37, 0x32, 0x36, 0x63, 0x33, 0x31, 0x62, 0x31, 0x32, 0x30, 0x36, 0x33, 0x64, 0x35, 0x31, 0x36, 0x39, 0x61, 0x36, 0x34, 0x36, 0x37, 0x37, 0x33, 0x30, 0x37, 0x39, 0x32, 0x38, 0x35, 0x33, 0x36, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x62, 0x66, 0x63, 0x30, 0x34, 0x32, 0x65, 0x39, 0x31, 0x38, 0x30, 0x63, 0x36, 0x32, 0x63, 0x62, 0x62, 0x32, 0x35, 0x62, 0x34, 0x35, 0x34, 0x35, 0x37, 0x30, 0x32, 0x39, 0x61, 0x32, 0x66, 0x35, 0x30, 0x62, 0x35, 0x31, 0x62, 0x30, 0x36, 0x32, 0x37, 0x37, 0x38, 0x62, 0x39, 0x63, 0x36, 0x37, 0x63, 0x64, 0x61, 0x66, 0x39, 0x34, 0x38, 0x66, 0x36, 0x64, 0x62, 0x65, 0x63, 0x35, 0x33, 0x38, 0x35, 0x65, 0x36, 0x63, 0x37, 0x39, 0x64, 0x38, 0x31, 0x38, 0x34, 0x33, 0x62, 0x33, 0x35, 0x30, 0x38, 0x66, 0x39, 0x63, 0x64, 0x31, 0x32, 0x65, 0x64, 0x31, 0x37, 0x32, 0x66, 0x34, 0x64, 0x36, 0x61, 0x31, 0x61, 0x64, 0x39, 0x30, 0x65, 0x35, 0x30, 0x31, 0x62, 0x31, 0x63, 0x64, 0x66, 0x32, 0x65, 0x31, 0x61, 0x63, 0x32, 0x32, 0x63, 0x33, 0x64, 0x61, 0x35, 0x30, 0x30, 0x34, 0x63, 0x33, 0x39, 0x62, 0x31, 0x62, 0x31, 0x63, 0x35, 0x35, 0x37, 0x36, 0x32, 0x63, 0x31, 0x38, 0x38, 0x66, 0x64, 0x32, 0x39, 0x64, 0x66, 0x31, 0x66, 0x30, 0x36, 0x62, 0x33, 0x34, 0x61, 0x36, 0x39, 0x33, 0x39, 0x61, 0x64, 0x37, 0x30, 0x62, 0x65, 0x62, 0x62, 0x62, 0x31, 0x37, 0x30, 0x35, 0x66, 0x35, 0x62, 0x66, 0x35, 0x37, 0x36, 0x33, 0x33, 0x31, 0x31, 0x33, 0x30, 0x34, 0x65, 0x37, 0x38, 0x31, 0x61, 0x63, 0x38, 0x63, 0x31, 0x30, 0x66, 0x64, 0x66, 0x35, 0x35, 0x38, 0x62, 0x37, 0x31, 0x66, 0x39, 0x39, 0x35, 0x39, 0x32, 0x33, 0x63, 0x32, 0x32, 0x37, 0x37, 0x32, 0x36, 0x35, 0x35, 0x62, 0x34, 0x33, 0x30, 0x66, 0x63, 0x64, 0x66, 0x35, 0x64, 0x61, 0x63, 0x62, 0x30, 0x33, 0x37, 0x64, 0x36, 0x38, 0x38, 0x63, 0x38, 0x64, 0x36, 0x37, 0x33, 0x65, 0x31, 0x64, 0x32, 0x32, 0x30, 0x35, 0x35, 0x30, 0x37, 0x35, 0x33, 0x36, 0x38, 0x62, 0x66, 0x62, 0x31, 0x30, 0x66, 0x64, 0x36, 0x30, 0x61, 0x64, 0x63, 0x38, 0x33, 0x63, 0x63, 0x35, 0x39, 0x63, 0x30, 0x33, 0x35, 0x31, 0x66, 0x61, 0x33, 0x32, 0x66, 0x34, 0x35, 0x31, 0x62, 0x36, 0x65, 0x64, 0x32, 0x35, 0x65, 0x62, 0x37, 0x61, 0x39, 0x66, 0x61, 0x37, 0x66, 0x66, 0x65, 0x65, 0x32, 0x62, 0x36, 0x38, 0x36, 0x31, 0x62, 0x30, 0x66, 0x34, 0x30, 0x39, 0x62, 0x37, 0x62, 0x30, 0x34, 0x65, 0x64, 0x32, 0x33, 0x66, 0x37, 0x65, 0x34, 0x64, 0x34, 0x65, 0x65, 0x31, 0x63, 0x62, 0x61, 0x34, 0x37, 0x32, 0x30, 0x38, 0x62, 0x30, 0x64, 0x31, 0x63, 0x32, 0x66, 0x39, 0x64, 0x37, 0x62, 0x34, 0x63, 0x63, 0x35, 0x66, 0x31, 0x33, 0x63, 0x65, 0x61, 0x30, 0x37, 0x66, 0x32, 0x39, 0x63, 0x39, 0x64, 0x34, 0x62, 0x35, 0x32, 0x38, 0x39, 0x36, 0x34, 0x64, 0x39, 0x37, 0x31, 0x39, 0x66, 0x61, 0x61, 0x33, 0x62, 0x33, 0x63, 0x38, 0x63, 0x61, 0x36, 0x36, 0x32, 0x61, 0x30, 0x64, 0x37, 0x38, 0x37, 0x32, 0x37, 0x38, 0x62, 0x35, 0x38, 0x36, 0x36, 0x36, 0x36, 0x39, 0x30, 0x37, 0x65, 0x33, 0x39, 0x61, 0x35, 0x35, 0x66, 0x39, 0x39, 0x32, 0x34, 0x64, 0x36, 0x39, 0x33, 0x64, 0x39, 0x34, 0x63, 0x31, 0x31, 0x38, 0x65, 0x36, 0x64, 0x66, 0x61, 0x35, 0x34, 0x34, 0x34, 0x61, 0x66, 0x33, 0x30, 0x66, 0x30, 0x61, 0x33, 0x61, 0x32, 0x63, 0x35, 0x38, 0x64, 0x63, 0x66, 0x65, 0x37, 0x38, 0x37, 0x32, 0x30, 0x38, 0x37, 0x31, 0x37, 0x34, 0x33, 0x64, 0x31, 0x36, 0x34, 0x30, 0x31, 0x61, 0x63, 0x65, 0x39, 0x31, 0x34, 0x32, 0x38, 0x63, 0x63, 0x36, 0x38, 0x66, 0x38, 0x63, 0x63, 0x65, 0x32, 0x36, 0x30, 0x63, 0x61, 0x64, 0x64, 0x36, 0x38, 0x32, 0x61, 0x37, 0x39, 0x66, 0x33, 0x63, 0x39, 0x39, 0x37, 0x34, 0x38, 0x36, 0x34, 0x36, 0x66, 0x33, 0x61, 0x36, 0x38, 0x63, 0x34, 0x30, 0x35, 0x61, 0x38, 0x38, 0x34, 0x39, 0x30, 0x63, 0x61, 0x34, 0x38, 0x62, 0x31, 0x39, 0x65, 0x39, 0x30, 0x36, 0x62, 0x62, 0x32, 0x37, 0x62, 0x36, 0x65, 0x61, 0x33, 0x33, 0x33, 0x31, 0x64, 0x64, 0x38, 0x33, 0x32, 0x31, 0x35, 0x62, 0x37, 0x32, 0x32, 0x64, 0x34, 0x62, 0x36, 0x64, 0x65, 0x66, 0x30, 0x32, 0x63, 0x64, 0x36, 0x62, 0x32, 0x66, 0x36, 0x37, 0x33, 0x36, 0x39, 0x35, 0x66, 0x38, 0x31, 0x65, 0x38, 0x64, 0x63, 0x33, 0x36, 0x36, 0x37, 0x38, 0x34, 0x65, 0x66, 0x36, 0x63, 0x33, 0x65, 0x39, 0x39, 0x35, 0x64, 0x39, 0x33, 0x37, 0x36, 0x36, 0x65, 0x34, 0x31, 0x61, 0x30, 0x63, 0x34, 0x39, 0x32, 0x61, 0x39, 0x32, 0x37, 0x37, 0x62, 0x33, 0x36, 0x32, 0x66, 0x34, 0x31, 0x39, 0x33, 0x33, 0x31, 0x62, 0x38, 0x64, 0x30, 0x65, 0x66, 0x31, 0x35, 0x35, 0x37, 0x36, 0x35, 0x34, 0x37, 0x32, 0x34, 0x35, 0x66, 0x62, 0x31, 0x37, 0x31, 0x39, 0x33, 0x39, 0x38, 0x32, 0x30, 0x64, 0x35, 0x35, 0x62, 0x31, 0x35, 0x32, 0x32, 0x37, 0x64, 0x62, 0x37, 0x30, 0x63, 0x33, 0x38, 0x38, 0x37, 0x30, 0x30, 0x31, 0x32, 0x34, 0x33, 0x61, 0x31, 0x34, 0x34, 0x34, 0x34, 0x39, 0x33, 0x38, 0x66, 0x33, 0x61, 0x62, 0x35, 0x66, 0x66, 0x63, 0x37, 0x34, 0x37, 0x31, 0x31, 0x35, 0x33, 0x33, 0x37, 0x32, 0x34, 0x33, 0x38, 0x38, 0x63, 0x62, 0x61, 0x62, 0x30, 0x61, 0x33, 0x61, 0x66, 0x32, 0x38, 0x61, 0x37, 0x38, 0x61, 0x61, 0x66, 0x62, 0x39, 0x38, 0x61, 0x35, 0x31, 0x33, 0x39, 0x63, 0x30, 0x32, 0x33, 0x35, 0x36, 0x35, 0x62, 0x63, 0x32, 0x65, 0x39, 0x37, 0x65, 0x36, 0x61, 0x31, 0x36, 0x36, 0x66, 0x39, 0x63, 0x61, 0x63, 0x35, 0x35, 0x31, 0x65, 0x64, 0x32, 0x32, 0x33, 0x34, 0x37, 0x32, 0x32, 0x34, 0x66, 0x35, 0x33, 0x65, 0x34, 0x39, 0x31, 0x65, 0x37, 0x39, 0x64, 0x30, 0x65, 0x61, 0x63, 0x36, 0x63, 0x30, 0x38, 0x62, 0x35, 0x38, 0x35, 0x34, 0x61, 0x39, 0x35, 0x37, 0x35, 0x38, 0x62, 0x33, 0x32, 0x38, 0x66, 0x62, 0x63, 0x30, 0x37, 0x66, 0x64, 0x34, 0x35, 0x66, 0x35, 0x39, 0x61, 0x35, 0x39, 0x34, 0x65, 0x63, 0x33, 0x66, 0x33, 0x32, 0x63, 0x35, 0x37, 0x30, 0x30, 0x64, 0x35, 0x65, 0x33, 0x66, 0x36, 0x35, 0x38, 0x32, 0x65, 0x35, 0x62, 0x37, 0x35, 0x30, 0x64, 0x35, 0x64, 0x35, 0x63, 0x32, 0x37, 0x66, 0x35, 0x32, 0x37, 0x34, 0x39, 0x32, 0x33, 0x64, 0x64, 0x30, 0x62, 0x66, 0x66, 0x37, 0x36, 0x63, 0x36, 0x61, 0x62, 0x34, 0x61, 0x38, 0x64, 0x36, 0x62, 0x36, 0x63, 0x37, 0x66, 0x61, 0x62, 0x63, 0x34, 0x35, 0x32, 0x39, 0x38, 0x62, 0x37, 0x39, 0x34, 0x39, 0x37, 0x39, 0x35, 0x63, 0x34, 0x32, 0x65, 0x32, 0x39, 0x39, 0x64, 0x36, 0x36, 0x62, 0x66, 0x65, 0x34, 0x64, 0x36, 0x65, 0x34, 0x32, 0x62, 0x66, 0x35, 0x39, 0x61, 0x38, 0x64, 0x34, 0x39, 0x39, 0x30, 0x65, 0x32, 0x36, 0x35, 0x65, 0x32, 0x62, 0x31, 0x65, 0x34, 0x37, 0x38, 0x64, 0x63, 0x64, 0x66, 0x39, 0x64, 0x35, 0x39, 0x33, 0x33, 0x37, 0x66, 0x66, 0x32, 0x36, 0x31, 0x62, 0x35, 0x65, 0x39, 0x36, 0x31, 0x39, 0x33, 0x39, 0x66, 0x34, 0x61, 0x39, 0x30, 0x62, 0x66, 0x63, 0x34, 0x32, 0x35, 0x65, 0x64, 0x34, 0x66, 0x36, 0x66, 0x62, 0x34, 0x61, 0x65, 0x33, 0x38, 0x38, 0x37, 0x38, 0x32, 0x63, 0x64, 0x64, 0x33, 0x30, 0x37, 0x35, 0x34, 0x62, 0x62, 0x36, 0x38, 0x34, 0x34, 0x38, 0x66, 0x34, 0x31, 0x61, 0x32, 0x39, 0x63, 0x39, 0x65, 0x38, 0x63, 0x64, 0x35, 0x34, 0x34, 0x33, 0x64, 0x38, 0x35, 0x65, 0x31, 0x62, 0x35, 0x36, 0x62, 0x35, 0x31, 0x64, 0x30, 0x63, 0x35, 0x64, 0x33, 0x62, 0x34, 0x32, 0x38, 0x33, 0x35, 0x65, 0x38, 0x35, 0x38, 0x64, 0x39, 0x36, 0x33, 0x35, 0x31, 0x37, 0x65, 0x34, 0x65, 0x64, 0x30, 0x61, 0x62, 0x65, 0x30, 0x30, 0x62, 0x37, 0x39, 0x39, 0x38, 0x62, 0x66, 0x31, 0x36, 0x64, 0x36, 0x61, 0x61, 0x31, 0x64, 0x31, 0x39, 0x32, 0x35, 0x38, 0x63, 0x31, 0x38, 0x62, 0x63, 0x66, 0x66, 0x36, 0x39, 0x63, 0x30, 0x66, 0x61, 0x65, 0x32, 0x33, 0x35, 0x38, 0x34, 0x39, 0x64, 0x35, 0x64, 0x38, 0x33, 0x30, 0x63, 0x34, 0x35, 0x62, 0x38, 0x62, 0x65, 0x31, 0x38, 0x38, 0x37, 0x31, 0x37, 0x32, 0x66, 0x32, 0x66, 0x34, 0x31, 0x64, 0x32, 0x32, 0x39, 0x61, 0x65, 0x63, 0x33, 0x33, 0x66, 0x37, 0x65, 0x31, 0x33, 0x37, 0x32, 0x35, 0x37, 0x32, 0x34, 0x65, 0x65, 0x36, 0x34, 0x63, 0x61, 0x65, 0x30, 0x64, 0x32, 0x62, 0x31, 0x35, 0x37, 0x63, 0x31, 0x64, 0x31, 0x32, 0x62, 0x64, 0x39, 0x33, 0x65, 0x64, 0x32, 0x37, 0x32, 0x31, 0x33, 0x39, 0x34, 0x38, 0x38, 0x33, 0x64, 0x34, 0x32, 0x33, 0x65, 0x34, 0x66, 0x66, 0x33, 0x31, 0x37, 0x61, 0x33, 0x38, 0x63, 0x38, 0x39, 0x33, 0x39, 0x33, 0x34, 0x61, 0x66, 0x64, 0x61, 0x62, 0x37, 0x32, 0x30, 0x35, 0x65, 0x39, 0x64, 0x65, 0x66, 0x31, 0x39, 0x37, 0x63, 0x39, 0x31, 0x39, 0x33, 0x64, 0x65, 0x33, 0x33, 0x65, 0x36, 0x37, 0x64, 0x64, 0x32, 0x31, 0x31, 0x35, 0x62, 0x62, 0x33, 0x31, 0x30, 0x37, 0x64, 0x32, 0x63, 0x37, 0x35, 0x61, 0x36, 0x30, 0x35, 0x30, 0x64, 0x63, 0x63, 0x36, 0x64, 0x62, 0x30, 0x38, 0x63, 0x30, 0x31, 0x33, 0x30, 0x35, 0x66, 0x33, 0x32, 0x63, 0x37, 0x32, 0x32, 0x62, 0x37, 0x30, 0x31, 0x31, 0x34, 0x63, 0x31, 0x32, 0x62, 0x30, 0x36, 0x61, 0x34, 0x37, 0x66, 0x62, 0x65, 0x33, 0x61, 0x31, 0x39, 0x38, 0x64, 0x34, 0x63, 0x35, 0x65, 0x64, 0x39, 0x37, 0x36, 0x39, 0x35, 0x36, 0x30, 0x62, 0x61, 0x39, 0x65, 0x33, 0x66, 0x61, 0x30, 0x31, 0x38, 0x32, 0x63, 0x63, 0x39, 0x37, 0x30, 0x62, 0x62, 0x32, 0x65, 0x32, 0x31, 0x32, 0x32, 0x39, 0x37, 0x32, 0x31, 0x64, 0x31, 0x31, 0x36, 0x35, 0x32, 0x31, 0x35, 0x30, 0x62, 0x34, 0x36, 0x39, 0x37, 0x35, 0x38, 0x37, 0x66, 0x65, 0x33, 0x31, 0x39, 0x30, 0x61, 0x33, 0x63, 0x61, 0x33, 0x64, 0x61, 0x33, 0x63, 0x65, 0x36, 0x61, 0x64, 0x36, 0x36, 0x64, 0x66, 0x38, 0x33, 0x36, 0x66, 0x31, 0x62, 0x63, 0x34, 0x39, 0x30, 0x32, 0x33, 0x39, 0x39, 0x32, 0x37, 0x30, 0x32, 0x62, 0x37, 0x35, 0x37, 0x32, 0x64, 0x36, 0x64, 0x31, 0x35, 0x34, 0x64, 0x65, 0x33, 0x66, 0x62, 0x38, 0x36, 0x33, 0x32, 0x62, 0x38, 0x61, 0x39, 0x33, 0x64, 0x36, 0x31, 0x39, 0x37, 0x31, 0x39, 0x34, 0x34, 0x33, 0x63, 0x30, 0x34, 0x30, 0x61, 0x36, 0x64, 0x33, 0x38, 0x65, 0x31, 0x33, 0x35, 0x32, 0x30, 0x34, 0x64, 0x62, 0x64, 0x30, 0x66, 0x61, 0x32, 0x31, 0x38, 0x32, 0x61, 0x65, 0x64, 0x33, 0x34, 0x32, 0x35, 0x39, 0x65, 0x33, 0x31, 0x62, 0x37, 0x31, 0x33, 0x34, 0x66, 0x34, 0x36, 0x31, 0x34, 0x37, 0x65, 0x34, 0x37, 0x65, 0x65, 0x34, 0x32, 0x63, 0x61, 0x34, 0x31, 0x32, 0x30, 0x32, 0x36, 0x65, 0x63, 0x33, 0x31, 0x62, 0x37, 0x63, 0x33, 0x63, 0x61, 0x63, 0x32, 0x62, 0x62, 0x32, 0x33, 0x31, 0x36, 0x63, 0x39, 0x66, 0x62, 0x65, 0x62, 0x36, 0x35, 0x61, 0x63, 0x61, 0x33, 0x63, 0x66, 0x65, 0x37, 0x32, 0x63, 0x39, 0x63, 0x35, 0x30, 0x32, 0x34, 0x39, 0x65, 0x30, 0x66, 0x62, 0x64, 0x65, 0x30, 0x35, 0x34, 0x38, 0x39, 0x64, 0x65, 0x65, 0x38, 0x39, 0x32, 0x34, 0x61, 0x63, 0x65, 0x61, 0x64, 0x34, 0x39, 0x30, 0x32, 0x31, 0x37, 0x35, 0x38, 0x32, 0x38, 0x62, 0x66, 0x62, 0x64, 0x31, 0x32, 0x35, 0x35, 0x61, 0x66, 0x35, 0x65, 0x64, 0x37, 0x35, 0x36, 0x36, 0x31, 0x65, 0x37, 0x30, 0x35, 0x65, 0x65, 0x30, 0x37, 0x64, 0x37, 0x37, 0x35, 0x65, 0x61, 0x31, 0x62, 0x33, 0x37, 0x33, 0x30, 0x34, 0x63, 0x36, 0x63, 0x37, 0x31, 0x62, 0x30, 0x30, 0x32, 0x66, 0x38, 0x65, 0x32, 0x37, 0x62, 0x34, 0x32, 0x31, 0x65, 0x35, 0x32, 0x35, 0x63, 0x39, 0x38, 0x34, 0x33, 0x63, 0x33, 0x66, 0x61, 0x34, 0x64, 0x33, 0x63, 0x63, 0x66, 0x63, 0x64, 0x39, 0x34, 0x63, 0x66, 0x38, 0x34, 0x33, 0x30, 0x39, 0x35, 0x38, 0x30, 0x64, 0x35, 0x65, 0x64, 0x30, 0x61, 0x64, 0x31, 0x34, 0x31, 0x34, 0x36, 0x34, 0x34, 0x30, 0x61, 0x64, 0x31, 0x34, 0x34, 0x36, 0x30, 0x63, 0x36, 0x38, 0x64, 0x38, 0x63, 0x36, 0x32, 0x36, 0x66, 0x63, 0x64, 0x61, 0x38, 0x65, 0x39, 0x61, 0x38, 0x31, 0x39, 0x33, 0x30, 0x32, 0x30, 0x39, 0x61, 0x35, 0x30, 0x30, 0x64, 0x38, 0x65, 0x61, 0x62, 0x32, 0x38, 0x30, 0x35, 0x37, 0x34, 0x34, 0x64, 0x62, 0x64, 0x66, 0x34, 0x65, 0x38, 0x30, 0x33, 0x35, 0x35, 0x36, 0x65, 0x35, 0x30, 0x32, 0x64, 0x34, 0x63, 0x35, 0x32, 0x39, 0x66, 0x37, 0x64, 0x30, 0x36, 0x66, 0x37, 0x31, 0x38, 0x36, 0x66, 0x31, 0x39, 0x66, 0x66, 0x36, 0x65, 0x35, 0x63, 0x66, 0x31, 0x31, 0x66, 0x38, 0x34, 0x34, 0x33, 0x64, 0x36, 0x34, 0x33, 0x39, 0x34, 0x34, 0x32, 0x36, 0x31, 0x30, 0x37, 0x32, 0x35, 0x64, 0x65, 0x34, 0x62, 0x61, 0x39, 0x66, 0x34, 0x36, 0x32, 0x61, 0x34, 0x38, 0x38, 0x37, 0x34, 0x33, 0x30, 0x65, 0x61, 0x62, 0x30, 0x35, 0x36, 0x34, 0x66, 0x63, 0x32, 0x35, 0x66, 0x33, 0x33, 0x36, 0x35, 0x39, 0x65, 0x66, 0x31, 0x63, 0x32, 0x37, 0x39, 0x66, 0x34, 0x32, 0x66, 0x32, 0x66, 0x30, 0x34, 0x30, 0x30, 0x32, 0x31, 0x62, 0x32, 0x38, 0x38, 0x66, 0x32, 0x64, 0x35, 0x62, 0x39, 0x38, 0x63, 0x33, 0x39, 0x39, 0x61, 0x64, 0x34, 0x64, 0x61, 0x64, 0x61, 0x37, 0x66, 0x34, 0x62, 0x37, 0x65, 0x66, 0x63, 0x62, 0x65, 0x33, 0x31, 0x33, 0x64, 0x38, 0x62, 0x63, 0x38, 0x33, 0x61, 0x61, 0x34, 0x35, 0x61, 0x62, 0x39, 0x35, 0x62, 0x36, 0x39, 0x39, 0x31, 0x31, 0x34, 0x62, 0x30, 0x34, 0x34, 0x38, 0x30, 0x31, 0x35, 0x35, 0x62, 0x37, 0x64, 0x63, 0x38, 0x30, 0x37, 0x32, 0x30, 0x65, 0x64, 0x64, 0x39, 0x30, 0x65, 0x66, 0x66, 0x33, 0x34, 0x30, 0x31, 0x66, 0x61, 0x63, 0x66, 0x37, 0x64, 0x38, 0x38, 0x63, 0x63, 0x62, 0x35, 0x39, 0x35, 0x38, 0x61, 0x32, 0x34, 0x39, 0x34, 0x36, 0x65, 0x38, 0x30, 0x39, 0x33, 0x37, 0x64, 0x31, 0x63, 0x36, 0x35, 0x64, 0x66, 0x38, 0x66, 0x36, 0x37, 0x36, 0x39, 0x63, 0x36, 0x64, 0x61, 0x65, 0x61, 0x31, 0x62, 0x63, 0x31, 0x39, 0x65, 0x62, 0x66, 0x39, 0x32, 0x36, 0x36, 0x64, 0x38, 0x62, 0x33, 0x63, 0x32, 0x61, 0x66, 0x30, 0x61, 0x63, 0x30, 0x30, 0x66, 0x30, 0x32, 0x63, 0x37, 0x31, 0x37, 0x62, 0x35, 0x30, 0x66, 0x37, 0x30, 0x37, 0x35, 0x33, 0x36, 0x38, 0x37, 0x36, 0x32, 0x63, 0x63, 0x34, 0x33, 0x61, 0x65, 0x32, 0x39, 0x32, 0x63, 0x64, 0x33, 0x34, 0x32, 0x39, 0x39, 0x63, 0x65, 0x62, 0x66, 0x62, 0x37, 0x32, 0x34, 0x65, 0x38, 0x61, 0x36, 0x64, 0x38, 0x63, 0x31, 0x31, 0x30, 0x63, 0x62, 0x35, 0x64, 0x35, 0x39, 0x35, 0x66, 0x38, 0x65, 0x38, 0x32, 0x38, 0x35, 0x66, 0x64, 0x62, 0x38, 0x39, 0x38, 0x61, 0x39, 0x35, 0x30, 0x31, 0x33, 0x66, 0x39, 0x35, 0x34, 0x39, 0x62, 0x64, 0x33, 0x31, 0x66, 0x33, 0x30, 0x33, 0x31, 0x35, 0x31, 0x61, 0x39, 0x36, 0x62, 0x63, 0x63, 0x37, 0x36, 0x65, 0x33, 0x34, 0x65, 0x30, 0x39, 0x65, 0x63, 0x66, 0x65, 0x31, 0x36, 0x63, 0x66, 0x30, 0x36, 0x37, 0x33, 0x39, 0x35, 0x65, 0x65, 0x35, 0x31, 0x62, 0x39, 0x64, 0x35, 0x66, 0x36, 0x61, 0x31, 0x61, 0x66, 0x62, 0x30, 0x39, 0x35, 0x31, 0x32, 0x63, 0x62, 0x63, 0x34, 0x32, 0x34, 0x39, 0x62, 0x34, 0x62, 0x64, 0x33, 0x36, 0x30, 0x66, 0x62, 0x30, 0x64, 0x30, 0x63, 0x37, 0x38, 0x39, 0x62, 0x31, 0x30, 0x35, 0x64, 0x65, 0x64, 0x62, 0x61, 0x38, 0x32, 0x37, 0x38, 0x64, 0x31, 0x39, 0x64, 0x61, 0x66, 0x31, 0x63, 0x32, 0x63, 0x33, 0x39, 0x64, 0x35, 0x39, 0x35, 0x34, 0x35, 0x37, 0x64, 0x31, 0x31, 0x35, 0x62, 0x39, 0x36, 0x62, 0x33, 0x39, 0x38, 0x31, 0x64, 0x37, 0x32, 0x63, 0x33, 0x32, 0x38, 0x63, 0x32, 0x34, 0x31, 0x31, 0x65, 0x36, 0x61, 0x30, 0x63, 0x33, 0x32, 0x39, 0x61, 0x37, 0x31, 0x30, 0x35, 0x33, 0x32, 0x30, 0x63, 0x63, 0x33, 0x39, 0x65, 0x64, 0x39, 0x62, 0x35, 0x64, 0x39, 0x61, 0x30, 0x61, 0x37, 0x66, 0x64, 0x65, 0x32, 0x30, 0x32, 0x30, 0x66, 0x62, 0x30, 0x32, 0x63, 0x61, 0x65, 0x35, 0x35, 0x35, 0x32, 0x35, 0x30, 0x34, 0x33, 0x61, 0x36, 0x34, 0x39, 0x61, 0x38, 0x38, 0x63, 0x35, 0x31, 0x33, 0x66, 0x36, 0x62, 0x63, 0x32, 0x33, 0x64, 0x35, 0x32, 0x30, 0x37, 0x32, 0x37, 0x36, 0x63, 0x66, 0x31, 0x37, 0x64, 0x64, 0x35, 0x38, 0x66, 0x64, 0x33, 0x37, 0x39, 0x62, 0x65, 0x62, 0x32, 0x36, 0x30, 0x33, 0x33, 0x36, 0x66, 0x64, 0x61, 0x31, 0x63, 0x31, 0x39, 0x36, 0x32, 0x38, 0x62, 0x64, 0x61, 0x64, 0x37, 0x64, 0x66, 0x39, 0x63, 0x36, 0x66, 0x61, 0x35, 0x36, 0x63, 0x38, 0x66, 0x64, 0x37, 0x61, 0x64, 0x36, 0x34, 0x65, 0x32, 0x63, 0x32, 0x39, 0x37, 0x32, 0x33, 0x30, 0x64, 0x31, 0x65, 0x37, 0x36, 0x61, 0x33, 0x36, 0x35, 0x32, 0x38, 0x63, 0x32, 0x35, 0x37, 0x35, 0x32, 0x62, 0x36, 0x37, 0x61, 0x62, 0x39, 0x37, 0x33, 0x65, 0x61, 0x39, 0x37, 0x38, 0x31, 0x36, 0x39, 0x35, 0x31, 0x62, 0x30, 0x34, 0x36, 0x63, 0x35, 0x62, 0x38, 0x61, 0x65, 0x62, 0x39, 0x32, 0x36, 0x35, 0x62, 0x34, 0x63, 0x65, 0x62, 0x34, 0x66, 0x36, 0x63, 0x33, 0x31, 0x30, 0x33, 0x32, 0x39, 0x39, 0x31, 0x63, 0x65, 0x33, 0x64, 0x36, 0x34, 0x62, 0x63, 0x31, 0x32, 0x64, 0x36, 0x64, 0x63, 0x66, 0x38, 0x65, 0x37, 0x63, 0x37, 0x33, 0x31, 0x62, 0x33, 0x35, 0x36, 0x36, 0x64, 0x64, 0x39, 0x65, 0x35, 0x38, 0x61, 0x31, 0x61, 0x66, 0x65, 0x39, 0x31, 0x64, 0x38, 0x37, 0x64, 0x63, 0x61, 0x61, 0x37, 0x30, 0x39, 0x32, 0x39, 0x30, 0x39, 0x65, 0x62, 0x37, 0x30, 0x31, 0x33, 0x35, 0x61, 0x30, 0x66, 0x39, 0x30, 0x61, 0x32, 0x38, 0x62, 0x34, 0x35, 0x62, 0x31, 0x35, 0x63, 0x31, 0x35, 0x35, 0x34, 0x32, 0x35, 0x36, 0x61, 0x65, 0x32, 0x61, 0x35, 0x33, 0x34, 0x62, 0x66, 0x31, 0x30, 0x66, 0x33, 0x33, 0x37, 0x38, 0x32, 0x64, 0x39, 0x31, 0x63, 0x32, 0x62, 0x32, 0x63, 0x65, 0x64, 0x66, 0x65, 0x64, 0x35, 0x39, 0x36, 0x31, 0x35, 0x34, 0x65, 0x35, 0x34, 0x64, 0x30, 0x32, 0x64, 0x38, 0x37, 0x37, 0x39, 0x61, 0x37, 0x30, 0x30, 0x62, 0x62, 0x34, 0x30, 0x61, 0x38, 0x65, 0x64, 0x62, 0x38, 0x38, 0x30, 0x31, 0x39, 0x32, 0x30, 0x34, 0x36, 0x31, 0x62, 0x66, 0x37, 0x61, 0x62, 0x63, 0x63, 0x62, 0x34, 0x34, 0x31, 0x31, 0x38, 0x37, 0x66, 0x33, 0x38, 0x34, 0x64, 0x31, 0x35, 0x61, 0x33, 0x36, 0x66, 0x33, 0x31, 0x61, 0x64, 0x61, 0x30, 0x34, 0x35, 0x65, 0x36, 0x32, 0x63, 0x39, 0x34, 0x30, 0x62, 0x36, 0x30, 0x64, 0x38, 0x30, 0x65, 0x37, 0x61, 0x66, 0x66, 0x31, 0x36, 0x64, 0x62, 0x34, 0x39, 0x39, 0x33, 0x65, 0x30, 0x66, 0x31, 0x35, 0x65, 0x34, 0x33, 0x66, 0x65, 0x64, 0x32, 0x31, 0x65, 0x66, 0x35, 0x62, 0x61, 0x38, 0x38, 0x65, 0x61, 0x35, 0x32, 0x61, 0x61, 0x35, 0x66, 0x61, 0x37, 0x30, 0x61, 0x34, 0x33, 0x32, 0x35, 0x30, 0x32, 0x38, 0x63, 0x33, 0x33, 0x64, 0x63, 0x36, 0x37, 0x30, 0x32, 0x63, 0x30, 0x33, 0x37, 0x31, 0x62, 0x64, 0x37, 0x35, 0x34, 0x33, 0x32, 0x35, 0x37, 0x33, 0x62, 0x36, 0x64, 0x37, 0x63, 0x37, 0x62, 0x33, 0x63, 0x36, 0x32, 0x35, 0x65, 0x65, 0x65, 0x34, 0x64, 0x64, 0x62, 0x64, 0x61, 0x37, 0x62, 0x38, 0x36, 0x31, 0x66, 0x38, 0x38, 0x65, 0x32, 0x66, 0x36, 0x66, 0x62, 0x65, 0x31, 0x62, 0x35, 0x39, 0x38, 0x34, 0x39, 0x66, 0x65, 0x63, 0x65, 0x30, 0x36, 0x65, 0x33, 0x37, 0x63, 0x36, 0x61, 0x62, 0x35, 0x30, 0x66, 0x38, 0x64, 0x36, 0x66, 0x66, 0x65, 0x63, 0x63, 0x65, 0x32, 0x33, 0x39, 0x34, 0x63, 0x32, 0x32, 0x35, 0x63, 0x65, 0x37, 0x30, 0x64, 0x33, 0x34, 0x35, 0x62, 0x33, 0x32, 0x36, 0x33, 0x30, 0x32, 0x36, 0x39, 0x34, 0x64, 0x65, 0x39, 0x66, 0x66, 0x65, 0x33, 0x66, 0x32, 0x34, 0x39, 0x30, 0x32, 0x35, 0x32, 0x65, 0x64, 0x38, 0x64, 0x65, 0x64, 0x62, 0x64, 0x39, 0x37, 0x64, 0x31, 0x63, 0x36, 0x65, 0x36, 0x64, 0x38, 0x36, 0x38, 0x66, 0x61, 0x31, 0x61, 0x34, 0x66, 0x33, 0x30, 0x30, 0x39, 0x35, 0x66, 0x63, 0x65, 0x33, 0x66, 0x35, 0x30, 0x39, 0x66, 0x64, 0x36, 0x62, 0x31, 0x37, 0x61, 0x32, 0x37, 0x37, 0x35, 0x38, 0x66, 0x66, 0x35, 0x33, 0x66, 0x30, 0x36, 0x34, 0x30, 0x63, 0x64, 0x35, 0x34, 0x38, 0x62, 0x62, 0x34, 0x32, 0x32, 0x34, 0x32, 0x61, 0x35, 0x32, 0x35, 0x65, 0x30, 0x33, 0x62, 0x34, 0x37, 0x61, 0x61, 0x32, 0x66, 0x38, 0x65, 0x36, 0x35, 0x39, 0x33, 0x37, 0x36, 0x62, 0x37, 0x39, 0x37, 0x63, 0x61, 0x36, 0x62, 0x63, 0x62, 0x35, 0x64, 0x61, 0x37, 0x31, 0x63, 0x32, 0x61, 0x35, 0x34, 0x66, 0x38, 0x65, 0x32, 0x31, 0x34, 0x65, 0x32, 0x32, 0x61, 0x65, 0x30, 0x62, 0x31, 0x64, 0x35, 0x30, 0x62, 0x64, 0x32, 0x61, 0x66, 0x63, 0x37, 0x66, 0x30, 0x31, 0x36, 0x33, 0x66, 0x31, 0x35, 0x30, 0x65, 0x66, 0x64, 0x38, 0x61, 0x34, 0x37, 0x61, 0x33, 0x38, 0x32, 0x31, 0x36, 0x33, 0x32, 0x35, 0x61, 0x62, 0x65, 0x64, 0x63, 0x64, 0x30, 0x31, 0x65, 0x62, 0x66, 0x62, 0x66, 0x37, 0x37, 0x38, 0x34, 0x63, 0x32, 0x65, 0x63, 0x34, 0x37, 0x32, 0x65, 0x38, 0x36, 0x62, 0x33, 0x34, 0x36, 0x32, 0x62, 0x35, 0x32, 0x65, 0x33, 0x32, 0x34, 0x30, 0x61, 0x66, 0x64, 0x62, 0x37, 0x33, 0x34, 0x38, 0x61, 0x30, 0x63, 0x38, 0x32, 0x64, 0x33, 0x38, 0x63, 0x61, 0x33, 0x37, 0x62, 0x64, 0x36, 0x63, 0x65, 0x37, 0x65, 0x30, 0x37, 0x63, 0x39, 0x35, 0x39, 0x36, 0x64, 0x61, 0x66, 0x39, 0x33, 0x38, 0x66, 0x36, 0x34, 0x63, 0x33, 0x65, 0x30, 0x66, 0x32, 0x32, 0x62, 0x37, 0x61, 0x32, 0x35, 0x65, 0x35, 0x39, 0x39, 0x32, 0x30, 0x65, 0x64, 0x61, 0x34, 0x37, 0x39, 0x33, 0x30, 0x31, 0x37, 0x63, 0x32, 0x32, 0x34, 0x33, 0x62, 0x62, 0x61, 0x36, 0x66, 0x36, 0x34, 0x34, 0x35, 0x61, 0x36, 0x37, 0x30, 0x65, 0x35, 0x35, 0x38, 0x37, 0x64, 0x64, 0x33, 0x36, 0x38, 0x30, 0x63, 0x66, 0x30, 0x37, 0x61, 0x35, 0x39, 0x37, 0x61, 0x36, 0x37, 0x32, 0x65, 0x38, 0x31, 0x38, 0x36, 0x38, 0x62, 0x32, 0x32, 0x36, 0x62, 0x39, 0x33, 0x30, 0x64, 0x35, 0x66, 0x31, 0x36, 0x63, 0x66, 0x61, 0x66, 0x31, 0x31, 0x65, 0x65, 0x36, 0x31, 0x31, 0x34, 0x32, 0x33, 0x34, 0x66, 0x61, 0x65, 0x34, 0x38, 0x33, 0x31, 0x35, 0x39, 0x62, 0x39, 0x61, 0x35, 0x63, 0x61, 0x34, 0x63, 0x31, 0x34, 0x39, 0x38, 0x30, 0x35, 0x38, 0x64, 0x32, 0x35, 0x34, 0x32, 0x66, 0x37, 0x34, 0x33, 0x32, 0x32, 0x31, 0x32, 0x38, 0x61, 0x66, 0x63, 0x32, 0x36, 0x38, 0x38, 0x64, 0x31, 0x33, 0x31, 0x36, 0x65, 0x62, 0x64, 0x30, 0x30, 0x32, 0x39, 0x39, 0x64, 0x33, 0x34, 0x34, 0x34, 0x32, 0x61, 0x33, 0x64, 0x61, 0x62, 0x32, 0x39, 0x37, 0x61, 0x62, 0x37, 0x66, 0x64, 0x36, 0x61, 0x64, 0x62, 0x66, 0x63, 0x35, 0x62, 0x35, 0x35, 0x66, 0x31, 0x37, 0x34, 0x63, 0x31, 0x30, 0x61, 0x61, 0x64, 0x64, 0x66, 0x35, 0x30, 0x38, 0x36, 0x33, 0x30, 0x63, 0x30, 0x30, 0x36, 0x61, 0x39, 0x32, 0x33, 0x66, 0x31, 0x37, 0x64, 0x38, 0x34, 0x63, 0x62, 0x34, 0x33, 0x37, 0x30, 0x37, 0x63, 0x64, 0x62, 0x61, 0x35, 0x31, 0x32, 0x38, 0x38, 0x61, 0x34, 0x35, 0x32, 0x63, 0x34, 0x30, 0x63, 0x65, 0x39, 0x39, 0x62, 0x31, 0x34, 0x61, 0x64, 0x30, 0x33, 0x34, 0x39, 0x63, 0x37, 0x32, 0x66, 0x62, 0x34, 0x37, 0x34, 0x33, 0x39, 0x36, 0x31, 0x33, 0x36, 0x30, 0x32, 0x34, 0x36, 0x38, 0x35, 0x36, 0x38, 0x38, 0x62, 0x37, 0x34, 0x62, 0x33, 0x32, 0x31, 0x37, 0x36, 0x30, 0x34, 0x37, 0x65, 0x33, 0x35, 0x39, 0x36, 0x31, 0x63, 0x66, 0x38, 0x66, 0x66, 0x34, 0x38, 0x31, 0x63, 0x65, 0x38, 0x30, 0x61, 0x32, 0x64, 0x33, 0x32, 0x65, 0x30, 0x36, 0x35, 0x32, 0x38, 0x63, 0x37, 0x32, 0x34, 0x36, 0x66, 0x31, 0x61, 0x30, 0x63, 0x65, 0x61, 0x38, 0x61, 0x30, 0x36, 0x61, 0x36, 0x31, 0x35, 0x38, 0x32, 0x61, 0x66, 0x32, 0x64, 0x31, 0x66, 0x61, 0x34, 0x35, 0x31, 0x61, 0x63, 0x31, 0x37, 0x33, 0x65, 0x30, 0x38, 0x31, 0x64, 0x65, 0x63, 0x62, 0x39, 0x32, 0x35, 0x33, 0x34, 0x35, 0x62, 0x38, 0x61, 0x31, 0x37, 0x36, 0x33, 0x61, 0x34, 0x66, 0x64, 0x36, 0x37, 0x31, 0x37, 0x32, 0x32, 0x64, 0x35, 0x66, 0x33, 0x31, 0x31, 0x32, 0x38, 0x65, 0x30, 0x33, 0x30, 0x66, 0x35, 0x62, 0x32, 0x35, 0x66, 0x62, 0x61, 0x61, 0x34, 0x65, 0x65, 0x33, 0x36, 0x61, 0x32, 0x32, 0x33, 0x33, 0x33, 0x38, 0x61, 0x32, 0x31, 0x65, 0x32, 0x34, 0x35, 0x39, 0x38, 0x33, 0x31, 0x63, 0x34, 0x33, 0x37, 0x35, 0x64, 0x30, 0x62, 0x35, 0x37, 0x32, 0x64, 0x34, 0x39, 0x64, 0x39, 0x62, 0x37, 0x32, 0x37, 0x61, 0x62, 0x64, 0x34, 0x36, 0x33, 0x36, 0x34, 0x30, 0x63, 0x39, 0x65, 0x32, 0x62, 0x62, 0x30, 0x38, 0x63, 0x34, 0x66, 0x61, 0x62, 0x36, 0x64, 0x31, 0x30, 0x31, 0x31, 0x35, 0x31, 0x35, 0x63, 0x30, 0x35, 0x36, 0x39, 0x31, 0x34, 0x39, 0x30, 0x66, 0x32, 0x32, 0x35, 0x62, 0x33, 0x37, 0x32, 0x38, 0x34, 0x32, 0x36, 0x65, 0x65, 0x32, 0x32, 0x38, 0x63, 0x65, 0x65, 0x65, 0x30, 0x32, 0x33, 0x63, 0x33, 0x64, 0x63, 0x38, 0x64, 0x31, 0x37, 0x65, 0x37, 0x30, 0x31, 0x37, 0x35, 0x64, 0x36, 0x30, 0x62, 0x35, 0x36, 0x61, 0x39, 0x32, 0x37, 0x33, 0x37, 0x35, 0x31, 0x33, 0x33, 0x63, 0x63, 0x36, 0x39, 0x63, 0x34, 0x35, 0x66, 0x61, 0x39, 0x35, 0x32, 0x32, 0x63, 0x35, 0x36, 0x64, 0x63, 0x35, 0x64, 0x61, 0x65, 0x32, 0x30, 0x62, 0x35, 0x62, 0x38, 0x66, 0x62, 0x63, 0x34, 0x62, 0x62, 0x37, 0x39, 0x36, 0x37, 0x34, 0x61, 0x64, 0x32, 0x33, 0x63, 0x30, 0x37, 0x63, 0x36, 0x38, 0x31, 0x61, 0x35, 0x65, 0x31, 0x31, 0x30, 0x65, 0x31, 0x62, 0x39, 0x30, 0x31, 0x34, 0x33, 0x64, 0x64, 0x30, 0x65, 0x37, 0x65, 0x64, 0x35, 0x66, 0x32, 0x37, 0x35, 0x63, 0x33, 0x64, 0x62, 0x65, 0x30, 0x32, 0x62, 0x35, 0x31, 0x63, 0x66, 0x33, 0x61, 0x65, 0x33, 0x30, 0x32, 0x63, 0x35, 0x30, 0x64, 0x64, 0x62, 0x36, 0x62, 0x66, 0x38, 0x61, 0x34, 0x34, 0x36, 0x62, 0x33, 0x32, 0x38, 0x63, 0x36, 0x62, 0x65, 0x64, 0x31, 0x39, 0x61, 0x34, 0x64, 0x63, 0x65, 0x39, 0x64, 0x31, 0x38, 0x37, 0x31, 0x61, 0x62, 0x38, 0x35, 0x34, 0x32, 0x31, 0x39, 0x66, 0x62, 0x36, 0x61, 0x64, 0x38, 0x66, 0x64, 0x32, 0x30, 0x36, 0x66, 0x31, 0x34, 0x62, 0x66, 0x32, 0x62, 0x33, 0x38, 0x63, 0x37, 0x32, 0x37, 0x39, 0x63, 0x65, 0x33, 0x64, 0x64, 0x39, 0x65, 0x65, 0x30, 0x30, 0x37, 0x38, 0x30, 0x32, 0x65, 0x38, 0x66, 0x35, 0x36, 0x34, 0x32, 0x31, 0x62, 0x32, 0x30, 0x36, 0x32, 0x66, 0x38, 0x62, 0x62, 0x61, 0x30, 0x36, 0x32, 0x64, 0x61, 0x62, 0x32, 0x37, 0x66, 0x32, 0x32, 0x31, 0x64, 0x39, 0x38, 0x32, 0x62, 0x34, 0x34, 0x34, 0x36, 0x34, 0x65, 0x35, 0x33, 0x35, 0x37, 0x38, 0x31, 0x35, 0x61, 0x37, 0x32, 0x64, 0x30, 0x65, 0x32, 0x37, 0x39, 0x62, 0x33, 0x31, 0x32, 0x33, 0x65, 0x39, 0x38, 0x63, 0x61, 0x34, 0x64, 0x63, 0x61, 0x62, 0x34, 0x37, 0x63, 0x37, 0x30, 0x63, 0x32, 0x66, 0x63, 0x35, 0x61, 0x66, 0x35, 0x34, 0x37, 0x38, 0x37, 0x63, 0x35, 0x63, 0x34, 0x31, 0x33, 0x34, 0x31, 0x35, 0x35, 0x36, 0x66, 0x31, 0x39, 0x30, 0x64, 0x65, 0x64, 0x37, 0x38, 0x30, 0x37, 0x32, 0x31, 0x35, 0x65, 0x63, 0x35, 0x33, 0x64, 0x31, 0x34, 0x31, 0x62, 0x32, 0x31, 0x35, 0x30, 0x32, 0x33, 0x35, 0x33, 0x66, 0x31, 0x34, 0x31, 0x66, 0x39, 0x30, 0x63, 0x34, 0x31, 0x34, 0x37, 0x30, 0x35, 0x63, 0x64, 0x36, 0x66, 0x30, 0x37, 0x33, 0x66, 0x37, 0x30, 0x34, 0x32, 0x36, 0x34, 0x66, 0x31, 0x63, 0x64, 0x34, 0x65, 0x65, 0x66, 0x66, 0x63, 0x64, 0x63, 0x35, 0x65, 0x66, 0x37, 0x32, 0x32, 0x33, 0x39, 0x63, 0x64, 0x61, 0x35, 0x38, 0x62, 0x63, 0x61, 0x37, 0x61, 0x35, 0x32, 0x38, 0x37, 0x65, 0x61, 0x30, 0x61, 0x61, 0x36, 0x62, 0x65, 0x33, 0x38, 0x66, 0x31, 0x39, 0x31, 0x61, 0x33, 0x31, 0x39, 0x31, 0x30, 0x62, 0x32, 0x63, 0x30, 0x33, 0x34, 0x65, 0x39, 0x30, 0x39, 0x63, 0x35, 0x33, 0x64, 0x66, 0x36, 0x31, 0x36, 0x33, 0x36, 0x35, 0x30, 0x63, 0x65, 0x66, 0x36, 0x35, 0x61, 0x65, 0x65, 0x32, 0x35, 0x30, 0x31, 0x33, 0x38, 0x61, 0x63, 0x33, 0x31, 0x38, 0x39, 0x38, 0x39, 0x66, 0x66, 0x37, 0x34, 0x33, 0x34, 0x35, 0x30, 0x34, 0x32, 0x66, 0x62, 0x33, 0x38, 0x66, 0x39, 0x62, 0x36, 0x37, 0x65, 0x37, 0x34, 0x66, 0x63, 0x62, 0x34, 0x36, 0x64, 0x37, 0x65, 0x38, 0x64, 0x36, 0x62, 0x33, 0x39, 0x30, 0x36, 0x32, 0x32, 0x36, 0x65, 0x36, 0x37, 0x30, 0x35, 0x30, 0x38, 0x33, 0x38, 0x34, 0x61, 0x66, 0x32, 0x35, 0x64, 0x35, 0x34, 0x64, 0x32, 0x63, 0x63, 0x34, 0x30, 0x65, 0x64, 0x37, 0x32, 0x32, 0x33, 0x39, 0x35, 0x37, 0x38, 0x63, 0x62, 0x62, 0x61, 0x30, 0x35, 0x34, 0x39, 0x39, 0x62, 0x66, 0x36, 0x66, 0x35, 0x38, 0x33, 0x62, 0x34, 0x30, 0x33, 0x33, 0x37, 0x35, 0x66, 0x34, 0x63, 0x61, 0x38, 0x66, 0x62, 0x35, 0x38, 0x65, 0x37, 0x30, 0x36, 0x30, 0x39, 0x64, 0x61, 0x35, 0x32, 0x31, 0x66, 0x66, 0x34, 0x65, 0x39, 0x63, 0x66, 0x39, 0x62, 0x33, 0x64, 0x32, 0x34, 0x62, 0x37, 0x38, 0x66, 0x31, 0x31, 0x34, 0x34, 0x36, 0x39, 0x36, 0x66, 0x61, 0x63, 0x66, 0x61, 0x36, 0x37, 0x32, 0x33, 0x64, 0x64, 0x38, 0x32, 0x66, 0x39, 0x36, 0x33, 0x61, 0x30, 0x35, 0x61, 0x32, 0x38, 0x32, 0x61, 0x65, 0x62, 0x30, 0x65, 0x36, 0x32, 0x38, 0x37, 0x32, 0x63, 0x38, 0x63, 0x37, 0x64, 0x30, 0x30, 0x31, 0x62, 0x39, 0x36, 0x36, 0x62, 0x30, 0x62, 0x30, 0x63, 0x66, 0x39, 0x35, 0x39, 0x34, 0x39, 0x63, 0x33, 0x38, 0x30, 0x39, 0x36, 0x64, 0x37, 0x63, 0x37, 0x64, 0x31, 0x62, 0x36, 0x62, 0x39, 0x64, 0x63, 0x33, 0x31, 0x32, 0x39, 0x31, 0x39, 0x36, 0x33, 0x61, 0x30, 0x62, 0x32, 0x33, 0x34, 0x35, 0x30, 0x39, 0x65, 0x39, 0x61, 0x39, 0x37, 0x32, 0x63, 0x37, 0x34, 0x61, 0x32, 0x65, 0x31, 0x63, 0x66, 0x61, 0x36, 0x62, 0x31, 0x63, 0x33, 0x64, 0x64, 0x30, 0x39, 0x65, 0x61, 0x30, 0x61, 0x36, 0x31, 0x64, 0x65, 0x64, 0x31, 0x63, 0x39, 0x63, 0x33, 0x32, 0x38, 0x36, 0x31, 0x31, 0x30, 0x61, 0x35, 0x61, 0x35, 0x36, 0x39, 0x64, 0x37, 0x62, 0x32, 0x65, 0x36, 0x33, 0x36, 0x63, 0x30, 0x62, 0x35, 0x62, 0x62, 0x62, 0x34, 0x62, 0x34, 0x31, 0x63, 0x63, 0x65, 0x36, 0x32, 0x62, 0x39, 0x33, 0x61, 0x61, 0x36, 0x37, 0x30, 0x33, 0x34, 0x65, 0x35, 0x39, 0x34, 0x34, 0x33, 0x64, 0x35, 0x37, 0x30, 0x64, 0x65, 0x38, 0x61, 0x35, 0x63, 0x63, 0x37, 0x33, 0x33, 0x61, 0x61, 0x35, 0x34, 0x37, 0x34, 0x61, 0x32, 0x31, 0x30, 0x62, 0x34, 0x36, 0x34, 0x63, 0x34, 0x35, 0x31, 0x35, 0x36, 0x34, 0x38, 0x38, 0x61, 0x33, 0x32, 0x39, 0x37, 0x32, 0x62, 0x39, 0x36, 0x32, 0x37, 0x35, 0x62, 0x62, 0x37, 0x62, 0x63, 0x35, 0x30, 0x61, 0x62, 0x62, 0x31, 0x31, 0x36, 0x33, 0x38, 0x32, 0x37, 0x65, 0x61, 0x65, 0x31, 0x39, 0x62, 0x34, 0x61, 0x65, 0x31, 0x36, 0x61, 0x33, 0x61, 0x62, 0x34, 0x33, 0x33, 0x34, 0x34, 0x36, 0x64, 0x30, 0x35, 0x65, 0x32, 0x30, 0x66, 0x36, 0x62, 0x32, 0x31, 0x66, 0x65, 0x30, 0x38, 0x64, 0x64, 0x33, 0x37, 0x32, 0x61, 0x63, 0x64, 0x66, 0x37, 0x34, 0x38, 0x38, 0x30, 0x61, 0x64, 0x66, 0x65, 0x38, 0x65, 0x38, 0x37, 0x34, 0x35, 0x66, 0x34, 0x62, 0x34, 0x36, 0x64, 0x61, 0x31, 0x36, 0x65, 0x62, 0x30, 0x39, 0x36, 0x34, 0x64, 0x38, 0x31, 0x62, 0x62, 0x66, 0x35, 0x35, 0x63, 0x35, 0x38, 0x32, 0x37, 0x64, 0x36, 0x62, 0x61, 0x39, 0x34, 0x38, 0x36, 0x62, 0x34, 0x35, 0x33, 0x63, 0x39, 0x64, 0x37, 0x32, 0x39, 0x33, 0x63, 0x66, 0x35, 0x64, 0x66, 0x64, 0x64, 0x36, 0x31, 0x64, 0x30, 0x32, 0x35, 0x39, 0x39, 0x31, 0x32, 0x66, 0x37, 0x32, 0x31, 0x33, 0x33, 0x65, 0x35, 0x30, 0x39, 0x39, 0x66, 0x39, 0x61, 0x64, 0x37, 0x63, 0x62, 0x39, 0x35, 0x61, 0x64, 0x61, 0x65, 0x30, 0x30, 0x37, 0x63, 0x39, 0x34, 0x33, 0x32, 0x61, 0x36, 0x64, 0x33, 0x32, 0x38, 0x39, 0x30, 0x35, 0x66, 0x31, 0x37, 0x32, 0x36, 0x35, 0x36, 0x39, 0x38, 0x32, 0x33, 0x64, 0x63, 0x65, 0x65, 0x35, 0x62, 0x39, 0x63, 0x32, 0x30, 0x34, 0x32, 0x66, 0x37, 0x39, 0x33, 0x37, 0x30, 0x64, 0x30, 0x38, 0x61, 0x33, 0x65, 0x31, 0x32, 0x30, 0x63, 0x30, 0x32, 0x30, 0x63, 0x32, 0x64, 0x38, 0x66, 0x34, 0x63, 0x30, 0x33, 0x64, 0x63, 0x35, 0x62, 0x32, 0x39, 0x30, 0x63, 0x31, 0x61, 0x37, 0x66, 0x39, 0x63, 0x63, 0x37, 0x32, 0x32, 0x62, 0x38, 0x63, 0x33, 0x37, 0x39, 0x64, 0x37, 0x39, 0x38, 0x65, 0x36, 0x65, 0x38, 0x64, 0x64, 0x61, 0x36, 0x39, 0x33, 0x62, 0x34, 0x34, 0x66, 0x66, 0x37, 0x34, 0x65, 0x34, 0x66, 0x34, 0x66, 0x66, 0x63, 0x35, 0x33, 0x33, 0x64, 0x35, 0x33, 0x30, 0x63, 0x34, 0x64, 0x65, 0x66, 0x66, 0x62, 0x33, 0x66, 0x34, 0x62, 0x35, 0x37, 0x33, 0x36, 0x61, 0x38, 0x62, 0x33, 0x62, 0x34, 0x61, 0x31, 0x63, 0x64, 0x31, 0x62, 0x34, 0x36, 0x39, 0x62, 0x34, 0x35, 0x35, 0x37, 0x30, 0x61, 0x30, 0x34, 0x61, 0x61, 0x39, 0x37, 0x65, 0x63, 0x63, 0x34, 0x34, 0x37, 0x34, 0x35, 0x63, 0x37, 0x61, 0x30, 0x66, 0x34, 0x36, 0x65, 0x64, 0x38, 0x65, 0x38, 0x38, 0x36, 0x39, 0x61, 0x64, 0x39, 0x65, 0x34, 0x33, 0x38, 0x34, 0x38, 0x30, 0x34, 0x63, 0x34, 0x62, 0x36, 0x66, 0x33, 0x30, 0x36, 0x65, 0x38, 0x34, 0x38, 0x32, 0x62, 0x39, 0x39, 0x30, 0x37, 0x36, 0x61, 0x35, 0x33, 0x33, 0x32, 0x63, 0x36, 0x37, 0x34, 0x63, 0x33, 0x31, 0x30, 0x61, 0x64, 0x34, 0x32, 0x33, 0x38, 0x63, 0x39, 0x66, 0x32, 0x32, 0x61, 0x66, 0x62, 0x39, 0x35, 0x66, 0x37, 0x34, 0x31, 0x64, 0x66, 0x64, 0x30, 0x66, 0x39, 0x38, 0x62, 0x65, 0x37, 0x62, 0x65, 0x30, 0x62, 0x38, 0x36, 0x37, 0x35, 0x34, 0x37, 0x32, 0x63, 0x64, 0x66, 0x34, 0x31, 0x31, 0x62, 0x61, 0x66, 0x30, 0x31, 0x33, 0x64, 0x30, 0x61, 0x30, 0x31, 0x39, 0x39, 0x30, 0x63, 0x36, 0x31, 0x64, 0x32, 0x66, 0x33, 0x35, 0x30, 0x39, 0x39, 0x31, 0x37, 0x34, 0x30, 0x63, 0x66, 0x63, 0x34, 0x30, 0x33, 0x37, 0x33, 0x31, 0x32, 0x65, 0x62, 0x33, 0x39, 0x66, 0x66, 0x31, 0x31, 0x32, 0x65, 0x38, 0x66, 0x34, 0x32, 0x33, 0x64, 0x30, 0x37, 0x32, 0x31, 0x37, 0x65, 0x38, 0x36, 0x32, 0x36, 0x37, 0x62, 0x33, 0x39, 0x37, 0x38, 0x62, 0x38, 0x62, 0x62, 0x62, 0x32, 0x35, 0x36, 0x36, 0x30, 0x33, 0x36, 0x36, 0x30, 0x38, 0x39, 0x31, 0x31, 0x30, 0x61, 0x33, 0x37, 0x65, 0x38, 0x39, 0x38, 0x34, 0x31, 0x30, 0x63, 0x65, 0x65, 0x62, 0x63, 0x35, 0x37, 0x66, 0x61, 0x30, 0x61, 0x61, 0x36, 0x32, 0x30, 0x65, 0x30, 0x63, 0x34, 0x39, 0x37, 0x32, 0x62, 0x66, 0x31, 0x61, 0x62, 0x35, 0x33, 0x35, 0x31, 0x66, 0x34, 0x63, 0x32, 0x32, 0x38, 0x63, 0x64, 0x66, 0x63, 0x32, 0x31, 0x30, 0x63, 0x39, 0x34, 0x37, 0x35, 0x34, 0x62, 0x34, 0x32, 0x34, 0x66, 0x31, 0x39, 0x32, 0x38, 0x30, 0x37, 0x31, 0x31, 0x37, 0x62, 0x61, 0x34, 0x33, 0x35, 0x30, 0x32, 0x39, 0x61, 0x36, 0x34, 0x66, 0x66, 0x36, 0x62, 0x39, 0x31, 0x30, 0x66, 0x63, 0x37, 0x32, 0x65, 0x36, 0x65, 0x38, 0x65, 0x61, 0x65, 0x31, 0x64, 0x66, 0x39, 0x65, 0x61, 0x65, 0x66, 0x37, 0x64, 0x61, 0x37, 0x37, 0x61, 0x34, 0x66, 0x62, 0x34, 0x31, 0x64, 0x63, 0x39, 0x66, 0x31, 0x63, 0x37, 0x63, 0x63, 0x64, 0x37, 0x62, 0x32, 0x37, 0x32, 0x37, 0x35, 0x65, 0x39, 0x62, 0x33, 0x35, 0x33, 0x38, 0x34, 0x34, 0x62, 0x36, 0x63, 0x37, 0x33, 0x37, 0x31, 0x32, 0x30, 0x34, 0x31, 0x63, 0x63, 0x30, 0x39, 0x32, 0x38, 0x38, 0x33, 0x61, 0x30, 0x32, 0x66, 0x37, 0x62, 0x65, 0x65, 0x62, 0x63, 0x34, 0x35, 0x64, 0x37, 0x62, 0x36, 0x33, 0x35, 0x38, 0x35, 0x34, 0x32, 0x36, 0x35, 0x64, 0x38, 0x62, 0x30, 0x30, 0x32, 0x65, 0x37, 0x37, 0x32, 0x33, 0x66, 0x30, 0x66, 0x31, 0x32, 0x65, 0x39, 0x36, 0x63, 0x65, 0x65, 0x37, 0x37, 0x66, 0x65, 0x64, 0x63, 0x34, 0x36, 0x33, 0x32, 0x66, 0x34, 0x39, 0x63, 0x34, 0x66, 0x61, 0x33, 0x63, 0x37, 0x63, 0x31, 0x65, 0x64, 0x38, 0x63, 0x30, 0x61, 0x37, 0x64, 0x66, 0x38, 0x66, 0x62, 0x66, 0x30, 0x37, 0x37, 0x32, 0x30, 0x36, 0x32, 0x37, 0x65, 0x38, 0x61, 0x30, 0x66, 0x39, 0x39, 0x66, 0x62, 0x65, 0x34, 0x32, 0x35, 0x62, 0x33, 0x62, 0x62, 0x30, 0x61, 0x39, 0x36, 0x31, 0x63, 0x38, 0x39, 0x64, 0x37, 0x32, 0x32, 0x33, 0x37, 0x32, 0x66, 0x33, 0x38, 0x35, 0x61, 0x34, 0x30, 0x32, 0x37, 0x66, 0x65, 0x32, 0x34, 0x32, 0x38, 0x36, 0x65, 0x34, 0x62, 0x66, 0x61, 0x65, 0x33, 0x31, 0x64, 0x62, 0x66, 0x39, 0x31, 0x35, 0x31, 0x30, 0x63, 0x33, 0x31, 0x33, 0x38, 0x64, 0x30, 0x33, 0x36, 0x64, 0x32, 0x39, 0x31, 0x66, 0x35, 0x63, 0x34, 0x30, 0x61, 0x38, 0x36, 0x31, 0x64, 0x31, 0x64, 0x31, 0x65, 0x65, 0x34, 0x37, 0x33, 0x32, 0x30, 0x63, 0x36, 0x61, 0x32, 0x30, 0x38, 0x31, 0x32, 0x32, 0x63, 0x39, 0x31, 0x65, 0x32, 0x64, 0x38, 0x35, 0x65, 0x33, 0x32, 0x64, 0x61, 0x37, 0x37, 0x35, 0x39, 0x37, 0x32, 0x30, 0x32, 0x31, 0x33, 0x31, 0x63, 0x62, 0x33, 0x63, 0x30, 0x63, 0x32, 0x31, 0x38, 0x63, 0x36, 0x65, 0x61, 0x37, 0x61, 0x63, 0x66, 0x61, 0x32, 0x37, 0x38, 0x30, 0x64, 0x39, 0x39, 0x34, 0x37, 0x65, 0x35, 0x65, 0x37, 0x35, 0x38, 0x30, 0x36, 0x30, 0x65, 0x62, 0x34, 0x65, 0x36, 0x62, 0x65, 0x33, 0x66, 0x34, 0x39, 0x36, 0x61, 0x64, 0x30, 0x62, 0x35, 0x66, 0x64, 0x66, 0x38, 0x64, 0x36, 0x35, 0x37, 0x61, 0x32, 0x31, 0x63, 0x61, 0x61, 0x62, 0x65, 0x65, 0x62, 0x38, 0x34, 0x37, 0x34, 0x33, 0x30, 0x33, 0x36, 0x66, 0x61, 0x38, 0x65, 0x36, 0x66, 0x65, 0x34, 0x65, 0x37, 0x61, 0x31, 0x66, 0x35, 0x30, 0x32, 0x64, 0x38, 0x36, 0x31, 0x38, 0x66, 0x36, 0x34, 0x61, 0x61, 0x34, 0x37, 0x33, 0x32, 0x37, 0x63, 0x63, 0x38, 0x62, 0x38, 0x38, 0x62, 0x62, 0x35, 0x39, 0x38, 0x31, 0x35, 0x37, 0x61, 0x36, 0x31, 0x61, 0x34, 0x37, 0x39, 0x31, 0x66, 0x36, 0x39, 0x34, 0x31, 0x65, 0x38, 0x63, 0x37, 0x36, 0x61, 0x30, 0x38, 0x31, 0x61, 0x37, 0x61, 0x38, 0x39, 0x35, 0x31, 0x36, 0x35, 0x61, 0x37, 0x32, 0x37, 0x61, 0x33, 0x32, 0x65, 0x37, 0x30, 0x37, 0x32, 0x36, 0x37, 0x33, 0x31, 0x36, 0x32, 0x30, 0x64, 0x35, 0x32, 0x64, 0x31, 0x65, 0x39, 0x31, 0x66, 0x61, 0x64, 0x30, 0x62, 0x32, 0x37, 0x63, 0x35, 0x34, 0x31, 0x66, 0x37, 0x61, 0x34, 0x33, 0x34, 0x65, 0x34, 0x63, 0x66, 0x66, 0x61, 0x37, 0x38, 0x33, 0x64, 0x34, 0x62, 0x37, 0x38, 0x65, 0x30, 0x36, 0x33, 0x61, 0x63, 0x61, 0x37, 0x32, 0x38, 0x35, 0x64, 0x66, 0x38, 0x38, 0x39, 0x31, 0x62, 0x34, 0x36, 0x35, 0x32, 0x33, 0x32, 0x66, 0x33, 0x39, 0x36, 0x65, 0x37, 0x63, 0x35, 0x35, 0x62, 0x37, 0x34, 0x65, 0x35, 0x64, 0x36, 0x35, 0x30, 0x65, 0x32, 0x66, 0x65, 0x66, 0x36, 0x62, 0x62, 0x63, 0x38, 0x36, 0x61, 0x34, 0x65, 0x65, 0x63, 0x32, 0x33, 0x39, 0x30, 0x64, 0x66, 0x65, 0x62, 0x39, 0x35, 0x62, 0x66, 0x32, 0x37, 0x32, 0x62, 0x36, 0x61, 0x39, 0x36, 0x35, 0x66, 0x62, 0x34, 0x64, 0x34, 0x39, 0x63, 0x63, 0x34, 0x63, 0x31, 0x65, 0x63, 0x30, 0x63, 0x61, 0x34, 0x30, 0x34, 0x32, 0x39, 0x61, 0x61, 0x32, 0x39, 0x31, 0x37, 0x63, 0x32, 0x61, 0x30, 0x32, 0x62, 0x39, 0x32, 0x36, 0x62, 0x62, 0x35, 0x39, 0x65, 0x65, 0x62, 0x32, 0x32, 0x31, 0x33, 0x31, 0x31, 0x34, 0x33, 0x34, 0x63, 0x35, 0x61, 0x31, 0x34, 0x38, 0x34, 0x63, 0x30, 0x35, 0x63, 0x65, 0x35, 0x66, 0x33, 0x30, 0x36, 0x64, 0x31, 0x35, 0x31, 0x31, 0x38, 0x65, 0x66, 0x37, 0x63, 0x39, 0x38, 0x32, 0x38, 0x38, 0x35, 0x65, 0x63, 0x66, 0x61, 0x33, 0x38, 0x35, 0x61, 0x32, 0x61, 0x31, 0x33, 0x63, 0x37, 0x31, 0x65, 0x37, 0x64, 0x35, 0x37, 0x38, 0x66, 0x32, 0x32, 0x63, 0x34, 0x36, 0x37, 0x35, 0x64, 0x35, 0x65, 0x37, 0x39, 0x37, 0x37, 0x32, 0x39, 0x33, 0x31, 0x65, 0x66, 0x37, 0x37, 0x31, 0x30, 0x39, 0x36, 0x65, 0x66, 0x32, 0x33, 0x65, 0x30, 0x32, 0x38, 0x36, 0x30, 0x66, 0x38, 0x32, 0x30, 0x36, 0x65, 0x61, 0x35, 0x32, 0x66, 0x65, 0x64, 0x36, 0x66, 0x65, 0x32, 0x36, 0x39, 0x36, 0x35, 0x61, 0x33, 0x64, 0x62, 0x31, 0x34, 0x33, 0x33, 0x39, 0x65, 0x62, 0x36, 0x64, 0x39, 0x34, 0x65, 0x32, 0x33, 0x33, 0x64, 0x32, 0x37, 0x32, 0x35, 0x34, 0x64, 0x37, 0x31, 0x31, 0x33, 0x36, 0x33, 0x30, 0x62, 0x36, 0x37, 0x36, 0x66, 0x61, 0x66, 0x38, 0x30, 0x62, 0x35, 0x61, 0x66, 0x38, 0x34, 0x66, 0x64, 0x64, 0x36, 0x62, 0x61, 0x34, 0x35, 0x62, 0x31, 0x34, 0x36, 0x39, 0x39, 0x64, 0x34, 0x33, 0x61, 0x61, 0x38, 0x30, 0x39, 0x32, 0x65, 0x36, 0x35, 0x33, 0x39, 0x65, 0x36, 0x39, 0x32, 0x34, 0x61, 0x33, 0x61, 0x61, 0x37, 0x32, 0x37, 0x66, 0x63, 0x30, 0x30, 0x31, 0x35, 0x38, 0x65, 0x65, 0x37, 0x33, 0x62, 0x38, 0x61, 0x30, 0x34, 0x30, 0x61, 0x65, 0x61, 0x65, 0x32, 0x63, 0x66, 0x38, 0x65, 0x62, 0x62, 0x37, 0x64, 0x65, 0x66, 0x39, 0x33, 0x34, 0x64, 0x62, 0x38, 0x62, 0x34, 0x38, 0x66, 0x38, 0x38, 0x38, 0x37, 0x33, 0x64, 0x33, 0x32, 0x37, 0x62, 0x61, 0x63, 0x61, 0x36, 0x62, 0x35, 0x33, 0x64, 0x66, 0x34, 0x39, 0x66, 0x30, 0x61, 0x31, 0x34, 0x39, 0x39, 0x66, 0x36, 0x37, 0x30, 0x36, 0x63, 0x62, 0x64, 0x61, 0x30, 0x38, 0x38, 0x34, 0x38, 0x66, 0x66, 0x62, 0x39, 0x64, 0x32, 0x36, 0x33, 0x39, 0x65, 0x38, 0x30, 0x32, 0x63, 0x35, 0x32, 0x35, 0x32, 0x63, 0x64, 0x34, 0x64, 0x64, 0x34, 0x39, 0x62, 0x64, 0x62, 0x66, 0x38, 0x30, 0x37, 0x39, 0x38, 0x65, 0x65, 0x38, 0x30, 0x32, 0x61, 0x62, 0x32, 0x36, 0x32, 0x36, 0x65, 0x35, 0x36, 0x32, 0x39, 0x65, 0x62, 0x32, 0x66, 0x64, 0x33, 0x36, 0x34, 0x36, 0x30, 0x34, 0x33, 0x35, 0x38, 0x62, 0x38, 0x64, 0x33, 0x38, 0x66, 0x30, 0x39, 0x38, 0x33, 0x61, 0x30, 0x34, 0x61, 0x30, 0x63, 0x66, 0x35, 0x30, 0x31, 0x31, 0x65, 0x66, 0x30, 0x33, 0x37, 0x65, 0x32, 0x34, 0x65, 0x37, 0x30, 0x63, 0x37, 0x64, 0x66, 0x64, 0x35, 0x35, 0x32, 0x31, 0x37, 0x32, 0x33, 0x32, 0x65, 0x30, 0x38, 0x64, 0x61, 0x61, 0x66, 0x62, 0x64, 0x37, 0x66, 0x39, 0x63, 0x37, 0x61, 0x30, 0x36, 0x61, 0x66, 0x39, 0x33, 0x36, 0x39, 0x66, 0x32, 0x63, 0x31, 0x30, 0x36, 0x61, 0x30, 0x30, 0x38, 0x65, 0x63, 0x38, 0x36, 0x64, 0x37, 0x31, 0x32, 0x30, 0x33, 0x62, 0x65, 0x35, 0x30, 0x35, 0x39, 0x65, 0x63, 0x30, 0x64, 0x39, 0x33, 0x37, 0x33, 0x39, 0x36, 0x36, 0x36, 0x39, 0x39, 0x65, 0x63, 0x37, 0x34, 0x38, 0x36, 0x37, 0x38, 0x62, 0x39, 0x62, 0x37, 0x36, 0x38, 0x64, 0x63, 0x34, 0x65, 0x61, 0x61, 0x37, 0x35, 0x37, 0x61, 0x38, 0x66, 0x37, 0x66, 0x32, 0x66, 0x33, 0x31, 0x66, 0x62, 0x62, 0x63, 0x38, 0x32, 0x38, 0x64, 0x64, 0x62, 0x64, 0x34, 0x30, 0x34, 0x34, 0x64, 0x36, 0x66, 0x66, 0x33, 0x34, 0x38, 0x33, 0x34, 0x37, 0x61, 0x61, 0x30, 0x39, 0x34, 0x32, 0x64, 0x31, 0x34, 0x31, 0x37, 0x34, 0x30, 0x30, 0x31, 0x36, 0x36, 0x66, 0x61, 0x65, 0x34, 0x35, 0x35, 0x35, 0x33, 0x38, 0x37, 0x32, 0x33, 0x35, 0x37, 0x62, 0x39, 0x62, 0x35, 0x38, 0x65, 0x39, 0x32, 0x31, 0x65, 0x62, 0x32, 0x36, 0x38, 0x37, 0x31, 0x30, 0x35, 0x39, 0x37, 0x34, 0x33, 0x33, 0x61, 0x30, 0x32, 0x32, 0x38, 0x30, 0x61, 0x35, 0x36, 0x32, 0x33, 0x64, 0x63, 0x61, 0x37, 0x32, 0x33, 0x35, 0x64, 0x64, 0x34, 0x39, 0x62, 0x39, 0x66, 0x65, 0x36, 0x65, 0x61, 0x30, 0x63, 0x64, 0x38, 0x36, 0x39, 0x39, 0x31, 0x38, 0x66, 0x36, 0x36, 0x64, 0x34, 0x64, 0x66, 0x39, 0x33, 0x62, 0x33, 0x61, 0x39, 0x34, 0x64, 0x62, 0x61, 0x61, 0x63, 0x30, 0x30, 0x61, 0x62, 0x62, 0x65, 0x66, 0x34, 0x32, 0x64, 0x30, 0x64, 0x33, 0x61, 0x33, 0x37, 0x37, 0x66, 0x65, 0x30, 0x34, 0x37, 0x32, 0x35, 0x36, 0x63, 0x65, 0x61, 0x66, 0x64, 0x64, 0x38, 0x65, 0x63, 0x36, 0x37, 0x61, 0x37, 0x37, 0x62, 0x36, 0x64, 0x66, 0x37, 0x39, 0x62, 0x37, 0x30, 0x61, 0x39, 0x33, 0x34, 0x35, 0x38, 0x33, 0x63, 0x38, 0x66, 0x32, 0x64, 0x38, 0x37, 0x63, 0x35, 0x34, 0x66, 0x33, 0x35, 0x30, 0x39, 0x33, 0x31, 0x64, 0x61, 0x31, 0x38, 0x63, 0x32, 0x39, 0x62, 0x65, 0x33, 0x38, 0x37, 0x39, 0x37, 0x32, 0x39, 0x38, 0x37, 0x37, 0x34, 0x64, 0x32, 0x32, 0x66, 0x38, 0x63, 0x36, 0x64, 0x31, 0x30, 0x31, 0x35, 0x34, 0x36, 0x64, 0x30, 0x30, 0x61, 0x37, 0x30, 0x61, 0x39, 0x62, 0x65, 0x62, 0x39, 0x38, 0x65, 0x39, 0x30, 0x64, 0x63, 0x30, 0x62, 0x31, 0x39, 0x61, 0x63, 0x37, 0x32, 0x32, 0x65, 0x61, 0x33, 0x65, 0x61, 0x65, 0x35, 0x33, 0x35, 0x66, 0x37, 0x63, 0x36, 0x35, 0x37, 0x33, 0x31, 0x63, 0x62, 0x61, 0x63, 0x63, 0x66, 0x37, 0x66, 0x31, 0x31, 0x36, 0x36, 0x32, 0x34, 0x32, 0x31, 0x62, 0x34, 0x39, 0x33, 0x31, 0x32, 0x63, 0x39, 0x38, 0x35, 0x38, 0x65, 0x64, 0x32, 0x66, 0x66, 0x63, 0x61, 0x66, 0x66, 0x30, 0x30, 0x65, 0x61, 0x32, 0x61, 0x34, 0x63, 0x65, 0x65, 0x66, 0x32, 0x30, 0x65, 0x38, 0x38, 0x65, 0x36, 0x33, 0x31, 0x36, 0x63, 0x35, 0x64, 0x34, 0x31, 0x38, 0x35, 0x31, 0x32, 0x32, 0x36, 0x64, 0x35, 0x37, 0x35, 0x66, 0x37, 0x61, 0x33, 0x63, 0x64, 0x63, 0x39, 0x32, 0x63, 0x36, 0x31, 0x32, 0x64, 0x35, 0x34, 0x64, 0x66, 0x32, 0x37, 0x30, 0x30, 0x37, 0x34, 0x30, 0x33, 0x62, 0x62, 0x33, 0x66, 0x65, 0x36, 0x38, 0x35, 0x65, 0x30, 0x64, 0x37, 0x30, 0x61, 0x66, 0x65, 0x32, 0x61, 0x30, 0x39, 0x35, 0x30, 0x34, 0x30, 0x33, 0x33, 0x66, 0x30, 0x36, 0x37, 0x30, 0x39, 0x62, 0x31, 0x35, 0x63, 0x30, 0x62, 0x62, 0x66, 0x39, 0x36, 0x38, 0x30, 0x36, 0x35, 0x61, 0x64, 0x36, 0x35, 0x33, 0x35, 0x31, 0x30, 0x36, 0x30, 0x32, 0x32, 0x33, 0x66, 0x31, 0x30, 0x63, 0x63, 0x61, 0x37, 0x33, 0x38, 0x34, 0x62, 0x61, 0x33, 0x64, 0x61, 0x32, 0x38, 0x39, 0x36, 0x64, 0x30, 0x31, 0x32, 0x61, 0x61, 0x38, 0x61, 0x65, 0x37, 0x39, 0x39, 0x64, 0x31, 0x36, 0x36, 0x66, 0x34, 0x66, 0x31, 0x66, 0x30, 0x38, 0x30, 0x30, 0x64, 0x32, 0x62, 0x32, 0x34, 0x34, 0x35, 0x65, 0x66, 0x31, 0x61, 0x38, 0x61, 0x37, 0x31, 0x63, 0x62, 0x63, 0x34, 0x31, 0x35, 0x37, 0x35, 0x64, 0x33, 0x39, 0x63, 0x32, 0x32, 0x62, 0x38, 0x63, 0x36, 0x33, 0x35, 0x63, 0x37, 0x30, 0x36, 0x65, 0x37, 0x39, 0x31, 0x31, 0x34, 0x39, 0x38, 0x64, 0x63, 0x63, 0x66, 0x36, 0x65, 0x36, 0x37, 0x32, 0x33, 0x33, 0x38, 0x33, 0x61, 0x38, 0x65, 0x36, 0x31, 0x30, 0x62, 0x36, 0x64, 0x34, 0x62, 0x35, 0x30, 0x30, 0x39, 0x65, 0x63, 0x34, 0x65, 0x37, 0x65, 0x35, 0x39, 0x64, 0x63, 0x65, 0x38, 0x37, 0x38, 0x31, 0x36, 0x62, 0x37, 0x61, 0x31, 0x35, 0x65, 0x39, 0x38, 0x64, 0x66, 0x36, 0x31, 0x31, 0x30, 0x39, 0x37, 0x37, 0x66, 0x33, 0x32, 0x61, 0x38, 0x31, 0x66, 0x36, 0x33, 0x33, 0x37, 0x32, 0x37, 0x33, 0x36, 0x39, 0x65, 0x61, 0x36, 0x30, 0x35, 0x32, 0x31, 0x62, 0x64, 0x31, 0x64, 0x36, 0x39, 0x66, 0x62, 0x63, 0x39, 0x61, 0x37, 0x30, 0x64, 0x63, 0x62, 0x63, 0x63, 0x36, 0x61, 0x32, 0x62, 0x39, 0x31, 0x39, 0x62, 0x35, 0x34, 0x30, 0x34, 0x30, 0x37, 0x65, 0x63, 0x38, 0x66, 0x64, 0x34, 0x38, 0x61, 0x66, 0x61, 0x36, 0x33, 0x35, 0x66, 0x33, 0x65, 0x36, 0x63, 0x30, 0x31, 0x34, 0x30, 0x39, 0x37, 0x36, 0x30, 0x66, 0x36, 0x64, 0x34, 0x63, 0x66, 0x35, 0x61, 0x66, 0x38, 0x32, 0x36, 0x36, 0x62, 0x33, 0x63, 0x34, 0x63, 0x31, 0x32, 0x63, 0x33, 0x35, 0x39, 0x62, 0x62, 0x32, 0x66, 0x64, 0x35, 0x35, 0x66, 0x62, 0x65, 0x36, 0x31, 0x32, 0x32, 0x39, 0x62, 0x32, 0x34, 0x63, 0x36, 0x62, 0x34, 0x39, 0x38, 0x35, 0x37, 0x37, 0x34, 0x31, 0x30, 0x62, 0x39, 0x33, 0x30, 0x35, 0x34, 0x65, 0x31, 0x31, 0x63, 0x34, 0x63, 0x35, 0x66, 0x32, 0x61, 0x39, 0x39, 0x66, 0x66, 0x34, 0x38, 0x32, 0x65, 0x63, 0x35, 0x64, 0x38, 0x64, 0x31, 0x31, 0x36, 0x34, 0x65, 0x39, 0x61, 0x38, 0x33, 0x32, 0x63, 0x37, 0x30, 0x39, 0x33, 0x33, 0x39, 0x32, 0x37, 0x32, 0x37, 0x32, 0x30, 0x66, 0x30, 0x35, 0x65, 0x36, 0x38, 0x37, 0x62, 0x63, 0x30, 0x30, 0x64, 0x33, 0x62, 0x66, 0x37, 0x32, 0x35, 0x33, 0x38, 0x31, 0x64, 0x62, 0x64, 0x34, 0x33, 0x64, 0x38, 0x39, 0x61, 0x64, 0x38, 0x34, 0x38, 0x35, 0x36, 0x66, 0x65, 0x66, 0x32, 0x34, 0x32, 0x36, 0x66, 0x36, 0x64, 0x38, 0x37, 0x37, 0x39, 0x30, 0x37, 0x31, 0x33, 0x62, 0x39, 0x30, 0x31, 0x38, 0x34, 0x61, 0x30, 0x31, 0x66, 0x32, 0x62, 0x65, 0x33, 0x37, 0x31, 0x30, 0x37, 0x63, 0x36, 0x65, 0x39, 0x34, 0x64, 0x38, 0x33, 0x30, 0x38, 0x33, 0x39, 0x64, 0x39, 0x33, 0x66, 0x66, 0x61, 0x32, 0x61, 0x61, 0x64, 0x36, 0x61, 0x64, 0x31, 0x62, 0x34, 0x63, 0x36, 0x38, 0x37, 0x65, 0x63, 0x61, 0x32, 0x31, 0x39, 0x39, 0x39, 0x36, 0x35, 0x32, 0x65, 0x34, 0x34, 0x34, 0x39, 0x34, 0x61, 0x34, 0x66, 0x36, 0x63, 0x33, 0x37, 0x35, 0x37, 0x61, 0x35, 0x35, 0x65, 0x64, 0x32, 0x62, 0x33, 0x66, 0x35, 0x64, 0x36, 0x65, 0x31, 0x38, 0x33, 0x64, 0x33, 0x35, 0x64, 0x30, 0x66, 0x39, 0x38, 0x33, 0x33, 0x64, 0x66, 0x62, 0x32, 0x32, 0x61, 0x37, 0x62, 0x39, 0x36, 0x36, 0x32, 0x32, 0x33, 0x36, 0x64, 0x36, 0x62, 0x65, 0x36, 0x39, 0x38, 0x61, 0x31, 0x65, 0x65, 0x34, 0x36, 0x35, 0x36, 0x66, 0x61, 0x31, 0x30, 0x64, 0x33, 0x37, 0x32, 0x65, 0x36, 0x31, 0x32, 0x31, 0x30, 0x38, 0x35, 0x35, 0x61, 0x36, 0x34, 0x64, 0x33, 0x35, 0x36, 0x65, 0x34, 0x62, 0x61, 0x63, 0x34, 0x38, 0x36, 0x32, 0x30, 0x66, 0x62, 0x31, 0x34, 0x66, 0x31, 0x63, 0x63, 0x63, 0x30, 0x38, 0x65, 0x65, 0x65, 0x31, 0x64, 0x64, 0x36, 0x35, 0x64, 0x30, 0x30, 0x64, 0x32, 0x32, 0x34, 0x30, 0x61, 0x62, 0x34, 0x31, 0x30, 0x36, 0x62, 0x64, 0x39, 0x62, 0x34, 0x39, 0x62, 0x37, 0x33, 0x66, 0x33, 0x34, 0x30, 0x64, 0x66, 0x36, 0x31, 0x63, 0x37, 0x32, 0x33, 0x35, 0x37, 0x33, 0x38, 0x62, 0x62, 0x39, 0x37, 0x64, 0x32, 0x35, 0x34, 0x63, 0x64, 0x34, 0x66, 0x31, 0x34, 0x39, 0x62, 0x61, 0x64, 0x33, 0x63, 0x33, 0x61, 0x61, 0x35, 0x63, 0x66, 0x66, 0x37, 0x38, 0x61, 0x62, 0x63, 0x34, 0x30, 0x66, 0x36, 0x62, 0x38, 0x66, 0x62, 0x61, 0x62, 0x66, 0x34, 0x65, 0x62, 0x61, 0x33, 0x32, 0x39, 0x66, 0x39, 0x32, 0x39, 0x63, 0x32, 0x34, 0x37, 0x32, 0x63, 0x31, 0x35, 0x65, 0x37, 0x63, 0x62, 0x62, 0x65, 0x63, 0x62, 0x36, 0x32, 0x65, 0x62, 0x62, 0x63, 0x38, 0x36, 0x64, 0x66, 0x36, 0x33, 0x36, 0x30, 0x39, 0x34, 0x39, 0x36, 0x36, 0x63, 0x66, 0x62, 0x61, 0x34, 0x38, 0x30, 0x39, 0x31, 0x63, 0x65, 0x66, 0x39, 0x32, 0x33, 0x62, 0x66, 0x62, 0x63, 0x38, 0x34, 0x65, 0x38, 0x31, 0x62, 0x37, 0x34, 0x31, 0x61, 0x35, 0x37, 0x66, 0x35, 0x32, 0x39, 0x34, 0x61, 0x62, 0x62, 0x32, 0x36, 0x62, 0x62, 0x31, 0x31, 0x33, 0x36, 0x61, 0x37, 0x39, 0x65, 0x38, 0x33, 0x37, 0x63, 0x65, 0x39, 0x36, 0x33, 0x66, 0x38, 0x36, 0x62, 0x62, 0x64, 0x61, 0x32, 0x34, 0x66, 0x66, 0x62, 0x65, 0x33, 0x38, 0x37, 0x39, 0x64, 0x61, 0x38, 0x30, 0x34, 0x64, 0x61, 0x39, 0x63, 0x66, 0x66, 0x37, 0x31, 0x61, 0x35, 0x31, 0x39, 0x63, 0x64, 0x36, 0x37, 0x32, 0x39, 0x65, 0x31, 0x32, 0x62, 0x32, 0x62, 0x33, 0x38, 0x63, 0x33, 0x66, 0x35, 0x36, 0x39, 0x62, 0x31, 0x33, 0x61, 0x34, 0x65, 0x66, 0x30, 0x35, 0x32, 0x38, 0x32, 0x38, 0x64, 0x66, 0x32, 0x31, 0x64, 0x38, 0x65, 0x64, 0x33, 0x31, 0x33, 0x39, 0x63, 0x32, 0x38, 0x64, 0x35, 0x30, 0x31, 0x65, 0x34, 0x33, 0x62, 0x30, 0x33, 0x62, 0x65, 0x61, 0x36, 0x64, 0x35, 0x62, 0x32, 0x32, 0x37, 0x32, 0x36, 0x38, 0x37, 0x32, 0x31, 0x66, 0x38, 0x65, 0x35, 0x39, 0x38, 0x66, 0x62, 0x62, 0x63, 0x66, 0x65, 0x33, 0x39, 0x34, 0x32, 0x38, 0x65, 0x61, 0x30, 0x33, 0x37, 0x64, 0x63, 0x63, 0x32, 0x39, 0x35, 0x65, 0x62, 0x34, 0x61, 0x36, 0x33, 0x62, 0x37, 0x34, 0x61, 0x65, 0x62, 0x32, 0x38, 0x35, 0x33, 0x38, 0x34, 0x38, 0x38, 0x38, 0x35, 0x36, 0x37, 0x34, 0x32, 0x64, 0x64, 0x30, 0x33, 0x66, 0x66, 0x63, 0x32, 0x32, 0x38, 0x30, 0x64, 0x64, 0x65, 0x65, 0x38, 0x30, 0x64, 0x31, 0x65, 0x35, 0x37, 0x63, 0x30, 0x61, 0x36, 0x30, 0x35, 0x65, 0x33, 0x36, 0x66, 0x33, 0x63, 0x61, 0x34, 0x38, 0x36, 0x36, 0x62, 0x33, 0x61, 0x66, 0x64, 0x36, 0x38, 0x62, 0x65, 0x39, 0x34, 0x35, 0x38, 0x34, 0x66, 0x36, 0x36, 0x38, 0x64, 0x65, 0x62, 0x30, 0x38, 0x37, 0x61, 0x34, 0x62, 0x32, 0x30, 0x64, 0x65, 0x33, 0x37, 0x36, 0x39, 0x64, 0x63, 0x66, 0x39, 0x66, 0x32, 0x63, 0x30, 0x65, 0x66, 0x34, 0x33, 0x38, 0x64, 0x30, 0x31, 0x62, 0x31, 0x65, 0x35, 0x34, 0x35, 0x31, 0x66, 0x35, 0x66, 0x32, 0x33, 0x39, 0x34, 0x37, 0x36, 0x62, 0x61, 0x66, 0x63, 0x66, 0x35, 0x36, 0x65, 0x62, 0x36, 0x34, 0x35, 0x33, 0x34, 0x62, 0x65, 0x32, 0x30, 0x34, 0x61, 0x30, 0x37, 0x36, 0x36, 0x62, 0x36, 0x31, 0x31, 0x38, 0x30, 0x65, 0x31, 0x39, 0x33, 0x35, 0x65, 0x30, 0x30, 0x34, 0x62, 0x33, 0x30, 0x38, 0x30, 0x33, 0x65, 0x39, 0x32, 0x65, 0x37, 0x36, 0x61, 0x63, 0x33, 0x35, 0x38, 0x64, 0x38, 0x63, 0x37, 0x36, 0x66, 0x62, 0x33, 0x62, 0x65, 0x32, 0x38, 0x65, 0x61, 0x36, 0x37, 0x66, 0x62, 0x33, 0x39, 0x64, 0x31, 0x66, 0x65, 0x66, 0x33, 0x34, 0x38, 0x38, 0x36, 0x66, 0x30, 0x65, 0x37, 0x32, 0x38, 0x36, 0x65, 0x36, 0x35, 0x36, 0x34, 0x65, 0x32, 0x37, 0x36, 0x63, 0x34, 0x62, 0x65, 0x35, 0x38, 0x65, 0x37, 0x39, 0x36, 0x61, 0x39, 0x39, 0x30, 0x37, 0x64, 0x63, 0x35, 0x37, 0x61, 0x36, 0x61, 0x62, 0x33, 0x38, 0x63, 0x61, 0x66, 0x63, 0x63, 0x61, 0x39, 0x35, 0x31, 0x65, 0x30, 0x36, 0x37, 0x32, 0x62, 0x39, 0x62, 0x30, 0x33, 0x38, 0x38, 0x62, 0x37, 0x66, 0x34, 0x35, 0x37, 0x32, 0x39, 0x64, 0x64, 0x36, 0x66, 0x31, 0x63, 0x36, 0x38, 0x37, 0x61, 0x32, 0x34, 0x38, 0x36, 0x35, 0x62, 0x64, 0x64, 0x30, 0x38, 0x66, 0x63, 0x65, 0x66, 0x30, 0x38, 0x30, 0x66, 0x30, 0x30, 0x66, 0x31, 0x32, 0x32, 0x32, 0x37, 0x38, 0x63, 0x61, 0x65, 0x38, 0x38, 0x64, 0x33, 0x30, 0x62, 0x33, 0x33, 0x39, 0x31, 0x61, 0x32, 0x38, 0x63, 0x36, 0x63, 0x33, 0x62, 0x66, 0x32, 0x34, 0x37, 0x32, 0x30, 0x65, 0x32, 0x38, 0x36, 0x32, 0x30, 0x30, 0x38, 0x66, 0x38, 0x37, 0x35, 0x38, 0x30, 0x63, 0x33, 0x66, 0x35, 0x30, 0x61, 0x61, 0x39, 0x65, 0x62, 0x64, 0x62, 0x39, 0x35, 0x35, 0x30, 0x31, 0x66, 0x35, 0x62, 0x61, 0x65, 0x64, 0x61, 0x37, 0x34, 0x65, 0x37, 0x66, 0x31, 0x63, 0x64, 0x66, 0x36, 0x65, 0x66, 0x37, 0x36, 0x36, 0x66, 0x65, 0x39, 0x34, 0x65, 0x66, 0x61, 0x32, 0x36, 0x64, 0x37, 0x31, 0x32, 0x39, 0x36, 0x66, 0x33, 0x62, 0x39, 0x31, 0x32, 0x66, 0x35, 0x34, 0x63, 0x38, 0x32, 0x32, 0x37, 0x32, 0x38, 0x36, 0x38, 0x63, 0x38, 0x62, 0x32, 0x38, 0x63, 0x39, 0x39, 0x65, 0x33, 0x66, 0x32, 0x33, 0x32, 0x35, 0x37, 0x39, 0x30, 0x38, 0x66, 0x39, 0x30, 0x32, 0x38, 0x36, 0x66, 0x65, 0x65, 0x35, 0x38, 0x31, 0x62, 0x36, 0x64, 0x38, 0x32, 0x63, 0x61, 0x38, 0x31, 0x34, 0x33, 0x66, 0x31, 0x61, 0x37, 0x66, 0x36, 0x30, 0x38, 0x63, 0x64, 0x36, 0x38, 0x37, 0x34, 0x30, 0x31, 0x36, 0x31, 0x35, 0x35, 0x61, 0x36, 0x38, 0x64, 0x34, 0x37, 0x34, 0x37, 0x61, 0x38, 0x30, 0x37, 0x31, 0x61, 0x63, 0x66, 0x62, 0x34, 0x61, 0x65, 0x65, 0x61, 0x65, 0x38, 0x36, 0x36, 0x37, 0x35, 0x35, 0x64, 0x36, 0x30, 0x64, 0x38, 0x64, 0x30, 0x36, 0x35, 0x32, 0x33, 0x36, 0x37, 0x32, 0x32, 0x65, 0x39, 0x33, 0x31, 0x35, 0x38, 0x39, 0x61, 0x32, 0x35, 0x63, 0x38, 0x36, 0x38, 0x30, 0x31, 0x30, 0x34, 0x38, 0x38, 0x36, 0x64, 0x30, 0x66, 0x33, 0x62, 0x36, 0x63, 0x61, 0x61, 0x61, 0x37, 0x33, 0x32, 0x63, 0x30, 0x64, 0x31, 0x32, 0x64, 0x64, 0x36, 0x65, 0x31, 0x63, 0x30, 0x61, 0x65, 0x62, 0x33, 0x30, 0x63, 0x66, 0x32, 0x63, 0x65, 0x38, 0x36, 0x66, 0x34, 0x65, 0x37, 0x32, 0x61, 0x63, 0x38, 0x33, 0x36, 0x34, 0x31, 0x35, 0x62, 0x38, 0x64, 0x66, 0x30, 0x37, 0x34, 0x63, 0x64, 0x33, 0x33, 0x64, 0x34, 0x37, 0x32, 0x65, 0x36, 0x32, 0x37, 0x36, 0x38, 0x32, 0x36, 0x66, 0x36, 0x34, 0x35, 0x33, 0x32, 0x31, 0x63, 0x33, 0x34, 0x61, 0x61, 0x36, 0x33, 0x39, 0x36, 0x37, 0x37, 0x32, 0x61, 0x35, 0x35, 0x30, 0x64, 0x37, 0x38, 0x36, 0x33, 0x62, 0x33, 0x63, 0x37, 0x32, 0x64, 0x30, 0x37, 0x38, 0x35, 0x64, 0x30, 0x66, 0x32, 0x66, 0x37, 0x64, 0x63, 0x32, 0x32, 0x64, 0x37, 0x30, 0x64, 0x33, 0x39, 0x37, 0x33, 0x32, 0x36, 0x35, 0x38, 0x38, 0x36, 0x38, 0x33, 0x31, 0x38, 0x39, 0x36, 0x35, 0x32, 0x33, 0x61, 0x30, 0x30, 0x66, 0x66, 0x34, 0x63, 0x61, 0x38, 0x34, 0x35, 0x61, 0x64, 0x62, 0x37, 0x33, 0x33, 0x35, 0x32, 0x61, 0x65, 0x30, 0x31, 0x63, 0x32, 0x65, 0x31, 0x35, 0x35, 0x65, 0x35, 0x61, 0x31, 0x39, 0x30, 0x39, 0x66, 0x38, 0x63, 0x33, 0x31, 0x65, 0x36, 0x33, 0x66, 0x34, 0x62, 0x62, 0x31, 0x30, 0x61, 0x33, 0x64, 0x34, 0x38, 0x65, 0x66, 0x65, 0x37, 0x36, 0x37, 0x31, 0x65, 0x61, 0x63, 0x39, 0x38, 0x30, 0x37, 0x65, 0x62, 0x38, 0x36, 0x65, 0x32, 0x66, 0x38, 0x63, 0x64, 0x31, 0x62, 0x61, 0x32, 0x36, 0x62, 0x66, 0x39, 0x30, 0x31, 0x38, 0x34, 0x35, 0x39, 0x34, 0x62, 0x63, 0x61, 0x66, 0x32, 0x32, 0x32, 0x62, 0x63, 0x62, 0x61, 0x37, 0x35, 0x65, 0x37, 0x64, 0x63, 0x34, 0x62, 0x39, 0x32, 0x37, 0x37, 0x64, 0x38, 0x64, 0x31, 0x38, 0x64, 0x65, 0x39, 0x31, 0x33, 0x31, 0x62, 0x39, 0x63, 0x39, 0x63, 0x36, 0x62, 0x39, 0x32, 0x36, 0x65, 0x37, 0x63, 0x61, 0x38, 0x32, 0x62, 0x66, 0x35, 0x66, 0x63, 0x38, 0x61, 0x34, 0x34, 0x33, 0x33, 0x37, 0x37, 0x36, 0x36, 0x66, 0x36, 0x61, 0x65, 0x65, 0x39, 0x34, 0x34, 0x36, 0x61, 0x37, 0x34, 0x37, 0x39, 0x64, 0x34, 0x32, 0x65, 0x36, 0x37, 0x35, 0x37, 0x38, 0x39, 0x36, 0x65, 0x30, 0x66, 0x39, 0x64, 0x33, 0x31, 0x61, 0x63, 0x65, 0x61, 0x36, 0x38, 0x31, 0x30, 0x34, 0x34, 0x34, 0x30, 0x32, 0x61, 0x61, 0x65, 0x39, 0x35, 0x65, 0x37, 0x31, 0x65, 0x33, 0x32, 0x34, 0x33, 0x31, 0x37, 0x34, 0x64, 0x31, 0x64, 0x30, 0x63, 0x35, 0x37, 0x34, 0x37, 0x61, 0x38, 0x66, 0x64, 0x66, 0x66, 0x34, 0x63, 0x38, 0x61, 0x33, 0x34, 0x31, 0x39, 0x62, 0x30, 0x32, 0x34, 0x37, 0x64, 0x30, 0x66, 0x63, 0x35, 0x63, 0x66, 0x35, 0x31, 0x32, 0x33, 0x38, 0x39, 0x64, 0x39, 0x32, 0x32, 0x34, 0x65, 0x62, 0x64, 0x35, 0x30, 0x64, 0x65, 0x63, 0x33, 0x30, 0x63, 0x39, 0x39, 0x33, 0x36, 0x66, 0x38, 0x32, 0x64, 0x39, 0x66, 0x65, 0x66, 0x36, 0x36, 0x34, 0x32, 0x33, 0x31, 0x32, 0x30, 0x30, 0x34, 0x34, 0x65, 0x37, 0x39, 0x63, 0x61, 0x36, 0x34, 0x34, 0x35, 0x64, 0x30, 0x63, 0x63, 0x37, 0x31, 0x38, 0x39, 0x66, 0x63, 0x62, 0x65, 0x30, 0x37, 0x30, 0x36, 0x64, 0x62, 0x63, 0x30, 0x30, 0x34, 0x38, 0x30, 0x39, 0x61, 0x38, 0x36, 0x31, 0x35, 0x34, 0x65, 0x63, 0x38, 0x37, 0x37, 0x32, 0x65, 0x61, 0x65, 0x64, 0x65, 0x37, 0x66, 0x34, 0x37, 0x37, 0x37, 0x39, 0x30, 0x35, 0x37, 0x34, 0x34, 0x33, 0x31, 0x39, 0x61, 0x39, 0x61, 0x34, 0x62, 0x31, 0x61, 0x64, 0x63, 0x63, 0x39, 0x35, 0x62, 0x30, 0x34, 0x38, 0x36, 0x63, 0x39, 0x39, 0x38, 0x61, 0x62, 0x38, 0x31, 0x64, 0x35, 0x37, 0x39, 0x37, 0x62, 0x39, 0x63, 0x33, 0x66, 0x64, 0x64, 0x66, 0x31, 0x64, 0x35, 0x35, 0x30, 0x31, 0x66, 0x35, 0x61, 0x37, 0x63, 0x32, 0x33, 0x34, 0x33, 0x32, 0x63, 0x37, 0x62, 0x64, 0x33, 0x37, 0x66, 0x35, 0x64, 0x61, 0x35, 0x61, 0x64, 0x36, 0x33, 0x66, 0x39, 0x31, 0x35, 0x30, 0x36, 0x64, 0x62, 0x38, 0x61, 0x31, 0x62, 0x35, 0x38, 0x66, 0x62, 0x39, 0x66, 0x39, 0x65, 0x64, 0x38, 0x32, 0x39, 0x34, 0x34, 0x36, 0x31, 0x62, 0x62, 0x38, 0x64, 0x32, 0x33, 0x64, 0x33, 0x61, 0x31, 0x38, 0x35, 0x64, 0x65, 0x34, 0x33, 0x35, 0x65, 0x32, 0x31, 0x64, 0x33, 0x30, 0x37, 0x36, 0x61, 0x37, 0x61, 0x66, 0x66, 0x31, 0x33, 0x36, 0x33, 0x30, 0x66, 0x39, 0x33, 0x64, 0x63, 0x31, 0x38, 0x38, 0x61, 0x37, 0x38, 0x64, 0x65, 0x36, 0x39, 0x37, 0x39, 0x61, 0x35, 0x62, 0x61, 0x63, 0x33, 0x32, 0x62, 0x65, 0x33, 0x31, 0x39, 0x37, 0x35, 0x38, 0x39, 0x38, 0x65, 0x31, 0x33, 0x33, 0x35, 0x66, 0x35, 0x62, 0x62, 0x63, 0x38, 0x61, 0x38, 0x30, 0x32, 0x64, 0x61, 0x35, 0x61, 0x30, 0x33, 0x66, 0x35, 0x65, 0x39, 0x61, 0x39, 0x34, 0x36, 0x65, 0x30, 0x30, 0x66, 0x64, 0x35, 0x66, 0x35, 0x35, 0x36, 0x64, 0x66, 0x36, 0x61, 0x34, 0x38, 0x38, 0x37, 0x31, 0x32, 0x30, 0x32, 0x61, 0x62, 0x64, 0x36, 0x36, 0x31, 0x35, 0x32, 0x65, 0x32, 0x31, 0x63, 0x35, 0x35, 0x37, 0x63, 0x39, 0x37, 0x32, 0x39, 0x64, 0x37, 0x30, 0x31, 0x35, 0x37, 0x33, 0x63, 0x31, 0x37, 0x38, 0x34, 0x39, 0x35, 0x66, 0x62, 0x30, 0x39, 0x66, 0x37, 0x36, 0x62, 0x61, 0x38, 0x66, 0x38, 0x39, 0x38, 0x66, 0x38, 0x34, 0x64, 0x64, 0x32, 0x65, 0x61, 0x38, 0x38, 0x64, 0x62, 0x64, 0x36, 0x33, 0x64, 0x32, 0x39, 0x38, 0x61, 0x34, 0x33, 0x39, 0x35, 0x65, 0x37, 0x34, 0x39, 0x64, 0x62, 0x37, 0x62, 0x63, 0x37, 0x32, 0x36, 0x36, 0x36, 0x35, 0x65, 0x36, 0x61, 0x32, 0x38, 0x30, 0x30, 0x66, 0x39, 0x32, 0x32, 0x33, 0x63, 0x66, 0x37, 0x66, 0x33, 0x65, 0x65, 0x36, 0x61, 0x61, 0x30, 0x65, 0x30, 0x63, 0x63, 0x38, 0x30, 0x30, 0x66, 0x30, 0x66, 0x66, 0x65, 0x36, 0x65, 0x62, 0x62, 0x34, 0x65, 0x63, 0x61, 0x64, 0x30, 0x66, 0x39, 0x38, 0x62, 0x65, 0x30, 0x34, 0x64, 0x62, 0x32, 0x34, 0x32, 0x61, 0x36, 0x65, 0x63, 0x32, 0x33, 0x65, 0x63, 0x61, 0x61, 0x36, 0x61, 0x31, 0x63, 0x32, 0x34, 0x64, 0x62, 0x63, 0x61, 0x37, 0x37, 0x36, 0x36, 0x61, 0x61, 0x37, 0x30, 0x30, 0x66, 0x36, 0x65, 0x61, 0x66, 0x33, 0x66, 0x32, 0x65, 0x34, 0x39, 0x61, 0x35, 0x31, 0x37, 0x36, 0x63, 0x33, 0x62, 0x65, 0x65, 0x30, 0x64, 0x66, 0x38, 0x62, 0x30, 0x30, 0x32, 0x35, 0x30, 0x37, 0x34, 0x61, 0x39, 0x34, 0x36, 0x65, 0x36, 0x32, 0x65, 0x37, 0x37, 0x36, 0x66, 0x33, 0x31, 0x37, 0x34, 0x66, 0x64, 0x62, 0x31, 0x65, 0x39, 0x32, 0x35, 0x64, 0x61, 0x32, 0x63, 0x36, 0x32, 0x39, 0x62, 0x61, 0x34, 0x32, 0x32, 0x63, 0x35, 0x33, 0x34, 0x38, 0x66, 0x62, 0x38, 0x33, 0x63, 0x35, 0x62, 0x36, 0x39, 0x30, 0x35, 0x30, 0x64, 0x61, 0x64, 0x62, 0x65, 0x39, 0x62, 0x63, 0x35, 0x31, 0x38, 0x31, 0x65, 0x34, 0x32, 0x30, 0x33, 0x62, 0x63, 0x36, 0x38, 0x35, 0x65, 0x35, 0x66, 0x38, 0x34, 0x64, 0x62, 0x35, 0x32, 0x65, 0x32, 0x33, 0x34, 0x35, 0x38, 0x32, 0x65, 0x38, 0x38, 0x39, 0x36, 0x34, 0x32, 0x31, 0x37, 0x37, 0x66, 0x65, 0x63, 0x32, 0x62, 0x38, 0x33, 0x30, 0x61, 0x39, 0x30, 0x39, 0x66, 0x39, 0x36, 0x62, 0x30, 0x65, 0x63, 0x65, 0x36, 0x61, 0x32, 0x35, 0x31, 0x66, 0x37, 0x35, 0x37, 0x38, 0x37, 0x32, 0x63, 0x36, 0x63, 0x62, 0x33, 0x37, 0x38, 0x39, 0x63, 0x64, 0x34, 0x37, 0x63, 0x62, 0x61, 0x30, 0x37, 0x64, 0x39, 0x33, 0x66, 0x61, 0x37, 0x30, 0x65, 0x33, 0x33, 0x61, 0x63, 0x39, 0x37, 0x36, 0x64, 0x66, 0x35, 0x35, 0x37, 0x32, 0x36, 0x63, 0x31, 0x61, 0x63, 0x64, 0x39, 0x38, 0x65, 0x35, 0x32, 0x66, 0x39, 0x32, 0x63, 0x66, 0x65, 0x64, 0x32, 0x31, 0x65, 0x33, 0x33, 0x65, 0x37, 0x32, 0x31, 0x62, 0x66, 0x64, 0x64, 0x38, 0x31, 0x64, 0x34, 0x34, 0x35, 0x38, 0x63, 0x63, 0x65, 0x39, 0x66, 0x61, 0x64, 0x32, 0x35, 0x65, 0x35, 0x36, 0x35, 0x35, 0x37, 0x63, 0x37, 0x36, 0x33, 0x38, 0x38, 0x39, 0x64, 0x31, 0x36, 0x62, 0x37, 0x34, 0x66, 0x62, 0x30, 0x62, 0x64, 0x62, 0x31, 0x66, 0x39, 0x31, 0x38, 0x34, 0x33, 0x31, 0x63, 0x34, 0x35, 0x33, 0x64, 0x30, 0x39, 0x63, 0x35, 0x35, 0x65, 0x65, 0x61, 0x33, 0x66, 0x66, 0x66, 0x65, 0x66, 0x38, 0x64, 0x30, 0x30, 0x63, 0x62, 0x35, 0x37, 0x61, 0x64, 0x36, 0x64, 0x65, 0x34, 0x64, 0x61, 0x34, 0x38, 0x64, 0x35, 0x35, 0x61, 0x63, 0x66, 0x66, 0x39, 0x34, 0x34, 0x39, 0x66, 0x32, 0x32, 0x34, 0x39, 0x64, 0x65, 0x33, 0x64, 0x61, 0x63, 0x66, 0x30, 0x65, 0x31, 0x65, 0x39, 0x65, 0x62, 0x64, 0x36, 0x66, 0x64, 0x32, 0x37, 0x32, 0x61, 0x33, 0x66, 0x39, 0x61, 0x64, 0x31, 0x37, 0x35, 0x30, 0x36, 0x61, 0x64, 0x66, 0x35, 0x38, 0x33, 0x36, 0x36, 0x63, 0x61, 0x37, 0x36, 0x34, 0x31, 0x36, 0x61, 0x30, 0x66, 0x35, 0x66, 0x35, 0x39, 0x63, 0x62, 0x39, 0x38, 0x66, 0x61, 0x35, 0x64, 0x36, 0x35, 0x35, 0x39, 0x35, 0x39, 0x34, 0x62, 0x33, 0x37, 0x39, 0x35, 0x34, 0x30, 0x31, 0x39, 0x37, 0x31, 0x62, 0x37, 0x65, 0x37, 0x32, 0x66, 0x33, 0x64, 0x37, 0x62, 0x34, 0x36, 0x61, 0x62, 0x61, 0x31, 0x39, 0x65, 0x33, 0x31, 0x61, 0x37, 0x63, 0x33, 0x64, 0x61, 0x34, 0x35, 0x35, 0x66, 0x31, 0x64, 0x39, 0x31, 0x38, 0x61, 0x34, 0x62, 0x31, 0x64, 0x34, 0x61, 0x62, 0x37, 0x39, 0x65, 0x30, 0x65, 0x32, 0x66, 0x35, 0x64, 0x37, 0x34, 0x63, 0x38, 0x32, 0x32, 0x30, 0x62, 0x30, 0x66, 0x36, 0x64, 0x38, 0x62, 0x30, 0x37, 0x31, 0x34, 0x33, 0x39, 0x32, 0x33, 0x38, 0x34, 0x39, 0x35, 0x63, 0x35, 0x38, 0x64, 0x37, 0x39, 0x62, 0x32, 0x33, 0x37, 0x33, 0x32, 0x31, 0x61, 0x35, 0x62, 0x66, 0x39, 0x63, 0x63, 0x36, 0x37, 0x66, 0x30, 0x63, 0x36, 0x62, 0x33, 0x65, 0x33, 0x36, 0x38, 0x64, 0x36, 0x33, 0x62, 0x30, 0x33, 0x39, 0x38, 0x39, 0x37, 0x61, 0x37, 0x64, 0x39, 0x66, 0x39, 0x64, 0x30, 0x30, 0x31, 0x33, 0x35, 0x39, 0x64, 0x63, 0x33, 0x32, 0x64, 0x66, 0x65, 0x33, 0x31, 0x34, 0x38, 0x39, 0x32, 0x62, 0x37, 0x30, 0x35, 0x31, 0x61, 0x65, 0x64, 0x64, 0x30, 0x63, 0x64, 0x33, 0x39, 0x38, 0x32, 0x64, 0x30, 0x38, 0x37, 0x34, 0x36, 0x37, 0x34, 0x61, 0x34, 0x62, 0x32, 0x39, 0x37, 0x64, 0x38, 0x33, 0x37, 0x39, 0x62, 0x39, 0x36, 0x63, 0x35, 0x35, 0x62, 0x66, 0x32, 0x39, 0x32, 0x62, 0x38, 0x30, 0x37, 0x32, 0x33, 0x32, 0x38, 0x38, 0x36, 0x35, 0x31, 0x37, 0x37, 0x66, 0x63, 0x65, 0x37, 0x31, 0x35, 0x38, 0x39, 0x30, 0x63, 0x32, 0x37, 0x63, 0x37, 0x61, 0x64, 0x34, 0x62, 0x64, 0x30, 0x30, 0x38, 0x39, 0x65, 0x64, 0x61, 0x37, 0x31, 0x31, 0x65, 0x66, 0x32, 0x65, 0x30, 0x66, 0x66, 0x39, 0x37, 0x31, 0x36, 0x63, 0x62, 0x38, 0x66, 0x35, 0x30, 0x64, 0x63, 0x35, 0x35, 0x30, 0x32, 0x39, 0x37, 0x32, 0x65, 0x65, 0x35, 0x32, 0x64, 0x36, 0x37, 0x66, 0x35, 0x65, 0x34, 0x38, 0x31, 0x33, 0x39, 0x36, 0x66, 0x33, 0x63, 0x31, 0x33, 0x62, 0x64, 0x39, 0x35, 0x62, 0x32, 0x30, 0x36, 0x32, 0x37, 0x39, 0x37, 0x30, 0x36, 0x62, 0x65, 0x65, 0x65, 0x37, 0x32, 0x64, 0x65, 0x30, 0x65, 0x32, 0x66, 0x33, 0x63, 0x35, 0x30, 0x33, 0x34, 0x61, 0x37, 0x65, 0x31, 0x30, 0x31, 0x37, 0x34, 0x66, 0x30, 0x64, 0x36, 0x35, 0x38, 0x35, 0x32, 0x61, 0x34, 0x35, 0x61, 0x38, 0x64, 0x63, 0x34, 0x32, 0x32, 0x31, 0x39, 0x35, 0x34, 0x34, 0x61, 0x38, 0x62, 0x37, 0x38, 0x38, 0x36, 0x39, 0x37, 0x30, 0x34, 0x36, 0x39, 0x66, 0x32, 0x30, 0x36, 0x33, 0x35, 0x30, 0x38, 0x31, 0x66, 0x63, 0x35, 0x66, 0x64, 0x34, 0x30, 0x33, 0x64, 0x61, 0x32, 0x37, 0x35, 0x63, 0x63, 0x61, 0x34, 0x63, 0x63, 0x63, 0x35, 0x61, 0x66, 0x64, 0x30, 0x33, 0x63, 0x64, 0x30, 0x35, 0x33, 0x32, 0x38, 0x33, 0x65, 0x64, 0x39, 0x39, 0x63, 0x35, 0x36, 0x62, 0x36, 0x35, 0x39, 0x66, 0x61, 0x61, 0x62, 0x64, 0x32, 0x62, 0x35, 0x32, 0x39, 0x31, 0x35, 0x38, 0x62, 0x65, 0x34, 0x63, 0x33, 0x34, 0x61, 0x61, 0x66, 0x32, 0x30, 0x35, 0x61, 0x63, 0x65, 0x37, 0x39, 0x65, 0x32, 0x63, 0x38, 0x30, 0x38, 0x64, 0x65, 0x33, 0x30, 0x63, 0x65, 0x33, 0x62, 0x61, 0x65, 0x30, 0x65, 0x37, 0x33, 0x62, 0x65, 0x35, 0x33, 0x38, 0x64, 0x65, 0x66, 0x64, 0x31, 0x33, 0x33, 0x37, 0x62, 0x38, 0x66, 0x65, 0x34, 0x39, 0x32, 0x37, 0x36, 0x31, 0x65, 0x36, 0x33, 0x38, 0x39, 0x63, 0x31, 0x31, 0x38, 0x35, 0x33, 0x36, 0x61, 0x39, 0x66, 0x35, 0x36, 0x62, 0x31, 0x65, 0x63, 0x61, 0x61, 0x65, 0x30, 0x61, 0x38, 0x64, 0x63, 0x66, 0x31, 0x32, 0x32, 0x61, 0x63, 0x39, 0x33, 0x33, 0x30, 0x34, 0x66, 0x61, 0x63, 0x63, 0x65, 0x61, 0x31, 0x31, 0x61, 0x37, 0x37, 0x36, 0x62, 0x39, 0x34, 0x63, 0x39, 0x63, 0x37, 0x32, 0x63, 0x33, 0x32, 0x34, 0x39, 0x33, 0x31, 0x64, 0x38, 0x63, 0x32, 0x34, 0x30, 0x32, 0x34, 0x61, 0x31, 0x36, 0x32, 0x63, 0x35, 0x33, 0x35, 0x62, 0x66, 0x39, 0x64, 0x62, 0x61, 0x30, 0x35, 0x31, 0x61, 0x62, 0x37, 0x32, 0x35, 0x34, 0x31, 0x36, 0x33, 0x30, 0x31, 0x32, 0x37, 0x36, 0x35, 0x35, 0x37, 0x63, 0x33, 0x30, 0x32, 0x64, 0x38, 0x63, 0x31, 0x65, 0x31, 0x35, 0x37, 0x64, 0x63, 0x64, 0x30, 0x34, 0x65, 0x31, 0x36, 0x64, 0x62, 0x39, 0x65, 0x33, 0x65, 0x63, 0x37, 0x61, 0x39, 0x61, 0x64, 0x61, 0x34, 0x30, 0x63, 0x39, 0x66, 0x65, 0x31, 0x64, 0x33, 0x30, 0x37, 0x62, 0x33, 0x62, 0x34, 0x37, 0x37, 0x32, 0x34, 0x31, 0x39, 0x39, 0x31, 0x62, 0x35, 0x37, 0x61, 0x36, 0x35, 0x38, 0x30, 0x36, 0x34, 0x32, 0x65, 0x61, 0x31, 0x66, 0x38, 0x33, 0x31, 0x64, 0x37, 0x65, 0x33, 0x39, 0x32, 0x32, 0x36, 0x62, 0x65, 0x61, 0x35, 0x37, 0x65, 0x36, 0x37, 0x35, 0x37, 0x65, 0x32, 0x33, 0x32, 0x33, 0x64, 0x39, 0x37, 0x37, 0x62, 0x35, 0x35, 0x32, 0x66, 0x64, 0x36, 0x65, 0x64, 0x38, 0x35, 0x39, 0x37, 0x32, 0x33, 0x31, 0x62, 0x36, 0x61, 0x63, 0x36, 0x61, 0x64, 0x62, 0x37, 0x30, 0x35, 0x30, 0x39, 0x62, 0x30, 0x64, 0x34, 0x32, 0x65, 0x63, 0x33, 0x63, 0x65, 0x62, 0x62, 0x66, 0x31, 0x31, 0x64, 0x64, 0x32, 0x35, 0x39, 0x34, 0x62, 0x32, 0x38, 0x63, 0x31, 0x34, 0x33, 0x61, 0x37, 0x39, 0x33, 0x39, 0x36, 0x34, 0x37, 0x61, 0x66, 0x39, 0x30, 0x31, 0x63, 0x33, 0x66, 0x30, 0x30, 0x37, 0x37, 0x32, 0x61, 0x36, 0x62, 0x31, 0x36, 0x35, 0x66, 0x62, 0x36, 0x66, 0x34, 0x30, 0x65, 0x37, 0x32, 0x32, 0x61, 0x39, 0x63, 0x39, 0x32, 0x34, 0x61, 0x61, 0x30, 0x34, 0x61, 0x61, 0x64, 0x64, 0x34, 0x34, 0x39, 0x61, 0x61, 0x66, 0x62, 0x35, 0x31, 0x33, 0x64, 0x62, 0x62, 0x35, 0x62, 0x36, 0x33, 0x31, 0x34, 0x31, 0x63, 0x65, 0x36, 0x30, 0x34, 0x31, 0x66, 0x31, 0x38, 0x66, 0x38, 0x66, 0x37, 0x32, 0x33, 0x38, 0x37, 0x64, 0x39, 0x65, 0x34, 0x34, 0x35, 0x65, 0x64, 0x63, 0x37, 0x32, 0x62, 0x37, 0x62, 0x39, 0x32, 0x39, 0x63, 0x38, 0x64, 0x65, 0x64, 0x36, 0x34, 0x33, 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x36, 0x66, 0x32, 0x39, 0x31, 0x36, 0x39, 0x37, 0x62, 0x66, 0x31, 0x64, 0x64, 0x32, 0x37, 0x38, 0x37, 0x33, 0x37, 0x62, 0x38, 0x65, 0x63, 0x63, 0x30, 0x33, 0x31, 0x30, 0x30, 0x39, 0x33, 0x36, 0x65, 0x64, 0x65, 0x37, 0x33, 0x63, 0x61, 0x39, 0x61, 0x35, 0x39, 0x32, 0x30, 0x63, 0x63, 0x34, 0x61, 0x36, 0x39, 0x32, 0x39, 0x32, 0x38, 0x32, 0x39, 0x33, 0x39, 0x33, 0x36, 0x64, 0x33, 0x31, 0x38, 0x31, 0x62, 0x39, 0x38, 0x35, 0x30, 0x32, 0x34, 0x64, 0x64, 0x30, 0x31, 0x61, 0x39, 0x30, 0x30, 0x32, 0x37, 0x33, 0x36, 0x35, 0x35, 0x34, 0x36, 0x66, 0x36, 0x65, 0x36, 0x34, 0x39, 0x32, 0x33, 0x66, 0x66, 0x61, 0x35, 0x61, 0x62, 0x34, 0x37, 0x30, 0x66, 0x31, 0x39, 0x38, 0x30, 0x66, 0x38, 0x37, 0x34, 0x37, 0x38, 0x30, 0x37, 0x31, 0x32, 0x61, 0x64, 0x61, 0x38, 0x30, 0x30, 0x31, 0x39, 0x39, 0x32, 0x38, 0x36, 0x64, 0x36, 0x63, 0x37, 0x37, 0x39, 0x66, 0x33, 0x66, 0x66, 0x30, 0x66, 0x61, 0x35, 0x30, 0x64, 0x37, 0x61, 0x66, 0x63, 0x65, 0x66, 0x64, 0x37, 0x32, 0x30, 0x32, 0x66, 0x31, 0x62, 0x30, 0x65, 0x31, 0x33, 0x64, 0x62, 0x63, 0x63, 0x64, 0x31, 0x35, 0x61, 0x65, 0x35, 0x61, 0x32, 0x39, 0x62, 0x35, 0x62, 0x36, 0x34, 0x66, 0x33, 0x37, 0x61, 0x30, 0x30, 0x62, 0x37, 0x61, 0x34, 0x38, 0x61, 0x66, 0x39, 0x37, 0x37, 0x38, 0x31, 0x37, 0x33, 0x62, 0x61, 0x64, 0x61, 0x61, 0x39, 0x61, 0x32, 0x33, 0x31, 0x63, 0x36, 0x61, 0x38, 0x31, 0x37, 0x32, 0x65, 0x38, 0x35, 0x63, 0x37, 0x39, 0x31, 0x39, 0x37, 0x64, 0x36, 0x37, 0x64, 0x63, 0x37, 0x32, 0x62, 0x65, 0x64, 0x65, 0x36, 0x39, 0x35, 0x38, 0x61, 0x35, 0x66, 0x66, 0x36, 0x61, 0x30, 0x36, 0x38, 0x33, 0x62, 0x63, 0x31, 0x38, 0x66, 0x65, 0x30, 0x31, 0x33, 0x62, 0x62, 0x61, 0x65, 0x32, 0x63, 0x39, 0x31, 0x63, 0x61, 0x64, 0x35, 0x33, 0x64, 0x61, 0x35, 0x35, 0x65, 0x64, 0x37, 0x32, 0x31, 0x66, 0x64, 0x66, 0x66, 0x39, 0x62, 0x35, 0x65, 0x35, 0x39, 0x31, 0x66, 0x33, 0x65, 0x66, 0x38, 0x61, 0x31, 0x39, 0x32, 0x61, 0x61, 0x63, 0x34, 0x34, 0x30, 0x66, 0x66, 0x34, 0x61, 0x33, 0x66, 0x31, 0x38, 0x64, 0x31, 0x30, 0x61, 0x31, 0x36, 0x34, 0x63, 0x36, 0x34, 0x37, 0x66, 0x64, 0x38, 0x36, 0x66, 0x65, 0x63, 0x62, 0x61, 0x38, 0x38, 0x63, 0x36, 0x36, 0x62, 0x39, 0x37, 0x32, 0x37, 0x38, 0x32, 0x31, 0x32, 0x30, 0x36, 0x62, 0x33, 0x37, 0x64, 0x38, 0x33, 0x33, 0x66, 0x66, 0x35, 0x39, 0x39, 0x35, 0x39, 0x37, 0x64, 0x31, 0x63, 0x66, 0x62, 0x33, 0x32, 0x33, 0x39, 0x39, 0x39, 0x35, 0x61, 0x37, 0x62, 0x36, 0x66, 0x31, 0x35, 0x63, 0x65, 0x37, 0x62, 0x65, 0x61, 0x66, 0x62, 0x65, 0x61, 0x61, 0x37, 0x36, 0x39, 0x33, 0x35, 0x61, 0x34, 0x64, 0x34, 0x65, 0x33, 0x39, 0x66, 0x61, 0x31, 0x31, 0x34, 0x64, 0x65, 0x31, 0x34, 0x63, 0x36, 0x32, 0x66, 0x34, 0x39, 0x36, 0x35, 0x34, 0x63, 0x37, 0x33, 0x66, 0x30, 0x33, 0x65, 0x30, 0x30, 0x34, 0x64, 0x65, 0x36, 0x37, 0x33, 0x32, 0x65, 0x65, 0x35, 0x33, 0x63, 0x30, 0x33, 0x38, 0x37, 0x35, 0x38, 0x31, 0x66, 0x30, 0x63, 0x38, 0x36, 0x39, 0x31, 0x65, 0x31, 0x35, 0x39, 0x36, 0x38, 0x37, 0x65, 0x65, 0x32, 0x63, 0x36, 0x65, 0x37, 0x30, 0x30, 0x30, 0x64, 0x35, 0x35, 0x37, 0x32, 0x65, 0x37, 0x64, 0x66, 0x62, 0x64, 0x33, 0x39, 0x35, 0x35, 0x35, 0x66, 0x64, 0x61, 0x31, 0x62, 0x33, 0x36, 0x63, 0x37, 0x65, 0x34, 0x31, 0x32, 0x36, 0x63, 0x62, 0x66, 0x36, 0x66, 0x36, 0x32, 0x32, 0x66, 0x36, 0x34, 0x38, 0x66, 0x32, 0x62, 0x32, 0x31, 0x64, 0x38, 0x31, 0x64, 0x66, 0x61, 0x65, 0x36, 0x38, 0x37, 0x32, 0x38, 0x32, 0x31, 0x38, 0x38, 0x34, 0x34, 0x35, 0x66, 0x37, 0x35, 0x61, 0x61, 0x33, 0x35, 0x30, 0x33, 0x37, 0x30, 0x32, 0x32, 0x30, 0x36, 0x37, 0x62, 0x30, 0x32, 0x63, 0x31, 0x35, 0x65, 0x34, 0x33, 0x37, 0x33, 0x31, 0x31, 0x36, 0x64, 0x32, 0x65, 0x65, 0x39, 0x62, 0x31, 0x63, 0x30, 0x31, 0x65, 0x63, 0x63, 0x35, 0x61, 0x65, 0x34, 0x39, 0x36, 0x37, 0x65, 0x34, 0x31, 0x64, 0x31, 0x37, 0x64, 0x30, 0x33, 0x38, 0x36, 0x64, 0x35, 0x66, 0x66, 0x37, 0x61, 0x30, 0x33, 0x61, 0x61, 0x61, 0x32, 0x63, 0x66, 0x62, 0x62, 0x35, 0x37, 0x31, 0x61, 0x30, 0x62, 0x66, 0x33, 0x65, 0x61, 0x61, 0x66, 0x62, 0x35, 0x39, 0x66, 0x35, 0x34, 0x37, 0x61, 0x32, 0x32, 0x65, 0x35, 0x62, 0x38, 0x37, 0x66, 0x61, 0x64, 0x35, 0x30, 0x34, 0x63, 0x31, 0x35, 0x32, 0x64, 0x32, 0x37, 0x32, 0x35, 0x38, 0x34, 0x61, 0x35, 0x65, 0x32, 0x61, 0x35, 0x31, 0x66, 0x32, 0x38, 0x31, 0x30, 0x32, 0x63, 0x62, 0x30, 0x35, 0x64, 0x62, 0x66, 0x63, 0x37, 0x35, 0x63, 0x62, 0x32, 0x63, 0x35, 0x37, 0x30, 0x31, 0x65, 0x31, 0x38, 0x35, 0x34, 0x62, 0x32, 0x36, 0x65, 0x63, 0x33, 0x39, 0x65, 0x34, 0x39, 0x31, 0x37, 0x34, 0x64, 0x31, 0x62, 0x38, 0x37, 0x61, 0x61, 0x33, 0x66, 0x32, 0x66, 0x65, 0x36, 0x34, 0x37, 0x64, 0x38, 0x39, 0x37, 0x66, 0x37, 0x63, 0x33, 0x34, 0x61, 0x36, 0x39, 0x64, 0x30, 0x34, 0x39, 0x32, 0x36, 0x33, 0x36, 0x31, 0x65, 0x36, 0x30, 0x31, 0x32, 0x31, 0x30, 0x63, 0x35, 0x61, 0x31, 0x32, 0x37, 0x66, 0x63, 0x37, 0x32, 0x61, 0x31, 0x36, 0x64, 0x64, 0x66, 0x30, 0x32, 0x32, 0x35, 0x37, 0x33, 0x37, 0x63, 0x37, 0x61, 0x61, 0x62, 0x30, 0x61, 0x64, 0x64, 0x30, 0x34, 0x32, 0x39, 0x37, 0x35, 0x34, 0x63, 0x63, 0x37, 0x35, 0x30, 0x62, 0x32, 0x39, 0x62, 0x62, 0x33, 0x66, 0x33, 0x64, 0x64, 0x31, 0x66, 0x39, 0x39, 0x38, 0x31, 0x33, 0x63, 0x64, 0x35, 0x39, 0x30, 0x64, 0x62, 0x66, 0x62, 0x31, 0x32, 0x35, 0x30, 0x31, 0x62, 0x31, 0x62, 0x66, 0x39, 0x66, 0x38, 0x65, 0x33, 0x63, 0x37, 0x38, 0x62, 0x38, 0x38, 0x34, 0x66, 0x31, 0x39, 0x65, 0x35, 0x62, 0x37, 0x32, 0x39, 0x35, 0x32, 0x64, 0x61, 0x66, 0x33, 0x32, 0x63, 0x38, 0x62, 0x65, 0x32, 0x35, 0x39, 0x63, 0x34, 0x37, 0x35, 0x36, 0x38, 0x37, 0x61, 0x32, 0x64, 0x35, 0x35, 0x32, 0x38, 0x37, 0x66, 0x31, 0x38, 0x64, 0x64, 0x38, 0x34, 0x34, 0x64, 0x33, 0x63, 0x64, 0x38, 0x39, 0x35, 0x62, 0x38, 0x36, 0x34, 0x66, 0x30, 0x37, 0x61, 0x61, 0x64, 0x35, 0x64, 0x30, 0x36, 0x63, 0x35, 0x30, 0x37, 0x32, 0x64, 0x35, 0x63, 0x35, 0x38, 0x34, 0x63, 0x31, 0x65, 0x38, 0x66, 0x33, 0x32, 0x39, 0x34, 0x39, 0x65, 0x62, 0x65, 0x38, 0x35, 0x38, 0x32, 0x66, 0x61, 0x31, 0x39, 0x65, 0x31, 0x36, 0x65, 0x32, 0x65, 0x35, 0x38, 0x32, 0x31, 0x35, 0x66, 0x35, 0x61, 0x36, 0x63, 0x32, 0x32, 0x35, 0x63, 0x37, 0x63, 0x64, 0x36, 0x63, 0x31, 0x34, 0x63, 0x37, 0x37, 0x39, 0x64, 0x38, 0x64, 0x36, 0x37, 0x32, 0x33, 0x31, 0x37, 0x37, 0x37, 0x33, 0x31, 0x62, 0x63, 0x66, 0x34, 0x33, 0x39, 0x62, 0x35, 0x39, 0x63, 0x35, 0x64, 0x30, 0x61, 0x36, 0x37, 0x35, 0x35, 0x39, 0x64, 0x65, 0x61, 0x38, 0x66, 0x66, 0x61, 0x30, 0x32, 0x36, 0x30, 0x30, 0x66, 0x38, 0x62, 0x30, 0x66, 0x32, 0x66, 0x33, 0x38, 0x32, 0x34, 0x66, 0x34, 0x33, 0x36, 0x61, 0x32, 0x32, 0x32, 0x35, 0x32, 0x66, 0x31, 0x38, 0x36, 0x66, 0x38, 0x34, 0x63, 0x66, 0x38, 0x65, 0x32, 0x35, 0x35, 0x30, 0x36, 0x32, 0x34, 0x62, 0x32, 0x66, 0x31, 0x64, 0x33, 0x32, 0x32, 0x37, 0x30, 0x31, 0x61, 0x36, 0x39, 0x66, 0x31, 0x38, 0x66, 0x62, 0x62, 0x34, 0x62, 0x30, 0x38, 0x31, 0x62, 0x30, 0x38, 0x61, 0x66, 0x65, 0x30, 0x39, 0x30, 0x38, 0x34, 0x31, 0x37, 0x31, 0x31, 0x61, 0x34, 0x32, 0x34, 0x35, 0x63, 0x66, 0x61, 0x35, 0x37, 0x32, 0x32, 0x35, 0x36, 0x66, 0x36, 0x65, 0x35, 0x38, 0x36, 0x65, 0x63, 0x65, 0x32, 0x32, 0x65, 0x64, 0x33, 0x30, 0x61, 0x36, 0x37, 0x37, 0x39, 0x32, 0x61, 0x38, 0x34, 0x38, 0x62, 0x33, 0x34, 0x39, 0x31, 0x35, 0x38, 0x64, 0x38, 0x66, 0x63, 0x37, 0x65, 0x62, 0x63, 0x30, 0x37, 0x63, 0x35, 0x36, 0x63, 0x33, 0x30, 0x32, 0x63, 0x62, 0x36, 0x66, 0x37, 0x36, 0x63, 0x36, 0x35, 0x66, 0x32, 0x33, 0x62, 0x64, 0x38, 0x66, 0x34, 0x38, 0x38, 0x61, 0x63, 0x30, 0x66, 0x37, 0x34, 0x65, 0x35, 0x37, 0x35, 0x66, 0x62, 0x63, 0x61, 0x33, 0x61, 0x32, 0x31, 0x63, 0x36, 0x65, 0x37, 0x31, 0x35, 0x33, 0x31, 0x36, 0x61, 0x31, 0x31, 0x61, 0x38, 0x37, 0x62, 0x39, 0x65, 0x34, 0x34, 0x39, 0x63, 0x34, 0x33, 0x32, 0x31, 0x34, 0x36, 0x62, 0x34, 0x34, 0x62, 0x33, 0x65, 0x63, 0x36, 0x35, 0x32, 0x64, 0x35, 0x62, 0x30, 0x39, 0x37, 0x30, 0x39, 0x61, 0x62, 0x61, 0x65, 0x65, 0x37, 0x32, 0x35, 0x65, 0x62, 0x37, 0x39, 0x37, 0x31, 0x61, 0x36, 0x34, 0x62, 0x37, 0x33, 0x65, 0x64, 0x65, 0x61, 0x36, 0x30, 0x35, 0x39, 0x36, 0x30, 0x65, 0x66, 0x30, 0x65, 0x65, 0x30, 0x65, 0x65, 0x38, 0x38, 0x37, 0x30, 0x39, 0x39, 0x30, 0x37, 0x34, 0x35, 0x63, 0x30, 0x31, 0x39, 0x64, 0x39, 0x31, 0x31, 0x34, 0x37, 0x30, 0x37, 0x39, 0x65, 0x33, 0x30, 0x32, 0x37, 0x34, 0x30, 0x33, 0x36, 0x34, 0x31, 0x34, 0x37, 0x65, 0x35, 0x63, 0x38, 0x63, 0x64, 0x63, 0x66, 0x31, 0x61, 0x61, 0x38, 0x35, 0x34, 0x33, 0x31, 0x64, 0x32, 0x30, 0x39, 0x63, 0x64, 0x37, 0x37, 0x37, 0x38, 0x37, 0x63, 0x36, 0x64, 0x32, 0x64, 0x39, 0x31, 0x63, 0x31, 0x65, 0x39, 0x39, 0x38, 0x63, 0x38, 0x62, 0x62, 0x64, 0x37, 0x32, 0x31, 0x66, 0x37, 0x34, 0x61, 0x32, 0x34, 0x62, 0x61, 0x32, 0x37, 0x38, 0x64, 0x62, 0x34, 0x63, 0x65, 0x62, 0x64, 0x62, 0x36, 0x38, 0x37, 0x37, 0x65, 0x61, 0x30, 0x31, 0x30, 0x62, 0x63, 0x62, 0x33, 0x30, 0x62, 0x65, 0x32, 0x65, 0x38, 0x64, 0x38, 0x35, 0x65, 0x66, 0x31, 0x30, 0x33, 0x30, 0x64, 0x32, 0x65, 0x62, 0x61, 0x62, 0x35, 0x39, 0x35, 0x37, 0x66, 0x31, 0x37, 0x37, 0x37, 0x32, 0x37, 0x39, 0x35, 0x35, 0x62, 0x62, 0x63, 0x63, 0x34, 0x36, 0x62, 0x65, 0x32, 0x63, 0x64, 0x33, 0x33, 0x62, 0x37, 0x63, 0x63, 0x62, 0x34, 0x36, 0x61, 0x32, 0x31, 0x65, 0x36, 0x61, 0x32, 0x36, 0x36, 0x38, 0x66, 0x39, 0x37, 0x37, 0x33, 0x33, 0x32, 0x65, 0x36, 0x35, 0x33, 0x63, 0x35, 0x64, 0x38, 0x31, 0x63, 0x38, 0x38, 0x64, 0x62, 0x37, 0x65, 0x36, 0x62, 0x39, 0x35, 0x65, 0x37, 0x32, 0x35, 0x32, 0x36, 0x34, 0x62, 0x35, 0x39, 0x38, 0x32, 0x35, 0x64, 0x34, 0x61, 0x34, 0x31, 0x33, 0x30, 0x62, 0x30, 0x66, 0x34, 0x64, 0x35, 0x30, 0x31, 0x32, 0x63, 0x62, 0x63, 0x33, 0x30, 0x64, 0x66, 0x32, 0x34, 0x37, 0x34, 0x35, 0x62, 0x32, 0x61, 0x66, 0x30, 0x38, 0x39, 0x66, 0x39, 0x35, 0x35, 0x63, 0x65, 0x32, 0x32, 0x35, 0x39, 0x66, 0x64, 0x37, 0x35, 0x36, 0x36, 0x30, 0x32, 0x36, 0x62, 0x36, 0x65, 0x35, 0x61, 0x65, 0x36, 0x33, 0x63, 0x65, 0x33, 0x64, 0x35, 0x33, 0x31, 0x32, 0x38, 0x64, 0x61, 0x37, 0x64, 0x30, 0x31, 0x35, 0x31, 0x34, 0x33, 0x66, 0x63, 0x64, 0x62, 0x32, 0x30, 0x66, 0x35, 0x31, 0x65, 0x30, 0x30, 0x31, 0x31, 0x36, 0x31, 0x30, 0x64, 0x35, 0x63, 0x30, 0x66, 0x37, 0x36, 0x35, 0x30, 0x61, 0x31, 0x33, 0x36, 0x66, 0x33, 0x38, 0x39, 0x64, 0x36, 0x30, 0x65, 0x35, 0x61, 0x61, 0x61, 0x61, 0x34, 0x35, 0x39, 0x63, 0x62, 0x35, 0x39, 0x32, 0x31, 0x38, 0x64, 0x32, 0x30, 0x35, 0x64, 0x30, 0x31, 0x32, 0x38, 0x63, 0x63, 0x30, 0x63, 0x31, 0x36, 0x65, 0x30, 0x38, 0x66, 0x65, 0x37, 0x66, 0x34, 0x38, 0x66, 0x33, 0x38, 0x33, 0x64, 0x66, 0x62, 0x66, 0x61, 0x35, 0x61, 0x38, 0x35, 0x37, 0x66, 0x64, 0x33, 0x62, 0x66, 0x32, 0x33, 0x61, 0x37, 0x32, 0x64, 0x39, 0x65, 0x63, 0x32, 0x63, 0x31, 0x33, 0x33, 0x37, 0x35, 0x37, 0x39, 0x39, 0x66, 0x38, 0x31, 0x62, 0x34, 0x35, 0x35, 0x64, 0x31, 0x35, 0x63, 0x64, 0x62, 0x36, 0x36, 0x63, 0x30, 0x30, 0x36, 0x38, 0x65, 0x65, 0x62, 0x33, 0x30, 0x65, 0x65, 0x66, 0x32, 0x64, 0x31, 0x64, 0x37, 0x64, 0x39, 0x37, 0x66, 0x31, 0x31, 0x62, 0x61, 0x35, 0x32, 0x31, 0x30, 0x66, 0x37, 0x65, 0x37, 0x32, 0x66, 0x30, 0x36, 0x34, 0x30, 0x64, 0x35, 0x66, 0x32, 0x37, 0x39, 0x30, 0x30, 0x66, 0x33, 0x64, 0x38, 0x36, 0x61, 0x36, 0x63, 0x30, 0x61, 0x66, 0x65, 0x32, 0x30, 0x37, 0x35, 0x35, 0x33, 0x62, 0x66, 0x62, 0x63, 0x34, 0x38, 0x30, 0x64, 0x39, 0x65, 0x38, 0x34, 0x65, 0x30, 0x34, 0x65, 0x64, 0x62, 0x66, 0x31, 0x66, 0x38, 0x63, 0x39, 0x66, 0x65, 0x64, 0x37, 0x30, 0x32, 0x35, 0x33, 0x31, 0x34, 0x35, 0x37, 0x37, 0x66, 0x30, 0x30, 0x30, 0x33, 0x39, 0x39, 0x64, 0x36, 0x64, 0x66, 0x30, 0x66, 0x66, 0x34, 0x66, 0x39, 0x32, 0x63, 0x64, 0x39, 0x31, 0x38, 0x37, 0x31, 0x31, 0x37, 0x37, 0x38, 0x61, 0x31, 0x63, 0x31, 0x66, 0x39, 0x33, 0x66, 0x34, 0x34, 0x35, 0x34, 0x33, 0x66, 0x66, 0x63, 0x31, 0x33, 0x31, 0x39, 0x66, 0x62, 0x34, 0x62, 0x62, 0x35, 0x62, 0x30, 0x66, 0x33, 0x30, 0x66, 0x32, 0x36, 0x63, 0x32, 0x34, 0x36, 0x62, 0x66, 0x30, 0x62, 0x66, 0x66, 0x35, 0x66, 0x35, 0x31, 0x64, 0x35, 0x62, 0x63, 0x38, 0x61, 0x33, 0x37, 0x30, 0x35, 0x35, 0x61, 0x66, 0x65, 0x33, 0x32, 0x30, 0x66, 0x38, 0x39, 0x61, 0x64, 0x35, 0x37, 0x39, 0x63, 0x66, 0x62, 0x34, 0x37, 0x33, 0x66, 0x31, 0x64, 0x65, 0x64, 0x33, 0x34, 0x38, 0x36, 0x34, 0x30, 0x66, 0x64, 0x36, 0x37, 0x32, 0x31, 0x34, 0x38, 0x35, 0x30, 0x66, 0x37, 0x64, 0x63, 0x30, 0x33, 0x39, 0x66, 0x64, 0x36, 0x62, 0x65, 0x39, 0x61, 0x63, 0x37, 0x61, 0x64, 0x34, 0x36, 0x32, 0x66, 0x62, 0x66, 0x62, 0x32, 0x35, 0x34, 0x34, 0x30, 0x38, 0x36, 0x63, 0x32, 0x37, 0x33, 0x38, 0x32, 0x31, 0x66, 0x30, 0x63, 0x37, 0x37, 0x34, 0x61, 0x36, 0x64, 0x65, 0x36, 0x38, 0x32, 0x65, 0x63, 0x33, 0x33, 0x30, 0x37, 0x32, 0x34, 0x32, 0x36, 0x34, 0x61, 0x62, 0x34, 0x31, 0x37, 0x31, 0x31, 0x37, 0x32, 0x39, 0x62, 0x61, 0x64, 0x37, 0x66, 0x34, 0x37, 0x39, 0x34, 0x64, 0x37, 0x38, 0x62, 0x38, 0x36, 0x39, 0x33, 0x64, 0x32, 0x65, 0x66, 0x35, 0x39, 0x61, 0x31, 0x64, 0x39, 0x36, 0x33, 0x33, 0x36, 0x61, 0x66, 0x33, 0x64, 0x34, 0x39, 0x38, 0x65, 0x36, 0x38, 0x33, 0x35, 0x38, 0x38, 0x36, 0x36, 0x36, 0x31, 0x33, 0x34, 0x39, 0x38, 0x66, 0x35, 0x39, 0x64, 0x65, 0x62, 0x66, 0x38, 0x38, 0x66, 0x61, 0x33, 0x36, 0x65, 0x61, 0x34, 0x37, 0x30, 0x63, 0x38, 0x38, 0x39, 0x36, 0x37, 0x61, 0x36, 0x62, 0x63, 0x63, 0x63, 0x32, 0x39, 0x31, 0x39, 0x35, 0x37, 0x31, 0x36, 0x32, 0x65, 0x34, 0x38, 0x38, 0x33, 0x65, 0x30, 0x66, 0x65, 0x31, 0x37, 0x33, 0x34, 0x34, 0x39, 0x61, 0x35, 0x62, 0x61, 0x31, 0x33, 0x63, 0x63, 0x36, 0x37, 0x61, 0x66, 0x62, 0x30, 0x34, 0x63, 0x30, 0x66, 0x32, 0x36, 0x62, 0x64, 0x63, 0x37, 0x31, 0x65, 0x32, 0x33, 0x39, 0x66, 0x37, 0x64, 0x36, 0x66, 0x31, 0x32, 0x37, 0x62, 0x62, 0x66, 0x61, 0x36, 0x33, 0x36, 0x39, 0x65, 0x65, 0x31, 0x62, 0x62, 0x34, 0x36, 0x66, 0x64, 0x39, 0x64, 0x33, 0x63, 0x66, 0x38, 0x31, 0x64, 0x61, 0x35, 0x62, 0x30, 0x36, 0x30, 0x32, 0x37, 0x32, 0x65, 0x39, 0x62, 0x65, 0x64, 0x39, 0x62, 0x37, 0x37, 0x64, 0x39, 0x36, 0x34, 0x37, 0x31, 0x35, 0x62, 0x38, 0x31, 0x30, 0x36, 0x61, 0x30, 0x32, 0x62, 0x30, 0x32, 0x39, 0x37, 0x39, 0x66, 0x33, 0x30, 0x62, 0x39, 0x35, 0x30, 0x39, 0x61, 0x37, 0x63, 0x63, 0x39, 0x62, 0x63, 0x36, 0x31, 0x35, 0x32, 0x34, 0x32, 0x63, 0x39, 0x37, 0x63, 0x37, 0x31, 0x31, 0x64, 0x65, 0x61, 0x37, 0x33, 0x30, 0x30, 0x30, 0x62, 0x37, 0x32, 0x37, 0x61, 0x64, 0x37, 0x66, 0x37, 0x34, 0x65, 0x65, 0x34, 0x35, 0x33, 0x32, 0x32, 0x34, 0x64, 0x30, 0x31, 0x61, 0x64, 0x32, 0x65, 0x33, 0x62, 0x34, 0x31, 0x38, 0x31, 0x38, 0x61, 0x36, 0x65, 0x65, 0x63, 0x39, 0x35, 0x37, 0x64, 0x38, 0x64, 0x65, 0x33, 0x66, 0x63, 0x65, 0x34, 0x32, 0x63, 0x36, 0x39, 0x62, 0x30, 0x65, 0x37, 0x32, 0x30, 0x65, 0x37, 0x32, 0x64, 0x35, 0x64, 0x63, 0x31, 0x36, 0x35, 0x37, 0x39, 0x62, 0x63, 0x61, 0x31, 0x32, 0x30, 0x66, 0x36, 0x33, 0x65, 0x61, 0x64, 0x38, 0x65, 0x34, 0x32, 0x30, 0x39, 0x30, 0x32, 0x62, 0x35, 0x64, 0x65, 0x61, 0x34, 0x39, 0x64, 0x64, 0x33, 0x39, 0x39, 0x61, 0x37, 0x36, 0x37, 0x65, 0x32, 0x61, 0x36, 0x39, 0x38, 0x34, 0x64, 0x65, 0x62, 0x63, 0x65, 0x33, 0x31, 0x36, 0x30, 0x66, 0x37, 0x32, 0x36, 0x30, 0x63, 0x61, 0x39, 0x62, 0x66, 0x31, 0x35, 0x39, 0x32, 0x33, 0x34, 0x33, 0x66, 0x32, 0x32, 0x62, 0x31, 0x30, 0x65, 0x65, 0x32, 0x61, 0x36, 0x39, 0x32, 0x36, 0x38, 0x37, 0x39, 0x31, 0x33, 0x33, 0x39, 0x34, 0x32, 0x31, 0x65, 0x63, 0x36, 0x33, 0x62, 0x36, 0x31, 0x30, 0x36, 0x38, 0x31, 0x65, 0x64, 0x39, 0x37, 0x36, 0x36, 0x32, 0x38, 0x66, 0x39, 0x38, 0x61, 0x61, 0x37, 0x32, 0x34, 0x32, 0x37, 0x31, 0x36, 0x30, 0x61, 0x34, 0x31, 0x63, 0x61, 0x30, 0x38, 0x64, 0x38, 0x66, 0x63, 0x37, 0x35, 0x32, 0x37, 0x32, 0x61, 0x36, 0x65, 0x31, 0x31, 0x65, 0x61, 0x63, 0x30, 0x38, 0x36, 0x64, 0x61, 0x64, 0x64, 0x65, 0x39, 0x65, 0x63, 0x35, 0x63, 0x34, 0x61, 0x34, 0x63, 0x65, 0x36, 0x30, 0x32, 0x35, 0x36, 0x32, 0x62, 0x37, 0x62, 0x31, 0x63, 0x65, 0x63, 0x64, 0x36, 0x31, 0x62, 0x34, 0x35, 0x34, 0x64, 0x61, 0x38, 0x33, 0x32, 0x37, 0x65, 0x62, 0x62, 0x33, 0x31, 0x66, 0x37, 0x31, 0x30, 0x32, 0x35, 0x66, 0x61, 0x39, 0x64, 0x30, 0x30, 0x36, 0x36, 0x39, 0x62, 0x61, 0x61, 0x34, 0x66, 0x61, 0x62, 0x63, 0x35, 0x37, 0x36, 0x36, 0x62, 0x61, 0x64, 0x64, 0x39, 0x36, 0x32, 0x32, 0x66, 0x37, 0x62, 0x37, 0x65, 0x65, 0x32, 0x31, 0x63, 0x38, 0x38, 0x64, 0x37, 0x32, 0x32, 0x66, 0x61, 0x32, 0x36, 0x65, 0x66, 0x66, 0x64, 0x65, 0x39, 0x62, 0x62, 0x63, 0x34, 0x66, 0x30, 0x38, 0x37, 0x65, 0x31, 0x35, 0x62, 0x39, 0x64, 0x32, 0x39, 0x38, 0x61, 0x36, 0x65, 0x30, 0x30, 0x61, 0x30, 0x32, 0x39, 0x32, 0x33, 0x37, 0x35, 0x34, 0x37, 0x64, 0x39, 0x64, 0x34, 0x66, 0x62, 0x34, 0x30, 0x33, 0x62, 0x38, 0x62, 0x36, 0x38, 0x32, 0x63, 0x65, 0x33, 0x38, 0x37, 0x32, 0x64, 0x35, 0x30, 0x39, 0x64, 0x63, 0x65, 0x32, 0x33, 0x35, 0x61, 0x61, 0x34, 0x61, 0x64, 0x61, 0x34, 0x66, 0x31, 0x36, 0x66, 0x65, 0x61, 0x61, 0x33, 0x62, 0x37, 0x66, 0x38, 0x31, 0x62, 0x36, 0x36, 0x34, 0x36, 0x31, 0x66, 0x33, 0x36, 0x31, 0x61, 0x37, 0x32, 0x39, 0x31, 0x61, 0x39, 0x63, 0x61, 0x30, 0x62, 0x37, 0x35, 0x32, 0x61, 0x33, 0x36, 0x34, 0x32, 0x36, 0x36, 0x64, 0x37, 0x32, 0x33, 0x38, 0x36, 0x32, 0x66, 0x64, 0x38, 0x37, 0x63, 0x30, 0x31, 0x36, 0x31, 0x62, 0x32, 0x31, 0x35, 0x63, 0x36, 0x39, 0x36, 0x36, 0x66, 0x34, 0x65, 0x63, 0x31, 0x36, 0x39, 0x38, 0x64, 0x62, 0x37, 0x66, 0x37, 0x31, 0x39, 0x31, 0x30, 0x64, 0x36, 0x66, 0x36, 0x31, 0x63, 0x38, 0x30, 0x61, 0x62, 0x34, 0x37, 0x35, 0x38, 0x32, 0x33, 0x66, 0x32, 0x36, 0x35, 0x65, 0x62, 0x32, 0x37, 0x32, 0x35, 0x62, 0x62, 0x30, 0x66, 0x32, 0x64, 0x36, 0x63, 0x34, 0x62, 0x31, 0x62, 0x36, 0x35, 0x37, 0x31, 0x36, 0x65, 0x61, 0x62, 0x32, 0x33, 0x62, 0x34, 0x34, 0x34, 0x35, 0x30, 0x35, 0x34, 0x39, 0x61, 0x37, 0x32, 0x34, 0x32, 0x32, 0x61, 0x35, 0x65, 0x31, 0x31, 0x31, 0x39, 0x66, 0x32, 0x33, 0x39, 0x32, 0x61, 0x63, 0x35, 0x35, 0x64, 0x32, 0x62, 0x39, 0x33, 0x37, 0x39, 0x33, 0x37, 0x32, 0x64, 0x34, 0x38, 0x66, 0x61, 0x35, 0x65, 0x63, 0x39, 0x31, 0x63, 0x31, 0x35, 0x62, 0x66, 0x37, 0x64, 0x62, 0x32, 0x65, 0x63, 0x33, 0x66, 0x34, 0x37, 0x39, 0x35, 0x63, 0x64, 0x39, 0x36, 0x37, 0x65, 0x39, 0x64, 0x61, 0x31, 0x63, 0x62, 0x63, 0x34, 0x30, 0x38, 0x33, 0x36, 0x63, 0x62, 0x37, 0x61, 0x62, 0x35, 0x39, 0x39, 0x35, 0x62, 0x39, 0x61, 0x34, 0x65, 0x63, 0x30, 0x31, 0x37, 0x32, 0x37, 0x66, 0x36, 0x34, 0x34, 0x31, 0x37, 0x33, 0x37, 0x39, 0x31, 0x61, 0x65, 0x31, 0x38, 0x33, 0x32, 0x64, 0x62, 0x36, 0x36, 0x35, 0x31, 0x30, 0x65, 0x65, 0x31, 0x32, 0x37, 0x31, 0x65, 0x31, 0x39, 0x66, 0x34, 0x38, 0x64, 0x39, 0x34, 0x35, 0x61, 0x62, 0x39, 0x62, 0x35, 0x65, 0x61, 0x37, 0x38, 0x33, 0x32, 0x32, 0x66, 0x61, 0x66, 0x38, 0x63, 0x33, 0x31, 0x61, 0x35, 0x33, 0x37, 0x32, 0x33, 0x32, 0x38, 0x30, 0x32, 0x30, 0x35, 0x31, 0x32, 0x30, 0x38, 0x37, 0x61, 0x34, 0x35, 0x30, 0x38, 0x62, 0x35, 0x65, 0x61, 0x34, 0x36, 0x62, 0x61, 0x37, 0x35, 0x35, 0x38, 0x65, 0x62, 0x30, 0x64, 0x33, 0x65, 0x64, 0x31, 0x32, 0x66, 0x65, 0x66, 0x34, 0x63, 0x63, 0x66, 0x63, 0x64, 0x66, 0x65, 0x66, 0x64, 0x38, 0x62, 0x61, 0x63, 0x65, 0x66, 0x36, 0x64, 0x37, 0x61, 0x32, 0x37, 0x32, 0x61, 0x64, 0x33, 0x65, 0x61, 0x66, 0x32, 0x39, 0x36, 0x64, 0x36, 0x31, 0x34, 0x34, 0x61, 0x39, 0x34, 0x30, 0x33, 0x61, 0x62, 0x38, 0x65, 0x30, 0x38, 0x34, 0x64, 0x38, 0x37, 0x64, 0x65, 0x37, 0x30, 0x34, 0x62, 0x30, 0x34, 0x66, 0x39, 0x39, 0x39, 0x66, 0x65, 0x61, 0x32, 0x62, 0x63, 0x30, 0x35, 0x31, 0x36, 0x37, 0x39, 0x65, 0x31, 0x62, 0x34, 0x30, 0x36, 0x64, 0x37, 0x33, 0x37, 0x32, 0x38, 0x62, 0x38, 0x37, 0x64, 0x62, 0x36, 0x62, 0x61, 0x63, 0x33, 0x30, 0x30, 0x63, 0x31, 0x39, 0x36, 0x38, 0x31, 0x36, 0x33, 0x61, 0x38, 0x66, 0x30, 0x33, 0x37, 0x64, 0x63, 0x62, 0x61, 0x65, 0x34, 0x62, 0x61, 0x31, 0x66, 0x34, 0x64, 0x35, 0x63, 0x65, 0x32, 0x37, 0x37, 0x61, 0x64, 0x61, 0x31, 0x63, 0x37, 0x64, 0x64, 0x65, 0x37, 0x35, 0x66, 0x38, 0x36, 0x33, 0x66, 0x31, 0x31, 0x37, 0x36, 0x30, 0x38, 0x38, 0x38, 0x62, 0x32, 0x30, 0x64, 0x62, 0x33, 0x37, 0x65, 0x37, 0x37, 0x34, 0x37, 0x34, 0x38, 0x63, 0x33, 0x62, 0x30, 0x64, 0x62, 0x39, 0x31, 0x64, 0x61, 0x62, 0x62, 0x38, 0x32, 0x34, 0x34, 0x37, 0x34, 0x33, 0x61, 0x62, 0x63, 0x38, 0x30, 0x63, 0x35, 0x39, 0x66, 0x34, 0x31, 0x61, 0x39, 0x33, 0x33, 0x36, 0x30, 0x34, 0x34, 0x34, 0x65, 0x31, 0x66, 0x63, 0x37, 0x32, 0x66, 0x62, 0x37, 0x39, 0x39, 0x61, 0x35, 0x33, 0x38, 0x61, 0x32, 0x39, 0x38, 0x65, 0x37, 0x34, 0x30, 0x34, 0x37, 0x32, 0x36, 0x61, 0x37, 0x35, 0x64, 0x36, 0x62, 0x33, 0x39, 0x30, 0x30, 0x36, 0x38, 0x61, 0x30, 0x61, 0x63, 0x33, 0x66, 0x37, 0x39, 0x38, 0x36, 0x64, 0x37, 0x61, 0x35, 0x34, 0x31, 0x34, 0x35, 0x33, 0x30, 0x33, 0x61, 0x63, 0x62, 0x31, 0x39, 0x64, 0x63, 0x35, 0x37, 0x32, 0x33, 0x39, 0x66, 0x63, 0x62, 0x36, 0x36, 0x34, 0x65, 0x65, 0x65, 0x34, 0x66, 0x38, 0x31, 0x30, 0x30, 0x64, 0x62, 0x64, 0x64, 0x30, 0x32, 0x65, 0x66, 0x33, 0x61, 0x31, 0x35, 0x39, 0x30, 0x30, 0x32, 0x31, 0x33, 0x66, 0x35, 0x63, 0x32, 0x33, 0x36, 0x35, 0x65, 0x36, 0x31, 0x38, 0x33, 0x65, 0x65, 0x64, 0x62, 0x39, 0x34, 0x64, 0x35, 0x61, 0x36, 0x33, 0x33, 0x65, 0x64, 0x39, 0x37, 0x32, 0x38, 0x34, 0x35, 0x36, 0x61, 0x62, 0x61, 0x61, 0x37, 0x61, 0x35, 0x34, 0x38, 0x31, 0x39, 0x30, 0x38, 0x37, 0x34, 0x64, 0x35, 0x66, 0x64, 0x64, 0x34, 0x37, 0x35, 0x36, 0x64, 0x64, 0x33, 0x31, 0x33, 0x31, 0x34, 0x35, 0x61, 0x66, 0x61, 0x62, 0x61, 0x61, 0x38, 0x38, 0x37, 0x32, 0x63, 0x65, 0x33, 0x38, 0x64, 0x61, 0x63, 0x61, 0x35, 0x30, 0x62, 0x64, 0x38, 0x38, 0x30, 0x36, 0x37, 0x32, 0x37, 0x32, 0x62, 0x62, 0x37, 0x62, 0x30, 0x66, 0x39, 0x39, 0x37, 0x61, 0x36, 0x34, 0x31, 0x35, 0x33, 0x30, 0x64, 0x30, 0x39, 0x62, 0x32, 0x33, 0x34, 0x35, 0x32, 0x66, 0x35, 0x31, 0x37, 0x36, 0x61, 0x33, 0x34, 0x32, 0x66, 0x33, 0x32, 0x38, 0x34, 0x62, 0x34, 0x33, 0x37, 0x37, 0x33, 0x31, 0x36, 0x33, 0x32, 0x34, 0x32, 0x39, 0x31, 0x64, 0x62, 0x31, 0x37, 0x62, 0x34, 0x62, 0x37, 0x32, 0x34, 0x30, 0x66, 0x37, 0x33, 0x33, 0x36, 0x66, 0x63, 0x36, 0x33, 0x32, 0x34, 0x39, 0x62, 0x37, 0x65, 0x66, 0x30, 0x39, 0x65, 0x31, 0x64, 0x30, 0x66, 0x34, 0x62, 0x66, 0x39, 0x38, 0x37, 0x38, 0x38, 0x35, 0x37, 0x38, 0x34, 0x37, 0x63, 0x38, 0x38, 0x32, 0x31, 0x65, 0x66, 0x64, 0x66, 0x35, 0x39, 0x34, 0x63, 0x38, 0x64, 0x32, 0x63, 0x63, 0x38, 0x62, 0x38, 0x63, 0x39, 0x63, 0x37, 0x32, 0x64, 0x39, 0x34, 0x31, 0x38, 0x34, 0x63, 0x66, 0x65, 0x32, 0x34, 0x65, 0x36, 0x61, 0x39, 0x31, 0x65, 0x66, 0x61, 0x37, 0x61, 0x36, 0x61, 0x64, 0x63, 0x63, 0x36, 0x34, 0x39, 0x34, 0x64, 0x30, 0x61, 0x35, 0x30, 0x38, 0x33, 0x35, 0x30, 0x32, 0x63, 0x31, 0x64, 0x63, 0x63, 0x35, 0x37, 0x34, 0x38, 0x33, 0x64, 0x31, 0x39, 0x36, 0x36, 0x65, 0x66, 0x30, 0x38, 0x34, 0x36, 0x66, 0x34, 0x39, 0x66, 0x36, 0x63, 0x35, 0x34, 0x64, 0x65, 0x61, 0x36, 0x32, 0x35, 0x32, 0x66, 0x31, 0x37, 0x32, 0x38, 0x33, 0x33, 0x33, 0x34, 0x30, 0x35, 0x62, 0x38, 0x66, 0x66, 0x34, 0x65, 0x30, 0x34, 0x31, 0x34, 0x32, 0x38, 0x35, 0x65, 0x31, 0x65, 0x63, 0x35, 0x64, 0x37, 0x62, 0x36, 0x65, 0x66, 0x35, 0x34, 0x37, 0x30, 0x62, 0x34, 0x63, 0x65, 0x37, 0x65, 0x37, 0x65, 0x66, 0x32, 0x33, 0x31, 0x32, 0x64, 0x66, 0x35, 0x33, 0x63, 0x30, 0x33, 0x33, 0x64, 0x64, 0x66, 0x38, 0x61, 0x36, 0x61, 0x35, 0x37, 0x36, 0x37, 0x63, 0x33, 0x30, 0x64, 0x37, 0x66, 0x61, 0x38, 0x36, 0x35, 0x63, 0x37, 0x36, 0x38, 0x38, 0x62, 0x32, 0x30, 0x33, 0x34, 0x34, 0x35, 0x33, 0x39, 0x38, 0x61, 0x34, 0x65, 0x30, 0x65, 0x65, 0x63, 0x65, 0x64, 0x37, 0x36, 0x62, 0x35, 0x31, 0x31, 0x39, 0x38, 0x31, 0x37, 0x32, 0x66, 0x32, 0x36, 0x33, 0x66, 0x31, 0x65, 0x65, 0x31, 0x30, 0x34, 0x61, 0x64, 0x35, 0x30, 0x35, 0x35, 0x31, 0x37, 0x65, 0x37, 0x63, 0x63, 0x30, 0x63, 0x33, 0x37, 0x35, 0x30, 0x35, 0x63, 0x32, 0x35, 0x34, 0x30, 0x33, 0x32, 0x62, 0x37, 0x62, 0x61, 0x38, 0x33, 0x62, 0x62, 0x64, 0x37, 0x63, 0x65, 0x62, 0x62, 0x36, 0x62, 0x39, 0x65, 0x62, 0x39, 0x61, 0x62, 0x32, 0x35, 0x33, 0x37, 0x32, 0x38, 0x38, 0x35, 0x63, 0x32, 0x66, 0x64, 0x36, 0x65, 0x33, 0x34, 0x36, 0x64, 0x32, 0x35, 0x37, 0x62, 0x33, 0x39, 0x35, 0x33, 0x62, 0x30, 0x63, 0x33, 0x31, 0x34, 0x65, 0x33, 0x66, 0x65, 0x34, 0x35, 0x35, 0x61, 0x30, 0x37, 0x38, 0x33, 0x66, 0x39, 0x37, 0x62, 0x66, 0x66, 0x64, 0x31, 0x38, 0x65, 0x62, 0x35, 0x35, 0x65, 0x39, 0x34, 0x38, 0x33, 0x34, 0x33, 0x66, 0x34, 0x33, 0x31, 0x30, 0x32, 0x32, 0x65, 0x34, 0x31, 0x37, 0x38, 0x61, 0x65, 0x34, 0x64, 0x36, 0x61, 0x31, 0x62, 0x32, 0x38, 0x39, 0x37, 0x38, 0x30, 0x64, 0x35, 0x30, 0x62, 0x65, 0x61, 0x39, 0x33, 0x33, 0x63, 0x30, 0x31, 0x31, 0x66, 0x37, 0x61, 0x61, 0x33, 0x36, 0x63, 0x66, 0x38, 0x61, 0x61, 0x31, 0x62, 0x30, 0x62, 0x33, 0x35, 0x35, 0x66, 0x65, 0x65, 0x35, 0x65, 0x63, 0x32, 0x35, 0x38, 0x61, 0x37, 0x32, 0x66, 0x65, 0x66, 0x39, 0x63, 0x35, 0x61, 0x63, 0x33, 0x30, 0x30, 0x65, 0x31, 0x38, 0x61, 0x64, 0x35, 0x30, 0x33, 0x38, 0x34, 0x62, 0x65, 0x34, 0x34, 0x33, 0x66, 0x32, 0x35, 0x39, 0x33, 0x36, 0x63, 0x33, 0x35, 0x62, 0x31, 0x32, 0x30, 0x38, 0x62, 0x30, 0x62, 0x61, 0x61, 0x62, 0x62, 0x38, 0x37, 0x61, 0x66, 0x65, 0x61, 0x39, 0x38, 0x32, 0x32, 0x37, 0x30, 0x38, 0x38, 0x63, 0x31, 0x37, 0x32, 0x61, 0x36, 0x63, 0x38, 0x62, 0x34, 0x31, 0x62, 0x62, 0x35, 0x64, 0x30, 0x64, 0x65, 0x32, 0x34, 0x37, 0x36, 0x31, 0x30, 0x61, 0x32, 0x65, 0x38, 0x64, 0x61, 0x38, 0x39, 0x62, 0x37, 0x66, 0x33, 0x36, 0x35, 0x39, 0x30, 0x33, 0x34, 0x61, 0x31, 0x34, 0x38, 0x36, 0x62, 0x36, 0x34, 0x65, 0x33, 0x38, 0x64, 0x61, 0x61, 0x63, 0x33, 0x62, 0x65, 0x66, 0x66, 0x32, 0x36, 0x62, 0x37, 0x32, 0x38, 0x34, 0x36, 0x65, 0x34, 0x63, 0x35, 0x66, 0x37, 0x30, 0x61, 0x64, 0x31, 0x39, 0x62, 0x63, 0x65, 0x62, 0x36, 0x35, 0x61, 0x35, 0x34, 0x33, 0x64, 0x66, 0x38, 0x62, 0x34, 0x36, 0x61, 0x36, 0x34, 0x37, 0x61, 0x31, 0x33, 0x65, 0x63, 0x36, 0x37, 0x65, 0x66, 0x37, 0x31, 0x36, 0x37, 0x32, 0x63, 0x63, 0x32, 0x31, 0x36, 0x39, 0x32, 0x34, 0x64, 0x32, 0x32, 0x34, 0x39, 0x31, 0x33, 0x38, 0x36, 0x34, 0x63, 0x35, 0x39, 0x34, 0x31, 0x61, 0x35, 0x35, 0x34, 0x63, 0x62, 0x38, 0x63, 0x32, 0x37, 0x37, 0x61, 0x62, 0x33, 0x38, 0x64, 0x34, 0x35, 0x66, 0x30, 0x31, 0x34, 0x35, 0x32, 0x30, 0x66, 0x65, 0x37, 0x39, 0x32, 0x35, 0x33, 0x63, 0x62, 0x39, 0x37, 0x30, 0x31, 0x34, 0x65, 0x33, 0x36, 0x64, 0x65, 0x38, 0x35, 0x61, 0x35, 0x31, 0x37, 0x62, 0x65, 0x65, 0x61, 0x32, 0x30, 0x64, 0x61, 0x33, 0x39, 0x39, 0x34, 0x38, 0x35, 0x31, 0x66, 0x39, 0x30, 0x34, 0x61, 0x31, 0x37, 0x35, 0x35, 0x36, 0x62, 0x38, 0x34, 0x66, 0x64, 0x61, 0x38, 0x38, 0x38, 0x31, 0x33, 0x62, 0x36, 0x62, 0x64, 0x33, 0x64, 0x36, 0x63, 0x35, 0x30, 0x61, 0x65, 0x33, 0x64, 0x65, 0x65, 0x63, 0x36, 0x39, 0x64, 0x33, 0x65, 0x64, 0x37, 0x31, 0x31, 0x61, 0x32, 0x39, 0x64, 0x31, 0x37, 0x65, 0x31, 0x64, 0x64, 0x33, 0x38, 0x64, 0x39, 0x65, 0x31, 0x32, 0x66, 0x37, 0x62, 0x36, 0x65, 0x32, 0x66, 0x30, 0x64, 0x61, 0x33, 0x66, 0x31, 0x32, 0x32, 0x33, 0x64, 0x63, 0x35, 0x61, 0x62, 0x65, 0x35, 0x62, 0x37, 0x32, 0x65, 0x37, 0x39, 0x37, 0x66, 0x34, 0x39, 0x33, 0x61, 0x61, 0x64, 0x61, 0x62, 0x30, 0x38, 0x66, 0x64, 0x32, 0x34, 0x34, 0x64, 0x66, 0x31, 0x32, 0x31, 0x62, 0x34, 0x64, 0x36, 0x35, 0x63, 0x63, 0x31, 0x65, 0x35, 0x32, 0x65, 0x66, 0x38, 0x38, 0x66, 0x33, 0x33, 0x38, 0x30, 0x64, 0x38, 0x64, 0x31, 0x35, 0x64, 0x65, 0x65, 0x61, 0x36, 0x36, 0x62, 0x61, 0x37, 0x31, 0x39, 0x34, 0x31, 0x39, 0x61, 0x30, 0x32, 0x66, 0x65, 0x30, 0x31, 0x30, 0x63, 0x66, 0x66, 0x63, 0x33, 0x65, 0x37, 0x64, 0x35, 0x31, 0x61, 0x34, 0x62, 0x64, 0x63, 0x34, 0x63, 0x31, 0x34, 0x66, 0x31, 0x39, 0x36, 0x37, 0x34, 0x32, 0x39, 0x64, 0x64, 0x30, 0x62, 0x63, 0x34, 0x65, 0x30, 0x37, 0x62, 0x66, 0x36, 0x63, 0x39, 0x34, 0x65, 0x66, 0x35, 0x37, 0x36, 0x32, 0x66, 0x63, 0x37, 0x38, 0x33, 0x64, 0x37, 0x62, 0x34, 0x64, 0x33, 0x66, 0x33, 0x65, 0x62, 0x37, 0x33, 0x65, 0x35, 0x62, 0x63, 0x64, 0x35, 0x37, 0x63, 0x66, 0x35, 0x64, 0x39, 0x32, 0x36, 0x35, 0x37, 0x33, 0x31, 0x35, 0x37, 0x32, 0x35, 0x63, 0x66, 0x64, 0x39, 0x63, 0x34, 0x38, 0x32, 0x32, 0x32, 0x31, 0x36, 0x34, 0x63, 0x38, 0x62, 0x35, 0x37, 0x62, 0x63, 0x61, 0x65, 0x61, 0x62, 0x37, 0x64, 0x64, 0x30, 0x61, 0x31, 0x30, 0x62, 0x63, 0x30, 0x38, 0x31, 0x38, 0x65, 0x34, 0x38, 0x65, 0x36, 0x61, 0x62, 0x66, 0x33, 0x32, 0x38, 0x33, 0x38, 0x34, 0x34, 0x62, 0x61, 0x31, 0x33, 0x66, 0x36, 0x61, 0x63, 0x61, 0x37, 0x32, 0x63, 0x37, 0x33, 0x63, 0x65, 0x64, 0x63, 0x62, 0x61, 0x62, 0x65, 0x30, 0x39, 0x39, 0x39, 0x32, 0x33, 0x63, 0x37, 0x37, 0x39, 0x39, 0x36, 0x38, 0x30, 0x61, 0x30, 0x37, 0x33, 0x66, 0x64, 0x39, 0x62, 0x37, 0x31, 0x63, 0x31, 0x38, 0x34, 0x30, 0x64, 0x35, 0x37, 0x36, 0x61, 0x62, 0x34, 0x63, 0x37, 0x63, 0x63, 0x32, 0x62, 0x61, 0x64, 0x64, 0x36, 0x33, 0x32, 0x37, 0x66, 0x32, 0x33, 0x62, 0x35, 0x64, 0x36, 0x35, 0x31, 0x62, 0x65, 0x31, 0x39, 0x35, 0x61, 0x33, 0x37, 0x65, 0x34, 0x64, 0x61, 0x31, 0x61, 0x31, 0x65, 0x32, 0x31, 0x35, 0x63, 0x65, 0x37, 0x64, 0x34, 0x61, 0x66, 0x39, 0x63, 0x30, 0x33, 0x35, 0x34, 0x62, 0x32, 0x63, 0x63, 0x31, 0x36, 0x39, 0x32, 0x61, 0x37, 0x35, 0x36, 0x62, 0x36, 0x31, 0x35, 0x64, 0x37, 0x31, 0x61, 0x34, 0x34, 0x38, 0x33, 0x32, 0x37, 0x32, 0x37, 0x38, 0x63, 0x34, 0x37, 0x39, 0x30, 0x30, 0x39, 0x35, 0x32, 0x34, 0x35, 0x39, 0x64, 0x64, 0x36, 0x30, 0x36, 0x61, 0x30, 0x66, 0x38, 0x38, 0x34, 0x32, 0x35, 0x64, 0x32, 0x65, 0x37, 0x64, 0x35, 0x62, 0x36, 0x31, 0x61, 0x62, 0x31, 0x35, 0x30, 0x36, 0x66, 0x31, 0x33, 0x36, 0x66, 0x36, 0x62, 0x31, 0x39, 0x34, 0x66, 0x37, 0x64, 0x31, 0x64, 0x34, 0x65, 0x33, 0x63, 0x30, 0x37, 0x32, 0x31, 0x38, 0x66, 0x66, 0x37, 0x65, 0x37, 0x34, 0x66, 0x38, 0x61, 0x34, 0x61, 0x37, 0x61, 0x38, 0x34, 0x62, 0x62, 0x31, 0x64, 0x64, 0x63, 0x64, 0x63, 0x64, 0x36, 0x36, 0x66, 0x63, 0x30, 0x38, 0x34, 0x63, 0x38, 0x34, 0x33, 0x37, 0x66, 0x39, 0x34, 0x63, 0x39, 0x36, 0x37, 0x63, 0x62, 0x39, 0x35, 0x33, 0x34, 0x32, 0x39, 0x66, 0x33, 0x36, 0x32, 0x37, 0x62, 0x37, 0x39, 0x65, 0x31, 0x65, 0x31, 0x36, 0x34, 0x30, 0x38, 0x39, 0x64, 0x35, 0x64, 0x65, 0x64, 0x38, 0x33, 0x30, 0x38, 0x33, 0x30, 0x30, 0x64, 0x30, 0x63, 0x66, 0x65, 0x62, 0x37, 0x35, 0x31, 0x66, 0x66, 0x31, 0x37, 0x65, 0x33, 0x31, 0x35, 0x36, 0x38, 0x39, 0x37, 0x64, 0x33, 0x39, 0x65, 0x32, 0x66, 0x39, 0x64, 0x66, 0x35, 0x39, 0x61, 0x65, 0x64, 0x33, 0x63, 0x34, 0x31, 0x37, 0x62, 0x35, 0x35, 0x35, 0x32, 0x36, 0x63, 0x34, 0x32, 0x62, 0x35, 0x64, 0x39, 0x34, 0x65, 0x61, 0x36, 0x62, 0x66, 0x30, 0x32, 0x65, 0x34, 0x63, 0x32, 0x39, 0x61, 0x66, 0x61, 0x33, 0x39, 0x33, 0x61, 0x62, 0x39, 0x63, 0x61, 0x65, 0x33, 0x64, 0x66, 0x30, 0x31, 0x32, 0x64, 0x35, 0x62, 0x65, 0x38, 0x37, 0x37, 0x39, 0x34, 0x62, 0x33, 0x64, 0x35, 0x65, 0x37, 0x61, 0x30, 0x66, 0x64, 0x35, 0x36, 0x30, 0x33, 0x64, 0x34, 0x64, 0x30, 0x35, 0x65, 0x62, 0x62, 0x39, 0x64, 0x38, 0x36, 0x35, 0x31, 0x31, 0x38, 0x64, 0x35, 0x36, 0x30, 0x63, 0x65, 0x30, 0x65, 0x62, 0x37, 0x36, 0x39, 0x35, 0x30, 0x63, 0x37, 0x61, 0x65, 0x38, 0x37, 0x64, 0x62, 0x65, 0x39, 0x66, 0x62, 0x33, 0x63, 0x35, 0x38, 0x32, 0x33, 0x63, 0x36, 0x63, 0x38, 0x30, 0x61, 0x39, 0x33, 0x65, 0x64, 0x35, 0x32, 0x34, 0x63, 0x38, 0x64, 0x61, 0x37, 0x32, 0x62, 0x36, 0x39, 0x32, 0x37, 0x36, 0x36, 0x30, 0x36, 0x32, 0x39, 0x64, 0x32, 0x62, 0x37, 0x39, 0x34, 0x35, 0x66, 0x35, 0x35, 0x65, 0x66, 0x36, 0x32, 0x65, 0x34, 0x36, 0x65, 0x32, 0x33, 0x30, 0x31, 0x34, 0x38, 0x35, 0x31, 0x31, 0x66, 0x35, 0x35, 0x65, 0x32, 0x35, 0x31, 0x38, 0x61, 0x33, 0x30, 0x33, 0x34, 0x62, 0x63, 0x38, 0x64, 0x62, 0x63, 0x30, 0x61, 0x62, 0x34, 0x39, 0x31, 0x30, 0x37, 0x39, 0x62, 0x33, 0x61, 0x30, 0x39, 0x61, 0x35, 0x33, 0x33, 0x36, 0x38, 0x38, 0x33, 0x34, 0x37, 0x32, 0x31, 0x36, 0x64, 0x30, 0x62, 0x39, 0x33, 0x39, 0x31, 0x61, 0x61, 0x31, 0x65, 0x30, 0x33, 0x63, 0x64, 0x33, 0x61, 0x39, 0x30, 0x32, 0x32, 0x32, 0x37, 0x33, 0x39, 0x61, 0x33, 0x36, 0x62, 0x30, 0x34, 0x63, 0x36, 0x33, 0x35, 0x36, 0x32, 0x39, 0x39, 0x61, 0x64, 0x63, 0x36, 0x63, 0x31, 0x36, 0x64, 0x32, 0x39, 0x37, 0x31, 0x65, 0x37, 0x63, 0x65, 0x61, 0x64, 0x36, 0x30, 0x63, 0x65, 0x32, 0x64, 0x31, 0x62, 0x33, 0x30, 0x34, 0x30, 0x62, 0x62, 0x61, 0x64, 0x61, 0x61, 0x34, 0x61, 0x30, 0x66, 0x31, 0x38, 0x65, 0x30, 0x38, 0x31, 0x30, 0x32, 0x35, 0x34, 0x34, 0x63, 0x61, 0x38, 0x64, 0x62, 0x38, 0x65, 0x34, 0x36, 0x32, 0x39, 0x61, 0x32, 0x64, 0x31, 0x62, 0x37, 0x32, 0x64, 0x32, 0x62, 0x61, 0x30, 0x62, 0x63, 0x62, 0x35, 0x30, 0x35, 0x61, 0x36, 0x39, 0x64, 0x39, 0x31, 0x65, 0x64, 0x37, 0x36, 0x33, 0x66, 0x34, 0x35, 0x34, 0x63, 0x35, 0x36, 0x62, 0x38, 0x65, 0x62, 0x34, 0x34, 0x38, 0x32, 0x30, 0x32, 0x65, 0x39, 0x61, 0x33, 0x61, 0x32, 0x31, 0x63, 0x37, 0x38, 0x37, 0x37, 0x33, 0x31, 0x63, 0x38, 0x34, 0x30, 0x30, 0x35, 0x65, 0x65, 0x30, 0x30, 0x32, 0x34, 0x31, 0x32, 0x38, 0x61, 0x37, 0x66, 0x30, 0x63, 0x66, 0x64, 0x63, 0x61, 0x64, 0x38, 0x35, 0x32, 0x65, 0x62, 0x35, 0x33, 0x31, 0x65, 0x63, 0x65, 0x64, 0x66, 0x61, 0x39, 0x63, 0x66, 0x33, 0x34, 0x62, 0x63, 0x61, 0x37, 0x35, 0x65, 0x66, 0x36, 0x31, 0x34, 0x64, 0x30, 0x33, 0x34, 0x66, 0x37, 0x63, 0x34, 0x38, 0x39, 0x66, 0x65, 0x64, 0x34, 0x34, 0x65, 0x31, 0x32, 0x65, 0x37, 0x32, 0x34, 0x65, 0x31, 0x63, 0x63, 0x33, 0x30, 0x35, 0x62, 0x63, 0x39, 0x62, 0x37, 0x32, 0x36, 0x35, 0x62, 0x35, 0x38, 0x66, 0x37, 0x31, 0x37, 0x37, 0x39, 0x37, 0x65, 0x35, 0x62, 0x30, 0x33, 0x35, 0x32, 0x31, 0x66, 0x33, 0x30, 0x31, 0x33, 0x35, 0x38, 0x34, 0x61, 0x37, 0x38, 0x66, 0x30, 0x31, 0x30, 0x36, 0x66, 0x35, 0x61, 0x33, 0x61, 0x66, 0x33, 0x39, 0x33, 0x37, 0x31, 0x36, 0x30, 0x63, 0x63, 0x33, 0x36, 0x65, 0x39, 0x66, 0x65, 0x39, 0x34, 0x61, 0x66, 0x64, 0x37, 0x37, 0x39, 0x30, 0x38, 0x32, 0x35, 0x38, 0x33, 0x33, 0x31, 0x62, 0x30, 0x63, 0x35, 0x31, 0x62, 0x35, 0x37, 0x38, 0x63, 0x62, 0x34, 0x65, 0x61, 0x63, 0x39, 0x34, 0x34, 0x34, 0x66, 0x61, 0x63, 0x62, 0x34, 0x65, 0x35, 0x31, 0x62, 0x64, 0x31, 0x38, 0x64, 0x32, 0x63, 0x65, 0x39, 0x37, 0x64, 0x65, 0x35, 0x37, 0x36, 0x33, 0x65, 0x35, 0x61, 0x37, 0x66, 0x33, 0x61, 0x33, 0x64, 0x64, 0x35, 0x35, 0x30, 0x33, 0x64, 0x33, 0x36, 0x63, 0x37, 0x35, 0x33, 0x37, 0x65, 0x34, 0x38, 0x34, 0x62, 0x65, 0x61, 0x36, 0x32, 0x34, 0x32, 0x65, 0x38, 0x36, 0x39, 0x34, 0x31, 0x66, 0x66, 0x64, 0x36, 0x61, 0x64, 0x35, 0x32, 0x31, 0x32, 0x37, 0x66, 0x63, 0x37, 0x61, 0x66, 0x64, 0x38, 0x38, 0x64, 0x34, 0x37, 0x32, 0x36, 0x33, 0x35, 0x36, 0x31, 0x38, 0x33, 0x33, 0x38, 0x32, 0x64, 0x61, 0x32, 0x37, 0x31, 0x37, 0x32, 0x31, 0x33, 0x32, 0x62, 0x61, 0x30, 0x31, 0x35, 0x37, 0x34, 0x64, 0x38, 0x30, 0x61, 0x38, 0x61, 0x63, 0x37, 0x62, 0x31, 0x63, 0x63, 0x37, 0x39, 0x39, 0x36, 0x33, 0x32, 0x35, 0x35, 0x62, 0x30, 0x34, 0x30, 0x37, 0x64, 0x30, 0x30, 0x63, 0x36, 0x31, 0x32, 0x63, 0x37, 0x65, 0x37, 0x32, 0x37, 0x66, 0x62, 0x31, 0x35, 0x34, 0x31, 0x30, 0x31, 0x66, 0x30, 0x30, 0x30, 0x36, 0x37, 0x62, 0x36, 0x33, 0x30, 0x33, 0x37, 0x30, 0x66, 0x33, 0x64, 0x35, 0x34, 0x38, 0x36, 0x62, 0x32, 0x39, 0x65, 0x34, 0x36, 0x39, 0x63, 0x33, 0x62, 0x38, 0x32, 0x64, 0x63, 0x65, 0x33, 0x63, 0x33, 0x63, 0x62, 0x34, 0x33, 0x30, 0x61, 0x39, 0x62, 0x63, 0x65, 0x37, 0x64, 0x30, 0x66, 0x33, 0x37, 0x32, 0x63, 0x37, 0x63, 0x38, 0x63, 0x35, 0x31, 0x32, 0x65, 0x31, 0x34, 0x61, 0x35, 0x38, 0x63, 0x66, 0x31, 0x34, 0x63, 0x66, 0x39, 0x65, 0x66, 0x33, 0x34, 0x37, 0x62, 0x35, 0x65, 0x36, 0x66, 0x61, 0x66, 0x35, 0x65, 0x61, 0x36, 0x64, 0x61, 0x38, 0x62, 0x33, 0x33, 0x65, 0x63, 0x30, 0x32, 0x61, 0x39, 0x38, 0x31, 0x33, 0x64, 0x39, 0x34, 0x35, 0x35, 0x63, 0x33, 0x61, 0x64, 0x32, 0x37, 0x32, 0x37, 0x33, 0x34, 0x39, 0x64, 0x31, 0x39, 0x66, 0x66, 0x64, 0x30, 0x64, 0x36, 0x39, 0x33, 0x37, 0x63, 0x62, 0x36, 0x32, 0x32, 0x38, 0x61, 0x32, 0x36, 0x32, 0x34, 0x64, 0x37, 0x63, 0x31, 0x33, 0x34, 0x66, 0x63, 0x35, 0x32, 0x32, 0x34, 0x36, 0x30, 0x32, 0x34, 0x38, 0x39, 0x38, 0x31, 0x64, 0x31, 0x63, 0x30, 0x36, 0x33, 0x36, 0x62, 0x32, 0x66, 0x63, 0x65, 0x63, 0x65, 0x35, 0x31, 0x63, 0x37, 0x35, 0x32, 0x62, 0x30, 0x37, 0x35, 0x66, 0x35, 0x61, 0x31, 0x61, 0x38, 0x62, 0x33, 0x31, 0x38, 0x62, 0x35, 0x32, 0x64, 0x61, 0x36, 0x35, 0x34, 0x32, 0x33, 0x63, 0x31, 0x65, 0x64, 0x66, 0x37, 0x62, 0x31, 0x66, 0x33, 0x37, 0x62, 0x61, 0x35, 0x32, 0x38, 0x35, 0x63, 0x65, 0x64, 0x30, 0x34, 0x35, 0x62, 0x37, 0x63, 0x65, 0x66, 0x64, 0x38, 0x63, 0x36, 0x63, 0x61, 0x38, 0x33, 0x39, 0x35, 0x37, 0x38, 0x66, 0x32, 0x65, 0x37, 0x63, 0x62, 0x32, 0x62, 0x61, 0x33, 0x30, 0x31, 0x34, 0x64, 0x64, 0x33, 0x37, 0x30, 0x30, 0x34, 0x37, 0x34, 0x65, 0x36, 0x32, 0x35, 0x62, 0x34, 0x66, 0x38, 0x39, 0x31, 0x35, 0x38, 0x65, 0x39, 0x37, 0x63, 0x32, 0x64, 0x33, 0x65, 0x66, 0x64, 0x66, 0x31, 0x33, 0x64, 0x39, 0x38, 0x30, 0x33, 0x31, 0x64, 0x39, 0x32, 0x31, 0x37, 0x36, 0x37, 0x32, 0x66, 0x35, 0x35, 0x63, 0x36, 0x31, 0x32, 0x64, 0x37, 0x35, 0x64, 0x35, 0x31, 0x63, 0x63, 0x63, 0x36, 0x66, 0x66, 0x64, 0x62, 0x35, 0x37, 0x35, 0x39, 0x61, 0x36, 0x35, 0x38, 0x31, 0x36, 0x61, 0x30, 0x35, 0x61, 0x61, 0x65, 0x36, 0x62, 0x34, 0x38, 0x30, 0x30, 0x35, 0x39, 0x39, 0x36, 0x37, 0x39, 0x39, 0x66, 0x34, 0x35, 0x36, 0x38, 0x63, 0x66, 0x63, 0x31, 0x61, 0x37, 0x63, 0x37, 0x32, 0x62, 0x39, 0x63, 0x36, 0x31, 0x31, 0x32, 0x34, 0x63, 0x39, 0x65, 0x66, 0x37, 0x35, 0x39, 0x35, 0x36, 0x31, 0x33, 0x30, 0x38, 0x61, 0x62, 0x31, 0x36, 0x62, 0x32, 0x37, 0x32, 0x31, 0x61, 0x61, 0x66, 0x36, 0x66, 0x31, 0x32, 0x30, 0x30, 0x39, 0x36, 0x38, 0x30, 0x31, 0x32, 0x30, 0x35, 0x38, 0x31, 0x38, 0x61, 0x30, 0x33, 0x38, 0x63, 0x32, 0x30, 0x39, 0x37, 0x36, 0x36, 0x66, 0x32, 0x64, 0x39, 0x34, 0x64, 0x30, 0x35, 0x34, 0x66, 0x63, 0x37, 0x33, 0x32, 0x38, 0x63, 0x62, 0x35, 0x66, 0x37, 0x35, 0x36, 0x63, 0x63, 0x66, 0x65, 0x61, 0x65, 0x34, 0x34, 0x36, 0x36, 0x35, 0x37, 0x30, 0x36, 0x32, 0x38, 0x34, 0x33, 0x61, 0x39, 0x34, 0x34, 0x35, 0x32, 0x36, 0x31, 0x33, 0x38, 0x65, 0x64, 0x34, 0x37, 0x64, 0x38, 0x37, 0x38, 0x37, 0x66, 0x31, 0x33, 0x64, 0x31, 0x33, 0x37, 0x32, 0x36, 0x33, 0x61, 0x64, 0x65, 0x39, 0x66, 0x35, 0x33, 0x39, 0x37, 0x34, 0x66, 0x34, 0x66, 0x66, 0x31, 0x32, 0x66, 0x30, 0x66, 0x31, 0x39, 0x61, 0x37, 0x32, 0x37, 0x35, 0x38, 0x64, 0x36, 0x36, 0x64, 0x35, 0x38, 0x34, 0x32, 0x38, 0x66, 0x61, 0x64, 0x37, 0x61, 0x37, 0x61, 0x65, 0x34, 0x39, 0x39, 0x64, 0x66, 0x30, 0x64, 0x33, 0x39, 0x38, 0x31, 0x39, 0x31, 0x62, 0x62, 0x37, 0x37, 0x32, 0x39, 0x32, 0x61, 0x34, 0x37, 0x32, 0x39, 0x34, 0x31, 0x33, 0x38, 0x32, 0x36, 0x34, 0x63, 0x66, 0x62, 0x30, 0x36, 0x35, 0x36, 0x63, 0x65, 0x34, 0x62, 0x30, 0x31, 0x33, 0x62, 0x32, 0x34, 0x61, 0x61, 0x62, 0x33, 0x63, 0x37, 0x39, 0x33, 0x64, 0x34, 0x34, 0x32, 0x35, 0x38, 0x36, 0x31, 0x36, 0x31, 0x38, 0x62, 0x32, 0x61, 0x33, 0x34, 0x37, 0x65, 0x32, 0x30, 0x34, 0x62, 0x33, 0x32, 0x34, 0x35, 0x31, 0x38, 0x66, 0x63, 0x63, 0x62, 0x35, 0x36, 0x61, 0x33, 0x61, 0x63, 0x66, 0x36, 0x32, 0x38, 0x38, 0x39, 0x35, 0x64, 0x35, 0x33, 0x66, 0x34, 0x31, 0x31, 0x31, 0x30, 0x36, 0x34, 0x61, 0x63, 0x36, 0x38, 0x64, 0x33, 0x36, 0x36, 0x66, 0x33, 0x61, 0x66, 0x33, 0x38, 0x35, 0x63, 0x63, 0x66, 0x30, 0x33, 0x65, 0x35, 0x35, 0x63, 0x35, 0x63, 0x38, 0x66, 0x30, 0x34, 0x38, 0x31, 0x61, 0x65, 0x61, 0x36, 0x39, 0x66, 0x62, 0x35, 0x63, 0x35, 0x31, 0x65, 0x65, 0x38, 0x36, 0x61, 0x66, 0x30, 0x37, 0x35, 0x30, 0x62, 0x35, 0x32, 0x66, 0x62, 0x34, 0x39, 0x37, 0x38, 0x63, 0x32, 0x65, 0x31, 0x31, 0x30, 0x39, 0x66, 0x35, 0x32, 0x63, 0x35, 0x30, 0x65, 0x32, 0x66, 0x34, 0x31, 0x66, 0x34, 0x61, 0x39, 0x32, 0x65, 0x33, 0x35, 0x37, 0x64, 0x62, 0x61, 0x66, 0x31, 0x65, 0x37, 0x32, 0x64, 0x36, 0x31, 0x66, 0x37, 0x33, 0x65, 0x39, 0x35, 0x66, 0x62, 0x65, 0x66, 0x64, 0x64, 0x34, 0x39, 0x61, 0x37, 0x34, 0x37, 0x37, 0x31, 0x33, 0x31, 0x66, 0x32, 0x65, 0x64, 0x63, 0x30, 0x39, 0x31, 0x36, 0x61, 0x36, 0x31, 0x66, 0x64, 0x34, 0x30, 0x37, 0x63, 0x32, 0x33, 0x65, 0x31, 0x64, 0x36, 0x36, 0x30, 0x33, 0x37, 0x36, 0x65, 0x31, 0x34, 0x39, 0x35, 0x66, 0x61, 0x37, 0x37, 0x32, 0x35, 0x36, 0x34, 0x61, 0x35, 0x62, 0x63, 0x61, 0x64, 0x36, 0x36, 0x63, 0x34, 0x34, 0x65, 0x63, 0x61, 0x34, 0x61, 0x61, 0x39, 0x63, 0x32, 0x33, 0x32, 0x34, 0x34, 0x61, 0x36, 0x39, 0x35, 0x34, 0x35, 0x66, 0x38, 0x36, 0x38, 0x33, 0x64, 0x35, 0x36, 0x64, 0x38, 0x63, 0x61, 0x33, 0x30, 0x35, 0x62, 0x39, 0x33, 0x63, 0x63, 0x39, 0x66, 0x38, 0x32, 0x35, 0x36, 0x62, 0x30, 0x66, 0x35, 0x62, 0x64, 0x36, 0x39, 0x61, 0x31, 0x37, 0x32, 0x65, 0x30, 0x38, 0x37, 0x61, 0x66, 0x32, 0x65, 0x66, 0x36, 0x36, 0x63, 0x61, 0x38, 0x33, 0x39, 0x38, 0x34, 0x37, 0x34, 0x66, 0x39, 0x36, 0x61, 0x64, 0x36, 0x35, 0x32, 0x34, 0x62, 0x38, 0x31, 0x63, 0x34, 0x32, 0x36, 0x36, 0x65, 0x65, 0x32, 0x39, 0x34, 0x66, 0x39, 0x63, 0x33, 0x31, 0x30, 0x65, 0x35, 0x61, 0x34, 0x35, 0x37, 0x63, 0x37, 0x32, 0x35, 0x37, 0x31, 0x37, 0x37, 0x39, 0x64, 0x66, 0x39, 0x36, 0x30, 0x38, 0x63, 0x61, 0x32, 0x64, 0x31, 0x66, 0x32, 0x61, 0x33, 0x64, 0x61, 0x63, 0x64, 0x61, 0x39, 0x36, 0x30, 0x62, 0x34, 0x63, 0x39, 0x38, 0x31, 0x38, 0x38, 0x66, 0x39, 0x31, 0x34, 0x63, 0x66, 0x34, 0x32, 0x30, 0x63, 0x66, 0x66, 0x34, 0x36, 0x39, 0x63, 0x62, 0x37, 0x32, 0x36, 0x64, 0x37, 0x31, 0x32, 0x35, 0x36, 0x61, 0x63, 0x33, 0x33, 0x34, 0x36, 0x31, 0x35, 0x62, 0x38, 0x36, 0x32, 0x66, 0x61, 0x62, 0x36, 0x63, 0x39, 0x36, 0x30, 0x33, 0x66, 0x37, 0x62, 0x33, 0x36, 0x39, 0x31, 0x64, 0x63, 0x30, 0x66, 0x61, 0x39, 0x38, 0x65, 0x63, 0x37, 0x62, 0x66, 0x37, 0x66, 0x37, 0x34, 0x62, 0x30, 0x30, 0x30, 0x61, 0x36, 0x35, 0x39, 0x61, 0x63, 0x61, 0x30, 0x34, 0x34, 0x38, 0x35, 0x35, 0x36, 0x63, 0x37, 0x32, 0x34, 0x36, 0x30, 0x35, 0x33, 0x32, 0x62, 0x37, 0x32, 0x38, 0x32, 0x34, 0x39, 0x33, 0x36, 0x65, 0x35, 0x66, 0x31, 0x62, 0x39, 0x64, 0x30, 0x31, 0x61, 0x32, 0x34, 0x65, 0x61, 0x66, 0x64, 0x36, 0x62, 0x32, 0x38, 0x62, 0x32, 0x65, 0x63, 0x31, 0x35, 0x66, 0x34, 0x36, 0x63, 0x62, 0x39, 0x65, 0x31, 0x39, 0x35, 0x33, 0x62, 0x64, 0x64, 0x39, 0x32, 0x62, 0x37, 0x31, 0x65, 0x32, 0x34, 0x37, 0x31, 0x35, 0x36, 0x66, 0x31, 0x64, 0x30, 0x34, 0x62, 0x38, 0x38, 0x61, 0x66, 0x36, 0x66, 0x39, 0x62, 0x64, 0x38, 0x38, 0x35, 0x33, 0x30, 0x65, 0x37, 0x66, 0x34, 0x33, 0x61, 0x31, 0x31, 0x38, 0x63, 0x36, 0x65, 0x31, 0x65, 0x33, 0x34, 0x37, 0x62, 0x65, 0x37, 0x65, 0x39, 0x61, 0x37, 0x35, 0x39, 0x35, 0x38, 0x37, 0x39, 0x39, 0x30, 0x36, 0x62, 0x66, 0x36, 0x66, 0x61, 0x61, 0x32, 0x30, 0x64, 0x38, 0x64, 0x31, 0x34, 0x39, 0x66, 0x64, 0x39, 0x64, 0x64, 0x35, 0x61, 0x38, 0x32, 0x32, 0x39, 0x34, 0x65, 0x63, 0x66, 0x34, 0x64, 0x33, 0x66, 0x37, 0x35, 0x64, 0x39, 0x30, 0x63, 0x61, 0x33, 0x63, 0x64, 0x64, 0x65, 0x64, 0x36, 0x31, 0x39, 0x66, 0x31, 0x34, 0x34, 0x32, 0x62, 0x62, 0x63, 0x64, 0x37, 0x35, 0x33, 0x62, 0x37, 0x30, 0x35, 0x65, 0x66, 0x33, 0x39, 0x64, 0x32, 0x62, 0x30, 0x61, 0x64, 0x30, 0x31, 0x30, 0x63, 0x65, 0x64, 0x66, 0x64, 0x62, 0x30, 0x62, 0x64, 0x37, 0x61, 0x65, 0x39, 0x36, 0x39, 0x65, 0x35, 0x62, 0x36, 0x39, 0x32, 0x35, 0x66, 0x63, 0x35, 0x30, 0x64, 0x39, 0x31, 0x37, 0x36, 0x34, 0x32, 0x32, 0x62, 0x66, 0x37, 0x36, 0x62, 0x30, 0x33, 0x39, 0x31, 0x66, 0x32, 0x65, 0x62, 0x36, 0x32, 0x36, 0x64, 0x35, 0x34, 0x61, 0x61, 0x32, 0x37, 0x32, 0x35, 0x30, 0x62, 0x37, 0x34, 0x64, 0x37, 0x33, 0x37, 0x31, 0x61, 0x39, 0x37, 0x35, 0x62, 0x36, 0x32, 0x32, 0x31, 0x32, 0x63, 0x36, 0x66, 0x32, 0x61, 0x31, 0x37, 0x32, 0x31, 0x35, 0x30, 0x37, 0x36, 0x35, 0x38, 0x35, 0x64, 0x38, 0x65, 0x33, 0x31, 0x32, 0x61, 0x62, 0x34, 0x39, 0x38, 0x33, 0x62, 0x65, 0x33, 0x63, 0x36, 0x37, 0x64, 0x63, 0x39, 0x62, 0x65, 0x39, 0x62, 0x39, 0x37, 0x32, 0x32, 0x38, 0x30, 0x38, 0x63, 0x61, 0x37, 0x36, 0x62, 0x35, 0x63, 0x66, 0x34, 0x65, 0x64, 0x34, 0x32, 0x66, 0x33, 0x34, 0x33, 0x63, 0x30, 0x36, 0x32, 0x38, 0x64, 0x37, 0x66, 0x62, 0x38, 0x38, 0x64, 0x30, 0x35, 0x32, 0x33, 0x64, 0x36, 0x38, 0x63, 0x34, 0x63, 0x38, 0x31, 0x66, 0x66, 0x62, 0x37, 0x38, 0x61, 0x62, 0x65, 0x31, 0x63, 0x35, 0x33, 0x62, 0x31, 0x33, 0x39, 0x34, 0x37, 0x32, 0x63, 0x35, 0x32, 0x39, 0x37, 0x39, 0x61, 0x39, 0x38, 0x33, 0x66, 0x34, 0x64, 0x31, 0x66, 0x38, 0x64, 0x63, 0x34, 0x39, 0x36, 0x39, 0x36, 0x38, 0x33, 0x66, 0x62, 0x63, 0x37, 0x66, 0x36, 0x36, 0x64, 0x39, 0x63, 0x36, 0x39, 0x66, 0x66, 0x62, 0x31, 0x37, 0x65, 0x38, 0x38, 0x30, 0x36, 0x35, 0x38, 0x35, 0x61, 0x39, 0x65, 0x35, 0x34, 0x33, 0x65, 0x64, 0x66, 0x66, 0x61, 0x33, 0x32, 0x61, 0x35, 0x65, 0x64, 0x31, 0x65, 0x34, 0x62, 0x33, 0x34, 0x36, 0x61, 0x34, 0x36, 0x35, 0x64, 0x64, 0x65, 0x30, 0x33, 0x37, 0x39, 0x63, 0x62, 0x62, 0x39, 0x33, 0x32, 0x33, 0x64, 0x66, 0x34, 0x61, 0x36, 0x34, 0x66, 0x37, 0x34, 0x39, 0x65, 0x39, 0x63, 0x32, 0x36, 0x30, 0x63, 0x61, 0x38, 0x35, 0x30, 0x66, 0x33, 0x66, 0x62, 0x34, 0x32, 0x34, 0x65, 0x38, 0x62, 0x66, 0x65, 0x32, 0x32, 0x31, 0x37, 0x38, 0x61, 0x37, 0x39, 0x37, 0x65, 0x62, 0x37, 0x35, 0x37, 0x35, 0x38, 0x38, 0x32, 0x39, 0x38, 0x38, 0x35, 0x38, 0x36, 0x30, 0x37, 0x38, 0x64, 0x31, 0x38, 0x31, 0x62, 0x33, 0x37, 0x66, 0x65, 0x65, 0x31, 0x61, 0x62, 0x33, 0x34, 0x33, 0x38, 0x66, 0x63, 0x37, 0x38, 0x34, 0x39, 0x62, 0x65, 0x32, 0x37, 0x62, 0x31, 0x30, 0x34, 0x35, 0x66, 0x65, 0x34, 0x34, 0x63, 0x64, 0x37, 0x32, 0x39, 0x30, 0x37, 0x36, 0x38, 0x35, 0x63, 0x34, 0x61, 0x36, 0x66, 0x66, 0x65, 0x38, 0x65, 0x63, 0x65, 0x31, 0x65, 0x32, 0x64, 0x65, 0x64, 0x63, 0x33, 0x31, 0x62, 0x31, 0x34, 0x32, 0x34, 0x65, 0x33, 0x32, 0x33, 0x36, 0x62, 0x33, 0x62, 0x63, 0x31, 0x65, 0x34, 0x30, 0x35, 0x31, 0x63, 0x38, 0x39, 0x33, 0x39, 0x36, 0x35, 0x33, 0x38, 0x30, 0x36, 0x34, 0x65, 0x62, 0x34, 0x65, 0x36, 0x39, 0x36, 0x61, 0x30, 0x33, 0x37, 0x30, 0x62, 0x64, 0x36, 0x37, 0x63, 0x32, 0x66, 0x37, 0x33, 0x65, 0x64, 0x65, 0x39, 0x39, 0x35, 0x65, 0x39, 0x31, 0x39, 0x64, 0x32, 0x63, 0x64, 0x39, 0x30, 0x34, 0x65, 0x30, 0x35, 0x32, 0x37, 0x35, 0x33, 0x37, 0x65, 0x35, 0x61, 0x63, 0x36, 0x38, 0x33, 0x64, 0x63, 0x35, 0x62, 0x36, 0x39, 0x37, 0x63, 0x37, 0x30, 0x37, 0x32, 0x33, 0x63, 0x36, 0x37, 0x32, 0x61, 0x61, 0x38, 0x63, 0x31, 0x30, 0x32, 0x66, 0x30, 0x38, 0x37, 0x32, 0x63, 0x31, 0x30, 0x65, 0x62, 0x32, 0x33, 0x63, 0x66, 0x33, 0x30, 0x35, 0x31, 0x64, 0x61, 0x66, 0x35, 0x30, 0x34, 0x35, 0x32, 0x34, 0x32, 0x37, 0x61, 0x33, 0x32, 0x65, 0x38, 0x32, 0x38, 0x65, 0x61, 0x62, 0x32, 0x39, 0x66, 0x64, 0x39, 0x61, 0x33, 0x35, 0x36, 0x30, 0x61, 0x62, 0x38, 0x35, 0x32, 0x39, 0x31, 0x32, 0x38, 0x62, 0x30, 0x39, 0x66, 0x38, 0x65, 0x65, 0x34, 0x38, 0x30, 0x32, 0x61, 0x64, 0x36, 0x39, 0x33, 0x38, 0x30, 0x65, 0x31, 0x38, 0x37, 0x32, 0x33, 0x38, 0x66, 0x39, 0x34, 0x36, 0x37, 0x63, 0x64, 0x36, 0x38, 0x61, 0x37, 0x34, 0x34, 0x66, 0x35, 0x39, 0x63, 0x39, 0x63, 0x35, 0x66, 0x39, 0x35, 0x61, 0x63, 0x66, 0x35, 0x34, 0x34, 0x63, 0x64, 0x33, 0x65, 0x39, 0x36, 0x36, 0x34, 0x36, 0x63, 0x34, 0x33, 0x64, 0x64, 0x38, 0x33, 0x63, 0x64, 0x34, 0x66, 0x33, 0x64, 0x37, 0x33, 0x39, 0x39, 0x38, 0x33, 0x34, 0x62, 0x35, 0x34, 0x38, 0x31, 0x66, 0x32, 0x32, 0x39, 0x37, 0x35, 0x33, 0x35, 0x30, 0x31, 0x39, 0x66, 0x39, 0x31, 0x33, 0x34, 0x33, 0x66, 0x30, 0x66, 0x33, 0x39, 0x35, 0x63, 0x62, 0x30, 0x35, 0x61, 0x64, 0x30, 0x39, 0x61, 0x33, 0x31, 0x31, 0x36, 0x33, 0x37, 0x32, 0x35, 0x34, 0x65, 0x32, 0x37, 0x35, 0x62, 0x33, 0x34, 0x66, 0x64, 0x64, 0x38, 0x65, 0x64, 0x35, 0x32, 0x61, 0x31, 0x39, 0x37, 0x37, 0x33, 0x61, 0x34, 0x38, 0x63, 0x65, 0x36, 0x61, 0x36, 0x37, 0x65, 0x34, 0x35, 0x61, 0x37, 0x65, 0x39, 0x64, 0x64, 0x63, 0x33, 0x37, 0x62, 0x65, 0x64, 0x36, 0x30, 0x63, 0x32, 0x38, 0x39, 0x37, 0x33, 0x65, 0x37, 0x33, 0x37, 0x39, 0x63, 0x36, 0x33, 0x62, 0x64, 0x63, 0x64, 0x37, 0x30, 0x35, 0x63, 0x37, 0x65, 0x65, 0x65, 0x62, 0x35, 0x38, 0x31, 0x37, 0x34, 0x66, 0x64, 0x64, 0x32, 0x36, 0x30, 0x38, 0x38, 0x36, 0x34, 0x32, 0x63, 0x31, 0x37, 0x31, 0x62, 0x61, 0x30, 0x63, 0x32, 0x37, 0x32, 0x35, 0x31, 0x61, 0x64, 0x30, 0x63, 0x61, 0x33, 0x30, 0x35, 0x34, 0x32, 0x33, 0x32, 0x38, 0x39, 0x38, 0x32, 0x32, 0x37, 0x63, 0x64, 0x32, 0x37, 0x32, 0x30, 0x36, 0x66, 0x31, 0x65, 0x33, 0x61, 0x37, 0x34, 0x36, 0x35, 0x32, 0x63, 0x30, 0x63, 0x38, 0x35, 0x35, 0x36, 0x36, 0x32, 0x30, 0x31, 0x62, 0x65, 0x39, 0x36, 0x33, 0x30, 0x37, 0x30, 0x34, 0x35, 0x32, 0x34, 0x62, 0x32, 0x38, 0x36, 0x38, 0x38, 0x39, 0x35, 0x64, 0x61, 0x32, 0x37, 0x36, 0x39, 0x33, 0x35, 0x30, 0x36, 0x62, 0x39, 0x62, 0x31, 0x35, 0x63, 0x30, 0x35, 0x35, 0x30, 0x62, 0x62, 0x34, 0x38, 0x38, 0x39, 0x64, 0x65, 0x35, 0x66, 0x64, 0x64, 0x32, 0x36, 0x38, 0x34, 0x65, 0x62, 0x62, 0x35, 0x64, 0x37, 0x64, 0x36, 0x66, 0x30, 0x65, 0x61, 0x62, 0x38, 0x65, 0x31, 0x34, 0x62, 0x34, 0x39, 0x66, 0x64, 0x34, 0x36, 0x33, 0x37, 0x31, 0x66, 0x65, 0x34, 0x39, 0x62, 0x63, 0x33, 0x35, 0x31, 0x36, 0x65, 0x63, 0x62, 0x62, 0x66, 0x34, 0x61, 0x32, 0x31, 0x65, 0x37, 0x32, 0x64, 0x66, 0x64, 0x62, 0x39, 0x61, 0x63, 0x65, 0x61, 0x39, 0x39, 0x32, 0x31, 0x62, 0x31, 0x31, 0x65, 0x64, 0x30, 0x63, 0x31, 0x62, 0x37, 0x63, 0x37, 0x32, 0x31, 0x39, 0x61, 0x66, 0x31, 0x33, 0x32, 0x62, 0x37, 0x65, 0x65, 0x63, 0x64, 0x32, 0x39, 0x31, 0x64, 0x66, 0x37, 0x38, 0x65, 0x36, 0x63, 0x61, 0x63, 0x64, 0x39, 0x31, 0x34, 0x31, 0x66, 0x62, 0x32, 0x33, 0x34, 0x66, 0x37, 0x32, 0x38, 0x37, 0x36, 0x61, 0x39, 0x36, 0x62, 0x30, 0x63, 0x62, 0x39, 0x34, 0x65, 0x30, 0x65, 0x32, 0x62, 0x32, 0x32, 0x30, 0x34, 0x34, 0x37, 0x34, 0x66, 0x31, 0x64, 0x37, 0x31, 0x39, 0x61, 0x33, 0x30, 0x38, 0x35, 0x32, 0x36, 0x36, 0x32, 0x33, 0x36, 0x35, 0x64, 0x64, 0x65, 0x30, 0x62, 0x35, 0x63, 0x61, 0x64, 0x64, 0x33, 0x62, 0x62, 0x66, 0x64, 0x35, 0x32, 0x36, 0x31, 0x30, 0x37, 0x32, 0x31, 0x63, 0x65, 0x65, 0x39, 0x36, 0x61, 0x37, 0x36, 0x62, 0x65, 0x31, 0x34, 0x31, 0x35, 0x35, 0x32, 0x39, 0x63, 0x37, 0x63, 0x37, 0x37, 0x36, 0x31, 0x64, 0x36, 0x39, 0x35, 0x64, 0x63, 0x35, 0x32, 0x31, 0x31, 0x34, 0x61, 0x33, 0x63, 0x39, 0x35, 0x35, 0x37, 0x39, 0x64, 0x66, 0x31, 0x64, 0x30, 0x61, 0x64, 0x32, 0x31, 0x63, 0x35, 0x39, 0x66, 0x30, 0x37, 0x61, 0x31, 0x31, 0x34, 0x62, 0x64, 0x38, 0x33, 0x30, 0x31, 0x34, 0x37, 0x32, 0x31, 0x63, 0x62, 0x61, 0x34, 0x34, 0x36, 0x34, 0x61, 0x65, 0x35, 0x35, 0x66, 0x30, 0x61, 0x35, 0x36, 0x64, 0x31, 0x32, 0x32, 0x33, 0x34, 0x66, 0x31, 0x62, 0x39, 0x37, 0x39, 0x63, 0x35, 0x64, 0x35, 0x64, 0x31, 0x35, 0x35, 0x35, 0x64, 0x36, 0x37, 0x61, 0x63, 0x30, 0x37, 0x64, 0x34, 0x30, 0x63, 0x34, 0x36, 0x38, 0x31, 0x64, 0x37, 0x32, 0x39, 0x34, 0x32, 0x66, 0x66, 0x62, 0x32, 0x38, 0x32, 0x31, 0x61, 0x32, 0x38, 0x61, 0x66, 0x31, 0x37, 0x37, 0x33, 0x30, 0x31, 0x63, 0x39, 0x33, 0x30, 0x32, 0x63, 0x64, 0x64, 0x39, 0x32, 0x34, 0x33, 0x33, 0x33, 0x30, 0x35, 0x65, 0x30, 0x32, 0x61, 0x35, 0x66, 0x65, 0x39, 0x61, 0x31, 0x39, 0x64, 0x37, 0x37, 0x36, 0x63, 0x64, 0x39, 0x64, 0x63, 0x34, 0x62, 0x38, 0x63, 0x64, 0x37, 0x32, 0x65, 0x62, 0x39, 0x31, 0x36, 0x31, 0x34, 0x34, 0x32, 0x65, 0x61, 0x33, 0x62, 0x65, 0x66, 0x36, 0x39, 0x36, 0x64, 0x66, 0x36, 0x34, 0x39, 0x39, 0x63, 0x64, 0x30, 0x36, 0x61, 0x65, 0x66, 0x66, 0x39, 0x38, 0x32, 0x35, 0x34, 0x39, 0x66, 0x36, 0x39, 0x63, 0x36, 0x61, 0x64, 0x66, 0x39, 0x38, 0x34, 0x62, 0x37, 0x36, 0x39, 0x34, 0x66, 0x38, 0x65, 0x61, 0x63, 0x33, 0x30, 0x39, 0x37, 0x32, 0x65, 0x39, 0x32, 0x39, 0x64, 0x39, 0x62, 0x31, 0x63, 0x63, 0x34, 0x63, 0x63, 0x63, 0x31, 0x39, 0x36, 0x30, 0x32, 0x30, 0x61, 0x63, 0x32, 0x30, 0x33, 0x65, 0x64, 0x37, 0x61, 0x34, 0x66, 0x66, 0x32, 0x37, 0x61, 0x37, 0x39, 0x37, 0x33, 0x65, 0x66, 0x38, 0x66, 0x38, 0x61, 0x62, 0x38, 0x38, 0x64, 0x63, 0x39, 0x65, 0x62, 0x38, 0x39, 0x38, 0x36, 0x33, 0x38, 0x63, 0x35, 0x36, 0x35, 0x39, 0x38, 0x61, 0x36, 0x37, 0x31, 0x34, 0x33, 0x34, 0x30, 0x31, 0x30, 0x33, 0x31, 0x65, 0x33, 0x65, 0x39, 0x61, 0x34, 0x62, 0x61, 0x34, 0x31, 0x30, 0x35, 0x62, 0x32, 0x37, 0x61, 0x34, 0x33, 0x66, 0x35, 0x35, 0x63, 0x31, 0x61, 0x63, 0x35, 0x64, 0x30, 0x37, 0x64, 0x64, 0x32, 0x63, 0x38, 0x62, 0x65, 0x36, 0x30, 0x33, 0x33, 0x61, 0x31, 0x35, 0x66, 0x62, 0x32, 0x37, 0x37, 0x61, 0x36, 0x35, 0x62, 0x61, 0x30, 0x31, 0x31, 0x33, 0x32, 0x35, 0x33, 0x66, 0x66, 0x38, 0x61, 0x38, 0x35, 0x33, 0x35, 0x65, 0x31, 0x62, 0x37, 0x32, 0x65, 0x32, 0x31, 0x66, 0x61, 0x66, 0x64, 0x65, 0x34, 0x33, 0x38, 0x31, 0x35, 0x62, 0x66, 0x37, 0x36, 0x62, 0x62, 0x65, 0x37, 0x31, 0x39, 0x36, 0x38, 0x37, 0x31, 0x36, 0x39, 0x33, 0x62, 0x31, 0x34, 0x34, 0x33, 0x64, 0x31, 0x65, 0x66, 0x65, 0x37, 0x32, 0x34, 0x36, 0x62, 0x38, 0x39, 0x63, 0x37, 0x38, 0x61, 0x30, 0x64, 0x32, 0x32, 0x37, 0x64, 0x33, 0x39, 0x38, 0x65, 0x63, 0x37, 0x39, 0x62, 0x62, 0x33, 0x61, 0x64, 0x37, 0x37, 0x62, 0x38, 0x61, 0x31, 0x38, 0x37, 0x65, 0x62, 0x30, 0x66, 0x31, 0x61, 0x35, 0x30, 0x31, 0x61, 0x35, 0x39, 0x39, 0x37, 0x35, 0x32, 0x30, 0x62, 0x35, 0x36, 0x33, 0x35, 0x63, 0x33, 0x61, 0x64, 0x61, 0x33, 0x38, 0x33, 0x37, 0x38, 0x61, 0x34, 0x31, 0x34, 0x64, 0x34, 0x38, 0x63, 0x38, 0x34, 0x38, 0x64, 0x35, 0x64, 0x36, 0x30, 0x34, 0x64, 0x34, 0x33, 0x35, 0x61, 0x63, 0x33, 0x33, 0x31, 0x65, 0x33, 0x65, 0x64, 0x34, 0x63, 0x32, 0x61, 0x30, 0x31, 0x64, 0x30, 0x38, 0x39, 0x33, 0x35, 0x36, 0x30, 0x31, 0x38, 0x38, 0x33, 0x63, 0x35, 0x65, 0x62, 0x35, 0x62, 0x38, 0x33, 0x62, 0x38, 0x32, 0x37, 0x32, 0x62, 0x63, 0x38, 0x34, 0x31, 0x31, 0x31, 0x32, 0x35, 0x39, 0x64, 0x65, 0x38, 0x34, 0x66, 0x33, 0x37, 0x31, 0x30, 0x61, 0x33, 0x63, 0x65, 0x36, 0x37, 0x34, 0x34, 0x35, 0x31, 0x65, 0x66, 0x66, 0x36, 0x38, 0x36, 0x31, 0x31, 0x30, 0x63, 0x36, 0x37, 0x62, 0x31, 0x36, 0x66, 0x65, 0x35, 0x61, 0x36, 0x65, 0x64, 0x32, 0x61, 0x37, 0x33, 0x39, 0x31, 0x66, 0x37, 0x33, 0x66, 0x33, 0x37, 0x32, 0x30, 0x65, 0x65, 0x31, 0x32, 0x65, 0x33, 0x37, 0x61, 0x63, 0x64, 0x66, 0x61, 0x36, 0x32, 0x38, 0x31, 0x35, 0x34, 0x33, 0x32, 0x38, 0x64, 0x65, 0x30, 0x38, 0x35, 0x38, 0x35, 0x31, 0x35, 0x61, 0x37, 0x61, 0x38, 0x30, 0x38, 0x63, 0x35, 0x34, 0x65, 0x32, 0x33, 0x35, 0x30, 0x35, 0x38, 0x65, 0x62, 0x62, 0x35, 0x37, 0x63, 0x64, 0x34, 0x31, 0x37, 0x63, 0x34, 0x39, 0x30, 0x64, 0x37, 0x32, 0x33, 0x33, 0x38, 0x32, 0x33, 0x31, 0x39, 0x31, 0x30, 0x66, 0x63, 0x31, 0x39, 0x34, 0x30, 0x37, 0x39, 0x38, 0x34, 0x36, 0x65, 0x36, 0x64, 0x39, 0x61, 0x64, 0x62, 0x61, 0x31, 0x61, 0x65, 0x64, 0x32, 0x38, 0x31, 0x38, 0x35, 0x35, 0x62, 0x36, 0x62, 0x32, 0x39, 0x39, 0x61, 0x35, 0x66, 0x38, 0x38, 0x64, 0x61, 0x36, 0x36, 0x32, 0x64, 0x62, 0x30, 0x64, 0x39, 0x34, 0x33, 0x35, 0x37, 0x32, 0x35, 0x64, 0x66, 0x65, 0x39, 0x33, 0x34, 0x30, 0x37, 0x65, 0x31, 0x31, 0x35, 0x66, 0x65, 0x35, 0x61, 0x30, 0x34, 0x38, 0x64, 0x31, 0x37, 0x39, 0x62, 0x31, 0x37, 0x30, 0x34, 0x34, 0x38, 0x35, 0x62, 0x38, 0x33, 0x39, 0x65, 0x36, 0x61, 0x61, 0x30, 0x62, 0x31, 0x38, 0x39, 0x61, 0x33, 0x31, 0x32, 0x34, 0x32, 0x32, 0x64, 0x38, 0x39, 0x62, 0x33, 0x61, 0x39, 0x34, 0x66, 0x30, 0x32, 0x61, 0x30, 0x63, 0x34, 0x64, 0x37, 0x33, 0x34, 0x63, 0x64, 0x33, 0x66, 0x37, 0x31, 0x35, 0x31, 0x66, 0x33, 0x39, 0x31, 0x39, 0x62, 0x61, 0x34, 0x66, 0x34, 0x65, 0x36, 0x34, 0x34, 0x32, 0x61, 0x33, 0x62, 0x33, 0x37, 0x61, 0x63, 0x38, 0x32, 0x39, 0x63, 0x66, 0x31, 0x38, 0x36, 0x66, 0x61, 0x35, 0x39, 0x61, 0x35, 0x61, 0x36, 0x33, 0x30, 0x39, 0x36, 0x35, 0x35, 0x63, 0x33, 0x65, 0x31, 0x36, 0x34, 0x38, 0x34, 0x36, 0x62, 0x39, 0x64, 0x64, 0x61, 0x65, 0x35, 0x33, 0x30, 0x30, 0x37, 0x38, 0x35, 0x37, 0x66, 0x35, 0x64, 0x64, 0x63, 0x33, 0x34, 0x63, 0x33, 0x32, 0x64, 0x39, 0x33, 0x35, 0x31, 0x31, 0x36, 0x34, 0x61, 0x62, 0x30, 0x38, 0x64, 0x64, 0x32, 0x62, 0x64, 0x38, 0x38, 0x33, 0x63, 0x63, 0x39, 0x63, 0x63, 0x38, 0x38, 0x64, 0x36, 0x62, 0x66, 0x33, 0x32, 0x66, 0x37, 0x32, 0x31, 0x64, 0x35, 0x34, 0x66, 0x33, 0x65, 0x37, 0x38, 0x66, 0x36, 0x37, 0x64, 0x39, 0x34, 0x34, 0x38, 0x63, 0x66, 0x39, 0x30, 0x30, 0x35, 0x65, 0x64, 0x35, 0x66, 0x63, 0x64, 0x30, 0x39, 0x66, 0x66, 0x64, 0x32, 0x63, 0x63, 0x62, 0x32, 0x63, 0x34, 0x61, 0x66, 0x66, 0x35, 0x32, 0x33, 0x63, 0x38, 0x63, 0x35, 0x62, 0x39, 0x35, 0x31, 0x30, 0x66, 0x37, 0x39, 0x33, 0x36, 0x61, 0x37, 0x32, 0x63, 0x37, 0x36, 0x62, 0x31, 0x66, 0x39, 0x32, 0x32, 0x33, 0x63, 0x31, 0x37, 0x32, 0x39, 0x65, 0x64, 0x66, 0x38, 0x33, 0x39, 0x65, 0x65, 0x62, 0x35, 0x36, 0x33, 0x62, 0x30, 0x64, 0x34, 0x32, 0x64, 0x66, 0x62, 0x38, 0x32, 0x61, 0x63, 0x34, 0x65, 0x39, 0x64, 0x34, 0x32, 0x66, 0x34, 0x36, 0x63, 0x64, 0x39, 0x39, 0x64, 0x34, 0x62, 0x31, 0x33, 0x65, 0x62, 0x33, 0x38, 0x36, 0x37, 0x32, 0x61, 0x64, 0x65, 0x63, 0x63, 0x33, 0x30, 0x36, 0x62, 0x65, 0x31, 0x30, 0x39, 0x34, 0x32, 0x61, 0x36, 0x34, 0x38, 0x32, 0x63, 0x38, 0x32, 0x34, 0x39, 0x37, 0x38, 0x33, 0x66, 0x32, 0x62, 0x64, 0x39, 0x36, 0x39, 0x30, 0x35, 0x62, 0x64, 0x32, 0x64, 0x32, 0x64, 0x63, 0x66, 0x64, 0x61, 0x66, 0x62, 0x62, 0x30, 0x36, 0x36, 0x63, 0x66, 0x39, 0x37, 0x64, 0x36, 0x61, 0x30, 0x31, 0x37, 0x32, 0x35, 0x36, 0x66, 0x30, 0x61, 0x61, 0x65, 0x62, 0x31, 0x30, 0x32, 0x36, 0x31, 0x37, 0x38, 0x39, 0x38, 0x61, 0x66, 0x39, 0x64, 0x63, 0x32, 0x39, 0x66, 0x64, 0x62, 0x37, 0x39, 0x34, 0x35, 0x35, 0x34, 0x61, 0x34, 0x39, 0x34, 0x66, 0x37, 0x66, 0x37, 0x64, 0x35, 0x65, 0x66, 0x65, 0x61, 0x32, 0x30, 0x38, 0x61, 0x62, 0x64, 0x64, 0x37, 0x61, 0x65, 0x66, 0x39, 0x31, 0x30, 0x64, 0x37, 0x32, 0x30, 0x66, 0x30, 0x31, 0x64, 0x38, 0x34, 0x31, 0x63, 0x35, 0x66, 0x37, 0x64, 0x32, 0x66, 0x31, 0x65, 0x36, 0x62, 0x31, 0x36, 0x39, 0x61, 0x30, 0x64, 0x37, 0x35, 0x66, 0x37, 0x37, 0x63, 0x37, 0x62, 0x30, 0x62, 0x32, 0x63, 0x63, 0x32, 0x66, 0x64, 0x66, 0x63, 0x63, 0x66, 0x33, 0x65, 0x33, 0x30, 0x38, 0x33, 0x33, 0x64, 0x63, 0x36, 0x64, 0x34, 0x33, 0x64, 0x34, 0x65, 0x65, 0x33, 0x30, 0x37, 0x61, 0x39, 0x31, 0x62, 0x63, 0x32, 0x62, 0x66, 0x32, 0x38, 0x32, 0x34, 0x38, 0x39, 0x34, 0x33, 0x35, 0x36, 0x35, 0x65, 0x38, 0x31, 0x64, 0x62, 0x65, 0x66, 0x64, 0x61, 0x38, 0x32, 0x30, 0x39, 0x38, 0x39, 0x33, 0x38, 0x61, 0x66, 0x64, 0x33, 0x38, 0x64, 0x39, 0x61, 0x63, 0x30, 0x66, 0x35, 0x35, 0x33, 0x66, 0x30, 0x38, 0x61, 0x64, 0x32, 0x66, 0x32, 0x32, 0x31, 0x61, 0x37, 0x32, 0x62, 0x32, 0x30, 0x65, 0x63, 0x33, 0x33, 0x63, 0x61, 0x36, 0x37, 0x63, 0x37, 0x36, 0x39, 0x38, 0x63, 0x31, 0x38, 0x36, 0x30, 0x61, 0x39, 0x65, 0x64, 0x33, 0x37, 0x37, 0x31, 0x64, 0x34, 0x65, 0x31, 0x36, 0x34, 0x62, 0x64, 0x63, 0x36, 0x36, 0x30, 0x39, 0x63, 0x32, 0x30, 0x66, 0x37, 0x36, 0x32, 0x33, 0x38, 0x39, 0x39, 0x37, 0x34, 0x36, 0x34, 0x64, 0x34, 0x35, 0x36, 0x37, 0x30, 0x34, 0x38, 0x33, 0x31, 0x66, 0x65, 0x65, 0x61, 0x32, 0x39, 0x64, 0x63, 0x63, 0x34, 0x38, 0x38, 0x30, 0x34, 0x35, 0x33, 0x62, 0x61, 0x37, 0x31, 0x38, 0x64, 0x61, 0x39, 0x36, 0x38, 0x39, 0x33, 0x66, 0x65, 0x33, 0x39, 0x66, 0x37, 0x63, 0x65, 0x35, 0x31, 0x34, 0x32, 0x37, 0x36, 0x64, 0x32, 0x63, 0x66, 0x37, 0x64, 0x37, 0x38, 0x35, 0x66, 0x62, 0x61, 0x66, 0x62, 0x30, 0x64, 0x66, 0x37, 0x32, 0x64, 0x66, 0x39, 0x35, 0x65, 0x64, 0x34, 0x62, 0x62, 0x65, 0x61, 0x62, 0x64, 0x36, 0x37, 0x63, 0x33, 0x65, 0x33, 0x36, 0x31, 0x30, 0x62, 0x36, 0x34, 0x33, 0x39, 0x65, 0x30, 0x32, 0x33, 0x34, 0x32, 0x34, 0x39, 0x34, 0x62, 0x61, 0x38, 0x37, 0x35, 0x37, 0x35, 0x39, 0x61, 0x30, 0x36, 0x61, 0x32, 0x62, 0x30, 0x66, 0x32, 0x62, 0x64, 0x62, 0x36, 0x62, 0x30, 0x31, 0x33, 0x39, 0x37, 0x32, 0x37, 0x32, 0x37, 0x33, 0x35, 0x33, 0x63, 0x63, 0x37, 0x66, 0x61, 0x34, 0x65, 0x62, 0x33, 0x64, 0x63, 0x32, 0x61, 0x66, 0x38, 0x32, 0x37, 0x31, 0x65, 0x36, 0x30, 0x35, 0x38, 0x35, 0x66, 0x63, 0x65, 0x65, 0x33, 0x32, 0x61, 0x63, 0x35, 0x39, 0x65, 0x37, 0x32, 0x64, 0x31, 0x32, 0x35, 0x37, 0x64, 0x35, 0x39, 0x65, 0x39, 0x34, 0x35, 0x61, 0x31, 0x32, 0x38, 0x37, 0x38, 0x62, 0x37, 0x32, 0x32, 0x36, 0x30, 0x32, 0x63, 0x32, 0x39, 0x31, 0x66, 0x61, 0x31, 0x35, 0x63, 0x37, 0x37, 0x37, 0x34, 0x37, 0x66, 0x65, 0x38, 0x66, 0x37, 0x37, 0x37, 0x37, 0x32, 0x34, 0x34, 0x66, 0x35, 0x32, 0x30, 0x64, 0x62, 0x61, 0x35, 0x36, 0x65, 0x30, 0x62, 0x30, 0x31, 0x65, 0x66, 0x62, 0x66, 0x31, 0x30, 0x32, 0x30, 0x65, 0x33, 0x31, 0x32, 0x37, 0x30, 0x32, 0x35, 0x66, 0x34, 0x37, 0x37, 0x32, 0x37, 0x64, 0x34, 0x36, 0x30, 0x31, 0x36, 0x32, 0x39, 0x30, 0x34, 0x62, 0x64, 0x66, 0x39, 0x63, 0x62, 0x39, 0x61, 0x66, 0x37, 0x34, 0x33, 0x66, 0x33, 0x63, 0x65, 0x36, 0x32, 0x62, 0x64, 0x36, 0x65, 0x37, 0x34, 0x38, 0x65, 0x64, 0x39, 0x39, 0x35, 0x30, 0x36, 0x32, 0x66, 0x30, 0x30, 0x62, 0x30, 0x66, 0x36, 0x62, 0x61, 0x36, 0x35, 0x62, 0x32, 0x33, 0x38, 0x34, 0x62, 0x30, 0x37, 0x32, 0x30, 0x64, 0x30, 0x36, 0x32, 0x30, 0x39, 0x37, 0x30, 0x39, 0x36, 0x37, 0x66, 0x31, 0x61, 0x30, 0x62, 0x66, 0x63, 0x34, 0x36, 0x38, 0x34, 0x66, 0x39, 0x64, 0x31, 0x31, 0x39, 0x64, 0x34, 0x35, 0x35, 0x65, 0x39, 0x62, 0x64, 0x31, 0x65, 0x35, 0x66, 0x31, 0x36, 0x64, 0x31, 0x64, 0x65, 0x35, 0x37, 0x61, 0x33, 0x32, 0x63, 0x32, 0x63, 0x39, 0x64, 0x35, 0x34, 0x36, 0x30, 0x36, 0x33, 0x34, 0x35, 0x30, 0x31, 0x63, 0x34, 0x61, 0x63, 0x39, 0x64, 0x30, 0x62, 0x32, 0x66, 0x32, 0x39, 0x37, 0x36, 0x39, 0x36, 0x36, 0x62, 0x30, 0x66, 0x31, 0x62, 0x37, 0x65, 0x65, 0x39, 0x63, 0x37, 0x35, 0x35, 0x63, 0x37, 0x31, 0x38, 0x38, 0x64, 0x35, 0x65, 0x35, 0x65, 0x36, 0x37, 0x37, 0x39, 0x38, 0x39, 0x31, 0x38, 0x35, 0x34, 0x65, 0x32, 0x39, 0x30, 0x62, 0x33, 0x37, 0x66, 0x33, 0x37, 0x32, 0x38, 0x64, 0x37, 0x36, 0x38, 0x30, 0x61, 0x66, 0x34, 0x66, 0x39, 0x32, 0x61, 0x61, 0x65, 0x66, 0x38, 0x61, 0x62, 0x36, 0x61, 0x65, 0x63, 0x61, 0x62, 0x37, 0x64, 0x65, 0x30, 0x62, 0x37, 0x31, 0x65, 0x66, 0x65, 0x34, 0x34, 0x30, 0x31, 0x32, 0x35, 0x31, 0x63, 0x37, 0x63, 0x39, 0x66, 0x33, 0x64, 0x34, 0x31, 0x35, 0x34, 0x35, 0x63, 0x61, 0x61, 0x35, 0x64, 0x39, 0x37, 0x66, 0x37, 0x30, 0x65, 0x65, 0x61, 0x65, 0x32, 0x36, 0x39, 0x62, 0x39, 0x32, 0x36, 0x33, 0x65, 0x39, 0x30, 0x64, 0x62, 0x66, 0x66, 0x63, 0x39, 0x39, 0x30, 0x38, 0x63, 0x32, 0x34, 0x64, 0x30, 0x38, 0x32, 0x31, 0x64, 0x63, 0x31, 0x32, 0x65, 0x66, 0x39, 0x38, 0x32, 0x31, 0x64, 0x63, 0x30, 0x63, 0x36, 0x63, 0x38, 0x61, 0x39, 0x65, 0x63, 0x39, 0x35, 0x39, 0x36, 0x37, 0x61, 0x63, 0x32, 0x37, 0x37, 0x32, 0x33, 0x38, 0x66, 0x36, 0x37, 0x61, 0x64, 0x30, 0x36, 0x31, 0x66, 0x62, 0x36, 0x37, 0x37, 0x33, 0x35, 0x38, 0x66, 0x61, 0x30, 0x37, 0x39, 0x31, 0x65, 0x33, 0x65, 0x35, 0x38, 0x63, 0x63, 0x33, 0x61, 0x65, 0x31, 0x38, 0x31, 0x30, 0x30, 0x39, 0x65, 0x35, 0x64, 0x61, 0x35, 0x34, 0x62, 0x65, 0x33, 0x63, 0x65, 0x64, 0x62, 0x39, 0x65, 0x62, 0x62, 0x39, 0x36, 0x35, 0x61, 0x36, 0x30, 0x35, 0x34, 0x66, 0x62, 0x33, 0x38, 0x31, 0x33, 0x63, 0x66, 0x66, 0x34, 0x38, 0x36, 0x35, 0x39, 0x36, 0x66, 0x32, 0x66, 0x37, 0x61, 0x31, 0x30, 0x34, 0x39, 0x38, 0x33, 0x34, 0x61, 0x34, 0x33, 0x38, 0x30, 0x31, 0x37, 0x38, 0x37, 0x36, 0x66, 0x63, 0x65, 0x38, 0x31, 0x62, 0x62, 0x35, 0x64, 0x39, 0x39, 0x34, 0x30, 0x39, 0x61, 0x32, 0x62, 0x33, 0x33, 0x63, 0x38, 0x37, 0x33, 0x36, 0x37, 0x32, 0x65, 0x66, 0x32, 0x33, 0x30, 0x62, 0x31, 0x63, 0x32, 0x34, 0x31, 0x65, 0x65, 0x33, 0x39, 0x39, 0x61, 0x31, 0x39, 0x32, 0x39, 0x63, 0x36, 0x33, 0x35, 0x36, 0x37, 0x34, 0x33, 0x38, 0x39, 0x35, 0x39, 0x38, 0x33, 0x36, 0x39, 0x31, 0x62, 0x31, 0x64, 0x30, 0x32, 0x64, 0x66, 0x36, 0x62, 0x35, 0x38, 0x36, 0x61, 0x33, 0x38, 0x38, 0x32, 0x66, 0x36, 0x35, 0x34, 0x66, 0x64, 0x33, 0x32, 0x32, 0x64, 0x39, 0x64, 0x34, 0x30, 0x61, 0x35, 0x33, 0x31, 0x34, 0x37, 0x30, 0x33, 0x36, 0x30, 0x37, 0x38, 0x62, 0x30, 0x34, 0x65, 0x64, 0x61, 0x33, 0x64, 0x34, 0x34, 0x38, 0x65, 0x64, 0x33, 0x63, 0x34, 0x61, 0x65, 0x65, 0x31, 0x61, 0x66, 0x30, 0x32, 0x30, 0x32, 0x65, 0x32, 0x63, 0x62, 0x65, 0x31, 0x30, 0x64, 0x62, 0x32, 0x35, 0x61, 0x33, 0x66, 0x37, 0x62, 0x35, 0x39, 0x64, 0x37, 0x32, 0x37, 0x35, 0x33, 0x38, 0x38, 0x66, 0x35, 0x66, 0x39, 0x39, 0x39, 0x31, 0x34, 0x66, 0x65, 0x62, 0x64, 0x33, 0x66, 0x38, 0x64, 0x35, 0x37, 0x39, 0x39, 0x37, 0x32, 0x34, 0x62, 0x65, 0x66, 0x34, 0x37, 0x32, 0x37, 0x33, 0x33, 0x39, 0x61, 0x34, 0x34, 0x36, 0x37, 0x32, 0x61, 0x62, 0x36, 0x66, 0x33, 0x36, 0x33, 0x33, 0x37, 0x32, 0x39, 0x31, 0x33, 0x66, 0x66, 0x66, 0x64, 0x39, 0x37, 0x32, 0x65, 0x33, 0x30, 0x32, 0x36, 0x35, 0x31, 0x35, 0x39, 0x34, 0x65, 0x61, 0x64, 0x37, 0x38, 0x32, 0x38, 0x37, 0x31, 0x63, 0x33, 0x30, 0x65, 0x36, 0x39, 0x64, 0x39, 0x31, 0x38, 0x35, 0x34, 0x35, 0x32, 0x34, 0x33, 0x66, 0x34, 0x33, 0x39, 0x39, 0x31, 0x34, 0x35, 0x37, 0x37, 0x37, 0x64, 0x32, 0x35, 0x33, 0x33, 0x34, 0x31, 0x34, 0x66, 0x64, 0x61, 0x65, 0x31, 0x64, 0x65, 0x31, 0x32, 0x66, 0x64, 0x38, 0x35, 0x35, 0x33, 0x66, 0x32, 0x63, 0x35, 0x39, 0x39, 0x66, 0x32, 0x65, 0x64, 0x66, 0x65, 0x32, 0x61, 0x34, 0x30, 0x39, 0x36, 0x65, 0x64, 0x65, 0x33, 0x36, 0x66, 0x34, 0x39, 0x63, 0x34, 0x35, 0x61, 0x39, 0x39, 0x62, 0x32, 0x37, 0x64, 0x61, 0x66, 0x35, 0x33, 0x63, 0x37, 0x37, 0x35, 0x65, 0x38, 0x35, 0x31, 0x36, 0x66, 0x33, 0x63, 0x37, 0x62, 0x62, 0x31, 0x30, 0x30, 0x63, 0x32, 0x35, 0x39, 0x39, 0x35, 0x65, 0x37, 0x35, 0x33, 0x37, 0x33, 0x38, 0x33, 0x66, 0x31, 0x32, 0x32, 0x33, 0x32, 0x63, 0x37, 0x64, 0x37, 0x37, 0x33, 0x35, 0x31, 0x33, 0x33, 0x35, 0x35, 0x38, 0x64, 0x31, 0x39, 0x61, 0x35, 0x65, 0x36, 0x62, 0x34, 0x37, 0x38, 0x65, 0x36, 0x36, 0x32, 0x61, 0x62, 0x38, 0x38, 0x36, 0x62, 0x35, 0x31, 0x63, 0x63, 0x30, 0x63, 0x30, 0x30, 0x35, 0x37, 0x32, 0x62, 0x35, 0x64, 0x38, 0x66, 0x35, 0x35, 0x38, 0x31, 0x32, 0x61, 0x32, 0x30, 0x33, 0x61, 0x37, 0x33, 0x31, 0x39, 0x39, 0x64, 0x33, 0x39, 0x61, 0x36, 0x38, 0x33, 0x38, 0x30, 0x36, 0x34, 0x63, 0x34, 0x63, 0x39, 0x38, 0x65, 0x36, 0x63, 0x37, 0x66, 0x33, 0x37, 0x30, 0x66, 0x66, 0x66, 0x64, 0x39, 0x39, 0x36, 0x38, 0x33, 0x34, 0x37, 0x35, 0x34, 0x36, 0x62, 0x33, 0x36, 0x38, 0x36, 0x39, 0x30, 0x37, 0x38, 0x34, 0x33, 0x33, 0x35, 0x64, 0x62, 0x66, 0x65, 0x66, 0x30, 0x63, 0x64, 0x62, 0x64, 0x39, 0x36, 0x31, 0x36, 0x33, 0x66, 0x31, 0x32, 0x39, 0x33, 0x34, 0x34, 0x30, 0x64, 0x36, 0x38, 0x38, 0x64, 0x65, 0x35, 0x35, 0x32, 0x62, 0x37, 0x33, 0x62, 0x64, 0x66, 0x62, 0x66, 0x37, 0x61, 0x64, 0x33, 0x61, 0x62, 0x63, 0x32, 0x61, 0x38, 0x65, 0x65, 0x66, 0x65, 0x38, 0x37, 0x32, 0x62, 0x32, 0x35, 0x36, 0x33, 0x39, 0x64, 0x65, 0x32, 0x36, 0x33, 0x61, 0x61, 0x61, 0x34, 0x30, 0x63, 0x64, 0x37, 0x38, 0x63, 0x33, 0x61, 0x34, 0x32, 0x65, 0x31, 0x63, 0x66, 0x34, 0x62, 0x65, 0x65, 0x35, 0x32, 0x61, 0x34, 0x39, 0x38, 0x65, 0x37, 0x66, 0x34, 0x63, 0x38, 0x32, 0x65, 0x33, 0x36, 0x33, 0x65, 0x62, 0x65, 0x37, 0x39, 0x37, 0x36, 0x66, 0x64, 0x63, 0x63, 0x64, 0x37, 0x32, 0x62, 0x63, 0x33, 0x34, 0x38, 0x33, 0x33, 0x35, 0x62, 0x64, 0x66, 0x32, 0x37, 0x65, 0x64, 0x62, 0x64, 0x65, 0x38, 0x61, 0x35, 0x61, 0x31, 0x31, 0x64, 0x63, 0x37, 0x30, 0x36, 0x64, 0x64, 0x39, 0x30, 0x66, 0x36, 0x38, 0x64, 0x66, 0x38, 0x62, 0x63, 0x66, 0x31, 0x66, 0x30, 0x61, 0x65, 0x37, 0x33, 0x31, 0x65, 0x64, 0x62, 0x39, 0x37, 0x61, 0x64, 0x31, 0x31, 0x38, 0x38, 0x39, 0x37, 0x32, 0x37, 0x62, 0x61, 0x66, 0x36, 0x30, 0x61, 0x39, 0x62, 0x37, 0x66, 0x30, 0x34, 0x38, 0x65, 0x64, 0x34, 0x62, 0x32, 0x63, 0x35, 0x31, 0x35, 0x36, 0x32, 0x63, 0x63, 0x38, 0x32, 0x62, 0x38, 0x32, 0x63, 0x34, 0x66, 0x37, 0x38, 0x61, 0x30, 0x38, 0x66, 0x61, 0x38, 0x65, 0x32, 0x34, 0x32, 0x35, 0x38, 0x31, 0x38, 0x66, 0x64, 0x35, 0x64, 0x38, 0x64, 0x63, 0x32, 0x39, 0x37, 0x33, 0x36, 0x31, 0x61, 0x33, 0x35, 0x39, 0x35, 0x61, 0x30, 0x35, 0x38, 0x35, 0x65, 0x35, 0x31, 0x66, 0x31, 0x61, 0x39, 0x61, 0x65, 0x37, 0x38, 0x61, 0x35, 0x62, 0x37, 0x64, 0x30, 0x64, 0x38, 0x32, 0x61, 0x64, 0x64, 0x64, 0x30, 0x39, 0x33, 0x37, 0x32, 0x36, 0x35, 0x64, 0x34, 0x39, 0x65, 0x35, 0x32, 0x37, 0x35, 0x35, 0x66, 0x35, 0x36, 0x63, 0x36, 0x38, 0x36, 0x35, 0x33, 0x39, 0x35, 0x37, 0x37, 0x32, 0x36, 0x31, 0x31, 0x61, 0x31, 0x38, 0x39, 0x62, 0x34, 0x62, 0x64, 0x39, 0x31, 0x62, 0x61, 0x37, 0x38, 0x30, 0x33, 0x63, 0x62, 0x64, 0x66, 0x30, 0x37, 0x34, 0x65, 0x64, 0x65, 0x32, 0x31, 0x37, 0x30, 0x61, 0x36, 0x62, 0x39, 0x39, 0x37, 0x30, 0x32, 0x37, 0x31, 0x61, 0x31, 0x38, 0x62, 0x63, 0x62, 0x32, 0x39, 0x66, 0x65, 0x38, 0x36, 0x39, 0x35, 0x61, 0x39, 0x35, 0x64, 0x64, 0x37, 0x32, 0x35, 0x63, 0x30, 0x32, 0x63, 0x33, 0x34, 0x31, 0x66, 0x32, 0x38, 0x37, 0x61, 0x32, 0x63, 0x62, 0x35, 0x37, 0x32, 0x39, 0x61, 0x34, 0x39, 0x37, 0x61, 0x63, 0x33, 0x66, 0x35, 0x63, 0x63, 0x32, 0x66, 0x61, 0x30, 0x65, 0x32, 0x63, 0x35, 0x62, 0x61, 0x65, 0x30, 0x61, 0x35, 0x36, 0x30, 0x64, 0x31, 0x63, 0x66, 0x31, 0x39, 0x62, 0x39, 0x37, 0x37, 0x34, 0x66, 0x39, 0x66, 0x64, 0x36, 0x63, 0x33, 0x62, 0x62, 0x35, 0x30, 0x32, 0x39, 0x32, 0x62, 0x62, 0x33, 0x30, 0x33, 0x61, 0x38, 0x34, 0x37, 0x66, 0x65, 0x33, 0x61, 0x63, 0x63, 0x30, 0x34, 0x37, 0x30, 0x37, 0x38, 0x63, 0x30, 0x32, 0x39, 0x63, 0x38, 0x33, 0x63, 0x64, 0x37, 0x64, 0x35, 0x36, 0x38, 0x33, 0x62, 0x38, 0x66, 0x62, 0x64, 0x62, 0x65, 0x61, 0x65, 0x39, 0x39, 0x32, 0x33, 0x37, 0x66, 0x65, 0x65, 0x32, 0x32, 0x35, 0x63, 0x31, 0x31, 0x65, 0x35, 0x39, 0x61, 0x64, 0x62, 0x61, 0x36, 0x36, 0x36, 0x63, 0x66, 0x33, 0x62, 0x39, 0x30, 0x66, 0x33, 0x38, 0x66, 0x66, 0x65, 0x64, 0x32, 0x63, 0x37, 0x37, 0x65, 0x38, 0x36, 0x37, 0x36, 0x37, 0x35, 0x37, 0x66, 0x64, 0x39, 0x38, 0x66, 0x37, 0x31, 0x35, 0x31, 0x31, 0x36, 0x33, 0x65, 0x34, 0x35, 0x36, 0x34, 0x38, 0x65, 0x62, 0x31, 0x38, 0x32, 0x66, 0x32, 0x30, 0x37, 0x30, 0x36, 0x32, 0x63, 0x38, 0x64, 0x30, 0x62, 0x37, 0x33, 0x66, 0x61, 0x35, 0x64, 0x30, 0x65, 0x63, 0x34, 0x30, 0x64, 0x39, 0x32, 0x38, 0x37, 0x39, 0x64, 0x36, 0x63, 0x65, 0x63, 0x36, 0x38, 0x33, 0x63, 0x34, 0x34, 0x34, 0x34, 0x33, 0x65, 0x37, 0x38, 0x34, 0x33, 0x65, 0x61, 0x30, 0x64, 0x65, 0x36, 0x30, 0x34, 0x33, 0x63, 0x31, 0x61, 0x62, 0x32, 0x66, 0x66, 0x34, 0x37, 0x32, 0x66, 0x34, 0x61, 0x32, 0x35, 0x61, 0x39, 0x30, 0x62, 0x32, 0x31, 0x66, 0x66, 0x38, 0x32, 0x38, 0x34, 0x64, 0x65, 0x66, 0x66, 0x66, 0x34, 0x38, 0x32, 0x62, 0x65, 0x36, 0x66, 0x33, 0x37, 0x36, 0x37, 0x39, 0x66, 0x64, 0x37, 0x32, 0x33, 0x65, 0x31, 0x38, 0x66, 0x61, 0x38, 0x66, 0x64, 0x35, 0x35, 0x36, 0x34, 0x35, 0x37, 0x39, 0x64, 0x37, 0x62, 0x31, 0x66, 0x30, 0x32, 0x39, 0x37, 0x32, 0x37, 0x30, 0x36, 0x34, 0x64, 0x36, 0x64, 0x63, 0x30, 0x39, 0x61, 0x33, 0x64, 0x30, 0x30, 0x65, 0x65, 0x33, 0x30, 0x61, 0x34, 0x30, 0x34, 0x30, 0x39, 0x39, 0x63, 0x65, 0x31, 0x62, 0x33, 0x34, 0x38, 0x38, 0x36, 0x65, 0x63, 0x37, 0x36, 0x65, 0x35, 0x30, 0x32, 0x32, 0x39, 0x65, 0x38, 0x32, 0x39, 0x31, 0x61, 0x37, 0x37, 0x39, 0x30, 0x63, 0x36, 0x62, 0x34, 0x36, 0x66, 0x61, 0x35, 0x62, 0x39, 0x63, 0x30, 0x39, 0x65, 0x64, 0x36, 0x61, 0x31, 0x30, 0x62, 0x32, 0x36, 0x33, 0x37, 0x63, 0x62, 0x65, 0x63, 0x62, 0x38, 0x65, 0x63, 0x38, 0x32, 0x61, 0x30, 0x37, 0x61, 0x38, 0x32, 0x66, 0x37, 0x33, 0x66, 0x31, 0x63, 0x31, 0x35, 0x34, 0x62, 0x39, 0x37, 0x61, 0x31, 0x34, 0x62, 0x31, 0x34, 0x32, 0x32, 0x63, 0x31, 0x64, 0x36, 0x65, 0x62, 0x66, 0x64, 0x32, 0x30, 0x64, 0x37, 0x31, 0x31, 0x30, 0x39, 0x36, 0x65, 0x66, 0x66, 0x32, 0x34, 0x65, 0x35, 0x65, 0x64, 0x62, 0x30, 0x35, 0x35, 0x33, 0x61, 0x66, 0x64, 0x64, 0x65, 0x38, 0x33, 0x65, 0x64, 0x35, 0x39, 0x62, 0x32, 0x33, 0x32, 0x64, 0x66, 0x39, 0x32, 0x36, 0x39, 0x64, 0x63, 0x65, 0x34, 0x62, 0x62, 0x31, 0x37, 0x33, 0x36, 0x31, 0x30, 0x30, 0x38, 0x66, 0x37, 0x62, 0x37, 0x33, 0x31, 0x62, 0x62, 0x34, 0x35, 0x66, 0x34, 0x33, 0x31, 0x64, 0x65, 0x30, 0x37, 0x35, 0x66, 0x31, 0x34, 0x31, 0x35, 0x39, 0x36, 0x62, 0x66, 0x65, 0x34, 0x61, 0x30, 0x38, 0x66, 0x63, 0x38, 0x66, 0x37, 0x30, 0x37, 0x61, 0x38, 0x62, 0x37, 0x65, 0x34, 0x66, 0x63, 0x63, 0x61, 0x63, 0x36, 0x66, 0x36, 0x30, 0x34, 0x38, 0x39, 0x65, 0x62, 0x38, 0x38, 0x30, 0x30, 0x38, 0x37, 0x32, 0x33, 0x64, 0x38, 0x31, 0x64, 0x37, 0x37, 0x32, 0x36, 0x31, 0x62, 0x37, 0x64, 0x32, 0x64, 0x64, 0x36, 0x63, 0x66, 0x34, 0x62, 0x32, 0x36, 0x62, 0x31, 0x62, 0x65, 0x34, 0x37, 0x31, 0x63, 0x63, 0x35, 0x35, 0x66, 0x37, 0x37, 0x34, 0x63, 0x34, 0x37, 0x39, 0x65, 0x66, 0x61, 0x36, 0x32, 0x39, 0x66, 0x66, 0x61, 0x35, 0x38, 0x30, 0x35, 0x30, 0x32, 0x39, 0x36, 0x34, 0x63, 0x36, 0x31, 0x61, 0x38, 0x39, 0x62, 0x39, 0x39, 0x38, 0x34, 0x30, 0x62, 0x61, 0x33, 0x36, 0x34, 0x38, 0x33, 0x63, 0x66, 0x63, 0x35, 0x66, 0x32, 0x61, 0x66, 0x39, 0x63, 0x62, 0x31, 0x64, 0x63, 0x37, 0x33, 0x36, 0x66, 0x33, 0x39, 0x38, 0x39, 0x66, 0x64, 0x61, 0x65, 0x32, 0x32, 0x33, 0x66, 0x34, 0x35, 0x61, 0x62, 0x30, 0x30, 0x66, 0x65, 0x63, 0x66, 0x66, 0x31, 0x39, 0x61, 0x39, 0x63, 0x37, 0x63, 0x35, 0x39, 0x61, 0x35, 0x39, 0x33, 0x33, 0x37, 0x32, 0x35, 0x33, 0x35, 0x65, 0x64, 0x63, 0x39, 0x66, 0x30, 0x33, 0x30, 0x36, 0x65, 0x32, 0x65, 0x61, 0x38, 0x35, 0x64, 0x33, 0x37, 0x63, 0x66, 0x64, 0x36, 0x36, 0x32, 0x66, 0x36, 0x33, 0x36, 0x35, 0x33, 0x63, 0x63, 0x61, 0x36, 0x35, 0x38, 0x62, 0x66, 0x64, 0x36, 0x37, 0x37, 0x31, 0x30, 0x32, 0x62, 0x30, 0x35, 0x64, 0x64, 0x35, 0x65, 0x61, 0x33, 0x39, 0x61, 0x31, 0x66, 0x30, 0x34, 0x30, 0x65, 0x62, 0x66, 0x33, 0x37, 0x31, 0x37, 0x61, 0x34, 0x66, 0x37, 0x34, 0x33, 0x39, 0x34, 0x61, 0x32, 0x35, 0x63, 0x61, 0x65, 0x35, 0x37, 0x63, 0x61, 0x32, 0x65, 0x30, 0x31, 0x33, 0x64, 0x38, 0x39, 0x37, 0x65, 0x65, 0x31, 0x30, 0x37, 0x63, 0x38, 0x30, 0x62, 0x65, 0x62, 0x66, 0x63, 0x62, 0x38, 0x30, 0x63, 0x65, 0x64, 0x38, 0x61, 0x64, 0x64, 0x30, 0x62, 0x33, 0x35, 0x35, 0x32, 0x33, 0x65, 0x36, 0x66, 0x39, 0x38, 0x61, 0x64, 0x33, 0x61, 0x39, 0x64, 0x66, 0x39, 0x38, 0x62, 0x33, 0x37, 0x37, 0x61, 0x32, 0x34, 0x31, 0x32, 0x65, 0x66, 0x61, 0x64, 0x39, 0x66, 0x37, 0x63, 0x30, 0x61, 0x61, 0x38, 0x36, 0x33, 0x36, 0x37, 0x36, 0x35, 0x64, 0x37, 0x66, 0x61, 0x38, 0x31, 0x33, 0x63, 0x30, 0x32, 0x37, 0x66, 0x63, 0x35, 0x39, 0x30, 0x63, 0x30, 0x31, 0x34, 0x39, 0x37, 0x32, 0x33, 0x62, 0x64, 0x65, 0x33, 0x63, 0x65, 0x38, 0x65, 0x63, 0x38, 0x38, 0x63, 0x62, 0x64, 0x32, 0x39, 0x31, 0x37, 0x37, 0x64, 0x37, 0x61, 0x33, 0x38, 0x63, 0x32, 0x33, 0x65, 0x61, 0x66, 0x66, 0x64, 0x65, 0x34, 0x37, 0x38, 0x31, 0x66, 0x33, 0x62, 0x64, 0x38, 0x34, 0x61, 0x64, 0x66, 0x35, 0x65, 0x63, 0x38, 0x39, 0x36, 0x62, 0x34, 0x34, 0x33, 0x32, 0x32, 0x30, 0x66, 0x36, 0x37, 0x32, 0x34, 0x37, 0x66, 0x62, 0x63, 0x38, 0x32, 0x64, 0x61, 0x62, 0x61, 0x32, 0x62, 0x35, 0x62, 0x63, 0x32, 0x62, 0x31, 0x65, 0x64, 0x62, 0x63, 0x30, 0x64, 0x31, 0x30, 0x64, 0x39, 0x63, 0x38, 0x64, 0x65, 0x38, 0x33, 0x32, 0x62, 0x32, 0x31, 0x36, 0x35, 0x63, 0x39, 0x33, 0x66, 0x31, 0x32, 0x36, 0x37, 0x36, 0x39, 0x32, 0x33, 0x35, 0x36, 0x37, 0x66, 0x64, 0x63, 0x63, 0x34, 0x65, 0x37, 0x32, 0x63, 0x39, 0x37, 0x31, 0x39, 0x66, 0x30, 0x31, 0x30, 0x64, 0x31, 0x37, 0x39, 0x61, 0x61, 0x39, 0x35, 0x39, 0x64, 0x65, 0x34, 0x66, 0x65, 0x30, 0x35, 0x35, 0x65, 0x33, 0x62, 0x61, 0x35, 0x30, 0x66, 0x31, 0x62, 0x37, 0x39, 0x34, 0x37, 0x37, 0x65, 0x31, 0x38, 0x63, 0x35, 0x34, 0x64, 0x65, 0x31, 0x62, 0x37, 0x66, 0x65, 0x33, 0x63, 0x62, 0x37, 0x33, 0x31, 0x65, 0x66, 0x33, 0x37, 0x32, 0x33, 0x64, 0x37, 0x34, 0x33, 0x39, 0x30, 0x37, 0x30, 0x61, 0x35, 0x62, 0x66, 0x39, 0x36, 0x62, 0x35, 0x38, 0x65, 0x63, 0x35, 0x39, 0x37, 0x39, 0x37, 0x33, 0x34, 0x61, 0x32, 0x34, 0x62, 0x63, 0x32, 0x64, 0x39, 0x35, 0x61, 0x66, 0x65, 0x66, 0x30, 0x39, 0x63, 0x38, 0x62, 0x64, 0x37, 0x39, 0x31, 0x65, 0x30, 0x63, 0x64, 0x30, 0x39, 0x38, 0x61, 0x30, 0x61, 0x61, 0x35, 0x39, 0x30, 0x39, 0x65, 0x30, 0x35, 0x35, 0x62, 0x61, 0x36, 0x35, 0x65, 0x64, 0x61, 0x65, 0x64, 0x66, 0x33, 0x38, 0x31, 0x32, 0x36, 0x30, 0x31, 0x31, 0x61, 0x62, 0x39, 0x62, 0x65, 0x33, 0x66, 0x39, 0x37, 0x63, 0x65, 0x32, 0x65, 0x33, 0x64, 0x66, 0x35, 0x62, 0x66, 0x64, 0x62, 0x65, 0x34, 0x32, 0x66, 0x35, 0x61, 0x32, 0x66, 0x65, 0x35, 0x63, 0x63, 0x61, 0x39, 0x61, 0x33, 0x30, 0x36, 0x61, 0x37, 0x32, 0x63, 0x39, 0x64, 0x33, 0x65, 0x35, 0x66, 0x62, 0x32, 0x39, 0x35, 0x63, 0x64, 0x37, 0x33, 0x33, 0x66, 0x65, 0x35, 0x38, 0x31, 0x64, 0x38, 0x62, 0x38, 0x34, 0x32, 0x39, 0x35, 0x35, 0x66, 0x63, 0x35, 0x39, 0x34, 0x61, 0x33, 0x38, 0x31, 0x62, 0x62, 0x64, 0x37, 0x38, 0x35, 0x61, 0x36, 0x61, 0x33, 0x66, 0x31, 0x38, 0x36, 0x38, 0x64, 0x35, 0x38, 0x38, 0x36, 0x63, 0x63, 0x36, 0x37, 0x32, 0x32, 0x61, 0x30, 0x66, 0x62, 0x33, 0x34, 0x35, 0x31, 0x61, 0x64, 0x65, 0x61, 0x64, 0x64, 0x34, 0x61, 0x65, 0x62, 0x33, 0x32, 0x34, 0x30, 0x62, 0x31, 0x31, 0x30, 0x63, 0x33, 0x38, 0x64, 0x65, 0x38, 0x34, 0x30, 0x39, 0x36, 0x36, 0x32, 0x35, 0x33, 0x34, 0x35, 0x65, 0x62, 0x30, 0x66, 0x66, 0x31, 0x33, 0x35, 0x33, 0x36, 0x61, 0x66, 0x35, 0x38, 0x34, 0x35, 0x63, 0x35, 0x30, 0x37, 0x32, 0x37, 0x34, 0x63, 0x62, 0x36, 0x30, 0x30, 0x34, 0x65, 0x32, 0x62, 0x65, 0x33, 0x37, 0x66, 0x61, 0x30, 0x30, 0x62, 0x62, 0x30, 0x37, 0x33, 0x64, 0x61, 0x62, 0x35, 0x36, 0x32, 0x36, 0x65, 0x30, 0x64, 0x63, 0x61, 0x34, 0x63, 0x61, 0x37, 0x32, 0x66, 0x61, 0x33, 0x31, 0x35, 0x66, 0x65, 0x38, 0x35, 0x66, 0x38, 0x33, 0x33, 0x38, 0x62, 0x39, 0x39, 0x31, 0x31, 0x64, 0x65, 0x61, 0x37, 0x30, 0x30, 0x33, 0x34, 0x35, 0x36, 0x66, 0x33, 0x62, 0x38, 0x38, 0x62, 0x35, 0x62, 0x64, 0x39, 0x32, 0x61, 0x32, 0x32, 0x37, 0x37, 0x34, 0x38, 0x61, 0x61, 0x32, 0x33, 0x35, 0x65, 0x38, 0x31, 0x63, 0x63, 0x31, 0x39, 0x65, 0x64, 0x35, 0x39, 0x38, 0x61, 0x65, 0x61, 0x31, 0x65, 0x65, 0x31, 0x65, 0x31, 0x35, 0x64, 0x35, 0x35, 0x30, 0x39, 0x34, 0x30, 0x64, 0x38, 0x36, 0x36, 0x31, 0x37, 0x32, 0x32, 0x30, 0x31, 0x65, 0x33, 0x32, 0x36, 0x33, 0x39, 0x66, 0x61, 0x65, 0x31, 0x36, 0x37, 0x33, 0x65, 0x38, 0x34, 0x64, 0x35, 0x35, 0x32, 0x64, 0x37, 0x35, 0x38, 0x61, 0x32, 0x34, 0x38, 0x64, 0x32, 0x30, 0x34, 0x33, 0x32, 0x61, 0x33, 0x62, 0x35, 0x35, 0x63, 0x62, 0x38, 0x61, 0x34, 0x63, 0x65, 0x31, 0x65, 0x66, 0x61, 0x34, 0x65, 0x38, 0x61, 0x66, 0x63, 0x32, 0x36, 0x36, 0x32, 0x39, 0x32, 0x62, 0x66, 0x34, 0x36, 0x38, 0x35, 0x63, 0x31, 0x39, 0x30, 0x38, 0x34, 0x63, 0x33, 0x39, 0x37, 0x63, 0x39, 0x33, 0x66, 0x61, 0x65, 0x34, 0x34, 0x35, 0x34, 0x64, 0x31, 0x34, 0x65, 0x65, 0x32, 0x62, 0x66, 0x64, 0x34, 0x34, 0x61, 0x61, 0x31, 0x63, 0x64, 0x33, 0x35, 0x66, 0x31, 0x31, 0x39, 0x32, 0x35, 0x38, 0x61, 0x32, 0x62, 0x39, 0x65, 0x39, 0x33, 0x36, 0x66, 0x66, 0x37, 0x32, 0x31, 0x34, 0x63, 0x65, 0x37, 0x65, 0x37, 0x38, 0x39, 0x32, 0x65, 0x63, 0x36, 0x61, 0x35, 0x32, 0x32, 0x30, 0x35, 0x61, 0x36, 0x62, 0x31, 0x61, 0x30, 0x64, 0x35, 0x36, 0x61, 0x31, 0x36, 0x32, 0x63, 0x66, 0x39, 0x38, 0x31, 0x37, 0x34, 0x32, 0x65, 0x64, 0x38, 0x37, 0x65, 0x34, 0x61, 0x36, 0x61, 0x32, 0x37, 0x63, 0x65, 0x36, 0x33, 0x64, 0x64, 0x33, 0x37, 0x32, 0x30, 0x63, 0x31, 0x35, 0x63, 0x66, 0x38, 0x61, 0x39, 0x38, 0x37, 0x66, 0x64, 0x31, 0x62, 0x31, 0x38, 0x36, 0x63, 0x66, 0x32, 0x33, 0x31, 0x64, 0x39, 0x38, 0x37, 0x36, 0x33, 0x62, 0x66, 0x35, 0x66, 0x63, 0x34, 0x33, 0x30, 0x30, 0x34, 0x66, 0x64, 0x38, 0x64, 0x38, 0x37, 0x38, 0x35, 0x65, 0x61, 0x64, 0x33, 0x62, 0x36, 0x37, 0x61, 0x61, 0x34, 0x61, 0x64, 0x30, 0x34, 0x61, 0x37, 0x30, 0x63, 0x37, 0x37, 0x32, 0x64, 0x36, 0x32, 0x38, 0x39, 0x61, 0x35, 0x35, 0x31, 0x65, 0x62, 0x34, 0x36, 0x33, 0x30, 0x38, 0x39, 0x63, 0x32, 0x61, 0x63, 0x64, 0x66, 0x65, 0x61, 0x34, 0x63, 0x37, 0x37, 0x66, 0x63, 0x37, 0x33, 0x35, 0x33, 0x65, 0x37, 0x35, 0x63, 0x66, 0x30, 0x37, 0x65, 0x36, 0x39, 0x63, 0x35, 0x33, 0x66, 0x38, 0x35, 0x32, 0x31, 0x33, 0x63, 0x30, 0x66, 0x62, 0x34, 0x61, 0x65, 0x35, 0x37, 0x32, 0x37, 0x30, 0x61, 0x66, 0x32, 0x61, 0x39, 0x66, 0x37, 0x30, 0x64, 0x64, 0x31, 0x31, 0x30, 0x35, 0x36, 0x38, 0x35, 0x65, 0x61, 0x66, 0x63, 0x35, 0x65, 0x62, 0x63, 0x62, 0x38, 0x64, 0x38, 0x37, 0x33, 0x37, 0x64, 0x34, 0x35, 0x34, 0x63, 0x64, 0x34, 0x65, 0x61, 0x31, 0x31, 0x63, 0x32, 0x30, 0x34, 0x35, 0x66, 0x36, 0x64, 0x32, 0x32, 0x62, 0x65, 0x38, 0x35, 0x63, 0x63, 0x38, 0x34, 0x64, 0x34, 0x35, 0x65, 0x38, 0x64, 0x65, 0x36, 0x64, 0x66, 0x64, 0x65, 0x37, 0x63, 0x66, 0x34, 0x62, 0x61, 0x65, 0x61, 0x36, 0x64, 0x62, 0x38, 0x66, 0x33, 0x30, 0x39, 0x63, 0x65, 0x38, 0x35, 0x37, 0x35, 0x66, 0x61, 0x63, 0x62, 0x61, 0x64, 0x37, 0x65, 0x63, 0x33, 0x61, 0x62, 0x35, 0x63, 0x38, 0x63, 0x63, 0x39, 0x35, 0x36, 0x34, 0x33, 0x31, 0x30, 0x31, 0x62, 0x33, 0x63, 0x64, 0x36, 0x37, 0x38, 0x64, 0x31, 0x36, 0x61, 0x35, 0x34, 0x65, 0x38, 0x35, 0x37, 0x63, 0x62, 0x37, 0x65, 0x32, 0x37, 0x66, 0x65, 0x37, 0x32, 0x35, 0x36, 0x62, 0x61, 0x30, 0x37, 0x35, 0x35, 0x64, 0x64, 0x38, 0x30, 0x34, 0x64, 0x36, 0x61, 0x61, 0x36, 0x62, 0x39, 0x37, 0x62, 0x36, 0x38, 0x36, 0x61, 0x30, 0x31, 0x31, 0x32, 0x61, 0x65, 0x36, 0x32, 0x61, 0x63, 0x30, 0x36, 0x33, 0x33, 0x61, 0x31, 0x62, 0x36, 0x32, 0x37, 0x34, 0x33, 0x65, 0x36, 0x63, 0x35, 0x36, 0x36, 0x37, 0x39, 0x35, 0x36, 0x66, 0x31, 0x37, 0x65, 0x39, 0x38, 0x65, 0x62, 0x64, 0x65, 0x62, 0x66, 0x33, 0x65, 0x32, 0x65, 0x36, 0x33, 0x66, 0x38, 0x33, 0x38, 0x34, 0x33, 0x31, 0x62, 0x30, 0x31, 0x66, 0x65, 0x35, 0x32, 0x38, 0x37, 0x38, 0x66, 0x64, 0x63, 0x38, 0x32, 0x39, 0x39, 0x33, 0x65, 0x64, 0x63, 0x34, 0x33, 0x65, 0x65, 0x61, 0x31, 0x35, 0x30, 0x64, 0x65, 0x36, 0x34, 0x32, 0x37, 0x66, 0x61, 0x37, 0x63, 0x62, 0x34, 0x61, 0x64, 0x36, 0x62, 0x31, 0x63, 0x37, 0x37, 0x39, 0x66, 0x66, 0x30, 0x33, 0x33, 0x32, 0x34, 0x65, 0x38, 0x61, 0x34, 0x39, 0x36, 0x39, 0x30, 0x36, 0x35, 0x31, 0x63, 0x64, 0x35, 0x38, 0x31, 0x35, 0x32, 0x33, 0x64, 0x64, 0x37, 0x62, 0x34, 0x63, 0x65, 0x62, 0x39, 0x33, 0x36, 0x62, 0x65, 0x34, 0x62, 0x30, 0x30, 0x35, 0x35, 0x33, 0x61, 0x66, 0x34, 0x38, 0x33, 0x37, 0x64, 0x36, 0x36, 0x37, 0x66, 0x65, 0x65, 0x31, 0x62, 0x34, 0x63, 0x66, 0x37, 0x33, 0x65, 0x31, 0x65, 0x35, 0x36, 0x64, 0x62, 0x35, 0x64, 0x61, 0x63, 0x62, 0x66, 0x37, 0x35, 0x32, 0x34, 0x64, 0x36, 0x38, 0x65, 0x61, 0x30, 0x34, 0x64, 0x34, 0x64, 0x35, 0x62, 0x61, 0x35, 0x33, 0x30, 0x62, 0x34, 0x30, 0x38, 0x66, 0x31, 0x36, 0x65, 0x61, 0x32, 0x65, 0x37, 0x30, 0x30, 0x63, 0x33, 0x36, 0x37, 0x34, 0x36, 0x63, 0x66, 0x39, 0x62, 0x33, 0x39, 0x64, 0x39, 0x36, 0x37, 0x33, 0x61, 0x62, 0x66, 0x31, 0x37, 0x64, 0x66, 0x38, 0x38, 0x63, 0x62, 0x30, 0x63, 0x36, 0x63, 0x39, 0x39, 0x64, 0x61, 0x34, 0x63, 0x36, 0x63, 0x62, 0x36, 0x37, 0x65, 0x61, 0x62, 0x63, 0x66, 0x33, 0x63, 0x33, 0x35, 0x37, 0x66, 0x38, 0x31, 0x36, 0x66, 0x64, 0x38, 0x62, 0x61, 0x65, 0x39, 0x33, 0x35, 0x39, 0x66, 0x39, 0x39, 0x62, 0x36, 0x39, 0x35, 0x62, 0x31, 0x36, 0x62, 0x65, 0x31, 0x32, 0x30, 0x62, 0x36, 0x37, 0x38, 0x31, 0x35, 0x33, 0x32, 0x35, 0x37, 0x31, 0x35, 0x63, 0x61, 0x39, 0x30, 0x34, 0x65, 0x34, 0x66, 0x35, 0x61, 0x30, 0x32, 0x36, 0x65, 0x32, 0x65, 0x33, 0x30, 0x66, 0x39, 0x32, 0x32, 0x37, 0x63, 0x33, 0x35, 0x63, 0x31, 0x64, 0x62, 0x35, 0x32, 0x32, 0x33, 0x32, 0x61, 0x64, 0x62, 0x33, 0x37, 0x65, 0x62, 0x39, 0x64, 0x33, 0x38, 0x35, 0x36, 0x63, 0x37, 0x37, 0x33, 0x35, 0x31, 0x64, 0x34, 0x65, 0x32, 0x35, 0x34, 0x35, 0x62, 0x61, 0x35, 0x35, 0x35, 0x62, 0x34, 0x39, 0x33, 0x35, 0x63, 0x63, 0x64, 0x35, 0x34, 0x38, 0x64, 0x37, 0x61, 0x64, 0x37, 0x32, 0x63, 0x36, 0x36, 0x34, 0x30, 0x66, 0x34, 0x37, 0x61, 0x65, 0x39, 0x36, 0x39, 0x33, 0x35, 0x36, 0x66, 0x61, 0x64, 0x30, 0x34, 0x66, 0x31, 0x37, 0x34, 0x32, 0x66, 0x30, 0x66, 0x34, 0x63, 0x66, 0x61, 0x36, 0x32, 0x35, 0x31, 0x34, 0x30, 0x31, 0x33, 0x66, 0x66, 0x34, 0x37, 0x62, 0x66, 0x31, 0x33, 0x33, 0x64, 0x38, 0x38, 0x35, 0x66, 0x65, 0x38, 0x36, 0x38, 0x37, 0x32, 0x65, 0x38, 0x64, 0x62, 0x62, 0x35, 0x32, 0x61, 0x32, 0x38, 0x66, 0x62, 0x66, 0x30, 0x34, 0x38, 0x63, 0x30, 0x30, 0x35, 0x31, 0x34, 0x65, 0x34, 0x33, 0x61, 0x61, 0x31, 0x31, 0x32, 0x31, 0x66, 0x34, 0x36, 0x38, 0x35, 0x30, 0x61, 0x34, 0x63, 0x62, 0x37, 0x66, 0x64, 0x32, 0x33, 0x61, 0x38, 0x38, 0x61, 0x61, 0x62, 0x64, 0x31, 0x37, 0x35, 0x64, 0x35, 0x35, 0x30, 0x38, 0x64, 0x61, 0x62, 0x34, 0x33, 0x66, 0x65, 0x61, 0x37, 0x32, 0x66, 0x62, 0x63, 0x33, 0x33, 0x64, 0x61, 0x30, 0x30, 0x63, 0x62, 0x63, 0x38, 0x65, 0x34, 0x37, 0x31, 0x33, 0x61, 0x65, 0x66, 0x35, 0x30, 0x35, 0x35, 0x63, 0x63, 0x35, 0x33, 0x38, 0x39, 0x66, 0x38, 0x32, 0x30, 0x38, 0x32, 0x30, 0x36, 0x64, 0x61, 0x39, 0x30, 0x35, 0x36, 0x62, 0x65, 0x38, 0x38, 0x30, 0x38, 0x34, 0x31, 0x31, 0x39, 0x31, 0x36, 0x65, 0x62, 0x37, 0x64, 0x39, 0x37, 0x32, 0x33, 0x35, 0x31, 0x32, 0x65, 0x36, 0x31, 0x39, 0x32, 0x33, 0x38, 0x66, 0x63, 0x64, 0x34, 0x31, 0x32, 0x33, 0x39, 0x33, 0x31, 0x36, 0x36, 0x30, 0x64, 0x63, 0x66, 0x34, 0x65, 0x64, 0x65, 0x38, 0x36, 0x37, 0x62, 0x61, 0x32, 0x64, 0x37, 0x30, 0x30, 0x64, 0x64, 0x30, 0x39, 0x35, 0x63, 0x62, 0x31, 0x36, 0x62, 0x32, 0x34, 0x35, 0x65, 0x34, 0x39, 0x64, 0x33, 0x36, 0x31, 0x64, 0x33, 0x30, 0x65, 0x32, 0x65, 0x66, 0x32, 0x66, 0x39, 0x39, 0x33, 0x33, 0x32, 0x37, 0x63, 0x30, 0x66, 0x63, 0x39, 0x38, 0x66, 0x66, 0x61, 0x34, 0x64, 0x35, 0x63, 0x65, 0x61, 0x66, 0x66, 0x39, 0x31, 0x39, 0x61, 0x64, 0x37, 0x34, 0x33, 0x38, 0x35, 0x38, 0x61, 0x39, 0x62, 0x36, 0x32, 0x63, 0x33, 0x35, 0x33, 0x37, 0x61, 0x66, 0x34, 0x61, 0x66, 0x38, 0x37, 0x37, 0x30, 0x64, 0x64, 0x61, 0x37, 0x32, 0x32, 0x65, 0x65, 0x34, 0x66, 0x66, 0x36, 0x37, 0x66, 0x38, 0x62, 0x37, 0x33, 0x33, 0x62, 0x32, 0x32, 0x31, 0x35, 0x32, 0x63, 0x65, 0x37, 0x35, 0x33, 0x31, 0x64, 0x63, 0x38, 0x39, 0x38, 0x65, 0x32, 0x31, 0x33, 0x39, 0x35, 0x30, 0x63, 0x34, 0x39, 0x38, 0x63, 0x63, 0x63, 0x31, 0x35, 0x63, 0x33, 0x37, 0x34, 0x37, 0x34, 0x61, 0x37, 0x37, 0x32, 0x37, 0x36, 0x61, 0x32, 0x62, 0x37, 0x32, 0x65, 0x38, 0x66, 0x34, 0x61, 0x32, 0x61, 0x65, 0x36, 0x39, 0x61, 0x30, 0x63, 0x66, 0x39, 0x30, 0x65, 0x36, 0x38, 0x66, 0x61, 0x35, 0x30, 0x31, 0x31, 0x36, 0x65, 0x37, 0x35, 0x33, 0x39, 0x62, 0x34, 0x35, 0x66, 0x63, 0x61, 0x64, 0x66, 0x34, 0x61, 0x39, 0x39, 0x38, 0x66, 0x38, 0x31, 0x38, 0x33, 0x31, 0x30, 0x37, 0x33, 0x61, 0x37, 0x66, 0x62, 0x38, 0x61, 0x33, 0x31, 0x62, 0x32, 0x62, 0x38, 0x33, 0x35, 0x39, 0x36, 0x39, 0x32, 0x32, 0x37, 0x33, 0x64, 0x62, 0x35, 0x65, 0x35, 0x65, 0x30, 0x62, 0x34, 0x65, 0x61, 0x65, 0x38, 0x65, 0x35, 0x61, 0x33, 0x33, 0x63, 0x62, 0x65, 0x65, 0x36, 0x35, 0x65, 0x64, 0x31, 0x31, 0x35, 0x31, 0x30, 0x32, 0x66, 0x38, 0x32, 0x63, 0x36, 0x61, 0x61, 0x39, 0x33, 0x38, 0x64, 0x36, 0x39, 0x36, 0x62, 0x64, 0x65, 0x30, 0x65, 0x35, 0x37, 0x32, 0x30, 0x63, 0x35, 0x64, 0x62, 0x36, 0x39, 0x34, 0x34, 0x66, 0x37, 0x62, 0x34, 0x37, 0x34, 0x34, 0x31, 0x35, 0x65, 0x37, 0x31, 0x32, 0x65, 0x35, 0x64, 0x32, 0x30, 0x30, 0x30, 0x36, 0x37, 0x38, 0x38, 0x37, 0x34, 0x64, 0x63, 0x36, 0x65, 0x66, 0x31, 0x34, 0x65, 0x32, 0x34, 0x62, 0x38, 0x38, 0x37, 0x66, 0x39, 0x31, 0x34, 0x32, 0x65, 0x34, 0x61, 0x36, 0x39, 0x32, 0x64, 0x66, 0x30, 0x37, 0x34, 0x66, 0x39, 0x65, 0x62, 0x36, 0x65, 0x39, 0x62, 0x37, 0x38, 0x65, 0x37, 0x38, 0x31, 0x31, 0x32, 0x62, 0x61, 0x33, 0x66, 0x39, 0x64, 0x30, 0x62, 0x62, 0x36, 0x65, 0x63, 0x62, 0x64, 0x61, 0x65, 0x31, 0x62, 0x36, 0x37, 0x61, 0x31, 0x62, 0x30, 0x61, 0x31, 0x63, 0x62, 0x35, 0x34, 0x34, 0x30, 0x31, 0x65, 0x39, 0x63, 0x64, 0x32, 0x62, 0x32, 0x65, 0x36, 0x39, 0x36, 0x39, 0x37, 0x32, 0x36, 0x65, 0x34, 0x30, 0x65, 0x31, 0x65, 0x61, 0x31, 0x35, 0x61, 0x33, 0x66, 0x33, 0x33, 0x35, 0x36, 0x31, 0x37, 0x64, 0x30, 0x64, 0x33, 0x61, 0x62, 0x61, 0x32, 0x37, 0x35, 0x36, 0x61, 0x34, 0x31, 0x39, 0x61, 0x37, 0x62, 0x62, 0x34, 0x36, 0x62, 0x34, 0x65, 0x66, 0x63, 0x65, 0x35, 0x65, 0x66, 0x66, 0x61, 0x63, 0x37, 0x64, 0x38, 0x37, 0x65, 0x30, 0x37, 0x63, 0x63, 0x66, 0x37, 0x32, 0x38, 0x38, 0x37, 0x63, 0x38, 0x64, 0x36, 0x32, 0x64, 0x39, 0x62, 0x65, 0x39, 0x38, 0x63, 0x30, 0x61, 0x37, 0x33, 0x36, 0x62, 0x38, 0x65, 0x39, 0x32, 0x61, 0x36, 0x39, 0x35, 0x34, 0x34, 0x66, 0x66, 0x34, 0x31, 0x63, 0x30, 0x64, 0x33, 0x61, 0x65, 0x34, 0x64, 0x36, 0x37, 0x39, 0x64, 0x34, 0x37, 0x33, 0x39, 0x38, 0x61, 0x37, 0x36, 0x33, 0x64, 0x37, 0x39, 0x35, 0x39, 0x30, 0x35, 0x32, 0x38, 0x32, 0x33, 0x33, 0x63, 0x33, 0x35, 0x36, 0x33, 0x31, 0x31, 0x36, 0x35, 0x38, 0x36, 0x32, 0x62, 0x62, 0x34, 0x63, 0x37, 0x36, 0x32, 0x36, 0x61, 0x34, 0x62, 0x36, 0x31, 0x35, 0x36, 0x34, 0x62, 0x33, 0x35, 0x31, 0x36, 0x31, 0x36, 0x39, 0x35, 0x35, 0x39, 0x64, 0x39, 0x66, 0x39, 0x34, 0x61, 0x34, 0x62, 0x39, 0x65, 0x35, 0x63, 0x33, 0x37, 0x33, 0x63, 0x63, 0x61, 0x33, 0x33, 0x32, 0x30, 0x61, 0x33, 0x65, 0x62, 0x66, 0x39, 0x65, 0x66, 0x35, 0x34, 0x38, 0x65, 0x34, 0x61, 0x65, 0x31, 0x30, 0x31, 0x66, 0x66, 0x64, 0x31, 0x35, 0x35, 0x66, 0x31, 0x39, 0x33, 0x65, 0x35, 0x65, 0x38, 0x64, 0x35, 0x62, 0x35, 0x33, 0x33, 0x38, 0x34, 0x34, 0x37, 0x66, 0x34, 0x32, 0x39, 0x36, 0x62, 0x34, 0x33, 0x38, 0x36, 0x34, 0x63, 0x37, 0x35, 0x39, 0x39, 0x38, 0x65, 0x62, 0x37, 0x32, 0x30, 0x33, 0x33, 0x62, 0x64, 0x32, 0x34, 0x32, 0x30, 0x61, 0x66, 0x32, 0x30, 0x35, 0x61, 0x65, 0x62, 0x61, 0x39, 0x66, 0x63, 0x65, 0x35, 0x34, 0x38, 0x61, 0x66, 0x36, 0x65, 0x39, 0x36, 0x38, 0x65, 0x33, 0x63, 0x30, 0x39, 0x33, 0x65, 0x31, 0x31, 0x61, 0x31, 0x34, 0x63, 0x63, 0x34, 0x66, 0x61, 0x63, 0x38, 0x38, 0x64, 0x39, 0x39, 0x37, 0x66, 0x62, 0x66, 0x63, 0x36, 0x64, 0x37, 0x32, 0x39, 0x39, 0x38, 0x32, 0x39, 0x62, 0x39, 0x62, 0x38, 0x34, 0x61, 0x32, 0x33, 0x33, 0x36, 0x63, 0x34, 0x34, 0x34, 0x32, 0x36, 0x65, 0x33, 0x36, 0x63, 0x63, 0x62, 0x66, 0x63, 0x36, 0x61, 0x30, 0x36, 0x33, 0x63, 0x66, 0x63, 0x65, 0x39, 0x32, 0x32, 0x39, 0x30, 0x38, 0x30, 0x62, 0x64, 0x61, 0x64, 0x61, 0x65, 0x61, 0x64, 0x33, 0x61, 0x36, 0x33, 0x35, 0x30, 0x37, 0x33, 0x37, 0x36, 0x38, 0x64, 0x39, 0x37, 0x39, 0x39, 0x37, 0x36, 0x61, 0x61, 0x34, 0x61, 0x30, 0x63, 0x30, 0x34, 0x31, 0x33, 0x62, 0x38, 0x62, 0x39, 0x33, 0x36, 0x66, 0x39, 0x39, 0x38, 0x31, 0x65, 0x63, 0x65, 0x63, 0x38, 0x33, 0x62, 0x63, 0x35, 0x33, 0x37, 0x64, 0x66, 0x30, 0x33, 0x37, 0x65, 0x65, 0x33, 0x66, 0x36, 0x61, 0x64, 0x65, 0x63, 0x36, 0x39, 0x37, 0x63, 0x61, 0x38, 0x32, 0x63, 0x33, 0x35, 0x61, 0x35, 0x31, 0x61, 0x33, 0x32, 0x33, 0x66, 0x64, 0x64, 0x65, 0x37, 0x35, 0x34, 0x35, 0x32, 0x32, 0x66, 0x38, 0x33, 0x31, 0x33, 0x61, 0x30, 0x64, 0x32, 0x34, 0x64, 0x35, 0x63, 0x32, 0x62, 0x39, 0x30, 0x30, 0x65, 0x65, 0x66, 0x66, 0x65, 0x64, 0x62, 0x63, 0x65, 0x62, 0x35, 0x65, 0x64, 0x63, 0x36, 0x66, 0x38, 0x31, 0x62, 0x34, 0x37, 0x65, 0x65, 0x39, 0x36, 0x38, 0x66, 0x34, 0x37, 0x32, 0x61, 0x34, 0x37, 0x61, 0x31, 0x63, 0x34, 0x38, 0x35, 0x63, 0x62, 0x36, 0x35, 0x33, 0x30, 0x32, 0x38, 0x39, 0x66, 0x30, 0x32, 0x38, 0x37, 0x64, 0x65, 0x64, 0x61, 0x31, 0x39, 0x36, 0x39, 0x35, 0x66, 0x34, 0x31, 0x64, 0x32, 0x38, 0x37, 0x35, 0x39, 0x37, 0x30, 0x65, 0x63, 0x39, 0x63, 0x35, 0x64, 0x61, 0x63, 0x32, 0x37, 0x39, 0x30, 0x39, 0x39, 0x62, 0x34, 0x32, 0x34, 0x38, 0x36, 0x35, 0x63, 0x65, 0x65, 0x34, 0x36, 0x30, 0x37, 0x31, 0x66, 0x61, 0x33, 0x38, 0x64, 0x37, 0x38, 0x32, 0x31, 0x66, 0x36, 0x36, 0x33, 0x35, 0x34, 0x63, 0x38, 0x37, 0x66, 0x39, 0x30, 0x65, 0x37, 0x33, 0x66, 0x30, 0x39, 0x31, 0x32, 0x61, 0x38, 0x62, 0x35, 0x37, 0x37, 0x37, 0x61, 0x64, 0x32, 0x36, 0x65, 0x62, 0x62, 0x37, 0x31, 0x65, 0x33, 0x33, 0x37, 0x37, 0x37, 0x35, 0x39, 0x34, 0x37, 0x32, 0x37, 0x34, 0x36, 0x63, 0x31, 0x34, 0x36, 0x62, 0x36, 0x37, 0x32, 0x36, 0x32, 0x64, 0x66, 0x33, 0x39, 0x30, 0x31, 0x62, 0x65, 0x38, 0x64, 0x64, 0x33, 0x35, 0x65, 0x66, 0x65, 0x31, 0x62, 0x32, 0x36, 0x62, 0x63, 0x61, 0x61, 0x30, 0x35, 0x35, 0x37, 0x64, 0x37, 0x34, 0x61, 0x32, 0x31, 0x35, 0x33, 0x66, 0x66, 0x31, 0x30, 0x32, 0x62, 0x63, 0x37, 0x66, 0x30, 0x62, 0x61, 0x32, 0x37, 0x32, 0x64, 0x62, 0x38, 0x36, 0x64, 0x66, 0x37, 0x33, 0x37, 0x30, 0x34, 0x65, 0x63, 0x33, 0x38, 0x35, 0x36, 0x62, 0x62, 0x33, 0x39, 0x39, 0x31, 0x34, 0x32, 0x30, 0x30, 0x38, 0x38, 0x61, 0x62, 0x31, 0x32, 0x65, 0x37, 0x30, 0x39, 0x63, 0x37, 0x62, 0x34, 0x65, 0x61, 0x37, 0x64, 0x39, 0x32, 0x35, 0x35, 0x63, 0x63, 0x30, 0x35, 0x61, 0x63, 0x37, 0x38, 0x63, 0x63, 0x62, 0x35, 0x37, 0x37, 0x32, 0x34, 0x63, 0x30, 0x34, 0x34, 0x37, 0x66, 0x39, 0x64, 0x66, 0x39, 0x33, 0x35, 0x38, 0x36, 0x37, 0x63, 0x38, 0x64, 0x38, 0x31, 0x63, 0x35, 0x37, 0x31, 0x37, 0x64, 0x61, 0x33, 0x37, 0x36, 0x61, 0x39, 0x30, 0x34, 0x37, 0x32, 0x33, 0x62, 0x34, 0x33, 0x62, 0x64, 0x31, 0x32, 0x37, 0x34, 0x66, 0x62, 0x33, 0x36, 0x34, 0x30, 0x31, 0x39, 0x32, 0x33, 0x32, 0x34, 0x31, 0x36, 0x36, 0x37, 0x32, 0x64, 0x31, 0x61, 0x64, 0x30, 0x38, 0x32, 0x63, 0x63, 0x38, 0x35, 0x35, 0x61, 0x66, 0x66, 0x38, 0x34, 0x39, 0x35, 0x36, 0x63, 0x66, 0x63, 0x30, 0x38, 0x37, 0x61, 0x64, 0x32, 0x64, 0x36, 0x61, 0x32, 0x37, 0x38, 0x65, 0x39, 0x63, 0x33, 0x39, 0x36, 0x65, 0x31, 0x37, 0x62, 0x62, 0x35, 0x64, 0x64, 0x33, 0x32, 0x65, 0x39, 0x65, 0x34, 0x38, 0x35, 0x30, 0x37, 0x36, 0x34, 0x63, 0x30, 0x31, 0x30, 0x34, 0x33, 0x66, 0x39, 0x64, 0x34, 0x62, 0x37, 0x66, 0x34, 0x30, 0x61, 0x62, 0x64, 0x66, 0x64, 0x32, 0x32, 0x31, 0x39, 0x64, 0x31, 0x32, 0x64, 0x37, 0x33, 0x65, 0x34, 0x39, 0x38, 0x32, 0x63, 0x38, 0x34, 0x62, 0x36, 0x64, 0x33, 0x62, 0x38, 0x37, 0x64, 0x63, 0x31, 0x61, 0x36, 0x33, 0x61, 0x36, 0x66, 0x31, 0x38, 0x32, 0x32, 0x62, 0x38, 0x39, 0x33, 0x63, 0x32, 0x65, 0x37, 0x32, 0x66, 0x33, 0x37, 0x66, 0x38, 0x33, 0x32, 0x30, 0x36, 0x35, 0x38, 0x31, 0x36, 0x35, 0x34, 0x35, 0x63, 0x36, 0x62, 0x37, 0x62, 0x34, 0x61, 0x61, 0x64, 0x35, 0x37, 0x61, 0x34, 0x31, 0x63, 0x64, 0x31, 0x32, 0x63, 0x35, 0x38, 0x39, 0x38, 0x35, 0x38, 0x34, 0x34, 0x66, 0x30, 0x63, 0x63, 0x39, 0x37, 0x31, 0x63, 0x66, 0x30, 0x38, 0x38, 0x32, 0x33, 0x33, 0x36, 0x39, 0x32, 0x63, 0x33, 0x31, 0x36, 0x63, 0x62, 0x33, 0x66, 0x64, 0x33, 0x64, 0x63, 0x35, 0x35, 0x66, 0x64, 0x65, 0x36, 0x34, 0x33, 0x64, 0x30, 0x36, 0x38, 0x36, 0x63, 0x61, 0x30, 0x35, 0x36, 0x33, 0x38, 0x37, 0x30, 0x39, 0x31, 0x61, 0x61, 0x38, 0x61, 0x62, 0x63, 0x61, 0x63, 0x66, 0x61, 0x62, 0x61, 0x34, 0x35, 0x37, 0x30, 0x63, 0x30, 0x38, 0x64, 0x61, 0x34, 0x30, 0x37, 0x30, 0x37, 0x39, 0x62, 0x32, 0x37, 0x32, 0x30, 0x61, 0x31, 0x34, 0x33, 0x65, 0x65, 0x65, 0x63, 0x33, 0x36, 0x30, 0x34, 0x61, 0x39, 0x39, 0x33, 0x37, 0x33, 0x66, 0x30, 0x61, 0x64, 0x38, 0x37, 0x30, 0x37, 0x62, 0x65, 0x32, 0x34, 0x63, 0x33, 0x61, 0x37, 0x63, 0x65, 0x39, 0x39, 0x65, 0x31, 0x30, 0x62, 0x65, 0x30, 0x39, 0x33, 0x62, 0x61, 0x65, 0x35, 0x63, 0x35, 0x34, 0x30, 0x34, 0x33, 0x65, 0x36, 0x34, 0x34, 0x38, 0x30, 0x38, 0x36, 0x39, 0x35, 0x30, 0x61, 0x30, 0x31, 0x32, 0x39, 0x30, 0x39, 0x37, 0x39, 0x34, 0x63, 0x30, 0x34, 0x32, 0x63, 0x64, 0x66, 0x38, 0x33, 0x35, 0x38, 0x63, 0x31, 0x61, 0x65, 0x31, 0x35, 0x66, 0x33, 0x63, 0x35, 0x37, 0x33, 0x39, 0x30, 0x64, 0x65, 0x62, 0x64, 0x63, 0x30, 0x37, 0x39, 0x38, 0x61, 0x39, 0x37, 0x36, 0x37, 0x61, 0x34, 0x62, 0x30, 0x64, 0x66, 0x34, 0x32, 0x35, 0x31, 0x61, 0x38, 0x64, 0x36, 0x31, 0x39, 0x35, 0x36, 0x65, 0x33, 0x38, 0x66, 0x62, 0x34, 0x33, 0x63, 0x37, 0x33, 0x36, 0x34, 0x32, 0x35, 0x36, 0x35, 0x64, 0x64, 0x34, 0x30, 0x36, 0x38, 0x66, 0x39, 0x34, 0x61, 0x66, 0x32, 0x31, 0x36, 0x62, 0x34, 0x63, 0x31, 0x37, 0x65, 0x37, 0x61, 0x61, 0x66, 0x66, 0x36, 0x33, 0x38, 0x38, 0x65, 0x66, 0x65, 0x35, 0x38, 0x61, 0x66, 0x32, 0x32, 0x34, 0x37, 0x32, 0x38, 0x65, 0x33, 0x33, 0x33, 0x63, 0x62, 0x64, 0x64, 0x31, 0x33, 0x38, 0x64, 0x35, 0x61, 0x61, 0x36, 0x32, 0x36, 0x36, 0x34, 0x66, 0x38, 0x62, 0x39, 0x62, 0x66, 0x64, 0x63, 0x63, 0x32, 0x32, 0x36, 0x30, 0x65, 0x32, 0x36, 0x37, 0x34, 0x37, 0x32, 0x33, 0x32, 0x32, 0x30, 0x30, 0x30, 0x63, 0x64, 0x65, 0x32, 0x32, 0x30, 0x35, 0x66, 0x61, 0x30, 0x37, 0x64, 0x34, 0x39, 0x62, 0x37, 0x32, 0x65, 0x31, 0x63, 0x32, 0x34, 0x66, 0x61, 0x39, 0x32, 0x65, 0x61, 0x35, 0x34, 0x36, 0x39, 0x61, 0x32, 0x61, 0x31, 0x30, 0x66, 0x64, 0x64, 0x64, 0x30, 0x62, 0x37, 0x66, 0x37, 0x38, 0x38, 0x32, 0x63, 0x66, 0x39, 0x35, 0x64, 0x64, 0x36, 0x32, 0x36, 0x63, 0x62, 0x66, 0x34, 0x32, 0x34, 0x62, 0x31, 0x38, 0x65, 0x30, 0x62, 0x34, 0x36, 0x35, 0x64, 0x35, 0x39, 0x38, 0x38, 0x65, 0x32, 0x61, 0x35, 0x36, 0x37, 0x35, 0x63, 0x35, 0x33, 0x63, 0x34, 0x65, 0x30, 0x34, 0x66, 0x36, 0x30, 0x63, 0x38, 0x65, 0x35, 0x32, 0x31, 0x63, 0x39, 0x38, 0x62, 0x34, 0x66, 0x64, 0x30, 0x33, 0x38, 0x36, 0x61, 0x31, 0x64, 0x31, 0x34, 0x34, 0x34, 0x61, 0x62, 0x39, 0x39, 0x30, 0x36, 0x65, 0x65, 0x30, 0x65, 0x64, 0x36, 0x38, 0x61, 0x38, 0x36, 0x66, 0x62, 0x39, 0x63, 0x63, 0x34, 0x38, 0x33, 0x35, 0x62, 0x35, 0x39, 0x65, 0x30, 0x36, 0x63, 0x39, 0x33, 0x34, 0x63, 0x31, 0x34, 0x33, 0x31, 0x64, 0x39, 0x66, 0x35, 0x30, 0x34, 0x34, 0x62, 0x32, 0x35, 0x64, 0x38, 0x62, 0x37, 0x34, 0x62, 0x31, 0x33, 0x35, 0x32, 0x65, 0x66, 0x35, 0x30, 0x31, 0x33, 0x39, 0x63, 0x65, 0x35, 0x30, 0x62, 0x65, 0x33, 0x64, 0x64, 0x61, 0x34, 0x36, 0x35, 0x63, 0x65, 0x34, 0x32, 0x34, 0x63, 0x39, 0x37, 0x32, 0x38, 0x39, 0x39, 0x34, 0x37, 0x38, 0x38, 0x32, 0x61, 0x62, 0x31, 0x30, 0x63, 0x38, 0x38, 0x35, 0x61, 0x62, 0x64, 0x33, 0x64, 0x62, 0x66, 0x65, 0x32, 0x64, 0x62, 0x39, 0x62, 0x66, 0x65, 0x32, 0x37, 0x36, 0x66, 0x62, 0x32, 0x39, 0x37, 0x63, 0x35, 0x32, 0x63, 0x30, 0x37, 0x63, 0x37, 0x33, 0x39, 0x62, 0x31, 0x64, 0x39, 0x31, 0x34, 0x32, 0x33, 0x35, 0x63, 0x63, 0x64, 0x37, 0x36, 0x62, 0x30, 0x62, 0x62, 0x30, 0x36, 0x65, 0x38, 0x35, 0x66, 0x61, 0x33, 0x39, 0x62, 0x63, 0x38, 0x61, 0x32, 0x39, 0x34, 0x36, 0x61, 0x33, 0x36, 0x61, 0x61, 0x35, 0x65, 0x62, 0x62, 0x65, 0x35, 0x32, 0x64, 0x62, 0x37, 0x62, 0x31, 0x63, 0x35, 0x66, 0x33, 0x39, 0x64, 0x33, 0x61, 0x30, 0x30, 0x31, 0x36, 0x66, 0x37, 0x35, 0x64, 0x33, 0x32, 0x39, 0x62, 0x61, 0x62, 0x66, 0x38, 0x33, 0x30, 0x30, 0x63, 0x38, 0x39, 0x64, 0x36, 0x34, 0x62, 0x35, 0x35, 0x38, 0x37, 0x31, 0x62, 0x37, 0x37, 0x33, 0x63, 0x35, 0x38, 0x37, 0x64, 0x63, 0x63, 0x33, 0x39, 0x30, 0x37, 0x37, 0x34, 0x35, 0x31, 0x35, 0x64, 0x36, 0x34, 0x65, 0x33, 0x63, 0x66, 0x36, 0x35, 0x39, 0x63, 0x61, 0x62, 0x38, 0x37, 0x33, 0x37, 0x66, 0x33, 0x65, 0x36, 0x38, 0x34, 0x64, 0x63, 0x63, 0x38, 0x61, 0x34, 0x34, 0x31, 0x36, 0x61, 0x32, 0x64, 0x35, 0x34, 0x38, 0x37, 0x38, 0x34, 0x34, 0x37, 0x30, 0x30, 0x37, 0x37, 0x39, 0x39, 0x61, 0x64, 0x65, 0x64, 0x37, 0x37, 0x38, 0x33, 0x39, 0x37, 0x33, 0x39, 0x66, 0x66, 0x30, 0x62, 0x35, 0x37, 0x66, 0x30, 0x64, 0x61, 0x66, 0x33, 0x38, 0x37, 0x39, 0x38, 0x31, 0x63, 0x37, 0x30, 0x39, 0x64, 0x30, 0x37, 0x38, 0x61, 0x65, 0x38, 0x61, 0x37, 0x61, 0x37, 0x33, 0x36, 0x33, 0x31, 0x36, 0x33, 0x66, 0x30, 0x31, 0x33, 0x39, 0x34, 0x30, 0x35, 0x33, 0x62, 0x33, 0x37, 0x33, 0x32, 0x34, 0x33, 0x36, 0x64, 0x33, 0x63, 0x33, 0x66, 0x30, 0x65, 0x38, 0x32, 0x36, 0x37, 0x64, 0x38, 0x39, 0x39, 0x39, 0x34, 0x38, 0x37, 0x34, 0x32, 0x39, 0x33, 0x63, 0x61, 0x37, 0x32, 0x66, 0x33, 0x38, 0x35, 0x31, 0x34, 0x64, 0x31, 0x65, 0x38, 0x63, 0x34, 0x34, 0x36, 0x31, 0x37, 0x32, 0x30, 0x66, 0x64, 0x33, 0x37, 0x32, 0x65, 0x64, 0x39, 0x65, 0x34, 0x35, 0x62, 0x36, 0x32, 0x61, 0x37, 0x31, 0x31, 0x33, 0x36, 0x61, 0x65, 0x36, 0x39, 0x30, 0x63, 0x33, 0x61, 0x36, 0x30, 0x61, 0x30, 0x33, 0x35, 0x32, 0x62, 0x36, 0x63, 0x65, 0x35, 0x33, 0x63, 0x35, 0x32, 0x31, 0x30, 0x36, 0x38, 0x62, 0x33, 0x30, 0x31, 0x62, 0x34, 0x63, 0x63, 0x31, 0x39, 0x62, 0x39, 0x61, 0x36, 0x31, 0x32, 0x65, 0x66, 0x38, 0x34, 0x35, 0x32, 0x31, 0x37, 0x38, 0x61, 0x32, 0x64, 0x63, 0x38, 0x36, 0x39, 0x33, 0x32, 0x63, 0x64, 0x37, 0x35, 0x34, 0x36, 0x66, 0x65, 0x62, 0x38, 0x62, 0x38, 0x63, 0x33, 0x62, 0x65, 0x31, 0x32, 0x63, 0x32, 0x34, 0x61, 0x34, 0x34, 0x38, 0x35, 0x33, 0x30, 0x38, 0x61, 0x61, 0x34, 0x33, 0x37, 0x35, 0x65, 0x35, 0x30, 0x39, 0x37, 0x36, 0x63, 0x30, 0x31, 0x30, 0x34, 0x63, 0x31, 0x39, 0x38, 0x36, 0x63, 0x36, 0x64, 0x61, 0x30, 0x65, 0x31, 0x65, 0x61, 0x33, 0x36, 0x34, 0x37, 0x30, 0x39, 0x33, 0x31, 0x31, 0x62, 0x35, 0x64, 0x39, 0x35, 0x34, 0x63, 0x63, 0x32, 0x63, 0x66, 0x30, 0x32, 0x31, 0x34, 0x66, 0x62, 0x66, 0x33, 0x32, 0x37, 0x65, 0x61, 0x35, 0x36, 0x65, 0x38, 0x32, 0x31, 0x37, 0x39, 0x36, 0x32, 0x35, 0x32, 0x31, 0x37, 0x30, 0x37, 0x32, 0x37, 0x36, 0x32, 0x62, 0x30, 0x39, 0x39, 0x32, 0x66, 0x30, 0x37, 0x66, 0x30, 0x66, 0x63, 0x39, 0x64, 0x36, 0x30, 0x64, 0x30, 0x39, 0x37, 0x38, 0x34, 0x35, 0x66, 0x35, 0x37, 0x39, 0x39, 0x61, 0x31, 0x64, 0x38, 0x36, 0x61, 0x33, 0x66, 0x38, 0x65, 0x61, 0x38, 0x63, 0x33, 0x30, 0x62, 0x61, 0x32, 0x30, 0x32, 0x66, 0x37, 0x65, 0x63, 0x32, 0x66, 0x36, 0x33, 0x36, 0x61, 0x62, 0x37, 0x32, 0x36, 0x37, 0x34, 0x32, 0x31, 0x66, 0x32, 0x61, 0x35, 0x34, 0x39, 0x39, 0x35, 0x64, 0x30, 0x61, 0x65, 0x30, 0x31, 0x32, 0x63, 0x37, 0x62, 0x34, 0x66, 0x34, 0x64, 0x32, 0x64, 0x61, 0x35, 0x30, 0x37, 0x39, 0x66, 0x61, 0x39, 0x37, 0x32, 0x65, 0x32, 0x33, 0x30, 0x39, 0x61, 0x63, 0x34, 0x36, 0x37, 0x34, 0x33, 0x34, 0x32, 0x31, 0x64, 0x64, 0x32, 0x38, 0x62, 0x32, 0x33, 0x63, 0x36, 0x66, 0x36, 0x63, 0x35, 0x32, 0x38, 0x38, 0x61, 0x62, 0x30, 0x35, 0x63, 0x31, 0x38, 0x36, 0x30, 0x31, 0x32, 0x61, 0x32, 0x37, 0x35, 0x65, 0x30, 0x34, 0x64, 0x37, 0x35, 0x63, 0x32, 0x33, 0x31, 0x66, 0x35, 0x36, 0x33, 0x61, 0x35, 0x64, 0x62, 0x63, 0x39, 0x62, 0x34, 0x36, 0x39, 0x63, 0x30, 0x65, 0x38, 0x34, 0x37, 0x39, 0x33, 0x34, 0x30, 0x39, 0x63, 0x33, 0x63, 0x66, 0x64, 0x33, 0x37, 0x32, 0x37, 0x63, 0x62, 0x65, 0x37, 0x38, 0x31, 0x37, 0x62, 0x63, 0x62, 0x61, 0x37, 0x37, 0x62, 0x39, 0x32, 0x38, 0x30, 0x63, 0x66, 0x37, 0x65, 0x38, 0x65, 0x61, 0x37, 0x33, 0x38, 0x33, 0x37, 0x33, 0x63, 0x62, 0x62, 0x36, 0x62, 0x32, 0x66, 0x63, 0x31, 0x36, 0x39, 0x63, 0x38, 0x64, 0x66, 0x38, 0x62, 0x32, 0x65, 0x34, 0x35, 0x63, 0x30, 0x63, 0x64, 0x62, 0x38, 0x66, 0x34, 0x35, 0x33, 0x62, 0x32, 0x34, 0x35, 0x66, 0x62, 0x65, 0x39, 0x66, 0x64, 0x34, 0x30, 0x34, 0x38, 0x37, 0x31, 0x34, 0x63, 0x61, 0x39, 0x35, 0x62, 0x63, 0x30, 0x34, 0x64, 0x61, 0x38, 0x34, 0x34, 0x32, 0x39, 0x34, 0x31, 0x33, 0x34, 0x61, 0x31, 0x66, 0x63, 0x33, 0x66, 0x66, 0x65, 0x62, 0x33, 0x37, 0x38, 0x61, 0x33, 0x36, 0x62, 0x36, 0x32, 0x38, 0x31, 0x65, 0x39, 0x65, 0x37, 0x66, 0x36, 0x34, 0x31, 0x31, 0x34, 0x30, 0x36, 0x30, 0x36, 0x38, 0x66, 0x31, 0x66, 0x35, 0x36, 0x30, 0x62, 0x66, 0x32, 0x36, 0x34, 0x35, 0x34, 0x64, 0x35, 0x31, 0x39, 0x63, 0x34, 0x37, 0x34, 0x31, 0x30, 0x34, 0x62, 0x36, 0x30, 0x62, 0x62, 0x32, 0x64, 0x35, 0x35, 0x63, 0x39, 0x39, 0x30, 0x38, 0x37, 0x31, 0x30, 0x38, 0x63, 0x66, 0x34, 0x35, 0x37, 0x62, 0x61, 0x65, 0x65, 0x66, 0x35, 0x61, 0x35, 0x63, 0x33, 0x38, 0x30, 0x32, 0x34, 0x37, 0x33, 0x34, 0x66, 0x39, 0x37, 0x61, 0x37, 0x65, 0x35, 0x64, 0x30, 0x66, 0x62, 0x30, 0x63, 0x61, 0x65, 0x37, 0x63, 0x35, 0x33, 0x38, 0x34, 0x65, 0x65, 0x31, 0x32, 0x36, 0x39, 0x36, 0x36, 0x61, 0x34, 0x31, 0x32, 0x65, 0x32, 0x66, 0x36, 0x62, 0x32, 0x31, 0x61, 0x38, 0x64, 0x61, 0x31, 0x38, 0x39, 0x37, 0x66, 0x36, 0x35, 0x35, 0x63, 0x33, 0x32, 0x61, 0x37, 0x32, 0x65, 0x64, 0x61, 0x34, 0x62, 0x31, 0x36, 0x34, 0x64, 0x66, 0x66, 0x65, 0x64, 0x37, 0x66, 0x30, 0x62, 0x36, 0x36, 0x37, 0x62, 0x36, 0x64, 0x37, 0x66, 0x63, 0x62, 0x32, 0x32, 0x34, 0x36, 0x61, 0x65, 0x65, 0x64, 0x37, 0x62, 0x34, 0x36, 0x63, 0x37, 0x34, 0x30, 0x64, 0x61, 0x62, 0x64, 0x34, 0x61, 0x36, 0x63, 0x37, 0x31, 0x61, 0x30, 0x65, 0x61, 0x63, 0x39, 0x63, 0x66, 0x64, 0x37, 0x32, 0x34, 0x31, 0x36, 0x61, 0x65, 0x32, 0x65, 0x31, 0x39, 0x30, 0x62, 0x35, 0x39, 0x32, 0x65, 0x33, 0x38, 0x36, 0x62, 0x33, 0x32, 0x36, 0x33, 0x32, 0x65, 0x63, 0x39, 0x65, 0x63, 0x65, 0x30, 0x34, 0x36, 0x32, 0x33, 0x30, 0x61, 0x36, 0x66, 0x31, 0x37, 0x34, 0x65, 0x66, 0x38, 0x34, 0x34, 0x66, 0x65, 0x31, 0x62, 0x63, 0x32, 0x62, 0x61, 0x30, 0x32, 0x63, 0x32, 0x34, 0x30, 0x66, 0x37, 0x32, 0x63, 0x66, 0x37, 0x32, 0x36, 0x61, 0x66, 0x66, 0x36, 0x38, 0x30, 0x32, 0x66, 0x37, 0x30, 0x61, 0x32, 0x61, 0x33, 0x30, 0x38, 0x36, 0x39, 0x38, 0x36, 0x64, 0x62, 0x30, 0x38, 0x66, 0x66, 0x32, 0x35, 0x62, 0x38, 0x31, 0x30, 0x35, 0x37, 0x33, 0x32, 0x31, 0x36, 0x34, 0x65, 0x66, 0x66, 0x39, 0x61, 0x30, 0x63, 0x61, 0x66, 0x62, 0x61, 0x38, 0x35, 0x37, 0x63, 0x31, 0x30, 0x66, 0x37, 0x32, 0x64, 0x32, 0x39, 0x38, 0x31, 0x64, 0x63, 0x66, 0x37, 0x64, 0x30, 0x35, 0x32, 0x64, 0x33, 0x62, 0x34, 0x65, 0x32, 0x36, 0x39, 0x65, 0x32, 0x34, 0x31, 0x30, 0x35, 0x30, 0x38, 0x66, 0x62, 0x64, 0x62, 0x61, 0x34, 0x61, 0x36, 0x62, 0x63, 0x30, 0x35, 0x36, 0x64, 0x39, 0x61, 0x32, 0x32, 0x36, 0x30, 0x65, 0x31, 0x32, 0x66, 0x37, 0x61, 0x37, 0x34, 0x65, 0x38, 0x65, 0x34, 0x66, 0x37, 0x32, 0x62, 0x34, 0x33, 0x37, 0x37, 0x66, 0x33, 0x37, 0x66, 0x62, 0x38, 0x62, 0x31, 0x30, 0x65, 0x66, 0x38, 0x64, 0x36, 0x33, 0x61, 0x61, 0x37, 0x35, 0x37, 0x36, 0x66, 0x32, 0x35, 0x63, 0x30, 0x35, 0x32, 0x64, 0x32, 0x64, 0x39, 0x39, 0x31, 0x35, 0x32, 0x64, 0x38, 0x38, 0x33, 0x62, 0x34, 0x62, 0x37, 0x61, 0x38, 0x39, 0x63, 0x34, 0x34, 0x62, 0x62, 0x65, 0x66, 0x64, 0x34, 0x66, 0x37, 0x32, 0x31, 0x35, 0x34, 0x39, 0x62, 0x36, 0x30, 0x66, 0x38, 0x36, 0x32, 0x32, 0x32, 0x32, 0x66, 0x35, 0x33, 0x30, 0x30, 0x35, 0x66, 0x35, 0x65, 0x64, 0x30, 0x38, 0x62, 0x65, 0x36, 0x30, 0x32, 0x66, 0x35, 0x39, 0x30, 0x37, 0x38, 0x63, 0x33, 0x36, 0x34, 0x33, 0x61, 0x33, 0x38, 0x62, 0x34, 0x37, 0x32, 0x31, 0x64, 0x33, 0x38, 0x35, 0x62, 0x36, 0x38, 0x64, 0x39, 0x36, 0x31, 0x39, 0x35, 0x39, 0x39, 0x31, 0x35, 0x36, 0x32, 0x38, 0x35, 0x32, 0x33, 0x63, 0x63, 0x32, 0x66, 0x64, 0x37, 0x39, 0x66, 0x62, 0x33, 0x61, 0x30, 0x33, 0x33, 0x32, 0x38, 0x65, 0x32, 0x64, 0x38, 0x33, 0x65, 0x36, 0x34, 0x63, 0x36, 0x36, 0x36, 0x39, 0x34, 0x61, 0x66, 0x61, 0x62, 0x30, 0x35, 0x62, 0x62, 0x34, 0x64, 0x37, 0x39, 0x33, 0x35, 0x32, 0x32, 0x37, 0x61, 0x39, 0x38, 0x65, 0x30, 0x33, 0x37, 0x32, 0x32, 0x61, 0x61, 0x38, 0x62, 0x38, 0x62, 0x30, 0x34, 0x64, 0x65, 0x64, 0x31, 0x32, 0x35, 0x32, 0x66, 0x38, 0x63, 0x39, 0x66, 0x64, 0x66, 0x34, 0x33, 0x32, 0x39, 0x64, 0x32, 0x31, 0x33, 0x30, 0x61, 0x32, 0x31, 0x36, 0x30, 0x33, 0x34, 0x66, 0x37, 0x30, 0x36, 0x31, 0x33, 0x37, 0x35, 0x38, 0x31, 0x33, 0x63, 0x34, 0x37, 0x38, 0x37, 0x38, 0x61, 0x33, 0x64, 0x35, 0x32, 0x62, 0x37, 0x32, 0x62, 0x65, 0x61, 0x61, 0x65, 0x30, 0x35, 0x32, 0x66, 0x64, 0x33, 0x39, 0x66, 0x31, 0x35, 0x61, 0x35, 0x33, 0x30, 0x37, 0x61, 0x31, 0x38, 0x61, 0x39, 0x32, 0x37, 0x37, 0x35, 0x62, 0x36, 0x30, 0x63, 0x38, 0x35, 0x32, 0x38, 0x30, 0x37, 0x34, 0x34, 0x66, 0x63, 0x39, 0x33, 0x33, 0x32, 0x36, 0x64, 0x63, 0x39, 0x62, 0x38, 0x62, 0x66, 0x63, 0x30, 0x61, 0x34, 0x63, 0x31, 0x30, 0x31, 0x65, 0x66, 0x31, 0x64, 0x31, 0x37, 0x64, 0x31, 0x37, 0x33, 0x38, 0x36, 0x39, 0x39, 0x36, 0x33, 0x62, 0x39, 0x65, 0x63, 0x66, 0x35, 0x30, 0x31, 0x34, 0x63, 0x30, 0x37, 0x33, 0x30, 0x38, 0x66, 0x39, 0x66, 0x64, 0x62, 0x64, 0x31, 0x35, 0x65, 0x31, 0x38, 0x64, 0x33, 0x34, 0x34, 0x30, 0x32, 0x34, 0x30, 0x31, 0x36, 0x39, 0x33, 0x30, 0x30, 0x32, 0x30, 0x31, 0x32, 0x61, 0x63, 0x33, 0x37, 0x32, 0x34, 0x39, 0x65, 0x30, 0x33, 0x64, 0x65, 0x34, 0x37, 0x34, 0x35, 0x66, 0x39, 0x65, 0x34, 0x32, 0x30, 0x62, 0x36, 0x66, 0x61, 0x66, 0x61, 0x38, 0x62, 0x63, 0x36, 0x37, 0x66, 0x32, 0x32, 0x31, 0x61, 0x63, 0x35, 0x66, 0x64, 0x66, 0x31, 0x66, 0x65, 0x32, 0x65, 0x35, 0x37, 0x32, 0x36, 0x31, 0x63, 0x66, 0x64, 0x61, 0x66, 0x63, 0x66, 0x30, 0x32, 0x63, 0x36, 0x63, 0x31, 0x31, 0x33, 0x64, 0x39, 0x32, 0x31, 0x61, 0x62, 0x38, 0x33, 0x33, 0x64, 0x36, 0x33, 0x36, 0x64, 0x37, 0x66, 0x35, 0x30, 0x38, 0x39, 0x31, 0x35, 0x38, 0x32, 0x61, 0x30, 0x37, 0x63, 0x35, 0x65, 0x66, 0x39, 0x30, 0x31, 0x34, 0x34, 0x62, 0x36, 0x37, 0x39, 0x30, 0x32, 0x66, 0x61, 0x37, 0x66, 0x32, 0x65, 0x34, 0x30, 0x64, 0x36, 0x32, 0x37, 0x31, 0x36, 0x35, 0x61, 0x33, 0x38, 0x37, 0x35, 0x65, 0x32, 0x61, 0x34, 0x62, 0x37, 0x66, 0x64, 0x33, 0x38, 0x31, 0x65, 0x61, 0x35, 0x64, 0x63, 0x66, 0x33, 0x35, 0x36, 0x66, 0x61, 0x34, 0x32, 0x61, 0x37, 0x30, 0x65, 0x66, 0x39, 0x34, 0x64, 0x33, 0x31, 0x38, 0x39, 0x66, 0x30, 0x38, 0x31, 0x65, 0x62, 0x38, 0x63, 0x35, 0x30, 0x31, 0x65, 0x62, 0x63, 0x33, 0x61, 0x66, 0x64, 0x66, 0x35, 0x65, 0x63, 0x65, 0x37, 0x34, 0x38, 0x65, 0x30, 0x64, 0x37, 0x32, 0x31, 0x65, 0x37, 0x38, 0x62, 0x36, 0x65, 0x37, 0x30, 0x63, 0x33, 0x65, 0x62, 0x38, 0x36, 0x31, 0x64, 0x30, 0x64, 0x61, 0x64, 0x37, 0x63, 0x30, 0x63, 0x35, 0x35, 0x38, 0x37, 0x36, 0x35, 0x38, 0x33, 0x37, 0x37, 0x63, 0x39, 0x34, 0x64, 0x63, 0x35, 0x35, 0x38, 0x62, 0x61, 0x39, 0x31, 0x61, 0x61, 0x62, 0x35, 0x36, 0x38, 0x36, 0x35, 0x64, 0x64, 0x65, 0x62, 0x65, 0x38, 0x33, 0x34, 0x64, 0x30, 0x30, 0x32, 0x62, 0x36, 0x38, 0x61, 0x61, 0x39, 0x65, 0x34, 0x38, 0x33, 0x36, 0x37, 0x61, 0x65, 0x32, 0x61, 0x66, 0x66, 0x36, 0x39, 0x35, 0x34, 0x66, 0x36, 0x32, 0x35, 0x65, 0x34, 0x32, 0x63, 0x36, 0x39, 0x32, 0x66, 0x66, 0x39, 0x65, 0x35, 0x34, 0x62, 0x62, 0x61, 0x33, 0x34, 0x30, 0x30, 0x62, 0x33, 0x32, 0x31, 0x64, 0x39, 0x31, 0x66, 0x37, 0x63, 0x35, 0x64, 0x37, 0x37, 0x32, 0x31, 0x36, 0x33, 0x64, 0x64, 0x37, 0x34, 0x37, 0x31, 0x37, 0x36, 0x63, 0x34, 0x31, 0x63, 0x39, 0x34, 0x65, 0x39, 0x66, 0x66, 0x65, 0x64, 0x35, 0x65, 0x66, 0x34, 0x63, 0x32, 0x63, 0x33, 0x65, 0x33, 0x33, 0x30, 0x31, 0x31, 0x64, 0x39, 0x33, 0x32, 0x38, 0x30, 0x65, 0x39, 0x32, 0x63, 0x38, 0x61, 0x34, 0x66, 0x35, 0x38, 0x38, 0x32, 0x33, 0x38, 0x65, 0x37, 0x32, 0x37, 0x33, 0x35, 0x61, 0x36, 0x32, 0x32, 0x39, 0x30, 0x33, 0x31, 0x37, 0x37, 0x30, 0x61, 0x62, 0x38, 0x62, 0x36, 0x35, 0x39, 0x31, 0x63, 0x66, 0x33, 0x33, 0x31, 0x31, 0x64, 0x35, 0x61, 0x63, 0x35, 0x34, 0x64, 0x62, 0x30, 0x30, 0x66, 0x65, 0x36, 0x37, 0x34, 0x66, 0x38, 0x66, 0x35, 0x30, 0x61, 0x32, 0x62, 0x62, 0x64, 0x37, 0x34, 0x65, 0x33, 0x33, 0x33, 0x64, 0x37, 0x33, 0x37, 0x38, 0x36, 0x39, 0x37, 0x32, 0x64, 0x62, 0x30, 0x32, 0x37, 0x32, 0x32, 0x66, 0x66, 0x39, 0x35, 0x30, 0x32, 0x35, 0x63, 0x64, 0x62, 0x32, 0x35, 0x34, 0x37, 0x65, 0x36, 0x62, 0x64, 0x65, 0x30, 0x36, 0x31, 0x64, 0x31, 0x35, 0x33, 0x38, 0x30, 0x35, 0x61, 0x37, 0x62, 0x61, 0x37, 0x30, 0x62, 0x30, 0x66, 0x65, 0x30, 0x65, 0x66, 0x64, 0x32, 0x64, 0x31, 0x62, 0x36, 0x65, 0x32, 0x37, 0x35, 0x38, 0x39, 0x31, 0x30, 0x31, 0x62, 0x61, 0x63, 0x65, 0x38, 0x30, 0x63, 0x61, 0x32, 0x32, 0x65, 0x65, 0x35, 0x38, 0x35, 0x39, 0x32, 0x34, 0x34, 0x38, 0x39, 0x64, 0x64, 0x63, 0x61, 0x34, 0x62, 0x64, 0x32, 0x64, 0x33, 0x63, 0x39, 0x39, 0x63, 0x62, 0x62, 0x62, 0x33, 0x65, 0x33, 0x65, 0x65, 0x63, 0x30, 0x37, 0x62, 0x66, 0x35, 0x66, 0x39, 0x31, 0x66, 0x36, 0x32, 0x37, 0x30, 0x65, 0x32, 0x33, 0x39, 0x37, 0x35, 0x34, 0x66, 0x39, 0x34, 0x65, 0x36, 0x36, 0x61, 0x31, 0x34, 0x34, 0x39, 0x65, 0x61, 0x35, 0x31, 0x35, 0x38, 0x38, 0x62, 0x63, 0x35, 0x30, 0x63, 0x31, 0x37, 0x66, 0x62, 0x38, 0x37, 0x37, 0x64, 0x35, 0x31, 0x37, 0x34, 0x65, 0x37, 0x65, 0x32, 0x65, 0x62, 0x32, 0x64, 0x30, 0x33, 0x38, 0x30, 0x66, 0x31, 0x34, 0x65, 0x66, 0x65, 0x38, 0x31, 0x35, 0x62, 0x37, 0x37, 0x63, 0x63, 0x36, 0x37, 0x32, 0x31, 0x63, 0x32, 0x38, 0x63, 0x35, 0x35, 0x38, 0x38, 0x36, 0x65, 0x34, 0x36, 0x66, 0x63, 0x37, 0x64, 0x32, 0x37, 0x30, 0x32, 0x61, 0x35, 0x32, 0x34, 0x36, 0x65, 0x34, 0x34, 0x63, 0x30, 0x34, 0x38, 0x32, 0x30, 0x30, 0x64, 0x34, 0x33, 0x33, 0x39, 0x32, 0x61, 0x34, 0x61, 0x66, 0x38, 0x64, 0x32, 0x34, 0x34, 0x62, 0x64, 0x39, 0x32, 0x62, 0x37, 0x65, 0x32, 0x65, 0x65, 0x33, 0x37, 0x32, 0x30, 0x66, 0x33, 0x36, 0x30, 0x36, 0x62, 0x30, 0x34, 0x38, 0x63, 0x62, 0x32, 0x38, 0x31, 0x31, 0x64, 0x62, 0x61, 0x34, 0x62, 0x30, 0x64, 0x62, 0x31, 0x38, 0x30, 0x63, 0x38, 0x35, 0x62, 0x30, 0x38, 0x37, 0x38, 0x32, 0x31, 0x61, 0x30, 0x65, 0x34, 0x62, 0x39, 0x32, 0x33, 0x35, 0x62, 0x31, 0x63, 0x61, 0x39, 0x64, 0x36, 0x64, 0x32, 0x61, 0x65, 0x62, 0x33, 0x30, 0x38, 0x63, 0x37, 0x32, 0x61, 0x66, 0x31, 0x65, 0x38, 0x34, 0x62, 0x61, 0x31, 0x63, 0x38, 0x38, 0x64, 0x32, 0x63, 0x35, 0x63, 0x32, 0x36, 0x38, 0x37, 0x38, 0x35, 0x64, 0x65, 0x35, 0x39, 0x38, 0x32, 0x39, 0x65, 0x34, 0x65, 0x31, 0x38, 0x38, 0x38, 0x61, 0x31, 0x35, 0x36, 0x33, 0x62, 0x33, 0x33, 0x36, 0x64, 0x32, 0x39, 0x63, 0x35, 0x35, 0x61, 0x34, 0x66, 0x31, 0x34, 0x61, 0x66, 0x31, 0x38, 0x32, 0x30, 0x64, 0x37, 0x30, 0x35, 0x64, 0x39, 0x31, 0x32, 0x37, 0x33, 0x33, 0x31, 0x63, 0x66, 0x32, 0x37, 0x32, 0x35, 0x32, 0x66, 0x63, 0x65, 0x65, 0x66, 0x64, 0x61, 0x34, 0x65, 0x36, 0x35, 0x62, 0x62, 0x39, 0x64, 0x36, 0x30, 0x38, 0x31, 0x33, 0x35, 0x64, 0x66, 0x34, 0x37, 0x38, 0x36, 0x64, 0x62, 0x37, 0x62, 0x37, 0x62, 0x36, 0x62, 0x61, 0x31, 0x36, 0x36, 0x36, 0x66, 0x30, 0x61, 0x38, 0x37, 0x32, 0x31, 0x65, 0x31, 0x34, 0x39, 0x31, 0x36, 0x30, 0x33, 0x36, 0x65, 0x31, 0x35, 0x30, 0x61, 0x64, 0x35, 0x30, 0x31, 0x32, 0x33, 0x63, 0x35, 0x64, 0x39, 0x64, 0x62, 0x36, 0x39, 0x66, 0x65, 0x33, 0x62, 0x65, 0x31, 0x63, 0x65, 0x66, 0x64, 0x65, 0x31, 0x31, 0x65, 0x31, 0x32, 0x31, 0x63, 0x64, 0x62, 0x61, 0x64, 0x66, 0x30, 0x65, 0x30, 0x64, 0x66, 0x63, 0x32, 0x30, 0x36, 0x32, 0x37, 0x32, 0x34, 0x64, 0x37, 0x32, 0x61, 0x34, 0x66, 0x63, 0x35, 0x39, 0x61, 0x61, 0x63, 0x31, 0x34, 0x33, 0x36, 0x35, 0x62, 0x64, 0x61, 0x38, 0x35, 0x37, 0x66, 0x61, 0x34, 0x39, 0x35, 0x61, 0x36, 0x36, 0x32, 0x33, 0x35, 0x65, 0x37, 0x66, 0x36, 0x38, 0x35, 0x61, 0x35, 0x35, 0x65, 0x38, 0x30, 0x61, 0x61, 0x34, 0x33, 0x37, 0x34, 0x33, 0x30, 0x38, 0x30, 0x61, 0x35, 0x37, 0x36, 0x35, 0x37, 0x32, 0x36, 0x64, 0x62, 0x64, 0x32, 0x36, 0x36, 0x65, 0x63, 0x30, 0x36, 0x63, 0x34, 0x65, 0x65, 0x33, 0x65, 0x35, 0x32, 0x31, 0x33, 0x35, 0x33, 0x64, 0x39, 0x64, 0x36, 0x35, 0x63, 0x37, 0x65, 0x32, 0x33, 0x35, 0x39, 0x66, 0x33, 0x65, 0x66, 0x33, 0x63, 0x62, 0x30, 0x37, 0x61, 0x35, 0x31, 0x63, 0x63, 0x64, 0x31, 0x35, 0x33, 0x61, 0x37, 0x61, 0x34, 0x31, 0x64, 0x65, 0x63, 0x66, 0x36, 0x61, 0x39, 0x36, 0x65, 0x35, 0x62, 0x34, 0x62, 0x30, 0x66, 0x66, 0x32, 0x30, 0x38, 0x39, 0x61, 0x65, 0x37, 0x36, 0x39, 0x34, 0x32, 0x63, 0x64, 0x64, 0x36, 0x64, 0x64, 0x64, 0x65, 0x65, 0x39, 0x31, 0x33, 0x38, 0x66, 0x33, 0x62, 0x38, 0x66, 0x37, 0x36, 0x30, 0x38, 0x37, 0x64, 0x66, 0x63, 0x32, 0x61, 0x31, 0x66, 0x63, 0x34, 0x66, 0x65, 0x36, 0x39, 0x31, 0x31, 0x64, 0x36, 0x36, 0x37, 0x32, 0x37, 0x64, 0x33, 0x63, 0x32, 0x61, 0x35, 0x38, 0x39, 0x38, 0x61, 0x65, 0x31, 0x34, 0x65, 0x36, 0x63, 0x33, 0x62, 0x30, 0x63, 0x63, 0x30, 0x61, 0x65, 0x37, 0x30, 0x34, 0x35, 0x32, 0x39, 0x38, 0x31, 0x39, 0x31, 0x35, 0x66, 0x30, 0x33, 0x37, 0x31, 0x36, 0x38, 0x36, 0x33, 0x66, 0x33, 0x61, 0x37, 0x36, 0x34, 0x30, 0x62, 0x66, 0x31, 0x30, 0x39, 0x31, 0x36, 0x64, 0x33, 0x39, 0x32, 0x65, 0x63, 0x33, 0x30, 0x38, 0x32, 0x63, 0x37, 0x62, 0x39, 0x38, 0x35, 0x39, 0x61, 0x61, 0x34, 0x39, 0x66, 0x61, 0x34, 0x36, 0x66, 0x31, 0x63, 0x64, 0x62, 0x37, 0x33, 0x61, 0x63, 0x65, 0x66, 0x33, 0x33, 0x39, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x63, 0x63, 0x64, 0x33, 0x32, 0x32, 0x37, 0x37, 0x33, 0x36, 0x38, 0x30, 0x31, 0x37, 0x32, 0x31, 0x39, 0x39, 0x33, 0x35, 0x66, 0x36, 0x37, 0x32, 0x39, 0x65, 0x62, 0x32, 0x36, 0x61, 0x63, 0x65, 0x32, 0x65, 0x37, 0x39, 0x65, 0x33, 0x34, 0x62, 0x35, 0x31, 0x65, 0x62, 0x65, 0x64, 0x31, 0x36, 0x32, 0x37, 0x66, 0x64, 0x35, 0x39, 0x34, 0x63, 0x63, 0x66, 0x34, 0x33, 0x65, 0x38, 0x63, 0x62, 0x32, 0x39, 0x31, 0x30, 0x61, 0x62, 0x65, 0x32, 0x34, 0x31, 0x62, 0x62, 0x65, 0x33, 0x30, 0x35, 0x65, 0x66, 0x64, 0x37, 0x66, 0x63, 0x37, 0x32, 0x30, 0x30, 0x39, 0x39, 0x61, 0x38, 0x38, 0x35, 0x30, 0x33, 0x61, 0x30, 0x62, 0x64, 0x30, 0x38, 0x31, 0x33, 0x35, 0x31, 0x63, 0x36, 0x64, 0x33, 0x36, 0x65, 0x34, 0x33, 0x31, 0x39, 0x36, 0x65, 0x61, 0x66, 0x63, 0x63, 0x66, 0x65, 0x32, 0x36, 0x35, 0x65, 0x39, 0x33, 0x37, 0x37, 0x39, 0x36, 0x64, 0x33, 0x39, 0x63, 0x64, 0x33, 0x66, 0x31, 0x38, 0x30, 0x34, 0x31, 0x34, 0x35, 0x37, 0x32, 0x30, 0x30, 0x62, 0x36, 0x36, 0x33, 0x39, 0x66, 0x66, 0x35, 0x32, 0x65, 0x61, 0x30, 0x39, 0x38, 0x32, 0x32, 0x64, 0x34, 0x31, 0x31, 0x64, 0x37, 0x65, 0x63, 0x38, 0x64, 0x31, 0x62, 0x30, 0x63, 0x65, 0x63, 0x37, 0x30, 0x62, 0x34, 0x37, 0x31, 0x37, 0x36, 0x39, 0x61, 0x34, 0x30, 0x32, 0x61, 0x34, 0x31, 0x61, 0x39, 0x30, 0x66, 0x32, 0x33, 0x36, 0x66, 0x32, 0x64, 0x62, 0x64, 0x37, 0x32, 0x33, 0x66, 0x35, 0x64, 0x62, 0x62, 0x63, 0x66, 0x35, 0x66, 0x37, 0x64, 0x39, 0x66, 0x33, 0x37, 0x65, 0x61, 0x38, 0x38, 0x62, 0x38, 0x33, 0x35, 0x30, 0x61, 0x63, 0x66, 0x65, 0x38, 0x35, 0x39, 0x35, 0x64, 0x38, 0x64, 0x64, 0x34, 0x38, 0x32, 0x33, 0x37, 0x35, 0x30, 0x66, 0x37, 0x35, 0x30, 0x36, 0x38, 0x31, 0x37, 0x61, 0x61, 0x35, 0x37, 0x37, 0x39, 0x35, 0x35, 0x33, 0x30, 0x37, 0x32, 0x38, 0x38, 0x30, 0x62, 0x39, 0x38, 0x37, 0x32, 0x65, 0x39, 0x36, 0x66, 0x31, 0x62, 0x31, 0x62, 0x65, 0x33, 0x38, 0x36, 0x66, 0x35, 0x33, 0x36, 0x39, 0x30, 0x35, 0x30, 0x35, 0x37, 0x35, 0x39, 0x36, 0x66, 0x36, 0x32, 0x36, 0x61, 0x63, 0x65, 0x36, 0x64, 0x65, 0x35, 0x65, 0x34, 0x32, 0x34, 0x35, 0x34, 0x61, 0x33, 0x38, 0x35, 0x66, 0x64, 0x33, 0x30, 0x34, 0x36, 0x36, 0x35, 0x30, 0x31, 0x34, 0x32, 0x65, 0x33, 0x31, 0x39, 0x32, 0x37, 0x33, 0x32, 0x31, 0x63, 0x35, 0x38, 0x39, 0x33, 0x64, 0x30, 0x32, 0x30, 0x61, 0x37, 0x39, 0x32, 0x36, 0x61, 0x63, 0x30, 0x31, 0x36, 0x30, 0x65, 0x38, 0x33, 0x31, 0x35, 0x39, 0x30, 0x35, 0x64, 0x64, 0x34, 0x36, 0x30, 0x65, 0x66, 0x62, 0x64, 0x32, 0x34, 0x36, 0x64, 0x36, 0x37, 0x33, 0x37, 0x63, 0x63, 0x38, 0x66, 0x34, 0x31, 0x37, 0x32, 0x38, 0x39, 0x31, 0x31, 0x61, 0x64, 0x34, 0x35, 0x62, 0x36, 0x33, 0x65, 0x61, 0x64, 0x32, 0x39, 0x61, 0x38, 0x63, 0x34, 0x64, 0x32, 0x32, 0x39, 0x66, 0x62, 0x30, 0x32, 0x64, 0x66, 0x63, 0x36, 0x37, 0x61, 0x62, 0x30, 0x34, 0x38, 0x38, 0x35, 0x37, 0x35, 0x31, 0x64, 0x66, 0x62, 0x30, 0x36, 0x66, 0x37, 0x65, 0x37, 0x38, 0x31, 0x36, 0x30, 0x39, 0x38, 0x62, 0x30, 0x38, 0x36, 0x37, 0x32, 0x34, 0x62, 0x32, 0x31, 0x37, 0x38, 0x34, 0x66, 0x30, 0x34, 0x36, 0x31, 0x36, 0x34, 0x36, 0x63, 0x34, 0x31, 0x65, 0x30, 0x64, 0x33, 0x35, 0x65, 0x39, 0x37, 0x38, 0x61, 0x31, 0x63, 0x33, 0x61, 0x66, 0x63, 0x31, 0x63, 0x36, 0x61, 0x65, 0x65, 0x37, 0x66, 0x61, 0x64, 0x36, 0x36, 0x35, 0x33, 0x36, 0x32, 0x37, 0x65, 0x34, 0x37, 0x61, 0x39, 0x39, 0x37, 0x31, 0x33, 0x34, 0x32, 0x37, 0x32, 0x62, 0x61, 0x34, 0x36, 0x36, 0x37, 0x33, 0x64, 0x61, 0x33, 0x32, 0x39, 0x66, 0x30, 0x61, 0x32, 0x30, 0x62, 0x66, 0x31, 0x39, 0x65, 0x39, 0x30, 0x34, 0x66, 0x38, 0x39, 0x64, 0x65, 0x38, 0x65, 0x38, 0x30, 0x36, 0x36, 0x32, 0x64, 0x37, 0x39, 0x61, 0x37, 0x33, 0x34, 0x36, 0x37, 0x61, 0x39, 0x64, 0x61, 0x66, 0x36, 0x30, 0x32, 0x30, 0x65, 0x64, 0x62, 0x34, 0x38, 0x38, 0x61, 0x37, 0x32, 0x37, 0x62, 0x31, 0x61, 0x62, 0x33, 0x39, 0x31, 0x61, 0x30, 0x37, 0x31, 0x33, 0x61, 0x33, 0x64, 0x36, 0x34, 0x65, 0x66, 0x34, 0x61, 0x34, 0x31, 0x61, 0x39, 0x63, 0x38, 0x38, 0x39, 0x33, 0x37, 0x32, 0x63, 0x63, 0x66, 0x63, 0x31, 0x37, 0x39, 0x62, 0x39, 0x64, 0x63, 0x38, 0x33, 0x33, 0x36, 0x34, 0x64, 0x34, 0x61, 0x33, 0x36, 0x30, 0x31, 0x33, 0x38, 0x63, 0x65, 0x33, 0x63, 0x32, 0x38, 0x32, 0x31, 0x39, 0x34, 0x37, 0x34, 0x38, 0x39, 0x39, 0x33, 0x61, 0x30, 0x37, 0x66, 0x37, 0x33, 0x35, 0x64, 0x36, 0x64, 0x35, 0x65, 0x35, 0x31, 0x66, 0x33, 0x36, 0x61, 0x33, 0x33, 0x62, 0x63, 0x37, 0x65, 0x33, 0x66, 0x35, 0x34, 0x32, 0x61, 0x30, 0x33, 0x61, 0x61, 0x36, 0x32, 0x64, 0x30, 0x32, 0x37, 0x38, 0x32, 0x63, 0x63, 0x65, 0x39, 0x32, 0x39, 0x39, 0x32, 0x63, 0x65, 0x35, 0x39, 0x35, 0x33, 0x37, 0x32, 0x39, 0x35, 0x32, 0x37, 0x32, 0x34, 0x30, 0x63, 0x36, 0x38, 0x39, 0x31, 0x62, 0x66, 0x38, 0x35, 0x34, 0x32, 0x62, 0x36, 0x65, 0x30, 0x66, 0x33, 0x34, 0x33, 0x39, 0x33, 0x64, 0x66, 0x61, 0x33, 0x36, 0x36, 0x35, 0x30, 0x37, 0x38, 0x31, 0x37, 0x34, 0x32, 0x66, 0x66, 0x36, 0x30, 0x30, 0x66, 0x62, 0x35, 0x34, 0x34, 0x37, 0x64, 0x31, 0x39, 0x39, 0x34, 0x31, 0x31, 0x30, 0x37, 0x33, 0x31, 0x38, 0x33, 0x31, 0x31, 0x36, 0x65, 0x64, 0x63, 0x35, 0x34, 0x31, 0x31, 0x64, 0x36, 0x30, 0x63, 0x38, 0x63, 0x61, 0x35, 0x38, 0x32, 0x34, 0x61, 0x39, 0x33, 0x63, 0x39, 0x38, 0x66, 0x31, 0x32, 0x66, 0x34, 0x39, 0x31, 0x64, 0x63, 0x39, 0x36, 0x63, 0x66, 0x63, 0x30, 0x66, 0x62, 0x35, 0x32, 0x36, 0x39, 0x66, 0x34, 0x37, 0x32, 0x35, 0x37, 0x30, 0x38, 0x37, 0x32, 0x34, 0x65, 0x36, 0x32, 0x61, 0x62, 0x62, 0x34, 0x38, 0x36, 0x37, 0x62, 0x33, 0x61, 0x34, 0x65, 0x31, 0x35, 0x62, 0x61, 0x65, 0x31, 0x38, 0x37, 0x37, 0x61, 0x36, 0x36, 0x34, 0x32, 0x34, 0x61, 0x62, 0x65, 0x31, 0x65, 0x62, 0x30, 0x61, 0x61, 0x39, 0x39, 0x39, 0x62, 0x31, 0x36, 0x37, 0x61, 0x32, 0x35, 0x30, 0x37, 0x65, 0x65, 0x64, 0x38, 0x39, 0x61, 0x30, 0x65, 0x34, 0x35, 0x34, 0x38, 0x30, 0x66, 0x35, 0x65, 0x38, 0x31, 0x36, 0x32, 0x62, 0x64, 0x66, 0x31, 0x62, 0x64, 0x31, 0x65, 0x66, 0x34, 0x63, 0x39, 0x64, 0x37, 0x66, 0x38, 0x39, 0x32, 0x39, 0x37, 0x36, 0x36, 0x37, 0x38, 0x39, 0x39, 0x30, 0x61, 0x64, 0x65, 0x65, 0x33, 0x66, 0x30, 0x30, 0x30, 0x34, 0x39, 0x39, 0x33, 0x34, 0x36, 0x65, 0x63, 0x30, 0x32, 0x66, 0x62, 0x62, 0x39, 0x37, 0x62, 0x36, 0x62, 0x30, 0x37, 0x63, 0x65, 0x63, 0x39, 0x65, 0x33, 0x38, 0x34, 0x30, 0x35, 0x61, 0x36, 0x61, 0x37, 0x61, 0x65, 0x31, 0x61, 0x61, 0x65, 0x63, 0x35, 0x38, 0x36, 0x32, 0x64, 0x66, 0x62, 0x62, 0x33, 0x39, 0x37, 0x30, 0x39, 0x34, 0x61, 0x61, 0x33, 0x63, 0x36, 0x37, 0x65, 0x65, 0x34, 0x66, 0x64, 0x39, 0x66, 0x33, 0x30, 0x31, 0x64, 0x66, 0x34, 0x36, 0x65, 0x32, 0x63, 0x63, 0x36, 0x31, 0x63, 0x37, 0x32, 0x37, 0x38, 0x31, 0x61, 0x65, 0x65, 0x32, 0x64, 0x65, 0x38, 0x64, 0x64, 0x66, 0x65, 0x62, 0x61, 0x33, 0x30, 0x33, 0x34, 0x63, 0x35, 0x62, 0x39, 0x30, 0x35, 0x39, 0x39, 0x62, 0x62, 0x62, 0x31, 0x38, 0x63, 0x30, 0x66, 0x34, 0x66, 0x36, 0x37, 0x62, 0x37, 0x35, 0x65, 0x31, 0x62, 0x32, 0x31, 0x64, 0x36, 0x33, 0x31, 0x33, 0x37, 0x39, 0x32, 0x38, 0x34, 0x39, 0x31, 0x64, 0x36, 0x33, 0x36, 0x34, 0x35, 0x64, 0x39, 0x36, 0x38, 0x32, 0x65, 0x61, 0x66, 0x33, 0x38, 0x38, 0x64, 0x66, 0x63, 0x62, 0x39, 0x39, 0x38, 0x30, 0x32, 0x33, 0x32, 0x33, 0x65, 0x39, 0x32, 0x37, 0x35, 0x34, 0x64, 0x34, 0x31, 0x63, 0x39, 0x65, 0x63, 0x66, 0x30, 0x64, 0x36, 0x39, 0x35, 0x66, 0x65, 0x31, 0x33, 0x66, 0x65, 0x66, 0x35, 0x34, 0x37, 0x30, 0x35, 0x62, 0x33, 0x34, 0x64, 0x30, 0x66, 0x34, 0x61, 0x63, 0x32, 0x36, 0x63, 0x34, 0x39, 0x61, 0x64, 0x35, 0x62, 0x62, 0x31, 0x31, 0x62, 0x34, 0x61, 0x38, 0x35, 0x39, 0x64, 0x39, 0x30, 0x38, 0x63, 0x66, 0x30, 0x33, 0x38, 0x38, 0x32, 0x39, 0x33, 0x39, 0x34, 0x66, 0x31, 0x65, 0x37, 0x62, 0x63, 0x34, 0x34, 0x30, 0x35, 0x31, 0x63, 0x39, 0x37, 0x34, 0x37, 0x38, 0x62, 0x65, 0x38, 0x61, 0x35, 0x36, 0x33, 0x36, 0x31, 0x64, 0x30, 0x37, 0x32, 0x63, 0x65, 0x32, 0x35, 0x34, 0x33, 0x61, 0x39, 0x64, 0x66, 0x63, 0x61, 0x32, 0x38, 0x38, 0x34, 0x35, 0x34, 0x64, 0x61, 0x33, 0x62, 0x63, 0x65, 0x39, 0x62, 0x62, 0x30, 0x39, 0x64, 0x37, 0x65, 0x30, 0x61, 0x63, 0x31, 0x65, 0x35, 0x34, 0x36, 0x64, 0x64, 0x35, 0x30, 0x61, 0x36, 0x36, 0x38, 0x61, 0x32, 0x66, 0x63, 0x65, 0x34, 0x62, 0x36, 0x63, 0x64, 0x35, 0x61, 0x62, 0x37, 0x33, 0x33, 0x35, 0x37, 0x65, 0x35, 0x39, 0x31, 0x34, 0x34, 0x62, 0x33, 0x32, 0x61, 0x38, 0x34, 0x62, 0x62, 0x65, 0x64, 0x66, 0x36, 0x31, 0x66, 0x63, 0x66, 0x61, 0x37, 0x38, 0x61, 0x38, 0x31, 0x37, 0x63, 0x30, 0x64, 0x34, 0x35, 0x39, 0x61, 0x66, 0x34, 0x33, 0x30, 0x64, 0x34, 0x65, 0x34, 0x38, 0x32, 0x66, 0x38, 0x32, 0x65, 0x32, 0x66, 0x31, 0x39, 0x34, 0x65, 0x65, 0x36, 0x39, 0x65, 0x32, 0x35, 0x39, 0x34, 0x30, 0x34, 0x65, 0x33, 0x66, 0x63, 0x34, 0x38, 0x63, 0x63, 0x38, 0x61, 0x62, 0x33, 0x35, 0x36, 0x66, 0x31, 0x30, 0x35, 0x38, 0x36, 0x39, 0x66, 0x39, 0x63, 0x31, 0x36, 0x64, 0x65, 0x36, 0x39, 0x38, 0x36, 0x63, 0x36, 0x37, 0x34, 0x34, 0x36, 0x32, 0x64, 0x32, 0x34, 0x61, 0x30, 0x64, 0x35, 0x65, 0x39, 0x31, 0x31, 0x63, 0x31, 0x32, 0x36, 0x65, 0x36, 0x65, 0x34, 0x37, 0x32, 0x33, 0x62, 0x34, 0x36, 0x37, 0x66, 0x65, 0x63, 0x62, 0x38, 0x34, 0x31, 0x64, 0x30, 0x63, 0x61, 0x65, 0x35, 0x36, 0x37, 0x65, 0x61, 0x39, 0x63, 0x64, 0x38, 0x35, 0x65, 0x31, 0x66, 0x63, 0x64, 0x32, 0x63, 0x33, 0x66, 0x62, 0x61, 0x33, 0x34, 0x65, 0x35, 0x65, 0x38, 0x32, 0x32, 0x30, 0x33, 0x63, 0x62, 0x65, 0x33, 0x35, 0x61, 0x35, 0x33, 0x61, 0x34, 0x64, 0x38, 0x37, 0x39, 0x37, 0x32, 0x63, 0x66, 0x65, 0x62, 0x34, 0x32, 0x37, 0x36, 0x37, 0x32, 0x34, 0x35, 0x61, 0x37, 0x66, 0x30, 0x64, 0x30, 0x63, 0x39, 0x33, 0x37, 0x61, 0x39, 0x35, 0x39, 0x62, 0x34, 0x63, 0x32, 0x30, 0x64, 0x33, 0x38, 0x38, 0x66, 0x35, 0x31, 0x36, 0x31, 0x39, 0x33, 0x64, 0x33, 0x64, 0x65, 0x64, 0x36, 0x34, 0x36, 0x32, 0x34, 0x31, 0x37, 0x32, 0x38, 0x63, 0x34, 0x62, 0x38, 0x63, 0x66, 0x37, 0x32, 0x63, 0x35, 0x35, 0x37, 0x66, 0x38, 0x30, 0x34, 0x66, 0x35, 0x62, 0x34, 0x34, 0x63, 0x32, 0x37, 0x66, 0x61, 0x33, 0x64, 0x38, 0x38, 0x35, 0x35, 0x32, 0x61, 0x36, 0x66, 0x36, 0x31, 0x32, 0x34, 0x31, 0x65, 0x61, 0x34, 0x39, 0x30, 0x31, 0x38, 0x37, 0x61, 0x62, 0x32, 0x65, 0x63, 0x65, 0x65, 0x61, 0x61, 0x36, 0x31, 0x30, 0x65, 0x32, 0x34, 0x33, 0x35, 0x33, 0x61, 0x36, 0x62, 0x37, 0x32, 0x62, 0x63, 0x31, 0x62, 0x37, 0x39, 0x30, 0x31, 0x36, 0x31, 0x61, 0x34, 0x38, 0x33, 0x31, 0x65, 0x35, 0x39, 0x33, 0x32, 0x62, 0x61, 0x63, 0x61, 0x64, 0x63, 0x31, 0x39, 0x37, 0x61, 0x61, 0x37, 0x38, 0x66, 0x35, 0x30, 0x38, 0x37, 0x31, 0x66, 0x35, 0x33, 0x61, 0x34, 0x33, 0x63, 0x31, 0x34, 0x36, 0x62, 0x32, 0x30, 0x35, 0x62, 0x30, 0x32, 0x62, 0x64, 0x37, 0x36, 0x35, 0x63, 0x37, 0x32, 0x61, 0x31, 0x33, 0x62, 0x30, 0x38, 0x34, 0x38, 0x64, 0x36, 0x63, 0x34, 0x30, 0x62, 0x34, 0x37, 0x33, 0x34, 0x32, 0x39, 0x65, 0x39, 0x61, 0x37, 0x36, 0x62, 0x64, 0x34, 0x39, 0x33, 0x31, 0x31, 0x33, 0x35, 0x39, 0x36, 0x37, 0x64, 0x35, 0x62, 0x30, 0x63, 0x64, 0x62, 0x66, 0x30, 0x66, 0x31, 0x35, 0x30, 0x62, 0x38, 0x63, 0x37, 0x61, 0x66, 0x30, 0x36, 0x61, 0x62, 0x32, 0x65, 0x36, 0x31, 0x66, 0x62, 0x36, 0x34, 0x36, 0x38, 0x38, 0x32, 0x62, 0x30, 0x37, 0x61, 0x34, 0x35, 0x33, 0x38, 0x36, 0x39, 0x61, 0x38, 0x33, 0x66, 0x37, 0x33, 0x33, 0x61, 0x32, 0x38, 0x33, 0x33, 0x37, 0x61, 0x61, 0x38, 0x36, 0x37, 0x31, 0x62, 0x39, 0x39, 0x65, 0x35, 0x64, 0x30, 0x32, 0x66, 0x35, 0x61, 0x61, 0x35, 0x31, 0x35, 0x61, 0x66, 0x33, 0x61, 0x39, 0x62, 0x33, 0x39, 0x35, 0x32, 0x37, 0x32, 0x30, 0x30, 0x61, 0x38, 0x33, 0x62, 0x34, 0x35, 0x30, 0x35, 0x61, 0x63, 0x33, 0x61, 0x30, 0x63, 0x31, 0x63, 0x32, 0x35, 0x34, 0x64, 0x30, 0x61, 0x35, 0x34, 0x33, 0x64, 0x65, 0x65, 0x32, 0x37, 0x35, 0x36, 0x32, 0x38, 0x61, 0x61, 0x63, 0x65, 0x64, 0x38, 0x32, 0x30, 0x30, 0x36, 0x30, 0x32, 0x63, 0x61, 0x34, 0x61, 0x39, 0x61, 0x32, 0x33, 0x64, 0x37, 0x38, 0x62, 0x38, 0x61, 0x30, 0x34, 0x32, 0x35, 0x31, 0x30, 0x35, 0x38, 0x66, 0x31, 0x32, 0x62, 0x39, 0x62, 0x37, 0x61, 0x61, 0x66, 0x39, 0x62, 0x39, 0x35, 0x66, 0x62, 0x62, 0x65, 0x39, 0x32, 0x31, 0x66, 0x34, 0x65, 0x36, 0x37, 0x32, 0x36, 0x63, 0x36, 0x33, 0x33, 0x37, 0x63, 0x38, 0x36, 0x30, 0x33, 0x38, 0x31, 0x39, 0x33, 0x66, 0x39, 0x37, 0x64, 0x62, 0x32, 0x61, 0x36, 0x63, 0x37, 0x39, 0x65, 0x33, 0x66, 0x37, 0x32, 0x35, 0x63, 0x37, 0x31, 0x61, 0x37, 0x63, 0x61, 0x65, 0x35, 0x66, 0x33, 0x65, 0x39, 0x37, 0x30, 0x31, 0x36, 0x61, 0x62, 0x63, 0x62, 0x38, 0x62, 0x32, 0x30, 0x66, 0x32, 0x38, 0x33, 0x62, 0x31, 0x33, 0x66, 0x30, 0x64, 0x65, 0x65, 0x66, 0x37, 0x30, 0x34, 0x63, 0x34, 0x35, 0x65, 0x62, 0x63, 0x35, 0x36, 0x66, 0x38, 0x61, 0x33, 0x39, 0x66, 0x32, 0x35, 0x64, 0x65, 0x64, 0x38, 0x37, 0x32, 0x30, 0x37, 0x30, 0x63, 0x63, 0x34, 0x36, 0x37, 0x61, 0x30, 0x30, 0x35, 0x61, 0x34, 0x39, 0x34, 0x62, 0x31, 0x38, 0x36, 0x62, 0x37, 0x65, 0x62, 0x38, 0x33, 0x30, 0x62, 0x30, 0x39, 0x31, 0x66, 0x65, 0x30, 0x35, 0x33, 0x32, 0x62, 0x38, 0x38, 0x30, 0x31, 0x62, 0x62, 0x30, 0x61, 0x30, 0x35, 0x65, 0x35, 0x62, 0x62, 0x39, 0x63, 0x63, 0x39, 0x36, 0x38, 0x32, 0x64, 0x32, 0x64, 0x37, 0x32, 0x38, 0x34, 0x65, 0x37, 0x30, 0x38, 0x30, 0x63, 0x62, 0x63, 0x30, 0x32, 0x62, 0x36, 0x64, 0x30, 0x66, 0x62, 0x39, 0x31, 0x34, 0x63, 0x32, 0x37, 0x34, 0x62, 0x33, 0x66, 0x36, 0x36, 0x35, 0x31, 0x65, 0x66, 0x34, 0x35, 0x39, 0x35, 0x35, 0x38, 0x61, 0x66, 0x32, 0x38, 0x62, 0x61, 0x32, 0x61, 0x38, 0x66, 0x34, 0x62, 0x36, 0x64, 0x65, 0x39, 0x38, 0x39, 0x31, 0x39, 0x62, 0x37, 0x37, 0x32, 0x32, 0x30, 0x61, 0x36, 0x65, 0x35, 0x65, 0x61, 0x34, 0x62, 0x33, 0x30, 0x62, 0x63, 0x66, 0x34, 0x61, 0x30, 0x38, 0x38, 0x62, 0x66, 0x33, 0x62, 0x32, 0x37, 0x65, 0x37, 0x65, 0x33, 0x66, 0x37, 0x32, 0x31, 0x66, 0x62, 0x33, 0x35, 0x64, 0x63, 0x34, 0x30, 0x63, 0x66, 0x39, 0x31, 0x33, 0x65, 0x66, 0x66, 0x66, 0x31, 0x62, 0x38, 0x39, 0x32, 0x63, 0x66, 0x37, 0x62, 0x36, 0x63, 0x32, 0x34, 0x33, 0x39, 0x32, 0x30, 0x63, 0x62, 0x62, 0x66, 0x38, 0x36, 0x31, 0x36, 0x32, 0x34, 0x64, 0x66, 0x35, 0x34, 0x31, 0x39, 0x62, 0x34, 0x34, 0x34, 0x32, 0x61, 0x38, 0x33, 0x39, 0x65, 0x62, 0x34, 0x37, 0x31, 0x36, 0x34, 0x32, 0x35, 0x32, 0x31, 0x62, 0x39, 0x31, 0x63, 0x61, 0x30, 0x31, 0x61, 0x66, 0x65, 0x35, 0x32, 0x32, 0x37, 0x32, 0x65, 0x33, 0x39, 0x30, 0x62, 0x36, 0x66, 0x36, 0x33, 0x31, 0x39, 0x36, 0x35, 0x31, 0x33, 0x66, 0x35, 0x36, 0x36, 0x62, 0x33, 0x39, 0x37, 0x35, 0x37, 0x66, 0x65, 0x65, 0x36, 0x37, 0x30, 0x61, 0x37, 0x64, 0x36, 0x38, 0x33, 0x39, 0x39, 0x38, 0x64, 0x38, 0x37, 0x34, 0x66, 0x39, 0x61, 0x64, 0x30, 0x34, 0x37, 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x36, 0x35, 0x38, 0x64, 0x65, 0x34, 0x34, 0x38, 0x66, 0x37, 0x39, 0x61, 0x37, 0x64, 0x35, 0x39, 0x38, 0x38, 0x38, 0x32, 0x36, 0x30, 0x65, 0x66, 0x66, 0x38, 0x33, 0x35, 0x62, 0x62, 0x61, 0x31, 0x65, 0x32, 0x38, 0x62, 0x39, 0x66, 0x38, 0x61, 0x63, 0x63, 0x62, 0x66, 0x63, 0x64, 0x34, 0x35, 0x63, 0x35, 0x65, 0x37, 0x37, 0x37, 0x33, 0x31, 0x61, 0x61, 0x62, 0x31, 0x63, 0x30, 0x65, 0x34, 0x38, 0x36, 0x31, 0x35, 0x36, 0x65, 0x62, 0x61, 0x35, 0x37, 0x36, 0x31, 0x64, 0x35, 0x36, 0x37, 0x62, 0x66, 0x62, 0x39, 0x32, 0x62, 0x65, 0x62, 0x38, 0x38, 0x32, 0x31, 0x33, 0x34, 0x62, 0x65, 0x66, 0x36, 0x64, 0x66, 0x36, 0x61, 0x66, 0x37, 0x66, 0x33, 0x61, 0x65, 0x33, 0x63, 0x30, 0x38, 0x65, 0x33, 0x37, 0x32, 0x31, 0x34, 0x34, 0x62, 0x33, 0x32, 0x62, 0x39, 0x38, 0x64, 0x39, 0x66, 0x30, 0x65, 0x33, 0x62, 0x61, 0x37, 0x34, 0x31, 0x38, 0x34, 0x35, 0x34, 0x66, 0x36, 0x37, 0x32, 0x65, 0x66, 0x33, 0x66, 0x31, 0x34, 0x39, 0x63, 0x35, 0x38, 0x30, 0x38, 0x34, 0x37, 0x33, 0x37, 0x38, 0x33, 0x32, 0x63, 0x33, 0x33, 0x31, 0x30, 0x36, 0x38, 0x62, 0x63, 0x39, 0x32, 0x65, 0x61, 0x63, 0x39, 0x38, 0x37, 0x63, 0x63, 0x66, 0x63, 0x64, 0x65, 0x31, 0x38, 0x31, 0x64, 0x62, 0x38, 0x32, 0x66, 0x39, 0x64, 0x30, 0x32, 0x30, 0x35, 0x62, 0x65, 0x66, 0x62, 0x31, 0x62, 0x37, 0x32, 0x30, 0x37, 0x38, 0x61, 0x64, 0x34, 0x39, 0x38, 0x37, 0x62, 0x37, 0x39, 0x30, 0x63, 0x64, 0x63, 0x37, 0x61, 0x37, 0x37, 0x36, 0x66, 0x38, 0x33, 0x37, 0x34, 0x39, 0x32, 0x37, 0x35, 0x62, 0x38, 0x34, 0x35, 0x39, 0x62, 0x64, 0x62, 0x31, 0x63, 0x64, 0x30, 0x31, 0x30, 0x62, 0x36, 0x65, 0x63, 0x33, 0x33, 0x64, 0x66, 0x30, 0x64, 0x32, 0x35, 0x39, 0x34, 0x61, 0x37, 0x38, 0x32, 0x33, 0x31, 0x32, 0x62, 0x38, 0x37, 0x32, 0x30, 0x64, 0x32, 0x33, 0x66, 0x35, 0x39, 0x64, 0x64, 0x64, 0x34, 0x31, 0x65, 0x32, 0x36, 0x37, 0x35, 0x39, 0x36, 0x32, 0x36, 0x33, 0x37, 0x31, 0x31, 0x31, 0x61, 0x37, 0x31, 0x37, 0x64, 0x33, 0x38, 0x34, 0x30, 0x62, 0x65, 0x31, 0x34, 0x32, 0x36, 0x64, 0x64, 0x61, 0x62, 0x31, 0x66, 0x34, 0x31, 0x30, 0x66, 0x37, 0x63, 0x33, 0x37, 0x66, 0x31, 0x34, 0x35, 0x66, 0x61, 0x39, 0x37, 0x38, 0x35, 0x61, 0x65, 0x34, 0x66, 0x38, 0x30, 0x37, 0x32, 0x63, 0x37, 0x38, 0x36, 0x66, 0x62, 0x33, 0x33, 0x32, 0x35, 0x32, 0x65, 0x63, 0x62, 0x63, 0x33, 0x36, 0x35, 0x65, 0x37, 0x38, 0x64, 0x37, 0x35, 0x62, 0x37, 0x31, 0x31, 0x32, 0x33, 0x66, 0x62, 0x66, 0x34, 0x34, 0x38, 0x36, 0x34, 0x64, 0x39, 0x61, 0x30, 0x37, 0x38, 0x32, 0x66, 0x37, 0x34, 0x37, 0x32, 0x30, 0x61, 0x65, 0x37, 0x34, 0x38, 0x33, 0x30, 0x32, 0x35, 0x61, 0x31, 0x66, 0x32, 0x38, 0x65, 0x65, 0x63, 0x37, 0x37, 0x64, 0x64, 0x38, 0x36, 0x31, 0x31, 0x38, 0x64, 0x64, 0x33, 0x66, 0x66, 0x63, 0x36, 0x62, 0x33, 0x39, 0x39, 0x37, 0x39, 0x65, 0x63, 0x61, 0x34, 0x32, 0x66, 0x35, 0x38, 0x33, 0x37, 0x61, 0x39, 0x65, 0x37, 0x64, 0x33, 0x32, 0x64, 0x38, 0x65, 0x61, 0x36, 0x30, 0x62, 0x38, 0x31, 0x61, 0x37, 0x38, 0x37, 0x39, 0x35, 0x61, 0x30, 0x31, 0x37, 0x39, 0x32, 0x32, 0x32, 0x64, 0x61, 0x34, 0x38, 0x31, 0x38, 0x65, 0x65, 0x37, 0x65, 0x31, 0x63, 0x36, 0x30, 0x61, 0x30, 0x35, 0x33, 0x36, 0x38, 0x62, 0x61, 0x31, 0x30, 0x64, 0x39, 0x33, 0x37, 0x61, 0x38, 0x30, 0x63, 0x63, 0x65, 0x66, 0x35, 0x32, 0x32, 0x61, 0x61, 0x32, 0x66, 0x37, 0x34, 0x61, 0x39, 0x32, 0x62, 0x39, 0x30, 0x38, 0x38, 0x36, 0x37, 0x36, 0x36, 0x63, 0x39, 0x65, 0x30, 0x31, 0x38, 0x64, 0x35, 0x63, 0x62, 0x35, 0x37, 0x34, 0x39, 0x32, 0x32, 0x63, 0x66, 0x37, 0x39, 0x31, 0x66, 0x66, 0x33, 0x62, 0x62, 0x39, 0x37, 0x30, 0x34, 0x32, 0x35, 0x36, 0x62, 0x33, 0x38, 0x31, 0x33, 0x32, 0x63, 0x64, 0x39, 0x64, 0x36, 0x38, 0x63, 0x64, 0x31, 0x36, 0x34, 0x33, 0x63, 0x62, 0x37, 0x37, 0x32, 0x38, 0x36, 0x36, 0x62, 0x34, 0x61, 0x66, 0x33, 0x61, 0x63, 0x39, 0x62, 0x35, 0x30, 0x38, 0x38, 0x63, 0x32, 0x39, 0x31, 0x34, 0x30, 0x34, 0x37, 0x32, 0x32, 0x36, 0x62, 0x31, 0x63, 0x30, 0x39, 0x38, 0x31, 0x33, 0x37, 0x66, 0x34, 0x62, 0x61, 0x64, 0x38, 0x61, 0x31, 0x38, 0x34, 0x34, 0x31, 0x37, 0x35, 0x31, 0x63, 0x32, 0x65, 0x66, 0x32, 0x63, 0x66, 0x39, 0x30, 0x32, 0x64, 0x36, 0x30, 0x31, 0x61, 0x32, 0x39, 0x34, 0x37, 0x61, 0x36, 0x66, 0x61, 0x65, 0x31, 0x65, 0x37, 0x35, 0x37, 0x31, 0x64, 0x64, 0x38, 0x63, 0x32, 0x64, 0x65, 0x31, 0x31, 0x35, 0x37, 0x35, 0x63, 0x33, 0x34, 0x32, 0x63, 0x32, 0x62, 0x30, 0x33, 0x36, 0x39, 0x36, 0x37, 0x33, 0x32, 0x36, 0x61, 0x38, 0x65, 0x64, 0x61, 0x30, 0x63, 0x30, 0x39, 0x37, 0x33, 0x62, 0x36, 0x33, 0x64, 0x35, 0x31, 0x35, 0x66, 0x31, 0x32, 0x62, 0x65, 0x34, 0x64, 0x38, 0x33, 0x38, 0x36, 0x64, 0x35, 0x65, 0x39, 0x39, 0x33, 0x63, 0x63, 0x61, 0x30, 0x37, 0x33, 0x30, 0x35, 0x38, 0x36, 0x32, 0x38, 0x63, 0x62, 0x34, 0x33, 0x38, 0x62, 0x36, 0x65, 0x39, 0x34, 0x35, 0x65, 0x38, 0x38, 0x39, 0x30, 0x39, 0x61, 0x31, 0x31, 0x65, 0x33, 0x30, 0x34, 0x65, 0x66, 0x64, 0x64, 0x63, 0x63, 0x65, 0x64, 0x33, 0x36, 0x30, 0x31, 0x36, 0x34, 0x63, 0x36, 0x36, 0x66, 0x30, 0x33, 0x39, 0x61, 0x33, 0x66, 0x34, 0x61, 0x31, 0x65, 0x35, 0x30, 0x63, 0x63, 0x64, 0x36, 0x30, 0x38, 0x37, 0x36, 0x36, 0x39, 0x34, 0x62, 0x33, 0x66, 0x65, 0x63, 0x63, 0x33, 0x63, 0x33, 0x64, 0x37, 0x37, 0x33, 0x32, 0x30, 0x32, 0x62, 0x38, 0x64, 0x34, 0x31, 0x35, 0x63, 0x30, 0x66, 0x65, 0x35, 0x66, 0x65, 0x37, 0x34, 0x39, 0x39, 0x30, 0x32, 0x66, 0x62, 0x63, 0x30, 0x61, 0x33, 0x66, 0x62, 0x33, 0x39, 0x66, 0x31, 0x62, 0x64, 0x35, 0x63, 0x65, 0x62, 0x65, 0x32, 0x37, 0x65, 0x39, 0x63, 0x30, 0x35, 0x35, 0x34, 0x33, 0x31, 0x34, 0x39, 0x63, 0x61, 0x37, 0x32, 0x61, 0x66, 0x34, 0x63, 0x62, 0x37, 0x39, 0x31, 0x64, 0x37, 0x31, 0x30, 0x38, 0x65, 0x32, 0x61, 0x34, 0x30, 0x30, 0x37, 0x30, 0x38, 0x64, 0x65, 0x32, 0x32, 0x37, 0x32, 0x61, 0x31, 0x63, 0x66, 0x63, 0x32, 0x35, 0x39, 0x33, 0x38, 0x63, 0x30, 0x35, 0x38, 0x38, 0x38, 0x33, 0x35, 0x62, 0x35, 0x33, 0x36, 0x63, 0x30, 0x65, 0x33, 0x36, 0x66, 0x33, 0x39, 0x31, 0x63, 0x64, 0x65, 0x39, 0x65, 0x38, 0x30, 0x30, 0x62, 0x61, 0x66, 0x39, 0x62, 0x39, 0x32, 0x38, 0x38, 0x66, 0x34, 0x39, 0x36, 0x39, 0x66, 0x33, 0x61, 0x37, 0x30, 0x35, 0x61, 0x38, 0x33, 0x30, 0x33, 0x38, 0x32, 0x64, 0x32, 0x30, 0x64, 0x37, 0x30, 0x31, 0x63, 0x63, 0x66, 0x31, 0x34, 0x63, 0x38, 0x37, 0x63, 0x34, 0x30, 0x61, 0x31, 0x66, 0x38, 0x32, 0x65, 0x30, 0x61, 0x38, 0x64, 0x61, 0x64, 0x61, 0x61, 0x64, 0x66, 0x65, 0x39, 0x61, 0x66, 0x66, 0x62, 0x36, 0x32, 0x39, 0x33, 0x39, 0x33, 0x30, 0x38, 0x31, 0x31, 0x35, 0x38, 0x35, 0x39, 0x32, 0x37, 0x38, 0x39, 0x66, 0x66, 0x37, 0x32, 0x39, 0x61, 0x38, 0x66, 0x34, 0x34, 0x30, 0x61, 0x64, 0x62, 0x64, 0x66, 0x64, 0x31, 0x34, 0x37, 0x39, 0x34, 0x36, 0x37, 0x63, 0x63, 0x37, 0x66, 0x36, 0x36, 0x64, 0x63, 0x34, 0x33, 0x66, 0x66, 0x34, 0x36, 0x38, 0x33, 0x37, 0x63, 0x35, 0x37, 0x62, 0x64, 0x39, 0x39, 0x62, 0x31, 0x34, 0x30, 0x35, 0x39, 0x38, 0x37, 0x65, 0x63, 0x37, 0x66, 0x35, 0x32, 0x64, 0x39, 0x39, 0x31, 0x36, 0x36, 0x34, 0x32, 0x36, 0x64, 0x65, 0x34, 0x36, 0x30, 0x31, 0x30, 0x66, 0x65, 0x33, 0x34, 0x35, 0x64, 0x66, 0x31, 0x34, 0x38, 0x39, 0x37, 0x66, 0x66, 0x31, 0x32, 0x39, 0x36, 0x33, 0x62, 0x36, 0x61, 0x38, 0x37, 0x32, 0x64, 0x61, 0x37, 0x39, 0x37, 0x30, 0x65, 0x36, 0x30, 0x36, 0x38, 0x66, 0x64, 0x32, 0x35, 0x32, 0x33, 0x32, 0x64, 0x30, 0x34, 0x31, 0x64, 0x38, 0x33, 0x32, 0x38, 0x33, 0x37, 0x30, 0x64, 0x61, 0x33, 0x61, 0x31, 0x39, 0x63, 0x64, 0x38, 0x35, 0x66, 0x31, 0x64, 0x33, 0x64, 0x37, 0x37, 0x66, 0x36, 0x38, 0x30, 0x39, 0x38, 0x34, 0x36, 0x33, 0x31, 0x38, 0x39, 0x32, 0x36, 0x61, 0x34, 0x39, 0x38, 0x34, 0x64, 0x62, 0x34, 0x63, 0x65, 0x36, 0x61, 0x32, 0x63, 0x35, 0x36, 0x39, 0x30, 0x63, 0x63, 0x35, 0x62, 0x38, 0x61, 0x64, 0x62, 0x64, 0x32, 0x38, 0x63, 0x37, 0x32, 0x36, 0x39, 0x35, 0x63, 0x39, 0x31, 0x34, 0x36, 0x31, 0x36, 0x30, 0x63, 0x65, 0x38, 0x34, 0x30, 0x37, 0x30, 0x65, 0x65, 0x39, 0x33, 0x35, 0x31, 0x63, 0x34, 0x66, 0x39, 0x32, 0x66, 0x31, 0x32, 0x63, 0x38, 0x62, 0x30, 0x31, 0x66, 0x62, 0x61, 0x33, 0x62, 0x64, 0x35, 0x62, 0x63, 0x62, 0x64, 0x38, 0x65, 0x35, 0x36, 0x38, 0x35, 0x36, 0x63, 0x66, 0x39, 0x65, 0x63, 0x37, 0x65, 0x31, 0x39, 0x33, 0x37, 0x37, 0x63, 0x31, 0x30, 0x31, 0x39, 0x37, 0x33, 0x31, 0x30, 0x63, 0x39, 0x62, 0x66, 0x64, 0x31, 0x61, 0x39, 0x64, 0x61, 0x37, 0x37, 0x31, 0x62, 0x38, 0x36, 0x64, 0x64, 0x39, 0x34, 0x35, 0x37, 0x30, 0x63, 0x66, 0x31, 0x37, 0x66, 0x39, 0x36, 0x63, 0x63, 0x30, 0x32, 0x31, 0x34, 0x34, 0x65, 0x61, 0x31, 0x62, 0x39, 0x35, 0x64, 0x65, 0x39, 0x61, 0x36, 0x37, 0x37, 0x31, 0x62, 0x33, 0x64, 0x62, 0x64, 0x33, 0x62, 0x39, 0x34, 0x63, 0x64, 0x65, 0x31, 0x30, 0x34, 0x34, 0x30, 0x31, 0x63, 0x32, 0x62, 0x35, 0x61, 0x34, 0x31, 0x63, 0x33, 0x32, 0x33, 0x39, 0x33, 0x62, 0x34, 0x66, 0x62, 0x65, 0x32, 0x31, 0x61, 0x64, 0x39, 0x31, 0x36, 0x36, 0x32, 0x36, 0x61, 0x64, 0x31, 0x36, 0x32, 0x30, 0x64, 0x63, 0x34, 0x36, 0x62, 0x32, 0x62, 0x36, 0x62, 0x63, 0x36, 0x30, 0x64, 0x61, 0x63, 0x36, 0x66, 0x38, 0x34, 0x32, 0x34, 0x38, 0x36, 0x66, 0x65, 0x61, 0x32, 0x30, 0x64, 0x32, 0x66, 0x39, 0x62, 0x62, 0x66, 0x38, 0x35, 0x34, 0x31, 0x65, 0x65, 0x33, 0x64, 0x30, 0x62, 0x35, 0x39, 0x63, 0x31, 0x35, 0x61, 0x32, 0x63, 0x63, 0x38, 0x65, 0x39, 0x39, 0x64, 0x66, 0x34, 0x37, 0x31, 0x30, 0x34, 0x39, 0x36, 0x30, 0x65, 0x32, 0x39, 0x32, 0x61, 0x30, 0x36, 0x37, 0x32, 0x65, 0x37, 0x38, 0x63, 0x31, 0x63, 0x36, 0x37, 0x30, 0x64, 0x63, 0x66, 0x65, 0x37, 0x34, 0x32, 0x34, 0x36, 0x33, 0x32, 0x63, 0x31, 0x39, 0x39, 0x65, 0x63, 0x39, 0x64, 0x39, 0x38, 0x38, 0x32, 0x65, 0x64, 0x62, 0x36, 0x61, 0x62, 0x38, 0x34, 0x61, 0x31, 0x34, 0x62, 0x66, 0x64, 0x62, 0x66, 0x32, 0x66, 0x30, 0x36, 0x33, 0x35, 0x33, 0x34, 0x30, 0x31, 0x34, 0x66, 0x31, 0x36, 0x37, 0x32, 0x65, 0x36, 0x36, 0x35, 0x63, 0x65, 0x39, 0x32, 0x31, 0x31, 0x65, 0x63, 0x30, 0x64, 0x64, 0x31, 0x34, 0x35, 0x36, 0x33, 0x66, 0x65, 0x34, 0x61, 0x39, 0x32, 0x61, 0x65, 0x30, 0x39, 0x32, 0x39, 0x65, 0x31, 0x37, 0x30, 0x65, 0x30, 0x35, 0x63, 0x38, 0x35, 0x36, 0x38, 0x37, 0x33, 0x32, 0x33, 0x61, 0x65, 0x36, 0x65, 0x66, 0x61, 0x66, 0x30, 0x32, 0x63, 0x62, 0x64, 0x64, 0x66, 0x37, 0x32, 0x63, 0x31, 0x36, 0x34, 0x38, 0x62, 0x62, 0x35, 0x31, 0x35, 0x35, 0x34, 0x66, 0x31, 0x39, 0x66, 0x36, 0x35, 0x39, 0x36, 0x34, 0x30, 0x37, 0x34, 0x66, 0x35, 0x34, 0x61, 0x36, 0x66, 0x62, 0x30, 0x32, 0x65, 0x39, 0x36, 0x35, 0x36, 0x61, 0x62, 0x64, 0x65, 0x61, 0x66, 0x37, 0x66, 0x64, 0x65, 0x64, 0x35, 0x65, 0x37, 0x37, 0x31, 0x35, 0x63, 0x61, 0x36, 0x39, 0x65, 0x35, 0x63, 0x37, 0x32, 0x38, 0x34, 0x30, 0x30, 0x66, 0x62, 0x32, 0x61, 0x63, 0x64, 0x66, 0x65, 0x35, 0x65, 0x38, 0x62, 0x34, 0x39, 0x62, 0x33, 0x35, 0x35, 0x63, 0x39, 0x35, 0x36, 0x30, 0x65, 0x65, 0x39, 0x30, 0x66, 0x33, 0x65, 0x36, 0x31, 0x36, 0x63, 0x62, 0x31, 0x63, 0x63, 0x39, 0x37, 0x64, 0x38, 0x34, 0x34, 0x39, 0x37, 0x32, 0x38, 0x37, 0x37, 0x36, 0x31, 0x61, 0x35, 0x38, 0x63, 0x37, 0x35, 0x37, 0x32, 0x30, 0x34, 0x66, 0x61, 0x36, 0x32, 0x37, 0x66, 0x36, 0x65, 0x34, 0x63, 0x36, 0x62, 0x64, 0x62, 0x37, 0x35, 0x65, 0x31, 0x34, 0x64, 0x39, 0x34, 0x62, 0x34, 0x33, 0x66, 0x34, 0x35, 0x34, 0x63, 0x32, 0x36, 0x63, 0x33, 0x30, 0x30, 0x66, 0x38, 0x37, 0x37, 0x39, 0x36, 0x64, 0x39, 0x65, 0x30, 0x62, 0x33, 0x33, 0x61, 0x34, 0x63, 0x65, 0x36, 0x36, 0x63, 0x38, 0x37, 0x33, 0x31, 0x37, 0x32, 0x36, 0x39, 0x62, 0x64, 0x37, 0x62, 0x64, 0x62, 0x62, 0x35, 0x64, 0x32, 0x37, 0x33, 0x62, 0x34, 0x37, 0x62, 0x66, 0x37, 0x65, 0x64, 0x39, 0x35, 0x32, 0x32, 0x61, 0x37, 0x30, 0x34, 0x37, 0x65, 0x30, 0x33, 0x39, 0x61, 0x66, 0x66, 0x63, 0x63, 0x63, 0x65, 0x34, 0x36, 0x62, 0x38, 0x32, 0x38, 0x61, 0x37, 0x31, 0x64, 0x35, 0x32, 0x61, 0x30, 0x37, 0x66, 0x35, 0x38, 0x33, 0x30, 0x35, 0x38, 0x39, 0x62, 0x34, 0x38, 0x36, 0x37, 0x35, 0x65, 0x62, 0x65, 0x35, 0x62, 0x30, 0x36, 0x63, 0x32, 0x34, 0x62, 0x38, 0x37, 0x33, 0x34, 0x34, 0x63, 0x33, 0x64, 0x64, 0x35, 0x38, 0x63, 0x66, 0x61, 0x39, 0x31, 0x38, 0x34, 0x63, 0x34, 0x30, 0x31, 0x32, 0x62, 0x34, 0x34, 0x33, 0x36, 0x63, 0x36, 0x65, 0x33, 0x36, 0x33, 0x64, 0x30, 0x62, 0x31, 0x61, 0x62, 0x61, 0x35, 0x38, 0x39, 0x31, 0x61, 0x63, 0x64, 0x36, 0x63, 0x66, 0x39, 0x31, 0x65, 0x65, 0x31, 0x34, 0x31, 0x34, 0x34, 0x62, 0x32, 0x39, 0x31, 0x38, 0x30, 0x32, 0x62, 0x39, 0x65, 0x61, 0x66, 0x37, 0x36, 0x61, 0x33, 0x63, 0x39, 0x33, 0x36, 0x66, 0x65, 0x63, 0x64, 0x30, 0x30, 0x34, 0x64, 0x65, 0x32, 0x63, 0x33, 0x38, 0x33, 0x38, 0x39, 0x61, 0x30, 0x32, 0x38, 0x32, 0x34, 0x37, 0x64, 0x62, 0x33, 0x63, 0x37, 0x37, 0x32, 0x63, 0x64, 0x35, 0x31, 0x38, 0x63, 0x32, 0x63, 0x36, 0x39, 0x39, 0x66, 0x32, 0x31, 0x61, 0x36, 0x63, 0x65, 0x38, 0x37, 0x66, 0x36, 0x62, 0x66, 0x34, 0x32, 0x35, 0x66, 0x38, 0x66, 0x66, 0x64, 0x65, 0x30, 0x63, 0x31, 0x38, 0x64, 0x32, 0x37, 0x39, 0x63, 0x34, 0x62, 0x35, 0x63, 0x33, 0x65, 0x36, 0x62, 0x35, 0x61, 0x31, 0x37, 0x31, 0x64, 0x37, 0x34, 0x31, 0x61, 0x38, 0x30, 0x37, 0x32, 0x34, 0x37, 0x33, 0x37, 0x61, 0x66, 0x61, 0x39, 0x33, 0x38, 0x39, 0x61, 0x32, 0x61, 0x36, 0x38, 0x64, 0x65, 0x35, 0x61, 0x37, 0x34, 0x62, 0x65, 0x63, 0x62, 0x61, 0x34, 0x37, 0x31, 0x62, 0x38, 0x63, 0x62, 0x34, 0x66, 0x35, 0x63, 0x65, 0x61, 0x36, 0x62, 0x64, 0x63, 0x62, 0x64, 0x36, 0x66, 0x63, 0x64, 0x64, 0x63, 0x62, 0x32, 0x38, 0x64, 0x63, 0x34, 0x61, 0x63, 0x33, 0x66, 0x37, 0x32, 0x38, 0x32, 0x64, 0x33, 0x65, 0x37, 0x62, 0x35, 0x34, 0x66, 0x65, 0x34, 0x63, 0x32, 0x34, 0x65, 0x61, 0x39, 0x34, 0x35, 0x37, 0x65, 0x39, 0x62, 0x61, 0x36, 0x66, 0x31, 0x65, 0x65, 0x65, 0x32, 0x64, 0x66, 0x32, 0x32, 0x38, 0x64, 0x34, 0x31, 0x34, 0x65, 0x63, 0x65, 0x38, 0x62, 0x30, 0x32, 0x34, 0x39, 0x31, 0x30, 0x65, 0x65, 0x33, 0x35, 0x32, 0x33, 0x30, 0x63, 0x30, 0x36, 0x33, 0x32, 0x66, 0x64, 0x38, 0x64, 0x36, 0x32, 0x39, 0x37, 0x64, 0x62, 0x62, 0x30, 0x31, 0x36, 0x31, 0x63, 0x37, 0x30, 0x36, 0x30, 0x61, 0x39, 0x36, 0x30, 0x65, 0x39, 0x30, 0x32, 0x30, 0x62, 0x62, 0x36, 0x64, 0x62, 0x35, 0x63, 0x62, 0x38, 0x34, 0x36, 0x34, 0x38, 0x64, 0x65, 0x62, 0x37, 0x32, 0x39, 0x65, 0x31, 0x61, 0x64, 0x63, 0x36, 0x36, 0x38, 0x32, 0x36, 0x39, 0x64, 0x32, 0x30, 0x37, 0x32, 0x62, 0x34, 0x38, 0x39, 0x63, 0x37, 0x34, 0x63, 0x33, 0x38, 0x65, 0x61, 0x62, 0x31, 0x61, 0x39, 0x39, 0x35, 0x38, 0x31, 0x63, 0x38, 0x31, 0x65, 0x63, 0x66, 0x39, 0x32, 0x30, 0x34, 0x33, 0x32, 0x64, 0x66, 0x63, 0x66, 0x34, 0x66, 0x66, 0x63, 0x34, 0x35, 0x33, 0x66, 0x39, 0x65, 0x62, 0x31, 0x66, 0x30, 0x32, 0x34, 0x62, 0x30, 0x33, 0x36, 0x33, 0x33, 0x65, 0x62, 0x33, 0x36, 0x37, 0x32, 0x30, 0x36, 0x36, 0x61, 0x37, 0x64, 0x35, 0x31, 0x66, 0x36, 0x61, 0x64, 0x64, 0x31, 0x36, 0x64, 0x35, 0x38, 0x63, 0x63, 0x30, 0x39, 0x36, 0x35, 0x31, 0x37, 0x66, 0x39, 0x31, 0x64, 0x66, 0x32, 0x61, 0x31, 0x61, 0x32, 0x34, 0x65, 0x30, 0x62, 0x36, 0x61, 0x39, 0x64, 0x32, 0x64, 0x39, 0x65, 0x35, 0x35, 0x36, 0x66, 0x66, 0x32, 0x38, 0x39, 0x38, 0x66, 0x39, 0x33, 0x33, 0x30, 0x37, 0x32, 0x37, 0x35, 0x61, 0x35, 0x39, 0x62, 0x36, 0x64, 0x36, 0x39, 0x32, 0x61, 0x62, 0x37, 0x62, 0x31, 0x61, 0x32, 0x64, 0x38, 0x35, 0x65, 0x61, 0x66, 0x62, 0x65, 0x30, 0x39, 0x39, 0x64, 0x64, 0x35, 0x65, 0x63, 0x33, 0x64, 0x65, 0x64, 0x66, 0x61, 0x36, 0x39, 0x38, 0x38, 0x30, 0x62, 0x35, 0x64, 0x66, 0x65, 0x65, 0x66, 0x31, 0x35, 0x37, 0x30, 0x37, 0x39, 0x37, 0x37, 0x30, 0x64, 0x33, 0x32, 0x66, 0x64, 0x30, 0x31, 0x63, 0x36, 0x64, 0x38, 0x30, 0x38, 0x64, 0x30, 0x35, 0x37, 0x32, 0x62, 0x30, 0x64, 0x65, 0x65, 0x63, 0x31, 0x61, 0x61, 0x39, 0x61, 0x65, 0x62, 0x37, 0x35, 0x30, 0x33, 0x63, 0x32, 0x30, 0x30, 0x31, 0x34, 0x64, 0x30, 0x64, 0x33, 0x63, 0x37, 0x39, 0x34, 0x30, 0x66, 0x32, 0x32, 0x62, 0x33, 0x64, 0x33, 0x62, 0x64, 0x30, 0x33, 0x62, 0x31, 0x30, 0x34, 0x37, 0x32, 0x38, 0x62, 0x65, 0x64, 0x64, 0x33, 0x32, 0x32, 0x36, 0x31, 0x64, 0x61, 0x64, 0x65, 0x37, 0x63, 0x34, 0x64, 0x35, 0x61, 0x33, 0x35, 0x38, 0x37, 0x39, 0x32, 0x33, 0x33, 0x64, 0x31, 0x63, 0x62, 0x37, 0x39, 0x61, 0x61, 0x37, 0x32, 0x39, 0x63, 0x66, 0x33, 0x33, 0x66, 0x32, 0x34, 0x64, 0x65, 0x61, 0x61, 0x63, 0x36, 0x35, 0x32, 0x37, 0x33, 0x36, 0x33, 0x35, 0x34, 0x35, 0x34, 0x37, 0x32, 0x34, 0x34, 0x62, 0x66, 0x62, 0x33, 0x35, 0x30, 0x34, 0x66, 0x39, 0x39, 0x38, 0x36, 0x65, 0x63, 0x62, 0x38, 0x30, 0x39, 0x38, 0x31, 0x31, 0x65, 0x34, 0x36, 0x38, 0x37, 0x65, 0x37, 0x35, 0x64, 0x31, 0x38, 0x34, 0x61, 0x62, 0x63, 0x32, 0x37, 0x34, 0x30, 0x31, 0x62, 0x61, 0x36, 0x30, 0x65, 0x64, 0x30, 0x32, 0x30, 0x36, 0x32, 0x34, 0x39, 0x63, 0x39, 0x30, 0x61, 0x30, 0x37, 0x37, 0x32, 0x64, 0x36, 0x31, 0x62, 0x38, 0x61, 0x62, 0x38, 0x34, 0x37, 0x61, 0x33, 0x65, 0x30, 0x30, 0x61, 0x34, 0x30, 0x38, 0x63, 0x61, 0x35, 0x36, 0x64, 0x64, 0x64, 0x64, 0x33, 0x30, 0x30, 0x34, 0x63, 0x37, 0x63, 0x63, 0x66, 0x64, 0x66, 0x61, 0x35, 0x38, 0x61, 0x33, 0x30, 0x37, 0x31, 0x30, 0x37, 0x66, 0x66, 0x63, 0x35, 0x35, 0x31, 0x63, 0x36, 0x63, 0x61, 0x63, 0x63, 0x34, 0x39, 0x37, 0x32, 0x34, 0x33, 0x32, 0x34, 0x64, 0x30, 0x38, 0x37, 0x37, 0x32, 0x39, 0x30, 0x37, 0x36, 0x65, 0x32, 0x64, 0x64, 0x38, 0x39, 0x35, 0x33, 0x65, 0x39, 0x35, 0x61, 0x64, 0x65, 0x66, 0x61, 0x39, 0x36, 0x66, 0x61, 0x34, 0x66, 0x36, 0x36, 0x39, 0x36, 0x32, 0x38, 0x63, 0x31, 0x33, 0x32, 0x38, 0x39, 0x37, 0x66, 0x66, 0x62, 0x30, 0x34, 0x32, 0x32, 0x36, 0x36, 0x36, 0x63, 0x38, 0x62, 0x30, 0x30, 0x38, 0x66, 0x64, 0x39, 0x36, 0x30, 0x36, 0x63, 0x66, 0x65, 0x32, 0x63, 0x37, 0x62, 0x65, 0x39, 0x36, 0x63, 0x32, 0x63, 0x31, 0x37, 0x66, 0x62, 0x39, 0x61, 0x32, 0x63, 0x62, 0x34, 0x62, 0x62, 0x33, 0x33, 0x38, 0x63, 0x36, 0x63, 0x34, 0x38, 0x38, 0x63, 0x62, 0x65, 0x30, 0x61, 0x36, 0x36, 0x30, 0x64, 0x39, 0x31, 0x62, 0x62, 0x36, 0x34, 0x35, 0x38, 0x61, 0x35, 0x36, 0x66, 0x37, 0x32, 0x61, 0x66, 0x38, 0x64, 0x32, 0x32, 0x39, 0x66, 0x64, 0x32, 0x34, 0x36, 0x62, 0x66, 0x37, 0x61, 0x37, 0x36, 0x36, 0x62, 0x34, 0x36, 0x66, 0x36, 0x32, 0x63, 0x39, 0x33, 0x63, 0x32, 0x34, 0x36, 0x61, 0x66, 0x66, 0x38, 0x65, 0x65, 0x63, 0x39, 0x61, 0x37, 0x63, 0x32, 0x39, 0x30, 0x64, 0x36, 0x66, 0x33, 0x38, 0x61, 0x38, 0x66, 0x62, 0x33, 0x66, 0x62, 0x39, 0x63, 0x36, 0x66, 0x33, 0x36, 0x32, 0x61, 0x39, 0x64, 0x30, 0x37, 0x63, 0x63, 0x35, 0x65, 0x38, 0x62, 0x33, 0x66, 0x39, 0x36, 0x33, 0x32, 0x32, 0x33, 0x35, 0x62, 0x38, 0x64, 0x64, 0x61, 0x37, 0x30, 0x61, 0x34, 0x32, 0x64, 0x31, 0x35, 0x65, 0x66, 0x39, 0x37, 0x38, 0x31, 0x37, 0x31, 0x39, 0x37, 0x65, 0x33, 0x33, 0x63, 0x33, 0x61, 0x35, 0x64, 0x34, 0x33, 0x34, 0x37, 0x36, 0x37, 0x65, 0x34, 0x39, 0x61, 0x36, 0x33, 0x64, 0x39, 0x37, 0x37, 0x37, 0x38, 0x65, 0x37, 0x37, 0x63, 0x62, 0x31, 0x32, 0x64, 0x33, 0x63, 0x38, 0x66, 0x63, 0x36, 0x36, 0x35, 0x33, 0x39, 0x33, 0x33, 0x37, 0x39, 0x39, 0x61, 0x38, 0x36, 0x34, 0x65, 0x66, 0x34, 0x31, 0x39, 0x39, 0x31, 0x62, 0x38, 0x33, 0x66, 0x36, 0x66, 0x36, 0x63, 0x63, 0x61, 0x32, 0x39, 0x39, 0x62, 0x33, 0x62, 0x61, 0x30, 0x65, 0x38, 0x32, 0x61, 0x35, 0x66, 0x33, 0x38, 0x37, 0x30, 0x36, 0x37, 0x33, 0x61, 0x66, 0x65, 0x63, 0x37, 0x38, 0x30, 0x35, 0x35, 0x39, 0x61, 0x65, 0x36, 0x37, 0x35, 0x63, 0x33, 0x37, 0x65, 0x39, 0x30, 0x36, 0x64, 0x38, 0x66, 0x32, 0x32, 0x63, 0x34, 0x37, 0x65, 0x37, 0x31, 0x35, 0x65, 0x39, 0x37, 0x36, 0x32, 0x35, 0x65, 0x38, 0x37, 0x33, 0x38, 0x62, 0x66, 0x66, 0x66, 0x35, 0x31, 0x31, 0x65, 0x33, 0x32, 0x37, 0x32, 0x32, 0x63, 0x38, 0x64, 0x31, 0x30, 0x38, 0x65, 0x63, 0x62, 0x61, 0x63, 0x32, 0x66, 0x64, 0x35, 0x30, 0x33, 0x33, 0x37, 0x38, 0x30, 0x64, 0x32, 0x64, 0x64, 0x66, 0x34, 0x35, 0x30, 0x63, 0x66, 0x32, 0x34, 0x31, 0x38, 0x66, 0x33, 0x33, 0x39, 0x30, 0x35, 0x65, 0x31, 0x30, 0x63, 0x30, 0x33, 0x63, 0x63, 0x61, 0x61, 0x34, 0x33, 0x32, 0x61, 0x30, 0x63, 0x31, 0x66, 0x39, 0x61, 0x37, 0x32, 0x38, 0x66, 0x30, 0x34, 0x65, 0x65, 0x32, 0x30, 0x34, 0x65, 0x65, 0x31, 0x64, 0x38, 0x30, 0x32, 0x63, 0x37, 0x36, 0x64, 0x62, 0x66, 0x30, 0x65, 0x36, 0x34, 0x63, 0x30, 0x31, 0x36, 0x35, 0x37, 0x32, 0x64, 0x62, 0x33, 0x36, 0x62, 0x32, 0x64, 0x37, 0x37, 0x39, 0x33, 0x35, 0x37, 0x30, 0x32, 0x62, 0x38, 0x66, 0x62, 0x63, 0x32, 0x61, 0x35, 0x39, 0x38, 0x39, 0x64, 0x63, 0x35, 0x37, 0x32, 0x33, 0x64, 0x33, 0x65, 0x35, 0x37, 0x36, 0x66, 0x34, 0x33, 0x32, 0x61, 0x36, 0x34, 0x31, 0x65, 0x61, 0x37, 0x33, 0x33, 0x63, 0x35, 0x64, 0x66, 0x62, 0x30, 0x66, 0x35, 0x32, 0x32, 0x36, 0x36, 0x63, 0x66, 0x33, 0x31, 0x38, 0x64, 0x65, 0x32, 0x66, 0x35, 0x32, 0x66, 0x34, 0x35, 0x61, 0x37, 0x39, 0x64, 0x32, 0x33, 0x32, 0x37, 0x38, 0x31, 0x31, 0x39, 0x30, 0x34, 0x31, 0x63, 0x37, 0x32, 0x32, 0x65, 0x35, 0x64, 0x32, 0x63, 0x61, 0x30, 0x63, 0x30, 0x66, 0x31, 0x37, 0x63, 0x39, 0x31, 0x35, 0x62, 0x62, 0x65, 0x37, 0x62, 0x65, 0x62, 0x64, 0x36, 0x39, 0x31, 0x61, 0x37, 0x32, 0x30, 0x32, 0x66, 0x61, 0x35, 0x63, 0x64, 0x64, 0x35, 0x61, 0x61, 0x31, 0x61, 0x39, 0x62, 0x35, 0x61, 0x65, 0x38, 0x32, 0x63, 0x62, 0x65, 0x61, 0x37, 0x32, 0x35, 0x31, 0x33, 0x62, 0x61, 0x37, 0x32, 0x64, 0x35, 0x30, 0x36, 0x36, 0x39, 0x66, 0x33, 0x66, 0x32, 0x61, 0x34, 0x38, 0x33, 0x30, 0x65, 0x64, 0x61, 0x62, 0x39, 0x37, 0x36, 0x38, 0x61, 0x61, 0x66, 0x37, 0x33, 0x30, 0x32, 0x65, 0x35, 0x38, 0x38, 0x35, 0x39, 0x39, 0x39, 0x64, 0x65, 0x37, 0x31, 0x35, 0x33, 0x36, 0x35, 0x36, 0x63, 0x62, 0x62, 0x63, 0x62, 0x65, 0x36, 0x34, 0x36, 0x33, 0x65, 0x35, 0x31, 0x38, 0x61, 0x37, 0x32, 0x65, 0x33, 0x64, 0x36, 0x39, 0x31, 0x37, 0x34, 0x66, 0x31, 0x35, 0x34, 0x37, 0x38, 0x65, 0x61, 0x36, 0x64, 0x38, 0x30, 0x62, 0x30, 0x31, 0x61, 0x33, 0x62, 0x66, 0x36, 0x33, 0x36, 0x66, 0x62, 0x34, 0x38, 0x64, 0x66, 0x38, 0x65, 0x30, 0x36, 0x65, 0x64, 0x64, 0x61, 0x39, 0x63, 0x62, 0x63, 0x65, 0x30, 0x35, 0x65, 0x62, 0x61, 0x64, 0x30, 0x34, 0x36, 0x34, 0x66, 0x65, 0x63, 0x37, 0x30, 0x64, 0x61, 0x65, 0x39, 0x30, 0x64, 0x37, 0x35, 0x32, 0x32, 0x36, 0x66, 0x34, 0x35, 0x35, 0x38, 0x39, 0x35, 0x39, 0x61, 0x63, 0x34, 0x33, 0x62, 0x64, 0x39, 0x37, 0x32, 0x35, 0x32, 0x33, 0x32, 0x32, 0x33, 0x38, 0x61, 0x39, 0x31, 0x32, 0x39, 0x65, 0x61, 0x63, 0x34, 0x38, 0x31, 0x65, 0x66, 0x61, 0x62, 0x64, 0x61, 0x64, 0x61, 0x33, 0x32, 0x64, 0x37, 0x65, 0x35, 0x62, 0x37, 0x37, 0x32, 0x38, 0x30, 0x64, 0x65, 0x62, 0x61, 0x61, 0x36, 0x61, 0x63, 0x30, 0x33, 0x34, 0x34, 0x34, 0x66, 0x65, 0x64, 0x66, 0x38, 0x33, 0x30, 0x62, 0x63, 0x32, 0x37, 0x66, 0x31, 0x30, 0x33, 0x64, 0x38, 0x61, 0x34, 0x61, 0x34, 0x31, 0x33, 0x33, 0x64, 0x33, 0x38, 0x31, 0x39, 0x39, 0x39, 0x64, 0x33, 0x34, 0x31, 0x64, 0x35, 0x61, 0x63, 0x64, 0x61, 0x64, 0x34, 0x65, 0x35, 0x65, 0x63, 0x30, 0x62, 0x65, 0x39, 0x32, 0x32, 0x66, 0x32, 0x62, 0x37, 0x35, 0x36, 0x32, 0x64, 0x31, 0x64, 0x63, 0x33, 0x35, 0x32, 0x34, 0x64, 0x62, 0x30, 0x32, 0x61, 0x36, 0x38, 0x39, 0x65, 0x64, 0x30, 0x63, 0x65, 0x32, 0x63, 0x31, 0x35, 0x61, 0x61, 0x37, 0x30, 0x31, 0x61, 0x31, 0x33, 0x33, 0x37, 0x31, 0x34, 0x34, 0x65, 0x66, 0x66, 0x37, 0x30, 0x33, 0x30, 0x34, 0x64, 0x62, 0x38, 0x32, 0x34, 0x32, 0x30, 0x30, 0x30, 0x35, 0x34, 0x37, 0x37, 0x62, 0x30, 0x62, 0x31, 0x66, 0x63, 0x36, 0x30, 0x34, 0x31, 0x66, 0x34, 0x65, 0x65, 0x35, 0x33, 0x34, 0x65, 0x37, 0x35, 0x61, 0x37, 0x38, 0x36, 0x34, 0x34, 0x36, 0x61, 0x65, 0x65, 0x63, 0x61, 0x32, 0x66, 0x66, 0x38, 0x65, 0x61, 0x30, 0x30, 0x65, 0x66, 0x62, 0x33, 0x63, 0x37, 0x61, 0x30, 0x63, 0x38, 0x37, 0x39, 0x37, 0x35, 0x36, 0x66, 0x37, 0x32, 0x62, 0x33, 0x35, 0x31, 0x61, 0x66, 0x37, 0x66, 0x65, 0x32, 0x34, 0x35, 0x31, 0x36, 0x38, 0x39, 0x33, 0x61, 0x32, 0x66, 0x32, 0x64, 0x34, 0x36, 0x37, 0x65, 0x33, 0x66, 0x31, 0x64, 0x61, 0x34, 0x34, 0x30, 0x30, 0x32, 0x66, 0x63, 0x65, 0x33, 0x34, 0x30, 0x30, 0x35, 0x30, 0x37, 0x38, 0x36, 0x65, 0x34, 0x38, 0x61, 0x39, 0x38, 0x34, 0x61, 0x33, 0x30, 0x36, 0x61, 0x61, 0x31, 0x37, 0x30, 0x31, 0x37, 0x35, 0x36, 0x39, 0x64, 0x37, 0x32, 0x38, 0x30, 0x62, 0x39, 0x39, 0x66, 0x31, 0x39, 0x33, 0x36, 0x61, 0x32, 0x34, 0x65, 0x36, 0x64, 0x66, 0x37, 0x39, 0x65, 0x33, 0x35, 0x32, 0x33, 0x32, 0x38, 0x61, 0x32, 0x31, 0x33, 0x62, 0x64, 0x32, 0x61, 0x61, 0x31, 0x31, 0x39, 0x39, 0x33, 0x62, 0x37, 0x36, 0x39, 0x62, 0x32, 0x38, 0x32, 0x62, 0x34, 0x61, 0x65, 0x33, 0x31, 0x36, 0x31, 0x61, 0x61, 0x62, 0x39, 0x32, 0x64, 0x65, 0x32, 0x61, 0x38, 0x30, 0x37, 0x61, 0x30, 0x65, 0x61, 0x38, 0x62, 0x31, 0x62, 0x30, 0x64, 0x61, 0x37, 0x63, 0x32, 0x31, 0x38, 0x64, 0x64, 0x32, 0x35, 0x64, 0x38, 0x63, 0x31, 0x35, 0x35, 0x63, 0x63, 0x62, 0x33, 0x66, 0x35, 0x62, 0x32, 0x34, 0x30, 0x64, 0x62, 0x30, 0x62, 0x38, 0x38, 0x31, 0x66, 0x36, 0x33, 0x34, 0x38, 0x37, 0x62, 0x31, 0x61, 0x33, 0x37, 0x32, 0x65, 0x35, 0x62, 0x32, 0x34, 0x65, 0x31, 0x31, 0x61, 0x35, 0x33, 0x36, 0x62, 0x38, 0x66, 0x33, 0x62, 0x30, 0x34, 0x66, 0x62, 0x37, 0x39, 0x30, 0x36, 0x65, 0x39, 0x39, 0x35, 0x35, 0x61, 0x63, 0x32, 0x32, 0x35, 0x35, 0x37, 0x61, 0x32, 0x33, 0x64, 0x62, 0x38, 0x31, 0x38, 0x38, 0x30, 0x65, 0x36, 0x37, 0x66, 0x30, 0x31, 0x38, 0x63, 0x65, 0x32, 0x63, 0x64, 0x37, 0x32, 0x31, 0x36, 0x62, 0x39, 0x64, 0x30, 0x37, 0x33, 0x33, 0x64, 0x32, 0x66, 0x66, 0x30, 0x31, 0x64, 0x39, 0x63, 0x31, 0x36, 0x63, 0x34, 0x35, 0x36, 0x37, 0x62, 0x62, 0x61, 0x35, 0x61, 0x66, 0x66, 0x61, 0x66, 0x38, 0x30, 0x32, 0x34, 0x36, 0x36, 0x30, 0x34, 0x36, 0x39, 0x34, 0x35, 0x30, 0x66, 0x66, 0x62, 0x62, 0x35, 0x38, 0x39, 0x37, 0x37, 0x61, 0x30, 0x31, 0x64, 0x30, 0x61, 0x37, 0x32, 0x63, 0x31, 0x39, 0x31, 0x66, 0x34, 0x62, 0x36, 0x39, 0x66, 0x65, 0x36, 0x31, 0x35, 0x37, 0x39, 0x34, 0x63, 0x34, 0x38, 0x32, 0x62, 0x36, 0x38, 0x63, 0x32, 0x39, 0x36, 0x38, 0x62, 0x63, 0x65, 0x64, 0x66, 0x36, 0x38, 0x63, 0x31, 0x37, 0x62, 0x36, 0x37, 0x64, 0x64, 0x38, 0x65, 0x66, 0x37, 0x64, 0x37, 0x35, 0x34, 0x35, 0x38, 0x32, 0x64, 0x38, 0x35, 0x66, 0x64, 0x30, 0x35, 0x37, 0x32, 0x33, 0x62, 0x38, 0x38, 0x39, 0x34, 0x61, 0x32, 0x31, 0x65, 0x63, 0x36, 0x61, 0x65, 0x32, 0x32, 0x33, 0x61, 0x65, 0x39, 0x34, 0x31, 0x39, 0x33, 0x33, 0x35, 0x61, 0x32, 0x37, 0x65, 0x30, 0x63, 0x39, 0x62, 0x63, 0x30, 0x37, 0x32, 0x38, 0x61, 0x35, 0x31, 0x35, 0x37, 0x64, 0x64, 0x61, 0x30, 0x38, 0x62, 0x37, 0x64, 0x66, 0x39, 0x39, 0x36, 0x64, 0x63, 0x66, 0x37, 0x63, 0x63, 0x34, 0x37, 0x34, 0x31, 0x31, 0x37, 0x64, 0x35, 0x32, 0x63, 0x32, 0x66, 0x62, 0x34, 0x64, 0x36, 0x62, 0x39, 0x34, 0x31, 0x38, 0x37, 0x61, 0x38, 0x39, 0x32, 0x37, 0x36, 0x35, 0x62, 0x61, 0x63, 0x38, 0x37, 0x63, 0x63, 0x32, 0x30, 0x66, 0x30, 0x39, 0x36, 0x61, 0x61, 0x66, 0x31, 0x64, 0x64, 0x38, 0x38, 0x61, 0x31, 0x37, 0x65, 0x64, 0x35, 0x62, 0x39, 0x63, 0x36, 0x30, 0x33, 0x30, 0x61, 0x37, 0x32, 0x39, 0x38, 0x31, 0x39, 0x65, 0x38, 0x39, 0x63, 0x36, 0x32, 0x36, 0x33, 0x66, 0x62, 0x38, 0x39, 0x63, 0x34, 0x62, 0x39, 0x32, 0x39, 0x33, 0x38, 0x34, 0x61, 0x30, 0x61, 0x32, 0x63, 0x32, 0x34, 0x34, 0x32, 0x36, 0x33, 0x65, 0x38, 0x34, 0x36, 0x61, 0x34, 0x32, 0x31, 0x62, 0x65, 0x38, 0x35, 0x39, 0x65, 0x66, 0x33, 0x38, 0x63, 0x61, 0x66, 0x30, 0x33, 0x38, 0x36, 0x37, 0x31, 0x37, 0x32, 0x64, 0x31, 0x34, 0x61, 0x37, 0x64, 0x64, 0x62, 0x66, 0x31, 0x33, 0x31, 0x34, 0x61, 0x65, 0x30, 0x34, 0x34, 0x38, 0x31, 0x31, 0x39, 0x61, 0x63, 0x30, 0x30, 0x66, 0x33, 0x61, 0x35, 0x33, 0x34, 0x37, 0x31, 0x39, 0x65, 0x64, 0x38, 0x32, 0x65, 0x61, 0x38, 0x35, 0x66, 0x64, 0x33, 0x39, 0x33, 0x34, 0x39, 0x34, 0x63, 0x31, 0x61, 0x39, 0x61, 0x35, 0x35, 0x33, 0x34, 0x38, 0x62, 0x37, 0x32, 0x61, 0x36, 0x62, 0x35, 0x32, 0x32, 0x36, 0x62, 0x61, 0x61, 0x31, 0x65, 0x36, 0x35, 0x34, 0x63, 0x64, 0x32, 0x31, 0x32, 0x30, 0x38, 0x30, 0x31, 0x62, 0x36, 0x35, 0x64, 0x34, 0x65, 0x37, 0x62, 0x61, 0x62, 0x31, 0x32, 0x39, 0x33, 0x32, 0x63, 0x39, 0x35, 0x36, 0x35, 0x38, 0x66, 0x61, 0x65, 0x64, 0x62, 0x33, 0x30, 0x38, 0x38, 0x30, 0x62, 0x62, 0x63, 0x64, 0x65, 0x34, 0x33, 0x37, 0x32, 0x39, 0x32, 0x35, 0x35, 0x37, 0x61, 0x35, 0x34, 0x33, 0x39, 0x33, 0x33, 0x66, 0x64, 0x38, 0x32, 0x30, 0x62, 0x33, 0x37, 0x37, 0x36, 0x65, 0x34, 0x35, 0x31, 0x65, 0x33, 0x38, 0x32, 0x61, 0x61, 0x31, 0x35, 0x38, 0x39, 0x37, 0x30, 0x64, 0x66, 0x63, 0x33, 0x35, 0x63, 0x37, 0x39, 0x30, 0x34, 0x36, 0x39, 0x38, 0x34, 0x32, 0x39, 0x36, 0x34, 0x31, 0x31, 0x66, 0x32, 0x31, 0x33, 0x37, 0x32, 0x66, 0x65, 0x61, 0x35, 0x30, 0x38, 0x61, 0x37, 0x34, 0x35, 0x35, 0x31, 0x36, 0x66, 0x30, 0x32, 0x63, 0x30, 0x65, 0x62, 0x61, 0x66, 0x33, 0x31, 0x32, 0x36, 0x33, 0x30, 0x30, 0x33, 0x37, 0x33, 0x39, 0x64, 0x63, 0x36, 0x35, 0x36, 0x65, 0x62, 0x37, 0x64, 0x62, 0x63, 0x32, 0x31, 0x39, 0x37, 0x30, 0x32, 0x36, 0x34, 0x65, 0x30, 0x62, 0x36, 0x34, 0x62, 0x34, 0x39, 0x65, 0x35, 0x33, 0x63, 0x61, 0x31, 0x39, 0x61, 0x38, 0x35, 0x38, 0x38, 0x35, 0x31, 0x32, 0x35, 0x62, 0x65, 0x32, 0x39, 0x36, 0x39, 0x66, 0x33, 0x39, 0x64, 0x34, 0x38, 0x34, 0x36, 0x33, 0x31, 0x39, 0x33, 0x36, 0x66, 0x36, 0x31, 0x36, 0x64, 0x33, 0x36, 0x61, 0x30, 0x30, 0x32, 0x65, 0x31, 0x30, 0x35, 0x34, 0x31, 0x34, 0x35, 0x36, 0x37, 0x36, 0x65, 0x35, 0x61, 0x35, 0x33, 0x32, 0x33, 0x37, 0x61, 0x37, 0x32, 0x34, 0x63, 0x32, 0x62, 0x30, 0x37, 0x34, 0x65, 0x38, 0x37, 0x65, 0x62, 0x65, 0x62, 0x63, 0x65, 0x61, 0x65, 0x62, 0x34, 0x66, 0x38, 0x36, 0x34, 0x65, 0x35, 0x39, 0x35, 0x64, 0x39, 0x65, 0x61, 0x34, 0x66, 0x65, 0x62, 0x31, 0x31, 0x39, 0x65, 0x39, 0x66, 0x39, 0x32, 0x66, 0x31, 0x35, 0x64, 0x36, 0x39, 0x66, 0x65, 0x32, 0x37, 0x66, 0x64, 0x30, 0x35, 0x64, 0x33, 0x38, 0x62, 0x37, 0x32, 0x65, 0x35, 0x36, 0x37, 0x35, 0x35, 0x32, 0x63, 0x63, 0x62, 0x63, 0x63, 0x62, 0x31, 0x33, 0x33, 0x34, 0x63, 0x63, 0x31, 0x37, 0x61, 0x66, 0x63, 0x38, 0x66, 0x63, 0x62, 0x37, 0x32, 0x38, 0x39, 0x61, 0x63, 0x64, 0x35, 0x62, 0x37, 0x36, 0x31, 0x33, 0x35, 0x30, 0x31, 0x39, 0x64, 0x66, 0x30, 0x30, 0x32, 0x63, 0x35, 0x37, 0x38, 0x38, 0x37, 0x35, 0x37, 0x61, 0x63, 0x61, 0x62, 0x37, 0x32, 0x38, 0x64, 0x64, 0x61, 0x64, 0x37, 0x31, 0x36, 0x63, 0x32, 0x39, 0x39, 0x62, 0x65, 0x63, 0x63, 0x33, 0x63, 0x30, 0x63, 0x32, 0x66, 0x63, 0x31, 0x34, 0x62, 0x62, 0x34, 0x34, 0x37, 0x30, 0x36, 0x32, 0x31, 0x31, 0x36, 0x37, 0x35, 0x33, 0x38, 0x32, 0x62, 0x32, 0x32, 0x66, 0x35, 0x39, 0x63, 0x66, 0x37, 0x39, 0x66, 0x35, 0x66, 0x61, 0x62, 0x32, 0x62, 0x39, 0x30, 0x63, 0x37, 0x31, 0x65, 0x66, 0x61, 0x36, 0x61, 0x65, 0x36, 0x61, 0x34, 0x32, 0x39, 0x62, 0x63, 0x34, 0x39, 0x36, 0x64, 0x62, 0x62, 0x64, 0x39, 0x35, 0x32, 0x64, 0x33, 0x63, 0x33, 0x36, 0x66, 0x31, 0x65, 0x35, 0x32, 0x37, 0x35, 0x31, 0x64, 0x38, 0x37, 0x63, 0x34, 0x34, 0x35, 0x64, 0x39, 0x64, 0x33, 0x65, 0x39, 0x66, 0x61, 0x32, 0x30, 0x65, 0x61, 0x62, 0x30, 0x39, 0x34, 0x63, 0x37, 0x38, 0x32, 0x30, 0x33, 0x32, 0x38, 0x31, 0x64, 0x32, 0x35, 0x63, 0x38, 0x38, 0x32, 0x31, 0x30, 0x63, 0x31, 0x31, 0x36, 0x61, 0x61, 0x63, 0x63, 0x37, 0x30, 0x64, 0x30, 0x62, 0x63, 0x63, 0x66, 0x66, 0x65, 0x38, 0x39, 0x63, 0x33, 0x31, 0x30, 0x31, 0x30, 0x62, 0x37, 0x62, 0x35, 0x32, 0x30, 0x33, 0x33, 0x36, 0x39, 0x34, 0x37, 0x38, 0x38, 0x62, 0x35, 0x64, 0x34, 0x65, 0x32, 0x61, 0x36, 0x38, 0x32, 0x37, 0x32, 0x61, 0x36, 0x66, 0x66, 0x38, 0x36, 0x38, 0x38, 0x64, 0x39, 0x62, 0x37, 0x65, 0x62, 0x63, 0x31, 0x35, 0x37, 0x37, 0x30, 0x31, 0x65, 0x38, 0x36, 0x37, 0x65, 0x33, 0x37, 0x64, 0x35, 0x38, 0x65, 0x35, 0x65, 0x30, 0x33, 0x35, 0x62, 0x64, 0x39, 0x61, 0x39, 0x38, 0x30, 0x37, 0x62, 0x37, 0x63, 0x62, 0x30, 0x37, 0x66, 0x66, 0x65, 0x31, 0x33, 0x61, 0x34, 0x64, 0x64, 0x38, 0x61, 0x31, 0x38, 0x61, 0x63, 0x34, 0x62, 0x34, 0x64, 0x64, 0x62, 0x38, 0x33, 0x31, 0x39, 0x39, 0x35, 0x61, 0x32, 0x35, 0x32, 0x31, 0x39, 0x65, 0x30, 0x31, 0x34, 0x38, 0x66, 0x63, 0x61, 0x63, 0x31, 0x34, 0x31, 0x37, 0x38, 0x63, 0x31, 0x63, 0x63, 0x31, 0x34, 0x36, 0x63, 0x31, 0x37, 0x30, 0x34, 0x30, 0x65, 0x37, 0x34, 0x61, 0x31, 0x39, 0x61, 0x38, 0x33, 0x36, 0x63, 0x32, 0x32, 0x64, 0x34, 0x37, 0x32, 0x62, 0x36, 0x35, 0x61, 0x36, 0x34, 0x34, 0x35, 0x39, 0x61, 0x62, 0x32, 0x30, 0x37, 0x34, 0x37, 0x65, 0x36, 0x62, 0x62, 0x36, 0x36, 0x32, 0x33, 0x30, 0x38, 0x33, 0x66, 0x30, 0x63, 0x61, 0x33, 0x62, 0x64, 0x66, 0x61, 0x64, 0x62, 0x33, 0x63, 0x63, 0x61, 0x38, 0x65, 0x31, 0x35, 0x39, 0x37, 0x61, 0x66, 0x33, 0x32, 0x31, 0x34, 0x37, 0x34, 0x63, 0x30, 0x35, 0x32, 0x36, 0x64, 0x36, 0x63, 0x62, 0x64, 0x31, 0x65, 0x37, 0x66, 0x33, 0x61, 0x33, 0x38, 0x32, 0x34, 0x35, 0x31, 0x36, 0x66, 0x65, 0x64, 0x31, 0x64, 0x65, 0x31, 0x38, 0x64, 0x63, 0x64, 0x30, 0x66, 0x38, 0x64, 0x66, 0x65, 0x39, 0x33, 0x39, 0x61, 0x32, 0x39, 0x34, 0x30, 0x32, 0x65, 0x38, 0x66, 0x38, 0x62, 0x34, 0x32, 0x62, 0x65, 0x62, 0x63, 0x32, 0x31, 0x38, 0x66, 0x61, 0x35, 0x38, 0x61, 0x33, 0x31, 0x37, 0x32, 0x61, 0x61, 0x37, 0x33, 0x65, 0x32, 0x32, 0x39, 0x64, 0x63, 0x32, 0x30, 0x65, 0x37, 0x33, 0x38, 0x37, 0x38, 0x65, 0x31, 0x61, 0x61, 0x62, 0x65, 0x34, 0x37, 0x66, 0x30, 0x65, 0x30, 0x66, 0x30, 0x37, 0x63, 0x61, 0x61, 0x30, 0x30, 0x62, 0x32, 0x32, 0x65, 0x62, 0x38, 0x33, 0x61, 0x38, 0x33, 0x34, 0x62, 0x35, 0x33, 0x63, 0x35, 0x30, 0x35, 0x66, 0x37, 0x65, 0x66, 0x32, 0x62, 0x37, 0x32, 0x62, 0x35, 0x33, 0x39, 0x61, 0x62, 0x34, 0x34, 0x30, 0x61, 0x35, 0x38, 0x37, 0x65, 0x63, 0x63, 0x39, 0x35, 0x63, 0x63, 0x37, 0x64, 0x38, 0x64, 0x35, 0x36, 0x63, 0x64, 0x30, 0x30, 0x33, 0x38, 0x34, 0x33, 0x36, 0x31, 0x34, 0x64, 0x64, 0x62, 0x34, 0x31, 0x61, 0x62, 0x62, 0x35, 0x34, 0x62, 0x63, 0x39, 0x36, 0x30, 0x38, 0x62, 0x63, 0x66, 0x31, 0x31, 0x65, 0x30, 0x39, 0x37, 0x32, 0x36, 0x63, 0x30, 0x39, 0x66, 0x37, 0x37, 0x66, 0x61, 0x64, 0x61, 0x61, 0x33, 0x37, 0x34, 0x31, 0x62, 0x30, 0x63, 0x65, 0x32, 0x31, 0x34, 0x61, 0x66, 0x30, 0x62, 0x64, 0x30, 0x39, 0x34, 0x63, 0x62, 0x65, 0x34, 0x63, 0x33, 0x64, 0x66, 0x35, 0x32, 0x34, 0x66, 0x64, 0x39, 0x36, 0x65, 0x64, 0x62, 0x37, 0x30, 0x37, 0x30, 0x32, 0x37, 0x39, 0x33, 0x64, 0x65, 0x63, 0x65, 0x62, 0x66, 0x33, 0x34, 0x31, 0x61, 0x37, 0x66, 0x32, 0x36, 0x61, 0x32, 0x65, 0x63, 0x66, 0x39, 0x35, 0x32, 0x30, 0x38, 0x37, 0x34, 0x64, 0x37, 0x37, 0x63, 0x37, 0x32, 0x37, 0x30, 0x61, 0x66, 0x64, 0x66, 0x30, 0x32, 0x37, 0x39, 0x31, 0x38, 0x30, 0x30, 0x39, 0x31, 0x36, 0x37, 0x39, 0x32, 0x37, 0x31, 0x33, 0x34, 0x37, 0x62, 0x30, 0x33, 0x31, 0x61, 0x35, 0x34, 0x63, 0x38, 0x39, 0x35, 0x33, 0x64, 0x31, 0x66, 0x36, 0x30, 0x65, 0x62, 0x34, 0x63, 0x64, 0x35, 0x39, 0x34, 0x63, 0x62, 0x64, 0x33, 0x37, 0x32, 0x39, 0x30, 0x30, 0x31, 0x66, 0x62, 0x30, 0x61, 0x38, 0x31, 0x61, 0x64, 0x31, 0x36, 0x61, 0x35, 0x63, 0x34, 0x37, 0x30, 0x32, 0x32, 0x37, 0x37, 0x35, 0x34, 0x33, 0x62, 0x32, 0x63, 0x36, 0x65, 0x34, 0x66, 0x39, 0x62, 0x33, 0x32, 0x66, 0x66, 0x35, 0x31, 0x32, 0x33, 0x66, 0x62, 0x30, 0x39, 0x64, 0x65, 0x39, 0x62, 0x31, 0x65, 0x65, 0x64, 0x61, 0x31, 0x66, 0x37, 0x39, 0x64, 0x63, 0x66, 0x64, 0x32, 0x61, 0x38, 0x33, 0x38, 0x62, 0x30, 0x35, 0x36, 0x38, 0x63, 0x39, 0x35, 0x36, 0x30, 0x35, 0x66, 0x62, 0x30, 0x36, 0x63, 0x64, 0x34, 0x33, 0x35, 0x32, 0x39, 0x30, 0x61, 0x32, 0x35, 0x38, 0x36, 0x31, 0x62, 0x31, 0x63, 0x36, 0x64, 0x34, 0x35, 0x38, 0x62, 0x65, 0x33, 0x34, 0x63, 0x64, 0x33, 0x31, 0x39, 0x64, 0x64, 0x35, 0x30, 0x38, 0x31, 0x37, 0x32, 0x65, 0x33, 0x66, 0x38, 0x33, 0x32, 0x31, 0x32, 0x66, 0x30, 0x32, 0x65, 0x36, 0x65, 0x38, 0x66, 0x63, 0x66, 0x36, 0x31, 0x65, 0x61, 0x61, 0x36, 0x36, 0x61, 0x30, 0x39, 0x61, 0x33, 0x32, 0x33, 0x39, 0x66, 0x63, 0x31, 0x33, 0x34, 0x30, 0x32, 0x38, 0x30, 0x32, 0x62, 0x31, 0x31, 0x30, 0x36, 0x34, 0x38, 0x37, 0x32, 0x35, 0x65, 0x39, 0x62, 0x37, 0x65, 0x36, 0x33, 0x62, 0x63, 0x63, 0x38, 0x38, 0x64, 0x34, 0x62, 0x63, 0x30, 0x65, 0x36, 0x66, 0x37, 0x30, 0x61, 0x66, 0x32, 0x38, 0x65, 0x63, 0x33, 0x63, 0x63, 0x32, 0x31, 0x62, 0x35, 0x34, 0x30, 0x66, 0x33, 0x65, 0x66, 0x62, 0x36, 0x34, 0x33, 0x37, 0x33, 0x38, 0x38, 0x66, 0x34, 0x62, 0x35, 0x39, 0x31, 0x36, 0x32, 0x62, 0x32, 0x61, 0x31, 0x37, 0x32, 0x38, 0x62, 0x65, 0x37, 0x65, 0x66, 0x39, 0x32, 0x37, 0x35, 0x32, 0x33, 0x37, 0x35, 0x36, 0x62, 0x35, 0x61, 0x37, 0x35, 0x35, 0x36, 0x62, 0x61, 0x32, 0x65, 0x35, 0x64, 0x30, 0x62, 0x30, 0x64, 0x38, 0x33, 0x61, 0x64, 0x61, 0x31, 0x31, 0x30, 0x63, 0x61, 0x63, 0x62, 0x32, 0x64, 0x36, 0x66, 0x61, 0x33, 0x65, 0x32, 0x37, 0x39, 0x32, 0x63, 0x35, 0x64, 0x61, 0x33, 0x37, 0x30, 0x37, 0x32, 0x66, 0x37, 0x37, 0x31, 0x35, 0x62, 0x38, 0x33, 0x62, 0x38, 0x30, 0x39, 0x39, 0x63, 0x66, 0x65, 0x35, 0x34, 0x31, 0x37, 0x34, 0x37, 0x34, 0x33, 0x61, 0x31, 0x37, 0x39, 0x38, 0x65, 0x66, 0x30, 0x33, 0x64, 0x38, 0x38, 0x31, 0x36, 0x33, 0x38, 0x37, 0x63, 0x63, 0x65, 0x63, 0x62, 0x63, 0x39, 0x36, 0x65, 0x64, 0x65, 0x62, 0x39, 0x36, 0x66, 0x35, 0x32, 0x62, 0x33, 0x32, 0x34, 0x37, 0x32, 0x33, 0x62, 0x37, 0x61, 0x37, 0x33, 0x31, 0x34, 0x37, 0x65, 0x37, 0x34, 0x33, 0x32, 0x32, 0x38, 0x62, 0x30, 0x32, 0x34, 0x30, 0x30, 0x63, 0x62, 0x30, 0x36, 0x39, 0x61, 0x32, 0x62, 0x38, 0x39, 0x62, 0x39, 0x61, 0x61, 0x65, 0x65, 0x61, 0x66, 0x37, 0x64, 0x37, 0x63, 0x31, 0x66, 0x66, 0x62, 0x39, 0x36, 0x37, 0x31, 0x37, 0x62, 0x32, 0x66, 0x35, 0x39, 0x39, 0x63, 0x63, 0x62, 0x37, 0x32, 0x39, 0x62, 0x38, 0x64, 0x66, 0x66, 0x66, 0x64, 0x31, 0x66, 0x64, 0x33, 0x33, 0x38, 0x36, 0x63, 0x34, 0x31, 0x37, 0x39, 0x65, 0x33, 0x61, 0x39, 0x30, 0x30, 0x31, 0x31, 0x38, 0x37, 0x34, 0x31, 0x30, 0x39, 0x62, 0x33, 0x31, 0x31, 0x30, 0x36, 0x61, 0x65, 0x34, 0x35, 0x35, 0x38, 0x37, 0x65, 0x33, 0x35, 0x38, 0x33, 0x39, 0x37, 0x37, 0x37, 0x37, 0x37, 0x36, 0x62, 0x30, 0x63, 0x37, 0x32, 0x36, 0x36, 0x65, 0x65, 0x37, 0x63, 0x38, 0x35, 0x36, 0x36, 0x35, 0x61, 0x64, 0x64, 0x62, 0x61, 0x65, 0x32, 0x31, 0x65, 0x38, 0x34, 0x38, 0x62, 0x34, 0x38, 0x34, 0x64, 0x63, 0x65, 0x37, 0x33, 0x34, 0x37, 0x32, 0x31, 0x62, 0x31, 0x32, 0x34, 0x66, 0x65, 0x39, 0x34, 0x63, 0x30, 0x31, 0x37, 0x38, 0x35, 0x64, 0x35, 0x62, 0x62, 0x63, 0x36, 0x31, 0x39, 0x63, 0x66, 0x36, 0x36, 0x37, 0x32, 0x65, 0x39, 0x34, 0x35, 0x61, 0x63, 0x35, 0x33, 0x30, 0x33, 0x64, 0x35, 0x35, 0x35, 0x38, 0x33, 0x36, 0x65, 0x31, 0x61, 0x62, 0x35, 0x39, 0x31, 0x31, 0x30, 0x64, 0x66, 0x37, 0x65, 0x61, 0x63, 0x34, 0x66, 0x35, 0x62, 0x37, 0x34, 0x65, 0x33, 0x64, 0x38, 0x30, 0x33, 0x35, 0x65, 0x64, 0x36, 0x30, 0x36, 0x38, 0x39, 0x30, 0x32, 0x62, 0x34, 0x61, 0x63, 0x37, 0x36, 0x65, 0x62, 0x37, 0x32, 0x66, 0x39, 0x64, 0x65, 0x65, 0x66, 0x35, 0x63, 0x32, 0x30, 0x31, 0x39, 0x33, 0x37, 0x65, 0x32, 0x30, 0x32, 0x63, 0x33, 0x63, 0x61, 0x34, 0x64, 0x63, 0x63, 0x35, 0x66, 0x36, 0x31, 0x39, 0x61, 0x36, 0x65, 0x39, 0x37, 0x64, 0x37, 0x65, 0x34, 0x63, 0x64, 0x37, 0x33, 0x36, 0x64, 0x62, 0x66, 0x61, 0x36, 0x62, 0x30, 0x32, 0x62, 0x32, 0x33, 0x37, 0x63, 0x33, 0x36, 0x35, 0x65, 0x30, 0x39, 0x62, 0x64, 0x37, 0x39, 0x62, 0x61, 0x30, 0x31, 0x66, 0x35, 0x61, 0x62, 0x64, 0x30, 0x34, 0x36, 0x63, 0x35, 0x32, 0x65, 0x64, 0x35, 0x61, 0x35, 0x64, 0x31, 0x33, 0x35, 0x35, 0x38, 0x32, 0x39, 0x35, 0x37, 0x62, 0x32, 0x64, 0x37, 0x64, 0x31, 0x30, 0x61, 0x35, 0x38, 0x39, 0x33, 0x35, 0x65, 0x39, 0x66, 0x30, 0x32, 0x65, 0x31, 0x32, 0x38, 0x61, 0x66, 0x66, 0x33, 0x30, 0x63, 0x30, 0x33, 0x35, 0x38, 0x30, 0x65, 0x61, 0x32, 0x33, 0x39, 0x36, 0x38, 0x32, 0x33, 0x32, 0x33, 0x65, 0x38, 0x39, 0x37, 0x66, 0x64, 0x33, 0x32, 0x30, 0x34, 0x35, 0x35, 0x62, 0x38, 0x63, 0x37, 0x37, 0x65, 0x33, 0x34, 0x32, 0x30, 0x31, 0x34, 0x32, 0x30, 0x31, 0x36, 0x31, 0x37, 0x65, 0x34, 0x61, 0x65, 0x64, 0x39, 0x34, 0x35, 0x30, 0x34, 0x64, 0x39, 0x34, 0x65, 0x36, 0x32, 0x66, 0x66, 0x37, 0x32, 0x38, 0x36, 0x30, 0x31, 0x34, 0x63, 0x30, 0x64, 0x32, 0x37, 0x61, 0x63, 0x66, 0x66, 0x31, 0x33, 0x37, 0x63, 0x62, 0x62, 0x37, 0x62, 0x38, 0x38, 0x64, 0x32, 0x64, 0x31, 0x37, 0x33, 0x34, 0x63, 0x33, 0x62, 0x34, 0x61, 0x33, 0x37, 0x38, 0x36, 0x33, 0x32, 0x30, 0x66, 0x38, 0x34, 0x62, 0x39, 0x64, 0x64, 0x39, 0x33, 0x61, 0x31, 0x64, 0x36, 0x65, 0x31, 0x33, 0x63, 0x33, 0x30, 0x37, 0x32, 0x34, 0x36, 0x35, 0x61, 0x34, 0x37, 0x38, 0x65, 0x34, 0x61, 0x39, 0x63, 0x33, 0x62, 0x63, 0x62, 0x35, 0x66, 0x63, 0x35, 0x32, 0x63, 0x62, 0x32, 0x31, 0x34, 0x31, 0x34, 0x39, 0x36, 0x30, 0x30, 0x64, 0x61, 0x39, 0x61, 0x64, 0x36, 0x31, 0x34, 0x38, 0x61, 0x64, 0x31, 0x38, 0x38, 0x38, 0x39, 0x32, 0x32, 0x37, 0x33, 0x37, 0x33, 0x35, 0x61, 0x63, 0x34, 0x61, 0x38, 0x32, 0x36, 0x36, 0x63, 0x32, 0x31, 0x35, 0x32, 0x66, 0x66, 0x38, 0x32, 0x33, 0x36, 0x34, 0x37, 0x38, 0x61, 0x66, 0x30, 0x39, 0x32, 0x32, 0x61, 0x36, 0x65, 0x31, 0x38, 0x39, 0x36, 0x38, 0x63, 0x37, 0x61, 0x31, 0x39, 0x32, 0x62, 0x66, 0x62, 0x36, 0x34, 0x30, 0x61, 0x65, 0x32, 0x63, 0x34, 0x65, 0x63, 0x61, 0x37, 0x30, 0x34, 0x62, 0x37, 0x35, 0x31, 0x61, 0x61, 0x33, 0x62, 0x63, 0x39, 0x66, 0x31, 0x33, 0x61, 0x35, 0x36, 0x39, 0x37, 0x62, 0x37, 0x36, 0x30, 0x61, 0x31, 0x34, 0x30, 0x35, 0x33, 0x30, 0x34, 0x31, 0x38, 0x62, 0x39, 0x66, 0x30, 0x34, 0x64, 0x65, 0x63, 0x61, 0x31, 0x66, 0x66, 0x38, 0x38, 0x38, 0x30, 0x30, 0x66, 0x61, 0x34, 0x63, 0x38, 0x33, 0x62, 0x31, 0x64, 0x38, 0x65, 0x32, 0x35, 0x30, 0x64, 0x66, 0x39, 0x34, 0x39, 0x61, 0x32, 0x64, 0x32, 0x32, 0x63, 0x37, 0x34, 0x31, 0x38, 0x33, 0x66, 0x66, 0x66, 0x64, 0x35, 0x34, 0x66, 0x65, 0x36, 0x38, 0x65, 0x32, 0x62, 0x35, 0x62, 0x37, 0x31, 0x33, 0x63, 0x38, 0x66, 0x31, 0x37, 0x35, 0x32, 0x66, 0x65, 0x35, 0x31, 0x38, 0x34, 0x61, 0x34, 0x36, 0x63, 0x31, 0x39, 0x31, 0x36, 0x39, 0x32, 0x62, 0x61, 0x37, 0x37, 0x62, 0x36, 0x39, 0x36, 0x30, 0x62, 0x30, 0x62, 0x65, 0x30, 0x30, 0x39, 0x39, 0x64, 0x35, 0x61, 0x37, 0x32, 0x30, 0x61, 0x62, 0x65, 0x39, 0x32, 0x33, 0x61, 0x32, 0x33, 0x31, 0x39, 0x36, 0x32, 0x66, 0x65, 0x37, 0x62, 0x36, 0x31, 0x38, 0x38, 0x39, 0x63, 0x61, 0x33, 0x65, 0x35, 0x65, 0x66, 0x30, 0x37, 0x34, 0x30, 0x30, 0x34, 0x36, 0x65, 0x33, 0x37, 0x63, 0x36, 0x31, 0x30, 0x33, 0x62, 0x35, 0x37, 0x65, 0x62, 0x34, 0x65, 0x32, 0x34, 0x65, 0x61, 0x31, 0x64, 0x65, 0x32, 0x64, 0x63, 0x37, 0x32, 0x63, 0x64, 0x31, 0x36, 0x63, 0x38, 0x61, 0x39, 0x31, 0x66, 0x37, 0x37, 0x62, 0x35, 0x33, 0x38, 0x37, 0x35, 0x66, 0x38, 0x31, 0x32, 0x62, 0x31, 0x32, 0x63, 0x32, 0x32, 0x64, 0x32, 0x65, 0x31, 0x63, 0x61, 0x31, 0x64, 0x39, 0x31, 0x62, 0x36, 0x61, 0x33, 0x33, 0x32, 0x32, 0x39, 0x37, 0x30, 0x36, 0x33, 0x37, 0x65, 0x61, 0x34, 0x64, 0x30, 0x63, 0x37, 0x35, 0x61, 0x63, 0x33, 0x31, 0x31, 0x38, 0x64, 0x65, 0x39, 0x35, 0x30, 0x36, 0x39, 0x61, 0x66, 0x38, 0x62, 0x65, 0x61, 0x39, 0x65, 0x33, 0x38, 0x31, 0x62, 0x65, 0x34, 0x36, 0x36, 0x64, 0x35, 0x37, 0x61, 0x32, 0x35, 0x63, 0x62, 0x32, 0x64, 0x32, 0x37, 0x39, 0x30, 0x62, 0x34, 0x65, 0x33, 0x64, 0x36, 0x64, 0x33, 0x32, 0x63, 0x30, 0x33, 0x39, 0x61, 0x32, 0x31, 0x36, 0x65, 0x38, 0x35, 0x34, 0x36, 0x38, 0x36, 0x37, 0x32, 0x62, 0x64, 0x31, 0x63, 0x31, 0x30, 0x62, 0x38, 0x34, 0x34, 0x35, 0x63, 0x61, 0x38, 0x66, 0x39, 0x33, 0x38, 0x65, 0x36, 0x65, 0x62, 0x32, 0x37, 0x35, 0x31, 0x39, 0x33, 0x37, 0x35, 0x37, 0x31, 0x32, 0x63, 0x62, 0x34, 0x65, 0x35, 0x61, 0x65, 0x33, 0x32, 0x32, 0x66, 0x64, 0x39, 0x32, 0x63, 0x63, 0x38, 0x63, 0x33, 0x65, 0x31, 0x30, 0x61, 0x38, 0x63, 0x36, 0x35, 0x32, 0x34, 0x37, 0x32, 0x61, 0x63, 0x65, 0x37, 0x33, 0x31, 0x64, 0x37, 0x33, 0x33, 0x34, 0x39, 0x37, 0x63, 0x61, 0x33, 0x61, 0x62, 0x35, 0x66, 0x64, 0x31, 0x61, 0x32, 0x38, 0x31, 0x66, 0x35, 0x61, 0x64, 0x32, 0x39, 0x35, 0x30, 0x30, 0x38, 0x33, 0x37, 0x31, 0x65, 0x63, 0x61, 0x32, 0x30, 0x33, 0x36, 0x36, 0x62, 0x35, 0x30, 0x38, 0x62, 0x37, 0x36, 0x39, 0x34, 0x39, 0x35, 0x66, 0x65, 0x63, 0x39, 0x37, 0x32, 0x66, 0x61, 0x34, 0x65, 0x34, 0x61, 0x63, 0x62, 0x39, 0x39, 0x31, 0x39, 0x31, 0x34, 0x33, 0x35, 0x62, 0x39, 0x34, 0x32, 0x61, 0x62, 0x64, 0x66, 0x35, 0x33, 0x35, 0x35, 0x35, 0x34, 0x64, 0x62, 0x66, 0x37, 0x34, 0x36, 0x66, 0x38, 0x62, 0x37, 0x36, 0x36, 0x65, 0x64, 0x38, 0x37, 0x61, 0x31, 0x65, 0x35, 0x37, 0x39, 0x39, 0x39, 0x37, 0x66, 0x36, 0x36, 0x36, 0x35, 0x34, 0x64, 0x30, 0x35, 0x32, 0x61, 0x37, 0x34, 0x66, 0x66, 0x31, 0x31, 0x37, 0x62, 0x66, 0x30, 0x33, 0x36, 0x34, 0x65, 0x65, 0x35, 0x61, 0x61, 0x31, 0x64, 0x32, 0x38, 0x38, 0x30, 0x66, 0x64, 0x30, 0x65, 0x31, 0x61, 0x32, 0x63, 0x38, 0x63, 0x31, 0x37, 0x65, 0x66, 0x65, 0x66, 0x62, 0x61, 0x32, 0x31, 0x35, 0x33, 0x36, 0x36, 0x66, 0x36, 0x64, 0x39, 0x32, 0x65, 0x31, 0x63, 0x31, 0x63, 0x64, 0x31, 0x37, 0x32, 0x62, 0x36, 0x33, 0x35, 0x33, 0x36, 0x62, 0x34, 0x61, 0x61, 0x35, 0x31, 0x33, 0x33, 0x38, 0x38, 0x38, 0x35, 0x35, 0x61, 0x30, 0x66, 0x63, 0x65, 0x31, 0x66, 0x66, 0x64, 0x65, 0x34, 0x35, 0x31, 0x65, 0x39, 0x64, 0x39, 0x39, 0x35, 0x64, 0x62, 0x37, 0x31, 0x37, 0x34, 0x36, 0x66, 0x33, 0x62, 0x33, 0x39, 0x33, 0x64, 0x61, 0x33, 0x64, 0x61, 0x66, 0x38, 0x61, 0x32, 0x64, 0x30, 0x37, 0x32, 0x66, 0x33, 0x35, 0x61, 0x36, 0x62, 0x35, 0x65, 0x32, 0x35, 0x39, 0x32, 0x64, 0x61, 0x36, 0x64, 0x34, 0x30, 0x34, 0x65, 0x61, 0x38, 0x62, 0x63, 0x38, 0x64, 0x31, 0x65, 0x37, 0x63, 0x62, 0x65, 0x61, 0x35, 0x32, 0x64, 0x30, 0x34, 0x34, 0x35, 0x35, 0x36, 0x32, 0x36, 0x39, 0x63, 0x62, 0x33, 0x31, 0x36, 0x37, 0x37, 0x30, 0x33, 0x37, 0x64, 0x33, 0x39, 0x31, 0x34, 0x34, 0x31, 0x37, 0x32, 0x64, 0x63, 0x35, 0x36, 0x38, 0x38, 0x35, 0x32, 0x64, 0x38, 0x61, 0x34, 0x39, 0x61, 0x35, 0x61, 0x62, 0x65, 0x39, 0x31, 0x61, 0x62, 0x35, 0x31, 0x62, 0x65, 0x64, 0x61, 0x66, 0x30, 0x32, 0x66, 0x36, 0x30, 0x62, 0x38, 0x62, 0x39, 0x38, 0x30, 0x62, 0x33, 0x33, 0x32, 0x30, 0x66, 0x39, 0x34, 0x31, 0x35, 0x33, 0x34, 0x64, 0x34, 0x32, 0x63, 0x62, 0x61, 0x61, 0x66, 0x64, 0x38, 0x36, 0x64, 0x31, 0x35, 0x61, 0x32, 0x39, 0x39, 0x31, 0x31, 0x35, 0x31, 0x64, 0x37, 0x31, 0x62, 0x65, 0x36, 0x33, 0x34, 0x32, 0x31, 0x33, 0x65, 0x33, 0x64, 0x64, 0x32, 0x35, 0x37, 0x63, 0x31, 0x33, 0x31, 0x36, 0x61, 0x31, 0x30, 0x65, 0x35, 0x38, 0x63, 0x35, 0x63, 0x35, 0x39, 0x63, 0x31, 0x34, 0x66, 0x38, 0x36, 0x30, 0x64, 0x32, 0x61, 0x36, 0x64, 0x39, 0x63, 0x66, 0x32, 0x32, 0x35, 0x34, 0x31, 0x64, 0x37, 0x35, 0x37, 0x38, 0x65, 0x66, 0x66, 0x32, 0x32, 0x36, 0x66, 0x66, 0x33, 0x33, 0x38, 0x34, 0x31, 0x31, 0x65, 0x37, 0x62, 0x36, 0x64, 0x39, 0x61, 0x33, 0x33, 0x64, 0x61, 0x32, 0x65, 0x31, 0x64, 0x34, 0x33, 0x36, 0x61, 0x35, 0x61, 0x63, 0x35, 0x31, 0x35, 0x32, 0x37, 0x63, 0x63, 0x37, 0x37, 0x34, 0x36, 0x38, 0x31, 0x35, 0x66, 0x31, 0x37, 0x32, 0x61, 0x64, 0x61, 0x34, 0x65, 0x30, 0x63, 0x33, 0x39, 0x39, 0x32, 0x33, 0x64, 0x63, 0x32, 0x34, 0x34, 0x63, 0x35, 0x61, 0x35, 0x31, 0x36, 0x34, 0x62, 0x34, 0x61, 0x34, 0x65, 0x61, 0x65, 0x37, 0x31, 0x66, 0x32, 0x64, 0x34, 0x39, 0x38, 0x36, 0x34, 0x33, 0x33, 0x31, 0x32, 0x64, 0x64, 0x39, 0x63, 0x38, 0x36, 0x64, 0x65, 0x32, 0x32, 0x66, 0x65, 0x61, 0x63, 0x61, 0x35, 0x39, 0x31, 0x38, 0x35, 0x36, 0x38, 0x37, 0x32, 0x36, 0x30, 0x38, 0x64, 0x63, 0x31, 0x30, 0x61, 0x34, 0x33, 0x61, 0x35, 0x64, 0x30, 0x35, 0x35, 0x66, 0x63, 0x38, 0x65, 0x36, 0x33, 0x65, 0x30, 0x34, 0x66, 0x37, 0x32, 0x39, 0x31, 0x30, 0x31, 0x36, 0x32, 0x32, 0x37, 0x34, 0x35, 0x35, 0x63, 0x32, 0x61, 0x38, 0x64, 0x64, 0x62, 0x32, 0x33, 0x64, 0x39, 0x66, 0x62, 0x65, 0x61, 0x66, 0x30, 0x64, 0x31, 0x39, 0x63, 0x35, 0x63, 0x37, 0x32, 0x37, 0x64, 0x37, 0x39, 0x65, 0x62, 0x31, 0x36, 0x63, 0x32, 0x64, 0x34, 0x64, 0x34, 0x64, 0x36, 0x35, 0x30, 0x66, 0x32, 0x38, 0x36, 0x37, 0x37, 0x34, 0x39, 0x61, 0x35, 0x33, 0x36, 0x31, 0x65, 0x37, 0x39, 0x61, 0x32, 0x34, 0x63, 0x31, 0x36, 0x63, 0x31, 0x36, 0x61, 0x32, 0x34, 0x61, 0x35, 0x36, 0x37, 0x32, 0x35, 0x62, 0x61, 0x64, 0x63, 0x30, 0x33, 0x61, 0x35, 0x33, 0x38, 0x37, 0x32, 0x31, 0x35, 0x32, 0x65, 0x33, 0x39, 0x65, 0x33, 0x37, 0x38, 0x38, 0x66, 0x62, 0x63, 0x64, 0x64, 0x38, 0x35, 0x34, 0x35, 0x65, 0x64, 0x37, 0x62, 0x39, 0x61, 0x31, 0x66, 0x38, 0x64, 0x35, 0x64, 0x64, 0x66, 0x34, 0x64, 0x63, 0x37, 0x62, 0x38, 0x66, 0x63, 0x36, 0x31, 0x31, 0x64, 0x31, 0x39, 0x36, 0x31, 0x64, 0x61, 0x35, 0x38, 0x61, 0x30, 0x36, 0x37, 0x30, 0x36, 0x63, 0x66, 0x37, 0x32, 0x39, 0x65, 0x37, 0x32, 0x33, 0x30, 0x31, 0x31, 0x30, 0x37, 0x61, 0x30, 0x33, 0x31, 0x63, 0x65, 0x64, 0x36, 0x32, 0x65, 0x62, 0x66, 0x37, 0x38, 0x62, 0x66, 0x62, 0x61, 0x32, 0x33, 0x39, 0x32, 0x31, 0x33, 0x36, 0x31, 0x61, 0x64, 0x33, 0x66, 0x30, 0x34, 0x31, 0x38, 0x66, 0x31, 0x66, 0x37, 0x37, 0x36, 0x38, 0x32, 0x35, 0x36, 0x62, 0x34, 0x38, 0x38, 0x66, 0x65, 0x32, 0x63, 0x37, 0x32, 0x37, 0x32, 0x66, 0x35, 0x63, 0x36, 0x36, 0x32, 0x31, 0x34, 0x34, 0x37, 0x66, 0x65, 0x33, 0x66, 0x31, 0x66, 0x64, 0x66, 0x62, 0x36, 0x30, 0x33, 0x33, 0x39, 0x64, 0x66, 0x38, 0x38, 0x30, 0x30, 0x39, 0x39, 0x38, 0x33, 0x33, 0x31, 0x31, 0x33, 0x31, 0x30, 0x62, 0x39, 0x35, 0x34, 0x31, 0x32, 0x35, 0x63, 0x37, 0x34, 0x39, 0x36, 0x61, 0x36, 0x31, 0x63, 0x31, 0x65, 0x31, 0x62, 0x34, 0x38, 0x66, 0x63, 0x39, 0x39, 0x61, 0x37, 0x62, 0x36, 0x62, 0x39, 0x65, 0x30, 0x30, 0x38, 0x38, 0x39, 0x38, 0x31, 0x30, 0x35, 0x31, 0x30, 0x65, 0x66, 0x64, 0x66, 0x37, 0x39, 0x64, 0x32, 0x30, 0x34, 0x37, 0x33, 0x62, 0x34, 0x36, 0x38, 0x62, 0x32, 0x34, 0x32, 0x36, 0x61, 0x62, 0x31, 0x66, 0x30, 0x36, 0x33, 0x61, 0x62, 0x64, 0x39, 0x39, 0x35, 0x66, 0x35, 0x35, 0x39, 0x31, 0x36, 0x37, 0x32, 0x39, 0x61, 0x63, 0x62, 0x62, 0x61, 0x66, 0x63, 0x32, 0x30, 0x65, 0x63, 0x35, 0x65, 0x30, 0x39, 0x31, 0x66, 0x38, 0x64, 0x33, 0x64, 0x37, 0x64, 0x66, 0x63, 0x66, 0x36, 0x33, 0x62, 0x65, 0x31, 0x31, 0x32, 0x32, 0x30, 0x64, 0x35, 0x61, 0x36, 0x30, 0x34, 0x65, 0x38, 0x39, 0x38, 0x61, 0x61, 0x30, 0x39, 0x36, 0x37, 0x65, 0x61, 0x30, 0x63, 0x63, 0x62, 0x33, 0x37, 0x62, 0x62, 0x37, 0x32, 0x33, 0x38, 0x36, 0x62, 0x39, 0x63, 0x63, 0x65, 0x62, 0x33, 0x31, 0x30, 0x35, 0x66, 0x37, 0x39, 0x31, 0x39, 0x36, 0x32, 0x36, 0x39, 0x62, 0x34, 0x37, 0x30, 0x39, 0x34, 0x64, 0x61, 0x35, 0x32, 0x39, 0x35, 0x62, 0x32, 0x61, 0x36, 0x37, 0x35, 0x65, 0x39, 0x33, 0x36, 0x65, 0x30, 0x31, 0x61, 0x39, 0x39, 0x39, 0x30, 0x64, 0x61, 0x39, 0x34, 0x62, 0x62, 0x64, 0x31, 0x66, 0x31, 0x37, 0x32, 0x63, 0x35, 0x62, 0x39, 0x34, 0x39, 0x32, 0x61, 0x66, 0x63, 0x34, 0x63, 0x33, 0x64, 0x61, 0x63, 0x65, 0x63, 0x35, 0x31, 0x63, 0x65, 0x63, 0x65, 0x62, 0x61, 0x36, 0x62, 0x62, 0x36, 0x36, 0x61, 0x62, 0x32, 0x62, 0x61, 0x32, 0x63, 0x32, 0x31, 0x35, 0x33, 0x39, 0x37, 0x64, 0x66, 0x65, 0x39, 0x39, 0x30, 0x30, 0x35, 0x62, 0x61, 0x31, 0x39, 0x37, 0x37, 0x37, 0x31, 0x35, 0x33, 0x37, 0x32, 0x31, 0x39, 0x34, 0x64, 0x35, 0x33, 0x61, 0x66, 0x33, 0x64, 0x31, 0x33, 0x33, 0x62, 0x34, 0x64, 0x39, 0x65, 0x35, 0x39, 0x34, 0x39, 0x33, 0x30, 0x36, 0x35, 0x34, 0x32, 0x65, 0x65, 0x37, 0x62, 0x62, 0x62, 0x33, 0x39, 0x37, 0x32, 0x64, 0x65, 0x37, 0x65, 0x37, 0x66, 0x37, 0x39, 0x38, 0x35, 0x39, 0x32, 0x33, 0x33, 0x62, 0x37, 0x33, 0x37, 0x32, 0x36, 0x63, 0x65, 0x30, 0x39, 0x37, 0x32, 0x65, 0x66, 0x62, 0x65, 0x31, 0x30, 0x33, 0x34, 0x30, 0x36, 0x38, 0x31, 0x34, 0x62, 0x37, 0x34, 0x39, 0x32, 0x37, 0x63, 0x39, 0x35, 0x36, 0x31, 0x61, 0x30, 0x37, 0x62, 0x39, 0x36, 0x61, 0x63, 0x61, 0x38, 0x65, 0x64, 0x31, 0x35, 0x38, 0x35, 0x36, 0x31, 0x30, 0x36, 0x32, 0x35, 0x34, 0x39, 0x32, 0x39, 0x35, 0x62, 0x38, 0x64, 0x63, 0x30, 0x32, 0x61, 0x30, 0x33, 0x66, 0x66, 0x31, 0x61, 0x62, 0x39, 0x61, 0x38, 0x65, 0x34, 0x34, 0x63, 0x38, 0x31, 0x65, 0x64, 0x66, 0x65, 0x33, 0x36, 0x39, 0x37, 0x38, 0x65, 0x65, 0x39, 0x30, 0x32, 0x31, 0x36, 0x30, 0x36, 0x31, 0x64, 0x63, 0x36, 0x31, 0x38, 0x63, 0x62, 0x35, 0x62, 0x65, 0x61, 0x65, 0x33, 0x39, 0x64, 0x64, 0x66, 0x66, 0x32, 0x63, 0x63, 0x66, 0x62, 0x63, 0x63, 0x37, 0x66, 0x31, 0x61, 0x30, 0x61, 0x66, 0x36, 0x37, 0x32, 0x66, 0x33, 0x37, 0x62, 0x35, 0x39, 0x66, 0x63, 0x31, 0x64, 0x61, 0x64, 0x33, 0x64, 0x37, 0x31, 0x32, 0x37, 0x30, 0x63, 0x65, 0x65, 0x64, 0x61, 0x35, 0x66, 0x65, 0x38, 0x33, 0x65, 0x33, 0x35, 0x65, 0x63, 0x63, 0x36, 0x37, 0x66, 0x62, 0x37, 0x32, 0x38, 0x66, 0x38, 0x35, 0x36, 0x39, 0x39, 0x34, 0x37, 0x64, 0x37, 0x37, 0x31, 0x65, 0x66, 0x61, 0x32, 0x32, 0x39, 0x39, 0x31, 0x35, 0x65, 0x65, 0x32, 0x62, 0x65, 0x65, 0x35, 0x34, 0x30, 0x36, 0x66, 0x64, 0x64, 0x66, 0x66, 0x37, 0x39, 0x32, 0x34, 0x38, 0x62, 0x64, 0x31, 0x38, 0x34, 0x61, 0x38, 0x38, 0x38, 0x62, 0x38, 0x61, 0x39, 0x63, 0x34, 0x39, 0x66, 0x33, 0x36, 0x65, 0x38, 0x39, 0x62, 0x30, 0x62, 0x34, 0x39, 0x32, 0x33, 0x61, 0x63, 0x36, 0x32, 0x61, 0x31, 0x30, 0x36, 0x64, 0x61, 0x62, 0x37, 0x62, 0x37, 0x37, 0x32, 0x35, 0x62, 0x66, 0x31, 0x33, 0x39, 0x63, 0x33, 0x39, 0x65, 0x65, 0x32, 0x63, 0x62, 0x35, 0x39, 0x39, 0x66, 0x38, 0x66, 0x65, 0x37, 0x34, 0x63, 0x33, 0x34, 0x30, 0x32, 0x33, 0x30, 0x31, 0x63, 0x64, 0x33, 0x36, 0x34, 0x64, 0x34, 0x31, 0x64, 0x32, 0x36, 0x33, 0x35, 0x39, 0x30, 0x62, 0x33, 0x38, 0x61, 0x61, 0x30, 0x66, 0x37, 0x36, 0x34, 0x64, 0x36, 0x39, 0x37, 0x34, 0x66, 0x36, 0x37, 0x33, 0x61, 0x36, 0x35, 0x64, 0x62, 0x36, 0x36, 0x35, 0x64, 0x62, 0x38, 0x37, 0x66, 0x66, 0x38, 0x35, 0x62, 0x64, 0x33, 0x62, 0x35, 0x65, 0x65, 0x66, 0x33, 0x66, 0x34, 0x61, 0x61, 0x31, 0x30, 0x62, 0x33, 0x65, 0x32, 0x33, 0x62, 0x33, 0x62, 0x63, 0x61, 0x33, 0x66, 0x30, 0x65, 0x37, 0x30, 0x39, 0x39, 0x34, 0x61, 0x65, 0x35, 0x65, 0x31, 0x37, 0x31, 0x31, 0x30, 0x38, 0x66, 0x37, 0x32, 0x63, 0x64, 0x34, 0x36, 0x61, 0x64, 0x66, 0x37, 0x31, 0x61, 0x35, 0x65, 0x37, 0x39, 0x34, 0x61, 0x66, 0x61, 0x34, 0x33, 0x32, 0x34, 0x64, 0x63, 0x33, 0x35, 0x65, 0x30, 0x32, 0x33, 0x37, 0x64, 0x61, 0x62, 0x66, 0x30, 0x64, 0x63, 0x63, 0x61, 0x65, 0x63, 0x31, 0x34, 0x64, 0x36, 0x64, 0x30, 0x65, 0x66, 0x63, 0x37, 0x30, 0x37, 0x38, 0x63, 0x31, 0x31, 0x39, 0x36, 0x35, 0x61, 0x32, 0x66, 0x63, 0x39, 0x37, 0x31, 0x63, 0x36, 0x36, 0x31, 0x66, 0x33, 0x31, 0x38, 0x63, 0x63, 0x65, 0x33, 0x32, 0x64, 0x63, 0x34, 0x36, 0x65, 0x63, 0x33, 0x66, 0x35, 0x64, 0x61, 0x63, 0x63, 0x33, 0x39, 0x34, 0x65, 0x64, 0x63, 0x31, 0x38, 0x64, 0x37, 0x39, 0x66, 0x33, 0x64, 0x39, 0x62, 0x61, 0x38, 0x61, 0x64, 0x32, 0x36, 0x37, 0x62, 0x38, 0x64, 0x30, 0x34, 0x31, 0x30, 0x64, 0x33, 0x37, 0x32, 0x35, 0x33, 0x35, 0x31, 0x32, 0x64, 0x65, 0x30, 0x33, 0x61, 0x62, 0x32, 0x63, 0x30, 0x61, 0x66, 0x66, 0x32, 0x36, 0x66, 0x32, 0x65, 0x39, 0x30, 0x32, 0x36, 0x61, 0x37, 0x62, 0x64, 0x36, 0x33, 0x34, 0x66, 0x30, 0x33, 0x39, 0x39, 0x65, 0x63, 0x35, 0x36, 0x66, 0x33, 0x38, 0x33, 0x35, 0x38, 0x62, 0x39, 0x63, 0x65, 0x36, 0x39, 0x36, 0x32, 0x32, 0x37, 0x61, 0x36, 0x66, 0x34, 0x33, 0x36, 0x32, 0x35, 0x31, 0x36, 0x61, 0x31, 0x62, 0x33, 0x61, 0x34, 0x30, 0x65, 0x30, 0x30, 0x38, 0x30, 0x37, 0x63, 0x38, 0x66, 0x37, 0x62, 0x30, 0x63, 0x32, 0x62, 0x34, 0x38, 0x66, 0x61, 0x32, 0x65, 0x38, 0x32, 0x39, 0x62, 0x37, 0x35, 0x34, 0x66, 0x35, 0x37, 0x37, 0x34, 0x65, 0x31, 0x66, 0x30, 0x34, 0x35, 0x38, 0x66, 0x35, 0x30, 0x66, 0x31, 0x65, 0x39, 0x30, 0x63, 0x30, 0x62, 0x30, 0x62, 0x31, 0x36, 0x61, 0x66, 0x32, 0x36, 0x64, 0x38, 0x36, 0x62, 0x34, 0x65, 0x34, 0x31, 0x61, 0x64, 0x38, 0x37, 0x37, 0x65, 0x62, 0x31, 0x33, 0x33, 0x31, 0x31, 0x65, 0x35, 0x34, 0x64, 0x39, 0x66, 0x33, 0x64, 0x34, 0x64, 0x65, 0x35, 0x32, 0x37, 0x38, 0x38, 0x33, 0x64, 0x61, 0x38, 0x32, 0x37, 0x33, 0x39, 0x66, 0x38, 0x38, 0x65, 0x31, 0x65, 0x37, 0x39, 0x63, 0x65, 0x31, 0x66, 0x34, 0x37, 0x34, 0x35, 0x38, 0x38, 0x31, 0x31, 0x64, 0x66, 0x36, 0x62, 0x65, 0x63, 0x30, 0x63, 0x65, 0x66, 0x66, 0x64, 0x64, 0x66, 0x66, 0x63, 0x39, 0x61, 0x64, 0x33, 0x30, 0x63, 0x36, 0x33, 0x39, 0x34, 0x65, 0x33, 0x65, 0x35, 0x31, 0x65, 0x62, 0x35, 0x64, 0x38, 0x62, 0x33, 0x33, 0x65, 0x37, 0x32, 0x64, 0x65, 0x62, 0x30, 0x64, 0x35, 0x37, 0x31, 0x65, 0x61, 0x62, 0x62, 0x36, 0x31, 0x36, 0x66, 0x65, 0x65, 0x35, 0x34, 0x63, 0x33, 0x62, 0x38, 0x62, 0x30, 0x66, 0x36, 0x65, 0x62, 0x39, 0x36, 0x62, 0x66, 0x39, 0x30, 0x35, 0x35, 0x63, 0x63, 0x30, 0x37, 0x31, 0x34, 0x66, 0x66, 0x33, 0x37, 0x35, 0x62, 0x36, 0x36, 0x61, 0x64, 0x34, 0x38, 0x37, 0x63, 0x64, 0x38, 0x34, 0x36, 0x61, 0x63, 0x30, 0x63, 0x36, 0x64, 0x34, 0x36, 0x32, 0x62, 0x34, 0x64, 0x38, 0x30, 0x31, 0x32, 0x37, 0x32, 0x38, 0x37, 0x31, 0x30, 0x66, 0x35, 0x62, 0x33, 0x62, 0x30, 0x30, 0x66, 0x36, 0x61, 0x37, 0x65, 0x34, 0x61, 0x35, 0x30, 0x33, 0x66, 0x35, 0x63, 0x36, 0x36, 0x31, 0x36, 0x35, 0x39, 0x65, 0x39, 0x66, 0x33, 0x32, 0x62, 0x65, 0x66, 0x66, 0x61, 0x38, 0x30, 0x35, 0x32, 0x62, 0x34, 0x66, 0x62, 0x33, 0x31, 0x37, 0x64, 0x39, 0x36, 0x37, 0x30, 0x32, 0x63, 0x36, 0x38, 0x35, 0x34, 0x37, 0x32, 0x32, 0x65, 0x36, 0x61, 0x33, 0x65, 0x37, 0x34, 0x32, 0x35, 0x37, 0x37, 0x65, 0x39, 0x63, 0x32, 0x35, 0x39, 0x34, 0x62, 0x33, 0x39, 0x35, 0x32, 0x38, 0x37, 0x33, 0x33, 0x39, 0x32, 0x65, 0x62, 0x35, 0x34, 0x39, 0x30, 0x39, 0x35, 0x63, 0x63, 0x35, 0x65, 0x39, 0x64, 0x38, 0x31, 0x66, 0x30, 0x63, 0x65, 0x38, 0x33, 0x33, 0x66, 0x33, 0x31, 0x31, 0x32, 0x63, 0x64, 0x65, 0x30, 0x33, 0x31, 0x32, 0x35, 0x66, 0x36, 0x35, 0x36, 0x30, 0x33, 0x33, 0x62, 0x39, 0x66, 0x65, 0x33, 0x36, 0x62, 0x35, 0x33, 0x35, 0x39, 0x37, 0x39, 0x32, 0x62, 0x39, 0x62, 0x63, 0x36, 0x65, 0x66, 0x63, 0x36, 0x61, 0x64, 0x32, 0x35, 0x66, 0x30, 0x30, 0x30, 0x37, 0x64, 0x65, 0x34, 0x61, 0x36, 0x30, 0x37, 0x32, 0x34, 0x30, 0x37, 0x62, 0x66, 0x65, 0x65, 0x62, 0x31, 0x64, 0x65, 0x61, 0x39, 0x32, 0x32, 0x36, 0x33, 0x35, 0x61, 0x39, 0x33, 0x36, 0x35, 0x62, 0x32, 0x36, 0x33, 0x62, 0x63, 0x31, 0x38, 0x63, 0x35, 0x33, 0x32, 0x61, 0x34, 0x33, 0x32, 0x34, 0x33, 0x38, 0x65, 0x33, 0x33, 0x65, 0x37, 0x31, 0x30, 0x39, 0x33, 0x32, 0x33, 0x33, 0x38, 0x64, 0x34, 0x38, 0x37, 0x36, 0x36, 0x35, 0x30, 0x32, 0x64, 0x33, 0x37, 0x65, 0x39, 0x36, 0x39, 0x34, 0x32, 0x32, 0x63, 0x62, 0x39, 0x37, 0x32, 0x33, 0x61, 0x63, 0x31, 0x34, 0x37, 0x66, 0x32, 0x61, 0x66, 0x34, 0x62, 0x64, 0x62, 0x66, 0x62, 0x32, 0x63, 0x61, 0x39, 0x64, 0x65, 0x30, 0x30, 0x30, 0x66, 0x64, 0x63, 0x64, 0x34, 0x63, 0x34, 0x37, 0x38, 0x62, 0x37, 0x35, 0x36, 0x61, 0x39, 0x36, 0x36, 0x36, 0x39, 0x65, 0x61, 0x30, 0x63, 0x36, 0x65, 0x30, 0x38, 0x36, 0x39, 0x61, 0x32, 0x38, 0x64, 0x66, 0x64, 0x36, 0x36, 0x36, 0x36, 0x66, 0x34, 0x36, 0x37, 0x31, 0x65, 0x31, 0x36, 0x63, 0x61, 0x37, 0x31, 0x32, 0x37, 0x65, 0x33, 0x34, 0x36, 0x65, 0x32, 0x33, 0x35, 0x34, 0x30, 0x35, 0x63, 0x37, 0x66, 0x33, 0x33, 0x39, 0x32, 0x63, 0x36, 0x65, 0x62, 0x65, 0x34, 0x32, 0x38, 0x66, 0x62, 0x62, 0x61, 0x63, 0x31, 0x64, 0x64, 0x35, 0x35, 0x64, 0x35, 0x36, 0x32, 0x65, 0x62, 0x66, 0x61, 0x64, 0x33, 0x31, 0x62, 0x37, 0x32, 0x32, 0x66, 0x62, 0x64, 0x62, 0x65, 0x31, 0x35, 0x37, 0x39, 0x30, 0x65, 0x34, 0x31, 0x35, 0x63, 0x66, 0x39, 0x64, 0x64, 0x65, 0x66, 0x35, 0x31, 0x35, 0x62, 0x33, 0x65, 0x30, 0x35, 0x62, 0x66, 0x64, 0x61, 0x63, 0x64, 0x31, 0x32, 0x31, 0x62, 0x30, 0x37, 0x31, 0x35, 0x39, 0x34, 0x35, 0x38, 0x61, 0x31, 0x31, 0x35, 0x62, 0x33, 0x34, 0x32, 0x39, 0x62, 0x35, 0x39, 0x37, 0x35, 0x37, 0x32, 0x33, 0x38, 0x38, 0x64, 0x39, 0x30, 0x33, 0x36, 0x39, 0x39, 0x31, 0x36, 0x36, 0x35, 0x31, 0x64, 0x61, 0x35, 0x39, 0x30, 0x66, 0x61, 0x32, 0x33, 0x31, 0x62, 0x32, 0x36, 0x63, 0x31, 0x64, 0x62, 0x31, 0x63, 0x62, 0x37, 0x34, 0x35, 0x36, 0x64, 0x63, 0x32, 0x61, 0x39, 0x39, 0x66, 0x63, 0x36, 0x64, 0x31, 0x63, 0x31, 0x33, 0x39, 0x66, 0x61, 0x62, 0x62, 0x34, 0x64, 0x64, 0x37, 0x37, 0x32, 0x32, 0x62, 0x37, 0x30, 0x38, 0x66, 0x34, 0x65, 0x31, 0x34, 0x31, 0x33, 0x64, 0x31, 0x34, 0x65, 0x30, 0x33, 0x36, 0x37, 0x37, 0x34, 0x37, 0x35, 0x35, 0x32, 0x36, 0x35, 0x64, 0x31, 0x36, 0x37, 0x62, 0x34, 0x62, 0x37, 0x38, 0x30, 0x36, 0x63, 0x30, 0x36, 0x31, 0x38, 0x33, 0x39, 0x30, 0x62, 0x35, 0x63, 0x32, 0x36, 0x64, 0x31, 0x30, 0x31, 0x63, 0x63, 0x63, 0x30, 0x38, 0x61, 0x37, 0x32, 0x39, 0x31, 0x34, 0x37, 0x35, 0x39, 0x37, 0x63, 0x39, 0x63, 0x38, 0x65, 0x66, 0x35, 0x38, 0x62, 0x32, 0x62, 0x65, 0x65, 0x64, 0x39, 0x62, 0x30, 0x31, 0x30, 0x33, 0x39, 0x38, 0x37, 0x31, 0x31, 0x33, 0x33, 0x64, 0x62, 0x64, 0x61, 0x66, 0x31, 0x63, 0x66, 0x39, 0x31, 0x36, 0x36, 0x33, 0x37, 0x32, 0x30, 0x33, 0x33, 0x61, 0x31, 0x63, 0x61, 0x33, 0x35, 0x66, 0x66, 0x33, 0x61, 0x33, 0x64, 0x39, 0x35, 0x30, 0x66, 0x34, 0x33, 0x64, 0x34, 0x62, 0x62, 0x39, 0x66, 0x65, 0x33, 0x61, 0x33, 0x35, 0x34, 0x32, 0x34, 0x36, 0x66, 0x39, 0x31, 0x61, 0x35, 0x31, 0x64, 0x38, 0x36, 0x62, 0x38, 0x39, 0x30, 0x66, 0x61, 0x32, 0x39, 0x65, 0x61, 0x38, 0x30, 0x37, 0x34, 0x66, 0x66, 0x33, 0x62, 0x63, 0x63, 0x65, 0x35, 0x66, 0x30, 0x64, 0x34, 0x38, 0x31, 0x66, 0x64, 0x34, 0x61, 0x37, 0x32, 0x33, 0x63, 0x34, 0x36, 0x33, 0x34, 0x38, 0x65, 0x33, 0x39, 0x34, 0x38, 0x61, 0x35, 0x66, 0x35, 0x36, 0x35, 0x30, 0x64, 0x37, 0x34, 0x63, 0x61, 0x36, 0x36, 0x64, 0x63, 0x61, 0x32, 0x65, 0x37, 0x31, 0x62, 0x33, 0x32, 0x63, 0x61, 0x61, 0x37, 0x33, 0x63, 0x32, 0x62, 0x35, 0x33, 0x61, 0x64, 0x39, 0x64, 0x35, 0x30, 0x62, 0x37, 0x33, 0x30, 0x35, 0x34, 0x62, 0x31, 0x66, 0x39, 0x37, 0x32, 0x30, 0x31, 0x61, 0x65, 0x61, 0x38, 0x37, 0x37, 0x64, 0x31, 0x31, 0x63, 0x65, 0x39, 0x31, 0x66, 0x35, 0x37, 0x61, 0x36, 0x37, 0x35, 0x66, 0x32, 0x35, 0x36, 0x33, 0x37, 0x33, 0x30, 0x38, 0x32, 0x66, 0x61, 0x31, 0x66, 0x35, 0x61, 0x61, 0x32, 0x36, 0x62, 0x62, 0x61, 0x31, 0x35, 0x35, 0x62, 0x65, 0x39, 0x64, 0x62, 0x63, 0x32, 0x35, 0x38, 0x37, 0x62, 0x31, 0x62, 0x31, 0x33, 0x32, 0x33, 0x31, 0x63, 0x65, 0x39, 0x37, 0x31, 0x36, 0x61, 0x61, 0x61, 0x32, 0x39, 0x30, 0x34, 0x64, 0x63, 0x61, 0x32, 0x38, 0x37, 0x34, 0x32, 0x38, 0x33, 0x34, 0x63, 0x61, 0x65, 0x33, 0x34, 0x32, 0x61, 0x33, 0x34, 0x37, 0x38, 0x33, 0x61, 0x30, 0x34, 0x35, 0x39, 0x34, 0x30, 0x31, 0x38, 0x35, 0x32, 0x39, 0x32, 0x63, 0x64, 0x30, 0x30, 0x35, 0x65, 0x32, 0x62, 0x66, 0x36, 0x61, 0x36, 0x37, 0x32, 0x31, 0x63, 0x32, 0x65, 0x30, 0x63, 0x31, 0x31, 0x39, 0x34, 0x64, 0x63, 0x64, 0x30, 0x63, 0x33, 0x30, 0x35, 0x66, 0x38, 0x39, 0x66, 0x38, 0x33, 0x34, 0x63, 0x30, 0x37, 0x66, 0x36, 0x66, 0x65, 0x33, 0x30, 0x62, 0x31, 0x34, 0x36, 0x30, 0x66, 0x65, 0x38, 0x31, 0x64, 0x36, 0x35, 0x34, 0x31, 0x31, 0x31, 0x65, 0x62, 0x61, 0x66, 0x39, 0x34, 0x34, 0x36, 0x63, 0x66, 0x30, 0x31, 0x36, 0x30, 0x39, 0x30, 0x33, 0x30, 0x31, 0x33, 0x66, 0x30, 0x36, 0x61, 0x63, 0x32, 0x33, 0x39, 0x65, 0x61, 0x36, 0x65, 0x64, 0x30, 0x64, 0x30, 0x65, 0x31, 0x35, 0x61, 0x63, 0x30, 0x65, 0x37, 0x61, 0x36, 0x62, 0x38, 0x63, 0x38, 0x31, 0x33, 0x34, 0x35, 0x61, 0x32, 0x38, 0x62, 0x65, 0x64, 0x32, 0x31, 0x36, 0x66, 0x33, 0x39, 0x61, 0x61, 0x61, 0x64, 0x65, 0x33, 0x38, 0x32, 0x65, 0x32, 0x37, 0x32, 0x65, 0x63, 0x37, 0x32, 0x64, 0x30, 0x36, 0x33, 0x35, 0x66, 0x61, 0x62, 0x32, 0x35, 0x65, 0x31, 0x34, 0x33, 0x31, 0x61, 0x39, 0x33, 0x33, 0x64, 0x37, 0x37, 0x66, 0x33, 0x63, 0x66, 0x35, 0x32, 0x34, 0x31, 0x39, 0x64, 0x61, 0x30, 0x35, 0x37, 0x32, 0x61, 0x64, 0x35, 0x64, 0x38, 0x64, 0x63, 0x63, 0x32, 0x65, 0x66, 0x62, 0x62, 0x33, 0x61, 0x31, 0x61, 0x32, 0x65, 0x36, 0x63, 0x37, 0x32, 0x38, 0x30, 0x30, 0x64, 0x38, 0x33, 0x34, 0x64, 0x31, 0x31, 0x36, 0x33, 0x30, 0x66, 0x30, 0x37, 0x37, 0x38, 0x62, 0x62, 0x65, 0x65, 0x37, 0x65, 0x35, 0x39, 0x31, 0x62, 0x34, 0x34, 0x37, 0x39, 0x34, 0x33, 0x33, 0x66, 0x62, 0x39, 0x66, 0x38, 0x32, 0x30, 0x66, 0x35, 0x36, 0x39, 0x62, 0x30, 0x62, 0x36, 0x36, 0x65, 0x34, 0x66, 0x38, 0x39, 0x35, 0x64, 0x37, 0x64, 0x63, 0x36, 0x34, 0x63, 0x64, 0x39, 0x31, 0x31, 0x33, 0x64, 0x63, 0x30, 0x37, 0x63, 0x64, 0x37, 0x33, 0x30, 0x39, 0x62, 0x39, 0x38, 0x61, 0x63, 0x66, 0x65, 0x64, 0x39, 0x61, 0x39, 0x65, 0x36, 0x36, 0x37, 0x37, 0x38, 0x66, 0x30, 0x34, 0x31, 0x63, 0x35, 0x64, 0x65, 0x62, 0x66, 0x64, 0x61, 0x66, 0x31, 0x34, 0x31, 0x33, 0x34, 0x65, 0x34, 0x30, 0x62, 0x39, 0x30, 0x34, 0x62, 0x61, 0x63, 0x65, 0x30, 0x30, 0x39, 0x35, 0x62, 0x35, 0x34, 0x65, 0x65, 0x30, 0x31, 0x38, 0x36, 0x39, 0x33, 0x34, 0x36, 0x39, 0x36, 0x66, 0x30, 0x39, 0x33, 0x36, 0x63, 0x31, 0x62, 0x32, 0x30, 0x64, 0x31, 0x38, 0x30, 0x38, 0x64, 0x39, 0x36, 0x31, 0x65, 0x31, 0x37, 0x61, 0x61, 0x65, 0x61, 0x65, 0x34, 0x64, 0x39, 0x37, 0x39, 0x32, 0x65, 0x33, 0x65, 0x36, 0x34, 0x30, 0x61, 0x33, 0x36, 0x36, 0x30, 0x62, 0x37, 0x30, 0x31, 0x35, 0x33, 0x33, 0x33, 0x30, 0x36, 0x63, 0x65, 0x37, 0x63, 0x62, 0x36, 0x65, 0x32, 0x34, 0x64, 0x37, 0x37, 0x37, 0x31, 0x30, 0x31, 0x38, 0x36, 0x34, 0x33, 0x30, 0x31, 0x33, 0x38, 0x64, 0x32, 0x66, 0x62, 0x36, 0x63, 0x37, 0x32, 0x31, 0x62, 0x63, 0x63, 0x62, 0x34, 0x64, 0x32, 0x66, 0x35, 0x36, 0x34, 0x33, 0x37, 0x34, 0x34, 0x64, 0x34, 0x62, 0x34, 0x34, 0x36, 0x35, 0x62, 0x37, 0x32, 0x63, 0x66, 0x38, 0x61, 0x63, 0x35, 0x33, 0x63, 0x61, 0x37, 0x33, 0x31, 0x31, 0x33, 0x63, 0x61, 0x32, 0x35, 0x31, 0x64, 0x36, 0x30, 0x33, 0x37, 0x35, 0x65, 0x63, 0x34, 0x30, 0x35, 0x33, 0x36, 0x31, 0x64, 0x61, 0x66, 0x38, 0x30, 0x31, 0x33, 0x39, 0x39, 0x65, 0x31, 0x37, 0x35, 0x30, 0x62, 0x33, 0x61, 0x62, 0x30, 0x38, 0x34, 0x35, 0x32, 0x35, 0x36, 0x66, 0x35, 0x64, 0x38, 0x37, 0x32, 0x37, 0x32, 0x62, 0x38, 0x31, 0x36, 0x31, 0x34, 0x65, 0x62, 0x34, 0x34, 0x30, 0x31, 0x61, 0x61, 0x36, 0x34, 0x38, 0x33, 0x37, 0x61, 0x36, 0x30, 0x37, 0x62, 0x65, 0x34, 0x65, 0x32, 0x37, 0x31, 0x37, 0x65, 0x39, 0x64, 0x63, 0x65, 0x38, 0x62, 0x31, 0x62, 0x36, 0x37, 0x34, 0x61, 0x39, 0x31, 0x65, 0x37, 0x39, 0x39, 0x34, 0x38, 0x64, 0x32, 0x63, 0x34, 0x65, 0x39, 0x36, 0x30, 0x31, 0x64, 0x36, 0x66, 0x34, 0x66, 0x66, 0x38, 0x37, 0x30, 0x33, 0x30, 0x65, 0x61, 0x62, 0x37, 0x39, 0x64, 0x36, 0x35, 0x65, 0x64, 0x37, 0x31, 0x30, 0x64, 0x37, 0x66, 0x38, 0x31, 0x64, 0x66, 0x37, 0x61, 0x63, 0x34, 0x35, 0x37, 0x37, 0x30, 0x65, 0x37, 0x61, 0x31, 0x65, 0x39, 0x64, 0x37, 0x37, 0x64, 0x61, 0x32, 0x38, 0x33, 0x38, 0x39, 0x36, 0x61, 0x33, 0x62, 0x61, 0x39, 0x61, 0x33, 0x37, 0x32, 0x61, 0x35, 0x31, 0x38, 0x61, 0x31, 0x61, 0x30, 0x62, 0x62, 0x64, 0x62, 0x66, 0x33, 0x34, 0x34, 0x32, 0x34, 0x37, 0x31, 0x33, 0x62, 0x37, 0x35, 0x35, 0x34, 0x66, 0x32, 0x39, 0x35, 0x39, 0x64, 0x32, 0x39, 0x33, 0x34, 0x34, 0x62, 0x32, 0x62, 0x36, 0x65, 0x37, 0x30, 0x64, 0x34, 0x37, 0x36, 0x66, 0x66, 0x66, 0x66, 0x33, 0x32, 0x30, 0x35, 0x66, 0x34, 0x63, 0x66, 0x34, 0x64, 0x37, 0x32, 0x37, 0x64, 0x61, 0x36, 0x30, 0x39, 0x66, 0x64, 0x33, 0x35, 0x30, 0x36, 0x31, 0x34, 0x30, 0x63, 0x63, 0x36, 0x36, 0x64, 0x36, 0x39, 0x35, 0x37, 0x33, 0x33, 0x38, 0x36, 0x33, 0x64, 0x37, 0x35, 0x61, 0x32, 0x62, 0x31, 0x65, 0x33, 0x38, 0x37, 0x66, 0x31, 0x62, 0x63, 0x33, 0x66, 0x64, 0x65, 0x33, 0x64, 0x39, 0x37, 0x38, 0x31, 0x66, 0x32, 0x35, 0x36, 0x32, 0x61, 0x65, 0x61, 0x35, 0x64, 0x32, 0x36, 0x34, 0x39, 0x34, 0x39, 0x39, 0x61, 0x37, 0x63, 0x38, 0x32, 0x33, 0x33, 0x66, 0x31, 0x31, 0x62, 0x31, 0x30, 0x32, 0x61, 0x36, 0x34, 0x63, 0x66, 0x39, 0x64, 0x32, 0x38, 0x62, 0x38, 0x31, 0x36, 0x37, 0x38, 0x39, 0x33, 0x63, 0x61, 0x63, 0x35, 0x38, 0x31, 0x62, 0x66, 0x31, 0x61, 0x62, 0x38, 0x61, 0x30, 0x32, 0x64, 0x64, 0x30, 0x34, 0x33, 0x35, 0x61, 0x33, 0x36, 0x37, 0x32, 0x36, 0x31, 0x33, 0x31, 0x66, 0x65, 0x35, 0x30, 0x61, 0x39, 0x37, 0x61, 0x34, 0x34, 0x64, 0x35, 0x37, 0x64, 0x33, 0x65, 0x65, 0x34, 0x63, 0x33, 0x39, 0x33, 0x34, 0x62, 0x32, 0x61, 0x38, 0x61, 0x65, 0x66, 0x30, 0x66, 0x66, 0x64, 0x62, 0x66, 0x65, 0x39, 0x35, 0x34, 0x38, 0x64, 0x37, 0x34, 0x38, 0x62, 0x36, 0x32, 0x37, 0x37, 0x33, 0x34, 0x32, 0x38, 0x62, 0x63, 0x65, 0x63, 0x37, 0x32, 0x33, 0x37, 0x35, 0x30, 0x38, 0x61, 0x38, 0x33, 0x64, 0x63, 0x64, 0x39, 0x61, 0x31, 0x62, 0x37, 0x62, 0x63, 0x62, 0x32, 0x65, 0x65, 0x35, 0x31, 0x32, 0x64, 0x62, 0x31, 0x32, 0x32, 0x38, 0x64, 0x38, 0x65, 0x66, 0x35, 0x34, 0x63, 0x36, 0x30, 0x63, 0x30, 0x32, 0x38, 0x31, 0x63, 0x35, 0x38, 0x31, 0x34, 0x33, 0x32, 0x31, 0x63, 0x36, 0x34, 0x35, 0x32, 0x35, 0x36, 0x38, 0x31, 0x35, 0x62, 0x34, 0x38, 0x66, 0x64, 0x62, 0x65, 0x31, 0x36, 0x37, 0x35, 0x66, 0x66, 0x64, 0x35, 0x62, 0x62, 0x65, 0x66, 0x34, 0x32, 0x36, 0x66, 0x31, 0x34, 0x64, 0x61, 0x63, 0x36, 0x34, 0x39, 0x30, 0x61, 0x61, 0x31, 0x34, 0x33, 0x37, 0x39, 0x62, 0x62, 0x66, 0x61, 0x35, 0x38, 0x34, 0x34, 0x36, 0x30, 0x38, 0x36, 0x61, 0x64, 0x33, 0x61, 0x36, 0x38, 0x65, 0x30, 0x33, 0x61, 0x34, 0x34, 0x37, 0x32, 0x66, 0x61, 0x32, 0x31, 0x35, 0x33, 0x63, 0x61, 0x35, 0x63, 0x38, 0x38, 0x61, 0x33, 0x33, 0x32, 0x63, 0x62, 0x34, 0x35, 0x30, 0x35, 0x35, 0x34, 0x36, 0x62, 0x61, 0x64, 0x35, 0x61, 0x31, 0x66, 0x34, 0x62, 0x33, 0x63, 0x35, 0x36, 0x31, 0x66, 0x34, 0x33, 0x38, 0x62, 0x35, 0x66, 0x36, 0x62, 0x33, 0x35, 0x63, 0x32, 0x31, 0x34, 0x62, 0x66, 0x39, 0x35, 0x33, 0x35, 0x64, 0x32, 0x36, 0x65, 0x62, 0x34, 0x65, 0x64, 0x66, 0x30, 0x38, 0x66, 0x34, 0x35, 0x33, 0x38, 0x38, 0x66, 0x39, 0x66, 0x34, 0x32, 0x66, 0x62, 0x35, 0x30, 0x66, 0x39, 0x62, 0x39, 0x35, 0x66, 0x30, 0x38, 0x39, 0x63, 0x35, 0x35, 0x63, 0x33, 0x33, 0x64, 0x61, 0x65, 0x38, 0x65, 0x36, 0x38, 0x32, 0x65, 0x65, 0x63, 0x34, 0x36, 0x35, 0x30, 0x31, 0x38, 0x37, 0x61, 0x64, 0x38, 0x39, 0x36, 0x64, 0x36, 0x37, 0x32, 0x38, 0x65, 0x64, 0x61, 0x66, 0x61, 0x39, 0x63, 0x38, 0x36, 0x61, 0x64, 0x39, 0x62, 0x66, 0x64, 0x64, 0x38, 0x33, 0x31, 0x34, 0x35, 0x33, 0x34, 0x32, 0x35, 0x30, 0x64, 0x38, 0x34, 0x39, 0x32, 0x63, 0x61, 0x65, 0x33, 0x34, 0x31, 0x62, 0x32, 0x64, 0x34, 0x61, 0x33, 0x32, 0x61, 0x35, 0x62, 0x38, 0x63, 0x30, 0x35, 0x33, 0x38, 0x39, 0x32, 0x64, 0x63, 0x35, 0x31, 0x30, 0x61, 0x31, 0x33, 0x36, 0x38, 0x61, 0x65, 0x32, 0x65, 0x64, 0x39, 0x38, 0x35, 0x66, 0x65, 0x30, 0x61, 0x35, 0x33, 0x32, 0x36, 0x35, 0x32, 0x63, 0x62, 0x63, 0x30, 0x31, 0x39, 0x32, 0x35, 0x34, 0x35, 0x63, 0x61, 0x65, 0x36, 0x31, 0x34, 0x30, 0x38, 0x33, 0x39, 0x62, 0x31, 0x66, 0x37, 0x66, 0x66, 0x33, 0x33, 0x38, 0x39, 0x38, 0x65, 0x30, 0x32, 0x35, 0x38, 0x34, 0x37, 0x62, 0x34, 0x65, 0x61, 0x31, 0x37, 0x66, 0x36, 0x63, 0x33, 0x37, 0x32, 0x64, 0x32, 0x39, 0x32, 0x66, 0x65, 0x63, 0x61, 0x65, 0x64, 0x31, 0x34, 0x61, 0x33, 0x62, 0x35, 0x64, 0x39, 0x64, 0x62, 0x34, 0x38, 0x64, 0x30, 0x35, 0x31, 0x65, 0x38, 0x31, 0x64, 0x38, 0x62, 0x34, 0x36, 0x39, 0x35, 0x33, 0x35, 0x66, 0x31, 0x34, 0x62, 0x63, 0x36, 0x64, 0x36, 0x63, 0x66, 0x66, 0x32, 0x34, 0x31, 0x35, 0x62, 0x36, 0x30, 0x37, 0x32, 0x32, 0x32, 0x66, 0x63, 0x66, 0x32, 0x32, 0x66, 0x31, 0x39, 0x30, 0x66, 0x32, 0x33, 0x36, 0x63, 0x62, 0x61, 0x33, 0x64, 0x31, 0x38, 0x38, 0x66, 0x62, 0x30, 0x65, 0x63, 0x61, 0x63, 0x65, 0x32, 0x63, 0x34, 0x63, 0x39, 0x65, 0x35, 0x35, 0x31, 0x64, 0x36, 0x36, 0x61, 0x38, 0x31, 0x37, 0x31, 0x32, 0x36, 0x65, 0x64, 0x64, 0x63, 0x66, 0x64, 0x65, 0x64, 0x37, 0x65, 0x39, 0x37, 0x32, 0x36, 0x39, 0x66, 0x31, 0x37, 0x36, 0x61, 0x37, 0x65, 0x39, 0x31, 0x65, 0x64, 0x61, 0x61, 0x65, 0x34, 0x62, 0x39, 0x30, 0x34, 0x66, 0x64, 0x36, 0x32, 0x33, 0x38, 0x39, 0x33, 0x37, 0x61, 0x33, 0x62, 0x37, 0x37, 0x39, 0x32, 0x63, 0x36, 0x38, 0x36, 0x34, 0x64, 0x66, 0x37, 0x34, 0x63, 0x66, 0x31, 0x32, 0x63, 0x35, 0x39, 0x30, 0x33, 0x38, 0x62, 0x65, 0x30, 0x61, 0x31, 0x63, 0x37, 0x36, 0x64, 0x37, 0x63, 0x64, 0x62, 0x63, 0x38, 0x31, 0x38, 0x63, 0x34, 0x61, 0x65, 0x39, 0x65, 0x63, 0x64, 0x64, 0x30, 0x35, 0x65, 0x30, 0x33, 0x35, 0x31, 0x62, 0x36, 0x35, 0x38, 0x36, 0x35, 0x63, 0x34, 0x30, 0x31, 0x33, 0x36, 0x37, 0x65, 0x65, 0x63, 0x66, 0x38, 0x62, 0x39, 0x38, 0x30, 0x34, 0x36, 0x37, 0x37, 0x61, 0x36, 0x61, 0x33, 0x35, 0x33, 0x36, 0x66, 0x66, 0x34, 0x33, 0x66, 0x36, 0x38, 0x34, 0x61, 0x61, 0x38, 0x32, 0x39, 0x35, 0x39, 0x32, 0x38, 0x35, 0x31, 0x33, 0x37, 0x31, 0x63, 0x62, 0x63, 0x63, 0x64, 0x31, 0x65, 0x64, 0x31, 0x39, 0x66, 0x37, 0x36, 0x31, 0x37, 0x65, 0x66, 0x33, 0x61, 0x61, 0x62, 0x38, 0x39, 0x37, 0x33, 0x39, 0x65, 0x34, 0x62, 0x38, 0x33, 0x61, 0x33, 0x65, 0x31, 0x36, 0x61, 0x61, 0x32, 0x66, 0x38, 0x36, 0x30, 0x35, 0x65, 0x32, 0x61, 0x31, 0x39, 0x66, 0x33, 0x33, 0x65, 0x31, 0x61, 0x61, 0x36, 0x34, 0x62, 0x38, 0x62, 0x33, 0x33, 0x61, 0x37, 0x61, 0x39, 0x38, 0x39, 0x65, 0x66, 0x62, 0x33, 0x31, 0x63, 0x36, 0x64, 0x31, 0x37, 0x31, 0x63, 0x31, 0x61, 0x32, 0x62, 0x66, 0x37, 0x33, 0x34, 0x36, 0x37, 0x31, 0x64, 0x64, 0x30, 0x36, 0x66, 0x61, 0x38, 0x30, 0x65, 0x36, 0x62, 0x62, 0x62, 0x32, 0x61, 0x31, 0x34, 0x64, 0x63, 0x36, 0x34, 0x64, 0x63, 0x35, 0x36, 0x30, 0x37, 0x61, 0x35, 0x30, 0x36, 0x62, 0x37, 0x39, 0x30, 0x39, 0x34, 0x65, 0x66, 0x34, 0x38, 0x39, 0x33, 0x32, 0x64, 0x61, 0x33, 0x66, 0x66, 0x35, 0x33, 0x65, 0x62, 0x37, 0x64, 0x35, 0x33, 0x36, 0x62, 0x32, 0x36, 0x62, 0x61, 0x38, 0x38, 0x64, 0x30, 0x39, 0x37, 0x31, 0x31, 0x38, 0x34, 0x38, 0x33, 0x66, 0x35, 0x30, 0x34, 0x32, 0x37, 0x38, 0x61, 0x37, 0x32, 0x32, 0x66, 0x35, 0x66, 0x32, 0x63, 0x33, 0x38, 0x31, 0x32, 0x63, 0x32, 0x62, 0x32, 0x38, 0x66, 0x31, 0x39, 0x37, 0x35, 0x36, 0x63, 0x65, 0x30, 0x32, 0x65, 0x64, 0x35, 0x36, 0x39, 0x36, 0x35, 0x32, 0x37, 0x30, 0x66, 0x39, 0x62, 0x35, 0x35, 0x63, 0x35, 0x38, 0x62, 0x62, 0x30, 0x30, 0x33, 0x62, 0x35, 0x63, 0x36, 0x63, 0x61, 0x61, 0x35, 0x65, 0x34, 0x31, 0x34, 0x62, 0x31, 0x37, 0x32, 0x33, 0x62, 0x63, 0x64, 0x30, 0x66, 0x35, 0x36, 0x31, 0x36, 0x32, 0x36, 0x39, 0x62, 0x31, 0x61, 0x38, 0x65, 0x38, 0x37, 0x32, 0x32, 0x65, 0x63, 0x62, 0x33, 0x33, 0x31, 0x66, 0x31, 0x38, 0x30, 0x62, 0x38, 0x64, 0x62, 0x65, 0x33, 0x38, 0x62, 0x33, 0x38, 0x36, 0x66, 0x32, 0x61, 0x65, 0x65, 0x39, 0x32, 0x62, 0x63, 0x34, 0x63, 0x32, 0x35, 0x36, 0x38, 0x33, 0x38, 0x31, 0x35, 0x37, 0x32, 0x62, 0x38, 0x35, 0x34, 0x36, 0x37, 0x30, 0x32, 0x66, 0x30, 0x63, 0x66, 0x65, 0x37, 0x64, 0x35, 0x34, 0x63, 0x39, 0x32, 0x63, 0x34, 0x66, 0x61, 0x36, 0x37, 0x36, 0x35, 0x61, 0x33, 0x31, 0x38, 0x36, 0x65, 0x61, 0x33, 0x66, 0x39, 0x35, 0x31, 0x65, 0x61, 0x35, 0x65, 0x35, 0x31, 0x38, 0x30, 0x38, 0x38, 0x37, 0x34, 0x31, 0x38, 0x35, 0x62, 0x35, 0x37, 0x36, 0x64, 0x37, 0x31, 0x32, 0x32, 0x32, 0x33, 0x30, 0x37, 0x37, 0x34, 0x66, 0x34, 0x35, 0x62, 0x31, 0x32, 0x61, 0x63, 0x30, 0x61, 0x37, 0x36, 0x36, 0x30, 0x64, 0x37, 0x38, 0x32, 0x38, 0x30, 0x35, 0x62, 0x63, 0x65, 0x63, 0x31, 0x62, 0x38, 0x63, 0x38, 0x61, 0x31, 0x65, 0x65, 0x38, 0x38, 0x35, 0x38, 0x63, 0x64, 0x36, 0x35, 0x65, 0x63, 0x36, 0x31, 0x62, 0x61, 0x62, 0x63, 0x63, 0x65, 0x36, 0x32, 0x37, 0x61, 0x31, 0x34, 0x62, 0x30, 0x33, 0x61, 0x61, 0x39, 0x35, 0x38, 0x64, 0x64, 0x62, 0x32, 0x39, 0x61, 0x66, 0x37, 0x35, 0x32, 0x35, 0x31, 0x30, 0x65, 0x66, 0x36, 0x31, 0x34, 0x36, 0x65, 0x36, 0x65, 0x33, 0x39, 0x33, 0x64, 0x34, 0x64, 0x36, 0x62, 0x62, 0x38, 0x66, 0x38, 0x63, 0x61, 0x66, 0x65, 0x31, 0x30, 0x34, 0x64, 0x33, 0x39, 0x66, 0x34, 0x64, 0x65, 0x35, 0x65, 0x33, 0x38, 0x31, 0x36, 0x37, 0x32, 0x39, 0x61, 0x31, 0x33, 0x37, 0x64, 0x38, 0x31, 0x66, 0x64, 0x34, 0x31, 0x38, 0x35, 0x66, 0x62, 0x64, 0x30, 0x35, 0x62, 0x36, 0x33, 0x64, 0x35, 0x62, 0x65, 0x64, 0x31, 0x31, 0x36, 0x35, 0x31, 0x32, 0x38, 0x31, 0x37, 0x64, 0x63, 0x31, 0x63, 0x66, 0x38, 0x64, 0x38, 0x66, 0x61, 0x64, 0x30, 0x37, 0x33, 0x37, 0x38, 0x61, 0x35, 0x63, 0x36, 0x37, 0x33, 0x33, 0x64, 0x62, 0x63, 0x37, 0x32, 0x37, 0x62, 0x36, 0x34, 0x38, 0x66, 0x66, 0x32, 0x32, 0x32, 0x30, 0x38, 0x30, 0x64, 0x36, 0x30, 0x64, 0x34, 0x32, 0x66, 0x66, 0x65, 0x64, 0x65, 0x35, 0x36, 0x65, 0x62, 0x64, 0x39, 0x33, 0x64, 0x35, 0x34, 0x34, 0x32, 0x30, 0x65, 0x32, 0x35, 0x32, 0x33, 0x62, 0x66, 0x64, 0x62, 0x62, 0x37, 0x36, 0x34, 0x63, 0x31, 0x37, 0x66, 0x36, 0x65, 0x64, 0x64, 0x33, 0x30, 0x38, 0x63, 0x37, 0x32, 0x62, 0x65, 0x32, 0x64, 0x35, 0x31, 0x65, 0x36, 0x31, 0x66, 0x63, 0x34, 0x62, 0x32, 0x63, 0x36, 0x30, 0x66, 0x37, 0x38, 0x33, 0x35, 0x32, 0x66, 0x35, 0x39, 0x66, 0x34, 0x66, 0x30, 0x64, 0x30, 0x36, 0x30, 0x65, 0x63, 0x66, 0x38, 0x64, 0x32, 0x31, 0x62, 0x35, 0x65, 0x66, 0x33, 0x38, 0x65, 0x32, 0x31, 0x38, 0x32, 0x30, 0x34, 0x36, 0x33, 0x37, 0x31, 0x66, 0x33, 0x62, 0x63, 0x37, 0x32, 0x63, 0x39, 0x62, 0x35, 0x37, 0x34, 0x31, 0x37, 0x66, 0x39, 0x33, 0x35, 0x35, 0x37, 0x35, 0x30, 0x39, 0x30, 0x61, 0x61, 0x39, 0x34, 0x38, 0x36, 0x33, 0x31, 0x35, 0x33, 0x32, 0x36, 0x36, 0x65, 0x64, 0x32, 0x30, 0x36, 0x39, 0x65, 0x38, 0x63, 0x32, 0x61, 0x61, 0x38, 0x33, 0x37, 0x34, 0x63, 0x61, 0x39, 0x66, 0x34, 0x61, 0x35, 0x39, 0x32, 0x32, 0x63, 0x34, 0x66, 0x66, 0x38, 0x37, 0x32, 0x36, 0x30, 0x62, 0x39, 0x34, 0x32, 0x31, 0x61, 0x31, 0x61, 0x66, 0x63, 0x37, 0x65, 0x30, 0x30, 0x30, 0x31, 0x65, 0x37, 0x31, 0x64, 0x62, 0x32, 0x63, 0x62, 0x30, 0x32, 0x38, 0x63, 0x35, 0x37, 0x34, 0x35, 0x32, 0x37, 0x34, 0x31, 0x37, 0x32, 0x61, 0x31, 0x35, 0x63, 0x64, 0x36, 0x64, 0x30, 0x63, 0x62, 0x30, 0x30, 0x36, 0x32, 0x65, 0x64, 0x39, 0x33, 0x39, 0x36, 0x66, 0x32, 0x37, 0x32, 0x30, 0x36, 0x35, 0x39, 0x63, 0x30, 0x63, 0x36, 0x34, 0x30, 0x66, 0x63, 0x65, 0x34, 0x39, 0x66, 0x30, 0x63, 0x61, 0x34, 0x61, 0x30, 0x35, 0x65, 0x33, 0x32, 0x30, 0x36, 0x33, 0x36, 0x36, 0x34, 0x62, 0x37, 0x32, 0x37, 0x66, 0x34, 0x64, 0x38, 0x62, 0x37, 0x31, 0x35, 0x38, 0x30, 0x65, 0x64, 0x35, 0x35, 0x61, 0x64, 0x38, 0x37, 0x39, 0x62, 0x30, 0x37, 0x62, 0x30, 0x30, 0x35, 0x37, 0x32, 0x62, 0x66, 0x65, 0x39, 0x37, 0x30, 0x65, 0x30, 0x66, 0x63, 0x33, 0x33, 0x62, 0x39, 0x35, 0x37, 0x61, 0x31, 0x39, 0x33, 0x62, 0x38, 0x65, 0x31, 0x31, 0x66, 0x39, 0x62, 0x62, 0x35, 0x32, 0x32, 0x32, 0x33, 0x30, 0x62, 0x61, 0x38, 0x62, 0x62, 0x34, 0x30, 0x64, 0x34, 0x33, 0x66, 0x36, 0x35, 0x62, 0x38, 0x36, 0x32, 0x64, 0x32, 0x35, 0x37, 0x37, 0x34, 0x64, 0x37, 0x65, 0x34, 0x30, 0x39, 0x38, 0x34, 0x66, 0x66, 0x65, 0x36, 0x65, 0x39, 0x64, 0x64, 0x63, 0x61, 0x65, 0x32, 0x63, 0x32, 0x64, 0x38, 0x36, 0x31, 0x34, 0x33, 0x34, 0x61, 0x34, 0x35, 0x66, 0x38, 0x65, 0x30, 0x34, 0x35, 0x64, 0x31, 0x66, 0x62, 0x33, 0x63, 0x62, 0x64, 0x36, 0x34, 0x34, 0x34, 0x61, 0x61, 0x65, 0x64, 0x37, 0x63, 0x30, 0x63, 0x66, 0x32, 0x66, 0x33, 0x62, 0x35, 0x61, 0x63, 0x61, 0x65, 0x37, 0x32, 0x64, 0x30, 0x61, 0x32, 0x66, 0x32, 0x63, 0x30, 0x64, 0x61, 0x31, 0x64, 0x35, 0x37, 0x35, 0x30, 0x65, 0x34, 0x39, 0x35, 0x38, 0x36, 0x65, 0x32, 0x61, 0x61, 0x37, 0x31, 0x61, 0x39, 0x37, 0x33, 0x32, 0x39, 0x63, 0x39, 0x31, 0x63, 0x63, 0x31, 0x61, 0x31, 0x37, 0x65, 0x33, 0x39, 0x65, 0x34, 0x33, 0x30, 0x63, 0x65, 0x61, 0x30, 0x30, 0x35, 0x65, 0x37, 0x39, 0x34, 0x66, 0x35, 0x30, 0x37, 0x63, 0x39, 0x63, 0x61, 0x31, 0x38, 0x62, 0x35, 0x61, 0x64, 0x31, 0x66, 0x61, 0x34, 0x37, 0x33, 0x30, 0x35, 0x62, 0x64, 0x35, 0x31, 0x33, 0x65, 0x37, 0x64, 0x39, 0x62, 0x39, 0x62, 0x33, 0x30, 0x66, 0x38, 0x35, 0x65, 0x38, 0x34, 0x35, 0x33, 0x63, 0x36, 0x63, 0x35, 0x33, 0x30, 0x32, 0x39, 0x61, 0x62, 0x65, 0x36, 0x65, 0x65, 0x32, 0x35, 0x39, 0x66, 0x38, 0x35, 0x65, 0x64, 0x37, 0x32, 0x36, 0x62, 0x63, 0x63, 0x32, 0x30, 0x37, 0x66, 0x35, 0x61, 0x62, 0x62, 0x61, 0x36, 0x38, 0x37, 0x35, 0x34, 0x35, 0x37, 0x35, 0x65, 0x37, 0x34, 0x64, 0x39, 0x32, 0x61, 0x36, 0x37, 0x39, 0x62, 0x63, 0x36, 0x34, 0x61, 0x37, 0x33, 0x62, 0x36, 0x38, 0x38, 0x62, 0x33, 0x33, 0x61, 0x63, 0x64, 0x61, 0x39, 0x61, 0x65, 0x33, 0x39, 0x38, 0x34, 0x36, 0x36, 0x33, 0x35, 0x36, 0x64, 0x32, 0x39, 0x31, 0x61, 0x66, 0x36, 0x64, 0x35, 0x36, 0x35, 0x36, 0x64, 0x65, 0x64, 0x61, 0x62, 0x31, 0x33, 0x61, 0x31, 0x37, 0x66, 0x66, 0x66, 0x62, 0x32, 0x38, 0x39, 0x31, 0x61, 0x38, 0x66, 0x38, 0x37, 0x34, 0x61, 0x37, 0x34, 0x38, 0x35, 0x63, 0x30, 0x30, 0x63, 0x33, 0x35, 0x32, 0x37, 0x64, 0x66, 0x66, 0x32, 0x30, 0x63, 0x34, 0x61, 0x61, 0x62, 0x62, 0x37, 0x37, 0x65, 0x30, 0x34, 0x37, 0x32, 0x64, 0x39, 0x61, 0x36, 0x33, 0x66, 0x36, 0x31, 0x38, 0x39, 0x66, 0x36, 0x61, 0x36, 0x36, 0x37, 0x30, 0x30, 0x32, 0x39, 0x31, 0x37, 0x66, 0x33, 0x36, 0x64, 0x30, 0x31, 0x39, 0x32, 0x37, 0x65, 0x62, 0x66, 0x65, 0x39, 0x63, 0x64, 0x35, 0x37, 0x34, 0x34, 0x65, 0x61, 0x66, 0x39, 0x63, 0x62, 0x31, 0x38, 0x38, 0x61, 0x61, 0x31, 0x61, 0x31, 0x64, 0x39, 0x64, 0x39, 0x32, 0x35, 0x37, 0x32, 0x36, 0x66, 0x38, 0x65, 0x34, 0x63, 0x64, 0x38, 0x30, 0x33, 0x66, 0x34, 0x31, 0x30, 0x35, 0x36, 0x65, 0x37, 0x62, 0x35, 0x35, 0x39, 0x62, 0x66, 0x37, 0x63, 0x34, 0x37, 0x32, 0x61, 0x37, 0x64, 0x62, 0x34, 0x61, 0x66, 0x33, 0x34, 0x65, 0x35, 0x35, 0x38, 0x32, 0x31, 0x34, 0x35, 0x63, 0x32, 0x64, 0x62, 0x63, 0x31, 0x33, 0x66, 0x32, 0x62, 0x32, 0x35, 0x61, 0x31, 0x35, 0x35, 0x36, 0x62, 0x33, 0x61, 0x33, 0x33, 0x35, 0x62, 0x64, 0x65, 0x32, 0x61, 0x34, 0x66, 0x61, 0x32, 0x33, 0x38, 0x38, 0x61, 0x35, 0x36, 0x63, 0x31, 0x66, 0x39, 0x38, 0x34, 0x66, 0x38, 0x33, 0x33, 0x36, 0x34, 0x62, 0x65, 0x62, 0x64, 0x61, 0x38, 0x33, 0x35, 0x38, 0x34, 0x37, 0x35, 0x34, 0x36, 0x36, 0x30, 0x33, 0x64, 0x39, 0x64, 0x64, 0x38, 0x37, 0x64, 0x38, 0x63, 0x38, 0x64, 0x38, 0x36, 0x36, 0x37, 0x39, 0x61, 0x31, 0x64, 0x35, 0x30, 0x34, 0x35, 0x64, 0x65, 0x63, 0x32, 0x65, 0x36, 0x64, 0x34, 0x64, 0x38, 0x62, 0x39, 0x33, 0x33, 0x35, 0x39, 0x32, 0x62, 0x35, 0x63, 0x64, 0x33, 0x39, 0x37, 0x61, 0x37, 0x38, 0x36, 0x32, 0x31, 0x62, 0x34, 0x33, 0x31, 0x66, 0x65, 0x38, 0x31, 0x30, 0x35, 0x66, 0x34, 0x66, 0x61, 0x66, 0x64, 0x34, 0x35, 0x31, 0x39, 0x64, 0x31, 0x36, 0x38, 0x37, 0x32, 0x66, 0x66, 0x66, 0x35, 0x34, 0x39, 0x33, 0x35, 0x31, 0x62, 0x66, 0x62, 0x34, 0x38, 0x35, 0x34, 0x61, 0x35, 0x66, 0x39, 0x31, 0x63, 0x63, 0x38, 0x34, 0x64, 0x64, 0x38, 0x36, 0x30, 0x65, 0x65, 0x64, 0x32, 0x32, 0x36, 0x31, 0x35, 0x38, 0x33, 0x39, 0x35, 0x63, 0x38, 0x35, 0x63, 0x30, 0x64, 0x39, 0x36, 0x65, 0x63, 0x66, 0x36, 0x33, 0x31, 0x35, 0x38, 0x36, 0x62, 0x37, 0x65, 0x37, 0x32, 0x32, 0x38, 0x33, 0x32, 0x39, 0x61, 0x36, 0x34, 0x66, 0x66, 0x33, 0x64, 0x65, 0x64, 0x62, 0x33, 0x32, 0x61, 0x61, 0x39, 0x63, 0x37, 0x33, 0x63, 0x61, 0x31, 0x30, 0x66, 0x65, 0x35, 0x64, 0x30, 0x32, 0x39, 0x64, 0x65, 0x32, 0x34, 0x39, 0x31, 0x66, 0x61, 0x32, 0x32, 0x39, 0x33, 0x38, 0x62, 0x38, 0x39, 0x39, 0x66, 0x37, 0x34, 0x65, 0x33, 0x39, 0x30, 0x31, 0x63, 0x65, 0x38, 0x37, 0x32, 0x39, 0x39, 0x37, 0x30, 0x65, 0x65, 0x39, 0x65, 0x32, 0x64, 0x36, 0x33, 0x66, 0x61, 0x61, 0x62, 0x64, 0x38, 0x37, 0x36, 0x39, 0x33, 0x35, 0x63, 0x61, 0x61, 0x61, 0x63, 0x65, 0x36, 0x66, 0x62, 0x39, 0x35, 0x34, 0x63, 0x63, 0x37, 0x32, 0x66, 0x64, 0x36, 0x61, 0x30, 0x35, 0x37, 0x31, 0x35, 0x64, 0x30, 0x34, 0x63, 0x38, 0x32, 0x36, 0x35, 0x61, 0x34, 0x31, 0x37, 0x61, 0x38, 0x32, 0x30, 0x65, 0x33, 0x63, 0x35, 0x31, 0x61, 0x38, 0x66, 0x36, 0x39, 0x37, 0x35, 0x36, 0x66, 0x39, 0x63, 0x33, 0x62, 0x34, 0x34, 0x36, 0x66, 0x34, 0x66, 0x66, 0x63, 0x32, 0x31, 0x35, 0x39, 0x64, 0x31, 0x31, 0x65, 0x66, 0x39, 0x36, 0x32, 0x37, 0x32, 0x30, 0x64, 0x63, 0x31, 0x64, 0x39, 0x37, 0x63, 0x39, 0x35, 0x62, 0x61, 0x33, 0x38, 0x36, 0x32, 0x30, 0x61, 0x63, 0x32, 0x32, 0x34, 0x37, 0x32, 0x34, 0x30, 0x30, 0x36, 0x32, 0x31, 0x38, 0x62, 0x62, 0x66, 0x63, 0x31, 0x38, 0x63, 0x34, 0x66, 0x32, 0x33, 0x39, 0x38, 0x35, 0x34, 0x31, 0x64, 0x30, 0x39, 0x33, 0x32, 0x63, 0x34, 0x37, 0x63, 0x65, 0x66, 0x37, 0x61, 0x31, 0x64, 0x65, 0x62, 0x63, 0x34, 0x36, 0x35, 0x63, 0x32, 0x39, 0x64, 0x36, 0x39, 0x30, 0x61, 0x39, 0x61, 0x61, 0x35, 0x35, 0x31, 0x33, 0x39, 0x34, 0x30, 0x33, 0x64, 0x38, 0x39, 0x30, 0x37, 0x66, 0x31, 0x35, 0x66, 0x34, 0x31, 0x33, 0x62, 0x30, 0x34, 0x36, 0x31, 0x36, 0x62, 0x37, 0x35, 0x33, 0x62, 0x65, 0x36, 0x65, 0x37, 0x31, 0x62, 0x35, 0x65, 0x63, 0x61, 0x30, 0x63, 0x62, 0x66, 0x39, 0x62, 0x37, 0x31, 0x65, 0x32, 0x30, 0x34, 0x39, 0x61, 0x36, 0x37, 0x39, 0x65, 0x37, 0x65, 0x64, 0x35, 0x34, 0x38, 0x38, 0x65, 0x31, 0x33, 0x65, 0x30, 0x37, 0x32, 0x62, 0x32, 0x30, 0x38, 0x35, 0x31, 0x63, 0x37, 0x65, 0x39, 0x31, 0x32, 0x31, 0x65, 0x33, 0x32, 0x35, 0x33, 0x63, 0x37, 0x31, 0x65, 0x65, 0x63, 0x39, 0x66, 0x33, 0x63, 0x36, 0x61, 0x33, 0x37, 0x61, 0x63, 0x35, 0x64, 0x35, 0x37, 0x33, 0x39, 0x33, 0x39, 0x66, 0x32, 0x66, 0x35, 0x31, 0x31, 0x30, 0x35, 0x32, 0x32, 0x38, 0x38, 0x62, 0x38, 0x30, 0x34, 0x35, 0x61, 0x64, 0x35, 0x37, 0x32, 0x33, 0x34, 0x34, 0x32, 0x65, 0x34, 0x61, 0x61, 0x32, 0x65, 0x33, 0x64, 0x64, 0x39, 0x62, 0x33, 0x35, 0x34, 0x34, 0x65, 0x66, 0x31, 0x38, 0x65, 0x36, 0x62, 0x61, 0x31, 0x66, 0x34, 0x61, 0x35, 0x64, 0x37, 0x38, 0x30, 0x62, 0x34, 0x37, 0x35, 0x61, 0x30, 0x61, 0x37, 0x33, 0x37, 0x61, 0x62, 0x66, 0x37, 0x63, 0x35, 0x35, 0x66, 0x34, 0x34, 0x65, 0x63, 0x36, 0x30, 0x31, 0x66, 0x37, 0x32, 0x65, 0x30, 0x35, 0x35, 0x31, 0x39, 0x63, 0x30, 0x37, 0x39, 0x38, 0x61, 0x31, 0x64, 0x33, 0x66, 0x63, 0x31, 0x31, 0x64, 0x32, 0x37, 0x66, 0x34, 0x61, 0x35, 0x35, 0x30, 0x37, 0x30, 0x34, 0x37, 0x31, 0x65, 0x65, 0x30, 0x62, 0x38, 0x33, 0x38, 0x31, 0x65, 0x62, 0x36, 0x65, 0x62, 0x34, 0x66, 0x63, 0x65, 0x30, 0x38, 0x37, 0x62, 0x64, 0x32, 0x63, 0x30, 0x32, 0x64, 0x31, 0x66, 0x33, 0x34, 0x66, 0x38, 0x66, 0x32, 0x34, 0x65, 0x30, 0x31, 0x66, 0x66, 0x39, 0x33, 0x64, 0x32, 0x35, 0x35, 0x34, 0x35, 0x61, 0x30, 0x61, 0x36, 0x36, 0x61, 0x38, 0x35, 0x61, 0x30, 0x64, 0x31, 0x35, 0x35, 0x39, 0x62, 0x33, 0x32, 0x62, 0x61, 0x31, 0x37, 0x34, 0x65, 0x61, 0x65, 0x66, 0x31, 0x39, 0x35, 0x35, 0x61, 0x33, 0x66, 0x32, 0x39, 0x62, 0x30, 0x63, 0x32, 0x36, 0x35, 0x64, 0x37, 0x37, 0x32, 0x66, 0x30, 0x33, 0x61, 0x35, 0x35, 0x36, 0x38, 0x35, 0x66, 0x38, 0x30, 0x38, 0x35, 0x64, 0x37, 0x37, 0x31, 0x36, 0x31, 0x65, 0x64, 0x30, 0x62, 0x62, 0x66, 0x38, 0x65, 0x61, 0x30, 0x39, 0x31, 0x38, 0x33, 0x66, 0x39, 0x37, 0x37, 0x33, 0x32, 0x35, 0x38, 0x38, 0x31, 0x32, 0x34, 0x61, 0x65, 0x61, 0x32, 0x64, 0x30, 0x33, 0x34, 0x32, 0x61, 0x34, 0x31, 0x37, 0x32, 0x36, 0x31, 0x37, 0x32, 0x34, 0x63, 0x62, 0x32, 0x66, 0x35, 0x38, 0x34, 0x62, 0x32, 0x64, 0x31, 0x65, 0x31, 0x64, 0x36, 0x31, 0x38, 0x30, 0x61, 0x33, 0x66, 0x62, 0x34, 0x64, 0x39, 0x38, 0x32, 0x32, 0x30, 0x37, 0x64, 0x62, 0x34, 0x66, 0x32, 0x39, 0x64, 0x34, 0x64, 0x63, 0x62, 0x31, 0x36, 0x30, 0x34, 0x35, 0x62, 0x39, 0x30, 0x34, 0x36, 0x33, 0x64, 0x33, 0x36, 0x38, 0x34, 0x64, 0x66, 0x31, 0x31, 0x37, 0x32, 0x32, 0x61, 0x64, 0x61, 0x64, 0x34, 0x65, 0x64, 0x64, 0x32, 0x39, 0x38, 0x31, 0x31, 0x65, 0x37, 0x33, 0x30, 0x39, 0x33, 0x35, 0x35, 0x31, 0x35, 0x61, 0x38, 0x61, 0x39, 0x33, 0x61, 0x36, 0x61, 0x34, 0x63, 0x31, 0x66, 0x32, 0x63, 0x39, 0x39, 0x36, 0x62, 0x33, 0x30, 0x63, 0x64, 0x30, 0x32, 0x31, 0x65, 0x31, 0x36, 0x62, 0x35, 0x34, 0x37, 0x36, 0x63, 0x62, 0x66, 0x36, 0x64, 0x30, 0x37, 0x34, 0x63, 0x39, 0x38, 0x30, 0x37, 0x30, 0x38, 0x39, 0x64, 0x31, 0x34, 0x63, 0x65, 0x31, 0x65, 0x32, 0x34, 0x36, 0x37, 0x64, 0x34, 0x39, 0x35, 0x37, 0x34, 0x35, 0x66, 0x63, 0x34, 0x63, 0x37, 0x31, 0x36, 0x63, 0x36, 0x36, 0x33, 0x39, 0x30, 0x32, 0x66, 0x36, 0x35, 0x31, 0x35, 0x36, 0x30, 0x33, 0x64, 0x36, 0x39, 0x38, 0x31, 0x30, 0x37, 0x36, 0x38, 0x65, 0x66, 0x65, 0x38, 0x37, 0x32, 0x63, 0x32, 0x31, 0x61, 0x31, 0x39, 0x39, 0x33, 0x66, 0x66, 0x34, 0x34, 0x33, 0x39, 0x36, 0x39, 0x64, 0x36, 0x61, 0x62, 0x66, 0x34, 0x36, 0x39, 0x62, 0x63, 0x64, 0x37, 0x38, 0x32, 0x65, 0x30, 0x66, 0x35, 0x39, 0x31, 0x63, 0x65, 0x30, 0x31, 0x31, 0x62, 0x63, 0x63, 0x37, 0x37, 0x39, 0x33, 0x61, 0x61, 0x62, 0x38, 0x36, 0x35, 0x31, 0x62, 0x65, 0x33, 0x36, 0x64, 0x35, 0x65, 0x30, 0x39, 0x39, 0x39, 0x33, 0x34, 0x37, 0x64, 0x38, 0x32, 0x39, 0x34, 0x31, 0x39, 0x62, 0x64, 0x35, 0x38, 0x30, 0x63, 0x33, 0x38, 0x61, 0x37, 0x34, 0x35, 0x37, 0x33, 0x39, 0x37, 0x33, 0x34, 0x30, 0x66, 0x32, 0x35, 0x34, 0x65, 0x61, 0x37, 0x31, 0x38, 0x33, 0x36, 0x64, 0x32, 0x30, 0x64, 0x30, 0x34, 0x62, 0x32, 0x33, 0x61, 0x38, 0x65, 0x38, 0x62, 0x61, 0x38, 0x30, 0x39, 0x64, 0x33, 0x31, 0x36, 0x37, 0x66, 0x34, 0x63, 0x39, 0x39, 0x39, 0x33, 0x63, 0x63, 0x35, 0x35, 0x38, 0x32, 0x30, 0x30, 0x31, 0x39, 0x32, 0x33, 0x36, 0x62, 0x65, 0x37, 0x37, 0x35, 0x35, 0x34, 0x30, 0x66, 0x33, 0x34, 0x61, 0x37, 0x33, 0x30, 0x36, 0x39, 0x32, 0x64, 0x38, 0x38, 0x66, 0x38, 0x31, 0x65, 0x66, 0x32, 0x31, 0x30, 0x34, 0x61, 0x34, 0x38, 0x64, 0x66, 0x39, 0x37, 0x34, 0x37, 0x66, 0x64, 0x37, 0x32, 0x32, 0x66, 0x65, 0x31, 0x36, 0x62, 0x32, 0x38, 0x32, 0x36, 0x63, 0x36, 0x34, 0x66, 0x32, 0x39, 0x62, 0x37, 0x35, 0x37, 0x38, 0x36, 0x35, 0x30, 0x33, 0x30, 0x34, 0x34, 0x34, 0x31, 0x38, 0x36, 0x61, 0x65, 0x61, 0x33, 0x30, 0x33, 0x33, 0x33, 0x33, 0x62, 0x38, 0x32, 0x38, 0x30, 0x30, 0x31, 0x30, 0x62, 0x35, 0x38, 0x66, 0x37, 0x63, 0x64, 0x35, 0x66, 0x61, 0x64, 0x35, 0x32, 0x37, 0x32, 0x33, 0x38, 0x63, 0x36, 0x65, 0x31, 0x64, 0x62, 0x30, 0x35, 0x38, 0x64, 0x32, 0x36, 0x64, 0x33, 0x32, 0x37, 0x66, 0x36, 0x30, 0x61, 0x64, 0x31, 0x37, 0x31, 0x63, 0x32, 0x35, 0x61, 0x36, 0x38, 0x36, 0x31, 0x64, 0x66, 0x38, 0x62, 0x37, 0x65, 0x62, 0x38, 0x38, 0x36, 0x65, 0x30, 0x63, 0x35, 0x33, 0x66, 0x37, 0x63, 0x37, 0x63, 0x30, 0x63, 0x38, 0x33, 0x65, 0x62, 0x30, 0x39, 0x35, 0x36, 0x61, 0x65, 0x31, 0x35, 0x64, 0x33, 0x65, 0x64, 0x62, 0x30, 0x33, 0x63, 0x39, 0x36, 0x34, 0x30, 0x31, 0x35, 0x63, 0x63, 0x39, 0x62, 0x30, 0x66, 0x62, 0x32, 0x63, 0x30, 0x34, 0x35, 0x36, 0x37, 0x35, 0x65, 0x33, 0x32, 0x65, 0x66, 0x34, 0x61, 0x66, 0x63, 0x34, 0x65, 0x63, 0x39, 0x33, 0x38, 0x36, 0x65, 0x63, 0x63, 0x63, 0x62, 0x63, 0x37, 0x63, 0x38, 0x34, 0x61, 0x63, 0x35, 0x37, 0x32, 0x35, 0x66, 0x32, 0x64, 0x64, 0x38, 0x62, 0x35, 0x64, 0x61, 0x61, 0x66, 0x65, 0x30, 0x39, 0x64, 0x36, 0x32, 0x62, 0x65, 0x38, 0x61, 0x62, 0x34, 0x35, 0x35, 0x66, 0x61, 0x37, 0x37, 0x38, 0x63, 0x39, 0x31, 0x32, 0x33, 0x30, 0x37, 0x36, 0x37, 0x66, 0x39, 0x39, 0x65, 0x61, 0x62, 0x37, 0x34, 0x35, 0x33, 0x64, 0x33, 0x32, 0x37, 0x61, 0x30, 0x32, 0x38, 0x37, 0x66, 0x37, 0x31, 0x37, 0x32, 0x30, 0x63, 0x30, 0x62, 0x30, 0x34, 0x63, 0x30, 0x36, 0x33, 0x62, 0x33, 0x37, 0x62, 0x33, 0x61, 0x62, 0x65, 0x63, 0x62, 0x35, 0x33, 0x30, 0x63, 0x33, 0x39, 0x31, 0x36, 0x39, 0x62, 0x66, 0x39, 0x65, 0x34, 0x30, 0x33, 0x38, 0x35, 0x31, 0x65, 0x38, 0x64, 0x31, 0x31, 0x35, 0x32, 0x34, 0x64, 0x35, 0x33, 0x31, 0x39, 0x66, 0x62, 0x33, 0x66, 0x35, 0x65, 0x33, 0x34, 0x32, 0x30, 0x37, 0x32, 0x35, 0x64, 0x66, 0x30, 0x33, 0x64, 0x63, 0x64, 0x64, 0x39, 0x66, 0x38, 0x35, 0x39, 0x64, 0x36, 0x31, 0x66, 0x39, 0x38, 0x37, 0x62, 0x66, 0x34, 0x33, 0x36, 0x63, 0x31, 0x32, 0x65, 0x39, 0x33, 0x38, 0x36, 0x38, 0x62, 0x31, 0x38, 0x66, 0x63, 0x38, 0x66, 0x61, 0x63, 0x64, 0x66, 0x66, 0x65, 0x61, 0x38, 0x31, 0x35, 0x64, 0x63, 0x34, 0x39, 0x65, 0x62, 0x62, 0x32, 0x37, 0x62, 0x34, 0x36, 0x31, 0x37, 0x65, 0x66, 0x33, 0x61, 0x32, 0x38, 0x31, 0x61, 0x37, 0x66, 0x31, 0x34, 0x37, 0x31, 0x65, 0x66, 0x34, 0x61, 0x63, 0x31, 0x66, 0x31, 0x64, 0x33, 0x38, 0x65, 0x62, 0x34, 0x62, 0x37, 0x61, 0x30, 0x66, 0x64, 0x33, 0x33, 0x37, 0x35, 0x33, 0x32, 0x65, 0x36, 0x30, 0x39, 0x34, 0x35, 0x63, 0x62, 0x35, 0x38, 0x30, 0x64, 0x32, 0x32, 0x63, 0x62, 0x31, 0x30, 0x39, 0x62, 0x37, 0x32, 0x30, 0x61, 0x63, 0x39, 0x62, 0x39, 0x35, 0x64, 0x63, 0x34, 0x31, 0x32, 0x36, 0x66, 0x31, 0x31, 0x39, 0x61, 0x31, 0x65, 0x38, 0x64, 0x31, 0x63, 0x33, 0x33, 0x31, 0x37, 0x65, 0x66, 0x39, 0x66, 0x62, 0x64, 0x34, 0x65, 0x34, 0x36, 0x30, 0x38, 0x37, 0x35, 0x39, 0x39, 0x38, 0x34, 0x35, 0x32, 0x31, 0x31, 0x30, 0x65, 0x64, 0x30, 0x37, 0x36, 0x37, 0x30, 0x34, 0x35, 0x37, 0x39, 0x37, 0x32, 0x34, 0x30, 0x31, 0x38, 0x34, 0x32, 0x34, 0x66, 0x63, 0x39, 0x34, 0x63, 0x65, 0x39, 0x61, 0x39, 0x63, 0x63, 0x37, 0x63, 0x61, 0x31, 0x31, 0x61, 0x66, 0x31, 0x65, 0x61, 0x63, 0x61, 0x62, 0x62, 0x63, 0x64, 0x30, 0x63, 0x34, 0x62, 0x32, 0x66, 0x36, 0x39, 0x34, 0x35, 0x37, 0x66, 0x65, 0x37, 0x62, 0x37, 0x38, 0x63, 0x62, 0x62, 0x64, 0x37, 0x30, 0x33, 0x31, 0x36, 0x61, 0x35, 0x34, 0x34, 0x33, 0x63, 0x36, 0x33, 0x63, 0x31, 0x38, 0x31, 0x38, 0x38, 0x64, 0x30, 0x39, 0x39, 0x30, 0x34, 0x33, 0x38, 0x66, 0x33, 0x62, 0x64, 0x61, 0x37, 0x36, 0x32, 0x34, 0x36, 0x34, 0x63, 0x63, 0x35, 0x36, 0x30, 0x65, 0x33, 0x32, 0x36, 0x39, 0x66, 0x62, 0x62, 0x62, 0x66, 0x61, 0x30, 0x35, 0x34, 0x35, 0x35, 0x38, 0x63, 0x33, 0x63, 0x38, 0x38, 0x35, 0x64, 0x36, 0x65, 0x37, 0x32, 0x37, 0x32, 0x61, 0x64, 0x61, 0x30, 0x35, 0x61, 0x35, 0x32, 0x61, 0x64, 0x30, 0x30, 0x38, 0x38, 0x33, 0x34, 0x62, 0x38, 0x30, 0x62, 0x33, 0x33, 0x37, 0x31, 0x36, 0x65, 0x61, 0x32, 0x65, 0x62, 0x33, 0x37, 0x35, 0x62, 0x65, 0x37, 0x30, 0x63, 0x62, 0x31, 0x39, 0x35, 0x65, 0x39, 0x34, 0x38, 0x65, 0x35, 0x39, 0x66, 0x32, 0x62, 0x30, 0x63, 0x31, 0x34, 0x33, 0x35, 0x35, 0x33, 0x32, 0x64, 0x37, 0x32, 0x33, 0x62, 0x64, 0x34, 0x37, 0x37, 0x31, 0x32, 0x32, 0x36, 0x64, 0x39, 0x31, 0x65, 0x64, 0x35, 0x32, 0x30, 0x33, 0x34, 0x37, 0x36, 0x30, 0x66, 0x36, 0x62, 0x66, 0x38, 0x65, 0x30, 0x63, 0x61, 0x64, 0x36, 0x39, 0x33, 0x33, 0x32, 0x34, 0x65, 0x35, 0x34, 0x33, 0x64, 0x36, 0x64, 0x31, 0x32, 0x35, 0x61, 0x39, 0x61, 0x31, 0x64, 0x38, 0x38, 0x66, 0x39, 0x63, 0x65, 0x66, 0x32, 0x35, 0x63, 0x32, 0x37, 0x66, 0x64, 0x34, 0x32, 0x65, 0x39, 0x64, 0x65, 0x35, 0x39, 0x35, 0x33, 0x37, 0x61, 0x33, 0x36, 0x65, 0x30, 0x36, 0x61, 0x62, 0x66, 0x33, 0x63, 0x65, 0x37, 0x38, 0x31, 0x30, 0x31, 0x66, 0x62, 0x63, 0x30, 0x63, 0x65, 0x39, 0x36, 0x39, 0x34, 0x35, 0x30, 0x66, 0x33, 0x32, 0x37, 0x66, 0x36, 0x36, 0x36, 0x64, 0x32, 0x34, 0x36, 0x63, 0x62, 0x30, 0x38, 0x61, 0x62, 0x35, 0x66, 0x30, 0x63, 0x38, 0x33, 0x64, 0x61, 0x62, 0x64, 0x61, 0x65, 0x35, 0x32, 0x32, 0x31, 0x37, 0x34, 0x32, 0x30, 0x35, 0x64, 0x61, 0x66, 0x63, 0x32, 0x35, 0x32, 0x62, 0x36, 0x33, 0x38, 0x65, 0x65, 0x65, 0x32, 0x66, 0x35, 0x30, 0x36, 0x66, 0x30, 0x39, 0x39, 0x65, 0x33, 0x63, 0x65, 0x36, 0x39, 0x66, 0x62, 0x32, 0x36, 0x61, 0x39, 0x36, 0x34, 0x38, 0x38, 0x32, 0x32, 0x62, 0x37, 0x37, 0x32, 0x63, 0x33, 0x33, 0x30, 0x34, 0x66, 0x30, 0x35, 0x39, 0x36, 0x37, 0x66, 0x39, 0x38, 0x30, 0x34, 0x31, 0x35, 0x62, 0x36, 0x31, 0x35, 0x33, 0x36, 0x36, 0x64, 0x38, 0x30, 0x61, 0x35, 0x34, 0x66, 0x35, 0x33, 0x61, 0x33, 0x36, 0x33, 0x62, 0x38, 0x31, 0x35, 0x34, 0x37, 0x38, 0x65, 0x33, 0x63, 0x37, 0x34, 0x31, 0x38, 0x64, 0x62, 0x63, 0x35, 0x34, 0x38, 0x33, 0x34, 0x34, 0x36, 0x37, 0x32, 0x35, 0x64, 0x38, 0x39, 0x63, 0x63, 0x37, 0x32, 0x33, 0x30, 0x61, 0x31, 0x36, 0x37, 0x35, 0x36, 0x34, 0x33, 0x63, 0x35, 0x64, 0x35, 0x63, 0x35, 0x30, 0x63, 0x66, 0x36, 0x32, 0x34, 0x31, 0x37, 0x61, 0x36, 0x39, 0x38, 0x32, 0x36, 0x38, 0x31, 0x39, 0x38, 0x62, 0x31, 0x64, 0x63, 0x64, 0x37, 0x61, 0x30, 0x37, 0x30, 0x31, 0x66, 0x37, 0x35, 0x38, 0x37, 0x65, 0x35, 0x33, 0x65, 0x34, 0x34, 0x39, 0x63, 0x61, 0x36, 0x30, 0x32, 0x31, 0x66, 0x65, 0x39, 0x65, 0x39, 0x65, 0x30, 0x33, 0x31, 0x65, 0x66, 0x64, 0x38, 0x31, 0x63, 0x30, 0x62, 0x35, 0x32, 0x33, 0x64, 0x30, 0x33, 0x32, 0x37, 0x34, 0x35, 0x30, 0x37, 0x66, 0x37, 0x38, 0x30, 0x33, 0x38, 0x34, 0x63, 0x63, 0x30, 0x32, 0x61, 0x62, 0x39, 0x61, 0x61, 0x31, 0x34, 0x65, 0x31, 0x35, 0x37, 0x36, 0x61, 0x39, 0x35, 0x37, 0x32, 0x65, 0x37, 0x64, 0x31, 0x35, 0x34, 0x34, 0x30, 0x64, 0x62, 0x37, 0x63, 0x66, 0x30, 0x37, 0x62, 0x31, 0x38, 0x33, 0x64, 0x33, 0x39, 0x37, 0x38, 0x36, 0x35, 0x34, 0x37, 0x66, 0x37, 0x65, 0x65, 0x64, 0x61, 0x34, 0x61, 0x35, 0x39, 0x32, 0x61, 0x61, 0x31, 0x36, 0x61, 0x37, 0x33, 0x64, 0x37, 0x61, 0x30, 0x35, 0x35, 0x39, 0x37, 0x33, 0x37, 0x65, 0x39, 0x38, 0x35, 0x66, 0x33, 0x31, 0x30, 0x65, 0x61, 0x34, 0x34, 0x36, 0x31, 0x30, 0x62, 0x32, 0x65, 0x65, 0x62, 0x62, 0x39, 0x34, 0x33, 0x39, 0x34, 0x32, 0x65, 0x30, 0x31, 0x38, 0x30, 0x33, 0x62, 0x31, 0x30, 0x63, 0x62, 0x34, 0x33, 0x37, 0x30, 0x32, 0x63, 0x33, 0x37, 0x31, 0x39, 0x32, 0x30, 0x31, 0x37, 0x39, 0x64, 0x33, 0x39, 0x33, 0x64, 0x62, 0x32, 0x63, 0x63, 0x31, 0x65, 0x38, 0x33, 0x65, 0x31, 0x36, 0x39, 0x37, 0x32, 0x39, 0x66, 0x64, 0x64, 0x30, 0x63, 0x64, 0x37, 0x61, 0x36, 0x33, 0x32, 0x31, 0x39, 0x36, 0x62, 0x61, 0x31, 0x63, 0x66, 0x36, 0x38, 0x39, 0x36, 0x39, 0x61, 0x32, 0x62, 0x37, 0x66, 0x64, 0x34, 0x31, 0x33, 0x63, 0x65, 0x39, 0x30, 0x36, 0x32, 0x33, 0x62, 0x65, 0x64, 0x36, 0x62, 0x34, 0x32, 0x30, 0x36, 0x64, 0x61, 0x39, 0x30, 0x64, 0x36, 0x37, 0x35, 0x36, 0x34, 0x64, 0x34, 0x37, 0x32, 0x37, 0x61, 0x38, 0x30, 0x36, 0x39, 0x65, 0x65, 0x38, 0x31, 0x38, 0x39, 0x61, 0x35, 0x62, 0x38, 0x65, 0x37, 0x61, 0x66, 0x63, 0x63, 0x62, 0x33, 0x33, 0x64, 0x35, 0x64, 0x66, 0x64, 0x34, 0x38, 0x33, 0x39, 0x36, 0x36, 0x39, 0x37, 0x61, 0x61, 0x34, 0x30, 0x64, 0x30, 0x65, 0x35, 0x35, 0x30, 0x65, 0x62, 0x33, 0x32, 0x64, 0x38, 0x66, 0x33, 0x33, 0x35, 0x38, 0x39, 0x39, 0x34, 0x34, 0x35, 0x32, 0x38, 0x33, 0x65, 0x62, 0x61, 0x62, 0x66, 0x36, 0x66, 0x34, 0x32, 0x64, 0x31, 0x31, 0x62, 0x66, 0x65, 0x37, 0x31, 0x37, 0x36, 0x61, 0x64, 0x36, 0x38, 0x65, 0x30, 0x66, 0x65, 0x35, 0x38, 0x63, 0x38, 0x38, 0x66, 0x30, 0x38, 0x61, 0x30, 0x61, 0x32, 0x38, 0x63, 0x36, 0x35, 0x35, 0x64, 0x64, 0x32, 0x37, 0x32, 0x61, 0x66, 0x36, 0x62, 0x64, 0x61, 0x31, 0x64, 0x64, 0x65, 0x37, 0x32, 0x34, 0x33, 0x64, 0x37, 0x64, 0x64, 0x31, 0x62, 0x31, 0x35, 0x64, 0x37, 0x65, 0x35, 0x30, 0x61, 0x35, 0x61, 0x31, 0x61, 0x32, 0x61, 0x34, 0x31, 0x62, 0x65, 0x32, 0x35, 0x38, 0x31, 0x64, 0x61, 0x32, 0x38, 0x36, 0x38, 0x30, 0x61, 0x64, 0x62, 0x32, 0x37, 0x62, 0x30, 0x39, 0x34, 0x63, 0x64, 0x30, 0x33, 0x64, 0x31, 0x36, 0x64, 0x66, 0x30, 0x66, 0x62, 0x32, 0x37, 0x35, 0x65, 0x30, 0x32, 0x31, 0x61, 0x30, 0x37, 0x36, 0x34, 0x38, 0x32, 0x61, 0x66, 0x35, 0x30, 0x63, 0x37, 0x31, 0x30, 0x63, 0x31, 0x35, 0x66, 0x66, 0x39, 0x33, 0x61, 0x62, 0x30, 0x63, 0x35, 0x33, 0x61, 0x63, 0x36, 0x39, 0x65, 0x34, 0x61, 0x37, 0x31, 0x61, 0x33, 0x64, 0x64, 0x34, 0x38, 0x36, 0x65, 0x62, 0x39, 0x30, 0x36, 0x35, 0x63, 0x62, 0x66, 0x34, 0x62, 0x31, 0x34, 0x32, 0x65, 0x31, 0x32, 0x37, 0x32, 0x39, 0x61, 0x62, 0x38, 0x30, 0x37, 0x61, 0x33, 0x33, 0x66, 0x37, 0x30, 0x39, 0x39, 0x39, 0x37, 0x30, 0x32, 0x63, 0x64, 0x63, 0x34, 0x34, 0x30, 0x66, 0x31, 0x32, 0x35, 0x61, 0x36, 0x61, 0x37, 0x31, 0x35, 0x31, 0x65, 0x34, 0x31, 0x34, 0x38, 0x33, 0x31, 0x65, 0x61, 0x32, 0x34, 0x39, 0x31, 0x30, 0x37, 0x30, 0x37, 0x64, 0x36, 0x39, 0x31, 0x31, 0x61, 0x36, 0x63, 0x35, 0x37, 0x32, 0x39, 0x66, 0x35, 0x34, 0x30, 0x63, 0x39, 0x34, 0x31, 0x34, 0x64, 0x36, 0x31, 0x36, 0x35, 0x38, 0x64, 0x38, 0x31, 0x32, 0x63, 0x64, 0x38, 0x35, 0x37, 0x66, 0x39, 0x65, 0x30, 0x34, 0x37, 0x66, 0x37, 0x39, 0x31, 0x36, 0x65, 0x62, 0x66, 0x32, 0x63, 0x37, 0x63, 0x30, 0x61, 0x30, 0x35, 0x62, 0x36, 0x38, 0x31, 0x34, 0x66, 0x33, 0x63, 0x38, 0x32, 0x63, 0x64, 0x66, 0x63, 0x32, 0x62, 0x31, 0x38, 0x34, 0x62, 0x61, 0x36, 0x30, 0x38, 0x34, 0x35, 0x63, 0x39, 0x33, 0x63, 0x33, 0x31, 0x66, 0x31, 0x64, 0x33, 0x34, 0x36, 0x35, 0x30, 0x33, 0x37, 0x34, 0x35, 0x62, 0x30, 0x38, 0x34, 0x63, 0x61, 0x31, 0x66, 0x35, 0x31, 0x35, 0x31, 0x65, 0x61, 0x34, 0x38, 0x35, 0x66, 0x62, 0x36, 0x37, 0x65, 0x61, 0x35, 0x35, 0x63, 0x39, 0x62, 0x33, 0x31, 0x39, 0x34, 0x30, 0x39, 0x30, 0x38, 0x37, 0x32, 0x65, 0x35, 0x64, 0x63, 0x62, 0x66, 0x35, 0x36, 0x36, 0x37, 0x66, 0x62, 0x66, 0x37, 0x61, 0x66, 0x66, 0x30, 0x35, 0x66, 0x36, 0x30, 0x33, 0x32, 0x62, 0x36, 0x30, 0x39, 0x35, 0x34, 0x64, 0x64, 0x30, 0x37, 0x66, 0x33, 0x65, 0x35, 0x65, 0x30, 0x39, 0x34, 0x63, 0x32, 0x38, 0x31, 0x38, 0x38, 0x65, 0x36, 0x39, 0x30, 0x65, 0x37, 0x33, 0x33, 0x33, 0x65, 0x65, 0x37, 0x64, 0x33, 0x37, 0x32, 0x37, 0x39, 0x61, 0x64, 0x63, 0x33, 0x61, 0x39, 0x37, 0x37, 0x63, 0x65, 0x66, 0x36, 0x36, 0x62, 0x34, 0x32, 0x39, 0x35, 0x66, 0x63, 0x61, 0x64, 0x31, 0x33, 0x39, 0x62, 0x36, 0x39, 0x39, 0x63, 0x62, 0x63, 0x63, 0x39, 0x33, 0x37, 0x62, 0x37, 0x61, 0x33, 0x65, 0x37, 0x64, 0x37, 0x35, 0x35, 0x30, 0x39, 0x39, 0x33, 0x61, 0x66, 0x37, 0x65, 0x65, 0x30, 0x61, 0x61, 0x37, 0x31, 0x31, 0x39, 0x64, 0x34, 0x64, 0x39, 0x63, 0x35, 0x64, 0x38, 0x31, 0x65, 0x38, 0x38, 0x66, 0x39, 0x65, 0x65, 0x66, 0x37, 0x38, 0x39, 0x32, 0x34, 0x38, 0x62, 0x65, 0x61, 0x34, 0x32, 0x63, 0x30, 0x64, 0x37, 0x33, 0x63, 0x33, 0x37, 0x30, 0x61, 0x30, 0x31, 0x33, 0x37, 0x65, 0x64, 0x66, 0x36, 0x64, 0x30, 0x35, 0x62, 0x66, 0x65, 0x36, 0x61, 0x38, 0x37, 0x33, 0x64, 0x62, 0x36, 0x65, 0x63, 0x32, 0x32, 0x65, 0x36, 0x34, 0x31, 0x61, 0x36, 0x63, 0x61, 0x66, 0x31, 0x62, 0x61, 0x37, 0x66, 0x66, 0x65, 0x36, 0x63, 0x61, 0x64, 0x39, 0x64, 0x63, 0x39, 0x63, 0x31, 0x34, 0x36, 0x36, 0x66, 0x64, 0x64, 0x34, 0x61, 0x30, 0x64, 0x39, 0x34, 0x34, 0x39, 0x37, 0x36, 0x38, 0x30, 0x32, 0x36, 0x32, 0x61, 0x64, 0x66, 0x63, 0x63, 0x65, 0x64, 0x38, 0x38, 0x64, 0x36, 0x31, 0x65, 0x66, 0x33, 0x36, 0x36, 0x36, 0x64, 0x31, 0x35, 0x37, 0x38, 0x66, 0x63, 0x38, 0x35, 0x65, 0x62, 0x65, 0x38, 0x62, 0x61, 0x31, 0x65, 0x37, 0x31, 0x34, 0x64, 0x30, 0x30, 0x33, 0x32, 0x62, 0x32, 0x30, 0x33, 0x36, 0x65, 0x39, 0x32, 0x62, 0x37, 0x31, 0x38, 0x30, 0x35, 0x30, 0x61, 0x65, 0x36, 0x61, 0x35, 0x61, 0x65, 0x61, 0x30, 0x38, 0x65, 0x34, 0x39, 0x35, 0x62, 0x37, 0x66, 0x39, 0x65, 0x36, 0x31, 0x37, 0x32, 0x37, 0x61, 0x38, 0x31, 0x64, 0x34, 0x38, 0x66, 0x35, 0x35, 0x33, 0x64, 0x37, 0x66, 0x65, 0x36, 0x62, 0x39, 0x62, 0x66, 0x62, 0x38, 0x66, 0x65, 0x38, 0x31, 0x64, 0x32, 0x63, 0x37, 0x38, 0x32, 0x36, 0x65, 0x32, 0x33, 0x62, 0x32, 0x33, 0x63, 0x31, 0x63, 0x61, 0x64, 0x66, 0x33, 0x61, 0x37, 0x32, 0x61, 0x30, 0x32, 0x38, 0x36, 0x65, 0x65, 0x66, 0x35, 0x30, 0x64, 0x34, 0x37, 0x32, 0x36, 0x65, 0x36, 0x61, 0x39, 0x61, 0x30, 0x33, 0x64, 0x38, 0x65, 0x30, 0x65, 0x62, 0x34, 0x61, 0x34, 0x36, 0x64, 0x34, 0x36, 0x35, 0x36, 0x37, 0x31, 0x33, 0x37, 0x34, 0x32, 0x31, 0x36, 0x63, 0x37, 0x30, 0x39, 0x38, 0x33, 0x37, 0x31, 0x32, 0x34, 0x32, 0x36, 0x63, 0x36, 0x62, 0x34, 0x34, 0x37, 0x65, 0x31, 0x35, 0x39, 0x37, 0x30, 0x31, 0x37, 0x63, 0x36, 0x39, 0x66, 0x30, 0x32, 0x33, 0x35, 0x65, 0x33, 0x65, 0x61, 0x64, 0x32, 0x61, 0x62, 0x33, 0x30, 0x65, 0x33, 0x39, 0x35, 0x36, 0x37, 0x65, 0x33, 0x36, 0x31, 0x37, 0x64, 0x37, 0x33, 0x62, 0x39, 0x32, 0x66, 0x34, 0x61, 0x38, 0x62, 0x63, 0x34, 0x36, 0x65, 0x62, 0x31, 0x39, 0x35, 0x61, 0x34, 0x35, 0x31, 0x35, 0x39, 0x30, 0x37, 0x36, 0x65, 0x61, 0x62, 0x32, 0x30, 0x34, 0x65, 0x30, 0x39, 0x61, 0x61, 0x37, 0x39, 0x37, 0x32, 0x63, 0x36, 0x38, 0x32, 0x61, 0x37, 0x32, 0x62, 0x36, 0x37, 0x62, 0x30, 0x33, 0x33, 0x37, 0x33, 0x37, 0x63, 0x35, 0x37, 0x61, 0x32, 0x36, 0x33, 0x34, 0x64, 0x38, 0x32, 0x34, 0x37, 0x62, 0x65, 0x31, 0x36, 0x64, 0x30, 0x31, 0x61, 0x64, 0x64, 0x61, 0x36, 0x63, 0x61, 0x38, 0x35, 0x61, 0x35, 0x39, 0x61, 0x62, 0x30, 0x33, 0x37, 0x35, 0x36, 0x66, 0x35, 0x63, 0x34, 0x34, 0x38, 0x36, 0x39, 0x31, 0x33, 0x35, 0x32, 0x32, 0x65, 0x34, 0x37, 0x64, 0x36, 0x66, 0x36, 0x37, 0x63, 0x32, 0x64, 0x31, 0x63, 0x64, 0x30, 0x35, 0x38, 0x63, 0x39, 0x34, 0x30, 0x34, 0x62, 0x31, 0x64, 0x63, 0x36, 0x33, 0x32, 0x32, 0x65, 0x31, 0x62, 0x36, 0x65, 0x33, 0x62, 0x31, 0x39, 0x30, 0x38, 0x30, 0x39, 0x66, 0x33, 0x30, 0x37, 0x65, 0x66, 0x35, 0x33, 0x66, 0x31, 0x38, 0x66, 0x35, 0x39, 0x37, 0x32, 0x34, 0x36, 0x38, 0x61, 0x36, 0x66, 0x36, 0x37, 0x31, 0x32, 0x35, 0x37, 0x33, 0x34, 0x34, 0x65, 0x31, 0x30, 0x32, 0x37, 0x39, 0x66, 0x30, 0x36, 0x35, 0x35, 0x65, 0x66, 0x37, 0x39, 0x32, 0x37, 0x32, 0x32, 0x66, 0x62, 0x63, 0x32, 0x31, 0x33, 0x39, 0x30, 0x36, 0x63, 0x38, 0x36, 0x36, 0x62, 0x32, 0x62, 0x32, 0x35, 0x66, 0x63, 0x61, 0x32, 0x31, 0x30, 0x38, 0x66, 0x61, 0x35, 0x37, 0x32, 0x64, 0x32, 0x66, 0x61, 0x30, 0x31, 0x64, 0x35, 0x37, 0x38, 0x36, 0x66, 0x63, 0x62, 0x31, 0x35, 0x37, 0x30, 0x34, 0x62, 0x61, 0x63, 0x63, 0x39, 0x64, 0x33, 0x38, 0x35, 0x39, 0x33, 0x36, 0x33, 0x36, 0x35, 0x34, 0x33, 0x30, 0x62, 0x33, 0x65, 0x35, 0x34, 0x62, 0x34, 0x64, 0x38, 0x37, 0x66, 0x37, 0x38, 0x38, 0x31, 0x34, 0x30, 0x39, 0x32, 0x63, 0x32, 0x64, 0x30, 0x64, 0x62, 0x37, 0x32, 0x35, 0x66, 0x33, 0x36, 0x61, 0x38, 0x64, 0x31, 0x62, 0x63, 0x37, 0x37, 0x32, 0x61, 0x32, 0x62, 0x34, 0x38, 0x35, 0x63, 0x36, 0x66, 0x30, 0x34, 0x33, 0x30, 0x64, 0x39, 0x33, 0x38, 0x30, 0x62, 0x36, 0x36, 0x32, 0x30, 0x32, 0x36, 0x32, 0x62, 0x63, 0x33, 0x33, 0x36, 0x35, 0x37, 0x32, 0x36, 0x65, 0x66, 0x39, 0x31, 0x31, 0x35, 0x37, 0x33, 0x39, 0x33, 0x33, 0x39, 0x30, 0x33, 0x34, 0x64, 0x65, 0x33, 0x64, 0x33, 0x33, 0x37, 0x35, 0x31, 0x30, 0x66, 0x37, 0x34, 0x66, 0x30, 0x65, 0x62, 0x66, 0x66, 0x33, 0x64, 0x65, 0x35, 0x63, 0x39, 0x63, 0x62, 0x39, 0x39, 0x66, 0x35, 0x32, 0x34, 0x37, 0x30, 0x31, 0x36, 0x61, 0x38, 0x31, 0x33, 0x34, 0x38, 0x62, 0x33, 0x31, 0x64, 0x30, 0x65, 0x37, 0x30, 0x66, 0x39, 0x65, 0x39, 0x37, 0x35, 0x66, 0x62, 0x33, 0x35, 0x30, 0x64, 0x37, 0x32, 0x62, 0x33, 0x65, 0x34, 0x30, 0x35, 0x36, 0x36, 0x64, 0x33, 0x30, 0x35, 0x66, 0x38, 0x62, 0x66, 0x66, 0x61, 0x36, 0x32, 0x36, 0x63, 0x61, 0x36, 0x30, 0x64, 0x63, 0x38, 0x66, 0x35, 0x64, 0x36, 0x30, 0x63, 0x66, 0x38, 0x34, 0x36, 0x36, 0x34, 0x64, 0x63, 0x66, 0x31, 0x32, 0x36, 0x38, 0x62, 0x32, 0x33, 0x30, 0x62, 0x34, 0x36, 0x35, 0x62, 0x62, 0x61, 0x65, 0x30, 0x61, 0x35, 0x37, 0x32, 0x33, 0x64, 0x38, 0x66, 0x33, 0x34, 0x30, 0x33, 0x64, 0x36, 0x38, 0x35, 0x61, 0x66, 0x62, 0x37, 0x61, 0x66, 0x66, 0x61, 0x62, 0x33, 0x34, 0x38, 0x39, 0x38, 0x34, 0x36, 0x37, 0x32, 0x62, 0x33, 0x65, 0x36, 0x31, 0x61, 0x33, 0x61, 0x30, 0x35, 0x31, 0x37, 0x33, 0x35, 0x32, 0x64, 0x35, 0x63, 0x37, 0x36, 0x61, 0x32, 0x37, 0x36, 0x66, 0x33, 0x62, 0x65, 0x30, 0x66, 0x38, 0x61, 0x37, 0x32, 0x32, 0x38, 0x37, 0x37, 0x39, 0x34, 0x34, 0x32, 0x34, 0x63, 0x31, 0x37, 0x61, 0x31, 0x65, 0x36, 0x33, 0x66, 0x37, 0x30, 0x33, 0x32, 0x35, 0x37, 0x37, 0x38, 0x35, 0x63, 0x37, 0x37, 0x37, 0x63, 0x62, 0x38, 0x62, 0x33, 0x37, 0x34, 0x34, 0x38, 0x65, 0x61, 0x33, 0x37, 0x37, 0x33, 0x36, 0x34, 0x38, 0x37, 0x64, 0x34, 0x62, 0x31, 0x38, 0x62, 0x61, 0x34, 0x61, 0x34, 0x37, 0x66, 0x36, 0x35, 0x36, 0x66, 0x61, 0x39, 0x62, 0x32, 0x38, 0x35, 0x36, 0x33, 0x30, 0x61, 0x38, 0x39, 0x34, 0x31, 0x65, 0x31, 0x36, 0x37, 0x37, 0x31, 0x64, 0x65, 0x35, 0x36, 0x66, 0x65, 0x34, 0x32, 0x33, 0x61, 0x65, 0x33, 0x61, 0x33, 0x39, 0x35, 0x65, 0x38, 0x37, 0x66, 0x30, 0x63, 0x36, 0x64, 0x64, 0x33, 0x63, 0x66, 0x30, 0x31, 0x66, 0x33, 0x64, 0x62, 0x39, 0x36, 0x61, 0x37, 0x37, 0x35, 0x35, 0x32, 0x66, 0x38, 0x31, 0x36, 0x38, 0x61, 0x63, 0x64, 0x35, 0x32, 0x64, 0x33, 0x61, 0x37, 0x32, 0x38, 0x39, 0x66, 0x31, 0x65, 0x36, 0x61, 0x61, 0x31, 0x61, 0x63, 0x37, 0x36, 0x34, 0x34, 0x62, 0x37, 0x31, 0x30, 0x65, 0x64, 0x66, 0x61, 0x64, 0x38, 0x30, 0x64, 0x37, 0x64, 0x61, 0x62, 0x65, 0x63, 0x31, 0x63, 0x39, 0x64, 0x64, 0x62, 0x36, 0x36, 0x65, 0x39, 0x63, 0x66, 0x39, 0x66, 0x32, 0x62, 0x33, 0x32, 0x31, 0x36, 0x34, 0x62, 0x33, 0x34, 0x33, 0x65, 0x61, 0x61, 0x66, 0x35, 0x64, 0x63, 0x34, 0x30, 0x64, 0x39, 0x30, 0x39, 0x38, 0x66, 0x39, 0x64, 0x65, 0x65, 0x37, 0x39, 0x65, 0x35, 0x32, 0x66, 0x64, 0x37, 0x66, 0x39, 0x66, 0x33, 0x37, 0x62, 0x38, 0x65, 0x38, 0x61, 0x66, 0x31, 0x61, 0x64, 0x38, 0x30, 0x38, 0x33, 0x65, 0x32, 0x39, 0x31, 0x64, 0x63, 0x65, 0x39, 0x37, 0x32, 0x63, 0x39, 0x63, 0x30, 0x33, 0x63, 0x66, 0x33, 0x62, 0x30, 0x63, 0x33, 0x31, 0x37, 0x38, 0x35, 0x63, 0x31, 0x39, 0x31, 0x34, 0x34, 0x36, 0x63, 0x30, 0x35, 0x61, 0x36, 0x34, 0x37, 0x38, 0x38, 0x37, 0x34, 0x66, 0x66, 0x36, 0x35, 0x34, 0x65, 0x65, 0x31, 0x38, 0x33, 0x36, 0x64, 0x31, 0x64, 0x66, 0x35, 0x66, 0x30, 0x39, 0x31, 0x61, 0x65, 0x62, 0x30, 0x66, 0x37, 0x65, 0x66, 0x34, 0x61, 0x38, 0x33, 0x33, 0x38, 0x65, 0x64, 0x61, 0x39, 0x39, 0x37, 0x33, 0x34, 0x64, 0x30, 0x37, 0x66, 0x62, 0x30, 0x35, 0x34, 0x31, 0x39, 0x39, 0x63, 0x65, 0x62, 0x66, 0x30, 0x32, 0x36, 0x37, 0x65, 0x63, 0x30, 0x66, 0x33, 0x38, 0x62, 0x34, 0x33, 0x39, 0x35, 0x63, 0x38, 0x62, 0x65, 0x32, 0x66, 0x35, 0x61, 0x30, 0x31, 0x65, 0x38, 0x32, 0x31, 0x62, 0x61, 0x31, 0x35, 0x65, 0x63, 0x36, 0x31, 0x38, 0x38, 0x64, 0x35, 0x39, 0x37, 0x64, 0x65, 0x65, 0x32, 0x34, 0x36, 0x63, 0x64, 0x35, 0x35, 0x64, 0x37, 0x63, 0x66, 0x61, 0x34, 0x30, 0x65, 0x34, 0x34, 0x39, 0x39, 0x37, 0x62, 0x66, 0x34, 0x36, 0x37, 0x37, 0x35, 0x62, 0x61, 0x32, 0x63, 0x66, 0x62, 0x30, 0x32, 0x32, 0x39, 0x33, 0x62, 0x33, 0x31, 0x62, 0x36, 0x62, 0x35, 0x38, 0x34, 0x36, 0x61, 0x31, 0x35, 0x31, 0x64, 0x37, 0x32, 0x61, 0x37, 0x35, 0x66, 0x30, 0x33, 0x33, 0x65, 0x64, 0x32, 0x38, 0x36, 0x64, 0x38, 0x65, 0x63, 0x35, 0x32, 0x65, 0x38, 0x35, 0x65, 0x36, 0x65, 0x34, 0x36, 0x63, 0x62, 0x30, 0x35, 0x33, 0x31, 0x30, 0x63, 0x37, 0x31, 0x39, 0x63, 0x63, 0x35, 0x32, 0x61, 0x38, 0x33, 0x30, 0x61, 0x33, 0x37, 0x36, 0x30, 0x38, 0x36, 0x65, 0x61, 0x63, 0x39, 0x35, 0x63, 0x30, 0x31, 0x38, 0x32, 0x37, 0x32, 0x38, 0x34, 0x36, 0x38, 0x38, 0x34, 0x63, 0x32, 0x36, 0x61, 0x39, 0x65, 0x63, 0x66, 0x36, 0x32, 0x35, 0x36, 0x62, 0x31, 0x30, 0x63, 0x36, 0x66, 0x33, 0x65, 0x32, 0x38, 0x64, 0x37, 0x35, 0x32, 0x62, 0x37, 0x31, 0x30, 0x65, 0x37, 0x63, 0x34, 0x34, 0x64, 0x63, 0x36, 0x31, 0x34, 0x66, 0x66, 0x33, 0x61, 0x65, 0x63, 0x38, 0x63, 0x39, 0x35, 0x65, 0x36, 0x62, 0x65, 0x35, 0x33, 0x37, 0x32, 0x38, 0x30, 0x66, 0x34, 0x35, 0x39, 0x35, 0x66, 0x65, 0x30, 0x63, 0x36, 0x65, 0x62, 0x62, 0x35, 0x31, 0x65, 0x39, 0x36, 0x65, 0x61, 0x62, 0x62, 0x31, 0x61, 0x34, 0x37, 0x39, 0x38, 0x32, 0x36, 0x63, 0x61, 0x65, 0x32, 0x62, 0x33, 0x39, 0x34, 0x37, 0x38, 0x63, 0x63, 0x61, 0x66, 0x36, 0x61, 0x64, 0x62, 0x65, 0x65, 0x31, 0x63, 0x38, 0x39, 0x37, 0x65, 0x32, 0x35, 0x35, 0x32, 0x37, 0x32, 0x39, 0x36, 0x36, 0x65, 0x63, 0x32, 0x38, 0x64, 0x65, 0x66, 0x37, 0x35, 0x33, 0x31, 0x64, 0x31, 0x37, 0x64, 0x66, 0x36, 0x33, 0x64, 0x65, 0x65, 0x33, 0x36, 0x31, 0x35, 0x34, 0x64, 0x63, 0x64, 0x34, 0x31, 0x61, 0x33, 0x39, 0x64, 0x64, 0x65, 0x38, 0x61, 0x38, 0x33, 0x63, 0x36, 0x62, 0x38, 0x37, 0x30, 0x35, 0x61, 0x38, 0x37, 0x63, 0x37, 0x65, 0x32, 0x34, 0x64, 0x36, 0x34, 0x37, 0x32, 0x34, 0x63, 0x30, 0x65, 0x39, 0x39, 0x38, 0x63, 0x39, 0x63, 0x64, 0x38, 0x31, 0x37, 0x34, 0x30, 0x30, 0x39, 0x37, 0x32, 0x37, 0x37, 0x64, 0x63, 0x66, 0x66, 0x35, 0x38, 0x63, 0x34, 0x64, 0x33, 0x62, 0x36, 0x33, 0x30, 0x62, 0x35, 0x32, 0x63, 0x62, 0x39, 0x37, 0x62, 0x62, 0x38, 0x33, 0x66, 0x32, 0x33, 0x31, 0x65, 0x35, 0x61, 0x31, 0x34, 0x31, 0x36, 0x32, 0x36, 0x34, 0x34, 0x37, 0x32, 0x64, 0x61, 0x63, 0x64, 0x35, 0x35, 0x63, 0x66, 0x36, 0x35, 0x31, 0x35, 0x66, 0x33, 0x63, 0x31, 0x39, 0x38, 0x64, 0x31, 0x34, 0x34, 0x66, 0x38, 0x30, 0x36, 0x62, 0x37, 0x32, 0x31, 0x35, 0x61, 0x33, 0x30, 0x63, 0x61, 0x37, 0x35, 0x34, 0x65, 0x30, 0x34, 0x39, 0x36, 0x30, 0x61, 0x64, 0x62, 0x30, 0x33, 0x32, 0x64, 0x31, 0x32, 0x64, 0x35, 0x63, 0x36, 0x36, 0x62, 0x33, 0x36, 0x34, 0x33, 0x66, 0x37, 0x30, 0x64, 0x30, 0x39, 0x32, 0x61, 0x30, 0x33, 0x63, 0x36, 0x32, 0x37, 0x64, 0x64, 0x63, 0x61, 0x66, 0x62, 0x38, 0x64, 0x30, 0x61, 0x34, 0x66, 0x39, 0x34, 0x31, 0x30, 0x62, 0x66, 0x38, 0x39, 0x31, 0x38, 0x66, 0x63, 0x30, 0x63, 0x61, 0x34, 0x39, 0x35, 0x61, 0x33, 0x64, 0x34, 0x61, 0x62, 0x30, 0x36, 0x63, 0x35, 0x64, 0x32, 0x35, 0x38, 0x65, 0x31, 0x35, 0x31, 0x37, 0x32, 0x39, 0x33, 0x65, 0x64, 0x63, 0x37, 0x36, 0x30, 0x66, 0x34, 0x33, 0x38, 0x38, 0x65, 0x32, 0x66, 0x63, 0x35, 0x30, 0x39, 0x65, 0x37, 0x61, 0x30, 0x37, 0x64, 0x63, 0x34, 0x34, 0x36, 0x66, 0x31, 0x31, 0x33, 0x30, 0x34, 0x38, 0x37, 0x61, 0x38, 0x30, 0x38, 0x35, 0x33, 0x36, 0x65, 0x39, 0x61, 0x65, 0x38, 0x31, 0x65, 0x65, 0x63, 0x31, 0x33, 0x32, 0x33, 0x33, 0x35, 0x66, 0x33, 0x37, 0x32, 0x35, 0x34, 0x61, 0x33, 0x33, 0x34, 0x32, 0x66, 0x36, 0x33, 0x31, 0x37, 0x32, 0x66, 0x34, 0x63, 0x31, 0x66, 0x30, 0x33, 0x36, 0x34, 0x65, 0x32, 0x33, 0x35, 0x30, 0x37, 0x63, 0x31, 0x35, 0x33, 0x39, 0x65, 0x64, 0x30, 0x39, 0x34, 0x30, 0x64, 0x62, 0x33, 0x63, 0x64, 0x37, 0x35, 0x36, 0x37, 0x35, 0x36, 0x39, 0x64, 0x63, 0x35, 0x61, 0x30, 0x64, 0x65, 0x63, 0x31, 0x63, 0x66, 0x34, 0x36, 0x36, 0x38, 0x61, 0x63, 0x33, 0x66, 0x34, 0x36, 0x65, 0x64, 0x64, 0x61, 0x32, 0x35, 0x65, 0x65, 0x34, 0x61, 0x31, 0x37, 0x31, 0x66, 0x33, 0x33, 0x64, 0x35, 0x34, 0x62, 0x37, 0x35, 0x65, 0x31, 0x39, 0x39, 0x66, 0x66, 0x31, 0x63, 0x35, 0x61, 0x31, 0x36, 0x33, 0x63, 0x34, 0x64, 0x39, 0x36, 0x36, 0x61, 0x66, 0x62, 0x39, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, 0x35, 0x39, 0x35, 0x37, 0x32, 0x32, 0x63, 0x35, 0x64, 0x31, 0x34, 0x36, 0x32, 0x64, 0x66, 0x34, 0x62, 0x38, 0x39, 0x64, 0x31, 0x35, 0x37, 0x34, 0x63, 0x64, 0x30, 0x31, 0x39, 0x61, 0x64, 0x38, 0x34, 0x61, 0x36, 0x37, 0x38, 0x62, 0x33, 0x65, 0x38, 0x63, 0x64, 0x62, 0x63, 0x30, 0x39, 0x30, 0x61, 0x33, 0x38, 0x64, 0x62, 0x34, 0x36, 0x65, 0x66, 0x31, 0x33, 0x33, 0x64, 0x66, 0x66, 0x36, 0x35, 0x37, 0x62, 0x37, 0x32, 0x65, 0x66, 0x33, 0x64, 0x34, 0x35, 0x32, 0x39, 0x38, 0x37, 0x35, 0x36, 0x36, 0x33, 0x35, 0x38, 0x34, 0x35, 0x61, 0x36, 0x30, 0x37, 0x36, 0x36, 0x31, 0x37, 0x31, 0x34, 0x65, 0x37, 0x61, 0x31, 0x33, 0x38, 0x37, 0x32, 0x63, 0x36, 0x66, 0x39, 0x65, 0x33, 0x34, 0x39, 0x30, 0x65, 0x34, 0x62, 0x63, 0x30, 0x66, 0x65, 0x66, 0x34, 0x37, 0x64, 0x39, 0x36, 0x64, 0x32, 0x64, 0x33, 0x37, 0x32, 0x65, 0x63, 0x63, 0x63, 0x33, 0x61, 0x62, 0x66, 0x31, 0x33, 0x35, 0x39, 0x62, 0x33, 0x34, 0x38, 0x37, 0x37, 0x62, 0x61, 0x33, 0x62, 0x39, 0x64, 0x66, 0x61, 0x64, 0x31, 0x30, 0x64, 0x65, 0x65, 0x39, 0x63, 0x37, 0x39, 0x32, 0x33, 0x65, 0x33, 0x32, 0x37, 0x64, 0x30, 0x66, 0x34, 0x36, 0x34, 0x66, 0x38, 0x66, 0x33, 0x66, 0x31, 0x63, 0x66, 0x39, 0x32, 0x62, 0x65, 0x66, 0x34, 0x35, 0x63, 0x65, 0x62, 0x36, 0x65, 0x64, 0x34, 0x65, 0x38, 0x30, 0x32, 0x32, 0x36, 0x62, 0x64, 0x66, 0x32, 0x37, 0x31, 0x33, 0x39, 0x35, 0x38, 0x63, 0x62, 0x31, 0x31, 0x66, 0x35, 0x62, 0x61, 0x36, 0x61, 0x63, 0x32, 0x39, 0x33, 0x37, 0x31, 0x66, 0x62, 0x30, 0x66, 0x62, 0x61, 0x37, 0x32, 0x61, 0x63, 0x31, 0x62, 0x33, 0x30, 0x33, 0x32, 0x33, 0x31, 0x61, 0x62, 0x37, 0x63, 0x30, 0x32, 0x37, 0x32, 0x39, 0x32, 0x34, 0x37, 0x36, 0x34, 0x63, 0x36, 0x64, 0x37, 0x33, 0x65, 0x33, 0x35, 0x35, 0x63, 0x36, 0x34, 0x39, 0x33, 0x33, 0x33, 0x37, 0x62, 0x63, 0x31, 0x61, 0x31, 0x66, 0x37, 0x30, 0x61, 0x39, 0x31, 0x32, 0x37, 0x65, 0x39, 0x64, 0x63, 0x62, 0x31, 0x33, 0x36, 0x36, 0x62, 0x63, 0x38, 0x38, 0x34, 0x38, 0x30, 0x66, 0x61, 0x32, 0x65, 0x31, 0x35, 0x66, 0x65, 0x37, 0x61, 0x37, 0x32, 0x66, 0x63, 0x33, 0x32, 0x36, 0x32, 0x36, 0x39, 0x36, 0x30, 0x33, 0x37, 0x62, 0x32, 0x38, 0x32, 0x66, 0x30, 0x39, 0x64, 0x39, 0x64, 0x62, 0x36, 0x66, 0x37, 0x35, 0x65, 0x66, 0x62, 0x39, 0x35, 0x65, 0x65, 0x64, 0x38, 0x64, 0x35, 0x63, 0x39, 0x61, 0x32, 0x62, 0x32, 0x34, 0x36, 0x35, 0x31, 0x64, 0x33, 0x31, 0x35, 0x32, 0x64, 0x62, 0x30, 0x63, 0x63, 0x64, 0x65, 0x66, 0x37, 0x37, 0x32, 0x36, 0x64, 0x39, 0x61, 0x62, 0x39, 0x38, 0x34, 0x30, 0x30, 0x66, 0x31, 0x61, 0x36, 0x39, 0x36, 0x36, 0x61, 0x66, 0x34, 0x63, 0x36, 0x62, 0x34, 0x66, 0x32, 0x37, 0x35, 0x66, 0x35, 0x37, 0x35, 0x61, 0x62, 0x30, 0x64, 0x37, 0x63, 0x66, 0x31, 0x39, 0x30, 0x30, 0x37, 0x34, 0x32, 0x30, 0x38, 0x32, 0x64, 0x63, 0x32, 0x63, 0x37, 0x33, 0x62, 0x37, 0x31, 0x31, 0x32, 0x38, 0x66, 0x32, 0x37, 0x38, 0x62, 0x61, 0x37, 0x32, 0x34, 0x34, 0x36, 0x66, 0x30, 0x61, 0x32, 0x35, 0x33, 0x30, 0x35, 0x39, 0x65, 0x39, 0x31, 0x39, 0x32, 0x64, 0x35, 0x34, 0x38, 0x35, 0x64, 0x34, 0x66, 0x33, 0x35, 0x38, 0x35, 0x36, 0x63, 0x31, 0x37, 0x39, 0x63, 0x39, 0x31, 0x31, 0x66, 0x39, 0x33, 0x31, 0x66, 0x35, 0x65, 0x64, 0x36, 0x36, 0x32, 0x31, 0x32, 0x32, 0x31, 0x66, 0x35, 0x34, 0x61, 0x30, 0x31, 0x62, 0x34, 0x62, 0x61, 0x38, 0x37, 0x33, 0x35, 0x35, 0x33, 0x32, 0x66, 0x38, 0x39, 0x32, 0x30, 0x34, 0x39, 0x32, 0x35, 0x38, 0x32, 0x62, 0x36, 0x65, 0x33, 0x32, 0x31, 0x37, 0x34, 0x35, 0x31, 0x37, 0x63, 0x36, 0x32, 0x33, 0x39, 0x64, 0x61, 0x63, 0x37, 0x35, 0x31, 0x65, 0x34, 0x38, 0x35, 0x62, 0x33, 0x62, 0x30, 0x30, 0x31, 0x32, 0x35, 0x35, 0x39, 0x31, 0x63, 0x65, 0x32, 0x31, 0x39, 0x39, 0x36, 0x32, 0x34, 0x62, 0x66, 0x35, 0x32, 0x62, 0x33, 0x33, 0x66, 0x30, 0x64, 0x35, 0x35, 0x63, 0x33, 0x33, 0x31, 0x62, 0x32, 0x63, 0x61, 0x32, 0x39, 0x35, 0x36, 0x39, 0x30, 0x38, 0x65, 0x32, 0x34, 0x39, 0x64, 0x63, 0x64, 0x33, 0x37, 0x34, 0x38, 0x33, 0x36, 0x65, 0x61, 0x64, 0x33, 0x34, 0x31, 0x38, 0x63, 0x31, 0x37, 0x62, 0x39, 0x39, 0x66, 0x34, 0x61, 0x35, 0x61, 0x33, 0x31, 0x64, 0x66, 0x61, 0x64, 0x35, 0x62, 0x38, 0x34, 0x39, 0x31, 0x31, 0x63, 0x36, 0x35, 0x33, 0x39, 0x33, 0x34, 0x66, 0x36, 0x34, 0x66, 0x62, 0x30, 0x63, 0x32, 0x64, 0x34, 0x34, 0x34, 0x39, 0x36, 0x62, 0x38, 0x64, 0x33, 0x33, 0x63, 0x35, 0x62, 0x63, 0x64, 0x64, 0x34, 0x33, 0x63, 0x39, 0x65, 0x36, 0x35, 0x66, 0x61, 0x34, 0x62, 0x31, 0x34, 0x36, 0x61, 0x37, 0x37, 0x30, 0x61, 0x37, 0x32, 0x38, 0x65, 0x33, 0x35, 0x61, 0x64, 0x61, 0x34, 0x63, 0x38, 0x31, 0x66, 0x65, 0x39, 0x61, 0x62, 0x64, 0x30, 0x36, 0x34, 0x32, 0x66, 0x31, 0x39, 0x31, 0x31, 0x64, 0x30, 0x39, 0x66, 0x31, 0x63, 0x33, 0x35, 0x32, 0x39, 0x30, 0x62, 0x63, 0x36, 0x65, 0x39, 0x39, 0x65, 0x63, 0x38, 0x63, 0x35, 0x61, 0x39, 0x61, 0x62, 0x34, 0x64, 0x62, 0x36, 0x36, 0x32, 0x63, 0x66, 0x35, 0x64, 0x35, 0x66, 0x34, 0x37, 0x37, 0x61, 0x35, 0x38, 0x31, 0x32, 0x64, 0x38, 0x32, 0x33, 0x34, 0x66, 0x63, 0x34, 0x35, 0x65, 0x64, 0x30, 0x39, 0x62, 0x39, 0x62, 0x39, 0x31, 0x35, 0x64, 0x32, 0x39, 0x66, 0x33, 0x63, 0x34, 0x36, 0x62, 0x38, 0x64, 0x37, 0x64, 0x35, 0x34, 0x35, 0x38, 0x33, 0x36, 0x65, 0x30, 0x30, 0x39, 0x65, 0x32, 0x66, 0x33, 0x33, 0x65, 0x30, 0x37, 0x35, 0x35, 0x39, 0x37, 0x33, 0x34, 0x38, 0x35, 0x66, 0x31, 0x38, 0x37, 0x65, 0x36, 0x63, 0x37, 0x35, 0x34, 0x65, 0x38, 0x61, 0x32, 0x32, 0x64, 0x62, 0x30, 0x35, 0x34, 0x39, 0x64, 0x65, 0x64, 0x32, 0x39, 0x38, 0x65, 0x38, 0x63, 0x30, 0x33, 0x32, 0x61, 0x62, 0x38, 0x64, 0x65, 0x33, 0x38, 0x62, 0x39, 0x32, 0x30, 0x62, 0x66, 0x31, 0x39, 0x34, 0x37, 0x64, 0x39, 0x32, 0x31, 0x64, 0x36, 0x32, 0x62, 0x37, 0x39, 0x34, 0x38, 0x37, 0x39, 0x66, 0x31, 0x64, 0x31, 0x34, 0x66, 0x65, 0x39, 0x31, 0x30, 0x39, 0x66, 0x64, 0x34, 0x35, 0x39, 0x35, 0x35, 0x66, 0x64, 0x32, 0x37, 0x33, 0x37, 0x65, 0x32, 0x33, 0x39, 0x65, 0x65, 0x31, 0x30, 0x64, 0x61, 0x35, 0x36, 0x32, 0x39, 0x31, 0x31, 0x33, 0x36, 0x66, 0x36, 0x63, 0x36, 0x30, 0x34, 0x63, 0x38, 0x66, 0x36, 0x34, 0x38, 0x66, 0x34, 0x31, 0x38, 0x30, 0x36, 0x37, 0x32, 0x33, 0x37, 0x65, 0x61, 0x63, 0x37, 0x35, 0x31, 0x65, 0x35, 0x33, 0x30, 0x61, 0x34, 0x38, 0x35, 0x66, 0x62, 0x66, 0x63, 0x34, 0x33, 0x32, 0x31, 0x33, 0x35, 0x39, 0x31, 0x62, 0x35, 0x62, 0x64, 0x63, 0x35, 0x65, 0x64, 0x62, 0x35, 0x32, 0x31, 0x39, 0x65, 0x33, 0x32, 0x36, 0x64, 0x66, 0x37, 0x34, 0x62, 0x32, 0x36, 0x39, 0x31, 0x38, 0x35, 0x64, 0x61, 0x31, 0x39, 0x61, 0x39, 0x34, 0x39, 0x34, 0x66, 0x33, 0x62, 0x32, 0x66, 0x63, 0x30, 0x38, 0x34, 0x36, 0x33, 0x31, 0x35, 0x63, 0x65, 0x62, 0x37, 0x35, 0x62, 0x37, 0x31, 0x65, 0x30, 0x36, 0x35, 0x32, 0x38, 0x36, 0x33, 0x33, 0x34, 0x65, 0x33, 0x34, 0x62, 0x31, 0x65, 0x36, 0x30, 0x64, 0x66, 0x62, 0x39, 0x33, 0x34, 0x62, 0x31, 0x34, 0x38, 0x36, 0x61, 0x32, 0x33, 0x65, 0x37, 0x35, 0x31, 0x33, 0x38, 0x63, 0x31, 0x37, 0x32, 0x64, 0x31, 0x31, 0x62, 0x30, 0x35, 0x64, 0x63, 0x64, 0x35, 0x37, 0x34, 0x37, 0x33, 0x31, 0x38, 0x65, 0x64, 0x34, 0x33, 0x32, 0x64, 0x65, 0x35, 0x63, 0x65, 0x64, 0x66, 0x33, 0x31, 0x36, 0x61, 0x30, 0x64, 0x61, 0x62, 0x63, 0x31, 0x36, 0x64, 0x62, 0x62, 0x38, 0x62, 0x64, 0x35, 0x34, 0x39, 0x37, 0x35, 0x64, 0x33, 0x62, 0x30, 0x30, 0x64, 0x32, 0x65, 0x39, 0x31, 0x34, 0x62, 0x30, 0x30, 0x31, 0x37, 0x65, 0x30, 0x62, 0x63, 0x62, 0x61, 0x33, 0x33, 0x63, 0x32, 0x36, 0x61, 0x32, 0x34, 0x65, 0x65, 0x65, 0x62, 0x61, 0x63, 0x66, 0x33, 0x64, 0x62, 0x64, 0x65, 0x33, 0x39, 0x38, 0x63, 0x61, 0x31, 0x64, 0x39, 0x32, 0x65, 0x65, 0x37, 0x62, 0x31, 0x36, 0x66, 0x32, 0x37, 0x62, 0x63, 0x63, 0x30, 0x30, 0x63, 0x32, 0x63, 0x32, 0x61, 0x64, 0x63, 0x31, 0x34, 0x32, 0x30, 0x37, 0x32, 0x39, 0x35, 0x39, 0x35, 0x31, 0x34, 0x30, 0x63, 0x34, 0x38, 0x64, 0x37, 0x63, 0x36, 0x38, 0x62, 0x39, 0x32, 0x61, 0x64, 0x66, 0x39, 0x65, 0x32, 0x61, 0x65, 0x61, 0x38, 0x66, 0x65, 0x63, 0x61, 0x39, 0x34, 0x31, 0x36, 0x66, 0x38, 0x33, 0x62, 0x63, 0x38, 0x35, 0x33, 0x61, 0x62, 0x66, 0x36, 0x65, 0x38, 0x34, 0x39, 0x66, 0x33, 0x35, 0x34, 0x34, 0x31, 0x32, 0x33, 0x37, 0x39, 0x36, 0x32, 0x37, 0x64, 0x38, 0x31, 0x36, 0x36, 0x63, 0x33, 0x38, 0x34, 0x34, 0x62, 0x66, 0x36, 0x30, 0x63, 0x63, 0x36, 0x39, 0x63, 0x64, 0x37, 0x31, 0x63, 0x61, 0x65, 0x62, 0x38, 0x35, 0x64, 0x32, 0x37, 0x31, 0x35, 0x37, 0x30, 0x38, 0x66, 0x33, 0x38, 0x36, 0x66, 0x35, 0x61, 0x64, 0x31, 0x66, 0x61, 0x30, 0x38, 0x31, 0x34, 0x64, 0x30, 0x37, 0x33, 0x34, 0x66, 0x37, 0x65, 0x64, 0x62, 0x33, 0x62, 0x39, 0x35, 0x65, 0x63, 0x38, 0x63, 0x62, 0x61, 0x66, 0x32, 0x31, 0x37, 0x33, 0x65, 0x37, 0x63, 0x34, 0x31, 0x30, 0x35, 0x61, 0x37, 0x61, 0x38, 0x30, 0x61, 0x66, 0x37, 0x32, 0x62, 0x61, 0x64, 0x35, 0x35, 0x35, 0x31, 0x35, 0x64, 0x65, 0x38, 0x35, 0x31, 0x38, 0x39, 0x34, 0x35, 0x65, 0x39, 0x62, 0x31, 0x34, 0x39, 0x65, 0x35, 0x33, 0x30, 0x36, 0x66, 0x66, 0x66, 0x65, 0x35, 0x37, 0x32, 0x62, 0x32, 0x36, 0x31, 0x34, 0x32, 0x62, 0x32, 0x39, 0x38, 0x35, 0x65, 0x35, 0x35, 0x66, 0x34, 0x38, 0x37, 0x66, 0x30, 0x31, 0x38, 0x65, 0x32, 0x65, 0x36, 0x61, 0x32, 0x61, 0x30, 0x61, 0x64, 0x62, 0x37, 0x33, 0x38, 0x64, 0x64, 0x33, 0x61, 0x33, 0x37, 0x32, 0x62, 0x61, 0x65, 0x30, 0x30, 0x65, 0x63, 0x64, 0x38, 0x63, 0x33, 0x30, 0x30, 0x33, 0x36, 0x61, 0x38, 0x62, 0x30, 0x30, 0x66, 0x36, 0x35, 0x37, 0x39, 0x66, 0x38, 0x66, 0x63, 0x37, 0x32, 0x63, 0x37, 0x66, 0x38, 0x63, 0x32, 0x38, 0x39, 0x30, 0x65, 0x37, 0x37, 0x61, 0x30, 0x32, 0x62, 0x30, 0x34, 0x38, 0x34, 0x36, 0x38, 0x30, 0x61, 0x66, 0x35, 0x33, 0x30, 0x61, 0x64, 0x35, 0x36, 0x39, 0x38, 0x30, 0x35, 0x31, 0x30, 0x39, 0x32, 0x63, 0x64, 0x38, 0x65, 0x64, 0x63, 0x32, 0x37, 0x61, 0x61, 0x39, 0x62, 0x37, 0x32, 0x33, 0x65, 0x33, 0x36, 0x37, 0x62, 0x33, 0x37, 0x30, 0x33, 0x32, 0x63, 0x31, 0x30, 0x66, 0x35, 0x30, 0x34, 0x66, 0x34, 0x65, 0x32, 0x30, 0x37, 0x37, 0x38, 0x61, 0x36, 0x65, 0x66, 0x34, 0x65, 0x64, 0x61, 0x61, 0x65, 0x37, 0x33, 0x34, 0x38, 0x63, 0x36, 0x38, 0x38, 0x32, 0x36, 0x64, 0x66, 0x65, 0x37, 0x62, 0x37, 0x65, 0x65, 0x64, 0x39, 0x35, 0x37, 0x65, 0x31, 0x64, 0x61, 0x35, 0x38, 0x64, 0x63, 0x65, 0x63, 0x65, 0x35, 0x32, 0x33, 0x64, 0x32, 0x36, 0x30, 0x35, 0x62, 0x31, 0x37, 0x35, 0x32, 0x61, 0x32, 0x32, 0x66, 0x32, 0x63, 0x36, 0x36, 0x35, 0x64, 0x33, 0x33, 0x62, 0x64, 0x38, 0x63, 0x36, 0x66, 0x33, 0x30, 0x62, 0x35, 0x32, 0x62, 0x34, 0x30, 0x61, 0x34, 0x38, 0x65, 0x32, 0x39, 0x37, 0x63, 0x66, 0x61, 0x65, 0x63, 0x33, 0x66, 0x31, 0x66, 0x63, 0x31, 0x37, 0x32, 0x61, 0x31, 0x36, 0x62, 0x30, 0x62, 0x37, 0x65, 0x31, 0x65, 0x63, 0x33, 0x33, 0x34, 0x37, 0x38, 0x34, 0x31, 0x37, 0x31, 0x63, 0x39, 0x34, 0x35, 0x38, 0x39, 0x39, 0x63, 0x64, 0x32, 0x38, 0x65, 0x34, 0x32, 0x62, 0x65, 0x62, 0x36, 0x32, 0x30, 0x65, 0x37, 0x62, 0x65, 0x36, 0x63, 0x63, 0x61, 0x63, 0x37, 0x38, 0x31, 0x37, 0x64, 0x32, 0x39, 0x66, 0x64, 0x31, 0x63, 0x35, 0x66, 0x32, 0x61, 0x64, 0x34, 0x38, 0x35, 0x66, 0x38, 0x62, 0x34, 0x61, 0x34, 0x34, 0x66, 0x65, 0x30, 0x30, 0x39, 0x34, 0x38, 0x34, 0x33, 0x30, 0x63, 0x36, 0x36, 0x30, 0x34, 0x66, 0x66, 0x66, 0x65, 0x35, 0x32, 0x66, 0x66, 0x63, 0x61, 0x38, 0x33, 0x35, 0x35, 0x65, 0x61, 0x34, 0x64, 0x34, 0x65, 0x33, 0x32, 0x62, 0x30, 0x33, 0x39, 0x35, 0x61, 0x65, 0x38, 0x34, 0x33, 0x65, 0x61, 0x61, 0x61, 0x37, 0x32, 0x30, 0x35, 0x65, 0x30, 0x30, 0x37, 0x30, 0x64, 0x30, 0x65, 0x63, 0x61, 0x66, 0x36, 0x37, 0x31, 0x35, 0x63, 0x64, 0x34, 0x65, 0x34, 0x35, 0x34, 0x36, 0x62, 0x61, 0x30, 0x66, 0x38, 0x35, 0x63, 0x61, 0x34, 0x34, 0x36, 0x66, 0x36, 0x63, 0x37, 0x62, 0x61, 0x39, 0x35, 0x38, 0x64, 0x64, 0x31, 0x32, 0x64, 0x31, 0x35, 0x33, 0x66, 0x38, 0x66, 0x31, 0x37, 0x64, 0x32, 0x34, 0x38, 0x37, 0x32, 0x34, 0x61, 0x65, 0x38, 0x64, 0x35, 0x36, 0x39, 0x66, 0x33, 0x63, 0x37, 0x63, 0x35, 0x64, 0x35, 0x31, 0x30, 0x65, 0x38, 0x39, 0x32, 0x35, 0x31, 0x39, 0x36, 0x34, 0x34, 0x66, 0x38, 0x39, 0x64, 0x38, 0x66, 0x63, 0x64, 0x39, 0x36, 0x63, 0x30, 0x33, 0x35, 0x32, 0x36, 0x38, 0x33, 0x35, 0x39, 0x63, 0x66, 0x35, 0x34, 0x38, 0x31, 0x32, 0x63, 0x31, 0x30, 0x64, 0x65, 0x35, 0x38, 0x37, 0x32, 0x62, 0x65, 0x66, 0x35, 0x38, 0x39, 0x63, 0x39, 0x35, 0x65, 0x64, 0x65, 0x65, 0x64, 0x35, 0x33, 0x64, 0x62, 0x65, 0x37, 0x38, 0x61, 0x36, 0x63, 0x63, 0x64, 0x38, 0x35, 0x34, 0x32, 0x65, 0x63, 0x62, 0x31, 0x35, 0x34, 0x63, 0x36, 0x61, 0x33, 0x38, 0x66, 0x33, 0x39, 0x32, 0x65, 0x61, 0x61, 0x36, 0x32, 0x63, 0x36, 0x30, 0x63, 0x36, 0x66, 0x31, 0x39, 0x62, 0x66, 0x37, 0x32, 0x37, 0x32, 0x38, 0x39, 0x38, 0x62, 0x65, 0x39, 0x64, 0x35, 0x61, 0x30, 0x35, 0x36, 0x32, 0x38, 0x64, 0x66, 0x35, 0x33, 0x31, 0x30, 0x62, 0x33, 0x34, 0x32, 0x65, 0x65, 0x39, 0x66, 0x31, 0x65, 0x35, 0x62, 0x32, 0x34, 0x37, 0x62, 0x37, 0x33, 0x35, 0x35, 0x34, 0x62, 0x35, 0x39, 0x33, 0x38, 0x35, 0x36, 0x66, 0x37, 0x34, 0x62, 0x32, 0x63, 0x62, 0x66, 0x32, 0x35, 0x37, 0x63, 0x34, 0x66, 0x30, 0x61, 0x34, 0x35, 0x33, 0x37, 0x31, 0x64, 0x63, 0x30, 0x33, 0x64, 0x34, 0x66, 0x34, 0x31, 0x31, 0x34, 0x37, 0x64, 0x62, 0x31, 0x33, 0x66, 0x65, 0x39, 0x31, 0x66, 0x61, 0x37, 0x61, 0x65, 0x35, 0x36, 0x39, 0x38, 0x32, 0x62, 0x34, 0x62, 0x39, 0x35, 0x39, 0x31, 0x39, 0x39, 0x63, 0x64, 0x35, 0x38, 0x30, 0x36, 0x35, 0x65, 0x32, 0x37, 0x36, 0x66, 0x35, 0x39, 0x38, 0x31, 0x37, 0x35, 0x32, 0x33, 0x39, 0x61, 0x37, 0x32, 0x36, 0x35, 0x35, 0x61, 0x62, 0x35, 0x32, 0x62, 0x34, 0x34, 0x36, 0x31, 0x61, 0x30, 0x34, 0x33, 0x64, 0x61, 0x34, 0x30, 0x33, 0x33, 0x65, 0x62, 0x62, 0x38, 0x63, 0x64, 0x37, 0x37, 0x38, 0x61, 0x38, 0x35, 0x33, 0x38, 0x65, 0x35, 0x34, 0x63, 0x38, 0x66, 0x38, 0x35, 0x36, 0x31, 0x30, 0x36, 0x63, 0x62, 0x30, 0x35, 0x66, 0x32, 0x35, 0x63, 0x37, 0x66, 0x35, 0x63, 0x38, 0x63, 0x65, 0x31, 0x32, 0x64, 0x37, 0x33, 0x61, 0x65, 0x65, 0x37, 0x64, 0x62, 0x35, 0x32, 0x34, 0x64, 0x31, 0x36, 0x61, 0x65, 0x36, 0x31, 0x63, 0x34, 0x39, 0x63, 0x33, 0x33, 0x35, 0x32, 0x30, 0x65, 0x34, 0x32, 0x61, 0x32, 0x32, 0x39, 0x35, 0x36, 0x31, 0x35, 0x30, 0x66, 0x62, 0x64, 0x63, 0x39, 0x63, 0x33, 0x31, 0x32, 0x63, 0x61, 0x34, 0x30, 0x63, 0x65, 0x35, 0x65, 0x30, 0x36, 0x31, 0x65, 0x63, 0x64, 0x35, 0x35, 0x35, 0x34, 0x30, 0x63, 0x38, 0x61, 0x32, 0x32, 0x37, 0x35, 0x36, 0x38, 0x64, 0x36, 0x65, 0x62, 0x35, 0x31, 0x39, 0x30, 0x35, 0x65, 0x31, 0x39, 0x33, 0x62, 0x63, 0x36, 0x62, 0x32, 0x30, 0x36, 0x39, 0x35, 0x61, 0x64, 0x62, 0x61, 0x39, 0x66, 0x39, 0x64, 0x33, 0x64, 0x66, 0x62, 0x61, 0x38, 0x34, 0x62, 0x35, 0x32, 0x61, 0x35, 0x64, 0x64, 0x36, 0x64, 0x36, 0x63, 0x36, 0x38, 0x31, 0x34, 0x38, 0x62, 0x61, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x34, 0x34, 0x65, 0x31, 0x32, 0x37, 0x37, 0x62, 0x30, 0x63, 0x35, 0x34, 0x36, 0x65, 0x33, 0x30, 0x38, 0x37, 0x33, 0x33, 0x39, 0x34, 0x66, 0x35, 0x31, 0x66, 0x38, 0x65, 0x34, 0x32, 0x39, 0x33, 0x64, 0x61, 0x35, 0x32, 0x31, 0x61, 0x37, 0x37, 0x34, 0x36, 0x35, 0x62, 0x38, 0x37, 0x61, 0x30, 0x35, 0x39, 0x33, 0x37, 0x38, 0x37, 0x64, 0x64, 0x64, 0x37, 0x31, 0x63, 0x63, 0x66, 0x39, 0x36, 0x36, 0x33, 0x64, 0x34, 0x34, 0x36, 0x33, 0x66, 0x61, 0x65, 0x30, 0x64, 0x63, 0x38, 0x62, 0x35, 0x38, 0x63, 0x36, 0x62, 0x65, 0x32, 0x61, 0x39, 0x35, 0x33, 0x33, 0x63, 0x61, 0x63, 0x35, 0x33, 0x66, 0x61, 0x65, 0x39, 0x37, 0x31, 0x32, 0x63, 0x36, 0x38, 0x65, 0x39, 0x62, 0x35, 0x31, 0x37, 0x32, 0x62, 0x31, 0x37, 0x61, 0x31, 0x65, 0x65, 0x62, 0x38, 0x36, 0x62, 0x65, 0x62, 0x31, 0x39, 0x61, 0x34, 0x63, 0x63, 0x61, 0x37, 0x33, 0x65, 0x34, 0x30, 0x39, 0x65, 0x38, 0x39, 0x39, 0x36, 0x36, 0x32, 0x61, 0x61, 0x32, 0x33, 0x33, 0x66, 0x39, 0x32, 0x61, 0x61, 0x61, 0x34, 0x32, 0x30, 0x30, 0x36, 0x64, 0x36, 0x65, 0x30, 0x61, 0x63, 0x62, 0x35, 0x32, 0x39, 0x35, 0x33, 0x62, 0x33, 0x64, 0x63, 0x63, 0x32, 0x30, 0x64, 0x37, 0x37, 0x66, 0x34, 0x36, 0x35, 0x33, 0x36, 0x65, 0x39, 0x37, 0x34, 0x32, 0x63, 0x66, 0x34, 0x63, 0x31, 0x38, 0x38, 0x31, 0x61, 0x36, 0x39, 0x39, 0x32, 0x31, 0x63, 0x34, 0x34, 0x61, 0x35, 0x37, 0x66, 0x33, 0x39, 0x64, 0x35, 0x62, 0x34, 0x65, 0x36, 0x36, 0x66, 0x64, 0x39, 0x30, 0x30, 0x31, 0x35, 0x34, 0x35, 0x63, 0x36, 0x64, 0x66, 0x35, 0x30, 0x34, 0x38, 0x37, 0x33, 0x39, 0x31, 0x64, 0x31, 0x38, 0x33, 0x64, 0x39, 0x62, 0x37, 0x37, 0x65, 0x65, 0x66, 0x63, 0x37, 0x31, 0x35, 0x66, 0x34, 0x32, 0x31, 0x32, 0x39, 0x34, 0x65, 0x39, 0x37, 0x39, 0x36, 0x32, 0x63, 0x36, 0x61, 0x66, 0x39, 0x39, 0x65, 0x35, 0x34, 0x32, 0x66, 0x34, 0x33, 0x66, 0x62, 0x37, 0x39, 0x64, 0x36, 0x32, 0x66, 0x64, 0x31, 0x35, 0x61, 0x64, 0x63, 0x34, 0x35, 0x36, 0x32, 0x31, 0x30, 0x31, 0x61, 0x65, 0x37, 0x34, 0x65, 0x64, 0x66, 0x66, 0x64, 0x66, 0x33, 0x63, 0x63, 0x34, 0x65, 0x39, 0x30, 0x35, 0x64, 0x65, 0x39, 0x38, 0x39, 0x36, 0x38, 0x35, 0x64, 0x38, 0x31, 0x34, 0x30, 0x64, 0x38, 0x63, 0x32, 0x66, 0x31, 0x39, 0x64, 0x66, 0x37, 0x35, 0x30, 0x32, 0x36, 0x31, 0x30, 0x35, 0x62, 0x66, 0x64, 0x33, 0x62, 0x66, 0x31, 0x32, 0x64, 0x61, 0x37, 0x32, 0x61, 0x64, 0x30, 0x64, 0x36, 0x65, 0x35, 0x65, 0x62, 0x31, 0x31, 0x62, 0x37, 0x66, 0x65, 0x34, 0x39, 0x35, 0x31, 0x33, 0x62, 0x63, 0x32, 0x36, 0x64, 0x64, 0x30, 0x36, 0x31, 0x61, 0x35, 0x30, 0x33, 0x32, 0x66, 0x62, 0x36, 0x39, 0x35, 0x31, 0x66, 0x39, 0x31, 0x33, 0x32, 0x34, 0x64, 0x33, 0x37, 0x38, 0x36, 0x37, 0x66, 0x30, 0x62, 0x37, 0x30, 0x63, 0x37, 0x30, 0x32, 0x38, 0x37, 0x32, 0x34, 0x32, 0x63, 0x63, 0x65, 0x61, 0x63, 0x36, 0x38, 0x31, 0x36, 0x30, 0x66, 0x63, 0x31, 0x62, 0x30, 0x37, 0x33, 0x62, 0x39, 0x34, 0x65, 0x66, 0x33, 0x32, 0x66, 0x39, 0x66, 0x30, 0x35, 0x65, 0x36, 0x63, 0x63, 0x61, 0x61, 0x61, 0x33, 0x38, 0x37, 0x33, 0x61, 0x30, 0x64, 0x65, 0x36, 0x62, 0x37, 0x39, 0x66, 0x31, 0x35, 0x31, 0x31, 0x62, 0x65, 0x32, 0x35, 0x38, 0x30, 0x32, 0x31, 0x62, 0x33, 0x32, 0x30, 0x62, 0x37, 0x62, 0x33, 0x39, 0x39, 0x64, 0x32, 0x65, 0x62, 0x64, 0x36, 0x62, 0x31, 0x30, 0x30, 0x32, 0x34, 0x33, 0x33, 0x66, 0x33, 0x61, 0x34, 0x38, 0x65, 0x66, 0x63, 0x66, 0x31, 0x32, 0x30, 0x33, 0x64, 0x62, 0x33, 0x34, 0x66, 0x38, 0x30, 0x36, 0x38, 0x65, 0x33, 0x35, 0x64, 0x63, 0x33, 0x32, 0x33, 0x33, 0x65, 0x66, 0x32, 0x64, 0x66, 0x32, 0x36, 0x39, 0x37, 0x32, 0x30, 0x36, 0x37, 0x38, 0x39, 0x36, 0x66, 0x33, 0x66, 0x65, 0x33, 0x37, 0x64, 0x65, 0x30, 0x39, 0x65, 0x35, 0x36, 0x31, 0x65, 0x63, 0x62, 0x62, 0x61, 0x35, 0x33, 0x30, 0x34, 0x63, 0x37, 0x61, 0x61, 0x66, 0x39, 0x64, 0x65, 0x64, 0x62, 0x38, 0x63, 0x37, 0x31, 0x39, 0x35, 0x31, 0x31, 0x31, 0x66, 0x61, 0x31, 0x30, 0x35, 0x37, 0x35, 0x66, 0x31, 0x33, 0x61, 0x64, 0x64, 0x35, 0x34, 0x38, 0x64, 0x38, 0x62, 0x38, 0x38, 0x33, 0x62, 0x36, 0x34, 0x66, 0x66, 0x64, 0x65, 0x62, 0x63, 0x39, 0x31, 0x39, 0x36, 0x39, 0x66, 0x38, 0x63, 0x38, 0x35, 0x63, 0x30, 0x33, 0x61, 0x39, 0x30, 0x62, 0x39, 0x39, 0x61, 0x36, 0x62, 0x31, 0x31, 0x65, 0x66, 0x61, 0x30, 0x39, 0x32, 0x65, 0x65, 0x65, 0x38, 0x33, 0x66, 0x66, 0x33, 0x61, 0x38, 0x31, 0x32, 0x63, 0x38, 0x39, 0x33, 0x66, 0x37, 0x32, 0x35, 0x35, 0x65, 0x32, 0x32, 0x61, 0x30, 0x39, 0x38, 0x32, 0x61, 0x61, 0x66, 0x61, 0x63, 0x66, 0x34, 0x64, 0x64, 0x65, 0x64, 0x32, 0x36, 0x32, 0x30, 0x39, 0x32, 0x64, 0x61, 0x64, 0x61, 0x36, 0x30, 0x63, 0x36, 0x30, 0x31, 0x64, 0x62, 0x61, 0x66, 0x63, 0x39, 0x31, 0x63, 0x34, 0x66, 0x34, 0x30, 0x36, 0x65, 0x65, 0x31, 0x38, 0x37, 0x65, 0x64, 0x65, 0x66, 0x61, 0x33, 0x30, 0x37, 0x32, 0x32, 0x31, 0x37, 0x66, 0x32, 0x36, 0x37, 0x65, 0x65, 0x39, 0x37, 0x61, 0x35, 0x62, 0x63, 0x30, 0x36, 0x37, 0x61, 0x39, 0x62, 0x65, 0x62, 0x62, 0x39, 0x65, 0x65, 0x37, 0x36, 0x30, 0x38, 0x38, 0x34, 0x64, 0x61, 0x66, 0x33, 0x31, 0x34, 0x64, 0x38, 0x64, 0x35, 0x65, 0x31, 0x35, 0x62, 0x38, 0x64, 0x33, 0x66, 0x33, 0x66, 0x33, 0x33, 0x37, 0x32, 0x62, 0x63, 0x34, 0x65, 0x32, 0x36, 0x30, 0x63, 0x35, 0x65, 0x65, 0x62, 0x63, 0x35, 0x61, 0x33, 0x36, 0x66, 0x35, 0x37, 0x32, 0x61, 0x37, 0x33, 0x66, 0x35, 0x34, 0x65, 0x32, 0x38, 0x33, 0x66, 0x30, 0x38, 0x35, 0x31, 0x65, 0x37, 0x38, 0x33, 0x36, 0x61, 0x35, 0x30, 0x35, 0x64, 0x38, 0x63, 0x30, 0x34, 0x35, 0x32, 0x35, 0x39, 0x35, 0x65, 0x65, 0x64, 0x37, 0x66, 0x64, 0x65, 0x63, 0x39, 0x39, 0x30, 0x61, 0x63, 0x38, 0x36, 0x34, 0x61, 0x36, 0x32, 0x63, 0x62, 0x33, 0x65, 0x61, 0x39, 0x37, 0x31, 0x38, 0x33, 0x64, 0x39, 0x64, 0x34, 0x35, 0x37, 0x65, 0x65, 0x37, 0x38, 0x63, 0x37, 0x66, 0x37, 0x34, 0x37, 0x64, 0x31, 0x30, 0x32, 0x34, 0x36, 0x30, 0x39, 0x66, 0x66, 0x39, 0x31, 0x39, 0x30, 0x65, 0x37, 0x62, 0x33, 0x38, 0x66, 0x35, 0x38, 0x32, 0x65, 0x35, 0x62, 0x33, 0x39, 0x63, 0x62, 0x66, 0x37, 0x35, 0x37, 0x32, 0x31, 0x32, 0x32, 0x33, 0x65, 0x33, 0x65, 0x31, 0x64, 0x65, 0x38, 0x64, 0x34, 0x34, 0x64, 0x38, 0x32, 0x37, 0x33, 0x63, 0x37, 0x65, 0x31, 0x66, 0x38, 0x32, 0x39, 0x31, 0x31, 0x62, 0x38, 0x32, 0x33, 0x64, 0x31, 0x39, 0x66, 0x63, 0x37, 0x36, 0x61, 0x65, 0x38, 0x63, 0x61, 0x38, 0x62, 0x38, 0x64, 0x63, 0x65, 0x32, 0x38, 0x66, 0x36, 0x63, 0x32, 0x30, 0x64, 0x34, 0x38, 0x63, 0x37, 0x32, 0x65, 0x37, 0x32, 0x34, 0x32, 0x39, 0x65, 0x66, 0x33, 0x36, 0x61, 0x37, 0x34, 0x38, 0x37, 0x36, 0x38, 0x30, 0x64, 0x61, 0x39, 0x35, 0x31, 0x32, 0x32, 0x39, 0x34, 0x34, 0x36, 0x37, 0x39, 0x66, 0x64, 0x31, 0x34, 0x64, 0x33, 0x63, 0x36, 0x64, 0x32, 0x38, 0x63, 0x38, 0x31, 0x35, 0x31, 0x38, 0x37, 0x39, 0x35, 0x62, 0x62, 0x64, 0x63, 0x38, 0x31, 0x31, 0x66, 0x31, 0x63, 0x61, 0x36, 0x31, 0x31, 0x36, 0x64, 0x62, 0x63, 0x65, 0x63, 0x32, 0x34, 0x62, 0x32, 0x36, 0x63, 0x37, 0x30, 0x38, 0x61, 0x65, 0x30, 0x37, 0x64, 0x38, 0x32, 0x62, 0x38, 0x66, 0x37, 0x32, 0x38, 0x34, 0x37, 0x37, 0x33, 0x66, 0x32, 0x33, 0x33, 0x34, 0x39, 0x34, 0x36, 0x66, 0x31, 0x35, 0x62, 0x63, 0x32, 0x33, 0x63, 0x39, 0x35, 0x37, 0x32, 0x38, 0x31, 0x31, 0x30, 0x32, 0x32, 0x39, 0x35, 0x35, 0x33, 0x62, 0x32, 0x61, 0x62, 0x65, 0x35, 0x38, 0x39, 0x32, 0x34, 0x32, 0x32, 0x34, 0x65, 0x64, 0x30, 0x64, 0x64, 0x64, 0x61, 0x34, 0x37, 0x35, 0x36, 0x33, 0x61, 0x38, 0x62, 0x34, 0x35, 0x61, 0x63, 0x38, 0x30, 0x35, 0x62, 0x38, 0x66, 0x65, 0x64, 0x35, 0x35, 0x38, 0x34, 0x62, 0x37, 0x33, 0x37, 0x32, 0x62, 0x62, 0x66, 0x64, 0x33, 0x62, 0x35, 0x65, 0x36, 0x30, 0x37, 0x30, 0x66, 0x36, 0x36, 0x63, 0x62, 0x34, 0x38, 0x37, 0x31, 0x34, 0x66, 0x33, 0x62, 0x34, 0x32, 0x64, 0x61, 0x33, 0x31, 0x63, 0x62, 0x30, 0x31, 0x31, 0x34, 0x38, 0x33, 0x31, 0x65, 0x34, 0x64, 0x31, 0x39, 0x34, 0x62, 0x38, 0x36, 0x39, 0x61, 0x35, 0x34, 0x30, 0x61, 0x36, 0x35, 0x30, 0x36, 0x30, 0x36, 0x32, 0x32, 0x65, 0x61, 0x33, 0x39, 0x65, 0x34, 0x38, 0x62, 0x34, 0x62, 0x32, 0x62, 0x35, 0x33, 0x39, 0x37, 0x32, 0x38, 0x31, 0x64, 0x63, 0x37, 0x66, 0x65, 0x64, 0x39, 0x31, 0x66, 0x34, 0x32, 0x64, 0x31, 0x63, 0x33, 0x39, 0x63, 0x31, 0x63, 0x65, 0x38, 0x36, 0x62, 0x34, 0x33, 0x37, 0x32, 0x35, 0x37, 0x34, 0x38, 0x63, 0x61, 0x32, 0x65, 0x65, 0x65, 0x64, 0x37, 0x31, 0x37, 0x31, 0x33, 0x33, 0x39, 0x32, 0x34, 0x35, 0x62, 0x32, 0x30, 0x31, 0x65, 0x64, 0x31, 0x32, 0x63, 0x36, 0x35, 0x63, 0x31, 0x37, 0x37, 0x63, 0x65, 0x34, 0x65, 0x39, 0x30, 0x38, 0x34, 0x64, 0x38, 0x65, 0x65, 0x36, 0x66, 0x34, 0x31, 0x32, 0x32, 0x34, 0x36, 0x66, 0x65, 0x35, 0x64, 0x30, 0x35, 0x38, 0x64, 0x32, 0x64, 0x33, 0x61, 0x65, 0x36, 0x33, 0x38, 0x64, 0x62, 0x39, 0x31, 0x31, 0x37, 0x30, 0x38, 0x34, 0x62, 0x35, 0x63, 0x61, 0x64, 0x31, 0x39, 0x36, 0x38, 0x36, 0x33, 0x65, 0x62, 0x39, 0x37, 0x33, 0x35, 0x63, 0x35, 0x37, 0x32, 0x33, 0x31, 0x66, 0x39, 0x62, 0x65, 0x31, 0x30, 0x31, 0x31, 0x31, 0x38, 0x33, 0x30, 0x31, 0x33, 0x63, 0x33, 0x39, 0x65, 0x32, 0x64, 0x32, 0x64, 0x30, 0x32, 0x62, 0x62, 0x36, 0x63, 0x66, 0x39, 0x61, 0x61, 0x34, 0x61, 0x37, 0x36, 0x35, 0x31, 0x38, 0x36, 0x61, 0x36, 0x38, 0x30, 0x34, 0x62, 0x36, 0x61, 0x38, 0x39, 0x33, 0x65, 0x65, 0x63, 0x36, 0x62, 0x66, 0x37, 0x32, 0x34, 0x34, 0x33, 0x38, 0x65, 0x64, 0x64, 0x63, 0x37, 0x63, 0x36, 0x31, 0x39, 0x36, 0x64, 0x34, 0x61, 0x31, 0x33, 0x39, 0x65, 0x62, 0x64, 0x36, 0x39, 0x38, 0x38, 0x61, 0x31, 0x62, 0x61, 0x62, 0x30, 0x65, 0x34, 0x31, 0x64, 0x65, 0x36, 0x38, 0x35, 0x62, 0x31, 0x33, 0x30, 0x32, 0x34, 0x38, 0x30, 0x61, 0x39, 0x65, 0x30, 0x62, 0x39, 0x36, 0x34, 0x37, 0x31, 0x35, 0x64, 0x66, 0x36, 0x64, 0x34, 0x39, 0x65, 0x39, 0x34, 0x62, 0x39, 0x62, 0x37, 0x65, 0x62, 0x33, 0x63, 0x63, 0x31, 0x37, 0x31, 0x31, 0x64, 0x37, 0x38, 0x30, 0x64, 0x31, 0x33, 0x62, 0x62, 0x31, 0x36, 0x33, 0x31, 0x31, 0x63, 0x36, 0x66, 0x36, 0x37, 0x65, 0x63, 0x35, 0x34, 0x32, 0x31, 0x65, 0x63, 0x36, 0x62, 0x36, 0x30, 0x38, 0x64, 0x62, 0x64, 0x36, 0x66, 0x33, 0x37, 0x64, 0x31, 0x33, 0x64, 0x64, 0x32, 0x61, 0x63, 0x38, 0x66, 0x65, 0x35, 0x38, 0x35, 0x39, 0x63, 0x36, 0x62, 0x37, 0x30, 0x35, 0x64, 0x30, 0x38, 0x34, 0x35, 0x33, 0x34, 0x63, 0x63, 0x61, 0x33, 0x31, 0x63, 0x66, 0x30, 0x38, 0x62, 0x32, 0x64, 0x30, 0x63, 0x37, 0x38, 0x36, 0x64, 0x31, 0x36, 0x33, 0x31, 0x62, 0x38, 0x33, 0x31, 0x39, 0x37, 0x62, 0x32, 0x33, 0x65, 0x63, 0x63, 0x36, 0x61, 0x61, 0x35, 0x33, 0x30, 0x30, 0x37, 0x32, 0x36, 0x39, 0x39, 0x34, 0x62, 0x32, 0x36, 0x38, 0x30, 0x30, 0x30, 0x34, 0x62, 0x35, 0x33, 0x31, 0x62, 0x36, 0x30, 0x30, 0x61, 0x65, 0x62, 0x32, 0x30, 0x38, 0x63, 0x65, 0x35, 0x33, 0x35, 0x34, 0x36, 0x64, 0x63, 0x36, 0x30, 0x36, 0x39, 0x30, 0x37, 0x62, 0x63, 0x35, 0x65, 0x33, 0x34, 0x30, 0x31, 0x39, 0x35, 0x62, 0x36, 0x66, 0x38, 0x32, 0x38, 0x34, 0x33, 0x34, 0x31, 0x61, 0x37, 0x32, 0x30, 0x30, 0x35, 0x38, 0x63, 0x66, 0x33, 0x61, 0x36, 0x34, 0x34, 0x63, 0x62, 0x39, 0x63, 0x30, 0x33, 0x30, 0x63, 0x33, 0x62, 0x65, 0x39, 0x30, 0x62, 0x38, 0x62, 0x31, 0x30, 0x63, 0x37, 0x37, 0x39, 0x65, 0x64, 0x63, 0x66, 0x31, 0x65, 0x63, 0x30, 0x61, 0x65, 0x30, 0x30, 0x65, 0x31, 0x35, 0x32, 0x34, 0x35, 0x62, 0x66, 0x39, 0x36, 0x34, 0x64, 0x34, 0x31, 0x63, 0x65, 0x37, 0x37, 0x32, 0x63, 0x65, 0x35, 0x36, 0x65, 0x39, 0x36, 0x36, 0x66, 0x63, 0x64, 0x63, 0x64, 0x38, 0x63, 0x62, 0x36, 0x63, 0x37, 0x64, 0x30, 0x34, 0x30, 0x62, 0x31, 0x32, 0x34, 0x35, 0x61, 0x66, 0x35, 0x64, 0x30, 0x38, 0x34, 0x64, 0x31, 0x38, 0x39, 0x32, 0x64, 0x37, 0x34, 0x36, 0x36, 0x64, 0x34, 0x33, 0x64, 0x30, 0x32, 0x66, 0x63, 0x32, 0x65, 0x64, 0x31, 0x34, 0x62, 0x63, 0x62, 0x36, 0x37, 0x32, 0x61, 0x65, 0x31, 0x34, 0x64, 0x62, 0x38, 0x66, 0x32, 0x33, 0x37, 0x37, 0x61, 0x62, 0x32, 0x31, 0x36, 0x66, 0x32, 0x34, 0x62, 0x35, 0x31, 0x39, 0x62, 0x39, 0x39, 0x35, 0x37, 0x65, 0x34, 0x39, 0x61, 0x39, 0x61, 0x63, 0x30, 0x32, 0x32, 0x35, 0x34, 0x33, 0x61, 0x33, 0x63, 0x33, 0x36, 0x33, 0x30, 0x62, 0x31, 0x38, 0x33, 0x35, 0x61, 0x36, 0x36, 0x35, 0x30, 0x62, 0x35, 0x31, 0x37, 0x32, 0x33, 0x61, 0x64, 0x34, 0x66, 0x61, 0x66, 0x38, 0x63, 0x36, 0x32, 0x63, 0x62, 0x65, 0x38, 0x37, 0x62, 0x37, 0x35, 0x32, 0x34, 0x36, 0x31, 0x35, 0x36, 0x36, 0x39, 0x36, 0x33, 0x34, 0x32, 0x63, 0x63, 0x37, 0x66, 0x36, 0x36, 0x35, 0x34, 0x37, 0x35, 0x30, 0x65, 0x32, 0x32, 0x36, 0x62, 0x32, 0x61, 0x33, 0x38, 0x66, 0x62, 0x38, 0x33, 0x32, 0x38, 0x37, 0x66, 0x35, 0x30, 0x30, 0x37, 0x32, 0x30, 0x33, 0x30, 0x62, 0x64, 0x63, 0x36, 0x64, 0x66, 0x66, 0x35, 0x62, 0x64, 0x37, 0x36, 0x32, 0x33, 0x63, 0x39, 0x33, 0x61, 0x61, 0x63, 0x32, 0x37, 0x37, 0x64, 0x61, 0x39, 0x32, 0x35, 0x37, 0x64, 0x34, 0x61, 0x30, 0x65, 0x35, 0x37, 0x34, 0x64, 0x39, 0x31, 0x65, 0x34, 0x39, 0x32, 0x63, 0x30, 0x35, 0x62, 0x34, 0x39, 0x65, 0x63, 0x61, 0x61, 0x62, 0x33, 0x62, 0x36, 0x66, 0x36, 0x36, 0x62, 0x31, 0x32, 0x66, 0x39, 0x31, 0x31, 0x62, 0x38, 0x31, 0x65, 0x34, 0x33, 0x39, 0x32, 0x62, 0x33, 0x37, 0x32, 0x61, 0x35, 0x34, 0x61, 0x64, 0x35, 0x36, 0x37, 0x62, 0x31, 0x31, 0x36, 0x36, 0x31, 0x64, 0x35, 0x38, 0x34, 0x35, 0x39, 0x38, 0x66, 0x30, 0x61, 0x34, 0x30, 0x37, 0x64, 0x61, 0x33, 0x66, 0x36, 0x38, 0x34, 0x38, 0x37, 0x66, 0x35, 0x61, 0x33, 0x36, 0x39, 0x61, 0x37, 0x32, 0x38, 0x62, 0x34, 0x33, 0x61, 0x30, 0x36, 0x35, 0x30, 0x64, 0x61, 0x66, 0x64, 0x63, 0x66, 0x35, 0x38, 0x65, 0x66, 0x65, 0x33, 0x31, 0x64, 0x62, 0x32, 0x65, 0x33, 0x35, 0x64, 0x36, 0x30, 0x33, 0x64, 0x36, 0x31, 0x64, 0x34, 0x62, 0x37, 0x63, 0x37, 0x37, 0x36, 0x63, 0x33, 0x38, 0x32, 0x31, 0x63, 0x39, 0x66, 0x33, 0x65, 0x66, 0x62, 0x37, 0x65, 0x66, 0x36, 0x65, 0x33, 0x65, 0x37, 0x32, 0x30, 0x62, 0x32, 0x36, 0x37, 0x64, 0x33, 0x38, 0x36, 0x33, 0x65, 0x37, 0x61, 0x38, 0x36, 0x32, 0x64, 0x66, 0x66, 0x64, 0x30, 0x31, 0x62, 0x31, 0x63, 0x39, 0x33, 0x32, 0x30, 0x66, 0x34, 0x63, 0x66, 0x33, 0x32, 0x37, 0x35, 0x39, 0x65, 0x32, 0x32, 0x66, 0x61, 0x37, 0x33, 0x62, 0x35, 0x66, 0x32, 0x31, 0x33, 0x36, 0x31, 0x63, 0x36, 0x33, 0x36, 0x36, 0x33, 0x62, 0x63, 0x33, 0x37, 0x32, 0x35, 0x61, 0x32, 0x36, 0x36, 0x37, 0x39, 0x62, 0x66, 0x32, 0x64, 0x65, 0x65, 0x66, 0x33, 0x61, 0x39, 0x61, 0x35, 0x36, 0x62, 0x39, 0x30, 0x65, 0x62, 0x64, 0x38, 0x34, 0x34, 0x65, 0x65, 0x66, 0x62, 0x63, 0x63, 0x66, 0x63, 0x34, 0x37, 0x66, 0x38, 0x38, 0x39, 0x39, 0x34, 0x34, 0x63, 0x31, 0x62, 0x39, 0x31, 0x64, 0x66, 0x39, 0x38, 0x32, 0x31, 0x33, 0x37, 0x62, 0x38, 0x31, 0x37, 0x32, 0x36, 0x35, 0x32, 0x61, 0x64, 0x39, 0x38, 0x34, 0x63, 0x39, 0x31, 0x30, 0x35, 0x37, 0x38, 0x37, 0x65, 0x36, 0x32, 0x38, 0x37, 0x34, 0x32, 0x33, 0x63, 0x66, 0x34, 0x32, 0x33, 0x37, 0x61, 0x31, 0x31, 0x62, 0x35, 0x63, 0x35, 0x61, 0x36, 0x35, 0x65, 0x38, 0x35, 0x33, 0x33, 0x65, 0x31, 0x36, 0x31, 0x31, 0x61, 0x38, 0x30, 0x35, 0x30, 0x35, 0x66, 0x32, 0x61, 0x31, 0x34, 0x38, 0x37, 0x32, 0x30, 0x35, 0x38, 0x62, 0x65, 0x38, 0x33, 0x64, 0x32, 0x38, 0x64, 0x33, 0x62, 0x62, 0x31, 0x61, 0x64, 0x34, 0x65, 0x65, 0x63, 0x36, 0x37, 0x62, 0x61, 0x35, 0x33, 0x37, 0x65, 0x36, 0x30, 0x31, 0x64, 0x61, 0x34, 0x37, 0x34, 0x33, 0x35, 0x33, 0x31, 0x39, 0x64, 0x32, 0x30, 0x31, 0x65, 0x34, 0x65, 0x36, 0x65, 0x32, 0x37, 0x30, 0x36, 0x66, 0x38, 0x62, 0x62, 0x63, 0x33, 0x37, 0x37, 0x32, 0x61, 0x37, 0x65, 0x63, 0x37, 0x36, 0x66, 0x35, 0x37, 0x30, 0x63, 0x32, 0x39, 0x37, 0x30, 0x37, 0x36, 0x31, 0x64, 0x64, 0x33, 0x36, 0x37, 0x36, 0x65, 0x32, 0x32, 0x64, 0x30, 0x64, 0x61, 0x38, 0x61, 0x61, 0x61, 0x64, 0x66, 0x62, 0x65, 0x31, 0x32, 0x30, 0x62, 0x36, 0x65, 0x66, 0x63, 0x62, 0x38, 0x66, 0x31, 0x65, 0x37, 0x64, 0x34, 0x39, 0x63, 0x31, 0x37, 0x64, 0x35, 0x62, 0x37, 0x32, 0x66, 0x37, 0x36, 0x38, 0x62, 0x30, 0x39, 0x39, 0x36, 0x63, 0x61, 0x62, 0x30, 0x63, 0x64, 0x31, 0x33, 0x36, 0x31, 0x38, 0x36, 0x36, 0x34, 0x35, 0x62, 0x65, 0x64, 0x35, 0x33, 0x64, 0x37, 0x35, 0x61, 0x35, 0x32, 0x33, 0x38, 0x63, 0x39, 0x30, 0x38, 0x36, 0x39, 0x61, 0x35, 0x37, 0x35, 0x63, 0x64, 0x61, 0x62, 0x33, 0x37, 0x62, 0x32, 0x61, 0x62, 0x31, 0x61, 0x30, 0x64, 0x37, 0x37, 0x32, 0x35, 0x39, 0x61, 0x63, 0x36, 0x39, 0x33, 0x34, 0x62, 0x35, 0x61, 0x38, 0x66, 0x37, 0x64, 0x61, 0x65, 0x31, 0x30, 0x30, 0x36, 0x37, 0x35, 0x62, 0x64, 0x32, 0x34, 0x65, 0x64, 0x32, 0x34, 0x64, 0x37, 0x37, 0x39, 0x61, 0x65, 0x62, 0x39, 0x38, 0x64, 0x61, 0x66, 0x31, 0x64, 0x61, 0x61, 0x64, 0x62, 0x33, 0x34, 0x66, 0x31, 0x30, 0x62, 0x62, 0x35, 0x65, 0x63, 0x32, 0x32, 0x61, 0x36, 0x36, 0x65, 0x34, 0x33, 0x32, 0x37, 0x31, 0x33, 0x63, 0x39, 0x62, 0x33, 0x36, 0x37, 0x65, 0x63, 0x64, 0x39, 0x31, 0x32, 0x39, 0x38, 0x63, 0x62, 0x62, 0x62, 0x63, 0x61, 0x34, 0x65, 0x32, 0x37, 0x66, 0x30, 0x33, 0x65, 0x33, 0x33, 0x32, 0x64, 0x39, 0x33, 0x66, 0x37, 0x32, 0x31, 0x65, 0x30, 0x38, 0x37, 0x38, 0x65, 0x66, 0x61, 0x39, 0x35, 0x30, 0x35, 0x62, 0x37, 0x61, 0x32, 0x36, 0x36, 0x30, 0x62, 0x36, 0x34, 0x33, 0x37, 0x30, 0x64, 0x33, 0x37, 0x62, 0x62, 0x37, 0x64, 0x30, 0x66, 0x64, 0x63, 0x34, 0x34, 0x34, 0x35, 0x38, 0x30, 0x36, 0x30, 0x38, 0x66, 0x61, 0x36, 0x34, 0x62, 0x61, 0x61, 0x65, 0x39, 0x37, 0x38, 0x31, 0x61, 0x65, 0x30, 0x31, 0x38, 0x62, 0x30, 0x35, 0x36, 0x39, 0x61, 0x64, 0x33, 0x61, 0x32, 0x33, 0x38, 0x61, 0x35, 0x35, 0x39, 0x36, 0x36, 0x62, 0x37, 0x32, 0x62, 0x36, 0x61, 0x63, 0x66, 0x66, 0x38, 0x30, 0x33, 0x62, 0x36, 0x39, 0x63, 0x31, 0x35, 0x66, 0x62, 0x61, 0x30, 0x38, 0x63, 0x65, 0x34, 0x32, 0x35, 0x38, 0x36, 0x34, 0x61, 0x39, 0x64, 0x38, 0x34, 0x34, 0x64, 0x63, 0x62, 0x35, 0x36, 0x32, 0x39, 0x39, 0x39, 0x39, 0x35, 0x36, 0x65, 0x61, 0x61, 0x30, 0x35, 0x39, 0x65, 0x34, 0x63, 0x62, 0x39, 0x38, 0x64, 0x33, 0x36, 0x32, 0x37, 0x32, 0x64, 0x64, 0x62, 0x33, 0x34, 0x30, 0x63, 0x34, 0x30, 0x35, 0x63, 0x36, 0x32, 0x30, 0x36, 0x36, 0x32, 0x38, 0x62, 0x61, 0x66, 0x65, 0x38, 0x63, 0x33, 0x34, 0x61, 0x36, 0x37, 0x63, 0x31, 0x36, 0x31, 0x66, 0x34, 0x63, 0x38, 0x64, 0x34, 0x36, 0x34, 0x35, 0x39, 0x63, 0x36, 0x31, 0x30, 0x62, 0x30, 0x38, 0x62, 0x61, 0x31, 0x62, 0x65, 0x62, 0x63, 0x32, 0x36, 0x34, 0x65, 0x65, 0x36, 0x37, 0x32, 0x61, 0x39, 0x65, 0x36, 0x35, 0x62, 0x33, 0x64, 0x63, 0x35, 0x36, 0x36, 0x38, 0x39, 0x39, 0x37, 0x32, 0x37, 0x64, 0x31, 0x38, 0x33, 0x38, 0x30, 0x34, 0x66, 0x65, 0x30, 0x32, 0x32, 0x32, 0x34, 0x30, 0x30, 0x39, 0x61, 0x39, 0x62, 0x31, 0x37, 0x30, 0x38, 0x65, 0x33, 0x36, 0x34, 0x63, 0x38, 0x65, 0x66, 0x36, 0x36, 0x37, 0x36, 0x37, 0x63, 0x37, 0x61, 0x63, 0x66, 0x38, 0x30, 0x34, 0x39, 0x66, 0x64, 0x63, 0x36, 0x64, 0x32, 0x30, 0x62, 0x61, 0x32, 0x34, 0x63, 0x32, 0x31, 0x39, 0x65, 0x36, 0x39, 0x62, 0x34, 0x39, 0x35, 0x38, 0x61, 0x32, 0x65, 0x30, 0x37, 0x30, 0x36, 0x31, 0x32, 0x38, 0x39, 0x37, 0x37, 0x66, 0x62, 0x31, 0x61, 0x61, 0x64, 0x39, 0x61, 0x35, 0x64, 0x64, 0x65, 0x65, 0x38, 0x38, 0x66, 0x38, 0x64, 0x37, 0x63, 0x66, 0x33, 0x65, 0x38, 0x39, 0x30, 0x31, 0x31, 0x38, 0x32, 0x36, 0x33, 0x64, 0x39, 0x32, 0x65, 0x36, 0x36, 0x39, 0x61, 0x34, 0x34, 0x30, 0x34, 0x33, 0x62, 0x33, 0x30, 0x37, 0x33, 0x34, 0x66, 0x35, 0x37, 0x36, 0x38, 0x30, 0x35, 0x30, 0x64, 0x34, 0x30, 0x61, 0x63, 0x30, 0x39, 0x63, 0x62, 0x65, 0x38, 0x64, 0x39, 0x35, 0x63, 0x64, 0x39, 0x34, 0x33, 0x36, 0x36, 0x31, 0x39, 0x66, 0x35, 0x65, 0x66, 0x34, 0x31, 0x38, 0x35, 0x32, 0x31, 0x38, 0x35, 0x36, 0x34, 0x37, 0x30, 0x39, 0x63, 0x66, 0x39, 0x32, 0x63, 0x66, 0x37, 0x38, 0x66, 0x37, 0x66, 0x38, 0x61, 0x36, 0x66, 0x32, 0x62, 0x32, 0x39, 0x32, 0x63, 0x30, 0x65, 0x64, 0x30, 0x38, 0x62, 0x65, 0x65, 0x31, 0x63, 0x31, 0x66, 0x31, 0x66, 0x38, 0x30, 0x33, 0x37, 0x64, 0x32, 0x32, 0x32, 0x63, 0x37, 0x36, 0x64, 0x65, 0x31, 0x62, 0x38, 0x62, 0x35, 0x65, 0x37, 0x32, 0x31, 0x64, 0x62, 0x36, 0x30, 0x30, 0x35, 0x33, 0x38, 0x30, 0x31, 0x64, 0x64, 0x31, 0x65, 0x39, 0x64, 0x35, 0x38, 0x30, 0x38, 0x63, 0x38, 0x34, 0x64, 0x38, 0x32, 0x30, 0x37, 0x33, 0x64, 0x36, 0x34, 0x35, 0x38, 0x38, 0x61, 0x64, 0x30, 0x38, 0x32, 0x66, 0x66, 0x32, 0x62, 0x32, 0x30, 0x62, 0x64, 0x33, 0x32, 0x66, 0x30, 0x35, 0x65, 0x34, 0x65, 0x30, 0x34, 0x30, 0x34, 0x32, 0x30, 0x33, 0x38, 0x33, 0x36, 0x33, 0x37, 0x37, 0x62, 0x38, 0x64, 0x33, 0x62, 0x38, 0x30, 0x63, 0x62, 0x35, 0x37, 0x62, 0x65, 0x32, 0x37, 0x38, 0x39, 0x38, 0x38, 0x33, 0x39, 0x64, 0x34, 0x36, 0x37, 0x33, 0x61, 0x30, 0x62, 0x36, 0x35, 0x63, 0x37, 0x62, 0x38, 0x61, 0x63, 0x38, 0x66, 0x66, 0x64, 0x31, 0x36, 0x63, 0x31, 0x63, 0x64, 0x61, 0x33, 0x35, 0x38, 0x63, 0x39, 0x62, 0x30, 0x61, 0x30, 0x38, 0x64, 0x39, 0x34, 0x66, 0x39, 0x61, 0x30, 0x64, 0x64, 0x31, 0x64, 0x38, 0x66, 0x65, 0x35, 0x63, 0x62, 0x39, 0x61, 0x66, 0x35, 0x61, 0x31, 0x34, 0x36, 0x38, 0x66, 0x33, 0x38, 0x66, 0x31, 0x30, 0x35, 0x31, 0x38, 0x62, 0x32, 0x31, 0x30, 0x32, 0x36, 0x65, 0x35, 0x30, 0x61, 0x36, 0x63, 0x65, 0x61, 0x37, 0x66, 0x61, 0x66, 0x63, 0x37, 0x36, 0x39, 0x39, 0x37, 0x35, 0x34, 0x35, 0x37, 0x32, 0x65, 0x38, 0x64, 0x66, 0x31, 0x39, 0x39, 0x30, 0x65, 0x64, 0x65, 0x35, 0x33, 0x66, 0x30, 0x63, 0x36, 0x66, 0x37, 0x61, 0x66, 0x30, 0x38, 0x65, 0x39, 0x39, 0x32, 0x34, 0x30, 0x38, 0x37, 0x34, 0x62, 0x66, 0x31, 0x35, 0x33, 0x33, 0x62, 0x64, 0x33, 0x66, 0x35, 0x39, 0x37, 0x35, 0x38, 0x38, 0x38, 0x34, 0x33, 0x64, 0x61, 0x33, 0x30, 0x65, 0x33, 0x66, 0x33, 0x37, 0x30, 0x39, 0x34, 0x63, 0x65, 0x35, 0x36, 0x32, 0x63, 0x62, 0x61, 0x34, 0x32, 0x65, 0x30, 0x65, 0x64, 0x66, 0x30, 0x35, 0x38, 0x36, 0x30, 0x30, 0x38, 0x39, 0x63, 0x30, 0x39, 0x38, 0x36, 0x30, 0x61, 0x38, 0x65, 0x38, 0x66, 0x66, 0x64, 0x35, 0x34, 0x63, 0x61, 0x35, 0x38, 0x37, 0x66, 0x61, 0x61, 0x34, 0x31, 0x66, 0x30, 0x31, 0x63, 0x31, 0x36, 0x33, 0x64, 0x36, 0x35, 0x62, 0x66, 0x39, 0x32, 0x31, 0x33, 0x39, 0x61, 0x35, 0x32, 0x39, 0x37, 0x35, 0x32, 0x61, 0x33, 0x35, 0x30, 0x65, 0x31, 0x36, 0x30, 0x31, 0x35, 0x63, 0x35, 0x61, 0x37, 0x32, 0x38, 0x62, 0x64, 0x38, 0x31, 0x34, 0x64, 0x34, 0x32, 0x64, 0x39, 0x33, 0x37, 0x39, 0x65, 0x34, 0x38, 0x64, 0x35, 0x32, 0x65, 0x30, 0x39, 0x32, 0x39, 0x34, 0x66, 0x36, 0x33, 0x36, 0x39, 0x33, 0x33, 0x36, 0x63, 0x62, 0x62, 0x33, 0x32, 0x66, 0x37, 0x32, 0x31, 0x65, 0x31, 0x61, 0x65, 0x39, 0x32, 0x30, 0x65, 0x30, 0x39, 0x36, 0x31, 0x37, 0x31, 0x66, 0x32, 0x35, 0x62, 0x62, 0x66, 0x61, 0x31, 0x66, 0x35, 0x36, 0x38, 0x64, 0x63, 0x61, 0x66, 0x39, 0x31, 0x39, 0x39, 0x61, 0x32, 0x31, 0x63, 0x35, 0x66, 0x63, 0x31, 0x36, 0x30, 0x39, 0x63, 0x35, 0x33, 0x36, 0x66, 0x35, 0x30, 0x38, 0x30, 0x64, 0x62, 0x61, 0x66, 0x62, 0x38, 0x37, 0x37, 0x32, 0x35, 0x30, 0x65, 0x34, 0x37, 0x39, 0x34, 0x66, 0x61, 0x31, 0x39, 0x64, 0x61, 0x39, 0x35, 0x30, 0x63, 0x39, 0x37, 0x39, 0x30, 0x65, 0x31, 0x30, 0x31, 0x62, 0x33, 0x61, 0x65, 0x36, 0x39, 0x62, 0x39, 0x32, 0x30, 0x34, 0x34, 0x30, 0x32, 0x34, 0x36, 0x32, 0x32, 0x66, 0x32, 0x65, 0x32, 0x64, 0x30, 0x66, 0x30, 0x62, 0x38, 0x34, 0x65, 0x66, 0x63, 0x63, 0x31, 0x32, 0x32, 0x62, 0x33, 0x37, 0x36, 0x30, 0x66, 0x33, 0x62, 0x37, 0x37, 0x38, 0x32, 0x32, 0x38, 0x63, 0x36, 0x36, 0x65, 0x61, 0x37, 0x62, 0x32, 0x62, 0x65, 0x66, 0x63, 0x35, 0x31, 0x38, 0x34, 0x62, 0x39, 0x39, 0x34, 0x33, 0x63, 0x31, 0x34, 0x30, 0x34, 0x37, 0x33, 0x65, 0x64, 0x34, 0x30, 0x61, 0x65, 0x33, 0x65, 0x64, 0x61, 0x37, 0x64, 0x30, 0x34, 0x37, 0x31, 0x31, 0x61, 0x66, 0x32, 0x35, 0x31, 0x33, 0x31, 0x33, 0x36, 0x33, 0x62, 0x38, 0x62, 0x35, 0x35, 0x39, 0x66, 0x39, 0x66, 0x36, 0x33, 0x35, 0x31, 0x64, 0x30, 0x33, 0x35, 0x39, 0x31, 0x37, 0x38, 0x38, 0x35, 0x33, 0x32, 0x62, 0x36, 0x61, 0x34, 0x32, 0x66, 0x61, 0x34, 0x65, 0x36, 0x34, 0x36, 0x37, 0x37, 0x62, 0x63, 0x38, 0x38, 0x35, 0x37, 0x33, 0x61, 0x30, 0x33, 0x33, 0x66, 0x35, 0x39, 0x63, 0x34, 0x61, 0x36, 0x33, 0x36, 0x66, 0x37, 0x32, 0x32, 0x37, 0x61, 0x37, 0x33, 0x33, 0x32, 0x36, 0x36, 0x31, 0x38, 0x36, 0x39, 0x65, 0x37, 0x37, 0x62, 0x37, 0x63, 0x36, 0x61, 0x37, 0x39, 0x65, 0x64, 0x33, 0x31, 0x31, 0x66, 0x33, 0x64, 0x39, 0x66, 0x33, 0x66, 0x38, 0x33, 0x65, 0x65, 0x31, 0x65, 0x65, 0x66, 0x32, 0x61, 0x39, 0x64, 0x65, 0x34, 0x63, 0x35, 0x37, 0x32, 0x34, 0x66, 0x63, 0x36, 0x36, 0x33, 0x33, 0x64, 0x61, 0x33, 0x32, 0x66, 0x66, 0x39, 0x36, 0x37, 0x33, 0x65, 0x62, 0x61, 0x37, 0x62, 0x61, 0x32, 0x35, 0x62, 0x34, 0x36, 0x36, 0x30, 0x38, 0x31, 0x34, 0x62, 0x31, 0x30, 0x30, 0x65, 0x63, 0x38, 0x38, 0x61, 0x32, 0x64, 0x62, 0x34, 0x38, 0x38, 0x34, 0x35, 0x39, 0x35, 0x62, 0x39, 0x35, 0x61, 0x38, 0x66, 0x32, 0x33, 0x65, 0x65, 0x35, 0x63, 0x38, 0x64, 0x61, 0x32, 0x61, 0x65, 0x34, 0x62, 0x65, 0x37, 0x32, 0x33, 0x65, 0x32, 0x62, 0x62, 0x65, 0x34, 0x33, 0x64, 0x30, 0x62, 0x66, 0x36, 0x39, 0x31, 0x64, 0x32, 0x62, 0x34, 0x36, 0x30, 0x64, 0x39, 0x65, 0x66, 0x39, 0x65, 0x38, 0x31, 0x36, 0x33, 0x38, 0x30, 0x32, 0x32, 0x37, 0x38, 0x62, 0x62, 0x36, 0x62, 0x30, 0x33, 0x33, 0x62, 0x35, 0x36, 0x31, 0x64, 0x31, 0x66, 0x35, 0x35, 0x63, 0x34, 0x35, 0x62, 0x31, 0x33, 0x37, 0x66, 0x61, 0x31, 0x39, 0x37, 0x35, 0x63, 0x61, 0x62, 0x39, 0x66, 0x38, 0x65, 0x64, 0x65, 0x65, 0x34, 0x65, 0x37, 0x61, 0x64, 0x31, 0x66, 0x38, 0x65, 0x35, 0x31, 0x37, 0x38, 0x30, 0x38, 0x65, 0x31, 0x32, 0x61, 0x34, 0x39, 0x66, 0x66, 0x62, 0x31, 0x33, 0x37, 0x34, 0x65, 0x62, 0x66, 0x37, 0x35, 0x63, 0x39, 0x38, 0x30, 0x65, 0x61, 0x66, 0x35, 0x66, 0x34, 0x32, 0x65, 0x61, 0x31, 0x34, 0x61, 0x33, 0x37, 0x32, 0x66, 0x64, 0x62, 0x66, 0x36, 0x32, 0x39, 0x31, 0x35, 0x64, 0x65, 0x62, 0x35, 0x66, 0x61, 0x62, 0x39, 0x61, 0x36, 0x62, 0x36, 0x64, 0x38, 0x66, 0x37, 0x30, 0x66, 0x30, 0x39, 0x62, 0x61, 0x39, 0x35, 0x33, 0x33, 0x37, 0x39, 0x39, 0x63, 0x38, 0x65, 0x62, 0x34, 0x66, 0x66, 0x34, 0x31, 0x61, 0x64, 0x34, 0x64, 0x38, 0x65, 0x36, 0x63, 0x36, 0x31, 0x61, 0x38, 0x32, 0x33, 0x30, 0x37, 0x32, 0x36, 0x38, 0x64, 0x36, 0x32, 0x31, 0x32, 0x35, 0x31, 0x37, 0x65, 0x31, 0x36, 0x38, 0x39, 0x66, 0x31, 0x65, 0x35, 0x64, 0x34, 0x39, 0x34, 0x30, 0x37, 0x64, 0x39, 0x34, 0x38, 0x64, 0x31, 0x61, 0x61, 0x37, 0x31, 0x62, 0x33, 0x65, 0x35, 0x35, 0x61, 0x63, 0x36, 0x33, 0x33, 0x64, 0x30, 0x65, 0x65, 0x65, 0x30, 0x32, 0x39, 0x32, 0x66, 0x36, 0x36, 0x34, 0x36, 0x63, 0x63, 0x63, 0x32, 0x65, 0x35, 0x36, 0x64, 0x34, 0x38, 0x30, 0x35, 0x65, 0x61, 0x31, 0x36, 0x31, 0x35, 0x62, 0x31, 0x63, 0x31, 0x37, 0x61, 0x36, 0x31, 0x33, 0x30, 0x37, 0x64, 0x36, 0x31, 0x31, 0x30, 0x30, 0x34, 0x62, 0x39, 0x33, 0x34, 0x30, 0x64, 0x33, 0x65, 0x31, 0x37, 0x63, 0x38, 0x36, 0x65, 0x66, 0x33, 0x31, 0x35, 0x66, 0x65, 0x37, 0x62, 0x38, 0x30, 0x34, 0x35, 0x36, 0x33, 0x65, 0x64, 0x31, 0x37, 0x32, 0x64, 0x33, 0x33, 0x64, 0x37, 0x64, 0x31, 0x62, 0x33, 0x62, 0x64, 0x30, 0x64, 0x61, 0x64, 0x33, 0x38, 0x66, 0x66, 0x34, 0x36, 0x34, 0x38, 0x65, 0x33, 0x63, 0x37, 0x61, 0x35, 0x37, 0x31, 0x34, 0x39, 0x39, 0x32, 0x37, 0x31, 0x31, 0x30, 0x36, 0x39, 0x66, 0x63, 0x66, 0x34, 0x62, 0x30, 0x39, 0x64, 0x33, 0x36, 0x30, 0x64, 0x63, 0x62, 0x61, 0x31, 0x34, 0x62, 0x39, 0x33, 0x64, 0x37, 0x32, 0x38, 0x32, 0x34, 0x66, 0x61, 0x39, 0x63, 0x65, 0x30, 0x35, 0x66, 0x31, 0x63, 0x63, 0x32, 0x38, 0x34, 0x62, 0x62, 0x36, 0x32, 0x38, 0x63, 0x37, 0x63, 0x61, 0x62, 0x36, 0x34, 0x64, 0x62, 0x38, 0x39, 0x36, 0x37, 0x37, 0x32, 0x38, 0x61, 0x65, 0x61, 0x33, 0x38, 0x38, 0x64, 0x37, 0x64, 0x35, 0x62, 0x30, 0x34, 0x33, 0x38, 0x66, 0x63, 0x63, 0x30, 0x64, 0x38, 0x37, 0x61, 0x35, 0x37, 0x32, 0x31, 0x31, 0x63, 0x66, 0x63, 0x36, 0x30, 0x62, 0x38, 0x35, 0x63, 0x37, 0x37, 0x62, 0x64, 0x66, 0x34, 0x63, 0x62, 0x33, 0x65, 0x39, 0x63, 0x64, 0x37, 0x63, 0x37, 0x61, 0x34, 0x63, 0x61, 0x31, 0x36, 0x39, 0x33, 0x30, 0x35, 0x38, 0x34, 0x32, 0x31, 0x63, 0x30, 0x33, 0x34, 0x64, 0x37, 0x36, 0x63, 0x31, 0x38, 0x38, 0x65, 0x39, 0x66, 0x65, 0x31, 0x30, 0x66, 0x38, 0x33, 0x66, 0x34, 0x37, 0x65, 0x38, 0x32, 0x38, 0x39, 0x34, 0x66, 0x31, 0x34, 0x34, 0x36, 0x39, 0x38, 0x34, 0x38, 0x37, 0x33, 0x62, 0x62, 0x31, 0x35, 0x32, 0x32, 0x62, 0x63, 0x63, 0x62, 0x64, 0x62, 0x31, 0x65, 0x64, 0x32, 0x31, 0x31, 0x31, 0x35, 0x38, 0x35, 0x62, 0x37, 0x62, 0x32, 0x32, 0x64, 0x36, 0x35, 0x38, 0x65, 0x64, 0x31, 0x38, 0x65, 0x32, 0x37, 0x32, 0x62, 0x66, 0x33, 0x34, 0x30, 0x64, 0x37, 0x32, 0x66, 0x62, 0x39, 0x34, 0x36, 0x35, 0x35, 0x39, 0x31, 0x36, 0x38, 0x32, 0x62, 0x63, 0x61, 0x61, 0x37, 0x31, 0x62, 0x34, 0x63, 0x30, 0x36, 0x31, 0x38, 0x66, 0x39, 0x32, 0x62, 0x30, 0x39, 0x30, 0x34, 0x31, 0x66, 0x66, 0x37, 0x36, 0x30, 0x39, 0x66, 0x34, 0x63, 0x33, 0x65, 0x36, 0x64, 0x30, 0x37, 0x32, 0x35, 0x63, 0x39, 0x62, 0x61, 0x63, 0x61, 0x64, 0x36, 0x65, 0x35, 0x39, 0x37, 0x32, 0x31, 0x31, 0x30, 0x36, 0x35, 0x33, 0x39, 0x37, 0x32, 0x34, 0x64, 0x30, 0x32, 0x66, 0x63, 0x39, 0x66, 0x62, 0x65, 0x33, 0x32, 0x35, 0x66, 0x64, 0x30, 0x33, 0x36, 0x31, 0x64, 0x39, 0x63, 0x63, 0x62, 0x30, 0x31, 0x34, 0x30, 0x63, 0x39, 0x35, 0x35, 0x38, 0x39, 0x66, 0x64, 0x62, 0x32, 0x39, 0x61, 0x35, 0x64, 0x63, 0x31, 0x63, 0x66, 0x32, 0x31, 0x63, 0x64, 0x65, 0x31, 0x30, 0x37, 0x31, 0x38, 0x66, 0x35, 0x64, 0x64, 0x63, 0x36, 0x62, 0x33, 0x32, 0x64, 0x37, 0x33, 0x64, 0x39, 0x37, 0x61, 0x66, 0x62, 0x63, 0x36, 0x36, 0x63, 0x65, 0x62, 0x61, 0x65, 0x36, 0x35, 0x32, 0x62, 0x35, 0x34, 0x33, 0x38, 0x61, 0x31, 0x39, 0x32, 0x33, 0x39, 0x64, 0x65, 0x38, 0x39, 0x37, 0x38, 0x30, 0x64, 0x61, 0x35, 0x64, 0x30, 0x66, 0x36, 0x39, 0x34, 0x36, 0x63, 0x33, 0x63, 0x33, 0x37, 0x32, 0x61, 0x35, 0x39, 0x30, 0x61, 0x66, 0x61, 0x36, 0x66, 0x62, 0x31, 0x66, 0x30, 0x63, 0x64, 0x38, 0x32, 0x39, 0x30, 0x34, 0x66, 0x32, 0x38, 0x36, 0x38, 0x63, 0x62, 0x65, 0x65, 0x35, 0x62, 0x35, 0x61, 0x63, 0x36, 0x66, 0x32, 0x62, 0x32, 0x62, 0x36, 0x65, 0x66, 0x30, 0x39, 0x64, 0x65, 0x38, 0x63, 0x64, 0x39, 0x63, 0x61, 0x39, 0x66, 0x36, 0x33, 0x65, 0x35, 0x30, 0x61, 0x65, 0x30, 0x64, 0x30, 0x63, 0x36, 0x62, 0x31, 0x61, 0x32, 0x31, 0x61, 0x31, 0x30, 0x37, 0x37, 0x64, 0x61, 0x36, 0x38, 0x31, 0x36, 0x62, 0x37, 0x38, 0x31, 0x31, 0x35, 0x65, 0x34, 0x64, 0x65, 0x38, 0x32, 0x65, 0x63, 0x38, 0x36, 0x64, 0x36, 0x33, 0x38, 0x33, 0x37, 0x66, 0x33, 0x37, 0x31, 0x65, 0x34, 0x62, 0x61, 0x35, 0x33, 0x33, 0x64, 0x64, 0x32, 0x38, 0x64, 0x62, 0x38, 0x34, 0x61, 0x38, 0x37, 0x32, 0x37, 0x61, 0x34, 0x39, 0x63, 0x61, 0x63, 0x63, 0x30, 0x61, 0x63, 0x31, 0x30, 0x33, 0x63, 0x62, 0x39, 0x38, 0x37, 0x36, 0x39, 0x63, 0x39, 0x37, 0x33, 0x39, 0x32, 0x39, 0x32, 0x62, 0x64, 0x36, 0x35, 0x31, 0x65, 0x30, 0x30, 0x30, 0x65, 0x38, 0x31, 0x38, 0x66, 0x30, 0x37, 0x39, 0x62, 0x63, 0x30, 0x34, 0x34, 0x38, 0x34, 0x64, 0x64, 0x31, 0x32, 0x34, 0x66, 0x34, 0x31, 0x64, 0x35, 0x34, 0x37, 0x30, 0x66, 0x63, 0x64, 0x38, 0x66, 0x64, 0x34, 0x66, 0x35, 0x34, 0x65, 0x35, 0x64, 0x32, 0x66, 0x37, 0x30, 0x34, 0x37, 0x39, 0x34, 0x38, 0x62, 0x65, 0x64, 0x62, 0x37, 0x64, 0x66, 0x31, 0x34, 0x61, 0x33, 0x62, 0x32, 0x31, 0x30, 0x66, 0x64, 0x65, 0x39, 0x33, 0x65, 0x32, 0x39, 0x65, 0x64, 0x30, 0x35, 0x64, 0x31, 0x39, 0x63, 0x34, 0x37, 0x32, 0x34, 0x36, 0x37, 0x30, 0x30, 0x35, 0x61, 0x65, 0x35, 0x36, 0x31, 0x36, 0x31, 0x35, 0x64, 0x34, 0x66, 0x39, 0x62, 0x30, 0x35, 0x30, 0x33, 0x61, 0x64, 0x33, 0x30, 0x32, 0x33, 0x62, 0x62, 0x34, 0x63, 0x31, 0x32, 0x38, 0x63, 0x35, 0x31, 0x33, 0x61, 0x36, 0x38, 0x63, 0x65, 0x36, 0x61, 0x61, 0x30, 0x61, 0x33, 0x30, 0x63, 0x63, 0x35, 0x63, 0x62, 0x63, 0x31, 0x64, 0x38, 0x66, 0x39, 0x35, 0x36, 0x62, 0x35, 0x39, 0x34, 0x32, 0x35, 0x30, 0x65, 0x35, 0x31, 0x34, 0x31, 0x61, 0x31, 0x64, 0x37, 0x33, 0x33, 0x30, 0x30, 0x62, 0x65, 0x63, 0x38, 0x30, 0x61, 0x34, 0x33, 0x62, 0x35, 0x39, 0x35, 0x62, 0x64, 0x62, 0x32, 0x62, 0x63, 0x66, 0x37, 0x63, 0x61, 0x37, 0x62, 0x62, 0x64, 0x31, 0x36, 0x36, 0x63, 0x62, 0x30, 0x34, 0x35, 0x38, 0x30, 0x34, 0x63, 0x36, 0x34, 0x62, 0x36, 0x31, 0x32, 0x34, 0x63, 0x39, 0x37, 0x32, 0x66, 0x33, 0x35, 0x38, 0x66, 0x35, 0x65, 0x63, 0x33, 0x38, 0x63, 0x34, 0x63, 0x66, 0x64, 0x31, 0x31, 0x65, 0x31, 0x32, 0x61, 0x65, 0x36, 0x62, 0x34, 0x34, 0x31, 0x33, 0x32, 0x62, 0x66, 0x62, 0x32, 0x38, 0x35, 0x34, 0x66, 0x64, 0x35, 0x30, 0x66, 0x66, 0x32, 0x61, 0x66, 0x35, 0x39, 0x62, 0x33, 0x38, 0x63, 0x31, 0x37, 0x62, 0x64, 0x38, 0x65, 0x62, 0x66, 0x61, 0x36, 0x36, 0x37, 0x32, 0x31, 0x37, 0x64, 0x34, 0x65, 0x39, 0x38, 0x62, 0x66, 0x38, 0x39, 0x31, 0x38, 0x31, 0x33, 0x37, 0x30, 0x63, 0x63, 0x65, 0x37, 0x35, 0x33, 0x30, 0x30, 0x63, 0x32, 0x39, 0x30, 0x37, 0x36, 0x37, 0x62, 0x62, 0x33, 0x62, 0x62, 0x65, 0x65, 0x33, 0x37, 0x64, 0x66, 0x38, 0x31, 0x33, 0x37, 0x62, 0x38, 0x66, 0x31, 0x31, 0x35, 0x36, 0x66, 0x62, 0x61, 0x36, 0x38, 0x35, 0x63, 0x65, 0x37, 0x32, 0x30, 0x64, 0x36, 0x31, 0x31, 0x66, 0x32, 0x34, 0x61, 0x38, 0x62, 0x30, 0x31, 0x38, 0x65, 0x38, 0x34, 0x38, 0x30, 0x39, 0x34, 0x39, 0x33, 0x36, 0x66, 0x35, 0x62, 0x31, 0x35, 0x64, 0x64, 0x38, 0x31, 0x38, 0x32, 0x35, 0x66, 0x64, 0x65, 0x64, 0x32, 0x64, 0x37, 0x64, 0x38, 0x62, 0x31, 0x31, 0x61, 0x62, 0x63, 0x35, 0x30, 0x38, 0x61, 0x32, 0x36, 0x65, 0x64, 0x63, 0x66, 0x38, 0x37, 0x32, 0x32, 0x39, 0x33, 0x64, 0x33, 0x61, 0x33, 0x36, 0x35, 0x32, 0x65, 0x65, 0x64, 0x39, 0x61, 0x34, 0x63, 0x35, 0x33, 0x32, 0x32, 0x33, 0x32, 0x39, 0x65, 0x66, 0x65, 0x66, 0x61, 0x64, 0x30, 0x66, 0x39, 0x62, 0x66, 0x34, 0x31, 0x63, 0x63, 0x37, 0x31, 0x66, 0x30, 0x31, 0x63, 0x37, 0x32, 0x30, 0x31, 0x30, 0x63, 0x66, 0x36, 0x37, 0x61, 0x66, 0x38, 0x61, 0x30, 0x39, 0x32, 0x63, 0x37, 0x32, 0x64, 0x62, 0x39, 0x31, 0x38, 0x63, 0x32, 0x63, 0x62, 0x66, 0x31, 0x37, 0x66, 0x31, 0x34, 0x64, 0x64, 0x35, 0x39, 0x35, 0x36, 0x38, 0x64, 0x33, 0x64, 0x38, 0x35, 0x64, 0x38, 0x34, 0x33, 0x35, 0x65, 0x37, 0x33, 0x62, 0x62, 0x30, 0x34, 0x31, 0x30, 0x38, 0x34, 0x63, 0x36, 0x30, 0x37, 0x65, 0x65, 0x64, 0x38, 0x34, 0x34, 0x38, 0x39, 0x64, 0x65, 0x63, 0x39, 0x35, 0x64, 0x35, 0x36, 0x33, 0x31, 0x66, 0x35, 0x35, 0x32, 0x32, 0x34, 0x38, 0x62, 0x36, 0x66, 0x33, 0x30, 0x65, 0x36, 0x39, 0x62, 0x61, 0x32, 0x65, 0x65, 0x34, 0x37, 0x39, 0x30, 0x39, 0x61, 0x38, 0x63, 0x36, 0x65, 0x61, 0x62, 0x34, 0x37, 0x35, 0x34, 0x61, 0x61, 0x38, 0x62, 0x66, 0x36, 0x35, 0x30, 0x34, 0x39, 0x34, 0x38, 0x33, 0x31, 0x37, 0x36, 0x38, 0x63, 0x39, 0x62, 0x61, 0x38, 0x33, 0x37, 0x61, 0x36, 0x36, 0x65, 0x35, 0x30, 0x30, 0x62, 0x39, 0x32, 0x38, 0x32, 0x30, 0x61, 0x39, 0x35, 0x65, 0x33, 0x65, 0x39, 0x31, 0x34, 0x65, 0x66, 0x36, 0x34, 0x39, 0x61, 0x65, 0x31, 0x66, 0x35, 0x65, 0x65, 0x65, 0x38, 0x39, 0x36, 0x62, 0x32, 0x38, 0x38, 0x33, 0x36, 0x63, 0x38, 0x38, 0x36, 0x34, 0x33, 0x63, 0x39, 0x61, 0x63, 0x64, 0x33, 0x31, 0x39, 0x61, 0x36, 0x32, 0x38, 0x30, 0x64, 0x36, 0x37, 0x32, 0x63, 0x36, 0x61, 0x32, 0x35, 0x36, 0x36, 0x39, 0x30, 0x39, 0x66, 0x34, 0x64, 0x31, 0x66, 0x61, 0x35, 0x37, 0x38, 0x33, 0x65, 0x61, 0x33, 0x39, 0x32, 0x65, 0x62, 0x61, 0x63, 0x33, 0x30, 0x64, 0x61, 0x65, 0x33, 0x34, 0x66, 0x38, 0x36, 0x63, 0x66, 0x34, 0x38, 0x61, 0x32, 0x32, 0x38, 0x39, 0x39, 0x33, 0x34, 0x66, 0x64, 0x39, 0x35, 0x33, 0x36, 0x35, 0x31, 0x36, 0x31, 0x39, 0x37, 0x32, 0x34, 0x35, 0x32, 0x30, 0x62, 0x64, 0x63, 0x37, 0x34, 0x39, 0x31, 0x61, 0x37, 0x30, 0x30, 0x32, 0x66, 0x37, 0x64, 0x30, 0x36, 0x32, 0x37, 0x31, 0x34, 0x38, 0x34, 0x38, 0x33, 0x34, 0x64, 0x39, 0x39, 0x37, 0x63, 0x32, 0x30, 0x37, 0x38, 0x38, 0x35, 0x39, 0x39, 0x34, 0x63, 0x37, 0x62, 0x32, 0x66, 0x39, 0x34, 0x64, 0x62, 0x33, 0x36, 0x37, 0x36, 0x64, 0x61, 0x36, 0x39, 0x62, 0x37, 0x32, 0x38, 0x35, 0x39, 0x36, 0x36, 0x65, 0x65, 0x37, 0x37, 0x62, 0x35, 0x35, 0x34, 0x65, 0x65, 0x38, 0x35, 0x63, 0x37, 0x64, 0x36, 0x39, 0x37, 0x33, 0x39, 0x66, 0x38, 0x32, 0x64, 0x33, 0x37, 0x33, 0x61, 0x62, 0x31, 0x38, 0x65, 0x33, 0x63, 0x37, 0x39, 0x36, 0x63, 0x64, 0x31, 0x32, 0x35, 0x64, 0x32, 0x35, 0x66, 0x39, 0x31, 0x65, 0x66, 0x62, 0x38, 0x39, 0x37, 0x65, 0x34, 0x35, 0x35, 0x32, 0x36, 0x35, 0x63, 0x64, 0x32, 0x33, 0x63, 0x63, 0x65, 0x37, 0x64, 0x35, 0x37, 0x61, 0x31, 0x39, 0x34, 0x37, 0x34, 0x62, 0x39, 0x62, 0x66, 0x36, 0x31, 0x36, 0x31, 0x30, 0x30, 0x31, 0x34, 0x39, 0x62, 0x31, 0x61, 0x62, 0x64, 0x65, 0x39, 0x39, 0x39, 0x61, 0x62, 0x63, 0x37, 0x33, 0x61, 0x64, 0x35, 0x31, 0x64, 0x36, 0x37, 0x64, 0x36, 0x32, 0x65, 0x63, 0x34, 0x65, 0x63, 0x38, 0x37, 0x32, 0x33, 0x37, 0x38, 0x38, 0x61, 0x30, 0x61, 0x38, 0x62, 0x62, 0x63, 0x63, 0x39, 0x63, 0x65, 0x32, 0x65, 0x65, 0x65, 0x62, 0x31, 0x39, 0x65, 0x38, 0x38, 0x64, 0x64, 0x63, 0x63, 0x66, 0x66, 0x35, 0x34, 0x30, 0x63, 0x37, 0x64, 0x37, 0x36, 0x66, 0x64, 0x64, 0x65, 0x66, 0x65, 0x65, 0x33, 0x39, 0x36, 0x37, 0x36, 0x30, 0x66, 0x66, 0x61, 0x36, 0x63, 0x62, 0x62, 0x30, 0x38, 0x64, 0x35, 0x65, 0x65, 0x33, 0x32, 0x34, 0x37, 0x66, 0x38, 0x30, 0x66, 0x38, 0x37, 0x32, 0x30, 0x63, 0x66, 0x39, 0x30, 0x34, 0x35, 0x62, 0x62, 0x61, 0x36, 0x36, 0x30, 0x36, 0x31, 0x31, 0x34, 0x38, 0x33, 0x38, 0x32, 0x34, 0x34, 0x32, 0x39, 0x63, 0x36, 0x63, 0x61, 0x31, 0x34, 0x34, 0x30, 0x36, 0x31, 0x61, 0x30, 0x66, 0x63, 0x30, 0x63, 0x62, 0x63, 0x64, 0x66, 0x66, 0x33, 0x39, 0x64, 0x30, 0x37, 0x32, 0x33, 0x63, 0x38, 0x33, 0x37, 0x31, 0x36, 0x39, 0x31, 0x63, 0x63, 0x62, 0x36, 0x30, 0x31, 0x38, 0x63, 0x65, 0x36, 0x35, 0x39, 0x61, 0x31, 0x30, 0x62, 0x64, 0x39, 0x65, 0x63, 0x36, 0x35, 0x30, 0x66, 0x33, 0x63, 0x64, 0x65, 0x36, 0x35, 0x61, 0x34, 0x64, 0x63, 0x33, 0x38, 0x32, 0x33, 0x30, 0x65, 0x35, 0x65, 0x36, 0x65, 0x39, 0x37, 0x66, 0x36, 0x30, 0x30, 0x61, 0x64, 0x37, 0x37, 0x32, 0x38, 0x38, 0x35, 0x62, 0x35, 0x66, 0x31, 0x66, 0x65, 0x66, 0x37, 0x64, 0x38, 0x61, 0x38, 0x38, 0x64, 0x30, 0x33, 0x61, 0x34, 0x63, 0x30, 0x39, 0x33, 0x39, 0x31, 0x38, 0x39, 0x35, 0x62, 0x37, 0x34, 0x34, 0x34, 0x31, 0x35, 0x33, 0x38, 0x32, 0x39, 0x63, 0x30, 0x34, 0x38, 0x35, 0x33, 0x65, 0x35, 0x35, 0x62, 0x33, 0x31, 0x62, 0x62, 0x66, 0x34, 0x33, 0x32, 0x35, 0x38, 0x62, 0x35, 0x66, 0x36, 0x38, 0x35, 0x35, 0x37, 0x30, 0x37, 0x38, 0x63, 0x31, 0x61, 0x31, 0x61, 0x63, 0x36, 0x64, 0x63, 0x63, 0x32, 0x39, 0x64, 0x33, 0x33, 0x37, 0x36, 0x66, 0x31, 0x61, 0x39, 0x63, 0x66, 0x34, 0x35, 0x34, 0x39, 0x34, 0x32, 0x63, 0x63, 0x61, 0x63, 0x36, 0x39, 0x30, 0x63, 0x66, 0x38, 0x31, 0x32, 0x31, 0x62, 0x32, 0x61, 0x63, 0x65, 0x36, 0x66, 0x62, 0x66, 0x34, 0x63, 0x34, 0x37, 0x32, 0x34, 0x35, 0x38, 0x65, 0x36, 0x38, 0x36, 0x39, 0x61, 0x39, 0x64, 0x36, 0x61, 0x34, 0x36, 0x32, 0x30, 0x65, 0x63, 0x36, 0x35, 0x39, 0x32, 0x63, 0x62, 0x31, 0x34, 0x66, 0x63, 0x62, 0x65, 0x37, 0x33, 0x66, 0x32, 0x32, 0x65, 0x36, 0x35, 0x62, 0x30, 0x61, 0x66, 0x63, 0x65, 0x34, 0x66, 0x65, 0x64, 0x62, 0x64, 0x35, 0x63, 0x32, 0x38, 0x31, 0x33, 0x33, 0x37, 0x64, 0x39, 0x30, 0x37, 0x32, 0x63, 0x66, 0x61, 0x32, 0x31, 0x31, 0x65, 0x34, 0x36, 0x39, 0x63, 0x61, 0x35, 0x30, 0x64, 0x34, 0x30, 0x62, 0x64, 0x36, 0x30, 0x66, 0x30, 0x35, 0x64, 0x31, 0x36, 0x38, 0x31, 0x61, 0x66, 0x36, 0x31, 0x64, 0x38, 0x65, 0x30, 0x37, 0x64, 0x33, 0x66, 0x62, 0x31, 0x63, 0x34, 0x38, 0x33, 0x39, 0x65, 0x36, 0x66, 0x64, 0x61, 0x62, 0x33, 0x31, 0x30, 0x62, 0x63, 0x61, 0x64, 0x36, 0x30, 0x33, 0x36, 0x63, 0x39, 0x30, 0x64, 0x34, 0x64, 0x30, 0x62, 0x66, 0x31, 0x62, 0x65, 0x35, 0x65, 0x38, 0x32, 0x32, 0x64, 0x33, 0x63, 0x34, 0x32, 0x39, 0x62, 0x35, 0x37, 0x63, 0x37, 0x33, 0x38, 0x33, 0x31, 0x65, 0x66, 0x61, 0x36, 0x39, 0x63, 0x36, 0x32, 0x65, 0x37, 0x33, 0x33, 0x63, 0x39, 0x64, 0x39, 0x32, 0x35, 0x36, 0x37, 0x33, 0x65, 0x36, 0x35, 0x36, 0x38, 0x37, 0x39, 0x34, 0x35, 0x39, 0x61, 0x31, 0x66, 0x64, 0x32, 0x37, 0x38, 0x62, 0x39, 0x33, 0x64, 0x38, 0x66, 0x32, 0x36, 0x33, 0x37, 0x36, 0x33, 0x34, 0x65, 0x37, 0x65, 0x30, 0x30, 0x30, 0x61, 0x66, 0x38, 0x64, 0x31, 0x65, 0x66, 0x36, 0x34, 0x63, 0x32, 0x31, 0x33, 0x65, 0x61, 0x33, 0x37, 0x36, 0x65, 0x62, 0x65, 0x65, 0x64, 0x32, 0x63, 0x38, 0x35, 0x38, 0x64, 0x34, 0x30, 0x39, 0x61, 0x36, 0x31, 0x65, 0x37, 0x32, 0x61, 0x64, 0x39, 0x30, 0x65, 0x34, 0x39, 0x64, 0x36, 0x31, 0x36, 0x30, 0x62, 0x34, 0x34, 0x32, 0x34, 0x34, 0x64, 0x61, 0x32, 0x64, 0x30, 0x66, 0x62, 0x64, 0x62, 0x39, 0x35, 0x37, 0x38, 0x63, 0x35, 0x66, 0x36, 0x62, 0x63, 0x39, 0x62, 0x64, 0x38, 0x39, 0x31, 0x63, 0x37, 0x61, 0x38, 0x64, 0x32, 0x61, 0x35, 0x36, 0x66, 0x61, 0x33, 0x64, 0x31, 0x32, 0x64, 0x30, 0x39, 0x30, 0x33, 0x63, 0x30, 0x64, 0x38, 0x33, 0x39, 0x62, 0x63, 0x34, 0x32, 0x66, 0x32, 0x64, 0x31, 0x61, 0x37, 0x65, 0x31, 0x34, 0x62, 0x39, 0x63, 0x32, 0x62, 0x37, 0x31, 0x61, 0x38, 0x34, 0x34, 0x66, 0x30, 0x65, 0x64, 0x33, 0x65, 0x32, 0x38, 0x33, 0x39, 0x31, 0x30, 0x39, 0x63, 0x30, 0x66, 0x37, 0x35, 0x38, 0x39, 0x39, 0x30, 0x32, 0x63, 0x33, 0x39, 0x30, 0x63, 0x32, 0x32, 0x31, 0x34, 0x61, 0x36, 0x61, 0x34, 0x66, 0x63, 0x65, 0x33, 0x61, 0x32, 0x64, 0x63, 0x36, 0x31, 0x39, 0x37, 0x35, 0x65, 0x37, 0x36, 0x39, 0x37, 0x35, 0x30, 0x64, 0x38, 0x30, 0x35, 0x39, 0x64, 0x33, 0x39, 0x34, 0x31, 0x38, 0x33, 0x38, 0x32, 0x34, 0x33, 0x37, 0x30, 0x62, 0x36, 0x31, 0x30, 0x64, 0x62, 0x32, 0x35, 0x63, 0x64, 0x32, 0x61, 0x35, 0x66, 0x64, 0x34, 0x63, 0x34, 0x62, 0x63, 0x32, 0x39, 0x35, 0x37, 0x32, 0x32, 0x66, 0x63, 0x64, 0x33, 0x64, 0x62, 0x62, 0x37, 0x36, 0x37, 0x64, 0x33, 0x62, 0x66, 0x62, 0x65, 0x36, 0x34, 0x38, 0x36, 0x65, 0x33, 0x31, 0x39, 0x37, 0x36, 0x38, 0x34, 0x38, 0x33, 0x64, 0x36, 0x62, 0x64, 0x32, 0x33, 0x66, 0x64, 0x38, 0x35, 0x39, 0x63, 0x39, 0x38, 0x38, 0x33, 0x37, 0x66, 0x63, 0x36, 0x31, 0x30, 0x36, 0x61, 0x35, 0x31, 0x32, 0x61, 0x65, 0x65, 0x31, 0x35, 0x35, 0x39, 0x66, 0x66, 0x31, 0x31, 0x36, 0x36, 0x34, 0x33, 0x32, 0x66, 0x61, 0x38, 0x35, 0x39, 0x32, 0x34, 0x33, 0x63, 0x62, 0x32, 0x39, 0x35, 0x33, 0x36, 0x37, 0x35, 0x61, 0x32, 0x34, 0x39, 0x31, 0x33, 0x63, 0x32, 0x66, 0x63, 0x61, 0x64, 0x39, 0x33, 0x65, 0x37, 0x61, 0x36, 0x37, 0x30, 0x32, 0x30, 0x61, 0x35, 0x62, 0x39, 0x61, 0x30, 0x37, 0x66, 0x39, 0x39, 0x32, 0x66, 0x30, 0x37, 0x32, 0x37, 0x35, 0x38, 0x37, 0x66, 0x33, 0x63, 0x31, 0x62, 0x33, 0x36, 0x66, 0x31, 0x34, 0x62, 0x31, 0x61, 0x31, 0x62, 0x32, 0x31, 0x37, 0x66, 0x34, 0x38, 0x31, 0x64, 0x66, 0x32, 0x35, 0x30, 0x64, 0x38, 0x35, 0x62, 0x31, 0x65, 0x39, 0x66, 0x66, 0x32, 0x31, 0x62, 0x62, 0x63, 0x62, 0x66, 0x62, 0x36, 0x32, 0x38, 0x65, 0x34, 0x35, 0x30, 0x61, 0x36, 0x63, 0x33, 0x64, 0x39, 0x34, 0x36, 0x62, 0x63, 0x35, 0x33, 0x31, 0x37, 0x66, 0x39, 0x30, 0x36, 0x64, 0x35, 0x32, 0x35, 0x32, 0x38, 0x38, 0x32, 0x30, 0x62, 0x61, 0x30, 0x64, 0x39, 0x39, 0x64, 0x64, 0x66, 0x30, 0x36, 0x38, 0x61, 0x39, 0x34, 0x30, 0x35, 0x39, 0x31, 0x36, 0x61, 0x31, 0x30, 0x36, 0x33, 0x33, 0x64, 0x37, 0x36, 0x32, 0x31, 0x31, 0x65, 0x39, 0x39, 0x34, 0x62, 0x34, 0x39, 0x61, 0x31, 0x61, 0x39, 0x31, 0x37, 0x32, 0x37, 0x35, 0x31, 0x30, 0x37, 0x35, 0x30, 0x35, 0x39, 0x33, 0x33, 0x36, 0x65, 0x37, 0x37, 0x64, 0x63, 0x37, 0x35, 0x38, 0x61, 0x32, 0x64, 0x36, 0x37, 0x35, 0x65, 0x30, 0x64, 0x31, 0x33, 0x39, 0x64, 0x32, 0x66, 0x30, 0x38, 0x38, 0x32, 0x39, 0x63, 0x38, 0x61, 0x33, 0x31, 0x62, 0x38, 0x34, 0x32, 0x62, 0x33, 0x62, 0x61, 0x35, 0x35, 0x36, 0x63, 0x62, 0x36, 0x64, 0x64, 0x39, 0x33, 0x30, 0x34, 0x66, 0x39, 0x39, 0x38, 0x62, 0x37, 0x34, 0x39, 0x63, 0x66, 0x35, 0x37, 0x65, 0x31, 0x32, 0x66, 0x31, 0x37, 0x66, 0x63, 0x36, 0x34, 0x66, 0x36, 0x39, 0x65, 0x62, 0x66, 0x32, 0x38, 0x61, 0x66, 0x36, 0x38, 0x63, 0x33, 0x39, 0x65, 0x34, 0x62, 0x37, 0x62, 0x31, 0x33, 0x34, 0x38, 0x63, 0x64, 0x36, 0x35, 0x38, 0x34, 0x32, 0x30, 0x62, 0x35, 0x65, 0x33, 0x62, 0x34, 0x34, 0x37, 0x32, 0x34, 0x61, 0x30, 0x64, 0x65, 0x37, 0x64, 0x64, 0x37, 0x30, 0x32, 0x35, 0x31, 0x37, 0x64, 0x64, 0x37, 0x35, 0x38, 0x66, 0x33, 0x63, 0x33, 0x31, 0x33, 0x32, 0x36, 0x64, 0x63, 0x33, 0x65, 0x33, 0x35, 0x65, 0x64, 0x65, 0x66, 0x65, 0x65, 0x35, 0x39, 0x35, 0x30, 0x32, 0x63, 0x64, 0x65, 0x31, 0x64, 0x34, 0x65, 0x64, 0x30, 0x65, 0x30, 0x63, 0x39, 0x61, 0x62, 0x34, 0x37, 0x33, 0x37, 0x32, 0x31, 0x65, 0x31, 0x61, 0x32, 0x35, 0x64, 0x61, 0x66, 0x39, 0x38, 0x30, 0x63, 0x39, 0x32, 0x63, 0x32, 0x64, 0x30, 0x32, 0x66, 0x32, 0x65, 0x39, 0x36, 0x61, 0x66, 0x30, 0x35, 0x30, 0x36, 0x66, 0x62, 0x62, 0x66, 0x64, 0x38, 0x39, 0x38, 0x66, 0x32, 0x36, 0x61, 0x64, 0x30, 0x34, 0x36, 0x39, 0x37, 0x37, 0x34, 0x30, 0x38, 0x30, 0x63, 0x31, 0x36, 0x66, 0x30, 0x30, 0x39, 0x38, 0x37, 0x32, 0x61, 0x30, 0x34, 0x32, 0x61, 0x31, 0x62, 0x33, 0x39, 0x30, 0x34, 0x35, 0x65, 0x62, 0x33, 0x66, 0x35, 0x38, 0x37, 0x66, 0x31, 0x32, 0x66, 0x66, 0x36, 0x62, 0x31, 0x35, 0x38, 0x61, 0x34, 0x34, 0x66, 0x34, 0x66, 0x36, 0x36, 0x63, 0x32, 0x66, 0x30, 0x63, 0x38, 0x30, 0x64, 0x32, 0x37, 0x32, 0x39, 0x39, 0x34, 0x30, 0x36, 0x66, 0x34, 0x62, 0x37, 0x37, 0x33, 0x36, 0x38, 0x31, 0x37, 0x32, 0x64, 0x31, 0x31, 0x39, 0x66, 0x37, 0x64, 0x66, 0x30, 0x38, 0x32, 0x33, 0x36, 0x33, 0x63, 0x64, 0x39, 0x66, 0x32, 0x39, 0x38, 0x30, 0x37, 0x32, 0x37, 0x35, 0x37, 0x66, 0x65, 0x61, 0x37, 0x66, 0x37, 0x32, 0x31, 0x37, 0x64, 0x36, 0x30, 0x63, 0x39, 0x62, 0x61, 0x33, 0x37, 0x65, 0x31, 0x32, 0x36, 0x63, 0x37, 0x31, 0x65, 0x30, 0x63, 0x33, 0x38, 0x66, 0x65, 0x36, 0x63, 0x34, 0x37, 0x32, 0x65, 0x63, 0x36, 0x33, 0x30, 0x33, 0x32, 0x38, 0x32, 0x64, 0x35, 0x30, 0x64, 0x39, 0x37, 0x62, 0x32, 0x63, 0x39, 0x63, 0x66, 0x34, 0x64, 0x35, 0x30, 0x36, 0x34, 0x31, 0x61, 0x34, 0x34, 0x31, 0x38, 0x31, 0x65, 0x38, 0x36, 0x63, 0x33, 0x63, 0x34, 0x62, 0x35, 0x39, 0x32, 0x37, 0x62, 0x64, 0x63, 0x65, 0x37, 0x34, 0x38, 0x30, 0x64, 0x38, 0x64, 0x33, 0x30, 0x30, 0x61, 0x62, 0x37, 0x32, 0x38, 0x64, 0x32, 0x61, 0x61, 0x61, 0x36, 0x62, 0x61, 0x66, 0x37, 0x30, 0x32, 0x33, 0x37, 0x35, 0x35, 0x30, 0x63, 0x61, 0x36, 0x62, 0x61, 0x62, 0x31, 0x62, 0x33, 0x38, 0x36, 0x38, 0x31, 0x39, 0x37, 0x65, 0x38, 0x30, 0x35, 0x37, 0x31, 0x36, 0x64, 0x36, 0x64, 0x37, 0x32, 0x33, 0x38, 0x37, 0x33, 0x65, 0x64, 0x38, 0x65, 0x61, 0x32, 0x66, 0x66, 0x36, 0x65, 0x34, 0x30, 0x31, 0x37, 0x32, 0x66, 0x32, 0x32, 0x64, 0x64, 0x34, 0x39, 0x61, 0x62, 0x62, 0x39, 0x30, 0x36, 0x30, 0x38, 0x38, 0x31, 0x32, 0x63, 0x34, 0x35, 0x62, 0x36, 0x64, 0x38, 0x64, 0x63, 0x39, 0x33, 0x63, 0x63, 0x62, 0x39, 0x37, 0x38, 0x65, 0x61, 0x37, 0x35, 0x66, 0x34, 0x64, 0x30, 0x33, 0x39, 0x36, 0x37, 0x37, 0x38, 0x37, 0x33, 0x61, 0x35, 0x64, 0x63, 0x34, 0x32, 0x31, 0x38, 0x63, 0x31, 0x31, 0x31, 0x35, 0x31, 0x30, 0x62, 0x65, 0x31, 0x38, 0x33, 0x39, 0x37, 0x32, 0x61, 0x34, 0x64, 0x65, 0x31, 0x63, 0x62, 0x37, 0x61, 0x65, 0x65, 0x31, 0x35, 0x32, 0x63, 0x35, 0x35, 0x36, 0x66, 0x66, 0x30, 0x34, 0x38, 0x66, 0x35, 0x62, 0x37, 0x63, 0x33, 0x32, 0x65, 0x66, 0x63, 0x33, 0x33, 0x63, 0x61, 0x35, 0x64, 0x64, 0x34, 0x38, 0x32, 0x33, 0x32, 0x62, 0x36, 0x61, 0x66, 0x62, 0x34, 0x30, 0x32, 0x34, 0x62, 0x37, 0x61, 0x30, 0x38, 0x66, 0x38, 0x61, 0x38, 0x66, 0x30, 0x39, 0x64, 0x37, 0x31, 0x34, 0x34, 0x65, 0x64, 0x65, 0x36, 0x64, 0x63, 0x63, 0x39, 0x61, 0x33, 0x64, 0x65, 0x62, 0x63, 0x61, 0x63, 0x64, 0x65, 0x65, 0x62, 0x61, 0x37, 0x66, 0x38, 0x37, 0x32, 0x39, 0x34, 0x35, 0x34, 0x33, 0x63, 0x36, 0x30, 0x34, 0x61, 0x64, 0x32, 0x66, 0x66, 0x66, 0x66, 0x35, 0x39, 0x30, 0x37, 0x32, 0x38, 0x34, 0x30, 0x64, 0x31, 0x66, 0x36, 0x33, 0x39, 0x33, 0x39, 0x62, 0x33, 0x37, 0x32, 0x36, 0x36, 0x36, 0x65, 0x38, 0x66, 0x33, 0x62, 0x62, 0x63, 0x37, 0x66, 0x35, 0x61, 0x36, 0x38, 0x34, 0x63, 0x65, 0x61, 0x31, 0x39, 0x65, 0x66, 0x37, 0x65, 0x35, 0x65, 0x65, 0x38, 0x66, 0x65, 0x61, 0x38, 0x63, 0x39, 0x39, 0x31, 0x33, 0x61, 0x39, 0x64, 0x35, 0x39, 0x34, 0x31, 0x32, 0x36, 0x65, 0x66, 0x37, 0x61, 0x65, 0x63, 0x39, 0x31, 0x33, 0x30, 0x32, 0x37, 0x31, 0x65, 0x63, 0x64, 0x31, 0x62, 0x33, 0x37, 0x34, 0x32, 0x31, 0x66, 0x38, 0x66, 0x31, 0x37, 0x63, 0x37, 0x39, 0x31, 0x38, 0x33, 0x30, 0x33, 0x31, 0x33, 0x30, 0x66, 0x66, 0x61, 0x66, 0x66, 0x35, 0x31, 0x35, 0x35, 0x31, 0x65, 0x64, 0x38, 0x37, 0x33, 0x63, 0x61, 0x32, 0x35, 0x35, 0x36, 0x39, 0x30, 0x64, 0x37, 0x32, 0x38, 0x39, 0x34, 0x32, 0x65, 0x64, 0x38, 0x65, 0x34, 0x31, 0x63, 0x64, 0x63, 0x62, 0x37, 0x65, 0x63, 0x65, 0x64, 0x36, 0x36, 0x36, 0x37, 0x34, 0x37, 0x33, 0x66, 0x63, 0x32, 0x62, 0x35, 0x37, 0x30, 0x61, 0x62, 0x66, 0x33, 0x38, 0x66, 0x31, 0x37, 0x66, 0x30, 0x63, 0x64, 0x36, 0x66, 0x66, 0x63, 0x65, 0x39, 0x35, 0x35, 0x35, 0x64, 0x65, 0x36, 0x34, 0x34, 0x66, 0x65, 0x62, 0x37, 0x32, 0x38, 0x30, 0x64, 0x66, 0x62, 0x63, 0x35, 0x33, 0x30, 0x66, 0x65, 0x31, 0x34, 0x63, 0x39, 0x34, 0x36, 0x63, 0x34, 0x33, 0x63, 0x31, 0x66, 0x36, 0x65, 0x37, 0x62, 0x35, 0x36, 0x31, 0x65, 0x31, 0x37, 0x32, 0x66, 0x36, 0x36, 0x32, 0x64, 0x64, 0x36, 0x32, 0x35, 0x35, 0x39, 0x64, 0x66, 0x33, 0x31, 0x62, 0x32, 0x35, 0x61, 0x64, 0x64, 0x65, 0x61, 0x65, 0x35, 0x39, 0x30, 0x38, 0x30, 0x32, 0x39, 0x66, 0x37, 0x38, 0x33, 0x65, 0x30, 0x64, 0x62, 0x35, 0x63, 0x37, 0x39, 0x61, 0x63, 0x62, 0x35, 0x39, 0x65, 0x34, 0x66, 0x39, 0x65, 0x36, 0x61, 0x36, 0x30, 0x32, 0x65, 0x37, 0x65, 0x35, 0x38, 0x63, 0x36, 0x36, 0x36, 0x66, 0x30, 0x34, 0x39, 0x34, 0x37, 0x31, 0x30, 0x36, 0x37, 0x32, 0x66, 0x65, 0x63, 0x37, 0x36, 0x35, 0x33, 0x31, 0x39, 0x36, 0x33, 0x66, 0x62, 0x38, 0x30, 0x36, 0x61, 0x35, 0x33, 0x61, 0x33, 0x34, 0x63, 0x34, 0x36, 0x62, 0x64, 0x39, 0x63, 0x34, 0x31, 0x36, 0x32, 0x66, 0x36, 0x39, 0x34, 0x34, 0x39, 0x31, 0x34, 0x38, 0x36, 0x35, 0x66, 0x63, 0x63, 0x64, 0x31, 0x62, 0x31, 0x64, 0x31, 0x33, 0x31, 0x37, 0x39, 0x62, 0x64, 0x65, 0x36, 0x66, 0x63, 0x39, 0x64, 0x65, 0x30, 0x35, 0x63, 0x63, 0x30, 0x32, 0x30, 0x65, 0x62, 0x62, 0x34, 0x32, 0x37, 0x32, 0x38, 0x63, 0x64, 0x66, 0x63, 0x65, 0x34, 0x35, 0x38, 0x34, 0x64, 0x61, 0x64, 0x33, 0x35, 0x63, 0x39, 0x30, 0x31, 0x37, 0x32, 0x33, 0x64, 0x32, 0x63, 0x64, 0x65, 0x34, 0x39, 0x63, 0x39, 0x35, 0x33, 0x38, 0x66, 0x66, 0x61, 0x31, 0x35, 0x66, 0x65, 0x62, 0x61, 0x38, 0x39, 0x63, 0x62, 0x35, 0x32, 0x65, 0x34, 0x64, 0x36, 0x36, 0x33, 0x66, 0x31, 0x65, 0x66, 0x61, 0x34, 0x36, 0x37, 0x32, 0x63, 0x32, 0x39, 0x37, 0x34, 0x33, 0x34, 0x61, 0x39, 0x30, 0x39, 0x30, 0x37, 0x64, 0x35, 0x64, 0x66, 0x32, 0x33, 0x64, 0x33, 0x65, 0x66, 0x39, 0x33, 0x61, 0x32, 0x63, 0x36, 0x65, 0x34, 0x32, 0x34, 0x37, 0x39, 0x37, 0x36, 0x63, 0x36, 0x33, 0x35, 0x66, 0x39, 0x36, 0x64, 0x62, 0x36, 0x31, 0x37, 0x35, 0x65, 0x33, 0x30, 0x32, 0x33, 0x63, 0x37, 0x66, 0x30, 0x32, 0x34, 0x66, 0x37, 0x32, 0x63, 0x35, 0x66, 0x32, 0x30, 0x36, 0x39, 0x38, 0x33, 0x64, 0x32, 0x32, 0x35, 0x62, 0x64, 0x62, 0x39, 0x33, 0x63, 0x66, 0x39, 0x39, 0x35, 0x34, 0x31, 0x61, 0x66, 0x61, 0x65, 0x38, 0x31, 0x65, 0x31, 0x38, 0x63, 0x34, 0x37, 0x36, 0x65, 0x34, 0x64, 0x35, 0x61, 0x66, 0x62, 0x39, 0x62, 0x32, 0x33, 0x64, 0x65, 0x61, 0x62, 0x33, 0x65, 0x31, 0x61, 0x61, 0x65, 0x64, 0x33, 0x31, 0x37, 0x32, 0x66, 0x63, 0x30, 0x61, 0x66, 0x62, 0x66, 0x61, 0x61, 0x64, 0x61, 0x62, 0x66, 0x61, 0x37, 0x63, 0x61, 0x38, 0x63, 0x61, 0x62, 0x30, 0x38, 0x38, 0x32, 0x30, 0x64, 0x39, 0x61, 0x66, 0x36, 0x66, 0x66, 0x34, 0x31, 0x61, 0x37, 0x37, 0x37, 0x39, 0x36, 0x63, 0x61, 0x35, 0x64, 0x38, 0x30, 0x63, 0x35, 0x62, 0x36, 0x64, 0x62, 0x62, 0x38, 0x63, 0x65, 0x65, 0x66, 0x37, 0x37, 0x66, 0x37, 0x32, 0x39, 0x32, 0x33, 0x65, 0x30, 0x66, 0x63, 0x31, 0x38, 0x35, 0x37, 0x64, 0x66, 0x61, 0x36, 0x32, 0x63, 0x63, 0x62, 0x65, 0x32, 0x35, 0x64, 0x65, 0x35, 0x64, 0x30, 0x62, 0x62, 0x31, 0x32, 0x34, 0x37, 0x33, 0x34, 0x65, 0x39, 0x61, 0x35, 0x31, 0x32, 0x61, 0x62, 0x62, 0x37, 0x61, 0x37, 0x30, 0x66, 0x31, 0x33, 0x38, 0x63, 0x64, 0x35, 0x34, 0x63, 0x63, 0x63, 0x31, 0x65, 0x35, 0x37, 0x32, 0x35, 0x36, 0x65, 0x35, 0x62, 0x37, 0x61, 0x38, 0x36, 0x64, 0x33, 0x37, 0x34, 0x37, 0x34, 0x30, 0x32, 0x39, 0x62, 0x38, 0x38, 0x35, 0x61, 0x38, 0x62, 0x37, 0x38, 0x36, 0x64, 0x37, 0x39, 0x30, 0x38, 0x36, 0x31, 0x64, 0x38, 0x35, 0x36, 0x33, 0x33, 0x34, 0x32, 0x66, 0x34, 0x33, 0x61, 0x32, 0x32, 0x33, 0x36, 0x31, 0x33, 0x63, 0x33, 0x33, 0x61, 0x65, 0x64, 0x38, 0x63, 0x64, 0x37, 0x32, 0x65, 0x31, 0x36, 0x33, 0x37, 0x63, 0x64, 0x61, 0x61, 0x63, 0x38, 0x33, 0x31, 0x35, 0x36, 0x62, 0x37, 0x30, 0x34, 0x30, 0x66, 0x62, 0x38, 0x61, 0x62, 0x36, 0x62, 0x31, 0x64, 0x39, 0x62, 0x63, 0x61, 0x36, 0x61, 0x38, 0x61, 0x66, 0x64, 0x34, 0x30, 0x37, 0x64, 0x37, 0x33, 0x65, 0x39, 0x30, 0x30, 0x35, 0x64, 0x66, 0x66, 0x34, 0x61, 0x36, 0x64, 0x63, 0x33, 0x34, 0x62, 0x38, 0x31, 0x30, 0x34, 0x64, 0x35, 0x35, 0x36, 0x64, 0x39, 0x65, 0x38, 0x36, 0x64, 0x38, 0x38, 0x35, 0x63, 0x62, 0x33, 0x63, 0x65, 0x66, 0x64, 0x35, 0x65, 0x33, 0x64, 0x38, 0x30, 0x65, 0x34, 0x38, 0x38, 0x38, 0x31, 0x30, 0x39, 0x32, 0x34, 0x36, 0x64, 0x35, 0x35, 0x37, 0x34, 0x65, 0x66, 0x31, 0x66, 0x63, 0x33, 0x39, 0x65, 0x30, 0x31, 0x33, 0x33, 0x38, 0x32, 0x31, 0x65, 0x65, 0x31, 0x64, 0x37, 0x32, 0x64, 0x32, 0x66, 0x64, 0x35, 0x34, 0x34, 0x39, 0x32, 0x61, 0x37, 0x63, 0x36, 0x34, 0x34, 0x38, 0x35, 0x35, 0x64, 0x38, 0x37, 0x33, 0x30, 0x61, 0x61, 0x66, 0x63, 0x64, 0x36, 0x64, 0x61, 0x64, 0x65, 0x63, 0x66, 0x64, 0x61, 0x63, 0x36, 0x34, 0x62, 0x35, 0x66, 0x36, 0x63, 0x64, 0x65, 0x34, 0x30, 0x30, 0x30, 0x33, 0x63, 0x64, 0x63, 0x61, 0x62, 0x38, 0x39, 0x62, 0x36, 0x37, 0x37, 0x32, 0x38, 0x38, 0x35, 0x32, 0x33, 0x30, 0x39, 0x31, 0x31, 0x36, 0x30, 0x35, 0x61, 0x38, 0x31, 0x66, 0x62, 0x38, 0x38, 0x32, 0x31, 0x65, 0x37, 0x37, 0x66, 0x63, 0x33, 0x35, 0x36, 0x34, 0x33, 0x39, 0x61, 0x36, 0x39, 0x34, 0x62, 0x36, 0x35, 0x63, 0x61, 0x63, 0x33, 0x65, 0x61, 0x31, 0x32, 0x32, 0x35, 0x64, 0x37, 0x38, 0x30, 0x32, 0x66, 0x64, 0x32, 0x39, 0x39, 0x63, 0x64, 0x33, 0x36, 0x30, 0x38, 0x31, 0x36, 0x37, 0x33, 0x65, 0x32, 0x37, 0x39, 0x39, 0x30, 0x64, 0x38, 0x62, 0x33, 0x64, 0x66, 0x39, 0x39, 0x66, 0x63, 0x31, 0x39, 0x38, 0x37, 0x32, 0x64, 0x33, 0x65, 0x39, 0x62, 0x37, 0x33, 0x37, 0x30, 0x30, 0x33, 0x62, 0x36, 0x37, 0x36, 0x35, 0x66, 0x66, 0x37, 0x31, 0x31, 0x31, 0x30, 0x31, 0x38, 0x66, 0x61, 0x63, 0x38, 0x66, 0x66, 0x32, 0x38, 0x62, 0x34, 0x32, 0x30, 0x61, 0x32, 0x34, 0x37, 0x38, 0x37, 0x35, 0x35, 0x30, 0x35, 0x64, 0x62, 0x32, 0x39, 0x32, 0x39, 0x35, 0x63, 0x34, 0x32, 0x62, 0x66, 0x63, 0x65, 0x61, 0x35, 0x39, 0x63, 0x33, 0x32, 0x64, 0x61, 0x37, 0x32, 0x64, 0x61, 0x35, 0x34, 0x30, 0x61, 0x61, 0x66, 0x30, 0x64, 0x32, 0x32, 0x34, 0x38, 0x33, 0x34, 0x30, 0x38, 0x33, 0x64, 0x30, 0x39, 0x37, 0x62, 0x37, 0x32, 0x31, 0x39, 0x37, 0x37, 0x32, 0x31, 0x38, 0x36, 0x66, 0x31, 0x35, 0x34, 0x33, 0x64, 0x39, 0x34, 0x64, 0x36, 0x64, 0x38, 0x37, 0x66, 0x35, 0x62, 0x64, 0x34, 0x32, 0x39, 0x37, 0x61, 0x39, 0x66, 0x39, 0x35, 0x61, 0x64, 0x63, 0x66, 0x39, 0x31, 0x32, 0x34, 0x33, 0x30, 0x39, 0x61, 0x64, 0x37, 0x64, 0x39, 0x38, 0x38, 0x37, 0x61, 0x61, 0x34, 0x34, 0x33, 0x37, 0x62, 0x35, 0x35, 0x32, 0x64, 0x32, 0x31, 0x37, 0x37, 0x32, 0x30, 0x64, 0x39, 0x36, 0x66, 0x31, 0x66, 0x39, 0x34, 0x35, 0x36, 0x65, 0x35, 0x62, 0x31, 0x63, 0x33, 0x32, 0x63, 0x64, 0x62, 0x63, 0x34, 0x33, 0x33, 0x66, 0x31, 0x39, 0x39, 0x32, 0x62, 0x32, 0x66, 0x31, 0x36, 0x62, 0x30, 0x30, 0x38, 0x63, 0x61, 0x37, 0x38, 0x65, 0x39, 0x39, 0x38, 0x63, 0x36, 0x31, 0x64, 0x31, 0x66, 0x38, 0x35, 0x38, 0x36, 0x30, 0x30, 0x65, 0x63, 0x63, 0x37, 0x32, 0x30, 0x30, 0x35, 0x37, 0x32, 0x65, 0x38, 0x32, 0x34, 0x66, 0x37, 0x65, 0x39, 0x33, 0x33, 0x62, 0x32, 0x62, 0x63, 0x39, 0x64, 0x65, 0x63, 0x64, 0x37, 0x64, 0x65, 0x33, 0x34, 0x65, 0x39, 0x39, 0x31, 0x39, 0x61, 0x65, 0x66, 0x63, 0x34, 0x66, 0x37, 0x39, 0x39, 0x31, 0x66, 0x37, 0x31, 0x64, 0x38, 0x33, 0x30, 0x39, 0x61, 0x66, 0x65, 0x61, 0x61, 0x33, 0x32, 0x35, 0x36, 0x62, 0x37, 0x32, 0x38, 0x30, 0x63, 0x62, 0x65, 0x65, 0x63, 0x33, 0x64, 0x37, 0x31, 0x35, 0x63, 0x37, 0x38, 0x65, 0x39, 0x35, 0x38, 0x37, 0x63, 0x38, 0x61, 0x64, 0x61, 0x38, 0x35, 0x33, 0x37, 0x37, 0x35, 0x39, 0x65, 0x34, 0x32, 0x30, 0x66, 0x62, 0x33, 0x37, 0x32, 0x32, 0x37, 0x39, 0x37, 0x39, 0x37, 0x30, 0x61, 0x36, 0x38, 0x30, 0x66, 0x62, 0x39, 0x64, 0x30, 0x30, 0x31, 0x31, 0x38, 0x61, 0x35, 0x62, 0x35, 0x66, 0x32, 0x31, 0x63, 0x62, 0x37, 0x33, 0x30, 0x65, 0x61, 0x36, 0x62, 0x65, 0x61, 0x33, 0x61, 0x30, 0x64, 0x38, 0x38, 0x64, 0x63, 0x39, 0x35, 0x66, 0x31, 0x38, 0x37, 0x61, 0x34, 0x36, 0x65, 0x63, 0x31, 0x35, 0x66, 0x66, 0x30, 0x39, 0x64, 0x66, 0x62, 0x64, 0x62, 0x63, 0x63, 0x34, 0x63, 0x37, 0x32, 0x33, 0x32, 0x32, 0x61, 0x36, 0x62, 0x31, 0x30, 0x61, 0x32, 0x33, 0x34, 0x37, 0x37, 0x61, 0x39, 0x62, 0x38, 0x63, 0x62, 0x61, 0x66, 0x36, 0x38, 0x35, 0x37, 0x36, 0x37, 0x62, 0x64, 0x39, 0x66, 0x32, 0x34, 0x64, 0x32, 0x37, 0x35, 0x38, 0x34, 0x64, 0x33, 0x61, 0x30, 0x62, 0x37, 0x66, 0x36, 0x62, 0x62, 0x31, 0x35, 0x33, 0x37, 0x30, 0x30, 0x31, 0x34, 0x32, 0x36, 0x34, 0x33, 0x34, 0x36, 0x30, 0x65, 0x32, 0x64, 0x36, 0x31, 0x34, 0x37, 0x31, 0x61, 0x34, 0x36, 0x35, 0x31, 0x66, 0x61, 0x61, 0x33, 0x37, 0x63, 0x66, 0x31, 0x34, 0x39, 0x36, 0x61, 0x64, 0x32, 0x61, 0x35, 0x62, 0x65, 0x31, 0x66, 0x38, 0x64, 0x39, 0x62, 0x30, 0x31, 0x65, 0x62, 0x63, 0x66, 0x35, 0x32, 0x62, 0x34, 0x39, 0x36, 0x37, 0x65, 0x64, 0x35, 0x39, 0x31, 0x64, 0x32, 0x34, 0x64, 0x30, 0x30, 0x32, 0x34, 0x32, 0x39, 0x34, 0x65, 0x63, 0x32, 0x33, 0x35, 0x35, 0x34, 0x36, 0x37, 0x32, 0x35, 0x62, 0x62, 0x34, 0x34, 0x32, 0x64, 0x31, 0x66, 0x30, 0x38, 0x31, 0x61, 0x65, 0x37, 0x34, 0x33, 0x37, 0x63, 0x39, 0x35, 0x66, 0x32, 0x37, 0x61, 0x38, 0x65, 0x66, 0x63, 0x33, 0x37, 0x36, 0x66, 0x38, 0x64, 0x33, 0x35, 0x65, 0x33, 0x64, 0x34, 0x62, 0x39, 0x63, 0x34, 0x35, 0x35, 0x38, 0x37, 0x61, 0x38, 0x37, 0x31, 0x34, 0x65, 0x37, 0x37, 0x32, 0x62, 0x33, 0x62, 0x64, 0x30, 0x66, 0x37, 0x62, 0x62, 0x33, 0x30, 0x32, 0x32, 0x33, 0x32, 0x30, 0x63, 0x36, 0x31, 0x61, 0x62, 0x33, 0x37, 0x35, 0x31, 0x65, 0x64, 0x31, 0x39, 0x39, 0x62, 0x66, 0x38, 0x34, 0x30, 0x33, 0x35, 0x61, 0x32, 0x62, 0x66, 0x30, 0x30, 0x32, 0x31, 0x31, 0x64, 0x34, 0x64, 0x39, 0x63, 0x36, 0x32, 0x34, 0x33, 0x37, 0x65, 0x63, 0x34, 0x31, 0x33, 0x61, 0x62, 0x34, 0x65, 0x39, 0x64, 0x30, 0x37, 0x32, 0x36, 0x39, 0x36, 0x34, 0x65, 0x38, 0x62, 0x33, 0x64, 0x38, 0x66, 0x32, 0x65, 0x39, 0x31, 0x32, 0x34, 0x30, 0x36, 0x66, 0x65, 0x62, 0x62, 0x35, 0x35, 0x62, 0x63, 0x30, 0x65, 0x31, 0x37, 0x37, 0x36, 0x39, 0x34, 0x30, 0x65, 0x61, 0x62, 0x31, 0x37, 0x61, 0x64, 0x38, 0x35, 0x38, 0x64, 0x61, 0x39, 0x38, 0x35, 0x66, 0x32, 0x62, 0x61, 0x39, 0x34, 0x34, 0x39, 0x32, 0x65, 0x65, 0x34, 0x64, 0x34, 0x31, 0x38, 0x35, 0x35, 0x62, 0x65, 0x39, 0x61, 0x30, 0x33, 0x31, 0x39, 0x63, 0x39, 0x64, 0x35, 0x66, 0x64, 0x32, 0x30, 0x32, 0x63, 0x66, 0x61, 0x35, 0x64, 0x38, 0x33, 0x30, 0x36, 0x62, 0x36, 0x39, 0x39, 0x39, 0x61, 0x38, 0x37, 0x30, 0x66, 0x30, 0x62, 0x64, 0x62, 0x34, 0x65, 0x32, 0x36, 0x39, 0x34, 0x65, 0x33, 0x64, 0x35, 0x36, 0x32, 0x62, 0x62, 0x33, 0x32, 0x32, 0x35, 0x64, 0x33, 0x61, 0x36, 0x30, 0x33, 0x33, 0x62, 0x34, 0x37, 0x36, 0x62, 0x38, 0x39, 0x34, 0x66, 0x35, 0x65, 0x64, 0x38, 0x63, 0x37, 0x36, 0x32, 0x63, 0x38, 0x66, 0x33, 0x37, 0x36, 0x36, 0x32, 0x35, 0x38, 0x34, 0x36, 0x34, 0x39, 0x32, 0x33, 0x39, 0x35, 0x61, 0x38, 0x34, 0x36, 0x34, 0x65, 0x62, 0x34, 0x65, 0x66, 0x33, 0x66, 0x36, 0x34, 0x65, 0x61, 0x30, 0x61, 0x33, 0x30, 0x64, 0x37, 0x32, 0x39, 0x61, 0x34, 0x66, 0x31, 0x32, 0x39, 0x61, 0x35, 0x33, 0x38, 0x38, 0x33, 0x35, 0x66, 0x65, 0x36, 0x31, 0x33, 0x33, 0x66, 0x31, 0x35, 0x32, 0x61, 0x33, 0x33, 0x64, 0x35, 0x39, 0x62, 0x39, 0x30, 0x36, 0x32, 0x64, 0x36, 0x64, 0x39, 0x34, 0x63, 0x31, 0x63, 0x65, 0x63, 0x63, 0x63, 0x38, 0x30, 0x66, 0x33, 0x33, 0x34, 0x66, 0x37, 0x34, 0x62, 0x33, 0x37, 0x33, 0x33, 0x32, 0x37, 0x32, 0x30, 0x36, 0x61, 0x62, 0x36, 0x33, 0x35, 0x39, 0x64, 0x61, 0x33, 0x32, 0x65, 0x66, 0x66, 0x61, 0x39, 0x32, 0x32, 0x33, 0x39, 0x66, 0x38, 0x64, 0x65, 0x34, 0x37, 0x36, 0x30, 0x34, 0x35, 0x62, 0x34, 0x30, 0x66, 0x35, 0x34, 0x37, 0x32, 0x35, 0x34, 0x38, 0x34, 0x64, 0x36, 0x62, 0x31, 0x33, 0x33, 0x66, 0x36, 0x30, 0x30, 0x34, 0x33, 0x61, 0x34, 0x62, 0x35, 0x30, 0x35, 0x31, 0x37, 0x32, 0x39, 0x34, 0x33, 0x61, 0x65, 0x33, 0x34, 0x31, 0x35, 0x33, 0x34, 0x35, 0x35, 0x32, 0x62, 0x61, 0x38, 0x66, 0x65, 0x62, 0x63, 0x38, 0x61, 0x39, 0x35, 0x64, 0x66, 0x31, 0x32, 0x35, 0x36, 0x64, 0x38, 0x35, 0x36, 0x34, 0x30, 0x62, 0x38, 0x61, 0x30, 0x38, 0x33, 0x36, 0x66, 0x66, 0x39, 0x32, 0x66, 0x33, 0x32, 0x66, 0x39, 0x62, 0x33, 0x63, 0x38, 0x32, 0x35, 0x63, 0x31, 0x39, 0x37, 0x32, 0x31, 0x34, 0x33, 0x61, 0x37, 0x65, 0x65, 0x35, 0x31, 0x31, 0x31, 0x31, 0x64, 0x38, 0x37, 0x37, 0x34, 0x31, 0x61, 0x33, 0x62, 0x35, 0x39, 0x36, 0x63, 0x66, 0x65, 0x38, 0x37, 0x66, 0x31, 0x30, 0x63, 0x30, 0x65, 0x31, 0x62, 0x62, 0x66, 0x37, 0x66, 0x39, 0x61, 0x62, 0x63, 0x36, 0x34, 0x31, 0x61, 0x64, 0x35, 0x30, 0x36, 0x66, 0x62, 0x66, 0x66, 0x63, 0x61, 0x36, 0x34, 0x34, 0x37, 0x32, 0x66, 0x38, 0x62, 0x63, 0x64, 0x34, 0x64, 0x65, 0x38, 0x66, 0x37, 0x32, 0x61, 0x35, 0x38, 0x66, 0x31, 0x35, 0x30, 0x37, 0x33, 0x63, 0x33, 0x36, 0x35, 0x36, 0x31, 0x64, 0x30, 0x35, 0x61, 0x62, 0x64, 0x64, 0x65, 0x32, 0x62, 0x39, 0x34, 0x33, 0x65, 0x33, 0x34, 0x34, 0x64, 0x36, 0x37, 0x35, 0x61, 0x66, 0x65, 0x61, 0x31, 0x38, 0x38, 0x62, 0x37, 0x61, 0x33, 0x61, 0x30, 0x30, 0x37, 0x32, 0x30, 0x37, 0x36, 0x37, 0x30, 0x65, 0x37, 0x38, 0x33, 0x31, 0x34, 0x63, 0x62, 0x39, 0x33, 0x63, 0x32, 0x37, 0x64, 0x38, 0x38, 0x64, 0x61, 0x33, 0x62, 0x35, 0x35, 0x64, 0x30, 0x63, 0x36, 0x39, 0x32, 0x39, 0x31, 0x66, 0x62, 0x61, 0x61, 0x38, 0x38, 0x30, 0x32, 0x63, 0x30, 0x36, 0x37, 0x32, 0x66, 0x63, 0x36, 0x34, 0x64, 0x30, 0x33, 0x37, 0x65, 0x64, 0x66, 0x36, 0x62, 0x34, 0x36, 0x32, 0x64, 0x30, 0x37, 0x34, 0x38, 0x64, 0x61, 0x39, 0x38, 0x34, 0x36, 0x32, 0x62, 0x32, 0x36, 0x62, 0x66, 0x38, 0x36, 0x36, 0x61, 0x61, 0x66, 0x62, 0x37, 0x31, 0x61, 0x61, 0x66, 0x66, 0x36, 0x38, 0x38, 0x31, 0x64, 0x39, 0x30, 0x37, 0x39, 0x34, 0x63, 0x31, 0x65, 0x61, 0x33, 0x33, 0x33, 0x35, 0x33, 0x39, 0x63, 0x66, 0x37, 0x61, 0x30, 0x61, 0x62, 0x39, 0x65, 0x30, 0x64, 0x37, 0x37, 0x32, 0x61, 0x32, 0x62, 0x38, 0x63, 0x32, 0x31, 0x36, 0x65, 0x35, 0x39, 0x36, 0x39, 0x32, 0x30, 0x65, 0x65, 0x63, 0x39, 0x32, 0x36, 0x39, 0x61, 0x39, 0x33, 0x31, 0x30, 0x39, 0x62, 0x32, 0x34, 0x65, 0x31, 0x30, 0x34, 0x61, 0x36, 0x34, 0x35, 0x35, 0x66, 0x66, 0x63, 0x65, 0x65, 0x63, 0x30, 0x62, 0x63, 0x31, 0x65, 0x34, 0x37, 0x34, 0x34, 0x39, 0x65, 0x35, 0x35, 0x35, 0x34, 0x37, 0x30, 0x38, 0x66, 0x35, 0x34, 0x34, 0x35, 0x61, 0x63, 0x63, 0x65, 0x31, 0x66, 0x36, 0x64, 0x35, 0x36, 0x65, 0x66, 0x66, 0x39, 0x39, 0x63, 0x32, 0x64, 0x38, 0x33, 0x30, 0x63, 0x62, 0x31, 0x37, 0x30, 0x62, 0x66, 0x37, 0x39, 0x64, 0x30, 0x31, 0x32, 0x65, 0x63, 0x63, 0x36, 0x35, 0x63, 0x38, 0x63, 0x33, 0x33, 0x38, 0x31, 0x62, 0x63, 0x36, 0x30, 0x33, 0x34, 0x62, 0x65, 0x38, 0x65, 0x38, 0x37, 0x32, 0x64, 0x30, 0x36, 0x35, 0x66, 0x36, 0x38, 0x36, 0x30, 0x36, 0x37, 0x61, 0x33, 0x64, 0x31, 0x35, 0x34, 0x61, 0x66, 0x39, 0x66, 0x32, 0x32, 0x62, 0x30, 0x65, 0x33, 0x34, 0x64, 0x32, 0x37, 0x31, 0x30, 0x35, 0x65, 0x34, 0x37, 0x62, 0x66, 0x32, 0x61, 0x32, 0x65, 0x38, 0x65, 0x64, 0x30, 0x37, 0x33, 0x62, 0x36, 0x34, 0x35, 0x30, 0x35, 0x31, 0x37, 0x36, 0x31, 0x30, 0x37, 0x63, 0x37, 0x32, 0x37, 0x61, 0x65, 0x62, 0x31, 0x61, 0x62, 0x64, 0x32, 0x32, 0x37, 0x32, 0x38, 0x35, 0x38, 0x61, 0x63, 0x63, 0x34, 0x37, 0x62, 0x62, 0x35, 0x35, 0x33, 0x35, 0x64, 0x35, 0x35, 0x39, 0x62, 0x31, 0x34, 0x62, 0x39, 0x31, 0x64, 0x38, 0x34, 0x35, 0x39, 0x32, 0x61, 0x63, 0x31, 0x33, 0x37, 0x39, 0x37, 0x63, 0x38, 0x33, 0x34, 0x30, 0x63, 0x32, 0x32, 0x30, 0x35, 0x32, 0x66, 0x63, 0x31, 0x39, 0x38, 0x36, 0x38, 0x38, 0x30, 0x36, 0x31, 0x33, 0x36, 0x34, 0x62, 0x35, 0x37, 0x31, 0x65, 0x32, 0x61, 0x37, 0x35, 0x33, 0x66, 0x66, 0x35, 0x32, 0x30, 0x66, 0x31, 0x63, 0x65, 0x30, 0x66, 0x66, 0x61, 0x39, 0x32, 0x36, 0x32, 0x34, 0x31, 0x31, 0x62, 0x65, 0x34, 0x61, 0x32, 0x32, 0x61, 0x39, 0x65, 0x61, 0x63, 0x65, 0x34, 0x61, 0x35, 0x35, 0x62, 0x35, 0x30, 0x62, 0x62, 0x62, 0x31, 0x61, 0x32, 0x34, 0x36, 0x66, 0x35, 0x31, 0x64, 0x33, 0x63, 0x61, 0x35, 0x61, 0x62, 0x35, 0x32, 0x65, 0x63, 0x65, 0x34, 0x62, 0x62, 0x65, 0x32, 0x30, 0x30, 0x33, 0x61, 0x33, 0x34, 0x65, 0x32, 0x30, 0x63, 0x61, 0x39, 0x61, 0x32, 0x64, 0x63, 0x37, 0x63, 0x66, 0x31, 0x65, 0x37, 0x32, 0x38, 0x39, 0x33, 0x32, 0x62, 0x61, 0x36, 0x32, 0x61, 0x61, 0x39, 0x62, 0x34, 0x61, 0x30, 0x33, 0x37, 0x32, 0x32, 0x35, 0x34, 0x33, 0x36, 0x35, 0x61, 0x64, 0x61, 0x39, 0x36, 0x37, 0x63, 0x39, 0x63, 0x38, 0x32, 0x63, 0x62, 0x38, 0x31, 0x39, 0x31, 0x31, 0x37, 0x62, 0x35, 0x34, 0x35, 0x65, 0x62, 0x30, 0x30, 0x39, 0x30, 0x62, 0x66, 0x35, 0x62, 0x65, 0x65, 0x33, 0x64, 0x65, 0x63, 0x34, 0x31, 0x35, 0x31, 0x35, 0x36, 0x37, 0x34, 0x37, 0x39, 0x36, 0x34, 0x36, 0x34, 0x63, 0x65, 0x34, 0x37, 0x32, 0x63, 0x31, 0x62, 0x30, 0x65, 0x35, 0x62, 0x30, 0x34, 0x31, 0x38, 0x36, 0x63, 0x63, 0x33, 0x63, 0x61, 0x30, 0x31, 0x37, 0x31, 0x35, 0x65, 0x35, 0x36, 0x37, 0x61, 0x61, 0x66, 0x66, 0x35, 0x63, 0x37, 0x32, 0x38, 0x34, 0x38, 0x61, 0x66, 0x30, 0x61, 0x61, 0x34, 0x34, 0x31, 0x62, 0x61, 0x65, 0x32, 0x61, 0x30, 0x65, 0x62, 0x31, 0x36, 0x30, 0x33, 0x31, 0x35, 0x64, 0x38, 0x65, 0x37, 0x32, 0x65, 0x34, 0x62, 0x33, 0x66, 0x39, 0x34, 0x39, 0x65, 0x36, 0x34, 0x30, 0x34, 0x38, 0x65, 0x30, 0x30, 0x31, 0x62, 0x34, 0x62, 0x64, 0x61, 0x32, 0x66, 0x32, 0x62, 0x35, 0x65, 0x36, 0x62, 0x62, 0x65, 0x34, 0x34, 0x62, 0x35, 0x34, 0x65, 0x38, 0x30, 0x35, 0x39, 0x33, 0x32, 0x39, 0x63, 0x61, 0x62, 0x31, 0x34, 0x30, 0x33, 0x37, 0x65, 0x39, 0x64, 0x31, 0x30, 0x66, 0x37, 0x39, 0x37, 0x32, 0x31, 0x63, 0x31, 0x61, 0x31, 0x62, 0x33, 0x36, 0x33, 0x64, 0x62, 0x61, 0x65, 0x30, 0x36, 0x63, 0x63, 0x38, 0x33, 0x31, 0x31, 0x61, 0x36, 0x38, 0x66, 0x63, 0x32, 0x64, 0x38, 0x32, 0x65, 0x31, 0x36, 0x38, 0x39, 0x32, 0x35, 0x34, 0x31, 0x38, 0x31, 0x35, 0x65, 0x38, 0x30, 0x61, 0x30, 0x66, 0x38, 0x36, 0x34, 0x61, 0x31, 0x35, 0x30, 0x64, 0x64, 0x65, 0x38, 0x32, 0x63, 0x64, 0x37, 0x32, 0x32, 0x31, 0x66, 0x30, 0x37, 0x34, 0x66, 0x33, 0x34, 0x32, 0x66, 0x30, 0x63, 0x32, 0x62, 0x63, 0x35, 0x35, 0x36, 0x63, 0x31, 0x34, 0x35, 0x37, 0x65, 0x39, 0x32, 0x37, 0x31, 0x65, 0x31, 0x33, 0x32, 0x36, 0x33, 0x66, 0x37, 0x62, 0x31, 0x65, 0x38, 0x64, 0x65, 0x32, 0x39, 0x39, 0x38, 0x65, 0x34, 0x35, 0x36, 0x31, 0x63, 0x34, 0x34, 0x65, 0x39, 0x30, 0x63, 0x36, 0x36, 0x33, 0x36, 0x30, 0x61, 0x36, 0x32, 0x62, 0x37, 0x66, 0x37, 0x35, 0x37, 0x36, 0x64, 0x35, 0x31, 0x64, 0x39, 0x35, 0x30, 0x61, 0x36, 0x31, 0x66, 0x37, 0x66, 0x65, 0x32, 0x34, 0x30, 0x64, 0x34, 0x34, 0x36, 0x64, 0x65, 0x31, 0x36, 0x35, 0x65, 0x62, 0x38, 0x61, 0x64, 0x64, 0x34, 0x61, 0x64, 0x36, 0x66, 0x38, 0x35, 0x38, 0x31, 0x32, 0x32, 0x65, 0x62, 0x66, 0x32, 0x62, 0x31, 0x34, 0x35, 0x61, 0x37, 0x32, 0x32, 0x33, 0x32, 0x35, 0x62, 0x61, 0x30, 0x39, 0x32, 0x32, 0x33, 0x34, 0x66, 0x66, 0x31, 0x61, 0x63, 0x33, 0x62, 0x64, 0x38, 0x65, 0x64, 0x33, 0x61, 0x39, 0x39, 0x35, 0x31, 0x31, 0x61, 0x36, 0x66, 0x64, 0x30, 0x31, 0x39, 0x30, 0x66, 0x37, 0x36, 0x35, 0x33, 0x36, 0x31, 0x34, 0x65, 0x36, 0x37, 0x63, 0x36, 0x35, 0x30, 0x61, 0x39, 0x63, 0x39, 0x64, 0x33, 0x32, 0x33, 0x32, 0x30, 0x62, 0x65, 0x32, 0x35, 0x30, 0x34, 0x61, 0x65, 0x64, 0x32, 0x62, 0x64, 0x32, 0x37, 0x64, 0x36, 0x61, 0x34, 0x37, 0x38, 0x65, 0x38, 0x31, 0x34, 0x33, 0x34, 0x39, 0x37, 0x38, 0x37, 0x39, 0x66, 0x38, 0x62, 0x39, 0x38, 0x32, 0x65, 0x34, 0x65, 0x39, 0x65, 0x63, 0x34, 0x30, 0x63, 0x61, 0x31, 0x39, 0x33, 0x62, 0x33, 0x32, 0x30, 0x65, 0x38, 0x61, 0x31, 0x33, 0x31, 0x36, 0x37, 0x62, 0x32, 0x33, 0x32, 0x38, 0x38, 0x65, 0x35, 0x32, 0x31, 0x30, 0x35, 0x66, 0x37, 0x37, 0x36, 0x61, 0x31, 0x66, 0x38, 0x64, 0x64, 0x61, 0x65, 0x39, 0x66, 0x63, 0x34, 0x34, 0x63, 0x64, 0x30, 0x33, 0x33, 0x63, 0x36, 0x65, 0x63, 0x35, 0x37, 0x64, 0x33, 0x61, 0x38, 0x38, 0x37, 0x30, 0x35, 0x30, 0x38, 0x31, 0x62, 0x64, 0x66, 0x35, 0x39, 0x62, 0x30, 0x38, 0x61, 0x66, 0x36, 0x33, 0x66, 0x35, 0x37, 0x32, 0x38, 0x35, 0x62, 0x34, 0x65, 0x63, 0x37, 0x61, 0x34, 0x35, 0x31, 0x61, 0x37, 0x65, 0x39, 0x61, 0x38, 0x65, 0x31, 0x36, 0x64, 0x33, 0x38, 0x62, 0x64, 0x30, 0x65, 0x33, 0x62, 0x64, 0x62, 0x36, 0x65, 0x36, 0x30, 0x36, 0x63, 0x34, 0x66, 0x65, 0x30, 0x38, 0x37, 0x34, 0x39, 0x62, 0x32, 0x32, 0x34, 0x62, 0x35, 0x36, 0x36, 0x63, 0x31, 0x32, 0x33, 0x32, 0x38, 0x65, 0x65, 0x62, 0x37, 0x32, 0x61, 0x31, 0x33, 0x37, 0x63, 0x31, 0x30, 0x64, 0x34, 0x61, 0x38, 0x33, 0x30, 0x36, 0x39, 0x39, 0x39, 0x31, 0x64, 0x37, 0x30, 0x39, 0x38, 0x66, 0x32, 0x62, 0x34, 0x30, 0x64, 0x63, 0x61, 0x36, 0x36, 0x62, 0x35, 0x66, 0x35, 0x64, 0x32, 0x34, 0x34, 0x63, 0x39, 0x63, 0x37, 0x66, 0x61, 0x66, 0x32, 0x61, 0x35, 0x31, 0x66, 0x61, 0x39, 0x64, 0x33, 0x36, 0x30, 0x39, 0x61, 0x65, 0x37, 0x32, 0x37, 0x38, 0x36, 0x64, 0x62, 0x32, 0x33, 0x61, 0x63, 0x36, 0x32, 0x39, 0x62, 0x31, 0x63, 0x37, 0x62, 0x64, 0x61, 0x64, 0x61, 0x39, 0x36, 0x32, 0x30, 0x38, 0x30, 0x32, 0x39, 0x64, 0x36, 0x66, 0x32, 0x34, 0x37, 0x31, 0x37, 0x32, 0x35, 0x64, 0x61, 0x32, 0x33, 0x66, 0x38, 0x34, 0x35, 0x39, 0x39, 0x63, 0x63, 0x32, 0x66, 0x36, 0x33, 0x39, 0x37, 0x30, 0x30, 0x39, 0x66, 0x31, 0x33, 0x31, 0x63, 0x33, 0x64, 0x66, 0x65, 0x33, 0x64, 0x39, 0x61, 0x62, 0x65, 0x31, 0x31, 0x32, 0x35, 0x31, 0x66, 0x63, 0x34, 0x33, 0x36, 0x37, 0x31, 0x32, 0x33, 0x61, 0x38, 0x61, 0x64, 0x36, 0x63, 0x32, 0x30, 0x36, 0x31, 0x66, 0x64, 0x30, 0x32, 0x35, 0x32, 0x32, 0x64, 0x39, 0x62, 0x65, 0x35, 0x38, 0x38, 0x34, 0x35, 0x62, 0x35, 0x34, 0x32, 0x36, 0x61, 0x33, 0x38, 0x66, 0x36, 0x30, 0x30, 0x38, 0x30, 0x33, 0x62, 0x39, 0x66, 0x64, 0x38, 0x63, 0x35, 0x64, 0x31, 0x35, 0x37, 0x30, 0x63, 0x63, 0x61, 0x38, 0x39, 0x31, 0x31, 0x39, 0x39, 0x64, 0x31, 0x61, 0x38, 0x31, 0x30, 0x31, 0x37, 0x38, 0x65, 0x31, 0x31, 0x39, 0x39, 0x34, 0x62, 0x39, 0x35, 0x64, 0x31, 0x38, 0x32, 0x63, 0x65, 0x35, 0x62, 0x35, 0x33, 0x38, 0x64, 0x36, 0x66, 0x33, 0x37, 0x36, 0x65, 0x36, 0x31, 0x36, 0x37, 0x32, 0x35, 0x31, 0x31, 0x34, 0x35, 0x33, 0x63, 0x61, 0x65, 0x65, 0x63, 0x32, 0x36, 0x36, 0x37, 0x38, 0x36, 0x66, 0x39, 0x35, 0x39, 0x31, 0x34, 0x61, 0x65, 0x37, 0x62, 0x37, 0x66, 0x63, 0x63, 0x36, 0x66, 0x32, 0x35, 0x38, 0x38, 0x39, 0x38, 0x65, 0x34, 0x32, 0x34, 0x34, 0x34, 0x62, 0x38, 0x30, 0x63, 0x65, 0x32, 0x62, 0x33, 0x66, 0x39, 0x36, 0x30, 0x66, 0x62, 0x65, 0x33, 0x37, 0x37, 0x32, 0x30, 0x35, 0x34, 0x30, 0x65, 0x61, 0x39, 0x66, 0x31, 0x34, 0x66, 0x62, 0x31, 0x37, 0x37, 0x34, 0x33, 0x63, 0x33, 0x66, 0x64, 0x62, 0x61, 0x39, 0x61, 0x61, 0x30, 0x30, 0x34, 0x30, 0x39, 0x61, 0x36, 0x64, 0x32, 0x34, 0x33, 0x34, 0x34, 0x61, 0x65, 0x38, 0x32, 0x38, 0x38, 0x35, 0x66, 0x37, 0x66, 0x62, 0x30, 0x35, 0x65, 0x35, 0x32, 0x31, 0x38, 0x35, 0x35, 0x36, 0x63, 0x37, 0x36, 0x65, 0x31, 0x63, 0x33, 0x39, 0x33, 0x34, 0x35, 0x63, 0x35, 0x66, 0x65, 0x38, 0x61, 0x66, 0x32, 0x65, 0x33, 0x62, 0x38, 0x62, 0x31, 0x37, 0x65, 0x61, 0x30, 0x35, 0x39, 0x39, 0x62, 0x63, 0x61, 0x64, 0x32, 0x33, 0x64, 0x31, 0x34, 0x38, 0x39, 0x64, 0x37, 0x66, 0x32, 0x30, 0x32, 0x61, 0x33, 0x34, 0x33, 0x65, 0x35, 0x30, 0x37, 0x38, 0x30, 0x64, 0x61, 0x65, 0x36, 0x65, 0x37, 0x61, 0x31, 0x63, 0x36, 0x35, 0x35, 0x33, 0x35, 0x37, 0x34, 0x34, 0x39, 0x31, 0x63, 0x39, 0x39, 0x64, 0x39, 0x36, 0x63, 0x37, 0x63, 0x65, 0x30, 0x66, 0x65, 0x31, 0x62, 0x66, 0x32, 0x38, 0x61, 0x66, 0x38, 0x38, 0x31, 0x38, 0x39, 0x33, 0x61, 0x64, 0x65, 0x30, 0x34, 0x34, 0x30, 0x37, 0x31, 0x62, 0x66, 0x61, 0x63, 0x31, 0x65, 0x63, 0x36, 0x65, 0x39, 0x63, 0x33, 0x33, 0x38, 0x63, 0x31, 0x61, 0x31, 0x61, 0x61, 0x63, 0x62, 0x36, 0x65, 0x30, 0x38, 0x39, 0x35, 0x30, 0x30, 0x65, 0x65, 0x35, 0x34, 0x31, 0x66, 0x33, 0x31, 0x64, 0x39, 0x38, 0x34, 0x61, 0x64, 0x30, 0x64, 0x66, 0x38, 0x62, 0x33, 0x38, 0x38, 0x63, 0x36, 0x66, 0x33, 0x31, 0x62, 0x39, 0x33, 0x35, 0x30, 0x34, 0x33, 0x65, 0x37, 0x31, 0x35, 0x62, 0x30, 0x34, 0x35, 0x34, 0x62, 0x36, 0x33, 0x64, 0x33, 0x66, 0x62, 0x34, 0x37, 0x32, 0x65, 0x62, 0x39, 0x66, 0x66, 0x66, 0x30, 0x38, 0x33, 0x66, 0x37, 0x34, 0x39, 0x64, 0x38, 0x36, 0x36, 0x63, 0x64, 0x35, 0x31, 0x36, 0x33, 0x65, 0x38, 0x62, 0x35, 0x63, 0x38, 0x39, 0x35, 0x63, 0x61, 0x62, 0x63, 0x30, 0x64, 0x33, 0x33, 0x64, 0x61, 0x32, 0x63, 0x64, 0x62, 0x66, 0x37, 0x32, 0x30, 0x64, 0x64, 0x37, 0x38, 0x36, 0x31, 0x36, 0x66, 0x61, 0x62, 0x62, 0x64, 0x30, 0x37, 0x32, 0x66, 0x34, 0x62, 0x61, 0x35, 0x33, 0x62, 0x39, 0x65, 0x33, 0x65, 0x36, 0x34, 0x65, 0x34, 0x33, 0x65, 0x66, 0x63, 0x35, 0x39, 0x32, 0x35, 0x35, 0x38, 0x61, 0x66, 0x37, 0x39, 0x39, 0x38, 0x38, 0x37, 0x31, 0x35, 0x36, 0x39, 0x61, 0x32, 0x32, 0x30, 0x65, 0x62, 0x39, 0x30, 0x61, 0x33, 0x35, 0x36, 0x64, 0x61, 0x63, 0x31, 0x35, 0x35, 0x61, 0x36, 0x35, 0x35, 0x39, 0x65, 0x64, 0x32, 0x30, 0x34, 0x35, 0x38, 0x64, 0x32, 0x61, 0x65, 0x39, 0x38, 0x31, 0x35, 0x38, 0x36, 0x31, 0x63, 0x35, 0x32, 0x37, 0x38, 0x30, 0x38, 0x35, 0x39, 0x62, 0x37, 0x65, 0x39, 0x38, 0x34, 0x66, 0x39, 0x63, 0x33, 0x64, 0x30, 0x64, 0x62, 0x66, 0x65, 0x36, 0x66, 0x32, 0x66, 0x32, 0x66, 0x37, 0x61, 0x33, 0x63, 0x39, 0x64, 0x31, 0x65, 0x61, 0x37, 0x38, 0x64, 0x32, 0x36, 0x38, 0x30, 0x34, 0x37, 0x32, 0x39, 0x32, 0x64, 0x39, 0x37, 0x38, 0x34, 0x32, 0x35, 0x32, 0x31, 0x39, 0x32, 0x37, 0x61, 0x65, 0x63, 0x30, 0x62, 0x61, 0x34, 0x39, 0x65, 0x36, 0x39, 0x63, 0x66, 0x35, 0x34, 0x35, 0x37, 0x33, 0x64, 0x35, 0x31, 0x63, 0x64, 0x39, 0x66, 0x39, 0x66, 0x66, 0x35, 0x39, 0x38, 0x38, 0x33, 0x36, 0x38, 0x35, 0x66, 0x65, 0x61, 0x34, 0x63, 0x34, 0x30, 0x34, 0x35, 0x39, 0x33, 0x33, 0x36, 0x61, 0x62, 0x39, 0x35, 0x30, 0x32, 0x32, 0x35, 0x66, 0x64, 0x37, 0x63, 0x61, 0x61, 0x62, 0x65, 0x62, 0x34, 0x65, 0x34, 0x34, 0x32, 0x62, 0x65, 0x32, 0x38, 0x38, 0x31, 0x32, 0x32, 0x64, 0x65, 0x33, 0x33, 0x64, 0x35, 0x30, 0x38, 0x34, 0x36, 0x64, 0x35, 0x66, 0x62, 0x35, 0x37, 0x62, 0x36, 0x39, 0x37, 0x65, 0x34, 0x61, 0x33, 0x35, 0x35, 0x36, 0x33, 0x66, 0x36, 0x62, 0x33, 0x63, 0x32, 0x30, 0x63, 0x39, 0x36, 0x31, 0x37, 0x36, 0x38, 0x38, 0x38, 0x30, 0x32, 0x36, 0x38, 0x37, 0x65, 0x35, 0x30, 0x38, 0x64, 0x61, 0x36, 0x65, 0x31, 0x34, 0x33, 0x66, 0x65, 0x66, 0x38, 0x37, 0x36, 0x33, 0x66, 0x38, 0x63, 0x38, 0x32, 0x65, 0x66, 0x33, 0x33, 0x61, 0x31, 0x31, 0x30, 0x36, 0x61, 0x62, 0x39, 0x32, 0x39, 0x31, 0x35, 0x64, 0x36, 0x30, 0x39, 0x65, 0x36, 0x62, 0x32, 0x37, 0x30, 0x31, 0x61, 0x61, 0x39, 0x63, 0x65, 0x33, 0x39, 0x33, 0x66, 0x64, 0x65, 0x38, 0x34, 0x37, 0x34, 0x32, 0x62, 0x65, 0x66, 0x63, 0x30, 0x64, 0x31, 0x38, 0x66, 0x39, 0x31, 0x62, 0x32, 0x35, 0x65, 0x32, 0x63, 0x36, 0x37, 0x62, 0x62, 0x33, 0x36, 0x33, 0x34, 0x65, 0x38, 0x35, 0x30, 0x64, 0x61, 0x31, 0x30, 0x33, 0x66, 0x35, 0x34, 0x64, 0x37, 0x66, 0x65, 0x62, 0x39, 0x38, 0x37, 0x32, 0x30, 0x30, 0x39, 0x64, 0x64, 0x64, 0x32, 0x35, 0x30, 0x35, 0x30, 0x31, 0x65, 0x33, 0x38, 0x34, 0x31, 0x35, 0x39, 0x64, 0x64, 0x39, 0x63, 0x62, 0x37, 0x31, 0x65, 0x39, 0x34, 0x35, 0x61, 0x62, 0x33, 0x30, 0x62, 0x35, 0x65, 0x34, 0x35, 0x62, 0x39, 0x62, 0x38, 0x35, 0x31, 0x31, 0x66, 0x62, 0x36, 0x30, 0x33, 0x31, 0x30, 0x62, 0x65, 0x38, 0x34, 0x63, 0x36, 0x39, 0x62, 0x31, 0x31, 0x39, 0x37, 0x32, 0x61, 0x64, 0x63, 0x64, 0x33, 0x32, 0x64, 0x32, 0x31, 0x37, 0x39, 0x38, 0x30, 0x39, 0x62, 0x65, 0x33, 0x66, 0x64, 0x65, 0x35, 0x38, 0x66, 0x64, 0x66, 0x31, 0x37, 0x39, 0x39, 0x30, 0x39, 0x37, 0x62, 0x34, 0x38, 0x33, 0x65, 0x33, 0x34, 0x38, 0x34, 0x35, 0x35, 0x63, 0x31, 0x61, 0x61, 0x30, 0x64, 0x64, 0x63, 0x36, 0x38, 0x61, 0x31, 0x66, 0x31, 0x38, 0x64, 0x63, 0x32, 0x39, 0x32, 0x36, 0x65, 0x35, 0x66, 0x39, 0x34, 0x64, 0x33, 0x31, 0x38, 0x61, 0x64, 0x66, 0x62, 0x64, 0x65, 0x31, 0x38, 0x31, 0x32, 0x30, 0x30, 0x34, 0x32, 0x33, 0x66, 0x35, 0x64, 0x33, 0x33, 0x66, 0x61, 0x39, 0x33, 0x31, 0x35, 0x64, 0x62, 0x63, 0x30, 0x30, 0x32, 0x61, 0x36, 0x34, 0x33, 0x37, 0x39, 0x30, 0x33, 0x61, 0x30, 0x37, 0x66, 0x35, 0x65, 0x65, 0x37, 0x37, 0x65, 0x32, 0x64, 0x65, 0x35, 0x31, 0x65, 0x31, 0x38, 0x35, 0x30, 0x32, 0x61, 0x34, 0x36, 0x64, 0x62, 0x39, 0x66, 0x35, 0x62, 0x31, 0x35, 0x64, 0x30, 0x38, 0x38, 0x30, 0x63, 0x62, 0x38, 0x66, 0x66, 0x35, 0x39, 0x31, 0x39, 0x62, 0x65, 0x64, 0x64, 0x66, 0x36, 0x63, 0x34, 0x38, 0x32, 0x30, 0x32, 0x33, 0x37, 0x30, 0x30, 0x31, 0x66, 0x39, 0x34, 0x34, 0x64, 0x36, 0x66, 0x66, 0x61, 0x37, 0x32, 0x63, 0x39, 0x62, 0x37, 0x32, 0x63, 0x65, 0x30, 0x66, 0x35, 0x30, 0x31, 0x38, 0x36, 0x63, 0x64, 0x39, 0x31, 0x35, 0x36, 0x30, 0x65, 0x36, 0x31, 0x39, 0x37, 0x39, 0x35, 0x34, 0x38, 0x64, 0x65, 0x66, 0x33, 0x38, 0x33, 0x39, 0x36, 0x66, 0x31, 0x66, 0x63, 0x33, 0x64, 0x33, 0x65, 0x38, 0x33, 0x64, 0x36, 0x39, 0x64, 0x63, 0x63, 0x62, 0x61, 0x34, 0x65, 0x39, 0x66, 0x39, 0x37, 0x66, 0x65, 0x37, 0x31, 0x30, 0x37, 0x32, 0x32, 0x34, 0x35, 0x62, 0x33, 0x30, 0x39, 0x64, 0x32, 0x62, 0x32, 0x64, 0x31, 0x66, 0x31, 0x32, 0x64, 0x63, 0x33, 0x35, 0x62, 0x31, 0x63, 0x33, 0x31, 0x37, 0x63, 0x36, 0x31, 0x66, 0x31, 0x34, 0x66, 0x38, 0x66, 0x63, 0x61, 0x32, 0x37, 0x66, 0x35, 0x62, 0x32, 0x33, 0x66, 0x31, 0x34, 0x32, 0x61, 0x37, 0x37, 0x64, 0x38, 0x34, 0x37, 0x64, 0x62, 0x62, 0x64, 0x39, 0x65, 0x64, 0x33, 0x62, 0x37, 0x65, 0x31, 0x36, 0x65, 0x33, 0x30, 0x36, 0x31, 0x33, 0x35, 0x38, 0x66, 0x62, 0x66, 0x38, 0x39, 0x32, 0x34, 0x61, 0x61, 0x64, 0x36, 0x32, 0x30, 0x38, 0x38, 0x63, 0x64, 0x61, 0x63, 0x61, 0x39, 0x32, 0x34, 0x65, 0x35, 0x34, 0x31, 0x63, 0x32, 0x32, 0x62, 0x65, 0x37, 0x66, 0x38, 0x62, 0x33, 0x31, 0x35, 0x64, 0x63, 0x63, 0x61, 0x33, 0x33, 0x66, 0x65, 0x38, 0x39, 0x62, 0x37, 0x32, 0x30, 0x64, 0x39, 0x36, 0x62, 0x66, 0x64, 0x34, 0x61, 0x36, 0x35, 0x64, 0x66, 0x35, 0x39, 0x39, 0x63, 0x31, 0x65, 0x38, 0x32, 0x34, 0x33, 0x36, 0x32, 0x36, 0x35, 0x36, 0x36, 0x33, 0x64, 0x62, 0x36, 0x36, 0x31, 0x33, 0x65, 0x36, 0x61, 0x33, 0x39, 0x38, 0x30, 0x34, 0x31, 0x37, 0x39, 0x35, 0x31, 0x35, 0x34, 0x37, 0x31, 0x65, 0x35, 0x66, 0x31, 0x34, 0x35, 0x39, 0x30, 0x39, 0x35, 0x37, 0x33, 0x66, 0x39, 0x30, 0x34, 0x63, 0x37, 0x34, 0x37, 0x63, 0x34, 0x32, 0x33, 0x65, 0x30, 0x63, 0x31, 0x31, 0x36, 0x66, 0x66, 0x31, 0x61, 0x30, 0x64, 0x31, 0x61, 0x34, 0x62, 0x37, 0x35, 0x62, 0x64, 0x64, 0x63, 0x63, 0x61, 0x39, 0x32, 0x38, 0x32, 0x64, 0x32, 0x34, 0x35, 0x64, 0x32, 0x32, 0x30, 0x39, 0x35, 0x62, 0x61, 0x62, 0x65, 0x30, 0x30, 0x34, 0x64, 0x66, 0x66, 0x65, 0x36, 0x66, 0x35, 0x62, 0x62, 0x30, 0x35, 0x34, 0x63, 0x39, 0x37, 0x32, 0x62, 0x61, 0x32, 0x61, 0x38, 0x36, 0x31, 0x61, 0x36, 0x34, 0x37, 0x30, 0x32, 0x39, 0x38, 0x63, 0x32, 0x31, 0x64, 0x38, 0x62, 0x30, 0x38, 0x61, 0x35, 0x37, 0x31, 0x61, 0x61, 0x37, 0x65, 0x32, 0x66, 0x30, 0x66, 0x61, 0x66, 0x61, 0x62, 0x65, 0x38, 0x39, 0x64, 0x64, 0x32, 0x39, 0x34, 0x39, 0x39, 0x66, 0x31, 0x62, 0x37, 0x32, 0x62, 0x35, 0x35, 0x66, 0x37, 0x65, 0x31, 0x62, 0x37, 0x66, 0x62, 0x63, 0x33, 0x33, 0x63, 0x64, 0x31, 0x62, 0x63, 0x38, 0x62, 0x38, 0x34, 0x63, 0x35, 0x36, 0x37, 0x65, 0x64, 0x36, 0x36, 0x38, 0x63, 0x33, 0x31, 0x34, 0x63, 0x39, 0x61, 0x37, 0x63, 0x30, 0x38, 0x31, 0x31, 0x61, 0x36, 0x36, 0x33, 0x33, 0x61, 0x32, 0x66, 0x66, 0x66, 0x39, 0x39, 0x39, 0x66, 0x34, 0x35, 0x38, 0x37, 0x32, 0x30, 0x36, 0x66, 0x35, 0x34, 0x32, 0x65, 0x63, 0x35, 0x62, 0x66, 0x38, 0x66, 0x32, 0x65, 0x34, 0x37, 0x65, 0x32, 0x34, 0x31, 0x33, 0x65, 0x36, 0x38, 0x38, 0x37, 0x66, 0x32, 0x63, 0x36, 0x64, 0x36, 0x33, 0x31, 0x30, 0x36, 0x39, 0x39, 0x31, 0x31, 0x32, 0x66, 0x66, 0x35, 0x31, 0x62, 0x65, 0x65, 0x63, 0x39, 0x66, 0x63, 0x64, 0x38, 0x61, 0x37, 0x30, 0x39, 0x38, 0x61, 0x37, 0x37, 0x32, 0x66, 0x36, 0x32, 0x37, 0x62, 0x31, 0x65, 0x30, 0x36, 0x62, 0x34, 0x38, 0x30, 0x66, 0x38, 0x33, 0x63, 0x66, 0x65, 0x64, 0x35, 0x32, 0x65, 0x30, 0x35, 0x33, 0x31, 0x35, 0x62, 0x34, 0x33, 0x39, 0x32, 0x35, 0x64, 0x61, 0x38, 0x36, 0x38, 0x34, 0x30, 0x38, 0x35, 0x64, 0x34, 0x30, 0x39, 0x66, 0x31, 0x37, 0x39, 0x64, 0x66, 0x61, 0x66, 0x31, 0x33, 0x30, 0x35, 0x39, 0x33, 0x38, 0x37, 0x32, 0x62, 0x36, 0x61, 0x35, 0x32, 0x62, 0x62, 0x31, 0x39, 0x35, 0x39, 0x32, 0x31, 0x37, 0x32, 0x30, 0x66, 0x37, 0x31, 0x66, 0x38, 0x31, 0x34, 0x31, 0x61, 0x32, 0x37, 0x36, 0x62, 0x33, 0x36, 0x61, 0x65, 0x65, 0x33, 0x62, 0x63, 0x61, 0x62, 0x38, 0x65, 0x62, 0x37, 0x39, 0x32, 0x36, 0x36, 0x30, 0x31, 0x61, 0x38, 0x38, 0x35, 0x37, 0x65, 0x37, 0x34, 0x64, 0x31, 0x62, 0x66, 0x32, 0x37, 0x32, 0x30, 0x35, 0x32, 0x36, 0x37, 0x31, 0x66, 0x36, 0x37, 0x66, 0x62, 0x35, 0x62, 0x63, 0x37, 0x31, 0x33, 0x64, 0x36, 0x64, 0x31, 0x61, 0x63, 0x32, 0x63, 0x66, 0x33, 0x64, 0x39, 0x31, 0x34, 0x38, 0x66, 0x38, 0x64, 0x62, 0x37, 0x62, 0x32, 0x36, 0x36, 0x34, 0x36, 0x34, 0x62, 0x64, 0x35, 0x33, 0x35, 0x32, 0x39, 0x65, 0x37, 0x32, 0x64, 0x30, 0x34, 0x39, 0x63, 0x61, 0x66, 0x66, 0x34, 0x36, 0x39, 0x32, 0x61, 0x63, 0x65, 0x66, 0x39, 0x63, 0x38, 0x33, 0x32, 0x35, 0x38, 0x32, 0x33, 0x39, 0x32, 0x64, 0x34, 0x38, 0x36, 0x63, 0x35, 0x36, 0x34, 0x38, 0x63, 0x35, 0x62, 0x30, 0x33, 0x66, 0x31, 0x36, 0x32, 0x65, 0x38, 0x64, 0x33, 0x37, 0x64, 0x63, 0x37, 0x36, 0x65, 0x36, 0x61, 0x30, 0x37, 0x31, 0x36, 0x63, 0x33, 0x33, 0x63, 0x66, 0x38, 0x33, 0x31, 0x34, 0x33, 0x33, 0x37, 0x32, 0x64, 0x31, 0x61, 0x65, 0x37, 0x63, 0x30, 0x61, 0x34, 0x64, 0x31, 0x66, 0x35, 0x63, 0x32, 0x62, 0x36, 0x32, 0x33, 0x36, 0x65, 0x64, 0x64, 0x65, 0x63, 0x64, 0x30, 0x35, 0x34, 0x31, 0x31, 0x66, 0x39, 0x30, 0x36, 0x36, 0x65, 0x38, 0x39, 0x31, 0x33, 0x32, 0x62, 0x62, 0x31, 0x31, 0x62, 0x66, 0x65, 0x32, 0x32, 0x66, 0x30, 0x39, 0x34, 0x38, 0x66, 0x62, 0x65, 0x33, 0x32, 0x61, 0x37, 0x32, 0x63, 0x62, 0x38, 0x37, 0x64, 0x38, 0x32, 0x61, 0x35, 0x31, 0x31, 0x36, 0x34, 0x64, 0x31, 0x39, 0x64, 0x61, 0x61, 0x31, 0x38, 0x63, 0x37, 0x66, 0x36, 0x34, 0x38, 0x65, 0x62, 0x38, 0x33, 0x63, 0x39, 0x37, 0x66, 0x35, 0x64, 0x35, 0x39, 0x37, 0x35, 0x62, 0x31, 0x63, 0x64, 0x66, 0x37, 0x64, 0x31, 0x36, 0x64, 0x65, 0x39, 0x32, 0x33, 0x33, 0x62, 0x36, 0x30, 0x38, 0x30, 0x63, 0x37, 0x32, 0x36, 0x39, 0x35, 0x33, 0x37, 0x39, 0x31, 0x35, 0x37, 0x66, 0x32, 0x33, 0x64, 0x37, 0x61, 0x35, 0x35, 0x62, 0x34, 0x38, 0x39, 0x66, 0x63, 0x61, 0x64, 0x32, 0x33, 0x61, 0x31, 0x63, 0x31, 0x35, 0x31, 0x38, 0x64, 0x32, 0x65, 0x36, 0x33, 0x35, 0x37, 0x61, 0x61, 0x36, 0x37, 0x32, 0x62, 0x65, 0x34, 0x38, 0x37, 0x37, 0x63, 0x31, 0x33, 0x66, 0x62, 0x32, 0x33, 0x62, 0x39, 0x30, 0x30, 0x62, 0x35, 0x33, 0x33, 0x32, 0x37, 0x34, 0x37, 0x34, 0x62, 0x65, 0x36, 0x64, 0x32, 0x61, 0x36, 0x37, 0x37, 0x66, 0x38, 0x64, 0x31, 0x34, 0x61, 0x34, 0x62, 0x61, 0x61, 0x63, 0x36, 0x63, 0x34, 0x37, 0x65, 0x65, 0x63, 0x64, 0x39, 0x63, 0x37, 0x33, 0x37, 0x33, 0x63, 0x66, 0x66, 0x63, 0x63, 0x31, 0x33, 0x32, 0x33, 0x35, 0x34, 0x37, 0x61, 0x31, 0x61, 0x37, 0x39, 0x39, 0x33, 0x61, 0x37, 0x32, 0x63, 0x65, 0x31, 0x30, 0x35, 0x64, 0x65, 0x62, 0x62, 0x30, 0x62, 0x61, 0x39, 0x37, 0x36, 0x31, 0x66, 0x66, 0x38, 0x65, 0x36, 0x38, 0x33, 0x32, 0x39, 0x39, 0x36, 0x35, 0x64, 0x66, 0x32, 0x37, 0x34, 0x33, 0x36, 0x33, 0x35, 0x34, 0x37, 0x63, 0x63, 0x35, 0x61, 0x39, 0x38, 0x64, 0x31, 0x39, 0x37, 0x31, 0x62, 0x33, 0x38, 0x38, 0x39, 0x36, 0x61, 0x65, 0x34, 0x62, 0x37, 0x39, 0x37, 0x32, 0x36, 0x39, 0x66, 0x66, 0x61, 0x35, 0x39, 0x39, 0x38, 0x65, 0x66, 0x66, 0x35, 0x33, 0x63, 0x33, 0x35, 0x63, 0x62, 0x64, 0x61, 0x64, 0x33, 0x33, 0x37, 0x64, 0x64, 0x32, 0x39, 0x38, 0x64, 0x32, 0x63, 0x38, 0x36, 0x39, 0x37, 0x30, 0x39, 0x66, 0x35, 0x38, 0x35, 0x30, 0x37, 0x61, 0x34, 0x66, 0x66, 0x35, 0x63, 0x35, 0x33, 0x63, 0x34, 0x62, 0x34, 0x62, 0x31, 0x30, 0x66, 0x64, 0x36, 0x61, 0x37, 0x64, 0x62, 0x34, 0x39, 0x31, 0x61, 0x39, 0x39, 0x63, 0x61, 0x61, 0x61, 0x38, 0x66, 0x64, 0x32, 0x34, 0x38, 0x63, 0x66, 0x62, 0x39, 0x38, 0x30, 0x62, 0x37, 0x38, 0x36, 0x31, 0x64, 0x64, 0x64, 0x64, 0x36, 0x61, 0x64, 0x35, 0x62, 0x66, 0x66, 0x34, 0x39, 0x32, 0x65, 0x36, 0x39, 0x62, 0x32, 0x63, 0x36, 0x34, 0x63, 0x39, 0x31, 0x63, 0x62, 0x35, 0x35, 0x35, 0x63, 0x65, 0x37, 0x32, 0x35, 0x62, 0x66, 0x64, 0x61, 0x63, 0x30, 0x62, 0x31, 0x64, 0x66, 0x38, 0x31, 0x32, 0x61, 0x38, 0x33, 0x65, 0x65, 0x32, 0x34, 0x66, 0x38, 0x61, 0x62, 0x64, 0x61, 0x32, 0x30, 0x34, 0x33, 0x62, 0x63, 0x32, 0x39, 0x65, 0x37, 0x36, 0x37, 0x63, 0x62, 0x34, 0x39, 0x30, 0x33, 0x31, 0x62, 0x31, 0x61, 0x30, 0x66, 0x65, 0x38, 0x65, 0x63, 0x61, 0x66, 0x32, 0x35, 0x35, 0x39, 0x64, 0x37, 0x32, 0x37, 0x37, 0x35, 0x61, 0x33, 0x33, 0x35, 0x36, 0x34, 0x30, 0x33, 0x66, 0x39, 0x32, 0x32, 0x32, 0x61, 0x65, 0x38, 0x36, 0x34, 0x62, 0x62, 0x31, 0x36, 0x64, 0x33, 0x31, 0x30, 0x65, 0x32, 0x39, 0x33, 0x61, 0x33, 0x61, 0x62, 0x35, 0x36, 0x61, 0x66, 0x35, 0x61, 0x38, 0x36, 0x65, 0x62, 0x33, 0x30, 0x36, 0x66, 0x66, 0x36, 0x62, 0x34, 0x35, 0x39, 0x64, 0x65, 0x36, 0x32, 0x62, 0x37, 0x32, 0x62, 0x64, 0x37, 0x35, 0x65, 0x65, 0x64, 0x35, 0x34, 0x36, 0x36, 0x36, 0x33, 0x65, 0x37, 0x31, 0x36, 0x33, 0x34, 0x36, 0x30, 0x32, 0x63, 0x62, 0x65, 0x62, 0x34, 0x33, 0x39, 0x33, 0x33, 0x36, 0x32, 0x30, 0x64, 0x65, 0x33, 0x33, 0x30, 0x66, 0x35, 0x66, 0x64, 0x64, 0x64, 0x63, 0x66, 0x37, 0x64, 0x32, 0x61, 0x35, 0x34, 0x64, 0x66, 0x31, 0x35, 0x61, 0x63, 0x64, 0x38, 0x39, 0x37, 0x32, 0x65, 0x34, 0x30, 0x62, 0x64, 0x65, 0x38, 0x65, 0x35, 0x33, 0x63, 0x35, 0x62, 0x61, 0x33, 0x66, 0x63, 0x63, 0x35, 0x34, 0x62, 0x64, 0x37, 0x30, 0x63, 0x35, 0x37, 0x33, 0x35, 0x64, 0x39, 0x65, 0x65, 0x34, 0x37, 0x39, 0x64, 0x63, 0x38, 0x30, 0x64, 0x61, 0x33, 0x36, 0x36, 0x64, 0x33, 0x38, 0x35, 0x38, 0x30, 0x64, 0x62, 0x31, 0x66, 0x62, 0x33, 0x65, 0x31, 0x61, 0x61, 0x30, 0x37, 0x32, 0x65, 0x32, 0x34, 0x30, 0x62, 0x66, 0x33, 0x34, 0x37, 0x35, 0x36, 0x36, 0x34, 0x61, 0x62, 0x34, 0x66, 0x63, 0x33, 0x31, 0x34, 0x30, 0x34, 0x66, 0x66, 0x37, 0x64, 0x32, 0x37, 0x39, 0x33, 0x37, 0x61, 0x35, 0x39, 0x61, 0x63, 0x34, 0x39, 0x61, 0x36, 0x32, 0x39, 0x30, 0x32, 0x38, 0x35, 0x33, 0x63, 0x63, 0x34, 0x63, 0x36, 0x30, 0x31, 0x33, 0x31, 0x61, 0x33, 0x38, 0x36, 0x63, 0x30, 0x36, 0x32, 0x65, 0x65, 0x36, 0x61, 0x35, 0x64, 0x65, 0x33, 0x32, 0x35, 0x65, 0x32, 0x64, 0x35, 0x61, 0x31, 0x66, 0x63, 0x34, 0x38, 0x61, 0x31, 0x35, 0x62, 0x64, 0x64, 0x63, 0x38, 0x61, 0x63, 0x65, 0x31, 0x62, 0x66, 0x35, 0x33, 0x33, 0x30, 0x36, 0x30, 0x61, 0x39, 0x61, 0x39, 0x34, 0x34, 0x37, 0x32, 0x39, 0x62, 0x33, 0x35, 0x38, 0x32, 0x62, 0x33, 0x38, 0x32, 0x65, 0x32, 0x63, 0x37, 0x32, 0x35, 0x34, 0x38, 0x38, 0x61, 0x35, 0x36, 0x30, 0x35, 0x63, 0x63, 0x65, 0x32, 0x37, 0x36, 0x37, 0x64, 0x64, 0x66, 0x33, 0x39, 0x32, 0x33, 0x37, 0x63, 0x38, 0x31, 0x33, 0x38, 0x36, 0x36, 0x66, 0x34, 0x61, 0x62, 0x30, 0x32, 0x30, 0x39, 0x63, 0x62, 0x65, 0x34, 0x66, 0x31, 0x33, 0x39, 0x38, 0x32, 0x64, 0x66, 0x33, 0x64, 0x66, 0x61, 0x36, 0x37, 0x64, 0x35, 0x35, 0x31, 0x32, 0x37, 0x32, 0x33, 0x36, 0x30, 0x66, 0x31, 0x64, 0x66, 0x30, 0x65, 0x32, 0x32, 0x37, 0x63, 0x33, 0x30, 0x63, 0x31, 0x39, 0x66, 0x64, 0x30, 0x32, 0x33, 0x32, 0x64, 0x36, 0x38, 0x35, 0x62, 0x31, 0x64, 0x33, 0x64, 0x66, 0x65, 0x32, 0x65, 0x62, 0x63, 0x62, 0x33, 0x33, 0x33, 0x31, 0x64, 0x31, 0x37, 0x33, 0x61, 0x31, 0x38, 0x65, 0x66, 0x33, 0x30, 0x31, 0x62, 0x38, 0x33, 0x63, 0x31, 0x30, 0x34, 0x65, 0x62, 0x34, 0x34, 0x64, 0x34, 0x66, 0x66, 0x31, 0x64, 0x33, 0x39, 0x65, 0x65, 0x35, 0x61, 0x34, 0x61, 0x64, 0x35, 0x38, 0x30, 0x36, 0x35, 0x32, 0x62, 0x37, 0x30, 0x30, 0x66, 0x65, 0x32, 0x34, 0x36, 0x30, 0x31, 0x35, 0x61, 0x31, 0x39, 0x32, 0x39, 0x66, 0x31, 0x63, 0x38, 0x66, 0x33, 0x61, 0x36, 0x32, 0x38, 0x34, 0x64, 0x39, 0x66, 0x39, 0x30, 0x35, 0x63, 0x38, 0x34, 0x63, 0x37, 0x32, 0x65, 0x30, 0x37, 0x36, 0x32, 0x65, 0x62, 0x38, 0x63, 0x36, 0x37, 0x31, 0x65, 0x62, 0x64, 0x35, 0x30, 0x62, 0x39, 0x31, 0x35, 0x39, 0x63, 0x36, 0x66, 0x31, 0x36, 0x34, 0x35, 0x33, 0x37, 0x37, 0x33, 0x66, 0x31, 0x31, 0x65, 0x63, 0x65, 0x64, 0x35, 0x38, 0x30, 0x30, 0x36, 0x63, 0x35, 0x38, 0x63, 0x31, 0x63, 0x36, 0x64, 0x34, 0x33, 0x37, 0x35, 0x63, 0x31, 0x38, 0x35, 0x62, 0x31, 0x39, 0x37, 0x33, 0x37, 0x32, 0x35, 0x65, 0x34, 0x63, 0x64, 0x37, 0x61, 0x38, 0x38, 0x30, 0x34, 0x64, 0x66, 0x31, 0x34, 0x38, 0x31, 0x61, 0x66, 0x39, 0x36, 0x30, 0x66, 0x35, 0x31, 0x33, 0x31, 0x38, 0x38, 0x61, 0x37, 0x61, 0x37, 0x34, 0x34, 0x64, 0x64, 0x66, 0x33, 0x36, 0x33, 0x62, 0x63, 0x31, 0x63, 0x36, 0x64, 0x32, 0x34, 0x63, 0x36, 0x35, 0x37, 0x34, 0x36, 0x63, 0x33, 0x35, 0x37, 0x32, 0x33, 0x32, 0x35, 0x62, 0x61, 0x35, 0x34, 0x39, 0x32, 0x64, 0x31, 0x39, 0x35, 0x35, 0x35, 0x32, 0x34, 0x63, 0x64, 0x32, 0x66, 0x37, 0x35, 0x62, 0x33, 0x62, 0x61, 0x61, 0x35, 0x35, 0x35, 0x37, 0x65, 0x31, 0x30, 0x63, 0x63, 0x31, 0x30, 0x38, 0x33, 0x39, 0x66, 0x30, 0x65, 0x36, 0x38, 0x30, 0x31, 0x37, 0x39, 0x63, 0x61, 0x35, 0x66, 0x66, 0x33, 0x65, 0x64, 0x63, 0x63, 0x39, 0x37, 0x32, 0x31, 0x65, 0x65, 0x63, 0x38, 0x33, 0x30, 0x62, 0x33, 0x34, 0x38, 0x36, 0x38, 0x31, 0x66, 0x37, 0x64, 0x37, 0x39, 0x62, 0x33, 0x37, 0x35, 0x66, 0x37, 0x63, 0x35, 0x63, 0x31, 0x30, 0x33, 0x65, 0x64, 0x62, 0x64, 0x31, 0x62, 0x32, 0x39, 0x39, 0x34, 0x31, 0x64, 0x37, 0x63, 0x32, 0x66, 0x39, 0x36, 0x39, 0x35, 0x38, 0x31, 0x63, 0x61, 0x64, 0x39, 0x66, 0x65, 0x35, 0x38, 0x30, 0x37, 0x32, 0x64, 0x65, 0x62, 0x30, 0x63, 0x36, 0x34, 0x39, 0x64, 0x32, 0x31, 0x37, 0x37, 0x61, 0x30, 0x39, 0x35, 0x34, 0x65, 0x37, 0x63, 0x36, 0x37, 0x37, 0x66, 0x34, 0x63, 0x39, 0x64, 0x66, 0x37, 0x33, 0x62, 0x38, 0x64, 0x64, 0x65, 0x66, 0x62, 0x30, 0x32, 0x65, 0x39, 0x35, 0x33, 0x31, 0x33, 0x64, 0x35, 0x61, 0x30, 0x64, 0x62, 0x61, 0x65, 0x65, 0x61, 0x31, 0x32, 0x64, 0x64, 0x38, 0x32, 0x32, 0x37, 0x66, 0x39, 0x62, 0x38, 0x34, 0x36, 0x32, 0x36, 0x34, 0x33, 0x64, 0x30, 0x64, 0x66, 0x33, 0x61, 0x34, 0x62, 0x38, 0x37, 0x38, 0x32, 0x62, 0x66, 0x33, 0x35, 0x65, 0x65, 0x36, 0x66, 0x33, 0x61, 0x64, 0x35, 0x36, 0x32, 0x39, 0x32, 0x64, 0x32, 0x34, 0x35, 0x63, 0x36, 0x66, 0x33, 0x39, 0x62, 0x31, 0x36, 0x63, 0x30, 0x31, 0x32, 0x38, 0x36, 0x33, 0x36, 0x34, 0x38, 0x35, 0x30, 0x30, 0x36, 0x37, 0x39, 0x37, 0x61, 0x39, 0x36, 0x66, 0x34, 0x37, 0x38, 0x30, 0x32, 0x65, 0x63, 0x65, 0x30, 0x36, 0x37, 0x30, 0x30, 0x65, 0x66, 0x65, 0x64, 0x31, 0x35, 0x38, 0x63, 0x34, 0x34, 0x34, 0x36, 0x39, 0x36, 0x65, 0x32, 0x66, 0x65, 0x37, 0x38, 0x31, 0x65, 0x64, 0x65, 0x32, 0x33, 0x62, 0x32, 0x34, 0x66, 0x34, 0x31, 0x32, 0x63, 0x35, 0x63, 0x36, 0x36, 0x62, 0x64, 0x62, 0x30, 0x35, 0x63, 0x39, 0x65, 0x30, 0x66, 0x32, 0x31, 0x35, 0x37, 0x63, 0x62, 0x63, 0x63, 0x36, 0x39, 0x31, 0x39, 0x34, 0x36, 0x39, 0x33, 0x35, 0x66, 0x63, 0x32, 0x32, 0x30, 0x61, 0x30, 0x39, 0x66, 0x38, 0x38, 0x31, 0x32, 0x65, 0x30, 0x34, 0x30, 0x63, 0x38, 0x62, 0x39, 0x31, 0x39, 0x39, 0x66, 0x30, 0x37, 0x34, 0x34, 0x63, 0x38, 0x36, 0x33, 0x31, 0x63, 0x30, 0x30, 0x37, 0x38, 0x39, 0x37, 0x32, 0x34, 0x37, 0x39, 0x65, 0x32, 0x65, 0x36, 0x34, 0x66, 0x33, 0x38, 0x31, 0x30, 0x62, 0x36, 0x66, 0x35, 0x64, 0x32, 0x33, 0x64, 0x39, 0x34, 0x39, 0x61, 0x30, 0x36, 0x38, 0x66, 0x38, 0x34, 0x37, 0x31, 0x33, 0x33, 0x66, 0x64, 0x63, 0x36, 0x63, 0x30, 0x61, 0x36, 0x37, 0x63, 0x37, 0x66, 0x66, 0x65, 0x37, 0x63, 0x63, 0x38, 0x62, 0x65, 0x65, 0x64, 0x64, 0x35, 0x33, 0x66, 0x64, 0x34, 0x33, 0x61, 0x61, 0x64, 0x35, 0x65, 0x38, 0x32, 0x38, 0x36, 0x39, 0x65, 0x34, 0x61, 0x34, 0x32, 0x31, 0x37, 0x39, 0x30, 0x65, 0x36, 0x62, 0x65, 0x32, 0x66, 0x31, 0x30, 0x37, 0x39, 0x34, 0x36, 0x62, 0x36, 0x35, 0x37, 0x34, 0x36, 0x36, 0x39, 0x36, 0x63, 0x34, 0x62, 0x61, 0x34, 0x66, 0x32, 0x62, 0x38, 0x39, 0x36, 0x31, 0x62, 0x30, 0x63, 0x65, 0x61, 0x31, 0x61, 0x65, 0x32, 0x66, 0x36, 0x32, 0x36, 0x34, 0x30, 0x35, 0x32, 0x63, 0x63, 0x30, 0x65, 0x31, 0x33, 0x33, 0x31, 0x31, 0x36, 0x34, 0x36, 0x37, 0x30, 0x39, 0x61, 0x35, 0x64, 0x62, 0x39, 0x61, 0x38, 0x38, 0x65, 0x36, 0x62, 0x34, 0x34, 0x66, 0x63, 0x63, 0x38, 0x37, 0x62, 0x64, 0x32, 0x64, 0x61, 0x32, 0x66, 0x61, 0x32, 0x66, 0x39, 0x64, 0x65, 0x38, 0x33, 0x37, 0x38, 0x39, 0x61, 0x63, 0x35, 0x31, 0x31, 0x63, 0x37, 0x32, 0x33, 0x35, 0x63, 0x38, 0x38, 0x66, 0x36, 0x64, 0x36, 0x38, 0x63, 0x35, 0x62, 0x34, 0x63, 0x64, 0x37, 0x64, 0x30, 0x33, 0x65, 0x37, 0x65, 0x64, 0x62, 0x66, 0x61, 0x65, 0x38, 0x37, 0x39, 0x30, 0x33, 0x31, 0x61, 0x30, 0x35, 0x34, 0x31, 0x38, 0x63, 0x61, 0x62, 0x62, 0x34, 0x30, 0x64, 0x65, 0x35, 0x34, 0x31, 0x35, 0x64, 0x61, 0x39, 0x39, 0x63, 0x61, 0x31, 0x34, 0x35, 0x39, 0x36, 0x34, 0x37, 0x35, 0x33, 0x63, 0x34, 0x65, 0x38, 0x62, 0x38, 0x66, 0x35, 0x32, 0x63, 0x38, 0x64, 0x65, 0x63, 0x36, 0x31, 0x66, 0x65, 0x62, 0x30, 0x32, 0x66, 0x37, 0x62, 0x62, 0x39, 0x36, 0x36, 0x33, 0x66, 0x33, 0x36, 0x64, 0x37, 0x65, 0x62, 0x61, 0x38, 0x64, 0x66, 0x65, 0x34, 0x62, 0x36, 0x38, 0x35, 0x37, 0x38, 0x39, 0x63, 0x33, 0x36, 0x39, 0x64, 0x62, 0x37, 0x38, 0x36, 0x62, 0x37, 0x32, 0x36, 0x66, 0x61, 0x38, 0x35, 0x39, 0x61, 0x63, 0x31, 0x30, 0x32, 0x33, 0x37, 0x38, 0x30, 0x63, 0x30, 0x64, 0x38, 0x61, 0x65, 0x32, 0x35, 0x32, 0x37, 0x34, 0x30, 0x32, 0x64, 0x39, 0x32, 0x61, 0x39, 0x62, 0x32, 0x62, 0x64, 0x33, 0x64, 0x35, 0x64, 0x65, 0x38, 0x64, 0x37, 0x61, 0x63, 0x37, 0x62, 0x61, 0x34, 0x61, 0x66, 0x35, 0x34, 0x38, 0x64, 0x33, 0x63, 0x37, 0x34, 0x39, 0x37, 0x32, 0x30, 0x36, 0x30, 0x35, 0x34, 0x65, 0x38, 0x34, 0x63, 0x38, 0x32, 0x33, 0x31, 0x39, 0x37, 0x36, 0x62, 0x31, 0x30, 0x32, 0x63, 0x39, 0x65, 0x65, 0x39, 0x35, 0x31, 0x33, 0x63, 0x38, 0x35, 0x33, 0x34, 0x63, 0x33, 0x34, 0x36, 0x66, 0x66, 0x66, 0x65, 0x62, 0x30, 0x34, 0x62, 0x33, 0x61, 0x32, 0x32, 0x32, 0x36, 0x35, 0x62, 0x31, 0x32, 0x34, 0x64, 0x36, 0x34, 0x38, 0x32, 0x66, 0x35, 0x36, 0x64, 0x65, 0x61, 0x36, 0x33, 0x66, 0x31, 0x36, 0x35, 0x33, 0x30, 0x31, 0x38, 0x31, 0x36, 0x63, 0x37, 0x31, 0x37, 0x39, 0x37, 0x31, 0x64, 0x63, 0x38, 0x31, 0x30, 0x65, 0x66, 0x35, 0x30, 0x30, 0x37, 0x61, 0x32, 0x35, 0x65, 0x63, 0x34, 0x31, 0x64, 0x66, 0x30, 0x33, 0x34, 0x61, 0x36, 0x66, 0x64, 0x66, 0x31, 0x65, 0x35, 0x39, 0x37, 0x65, 0x66, 0x32, 0x34, 0x30, 0x63, 0x61, 0x31, 0x33, 0x62, 0x65, 0x33, 0x37, 0x63, 0x38, 0x30, 0x37, 0x61, 0x63, 0x32, 0x62, 0x35, 0x64, 0x34, 0x38, 0x64, 0x33, 0x32, 0x63, 0x61, 0x61, 0x66, 0x64, 0x63, 0x33, 0x37, 0x30, 0x31, 0x62, 0x38, 0x61, 0x39, 0x64, 0x66, 0x31, 0x38, 0x66, 0x61, 0x65, 0x32, 0x65, 0x35, 0x31, 0x38, 0x63, 0x66, 0x35, 0x31, 0x64, 0x62, 0x32, 0x33, 0x33, 0x63, 0x32, 0x37, 0x64, 0x65, 0x61, 0x33, 0x37, 0x37, 0x32, 0x32, 0x38, 0x31, 0x35, 0x36, 0x63, 0x61, 0x33, 0x38, 0x65, 0x66, 0x32, 0x36, 0x31, 0x64, 0x36, 0x35, 0x39, 0x34, 0x62, 0x37, 0x61, 0x37, 0x34, 0x64, 0x36, 0x39, 0x39, 0x30, 0x39, 0x65, 0x64, 0x64, 0x63, 0x63, 0x64, 0x32, 0x62, 0x34, 0x64, 0x62, 0x61, 0x65, 0x38, 0x61, 0x30, 0x35, 0x64, 0x35, 0x63, 0x34, 0x62, 0x39, 0x30, 0x35, 0x30, 0x38, 0x36, 0x33, 0x65, 0x38, 0x32, 0x31, 0x39, 0x35, 0x64, 0x38, 0x35, 0x62, 0x39, 0x62, 0x64, 0x62, 0x33, 0x32, 0x33, 0x36, 0x66, 0x65, 0x38, 0x36, 0x64, 0x62, 0x31, 0x30, 0x32, 0x32, 0x37, 0x66, 0x38, 0x34, 0x32, 0x65, 0x33, 0x35, 0x35, 0x32, 0x32, 0x66, 0x35, 0x65, 0x61, 0x32, 0x32, 0x62, 0x63, 0x61, 0x32, 0x32, 0x36, 0x39, 0x64, 0x63, 0x62, 0x34, 0x63, 0x63, 0x61, 0x39, 0x39, 0x33, 0x32, 0x61, 0x64, 0x31, 0x66, 0x37, 0x32, 0x30, 0x38, 0x35, 0x63, 0x31, 0x62, 0x66, 0x39, 0x32, 0x66, 0x64, 0x39, 0x30, 0x63, 0x63, 0x36, 0x66, 0x39, 0x32, 0x37, 0x32, 0x30, 0x39, 0x39, 0x65, 0x34, 0x35, 0x61, 0x64, 0x61, 0x66, 0x38, 0x36, 0x39, 0x34, 0x39, 0x38, 0x36, 0x66, 0x32, 0x39, 0x65, 0x64, 0x32, 0x31, 0x37, 0x61, 0x31, 0x37, 0x63, 0x61, 0x30, 0x33, 0x31, 0x66, 0x37, 0x38, 0x61, 0x34, 0x39, 0x64, 0x32, 0x37, 0x32, 0x35, 0x39, 0x31, 0x31, 0x64, 0x38, 0x63, 0x32, 0x61, 0x37, 0x63, 0x36, 0x32, 0x64, 0x32, 0x34, 0x34, 0x38, 0x65, 0x66, 0x32, 0x32, 0x63, 0x63, 0x64, 0x38, 0x33, 0x36, 0x38, 0x62, 0x35, 0x33, 0x63, 0x62, 0x39, 0x36, 0x65, 0x37, 0x66, 0x65, 0x62, 0x66, 0x61, 0x66, 0x30, 0x38, 0x63, 0x65, 0x66, 0x39, 0x34, 0x65, 0x66, 0x30, 0x36, 0x64, 0x38, 0x31, 0x37, 0x36, 0x66, 0x35, 0x37, 0x32, 0x35, 0x38, 0x62, 0x31, 0x39, 0x62, 0x64, 0x62, 0x32, 0x64, 0x64, 0x61, 0x63, 0x35, 0x64, 0x34, 0x37, 0x62, 0x63, 0x33, 0x37, 0x66, 0x64, 0x65, 0x35, 0x66, 0x66, 0x39, 0x35, 0x35, 0x31, 0x39, 0x64, 0x38, 0x31, 0x32, 0x38, 0x61, 0x36, 0x30, 0x35, 0x38, 0x33, 0x34, 0x63, 0x65, 0x61, 0x38, 0x30, 0x33, 0x35, 0x66, 0x37, 0x66, 0x30, 0x63, 0x30, 0x31, 0x36, 0x34, 0x32, 0x35, 0x37, 0x32, 0x61, 0x30, 0x63, 0x34, 0x36, 0x30, 0x35, 0x31, 0x63, 0x36, 0x31, 0x38, 0x30, 0x65, 0x62, 0x63, 0x61, 0x31, 0x32, 0x36, 0x38, 0x37, 0x62, 0x64, 0x62, 0x66, 0x32, 0x34, 0x39, 0x38, 0x35, 0x30, 0x34, 0x39, 0x63, 0x31, 0x33, 0x64, 0x39, 0x64, 0x63, 0x62, 0x62, 0x34, 0x36, 0x31, 0x65, 0x37, 0x39, 0x35, 0x61, 0x30, 0x61, 0x63, 0x64, 0x39, 0x66, 0x36, 0x33, 0x35, 0x38, 0x35, 0x35, 0x63, 0x66, 0x38, 0x36, 0x63, 0x38, 0x36, 0x61, 0x35, 0x61, 0x38, 0x36, 0x65, 0x62, 0x30, 0x65, 0x35, 0x37, 0x30, 0x36, 0x33, 0x31, 0x31, 0x63, 0x33, 0x35, 0x30, 0x37, 0x39, 0x33, 0x38, 0x62, 0x38, 0x32, 0x39, 0x63, 0x61, 0x32, 0x65, 0x35, 0x32, 0x62, 0x36, 0x38, 0x33, 0x36, 0x32, 0x39, 0x34, 0x65, 0x62, 0x34, 0x33, 0x37, 0x37, 0x31, 0x34, 0x37, 0x39, 0x31, 0x32, 0x39, 0x65, 0x37, 0x32, 0x38, 0x32, 0x34, 0x30, 0x61, 0x64, 0x63, 0x30, 0x38, 0x62, 0x64, 0x30, 0x38, 0x30, 0x35, 0x33, 0x64, 0x32, 0x31, 0x38, 0x36, 0x61, 0x36, 0x66, 0x36, 0x38, 0x63, 0x31, 0x65, 0x61, 0x62, 0x37, 0x30, 0x65, 0x32, 0x66, 0x38, 0x30, 0x37, 0x30, 0x63, 0x64, 0x37, 0x37, 0x35, 0x38, 0x64, 0x38, 0x62, 0x65, 0x39, 0x31, 0x36, 0x34, 0x30, 0x32, 0x63, 0x61, 0x36, 0x32, 0x64, 0x66, 0x37, 0x32, 0x35, 0x35, 0x63, 0x65, 0x30, 0x39, 0x34, 0x32, 0x33, 0x65, 0x37, 0x65, 0x34, 0x34, 0x63, 0x32, 0x66, 0x31, 0x61, 0x36, 0x36, 0x37, 0x37, 0x33, 0x62, 0x39, 0x66, 0x62, 0x37, 0x34, 0x39, 0x65, 0x64, 0x66, 0x39, 0x66, 0x65, 0x61, 0x39, 0x36, 0x30, 0x65, 0x33, 0x35, 0x35, 0x65, 0x64, 0x63, 0x31, 0x65, 0x30, 0x66, 0x31, 0x38, 0x62, 0x66, 0x65, 0x32, 0x32, 0x65, 0x66, 0x31, 0x37, 0x32, 0x62, 0x66, 0x37, 0x61, 0x38, 0x63, 0x37, 0x64, 0x32, 0x63, 0x39, 0x66, 0x36, 0x31, 0x63, 0x61, 0x34, 0x61, 0x65, 0x34, 0x39, 0x30, 0x64, 0x30, 0x39, 0x36, 0x62, 0x37, 0x31, 0x36, 0x37, 0x61, 0x37, 0x65, 0x38, 0x30, 0x39, 0x34, 0x66, 0x36, 0x34, 0x66, 0x36, 0x62, 0x65, 0x39, 0x39, 0x39, 0x35, 0x65, 0x36, 0x31, 0x38, 0x66, 0x33, 0x31, 0x65, 0x34, 0x62, 0x66, 0x36, 0x66, 0x37, 0x32, 0x33, 0x31, 0x34, 0x62, 0x39, 0x65, 0x34, 0x35, 0x32, 0x32, 0x34, 0x34, 0x65, 0x38, 0x35, 0x35, 0x39, 0x35, 0x38, 0x39, 0x66, 0x39, 0x64, 0x34, 0x63, 0x65, 0x34, 0x32, 0x66, 0x31, 0x38, 0x66, 0x61, 0x64, 0x34, 0x31, 0x62, 0x39, 0x30, 0x33, 0x34, 0x35, 0x31, 0x31, 0x35, 0x63, 0x33, 0x31, 0x31, 0x37, 0x38, 0x31, 0x32, 0x35, 0x35, 0x33, 0x61, 0x37, 0x61, 0x33, 0x63, 0x39, 0x34, 0x61, 0x34, 0x63, 0x37, 0x33, 0x32, 0x65, 0x66, 0x32, 0x32, 0x35, 0x63, 0x65, 0x63, 0x63, 0x61, 0x35, 0x64, 0x39, 0x63, 0x36, 0x62, 0x62, 0x34, 0x32, 0x31, 0x64, 0x66, 0x36, 0x30, 0x35, 0x38, 0x37, 0x38, 0x39, 0x63, 0x38, 0x63, 0x65, 0x65, 0x39, 0x33, 0x35, 0x34, 0x61, 0x36, 0x64, 0x33, 0x33, 0x35, 0x34, 0x64, 0x63, 0x62, 0x64, 0x36, 0x65, 0x36, 0x37, 0x63, 0x63, 0x39, 0x31, 0x32, 0x61, 0x36, 0x38, 0x35, 0x30, 0x30, 0x63, 0x65, 0x32, 0x30, 0x63, 0x39, 0x64, 0x32, 0x39, 0x36, 0x65, 0x36, 0x32, 0x36, 0x33, 0x37, 0x61, 0x61, 0x39, 0x63, 0x63, 0x39, 0x61, 0x61, 0x32, 0x66, 0x61, 0x37, 0x31, 0x38, 0x35, 0x63, 0x31, 0x61, 0x65, 0x62, 0x62, 0x33, 0x35, 0x63, 0x61, 0x39, 0x61, 0x62, 0x63, 0x64, 0x66, 0x39, 0x36, 0x38, 0x64, 0x32, 0x62, 0x32, 0x61, 0x63, 0x34, 0x35, 0x66, 0x61, 0x30, 0x31, 0x36, 0x39, 0x39, 0x30, 0x63, 0x63, 0x31, 0x35, 0x66, 0x37, 0x63, 0x39, 0x34, 0x61, 0x30, 0x66, 0x31, 0x61, 0x35, 0x63, 0x34, 0x38, 0x38, 0x61, 0x31, 0x64, 0x30, 0x38, 0x61, 0x64, 0x37, 0x38, 0x65, 0x62, 0x66, 0x62, 0x66, 0x36, 0x35, 0x32, 0x38, 0x32, 0x36, 0x36, 0x65, 0x30, 0x65, 0x35, 0x63, 0x65, 0x62, 0x36, 0x32, 0x63, 0x62, 0x61, 0x32, 0x39, 0x62, 0x37, 0x32, 0x65, 0x33, 0x34, 0x65, 0x34, 0x61, 0x65, 0x36, 0x62, 0x37, 0x61, 0x39, 0x62, 0x35, 0x36, 0x36, 0x63, 0x36, 0x64, 0x32, 0x61, 0x33, 0x37, 0x34, 0x36, 0x30, 0x36, 0x61, 0x38, 0x65, 0x38, 0x39, 0x30, 0x65, 0x37, 0x66, 0x61, 0x62, 0x30, 0x61, 0x35, 0x64, 0x39, 0x39, 0x34, 0x66, 0x33, 0x61, 0x37, 0x39, 0x36, 0x63, 0x38, 0x35, 0x62, 0x64, 0x66, 0x38, 0x64, 0x36, 0x34, 0x62, 0x34, 0x62, 0x38, 0x39, 0x61, 0x32, 0x31, 0x35, 0x31, 0x31, 0x61, 0x36, 0x64, 0x37, 0x65, 0x36, 0x30, 0x37, 0x66, 0x64, 0x31, 0x61, 0x65, 0x65, 0x30, 0x30, 0x37, 0x65, 0x64, 0x38, 0x31, 0x39, 0x63, 0x37, 0x31, 0x30, 0x33, 0x33, 0x35, 0x39, 0x34, 0x39, 0x65, 0x35, 0x39, 0x30, 0x62, 0x37, 0x35, 0x65, 0x39, 0x64, 0x33, 0x36, 0x63, 0x34, 0x38, 0x61, 0x61, 0x32, 0x37, 0x33, 0x38, 0x37, 0x37, 0x32, 0x34, 0x35, 0x32, 0x33, 0x33, 0x61, 0x34, 0x34, 0x35, 0x61, 0x34, 0x64, 0x38, 0x61, 0x31, 0x30, 0x39, 0x33, 0x33, 0x38, 0x32, 0x39, 0x30, 0x61, 0x62, 0x64, 0x33, 0x63, 0x38, 0x64, 0x32, 0x66, 0x65, 0x32, 0x34, 0x31, 0x31, 0x64, 0x32, 0x36, 0x38, 0x35, 0x31, 0x38, 0x30, 0x32, 0x33, 0x33, 0x37, 0x36, 0x33, 0x32, 0x30, 0x61, 0x32, 0x39, 0x63, 0x36, 0x31, 0x38, 0x32, 0x37, 0x37, 0x32, 0x31, 0x36, 0x66, 0x61, 0x32, 0x38, 0x61, 0x36, 0x37, 0x64, 0x61, 0x34, 0x35, 0x64, 0x62, 0x39, 0x39, 0x65, 0x33, 0x64, 0x33, 0x38, 0x31, 0x63, 0x66, 0x61, 0x32, 0x30, 0x38, 0x66, 0x37, 0x63, 0x37, 0x30, 0x33, 0x39, 0x39, 0x37, 0x35, 0x34, 0x31, 0x61, 0x61, 0x65, 0x31, 0x39, 0x65, 0x35, 0x66, 0x37, 0x62, 0x62, 0x64, 0x34, 0x32, 0x38, 0x33, 0x31, 0x38, 0x37, 0x32, 0x38, 0x37, 0x32, 0x31, 0x39, 0x66, 0x63, 0x35, 0x32, 0x32, 0x65, 0x33, 0x63, 0x31, 0x32, 0x35, 0x30, 0x34, 0x37, 0x63, 0x64, 0x35, 0x64, 0x62, 0x30, 0x39, 0x62, 0x30, 0x61, 0x37, 0x62, 0x30, 0x36, 0x32, 0x36, 0x39, 0x39, 0x63, 0x64, 0x32, 0x63, 0x31, 0x34, 0x34, 0x63, 0x61, 0x36, 0x64, 0x34, 0x33, 0x30, 0x37, 0x33, 0x36, 0x66, 0x32, 0x65, 0x31, 0x34, 0x32, 0x63, 0x64, 0x63, 0x65, 0x62, 0x32, 0x32, 0x33, 0x65, 0x39, 0x64, 0x31, 0x35, 0x34, 0x66, 0x65, 0x37, 0x33, 0x30, 0x64, 0x61, 0x39, 0x39, 0x65, 0x31, 0x34, 0x35, 0x61, 0x30, 0x66, 0x37, 0x62, 0x64, 0x38, 0x30, 0x38, 0x30, 0x37, 0x31, 0x63, 0x34, 0x65, 0x31, 0x64, 0x36, 0x66, 0x63, 0x31, 0x34, 0x35, 0x34, 0x37, 0x62, 0x34, 0x36, 0x37, 0x30, 0x32, 0x34, 0x32, 0x31, 0x31, 0x35, 0x64, 0x31, 0x36, 0x39, 0x64, 0x34, 0x37, 0x32, 0x63, 0x63, 0x61, 0x61, 0x33, 0x39, 0x37, 0x33, 0x63, 0x65, 0x30, 0x61, 0x62, 0x38, 0x38, 0x36, 0x63, 0x32, 0x37, 0x61, 0x35, 0x31, 0x35, 0x35, 0x37, 0x35, 0x35, 0x61, 0x36, 0x65, 0x64, 0x66, 0x30, 0x37, 0x61, 0x61, 0x38, 0x37, 0x30, 0x39, 0x61, 0x39, 0x37, 0x34, 0x65, 0x62, 0x66, 0x34, 0x37, 0x62, 0x37, 0x38, 0x63, 0x38, 0x37, 0x61, 0x36, 0x37, 0x36, 0x38, 0x65, 0x33, 0x31, 0x65, 0x38, 0x33, 0x33, 0x33, 0x65, 0x36, 0x36, 0x38, 0x63, 0x37, 0x61, 0x66, 0x66, 0x62, 0x35, 0x64, 0x30, 0x63, 0x61, 0x64, 0x30, 0x64, 0x61, 0x62, 0x32, 0x66, 0x39, 0x35, 0x34, 0x32, 0x36, 0x31, 0x32, 0x65, 0x35, 0x63, 0x61, 0x65, 0x32, 0x63, 0x37, 0x32, 0x63, 0x35, 0x35, 0x63, 0x30, 0x64, 0x31, 0x66, 0x31, 0x30, 0x31, 0x30, 0x32, 0x63, 0x37, 0x63, 0x36, 0x36, 0x36, 0x66, 0x32, 0x63, 0x33, 0x37, 0x39, 0x66, 0x64, 0x35, 0x65, 0x63, 0x31, 0x62, 0x39, 0x30, 0x39, 0x63, 0x66, 0x35, 0x32, 0x32, 0x62, 0x62, 0x34, 0x37, 0x62, 0x61, 0x64, 0x38, 0x64, 0x65, 0x33, 0x37, 0x64, 0x62, 0x66, 0x66, 0x66, 0x64, 0x36, 0x39, 0x31, 0x30, 0x31, 0x66, 0x65, 0x34, 0x62, 0x39, 0x61, 0x33, 0x37, 0x35, 0x30, 0x64, 0x61, 0x32, 0x62, 0x39, 0x65, 0x63, 0x31, 0x35, 0x32, 0x37, 0x37, 0x32, 0x32, 0x30, 0x36, 0x38, 0x65, 0x62, 0x63, 0x37, 0x32, 0x38, 0x33, 0x37, 0x38, 0x37, 0x62, 0x31, 0x65, 0x64, 0x36, 0x34, 0x61, 0x62, 0x33, 0x39, 0x38, 0x64, 0x38, 0x30, 0x34, 0x39, 0x31, 0x35, 0x33, 0x31, 0x63, 0x33, 0x31, 0x63, 0x35, 0x37, 0x30, 0x32, 0x36, 0x36, 0x33, 0x37, 0x30, 0x35, 0x39, 0x66, 0x33, 0x31, 0x64, 0x38, 0x39, 0x62, 0x35, 0x39, 0x64, 0x33, 0x62, 0x35, 0x37, 0x32, 0x31, 0x65, 0x37, 0x66, 0x65, 0x66, 0x33, 0x34, 0x64, 0x63, 0x38, 0x32, 0x30, 0x39, 0x33, 0x64, 0x39, 0x30, 0x33, 0x63, 0x36, 0x34, 0x62, 0x34, 0x30, 0x64, 0x32, 0x30, 0x63, 0x65, 0x32, 0x39, 0x35, 0x31, 0x65, 0x30, 0x62, 0x38, 0x34, 0x62, 0x65, 0x65, 0x35, 0x66, 0x32, 0x31, 0x62, 0x34, 0x35, 0x32, 0x36, 0x66, 0x31, 0x65, 0x65, 0x64, 0x36, 0x33, 0x35, 0x33, 0x39, 0x61, 0x30, 0x62, 0x65, 0x36, 0x32, 0x64, 0x35, 0x66, 0x31, 0x66, 0x61, 0x65, 0x64, 0x35, 0x38, 0x37, 0x64, 0x36, 0x64, 0x37, 0x66, 0x36, 0x66, 0x31, 0x36, 0x30, 0x63, 0x61, 0x38, 0x34, 0x66, 0x39, 0x38, 0x61, 0x39, 0x34, 0x35, 0x64, 0x33, 0x30, 0x35, 0x32, 0x61, 0x63, 0x35, 0x38, 0x65, 0x39, 0x62, 0x37, 0x61, 0x31, 0x33, 0x36, 0x64, 0x31, 0x37, 0x61, 0x65, 0x33, 0x32, 0x33, 0x37, 0x33, 0x33, 0x62, 0x30, 0x31, 0x37, 0x61, 0x36, 0x35, 0x64, 0x31, 0x64, 0x31, 0x62, 0x66, 0x66, 0x30, 0x38, 0x61, 0x35, 0x34, 0x34, 0x34, 0x64, 0x32, 0x36, 0x33, 0x61, 0x37, 0x32, 0x34, 0x31, 0x61, 0x32, 0x63, 0x30, 0x64, 0x65, 0x32, 0x39, 0x39, 0x63, 0x61, 0x64, 0x65, 0x63, 0x33, 0x61, 0x38, 0x39, 0x35, 0x64, 0x66, 0x37, 0x65, 0x64, 0x33, 0x63, 0x34, 0x38, 0x66, 0x39, 0x38, 0x30, 0x63, 0x36, 0x65, 0x31, 0x38, 0x33, 0x35, 0x35, 0x34, 0x62, 0x64, 0x62, 0x30, 0x62, 0x34, 0x32, 0x36, 0x39, 0x34, 0x33, 0x33, 0x39, 0x64, 0x37, 0x35, 0x30, 0x33, 0x65, 0x30, 0x38, 0x65, 0x31, 0x34, 0x36, 0x33, 0x30, 0x31, 0x61, 0x35, 0x35, 0x37, 0x32, 0x66, 0x64, 0x35, 0x65, 0x34, 0x64, 0x65, 0x35, 0x38, 0x30, 0x32, 0x64, 0x39, 0x65, 0x34, 0x36, 0x61, 0x39, 0x36, 0x35, 0x34, 0x38, 0x38, 0x37, 0x32, 0x38, 0x31, 0x38, 0x30, 0x39, 0x61, 0x61, 0x66, 0x33, 0x62, 0x35, 0x37, 0x38, 0x37, 0x35, 0x64, 0x63, 0x65, 0x32, 0x63, 0x30, 0x66, 0x61, 0x30, 0x62, 0x38, 0x39, 0x35, 0x30, 0x64, 0x36, 0x66, 0x32, 0x38, 0x61, 0x35, 0x36, 0x39, 0x63, 0x36, 0x37, 0x64, 0x38, 0x35, 0x64, 0x31, 0x39, 0x32, 0x63, 0x39, 0x34, 0x62, 0x66, 0x38, 0x62, 0x37, 0x32, 0x33, 0x39, 0x65, 0x63, 0x31, 0x37, 0x32, 0x64, 0x35, 0x34, 0x37, 0x64, 0x66, 0x66, 0x38, 0x36, 0x35, 0x38, 0x64, 0x33, 0x65, 0x34, 0x66, 0x32, 0x33, 0x37, 0x66, 0x39, 0x30, 0x36, 0x33, 0x39, 0x37, 0x63, 0x35, 0x34, 0x31, 0x39, 0x64, 0x66, 0x34, 0x30, 0x66, 0x32, 0x61, 0x33, 0x30, 0x36, 0x37, 0x63, 0x39, 0x61, 0x36, 0x37, 0x66, 0x64, 0x39, 0x33, 0x33, 0x36, 0x35, 0x61, 0x38, 0x62, 0x32, 0x30, 0x64, 0x63, 0x33, 0x37, 0x32, 0x30, 0x61, 0x32, 0x61, 0x33, 0x38, 0x36, 0x34, 0x36, 0x61, 0x35, 0x66, 0x62, 0x61, 0x37, 0x34, 0x35, 0x32, 0x62, 0x32, 0x32, 0x66, 0x36, 0x65, 0x32, 0x39, 0x66, 0x38, 0x64, 0x37, 0x61, 0x38, 0x31, 0x31, 0x36, 0x65, 0x62, 0x34, 0x38, 0x66, 0x61, 0x35, 0x38, 0x64, 0x36, 0x35, 0x38, 0x37, 0x39, 0x34, 0x33, 0x38, 0x37, 0x66, 0x36, 0x35, 0x31, 0x35, 0x31, 0x36, 0x37, 0x38, 0x32, 0x31, 0x64, 0x36, 0x38, 0x62, 0x31, 0x62, 0x62, 0x30, 0x36, 0x30, 0x32, 0x63, 0x30, 0x31, 0x61, 0x31, 0x33, 0x36, 0x31, 0x64, 0x62, 0x36, 0x66, 0x35, 0x36, 0x39, 0x38, 0x37, 0x65, 0x66, 0x37, 0x39, 0x38, 0x32, 0x36, 0x32, 0x65, 0x37, 0x35, 0x33, 0x39, 0x65, 0x30, 0x66, 0x31, 0x62, 0x66, 0x66, 0x65, 0x38, 0x61, 0x64, 0x63, 0x35, 0x63, 0x31, 0x30, 0x64, 0x32, 0x36, 0x65, 0x36, 0x37, 0x32, 0x31, 0x37, 0x33, 0x61, 0x33, 0x32, 0x38, 0x30, 0x63, 0x32, 0x63, 0x62, 0x66, 0x61, 0x30, 0x33, 0x38, 0x36, 0x39, 0x64, 0x32, 0x34, 0x39, 0x37, 0x36, 0x37, 0x39, 0x64, 0x66, 0x34, 0x37, 0x61, 0x33, 0x64, 0x39, 0x33, 0x30, 0x35, 0x32, 0x34, 0x61, 0x33, 0x33, 0x37, 0x38, 0x37, 0x63, 0x65, 0x34, 0x62, 0x36, 0x30, 0x62, 0x65, 0x39, 0x34, 0x63, 0x66, 0x36, 0x35, 0x37, 0x36, 0x37, 0x32, 0x66, 0x66, 0x31, 0x39, 0x61, 0x32, 0x61, 0x63, 0x64, 0x66, 0x34, 0x32, 0x62, 0x31, 0x66, 0x64, 0x64, 0x35, 0x65, 0x61, 0x65, 0x62, 0x36, 0x64, 0x62, 0x66, 0x37, 0x64, 0x65, 0x37, 0x35, 0x38, 0x37, 0x66, 0x37, 0x63, 0x64, 0x63, 0x34, 0x35, 0x65, 0x64, 0x38, 0x62, 0x64, 0x33, 0x30, 0x37, 0x39, 0x31, 0x35, 0x31, 0x66, 0x38, 0x30, 0x63, 0x30, 0x37, 0x33, 0x65, 0x35, 0x65, 0x37, 0x32, 0x66, 0x37, 0x35, 0x63, 0x66, 0x64, 0x36, 0x34, 0x66, 0x61, 0x32, 0x62, 0x32, 0x61, 0x66, 0x34, 0x63, 0x65, 0x38, 0x36, 0x61, 0x33, 0x65, 0x37, 0x34, 0x66, 0x39, 0x31, 0x62, 0x31, 0x66, 0x31, 0x36, 0x31, 0x66, 0x64, 0x64, 0x63, 0x36, 0x34, 0x30, 0x64, 0x38, 0x30, 0x66, 0x30, 0x31, 0x63, 0x63, 0x39, 0x39, 0x34, 0x63, 0x39, 0x37, 0x39, 0x61, 0x64, 0x62, 0x61, 0x63, 0x30, 0x37, 0x32, 0x31, 0x31, 0x31, 0x61, 0x35, 0x32, 0x37, 0x33, 0x35, 0x39, 0x39, 0x39, 0x61, 0x63, 0x34, 0x37, 0x63, 0x62, 0x35, 0x66, 0x66, 0x37, 0x39, 0x63, 0x63, 0x32, 0x38, 0x36, 0x66, 0x61, 0x61, 0x63, 0x37, 0x34, 0x61, 0x66, 0x32, 0x64, 0x32, 0x36, 0x64, 0x63, 0x31, 0x38, 0x35, 0x66, 0x31, 0x66, 0x30, 0x63, 0x64, 0x32, 0x62, 0x36, 0x30, 0x61, 0x39, 0x37, 0x65, 0x66, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x38, 0x64, 0x63, 0x37, 0x61, 0x38, 0x66, 0x61, 0x38, 0x32, 0x34, 0x31, 0x36, 0x63, 0x36, 0x65, 0x39, 0x38, 0x36, 0x66, 0x31, 0x66, 0x36, 0x37, 0x30, 0x61, 0x37, 0x66, 0x62, 0x35, 0x31, 0x64, 0x63, 0x35, 0x33, 0x34, 0x31, 0x62, 0x37, 0x63, 0x64, 0x36, 0x61, 0x62, 0x32, 0x39, 0x30, 0x36, 0x35, 0x33, 0x32, 0x30, 0x35, 0x32, 0x38, 0x63, 0x34, 0x62, 0x33, 0x35, 0x37, 0x32, 0x66, 0x62, 0x62, 0x30, 0x30, 0x36, 0x34, 0x39, 0x65, 0x63, 0x36, 0x33, 0x61, 0x37, 0x65, 0x35, 0x63, 0x31, 0x37, 0x34, 0x39, 0x64, 0x31, 0x37, 0x36, 0x35, 0x65, 0x30, 0x30, 0x39, 0x37, 0x34, 0x64, 0x65, 0x33, 0x35, 0x31, 0x39, 0x31, 0x62, 0x37, 0x30, 0x30, 0x30, 0x64, 0x35, 0x30, 0x30, 0x33, 0x32, 0x64, 0x30, 0x38, 0x66, 0x64, 0x33, 0x35, 0x33, 0x34, 0x65, 0x66, 0x62, 0x31, 0x36, 0x34, 0x36, 0x63, 0x39, 0x61, 0x36, 0x63, 0x30, 0x65, 0x34, 0x39, 0x31, 0x30, 0x38, 0x36, 0x65, 0x36, 0x35, 0x34, 0x65, 0x39, 0x35, 0x34, 0x65, 0x37, 0x35, 0x62, 0x34, 0x63, 0x66, 0x63, 0x63, 0x61, 0x63, 0x37, 0x64, 0x63, 0x62, 0x38, 0x63, 0x66, 0x34, 0x38, 0x38, 0x30, 0x33, 0x34, 0x36, 0x33, 0x65, 0x33, 0x34, 0x39, 0x63, 0x38, 0x35, 0x39, 0x32, 0x35, 0x32, 0x30, 0x61, 0x34, 0x35, 0x34, 0x37, 0x64, 0x34, 0x61, 0x35, 0x64, 0x35, 0x36, 0x30, 0x39, 0x37, 0x33, 0x39, 0x35, 0x35, 0x32, 0x37, 0x66, 0x63, 0x61, 0x36, 0x63, 0x64, 0x65, 0x61, 0x31, 0x33, 0x61, 0x31, 0x34, 0x62, 0x66, 0x65, 0x62, 0x66, 0x64, 0x31, 0x66, 0x31, 0x66, 0x32, 0x36, 0x39, 0x63, 0x33, 0x32, 0x37, 0x32, 0x65, 0x65, 0x37, 0x66, 0x62, 0x33, 0x31, 0x39, 0x32, 0x37, 0x33, 0x61, 0x38, 0x36, 0x38, 0x34, 0x37, 0x31, 0x63, 0x62, 0x66, 0x37, 0x38, 0x31, 0x38, 0x30, 0x66, 0x34, 0x63, 0x65, 0x63, 0x36, 0x30, 0x31, 0x61, 0x65, 0x39, 0x31, 0x65, 0x33, 0x62, 0x30, 0x61, 0x32, 0x36, 0x30, 0x66, 0x62, 0x63, 0x65, 0x65, 0x66, 0x34, 0x38, 0x32, 0x35, 0x36, 0x66, 0x64, 0x66, 0x33, 0x33, 0x37, 0x62, 0x62, 0x63, 0x32, 0x33, 0x34, 0x63, 0x64, 0x61, 0x32, 0x63, 0x35, 0x33, 0x35, 0x37, 0x32, 0x66, 0x31, 0x62, 0x62, 0x61, 0x38, 0x34, 0x61, 0x38, 0x62, 0x34, 0x30, 0x37, 0x65, 0x35, 0x33, 0x33, 0x39, 0x37, 0x65, 0x35, 0x31, 0x38, 0x39, 0x31, 0x39, 0x36, 0x31, 0x61, 0x33, 0x32, 0x33, 0x38, 0x38, 0x64, 0x36, 0x33, 0x38, 0x30, 0x65, 0x33, 0x36, 0x30, 0x38, 0x30, 0x65, 0x62, 0x64, 0x62, 0x65, 0x65, 0x64, 0x30, 0x35, 0x63, 0x34, 0x66, 0x62, 0x34, 0x61, 0x38, 0x63, 0x34, 0x62, 0x34, 0x61, 0x66, 0x65, 0x65, 0x61, 0x31, 0x35, 0x37, 0x36, 0x34, 0x36, 0x66, 0x34, 0x63, 0x30, 0x30, 0x39, 0x37, 0x34, 0x64, 0x36, 0x37, 0x32, 0x66, 0x35, 0x65, 0x32, 0x62, 0x39, 0x39, 0x38, 0x33, 0x38, 0x65, 0x65, 0x65, 0x38, 0x32, 0x39, 0x34, 0x32, 0x31, 0x33, 0x31, 0x34, 0x66, 0x34, 0x36, 0x35, 0x37, 0x36, 0x63, 0x32, 0x65, 0x62, 0x65, 0x33, 0x66, 0x65, 0x64, 0x32, 0x37, 0x32, 0x36, 0x32, 0x31, 0x36, 0x37, 0x32, 0x65, 0x35, 0x61, 0x30, 0x62, 0x34, 0x37, 0x61, 0x64, 0x30, 0x38, 0x65, 0x64, 0x32, 0x37, 0x63, 0x38, 0x37, 0x36, 0x35, 0x39, 0x30, 0x38, 0x33, 0x36, 0x38, 0x36, 0x30, 0x34, 0x35, 0x62, 0x37, 0x66, 0x34, 0x38, 0x65, 0x32, 0x38, 0x62, 0x62, 0x32, 0x35, 0x37, 0x36, 0x63, 0x38, 0x30, 0x63, 0x30, 0x62, 0x35, 0x31, 0x38, 0x39, 0x35, 0x61, 0x37, 0x32, 0x65, 0x35, 0x32, 0x39, 0x66, 0x33, 0x30, 0x64, 0x36, 0x64, 0x65, 0x34, 0x36, 0x34, 0x36, 0x38, 0x30, 0x64, 0x64, 0x63, 0x62, 0x66, 0x32, 0x36, 0x33, 0x62, 0x36, 0x32, 0x32, 0x66, 0x61, 0x31, 0x36, 0x37, 0x32, 0x32, 0x61, 0x63, 0x35, 0x64, 0x63, 0x64, 0x38, 0x63, 0x37, 0x34, 0x37, 0x64, 0x37, 0x30, 0x64, 0x38, 0x32, 0x65, 0x39, 0x37, 0x33, 0x34, 0x63, 0x38, 0x36, 0x33, 0x37, 0x32, 0x33, 0x37, 0x65, 0x37, 0x66, 0x64, 0x63, 0x61, 0x62, 0x66, 0x61, 0x32, 0x64, 0x38, 0x31, 0x31, 0x35, 0x30, 0x33, 0x32, 0x37, 0x30, 0x36, 0x34, 0x64, 0x33, 0x61, 0x30, 0x33, 0x36, 0x66, 0x31, 0x35, 0x36, 0x66, 0x37, 0x63, 0x62, 0x66, 0x66, 0x33, 0x61, 0x65, 0x34, 0x34, 0x36, 0x33, 0x31, 0x37, 0x61, 0x37, 0x31, 0x31, 0x66, 0x33, 0x39, 0x37, 0x30, 0x32, 0x33, 0x65, 0x39, 0x37, 0x32, 0x63, 0x37, 0x32, 0x33, 0x33, 0x30, 0x61, 0x63, 0x63, 0x36, 0x65, 0x61, 0x33, 0x31, 0x32, 0x30, 0x66, 0x62, 0x30, 0x36, 0x64, 0x31, 0x36, 0x37, 0x65, 0x37, 0x65, 0x65, 0x39, 0x66, 0x30, 0x30, 0x65, 0x38, 0x65, 0x30, 0x36, 0x65, 0x37, 0x35, 0x65, 0x33, 0x64, 0x62, 0x64, 0x33, 0x30, 0x65, 0x35, 0x35, 0x30, 0x30, 0x38, 0x36, 0x64, 0x62, 0x66, 0x66, 0x39, 0x61, 0x61, 0x66, 0x37, 0x32, 0x62, 0x64, 0x32, 0x64, 0x34, 0x62, 0x38, 0x61, 0x30, 0x66, 0x37, 0x61, 0x30, 0x65, 0x38, 0x38, 0x35, 0x34, 0x32, 0x66, 0x37, 0x35, 0x39, 0x37, 0x64, 0x31, 0x37, 0x38, 0x34, 0x38, 0x31, 0x35, 0x37, 0x33, 0x66, 0x32, 0x31, 0x33, 0x35, 0x66, 0x37, 0x37, 0x65, 0x66, 0x63, 0x62, 0x66, 0x31, 0x32, 0x64, 0x61, 0x35, 0x38, 0x64, 0x63, 0x31, 0x34, 0x31, 0x61, 0x33, 0x66, 0x34, 0x37, 0x32, 0x34, 0x35, 0x62, 0x62, 0x32, 0x36, 0x62, 0x31, 0x33, 0x36, 0x31, 0x35, 0x63, 0x31, 0x33, 0x62, 0x64, 0x36, 0x65, 0x38, 0x61, 0x63, 0x33, 0x61, 0x37, 0x36, 0x34, 0x35, 0x32, 0x65, 0x31, 0x63, 0x34, 0x65, 0x37, 0x62, 0x65, 0x36, 0x37, 0x36, 0x64, 0x61, 0x61, 0x33, 0x63, 0x34, 0x34, 0x62, 0x66, 0x36, 0x64, 0x35, 0x66, 0x32, 0x66, 0x63, 0x32, 0x34, 0x32, 0x62, 0x32, 0x39, 0x33, 0x30, 0x65, 0x33, 0x36, 0x30, 0x35, 0x63, 0x63, 0x62, 0x64, 0x37, 0x36, 0x32, 0x63, 0x34, 0x65, 0x63, 0x31, 0x65, 0x37, 0x66, 0x61, 0x63, 0x63, 0x31, 0x31, 0x66, 0x64, 0x35, 0x33, 0x35, 0x36, 0x61, 0x62, 0x34, 0x33, 0x36, 0x61, 0x64, 0x62, 0x64, 0x65, 0x36, 0x31, 0x65, 0x33, 0x31, 0x62, 0x37, 0x37, 0x36, 0x38, 0x39, 0x66, 0x64, 0x65, 0x31, 0x31, 0x61, 0x39, 0x33, 0x36, 0x66, 0x32, 0x32, 0x31, 0x33, 0x64, 0x63, 0x35, 0x33, 0x64, 0x34, 0x39, 0x38, 0x38, 0x31, 0x39, 0x63, 0x30, 0x30, 0x66, 0x65, 0x38, 0x33, 0x66, 0x63, 0x35, 0x61, 0x64, 0x33, 0x61, 0x62, 0x34, 0x32, 0x61, 0x64, 0x66, 0x38, 0x37, 0x33, 0x35, 0x66, 0x66, 0x32, 0x36, 0x64, 0x37, 0x64, 0x38, 0x65, 0x61, 0x65, 0x36, 0x37, 0x32, 0x38, 0x62, 0x31, 0x39, 0x66, 0x35, 0x65, 0x61, 0x34, 0x32, 0x33, 0x37, 0x32, 0x30, 0x32, 0x30, 0x31, 0x35, 0x35, 0x36, 0x38, 0x66, 0x37, 0x39, 0x30, 0x38, 0x30, 0x31, 0x65, 0x32, 0x39, 0x63, 0x62, 0x62, 0x32, 0x38, 0x61, 0x61, 0x64, 0x38, 0x31, 0x30, 0x36, 0x66, 0x35, 0x31, 0x62, 0x64, 0x61, 0x66, 0x39, 0x34, 0x32, 0x32, 0x64, 0x61, 0x34, 0x37, 0x63, 0x36, 0x65, 0x62, 0x61, 0x36, 0x66, 0x64, 0x38, 0x32, 0x65, 0x61, 0x32, 0x36, 0x66, 0x32, 0x30, 0x37, 0x32, 0x32, 0x39, 0x65, 0x65, 0x31, 0x66, 0x62, 0x63, 0x30, 0x33, 0x63, 0x65, 0x36, 0x33, 0x39, 0x62, 0x31, 0x33, 0x34, 0x32, 0x61, 0x64, 0x62, 0x39, 0x31, 0x66, 0x65, 0x63, 0x39, 0x35, 0x35, 0x35, 0x64, 0x64, 0x65, 0x64, 0x66, 0x31, 0x64, 0x64, 0x65, 0x31, 0x65, 0x65, 0x66, 0x30, 0x37, 0x30, 0x32, 0x32, 0x36, 0x62, 0x65, 0x32, 0x38, 0x36, 0x31, 0x31, 0x35, 0x39, 0x37, 0x35, 0x31, 0x37, 0x34, 0x63, 0x30, 0x66, 0x66, 0x30, 0x35, 0x38, 0x64, 0x62, 0x37, 0x32, 0x32, 0x32, 0x33, 0x32, 0x62, 0x30, 0x30, 0x39, 0x39, 0x31, 0x33, 0x33, 0x33, 0x34, 0x36, 0x34, 0x30, 0x36, 0x61, 0x34, 0x65, 0x32, 0x63, 0x65, 0x39, 0x63, 0x62, 0x33, 0x31, 0x31, 0x63, 0x36, 0x35, 0x34, 0x36, 0x31, 0x61, 0x38, 0x39, 0x32, 0x34, 0x35, 0x38, 0x38, 0x65, 0x39, 0x34, 0x62, 0x66, 0x39, 0x37, 0x30, 0x34, 0x39, 0x62, 0x38, 0x65, 0x36, 0x64, 0x33, 0x36, 0x63, 0x63, 0x37, 0x61, 0x35, 0x36, 0x38, 0x37, 0x30, 0x34, 0x30, 0x32, 0x38, 0x32, 0x37, 0x35, 0x31, 0x30, 0x31, 0x62, 0x66, 0x65, 0x65, 0x33, 0x30, 0x39, 0x64, 0x63, 0x33, 0x64, 0x37, 0x38, 0x62, 0x30, 0x65, 0x34, 0x63, 0x66, 0x33, 0x31, 0x30, 0x62, 0x63, 0x66, 0x37, 0x61, 0x31, 0x31, 0x35, 0x64, 0x66, 0x33, 0x62, 0x34, 0x34, 0x34, 0x39, 0x64, 0x66, 0x36, 0x31, 0x36, 0x61, 0x62, 0x66, 0x61, 0x63, 0x37, 0x34, 0x32, 0x62, 0x63, 0x31, 0x30, 0x39, 0x66, 0x65, 0x37, 0x36, 0x65, 0x66, 0x65, 0x63, 0x63, 0x39, 0x65, 0x31, 0x39, 0x61, 0x37, 0x32, 0x39, 0x33, 0x39, 0x35, 0x31, 0x62, 0x33, 0x64, 0x37, 0x39, 0x38, 0x36, 0x34, 0x32, 0x63, 0x62, 0x35, 0x33, 0x61, 0x38, 0x32, 0x37, 0x62, 0x35, 0x30, 0x62, 0x37, 0x32, 0x34, 0x30, 0x63, 0x36, 0x36, 0x62, 0x64, 0x37, 0x31, 0x66, 0x64, 0x62, 0x34, 0x38, 0x38, 0x64, 0x66, 0x30, 0x62, 0x33, 0x64, 0x36, 0x37, 0x38, 0x61, 0x30, 0x61, 0x33, 0x62, 0x36, 0x62, 0x30, 0x38, 0x33, 0x39, 0x32, 0x62, 0x32, 0x62, 0x35, 0x62, 0x37, 0x61, 0x30, 0x31, 0x33, 0x36, 0x37, 0x62, 0x64, 0x39, 0x63, 0x64, 0x63, 0x38, 0x62, 0x33, 0x32, 0x63, 0x35, 0x30, 0x37, 0x34, 0x36, 0x63, 0x32, 0x65, 0x34, 0x35, 0x64, 0x37, 0x35, 0x65, 0x35, 0x66, 0x61, 0x64, 0x64, 0x33, 0x65, 0x63, 0x37, 0x35, 0x62, 0x64, 0x37, 0x32, 0x37, 0x66, 0x31, 0x63, 0x33, 0x62, 0x35, 0x38, 0x62, 0x35, 0x33, 0x31, 0x31, 0x38, 0x62, 0x36, 0x61, 0x37, 0x62, 0x37, 0x39, 0x30, 0x37, 0x33, 0x33, 0x34, 0x65, 0x35, 0x65, 0x31, 0x61, 0x32, 0x62, 0x32, 0x34, 0x64, 0x32, 0x62, 0x35, 0x37, 0x32, 0x32, 0x35, 0x33, 0x37, 0x38, 0x31, 0x62, 0x36, 0x62, 0x39, 0x33, 0x34, 0x32, 0x36, 0x34, 0x61, 0x35, 0x63, 0x34, 0x39, 0x32, 0x35, 0x63, 0x36, 0x30, 0x31, 0x34, 0x33, 0x63, 0x66, 0x36, 0x62, 0x32, 0x37, 0x32, 0x64, 0x34, 0x64, 0x65, 0x34, 0x32, 0x38, 0x32, 0x64, 0x62, 0x61, 0x36, 0x66, 0x30, 0x64, 0x31, 0x35, 0x38, 0x31, 0x62, 0x32, 0x62, 0x63, 0x39, 0x34, 0x38, 0x61, 0x37, 0x32, 0x66, 0x34, 0x63, 0x65, 0x66, 0x34, 0x32, 0x32, 0x34, 0x66, 0x36, 0x32, 0x65, 0x61, 0x33, 0x32, 0x65, 0x36, 0x37, 0x64, 0x63, 0x63, 0x31, 0x37, 0x31, 0x33, 0x30, 0x64, 0x66, 0x62, 0x38, 0x34, 0x38, 0x30, 0x37, 0x36, 0x64, 0x37, 0x35, 0x32, 0x38, 0x37, 0x33, 0x39, 0x64, 0x35, 0x32, 0x35, 0x31, 0x61, 0x66, 0x37, 0x37, 0x36, 0x65, 0x37, 0x33, 0x61, 0x36, 0x65, 0x38, 0x36, 0x32, 0x33, 0x37, 0x35, 0x35, 0x61, 0x38, 0x35, 0x39, 0x31, 0x66, 0x30, 0x65, 0x31, 0x38, 0x37, 0x32, 0x37, 0x38, 0x61, 0x32, 0x37, 0x63, 0x31, 0x30, 0x34, 0x32, 0x37, 0x66, 0x34, 0x30, 0x30, 0x63, 0x36, 0x62, 0x62, 0x65, 0x65, 0x62, 0x64, 0x38, 0x61, 0x39, 0x64, 0x31, 0x63, 0x62, 0x64, 0x31, 0x33, 0x32, 0x62, 0x31, 0x35, 0x66, 0x62, 0x63, 0x61, 0x39, 0x35, 0x33, 0x64, 0x39, 0x30, 0x30, 0x31, 0x64, 0x36, 0x38, 0x39, 0x39, 0x39, 0x63, 0x64, 0x38, 0x62, 0x37, 0x34, 0x63, 0x62, 0x64, 0x37, 0x64, 0x39, 0x31, 0x31, 0x66, 0x64, 0x38, 0x64, 0x63, 0x38, 0x63, 0x64, 0x66, 0x38, 0x33, 0x64, 0x30, 0x63, 0x64, 0x66, 0x65, 0x35, 0x62, 0x37, 0x62, 0x31, 0x65, 0x64, 0x38, 0x39, 0x63, 0x63, 0x34, 0x33, 0x35, 0x63, 0x37, 0x33, 0x65, 0x65, 0x61, 0x62, 0x33, 0x38, 0x61, 0x32, 0x37, 0x32, 0x64, 0x39, 0x30, 0x66, 0x37, 0x64, 0x65, 0x34, 0x35, 0x33, 0x34, 0x66, 0x66, 0x63, 0x62, 0x35, 0x30, 0x37, 0x33, 0x38, 0x32, 0x62, 0x31, 0x35, 0x62, 0x31, 0x38, 0x36, 0x31, 0x62, 0x32, 0x38, 0x30, 0x31, 0x61, 0x63, 0x31, 0x34, 0x63, 0x31, 0x32, 0x37, 0x39, 0x35, 0x64, 0x30, 0x36, 0x63, 0x63, 0x31, 0x34, 0x38, 0x66, 0x33, 0x66, 0x31, 0x35, 0x37, 0x36, 0x33, 0x63, 0x38, 0x37, 0x32, 0x34, 0x64, 0x32, 0x62, 0x33, 0x65, 0x66, 0x66, 0x33, 0x61, 0x63, 0x34, 0x62, 0x31, 0x39, 0x32, 0x61, 0x39, 0x64, 0x34, 0x65, 0x34, 0x62, 0x30, 0x66, 0x37, 0x30, 0x30, 0x64, 0x33, 0x38, 0x66, 0x37, 0x39, 0x31, 0x66, 0x65, 0x30, 0x66, 0x62, 0x65, 0x32, 0x34, 0x32, 0x63, 0x31, 0x30, 0x31, 0x39, 0x37, 0x63, 0x62, 0x35, 0x62, 0x63, 0x33, 0x32, 0x36, 0x31, 0x35, 0x66, 0x35, 0x34, 0x33, 0x64, 0x31, 0x33, 0x66, 0x34, 0x38, 0x64, 0x61, 0x63, 0x62, 0x38, 0x61, 0x65, 0x31, 0x65, 0x64, 0x33, 0x38, 0x39, 0x31, 0x66, 0x35, 0x36, 0x39, 0x37, 0x30, 0x33, 0x39, 0x66, 0x38, 0x32, 0x30, 0x64, 0x35, 0x32, 0x31, 0x61, 0x63, 0x32, 0x35, 0x37, 0x38, 0x30, 0x36, 0x30, 0x33, 0x37, 0x33, 0x64, 0x31, 0x38, 0x64, 0x33, 0x63, 0x62, 0x33, 0x37, 0x36, 0x38, 0x61, 0x39, 0x61, 0x37, 0x32, 0x34, 0x65, 0x63, 0x38, 0x36, 0x36, 0x36, 0x66, 0x64, 0x63, 0x66, 0x36, 0x31, 0x31, 0x34, 0x39, 0x37, 0x61, 0x39, 0x30, 0x39, 0x35, 0x33, 0x37, 0x35, 0x35, 0x39, 0x36, 0x61, 0x66, 0x32, 0x31, 0x65, 0x39, 0x64, 0x30, 0x35, 0x37, 0x63, 0x31, 0x63, 0x37, 0x34, 0x32, 0x36, 0x36, 0x63, 0x39, 0x36, 0x31, 0x61, 0x32, 0x66, 0x30, 0x37, 0x30, 0x33, 0x62, 0x38, 0x61, 0x33, 0x64, 0x36, 0x33, 0x38, 0x65, 0x64, 0x66, 0x64, 0x65, 0x39, 0x37, 0x31, 0x65, 0x37, 0x31, 0x38, 0x30, 0x35, 0x37, 0x31, 0x30, 0x38, 0x66, 0x61, 0x35, 0x33, 0x39, 0x37, 0x65, 0x35, 0x64, 0x34, 0x33, 0x39, 0x65, 0x66, 0x33, 0x33, 0x34, 0x32, 0x35, 0x34, 0x31, 0x38, 0x66, 0x35, 0x61, 0x38, 0x36, 0x64, 0x32, 0x61, 0x61, 0x34, 0x64, 0x32, 0x61, 0x63, 0x38, 0x37, 0x34, 0x66, 0x31, 0x39, 0x34, 0x37, 0x32, 0x39, 0x31, 0x37, 0x66, 0x30, 0x34, 0x31, 0x65, 0x63, 0x35, 0x33, 0x65, 0x39, 0x63, 0x38, 0x30, 0x64, 0x65, 0x31, 0x39, 0x61, 0x65, 0x63, 0x39, 0x30, 0x31, 0x34, 0x63, 0x61, 0x66, 0x63, 0x61, 0x63, 0x65, 0x36, 0x66, 0x33, 0x61, 0x37, 0x39, 0x31, 0x30, 0x32, 0x33, 0x33, 0x38, 0x37, 0x31, 0x61, 0x64, 0x39, 0x31, 0x32, 0x63, 0x64, 0x38, 0x34, 0x66, 0x35, 0x39, 0x64, 0x61, 0x33, 0x62, 0x32, 0x37, 0x37, 0x66, 0x66, 0x33, 0x36, 0x32, 0x34, 0x65, 0x64, 0x39, 0x61, 0x35, 0x34, 0x64, 0x66, 0x38, 0x30, 0x34, 0x32, 0x61, 0x30, 0x33, 0x33, 0x35, 0x36, 0x35, 0x63, 0x34, 0x33, 0x65, 0x64, 0x33, 0x37, 0x65, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x64, 0x37, 0x32, 0x33, 0x33, 0x32, 0x31, 0x31, 0x63, 0x64, 0x62, 0x63, 0x32, 0x33, 0x34, 0x33, 0x63, 0x35, 0x39, 0x38, 0x37, 0x32, 0x31, 0x64, 0x36, 0x38, 0x36, 0x64, 0x30, 0x33, 0x62, 0x31, 0x35, 0x33, 0x32, 0x65, 0x35, 0x62, 0x65, 0x31, 0x61, 0x61, 0x37, 0x30, 0x34, 0x38, 0x33, 0x33, 0x36, 0x38, 0x31, 0x63, 0x63, 0x30, 0x30, 0x33, 0x66, 0x38, 0x38, 0x35, 0x33, 0x30, 0x30, 0x38, 0x32, 0x37, 0x31, 0x63, 0x35, 0x38, 0x66, 0x37, 0x39, 0x61, 0x61, 0x61, 0x33, 0x36, 0x38, 0x65, 0x31, 0x63, 0x63, 0x35, 0x31, 0x64, 0x36, 0x62, 0x38, 0x64, 0x35, 0x66, 0x63, 0x66, 0x36, 0x64, 0x32, 0x36, 0x35, 0x63, 0x30, 0x62, 0x63, 0x31, 0x32, 0x61, 0x37, 0x63, 0x38, 0x37, 0x33, 0x36, 0x64, 0x62, 0x35, 0x32, 0x32, 0x33, 0x33, 0x35, 0x36, 0x39, 0x30, 0x38, 0x65, 0x64, 0x61, 0x37, 0x31, 0x30, 0x61, 0x36, 0x61, 0x66, 0x64, 0x61, 0x39, 0x66, 0x36, 0x32, 0x62, 0x31, 0x32, 0x34, 0x32, 0x61, 0x35, 0x32, 0x37, 0x32, 0x62, 0x65, 0x37, 0x38, 0x39, 0x30, 0x61, 0x39, 0x64, 0x65, 0x32, 0x61, 0x33, 0x64, 0x35, 0x65, 0x38, 0x35, 0x39, 0x61, 0x39, 0x34, 0x35, 0x63, 0x36, 0x30, 0x32, 0x34, 0x38, 0x36, 0x36, 0x37, 0x61, 0x30, 0x37, 0x30, 0x33, 0x38, 0x65, 0x39, 0x66, 0x38, 0x62, 0x35, 0x61, 0x35, 0x33, 0x63, 0x33, 0x64, 0x66, 0x66, 0x34, 0x36, 0x38, 0x64, 0x35, 0x38, 0x32, 0x31, 0x30, 0x38, 0x37, 0x32, 0x35, 0x35, 0x36, 0x35, 0x36, 0x36, 0x35, 0x64, 0x33, 0x39, 0x35, 0x32, 0x30, 0x33, 0x62, 0x39, 0x32, 0x61, 0x63, 0x65, 0x32, 0x30, 0x37, 0x37, 0x38, 0x34, 0x63, 0x35, 0x33, 0x39, 0x33, 0x34, 0x62, 0x30, 0x66, 0x39, 0x66, 0x32, 0x37, 0x38, 0x62, 0x66, 0x66, 0x37, 0x37, 0x31, 0x63, 0x61, 0x36, 0x64, 0x34, 0x32, 0x30, 0x37, 0x38, 0x37, 0x66, 0x64, 0x30, 0x33, 0x37, 0x62, 0x37, 0x32, 0x32, 0x39, 0x62, 0x34, 0x33, 0x64, 0x39, 0x61, 0x65, 0x63, 0x61, 0x66, 0x61, 0x32, 0x37, 0x37, 0x30, 0x66, 0x31, 0x30, 0x34, 0x63, 0x37, 0x37, 0x61, 0x36, 0x63, 0x33, 0x38, 0x39, 0x39, 0x36, 0x39, 0x33, 0x63, 0x33, 0x37, 0x36, 0x63, 0x38, 0x32, 0x64, 0x37, 0x30, 0x34, 0x66, 0x38, 0x64, 0x33, 0x31, 0x39, 0x32, 0x35, 0x33, 0x38, 0x39, 0x66, 0x32, 0x30, 0x63, 0x33, 0x33, 0x30, 0x34, 0x66, 0x66, 0x37, 0x36, 0x64, 0x65, 0x35, 0x34, 0x32, 0x32, 0x35, 0x63, 0x32, 0x64, 0x36, 0x63, 0x34, 0x38, 0x32, 0x36, 0x32, 0x34, 0x39, 0x61, 0x36, 0x31, 0x37, 0x65, 0x38, 0x63, 0x64, 0x31, 0x32, 0x32, 0x37, 0x35, 0x62, 0x64, 0x62, 0x62, 0x63, 0x33, 0x38, 0x63, 0x30, 0x65, 0x64, 0x39, 0x37, 0x63, 0x31, 0x66, 0x35, 0x35, 0x31, 0x32, 0x62, 0x33, 0x34, 0x64, 0x63, 0x61, 0x30, 0x39, 0x32, 0x64, 0x37, 0x34, 0x63, 0x35, 0x32, 0x63, 0x36, 0x65, 0x62, 0x64, 0x31, 0x32, 0x38, 0x38, 0x37, 0x34, 0x65, 0x32, 0x62, 0x64, 0x65, 0x34, 0x36, 0x30, 0x34, 0x36, 0x32, 0x30, 0x61, 0x30, 0x31, 0x30, 0x36, 0x62, 0x38, 0x37, 0x39, 0x33, 0x32, 0x62, 0x65, 0x66, 0x33, 0x30, 0x65, 0x35, 0x66, 0x37, 0x30, 0x63, 0x35, 0x62, 0x61, 0x66, 0x66, 0x38, 0x32, 0x32, 0x39, 0x64, 0x33, 0x37, 0x64, 0x37, 0x37, 0x61, 0x31, 0x37, 0x33, 0x61, 0x61, 0x61, 0x30, 0x35, 0x36, 0x33, 0x32, 0x34, 0x66, 0x61, 0x65, 0x61, 0x32, 0x34, 0x62, 0x63, 0x31, 0x65, 0x38, 0x63, 0x34, 0x64, 0x39, 0x35, 0x66, 0x37, 0x64, 0x37, 0x61, 0x63, 0x63, 0x39, 0x34, 0x38, 0x39, 0x31, 0x66, 0x39, 0x34, 0x35, 0x33, 0x66, 0x32, 0x31, 0x62, 0x38, 0x38, 0x31, 0x33, 0x64, 0x37, 0x38, 0x38, 0x62, 0x37, 0x32, 0x30, 0x65, 0x65, 0x36, 0x30, 0x63, 0x33, 0x33, 0x35, 0x64, 0x36, 0x31, 0x38, 0x37, 0x35, 0x62, 0x34, 0x65, 0x34, 0x37, 0x38, 0x34, 0x38, 0x32, 0x37, 0x39, 0x36, 0x65, 0x38, 0x64, 0x61, 0x65, 0x65, 0x36, 0x62, 0x39, 0x31, 0x64, 0x36, 0x65, 0x39, 0x65, 0x32, 0x66, 0x61, 0x66, 0x32, 0x63, 0x37, 0x38, 0x38, 0x66, 0x65, 0x36, 0x61, 0x38, 0x66, 0x37, 0x36, 0x62, 0x35, 0x66, 0x37, 0x32, 0x61, 0x31, 0x34, 0x61, 0x33, 0x39, 0x30, 0x38, 0x37, 0x37, 0x62, 0x61, 0x30, 0x32, 0x33, 0x39, 0x65, 0x33, 0x66, 0x36, 0x30, 0x39, 0x36, 0x35, 0x63, 0x39, 0x35, 0x35, 0x39, 0x65, 0x64, 0x39, 0x35, 0x66, 0x66, 0x30, 0x36, 0x36, 0x38, 0x30, 0x39, 0x35, 0x66, 0x30, 0x62, 0x39, 0x36, 0x66, 0x61, 0x31, 0x32, 0x39, 0x37, 0x32, 0x62, 0x39, 0x38, 0x31, 0x39, 0x34, 0x65, 0x65, 0x37, 0x32, 0x31, 0x31, 0x32, 0x36, 0x33, 0x61, 0x37, 0x36, 0x36, 0x63, 0x64, 0x30, 0x62, 0x33, 0x38, 0x38, 0x33, 0x62, 0x32, 0x34, 0x33, 0x36, 0x31, 0x31, 0x31, 0x63, 0x63, 0x31, 0x62, 0x30, 0x31, 0x62, 0x32, 0x30, 0x30, 0x33, 0x36, 0x31, 0x61, 0x34, 0x62, 0x65, 0x36, 0x36, 0x30, 0x65, 0x39, 0x32, 0x38, 0x30, 0x34, 0x65, 0x66, 0x34, 0x61, 0x36, 0x62, 0x32, 0x35, 0x65, 0x30, 0x34, 0x37, 0x32, 0x33, 0x66, 0x64, 0x33, 0x61, 0x37, 0x63, 0x35, 0x61, 0x35, 0x30, 0x32, 0x65, 0x35, 0x34, 0x38, 0x64, 0x37, 0x66, 0x35, 0x37, 0x63, 0x62, 0x37, 0x36, 0x37, 0x38, 0x37, 0x38, 0x37, 0x30, 0x62, 0x37, 0x66, 0x35, 0x63, 0x30, 0x32, 0x64, 0x36, 0x36, 0x65, 0x66, 0x65, 0x65, 0x35, 0x31, 0x38, 0x32, 0x64, 0x61, 0x33, 0x63, 0x38, 0x30, 0x30, 0x35, 0x61, 0x63, 0x33, 0x32, 0x30, 0x32, 0x36, 0x32, 0x31, 0x63, 0x37, 0x34, 0x34, 0x66, 0x37, 0x34, 0x63, 0x38, 0x35, 0x32, 0x32, 0x63, 0x36, 0x31, 0x38, 0x66, 0x34, 0x65, 0x62, 0x63, 0x32, 0x32, 0x31, 0x36, 0x63, 0x31, 0x64, 0x30, 0x39, 0x31, 0x35, 0x61, 0x62, 0x30, 0x36, 0x63, 0x34, 0x34, 0x64, 0x64, 0x34, 0x32, 0x30, 0x34, 0x35, 0x35, 0x63, 0x63, 0x38, 0x39, 0x65, 0x35, 0x31, 0x37, 0x64, 0x33, 0x37, 0x64, 0x66, 0x35, 0x30, 0x62, 0x38, 0x38, 0x62, 0x63, 0x33, 0x64, 0x61, 0x36, 0x31, 0x30, 0x34, 0x32, 0x63, 0x38, 0x64, 0x63, 0x38, 0x61, 0x33, 0x30, 0x65, 0x38, 0x39, 0x37, 0x31, 0x33, 0x66, 0x63, 0x64, 0x66, 0x61, 0x35, 0x64, 0x63, 0x33, 0x30, 0x62, 0x38, 0x37, 0x35, 0x35, 0x64, 0x64, 0x35, 0x66, 0x66, 0x66, 0x65, 0x61, 0x62, 0x37, 0x63, 0x38, 0x33, 0x66, 0x33, 0x64, 0x64, 0x33, 0x64, 0x35, 0x37, 0x32, 0x38, 0x61, 0x35, 0x33, 0x64, 0x39, 0x61, 0x32, 0x35, 0x38, 0x36, 0x37, 0x38, 0x39, 0x35, 0x37, 0x30, 0x64, 0x31, 0x65, 0x65, 0x63, 0x31, 0x34, 0x64, 0x64, 0x36, 0x65, 0x35, 0x65, 0x37, 0x32, 0x66, 0x37, 0x36, 0x66, 0x62, 0x64, 0x33, 0x33, 0x64, 0x65, 0x65, 0x66, 0x32, 0x37, 0x62, 0x61, 0x39, 0x37, 0x37, 0x36, 0x33, 0x32, 0x37, 0x37, 0x64, 0x38, 0x64, 0x65, 0x30, 0x30, 0x37, 0x32, 0x36, 0x64, 0x31, 0x33, 0x65, 0x61, 0x32, 0x38, 0x61, 0x64, 0x36, 0x34, 0x61, 0x30, 0x35, 0x30, 0x30, 0x62, 0x30, 0x65, 0x64, 0x64, 0x61, 0x36, 0x65, 0x31, 0x39, 0x66, 0x31, 0x36, 0x64, 0x38, 0x33, 0x31, 0x36, 0x39, 0x32, 0x64, 0x38, 0x62, 0x61, 0x64, 0x32, 0x62, 0x62, 0x64, 0x36, 0x30, 0x37, 0x37, 0x34, 0x38, 0x39, 0x61, 0x31, 0x35, 0x65, 0x33, 0x30, 0x39, 0x65, 0x63, 0x35, 0x33, 0x63, 0x66, 0x39, 0x32, 0x35, 0x31, 0x62, 0x64, 0x61, 0x66, 0x61, 0x62, 0x66, 0x39, 0x39, 0x31, 0x61, 0x63, 0x35, 0x63, 0x65, 0x37, 0x30, 0x35, 0x39, 0x31, 0x31, 0x36, 0x61, 0x37, 0x38, 0x38, 0x35, 0x35, 0x30, 0x31, 0x35, 0x65, 0x34, 0x34, 0x31, 0x33, 0x64, 0x61, 0x31, 0x65, 0x37, 0x64, 0x37, 0x36, 0x36, 0x37, 0x61, 0x30, 0x31, 0x37, 0x64, 0x39, 0x62, 0x61, 0x31, 0x63, 0x37, 0x32, 0x65, 0x65, 0x36, 0x61, 0x36, 0x30, 0x64, 0x39, 0x31, 0x61, 0x61, 0x36, 0x64, 0x32, 0x33, 0x39, 0x62, 0x32, 0x64, 0x63, 0x31, 0x30, 0x38, 0x36, 0x61, 0x65, 0x66, 0x61, 0x33, 0x34, 0x34, 0x62, 0x33, 0x37, 0x35, 0x35, 0x66, 0x63, 0x36, 0x62, 0x30, 0x31, 0x38, 0x61, 0x32, 0x30, 0x62, 0x61, 0x31, 0x62, 0x35, 0x36, 0x64, 0x31, 0x34, 0x34, 0x63, 0x32, 0x35, 0x36, 0x36, 0x63, 0x37, 0x32, 0x31, 0x66, 0x33, 0x66, 0x64, 0x64, 0x32, 0x36, 0x38, 0x36, 0x62, 0x35, 0x35, 0x39, 0x32, 0x31, 0x63, 0x61, 0x37, 0x35, 0x38, 0x39, 0x35, 0x34, 0x33, 0x63, 0x62, 0x31, 0x63, 0x63, 0x62, 0x63, 0x38, 0x33, 0x31, 0x34, 0x31, 0x64, 0x35, 0x61, 0x65, 0x64, 0x65, 0x33, 0x62, 0x64, 0x39, 0x37, 0x33, 0x63, 0x66, 0x38, 0x33, 0x35, 0x32, 0x31, 0x61, 0x63, 0x37, 0x32, 0x63, 0x33, 0x32, 0x65, 0x62, 0x39, 0x65, 0x32, 0x35, 0x63, 0x37, 0x38, 0x35, 0x36, 0x37, 0x61, 0x30, 0x62, 0x30, 0x63, 0x33, 0x61, 0x30, 0x34, 0x34, 0x38, 0x37, 0x64, 0x31, 0x32, 0x30, 0x61, 0x66, 0x36, 0x34, 0x38, 0x64, 0x31, 0x61, 0x39, 0x63, 0x31, 0x36, 0x62, 0x38, 0x30, 0x31, 0x37, 0x65, 0x63, 0x61, 0x64, 0x36, 0x36, 0x63, 0x37, 0x31, 0x32, 0x31, 0x66, 0x31, 0x38, 0x35, 0x65, 0x65, 0x63, 0x37, 0x32, 0x33, 0x35, 0x63, 0x32, 0x38, 0x39, 0x36, 0x63, 0x35, 0x30, 0x65, 0x66, 0x36, 0x64, 0x38, 0x34, 0x64, 0x62, 0x66, 0x32, 0x30, 0x61, 0x36, 0x64, 0x62, 0x64, 0x35, 0x65, 0x31, 0x62, 0x65, 0x36, 0x35, 0x36, 0x38, 0x35, 0x62, 0x30, 0x38, 0x32, 0x39, 0x65, 0x63, 0x32, 0x34, 0x34, 0x34, 0x37, 0x65, 0x65, 0x39, 0x62, 0x30, 0x66, 0x39, 0x31, 0x64, 0x64, 0x36, 0x34, 0x39, 0x38, 0x32, 0x35, 0x30, 0x38, 0x33, 0x36, 0x30, 0x32, 0x63, 0x31, 0x66, 0x39, 0x62, 0x33, 0x38, 0x36, 0x37, 0x31, 0x32, 0x33, 0x30, 0x61, 0x63, 0x38, 0x33, 0x65, 0x63, 0x61, 0x39, 0x64, 0x35, 0x65, 0x34, 0x62, 0x33, 0x33, 0x39, 0x65, 0x39, 0x38, 0x32, 0x65, 0x39, 0x30, 0x35, 0x30, 0x30, 0x63, 0x64, 0x34, 0x62, 0x61, 0x32, 0x33, 0x61, 0x36, 0x34, 0x33, 0x35, 0x65, 0x32, 0x63, 0x62, 0x39, 0x37, 0x32, 0x32, 0x32, 0x63, 0x31, 0x61, 0x34, 0x63, 0x38, 0x32, 0x62, 0x32, 0x36, 0x37, 0x35, 0x31, 0x63, 0x30, 0x36, 0x33, 0x36, 0x32, 0x61, 0x32, 0x39, 0x61, 0x31, 0x36, 0x62, 0x62, 0x34, 0x33, 0x63, 0x31, 0x39, 0x62, 0x31, 0x31, 0x64, 0x36, 0x62, 0x64, 0x65, 0x38, 0x64, 0x32, 0x33, 0x63, 0x61, 0x34, 0x30, 0x65, 0x64, 0x66, 0x36, 0x35, 0x32, 0x33, 0x38, 0x64, 0x35, 0x36, 0x34, 0x37, 0x32, 0x63, 0x65, 0x65, 0x66, 0x33, 0x31, 0x39, 0x34, 0x37, 0x30, 0x66, 0x39, 0x66, 0x62, 0x63, 0x35, 0x35, 0x30, 0x61, 0x38, 0x65, 0x33, 0x32, 0x36, 0x37, 0x62, 0x30, 0x31, 0x63, 0x34, 0x66, 0x61, 0x65, 0x31, 0x62, 0x31, 0x61, 0x35, 0x66, 0x39, 0x35, 0x34, 0x36, 0x66, 0x34, 0x34, 0x37, 0x66, 0x66, 0x35, 0x37, 0x65, 0x61, 0x32, 0x34, 0x64, 0x36, 0x39, 0x33, 0x32, 0x62, 0x33, 0x37, 0x32, 0x32, 0x30, 0x62, 0x65, 0x66, 0x36, 0x36, 0x63, 0x31, 0x63, 0x32, 0x63, 0x30, 0x65, 0x30, 0x64, 0x31, 0x39, 0x66, 0x34, 0x64, 0x66, 0x39, 0x39, 0x37, 0x65, 0x39, 0x61, 0x38, 0x32, 0x35, 0x62, 0x32, 0x30, 0x63, 0x31, 0x34, 0x63, 0x37, 0x33, 0x35, 0x62, 0x33, 0x33, 0x63, 0x33, 0x62, 0x30, 0x38, 0x65, 0x62, 0x30, 0x30, 0x64, 0x65, 0x66, 0x31, 0x62, 0x32, 0x36, 0x33, 0x33, 0x37, 0x32, 0x37, 0x31, 0x37, 0x38, 0x32, 0x62, 0x64, 0x62, 0x63, 0x34, 0x61, 0x63, 0x65, 0x66, 0x33, 0x32, 0x37, 0x64, 0x36, 0x35, 0x64, 0x64, 0x66, 0x63, 0x39, 0x61, 0x65, 0x66, 0x32, 0x38, 0x38, 0x61, 0x61, 0x64, 0x35, 0x31, 0x37, 0x64, 0x34, 0x63, 0x35, 0x62, 0x32, 0x34, 0x34, 0x61, 0x37, 0x64, 0x66, 0x65, 0x32, 0x31, 0x30, 0x30, 0x66, 0x38, 0x39, 0x62, 0x34, 0x64, 0x35, 0x63, 0x37, 0x32, 0x37, 0x34, 0x38, 0x36, 0x64, 0x64, 0x64, 0x38, 0x32, 0x39, 0x66, 0x66, 0x61, 0x62, 0x34, 0x38, 0x37, 0x33, 0x34, 0x39, 0x62, 0x62, 0x38, 0x62, 0x63, 0x34, 0x37, 0x62, 0x36, 0x62, 0x30, 0x39, 0x37, 0x64, 0x64, 0x32, 0x31, 0x39, 0x33, 0x65, 0x37, 0x36, 0x32, 0x66, 0x65, 0x65, 0x64, 0x32, 0x36, 0x64, 0x31, 0x32, 0x38, 0x37, 0x62, 0x31, 0x37, 0x39, 0x33, 0x34, 0x38, 0x37, 0x37, 0x32, 0x35, 0x33, 0x65, 0x32, 0x65, 0x34, 0x39, 0x35, 0x38, 0x35, 0x34, 0x33, 0x32, 0x36, 0x33, 0x31, 0x30, 0x65, 0x62, 0x64, 0x36, 0x66, 0x39, 0x38, 0x64, 0x31, 0x32, 0x36, 0x34, 0x64, 0x36, 0x65, 0x61, 0x65, 0x38, 0x38, 0x39, 0x33, 0x35, 0x65, 0x32, 0x39, 0x36, 0x36, 0x61, 0x61, 0x39, 0x65, 0x39, 0x64, 0x32, 0x34, 0x38, 0x36, 0x37, 0x64, 0x33, 0x35, 0x62, 0x38, 0x61, 0x61, 0x33, 0x38, 0x39, 0x31, 0x31, 0x62, 0x35, 0x66, 0x36, 0x66, 0x63, 0x66, 0x65, 0x63, 0x62, 0x34, 0x39, 0x63, 0x33, 0x61, 0x33, 0x62, 0x31, 0x64, 0x30, 0x32, 0x35, 0x36, 0x61, 0x61, 0x34, 0x66, 0x36, 0x34, 0x64, 0x38, 0x33, 0x34, 0x61, 0x33, 0x31, 0x38, 0x63, 0x38, 0x37, 0x65, 0x31, 0x66, 0x36, 0x63, 0x32, 0x65, 0x33, 0x37, 0x36, 0x39, 0x36, 0x62, 0x36, 0x64, 0x34, 0x66, 0x61, 0x30, 0x37, 0x32, 0x62, 0x38, 0x31, 0x61, 0x36, 0x34, 0x63, 0x33, 0x35, 0x38, 0x32, 0x34, 0x63, 0x62, 0x63, 0x35, 0x62, 0x61, 0x39, 0x38, 0x33, 0x65, 0x34, 0x38, 0x35, 0x30, 0x61, 0x62, 0x33, 0x61, 0x64, 0x61, 0x64, 0x65, 0x66, 0x39, 0x37, 0x62, 0x33, 0x64, 0x63, 0x38, 0x64, 0x38, 0x34, 0x33, 0x64, 0x35, 0x38, 0x64, 0x61, 0x33, 0x31, 0x63, 0x36, 0x36, 0x36, 0x65, 0x35, 0x37, 0x63, 0x64, 0x37, 0x32, 0x66, 0x64, 0x36, 0x35, 0x36, 0x31, 0x39, 0x62, 0x39, 0x37, 0x64, 0x35, 0x38, 0x38, 0x31, 0x64, 0x38, 0x31, 0x37, 0x33, 0x36, 0x30, 0x61, 0x33, 0x39, 0x39, 0x35, 0x64, 0x65, 0x36, 0x31, 0x31, 0x37, 0x36, 0x30, 0x65, 0x39, 0x64, 0x66, 0x33, 0x30, 0x62, 0x39, 0x61, 0x37, 0x66, 0x36, 0x62, 0x61, 0x66, 0x37, 0x34, 0x32, 0x32, 0x63, 0x64, 0x30, 0x64, 0x66, 0x66, 0x63, 0x30, 0x37, 0x32, 0x35, 0x62, 0x66, 0x65, 0x65, 0x65, 0x35, 0x31, 0x34, 0x62, 0x36, 0x37, 0x33, 0x36, 0x39, 0x66, 0x30, 0x63, 0x36, 0x66, 0x66, 0x37, 0x35, 0x61, 0x36, 0x61, 0x31, 0x37, 0x39, 0x39, 0x39, 0x39, 0x30, 0x35, 0x33, 0x63, 0x35, 0x63, 0x39, 0x61, 0x32, 0x33, 0x66, 0x65, 0x32, 0x37, 0x62, 0x65, 0x37, 0x30, 0x62, 0x65, 0x34, 0x30, 0x63, 0x64, 0x32, 0x66, 0x62, 0x39, 0x37, 0x30, 0x37, 0x32, 0x33, 0x62, 0x62, 0x39, 0x35, 0x65, 0x62, 0x36, 0x37, 0x64, 0x31, 0x35, 0x61, 0x62, 0x36, 0x64, 0x30, 0x34, 0x31, 0x64, 0x36, 0x39, 0x30, 0x36, 0x38, 0x39, 0x34, 0x37, 0x61, 0x63, 0x33, 0x65, 0x36, 0x34, 0x34, 0x65, 0x66, 0x35, 0x63, 0x65, 0x31, 0x31, 0x61, 0x33, 0x64, 0x64, 0x32, 0x32, 0x37, 0x37, 0x37, 0x33, 0x38, 0x37, 0x62, 0x30, 0x36, 0x38, 0x61, 0x34, 0x39, 0x33, 0x31, 0x32, 0x65, 0x62, 0x65, 0x62, 0x31, 0x30, 0x31, 0x63, 0x38, 0x30, 0x62, 0x30, 0x31, 0x39, 0x37, 0x30, 0x33, 0x62, 0x39, 0x66, 0x66, 0x63, 0x30, 0x32, 0x64, 0x62, 0x61, 0x61, 0x39, 0x36, 0x35, 0x63, 0x36, 0x63, 0x31, 0x35, 0x64, 0x32, 0x61, 0x32, 0x36, 0x34, 0x35, 0x32, 0x34, 0x62, 0x66, 0x61, 0x33, 0x35, 0x36, 0x36, 0x32, 0x65, 0x39, 0x39, 0x62, 0x32, 0x36, 0x66, 0x65, 0x61, 0x34, 0x35, 0x31, 0x38, 0x36, 0x35, 0x37, 0x37, 0x64, 0x64, 0x39, 0x64, 0x30, 0x61, 0x32, 0x33, 0x35, 0x31, 0x34, 0x34, 0x35, 0x62, 0x37, 0x39, 0x30, 0x61, 0x65, 0x33, 0x30, 0x30, 0x66, 0x64, 0x39, 0x64, 0x62, 0x35, 0x63, 0x62, 0x61, 0x31, 0x66, 0x31, 0x66, 0x62, 0x32, 0x62, 0x62, 0x63, 0x65, 0x34, 0x37, 0x30, 0x66, 0x61, 0x31, 0x62, 0x31, 0x61, 0x37, 0x65, 0x39, 0x64, 0x64, 0x38, 0x37, 0x32, 0x66, 0x38, 0x39, 0x34, 0x36, 0x38, 0x65, 0x30, 0x30, 0x66, 0x62, 0x33, 0x30, 0x37, 0x39, 0x33, 0x66, 0x31, 0x39, 0x63, 0x34, 0x39, 0x63, 0x63, 0x65, 0x35, 0x36, 0x38, 0x65, 0x66, 0x64, 0x65, 0x32, 0x31, 0x31, 0x32, 0x66, 0x61, 0x31, 0x64, 0x38, 0x33, 0x64, 0x63, 0x35, 0x39, 0x31, 0x36, 0x61, 0x66, 0x33, 0x37, 0x33, 0x61, 0x62, 0x65, 0x64, 0x64, 0x31, 0x63, 0x39, 0x33, 0x32, 0x39, 0x37, 0x62, 0x33, 0x34, 0x65, 0x63, 0x35, 0x66, 0x37, 0x33, 0x35, 0x62, 0x34, 0x38, 0x35, 0x65, 0x64, 0x34, 0x38, 0x38, 0x38, 0x65, 0x30, 0x39, 0x33, 0x31, 0x39, 0x61, 0x37, 0x33, 0x65, 0x65, 0x66, 0x38, 0x36, 0x61, 0x36, 0x38, 0x37, 0x35, 0x34, 0x30, 0x64, 0x33, 0x32, 0x34, 0x34, 0x36, 0x35, 0x66, 0x39, 0x65, 0x61, 0x33, 0x38, 0x31, 0x35, 0x65, 0x39, 0x62, 0x33, 0x62, 0x37, 0x32, 0x30, 0x64, 0x62, 0x63, 0x39, 0x61, 0x30, 0x62, 0x61, 0x30, 0x37, 0x32, 0x61, 0x37, 0x35, 0x63, 0x34, 0x34, 0x37, 0x65, 0x31, 0x36, 0x32, 0x33, 0x32, 0x33, 0x36, 0x61, 0x38, 0x62, 0x39, 0x38, 0x32, 0x33, 0x62, 0x62, 0x38, 0x39, 0x65, 0x32, 0x63, 0x38, 0x32, 0x64, 0x30, 0x65, 0x61, 0x36, 0x62, 0x36, 0x38, 0x30, 0x39, 0x33, 0x38, 0x34, 0x33, 0x32, 0x39, 0x61, 0x65, 0x30, 0x37, 0x32, 0x37, 0x31, 0x63, 0x66, 0x35, 0x62, 0x36, 0x64, 0x34, 0x62, 0x65, 0x35, 0x38, 0x61, 0x63, 0x62, 0x33, 0x38, 0x35, 0x37, 0x64, 0x62, 0x34, 0x66, 0x34, 0x63, 0x66, 0x61, 0x36, 0x36, 0x33, 0x66, 0x36, 0x66, 0x37, 0x33, 0x36, 0x64, 0x34, 0x33, 0x39, 0x36, 0x32, 0x63, 0x62, 0x62, 0x37, 0x32, 0x33, 0x30, 0x65, 0x62, 0x30, 0x61, 0x39, 0x38, 0x33, 0x62, 0x38, 0x37, 0x34, 0x38, 0x30, 0x64, 0x30, 0x30, 0x32, 0x36, 0x37, 0x63, 0x35, 0x30, 0x38, 0x35, 0x34, 0x30, 0x34, 0x32, 0x39, 0x66, 0x31, 0x64, 0x62, 0x61, 0x63, 0x38, 0x62, 0x62, 0x36, 0x66, 0x30, 0x65, 0x35, 0x63, 0x31, 0x61, 0x30, 0x36, 0x61, 0x62, 0x33, 0x33, 0x38, 0x63, 0x30, 0x63, 0x38, 0x61, 0x36, 0x65, 0x38, 0x32, 0x30, 0x30, 0x35, 0x32, 0x30, 0x65, 0x61, 0x36, 0x34, 0x37, 0x62, 0x32, 0x38, 0x63, 0x34, 0x35, 0x62, 0x35, 0x37, 0x37, 0x36, 0x34, 0x36, 0x31, 0x31, 0x62, 0x35, 0x37, 0x65, 0x32, 0x31, 0x34, 0x33, 0x61, 0x61, 0x64, 0x33, 0x63, 0x32, 0x65, 0x66, 0x66, 0x61, 0x32, 0x31, 0x33, 0x39, 0x36, 0x33, 0x62, 0x37, 0x66, 0x37, 0x66, 0x62, 0x33, 0x38, 0x35, 0x61, 0x39, 0x66, 0x66, 0x30, 0x30, 0x35, 0x61, 0x35, 0x37, 0x38, 0x66, 0x65, 0x33, 0x36, 0x63, 0x38, 0x62, 0x33, 0x37, 0x34, 0x66, 0x31, 0x36, 0x37, 0x31, 0x38, 0x62, 0x64, 0x66, 0x66, 0x36, 0x34, 0x63, 0x35, 0x36, 0x63, 0x64, 0x36, 0x37, 0x63, 0x30, 0x39, 0x32, 0x62, 0x65, 0x37, 0x66, 0x35, 0x37, 0x34, 0x38, 0x66, 0x39, 0x34, 0x65, 0x62, 0x32, 0x31, 0x37, 0x30, 0x65, 0x66, 0x39, 0x61, 0x62, 0x34, 0x34, 0x39, 0x35, 0x64, 0x35, 0x34, 0x35, 0x37, 0x38, 0x35, 0x62, 0x35, 0x62, 0x62, 0x37, 0x37, 0x65, 0x35, 0x32, 0x37, 0x32, 0x32, 0x30, 0x34, 0x38, 0x62, 0x38, 0x38, 0x38, 0x66, 0x66, 0x33, 0x38, 0x32, 0x33, 0x62, 0x32, 0x61, 0x33, 0x38, 0x62, 0x66, 0x39, 0x62, 0x33, 0x35, 0x32, 0x32, 0x38, 0x37, 0x35, 0x66, 0x63, 0x31, 0x36, 0x34, 0x38, 0x33, 0x63, 0x66, 0x31, 0x65, 0x37, 0x38, 0x37, 0x37, 0x65, 0x38, 0x32, 0x37, 0x65, 0x30, 0x39, 0x34, 0x30, 0x34, 0x37, 0x63, 0x30, 0x39, 0x31, 0x37, 0x32, 0x66, 0x66, 0x39, 0x62, 0x63, 0x64, 0x63, 0x31, 0x36, 0x31, 0x63, 0x33, 0x62, 0x34, 0x66, 0x63, 0x33, 0x35, 0x64, 0x37, 0x65, 0x36, 0x37, 0x63, 0x66, 0x39, 0x35, 0x33, 0x31, 0x64, 0x30, 0x66, 0x65, 0x64, 0x39, 0x62, 0x63, 0x35, 0x30, 0x66, 0x30, 0x39, 0x31, 0x34, 0x66, 0x66, 0x36, 0x30, 0x30, 0x32, 0x38, 0x33, 0x31, 0x39, 0x34, 0x37, 0x31, 0x35, 0x65, 0x62, 0x36, 0x62, 0x34, 0x63, 0x35, 0x66, 0x31, 0x65, 0x63, 0x65, 0x61, 0x39, 0x62, 0x66, 0x63, 0x63, 0x36, 0x31, 0x62, 0x37, 0x33, 0x34, 0x34, 0x38, 0x33, 0x32, 0x31, 0x35, 0x30, 0x65, 0x36, 0x63, 0x66, 0x63, 0x31, 0x63, 0x39, 0x63, 0x30, 0x39, 0x35, 0x34, 0x32, 0x34, 0x65, 0x32, 0x33, 0x64, 0x65, 0x39, 0x32, 0x66, 0x31, 0x62, 0x61, 0x37, 0x65, 0x31, 0x63, 0x63, 0x30, 0x33, 0x62, 0x33, 0x66, 0x36, 0x37, 0x32, 0x61, 0x30, 0x36, 0x64, 0x33, 0x64, 0x30, 0x37, 0x62, 0x64, 0x34, 0x65, 0x31, 0x38, 0x34, 0x66, 0x35, 0x32, 0x32, 0x30, 0x36, 0x32, 0x33, 0x37, 0x34, 0x30, 0x30, 0x65, 0x66, 0x65, 0x38, 0x36, 0x62, 0x36, 0x62, 0x36, 0x33, 0x35, 0x65, 0x64, 0x34, 0x30, 0x63, 0x34, 0x63, 0x66, 0x38, 0x30, 0x61, 0x65, 0x30, 0x33, 0x62, 0x35, 0x32, 0x30, 0x64, 0x63, 0x66, 0x66, 0x31, 0x32, 0x37, 0x32, 0x64, 0x39, 0x33, 0x38, 0x65, 0x38, 0x66, 0x30, 0x63, 0x34, 0x62, 0x33, 0x36, 0x35, 0x38, 0x62, 0x39, 0x32, 0x37, 0x35, 0x61, 0x63, 0x34, 0x37, 0x61, 0x61, 0x35, 0x64, 0x32, 0x35, 0x65, 0x37, 0x31, 0x66, 0x33, 0x38, 0x33, 0x39, 0x66, 0x39, 0x32, 0x64, 0x64, 0x62, 0x66, 0x31, 0x31, 0x30, 0x62, 0x38, 0x38, 0x61, 0x33, 0x65, 0x62, 0x35, 0x34, 0x39, 0x38, 0x30, 0x63, 0x66, 0x37, 0x32, 0x62, 0x66, 0x32, 0x62, 0x34, 0x39, 0x30, 0x32, 0x62, 0x31, 0x66, 0x34, 0x33, 0x36, 0x35, 0x66, 0x63, 0x62, 0x66, 0x37, 0x33, 0x35, 0x64, 0x39, 0x32, 0x30, 0x61, 0x37, 0x36, 0x64, 0x33, 0x64, 0x37, 0x61, 0x62, 0x63, 0x65, 0x33, 0x37, 0x36, 0x39, 0x39, 0x64, 0x36, 0x32, 0x34, 0x39, 0x35, 0x63, 0x34, 0x30, 0x35, 0x63, 0x38, 0x62, 0x37, 0x66, 0x65, 0x32, 0x33, 0x63, 0x66, 0x35, 0x65, 0x30, 0x39, 0x37, 0x37, 0x63, 0x34, 0x37, 0x64, 0x34, 0x36, 0x32, 0x64, 0x63, 0x34, 0x36, 0x30, 0x64, 0x39, 0x31, 0x38, 0x33, 0x34, 0x62, 0x34, 0x61, 0x30, 0x66, 0x39, 0x32, 0x33, 0x33, 0x32, 0x32, 0x39, 0x39, 0x33, 0x39, 0x63, 0x36, 0x66, 0x36, 0x62, 0x66, 0x31, 0x38, 0x61, 0x39, 0x38, 0x66, 0x63, 0x63, 0x35, 0x33, 0x35, 0x66, 0x36, 0x64, 0x32, 0x38, 0x33, 0x34, 0x31, 0x35, 0x65, 0x33, 0x38, 0x36, 0x64, 0x30, 0x37, 0x66, 0x62, 0x37, 0x33, 0x33, 0x38, 0x37, 0x62, 0x62, 0x66, 0x63, 0x30, 0x62, 0x65, 0x65, 0x37, 0x36, 0x33, 0x61, 0x37, 0x33, 0x32, 0x63, 0x32, 0x38, 0x61, 0x61, 0x64, 0x38, 0x32, 0x31, 0x62, 0x64, 0x32, 0x38, 0x65, 0x38, 0x38, 0x36, 0x65, 0x65, 0x31, 0x66, 0x61, 0x61, 0x36, 0x33, 0x30, 0x31, 0x61, 0x35, 0x37, 0x38, 0x63, 0x63, 0x65, 0x30, 0x31, 0x61, 0x63, 0x31, 0x63, 0x38, 0x34, 0x34, 0x38, 0x34, 0x66, 0x31, 0x36, 0x61, 0x38, 0x66, 0x33, 0x30, 0x66, 0x62, 0x35, 0x39, 0x62, 0x37, 0x62, 0x38, 0x32, 0x30, 0x63, 0x37, 0x64, 0x65, 0x32, 0x33, 0x62, 0x33, 0x33, 0x61, 0x33, 0x66, 0x34, 0x37, 0x38, 0x38, 0x36, 0x38, 0x35, 0x31, 0x64, 0x61, 0x64, 0x31, 0x34, 0x35, 0x62, 0x61, 0x63, 0x32, 0x64, 0x38, 0x30, 0x38, 0x32, 0x37, 0x32, 0x62, 0x66, 0x62, 0x34, 0x33, 0x35, 0x61, 0x33, 0x35, 0x37, 0x38, 0x31, 0x35, 0x63, 0x64, 0x64, 0x65, 0x31, 0x36, 0x63, 0x31, 0x32, 0x63, 0x34, 0x66, 0x39, 0x62, 0x62, 0x66, 0x64, 0x30, 0x38, 0x30, 0x62, 0x66, 0x39, 0x65, 0x37, 0x31, 0x32, 0x64, 0x64, 0x35, 0x34, 0x62, 0x64, 0x62, 0x66, 0x30, 0x62, 0x37, 0x36, 0x64, 0x64, 0x66, 0x31, 0x33, 0x33, 0x31, 0x39, 0x36, 0x33, 0x37, 0x32, 0x64, 0x31, 0x39, 0x36, 0x32, 0x32, 0x31, 0x66, 0x32, 0x64, 0x36, 0x38, 0x38, 0x34, 0x30, 0x66, 0x30, 0x39, 0x30, 0x34, 0x34, 0x64, 0x32, 0x62, 0x33, 0x64, 0x64, 0x38, 0x63, 0x34, 0x35, 0x30, 0x65, 0x30, 0x35, 0x34, 0x35, 0x66, 0x39, 0x63, 0x38, 0x30, 0x61, 0x39, 0x61, 0x37, 0x35, 0x61, 0x31, 0x39, 0x37, 0x65, 0x38, 0x61, 0x66, 0x64, 0x30, 0x62, 0x61, 0x33, 0x63, 0x33, 0x36, 0x33, 0x65, 0x35, 0x65, 0x64, 0x61, 0x37, 0x37, 0x30, 0x39, 0x63, 0x65, 0x62, 0x39, 0x34, 0x33, 0x34, 0x34, 0x31, 0x64, 0x37, 0x63, 0x38, 0x37, 0x31, 0x61, 0x31, 0x61, 0x36, 0x31, 0x66, 0x32, 0x65, 0x31, 0x34, 0x30, 0x61, 0x62, 0x62, 0x39, 0x31, 0x66, 0x30, 0x34, 0x39, 0x35, 0x31, 0x33, 0x39, 0x39, 0x36, 0x34, 0x35, 0x37, 0x61, 0x61, 0x32, 0x63, 0x62, 0x31, 0x33, 0x32, 0x63, 0x36, 0x64, 0x61, 0x36, 0x35, 0x32, 0x30, 0x65, 0x64, 0x32, 0x32, 0x35, 0x38, 0x31, 0x61, 0x30, 0x34, 0x39, 0x30, 0x30, 0x34, 0x33, 0x61, 0x34, 0x33, 0x39, 0x35, 0x33, 0x63, 0x39, 0x61, 0x65, 0x64, 0x32, 0x39, 0x65, 0x65, 0x66, 0x66, 0x35, 0x36, 0x37, 0x34, 0x34, 0x37, 0x66, 0x65, 0x33, 0x39, 0x31, 0x63, 0x61, 0x61, 0x38, 0x33, 0x38, 0x33, 0x32, 0x38, 0x35, 0x30, 0x64, 0x30, 0x30, 0x34, 0x62, 0x38, 0x32, 0x30, 0x62, 0x30, 0x38, 0x37, 0x63, 0x62, 0x31, 0x36, 0x64, 0x33, 0x64, 0x38, 0x36, 0x31, 0x33, 0x36, 0x61, 0x38, 0x64, 0x33, 0x39, 0x31, 0x32, 0x63, 0x31, 0x64, 0x33, 0x38, 0x61, 0x36, 0x34, 0x37, 0x61, 0x34, 0x34, 0x65, 0x39, 0x34, 0x33, 0x63, 0x66, 0x32, 0x30, 0x38, 0x38, 0x36, 0x37, 0x39, 0x31, 0x39, 0x35, 0x30, 0x36, 0x65, 0x30, 0x38, 0x65, 0x34, 0x38, 0x37, 0x32, 0x32, 0x65, 0x63, 0x62, 0x33, 0x39, 0x39, 0x64, 0x34, 0x63, 0x66, 0x34, 0x61, 0x34, 0x32, 0x33, 0x65, 0x63, 0x37, 0x61, 0x32, 0x38, 0x37, 0x62, 0x32, 0x36, 0x37, 0x65, 0x36, 0x32, 0x39, 0x30, 0x32, 0x35, 0x37, 0x63, 0x64, 0x30, 0x37, 0x39, 0x36, 0x37, 0x36, 0x31, 0x36, 0x65, 0x34, 0x33, 0x35, 0x30, 0x35, 0x64, 0x62, 0x35, 0x38, 0x35, 0x61, 0x65, 0x34, 0x63, 0x39, 0x35, 0x37, 0x32, 0x34, 0x31, 0x30, 0x36, 0x63, 0x31, 0x65, 0x65, 0x32, 0x63, 0x32, 0x34, 0x30, 0x66, 0x63, 0x35, 0x31, 0x36, 0x30, 0x35, 0x30, 0x65, 0x63, 0x31, 0x31, 0x36, 0x62, 0x63, 0x33, 0x37, 0x35, 0x31, 0x61, 0x65, 0x39, 0x65, 0x64, 0x34, 0x63, 0x63, 0x65, 0x34, 0x34, 0x32, 0x64, 0x30, 0x34, 0x61, 0x63, 0x62, 0x66, 0x39, 0x36, 0x31, 0x37, 0x66, 0x31, 0x39, 0x36, 0x63, 0x33, 0x66, 0x33, 0x39, 0x38, 0x38, 0x32, 0x65, 0x32, 0x30, 0x34, 0x62, 0x30, 0x37, 0x36, 0x61, 0x31, 0x33, 0x64, 0x38, 0x61, 0x39, 0x36, 0x62, 0x33, 0x34, 0x38, 0x36, 0x31, 0x33, 0x34, 0x63, 0x34, 0x31, 0x63, 0x35, 0x66, 0x38, 0x63, 0x39, 0x36, 0x61, 0x37, 0x65, 0x64, 0x39, 0x35, 0x32, 0x32, 0x35, 0x38, 0x31, 0x66, 0x34, 0x30, 0x38, 0x64, 0x37, 0x63, 0x34, 0x35, 0x66, 0x61, 0x36, 0x61, 0x32, 0x31, 0x38, 0x39, 0x63, 0x61, 0x38, 0x66, 0x63, 0x61, 0x37, 0x62, 0x31, 0x39, 0x38, 0x34, 0x39, 0x61, 0x64, 0x37, 0x33, 0x35, 0x34, 0x36, 0x34, 0x66, 0x37, 0x37, 0x32, 0x63, 0x61, 0x62, 0x64, 0x35, 0x39, 0x65, 0x32, 0x37, 0x63, 0x64, 0x31, 0x65, 0x64, 0x62, 0x62, 0x37, 0x35, 0x37, 0x39, 0x64, 0x65, 0x66, 0x39, 0x36, 0x38, 0x33, 0x33, 0x66, 0x30, 0x63, 0x39, 0x37, 0x61, 0x31, 0x31, 0x37, 0x32, 0x30, 0x64, 0x35, 0x35, 0x37, 0x30, 0x32, 0x65, 0x37, 0x61, 0x34, 0x65, 0x64, 0x39, 0x38, 0x37, 0x64, 0x38, 0x62, 0x62, 0x65, 0x65, 0x64, 0x31, 0x36, 0x34, 0x63, 0x34, 0x61, 0x62, 0x35, 0x36, 0x64, 0x39, 0x35, 0x30, 0x35, 0x34, 0x34, 0x35, 0x37, 0x32, 0x30, 0x35, 0x37, 0x30, 0x38, 0x64, 0x38, 0x64, 0x35, 0x32, 0x63, 0x38, 0x32, 0x66, 0x31, 0x32, 0x30, 0x66, 0x35, 0x31, 0x37, 0x32, 0x37, 0x35, 0x33, 0x38, 0x33, 0x61, 0x39, 0x39, 0x62, 0x35, 0x63, 0x65, 0x37, 0x35, 0x30, 0x34, 0x66, 0x30, 0x65, 0x33, 0x66, 0x66, 0x33, 0x62, 0x30, 0x31, 0x62, 0x61, 0x65, 0x63, 0x65, 0x32, 0x36, 0x38, 0x37, 0x30, 0x63, 0x38, 0x34, 0x35, 0x31, 0x66, 0x38, 0x61, 0x36, 0x33, 0x65, 0x39, 0x66, 0x31, 0x32, 0x35, 0x64, 0x64, 0x33, 0x62, 0x32, 0x66, 0x39, 0x64, 0x64, 0x37, 0x36, 0x36, 0x35, 0x30, 0x35, 0x35, 0x38, 0x33, 0x61, 0x34, 0x36, 0x34, 0x65, 0x34, 0x63, 0x36, 0x38, 0x39, 0x65, 0x65, 0x33, 0x30, 0x66, 0x30, 0x63, 0x39, 0x38, 0x64, 0x66, 0x39, 0x66, 0x62, 0x62, 0x38, 0x36, 0x39, 0x31, 0x35, 0x36, 0x36, 0x64, 0x66, 0x36, 0x38, 0x36, 0x64, 0x32, 0x66, 0x61, 0x36, 0x36, 0x35, 0x63, 0x65, 0x32, 0x63, 0x63, 0x64, 0x35, 0x38, 0x66, 0x32, 0x39, 0x35, 0x35, 0x39, 0x65, 0x63, 0x30, 0x37, 0x35, 0x35, 0x38, 0x34, 0x64, 0x30, 0x35, 0x35, 0x35, 0x64, 0x36, 0x37, 0x61, 0x33, 0x65, 0x32, 0x64, 0x34, 0x37, 0x30, 0x31, 0x39, 0x66, 0x30, 0x38, 0x34, 0x61, 0x30, 0x36, 0x32, 0x38, 0x38, 0x34, 0x61, 0x64, 0x63, 0x31, 0x65, 0x37, 0x35, 0x61, 0x30, 0x35, 0x65, 0x38, 0x61, 0x64, 0x31, 0x62, 0x63, 0x31, 0x37, 0x37, 0x30, 0x38, 0x66, 0x30, 0x30, 0x37, 0x32, 0x66, 0x33, 0x34, 0x39, 0x33, 0x31, 0x39, 0x39, 0x31, 0x63, 0x31, 0x65, 0x63, 0x31, 0x36, 0x62, 0x35, 0x61, 0x31, 0x38, 0x61, 0x33, 0x39, 0x31, 0x33, 0x31, 0x33, 0x38, 0x65, 0x39, 0x64, 0x61, 0x35, 0x37, 0x32, 0x39, 0x63, 0x33, 0x63, 0x36, 0x33, 0x39, 0x66, 0x37, 0x64, 0x66, 0x65, 0x33, 0x66, 0x63, 0x39, 0x35, 0x33, 0x64, 0x33, 0x61, 0x39, 0x30, 0x35, 0x39, 0x36, 0x38, 0x37, 0x32, 0x63, 0x63, 0x39, 0x65, 0x36, 0x37, 0x34, 0x64, 0x35, 0x33, 0x39, 0x62, 0x62, 0x61, 0x30, 0x31, 0x36, 0x38, 0x39, 0x39, 0x35, 0x36, 0x66, 0x32, 0x65, 0x65, 0x62, 0x63, 0x35, 0x63, 0x37, 0x63, 0x63, 0x64, 0x33, 0x65, 0x66, 0x39, 0x37, 0x61, 0x62, 0x37, 0x34, 0x65, 0x32, 0x65, 0x33, 0x65, 0x38, 0x61, 0x33, 0x37, 0x37, 0x64, 0x33, 0x39, 0x64, 0x37, 0x64, 0x30, 0x34, 0x36, 0x35, 0x61, 0x39, 0x62, 0x64, 0x36, 0x34, 0x66, 0x61, 0x37, 0x63, 0x32, 0x31, 0x38, 0x63, 0x64, 0x35, 0x66, 0x61, 0x31, 0x31, 0x37, 0x32, 0x63, 0x32, 0x30, 0x36, 0x35, 0x38, 0x35, 0x34, 0x61, 0x62, 0x37, 0x34, 0x35, 0x31, 0x33, 0x33, 0x33, 0x32, 0x33, 0x35, 0x64, 0x34, 0x63, 0x32, 0x36, 0x32, 0x35, 0x66, 0x64, 0x65, 0x63, 0x38, 0x34, 0x32, 0x63, 0x64, 0x37, 0x61, 0x66, 0x31, 0x37, 0x36, 0x32, 0x64, 0x64, 0x61, 0x62, 0x61, 0x30, 0x39, 0x38, 0x30, 0x32, 0x36, 0x39, 0x38, 0x34, 0x37, 0x36, 0x34, 0x38, 0x33, 0x37, 0x32, 0x35, 0x61, 0x33, 0x35, 0x61, 0x61, 0x32, 0x66, 0x34, 0x39, 0x63, 0x63, 0x33, 0x35, 0x33, 0x39, 0x30, 0x32, 0x35, 0x34, 0x64, 0x65, 0x64, 0x61, 0x32, 0x39, 0x65, 0x34, 0x65, 0x32, 0x32, 0x38, 0x36, 0x35, 0x34, 0x39, 0x32, 0x61, 0x31, 0x39, 0x32, 0x37, 0x32, 0x61, 0x34, 0x36, 0x35, 0x65, 0x38, 0x34, 0x65, 0x37, 0x34, 0x66, 0x38, 0x32, 0x30, 0x35, 0x66, 0x31, 0x32, 0x35, 0x64, 0x32, 0x63, 0x65, 0x34, 0x30, 0x33, 0x38, 0x30, 0x34, 0x37, 0x39, 0x38, 0x39, 0x31, 0x66, 0x31, 0x32, 0x61, 0x65, 0x39, 0x61, 0x65, 0x32, 0x63, 0x36, 0x65, 0x31, 0x35, 0x31, 0x39, 0x30, 0x65, 0x36, 0x33, 0x61, 0x33, 0x30, 0x30, 0x63, 0x31, 0x30, 0x63, 0x34, 0x33, 0x32, 0x35, 0x34, 0x66, 0x62, 0x65, 0x61, 0x30, 0x38, 0x31, 0x36, 0x33, 0x33, 0x65, 0x35, 0x30, 0x31, 0x36, 0x34, 0x33, 0x64, 0x33, 0x32, 0x61, 0x33, 0x38, 0x30, 0x38, 0x63, 0x33, 0x65, 0x32, 0x38, 0x35, 0x30, 0x37, 0x62, 0x61, 0x30, 0x37, 0x32, 0x31, 0x64, 0x63, 0x33, 0x61, 0x63, 0x38, 0x30, 0x65, 0x65, 0x32, 0x37, 0x31, 0x39, 0x32, 0x66, 0x30, 0x62, 0x63, 0x35, 0x34, 0x37, 0x32, 0x31, 0x30, 0x32, 0x39, 0x64, 0x39, 0x64, 0x30, 0x66, 0x61, 0x63, 0x32, 0x33, 0x38, 0x37, 0x66, 0x36, 0x36, 0x66, 0x32, 0x62, 0x62, 0x36, 0x39, 0x39, 0x30, 0x38, 0x34, 0x63, 0x36, 0x36, 0x31, 0x66, 0x36, 0x64, 0x62, 0x62, 0x66, 0x64, 0x31, 0x63, 0x33, 0x61, 0x65, 0x62, 0x66, 0x37, 0x30, 0x33, 0x31, 0x66, 0x39, 0x62, 0x36, 0x64, 0x36, 0x31, 0x35, 0x32, 0x61, 0x61, 0x64, 0x30, 0x33, 0x63, 0x33, 0x38, 0x66, 0x36, 0x66, 0x66, 0x38, 0x35, 0x30, 0x33, 0x65, 0x63, 0x62, 0x39, 0x39, 0x61, 0x31, 0x36, 0x35, 0x64, 0x30, 0x64, 0x38, 0x31, 0x30, 0x65, 0x39, 0x38, 0x39, 0x61, 0x65, 0x38, 0x62, 0x62, 0x38, 0x30, 0x37, 0x65, 0x64, 0x32, 0x37, 0x30, 0x36, 0x32, 0x33, 0x63, 0x37, 0x30, 0x35, 0x62, 0x66, 0x34, 0x62, 0x65, 0x64, 0x35, 0x32, 0x34, 0x32, 0x66, 0x38, 0x37, 0x32, 0x66, 0x63, 0x64, 0x39, 0x30, 0x62, 0x63, 0x65, 0x37, 0x61, 0x35, 0x32, 0x31, 0x37, 0x36, 0x30, 0x61, 0x37, 0x36, 0x64, 0x36, 0x66, 0x64, 0x66, 0x33, 0x65, 0x31, 0x65, 0x64, 0x35, 0x62, 0x62, 0x33, 0x62, 0x66, 0x38, 0x38, 0x36, 0x61, 0x35, 0x30, 0x66, 0x38, 0x37, 0x30, 0x33, 0x37, 0x36, 0x64, 0x36, 0x39, 0x35, 0x33, 0x31, 0x64, 0x64, 0x63, 0x38, 0x64, 0x62, 0x31, 0x38, 0x22, 0x5d, 0x7d, 0x2c, 0x22, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x75, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x69, 0x73, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x31, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x2c, 0x22, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x45, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x22, 0x5d, 0x7d, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x31, 0x20, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x22, 0x4e, 0x65, 0x77, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x75, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x32, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x32, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x2c, 0x22, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x45, 0x44, 0x22, 0x5d, 0x7d, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x32, 0x36, 0x30, 0x32, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x32, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x32, 0x37, 0x32, 0x30, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x61, 0x64, 0x32, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x38, 0x30, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x30, 0x31, 0x61, 0x30, 0x38, 0x34, 0x30, 0x36, 0x35, 0x30, 0x61, 0x61, 0x38, 0x66, 0x37, 0x34, 0x64, 0x32, 0x62, 0x30, 0x37, 0x66, 0x34, 0x30, 0x30, 0x36, 0x37, 0x64, 0x63, 0x33, 0x33, 0x62, 0x37, 0x31, 0x35, 0x30, 0x37, 0x38, 0x64, 0x37, 0x33, 0x34, 0x32, 0x32, 0x66, 0x30, 0x31, 0x64, 0x61, 0x31, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x31, 0x31, 0x65, 0x30, 0x32, 0x62, 0x62, 0x64, 0x66, 0x64, 0x61, 0x39, 0x61, 0x30, 0x34, 0x62, 0x32, 0x32, 0x36, 0x30, 0x66, 0x36, 0x30, 0x32, 0x32, 0x62, 0x66, 0x35, 0x33, 0x65, 0x61, 0x64, 0x62, 0x33, 0x33, 0x37, 0x62, 0x33, 0x65, 0x35, 0x39, 0x35, 0x31, 0x34, 0x39, 0x33, 0x36, 0x66, 0x37, 0x33, 0x31, 0x37, 0x64, 0x38, 0x37, 0x32, 0x64, 0x65, 0x66, 0x62, 0x38, 0x39, 0x31, 0x61, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x37, 0x39, 0x62, 0x64, 0x63, 0x61, 0x39, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x35, 0x32, 0x31, 0x64, 0x35, 0x32, 0x38, 0x61, 0x64, 0x30, 0x63, 0x37, 0x36, 0x30, 0x33, 0x35, 0x34, 0x61, 0x34, 0x66, 0x30, 0x34, 0x39, 0x36, 0x37, 0x37, 0x36, 0x63, 0x66, 0x31, 0x34, 0x61, 0x39, 0x32, 0x66, 0x65, 0x31, 0x66, 0x62, 0x35, 0x64, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x63, 0x65, 0x61, 0x31, 0x61, 0x34, 0x38, 0x39, 0x63, 0x37, 0x63, 0x38, 0x33, 0x31, 0x30, 0x31, 0x61, 0x30, 0x61, 0x38, 0x36, 0x63, 0x31, 0x66, 0x64, 0x38, 0x63, 0x32, 0x65, 0x37, 0x34, 0x38, 0x32, 0x30, 0x36, 0x38, 0x36, 0x39, 0x33, 0x37, 0x66, 0x35, 0x63, 0x31, 0x62, 0x66, 0x65, 0x38, 0x33, 0x36, 0x65, 0x32, 0x66, 0x62, 0x36, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66, 0x63, 0x62, 0x65, 0x62, 0x64, 0x63, 0x34, 0x61, 0x62, 0x34, 0x33, 0x35, 0x37, 0x66, 0x32, 0x64, 0x62, 0x62, 0x63, 0x36, 0x31, 0x61, 0x30, 0x35, 0x63, 0x33, 0x62, 0x32, 0x62, 0x34, 0x34, 0x66, 0x66, 0x38, 0x32, 0x35, 0x32, 0x66, 0x37, 0x38, 0x64, 0x37, 0x30, 0x61, 0x65, 0x62, 0x33, 0x33, 0x66, 0x38, 0x62, 0x61, 0x30, 0x39, 0x62, 0x65, 0x61, 0x65, 0x61, 0x64, 0x61, 0x64, 0x31, 0x62, 0x33, 0x37, 0x36, 0x61, 0x35, 0x37, 0x64, 0x33, 0x34, 0x66, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x63, 0x34, 0x61, 0x31, 0x38, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x32, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x36, 0x32, 0x63, 0x33, 0x36, 0x30, 0x66, 0x64, 0x64, 0x38, 0x38, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x39, 0x64, 0x34, 0x36, 0x33, 0x65, 0x36, 0x64, 0x36, 0x34, 0x62, 0x32, 0x65, 0x65, 0x33, 0x32, 0x30, 0x61, 0x63, 0x36, 0x61, 0x30, 0x38, 0x38, 0x38, 0x35, 0x64, 0x66, 0x36, 0x30, 0x38, 0x33, 0x36, 0x34, 0x34, 0x61, 0x30, 0x36, 0x33, 0x65, 0x37, 0x30, 0x31, 0x61, 0x30, 0x33, 0x37, 0x61, 0x37, 0x32, 0x38, 0x61, 0x65, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x66, 0x66, 0x61, 0x37, 0x30, 0x32, 0x61, 0x32, 0x63, 0x61, 0x36, 0x32, 0x30, 0x64, 0x62, 0x38, 0x39, 0x63, 0x61, 0x66, 0x33, 0x65, 0x34, 0x36, 0x61, 0x62, 0x37, 0x66, 0x32, 0x35, 0x66, 0x37, 0x36, 0x34, 0x36, 0x66, 0x63, 0x39, 0x35, 0x31, 0x35, 0x31, 0x30, 0x39, 0x39, 0x31, 0x62, 0x61, 0x64, 0x63, 0x61, 0x30, 0x36, 0x35, 0x64, 0x38, 0x34, 0x36, 0x66, 0x30, 0x34, 0x36, 0x33, 0x35, 0x37, 0x61, 0x66, 0x33, 0x39, 0x62, 0x62, 0x37, 0x33, 0x39, 0x62, 0x31, 0x36, 0x31, 0x32, 0x33, 0x33, 0x66, 0x63, 0x65, 0x37, 0x33, 0x64, 0x64, 0x66, 0x65, 0x30, 0x62, 0x62, 0x38, 0x37, 0x66, 0x32, 0x64, 0x32, 0x38, 0x65, 0x66, 0x36, 0x30, 0x64, 0x66, 0x65, 0x36, 0x64, 0x62, 0x62, 0x30, 0x31, 0x32, 0x38, 0x64, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x33, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x75, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x75, 0x6e, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x33, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x33, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x2c, 0x22, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x45, 0x44, 0x22, 0x5d, 0x7d, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x32, 0x36, 0x30, 0x32, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x35, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x33, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x32, 0x37, 0x32, 0x30, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x61, 0x64, 0x32, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x38, 0x30, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x30, 0x31, 0x61, 0x30, 0x38, 0x34, 0x30, 0x36, 0x35, 0x30, 0x61, 0x61, 0x38, 0x66, 0x37, 0x34, 0x64, 0x32, 0x62, 0x30, 0x37, 0x66, 0x34, 0x30, 0x30, 0x36, 0x37, 0x64, 0x63, 0x33, 0x33, 0x62, 0x37, 0x31, 0x35, 0x30, 0x37, 0x38, 0x64, 0x37, 0x33, 0x34, 0x32, 0x32, 0x66, 0x30, 0x31, 0x64, 0x61, 0x31, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x31, 0x31, 0x65, 0x30, 0x32, 0x62, 0x62, 0x64, 0x66, 0x64, 0x61, 0x39, 0x61, 0x30, 0x34, 0x62, 0x32, 0x32, 0x36, 0x30, 0x66, 0x36, 0x30, 0x32, 0x32, 0x62, 0x66, 0x35, 0x33, 0x65, 0x61, 0x64, 0x62, 0x33, 0x33, 0x37, 0x62, 0x33, 0x65, 0x35, 0x39, 0x35, 0x31, 0x34, 0x39, 0x33, 0x36, 0x66, 0x37, 0x33, 0x31, 0x37, 0x64, 0x38, 0x37, 0x32, 0x64, 0x65, 0x66, 0x62, 0x38, 0x39, 0x31, 0x61, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x37, 0x39, 0x62, 0x64, 0x63, 0x61, 0x39, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x35, 0x32, 0x31, 0x64, 0x35, 0x32, 0x38, 0x61, 0x64, 0x30, 0x63, 0x37, 0x36, 0x30, 0x33, 0x35, 0x34, 0x61, 0x34, 0x66, 0x30, 0x34, 0x39, 0x36, 0x37, 0x37, 0x36, 0x63, 0x66, 0x31, 0x34, 0x61, 0x39, 0x32, 0x66, 0x65, 0x31, 0x66, 0x62, 0x35, 0x64, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x63, 0x65, 0x61, 0x31, 0x61, 0x34, 0x38, 0x39, 0x63, 0x37, 0x63, 0x38, 0x33, 0x31, 0x30, 0x31, 0x61, 0x30, 0x61, 0x38, 0x36, 0x63, 0x31, 0x66, 0x64, 0x38, 0x63, 0x32, 0x65, 0x37, 0x34, 0x38, 0x32, 0x30, 0x36, 0x38, 0x36, 0x39, 0x33, 0x37, 0x66, 0x35, 0x63, 0x31, 0x62, 0x66, 0x65, 0x38, 0x33, 0x36, 0x65, 0x32, 0x66, 0x62, 0x36, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66, 0x63, 0x62, 0x65, 0x62, 0x64, 0x63, 0x34, 0x61, 0x62, 0x34, 0x33, 0x35, 0x37, 0x66, 0x32, 0x64, 0x62, 0x62, 0x63, 0x36, 0x31, 0x61, 0x30, 0x35, 0x63, 0x33, 0x62, 0x32, 0x62, 0x34, 0x34, 0x66, 0x66, 0x38, 0x32, 0x35, 0x32, 0x66, 0x37, 0x38, 0x64, 0x37, 0x30, 0x61, 0x65, 0x62, 0x33, 0x33, 0x66, 0x38, 0x62, 0x61, 0x30, 0x39, 0x62, 0x65, 0x61, 0x65, 0x61, 0x64, 0x61, 0x64, 0x31, 0x62, 0x33, 0x37, 0x36, 0x61, 0x35, 0x37, 0x64, 0x33, 0x34, 0x66, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x63, 0x34, 0x61, 0x31, 0x38, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x32, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x36, 0x32, 0x63, 0x33, 0x36, 0x30, 0x66, 0x64, 0x64, 0x38, 0x38, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x39, 0x64, 0x34, 0x36, 0x33, 0x65, 0x36, 0x64, 0x36, 0x34, 0x62, 0x32, 0x65, 0x65, 0x33, 0x32, 0x30, 0x61, 0x63, 0x36, 0x61, 0x30, 0x38, 0x38, 0x38, 0x35, 0x64, 0x66, 0x36, 0x30, 0x38, 0x33, 0x36, 0x34, 0x34, 0x61, 0x30, 0x36, 0x33, 0x65, 0x37, 0x30, 0x31, 0x61, 0x30, 0x33, 0x37, 0x61, 0x37, 0x32, 0x38, 0x61, 0x65, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x66, 0x66, 0x61, 0x37, 0x30, 0x32, 0x61, 0x32, 0x63, 0x61, 0x36, 0x32, 0x30, 0x64, 0x62, 0x38, 0x39, 0x63, 0x61, 0x66, 0x33, 0x65, 0x34, 0x36, 0x61, 0x62, 0x37, 0x66, 0x32, 0x35, 0x66, 0x37, 0x36, 0x34, 0x36, 0x66, 0x63, 0x39, 0x35, 0x31, 0x35, 0x31, 0x30, 0x39, 0x39, 0x31, 0x62, 0x61, 0x64, 0x63, 0x61, 0x30, 0x36, 0x35, 0x64, 0x38, 0x34, 0x36, 0x66, 0x30, 0x34, 0x36, 0x33, 0x35, 0x37, 0x61, 0x66, 0x33, 0x39, 0x62, 0x62, 0x37, 0x33, 0x39, 0x62, 0x31, 0x36, 0x31, 0x32, 0x33, 0x33, 0x66, 0x63, 0x65, 0x37, 0x33, 0x64, 0x64, 0x66, 0x65, 0x30, 0x62, 0x62, 0x38, 0x37, 0x66, 0x32, 0x64, 0x32, 0x38, 0x65, 0x66, 0x36, 0x30, 0x64, 0x66, 0x65, 0x36, 0x64, 0x62, 0x62, 0x30, 0x31, 0x32, 0x38, 0x64, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x22, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x36, 0x39, 0x36, 0x33, 0x30, 0x66, 0x35, 0x33, 0x35, 0x62, 0x34, 0x61, 0x34, 0x31, 0x33, 0x33, 0x30, 0x31, 0x36, 0x34, 0x63, 0x36, 0x65, 0x35, 0x63, 0x39, 0x32, 0x62, 0x31, 0x32, 0x32, 0x34, 0x63, 0x30, 0x63, 0x34, 0x30, 0x37, 0x66, 0x35, 0x38, 0x32, 0x64, 0x34, 0x30, 0x37, 0x64, 0x30, 0x61, 0x63, 0x33, 0x64, 0x32, 0x30, 0x36, 0x63, 0x64, 0x33, 0x32, 0x66, 0x64, 0x35, 0x32, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x34, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x75, 0x6e, 0x73, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x44, 0x6f, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x75, 0x72, 0x6c, 0x22, 0x3a, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x70, 0x72, 0x61, 0x67, 0x75, 0x65, 0x2e, 0x6d, 0x64, 0x23, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x76, 0x34, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x34, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x39, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x56, 0x31, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x39, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x53, 0x59, 0x4e, 0x43, 0x49, 0x4e, 0x47, 0x22, 0x2c, 0x22, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x45, 0x44, 0x22, 0x5d, 0x7d, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x32, 0x36, 0x30, 0x32, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x3a, 0x20, 0x2d, 0x33, 0x38, 0x30, 0x30, 0x35, 0x2c, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x6b, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x34, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x62, 0x38, 0x66, 0x62, 0x32, 0x34, 0x30, 0x64, 0x32, 0x38, 0x38, 0x37, 0x38, 0x31, 0x64, 0x34, 0x61, 0x61, 0x63, 0x39, 0x34, 0x64, 0x33, 0x66, 0x64, 0x31, 0x36, 0x38, 0x30, 0x39, 0x65, 0x65, 0x34, 0x31, 0x33, 0x62, 0x63, 0x39, 0x39, 0x32, 0x39, 0x34, 0x61, 0x30, 0x38, 0x35, 0x37, 0x39, 0x38, 0x61, 0x35, 0x38, 0x39, 0x64, 0x61, 0x65, 0x35, 0x31, 0x64, 0x64, 0x64, 0x34, 0x61, 0x22, 0x2c, 0x22, 0x66, 0x65, 0x65, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x61, 0x33, 0x31, 0x34, 0x39, 0x66, 0x61, 0x39, 0x65, 0x33, 0x37, 0x64, 0x62, 0x30, 0x38, 0x64, 0x31, 0x63, 0x64, 0x34, 0x39, 0x63, 0x39, 0x30, 0x36, 0x31, 0x64, 0x62, 0x31, 0x30, 0x30, 0x32, 0x65, 0x66, 0x31, 0x63, 0x64, 0x35, 0x38, 0x64, 0x62, 0x32, 0x32, 0x31, 0x30, 0x66, 0x32, 0x31, 0x31, 0x35, 0x63, 0x38, 0x63, 0x39, 0x38, 0x39, 0x62, 0x32, 0x62, 0x64, 0x66, 0x34, 0x35, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x35, 0x36, 0x65, 0x38, 0x31, 0x66, 0x31, 0x37, 0x31, 0x62, 0x63, 0x63, 0x35, 0x35, 0x61, 0x36, 0x66, 0x66, 0x38, 0x33, 0x34, 0x35, 0x65, 0x36, 0x39, 0x32, 0x63, 0x30, 0x66, 0x38, 0x36, 0x65, 0x35, 0x62, 0x34, 0x38, 0x65, 0x30, 0x31, 0x62, 0x39, 0x39, 0x36, 0x63, 0x61, 0x64, 0x63, 0x30, 0x30, 0x31, 0x36, 0x32, 0x32, 0x66, 0x62, 0x35, 0x65, 0x33, 0x36, 0x33, 0x62, 0x34, 0x32, 0x31, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x65, 0x76, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x63, 0x31, 0x33, 0x30, 0x64, 0x35, 0x65, 0x36, 0x33, 0x63, 0x36, 0x31, 0x63, 0x39, 0x33, 0x35, 0x66, 0x36, 0x30, 0x38, 0x39, 0x65, 0x36, 0x31, 0x31, 0x34, 0x30, 0x63, 0x61, 0x39, 0x31, 0x33, 0x36, 0x31, 0x37, 0x32, 0x36, 0x37, 0x37, 0x63, 0x66, 0x36, 0x61, 0x61, 0x35, 0x38, 0x30, 0x30, 0x64, 0x63, 0x63, 0x31, 0x63, 0x66, 0x30, 0x61, 0x30, 0x32, 0x31, 0x35, 0x32, 0x61, 0x31, 0x34, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x31, 0x32, 0x37, 0x32, 0x30, 0x66, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x63, 0x39, 0x63, 0x33, 0x38, 0x30, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x61, 0x64, 0x32, 0x65, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x36, 0x34, 0x65, 0x37, 0x37, 0x38, 0x35, 0x62, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x37, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x38, 0x30, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x30, 0x31, 0x61, 0x30, 0x38, 0x34, 0x30, 0x36, 0x35, 0x30, 0x61, 0x61, 0x38, 0x66, 0x37, 0x34, 0x64, 0x32, 0x62, 0x30, 0x37, 0x66, 0x34, 0x30, 0x30, 0x36, 0x37, 0x64, 0x63, 0x33, 0x33, 0x62, 0x37, 0x31, 0x35, 0x30, 0x37, 0x38, 0x64, 0x37, 0x33, 0x34, 0x32, 0x32, 0x66, 0x30, 0x31, 0x64, 0x61, 0x31, 0x37, 0x61, 0x62, 0x64, 0x62, 0x64, 0x31, 0x31, 0x65, 0x30, 0x32, 0x62, 0x62, 0x64, 0x66, 0x64, 0x61, 0x39, 0x61, 0x30, 0x34, 0x62, 0x32, 0x32, 0x36, 0x30, 0x66, 0x36, 0x30, 0x32, 0x32, 0x62, 0x66, 0x35, 0x33, 0x65, 0x61, 0x64, 0x62, 0x33, 0x33, 0x37, 0x62, 0x33, 0x65, 0x35, 0x39, 0x35, 0x31, 0x34, 0x39, 0x33, 0x36, 0x66, 0x37, 0x33, 0x31, 0x37, 0x64, 0x38, 0x37, 0x32, 0x64, 0x65, 0x66, 0x62, 0x38, 0x39, 0x31, 0x61, 0x37, 0x30, 0x38, 0x65, 0x65, 0x32, 0x37, 0x39, 0x62, 0x64, 0x63, 0x61, 0x39, 0x30, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x31, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x35, 0x32, 0x31, 0x64, 0x35, 0x32, 0x38, 0x61, 0x64, 0x30, 0x63, 0x37, 0x36, 0x30, 0x33, 0x35, 0x34, 0x61, 0x34, 0x66, 0x30, 0x34, 0x39, 0x36, 0x37, 0x37, 0x36, 0x63, 0x66, 0x31, 0x34, 0x61, 0x39, 0x32, 0x66, 0x65, 0x31, 0x66, 0x62, 0x35, 0x64, 0x35, 0x30, 0x65, 0x39, 0x35, 0x39, 0x64, 0x63, 0x65, 0x61, 0x31, 0x61, 0x34, 0x38, 0x39, 0x63, 0x37, 0x63, 0x38, 0x33, 0x31, 0x30, 0x31, 0x61, 0x30, 0x61, 0x38, 0x36, 0x63, 0x31, 0x66, 0x64, 0x38, 0x63, 0x32, 0x65, 0x37, 0x34, 0x38, 0x32, 0x30, 0x36, 0x38, 0x36, 0x39, 0x33, 0x37, 0x66, 0x35, 0x63, 0x31, 0x62, 0x66, 0x65, 0x38, 0x33, 0x36, 0x65, 0x32, 0x66, 0x62, 0x36, 0x32, 0x32, 0x61, 0x63, 0x39, 0x66, 0x63, 0x62, 0x65, 0x62, 0x64, 0x63, 0x34, 0x61, 0x62, 0x34, 0x33, 0x35, 0x37, 0x66, 0x32, 0x64, 0x62, 0x62, 0x63, 0x36, 0x31, 0x61, 0x30, 0x35, 0x63, 0x33, 0x62, 0x32, 0x62, 0x34, 0x34, 0x66, 0x66, 0x38, 0x32, 0x35, 0x32, 0x66, 0x37, 0x38, 0x64, 0x37, 0x30, 0x61, 0x65, 0x62, 0x33, 0x33, 0x66, 0x38, 0x62, 0x61, 0x30, 0x39, 0x62, 0x65, 0x61, 0x65, 0x61, 0x64, 0x61, 0x64, 0x31, 0x62, 0x33, 0x37, 0x36, 0x61, 0x35, 0x37, 0x64, 0x33, 0x34, 0x66, 0x61, 0x37, 0x32, 0x30, 0x62, 0x62, 0x63, 0x34, 0x61, 0x31, 0x38, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x30, 0x78, 0x30, 0x33, 0x66, 0x38, 0x38, 0x66, 0x30, 0x37, 0x30, 0x32, 0x38, 0x34, 0x33, 0x62, 0x39, 0x61, 0x63, 0x61, 0x30, 0x30, 0x38, 0x35, 0x30, 0x36, 0x66, 0x63, 0x32, 0x33, 0x61, 0x63, 0x30, 0x30, 0x38, 0x33, 0x30, 0x31, 0x38, 0x36, 0x61, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x38, 0x30, 0x63, 0x30, 0x30, 0x31, 0x65, 0x31, 0x61, 0x30, 0x30, 0x31, 0x34, 0x35, 0x33, 0x33, 0x36, 0x32, 0x63, 0x33, 0x36, 0x30, 0x66, 0x64, 0x64, 0x38, 0x38, 0x33, 0x32, 0x65, 0x33, 0x35, 0x33, 0x39, 0x64, 0x34, 0x36, 0x33, 0x65, 0x36, 0x64, 0x36, 0x34, 0x62, 0x32, 0x65, 0x65, 0x33, 0x32, 0x30, 0x61, 0x63, 0x36, 0x61, 0x30, 0x38, 0x38, 0x38, 0x35, 0x64, 0x66, 0x36, 0x30, 0x38, 0x33, 0x36, 0x34, 0x34, 0x61, 0x30, 0x36, 0x33, 0x65, 0x37, 0x30, 0x31, 0x61, 0x30, 0x33, 0x37, 0x61, 0x37, 0x32, 0x38, 0x61, 0x65, 0x63, 0x30, 0x38, 0x61, 0x65, 0x66, 0x66, 0x66, 0x61, 0x37, 0x30, 0x32, 0x61, 0x32, 0x63, 0x61, 0x36, 0x32, 0x30, 0x64, 0x62, 0x38, 0x39, 0x63, 0x61, 0x66, 0x33, 0x65, 0x34, 0x36, 0x61, 0x62, 0x37, 0x66, 0x32, 0x35, 0x66, 0x37, 0x36, 0x34, 0x36, 0x66, 0x63, 0x39, 0x35, 0x31, 0x35, 0x31, 0x30, 0x39, 0x39, 0x31, 0x62, 0x61, 0x64, 0x63, 0x61, 0x30, 0x36, 0x35, 0x64, 0x38, 0x34, 0x36, 0x66, 0x30, 0x34, 0x36, 0x33, 0x35, 0x37, 0x61, 0x66, 0x33, 0x39, 0x62, 0x62, 0x37, 0x33, 0x39, 0x62, 0x31, 0x36, 0x31, 0x32, 0x33, 0x33, 0x66, 0x63, 0x65, 0x37, 0x33, 0x64, 0x64, 0x66, 0x65, 0x30, 0x62, 0x62, 0x38, 0x37, 0x66, 0x32, 0x64, 0x32, 0x38, 0x65, 0x66, 0x36, 0x30, 0x64, 0x66, 0x65, 0x36, 0x64, 0x62, 0x62, 0x30, 0x31, 0x32, 0x38, 0x64, 0x22, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x31, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x36, 0x61, 0x39, 0x36, 0x30, 0x38, 0x36, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x66, 0x31, 0x37, 0x36, 0x36, 0x38, 0x66, 0x33, 0x35, 0x66, 0x37, 0x34, 0x31, 0x38, 0x65, 0x66, 0x38, 0x37, 0x39, 0x38, 0x30, 0x37, 0x39, 0x31, 0x36, 0x37, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x37, 0x32, 0x65, 0x63, 0x64, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x32, 0x36, 0x31, 0x33, 0x37, 0x63, 0x66, 0x34, 0x35, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x32, 0x34, 0x37, 0x38, 0x36, 0x61, 0x62, 0x33, 0x34, 0x38, 0x33, 0x63, 0x32, 0x66, 0x39, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x33, 0x66, 0x35, 0x31, 0x30, 0x32, 0x64, 0x61, 0x62, 0x65, 0x30, 0x61, 0x32, 0x37, 0x62, 0x31, 0x37, 0x34, 0x36, 0x30, 0x39, 0x38, 0x64, 0x31, 0x64, 0x63, 0x31, 0x37, 0x61, 0x35, 0x64, 0x33, 0x66, 0x62, 0x64, 0x34, 0x37, 0x38, 0x37, 0x35, 0x39, 0x66, 0x65, 0x61, 0x39, 0x32, 0x38, 0x37, 0x65, 0x34, 0x65, 0x34, 0x31, 0x39, 0x62, 0x33, 0x63, 0x33, 0x63, 0x65, 0x66, 0x32, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x62, 0x31, 0x61, 0x63, 0x64, 0x62, 0x32, 0x63, 0x34, 0x64, 0x33, 0x64, 0x66, 0x33, 0x66, 0x31, 0x62, 0x38, 0x64, 0x33, 0x62, 0x66, 0x64, 0x33, 0x33, 0x34, 0x32, 0x31, 0x36, 0x36, 0x30, 0x64, 0x66, 0x33, 0x35, 0x38, 0x64, 0x38, 0x34, 0x64, 0x37, 0x38, 0x64, 0x31, 0x36, 0x63, 0x34, 0x36, 0x30, 0x33, 0x35, 0x35, 0x31, 0x39, 0x33, 0x35, 0x66, 0x34, 0x62, 0x36, 0x37, 0x36, 0x34, 0x33, 0x33, 0x37, 0x33, 0x65, 0x37, 0x65, 0x62, 0x36, 0x33, 0x64, 0x63, 0x62, 0x31, 0x36, 0x65, 0x63, 0x33, 0x35, 0x39, 0x62, 0x65, 0x30, 0x65, 0x63, 0x34, 0x31, 0x66, 0x65, 0x65, 0x33, 0x33, 0x62, 0x30, 0x33, 0x61, 0x31, 0x36, 0x65, 0x38, 0x30, 0x37, 0x34, 0x35, 0x66, 0x32, 0x33, 0x37, 0x34, 0x66, 0x66, 0x31, 0x64, 0x33, 0x63, 0x33, 0x35, 0x32, 0x35, 0x30, 0x38, 0x61, 0x63, 0x35, 0x64, 0x38, 0x35, 0x37, 0x63, 0x36, 0x34, 0x37, 0x36, 0x64, 0x33, 0x63, 0x33, 0x62, 0x63, 0x66, 0x37, 0x65, 0x36, 0x63, 0x61, 0x33, 0x37, 0x34, 0x32, 0x37, 0x63, 0x39, 0x32, 0x30, 0x39, 0x66, 0x31, 0x37, 0x62, 0x65, 0x33, 0x61, 0x66, 0x35, 0x32, 0x36, 0x34, 0x63, 0x30, 0x65, 0x32, 0x31, 0x33, 0x32, 0x62, 0x33, 0x64, 0x64, 0x31, 0x31, 0x35, 0x36, 0x63, 0x32, 0x38, 0x62, 0x34, 0x65, 0x39, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x30, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x63, 0x38, 0x35, 0x61, 0x36, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x63, 0x32, 0x31, 0x35, 0x66, 0x36, 0x61, 0x31, 0x32, 0x38, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x31, 0x65, 0x65, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x36, 0x34, 0x32, 0x34, 0x34, 0x30, 0x34, 0x33, 0x61, 0x35, 0x66, 0x36, 0x33, 0x39, 0x61, 0x61, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x32, 0x30, 0x34, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x63, 0x38, 0x35, 0x31, 0x66, 0x32, 0x39, 0x63, 0x37, 0x63, 0x31, 0x38, 0x33, 0x62, 0x65, 0x32, 0x35, 0x33, 0x65, 0x61, 0x31, 0x35, 0x31, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x31, 0x64, 0x62, 0x37, 0x30, 0x63, 0x34, 0x38, 0x35, 0x62, 0x36, 0x32, 0x36, 0x34, 0x36, 0x39, 0x32, 0x66, 0x32, 0x36, 0x62, 0x38, 0x61, 0x65, 0x61, 0x61, 0x62, 0x35, 0x62, 0x30, 0x63, 0x33, 0x38, 0x34, 0x31, 0x38, 0x30, 0x64, 0x66, 0x38, 0x65, 0x32, 0x31, 0x38, 0x34, 0x61, 0x32, 0x31, 0x61, 0x38, 0x30, 0x38, 0x61, 0x33, 0x65, 0x63, 0x38, 0x65, 0x38, 0x36, 0x63, 0x61, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x35, 0x36, 0x31, 0x37, 0x33, 0x31, 0x37, 0x38, 0x35, 0x62, 0x34, 0x38, 0x63, 0x66, 0x31, 0x38, 0x38, 0x36, 0x34, 0x31, 0x32, 0x32, 0x33, 0x34, 0x35, 0x33, 0x31, 0x65, 0x34, 0x39, 0x34, 0x30, 0x30, 0x36, 0x34, 0x35, 0x38, 0x34, 0x34, 0x36, 0x33, 0x65, 0x39, 0x36, 0x61, 0x63, 0x36, 0x33, 0x61, 0x31, 0x61, 0x31, 0x35, 0x34, 0x33, 0x32, 0x30, 0x32, 0x32, 0x37, 0x65, 0x33, 0x33, 0x33, 0x66, 0x62, 0x35, 0x31, 0x61, 0x64, 0x64, 0x63, 0x34, 0x61, 0x38, 0x39, 0x62, 0x37, 0x65, 0x30, 0x64, 0x33, 0x66, 0x38, 0x36, 0x32, 0x64, 0x37, 0x63, 0x31, 0x66, 0x64, 0x34, 0x65, 0x61, 0x30, 0x33, 0x62, 0x64, 0x38, 0x65, 0x62, 0x33, 0x64, 0x38, 0x38, 0x30, 0x36, 0x66, 0x31, 0x65, 0x37, 0x64, 0x61, 0x66, 0x35, 0x39, 0x31, 0x63, 0x62, 0x62, 0x62, 0x62, 0x39, 0x32, 0x62, 0x30, 0x62, 0x65, 0x62, 0x37, 0x34, 0x64, 0x31, 0x33, 0x63, 0x30, 0x31, 0x36, 0x31, 0x37, 0x66, 0x32, 0x32, 0x63, 0x35, 0x30, 0x32, 0x36, 0x62, 0x34, 0x66, 0x39, 0x66, 0x39, 0x66, 0x32, 0x39, 0x34, 0x61, 0x38, 0x61, 0x37, 0x63, 0x33, 0x32, 0x64, 0x62, 0x38, 0x39, 0x35, 0x64, 0x65, 0x33, 0x62, 0x30, 0x31, 0x62, 0x65, 0x65, 0x30, 0x31, 0x33, 0x32, 0x63, 0x39, 0x32, 0x30, 0x39, 0x65, 0x31, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x66, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x36, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x64, 0x61, 0x65, 0x65, 0x64, 0x37, 0x33, 0x34, 0x64, 0x61, 0x31, 0x31, 0x34, 0x34, 0x37, 0x30, 0x64, 0x61, 0x35, 0x35, 0x39, 0x62, 0x64, 0x34, 0x62, 0x34, 0x63, 0x37, 0x32, 0x35, 0x39, 0x65, 0x31, 0x66, 0x37, 0x39, 0x35, 0x32, 0x35, 0x35, 0x35, 0x32, 0x34, 0x31, 0x64, 0x63, 0x62, 0x63, 0x39, 0x30, 0x63, 0x66, 0x31, 0x39, 0x34, 0x61, 0x32, 0x65, 0x66, 0x36, 0x37, 0x36, 0x66, 0x63, 0x36, 0x30, 0x30, 0x35, 0x66, 0x33, 0x36, 0x37, 0x32, 0x66, 0x61, 0x64, 0x61, 0x32, 0x61, 0x33, 0x36, 0x34, 0x35, 0x65, 0x64, 0x62, 0x32, 0x39, 0x37, 0x61, 0x37, 0x35, 0x35, 0x33, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x39, 0x34, 0x66, 0x35, 0x33, 0x37, 0x34, 0x66, 0x63, 0x65, 0x35, 0x65, 0x64, 0x62, 0x63, 0x38, 0x65, 0x32, 0x61, 0x38, 0x36, 0x39, 0x37, 0x63, 0x31, 0x35, 0x33, 0x33, 0x31, 0x36, 0x37, 0x37, 0x65, 0x36, 0x65, 0x62, 0x66, 0x30, 0x62, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x38, 0x35, 0x31, 0x30, 0x33, 0x61, 0x35, 0x36, 0x31, 0x37, 0x39, 0x33, 0x37, 0x36, 0x39, 0x31, 0x64, 0x66, 0x65, 0x65, 0x62, 0x38, 0x39, 0x62, 0x38, 0x36, 0x61, 0x38, 0x30, 0x64, 0x35, 0x64, 0x63, 0x39, 0x65, 0x33, 0x63, 0x39, 0x64, 0x33, 0x61, 0x31, 0x61, 0x30, 0x65, 0x37, 0x63, 0x65, 0x33, 0x31, 0x31, 0x65, 0x32, 0x36, 0x65, 0x30, 0x62, 0x62, 0x37, 0x33, 0x32, 0x65, 0x61, 0x62, 0x61, 0x61, 0x34, 0x37, 0x66, 0x66, 0x61, 0x32, 0x38, 0x38, 0x66, 0x30, 0x64, 0x35, 0x34, 0x64, 0x65, 0x32, 0x38, 0x32, 0x30, 0x39, 0x61, 0x36, 0x32, 0x61, 0x37, 0x64, 0x32, 0x39, 0x64, 0x30, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x38, 0x64, 0x61, 0x65, 0x65, 0x64, 0x37, 0x33, 0x34, 0x64, 0x61, 0x31, 0x31, 0x34, 0x34, 0x37, 0x30, 0x64, 0x61, 0x35, 0x35, 0x39, 0x62, 0x64, 0x34, 0x62, 0x34, 0x63, 0x37, 0x32, 0x35, 0x39, 0x65, 0x31, 0x66, 0x37, 0x39, 0x35, 0x32, 0x35, 0x35, 0x35, 0x32, 0x34, 0x31, 0x64, 0x63, 0x62, 0x63, 0x39, 0x30, 0x63, 0x66, 0x31, 0x39, 0x34, 0x61, 0x32, 0x65, 0x66, 0x36, 0x37, 0x36, 0x66, 0x63, 0x36, 0x30, 0x30, 0x35, 0x66, 0x33, 0x36, 0x37, 0x32, 0x66, 0x61, 0x64, 0x61, 0x32, 0x61, 0x33, 0x36, 0x34, 0x35, 0x65, 0x64, 0x62, 0x32, 0x39, 0x37, 0x61, 0x37, 0x35, 0x35, 0x33, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x66, 0x36, 0x22, 0x2c, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x39, 0x36, 0x61, 0x39, 0x36, 0x30, 0x38, 0x36, 0x63, 0x66, 0x66, 0x30, 0x37, 0x64, 0x66, 0x31, 0x37, 0x36, 0x36, 0x38, 0x66, 0x33, 0x35, 0x66, 0x37, 0x34, 0x31, 0x38, 0x65, 0x66, 0x38, 0x37, 0x39, 0x38, 0x30, 0x37, 0x39, 0x31, 0x36, 0x37, 0x65, 0x33, 0x66, 0x34, 0x66, 0x39, 0x62, 0x37, 0x32, 0x65, 0x63, 0x64, 0x65, 0x31, 0x37, 0x62, 0x32, 0x38, 0x32, 0x32, 0x36, 0x31, 0x33, 0x37, 0x63, 0x66, 0x34, 0x35, 0x34, 0x61, 0x62, 0x31, 0x64, 0x64, 0x32, 0x30, 0x65, 0x66, 0x35, 0x64, 0x39, 0x32, 0x34, 0x37, 0x38, 0x36, 0x61, 0x62, 0x33, 0x34, 0x38, 0x33, 0x63, 0x32, 0x66, 0x39, 0x22, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x61, 0x35, 0x63, 0x38, 0x35, 0x61, 0x36, 0x30, 0x62, 0x61, 0x32, 0x39, 0x30, 0x35, 0x63, 0x32, 0x31, 0x35, 0x66, 0x36, 0x61, 0x31, 0x32, 0x38, 0x37, 0x32, 0x65, 0x36, 0x32, 0x62, 0x31, 0x65, 0x65, 0x30, 0x33, 0x37, 0x30, 0x35, 0x31, 0x33, 0x36, 0x34, 0x32, 0x34, 0x34, 0x30, 0x34, 0x33, 0x61, 0x35, 0x66, 0x36, 0x33, 0x39, 0x61, 0x61, 0x38, 0x31, 0x62, 0x30, 0x34, 0x61, 0x32, 0x30, 0x34, 0x63, 0x35, 0x35, 0x65, 0x37, 0x63, 0x63, 0x38, 0x35, 0x31, 0x66, 0x32, 0x39, 0x63, 0x37, 0x63, 0x31, 0x38, 0x33, 0x62, 0x65, 0x32, 0x35, 0x33, 0x65, 0x61, 0x31, 0x35, 0x31, 0x30, 0x62, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x5b, 0x22, 0x30, 0x78, 0x30, 0x30, 0x30, 0x36, 0x35, 0x37, 0x66, 0x33, 0x37, 0x35, 0x35, 0x34, 0x63, 0x37, 0x38, 0x31, 0x34, 0x30, 0x32, 0x61, 0x32, 0x32, 0x39, 0x31, 0x37, 0x64, 0x65, 0x65, 0x32, 0x66, 0x37, 0x35, 0x64, 0x65, 0x66, 0x37, 0x61, 0x62, 0x39, 0x36, 0x36, 0x64, 0x37, 0x62, 0x37, 0x37, 0x30, 0x39, 0x30, 0x35, 0x33, 0x39, 0x38, 0x65, 0x62, 0x61, 0x33, 0x63, 0x34, 0x34, 0x34, 0x30, 0x31, 0x34, 0x22, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x31, 0x36, 0x39, 0x36, 0x33, 0x30, 0x66, 0x35, 0x33, 0x35, 0x62, 0x34, 0x61, 0x34, 0x31, 0x33, 0x33, 0x30, 0x31, 0x36, 0x34, 0x63, 0x36, 0x65, 0x35, 0x63, 0x39, 0x32, 0x62, 0x31, 0x32, 0x32, 0x34, 0x63, 0x30, 0x63, 0x34, 0x30, 0x37, 0x66, 0x35, 0x38, 0x32, 0x64, 0x34, 0x30, 0x37, 0x64, 0x30, 0x61, 0x63, 0x33, 0x64, 0x32, 0x30, 0x36, 0x63, 0x64, 0x33, 0x32, 0x66, 0x64, 0x35, 0x32, 0x22, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x22, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x22, 0x30, 0x78, 0x33, 0x35, 0x35, 0x39, 0x65, 0x38, 0x35, 0x31, 0x34, 0x37, 0x30, 0x66, 0x36, 0x65, 0x37, 0x62, 0x62, 0x65, 0x64, 0x31, 0x64, 0x62, 0x34, 0x37, 0x34, 0x39, 0x38, 0x30, 0x36, 0x38, 0x33, 0x65, 0x38, 0x63, 0x33, 0x31, 0x35, 0x62, 0x66, 0x63, 0x65, 0x39, 0x39, 0x62, 0x32, 0x61, 0x36, 0x65, 0x66, 0x34, 0x37, 0x63, 0x30, 0x35, 0x37, 0x63, 0x30, 0x34, 0x64, 0x65, 0x37, 0x38, 0x35, 0x38, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x20, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x62, 0x6c, 0x6f, 0x62, 0x42, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x52, 0x61, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x52, 0x61, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x6d, 0x75, 0x63, 0x68, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x52, 0x61, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x66, 0x65, 0x65, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x65, 0x65, 0x20, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2e, 0x20, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x77, 0x65, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x48, 0x69, 0x67, 0x68, 0x65, 0x73, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x20, 0x6d, 0x6f, 0x6e, 0x6f, 0x74, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x62, 0x79, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x69, 0x70, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x69, 0x70, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x2e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x30, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x31, 0x30, 0x30, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x65, 0x65, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x65, 0x65, 0x20, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x65, 0x65, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x65, 0x65, 0x20, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x6f, 0x6c, 0x64, 0x65, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6c, 0x64, 0x65, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x6c, 0x64, 0x65, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2c, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x77, 0x65, 0x73, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x45, 0x49, 0x50, 0x2d, 0x31, 0x35, 0x35, 0x39, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2c, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x77, 0x65, 0x73, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x22, 0x3a, 0x20, 0x31, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x22, 0x3a, 0x30, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x22, 0x3a, 0x20, 0x31, 0x7d, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x20, 0x74, 0x77, 0x6f, 0x2d, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x7a, 0x65, 0x72, 0x6f, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x6c, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2c, 0x20, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x2e, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x79, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x79, 0x64, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x79, 0x64, 0x72, 0x61, 0x74, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4f, 0x6d, 0x6d, 0x65, 0x72, 0x73, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x69, 0x78, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x75, 0x6c, 0x6c, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x75, 0x6e, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x34, 0x38, 0x34, 0x34, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x31, 0x35, 0x35, 0x39, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x32, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x32, 0x39, 0x33, 0x30, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x31, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x79, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x79, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x79, 0x64, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x79, 0x64, 0x72, 0x61, 0x74, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x68, 0x61, 0x33, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4f, 0x6d, 0x6d, 0x65, 0x72, 0x73, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x47, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x44, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x74, 0x72, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x69, 0x78, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x69, 0x78, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x36, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x75, 0x6c, 0x6c, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x75, 0x6e, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x34, 0x38, 0x34, 0x34, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x31, 0x35, 0x35, 0x39, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x32, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x32, 0x39, 0x33, 0x30, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x31, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x79, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x73, 0x75, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x61, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x2e, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6c, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x73, 0x74, 0x2d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x42, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x20, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x31, 0x20, 0x28, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x20, 0x28, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x29, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x42, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x20, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x64, 0x65, 0x64, 0x75, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x27, 0x73, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x31, 0x35, 0x35, 0x39, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x2e, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x20, 0x2b, 0x20, 0x6d, 0x69, 0x6e, 0x28, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x20, 0x2d, 0x20, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x2c, 0x20, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x29, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x64, 0x65, 0x64, 0x75, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x27, 0x73, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x64, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x79, 0x74, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x50, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x20, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x70, 0x6f, 0x6c, 0x6c, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4c, 0x6f, 0x67, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x77, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x4c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x69, 0x64, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4c, 0x6f, 0x67, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x77, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x69, 0x64, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x28, 0x65, 0x73, 0x29, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x79, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x79, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4c, 0x6f, 0x67, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x65, 0x77, 0x20, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x2c, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x6f, 0x64, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x6b, 0x65, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6b, 0x65, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x33, 0x7d, 0x29, 0x7c, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x41, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x74, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x73, 0x6c, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x30, 0x2c, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x41, 0x6e, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x75, 0x6e, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x34, 0x38, 0x34, 0x34, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x31, 0x35, 0x35, 0x39, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x32, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x32, 0x39, 0x33, 0x30, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x31, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x41, 0x6e, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x75, 0x6e, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x34, 0x38, 0x34, 0x34, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x31, 0x35, 0x35, 0x39, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x32, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x32, 0x39, 0x33, 0x30, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x31, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5d, 0x2c, 0x22, 0x75, 0x6e, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x34, 0x38, 0x34, 0x34, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x31, 0x35, 0x35, 0x39, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x32, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x2c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x32, 0x39, 0x33, 0x30, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x31, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x69, 0x74, 0x79, 0x20, 0x28, 0x30, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x2c, 0x20, 0x31, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x64, 0x64, 0x29, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x79, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2c, 0x20, 0x60, 0x76, 0x60, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x79, 0x50, 0x61, 0x72, 0x69, 0x74, 0x79, 0x60, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x30, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x68, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x61, 0x67, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x61, 0x6e, 0x79, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x73, 0x75, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x70, 0x72, 0x65, 0x63, 0x65, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x61, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x2e, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x75, 0x6c, 0x6c, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x5b, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x5d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6c, 0x6f, 0x67, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x6f, 0x6d, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x35, 0x31, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x73, 0x74, 0x2d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x42, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x20, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x31, 0x20, 0x28, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x29, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x20, 0x28, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x29, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x42, 0x79, 0x7a, 0x61, 0x6e, 0x74, 0x69, 0x75, 0x6d, 0x20, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x64, 0x65, 0x64, 0x75, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x27, 0x73, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x31, 0x35, 0x35, 0x39, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x2e, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x20, 0x2b, 0x20, 0x6d, 0x69, 0x6e, 0x28, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x20, 0x2d, 0x20, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x2c, 0x20, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x29, 0x2e, 0x22, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x64, 0x65, 0x64, 0x75, 0x63, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x27, 0x73, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x2e, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x67, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x67, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x65, 0x6e, 0x75, 0x6d, 0x22, 0x3a, 0x5b, 0x22, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0x2c, 0x22, 0x73, 0x61, 0x66, 0x65, 0x22, 0x2c, 0x22, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x5d, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x60, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x77, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x3b, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2d, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2c, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61, 0x6e, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x73, 0x61, 0x66, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x68, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x3a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x2d, 0x6f, 0x72, 0x67, 0x65, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x2f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3b, 0x20, 0x60, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x60, 0x3a, 0x20, 0x41, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x60, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x6d, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x20, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x60, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x73, 0x61, 0x66, 0x65, 0x60, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x2d, 0x33, 0x39, 0x30, 0x30, 0x31, 0x3a, 0x20, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x60, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x63, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x6e, 0x65, 0x77, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x2c, 0x20, 0x74, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x61, 0x72, 0x72, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x6e, 0x65, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x74, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x20, 0x28, 0x6c, 0x6f, 0x67, 0x73, 0x29, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x28, 0x65, 0x73, 0x29, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x79, 0x20, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x6e, 0x79, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x6e, 0x65, 0x77, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x2c, 0x20, 0x74, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x72, 0x69, 0x76, 0x65, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x73, 0x65, 0x6e, 0x64, 0x52, 0x61, 0x77, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x73, 0x20, 0x61, 0x20, 0x72, 0x61, 0x77, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x77, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2c, 0x20, 0x4b, 0x5a, 0x47, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4b, 0x5a, 0x47, 0x20, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x73, 0x65, 0x6e, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x73, 0x20, 0x61, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x52, 0x61, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x68, 0x61, 0x73, 0x68, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x31, 0x39, 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x36, 0x35, 0x20, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x31, 0x33, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x52, 0x4c, 0x50, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x22, 0x3a, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x3f, 0x29, 0x7b, 0x31, 0x2c, 0x32, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x74, 0x6f, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6e, 0x75, 0x6c, 0x6c, 0x22, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x5d, 0x7d, 0x2c, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x67, 0x61, 0x73, 0x20, 0x70, 0x72, 0x69, 0x63, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x69, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x28, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x2f, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x66, 0x65, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x2f, 0x20, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x66, 0x65, 0x65, 0x29, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x6d, 0x61, 0x78, 0x46, 0x65, 0x65, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x6d, 0x61, 0x78, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x66, 0x65, 0x65, 0x20, 0x70, 0x65, 0x72, 0x20, 0x67, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x67, 0x61, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x65, 0x69, 0x22, 0x7d, 0x2c, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x45, 0x49, 0x50, 0x2d, 0x32, 0x39, 0x33, 0x30, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x41, 0x2d, 0x46, 0x5d, 0x7b, 0x34, 0x30, 0x7d, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x34, 0x38, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x68, 0x65, 0x78, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x7b, 0x36, 0x34, 0x7d, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x52, 0x61, 0x77, 0x20, 0x62, 0x6c, 0x6f, 0x62, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x61, 0x72, 0x72, 0x61, 0x79, 0x22, 0x2c, 0x22, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x2c, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x49, 0x44, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x6e, 0x2e, 0x22, 0x7d, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x22, 0x6f, 0x6e, 0x65, 0x4f, 0x66, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0x2c, 0x22, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2c, 0x22, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x22, 0x3a, 0x7b, 0x22, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x2c, 0x22, 0x68, 0x69, 0x67, 0x68, 0x65, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x48, 0x69, 0x67, 0x68, 0x65, 0x73, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x4e, 0x6f, 0x74, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x2e, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x5d, 0x7d, 0x7d, 0x7d, 0x2c, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x65, 0x74, 0x68, 0x5f, 0x75, 0x6e, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x3a, 0x22, 0x55, 0x6e, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x69, 0x64, 0x2e, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x3a, 0x5b, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3a, 0x22, 0x68, 0x65, 0x78, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x22, 0x2c, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x2c, 0x22, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x22, 0x3a, 0x22, 0x5e, 0x30, 0x78, 0x28, 0x5b, 0x31, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2b, 0x5b, 0x30, 0x2d, 0x39, 0x61, 0x2d, 0x66, 0x5d, 0x2a, 0x7c, 0x30, 0x29, 0x24, 0x22, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3a, 0x7b, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x22, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x22, 0x2c, 0x22, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x7b, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3a, 0x22, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x22, 0x7d, 0x7d, 0x7d, 0x5d, 0x2c, 0x22, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3a, 0x7b, 0x7d, 0x7d }; namespace silkworm::rpc::json_rpc { constinit const std::string_view kSpecificationJson{&kSpecificationDataInternal[0], sizeof(kSpecificationDataInternal)}; } ================================================ FILE: silkworm/rpc/json_rpc/specification.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::rpc::json_rpc { constinit extern const std::string_view kSpecificationJson; } ================================================ FILE: silkworm/rpc/json_rpc/specification.json ================================================ { "openrpc": "1.2.4", "info": { "title": "Ethereum JSON-RPC Specification", "description": "A specification of the standard interface for Ethereum clients.", "license": { "name": "CC0-1.0", "url": "https://creativecommons.org/publicdomain/zero/1.0/legalcode" }, "version": "0.0.0" }, "methods": [ { "name": "debug_accountRange", "summary": "Enumerates all accounts at a given block with paging capability.", "params": [ { "name": "Block", "required": true, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } }, { "name": "Addresses prefix", "required": true, "schema": { "title": "prefix of addresses expressed as array of bytes", "type": "array", "items": { "title": "decimal 8-bit number", "type": "number", "minimum": 0, "maximum": 255 } } }, { "name": "Maximum results", "required": true, "schema": { "items": { "title": "hex encoded 64 bit unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "No Code", "required": true, "schema": { "type": "boolean" } }, { "name": "No Storage", "required": true, "schema": { "type": "boolean" } }, { "name": "No preimages", "required": false, "schema": { "type": "boolean" } } ], "result": { "name": "dumpAccounts", "schema": { "title": "Dumped Accounts", "type": "object", "required": [ "root", "accounts", "next" ], "additionalProperties": false, "properties": { "root": { "title": "root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "accounts": { "title": "accounts", "type": "object", "required": [ "balance", "nonce" ], "additionalProperties": false, "properties": { "address": { "title": "balance", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "root": { "title": "storageHash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "codeHash": { "title": "codeHash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "code": { "title": "code", "type": "string", "pattern": "^0x[0-9a-f]*$" } } }, "next": { "title": "next", "type": "string", "pattern": "^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{4}|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{2}={2})$" } } } } }, { "name": "debug_getBadBlocks", "summary": "Returns an array of recent bad blocks that the client has seen on the network.", "params": [], "result": { "name": "Blocks", "schema": { "title": "Bad block array", "type": "array", "items": { "title": "Bad block", "type": "object", "required": [ "block", "hash", "rlp" ], "additionalProperties": false, "properties": { "block": { "title": "Block", "type": "object", "required": [ "hash", "parentHash", "sha3Uncles", "miner", "stateRoot", "transactionsRoot", "receiptsRoot", "logsBloom", "number", "gasLimit", "gasUsed", "timestamp", "extraData", "mixHash", "nonce", "size", "transactions", "uncles" ], "additionalProperties": false, "properties": { "hash": { "title": "Hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "sha3Uncles": { "title": "Ommers hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "miner": { "title": "Coinbase", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionsRoot": { "title": "Transactions root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "difficulty": { "title": "Difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "number": { "title": "Number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "mixHash": { "title": "Mix hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "nonce": { "title": "Nonce", "type": "string", "pattern": "^0x[0-9a-f]{16}$" }, "totalDifficulty": { "title": "Total difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "withdrawalsRoot": { "title": "Withdrawals root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blobGasUsed": { "title": "Blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "excessBlobGas": { "title": "Excess blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "parentBeaconBlockRoot": { "title": "Parent Beacon Block Root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "size": { "title": "Block size", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactions": { "anyOf": [ { "title": "Transaction hashes", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "title": "Full transactions", "type": "array", "items": { "type": "object", "title": "Transaction information", "required": [ "blockHash", "blockNumber", "from", "hash", "transactionIndex" ], "unevaluatedProperties": false, "oneOf": [ { "title": "Signed 4844 Transaction", "type": "object", "required": [ "accessList", "blobVersionedHashes", "chainId", "gas", "input", "maxFeePerBlobGas", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "to", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 1559 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x2$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The effective gas price paid by the sender in wei. For transactions not yet included in a block, this value should be set equal to the max fee per gas. This field is DEPRECATED, please transition to using effectiveGasPrice in the receipt object going forward." }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 2930 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x1$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed Legacy Transaction", "type": "object", "required": [ "gas", "gasPrice", "input", "nonce", "r", "s", "type", "v", "value" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x0$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ], "properties": { "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "hash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } ] }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "type": "object", "title": "Validator withdrawal", "required": [ "index", "validatorIndex", "address", "amount" ], "additionalProperties": false, "properties": { "index": { "title": "index of withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "index of validator that generated withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "recipient address for withdrawal value", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "value contained in withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" } } } }, "uncles": { "title": "Uncles", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } }, "hash": { "title": "Hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "rlp": { "title": "RLP", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } } }, "examples": [ { "name": "debug_getBadBlocks example", "params": [], "result": { "name": "Bad block array", "value": [ { "block": { "number": "0xd", "hash": "0x85c2edc1ca74b4863cab46ff6ed4df514a698aa7c29a9bce58742a33af07d7e6", "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash": "0x544a2f7a4c8defc0d8da44aa0c0db7c36b56db2605c01ed266e919e936579d31", "nonce": "0x0000000000000000", "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "transactionsRoot": "0x02c387e001cbe2a8296bfa2e18afbc3480d0e49588b05556148b0bf7c17dec41", "stateRoot": "0x861ab7e868e3c23f84b7c4ed86b52a6a4f063633bc45ef29212c33459df84ea5", "receiptsRoot": "0xccd2d33763dc0ac3fe02d4ecbbcd7d2bdc6f57db635ba31007184679303721d7", "miner": "0x0000000000000000000000000000000000000000", "difficulty": "0x1", "totalDifficulty": "0x1", "extraData": "0x00000000000000000000000000000000000000000000000000000000000000008c6a091f07e4ba3930f2f5fabbfc5b1c70986319096760ba200a6abc0d30e33c2d501702d1b58d7f75807bdbf981044557628611319121170b96466ec06bb3fd01", "size": "0x3a0", "gasLimit": "0xffffffffffff", "gasUsed": "0x1a488", "timestamp": "0x5f5b6824", "uncles": [], "transactions": [ { "blockHash": "0x85c2edc1ca74b4863cab46ff6ed4df514a698aa7c29a9bce58742a33af07d7e6", "blockNumber": "0xd", "from": "0xfe3b557e8fb62b89f4916b721be55ceb828dbd73", "gas": "0x1a49e", "gasPrice": "0x3e8", "hash": "0xdd8cf045113754c306ba9ac8ac8786235e33bc5c087678084ef260a2a583f127", "input": "0x608060405234801561001057600080fd5b5060c78061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80636057361d146037578063b05784b8146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea26469706673582212208dea039245bf78c381278382d7056eef5083f7d243d8958817ef447e0a403bd064736f6c63430006060033", "nonce": "0x0", "to": null, "transactionIndex": "0x0", "value": "0x0", "v": "0xf9d", "r": "0xa7a15050302ca4b7d3842d35cdd3cbf25b2c48c0c37f96d78beb6a6a6bc4f1c7", "s": "0x130d29294b2b6a2b7e89f501eb27772f7abf37bfa28a1ce300daade975589fca" } ] }, "hash": "0x85c2edc1ca74b4863cab46ff6ed4df514a698aa7c29a9bce58742a33af07d7e6", "rlp": "0xf9039df9025ca0544a2f7a4c8defc0d8da44aa0c0db7c36b56db2605c01ed266e919e936579d31a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0861ab7e868e3c23f84b7c4ed86b52a6a4f063633bc45ef29212c33459df84ea5a002c387e001cbe2a8296bfa2e18afbc3480d0e49588b05556148b0bf7c17dec41a0ccd2d33763dc0ac3fe02d4ecbbcd7d2bdc6f57db635ba31007184679303721d7b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010d86ffffffffffff8301a488845f5b6824b86100000000000000000000000000000000000000000000000000000000000000008c6a091f07e4ba3930f2f5fabbfc5b1c70986319096760ba200a6abc0d30e33c2d501702d1b58d7f75807bdbf981044557628611319121170b96466ec06bb3fd01a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f9013af90137808203e88301a49e8080b8e6608060405234801561001057600080fd5b5060c78061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80636057361d146037578063b05784b8146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea26469706673582212208dea039245bf78c381278382d7056eef5083f7d243d8958817ef447e0a403bd064736f6c63430006060033820f9da0a7a15050302ca4b7d3842d35cdd3cbf25b2c48c0c37f96d78beb6a6a6bc4f1c7a0130d29294b2b6a2b7e89f501eb27772f7abf37bfa28a1ce300daade975589fcac0" }, { "block": { "number": "0x8", "hash": "0x601a3ae9b6eceb2476d249e1cffe058ba3ff2c9c1b28b1ec7a0259fdd1d90121", "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash": "0x98ae440cd7b904d842daa6c263608969a3c8ce6a9acd6bd1f99b394f5f28a207", "nonce": "0x0000000000000000", "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "transactionsRoot": "0x8ee998cc699a1f9310a1079458780b3ebee8756f96a0905f5224b89d0eb17486", "stateRoot": "0x140a9783291704223eb759e3a0db5471a520d349fc17ac2f77ff8582472e3bac", "receiptsRoot": "0x2b5c77f6e7764d2468178fab7253346b9b8bb6a34b63946f6bdc2f5ad398bfc3", "miner": "0x0000000000000000000000000000000000000000", "difficulty": "0x2", "totalDifficulty": "0x2", "extraData": "0x00000000000000000000000000000000000000000000000000000000000000004d04551bdd9ae08af1fd661e49d4ab662c98c532c7ec0e4656a27e4de7d330af578ab1e4f5e49e085ff1d78673c7388ed9ccf017fbe89e53066bfa4018142c0701", "size": "0x3a0", "gasLimit": "0xffffffffffff", "gasUsed": "0x1a4c9", "timestamp": "0x5f5b6b80", "uncles": [], "transactions": [ { "blockHash": "0x601a3ae9b6eceb2476d249e1cffe058ba3ff2c9c1b28b1ec7a0259fdd1d90121", "blockNumber": "0x8", "from": "0xfe3b557e8fb62b89f4916b721be55ceb828dbd73", "gas": "0x1a4c9", "gasPrice": "0x3e8", "hash": "0x675e336a4281b29c619dfd4ccfbd2f930f3728b20caf9e0067284aa3224e6758", "input": "0x608060405234801561001057600080fd5b5060c78061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80636057361d146037578063b05784b8146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea26469706673582212208dea039245bf78c381278382d7056eef5083f7d243d8958817ef447e0a403bd064736f6c63430006060033", "nonce": "0x0", "to": null, "transactionIndex": "0x0", "value": "0x0", "v": "0xf9d", "r": "0x2e30624c0305e64812e1d9e325ba6e50410314634b008edcb50f45be71fa0d4", "s": "0x50e205faed23c219ba15610de2451d458cbd4221207b2168344cfc972a7973c0" } ] }, "hash": "0x601a3ae9b6eceb2476d249e1cffe058ba3ff2c9c1b28b1ec7a0259fdd1d90121", "rlp": "0xf9039df9025ca098ae440cd7b904d842daa6c263608969a3c8ce6a9acd6bd1f99b394f5f28a207a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0140a9783291704223eb759e3a0db5471a520d349fc17ac2f77ff8582472e3baca08ee998cc699a1f9310a1079458780b3ebee8756f96a0905f5224b89d0eb17486a02b5c77f6e7764d2468178fab7253346b9b8bb6a34b63946f6bdc2f5ad398bfc3b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020886ffffffffffff8301a4c9845f5b6b80b86100000000000000000000000000000000000000000000000000000000000000004d04551bdd9ae08af1fd661e49d4ab662c98c532c7ec0e4656a27e4de7d330af578ab1e4f5e49e085ff1d78673c7388ed9ccf017fbe89e53066bfa4018142c0701a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f9013af90137808203e88301a4c98080b8e6608060405234801561001057600080fd5b5060c78061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80636057361d146037578063b05784b8146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea26469706673582212208dea039245bf78c381278382d7056eef5083f7d243d8958817ef447e0a403bd064736f6c63430006060033820f9da002e30624c0305e64812e1d9e325ba6e50410314634b008edcb50f45be71fa0d4a050e205faed23c219ba15610de2451d458cbd4221207b2168344cfc972a7973c0c0" } ] } } ] }, { "name": "debug_getRawBlock", "summary": "Returns an RLP-encoded block.", "params": [ { "name": "Block", "required": true, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } } ], "result": { "name": "Block RLP", "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "examples": [ { "name": "debug_getRawBlock example", "params": [ { "name": "Block", "value": "0x32026E" } ], "result": { "name": "Block RLP", "value": "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" } } ] }, { "name": "debug_getRawHeader", "summary": "Returns an RLP-encoded header.", "params": [ { "name": "Block", "required": true, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } } ], "result": { "name": "Header RLP", "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "examples": [ { "name": "debug_getRawHeader example", "params": [ { "name": "Block", "value": "0x32026E" } ], "result": { "name": "Header RLP", "value": "0xf90236a09f73691f6dabca4f0a99b05d0a701995506aa311dcaa9ce9833d6f4ca474c162a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794c6e2459991bfe27cca6d86722f35da23a1e4cb97a078103ea8c47231886481d72ec1afae6eeb06c3773ce24a91323d5c9eed69d4cca0008992da2531db404f07b0871dd620a94ba346963e1b1c6dc7b00748e8593a1ea0b6c3890d9604434fc52f722848c84d1770add20cd75bbc28cdedff42940dbb56b90100200800000400000002000e0000000401000000440100000000c0400600000002000801000000040480020840048000000000400000000000000020004220000011002000000000000204000800000010010002000002000000000040a000000000000400020000010885000000000808000000008800001004002010020300005000000010002110410402000000000000000890000008000000000000000000020040000002000000000000810400000040006000004000004080020000000000000022001000000000000840400000000220250000000000080402000420000418000000000000000400040000004080040010200000000000108020020000808332026e8401c9c380833e3c3c846436f93899d883010b05846765746888676f312e32302e32856c696e7578a0112d8f15793e7df7f8dcdb21c891cff78c0d1839cb5b6dcd06116cdbb99536ae88000000000000000008a0cdb97712af6685bb9650d21d609525913293c48adda7c45990926daada335c9b" } } ] }, { "name": "debug_getRawReceipts", "summary": "Returns an array of EIP-2718 binary-encoded receipts.", "params": [ { "name": "Block", "required": true, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } } ], "result": { "name": "Receipts", "schema": { "title": "Receipt array", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } }, "examples": [ { "name": "debug_getRawReceipts example", "params": [ { "name": "Block", "value": "0x32026E" } ], "result": { "name": "Receipts", "value": [ "0xf901a60182c70eb9010000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000002000000000000000000000008000000000000000000000000000000000040000000001000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000100000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000002000000000100000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000020000000000000000f89df89b947753cfad258efbc52a9a1452e42ffbce9be486cbf863a0ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa00000000000000000000000000828d0386c1122e565f07dd28c7d1340ed5b3315a000000000000000000000000021849e99c31e3113a489d7eb0fd4d8c0edbe47afa00000000000000000000000000000000000000000000000000000000029b92700", "0xf901a70183018e1cb9010000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000002000000000000000000000008000000000000000000000000000000000040000000001000000000000000000000000000000000000000000000000010000000000000000000000000000000008000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000002000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000020000000000000000f89df89b947753cfad258efbc52a9a1452e42ffbce9be486cbf863a0ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa00000000000000000000000000828d0386c1122e565f07dd28c7d1340ed5b3315a000000000000000000000000069cda9d6cc6ce05982d0b4fdf9480f2991f39b5aa00000000000000000000000000000000000000000000000000000000029b92700" ] } } ] }, { "name": "debug_getRawTransaction", "summary": "Returns an array of EIP-2718 binary-encoded transactions.", "params": [ { "name": "Transaction hash", "required": true, "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ], "result": { "name": "EIP-2718 binary-encoded transaction", "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "examples": [ { "name": "debug_getRawTransaction example", "params": [ { "name": "Transaction hash", "value": "0x3a2fd1a5ea9ffee477f449be53a49398533d2c006a5815023920d1c397298df3" } ], "result": { "name": "EIP-2718 binary-encoded transaction", "value": "0xf8678084342770c182520894658bdf435d810c91414ec09147daa6db624063798203e880820a95a0af5fc351b9e457a31f37c84e5cd99dd3c5de60af3de33c6f4160177a2c786a60a0201da7a21046af55837330a2c52fc1543cd4d9ead00ddf178dd96935b607ff9b" } } ] }, { "name": "engine_exchangeCapabilities", "summary": "Exchanges list of supported Engine API methods", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md#engine_exchangecapabilities" }, "params": [ { "name": "Consensus client methods", "required": true, "schema": { "type": "array", "items": { "type": "string" } } } ], "result": { "name": "Execution client methods", "schema": { "type": "array", "items": { "type": "string" } } }, "examples": [ { "name": "engine_exchangeCapabilities example", "params": [ { "name": "Consensus client methods", "value": [ "engine_exchangeTransitionConfigurationV1", "engine_forkchoiceUpdatedV1", "engine_getPayloadBodiesByHashV1", "engine_getPayloadBodiesByRangeV1", "engine_getPayloadV1", "engine_newPayloadV1" ] } ], "result": { "name": "Execution client methods", "value": [ "engine_getPayloadV1", "engine_getPayloadV2", "engine_executePayloadV1", "engine_newPayloadV1", "engine_newPayloadV2", "engine_forkchoiceUpdatedV1", "engine_forkchoiceUpdatedV2", "engine_exchangeTransitionConfigurationV1", "engine_getPayloadBodiesByHashV1", "engine_getPayloadBodiesByRangeV1" ] } } ] }, { "name": "engine_exchangeTransitionConfigurationV1", "summary": "Exchanges transition configuration", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#engine_exchangetransitionconfigurationv1" }, "params": [ { "name": "Consensus client configuration", "required": true, "schema": { "title": "Transition configuration object", "type": "object", "required": [ "terminalTotalDifficulty", "terminalBlockHash", "terminalBlockNumber" ], "properties": { "terminalTotalDifficulty": { "title": "Terminal total difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "terminalBlockHash": { "title": "Terminal block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "terminalBlockNumber": { "title": "Terminal block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } ], "result": { "name": "Execution client configuration", "schema": { "title": "Transition configuration object", "type": "object", "required": [ "terminalTotalDifficulty", "terminalBlockHash", "terminalBlockNumber" ], "properties": { "terminalTotalDifficulty": { "title": "Terminal total difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "terminalBlockHash": { "title": "Terminal block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "terminalBlockNumber": { "title": "Terminal block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "examples": [ { "name": "engine_exchangeTransitionConfigurationV1 example", "params": [ { "name": "Consensus client configuration", "value": { "terminalTotalDifficulty": 0, "terminalBlockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber": "0x1" } } ], "result": { "name": "Execution client configuration", "value": { "terminalTotalDifficulty": 0, "terminalBlockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "terminalBlockNumber": "0x1" } } } ] }, { "name": "engine_forkchoiceUpdatedV1", "summary": "Updates the forkchoice state", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#engine_forkchoiceupdatedv1" }, "params": [ { "name": "Forkchoice state", "required": true, "schema": { "title": "Forkchoice state object V1", "type": "object", "required": [ "headBlockHash", "safeBlockHash", "finalizedBlockHash" ], "properties": { "headBlockHash": { "title": "Head block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "safeBlockHash": { "title": "Safe block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "finalizedBlockHash": { "title": "Finalized block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } }, { "name": "Payload attributes", "required": false, "schema": { "oneOf": [ { "title": "No payload attributes (null)", "type": "null" }, { "title": "Payload attributes object V1", "type": "object", "required": [ "timestamp", "prevRandao", "suggestedFeeRecipient" ], "properties": { "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "suggestedFeeRecipient": { "title": "Suggested fee recipient", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } } } ] } } ], "result": { "name": "Response object", "schema": { "title": "Forkchoice updated response", "type": "object", "required": [ "payloadStatus" ], "properties": { "payloadStatus": { "title": "Payload status", "type": "object", "required": [ "status" ], "properties": { "status": { "title": "Payload validation status", "type": "string", "enum": [ "VALID", "INVALID", "SYNCING" ], "description": "Set of possible values is restricted to VALID, INVALID, SYNCING" }, "latestValidHash": { "title": "The hash of the most recent valid block", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "validationError": { "title": "Validation error message", "type": "string" } } }, "payloadId": { "title": "Payload id", "type": "string", "pattern": "^0x[0-9a-f]{16}$" } } } }, "errors": [ { "code": -38002, "message": "Invalid forkchoice state" }, { "code": -38003, "message": "Invalid payload attributes" } ], "examples": [ { "name": "engine_forkchoiceUpdatedV1 example", "params": [ { "name": "Forkchoice state", "value": { "headBlockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "safeBlockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "finalizedBlockHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a" } }, { "name": "Payload attributes", "value": { "timestamp": "0x5", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "suggestedFeeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" } } ], "result": { "name": "Response object", "value": { "payloadStatus": { "status": "VALID", "latestValidHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "validationError": null }, "payloadId": "0x0000000021f32cc1" } } } ] }, { "name": "engine_forkchoiceUpdatedV2", "summary": "Updates the forkchoice state", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_forkchoiceupdatedv2" }, "params": [ { "name": "Forkchoice state", "required": true, "schema": { "title": "Forkchoice state object V1", "type": "object", "required": [ "headBlockHash", "safeBlockHash", "finalizedBlockHash" ], "properties": { "headBlockHash": { "title": "Head block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "safeBlockHash": { "title": "Safe block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "finalizedBlockHash": { "title": "Finalized block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } }, { "name": "Payload attributes", "required": false, "schema": { "oneOf": [ { "title": "No payload attributes (null)", "type": "null" }, { "title": "Payload attributes object V2", "type": "object", "required": [ "timestamp", "prevRandao", "suggestedFeeRecipient", "withdrawals" ], "properties": { "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "suggestedFeeRecipient": { "title": "Suggested fee recipient", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } } } ] } } ], "result": { "name": "Response object", "schema": { "title": "Forkchoice updated response", "type": "object", "required": [ "payloadStatus" ], "properties": { "payloadStatus": { "title": "Payload status", "type": "object", "required": [ "status" ], "properties": { "status": { "title": "Payload validation status", "type": "string", "enum": [ "VALID", "INVALID", "SYNCING" ], "description": "Set of possible values is restricted to VALID, INVALID, SYNCING" }, "latestValidHash": { "title": "The hash of the most recent valid block", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "validationError": { "title": "Validation error message", "type": "string" } } }, "payloadId": { "title": "Payload id", "type": "string", "pattern": "^0x[0-9a-f]{16}$" } } } }, "errors": [ { "code": -38002, "message": "Invalid forkchoice state" }, { "code": -38003, "message": "Invalid payload attributes" } ], "examples": [ { "name": "engine_forkchoiceUpdatedV2 example", "params": [ { "name": "Forkchoice state", "value": { "headBlockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "safeBlockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "finalizedBlockHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a" } }, { "name": "Payload attributes", "value": { "timestamp": "0x64e7785b", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "suggestedFeeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ] } } ], "result": { "name": "Response object", "value": { "payloadStatus": { "status": "VALID", "latestValidHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "validationError": null }, "payloadId": "0x0000000021f32cc1" } } } ] }, { "name": "engine_forkchoiceUpdatedV3", "summary": "Updates the forkchoice state", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#engine_forkchoiceupdatedv3" }, "params": [ { "name": "Forkchoice state", "required": true, "schema": { "title": "Forkchoice state object V1", "type": "object", "required": [ "headBlockHash", "safeBlockHash", "finalizedBlockHash" ], "properties": { "headBlockHash": { "title": "Head block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "safeBlockHash": { "title": "Safe block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "finalizedBlockHash": { "title": "Finalized block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } }, { "name": "Payload attributes", "required": false, "schema": { "oneOf": [ { "title": "No payload attributes (null)", "type": "null" }, { "title": "Payload attributes object V3", "type": "object", "required": [ "timestamp", "prevRandao", "suggestedFeeRecipient", "withdrawals", "parentBeaconBlockRoot" ], "properties": { "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "suggestedFeeRecipient": { "title": "Suggested fee recipient", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "parentBeaconBlockRoot": { "title": "Parent beacon block root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } ] } } ], "result": { "name": "Response object", "schema": { "title": "Forkchoice updated response", "type": "object", "required": [ "payloadStatus" ], "properties": { "payloadStatus": { "title": "Payload status", "type": "object", "required": [ "status" ], "properties": { "status": { "title": "Payload validation status", "type": "string", "enum": [ "VALID", "INVALID", "SYNCING" ], "description": "Set of possible values is restricted to VALID, INVALID, SYNCING" }, "latestValidHash": { "title": "The hash of the most recent valid block", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "validationError": { "title": "Validation error message", "type": "string" } } }, "payloadId": { "title": "Payload id", "type": "string", "pattern": "^0x[0-9a-f]{16}$" } } } }, "errors": [ { "code": -38002, "message": "Invalid forkchoice state" }, { "code": -38003, "message": "Invalid payload attributes" }, { "code": -32602, "message": "Invalid params" }, { "code": -38005, "message": "Unsupported fork" } ], "examples": [ { "name": "engine_forkchoiceUpdatedV3 example", "params": [ { "name": "Forkchoice state", "value": { "headBlockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "safeBlockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "finalizedBlockHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a" } }, { "name": "Payload attributes", "value": { "timestamp": "0x64e7785b", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "suggestedFeeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ], "parentBeaconBlockRoot": "0x11f780a954bcba8889998e4e61deaae6388dd2391e9c810bd9c94962cc1eadc1" } } ], "result": { "name": "Response object", "value": { "payloadStatus": { "status": "VALID", "latestValidHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "validationError": null }, "payloadId": "0x0000000021f32cc1" } } } ] }, { "name": "engine_getPayloadBodiesByHashV1", "summary": "Given block hashes returns bodies of the corresponding execution payloads", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_getpayloadbodiesbyhashv1" }, "params": [ { "name": "Array of block hashes", "required": true, "schema": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } ], "result": { "name": "Execution payload bodies", "schema": { "type": "array", "items": { "title": "Execution payload body object V1", "type": "object", "required": [ "transactions" ], "properties": { "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": [ "array", "null" ], "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } } } } }, "errors": [ { "code": -38004, "message": "Too large request" } ], "examples": [ { "name": "engine_getPayloadBodiesByHashV1 example", "params": [ { "name": "Array of block hashes", "value": [ "0xd5f1812548be429cbdc6376b29611fc49e06f1359758c4ceaaa3b393e2239f9c", "0xfe88c94d860f01a17f961bf4bdfb6e0c6cd10d3fda5cc861e805ca1240c58553" ] } ], "result": { "name": "Execution payload bodies", "value": [ { "transactions": [ "0xf865808506fc23ac00830124f8940101010101010101010101010101010101010101018031a02c4d88bfdc2f6dbf82c33d235c4e785e9fc23b2d0fc7b9d20fc5e9674f1f9d15a016d6d69b925cf26128683ab4a096e196fbb1142d6c6d4e8d3481b9bef1bd0f65", "0x02f86c0701843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a039409b4e5603dd8c3cf38232348661a8e99ac518396eeaa128ec9ec2a3eb8127a06b21ab956f5f138cb44fda1a9055bd08980ea4f8040d877c00dac025608d0d95" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ] }, { "transactions": [ "0xf865108506fc23ac00830124f8940101010101010101010101010101010101010101018031a0d9712a3c40ae85aea4ad1bd95a0b7cc7bd805189a9e2517403b11a00a1530f81a053b53b0267a6dcfe9f9a1652307b396b3e8a65e65707a450e60c92baefdbcfbe", "0x02f86c0711843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a071d36bc93c7ae8cc5c01501e51e5e97a51aa541d1a89c809a2af7eb40e9bc2cba071644230e21c075c1da08916aff5efe9f95a6f6a4f94dc217f6c1bb4a3240b29" ], "withdrawals": [ { "index": "0xf2", "validatorIndex": "0xf2", "address": "0x00000000000000000000000000000000000010f2", "amount": "0x1" }, { "index": "0xf3", "validatorIndex": "0xf3", "address": "0x00000000000000000000000000000000000010f3", "amount": "0x1" } ] } ] } } ] }, { "name": "engine_getPayloadBodiesByHashV2", "summary": "Given block hashes returns bodies of the corresponding execution payloads", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/prague.md#engine_getpayloadbodiesbyhashv2" }, "params": [ { "name": "Array of block hashes", "required": true, "schema": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } ], "result": { "name": "Execution payload bodies", "schema": { "type": "array", "items": { "title": "Execution payload body object V2", "type": "object", "required": [ "transactions" ], "properties": { "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": [ "array", "null" ], "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "depositRequests": { "title": "Deposit requests", "type": [ "array", "null" ], "items": { "title": "Deposit request object V1", "type": "object", "required": [ "pubkey", "withdrawalCredentials", "amount", "signature", "index" ], "properties": { "pubkey": { "title": "Public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "withdrawalCredentials": { "title": "Withdrawal credentials", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "amount": { "title": "Deposit amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "signature": { "title": "Deposit signature", "type": "string", "pattern": "^0x[0-9a-f]{192}$" }, "index": { "title": "Deposit index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "withdrawalRequests": { "title": "Withdrawals requests", "type": [ "array", "null" ], "items": { "title": "Withdrawal request object V1", "type": "object", "required": [ "sourceAddress", "validatorPubkey", "amount" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "validatorPubkey": { "title": "Validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "amount": { "title": "Withdraw amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "consolidationRequests": { "title": "Consolidation requests - array - 'null'", "items": { "title": "Consolidation request object V1", "type": "object", "required": [ "sourceAddress", "sourcePubkey", "targetPubkey" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "sourcePubkey": { "title": "Source validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "targetPubkey": { "title": "Target validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } } } } } } } }, "errors": [ { "code": -38004, "message": "Too large request" } ], "examples": [ { "name": "engine_getPayloadBodiesByHashV2 example", "params": [ { "name": "Array of block hashes", "value": [ "0xd5f1812548be429cbdc6376b29611fc49e06f1359758c4ceaaa3b393e2239f9c", "0xfe88c94d860f01a17f961bf4bdfb6e0c6cd10d3fda5cc861e805ca1240c58553" ] } ], "result": { "name": "Execution payload bodies", "value": [ { "transactions": [ "0xf865808506fc23ac00830124f8940101010101010101010101010101010101010101018031a02c4d88bfdc2f6dbf82c33d235c4e785e9fc23b2d0fc7b9d20fc5e9674f1f9d15a016d6d69b925cf26128683ab4a096e196fbb1142d6c6d4e8d3481b9bef1bd0f65", "0x02f86c0701843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a039409b4e5603dd8c3cf38232348661a8e99ac518396eeaa128ec9ec2a3eb8127a06b21ab956f5f138cb44fda1a9055bd08980ea4f8040d877c00dac025608d0d95" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ], "depositRequests": [ { "pubkey": "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9", "withdrawalCredentials": "0x003f5102dabe0a27b1746098d1dc17a5d3fbd478759fea9287e4e419b3c3cef2", "amount": "0x1", "signature": "0xb1acdb2c4d3df3f1b8d3bfd33421660df358d84d78d16c4603551935f4b67643373e7eb63dcb16ec359be0ec41fee33b03a16e80745f2374ff1d3c352508ac5d857c6476d3c3bcf7e6ca37427c9209f17be3af5264c0e2132b3dd1156c28b4e9", "index": "0xf0" } ], "withdrawalRequests": [ { "sourceAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "validatorPubkey": "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0", "amount": "0x0" } ], "consolidationRequests": [ { "sourceAddress": "0x00000000000000000000000000000000000010f6", "sourcePubkey": "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9", "targetPubkey": "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b" } ] }, { "transactions": [ "0xf865108506fc23ac00830124f8940101010101010101010101010101010101010101018031a0d9712a3c40ae85aea4ad1bd95a0b7cc7bd805189a9e2517403b11a00a1530f81a053b53b0267a6dcfe9f9a1652307b396b3e8a65e65707a450e60c92baefdbcfbe", "0x02f86c0711843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a071d36bc93c7ae8cc5c01501e51e5e97a51aa541d1a89c809a2af7eb40e9bc2cba071644230e21c075c1da08916aff5efe9f95a6f6a4f94dc217f6c1bb4a3240b29" ], "withdrawals": [ { "index": "0xf2", "validatorIndex": "0xf2", "address": "0x00000000000000000000000000000000000010f2", "amount": "0x1" }, { "index": "0xf3", "validatorIndex": "0xf3", "address": "0x00000000000000000000000000000000000010f3", "amount": "0x1" } ], "depositRequests": [ { "pubkey": "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b", "withdrawalCredentials": "0x001db70c485b6264692f26b8aeaab5b0c384180df8e2184a21a808a3ec8e86ca", "amount": "0x1", "signature": "0x9561731785b48cf1886412234531e4940064584463e96ac63a1a154320227e333fb51addc4a89b7e0d3f862d7c1fd4ea03bd8eb3d8806f1e7daf591cbbbb92b0beb74d13c01617f22c5026b4f9f9f294a8a7c32db895de3b01bee0132c9209e1", "index": "0xf1" } ], "withdrawalRequests": [ { "sourceAddress": "0x00000000000000000000000000000000000010f6", "validatorPubkey": "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553", "amount": "0x1" } ], "consolidationRequests": [ { "sourceAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "sourcePubkey": "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0", "targetPubkey": "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553" } ] } ] } } ] }, { "name": "engine_getPayloadBodiesByRangeV1", "summary": "Given a range of block numbers returns bodies of the corresponding execution payloads", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_getpayloadbodiesbyrangev1" }, "params": [ { "name": "Starting block number", "required": true, "schema": { "title": "hex encoded 64 bit unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } }, { "name": "Number of blocks to return", "required": true, "schema": { "title": "hex encoded 64 bit unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } ], "result": { "name": "Execution payload bodies", "schema": { "type": "array", "items": { "title": "Execution payload body object V1", "type": "object", "required": [ "transactions" ], "properties": { "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": [ "array", "null" ], "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } } } } }, "errors": [ { "code": -38004, "message": "Too large request" } ], "examples": [ { "name": "engine_getPayloadBodiesByRangeV1 example", "params": [ { "name": "Starting block number", "value": "0x20" }, { "name": "Number of blocks to return", "value": "0x2" } ], "result": { "name": "Execution payload bodies", "value": [ { "transactions": [ "0xf865808506fc23ac00830124f8940101010101010101010101010101010101010101018031a02c4d88bfdc2f6dbf82c33d235c4e785e9fc23b2d0fc7b9d20fc5e9674f1f9d15a016d6d69b925cf26128683ab4a096e196fbb1142d6c6d4e8d3481b9bef1bd0f65", "0x02f86c0701843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a039409b4e5603dd8c3cf38232348661a8e99ac518396eeaa128ec9ec2a3eb8127a06b21ab956f5f138cb44fda1a9055bd08980ea4f8040d877c00dac025608d0d95" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ] }, { "transactions": [ "0xf865108506fc23ac00830124f8940101010101010101010101010101010101010101018031a0d9712a3c40ae85aea4ad1bd95a0b7cc7bd805189a9e2517403b11a00a1530f81a053b53b0267a6dcfe9f9a1652307b396b3e8a65e65707a450e60c92baefdbcfbe", "0x02f86c0711843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a071d36bc93c7ae8cc5c01501e51e5e97a51aa541d1a89c809a2af7eb40e9bc2cba071644230e21c075c1da08916aff5efe9f95a6f6a4f94dc217f6c1bb4a3240b29" ], "withdrawals": [ { "index": "0xf2", "validatorIndex": "0xf2", "address": "0x00000000000000000000000000000000000010f2", "amount": "0x1" }, { "index": "0xf3", "validatorIndex": "0xf3", "address": "0x00000000000000000000000000000000000010f3", "amount": "0x1" } ] } ] } } ] }, { "name": "engine_getPayloadBodiesByRangeV2", "summary": "Given a range of block numbers returns bodies of the corresponding execution payloads", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/prague.md#engine_getpayloadbodiesbyrangev2" }, "params": [ { "name": "Starting block number", "required": true, "schema": { "title": "hex encoded 64 bit unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } }, { "name": "Number of blocks to return", "required": true, "schema": { "title": "hex encoded 64 bit unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } ], "result": { "name": "Execution payload bodies", "schema": { "type": "array", "items": { "title": "Execution payload body object V2", "type": "object", "required": [ "transactions" ], "properties": { "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": [ "array", "null" ], "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "depositRequests": { "title": "Deposit requests", "type": [ "array", "null" ], "items": { "title": "Deposit request object V1", "type": "object", "required": [ "pubkey", "withdrawalCredentials", "amount", "signature", "index" ], "properties": { "pubkey": { "title": "Public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "withdrawalCredentials": { "title": "Withdrawal credentials", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "amount": { "title": "Deposit amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "signature": { "title": "Deposit signature", "type": "string", "pattern": "^0x[0-9a-f]{192}$" }, "index": { "title": "Deposit index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "withdrawalRequests": { "title": "Withdrawals requests", "type": [ "array", "null" ], "items": { "title": "Withdrawal request object V1", "type": "object", "required": [ "sourceAddress", "validatorPubkey", "amount" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "validatorPubkey": { "title": "Validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "amount": { "title": "Withdraw amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "consolidationRequests": { "title": "Consolidation requests - array - 'null'", "items": { "title": "Consolidation request object V1", "type": "object", "required": [ "sourceAddress", "sourcePubkey", "targetPubkey" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "sourcePubkey": { "title": "Source validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "targetPubkey": { "title": "Target validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } } } } } } } }, "errors": [ { "code": -38004, "message": "Too large request" } ], "examples": [ { "name": "engine_getPayloadBodiesByRangeV2 example", "params": [ { "name": "Starting block number", "value": "0x20" }, { "name": "Number of blocks to return", "value": "0x2" } ], "result": { "name": "Execution payload bodies", "value": [ { "transactions": [ "0xf865808506fc23ac00830124f8940101010101010101010101010101010101010101018031a02c4d88bfdc2f6dbf82c33d235c4e785e9fc23b2d0fc7b9d20fc5e9674f1f9d15a016d6d69b925cf26128683ab4a096e196fbb1142d6c6d4e8d3481b9bef1bd0f65", "0x02f86c0701843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a039409b4e5603dd8c3cf38232348661a8e99ac518396eeaa128ec9ec2a3eb8127a06b21ab956f5f138cb44fda1a9055bd08980ea4f8040d877c00dac025608d0d95" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ], "depositRequests": [ { "pubkey": "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9", "withdrawalCredentials": "0x003f5102dabe0a27b1746098d1dc17a5d3fbd478759fea9287e4e419b3c3cef2", "amount": "0x1", "signature": "0xb1acdb2c4d3df3f1b8d3bfd33421660df358d84d78d16c4603551935f4b67643373e7eb63dcb16ec359be0ec41fee33b03a16e80745f2374ff1d3c352508ac5d857c6476d3c3bcf7e6ca37427c9209f17be3af5264c0e2132b3dd1156c28b4e9", "index": "0xf0" } ], "withdrawalRequests": [ { "sourceAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "validatorPubkey": "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0", "amount": "0x0" } ], "consolidationRequests": [ { "sourceAddress": "0x00000000000000000000000000000000000010f6", "sourcePubkey": "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9", "targetPubkey": "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b" } ] }, { "transactions": [ "0xf865108506fc23ac00830124f8940101010101010101010101010101010101010101018031a0d9712a3c40ae85aea4ad1bd95a0b7cc7bd805189a9e2517403b11a00a1530f81a053b53b0267a6dcfe9f9a1652307b396b3e8a65e65707a450e60c92baefdbcfbe", "0x02f86c0711843b9aca008506fc23ac00830124f89402020202020202020202020202020202020202020180c080a071d36bc93c7ae8cc5c01501e51e5e97a51aa541d1a89c809a2af7eb40e9bc2cba071644230e21c075c1da08916aff5efe9f95a6f6a4f94dc217f6c1bb4a3240b29" ], "withdrawals": [ { "index": "0xf2", "validatorIndex": "0xf2", "address": "0x00000000000000000000000000000000000010f2", "amount": "0x1" }, { "index": "0xf3", "validatorIndex": "0xf3", "address": "0x00000000000000000000000000000000000010f3", "amount": "0x1" } ], "depositRequests": [ { "pubkey": "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b", "withdrawalCredentials": "0x001db70c485b6264692f26b8aeaab5b0c384180df8e2184a21a808a3ec8e86ca", "amount": "0x1", "signature": "0x9561731785b48cf1886412234531e4940064584463e96ac63a1a154320227e333fb51addc4a89b7e0d3f862d7c1fd4ea03bd8eb3d8806f1e7daf591cbbbb92b0beb74d13c01617f22c5026b4f9f9f294a8a7c32db895de3b01bee0132c9209e1", "index": "0xf1" } ], "withdrawalRequests": [ { "sourceAddress": "0x00000000000000000000000000000000000010f6", "validatorPubkey": "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553", "amount": "0x1" } ], "consolidationRequests": [ { "sourceAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "sourcePubkey": "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0", "targetPubkey": "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553" } ] } ] } } ] }, { "name": "engine_getPayloadV1", "summary": "Obtains execution payload from payload build process", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#engine_getpayloadv1" }, "params": [ { "name": "Payload id", "required": true, "schema": { "title": "8 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{16}$" } } ], "result": { "name": "Execution payload", "schema": { "title": "Execution payload object V1", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } } }, "errors": [ { "code": -38001, "message": "Unknown payload" } ], "examples": [ { "name": "engine_getPayloadV1 example", "params": [ { "name": "Payload id", "value": "0x0000000021f32cc1" } ], "result": { "name": "Execution payload", "value": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1", "gasLimit": "0x1c9c380", "gasUsed": "0x0", "timestamp": "0x5", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions": [] } } } ] }, { "name": "engine_getPayloadV2", "summary": "Obtains execution payload from payload build process", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_getpayloadv2" }, "params": [ { "name": "Payload id", "required": true, "schema": { "title": "8 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{16}$" } } ], "result": { "name": "Response object", "schema": { "type": "object", "required": [ "executionPayload", "blockValue" ], "properties": { "executionPayload": { "title": "Execution payload", "oneOf": [ { "title": "Execution payload object V1", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } }, { "title": "Execution payload object V2", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions", "withdrawals" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } } } ] }, "blockValue": { "title": "Expected fee value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" } } } }, "errors": [ { "code": -38001, "message": "Unknown payload" } ], "examples": [ { "name": "engine_getPayloadV2 example", "params": [ { "name": "Payload id", "value": "0x0000000038fa5dd" } ], "result": { "name": "Response object", "value": { "executionPayload": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "blockNumber": "0x112720f", "gasLimit": "0x1c9c380", "gasUsed": "0xbad2e8", "timestamp": "0x64e7785b", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x1256f99fb899c2de0aeac0c5aa6aad69de188b6a0f4ac29f2d075a53aa3ed0e4", "transactions": [ "0x03f88f0780843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a0010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c44401401a0840650aa8f74d2b07f40067dc33b715078d73422f01da17abdbd11e02bbdfda9a04b2260f6022bf53eadb337b3e59514936f7317d872defb891a708ee279bdca90", "0x03f88f0701843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001521d528ad0c760354a4f0496776cf14a92fe1fb5d50e959dcea1a489c7c83101a0a86c1fd8c2e74820686937f5c1bfe836e2fb622ac9fcbebdc4ab4357f2dbbc61a05c3b2b44ff8252f78d70aeb33f8ba09beaeadad1b376a57d34fa720bbc4a18ee", "0x03f88f0702843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001453362c360fdd8832e3539d463e6d64b2ee320ac6a08885df6083644a063e701a037a728aec08aefffa702a2ca620db89caf3e46ab7f25f7646fc951510991badca065d846f046357af39bb739b161233fce73ddfe0bb87f2d28ef60dfe6dbb0128d" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ] }, "blockValue": "0x10a741a46278014d" } } } ] }, { "name": "engine_getPayloadV3", "summary": "Obtains execution payload from payload build process", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#engine_getpayloadv3" }, "params": [ { "name": "Payload id", "required": true, "schema": { "title": "8 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{16}$" } } ], "result": { "name": "Response object", "schema": { "type": "object", "required": [ "executionPayload", "blockValue", "blobsBundle", "shouldOverrideBuilder" ], "properties": { "executionPayload": { "title": "Execution payload", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions", "withdrawals", "blobGasUsed", "excessBlobGas" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "blobGasUsed": { "title": "Blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "excessBlobGas": { "title": "Excess blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, "blockValue": { "title": "Expected fee value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blobsBundle": { "title": "Blobs bundle", "type": "object", "required": [ "commitments", "proofs", "blobs" ], "properties": { "commitments": { "title": "Commitments", "type": "array", "items": { "title": "48 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } }, "proofs": { "title": "Proofs", "type": "array", "items": { "title": "48 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } }, "blobs": { "title": "Blobs", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } }, "shouldOverrideBuilder": { "title": "Should override builder flag", "type": "boolean" } } } }, "errors": [ { "code": -38001, "message": "Unknown payload" }, { "code": -38005, "message": "Unsupported fork" } ], "examples": [ { "name": "engine_getPayloadV3 example", "params": [ { "name": "Payload id", "value": "0x0000000038fa5dd" } ], "result": { "name": "Response object", "value": { "executionPayload": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "blockNumber": "0x112720f", "gasLimit": "0x1c9c380", "gasUsed": "0xbad2e8", "timestamp": "0x64e7785b", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x1256f99fb899c2de0aeac0c5aa6aad69de188b6a0f4ac29f2d075a53aa3ed0e4", "transactions": [ "0x03f88f0780843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a0010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c44401401a0840650aa8f74d2b07f40067dc33b715078d73422f01da17abdbd11e02bbdfda9a04b2260f6022bf53eadb337b3e59514936f7317d872defb891a708ee279bdca90", "0x03f88f0701843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001521d528ad0c760354a4f0496776cf14a92fe1fb5d50e959dcea1a489c7c83101a0a86c1fd8c2e74820686937f5c1bfe836e2fb622ac9fcbebdc4ab4357f2dbbc61a05c3b2b44ff8252f78d70aeb33f8ba09beaeadad1b376a57d34fa720bbc4a18ee", "0x03f88f0702843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001453362c360fdd8832e3539d463e6d64b2ee320ac6a08885df6083644a063e701a037a728aec08aefffa702a2ca620db89caf3e46ab7f25f7646fc951510991badca065d846f046357af39bb739b161233fce73ddfe0bb87f2d28ef60dfe6dbb0128d" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ], "blobGasUsed": "0x60000", "excessBlobGas": "0x0" }, "blockValue": "0x10a741a46278014d", "blobsBundle": { "commitments": [ "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0" ], "proofs": [ "0x80c5f2e1eb23939cf3600f61872e3e9964d0acafb440634e530d6139a193b889c56a0c07d737729dbe0626706fc9f25f" ], "blobs": [ "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" ] }, "shouldOverrideBuilder": false } } } ] }, { "name": "engine_getPayloadV4", "summary": "Obtains execution payload from payload build process", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/prague.md#engine_getpayloadv4" }, "params": [ { "name": "Payload id", "required": true, "schema": { "title": "8 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{16}$" } } ], "result": { "name": "Response object", "schema": { "type": "object", "required": [ "executionPayload", "blockValue", "blobsBundle", "shouldOverrideBuilder" ], "properties": { "executionPayload": { "title": "Execution payload", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions", "withdrawals", "blobGasUsed", "excessBlobGas", "depositRequests", "withdrawalRequests", "consolidationRequests" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "blobGasUsed": { "title": "Blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "excessBlobGas": { "title": "Excess blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "depositRequests": { "title": "Deposit requests", "type": "array", "items": { "title": "Deposit request object V1", "type": "object", "required": [ "pubkey", "withdrawalCredentials", "amount", "signature", "index" ], "properties": { "pubkey": { "title": "Public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "withdrawalCredentials": { "title": "Withdrawal credentials", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "amount": { "title": "Deposit amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "signature": { "title": "Deposit signature", "type": "string", "pattern": "^0x[0-9a-f]{192}$" }, "index": { "title": "Deposit index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "withdrawalRequests": { "title": "Withdrawals requests", "type": "array", "items": { "title": "Withdrawal request object V1", "type": "object", "required": [ "sourceAddress", "validatorPubkey", "amount" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "validatorPubkey": { "title": "Validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "amount": { "title": "Withdraw amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "consolidationRequests": { "title": "Consolidation requests", "type": "array", "items": { "title": "Consolidation request object V1", "type": "object", "required": [ "sourceAddress", "sourcePubkey", "targetPubkey" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "sourcePubkey": { "title": "Source validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "targetPubkey": { "title": "Target validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } } } } } }, "blockValue": { "title": "Expected fee value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blobsBundle": { "title": "Blobs bundle", "type": "object", "required": [ "commitments", "proofs", "blobs" ], "properties": { "commitments": { "title": "Commitments", "type": "array", "items": { "title": "48 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } }, "proofs": { "title": "Proofs", "type": "array", "items": { "title": "48 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } }, "blobs": { "title": "Blobs", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } }, "shouldOverrideBuilder": { "title": "Should override builder flag", "type": "boolean" } } } }, "errors": [ { "code": -38001, "message": "Unknown payload" }, { "code": -38005, "message": "Unsupported fork" } ], "examples": [ { "name": "engine_getPayloadV4 example", "params": [ { "name": "Payload id", "value": "0x0000000038fa5dd" } ], "result": { "name": "Response object", "value": { "executionPayload": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "blockNumber": "0x112720f", "gasLimit": "0x1c9c380", "gasUsed": "0xbad2e8", "timestamp": "0x64e7785b", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x1256f99fb899c2de0aeac0c5aa6aad69de188b6a0f4ac29f2d075a53aa3ed0e4", "transactions": [ "0x03f88f0780843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a0010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c44401401a0840650aa8f74d2b07f40067dc33b715078d73422f01da17abdbd11e02bbdfda9a04b2260f6022bf53eadb337b3e59514936f7317d872defb891a708ee279bdca90", "0x03f88f0701843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001521d528ad0c760354a4f0496776cf14a92fe1fb5d50e959dcea1a489c7c83101a0a86c1fd8c2e74820686937f5c1bfe836e2fb622ac9fcbebdc4ab4357f2dbbc61a05c3b2b44ff8252f78d70aeb33f8ba09beaeadad1b376a57d34fa720bbc4a18ee", "0x03f88f0702843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001453362c360fdd8832e3539d463e6d64b2ee320ac6a08885df6083644a063e701a037a728aec08aefffa702a2ca620db89caf3e46ab7f25f7646fc951510991badca065d846f046357af39bb739b161233fce73ddfe0bb87f2d28ef60dfe6dbb0128d" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ], "blobGasUsed": "0x60000", "excessBlobGas": "0x0", "depositRequests": [ { "pubkey": "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9", "withdrawalCredentials": "0x003f5102dabe0a27b1746098d1dc17a5d3fbd478759fea9287e4e419b3c3cef2", "amount": "0x1", "signature": "0xb1acdb2c4d3df3f1b8d3bfd33421660df358d84d78d16c4603551935f4b67643373e7eb63dcb16ec359be0ec41fee33b03a16e80745f2374ff1d3c352508ac5d857c6476d3c3bcf7e6ca37427c9209f17be3af5264c0e2132b3dd1156c28b4e9", "index": "0xf0" }, { "pubkey": "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b", "withdrawalCredentials": "0x001db70c485b6264692f26b8aeaab5b0c384180df8e2184a21a808a3ec8e86ca", "amount": "0x1", "signature": "0x9561731785b48cf1886412234531e4940064584463e96ac63a1a154320227e333fb51addc4a89b7e0d3f862d7c1fd4ea03bd8eb3d8806f1e7daf591cbbbb92b0beb74d13c01617f22c5026b4f9f9f294a8a7c32db895de3b01bee0132c9209e1", "index": "0xf1" } ], "withdrawalRequests": [ { "sourceAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "validatorPubkey": "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0", "amount": "0x0" }, { "sourceAddress": "0x00000000000000000000000000000000000010f6", "validatorPubkey": "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553", "amount": "0x1" } ] }, "blockValue": "0x10a741a46278014d", "blobsBundle": { "commitments": [ "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0" ], "proofs": [ "0x80c5f2e1eb23939cf3600f61872e3e9964d0acafb440634e530d6139a193b889c56a0c07d737729dbe0626706fc9f25f" ], "blobs": [ "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" ] }, "shouldOverrideBuilder": false } } } ] }, { "name": "engine_newPayloadV1", "summary": "Runs execution payload validation", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#engine_newpayloadv1" }, "params": [ { "name": "Execution payload", "required": true, "schema": { "title": "Execution payload object V1", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } } } ], "result": { "name": "Payload status", "schema": { "title": "Payload status object V1", "type": "object", "required": [ "status" ], "properties": { "status": { "title": "Payload validation status", "type": "string", "enum": [ "VALID", "INVALID", "SYNCING", "ACCEPTED", "INVALID_BLOCK_HASH" ] }, "latestValidHash": { "title": "The hash of the most recent valid block", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "validationError": { "title": "Validation error message", "type": "string" } } } }, "examples": [ { "name": "engine_newPayloadV1 example", "params": [ { "name": "Execution payload", "value": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1", "gasLimit": "0x1c9c380", "gasUsed": "0x0", "timestamp": "0x5", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions": [] } } ], "result": { "name": "Payload status", "value": { "status": "VALID", "latestValidHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "validationError": null } } }, { "name": "engine_newPayloadV1 invalid example", "params": [ { "name": "Execution payload", "value": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1", "gasLimit": "0x1c9c380", "gasUsed": "0x0", "timestamp": "0x5", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions": [] } } ], "result": { "name": "Payload status", "value": { "status": "INVALID", "latestValidHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "validationError": "New payload is invalid" } } } ] }, { "name": "engine_newPayloadV2", "summary": "Runs execution payload validation", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#engine_newpayloadv2" }, "params": [ { "name": "Execution payload", "required": true, "schema": { "oneOf": [ { "title": "Execution payload object V1", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } }, { "title": "Execution payload object V2", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions", "withdrawals" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } } } ] } } ], "result": { "name": "Payload status", "schema": { "title": "Payload status object deprecating INVALID_BLOCK_HASH status", "type": "object", "required": [ "status" ], "properties": { "status": { "title": "Payload validation status", "type": "string", "enum": [ "VALID", "INVALID", "SYNCING", "ACCEPTED" ] }, "latestValidHash": { "title": "The hash of the most recent valid block", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "validationError": { "title": "Validation error message", "type": "string" } } } }, "errors": [ { "code": -32602, "message": "Invalid params" } ], "examples": [ { "name": "engine_newPayloadV2 example", "params": [ { "name": "Execution payload", "value": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "blockNumber": "0x112720f", "gasLimit": "0x1c9c380", "gasUsed": "0xbad2e8", "timestamp": "0x64e7785b", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions": [ "0x03f88f0780843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a0010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c44401401a0840650aa8f74d2b07f40067dc33b715078d73422f01da17abdbd11e02bbdfda9a04b2260f6022bf53eadb337b3e59514936f7317d872defb891a708ee279bdca90", "0x03f88f0701843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001521d528ad0c760354a4f0496776cf14a92fe1fb5d50e959dcea1a489c7c83101a0a86c1fd8c2e74820686937f5c1bfe836e2fb622ac9fcbebdc4ab4357f2dbbc61a05c3b2b44ff8252f78d70aeb33f8ba09beaeadad1b376a57d34fa720bbc4a18ee", "0x03f88f0702843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001453362c360fdd8832e3539d463e6d64b2ee320ac6a08885df6083644a063e701a037a728aec08aefffa702a2ca620db89caf3e46ab7f25f7646fc951510991badca065d846f046357af39bb739b161233fce73ddfe0bb87f2d28ef60dfe6dbb0128d" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ] } } ], "result": { "name": "Payload status", "value": { "status": "VALID", "latestValidHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "validationError": null } } } ] }, { "name": "engine_newPayloadV3", "summary": "Runs execution payload validation", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#engine_newpayloadv3" }, "params": [ { "name": "Execution payload", "required": true, "schema": { "title": "Execution payload object V3", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions", "withdrawals", "blobGasUsed", "excessBlobGas" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "blobGasUsed": { "title": "Blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "excessBlobGas": { "title": "Excess blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, { "name": "Expected blob versioned hashes", "required": true, "schema": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } }, { "name": "Root of the parent beacon block", "required": true, "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ], "result": { "name": "Payload status", "schema": { "title": "Payload status object deprecating INVALID_BLOCK_HASH status", "type": "object", "required": [ "status" ], "properties": { "status": { "title": "Payload validation status", "type": "string", "enum": [ "VALID", "INVALID", "SYNCING", "ACCEPTED" ] }, "latestValidHash": { "title": "The hash of the most recent valid block", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "validationError": { "title": "Validation error message", "type": "string" } } } }, "errors": [ { "code": -32602, "message": "Invalid params" }, { "code": -38005, "message": "Unsupported fork" } ], "examples": [ { "name": "engine_newPayloadV3 example", "params": [ { "name": "Execution payload", "value": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "blockNumber": "0x112720f", "gasLimit": "0x1c9c380", "gasUsed": "0xbad2e8", "timestamp": "0x64e7785b", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions": [ "0x03f88f0780843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a0010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c44401401a0840650aa8f74d2b07f40067dc33b715078d73422f01da17abdbd11e02bbdfda9a04b2260f6022bf53eadb337b3e59514936f7317d872defb891a708ee279bdca90", "0x03f88f0701843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001521d528ad0c760354a4f0496776cf14a92fe1fb5d50e959dcea1a489c7c83101a0a86c1fd8c2e74820686937f5c1bfe836e2fb622ac9fcbebdc4ab4357f2dbbc61a05c3b2b44ff8252f78d70aeb33f8ba09beaeadad1b376a57d34fa720bbc4a18ee", "0x03f88f0702843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001453362c360fdd8832e3539d463e6d64b2ee320ac6a08885df6083644a063e701a037a728aec08aefffa702a2ca620db89caf3e46ab7f25f7646fc951510991badca065d846f046357af39bb739b161233fce73ddfe0bb87f2d28ef60dfe6dbb0128d" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ], "blobGasUsed": "0x0", "excessBlobGas": "0x0" } }, { "name": "Expected blob versioned hashes", "value": [ "0x000657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c444014" ] }, { "name": "Root of the parent beacon block", "value": "0x169630f535b4a41330164c6e5c92b1224c0c407f582d407d0ac3d206cd32fd52" } ], "result": { "name": "Payload status", "value": { "status": "VALID", "latestValidHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "validationError": null } } } ] }, { "name": "engine_newPayloadV4", "summary": "Runs execution payload validation", "externalDocs": { "description": "Method specification", "url": "https://github.com/ethereum/execution-apis/blob/main/src/engine/prague.md#engine_newpayloadv4" }, "params": [ { "name": "Execution payload", "required": true, "schema": { "title": "Execution payload object V4", "type": "object", "required": [ "parentHash", "feeRecipient", "stateRoot", "receiptsRoot", "logsBloom", "prevRandao", "blockNumber", "gasLimit", "gasUsed", "timestamp", "extraData", "baseFeePerGas", "blockHash", "transactions", "withdrawals", "blobGasUsed", "excessBlobGas", "depositRequests", "withdrawalRequests", "consolidationRequests" ], "properties": { "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "feeRecipient": { "title": "Recipient of transaction priority fees", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "prevRandao": { "title": "Previous randao value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "blockHash": { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactions": { "title": "Transactions", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "title": "Withdrawal object V1", "type": "object", "required": [ "index", "validatorIndex", "address", "amount" ], "properties": { "index": { "title": "Withdrawal index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "Validator index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Withdrawal address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "Withdrawal amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "blobGasUsed": { "title": "Blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "excessBlobGas": { "title": "Excess blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "depositRequests": { "title": "Deposit requests", "type": "array", "items": { "title": "Deposit request object V1", "type": "object", "required": [ "pubkey", "withdrawalCredentials", "amount", "signature", "index" ], "properties": { "pubkey": { "title": "Public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "withdrawalCredentials": { "title": "Withdrawal credentials", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "amount": { "title": "Deposit amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "signature": { "title": "Deposit signature", "type": "string", "pattern": "^0x[0-9a-f]{192}$" }, "index": { "title": "Deposit index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "withdrawalRequests": { "title": "Withdrawals requests", "type": "array", "items": { "title": "Withdrawal request object V1", "type": "object", "required": [ "sourceAddress", "validatorPubkey", "amount" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "validatorPubkey": { "title": "Validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "amount": { "title": "Withdraw amount", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } }, "consolidationRequests": { "title": "Consolidation requests", "type": "array", "items": { "title": "Consolidation request object V1", "type": "object", "required": [ "sourceAddress", "sourcePubkey", "targetPubkey" ], "properties": { "sourceAddress": { "title": "Source address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "sourcePubkey": { "title": "Source validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" }, "targetPubkey": { "title": "Target validator public key", "type": "string", "pattern": "^0x[0-9a-f]{96}$" } } } } } } }, { "name": "Expected blob versioned hashes", "required": true, "schema": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } }, { "name": "Root of the parent beacon block", "required": true, "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ], "result": { "name": "Payload status", "schema": { "title": "Payload status object deprecating INVALID_BLOCK_HASH status", "type": "object", "required": [ "status" ], "properties": { "status": { "title": "Payload validation status", "type": "string", "enum": [ "VALID", "INVALID", "SYNCING", "ACCEPTED" ] }, "latestValidHash": { "title": "The hash of the most recent valid block", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "validationError": { "title": "Validation error message", "type": "string" } } } }, "errors": [ { "code": -32602, "message": "Invalid params" }, { "code": -38005, "message": "Unsupported fork" } ], "examples": [ { "name": "engine_newPayloadV4 example", "params": [ { "name": "Execution payload", "value": { "parentHash": "0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a", "feeRecipient": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "stateRoot": "0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0xc130d5e63c61c935f6089e61140ca9136172677cf6aa5800dcc1cf0a02152a14", "blockNumber": "0x112720f", "gasLimit": "0x1c9c380", "gasUsed": "0xbad2e8", "timestamp": "0x64e7785b", "extraData": "0x", "baseFeePerGas": "0x7", "blockHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "transactions": [ "0x03f88f0780843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a0010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c44401401a0840650aa8f74d2b07f40067dc33b715078d73422f01da17abdbd11e02bbdfda9a04b2260f6022bf53eadb337b3e59514936f7317d872defb891a708ee279bdca90", "0x03f88f0701843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001521d528ad0c760354a4f0496776cf14a92fe1fb5d50e959dcea1a489c7c83101a0a86c1fd8c2e74820686937f5c1bfe836e2fb622ac9fcbebdc4ab4357f2dbbc61a05c3b2b44ff8252f78d70aeb33f8ba09beaeadad1b376a57d34fa720bbc4a18ee", "0x03f88f0702843b9aca008506fc23ac00830186a09400000000000000000000000000000000000001008080c001e1a001453362c360fdd8832e3539d463e6d64b2ee320ac6a08885df6083644a063e701a037a728aec08aefffa702a2ca620db89caf3e46ab7f25f7646fc951510991badca065d846f046357af39bb739b161233fce73ddfe0bb87f2d28ef60dfe6dbb0128d" ], "withdrawals": [ { "index": "0xf0", "validatorIndex": "0xf0", "address": "0x00000000000000000000000000000000000010f0", "amount": "0x1" }, { "index": "0xf1", "validatorIndex": "0xf1", "address": "0x00000000000000000000000000000000000010f1", "amount": "0x1" } ], "blobGasUsed": "0x0", "excessBlobGas": "0x0", "depositRequests": [ { "pubkey": "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9", "withdrawalCredentials": "0x003f5102dabe0a27b1746098d1dc17a5d3fbd478759fea9287e4e419b3c3cef2", "amount": "0x1", "signature": "0xb1acdb2c4d3df3f1b8d3bfd33421660df358d84d78d16c4603551935f4b67643373e7eb63dcb16ec359be0ec41fee33b03a16e80745f2374ff1d3c352508ac5d857c6476d3c3bcf7e6ca37427c9209f17be3af5264c0e2132b3dd1156c28b4e9", "index": "0xf0" }, { "pubkey": "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b", "withdrawalCredentials": "0x001db70c485b6264692f26b8aeaab5b0c384180df8e2184a21a808a3ec8e86ca", "amount": "0x1", "signature": "0x9561731785b48cf1886412234531e4940064584463e96ac63a1a154320227e333fb51addc4a89b7e0d3f862d7c1fd4ea03bd8eb3d8806f1e7daf591cbbbb92b0beb74d13c01617f22c5026b4f9f9f294a8a7c32db895de3b01bee0132c9209e1", "index": "0xf1" } ], "withdrawalRequests": [ { "sourceAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "validatorPubkey": "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0", "amount": "0x0" }, { "sourceAddress": "0x00000000000000000000000000000000000010f6", "validatorPubkey": "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553", "amount": "0x1" } ], "consolidationRequests": [ { "sourceAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "sourcePubkey": "0x85103a5617937691dfeeb89b86a80d5dc9e3c9d3a1a0e7ce311e26e0bb732eabaa47ffa288f0d54de28209a62a7d29d0", "targetPubkey": "0x98daeed734da114470da559bd4b4c7259e1f7952555241dcbc90cf194a2ef676fc6005f3672fada2a3645edb297a7553" }, { "sourceAddress": "0x00000000000000000000000000000000000010f6", "sourcePubkey": "0x96a96086cff07df17668f35f7418ef8798079167e3f4f9b72ecde17b28226137cf454ab1dd20ef5d924786ab3483c2f9", "targetPubkey": "0xa5c85a60ba2905c215f6a12872e62b1ee037051364244043a5f639aa81b04a204c55e7cc851f29c7c183be253ea1510b" } ] } }, { "name": "Expected blob versioned hashes", "value": [ "0x000657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c444014" ] }, { "name": "Root of the parent beacon block", "value": "0x169630f535b4a41330164c6e5c92b1224c0c407f582d407d0ac3d206cd32fd52" } ], "result": { "name": "Payload status", "value": { "status": "VALID", "latestValidHash": "0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858", "validationError": null } } } ] }, { "name": "eth_accounts", "summary": "Returns a list of addresses owned by client.", "params": [], "result": { "name": "Accounts", "schema": { "title": "Accounts", "type": "array", "items": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } } } }, { "name": "eth_blobBaseFee", "summary": "Returns the base fee per blob gas in wei.", "params": [], "result": { "name": "Blob gas base fee", "schema": { "title": "Blob gas base fee", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_blockNumber", "summary": "Returns the number of most recent block.", "params": [], "result": { "name": "Block number", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_call", "summary": "Executes a new message call immediately without creating a transaction on the block chain.", "params": [ { "name": "Transaction", "required": true, "schema": { "type": "object", "title": "Transaction object generic to all types", "additionalProperties": false, "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "blobs": { "title": "blobs", "description": "Raw blob data.", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." } } } }, { "name": "Block", "required": false, "schema": { "title": "Block number, tag, or block hash", "anyOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" }, { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } ] } } ], "result": { "name": "Return data", "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } }, { "name": "eth_chainId", "summary": "Returns the chain ID of the current network.", "params": [], "result": { "name": "Chain ID", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_coinbase", "summary": "Returns the client coinbase address.", "params": [], "result": { "name": "Coinbase address", "schema": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } } }, { "name": "eth_createAccessList", "summary": "Generates an access list for a transaction.", "params": [ { "name": "Transaction", "required": true, "schema": { "type": "object", "title": "Transaction object generic to all types", "additionalProperties": false, "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "blobs": { "title": "blobs", "description": "Raw blob data.", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." } } } }, { "name": "Block", "required": false, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } } ], "result": { "name": "Gas used", "schema": { "title": "Access list result", "type": "object", "additionalProperties": false, "properties": { "accessList": { "title": "accessList", "type": "array", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "error": { "title": "error", "type": "string" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } }, { "name": "eth_estimateGas", "summary": "Generates and returns an estimate of how much gas is necessary to allow the transaction to complete.", "params": [ { "name": "Transaction", "required": true, "schema": { "type": "object", "title": "Transaction object generic to all types", "additionalProperties": false, "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "blobs": { "title": "blobs", "description": "Raw blob data.", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." } } } }, { "name": "Block", "required": false, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } } ], "result": { "name": "Gas used", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_feeHistory", "summary": "Transaction fee history", "description": "Returns transaction base fee per gas and effective priority fee per gas for the requested/supported block range.", "params": [ { "name": "blockCount", "description": "Requested range of blocks. Clients will return less than the requested range if not all blocks are available.", "required": true, "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } }, { "name": "newestBlock", "description": "Highest block of the requested range.", "required": true, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } }, { "name": "rewardPercentiles", "description": "A monotonically increasing list of percentile values. For each block in the requested range, the transactions will be sorted in ascending order by effective tip per gas and the coresponding effective tip for the percentile will be determined, accounting for gas consumed.", "required": true, "schema": { "title": "rewardPercentiles", "type": "array", "items": { "title": "rewardPercentile", "description": "Floating point value between 0 and 100.", "type": "number" } } } ], "result": { "name": "feeHistoryResult", "description": "Fee history for the returned block range. This can be a subsection of the requested range if not all blocks are available.", "schema": { "title": "feeHistoryResults", "description": "Fee history results.", "type": "object", "required": [ "oldestBlock", "baseFeePerGas", "gasUsedRatio" ], "additionalProperties": false, "properties": { "oldestBlock": { "title": "oldestBlock", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Lowest number block of returned range." }, "baseFeePerGas": { "title": "baseFeePerGasArray", "description": "An array of block base fees per gas. This includes the next block after the newest of the returned range, because this value can be derived from the newest block. Zeroes are returned for pre-EIP-1559 blocks.", "type": "array", "items": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } }, "baseFeePerBlobGas": { "title": "baseFeePerBlobGasArray", "description": "An array of block base fees per blob gas. This includes the next block after the newest of the returned range, because this value can be derived from the newest block. Zeroes are returned for pre-EIP-4844 blocks.", "type": "array", "items": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } }, "gasUsedRatio": { "title": "gasUsedRatio", "description": "An array of block gas used ratios. These are calculated as the ratio of gasUsed and gasLimit.", "type": "array", "items": { "title": "normalized ratio", "type": "number", "minimum": 0, "maximum": 1 } }, "blobGasUsedRatio": { "title": "blobGasUsedRatio", "description": "An array of block blob gas used ratios. These are calculated as the ratio of blobGasUsed and the max blob gas per block.", "type": "array", "items": { "title": "normalized ratio", "type": "number", "minimum": 0, "maximum": 1 } }, "reward": { "title": "rewardArray", "description": "A two-dimensional array of effective priority fees per gas at the requested block percentiles.", "type": "array", "items": { "title": "rewardPercentile", "description": "An array of effective priority fee per gas data points from a single block. All zeroes are returned if the block is empty.", "type": "array", "items": { "title": "rewardPercentile", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "A given percentile sample of effective priority fees per gas from a single block in ascending order, weighted by gas used. Zeroes are returned if the block is empty." } } } } } } }, { "name": "eth_gasPrice", "summary": "Returns the current price per gas in wei.", "params": [], "result": { "name": "Gas price", "schema": { "title": "Gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_getBalance", "summary": "Returns the balance of the account of given address.", "params": [ { "name": "Address", "required": true, "schema": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } }, { "name": "Block", "required": true, "schema": { "title": "Block number, tag, or block hash", "anyOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" }, { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } ] } } ], "result": { "name": "Balance", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_getBlockByHash", "summary": "Returns information about a block by hash.", "params": [ { "name": "Block hash", "required": true, "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "name": "Hydrated transactions", "required": true, "schema": { "title": "hydrated", "type": "boolean" } } ], "result": { "name": "Block information", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "title": "Block object", "type": "object", "required": [ "hash", "parentHash", "sha3Uncles", "miner", "stateRoot", "transactionsRoot", "receiptsRoot", "logsBloom", "number", "gasLimit", "gasUsed", "timestamp", "extraData", "mixHash", "nonce", "size", "transactions", "uncles" ], "additionalProperties": false, "properties": { "hash": { "title": "Hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "sha3Uncles": { "title": "Ommers hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "miner": { "title": "Coinbase", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionsRoot": { "title": "Transactions root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "difficulty": { "title": "Difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "number": { "title": "Number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "mixHash": { "title": "Mix hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "nonce": { "title": "Nonce", "type": "string", "pattern": "^0x[0-9a-f]{16}$" }, "totalDifficulty": { "title": "Total difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "withdrawalsRoot": { "title": "Withdrawals root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blobGasUsed": { "title": "Blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "excessBlobGas": { "title": "Excess blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "parentBeaconBlockRoot": { "title": "Parent Beacon Block Root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "size": { "title": "Block size", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactions": { "anyOf": [ { "title": "Transaction hashes", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "title": "Full transactions", "type": "array", "items": { "type": "object", "title": "Transaction information", "required": [ "blockHash", "blockNumber", "from", "hash", "transactionIndex" ], "unevaluatedProperties": false, "oneOf": [ { "title": "Signed 4844 Transaction", "type": "object", "required": [ "accessList", "blobVersionedHashes", "chainId", "gas", "input", "maxFeePerBlobGas", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "to", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 1559 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x2$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The effective gas price paid by the sender in wei. For transactions not yet included in a block, this value should be set equal to the max fee per gas. This field is DEPRECATED, please transition to using effectiveGasPrice in the receipt object going forward." }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 2930 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x1$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed Legacy Transaction", "type": "object", "required": [ "gas", "gasPrice", "input", "nonce", "r", "s", "type", "v", "value" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x0$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ], "properties": { "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "hash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } ] }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "type": "object", "title": "Validator withdrawal", "required": [ "index", "validatorIndex", "address", "amount" ], "additionalProperties": false, "properties": { "index": { "title": "index of withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "index of validator that generated withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "recipient address for withdrawal value", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "value contained in withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" } } } }, "uncles": { "title": "Uncles", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } ] } } }, { "name": "eth_getBlockByNumber", "summary": "Returns information about a block by number.", "params": [ { "name": "Block", "required": true, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } }, { "name": "Hydrated transactions", "required": true, "schema": { "title": "hydrated", "type": "boolean" } } ], "result": { "name": "Block information", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "title": "Block object", "type": "object", "required": [ "hash", "parentHash", "sha3Uncles", "miner", "stateRoot", "transactionsRoot", "receiptsRoot", "logsBloom", "number", "gasLimit", "gasUsed", "timestamp", "extraData", "mixHash", "nonce", "size", "transactions", "uncles" ], "additionalProperties": false, "properties": { "hash": { "title": "Hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "parentHash": { "title": "Parent block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "sha3Uncles": { "title": "Ommers hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "miner": { "title": "Coinbase", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "stateRoot": { "title": "State root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionsRoot": { "title": "Transactions root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "receiptsRoot": { "title": "Receipts root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "logsBloom": { "title": "Bloom filter", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "difficulty": { "title": "Difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "number": { "title": "Number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasLimit": { "title": "Gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "gasUsed": { "title": "Gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "timestamp": { "title": "Timestamp", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "extraData": { "title": "Extra data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "mixHash": { "title": "Mix hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "nonce": { "title": "Nonce", "type": "string", "pattern": "^0x[0-9a-f]{16}$" }, "totalDifficulty": { "title": "Total difficulty", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "baseFeePerGas": { "title": "Base fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "withdrawalsRoot": { "title": "Withdrawals root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blobGasUsed": { "title": "Blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "excessBlobGas": { "title": "Excess blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "parentBeaconBlockRoot": { "title": "Parent Beacon Block Root", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "size": { "title": "Block size", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactions": { "anyOf": [ { "title": "Transaction hashes", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "title": "Full transactions", "type": "array", "items": { "type": "object", "title": "Transaction information", "required": [ "blockHash", "blockNumber", "from", "hash", "transactionIndex" ], "unevaluatedProperties": false, "oneOf": [ { "title": "Signed 4844 Transaction", "type": "object", "required": [ "accessList", "blobVersionedHashes", "chainId", "gas", "input", "maxFeePerBlobGas", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "to", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 1559 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x2$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The effective gas price paid by the sender in wei. For transactions not yet included in a block, this value should be set equal to the max fee per gas. This field is DEPRECATED, please transition to using effectiveGasPrice in the receipt object going forward." }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 2930 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x1$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed Legacy Transaction", "type": "object", "required": [ "gas", "gasPrice", "input", "nonce", "r", "s", "type", "v", "value" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x0$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ], "properties": { "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "hash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } } ] }, "withdrawals": { "title": "Withdrawals", "type": "array", "items": { "type": "object", "title": "Validator withdrawal", "required": [ "index", "validatorIndex", "address", "amount" ], "additionalProperties": false, "properties": { "index": { "title": "index of withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "validatorIndex": { "title": "index of validator that generated withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "recipient address for withdrawal value", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "amount": { "title": "value contained in withdrawal", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" } } } }, "uncles": { "title": "Uncles", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } ] } } }, { "name": "eth_getBlockReceipts", "summary": "Returns the receipts of a block by number or hash.", "params": [ { "name": "Block", "required": true, "schema": { "title": "Block number, tag, or block hash", "anyOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" }, { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } ] } } ], "result": { "name": "Receipts information", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "title": "Receipts information", "type": "array", "items": { "type": "object", "title": "Receipt information", "required": [ "blockHash", "blockNumber", "from", "cumulativeGasUsed", "gasUsed", "logs", "logsBloom", "transactionHash", "transactionIndex", "effectiveGasPrice" ], "additionalProperties": false, "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "transactionHash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "to": { "title": "to", "description": "Address of the receiver or null in a contract creation transaction.", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Recipient Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "cumulativeGasUsed": { "title": "cumulative gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The sum of gas used by this transaction and all preceding transactions in the same block." }, "gasUsed": { "title": "gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The amount of gas used for this specific transaction alone." }, "blobGasUsed": { "title": "blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The amount of blob gas used for this specific transaction. Only specified for blob transactions as defined by EIP-4844." }, "contractAddress": { "title": "contract address", "description": "The contract address created, if the transaction was a contract creation, otherwise null.", "oneOf": [ { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, { "title": "Null", "type": "null" } ] }, "logs": { "title": "logs", "type": "array", "items": { "title": "log", "type": "object", "required": [ "transactionHash" ], "additionalProperties": false, "properties": { "removed": { "title": "removed", "type": "boolean" }, "logIndex": { "title": "log index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionHash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "data": { "title": "data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "topics": { "title": "topics", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "logsBloom": { "title": "logs bloom", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "root": { "title": "state root", "type": "string", "pattern": "^0x[0-9a-f]{64}$", "description": "The post-transaction state root. Only specified for transactions included before the Byzantium upgrade." }, "status": { "title": "status", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Either 1 (success) or 0 (failure). Only specified for transactions included after the Byzantium upgrade." }, "effectiveGasPrice": { "title": "effective gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The actual value per gas deducted from the sender's account. Before EIP-1559, this is equal to the transaction's gas price. After, it is equal to baseFeePerGas + min(maxFeePerGas - baseFeePerGas, maxPriorityFeePerGas)." }, "blobGasPrice": { "title": "blob gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The actual value per gas deducted from the sender's account for blob gas. Only specified for blob transactions as defined by EIP-4844." } } } } ] } } }, { "name": "eth_getBlockTransactionCountByHash", "summary": "Returns the number of transactions in a block from a block matching the given block hash.", "params": [ { "name": "Block hash", "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ], "result": { "name": "Transaction count", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "title": "Transaction count", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } ] } } }, { "name": "eth_getBlockTransactionCountByNumber", "summary": "Returns the number of transactions in a block matching the given block number.", "params": [ { "name": "Block", "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } } ], "result": { "name": "Transaction count", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "title": "Transaction count", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } ] } } }, { "name": "eth_getCode", "summary": "Returns code at a given address.", "params": [ { "name": "Address", "required": true, "schema": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } }, { "name": "Block", "required": true, "schema": { "title": "Block number, tag, or block hash", "anyOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" }, { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } ] } } ], "result": { "name": "Bytecode", "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } }, { "name": "eth_getFilterChanges", "summary": "Polling method for a filter, which returns an array of logs which occurred since last poll.", "params": [ { "name": "Filter Identifier", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } ], "result": { "name": "Log objects", "schema": { "title": "Filter results", "oneOf": [ { "title": "new block or transaction hashes", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "title": "new logs", "type": "array", "items": { "title": "log", "type": "object", "required": [ "transactionHash" ], "additionalProperties": false, "properties": { "removed": { "title": "removed", "type": "boolean" }, "logIndex": { "title": "log index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionHash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "data": { "title": "data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "topics": { "title": "topics", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } } ] } } }, { "name": "eth_getFilterLogs", "summary": "Returns an array of all logs matching filter with given id.", "params": [ { "name": "Filter Identifier", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } ], "result": { "name": "Log objects", "schema": { "title": "Filter results", "oneOf": [ { "title": "new block or transaction hashes", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "title": "new logs", "type": "array", "items": { "title": "log", "type": "object", "required": [ "transactionHash" ], "additionalProperties": false, "properties": { "removed": { "title": "removed", "type": "boolean" }, "logIndex": { "title": "log index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionHash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "data": { "title": "data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "topics": { "title": "topics", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } } ] } } }, { "name": "eth_getLogs", "summary": "Returns an array of all logs matching filter with given id.", "params": [ { "name": "Filter", "schema": { "title": "filter", "type": "object", "additionalProperties": false, "properties": { "fromBlock": { "title": "from block", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "toBlock": { "title": "to block", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Address(es)", "oneOf": [ { "title": "Any Address", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, { "title": "Addresses", "type": "array", "items": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } } ] }, "topics": { "title": "Topics", "oneOf": [ { "title": "Any Topic Match", "type": "null" }, { "title": "Specified Filter Topics", "type": "array", "items": { "title": "Filter Topic List Entry", "oneOf": [ { "title": "Single Topic Match", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, { "title": "Multiple Topic Match", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ] } } ] } } } } ], "result": { "name": "Log objects", "schema": { "title": "Filter results", "oneOf": [ { "title": "new block or transaction hashes", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "title": "new logs", "type": "array", "items": { "title": "log", "type": "object", "required": [ "transactionHash" ], "additionalProperties": false, "properties": { "removed": { "title": "removed", "type": "boolean" }, "logIndex": { "title": "log index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionHash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "data": { "title": "data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "topics": { "title": "topics", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } } ] } } }, { "name": "eth_getProof", "summary": "Returns the merkle proof for a given account and optionally some storage keys.", "params": [ { "name": "Address", "required": true, "schema": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } }, { "name": "StorageKeys", "required": true, "schema": { "title": "Storage keys", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" } } }, { "name": "Block", "required": true, "schema": { "title": "Block number, tag, or block hash", "anyOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" }, { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } ] } } ], "result": { "name": "Account", "schema": { "title": "Account proof", "type": "object", "required": [ "address", "accountProof", "balance", "codeHash", "nonce", "storageHash", "storageProof" ], "additionalProperties": false, "properties": { "address": { "title": "address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "accountProof": { "title": "accountProof", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "balance": { "title": "balance", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "codeHash": { "title": "codeHash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "storageHash": { "title": "storageHash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "storageProof": { "title": "Storage proofs", "type": "array", "items": { "title": "Storage proof", "type": "object", "required": [ "key", "value", "proof" ], "additionalProperties": false, "properties": { "key": { "title": "key", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]{0,63})|0$" }, "proof": { "title": "proof", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } } } } } } } }, { "name": "eth_getStorageAt", "summary": "Returns the value from a storage position at a given address.", "params": [ { "name": "Address", "required": true, "schema": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } }, { "name": "Storage slot", "required": true, "schema": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{0,64}$" } }, { "name": "Block", "required": true, "schema": { "title": "Block number, tag, or block hash", "anyOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" }, { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } ] } } ], "result": { "name": "Value", "schema": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } }, { "name": "eth_getTransactionByBlockHashAndIndex", "summary": "Returns information about a transaction by block hash and transaction index position.", "params": [ { "name": "Block hash", "required": true, "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, { "name": "Transaction index", "required": true, "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } ], "result": { "name": "Transaction information", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "type": "object", "title": "Transaction information", "required": [ "blockHash", "blockNumber", "from", "hash", "transactionIndex" ], "unevaluatedProperties": false, "oneOf": [ { "title": "Signed 4844 Transaction", "type": "object", "required": [ "accessList", "blobVersionedHashes", "chainId", "gas", "input", "maxFeePerBlobGas", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "to", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 1559 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x2$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The effective gas price paid by the sender in wei. For transactions not yet included in a block, this value should be set equal to the max fee per gas. This field is DEPRECATED, please transition to using effectiveGasPrice in the receipt object going forward." }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 2930 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x1$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed Legacy Transaction", "type": "object", "required": [ "gas", "gasPrice", "input", "nonce", "r", "s", "type", "v", "value" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x0$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ], "properties": { "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "hash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ] } } }, { "name": "eth_getTransactionByBlockNumberAndIndex", "summary": "Returns information about a transaction by block number and transaction index position.", "params": [ { "name": "Block", "required": true, "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } }, { "name": "Transaction index", "required": true, "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } ], "result": { "name": "Transaction information", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "type": "object", "title": "Transaction information", "required": [ "blockHash", "blockNumber", "from", "hash", "transactionIndex" ], "unevaluatedProperties": false, "oneOf": [ { "title": "Signed 4844 Transaction", "type": "object", "required": [ "accessList", "blobVersionedHashes", "chainId", "gas", "input", "maxFeePerBlobGas", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "to", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 1559 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x2$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The effective gas price paid by the sender in wei. For transactions not yet included in a block, this value should be set equal to the max fee per gas. This field is DEPRECATED, please transition to using effectiveGasPrice in the receipt object going forward." }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 2930 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x1$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed Legacy Transaction", "type": "object", "required": [ "gas", "gasPrice", "input", "nonce", "r", "s", "type", "v", "value" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x0$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ], "properties": { "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "hash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ] } } }, { "name": "eth_getTransactionByHash", "summary": "Returns the information about a transaction requested by transaction hash.", "params": [ { "name": "Transaction hash", "required": true, "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ], "result": { "name": "Transaction information", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "type": "object", "title": "Transaction information", "required": [ "blockHash", "blockNumber", "from", "hash", "transactionIndex" ], "unevaluatedProperties": false, "oneOf": [ { "title": "Signed 4844 Transaction", "type": "object", "required": [ "accessList", "blobVersionedHashes", "chainId", "gas", "input", "maxFeePerBlobGas", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "to", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 1559 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x2$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The effective gas price paid by the sender in wei. For transactions not yet included in a block, this value should be set equal to the max fee per gas. This field is DEPRECATED, please transition to using effectiveGasPrice in the receipt object going forward." }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed 2930 Transaction", "type": "object", "required": [ "accessList", "chainId", "gas", "gasPrice", "input", "nonce", "r", "s", "type", "value", "yParity" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x1$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "yParity": { "title": "yParity", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The parity (0 for even, 1 for odd) of the y-value of the secp256k1 signature." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "For backwards compatibility, `v` is optionally provided as an alternative to `yParity`. This field is DEPRECATED and all use of it should migrate to `yParity`." }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Signed Legacy Transaction", "type": "object", "required": [ "gas", "gasPrice", "input", "nonce", "r", "s", "type", "v", "value" ], "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x0$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." }, "v": { "title": "v", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "r": { "title": "r", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "s": { "title": "s", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ], "properties": { "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "hash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } } ] } } }, { "name": "eth_getTransactionCount", "summary": "Returns the number of transactions sent from an address.", "params": [ { "name": "Address", "required": true, "schema": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } }, { "name": "Block", "required": true, "schema": { "title": "Block number, tag, or block hash", "anyOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" }, { "title": "Block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } ] } } ], "result": { "name": "Transaction count", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_getTransactionReceipt", "summary": "Returns the receipt of a transaction by transaction hash.", "params": [ { "name": "Transaction hash", "required": true, "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ], "result": { "name": "Receipt information", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "type": "object", "title": "Receipt information", "required": [ "blockHash", "blockNumber", "from", "cumulativeGasUsed", "gasUsed", "logs", "logsBloom", "transactionHash", "transactionIndex", "effectiveGasPrice" ], "additionalProperties": false, "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "transactionHash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "from": { "title": "from", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "to": { "title": "to", "description": "Address of the receiver or null in a contract creation transaction.", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Recipient Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "cumulativeGasUsed": { "title": "cumulative gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The sum of gas used by this transaction and all preceding transactions in the same block." }, "gasUsed": { "title": "gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The amount of gas used for this specific transaction alone." }, "blobGasUsed": { "title": "blob gas used", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The amount of blob gas used for this specific transaction. Only specified for blob transactions as defined by EIP-4844." }, "contractAddress": { "title": "contract address", "description": "The contract address created, if the transaction was a contract creation, otherwise null.", "oneOf": [ { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, { "title": "Null", "type": "null" } ] }, "logs": { "title": "logs", "type": "array", "items": { "title": "log", "type": "object", "required": [ "transactionHash" ], "additionalProperties": false, "properties": { "removed": { "title": "removed", "type": "boolean" }, "logIndex": { "title": "log index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionIndex": { "title": "transaction index", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "transactionHash": { "title": "transaction hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockHash": { "title": "block hash", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, "blockNumber": { "title": "block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "data": { "title": "data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "topics": { "title": "topics", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "logsBloom": { "title": "logs bloom", "type": "string", "pattern": "^0x[0-9a-f]{512}$" }, "root": { "title": "state root", "type": "string", "pattern": "^0x[0-9a-f]{64}$", "description": "The post-transaction state root. Only specified for transactions included before the Byzantium upgrade." }, "status": { "title": "status", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Either 1 (success) or 0 (failure). Only specified for transactions included after the Byzantium upgrade." }, "effectiveGasPrice": { "title": "effective gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The actual value per gas deducted from the sender's account. Before EIP-1559, this is equal to the transaction's gas price. After, it is equal to baseFeePerGas + min(maxFeePerGas - baseFeePerGas, maxPriorityFeePerGas)." }, "blobGasPrice": { "title": "blob gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The actual value per gas deducted from the sender's account for blob gas. Only specified for blob transactions as defined by EIP-4844." } } } ] } } }, { "name": "eth_getUncleCountByBlockHash", "summary": "Returns the number of uncles in a block from a block matching the given block hash.", "params": [ { "name": "Block hash", "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ], "result": { "name": "Uncle count", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "title": "Uncle count", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } ] } } }, { "name": "eth_getUncleCountByBlockNumber", "summary": "Returns the number of transactions in a block matching the given block number.", "params": [ { "name": "Block", "schema": { "title": "Block number or tag", "oneOf": [ { "title": "Block number", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, { "title": "Block tag", "type": "string", "enum": [ "earliest", "finalized", "safe", "latest", "pending" ], "description": "`earliest`: The lowest numbered block the client has available; `finalized`: The most recent crypto-economically secure block, cannot be re-orged outside of manual intervention driven by community coordination; `safe`: The most recent block that is safe from re-orgs under honest majority and certain synchronicity assumptions; `latest`: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions; `pending`: A sample next block built by the client on top of `latest` and containing the set of transactions usually taken from local mempool. Before the merge transition is finalized, any call querying for `finalized` or `safe` block MUST be responded to with `-39001: Unknown block` error" } ] } } ], "result": { "name": "Uncle count", "schema": { "oneOf": [ { "title": "Not Found (null)", "type": "null" }, { "title": "Uncle count", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } ] } } }, { "name": "eth_maxPriorityFeePerGas", "summary": "Returns the current maxPriorityFeePerGas per gas in wei.", "params": [], "result": { "name": "Max priority fee per gas", "schema": { "title": "Max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_newBlockFilter", "summary": "Creates a filter in the node, to notify when a new block arrives.", "params": [], "result": { "name": "Filter Identifier", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_newFilter", "summary": "Creates a filter object, based on filter options, to notify when the state changes (logs).", "params": [ { "name": "Filter", "schema": { "title": "filter", "type": "object", "additionalProperties": false, "properties": { "fromBlock": { "title": "from block", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "toBlock": { "title": "to block", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "address": { "title": "Address(es)", "oneOf": [ { "title": "Any Address", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, { "title": "Addresses", "type": "array", "items": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } } ] }, "topics": { "title": "Topics", "oneOf": [ { "title": "Any Topic Match", "type": "null" }, { "title": "Specified Filter Topics", "type": "array", "items": { "title": "Filter Topic List Entry", "oneOf": [ { "title": "Single Topic Match", "type": "string", "pattern": "^0x[0-9a-f]{64}$" }, { "title": "Multiple Topic Match", "type": "array", "items": { "title": "32 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } ] } } ] } } } } ], "result": { "name": "Filter Identifier", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_newPendingTransactionFilter", "summary": "Creates a filter in the node, to notify when new pending transactions arrive.", "params": [], "result": { "name": "Filter Identifier", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "name": "eth_sendRawTransaction", "summary": "Submits a raw transaction. For EIP-4844 transactions, the raw form must be the network form. This means it includes the blobs, KZG commitments, and KZG proofs.", "params": [ { "name": "Transaction", "required": true, "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } ], "result": { "name": "Transaction hash", "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } }, { "name": "eth_sendTransaction", "summary": "Signs and submits a transaction.", "params": [ { "name": "Transaction", "required": true, "schema": { "type": "object", "title": "Transaction object generic to all types", "additionalProperties": false, "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "blobs": { "title": "blobs", "description": "Raw blob data.", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." } } } } ], "result": { "name": "Transaction hash", "schema": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } }, { "name": "eth_sign", "summary": "Returns an EIP-191 signature over the provided data.", "params": [ { "name": "Address", "required": true, "schema": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } }, { "name": "Message", "required": true, "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } ], "result": { "name": "Signature", "schema": { "title": "65 hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]{130}$" } } }, { "name": "eth_signTransaction", "summary": "Returns an RLP encoded transaction signed by the specified account.", "params": [ { "name": "Transaction", "required": true, "schema": { "type": "object", "title": "Transaction object generic to all types", "additionalProperties": false, "properties": { "type": { "title": "type", "type": "string", "pattern": "^0x([0-9a-fA-F]?){1,2}$" }, "nonce": { "title": "nonce", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "to": { "title": "to address", "oneOf": [ { "title": "Contract Creation (null)", "type": "null" }, { "title": "Address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" } ] }, "from": { "title": "from address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "gas": { "title": "gas limit", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "value": { "title": "value", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "input": { "title": "input data", "type": "string", "pattern": "^0x[0-9a-f]*$" }, "gasPrice": { "title": "gas price", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The gas price willing to be paid by the sender in wei" }, "maxPriorityFeePerGas": { "title": "max priority fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Maximum fee per gas the sender is willing to pay to miners in wei" }, "maxFeePerGas": { "title": "max fee per gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay (includes the network / base fee and miner / priority fee) in wei" }, "maxFeePerBlobGas": { "title": "max fee per blob gas", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "The maximum total fee per gas the sender is willing to pay for blob gas in wei" }, "accessList": { "title": "accessList", "type": "array", "description": "EIP-2930 access list", "items": { "title": "Access list entry", "type": "object", "additionalProperties": false, "properties": { "address": { "title": "hex encoded address", "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }, "storageKeys": { "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } } } } }, "blobVersionedHashes": { "title": "blobVersionedHashes", "description": "List of versioned blob hashes associated with the transaction's EIP-4844 data blobs.", "type": "array", "items": { "title": "32 byte hex value", "type": "string", "pattern": "^0x[0-9a-f]{64}$" } }, "blobs": { "title": "blobs", "description": "Raw blob data.", "type": "array", "items": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } }, "chainId": { "title": "chainId", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$", "description": "Chain ID that this transaction is valid on." } } } } ], "result": { "name": "Encoded transaction", "schema": { "title": "hex encoded bytes", "type": "string", "pattern": "^0x[0-9a-f]*$" } } }, { "name": "eth_syncing", "summary": "Returns an object with data about the sync status or false.", "params": [], "result": { "name": "Syncing status", "schema": { "title": "Syncing status", "oneOf": [ { "title": "Syncing progress", "type": "object", "additionalProperties": false, "properties": { "startingBlock": { "title": "Starting block", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "currentBlock": { "title": "Current block", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" }, "highestBlock": { "title": "Highest block", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } }, { "title": "Not syncing", "description": "Should always return false if not syncing.", "type": "boolean" } ] } } }, { "name": "eth_uninstallFilter", "summary": "Uninstalls a filter with given id.", "params": [ { "name": "Filter Identifier", "schema": { "title": "hex encoded unsigned integer", "type": "string", "pattern": "^0x([1-9a-f]+[0-9a-f]*|0)$" } } ], "result": { "name": "Success", "schema": { "type": "boolean" } } } ], "components": {} } ================================================ FILE: silkworm/rpc/json_rpc/validator.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "validator.hpp" #include #include #include "specification.hpp" namespace silkworm::rpc::json_rpc { static constexpr std::string_view kRequestFieldJsonRpc{"jsonrpc"}; static constexpr std::string_view kRequestFieldId{"id"}; static constexpr std::string_view kRequestFieldMethod{"method"}; static constexpr std::string_view kRequestFieldParameters{"params"}; static const std::string kRequestRequiredFields{ std::string{kRequestFieldJsonRpc} + "," + std::string{kRequestFieldId} + "," + std::string{kRequestFieldMethod} + "," + std::string{kRequestFieldParameters}}; void Validator::load_specification() { const auto spec = nlohmann::json::parse(kSpecificationJson, nullptr, /*allow_exceptions=*/false); if (spec.contains("methods")) { for (const auto& method : spec["methods"]) { method_specs_[method["name"].get()] = method["params"]; } } if (spec.contains("openrpc")) { openrpc_version_ = spec["openrpc"]; } std::function fill_patterns = [&](const nlohmann::json& json) mutable { if (json.is_object()) { for (auto& [key, value] : json.items()) { if (key == "pattern" && value.is_string()) { const auto value_string = value.get(); patterns_[value_string] = boost::regex(value_string, boost::regex::optimize | boost::regex::icase); } fill_patterns(value); } } else if (json.is_array()) { for (const auto& element : json) { fill_patterns(element); } } }; fill_patterns(spec); } ValidationResult Validator::validate(const nlohmann::json& request) { if (auto valid_result{check_request_fields(request)}; !valid_result) { return valid_result; } return validate_params(request); } ValidationResult Validator::check_request_fields(const nlohmann::json& request) { // Expected fields: jsonrpc, id, method, params (optional) auto required_fields = 0b111; for (auto item = request.begin(); item != request.end(); ++item) { if (item.key() == kRequestFieldMethod) { if (!item.value().is_string()) { return tl::make_unexpected("Invalid field: " + item.key()); } required_fields &= 0b110; } else if (item.key() == kRequestFieldId) { if (!item.value().is_number()) { return tl::make_unexpected("Invalid field: " + item.key()); } required_fields &= 0b101; } else if (item.key() == kRequestFieldParameters) { if (!item.value().is_array()) { return tl::make_unexpected("Invalid field: " + item.key()); } } else if (item.key() == kRequestFieldJsonRpc) { if (!item.value().is_string()) { return tl::make_unexpected("Invalid field: " + item.key()); } required_fields &= 0b011; } else { return tl::make_unexpected("Invalid field: " + item.key()); } } if (required_fields != 0) { return tl::make_unexpected("Request not valid, required fields: " + kRequestRequiredFields); } return {}; } ValidationResult Validator::validate_params(const nlohmann::json& request) { const auto& method = request.find(kRequestFieldMethod).value().get(); const auto& params_field = request.find(kRequestFieldParameters); const auto& params = params_field != request.end() ? params_field.value() : nlohmann::json::array(); const auto& method_spec_field = method_specs_.find(method); if (method_spec_field == method_specs_.end()) { if (accept_unknown_methods_) { return {}; } return tl::make_unexpected("Method not found in spec: " + method); } const auto& method_spec = method_spec_field->second; if (params.size() > method_spec.size() + 1) { // allow one extra parameter for optimize_gas return tl::make_unexpected("Invalid number of parameters: " + std::to_string(params.size())); } size_t idx = 0; for (const auto& spec : method_spec) { const auto& spec_name = spec["name"].get(); const auto& spec_schema = spec["schema"]; if (params.size() <= idx) { if (spec.contains("required") && spec["required"].get()) { return tl::make_unexpected("Missing required parameter: " + spec_name); } break; } if (auto result{validate_schema(params[idx], spec_schema)}; !result) { return tl::make_unexpected(result.error() + " in spec: " + spec_name); } ++idx; } return {}; } ValidationResult Validator::validate_schema(const nlohmann::json& value, const nlohmann::json& schema) { if (schema.contains("type")) { if (auto result{validate_type(value, schema)}; !result) { return result; } } auto schema_of_collection = schema.find("anyOf"); if (schema_of_collection == schema.end()) { schema_of_collection = schema.find("oneOf"); } ValidationResult result; if (schema_of_collection != schema.end()) { for (const auto& schema_of : schema_of_collection.value()) { result = validate_type(value, schema_of); if (result) { break; } } } return result; } ValidationResult Validator::validate_type(const nlohmann::json& value, const nlohmann::json& schema) { const auto& schema_type = schema["type"].get(); if (schema_type == "string") { return validate_string(value, schema); } if (schema_type == "array") { return validate_array(value, schema); } if (schema_type == "object") { return validate_object(value, schema); } if (schema_type == "boolean") { return validate_boolean(value); } if (schema_type == "number") { return validate_number(value); } if (schema_type == "null") { return validate_null(value); } return tl::make_unexpected("Invalid schema type: " + schema_type); } ValidationResult Validator::validate_string(const nlohmann::json& string, const nlohmann::json& schema) { if (!string.is_string()) { return tl::make_unexpected("Invalid string: " + string.dump()); } const auto& schema_pattern_field = schema.find("pattern"); if (schema_pattern_field != schema.end()) { const auto& schema_pattern = schema_pattern_field.value().get(); const auto& pattern_field = patterns_.find(schema_pattern); if (pattern_field == patterns_.end()) { return tl::make_unexpected("Prebuilt pattern not found for: " + schema_pattern); } const auto& pattern = pattern_field->second; if (!boost::regex_match(string.get(), pattern)) { return tl::make_unexpected("Invalid string pattern: " + string.get()); } } const auto& enum_field = schema.find("enum"); if (enum_field != schema.end()) { bool is_valid = false; for (const auto& enum_value : enum_field.value()) { if (string == enum_value) { is_valid = true; break; } } if (!is_valid) { return tl::make_unexpected("Invalid string enum: " + string.dump()); } } return {}; } ValidationResult Validator::validate_array(const nlohmann::json& array, const nlohmann::json& schema) { if (!array.is_array() && !array.is_null() && array.empty()) { return tl::make_unexpected("Invalid array: " + array.dump()); } ValidationResult result; const auto& schema_items = schema["items"]; for (const auto& item : array) { result = validate_schema(item, schema_items); if (!result) { return result; } } return result; } ValidationResult Validator::validate_object(const nlohmann::json& object, const nlohmann::json& schema) { if (!object.is_object()) { return tl::make_unexpected("Invalid object: " + object.dump()); } if (schema.contains("required")) { for (const auto& item : schema["required"]) { if (object.find(item) == object.end()) { return tl::make_unexpected("Missing required field: " + item.get()); } } } if (schema.contains("properties")) { for (const auto& item : object.items()) { if (schema["properties"].contains(item.key())) { if (auto valid_result{validate_schema(item.value(), schema["properties"][item.key()])}; !valid_result) { return tl::make_unexpected(valid_result.error() + " for field: " + item.key()); } } else if (item.key() == "data") { // backward compatibility: optional `data` field is hex data if (auto valid_result{validate_string(item.value(), R"({"pattern": "^0x[0-9a-f]*$"})"_json)}; !valid_result) { return tl::make_unexpected(valid_result.error() + " for field: " + item.key()); } } else { return tl::make_unexpected("Invalid field: " + item.key()); } } } return {}; } ValidationResult Validator::validate_boolean(const nlohmann::json& boolean) { if (!boolean.is_boolean()) { return tl::make_unexpected("Invalid boolean: " + boolean.dump()); } return {}; } ValidationResult Validator::validate_number(const nlohmann::json& number) { if (!number.is_number()) { return tl::make_unexpected("Invalid number: " + number.dump()); } return {}; } ValidationResult Validator::validate_null(const nlohmann::json& value) { if (value.is_null()) { return {}; } if (value.is_string() && (value.get().empty() || value.get() == "null")) { return {}; } return tl::make_unexpected("Invalid null: " + value.dump()); } } // namespace silkworm::rpc::json_rpc ================================================ FILE: silkworm/rpc/json_rpc/validator.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc::json_rpc { using ValidationResult = tl::expected; class Validator { public: static void load_specification(); static const std::string& openrpc_version() { return openrpc_version_; } ValidationResult validate(const nlohmann::json& request); private: ValidationResult check_request_fields(const nlohmann::json& request); ValidationResult validate_params(const nlohmann::json& request); ValidationResult validate_schema(const nlohmann::json& value, const nlohmann::json& schema); ValidationResult validate_type(const nlohmann::json& value, const nlohmann::json& schema); ValidationResult validate_string(const nlohmann::json& string, const nlohmann::json& schema); ValidationResult validate_array(const nlohmann::json& array, const nlohmann::json& schema); ValidationResult validate_object(const nlohmann::json& object, const nlohmann::json& schema); ValidationResult validate_boolean(const nlohmann::json& boolean); ValidationResult validate_number(const nlohmann::json& number); ValidationResult validate_null(const nlohmann::json& value); static inline std::string openrpc_version_; static inline std::map method_specs_; static inline std::map patterns_; bool accept_unknown_methods_{true}; }; } // namespace silkworm::rpc::json_rpc ================================================ FILE: silkworm/rpc/json_rpc/validator_benchmark.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include #include #include #include "validator.hpp" static silkworm::rpc::json_rpc::Validator validator{}; static const nlohmann::json kRequests[2] = { { {"jsonrpc", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", {"0x0", true}}, {"id", 1}, }, {{"jsonrpc", "2.0"}, {"id", 1}, {"method", "engine_exchangeTransitionConfigurationV1"}, {"params", {{ {"terminalTotalDifficulty", "0x1"}, {"terminalBlockHash", "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794"}, {"terminalBlockNumber", "0x1"}, }}}}}; static void json_rpc_validator(benchmark::State& state) { nlohmann::json json = kRequests[state.range(0)]; for ([[maybe_unused]] auto _ : state) { validator.validate(json); } } BENCHMARK(json_rpc_validator)->Arg(0)->Arg(1); ================================================ FILE: silkworm/rpc/json_rpc/validator_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "validator.hpp" #include #include #include #include namespace silkworm::rpc::json_rpc { //! Ensure JSON RPC spec has been loaded before creating Validator instance static Validator create_validator_for_test() { Validator::load_specification(); return {}; } TEST_CASE("Validator loads spec in constructor", "[rpc][json_rpc][validator]") { REQUIRE_NOTHROW(Validator::load_specification()); CHECK(Validator::openrpc_version() == "1.2.4"); } TEST_CASE("Validator validates request fields", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", {"0x0", true}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator detects missing request field", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"method", "eth_getBlockByNumber"}, {"params", {"0x0", true}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Request not valid, required fields: jsonrpc,id,method,params"); request = { {"jsonrpc", "2.0"}, {"params", {"0x0", true}}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Request not valid, required fields: jsonrpc,id,method,params"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", {"0x0", true}}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Request not valid, required fields: jsonrpc,id,method,params"); } TEST_CASE("Validator validates invalid request fields", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", 2}, {"method", "eth_getBlockByNumber"}, {"params", {"0x0", true}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid field: jsonrpc"); request = { {"jsonrpc", "2.0"}, {"method", 1}, {"params", {"0x0", true}}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid field: method"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", "params"}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid field: params"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", {"0x0", true}}, {"id", "1"}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid field: id"); } TEST_CASE("Validator accepts missing params field", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "debug_getBadBlocks"}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator rejects missing params field if required", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBlockReceipts"}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Missing required parameter: Block"); } TEST_CASE("Validator detects unknown fields", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"unknown", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", {"0x0", true}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid field: unknown"); } TEST_CASE("Validator accepts missing optional parameter", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; const auto request = R"({ "jsonrpc":"2.0", "id":1, "method":"eth_call", "params":[ { "from":"0xEF04bc7821433f080461BBAE815182E3d7bBb61A", "to":"0x4debB0dF4da8D1f51EF67B727c3F1c0eCC7ed009", "gas":"0x5208", "gasPrice":"0x2CB417800", "value": "0x229322" } ] })"_json; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator validates string parameter", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", nlohmann::json::array({"0xaa0", "latest"})}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid string pattern: 0xaa0 in spec: Address"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", nlohmann::json::array({"0xga00000000000000000000000000000000000000", "latest"})}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid string pattern: 0xga00000000000000000000000000000000000000 in spec: Address"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", nlohmann::json::array({"1xaa00000000000000000000000000000000000000", "latest"})}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid string pattern: 1xaa00000000000000000000000000000000000000 in spec: Address"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", nlohmann::json::array({"aa00000000000000000000000000000000000000", "latest"})}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid string pattern: aa00000000000000000000000000000000000000 in spec: Address"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", nlohmann::json::array({"account", "latest"})}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid string pattern: account in spec: Address"); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", nlohmann::json::array({123, "latest"})}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); CHECK(result.error() == "Invalid string: 123 in spec: Address"); } TEST_CASE("Validator validates optional parameter if provided", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", {"0xaa00000000000000000000000000000000000000", "not-valid-param"}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(!result); } TEST_CASE("Validator validates enum", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", {"0xaa00000000000000000000000000000000000000", "earliest"}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(result); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", {"0xaa00000000000000000000000000000000000000", "latest"}}, {"id", 1}, }; result = validator.validate(request); CHECK(result); CHECK(result); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", {"0xaa00000000000000000000000000000000000000", "other"}}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); } TEST_CASE("Validator validates hash", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", {"0xaa00000000000000000000000000000000000000", "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794"}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(result); request = { {"jsonrpc", "2.0"}, {"method", "eth_getBalance"}, {"params", {"0xaa00000000000000000000000000000000000000", "0x06734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a44979"}}, {"id", 1}, }; result = validator.validate(request); CHECK(!result); } TEST_CASE("Validator validates array", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "eth_getProof"}, {"params", {"0xaa00000000000000000000000000000000000000", {"0x01", "0x02"}, "0x3"}}}; ValidationResult result = validator.validate(request); CHECK(result); request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "eth_getProof"}, {"params", {"0xaa00000000000000000000000000000000000000", {"0x01", "invalid"}, "0x3"}}}; result = validator.validate(request); CHECK(!result); } TEST_CASE("Validator validates object", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "engine_exchangeTransitionConfigurationV1"}, {"params", {{ {"terminalTotalDifficulty", "0x1"}, {"terminalBlockHash", "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794"}, {"terminalBlockNumber", "0x1"}, }}}}; ValidationResult result = validator.validate(request); CHECK(result); request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "engine_exchangeTransitionConfigurationV1"}, {"params", {{ {"terminalTotalDifficulty", "0x1"}, {"terminalBlockNumber", "0x1"}, }}}}; result = validator.validate(request); CHECK(!result); request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "engine_exchangeTransitionConfigurationV1"}, {"params", {{ {"terminalTotalDifficulty", "1x1"}, {"terminalBlockHash", "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794"}, {"terminalBlockNumber", "0x1"}, }}}}; result = validator.validate(request); CHECK(!result); request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "engine_exchangeTransitionConfigurationV1"}, {"params", {{ {"terminalTotalDifficulty", "0x1"}, {"terminalBlockHash", "1x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794"}, {"terminalBlockNumber", "0x1"}, }}}}; result = validator.validate(request); CHECK(!result); request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "engine_exchangeTransitionConfigurationV1"}, {"params", {{ {"terminalTotalDifficulty", "0x1"}, {"terminalBlockHash", "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794"}, {"terminalBlockNumber", "1x1"}, }}}}; result = validator.validate(request); CHECK(!result); request = { {"jsonrpc", "2.0"}, {"id", 1}, {"method", "engine_exchangeTransitionConfigurationV1"}, {"params", {{ {"terminalTotalDifficulty", "0x1"}, {"terminalBlockHash", "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794"}, {"terminalBlockNumber", "0x1"}, {"extra", "extra"}, }}}}; result = validator.validate(request); CHECK(!result); } TEST_CASE("Validator validates uppercase hex value", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", {"0xF42405", true}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator validates `data` field", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; nlohmann::json request = { {"jsonrpc", "2.0"}, {"method", "eth_getBlockByNumber"}, {"params", {"0xF42405", true}}, {"id", 1}, }; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator validates nested arrays", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; auto request1 = R"({ "jsonrpc":"2.0", "method":"eth_getLogs", "params":[ { "fromBlock": "0x10B10B2", "toBlock": "0x10B10B3", "address": ["0x00000000219ab540356cbb839cbe05303d7705fa"], "topics": null } ], "id":3 })"_json; ValidationResult result1 = validator.validate(request1); CHECK(result1); auto request2 = R"({ "jsonrpc":"2.0", "method":"eth_getLogs", "params":[ { "fromBlock": "0x10B10B2", "toBlock": "0x10B10B3", "address": ["0x00000000219ab540356cbb839cbe05303d7705fa"], "topics": "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794" } ], "id":3 })"_json; ValidationResult result2 = validator.validate(request2); CHECK(result2); auto request3 = R"({ "jsonrpc":"2.0", "method":"eth_getLogs", "params":[ { "fromBlock": "0x10B10B2", "toBlock": "0x10B10B3", "address": ["0x00000000219ab540356cbb839cbe05303d7705fa"], "topics": [ "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449794", "0x76734e0205d8c4b711990ab957e86d3dc56d129600e60750552c95448a449795" ] } ], "id":3 })"_json; ValidationResult result3 = validator.validate(request3); CHECK(result3); } TEST_CASE("Validator validates spec test request", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; const auto tests_dir = db::test_util::get_tests_dir(); for (const auto& test_file : std::filesystem::recursive_directory_iterator(tests_dir)) { if (!test_file.is_directory() && test_file.path().extension() == ".io") { auto test_name = test_file.path().filename().string(); auto group_name = test_file.path().parent_path().filename().string(); SECTION("RPC IO test " + group_name + " | " + test_name) { // NOLINT(*-inefficient-string-concatenation) std::ifstream test_stream(test_file.path()); std::string request_line; if (std::getline(test_stream, request_line) && request_line.starts_with(">> ")) { auto request = nlohmann::json::parse(request_line.substr(3)); const auto result = validator.validate(request); if (!absl::StrContains(test_name, "invalid")) { CHECK(result); } } } } } } TEST_CASE("Validator engine_newPayloadV3: patch blobGasUsed regex", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; // blobGasUsed regex at commit 5849052: "^0x([1-9a-f]+[0-9a-f]{0,15})|0$" does not work for input "blobGasUsed":"0x0" // blobGasUsed regex patch: "^0x([1-9a-f]+[0-9a-f]*|0)$" auto request = R"({ "jsonrpc":"2.0", "id":13, "method":"engine_newPayloadV3", "params":[ { "parentHash":"0x448aadba99a68c0c761f85d786d9aa1972af991b1cd542421c7a4f4a62987cc4", "feeRecipient":"0x0000006916a87b82333f4245046623b23794c65c", "stateRoot":"0xd34d72e16fadc36e7d1173ee3d497f7a07e3d0d2c59298653d2c40d10810aff8", "receiptsRoot":"0x08794b3ff9f42df2954a0c4913b1370c2a9294f5803ce1e6ea7d92091f30762e", "logsBloom":"0x0ca18204900040848c30020aa0001c20a0201c88000480002a504c0a4028c040040000088220a041c8012a4041840082808008c212a4a22005021001403c081804b080080c0d10084180402e0a8000008e022c8541844005442c000084200820c824040a46404210d2204a050402092440ca04c0c509d5a081009314841894940a40000c12018160a40001114cc0018000120921010400041a01109004d81800220920220a00c6061100834420301101624200200008082608c84c020800402941807003000000040083018d0802400061000008414003010001994040a4e22c20104084006200083000002020804000100810008c806250840a12120160c224", "prevRandao":"0x354265f4b5cbfe6d192e9ae4eed264b2dd5a7379f0a03d07ac3e01c1adfe164a", "blockNumber":"0x532187", "gasLimit":"0x1c9c380", "gasUsed":"0x6853ff", "timestamp":"0x65ec2540", "extraData":"0xd883010d0d846765746888676f312e32322e30856c696e7578", "baseFeePerGas":"0x6dd380a", "blobGasUsed":"0x0", "excessBlobGas":"0x4cc0000", "blockHash":"0x1e11ea7472b7d08d393bb5e301f15cd0bce394dd48956e4f629a194edfeab68b", "transactions":["0xf88f828317850ba43b7400832dc6c0944873528341d33ec918c7465f244491acb75bc95f80a4a0712d6800000000000000000000000000000000000000000000021e19e0c9bab24000008401546d71a08fcaf736322dfc21a5b7f130f6322498f4d3edefe5736ed9ec2e4fa62416cfeba0277ce00b907f9a51e7244d7057cf87b82c51d663bea88f081247f3e89c811b8d","0x02f8d883aa36a78301796885037e11d6008503c04cb416830493e09419fc4f304c1198c8ae1c23630a1611b27883693a80b864127e94515b9f10064bf8d747203a7b8070ff7d8268fc52d28fa25520f3b52902b1c9122a0000000000000000000000002c718a8053b649b29e23e833e18ba4412952c14bfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe70c080a07680861821d92cac56fe18783f78165f8cbf0be4f59f8f19370de7cd247a3a31a07db28cc5c9ae0873c8751edbc4ce79ff80aa9bfe8545ed94708aa06cbeb352ab","0x02f87a83aa36a783b38e928501dcd650008502a18851008255f094b9c8323843cec57ffd37ddf0105e028113c2b43d8806f05b59d3b2000080c080a0712d3d1d37881fba58cd7f08df9ff50507b26d7849c6c90fea6a72675d728b94a0060d9d9274e30dabf507854bfaa19b15405889c4859af757a23e6f0754440391","0x02f87a83aa36a783b38e938501dcd650008502a18851008255f094965ee94053e61d842106d8da5cb9c7eddefeadb38806f05b59d3b2000080c001a0a1925c0cf61486d900e01a7052616edccdcb5d057c289b6b405491cdef82ff51a049a1684742574bdfa59237579cb8bc85eb40709f14300c6b4697524b730a8c26","0x02f8b483aa36a78085013023a14485013023a14482d5089408394e7e653472694ecd4527656b2881e5701a1480b84440c10f19000000000000000000000000c799fe168e3f2253b1b2fc18fad38b5f8951a7af00000000000000000000000000000000000000000000000000000000000f4240c080a0673fdcc2f19c59293d45fd7120b008064f70573904848285c25fb64cc6e8b85ea02c4ccd33efeba5daee60a65ecbe2b2fe5ae7a35db63286fe9d42d021e4f313a5","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","0xf901d58085010a2626b08309eb109419c7680f666e51a6086c270e2aa2a517ae585d05860d0c55ce6bc2b901642e325e040000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b6f4a8dccac0beab1062212f4665879d9937c83c000000000000000000000000000000000000000000000000058d15e176280000000000000000000000000000aee05bf707311799e707b7ff67df6386d7311800000000000000000000000000aee05bf707311799e707b7ff67df6386d731180000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1bfe2cad7ef4e6a70d595a8c8d26e5b1dd1fc77f95481d29932f3fe5eb06158e2b74d9bb185b5a551c093e7831d262d3d0ec7c6f462744c96ecb3379fc53f33de6000000000000000000000000000000000000000000000000000000000000008401546d71a091e2ff4ccd0418066c1815be976ca57c01882f8a12057edf549f8c75138fd0a5a07712e8dab636b146bdb3381a839c2e62b97d9a026d9596687f800abbaf55a9f7","0xf874830c35b8850108eb78588301482094914e58348ec3bc0f6b9658a2c43b258323ec8eb68806f05b59d3b20000808401546d72a095731ec36b6f1ce0bb043c627f16db8c873d38da67aabf7133ea5cc679fa1de5a03b985c9348a17ed4ce9b07dbc0a0c6ebf210a1743dfb918256e2ecc70ac57254","0xf874830bb8d1850108eb7858830148209420275c43e677586f48ef37158dda42f80d45cd9d8806f05b59d3b20000808401546d71a0726172ce6de61122bc338269d832427b8527bd244377f88cbd199ef9a21b9289a0566dc985a32a2d001071f07cf9b626751c4817c2d72a1a44de0bd1eaffb4d454","0xf874830af78c850108eb78588301482094a55b483606c5ec9d92e25e6b139935329ec2d28a8806f05b59d3b20000808401546d71a02e878d2572aa378c7f24acd39b23cff51608db8b5bd8acb666431b1a83242e59a0768083ae736ff5243b832ada957494cd43f86d7edc2c4901c85f80b2cb1a1ab9","0xf874830ade7e850108eb78588301482094ed5612624e2fd5f5954137b41e8f7a3f5378cbd78806f05b59d3b20000808401546d72a02020638007001378729eeacaf525d665d7f8b0b66ee47b00100a65c632607156a0110cb949fe9ebe13a6cd0ed00a6f69caf8e737a8bdc72e8e885620d4006f0560","0xf874830cd996850108e6d90c83014820949aed55be7ac0d3727e4dcc1073746a74598bae428806f05b59d3b20000808401546d71a0da95b9bf7fc24e4e562b27223183bde5e99cebab518b69001f80b3bc78cac54fa05edce4c2defa58703dcb368792aeeebde328a949028e01ee85e41c74a4c335a4","0x02f8b283aa36a72784f50a144384f50a144382b63e9401fa8deeddea8e4e465f158d93e162438d61c9eb80b844095ea7b3000000000000000000000000321ce961084fcf3a56de4be2f2006707a0421aa4000000000000000000000000000000000000000000084595161401484a000000c001a04d9829627dda62ad7561b50fe2eabe3be64016f0c1c48eac6554589f1332f670a065db2043c2cb2052e0e1a3de190510cb5ef8c92014cc437f4d62649bce48bb2a","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","0xf904108229948484736c86830327169433cafa2e5d5167806b236f5be9734ddce8706bfc80b903a42b0006fa000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000072dd00000000000000000000000000000000000000000000000000000000000072dec69080ecfe089df86a093d59903f41924e0995cbf084044031c698ea57270b42235b3a48ca14d2f68266f341124221593009649c5e7115e80243a83d5738b3ad20227cbcef731b6cbdc0edd5850c63dc7fbc27fb58d12cd4d08298799cf66a0512c230867d3375a1f4669e7267dad2c31ebcddbaccea6abd67798ceae35ae7611c665b6069339e6812d015e239594aa71c4e217288e374448c358f6459e057c91ad2ef514570b5dea21508e214430daadabdd23433820000fe98b1c6fa81d5c512b86fbf87bd7102775f8ef1da7e8014dc7aab225503237c7927c032e589e9a01a0eab9fda82ffe834c2a4977f36cc9bcb1f2327bdac5fb48ffbeb9656efcdf70d2656c328903e9fb96e4e3f470c447b3053cc68d68cf0ad317fe10aa7f254222e47ea07f3c1c3aacb74e5926a67262f261c1ed3120576ab877b49a81fb8aac51431858662af6b1a8138a44e9d0812d032340369459ccc98b109347cc874c7202dceecc3dbb09d7f9e5658f1ca3a92d22be1fa28f9945205d853e2c866d9b649301ac9857b07b92e4865283d3d5e2b711ea5f85cb2da71965382ece050508d3d008bbe4df5458f70bd3e1bfcc50b34222b43cd28cbe39a3bab6e464664a742161df99c607638e415ced49d0cd719518539ed5f561f81d07fe40d3ce85508e0332465313e60ad9ae271d580022ffca4fbe4d72d38d18e7a6e20d020a1d1e5a8f411291ab95521386fa538ddfe6a391d4a3669cc64c40f07895f031550b32f7d73205a69c214a8ef3cdf996c495e3fd24c00873f30ea6b2bfabfd38de1c3da357d1fefe203573fdad22f675cb5cfabbec0a041b1b31274f70193da8e90cfc4d6dc054c7cd26d09c1dadd064ec52b6ddcfa0cb144d65d9e131c0c88f8004f90d363034d839aa7760167b5302c36d2c2f6714b41782070b10c51c178bd923182d28502f36e19b079b190008c46d19c399331fd60b6b6bde898bd1dd0a71ee7ec7ff7124cc3d374846614389e7b5975b77c4059bc42b810673dbb6f8b951e5b636bdf24afd2a3cbe96ce8600e8a79731b4a56c697596e0bff7b73f413bdbc75069b002b00d713fae8d6450428246f1b794d56717050fdb77bbe094ac2ee6af54a153e2fb8ce1d31a86c4fdd523783b910bedf7db58a46ba6ce48ac3ca194f3cf2275e8401546d72a0c28451ec7799c6a1692b8b5fbdc3982a7af3a4ffea90db1a67ac6e12f4610966a05d5a773b7ad73c5fbc4e57e715ea902cc8028a4d926b2166c1450e4c9416a674","0x02f87883aa36a7830c1796847735940085746a5288008252089423c5f78b35b945163b7c4834cacf3cb03d36c2b587b25953d844290080c001a0b743453784794ece06aab5674a7e2a00298f8c7bab4ff9b4234f0f946d2e1f0fa03cba8b238e4b3c67c3513cb98e281c42f307d9d16d6604e2e61a3a09035b968b","0x02f87883aa36a7830c1797847735940085746a52880082520894bfcdba8331d02cf265448bbfdd338ddd6cca263087ba44cf3a95d90080c001a0905c6f775e0bc7150f83373ea680743e064994266ab4853a1766e2730a15d8f3a00d96c43cc42ef11f9fcd778b882a4fb18bd704655a29b1a9f849e609f4214dd1","0x02f87983aa36a7830c1798847735940085746a52880082520894e7af3966a2303cbaab0d824b7acbe6518ebfba1a881d5d0f774ceb120080c001a056c850281ab9e3dfd788e64af2cd1f09ff259b2f06bb12969f3acd45a626b3d5a054582a8567c3800bf2a49b53aaa215dbd19ee2e038af34fb4fe975706176d754","0xf86f048460d26080827b0c941ed29c10e661e5721dfe162845f72548f090d8e78803d0ff0b013ba544808401546d71a0280f65b44c3a91a61d0a193ab6c6e80a7c5f071498386a4403626ad17a7f819da0274cb676983621230c472ef749061039ae88e3d33f5f08cd219ff5984051623b","0xf86f018460d26080827b0c941ed29c10e661e5721dfe162845f72548f090d8e78803d0ff0b013ba544808401546d71a0d37e39fc4c4dd84af425a5123d48f4c6369c5bf388f4e9984683c01abfba8e90a017cf0dff5dc0c280d4b562d742950774fcc6144648fb4c85906ca3c0e7385123","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","0x02f9017683aa36a781b88459682f008461d00b6f8401b2e0209419c7680f666e51a6086c270e2aa2a517ae585d0580b90104faa9bce90000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000b31c077c99e0d61305fcd873a39f974d13bc773c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1b45188ccb74751133eb81ec5f059fd3101ee73ebafee8ea007407f5d0f30c50ea5240cd8f54223e2bf9d45da6c98feb9d40fd6bb18b67eb0ac2ea23e587874cbd00000000000000000000000000000000000000000000000000000000000000c001a0ea6c2fd48a0d181544124b58e8d0ebab38b407dd5c6519e61c5f074311f8f34ba03b731a85472942ea0267af3b71cc58f7c5fb2931099f2526f3a3105c939e2493","0x02f902fc83aa36a7068459682f008462d9f23f8302f63b943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad8809b6e64a8ec60000b902843593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000065ec277400000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000009b6e64a8ec600000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000009b6e64a8ec60000000000000000000000000000000000000000000000000000018e06363c66e3eb00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bfff9976782d46cc05630d1f6ebab18b2324d6b140027100305ea0a4b43a12e3d130448e9b4711932231e83000000000000000000000000000000000000000000c001a04ab810c66296497f7d275c8cbdf7ebc5a91ea14f9341316e31ec7949094d4e20a009f15f6e9a4dd182d81ae5bd08340ebcdcd7492e267070bf35b30eb44f39a418","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","0x02f902fc83aa36a73f8459682f008462d9f23f8302e8fc943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad88077e772392b60000b902843593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000065ec277400000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000077e772392b6000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000077e772392b6000000000000000000000000000000000000000000000000000001330cd97b0d4ef900000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bfff9976782d46cc05630d1f6ebab18b2324d6b140027100305ea0a4b43a12e3d130448e9b4711932231e83000000000000000000000000000000000000000000c080a0a8fe19cc48a5c5b041d6fb96c4283a6f38bd7475d4ca1f37c77409c26ce68a40a04aa9db8ba0200dd02fb5cbf926a5619f6a34f7b2ca35d122256157da0a41b21f","0x02f8b583aa36a78201058459682f0084630562cb8302d7f694b31c077c99e0d61305fcd873a39f974d13bc773c80b8447bde82f200000000000000000000000000000000000000000000000002c68af0bb1400000000000000000000000000008334b2380a85d14f4366bfd52634a083382639adc080a0a0a2f59bad445d33b33a0179abb498751e5cea7799d8de66806ad79991146e4fa03b2917c3ac96b335b87959c8888caa236904a28b1e2c2f076910733874ae75ab","0x02f902fc83aa36a7028459682f0084630562cb8302f63b943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad880de0b6b3a7640000b902843593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000065ec277400000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000023898944434e94e00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bfff9976782d46cc05630d1f6ebab18b2324d6b140027100305ea0a4b43a12e3d130448e9b4711932231e83000000000000000000000000000000000000000000c001a063d5d7fad1c62eb2dd1e01dbdaae93cf845a851fece39c6bd74f9cd155db0990a0667f8246c6a198632d32f4495aa8ef89ce0137c0375a38ec88d3c3ceb0468de3","0x02f902fe83aa36a78201388459682f0084630562cb830292b7943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad88016345785d8a0000b902843593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000065ec278000000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000016345785d8a000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000016345785d8a00000000000000000000000000000000000000000000000000000038dac33485e30c00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bfff9976782d46cc05630d1f6ebab18b2324d6b140027100305ea0a4b43a12e3d130448e9b4711932231e83000000000000000000000000000000000000000000c080a01d35d727bc6611daca011098e403081c611b94cb58a644ac1617005c95541083a037c296c97d1617b044c91000caaed68fa7f81dcdb96e8d09d15f9b408f36e22e","0x02f87483aa36a7018459682f008462d9f23f825208945e809a85aa182a9921edd10a4163745bb3e3628487160ff64c0e33a980c080a0179beb93e9b7f9200b08dd7e8473b5aa5d6e2757b389e771f68ac6e0b3e85c57a0131cc6d17980908975aa53305ab35391d7c8a40755fc74131f5431bed77c0bb7","0x02f87483aa36a71f8459682f008462d9f23f8252089446e53434b77c7a301b54ff4f01b3c05f5688576687b1a2bc2ec5000080c001a08c29517e09da96947a545ee66cec1bb8f833ac711aa0460673798244212e2600a0723eb2fa32e194210220febd93652d66f04c59527405d563cb0883e6d289feeb","0x02f901da83aa36a70d8459682f008461d00b6f8309eb109419c7680f666e51a6086c270e2aa2a517ae585d05860c1d93b2e642b901642e325e040000000000000000000000000000000000000000000000000000000000000001000000000000000000000000b6f4a8dccac0beab1062212f4665879d9937c83c00000000000000000000000000000000000000000000000000071afd498d00000000000000000000000000002a7306d74ec5cc82ed3685d387fadcc5ed0c06550000000000000000000000002a7306d74ec5cc82ed3685d387fadcc5ed0c065500000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1c7ec5692ccfc700dc340b3902a8e4f8d1dab0c4fc9fa4541d2ca64d49d36b158d6af6e5e21548b6d0fac426bf034b88ce44d080f0be4d985b0e6aa0431b6da63c00000000000000000000000000000000000000000000000000000000000000c001a0890e8992dc344f0929e1c5af123aafd2320303a9b328d287a1fde98ecb2d6b2fa07ad9f35d65f83d79955e3ec449e1121707108d421854a4dcf60b0b9143a012dc","0x02f8db83aa36a7118459682f0084630562cb830e6f0d941b240fa1e884cb5e09a7a22edf2563f371c5f8828803782dace9d90000b864b1a1a8820000000000000000000000000000000000000000000000000000000000030d4000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000c080a0874bf3789870b7a8b18cd54bc76860f561ab829cce28ae8f0e84fe907c9ac0c5a00dbeee510cab64436466a4af0316aad0b92aea33ca430ea2dabc95d3c70579b2","0x02f87483aa36a7018459682f008462d9f23f825208945e809a85aa182a9921edd10a4163745bb3e3628487166ae95c8873a980c080a0b2afd01021652e58153b0c5fb5ed0eeb67e597cd89cd56be94dbd16d99620878a06e32970f4ba0f1789dc5275f6f4cf21c8e60aa9980fee60eb607cfd99635e80d","0x02f901da83aa36a73e8459682f0084630562cb8309eb109419c7680f666e51a6086c270e2aa2a517ae585d05860d0a3822d182b901642e325e040000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b6f4a8dccac0beab1062212f4665879d9937c83c000000000000000000000000000000000000000000000000045cf1dfa23867bc000000000000000000000000d06c414d539fd06d3d1a13c2985a0b8c765e8363000000000000000000000000d06c414d539fd06d3d1a13c2985a0b8c765e836300000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1b42cea67aec5cae595656a61cbee1db9e1a3ec699cdd2188ad03e37ae1608c2315e5069a16331171fbb9a0425e4a8c5823d239fc14377e0da54f9bf041acdc99000000000000000000000000000000000000000000000000000000000000000c080a043eca376fdd4c0f062fd5068ebeec83c795f7c2d88b8d3d1a6126e5548876342a00774387c2fedb695b834b0169cd9b6ce19c032b9f645f528abf73d230e43f381","0x02f9019c83aa36a7428459682f008461d00b6f8301ad5394d13d092f9813f6afb9230cdb76f370ddccba20f08802c6e95663fe5f80b90124679b6ded000000000000000000000000c3aac133ba5895e0c930bad02023e342f3efc8fa00000000000000000000000000000000000000000000000002c68af0bb14000000000000000000000000000000000000000000000000000000005acba685af80000000000000000000000000c3aac133ba5895e0c930bad02023e342f3efc8fa000000000000000000000000c3aac133ba5895e0c930bad02023e342f3efc8fa00000000000000000000000000000000000000000000000000000000000493e00000000000000000000000000000000000000000000000000000000000c96a8000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000c001a075bdb8a54e1d1bca9b4307185caa37ba256c0ad73d4d1d8e6259313bdb0cb730a049c664610194ed1c1950f2a2163d606e036f4ec1d8d14ff53e797a0e52b834bf","0x02f87583aa36a7028459682f0084630562cb82520894f32d473da97b831c1025ba7eee80e57d4013c99b8803fb7c9980bf000080c001a009a5c41644a22facb3916251d3eeb22e85d2afa9ca341c46357ee5dfdfacd6bba00126b7ec1ec696d4dfa22c6caa99481dec90ad4b9200f9334a97a63eaccc5584","0x02f9017483aa36a7018459682f0084630562cb830755769419c7680f666e51a6086c270e2aa2a517ae585d0580b90104faa9bce9000000000000000000000000000000000000000000000000016345785d8a0000000000000000000000000000b31c077c99e0d61305fcd873a39f974d13bc773c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1c443c831aff82b2dc0eaa537e42fe3087a084c35d39a123d8ff56886da7b0d8b2766fa00667ed35d48dce449a11b82b6c52c92ef6a2d0bffe014d2b37c651beee00000000000000000000000000000000000000000000000000000000000000c080a074b650718466a0a060b0bbd7da46a9393a6c14e4966f9c8a6f2155c12ce702f8a07dba87b7e4d1e64183ccf71f024c3ee4798f3a8b2488369463a38b073f29c541","0x02f902fc83aa36a7588459682f0084630562cb8302f5e1943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad881b0fcaab20030000b902843593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000065ec277400000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000001b0fcaab20030000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000001b0fcaab200300000000000000000000000000000000000000000000000000000454b331f4c63a0600000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bfff9976782d46cc05630d1f6ebab18b2324d6b140027100305ea0a4b43a12e3d130448e9b4711932231e83000000000000000000000000000000000000000000c001a0ea17b7721aa6bf3b022be99d0240892747417640e2b09aaa13d68d63a3811df5a06b1a92d6056b362cb6fb4c333e5599b654a8f9ce14ed2da76bcd52e85ff3a40f","0x02f87483aa36a7018459682f008462d9f23f825208945e809a85aa182a9921edd10a4163745bb3e362848715d04c26ebd3a980c001a0a4c2625ede867c6310896ccbe03fc157f143fb07ed038e65bd8c85de4f96055ba035363af57c6c158b1902d5a2608f8b51bf54583955db461cd842d899cd94671e","0x02f8dc83aa36a782048a8459682f008462d9f23f830248ba94b9a60416f2dea96c07a9ab53e35350888d2d67e08720a0125de6c000b864c25dc7bc0000000000000000000000000000000000000000000000000000000000000c2600000000000000000000000000000000000000000000000000038d7ea4c68000000000000000000000000000a19874046c0afdddf42757e094f45cbc0bfd649bc001a05fad3f331010a026faa7223c81431592107c21963f1d829c0fba5fae787045c9a023f9841ec4438c7129e631e1377c9af37e78660427e7fa91645a2ef4caa1c0a9","0x02f87483aa36a7018459682f008462d9f23f825208945e809a85aa182a9921edd10a4163745bb3e36284871619f76f25e3a980c080a0372888d87046421b7d60ac06b75d55d26e4679f7ca585106832035bbf6d7eb69a07934b938e5a1eb190f72c6917bb3ba0b2ba22833d2bc43ee98912a82993acf4b","0x02f8b283aa36a76e8459682f008462d9f23f82b652944b8eed87b61023f5beccebd2868c058fee6b7ac780b844095ea7b30000000000000000000000005699f1bc92b8e61aad266f658de9c968631105230000000000000000000000000000000000000000000000056bc75e2d63100000c080a0e3f8cf21c0c987e718839478bc4c255179e262f7a382d20a6da2e0804abe0214a062742564b43928aa00e7740109d0874670f6cb2165f8fdcdfecca2ed7e50fdaa","0x02f9017583aa36a781ae8459682f0084630562cb830689d19419c7680f666e51a6086c270e2aa2a517ae585d0580b90104faa9bce900000000000000000000000000000000000000000000000000b1a2bc2ec50000000000000000000000000000b31c077c99e0d61305fcd873a39f974d13bc773c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1c2717b89df289ff56f2fa5d410cccf52904d7ec3b0f9e5b2c698e07be8486abb8524ff83ef5678d60846d0e4ccf7dd1bc84fb150e1d612ad492498820719f9b9c00000000000000000000000000000000000000000000000000000000000000c001a0cf19b29b5ade6cfd4d02efb07a19199c2130495e2a5394c84c6bb05b3f56bf89a037e8c423b623225a1cc3592aa42daef918e89ac6e5798c02ca22b64d189f04bf","0x02f902fc83aa36a7048459682f008462d9f23f8302e8ba943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad8806ccd46763f10000b902843593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000065ec274400000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000006ccd46763f100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000006ccd46763f100000000000000000000000000000000000000000000000000000114f435a31a2d0f00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bfff9976782d46cc05630d1f6ebab18b2324d6b140027100305ea0a4b43a12e3d130448e9b4711932231e83000000000000000000000000000000000000000000c080a0877d6c5c52c51f85ec1b5fb474f4900ae77bc744c41819792cec739b5d15e82ca004a3ecfb91548c9b1f87cf1c9e119c82537970fb44aadd92cb12527cab011456","0x02f9017483aa36a7018459682f0084630562cb830689e39419c7680f666e51a6086c270e2aa2a517ae585d0580b90104faa9bce900000000000000000000000000000000000000000000000006f05b59d3b20000000000000000000000000000b31c077c99e0d61305fcd873a39f974d13bc773c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1bba3de764afee699adb13ebc1be6c6823f67d1802230ad3fdbef6f01f7ad1738925f8fa08927ac8fbf2532dee91ed8ff7423614520db9f34c527d664026c1521500000000000000000000000000000000000000000000000000000000000000c080a02d0d667c36bbd9205df55e6ca26a4b98bd68936245931f1fdeceeb165a3e62c3a00b7b0193a5f22b85c428f50bef33a13316a2b947c60cfa3a0ee3127e607a1b01","0x02f902fe83aa36a78201388459682f0084630562cb8302a4e1943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad880de0b6b3a7640000b902843593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000065ec278000000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000023883e27a56832d00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bfff9976782d46cc05630d1f6ebab18b2324d6b140027100305ea0a4b43a12e3d130448e9b4711932231e83000000000000000000000000000000000000000000c001a07ee13472fef5d9c6be9054268b54d936189952058ab59ee2475c12d410ca5741a02cff07a888b29694e44f871eb92da5b1c521bbb8d321379da7238845922d9c40","0x02f9017483aa36a73e8459682f0084630562cb830689bf9419c7680f666e51a6086c270e2aa2a517ae585d0580b90104faa9bce900000000000000000000000000000000000000000000000000470de4df820000000000000000000000000000b31c077c99e0d61305fcd873a39f974d13bc773c00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1b88370c04e89a0cacdf03ae09222d305c59a42e2bfa9dfc603af6304a4fbf35b5401f0f55e94a6e10005d3a5eadb4b896a5c9ada5e9c692d1c16cfb1d131474ea00000000000000000000000000000000000000000000000000000000000000c080a0ae173cc9563fde7e7b296fd6454a7ffac1945b140884bd1bcc86c6407e2cb482a00985b112c17dd36aa3d0566afd4b1587bdc36e5bb9cf3eb7f3442e1acb641592","0x02f901da83aa36a7258459682f0084630562cb8309eb109419c7680f666e51a6086c270e2aa2a517ae585d05860d0a3822d182b901642e325e040000000000000000000000000000000000000000000000000000000000000001000000000000000000000000b6f4a8dccac0beab1062212f4665879d9937c83c00000000000000000000000000000000000000000000000001cdda4faccd00000000000000000000000000003d3d8cada4ae176801222fb6693520a5329fa9d10000000000000000000000003d3d8cada4ae176801222fb6693520a5329fa9d100000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000061ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1c3edde24be770998e9575ae92af125aa62eca343f8bb772dfe85ac29ef2efdd25591bb1b845b80aaa55a1a14a5be2a7b45056d9c48b2827fc4ec67f2ced33991300000000000000000000000000000000000000000000000000000000000000c001a05970e773f8c58c74d514ccc8949bc628f5f2579b5ded158d0221c8eb7338a511a039f8087d69f5c0e1bfb5b38b221c6ddd17a698e192827c8d4819803f78c924f4","0x02f8bb83aa36a77f8459682f0084630562cb8302e34294ab260022803e6735a81256604d73115d663c6b82881e75a6c3083c7c00b844592de11d000000000000000000000000dfe738894d90efe91f796fd1fdfb6a486a90e2b80000000000000000000000000000000000000000000000000000000000000019c001a0586247735164f942bf0b5d4ce26078ac9856db2de25a31efab21095cd8a98ef0a0597610109db5296873fede2c95bdde8fc40b15ba3e07dedc1967d88d7d2bba94","0x02f9019d83aa36a781838459682f008462d9f23f8301ad4694d13d092f9813f6afb9230cdb76f370ddccba20f0880163a318baa32700b90124679b6ded00000000000000000000000093404bcb286f234286e1bb26bc79c298da89b63a000000000000000000000000000000000000000000000000016345785d8a000000000000000000000000000000000000000000000000000000005a065ab4770000000000000000000000000093404bcb286f234286e1bb26bc79c298da89b63a00000000000000000000000093404bcb286f234286e1bb26bc79c298da89b63a00000000000000000000000000000000000000000000000000000000000493e00000000000000000000000000000000000000000000000000000000000c96a8000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000c001a09952f5f1e24e916cc585bdd33a8f5182a99956648227d1b6524b700c1c2f093aa07a03cd1160caf36bbe7dd29386e4f5ebaab1a04fb7de3858c0b7347c6279ccef","0x02f8db83aa36a781908459682f008462d9f23f830248ba94b9a60416f2dea96c07a9ab53e35350888d2d67e08720a0125de6c000b864c25dc7bc0000000000000000000000000000000000000000000000000000000000000c2600000000000000000000000000000000000000000000000007a1fe16027700000000000000000000000000004c66a65fd9c7b0136fbf1ba4617521ba39379c43c080a08f4e752a49bcabd1197e21d8e74428ed8dd8478b64790248e4fb6b9e4460afbfa01559ac0d0980f5d0ed9bb779b7c2eaa277d3f997da3983011436f79ea052575d","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","0x02f87783aa36a7358459682f0084630562cb83018f0994120de9fcc9b1cca7e071fbc9ee500a7b69980ec685018cf789008400000000c080a0b12bf5902aeb7b08323081ecd77a411eb88ff218c95c8da341b6fa89a8e1dd80a066eeb6edd6e17a2d2c66c25173c604a50cdc7f08d790499fc6748ed3573a0cb3","0x02f87483aa36a7108459682f0084630562cb82520894e927025831c569e48df971f6818b061910920a53872386f26fc1000080c001a0c0ae976389cedfe0f9420be80ca927ad1cbc537391c743690cce7affedfc3796a07624eb9c2307be1910cec58a036fb05f5a40c7ad4131764da97a83d0587515a5","0xf902708297c584561953e98313d3d494f68f872f0dde0ec1ba8c28eed9d0674760aa8eb180b90204e7d811960000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000018000000c2600aa36a700000000000000000000000000000000000000000008e3d8966c63d14939ec9ace2dc744f5ea970e1cc6f20f12afefdcdff58ed5d321637e0000000000000000000000008e7dffb6d9b89b3701dcf1ef49e30e90610c88cf00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000f2e50b1753cd1588e33f38bb78f1d609916d92bc00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000d529ae9e86000000000000000000000000000030e3a4286e227968fe3c8957f61c568a55ef62480000000000000000000000000000000000000000000000000000000000000041ee2d46552384f2b47336fd4a3afd8084259259788b8ecbfff67d9c74b658245e5590cac521c6834af12e7dca863edae2465182dfbd678ae58690f57fd61de4301b000000000000000000000000000000000000000000000000000000000000008401546d72a028dddabef21aba0a51f6886777f973d2747f1e68c48775fba9eb8909af996be1a0532cc002d0b196f0225c7b9ffe525b236edc1e94bd9a337b6a28cfa43b992fe8","0x02f9025683aa36a782fb5d843e4b406a8447e75bab8302de9494cf8edb3333fae73b23f689229f4de6ac95d1f70780b901e409c56431f0ee4e010d5502a33eef1fe2fcdba19c5345eb160078d9dee2b47cb96edd4e6a0000000000000000000000007506c12a824d73d9b08564d5afc22c949434755e00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000065ec253b0000000000000000000000000000000000000000000000000000000065ec28bf66348c483727fb2eb578ccd1e2240d2113f20367fec28e95a9d613cdb516e2bb8d618511d2d85ca1cd13cfc65a40179be41b0cae91b81b1e8cfadaa15ca492bc00000000000000000000000000000000000000000000000000000000000000c4da2ff2f546bc2970c11ab5255dcf452cbd6a4da50547ff1f8cf7c8a5708810d52eb85fe20000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000004189ae420141c046a651b88b37c70cae3726cf48d8b561f4fc79feb8b910860f1e1ebdde770ef7ea5ce72493d2d2b6bc9a79b530c57fea7e591a4b1a197c7cce8a1c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c001a0280d27bf5f0a7e00a125a742c0727ca18dda3ab2b1e1171133f1b6ccdf918f30a0722d537cade98c4799852077b3100c999bda5a9b1fa02fc3deea0bed0f1539de","0x02f8f583aa36a7821401843b9aca0084b2d05e00830156c29475a6b961c8da942ee03ca641b09c322549f6fa9880b8849aaab6483bfe8a55f85a2a91f45ddc40b097dfef45b2dd245cf347aec2a0bbac31bc163e00000000000000000000000000000000000000000000000000000000000e1168cf952fe6650f909d96c72da5bfa9056284a3ccd733bec61b3cad3e2c6fe3857c0000000000000000000000000000000000000000000000000000000000532180c001a07fbc2d9293870837043367909d42882002b33f54adabf25fe59c2d7432180e54a039eedc65f9ca9e16465b15314b43f11a3964d1ad799db1b0c7b5031eae5a252a","0x02f9011383aa36a78305b53a843b9aca0084b2d05e00825bbc94ff0000000000000000000000000000000004206980b8a200b45ef8dbdc47267ddffe8775fe84ff8e00000000008a78dadae1cff0c36781c7977ebb87ef238fb684a45cdeb5299d937169c40e569dde637ffb788fba24164635072b362ef0363f3fdbf47f4eed834737e7f389f22ffd1366e61593dda2d4bedc7011c781568d96d437aa46072006fef799b1a6b9f13f97e9bacceb3fdf983f4c39a7beb3605afe824f1382e29e5bb6b3106da0f90140000000ffff74e34f2b01c001a0ca432943bd2f4d3b5766b4a855dc137e9c4651ccfdf3221c1346006e495b3f0ba01448a7fbc3837feb3a7f8426899b752d7c8d6b5df78140fa356969dea950cd8d"], "withdrawals":[{"index":"0x257c870","validatorIndex":"0x1de","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c871","validatorIndex":"0x1df","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c872","validatorIndex":"0x1e0","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c873","validatorIndex":"0x1e1","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c874","validatorIndex":"0x1e2","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c875","validatorIndex":"0x1e3","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x38c64"},{"index":"0x257c876","validatorIndex":"0x1e4","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x38c64"},{"index":"0x257c877","validatorIndex":"0x1e5","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c878","validatorIndex":"0x1e6","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x38c64"},{"index":"0x257c879","validatorIndex":"0x1e7","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x38c64"},{"index":"0x257c87a","validatorIndex":"0x1e8","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x38c64"},{"index":"0x257c87b","validatorIndex":"0x1e9","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c87c","validatorIndex":"0x1ea","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x38c64"},{"index":"0x257c87d","validatorIndex":"0x1eb","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"},{"index":"0x257c87e","validatorIndex":"0x1ec","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x38c64"},{"index":"0x257c87f","validatorIndex":"0x1ed","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0x36784"}] }, [], "0x705d84b4afc89d063429e34886b51a2d8844862acca72d9192ea5f1d0903dd21" ] })"_json; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator engine_newPayloadV3: patch gasUsed regex", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; // gasUsed regex at commit 5849052: "^0x([1-9a-f]+[0-9a-f]{0,15})|0$" does not work for input "gasUsed":"0x0" // gasUsed regex patch: "^0x([1-9a-f]+[0-9a-f]*|0)$" auto request = R"({ "jsonrpc":"2.0", "id":23, "method":"engine_newPayloadV3", "params":[ { "parentHash":"0x89524ffba439f613e30cff04611bf1e8dca0ab013e3db80af09b5d687dff1201", "feeRecipient":"0x0f35b0753e261375c9a6cb44316b4bdc7e765509", "stateRoot":"0x3844a42d6aca69fac803e3c891e0841242908b8e55cab1561fd7d1a417fe9b80", "receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao":"0xa6846c71318111439896fe1f6f00f4def93c0527889aa43aa20acfbeed586dda", "blockNumber":"0x5321b0", "gasLimit":"0x1c9c380", "gasUsed":"0x0", "timestamp":"0x65ec272c", "extraData":"0xd883010d0b846765746888676f312e32312e36856c696e7578", "baseFeePerGas":"0x817760c", "blobGasUsed":"0x0", "excessBlobGas":"0x4c80000", "blockHash":"0x9db7d47eb2a5d03c56b8f437c9c29bd6ebd9688107b519263401d56ccfc3a8df", "transactions":[], "withdrawals":[{"index":"0x257cb00","validatorIndex":"0x611","address":"0xf97e180c050e5ab072211ad2c213eb5aee4df134","amount":"0xec0"},{"index":"0x257cb01","validatorIndex":"0x612","address":"0xf97e180c050e5ab072211ad2c213eb5aee4df134","amount":"0xec0"},{"index":"0x257cb02","validatorIndex":"0x614","address":"0xf97e180c050e5ab072211ad2c213eb5aee4df134","amount":"0xec0"},{"index":"0x257cb03","validatorIndex":"0x622","address":"0x388ea662ef2c223ec0b047d41bf3c0f362142ad5","amount":"0xec0"},{"index":"0x257cb04","validatorIndex":"0x191","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb05","validatorIndex":"0x193","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb06","validatorIndex":"0x19b","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb07","validatorIndex":"0x19c","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb08","validatorIndex":"0x19d","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb09","validatorIndex":"0x19e","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb0a","validatorIndex":"0x1a3","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb0b","validatorIndex":"0x1a5","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xec0"},{"index":"0x257cb0c","validatorIndex":"0x1a7","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xb10"},{"index":"0x257cb0d","validatorIndex":"0x1ab","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xb10"},{"index":"0x257cb0e","validatorIndex":"0x1ba","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xb10"},{"index":"0x257cb0f","validatorIndex":"0x1c4","address":"0x25c4a76e7d118705e7ea2e9b7d8c59930d8acd3b","amount":"0xb10"}] }, [], "0xc3e3a313cb5b0e746326f0958cc5cbd931c5ccf9f6dde99e3ab0bd5d2c05d92a" ] })"_json; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator engine_forkchoiceUpdatedV3: null payloadAttributes param", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; // Payload attributes at commit 5849052 does NOT allow for null value auto request = R"({ "jsonrpc":"2.0", "id":37, "method":"engine_forkchoiceUpdatedV3", "params":[ { "headBlockHash":"0xb0433cd89f470c3b72275a28198a4bb5b31cb7095f81a230a20c1774d5b93557", "safeBlockHash":"0x636bfa7b1c7d804c97de4a4cc33239899cf0406ac7a128b3277342af9a2e00a4", "finalizedBlockHash":"0x636bfa7b1c7d804c97de4a4cc33239899cf0406ac7a128b3277342af9a2e00a4" }, null ] })"_json; ValidationResult result = validator.validate(request); CHECK(result); } TEST_CASE("Validator engine_forkchoiceUpdatedV3: missing payloadAttributes param", "[rpc][json_rpc][validator]") { Validator validator{create_validator_for_test()}; auto request = R"({ "jsonrpc":"2.0", "id":37, "method":"engine_forkchoiceUpdatedV3", "params":[ { "headBlockHash":"0xb0433cd89f470c3b72275a28198a4bb5b31cb7095f81a230a20c1774d5b93557", "safeBlockHash":"0x636bfa7b1c7d804c97de4a4cc33239899cf0406ac7a128b3277342af9a2e00a4", "finalizedBlockHash":"0x636bfa7b1c7d804c97de4a4cc33239899cf0406ac7a128b3277342af9a2e00a4" } ] })"_json; ValidationResult result = validator.validate(request); CHECK(result); } } // namespace silkworm::rpc::json_rpc ================================================ FILE: silkworm/rpc/protocol/errors.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "errors.hpp" #include namespace silkworm::rpc { // avoid GCC non-virtual-dtor warning #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wnon-virtual-dtor" // NOLINTNEXTLINE(cppcoreguidelines-virtual-class-destructor) class ProtocolErrorCategory final : public boost::system::error_category { public: const char* name() const noexcept override { return "rpc::ProtocolErrorCategory"; }; std::string message(int ev) const override { switch (static_cast(ev)) { case ErrorCode::kParseError: return "invalid JSON was received by the server"; case ErrorCode::kInvalidRequest: return "the JSON sent is not a valid Request object"; case ErrorCode::kMethodNotFound: return "the method does not exist / is not available"; case ErrorCode::kInvalidParams: return "invalid method parameter(s)"; case ErrorCode::kInternalError: return "internal JSON-RPC error"; case ErrorCode::kServerError: return "generic client error while processing request"; case ErrorCode::kUnknownPayload: return "payload does not exist / is not available"; case ErrorCode::kInvalidForkChoiceState: return "forkchoice state is invalid / inconsistent"; case ErrorCode::kInvalidPayloadAttributes: return "payload attributes are invalid / inconsistent"; case ErrorCode::kTooLargeRequest: return "number of requested entities is too large"; default: return "unknown error occurred"; } } static ProtocolErrorCategory instance; }; #pragma GCC diagnostic pop ProtocolErrorCategory ProtocolErrorCategory::instance; boost::system::error_code to_system_code(ErrorCode e) { return {static_cast(e), ProtocolErrorCategory::instance}; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/protocol/errors.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { enum ErrorCode : int64_t { /** Generic JSON-RPC API errors **/ kParseError = -32700, // Invalid JSON was received by the server kInvalidRequest = -32600, // The JSON sent is not a valid Request object kMethodNotFound = -32601, // The method does not exist / is not available kInvalidParams = -32602, // Invalid method parameter(s) kInternalError = -32603, // Internal JSON-RPC error kServerError = -32000, // Generic client error while processing request /** Engine API errors **/ kUnknownPayload = -38001, // Payload does not exist / is not available kInvalidForkChoiceState = -38002, // Forkchoice state is invalid / inconsistent kInvalidPayloadAttributes = -38003, // Payload attributes are invalid / inconsistent kTooLargeRequest = -38004, // Number of requested entities is too large kUnsupportedFork = -38005, // Invalid API version for the current fork }; // To raise a boost::system::system_error exception: // throw boost::system::system_error{rpc::to_system_code(rpc::ErrorCode::kSomething)}; boost::system::error_code to_system_code(ErrorCode e); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/settings.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { struct DaemonSettings { ApplicationInfo build_info; log::Settings log_settings; InterfaceLogSettings eth_ifc_log_settings{.ifc_name = "eth_rpc_api"}; InterfaceLogSettings engine_ifc_log_settings{.ifc_name = "engine_rpc_api"}; concurrency::ContextPoolSettings context_pool_settings; std::optional datadir; std::string eth_end_point{kDefaultEth1EndPoint}; std::string engine_end_point{kDefaultEngineEndPoint}; std::string eth_api_spec{kDefaultEth1ApiSpec}; std::string private_api_addr{kDefaultPrivateApiAddr}; uint32_t num_workers{kDefaultNumWorkers}; std::vector cors_domain; std::optional jwt_secret_file; bool standalone{true}; bool skip_protocol_check{false}; bool erigon_json_rpc_compatibility{false}; bool use_websocket{false}; bool ws_compression{false}; bool http_compression{true}; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/stagedsync/stages.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stages.hpp" #include #include #include namespace silkworm::rpc::stages { Task get_sync_stage_progress(db::kv::api::Transaction& tx, ByteView stage_key) { const auto kv_pair = co_await tx.get(db::table::kSyncStageProgressName, stage_key); const auto value = kv_pair.value; if (value.empty()) { co_return 0; } if (value.size() < 8) { throw std::runtime_error("data too short, expected 8 got " + std::to_string(value.size())); } BlockNum block_num = endian::load_big_u64(value.substr(0, 8).data()); co_return block_num; } } // namespace silkworm::rpc::stages ================================================ FILE: silkworm/rpc/stagedsync/stages.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc::stages { inline const ByteView kHeaders = string_view_to_byte_view(db::stages::kHeadersKey); inline const ByteView kExecution = string_view_to_byte_view(db::stages::kExecutionKey); inline const ByteView kFinish = string_view_to_byte_view(db::stages::kFinishKey); Task get_sync_stage_progress(db::kv::api::Transaction& tx, ByteView stage_key); } // namespace silkworm::rpc::stages ================================================ FILE: silkworm/rpc/stagedsync/stages_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stages.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::stages { using db::kv::api::KeyValue; using testing::_; using testing::InvokeWithoutArgs; // Exclude on MSVC due to error LNK2001: unresolved external symbol testing::Matcher Task { co_return KeyValue{silkworm::Bytes{}, silkworm::Bytes{}}; })); auto result = boost::asio::co_spawn(pool, get_sync_stage_progress(transaction, kFinish), boost::asio::use_future); CHECK(result.get() == 0); } SECTION("invalid stage progress value") { EXPECT_CALL(transaction, get(db::table::kSyncStageProgressName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("FF")}; })); auto result = boost::asio::co_spawn(pool, get_sync_stage_progress(transaction, kFinish), boost::asio::use_future); CHECK_THROWS_AS(result.get(), std::runtime_error); } SECTION("valid stage progress value") { EXPECT_CALL(transaction, get(db::table::kSyncStageProgressName, _)).WillOnce(InvokeWithoutArgs([]() -> Task { co_return KeyValue{silkworm::Bytes{}, *silkworm::from_hex("00000000000000FF")}; })); auto result = boost::asio::co_spawn(pool, get_sync_stage_progress(transaction, kFinish), boost::asio::use_future); CHECK(result.get() == 255); } } #endif // _WIN32 } // namespace silkworm::rpc::stages ================================================ FILE: silkworm/rpc/test_util/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(Boost REQUIRED COMPONENTS headers) find_package(GTest REQUIRED) silkworm_library( silkworm_rpcdaemon_test_util PUBLIC silkworm_infra silkworm_rpcdaemon PRIVATE silkworm_db_test_util Boost::headers glaze::glaze GTest::gmock ) ================================================ FILE: silkworm/rpc/test_util/api_test_base.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc::test_util { template class JsonApiTestBase : public ServiceContextTestBase { public: template auto run(Args&&... args) { JsonApi api{ioc_}; return spawn_and_wait((api.*method)(std::forward(args)...)); } }; template class JsonApiWithWorkersTestBase : public ServiceContextTestBase { public: explicit JsonApiWithWorkersTestBase() : ServiceContextTestBase(), workers_{1} {} template auto run(Args&&... args) { JsonApi api{ioc_, workers_}; return spawn_and_wait((api.*method)(std::forward(args)...)); } protected: WorkerPool workers_; }; template class GrpcApiTestBase : public ServiceContextTestBase { public: template auto run(Args&&... args) { GrpcApi api{std::move(stub_), grpc_context_}; return spawn_and_wait((api.*method)(std::forward(args)...)); } protected: std::unique_ptr stub_{std::make_unique()}; }; } // namespace silkworm::rpc::test_util ================================================ FILE: silkworm/rpc/test_util/api_test_database.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::test_util { inline constexpr size_t kDefaultCapacity = 4 * 1024; class ChannelForTest : public StreamWriter { public: Task open_stream(uint64_t /* request_id */) override { co_return; } size_t get_capacity() const noexcept override { return kDefaultCapacity; } Task close_stream(uint64_t /* request_id */) override { co_return; } Task write(uint64_t /* request_id */, std::string_view /* content */, bool /* last */) override { co_return 0; } }; class RequestHandlerForTest : public json_rpc::RequestHandler { public: RequestHandlerForTest(ChannelForTest* channel, commands::RpcApi& rpc_api, const commands::RpcApiTable& rpc_api_table) : json_rpc::RequestHandler(channel, rpc_api, rpc_api_table) {} Task request_and_create_reply(const nlohmann::json& request_json, std::string& response) { co_await RequestHandler::handle_request_and_create_reply(request_json, response, /* request_id */ 0); } Task handle_request(const std::string& request, std::string& response) { auto answer = co_await RequestHandler::handle(request, /* request_id */ 0); if (answer) { response = *answer; } } }; class TestDataStoreBase { public: db::DataStoreRef data_store() { return data_store_->ref(); } private: TemporaryDirectory tmp_dir_; db::test_util::TestDataStore data_store_{tmp_dir_}; }; class LocalContextTestBase : public ServiceContextTestBase { public: LocalContextTestBase(db::DataStoreRef data_store, db::kv::api::StateCache* state_cache) { datastore::kvdb::ROTxnManaged ro_txn = data_store.chaindata.access_ro().start_ro_tx(); auto chain_config = db::read_chain_config(ro_txn); SILKWORM_ASSERT(chain_config); chain_config_ = std::move(*chain_config); db::kv::api::StateChangeRunner runner{ioc_.get_executor()}; db::kv::api::ServiceRouter router{runner.state_changes_calls_channel()}; add_private_service(ioc_, std::make_unique( std::make_shared( router, std::move(data_store), chain_config_, state_cache))); } private: ChainConfig chain_config_; }; template class RpcApiTestBase : public LocalContextTestBase { public: explicit RpcApiTestBase(db::DataStoreRef data_store) : LocalContextTestBase{std::move(data_store), &state_cache_}, workers_{1}, socket_{ioc_}, rpc_api_{ioc_, workers_}, rpc_api_table_{kDefaultEth1ApiSpec} { } template auto run(Args&&... args) { ChannelForTest channel; TestRequestHandler handler{&channel, rpc_api_, rpc_api_table_}; return spawn_and_wait((handler.*method)(std::forward(args)...)); } private: WorkerPool workers_; boost::asio::ip::tcp::socket socket_; commands::RpcApi rpc_api_; commands::RpcApiTable rpc_api_table_; db::kv::api::CoherentStateCache state_cache_; }; class RpcApiE2ETest : public TestDataStoreBase, RpcApiTestBase { public: explicit RpcApiE2ETest() : RpcApiTestBase{data_store()} { // Ensure JSON RPC spec has been loaded into the validator if (!jsonrpc_spec_loaded) { json_rpc::Validator::load_specification(); jsonrpc_spec_loaded = true; } } using RpcApiTestBase::run; private: static inline bool jsonrpc_spec_loaded{false}; }; } // namespace silkworm::rpc::test_util ================================================ FILE: silkworm/rpc/test_util/dummy_client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::test { //! This dummy service acts as a factory for dummy transactions using the same cursor. class DummyService : public db::kv::api::Service { public: DummyService(std::shared_ptr cursor, std::shared_ptr cursor_dup_sort, test::BackEndMock* backend) : DummyService(0, 0, std::move(cursor), std::move(cursor_dup_sort), backend) {} DummyService(uint64_t tx_id, uint64_t view_id, std::shared_ptr cursor, std::shared_ptr cursor_dup_sort, test::BackEndMock* backend) : tx_id_(tx_id), view_id_(view_id), cursor_(std::move(cursor)), cursor_dup_sort_(std::move(cursor_dup_sort)), backend_(backend) {} Task> begin_transaction() override { co_return std::make_unique(tx_id_, view_id_, cursor_, cursor_dup_sort_, backend_); } Task version() override { co_return db::kv::api::kCurrentVersion; } Task state_changes(const db::kv::api::StateChangeOptions&, db::kv::api::StateChangeConsumer) override { co_return; } private: uint64_t tx_id_; uint64_t view_id_; std::shared_ptr cursor_; std::shared_ptr cursor_dup_sort_; test::BackEndMock* backend_; }; //! This dummy client acts as a factory for dummy services. class DummyClient : public db::kv::api::Client { public: DummyClient(std::shared_ptr cursor, std::shared_ptr cursor_dup_sort, test::BackEndMock* backend) : DummyClient(0, 0, std::move(cursor), std::move(cursor_dup_sort), backend) {} DummyClient(uint64_t tx_id, uint64_t view_id, std::shared_ptr cursor, std::shared_ptr cursor_dup_sort, test::BackEndMock* backend) : tx_id_(tx_id), view_id_(view_id), cursor_(std::move(cursor)), cursor_dup_sort_(std::move(cursor_dup_sort)), backend_(backend) {} std::shared_ptr service() override { return std::make_shared(tx_id_, view_id_, cursor_, cursor_dup_sort_, backend_); } private: uint64_t tx_id_; uint64_t view_id_; std::shared_ptr cursor_; std::shared_ptr cursor_dup_sort_; test::BackEndMock* backend_; }; } // namespace silkworm::rpc::test ================================================ FILE: silkworm/rpc/test_util/dummy_transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::test { template inline auto empty_stream() { return db::kv::api::StreamReply{db::kv::api::EmptyStreamFactory}; } inline db::kv::api::TimestampStreamReply empty_timestamps() { return empty_stream(); } inline db::kv::api::KeyValueStreamReply empty_keys_and_values() { return empty_stream(); } //! This dummy transaction just gives you the same cursor over and over again. class DummyTransaction : public db::kv::api::BaseTransaction { public: DummyTransaction(uint64_t tx_id, uint64_t view_id, std::shared_ptr cursor, std::shared_ptr cursor_dup_sort, test::BackEndMock* backend) : BaseTransaction{nullptr}, tx_id_(tx_id), view_id_(view_id), cursor_(std::move(cursor)), cursor_dup_sort_(std::move(cursor_dup_sort)), backend_(backend) {} uint64_t tx_id() const override { return tx_id_; } uint64_t view_id() const override { return view_id_; } Task open() override { co_return; } Task> cursor(std::string_view /*table*/) override { co_return cursor_; } Task> cursor_dup_sort(std::string_view /*table*/) override { co_return cursor_dup_sort_; } std::shared_ptr make_storage() override { return std::make_shared(*this, ethdb::kv::make_backend_providers(backend_)); } Task first_txn_num_in_block(BlockNum /*block_num*/) override { co_return 0; } Task close() override { co_return; } Task get_latest(db::kv::api::GetLatestRequest /*query*/) override { co_return db::kv::api::GetLatestResult{}; } Task get_as_of(db::kv::api::GetAsOfRequest /*query*/) override { co_return db::kv::api::GetAsOfResult{}; } Task history_seek(db::kv::api::HistoryPointRequest /*query*/) override { co_return db::kv::api::HistoryPointResult{}; } Task index_range(db::kv::api::IndexRangeRequest /*query*/) override { co_return empty_timestamps(); } Task history_range(db::kv::api::HistoryRangeRequest /*query*/) override { co_return empty_keys_and_values(); } Task range_as_of(db::kv::api::DomainRangeRequest /*query*/) override { co_return empty_keys_and_values(); } private: uint64_t tx_id_; uint64_t view_id_; std::shared_ptr cursor_; std::shared_ptr cursor_dup_sort_; test::BackEndMock* backend_; }; } // namespace silkworm::rpc::test ================================================ FILE: silkworm/rpc/test_util/mock_back_end.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::rpc::test { class BackEndMock : public ethbackend::BackEnd { // NOLINT public: MOCK_METHOD((Task), etherbase, ()); MOCK_METHOD((Task), protocol_version, ()); MOCK_METHOD((Task), net_version, ()); MOCK_METHOD((Task), client_version, ()); MOCK_METHOD((Task), net_peer_count, ()); MOCK_METHOD((Task), engine_get_payload, (uint64_t)); MOCK_METHOD((Task), engine_new_payload, (const NewPayloadRequest&)); MOCK_METHOD((Task), engine_forkchoice_updated, (const ForkChoiceUpdatedRequest&)); MOCK_METHOD((Task), engine_get_payload_bodies_by_hash, (const std::vector&)); MOCK_METHOD((Task), engine_get_payload_bodies_by_range, (BlockNum, uint64_t)); MOCK_METHOD((Task), engine_node_info, ()); MOCK_METHOD((Task), peers, ()); MOCK_METHOD((Task), get_block, (BlockNum, const HashAsSpan&, bool, silkworm::Block&)); MOCK_METHOD((Task>>), get_block_num_from_txn_hash, (const HashAsSpan&)); MOCK_METHOD((Task>), get_block_num_from_hash, (const HashAsSpan&)); MOCK_METHOD((Task>), get_block_hash_from_block_num, (BlockNum)); MOCK_METHOD((Task>), canonical_body_for_storage, (BlockNum)); }; } // namespace silkworm::rpc::test ================================================ FILE: silkworm/rpc/test_util/mock_block_cache.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc::test { class MockBlockCache : public silkworm::BlockCache { public: MOCK_METHOD((std::optional>), get, (const evmc::bytes32&), ()); MOCK_METHOD((void), insert, (const evmc::bytes32&, const std::shared_ptr), ()); }; } // namespace silkworm::rpc::test ================================================ FILE: silkworm/rpc/test_util/mock_estimate_gas_oracle.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::rpc { class MockEstimateGasOracle : public EstimateGasOracle { public: explicit MockEstimateGasOracle(const AccountReader& account_reader, const silkworm::ChainConfig& config, WorkerPool& workers, db::kv::api::Transaction& tx, const ChainStorage& storage, AccountsOverrides& accounts_overrides) : EstimateGasOracle(account_reader, config, workers, tx, storage, accounts_overrides) {} MOCK_METHOD((ExecutionResult), try_execution, (EVMExecutor&, const silkworm::Transaction&), (override)); }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/test_util/mock_execution_engine.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::rpc::test_util { class ExecutionEngineMock : public engine::ExecutionEngine { // NOLINT public: MOCK_METHOD((Task), get_payload, (uint64_t, Msec)); MOCK_METHOD((Task), new_payload, (const NewPayloadRequest&, Msec)); MOCK_METHOD((Task), fork_choice_updated, (const ForkChoiceUpdatedRequest&, Msec)); MOCK_METHOD((Task), get_payload_bodies_by_hash, (const std::vector&, Msec)); MOCK_METHOD((Task), get_payload_bodies_by_range, (BlockNum start, uint64_t count, Msec)); }; } // namespace silkworm::rpc::test_util ================================================ FILE: silkworm/rpc/test_util/mock_state_cache.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::test { class MockStateView : public ethdb::kv::StateView { public: MOCK_METHOD((Task>), get, (const silkworm::Bytes&)); MOCK_METHOD((Task>), get_code, (const silkworm::Bytes&)); }; class MockStateCache : public ethdb::kv::StateCache { public: MOCK_METHOD((std::unique_ptr), get_view, (ethdb::Transaction&), (override)); MOCK_METHOD((void), on_new_block, (const remote::StateChangeBatch&), (override)); MOCK_METHOD((size_t), latest_data_size, (), (override)); MOCK_METHOD((size_t), latest_code_size, (), (override)); MOCK_METHOD((uint64_t), state_hit_count, (), (const)); MOCK_METHOD((uint64_t), state_miss_count, (), (const)); MOCK_METHOD((uint64_t), state_key_count, (), (const)); MOCK_METHOD((uint64_t), state_eviction_count, (), (const)); MOCK_METHOD((uint64_t), code_hit_count, (), (const)); MOCK_METHOD((uint64_t), code_miss_count, (), (const)); MOCK_METHOD((uint64_t), code_key_count, (), (const)); MOCK_METHOD((uint64_t), code_eviction_count, (), (const)); }; } // namespace silkworm::rpc::test ================================================ FILE: silkworm/rpc/test_util/service_context_test_base.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "service_context_test_base.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include "mock_execution_engine.hpp" namespace silkworm::rpc::test_util { ServiceContextTestBase::ServiceContextTestBase() : ContextTestBase() { add_shared_service(ioc_, std::make_shared()); add_shared_service(ioc_, std::make_shared(1024)); add_shared_service(ioc_, std::make_shared()); add_shared_service(ioc_, std::make_shared()); auto* state_cache{must_use_shared_service(ioc_)}; auto grpc_channel{::grpc::CreateChannel("localhost:12345", ::grpc::InsecureChannelCredentials())}; auto backend{std::make_unique(grpc_channel, grpc_context_)}; add_private_service(ioc_, std::make_unique( [=]() { return grpc_channel; }, grpc_context_, state_cache, ethdb::kv::make_backend_providers(backend.get()))); add_private_service(ioc_, std::move(backend)); add_private_service(ioc_, std::make_unique(grpc_channel, grpc_context_)); add_private_service(ioc_, std::make_unique(grpc_channel, grpc_context_)); } } // namespace silkworm::rpc::test_util ================================================ FILE: silkworm/rpc/test_util/service_context_test_base.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::rpc::test_util { using silkworm::test_util::ContextTestBase; class ServiceContextTestBase : public ContextTestBase { public: ServiceContextTestBase(); ~ServiceContextTestBase() = default; }; } // namespace silkworm::rpc::test_util ================================================ FILE: silkworm/rpc/transport/request_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "stream_writer.hpp" namespace silkworm::rpc { using Request = std::string; using Response = std::string; class RequestHandler { public: RequestHandler() = default; virtual ~RequestHandler() = default; RequestHandler(const RequestHandler&) = delete; RequestHandler& operator=(const RequestHandler&) = delete; virtual Task> handle(const Request& request, uint64_t request_id) = 0; }; using RequestHandlerPtr = std::unique_ptr; //! We use \code absl::AnyInvocable waiting for \code std::move_only_function in C++23 using RequestHandlerFactory = absl::AnyInvocable; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/transport/stream_writer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::rpc { class StreamWriter { public: virtual ~StreamWriter() = default; virtual Task open_stream(uint64_t request_id) = 0; virtual Task close_stream(uint64_t request_id) = 0; virtual Task write(uint64_t request_id, std::string_view content, bool last) = 0; virtual size_t get_capacity() const noexcept = 0; }; inline constexpr size_t kDefaultCapacity = 2048; class StringWriter : public StreamWriter { public: StringWriter() = default; explicit StringWriter(size_t initial_capacity) { content_.reserve(initial_capacity); } size_t get_capacity() const noexcept override { return kDefaultCapacity; } Task open_stream(uint64_t /* request_id */) override { co_return; } Task close_stream(uint64_t /* request_id */) override { co_return; } Task write(uint64_t /* request_id */, std::string_view content, bool /*last*/) override { content_.append(content); co_return content.size(); } const std::string& get_content() { return content_; } private: std::string content_; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/transport/stream_writer_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "stream_writer.hpp" #include #include #include #include namespace silkworm::rpc { struct WriterTest : test_util::ServiceContextTestBase { }; class JsonChunkWriter : public StreamWriter { public: explicit JsonChunkWriter(StreamWriter& writer, size_t chunk_size = kDefaultChunkSize); Task open_stream(uint64_t /* request_id */) override { co_return; } size_t get_capacity() const noexcept override { return 0; } Task close_stream(uint64_t /* request_id */) override; Task write(uint64_t /* request_id */, std::string_view content, bool last) override; private: static constexpr size_t kDefaultChunkSize{0x800}; StreamWriter& writer_; bool chunk_open_ = false; const size_t chunk_size_; size_t room_left_in_chunk_; size_t written_{0}; }; JsonChunkWriter::JsonChunkWriter(StreamWriter& writer, size_t chunk_size) : writer_(writer), chunk_size_(chunk_size), room_left_in_chunk_(chunk_size_) { } Task JsonChunkWriter::write(uint64_t request_id, std::string_view content, bool /*last*/) { auto size = content.size(); SILK_DEBUG << "JsonChunkWriter::write written_: " << written_ << " size: " << size; if (!chunk_open_) { chunk_open_ = true; } size_t remaining_in_view = size; size_t start = 0; while (start < size) { const auto length = std::min(room_left_in_chunk_, remaining_in_view); std::string_view sub_view(content.data() + start, length); co_await writer_.write(request_id, sub_view, true); written_ += length; start += length; remaining_in_view -= length; room_left_in_chunk_ -= length; if ((room_left_in_chunk_ % chunk_size_) == 0) { if (chunk_open_) { room_left_in_chunk_ = chunk_size_; chunk_open_ = false; } if (remaining_in_view > 0) { chunk_open_ = true; } } } co_return content.size(); } Task JsonChunkWriter::close_stream(uint64_t request_id) { if (chunk_open_) { if (room_left_in_chunk_ > 0) { std::unique_ptr buffer{new char[room_left_in_chunk_]}; std::memset(buffer.get(), ' ', room_left_in_chunk_); co_await writer_.write(request_id, std::string_view(buffer.get(), room_left_in_chunk_), true); } chunk_open_ = false; room_left_in_chunk_ = chunk_size_; } co_return; } TEST_CASE_METHOD(WriterTest, "StringWriter") { SECTION("write") { StringWriter writer; std::string test = "test"; spawn_and_wait(writer.write(/* request_id */ 0, test, true)); CHECK(writer.get_content() == test); } SECTION("close_stream") { StringWriter writer(5); std::string test = "test"; spawn_and_wait(writer.write(/* request_id */ 0, test, true)); spawn_and_wait(writer.close_stream(/* request_id */ 0)); CHECK(writer.get_content() == test); } } TEST_CASE_METHOD(WriterTest, "JsonChunkWriter") { SECTION("write&close under chunk size") { StringWriter s_writer; JsonChunkWriter writer(s_writer, 16); spawn_and_wait(writer.write(/* request_id */ 0, "1234", true)); spawn_and_wait(writer.close_stream(/* request_id */ 0)); CHECK(s_writer.get_content() == "1234 "); } SECTION("write&close over chunk size 4") { StringWriter s_writer; JsonChunkWriter writer(s_writer, 4); spawn_and_wait(writer.write(/* request_id */ 0, "1234567890", true)); spawn_and_wait(writer.close_stream(/* request_id */ 0)); CHECK(s_writer.get_content() == "1234567890 "); } SECTION("write&close over chunk size 5") { StringWriter s_writer; JsonChunkWriter writer(s_writer, 5); spawn_and_wait(writer.write(/* request_id */ 0, "1234567890", true)); spawn_and_wait(writer.close_stream(/* request_id */ 0)); CHECK(s_writer.get_content() == "1234567890"); } SECTION("write&close over chunk size 5") { StringWriter s_writer; JsonChunkWriter writer(s_writer, 5); spawn_and_wait(writer.write(/* request_id */ 0, "123456789012", true)); spawn_and_wait(writer.close_stream(/* request_id */ 0)); CHECK(s_writer.get_content() == "123456789012 "); } SECTION("close") { StringWriter s_writer; JsonChunkWriter writer(s_writer); spawn_and_wait(writer.close_stream(/* request_id */ 0)); CHECK(s_writer.get_content().empty()); } SECTION("write json") { StringWriter s_writer; JsonChunkWriter writer(s_writer, 48); nlohmann::json json = R"({ "accounts": {}, "next": "next", "root": "root" })"_json; const auto content = json.dump(/*indent=*/-1, /*indent_char=*/' ', /*ensure_ascii=*/false, nlohmann::json::error_handler_t::replace); spawn_and_wait(writer.write(/* request_id */ 0, content, true)); spawn_and_wait(writer.close_stream(/* request_id */ 0)); CHECK(s_writer.get_content() == "{\"accounts\":{},\"next\":\"next\",\"root\":\"root\"} "); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/txpool/miner.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "miner.hpp" #include #include #include #include namespace silkworm::rpc::txpool { namespace proto = ::txpool; using Stub = proto::Mining::StubInterface; Miner::Miner(const std::shared_ptr& channel, agrpc::GrpcContext& grpc_context) : Miner(proto::Mining::NewStub(channel), grpc_context) {} Miner::Miner(std::unique_ptr stub, agrpc::GrpcContext& grpc_context) : stub_(std::move(stub)), grpc_context_(grpc_context) {} Task Miner::get_work() { const auto start_time = clock_time::now(); SILK_DEBUG << "Miner::get_work"; const proto::GetWorkRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetWork, *stub_, request, grpc_context_); const auto header_hash = bytes32_from_hex(reply.header_hash()); const auto seed_hash = bytes32_from_hex(reply.seed_hash()); const auto target = bytes32_from_hex(reply.target()); const auto block_num = from_hex(reply.block_number()).value_or(Bytes{}); WorkResult result{header_hash, seed_hash, target, block_num}; SILK_DEBUG << "Miner::get_work header_hash=" << to_hex(header_hash) << " seed_hash=" << to_hex(seed_hash) << " target=" << to_hex(target) << " block_num=" << block_num << " t=" << clock_time::since(start_time); co_return result; } Task Miner::submit_work(const silkworm::Bytes& block_nonce, const evmc::bytes32& pow_hash, const evmc::bytes32& digest) { const auto start_time = clock_time::now(); SILK_DEBUG << "Miner::submit_work block_nonce=" << block_nonce << " pow_hash=" << to_hex(pow_hash) << " digest=" << to_hex(digest); proto::SubmitWorkRequest request; request.set_block_nonce(block_nonce.data(), block_nonce.size()); request.set_pow_hash(pow_hash.bytes, silkworm::kHashLength); request.set_digest(digest.bytes, silkworm::kHashLength); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncSubmitWork, *stub_, request, grpc_context_); const auto ok = reply.ok(); SILK_DEBUG << "Miner::submit_work ok=" << std::boolalpha << ok << " t=" << clock_time::since(start_time); co_return ok; } Task Miner::submit_hash_rate(const intx::uint256& rate, const evmc::bytes32& id) { const auto start_time = clock_time::now(); SILK_DEBUG << "Miner::submit_hash_rate rate=" << rate << " id=" << to_hex(id); ::txpool::SubmitHashRateRequest request; request.set_rate(uint64_t{rate}); request.set_id(id.bytes, kHashLength); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncSubmitHashRate, *stub_, request, grpc_context_); const auto ok = reply.ok(); SILK_DEBUG << "Miner::submit_hash_rate ok=" << std::boolalpha << ok << " t=" << clock_time::since(start_time); co_return ok; } Task Miner::get_hash_rate() { const auto start_time = clock_time::now(); SILK_DEBUG << "Miner::hash_rate"; const proto::HashRateRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHashRate, *stub_, request, grpc_context_); const auto hash_rate = reply.hash_rate(); SILK_DEBUG << "Miner::hash_rate hash_rate=" << hash_rate << " t=" << clock_time::since(start_time); co_return hash_rate; } Task Miner::get_mining() { const auto start_time = clock_time::now(); SILK_DEBUG << "Miner::get_mining"; const proto::MiningRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncMining, *stub_, request, grpc_context_); const auto enabled = reply.enabled(); const auto running = reply.running(); MiningResult result{enabled, running}; SILK_DEBUG << "Miner::get_mining enabled=" << std::boolalpha << enabled << " running=" << running << " t=" << clock_time::since(start_time); co_return result; } } // namespace silkworm::rpc::txpool ================================================ FILE: silkworm/rpc/txpool/miner.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include #include namespace silkworm::rpc::txpool { struct WorkResult { evmc::bytes32 header_hash; evmc::bytes32 seed_hash; evmc::bytes32 target; silkworm::Bytes block_num; }; struct MiningResult { bool enabled; bool running; }; class Miner final { public: Miner(const std::shared_ptr& channel, agrpc::GrpcContext& grpc_context); Miner(std::unique_ptr<::txpool::Mining::StubInterface> stub, agrpc::GrpcContext& grpc_context); Task get_work(); Task submit_work(const silkworm::Bytes& block_nonce, const evmc::bytes32& pow_hash, const evmc::bytes32& digest); Task submit_hash_rate(const intx::uint256& rate, const evmc::bytes32& id); Task get_hash_rate(); Task get_mining(); private: std::unique_ptr<::txpool::Mining::StubInterface> stub_; agrpc::GrpcContext& grpc_context_; }; } // namespace silkworm::rpc::txpool ================================================ FILE: silkworm/rpc/txpool/miner_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "miner.hpp" #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::txpool { using evmc::literals::operator""_bytes32; using StrictMockMiningStub = testing::StrictMock<::txpool::MockMiningStub>; using MinerTest = test_util::GrpcApiTestBase; #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(MinerTest, "Miner::get_work", "[rpc][txpool][miner]") { test::StrictMockAsyncResponseReader<::txpool::GetWorkReply> reader; EXPECT_CALL(*stub_, AsyncGetWorkRaw).WillOnce(testing::Return(&reader)); SECTION("call get_work and get result") { ::txpool::GetWorkReply response; response.set_header_hash("0x209f062567c161c5f71b3f57a7de277b0e95c3455050b152d785ad7524ef8ee7"); response.set_seed_hash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"); response.set_target("0xe7536c5b61ed0e0ab7f3ce7f085806d40f716689c0c086676757de401b595658"); response.set_block_number("0x00000000"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto work_result = run<&Miner::get_work>(); CHECK(work_result.header_hash == 0x209f062567c161c5f71b3f57a7de277b0e95c3455050b152d785ad7524ef8ee7_bytes32); CHECK(work_result.seed_hash == 0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347_bytes32); CHECK(work_result.target == 0xe7536c5b61ed0e0ab7f3ce7f085806d40f716689c0c086676757de401b595658_bytes32); CHECK(work_result.block_num == *from_hex("0x00000000")); } SECTION("call get_work and get empty result") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto work = run<&Miner::get_work>(); CHECK(!work.header_hash); CHECK(!work.seed_hash); CHECK(!work.target); CHECK(work.block_num == *from_hex("0x")); } SECTION("call get_work and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&Miner::get_work>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(MinerTest, "Miner::get_hashrate", "[rpc][txpool][miner]") { test::StrictMockAsyncResponseReader<::txpool::HashRateReply> reader; EXPECT_CALL(*stub_, AsyncHashRateRaw).WillOnce(testing::Return(&reader)); SECTION("call get_hashrate and get result") { ::txpool::HashRateReply response; response.set_hash_rate(1234567); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto hash_rate = run<&Miner::get_hash_rate>(); CHECK(hash_rate == 1234567); } SECTION("call get_hashrate and get empty result") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto hash_rate = run<&Miner::get_hash_rate>(); CHECK(hash_rate == 0); } SECTION("call get_hashrate and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&Miner::get_hash_rate>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(MinerTest, "Miner::get_mining", "[rpc][txpool][miner]") { test::StrictMockAsyncResponseReader<::txpool::MiningReply> reader; EXPECT_CALL(*stub_, AsyncMiningRaw).WillOnce(testing::Return(&reader)); const std::pair enabled_running_pairs[] = { {false, false}, {false, true}, {true, false}, {true, true}, }; for (const auto& [enabled, running] : enabled_running_pairs) { SECTION(std::string("call get_mining and get [") + std::to_string(enabled) + "," + std::to_string(running) + std::string("] result")) { ::txpool::MiningReply response; response.set_enabled(true); response.set_running(true); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto mining = run<&Miner::get_mining>(); CHECK(mining.enabled); CHECK(mining.running); } } SECTION("call get_mining and get empty result") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto mining = run<&Miner::get_mining>(); CHECK(!mining.enabled); CHECK(!mining.running); } SECTION("call get_mining and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&Miner::get_mining>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(MinerTest, "Miner::submit_work", "[rpc][txpool][miner]") { test::StrictMockAsyncResponseReader<::txpool::SubmitWorkReply> reader; EXPECT_CALL(*stub_, AsyncSubmitWorkRaw).WillOnce(testing::Return(&reader)); SECTION("call submit_work and get result") { ::txpool::SubmitWorkReply response; response.set_ok(true); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); Bytes block_nonce{}; // don't care evmc::bytes32 pow_hash{kEmptyHash}; // don't care evmc::bytes32 digest{kEmptyHash}; // don't care const auto ok = run<&Miner::submit_work>(block_nonce, pow_hash, digest); CHECK(ok); } SECTION("call submit_work and get empty result") { Bytes block_nonce{}; // don't care evmc::bytes32 pow_hash{kEmptyHash}; // don't care evmc::bytes32 digest{kEmptyHash}; // don't care EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto ok = run<&Miner::submit_work>(block_nonce, pow_hash, digest); CHECK(!ok); } SECTION("call submit_work and get error") { Bytes block_nonce{}; // don't care evmc::bytes32 pow_hash{kEmptyHash}; // don't care evmc::bytes32 digest{kEmptyHash}; // don't care EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&Miner::submit_work>(block_nonce, pow_hash, digest)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(MinerTest, "Miner::submit_hash_rate", "[rpc][txpool][miner]") { test::StrictMockAsyncResponseReader<::txpool::SubmitHashRateReply> reader; EXPECT_CALL(*stub_, AsyncSubmitHashRateRaw).WillOnce(testing::Return(&reader)); SECTION("call submit_hash_rate and get result") { ::txpool::SubmitHashRateReply response; response.set_ok(true); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); intx::uint256 rate{}; // don't care evmc::bytes32 id{kEmptyHash}; // don't care const auto ok = run<&Miner::submit_hash_rate>(rate, id); CHECK(ok); } SECTION("call submit_hash_rate and get empty result") { intx::uint256 rate{}; // don't care evmc::bytes32 id{kEmptyHash}; // don't care EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto ok = run<&Miner::submit_hash_rate>(rate, id); CHECK(!ok); } SECTION("call submit_hash_rate and get error") { intx::uint256 rate{}; // don't care evmc::bytes32 id{kEmptyHash}; // don't care EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&Miner::submit_hash_rate>(rate, id)), rpc::GrpcStatusError); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::txpool ================================================ FILE: silkworm/rpc/txpool/transaction_pool.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction_pool.hpp" #include #include #include #include #include #include namespace silkworm::rpc::txpool { namespace proto = ::txpool; using Stub = proto::Txpool::StubInterface; TransactionPool::TransactionPool(const std::shared_ptr& channel, agrpc::GrpcContext& grpc_context) : TransactionPool(proto::Txpool::NewStub(channel, grpc::StubOptions()), grpc_context) {} TransactionPool::TransactionPool(std::unique_ptr stub, agrpc::GrpcContext& grpc_context) : stub_(std::move(stub)), grpc_context_(grpc_context) {} Task TransactionPool::add_transaction(const silkworm::ByteView& rlp_tx) { const auto start_time = clock_time::now(); SILK_DEBUG << "TransactionPool::add_transaction rlp_tx=" << silkworm::to_hex(rlp_tx); ::txpool::AddRequest request; request.add_rlp_txs(rlp_tx.data(), rlp_tx.size()); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncAdd, *stub_, request, grpc_context_); const auto imported_size = reply.imported_size(); const auto errors_size = reply.errors_size(); SILK_DEBUG << "TransactionPool::add_transaction imported_size=" << imported_size << " errors_size=" << errors_size; OperationResult result; if (imported_size == 1) { const auto import_result = reply.imported(0); SILK_DEBUG << "TransactionPool::add_transaction import_result=" << import_result; if (import_result != ::txpool::ImportResult::SUCCESS) { result.success = false; if (errors_size >= 1) { const auto& import_error = reply.errors(0); result.error_descr = import_error; SILK_WARN << "TransactionPool::add_transaction import_result=" << import_result << " error=" << import_error; } else { result.error_descr = "no specific error"; SILK_WARN << "TransactionPool::add_transaction import_result=" << import_result << ", no error received"; } } else { result.success = true; } } else { result.success = false; result.error_descr = "unexpected imported size"; SILK_WARN << "TransactionPool::add_transaction unexpected imported_size=" << imported_size; } SILK_DEBUG << "TransactionPool::add_transaction t=" << clock_time::since(start_time); co_return result; } Task> TransactionPool::get_transaction(const evmc::bytes32& tx_hash) { const auto start_time = clock_time::now(); SILK_DEBUG << "TransactionPool::get_transaction tx_hash=" << silkworm::to_hex(tx_hash); auto hi = new ::types::H128{}; auto lo = new ::types::H128{}; hi->set_hi(evmc::load64be(tx_hash.bytes + 0)); hi->set_lo(evmc::load64be(tx_hash.bytes + 8)); lo->set_hi(evmc::load64be(tx_hash.bytes + 16)); lo->set_lo(evmc::load64be(tx_hash.bytes + 24)); ::txpool::TransactionsRequest request; ::types::H256* hash_h256{request.add_hashes()}; hash_h256->set_allocated_hi(hi); // take ownership hash_h256->set_allocated_lo(lo); // take ownership const auto reply = co_await rpc::unary_rpc(&Stub::AsyncTransactions, *stub_, request, grpc_context_); const auto rlp_txs_size = reply.rlp_txs_size(); SILK_DEBUG << "TransactionPool::get_transaction rlp_txs_size=" << rlp_txs_size; if (rlp_txs_size == 1) { const auto& rlp_tx = reply.rlp_txs(0); SILK_DEBUG << "TransactionPool::get_transaction t=" << clock_time::since(start_time); co_return silkworm::Bytes{rlp_tx.begin(), rlp_tx.end()}; } else { SILK_WARN << "TransactionPool::get_transaction unexpected rlp_txs_size=" << rlp_txs_size; SILK_DEBUG << "TransactionPool::get_transaction t=" << clock_time::since(start_time); co_return std::nullopt; } } Task> TransactionPool::nonce(const evmc::address& address) { const auto start_time = clock_time::now(); SILK_DEBUG << "TransactionPool::nonce address=" << address; ::txpool::NonceRequest request; request.set_allocated_address(h160_from_address(address).release()); const auto reply = co_await rpc::unary_rpc(&Stub::AsyncNonce, *stub_, request, grpc_context_); SILK_DEBUG << "TransactionPool::nonce found:" << reply.found() << " nonce: " << reply.nonce() << " t=" << clock_time::since(start_time); co_return reply.found() ? std::optional{reply.nonce()} : std::nullopt; } Task TransactionPool::get_status() { const auto start_time = clock_time::now(); SILK_DEBUG << "TransactionPool::get_status"; const ::txpool::StatusRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncStatus, *stub_, request, grpc_context_); StatusInfo status_info{ .queued_count = reply.queued_count(), .pending_count = reply.pending_count(), .base_fee_count = reply.base_fee_count()}; SILK_DEBUG << "TransactionPool::get_status t=" << clock_time::since(start_time); co_return status_info; } Task TransactionPool::get_transactions() { const auto start_time = clock_time::now(); SILK_DEBUG << "TransactionPool::get_transactions"; const ::txpool::AllRequest request; const auto reply = co_await rpc::unary_rpc(&Stub::AsyncAll, *stub_, request, grpc_context_); TransactionsInPool transactions_in_pool; const auto txs_size = reply.txs_size(); for (int i = 0; i < txs_size; ++i) { const auto& tx = reply.txs(i); TransactionInfo element{}; element.sender = address_from_h160(tx.sender()); const auto& rlp = tx.rlp_tx(); element.rlp = silkworm::Bytes{rlp.begin(), rlp.end()}; if (tx.txn_type() == ::txpool::AllReply_TxnType_PENDING) { element.transaction_type = kPending; } else if (tx.txn_type() == ::txpool::AllReply_TxnType_QUEUED) { element.transaction_type = kQueued; } else { element.transaction_type = kBaseFee; } transactions_in_pool.push_back(element); } SILK_DEBUG << "TransactionPool::get_transactions t=" << clock_time::since(start_time); co_return transactions_in_pool; } } // namespace silkworm::rpc::txpool ================================================ FILE: silkworm/rpc/txpool/transaction_pool.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsign-conversion" #include #pragma GCC diagnostic pop #include #include #include #include #include #include #include namespace silkworm::rpc::txpool { struct OperationResult { bool success{false}; std::string error_descr; }; struct StatusInfo { unsigned int queued_count{0}; unsigned int pending_count{0}; unsigned int base_fee_count{0}; }; enum TransactionType { kQueued, kPending, kBaseFee }; struct TransactionInfo { TransactionType transaction_type; evmc::address sender; silkworm::Bytes rlp; }; using TransactionsInPool = std::vector; class TransactionPool final { public: TransactionPool(const std::shared_ptr& channel, agrpc::GrpcContext& grpc_context); TransactionPool(std::unique_ptr<::txpool::Txpool::StubInterface> stub, agrpc::GrpcContext& grpc_context); Task add_transaction(const silkworm::ByteView& rlp_tx); Task> get_transaction(const evmc::bytes32& tx_hash); Task> nonce(const evmc::address& address); Task get_status(); Task get_transactions(); private: std::unique_ptr<::txpool::Txpool::StubInterface> stub_; agrpc::GrpcContext& grpc_context_; }; } // namespace silkworm::rpc::txpool ================================================ FILE: silkworm/rpc/txpool/transaction_pool_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction_pool.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace grpc { inline bool operator==(const Status& lhs, const Status& rhs) { return lhs.error_code() == rhs.error_code() && lhs.error_message() == rhs.error_message() && lhs.error_details() == rhs.error_details(); } ::types::H160* make_h160(uint64_t hi_hi, uint64_t hi_lo, uint32_t lo) { auto h128_ptr{new ::types::H128()}; h128_ptr->set_hi(hi_hi); h128_ptr->set_lo(hi_lo); auto h160_ptr{new ::types::H160()}; h160_ptr->set_allocated_hi(h128_ptr); h160_ptr->set_lo(lo); return h160_ptr; } } // namespace grpc namespace txpool { inline bool operator==(const AddReply& lhs, const AddReply& rhs) { if (lhs.imported_size() != rhs.imported_size()) return false; for (auto i{0}; i < lhs.imported_size(); ++i) { if (lhs.imported(i) != rhs.imported(i)) return false; } if (lhs.errors_size() != rhs.errors_size()) return false; for (auto i{0}; i < lhs.errors_size(); ++i) { if (lhs.errors(i) != rhs.errors(i)) return false; } return true; } } // namespace txpool namespace silkworm::rpc::txpool { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; using StrictMockTxpoolStub = testing::StrictMock<::txpool::MockTxpoolStub>; using TransactionPoolTest = test_util::GrpcApiTestBase; #ifndef SILKWORM_SANITIZE TEST_CASE_METHOD(TransactionPoolTest, "TransactionPool::add_transaction", "[rpc][txpool][transaction_pool]") { test::StrictMockAsyncResponseReader<::txpool::AddReply> reader; EXPECT_CALL(*stub_, AsyncAddRaw).WillOnce(testing::Return(&reader)); const Bytes tx_rlp{0x00, 0x01}; SECTION("call add_transaction and check import success") { ::txpool::AddReply response; response.add_imported(::txpool::ImportResult::SUCCESS); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto result = run<&TransactionPool::add_transaction>(tx_rlp); CHECK(result.success); } SECTION("call add_transaction and check import failure [unexpected import size]") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto result = run<&TransactionPool::add_transaction>(tx_rlp); CHECK(!result.success); } SECTION("call add_transaction and check import failure [invalid error]") { ::txpool::AddReply response; response.add_imported(::txpool::ImportResult::INVALID); response.add_errors("invalid transaction"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto result = run<&TransactionPool::add_transaction>(tx_rlp); CHECK(!result.success); } SECTION("call add_transaction and check import failure [internal error]") { ::txpool::AddReply response; response.add_imported(::txpool::ImportResult::INTERNAL_ERROR); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto result = run<&TransactionPool::add_transaction>(tx_rlp); CHECK(!result.success); } SECTION("call add_transaction and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&TransactionPool::add_transaction>(tx_rlp)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(TransactionPoolTest, "TransactionPool::get_transaction", "[rpc][txpool][transaction_pool]") { test::StrictMockAsyncResponseReader<::txpool::TransactionsReply> reader; EXPECT_CALL(*stub_, AsyncTransactionsRaw).WillOnce(testing::Return(&reader)); const evmc::bytes32 tx_hash{0x3763e4f6e4198413383534c763f3f5dac5c5e939f0a81724e3beb96d6e2ad0d5_bytes32}; SECTION("call get_transaction and check success") { ::txpool::TransactionsReply response; response.add_rlp_txs("0804"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto tx_rlp = run<&TransactionPool::get_transaction>(tx_hash); CHECK(tx_rlp); if (tx_rlp) { CHECK(tx_rlp.value() == Bytes{0x30, 0x38, 0x30, 0x34}); } } SECTION("call get_transaction and check result is null [rlp_txs size is 0]") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto tx_rlp = run<&TransactionPool::get_transaction>(tx_hash); CHECK(!tx_rlp); } SECTION("call get_transaction and check result is null [rlp_txs size is greater than 1]") { ::txpool::TransactionsReply response; response.add_rlp_txs("0804"); response.add_rlp_txs("0905"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto tx_rlp = run<&TransactionPool::get_transaction>(tx_hash); CHECK(!tx_rlp); } SECTION("call get_transaction and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&TransactionPool::get_transaction>(tx_hash)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(TransactionPoolTest, "TransactionPool::nonce", "[rpc][txpool][transaction_pool]") { test::StrictMockAsyncResponseReader<::txpool::NonceReply> reader; EXPECT_CALL(*stub_, AsyncNonceRaw).WillOnce(testing::Return(&reader)); const evmc::address account{0x99f9b87991262f6ba471f09758cde1c0fc1de734_address}; SECTION("call nonce and check success") { ::txpool::NonceReply response; response.set_found(true); response.set_nonce(21); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto nonce = run<&TransactionPool::nonce>(account); CHECK(nonce); if (nonce) { CHECK(nonce.value() == 21); } } SECTION("call nonce and check result is null") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto nonce = run<&TransactionPool::nonce>(account); CHECK(!nonce); } SECTION("call nonce and check result is null [not found]") { ::txpool::NonceReply response; response.set_found(false); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto nonce = run<&TransactionPool::nonce>(account); CHECK(!nonce); } SECTION("call nonce and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&TransactionPool::nonce>(account)), rpc::GrpcStatusError); } } TEST_CASE_METHOD(TransactionPoolTest, "TransactionPool::get_status", "[rpc][txpool][transaction_pool]") { test::StrictMockAsyncResponseReader<::txpool::StatusReply> reader; EXPECT_CALL(*stub_, AsyncStatusRaw).WillOnce(testing::Return(&reader)); SECTION("call get_status and check success") { ::txpool::StatusReply response; response.set_queued_count(0x6); response.set_pending_count(0x5); response.set_base_fee_count(0x4); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto status_info = run<&TransactionPool::get_status>(); CHECK(status_info.queued_count == 0x6); CHECK(status_info.pending_count == 0x5); CHECK(status_info.base_fee_count == 0x4); } SECTION("call get_status and check result is empty") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto status_info = run<&TransactionPool::get_status>(); CHECK(status_info.queued_count == 0); CHECK(status_info.pending_count == 0); CHECK(status_info.base_fee_count == 0); } SECTION("call get_status and get error") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_cancelled(grpc_context_)); CHECK_THROWS_AS((run<&TransactionPool::get_status>()), rpc::GrpcStatusError); } } TEST_CASE_METHOD(TransactionPoolTest, "TransactionPool::get_transactions", "[rpc][txpool][transaction_pool]") { test::StrictMockAsyncResponseReader<::txpool::AllReply> reader; EXPECT_CALL(*stub_, AsyncAllRaw).WillOnce(testing::Return(&reader)); SECTION("call get_transactions and check success [one tx]") { ::txpool::AllReply response; auto tx = response.add_txs(); tx->set_txn_type(::txpool::AllReply_TxnType_QUEUED); auto address{grpc::make_h160(0xAAAAEEFFFFEEAAAA, 0x11DDBBAAAABBDD11, 0xCCDDDDCC)}; tx->set_allocated_sender(address); tx->set_rlp_tx("0804"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto transactions = run<&TransactionPool::get_transactions>(); REQUIRE(transactions.size() == 1); CHECK(transactions[0].transaction_type == TransactionType::kQueued); CHECK(transactions[0].sender == 0xaaaaeeffffeeaaaa11ddbbaaaabbdd11ccddddcc_address); CHECK(transactions[0].rlp == Bytes{0x30, 0x38, 0x30, 0x34}); } SECTION("call get_transactions and check success [more than one tx]") { ::txpool::AllReply response; auto tx = response.add_txs(); tx->set_txn_type(::txpool::AllReply_TxnType_QUEUED); auto address{grpc::make_h160(0xAAAAEEFFFFEEAAAA, 0x11DDBBAAAABBDD11, 0xCCDDDDCC)}; tx->set_allocated_sender(address); tx->set_rlp_tx("0804"); tx = response.add_txs(); tx->set_txn_type(::txpool::AllReply_TxnType_PENDING); auto address1{grpc::make_h160(0xAAAAEEFFFFEEAAAA, 0x11DDBBAAAABBDD11, 0xCCDDDDDD)}; tx->set_allocated_sender(address1); tx->set_rlp_tx("0806"); tx = response.add_txs(); tx->set_txn_type(::txpool::AllReply_TxnType_BASE_FEE); auto address2{grpc::make_h160(0xAAAAEEFFFFEEAAAA, 0x11DDBBAAAABBDD11, 0xCCDDDDEE)}; tx->set_allocated_sender(address2); tx->set_rlp_tx("0807"); EXPECT_CALL(reader, Finish).WillOnce(test::finish_with(grpc_context_, std::move(response))); const auto transactions = run<&TransactionPool::get_transactions>(); REQUIRE(transactions.size() == 3); CHECK(transactions[0].transaction_type == txpool::TransactionType::kQueued); CHECK(transactions[0].sender == 0xaaaaeeffffeeaaaa11ddbbaaaabbdd11ccddddcc_address); CHECK(transactions[0].rlp == Bytes{0x30, 0x38, 0x30, 0x34}); CHECK(transactions[1].transaction_type == txpool::TransactionType::kPending); CHECK(transactions[1].sender == 0xaaaaeeffffeeaaaa11ddbbaaaabbdd11ccdddddd_address); CHECK(transactions[1].rlp == Bytes{0x30, 0x38, 0x30, 0x36}); CHECK(transactions[2].transaction_type == txpool::TransactionType::kBaseFee); CHECK(transactions[2].sender == 0xaaaaeeffffeeaaaa11ddbbaaaabbdd11ccddddee_address); CHECK(transactions[2].rlp == Bytes{0x30, 0x38, 0x30, 0x37}); } SECTION("call get_transactions and check result is empty") { EXPECT_CALL(reader, Finish).WillOnce(test::finish_ok(grpc_context_)); const auto transactions = run<&TransactionPool::get_transactions>(); CHECK(transactions.empty()); } } #endif // SILKWORM_SANITIZE } // namespace silkworm::rpc::txpool ================================================ FILE: silkworm/rpc/types/block.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const Block& b) { out << b.to_string(); return out; } std::string Block::to_string() const { const auto& b = *this; std::stringstream out; auto& block = b.block_with_hash->block; out << "parent_hash: " << to_hex(block.header.parent_hash); out << " ommers_hash: " << to_hex(block.header.ommers_hash); out << " beneficiary: "; for (const auto& byte : block.header.beneficiary.bytes) { out << std::hex << std::setw(2) << std::setfill('0') << int{byte}; } out << std::dec; out << " state_root: " << to_hex(block.header.state_root); out << " transactions_root: " << to_hex(block.header.transactions_root); out << " receipts_root: " << to_hex(block.header.receipts_root); out << " logs_bloom: " << silkworm::to_hex(full_view(block.header.logs_bloom)); out << " difficulty: " << silkworm::to_hex(silkworm::endian::to_big_compact(block.header.difficulty)); out << " number: " << block.header.number; out << " gas_limit: " << block.header.gas_limit; out << " gas_used: " << block.header.gas_used; out << " timestamp: " << block.header.timestamp; out << " extra_data: " << silkworm::to_hex(block.header.extra_data); out << " prev_randao: " << to_hex(block.header.prev_randao); out << " nonce: " << silkworm::to_hex({block.header.nonce.data(), block.header.nonce.size()}); out << " #transactions: " << block.transactions.size(); out << " #ommers: " << block.ommers.size(); out << " hash: " << to_hex(b.block_with_hash->hash); out << " full_tx: " << b.full_tx; return out.str(); } uint64_t Block::get_block_size() const { silkworm::rlp::Header rlp_head{true, 0}; auto& block = block_with_hash->block; rlp_head.payload_length = silkworm::rlp::length(block.header); rlp_head.payload_length += silkworm::rlp::length(block.transactions); rlp_head.payload_length += silkworm::rlp::length(block.ommers); if (block.withdrawals) { rlp_head.payload_length += silkworm::rlp::length(*(block.withdrawals)); } rlp_head.payload_length += silkworm::rlp::length_of_length(rlp_head.payload_length); return rlp_head.payload_length; } std::ostream& operator<<(std::ostream& out, const BlockNumOrHash& block_num_or_hash) { out << block_num_or_hash.to_string(); return out; } std::string BlockNumOrHash::to_string() const { const auto& block_num_or_hash = *this; std::stringstream out; if (block_num_or_hash.is_number()) { out << "0x" << std::hex << block_num_or_hash.number() << std::dec; } else if (block_num_or_hash.is_hash()) { out << to_hex(block_num_or_hash.hash(), true); } else { SILKWORM_ASSERT(block_num_or_hash.is_tag()); out << block_num_or_hash.tag(); } return out.str(); } void BlockNumOrHash::parse(const std::string& block_num_or_hash) { value_ = uint64_t{0}; if (block_num_or_hash == kEarliestBlockId) { value_ = kEarliestBlockNum; } else if (block_num_or_hash == kLatestBlockId || block_num_or_hash == kPendingBlockId || block_num_or_hash == kFinalizedBlockId || block_num_or_hash == kSafeBlockId) { value_ = block_num_or_hash; } else if (absl::StartsWithIgnoreCase(block_num_or_hash, "0x")) { if (block_num_or_hash.size() == 66) { const auto b32_bytes = silkworm::from_hex(block_num_or_hash); const auto b32 = silkworm::to_bytes32(b32_bytes.value_or(silkworm::Bytes{})); value_ = b32; } else { value_ = std::stoul(block_num_or_hash, nullptr, 16); } } else { value_ = std::stoul(block_num_or_hash, nullptr, 10); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/block.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "receipt.hpp" namespace silkworm::rpc { struct Block { std::shared_ptr block_with_hash{nullptr}; bool full_tx{false}; uint64_t get_block_size() const; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const Block& b); class BlockNumOrHash { public: explicit BlockNumOrHash(const std::string& block_num_or_hash) { parse(block_num_or_hash); } explicit BlockNumOrHash(BlockNum block_num) noexcept : value_{block_num} {} virtual ~BlockNumOrHash() noexcept = default; BlockNumOrHash(const BlockNumOrHash&) noexcept = default; BlockNumOrHash& operator=(const BlockNumOrHash&) = default; BlockNumOrHash(BlockNumOrHash&&) = default; BlockNumOrHash& operator=(BlockNumOrHash&&) noexcept = default; bool is_number() const { return std::holds_alternative(value_); } uint64_t number() const { return is_number() ? *std::get_if(&value_) : 0; } bool is_hash() const { return std::holds_alternative(value_); } evmc::bytes32 hash() const { return is_hash() ? *std::get_if(&value_) : evmc::bytes32{0}; } bool is_tag() const { return std::holds_alternative(value_); } std::string tag() const { return is_tag() ? *std::get_if(&value_) : ""; } std::string to_string() const; private: void parse(std::string const& block_num_or_hash); std::variant value_; }; std::ostream& operator<<(std::ostream& out, const BlockNumOrHash& block_num_or_hash); struct BlockDetails { uint64_t block_size; evmc::bytes32 hash; silkworm::BlockHeader header; uint64_t transaction_count{0}; std::vector ommers; std::optional> withdrawals{std::nullopt}; }; struct IssuanceDetails { intx::uint256 miner_reward{0}; intx::uint256 ommers_reward{0}; intx::uint256 total_reward{0}; }; struct BlockDetailsResponse { BlockDetails block; IssuanceDetails issuance{}; intx::uint256 total_fees{0}; }; struct BlockTransactionsResponse { uint64_t block_size{0}; evmc::bytes32 hash; silkworm::BlockHeader header; uint64_t transaction_count{0}; std::vector ommers; std::vector receipts; std::vector transactions; std::optional> withdrawals{std::nullopt}; }; struct TransactionsWithReceipts { bool first_page{false}; bool last_page{false}; std::vector receipts; std::vector transactions; std::vector blocks; std::vector headers; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/block_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "block.hpp" #include #include #include #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_bytes32; evmc::bytes32 kZeroHash{0}; TEST_CASE("block_num_or_hash") { SECTION("ctor from hash string") { BlockNumOrHash block_num_or_hash{"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c"}; CHECK(block_num_or_hash.is_hash() == true); CHECK(block_num_or_hash.is_number() == false); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.hash() == 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32); CHECK(block_num_or_hash.number() == 0); CHECK(block_num_or_hash.tag().empty()); } SECTION("ctor from decimal number string") { BlockNumOrHash block_num_or_hash{"1966"}; CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == true); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.hash() == kZeroHash); CHECK(block_num_or_hash.number() == 1966); CHECK(block_num_or_hash.tag().empty()); } SECTION("ctor from hex number string") { BlockNumOrHash block_num_or_hash{"0x374f3"}; CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == true); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.hash() == kZeroHash); CHECK(block_num_or_hash.number() == 0x374f3); CHECK(block_num_or_hash.tag().empty()); } SECTION("ctor from 'latest' tag") { BlockNumOrHash block_num_or_hash{"latest"}; CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == false); CHECK(block_num_or_hash.is_tag() == true); CHECK(block_num_or_hash.hash() == kZeroHash); CHECK(block_num_or_hash.number() == 0); CHECK(block_num_or_hash.tag() == "latest"); } SECTION("ctor from 'earliest' tag") { BlockNumOrHash block_num_or_hash{"earliest"}; CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == true); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.hash() == kZeroHash); CHECK(block_num_or_hash.number() == 0); CHECK(block_num_or_hash.tag().empty()); } SECTION("ctor from 'pending' tag") { BlockNumOrHash block_num_or_hash{"pending"}; CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == false); CHECK(block_num_or_hash.is_tag() == true); CHECK(block_num_or_hash.hash() == kZeroHash); CHECK(block_num_or_hash.number() == 0); CHECK(block_num_or_hash.tag() == "pending"); } SECTION("ctor from number") { BlockNumOrHash block_num_or_hash{123456}; CHECK(block_num_or_hash.is_hash() == false); CHECK(block_num_or_hash.is_number() == true); CHECK(block_num_or_hash.is_tag() == false); CHECK(block_num_or_hash.hash() == kZeroHash); CHECK(block_num_or_hash.number() == 123456); CHECK(block_num_or_hash.tag().empty()); } SECTION("copy ctor") { BlockNumOrHash block_num_or_hash{"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c"}; BlockNumOrHash copy{block_num_or_hash}; // NOLINT(performance-unnecessary-copy-initialization) CHECK(block_num_or_hash.is_hash() == copy.is_hash()); CHECK(block_num_or_hash.is_number() == copy.is_number()); CHECK(block_num_or_hash.is_tag() == copy.is_tag()); CHECK(block_num_or_hash.hash() == copy.hash()); CHECK(block_num_or_hash.number() == 0); CHECK(block_num_or_hash.tag().empty()); } SECTION("copy hash") { BlockNumOrHash block_num_or_hash{"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c"}; BlockNumOrHash copy = block_num_or_hash; // NOLINT(performance-unnecessary-copy-initialization) CHECK(block_num_or_hash.is_hash() == copy.is_hash()); CHECK(block_num_or_hash.is_number() == copy.is_number()); CHECK(block_num_or_hash.is_tag() == copy.is_tag()); CHECK(block_num_or_hash.hash() == copy.hash()); } SECTION("copy number") { BlockNumOrHash block_num_or_hash{123456}; BlockNumOrHash copy = block_num_or_hash; // NOLINT(performance-unnecessary-copy-initialization) CHECK(block_num_or_hash.is_hash() == copy.is_hash()); CHECK(block_num_or_hash.is_number() == copy.is_number()); CHECK(block_num_or_hash.is_tag() == copy.is_tag()); CHECK(block_num_or_hash.number() == copy.number()); } SECTION("copy tag") { BlockNumOrHash block_num_or_hash{"latest"}; BlockNumOrHash copy = block_num_or_hash; // NOLINT(performance-unnecessary-copy-initialization) CHECK(block_num_or_hash.is_hash() == copy.is_hash()); CHECK(block_num_or_hash.is_number() == copy.is_number()); CHECK(block_num_or_hash.is_tag() == copy.is_tag()); CHECK(block_num_or_hash.tag() == copy.tag()); } SECTION("number overflow") { CHECK_THROWS_AS(BlockNumOrHash{"0x1ffffffffffffffff"}, std::out_of_range); } SECTION("invalid string") { CHECK_THROWS_AS(BlockNumOrHash{"invalid"}, std::invalid_argument); } SECTION("operator<<") { std::stringstream out; BlockNumOrHash block_num_or_hash1{"0x374f3"}; out << block_num_or_hash1; CHECK(out.str() == "0x374f3"); out.str(""); BlockNumOrHash block_num_or_hash2{"0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c"}; out << block_num_or_hash2; CHECK(out.str() == "0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c"); out.str(""); BlockNumOrHash block_num_or_hash3{"latest"}; out << block_num_or_hash3; CHECK(out.str() == "latest"); out.str(""); BlockNumOrHash block_num_or_hash4{"pending"}; out << block_num_or_hash4; CHECK(out.str() == "pending"); out.str(""); } } TEST_CASE("create empty block", "[rpc][types][block]") { Block b{}; CHECK(b.full_tx == false); } TEST_CASE("check size of EIP-2718 block from RLP", "[rpc][types][block]") { const char* rlp_hex{ "f90319f90211a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd4" "1ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ef1552a40b7165c3cd773806b9e0c165" "b75356e0314bf0706f279c729f51e017a0e6e49996c7ec59f7a23d22b83239a60151512c65613bf84a0d7da336399ebc4aa0cafe75574d" "59780665a97fbfd11365c7545aa8f1abf4e5e12e8243334ef7286bb9010000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000083020000820200832fefd882a410845506eb0796636f6f6c65737420626c6f636b206f6e20636861696ea0bd" "4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff49888a13a5a8c8f2bb1c4f90101f85f800a82c35094095e7bae" "a6a6c7c4c2dfeb977efac326af552d870a801ba09bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094fa08a8f" "ae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b1b89e01f89b01800a8301e24194095e7baea6a6c7c4c2dfeb97" "7efac326af552d878080f838f7940000000000000000000000000000000000000001e1a000000000000000000000000000000000000000" "0000000000000000000000000001a03dbacc8d0259f2508625e97fdfc57cd85fdd16e5821bc2c10bdd1a52649e8335a0476e10695b183a" "87b0aa292a7f4b78ef0c3fbe62aa2c42c84e1d9c3da159ef14c0"}; silkworm::Bytes rlp_bytes{*silkworm::from_hex(rlp_hex)}; silkworm::ByteView view{rlp_bytes}; auto block_with_hash = std::make_shared(); Block rpc_block{block_with_hash}; REQUIRE(silkworm::rlp::decode(view, rpc_block.block_with_hash->block)); CHECK(view.empty()); CHECK(rpc_block.get_block_size() == rlp_bytes.size()); CHECK_NOTHROW(test_util::null_stream() << rpc_block); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/cache_validation_result.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc { struct CacheValidationResult { const db::kv::api::StateCache::ValidationResult& ref; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/call.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call.hpp" #include #include #include #include #include #include namespace silkworm::rpc { static std::string optional_uint256_to_string(const std::optional& u) { return silkworm::to_hex(silkworm::endian::to_big_compact(u.value_or(intx::uint256{}))); } static std::string optional_bytes_to_string(const std::optional& u) { return silkworm::to_hex(u.value_or(silkworm::Bytes{})); } std::ostream& operator<<(std::ostream& out, const Call& call) { out << call.to_string(); return out; } std::string Call::to_string() const { const auto& call = *this; std::stringstream out; out << "from: " << call.from.value_or(evmc::address{}) << " " << "to: " << call.to.value_or(evmc::address{}) << " " << "gas: " << call.gas.value_or(0) << " " << "gas_price: " << optional_uint256_to_string(call.gas_price) << " " << "max_priority_fee_per_gas: " << optional_uint256_to_string(call.max_priority_fee_per_gas) << " " << "max_fee_per_gas: " << optional_uint256_to_string(call.max_fee_per_gas) << " " << "value: " << optional_uint256_to_string(call.value) << " " << "data: " << optional_bytes_to_string(call.data); return out.str(); } std::string bundles_to_string(const Bundles& bundles) { std::stringstream out; out << "["; bool first = true; for (const auto& bundle : bundles) { if (!first) { out << ", "; } out << "{" << bundle << "}"; first = false; } out << "]"; return out.str(); } std::ostream& operator<<(std::ostream& out, const Bundles& bundles) { out << bundles_to_string(bundles); return out; } std::ostream& operator<<(std::ostream& out, const Bundle& bundle) { out << bundle.to_string(); return out; } std::string Bundle::to_string() const { const auto& bundle = *this; std::stringstream out; out << "transactions: ["; for (const auto& transaction : bundle.transactions) { out << transaction; } out << "] "; out << "block_override: " << bundle.block_override; return out.str(); } std::ostream& operator<<(std::ostream& out, const BlockOverrides& bo) { out << bo.to_string(); return out; } std::string BlockOverrides::to_string() const { const auto& bo = *this; std::stringstream out; out << "block_num: " << bo.block_num.value_or(0) << " "; return out.str(); } std::ostream& operator<<(std::ostream& out, const SimulationContext& sc) { out << sc.to_string(); return out; } std::string SimulationContext::to_string() const { const auto& sc = *this; std::stringstream out; out << "block_num: " << sc.block_num << " " << "transaction_index: " << sc.transaction_index; return out.str(); } std::string accounts_overrides_to_string(const AccountsOverrides& ao) { std::stringstream out; out << "{"; bool first = true; for (const auto& item : ao) { if (!first) { out << ", "; } out << item.first << ": {" << item.second << "}"; first = false; } out << "} "; return out.str(); } std::ostream& operator<<(std::ostream& out, const AccountsOverrides& ao) { out << accounts_overrides_to_string(ao); return out; } std::ostream& operator<<(std::ostream& out, const AccountOverrides& ao) { out << ao.to_string(); return out; } std::string AccountOverrides::to_string() const { const auto& ao = *this; std::stringstream out; out << "balance: " << optional_uint256_to_string(ao.balance) << " " << "nonce: " << ao.nonce.value_or(0) << " " << "code: " << optional_bytes_to_string(ao.code) << " " << "state: #" << ao.state.size() << " " << "state_diff: #" << ao.state_diff.size() << " "; return out.str(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { // Gas limit cap for eth_call (increased wrt RPCDaemon) inline constexpr uint64_t kDefaultGasLimit{50'000'000}; struct Call { std::optional from; std::optional to; std::optional gas; std::optional gas_price; std::optional max_priority_fee_per_gas; std::optional max_fee_per_gas; std::optional value; std::optional data; std::optional nonce; AccessList access_list; silkworm::Transaction to_transaction( const std::optional& override_access_list = std::nullopt, const std::optional override_nonce = std::nullopt) const { silkworm::Transaction txn{}; txn.set_sender(from ? *from : evmc::address{}); txn.to = to; if (override_nonce) { txn.nonce = *override_nonce; } else if (nonce) { txn.nonce = *nonce; } if (override_access_list) { txn.access_list = *override_access_list; } else if (!access_list.empty()) { txn.access_list = access_list; } txn.gas_limit = gas.value_or(kDefaultGasLimit); if (gas > kDefaultGasLimit) { txn.gas_limit = kDefaultGasLimit; } if (gas_price) { // We need to update JSON RPC validation spec to uncomment the following assertion // SILKWORM_ASSERT(!max_priority_fee_per_gas && !max_fee_per_gas); txn.type = TransactionType::kLegacy; txn.max_priority_fee_per_gas = gas_price.value(); txn.max_fee_per_gas = gas_price.value(); } else { // We need to update JSON RPC validation spec to uncomment the following assertion // SILKWORM_ASSERT(!gas_price); txn.type = TransactionType::kDynamicFee; txn.max_priority_fee_per_gas = max_priority_fee_per_gas.value_or(intx::uint256{0}); txn.max_fee_per_gas = max_fee_per_gas.value_or(intx::uint256{0}); } txn.value = value.value_or(intx::uint256{0}); txn.data = data.value_or(silkworm::Bytes{}); return txn; } std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const Call& call); struct BlockOverrides { std::optional block_num; std::optional coin_base; std::optional timestamp; std::optional difficulty; std::optional gas_limit; std::optional base_fee; std::map block_hash; std::string to_string() const; }; struct SimulationContext { BlockNumOrHash block_num{0}; std::int32_t transaction_index{-1}; std::string to_string() const; }; struct AccountOverrides { std::optional nonce; std::optional balance; std::optional code; std::optional code_hash; std::map state; std::map state_diff; std::string to_string() const; }; struct Bundle { std::vector transactions; BlockOverrides block_override; std::string to_string() const; }; using Bundles = std::vector; using AccountsOverrides = std::map; std::ostream& operator<<(std::ostream& out, const Bundles& bundles); std::ostream& operator<<(std::ostream& out, const Bundle& bundle); std::ostream& operator<<(std::ostream& out, const BlockOverrides& bo); std::ostream& operator<<(std::ostream& out, const SimulationContext& sc); std::ostream& operator<<(std::ostream& out, const AccountsOverrides& ao); std::ostream& operator<<(std::ostream& out, const AccountOverrides& ao); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/call_bundle.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { struct CallBundleTxInfo { ethash_hash256 hash; uint64_t gas_used; evmc::bytes32 value; std::string error_message; }; struct CallBundleInfo { ethash_hash256 bundle_hash; std::vector txs_info; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/call_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "call.hpp" #include #include #include #include #include #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("empty call", "[rpc][types][call]") { Call call{}; CHECK(call.from == std::nullopt); CHECK(call.to == std::nullopt); CHECK(call.gas == std::nullopt); CHECK(call.gas_price == std::nullopt); CHECK(call.max_priority_fee_per_gas == std::nullopt); CHECK(call.max_fee_per_gas == std::nullopt); CHECK(call.value == std::nullopt); CHECK(call.data == std::nullopt); CHECK(call.nonce == std::nullopt); CHECK(call.access_list.empty()); } TEST_CASE("call with gas price", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas 21000, // gas_price std::nullopt, // max_priority_fee_per_gas std::nullopt, // max_fee_per_gas 31337, // value {}, // data 1, // nonce {}, }; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 21000); CHECK(txn.max_priority_fee_per_gas == 21000); CHECK(txn.nonce == 1); } TEST_CASE("call w/o gas price and max_fee_per_gas & max_priority_fee_per_gas not zero", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas std::nullopt, // gas_price 18000, // max_priority_fee_per_gas 18000, // max_fee_per_gas 31337, // value {}, // data 1, // nonce {}, }; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 18000); CHECK(txn.max_priority_fee_per_gas == 18000); CHECK(txn.nonce == 1); } TEST_CASE("call w/o gas price, max_fee_per_gas & max_priority_fee_per_gas", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas std::nullopt, // gas_price std::nullopt, // max_priority_fee_per_gas std::nullopt, // max_fee_per_gas 31337, // value {}, // data 1, // nonce {}, }; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 0); CHECK(txn.max_priority_fee_per_gas == 0); CHECK(txn.nonce == 1); } TEST_CASE("call w/o gas price with base_fee", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas std::nullopt, // gas_price std::nullopt, // max_priority_fee_per_gas std::nullopt, // max_fee_per_gas 31337, // value {}, // data 1, // nonce {}, }; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 0); CHECK(txn.max_priority_fee_per_gas == 0); CHECK(txn.nonce == 1); } TEST_CASE("call with gas price and base_fee", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas 21000, // gas_price std::nullopt, // max_priority_fee_per_gas std::nullopt, // max_fee_per_gas 31337, // value {}, // data 1, // nonce {}, }; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 21000); CHECK(txn.max_priority_fee_per_gas == 21000); CHECK(txn.nonce == 1); } AccessList access_list{ {0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae_address, { 0x0000000000000000000000000000000000000000000000000000000000000003_bytes32, 0x0000000000000000000000000000000000000000000000000000000000000007_bytes32, }}, {0xbb9bc244d798123fde783fcc1c72d3bb8c189413_address, {}}, }; TEST_CASE("call with no gas price and no max_fee_per_gas and max_priority_fee_per_gas", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas 0, // gas_price std::nullopt, std::nullopt, std::nullopt, std::nullopt, 23, }; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 0); CHECK(txn.nonce == 23); CHECK(txn.max_priority_fee_per_gas == 0); } TEST_CASE("call with no gas price and valid max_fee_per_gas and max_priority_fee_per_gas", "[rpc][types][call]") { Call call{ 0x99f9b87991262f6ba471f09758cde1c0fc1de734_address, // from 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address, // to 235, // gas std::nullopt, // gas_price 10000, // max_fee_per_gas 10000, // max_priority_fee_per_gas 31337, // value silkworm::from_hex("001122aabbcc")}; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.sender() == 0x99f9b87991262f6ba471f09758cde1c0fc1de734_address); CHECK(txn.to == 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 10000); CHECK(txn.max_priority_fee_per_gas == 10000); CHECK(txn.value == 31337); CHECK(txn.data == silkworm::from_hex("001122aabbcc")); } TEST_CASE("call with no gas", "[rpc][types][call]") { Call call; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 50000000); CHECK(txn.value == 0); CHECK(txn.data.empty()); } TEST_CASE("call with AccessList", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas 21000, // gas_price std::nullopt, // max_priority_fee_per_gas std::nullopt, // max_fee_per_gas 31337, // value {}, // data 1, // nonce access_list}; silkworm::Transaction txn = call.to_transaction(); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 21000); CHECK(txn.max_priority_fee_per_gas == 21000); CHECK(txn.nonce == 1); CHECK(!txn.access_list.empty()); CHECK(txn.access_list == access_list); } TEST_CASE("call with no AccessList and pass it to_transaction", "[rpc][types][call]") { Call call{ std::nullopt, std::nullopt, 235, // gas 21000, // gas_price std::nullopt, // max_priority_fee_per_gas std::nullopt, // max_fee_per_gas 31337, // value {}, // data 1}; // nonce silkworm::Transaction txn = call.to_transaction(access_list); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 21000); CHECK(txn.max_priority_fee_per_gas == 21000); CHECK(txn.nonce == 1); CHECK(!txn.access_list.empty()); CHECK(txn.access_list == access_list); } TEST_CASE("call with no nonce and pass it to_transaction", "[rpc][types][call]") { uint64_t nonce = 5; Call call{ std::nullopt, std::nullopt, 235, // gas 21000, // gas_price std::nullopt, // max_priority_fee_per_gas std::nullopt, // max_fee_per_gas 31337, // value {}, // data std::nullopt}; // nonce silkworm::Transaction txn = call.to_transaction(std::nullopt, nonce); CHECK(txn.gas_limit == 235); CHECK(txn.max_fee_per_gas == 21000); CHECK(txn.max_priority_fee_per_gas == 21000); CHECK(txn.nonce == nonce); CHECK(txn.access_list.empty()); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/chain_config.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "chain_config.hpp" #include #include #include namespace silkworm::rpc { std::string chain_config_to_string(const ChainConfig& chain_config) { std::stringstream out; out << "genesis: " << to_hex(chain_config.genesis_hash.value_or(evmc::bytes32{})) << " " << "config: " << chain_config.to_json().dump(); return out.str(); } std::ostream& operator<<(std::ostream& out, const ChainConfig& chain_config) { out << chain_config_to_string(chain_config); return out; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/chain_config.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::rpc { struct Forks { evmc::bytes32 genesis_hash; std::vector block_nums; std::vector block_times; explicit Forks(const ChainConfig& cc) : genesis_hash(cc.genesis_hash.value_or(evmc::bytes32{})) { for (auto& fork_block_num : cc.distinct_fork_block_nums()) { if (fork_block_num) { // Skip any forks in block 0, that's the genesis ruleset block_nums.push_back(fork_block_num); } } for (auto& fork_block_time : cc.distinct_fork_times()) { if (fork_block_time) { // Skip any forks in block 0, that's the genesis ruleset block_times.push_back(fork_block_time); } } } }; std::ostream& operator<<(std::ostream& out, const ChainConfig& chain_config); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/chain_config_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "chain_config.hpp" #include #include #include #include namespace silkworm::rpc { /*TEST_CASE("create empty chain config", "[rpc][types][chain_config]") { ChainConfig chain_config{}; CHECK(chain_config.genesis_hash == evmc::bytes32{}); CHECK(chain_config.config == R"(null)"_json); } TEST_CASE("print empty chain config", "[rpc][types][chain_config]") { ChainConfig chain_config{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << chain_config); } TEST_CASE("cannot create forks from empty chain config", "[rpc][types][chain_config]") { ChainConfig chain_config{}; CHECK_THROWS_AS(Forks{chain_config}, std::system_error); } TEST_CASE("create forks from chain config", "[rpc][types][chain_config]") { ChainConfig chain_config{ 0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3_bytes32, R"({ "berlinBlock":12244000, "byzantiumBlock":4370000, "chainId":1, "constantinopleBlock":7280000, "daoForkBlock":1920000, "eip150Block":2463000, "eip155Block":2675000, "ethash":{}, "homesteadBlock":1150000, "istanbulBlock":9069000, "londonBlock":12965000, "muirGlacierBlock":9200000, "petersburgBlock":7280000 })"_json}; Forks forks{chain_config}; CHECK(forks.genesis_hash == 0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3_bytes32); CHECK(forks.block_nums[0] == 1'150'000); CHECK(forks.block_nums[1] == 1'920'000); CHECK(forks.block_nums[2] == 2'463'000); CHECK(forks.block_nums[3] == 2'675'000); CHECK(forks.block_nums[4] == 4'370'000); CHECK(forks.block_nums[5] == 7'280'000); CHECK(forks.block_nums[6] == 9'069'000); CHECK(forks.block_nums[7] == 9'200'000); CHECK(forks.block_nums[8] == 12'244'000); CHECK(forks.block_nums[9] == 12'965'000); }*/ } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/chain_traffic.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::rpc { struct ChainTraffic { intx::uint<256> cumulative_gas_used; uint64_t cumulative_transactions_count{0}; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/dump_account.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "dump_account.hpp" #include #include #include #include #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const DumpAccounts& dump) { out << dump.to_string(); return out; } std::string DumpAccounts::to_string() const { const auto& dump = *this; std::stringstream out; out << "root: 0x" << silkworm::to_hex(dump.root) << " next: " << dump.next << " accounts: " << dump.accounts.size(); return out.str(); } void to_json(nlohmann::json& json, const DumpAccounts& dump) { nlohmann::json accounts({}); for (const auto& entry : dump.accounts) { nlohmann::json item; to_json(item, entry.second); accounts.push_back(nlohmann::json::object_t::value_type(address_to_hex(entry.first), item)); } auto encoded = base64_encode({dump.next.bytes, kAddressLength}, false); json = { {"root", dump.root}, {"accounts", accounts}, {"next", encoded}}; } void to_json(nlohmann::json& json, const DumpAccount& dump_account) { json["balance"] = to_string(dump_account.balance); json["nonce"] = dump_account.nonce; json["root"] = dump_account.root; json["codeHash"] = dump_account.code_hash; if (dump_account.code) { json["code"] = silkworm::to_hex(dump_account.code.value(), /*with_prefix=*/true); } if (dump_account.storage) { nlohmann::json storage({}); for (const auto& entry : dump_account.storage.value()) { storage[silkworm::to_hex(entry.first, /*with_prefix=*/true)] = silkworm::to_hex(entry.second); } json["storage"] = storage; } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/dump_account.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::rpc { using Storage = std::map; struct DumpAccount { intx::uint256 balance{}; uint64_t nonce{0}; uint64_t incarnation{0}; evmc::bytes32 root{0}; evmc::bytes32 code_hash{0}; std::optional code; std::optional storage; }; using AccountsMap = std::map; struct DumpAccounts { evmc::bytes32 root{0}; evmc::address next{0}; AccountsMap accounts; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const DumpAccounts& dump); void to_json(nlohmann::json& json, const DumpAccounts& dump); void to_json(nlohmann::json& json, const DumpAccount& dump_account); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/dump_account_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "dump_account.hpp" #include #include #include #include #include namespace silkworm::rpc { static constexpr evmc::address kZeroAddress; static constexpr evmc::bytes32 kEmptyHash; static constexpr intx::uint256 kZeroBalance = intx::uint256{0}; using evmc::literals::operator""_address; using evmc::literals::operator""_bytes32; TEST_CASE("Empty DumpAccounts", "[rpc][types][dump_account]") { DumpAccounts da; SECTION("check fields") { CHECK(da.root == kEmptyHash); CHECK(da.accounts.empty()); CHECK(da.next == kZeroAddress); } SECTION("print") { CHECK_NOTHROW(silkworm::test_util::null_stream() << da); } SECTION("json") { nlohmann::json json = da; CHECK(json == R"({ "accounts": {}, "next": "AAAAAAAAAAAAAAAAAAAAAAAAAAA=", "root": "0x0000000000000000000000000000000000000000000000000000000000000000" })"_json); } } TEST_CASE("Filled DumpAccounts", "[rpc][types][dump_account]") { DumpAccount da{ 10, 20, 30, 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32, 0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32}; DumpAccounts das{ 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32, 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address, AccountsMap{ {0x0000000000000000000000000000000000000000_address, da}}}; SECTION("check fields") { CHECK(das.root == 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32); CHECK(das.accounts.size() == 1); CHECK(das.next == 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address); } SECTION("print") { CHECK_NOTHROW(silkworm::test_util::null_stream() << das); } SECTION("json") { nlohmann::json json = das; CHECK(json == R"({ "accounts":{ "0x0000000000000000000000000000000000000000":{ "balance":"10", "codeHash":"0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6", "nonce":20, "root":"0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6" } }, "next":"eaTUGPeIfdTVEjpBtsjBhmhq6Ms=", "root":"0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6" })"_json); } } TEST_CASE("Filled zero-account DumpAccounts", "[rpc][types][dump_account]") { DumpAccounts da{ 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32, 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address}; SECTION("check fields") { CHECK(da.root == 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32); CHECK(da.accounts.empty()); CHECK(da.next == 0x79a4d418f7887dd4d5123a41b6c8c186686ae8cb_address); } SECTION("print") { CHECK_NOTHROW(silkworm::test_util::null_stream() << da); } SECTION("json") { nlohmann::json json = da; CHECK(json == R"({ "accounts": {}, "next": "eaTUGPeIfdTVEjpBtsjBhmhq6Ms=", "root": "0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6" })"_json); } } TEST_CASE("Empty DumpAccount", "[rpc][types][dump_account]") { DumpAccount da; SECTION("check fields") { CHECK(da.balance == kZeroBalance); CHECK(da.nonce == 0); CHECK(da.incarnation == 0); CHECK(da.root == kEmptyHash); CHECK(da.code_hash == kEmptyHash); CHECK(da.code == std::nullopt); CHECK(da.storage == std::nullopt); } SECTION("json") { nlohmann::json json = da; CHECK(json == R"({ "balance":"0", "codeHash":"0x0000000000000000000000000000000000000000000000000000000000000000", "nonce":0, "root":"0x0000000000000000000000000000000000000000000000000000000000000000" })"_json); } } TEST_CASE("Filled externally-owned DumpAccount", "[rpc][types][dump_account]") { DumpAccount da{ 10, 20, 30, 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32, 0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32}; SECTION("check fields") { CHECK(da.balance == 10); CHECK(da.nonce == 20); CHECK(da.incarnation == 30); CHECK(da.root == 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32); CHECK(da.code_hash == 0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32); CHECK(da.code == std::nullopt); CHECK(da.storage == std::nullopt); } SECTION("json") { nlohmann::json json = da; CHECK(json == R"({ "balance":"10", "codeHash":"0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6", "nonce":20, "root":"0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6" })"_json); } } TEST_CASE("Filled contract DumpAccount", "[rpc][types][dump_account]") { DumpAccount da{ 10, 20, 30, 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32, 0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32, silkworm::from_hex("0x0608"), Storage{ {0x209f062567c161c5f71b3f57a7de277b0e95c3455050b152d785ad7524ef8ee7_bytes32, *silkworm::from_hex("0x0000000000000000000000000000000000000000000000000000000000000000")}}}; SECTION("check fields") { CHECK(da.balance == 10); CHECK(da.nonce == 20); CHECK(da.incarnation == 30); CHECK(da.root == 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32); CHECK(da.code_hash == 0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6_bytes32); CHECK(da.code == silkworm::Bytes{0x06, 0x08}); CHECK(da.storage == Storage{{0x209f062567c161c5f71b3f57a7de277b0e95c3455050b152d785ad7524ef8ee7_bytes32, *silkworm::from_hex("0x0000000000000000000000000000000000000000000000000000000000000000")}}); } SECTION("json") { nlohmann::json json = da; CHECK(json == R"({ "balance":"10", "codeHash":"0xc10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6", "nonce":20, "root":"0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6", "code":"0x0608", "storage":{ "0x209f062567c161c5f71b3f57a7de277b0e95c3455050b152d785ad7524ef8ee7": "0000000000000000000000000000000000000000000000000000000000000000" } })"_json); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/error.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "error.hpp" #include #include #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const Error& error) { out << error.to_string(); return out; } std::string Error::to_string() const { const auto& error = *this; std::stringstream out; out << " code: " << error.code << " message: " << error.message; return out.str(); } std::ostream& operator<<(std::ostream& out, const RevertError& error) { out << error.to_string(); return out; } std::string RevertError::to_string() const { const auto& error = *this; std::stringstream out; out << " code: " << error.code << " message: " << error.message << " data: " << silkworm::to_hex(error.data); return out.str(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/error.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc { struct Error { int code{0}; std::string message; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const Error& error); struct RevertError : public Error { silkworm::Bytes data; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const RevertError& error); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/error_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "error.hpp" #include #include #include namespace silkworm::rpc { TEST_CASE("create empty error", "[rpc][types][error]") { Error err{}; CHECK(err.code == 0); CHECK(err.message.empty()); } TEST_CASE("create empty revert error", "[rpc][types][error]") { RevertError err{}; CHECK(err.code == 0); CHECK(err.message.empty()); CHECK(err.data.empty()); } TEST_CASE("print empty error", "[rpc][types][error]") { Error err{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << err); } TEST_CASE("print empty revert error", "[rpc][types][error]") { RevertError err{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << err); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/execution_payload.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "execution_payload.hpp" #include #include #include #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const ExecutionPayload& payload) { out << payload.to_string(); return out; } std::string ExecutionPayload::to_string() const { const auto& payload = *this; std::stringstream out; auto bloom_bytes{silkworm::ByteView(&payload.logs_bloom[0], 256)}; out << "version: " << payload.version << " block_num: " << payload.block_num << " block_hash: " << to_hex(payload.block_hash) << " parent_hash: " << to_hex(payload.parent_hash) << " timestamp: " << payload.timestamp << " gas_limit: " << payload.gas_limit << " gas_used: " << payload.gas_used << " suggested_fee_recipient: " << payload.suggested_fee_recipient << " state_root: " << to_hex(payload.state_root) << " receipts_root: " << to_hex(payload.receipts_root) << " prev_randao: " << to_hex(payload.prev_randao) << " logs_bloom: " << silkworm::to_hex(bloom_bytes) << " extra_data: " << silkworm::to_hex(payload.extra_data) << " #transactions: " << payload.transactions.size(); if (payload.withdrawals) { out << " #withdrawals: " << payload.withdrawals->size(); } return out.str(); } std::ostream& operator<<(std::ostream& out, const PayloadStatus& payload_status) { out << payload_status.to_string(); return out; } std::string PayloadStatus::to_string() const { const auto& payload_status = *this; std::stringstream out; out << "status: " << payload_status.status; if (payload_status.latest_valid_hash) { out << " latest_valid_hash: " << to_hex(*payload_status.latest_valid_hash); } if (payload_status.validation_error) { out << " validation_error: " << *payload_status.validation_error; } return out.str(); } std::ostream& operator<<(std::ostream& out, const ForkChoiceState& fork_choice_state) { out << fork_choice_state.to_string(); return out; } std::string ForkChoiceState::to_string() const { const auto& fork_choice_state = *this; std::stringstream out; out << "head_block_hash: " << to_hex(fork_choice_state.head_block_hash) << " safe_block_hash: " << to_hex(fork_choice_state.safe_block_hash) << " finalized_block_hash: " << to_hex(fork_choice_state.finalized_block_hash); return out.str(); } std::ostream& operator<<(std::ostream& out, const PayloadAttributes& attributes) { out << attributes.to_string(); return out; } std::string PayloadAttributes::to_string() const { const auto& attributes = *this; std::stringstream out; out << "version: " << attributes.version << " timestamp: " << attributes.timestamp << " prev_randao: " << to_hex(attributes.prev_randao) << " suggested_fee_recipient: " << attributes.suggested_fee_recipient; if (attributes.withdrawals) { out << " #withdrawals: " << attributes.withdrawals->size(); } return out.str(); } std::ostream& operator<<(std::ostream& out, const ForkChoiceUpdatedRequest& fcu_request) { out << fcu_request.to_string(); return out; } std::string ForkChoiceUpdatedRequest::to_string() const { const auto& fcu_request = *this; std::stringstream out; out << fcu_request.fork_choice_state; if (fcu_request.payload_attributes) { out << " " << *fcu_request.payload_attributes; } return out.str(); } std::ostream& operator<<(std::ostream& out, const ForkChoiceUpdatedReply& fcu_reply) { out << fcu_reply.to_string(); return out; } std::string ForkChoiceUpdatedReply::to_string() const { const auto& fcu_reply = *this; std::stringstream out; out << fcu_reply.payload_status; if (fcu_reply.payload_id) { out << " payload_id: " << *fcu_reply.payload_id; } return out.str(); } std::ostream& operator<<(std::ostream& out, const TransitionConfiguration& transition_configuration) { out << transition_configuration.to_string(); return out; } std::string TransitionConfiguration::to_string() const { const auto& transition_configuration = *this; std::stringstream out; out << "terminal_total_difficulty: " << transition_configuration.terminal_total_difficulty << " terminal_block_hash: " << to_hex(transition_configuration.terminal_block_hash) << " terminal_block_num: " << transition_configuration.terminal_block_num; return out.str(); } std::ostream& operator<<(std::ostream& out, const ExecutionPayloadAndValue& pv) { out << pv.to_string(); return out; } std::string ExecutionPayloadAndValue::to_string() const { const auto& pv = *this; std::stringstream out; out << "payload: " << pv.payload << " block_value: " << pv.block_value; return out.str(); } std::ostream& operator<<(std::ostream& out, const ExecutionPayloadBody& body) { out << body.to_string(); return out; } std::string ExecutionPayloadBody::to_string() const { const auto& body = *this; std::stringstream out; if (body.transactions) { out << "#transactions: " << body.transactions->size(); if (body.withdrawals) { out << " #withdrawals: " << body.withdrawals->size(); } } else { out << "null"; } return out.str(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/execution_payload.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { //! Capabilities as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md#engine_exchangecapabilities using Capabilities = std::vector; //! ExecutionPayload represents either //! ExecutionPayloadV1 as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#executionpayloadv1 //! or //! ExecutionPayloadV2 as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#executionpayloadv2 //! or //! ExecutionPayloadV3 as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#executionpayloadv3 struct ExecutionPayload { enum Version : uint8_t { kV1 = 1, kV2 = 2, kV3 = 3 } version{kV1}; BlockNum block_num{0}; uint64_t timestamp{0}; uint64_t gas_limit{0}; uint64_t gas_used{0}; evmc::address suggested_fee_recipient; evmc::bytes32 state_root; evmc::bytes32 receipts_root; evmc::bytes32 parent_hash; evmc::bytes32 block_hash; evmc::bytes32 prev_randao; intx::uint256 base_fee; Bloom logs_bloom{}; Bytes extra_data; std::vector transactions; std::optional> withdrawals; // present iff version == V2 std::optional blob_gas_used; // present iff version == V3 std::optional excess_blob_gas; // present iff version == V3 std::string to_string() const; }; //! ForkChoiceStateV1 as specified by https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#forkchoicestatev1 struct ForkChoiceState { evmc::bytes32 head_block_hash; evmc::bytes32 safe_block_hash; evmc::bytes32 finalized_block_hash; std::string to_string() const; }; //! PayloadAttributes represents either //! PayloadAttributesV1 as specified by https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#payloadattributesv1 //! or //! PayloadAttributesV2 as specified by https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#payloadattributesv2 //! or //! PayloadAttributesV3 as specified by https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#payloadattributesv3 struct PayloadAttributes { enum Version : uint8_t { kV1 = 1, kV2 = 2, kV3 = 3 } version{kV1}; uint64_t timestamp{0}; evmc::bytes32 prev_randao; evmc::address suggested_fee_recipient; std::optional> withdrawals; // present iff version == V2 std::optional parent_beacon_block_root; // present iff version == V3 std::string to_string() const; }; struct NewPayloadRequest { rpc::ExecutionPayload execution_payload; std::optional> expected_blob_versioned_hashes; std::optional parent_beacon_block_root; std::optional> execution_requests; }; //! PayloadStatusV1 as specified by https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#payloadstatusv1 struct PayloadStatus { static constexpr std::string_view kValidStr{"VALID"}; static constexpr std::string_view kInvalidStr{"INVALID"}; static constexpr std::string_view kSyncingStr{"SYNCING"}; static constexpr std::string_view kAcceptedStr{"ACCEPTED"}; static constexpr std::string_view kInvalidBlockHashStr{"INVALID_BLOCK_HASH"}; static const PayloadStatus kSyncing; static const PayloadStatus kAccepted; static const PayloadStatus kInvalidBlockHash; std::string status; std::optional latest_valid_hash; std::optional validation_error; std::string to_string() const; }; inline const PayloadStatus PayloadStatus::kSyncing{.status = std::string{PayloadStatus::kSyncingStr}}; inline const PayloadStatus PayloadStatus::kAccepted{.status = std::string{PayloadStatus::kAcceptedStr}}; inline const PayloadStatus PayloadStatus::kInvalidBlockHash{.status = std::string{PayloadStatus::kInvalidBlockHashStr}}; inline bool operator==(const PayloadStatus& lhs, const PayloadStatus& rhs) { return lhs.status == rhs.status; } struct ForkChoiceUpdatedRequest { ForkChoiceState fork_choice_state; std::optional payload_attributes; std::string to_string() const; }; struct ForkChoiceUpdatedReply { PayloadStatus payload_status; std::optional payload_id; std::string to_string() const; }; //! TransitionConfigurationV1 as specified by https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#transitionconfigurationv1 struct TransitionConfiguration { intx::uint256 terminal_total_difficulty; evmc::bytes32 terminal_block_hash; BlockNum terminal_block_num{0}; std::string to_string() const; }; //! Response for engine_getPayloadV2 as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#response-2 struct ExecutionPayloadAndValue { ExecutionPayload payload; intx::uint256 block_value; // in wei std::string to_string() const; }; //! ExecutionPayloadBodyV1 as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#executionpayloadbodyv1 struct ExecutionPayloadBody { std::optional> transactions; // not present iff requested block is missing std::optional> withdrawals; // present iff after Shanghai std::string to_string() const; }; using ExecutionPayloadBodies = std::vector; //! BlobsBundleV1 as specified in https://github.com/ethereum/execution-apis/blob/main/src/engine/cancun.md#blobsbundlev1 struct BlobsBundle { using KZGCommitment = std::array; using KZGProof = std::array; using Blob = std::array; std::vector commitments; std::vector proofs; std::vector blobs; }; std::ostream& operator<<(std::ostream& out, const ExecutionPayload& payload); std::ostream& operator<<(std::ostream& out, const PayloadStatus& payload_status); std::ostream& operator<<(std::ostream& out, const ForkChoiceState& fork_choice_state); std::ostream& operator<<(std::ostream& out, const PayloadAttributes& payload_attributes); std::ostream& operator<<(std::ostream& out, const ForkChoiceUpdatedRequest& fcu_request); std::ostream& operator<<(std::ostream& out, const ForkChoiceUpdatedReply& fcu_reply); std::ostream& operator<<(std::ostream& out, const TransitionConfiguration& transition_configuration); std::ostream& operator<<(std::ostream& out, const ExecutionPayloadAndValue& pv); std::ostream& operator<<(std::ostream& out, const ExecutionPayloadBody& body); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/execution_payload_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "execution_payload.hpp" // NOLINT(build/include) #include #include namespace silkworm::rpc { TEST_CASE("print empty ExecutionPayloadV1", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << ExecutionPayload{.version = ExecutionPayload::kV1}); } TEST_CASE("print empty ExecutionPayloadV2", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << ExecutionPayload{.version = ExecutionPayload::kV2}); } TEST_CASE("print empty PayloadStatus", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << PayloadStatus{}); } TEST_CASE("print empty ForkChoiceState", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << ForkChoiceState{}); } TEST_CASE("print empty PayloadAttributesV1", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << PayloadAttributes{.version = PayloadAttributes::kV1}); } TEST_CASE("print empty PayloadAttributesV2", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << PayloadAttributes{.version = PayloadAttributes::kV2}); } TEST_CASE("print empty ForkChoiceUpdatedRequest", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << ForkChoiceUpdatedRequest{}); } TEST_CASE("print empty ForkChoiceUpdatedReply", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << ForkChoiceUpdatedReply{}); } TEST_CASE("print empty TransitionConfiguration", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << TransitionConfiguration{}); } TEST_CASE("print empty ExecutionPayloadAndValue", "[silkworm][rpc][types]") { ExecutionPayloadAndValue pv{.payload = {.version = ExecutionPayload::kV2}, .block_value = 0}; CHECK_NOTHROW(silkworm::test_util::null_stream() << pv); } TEST_CASE("print empty ExecutionPayloadBody", "[silkworm][rpc][types]") { CHECK_NOTHROW(silkworm::test_util::null_stream() << ExecutionPayloadBody{}); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/filter.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "filter.hpp" #include #include #include #include std::string filter_addresses_to_string(const std::optional& addresses) { std::stringstream out; if (addresses.has_value()) { const auto& address_vector = addresses.value(); out << "["; for (size_t i{0}; i < address_vector.size(); ++i) { out << address_vector[i]; if (i != address_vector.size() - 1) { out << " "; } } out << "]"; } else { out << "null"; } return out.str(); } std::ostream& operator<<(std::ostream& out, const std::optional& addresses) { out << filter_addresses_to_string(addresses); return out; } std::string filter_subtopics_to_string(const silkworm::rpc::FilterSubTopics& subtopics) { std::stringstream out; out << "["; for (size_t i{0}; i < subtopics.size(); ++i) { out << silkworm::to_hex(subtopics[i], true); if (i != subtopics.size() - 1) { out << " "; } } out << "]"; return out.str(); } std::ostream& operator<<(std::ostream& out, const silkworm::rpc::FilterSubTopics& subtopics) { out << filter_subtopics_to_string(subtopics); return out; } std::string filter_topics_to_string(const std::optional& topics) { std::stringstream out; if (topics.has_value()) { const auto& topic_vector = topics.value(); out << "["; for (size_t i{0}; i < topic_vector.size(); ++i) { out << topic_vector[i]; if (i != topic_vector.size() - 1) { out << " "; } } out << "]"; } else { out << "null"; } return out.str(); } std::ostream& operator<<(std::ostream& out, const std::optional& topics) { out << filter_topics_to_string(topics); return out; } namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const Filter& filter) { out << filter.to_string(); return out; } std::string Filter::to_string() const { const auto& filter = *this; std::stringstream out; out << "from_block: " << filter.from_block.value_or("null"); out << ", to_block: " << filter.to_block.value_or("null"); out << ", addresses: " << filter.addresses; out << ", topics: " << filter.topics; out << ", block_hash: " << filter.block_hash.value_or("null"); return out.str(); } std::ostream& operator<<(std::ostream& out, const LogFilterOptions& filter_options) { out << filter_options.to_string(); return out; } std::string LogFilterOptions::to_string() const { const auto& filter_options = *this; std::stringstream out; out << "add_timestamp: " << std::boolalpha << filter_options.add_timestamp; out << ", logCount: " << filter_options.log_count; out << ", blockCount: " << filter_options.block_count; out << ", ignore_topics_order: " << std::boolalpha << filter_options.ignore_topics_order; return out.str(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/filter.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc { using FilterAddresses = std::vector; using FilterSubTopics = std::vector; using FilterTopics = std::vector; struct Filter { std::optional from_block; std::optional to_block; FilterAddresses addresses; FilterTopics topics; std::optional block_hash; std::string to_string() const; }; struct LogFilterOptions { bool add_timestamp{false}; bool overwrite_log_index{false}; std::uint64_t log_count{0}; std::uint64_t block_count{0}; bool ignore_topics_order{false}; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const Filter& filter); std::ostream& operator<<(std::ostream& out, const LogFilterOptions& filter_options); } // namespace silkworm::rpc std::ostream& operator<<(std::ostream& out, const std::optional& addresses); std::ostream& operator<<(std::ostream& out, const silkworm::rpc::FilterSubTopics& subtopics); std::ostream& operator<<(std::ostream& out, const std::optional& topics); ================================================ FILE: silkworm/rpc/types/filter_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "filter.hpp" #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("write null filter addresses to ostream", "[rpc][types][filter]") { std::optional addresses{std::nullopt}; std::ostringstream oss; oss << addresses; CHECK(oss.str() == "null"); } TEST_CASE("write 0-sized filter addresses to ostream", "[rpc][types][filter]") { FilterAddresses addresses{}; std::ostringstream oss; oss << addresses; CHECK(oss.str() == "[]"); } TEST_CASE("write 1-sized filter addresses to ostream", "[rpc][types][filter]") { FilterAddresses addresses{0x6090a6e47849629b7245dfa1ca21d94cd15878ef_address}; std::ostringstream oss; oss << addresses; CHECK(oss.str() == "[0x6090a6e47849629b7245dfa1ca21d94cd15878ef]"); } TEST_CASE("write 2-sized filter addresses to ostream", "[rpc][types][filter]") { FilterAddresses addresses{ 0x6090a6e47849629b7245dfa1ca21d94cd15878ef_address, 0x702a999710cfd011b475505335d4f437d8132fae_address}; std::ostringstream oss; oss << addresses; CHECK(oss.str() == "[0x6090a6e47849629b7245dfa1ca21d94cd15878ef 0x702a999710cfd011b475505335d4f437d8132fae]"); } TEST_CASE("write 0-sized filter subtopics to ostream", "[rpc][types][filter]") { FilterSubTopics subtopics{}; std::ostringstream oss; oss << subtopics; CHECK(oss.str() == "[]"); } TEST_CASE("write 1-sized filter subtopics to ostream", "[rpc][types][filter]") { FilterSubTopics subtopics{0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; std::ostringstream oss; oss << subtopics; CHECK(oss.str() == "[0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c]"); } TEST_CASE("write 2-sized filter subtopics to ostream", "[rpc][types][filter]") { FilterSubTopics subtopics{ 0x0000000000000000000000000000000000000000000000000000000000000000_bytes32, 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}; std::ostringstream oss; oss << subtopics; CHECK(oss.str() == R"([0x0000000000000000000000000000000000000000000000000000000000000000 0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c])"); } TEST_CASE("write null filter topics to ostream", "[rpc][types][filter]") { std::optional topics{std::nullopt}; std::ostringstream oss; oss << topics; CHECK(oss.str() == "null"); } TEST_CASE("write 0-sized filter topics to ostream", "[rpc][types][filter]") { FilterTopics topics{}; std::ostringstream oss; oss << topics; CHECK(oss.str() == "[]"); } TEST_CASE("write 1-sized filter topics to ostream", "[rpc][types][filter]") { FilterTopics topics{ {0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}, {0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}, }; std::ostringstream oss; oss << topics; CHECK(oss.str() == "[[0x0000000000000000000000000000000000000000000000000000000000000000] [0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c]]"); } TEST_CASE("write filter to ostream", "[rpc][types][filter]") { Filter filter{ "0", "10000000", FilterAddresses{0x6090a6e47849629b7245dfa1ca21d94cd15878ef_address}, FilterTopics{ {0x0000000000000000000000000000000000000000000000000000000000000000_bytes32}, {0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c_bytes32}, }, }; std::ostringstream oss; oss << filter; CHECK(oss.str() == "from_block: 0, to_block: 10000000, addresses: " "[0x6090a6e47849629b7245dfa1ca21d94cd15878ef], topics: [[0x0000000000000000000000000000000000000000000000000000000000000000] " "[0x374f3a049e006f36f6cf91b02a3b0ee16c858af2f75858733eb0e927b5b7126c]], block_hash: null"); } TEST_CASE("LogFilterOptions", "[rpc][types][options]") { SECTION("default to ostream") { LogFilterOptions options; std::ostringstream oss; oss << options; CHECK(oss.str() == "add_timestamp: false, logCount: 0, blockCount: 0, ignore_topics_order: false"); } SECTION("option to ostream") { LogFilterOptions options{true}; std::ostringstream oss; oss << options; CHECK(oss.str() == "add_timestamp: true, logCount: 0, blockCount: 0, ignore_topics_order: false"); } } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/issuance.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "issuance.hpp" #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const Issuance& issuance) { out << issuance.to_string(); return out; } std::string Issuance::to_string() const { std::stringstream out; out << "block_reward: " << block_reward.value_or("null") << " " << "ommer_reward: " << ommer_reward.value_or("null") << " " << "issuance: " << issuance.value_or("null") << " "; return out.str(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/issuance.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::rpc { struct Issuance { std::optional block_reward; std::optional ommer_reward; std::optional issuance; std::optional burnt; std::optional total_issued; std::optional total_burnt; std::optional tips; std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const Issuance& issuance); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/issuance_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "issuance.hpp" #include #include #include namespace silkworm::rpc { TEST_CASE("create empty issuance", "[rpc][types][issuance]") { Issuance i{}; CHECK(i.block_reward == std::nullopt); CHECK(i.ommer_reward == std::nullopt); CHECK(i.issuance == std::nullopt); } TEST_CASE("print empty issuance", "[rpc][types][issuance]") { Issuance i{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << i); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/log.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const Log& log) { out << log.to_string(); return out; } std::string Log::to_string() const { const auto& log = *this; std::stringstream out; out << "#topics: " << log.topics.size(); out << " #data: " << log.data.size(); out << " block_num: " << static_cast(log.block_num); out << " tx_hash: " << to_hex(log.tx_hash); out << " tx_index: " << log.tx_index; out << " block_hash: " << to_hex(log.block_hash); out << " index: " << log.index; out << " removed: " << log.removed; out << " address: "; for (const auto& b : log.address.bytes) { out << std::hex << std::setw(2) << std::setfill('0') << int{b}; } out << std::dec; return out.str(); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/log.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::rpc { struct Log { /* raw fields */ evmc::address address; std::vector topics; silkworm::Bytes data; /* derived fields */ BlockNum block_num{0}; evmc::bytes32 tx_hash; uint32_t tx_index{0}; evmc::bytes32 block_hash; uint32_t index{0}; bool removed{false}; std::optional timestamp{std::nullopt}; std::string to_string() const; }; using Logs = std::vector; std::ostream& operator<<(std::ostream& out, const Log& log); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/log_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "log.hpp" #include #include #include #include namespace silkworm::rpc { TEST_CASE("create empty log", "[rpc][types][log]") { Log l{}; CHECK(l.address == evmc::address{}); CHECK(l.topics.empty()); CHECK(l.data.empty()); } TEST_CASE("print empty log", "[rpc][types][log]") { Log l{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << l); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/node_info.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { struct NodeInfoPorts { uint64_t discovery{0}; uint64_t listener{0}; }; struct NodeInfo { std::string id; std::string name; std::string enode; std::string enr; std::string listener_addr; std::string protocols; NodeInfoPorts ports; }; using NodeInfos = std::vector; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/peer_info.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { struct PeerInfo { std::string id; std::string name; std::string enode; std::string enr; std::vector caps; std::string local_address; std::string remote_address; bool is_connection_inbound{false}; bool is_connection_trusted{false}; bool is_connection_static{false}; }; using PeerInfos = std::vector; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/receipt.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipt.hpp" #include #include #include #include #include #include namespace silkworm::rpc { std::ostream& operator<<(std::ostream& out, const Receipt& r) { out << r.to_string(); return out; } std::string Receipt::to_string() const { const auto& r = *this; std::stringstream out; out << " block_hash: " << to_hex(r.block_hash); out << " block_num: " << r.block_num; out << " contract_address: " << r.contract_address; out << " cumulative_gas_used: " << r.cumulative_gas_used; if (r.from) { out << " from: " << *r.from; } else { out << " from: null"; } out << " gas_used: " << r.gas_used; out << " #logs: " << r.logs.size(); auto bloom_view = full_view(r.bloom); out << " bloom: " << silkworm::to_hex(bloom_view); out << " success: " << r.success; if (r.to) { out << " to: " << *r.to; } else { out << " to: null"; } out << " tx_hash: " << to_hex(r.tx_hash); out << " tx_index: " << r.tx_index; out << " type: 0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast(r.type) << std::dec; return out.str(); } Bloom bloom_from_logs(const Logs& logs) { SILK_TRACE << "bloom_from_logs #logs: " << logs.size(); Bloom bloom{}; for (auto const& log : logs) { m3_2048(bloom, log.address.bytes); for (const auto& topic : log.topics) { m3_2048(bloom, topic.bytes); } } SILK_TRACE << "bloom_from_logs bloom: " << silkworm::to_hex(full_view(bloom)); return bloom; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/receipt.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::rpc { struct Receipt { /* raw fields */ TransactionType type{TransactionType::kLegacy}; // EIP-2718 bool success{false}; uint64_t cumulative_gas_used{0}; silkworm::Bloom bloom{}; Logs logs; /* derived fields */ evmc::bytes32 tx_hash; evmc::address contract_address; uint64_t gas_used{0}; evmc::bytes32 block_hash; BlockNum block_num{0}; uint32_t tx_index{0}; std::optional from; std::optional to; intx::uint256 effective_gas_price{0}; std::optional blob_gas_used{std::nullopt}; // EIP-4844 std::optional blob_gas_price{std::nullopt}; // EIP-4844 std::string to_string() const; }; std::ostream& operator<<(std::ostream& out, const Receipt& r); silkworm::Bloom bloom_from_logs(const Logs& logs); using Receipts = std::vector>; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/receipt_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "receipt.hpp" #include #include #include #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; TEST_CASE("create empty receipt", "[rpc][types][receipt]") { Receipt r{}; CHECK(r.success == false); CHECK(r.cumulative_gas_used == 0); CHECK(r.bloom == silkworm::Bloom{}); } TEST_CASE("print empty receipt", "[rpc][types][receipt]") { Receipt r{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << r); } TEST_CASE("print receipt", "[rpc][types][receipt]") { Logs logs{}; Receipt r{ TransactionType::kDynamicFee, true, 210000, bloom_from_logs(logs), logs}; r.from = 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address; r.to = 0x0715a7794a1dc8e42615f059dd6e406a6594651a_address; CHECK_NOTHROW(silkworm::test_util::null_stream() << r); } TEST_CASE("bloom from empty logs", "[rpc][types][receipt]") { Logs logs{}; CHECK(bloom_from_logs(logs) == silkworm::Bloom{}); } TEST_CASE("bloom from one empty log", "[rpc][types][receipt]") { Logs logs{ Log{}}; silkworm::Bloom expected_bloom{}; expected_bloom[9] = uint8_t{128}; expected_bloom[47] = uint8_t{2}; expected_bloom[143] = uint8_t{1}; CHECK(bloom_from_logs(logs) == expected_bloom); } TEST_CASE("bloom from more than one log", "[rpc][types][receipt]") { Logs logs{ { 0x22341ae42d6dd7384bc8584e50419ea3ac75b83f_address, // address {0x04491edcd115127caedbd478e2e7895ed80c7847e903431f94f9cfa579cad47f_bytes32}, // topics }, { 0xe7fb22dfef11920312e4989a3a2b81e2ebf05986_address, // address { 0x7f1fef85c4b037150d3675218e0cdb7cf38fea354759471e309f3354918a442f_bytes32, 0xd85629c7eaae9ea4a10234fed31bc0aeda29b2683ebe0c1882499d272621f6b6_bytes32, }, // topics *silkworm::from_hex("0x2d690516512020171c1ec870f6ff45398cc8609250326be89915fb538e7b"), // data }, }; silkworm::Bloom bloom{bloom_from_logs(logs)}; CHECK(silkworm::to_hex(full_view(bloom)) == "000000000000000000810000000000000000000000000000000000020000000000000000000000000000008000" "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000280000000000400000800000004000000000" "000000000000000000000000000000000000000000000000000000000000100000100000000000000000000000" "00000000001400000000000000008000000000000000000000000000000000"); } TEST_CASE("receipt with empty bloom", "[rpc][types][receipt]") { Logs logs{}; Receipt r{ TransactionType::kLegacy, true, 210000, bloom_from_logs(logs), logs}; CHECK(r.success == true); CHECK(r.cumulative_gas_used == 210000); CHECK(r.bloom == silkworm::Bloom{}); CHECK(r.logs.empty()); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/syncing_data.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::rpc { struct StageData { std::string stage_name; std::string block_num; }; struct SyncingData { std::string current_block; std::string max_block; std::vector stages; }; } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/transaction.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction.hpp" #include #include #include #include #include #include namespace silkworm::rpc { intx::uint256 Transaction::effective_gas_price() const { return silkworm::Transaction::effective_gas_price(block_base_fee_per_gas.value_or(0)); } std::ostream& operator<<(std::ostream& out, const Transaction& t) { out << t.to_string(); return out; } std::string Transaction::to_string() const { const auto& t = *this; std::stringstream out; out << " #access_list: " << t.access_list.size(); out << " #authorizations: " << t.authorizations.size(); out << " block_hash: " << to_hex(t.block_hash); out << " block_num: " << t.block_num; out << " block_base_fee_per_gas: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.block_base_fee_per_gas.value_or(0))); if (t.chain_id) { out << " chain_id: " << silkworm::to_hex(silkworm::endian::to_big_compact(*t.chain_id)); } else { out << " chain_id: null"; } out << " data: " << silkworm::to_hex(t.data); if (t.sender()) { out << " from: " << *t.sender(); } else { out << " from: null"; } out << " nonce: " << t.nonce; out << " max_priority_fee_per_gas: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.max_priority_fee_per_gas)); out << " max_fee_per_gas: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.max_fee_per_gas)); out << " gas_price: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.effective_gas_price())); out << " gas_limit: " << t.gas_limit; out << " odd_y_parity: " << t.odd_y_parity; out << " r: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.r)); out << " s: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.s)); if (t.to) { out << " to: " << *t.to; } else { out << " to: null"; } out << " transaction_index: " << t.transaction_index; out << " type: 0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast(t.type); out << " value: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.value)); out << std::dec; return out.str(); } std::string core_transaction_to_string(const silkworm::Transaction& t) { std::stringstream out; out << " #access_list: " << t.access_list.size(); out << " #authorizations: " << t.authorizations.size(); if (t.chain_id) { out << " chain_id: " << silkworm::to_hex(silkworm::endian::to_big_compact(*t.chain_id)); } else { out << " chain_id: null"; } out << " data: " << silkworm::to_hex(t.data); if (t.sender()) { out << " from: " << *t.sender(); } else { out << " from: null"; } out << " nonce: " << t.nonce; out << " max_priority_fee_per_gas: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.max_priority_fee_per_gas)); out << " max_fee_per_gas: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.max_fee_per_gas)); out << " gas_limit: " << t.gas_limit; out << " odd_y_parity: " << t.odd_y_parity; out << " r: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.r)); out << " s: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.s)); if (t.to) { out << " to: " << *t.to; } else { out << " to: null"; } out << " type: 0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast(t.type) << std::dec; out << " value: " << silkworm::to_hex(silkworm::endian::to_big_compact(t.value)); return out.str(); } std::ostream& operator<<(std::ostream& out, const silkworm::Transaction& t) { out << core_transaction_to_string(t); return out; } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/transaction.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc { struct Transaction : public silkworm::Transaction { evmc::bytes32 block_hash; BlockNum block_num{0}; std::optional block_base_fee_per_gas{std::nullopt}; uint64_t transaction_index{0}; bool queued_in_pool{false}; intx::uint256 effective_gas_price() const; // EIP-1559 std::string to_string() const; }; struct Rlp { silkworm::Bytes buffer; }; struct TransactionWithBlock { std::shared_ptr block_with_hash{nullptr}; Transaction transaction; }; using AccessList = std::vector; struct AccessListResult { AccessList access_list; std::optional error; uint64_t gas_used{0}; }; struct TxPoolStatusInfo { unsigned int base_fee; unsigned int pending; unsigned int queued; }; using TransactionContent = std::map>>; std::ostream& operator<<(std::ostream& out, const Transaction& t); std::ostream& operator<<(std::ostream& out, const silkworm::Transaction& t); } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/types/transaction_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "transaction.hpp" #include #include #include #include #include namespace silkworm::rpc { using evmc::literals::operator""_address, evmc::literals::operator""_bytes32; using silkworm::kGiga; TEST_CASE("create empty transaction", "[rpc][types][transaction]") { Transaction txn{}; CHECK(txn.block_hash == evmc::bytes32{}); CHECK(txn.block_num == 0); CHECK(txn.transaction_index == 0); CHECK(txn.effective_gas_price() == intx::uint256{0}); } TEST_CASE("create empty silkworm::transaction", "[rpc][types][silkworm::transaction]") { silkworm::Transaction txn{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << txn); } TEST_CASE("print empty transaction", "[rpc][types][transaction]") { Transaction txn{}; CHECK_NOTHROW(silkworm::test_util::null_stream() << txn); } TEST_CASE("print type-2 transaction", "[rpc][types][transaction]") { // https://etherscan.io/tx/0x4b408a48f927f03a63502fb63f7d42c5c4783737ebe8d084cef157575d40f344 Transaction txn{}; txn.type = TransactionType::kDynamicFee; txn.chain_id = 1; txn.nonce = 371; txn.max_priority_fee_per_gas = 1 * kGiga; txn.max_fee_per_gas = 217'914'097'876; txn.gas_limit = 613'991; txn.to = 0x14efa0d4b0f9850ba1787edc730324962446d7cc_address; txn.value = 210'000'000 * kGiga; txn.data = *from_hex("0x6ecd23060000000000000000000000000000000000000000000000000000000000000005"); txn.odd_y_parity = true; txn.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn.set_sender(0x7ad75fdb6244111753822140dad3337f5535f718_address); txn.block_hash = 0x007fe79ccdd5365f46c34336b8a15b36e05c249a0c62596878236a38034edc21_bytes32; txn.block_num = 13116571; txn.block_base_fee_per_gas = 110'045'619'790; txn.transaction_index = 144; CHECK_NOTHROW(silkworm::test_util::null_stream() << txn); } TEST_CASE("print type-2 silkworm::transaction", "[rpc][types][silkworm::transaction]") { // https://etherscan.io/tx/0x4b408a48f927f03a63502fb63f7d42c5c4783737ebe8d084cef157575d40f344 silkworm::Transaction txn{}; txn.type = TransactionType::kDynamicFee; txn.chain_id = 1; txn.nonce = 371; txn.max_priority_fee_per_gas = 1 * kGiga; txn.max_fee_per_gas = 217'914'097'876; txn.gas_limit = 613'991; txn.to = 0x14efa0d4b0f9850ba1787edc730324962446d7cc_address; txn.value = 210'000'000 * kGiga; txn.data = *from_hex("0x6ecd23060000000000000000000000000000000000000000000000000000000000000005"); txn.odd_y_parity = true; txn.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn.set_sender(0x7ad75fdb6244111753822140dad3337f5535f718_address); CHECK_NOTHROW(silkworm::test_util::null_stream() << txn); } TEST_CASE("create legacy transaction", "[rpc][types][transaction]") { // https://etherscan.io/tx/0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060 Transaction txn{}; txn.type = TransactionType::kLegacy; txn.nonce = 0; txn.max_priority_fee_per_gas = 50'000 * kGiga; txn.max_fee_per_gas = 50'000 * kGiga; txn.gas_limit = 21'000; txn.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn.value = 31337; txn.odd_y_parity = true; txn.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn.set_sender(0xa1e4380a3b1f749673e270229993ee55f35663b4_address); txn.block_hash = 0x4e3a3754410177e6937ef1f84bba68ea139e8d1a2258c5f85db9f1cd715a1bdd_bytes32; txn.block_num = 46147; CHECK(txn.effective_gas_price() == 50000000000000); } TEST_CASE("create legacy silkworm::transaction", "[rpc][types][silkworm::transaction]") { // https://etherscan.io/tx/0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060 silkworm::Transaction txn{}; txn.type = TransactionType::kLegacy; txn.nonce = 0; txn.max_priority_fee_per_gas = 50'000 * kGiga; txn.max_fee_per_gas = 50'000 * kGiga; txn.gas_limit = 21'000; txn.to = 0x5df9b87991262f6ba471f09758cde1c0fc1de734_address; txn.value = 31337; txn.odd_y_parity = true; txn.r = intx::from_string("0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0"); txn.s = intx::from_string("0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a"); txn.set_sender(0xa1e4380a3b1f749673e270229993ee55f35663b4_address); CHECK_NOTHROW(silkworm::test_util::null_stream() << txn); } } // namespace silkworm::rpc ================================================ FILE: silkworm/rpc/ws/connection.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "connection.hpp" #include #include #include #include #include #include #include namespace silkworm::rpc::ws { Connection::Connection(TcpStream&& stream, RequestHandlerFactory& handler_factory, bool compression) : stream_{std::move(stream)}, handler_{handler_factory(this)}, compression_{compression} { SILK_TRACE << "ws::Connection::Connection socket created:" << &stream_; } Connection::~Connection() { SILK_TRACE << "ws::Connection::~Connection socket deleted:" << &stream_; } Task Connection::accept(const boost::beast::http::request& req) { // Set timeout settings for the websocket boost::beast::websocket::stream_base::timeout timeout{ .handshake_timeout = std::chrono::seconds(30), .idle_timeout = std::chrono::seconds(60), .keep_alive_pings = true, }; stream_.set_option(timeout); stream_.write_buffer_bytes(65536); stream_.auto_fragment(false); if (compression_) { boost::beast::websocket::permessage_deflate permessage_deflate{ .server_enable = true, .client_enable = true, .server_no_context_takeover = true, .client_no_context_takeover = true, }; stream_.set_option(permessage_deflate); } // Accept the WebSocket handshake co_await stream_.async_accept(req, boost::asio::use_awaitable); } Task Connection::read_loop() { SILK_TRACE << "ws::Connection::run starting connection for socket: " << &stream_; try { while (true) { co_await do_read(); } } catch (const boost::system::system_error& se) { SILK_TRACE << "ws::Connection::read_loop system_error: " << se.what(); } catch (const std::exception& e) { SILK_ERROR << "ws::Connection::read_loop exception: " << e.what(); } } Task Connection::do_read() { std::string req_content; auto req_buffer = boost::asio::dynamic_buffer(req_content); const auto bytes_read = co_await stream_.async_read(req_buffer, boost::asio::use_awaitable); SILK_TRACE << "ws::Connection::do_read bytes_read: " << bytes_read << " [" << req_content << "]"; auto rsp_content = co_await handler_->handle(req_content, 0); if (rsp_content) { co_await do_write(*rsp_content); } } Task Connection::write(uint64_t /* request_id */, std::string_view content, bool last) { try { const auto written = co_await stream_.async_write_some(last, boost::asio::buffer(content.data(), content.size()), boost::asio::use_awaitable); SILK_TRACE << "ws::Connection::write: [" << content.data() << "]"; co_return written; } catch (const boost::system::system_error& se) { SILK_TRACE << "ws::Connection::write system_error: " << se.what(); throw; } catch (const std::exception& e) { SILK_ERROR << "ws::Connection::write exception: " << e.what(); throw; } } Task Connection::do_write(const std::string& content) { try { const auto written = co_await stream_.async_write(boost::asio::buffer(content), boost::asio::use_awaitable); SILK_TRACE << "ws::Connection::do_write: [" << content << "]"; co_return written; } catch (const boost::system::system_error& se) { SILK_TRACE << "ws::Connection::do_write system_error: " << se.what(); throw; } catch (const std::exception& e) { SILK_ERROR << "ws::Connection::do_write exception: " << e.what(); throw; } } } // namespace silkworm::rpc::ws ================================================ FILE: silkworm/rpc/ws/connection.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::rpc::ws { using TcpStream = boost::beast::websocket::stream; inline constexpr size_t kDefaultCapacity = 5 * 1024 * 1024; //! Represents a single connection from a client via websocket. class Connection : public StreamWriter { public: Connection(const Connection&) = delete; Connection& operator=(const Connection&) = delete; //! Construct a connection running within the given execution context. Connection(TcpStream&& stream, RequestHandlerFactory& handler_factory, bool compression = false); ~Connection() override; Task accept(const boost::beast::http::request& req); Task read_loop(); // Methods of StreamWriter interface Task open_stream(uint64_t /* request_id */) override { co_return; } Task close_stream(uint64_t /* request_id */) override { co_return; } size_t get_capacity() const noexcept override { return kDefaultCapacity; } Task write(uint64_t request_id, std::string_view content, bool last) override; private: Task do_read(); //! Perform an asynchronous write operation. Task do_write(const std::string& content); //! The WebSocket TCP stream TcpStream stream_; //! The handler used to process the incoming request. RequestHandlerPtr handler_; //! enable compress flag bool compression_{false}; }; } // namespace silkworm::rpc::ws ================================================ FILE: silkworm/sentry/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(absl REQUIRED) find_package(Boost REQUIRED COMPONENTS headers) find_package(gRPC REQUIRED) find_package(Microsoft.GSL REQUIRED) find_package(OpenSSL REQUIRED) find_package(Snappy REQUIRED) # sentry common add_subdirectory(common) # discovery common add_subdirectory(discovery/common) # node DB add_subdirectory(discovery/node_db) # ENR add_subdirectory(discovery/enr) # disc v4 add_subdirectory(discovery/disc_v4) set(LIBS_PRIVATE gRPC::grpc++ protobuf::libprotobuf OpenSSL::Crypto Snappy::snappy stbrumme_crc32 stbrumme_keccak stun_msg silkworm_capi_common silkworm_core silkworm_interfaces silkworm-buildinfo silkworm_sentry_common silkworm_sentry_node_db silkworm_sentry_discovery_common silkworm_sentry_discovery_enr silkworm_sentry_disc_v4 ) # cmake-format: off set(LIBS_PUBLIC Boost::headers Microsoft.GSL::GSL silkworm_infra ) # cmake-format: on silkworm_library( silkworm_sentry PUBLIC ${LIBS_PUBLIC} PRIVATE ${LIBS_PRIVATE} ) # silkworm_sentry_cli depends on silkworm_sentry add_subdirectory(cli) ================================================ FILE: silkworm/sentry/api/common/message_from_peer.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry::api { struct MessageFromPeer { sentry::Message message; std::optional peer_public_key; }; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/common/message_id_set.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::sentry::api { using MessageIdSet = std::set; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/common/node_info.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::sentry::api { struct NodeInfo { sentry::EnodeUrl node_url; std::string client_id; boost::asio::ip::tcp::endpoint rlpx_server_listen_endpoint; uint16_t rlpx_server_port; }; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/common/peer_event.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry::api { enum class PeerEventId { kAdded, kRemoved, }; struct PeerEvent { std::optional peer_public_key; PeerEventId event_id{}; }; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/common/peer_filter.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry::api { struct PeerFilter { std::optional max_peers; std::optional peer_public_key; static PeerFilter with_max_peers(size_t max_peers) { return {{max_peers}, std::nullopt}; } static PeerFilter with_peer_public_key(sentry::EccPublicKey public_key) { return {std::nullopt, {std::move(public_key)}}; } }; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/common/peer_info.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::sentry::api { struct PeerInfo { sentry::EnodeUrl url; boost::asio::ip::tcp::endpoint local_endpoint; boost::asio::ip::tcp::endpoint remote_endpoint; bool is_inbound; bool is_static; std::string client_id; std::vector capabilities; }; using PeerInfos = std::vector; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/common/sentry_client.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "service.hpp" namespace silkworm::sentry::api { struct SentryClient { virtual ~SentryClient() = default; virtual Task> service() = 0; //! Connected or just created an ready to handle calls. service() is unlikely to block for long. virtual bool is_ready() = 0; virtual void on_disconnect(std::function()> callback) = 0; virtual Task reconnect() = 0; }; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/common/service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "message_from_peer.hpp" #include "message_id_set.hpp" #include "node_info.hpp" #include "peer_event.hpp" #include "peer_info.hpp" namespace silkworm::sentry::api { struct Service { virtual ~Service() = default; // rpc SetStatus(StatusData) returns (SetStatusReply); virtual Task set_status(eth::StatusData status_data) = 0; // rpc HandShake(google.protobuf.Empty) returns (HandShakeReply); virtual Task handshake() = 0; using NodeInfos = std::vector; // rpc NodeInfo(google.protobuf.Empty) returns(types.NodeInfoReply); virtual Task node_infos() = 0; using PeerKeys = std::vector; // rpc SendMessageById(SendMessageByIdRequest) returns (SentPeers); virtual Task send_message_by_id(Message message, EccPublicKey public_key) = 0; // rpc SendMessageToRandomPeers(SendMessageToRandomPeersRequest) returns (SentPeers); virtual Task send_message_to_random_peers(Message message, size_t max_peers) = 0; // rpc SendMessageToAll(OutboundMessageData) returns (SentPeers); virtual Task send_message_to_all(Message message) = 0; // rpc SendMessageByMinBlock(SendMessageByMinBlockRequest) returns (SentPeers); virtual Task send_message_by_min_block(Message message, size_t max_peers) = 0; // rpc PeerMinBlock(PeerMinBlockRequest) returns (google.protobuf.Empty); virtual Task peer_min_block(EccPublicKey public_key) = 0; // rpc Messages(MessagesRequest) returns (stream InboundMessage); virtual Task messages( MessageIdSet message_id_filter, std::function(MessageFromPeer)> consumer) = 0; // rpc Peers(google.protobuf.Empty) returns (PeersReply); virtual Task peers() = 0; // rpc PeerCount(PeerCountRequest) returns (PeerCountReply); virtual Task peer_count() = 0; // rpc PeerById(PeerByIdRequest) returns (PeerByIdReply); virtual Task> peer_by_id(EccPublicKey public_key) = 0; // rpc PenalizePeer(PenalizePeerRequest) returns (google.protobuf.Empty); virtual Task penalize_peer(EccPublicKey public_key) = 0; // rpc PeerEvents(PeerEventsRequest) returns (stream PeerEvent); virtual Task peer_events(std::function(PeerEvent)> consumer) = 0; }; } // namespace silkworm::sentry::api ================================================ FILE: silkworm/sentry/api/router/direct_service.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "direct_service.hpp" #include #include #include #include #include #include "messages_call.hpp" #include "peer_call.hpp" #include "peer_events_call.hpp" #include "send_message_call.hpp" namespace silkworm::sentry::api::router { using namespace boost::asio; Task DirectService::set_status(eth::StatusData status_data) { status_data.message.version = router_.eth_version; co_await router_.status_channel.send(std::move(status_data)); } Task DirectService::handshake() { co_return router_.eth_version; } Task DirectService::node_infos() { co_return Service::NodeInfos{router_.node_info_provider()}; } static Task do_send_message_call( const ServiceRouter& router, Message message, PeerFilter peer_filter) { auto executor = co_await this_coro::executor; SendMessageCall call{std::move(message), std::move(peer_filter), executor}; co_await router.send_message_channel.send(call); co_return (co_await call.result()); } Task DirectService::send_message_by_id(Message message, EccPublicKey public_key) { co_return (co_await do_send_message_call(router_, std::move(message), PeerFilter::with_peer_public_key(std::move(public_key)))); } Task DirectService::send_message_to_random_peers(Message message, size_t max_peers) { co_return (co_await do_send_message_call(router_, std::move(message), PeerFilter::with_max_peers(max_peers))); } Task DirectService::send_message_to_all(Message message) { co_return (co_await do_send_message_call(router_, std::move(message), api::PeerFilter{})); } Task DirectService::send_message_by_min_block(Message message, size_t max_peers) { co_return (co_await do_send_message_call(router_, std::move(message), PeerFilter::with_max_peers(max_peers))); } Task DirectService::peer_min_block(EccPublicKey /*public_key*/) { // TODO: implement co_return; } Task DirectService::messages( MessageIdSet message_id_filter, std::function(MessageFromPeer)> consumer) { auto executor = co_await this_coro::executor; MessagesCall call{std::move(message_id_filter), executor}; auto unsubscribe_signal = call.unsubscribe_signal(); [[maybe_unused]] auto _ = gsl::finally([=]() { unsubscribe_signal->notify(); }); co_await router_.message_calls_channel.send(call); auto channel = co_await call.result(); // loop until a cancelled exception while (true) { auto message = co_await channel->receive(); co_await consumer(std::move(message)); } } Task DirectService::peers() { auto executor = co_await this_coro::executor; auto call = std::make_shared>(executor); auto call_future = call->get_future(); co_await router_.peers_calls_channel.send(call); co_return (co_await call_future.get_async()); } Task DirectService::peer_count() { auto executor = co_await this_coro::executor; auto call = std::make_shared>(executor); auto call_future = call->get_future(); co_await router_.peer_count_calls_channel.send(call); co_return (co_await call_future.get_async()); } Task> DirectService::peer_by_id(EccPublicKey public_key) { auto executor = co_await this_coro::executor; PeerCall call{std::move(public_key), executor}; auto call_future = call.result_promise->get_future(); co_await router_.peer_calls_channel.send(call); co_return (co_await call_future.get_async()); } Task DirectService::penalize_peer(EccPublicKey public_key) { co_await router_.peer_penalize_calls_channel.send({std::move(public_key)}); } Task DirectService::peer_events( std::function(PeerEvent)> consumer) { auto executor = co_await this_coro::executor; PeerEventsCall call{executor}; auto call_future = call.result_promise->get_future(); auto unsubscribe_signal = call.unsubscribe_signal; [[maybe_unused]] auto _ = gsl::finally([=]() { unsubscribe_signal->notify(); }); co_await router_.peer_events_calls_channel.send(call); auto channel = co_await call_future.get_async(); // loop until a cancelled exception while (true) { auto event = co_await channel->receive(); co_await consumer(std::move(event)); } } } // namespace silkworm::sentry::api::router ================================================ FILE: silkworm/sentry/api/router/direct_service.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include "service_router.hpp" namespace silkworm::sentry::api::router { class DirectService : public Service { public: explicit DirectService(ServiceRouter router) : router_(std::move(router)) {} ~DirectService() override = default; Task set_status(eth::StatusData status_data) override; Task handshake() override; Task node_infos() override; Task send_message_by_id(Message message, EccPublicKey public_key) override; Task send_message_to_random_peers(Message message, size_t max_peers) override; Task send_message_to_all(Message message) override; Task send_message_by_min_block(Message message, size_t max_peers) override; Task peer_min_block(EccPublicKey public_key) override; Task messages( MessageIdSet message_id_filter, std::function(MessageFromPeer)> consumer) override; Task peers() override; Task peer_count() override; Task> peer_by_id(EccPublicKey public_key) override; Task penalize_peer(EccPublicKey public_key) override; Task peer_events(std::function(PeerEvent)> consumer) override; private: ServiceRouter router_; }; } // namespace silkworm::sentry::api::router ================================================ FILE: silkworm/sentry/api/router/messages_call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include namespace silkworm::sentry::api::router { class MessagesCall final { public: using Result = std::shared_ptr>; MessagesCall( MessageIdSet message_id_filter, const boost::asio::any_io_executor& executor) : message_id_filter_(std::move(message_id_filter)), result_promise_(std::make_shared>(executor)), unsubscribe_signal_(std::make_shared(executor)) {} MessagesCall() = default; const MessageIdSet& message_id_filter() const { return message_id_filter_; } Task result() { auto future = result_promise_->get_future(); co_return (co_await future.get_async()); } void set_result(Result result) { result_promise_->set_value(std::move(result)); } std::shared_ptr unsubscribe_signal() const { return unsubscribe_signal_; } private: MessageIdSet message_id_filter_; std::shared_ptr> result_promise_; std::shared_ptr unsubscribe_signal_; }; } // namespace silkworm::sentry::api::router ================================================ FILE: silkworm/sentry/api/router/peer_call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::sentry::api::router { struct PeerCall { std::optional peer_public_key; std::shared_ptr>> result_promise; PeerCall() = default; PeerCall( sentry::EccPublicKey peer_public_key1, const boost::asio::any_io_executor& executor) : peer_public_key(std::move(peer_public_key1)), result_promise(std::make_shared>>(executor)) {} }; } // namespace silkworm::sentry::api::router ================================================ FILE: silkworm/sentry/api/router/peer_events_call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::sentry::api::router { struct PeerEventsCall { using Result = std::shared_ptr>; std::shared_ptr> result_promise; std::shared_ptr unsubscribe_signal; PeerEventsCall() = default; explicit PeerEventsCall(const boost::asio::any_io_executor& executor) : result_promise(std::make_shared>(executor)), unsubscribe_signal(std::make_shared(executor)) {} }; } // namespace silkworm::sentry::api::router ================================================ FILE: silkworm/sentry/api/router/send_message_call.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::sentry::api::router { class SendMessageCall final { public: using PeerKeys = std::vector; SendMessageCall( sentry::Message message, PeerFilter peer_filter, const boost::asio::any_io_executor& executor) : message_(std::move(message)), peer_filter_(std::move(peer_filter)), result_promise_(std::make_shared>(executor)) {} SendMessageCall() = default; const sentry::Message& message() const { return message_; } const PeerFilter& peer_filter() const { return peer_filter_; } Task result() { auto future = result_promise_->get_future(); co_return (co_await future.get_async()); } void set_result(PeerKeys result) { result_promise_->set_value(std::move(result)); } private: sentry::Message message_; PeerFilter peer_filter_; std::shared_ptr> result_promise_; }; } // namespace silkworm::sentry::api::router ================================================ FILE: silkworm/sentry/api/router/service_router.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "messages_call.hpp" #include "peer_call.hpp" #include "peer_events_call.hpp" #include "send_message_call.hpp" namespace silkworm::sentry::api::router { struct ServiceRouter { uint8_t eth_version; template using Channel = concurrency::Channel; Channel& status_channel; Channel& send_message_channel; Channel& message_calls_channel; Channel>>& peer_count_calls_channel; Channel>>& peers_calls_channel; Channel& peer_calls_channel; Channel>& peer_penalize_calls_channel; Channel& peer_events_calls_channel; std::function node_info_provider; }; } // namespace silkworm::sentry::api::router ================================================ FILE: silkworm/sentry/capi/component.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::sentry::capi { struct Component { std::unique_ptr sentry_thread; boost::asio::cancellation_signal sentry_stop_signal; }; } // namespace silkworm::sentry::capi ================================================ FILE: silkworm/sentry/capi/sentry.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "sentry.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "component.hpp" #include "sentry.h" using namespace silkworm; using namespace silkworm::sentry; using silkworm::concurrency::ContextPoolSettings; static std::vector parse_peer_urls(const char (&c_urls)[SILKWORM_SENTRY_SETTINGS_PEERS_MAX][200]) { std::vector urls; for (const auto& c_url : c_urls) { std::string_view url_str = c_url; if (url_str.empty()) break; urls.emplace_back(url_str); } return urls; } static nat::NatOption parse_nat_option(const char (&c_nat)[50]) { nat::NatOption nat; std::string_view nat_str{c_nat}; if (!nat_str.empty()) { bool ok = nat::lexical_cast(nat_str, nat); if (!ok) { throw std::runtime_error("make_settings: bad settings.nat string"); } } return nat; } static Settings make_settings( const struct SilkwormSentrySettings& settings, ContextPoolSettings context_pool_settings, std::filesystem::path data_dir_path) { std::string api_address = "127.0.0.1:" + std::to_string(settings.api_port); return Settings{ settings.client_id, {}, // log_settings are not used api_address, settings.port, parse_nat_option(settings.nat), context_pool_settings, std::move(data_dir_path), settings.network_id, {{Bytes{settings.node_key}}}, parse_peer_urls(settings.static_peers), parse_peer_urls(settings.bootnodes), settings.no_discover, settings.max_peers, }; } static void log_exception(const std::exception_ptr& ex_ptr, const char* message) { try { if (ex_ptr) { std::rethrow_exception(ex_ptr); } } catch (const boost::system::system_error& ex) { if (ex.code() != boost::system::errc::operation_canceled) { SILK_ERROR_M("sentry") << message << " system_error: " << ex.what(); } } catch (const std::exception& ex) { SILK_ERROR_M("sentry") << message << " exception: " << ex.what(); } catch (...) { SILK_ERROR_M("sentry") << message << " unexpected exception"; } } static void sentry_run( Settings settings, const boost::asio::cancellation_slot& sentry_stop_signal_slot, std::latch& sentry_started); SILKWORM_EXPORT int silkworm_sentry_start(SilkwormHandle silkworm_handle, const struct SilkwormSentrySettings* c_settings) SILKWORM_NOEXCEPT { try { if (!silkworm_handle) { return SILKWORM_INVALID_HANDLE; } if (!c_settings) { return SILKWORM_INVALID_SETTINGS; } if (silkworm_handle->sentry) { return SILKWORM_SERVICE_ALREADY_STARTED; } silkworm_handle->sentry = std::make_unique(); auto& handle = silkworm_handle->sentry; const auto& common = silkworm_handle->common; auto settings = make_settings( *c_settings, common.context_pool_settings, common.data_dir_path); std::latch sentry_started{1}; std::exception_ptr startup_ex_ptr; handle->sentry_thread = std::make_unique([settings = std::move(settings), &sentry_stop_signal = handle->sentry_stop_signal, &sentry_started, &startup_ex_ptr]() mutable { try { log::set_thread_name("sentry-run"); sentry_run(std::move(settings), sentry_stop_signal.slot(), sentry_started); } catch (...) { // error after it's started if (sentry_started.try_wait()) { log_exception(std::current_exception(), "sentry_thread"); } // error during startup will be rethrown else { startup_ex_ptr = std::current_exception(); sentry_started.count_down(); } } }); sentry_started.wait(); if (startup_ex_ptr) { std::rethrow_exception(startup_ex_ptr); } return SILKWORM_OK; } catch (...) { log_exception(std::current_exception(), __FUNCTION__); return SILKWORM_INTERNAL_ERROR; } } static void sentry_run( Settings settings, const boost::asio::cancellation_slot& sentry_stop_signal_slot, std::latch& sentry_started) { rpc::ClientContextPool context_pool{ settings.context_pool_settings, }; Sentry sentry{std::move(settings), context_pool.as_executor_pool()}; auto completion = [&context_pool](const std::exception_ptr& ex_ptr) { if (ex_ptr) { log_exception(ex_ptr, "sentry.run"); } context_pool.stop(); }; boost::asio::co_spawn( context_pool.any_executor(), sentry.run(), boost::asio::bind_cancellation_slot(sentry_stop_signal_slot, completion)); context_pool.start(); // signal that it's started, it is safe to call silkworm_sentry_stop() at this point sentry_started.count_down(); context_pool.join(); } SILKWORM_EXPORT int silkworm_sentry_stop(SilkwormHandle silkworm_handle) SILKWORM_NOEXCEPT { try { if (!silkworm_handle) { return SILKWORM_INVALID_HANDLE; } // check if it's already stopped if (!silkworm_handle->sentry) { return SILKWORM_OK; } auto& handle = silkworm_handle->sentry; // stop sentry.run() task handle->sentry_stop_signal.emit(boost::asio::cancellation_type::all); handle->sentry_thread->join(); handle->sentry_thread.reset(); handle.reset(); return SILKWORM_OK; } catch (...) { log_exception(std::current_exception(), __FUNCTION__); return SILKWORM_INTERNAL_ERROR; } } ================================================ FILE: silkworm/sentry/capi/sentry.h ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #ifndef SILKWORM_SENTRY_CAPI_H_ #define SILKWORM_SENTRY_CAPI_H_ #ifdef SILKWORM_CAPI_COMPONENT #include #else #include "preamble.h" #endif #if __cplusplus extern "C" { #endif #define SILKWORM_SENTRY_SETTINGS_CLIENT_ID_SIZE 128 #define SILKWORM_SENTRY_SETTINGS_NAT_SIZE 50 #define SILKWORM_SENTRY_SETTINGS_NODE_KEY_SIZE 32 #define SILKWORM_SENTRY_SETTINGS_PEERS_MAX 128 #define SILKWORM_SENTRY_SETTINGS_PEER_URL_SIZE 200 //! Silkworm Sentry configuration options struct SilkwormSentrySettings { char client_id[SILKWORM_SENTRY_SETTINGS_CLIENT_ID_SIZE]; uint16_t api_port; uint16_t port; char nat[SILKWORM_SENTRY_SETTINGS_NAT_SIZE]; uint64_t network_id; uint8_t node_key[SILKWORM_SENTRY_SETTINGS_NODE_KEY_SIZE]; char static_peers[SILKWORM_SENTRY_SETTINGS_PEERS_MAX][SILKWORM_SENTRY_SETTINGS_PEER_URL_SIZE]; char bootnodes[SILKWORM_SENTRY_SETTINGS_PEERS_MAX][SILKWORM_SENTRY_SETTINGS_PEER_URL_SIZE]; bool no_discover; size_t max_peers; }; /** * \brief Start Silkworm Sentry. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init.Must not be zero. * \param[in] settings The Sentry configuration settings. Must not be zero. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_sentry_start(SilkwormHandle handle, const struct SilkwormSentrySettings* settings) SILKWORM_NOEXCEPT; /** * \brief Stop Silkworm Sentry and wait for its termination. * \param[in] handle A valid Silkworm instance handle, got with silkworm_init. Must not be zero. * \return SILKWORM_OK (=0) on success, a non-zero error value on failure. */ SILKWORM_EXPORT int silkworm_sentry_stop(SilkwormHandle handle) SILKWORM_NOEXCEPT; #if __cplusplus } #endif #endif // SILKWORM_SENTRY_CAPI_H_ ================================================ FILE: silkworm/sentry/cli/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 add_library(silkworm_sentry_cli "sentry_options.cpp") target_link_libraries(silkworm_sentry_cli PUBLIC silkworm_sentry silkworm_infra_cli) ================================================ FILE: silkworm/sentry/cli/sentry_options.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "sentry_options.hpp" #include #include #include #include #include #include #include namespace silkworm::cmd::common { template void add_list_option(CLI::App& cli, const std::string& name, std::vector& target_list, const std::string& description) { auto option = cli.add_option(name, [&](const CLI::results_t& results) { try { for (auto& result : results) { if (result.empty()) continue; target_list.emplace_back(result); } } catch (const std::exception& e) { SILK_ERROR << e.what(); return false; } return true; }); option->description(description); option->type_size(1, INT_MAX); } void add_sentry_options(CLI::App& cli, silkworm::sentry::Settings& settings) { add_option_ip_endpoint(cli, "--sentry.api.addr", settings.api_address, "GRPC API endpoint"); cli.add_option("--port", settings.port) ->description("Network listening port for incoming peers TCP connections and discovery UDP requests") ->check(CLI::Range(1024, 65535)) ->capture_default_str(); auto nat_option = cli.add_option("--nat", [&settings](const CLI::results_t& results) { return lexical_cast(results[0], settings.nat); }); nat_option->description( "NAT port mapping mechanism (none|extip:)\n" "- none no NAT, use a local IP as public\n" "- stun detect a public IP using STUN (default)" "- extip:1.2.3.4 use the given public IP"); nat_option->default_str("none"); auto node_key_path_option = cli.add_option("--nodekey", [&settings](const CLI::results_t& results) { try { settings.node_key = {{std::filesystem::path(results[0])}}; return true; } catch (const std::exception& e) { SILK_ERROR << e.what(); return false; } }); node_key_path_option->description("P2P node key file"); auto node_key_hex_option = cli.add_option("--nodekeyhex", [&settings](const CLI::results_t& results) { auto key_bytes = from_hex(results[0]); if (key_bytes) { settings.node_key = {{key_bytes.value()}}; } return key_bytes.has_value(); }); node_key_hex_option->description("P2P node key as a hex string"); add_list_option(cli, "--staticpeers", settings.static_peers, "Peers enode URLs to connect to without discovery"); add_list_option(cli, "--bootnodes", settings.bootnodes, "Peers enode URLs for P2P discovery bootstrap"); cli.add_flag("--nodiscover", settings.no_discover) ->description("Disables automatic peer discovery"); cli.add_option("--maxpeers", settings.max_peers) ->description("Maximum number of P2P network peers") ->check(CLI::Range(0, 1000)) ->capture_default_str(); } } // namespace silkworm::cmd::common ================================================ FILE: silkworm/sentry/cli/sentry_options.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::cmd::common { void add_sentry_options(CLI::App& cli, silkworm::sentry::Settings& settings); } // namespace silkworm::cmd::common ================================================ FILE: silkworm/sentry/common/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") find_package(Boost REQUIRED COMPONENTS headers) silkworm_library(silkworm_sentry_common PUBLIC Boost::headers silkworm_core silkworm_infra) ================================================ FILE: silkworm/sentry/common/atomic_value.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry { template class AtomicValue { public: explicit AtomicValue(T value) : value_(std::move(value)) {} void set(T value) { std::scoped_lock lock(mutex_); value_ = value; } T get() { std::scoped_lock lock(mutex_); return value_; } std::function getter() { return [this] { return this->get(); }; } private: T value_; std::mutex mutex_; }; } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/crypto/ecdsa_signature.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ecdsa_signature.hpp" #include #include namespace silkworm::sentry::crypto::ecdsa_signature { Bytes sign_recoverable(ByteView data_hash, ByteView private_key) { SecP256K1Context ctx{/* allow_verify = */ false, /* allow_sign = */ true}; secp256k1_ecdsa_recoverable_signature signature; bool ok = ctx.sign_recoverable(&signature, data_hash, private_key); if (!ok) { throw std::runtime_error("ecdsa_signature::sign_recoverable failed"); } auto [signature_data, recovery_id] = ctx.serialize_recoverable_signature(&signature); signature_data.push_back(recovery_id); return signature_data; } Bytes sign(ByteView data_hash, ByteView private_key) { SecP256K1Context ctx{/* allow_verify = */ false, /* allow_sign = */ true}; secp256k1_ecdsa_signature signature; bool ok = ctx.sign(&signature, data_hash, private_key); if (!ok) { throw std::runtime_error("ecdsa_signature::sign failed"); } return ctx.serialize_signature(&signature); } EccPublicKey verify_and_recover(ByteView data_hash, ByteView signature_and_recovery_id) { if (signature_and_recovery_id.empty()) { throw std::runtime_error("ecdsa_signature::verify_and_recover: signature is empty"); } uint8_t recovery_id = signature_and_recovery_id.back(); ByteView signature_data = {signature_and_recovery_id.data(), signature_and_recovery_id.size() - 1}; SecP256K1Context ctx; secp256k1_ecdsa_recoverable_signature signature; bool ok = ctx.parse_recoverable_signature(&signature, signature_data, recovery_id); if (!ok) { throw std::runtime_error("ecdsa_signature::verify_and_recover: failed to parse a signature"); } secp256k1_pubkey public_key; ok = ctx.recover_signature_public_key(&public_key, &signature, data_hash); if (!ok) { throw std::runtime_error("ecdsa_signature::verify_and_recover: failed to recover a public key from a signature"); } return EccPublicKey{Bytes{public_key.data, sizeof(public_key.data)}}; } bool verify(ByteView data_hash, ByteView signature_data, const EccPublicKey& public_key1) { SecP256K1Context ctx; secp256k1_ecdsa_signature signature; bool ok = ctx.parse_signature(&signature, signature_data); if (!ok) { throw std::runtime_error("ecdsa_signature::verify: failed to parse a signature"); } secp256k1_pubkey public_key; memcpy(public_key.data, public_key1.data().data(), sizeof(public_key.data)); return ctx.verify_signature(&signature, data_hash, &public_key); } } // namespace silkworm::sentry::crypto::ecdsa_signature ================================================ FILE: silkworm/sentry/common/crypto/ecdsa_signature.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::sentry::crypto::ecdsa_signature { Bytes sign_recoverable(ByteView data_hash, ByteView private_key); EccPublicKey verify_and_recover(ByteView data_hash, ByteView signature_and_recovery_id); Bytes sign(ByteView data_hash, ByteView private_key); bool verify(ByteView data_hash, ByteView signature_data, const EccPublicKey& public_key); } // namespace silkworm::sentry::crypto::ecdsa_signature ================================================ FILE: silkworm/sentry/common/crypto/xor.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "xor.hpp" #include #include namespace silkworm::sentry::crypto { void xor_bytes(Bytes& data1, ByteView data2) { SILKWORM_ASSERT(data1.size() <= data2.size()); std::transform(data1.cbegin(), data1.cend(), data2.cbegin(), data1.begin(), std::bit_xor<>{}); } } // namespace silkworm::sentry::crypto ================================================ FILE: silkworm/sentry/common/crypto/xor.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry::crypto { void xor_bytes(Bytes& data1, ByteView data2); } // namespace silkworm::sentry::crypto ================================================ FILE: silkworm/sentry/common/ecc_key_pair.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ecc_key_pair.hpp" #include #include #include #include "random.hpp" namespace silkworm::sentry { EccKeyPair::EccKeyPair() { SecP256K1Context ctx; do { private_key_ = random_bytes(32); } while (!ctx.verify_private_key_data(private_key_)); } EccKeyPair::EccKeyPair(Bytes private_key_data) : private_key_(std::move(private_key_data)) { SecP256K1Context ctx; if (!ctx.verify_private_key_data(private_key_)) { throw std::invalid_argument("Invalid node key"); } } EccPublicKey EccKeyPair::public_key() const { SecP256K1Context ctx{/* allow_verify = */ false, /* allow_sign = */ true}; secp256k1_pubkey public_key; bool ok = ctx.create_public_key(&public_key, private_key_); if (!ok) { throw std::runtime_error("EccKeyPair::public_key failed to create a corresponding public key"); } return EccPublicKey(Bytes{public_key.data, sizeof(public_key.data)}); } std::string EccKeyPair::private_key_hex() const { return ::silkworm::to_hex(private_key_); } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/ecc_key_pair.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "ecc_public_key.hpp" namespace silkworm::sentry { class EccKeyPair { public: EccKeyPair(); explicit EccKeyPair(Bytes private_key_data); EccPublicKey public_key() const; ByteView private_key() const { return private_key_; } std::string private_key_hex() const; private: Bytes private_key_; }; } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/ecc_key_pair_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ecc_key_pair.hpp" #include #include namespace silkworm::sentry { TEST_CASE("EccKeyPair.public_key_hex") { CHECK( EccKeyPair(from_hex("289c2857d4598e37fb9647507e47a309d6133539bf21a8b9cb6df88fd5232032").value()) .public_key() .hex() == "7db227d7094ce215c3a0f57e1bcc732551fe351f94249471934567e0f5dc1bf795962b8cccb87a2eb56b29fbe37d614e2f4c3c45b789ae4f1f51f4cb21972ffd"); CHECK( EccKeyPair(from_hex("36a7edad64d51a568b00e51d3fa8cd340aa704153010edf7f55ab3066ca4ef21").value()) .public_key() .hex() == "24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d"); } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/ecc_public_key.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ecc_public_key.hpp" #include #include #include namespace silkworm::sentry { Bytes EccPublicKey::serialized_std(bool is_compressed) const { auto& data = data_; secp256k1_pubkey public_key; memcpy(public_key.data, data.data(), sizeof(public_key.data)); SecP256K1Context ctx; return ctx.serialize_public_key(&public_key, is_compressed); } Bytes EccPublicKey::serialized() const { Bytes data = serialized_std(); std::copy(data.cbegin() + 1, data.cend(), data.begin()); data.pop_back(); return data; } std::string EccPublicKey::hex() const { return ::silkworm::to_hex(serialized()); } EccPublicKey EccPublicKey::deserialize_std(ByteView serialized_data) { SecP256K1Context ctx; secp256k1_pubkey public_key; bool ok = ctx.parse_public_key(&public_key, serialized_data); if (!ok) { throw std::runtime_error("EccPublicKey::deserialize_std failed to parse a public key"); } return EccPublicKey{Bytes{public_key.data, sizeof(public_key.data)}}; } EccPublicKey EccPublicKey::deserialize(ByteView serialized_data) { Bytes data; data.reserve(serialized_data.size() + 1); data.push_back(SECP256K1_TAG_PUBKEY_UNCOMPRESSED); data += serialized_data; return deserialize_std(data); } EccPublicKey EccPublicKey::deserialize_hex(std::string_view hex) { auto data_opt = ::silkworm::from_hex(hex); if (!data_opt) throw std::runtime_error("EccPublicKey::deserialize_hex failed to parse a hex public key"); return deserialize(data_opt.value()); } bool operator<(const EccPublicKey& lhs, const EccPublicKey& rhs) { return lhs.data() < rhs.data(); } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/ecc_public_key.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::sentry { class EccPublicKey { public: explicit EccPublicKey(Bytes data) : data_(std::move(data)) {} ByteView data() const { return data_; } Bytes::size_type size() const { return data_.size(); } Bytes serialized_std(bool is_compressed = false) const; Bytes serialized() const; std::string hex() const; static EccPublicKey deserialize_std(ByteView serialized_data); static EccPublicKey deserialize(ByteView serialized_data); static EccPublicKey deserialize_hex(std::string_view hex); friend bool operator==(const EccPublicKey&, const EccPublicKey&) = default; private: Bytes data_; }; //! for using EccPublicKey as a key of std::map bool operator<(const EccPublicKey& lhs, const EccPublicKey& rhs); } // namespace silkworm::sentry namespace std { //! for using EccPublicKey as a key of std::unordered_map template <> struct hash { size_t operator()(const silkworm::sentry::EccPublicKey& public_key) const noexcept { auto data_str = silkworm::byte_view_to_string_view(public_key.data()); return std::hash{}(data_str); } }; } // namespace std ================================================ FILE: silkworm/sentry/common/enode_url.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enode_url.hpp" #include #include #include #include #include namespace silkworm::sentry { using namespace std; EnodeUrl::EnodeUrl(string_view url_str) : public_key_(Bytes{}) { regex url_regex( R"(enode://([0-9a-f]+)@((?:\d+\.){3}\d+)\:(\d+))", regex::icase); match_results match; if (!regex_match(url_str.cbegin(), url_str.cend(), match, url_regex)) { throw invalid_argument("Invalid enode URL format"); } string pub_key_hex = match[1]; string ip_str = match[2]; string port_str = match[3]; auto ip = boost::asio::ip::make_address(ip_str); auto port = gsl::narrow(std::stoul(port_str)); public_key_ = EccPublicKey::deserialize_hex(pub_key_hex); ip_ = ip; port_disc_ = port; port_rlpx_ = port; } string EnodeUrl::to_string() const { ostringstream out; out << "enode://"; out << public_key_.hex() << "@"; out << ip_.to_string(); out << ":" << port_rlpx_; if (port_disc_ != port_rlpx_) { out << "?discport=" << port_disc_; } return out.str(); } bool EnodeUrl::operator<(const EnodeUrl& other) const { return to_string() < other.to_string(); } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/enode_url.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "ecc_public_key.hpp" namespace silkworm::sentry { class EnodeUrl { public: explicit EnodeUrl(std::string_view url_str); EnodeUrl(EccPublicKey public_key, boost::asio::ip::address ip, uint16_t port_disc, uint16_t port_rlpx) : public_key_(std::move(public_key)), ip_(std::move(ip)), port_disc_(port_disc), port_rlpx_(port_rlpx) {} const EccPublicKey& public_key() const { return public_key_; } const boost::asio::ip::address& ip() const { return ip_; } uint16_t port_disc() const { return port_disc_; } uint16_t port_rlpx() const { return port_rlpx_; } std::string to_string() const; bool operator<(const EnodeUrl& other) const; friend bool operator==(const EnodeUrl&, const EnodeUrl&) = default; private: EccPublicKey public_key_; boost::asio::ip::address ip_; uint16_t port_disc_; uint16_t port_rlpx_; }; } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/enode_url_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enode_url.hpp" #include namespace silkworm::sentry { TEST_CASE("EnodeUrl") { EnodeUrl url1("enode://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@1.2.3.4:5"); CHECK(url1.public_key().hex() == "24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d"); CHECK(url1.ip().to_string() == "1.2.3.4"); CHECK(url1.port_disc() == 5); CHECK(url1.port_rlpx() == 5); CHECK(url1.to_string() == "enode://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@1.2.3.4:5"); CHECK_THROWS(EnodeUrl("http://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@1.2.3.4:5")); CHECK_THROWS(EnodeUrl("enode://xx@1.2.3.4:5")); CHECK_THROWS(EnodeUrl("enode://1.2.3.4:5")); CHECK_THROWS(EnodeUrl("enode://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@90000.2.3.4:5")); CHECK_THROWS(EnodeUrl("enode://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@localhost:5")); CHECK_THROWS(EnodeUrl("enode://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@1.2.3.4:x")); CHECK_THROWS(EnodeUrl("enode://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@1.2.3.4:90000")); CHECK_THROWS(EnodeUrl("enode://24bfa2cdce7c6a41184fa0809ad8d76969b7280952e9aa46179d90cfbab90f7d2b004928f0364389a1aa8d5166281f2ff7568493c1f719e8f6148ef8cf8af42d@1.2.3.4")); } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/error.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::sentry { template class Error : public std::runtime_error { public: Error(TErrorCode code, const char* message) : std::runtime_error(message), code_(code) {} TErrorCode code() const { return code_; } private: TErrorCode code_; }; } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/message.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry { struct Message { uint8_t id{0}; Bytes data; }; } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/random.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "random.hpp" namespace silkworm::sentry { Bytes random_bytes(Bytes::size_type size) { std::default_random_engine random_engine{std::random_device{}()}; std::uniform_int_distribution random_distribution{0, UINT8_MAX}; Bytes data(size, 0); for (auto& d : data) { d = static_cast(random_distribution(random_engine)); } return data; } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/random.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::sentry { Bytes random_bytes(Bytes::size_type size); template std::list random_list_items(std::list& l, size_t max_count) { // an output iterator similar to std::back_insert_iterator, // but it inserts pointers to the provided values instead of copying them to the target container class BackInsertPtrIterator { public: using iterator_category [[maybe_unused]] = std::output_iterator_tag; using value_type [[maybe_unused]] = void; using difference_type [[maybe_unused]] = std::ptrdiff_t; using pointer [[maybe_unused]] = void; using reference [[maybe_unused]] = void; explicit BackInsertPtrIterator(std::list& container) : container_(&container) {} BackInsertPtrIterator& operator=(T& value) { container_->push_back(&value); return *this; } // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved) BackInsertPtrIterator& operator=(T&&) { // required to conform to std::output_iterator container_->push_back(nullptr); // but we can't push the temporary's address return *this; } BackInsertPtrIterator& operator*() { return *this; } BackInsertPtrIterator& operator++() { return *this; } BackInsertPtrIterator operator++(int) { return *this; } private: std::list* container_; }; static_assert(std::output_iterator); std::list out; std::default_random_engine random_engine{std::random_device{}()}; std::sample(l.begin(), l.end(), BackInsertPtrIterator(out), max_count, random_engine); return out; } template std::vector random_vector_items(std::vector& l, size_t max_count) { std::vector out; std::default_random_engine random_engine{std::random_device{}()}; std::sample(l.begin(), l.end(), std::back_inserter(out), max_count, random_engine); return out; } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/socket_stream.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "socket_stream.hpp" #include #include #include #include #include namespace silkworm::sentry { using namespace boost::asio; Task SocketStream::send(Bytes data) { co_await async_write(socket_, buffer(data), use_awaitable); } Task SocketStream::receive_short() { Bytes data = co_await receive_fixed(sizeof(uint16_t)); uint16_t value = endian::load_big_u16(data.data()); co_return value; } Task SocketStream::receive_fixed(size_t size) { Bytes data(size, 0); co_await async_read(socket_, buffer(data), use_awaitable); co_return std::move(data); } Task SocketStream::receive_size_and_data(Bytes& raw_data) { raw_data.resize(sizeof(uint16_t)); co_await async_read(socket_, buffer(raw_data), use_awaitable); uint16_t size = endian::load_big_u16(raw_data.data()); raw_data.resize(raw_data.size() + size); auto data_ptr = raw_data.data() + sizeof(uint16_t); co_await async_read(socket_, buffer(data_ptr, size), use_awaitable); co_return ByteView(data_ptr, size); } } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/common/socket_stream.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::sentry { class SocketStream { public: explicit SocketStream(const boost::asio::any_io_executor& executor) : socket_(executor) {} SocketStream(SocketStream&&) = default; SocketStream& operator=(SocketStream&&) noexcept = default; boost::asio::ip::tcp::socket& socket() { return socket_; } const boost::asio::ip::tcp::socket& socket() const { return socket_; } Task send(Bytes data); Task receive_short(); Task receive_fixed(size_t size); Task receive_size_and_data(Bytes& raw_data); private: boost::asio::ip::tcp::socket socket_; }; } // namespace silkworm::sentry ================================================ FILE: silkworm/sentry/discovery/bootnodes.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "bootnodes.hpp" #include #include // TODO(yperbasis): add polygon boot nodes namespace silkworm::sentry::discovery { enum class NetworkId : uint64_t { kMainnet = *kKnownChainNameToId.find("mainnet"), kHolesky = *kKnownChainNameToId.find("holesky"), kSepolia = *kKnownChainNameToId.find("sepolia"), }; // MainnetBootnodes are the enode URLs of the P2P bootstrap nodes running on // the main Ethereum network. std::vector kMainnetBootnodes = { // Ethereum Foundation Go Bootnodes EnodeUrl{"enode://d860a01f9722d78051619d1e2351aba3f43f943f6f00718d1b9baa4101932a1f5011f16bb2b1bb35db20d6fe28fa0bf09636d26a87d31de9ec6203eeedb1f666@18.138.108.67:30303"}, // bootnode-aws-ap-southeast-1-001 EnodeUrl{"enode://22a8232c3abc76a16ae9d6c3b164f98775fe226f0917b0ca871128a74a8e9630b458460865bab457221f1d448dd9791d24c4e5d88786180ac185df813a68d4de@3.209.45.79:30303"}, // bootnode-aws-us-east-1-001 EnodeUrl{"enode://2b252ab6a1d0f971d9722cb839a42cb81db019ba44c08754628ab4a823487071b5695317c8ccd085219c3a03af063495b2f1da8d18218da2d6a82981b45e6ffc@65.108.70.101:30303"}, // bootnode-hetzner-hel EnodeUrl{"enode://4aeb4ab6c14b23e2c4cfdce879c04b0748a20d8e9b59e25ded2a08143e265c6c25936e74cbc8e641e3312ca288673d91f2f93f8e277de3cfa444ecdaaf982052@157.90.35.166:30303"}, // bootnode-hetzner-fsn }; std::vector kHoleskyBootnodes = { EnodeUrl{"enode://ac906289e4b7f12df423d654c5a962b6ebe5b3a74cc9e06292a85221f9a64a6f1cfdd6b714ed6dacef51578f92b34c60ee91e9ede9c7f8fadc4d347326d95e2b@146.190.13.128:30303"}, EnodeUrl{"enode://a3435a0155a3e837c02f5e7f5662a2f1fbc25b48e4dc232016e1c51b544cb5b4510ef633ea3278c0e970fa8ad8141e2d4d0f9f95456c537ff05fdf9b31c15072@178.128.136.233:30303"}, }; // SepoliaBootnodes are the enode URLs of the P2P bootstrap nodes running on the // Sepolia test network. std::vector kSepoliaBootnodes = { // EF DevOps EnodeUrl{"enode://4e5e92199ee224a01932a377160aa432f31d0b351f84ab413a8e0a42f4f36476f8fb1cbe914af0d9aef0d51665c214cf653c651c4bbd9d5550a934f241f1682b@138.197.51.181:30303"}, // sepolia-bootnode-1-nyc3 EnodeUrl{"enode://143e11fb766781d22d92a2e33f8f104cddae4411a122295ed1fdb6638de96a6ce65f5b7c964ba3763bba27961738fef7d3ecc739268f3e5e771fb4c87b6234ba@146.190.1.103:30303"}, // sepolia-bootnode-1-sfo3 EnodeUrl{"enode://8b61dc2d06c3f96fddcbebb0efb29d60d3598650275dc469c22229d3e5620369b0d3dedafd929835fe7f489618f19f456fe7c0df572bf2d914a9f4e006f783a9@170.64.250.88:30303"}, // sepolia-bootnode-1-syd1 EnodeUrl{"enode://10d62eff032205fcef19497f35ca8477bea0eadfff6d769a147e895d8b2b8f8ae6341630c645c30f5df6e67547c03494ced3d9c5764e8622a26587b083b028e8@139.59.49.206:30303"}, // sepolia-bootnode-1-blr1 EnodeUrl{"enode://9e9492e2e8836114cc75f5b929784f4f46c324ad01daf87d956f98b3b6c5fcba95524d6e5cf9861dc96a2c8a171ea7105bb554a197455058de185fa870970c7c@138.68.123.152:30303"}, // sepolia-bootnode-1-ams3 // from https://github.com/erigontech/erigon/issues/6134#issuecomment-1354923418 EnodeUrl{"enode://8ae4559db1b1e160be8cc46018d7db123ed6d03fbbfe481da5ec05f71f0aa4d5f4b02ad059127096aa994568706a0d02933984083b87c5e1e3de2b7692444d37@35.161.233.158:46855"}, EnodeUrl{"enode://d0b3b290422f35ec3e68356f3a4cdf9c661f71a868110670e31441a5021d7abd0440ae8dfb9360aafdd0198f177863361e3a7a7eb5e1a3e26575bf1ac3ef4ab3@162.19.136.65:48264"}, EnodeUrl{"enode://d64624bda3cdb65d542c90757a4a661cfe9dddf8328bdb1ea97a8d70fad287c360f0101c492d8fd6ab30d79160a3bf148cacfd68f5d2e47eab0b709516419304@51.195.63.10:30040"}, EnodeUrl{"enode://c7df835939e027325c6bba926220fae5912a33c83d96b3eef8ef445c98083f3191788581c9a0e8f74cadb0b13229b847f5c1ebd315b22bcf11faf6468020eb48@54.163.51.157:30303"}, EnodeUrl{"enode://da0609bad3afcab9b93175a41a2d621d07aa7ff6c134a00792d4541f0ce8d30d8f3c51bb37a47573508a0bf18865b04066af2a661edf1d3a3d8d133fc1031aa0@88.151.101.14:45192"}, EnodeUrl{"enode://7a4534d392c59369eae6befa56ac670476d9edc16597cf53c92bbefa6e741b6b0b9e6822cab12afb09123e03ca1131026fbef145adec429fe2e50182dfb650a5@94.130.18.108:31312"}, EnodeUrl{"enode://db6fa13b63a885440de581ee3fc8df9c6a590326b39fc5ccba7991707ee0cebac306211f7eca5270a350201a3132511f2338481edd81f3dc819c2a1c60419cf2@65.21.89.157:30303"}, EnodeUrl{"enode://fcf03e9404cace34c60e4eed374ef9a779471014319b3346352fbc2f992a399af6517486e8e65a4ab55f4645fe55420bbea1cddc13a4af4df63b0f731915c6a6@13.125.238.49:46173"}, EnodeUrl{"enode://8b973816278fdd56966709e4794c7ccce1f256eaa9165a6b013b991a9bdf3886a8f2d23af50ee723a5614a9fe9d197252b803b4455a87ab2468e128f7b06e0ca@172.104.107.145:30303"}, EnodeUrl{"enode://5a1fb15f826a213d3ef4adb9be47ab58b2240ea05df0d760a244f04762b0847dcb08276b1284f726c22eea30fce0c601cf121b81bac0c151f1b3b4ad00d1482a@34.159.55.147:51262"}, EnodeUrl{"enode://560928dd14819f88113586726e452b16bbc694ed4144ddadd6290053e7f3fc66bfad13add6889f7d8f37e0c21ccbb6948eb8899c8b30743f4b45a3081f1efed8@34.138.254.5:29888"}, EnodeUrl{"enode://69a13b575b8c5278431409e9f7db36e7218667ae286bfb65a72dfec9201b2c5bbbe2797a1babbdf17a7bf7ca68fa3fbe1554612637eb1b2425fa975e1bccb54c@35.223.41.3:30303"}, EnodeUrl{"enode://66158b31eecff939f220b291d2b448edbfe94f1d4c992d9395b5d476e55e54b5abd11d3ee44daf1e18ee27b910ef99cdf6f19775eb4820ebe4f77d7aa948e3b6@51.195.63.10:55198"}, EnodeUrl{"enode://bf94acbd51170bf075cacb9f149b21ff46354d659ab434a0d40688f776e1e1556bc62be2dc2867ba513844268c0dc8240099a6b60efe1713fbc25da7fdeb6ff1@3.82.105.139:30303"}, EnodeUrl{"enode://41329e5ceb51cdddbe6a475db00b682505768b71ff8ee37d2d3500ca1b78918f9fad57d6006dd9f79cd418437dbcf87ec2fd58d60710f925cb17da05a51197cf@65.21.34.60:30303"}, EnodeUrl{"enode://4e5e92199ee224a01932a377160aa432f31d0b351f84ab413a8e0a42f4f36476f8fb1cbe914af0d9aef0d51665c214cf653c651c4bbd9d5550a934f241f1682b@138.197.51.181:30303"}, EnodeUrl{"enode://143e11fb766781d22d92a2e33f8f104cddae4411a122295ed1fdb6638de96a6ce65f5b7c964ba3763bba27961738fef7d3ecc739268f3e5e771fb4c87b6234ba@146.190.1.103:30303"}, EnodeUrl{"enode://8b61dc2d06c3f96fddcbebb0efb29d60d3598650275dc469c22229d3e5620369b0d3dedafd929835fe7f489618f19f456fe7c0df572bf2d914a9f4e006f783a9@170.64.250.88:30303"}, EnodeUrl{"enode://10d62eff032205fcef19497f35ca8477bea0eadfff6d769a147e895d8b2b8f8ae6341630c645c30f5df6e67547c03494ced3d9c5764e8622a26587b083b028e8@139.59.49.206:30303"}, EnodeUrl{"enode://9e9492e2e8836114cc75f5b929784f4f46c324ad01daf87d956f98b3b6c5fcba95524d6e5cf9861dc96a2c8a171ea7105bb554a197455058de185fa870970c7c@138.68.123.152:30303"}, }; std::span bootnodes(uint64_t network_id) { switch (static_cast(network_id)) { case NetworkId::kMainnet: return std::span{kMainnetBootnodes.data(), kMainnetBootnodes.size()}; case NetworkId::kHolesky: return std::span{kHoleskyBootnodes.data(), kHoleskyBootnodes.size()}; case NetworkId::kSepolia: return std::span{kSepoliaBootnodes.data(), kSepoliaBootnodes.size()}; default: return std::span{}; } } } // namespace silkworm::sentry::discovery ================================================ FILE: silkworm/sentry/discovery/bootnodes.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry::discovery { std::span bootnodes(uint64_t network_id); } // namespace silkworm::sentry::discovery ================================================ FILE: silkworm/sentry/discovery/common/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(Boost REQUIRED COMPONENTS headers) include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") silkworm_library(silkworm_sentry_discovery_common PUBLIC silkworm_core Boost::headers) ================================================ FILE: silkworm/sentry/discovery/common/node_address.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node_address.hpp" #include #include #include #include namespace silkworm::sentry::discovery { Bytes ip_address_to_bytes(const boost::asio::ip::address& ip) { if (ip.is_v4()) { auto ip_bytes = ip.to_v4().to_bytes(); return Bytes{array_to_byte_view(ip_bytes)}; } if (ip.is_v6()) { auto ip_bytes = ip.to_v6().to_bytes(); return Bytes{array_to_byte_view(ip_bytes)}; } return {}; } std::optional ip_address_from_bytes(ByteView ip_bytes) noexcept { if (ip_bytes.size() == sizeof(boost::asio::ip::address_v4::bytes_type)) { boost::asio::ip::address_v4::bytes_type ip_bytes_array; memcpy(ip_bytes_array.data(), ip_bytes.data(), ip_bytes.size()); return {boost::asio::ip::address_v4{ip_bytes_array}}; } if (ip_bytes.size() == sizeof(boost::asio::ip::address_v6::bytes_type)) { boost::asio::ip::address_v6::bytes_type ip_bytes_array; memcpy(ip_bytes_array.data(), ip_bytes.data(), ip_bytes.size()); return {boost::asio::ip::address_v6{ip_bytes_array}}; } return std::nullopt; } //! RLP length size_t length(const NodeAddress& address) { return rlp::length(ip_address_to_bytes(address.endpoint.address()), address.endpoint.port(), address.port_rlpx); } //! RLP encode void encode(Bytes& to, const NodeAddress& address) { rlp::encode(to, ip_address_to_bytes(address.endpoint.address()), address.endpoint.port(), address.port_rlpx); } //! RLP decode DecodingResult decode(ByteView& from, NodeAddress& to, rlp::Leftover mode) noexcept { Bytes ip_bytes; uint16_t port{0}; auto result = rlp::decode(from, mode, ip_bytes, port, to.port_rlpx); if (!result) { return result; } auto ip = ip_address_from_bytes(ip_bytes); if (!ip) { return tl::unexpected{DecodingError::kUnexpectedString}; } to.endpoint = boost::asio::ip::udp::endpoint(*ip, port); return result; } } // namespace silkworm::sentry::discovery ================================================ FILE: silkworm/sentry/discovery/common/node_address.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include namespace silkworm::sentry::discovery { struct NodeAddress { boost::asio::ip::udp::endpoint endpoint; uint16_t port_rlpx{}; NodeAddress() = default; NodeAddress(boost::asio::ip::udp::endpoint endpoint1, uint16_t port_rlpx1) : endpoint(std::move(endpoint1)), port_rlpx(port_rlpx1) {} NodeAddress(const boost::asio::ip::address& ip, uint16_t port_disc, uint16_t port_rlpx1) : endpoint(ip, port_disc), port_rlpx(port_rlpx1) {} }; //! RLP length size_t length(const NodeAddress&); //! RLP encode void encode(Bytes& to, const NodeAddress&); DecodingResult decode(ByteView& from, NodeAddress& to, rlp::Leftover mode) noexcept; Bytes ip_address_to_bytes(const boost::asio::ip::address& ip); std::optional ip_address_from_bytes(ByteView ip_bytes) noexcept; } // namespace silkworm::sentry::discovery ================================================ FILE: silkworm/sentry/discovery/disc_v4/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(Boost REQUIRED COMPONENTS headers) include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") silkworm_library( silkworm_sentry_disc_v4 PUBLIC silkworm_infra silkworm_sentry_common silkworm_sentry_node_db silkworm_sentry_discovery_enr PRIVATE Boost::headers stbrumme_keccak silkworm_core silkworm_sentry_discovery_common ) ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/ip_classify.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ip_classify.hpp" #include #include #include #include namespace silkworm::sentry::discovery::disc_v4 { using namespace boost::asio::ip; static const std::vector& networks_lan_v4() { static std::vector networks = { make_network_v4("10.0.0.0/8"), make_network_v4("172.16.0.0/12"), make_network_v4("192.168.0.0/16"), make_network_v4("169.254.0.0/16"), }; return networks; } static const std::vector& networks_lan_v6() { static std::vector networks = { make_network_v6("fc00::/7"), make_network_v6("fe80::/10"), }; return networks; } static const std::vector& networks_special_v4() { static std::vector networks = { make_network_v4("100.64.0.0/10"), make_network_v4("192.0.0.0/24"), make_network_v4("192.0.0.8/32"), make_network_v4("192.0.0.9/32"), make_network_v4("192.0.0.10/32"), make_network_v4("192.0.0.170/32"), make_network_v4("192.0.0.171/32"), make_network_v4("192.0.2.0/24"), make_network_v4("192.31.196.0/24"), make_network_v4("192.52.193.0/24"), make_network_v4("192.175.48.0/24"), make_network_v4("198.18.0.0/15"), make_network_v4("198.51.100.0/24"), make_network_v4("203.0.113.0/24"), make_network_v4("240.0.0.0/4"), make_network_v4("255.255.255.255/32"), }; return networks; } static const std::vector& networks_special_v6() { static std::vector networks = { make_network_v6("100::/64"), make_network_v6("2001::/23"), make_network_v6("2001:1::1/128"), make_network_v6("2001:1::2/128"), make_network_v6("2001:2::/48"), make_network_v6("2001:3::/32"), make_network_v6("2001:4:112::/48"), make_network_v6("2001:20::/28"), make_network_v6("2001:30::/28"), make_network_v6("2001:db8::/32"), make_network_v6("2620:4f:8000::/48"), }; return networks; } static bool ip_belongs_to_networks_v4(const address_v4& ip, const std::vector& networks) { auto predicate = [&ip](const network_v4& network) { auto hosts = network.hosts(); return hosts.find(ip) != hosts.end(); }; return std::find_if(networks.begin(), networks.end(), predicate) != networks.end(); } static bool ip_belongs_to_networks_v6(const address_v6& ip, const std::vector& networks) { auto predicate = [&ip](const network_v6& network) { auto hosts = network.hosts(); return hosts.find(ip) != hosts.end(); }; return std::find_if(networks.begin(), networks.end(), predicate) != networks.end(); } static bool ip_is_lan(const address& ip) { if (ip.is_v4()) return ip_belongs_to_networks_v4(ip.to_v4(), networks_lan_v4()); if (ip.is_v6()) return ip_belongs_to_networks_v6(ip.to_v6(), networks_lan_v6()); return false; } static bool ip_is_special(const address& ip) { if (ip.is_v4()) return ip_belongs_to_networks_v4(ip.to_v4(), networks_special_v4()); if (ip.is_v6()) return ip_belongs_to_networks_v6(ip.to_v6(), networks_special_v6()); return false; } IpAddressType ip_classify(const address& ip) { if (ip.is_unspecified()) return IpAddressType::kUnspecified; if (ip.is_loopback()) return IpAddressType::kLoopback; if (ip.is_multicast()) return IpAddressType::kMulticast; if (ip == address_v4::broadcast()) return IpAddressType::kBroadcast; if (ip_is_lan(ip)) return IpAddressType::kLAN; if (ip_is_special(ip)) return IpAddressType::kSpecial; return IpAddressType::kRegular; } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/ip_classify.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::sentry::discovery::disc_v4 { enum class IpAddressType { kRegular, kUnspecified, kLoopback, kMulticast, kBroadcast, kLAN, // https://www.iana.org/assignments/iana-ipv4-special-registry/ // https://www.iana.org/assignments/iana-ipv6-special-registry/ kSpecial, }; IpAddressType ip_classify(const boost::asio::ip::address& ip); } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/ip_classify_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ip_classify.hpp" #include #include namespace silkworm::sentry::discovery::disc_v4::common { using namespace boost::asio::ip; TEST_CASE("ip_classify") { CHECK(ip_classify(make_address("23.55.1.242")) == IpAddressType::kRegular); CHECK(ip_classify(make_address("192.0.3.1")) == IpAddressType::kRegular); CHECK(ip_classify(make_address("1.0.0.0")) == IpAddressType::kRegular); CHECK(ip_classify(make_address("172.32.0.1")) == IpAddressType::kRegular); CHECK(ip_classify(make_address("fec0::2233")) == IpAddressType::kRegular); CHECK(ip_classify(make_address("0.2.0.8")) == IpAddressType::kRegular); CHECK(ip_classify(make_address("0.0.0.0")) == IpAddressType::kUnspecified); CHECK(ip_classify(make_address("127.0.0.1")) == IpAddressType::kLoopback); CHECK(ip_classify(make_address("127.0.2.19")) == IpAddressType::kLoopback); CHECK(ip_classify(make_address("224.0.0.22")) == IpAddressType::kMulticast); CHECK(ip_classify(make_address("ff05::1:3")) == IpAddressType::kMulticast); CHECK(ip_classify(make_address("255.255.255.255")) == IpAddressType::kBroadcast); CHECK(ip_classify(make_address("10.0.1.1")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("10.22.0.3")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("172.31.252.251")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("192.168.0.1")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("192.168.1.4")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("fe80::f4a1:8eff:fec5:9d9d")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("febf::ab32:2233")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("fc00::4")) == IpAddressType::kLAN); CHECK(ip_classify(make_address("192.0.2.1")) == IpAddressType::kSpecial); CHECK(ip_classify(make_address("192.0.2.44")) == IpAddressType::kSpecial); CHECK(ip_classify(make_address("192.0.0.171")) == IpAddressType::kSpecial); CHECK(ip_classify(make_address("2001:db8:85a3:8d3:1319:8a2e:370:7348")) == IpAddressType::kSpecial); } } // namespace silkworm::sentry::discovery::disc_v4::common ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/ipv6_unsupported_error.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::sentry::discovery::disc_v4 { class IPV6UnsupportedError : public std::runtime_error { public: IPV6UnsupportedError() : std::runtime_error("IPv6 is not supported") {} }; } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/message_expiration.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "message_expiration.hpp" namespace silkworm::sentry::discovery::disc_v4 { std::chrono::time_point make_message_expiration() { using namespace std::chrono_literals; static constexpr std::chrono::seconds kTtl = 20s; return std::chrono::system_clock::now() + kTtl; } bool is_expired_message_expiration(std::chrono::time_point expiration) { return is_time_in_past(expiration); } bool is_time_in_past(std::chrono::time_point time) { return time < std::chrono::system_clock::now(); } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/message_expiration.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::sentry::discovery::disc_v4 { std::chrono::time_point make_message_expiration(); bool is_expired_message_expiration(std::chrono::time_point expiration); bool is_time_in_past(std::chrono::time_point time); } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/node_distance.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node_distance.hpp" #include #include #include #include namespace silkworm::sentry::discovery::disc_v4 { size_t node_distance(const EccPublicKey& id1, const EccPublicKey& id2) { auto id1_hash = keccak256(id1.serialized()); auto id2_hash = keccak256(id2.serialized()); Bytes diff{ByteView{id1_hash.bytes}}; ByteView id2_hash_bytes{id2_hash.bytes}; crypto::xor_bytes(diff, id2_hash_bytes); size_t same_bits_count = 0; for (uint8_t byte : diff) { int same_bits = std::countl_zero(byte); same_bits_count += static_cast(same_bits); if (same_bits < 8) { break; } } return diff.size() * 8 - same_bits_count; } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/node_distance.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::sentry::discovery::disc_v4 { size_t node_distance(const EccPublicKey& id1, const EccPublicKey& id2); } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/node_distance_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node_distance.hpp" #include namespace silkworm::sentry::discovery::disc_v4 { TEST_CASE("distance") { auto id = EccPublicKey::deserialize_hex; CHECK(node_distance(id("e2b1dfe70675c9c82c540789359013153bd5bba3660956f0eff031e3ae4b5a8bb78e396a9e9f75fb24e9922d5855c675afbf7bbbd0a286b46e7fcb73091735e9"), id("29327274fb7cef377c555ba55e345c0c5c026d145282bbd26f88e0ba174d1a5d83903db9a5ee80a8320b6fc539c7459a574aa95477c7ea4b6cde9fa007bb3bc4")) == 256); CHECK(node_distance(id("f6184250f0ca4b0c711889e27874d440c717a1dc3ca79345414bade42b11178b14004cf2bc3fd9a5117eb0bbc675da0bfe150669f58de59f6c8e259c6fdf89be"), id("708ddc2b343a3d2668d4866188545edd96a0c8c2bc6b21daab69f047fda504d60c2d4edb9afa947955c1e7b61756588e484a6379c5885ab1caaf836ee0d6a3a0")) == 255); CHECK(node_distance(id("b9b918c8f1198bafbd9a8fa50ad689393c2252eff275fc1490b6ea4993c40f1117ddeafef88ae5a702ef08617d626b3699343ba8b0dba3485b4e8ada74c2f261"), id("ca53d549d6a5ced4d075eb2341df142340ea5c2fe5dd72dd3b12578ee9abf7314be25a5d1bf2dea264ff0bbdd933e1265bdc2f050af2ee723134f5cbb2038e80")) == 254); CHECK(node_distance(id("35474838cfaafff7f4a9321415edc7658f46212bef75681824e9bab9f3f3a2c717b522a947c116693e9ac22705d1f15108764ada4962cc770dfbdf34f5bbc479"), id("a3e6f07150e298427a00a80591eda5356cb07344e94a54a42ba5c58ec0e7fd5acc7b897e9c35dbc044f1bfec07fa431d3d3757b6e0939e983b4bfba03f885c7e")) == 253); CHECK(node_distance(id("b800d659c02d66f2f8e5347fae0663e772390d0b33da18c393d84834da70b7b8522a0099e85a16275c6cb274227f2f99efee4e13662b73c45a90dfda0ddc27c4"), id("8e9ef977bd93cc76cb62dfc65b1534878b2315271e4c09fc5337e2d672b3220af3a77a33a57a1958c179e2ae8358a4037584a370026215d50a884c06f2fd9cfa")) == 252); CHECK(node_distance(id("00fc6ff33b589fc2879905f9a179ee6ab21d80fa4581745bc15c0f311075cec435604a61feffc405445101db0288bb943c43821566a4b8b1aa90117faadccad5"), id("b81a407076268b11790429dbf2bb5e0d466a5606e2549a794409112ebbd24f4361a0c0e2adec0fc43d64de17dbb9a2f3a917dd94f6aecded87cb6f62c6319c57")) == 251); CHECK(node_distance(id("42f37f45f0133c951d1cf4ac33cd2feb93893cb7558b534e1b4f96bef95be0245181f1f1fa7e987461561e5bc5d02c8b4f5e2b134b5d2d8c44d711a2c857ef3c"), id("6609dd69289f41c22d6d8338a29e050a77efdad2489caf49cdd5b70d6bdc0366f69ec024bac63d8974844a73b3472e6611f2ea26bf49bb285dfa8fcb5bdd860d")) == 250); CHECK(node_distance(id("973e0b58bd1cd8eec974ddb2eda51dad21783295a8ba55a88e1cddbe5072dabcc7db16922361a9e66c154cb71c9aa7bedd5003a356f44916d8b85c1467846a14"), id("87fee2d3f5a6a1b6ac2d003ef82bd691fd828737a198b0dfc483bd89c7317ea67f32851166b218966314ed0e6cc4967c222729415f9be08c806f7d770a4750ec")) == 249); CHECK(node_distance(id("b655f1c7987d6b3ee6f96fa89f9802944fedfa44055e920a82d4953a267e1dc61898186277f7fe0cbb4e254c142df4ac08d64981f91087020dbacf7724942749"), id("95f9649da17beb05b6ff00043f64f2ae06c3e5587f461eecc24083d99033fa2c3c1552d38da970a6446f583278edd5c67c7945d9339cbeacafad77aff773c6b3")) == 248); CHECK(node_distance(id("51ad4bb22b48246ba0c663b31fa14a1edbc3054cf88136f9a62e52b813f0e39f0bdf4ad4a1a4db6309c8df245a53fe505ac18624a07de4f04ec265de39998507"), id("e5f5648ca4218c0a35758984b5eaf7b9e94c189e982c4fbcdecbb2ef6209885768278fb60f5d8de95416d4b8819da4566f0fcfe9f18147237c8f656bc3666824")) == 247); CHECK(node_distance(id("0e695470d54acc038b9c470512541ddd7e2c6e80415b92253a4ac0a8277a970f72add72e8099082544ac7242f5edc61d005af2be514f70376733166a06a0d087"), id("1bfbacf7ccf8bce69087687b9280b0eb74a65a5797977f2f2224052fd7bcc800b5311cacfad7f1e6adf55d5a1681e243528c0127d506c76259d02e8fe9c49732")) == 246); CHECK(node_distance(id("34afcbabcb95569e9fde85ff17bdae3d928bd7c625271e7ab047a0a26cd45f3f5e41fbfac88dbbb8e85422328be1e78a30d5957e1c025c97fffc7602dac48baa"), id("dcb371597d681dc7759a153956de93a98cd2ed69e16f9f326c1e36d514e5c92951678eac6a2657921268967a977823443da3a954e610d1cb7512e7dc72e9559d")) == 245); CHECK(node_distance(id("0bdb585d1f8561e38d8ba05b5e743abfaa89b9a8dd8367172e4c0f2f413c395d16f1f4eb2b6a065015b40131f885cda85f0b4e12fab83c6cb0406cfcc5de0185"), id("a983e853a3409c2f2861c06bc8266fa9c41f6c253dd219385abeb1be1999336214c60bccbe95446952f81063effc447f0abde249f127922a4d25ed3040a87e5a")) == 244); CHECK(node_distance(id("811309d80e1e21f1284ba4fd8d6d0faf81b8d284bcacad34d8c66c501f7792a23e3341235eb294684224a4996e1121de72b6f1f106ccdc6da3994753fbf317ef"), id("a7dab310c77f6dc0e559f69df6c6af4a7661512658d44fd269dd8882d36ffef6c30c4f450df07eab7a32e38df186d4ac659e5b889d5e10ab292d1e2c0809ea00")) == 243); CHECK(node_distance(id("c4ee97740ee9733d049c157ef34dbd3e0bdd4e2b6e3fc5d281eae03eeecea78d2b84cb8b5eaa48f8af721f3665fdbeb22471732f1c671ae3675b23c0663990df"), id("779ad287894ef641131ac6dc2dcd3a5a976650cfad9d8396c1c7184e133899b2e17ca2505838754b06774f74551cc3f8f0e24e5f4fe2d9f5f4bd711b1f4290ea")) == 242); CHECK(node_distance(id("8b2d08a040bdb1bd3bc1d947e98edf760ceef8506e1c6f7d0b30fce6fbe4f419a61fe6726dc166416eb4ed12f8f3063ccc0580600052b519d27336084f75b1ee"), id("e99292b9cbdab866b1e7eca5081a1ea2fcdb0af5da77d5fffae5fcc7fbc985394bebd0b0fea3428e9164602d573c10628097d7b2304dc40c4133bcaa775a6433")) == 241); CHECK(node_distance(id("edd26fcfad2d3f68f4c8ba7018895708909a87a1f3b34f0f931c6b8ab5a57c2264483cdfa0c910c597605736c946696703af752a93f3f03f14b8e1ffbcf92855"), id("3aa6608c6ac787577f628f7c7fcc179ea9a5c9a6a54bf50146d44ee3e2425de2465aacadb97057d4f8d26127c9997d292bed8ff441d91251dc1640d743f65cdb")) == 240); CHECK(node_distance(id("e31da2ba534ebdfbe8b1863c5a76eaa3dda03c6a55f7345e6a9ef1cda3c3ba77ae03513d37903c44b5400b0a1fbce6f6d87ec810563a6563794a91d2631f8f09"), id("3b5d897d76523a15a84ac1fef4dae83a2bce6501fde29ae620749a35dc1199d12666fdfef148ebd9bfc2cf2f25af9820049e34472612934d91603ab05278efd5")) == 239); CHECK(node_distance(id("cfd448d68854f5b8031d8ab13fdad34ff46b6a83c39711c58cb31b54c9b1798c6aa167adf9d3dae3e852a9569c2ee3a21dbb93a5441e5ee836554bf4697dec4f"), id("12743e04f81934681dc9a2da498fa574e7b95851bc9ed4903dc37be7e6171319815165bed420f0b6e4cae4923fb62f37932bee553f3d8b92dd4e7bbad469aa8e")) == 238); CHECK(node_distance(id("cfd448d68854f5b8031d8ab13fdad34ff46b6a83c39711c58cb31b54c9b1798c6aa167adf9d3dae3e852a9569c2ee3a21dbb93a5441e5ee836554bf4697dec4f"), id("cfd448d68854f5b8031d8ab13fdad34ff46b6a83c39711c58cb31b54c9b1798c6aa167adf9d3dae3e852a9569c2ee3a21dbb93a5441e5ee836554bf4697dec4f")) == 0); CHECK(node_distance(id("d00f5c3209c00b5f40300b0613329b2e65de285ac7b0c7e36d9bfbf64715a23b85380a3657514a71eeec54d0d585cda04aa1b618265a62c8798a2eba7ce16f0d"), id("d00f5c3209c00b5f40300b0613329b2e65de285ac7b0c7e36d9bfbf64715a23b85380a3657514a71eeec54d0d585cda04aa1b618265a62c8798a2eba7ce16f0d")) == 0); CHECK(node_distance(id("d00f5c3209c00b5f40300b0613329b2e65de285ac7b0c7e36d9bfbf64715a23b85380a3657514a71eeec54d0d585cda04aa1b618265a62c8798a2eba7ce16f0d"), id("da06206e55dd849c7c2c0b97def4b0e62bf99d7f395a69b5efe370dc5e501636039c41bd52c4b9d7a4d409d9b59aeb66bd2f25d0db85a1cf84889a0b2893b755")) == 256); CHECK(node_distance(id("40587ed129df02457b35027564ed7a915e8638460f3a1e55a04c29d447a36b731d5105be6f0317b6d4b231bd9a3e974d42822c27ce16e74b258fb8642dcd8f43"), id("19359199e6aa0038bca8e440e441dbd86b523ecaca5e0969bd80ac13ee75137dd43c4fe59907cba35ea723b1d3fe448401bfc4f8a4eee7fcf4b468e6dfbc1fa2")) == 256); CHECK(node_distance(id("1f20d6dff3a573aa8516d4ae266de6b0e0b0b371fbc45c7570e230f3559a9636bcf6cfd9b68c1b8cbb7f865c63dad3029feace82a5c206cce7c6699bc8c7c90e"), id("7abdedc2bc730891a0c5d25f9db3e77772531552ae1ca60d6fcf52110cc00efc2a41beb313d8d6a486c6b916638b43c843e0c15e1da27969157c9652f05584e8")) == 255); CHECK(node_distance(id("27a3e8a9bd8c3dc8d8385a95da26fe07cfdabf520d6516688e5d1f58009eba25ca219b0f647b9912ec7f215fb6b628c5eb6f10dfa60f213b7e623081fa96864b"), id("6047670f2a064f12681f7e850336a606000bb5287cb2631d3c469d0add1f535e29883b8b7523b5caf095b30456f9548b19dceacbbcd8a4532468c40c4d7cd14b")) == 255); CHECK(node_distance(id("8606e2e73bb7120b3c8a280bc9ddb6ec103042109da0a50f2a991ca19502b2225186d64ab1d26ad9229d9181ccfb54fdbfff54f9209147751388eeb135372ce6"), id("4f02bc52c7a8692bba40675b5e955ad6411344dbd3e6a2015947c54193d54c61bde8dc66ab0bec477e3baf53c193c425d28af599cd41129ab3a91d1ac32c0a4e")) == 254); CHECK(node_distance(id("905c5bdd20fc03e05042bdfac884336852077a054da47cfdf6fe763ae0774f9f0bfe0e4bba40738d5810418876183e9c9c17e25579a1e742fe09022a8f7d26c4"), id("d03349d73725e3b967e1edb2c9fa0c4f8f56e2d522a1289e889c5766d8f4e33408b0f363602eb3dcec53c7c8ea047d691994a1e2abb50da8bc8aba5fa4ab18ae")) == 254); CHECK(node_distance(id("b4cb19f92fb2325e41f239f7ed2e44da26e0578add3e3682f1dad0a94ce14d4e36bf092e6f9717b68765a76552a5b403f78f3f5c92c0f8172edd63c67e369f79"), id("62beb0427661dd95e24329ca34d5791db678a5c31c8bb9a2de81e464fe97a63632944c2b9ab07a9c4441b2adddabcf5c35c73fbfae483c1b416d8cfb3826d841")) == 254); CHECK(node_distance(id("76fbc4bb1a26eda04237fcdd9042c04e52c9c2302f32d455fe75479f54a441251e8e7e003729c9014611b710c5916e63ae920b5dfa6901692f5b7e82621cd528"), id("7764238559b9541c75ab34eb6c923b6e71c5d10291933f84c50b65575371377b9a14d7c0eb5e94e0ee5e5cb42347a149a734a18e42b49cd477c86701c1667a97")) == 253); CHECK(node_distance(id("f23636b28840898bc50c19897c1f64528e25331d47148806d662919b206d69da9dce74f97adb6f7925e8ca2172d5ee7f72bf7a82b1cb688b1376746c6fd9c293"), id("3656d2b5b4a80592dc8484d821bdd7b0e131c93b7425d61f37c4273ceb8e078f63b420703445b41f5123d4b6978950ff602fe792ea50c50f43cff6e7f2971e87")) == 252); CHECK(node_distance(id("455920ca5e232c195e517095c0bb6fbd009b0271d3e3302b1ee743f948256a47f267fb68b4b5abf484ff4b1319c792801760a17edc995d764f6a5f748c71ba34"), id("22916cb121608c65cd8604744b9aaab267830f0d23ef36af05c0d5375e65e5fde8c4238d25b708d2b3e22d0142774ac8875dcb00e512b63f29136965e25c84df")) == 251); } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/common/packet_type.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include namespace silkworm::sentry::discovery::disc_v4 { // NOLINTNEXTLINE(readability-enum-initial-value) enum class PacketType : uint8_t { kPing = 1, kPong, kFindNode, kNeighbors, kEnrRequest, kEnrResponse, kMaxValue = kEnrResponse, }; } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/discovery.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "discovery.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include "enr/enr_request_handler.hpp" #include "enr/fetch_enr_record.hpp" #include "find/find_node_handler.hpp" #include "find/lookup.hpp" #include "message_handler.hpp" #include "ping/ping_check.hpp" #include "ping/ping_handler.hpp" #include "server.hpp" namespace silkworm::sentry::discovery::disc_v4 { class DiscoveryImpl : private MessageHandler { public: DiscoveryImpl( const boost::asio::any_io_executor& executor, uint16_t server_port, std::function node_key, // NOLINT(performance-unnecessary-value-param) std::function node_url, std::function node_record, node_db::NodeDb& node_db) : node_id_([node_key]() { return node_key().public_key(); }), node_url_(std::move(node_url)), node_record_(std::move(node_record)), node_db_(node_db), server_(executor, server_port, node_key, *this), ping_checks_semaphore_(executor, kPingChecksTasksMax), ping_checks_tasks_(executor, kPingChecksTasksMax), discovered_event_notifier_(executor), discover_more_needed_notifier_(executor) {} ~DiscoveryImpl() override = default; DiscoveryImpl(const DiscoveryImpl&) = delete; DiscoveryImpl& operator=(const DiscoveryImpl&) = delete; Task run() { using namespace concurrency::awaitable_wait_for_all; server_.setup(); try { co_await (server_.run() && discover_more() && ping_checks() && ping_checks_tasks_.wait()); } catch (const boost::system::system_error& ex) { SILK_ERROR_M("sentry") << "DiscoveryImpl::run ex=" << ex.what(); if (ex.code() == boost::system::errc::operation_canceled) { // TODO(canepat) demote to debug after https://github.com/erigontech/silkworm/issues/2333 is solved SILK_WARN_M("sentry") << "DiscoveryImpl::run operation_canceled"; } throw; } } void discover_more_needed() { discover_more_needed_notifier_.notify(); } private: uint64_t local_enr_seq_num() const { return this->node_record_().seq_num; } Task on_find_node(find::FindNodeMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint) override { return find::FindNodeHandler::handle(std::move(message), std::move(sender_public_key), std::move(sender_endpoint), server_, node_db_); } Task on_neighbors(find::NeighborsMessage message, EccPublicKey sender_public_key) override { on_neighbors_signal_(std::move(message), std::move(sender_public_key)); co_return; } Task on_ping(ping::PingMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes ping_packet_hash) override { bool is_new = co_await ping::PingHandler::handle( std::move(message), std::move(sender_public_key), std::move(sender_endpoint), std::move(ping_packet_hash), node_id_(), local_enr_seq_num(), server_, node_db_); if (is_new) { discovered_event_notifier_.notify(); } } Task on_pong(ping::PongMessage message, EccPublicKey sender_public_key) override { on_pong_signal_(std::move(message), std::move(sender_public_key)); co_return; } Task on_enr_request(enr::EnrRequestMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes packet_hash) override { return enr::EnrRequestHandler::handle( message, std::move(sender_public_key), std::move(sender_endpoint), std::move(packet_hash), node_record_(), server_, node_db_); } Task on_enr_response(enr::EnrResponseMessage message) override { on_enr_response_signal_(std::move(message)); co_return; } Task discover_more() { using namespace std::chrono_literals; while (true) { co_await discover_more_needed_notifier_.wait(); auto total_neighbors = co_await find::lookup(node_id_(), server_, on_neighbors_signal_, node_db_); if (total_neighbors == 0) { co_await sleep(10s); discover_more_needed_notifier_.notify(); } else { discovered_event_notifier_.notify(); } } } Task ping_checks() { using namespace std::chrono_literals; using namespace concurrency::awaitable_wait_for_one; auto executor = co_await boost::asio::this_coro::executor; while (true) { auto now = std::chrono::system_clock::now(); auto node_ids = co_await node_db_.find_ping_candidates(now, 10); if (node_ids.empty()) { co_await (sleep(10s) || discovered_event_notifier_.wait()); continue; } for (auto& node_id : node_ids) { // grab the semaphore and block once we reach kPingChecksTasksMax co_await ping_checks_semaphore_.send(node_id.serialized()); ping_checks_tasks_.spawn(executor, [this, node_id = std::move(node_id)]() mutable -> Task { // when a ping check is going to finish, unblock the semaphore [[maybe_unused]] auto _ = gsl::finally([this] { auto finished_task_id = this->ping_checks_semaphore_.try_receive(); SILKWORM_ASSERT(finished_task_id.has_value()); }); co_await this->ping_check(std::move(node_id)); }()); } } } Task ping_check(EccPublicKey node_id) { using namespace std::chrono_literals; auto local_node_url = node_url_(); if (node_id == local_node_url.public_key()) { SILK_WARN_M("sentry") << "disc_v4::DiscoveryImpl::ping_check: " << "ignoring an attempt to ping the local node, " << "please delete it from the NodeDb by node_id=" << node_id.hex(); co_return; } try { auto ping_check_result = co_await ping::ping_check(node_id, local_node_url, local_enr_seq_num(), server_, on_pong_signal_, node_db_); if (ping_check_result.is_skipped()) { co_return; } if (ping_check_result.is_success()) { // wait enough time for "ping back" to happen // so that the remote peer verifies us and accepts our ENR request co_await sleep(1s); auto current_enr_seq_num = co_await node_db_.find_enr_seq_num(node_id); if (current_enr_seq_num != ping_check_result.enr_seq_num) { auto address = co_await node_db_.find_node_address(node_id); if (!address) { throw std::runtime_error("ping_check: node address not found"); } auto endpoint = address->to_common_address().endpoint; auto enr_record = co_await enr::fetch_enr_record(node_id, std::move(endpoint), server_, on_enr_response_signal_); if (enr_record) { co_await node_db_.update_eth1_fork_id(enr_record->public_key, enr_record->eth1_fork_id_data); co_await node_db_.update_enr_seq_num(enr_record->public_key, enr_record->seq_num); } } } co_await ping_check_result.save(node_db_); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_ERROR_M("sentry") << "disc_v4::DiscoveryImpl::ping_check node_id=" << node_id.hex() << " system_error: " << ex.what(); } catch (const std::exception& ex) { SILK_ERROR_M("sentry") << "disc_v4::DiscoveryImpl::ping_check node_id=" << node_id.hex() << " exception: " << ex.what(); } } std::function node_id_; std::function node_url_; std::function node_record_; node_db::NodeDb& node_db_; Server server_; concurrency::Channel ping_checks_semaphore_; concurrency::TaskGroup ping_checks_tasks_; static constexpr size_t kPingChecksTasksMax = 3; concurrency::EventNotifier discovered_event_notifier_; concurrency::EventNotifier discover_more_needed_notifier_; boost::signals2::signal on_neighbors_signal_; boost::signals2::signal on_pong_signal_; boost::signals2::signal on_enr_response_signal_; }; Discovery::Discovery( const boost::asio::any_io_executor& executor, uint16_t server_port, std::function node_key, std::function node_url, std::function node_record, node_db::NodeDb& node_db) : p_impl_(std::make_unique(executor, server_port, std::move(node_key), std::move(node_url), std::move(node_record), node_db)) {} Discovery::~Discovery() { SILK_TRACE_M("sentry") << "silkworm::sentry::discovery::disc_v4::Discovery::~Discovery"; } Task Discovery::run() { return p_impl_->run(); } void Discovery::discover_more_needed() { p_impl_->discover_more_needed(); } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/discovery.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4 { class DiscoveryImpl; class Discovery { public: Discovery( const boost::asio::any_io_executor& executor, uint16_t server_port, std::function node_key, std::function node_url, std::function node_record, node_db::NodeDb& node_db); ~Discovery(); Discovery(const Discovery&) = delete; Discovery& operator=(const Discovery&) = delete; Task run(); void discover_more_needed(); private: std::unique_ptr p_impl_; }; } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/enr_request_handler.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enr_request_handler.hpp" #include #include #include #include #include #include #include "enr_response_message.hpp" namespace silkworm::sentry::discovery::disc_v4::enr { Task EnrRequestHandler::handle( EnrRequestMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes packet_hash, discovery::enr::EnrRecord local_node_record, MessageSender& sender, node_db::NodeDb& db) { if (is_expired_message_expiration(message.expiration)) { co_return; } // check that the sender has a valid pong auto last_pong_time = co_await db.find_last_pong_time(sender_public_key); auto now = std::chrono::system_clock::system_clock::now(); if (!last_pong_time || (*last_pong_time < ping::min_valid_pong_time(now))) { co_return; } auto& recipient = sender_endpoint; EnrResponseMessage response{ std::move(packet_hash), std::move(local_node_record), }; try { co_await sender.send_enr_response(std::move(response), recipient); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_WARN_M("disc_v4") << "EnrRequestHandler::handle failed to reply" << " to " << recipient << " due to exception: " << ex.what(); } } } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/enr_request_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "enr_request_message.hpp" #include "message_sender.hpp" namespace silkworm::sentry::discovery::disc_v4::enr { struct EnrRequestHandler { static Task handle( EnrRequestMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes packet_hash, discovery::enr::EnrRecord local_node_record, MessageSender& sender, node_db::NodeDb& db); }; } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/enr_request_message.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enr_request_message.hpp" #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::enr { const uint8_t EnrRequestMessage::kId = static_cast(PacketType::kEnrRequest); Bytes EnrRequestMessage::rlp_encode() const { Bytes data; auto expiration_ts = unix_timestamp_from_time_point(expiration); rlp::encode(data, std::vector{expiration_ts}); return data; } EnrRequestMessage EnrRequestMessage::rlp_decode(ByteView data) { std::vector expiration_ts; auto result = rlp::decode( data, expiration_ts, rlp::Leftover::kAllow); if (!result && (result.error() != DecodingError::kUnexpectedListElements)) { throw DecodingException(result.error(), "Failed to decode EnrRequestMessage RLP"); } if (expiration_ts.empty()) { throw DecodingException(DecodingError::kUnexpectedListElements, "Failed to decode EnrRequestMessage RLP: no expiration"); } return EnrRequestMessage{ time_point_from_unix_timestamp(expiration_ts[0]), }; } } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/enr_request_message.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include namespace silkworm::sentry::discovery::disc_v4::enr { struct EnrRequestMessage { std::chrono::time_point expiration; Bytes rlp_encode() const; static EnrRequestMessage rlp_decode(ByteView data); static const uint8_t kId; }; } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/enr_response_message.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enr_response_message.hpp" #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::enr { const uint8_t EnrResponseMessage::kId = static_cast(PacketType::kEnrResponse); Bytes EnrResponseMessage::rlp_encode(const EccKeyPair& key_pair) const { Bytes request_hash_rlp_data; rlp::encode(request_hash_rlp_data, request_hash); std::vector items = { rlp::RlpBytes{request_hash_rlp_data}, rlp::RlpBytes{discovery::enr::EnrCodec::encode(record, key_pair)}, }; Bytes data; rlp::encode(data, items); return data; } EnrResponseMessage EnrResponseMessage::rlp_decode(ByteView data) { auto rlp_header = rlp::decode_header(data); if (!rlp_header) throw DecodingException(rlp_header.error(), "Failed to decode EnrResponseMessage RLP header"); if (!rlp_header->list) throw DecodingException(DecodingError::kUnexpectedString, "Failed to decode EnrResponseMessage RLP"); Bytes request_hash; auto request_hash_decode_result = rlp::decode(data, request_hash, rlp::Leftover::kAllow); if (!request_hash_decode_result) throw DecodingException(request_hash_decode_result.error(), "Failed to decode EnrResponseMessage RLP request_hash"); ByteView enr_data = data; auto record = [&enr_data]() -> discovery::enr::EnrRecord { try { return discovery::enr::EnrCodec::decode(enr_data); } catch (const std::runtime_error& ex) { throw DecodeEnrRecordError(ex); } }(); return EnrResponseMessage{ std::move(request_hash), std::move(record), }; } } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/enr_response_message.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::enr { struct EnrResponseMessage { using EnrRecord = discovery::enr::EnrRecord; Bytes request_hash; EnrRecord record; Bytes rlp_encode(const EccKeyPair& key_pair) const; static EnrResponseMessage rlp_decode(ByteView data); static const uint8_t kId; class DecodeEnrRecordError : public std::runtime_error { public: explicit DecodeEnrRecordError(const std::exception& ex) : std::runtime_error(std::string("Failed to decode EnrResponseMessage.record: ") + ex.what()) {} }; }; } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/enr_response_message_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enr_response_message.hpp" #include #include #include namespace silkworm::sentry::discovery::disc_v4::enr { TEST_CASE("EnrResponseMessage.rlp_decode") { auto message = EnrResponseMessage::rlp_decode(*from_hex("f8bda0d9291b8aeb19fc0bd30ee63ddf06a32b3d0d11f960923d7f5f2f2e4bb35ce51df89ab8405ad679e2553358ece5cd4b081032ffb64c52ea354201a354b1354240ad7df6e8571576a6628e1aaa83674e3deacd79a7cf3c459b2467abd133e338351435f0ad6a83657468cac984fc64ec0483118c30826964827634826970847f00000189736563703235366b31a103df05840e8262ca022aaab57ef93233e305181169f7ab3fdb62917756d345a8c98374637082766583756470827665")); auto& record = message.record; CHECK(record.public_key == EccPublicKey::deserialize_hex("df05840e8262ca022aaab57ef93233e305181169f7ab3fdb62917756d345a8c9739cf596254d5075281b7a013b6c6aff9b596830a7bfc24ae85f5d14b6efc545")); CHECK(record.seq_num == 106); REQUIRE(record.address_v4.has_value()); CHECK(record.address_v4->endpoint.address().to_string() == "127.0.0.1"); CHECK(record.address_v4->endpoint.port() == 30309); CHECK(record.address_v4->port_rlpx == 30309); CHECK_FALSE(record.address_v6.has_value()); REQUIRE(record.eth1_fork_id_data.has_value()); ByteView eth1_fork_id_data{*record.eth1_fork_id_data}; CHECK(eth1_fork_id_data.size() == 11); // eth1_fork_id_data is RLP([[hash_u32, next_u64]]) where the outer list has a single item. // It happens because in geth forkid.ID struct is contained within an enrEntry struct (each struct forms a list). // This outer list has an RLP header that decode_header() cuts off. auto eth1_fork_id_data_rlp_header = rlp::decode_header(eth1_fork_id_data); REQUIRE(eth1_fork_id_data_rlp_header.has_value()); CHECK(eth1_fork_id_data_rlp_header->list); CHECK(eth1_fork_id_data_rlp_header->payload_length == 10); // now eth1_fork_id_data is just RLP([hash_u32, next_u64]) uint32_t eth1_fork_id_hash{0}; uint64_t eth1_fork_id_next{0}; auto eth1_fork_id_decode_result = rlp::decode(eth1_fork_id_data, rlp::Leftover::kProhibit, eth1_fork_id_hash, eth1_fork_id_next); CHECK(eth1_fork_id_decode_result.has_value()); if (!eth1_fork_id_decode_result) { FAIL("eth1_fork_id_decode_result.error = " + std::to_string(static_cast(eth1_fork_id_decode_result.error()))); } CHECK(eth1_fork_id_hash == 0xFC64EC04); CHECK(eth1_fork_id_next == 1150000); CHECK_FALSE(record.eth2_fork_id_data.has_value()); CHECK_FALSE(record.eth2_attestation_subnets_data.has_value()); } TEST_CASE("EnrResponseMessage.rlp_decode.big_seq_num") { auto message = EnrResponseMessage::rlp_decode(*from_hex("f8cca0db48c2d9cd569e608d40ebd8cd4dbb7d225de93dcc5366e1385d412feacf8fabf8a9b840e9201a9daeffb557a377c87f15cacd5539a7b764a16e01d610e359d13e5aa29043a7d1e81fcd3e5d62fae96dbb5c167ec3473087161eb0d73e4d5aa36c561f2286017f0e71b3c483657468c7c684dce96c2d8082696482763482697084416c4665836c6573c10189736563703235366b31a1022b252ab6a1d0f971d9722cb839a42cb81db019ba44c08754628ab4a82348707184736e6170c08374637082765f8375647082765f")); auto& record = message.record; CHECK(record.seq_num == 1645214806980); REQUIRE(record.address_v4.has_value()); CHECK(record.address_v4->endpoint.address().to_string() == "65.108.70.101"); CHECK(record.address_v4->endpoint.port() == 30303); CHECK(record.address_v4->port_rlpx == 30303); } } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/fetch_enr_record.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "fetch_enr_record.hpp" #include #include #include #include #include #include #include #include #include #include #include "enr_request_message.hpp" namespace silkworm::sentry::discovery::disc_v4::enr { Task> fetch_enr_record( EccPublicKey node_id, boost::asio::ip::udp::endpoint endpoint, MessageSender& message_sender, boost::signals2::signal& on_enr_response_signal) { using namespace std::chrono_literals; using namespace concurrency::awaitable_wait_for_one; auto executor = co_await boost::asio::this_coro::executor; concurrency::Channel> response_channel{executor, 1}; auto on_enr_response_handler = [&](EnrResponseMessage message) { if (message.record.public_key == node_id) { response_channel.try_send(std::move(message.record)); } }; [[maybe_unused]] boost::signals2::scoped_connection subscription(on_enr_response_signal.connect(on_enr_response_handler)); EnrRequestMessage request_message{ make_message_expiration(), }; try { co_await message_sender.send_enr_request(request_message, endpoint); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_DEBUG_M("disc_v4") << "fetch_enr_record failed to send_enr_request" << " to " << endpoint << " due to exception: " << ex.what(); co_return std::nullopt; } try { auto record = std::get<0>(co_await (response_channel.receive() || concurrency::timeout(500ms))); co_return record; } catch (const concurrency::TimeoutExpiredError&) { co_return std::nullopt; } } } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/fetch_enr_record.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "enr_response_message.hpp" #include "message_sender.hpp" namespace silkworm::sentry::discovery::disc_v4::enr { Task> fetch_enr_record( EccPublicKey node_id, boost::asio::ip::udp::endpoint endpoint, MessageSender& message_sender, boost::signals2::signal& on_enr_response_signal); } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/message_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "enr_request_message.hpp" #include "enr_response_message.hpp" namespace silkworm::sentry::discovery::disc_v4::enr { struct MessageHandler { virtual ~MessageHandler() = default; virtual Task on_enr_request( EnrRequestMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes packet_hash) = 0; virtual Task on_enr_response(EnrResponseMessage message) = 0; }; } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/enr/message_sender.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "enr_request_message.hpp" #include "enr_response_message.hpp" namespace silkworm::sentry::discovery::disc_v4::enr { struct MessageSender { virtual ~MessageSender() = default; virtual Task send_enr_request(EnrRequestMessage message, boost::asio::ip::udp::endpoint recipient) = 0; virtual Task send_enr_response(EnrResponseMessage message, boost::asio::ip::udp::endpoint recipient) = 0; }; } // namespace silkworm::sentry::discovery::disc_v4::enr ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/find_neighbors.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "find_neighbors.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::find { Task find_neighbors( EccPublicKey node_id, EccPublicKey local_node_id, MessageSender& message_sender, boost::signals2::signal& on_neighbors_signal, node_db::NodeDb& db) { using namespace std::chrono_literals; using namespace concurrency::awaitable_wait_for_one; auto address = co_await db.find_node_address(node_id); if (!address) { throw std::runtime_error("find_neighbors: node address not found"); } auto endpoint = address->to_common_address().endpoint; auto executor = co_await boost::asio::this_coro::executor; concurrency::Channel> neighbors_channel{executor, 2}; auto on_neighbors_handler = [&](NeighborsMessage message, const EccPublicKey& sender_node_id) { if ((sender_node_id == node_id) && !is_expired_message_expiration(message.expiration)) { neighbors_channel.try_send(std::move(message.node_addresses)); } }; boost::signals2::scoped_connection neighbors_subscription(on_neighbors_signal.connect(on_neighbors_handler)); FindNodeMessage find_node_message{ local_node_id, make_message_expiration(), }; try { co_await message_sender.send_find_node(std::move(find_node_message), endpoint); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_DEBUG_M("disc_v4") << "find_neighbors failed to send_find_node" << " to " << endpoint << " due to exception: " << ex.what(); co_return 0; } std::map neighbors_node_addresses; try { neighbors_node_addresses = std::get<0>(co_await (neighbors_channel.receive() || concurrency::timeout(500ms))); } catch (const concurrency::TimeoutExpiredError&) { co_return 0; } for (auto& [neighbor_id, neighbor_node_address] : neighbors_node_addresses) { auto ip = neighbor_node_address.endpoint.address(); if (ip_classify(ip) != IpAddressType::kRegular) { continue; } if (neighbor_id == local_node_id) { continue; } auto distance = node_distance(neighbor_id, local_node_id); co_await db.upsert_node_address(neighbor_id, neighbor_node_address); co_await db.update_distance(neighbor_id, distance); } co_return neighbors_node_addresses.size(); } } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/find_neighbors.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include "message_sender.hpp" #include "neighbors_message.hpp" namespace silkworm::sentry::discovery::disc_v4::find { Task find_neighbors( EccPublicKey node_id, EccPublicKey local_node_id, MessageSender& message_sender, boost::signals2::signal& on_neighbors_signal, node_db::NodeDb& db); } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/find_node_handler.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "find_node_handler.hpp" #include #include #include #include #include #include #include #include #include #include "neighbors_message.hpp" namespace silkworm::sentry::discovery::disc_v4::find { Task FindNodeHandler::handle( FindNodeMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, MessageSender& sender, node_db::NodeDb& db) { if (is_expired_message_expiration(message.expiration)) { co_return; } // check that the sender has a valid pong auto last_pong_time = co_await db.find_last_pong_time(sender_public_key); auto now = std::chrono::system_clock::system_clock::now(); if (!last_pong_time || (*last_pong_time < ping::min_valid_pong_time(now))) { co_return; } // find a bunch of nodes to choose from sorted by distance to the target_public_key std::multimap node_ids_by_distance; for (auto& node_id : co_await db.find_useful_nodes(ping::min_valid_pong_time(now), 100)) { auto distance = node_distance(message.target_public_key, node_id); node_ids_by_distance.insert({distance, node_id}); } // collect several nodes closest to the target_public_key std::vector node_ids; for (auto& entry : node_ids_by_distance) { node_ids.push_back(entry.second); if (node_ids.size() >= 12) break; } // find addresses std::map node_addresses; for (auto& node_id : node_ids) { auto address = co_await db.find_node_address(node_id); if (address) { node_addresses.insert({node_id, address->to_common_address()}); } } auto& recipient = sender_endpoint; NeighborsMessage neighbors{ std::move(node_addresses), make_message_expiration(), }; try { co_await sender.send_neighbors(std::move(neighbors), recipient); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_WARN_M("disc_v4") << "FindNodeHandler::handle failed to reply" << " to " << recipient << " due to exception: " << ex.what(); } } } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/find_node_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "find_node_message.hpp" #include "message_sender.hpp" namespace silkworm::sentry::discovery::disc_v4::find { struct FindNodeHandler { static Task handle( FindNodeMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, MessageSender& sender, node_db::NodeDb& db); }; } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/find_node_message.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "find_node_message.hpp" #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::find { const uint8_t FindNodeMessage::kId = static_cast(PacketType::kFindNode); Bytes FindNodeMessage::rlp_encode() const { Bytes data; auto expiration_ts = unix_timestamp_from_time_point(expiration); rlp::encode(data, target_public_key.serialized(), expiration_ts); return data; } FindNodeMessage FindNodeMessage::rlp_decode(ByteView data) { Bytes target_public_key_data; uint64_t expiration_ts{0}; auto result = rlp::decode( data, rlp::Leftover::kAllow, target_public_key_data, expiration_ts); if (!result && (result.error() != DecodingError::kUnexpectedListElements)) { throw DecodingException(result.error(), "Failed to decode FindNodeMessage RLP"); } auto target_public_key = [&target_public_key_data]() -> EccPublicKey { try { return EccPublicKey::deserialize(target_public_key_data); } catch (const std::runtime_error& ex) { throw DecodeTargetPublicKeyError(ex); } }(); return FindNodeMessage{ std::move(target_public_key), time_point_from_unix_timestamp(expiration_ts), }; } } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/find_node_message.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::find { struct FindNodeMessage { EccPublicKey target_public_key; std::chrono::time_point expiration; Bytes rlp_encode() const; static FindNodeMessage rlp_decode(ByteView data); static const uint8_t kId; class DecodeTargetPublicKeyError : public std::runtime_error { public: explicit DecodeTargetPublicKeyError(const std::exception& ex) : std::runtime_error(std::string("Failed to decode FindNodeMessage.target_public_key: ") + ex.what()) {} }; }; } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/lookup.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "lookup.hpp" #include #include #include #include #include #include #include #include #include "find_neighbors.hpp" namespace silkworm::sentry::discovery::disc_v4::find { Task lookup( EccPublicKey local_node_id, MessageSender& message_sender, boost::signals2::signal& on_neighbors_signal, node_db::NodeDb& db) { using namespace std::chrono_literals; using namespace concurrency::awaitable_wait_for_one; auto now = std::chrono::system_clock::now(); node_db::NodeDb::FindLookupCandidatesQuery query{ /* min_pong_time = */ ping::min_valid_pong_time(now), /* max_lookup_time = */ now - 10min, /* limit = */ 3, }; auto node_ids = co_await db.take_lookup_candidates(query, now); size_t total_neighbors = 0; auto group_task_factory = [&](size_t index) -> Task { const auto& node_id = node_ids[index]; try { total_neighbors += co_await find_neighbors(node_id, local_node_id, message_sender, on_neighbors_signal, db); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_ERROR_M("sentry") << "disc_v4::find::lookup find_neighbors node_id=" << node_id.hex() << " system_error: " << ex.what(); } catch (const std::exception& ex) { SILK_ERROR_M("sentry") << "disc_v4::find::lookup find_neighbors node_id=" << node_id.hex() << " exception: " << ex.what(); } }; auto group_task = concurrency::generate_parallel_group_task(node_ids.size(), group_task_factory); try { co_await (std::move(group_task) || concurrency::timeout(1s)); } catch (const concurrency::TimeoutExpiredError&) { } co_return total_neighbors; } } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/lookup.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "message_sender.hpp" #include "neighbors_message.hpp" namespace silkworm::sentry::discovery::disc_v4::find { Task lookup( EccPublicKey local_node_id, MessageSender& message_sender, boost::signals2::signal& on_neighbors_signal, node_db::NodeDb& db); } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/message_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "find_node_message.hpp" #include "neighbors_message.hpp" namespace silkworm::sentry::discovery::disc_v4::find { struct MessageHandler { virtual ~MessageHandler() = default; virtual Task on_find_node(FindNodeMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint) = 0; virtual Task on_neighbors(NeighborsMessage message, EccPublicKey sender_public_key) = 0; }; } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/message_sender.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "find_node_message.hpp" #include "neighbors_message.hpp" namespace silkworm::sentry::discovery::disc_v4::find { struct MessageSender { virtual ~MessageSender() = default; virtual Task send_find_node(find::FindNodeMessage message, boost::asio::ip::udp::endpoint recipient) = 0; virtual Task send_neighbors(find::NeighborsMessage message, boost::asio::ip::udp::endpoint recipient) = 0; }; } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/neighbors_message.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "neighbors_message.hpp" #include #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::find { const uint8_t NeighborsMessage::kId = static_cast(PacketType::kNeighbors); struct NeighborsNodeInfo { NodeAddress address; EccPublicKey public_key{Bytes{}}; }; //! RLP length of NeighborsNodeInfo size_t length(const NeighborsNodeInfo& info) { auto& address = info.address; return rlp::length(ip_address_to_bytes(address.endpoint.address()), address.endpoint.port(), address.port_rlpx, info.public_key.serialized()); } //! RLP encode NeighborsNodeInfo void encode(Bytes& to, const NeighborsNodeInfo& info) { auto& address = info.address; rlp::encode(to, ip_address_to_bytes(address.endpoint.address()), address.endpoint.port(), address.port_rlpx, info.public_key.serialized()); } //! RLP decode NeighborsNodeInfo DecodingResult decode(ByteView& from, NeighborsNodeInfo& to, rlp::Leftover mode) noexcept { Bytes ip_bytes; uint16_t port{0}; Bytes public_key_data; auto result = rlp::decode(from, mode, ip_bytes, port, to.address.port_rlpx, public_key_data); if (!result) { return result; } auto ip = ip_address_from_bytes(ip_bytes); if (!ip) { return tl::unexpected{DecodingError::kUnexpectedString}; } to.address.endpoint = boost::asio::ip::udp::endpoint(*ip, port); try { to.public_key = EccPublicKey::deserialize(public_key_data); } catch (const std::runtime_error&) { return tl::unexpected{DecodingError::kUnexpectedString}; } return result; } Bytes NeighborsMessage::rlp_encode() const { std::vector node_infos; node_infos.reserve(node_addresses.size()); for (const auto& [public_key, address] : node_addresses) { node_infos.push_back({address, public_key}); } auto expiration_ts = unix_timestamp_from_time_point(expiration); Bytes data; rlp::encode(data, node_infos, expiration_ts); return data; } NeighborsMessage NeighborsMessage::rlp_decode(ByteView data) { std::vector node_infos; uint64_t expiration_ts{0}; auto result = rlp::decode( data, rlp::Leftover::kAllow, node_infos, expiration_ts); if (!result && (result.error() != DecodingError::kUnexpectedListElements)) { throw DecodingException(result.error(), "Failed to decode NeighborsMessage RLP"); } std::map node_addresses; for (auto& info : node_infos) { node_addresses[info.public_key] = info.address; } return NeighborsMessage{ std::move(node_addresses), time_point_from_unix_timestamp(expiration_ts), }; } } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/find/neighbors_message.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::find { struct NeighborsMessage { std::map node_addresses; std::chrono::time_point expiration; Bytes rlp_encode() const; static NeighborsMessage rlp_decode(ByteView data); static const uint8_t kId; }; } // namespace silkworm::sentry::discovery::disc_v4::find ================================================ FILE: silkworm/sentry/discovery/disc_v4/message_codec.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "message_codec.hpp" #include #include #include #include #include #include #include "common/packet_type.hpp" namespace silkworm::sentry::discovery::disc_v4 { #pragma pack(push) #pragma pack(1) struct Packet { uint8_t hash[32]{}; uint8_t signature[65]{}; uint8_t type{}; uint8_t data[1]{}; }; #pragma pack(pop) using namespace crypto; Bytes MessageCodec::encode(const Message& message, ByteView private_key) { Bytes packet_data(sizeof(Packet) + message.data.size() - 1, 0); auto packet = reinterpret_cast(packet_data.data()); packet->type = message.id; memcpy(packet->data, message.data.data(), message.data.size()); auto type_and_data_hash = keccak256(ByteView(packet_data).substr(offsetof(Packet, type))); Bytes signature = ecdsa_signature::sign_recoverable(ByteView(type_and_data_hash.bytes), private_key); memcpy(packet->signature, signature.data(), signature.size()); auto hash = keccak256(ByteView(packet_data).substr(offsetof(Packet, signature))); memcpy(packet->hash, hash.bytes, sizeof(hash.bytes)); return packet_data; } ByteView MessageCodec::encoded_packet_hash(ByteView packet_data) { SILKWORM_ASSERT(packet_data.size() >= sizeof(Packet)); return packet_data.substr(0, sizeof(Packet{}.hash)); } MessageEnvelope MessageCodec::decode(ByteView packet_data) { if (packet_data.size() < sizeof(Packet)) throw std::runtime_error("MessageCodec: packet is too small"); if (packet_data.size() > 1280) throw std::runtime_error("MessageCodec: packet is too big"); auto packet = reinterpret_cast(packet_data.data()); if ((packet->type == 0) || (packet->type > static_cast(PacketType::kMaxValue))) throw std::runtime_error("MessageCodec: invalid type"); auto expected_hash = keccak256(packet_data.substr(offsetof(Packet, signature))); if (ByteView(packet->hash) != ByteView(expected_hash.bytes)) throw std::runtime_error("MessageCodec: invalid hash"); auto type_and_data_hash = keccak256(packet_data.substr(offsetof(Packet, type))); auto public_key = ecdsa_signature::verify_and_recover( ByteView(type_and_data_hash.bytes), ByteView(packet->signature)); Message message{ packet->type, Bytes(packet_data.substr(offsetof(Packet, data))), }; return MessageEnvelope{ std::move(message), std::move(public_key), Bytes(packet->hash, sizeof(packet->hash)), }; } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/message_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include namespace silkworm::sentry::discovery::disc_v4 { struct MessageEnvelope { Message message; EccPublicKey public_key; Bytes packet_hash; }; struct MessageCodec { static Bytes encode(const Message& message, ByteView private_key); static ByteView encoded_packet_hash(ByteView packet_data); static MessageEnvelope decode(ByteView packet_data); }; } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/message_codec_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "message_codec.hpp" #include #include #include #include #include #include #include #include "common/packet_type.hpp" #include "find/find_node_message.hpp" #include "find/neighbors_message.hpp" #include "ping/ping_message.hpp" namespace silkworm::sentry::discovery::disc_v4 { using namespace boost::asio::ip; static EccKeyPair test_key_pair() { constexpr std::string_view kPrivateKey = "b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291"; return EccKeyPair{from_hex(kPrivateKey).value()}; } TEST_CASE("MessageCodec.ping_encode_and_decode") { EccKeyPair key_pair = test_key_pair(); ping::PingMessage expected_ping_message{ udp::endpoint{make_address("10.0.0.1"), 100}, 101, udp::endpoint{make_address("10.0.0.2"), 200}, std::chrono::system_clock::now(), 123, }; Message expected_message{static_cast(PacketType::kPing), expected_ping_message.rlp_encode()}; Bytes expected_message_data = MessageCodec::encode(expected_message, key_pair.private_key()); auto [decoded_message, decoded_public_key, decoded_packet_hash] = MessageCodec::decode(expected_message_data); CHECK(static_cast(decoded_message.id) == PacketType::kPing); CHECK(decoded_message.data == expected_message.data); CHECK(decoded_public_key == key_pair.public_key()); CHECK(decoded_packet_hash.size() == 32); CHECK(decoded_packet_hash == MessageCodec::encoded_packet_hash(expected_message_data)); auto decoded_ping_message = ping::PingMessage::rlp_decode(decoded_message.data); CHECK(decoded_ping_message.sender_endpoint == expected_ping_message.sender_endpoint); CHECK(decoded_ping_message.sender_port_rlpx == expected_ping_message.sender_port_rlpx); CHECK(decoded_ping_message.recipient_endpoint == expected_ping_message.recipient_endpoint); CHECK(std::chrono::duration_cast(decoded_ping_message.expiration - expected_ping_message.expiration).count() == 0); CHECK(decoded_ping_message.enr_seq_num == expected_ping_message.enr_seq_num); } TEST_CASE("MessageCodec.ping_decode") { Bytes data = from_hex("71dbda3a79554728d4f94411e42ee1f8b0d561c10e1e5f5893367948c6a7d70bb87b235fa28a77070271b6c164a2dce8c7e13a5739b53b5e96f2e5acb0e458a02902f5965d55ecbeb2ebb6cabb8b2b232896a36b737666c55265ad0a68412f250001ea04cb847f000001820cfa8215a8d790000000000000000000000000000000018208ae820d058443b9a355").value(); auto [decoded_message, decoded_public_key, decoded_packet_hash] = MessageCodec::decode(data); CHECK(static_cast(decoded_message.id) == PacketType::kPing); CHECK(decoded_public_key == test_key_pair().public_key()); auto decoded_ping_message = ping::PingMessage::rlp_decode(decoded_message.data); CHECK(decoded_ping_message.sender_endpoint.address().to_string() == "127.0.0.1"); CHECK(decoded_ping_message.sender_endpoint.port() == 3322); CHECK(decoded_ping_message.sender_port_rlpx == 5544); CHECK(decoded_ping_message.recipient_endpoint.address().to_string() == "::1"); CHECK(decoded_ping_message.recipient_endpoint.port() == 2222); CHECK(decoded_ping_message.expiration == time_point_from_unix_timestamp(1136239445)); } TEST_CASE("MessageCodec.find_node_decode") { Bytes data = from_hex("c7c44041b9f7c7e41934417ebac9a8e1a4c6298f74553f2fcfdcae6ed6fe53163eb3d2b52e39fe91831b8a927bf4fc222c3902202027e5e9eb812195f95d20061ef5cd31d502e47ecb61183f74a504fe04c51e73df81f25c4d506b26db4517490103f84eb840ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31387574077f301b421bc84df7266c44e9e6d569fc56be00812904767bf5ccd1fc7f8443b9a35582999983999999280dc62cc8255c73471e0a61da0c89acdc0e035e260add7fc0c04ad9ebf3919644c91cb247affc82b69bd2ca235c71eab8e49737c937a2c396").value(); auto [decoded_message, decoded_public_key, decoded_packet_hash] = MessageCodec::decode(data); CHECK(static_cast(decoded_message.id) == PacketType::kFindNode); CHECK(decoded_public_key == test_key_pair().public_key()); auto find_node_message = find::FindNodeMessage::rlp_decode(decoded_message.data); CHECK(find_node_message.target_public_key.hex() == "ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31387574077f301b421bc84df7266c44e9e6d569fc56be00812904767bf5ccd1fc7f"); CHECK(find_node_message.expiration == time_point_from_unix_timestamp(1136239445)); } TEST_CASE("MessageCodec.neighbors_decode") { Bytes data = from_hex("c679fc8fe0b8b12f06577f2e802d34f6fa257e6137a995f6f4cbfc9ee50ed3710faf6e66f932c4c8d81d64343f429651328758b47d3dbc02c4042f0fff6946a50f4a49037a72bb550f3a7872363a83e1b9ee6469856c24eb4ef80b7535bcf99c0004f9015bf90150f84d846321163782115c82115db8403155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32f84984010203040101b840312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069dbf8599020010db83c4d001500000000abcdef12820d05820d05b84038643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aacf8599020010db885a308d313198a2e037073488203e78203e8b8408dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df738443b9a355010203b525a138aa34383fec3d2719a0").value(); auto [decoded_message, decoded_public_key, decoded_packet_hash] = MessageCodec::decode(data); CHECK(static_cast(decoded_message.id) == PacketType::kNeighbors); CHECK(decoded_public_key == test_key_pair().public_key()); auto neighbors_message = find::NeighborsMessage::rlp_decode(decoded_message.data); CHECK(neighbors_message.expiration == time_point_from_unix_timestamp(1136239445)); CHECK(neighbors_message.node_addresses.size() == 4); std::map expected_nodes = { { "3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32", NodeAddress{ udp::endpoint{make_address("99.33.22.55"), 4444}, 4445, }, }, { "312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db", NodeAddress{ udp::endpoint{make_address("1.2.3.4"), 1}, 1, }, }, { "38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac", NodeAddress{ udp::endpoint{make_address("2001:db8:3c4d:15::abcd:ef12"), 3333}, 3333, }, }, { "8dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df73", NodeAddress{ udp::endpoint{make_address("2001:db8:85a3:8d3:1319:8a2e:370:7348"), 999}, 1000, }, }, }; for (const auto& [expected_public_key_hex, expected_address] : expected_nodes) { auto expected_public_key = EccPublicKey::deserialize_hex(expected_public_key_hex); REQUIRE(neighbors_message.node_addresses.count(expected_public_key)); auto& address = neighbors_message.node_addresses[expected_public_key]; CHECK(address.endpoint == expected_address.endpoint); CHECK(address.port_rlpx == expected_address.port_rlpx); } } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/message_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "enr/message_handler.hpp" #include "find/message_handler.hpp" #include "ping/message_handler.hpp" namespace silkworm::sentry::discovery::disc_v4 { struct MessageHandler : ping::MessageHandler, enr::MessageHandler, find::MessageHandler { }; } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/message_sender.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include "enr/message_sender.hpp" #include "find/message_sender.hpp" #include "ping/message_sender.hpp" namespace silkworm::sentry::discovery::disc_v4 { struct MessageSender : ping::MessageSender, enr::MessageSender, find::MessageSender { }; } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/message_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include "ping_message.hpp" #include "pong_message.hpp" namespace silkworm::sentry::discovery::disc_v4::ping { struct MessageHandler { virtual ~MessageHandler() = default; virtual Task on_ping(PingMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes ping_packet_hash) = 0; virtual Task on_pong(PongMessage message, EccPublicKey sender_public_key) = 0; }; } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/message_sender.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "ping_message.hpp" #include "pong_message.hpp" namespace silkworm::sentry::discovery::disc_v4::ping { struct MessageSender { virtual ~MessageSender() = default; virtual Task send_ping(ping::PingMessage message, boost::asio::ip::udp::endpoint recipient) = 0; virtual Task send_pong(ping::PongMessage message, boost::asio::ip::udp::endpoint recipient) = 0; }; } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/ping_check.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ping_check.hpp" #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::ping { static constexpr std::chrono::hours kPongValidityPeriod{24}; static std::chrono::time_point pong_expiration(std::chrono::time_point last_pong_time) { return last_pong_time + kPongValidityPeriod; } std::chrono::time_point min_valid_pong_time(std::chrono::time_point now) { return now - kPongValidityPeriod; } static std::chrono::minutes next_ping_delay(size_t ping_fails) { using namespace std::chrono_literals; if (ping_fails < 3) return 10min; // back off: double for each next retry return std::chrono::hours(1 << (ping_fails - 3)); } static std::chrono::time_point next_ping_time(std::chrono::time_point now, size_t ping_fails) { return now + next_ping_delay(ping_fails); } Task ping_check( EccPublicKey node_id, EnodeUrl local_node_url, uint64_t local_enr_seq_num, MessageSender& message_sender, boost::signals2::signal& on_pong_signal, node_db::NodeDb& db) { auto address = co_await db.find_node_address(node_id); if (!address) { throw std::runtime_error("ping_check: node address not found"); } auto endpoint = address->to_common_address().endpoint; auto last_pong_time = co_await db.find_last_pong_time(node_id); auto ping_fails_count = co_await db.find_ping_fails(node_id); auto result = co_await ping_check( std::move(node_id), std::move(endpoint), std::move(local_node_url), local_enr_seq_num, message_sender, on_pong_signal, last_pong_time, ping_fails_count.value_or(0)); co_return result; } Task PingCheckResult::save(node_db::NodeDb& db) const { auto& result = *this; if (result.ping_fails_count) co_await db.update_ping_fails(node_id, *result.ping_fails_count); if (result.next_ping_time) co_await db.update_next_ping_time(node_id, *result.next_ping_time); if (result.pong_time) co_await db.update_last_pong_time(node_id, *result.pong_time); } Task ping_check( EccPublicKey node_id, boost::asio::ip::udp::endpoint endpoint, EnodeUrl local_node_url, uint64_t local_enr_seq_num, MessageSender& message_sender, boost::signals2::signal& on_pong_signal, std::optional> last_pong_time, size_t prev_ping_fails_count) { using namespace std::chrono_literals; using namespace concurrency::awaitable_wait_for_one; if (node_id == local_node_url.public_key()) { SILKWORM_ASSERT(false); co_return PingCheckResult{std::move(node_id)}; } if (last_pong_time && !is_time_in_past(pong_expiration(*last_pong_time))) { co_return PingCheckResult{std::move(node_id)}; } auto executor = co_await boost::asio::this_coro::executor; concurrency::EventNotifier pong_received_notifier{executor}; std::optional enr_seq_num; auto on_pong_handler = [&](const PongMessage& message, const EccPublicKey& sender_node_id) { if ((sender_node_id == node_id) && !is_expired_message_expiration(message.expiration)) { enr_seq_num = message.enr_seq_num; pong_received_notifier.notify(); } }; [[maybe_unused]] boost::signals2::scoped_connection pong_subscription(on_pong_signal.connect(on_pong_handler)); PingMessage ping_message{ boost::asio::ip::udp::endpoint{local_node_url.ip(), local_node_url.port_disc()}, local_node_url.port_rlpx(), endpoint, make_message_expiration(), local_enr_seq_num, }; try { co_await message_sender.send_ping(std::move(ping_message), endpoint); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_DEBUG_M("disc_v4") << "ping_check failed to send_ping" << " to " << endpoint << " due to exception: " << ex.what(); } catch (const IPV6UnsupportedError& ex) { SILK_DEBUG_M("disc_v4") << "ping_check failed to send_ping" << " to " << endpoint << " due to exception: " << ex.what(); } bool is_pong_received = false; try { co_await (pong_received_notifier.wait() || concurrency::timeout(500ms)); is_pong_received = true; } catch (const concurrency::TimeoutExpiredError&) { } auto now = std::chrono::system_clock::now(); auto pong_time = is_pong_received ? std::optional{now} : std::nullopt; size_t ping_fails_count = is_pong_received ? 0 : prev_ping_fails_count + 1; auto next_ping_time1 = next_ping_time(now, ping_fails_count); co_return PingCheckResult{ std::move(node_id), pong_time, ping_fails_count, next_ping_time1, enr_seq_num, }; } } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/ping_check.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include "message_sender.hpp" #include "pong_message.hpp" namespace silkworm::sentry::discovery::disc_v4::ping { struct PingCheckResult { EccPublicKey node_id; std::optional> pong_time; std::optional ping_fails_count; std::optional> next_ping_time; std::optional enr_seq_num; Task save(node_db::NodeDb& db) const; bool is_skipped() const { return !next_ping_time.has_value(); } bool is_success() const { return pong_time.has_value(); } }; Task ping_check( EccPublicKey node_id, EnodeUrl local_node_url, uint64_t local_enr_seq_num, MessageSender& message_sender, boost::signals2::signal& on_pong_signal, node_db::NodeDb& db); Task ping_check( EccPublicKey node_id, boost::asio::ip::udp::endpoint endpoint, EnodeUrl local_node_url, uint64_t local_enr_seq_num, MessageSender& message_sender, boost::signals2::signal& on_pong_signal, std::optional> last_pong_time, size_t prev_ping_fails_count); std::chrono::time_point min_valid_pong_time( std::chrono::time_point now); } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/ping_handler.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ping_handler.hpp" #include #include #include #include #include #include "pong_message.hpp" namespace silkworm::sentry::discovery::disc_v4::ping { Task PingHandler::handle( PingMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes ping_packet_hash, EccPublicKey local_node_id, uint64_t local_enr_seq_num, MessageSender& sender, node_db::NodeDb& db) { if (is_expired_message_expiration(message.expiration)) { co_return false; } auto& recipient = sender_endpoint; PongMessage pong{ recipient, ping_packet_hash, make_message_expiration(), local_enr_seq_num, }; try { co_await sender.send_pong(std::move(pong), recipient); } catch (const boost::system::system_error& ex) { if (ex.code() == boost::system::errc::operation_canceled) throw; SILK_WARN_M("disc_v4") << "PingHandler::handle failed to reply" << " to " << recipient << " due to exception: " << ex.what(); co_return false; } // in misconfigured systems we might receive a ping from "ourselves" if (sender_public_key == local_node_id) { co_return false; } // save a ping sender node as if it was discovered by find_neighbors() bool is_inserted = co_await db.upsert_node_address(sender_public_key, message.sender_node_address()); if (is_inserted) { co_await db.update_distance(sender_public_key, node_distance(sender_public_key, local_node_id)); } co_return is_inserted; } } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/ping_handler.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "message_sender.hpp" #include "ping_message.hpp" namespace silkworm::sentry::discovery::disc_v4::ping { struct PingHandler { static Task handle( PingMessage message, EccPublicKey sender_public_key, boost::asio::ip::udp::endpoint sender_endpoint, Bytes ping_packet_hash, EccPublicKey local_node_id, uint64_t local_enr_seq_num, MessageSender& sender, node_db::NodeDb& db); }; } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/ping_message.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "ping_message.hpp" #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::ping { const uint8_t PingMessage::kId = static_cast(PacketType::kPing); Bytes PingMessage::rlp_encode() const { Bytes data; constexpr int kDiscVersion = 4; NodeAddress sender_address{sender_endpoint, sender_port_rlpx}; NodeAddress recipient_address{recipient_endpoint, 0}; auto expiration_ts = unix_timestamp_from_time_point(expiration); auto enr_seq_num_value = enr_seq_num ? *enr_seq_num : 0; rlp::encode(data, kDiscVersion, sender_address, recipient_address, expiration_ts, enr_seq_num_value); return data; } PingMessage PingMessage::rlp_decode(ByteView data) { unsigned int disc_version{0}; NodeAddress sender_address; NodeAddress recipient_address; uint64_t expiration_ts{0}; std::optional enr_seq_num_opt; auto result = rlp::decode( data, rlp::Leftover::kAllow, disc_version, sender_address, recipient_address, expiration_ts); if (!result && (result.error() != DecodingError::kUnexpectedListElements)) { throw DecodingException(result.error(), "Failed to decode PingMessage RLP"); } uint64_t enr_seq_num{0}; if (rlp::decode(data, enr_seq_num)) { enr_seq_num_opt = enr_seq_num; } return PingMessage{ std::move(sender_address.endpoint), sender_address.port_rlpx, std::move(recipient_address.endpoint), time_point_from_unix_timestamp(expiration_ts), enr_seq_num_opt, }; } } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/ping_message.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::ping { struct PingMessage { boost::asio::ip::udp::endpoint sender_endpoint; uint16_t sender_port_rlpx{}; boost::asio::ip::udp::endpoint recipient_endpoint; std::chrono::time_point expiration; std::optional enr_seq_num; Bytes rlp_encode() const; static PingMessage rlp_decode(ByteView data); NodeAddress sender_node_address() const { return {sender_endpoint, sender_port_rlpx}; }; static const uint8_t kId; }; } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/pong_message.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "pong_message.hpp" #include #include #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::ping { const uint8_t PongMessage::kId = static_cast(PacketType::kPong); Bytes PongMessage::rlp_encode() const { Bytes data; NodeAddress recipient_address{recipient_endpoint, 0}; auto expiration_ts = unix_timestamp_from_time_point(expiration); auto enr_seq_num_value = enr_seq_num ? *enr_seq_num : 0; rlp::encode(data, recipient_address, ping_hash, expiration_ts, enr_seq_num_value); return data; } PongMessage PongMessage::rlp_decode(ByteView data) { NodeAddress recipient_address; Bytes ping_hash; uint64_t expiration_ts{0}; std::optional enr_seq_num_opt; auto result = rlp::decode( data, rlp::Leftover::kAllow, recipient_address, ping_hash, expiration_ts); if (!result && (result.error() != DecodingError::kUnexpectedListElements)) { throw DecodingException(result.error(), "Failed to decode PingMessage RLP"); } uint64_t enr_seq_num{0}; if (rlp::decode(data, enr_seq_num)) { enr_seq_num_opt = enr_seq_num; } return PongMessage{ std::move(recipient_address.endpoint), std::move(ping_hash), time_point_from_unix_timestamp(expiration_ts), enr_seq_num_opt, }; } } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/ping/pong_message.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::sentry::discovery::disc_v4::ping { struct PongMessage { boost::asio::ip::udp::endpoint recipient_endpoint; Bytes ping_hash; std::chrono::time_point expiration; std::optional enr_seq_num; Bytes rlp_encode() const; static PongMessage rlp_decode(ByteView data); static const uint8_t kId; }; } // namespace silkworm::sentry::discovery::disc_v4::ping ================================================ FILE: silkworm/sentry/discovery/disc_v4/server.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "server.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "common/packet_type.hpp" #include "message_codec.hpp" namespace silkworm::sentry::discovery::disc_v4 { using namespace boost::asio; class ServerImpl { public: explicit ServerImpl( const any_io_executor& executor, uint16_t port, std::function node_key, MessageHandler& handler) : ip_(ip::address{ip::address_v4::any()}), port_(port), socket_(make_socket(executor, listen_endpoint())), node_key_(std::move(node_key)), handler_(handler) {} ServerImpl(const ServerImpl&) = delete; ServerImpl& operator=(const ServerImpl&) = delete; static ip::udp::socket make_socket(const any_io_executor& executor, const ip::udp::endpoint& endpoint) { ip::udp::socket socket{executor, endpoint.protocol()}; socket.set_option(ip::udp::socket::reuse_address(true)); #if defined(_WIN32) // Windows does not have SO_REUSEPORT // see portability notes https://stackoverflow.com/questions/14388706/how-do-so-reuseaddr-and-so-reuseport-differ socket.set_option(detail::socket_option::boolean(true)); #else socket.set_option(detail::socket_option::boolean(true)); #endif return socket; } void setup() { auto endpoint = listen_endpoint(); socket_.bind(endpoint); SILK_INFO_M("sentry") << "disc_v4::Server is listening at " << endpoint; } Task run() { Bytes packet_data_buffer(1280, 0); while (socket_.is_open()) { ip::udp::endpoint sender_endpoint; size_t received_count = co_await socket_.async_receive_from(buffer(packet_data_buffer), sender_endpoint, use_awaitable); ByteView packet_data{packet_data_buffer.data(), received_count}; std::optional envelope; try { envelope = MessageCodec::decode(packet_data); } catch (const std::runtime_error& ex) { SILK_WARN_M("sentry") << "disc_v4::Server received a bad packet from " << sender_endpoint << " : " << ex.what(); continue; } auto packet_type = static_cast(envelope->message.id); ByteView data = envelope->message.data; SILK_TRACE_M("sentry") << "disc_v4::Server received a packet " << static_cast(packet_type); try { switch (packet_type) { case PacketType::kPing: co_await handler_.on_ping( ping::PingMessage::rlp_decode(data), std::move(envelope->public_key), std::move(sender_endpoint), std::move(envelope->packet_hash)); break; case PacketType::kPong: co_await handler_.on_pong( ping::PongMessage::rlp_decode(data), std::move(envelope->public_key)); break; case PacketType::kFindNode: co_await handler_.on_find_node( find::FindNodeMessage::rlp_decode(data), std::move(envelope->public_key), std::move(sender_endpoint)); break; case PacketType::kNeighbors: co_await handler_.on_neighbors( find::NeighborsMessage::rlp_decode(data), std::move(envelope->public_key)); break; case PacketType::kEnrRequest: co_await handler_.on_enr_request( enr::EnrRequestMessage::rlp_decode(data), std::move(envelope->public_key), std::move(sender_endpoint), std::move(envelope->packet_hash)); break; case PacketType::kEnrResponse: co_await handler_.on_enr_response( enr::EnrResponseMessage::rlp_decode(data)); break; } } catch (const find::FindNodeMessage::DecodeTargetPublicKeyError& ex) { SILK_DEBUG_M("sentry") << "disc_v4::Server received a bad message from " << sender_endpoint << " : " << ex.what(); } catch (const enr::EnrResponseMessage::DecodeEnrRecordError& ex) { SILK_DEBUG_M("sentry") << "disc_v4::Server received a bad message from " << sender_endpoint << " : " << ex.what(); } catch (const DecodingException& ex) { SILK_WARN_M("sentry") << "disc_v4::Server received a bad message from " << sender_endpoint << " : " << ex.what(); } } } template Task send_message(const TMessage& message, ip::udp::endpoint recipient) { return send_message(Message{TMessage::kId, message.rlp_encode()}, std::move(recipient)); } template TMessage> Task send_message(const TMessage& message, ip::udp::endpoint recipient) { return send_message(Message{enr::EnrResponseMessage::kId, message.rlp_encode(node_key_())}, std::move(recipient)); } private: ip::udp::endpoint listen_endpoint() const { return ip::udp::endpoint{ip_, port_}; } Task send_message(Message message, ip::udp::endpoint recipient) { auto packet_data = MessageCodec::encode( message, node_key_().private_key()); co_await send_packet(std::move(packet_data), recipient); } Task send_packet(Bytes data, ip::udp::endpoint recipient) { using namespace std::chrono_literals; using namespace concurrency::awaitable_wait_for_one; if (ip_.is_v4() && recipient.address().is_v6()) { throw IPV6UnsupportedError(); } co_await (socket_.async_send_to(buffer(data), recipient, use_awaitable) || concurrency::timeout(1s)); } boost::asio::ip::address ip_; uint16_t port_; ip::udp::socket socket_; std::function node_key_; MessageHandler& handler_; }; Server::Server( const any_io_executor& executor, uint16_t port, std::function node_key, MessageHandler& handler) : p_impl_(std::make_unique(executor, port, std::move(node_key), handler)) {} Server::~Server() { SILK_TRACE_M("sentry") << "silkworm::sentry::discovery::disc_v4::Server::~Server"; } void Server::setup() { p_impl_->setup(); } Task Server::run() { return p_impl_->run(); } Task Server::send_ping(ping::PingMessage message, ip::udp::endpoint recipient) { return p_impl_->send_message(message, std::move(recipient)); } Task Server::send_pong(ping::PongMessage message, ip::udp::endpoint recipient) { return p_impl_->send_message(message, std::move(recipient)); } Task Server::send_find_node(find::FindNodeMessage message, ip::udp::endpoint recipient) { return p_impl_->send_message(message, std::move(recipient)); } Task Server::send_neighbors(find::NeighborsMessage message, ip::udp::endpoint recipient) { return p_impl_->send_message(message, std::move(recipient)); } Task Server::send_enr_request(enr::EnrRequestMessage message, ip::udp::endpoint recipient) { return p_impl_->send_message(message, std::move(recipient)); } Task Server::send_enr_response(enr::EnrResponseMessage message, ip::udp::endpoint recipient) { return p_impl_->send_message(message, std::move(recipient)); } } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/disc_v4/server.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include "message_handler.hpp" #include "message_sender.hpp" namespace silkworm::sentry::discovery::disc_v4 { class ServerImpl; class Server : public MessageSender { public: Server( const boost::asio::any_io_executor& executor, uint16_t port, std::function node_key, MessageHandler& handler); ~Server() override; Server(const Server&) = delete; Server& operator=(const Server&) = delete; void setup(); Task run(); Task send_ping(ping::PingMessage message, boost::asio::ip::udp::endpoint recipient) override; Task send_pong(ping::PongMessage message, boost::asio::ip::udp::endpoint recipient) override; Task send_find_node(find::FindNodeMessage message, boost::asio::ip::udp::endpoint recipient) override; Task send_neighbors(find::NeighborsMessage message, boost::asio::ip::udp::endpoint recipient) override; Task send_enr_request(enr::EnrRequestMessage message, boost::asio::ip::udp::endpoint recipient) override; Task send_enr_response(enr::EnrResponseMessage message, boost::asio::ip::udp::endpoint recipient) override; private: std::unique_ptr p_impl_; }; } // namespace silkworm::sentry::discovery::disc_v4 ================================================ FILE: silkworm/sentry/discovery/discovery.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "discovery.hpp" #include #include #include #include "bootnodes.hpp" #include "common/node_address.hpp" #include "disc_v4/common/node_distance.hpp" #include "disc_v4/discovery.hpp" #include "disc_v4/ping/ping_check.hpp" #include "node_db/node_db_sqlite.hpp" namespace silkworm::sentry::discovery { using namespace boost::asio; class DiscoveryImpl { public: explicit DiscoveryImpl( concurrency::ExecutorPool& executor_pool, std::vector peer_urls, bool with_dynamic_discovery, std::filesystem::path data_dir_path, uint64_t network_id, std::function node_key, std::function node_url, std::function node_record, std::vector bootnodes, uint16_t disc_v4_port); DiscoveryImpl(const DiscoveryImpl&) = delete; DiscoveryImpl& operator=(const DiscoveryImpl&) = delete; Task run(); Task> request_peer_candidates( size_t max_count, std::vector exclude_urls); bool is_static_peer_url(const EnodeUrl& peer_url); Task on_peer_useless(EccPublicKey peer_public_key); Task on_peer_disconnected(EccPublicKey peer_public_key); private: void setup_node_db(); const std::vector peer_urls_; bool with_dynamic_discovery_; std::filesystem::path data_dir_path_; std::function node_id_; uint64_t network_id_; node_db::NodeDbSqlite node_db_; std::vector bootnodes_; disc_v4::Discovery disc_v4_discovery_; }; DiscoveryImpl::DiscoveryImpl( concurrency::ExecutorPool& executor_pool, std::vector peer_urls, bool with_dynamic_discovery, std::filesystem::path data_dir_path, uint64_t network_id, std::function node_key, // NOLINT(performance-unnecessary-value-param) std::function node_url, std::function node_record, std::vector bootnodes, uint16_t disc_v4_port) : peer_urls_(std::move(peer_urls)), with_dynamic_discovery_(with_dynamic_discovery), data_dir_path_(std::move(data_dir_path)), node_id_([node_key] { return node_key().public_key(); }), network_id_(network_id), node_db_(executor_pool.any_executor()), bootnodes_(std::move(bootnodes)), disc_v4_discovery_(executor_pool.any_executor(), disc_v4_port, node_key, std::move(node_url), std::move(node_record), node_db_.interface()) { } Task DiscoveryImpl::run() { setup_node_db(); auto local_node_id = node_id_(); for (auto& url : peer_urls_) { auto& node_id = url.public_key(); if (node_id == local_node_id) { SILK_WARN_M("sentry") << "Discovery: ignoring the local node in the static peers list, please remove " << url.to_string(); continue; } auto& db = node_db_.interface(); co_await db.upsert_node_address( node_id, NodeAddress{url.ip(), url.port_disc(), url.port_rlpx()}); co_await db.update_distance(node_id, disc_v4::node_distance(node_id, local_node_id)); if (!with_dynamic_discovery_) { co_await db.update_last_pong_time(node_id, std::chrono::system_clock::now() + std::chrono::years(1)); } } if (with_dynamic_discovery_) { std::span bootnode_urls{bootnodes_.data(), bootnodes_.size()}; if (bootnode_urls.empty()) { bootnode_urls = bootnodes(network_id_); } for (auto& url : bootnode_urls) { auto& node_id = url.public_key(); if (node_id == local_node_id) { SILK_WARN_M("sentry") << "Discovery: ignoring the local node in the bootnodes list, please remove " << url.to_string(); continue; } auto& db = node_db_.interface(); co_await db.upsert_node_address( node_id, NodeAddress{url.ip(), url.port_disc(), url.port_rlpx()}); co_await db.update_distance(node_id, disc_v4::node_distance(node_id, local_node_id)); } } if (with_dynamic_discovery_) { co_await disc_v4_discovery_.run(); } } void DiscoveryImpl::setup_node_db() { DataDirectory data_dir{data_dir_path_, true}; node_db_.setup(data_dir.nodes().path()); } Task> DiscoveryImpl::request_peer_candidates( size_t max_count, std::vector exclude_urls) { using namespace std::chrono_literals; std::vector exclude_ids; exclude_ids.reserve(exclude_urls.size()); for (auto& url : exclude_urls) { exclude_ids.push_back(url.public_key()); } auto now = std::chrono::system_clock::now(); node_db::NodeDb::FindPeerCandidatesQuery query{ /* min_pong_time = */ disc_v4::ping::min_valid_pong_time(now), /* max_peer_disconnected_time = */ now - 60s, /* max_taken_time = */ now - 30s, std::move(exclude_ids), max_count, }; auto peer_ids = co_await node_db_.interface().take_peer_candidates(std::move(query), now); std::vector candidates; for (auto& peer_id : peer_ids) { auto address = co_await node_db_.interface().find_node_address(peer_id); if (address) { auto eth1_fork_id_data = co_await node_db_.interface().find_eth1_fork_id(peer_id); EnodeUrl peer_url{ peer_id, address->ip, address->port_disc, address->port_rlpx, }; Discovery::PeerCandidate candidate{ std::move(peer_url), std::move(eth1_fork_id_data), }; candidates.push_back(std::move(candidate)); } } if (candidates.empty()) { disc_v4_discovery_.discover_more_needed(); } co_return candidates; } bool DiscoveryImpl::is_static_peer_url(const EnodeUrl& peer_url) { return std::any_of(peer_urls_.cbegin(), peer_urls_.cend(), [&peer_url](const EnodeUrl& it) { return it == peer_url; }); } Task DiscoveryImpl::on_peer_useless(EccPublicKey peer_public_key) { co_await node_db_.interface().update_peer_is_useless(peer_public_key, true); } Task DiscoveryImpl::on_peer_disconnected(EccPublicKey peer_public_key) { auto now = std::chrono::system_clock::now(); co_await node_db_.interface().update_peer_disconnected_time(peer_public_key, now); } Discovery::Discovery( concurrency::ExecutorPool& executor_pool, std::vector peer_urls, bool with_dynamic_discovery, const std::filesystem::path& data_dir_path, uint64_t network_id, std::function node_key, std::function node_url, std::function node_record, std::vector bootnodes, uint16_t disc_v4_port) : p_impl_(std::make_unique( executor_pool, std::move(peer_urls), with_dynamic_discovery, data_dir_path, network_id, std::move(node_key), std::move(node_url), std::move(node_record), std::move(bootnodes), disc_v4_port)) {} Discovery::~Discovery() { SILK_TRACE_M("sentry") << "silkworm::sentry::discovery::Discovery::~Discovery"; } Task Discovery::run() { try { return p_impl_->run(); } catch (const boost::system::system_error& se) { if (se.code() == boost::system::errc::operation_canceled) { SILK_DEBUG_M("sentry") << "Discovery::run unexpected end [operation_canceled]"; } else { SILK_CRIT_M("sentry") << "Discovery::run unexpected end [" + std::string{se.what()} + "]"; } throw se; } } Task> Discovery::request_peer_candidates( size_t max_count, std::vector exclude_urls) { return p_impl_->request_peer_candidates(max_count, std::move(exclude_urls)); } bool Discovery::is_static_peer_url(const EnodeUrl& peer_url) { return p_impl_->is_static_peer_url(peer_url); } Task Discovery::on_peer_useless(EccPublicKey peer_public_key) { return p_impl_->on_peer_useless(std::move(peer_public_key)); } Task Discovery::on_peer_disconnected(EccPublicKey peer_public_key) { return p_impl_->on_peer_disconnected(std::move(peer_public_key)); } } // namespace silkworm::sentry::discovery ================================================ FILE: silkworm/sentry/discovery/discovery.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::sentry::discovery { class DiscoveryImpl; class Discovery { public: explicit Discovery( concurrency::ExecutorPool& executor_pool, std::vector peer_urls, bool with_dynamic_discovery, const std::filesystem::path& data_dir_path, uint64_t network_id, std::function node_key, std::function node_url, std::function node_record, std::vector bootnodes, uint16_t disc_v4_port); ~Discovery(); Discovery(const Discovery&) = delete; Discovery& operator=(const Discovery&) = delete; Task run(); struct PeerCandidate { EnodeUrl url; std::optional eth1_fork_id_data; }; Task> request_peer_candidates( size_t max_count, std::vector exclude_urls); bool is_static_peer_url(const EnodeUrl& peer_url); Task on_peer_useless(EccPublicKey peer_public_key); Task on_peer_disconnected(EccPublicKey peer_public_key); private: std::unique_ptr p_impl_; }; } // namespace silkworm::sentry::discovery ================================================ FILE: silkworm/sentry/discovery/enr/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") silkworm_library( silkworm_sentry_discovery_enr PUBLIC silkworm_sentry_common silkworm_core silkworm_sentry_discovery_common PRIVATE cpp_base64 silkworm_infra ) ================================================ FILE: silkworm/sentry/discovery/enr/enr_codec.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enr_codec.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include namespace silkworm::sentry::discovery::enr { static Bytes decode_rlp_bytes(rlp::RlpByteView data, const char* key) { ByteView from = data.data; Bytes value; auto result = rlp::decode(from, value); if (!result) throw DecodingException(result.error(), std::string("EnrCodec: failed to decode ") + key); return value; } static rlp::RlpBytes encode_rlp_bytes(ByteView bytes) { Bytes data; rlp::encode(data, bytes); return rlp::RlpBytes{std::move(data)}; } template static T decode_rlp_num_value(rlp::RlpByteView data, const char* key) { ByteView from = data.data; T value; auto result = rlp::decode(from, value); if (!result) throw DecodingException(result.error(), std::string("EnrCodec: failed to decode ") + key); return value; } template static rlp::RlpBytes encode_rlp_num_value(T value) { Bytes data; rlp::encode(data, value); return rlp::RlpBytes{std::move(data)}; } static rlp::RlpBytes string_to_rlp_bytes(std::string_view s) { return encode_rlp_bytes(ByteView{reinterpret_cast(s.data()), s.size()}); } template static std::optional map_get(const std::map& entries, const TKey& key) { return (entries.count(key) > 0) ? std::optional{entries.at(key)} : std::nullopt; } static std::optional copy_rlp_data(std::optional data) { return data ? std::optional{Bytes{data->data}} : std::nullopt; } static std::optional try_decode_node_address( const std::map& entries_data, const char* ip_key, const char* port_disc_key, const char* port_rlpx_key) { if (!entries_data.contains(ip_key) || !entries_data.contains(port_disc_key)) return std::nullopt; auto ip = ip_address_from_bytes(decode_rlp_bytes(entries_data.at(ip_key), ip_key)); if (!ip) throw std::runtime_error("EnrCodec: invalid IP address"); auto port_disc = decode_rlp_num_value(entries_data.at(port_disc_key), port_disc_key); uint16_t port_rlpx = 0; if (entries_data.contains(port_rlpx_key)) { port_rlpx = decode_rlp_num_value(entries_data.at(port_rlpx_key), port_rlpx_key); } return NodeAddress{ *ip, port_disc, port_rlpx, }; } static bool is_valid_signature(const std::vector& items, const EccPublicKey& public_key) { if (items.empty()) return false; Bytes signature = decode_rlp_bytes(items[0], "signature"); std::span content_items{items.begin() + 1, items.size() - 1}; Bytes content; rlp::encode(content, content_items); auto content_hash = keccak256(content); return crypto::ecdsa_signature::verify(ByteView{content_hash.bytes}, signature, public_key); } static Bytes sign(const std::vector& items, ByteView private_key) { if (items.empty()) return Bytes{}; std::span content_items{items.begin() + 1, items.size() - 1}; Bytes content; rlp::encode(content, content_items); auto content_hash = keccak256(content); return crypto::ecdsa_signature::sign(ByteView{content_hash.bytes}, private_key); } EnrRecord EnrCodec::decode(ByteView data) { std::vector items; auto decode_result = rlp::decode(data, items, rlp::Leftover::kAllow); if (!decode_result) throw DecodingException(decode_result.error(), "EnrCodec: failed to decode RLP"); if (items.size() < 6) throw std::runtime_error("EnrCodec: not enough RLP list items"); if (items.size() % 2) items.pop_back(); auto& seq_num_data = items[1]; auto seq_num = decode_rlp_num_value(seq_num_data, "seq_num"); std::map entries_data; for (size_t i = 2; i < items.size(); i += 2) { auto key_data = decode_rlp_bytes(items[i], "key"); std::string key{reinterpret_cast(key_data.data()), key_data.size()}; entries_data.emplace(key, items[i + 1]); } if (!entries_data.contains("id")) throw std::runtime_error("EnrCodec: missing required 'id' key"); if (decode_rlp_bytes(entries_data.at("id"), "id") != Bytes{'v', '4'}) throw std::runtime_error("EnrCodec: unsupported ID scheme"); if (!entries_data.contains("secp256k1")) throw std::runtime_error("EnrCodec: missing required 'secp256k1' key"); auto public_key = EccPublicKey::deserialize_std(decode_rlp_bytes(entries_data.at("secp256k1"), "secp256k1")); if (!is_valid_signature(items, public_key)) throw std::runtime_error("EnrCodec: invalid signature"); auto node_address_v4 = try_decode_node_address(entries_data, "ip", "udp", "tcp"); auto node_address_v6 = try_decode_node_address(entries_data, "ip6", "udp6", "tcp6"); return EnrRecord{ std::move(public_key), seq_num, std::move(node_address_v4), std::move(node_address_v6), copy_rlp_data(map_get(entries_data, std::string("eth"))), copy_rlp_data(map_get(entries_data, std::string("eth2"))), copy_rlp_data(map_get(entries_data, std::string("attnets"))), }; } Bytes EnrCodec::encode(const EnrRecord& record, const EccKeyPair& key_pair) { std::map entries; entries.emplace("id", string_to_rlp_bytes("v4")); entries.emplace("secp256k1", encode_rlp_bytes(key_pair.public_key().serialized_std(/* is_compressed = */ true))); if (record.address_v4) { entries.emplace("ip", encode_rlp_bytes(ip_address_to_bytes(record.address_v4->endpoint.address()))); entries.emplace("udp", encode_rlp_num_value(record.address_v4->endpoint.port())); if (record.address_v4->port_rlpx) { entries.emplace("tcp", encode_rlp_num_value(record.address_v4->port_rlpx)); } } if (record.address_v6) { entries.emplace("ip6", encode_rlp_bytes(ip_address_to_bytes(record.address_v6->endpoint.address()))); entries.emplace("udp6", encode_rlp_num_value(record.address_v6->endpoint.port())); if (record.address_v6->port_rlpx) { entries.emplace("tcp6", encode_rlp_num_value(record.address_v6->port_rlpx)); } } if (record.eth1_fork_id_data) { entries.emplace("eth", rlp::RlpBytes{*record.eth1_fork_id_data}); } if (record.eth2_fork_id_data) { entries.emplace("eth2", rlp::RlpBytes{*record.eth2_fork_id_data}); } if (record.eth2_attestation_subnets_data) { entries.emplace("attnets", rlp::RlpBytes{*record.eth2_attestation_subnets_data}); } std::vector items = { rlp::RlpBytes{Bytes{rlp::kEmptyStringCode}}, // signature placeholder encode_rlp_num_value(record.seq_num), }; for (auto& [key, entry_data] : entries) { items.push_back(string_to_rlp_bytes(key)); items.push_back(std::move(entry_data)); } // set signature Bytes signature = sign(items, key_pair.private_key()); items[0] = encode_rlp_bytes(signature); Bytes data; rlp::encode(data, items); return data; } } // namespace silkworm::sentry::discovery::enr ================================================ FILE: silkworm/sentry/discovery/enr/enr_codec.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include "enr_record.hpp" namespace silkworm::sentry::discovery::enr { struct EnrCodec { static EnrRecord decode(ByteView data); static Bytes encode(const EnrRecord& record, const EccKeyPair& key_pair); }; } // namespace silkworm::sentry::discovery::enr ================================================ FILE: silkworm/sentry/discovery/enr/enr_record.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include namespace silkworm::sentry::discovery::enr { struct EnrRecord { EccPublicKey public_key; uint64_t seq_num; std::optional address_v4; std::optional address_v6; std::optional eth1_fork_id_data; std::optional eth2_fork_id_data; std::optional eth2_attestation_subnets_data; }; } // namespace silkworm::sentry::discovery::enr ================================================ FILE: silkworm/sentry/discovery/enr/enr_url.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enr_url.hpp" #include #include #include "enr_codec.hpp" namespace silkworm::sentry::discovery::enr { EnrRecord EnrUrl::parse(std::string_view url_str) { if (!url_str.starts_with("enr:")) throw std::invalid_argument("Invalid ENR URL format"); auto data_str = base64_decode(url_str.substr(4), /* remove_linebreaks = */ false); ByteView data{reinterpret_cast(data_str.data()), data_str.size()}; return EnrCodec::decode(data); } std::string EnrUrl::make(const EnrRecord& record, const EccKeyPair& key_pair) { Bytes data = EnrCodec::encode(record, key_pair); return "enr:" + base64_encode(data.data(), data.size(), /* url = */ true); } } // namespace silkworm::sentry::discovery::enr ================================================ FILE: silkworm/sentry/discovery/enr/enr_url.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include "enr_record.hpp" namespace silkworm::sentry::discovery::enr { struct EnrUrl { static EnrRecord parse(std::string_view url_str); static std::string make(const EnrRecord& record, const EccKeyPair& key_pair); }; } // namespace silkworm::sentry::discovery::enr ================================================ FILE: silkworm/sentry/discovery/enr/enr_url_test.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "enr_url.hpp" #include #include #include #include #include namespace silkworm::sentry::discovery::enr { static EccKeyPair test_key_pair() { constexpr std::string_view kPrivateKey = "b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291"; return EccKeyPair{from_hex(kPrivateKey).value()}; } using namespace boost::asio::ip; TEST_CASE("EnrUrl::parse") { { auto record = EnrUrl::parse("enr:-IS4QHCYrYZbAKWCBRlAy5zzaDZXJBGkcnh4MHcBFZntXNFrdvJjX04jRzjzCBOonrkTfj499SZuOh8R33Ls8RRcy5wBgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQPKY0yuDUmstAHYpMa2_oxVtw0RW_QAdpzBQA8yWM0xOIN1ZHCCdl8"); CHECK(to_hex(record.public_key.serialized_std(/* is_compressed = */ true)) == "03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138"); CHECK(record.seq_num == 1); REQUIRE(record.address_v4.has_value()); CHECK(record.address_v4->endpoint.address().to_string() == "127.0.0.1"); CHECK(record.address_v4->endpoint.port() == 30303); CHECK(record.address_v4->port_rlpx == 0); CHECK_FALSE(record.address_v6.has_value()); } { auto record = EnrUrl::parse("enr:-Ku4QHqVeJ8PPICcWk1vSn_XcSkjOkNiTg6Fmii5j6vUQgvzMc9L1goFnLKgXqBJspJjIsB91LTOleFmyWWrFVATGngBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhAMRHkWJc2VjcDI1NmsxoQKLVXFOhp2uX6jeT0DvvDpPcU8FWMjQdR4wMuORMhpX24N1ZHCCIyg"); CHECK(record.seq_num == 1); REQUIRE(record.address_v4.has_value()); CHECK(record.address_v4->endpoint.address().to_string() == "3.17.30.69"); CHECK(record.address_v4->endpoint.port() == 9000); } { auto record = EnrUrl::parse("enr:-Ku4QImhMc1z8yCiNJ1TyUxdcfNucje3BGwEHzodEZUan8PherEo4sF7pPHPSIB1NNuSg5fZy7qFsjmUKs2ea1Whi0EBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpD1pf1CAAAAAP__________gmlkgnY0gmlwhBLf22SJc2VjcDI1NmsxoQOVphkDqal4QzPMksc5wnpuC3gvSC8AfbFOnZY_On34wIN1ZHCCIyg"); CHECK(record.seq_num == 1); REQUIRE(record.address_v4.has_value()); CHECK(record.address_v4->endpoint.address().to_string() == "18.223.219.100"); CHECK(record.address_v4->endpoint.port() == 9000); } } TEST_CASE("EnrUrl::encode_decode") { EccKeyPair key_pair = test_key_pair(); EnrRecord expected_record{ key_pair.public_key(), 123, NodeAddress{make_address("10.0.0.1"), 100, 101}, NodeAddress{make_address("fe80::40b6:ef45:4458:7fcf"), 200, 201}, Bytes{0x83, 'e', '1', 'f'}, Bytes{0x83, 'e', '2', 'f'}, Bytes{0x83, 'a', 't', 'n'}, }; auto actual_record = EnrUrl::parse(EnrUrl::make(expected_record, key_pair)); CHECK(actual_record.public_key == expected_record.public_key); CHECK(actual_record.seq_num == expected_record.seq_num); REQUIRE(expected_record.address_v4.has_value()); CHECK(actual_record.address_v4->endpoint == expected_record.address_v4->endpoint); CHECK(actual_record.address_v4->port_rlpx == expected_record.address_v4->port_rlpx); REQUIRE(expected_record.address_v6.has_value()); CHECK(actual_record.address_v6->endpoint == expected_record.address_v6->endpoint); CHECK(actual_record.address_v6->port_rlpx == expected_record.address_v6->port_rlpx); CHECK(actual_record.eth1_fork_id_data == expected_record.eth1_fork_id_data); CHECK(actual_record.eth2_fork_id_data == expected_record.eth2_fork_id_data); CHECK(actual_record.eth2_attestation_subnets_data == expected_record.eth2_attestation_subnets_data); } } // namespace silkworm::sentry::discovery::enr ================================================ FILE: silkworm/sentry/discovery/node_db/CMakeLists.txt ================================================ # Copyright 2025 The Silkworm Authors # SPDX-License-Identifier: Apache-2.0 find_package(Boost REQUIRED COMPONENTS headers) find_package(SQLiteCpp REQUIRED) include("${SILKWORM_MAIN_DIR}/cmake/common/targets.cmake") silkworm_library( silkworm_sentry_node_db PUBLIC silkworm_core silkworm_infra silkworm_sentry_common silkworm_sentry_discovery_common PRIVATE Boost::headers SQLiteCpp ) target_link_libraries(silkworm_sentry_node_db_test INTERFACE silkworm_infra_test_util) ================================================ FILE: silkworm/sentry/discovery/node_db/node_db.hpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace silkworm::sentry::discovery::node_db { using NodeId = EccPublicKey; using Time = std::chrono::time_point; struct NodeAddress { boost::asio::ip::address ip; uint16_t port_disc{}; uint16_t port_rlpx{}; // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) NodeAddress(boost::asio::ip::address ip1) : ip(std::move(ip1)) {} NodeAddress(boost::asio::ip::address ip1, uint16_t port_disc1, uint16_t port_rlpx1) : ip(std::move(ip1)), port_disc(port_disc1), port_rlpx(port_rlpx1) {} // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) NodeAddress(const discovery::NodeAddress& address) : ip(address.endpoint.address()), port_disc(address.endpoint.port()), port_rlpx(address.port_rlpx) {} discovery::NodeAddress to_common_address() const { return {ip, port_disc, port_rlpx}; } }; struct NodeDb { virtual ~NodeDb() = default; virtual Task upsert_node_address(NodeId id, NodeAddress address) = 0; virtual Task> find_node_address_v4(NodeId id) = 0; virtual Task> find_node_address_v6(NodeId id) = 0; virtual Task> find_node_address(NodeId id) { auto address = co_await find_node_address_v4(id); if (!address) { address = co_await find_node_address_v6(id); } co_return address; } virtual Task update_next_ping_time(NodeId id, Time value) = 0; virtual Task> find_next_ping_time(NodeId id) = 0; virtual Task update_last_pong_time(NodeId id, Time value) = 0; virtual Task> find_last_pong_time(NodeId id) = 0; virtual Task update_ping_fails(NodeId id, size_t value) = 0; virtual Task> find_ping_fails(NodeId id) = 0; virtual Task update_peer_disconnected_time(NodeId id, Time value) = 0; virtual Task> find_peer_disconnected_time(NodeId id) = 0; virtual Task update_peer_is_useless(NodeId id, bool value) = 0; virtual Task> find_peer_is_useless(NodeId id) = 0; virtual Task update_distance(NodeId id, size_t value) = 0; virtual Task> find_distance(NodeId id) = 0; virtual Task update_enr_seq_num(NodeId id, uint64_t value) = 0; virtual Task> find_enr_seq_num(NodeId id) = 0; virtual Task update_eth1_fork_id(NodeId id, std::optional value) = 0; virtual Task> find_eth1_fork_id(NodeId id) = 0; virtual Task> find_ping_candidates(Time time, size_t limit) = 0; virtual Task> find_useful_nodes(Time min_pong_time, size_t limit) = 0; struct FindLookupCandidatesQuery { Time min_pong_time; Time max_lookup_time; size_t limit{}; }; virtual Task> find_lookup_candidates(FindLookupCandidatesQuery query) = 0; virtual Task mark_taken_lookup_candidates(const std::vector& ids, Time time) = 0; virtual Task> take_lookup_candidates(FindLookupCandidatesQuery query, Time time) = 0; struct FindPeerCandidatesQuery { Time min_pong_time; Time max_peer_disconnected_time; Time max_taken_time; std::vector exclude_ids; size_t limit{}; }; virtual Task> find_peer_candidates(FindPeerCandidatesQuery query) = 0; virtual Task mark_taken_peer_candidates(const std::vector& ids, Time time) = 0; virtual Task> take_peer_candidates(FindPeerCandidatesQuery query, Time time) = 0; virtual Task delete_node(NodeId id) = 0; }; } // namespace silkworm::sentry::discovery::node_db ================================================ FILE: silkworm/sentry/discovery/node_db/node_db_sqlite.cpp ================================================ // Copyright 2025 The Silkworm Authors // SPDX-License-Identifier: Apache-2.0 #include "node_db_sqlite.hpp" #include #include #include #include #include #include #include #include #include "serial_node_db.hpp" namespace silkworm::sentry::discovery::node_db { static constexpr std::string_view kSqlCreateSchema = R"sql( PRAGMA journal_mode = WAL; CREATE TABLE IF NOT EXISTS nodes ( id TEXT PRIMARY KEY, ip TEXT, port_disc INTEGER, port_rlpx INTEGER, ip_v6 TEXT, ip_v6_port_disc INTEGER, ip_v6_port_rlpx INTEGER, next_ping_time INTEGER, last_pong_time INTEGER, ping_fails INTEGER NOT NULL DEFAULT 0, lookup_time INTEGER, peer_disconnected_time INTEGER, peer_is_useless INTEGER, taken_time INTEGER, enr_seq_num INTEGER, eth1_fork_id BLOB, distance INTEGER NON NULL DEFAULT 256 ); CREATE INDEX IF NOT EXISTS idx_nodes_ip ON nodes (ip); CREATE INDEX IF NOT EXISTS idx_nodes_ip_v6 ON nodes (ip_v6); CREATE INDEX IF NOT EXISTS idx_next_ping_time ON nodes (next_ping_time); CREATE INDEX IF NOT EXISTS idx_last_pong_time ON nodes (last_pong_time); CREATE INDEX IF NOT EXISTS idx_lookup_time ON nodes (lookup_time); CREATE INDEX IF NOT EXISTS idx_peer_disconnected_time ON nodes (peer_disconnected_time); CREATE INDEX IF NOT EXISTS idx_peer_is_useless ON nodes (peer_is_useless); CREATE INDEX IF NOT EXISTS idx_taken_time ON nodes (taken_time); CREATE INDEX IF NOT EXISTS idx_distance ON nodes (distance); )sql"; /** * Replaces `placeholder` in `sql` with `count` comma-separated question marks, e.g.: "?,?,?" * If `count` is zero, `placeholder` is replaced with an `empty_value`. */ static std::string replace_placeholders( std::string_view sql_template, std::string_view placeholder, size_t count, std::string_view empty_value) { std::string placeholders; if (count > 0) { std::ostringstream placeholders_stream; std::fill_n(std::ostream_iterator(placeholders_stream), count, "?,"); placeholders = placeholders_stream.str(); placeholders.pop_back(); // remove the last comma } else { placeholders = empty_value; } std::string sql{sql_template}; sql.replace(sql.find(placeholder), placeholder.size(), placeholders); return sql; } class NodeDbSqliteImpl : public NodeDb { public: NodeDbSqliteImpl() = default; ~NodeDbSqliteImpl() override = default; void setup(const std::filesystem::path& db_dir_path) { db_ = std::make_unique( db_dir_path / "nodes.sqlite", SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE); db_->exec(std::string{kSqlCreateSchema}); } void setup_in_memory() { db_ = std::make_unique( ":memory:", SQLite::OPEN_READWRITE | SQLite::OPEN_MEMORY); db_->exec(std::string{kSqlCreateSchema}); } Task upsert_node_address(NodeId id, NodeAddress address) override { static constexpr std::string_view kSqlIpV4 = R"sql( INSERT INTO nodes( id, ip, port_disc, port_rlpx ) VALUES (?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET ip = excluded.ip, port_disc = excluded.port_disc, port_rlpx = excluded.port_rlpx )sql"; static constexpr std::string_view kSqlIpV6 = R"sql( INSERT INTO nodes( id, ip_v6, ip_v6_port_disc, ip_v6_port_rlpx ) VALUES (?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET ip_v6 = excluded.ip_v6, ip_v6_port_disc = excluded.ip_v6_port_disc, ip_v6_port_rlpx = excluded.ip_v6_port_rlpx )sql"; static constexpr std::string_view kExistsSql = R"sql( SELECT 1 FROM nodes WHERE id = ? )sql"; SQLite::Statement exists_query{*db_, std::string{kExistsSql}}; exists_query.bind(1, id.hex()); std::string sql; if (address.ip.is_v4()) { sql = kSqlIpV4; } if (address.ip.is_v6()) { sql = kSqlIpV6; } SILKWORM_ASSERT(!sql.empty()); if (sql.empty()) { throw std::runtime_error("NodeDbSqliteImpl.upsert_node_address: unexpected ip type"); } SQLite::Statement statement{*db_, sql}; statement.bind(1, id.hex()); statement.bind(2, address.ip.to_string()); if (address.port_disc > 0) statement.bind(3, address.port_disc); if (address.port_rlpx > 0) statement.bind(4, address.port_rlpx); SQLite::Transaction transaction{*db_}; bool exists = exists_query.executeStep(); statement.exec(); transaction.commit(); co_return !exists; } Task> find_node_address_sql(NodeId id, std::string_view sql) { SQLite::Statement query{*db_, std::string{sql}}; query.bind(1, id.hex()); if (!query.executeStep()) { co_return std::nullopt; } if (query.isColumnNull(0)) { co_return std::nullopt; } std::string ip_str = query.getColumn(0); auto ip = boost::asio::ip::make_address(ip_str); NodeAddress address{std::move(ip)}; if (!query.isColumnNull(1)) address.port_disc = query.getColumn(1); if (!query.isColumnNull(2)) address.port_rlpx = query.getColumn(2); co_return address; } Task> find_node_address_v4(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT ip, port_disc, port_rlpx FROM nodes WHERE id = ? )sql"; return find_node_address_sql(id, kSql); } Task> find_node_address_v6(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT ip_v6, ip_v6_port_disc, ip_v6_port_rlpx FROM nodes WHERE id = ? )sql"; return find_node_address_sql(id, kSql); } Task update_next_ping_time(NodeId id, Time value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET next_ping_time = ? WHERE id = ? )sql"; set_node_property_time(id, kSql, value); co_return; } Task> find_next_ping_time(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT next_ping_time FROM nodes WHERE id = ? )sql"; co_return get_node_property_time(id, kSql); } Task update_last_pong_time(NodeId id, Time value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET last_pong_time = ? WHERE id = ? )sql"; set_node_property_time(id, kSql, value); co_return; } Task> find_last_pong_time(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT last_pong_time FROM nodes WHERE id = ? )sql"; co_return get_node_property_time(id, kSql); } Task update_ping_fails(NodeId id, size_t value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET ping_fails = ? WHERE id = ? )sql"; set_node_property_int(id, kSql, static_cast(value)); co_return; } Task> find_ping_fails(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT ping_fails FROM nodes WHERE id = ? )sql"; auto value = get_node_property_int(id, kSql); if (value) { co_return static_cast(*value); } else { co_return std::nullopt; } } Task update_peer_disconnected_time(NodeId id, Time value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET peer_disconnected_time = ? WHERE id = ? )sql"; set_node_property_time(id, kSql, value); co_return; } Task> find_peer_disconnected_time(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT peer_disconnected_time FROM nodes WHERE id = ? )sql"; co_return get_node_property_time(id, kSql); } Task update_peer_is_useless(NodeId id, bool value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET peer_is_useless = ? WHERE id = ? )sql"; set_node_property_int(id, kSql, value ? 1 : 0); co_return; } Task> find_peer_is_useless(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT peer_is_useless FROM nodes WHERE id = ? )sql"; auto value = get_node_property_int(id, kSql); if (value) { co_return *value; } else { co_return std::nullopt; } } Task update_distance(NodeId id, size_t value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET distance = ? WHERE id = ? )sql"; set_node_property_int(id, kSql, static_cast(value)); co_return; } Task> find_distance(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT distance FROM nodes WHERE id = ? )sql"; auto value = get_node_property_int(id, kSql); if (value) { co_return static_cast(*value); } else { co_return std::nullopt; } } Task update_enr_seq_num(NodeId id, uint64_t value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET enr_seq_num = ? WHERE id = ? )sql"; set_node_property_int(id, kSql, static_cast(value)); co_return; } Task> find_enr_seq_num(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT enr_seq_num FROM nodes WHERE id = ? )sql"; auto value = get_node_property_int(id, kSql); if (value) { co_return static_cast(*value); } else { co_return std::nullopt; } } Task update_eth1_fork_id(NodeId id, std::optional value) override { static constexpr std::string_view kSql = R"sql( UPDATE nodes SET eth1_fork_id = ? WHERE id = ? )sql"; SQLite::Statement statement{*db_, std::string{kSql}}; if (value) { statement.bindNoCopy(1, value->data(), static_cast(value->size())); } else { statement.bind(1); } statement.bind(2, id.hex()); statement.exec(); co_return; } Task> find_eth1_fork_id(NodeId id) override { static constexpr std::string_view kSql = R"sql( SELECT eth1_fork_id FROM nodes WHERE id = ? )sql"; SQLite::Statement query{*db_, std::string{kSql}}; query.bind(1, id.hex()); if (!query.executeStep()) { co_return std::nullopt; } if (query.isColumnNull(0)) { co_return std::nullopt; } Bytes value{ static_cast(query.getColumn(0).getBlob()), static_cast(query.getColumn(0).size()), }; co_return std::move(value); } Task> find_ping_candidates(Time time, size_t limit) override { static constexpr std::string_view kSql = R"sql( SELECT id FROM nodes WHERE ((next_ping_time IS NULL) OR (next_ping_time < ?)) AND ((peer_is_useless IS NULL) OR (peer_is_useless == 0)) ORDER BY next_ping_time LIMIT ? )sql"; SQLite::Statement query{*db_, std::string{kSql}}; query.bind(1, static_cast(unix_timestamp_from_time_point(time))); query.bind(2, static_cast(limit)); std::vector ids; while (query.executeStep()) { std::string id_hex = query.getColumn(0); auto id = EccPublicKey::deserialize_hex(id_hex); ids.push_back(std::move(id)); } co_return ids; } Task> find_useful_nodes(Time min_pong_time, size_t limit) override { static constexpr std::string_view kSql = R"sql( SELECT id FROM nodes WHERE ((last_pong_time IS NOT NULL) AND (last_pong_time > ?)) AND ((peer_is_useless IS NULL) OR (peer_is_useless == 0)) ORDER BY RANDOM() LIMIT ? )sql"; SQLite::Statement query{*db_, std::string{kSql}}; query.bind(1, static_cast(unix_timestamp_from_time_point(min_pong_time))); query.bind(2, static_cast(limit)); std::vector ids; while (query.executeStep()) { std::string id_hex = query.getColumn(0); auto id = EccPublicKey::deserialize_hex(id_hex); ids.push_back(std::move(id)); } co_return ids; } Task> find_lookup_candidates(FindLookupCandidatesQuery query_params) override { static constexpr std::string_view kSql = R"sql( SELECT id FROM nodes WHERE ((last_pong_time IS NOT NULL) AND (last_pong_time > ?)) AND ((peer_is_useless IS NULL) OR (peer_is_useless == 0)) AND ((lookup_time IS NULL) OR (lookup_time < ?)) ORDER BY distance, lookup_time LIMIT ? )sql"; SQLite::Statement query{*db_, std::string{kSql}}; query.bind(1, static_cast(unix_timestamp_from_time_point(query_params.min_pong_time))); query.bind(2, static_cast(unix_timestamp_from_time_point(query_params.max_lookup_time))); query.bind(3, static_cast(query_params.limit)); std::vector ids; while (query.executeStep()) { std::string id_hex = query.getColumn(0); auto id = EccPublicKey::deserialize_hex(id_hex); ids.push_back(std::move(id)); } co_return ids; } Task mark_taken_lookup_candidates(const std::vector& ids, Time time) override { if (ids.empty()) co_return; static constexpr std::string_view kSqlTemplate = R"sql( UPDATE nodes SET lookup_time = ? WHERE id IN (???) )sql"; auto sql = replace_placeholders(kSqlTemplate, "???", ids.size(), "NULL"); SQLite::Statement statement{*db_, sql}; statement.bind(1, static_cast(unix_timestamp_from_time_point(time))); for (size_t i = 0; i < ids.size(); ++i) { statement.bind(static_cast(i + 2), ids[i].hex()); } statement.exec(); co_return; } Task> take_lookup_candidates(FindLookupCandidatesQuery query, Time time) override { SQLite::Transaction transaction{*db_}; auto candidates = co_await find_lookup_candidates(query); co_await mark_taken_lookup_candidates(candidates, time); transaction.commit(); co_return candidates; } Task> find_peer_candidates(FindPeerCandidatesQuery query_params) override { static constexpr std::string_view kSqlTemplate = R"sql( SELECT id FROM nodes WHERE ((last_pong_time IS NOT NULL) AND (last_pong_time > ?)) AND ((peer_disconnected_time IS NULL) OR (peer_disconnected_time < ?)) AND ((peer_is_useless IS NULL) OR (peer_is_useless == 0)) AND ((taken_time IS NULL) OR (taken_time < ?)) AND (id NOT IN (???)) ORDER BY distance, RANDOM() LIMIT :limit )sql"; auto sql = replace_placeholders(kSqlTemplate, "???", query_params.exclude_ids.size(), "''"); SQLite::Statement query{*db_, sql}; query.bind(1, static_cast(unix_timestamp_from_time_point(query_params.min_pong_time))); query.bind(2, static_cast(unix_timestamp_from_time_point(query_params.max_peer_disconnected_time))); query.bind(3, static_cast(unix_timestamp_from_time_point(query_params.max_taken_time))); for (size_t i = 0; i < query_params.exclude_ids.size(); ++i) { query.bind(static_cast(i + 4), query_params.exclude_ids[i].hex()); } query.bind(":limit", static_cast(query_params.limit)); std::vector ids; while (query.executeStep()) { std::string id_hex = query.getColumn(0); auto id = EccPublicKey::deserialize_hex(id_hex); ids.push_back(std::move(id)); } co_return ids; } Task mark_taken_peer_candidates(const std::vector& ids, Time time) override { if (ids.empty()) co_return; static constexpr std::string_view kSqlTemplate = R"sql( UPDATE nodes SET taken_time = ? WHERE id IN (???) )sql"; auto sql = replace_placeholders(kSqlTemplate, "???", ids.size(), "NULL"); SQLite::Statement statement{*db_, sql}; statement.bind(1, static_cast(unix_timestamp_from_time_point(time))); for (size_t i = 0; i < ids.size(); ++i) { statement.bind(static_cast(i + 2), ids[i].hex()); } statement.exec(); co_return; } Task> take_peer_candidates(FindPeerCandidatesQuery query, Time time) override { SQLite::Transaction transaction{*db_}; auto candidates = co_await find_peer_candidates(std::move(query)); co_await mark_taken_peer_candidates(candidates, time); transaction.commit(); co_return candidates; } Task delete_node(NodeId id) override { static constexpr std::string_view kSql = R"sql( DELETE FROM nodes WHERE id = ? )sql"; SQLite::Statement statement{*db_, std::string{kSql}}; statement.bind(1, id.hex()); statement.exec(); co_return; } private: std::optional get_node_property_int(const NodeId& id, std::string_view sql) { SQLite::Statement query{*db_, std::string{sql}}; query.bind(1, id.hex()); if (!query.executeStep()) { return std::nullopt; } if (query.isColumnNull(0)) { return std::nullopt; } int64_t value = query.getColumn(0); return {value}; } void set_node_property_int(const NodeId& id, std::string_view sql, int64_t value) { SQLite::Statement statement{*db_, std::string{sql}}; statement.bind(1, value); statement.bind(2, id.hex()); statement.exec(); } std::optional